text stringlengths 12 1.05M | repo_name stringlengths 5 86 | path stringlengths 4 191 | language stringclasses 1 value | license stringclasses 15 values | size int32 12 1.05M | keyword listlengths 1 23 | text_hash stringlengths 64 64 |
|---|---|---|---|---|---|---|---|
# coding=utf-8
# Copyright 2022 The Google Research Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# Copyright 2022 The Google Research Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# Lint as: python3
"""A parser for Small Molecule Universe (SMU) files in custom Uni Basel format.
Used to read contents from SMU files and populates a corresponding protocol
buffer.
"""
import bz2
import collections
import enum
import math
import re
import traceback
from absl import logging
import numpy as np
from smu import dataset_pb2
from smu.parser import smu_utils_lib
# Number of items in BOND entry.
NUM_ITEMS_IN_BOND_ENTRY = 5
# We distinguish between the initial (cheap) coordinates and the optimized ones.
VALID_COORDINATE_LABELS = ['Initial Coords', 'Optimized Coords']
# Encoding order for quadru- and octopole moments.
RANK2_ENCODING_ORDER = ['xx', 'yy', 'zz', 'xy', 'xz', 'yz']
RANK3_ENCODING_ORDER = [
'xxx', 'yyy', 'zzz', 'xxy', 'xxz', 'xyy', 'yyz', 'xzz', 'yzz', 'xyz'
]
SEPARATOR_LINE = '=' * 80
EXCITATION_HEADER = ('Excitation energies and length rep. osc. strengths at '
'CC2/TZVP')
# All the possible single value properties and their associated fields
PROPERTIES_LABEL_FIELDS = collections.OrderedDict([
['PBE0D3/6-311Gd', 'single_point_energy_pbe0d3_6_311gd'],
['PBE0/6-311Gd', 'single_point_energy_pbe0_6_311gd'],
['PBE0/6-311GdMRCC', 'single_point_energy_pbe0_6_311gd_mrcc'],
['PBE0/6-311GdORCA', 'single_point_energy_pbe0_6_311gd_orca'],
['PBE0/6-311Gd(CAT)', 'single_point_energy_pbe0_6_311gd_cat'],
['PBE0/6-311Gd(CAT)MRCC', 'single_point_energy_pbe0_6_311gd_cat_mrcc'],
['PBE0/6-311Gd(CAT)ORCA', 'single_point_energy_pbe0_6_311gd_cat_orca'],
['PBE0/aug-pc-1', 'single_point_energy_pbe0_aug_pc_1'],
['HF/6-31Gd', 'single_point_energy_hf_6_31gd'],
['B3LYP/6-31++Gdp', 'single_point_energy_b3lyp_6_31ppgdp'],
['B3LYP/aug-pcS-1', 'single_point_energy_b3lyp_aug_pcs_1'],
['PBE0/6-31++Gdp', 'single_point_energy_pbe0_6_31ppgdp'],
['PBE0/aug-pcS-1', 'single_point_energy_pbe0_aug_pcs_1'],
['HF/TZVP', 'single_point_energy_hf_tzvp'],
['MP2/TZVP', 'single_point_energy_mp2_tzvp'],
['CC2/TZVP', 'single_point_energy_cc2_tzvp'],
['HF/3', 'single_point_energy_hf_3'],
['MP2/3', 'single_point_energy_mp2_3'],
['HF/4', 'single_point_energy_hf_4'],
['MP2/4', 'single_point_energy_mp2_4'],
['HF/(34)', 'single_point_energy_hf_34'],
['MP2/(34)', 'single_point_energy_mp2_34'],
['HF/CVTZ', 'single_point_energy_hf_cvtz'],
['MP2ful/CVTZ', 'single_point_energy_mp2ful_cvtz'],
['HF/2sp', 'single_point_energy_hf_2sp'],
['MP2/2sp', 'single_point_energy_mp2_2sp'],
['CCSD/2sp', 'single_point_energy_ccsd_2sp'],
['CCSD(T)/2sp', 'single_point_energy_ccsd_t_2sp'],
['HF/2sd', 'single_point_energy_hf_2sd'],
['MP2/2sd', 'single_point_energy_mp2_2sd'],
['CCSD/2sd', 'single_point_energy_ccsd_2sd'],
['CCSD(T)/2sd', 'single_point_energy_ccsd_t_2sd'],
['HF/3Psd', 'single_point_energy_hf_3psd'],
['MP2/3Psd', 'single_point_energy_mp2_3psd'],
['CCSD/3Psd', 'single_point_energy_ccsd_3psd'],
['NUCREP', 'nuclear_repulsion_energy'],
['NUM_OPT', 'number_of_optimization_runs'],
['NIMAG', 'number_imaginary_frequencies'],
['ZPE_unscaled', 'zpe_unscaled'],
])
class Atomic2FieldTypes(enum.Enum):
STRING = 1
SCALAR = 2
TRIPLE = 3
ATOMIC_LABEL_FIELDS = collections.OrderedDict([
[
'AT2_BSR_LEFT',
('bond_separation_reaction_left', Atomic2FieldTypes.STRING)
],
[
'AT2_BSR_RIGHT',
('bond_separation_reaction_right', Atomic2FieldTypes.STRING)
],
['AT2_T1mol', ('diagnostics_t1_ccsd_2sd', Atomic2FieldTypes.SCALAR)],
['AT2_T1exc', ('diagnostics_t1_ccsd_2sp_excess', Atomic2FieldTypes.SCALAR)],
['AT2_ZPE', ('zpe_atomic', Atomic2FieldTypes.TRIPLE)],
['AT2_ENE_B5', ('single_point_energy_atomic_b5', Atomic2FieldTypes.SCALAR)],
['AT2_ENE_B6', ('single_point_energy_atomic_b6', Atomic2FieldTypes.SCALAR)],
['AT2_ENE_ECCSD', ('single_point_energy_eccsd', Atomic2FieldTypes.SCALAR)],
[
'AT2_BSE_B5',
('bond_separation_energy_atomic_b5', Atomic2FieldTypes.TRIPLE)
],
[
'AT2_BSE_B6',
('bond_separation_energy_atomic_b6', Atomic2FieldTypes.TRIPLE)
],
[
'AT2_BSE_ECCSD',
('bond_separation_energy_eccsd', Atomic2FieldTypes.TRIPLE)
],
[
'AT2_AEe_B5',
('atomization_energy_excluding_zpe_atomic_b5', Atomic2FieldTypes.TRIPLE)
],
[
'AT2_AEe_B6',
('atomization_energy_excluding_zpe_atomic_b6', Atomic2FieldTypes.TRIPLE)
],
[
'AT2_AEe_ECCSD',
('atomization_energy_excluding_zpe_eccsd', Atomic2FieldTypes.TRIPLE)
],
[
'AT2_AE0_B5',
('atomization_energy_including_zpe_atomic_b5', Atomic2FieldTypes.TRIPLE)
],
[
'AT2_AE0_B6',
('atomization_energy_including_zpe_atomic_b6', Atomic2FieldTypes.TRIPLE)
],
[
'AT2_AE0_ECCSD',
('atomization_energy_including_zpe_eccsd', Atomic2FieldTypes.TRIPLE)
],
[
'AT2_HF0_B5',
('enthalpy_of_formation_0k_atomic_b5', Atomic2FieldTypes.TRIPLE)
],
[
'AT2_HF0_B6',
('enthalpy_of_formation_0k_atomic_b6', Atomic2FieldTypes.TRIPLE)
],
[
'AT2_HF0_ECCSD',
('enthalpy_of_formation_0k_eccsd', Atomic2FieldTypes.TRIPLE)
],
[
'AT2_HF298_B5',
('enthalpy_of_formation_298k_atomic_b5', Atomic2FieldTypes.TRIPLE)
],
[
'AT2_HF298_B6',
('enthalpy_of_formation_298k_atomic_b6', Atomic2FieldTypes.TRIPLE)
],
[
'AT2_HF298_ECCSD',
('enthalpy_of_formation_298k_eccsd', Atomic2FieldTypes.TRIPLE)
],
])
PARTIAL_CHARGES_LABEL_FIELDS = collections.OrderedDict([
['MUL-PBE0/aug-pc-1', 'partial_charges_mulliken_pbe0_aug_pc_1'],
['LOE-PBE0/aug-pc-1', 'partial_charges_loewdin_pbe0_aug_pc_1'],
['NAT-PBE0/aug-pc-1', 'partial_charges_natural_nbo_pbe0_aug_pc_1'],
['PON-PBE0/aug-pc-1', 'partial_charges_paboon_pbe0_aug_pc_1'],
['ESP-PBE0/aug-pc-1', 'partial_charges_esp_fit_pbe0_aug_pc_1'],
['MUL-HF/6-31Gd', 'partial_charges_mulliken_hf_6_31gd'],
['LOE-HF/6-31Gd', 'partial_charges_loewdin_hf_6_31gd'],
['NAT-HF/6-31Gd', 'partial_charges_natural_nbo_hf_6_31gd'],
['PON-HF/6-31Gd', 'partial_charges_paboon_hf_6_31gd'],
['ESP-HF/6-31Gd', 'partial_charges_esp_fit_hf_6_31gd'],
])
NMR_ISOTROPIC_SHIELDINGS_LABEL_FIELDS = collections.OrderedDict([
['B3LYP/6-31++Gdp', 'nmr_isotropic_shielding_b3lyp_6_31ppgdp'],
['B3LYP/aug-pcS-1', 'nmr_isotropic_shielding_b3lyp_aug_pcs_1'],
['PBE0/6-31++Gdp', 'nmr_isotropic_shielding_pbe0_6_31ppgdp'],
['PBE0/aug-pcS-1', 'nmr_isotropic_shielding_pbe0_aug_pcs_1'],
])
# The Gaussian sanity check section is a label with 1 or 2 floats after it.
# These are tuples of the prefix followed by a list of the proto fields from
# GaussianSanityCheck.
GAUSSIAN_SANITY_CHECK_LINES = [
('Dev. Energy PBE0/6-311G*', ['energy_pbe0_6_311gd_diff']),
('Max. Force ', ['max_force']),
('Max. and Avg Dev. Frequencies',
['max_frequencies_diff', 'mean_frequencies_diff']),
('Max. and Avg Dev. Intensities',
['max_intensities_diff', 'mean_intensities_diff']),
('Dev. Energy HF/6-31G* ', ['energy_hf_6_31gd_diff']),
('Max. Dev. Dipole Components', ['max_dipole_components_diff']),
('Max. Dev. Quadrup. Components', ['max_quadropole_components_diff']),
('Max. Dev. Octupole Components', ['max_octopole_components_diff']),
]
class SmuKnownError(Exception):
pass
class SmuBondTypeZeroError(SmuKnownError):
pass
class SmuOverfullFloatFieldError(SmuKnownError):
pass
class ParseModes(enum.Enum):
INITIALIZE = 1
SKIP = 2
KEYVALUE = 3
ALTERNATING = 4
INTERLEAVED = 5
RAW = 6
BYLABEL = 7
SKIP_BLANK_LINES = 8
_LONG_IDENTIFIER_RE = re.compile(r'^x(\d+)_(\w+)\.(\d+)\.(\d+)$')
def parse_long_identifier(identifier):
"""Parses a long style identifier into its components.
Long identifiers look like:
x07_c4o2fh7.618451.001
Args:
identifier: string
Returns:
heavy atom count(int), stoichiometry(string), bond topology id (int),
conformer id (int)
Raises:
ValueError: If the string could not be parsed
"""
match = _LONG_IDENTIFIER_RE.match(identifier)
if not match:
raise ValueError('Could not interpret "{}"'.format(identifier))
return (int(match.group(1)), match.group(2), int(match.group(3)),
int(match.group(4)))
class SmuParser:
"""A class to handle parsing of a single SMU file."""
def __init__(self, input_file):
"""Initialize the parser class.
Args:
input_file: The path to the SMU input file.
"""
self.input_file = input_file
self._raw_contents = None
self._conformer = None
self.line_num = None
def _input_generator(self):
"""Yields lines from from input_file."""
# This import is here to avoid dependency on gfile except while essential.
# This function is the only one that uses gfile.
from tensorflow.io import gfile # pylint: disable=g-import-not-at-top
if not gfile.exists(self.input_file):
raise FileNotFoundError
if self.input_file.endswith('.bz2'):
logging.info('Opening %s as bzip2 file', self.input_file)
with gfile.GFile(self.input_file, 'rb') as compressed_f:
with bz2.BZ2File(compressed_f, 'rb') as f:
for bin_line in f:
yield bin_line.decode('utf-8').rstrip('\n')
else:
logging.info('Opening %s via gfile', self.input_file)
with gfile.GFile(self.input_file, 'r') as f:
for line in f:
yield line.rstrip('\n')
def _read_next_chunk(self, line_generator):
"""Reads a chunk of input from line_generator and sets _raw_contents.
Args:
line_generator: generator for lines of input, from _input_generator()
Returns:
bool on whether we have a next chunk
"""
self._raw_contents = [SEPARATOR_LINE]
self.line_num = 0
try:
line = next(line_generator)
except StopIteration:
return False
# We have to handle the case where the separator line is the first thing
# and where the separator line has already been consumed from the last call
# to _read_next_chunk
if line != SEPARATOR_LINE:
self._raw_contents.append(line)
while True:
try:
line = next(line_generator)
except StopIteration:
return True
if line == SEPARATOR_LINE:
return True
self._raw_contents.append(line)
def _next_line(self):
if self.line_num >= len(self._raw_contents):
return None
return self._raw_contents[self.line_num]
def _next_line_startswith(self, prefix):
"""Whether the next line to parse starts with prefix."""
next_line = self._next_line()
return next_line and next_line.startswith(prefix)
def parse(self, mode, label=None, num_lines=0, allowed_keys=None):
"""Parses a number of lines by using a given mode.
This is the main parsing routine for the Basel SMU file format. It supports
a number of modes to tell the parser how data is stored in the file, which
changes frequently throughout and needs to be specified for each section of
data. The length of each section (in number of lines) has to be specified
as well where available. A mode like 'BYLABEL' can be used to parse sections
of unknown length.
Args:
mode: Mode used for parsing.
label: A label used to identify lines belonging to a section.
num_lines: The number of lines to parse next.
allowed_keys: if mode=KEYVALUE, the list of allowed keys. Only lines
starting with one of these keys will be included up until the first line
that does not split into two values or has a disallowed key, and
num_lines becomes a maximum to consider.'
Returns:
Depending on the mode, the method returns nothing (INITIALIZE, SKIP), a
section of file (RAW, BYLABEL), a dict (KEYVALUE) or a tuple of labels and
values (all others).
"""
first_line = self.line_num
if mode == ParseModes.SKIP_BLANK_LINES:
while (self.line_num < len(self._raw_contents) and
not str(self._raw_contents[self.line_num]).strip()):
self.line_num += 1
return
# If only label is known, determine size of section.
if mode == ParseModes.BYLABEL:
assert label in self._raw_contents[
first_line], 'Label %s not found in line %s.' % (
label, self._raw_contents[first_line])
last_line = first_line + 1
while (last_line < len(self._raw_contents) and
label in self._raw_contents[last_line]):
last_line += 1
num_lines = last_line - first_line
if mode is not ParseModes.INITIALIZE:
message = 'Parser was called with invalid number of lines %d.' % num_lines
assert num_lines > 0, message
last_line = self.line_num + num_lines
section = self._raw_contents[first_line:last_line]
self.line_num += num_lines
if mode == ParseModes.INITIALIZE:
# Resets the line number and returns.
self.line_num = 0
return
elif mode == ParseModes.RAW or mode == ParseModes.BYLABEL:
return section
elif mode == ParseModes.SKIP:
# Skip over a number of lines by updating the index.
return
elif mode == ParseModes.KEYVALUE:
# Lines with simple label-value pairs separated by a delimiter.
out = {}
for line_idx, line in enumerate(section):
splits = line.split()
if len(splits) != 2 or (allowed_keys and splits[0] not in allowed_keys):
# line_num was already advanced. We have to fix it up for the actual
# number of lines consumed.
self.line_num += line_idx - num_lines
return out
out[splits[0]] = splits[1]
return out
elif mode == ParseModes.ALTERNATING:
# Alternating lines, where odd lines contain (a number of) labels and even
# lines contain the corresponding values (one value per label).
labels = [line.strip() for i, line in enumerate(section) if i % 2 == 0]
labels = ' '.join(labels).split()
values = [line for i, line in enumerate(section) if i % 2 == 1]
values = [int(value) for value in ' '.join(values).split()]
return labels, values
elif mode == ParseModes.INTERLEAVED:
# Labels and values are interleaved in whitespace-separated columns. Odd
# columns contain the keys and even columns the corresponding values.
# KEYVALUE is a special case of this with only one pair.
serialized_section = ' '.join(section)
labels = [
label for i, label in enumerate(serialized_section.split())
if i % 2 == 0
]
values = [
value for i, value in enumerate(serialized_section.split()) if i % 2
]
return labels, values
else:
logging.error('Unknown parse mode %s.', mode)
def parse_stage1_header(self):
"""The first line after a divider describes a new conformer."""
header = str(self.parse(ParseModes.RAW, num_lines=1)[0])
vals = header.split()
if len(vals) != 7:
raise ValueError('Stage 1 header line %s invalid, need 7 values.' %
header)
if vals[0] == '*****':
# This is a fortran numeric overflow. We don't actually care about this
# info, so we just drop an invalid value in and regenerate '*****' in the
# writer.
self._conformer.original_conformer_index = -1
else:
self._conformer.original_conformer_index = int(vals[0])
errors = self._conformer.properties.errors
for field, val in zip(smu_utils_lib.STAGE1_ERROR_FIELDS, vals[1:5]):
setattr(errors, field, int(val))
# Note that vals[6] is the molecule identifier which we ignore in favor of
# the "ID" line.
# vals[5] is the number of atoms
return int(vals[5])
def parse_stage2_header(self):
"""The first line after a divider describes a new conformer."""
header = str(self.parse(ParseModes.RAW, num_lines=1)[0])
if len(header.split()) != 3:
raise ValueError(
'Header line %s invalid, need conformer, #atoms, and id.' % header)
conformer_index, num_atoms, unused_identifier = header.split()
if conformer_index == '*****':
# This is a fortran numeric overflow. We don't actually care about this
# info, so we just drop an invalid value in and regenerate '*****' in the
# writer.
self._conformer.original_conformer_index = -1
else:
self._conformer.original_conformer_index = int(conformer_index)
return int(num_atoms)
def parse_database(self):
"""Parse the line indicating what database the conformer should go to.
This line looks like:
Database standard
"""
line = str(self.parse(ParseModes.RAW, num_lines=1)[0])
parts = line.split()
if len(parts) != 2:
raise ValueError('Expected database line, got: {}'.format(line))
if parts[0] != 'Database':
raise ValueError('Bad keyword on database line, got: {}'.format(parts[0]))
if parts[1] == 'standard':
self._conformer.which_database = dataset_pb2.STANDARD
elif parts[1] == 'complete':
self._conformer.which_database = dataset_pb2.COMPLETE
else:
raise ValueError('Expected database indicator, got: {}'.format(parts[1]))
def parse_error_codes(self):
"""Parses the error section with the warning flags."""
lines = iter(self.parse(ParseModes.RAW, num_lines=6))
errors = self._conformer.properties.errors
parts = str(next(lines)).split()
assert (len(parts) == 2 and parts[0]
== 'Status'), ('Expected Status line, got {}'.format(parts))
errors.status = int(parts[1])
parts = str(next(lines)).split()
assert (len(parts) == 3 and parts[0]
== 'Warn_T1'), ('Expected Status line, got {}'.format(parts))
errors.warn_t1 = int(parts[1])
errors.warn_t1_excess = int(parts[2])
parts = str(next(lines)).split()
assert (len(parts) == 3 and parts[0]
== 'Warn_BSE'), ('Expected Status line, got {}'.format(parts))
errors.warn_bse_b5_b6 = int(parts[1])
errors.warn_bse_cccsd_b5 = int(parts[2])
parts = str(next(lines)).split()
assert (len(parts) == 4 and parts[0]
== 'Warn_EXC'), ('Expected Status line, got {}'.format(parts))
errors.warn_exc_lowest_excitation = int(parts[1])
errors.warn_exc_smallest_oscillator = int(parts[2])
errors.warn_exc_largest_oscillator = int(parts[3])
parts = str(next(lines)).split()
assert (len(parts) == 3 and parts[0]
== 'Warn_VIB'), ('Expected Status line, got {}'.format(parts))
errors.warn_vib_linearity = int(parts[1])
errors.warn_vib_imaginary = int(parts[2])
parts = str(next(lines)).split()
assert (len(parts) == 2 and parts[0]
== 'Warn_NEG'), ('Expected Status line, got {}'.format(parts))
errors.warn_num_neg = int(parts[1])
def parse_bond_topology(self):
"""Parse region with adjancy matrix, hydrogen count, smiles, and atom types."""
adjacency_code = str(self.parse(ParseModes.RAW, num_lines=1)[0]).strip()
hydrogen_counts = [
int(count)
for count in str(self.parse(ParseModes.RAW, num_lines=1)[0]).strip()
]
smiles = self.parse(ParseModes.RAW, num_lines=1)[0]
entry_id = str(self.parse(ParseModes.RAW, num_lines=1)[0]).strip()
assert entry_id.startswith('x'), 'Expected line like x02_c2h2'
atom_types = entry_id[4:].lower()
expanded_atom_types = self.expand_atom_types(atom_types)
self._conformer.bond_topologies.add()
self._conformer.bond_topologies[-1].CopyFrom(
smu_utils_lib.create_bond_topology(expanded_atom_types, adjacency_code,
hydrogen_counts))
self._conformer.bond_topologies[-1].smiles = str(smiles).replace(
'\'', '').strip()
def expand_atom_types(self, atom_types):
"""Takes an abbreviated atom composition, such as c4o2fh7, and expands it.
In the provided example, c4o2fh7 will be expanded to ccccoofhhhhhhh. The
sequence is significant, since it determines the order in which atom
coordinates and properties are stored in a SMU file.
Args:
atom_types: A sorted string of atoms in the molecule and their count.
Returns:
The expanded atom types with one letter per atom.
"""
expanded_atom_types = ''
current_type = atom_types[0]
character_count = 0
for i, character in enumerate(atom_types):
if character.isalpha():
if i > 0:
if not character_count:
character_count = 1
expanded_atom_types += current_type * character_count
current_type = character
character_count = 0
else:
character_count = character_count * 10 + int(character)
# Catches the case where the last character has no digits afterward
if not character_count:
character_count = 1
return expanded_atom_types + current_type * character_count
def parse_identifier(self):
"""Extracts and sets the bond topology and conformer identifier."""
line = str(self.parse(ParseModes.RAW, num_lines=1)[0])
id_str, bond_topology_id_str, conformer_id_str = line.split()
assert id_str == 'ID', ('Identifier line should start with "ID", got %s.' %
line)
bond_topology_id = int(bond_topology_id_str)
# Special casing for SMU1. Fun.
if smu_utils_lib.special_case_bt_id_from_dat_id(
bond_topology_id, self._conformer.bond_topologies[-1].smiles):
bond_topology_id = smu_utils_lib.special_case_bt_id_from_dat_id(
bond_topology_id, self._conformer.bond_topologies[-1].smiles)
self._conformer.bond_topologies[-1].bond_topology_id = bond_topology_id
self._conformer.conformer_id = (
bond_topology_id * 1000 + int(conformer_id_str))
def parse_cluster_info(self, num_lines):
"""Stores a string describing the compute cluster used for computations."""
cluster_info = self.parse(ParseModes.RAW, num_lines=num_lines)
self._conformer.properties.compute_cluster_info = '\n'.join(
cluster_info) + '\n'
def parse_stage1_timings(self):
"""Parses recorded timings for different computation steps.
In the stage 1 files, the labels are implicit and only the first two ever
have valid values so we'll just pull those out.
"""
line = self.parse(ParseModes.RAW, num_lines=1)[0]
values = str(line).strip().split()
if values[0] != 'TIMINGS':
raise ValueError('Bad timing line: {}'.format(line))
if len(values) != 11:
raise ValueError('Timing line has {} components, not 11: {}'.format(
len(values), line))
for v in values[3:]:
if v != '-1':
raise ValueError(
'Expected all trailing timing to be -1, got {}'.format(v))
calculation_statistics = self._conformer.properties.calculation_statistics
calculation_statistics.add(computing_location='Geo', timings=values[1])
calculation_statistics.add(computing_location='Force', timings=values[2])
def parse_stage2_timings(self):
"""Parses recorded timings for different computation steps."""
section = self.parse(ParseModes.RAW, num_lines=2)
labels = str(section[0]).strip().split()
values = str(section[1]).strip().split()[1:]
assert len(labels) == len(
values), 'Length mismatch between values %s and %s labels.' % (values,
labels)
calculation_statistics = self._conformer.properties.calculation_statistics
for label, value in zip(labels, values):
calculation_statistics.add()
calculation_statistics[-1].computing_location = label
calculation_statistics[-1].timings = value
def parse_bonds(self):
"""Ignores BOND section is redudant given the topology information."""
# Some entries do not have BOND sections, which is fine.
if not self._next_line_startswith('BOND'):
return
self.parse(ParseModes.BYLABEL, label='BOND')
def parse_gradient_norms(self):
"""Parses initial and optimized geometry energies and gradient norms."""
section = self.parse(ParseModes.RAW, num_lines=2)
assert str(section[0]).startswith('E_ini/G_norm') and str(
section[1]).startswith(
'E_opt/G_norm'
), 'Unable to parse section for gradient norm: %s.' % section
properties = self._conformer.properties
items = str(section[0]).split()
properties.initial_geometry_energy.value = float(items[1])
properties.initial_geometry_gradient_norm.value = float(items[2])
items = str(section[1]).split()
properties.optimized_geometry_energy.value = float(items[1])
properties.optimized_geometry_gradient_norm.value = float(items[2])
def parse_coordinates(self, label, num_atoms):
"""Parses a section defining a molecule's geometry in Cartesian coordinates.
Args:
label: One of 'Initial Coords' and 'Optimized Coords' to determine the
type of coordinates.
num_atoms: Number of atoms in the molecule (with one matching line of atom
coordinates).
"""
if not self._next_line_startswith(label):
return
coordinate_section = self.parse(ParseModes.RAW, num_lines=num_atoms)
assert label in VALID_COORDINATE_LABELS, 'Unknown label %s.' % label
conformer = self._conformer
geometry = conformer.initial_geometries.add(
) if label == 'Initial Coords' else conformer.optimized_geometry
for line in coordinate_section:
label1, label2, unused_atomic_number, x, y, z = str(line).strip().split()
assert '%s %s' % (
label1, label2
) == label, 'Found line with incorrect label "%s %s". Expected %s.' % (
label1, label2, label)
geometry.atom_positions.add()
geometry.atom_positions[-1].x = float(x)
geometry.atom_positions[-1].y = float(y)
geometry.atom_positions[-1].z = float(z)
def parse_rotational_constants(self):
"""Parses rotational constants vector (MHz)."""
if not self._next_line_startswith('Rotational constants'):
return
constants = self.parse(ParseModes.RAW, num_lines=1)[0]
values = str(constants).strip().split()[-3:]
rotational_constants = self._conformer.properties.rotational_constants
rotational_constants.x = float(values[0])
rotational_constants.y = float(values[1])
rotational_constants.z = float(values[2])
def parse_symmetry_used(self):
"""Parses whether or not symmetry was used in the computation."""
if not self._next_line_startswith('Symmetry used in calculation'):
return
symmetry = self.parse(ParseModes.RAW, num_lines=1)[0]
self._conformer.properties.symmetry_used_in_calculation = str(
symmetry).strip().split()[-1] != 'no'
def parse_frequencies_and_intensities(self, num_atoms, header):
"""Parses a section with harmonic frequencies and intensities.
There are 3 values per atom of each.
Args:
num_atoms: Number of atoms in the molecule.
header: Whether to expect a 'Frequencies and intensities' (different in
stage1 and stage2 files)
"""
if header:
if not self._next_line_startswith('Frequencies and intensities'):
return
# Skip the header line
self.parse(ParseModes.SKIP, num_lines=1)
else:
# This is a bit of a hack. The frequencies and intensities can be missing
# from a stage1 file. But the only way to know this is that these are the
# last things expected in the entry.
next_line = self._next_line()
if not next_line or next_line.startswith(SEPARATOR_LINE):
return
section = self.parse(
ParseModes.RAW, num_lines=math.ceil(3 * num_atoms / 10))
section = [str(line).strip() for line in section]
section = ' '.join(section).split()
harmonic_frequencies = self._conformer.properties.harmonic_frequencies
for value in section:
harmonic_frequencies.value.append(float(value))
section = self.parse(
ParseModes.RAW, num_lines=math.ceil(3 * num_atoms / 10))
section = [str(line).strip() for line in section]
section = ' '.join(section).split()
harmonic_intensities = self._conformer.properties.harmonic_intensities
for value in section:
harmonic_intensities.value.append(float(value))
def parse_gaussian_sanity_check(self):
"""Parses the gaussian sanity check section (present in SMU1-6)."""
if not self._next_line_startswith('Gaussian sanity check'):
return
section = self.parse(ParseModes.RAW, num_lines=9)
# An example line with two floats (most only have one)
# Max. and Avg Dev. Frequencies 0.463700 0.144060
# 012345678901234567890123456789012345678901234567890123456789
for line, (prefix, fields) in zip(section[1:], GAUSSIAN_SANITY_CHECK_LINES):
assert str(line).startswith(prefix)
parts = line.split()
if len(fields) == 1:
setattr(self._conformer.properties.gaussian_sanity_check, fields[0],
float(parts[-1]))
elif len(fields) == 2:
setattr(self._conformer.properties.gaussian_sanity_check, fields[0],
float(parts[-2]))
setattr(self._conformer.properties.gaussian_sanity_check, fields[1],
float(parts[-1]))
else:
raise ValueError(f'Bad fields length {len(fields)}')
def parse_normal_modes(self, num_atoms):
"""Parses a repeating section containing a number of normal modes.
Args:
num_atoms: Number of atoms in the molecule.
"""
if not self._next_line_startswith('Normal modes'):
return
# Skip the header line
self.parse(ParseModes.SKIP, num_lines=1)
properties = self._conformer.properties
for _ in range(3 * num_atoms):
if not self._next_line_startswith('Mode'):
raise ValueError(
'Parsing normal_modes, expect Mode line, got: {}'.format(
self._raw_contents[self.line_num]))
self.parse(ParseModes.SKIP, num_lines=1) # 'Mode #i'
section = self.parse(
ParseModes.RAW, num_lines=math.ceil(3 * num_atoms / 10))
section = [str(line).strip() for line in section]
section = ' '.join(section).split()
properties.normal_modes.add()
for triplet in zip(section[::3], section[1::3], section[2::3]):
properties.normal_modes[-1].displacements.add()
properties.normal_modes[-1].displacements[-1].x = float(triplet[0])
properties.normal_modes[-1].displacements[-1].y = float(triplet[1])
properties.normal_modes[-1].displacements[-1].z = float(triplet[2])
def parse_property_list(self):
"""Parses a section of properties stored as key-value pairs."""
labels_and_values = self.parse(
ParseModes.KEYVALUE,
num_lines=50,
allowed_keys=PROPERTIES_LABEL_FIELDS.keys())
properties = self._conformer.properties
for label in labels_and_values:
if label in ['NIMAG', 'NUM_OPT']:
setattr(properties, PROPERTIES_LABEL_FIELDS[label],
int(labels_and_values[label]))
else:
value = float(labels_and_values[label])
getattr(properties, PROPERTIES_LABEL_FIELDS[label]).value = value
def parse_diagnostics(self):
"""Parses D1 and T1 diagnostics."""
properties = self._conformer.properties
if self._next_line_startswith('D1DIAG'):
line = self.parse(ParseModes.RAW, num_lines=1)[0]
items = str(line).strip().split()
properties.diagnostics_d1_ccsd_2sp.value = float(items[2])
if self._next_line_startswith('T1DIAG'):
line = self.parse(ParseModes.RAW, num_lines=1)[0]
items = str(line).strip().split()
properties.diagnostics_t1_ccsd_2sp.value = float(items[2])
properties.diagnostics_t1_ccsd_2sd.value = float(items[4])
properties.diagnostics_t1_ccsd_3psd.value = float(items[6])
def parse_homo_lumo(self):
"""Parses HOMO and LUMO values (at different levels of theory).
Raises:
ValueError: for unknown level of theory
"""
if not self._next_line_startswith('HOMO/LUMO'):
return
homo_lumo_data = self.parse(ParseModes.BYLABEL, label='HOMO/LUMO')
properties = self._conformer.properties
for line in homo_lumo_data:
items = str(line).strip().split()
if items[1] == 'PBE0/6-311Gd':
properties.homo_pbe0_6_311gd.value = float(items[2])
properties.lumo_pbe0_6_311gd.value = float(items[3])
elif items[1] == 'PBE0/aug-pc-1':
properties.homo_pbe0_aug_pc_1.value = float(items[2])
properties.lumo_pbe0_aug_pc_1.value = float(items[3])
elif items[1] == 'PBE0/6-31++Gdp':
properties.homo_pbe0_6_31ppgdp.value = float(items[2])
properties.lumo_pbe0_6_31ppgdp.value = float(items[3])
elif items[1] == 'PBE0/aug-pcS-1':
properties.homo_pbe0_aug_pcs_1.value = float(items[2])
properties.lumo_pbe0_aug_pcs_1.value = float(items[3])
elif items[1] == 'HF/6-31Gd':
properties.homo_hf_6_31gd.value = float(items[2])
properties.lumo_hf_6_31gd.value = float(items[3])
elif items[1] == 'HF/TZVP':
properties.homo_hf_tzvp.value = float(items[2])
properties.lumo_hf_tzvp.value = float(items[3])
elif items[1] == 'HF/3':
properties.homo_hf_3.value = float(items[2])
properties.lumo_hf_3.value = float(items[3])
elif items[1] == 'HF/4':
properties.homo_hf_4.value = float(items[2])
properties.lumo_hf_4.value = float(items[3])
elif items[1] == 'HF/CVTZ':
properties.homo_hf_cvtz.value = float(items[2])
properties.lumo_hf_cvtz.value = float(items[3])
elif items[1] == 'B3LYP/6-31++Gdp':
properties.homo_b3lyp_6_31ppgdp.value = float(items[2])
properties.lumo_b3lyp_6_31ppgdp.value = float(items[3])
elif items[1] == 'B3LYP/aug-pcS-1':
properties.homo_b3lyp_aug_pcs_1.value = float(items[2])
properties.lumo_b3lyp_aug_pcs_1.value = float(items[3])
else:
raise ValueError('Invalid level of theory: %s.' % items[1])
def parse_atomic_block(self):
"""Parses block of properties beginning with AT2.
Raises:
ValueError: if encountering and unknown field type.
"""
if not self._next_line_startswith('AT2_'):
return
section = self.parse(ParseModes.BYLABEL, label='AT2_')
properties = self._conformer.properties
for line in section:
label, rest = str(line[:20]).strip(), line[20:]
field_name, field_type = ATOMIC_LABEL_FIELDS[label]
# Special case for AT2_T1mol. This same value is written in two places
# in the .dat file. We verify that the value already there (if there is
# one) is the same as what we have here.
if label == 'AT2_T1mol' and properties.HasField(
'diagnostics_t1_ccsd_2sd'):
new_val = float(rest)
if not np.isclose(
new_val, properties.diagnostics_t1_ccsd_2sd.value, atol=.00015):
raise ValueError(
'Atomic block AT2_T1mol ({:f}) differs from current value ({:f})'
.format(new_val, properties.diagnostics_t1_ccsd_2sd.value))
if field_type == Atomic2FieldTypes.STRING:
getattr(properties, field_name).value = str(rest)
elif field_type == Atomic2FieldTypes.SCALAR:
getattr(properties, field_name).value = float(rest)
elif field_type == Atomic2FieldTypes.TRIPLE:
for suffix, val in zip(['', '_um', '_um_ci'], str(rest).split()):
getattr(properties, field_name + suffix).value = float(val)
else:
raise ValueError(
'Atomic block unknown field types {}'.format(field_type))
def parse_excitation_energies_and_oscillations(self):
"""Parses exitation energies and length rep. osc. strengths at CC2/TZVP."""
if not self._next_line_startswith(EXCITATION_HEADER):
return
segment = self.parse(ParseModes.RAW, num_lines=6)
for line in segment[1:]:
items = str(line).strip().split()
properties = self._conformer.properties
properties.excitation_energies_cc2.value.append(float(items[-2]))
properties.excitation_oscillator_strengths_cc2.value.append(
float(items[-1]))
def parse_nmr_isotropic_shieldings(self):
"""Parses NMR isotropic shieldings (ppm) for different levels of theory.
Raises:
ValueError: if line could not be parsed.
"""
properties = self._conformer.properties
while self._next_line_startswith('NMR isotropic shieldings'):
shieldings_data = self.parse(
ParseModes.RAW,
num_lines=(len(self._conformer.bond_topologies[-1].atoms) + 1))
theory_basis = str(shieldings_data[0]).split()[-1]
field = getattr(properties,
NMR_ISOTROPIC_SHIELDINGS_LABEL_FIELDS[theory_basis])
for line in shieldings_data[1:]:
line = str(line) # for type checking
# Example line: ' 1 6 141.2736 +/- 0.0064'
# with offsets: 01234567890123456789012345678901234567
value_str, pm_str, precision_str = line[10:25], line[25:28], line[28:]
# An error check that the line appears to be formatted correctly.
if pm_str != '+/-':
raise ValueError('Could not parse nmr line: "{}"'.format(line))
field.values.append(float(value_str))
field.precision.append(float(precision_str))
def parse_partial_charges(self):
"""Parses partial charges (e) for different levels of theory."""
properties = self._conformer.properties
while self._next_line_startswith('Partial charges'):
partial_charges_data = self.parse(
ParseModes.RAW,
num_lines=(len(self._conformer.bond_topologies[-1].atoms) + 1))
theory_basis = str(partial_charges_data[0]).strip().split()[-1]
field = getattr(properties, PARTIAL_CHARGES_LABEL_FIELDS[theory_basis])
for line in partial_charges_data[1:]:
items = str(line).strip().split()
field.values.append(float(items[2]))
field.precision.append(float(items[-1]))
def parse_polarizability(self):
"""Parses dipole-dipole polarizability."""
if not self._next_line_startswith('Polarizability (au)'):
return
properties = self._conformer.properties
header = self.parse(ParseModes.RAW, num_lines=1) # Polarizability (au).
items = str(header).strip().split()
rank2_data = self.parse(ParseModes.KEYVALUE, num_lines=6)
if items[-1].startswith('PBE0'):
for label in RANK2_ENCODING_ORDER:
properties.dipole_dipole_polarizability_pbe0_aug_pc_1.matrix_values.append(
float(rank2_data[label]))
elif items[-1].startswith('HF'):
for label in RANK2_ENCODING_ORDER:
properties.dipole_dipole_polarizability_hf_6_31gd.matrix_values.append(
float(rank2_data[label]))
def parse_multipole_moments(self):
"""Parses Di-, Quadru-, and Octopole moments in (au)."""
properties = self._conformer.properties
# PBE0 section.
if self._next_line_startswith('Dipole moment (au): PBE0/aug-pc-1'):
self.parse(ParseModes.SKIP, num_lines=1) # Dipole moment (au).
dipole_data = self.parse(ParseModes.KEYVALUE, num_lines=3)
properties.dipole_moment_pbe0_aug_pc_1.x = float(dipole_data['x'])
properties.dipole_moment_pbe0_aug_pc_1.y = float(dipole_data['y'])
properties.dipole_moment_pbe0_aug_pc_1.z = float(dipole_data['z'])
self.parse(ParseModes.SKIP, num_lines=1) # Quadrupole moment (au).
quadrupole_data = self.parse(ParseModes.KEYVALUE, num_lines=6)
for label in RANK2_ENCODING_ORDER:
properties.quadrupole_moment_pbe0_aug_pc_1.matrix_values.append(
float(quadrupole_data[label]))
self.parse(ParseModes.SKIP, num_lines=1) # Octopole moment (au).
octopole_data = self.parse(ParseModes.KEYVALUE, num_lines=10)
if '**********' in dict(octopole_data).values():
raise SmuOverfullFloatFieldError()
for label in RANK3_ENCODING_ORDER:
properties.octopole_moment_pbe0_aug_pc_1.tensor_values.append(
float(octopole_data[label]))
# Hartree-Fock section.
if self._next_line_startswith('Dipole moment (au): HF/6-31Gd'):
self.parse(ParseModes.SKIP, num_lines=1) # Dipole moment (au).
dipole_data = self.parse(ParseModes.KEYVALUE, num_lines=3)
properties.dipole_moment_hf_6_31gd.x = float(dipole_data['x'])
properties.dipole_moment_hf_6_31gd.y = float(dipole_data['y'])
properties.dipole_moment_hf_6_31gd.z = float(dipole_data['z'])
self.parse(ParseModes.SKIP, num_lines=1) # Quadrupole moment (au).
quadrupole_data = self.parse(ParseModes.KEYVALUE, num_lines=6)
for label in RANK2_ENCODING_ORDER:
properties.quadrupole_moment_hf_6_31gd.matrix_values.append(
float(quadrupole_data[label]))
self.parse(ParseModes.SKIP, num_lines=1) # Octopole moment (au).
octopole_data = self.parse(ParseModes.KEYVALUE, num_lines=10)
if '**********' in dict(octopole_data).values():
raise SmuOverfullFloatFieldError()
for label in RANK3_ENCODING_ORDER:
properties.octopole_moment_hf_6_31gd.tensor_values.append(
float(octopole_data[label]))
def parse_stage1_to_proto(self):
"""Read _raw_contents and parses the various sections.
This parses the "stage1" files which are just the geometry optimization
before dedupping.
This only reads one conformer from _raw_contents. To read multiple, you have
to update _raw_contents between calls.
Returns:
dataset_pb2.Conformer or an Exception
"""
self.parse(ParseModes.INITIALIZE)
try:
self._conformer = dataset_pb2.Conformer()
self.parse(ParseModes.SKIP, num_lines=1) # Separator.
num_atoms = self.parse_stage1_header()
self.parse_bond_topology()
self.parse_identifier()
self.parse_cluster_info(num_lines=4)
self.parse_stage1_timings()
self.parse_gradient_norms()
self.parse_coordinates('Initial Coords', num_atoms)
self.parse_coordinates('Optimized Coords', num_atoms)
self.parse_frequencies_and_intensities(num_atoms, header=False)
# Somewhere along the lines in the regeneration process (maybe just for
# debugging), we add an extra blank line. We'll just skip it here and
# ignore blank lines at the end.
self.parse(ParseModes.SKIP_BLANK_LINES)
except (SmuKnownError, ValueError, IndexError, KeyError,
AssertionError) as exc:
exc.conformer_id = self._conformer.conformer_id
logging.info('Got exception during conformer %d: %s\n'
'traceback: %s', exc.conformer_id, str(exc),
traceback.format_exc())
return exc
return self._conformer
def parse_stage2_to_proto(self):
"""Read _raw_contents and parses the various sections.
This parses the "stage2" files which are the complete ones from the end of
the pipeline.
This only reads one conformer from _raw_contents. To read multiple, you have
to update _raw_contents between calls.
Returns:
dataset_pb2.Conformer with a single conformer, or an Exception
"""
self.parse(ParseModes.INITIALIZE)
try:
self._conformer = dataset_pb2.Conformer()
self.parse(ParseModes.SKIP, num_lines=1) # Separator.
num_atoms = self.parse_stage2_header()
self.parse_database()
self.parse_error_codes()
self.parse_bond_topology()
self.parse_identifier()
self.parse_cluster_info(num_lines=8)
self.parse_stage2_timings() # Timings per step.
self.parse_bonds()
self.parse_gradient_norms()
self.parse_coordinates('Initial Coords', num_atoms)
self.parse_coordinates('Optimized Coords', num_atoms)
self.parse_rotational_constants()
self.parse_symmetry_used()
# 'Frequencies and intensities'
self.parse_frequencies_and_intensities(num_atoms, header=True)
self.parse_gaussian_sanity_check()
self.parse_normal_modes(num_atoms)
self.parse_property_list() # Key-value pairs: Energies, frequencies,...
self.parse_diagnostics()
self.parse_atomic_block()
self.parse_homo_lumo()
self.parse_excitation_energies_and_oscillations()
self.parse_nmr_isotropic_shieldings()
self.parse_partial_charges()
self.parse_polarizability()
self.parse_multipole_moments()
# Somewhere along the lines in the regeneration process (maybe just for
# debugging), we add an extra blank line. We'll just skip it here and
# ignore blank lines at the end.
self.parse(ParseModes.SKIP_BLANK_LINES)
except (SmuKnownError, ValueError, IndexError, KeyError,
AssertionError) as exc:
exc.conformer_id = self._conformer.conformer_id
logging.info('Got exception during conformer %d: %s\n'
'traceback: %s', exc.conformer_id, str(exc),
traceback.format_exc())
return exc
return self._conformer
def _process(self, parse_fn):
line_generator = self._input_generator()
while self._read_next_chunk(line_generator):
yield parse_fn(), self._raw_contents
def process_stage1(self):
"""Execute a pass through a SMU file's contents.
The contents should be stage1 files from the initial geometry optimization
and filtering.
Yields:
dataset_pb2.Entry (with one conformer each) or an Exception encountered
during parsing, list of raw input lines
"""
yield from self._process(self.parse_stage1_to_proto)
def process_stage2(self):
"""Execute a pass through a SMU file's contents.
The contents should be stage2 files from the end of the pipeline.
Yielded line numbers are indices into self.raw_contents.
Yields:
dataset_pb2.Entry (with one conformer each) or an Exception encountered
during parsing, list of raw input lines
"""
yield from self._process(self.parse_stage2_to_proto)
| google-research/google-research | smu/parser/smu_parser_lib.py | Python | apache-2.0 | 47,286 | [
"Gaussian",
"ORCA"
] | ef20a906b67a50a90d21b279be4cff3799f14878372fd514385d9c58a0fc2004 |
"""
This is a comment
"""
#try: # this part to import as part of the DIRAC framework
import xml.sax
from xml.sax.handler import ContentHandler
from DIRAC.Core.Workflow.Parameter import *
from DIRAC.Core.Workflow.Module import *
from DIRAC.Core.Workflow.Step import *
from DIRAC.Core.Workflow.Workflow import Workflow
__RCSID__ = "$Id$"
class WorkflowXMLHandler(ContentHandler):
def __init__(self, new_wf=None):
""" If new_wf defined, it will be used as root of document """
# this is an attribute for the object to be created from the XML document
self.root=new_wf # the reference on the all document
self.stack=None # to keep last object
self.strings=None # to accumulate string object (list of strings) used to split long string
def startDocument(self):
#reset the process
#self.root=None
self.stack=[]
self.strings=[]
def endDocument(self):
pass
def startElement(self, name, attrs):
#print name ,"startElement", "attr=", attrs.getLength(), attrs.getNames()
self.clearCharacters() # clear to remove empty or nonprintable characters
if name == "Workflow":
if self.root == None: #if root not defined by constractor
self.root = Workflow()
self.stack.append(self.root)
elif name == "StepDefinition":
obj = StepDefinition("TemporaryXMLObject_StepDefinition")
if self.root == None: # in case we are saving Step only
self.root = obj
self.stack.append(obj)
elif name == "StepInstance":
obj = StepInstance("TemporaryXMLObject_StepInstance")
self.stack.append(obj)
elif name == "ModuleDefinition":
obj = ModuleDefinition("TemporaryXMLObject_ModuleDefinition")
if self.root == None: # in case we are saving Module only
self.root = obj
self.stack.append(obj)
elif name == "ModuleInstance":
obj = ModuleInstance("TemporaryXMLObject_ModuleInstance")
self.stack.append(obj)
elif name == "Parameter":
obj = Parameter(str(attrs['name']), None, str(attrs['type']), str(attrs['linked_module']), str(attrs['linked_parameter']), str(attrs['in']), str(attrs['out']), str(attrs['description']))
self.stack.append(obj)
# TEMPORARY CODE
elif name=="origin" or name == "version" or name == "name" or name == "type" or name == "value" or\
name == "required" or name == "descr_short" or name == "name" or name == "type" or name == "description" or name == "body":
pass
else:
print "UNTREATED! startElement name=", name, "attr=", attrs.getLength(), attrs.getNames()
pass
def endElement(self, name):
#print name, "endElement"
# attributes
if name=="origin":
self.stack[len(self.stack)-1].setOrigin(self.getCharacters())
elif name == "version":
self.stack[len(self.stack)-1].setVersion(self.getCharacters())
elif name == "name":
self.stack[len(self.stack)-1].setName(self.getCharacters())
elif name == "type":
self.stack[len(self.stack)-1].setType(self.getCharacters())
elif name == "required":
self.stack[len(self.stack)-1].setRequired(self.getCharacters())
elif name == "descr_short":
self.stack[len(self.stack)-1].setDescrShort(self.getCharacters())
elif name == "name":
self.stack[len(self.stack)-1].setName(self.getCharacters())
elif name == "type":
self.stack[len(self.stack)-1].setType(self.getCharacters())
elif name == "description":
self.stack[len(self.stack)-1].setDescription(self.getCharacters())
elif name == "body":
self.stack[len(self.stack)-1].setBody(self.getCharacters())
elif name == "value":
ch = self.getCharacters()
# to keep compatibility with the old version
# were """ was not used for the string
if self.stack[len(self.stack)-1].isTypeString():
self.stack[len(self.stack)-1].setValue(ch)
else:
self.stack[len(self.stack)-1].setValue(eval(ch))
#objects
elif name=="Workflow":
self.stack.pop()
elif name == "StepDefinition":
self.root.step_definitions.append(self.stack.pop())
elif name == "StepInstance":
self.root.step_instances.append(self.stack.pop())
elif name == "ModuleDefinition":
self.root.addModule(self.stack.pop())
elif name == "ModuleInstance":
obj=self.stack.pop()
self.stack[len(self.stack)-1].module_instances.append(obj)
elif name == "Parameter":
obj=self.stack.pop();
self.stack[len(self.stack)-1].addParameter(obj)
else:
print "UNTREATED! endElement", name
def getCharacters(self):
# combine all strings and clear the list
ret = ''.join(self.strings)
self.clearCharacters()
return str(ret)
def clearCharacters(self):
del self.strings
self.strings=[]
def characters(self, content):
self.strings.append(content)
| andresailer/DIRAC | Core/Workflow/WorkflowReader.py | Python | gpl-3.0 | 4,858 | [
"DIRAC"
] | 5cef9076db8361dd0acbd0a9fc48fc24607621d31da158f758b53b27f8b2132c |
"""
Featurizes proposed binding pockets.
"""
import numpy as np
import logging
from deepchem.feat import Featurizer
from deepchem.utils.rdkit_utils import load_molecule
logger = logging.getLogger(__name__)
def boxes_to_atoms(coords, boxes):
"""Maps each box to a list of atoms in that box.
Given the coordinates of a macromolecule, and a collection of boxes,
returns a dictionary which maps boxes to the atom indices of the
atoms in them.
Parameters
----------
coords: np.ndarray
Of shape `(N, 3)
boxes: list
list of `CoordinateBox` objects.
Returns
-------
dictionary mapping `CoordinateBox` objects to lists of atom coordinates
"""
mapping = {}
for box_ind, box in enumerate(boxes):
box_atoms = []
for atom_ind in range(len(coords)):
atom = coords[atom_ind]
if atom in box:
box_atoms.append(atom_ind)
mapping[box] = box_atoms
return mapping
class BindingPocketFeaturizer(Featurizer):
"""Featurizes binding pockets with information about chemical
environments.
In many applications, it's desirable to look at binding pockets on
macromolecules which may be good targets for potential ligands or
other molecules to interact with. A `BindingPocketFeaturizer`
expects to be given a macromolecule, and a list of pockets to
featurize on that macromolecule. These pockets should be of the form
produced by a `dc.dock.BindingPocketFinder`, that is as a list of
`dc.utils.CoordinateBox` objects.
The base featurization in this class's featurization is currently
very simple and counts the number of residues of each type present
in the pocket. It's likely that you'll want to overwrite this
implementation for more sophisticated downstream usecases. Note that
this class's implementation will only work for proteins and not for
other macromolecules
"""
residues = [
"ALA", "ARG", "ASN", "ASP", "CYS", "GLN", "GLU", "GLY", "HIS", "ILE",
"LEU", "LYS", "MET", "PHE", "PRO", "PYL", "SER", "SEC", "THR", "TRP",
"TYR", "VAL", "ASX", "GLX"
]
n_features = len(residues)
def featurize(self, protein_file, pockets):
"""
Calculate atomic coodinates.
Parameters
----------
protein_file: str
Location of PDB file. Will be loaded by MDTraj
pockets: list[CoordinateBox]
List of `dc.utils.CoordinateBox` objects.
Returns
-------
A numpy array of shale `(len(pockets), n_residues)`
"""
import mdtraj
protein_coords = load_molecule(
protein_file, add_hydrogens=False, calc_charges=False)[0]
mapping = boxes_to_atoms(protein_coords, pockets)
protein = mdtraj.load(protein_file)
n_pockets = len(pockets)
n_residues = len(BindingPocketFeaturizer.residues)
res_map = dict(zip(BindingPocketFeaturizer.residues, range(n_residues)))
all_features = np.zeros((n_pockets, n_residues))
for pocket_num, pocket in enumerate(pockets):
pocket_atoms = mapping[pocket]
for ind, atom in enumerate(pocket_atoms):
atom_name = str(protein.top.atom(atom))
# atom_name is of format RESX-ATOMTYPE
# where X is a 1 to 4 digit number
residue = atom_name[:3]
if residue not in res_map:
logger.info("Warning: Non-standard residue in PDB file")
continue
atomtype = atom_name.split("-")[1]
all_features[pocket_num, res_map[residue]] += 1
return all_features
| miaecle/deepchem | deepchem/feat/binding_pocket_features.py | Python | mit | 3,434 | [
"MDTraj"
] | 5515446f2e4a2bba3a8ca261180820667d81d9a6ef887b474152bcf8ccff3c81 |
# Copyright (c) 2012, GPy authors (see AUTHORS.txt).
# Licensed under the BSD 3-clause license (see LICENSE.txt)
import numpy as np
from ..core.sparse_gp_mpi import SparseGP_MPI
from .. import kern
from ..likelihoods import Gaussian
from ..core.parameterization.variational import SpikeAndSlabPrior, SpikeAndSlabPosterior
from ..inference.latent_function_inference.var_dtc_parallel import update_gradients, VarDTC_minibatch
from ..kern._src.psi_comp.ssrbf_psi_gpucomp import PSICOMP_SSRBF_GPU
class SSGPLVM(SparseGP_MPI):
"""
Spike-and-Slab Gaussian Process Latent Variable Model
:param Y: observed data (np.ndarray) or GPy.likelihood
:type Y: np.ndarray| GPy.likelihood instance
:param input_dim: latent dimensionality
:type input_dim: int
:param init: initialisation method for the latent space
:type init: 'PCA'|'random'
"""
def __init__(self, Y, input_dim, X=None, X_variance=None, Gamma=None, init='PCA', num_inducing=10,
Z=None, kernel=None, inference_method=None, likelihood=None, name='Spike_and_Slab GPLVM', group_spike=False, mpi_comm=None, pi=None, learnPi=True,normalizer=False, **kwargs):
self.group_spike = group_spike
if X == None:
from ..util.initialization import initialize_latent
X, fracs = initialize_latent(init, input_dim, Y)
else:
fracs = np.ones(input_dim)
self.init = init
if X_variance is None: # The variance of the variational approximation (S)
X_variance = np.random.uniform(0,.1,X.shape)
if Gamma is None:
gamma = np.random.randn(X.shape[0], input_dim)
else:
gamma = Gamma.copy()
if Z is None:
Z = np.random.permutation(X.copy())[:num_inducing]
assert Z.shape[1] == X.shape[1]
if likelihood is None:
likelihood = Gaussian()
if kernel is None:
kernel = kern.RBF(input_dim, lengthscale=fracs, ARD=True) # + kern.white(input_dim)
if kernel.useGPU:
kernel.psicomp = PSICOMP_SSRBF_GPU()
if inference_method is None:
inference_method = VarDTC_minibatch(mpi_comm=mpi_comm)
if pi is None:
pi = np.empty((input_dim))
pi[:] = 0.5
self.variational_prior = SpikeAndSlabPrior(pi=pi,learnPi=learnPi) # the prior probability of the latent binary variable b
X = SpikeAndSlabPosterior(X, X_variance, gamma)
super(SSGPLVM,self).__init__(X, Y, Z, kernel, likelihood, variational_prior=self.variational_prior, inference_method=inference_method, name=name, mpi_comm=mpi_comm, normalizer=normalizer, **kwargs)
# self.X.unfix()
# self.X.variance.constrain_positive()
self.link_parameter(self.X, index=0)
if self.group_spike:
[self.X.gamma[:,i].tie('tieGamma'+str(i)) for i in xrange(self.X.gamma.shape[1])] # Tie columns together
def set_X_gradients(self, X, X_grad):
"""Set the gradients of the posterior distribution of X in its specific form."""
X.mean.gradient, X.variance.gradient, X.binary_prob.gradient = X_grad
def get_X_gradients(self, X):
"""Get the gradients of the posterior distribution of X in its specific form."""
return X.mean.gradient, X.variance.gradient, X.binary_prob.gradient
def parameters_changed(self):
super(SSGPLVM,self).parameters_changed()
if isinstance(self.inference_method, VarDTC_minibatch):
return
self._log_marginal_likelihood -= self.variational_prior.KL_divergence(self.X)
self.X.mean.gradient, self.X.variance.gradient, self.X.binary_prob.gradient = self.kern.gradients_qX_expectations(variational_posterior=self.X, Z=self.Z, dL_dpsi0=self.grad_dict['dL_dpsi0'], dL_dpsi1=self.grad_dict['dL_dpsi1'], dL_dpsi2=self.grad_dict['dL_dpsi2'])
# update for the KL divergence
self.variational_prior.update_gradients_KL(self.X)
def input_sensitivity(self):
if self.kern.ARD:
return self.kern.input_sensitivity()
else:
return self.variational_prior.pi
def plot_latent(self, plot_inducing=True, *args, **kwargs):
import sys
assert "matplotlib" in sys.modules, "matplotlib package has not been imported."
from ..plotting.matplot_dep import dim_reduction_plots
return dim_reduction_plots.plot_latent(self, plot_inducing=plot_inducing, *args, **kwargs)
| gusmaogabriels/GPy | GPy/models/ss_gplvm.py | Python | bsd-3-clause | 4,601 | [
"Gaussian"
] | 054e461e5f0cc679a20bfcaca68c2238c4a1c397a32f8c4a0d906a14ae0e79f0 |
# Orca
#
# Copyright 2010 Consorcio Fernando de los Rios.
# Author: Javier Hernandez Antunez <jhernandez@emergya.es>
# Author: Alejandro Leiva <aleiva@emergya.es>
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the
# Free Software Foundation, Inc., Franklin Street, Fifth Floor,
# Boston MA 02110-1301 USA.
"""Settings manager module. This will load/save user settings from a
defined settings backend."""
__id__ = "$Id$"
__version__ = "$Revision$"
__date__ = "$Date$"
__copyright__ = "Copyright (c) 2010 Consorcio Fernando de los Rios."
__license__ = "LGPL"
import imp
import importlib
import os
from gi.repository import Gio, GLib
from . import debug
from . import orca_i18n
from . import script_manager
from . import settings
from . import pronunciation_dict
from .keybindings import KeyBinding
try:
_proxy = Gio.DBusProxy.new_for_bus_sync(
Gio.BusType.SESSION,
Gio.DBusProxyFlags.NONE,
None,
'org.a11y.Bus',
'/org/a11y/bus',
'org.freedesktop.DBus.Properties',
None)
except:
_proxy = None
_scriptManager = script_manager.getManager()
class SettingsManager(object):
"""Settings backend manager. This class manages orca user's settings
using different backends"""
_instance = None
def __new__(cls, *args, **kwargs):
if '__instance' not in vars(cls):
cls.__instance = object.__new__(cls, *args, **kwargs)
return cls.__instance
def __init__(self, backend='json'):
"""Initialize a SettingsManager Object.
If backend isn't defined then uses default backend, in this
case json-backend.
backend parameter can use the follow values:
backend='json'
"""
debug.println(debug.LEVEL_FINEST, 'INFO: Initializing settings manager')
self.backendModule = None
self._backend = None
self.profile = None
self.backendName = backend
self._prefsDir = None
# Dictionaries for store the default values
# The keys and values are defined at orca.settings
#
self.defaultGeneral = {}
self.defaultPronunciations = {}
self.defaultKeybindings = {}
# Dictionaries that store the key:value pairs which values are
# different from the current profile and the default ones
#
self.profileGeneral = {}
self.profilePronunciations = {}
self.profileKeybindings = {}
# Dictionaries that store the current settings.
# They are result to overwrite the default values with
# the ones from the current active profile
self.general = {}
self.pronunciations = {}
self.keybindings = {}
self._activeApp = ""
self._appGeneral = {}
self._appPronunciations = {}
self._appKeybindings = {}
if not self._loadBackend():
raise Exception('SettingsManager._loadBackend failed.')
self.customizedSettings = {}
self._customizationCompleted = False
# For handling the currently-"classic" application settings
self.settingsPackages = ["app-settings"]
debug.println(debug.LEVEL_FINEST, 'INFO: Settings manager initialized')
def activate(self, prefsDir=None, customSettings={}):
debug.println(debug.LEVEL_FINEST, 'INFO: Activating settings manager')
self.customizedSettings.update(customSettings)
self._prefsDir = prefsDir \
or os.path.join(GLib.get_user_data_dir(), "orca")
# Load the backend and the default values
self._backend = self.backendModule.Backend(self._prefsDir)
self._setDefaultGeneral()
self._setDefaultPronunciations()
self._setDefaultKeybindings()
self.general = self.defaultGeneral.copy()
if not self.isFirstStart():
self.general.update(self._backend.getGeneral())
self.pronunciations = self.defaultPronunciations.copy()
self.keybindings = self.defaultKeybindings.copy()
# If this is the first time we launch Orca, there is no user settings
# yet, so we need to create the user config directories and store the
# initial default settings
#
self._createDefaults()
debug.println(debug.LEVEL_FINEST, 'INFO: Settings manager activated')
# Set the active profile and load its stored settings
if self.profile is None:
self.profile = self.general.get('startingProfile')[1]
self.setProfile(self.profile)
def _loadBackend(self):
"""Load specific backend for manage user settings"""
try:
backend = '.backends.%s_backend' % self.backendName
self.backendModule = importlib.import_module(backend, 'orca')
return True
except:
return False
def _createDefaults(self):
"""Let the active backend to create the initial structure
for storing the settings and save the default ones from
orca.settings"""
def _createDir(dirName):
if not os.path.isdir(dirName):
os.makedirs(dirName)
# Set up the user's preferences directory
# ($XDG_DATA_HOME/orca by default).
#
orcaDir = self._prefsDir
_createDir(orcaDir)
# Set up $XDG_DATA_HOME/orca/orca-scripts as a Python package
#
orcaScriptDir = os.path.join(orcaDir, "orca-scripts")
_createDir(orcaScriptDir)
initFile = os.path.join(orcaScriptDir, "__init__.py")
if not os.path.exists(initFile):
os.close(os.open(initFile, os.O_CREAT, 0o700))
orcaSettingsDir = os.path.join(orcaDir, "app-settings")
_createDir(orcaSettingsDir)
# Set up $XDG_DATA_HOME/orca/orca-customizations.py empty file and
# define orcaDir as a Python package.
initFile = os.path.join(orcaDir, "__init__.py")
if not os.path.exists(initFile):
os.close(os.open(initFile, os.O_CREAT, 0o700))
userCustomFile = os.path.join(orcaDir, "orca-customizations.py")
if not os.path.exists(userCustomFile):
os.close(os.open(userCustomFile, os.O_CREAT, 0o700))
if self.isFirstStart():
self._backend.saveDefaultSettings(self.defaultGeneral,
self.defaultPronunciations,
self.defaultKeybindings)
def _setDefaultPronunciations(self):
"""Get the pronunciations by default from orca.settings"""
self.defaultPronunciations = {}
def _setDefaultKeybindings(self):
"""Get the keybindings by default from orca.settings"""
self.defaultKeybindings = {}
def _setDefaultGeneral(self):
"""Get the general settings by default from orca.settings"""
self._getCustomizedSettings()
self.defaultGeneral = {}
for key in settings.userCustomizableSettings:
value = self.customizedSettings.get(key)
if value == None:
try:
value = getattr(settings, key)
except:
pass
self.defaultGeneral[key] = value
def _getCustomizedSettings(self):
if self._customizationCompleted:
return self.customizedSettings
originalSettings = {}
for key, value in list(settings.__dict__.items()):
originalSettings[key] = value
self._customizationCompleted = self._loadUserCustomizations()
for key, value in list(originalSettings.items()):
customValue = settings.__dict__.get(key)
if value != customValue:
self.customizedSettings[key] = customValue
def _loadUserCustomizations(self):
"""Attempt to load the user's orca-customizations. Returns a boolean
indicating our success at doing so, where success is measured by the
likelihood that the results won't be different if we keep trying."""
success = False
pathList = [self._prefsDir]
try:
msg = "Attempt to load orca-customizations "
(fileHnd, moduleName, desc) = \
imp.find_module("orca-customizations", pathList)
msg += "from %s " % moduleName
imp.load_module("orca-customizations", fileHnd, moduleName, desc)
except ImportError:
success = True
msg += "failed due to ImportError. Giving up."
except AttributeError:
return False
else:
msg += "succeeded."
fileHnd.close()
success = True
debug.println(debug.LEVEL_ALL, msg)
return success
def getPrefsDir(self):
return self._prefsDir
def setSetting(self, settingName, settingValue):
self._setSettingsRuntime({settingName:settingValue})
def getSetting(self, settingName):
return getattr(settings, settingName, None)
def getVoiceLocale(self, voice='default'):
voices = self.getSetting('voices')
v = voices.get(voice, {})
lang = v.getLocale()
dialect = v.getDialect()
if dialect and len(str(dialect)) == 2:
lang = "%s_%s" % (lang, dialect.upper())
return lang
def _loadProfileSettings(self, profile=None):
"""Get from the active backend all the settings for the current
profile and store them in the object's attributes.
A profile can be passed as a parameter. This could be useful for
change from one profile to another."""
if profile is None:
profile = self.profile
self.profileGeneral = self.getGeneralSettings(profile) or {}
self.profilePronunciations = self.getPronunciations(profile) or {}
self.profileKeybindings = self.getKeybindings(profile) or {}
def _mergeSettings(self):
"""Update the changed values on the profile settings
over the current and active settings"""
self.profileGeneral.update(self._appGeneral)
self.profilePronunciations.update(self._appPronunciations)
self.profileKeybindings.update(self._appKeybindings)
self.general.update(self.profileGeneral)
self.pronunciations.update(self.profilePronunciations)
self.keybindings.update(self.profileKeybindings)
def _enableAccessibility(self):
"""Enables the GNOME accessibility flag. Users need to log out and
then back in for this to take effect.
Returns True if an action was taken (i.e., accessibility was not
set prior to this call).
"""
alreadyEnabled = self.isAccessibilityEnabled()
if not alreadyEnabled:
self.setAccessibility(True)
return not alreadyEnabled
def isAccessibilityEnabled(self):
if not _proxy:
return False
return _proxy.Get('(ss)', 'org.a11y.Status', 'IsEnabled')
def setAccessibility(self, enable):
if not _proxy:
return False
vEnable = GLib.Variant('b', enable)
_proxy.Set('(ssv)', 'org.a11y.Status', 'IsEnabled', vEnable)
def isScreenReaderServiceEnabled(self):
"""Returns True if the screen reader service is enabled. Note that
this does not necessarily mean that Orca (or any other screen reader)
is running at the moment."""
if not _proxy:
return False
return _proxy.Get('(ss)', 'org.a11y.Status', 'ScreenReaderEnabled')
def setStartingProfile(self, profile=None):
if profile is None:
profile = settings.profile
self._backend._setProfileKey('startingProfile', profile)
def getProfile(self):
return self.profile
def setProfile(self, profile='default', updateLocale=False):
"""Set a specific profile as the active one.
Also the settings from that profile will be loading
and updated the current settings with them."""
oldVoiceLocale = self.getVoiceLocale('default')
self.profile = profile
self._loadProfileSettings(profile)
self._mergeSettings()
self._setSettingsRuntime(self.general)
if not updateLocale:
return
newVoiceLocale = self.getVoiceLocale('default')
if oldVoiceLocale != newVoiceLocale:
orca_i18n.setLocaleForNames(newVoiceLocale)
orca_i18n.setLocaleForMessages(newVoiceLocale)
orca_i18n.setLocaleForGUI(newVoiceLocale)
def _setSettingsRuntime(self, settingsDict):
for key, value in list(settingsDict.items()):
setattr(settings, str(key), value)
self._getCustomizedSettings()
for key, value in list(self.customizedSettings.items()):
setattr(settings, str(key), value)
def _setPronunciationsRuntime(self, pronunciationsDict):
pronunciation_dict.pronunciation_dict = {}
for key, value in pronunciationsDict.values():
if key and value:
pronunciation_dict.setPronunciation(key, value)
def getGeneralSettings(self, profile='default'):
"""Return the current general settings.
Those settings comes from updating the default settings
with the profiles' ones"""
return self._backend.getGeneral(profile)
def getPronunciations(self, profile='default'):
"""Return the current pronunciations settings.
Those settings comes from updating the default settings
with the profiles' ones"""
return self._backend.getPronunciations(profile)
def getKeybindings(self, profile='default'):
"""Return the current keybindings settings.
Those settings comes from updating the default settings
with the profiles' ones"""
return self._backend.getKeybindings(profile)
def _setProfileGeneral(self, general):
"""Set the changed general settings from the defaults' ones
as the profile's."""
self.profileGeneral = {}
for key, value in list(general.items()):
if key in ['startingProfile', 'activeProfile']:
continue
elif key == 'profile':
self.profileGeneral[key] = value
elif value != self.defaultGeneral.get(key):
self.profileGeneral[key] = value
elif self.general.get(key) != value:
self.profileGeneral[key] = value
def _setProfilePronunciations(self, pronunciations):
"""Set the changed pronunciations settings from the defaults' ones
as the profile's."""
self.profilePronunciations = self.defaultPronunciations.copy()
self.profilePronunciations.update(pronunciations)
def _setProfileKeybindings(self, keybindings):
"""Set the changed keybindings settings from the defaults' ones
as the profile's."""
self.profileKeybindings = self.defaultKeybindings.copy()
self.profileKeybindings.update(keybindings)
def _saveAppSettings(self, appName, general, pronunciations, keybindings):
appGeneral = {}
profileGeneral = self.getGeneralSettings(self.profile)
for key, value in general.items():
if value != profileGeneral.get(key):
appGeneral[key] = value
appPronunciations = {}
profilePronunciations = self.getPronunciations(self.profile)
for key, value in pronunciations.items():
if value != profilePronunciations.get(key):
appPronunciations[key] = value
appKeybindings = {}
profileKeybindings = self.getKeybindings(self.profile)
for key, value in keybindings.items():
if value != profileKeybindings.get(key):
appKeybindings[key] = value
self._backend.saveAppSettings(appName,
self.profile,
appGeneral,
appPronunciations,
appKeybindings)
def saveSettings(self, script, general, pronunciations, keybindings):
"""Save the settings provided for the script provided."""
app = script.app
if app:
self._saveAppSettings(app.name, general, pronunciations, keybindings)
return
# Assign current profile
_profile = general.get('profile', settings.profile)
currentProfile = _profile[1]
self.profile = currentProfile
# Elements that need to stay updated in main configuration.
self.defaultGeneral['startingProfile'] = general.get('startingProfile',
_profile)
self._setProfileGeneral(general)
self._setProfilePronunciations(pronunciations)
self._setProfileKeybindings(keybindings)
self._backend.saveProfileSettings(self.profile,
self.profileGeneral,
self.profilePronunciations,
self.profileKeybindings)
return self._enableAccessibility()
def _adjustBindingTupleValues(self, bindingTuple):
"""Converts the values of bindingTuple into KeyBinding-ready values."""
keysym, mask, mods, clicks = bindingTuple
if not keysym:
bindingTuple = ('', 0, 0, 0)
else:
bindingTuple = (keysym, int(mask), int(mods), int(clicks))
return bindingTuple
def overrideKeyBindings(self, script, scriptKeyBindings):
keybindingsSettings = self.profileKeybindings
for handlerString, bindingTuples in list(keybindingsSettings.items()):
handler = script.inputEventHandlers.get(handlerString)
if not handler:
continue
scriptKeyBindings.removeByHandler(handler)
for bindingTuple in bindingTuples:
bindingTuple = self._adjustBindingTupleValues(bindingTuple)
keysym, mask, mods, clicks = bindingTuple
newBinding = KeyBinding(keysym, mask, mods, handler, clicks)
scriptKeyBindings.add(newBinding)
return scriptKeyBindings
def isFirstStart(self):
"""Check if the firstStart key is True or false"""
return self._backend.isFirstStart()
def setFirstStart(self, value=False):
"""Set firstStart. This user-configurable settting is primarily
intended to serve as an indication as to whether or not initial
configuration is needed."""
self._backend.setFirstStart(value)
def availableProfiles(self):
"""Get available profiles from active backend"""
return self._backend.availableProfiles()
def loadAppSettings(self, script):
"""Load the users application specific settings for an app.
Arguments:
- script: the current active script.
"""
if not (script and script.app):
return
for key in self._appPronunciations.keys():
self.pronunciations.pop(key)
prefs = self._backend.getAppSettings(script.app.name)
profiles = prefs.get('profiles', {})
profilePrefs = profiles.get(self.profile, {})
self._appGeneral = profilePrefs.get('general', {})
self._appKeybindings = profilePrefs.get('keybindings', {})
self._appPronunciations = profilePrefs.get('pronunciations', {})
self._activeApp = script.app.name
self._loadProfileSettings()
self._mergeSettings()
self._setSettingsRuntime(self.general)
self._setPronunciationsRuntime(self.pronunciations)
script.keyBindings = self.overrideKeyBindings(script, script.getKeyBindings())
_manager = SettingsManager()
def getManager():
return _manager
| ruibarreira/linuxtrail | usr/lib/python3/dist-packages/orca/settings_manager.py | Python | gpl-3.0 | 20,476 | [
"ORCA"
] | ceb61e9c7b23c7a1988a986189b6a0de7457c3d07f3d5db55b2b811f5de5305a |
import numpy as np
import numba as nb
from numpy.random import PCG64
from timeit import timeit
bit_gen = PCG64()
next_d = bit_gen.cffi.next_double
state_addr = bit_gen.cffi.state_address
def normals(n, state):
out = np.empty(n)
for i in range((n + 1) // 2):
x1 = 2.0 * next_d(state) - 1.0
x2 = 2.0 * next_d(state) - 1.0
r2 = x1 * x1 + x2 * x2
while r2 >= 1.0 or r2 == 0.0:
x1 = 2.0 * next_d(state) - 1.0
x2 = 2.0 * next_d(state) - 1.0
r2 = x1 * x1 + x2 * x2
f = np.sqrt(-2.0 * np.log(r2) / r2)
out[2 * i] = f * x1
if 2 * i + 1 < n:
out[2 * i + 1] = f * x2
return out
# Compile using Numba
normalsj = nb.jit(normals, nopython=True)
# Must use state address not state with numba
n = 10000
def numbacall():
return normalsj(n, state_addr)
rg = np.random.Generator(PCG64())
def numpycall():
return rg.normal(size=n)
# Check that the functions work
r1 = numbacall()
r2 = numpycall()
assert r1.shape == (n,)
assert r1.shape == r2.shape
t1 = timeit(numbacall, number=1000)
+print(f'{t1:.2f} secs for {n} PCG64 (Numba/PCG64) gaussian randoms')
t2 = timeit(numpycall, number=1000)
print(f'{t2:.2f} secs for {n} PCG64 (NumPy/PCG64) gaussian randoms')
# example 2
next_u32 = bit_gen.ctypes.next_uint32
ctypes_state = bit_gen.ctypes.state
@nb.jit(nopython=True)
def bounded_uint(lb, ub, state):
mask = delta = ub - lb
mask |= mask >> 1
mask |= mask >> 2
mask |= mask >> 4
mask |= mask >> 8
mask |= mask >> 16
val = next_u32(state) & mask
while val > delta:
val = next_u32(state) & mask
return lb + val
print(bounded_uint(323, 2394691, ctypes_state.value))
@nb.jit(nopython=True)
def bounded_uints(lb, ub, n, state):
out = np.empty(n, dtype=np.uint32)
for i in range(n):
out[i] = bounded_uint(lb, ub, state)
bounded_uints(323, 2394691, 10000000, ctypes_state.value)
| grlee77/numpy | numpy/random/_examples/numba/extending.py | Python | bsd-3-clause | 1,958 | [
"Gaussian"
] | 175370b7cd6220554db3f774f579bc851f5b321d24b0e7bc1c8a8878c0661724 |
"""QM/MM interface with QM=FHI-aims, MM=gromacs
QM could be something else, but you need to read in qm-atom charges
from the qm program (in method 'get_qm_charges')
One can have many QM regions, each with a different calculator.
There can be only one MM calculator, which is calculating the whole
system.
Non-bonded interactions:
------------------------
Generally:
Within the same QM-QM:
by qm calculator
MM-MM:
by MM calculator
QM-MM:
by MM using MM vdw parameters and QM charges.
Different QM different QM:
by MM using QM and MM charges and MM-vdw parameters
The Hirschfeld charges (or other atomic charges)
on QM atoms are calculated by QM in a H terminated cluster in vacuum.
The charge of QM atom next to MM atom (edge-QM-atom)
and its H neighbors are set as in the classical force field.
The extra(missing) charge results from:
1) linkH atoms
2) The edge-QM atoms, and their qm-H neighbors,
have their original MM charges.
3) and the fact that the charge of the QM fraction
is not usually an integer when using the original MM charges.
It is added equally to all QM atoms
(not being linkH and not being edge-QM-atom or its H neighbor)
so that the total charge of the MM-fragment involving QM atoms
will be the same as in the original MM-description.
Vdw interactions are calculated by MM-gromacs for MM and MM-QM inteactions.
The QM-QM vdw interaction s could be done by the FHI-aims if desired
(by modifying the imput for QM-FHI-aims input accordingly.
Bonded interactions::
E=
E_qm(QM-H) ; qm energy of H terminated QM cluster(s)
+ E_mm(ALL ATOMS) ; mm energy of all atoms,
; except for terms in which all MM-interacting atoms are
; in the same QM region
Forces do not act on link atoms but they are positioned by scaling.
Forces on link atoms are given to their QM and MM neighbors by chain rule.
(see J. Chem. Theory Comput. 2011, 7, 761-777).
The optimal edge-qm-atom-linkH bond length is calculated
by QM in 'get_eq_qm_atom_link_h_distances'
or they are read from a file.
Questions & Comments markus.kaukonen@iki.fi
I'm especially interested in cases when we need two or more
QM regions. For instance two redox centers in a protein,
cathode and anode of a fuel cell ... you name it!
Some things to improve:
1) Water topology issue (at the moment water cannot be in QM),
Its topology should be put into the main
topology file, not in a separate file.
2) point charges and periodicity (if desired) to the QM calculation
(now in vacuum)
3) Eichinger type of link atom treatment with fitted force constants for
linkH-QMedge (bond strecth)
linkH-QMedge-QMnextTOedge (angle terms)
4) file io using unformatted formats (.trr) instead of g96
This is not easily possible without loading extra stuff from
ftp://ftp.gromacs.org/pub/contrib/xd...e-1.1.1.tar.gz.
5) Utilize gromacs-python wrapper: (just found this today 31.12.2012...)
http://orbeckst.github.com/GromacsWrapper/index.html#
"""
import sys
import numpy as np
def get_neighbor_list(system):
"""
Makes a neighbor list of a system (ase Atoms).
See
https:\
//wiki.fysik.dtu.dk/ase/ase/calculators/calculators.html#module-calculators
"""
from ase.calculators.neighborlist import NeighborList
from ase.data import covalent_radii
import os
import pickle
NEIGHBOR_FILE = 'neighbor_list_for_ase_qmmm.txt'
if os.path.exists(NEIGHBOR_FILE):
print('Reading qm/mm neighbor list from file:')
print('neighbor_list_for_ase_qmmm.txt')
myfile = open(NEIGHBOR_FILE, 'r')
neighbor_list = pickle.load(myfile)
else:
cut = [covalent_radii[atom.number] for atom in system]
skin = [0.2 for atom in system]
neighbor_list = NeighborList(cut, skin, \
self_interaction=False, bothways=True)
neighbor_list.update(system)
file = open(NEIGHBOR_FILE, 'w')
pickle.dump(neighbor_list, file)
file.close()
return neighbor_list
def get_qm_atoms(indexfilename='index.ndx'):
"""
Read the indexes of all QM atoms (there may be many QM regions)
"""
infile = open(indexfilename,'r')
lines = infile.readlines()
infile.close()
qms = []
for iline, line in enumerate(lines):
if (('[ QM' in line) or ('[ qm' in line) or ('[ Qm' in line)) \
or (('[QM' in line) or ('[qm' in line) or ('[Qm' in line)):
qm = []
for checkline in lines[iline+1:]:
if ('[') in checkline:
break
else:
qm = qm + [int(float(s)-1.0) for s in \
checkline.split() if s.isdigit()]
qm = list(set(qm))
qms.append(qm)
return qms
class LinkAtom:
"""
Class for information about a single link-atom
(it terminates a QM cluster)
qm_region_index and link_atom_index refer to the following indexing system:
[[QM0 link atoms indexes from 0],[QM1 link atoms indexes from 0],...]
So above the second link atom in second qm region would have
qm_region_index=1, link_atom_index=1
link_atom_index_in_qm tells which index in qm system the link atom has
for instance
qm_region_index=1, link_atom_index_in_qm=20
means that link atom is 21'st atom in the second qm system
"""
def __init__(self, atom, qm_region_index, link_atom_index):
""" set initial values to a link atom object """
self.atom = atom
self.qm_region_index = qm_region_index
self.link_atom_index = link_atom_index
self.link_atom_index_in_qm = None
self.qm_neighbor = None
self.mm_neighbor = None
self.qm2_neighbors = []
self.qm3_neighbors = []
self.mm2_neighbors = []
self.set_qm2_neighbors = set([])
self.set_qm3_neighbors = set([])
self.set_mm2_neighbors = set([])
self.force_constant = 0.0
self.equilibrium_distance_xh = 0.0
self.equilibrium_distance_xy = 0.0
def set_link_atom(self, atom):
""" set an ase-atom to be the link atom """
self.atom = atom
def set_link_atom_qm_region_index(self, qm_region_index):
""" set to which qm region the link atom belongs to """
self.qm_region_index = qm_region_index
def set_link_atom_index_in_qm(self, link_atom_index_in_qm):
""" set what is my link atom index in this qm region """
self.link_atom_index_in_qm = link_atom_index_in_qm
def set_link_atom_qm_neighbor(self, qm_neighbor):
""" set what index does my qm neighbor have"""
self.qm_neighbor = qm_neighbor
def set_link_atom_mm_neighbor(self, mm_neighbor):
""" set what index does my mm neighbor have"""
self.mm_neighbor = mm_neighbor
def set_link_atom_qm2_neighbors(self, qm2_neighbors):
""" set what index does my second qm neighbor have"""
self.qm2_neighbors = qm2_neighbors
def set_link_atom_qm3_neighbors(self, qm3_neighbors):
""" set what index does my third qm neighbor have"""
self.qm3_neighbors = qm3_neighbors
def set_link_atom_mm2_neighbors(self, mm2_neighbors):
""" set what index does my second mm neighbor have"""
self.mm2_neighbors = mm2_neighbors
def set_force_constant(self, force_constant):
""" set the force constant of bond edge-qm -- linkH (not used)"""
self.force_constant = force_constant
def set_equilibrium_distance_xh(self, equilibrium_distance_xh):
""" set the equilibrium edge-qm -- linkH distance """
self.equilibrium_distance_xh = equilibrium_distance_xh
def set_equilibrium_distance_xy(self, equilibrium_distance_xy):
"""set the equilibrium edge-qm --
edge-mm distance (by MM-force field)"""
self.equilibrium_distance_xy = equilibrium_distance_xy
def get_link_atom(self):
""" get an ase-atom to be the link atom """
return self.atom
def get_link_atom_qm_region_index(self):
""" get to which qm region the link atom belongs to """
return self.qm_region_index
def get_link_atom_index_in_qm(self):
""" get what is my link atom index in this qm region """
return self.link_atom_index_in_qm
def get_link_atom_qm_neighbor(self):
""" get what index does my qm neighbor have"""
return self.qm_neighbor
def get_link_atom_mm_neighbor(self):
""" get what index does my mm neighbor have"""
return self.mm_neighbor
def get_link_atom_qm2_neighbors(self):
""" get what index does my second qm neighbor have"""
return self.qm2_neighbors
def get_link_atom_qm3_neighbors(self):
""" get what index does my third qm neighbor have"""
return self.qm3_neighbors
def get_link_atom_mm2_neighbors(self):
""" get what index does my second mm neighbor have"""
return self.mm2_neighbors
def get_force_constant(self):
""" get the force constant of bond edge-qm -- linkH (not used)"""
return self.force_constant
def get_equilibrium_distance_xh(self):
""" get the equilibrium edge-qm -- linkH distance """
return self.equilibrium_distance_xh
def get_equilibrium_distance_xy(self):
"""get the equilibrium edge-qm --
edge-mm distance (by MM-force field)"""
return self.equilibrium_distance_xy
class AseQmmmManyqm:
""" This is a qm/mm interface with qm=FHI-aims, mm=gromacs.
We can have many QM regions, each with a different calculator.
There can be only one MM calculator, which is calculating the whole
system.
Numeration of atoms starts from 0. (in qms, mms)
In qm calculations link atom(s) come(s) last.
For any qm region, the optimal bond lengths for all edge_atom-link_atom
pairs are optimized by QM simultaneously at the beginning of
the run when the flag link_info='byQM' is used (by method . The positions of other a
"""
def __init__(self, nqm_regions, \
qm_calculators, mm_calculator, \
link_info='byQM'):
""" Set initial values to each qm and mm calculator.
Additionally set information for the qm/mm interface.
The information about qm and mm indexes is read from
a file 'index.ndx'
Which can be generated with a gromacs tool 'make_ndx'
http://www.gromacs.org/Documentation/Gromacs_Utilities/make_ndx
Parameters
==========
nqm_regions: int
how many qm regions
qm_calculators: list members of a Class defining a Calculator
ase-qm calculator for each qm region
mm_calculator: a member of a Class defining a Calculator
ase-mm calculator for mm (the whole system)
link_info: str
can be either
'byQM': the edge_qm_atom-link_h_atom distances are calculated by QM
'byFile':the edge_qm_atom-link_h_atom distances are read from a file
"""
from ase.io import read, write
import os, glob
# clean
files = glob.glob('test-*')
for file in files:
try:
os.remove(file)
except OSError:
pass
self.atoms = None
self.positions = None
self.neighbor_list = None
self.link_atoms = []
self.energy = None
self.e_delta_stretch = None
self.nqm_regions = nqm_regions
self.qm_calculators = qm_calculators
self.mm_calculator = mm_calculator
self.qmatom_types = []
self.mmatom_types = []
#det unique name for each qm region
# (the output file of each qm calculation)
for i in range(len(self.qm_calculators)):
self.qm_calculators[i].set(output_template = 'aims'+str(i))
self.link_systems = None
self.equilibrium_distances_xy = []
self.equilibrium_distances_xh = []
self.force_constants = []
# get the sets of qm atoms
self.qms = get_qm_atoms()
self.set_qms = set(sum(self.qms, []))
print('qmsystem(s), indexing from 0:')
print('')
for index_out in self.qms:
index_str = ''
for index in index_out:
index_str += str(index) + ' '
print ('%s' % index_str)
print('')
if ( len(self.qms) != nqm_regions):
print ('Number of set of QM atoms does not match with nqm_regions')
print ('self.qms %s' % str(self.qms))
print ('nqm_regions %s' % str(nqm_regions))
sys.exit()
if ( len(self.qms) != len(qm_calculators)):
print ('Number of set of QM atoms does not match with')
print ('the number of QM calculators')
sys.exit()
#read the actual structure to define link atoms and their neighbors
system_tmp = mm_calculator.atoms
self.positions = system_tmp.get_positions()
#get neighbor lists
self.neighbor_list = get_neighbor_list(system_tmp)
#get the mm-atoms next to link atoms for all qm regions
(self.mms_edge, self.qms_edge, self.set_mms_edge, self.set_qms_edge) = \
self.get_edge_qm_and_mm_atoms(self.qms, system_tmp)
#get the mm atoms being second neighbors to any qm atom
(self.second_mms, self.set_second_mms) = \
self.get_next_neighbors(self.mms_edge, self.set_qms)
#get the qm atoms being second neighbors to link atom
(self.second_qms, self.set_second_qms) = \
self.get_next_neighbors(self.qms_edge, \
self.set_mms_edge)
#get the qm atoms being neighbors to link atom (edge-qm atoms)
# and their neighbors which have only single neighbor
# (for example edge-QM(C)-H or edge-QM(C)=O; for charge exclusion)
self.constant_charge_qms = \
self.get_constant_charge_qms\
(self.set_qms_edge, self.set_second_qms)
#get the qm atoms being third neighbors to link atom
(self.third_qms, self.set_third_qms) = \
self.get_next_neighbors\
(self.second_qms, self.set_qms_edge)
print('self.qms %s' % self.qms)
print('QM edge, MM edge %s' \
% str(self.qms_edge)+' '+ str(self.mms_edge))
print('MM second N of Link %s' % str(self.second_mms))
print('QM second N of Link %s' % str(self.second_qms))
print('QM third N of Link %s' % str(self.third_qms))
if link_info == 'byFILE':
self.read_eq_distances_from_file()
else:
#get QM-MM bond lengths
self.get_eq_distances_xy(\
topfilename=mm_calculator.topology_filename,\
force_field= mm_calculator.force_field)
#get QM-linkH distances by QM for all link atoms
self.get_eq_qm_atom_link_h_distances(system_tmp)
# write current link-info data to file (it can be later used,
# so XH bondconstants are already calculated by QM
# Also one can manually change the XY bond lengths
self.write_eq_distances_to_file(\
self.qms_edge)
#get target charge of each qm-region
self.classical_target_charge_sums = \
self.get_classical_target_charge_sums\
(self.mm_calculator.topology_filename, self.qms)
#get a list of link H atoms
self.link_atoms = self.get_link_atoms(\
self.qms_edge, self.mms_edge,\
self.force_constants,\
self.equilibrium_distances_xh, \
self.equilibrium_distances_xy)
self.qmsystems = self.define_QM_clusters_in_vacuum(system_tmp)
for iqm, qm in enumerate(self.qmsystems):
write('test-qm-'+str(iqm)+'.xyz', qm)
#attach calculators to qm regions
for iqm, qm in enumerate(self.qmsystems):
self.qmsystems[iqm].set_calculator(self.qm_calculators[iqm])
#attach calculators to the mm region (the whole system)
self.mm_system = system_tmp
self.mm_system.set_calculator(self.mm_calculator)
#initialize total energy and forces of qm regions
#and the mm energy
self.qm_energies = []
self.qm_forces = []
self.qm_charges = []
self.sum_qm_charge = []
for iqm, qm in enumerate(self.qmsystems):
self.qm_energies.append(0.0)
self.qm_forces.append(None)
self.qm_charges.append(None)
self.sum_qm_charge.append(None)
self.mm_energy = None
#set initial zero forces
self.forces = np.zeros((len(self.positions), 3))
self.charges = np.zeros((len(self.positions), 1))
try:
os.remove(self.mm_calculator.topology_filename+'.orig')
except:
pass
print('%s' % str(self.mm_calculator.topology_filename))
os.system('cp ' + self.mm_calculator.topology_filename + ' ' +\
self.mm_calculator.topology_filename + '.orig')
#remove some classical bonded interaction in the topology file
# this need to be done only once, because the bond topology
# is unchanged during a QM/MM run
#(QM charges can be updated in the topology, however)
# the original topology is generated when calling Gromacs(
# in the main script setting up QM, MM and minimization
if (self.mm_calculator.name == 'Gromacs'):
self.kill_top_lines_containing_only_qm_atoms\
(self.mm_calculator.topology_filename, self.qms, \
self.mm_calculator.topology_filename)
else:
print('Only Gromacs MM-calculator implemented in ASE-QM/MM')
sys.exit()
#exclude qm-qm non-bonded interactions in MM-gromacs
self.add_exclusions()
#generate input file for gromacs run
self.mm_calculator.generate_gromacs_run_file()
######### end of Init #####################################
def get_forces(self, atoms):
"""get forces acting on all atoms except link atoms """
self.update(atoms)
return self.forces
def get_potential_energy(self, atoms):
""" get the total energy of the MM and QM system(s) """
self.update(atoms)
return self.energy
def update(self, atoms):
"""Updates and does a check to see if a calculation is required"""
if self.calculation_required(atoms):
# performs an update of the atoms and qm systems
self.atoms = atoms.copy()
self.positions = atoms.get_positions()
self.mm_system = atoms.copy()
#get the positions of link H atoms
self.link_atoms = self.get_link_atoms(\
self.qms_edge, self.mms_edge,\
self.force_constants,\
self.equilibrium_distances_xh, \
self.equilibrium_distances_xy)
#get QM systens
self.qmsystems = self.define_QM_clusters_in_vacuum(\
self.atoms)
self.calculate(atoms)
def calculation_required(self, atoms):
"""Checks if a calculation is required"""
if ((self.positions is None) or
(self.atoms != atoms) or
(self.energy is None)):
return True
return False
def calculate_mm(self):
""" Calculating mm energies and forces """
import os
mm = self.atoms
mm.set_calculator(self.mm_calculator)
if (self.mm_calculator.name == 'Gromacs'):
try:
os.remove(self.mm_calculator.base_filename+'.log')
except:
pass
self.mm_calculator.update(mm)
self.mm_energy = 0
self.mm_energy += mm.get_potential_energy()
self.forces += mm.get_forces()
def calculate_qms(self):
""" QM calculations on all qm systems are carried out """
for iqm, qm in enumerate(self.qmsystems):
qm.set_calculator(self.qm_calculators[iqm])
self.qm_energies[iqm] = qm.get_potential_energy()
self.qm_forces[iqm] = np.zeros((len(qm), 3))
self.qm_forces[iqm] = qm.get_forces()
(self.sum_qm_charge[iqm], self.qm_charges[iqm]) = \
self.get_qm_charges(iqm,
number_of_link_atoms =\
len(self.qms_edge[iqm]))
if (len(self.qms[iqm]) != len(self.qm_charges[iqm])):
print('Problem in reading charges')
print('len(self.qms[iqm]) %s' % str(len(self.qms[iqm])))
print('len(self.qm_charges[iqm]) %s' \
% str(len(self.qm_charges[iqm])))
print('Check the output of QM program')
print('iqm, qm %s' % str(iqm)+ ' '+ str(qm))
print('self.qm_charges[iqm] %s' % str(self.qm_charges[iqm]))
sys.exit()
def calculate_single_qm(self, myqm, mycalculator):
""" Calculate the qm energy of a single qm region
(for X-H bond length calculations)
"""
myqm.set_calculator(mycalculator)
return myqm.get_potential_energy()
def run(self, atoms):
"""Runs QMs and MM"""
self.forces = np.zeros((len(atoms), 3))
self.calculate_qms()
# update QM charges to MM topology file
self.set_qm_charges_to_mm_topology()
#generate gromacs run file (.tpr) base on new topology
self.mm_calculator.generate_gromacs_run_file()
self.calculate_mm()
def calculate(self, atoms):
"""gets all energies and forces (qm, mm, qm-mm and corrections)"""
self.run(atoms)
self.energy = sum(self.qm_energies)+self.mm_energy
#map the forces of QM systems to all atoms
#loop over qm regions
for qm, qm_force in zip(self.qms, self.qm_forces):
#loop over qm atoms in a qm region
#set forces to the all-atom set (the all atom set does not
# have link atoms)
for iqm_atom, qm_atom in enumerate(qm):
self.forces[qm_atom] = self.forces[qm_atom] + \
qm_force[iqm_atom]
self.get_link_atom_forces(action = 'QM')
def get_link_atoms(self, qm_links, mm_links, \
force_constants,\
equilibrium_distances_xh, equilibrium_distances_xy):
"""
QM atoms can be bonded to MM atoms. In this case one sets
an extra H atom (a link atom).
The positions of the all link H atoms in all qm regions are
set along QM-MM and bond with length defined by:
J. Chem. Theory Comput 2011, 7, 761-777, Eq 1
r_XH = r_XY_current*(r_XH_from_qm_calculation /r_XY_from_forceField)
"""
import math
from ase import Atom
link_hs = []
for i_qm_region, (qm0, mm0) in enumerate (zip( qm_links, mm_links)):
for i_link_atom, (qmatom, mmatom) in enumerate (zip(qm0, mm0)):
dx = (self.positions[mmatom, 0] - self.positions[qmatom, 0])
dy = (self.positions[mmatom, 1] - self.positions[qmatom, 1])
dz = (self.positions[mmatom, 2] - self.positions[qmatom, 2])
d = math.sqrt(dx* dx+ dy* dy+ dz* dz)
unit_x = dx/ d
unit_y = dy/ d
unit_z = dz/ d
xh_bond_length = \
d*\
self.equilibrium_distances_xh[i_qm_region][i_link_atom]/\
self.equilibrium_distances_xy[i_qm_region][i_link_atom]
posh_x = self.positions[qmatom, 0] + unit_x* xh_bond_length
posh_y = self.positions[qmatom, 1] + unit_y* xh_bond_length
posh_z = self.positions[qmatom, 2] + unit_z* xh_bond_length
tmp_link_h = (Atom('H', position=(posh_x, posh_y, posh_z)))
link_h = LinkAtom(atom=tmp_link_h, \
qm_region_index = i_qm_region,\
link_atom_index = i_link_atom)
link_h.set_link_atom_qm_neighbor(qmatom)
link_h.set_link_atom_mm_neighbor(mmatom)
link_h.set_force_constant(\
force_constants[i_qm_region][i_link_atom])
link_h.set_equilibrium_distance_xh(equilibrium_distances_xh\
[i_qm_region][i_link_atom])
link_h.set_equilibrium_distance_xy(equilibrium_distances_xy\
[i_qm_region][i_link_atom])
link_hs.append(link_h)
return (link_hs)
def get_link_atom_forces(self, action):
""" Add forces due to link atom to QM atom
and to MM atom next to each link atom.
Top Curr Chem (2007) 268: 173-290
QM/MM Methods for Biological Systems
Hans Martin Senn and Walter Thiel
Eqs. 10(p192), 12(p193), 16a, 16b(p 194)
"""
for link_atom in self.link_atoms:
i_qm_atom = link_atom.qm_neighbor
i_mm_atom = link_atom.mm_neighbor
i_qm_region = link_atom.qm_region_index
link_atom_index_in_qm = link_atom.get_link_atom_index_in_qm()
if (action == 'QM'):
force_of_h = self.qm_forces[i_qm_region][link_atom_index_in_qm]
elif (action == 'MM'):
force_of_h = link_atom.mm_force
else:
print('not implemented in get_link_atom_forces')
sys.exit()
g = link_atom.equilibrium_distance_xh/\
link_atom.equilibrium_distance_xy
self.forces[i_mm_atom, 0] = self.forces[i_mm_atom, 0] +\
force_of_h[0] * g
self.forces[i_mm_atom, 1] = self.forces[i_mm_atom, 1] +\
force_of_h[1] * g
self.forces[i_mm_atom, 2] = self.forces[i_mm_atom, 2] +\
force_of_h[2] * g
self.forces[i_qm_atom, 0] = self.forces[i_qm_atom, 0] +\
force_of_h[0] * (1.0 - g)
self.forces[i_qm_atom, 1] = self.forces[i_qm_atom, 1] +\
force_of_h[1] * (1.0 - g)
self.forces[i_qm_atom, 2] = self.forces[i_qm_atom, 2] +\
force_of_h[2] * (1.0 - g)
def add_energy_exclusion_group(self, indexfilename='index.ndx'):
"""
Add energy exclusions for MM calculations.
This is the way to block non-bonded MM (coulomb&vdW)
interactions within a single QM region.
"""
infile = open(indexfilename,'r')
lines = infile.readlines()
infile.close()
qm_region_names = []
for line in lines:
if (('QM' in line) or ('Qm' in line) or ('qm' in line)):
qm_region_names.append(line.split()[1])
infile = open(self.mm_calculator.base_filename+'.mdp','r')
lines = infile.readlines()
infile.close()
outfile = open(self.mm_calculator.base_filename+'.mdp','w')
for line1 in lines:
outfile.write(line1)
outfile.write(';qm regions should not MM-interact with themselves \n')
outfile.write(';but separate qm regions MM-interact with each other \n')
outfile.write('energygrps = ')
for name in qm_region_names:
outfile.write(name + ' ')
outfile.write('\n')
outfile.write('energygrp_excl = ')
for name in qm_region_names:
outfile.write(name + ' ' + name + ' ')
outfile.write('\n')
outfile.close()
return
def add_exclusions(self):
"""
Add energy exclusions for MM calculations.
This is the way to block non-bonded MM (coulomb&vdW)
interactions within a single QM region.
"""
infile = open(self.mm_calculator.topology_filename,'r')
lines = infile.readlines()
infile.close()
outfile = open(self.mm_calculator.topology_filename,'w')
for line in lines:
if '[ angle' in line:
outfile.write('\n')
outfile.write('[ exclusions ] \n')
outfile.write(\
'; qm regions should not MM-interact with themselves \n')
outfile.write(\
'; but separate qm regions MM-interact with each other \n')
for qm_region in self.qms:
for qm_atom1 in qm_region:
outfile.write(str(qm_atom1 + 1) + ' ')
for qm_atom2 in qm_region:
if qm_atom1 != qm_atom2:
outfile.write(str(qm_atom2 + 1) + ' ')
outfile.write('\n')
outfile.write('\n')
outfile.write(line)
outfile.close()
return
def get_qm_charges(self, i_current_qm, calculator='Aims',
number_of_link_atoms = 0):
"""
Get partial charges on QM atoms.
The charges at link atoms are not returned.
"""
if calculator == 'Aims':
infile = open('aims'+str(i_current_qm)+'.out','r')
lines = infile.readlines()
infile.close()
qm_charges = []
for line in lines:
if ('Hirshfeld charge ' in line):
qm_charges.append(float(line.split()[4]))
sum_qm_charges = sum(qm_charges)
#delete charges of link atoms
if (number_of_link_atoms > 0):
del qm_charges[-number_of_link_atoms:]
return sum_qm_charges, qm_charges
def get_topology_lines(self, lines):
""" Get lines including charges of atoms (ok_lines)
also comments in these lines (comment_lines)
and lines before and after these lines
(lines_before and lines_after)
"""
lines_before = []
lines_change = []
lines_after = []
do_lines_before = True
do_lines_change = False
for line in lines:
if (' bonds ') in line:
do_lines_change = False
if do_lines_before:
lines_before.append(line)
elif do_lines_change:
lines_change.append(line)
else:
lines_after.append(line)
if (' atoms ') in line:
do_lines_before = False
do_lines_change = True
#kill comments and empty lines,
#get the charge in the topology file
comment_lines = []
lines_ok = []
for iline in range(len(lines_change)):
if lines_change[iline].startswith(';'):
comment_lines.append(lines_change[iline])
elif not lines_change[iline].strip():
pass
else:
try:
#new charge = float(lines_change[iline].split()[6])
#new charge_orig = charge_orig + charge
#top_charge.append(charge)
lines_ok.append(lines_change[iline])
except:
print('error in reading gromacs topology')
print('line is')
print('%s' % lines_change[iline])
sys.exit()
return lines_before, comment_lines, lines_ok, lines_after
def set_qm_charges_to_mm_topology(self):
""" Set qm charges to qm atoms of MM topology based on
a QM calculation.
1) The charges of link atoms are neglected.
2) The charge of a qm atom next to the link atom is set to be the
same value as in the original topology file. (trying to
avoid the artificial polarization due to qmAtom-linkH).
3) the total charge of the system (all QM and MM atoms) should be
the same as in the original classical system. Therefore, all the
QM atoms will gain/loose an equal amount of charge in the MM topology
file.
"""
infile = open(self.mm_calculator.topology_filename,'r')
lines = infile.readlines()
infile.close()
(lines_before, comment_lines, lines_ok, lines_after) = \
self.get_topology_lines(lines)
#check that the atom numering is ok
for iline in range(len(lines_ok)):
atom_nr = iline + 1
if int(lines_ok[iline].split()[0]) != atom_nr:
print('2: error in reading gromacs topology')
print('line is')
print('%s' % lines_ok[iline])
sys.exit()
# get the total charge of non-link H atoms in the current qm system
# The charges of edge atoms and their H neighbors
# are taken from topology
# (they are unchanged, it is not from QM calculations)
for iqm, qm in enumerate(self.qms):
charges = self.qm_charges[iqm]
charges_ok = charges
qm_charge_no_link_edge_mm = 0.0
n_qm_charge_atoms = 0
for qm_atom, charge in zip(qm, charges):
if qm_atom not in self.constant_charge_qms:
qm_charge_no_link_edge_mm = \
qm_charge_no_link_edge_mm + charge
n_qm_charge_atoms = n_qm_charge_atoms + 1
# correct the total charge to be equal the original one
# in the topology file by
# adding/ substracting missing/extra charge on
# non-edge and non-single neighbor next neib QM atoms
change_charge = \
( self.classical_target_charge_sums[iqm] - \
qm_charge_no_link_edge_mm)/\
float(n_qm_charge_atoms)
for iqmatom, qmatom in enumerate(qm):
if qmatom not in self.constant_charge_qms:
charges_ok[iqmatom] = charges[iqmatom] + change_charge
# set qm charges to the lines of gromacs topology file
for iqmatom, qmatom in enumerate(qm):
if qmatom not in self.constant_charge_qms:
lines_ok[qmatom] = \
lines_ok[qmatom][0:45]\
+str(round((charges_ok[iqmatom]),5)).rjust(11)+\
lines_ok[qmatom][56:70]
# write out the new topology file
sum_charge = 0.0
for iline in range(len(lines_ok)):
sum_charge = sum_charge + float(lines_ok[iline][46:56])
comment = '; qtot '+str(round(sum_charge,4))+'\n'.ljust(12)
outfile = open(self.mm_calculator.topology_filename, 'w')
for line in lines_before:
outfile.write(line)
for line in comment_lines:
outfile.write(line)
sum_charge = 0.0
for line in lines_ok:
sum_charge = sum_charge + float(line[46:56])
comment = '; qtot '+str(round(sum_charge,4)).ljust(11)+'\n'
outfile.write(line[0:70]+comment)
outfile.write('\n')
for line in lines_after:
outfile.write(line)
outfile.close()
#------------------------------------------------------------------
#------Below the stuff needed for initializing the QM/MM system ---
#------Setting up link atoms, defining QM and MM regions ----------
#------------------------------------------------------------------
def get_edge_qm_and_mm_atoms(self, qms, system):
""" Get neighbors of QM atoms (MM-link-atoms) that are not in QM
(there may be many QM regions)
edge-QM atom can NOT be neighbored by H atom(s)
also get edge-QM atoms
"""
masses = system.get_masses()
mms1 = []
qms1 = []
setmms1 = set([])
setqms1 = set([])
for qm in qms:
link_mm_atoms = []
link_qm_atoms = []
for qm_atom in qm:
indices, offsets = self.neighbor_list.get_neighbors(qm_atom)
for neib_atom in indices:
if neib_atom not in qm:
link_mm_atoms.append(neib_atom)
#take unique atoms of flattened list
link_mm_atoms = list(set(link_mm_atoms))
# Kill MM atoms that are H atoms in the neighborlist
oklink_mm_atoms = []
for index in link_mm_atoms:
if masses[index] > 1.5:
oklink_mm_atoms.append(index)
else:
print('WARNING:')
print('qm system cannot be bond to H atoms')
print('problem atom index is (numbering from 1): %s' \
% str(index+1))
print('if this is water H you should consider including it')
print('in QM')
#sys.exit()
#get indexes of QM edge atoms,
# one qm atom can be more then one time an edge atom
# (then this QM atom will have more than one link atoms)
for link_mm_atom in oklink_mm_atoms:
indices, offsets = \
self.neighbor_list.get_neighbors(link_mm_atom)
for neib_atom in indices:
if neib_atom in qm:
link_qm_atoms.append(neib_atom)
mms1.append(oklink_mm_atoms)
qms1.append(link_qm_atoms)
setmms1 |= set(oklink_mm_atoms)
setqms1 |= set(link_qm_atoms)
return mms1, qms1, setmms1, setqms1
def get_next_neighbors(self, atom_indexes, prohibited_set):
""" Get neighbors of all atoms in 'atom_indexes'
that are not in 'prohibited_set'.
'atom_indexes' is a list of list in which atom indexes belonging
of each QM region is a separate list, that is
[[QM1 atom_indexes], [QM2 atom_indexes], ...]
"""
list_neibs = []
set_list_neibs = set([])
for current_atoms in atom_indexes:
neibs = []
set_current_atoms = set(current_atoms)
for current_atom in current_atoms:
indices, offsets = \
self.neighbor_list.get_neighbors(current_atom)
setneib = set(indices)
neibs += list(setneib - set_current_atoms-prohibited_set)
list_neibs.append(neibs)
set_list_neibs |= set(neibs)
return list_neibs, set_list_neibs
def get_constant_charge_qms(self, set_qms_edge, set_second_qms):
""" get indices of all qm atoms whose charge in MM
calculations is taken from the original MM-topology
(not from the QM calculation). These atoms are edge QM atoms
and their neighbors in QM which have only one neighbor.
At least C(edge-qm)-H(second-edge-qm) and C(edge-qm)=O(second-edge-qm)
"""
set_charge_exclusion = set_qms_edge
for second_qms in set_second_qms:
indices, offsets = self.neighbor_list.get_neighbors(second_qms)
if len(indices)== 1:
set_charge_exclusion.add(second_qms)
return set_charge_exclusion
def get_eq_distances_xy(\
self, topfilename = 'gromos.top', force_field = 'oplsaa'):
"""
The link atom is positioned as in
J. Chem. Theory Comput 2011, 7, 761-777, Eq 1
For this purpose we need the equilibrium length of each
QM-MM covalent bond. Those are obtained here from the
files of the force field.
"""
import os
print('in get_eq_distances_xy, topfilename=')
print ('%s' % topfilename)
for qm in self.qms_edge:
equilibrium_distance_xy = []
for iqm in qm:
equilibrium_distance_xy.append(0.0)
self.equilibrium_distances_xy.append(equilibrium_distance_xy)
#get the version of the topology file where one sees the bond
# force constants (file is named as gromacs.top.dump)
try:
os.remove(self.mm_calculator.base_filename+'.tpr.dump')
except OSError:
pass
os.system('gmxdump -s '+ self.mm_calculator.base_filename\
+'.tpr > ' + \
self.mm_calculator.base_filename+ \
'.tpr.dump 2>/dev/null')
if 'GMXDATA' in os.environ:
gromacs_home = os.environ['GMXDATA'].split(':')[0]
else:
gromacs_home = '/usr/local/gromacs/share/gromacs/'
#read the bonded force constants of this force field in order to
#get an estimate for X-Y bond constant
linesff = open(gromacs_home+ '/top/'+ force_field+ \
'.ff/ffbonded.itp', 'r').readlines()
oklinesff = []
start = False
for line in linesff:
if 'bondtypes' in line:
start = True
elif '[' in line:
break
if start and (line.strip()):
oklinesff.append(line)
#lines for getting oplsaa atom dual-types
if 'opls' in force_field:
lines_for_dual_types = open(gromacs_home+ '/top/'+ force_field+ \
'.ff/ffnonbonded.itp', 'r').readlines()
#read the types of interaction for bond stretching
lines_tpr = open(self.mm_calculator.base_filename+\
'.tpr.dump', 'r').readlines()
#read the topology file to get QM atom type
lines_top = open(topfilename, 'r').readlines()
oklines_top = []
start = False
for line in lines_top:
if start and ('[' in line):
break
if start:
if (not line.startswith(';')) or (not line.strip()):
oklines_top.append(line)
if '[ atoms' in line:
start = True
#get force constant and bond eq distance for all QM-MM bonds
#
ok_equilibrium_distances_xy = []
ok_qmatom_types = []
ok_mmatom_types = []
for qm0, mm0, eqsxy in zip(
self.qms_edge, self.mms_edge, \
self.equilibrium_distances_xy):
ok_eqxy = []
ok_qmatom_type = []
ok_mmatom_type = []
for qmatom, mmatom, eqxy in \
zip(qm0, mm0, eqsxy):
#find qm-mm bond in topology file (indexes from 0)
# get the index for interaction
interaction = 'empty'
for line in lines_tpr:
if (' type' in line) and ('BONDS' in line):
if (qmatom == int(line.split()[3])) and \
(mmatom == int(line.split()[4])):
interaction = line.split()[1].lstrip('type=')
break
if (qmatom == int(line.split()[4])) and \
(mmatom == int(line.split()[3])):
interaction = line.split()[1].lstrip('type=')
break
if interaction == 'empty':
print('QM-MM bond not found in topology')
print('atoms are: QM, MM: (from 1 indexing) %s' \
% str(qmatom+1) + str(mmatom+1))
sys.exit()
for line in lines_tpr:
if ('functype['+interaction+']=BONDS') in line:
r_xy0 = float(line.split()[2].rstrip(','))
#get type of the QM atom
qmatom_type = 'empty'
for line in oklines_top:
if (int(line.split()[0] ) == qmatom+ 1):
qmatom_type = line.split()[1]
#oplsaa atom type has a double name,
#the other one is used in file ffbonded.itp
break
if (qmatom_type == 'empty'):
print('problem in QM atom type')
sys.exit()
if 'opls' in force_field:
found = False
for line in lines_for_dual_types:
if (qmatom_type == line.split()[0]):
qmatom_type = line.split()[1]
found = True
break
if not found:
print('problem in QM atom type')
print('with OPLSAA force field dual atom types')
sys.exit()
#get type of the true link-MM atom
mmatom_type = 'empty'
for line in oklines_top:
if (int(line.split()[0] ) == mmatom+ 1):
mmatom_type = line.split()[1]
#oplsaa atom type has a double name,
#the other one is used in file ffbonded.itp
break
if (mmatom_type == 'empty'):
print('problem in MM atom type')
sys.exit()
if 'opls' in force_field:
found = False
for line in lines_for_dual_types:
if (mmatom_type == line.split()[0]):
mmatom_type = line.split()[1]
found = True
break
if not found:
print('problem in MM atom type')
print('with OPLSAA force field dual atom types')
sys.exit()
ok_qmatom_type.append(qmatom_type)
ok_mmatom_type.append(mmatom_type)
if (eqxy != 0.0):
#use eq constant given by the user
ok_eqxy.append(eqxy)
else:
ok_eqxy.append(r_xy0)
ok_equilibrium_distances_xy.append(ok_eqxy)
ok_qmatom_types.append(ok_qmatom_type)
ok_mmatom_types.append(ok_mmatom_type)
outfile = open('qm-mm-linkAtomsInfo.txt','w')
outfile.write(\
'=======================================================\n')
outfile.write('Information about QM-MM boundary(ies) \n')
outfile.write(\
'Created using the Atomic Simulation Environment (ASE) \n')
outfile.write(\
'=======================================================\n')
qmregion_count = 0
# ADD qm-mm-linkAtomsInfo.txt
for qm, mm, eqs_xy, eqs_xh, qmtypes, mmtypes in zip\
(self.qms_edge, self.mms_edge, ok_equilibrium_distances_xy,\
self.equilibrium_distances_xh,\
ok_qmatom_types, ok_mmatom_types):
outfile.write(\
'=======================================================\n')
qmregion_count = qmregion_count+ 1
outfile.write('Parameters related to QM region number '+\
str(qmregion_count)+'\n')
for qmatom, mmatom, eq_xy, eq_xh, qmtype, mmtype in zip\
(qm, mm, eqs_xy, eqs_xh,\
qmtypes, mmtypes):
outfile.write('qm-link-atom-index (from 1): '+str(qmatom)+'\n')
outfile.write('qm-link-atom-type: '+str(qmtype)+'\n')
outfile.write('mm-link-atom-index (from 1): '+str(mmatom)+'\n')
outfile.write('mm-link-atom-type: '+str(mmtype)+'\n')
outfile.write('qm-mm(notH)-equilibrium-distance: '\
+str(eq_xy)+' nm\n')
outfile.write('qm-H-equilibrium-distance(calculated by QM): '\
+str(eq_xh)+' nm\n')
outfile.close()
self.equilibrium_distances_xy = ok_equilibrium_distances_xy
self.qmatom_types = ok_qmatom_types
self.mmatom_types = ok_mmatom_types
return
def write_eq_distances_to_file(
self,
qm_links, filename='linkDATAout.txt'):
"""
Write classical bond equilibrium lengths
for XY (X in QM, Y in MM)
Write QM calculated XH(link atom) bond length (X in QM, H link atom)
"""
outfile = open(filename, 'w')
for iqm_region, qmlink in enumerate (qm_links):
for ilink, dummy in enumerate (qmlink):
data = self.equilibrium_distances_xy[iqm_region][ilink]
outfile.write(str(data)+' ')
outfile.write('\n')
data = self.equilibrium_distances_xh[iqm_region][ilink]
outfile.write(str(data)+' ')
outfile.write('\n')
data = self.force_constants[iqm_region][ilink]
outfile.write(str(data)+' ')
outfile.write('\n')
data = self.qmatom_types[iqm_region][ilink]
outfile.write(str(data)+' ')
outfile.write('\n')
data = self.mmatom_types[iqm_region][ilink]
outfile.write(str(data)+' ')
outfile.write('\n')
outfile.close()
return
def read_eq_distances_from_file(self, filename='linkDATAin.txt'):
"""
Read classical bond equilibrium lengths
for XY (X in QM, Y in MM) or XH (X in QM, H link atom)
"""
myfile = open(filename, 'r')
self.equilibrium_distances_xy = []
self.equilibrium_distances_xh = []
self.force_constants = []
self.qmatom_types = []
self.mmatom_types = []
print('Reading X-H and other data from file: %s' % filename)
for qm in self.qms_edge:
equilibrium_distance_xy = []
equilibrium_distance_xh = []
force_constant = []
qmatom_type = []
mmatom_type = []
for iqm, dum in enumerate(qm):
line = myfile.readline()
equilibrium_distance_xy.append(float(line.split()[0]))
line = myfile.readline()
equilibrium_distance_xh.append(float(line.split()[0]))
line = myfile.readline()
force_constant.append(float(line.split()[0]))
line = myfile.readline()
qmatom_type.append(line.split()[0])
line = myfile.readline()
mmatom_type.append(line.split()[0])
self.equilibrium_distances_xy.append(equilibrium_distance_xy)
self.equilibrium_distances_xh.append(equilibrium_distance_xh)
self.force_constants.append(force_constant)
self.qmatom_types.append(qmatom_type)
self.mmatom_types.append(mmatom_type)
myfile.close()
return
def get_eq_qm_atom_link_h_distances(self, system_tmp):
""" get equilibrium QMatom-linkH distances
for all linkH:s
by QM """
#import matplotlib
#matplotlib.use('Agg')
#import matplotlib.pyplot as plt
from scipy.optimize import fmin
def qm_bond_energy_function(x, system_tmp, i_qm_region):
""" get the qm energy of a single qm system with a given
edge-qm-atom---link-h-atom distances of that qm region
The qm region is i_qm_region, all
edge-qm-atom---link-h-atom distance in this qm_region are
optimized simultaneously
"""
BIG_VALUE = 100000000.0
for index_x, current_x in enumerate(x):
self.equilibrium_distances_xh\
[i_qm_region][index_x] = current_x
print('current X-H bond lengths [nm]')
print('%s' % str(x))
self.link_atoms = self.get_link_atoms(\
self.qms_edge, self.mms_edge,\
self.force_constants,\
self.equilibrium_distances_xh, \
self.equilibrium_distances_xy)
self.qmsystems = \
self.define_QM_clusters_in_vacuum(system_tmp)
#try:
single_qm_energy = self.calculate_single_qm(\
self.qmsystems[i_qm_region],\
self.qm_calculators[i_qm_region])
#except RuntimeError:
# single_qm_energy = BIG_VALUE
return single_qm_energy
print('=====================================================')
print('Calculating X-H bond lengths and bond force constants')
print('by QM in one shot for each QM region.')
print('In later calculations you can: ')
print('cp linkDATAout.txt linkDATAin.txt')
print("and set link_info = 'byFILE'")
print('=====================================================')
self.equilibrium_distances_xh = []
self.force_constants = []
for qm_edges in self.qms_edge:
force_constants = []
equilibrium_distances_xh = []
for qm_edge in qm_edges:
force_constants.append(0.0)
equilibrium_distances_xh.append(0.11)
self.force_constants.append(force_constants)
self.equilibrium_distances_xh.append(equilibrium_distances_xh)
#loop over qm regions. To get optimal simultaneous
# edgeQMatom-linkH distance(s) in [nm] in that qm region
for i_qm_region in range(len(self.qms_edge)):
print('NOW running : ')
print('QM region for optimising edge-linkH distances %s'\
% str(i_qm_region))
x = self.equilibrium_distances_xh[i_qm_region][:]
xopt = fmin(qm_bond_energy_function, \
x,\
args=(system_tmp, i_qm_region),\
xtol=0.0001, ftol=0.0001)
for index_xopt, current_xopt in enumerate(xopt):
self.equilibrium_distances_xh\
[i_qm_region][index_xopt] = current_xopt
print('i_qm_region, i_link_atom, optimal X-H bond[nm] %s' \
% (str(i_qm_region) + ' ' + str(index_xopt) \
+ ' ' + str(current_xopt)))
def define_QM_clusters_in_vacuum(self, system):
""" Returns Each QM system as an Atoms object
We get a list of these Atoms objects
(in case we have many QM regions).
"""
from ase import Atoms
qmsystems = []
for qm0 in self.qms:
tmp_system = Atoms()
for qmatom in qm0:
tmp_system += system[qmatom]
qmsystems.append(tmp_system)
for link_atom in self.link_atoms:
tmp_atom = link_atom.get_link_atom()
qm_region = link_atom.get_link_atom_qm_region_index()
link_atom_index_in_qm = len(qmsystems[qm_region])
qmsystems[qm_region].append(tmp_atom)
link_atom.set_link_atom_index_in_qm(link_atom_index_in_qm)
return qmsystems
def kill_top_lines_containing_only_qm_atoms(self, \
intopfilename, \
qms, outtopfilename):
"""
Delete all lines in the topology file that contain only qm atoms
in bonded sections
(bonds, angles or dihedrals)
and in pairs section (1-4 interactions)
"""
# get an index of all qm atoms in all qm regions
qm = set()
for qm_tmp in qms:
qm = qm.union(set(qm_tmp))
infile = open(intopfilename,'r')
lines = infile.readlines()
infile.close()
outfile = sys.stdout
oklines = []
accept = True
check = ''
for line in lines:
if (('[ bonds' in line)):
oklines.append(line)
accept = False
check = 'bond'
elif (('[ angles' in line)):
oklines.append(line)
accept = False
check = 'angle'
elif (('[ dihedrals' in line)):
oklines.append(line)
accept = False
check = 'dihedral'
elif (('[ pairs' in line)):
oklines.append(line)
accept = False
check = 'pair'
elif ('[' in line):
oklines.append(line)
accept = True
check = ''
elif line in ['\n']:
oklines.append(line)
accept = True
check = ''
elif accept:
oklines.append(line)
else:
indexes = [int(float(s)-1.0) \
for s in line.split() if s.isdigit()]
indexes1 = [int(s) for s in line.split() if s.isdigit()]
if indexes == []:# this takes comment line
#after bond, angle, dihedral
oklines.append(line)
elif check == 'bond':
bondedatoms = set(indexes[0:2])
#set empty bond intereaction for qm-qm bonds (type 5)
#(this way LJ and electrostatics is not messed up)
if (bondedatoms.issubset(qm)):
newline = str(indexes1[0]).rjust(8)+\
str(indexes1[1]).rjust(8)+\
('5').rjust(8) + '\n'
oklines.append(newline)
else:
oklines.append(line)
elif check == 'angle':
bondedatoms = set(indexes[0:3])
if (bondedatoms.issubset(qm)):
pass
else:
oklines.append(line)
elif check == 'dihedral':
bondedatoms = set(indexes[0:4])
if (bondedatoms.issubset(qm)):
pass
else:
oklines.append(line)
elif check == 'pair':
bondedatoms = set(indexes[0:2])
if (bondedatoms.issubset(qm)):
pass
else:
oklines.append(line)
outfile = open(outtopfilename,'w')
for line in oklines:
outfile.write(line)
outfile.close()
return
def get_classical_target_charge_sums(self, intopfilename, qms):
""" get sum of MM charges of the charged changed by QM
these are qm atoms that are not link-atoms or edge-qm atoms
xxx this has a problem:
Water is in .itp files, not in topology...
"""
infile = open(intopfilename,'r')
lines = infile.readlines()
infile.close()
(lines_before, comment_lines, ok_lines, lines_after) = \
self.get_topology_lines(lines)
classical_target_charge_sums = []
for iqm, qm in enumerate(qms):
classical_target_charge_sum = 0.0
for line in ok_lines:
atom_index = int(line.split()[0])-1
if (atom_index in qm) and \
(not(atom_index in self.constant_charge_qms)):
classical_target_charge_sum = \
classical_target_charge_sum + \
float(line.split()[6])
classical_target_charge_sums.\
append(classical_target_charge_sum)
return classical_target_charge_sums
| grhawk/ASE | tools/ase/calculators/ase_qmmm_manyqm.py | Python | gpl-2.0 | 60,409 | [
"ASE",
"FHI-aims",
"GROMOS",
"Gromacs"
] | fcc2b73a7ef104bc86b97372b1a667fe976150aadaed018b99adccbea8931362 |
#!/usr/bin/env python
##################################################
## DEPENDENCIES
import sys
import os
import os.path
try:
import builtins as builtin
except ImportError:
import __builtin__ as builtin
from os.path import getmtime, exists
import time
import types
from Cheetah.Version import MinCompatibleVersion as RequiredCheetahVersion
from Cheetah.Version import MinCompatibleVersionTuple as RequiredCheetahVersionTuple
from Cheetah.Template import Template
from Cheetah.DummyTransaction import *
from Cheetah.NameMapper import NotFound, valueForName, valueFromSearchList, valueFromFrameOrSearchList
from Cheetah.CacheRegion import CacheRegion
import Cheetah.Filters as Filters
import Cheetah.ErrorCatchers as ErrorCatchers
##################################################
## MODULE CONSTANTS
VFFSL=valueFromFrameOrSearchList
VFSL=valueFromSearchList
VFN=valueForName
currentTime=time.time
__CHEETAH_version__ = '2.4.4'
__CHEETAH_versionTuple__ = (2, 4, 4, 'development', 0)
__CHEETAH_genTime__ = 1447321436.252264
__CHEETAH_genTimestamp__ = 'Thu Nov 12 18:43:56 2015'
__CHEETAH_src__ = '/home/knuth/openpli-oe-core/build/tmp/work/fusionhd-oe-linux/enigma2-plugin-extensions-openwebif/1+gitAUTOINC+5837c87afc-r0/git/plugin/controllers/views/web/epgservicenow.tmpl'
__CHEETAH_srcLastModified__ = 'Thu Nov 12 18:43:41 2015'
__CHEETAH_docstring__ = 'Autogenerated by Cheetah: The Python-Powered Template Engine'
if __CHEETAH_versionTuple__ < RequiredCheetahVersionTuple:
raise AssertionError(
'This template was compiled with Cheetah version'
' %s. Templates compiled before version %s must be recompiled.'%(
__CHEETAH_version__, RequiredCheetahVersion))
##################################################
## CLASSES
class epgservicenow(Template):
##################################################
## CHEETAH GENERATED METHODS
def __init__(self, *args, **KWs):
super(epgservicenow, self).__init__(*args, **KWs)
if not self._CHEETAH__instanceInitialized:
cheetahKWArgs = {}
allowedKWs = 'searchList namespaces filter filtersLib errorCatcher'.split()
for k,v in KWs.items():
if k in allowedKWs: cheetahKWArgs[k] = v
self._initCheetahInstance(**cheetahKWArgs)
def respond(self, trans=None):
## CHEETAH: main method generated for this template
if (not trans and not self._CHEETAH__isBuffering and not callable(self.transaction)):
trans = self.transaction # is None unless self.awake() was called
if not trans:
trans = DummyTransaction()
_dummyTrans = True
else: _dummyTrans = False
write = trans.response().write
SL = self._CHEETAH__searchList
_filter = self._CHEETAH__currentFilter
########################################
## START - generated method body
_orig_filter_88816577 = _filter
filterName = u'WebSafe'
if self._CHEETAH__filters.has_key("WebSafe"):
_filter = self._CHEETAH__currentFilter = self._CHEETAH__filters[filterName]
else:
_filter = self._CHEETAH__currentFilter = \
self._CHEETAH__filters[filterName] = getattr(self._CHEETAH__filtersLib, filterName)(self).filter
write(u'''<?xml version="1.0" encoding="UTF-8"?>
<e2eventlist>
''')
for event in VFFSL(SL,"events",True): # generated from line 4, col 2
write(u'''\t<e2event>
\t\t<e2eventid>''')
_v = VFFSL(SL,"str",False)(VFFSL(SL,"event.id",True)) # u'$str($event.id)' on line 6, col 14
if _v is not None: write(_filter(_v, rawExpr=u'$str($event.id)')) # from line 6, col 14.
write(u'''</e2eventid>
\t\t<e2eventstart>''')
_v = VFFSL(SL,"str",False)(VFFSL(SL,"event.begin_timestamp",True)) # u'$str($event.begin_timestamp)' on line 7, col 17
if _v is not None: write(_filter(_v, rawExpr=u'$str($event.begin_timestamp)')) # from line 7, col 17.
write(u'''</e2eventstart>
\t\t<e2eventduration>''')
_v = VFFSL(SL,"str",False)(VFFSL(SL,"event.duration_sec",True)) # u'$str($event.duration_sec)' on line 8, col 20
if _v is not None: write(_filter(_v, rawExpr=u'$str($event.duration_sec)')) # from line 8, col 20.
write(u'''</e2eventduration>
\t\t<e2eventcurrenttime>''')
_v = VFFSL(SL,"str",False)(VFFSL(SL,"event.now_timestamp",True)) # u'$str($event.now_timestamp)' on line 9, col 23
if _v is not None: write(_filter(_v, rawExpr=u'$str($event.now_timestamp)')) # from line 9, col 23.
write(u'''</e2eventcurrenttime>
\t\t<e2eventtitle>''')
_v = VFFSL(SL,"str",False)(VFFSL(SL,"event.title",True)) # u'$str($event.title)' on line 10, col 17
if _v is not None: write(_filter(_v, rawExpr=u'$str($event.title)')) # from line 10, col 17.
write(u'''</e2eventtitle>
\t\t<e2eventdescription>''')
_v = VFFSL(SL,"str",False)(VFFSL(SL,"event.shortdesc",True)) # u'$str($event.shortdesc)' on line 11, col 23
if _v is not None: write(_filter(_v, rawExpr=u'$str($event.shortdesc)')) # from line 11, col 23.
write(u'''</e2eventdescription>
\t\t<e2eventdescriptionextended>''')
_v = VFFSL(SL,"str",False)(VFFSL(SL,"event.longdesc",True)) # u'$str($event.longdesc)' on line 12, col 31
if _v is not None: write(_filter(_v, rawExpr=u'$str($event.longdesc)')) # from line 12, col 31.
write(u'''</e2eventdescriptionextended>
\t\t<e2eventservicereference>''')
_v = VFFSL(SL,"event.sref",True) # u'$event.sref' on line 13, col 28
if _v is not None: write(_filter(_v, rawExpr=u'$event.sref')) # from line 13, col 28.
write(u'''</e2eventservicereference>
\t\t<e2eventservicename>''')
_v = VFFSL(SL,"event.sname",True) # u'$event.sname' on line 14, col 23
if _v is not None: write(_filter(_v, rawExpr=u'$event.sname')) # from line 14, col 23.
write(u'''</e2eventservicename>
\t</e2event>
''')
write(u'''</e2eventlist>
''')
_filter = self._CHEETAH__currentFilter = _orig_filter_88816577
########################################
## END - generated method body
return _dummyTrans and trans.response().getvalue() or ""
##################################################
## CHEETAH GENERATED ATTRIBUTES
_CHEETAH__instanceInitialized = False
_CHEETAH_version = __CHEETAH_version__
_CHEETAH_versionTuple = __CHEETAH_versionTuple__
_CHEETAH_genTime = __CHEETAH_genTime__
_CHEETAH_genTimestamp = __CHEETAH_genTimestamp__
_CHEETAH_src = __CHEETAH_src__
_CHEETAH_srcLastModified = __CHEETAH_srcLastModified__
_mainCheetahMethod_for_epgservicenow= 'respond'
## END CLASS DEFINITION
if not hasattr(epgservicenow, '_initCheetahAttributes'):
templateAPIClass = getattr(epgservicenow, '_CHEETAH_templateClass', Template)
templateAPIClass._addCheetahPlumbingCodeToClass(epgservicenow)
# CHEETAH was developed by Tavis Rudd and Mike Orr
# with code, advice and input from many other volunteers.
# For more information visit http://www.CheetahTemplate.org/
##################################################
## if run from command line:
if __name__ == '__main__':
from Cheetah.TemplateCmdLineIface import CmdLineIface
CmdLineIface(templateObj=epgservicenow()).run()
| pli3/e2-openwbif | plugin/controllers/views/web/epgservicenow.py | Python | gpl-2.0 | 7,517 | [
"VisIt"
] | 5df81316aa681ea343d4b96de730a8dd474a36208014d46f4c160ad7bfffa463 |
#!/usr/bin/env python
# Copyright 2014-2020 The PySCF Developers. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import copy
import unittest
import numpy
from pyscf import lib
from pyscf import gto
from pyscf import scf
from pyscf import dft
from pyscf import fci
from pyscf import mcscf
b = 1.4
mol = gto.M(
verbose = 7,
output = '/dev/null',
atom = [
['N',( 0.000000, 0.000000, -b/2)],
['N',( 0.000000, 0.000000, b/2)], ],
basis = {'N': '631g', },
)
m = scf.RHF(mol)
m.conv_tol = 1e-10
m.scf()
molsym = gto.M(
verbose = 7,
output = '/dev/null',
atom = [
['N',( 0.000000, 0.000000, -b/2)],
['N',( 0.000000, 0.000000, b/2)], ],
basis = {'N': '631g', },
symmetry = True
)
msym = scf.RHF(molsym)
msym.conv_tol = 1e-10
msym.scf()
def tearDownModule():
global mol, molsym, m, msym
mol.stdout.close()
molsym.stdout.close()
del mol, molsym, m, msym
class KnownValues(unittest.TestCase):
def test_with_x2c_scanner(self):
mc1 = mcscf.CASCI(m, 4, 4).x2c().run()
self.assertAlmostEqual(mc1.e_tot, -108.89264146901512, 7)
mc1 = mcscf.CASCI(m, 4, 4).x2c().as_scanner().as_scanner()
mc1(mol)
self.assertAlmostEqual(mc1.e_tot, -108.89264146901512, 7)
def test_fix_spin_(self):
mc1 = mcscf.CASCI(m, 4, 4)
mc1.fix_spin_(ss=2).run()
self.assertAlmostEqual(mc1.e_tot, -108.03741684418183, 7)
mc1.fix_spin_(ss=0).run()
self.assertAlmostEqual(mc1.e_tot, -108.83741684447352, 7)
def test_cas_natorb(self):
mc1 = mcscf.CASCI(msym, 4, 4, ncore=5)
mo = mc1.sort_mo([4,5,10,13])
mc1.sorting_mo_energy = True
mc1.kernel(mo)
mo0 = mc1.mo_coeff
ci0 = mc1.ci
self.assertAlmostEqual(mc1.e_tot, -108.71841138528966, 9)
mo2, ci2, mo_e = mc1.canonicalize(sort=False, cas_natorb=True,
with_meta_lowdin=False, verbose=7)
casdm1 = mc1.fcisolver.make_rdm1(mc1.ci, 4, 4)
mc1.ci = None # Force cas_natorb_ to recompute CI coefficients
mc1.cas_natorb_(casdm1=casdm1, sort=True, with_meta_lowdin=True)
mo1 = mc1.mo_coeff
ci1 = mc1.ci
s = numpy.einsum('pi,pq,qj->ij', mo0[:,5:9], msym.get_ovlp(), mo1[:,5:9])
self.assertAlmostEqual(fci.addons.overlap(ci0, ci1, 4, 4, s), 1, 9)
self.assertAlmostEqual(float(abs(mo1-mo2).max()), 0, 9)
self.assertAlmostEqual(ci1.ravel().dot(ci2.ravel()), 1, 9)
# Make sure that mc.mo_occ has been set and that the NOONs add to nelectron
mo_occ = getattr(mc1, "mo_occ", numpy.array([]))
self.assertNotEqual(mo_occ, numpy.array([]))
self.assertAlmostEqual(numpy.sum(mo_occ), mc1.mol.nelectron, 9)
def test_multi_roots(self):
mc1 = mcscf.CASCI(m, 4, 4)
mc1.fcisolver.nroots = 2
mc1.natorb = True
mc1.kernel()
self.assertAlmostEqual(mc1.e_tot[0], -108.83741684447352, 9)
self.assertAlmostEqual(mc1.e_tot[1], -108.72522194135604, 9)
dm1 = mc1.analyze()
self.assertAlmostEqual(lib.finger(dm1[0]), 2.6252082970845532, 7)
self.assertAlmostEqual(lib.finger(dm1[1]), 2.6252082970845532, 7)
def test_external_fcisolver(self):
class FCI_as_DMRG(fci.direct_spin1.FCISolver):
def __getattribute__(self, attr):
"""Prevent 'private' attribute access"""
if attr in ('make_rdm1s', 'spin_square'):
raise AttributeError
else:
return object.__getattribute__(self, attr)
mc1 = mcscf.CASCI(m, 4, 4)
mc1.fcisolver = FCI_as_DMRG(mol)
mc1.fcisolver.nroots = 2
mc1.natorb = True
mc1.kernel()
self.assertAlmostEqual(mc1.e_tot[0], -108.83741684447352, 9)
self.assertAlmostEqual(mc1.e_tot[1], -108.72522194135604, 9)
dm1 = mc1.analyze(with_meta_lowdin=False)
self.assertAlmostEqual(lib.finger(dm1[0]), 2.6252082970845532*2, 7)
def test_get_h2eff(self):
mc1 = mcscf.approx_hessian(mcscf.CASCI(m, 4, 4))
eri1 = mc1.get_h2eff(m.mo_coeff[:,5:9])
eri2 = mc1.get_h2cas(m.mo_coeff[:,5:9])
self.assertAlmostEqual(abs(eri1-eri2).max(), 0, 12)
mc1 = mcscf.density_fit(mcscf.CASCI(m, 4, 4))
eri1 = mc1.get_h2eff(m.mo_coeff[:,5:9])
eri2 = mc1.get_h2cas(m.mo_coeff[:,5:9])
self.assertTrue(abs(eri1-eri2).max() > 1e-5)
def test_get_veff(self):
mf = m.view(dft.rks.RKS)
mc1 = mcscf.CASCI(mf, 4, 4)
nao = mol.nao_nr()
dm = numpy.random.random((nao,nao))
dm = dm + dm.T
veff1 = mc1.get_veff(mol, dm)
veff2 = m.get_veff(mol, dm)
self.assertAlmostEqual(abs(veff1-veff2).max(), 0, 12)
def test_with_ci_init_guess(self):
mc1 = mcscf.CASCI(msym, 4, 4)
ci0 = numpy.zeros((6,6))
ci0[0,1] = 1
mc1.kernel(ci0=ci0)
mc2 = mcscf.CASCI(msym, 4, 4)
mc2.wfnsym = 'A1u'
mc2.kernel()
self.assertAlmostEqual(mc1.e_tot, mc2.e_tot, 9)
def test_slight_symmetry_broken(self):
mf = copy.copy(msym)
mf.mo_coeff = numpy.array(msym.mo_coeff)
u = numpy.linalg.svd(numpy.random.random((4,4)))[0]
mf.mo_coeff[:,5:9] = mf.mo_coeff[:,5:9].dot(u)
mc1 = mcscf.CASCI(mf, 4, 4)
mc1.kernel()
self.assertAlmostEqual(mc1.e_tot, -108.83741684445798, 9)
def test_sort_mo(self):
mc1 = mcscf.CASCI(msym, 4, 4)
mo = mc1.sort_mo_by_irrep({'A1u':3, 'A1g':1})
mc1.kernel(mo)
self.assertAlmostEqual(mc1.e_tot, -105.82542805259033, 9)
def test_state_average(self):
mc = mcscf.CASCI(m, 4, 4)
mc.state_average_([0.5, 0.25, 0.25])
mc.fcisolver.spin = 2
mc.run()
self.assertAlmostEqual(mc.e_states[0], -108.72522194135607, 9)
self.assertAlmostEqual(mc.e_states[1], -108.67148843338228, 9)
self.assertAlmostEqual(mc.e_states[2], -108.67148843338228, 9)
mc.analyze()
mo_coeff, civec, mo_occ = mc.cas_natorb(sort=True)
mc.kernel(mo_coeff=mo_coeff)
self.assertAlmostEqual(mc.e_states[0], -108.72522194135607, 9)
self.assertAlmostEqual(mc.e_states[1], -108.67148843338228, 9)
#FIXME: with the initial guess from mc, FCI solver may converge to
# another state
#self.assertAlmostEqual(mc.e_tot[2], -108.67148843338228, 9)
self.assertAlmostEqual(abs((civec[0]*mc.ci[0]).sum()), 1, 9)
# Second and third root are degenerated
#self.assertAlmostEqual(abs((civec[1]*mc.ci[1]).sum()), 1, 9)
def test_state_average_mix(self):
mc = mcscf.CASCI(m, 4, 4)
cis1 = copy.copy(mc.fcisolver)
cis1.spin = 2
cis1.nroots = 3
mc = mcscf.addons.state_average_mix(mc, [cis1, mc.fcisolver], [.25, .25, .25, .25])
mc.run()
self.assertAlmostEqual(mc.e_states[0], -108.72522194135607, 9)
self.assertAlmostEqual(mc.e_states[1], -108.67148843338228, 9)
self.assertAlmostEqual(mc.e_states[2], -108.67148843338228, 9)
self.assertAlmostEqual(mc.e_states[3], -108.83741684447352, 9)
mc.analyze()
mo_coeff, civec, mo_occ = mc.cas_natorb(sort=True)
mc.kernel(mo_coeff=mo_coeff)
self.assertAlmostEqual(mc.e_states[0], -108.72522194135607, 9)
self.assertAlmostEqual(mc.e_states[1], -108.67148843338228, 9)
#FIXME: with the initial guess from mc, FCI solver may converge to
# another state
#self.assertAlmostEqual(mc.e_states[2], -108.67148843338228, 9)
self.assertAlmostEqual(mc.e_states[3], -108.83741684447352, 9)
self.assertAlmostEqual(abs((civec[0]*mc.ci[0]).sum()), 1, 8)
self.assertAlmostEqual(abs((civec[3]*mc.ci[3]).sum()), 1, 8)
def test_reset(self):
myci = mcscf.CASCI(scf.RHF(molsym), 4, 4).density_fit()
myci.reset(mol)
self.assertTrue(myci.mol is mol)
self.assertTrue(myci._scf.mol is mol)
self.assertTrue(myci.fcisolver.mol is mol)
self.assertTrue(myci.with_df.mol is mol)
def test_casci_SO3_symm(self):
mol = gto.M(atom='N', basis='ccpvdz', spin=3, symmetry=True)
mf = mol.RHF().newton().run()
mc = mf.CASSCF(4, 5)
mc.run()
self.assertAlmostEqual(mc.e_tot, -54.3884142370103, 9)
mc.wfnsym = 4
self.assertRaises(RuntimeError, mc.run)
if __name__ == "__main__":
print("Full Tests for CASCI")
unittest.main()
| sunqm/pyscf | pyscf/mcscf/test/test_casci.py | Python | apache-2.0 | 9,067 | [
"PySCF"
] | 629eb6820b3493defb0271a5bd738579ec99e9bba33afcfeb4cffdd2e5bff14a |
#!/usr/bin/python
#
# Created on Aug 25, 2016
# @author: Gaurav Rastogi (grastogi@avinetworks.com)
# Eric Anderson (eanderson@avinetworks.com)
# module_check: supported
#
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible. If not, see <http://www.gnu.org/licenses/>.
#
ANSIBLE_METADATA = {'metadata_version': '1.1',
'status': ['preview'],
'supported_by': 'community'}
DOCUMENTATION = '''
---
module: avi_serverautoscalepolicy
author: Gaurav Rastogi (grastogi@avinetworks.com)
short_description: Module for setup of ServerAutoScalePolicy Avi RESTful Object
description:
- This module is used to configure ServerAutoScalePolicy object
- more examples at U(https://github.com/avinetworks/devops)
requirements: [ avisdk ]
version_added: "2.4"
options:
state:
description:
- The state that should be applied on the entity.
default: present
choices: ["absent", "present"]
avi_api_update_method:
description:
- Default method for object update is HTTP PUT.
- Setting to patch will override that behavior to use HTTP PATCH.
version_added: "2.5"
default: put
choices: ["put", "patch"]
avi_api_patch_op:
description:
- Patch operation to use when using avi_api_update_method as patch.
version_added: "2.5"
choices: ["add", "replace", "delete"]
description:
description:
- User defined description for the object.
intelligent_autoscale:
description:
- Use avi intelligent autoscale algorithm where autoscale is performed by comparing load on the pool against estimated capacity of all the servers.
- Default value when not specified in API or module is interpreted by Avi Controller as False.
intelligent_scalein_margin:
description:
- Maximum extra capacity as percentage of load used by the intelligent scheme.
- Scalein is triggered when available capacity is more than this margin.
- Allowed values are 1-99.
- Default value when not specified in API or module is interpreted by Avi Controller as 40.
intelligent_scaleout_margin:
description:
- Minimum extra capacity as percentage of load used by the intelligent scheme.
- Scaleout is triggered when available capacity is less than this margin.
- Allowed values are 1-99.
- Default value when not specified in API or module is interpreted by Avi Controller as 20.
max_scalein_adjustment_step:
description:
- Maximum number of servers to scalein simultaneously.
- The actual number of servers to scalein is chosen such that target number of servers is always more than or equal to the min_size.
- Default value when not specified in API or module is interpreted by Avi Controller as 1.
max_scaleout_adjustment_step:
description:
- Maximum number of servers to scaleout simultaneously.
- The actual number of servers to scaleout is chosen such that target number of servers is always less than or equal to the max_size.
- Default value when not specified in API or module is interpreted by Avi Controller as 1.
max_size:
description:
- Maximum number of servers after scaleout.
- Allowed values are 0-400.
min_size:
description:
- No scale-in happens once number of operationally up servers reach min_servers.
- Allowed values are 0-400.
name:
description:
- Name of the object.
required: true
scalein_alertconfig_refs:
description:
- Trigger scalein when alerts due to any of these alert configurations are raised.
- It is a reference to an object of type alertconfig.
scalein_cooldown:
description:
- Cooldown period during which no new scalein is triggered to allow previous scalein to successfully complete.
- Default value when not specified in API or module is interpreted by Avi Controller as 300.
- Units(SEC).
scaleout_alertconfig_refs:
description:
- Trigger scaleout when alerts due to any of these alert configurations are raised.
- It is a reference to an object of type alertconfig.
scaleout_cooldown:
description:
- Cooldown period during which no new scaleout is triggered to allow previous scaleout to successfully complete.
- Default value when not specified in API or module is interpreted by Avi Controller as 300.
- Units(SEC).
tenant_ref:
description:
- It is a reference to an object of type tenant.
url:
description:
- Avi controller URL of the object.
use_predicted_load:
description:
- Use predicted load rather than current load.
- Default value when not specified in API or module is interpreted by Avi Controller as False.
uuid:
description:
- Unique object identifier of the object.
extends_documentation_fragment:
- avi
'''
EXAMPLES = """
- name: Example to create ServerAutoScalePolicy object
avi_serverautoscalepolicy:
controller: 10.10.25.42
username: admin
password: something
state: present
name: sample_serverautoscalepolicy
"""
RETURN = '''
obj:
description: ServerAutoScalePolicy (api/serverautoscalepolicy) object
returned: success, changed
type: dict
'''
from ansible.module_utils.basic import AnsibleModule
try:
from ansible.module_utils.network.avi.avi import (
avi_common_argument_spec, HAS_AVI, avi_ansible_api)
except ImportError:
HAS_AVI = False
def main():
argument_specs = dict(
state=dict(default='present',
choices=['absent', 'present']),
avi_api_update_method=dict(default='put',
choices=['put', 'patch']),
avi_api_patch_op=dict(choices=['add', 'replace', 'delete']),
description=dict(type='str',),
intelligent_autoscale=dict(type='bool',),
intelligent_scalein_margin=dict(type='int',),
intelligent_scaleout_margin=dict(type='int',),
max_scalein_adjustment_step=dict(type='int',),
max_scaleout_adjustment_step=dict(type='int',),
max_size=dict(type='int',),
min_size=dict(type='int',),
name=dict(type='str', required=True),
scalein_alertconfig_refs=dict(type='list',),
scalein_cooldown=dict(type='int',),
scaleout_alertconfig_refs=dict(type='list',),
scaleout_cooldown=dict(type='int',),
tenant_ref=dict(type='str',),
url=dict(type='str',),
use_predicted_load=dict(type='bool',),
uuid=dict(type='str',),
)
argument_specs.update(avi_common_argument_spec())
module = AnsibleModule(
argument_spec=argument_specs, supports_check_mode=True)
if not HAS_AVI:
return module.fail_json(msg=(
'Avi python API SDK (avisdk>=17.1) is not installed. '
'For more details visit https://github.com/avinetworks/sdk.'))
return avi_ansible_api(module, 'serverautoscalepolicy',
set([]))
if __name__ == '__main__':
main()
| le9i0nx/ansible | lib/ansible/modules/network/avi/avi_serverautoscalepolicy.py | Python | gpl-3.0 | 7,975 | [
"VisIt"
] | 0506066562f3f6cd5ffdaf5dc7dfd49836de80be7044b48e5c20ce2c0ba9bcd6 |
#!/usr/bin/env python
# This example demonstrates the conversion of point data to cell data.
# The conversion is necessary because we want to threshold data based
# on cell scalar values.
import vtk
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()
# Read some data with point data attributes. The data is from a
# plastic blow molding process (e.g., to make plastic bottles) and
# consists of two logical components: a mold and a parison. The
# parison is the hot plastic that is being molded, and the mold is
# clamped around the parison to form its shape.
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName(VTK_DATA_ROOT + "/Data/blow.vtk")
reader.SetScalarsName("thickness9")
reader.SetVectorsName("displacement9")
# Convert the point data to cell data. The point data is passed
# through the filter so it can be warped. The vtkThresholdFilter then
# thresholds based on cell scalar values and extracts a portion of the
# parison whose cell scalar values lie between 0.25 and 0.75.
p2c = vtk.vtkPointDataToCellData()
p2c.SetInputConnection(reader.GetOutputPort())
p2c.PassPointDataOn()
warp = vtk.vtkWarpVector()
warp.SetInput(p2c.GetUnstructuredGridOutput())
thresh = vtk.vtkThreshold()
thresh.SetInputConnection(warp.GetOutputPort())
thresh.ThresholdBetween(0.25, 0.75)
thresh.SetInputArrayToProcess(1, 0, 0, 0, "thickness9")
#thresh.SetAttributeModeToUseCellData()
# This is used to extract the mold from the parison.
connect = vtk.vtkConnectivityFilter()
connect.SetInputConnection(thresh.GetOutputPort())
connect.SetExtractionModeToSpecifiedRegions()
connect.AddSpecifiedRegion(0)
connect.AddSpecifiedRegion(1)
moldMapper = vtk.vtkDataSetMapper()
moldMapper.SetInputConnection(reader.GetOutputPort())
moldMapper.ScalarVisibilityOff()
moldActor = vtk.vtkActor()
moldActor.SetMapper(moldMapper)
moldActor.GetProperty().SetColor(.2, .2, .2)
moldActor.GetProperty().SetRepresentationToWireframe()
# The threshold filter has been used to extract the parison.
connect2 = vtk.vtkConnectivityFilter()
connect2.SetInputConnection(thresh.GetOutputPort())
parison = vtk.vtkGeometryFilter()
parison.SetInputConnection(connect2.GetOutputPort())
normals2 = vtk.vtkPolyDataNormals()
normals2.SetInputConnection(parison.GetOutputPort())
normals2.SetFeatureAngle(60)
lut = vtk.vtkLookupTable()
lut.SetHueRange(0.0, 0.66667)
parisonMapper = vtk.vtkPolyDataMapper()
parisonMapper.SetInputConnection(normals2.GetOutputPort())
parisonMapper.SetLookupTable(lut)
parisonMapper.SetScalarRange(0.12, 1.0)
parisonActor = vtk.vtkActor()
parisonActor.SetMapper(parisonMapper)
# We generate some contour lines on the parison.
cf = vtk.vtkContourFilter()
cf.SetInputConnection(connect2.GetOutputPort())
cf.SetValue(0, .5)
contourMapper = vtk.vtkPolyDataMapper()
contourMapper.SetInputConnection(cf.GetOutputPort())
contours = vtk.vtkActor()
contours.SetMapper(contourMapper)
# Create graphics stuff
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Add the actors to the renderer, set the background and size
ren.AddActor(moldActor)
ren.AddActor(parisonActor)
ren.AddActor(contours)
ren.ResetCamera()
ren.GetActiveCamera().Azimuth(60)
ren.GetActiveCamera().Roll(-90)
ren.GetActiveCamera().Dolly(2)
ren.ResetCameraClippingRange()
ren.SetBackground(1, 1, 1)
renWin.SetSize(750, 400)
iren.Initialize()
renWin.Render()
iren.Start()
| VisTrails/VisTrails | examples/vtk_examples/DataManipulation/pointToCellData.py | Python | bsd-3-clause | 3,452 | [
"VTK"
] | b680352b5680ffef0b4a829b7f5e0385e43db5136a70c11d1c52e7ac7fa851ce |
# -*- coding: utf-8 -*-
import datetime
from south.db import db
from south.v2 import SchemaMigration
from django.db import models
class Migration(SchemaMigration):
def forwards(self, orm):
# Adding field 'PresentMedicalHistory.tuberculosis'
db.add_column(u'patient_presentmedicalhistory', 'tuberculosis',
self.gf('django.db.models.fields.BooleanField')(default=False),
keep_default=False)
# Adding field 'PresentMedicalHistory.heart_disease'
db.add_column(u'patient_presentmedicalhistory', 'heart_disease',
self.gf('django.db.models.fields.BooleanField')(default=False),
keep_default=False)
# Adding field 'PresentMedicalHistory.chronical_renal_disease'
db.add_column(u'patient_presentmedicalhistory', 'chronical_renal_disease',
self.gf('django.db.models.fields.BooleanField')(default=False),
keep_default=False)
# Adding field 'PresentMedicalHistory.epilepsy'
db.add_column(u'patient_presentmedicalhistory', 'epilepsy',
self.gf('django.db.models.fields.BooleanField')(default=False),
keep_default=False)
# Adding field 'PresentMedicalHistory.diabetes_melitus'
db.add_column(u'patient_presentmedicalhistory', 'diabetes_melitus',
self.gf('django.db.models.fields.BooleanField')(default=False),
keep_default=False)
# Adding field 'PresentMedicalHistory.sexually_transmitted_infection'
db.add_column(u'patient_presentmedicalhistory', 'sexually_transmitted_infection',
self.gf('django.db.models.fields.BooleanField')(default=False),
keep_default=False)
# Adding field 'PresentMedicalHistory.hepatitis'
db.add_column(u'patient_presentmedicalhistory', 'hepatitis',
self.gf('django.db.models.fields.BooleanField')(default=False),
keep_default=False)
# Adding field 'PresentMedicalHistory.malaria'
db.add_column(u'patient_presentmedicalhistory', 'malaria',
self.gf('django.db.models.fields.BooleanField')(default=False),
keep_default=False)
# Adding field 'PresentMedicalHistory.sickle_cell_trait'
db.add_column(u'patient_presentmedicalhistory', 'sickle_cell_trait',
self.gf('django.db.models.fields.BooleanField')(default=False),
keep_default=False)
# Adding field 'PresentMedicalHistory.rhesus_d_antibodies'
db.add_column(u'patient_presentmedicalhistory', 'rhesus_d_antibodies',
self.gf('django.db.models.fields.BooleanField')(default=False),
keep_default=False)
# Adding field 'PresentMedicalHistory.HIV_status_if_known'
db.add_column(u'patient_presentmedicalhistory', 'HIV_status_if_known',
self.gf('django.db.models.fields.BooleanField')(default=False),
keep_default=False)
# Adding field 'PresentMedicalHistory.kidney_disease'
db.add_column(u'patient_presentmedicalhistory', 'kidney_disease',
self.gf('django.db.models.fields.BooleanField')(default=False),
keep_default=False)
# Adding field 'PresentMedicalHistory.liver_problems'
db.add_column(u'patient_presentmedicalhistory', 'liver_problems',
self.gf('django.db.models.fields.BooleanField')(default=False),
keep_default=False)
# Adding field 'PresentMedicalHistory.hypertension'
db.add_column(u'patient_presentmedicalhistory', 'hypertension',
self.gf('django.db.models.fields.BooleanField')(default=False),
keep_default=False)
# Adding field 'PresentMedicalHistory.urinary_tract_surgeries'
db.add_column(u'patient_presentmedicalhistory', 'urinary_tract_surgeries',
self.gf('django.db.models.fields.BooleanField')(default=False),
keep_default=False)
# Adding field 'PresentMedicalHistory.seizures'
db.add_column(u'patient_presentmedicalhistory', 'seizures',
self.gf('django.db.models.fields.BooleanField')(default=False),
keep_default=False)
# Adding field 'PresentMedicalHistory.pelvic_backinjuries'
db.add_column(u'patient_presentmedicalhistory', 'pelvic_backinjuries',
self.gf('django.db.models.fields.BooleanField')(default=False),
keep_default=False)
# Adding field 'PresentMedicalHistory.haemorrhage'
db.add_column(u'patient_presentmedicalhistory', 'haemorrhage',
self.gf('django.db.models.fields.BooleanField')(default=False),
keep_default=False)
def backwards(self, orm):
# Deleting field 'PresentMedicalHistory.tuberculosis'
db.delete_column(u'patient_presentmedicalhistory', 'tuberculosis')
# Deleting field 'PresentMedicalHistory.heart_disease'
db.delete_column(u'patient_presentmedicalhistory', 'heart_disease')
# Deleting field 'PresentMedicalHistory.chronical_renal_disease'
db.delete_column(u'patient_presentmedicalhistory', 'chronical_renal_disease')
# Deleting field 'PresentMedicalHistory.epilepsy'
db.delete_column(u'patient_presentmedicalhistory', 'epilepsy')
# Deleting field 'PresentMedicalHistory.diabetes_melitus'
db.delete_column(u'patient_presentmedicalhistory', 'diabetes_melitus')
# Deleting field 'PresentMedicalHistory.sexually_transmitted_infection'
db.delete_column(u'patient_presentmedicalhistory', 'sexually_transmitted_infection')
# Deleting field 'PresentMedicalHistory.hepatitis'
db.delete_column(u'patient_presentmedicalhistory', 'hepatitis')
# Deleting field 'PresentMedicalHistory.malaria'
db.delete_column(u'patient_presentmedicalhistory', 'malaria')
# Deleting field 'PresentMedicalHistory.sickle_cell_trait'
db.delete_column(u'patient_presentmedicalhistory', 'sickle_cell_trait')
# Deleting field 'PresentMedicalHistory.rhesus_d_antibodies'
db.delete_column(u'patient_presentmedicalhistory', 'rhesus_d_antibodies')
# Deleting field 'PresentMedicalHistory.HIV_status_if_known'
db.delete_column(u'patient_presentmedicalhistory', 'HIV_status_if_known')
# Deleting field 'PresentMedicalHistory.kidney_disease'
db.delete_column(u'patient_presentmedicalhistory', 'kidney_disease')
# Deleting field 'PresentMedicalHistory.liver_problems'
db.delete_column(u'patient_presentmedicalhistory', 'liver_problems')
# Deleting field 'PresentMedicalHistory.hypertension'
db.delete_column(u'patient_presentmedicalhistory', 'hypertension')
# Deleting field 'PresentMedicalHistory.urinary_tract_surgeries'
db.delete_column(u'patient_presentmedicalhistory', 'urinary_tract_surgeries')
# Deleting field 'PresentMedicalHistory.seizures'
db.delete_column(u'patient_presentmedicalhistory', 'seizures')
# Deleting field 'PresentMedicalHistory.pelvic_backinjuries'
db.delete_column(u'patient_presentmedicalhistory', 'pelvic_backinjuries')
# Deleting field 'PresentMedicalHistory.haemorrhage'
db.delete_column(u'patient_presentmedicalhistory', 'haemorrhage')
models = {
u'auth.group': {
'Meta': {'object_name': 'Group'},
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}),
'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': u"orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'})
},
u'auth.permission': {
'Meta': {'ordering': "(u'content_type__app_label', u'content_type__model', u'codename')", 'unique_together': "((u'content_type', u'codename'),)", 'object_name': 'Permission'},
'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['contenttypes.ContentType']"}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
},
u'auth.user': {
'Meta': {'object_name': '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': u"orm['auth.Group']", 'symmetrical': 'False', 'blank': 'True'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'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': u"orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'}),
'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'})
},
u'contenttypes.contenttype': {
'Meta': {'ordering': "('name',)", 'unique_together': "(('app_label', 'model'),)", 'object_name': 'ContentType', 'db_table': "'django_content_type'"},
'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
u'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'})
},
u'patient.additionalpatientinformation': {
'Meta': {'object_name': 'AdditionalPatientInformation'},
'alcohol': ('django.db.models.fields.CharField', [], {'max_length': '2'}),
'cigarettes': ('django.db.models.fields.CharField', [], {'max_length': '2'}),
'created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
'educational_level': ('django.db.models.fields.CharField', [], {'max_length': '2'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'literate': ('django.db.models.fields.CharField', [], {'max_length': '2'}),
'modified': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
'occupation': ('django.db.models.fields.CharField', [], {'max_length': '30'}),
'patient': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['patient.PatientInformation']"})
},
u'patient.familymedicalhistory': {
'HIV_status_if_known': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'Meta': {'object_name': 'FamilyMedicalHistory'},
'chronical_renal_disease': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
'date': ('django.db.models.fields.DateField', [], {}),
'diabetes_melitus': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'epilepsy': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'haemorrhage': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'heart_disease': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'hepatitis': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'hypertension': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'kidney_disease': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'liver_problems': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'malaria': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'modified': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
'others': ('django.db.models.fields.TextField', [], {}),
'patient': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['patient.PatientInformation']"}),
'pelvic_backinjuries': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'rhesus_d_antibodies': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'seizures': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'sexually_transmitted_infection': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'sickle_cell_trait': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'tuberculosis': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'urinary_tract_surgeries': ('django.db.models.fields.BooleanField', [], {'default': 'False'})
},
u'patient.guardian': {
'Meta': {'object_name': 'Guardian'},
'contact_number': ('django.db.models.fields.CharField', [], {'max_length': '15'}),
'created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
'educational_level': ('django.db.models.fields.CharField', [], {'max_length': '2'}),
'first_name': ('django.db.models.fields.CharField', [], {'max_length': '50'}),
'home_address': ('django.db.models.fields.TextField', [], {}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'job': ('django.db.models.fields.CharField', [], {'max_length': '20'}),
'last_name': ('django.db.models.fields.CharField', [], {'max_length': '50'}),
'modified': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
'patient': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['patient.PatientInformation']"}),
'relation': ('django.db.models.fields.CharField', [], {'max_length': '2'})
},
u'patient.gynaecologicalhistory': {
'Meta': {'object_name': 'GynaecologicalHistory'},
'created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
'date_of_last_pap_smear': ('django.db.models.fields.DateField', [], {}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'method_of_birth_control': ('django.db.models.fields.CharField', [], {'max_length': '2'}),
'modified': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
'patient': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['patient.PatientInformation']"}),
'previous_surgery': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['patient.PreviousSurgery']"}),
'result_pap_smear': ('django.db.models.fields.CharField', [], {'max_length': '2'})
},
u'patient.immunizationhistory': {
'Meta': {'object_name': 'ImmunizationHistory'},
'created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'modified': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
'patient': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['patient.PatientInformation']"}),
'tetanus_toxoid1': ('django.db.models.fields.DateTimeField', [], {}),
'tetanus_toxoid2': ('django.db.models.fields.DateTimeField', [], {}),
'tetanus_toxoid3': ('django.db.models.fields.DateTimeField', [], {}),
'vaccination': ('django.db.models.fields.CharField', [], {'max_length': '2'})
},
u'patient.laboratorytest': {
'Meta': {'object_name': 'LaboratoryTest'},
'blood_group': ('django.db.models.fields.CharField', [], {'max_length': '200'}),
'created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
'date': ('django.db.models.fields.DateTimeField', [], {}),
'hemoglobin': ('django.db.models.fields.CharField', [], {'max_length': '1'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'modified': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
'patient': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['patient.PatientInformation']"}),
'serological_test_for_syphilis': ('django.db.models.fields.CharField', [], {'max_length': '200'}),
'urinalysis': ('django.db.models.fields.CharField', [], {'max_length': '2'})
},
u'patient.medicalhistory': {
'Meta': {'object_name': 'MedicalHistory'},
'created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
'family_medical_history': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['patient.FamilyMedicalHistory']"}),
'gynaecological_history': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['patient.GynaecologicalHistory']"}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'immunization_history': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['patient.ImmunizationHistory']"}),
'menstrual_history': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['patient.MenstrualHistory']"}),
'modified': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
'obstetric_history': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['patient.ObstetricHistory']"}),
'past_medical_history': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['patient.PastMedicalHistory']"}),
'patient': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['patient.PatientInformation']"}),
'present_medical_history': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['patient.PresentMedicalHistory']"})
},
u'patient.menstrualhistory': {
'Meta': {'object_name': 'MenstrualHistory'},
'created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
'day_of_visit': ('django.db.models.fields.DateField', [], {}),
'expected_date_of_delivery': ('django.db.models.fields.DateField', [], {}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'last_menstrual_periods': ('django.db.models.fields.DateField', [], {}),
'menstrual_cycle': ('django.db.models.fields.CharField', [], {'max_length': '2'}),
'modified': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
'patient': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['patient.PatientInformation']"}),
'poa_by_lmp': ('django.db.models.fields.CharField', [], {'max_length': '100'})
},
u'patient.obstetrichistory': {
'Meta': {'object_name': 'ObstetricHistory'},
'check_if_you_have_been_miscarriages': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'check_if_you_have_been_pregnant': ('django.db.models.fields.CharField', [], {'max_length': '2'}),
'created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'list_previous_obstetric_history': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['patient.PreviousObstetricHistory']"}),
'modified': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
'patient': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['patient.PatientInformation']"})
},
u'patient.pastmedicalhistory': {
'HIV_status_if_known': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'Meta': {'object_name': 'PastMedicalHistory'},
'chronical_renal_disease': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
'date': ('django.db.models.fields.DateField', [], {}),
'diabetes_melitus': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'epilepsy': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'haemorrhage': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'heart_disease': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'hepatitis': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'hypertension': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'kidney_disease': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'liver_problems': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'malaria': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'modified': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
'others': ('django.db.models.fields.TextField', [], {}),
'patient': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['patient.PatientInformation']"}),
'pelvic_backinjuries': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'rhesus_d_antibodies': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'seizures': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'sexually_transmitted_infection': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'sickle_cell_trait': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'tuberculosis': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'urinary_tract_surgeries': ('django.db.models.fields.BooleanField', [], {'default': 'False'})
},
u'patient.patientinformation': {
'Meta': {'object_name': 'PatientInformation'},
'address': ('django.db.models.fields.TextField', [], {}),
'created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
'date_of_birth': ('django.db.models.fields.DateField', [], {}),
'email': ('django.db.models.fields.EmailField', [], {'max_length': '75'}),
'first_name': ('django.db.models.fields.CharField', [], {'max_length': '50'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'last_name': ('django.db.models.fields.CharField', [], {'max_length': '50'}),
'marital_status': ('django.db.models.fields.CharField', [], {'max_length': '2'}),
'modified': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
'operator': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['auth.User']"}),
'sex': ('django.db.models.fields.CharField', [], {'max_length': '1'}),
'telephone_number': ('django.db.models.fields.CharField', [], {'max_length': '15'})
},
u'patient.presentmedicalhistory': {
'HIV_status_if_known': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'Meta': {'object_name': 'PresentMedicalHistory'},
'chronical_renal_disease': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
'date': ('django.db.models.fields.DateField', [], {}),
'diabetes_melitus': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'epilepsy': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'haemorrhage': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'heart_disease': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'hepatitis': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'hypertension': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'kidney_disease': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'liver_problems': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'malaria': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'modified': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
'others': ('django.db.models.fields.TextField', [], {}),
'patient': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['patient.PatientInformation']"}),
'pelvic_backinjuries': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'rhesus_d_antibodies': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'seizures': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'sexually_transmitted_infection': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'sickle_cell_trait': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'tuberculosis': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'urinary_tract_surgeries': ('django.db.models.fields.BooleanField', [], {'default': 'False'})
},
u'patient.previousobstetrichistory': {
'Meta': {'object_name': 'PreviousObstetricHistory'},
'age_of_baby': ('django.db.models.fields.CharField', [], {'max_length': '30'}),
'birth_weight': ('django.db.models.fields.CharField', [], {'max_length': '50'}),
'created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'length_of_pregnancy': ('django.db.models.fields.CharField', [], {'max_length': '10'}),
'modified': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
'name_of_baby': ('django.db.models.fields.CharField', [], {'max_length': '30'}),
'obstetrical_operation': ('django.db.models.fields.CharField', [], {'max_length': '2'}),
'patient': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['patient.PatientInformation']"}),
'periods_of_exclusive_feeding': ('django.db.models.fields.CharField', [], {'max_length': '30'}),
'problems': ('django.db.models.fields.CharField', [], {'max_length': '2'}),
'sex': ('django.db.models.fields.CharField', [], {'max_length': '1'}),
'types_of_delivery': ('django.db.models.fields.CharField', [], {'max_length': '2'}),
'year': ('django.db.models.fields.DateField', [], {})
},
u'patient.previoussurgery': {
'Meta': {'object_name': 'PreviousSurgery'},
'created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
'endometriosis': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
'fibrocystic_breasts': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'modified': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
'others_please_state': ('django.db.models.fields.CharField', [], {'max_length': '20'}),
'ovarian_cysts': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
'patient': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['patient.PatientInformation']"}),
'uterine_fibroids': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
u'patient.report': {
'Meta': {'object_name': 'Report'},
'created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
'diabetis': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'hiv': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'modified': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
'patient': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['patient.PatientInformation']"}),
'pregnancy': ('django.db.models.fields.BooleanField', [], {'default': 'False'})
},
u'patient.routinecheckup': {
'Meta': {'object_name': 'Routinecheckup'},
'abdominal_changes': ('django.db.models.fields.CharField', [], {'max_length': '2'}),
'blood_pressure': ('django.db.models.fields.CharField', [], {'max_length': '2'}),
'chest_and_heart_auscultation': ('django.db.models.fields.CharField', [], {'max_length': '2'}),
'created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
'date': ('django.db.models.fields.DateTimeField', [], {}),
'fetal_movement': ('django.db.models.fields.CharField', [], {'max_length': '300'}),
'height': ('django.db.models.fields.CharField', [], {'max_length': '200'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'modified': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
'name_of_examiner': ('django.db.models.fields.CharField', [], {'max_length': '50'}),
'patient': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['patient.PatientInformation']"}),
'sign_of_severe_anaemia': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['patient.Signanaemia']"}),
'symptom_events': ('django.db.models.fields.CharField', [], {'max_length': '300'}),
'uterine_height': ('django.db.models.fields.CharField', [], {'max_length': '200'}),
'vaginal_examination': ('django.db.models.fields.CharField', [], {'max_length': '200'}),
'visit': ('django.db.models.fields.CharField', [], {'max_length': '2'}),
'weight': ('django.db.models.fields.CharField', [], {'max_length': '200'})
},
u'patient.signanaemia': {
'Meta': {'object_name': 'Signanaemia'},
'conjunctiva': ('django.db.models.fields.CharField', [], {'max_length': '200'}),
'created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
'fingernails': ('django.db.models.fields.CharField', [], {'max_length': '200'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'modified': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
'oral_mucosa': ('django.db.models.fields.CharField', [], {'max_length': '200'}),
'others_please_state': ('django.db.models.fields.CharField', [], {'max_length': '200'}),
'pale_complexion': ('django.db.models.fields.CharField', [], {'max_length': '200'}),
'patient': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['patient.PatientInformation']"}),
'shortness_of_breath': ('django.db.models.fields.CharField', [], {'max_length': '200'}),
'tip_of_tongue': ('django.db.models.fields.CharField', [], {'max_length': '200'})
},
u'patient.ultrasoundscanning': {
'AC': ('django.db.models.fields.CharField', [], {'max_length': '10'}),
'BPD': ('django.db.models.fields.CharField', [], {'max_length': '10'}),
'CRL': ('django.db.models.fields.CharField', [], {'max_length': '10'}),
'FL': ('django.db.models.fields.CharField', [], {'max_length': '10'}),
'HC': ('django.db.models.fields.CharField', [], {'max_length': '10'}),
'Meta': {'object_name': 'UltrasoundScanning'},
'amount_of_amniotic_fluid': ('django.db.models.fields.IntegerField', [], {'max_length': '10'}),
'created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
'date': ('django.db.models.fields.DateTimeField', [], {}),
'gestation_age': ('django.db.models.fields.CharField', [], {'max_length': '40'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'modified': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
'name_examiner': ('django.db.models.fields.CharField', [], {'max_length': '40'}),
'patient': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['patient.PatientInformation']"}),
'position_of_the_baby': ('django.db.models.fields.CharField', [], {'max_length': '10'}),
'position_of_the_placenta': ('django.db.models.fields.CharField', [], {'max_length': '10'}),
'saved_ultrasound_image': ('django.db.models.fields.files.FileField', [], {'max_length': '100'})
}
}
complete_apps = ['patient'] | aazhbd/medical_info01 | patient/migrations/0004_auto__add_field_presentmedicalhistory_tuberculosis__add_field_presentm.py | Python | bsd-3-clause | 35,674 | [
"VisIt"
] | 887867219345feaa057c5f3f6998ecfce35aff0caebc946407521461990a7b44 |
##############################################################################
# Copyright (c) 2013-2018, Lawrence Livermore National Security, LLC.
# Produced at the Lawrence Livermore National Laboratory.
#
# This file is part of Spack.
# Created by Todd Gamblin, tgamblin@llnl.gov, All rights reserved.
# LLNL-CODE-647188
#
# For details, see https://github.com/spack/spack
# Please also see the NOTICE and LICENSE files for our notice and the LGPL.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License (as
# published by the Free Software Foundation) version 2.1, February 1999.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and
# conditions of the GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
##############################################################################
from spack import *
import sys
class Gdal(AutotoolsPackage):
"""GDAL is a translator library for raster and vector geospatial
data formats that is released under an X/MIT style Open Source
license by the Open Source Geospatial Foundation. As a library,
it presents a single raster abstract data model and vector
abstract data model to the calling application for all supported
formats. It also comes with a variety of useful command line
utilities for data translation and processing.
"""
homepage = "http://www.gdal.org/"
url = "http://download.osgeo.org/gdal/2.1.2/gdal-2.1.2.tar.xz"
list_url = "http://download.osgeo.org/gdal/"
list_depth = 1
version('2.1.2', 'ae85b78888514c75e813d658cac9478e')
version('2.0.2', '940208e737c87d31a90eaae43d0efd65')
extends('python')
variant('hdf5', default=False, description='Enable HDF5 support')
variant('hdf', default=False, description='Enable HDF4 support')
variant('openjpeg', default=False, description='Enable JPEG2000 support')
variant('geos', default=False, description='Enable GEOS support')
variant('kea', default=False, description='Enable KEA support')
variant('netcdf', default=False, description='Enable netcdf support')
depends_on('swig')
depends_on("hdf5", when='+hdf5')
depends_on("hdf", when='+hdf')
depends_on("openjpeg", when='+openjpeg')
depends_on("geos", when='+geos')
depends_on("kealib", when='+kea')
depends_on("netcdf", when='+netcdf')
depends_on("libtiff")
depends_on("libpng")
depends_on("zlib")
depends_on("proj")
depends_on("py-numpy", type=('build', 'run'))
parallel = False
def configure_args(self):
spec = self.spec
args = []
args.append("--with-liblzma=yes")
args.append("--with-zlib=%s" % spec['zlib'].prefix)
args.append("--with-python=%s" % spec['python'].command.path)
args.append("--without-libtool")
if '+geos' in spec:
args.append('--with-geos=yes')
if '+hdf' in spec:
args.append('--with-hdf4=%s' % spec['hdf'].prefix)
if '+hdf5' in spec:
args.append('--with-hdf5=%s' % spec['hdf5'].prefix)
if '+openjpeg' in spec:
args.append('--with-openjpeg=%s' % spec['openjpeg'].prefix)
if '+kea' in spec:
args.append('--with-kea=yes')
if '+netcdf' in spec:
args.append('--with-netcdf=%s' % spec['netcdf'].prefix)
return args
@run_after('install')
def darwin_fix(self):
# The shared library is not installed correctly on Darwin; fix this
if sys.platform == 'darwin':
fix_darwin_install_name(self.prefix.lib)
| EmreAtes/spack | var/spack/repos/builtin/packages/gdal/package.py | Python | lgpl-2.1 | 3,990 | [
"NetCDF"
] | 770eaaf0bcb2eada909f2903ced7c9c560b4e1203f0f3a25b54d6da7bcae4650 |
#!/usr/bin/env python
'''
Created on 4 Feb 2010
@author: tcezard
'''
import os, sys, logging
from optparse import OptionParser
import utils
from utils import utils_param, utils_logging, compare_version_number,\
get_bwa_version, longest_common_substr_from_start, utils_commands
import command_runner
from utils.GenomeLoader import GenomeLoader
from utils.parameters import Config_file_error
from utils.FastaFormat import FastaReader
def trim_fastq_to_length(fastq_file, output_file, length):
#output_file = fastq_file+'trim%s'%length
opener='cat'
if fastq_file.endswith('.gz'):
opener='zcat'
command = '''%s %s | awk '{if (NR%4==2 || NR%4==0){print substr($0, 1,%s)}else{print $0}}' > %s'''%(opener, fastq_file, length, output_file)
return_code = command_runner.run_command(command)
return return_code
def fastq_2_bam(fastq_file, rgid, qual, files_and_dir, fifo):
fastqToSam_jar=''
sam_file=''
run_fine=True
command="java -Xmx2G -jar %s F1=%s O=%s RG=%s LB=%s SM=%s, QUALITY_FORMAT=%s"%(fastqToSam_jar,fastq_file,sam_file,rgid,rgid,rgid,qual)
if fifo:
command+=" &"
return_code = command_runner.run_command(command)
if return_code is not 0:
run_fine = False
files_and_dir.append(sam_file)
sam_file2_tmp='%s.sam.tmp'%os.path.join(output_dir, fastq_name)
if fifo:
if os.path.exists(sam_file2_tmp):
os.remove(sam_file2_tmp)
command="mkfifo %s"%sam_file2_tmp
return_code = command_runner.run_command( command)
command = fix_read_name_in_sam_command(129, header=False)
command+=""" %s > %s"""%(sam_file2,sam_file2_tmp)
def fix_read_name_in_sam_command(flag_to_add, header=False):
command="""awk 'BEGIN{OFS="\\t"} """
command+="""{if (/^@/){}else{ext=substr($1,length($1)-1,2);if (ext ~ /[/_][12]/){$1=substr($1,1,length($1)-2)};"""
if header:
command+="""$2+=%s;} print $0}' """%flag_to_add
else:
command+="""$2+=%s; print $0}}' """%flag_to_add
return command
def get_fastq_length(fastq_file):
with open(fastq_file) as open_fastq:
open_fastq.readline()
line2 = open_fastq.readline()
read_length = len(line2.strip())
return read_length
def get_fasta_length(fasta_file):
length=0
with open(fasta_file) as open_fasta:
reader = FastaReader(open_fasta)
header,sequence = reader.next()
length=len(sequence)
return length
def run_BWA_Command_for_RAD(genome_file, fastq_file1, fastq_file2=None, output_dir=None, sample_name=None,
clean_up=True, thread=1, read_group=None, illumina=False, fifo=False):
run_fine=True
try:
pipeline_param=utils_param.get_pipeline_parameters()
BWA_dir=pipeline_param.get_bwa_dir()
samtools_dir=pipeline_param.get_samtools_dir()
picard_dir=pipeline_param.get_picard_dir()
#get the path to the current script to infer the path to RAD_set_read1_consensus_to_read2.py
script_dir = os.path.dirname(os.path.realpath(__file__))
path_to_script = os.path.join(script_dir,"RAD_set_read1_consensus_to_read2.py")
if not os.path.exists(path_to_script):
logging.warning("Can't find RAD_set_read1_consensus_to_read2.py which is required")
path_to_script = "RAD_set_read1_consensus_to_read2.py"
except Config_file_error, e:
#logging.exception('Config_file_error:')
logging.critical("You need to have the environment variable properly set to use that script")
return False
return_code=0
files_and_dir=[]
if fastq_file1.endswith('.gz'):
fastq_file1_unzip,ext = os.path.splitext(fastq_file1)
command = 'gunzip -c %s > %s'%(fastq_file1,fastq_file1_unzip)
return_code = command_runner.run_command(command)
if return_code is not 0:
run_fine = False
fastq_file1=fastq_file1_unzip
files_and_dir.append(fastq_file1)
if fastq_file2 and fastq_file2.endswith('.gz'):
fastq_file2_unzip,ext = os.path.splitext(fastq_file2)
command = 'gunzip -c %s > %s'%(fastq_file2,fastq_file2_unzip)
return_code = command_runner.run_command(command)
if return_code is not 0:
run_fine = False
fastq_file2=fastq_file2_unzip
files_and_dir.append(fastq_file2)
length_fastq1=get_fastq_length(fastq_file1)
length_fasta=get_fasta_length(genome_file)
if length_fastq1>length_fasta:
longer_reads = True
else:
longer_reads = False
if length_fastq1>100 and length_fasta>100:
long_read=True
else: long_read = False
#Get the sample name
if not sample_name:
if fastq_file2:
fastq_common = longest_common_substr_from_start(fastq_file1,fastq_file2)
#remove trailing underscore _ and get the base name
sample_name = os.path.basename(fastq_common.rstrip('_'))
else:
tmp, ext=os.path.splitext(os.path.basename(fastq_file1))
tmp=tmp.rstrip('1')
sample_name = os.path.basename(tmp.rstrip('_'))
BWA_bin=os.path.join(BWA_dir,'bwa')
# Check bwa version do not allow read group before version 0.9
if compare_version_number(get_bwa_version(BWA_bin), "0.5.9") <0:
logging.warning("Your version of bwa does not support the read group. Get version 0.5.9 or later to use this function.")
read_group_command=''
else:
if read_group:
read_group_command='-r "%s"'%(read_group)
for element in read_group.split(r'\\t'):
if element.startswith("ID"):
rgid=element.split(":")[1]
elif element.startswith("LB"):
libid=element.split(":")[1]
elif element.startswith("SM"):
smid=element.split(":")[1]
elif read_group is None:
rgid=sample_name
libid=sample_name
smid=sample_name
read_group_element=[]
read_group_element.append("@RG")
read_group_element.append("ID:%s"%sample_name)
read_group_element.append("LB:%s"%sample_name)
read_group_element.append("CN:The Genepool")
read_group_element.append("PL:ILLUMINA")
read_group_element.append("SM:%s"%sample_name)
read_group_command= '-r "%s"'%('\\t'.join(read_group_element))
samtools_bin=os.path.join(samtools_dir,'samtools')
#Starts processing
if longer_reads:
#Trim the long read
name,ext = os.path.splitext(fastq_file1)
fastq_file1_trim=name+'_trim%s.fastq'%(length_fasta)
command = """awk '{if (NR%%2==0){print substr($0,1,%s)}else{print}}' %s > %s"""%(length_fasta,fastq_file1,fastq_file1_trim)
return_code = command_runner.run_command(command)
files_and_dir.append(fastq_file1_trim)
fastq_file1_long=fastq_file1
fastq_file1=fastq_file1_trim
if output_dir is None:
output_dir=os.path.dirname(fastq_file1)
if not fastq_file2:
#if long_read:
# sorted_bam_file = align_long_reads_se(fastq_file1, genome_file, output_dir, sample_name, thread, BWA_bin,
# samtools_bin, picard_dir, read_group_command, files_and_dir, illumina, fifo)
#else:
sorted_bam_file = align_short_reads_se(fastq_file1, genome_file, output_dir, sample_name, thread, BWA_bin,
samtools_bin, picard_dir, read_group_command, files_and_dir, illumina, fifo)
else:
#if long_read:
# sam_file = align_long_reads_pe(fastq_file1, fastq_file2, genome_file, output_dir, sample_name, thread, BWA_bin,
# samtools_bin, picard_dir, read_group_command, files_and_dir, illumina, fifo)
#else:
read1_sam_file,read2_sam_file = align_short_reads_pe(fastq_file1,fastq_file2, genome_file, output_dir,thread,
BWA_bin, samtools_bin, picard_dir, read_group_command,
rgid,libid,smid, files_and_dir, illumina, fifo)
if longer_reads:
#Now convert the first untrimmed read to sam
read1_long_sam_file = convert_untrimmed_read(fastq_file1_long,output_dir,rgid,libid,smid,picard_dir,
files_and_dir, illumina, fifo)
read2_sam_file = '%s %s'%(read1_long_sam_file,read2_sam_file)
name_sorted_bam_file=os.path.join(output_dir, sample_name+'_sorted_name')
command = "cat %s %s | %s view -bS - | %s sort -n - %s"%(read1_sam_file,read2_sam_file, samtools_bin, samtools_bin, name_sorted_bam_file)
return_code = command_runner.run_command(command)
if return_code is not 0:
run_fine = False
files_and_dir.append(name_sorted_bam_file+'.bam')
sorted_bam_file=os.path.join(output_dir, sample_name+'_sorted')
#change_consensus_on_read2
command ="%s view -h %s | "%(samtools_bin,name_sorted_bam_file+'.bam')
if longer_reads:
command +="python %s -p | "%path_to_script
else:
command +="python %s | "%path_to_script
command +="%s view -bS - | %s sort - %s"%(samtools_bin, samtools_bin, sorted_bam_file)
return_code = command_runner.run_command(command)
if return_code is not 0:
run_fine = False
sorted_bam_file=sorted_bam_file+".bam"
command="%s index %s"%(samtools_bin, sorted_bam_file)
return_code = command_runner.run_command(command)
if return_code is not 0:
run_fine = False
if run_fine and clean_up:
return_code = remove_file(files_and_dir)
if return_code is not 0:
run_fine = False
return run_fine
def align_bwa_long(fastq_file1, fastq_file2, genome_file, sample_name, read_group, analysis_type, output_dir,
BWA_bin, samtools_bin, picard_dir, thread, sort, illumina, files_and_dir):
if illumina:
logging.error("long read alignment do not support illumina format")
return False
if analysis_type is not None:
logging.error("long read alignment do not support %s analsyis"%(analysis_type))
return False
run_fine=True
tmp_bam_file=os.path.join(output_dir, sample_name+'_tmp.bam')
files_and_dir.append(tmp_bam_file)
if fastq_file2:
command = '%s mem -t %s %s %s %s | %s view -bS - > %s'%(BWA_bin, thread, genome_file, fastq_file1, fastq_file2, samtools_bin, tmp_bam_file)
else:
command = '%s bwasw -t %s %s %s | %s view -bS - > %s'%(BWA_bin, thread, genome_file, fastq_file1, samtools_bin, tmp_bam_file)
if run_fine: return_code = command_runner.run_command(command)
if return_code is not 0:
run_fine = False
if sort:
bam_file=os.path.join(output_dir, sample_name+'_sorted.bam')
sort_order='coordinate'
else:
bam_file=os.path.join(output_dir, sample_name+'.bam')
sort_order='queryname'
#bwa screw up the mate information
fixmate_jar = os.path.join(picard_dir, 'FixMateInformation.jar')
fixed_bam_file=os.path.join(output_dir, sample_name+'_fixed.bam')
command = 'java -jar -Xmx2G %s I=%s O=%s SO=%s VALIDATION_STRINGENCY=LENIENT'%(fixmate_jar, tmp_bam_file, fixed_bam_file, sort_order)
if run_fine: return_code = command_runner.run_command(command)
if return_code is not 0:
run_fine = False
if read_group:
files_and_dir.append(fixed_bam_file)
read_group_param=[]
read_group_elements = extract_read_group(read_group)
replace_readgroup_jar = os.path.join(picard_dir, 'AddOrReplaceReadGroups.jar')
for key in ['ID', 'LB', 'PL', 'PU', 'SM', 'CN']:
if read_group_elements.has_key(key):
read_group_param.append('%s="%s"'%(key, read_group_elements.get(key)))
else:
read_group_param.append('%s=0'%(key))
command = 'java -jar -Xmx2G %s I=%s O=%s SO=%s %s VALIDATION_STRINGENCY=LENIENT'%(replace_readgroup_jar, fixed_bam_file, bam_file, sort_order, ' '.join(read_group_param))
if run_fine: return_code = command_runner.run_command(command)
if return_code is not 0: run_fine = False
else:
bam_file=os.path.join(output_dir, sample_name+'.bam')
command='mv %s %s'%(fixed_bam_file, bam_file)
if run_fine: return_code = command_runner.run_command(command)
if return_code is not 0: run_fine = False
if run_fine:
return bam_file
else:
return False
def align_short_reads_se(fastq_file1, genome_file, output_dir, sample_name, thread,
BWA_bin, samtools_bin, picard_dir, read_group_command, files_and_dir, illumina, fifo):
fastq_name, ext=os.path.splitext(os.path.basename(fastq_file1))
sai_file1='%s.sai'%os.path.join(output_dir,fastq_name)
illumina_str=""
if illumina:
illumina_str=" -I "
command='%s aln %s -t %s %s %s > %s'%(BWA_bin, illumina_str,thread, genome_file, fastq_file1, sai_file1)
return_code = command_runner.run_command(command)
if return_code is not 0:
run_fine = False
files_and_dir.append(sai_file1)
#only one end so just run get the sorted bam file
bam_file=os.path.join(output_dir, sample_name+"_sorted")
command="""%s samse %s %s %s %s | %s view -bS - | %s sort - %s"""%(BWA_bin, read_group_command, genome_file, sai_file1,
fastq_file1, samtools_bin, samtools_bin, bam_file )
return_code = command_runner.run_command( command)
if return_code is not 0:
run_fine = False
return bam_file
def align_short_reads_pe(fastq_file1, fastq_file2, genome_file, output_dir, thread,
BWA_bin, samtools_bin, picard_dir, read_group_command, rgid,libid,smid,
files_and_dir, illumina, fifo):
#Align the first read
fastq_name, ext=os.path.splitext(os.path.basename(fastq_file1))
sai_file1='%s.sai'%os.path.join(output_dir,fastq_name)
illumina_str=""
if illumina:
illumina_str=" -I "
command='%s aln %s -t %s %s %s > %s'%(BWA_bin, illumina_str,thread, genome_file, fastq_file1, sai_file1)
return_code = command_runner.run_command(command)
if return_code is not 0:
run_fine = False
files_and_dir.append(sai_file1)
#Need to add to the first read the flag info specific to the paired end
read1_sam_file=os.path.join(output_dir, fastq_name+'.sam')
if fifo:
command="mkfifo %s"%read1_sam_file
if os.path.exists(read1_sam_file):
os.remove(read1_sam_file)
return_code = command_runner.run_command( command)
command="""%s samse %s %s %s %s | """%(BWA_bin, read_group_command,genome_file,sai_file1,fastq_file1)
command+=fix_read_name_in_sam_command(73, header=True)
command+=""" > %s"""%( read1_sam_file )
if fifo:
command+=" &"
return_code = command_runner.run_command( command)
if return_code is not 0:
run_fine = False
files_and_dir.append(read1_sam_file)
#Now convert the second read to sam
fastq_name, ext=os.path.splitext(os.path.basename(fastq_file2))
sam_file2='%s.sam'%os.path.join(output_dir,fastq_name)
if fifo:
command="mkfifo %s"%sam_file2
if os.path.exists(sam_file2):
os.remove(sam_file2)
return_code = command_runner.run_command( command)
fastqToSam_jar=os.path.join(picard_dir,"FastqToSam.jar")
if illumina:
qual="Illumina"
else:
qual="Standard"
command="java -Xmx2G -jar %s F1=%s O=%s RG=%s LB=%s SM=%s, QUALITY_FORMAT=%s"%(fastqToSam_jar,fastq_file2,sam_file2,rgid,libid,smid,qual)
if fifo:
command+=" &"
return_code = command_runner.run_command(command)
if return_code is not 0:
run_fine = False
files_and_dir.append(sam_file2)
read2_sam_file='%s.tmp'%(sam_file2)
if fifo:
if os.path.exists(read2_sam_file):
os.remove(read2_sam_file)
command="mkfifo %s"%read2_sam_file
return_code = command_runner.run_command( command)
command=fix_read_name_in_sam_command(129, header=False)
command+=""" %s > %s"""%(sam_file2, read2_sam_file)
if fifo:
command+=" &"
return_code = command_runner.run_command(command)
if return_code is not 0:
run_fine = False
files_and_dir.append(read2_sam_file)
return read1_sam_file,read2_sam_file
def convert_untrimmed_read(fastq_file, output_dir, rgid,libid,smid, picard_dir, files_and_dir, illumina, fifo):
fastq_name, ext=os.path.splitext(os.path.basename(fastq_file))
sam_file='%s.sam'%os.path.join(output_dir,fastq_name)
if fifo:
command="mkfifo %s"%sam_file
if os.path.exists(sam_file):
os.remove(sam_file)
return_code = command_runner.run_command(command)
fastqToSam_jar=os.path.join(picard_dir,"FastqToSam.jar")
if illumina:
qual="Illumina"
else:
qual="Standard"
command="java -Xmx2G -jar %s F1=%s O=%s RG=%s LB=%s SM=%s, QUALITY_FORMAT=%s"%(fastqToSam_jar,fastq_file,sam_file,rgid,libid,smid,qual)
if fifo:
command+=" &"
return_code = command_runner.run_command(command)
if return_code is not 0:
run_fine = False
files_and_dir.append(sam_file)
read_sam_tmp='%s.tmp'%(sam_file)
if fifo:
if os.path.exists(read_sam_tmp):
os.remove(read_sam_tmp)
command="mkfifo %s"%read_sam_tmp
return_code = command_runner.run_command( command)
command=fix_read_name_in_sam_command(65, header=False)
command+=""" %s > %s"""%(sam_file, read_sam_tmp)
if fifo:
command+=" &"
return_code = command_runner.run_command(command)
if return_code is not 0:
run_fine = False
files_and_dir.append(read_sam_tmp)
return read_sam_tmp
def remove_file(files_and_dir):
return command_runner.run_command( 'rm -fr %s'%(' '.join(files_and_dir)))
def check_genome_index(genome_file):
genome_index_valid=True
#extensions=['','.rbwt', '.amb', '.rpac', '.ann', '.rsa','.bwt','.sa', '.pac']
extensions=['','.amb', '.ann', '.bwt','.sa', '.pac']
for ext in extensions:
if not os.path.exists(genome_file+ext):
logging.error("%s doesn't exist"%(genome_file+ext))
genome_index_valid=False
return genome_index_valid
def main():
#initialize the logging
utils_logging.init_logging()
#Setup options
optparser=_prepare_optparser()
(options,args) = optparser.parse_args()
#verify options
arg_pass=_verifyOption(options)
if not arg_pass:
logging.warning(optparser.get_usage())
logging.critical("Non valid arguments: exit")
sys.exit(1)
#utils_logging.change_log_stdout_to_log_stderr()
if options.print_commands:
utils_logging.change_log_stdout_to_log_stderr()
else:
command_runner.set_command_to_run_localy()
run_fine=run_BWA_Command_for_RAD(options.genome_file, options.fastq_file1, options.fastq_file2,
options.output_dir, options.name, thread=options.thread, read_group=options.read_group,
illumina=options.illumina, fifo=options.fifo)
if run_fine:
logging.info('Run completed')
else:
logging.error('Run Failed')
sys.exit(1)
def _prepare_optparser():
"""Prepare optparser object. New options will be added in this
function first.
"""
usage = """usage: %prog <-g genome_fasta> <-1 first fastq file> [ -2 second fastq file -n sample_name]"""
description = """This script will align read in Sanger fastq format to a reference genome and create a bam file. using bwa and samtools"""
prog_version=utils.getWtss_version()
optparser = OptionParser(version="%prog of wtss_pipeline v"+prog_version,description=description,usage=usage,add_help_option=False)
optparser.add_option("-h","--help",action="help",help="show this help message and exit.")
optparser.add_option("-g","--genome_file",dest="genome_file",type="string",
help="Path to a fasta file where the genome is located. Default: %default")
optparser.add_option("-1","--fastq1",dest="fastq_file1",type="string",
help="Path to the first fastq file where the first reads are. This file is mandatory. Default: %default")
optparser.add_option("-2","--fastq2",dest="fastq_file2",type="string",
help="Path to the second fastq file where the second reads are. This file is optional. Default: %default")
optparser.add_option("-o","--output_dir",dest="output_dir",type="string",
help="The path to the directory where the results will be output. If not set, the results will be put in the same folder as fastq1. Default: %default")
optparser.add_option("-n","--name",dest="name",type="string",
help="The name of the sample currently being aligned. Default: %default")
optparser.add_option("-t", "--thread",dest="thread",type='int',default=1,
help="Number of thread used by the alignment algorithm. Default: %default")
optparser.add_option("--illumina",dest="illumina",action='store_true',default=False,
help="the fastq file are in illumina 1.3-1.6 fastq format. Default: %default")
optparser.add_option("--print",dest="print_commands",action='store_true',default=False,
help="Print the command instead of running them. Default: %default")
optparser.add_option("--fifo",dest="fifo",action='store_true',default=False,
help="Use fifo to avoid writing big temp file to the disk. Default: %default")
optparser.add_option("-r", "--readgroup",dest="read_group",type="string",help="Set read group for SAM file:\n"+"Example: RG\tID:uid\tSM:sample\tPL:Illumina\n")
return optparser
def _verifyOption(options):
"""Check if the mandatory option are present in the options objects.
@return False if any argument is wrong."""
arg_pass=True
if not options.genome_file :
logging.error("You must specify a genome fasta file.")
arg_pass=False
elif not os.path.exists(options.genome_file):
logging.error("Genome fasta file not found. You must specify an existing genome fasta file.")
arg_pass=False
elif not check_genome_index(options.genome_file):
logging.error("Genome fasta file is not indexed properly. You must index the genome first.")
arg_pass=False
#if not options.read_group:
# logging.error("You must specify a read group with ID, SM and PL attributes.")
# arg_pass=False
if not options.fastq_file1:
logging.error("You must specify at least one fastq file.")
arg_pass=False
elif not os.path.exists(options.fastq_file1):
logging.error("fastq1 file %s not found. You must specify an existing file."%options.fastq_file1)
arg_pass=False
if options.fastq_file2:
if not os.path.exists(options.fastq_file2):
logging.error("fastq2 file %s not found. You must specify an existing file."%options.fastq_file2)
arg_pass=False
if options.output_dir:
if not os.path.exists(options.output_dir):
logging.error("output directory %s not found. You must specify an existing directory."%options.output_dir)
arg_pass=False
return arg_pass
if __name__=="__main__":
main()
| tcezard/RADmapper | bin/RAD_assign_reads_to_consensus.py | Python | mit | 23,962 | [
"BWA"
] | 2ab713e8fca78ce1c5817e5b9a43a3cee27872b640be0a2891e6e3e41e422c55 |
# ======================================================================
# USER-GFMD - Elastic half-space methods for LAMMPS
# https://github.com/Atomistica/user-gfmd
#
# Copyright (2011-2016,2021)
# Lars Pastewka <lars.pastewka@imtek.uni-freiburg>,
# Tristan A. Sharp and others.
# See the AUTHORS file in the top-level USER-GFMD directory.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
# ======================================================================
# Quick script to plot the force difference between GF and full dump files.
# A dump file exists for each "probe displacement magnitude"
# TAS Feb 14 2014 - IDL to Python and boolean test criterion v00
# TAS May 12 2014 - Update comments and update test criterion to v01
# GFMD is
# Order u**2 accurate in energy
# Order u accurate in force
# So if GFMD is working, error in force should be quadratic with displacement u
# To match up probe atoms in the two probe dump files based on location, use this algorithm:
# Travervse atom1 array: for jj=0...N-1 * * * * * * * and find closest atom2 (at location "here")
# put the "here" values into sortorder = [0,1,3,3,2,4,X]
# Look for duplicate pairing and record where no pairing (X) was found in recallbadindices
# Could also use atom ids
import numpy
import glob
import pdb
# A function to find the magnitude of the difference of two 3D vectors
def diffmag(fx1,fy1,fz1,fx2,fy2,fz2):
return ((fx1-fx2)**(2.)+(fy1-fy2)**(2.)+(fz1-fz2)**(2.))**(0.5)
# Read energies from LAMMPS log file
def read_energy_difference(fn):
e = []
f = open(fn)
l = f.readline()
last_l = l
while l:
if l.startswith('Loop time'):
step, energy = list(map(float, last_l.split()))
e += [energy]
last_l = l
l = f.readline()
if len(e) == 2:
return e[1]-e[0]
elif len(e) == 3:
return e[2]-e[1]
elif len(e) == 4:
return e[3]-e[1]
else:
raise RuntimeError('Expected two, three or four runs in output.')
# Approx distance scale between atoms for error checking in this test
nn_scale = 1.0
# These are the relative step sizes of probe atoms in the test
#dstep = (1e-6, 1e-4, 1e-2, 1e-0)
#folders = ('dstep0.000001/','dstep0.0001/','dstep0.01/','dstep1.0/')
folders = glob.glob('01_test/dstep*')
dsteplist = [float(x[x.find('dstep')+5:]) for x in folders]
dstep = numpy.array(dsteplist)
interactivemode = 0
if interactivemode:
print(folders, dstep)
# ---------------------------------------------- #
# Nothing below here should need to be changed
# ---------------------------------------------- #
# The force on probe atoms (squared) and
# the error in the GF-calculated force (squared) at that dstep
err2=numpy.zeros((len(dstep),))
absmag2=numpy.zeros((len(dstep),))
eerr=numpy.zeros((len(dstep),))
if interactivemode:
print("Now we will print the contents of the probe dump files, with each")
print("probe atom identified in the GF run with the corresponding one in the full run")
for i in numpy.arange(len(dstep)):
if interactivemode:
print(folders[i])
# read the energies
denergy_gf = read_energy_difference(folders[i]+'/log.gf')
denergy_full = read_energy_difference(folders[i]+'/log.full')
eerr[i] = denergy_full-denergy_gf
# read in the init forces
init_pos_and_forces_gf = numpy.loadtxt(folders[i]+'/dumpinitprobegf', skiprows=9).reshape(-1,6)
init_pos_and_forces_full = numpy.loadtxt(folders[i]+'/dumpinitprobefull', skiprows=9).reshape(-1,6)
# read in the final forces
pos_and_forces_gf = numpy.loadtxt(folders[i]+'/dumpprobegf', skiprows=9).reshape(-1,6)
pos_and_forces_full = numpy.loadtxt(folders[i]+'/dumpprobefull', skiprows=9).reshape(-1,6)
x1 =pos_and_forces_gf[:,0]-init_pos_and_forces_gf[:,0]
y1 =pos_and_forces_gf[:,1]-init_pos_and_forces_gf[:,1]
z1 =pos_and_forces_gf[:,2]-init_pos_and_forces_gf[:,2]
fx1=pos_and_forces_gf[:,3]-init_pos_and_forces_gf[:,3]
fy1=pos_and_forces_gf[:,4]-init_pos_and_forces_gf[:,4]
fz1=pos_and_forces_gf[:,5]-init_pos_and_forces_gf[:,5]
x2 =pos_and_forces_full[:,0]-init_pos_and_forces_full[:,0]
y2 =pos_and_forces_full[:,1]-init_pos_and_forces_full[:,1]
z2 =pos_and_forces_full[:,2]-init_pos_and_forces_full[:,2]
fx2=pos_and_forces_full[:,3]-init_pos_and_forces_full[:,3]
fy2=pos_and_forces_full[:,4]-init_pos_and_forces_full[:,4]
fz2=pos_and_forces_full[:,5]-init_pos_and_forces_full[:,5]
if len(x1) != len(x2):
print("File data not even the same length! Invalid test."\
"(Different number of probe atoms in in.gf and in.full?)")
sortorder=numpy.zeros((len(x1),), dtype=int)
recallbadindices=numpy.zeros((len(x1),), dtype=int)
# Loop through all GF atoms
no_err=1
for jj in numpy.arange(len(x1)):
# Find the distance of all other atoms to this GF atom
distsq_of_atoms_to_atomjj = (x2-x1[jj])**(2.) + (y2-y1[jj])**(2.) + (z2-z1[jj])**(2.)
min_distsq_of_atoms_to_atomjj = min(distsq_of_atoms_to_atomjj)
# Print error message if atoms in the two files aren't even close together
if min_distsq_of_atoms_to_atomjj > (nn_scale/4.)**(2.):
if no_err:
print("Warning: atoms not even close to co-located; ID-ing may break down and "\
"artifically increase the error. May be due to PBCs, if only 1 atom has wrapped.")
no_err = 1
recallbadindices[jj] = 1 # Atom1[jj] has nothing near it and should never be used
# Record this atom's spatially colocated atom
else:
here = numpy.nonzero(distsq_of_atoms_to_atomjj == min(distsq_of_atoms_to_atomjj))[0]
if len(here) > 1:
print("Error: Possibly multiple atoms in file2 equally near atom jj in file 1")
exit
sortorder[jj]=here
# Sort the second file's array to the same order as the first's
x2 = x2[sortorder]
y2 = y2[sortorder]
z2 = z2[sortorder]
fx2=fx2[sortorder]
fy2=fy2[sortorder]
fz2=fz2[sortorder]
# The force vector (and error) are 3N dimensional. Calculate the magnitude squared.
for jj in numpy.arange(len(x1)):
if not (recallbadindices[jj]):
err2[i] += (diffmag(fx1[jj],fy1[jj],fz1[jj],fx2[jj],fy2[jj],fz2[jj]))**(2.0)
absmag2[i] += (diffmag(fx1[jj],fy1[jj],fz1[jj],0,0,0))**(2.0)
# Print for visual check; useful if need to debug this script
if interactivemode:
print("%14s%14s%14s%14s%14s%14s%14s%14s" % ( " ", " de", " dx", " dy", " dz", " fx", " fy", " fz" ))
for jj in numpy.arange(len(x1)):
if not (recallbadindices[jj]):
if (diffmag(x1[jj],y1[jj],z1[jj],x2[jj],y2[jj],z2[jj]) > (nn_scale/4.)):
print("Analysis script fatal error: The comparison is invalid but was not flagged!")
print("%14s%14e%14e%14e%14e%14e%14e%14e" % ( "full", denergy_full, x1[jj], y1[jj], z1[jj], fx1[jj], fy1[jj], fz1[jj] ))
print("%14s%14e%14e%14e%14e%14e%14e%14e" % ( "gf ", denergy_gf, x2[jj], y2[jj], z2[jj], fx2[jj], fy2[jj], fz2[jj] ))
print((err2[i])**(0.5), "/", (absmag2[i])**(0.5))
relerr = (err2)**(0.5)/(absmag2)**(0.5)
if interactivemode:
print("relative error", relerr)
numpy.savetxt('err.out', numpy.transpose([dstep, (err2)**(0.5), relerr, eerr]))
# Create an automated test to return a pass/fail boolean
# Check that force error goes like the square of the displacement err ~ u^(2-tolerance)
testpass=1
# Pick two folders (large dstep and small dstep)
largedstepindex = numpy.flatnonzero((dstep >= 1e-2*nn_scale) & (dstep < 4e-2*nn_scale))
if len(largedstepindex) < 1:
print("No test dstep was between 1e-2 and 4e-2 of the nearest neighbor distance", nn_scale)
testpass=0
else:
largedstepindex = (largedstepindex)[0]
if (relerr[largedstepindex] > 0.1):
raise RuntimeError("Greater than 10% error found when displacing probes "+repr(dstep[largedstepindex]))
testpass=0
smalldstepindex = numpy.flatnonzero((dstep >= 1e-4*nn_scale) & (dstep < 2e-3*nn_scale))
if len(smalldstepindex) < 1:
print("No test dstep was between 1e-4 and 2e-3 of the nearest neighbor distance", nn_scale)
testpass=0
else:
smalldstepindex = (smalldstepindex)[0]
if testpass == 1:
tolerance = 0.1
largedsteperr=(err2[largedstepindex])**(0.5)
smalldsteperr=(err2[smalldstepindex])**(0.5)
goeslike = numpy.log(smalldsteperr / largedsteperr) / numpy.log(dstep[smalldstepindex] / dstep[largedstepindex])
print("Difference goes like displacement to the "+repr(goeslike)+\
" between u= "+repr(dstep[smalldstepindex])+" and "+repr(dstep[largedstepindex]))
if (2.0 - goeslike > tolerance):
raise RuntimeError("Fail: Force error did not shrink (approx) like the square of displacement.")
testpass=0
if testpass:
print("Test passed! Check criterion: v01")
print("return 1")
f=open('goodness_measure.txt', 'w')
f.write('Difference goes like displacement to the '+repr(goeslike)+'\n')
f.write(' between u= '+repr(dstep[smalldstepindex])+' and '+repr(dstep[largedstepindex])+'\n')
f.write('Fractional error '+repr(relerr[largedstepindex])+' at dstep '+repr(dstep[largedstepindex])+'\n')
f.close()
| Atomistica/user-gfmd | tests/TEST_error_convergence_ft_two_layers_lj_cut/eval.py | Python | gpl-2.0 | 9,609 | [
"LAMMPS"
] | 108dce556788d2c81f1e3ce482c59115728f9cd868340a9734b5290b4bdfd246 |
"""
The weather-helper script sets the weather data used (``inputs/weather.epw``) for simulations.
"""
import os
import cea.config
import cea.inputlocator
__author__ = "Daren Thomas"
__copyright__ = "Copyright 2019, Architecture and Building Systems - ETH Zurich"
__credits__ = ["Daren Thomas"]
__license__ = "MIT"
__version__ = "0.1"
__maintainer__ = "Daren Thomas"
__email__ = "cea@arch.ethz.ch"
__status__ = "Production"
def copy_weather_file(source_weather_file, locator):
"""
Copy a weather file to the scenario's inputs.
:param string source_weather_file: path to a weather file (``*.epw``)
:param cea.inputlocator.InputLocator locator: use the InputLocator to find output path
:return: (this script doesn't return anything)
"""
from shutil import copyfile
assert os.path.exists(source_weather_file), "Could not find weather file: {source_weather_file}".format(
source_weather_file=source_weather_file
)
copyfile(source_weather_file, locator.get_weather_file())
print("Set weather for scenario <{scenario}> to {source_weather_file}".format(
scenario=os.path.basename(locator.scenario),
source_weather_file=source_weather_file
))
def main(config):
"""
Assign the weather file to the input folder.
:param cea.config.Configuration config: Configuration object for this script
:return:
"""
assert os.path.exists(config.scenario), 'Scenario not found: %s' % config.scenario
locator = cea.inputlocator.InputLocator(config.scenario)
copy_weather_file(config.weather_helper.weather, locator)
if __name__ == '__main__':
main(cea.config.Configuration())
| architecture-building-systems/CEAforArcGIS | cea/datamanagement/weather_helper.py | Python | mit | 1,672 | [
"EPW"
] | 6ae378bcd3f7d1923d0cbe6e6fea837820b523f261eb4c7b30c0e53fd7f3c6ff |
import numpy as np
import pybinding as pb
from pybinding.constants import pi, phi0, hbar
__all__ = ['mass_term', 'coulomb_potential', 'constant_magnetic_field',
'triaxial_strain', 'gaussian_bump']
def mass_term(delta):
"""Break sublattice symmetry, make massive Dirac electrons, open a band gap
Only for monolayer graphene.
Parameters
----------
delta : float
Onsite energy +delta is added to sublattice 'A' and -delta to 'B'.
"""
@pb.onsite_energy_modifier
def onsite(energy, sub_id):
energy[sub_id == "A"] += delta
energy[sub_id == "B"] -= delta
return energy
return onsite
def coulomb_potential(beta, cutoff_radius=.0, offset=(0, 0, 0)):
"""A Coulomb potential created by an impurity in graphene
Parameters
----------
beta : float
Charge of the impurity [unitless].
cutoff_radius : float
Cut off the potential below this radius [nm].
offset: array_like
Position of the charge.
"""
from .constants import vf
# beta is dimensionless -> multiply hbar*vF makes it [eV * nm]
scaled_beta = beta * hbar * vf
@pb.onsite_energy_modifier
def potential(energy, x, y, z):
x0, y0, z0 = offset
r = np.sqrt((x - x0)**2 + (y - y0)**2 + (z - z0)**2)
r[r < cutoff_radius] = cutoff_radius
return energy - scaled_beta / r
return potential
def constant_magnetic_field(magnitude):
"""Constant magnetic field in the z-direction, perpendicular to the graphene plane
Parameters
----------
magnitude : float
In units of Tesla.
"""
scale = 1e-18 # both the vector potential and coordinates are in [nm] -> scale to [m]
const = scale * 2 * pi / phi0
@pb.hopping_energy_modifier(is_complex=True)
def func(energy, x1, y1, x2, y2):
# vector potential along the x-axis
vp_x = 0.5 * magnitude * (y1 + y2)
# integral of (A * dl) from position 1 to position 2
peierls = vp_x * (x1 - x2)
return energy * np.exp(1j * const * peierls)
return func
@pb.hopping_energy_modifier
def strained_hopping(energy, x1, y1, z1, x2, y2, z2):
from .constants import a_cc, beta
l = np.sqrt((x1 - x2)**2 + (y1 - y2)**2 + (z1 - z2)**2)
w = l / a_cc - 1
return energy * np.exp(-beta * w)
def triaxial_strain(magnetic_field):
"""Triaxial strain corresponding to a homogeneous pseudo-magnetic field
Parameters
----------
magnetic_field : float
Intensity of the pseudo-magnetic field to induce.
"""
from .constants import a_cc, beta
def field_to_strain(field):
return field * a_cc / (4 * hbar * beta) * 10**-18
c = field_to_strain(magnetic_field)
zigzag_direction = False
@pb.site_position_modifier
def displacement(x, y, z):
if not zigzag_direction:
ux = 2*c * x*y
uy = c * (x**2 - y**2)
else:
ux = c * (y**2 - x**2)
uy = 2*c * x*y
x += ux
y += uy
return x, y, z
return displacement, strained_hopping
def gaussian_bump(height, sigma, center=(0, 0)):
"""Gaussian bump deformation
Parameters
----------
height : float
Height of the bump [nm].
sigma : float
Gaussian sigma parameter: controls the width of the bump [nm].
center : array_like
Position of the center of the bump.
"""
@pb.site_position_modifier
def displacement(x, y):
x0, y0 = center
r2 = (x - x0)**2 + (y - y0)**2
z = height * np.exp(-r2 / sigma**2)
return x, y, z
return displacement, strained_hopping
| dean0x7d/pybinding | pybinding/repository/graphene/modifiers.py | Python | bsd-2-clause | 3,680 | [
"DIRAC",
"Gaussian"
] | 32735bebd21d50c3336fd4f4f697e91c800f909df738ebc5eca5960132090ca0 |
# class generated by DeVIDE::createDeVIDEModuleFromVTKObject
from module_kits.vtk_kit.mixins import SimpleVTKClassModuleBase
import vtk
class vtkXMLPolyDataReader(SimpleVTKClassModuleBase):
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkXMLPolyDataReader(), 'Reading vtkXMLPolyData.',
(), ('vtkXMLPolyData',),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
| nagyistoce/devide | modules/vtk_basic/vtkXMLPolyDataReader.py | Python | bsd-3-clause | 496 | [
"VTK"
] | 9bff384fb1d264cd3c872480fffee6914ea7a2edf8eb0599412ac9ffcc43e5ce |
"""1-D Gaussian Processes for Regression and Bayesian Optimization"""
# Author: Charles Franzen
# License: MIT
from functools import partial
import numpy as np
import numpy.linalg as LA
import pandas as pd
import matplotlib.pyplot as plt
from scipy import stats
import dillinger.kernel_functions as kern
# main Gaussian Process class, with sample and fit methods.
class GaussianProcess:
'''Gaussian Processes for Regression.
Args:
domain (ndarray): Points in the domain.
kernel_function (string or Kernel):
Kernel to be used for covariance matrices. Can be a string
specifying a kernel function or a Kernel instance.
kernel_args (dict):
Dictionary of keyword arguments to pass the the kernel function.
noise (float): Gaussan noise assumed in observations.
'''
def __init__(self, domain: np.ndarray, kernel_function,
kernel_args=None, noise=1.):
self.domain = domain
self.domain.shape = -1, 1
self.n = np.prod(domain.shape)
self.noise = noise
if type(kernel_function) is str:
kernel_function = kern._kernel_dict[kernel_function]
self.kernel_obj = None
if kernel_args:
self.kernel_args = kernel_args
self.kernel = partial(kernel_function, **kernel_args)
else:
self.kernel = kernel_function
else: # for Kernel objects
if kernel_args:
self.kernel_args = kernel_args
self.kernel_obj = kernel_function(**kernel_args)
else:
self.kernel_obj = kernel_function()
self.kernel = self.kernel_obj.covariance
self.K = kern.cov_mat(self.kernel, self.domain, self.domain)
self.μ = np.zeros(self.n)
self.μ.shape = -1, 1
self.obs = None
def expected_improvement(self):
'''Expected improvement over the domain.
Returns:
ei (ndarray):
Expected improvement values at each point in the domain.
'''
obs_df = pd.DataFrame(self.obs, columns=['x', 'y'])
# mean observation at each point in the domain
mean_obs = obs_df.groupby('x').mean()
best_val = mean_obs.y.max()
# EI calculation
sigma = np.sqrt(np.diag(self.K))
gamma = (self.μ.flatten() - best_val) / sigma
ei = sigma * (gamma * stats.norm.cdf(gamma) + stats.norm.pdf(gamma))
return ei
def fit(self, x, y, clear_obs=False, **optimizer_args):
'''Fit the GP to observed data
Args:
x (ndarray): domain values
y (ndarray): noisy observations
clear_obs (bool): if True, clears previously stored observations
optimizer_args: args to be passed to Kernel.optimize_params()
'''
if clear_obs:
self.obs = None
if self.obs is not None:
self.obs = np.concatenate((self.obs, np.concatenate((x, y),
axis=1)))
else:
self.obs = np.concatenate((x, y), axis=1)
x = self.obs[:, 0]
x.shape = -1, 1
y = self.obs[:, 1]
y.shape = -1, 1
n_obs = x.shape[0]
if self.kernel_obj:
self.kernel_obj.optimize_params(x, y, **optimizer_args)
self.set_kernel_args(self.kernel_obj.params)
# create block matrix
K_X_X = kern.cov_mat(self.kernel, x, x)
K_X_Xt = kern.cov_mat(self.kernel, x, self.domain)
K_Xt_X = kern.cov_mat(self.kernel, self.domain, x)
K_Xt_Xt = kern.cov_mat(self.kernel, self.domain, self.domain)
# get means
shared_term = K_Xt_X.dot(LA.inv(K_X_X + self.noise**2 * np.eye(n_obs)))
self.μ = shared_term.dot(y) # see equation (4)
# get covariances
self.K = K_Xt_Xt - shared_term.dot(K_X_Xt) # see equation (3)
def plot(self, n_samples=0):
# get sigmas
sigmas = np.sqrt(np.diag(self.K))
sigmas.shape = -1, 1
# get confidence intervals
upper_ci = self.μ + 1.96 * sigmas
lower_ci = self.μ - 1.96 * sigmas
x = self.domain.flatten()
upper_ci = upper_ci.flatten()
lower_ci = lower_ci.flatten()
samples = self.sample(n_samples)
for sample in samples:
plt.plot(x, sample, alpha=.5)
plt.plot(x, self.μ, color='k', label='GP mean estimate')
plt.fill_between(x, lower_ci, upper_ci, alpha=.5, color='m')
if self.obs is not None:
plt.scatter(self.obs[:, 0],
self.obs[:, 1],
color='r',
marker='.',
linewidths=2,
s=100,
label='Observations')
plt.legend()
def plot_expected_improvement(self, objective=None):
# get sigmas
sigmas = np.sqrt(np.diag(self.K))
sigmas.shape = -1, 1
# get confidence intervals
upper_ci = self.μ + 1.96 * sigmas
lower_ci = self.μ - 1.96 * sigmas
x = self.domain.flatten()
upper_ci = upper_ci.flatten()
lower_ci = lower_ci.flatten()
# get expected improvement
ei = self.expected_improvement()
ei_max = ei.max()
ei_arg = np.argmax(ei)
# plotting
fig, (ax1, ax2) = plt.subplots(2, sharex=True)
# plot the GP
ax1.plot(x, self.μ, color='k', label='GP mean estimate')
ax1.fill_between(x, lower_ci, upper_ci, alpha=.5, color='m')
ax1.scatter(self.obs[:, 0],
self.obs[:, 1],
color='r',
marker='.',
linewidths=2,
s=100,
label='Observations')
if objective is not None:
if type(objective) == np.ndarray:
ax1.plot(self.domain,
objective,
linestyle='dashed',
linewidth=3,
c='g',
label='True objective')
else:
obj_x = np.linspace(np.min(self.domain),
np.max(self.domain),
100)
obj_y = objective(obj_x)
ax1.plot(obj_x,
obj_y,
linestyle='dashed',
linewidth=3,
c='y',
label='True objective')
ax1.set_title('GP')
ax1.legend(bbox_to_anchor=(1.1, 1.05))
# plot EI
ax2.plot(x, ei, linewidth=3)
ax2.vlines(x[ei_arg], 0, ei_max,
color='r', linestyles='dashed', label='max EI')
ax2.set_title('Expected improvement')
ax2.set_xlabel('$x$')
ax2.set_ylabel('$a(x)$')
ax2.legend()
def sample(self, n_samples):
# uses the cholesky decomp of the covariance matrix to draw samples
samples = np.zeros((n_samples, self.n))
try:
L = LA.cholesky(self.K + 1e-5 * np.eye(self.n))
except LA.LinAlgError:
# attempt rank 1 update if not positive definite
print('attempting rank 1 update')
e, v = LA.eig(self.K)
v1 = v[:, 0]
v1.shape = -1, 1
e1 = e[0]
print(f'negative eigenvalue: {e1:.4f}')
perturbed_K = self.K + v1.dot(v1.T).dot(np.spacing(e1) - e1)
L = LA.cholesky(perturbed_K)
for i in range(n_samples):
# draw samples
u = np.random.randn(self.n, 1)
z = L.dot(u)
z += self.μ
z = z.reshape(1, self.n)
samples[i] = z
return samples
def set_kernel_args(self, kernel_args):
self.kernel_args = kernel_args
if self.kernel_obj:
self.kernel_obj.set_params(**kernel_args)
self.kernel = self.kernel_obj.covariance
else:
self.kernel = partial(self.kernel, **kernel_args)
def x_next(self):
# get next point to sample
ei = self.expected_improvement()
return np.argmax(ei)
| chipfranzen/dillinger | dillinger/gaussian_process.py | Python | mit | 8,314 | [
"Gaussian"
] | c1168d4643434715f81a7380d41dbf9b4c070ca76c004711fc0b842eca8e0df9 |
#
# gPrime - A web-based genealogy program
#
# Copyright (C) 2008 Brian G. Matherly
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
#-------------------------------------------------------------------------
#
# Standard Python modules
#
#-------------------------------------------------------------------------
from ....const import LOCALE as glocale
_ = glocale.translation.gettext
#-------------------------------------------------------------------------
#
# Gprime modules
#
#-------------------------------------------------------------------------
from .._hasgallerybase import HasGalleryBase
#-------------------------------------------------------------------------
# "People with media object reference "
#-------------------------------------------------------------------------
class HavePhotos(HasGalleryBase):
"""Rule that checks for person who has media object reference"""
name = _('People with <count> media')
description = _("Matches people with a certain number of items in the gallery")
def __init__(self, arg, use_regex=False):
# Upgrade from pre 3.1 HasPhotos filter, use defaults that correspond
# Previous filter had 0 arguments
if len(arg) == 0:
HasGalleryBase.__init__(self, ["0", 'greater than'], use_regex)
else:
HasGalleryBase.__init__(self, arg, use_regex)
| sam-m888/gprime | gprime/filters/rules/person/_hasgallery.py | Python | gpl-2.0 | 2,032 | [
"Brian"
] | 0052ece7462d804aba7340f440ea2c901b7ffb81506950c0a230989d834796cf |
# -*- coding: utf-8 -*-
"""Release data for the IPython project."""
#-----------------------------------------------------------------------------
# Copyright (c) 2008, IPython Development Team.
# Copyright (c) 2001, Fernando Perez <fernando.perez@colorado.edu>
# Copyright (c) 2001, Janko Hauser <jhauser@zscout.de>
# Copyright (c) 2001, Nathaniel Gray <n8gray@caltech.edu>
#
# Distributed under the terms of the Modified BSD License.
#
# The full license is in the file COPYING.txt, distributed with this software.
#-----------------------------------------------------------------------------
# Name of the package for release purposes. This is the name which labels
# the tarballs and RPMs made by distutils, so it's best to lowercase it.
name = 'ipython'
# IPython version information. An empty _version_extra corresponds to a full
# release. 'dev' as a _version_extra string means this is a development
# version
_version_major = 1
_version_minor = 2
_version_patch = 0
# _version_extra = 'dev'
# _version_extra = 'rc1'
_version_extra = '' # Uncomment this for full releases
codename = 'An Afternoon Hack'
# Construct full version string from these.
_ver = [_version_major, _version_minor, _version_patch]
__version__ = '.'.join(map(str, _ver))
if _version_extra:
__version__ = __version__ + '-' + _version_extra
version = __version__ # backwards compatibility name
version_info = (_version_major, _version_minor, _version_patch, _version_extra)
# Change this when incrementing the kernel protocol version
kernel_protocol_version_info = (4, 0)
description = "IPython: Productive Interactive Computing"
long_description = \
"""
IPython provides a rich toolkit to help you make the most out of using Python
interactively. Its main components are:
* Powerful interactive Python shells (terminal- and Qt-based).
* A web-based interactive notebook environment with all shell features plus
support for embedded figures, animations and rich media.
* Support for interactive data visualization and use of GUI toolkits.
* Flexible, embeddable interpreters to load into your own projects.
* A high-performance library for high level and interactive parallel computing
that works in multicore systems, clusters, supercomputing and cloud scenarios.
The enhanced interactive Python shells have the following main features:
* Comprehensive object introspection.
* Input history, persistent across sessions.
* Caching of output results during a session with automatically generated
references.
* Extensible tab completion, with support by default for completion of python
variables and keywords, filenames and function keywords.
* Extensible system of 'magic' commands for controlling the environment and
performing many tasks related either to IPython or the operating system.
* A rich configuration system with easy switching between different setups
(simpler than changing $PYTHONSTARTUP environment variables every time).
* Session logging and reloading.
* Extensible syntax processing for special purpose situations.
* Access to the system shell with user-extensible alias system.
* Easily embeddable in other Python programs and GUIs.
* Integrated access to the pdb debugger and the Python profiler.
The parallel computing architecture has the following main features:
* Quickly parallelize Python code from an interactive Python/IPython session.
* A flexible and dynamic process model that be deployed on anything from
multicore workstations to supercomputers.
* An architecture that supports many different styles of parallelism, from
message passing to task farming.
* Both blocking and fully asynchronous interfaces.
* High level APIs that enable many things to be parallelized in a few lines
of code.
* Share live parallel jobs with other users securely.
* Dynamically load balanced task farming system.
* Robust error handling in parallel code.
The latest development version is always available from IPython's `GitHub
site <http://github.com/ipython>`_.
"""
license = 'BSD'
authors = {'Fernando' : ('Fernando Perez','fperez.net@gmail.com'),
'Janko' : ('Janko Hauser','jhauser@zscout.de'),
'Nathan' : ('Nathaniel Gray','n8gray@caltech.edu'),
'Ville' : ('Ville Vainio','vivainio@gmail.com'),
'Brian' : ('Brian E Granger', 'ellisonbg@gmail.com'),
'Min' : ('Min Ragan-Kelley', 'benjaminrk@gmail.com'),
'Thomas' : ('Thomas A. Kluyver', 'takowl@gmail.com'),
'Jorgen' : ('Jorgen Stenarson', 'jorgen.stenarson@bostream.nu'),
'Matthias' : ('Matthias Bussonnier', 'bussonniermatthias@gmail.com'),
}
author = 'The IPython Development Team'
author_email = 'ipython-dev@scipy.org'
url = 'http://ipython.org'
download_url = 'https://github.com/ipython/ipython/downloads'
platforms = ['Linux','Mac OSX','Windows XP/Vista/7/8']
keywords = ['Interactive','Interpreter','Shell','Parallel','Distributed',
'Web-based computing', 'Qt console', 'Embedding']
classifiers = [
'Intended Audience :: Developers',
'Intended Audience :: Science/Research',
'License :: OSI Approved :: BSD License',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.2',
'Programming Language :: Python :: 3.3',
'Topic :: System :: Distributed Computing',
'Topic :: System :: Shells'
]
| noslenfa/tdjangorest | uw/lib/python2.7/site-packages/IPython/core/release.py | Python | apache-2.0 | 5,583 | [
"Brian"
] | a936f43e6d95e4d8c312693a8e8b7ab64bbe87d60d3278b945ed7d8ef31beada |
# -*- Mode: Python; coding: utf-8 -*-
# vi:si:et:sw=4:sts=4:ts=4
##
## Copyright (C) 2013 Async Open Source <http://www.async.com.br>
## All rights reserved
##
## This program is free software; you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation; either version 2 of the License, or
## (at your option) any later version.
##
## This program is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with this program; if not, write to the Free Software
## Foundation, Inc., or visit: http://www.gnu.org/.
##
## Author(s): Stoq Team <stoq-devel@async.com.br>
#
"""Main gui definition for services application"""
import datetime
import urllib
import gtk
from kiwi.currency import currency
from kiwi.ui.gadgets import render_pixbuf
from kiwi.ui.objectlist import Column
import pango
from storm.expr import And, Or, Eq
from zope.interface import implementer
from stoqlib.api import api
from stoqlib.domain.workorder import (WorkOrder, WorkOrderCategory,
WorkOrderView)
from stoqlib.enums import SearchFilterPosition
from stoqlib.exceptions import InvalidStatus, NeedReason
from stoqlib.gui.dialogs.workordercategorydialog import WorkOrderCategoryDialog
from stoqlib.gui.editors.noteeditor import NoteEditor, Note
from stoqlib.gui.editors.workordereditor import (WorkOrderEditor,
WorkOrderPackageSendEditor)
from stoqlib.gui.interfaces import ISearchResultView
from stoqlib.gui.search.personsearch import ClientSearch
from stoqlib.gui.search.productsearch import ProductSearch
from stoqlib.gui.search.searchcolumns import IdentifierColumn, SearchColumn
from stoqlib.gui.search.searchfilters import ComboSearchFilter, DateSearchFilter
from stoqlib.gui.search.searchresultview import SearchResultListView
from stoqlib.gui.search.servicesearch import ServiceSearch
from stoqlib.gui.stockicons import STOQ_CLIENTS
from stoqlib.gui.utils.keybindings import get_accels
from stoqlib.gui.utils.printing import print_report
from stoqlib.gui.utils.workorderutils import get_workorder_state_icon
from stoqlib.gui.widgets.kanbanview import KanbanView, KanbanViewColumn
from stoqlib.gui.wizards.workorderpackagewizard import WorkOrderPackageReceiveWizard
from stoqlib.lib.environment import is_developer_mode
from stoqlib.lib.message import yesno, info
from stoqlib.lib.translation import stoqlib_gettext
from stoqlib.reporting.workorder import (WorkOrdersReport,
WorkOrderReceiptReport,
WorkOrderQuoteReport)
from stoq.gui.shell.shellapp import ShellApp
_ = stoqlib_gettext
@implementer(ISearchResultView)
class WorkOrderResultKanbanView(KanbanView):
def _change_status(self, work_order, new_status):
with api.new_store() as store:
if work_order.status == new_status:
return True
work_order = store.fetch(work_order)
try:
work_order.change_status(new_status)
except InvalidStatus as e:
info(str(e))
store.retval = False
except NeedReason as e:
info(str(e), _("Make the change on the order's menu so "
"you can specify a reason"))
store.retval = False
return store.retval
# ISearchResultView
def attach(self, search, columns):
self.connect('item-dragged', self._on__item_dragged)
statuses = list(WorkOrder.statuses.values())
statuses.remove(_(u'Cancelled'))
statuses.remove(_(u'Delivered'))
for status_name in statuses:
column = KanbanViewColumn(title=status_name)
self.add_column(column)
self.enable_editing()
def enable_lazy_search(self):
pass
def search_completed(self, results):
for work_order_view in results.order_by(WorkOrder.open_date):
work_order = work_order_view.work_order
status_name = WorkOrder.statuses.get(work_order.status)
# Skip cancel/delivered etc
if status_name is None:
continue
column = self.get_column_by_title(status_name)
if column is None:
continue
# FIXME: Figure out a better way of rendering
work_order_view.markup = '<b>%s - %s</b>\n%s\n%s' % (
work_order_view.sellable,
work_order_view.description,
unicode(api.escape(work_order_view.client_name)),
work_order_view.open_date.strftime('%x'))
column.append_item(work_order_view)
def get_settings(self):
return {}
def render_item(self, column, renderer, work_order_view):
renderer.props.margin_color = work_order_view.category_color
# Callbacks
def _on__item_dragged(self, kanban, column, work_order_view):
for status, status_name in WorkOrder.statuses.items():
if status_name == column.title:
new_status = status
break
else:
raise AssertionError
return self._change_status(work_order_view.work_order,
new_status)
class _FilterItem(object):
def __init__(self, name, value, color=None, obj_id=None):
self.name = name
self.value = value
self.color = color
self.id = obj_id or name
def __repr__(self):
return '<_FilterItem "%s">' % (self.name, )
class ServicesApp(ShellApp):
"""Services app"""
app_title = _(u'Services')
gladefile = 'services'
search_spec = WorkOrderView
search_label = _(u'matching:')
report_table = WorkOrdersReport
_status_query_mapper = {
'pending': Or(WorkOrder.status == WorkOrder.STATUS_OPENED,
WorkOrder.status == WorkOrder.STATUS_WORK_WAITING),
'in-progress': WorkOrder.status == WorkOrder.STATUS_WORK_IN_PROGRESS,
'finished': WorkOrder.status == WorkOrder.STATUS_WORK_FINISHED,
'delivered': WorkOrder.status == WorkOrder.STATUS_DELIVERED,
'cancelled': WorkOrder.status == WorkOrder.STATUS_CANCELLED,
'all-orders': None,
'not-delivered': And(WorkOrder.status != WorkOrder.STATUS_CANCELLED,
WorkOrder.status != WorkOrder.STATUS_DELIVERED),
}
_flags_query_mapper = {
'approved': And(WorkOrder.status != WorkOrder.STATUS_OPENED,
WorkOrder.status != WorkOrder.STATUS_CANCELLED),
'in-transport': Eq(WorkOrder.current_branch_id, None),
'rejected': Eq(WorkOrder.is_rejected, True),
}
#
# Application
#
def create_actions(self):
group = get_accels('app.services')
actions = [
# File
("OrderMenu", None, _(u"Order")),
("NewOrder", None, _(u"Work order..."),
group.get("new_order")),
("SendOrders", None, _(u"Send orders...")),
("ReceiveOrders", None, _(u"Receive orders...")),
# Search
("Products", None, _(u"Products..."),
group.get("search_products")),
("Services", None, _(u"Services..."),
group.get("search_services")),
("Categories", None, _(u"Categories..."),
group.get("search_categories")),
("Clients", STOQ_CLIENTS, _(u"Clients..."),
group.get("search_clients")),
# Order
("Edit", gtk.STOCK_EDIT, _(u"Edit..."),
group.get('order_edit'),
_(u"Edit the selected order")),
("Finish", gtk.STOCK_APPLY, _(u"Finish..."),
group.get('order_finish'),
_(u"Finish the selected order")),
("Cancel", gtk.STOCK_CANCEL, _(u"Cancel..."),
group.get('order_cancel'),
_(u"Cancel the selected order")),
("DeliverOrder", None, _(u"Deliver...")),
("Details", gtk.STOCK_INFO, _(u"Details..."),
group.get('order_details'),
_(u"Show details of the selected order")),
("PrintQuote", None, _(u"Print quote..."),
group.get('order_print_quote'),
_(u"Print a quote report of the selected order")),
("PrintReceipt", None, _(u"Print receipt..."),
group.get('order_print_receipt'),
_(u"Print a receipt of the selected order")),
("Approve", None, _(u"Approve...")),
("Pause", None, _(u"Pause the work...")),
("Work", None, _(u"Start the work...")),
("Reject", None, _(u"Reject order...")),
("UndoRejection", None, _(u"Undo order rejection...")),
("Reopen", None, _(u"Reopen order...")),
]
self.services_ui = self.add_ui_actions("", actions,
filename="services.xml")
radio_actions = [
('ViewKanban', '', _("View as Kanban"),
'', _("Show in Kanban mode")),
('ViewList', '', _("View as List"),
'', _("Show in list mode")),
]
self.add_ui_actions('', radio_actions, 'RadioActions',
'radio')
if is_developer_mode():
self.ViewList.props.active = True
else:
self.ViewList.props.visible = False
self.ViewKanban.props.visible = False
self.Edit.set_short_label(_(u"Edit"))
self.Finish.set_short_label(_(u"Finish"))
self.Edit.props.is_important = True
self.Finish.props.is_important = True
self.set_help_section(_(u"Services help"), 'app-services')
self.popup = self.uimanager.get_widget('/ServicesSelection')
def create_ui(self):
if api.sysparam.get_bool('SMART_LIST_LOADING'):
self.search.enable_lazy_search()
self.window.add_new_items([
self.NewOrder,
])
self.window.add_search_items([
self.Products,
self.Services,
self.Categories,
])
self.search.set_summary_label(
column='total',
label=('<b>%s</b>' %
api.escape(_('Total:'))),
format='<b>%s</b>',
parent=self.get_statusbar_message_area())
self.results.set_cell_data_func(self._on_results__cell_data_func)
def activate(self, refresh=True):
self.check_open_inventory()
self.window.NewToolItem.set_tooltip(
_(u"Create a new work order"))
self.window.SearchToolItem.set_tooltip(
_(u"Search for work order categories"))
if refresh:
self._update_view()
self.search.focus_search_entry()
def deactivate(self):
self.uimanager.remove_ui(self.services_ui)
def setup_focus(self):
self.refresh()
def new_activate(self):
self.new_order()
def search_activate(self):
self.run_dialog(ProductSearch, self.store,
hide_footer=True, hide_toolbar=True)
def search_completed(self, results, states):
if len(results):
return
base_msg = ''
url_msg = ''
state = states[1]
if state and state.value is None:
# Base search with no filters
base_msg = _(u"No work orders could be found.")
url = u"<a href='new_order'>%s</a>" % (
api.escape(_(u"create a new work order")), )
url_msg = _(u"Would you like to %s ?") % (url, )
else:
kind, value = state.value.value.split(':')
# Search filtering by status
if kind == 'status':
if value == 'pending':
base_msg = _(u"No pending work orders could be found.")
elif value == 'in-progress':
base_msg = _(u"No work orders in progress could be found.")
elif value == 'finished':
base_msg = _(u"No finished work orders could be found.")
elif value == 'delivered':
base_msg = _(u"No delivered or cancelled work "
u"orders could be found.")
# Search filtering by category
elif kind == 'category':
base_msg = _(u"No work orders in the category %s "
u"could be found.") % (
'<b>%s</b>' % (value, ), )
url = u"<a href='new_order?%s'>%s</a>" % (
urllib.quote(value.encode('utf-8')),
api.escape(_(u"create a new work order")), )
url_msg = _(u"Would you like to %s ?") % (url, )
if not base_msg:
return
msg = '\n\n'.join([base_msg, url_msg])
self.search.set_message(msg)
def create_filters(self):
self.set_text_field_columns(['sellable', 'description',
'client_name', 'identifier_str',
'sale_identifier_str'])
self.main_filter = ComboSearchFilter(_('Show'), [])
combo = self.main_filter.combo
combo.color_attribute = 'color'
combo.set_row_separator_func(self._on_main_filter__row_separator_func)
self.add_filter(self.main_filter, SearchFilterPosition.TOP,
callback=self._get_main_query)
self.create_branch_filter(column=[WorkOrder.branch_id,
WorkOrder.current_branch_id])
self._update_filters()
def get_columns(self):
return [
IdentifierColumn('identifier', title=_('WO #'), sorted=True),
IdentifierColumn('sale_identifier', title=_("Sale #"), visible=False),
SearchColumn('status_str', title=_(u'Status'),
search_attribute='status', data_type=str,
valid_values=self._get_status_values(), visible=False),
SearchColumn('category_name', title=_(u'Category'),
data_type=str, visible=False),
Column('equipment', title=_(u'Equipment (Description)'),
data_type=str, expand=True, pack_end=True),
Column('category_color', title=_(u'Equipment (Description)'),
column='equipment', data_type=gtk.gdk.Pixbuf,
format_func=render_pixbuf),
Column('flag_icon', title=_(u'Equipment (Description)'),
column='equipment', data_type=gtk.gdk.Pixbuf,
format_func=self._format_state_icon, format_func_data=True),
SearchColumn('client_name', title=_(u'Client'),
data_type=str),
SearchColumn('branch_name', title=_(u'Branch'),
data_type=str, visible=False),
SearchColumn('current_branch_name', title=_(u'Current branch'),
data_type=str, visible=False),
SearchColumn('execution_branch_name', title=_(u'Execution branch'),
data_type=str, visible=False),
SearchColumn('open_date', title=_(u'Open date'),
data_type=datetime.date),
SearchColumn('approve_date', title=_(u'Approval date'),
data_type=datetime.date, visible=False),
SearchColumn('estimated_start', title=_(u'Estimated start'),
data_type=datetime.date, visible=False),
SearchColumn('estimated_finish', title=_(u'Estimated finish'),
data_type=datetime.date, visible=False),
SearchColumn('finish_date', title=_(u'Finish date'),
data_type=datetime.date, visible=False),
SearchColumn('total', title=_(u'Total'),
data_type=currency),
]
def set_open_inventory(self):
# This needs to be implemented because we are calling check_open_inventory.
# We won't do anything here tough, WorkOrderEditor will, but we call
# check_open_inventory to display the open inventory bar and make
# it explicit for the user that there's an open inventory
pass
def search_for_date(self, date):
self.main_filter.combo.select(self._not_delivered_filter_item)
dfilter = DateSearchFilter(_("Estimated finish"))
dfilter.set_removable()
dfilter.select(data=DateSearchFilter.Type.USER_DAY)
self.add_filter(dfilter, columns=["estimated_finish"])
dfilter.start_date.set_date(date)
self.refresh()
#
# Private
#
def _format_state_icon(self, item, data):
# This happens with lazy object lists. Sometimes it calls this function
# without actually having the real object.
if not isinstance(item, WorkOrderView):
return
stock_id, tooltip = get_workorder_state_icon(item.work_order)
if stock_id is not None:
# We are using self.results because render_icon is a gtk.Widget's
# method. It has nothing to do with results tough.
return self.results.render_icon(stock_id, gtk.ICON_SIZE_MENU)
def _get_main_query(self, state):
item = state.value
kind, value = item.value.split(':')
if kind == 'category':
return WorkOrder.category_id == item.id
if kind == 'status':
return self._status_query_mapper[value]
if kind == 'flag':
return self._flags_query_mapper[value]
else:
raise AssertionError(kind, value)
def _get_status_values(self):
return ([(_('Any'), None)] +
[(v, k) for k, v in WorkOrder.statuses.items()])
def _update_view(self, select_item=None):
self.refresh()
if select_item is not None:
item = self.store.find(WorkOrderView, id=select_item.id).one()
self.select_result(item)
self._update_list_aware_view()
def _update_list_aware_view(self):
selection = self.search.get_selected_item()
has_selected = bool(selection)
wo = has_selected and selection.work_order
if wo and wo.sale is not None:
has_quote = wo.order_items.count() > 0
else:
has_quote = wo and bool(wo.defect_reported or wo.defect_detected)
self.set_sensitive([self.Edit], has_selected and wo.can_edit())
self.set_sensitive([self.Details], has_selected)
self.set_sensitive([self.Finish], has_selected and (wo.can_finish() or
wo.can_close()))
self.set_sensitive([self.Cancel], has_selected and wo.can_cancel())
self.set_sensitive([self.PrintReceipt], has_selected and wo.is_finished())
self.set_sensitive([self.PrintQuote], has_quote)
self.Finish.set_short_label(_(u"Finish"))
# If the selected work order is already finished, we change the finish
# button's label.
if has_selected and wo.status == WorkOrder.STATUS_WORK_FINISHED:
self.Finish.set_short_label(_(u"Deliver"))
for widget, value in [
(self.Approve, has_selected and wo.can_approve()),
(self.Reject, has_selected and wo.can_reject()),
(self.UndoRejection, has_selected and wo.can_undo_rejection()),
(self.Pause, has_selected and wo.can_pause()),
(self.Work, has_selected and wo.can_work()),
(self.Reopen, has_selected and wo.can_reopen()),
# DeliverOrder is grouped here since it's a special case
# Only finished orders without items and without sale can be
# delivered here, so avoid showing the option if it's not
#sensitive to avoid confusions
(self.DeliverOrder, (has_selected and wo.can_close() and
not wo.order_items.count() and not wo.sale))]:
self.set_sensitive([widget], value)
# Some of those options are mutually exclusive (except Approve,
# but it can only be called once) so avoid confusions and
# hide not available options
widget.set_visible(value)
def _update_filters(self):
self._not_delivered_filter_item = _FilterItem(_(u'Not delivered'),
'status:not-delivered')
options = [
self._not_delivered_filter_item,
_FilterItem(_(u'Pending'), 'status:pending'),
_FilterItem(_(u'In progress'), 'status:in-progress'),
_FilterItem(_(u'Finished'), 'status:finished'),
_FilterItem(_(u'Delivered'), 'status:delivered'),
_FilterItem(_(u'Cancelled'), 'status:cancelled'),
_FilterItem(_(u'All work orders'), 'status:all-orders'),
_FilterItem('sep', 'sep'),
_FilterItem(_(u'Approved'), 'flag:approved'),
_FilterItem(_(u'In transport'), 'flag:in-transport'),
_FilterItem(_(u'Rejected'), 'flag:rejected'),
]
categories = list(self.store.find(WorkOrderCategory))
if len(categories):
options.append(_FilterItem('sep', 'sep'))
for category in categories:
value = 'category:%s' % (category.name, )
options.append(_FilterItem(category.name, value,
color=category.color,
obj_id=category.id))
self.main_filter.update_values(
[(item.name, item) for item in options])
def new_order(self, category=None, available_categories=None):
with api.new_store() as store:
work_order = self.run_dialog(WorkOrderEditor, store,
category=store.fetch(category),
available_categories=available_categories)
if store.committed:
self._update_view(select_item=work_order)
# A category may have been created on the editor
self._update_filters()
def _edit_order(self, work_order=None):
if work_order is None:
work_order = self.search.get_selected_item().work_order
with api.new_store() as store:
self.run_dialog(WorkOrderEditor, store,
model=store.fetch(work_order))
if store.committed:
self._update_view()
# A category may have been created on the editor
self._update_filters()
def _finish_or_deliver_order(self):
work_order = self.search.get_selected_item().work_order
if work_order.status == WorkOrder.STATUS_WORK_FINISHED:
self._close_order()
else:
self._finish_order()
def _finish_order(self):
work_order = self.search.get_selected_item().work_order
if work_order.is_items_totally_reserved():
msg = _(u"This will finish the selected order, marking the "
u"work as done. Are you sure?")
else:
msg = _(u"Some items on this work order are not fully reserved. "
u"Do you still want to mark it as finished?")
if not yesno(msg, gtk.RESPONSE_NO,
_(u"Finish order"), _(u"Don't finish")):
return
with api.new_store() as store:
work_order = store.fetch(work_order)
work_order.finish()
self._update_view()
def _cancel_order(self):
msg_text = _(u"This will cancel the selected order. Any reserved items "
u"will return to stock. Are you sure?")
rv = self._run_notes_editor(msg_text=msg_text, mandatory=True)
if not rv:
return
selection = self.search.get_selected_item()
with api.new_store() as store:
work_order = store.fetch(selection.work_order)
work_order.cancel(reason=rv.notes)
self._update_view()
def _close_order(self):
if not yesno(_(u"This will mark the order as delivered. Are you "
"sure?"),
gtk.RESPONSE_NO, _(u"Mark as delivered"),
_(u"Don't mark")):
return
selection = self.search.get_selected_item()
with api.new_store() as store:
work_order = store.fetch(selection.work_order)
work_order.close()
self._update_view(select_item=selection)
def _approve_order(self):
if not yesno(_(u"This will inform the order that the client has "
u"approved the work. Are you sure?"),
gtk.RESPONSE_NO, _(u"Approve"), _(u"Don't approve")):
return
selection = self.search.get_selected_item()
with api.new_store() as store:
work_order = store.fetch(selection.work_order)
work_order.approve()
self._update_view(select_item=selection)
def _pause_order(self):
msg_text = _(u"This will inform the order that we are waiting. "
u"Are you sure?")
rv = self._run_notes_editor(msg_text=msg_text, mandatory=True)
if not rv:
return
selection = self.search.get_selected_item()
with api.new_store() as store:
work_order = store.fetch(selection.work_order)
work_order.pause(reason=rv.notes)
self._update_view(select_item=selection)
def _work(self):
selection = self.search.get_selected_item()
with api.new_store() as store:
work_order = store.fetch(selection.work_order)
work_order.work()
self._update_view(select_item=selection)
def _reject(self):
msg_text = _(u"This will reject the order. Are you sure?")
rv = self._run_notes_editor(msg_text=msg_text, mandatory=True)
if not rv:
return
selection = self.search.get_selected_item()
with api.new_store() as store:
work_order = store.fetch(selection.work_order)
work_order.reject(reason=rv.notes)
self._update_view(select_item=selection)
def _undo_rejection(self):
msg_text = _(u"This will undo the rejection of the order. "
u"Are you sure?")
rv = self._run_notes_editor(msg_text=msg_text, mandatory=False)
if not rv:
return
selection = self.search.get_selected_item()
with api.new_store() as store:
work_order = store.fetch(selection.work_order)
work_order.undo_rejection(reason=rv.notes)
self._update_view(select_item=selection)
def _reopen(self):
msg_text = _(u"This will reopen the order. Are you sure?")
rv = self._run_notes_editor(msg_text=msg_text, mandatory=True)
if not rv:
return
selection = self.search.get_selected_item()
with api.new_store() as store:
work_order = store.fetch(selection.work_order)
work_order.reopen(reason=rv.notes)
self._update_view(select_item=selection)
def _send_orders(self):
with api.new_store() as store:
self.run_dialog(WorkOrderPackageSendEditor, store)
if store.committed:
self._update_view()
def _receive_orders(self):
with api.new_store() as store:
self.run_dialog(WorkOrderPackageReceiveWizard, store)
if store.committed:
self._update_view()
def _run_order_details_dialog(self):
selection = self.search.get_selected_item()
with api.new_store() as store:
self.run_dialog(WorkOrderEditor, store,
model=store.fetch(selection.work_order),
visual_mode=True)
def _run_order_category_dialog(self):
with api.new_store() as store:
self.run_dialog(WorkOrderCategoryDialog, store)
self._update_view()
self._update_filters()
def _run_notes_editor(self, msg_text, mandatory):
return self.run_dialog(NoteEditor, self.store, model=Note(),
message_text=msg_text, label_text=_(u"Reason"),
mandatory=mandatory)
#
# Kiwi Callbacks
#
def _on_main_filter__row_separator_func(self, model, titer):
obj = model[titer][1]
if obj and obj.value == 'sep':
return True
return False
def _on_results__cell_data_func(self, column, renderer, wov, text):
if not isinstance(renderer, gtk.CellRendererText):
return text
work_order = wov.work_order
is_finished = work_order.status == WorkOrder.STATUS_WORK_FINISHED
is_delivered = work_order.status in [WorkOrder.STATUS_CANCELLED,
WorkOrder.STATUS_DELIVERED]
is_late = work_order.is_late()
for prop, is_set, value in [
('strikethrough', is_delivered, True),
('style', is_finished, pango.STYLE_ITALIC),
('weight', is_late, pango.WEIGHT_BOLD)]:
renderer.set_property(prop + '-set', is_set)
if is_set:
renderer.set_property(prop, value)
return text
def on_search__result_item_popup_menu(self, search, item, event):
self.popup.popup(None, None, None, event.button, event.time)
def on_search__result_item_activated(self, search, item):
if self.Edit.get_sensitive():
self._edit_order()
elif self.Details.get_sensitive():
self._run_order_details_dialog()
else:
assert False
def on_search__result_selection_changed(self, search):
self._update_list_aware_view()
def on_results__activate_link(self, results, uri):
if not uri.startswith('new_order'):
return
if '?' in uri:
category_name = unicode(urllib.unquote(uri.split('?', 1)[1]))
category = self.store.find(WorkOrderCategory,
name=category_name).one()
else:
category = None
self.new_order(category=category)
def on_NewOrder__activate(self, action):
self.new_order()
def on_SendOrders__activate(self, action):
self._send_orders()
def on_ReceiveOrders__activate(self, action):
self._receive_orders()
def on_Edit__activate(self, action):
self._edit_order()
def on_Finish__activate(self, action):
self._finish_or_deliver_order()
def on_Cancel__activate(self, action):
self._cancel_order()
def on_Details__activate(self, action):
self._run_order_details_dialog()
def on_Approve__activate(self, action):
self._approve_order()
def on_Pause__activate(self, action):
self._pause_order()
def on_Work__activate(self, action):
self._work()
def on_Reject__activate(self, action):
self._reject()
def on_UndoRejection__activate(self, action):
self._undo_rejection()
def on_Reopen__activate(self, action):
self._reopen()
def on_DeliverOrder__activate(self, action):
self._close_order()
def on_PrintQuote__activate(self, action):
workorderview = self.search.get_selected_item()
print_report(WorkOrderQuoteReport, workorderview.work_order)
def on_PrintReceipt__activate(self, action):
workorderview = self.search.get_selected_item()
print_report(WorkOrderReceiptReport, workorderview.work_order)
def on_Products__activate(self, action):
self.run_dialog(ProductSearch, self.store,
hide_footer=True, hide_toolbar=True)
def on_Services__activate(self, action):
self.run_dialog(ServiceSearch, self.store)
def on_Categories__activate(self, action):
self._run_order_category_dialog()
def on_Clients__activate(self, button):
self.run_dialog(ClientSearch, self.store, hide_footer=True)
def on_ViewList__toggled(self, action):
if not action.get_active():
return
self.search.set_result_view(SearchResultListView, refresh=True)
self._update_list_aware_view()
def on_ViewKanban__toggled(self, action):
if not action.get_active():
return
self.search.set_result_view(WorkOrderResultKanbanView, refresh=True)
self._update_list_aware_view()
| andrebellafronte/stoq | stoq/gui/services.py | Python | gpl-2.0 | 32,977 | [
"VisIt"
] | 5906046d7df0c403d1bffd0547cdad287cd5c5644d59e85f62270c0ef41f7979 |
"""Contains the logic for handling read model invocation and read creation"""
import time
from multiprocessing import Process, Queue
import pysam
import numpy as np
import mitty.lib.vcfio as vio
from mitty.lib.sanitizeseq import sanitize
import mitty.simulation.rpc as rpc
from mitty.simulation.sequencing.writefastq import writer
import logging
logger = logging.getLogger(__name__)
SEED_MAX = (1 << 32) - 1 # Used for seeding rng
__process_stop_code__ = 'SETECASTRONOMY'
DNA_complement = str.maketrans('ATCGN', 'TAGCN')
# Will hold the mem-shared read only data
vcf_df = None
# The sequence of steps is to
# 1. Generate read templates based on BED file -> save as global
# 2. Start up a bunch of workers and pass regions to them
# 3. Each worker creates the nodelist for the region and uses the relavant templates to create reads
# 4. Write out the reads as they are generated
#
# This code generates perfect reads. The reads can be piped (Tee-d) to an algorithm that implements
# corruption
# The following functions save data to global (Read only) variables so that we can use them with
# multi-processing
#TODO: Figure out behavior for SE model
#TODO: Add to readme the note that a single ended model will still produce two files, r2 will be empty
def process_multi_threaded(fasta_fname, vcf_fname, sample_name, bed_fname,
read_module, model, coverage,
fastq1_fname, sidecar_fname, fastq2_fname,
truncate_to=None,
unpair=False,
threads=2, seed=7):
"""
:param fasta_fname:
:param vcf_fname:
:param sample_name:
:param bed_fname:
:param read_module:
:param model:
:param coverage:
:param fastq1_fname:
:param sidecar_fname:
:param fastq2_fname:
:param truncate_to: If set, shorten reads to this length
:param unpair: If True, for models that produce paired-end reads, produce single end, instead
:param threads:
:param seed:
:return:
"""
if truncate_to is not None:
model['mean_rlen'] = min(truncate_to, model['mean_rlen'])
logger.debug('Truncating mean read length to: {}bp'.format(model['mean_rlen']))
if unpair:
logger.debug('Un-pairing reads')
model['unpaired'] = True
assert fastq2_fname is None, 'For unpaired reads, no FASTQ2 should be supplied'
read_model = read_module.read_model_params(model, coverage)
global vcf_df
vcf_df = vio.load_variant_file(vcf_fname, sample_name, bed_fname)
in_queue = Queue()
out_queue = Queue(10000) # This is the key to preventing workers from dying
logger.debug('Starting {} workers'.format(threads))
workers = []
for worker_id in range(threads):
p = Process(target=read_generating_worker,
args=(worker_id, fasta_fname, sample_name, read_module, read_model, in_queue, out_queue))
p.start()
workers.append(p)
logger.debug('Starting writer process')
wr = Process(target=writer, args=(fastq1_fname, sidecar_fname, fastq2_fname, out_queue))
wr.start()
logger.debug('Loading up the work queue')
for wd in get_data_for_workers(read_model, vcf_df, seed):
in_queue.put(wd)
logger.debug('Stopping workers')
for _ in workers:
in_queue.put(__process_stop_code__)
for w in workers:
w.join()
logger.debug('All workers are done')
logger.debug('Stopping writer')
out_queue.put(__process_stop_code__)
wr.join()
def get_data_for_workers(model, vcf, seed):
"""Given a vcf structure return an iterator that keeps returning us a region and copy to generate
reads from until the desired coverage has been attained.
:param model: Must contain a 'passes' field that determines how many times a region is passed to it
:param vcf: ploidy aware variant structure as returned by vcfio. We only use the region and ploidy information
to create and return a generator for regions. We generate as many regions as needed to achieve the
given coverage, taking ploidy of the region into account
:param seed: This is used to seed an RNG that generates rng seeds passed to all the workers
:return: a generator that returns worker data as a dict
{
'region_idx': r_idx, # Index into VCF structure
'region_cpy': cpy, # which copy of the region to use
'rng_seed': s # seed for the RNGs in the worker
}
access the variants as vcf_df[r_idx]['v'][cpy]
"""
seed_rng = np.random.RandomState(seed)
shuffle_seed = seed_rng.randint(SEED_MAX)
region_list = [
{'region_idx': idx, 'region_cpy': cpy, 'rng_seed': seed_rng.randint(SEED_MAX)}
for idx, v in enumerate(vcf)
for cpy in range(len(v['v']))
for _ in range(model['passes'])
]
logger.debug('{} passes will be made'.format(len(region_list)))
np.random.RandomState(shuffle_seed).shuffle(region_list)
for region in region_list:
yield region
# def read_generating_worker(worker_id, fasta_fname, sample_name, read_module, read_model, in_queue, out_queue):
# for ps, wd in enumerate(iter(in_queue.get, __process_stop_code__)):
# out_queue.put([str(ps), str(wd)])
def read_generating_worker(worker_id, fasta_fname, sample_name, read_module, read_model, in_queue, out_queue):
"""This worker will be given a fasta_fname, and region information. It is to generate the node_list,
the read locations and then, finally, the reads themselves. The reads - in FASTQ format - are returned
to the parent thread for writing.
:param worker_id: Just a serial that helps us number reads uniquely
:param fasta_fname:
:param sample_name: (This is just passed to the read qname)
:param model:
:param region_idx:
:param in_queue: will be sending work information as (region_idx, cpy)
:param out_queue: We'll be sending strings representing each template in FASTQ format
:return:
"""
fasta = pysam.FastaFile(fasta_fname)
total_cnt, t00 = 0, time.time()
for ps, wd in enumerate(iter(in_queue.get, __process_stop_code__)):
r_idx, cpy, rng_seed = wd['region_idx'], wd['region_cpy'], wd['rng_seed']
region = vcf_df[r_idx]['region']
ref_seq = sanitize(fasta.fetch(reference=region[0], start=region[1], end=region[2]))
# The structure needed to generate read sequences, pos and CIGAR strings
# + 1 because BED is 0-indexed and our convention is 1-indexed as is what is displayed in genome browsers
node_list = rpc.create_node_list(ref_seq, ref_start_pos=region[1] + 1, vl=vcf_df[r_idx]['v'][cpy])
p_min, p_max = node_list[0].ps, node_list[-1].ps + node_list[-1].oplen # We never end with a deletion
r_info_l = read_module.generate_reads(read_model, p_min, p_max, rng_seed)
qname_serial_stub = '{}:{}:{}'.format(sample_name, worker_id, ps)
t0 = time.time()
this_cnt = 0
for template in zip(
*[zip(*([r_info[k] for k in ['file_order', 'strand', 'pos', 'len']] +
rpc.get_begin_end_nodes(r_info['pos'], r_info['len'], node_list))) for r_info in r_info_l]):
reads = [None] * len(template)
for fo, s, p, l, ns, ne in template:
pos, cigar, v_list, seq = rpc.generate_read(p, l, ns, ne, node_list)
if seq.count('N') > 2: break
# This break combined with the else clause skips those read pairs where
# at least one read has too many 'N's
if s == 1:
seq = seq.translate(DNA_complement)[::-1]
reads[fo] = (s, pos, cigar, v_list, '', seq, 'I' * len(seq))
else:
this_cnt += 1
# (
# None, - We want the writer to put a unique stamp on each template
# sample_name,
# chrom,
# copy,
# (
# (strand, pos, cigar, (v1,v2,...), MD, seq, qual)
# ... [repeated as for as many reads in this template]
# )
# )
out_queue.put((None, sample_name, region[0], cpy, reads))
t1 = time.time()
logger.debug('Worker {} ({}): {} templates in {:0.2f}s ({:0.2f} t/s)'.format(worker_id, region, this_cnt, t1 - t0, this_cnt/(t1 - t0)))
total_cnt += this_cnt
t11 = time.time()
logger.debug('Worker {} finished: {} templates in {:0.2f}s ({:0.2f} t/s)'.format(
worker_id, total_cnt, t11 - t00, total_cnt / (t11 - t00)))
def validate_templates_from_read_model(tplt):
"""A series of tests to make sure that the returned template locations are in a format suitable for our use
:param tplt:
:return:
"""
if not isinstance(tplt, list):
raise RuntimeError('Read model should return a list')
if not isinstance(tplt[0], dict):
raise RuntimeError('Read model should return a list of dicts')
for k in ['reads', 'region']:
if k not in tplt[0]:
raise RuntimeError('Read model dict should contain {}'.format(k))
if not isinstance(tplt[0]['reads'], np.recarray):
raise RuntimeError('Reads should be in the form of a numpy recarray') | sbg/Mitty | mitty/simulation/readgenerate.py | Python | apache-2.0 | 8,916 | [
"pysam"
] | f77300c547b144d72c1471c4ad0ba5d2db53d0786526ac47d063fd188d3d66cc |
# Authors: Matti Hämäläinen <msh@nmr.mgh.harvard.edu>
# Alexandre Gramfort <alexandre.gramfort@inria.fr>
# Eric Larson <larson.eric.d@gmail.com>
# Lorenzo De Santis <lorenzo.de-santis@u-psud.fr>
#
# License: BSD (3-clause)
# The computations in this code were primarily derived from Matti Hämäläinen's
# C code.
from functools import partial
import glob
import os
import os.path as op
import shutil
from copy import deepcopy
import numpy as np
from scipy import linalg
from .io.constants import FIFF, FWD
from .io._digitization import _dig_kind_dict, _dig_kind_rev, _dig_kind_ints
from .io.write import (start_file, start_block, write_float, write_int,
write_float_matrix, write_int_matrix, end_block,
end_file)
from .io.tag import find_tag
from .io.tree import dir_tree_find
from .io.open import fiff_open
from .surface import (read_surface, write_surface, complete_surface_info,
_compute_nearest, _get_ico_surface, read_tri,
_fast_cross_nd_sum, _get_solids)
from .transforms import _ensure_trans, apply_trans, Transform
from .utils import (verbose, logger, run_subprocess, get_subjects_dir, warn,
_pl, _validate_type, _TempDir, _check_freesurfer_home,
_check_fname, has_nibabel)
from .fixes import einsum
# ############################################################################
# Compute BEM solution
# The following approach is based on:
#
# de Munck JC: "A linear discretization of the volume conductor boundary
# integral equation using analytically integrated elements",
# IEEE Trans Biomed Eng. 1992 39(9) : 986 - 990
#
class ConductorModel(dict):
"""BEM or sphere model."""
def __repr__(self): # noqa: D105
if self['is_sphere']:
center = ', '.join('%0.1f' % (x * 1000.) for x in self['r0'])
rad = self.radius
if rad is None: # no radius / MEG only
extra = 'Sphere (no layers): r0=[%s] mm' % center
else:
extra = ('Sphere (%s layer%s): r0=[%s] R=%1.f mm'
% (len(self['layers']) - 1, _pl(self['layers']),
center, rad * 1000.))
else:
extra = ('BEM (%s layer%s)' % (len(self['surfs']),
_pl(self['surfs'])))
return '<ConductorModel | %s>' % extra
def copy(self):
"""Return copy of ConductorModel instance."""
return deepcopy(self)
@property
def radius(self):
"""Sphere radius if an EEG sphere model."""
if not self['is_sphere']:
raise RuntimeError('radius undefined for BEM')
return None if len(self['layers']) == 0 else self['layers'][-1]['rad']
def _calc_beta(rk, rk_norm, rk1, rk1_norm):
"""Compute coefficients for calculating the magic vector omega."""
rkk1 = rk1[0] - rk[0]
size = np.linalg.norm(rkk1)
rkk1 /= size
num = rk_norm + np.dot(rk, rkk1)
den = rk1_norm + np.dot(rk1, rkk1)
res = np.log(num / den) / size
return res
def _lin_pot_coeff(fros, tri_rr, tri_nn, tri_area):
"""Compute the linear potential matrix element computations."""
omega = np.zeros((len(fros), 3))
# we replicate a little bit of the _get_solids code here for speed
# (we need some of the intermediate values later)
v1 = tri_rr[np.newaxis, 0, :] - fros
v2 = tri_rr[np.newaxis, 1, :] - fros
v3 = tri_rr[np.newaxis, 2, :] - fros
triples = _fast_cross_nd_sum(v1, v2, v3)
l1 = np.linalg.norm(v1, axis=1)
l2 = np.linalg.norm(v2, axis=1)
l3 = np.linalg.norm(v3, axis=1)
ss = l1 * l2 * l3
ss += einsum('ij,ij,i->i', v1, v2, l3)
ss += einsum('ij,ij,i->i', v1, v3, l2)
ss += einsum('ij,ij,i->i', v2, v3, l1)
solids = np.arctan2(triples, ss)
# We *could* subselect the good points from v1, v2, v3, triples, solids,
# l1, l2, and l3, but there are *very* few bad points. So instead we do
# some unnecessary calculations, and then omit them from the final
# solution. These three lines ensure we don't get invalid values in
# _calc_beta.
bad_mask = np.abs(solids) < np.pi / 1e6
l1[bad_mask] = 1.
l2[bad_mask] = 1.
l3[bad_mask] = 1.
# Calculate the magic vector vec_omega
beta = [_calc_beta(v1, l1, v2, l2)[:, np.newaxis],
_calc_beta(v2, l2, v3, l3)[:, np.newaxis],
_calc_beta(v3, l3, v1, l1)[:, np.newaxis]]
vec_omega = (beta[2] - beta[0]) * v1
vec_omega += (beta[0] - beta[1]) * v2
vec_omega += (beta[1] - beta[2]) * v3
area2 = 2.0 * tri_area
n2 = 1.0 / (area2 * area2)
# leave omega = 0 otherwise
# Put it all together...
yys = [v1, v2, v3]
idx = [0, 1, 2, 0, 2]
for k in range(3):
diff = yys[idx[k - 1]] - yys[idx[k + 1]]
zdots = _fast_cross_nd_sum(yys[idx[k + 1]], yys[idx[k - 1]], tri_nn)
omega[:, k] = -n2 * (area2 * zdots * 2. * solids -
triples * (diff * vec_omega).sum(axis=-1))
# omit the bad points from the solution
omega[bad_mask] = 0.
return omega
def _correct_auto_elements(surf, mat):
"""Improve auto-element approximation."""
pi2 = 2.0 * np.pi
tris_flat = surf['tris'].ravel()
misses = pi2 - mat.sum(axis=1)
for j, miss in enumerate(misses):
# How much is missing?
n_memb = len(surf['neighbor_tri'][j])
assert n_memb > 0 # should be guaranteed by our surface checks
# The node itself receives one half
mat[j, j] = miss / 2.0
# The rest is divided evenly among the member nodes...
miss /= (4.0 * n_memb)
members = np.where(j == tris_flat)[0]
mods = members % 3
offsets = np.array([[1, 2], [-1, 1], [-1, -2]])
tri_1 = members + offsets[mods, 0]
tri_2 = members + offsets[mods, 1]
for t1, t2 in zip(tri_1, tri_2):
mat[j, tris_flat[t1]] += miss
mat[j, tris_flat[t2]] += miss
return
def _fwd_bem_lin_pot_coeff(surfs):
"""Calculate the coefficients for linear collocation approach."""
# taken from fwd_bem_linear_collocation.c
nps = [surf['np'] for surf in surfs]
np_tot = sum(nps)
coeff = np.zeros((np_tot, np_tot))
offsets = np.cumsum(np.concatenate(([0], nps)))
for si_1, surf1 in enumerate(surfs):
rr_ord = np.arange(nps[si_1])
for si_2, surf2 in enumerate(surfs):
logger.info(" %s (%d) -> %s (%d) ..." %
(_surf_name[surf1['id']], nps[si_1],
_surf_name[surf2['id']], nps[si_2]))
tri_rr = surf2['rr'][surf2['tris']]
tri_nn = surf2['tri_nn']
tri_area = surf2['tri_area']
submat = coeff[offsets[si_1]:offsets[si_1 + 1],
offsets[si_2]:offsets[si_2 + 1]] # view
for k in range(surf2['ntri']):
tri = surf2['tris'][k]
if si_1 == si_2:
skip_idx = ((rr_ord == tri[0]) |
(rr_ord == tri[1]) |
(rr_ord == tri[2]))
else:
skip_idx = list()
# No contribution from a triangle that
# this vertex belongs to
# if sidx1 == sidx2 and (tri == j).any():
# continue
# Otherwise do the hard job
coeffs = _lin_pot_coeff(surf1['rr'], tri_rr[k], tri_nn[k],
tri_area[k])
coeffs[skip_idx] = 0.
submat[:, tri] -= coeffs
if si_1 == si_2:
_correct_auto_elements(surf1, submat)
return coeff
def _fwd_bem_multi_solution(solids, gamma, nps):
"""Do multi surface solution.
* Invert I - solids/(2*M_PI)
* Take deflation into account
* The matrix is destroyed after inversion
* This is the general multilayer case
"""
pi2 = 1.0 / (2 * np.pi)
n_tot = np.sum(nps)
assert solids.shape == (n_tot, n_tot)
nsurf = len(nps)
defl = 1.0 / n_tot
# Modify the matrix
offsets = np.cumsum(np.concatenate(([0], nps)))
for si_1 in range(nsurf):
for si_2 in range(nsurf):
mult = pi2 if gamma is None else pi2 * gamma[si_1, si_2]
slice_j = slice(offsets[si_1], offsets[si_1 + 1])
slice_k = slice(offsets[si_2], offsets[si_2 + 1])
solids[slice_j, slice_k] = defl - solids[slice_j, slice_k] * mult
solids += np.eye(n_tot)
return linalg.inv(solids, overwrite_a=True)
def _fwd_bem_homog_solution(solids, nps):
"""Make a homogeneous solution."""
return _fwd_bem_multi_solution(solids, None, nps)
def _fwd_bem_ip_modify_solution(solution, ip_solution, ip_mult, n_tri):
"""Modify the solution according to the IP approach."""
n_last = n_tri[-1]
mult = (1.0 + ip_mult) / ip_mult
logger.info(' Combining...')
offsets = np.cumsum(np.concatenate(([0], n_tri)))
for si in range(len(n_tri)):
# Pick the correct submatrix (right column) and multiply
sub = solution[offsets[si]:offsets[si + 1], np.sum(n_tri[:-1]):]
# Multiply
sub -= 2 * np.dot(sub, ip_solution)
# The lower right corner is a special case
sub[-n_last:, -n_last:] += mult * ip_solution
# Final scaling
logger.info(' Scaling...')
solution *= ip_mult
return
def _check_complete_surface(surf, copy=False, incomplete='raise', extra=''):
surf = complete_surface_info(surf, copy=copy, verbose=False)
fewer = np.where([len(t) < 3 for t in surf['neighbor_tri']])[0]
if len(fewer) > 0:
msg = ('Surface {} has topological defects: {:.0f} / {:.0f} vertices '
'have fewer than three neighboring triangles [{}]{}'
.format(_surf_name[surf['id']], len(fewer), surf['ntri'],
', '.join(str(f) for f in fewer), extra))
if incomplete == 'raise':
raise RuntimeError(msg)
else:
warn(msg)
return surf
def _fwd_bem_linear_collocation_solution(m):
"""Compute the linear collocation potential solution."""
# first, add surface geometries
for surf in m['surfs']:
_check_complete_surface(surf)
logger.info('Computing the linear collocation solution...')
logger.info(' Matrix coefficients...')
coeff = _fwd_bem_lin_pot_coeff(m['surfs'])
m['nsol'] = len(coeff)
logger.info(" Inverting the coefficient matrix...")
nps = [surf['np'] for surf in m['surfs']]
m['solution'] = _fwd_bem_multi_solution(coeff, m['gamma'], nps)
if len(m['surfs']) == 3:
ip_mult = m['sigma'][1] / m['sigma'][2]
if ip_mult <= FWD.BEM_IP_APPROACH_LIMIT:
logger.info('IP approach required...')
logger.info(' Matrix coefficients (homog)...')
coeff = _fwd_bem_lin_pot_coeff([m['surfs'][-1]])
logger.info(' Inverting the coefficient matrix (homog)...')
ip_solution = _fwd_bem_homog_solution(coeff,
[m['surfs'][-1]['np']])
logger.info(' Modify the original solution to incorporate '
'IP approach...')
_fwd_bem_ip_modify_solution(m['solution'], ip_solution, ip_mult,
nps)
m['bem_method'] = FWD.BEM_LINEAR_COLL
logger.info("Solution ready.")
@verbose
def make_bem_solution(surfs, verbose=None):
"""Create a BEM solution using the linear collocation approach.
Parameters
----------
surfs : list of dict
The BEM surfaces to use (from :func:`mne.make_bem_model`).
%(verbose)s
Returns
-------
bem : instance of ConductorModel
The BEM solution.
See Also
--------
make_bem_model
read_bem_surfaces
write_bem_surfaces
read_bem_solution
write_bem_solution
Notes
-----
.. versionadded:: 0.10.0
"""
logger.info('Approximation method : Linear collocation\n')
if isinstance(surfs, str):
# Load the surfaces
logger.info('Loading surfaces...')
surfs = read_bem_surfaces(surfs)
bem = ConductorModel(is_sphere=False, surfs=surfs)
_add_gamma_multipliers(bem)
if len(bem['surfs']) == 3:
logger.info('Three-layer model surfaces loaded.')
elif len(bem['surfs']) == 1:
logger.info('Homogeneous model surface loaded.')
else:
raise RuntimeError('Only 1- or 3-layer BEM computations supported')
_check_bem_size(bem['surfs'])
_fwd_bem_linear_collocation_solution(bem)
logger.info('BEM geometry computations complete.')
return bem
# ############################################################################
# Make BEM model
def _ico_downsample(surf, dest_grade):
"""Downsample the surface if isomorphic to a subdivided icosahedron."""
n_tri = len(surf['tris'])
bad_msg = ("Cannot decimate to requested ico grade %d. The provided "
"BEM surface has %d triangles, which cannot be isomorphic with "
"a subdivided icosahedron. Consider manually decimating the "
"surface to a suitable density and then use ico=None in "
"make_bem_model." % (dest_grade, n_tri))
if n_tri % 20 != 0:
raise RuntimeError(bad_msg)
n_tri = n_tri // 20
found = int(round(np.log(n_tri) / np.log(4)))
if n_tri != 4 ** found:
raise RuntimeError(bad_msg)
del n_tri
if dest_grade > found:
raise RuntimeError('For this surface, decimation grade should be %d '
'or less, not %s.' % (found, dest_grade))
source = _get_ico_surface(found)
dest = _get_ico_surface(dest_grade, patch_stats=True)
del dest['tri_cent']
del dest['tri_nn']
del dest['neighbor_tri']
del dest['tri_area']
if not np.array_equal(source['tris'], surf['tris']):
raise RuntimeError('The source surface has a matching number of '
'triangles but ordering is wrong')
logger.info('Going from %dth to %dth subdivision of an icosahedron '
'(n_tri: %d -> %d)' % (found, dest_grade, len(surf['tris']),
len(dest['tris'])))
# Find the mapping
dest['rr'] = surf['rr'][_get_ico_map(source, dest)]
return dest
def _get_ico_map(fro, to):
"""Get a mapping between ico surfaces."""
nearest, dists = _compute_nearest(fro['rr'], to['rr'], return_dists=True)
n_bads = (dists > 5e-3).sum()
if n_bads > 0:
raise RuntimeError('No matching vertex for %d destination vertices'
% (n_bads))
return nearest
def _order_surfaces(surfs):
"""Reorder the surfaces."""
if len(surfs) != 3:
return surfs
# we have three surfaces
surf_order = [FIFF.FIFFV_BEM_SURF_ID_HEAD,
FIFF.FIFFV_BEM_SURF_ID_SKULL,
FIFF.FIFFV_BEM_SURF_ID_BRAIN]
ids = np.array([surf['id'] for surf in surfs])
if set(ids) != set(surf_order):
raise RuntimeError('bad surface ids: %s' % ids)
order = [np.where(ids == id_)[0][0] for id_ in surf_order]
surfs = [surfs[idx] for idx in order]
return surfs
def _assert_complete_surface(surf, incomplete='raise'):
"""Check the sum of solid angles as seen from inside."""
# from surface_checks.c
# Center of mass....
cm = surf['rr'].mean(axis=0)
logger.info('%s CM is %6.2f %6.2f %6.2f mm' %
(_surf_name[surf['id']],
1000 * cm[0], 1000 * cm[1], 1000 * cm[2]))
tot_angle = _get_solids(surf['rr'][surf['tris']], cm[np.newaxis, :])[0]
prop = tot_angle / (2 * np.pi)
if np.abs(prop - 1.0) > 1e-5:
msg = ('Surface %s is not complete (sum of solid angles '
'yielded %g, should be 1.)'
% (_surf_name[surf['id']], prop))
if incomplete == 'raise':
raise RuntimeError(msg)
else:
warn(msg)
_surf_name = {
FIFF.FIFFV_BEM_SURF_ID_HEAD: 'outer skin ',
FIFF.FIFFV_BEM_SURF_ID_SKULL: 'outer skull',
FIFF.FIFFV_BEM_SURF_ID_BRAIN: 'inner skull',
FIFF.FIFFV_BEM_SURF_ID_UNKNOWN: 'unknown ',
}
def _assert_inside(fro, to):
"""Check one set of points is inside a surface."""
# this is "is_inside" in surface_checks.c
tot_angle = _get_solids(to['rr'][to['tris']], fro['rr'])
if (np.abs(tot_angle / (2 * np.pi) - 1.0) > 1e-5).any():
raise RuntimeError('Surface %s is not completely inside surface %s'
% (_surf_name[fro['id']], _surf_name[to['id']]))
def _check_surfaces(surfs, incomplete='raise'):
"""Check that the surfaces are complete and non-intersecting."""
for surf in surfs:
_assert_complete_surface(surf, incomplete=incomplete)
# Then check the topology
for surf_1, surf_2 in zip(surfs[:-1], surfs[1:]):
logger.info('Checking that %s surface is inside %s surface...' %
(_surf_name[surf_2['id']], _surf_name[surf_1['id']]))
_assert_inside(surf_2, surf_1)
def _check_surface_size(surf):
"""Check that the coordinate limits are reasonable."""
sizes = surf['rr'].max(axis=0) - surf['rr'].min(axis=0)
if (sizes < 0.05).any():
raise RuntimeError('Dimensions of the surface %s seem too small '
'(%9.5f mm). Maybe the the unit of measure is '
'meters instead of mm' %
(_surf_name[surf['id']], 1000 * sizes.min()))
def _check_thicknesses(surfs):
"""Compute how close we are."""
for surf_1, surf_2 in zip(surfs[:-1], surfs[1:]):
min_dist = _compute_nearest(surf_1['rr'], surf_2['rr'],
return_dists=True)[1]
min_dist = min_dist.min()
logger.info('Checking distance between %s and %s surfaces...' %
(_surf_name[surf_1['id']], _surf_name[surf_2['id']]))
logger.info('Minimum distance between the %s and %s surfaces is '
'approximately %6.1f mm' %
(_surf_name[surf_1['id']], _surf_name[surf_2['id']],
1000 * min_dist))
def _surfaces_to_bem(surfs, ids, sigmas, ico=None, rescale=True,
incomplete='raise', extra=''):
"""Convert surfaces to a BEM."""
# equivalent of mne_surf2bem
# surfs can be strings (filenames) or surface dicts
if len(surfs) not in (1, 3) or not (len(surfs) == len(ids) ==
len(sigmas)):
raise ValueError('surfs, ids, and sigmas must all have the same '
'number of elements (1 or 3)')
for si, surf in enumerate(surfs):
if isinstance(surf, str):
surfs[si] = read_surface(surf, return_dict=True)[-1]
# Downsampling if the surface is isomorphic with a subdivided icosahedron
if ico is not None:
for si, surf in enumerate(surfs):
surfs[si] = _ico_downsample(surf, ico)
for surf, id_ in zip(surfs, ids):
# Do topology checks (but don't save data) to fail early
surf['id'] = id_
_check_complete_surface(surf, copy=True, incomplete=incomplete,
extra=extra)
surf['coord_frame'] = surf.get('coord_frame', FIFF.FIFFV_COORD_MRI)
surf.update(np=len(surf['rr']), ntri=len(surf['tris']))
if rescale:
surf['rr'] /= 1000. # convert to meters
# Shifting surfaces is not implemented here...
# Order the surfaces for the benefit of the topology checks
for surf, sigma in zip(surfs, sigmas):
surf['sigma'] = sigma
surfs = _order_surfaces(surfs)
# Check topology as best we can
_check_surfaces(surfs, incomplete=incomplete)
for surf in surfs:
_check_surface_size(surf)
_check_thicknesses(surfs)
logger.info('Surfaces passed the basic topology checks.')
return surfs
@verbose
def make_bem_model(subject, ico=4, conductivity=(0.3, 0.006, 0.3),
subjects_dir=None, verbose=None):
"""Create a BEM model for a subject.
.. note:: To get a single layer bem corresponding to the --homog flag in
the command line tool set the ``conductivity`` parameter
to a list/tuple with a single value (e.g. [0.3]).
Parameters
----------
subject : str
The subject.
ico : int | None
The surface ico downsampling to use, e.g. 5=20484, 4=5120, 3=1280.
If None, no subsampling is applied.
conductivity : array of int, shape (3,) or (1,)
The conductivities to use for each shell. Should be a single element
for a one-layer model, or three elements for a three-layer model.
Defaults to ``[0.3, 0.006, 0.3]``. The MNE-C default for a
single-layer model would be ``[0.3]``.
%(subjects_dir)s
%(verbose)s
Returns
-------
surfaces : list of dict
The BEM surfaces. Use `make_bem_solution` to turn these into a
`~mne.bem.ConductorModel` suitable for forward calculation.
See Also
--------
make_bem_solution
make_sphere_model
read_bem_surfaces
write_bem_surfaces
Notes
-----
.. versionadded:: 0.10.0
"""
conductivity = np.array(conductivity, float)
if conductivity.ndim != 1 or conductivity.size not in (1, 3):
raise ValueError('conductivity must be 1D array-like with 1 or 3 '
'elements')
subjects_dir = get_subjects_dir(subjects_dir, raise_error=True)
subject_dir = op.join(subjects_dir, subject)
bem_dir = op.join(subject_dir, 'bem')
inner_skull = op.join(bem_dir, 'inner_skull.surf')
outer_skull = op.join(bem_dir, 'outer_skull.surf')
outer_skin = op.join(bem_dir, 'outer_skin.surf')
surfaces = [inner_skull, outer_skull, outer_skin]
ids = [FIFF.FIFFV_BEM_SURF_ID_BRAIN,
FIFF.FIFFV_BEM_SURF_ID_SKULL,
FIFF.FIFFV_BEM_SURF_ID_HEAD]
logger.info('Creating the BEM geometry...')
if len(conductivity) == 1:
surfaces = surfaces[:1]
ids = ids[:1]
surfaces = _surfaces_to_bem(surfaces, ids, conductivity, ico)
_check_bem_size(surfaces)
logger.info('Complete.\n')
return surfaces
# ############################################################################
# Compute EEG sphere model
def _fwd_eeg_get_multi_sphere_model_coeffs(m, n_terms):
"""Get the model depended weighting factor for n."""
nlayer = len(m['layers'])
if nlayer in (0, 1):
return 1.
# Initialize the arrays
c1 = np.zeros(nlayer - 1)
c2 = np.zeros(nlayer - 1)
cr = np.zeros(nlayer - 1)
cr_mult = np.zeros(nlayer - 1)
for k in range(nlayer - 1):
c1[k] = m['layers'][k]['sigma'] / m['layers'][k + 1]['sigma']
c2[k] = c1[k] - 1.0
cr_mult[k] = m['layers'][k]['rel_rad']
cr[k] = cr_mult[k]
cr_mult[k] *= cr_mult[k]
coeffs = np.zeros(n_terms - 1)
for n in range(1, n_terms):
# Increment the radius coefficients
for k in range(nlayer - 1):
cr[k] *= cr_mult[k]
# Multiply the matrices
M = np.eye(2)
n1 = n + 1.0
for k in range(nlayer - 2, -1, -1):
M = np.dot([[n + n1 * c1[k], n1 * c2[k] / cr[k]],
[n * c2[k] * cr[k], n1 + n * c1[k]]], M)
num = n * (2.0 * n + 1.0) ** (nlayer - 1)
coeffs[n - 1] = num / (n * M[1, 1] + n1 * M[1, 0])
return coeffs
def _compose_linear_fitting_data(mu, u):
"""Get the linear fitting data."""
k1 = np.arange(1, u['nterms'])
mu1ns = mu[0] ** k1
# data to be fitted
y = u['w'][:-1] * (u['fn'][1:] - mu1ns * u['fn'][0])
# model matrix
M = u['w'][:-1, np.newaxis] * (mu[1:] ** k1[:, np.newaxis] -
mu1ns[:, np.newaxis])
uu, sing, vv = linalg.svd(M, full_matrices=False)
ncomp = u['nfit'] - 1
uu, sing, vv = uu[:, :ncomp], sing[:ncomp], vv[:ncomp]
return y, uu, sing, vv
def _compute_linear_parameters(mu, u):
"""Compute the best-fitting linear parameters."""
y, uu, sing, vv = _compose_linear_fitting_data(mu, u)
# Compute the residuals
vec = np.dot(y, uu)
resi = y - np.dot(uu, vec)
vec /= sing
lambda_ = np.zeros(u['nfit'])
lambda_[1:] = np.dot(vec, vv)
lambda_[0] = u['fn'][0] - np.sum(lambda_[1:])
rv = np.dot(resi, resi) / np.dot(y, y)
return rv, lambda_
def _one_step(mu, u):
"""Evaluate the residual sum of squares fit for one set of mu values."""
if np.abs(mu).max() > 1.0:
return 1.0
# Compose the data for the linear fitting, compute SVD, then residuals
y, uu, sing, vv = _compose_linear_fitting_data(mu, u)
resi = y - np.dot(uu, np.dot(y, uu))
return np.dot(resi, resi)
def _fwd_eeg_fit_berg_scherg(m, nterms, nfit):
"""Fit the Berg-Scherg equivalent spherical model dipole parameters."""
from scipy.optimize import fmin_cobyla
assert nfit >= 2
u = dict(nfit=nfit, nterms=nterms)
# (1) Calculate the coefficients of the true expansion
u['fn'] = _fwd_eeg_get_multi_sphere_model_coeffs(m, nterms + 1)
# (2) Calculate the weighting
f = (min([layer['rad'] for layer in m['layers']]) /
max([layer['rad'] for layer in m['layers']]))
# correct weighting
k = np.arange(1, nterms + 1)
u['w'] = np.sqrt((2.0 * k + 1) * (3.0 * k + 1.0) /
k) * np.power(f, (k - 1.0))
u['w'][-1] = 0
# Do the nonlinear minimization, constraining mu to the interval [-1, +1]
mu_0 = np.zeros(3)
fun = partial(_one_step, u=u)
max_ = 1. - 2e-4 # adjust for fmin_cobyla "catol" that not all scipy have
cons = list()
for ii in range(nfit):
def mycon(x, ii=ii):
return max_ - np.abs(x[ii])
cons.append(mycon)
mu = fmin_cobyla(fun, mu_0, cons, rhobeg=0.5, rhoend=1e-5, disp=0)
# (6) Do the final step: calculation of the linear parameters
rv, lambda_ = _compute_linear_parameters(mu, u)
order = np.argsort(mu)[::-1]
mu, lambda_ = mu[order], lambda_[order] # sort: largest mu first
m['mu'] = mu
# This division takes into account the actual conductivities
m['lambda'] = lambda_ / m['layers'][-1]['sigma']
m['nfit'] = nfit
return rv
@verbose
def make_sphere_model(r0=(0., 0., 0.04), head_radius=0.09, info=None,
relative_radii=(0.90, 0.92, 0.97, 1.0),
sigmas=(0.33, 1.0, 0.004, 0.33), verbose=None):
"""Create a spherical model for forward solution calculation.
Parameters
----------
r0 : array-like | str
Head center to use (in head coordinates). If 'auto', the head
center will be calculated from the digitization points in info.
head_radius : float | str | None
If float, compute spherical shells for EEG using the given radius.
If 'auto', estimate an appropriate radius from the dig points in Info,
If None, exclude shells (single layer sphere model).
info : instance of Info | None
Measurement info. Only needed if ``r0`` or ``head_radius`` are
``'auto'``.
relative_radii : array-like
Relative radii for the spherical shells.
sigmas : array-like
Sigma values for the spherical shells.
%(verbose)s
Returns
-------
sphere : instance of ConductorModel
The resulting spherical conductor model.
See Also
--------
make_bem_model
make_bem_solution
Notes
-----
The default model has::
relative_radii = (0.90, 0.92, 0.97, 1.0)
sigmas = (0.33, 1.0, 0.004, 0.33)
These correspond to compartments (with relative radii in ``m`` and
conductivities σ in ``S/m``) for the brain, CSF, skull, and scalp,
respectively.
.. versionadded:: 0.9.0
"""
for name in ('r0', 'head_radius'):
param = locals()[name]
if isinstance(param, str):
if param != 'auto':
raise ValueError('%s, if str, must be "auto" not "%s"'
% (name, param))
relative_radii = np.array(relative_radii, float).ravel()
sigmas = np.array(sigmas, float).ravel()
if len(relative_radii) != len(sigmas):
raise ValueError('relative_radii length (%s) must match that of '
'sigmas (%s)' % (len(relative_radii),
len(sigmas)))
if len(sigmas) <= 1 and head_radius is not None:
raise ValueError('at least 2 sigmas must be supplied if '
'head_radius is not None, got %s' % (len(sigmas),))
if (isinstance(r0, str) and r0 == 'auto') or \
(isinstance(head_radius, str) and head_radius == 'auto'):
if info is None:
raise ValueError('Info must not be None for auto mode')
head_radius_fit, r0_fit = fit_sphere_to_headshape(info, units='m')[:2]
if isinstance(r0, str):
r0 = r0_fit
if isinstance(head_radius, str):
head_radius = head_radius_fit
sphere = ConductorModel(is_sphere=True, r0=np.array(r0),
coord_frame=FIFF.FIFFV_COORD_HEAD)
sphere['layers'] = list()
if head_radius is not None:
# Eventually these could be configurable...
relative_radii = np.array(relative_radii, float)
sigmas = np.array(sigmas, float)
order = np.argsort(relative_radii)
relative_radii = relative_radii[order]
sigmas = sigmas[order]
for rel_rad, sig in zip(relative_radii, sigmas):
# sort layers by (relative) radius, and scale radii
layer = dict(rad=rel_rad, sigma=sig)
layer['rel_rad'] = layer['rad'] = rel_rad
sphere['layers'].append(layer)
# scale the radii
R = sphere['layers'][-1]['rad']
rR = sphere['layers'][-1]['rel_rad']
for layer in sphere['layers']:
layer['rad'] /= R
layer['rel_rad'] /= rR
#
# Setup the EEG sphere model calculations
#
# Scale the relative radii
for k in range(len(relative_radii)):
sphere['layers'][k]['rad'] = (head_radius *
sphere['layers'][k]['rel_rad'])
rv = _fwd_eeg_fit_berg_scherg(sphere, 200, 3)
logger.info('\nEquiv. model fitting -> RV = %g %%' % (100 * rv))
for k in range(3):
logger.info('mu%d = %g lambda%d = %g'
% (k + 1, sphere['mu'][k], k + 1,
sphere['layers'][-1]['sigma'] *
sphere['lambda'][k]))
logger.info('Set up EEG sphere model with scalp radius %7.1f mm\n'
% (1000 * head_radius,))
return sphere
# #############################################################################
# Sphere fitting
@verbose
def fit_sphere_to_headshape(info, dig_kinds='auto', units='m', verbose=None):
"""Fit a sphere to the headshape points to determine head center.
Parameters
----------
info : instance of Info
Measurement info.
%(dig_kinds)s
units : str
Can be "m" (default) or "mm".
.. versionadded:: 0.12
move_origin : bool
If True, allow the origin to vary. Otherwise, fix it at (0, 0, 0).
.. versionadded:: 0.20
%(verbose)s
Returns
-------
radius : float
Sphere radius.
origin_head: ndarray, shape (3,)
Head center in head coordinates.
origin_device: ndarray, shape (3,)
Head center in device coordinates.
Notes
-----
This function excludes any points that are low and frontal
(``z < 0 and y > 0``) to improve the fit.
"""
if not isinstance(units, str) or units not in ('m', 'mm'):
raise ValueError('units must be a "m" or "mm"')
radius, origin_head, origin_device = _fit_sphere_to_headshape(
info, dig_kinds)
if units == 'mm':
radius *= 1e3
origin_head *= 1e3
origin_device *= 1e3
return radius, origin_head, origin_device
@verbose
def get_fitting_dig(info, dig_kinds='auto', exclude_frontal=True,
verbose=None):
"""Get digitization points suitable for sphere fitting.
Parameters
----------
info : instance of Info
The measurement info.
%(dig_kinds)s
%(exclude_frontal)s
Default is True.
.. versionadded:: 0.19
%(verbose)s
Returns
-------
dig : array, shape (n_pts, 3)
The digitization points (in head coordinates) to use for fitting.
Notes
-----
This will exclude digitization locations that have ``z < 0 and y > 0``,
i.e. points on the nose and below the nose on the face.
.. versionadded:: 0.14
"""
_validate_type(info, "info")
if info['dig'] is None:
raise RuntimeError('Cannot fit headshape without digitization '
', info["dig"] is None')
if isinstance(dig_kinds, str):
if dig_kinds == 'auto':
# try "extra" first
try:
return get_fitting_dig(info, 'extra')
except ValueError:
pass
return get_fitting_dig(info, ('extra', 'eeg'))
else:
dig_kinds = (dig_kinds,)
# convert string args to ints (first make dig_kinds mutable in case tuple)
dig_kinds = list(dig_kinds)
for di, d in enumerate(dig_kinds):
dig_kinds[di] = _dig_kind_dict.get(d, d)
if dig_kinds[di] not in _dig_kind_ints:
raise ValueError('dig_kinds[#%d] (%s) must be one of %s'
% (di, d, sorted(list(_dig_kind_dict.keys()))))
# get head digization points of the specified kind(s)
hsp = [p['r'] for p in info['dig'] if p['kind'] in dig_kinds]
if any(p['coord_frame'] != FIFF.FIFFV_COORD_HEAD for p in info['dig']):
raise RuntimeError('Digitization points not in head coordinates, '
'contact mne-python developers')
# exclude some frontal points (nose etc.)
if exclude_frontal:
hsp = [p for p in hsp if not (p[2] < -1e-6 and p[1] > 1e-6)]
hsp = np.array(hsp)
if len(hsp) <= 10:
kinds_str = ', '.join(['"%s"' % _dig_kind_rev[d]
for d in sorted(dig_kinds)])
msg = ('Only %s head digitization points of the specified kind%s (%s,)'
% (len(hsp), _pl(dig_kinds), kinds_str))
if len(hsp) < 4:
raise ValueError(msg + ', at least 4 required')
else:
warn(msg + ', fitting may be inaccurate')
return hsp
@verbose
def _fit_sphere_to_headshape(info, dig_kinds, verbose=None):
"""Fit a sphere to the given head shape."""
hsp = get_fitting_dig(info, dig_kinds)
radius, origin_head = _fit_sphere(np.array(hsp), disp=False)
# compute origin in device coordinates
dev_head_t = info['dev_head_t']
if dev_head_t is None:
dev_head_t = Transform('meg', 'head')
head_to_dev = _ensure_trans(dev_head_t, 'head', 'meg')
origin_device = apply_trans(head_to_dev, origin_head)
logger.info('Fitted sphere radius:'.ljust(30) + '%0.1f mm'
% (radius * 1e3,))
# 99th percentile on Wikipedia for Giabella to back of head is 21.7cm,
# i.e. 108mm "radius", so let's go with 110mm
# en.wikipedia.org/wiki/Human_head#/media/File:HeadAnthropometry.JPG
if radius > 0.110:
warn('Estimated head size (%0.1f mm) exceeded 99th '
'percentile for adult head size' % (1e3 * radius,))
# > 2 cm away from head center in X or Y is strange
if np.linalg.norm(origin_head[:2]) > 0.02:
warn('(X, Y) fit (%0.1f, %0.1f) more than 20 mm from '
'head frame origin' % tuple(1e3 * origin_head[:2]))
logger.info('Origin head coordinates:'.ljust(30) +
'%0.1f %0.1f %0.1f mm' % tuple(1e3 * origin_head))
logger.info('Origin device coordinates:'.ljust(30) +
'%0.1f %0.1f %0.1f mm' % tuple(1e3 * origin_device))
return radius, origin_head, origin_device
def _fit_sphere(points, disp='auto'):
"""Fit a sphere to an arbitrary set of points."""
from scipy.optimize import fmin_cobyla
if isinstance(disp, str) and disp == 'auto':
disp = True if logger.level <= 20 else False
# initial guess for center and radius
radii = (np.max(points, axis=1) - np.min(points, axis=1)) / 2.
radius_init = radii.mean()
center_init = np.median(points, axis=0)
# optimization
x0 = np.concatenate([center_init, [radius_init]])
def cost_fun(center_rad):
d = np.linalg.norm(points - center_rad[:3], axis=1) - center_rad[3]
d *= d
return d.sum()
def constraint(center_rad):
return center_rad[3] # radius must be >= 0
x_opt = fmin_cobyla(cost_fun, x0, constraint, rhobeg=radius_init,
rhoend=radius_init * 1e-6, disp=disp)
origin, radius = x_opt[:3], x_opt[3]
return radius, origin
def _check_origin(origin, info, coord_frame='head', disp=False):
"""Check or auto-determine the origin."""
if isinstance(origin, str):
if origin != 'auto':
raise ValueError('origin must be a numerical array, or "auto", '
'not %s' % (origin,))
if coord_frame == 'head':
R, origin = fit_sphere_to_headshape(info, verbose=False,
units='m')[:2]
logger.info(' Automatic origin fit: head of radius %0.1f mm'
% (R * 1000.,))
del R
else:
origin = (0., 0., 0.)
origin = np.array(origin, float)
if origin.shape != (3,):
raise ValueError('origin must be a 3-element array')
if disp:
origin_str = ', '.join(['%0.1f' % (o * 1000) for o in origin])
msg = (' Using origin %s mm in the %s frame'
% (origin_str, coord_frame))
if coord_frame == 'meg' and info['dev_head_t'] is not None:
o_dev = apply_trans(info['dev_head_t'], origin)
origin_str = ', '.join('%0.1f' % (o * 1000,) for o in o_dev)
msg += ' (%s mm in the head frame)' % (origin_str,)
logger.info(msg)
return origin
# ############################################################################
# Create BEM surfaces
@verbose
def make_watershed_bem(subject, subjects_dir=None, overwrite=False,
volume='T1', atlas=False, gcaatlas=False, preflood=None,
show=False, copy=False, T1=None, brainmask='ws.mgz',
verbose=None):
"""Create BEM surfaces using the FreeSurfer watershed algorithm.
Parameters
----------
subject : str
Subject name.
$(subjects_dir)s
overwrite : bool
Write over existing files.
volume : str
Defaults to T1.
atlas : bool
Specify the --atlas option for mri_watershed.
gcaatlas : bool
Specify the --brain_atlas option for mri_watershed.
preflood : int
Change the preflood height
show : bool
Show surfaces to visually inspect all three BEM surfaces (recommended).
.. versionadded:: 0.12
copy : bool
If True (default False), use copies instead of symlinks for surfaces
(if they do not already exist).
.. versionadded:: 0.18
T1 : bool | None
If True, pass the ``-T1`` flag.
By default (None), this takes the same value as ``gcaatlas``.
.. versionadded:: 0.19
brainmask : str
The filename for the brainmask output file relative to the
``$SUBJECTS_DIR/$SUBJECT/bem/watershed/`` directory.
Can be for example ``"../../mri/brainmask.mgz"`` to overwrite
the brainmask obtained via ``recon-all -autorecon1``.
.. versionadded:: 0.19
%(verbose)s
See Also
--------
mne.viz.plot_bem
Notes
-----
If your BEM meshes do not look correct when viewed in
:func:`mne.viz.plot_alignment` or :func:`mne.viz.plot_bem`, consider
potential solutions from the :ref:`FAQ <faq_watershed_bem_meshes>`.
.. versionadded:: 0.10
"""
from .viz.misc import plot_bem
env, mri_dir, bem_dir = _prepare_env(subject, subjects_dir)
tempdir = _TempDir() # fsl and Freesurfer create some random junk in CWD
run_subprocess_env = partial(run_subprocess, env=env,
cwd=tempdir)
subjects_dir = env['SUBJECTS_DIR'] # Set by _prepare_env() above.
subject_dir = op.join(subjects_dir, subject)
ws_dir = op.join(bem_dir, 'watershed')
T1_dir = op.join(mri_dir, volume)
T1_mgz = T1_dir
if not T1_dir.endswith('.mgz'):
T1_mgz += '.mgz'
if not op.isdir(bem_dir):
os.makedirs(bem_dir)
_check_fname(T1_mgz, overwrite='read', must_exist=True, name='MRI data')
if op.isdir(ws_dir):
if not overwrite:
raise RuntimeError('%s already exists. Use the --overwrite option'
' to recreate it.' % ws_dir)
else:
shutil.rmtree(ws_dir)
# put together the command
cmd = ['mri_watershed']
if preflood:
cmd += ["-h", "%s" % int(preflood)]
if T1 is None:
T1 = gcaatlas
if T1:
cmd += ['-T1']
if gcaatlas:
fname = op.join(env['FREESURFER_HOME'], 'average',
'RB_all_withskull_*.gca')
fname = sorted(glob.glob(fname))[::-1][0]
logger.info('Using GCA atlas: %s' % (fname,))
cmd += ['-atlas', '-brain_atlas', fname,
subject_dir + '/mri/transforms/talairach_with_skull.lta']
elif atlas:
cmd += ['-atlas']
if op.exists(T1_mgz):
cmd += ['-useSRAS', '-surf', op.join(ws_dir, subject), T1_mgz,
op.join(ws_dir, brainmask)]
else:
cmd += ['-useSRAS', '-surf', op.join(ws_dir, subject), T1_dir,
op.join(ws_dir, brainmask)]
# report and run
logger.info('\nRunning mri_watershed for BEM segmentation with the '
'following parameters:\n\nResults dir = %s\nCommand = %s\n'
% (ws_dir, ' '.join(cmd)))
os.makedirs(op.join(ws_dir))
run_subprocess_env(cmd)
del tempdir # clean up directory
if op.isfile(T1_mgz):
new_info = _extract_volume_info(T1_mgz) if has_nibabel() else dict()
if not new_info:
warn('nibabel is not available or the volumn info is invalid.'
'Volume info not updated in the written surface.')
surfs = ['brain', 'inner_skull', 'outer_skull', 'outer_skin']
for s in surfs:
surf_ws_out = op.join(ws_dir, '%s_%s_surface' % (subject, s))
rr, tris, volume_info = read_surface(surf_ws_out,
read_metadata=True)
# replace volume info, 'head' stays
volume_info.update(new_info)
write_surface(surf_ws_out, rr, tris, volume_info=volume_info,
overwrite=True)
# Create symbolic links
surf_out = op.join(bem_dir, '%s.surf' % s)
if not overwrite and op.exists(surf_out):
skip_symlink = True
else:
if op.exists(surf_out):
os.remove(surf_out)
_symlink(surf_ws_out, surf_out, copy)
skip_symlink = False
if skip_symlink:
logger.info("Unable to create all symbolic links to .surf files "
"in bem folder. Use --overwrite option to recreate "
"them.")
dest = op.join(bem_dir, 'watershed')
else:
logger.info("Symbolic links to .surf files created in bem folder")
dest = bem_dir
logger.info("\nThank you for waiting.\nThe BEM triangulations for this "
"subject are now available at:\n%s." % dest)
# Write a head file for coregistration
fname_head = op.join(bem_dir, subject + '-head.fif')
if op.isfile(fname_head):
os.remove(fname_head)
surf = _surfaces_to_bem([op.join(ws_dir, subject + '_outer_skin_surface')],
[FIFF.FIFFV_BEM_SURF_ID_HEAD], sigmas=[1])
write_bem_surfaces(fname_head, surf)
# Show computed BEM surfaces
if show:
plot_bem(subject=subject, subjects_dir=subjects_dir,
orientation='coronal', slices=None, show=True)
logger.info('Created %s\n\nComplete.' % (fname_head,))
def _extract_volume_info(mgz):
"""Extract volume info from a mgz file."""
import nibabel
header = nibabel.load(mgz).header
version = header['version']
vol_info = dict()
if version == 1:
version = '%s # volume info valid' % version
vol_info['valid'] = version
vol_info['filename'] = mgz
vol_info['volume'] = header['dims'][:3]
vol_info['voxelsize'] = header['delta']
vol_info['xras'], vol_info['yras'], vol_info['zras'] = header['Mdc']
vol_info['cras'] = header['Pxyz_c']
return vol_info
# ############################################################################
# Read
@verbose
def read_bem_surfaces(fname, patch_stats=False, s_id=None, verbose=None):
"""Read the BEM surfaces from a FIF file.
Parameters
----------
fname : str
The name of the file containing the surfaces.
patch_stats : bool, optional (default False)
Calculate and add cortical patch statistics to the surfaces.
s_id : int | None
If int, only read and return the surface with the given s_id.
An error will be raised if it doesn't exist. If None, all
surfaces are read and returned.
%(verbose)s
Returns
-------
surf: list | dict
A list of dictionaries that each contain a surface. If s_id
is not None, only the requested surface will be returned.
See Also
--------
write_bem_surfaces, write_bem_solution, make_bem_model
"""
# Default coordinate frame
coord_frame = FIFF.FIFFV_COORD_MRI
# Open the file, create directory
f, tree, _ = fiff_open(fname)
with f as fid:
# Find BEM
bem = dir_tree_find(tree, FIFF.FIFFB_BEM)
if bem is None or len(bem) == 0:
raise ValueError('BEM data not found')
bem = bem[0]
# Locate all surfaces
bemsurf = dir_tree_find(bem, FIFF.FIFFB_BEM_SURF)
if bemsurf is None:
raise ValueError('BEM surface data not found')
logger.info(' %d BEM surfaces found' % len(bemsurf))
# Coordinate frame possibly at the top level
tag = find_tag(fid, bem, FIFF.FIFF_BEM_COORD_FRAME)
if tag is not None:
coord_frame = tag.data
# Read all surfaces
if s_id is not None:
surf = [_read_bem_surface(fid, bsurf, coord_frame, s_id)
for bsurf in bemsurf]
surf = [s for s in surf if s is not None]
if not len(surf) == 1:
raise ValueError('surface with id %d not found' % s_id)
else:
surf = list()
for bsurf in bemsurf:
logger.info(' Reading a surface...')
this = _read_bem_surface(fid, bsurf, coord_frame)
surf.append(this)
logger.info('[done]')
logger.info(' %d BEM surfaces read' % len(surf))
for this in surf:
if patch_stats or this['nn'] is None:
_check_complete_surface(this)
return surf[0] if s_id is not None else surf
def _read_bem_surface(fid, this, def_coord_frame, s_id=None):
"""Read one bem surface."""
# fid should be open as a context manager here
res = dict()
# Read all the interesting stuff
tag = find_tag(fid, this, FIFF.FIFF_BEM_SURF_ID)
if tag is None:
res['id'] = FIFF.FIFFV_BEM_SURF_ID_UNKNOWN
else:
res['id'] = int(tag.data)
if s_id is not None and res['id'] != s_id:
return None
tag = find_tag(fid, this, FIFF.FIFF_BEM_SIGMA)
res['sigma'] = 1.0 if tag is None else float(tag.data)
tag = find_tag(fid, this, FIFF.FIFF_BEM_SURF_NNODE)
if tag is None:
raise ValueError('Number of vertices not found')
res['np'] = int(tag.data)
tag = find_tag(fid, this, FIFF.FIFF_BEM_SURF_NTRI)
if tag is None:
raise ValueError('Number of triangles not found')
res['ntri'] = int(tag.data)
tag = find_tag(fid, this, FIFF.FIFF_MNE_COORD_FRAME)
if tag is None:
tag = find_tag(fid, this, FIFF.FIFF_BEM_COORD_FRAME)
if tag is None:
res['coord_frame'] = def_coord_frame
else:
res['coord_frame'] = tag.data
else:
res['coord_frame'] = tag.data
# Vertices, normals, and triangles
tag = find_tag(fid, this, FIFF.FIFF_BEM_SURF_NODES)
if tag is None:
raise ValueError('Vertex data not found')
res['rr'] = tag.data.astype(np.float64) # XXX : double because of mayavi
if res['rr'].shape[0] != res['np']:
raise ValueError('Vertex information is incorrect')
tag = find_tag(fid, this, FIFF.FIFF_MNE_SOURCE_SPACE_NORMALS)
if tag is None:
tag = find_tag(fid, this, FIFF.FIFF_BEM_SURF_NORMALS)
if tag is None:
res['nn'] = None
else:
res['nn'] = tag.data.copy()
if res['nn'].shape[0] != res['np']:
raise ValueError('Vertex normal information is incorrect')
tag = find_tag(fid, this, FIFF.FIFF_BEM_SURF_TRIANGLES)
if tag is None:
raise ValueError('Triangulation not found')
res['tris'] = tag.data - 1 # index start at 0 in Python
if res['tris'].shape[0] != res['ntri']:
raise ValueError('Triangulation information is incorrect')
return res
@verbose
def read_bem_solution(fname, verbose=None):
"""Read the BEM solution from a file.
Parameters
----------
fname : str
The file containing the BEM solution.
%(verbose)s
Returns
-------
bem : instance of ConductorModel
The BEM solution.
See Also
--------
read_bem_surfaces
write_bem_surfaces
make_bem_solution
write_bem_solution
"""
# mirrors fwd_bem_load_surfaces from fwd_bem_model.c
logger.info('Loading surfaces...')
bem_surfs = read_bem_surfaces(fname, patch_stats=True, verbose=False)
if len(bem_surfs) == 3:
logger.info('Three-layer model surfaces loaded.')
needed = np.array([FIFF.FIFFV_BEM_SURF_ID_HEAD,
FIFF.FIFFV_BEM_SURF_ID_SKULL,
FIFF.FIFFV_BEM_SURF_ID_BRAIN])
if not all(x['id'] in needed for x in bem_surfs):
raise RuntimeError('Could not find necessary BEM surfaces')
# reorder surfaces as necessary (shouldn't need to?)
reorder = [None] * 3
for x in bem_surfs:
reorder[np.where(x['id'] == needed)[0][0]] = x
bem_surfs = reorder
elif len(bem_surfs) == 1:
if not bem_surfs[0]['id'] == FIFF.FIFFV_BEM_SURF_ID_BRAIN:
raise RuntimeError('BEM Surfaces not found')
logger.info('Homogeneous model surface loaded.')
# convert from surfaces to solution
bem = ConductorModel(is_sphere=False, surfs=bem_surfs)
logger.info('\nLoading the solution matrix...\n')
f, tree, _ = fiff_open(fname)
with f as fid:
# Find the BEM data
nodes = dir_tree_find(tree, FIFF.FIFFB_BEM)
if len(nodes) == 0:
raise RuntimeError('No BEM data in %s' % fname)
bem_node = nodes[0]
# Approximation method
tag = find_tag(f, bem_node, FIFF.FIFF_BEM_APPROX)
if tag is None:
raise RuntimeError('No BEM solution found in %s' % fname)
method = tag.data[0]
if method not in (FIFF.FIFFV_BEM_APPROX_CONST,
FIFF.FIFFV_BEM_APPROX_LINEAR):
raise RuntimeError('Cannot handle BEM approximation method : %d'
% method)
tag = find_tag(fid, bem_node, FIFF.FIFF_BEM_POT_SOLUTION)
dims = tag.data.shape
if len(dims) != 2:
raise RuntimeError('Expected a two-dimensional solution matrix '
'instead of a %d dimensional one' % dims[0])
dim = 0
for surf in bem['surfs']:
if method == FIFF.FIFFV_BEM_APPROX_LINEAR:
dim += surf['np']
else: # method == FIFF.FIFFV_BEM_APPROX_CONST
dim += surf['ntri']
if dims[0] != dim or dims[1] != dim:
raise RuntimeError('Expected a %d x %d solution matrix instead of '
'a %d x %d one' % (dim, dim, dims[1], dims[0]))
sol = tag.data
nsol = dims[0]
bem['solution'] = sol
bem['nsol'] = nsol
bem['bem_method'] = method
# Gamma factors and multipliers
_add_gamma_multipliers(bem)
kind = {
FIFF.FIFFV_BEM_APPROX_CONST: 'constant collocation',
FIFF.FIFFV_BEM_APPROX_LINEAR: 'linear_collocation',
}[bem['bem_method']]
logger.info('Loaded %s BEM solution from %s', kind, fname)
return bem
def _add_gamma_multipliers(bem):
"""Add gamma and multipliers in-place."""
bem['sigma'] = np.array([surf['sigma'] for surf in bem['surfs']])
# Dirty trick for the zero conductivity outside
sigma = np.r_[0.0, bem['sigma']]
bem['source_mult'] = 2.0 / (sigma[1:] + sigma[:-1])
bem['field_mult'] = sigma[1:] - sigma[:-1]
# make sure subsequent "zip"s work correctly
assert len(bem['surfs']) == len(bem['field_mult'])
bem['gamma'] = ((sigma[1:] - sigma[:-1])[np.newaxis, :] /
(sigma[1:] + sigma[:-1])[:, np.newaxis])
_surf_dict = {'inner_skull': FIFF.FIFFV_BEM_SURF_ID_BRAIN,
'outer_skull': FIFF.FIFFV_BEM_SURF_ID_SKULL,
'head': FIFF.FIFFV_BEM_SURF_ID_HEAD}
def _bem_find_surface(bem, id_):
"""Find surface from already-loaded BEM."""
if isinstance(id_, str):
name = id_
id_ = _surf_dict[id_]
else:
name = _surf_name[id_]
idx = np.where(np.array([s['id'] for s in bem['surfs']]) == id_)[0]
if len(idx) != 1:
raise RuntimeError('BEM model does not have the %s triangulation'
% name.replace('_', ' '))
return bem['surfs'][idx[0]]
# ############################################################################
# Write
def write_bem_surfaces(fname, surfs):
"""Write BEM surfaces to a fiff file.
Parameters
----------
fname : str
Filename to write.
surfs : dict | list of dict
The surfaces, or a single surface.
"""
if isinstance(surfs, dict):
surfs = [surfs]
with start_file(fname) as fid:
start_block(fid, FIFF.FIFFB_BEM)
write_int(fid, FIFF.FIFF_BEM_COORD_FRAME, surfs[0]['coord_frame'])
_write_bem_surfaces_block(fid, surfs)
end_block(fid, FIFF.FIFFB_BEM)
end_file(fid)
def _write_bem_surfaces_block(fid, surfs):
"""Write bem surfaces to open file handle."""
for surf in surfs:
start_block(fid, FIFF.FIFFB_BEM_SURF)
write_float(fid, FIFF.FIFF_BEM_SIGMA, surf['sigma'])
write_int(fid, FIFF.FIFF_BEM_SURF_ID, surf['id'])
write_int(fid, FIFF.FIFF_MNE_COORD_FRAME, surf['coord_frame'])
write_int(fid, FIFF.FIFF_BEM_SURF_NNODE, surf['np'])
write_int(fid, FIFF.FIFF_BEM_SURF_NTRI, surf['ntri'])
write_float_matrix(fid, FIFF.FIFF_BEM_SURF_NODES, surf['rr'])
# index start at 0 in Python
write_int_matrix(fid, FIFF.FIFF_BEM_SURF_TRIANGLES,
surf['tris'] + 1)
if 'nn' in surf and surf['nn'] is not None and len(surf['nn']) > 0:
write_float_matrix(fid, FIFF.FIFF_BEM_SURF_NORMALS, surf['nn'])
end_block(fid, FIFF.FIFFB_BEM_SURF)
def write_bem_solution(fname, bem):
"""Write a BEM model with solution.
Parameters
----------
fname : str
The filename to use.
bem : instance of ConductorModel
The BEM model with solution to save.
See Also
--------
read_bem_solution
"""
_check_bem_size(bem['surfs'])
with start_file(fname) as fid:
start_block(fid, FIFF.FIFFB_BEM)
# Coordinate frame (mainly for backward compatibility)
write_int(fid, FIFF.FIFF_BEM_COORD_FRAME,
bem['surfs'][0]['coord_frame'])
# Surfaces
_write_bem_surfaces_block(fid, bem['surfs'])
# The potential solution
if 'solution' in bem:
if bem['bem_method'] != FWD.BEM_LINEAR_COLL:
raise RuntimeError('Only linear collocation supported')
write_int(fid, FIFF.FIFF_BEM_APPROX, FIFF.FIFFV_BEM_APPROX_LINEAR)
write_float_matrix(fid, FIFF.FIFF_BEM_POT_SOLUTION,
bem['solution'])
end_block(fid, FIFF.FIFFB_BEM)
end_file(fid)
# #############################################################################
# Create 3-Layers BEM model from Flash MRI images
def _prepare_env(subject, subjects_dir):
"""Prepare an env object for subprocess calls."""
env = os.environ.copy()
fs_home = _check_freesurfer_home()
_validate_type(subject, "str")
subjects_dir = get_subjects_dir(subjects_dir, raise_error=True)
if not op.isdir(subjects_dir):
raise RuntimeError('Could not find the MRI data directory "%s"'
% subjects_dir)
subject_dir = op.join(subjects_dir, subject)
if not op.isdir(subject_dir):
raise RuntimeError('Could not find the subject data directory "%s"'
% (subject_dir,))
env.update(SUBJECT=subject, SUBJECTS_DIR=subjects_dir,
FREESURFER_HOME=fs_home)
mri_dir = op.join(subject_dir, 'mri')
bem_dir = op.join(subject_dir, 'bem')
return env, mri_dir, bem_dir
@verbose
def convert_flash_mris(subject, flash30=True, convert=True, unwarp=False,
subjects_dir=None, verbose=None):
"""Convert DICOM files for use with make_flash_bem.
Parameters
----------
subject : str
Subject name.
flash30 : bool
Use 30-degree flip angle data.
convert : bool
Assume that the Flash MRI images have already been converted
to mgz files.
unwarp : bool
Run grad_unwarp with -unwarp option on each of the converted
data sets. It requires FreeSurfer's MATLAB toolbox to be properly
installed.
%(subjects_dir)s
%(verbose)s
Notes
-----
Before running this script do the following:
(unless convert=False is specified)
1. Copy all of your FLASH images in a single directory <source> and
create a directory <dest> to hold the output of mne_organize_dicom
2. cd to <dest> and run
$ mne_organize_dicom <source>
to create an appropriate directory structure
3. Create symbolic links to make flash05 and flash30 point to the
appropriate series:
$ ln -s <FLASH 5 series dir> flash05
$ ln -s <FLASH 30 series dir> flash30
Some partition formats (e.g. FAT32) do not support symbolic links.
In this case, copy the file to the appropriate series:
$ cp <FLASH 5 series dir> flash05
$ cp <FLASH 30 series dir> flash30
4. cd to the directory where flash05 and flash30 links are
5. Set SUBJECTS_DIR and SUBJECT environment variables appropriately
6. Run this script
This function assumes that the Freesurfer segmentation of the subject
has been completed. In particular, the T1.mgz and brain.mgz MRI volumes
should be, as usual, in the subject's mri directory.
"""
env, mri_dir = _prepare_env(subject, subjects_dir)[:2]
tempdir = _TempDir() # fsl and Freesurfer create some random junk in CWD
run_subprocess_env = partial(run_subprocess, env=env,
cwd=tempdir)
# Step 1a : Data conversion to mgz format
if not op.exists(op.join(mri_dir, 'flash', 'parameter_maps')):
os.makedirs(op.join(mri_dir, 'flash', 'parameter_maps'))
echos_done = 0
if convert:
logger.info("\n---- Converting Flash images ----")
echos = ['001', '002', '003', '004', '005', '006', '007', '008']
if flash30:
flashes = ['05', '30']
else:
flashes = ['05']
#
missing = False
for flash in flashes:
for echo in echos:
if not op.isdir(op.join('flash' + flash, echo)):
missing = True
if missing:
echos = ['002', '003', '004', '005', '006', '007', '008', '009']
for flash in flashes:
for echo in echos:
if not op.isdir(op.join('flash' + flash, echo)):
raise RuntimeError("Directory %s is missing."
% op.join('flash' + flash, echo))
#
for flash in flashes:
for echo in echos:
if not op.isdir(op.join('flash' + flash, echo)):
raise RuntimeError("Directory %s is missing."
% op.join('flash' + flash, echo))
sample_file = glob.glob(op.join('flash' + flash, echo, '*'))[0]
dest_file = op.join(mri_dir, 'flash',
'mef' + flash + '_' + echo + '.mgz')
# do not redo if already present
if op.isfile(dest_file):
logger.info("The file %s is already there")
else:
cmd = ['mri_convert', sample_file, dest_file]
run_subprocess_env(cmd)
echos_done += 1
# Step 1b : Run grad_unwarp on converted files
flash_dir = op.join(mri_dir, "flash")
template = op.join(flash_dir, "mef*.mgz")
files = glob.glob(template)
if len(files) == 0:
raise ValueError('No suitable source files found (%s)' % template)
if unwarp:
logger.info("\n---- Unwarp mgz data sets ----")
for infile in files:
outfile = infile.replace(".mgz", "u.mgz")
cmd = ['grad_unwarp', '-i', infile, '-o', outfile, '-unwarp',
'true']
run_subprocess_env(cmd)
# Clear parameter maps if some of the data were reconverted
pm_dir = op.join(flash_dir, 'parameter_maps')
if echos_done > 0 and op.exists(pm_dir):
shutil.rmtree(pm_dir)
logger.info("\nParameter maps directory cleared")
if not op.exists(pm_dir):
os.makedirs(pm_dir)
# Step 2 : Create the parameter maps
if flash30:
logger.info("\n---- Creating the parameter maps ----")
if unwarp:
files = glob.glob(op.join(flash_dir, "mef05*u.mgz"))
if len(os.listdir(pm_dir)) == 0:
cmd = (['mri_ms_fitparms'] +
files +
[op.join(flash_dir, 'parameter_maps')])
run_subprocess_env(cmd)
else:
logger.info("Parameter maps were already computed")
# Step 3 : Synthesize the flash 5 images
logger.info("\n---- Synthesizing flash 5 images ----")
if not op.exists(op.join(pm_dir, 'flash5.mgz')):
cmd = ['mri_synthesize', '20', '5', '5',
op.join(pm_dir, 'T1.mgz'),
op.join(pm_dir, 'PD.mgz'),
op.join(pm_dir, 'flash5.mgz')
]
run_subprocess_env(cmd)
os.remove(op.join(pm_dir, 'flash5_reg.mgz'))
else:
logger.info("Synthesized flash 5 volume is already there")
else:
logger.info("\n---- Averaging flash5 echoes ----")
template = op.join(flash_dir,
"mef05*u.mgz" if unwarp else "mef05*.mgz")
files = glob.glob(template)
if len(files) == 0:
raise ValueError('No suitable source files found (%s)' % template)
cmd = (['mri_average', '-noconform'] +
files +
[op.join(pm_dir, 'flash5.mgz')])
run_subprocess_env(cmd)
if op.exists(op.join(pm_dir, 'flash5_reg.mgz')):
os.remove(op.join(pm_dir, 'flash5_reg.mgz'))
del tempdir # finally done running subprocesses
assert op.isfile(op.join(pm_dir, 'flash5.mgz'))
@verbose
def make_flash_bem(subject, overwrite=False, show=True, subjects_dir=None,
flash_path=None, copy=False, verbose=None):
"""Create 3-Layer BEM model from prepared flash MRI images.
Parameters
----------
subject : str
Subject name.
overwrite : bool
Write over existing .surf files in bem folder.
show : bool
Show surfaces to visually inspect all three BEM surfaces (recommended).
%(subjects_dir)s
flash_path : str | None
Path to the flash images. If None (default), mri/flash/parameter_maps
within the subject reconstruction is used.
.. versionadded:: 0.13.0
copy : bool
If True (default False), use copies instead of symlinks for surfaces
(if they do not already exist).
.. versionadded:: 0.18
%(verbose)s
Notes
-----
This program assumes that FreeSurfer is installed and sourced properly.
This function extracts the BEM surfaces (outer skull, inner skull, and
outer skin) from multiecho FLASH MRI data with spin angles of 5 and 30
degrees, in mgz format.
See Also
--------
convert_flash_mris
"""
from .viz.misc import plot_bem
env, mri_dir, bem_dir = _prepare_env(subject, subjects_dir)
tempdir = _TempDir() # fsl and Freesurfer create some random junk in CWD
run_subprocess_env = partial(run_subprocess, env=env,
cwd=tempdir)
if flash_path is None:
flash_path = op.join(mri_dir, 'flash', 'parameter_maps')
else:
flash_path = op.abspath(flash_path)
subjects_dir = env['SUBJECTS_DIR']
logger.info('\nProcessing the flash MRI data to produce BEM meshes with '
'the following parameters:\n'
'SUBJECTS_DIR = %s\n'
'SUBJECT = %s\n'
'Result dir = %s\n' % (subjects_dir, subject,
op.join(bem_dir, 'flash')))
# Step 4 : Register with MPRAGE
logger.info("\n---- Registering flash 5 with MPRAGE ----")
flash5 = op.join(flash_path, 'flash5.mgz')
flash5_reg = op.join(flash_path, 'flash5_reg.mgz')
if not op.exists(flash5_reg):
if op.exists(op.join(mri_dir, 'T1.mgz')):
ref_volume = op.join(mri_dir, 'T1.mgz')
else:
ref_volume = op.join(mri_dir, 'T1')
cmd = ['fsl_rigid_register', '-r', ref_volume, '-i', flash5,
'-o', flash5_reg]
run_subprocess_env(cmd)
else:
logger.info("Registered flash 5 image is already there")
# Step 5a : Convert flash5 into COR
logger.info("\n---- Converting flash5 volume into COR format ----")
flash5_dir = op.join(mri_dir, 'flash5')
shutil.rmtree(flash5_dir, ignore_errors=True)
os.makedirs(flash5_dir)
cmd = ['mri_convert', flash5_reg, op.join(mri_dir, 'flash5')]
run_subprocess_env(cmd)
# Step 5b and c : Convert the mgz volumes into COR
convert_T1 = False
T1_dir = op.join(mri_dir, 'T1')
if not op.isdir(T1_dir) or len(glob.glob(op.join(T1_dir, 'COR*'))) == 0:
convert_T1 = True
convert_brain = False
brain_dir = op.join(mri_dir, 'brain')
if not op.isdir(brain_dir) or \
len(glob.glob(op.join(brain_dir, 'COR*'))) == 0:
convert_brain = True
logger.info("\n---- Converting T1 volume into COR format ----")
if convert_T1:
T1_fname = op.join(mri_dir, 'T1.mgz')
if not op.isfile(T1_fname):
raise RuntimeError("Both T1 mgz and T1 COR volumes missing.")
os.makedirs(T1_dir)
cmd = ['mri_convert', T1_fname, T1_dir]
run_subprocess_env(cmd)
else:
logger.info("T1 volume is already in COR format")
logger.info("\n---- Converting brain volume into COR format ----")
if convert_brain:
brain_fname = op.join(mri_dir, 'brain.mgz')
if not op.isfile(brain_fname):
raise RuntimeError("Both brain mgz and brain COR volumes missing.")
os.makedirs(brain_dir)
cmd = ['mri_convert', brain_fname, brain_dir]
run_subprocess_env(cmd)
else:
logger.info("Brain volume is already in COR format")
# Finally ready to go
logger.info("\n---- Creating the BEM surfaces ----")
cmd = ['mri_make_bem_surfaces', subject]
run_subprocess_env(cmd)
del tempdir # ran our last subprocess; clean up directory
logger.info("\n---- Converting the tri files into surf files ----")
flash_bem_dir = op.join(bem_dir, 'flash')
if not op.exists(flash_bem_dir):
os.makedirs(flash_bem_dir)
surfs = ['inner_skull', 'outer_skull', 'outer_skin']
for surf in surfs:
out_fname = op.join(flash_bem_dir, surf + '.tri')
shutil.move(op.join(bem_dir, surf + '.tri'), out_fname)
nodes, tris = read_tri(out_fname, swap=True)
# Do not write volume info here because the tris are already in
# standard Freesurfer coords
write_surface(op.splitext(out_fname)[0] + '.surf', nodes, tris,
overwrite=True)
# Cleanup section
logger.info("\n---- Cleaning up ----")
os.remove(op.join(bem_dir, 'inner_skull_tmp.tri'))
# os.chdir(mri_dir)
if convert_T1:
shutil.rmtree(T1_dir)
logger.info("Deleted the T1 COR volume")
if convert_brain:
shutil.rmtree(brain_dir)
logger.info("Deleted the brain COR volume")
shutil.rmtree(flash5_dir)
logger.info("Deleted the flash5 COR volume")
# Create symbolic links to the .surf files in the bem folder
logger.info("\n---- Creating symbolic links ----")
# os.chdir(bem_dir)
for surf in surfs:
surf = op.join(bem_dir, surf + '.surf')
if not overwrite and op.exists(surf):
skip_symlink = True
else:
if op.exists(surf):
os.remove(surf)
_symlink(op.join(flash_bem_dir, op.basename(surf)), surf, copy)
skip_symlink = False
if skip_symlink:
logger.info("Unable to create all symbolic links to .surf files "
"in bem folder. Use --overwrite option to recreate them.")
dest = op.join(bem_dir, 'flash')
else:
logger.info("Symbolic links to .surf files created in bem folder")
dest = bem_dir
logger.info("\nThank you for waiting.\nThe BEM triangulations for this "
"subject are now available at:\n%s.\nWe hope the BEM meshes "
"created will facilitate your MEG and EEG data analyses."
% dest)
# Show computed BEM surfaces
if show:
plot_bem(subject=subject, subjects_dir=subjects_dir,
orientation='coronal', slices=None, show=True)
def _check_bem_size(surfs):
"""Check bem surface sizes."""
if len(surfs) > 1 and surfs[0]['np'] > 10000:
warn('The bem surfaces have %s data points. 5120 (ico grade=4) '
'should be enough. Dense 3-layer bems may not save properly.' %
surfs[0]['np'])
def _symlink(src, dest, copy=False):
"""Create a relative symlink (or just copy)."""
if not copy:
src_link = op.relpath(src, op.dirname(dest))
try:
os.symlink(src_link, dest)
except OSError:
warn('Could not create symbolic link %s. Check that your '
'partition handles symbolic links. The file will be copied '
'instead.' % dest)
copy = True
if copy:
shutil.copy(src, dest)
| Teekuningas/mne-python | mne/bem.py | Python | bsd-3-clause | 72,313 | [
"Mayavi"
] | bafb9561023b018f2e937c042513c4f1a6f5bde79c4fef0f8829da6f7eafdc20 |
# $Id$
#
# Copyright (C) 2003-2006 greg Landrum and Rational Discovery LLC
#
# @@ All Rights Reserved @@
# This file is part of the RDKit.
# The contents are covered by the terms of the BSD license
# which is included in the file license.txt, found at the root
# of the RDKit source tree.
#
""" Calculation of topological/topochemical descriptors.
"""
from __future__ import print_function
from rdkit import Chem
from rdkit.Chem import Graphs
from rdkit.Chem import rdchem
from rdkit.Chem import rdMolDescriptors
# FIX: remove this dependency here and below
from rdkit.Chem import pyPeriodicTable as PeriodicTable
import numpy
import math
from rdkit.ML.InfoTheory import entropy
periodicTable = rdchem.GetPeriodicTable()
_log2val = math.log(2)
def _log2(x):
return math.log(x) / _log2val
def _VertexDegrees(mat,onlyOnes=0):
""" *Internal Use Only*
this is just a row sum of the matrix... simple, neh?
"""
if not onlyOnes:
res = sum(mat)
else:
res = sum(numpy.equal(mat,1))
return res
def _NumAdjacencies(mol,dMat):
""" *Internal Use Only*
"""
res = mol.GetNumBonds()
return res
def _GetCountDict(arr):
""" *Internal Use Only*
"""
res = {}
for v in arr:
res[v] = res.get(v,0)+1
return res
def _pyHallKierAlpha(m):
""" calculate the Hall-Kier alpha value for a molecule
From equations (58) of Rev. Comp. Chem. vol 2, 367-422, (1991)
"""
alphaSum = 0.0
rC = PeriodicTable.nameTable['C'][5]
for atom in m.GetAtoms():
atNum=atom.GetAtomicNum()
if not atNum: continue
symb = atom.GetSymbol()
alphaV = PeriodicTable.hallKierAlphas.get(symb,None)
if alphaV is not None:
hyb = atom.GetHybridization()-2
if(hyb<len(alphaV)):
alpha = alphaV[hyb]
if alpha is None:
alpha = alphaV[-1]
else:
alpha = alphaV[-1]
else:
rA = PeriodicTable.nameTable[symb][5]
alpha = rA/rC - 1
print(atom.GetIdx(),atom.GetSymbol(),alpha)
alphaSum += alpha
return alphaSum
#HallKierAlpha.version="1.0.2"
def Ipc(mol, avg = 0, dMat = None, forceDMat = 0):
"""This returns the information content of the coefficients of the characteristic
polynomial of the adjacency matrix of a hydrogen-suppressed graph of a molecule.
'avg = 1' returns the information content divided by the total population.
From D. Bonchev & N. Trinajstic, J. Chem. Phys. vol 67, 4517-4533 (1977)
"""
if forceDMat or dMat is None:
if forceDMat:
dMat = Chem.GetDistanceMatrix(mol,0)
mol._adjMat = dMat
else:
try:
dMat = mol._adjMat
except AttributeError:
dMat = Chem.GetDistanceMatrix(mol,0)
mol._adjMat = dMat
adjMat = numpy.equal(dMat,1)
cPoly = abs(Graphs.CharacteristicPolynomial(mol, adjMat))
if avg:
return entropy.InfoEntropy(cPoly)
else:
return sum(cPoly)*entropy.InfoEntropy(cPoly)
Ipc.version="1.0.0"
def _pyKappa1(mol):
""" Hall-Kier Kappa1 value
From equations (58) and (59) of Rev. Comp. Chem. vol 2, 367-422, (1991)
"""
P1 = mol.GetNumBonds(1)
A = mol.GetNumHeavyAtoms()
alpha = HallKierAlpha(mol)
denom = P1 + alpha
if denom:
kappa = (A + alpha)*(A + alpha - 1)**2 / denom**2
else:
kappa = 0.0
return kappa
#Kappa1.version="1.0.0"
def _pyKappa2(mol):
""" Hall-Kier Kappa2 value
From equations (58) and (60) of Rev. Comp. Chem. vol 2, 367-422, (1991)
"""
P2 = len(Chem.FindAllPathsOfLengthN(mol,2))
A = mol.GetNumHeavyAtoms()
alpha = HallKierAlpha(mol)
denom = (P2 + alpha)**2
if denom:
kappa = (A + alpha - 1)*(A + alpha - 2)**2 / denom
else:
kappa = 0
return kappa
#Kappa2.version="1.0.0"
def _pyKappa3(mol):
""" Hall-Kier Kappa3 value
From equations (58), (61) and (62) of Rev. Comp. Chem. vol 2, 367-422, (1991)
"""
P3 = len(Chem.FindAllPathsOfLengthN(mol,3))
A = mol.GetNumHeavyAtoms()
alpha = HallKierAlpha(mol)
denom = (P3 + alpha)**2
if denom:
if A % 2 == 1:
kappa = (A + alpha - 1)*(A + alpha - 3)**2 / denom
else:
kappa = (A + alpha - 2)*(A + alpha - 3)**2 / denom
else:
kappa = 0
return kappa
#Kappa3.version="1.0.0"
HallKierAlpha = lambda x:rdMolDescriptors.CalcHallKierAlpha(x)
HallKierAlpha.version=rdMolDescriptors._CalcHallKierAlpha_version
Kappa1 = lambda x:rdMolDescriptors.CalcKappa1(x)
Kappa1.version=rdMolDescriptors._CalcKappa1_version
Kappa2 = lambda x:rdMolDescriptors.CalcKappa2(x)
Kappa2.version=rdMolDescriptors._CalcKappa2_version
Kappa3 = lambda x:rdMolDescriptors.CalcKappa3(x)
Kappa3.version=rdMolDescriptors._CalcKappa3_version
def Chi0(mol):
""" From equations (1),(9) and (10) of Rev. Comp. Chem. vol 2, 367-422, (1991)
"""
deltas = [x.GetDegree() for x in mol.GetAtoms()]
while 0 in deltas:
deltas.remove(0)
deltas = numpy.array(deltas,'d')
res = sum(numpy.sqrt(1./deltas))
return res
Chi0.version="1.0.0"
def Chi1(mol):
""" From equations (1),(11) and (12) of Rev. Comp. Chem. vol 2, 367-422, (1991)
"""
c1s = [x.GetBeginAtom().GetDegree()*x.GetEndAtom().GetDegree() for x in mol.GetBonds()]
while 0 in c1s:
c1s.remove(0)
c1s = numpy.array(c1s,'d')
res = sum(numpy.sqrt(1./c1s))
return res
Chi1.version="1.0.0"
def _nVal(atom):
return periodicTable.GetNOuterElecs(atom.GetAtomicNum())-atom.GetTotalNumHs()
def _hkDeltas(mol,skipHs=1):
global periodicTable
res = []
if hasattr(mol,'_hkDeltas') and mol._hkDeltas is not None:
return mol._hkDeltas
for atom in mol.GetAtoms():
n = atom.GetAtomicNum()
if n>1:
nV = periodicTable.GetNOuterElecs(n)
nHs = atom.GetTotalNumHs()
if n <= 10:
# first row
res.append(float(nV-nHs))
else:
# second row and up
res.append(float(nV-nHs)/float(n-nV-1))
elif n==1:
if not skipHs:
res.append(0.0)
else:
res.append(0.0)
mol._hkDeltas = res
return res
def _pyChi0v(mol):
""" From equations (5),(9) and (10) of Rev. Comp. Chem. vol 2, 367-422, (1991)
"""
deltas = _hkDeltas(mol)
while 0 in deltas:
deltas.remove(0)
mol._hkDeltas=None
res = sum(numpy.sqrt(1./numpy.array(deltas)))
return res
def _pyChi1v(mol):
""" From equations (5),(11) and (12) of Rev. Comp. Chem. vol 2, 367-422, (1991)
"""
deltas = numpy.array(_hkDeltas(mol,skipHs=0))
res = 0.0
for bond in mol.GetBonds():
v = deltas[bond.GetBeginAtomIdx()]*deltas[bond.GetEndAtomIdx()]
if v != 0.0:
res += numpy.sqrt(1./v)
return res
def _pyChiNv_(mol,order=2):
""" From equations (5),(15) and (16) of Rev. Comp. Chem. vol 2, 367-422, (1991)
**NOTE**: because the current path finding code does, by design,
detect rings as paths (e.g. in C1CC1 there is *1* atom path of
length 3), values of ChiNv with N >= 3 may give results that differ
from those provided by the old code in molecules that have rings of
size 3.
"""
deltas = numpy.array([(1. / numpy.sqrt(hkd) if hkd!=0.0 else 0.0) for hkd in _hkDeltas(mol, skipHs=0)])
accum = 0.0
for path in Chem.FindAllPathsOfLengthN(mol, order + 1, useBonds=0):
accum += numpy.prod(deltas[numpy.array(path)])
return accum
def _pyChi2v(mol):
""" From equations (5),(15) and (16) of Rev. Comp. Chem. vol 2, 367-422, (1991)
"""
return _pyChiNv_(mol,2)
def _pyChi3v(mol):
""" From equations (5),(15) and (16) of Rev. Comp. Chem. vol 2, 367-422, (1991)
"""
return _pyChiNv_(mol,3)
def _pyChi4v(mol):
""" From equations (5),(15) and (16) of Rev. Comp. Chem. vol 2, 367-422, (1991)
**NOTE**: because the current path finding code does, by design,
detect rings as paths (e.g. in C1CC1 there is *1* atom path of
length 3), values of Chi4v may give results that differ from those
provided by the old code in molecules that have 3 rings.
"""
return _pyChiNv_(mol,4)
def _pyChi0n(mol):
""" Similar to Hall Kier Chi0v, but uses nVal instead of valence
This makes a big difference after we get out of the first row.
"""
deltas = [_nVal(x) for x in mol.GetAtoms()]
while deltas.count(0):
deltas.remove(0)
deltas = numpy.array(deltas,'d')
res = sum(numpy.sqrt(1./deltas))
return res
def _pyChi1n(mol):
""" Similar to Hall Kier Chi1v, but uses nVal instead of valence
"""
delts = numpy.array([_nVal(x) for x in mol.GetAtoms()],'d')
res = 0.0
for bond in mol.GetBonds():
v = delts[bond.GetBeginAtomIdx()]*delts[bond.GetEndAtomIdx()]
if v != 0.0:
res += numpy.sqrt(1./v)
return res
def _pyChiNn_(mol,order=2):
""" Similar to Hall Kier ChiNv, but uses nVal instead of valence
This makes a big difference after we get out of the first row.
**NOTE**: because the current path finding code does, by design,
detect rings as paths (e.g. in C1CC1 there is *1* atom path of
length 3), values of ChiNn with N >= 3 may give results that differ
from those provided by the old code in molecules that have rings of
size 3.
"""
nval = [_nVal(x) for x in mol.GetAtoms()]
deltas = numpy.array([(1. / numpy.sqrt(x) if x else 0.0) for x in nval])
accum = 0.0
for path in Chem.FindAllPathsOfLengthN(mol,order+1,useBonds=0):
accum += numpy.prod(deltas[numpy.array(path)])
return accum
def _pyChi2n(mol):
""" Similar to Hall Kier Chi2v, but uses nVal instead of valence
This makes a big difference after we get out of the first row.
"""
return _pyChiNn_(mol,2)
def _pyChi3n(mol):
""" Similar to Hall Kier Chi3v, but uses nVal instead of valence
This makes a big difference after we get out of the first row.
"""
return _pyChiNn_(mol,3)
def _pyChi4n(mol):
""" Similar to Hall Kier Chi4v, but uses nVal instead of valence
This makes a big difference after we get out of the first row.
**NOTE**: because the current path finding code does, by design,
detect rings as paths (e.g. in C1CC1 there is *1* atom path of
length 3), values of Chi4n may give results that differ from those
provided by the old code in molecules that have 3 rings.
"""
return _pyChiNn_(mol,4)
Chi0v = lambda x:rdMolDescriptors.CalcChi0v(x)
Chi0v.version=rdMolDescriptors._CalcChi0v_version
Chi1v = lambda x:rdMolDescriptors.CalcChi1v(x)
Chi1v.version=rdMolDescriptors._CalcChi1v_version
Chi2v = lambda x:rdMolDescriptors.CalcChi2v(x)
Chi2v.version=rdMolDescriptors._CalcChi2v_version
Chi3v = lambda x:rdMolDescriptors.CalcChi3v(x)
Chi3v.version=rdMolDescriptors._CalcChi3v_version
Chi4v = lambda x:rdMolDescriptors.CalcChi4v(x)
Chi4v.version=rdMolDescriptors._CalcChi4v_version
ChiNv_ = lambda x,y:rdMolDescriptors.CalcChiNv(x,y)
ChiNv_.version=rdMolDescriptors._CalcChiNv_version
Chi0n = lambda x:rdMolDescriptors.CalcChi0n(x)
Chi0n.version=rdMolDescriptors._CalcChi0n_version
Chi1n = lambda x:rdMolDescriptors.CalcChi1n(x)
Chi1n.version=rdMolDescriptors._CalcChi1n_version
Chi2n = lambda x:rdMolDescriptors.CalcChi2n(x)
Chi2n.version=rdMolDescriptors._CalcChi2n_version
Chi3n = lambda x:rdMolDescriptors.CalcChi3n(x)
Chi3n.version=rdMolDescriptors._CalcChi3n_version
Chi4n = lambda x:rdMolDescriptors.CalcChi4n(x)
Chi4n.version=rdMolDescriptors._CalcChi4n_version
ChiNn_ = lambda x,y:rdMolDescriptors.CalcChiNn(x,y)
ChiNn_.version=rdMolDescriptors._CalcChiNn_version
def BalabanJ(mol,dMat=None,forceDMat=0):
""" Calculate Balaban's J value for a molecule
**Arguments**
- mol: a molecule
- dMat: (optional) a distance/adjacency matrix for the molecule, if this
is not provide, one will be calculated
- forceDMat: (optional) if this is set, the distance/adjacency matrix
will be recalculated regardless of whether or not _dMat_ is provided
or the molecule already has one
**Returns**
- a float containing the J value
We follow the notation of Balaban's paper:
Chem. Phys. Lett. vol 89, 399-404, (1982)
"""
# if no dMat is passed in, calculate one ourselves
if forceDMat or dMat is None:
if forceDMat:
# FIX: should we be using atom weights here or not?
dMat = Chem.GetDistanceMatrix(mol,useBO=1,useAtomWts=0,force=1)
mol._balabanMat = dMat
adjMat = Chem.GetAdjacencyMatrix(mol,useBO=0,emptyVal=0,force=0,prefix="NoBO")
mol._adjMat = adjMat
else:
try:
# first check if the molecule already has one
dMat = mol._balabanMat
except AttributeError:
# nope, gotta calculate one
dMat = Chem.GetDistanceMatrix(mol,useBO=1,useAtomWts=0,force=0,prefix="Balaban")
# now store it
mol._balabanMat = dMat
try:
adjMat = mol._adjMat
except AttributeError:
adjMat = Chem.GetAdjacencyMatrix(mol,useBO=0,emptyVal=0,force=0,prefix="NoBO")
mol._adjMat = adjMat
else:
adjMat = Chem.GetAdjacencyMatrix(mol,useBO=0,emptyVal=0,force=0,prefix="NoBO")
s = _VertexDegrees(dMat)
q = _NumAdjacencies(mol,dMat)
n = mol.GetNumAtoms()
mu = q - n + 1
sum = 0.
nS = len(s)
for i in range(nS):
si = s[i]
for j in range(i,nS):
if adjMat[i,j] == 1:
sum += 1./numpy.sqrt(si*s[j])
if mu+1 != 0:
J = float(q) / float(mu + 1) * sum
else:
J = 0
return J
BalabanJ.version="1.0.0"
#------------------------------------------------------------------------
#
# Start block of BertzCT stuff.
#
def _AssignSymmetryClasses(mol, vdList, bdMat, forceBDMat, numAtoms, cutoff):
"""
Used by BertzCT
vdList: the number of neighbors each atom has
bdMat: "balaban" distance matrix
"""
if forceBDMat:
bdMat = Chem.GetDistanceMatrix(mol,useBO=1,useAtomWts=0,force=1,
prefix="Balaban")
mol._balabanMat = bdMat
atomIdx = 0
keysSeen = []
symList = [0]*numAtoms
for i in range(numAtoms):
tmpList = bdMat[i].tolist()
tmpList.sort()
theKey = tuple(['%.4f'%x for x in tmpList[:cutoff]])
try:
idx = keysSeen.index(theKey)
except ValueError:
idx = len(keysSeen)
keysSeen.append(theKey)
symList[i] = idx+1
return tuple(symList)
def _LookUpBondOrder(atom1Id, atom2Id, bondDic):
"""
Used by BertzCT
"""
if atom1Id < atom2Id:
theKey = (atom1Id,atom2Id)
else:
theKey = (atom2Id,atom1Id)
tmp = bondDic[theKey]
if tmp == Chem.BondType.AROMATIC:
tmp = 1.5
else:
tmp = float(tmp)
#tmp = int(tmp)
return tmp
def _CalculateEntropies(connectionDict, atomTypeDict, numAtoms):
"""
Used by BertzCT
"""
connectionList = list(connectionDict.values())
totConnections = sum(connectionList)
connectionIE = totConnections*(entropy.InfoEntropy(numpy.array(connectionList)) +
math.log(totConnections)/_log2val)
atomTypeList = list(atomTypeDict.values())
atomTypeIE = numAtoms*entropy.InfoEntropy(numpy.array(atomTypeList))
return atomTypeIE + connectionIE
def _CreateBondDictEtc(mol, numAtoms):
""" _Internal Use Only_
Used by BertzCT
"""
bondDict = {}
nList = [None]*numAtoms
vdList = [0]*numAtoms
for aBond in mol.GetBonds():
atom1=aBond.GetBeginAtomIdx()
atom2=aBond.GetEndAtomIdx()
if atom1>atom2: atom2,atom1=atom1,atom2
if not aBond.GetIsAromatic():
bondDict[(atom1,atom2)] = aBond.GetBondType()
else:
# mark Kekulized systems as aromatic
bondDict[(atom1,atom2)] = Chem.BondType.AROMATIC
if nList[atom1] is None:
nList[atom1] = [atom2]
elif atom2 not in nList[atom1]:
nList[atom1].append(atom2)
if nList[atom2] is None:
nList[atom2] = [atom1]
elif atom1 not in nList[atom2]:
nList[atom2].append(atom1)
for i,element in enumerate(nList):
try:
element.sort()
vdList[i] = len(element)
except:
vdList[i] = 0
return bondDict, nList, vdList
def BertzCT(mol, cutoff = 100, dMat = None, forceDMat = 1):
""" A topological index meant to quantify "complexity" of molecules.
Consists of a sum of two terms, one representing the complexity
of the bonding, the other representing the complexity of the
distribution of heteroatoms.
From S. H. Bertz, J. Am. Chem. Soc., vol 103, 3599-3601 (1981)
"cutoff" is an integer value used to limit the computational
expense. A cutoff value tells the program to consider vertices
topologically identical if their distance vectors (sets of
distances to all other vertices) are equal out to the "cutoff"th
nearest-neighbor.
**NOTE** The original implementation had the following comment:
> this implementation treats aromatic rings as the
> corresponding Kekule structure with alternating bonds,
> for purposes of counting "connections".
Upon further thought, this is the WRONG thing to do. It
results in the possibility of a molecule giving two different
CT values depending on the kekulization. For example, in the
old implementation, these two SMILES:
CC2=CN=C1C3=C(C(C)=C(C=N3)C)C=CC1=C2C
CC3=CN=C2C1=NC=C(C)C(C)=C1C=CC2=C3C
which correspond to differentk kekule forms, yield different
values.
The new implementation uses consistent (aromatic) bond orders
for aromatic bonds.
THIS MEANS THAT THIS IMPLEMENTATION IS NOT BACKWARDS COMPATIBLE.
Any molecule containing aromatic rings will yield different
values with this implementation. The new behavior is the correct
one, so we're going to live with the breakage.
**NOTE** this barfs if the molecule contains a second (or
nth) fragment that is one atom.
"""
atomTypeDict = {}
connectionDict = {}
numAtoms = mol.GetNumAtoms()
if forceDMat or dMat is None:
if forceDMat:
# nope, gotta calculate one
dMat = Chem.GetDistanceMatrix(mol,useBO=0,useAtomWts=0,force=1)
mol._adjMat = dMat
else:
try:
dMat = mol._adjMat
except AttributeError:
dMat = Chem.GetDistanceMatrix(mol,useBO=0,useAtomWts=0,force=1)
mol._adjMat = dMat
if numAtoms < 2:
return 0
bondDict, neighborList, vdList = _CreateBondDictEtc(mol, numAtoms)
symmetryClasses = _AssignSymmetryClasses(mol, vdList, dMat, forceDMat, numAtoms, cutoff)
#print('Symmm Classes:',symmetryClasses)
for atomIdx in range(numAtoms):
hingeAtomNumber = mol.GetAtomWithIdx(atomIdx).GetAtomicNum()
atomTypeDict[hingeAtomNumber] = atomTypeDict.get(hingeAtomNumber,0)+1
hingeAtomClass = symmetryClasses[atomIdx]
numNeighbors = vdList[atomIdx]
for i in range(numNeighbors):
neighbor_iIdx = neighborList[atomIdx][i]
NiClass = symmetryClasses[neighbor_iIdx]
bond_i_order = _LookUpBondOrder(atomIdx, neighbor_iIdx, bondDict)
#print('\t',atomIdx,i,hingeAtomClass,NiClass,bond_i_order)
if (bond_i_order > 1) and (neighbor_iIdx > atomIdx):
numConnections = bond_i_order*(bond_i_order - 1)/2
connectionKey = (min(hingeAtomClass, NiClass), max(hingeAtomClass, NiClass))
connectionDict[connectionKey] = connectionDict.get(connectionKey,0)+numConnections
for j in range(i+1, numNeighbors):
neighbor_jIdx = neighborList[atomIdx][j]
NjClass = symmetryClasses[neighbor_jIdx]
bond_j_order = _LookUpBondOrder(atomIdx, neighbor_jIdx, bondDict)
numConnections = bond_i_order*bond_j_order
connectionKey = (min(NiClass, NjClass), hingeAtomClass, max(NiClass, NjClass))
connectionDict[connectionKey] = connectionDict.get(connectionKey,0)+numConnections
if not connectionDict:
connectionDict = {'a':1}
return _CalculateEntropies(connectionDict, atomTypeDict, numAtoms)
BertzCT.version="2.0.0"
# Recent Revisions:
# 1.0.0 -> 2.0.0:
# - force distance matrix updates properly (Fixed as part of Issue 125)
# - handle single-atom fragments (Issue 136)
#
# End block of BertzCT stuff.
#
#------------------------------------------------------------------------
| strets123/rdkit | rdkit/Chem/GraphDescriptors.py | Python | bsd-3-clause | 19,941 | [
"RDKit"
] | c39d1b65332392fd4996cf34112b67778b8d4d92abc7dda1a772b23116f4a94c |
# Copyright (C) 2010-2019 The ESPResSo project
#
# This file is part of ESPResSo.
#
# ESPResSo is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# ESPResSo is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from .__init__ import has_features
from .script_interface import ScriptInterfaceHelper, script_interface_register
if has_features("VIRTUAL_SITES"):
@script_interface_register
class ActiveVirtualSitesHandle(ScriptInterfaceHelper):
"""Handle for the virtual sites implementation active in the core
This should not be used directly.
Attributes
----------
implementation :
instance of a virtual sites implementation
"""
_so_name = "VirtualSites::ActiveVirtualSitesHandle"
@script_interface_register
class VirtualSitesOff(ScriptInterfaceHelper):
"""Virtual sites implementation which does nothing (default)"""
_so_name = "VirtualSites::VirtualSitesOff"
if has_features("VIRTUAL_SITES_INERTIALESS_TRACERS"):
@script_interface_register
class VirtualSitesInertialessTracers(ScriptInterfaceHelper):
"""Virtual sites which are advected with an lb fluid without inertia.
Forces are on them are transferred to the fluid instantly.
"""
_so_name = "VirtualSites::VirtualSitesInertialessTracers"
if has_features("VIRTUAL_SITES_RELATIVE"):
@script_interface_register
class VirtualSitesRelative(ScriptInterfaceHelper):
"""Virtual sites implementation placing virtual sites relative to other
particles. See :ref:`Rigid arrangements of particles` for details.
"""
_so_name = "VirtualSites::VirtualSitesRelative"
| KaiSzuttor/espresso | src/python/espressomd/virtual_sites.py | Python | gpl-3.0 | 2,198 | [
"ESPResSo"
] | 6aa58789d0a8b62bfd73906a81d77f47a0d95b63a0272c9e56b51fc18dccf64a |
# vim: ts=4 sw=4 expandtab
""" This is an abstract module for visiting specific nodes. This is useed to
traverse the tree to generate warnings.
"""
def visit(event, *args):
""" This decorator is used to indicate which nodes the function should
examine. The function should accept (self, node) and return the relevant
node or None. """
def _decorate(fn):
fn._visit_event = event
fn._visit_nodes = args
return fn
return _decorate
def make_visitors(visitors, klasses):
""" Searches klasses for all member functions decorated with @visit and
fills a dictionary that looks like:
visitors = {
'event_name': {
'node_type' : [func1, func2]
}
}
"""
assert isinstance(visitors, dict)
# Intantiate an instance of each class
for klass in klasses:
if klass.__name__.lower() != klass.__name__:
raise ValueError, 'class names must be lowercase'
if not klass.__doc__:
raise ValueError, 'missing docstring on class %s' % klass.__name__
# Look for functions with the "_visit_nodes" property.
visitor = klass()
for func in [getattr(visitor, name) for name in dir(visitor)]:
event_visitors = None
for node_kind in getattr(func, '_visit_nodes', ()):
# Group visitors by event (e.g. push vs pop)
if not event_visitors:
try:
event_visitors = visitors[func._visit_event]
except KeyError:
event_visitors = visitors[func._visit_event] = {}
# Map from node_kind to the function
try:
event_visitors[node_kind].append(func)
except KeyError:
event_visitors[node_kind] = [func]
return visitors
| hackathon-2014/laserspacecats-repo | toot-node/node_modules/restify/node_modules/verror/node_modules/extsprintf/deps/javascriptlint/javascriptlint/visitation.py | Python | gpl-2.0 | 1,893 | [
"VisIt"
] | 2ec0f972a5ed86c45da856e6e346a887e304d8a32ad988b38d25c45ab9f838fd |
""" Utility functions for processing point clouds.
Author: Charles R. Qi, Hao Su
Date: November 2016
"""
import os
import sys
import warnings
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
sys.path.append(BASE_DIR)
# Draw point cloud
from eulerangles import euler2mat
# Point cloud IO
import numpy as np
from plyfile import PlyData, PlyElement
# ----------------------------------------
# Point Cloud/Volume Conversions
# ----------------------------------------
def point_cloud_to_volume_batch(point_clouds, vsize=12, radius=1.0, flatten=True):
""" Input is BxNx3 batch of point cloud
Output is Bx(vsize^3)
"""
vol_list = []
for b in range(point_clouds.shape[0]):
vol = point_cloud_to_volume(np.squeeze(point_clouds[b,:,:]), vsize, radius)
if flatten:
vol_list.append(vol.flatten())
else:
vol_list.append(np.expand_dims(np.expand_dims(vol, -1), 0))
if flatten:
return np.vstack(vol_list)
else:
return np.concatenate(vol_list, 0)
def point_cloud_to_volume(points, vsize, radius=1.0):
""" input is Nx3 points.
output is vsize*vsize*vsize
assumes points are in range [-radius, radius]
"""
vol = np.zeros((vsize,vsize,vsize))
voxel = 2*radius/float(vsize)
locations = (points + radius)/voxel
locations = locations.astype(int)
vol[locations[:,0],locations[:,1],locations[:,2]] = 1.0
return vol
#a = np.zeros((16,1024,3))
#print point_cloud_to_volume_batch(a, 12, 1.0, False).shape
def volume_to_point_cloud(vol):
""" vol is occupancy grid (value = 0 or 1) of size vsize*vsize*vsize
return Nx3 numpy array.
"""
vsize = vol.shape[0]
assert(vol.shape[1] == vsize and vol.shape[1] == vsize)
points = []
for a in range(vsize):
for b in range(vsize):
for c in range(vsize):
if vol[a,b,c] == 1:
points.append(np.array([a,b,c]))
if len(points) == 0:
return np.zeros((0,3))
points = np.vstack(points)
return points
def point_cloud_to_volume_v2_batch(point_clouds, vsize=12, radius=1.0, num_sample=128):
""" Input is BxNx3 a batch of point cloud
Output is BxVxVxVxnum_samplex3
Added on Feb 19
"""
vol_list = []
for b in range(point_clouds.shape[0]):
vol = point_cloud_to_volume_v2(point_clouds[b,:,:], vsize, radius, num_sample)
vol_list.append(np.expand_dims(vol, 0))
return np.concatenate(vol_list, 0)
def point_cloud_to_volume_v2(points, vsize, radius=1.0, num_sample=128):
""" input is Nx3 points
output is vsize*vsize*vsize*num_sample*3
assumes points are in range [-radius, radius]
samples num_sample points in each voxel, if there are less than
num_sample points, replicate the points
Added on Feb 19
"""
vol = np.zeros((vsize,vsize,vsize,num_sample,3))
voxel = 2*radius/float(vsize)
locations = (points + radius)/voxel
locations = locations.astype(int)
loc2pc = {}
for n in range(points.shape[0]):
loc = tuple(locations[n,:])
if loc not in loc2pc:
loc2pc[loc] = []
loc2pc[loc].append(points[n,:])
#print loc2pc
for i in range(vsize):
for j in range(vsize):
for k in range(vsize):
if (i,j,k) not in loc2pc:
vol[i,j,k,:,:] = np.zeros((num_sample,3))
else:
pc = loc2pc[(i,j,k)] # a list of (3,) arrays
pc = np.vstack(pc) # kx3
# Sample/pad to num_sample points
if pc.shape[0]>num_sample:
choices = np.random.choice(pc.shape[0], num_sample, replace=False)
pc = pc[choices,:]
elif pc.shape[0]<num_sample:
pc = np.lib.pad(pc, ((0,num_sample-pc.shape[0]),(0,0)), 'edge')
# Normalize
pc_center = (np.array([i,j,k])+0.5)*voxel - radius
#print 'pc center: ', pc_center
pc = (pc - pc_center) / voxel # shift and scale
vol[i,j,k,:,:] = pc
#print (i,j,k), vol[i,j,k,:,:]
return vol
def point_cloud_to_image_batch(point_clouds, imgsize, radius=1.0, num_sample=128):
""" Input is BxNx3 a batch of point cloud
Output is BxIxIxnum_samplex3
Added on Feb 19
"""
img_list = []
for b in range(point_clouds.shape[0]):
img = point_cloud_to_image(point_clouds[b,:,:], imgsize, radius, num_sample)
img_list.append(np.expand_dims(img, 0))
return np.concatenate(img_list, 0)
def point_cloud_to_image(points, imgsize, radius=1.0, num_sample=128):
""" input is Nx3 points
output is imgsize*imgsize*num_sample*3
assumes points are in range [-radius, radius]
samples num_sample points in each pixel, if there are less than
num_sample points, replicate the points
Added on Feb 19
"""
img = np.zeros((imgsize, imgsize, num_sample, 3))
pixel = 2*radius/float(imgsize)
locations = (points[:,0:2] + radius)/pixel # Nx2
locations = locations.astype(int)
loc2pc = {}
for n in range(points.shape[0]):
loc = tuple(locations[n,:])
if loc not in loc2pc:
loc2pc[loc] = []
loc2pc[loc].append(points[n,:])
for i in range(imgsize):
for j in range(imgsize):
if (i,j) not in loc2pc:
img[i,j,:,:] = np.zeros((num_sample,3))
else:
pc = loc2pc[(i,j)]
pc = np.vstack(pc)
if pc.shape[0]>num_sample:
choices = np.random.choice(pc.shape[0], num_sample, replace=False)
pc = pc[choices,:]
elif pc.shape[0]<num_sample:
pc = np.lib.pad(pc, ((0,num_sample-pc.shape[0]),(0,0)), 'edge')
pc_center = (np.array([i,j])+0.5)*pixel - radius
pc[:,0:2] = (pc[:,0:2] - pc_center)/pixel
img[i,j,:,:] = pc
return img
def surface_normal_area(face, vertex):
normals = list()
areas = list()
vertex_to_face = [[] for i in range(len(vertex))]
for fid, f in enumerate(face):
f = f[0]
va, vb, vc = f[0], f[1], f[2]
vertex_to_face[va].append(fid)
vertex_to_face[vb].append(fid)
vertex_to_face[vc].append(fid)
a = vertex[vb] - vertex[va]
b = vertex[vc] - vertex[va]
normal = np.cross(a, b)
area = np.dot(normal, normal) / 2.0
normalized_normal = normal / np.linalg.norm(normal)
normals.append(normalized_normal)
areas.append(area)
return np.array(normals), np.array(areas), vertex_to_face
def vertex_normal(vertex_to_face, normal, areas):
vertex_normals = list()
num_vertex = len(vertex_to_face)
for vid in range(num_vertex):
adj_faces = vertex_to_face[vid]
if len(adj_faces)==0: # single point with no adjancy points
vertex_normals.append([0,0,1])
continue
adj_faces_area = np.expand_dims(np.array(areas[adj_faces]), axis=-1)
adj_faces_normal = np.array(normal[adj_faces])
avg_normal = (adj_faces_normal * adj_faces_area) / np.sum(adj_faces_area)
avg_normal = np.sum(avg_normal, axis=0)
normalized_normal = avg_normal / np.linalg.norm(avg_normal)
#if np.isclose(np.linalg.norm(avg_normal), 0.0):
# print('-------------------')
# print(len(adj_faces))
# print('-------------------')
# print('-------------------')
# print(adj_faces_area.shape, adj_faces_normal.shape, adj_faces_area, adj_faces_normal)
# print(adj_faces_normal * adj_faces_area)
# print(np.sum(adj_faces_area))
# print((adj_faces_normal * adj_faces_area) / np.sum(adj_faces_area))
# print(avg_normal, np.linalg.norm(avg_normal), adj_faces_area, adj_faces_normal)
# print('-------------------')
vertex_normals.append(normalized_normal)
return np.array(vertex_normals)
# ----------------------------------------
# Point cloud IO
# ----------------------------------------
def read_ply(filename):
""" read XYZ point cloud from filename PLY file """
plydata = PlyData.read(filename)
pc = plydata['vertex'].data
pc_array = np.array([[x, y, z] for x,y,z in pc])
return pc_array
def read_ply_rgba(filename):
""" read XYZRGBA point cloud from filename PLY file """
plydata = PlyData.read(filename)
pc = plydata['vertex'].data
pc_array = np.array([[x, y, z,r,g,b,a] for x,y,z,r,g,b,a in pc])
return pc_array
def read_ply_rgba_normal(filename):
""" read XYZRGBA and NxNyNz point cloud from filename PLY file """
plydata = PlyData.read(filename)
pc = plydata['vertex'].data
pc_array = np.array([[x, y, z,r,g,b,a] for x,y,z,r,g,b,a in pc])
face = plydata['face'].data
f_n, f_a, v_f = surface_normal_area(face, pc_array[:, 0:3])
v_n = vertex_normal(v_f, f_n, f_a)
pc_array = np.concatenate((pc_array, v_n), axis=-1)
return pc_array
def write_ply(points, filename, text=True):
""" input: Nx3, write points to filename as PLY format. """
points = [(points[i,0], points[i,1], points[i,2]) for i in range(points.shape[0])]
vertex = np.array(points, dtype=[('x', 'f4'), ('y', 'f4'),('z', 'f4')])
el = PlyElement.describe(vertex, 'vertex', comments=['vertices'])
PlyData([el], text=text).write(filename)
def write_ply_rgb(points, colors, filename, text=True):
""" input: Nx3, Nx3 write points and colors to filename as PLY format. """
num_points = len(points)
assert len(colors) == num_points
points = [(points[i,0], points[i,1], points[i,2]) for i in range(points.shape[0])]
colors = [(colors[i,0], colors[i,1], colors[i,2]) for i in range(colors.shape[0])]
vertex = np.array(points, dtype=[('x', 'f4'), ('y', 'f4'),('z', 'f4')])
color = np.array(colors, dtype=[('red', 'u1'), ('green', 'u1'),('blue', 'u1')])
vertex_all = np.empty(num_points, vertex.dtype.descr + color.dtype.descr)
for prop in vertex.dtype.names:
vertex_all[prop] = vertex[prop]
for prop in color.dtype.names:
vertex_all[prop] = color[prop]
el = PlyElement.describe(vertex_all, 'vertex', comments=['vertices'])
PlyData([el], text=text).write(filename)
def write_ply_rgb_normal(points, colors, normals, filename, text=True):
""" input: Nx3, Nx3, Nx3 write points and colors to filename as PLY format. """
num_points = len(points)
assert len(colors) == num_points
points = [(points[i,0], points[i,1], points[i,2]) for i in range(points.shape[0])]
colors = [(colors[i,0], colors[i,1], colors[i,2]) for i in range(colors.shape[0])]
normals = [(normals[i,0], normals[i,1], normals[i,2]) for i in range(normals.shape[0])]
vertex = np.array(points, dtype=[('x', 'f4'), ('y', 'f4'),('z', 'f4')])
color = np.array(colors, dtype=[('red', 'u1'), ('green', 'u1'),('blue', 'u1')])
normal = np.array(normals, dtype=[('nx', 'f4'), ('ny', 'f4'),('nz', 'f4')])
vertex_all = np.empty(num_points, vertex.dtype.descr + color.dtype.descr + normal.dtype.descr)
for prop in vertex.dtype.names:
vertex_all[prop] = vertex[prop]
for prop in color.dtype.names:
vertex_all[prop] = color[prop]
for prop in normal.dtype.names:
vertex_all[prop] = normal[prop]
el = PlyElement.describe(vertex_all, 'vertex', comments=['vertices'])
PlyData([el], text=text).write(filename)
# ----------------------------------------
# Simple Point cloud and Volume Renderers
# ----------------------------------------
def draw_point_cloud(input_points, canvasSize=500, space=200, diameter=25,
xrot=0, yrot=0, zrot=0, switch_xyz=[0,1,2], normalize=True):
""" Render point cloud to image with alpha channel.
Input:
points: Nx3 numpy array (+y is up direction)
Output:
gray image as numpy array of size canvasSizexcanvasSize
"""
image = np.zeros((canvasSize, canvasSize))
if input_points is None or input_points.shape[0] == 0:
return image
points = input_points[:, switch_xyz]
M = euler2mat(zrot, yrot, xrot)
points = (np.dot(M, points.transpose())).transpose()
# Normalize the point cloud
# We normalize scale to fit points in a unit sphere
if normalize:
centroid = np.mean(points, axis=0)
points -= centroid
furthest_distance = np.max(np.sqrt(np.sum(abs(points)**2,axis=-1)))
points /= furthest_distance
# Pre-compute the Gaussian disk
radius = (diameter-1)/2.0
disk = np.zeros((diameter, diameter))
for i in range(diameter):
for j in range(diameter):
if (i - radius) * (i-radius) + (j-radius) * (j-radius) <= radius * radius:
disk[i, j] = np.exp((-(i-radius)**2 - (j-radius)**2)/(radius**2))
mask = np.argwhere(disk > 0)
dx = mask[:, 0]
dy = mask[:, 1]
dv = disk[disk > 0]
# Order points by z-buffer
zorder = np.argsort(points[:, 2])
points = points[zorder, :]
points[:, 2] = (points[:, 2] - np.min(points[:, 2])) / (np.max(points[:, 2] - np.min(points[:, 2])))
max_depth = np.max(points[:, 2])
for i in range(points.shape[0]):
j = points.shape[0] - i - 1
x = points[j, 0]
y = points[j, 1]
xc = canvasSize/2 + (x*space)
yc = canvasSize/2 + (y*space)
xc = int(np.round(xc))
yc = int(np.round(yc))
px = dx + xc
py = dy + yc
image[px, py] = image[px, py] * 0.7 + dv * (max_depth - points[j, 2]) * 0.3
image = image / np.max(image)
return image
def point_cloud_three_views(points):
""" input points Nx3 numpy array (+y is up direction).
return an numpy array gray image of size 500x1500. """
# +y is up direction
# xrot is azimuth
# yrot is in-plane
# zrot is elevation
img1 = draw_point_cloud(points, zrot=110/180.0*np.pi, xrot=45/180.0*np.pi, yrot=0/180.0*np.pi)
img2 = draw_point_cloud(points, zrot=70/180.0*np.pi, xrot=135/180.0*np.pi, yrot=0/180.0*np.pi)
img3 = draw_point_cloud(points, zrot=180.0/180.0*np.pi, xrot=90/180.0*np.pi, yrot=0/180.0*np.pi)
image_large = np.concatenate([img1, img2, img3], 1)
return image_large
def point_cloud_three_views_demo():
""" Demo for draw_point_cloud function """
from PIL import Image
points = read_ply('../third_party/mesh_sampling/piano.ply')
im_array = point_cloud_three_views(points)
img = Image.fromarray(np.uint8(im_array*255.0))
img.save('piano.jpg')
if __name__=="__main__":
point_cloud_three_views_demo()
def pyplot_draw_point_cloud(points, output_filename):
""" points is a Nx3 numpy array """
import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(points[:,0], points[:,1], points[:,2])
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('z')
#savefig(output_filename)
def pyplot_draw_volume(vol, output_filename):
""" vol is of size vsize*vsize*vsize
output an image to output_filename
"""
points = volume_to_point_cloud(vol)
pyplot_draw_point_cloud(points, output_filename)
def write_ply_color(points, labels, out_filename, num_classes=None, colors=None):
""" Color (N,3) points with labels (N) within range 0 ~ num_classes-1 as OBJ file """
import matplotlib.pyplot as pyplot
labels = labels.astype(int)
N = points.shape[0]
if num_classes is None:
num_classes = np.max(labels)+1
print(num_classes)
else:
assert(num_classes>np.max(labels))
if colors is None:
#colors = [pyplot.cm.hsv(i/float(num_classes)) for i in range(num_classes)]
colors = [pyplot.cm.jet(i/float(num_classes)) for i in range(num_classes)]
fout = open(out_filename, 'w')
for i in range(N):
c = colors[labels[i]]
fout.write('v %f %f %f %d %d %d\n' % (points[i,0],points[i,1],points[i,2],c[0],c[1],c[2]))
fout.close()
| googleinterns/deep-3d-reconstruction | scannet/utils/pc_utils.py | Python | apache-2.0 | 16,335 | [
"Gaussian"
] | 6e209d8eabb2f2d489116c0d133a8d12a021139385710c5fc362f6689f8219e4 |
# coding: utf-8
# Copyright (c) Pymatgen Development Team.
# Distributed under the terms of the MIT License.
import collections
from pymatgen.util.testing import PymatgenTest
from pymatgen.core.units import (Energy, Time, Length, unitized, Mass, Memory,
EnergyArray, TimeArray, LengthArray, Unit,
FloatWithUnit, ArrayWithUnit, UnitError)
class UnitTest(PymatgenTest):
def test_init(self):
u1 = Unit((("m", 1), ("s", -1)))
self.assertEqual(str(u1), "m s^-1")
u2 = Unit("kg m ^ 2 s ^ -2")
self.assertEqual(str(u2), "J")
self.assertEqual(str(u1 * u2), "J m s^-1")
self.assertEqual(str(u2 / u1), "J s m^-1")
self.assertEqual(str(u1 / Unit("m")), "Hz")
self.assertEqual(str(u1 * Unit("s")), "m")
acc = u1 / Unit("s")
newton = Unit("kg") * acc
self.assertEqual(str(newton * Unit("m")), "N m")
class FloatWithUnitTest(PymatgenTest):
def test_energy(self):
a = Energy(1.1, "eV")
b = a.to("Ha")
self.assertAlmostEqual(b, 0.0404242579378)
c = Energy(3.14, "J")
self.assertAlmostEqual(c.to("eV"), 1.9598338493806797e+19)
self.assertRaises(UnitError, Energy, 1, "m")
d = Energy(1, "Ha")
self.assertAlmostEqual(a + d, 28.311386245987997)
self.assertAlmostEqual(a - d, -26.111386245987994)
self.assertEqual(a + 1, 2.1)
self.assertEqual(str(a / d), "1.1 eV Ha^-1")
def test_time(self):
a = Time(20, "h")
self.assertAlmostEqual(float(a.to("s")), 3600 * 20)
# Test left and right multiplication.
b = a * 3
self.assertAlmostEqual(float(b), 60.0)
self.assertEqual(str(b.unit), "h")
self.assertEqual(float(3 * a), 60.0)
a = Time(0.5, "d")
self.assertAlmostEqual(float(a.to("s")), 3600 * 24 * 0.5)
def test_length(self):
x = Length(4.2, "ang")
self.assertAlmostEqual(x.to("cm"), 4.2e-08)
self.assertEqual(x.to("pm"), 420)
self.assertEqual(str(x / 2), "2.1 ang")
y = x ** 3
self.assertAlmostEqual(y, 74.088)
self.assertEqual(str(y.unit), "ang^3")
def test_memory(self):
mega = Memory(1, "Mb")
self.assertEqual(mega.to("byte"), 1024 ** 2)
self.assertEqual(mega, Memory(1, "mb"))
same_mega = Memory.from_string("1Mb")
self.assertEqual(same_mega.unit_type, "memory")
other_mega = Memory.from_string("+1.0 mb")
self.assertEqual(mega, other_mega)
def test_unitized(self):
@unitized("eV")
def f():
return [1, 2, 3]
self.assertEqual(str(f()[0]), "1.0 eV")
self.assertIsInstance(f(), list)
@unitized("eV")
def g():
return 2, 3, 4
self.assertEqual(str(g()[0]), "2.0 eV")
self.assertIsInstance(g(), tuple)
@unitized("pm")
def h():
d = collections.OrderedDict()
for i in range(3):
d[i] = i * 20
return d
self.assertEqual(str(h()[1]), "20.0 pm")
self.assertIsInstance(h(), collections.OrderedDict)
@unitized("kg")
def i():
return FloatWithUnit(5, "g")
self.assertEqual(i(), FloatWithUnit(0.005, "kg"))
@unitized("kg")
def j():
return ArrayWithUnit([5, 10], "g")
j_out = j()
self.assertEqual(j_out.unit, Unit("kg"))
self.assertEqual(j_out[0], 0.005)
self.assertEqual(j_out[1], 0.01)
def test_compound_operations(self):
g = 10 * Length(1, "m") / (Time(1, "s") ** 2)
e = Mass(1, "kg") * g * Length(1, "m")
self.assertEqual(str(e), "10.0 N m")
form_e = FloatWithUnit(10, unit="kJ mol^-1").to("eV atom^-1")
self.assertAlmostEqual(float(form_e), 0.103642691905)
self.assertEqual(str(form_e.unit), "eV atom^-1")
self.assertRaises(UnitError, form_e.to, "m s^-1")
a = FloatWithUnit(1.0, "Ha^3")
b = a.to("J^3")
self.assertAlmostEqual(b, 8.28672661615e-53)
self.assertEqual(str(b.unit), "J^3")
a = FloatWithUnit(1.0, "Ha bohr^-2")
b = a.to("J m^-2")
self.assertAlmostEqual(b, 1556.8931028218924)
self.assertEqual(str(b.unit), "J m^-2")
def test_as_base_units(self):
x = FloatWithUnit(5, "MPa")
self.assertEqual(FloatWithUnit(5000000, "Pa"), x.as_base_units)
class ArrayWithFloatWithUnitTest(PymatgenTest):
def test_energy(self):
"""
Similar to FloatWithUnitTest.test_energy.
Check whether EnergyArray and FloatWithUnit have same behavior.
# TODO
One can merge the two tests easily:
for obj in [Energy, EnergyArray]:
a = obj(...)
self.assert(...)
"""
a = EnergyArray(1.1, "eV")
b = a.to("Ha")
self.assertAlmostEqual(float(b), 0.0404242579378)
c = EnergyArray(3.14, "J")
self.assertAlmostEqual(float(c.to("eV")), 1.9598338493806797e+19, 5)
# self.assertRaises(ValueError, Energy, 1, "m")
d = EnergyArray(1, "Ha")
self.assertAlmostEqual(float(a + d), 28.311386245987997)
self.assertAlmostEqual(float(a - d), -26.111386245987994)
self.assertEqual(float(a + 1), 2.1)
def test_time(self):
"""
Similar to FloatWithUnitTest.test_time.
Check whether EnergyArray and FloatWithUnit have same behavior.
"""
# here there's a minor difference because we have a ndarray with
# dtype=np.int.
a = TimeArray(20, "h")
self.assertAlmostEqual(a.to("s"), 3600 * 20)
# Test left and right multiplication.
self.assertEqual(str(a * 3), "60 h")
self.assertEqual(str(3 * a), "60 h")
def test_length(self):
"""
Similar to FloatWithUnitTest.test_time.
Check whether EnergyArray and FloatWithUnit have same behavior.
"""
x = LengthArray(4.2, "ang")
self.assertAlmostEqual(float(x.to("cm")), 4.2e-08)
self.assertEqual(float(x.to("pm")), 420)
self.assertEqual(str(x / 2), "2.1 ang")
def test_array_algebra(self):
ene_ha = EnergyArray([1, 2], "Ha")
ene_ev = EnergyArray([1, 2], "eV")
time_s = TimeArray([1, 2], "s")
e1 = ene_ha.copy()
e1 += 1
e2 = ene_ha.copy()
e2 -= 1
e3 = ene_ha.copy()
# e3 /= 2
e4 = ene_ha.copy()
e4 *= 2
objects_with_unit = [
ene_ha + ene_ev,
ene_ha - ene_ev,
3 * ene_ha,
ene_ha * 3,
ene_ha / 3,
3 / ene_ha,
ene_ha * time_s,
ene_ha / ene_ev,
ene_ha.copy(),
ene_ha[0:1],
e1,
e2,
e3,
e4,
]
for i, obj in enumerate(objects_with_unit):
self.assertTrue(hasattr(obj, "unit"))
objects_without_unit = [
# Here we could return a FloatWithUnit object but I prefer this
# a bare scalar since FloatWithUnit extends float while we could
# have an int.
ene_ha[0],
]
for obj in objects_without_unit:
self.assertFalse(hasattr(obj, "unit"))
with self.assertRaises(UnitError):
ene_ha + time_s
def test_factors(self):
e = EnergyArray([27.21138386, 1], "eV").to("Ha")
self.assertTrue(str(e).endswith("Ha"))
l = LengthArray([1.0], "ang").to("bohr")
self.assertTrue(str(l).endswith(" bohr"))
v = ArrayWithUnit([1, 2, 3], "bohr^3").to("ang^3")
self.assertTrue(str(v).endswith(' ang^3'))
def test_as_base_units(self):
x = ArrayWithUnit([5, 10], "MPa")
self.assertArrayEqual(ArrayWithUnit([5000000, 10000000], "Pa"), x.as_base_units)
class DataPersistenceTest(PymatgenTest):
def test_pickle(self):
"""Test whether FloatWithUnit and ArrayWithUnit support pickle"""
for cls in [FloatWithUnit, ArrayWithUnit]:
a = cls(1, "eV")
b = cls(10, "N bohr")
objects = [a, b]
new_objects_from_protocol = self.serialize_with_pickle(objects)
for new_objects in new_objects_from_protocol:
for old_item, new_item in zip(objects, new_objects):
self.assertTrue(str(old_item) == str(new_item))
if __name__ == '__main__':
import unittest
unittest.main()
| fraricci/pymatgen | pymatgen/core/tests/test_units.py | Python | mit | 8,589 | [
"pymatgen"
] | 6dd5615e01f888af086919b2eedc26a791ab398f93e7289fa4ed32bd724831f6 |
"""
CrystFEL stream format 2.2
Reflections measured after indexing
h k l I sigma(I) peak background fs/px ss/px
-18 38 -15 -77.63 50.81 50.00 22.12 248.3 861.5
= CrystFEL stream format 2.3 =
----- Begin chunk -----
Image filename: /lfs01/iwata/nureki/2015-Apr-KEK-A/297151-0/run297151-0.h5
Event: tag-57375862//
Image serial number: 2
indexed_by = none
photon_energy_eV = 13026.000000
beam_divergence = 4.00e-04 rad
beam_bandwidth = 5.20e-03 (fraction)
hdf5/%/photon_energy_ev = 13026.000000
average_camera_length = 0.054939 m
num_peaks = 24
num_saturated_peaks = 0
Peaks from peak search
fs/px ss/px (1/d)/nm^-1 Intensity Panel
375.36 1165.47 2.02 3875.92 q2
...
End of peak list
--- Begin crystal
Cell parameters 5.79940 11.98424 14.28581 nm, 90.39531 89.16323 90.05762 deg
astar = +0.0579467 -0.1028938 +0.1256744 nm^-1
bstar = +0.0547752 -0.0339926 -0.0529833 nm^-1
cstar = +0.0472735 +0.0488341 +0.0167826 nm^-1
lattice_type = orthorhombic
centering = P
unique_axis = ?
profile_radius = 0.00429 nm^-1
predict_refine/det_shift x = 0.007 y = 0.003 mm
predict_refine/R old = 0.00356 new = 0.00429 nm^-1
diffraction_resolution_limit = 3.69 nm^-1 or 2.71 A
num_reflections = 3941
num_saturated_reflections = 0
num_implausible_reflections = 0
Reflections measured after indexing
h k l I sigma(I) peak background fs/px ss/px panel
-50 -43 -10 -2.50 17.37 11.00 1.50 490.2 5107.3 q5
...
End of reflections
--- End crystal
----- End chunk -----
"""
import re
from libtbx import adopt_init_args
from cctbx import miller
from cctbx import crystal
from cctbx.array_family import flex
import cPickle as pickle
import sys
import numpy
#import msgpack
re_abcstar = re.compile("([-\+][0-9\.]+ )([-\+][0-9\.]+ )([-\+][0-9\.]+ )")
class Chunk:
def __init__(self, read_reflections=True):
filename, event, serial = None, None, None
indexed_by = None
photon_e, beam_div, beam_bw = None, None, None
avg_clen = None
n_peaks = 0
n_sat_peaks = 0
cell = None #
astar, bstar, cstar = None, None, None
latt_type, centering, unique_axis = None, None, None
profile_radius = None
res_lim = None
det_shift = None, None
n_refl = 0
n_sat_refl = 0
n_imp_refl = 0
indices = []
iobs = []
sigma = []
peak = []
background, fs, ss, panel = [], [], [], []
adopt_init_args(self, locals())
self.parsing = None
# __init__()
def parse_line(self, l):
if l.startswith("End of reflections"):
self.parsing = None
elif self.parsing == "hkls":
if not self.read_reflections: return
sp = l.split()
self.indices.append(tuple(map(int, sp[:3])))
self.iobs.append(float(sp[3]))
self.sigma.append(float(sp[4]))
self.peak.append(float(sp[5]))
self.background.append(float(sp[6]))
self.fs.append(float(sp[7]))
self.ss.append(float(sp[8]))
if len(sp) > 9:
self.panel.append(sp[9])
elif l.startswith(" h k l"):
self.parsing = "hkls"
elif l.startswith("Image filename:"):
self.filename = l[l.index(":")+1:].strip()
elif l.startswith("Event:"):
self.event = l[l.index(":")+1:].strip()
elif l.startswith("Image serial number:"):
self.serial = l[l.index(":")+1:].strip()
elif l.startswith("indexed_by ="):
tmp = l[l.index("=")+1:].strip()
if tmp != "none": self.indexed_by = tmp
elif l.startswith("photon_energy_eV ="):
self.photon_e = float(l[l.index("=")+1:].strip())
elif l.startswith("beam_divergence ="):
tmp = l[l.index("=")+1:].strip().split()
if len(tmp) == 2: assert tmp[1] == "rad"
self.beam_div = float(tmp[0])
elif l.startswith("beam_bandwidth ="):
tmp = l[l.index("=")+1:].strip().split()
if len(tmp) == 2: assert tmp[1] == "(fraction)"
self.beam_bw = float(tmp[0])
elif l.startswith("average_camera_length ="):
tmp = l[l.index("=")+1:].strip().split()
if len(tmp) == 2: assert tmp[1] == "m"
self.avg_clen = float(tmp[0])
elif l.startswith("num_peaks ="):
self.n_peaks = int(l[l.index("=")+1:].strip())
elif l.startswith("num_saturated_peaks ="):
self.n_sat_peaks = int(l[l.index("=")+1:].strip())
elif l.startswith("Cell parameters"):
sp = l.split()
self.cell = tuple(map(lambda x:float(x)*10., sp[2:5]) + map(float, sp[6:9]))
elif l.startswith("astar ="):
self.astar = map(lambda x:float(x)/10., re_abcstar.search(l).groups())
elif l.startswith("bstar ="):
self.bstar = map(lambda x:float(x)/10., re_abcstar.search(l).groups())
elif l.startswith("cstar ="):
self.cstar = map(lambda x:float(x)/10., re_abcstar.search(l).groups())
elif l.startswith("lattice_type ="):
self.latt_type = l[l.index("=")+1:].strip()
elif l.startswith("centering ="):
self.centering = l[l.index("=")+1:].strip()
elif l.startswith("unique_axis ="):
self.unique_axis = l[l.index("=")+1:].strip()
elif l.startswith("profile_radius ="):
tmp = l[l.index("=")+1:].strip().split()
assert len(tmp) == 2
assert tmp[-1] == "nm^-1"
self.profile_radius = float(tmp[0])/10.
elif l.startswith("predict_refine/det_shift "):
tmp = l[25:].strip().split()
assert len(tmp) == 7
assert tmp[-1] == "mm"
self.det_shift = float(tmp[2])/1.e3, float(tmp[5])/1.e3 # to meter
elif l.startswith("diffraction_resolution_limit ="):
tmp = l.split()
assert tmp[-1] == "A"
self.res_lim = float(tmp[-2])
elif l.startswith("num_reflections ="):
self.n_refl = int(l[l.index("=")+1:].strip())
elif l.startswith("num_saturated_reflections ="):
self.n_sat_refl = int(l[l.index("=")+1:].strip())
# parse_line()
def indexed_symmetry(self):
if not self.cell: return None
if self.latt_type == "triclinic":
sgstr = "P1"
elif self.latt_type == "monoclinic":
tmp = dict(a="211", b="121", c="112")
sgstr = self.centering + tmp[self.unique_axis]
elif self.latt_type == "orthorhombic":
sgstr = self.centering + "222"
elif self.latt_type == "tetragonal":
sgstr = self.centering + "422"
elif self.latt_type == "rhombohedral":
sgstr = self.centering + "32"
elif self.latt_type == "hexagonal":
sgstr = self.centering + "622"
elif self.latt_type == "cubic":
sgstr = self.centering + "432"
else:
raise RuntimeError("Unknown lattice type (%s)" % self.latt_type)
return crystal.symmetry(self.cell, sgstr, assert_is_compatible_unit_cell=False)
# indexed_symmetry()
def ub_matrix(self):
if None in (self.astar, self.bstar, self.cstar): return None
ub = numpy.array([self.astar, self.bstar, self.cstar]).transpose()
# numpy.linalg.inv(ub) to get abc matrix (avector = abc[0,:])
return ub
# ub_matrix()
def miller_set(self, space_group, anomalous_flag):
return miller.set(crystal_symmetry=crystal.symmetry(unit_cell=self.cell,
space_group=space_group,
assert_is_compatible_unit_cell=False),
indices=flex.miller_index(self.indices),
anomalous_flag=anomalous_flag)
# miller_set()
def data_array(self, space_group, anomalous_flag):
return miller.array(self.miller_set(space_group, anomalous_flag),
data=flex.double(self.iobs),
sigmas=flex.double(self.sigma))
# data_array()
def make_lines(self, ver):
ret = ["----- Begin chunk -----"]
if self.filename is not None: ret.append("Image filename: %s" % self.filename)
if self.event is not None: ret.append("Event: %s" % self.event)
if self.serial is not None: ret.append("Image serial number: %s" % self.serial)
if self.indexed_by is not None: ret.append("indexed_by = %s" % self.indexed_by)
if self.photon_e is not None: ret.append("photon_energy_eV = %f" % self.photon_e)
if self.beam_div is not None: ret.append("beam_divergence = %.2e rad" % self.beam_div)
if self.beam_bw is not None: ret.append("beam_bandwidth = %.2e (fraction)" % self.beam_bw)
if self.avg_clen is not None: ret.append("average_camera_length = %f m" % self.avg_clen)
if self.n_peaks is not None: ret.append("num_peaks = %d" % self.n_peaks)
if self.n_sat_peaks is not None: ret.append("num_saturated_peaks = %d" % self.n_sat_peaks)
ret.append("--- Begin crystal")
if self.cell is not None:
tmp = tuple(map(lambda x: x/10, self.cell[:3])) + self.cell[3:]
ret.append("Cell parameters %7.5f %7.5f %7.5f nm, %7.5f %7.5f %7.5f deg"% tmp)
for i, d in enumerate((self.astar, self.bstar, self.cstar)):
if d is not None:
tmp = ("abc"[i],) + tuple(map(lambda x: x*10., d))
ret.append("%sstar = %+9.7f %+9.7f %+9.7f nm^-1" % tmp)
if self.latt_type is not None: ret.append("lattice_type = %s" % self.latt_type)
if self.centering is not None: ret.append("centering = %s" % self.centering)
if self.unique_axis is not None: ret.append("unique_axis = %s" % self.unique_axis)
if self.profile_radius is not None: ret.append("profile_radius = %.5f nm^-1" % (self.profile_radius*10.))
if self.det_shift[0] is not None: ret.append("predict_refine/det_shift x = %.3f y = %.3f mm" % (self.det_shift[0]*1.e3, self.det_shift[1]*1.e3))
if self.res_lim is not None: ret.append("diffraction_resolution_limit = %.2f nm^-1 or %.2f A" % (10./self.res_lim, self.res_lim))
if self.n_refl is not None: ret.append("num_reflections = %d" % self.n_refl)
if self.n_sat_refl is not None: ret.append("num_saturated_reflections = %d" % self.n_sat_refl)
if self.n_imp_refl is not None: ret.append("num_implausible_reflections = %d" % self.n_imp_refl)
#if self. is not None: ret.append("%" % self.)
ret.append("Reflections measured after indexing")
if ver == "2.3":
ret.append(" h k l I sigma(I) peak background fs/px ss/px panel")
else:
raise "Never reaches here"
for i in xrange(len(self.indices)):
if ver == "2.3":
h, k, l = self.indices[i]
tmp = (h, k, l, self.iobs[i], self.sigma[i],
self.peak[i], self.background[i],
self.fs[i], self.ss[i], self.panel[i])
ret.append("%4i %4i %4i %10.2f %10.2f %10.2f %10.2f %6.1f %6.1f %s" % tmp)
else:
raise "Never reaches here"
ret.append("End of reflections")
ret.append("--- End crystal")
ret.append("----- End chunk -----")
return "\n".join(ret) + "\n"
# make_lines()
def set_sg(self, sg):
# sg must be space_group object
self.latt_type = sg.crystal_system().lower()
self.centering = sg.conventional_centring_type_symbol()
q = sgtbx.space_group_symbols(str(sg.info())).qualifier()
self.unique_axis = q if q else "*" # XXX should return c for P4 etc??
# class Chunk
class Streamfile:
def __init__(self, strin=None):
self.chunks = []
if strin is not None:
self.read_file(strin)
# __init__()
def read_file(self, strin):
fin = open(strin)
line = fin.readline()
format_ver = re.search("CrystFEL stream format ([0-9\.]+)", line).group(1)
print "# format version:", format_ver
assert format_ver == "2.2" # TODO support other version
self.chunks = []
read_flag = False
for l in fin:
if "----- Begin chunk -----" in l:
read_flag = True
self.chunks.append(Chunk())
elif "----- End chunk -----" in l:
read_flag = False
sys.stderr.write("\rprocessed: %d" % len(self.chunks))
sys.stderr.flush()
elif read_flag:
self.chunks[-1].parse_line(l)
print >>sys.stderr, " done."
# read_file()
def dump_pickle(self, pklout):
pickle.dump(self.chunks, open(pklout, "wb"), -1)
# dump_pickle()
def load_pickle(self, pklin):
self.chunks = pickle.load(open(pklin, "rb"))
# load_pickle()
"""
def dump_msgpack(self, msgout):
open(msgout, "wb").write(msgpack.packb(self.chunks))
# dump_msgpack()
def load_msgpack(self, msgin):
self.chunks = msgpack.load(open(msgin, "rb"))
# load_msgpack()
"""
# class Streamfile
def stream_iterator(stream, start_at=0, read_reflections=True):
if stream.endswith(".bz2"):
fin = bz2.BZ2File(stream)
else:
fin = open(stream)
line = fin.readline()
format_ver = re.search("CrystFEL stream format ([0-9\.]+)", line).group(1)
print "# format version:", format_ver
assert float(format_ver) >= 2.2 # TODO support other version
chunk = None
count = 0
read_flag = False
for l in fin:
if "----- Begin chunk -----" in l:
read_flag = True
chunk = Chunk(read_reflections=read_reflections)
elif "----- End chunk -----" in l:
read_flag = False
if chunk.indexed_by is not None:
if start_at <= count: yield chunk
count += 1
elif read_flag:
chunk.parse_line(l)
# stream_iterator()
if __name__ == "__main__":
import sys
import time
t = time.time()
stream = Streamfile(sys.argv[1])
print "process time:", time.time() - t
""" t = time.time()
stream.dump_msgpack("junk.msg")
print "msgpack dump time:", time.time() - t
t = time.time()
stream.load_msgpack("junk.msg")
print "msgpack load time:", time.time() - t
"""
t = time.time()
stream.dump_pickle("junk.pkl")
print "pickle dump time:", time.time() - t
t = time.time()
stream.load_pickle("junk.pkl")
print "pickle load time:", time.time() - t
| keitaroyam/yamtbx | yamtbx/dataproc/crystfel/stream.py | Python | bsd-3-clause | 14,891 | [
"CRYSTAL"
] | 19b0f55ab410aacbd3ca840ac8f5a146f5358b3dce2691c2c37464edfa946df2 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# --- BEGIN_HEADER ---
#
# vmbuilder - shared virtual machine builder functions and script
#
# Copyright (C) 2003-2012 The MiG Project lead by Brian Vinter
#
# This file is part of MiG.
#
# MiG is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# MiG is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
# -- END_HEADER ---
#
"""A collection of functions for building virtual machines for grid use and a
simple handler for invocation as a command line vm build script.
"""
import getopt
import os
import subprocess
import sys
from tempfile import mkdtemp
from shared.conf import get_configuration_object
configuration = get_configuration_object()
logger = configuration.logger
# Packages needed for basic desktop with vnc proxy (using vboxguest module)
default_adds = ['iptables', 'acpid', 'x11vnc', 'xorg', 'gdm', 'xfce4', 'gcc',
'make', 'python-openssl', 'zenity']
# Packages installed by recommends but not needed
default_removes = ['gnome-session', 'compiz', 'metacity', 'xscreensaver',
'nautilus', 'yelp', 'rhythmbox']
default_specs = {'distro': 'ubuntu', 'hypervisor': 'vbox', 'memory': 1024,
'cpu_count': 1, 'suite': 'lucid', 'mig_code_base':
configuration.mig_code_base, 'working_dir':
configuration.vms_builder_home, 'architecture': 'i386',
'mirror': 'http://127.0.0.1:9999/ubuntu', 'add_packages':
default_adds, 'remove_packages': default_removes,
'late_adds': [], 'late_removes': [], 'vmbuilder_opts':
'--vbox-disk-format=vmdk'}
def fill_template(src, dst, vm_specs):
"""Fills template in src with values from specs and writes it to dst. All
fields used in template should be provided in vm_specs.
"""
src_fd = open(src, 'r')
template = src_fd.read()
src_fd.close()
filled_conf = template % vm_specs
dst_fd = open(dst, 'w')
dst_fd.write(filled_conf)
dst_fd.close()
logger.info("filled %s in %s:\n%s" % (src, dst, filled_conf))
def build_vm(vm_specs):
"""Use vmbuilder to build an OS image with settings from the vm_specs
dictionary.
"""
build_specs = {}
build_specs.update(default_specs)
build_specs.update(vm_specs)
# Recent suites added unused unity package(s)
if build_specs['suite'] in ('precise', ):
build_specs['remove_packages'].append('unity')
# Make sure basic package adds and removes are done
build_specs['postinst_adds'] = ' '.join(build_specs['add_packages'] + \
build_specs['late_adds'])
build_specs['postinst_removes'] = ' '.join(build_specs['remove_packages'] \
+ build_specs['late_removes'])
# Fill conf template (currently just copies it since all args are explicit)
tmp_dir = mkdtemp()
conf_path = os.path.join(tmp_dir, '%(distro)s.cfg' % build_specs)
conf_template_path = os.path.join(configuration.vms_builder_home,
'%(distro)s.cfg' % build_specs)
bundle_path = os.path.join(tmp_dir, 'bundle-%(suite)s' % build_specs)
bundle_template_path = os.path.join(configuration.vms_builder_home,
'bundle-%(suite)s.in' % build_specs)
# Install late_adds and purge late_removes in post-install to avoid
# early install problems and clean up
postinst_path = os.path.join(tmp_dir, 'post-install-%(suite)s.sh' % \
build_specs)
postinst_template_path = os.path.join(configuration.vms_builder_home,
'post-install-%(suite)s.sh.in' % build_specs)
# destdir option in conf does not work - keep most on cli
# reserve 3G for tmpfs for way faster build (and enough for sys disk)
opts_string = "%(vmbuilder_opts)s"
opts_string += " -c %s --copy %s --exec %s --tmpfs 3072 -o" % \
(conf_path, bundle_path, postinst_path)
opts_string += " -d %(working_dir)s/%(hypervisor)s-%(distro)s-%(suite)s-%(architecture)s"
opts_string += " --suite %(suite)s --arch %(architecture)s"
opts_string += " --mem %(memory)d --cpus %(cpu_count)d --mirror %(mirror)s"
opts_string += " --part %(working_dir)s/%(suite)s.partition"
opts_string += " --firstboot %(working_dir)s/boot-%(suite)s.sh"
for name in build_specs["add_packages"]:
opts_string += " --addpkg %s" % name
for name in build_specs["remove_packages"]:
opts_string += " --removepkg %s" % name
build_specs["vmbuilder_opts"] = opts_string % build_specs
try:
fill_template(conf_template_path, conf_path, build_specs)
fill_template(bundle_template_path, bundle_path, build_specs)
fill_template(postinst_template_path, postinst_path, build_specs)
os.chmod(postinst_path, 0755)
cmd_base = "sudo /usr/bin/vmbuilder"
cmd_args = "%(hypervisor)s %(distro)s %(vmbuilder_opts)s" % build_specs
cmd_string = "%s %s" % (cmd_base, cmd_args)
cmd = cmd_string.split()
logger.info("building vm with: %s" % cmd_string)
subprocess.check_call(cmd)
logger.info("built vm in %(working_dir)s" % build_specs)
except Exception, exc:
logger.error("vm built failed: %s" % exc)
finally:
os.remove(conf_path)
os.remove(bundle_path)
os.remove(postinst_path)
os.rmdir(tmp_dir)
def usage():
"""Script usage help"""
print "%s OPTIONS [EXTRA_PACKAGES]" % sys.argv[0]
print "where OPTIONS include the names:"
for name in default_specs.keys():
if name in ('add_packages', 'late_adds', 'remove_packages',
'late_removes'):
continue
print " %s (default: %s)" % (name.replace('_', '-'),
default_specs[name])
if __name__ == '__main__':
specs = {}
specs.update(default_specs)
try:
(opts, args) = getopt.getopt(sys.argv[1:], 'h', [
'help',
'distro=',
'hypervisor=',
'memory=',
'cpu_count=',
'architecture=',
'working-dir=',
'suite=',
'mirror=',
'blacklist=',
'vmbuilder-opts=',
])
except getopt.GetoptError, exc:
logger.error('option parsing failed: %s' % exc)
sys.exit(1)
for (opt, val) in opts:
if opt in ('-h', '--help'):
usage()
sys.exit(0)
elif opt in ('--blacklist', ):
specs["late_removes"] = val.split()
elif opt in ('--distro', ):
specs["distro"] = val
elif opt in ('--hypervisor', ):
specs["hypervisor"] = val
elif opt in ('--memory', ):
specs["memory"] = int(val)
elif opt in ('--cpu-count', ):
specs["cpu_count"] = int(val)
elif opt in ('--architecture', ):
specs["architecture"] = val
elif opt in ('--working-dir', ):
specs["working_dir"] = val
elif opt in ('--suite', ):
specs["suite"] = val
elif opt in ('--mirror', ):
specs["mirror"] = val
elif opt in ('--vmbuilder-opts', ):
specs["vmbuilder_opts"] = val
else:
logger.error("Unknown option: %s" % opt)
usage()
sys.exit(1)
if args:
specs['late_adds'] = args
build_vm(specs)
| heromod/migrid | mig/shared/vmbuilder.py | Python | gpl-2.0 | 8,114 | [
"Brian"
] | e295b1bab32d6fc4de83870e4b0806d1034b5da5bfad52c5ca7c3d7381816d43 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
'''
freeseer - vga/presentation capture software
Copyright (C) 2013 Free and Open Source Software Learning Centre
http://fosslc.org
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
For support, questions, suggestions or any other inquiries, visit:
http://wiki.github.com/Freeseer/freeseer/
@author: Thanh Ha
'''
from PyQt4.QtGui import QComboBox
from PyQt4.QtGui import QFormLayout
from PyQt4.QtGui import QLabel
from PyQt4.QtGui import QWidget
class ConfigWidget(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
layout = QFormLayout()
self.setLayout(layout)
# Preview
self.previewLabel = QLabel("Preview")
self.previewComboBox = QComboBox()
self.previewComboBox.addItem("autovideosink")
self.previewComboBox.addItem("ximagesink")
self.previewComboBox.addItem("xvimagesink")
self.previewComboBox.addItem("gconfvideosink")
layout.addRow(self.previewLabel, self.previewComboBox)
# Leaky Queue
# Allows user to set queue in video to be leaky - required to work with RTMP streaming plugin
self.leakyQueueLabel = QLabel("Leaky Queue")
self.leakyQueueComboBox = QComboBox()
layout.addRow(self.leakyQueueLabel, self.leakyQueueComboBox)
| Freeseer/freeseer | src/freeseer/plugins/output/videopreview/widget.py | Python | gpl-3.0 | 1,906 | [
"VisIt"
] | 99bae75197eadf4c029f6aac808f72db620aa31c0129eb6a2597d6c16269c686 |
# -*- coding: utf-8 -*-
# @Author: YangZhou
# @Date: 2016-12-24 18:47:10
# @Last Modified by: YangZhou
# @Last Modified time: 2017-06-19 12:36:00
from aces import config
import aces.tools as tl
from aces.runners.phonopy import runner as Runner
import time
class runner(Runner):
def force_constant(self):
cmd = config.phonopy + "--fc dirs/dir_POSCAR001/vasprun.xml"
tl.passthru(cmd)
def getVaspRun_vasp(self):
m = self.m
if m.isym:
sym = "ISYM = 1"
else:
sym = "ISYM = 0"
if m.ispin:
spin = "ISPIN =2"
else:
spin = ""
s = """SYSTEM=calculate energy
PREC = High
IBRION = 8
ENCUT = %f
EDIFF = 1.0e-8
ISMEAR = %d; SIGMA = 0.01
IALGO = 38
LREAL = .FALSE.
ADDGRID = .TRUE.
LWAVE = .FALSE.
LCHARG = .FALSE.
%s
%s
""" % (self.m.ecut, m.ismear, sym, spin)
s = s.replace(r'^\s+', '')
tl.write(s, 'INCAR')
m = self.m
m.writePOTCAR()
s = """A
0
Monkhorst-Pack
%s
0 0 0
""" % ' '.join(map(str, m.ekpoints))
s = s.replace(r'^\s+', '')
tl.write(s, 'KPOINTS')
if 'jm' in self.__dict__:
from aces.jobManager import pbs
path = tl.pwd()
if m.queue == "q3.4":
pb = pbs(
queue=m.queue,
nodes=12,
procs=4,
disp=m.pbsname,
path=path,
content=config.mpirun +
" 48 " +
config.vasp +
' >log.out')
else:
pb = pbs(
queue=m.queue,
nodes=4,
procs=12,
disp=m.pbsname,
path=path,
content=config.mpirun +
" 48 " +
config.vasp +
' >log.out')
self.jm.reg(pb)
else:
tl.shell_exec(
config.mpirun +
" %s " %
m.cores +
config.vasp +
' >log.out')
def generate(self):
m = self.m
self.minimizePOSCAR()
a = time.time()
self.generate_supercells()
tl.debug('generate_supercells:%f s' % (time.time() - a))
tl.shell_exec("rm *-*")
tl.cp("SPOSCAR", "POSCAR001")
a = time.time()
files = ['POSCAR001']
self.getvasprun(files)
tl.debug('getvasprun:%f s' % (time.time() - a))
a = time.time()
self.force_constant()
tl.debug('force_constant:%f s' % (time.time() - a))
if m.phofc:
return self
self.postp()
| vanceeasleaf/aces | aces/runners/phonopy_dfpt.py | Python | gpl-2.0 | 2,888 | [
"VASP",
"phonopy"
] | 16b819484bce89642120a348a8686f9577f9fe59241eb6c0c21c857a7a176ca7 |
#########################################################################
## This program is part of 'MOOSE', the
## Messaging Object Oriented Simulation Environment.
## Copyright (C) 2014 Upinder S. Bhalla. and NCBS
## It is made available under the terms of the
## GNU Lesser General Public License version 2.1
## See the file COPYING.LIB for the full notice.
#########################################################################
import sys
import math
import numpy as np
import moose
print('[INFO] Using moose from %s' % moose.__file__ )
import os
moose.seed( 1 )
concA = 0.005 # millimolar
def makeModel():
# create container for model
r0 = 2e-6 # m
r1 = 1e-6 # m
num = 100
diffLength = 1e-6 # m
L = num * diffLength # m
diffConst = 10e-12
#motorRate = 1e-6
#diffConst = 0
motorRate = 0
model = moose.Neutral( 'model' )
compartment = moose.CylMesh( '/model/compartment' )
compartment.r0 = r0
compartment.r1 = r1
compartment.x0 = 0
compartment.x1 = L
compartment.diffLength = diffLength
assert( compartment.numDiffCompts == num )
# create molecules and reactions
a = moose.Pool( '/model/compartment/a' )
b = moose.Pool( '/model/compartment/b' )
c = moose.Pool( '/model/compartment/c' )
d = moose.Pool( '/model/compartment/d' )
r1 = moose.Reac( '/model/compartment/r1' )
moose.connect( r1, 'sub', b, 'reac' )
moose.connect( r1, 'sub', d, 'reac' )
moose.connect( r1, 'prd', c, 'reac' )
r1.Kf = 1000.0 # 1/(mM.sec)
r1.Kb = 1 # 1/sec
# Assign parameters
a.diffConst = diffConst
b.diffConst = diffConst / 2.0
b.motorConst = motorRate
c.diffConst = diffConst
d.diffConst = diffConst
# Make solvers
ksolve = moose.Gsolve( '/model/compartment/ksolve' )
dsolve = moose.Dsolve( '/model/compartment/dsolve' )
stoich = moose.Stoich( '/model/compartment/stoich' )
stoich.compartment = compartment
stoich.ksolve = ksolve
stoich.dsolve = dsolve
stoich.path = "/model/compartment/##"
assert( dsolve.numPools == 4 )
a.vec.concInit = concA
b.vec.concInit = concA / 5.0
c.vec.concInit = concA
d.vec.concInit = concA / 5.0
for i in range( num ):
d.vec[i].concInit = concA * 2 * i / num
def test_diffusion_gsolve_dsolve():
"""
This example illustrates how to set up a diffusion/transport model with
a simple reaction-diffusion system in a tapering cylinder:
| Molecule **a** diffuses with diffConst of 10e-12 m^2/s.
| Molecule **b** diffuses with diffConst of 5e-12 m^2/s.
| Molecule **b** also undergoes motor transport with a rate of 10e-6 m/s
| Thus it 'piles up' at the end of the cylinder.
| Molecule **c** does not move: diffConst = 0.0
| Molecule **d** does not move: diffConst = 10.0e-12 but it is buffered.
| Because it is buffered, it is treated as non-diffusing.
All molecules other than **d** start out only in the leftmost (first)
voxel, with a concentration of 1 mM. **d** is present throughout
at 0.2 mM, except in the last voxel, where it is at 1.0 mM.
The cylinder has a starting radius of 2 microns, and end radius of
1 micron. So when the molecule undergoing motor transport gets to the
narrower end, its concentration goes up.
There is a little reaction in all compartments: ``b + d <===> c``
As there is a high concentration of **d** in the last compartment,
when the molecule **b** reaches the end of the cylinder, the reaction
produces lots of **c**.
Note that molecule **a** does not participate in this reaction.
The concentrations of all molecules are displayed in an animation.
"""
runtime = 20.0
diffdt = 0.005
plotdt = 0.1
makeModel()
# Set up clocks. The dsolver to know before assigning stoich
moose.setClock( 10, diffdt ) # 10 is the standard clock for Dsolve.
moose.setClock( 16, plotdt ) # 16 is the standard clock for Ksolve.
a = moose.element( '/model/compartment/a' )
b = moose.element( '/model/compartment/b' )
c = moose.element( '/model/compartment/c' )
d = moose.element( '/model/compartment/d' )
moose.reinit()
atot = sum( a.vec.n )
btot = sum( b.vec.n )
ctot = sum( c.vec.n )
dtot = sum( d.vec.n )
for t in np.arange( 0, runtime, plotdt ):
moose.start( plotdt )
atot2 = sum( a.vec.n )
btot2 = sum( b.vec.n )
ctot2 = sum( c.vec.n )
dtot2 = sum( d.vec.n )
msg = 'Ratio of initial to final total numbers of '
got = np.array((atot2/atot, btot2/btot, ctot2/ctot, dtot2/dtot))
msg += 'a=%f b=%f, c=%f, d=%f' % (tuple(got))
print(msg)
print('Initial to final (b+c)=%f' % (float(btot2 + ctot2) / (btot + ctot )))
expected = np.array((1.00003087, 1.39036644, 0.92191184, 1.11427514))
error = got - expected
rerror = np.abs( error ) / expected
assert np.allclose(got, expected, atol=1e-3), "Got %s, expected %s" % (got, expected)
def main():
test_diffusion_gsolve_dsolve()
# Run the 'main' if this script is executed standalone.
if __name__ == '__main__':
main()
| dilawar/moose-core | tests/core/test_cylinder_diffusion_gsolve+dsolve.py | Python | gpl-3.0 | 5,170 | [
"MOOSE"
] | fd65973573a4a2724d953e34ba29b10ced2f7e00bb61b882f0964d69a2812c41 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# --- BEGIN_HEADER ---
#
# native-https - native https access
# Copyright (C) 2003-2014 The MiG Project lead by Brian Vinter
#
# This file is part of MiG.
#
# MiG is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# MiG is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
# -- END_HEADER ---
#
"""Test native python SSL using HTTPSConnection against MiG
server.
"""
import os
import sys
import httplib
try:
HOME = os.getenv('HOME')
except Exception:
HOME = '.'
args = ['dk-cert.migrid.org', 443, '%s/.mig/key.pem' % HOME,
'%s/.mig/cert.pem' % HOME]
input_args = sys.argv[1:]
if len(input_args) > 4:
input_args = input_args[:4]
args = input_args[:len(input_args)] + args[len(input_args):]
(server, port, key_path, cert_path) = args
print 'Connecting to %s:%s using key in %s and cert in %s' % tuple(args)
try:
connection = httplib.HTTPSConnection(server, int(port), key_path,
cert_path)
sys.stdin = os.open('pp.txt', os.O_RDWR)
connection.connect()
print 'Received server certificate data:'
# print repr(ssl_sock.server())
print repr(connection.sock._ssl.server())
print 'Received CA certificate data:'
# print repr(ssl_sock.issuer())
print repr(connection.sock._ssl.issuer())
print ''
request = ['GET', '/']
print 'sending request:\n%s' % request
connection.request(request[0], request[1])
reply = connection.getresponse()
print reply.status, reply.reason
data = reply.read()
print 'received:\n%s' % data
except Exception, err:
print 'Failed to create SSL connnection: %s' % err
sys.exit(1)
try:
connection.close()
except:
pass
| heromod/migrid | mig/user/native-https.py | Python | gpl-2.0 | 2,281 | [
"Brian"
] | eec6901359d217b3f54053488a47a4438184695bdbd44df5637393bc79196798 |
import warnings
import json
import numpy as np
import menpo.io as mio
from menpo.shape import ColouredTriMesh, TexturedTriMesh, TriMesh, PointCloud
def _construct_shape_type(points, trilist, tcoords, texture, colour_per_vertex):
r"""
Construct the correct Shape subclass given the inputs. TexturedTriMesh
can only be created when tcoords and texture are available. ColouredTriMesh
can only be created when colour_per_vertex is non None and TriMesh
can only be created when trilist is non None. Worst case fall back is
PointCloud.
Parameters
----------
points : ``(N, D)`` `ndarray`
The N-D points.
trilist : ``(N, 3)`` `ndarray`` or ``None``
Triangle list or None.
tcoords : ``(N, 2)`` `ndarray` or ``None``
Texture coordinates.
texture : :map:`Image` or ``None``
Texture.
colour_per_vertex : ``(N, 1)`` or ``(N, 3)`` `ndarray` or ``None``
The colour per vertex.
Returns
-------
shape : :map:`PointCloud` or subclass
The correct shape for the given inputs.
"""
# Four different outcomes - either we have a textured mesh, a coloured
# mesh or just a plain mesh or we fall back to a plain pointcloud.
if trilist is None:
obj = PointCloud(points, copy=False)
elif tcoords is not None and texture is not None:
obj = TexturedTriMesh(points, tcoords, texture,
trilist=trilist, copy=False)
elif colour_per_vertex is not None:
obj = ColouredTriMesh(points, trilist=trilist,
colours=colour_per_vertex, copy=False)
else:
# TriMesh fall through
obj = TriMesh(points, trilist=trilist, copy=False)
if tcoords is not None and texture is None:
warnings.warn('tcoords were found, but no texture was recovered, '
'reverting to an untextured mesh.')
if texture is not None and tcoords is None:
warnings.warn('texture was found, but no tcoords were recovered, '
'reverting to an untextured mesh.')
return obj
def vtk_ensure_trilist(polydata):
try:
import vtk
from vtk.util.numpy_support import vtk_to_numpy
trilist = vtk_to_numpy(polydata.GetPolys().GetData())
# 5 is the triangle type - if we have another type we need to
# use a vtkTriangleFilter
c = vtk.vtkCellTypes()
polydata.GetCellTypes(c)
if c.GetNumberOfTypes() != 1 or polydata.GetCellType(0) != 5:
warnings.warn('Non-triangular mesh connectivity was detected - '
'this is currently unsupported and thus the '
'connectivity is being coerced into a triangular '
'mesh. This may have unintended consequences.')
t_filter = vtk.vtkTriangleFilter()
t_filter.SetInputData(polydata)
t_filter.Update()
trilist = vtk_to_numpy(t_filter.GetOutput().GetPolys().GetData())
return trilist.reshape([-1, 4])[:, 1:]
except Exception as e:
warnings.warn(str(e))
return None
def wrl_importer(filepath, asset=None, texture_resolver=None, **kwargs):
"""Allows importing VRML 2.0 meshes.
Uses VTK and assumes that the first actor in the scene is the one
that we want.
Parameters
----------
asset : `object`, optional
An optional asset that may help with loading. This is unused for this
implementation.
texture_resolver : `callable`, optional
A callable that recieves the mesh filepath and returns a single
path to the texture to load.
\**kwargs : `dict`, optional
Any other keyword arguments.
Returns
-------
shape : :map:`PointCloud` or subclass
The correct shape for the given inputs.
"""
import vtk
from vtk.util.numpy_support import vtk_to_numpy
vrml_importer = vtk.vtkVRMLImporter()
vrml_importer.SetFileName(str(filepath))
vrml_importer.Update()
# Get the first actor.
actors = vrml_importer.GetRenderer().GetActors()
actors.InitTraversal()
mapper = actors.GetNextActor().GetMapper()
mapper_dataset = mapper.GetInput()
if actors.GetNextActor():
# There was more than one actor!
warnings.warn('More than one actor was detected in the scene. Only '
'single scene actors are currently supported.')
# Get the Data
polydata = vtk.vtkPolyData.SafeDownCast(mapper_dataset)
# We must have point data!
points = vtk_to_numpy(polydata.GetPoints().GetData()).astype(np.float)
trilist = vtk_ensure_trilist(polydata)
texture = None
if texture_resolver is not None:
texture_path = texture_resolver(filepath)
if texture_path is not None and texture_path.exists():
texture = mio.import_image(texture_path)
# Three different outcomes - either we have a textured mesh, a coloured
# mesh or just a plain mesh. Let's try each in turn.
# Textured
tcoords = None
try:
tcoords = vtk_to_numpy(polydata.GetPointData().GetTCoords())
except Exception:
pass
if isinstance(tcoords, np.ndarray) and tcoords.size == 0:
tcoords = None
# Colour-per-vertex
try:
colour_per_vertex = vtk_to_numpy(mapper.GetLookupTable().GetTable()) / 255.
except Exception:
pass
if isinstance(colour_per_vertex, np.ndarray) and colour_per_vertex.size == 0:
colour_per_vertex = None
return _construct_shape_type(points, trilist, tcoords, texture,
colour_per_vertex)
def obj_importer(filepath, asset=None, texture_resolver=None, **kwargs):
"""Allows importing Wavefront (OBJ) files.
Uses VTK.
Parameters
----------
asset : `object`, optional
An optional asset that may help with loading. This is unused for this
implementation.
texture_resolver : `callable`, optional
A callable that recieves the mesh filepath and returns a single
path to the texture to load.
\**kwargs : `dict`, optional
Any other keyword arguments.
Returns
-------
shape : :map:`PointCloud` or subclass
The correct shape for the given inputs.
"""
import vtk
from vtk.util.numpy_support import vtk_to_numpy
obj_importer = vtk.vtkOBJReader()
obj_importer.SetFileName(str(filepath))
obj_importer.Update()
# Get the output
polydata = obj_importer.GetOutput()
# We must have point data!
points = vtk_to_numpy(polydata.GetPoints().GetData()).astype(np.float)
trilist = np.require(vtk_ensure_trilist(polydata), requirements=['C'])
texture = None
if texture_resolver is not None:
texture_path = texture_resolver(filepath)
if texture_path is not None and texture_path.exists():
texture = mio.import_image(texture_path)
tcoords = None
if texture is not None:
try:
tcoords = vtk_to_numpy(polydata.GetPointData().GetTCoords())
except Exception:
pass
if isinstance(tcoords, np.ndarray) and tcoords.size == 0:
tcoords = None
colour_per_vertex = None
return _construct_shape_type(points, trilist, tcoords, texture,
colour_per_vertex)
def ply_importer(filepath, asset=None, texture_resolver=None, **kwargs):
"""Allows importing Wavefront (OBJ) files.
Uses VTK.
Parameters
----------
asset : `object`, optional
An optional asset that may help with loading. This is unused for this
implementation.
texture_resolver : `callable`, optional
A callable that recieves the mesh filepath and returns a single
path to the texture to load.
\**kwargs : `dict`, optional
Any other keyword arguments.
Returns
-------
shape : :map:`PointCloud` or subclass
The correct shape for the given inputs.
"""
import vtk
from vtk.util.numpy_support import vtk_to_numpy
ply_importer = vtk.vtkPLYReader()
ply_importer.SetFileName(str(filepath))
ply_importer.Update()
# Get the output
polydata = ply_importer.GetOutput()
# We must have point data!
points = vtk_to_numpy(polydata.GetPoints().GetData()).astype(np.float)
trilist = np.require(vtk_ensure_trilist(polydata), requirements=['C'])
texture = None
if texture_resolver is not None:
texture_path = texture_resolver(filepath)
if texture_path is not None and texture_path.exists():
texture = mio.import_image(texture_path)
tcoords = None
if texture is not None:
try:
tcoords = vtk_to_numpy(polydata.GetPointData().GetTCoords())
except Exception:
pass
if isinstance(tcoords, np.ndarray) and tcoords.size == 0:
tcoords = None
colour_per_vertex = None
return _construct_shape_type(points, trilist, tcoords, texture,
colour_per_vertex)
def stl_importer(filepath, asset=None, **kwargs):
"""Allows importing Stereolithography CAD (STL) files.
Uses VTK.
Parameters
----------
asset : `object`, optional
An optional asset that may help with loading. This is unused for this
implementation.
\**kwargs : `dict`, optional
Any other keyword arguments.
Returns
-------
shape : :map:`PointCloud` or subclass
The correct shape for the given inputs.
"""
import vtk
from vtk.util.numpy_support import vtk_to_numpy
stl_importer = vtk.vtkSTLReader()
stl_importer.SetFileName(str(filepath))
stl_importer.Update()
# Get the output
polydata = stl_importer.GetOutput()
# We must have point data!
points = vtk_to_numpy(polydata.GetPoints().GetData()).astype(np.float)
trilist = np.require(vtk_ensure_trilist(polydata), requirements=['C'])
colour_per_vertex = None
tcoords = None
texture = None
return _construct_shape_type(points, trilist, tcoords, texture,
colour_per_vertex)
def mjson_importer(filepath, asset=None, texture_resolver=True, **kwargs):
"""
Import meshes that are in a simple JSON format.
Parameters
----------
asset : `object`, optional
An optional asset that may help with loading. This is unused for this
implementation.
texture_resolver : `callable`, optional
A callable that recieves the mesh filepath and returns a single
path to the texture to load.
\**kwargs : `dict`, optional
Any other keyword arguments.
Returns
-------
shape : :map:`PointCloud` or subclass
The correct shape for the given inputs.
"""
with open(str(filepath), 'rb') as f:
mesh_json = json.load(f)
texture = None
if texture_resolver is not None:
texture_path = texture_resolver(filepath)
if texture_path is not None and texture_path.exists():
texture = mio.import_image(texture_path)
points = mesh_json['points']
trilist = mesh_json['trilist']
tcoords = mesh_json.get('tcoords'),
colour_per_vertex = mesh_json.get('colour_per_vertex')
return _construct_shape_type(points, trilist, tcoords, texture,
colour_per_vertex)
| grigorisg9gr/menpo3d | menpo3d/io/input/mesh/base.py | Python | bsd-3-clause | 11,427 | [
"VTK"
] | d39656acf178cd81a17706b632e45e121665ca615c7ec2be55a06986312b30f3 |
"""
Functions for adding decorations (axes, colorbar, outlines..) to the
pipeline in a procedural way.
"""
# Author: Gael Varoquaux
# Copyright (c) 2007-2015 Enthought, Inc.
# License: BSD Style.
import numbers
import numpy as np
# Enthought library imports.
from traits.api import String, CFloat, Instance, HasTraits, \
Trait, CArray, true, Any, Range, Either
from . import tools
from .figure import draw, gcf
# Mayavi imports
import mayavi.modules.api as modules
from .pipe_base import make_function
from .modules import ModuleFactory
from .engine_manager import get_engine, engine_manager
#############################################################################
# Colorbar related functions
def _orient_colorbar(lut_mgr, orientation):
"""Orients the given LUTManager (make it horizontal or vertical).
"""
rep = lut_mgr.scalar_bar_representation
colorbar = lut_mgr.scalar_bar
if orientation == "vertical":
if rep is None:
# VTK < 5.2
colorbar.orientation = "vertical"
else:
rep.orientation = 1
rep.position = (0.01, 0.15)
rep.position2 = (0.1, 0.8)
colorbar.width = 0.1
colorbar.height = 0.8
colorbar.position = (0.01, 0.15)
elif orientation == "horizontal":
if rep is None:
colorbar.orientation = "horizontal"
else:
rep.orientation = 0
rep.position = (0.1, 0.01)
rep.position2 = (0.8, 0.17)
colorbar.width = 0.8
colorbar.height = 0.17
colorbar.position = (0.1, 0.01)
else:
raise ValueError("Unknown orientation: %s" % orientation)
draw()
def _lut_manager_properties(lut_manager, **props):
""" Internal function used to apply properties to a colorbar.
"""
need_redraw = False
orientation = props.get('orientation', None)
if orientation is not None:
_orient_colorbar(lut_manager, orientation)
colorbar = lut_manager.scalar_bar
title = props.get('title', None)
if title is not None:
colorbar.title = title
need_redraw = True
label_fmt = props.get('label_fmt', None)
if label_fmt is not None:
colorbar.label_format = label_fmt
need_redraw = True
nb_labels = props.get('nb_labels', None)
if nb_labels is not None:
colorbar.number_of_labels = nb_labels
need_redraw = True
nb_colors = props.get('nb_colors', None)
if nb_colors is not None:
colorbar.maximum_number_of_colors = nb_colors
need_redraw = True
if need_redraw:
draw()
def scalarbar(object=None, title=None, orientation=None,
nb_labels=None, nb_colors=None,
label_fmt=None):
"""Adds a colorbar for the scalar color mapping of the given object.
If no object is specified, the first object with scalar data in the scene
is used.
**Keyword arguments**:
:object: Optional object to get the scalar color map from
:title: The title string
:orientation: Can be 'horizontal' or 'vertical'
:nb_labels: The number of labels to display on the colorbar.
:label_fmt: The string formater for the labels. This needs to be
a formater for float number, eg '%.1f'.
:nb_colors: The maximum number of colors displayed on the
colorbar.
"""
module_manager = tools._find_module_manager(object=object,
data_type="scalar")
if module_manager is None:
return
if not module_manager.scalar_lut_manager.show_scalar_bar:
if title is None:
title = ''
if orientation is None:
orientation = 'horizontal'
lut_mgr = module_manager.scalar_lut_manager
module_manager.scalar_lut_manager.show_scalar_bar = True
_lut_manager_properties(lut_mgr, title=title, orientation=orientation,
nb_labels=nb_labels, nb_colors=nb_colors,
label_fmt=label_fmt)
return lut_mgr
def vectorbar(object=None, title=None, orientation=None,
nb_labels=None, nb_colors=None,
label_fmt=None):
"""Adds a colorbar for the vector color mapping of the given object.
If no object is specified, the first object with vector data in the scene
is used.
**Keyword arguments**
:object: Optional object to get the vector color map from
:title: The title string
:orientation: Can be 'horizontal' or 'vertical'
:nb_labels: The number of labels to display on the colorbar.
:label_fmt: The string formater for the labels. This needs to be
a formater for float number, eg '%.1f'.
:nb_colors: The maximum number of colors displayed on the
colorbar.
"""
module_manager = tools._find_module_manager(object=object,
data_type="vector")
if module_manager is None:
return
if not module_manager.vector_lut_manager.show_scalar_bar:
if title is None:
title = ''
orientation = 'horizontal'
lut_mgr = module_manager.vector_lut_manager
lut_mgr.show_scalar_bar = True
_lut_manager_properties(lut_mgr, title=title, orientation=orientation,
nb_labels=nb_labels, nb_colors=nb_colors,
label_fmt=label_fmt)
return lut_mgr
def colorbar(object=None, title=None, orientation=None,
nb_labels=None, nb_colors=None,
label_fmt=None):
"""Adds a colorbar for the color mapping of the given object.
If the object has scalar data, the scalar color mapping is
represented. Elsewhere the vector color mapping is represented, if
available.
If no object is specified, the first object with a color map in the scene
is used.
**Keyword arguments**:
:object: Optional object to get the color map from
:title: The title string
:orientation: Can be 'horizontal' or 'vertical'
:nb_labels: The number of labels to display on the colorbar.
:label_fmt: The string formater for the labels. This needs to be
a formater for float number, eg '%.1f'.
:nb_colors: The maximum number of colors displayed on the
colorbar.
"""
colorbar = scalarbar(object=object, title=title, orientation=orientation,
nb_labels=nb_labels, nb_colors=nb_colors,
label_fmt=label_fmt)
if colorbar is None:
colorbar = vectorbar(object=object, title=title,
orientation=orientation,
nb_labels=nb_labels, nb_colors=nb_colors,
label_fmt=label_fmt)
return colorbar
#############################################################################
class SingletonModuleFactory(ModuleFactory):
""" Base classe for factories that can find an existing object
matching certain criteria instead of building a new one"""
# The parent object on which this module is going to be added.
_parent = Any
def __init__(self, *args, **kwargs):
""" Try to find an module actor with the same name, on the given
parent (if any) and use it rather than building a new module."""
# Call the HasTraits constructor, but not the PipeBase one.
HasTraits.__init__(self)
self._scene = gcf()
if not 'figure' in kwargs:
self._engine = get_engine()
else:
figure = kwargs['figure']
self._engine = engine_manager.find_figure_engine(figure)
self._engine.current_scene = figure
kwargs.pop('figure')
if self._scene.scene is not None:
self._scene.scene.disable_render = True
# Process the arguments
if len(args) == 1:
(parent, ) = args
elif len(args) == 0:
parent = self._engine.current_object
else:
raise ValueError("Wrong number of arguments")
# Try to find an existing module, if not add one to the pipeline
if parent is None:
target = self._scene
else:
target = parent
klass = self._target.__class__
for obj in tools._traverse(target):
if (isinstance(obj, klass)
and obj.name == self.name):
self._target = obj
break
else:
# Keep a reference to the parent
self._parent = parent
self._engine.add_module(self._target, obj=parent)
# Now calling the traits setter, so that traits handlers are
# called
self.set(**kwargs)
if self._scene.scene is not None:
self._scene.scene.disable_render = False
#############################################################################
class AxesLikeModuleFactory(SingletonModuleFactory):
""" Base class for axes and outline"""
extent = CArray(shape=(6,),
help="""[xmin, xmax, ymin, ymax, zmin, zmax]
Default is the object's extents.""", )
def _extent_changed(self):
""" There is no universal way of setting extents for decoration
objects. This should be implemented in subclasses
"""
pass
# Override the color and opacity handlers: axes and outlines do not
# behave like other modules
def _color_changed(self):
if self.color:
try:
self._target.property.color = self.color
except AttributeError:
try:
self._target.actor.property.color = self.color
except AttributeError:
pass
def _opacity_changed(self):
try:
self._target.property.opacity = self.opacity
except AttributeError:
try:
self._target.actor.property.opacity = self.opacity
except AttributeError:
pass
def __init__(self, *args, **kwargs):
""" Overide the call method to be able to catch the extents of
the object, if any.
"""
SingletonModuleFactory.__init__(self, *args, **kwargs)
if not 'extent' in kwargs:
try:
# XXX: Do not use tools.set_extent, as it does not work
# on axes.
self.extent = self._parent.actor.actor.bounds
except AttributeError:
""" Either this is not a module, or it has no actors"""
#############################################################################
class Outline(AxesLikeModuleFactory):
""" Creates an outline for the current (or given) object."""
_target = Instance(modules.Outline, ())
def _extent_changed(self):
self._target.manual_bounds = True
self._target.bounds = self.extent
outline = make_function(Outline)
#############################################################################
class Axes(AxesLikeModuleFactory):
""" Creates axes for the current (or given) object."""
xlabel = String(None, adapts='axes.x_label',
help='the label of the x axis')
ylabel = String(None, adapts='axes.y_label',
help='the label of the y axis')
zlabel = String(None, adapts='axes.z_label',
help='the label of the z axis')
nb_labels = Range(0, 50, 2, adapts='axes.number_of_labels',
desc='The number of labels along each direction')
ranges = Trait(None, None, CArray(shape=(6,)),
help="""[xmin, xmax, ymin, ymax, zmin, zmax]
Ranges of the labels displayed on the axes.
Default is the object's extents.""", )
x_axis_visibility = true(adapts='axes.x_axis_visibility',
help="Whether or not the x axis is visible (boolean)")
y_axis_visibility = true(adapts='axes.y_axis_visibility',
help="Whether or not the y axis is visible (boolean)")
z_axis_visibility = true(adapts='axes.z_axis_visibility',
help="Whether or not the z axis is visible (boolean)")
_target = Instance(modules.Axes, ())
def _extent_changed(self):
""" Code to modify the extents for
"""
axes = self._target
axes.axes.use_data_bounds = False
axes.axes.bounds = self.extent
if self.ranges is None:
axes.axes.ranges = \
axes.module_manager.source.outputs[0].bounds
def _ranges_changed(self):
if self.ranges is not None:
self._target.axes.ranges = self.ranges
self._target.axes.use_ranges = True
axes = make_function(Axes)
def xlabel(text, object=None):
"""
Creates a set of axes if there isn't already one, and sets the x label
**Keyword arguments**:
:object: The object to apply the module to, if not the whole scene
is searched for a suitable object.
"""
return axes(object, xlabel=text)
def ylabel(text, object=None):
"""
Creates a set of axes if there isn't already one, and sets the y label
**Keyword arguments**:
:object: The object to apply the module to, if not the whole scene
is searched for a suitable object.
"""
return axes(object, ylabel=text)
def zlabel(text, object=None):
"""
Creates a set of axes if there isn't already one, and sets the z label
**Keyword arguments**
:object: The object to apply the module to, if not the whole scene
is searched for a suitable object.
"""
return axes(object, zlabel=text)
##############################################################################
class OrientationAxesFactory(SingletonModuleFactory):
"""Applies the OrientationAxes mayavi module to the given VTK data object.
"""
xlabel = String(None, adapts='axes.x_axis_label_text',
help='the label of the x axis')
ylabel = String(None, adapts='axes.y_axis_label_text',
help='the label of the y axis')
zlabel = String(None, adapts='axes.z_axis_label_text',
help='the label of the z axis')
_target = Instance(modules.OrientationAxes, ())
orientation_axes = make_function(OrientationAxesFactory)
###############################################################################
class Text(ModuleFactory):
""" Adds a text on the figure.
**Function signature**::
text(x, y, text, ...)
x, and y are the position of the origin of the text. If no z
keyword argument is given, x and y are the 2D projection of the
figure, they belong to [0, 1]. If a z keyword argument is given, the
text is positionned in 3D, in figure coordinnates.
"""
width = Trait(None, None, CFloat, adapts='width',
help="""width of the text.""")
z = Trait(None, None, CFloat,
help="""Optional z position. When specified, the
text is positioned in 3D""")
_target = Instance(modules.Text, ())
opacity = CFloat(1, adapts="property.opacity",
help="""The opacity of the text.""")
def __init__(self, x, y, text, **kwargs):
""" Override init as for different positional arguments."""
if 'z' in kwargs and kwargs['z'] is not None:
self._target.z_position = kwargs['z']
self._target.position_in_3d = True
elif not (x < 1. and x > 0. and y > 0. and y < 1.):
raise ValueError('Text positions should be in [0, 1] if no z'
'position is given')
super(Text, self).__init__(None, **kwargs)
self._target.text = text
self._target.x_position = x
self._target.y_position = y
text = make_function(Text)
###############################################################################
class Text3D(ModuleFactory):
""" Positions text at a 3D location in the scene.
**Function signature**::
text3d(x, y, z, text, ...)
x, y, and z are the position of the origin of the text. The
text is positionned in 3D, in figure coordinnates.
"""
_target = Instance(modules.Text3D, ())
scale = Either(CFloat(1), CArray(shape=(3,)),
help="""The scale of the text, in figure units.
Either a float, or 3-tuple of floats.""")
orientation = CArray(shape=(3,), adapts='orientation',
desc="""the angles giving the orientation of the
text. If the text is oriented to the camera,
these angles are referenced to the axis of the
camera. If not, these angles are referenced to
the z axis.""")
orient_to_camera = true(adapts='orient_to_camera',
desc="""if the text is kept oriented to the
camera, or is pointing in a specific direction,
regardless of the camera position.""")
def __init__(self, x, y, z, text, **kwargs):
""" Override init as for different positional arguments."""
if not 'scale' in kwargs:
kwargs['scale'] = 1
super(Text3D, self).__init__(None, **kwargs)
self._target.text = text
self._target.position = (x, y, z)
def _scale_changed(self):
scale = self.scale
if isinstance(scale, numbers.Number):
scale = scale * np.ones((3,))
self._target.scale = scale
text3d = make_function(Text3D)
#############################################################################
class Title(SingletonModuleFactory):
"""Creates a title for the figure.
**Function signature**::
title(text, ...)
"""
size = CFloat(1, help="the size of the title")
height = CFloat(0.8, adapts='y_position',
help="""height of the title, in portion of the
figure height""")
def _size_changed(self):
self._target.width = min(0.05 * self.size * len(self._text), 1)
self._target.x_position = 0.5 * (1 - self._target.width)
_target = Instance(modules.Text)
def __target_default(self):
""" This is called only if no existing title is found."""
width = min(0.05 * self.size * len(self._text), 1)
text = modules.Text(text=self._text,
y_position=self.height,
x_position=0.5 * (1 - width),)
text.width = width
return text
def __init__(self, text, **kwargs):
self._text = text # This will be used by _size_changed
if not 'name' in kwargs:
# The name is used as au unique marker to identify the
# title. We need to set it ASAP.
self.name = kwargs['name'] = 'Title'
super(Title, self).__init__(**kwargs)
self._target.text = self._text
# We need to set position after Text is initiated, as text will
# override these positions
self._target.y_position = self.height
self._size_changed()
title = make_function(Title)
| dmsurti/mayavi | mayavi/tools/decorations.py | Python | bsd-3-clause | 19,548 | [
"Mayavi",
"VTK"
] | 5dfcca96ed9763ca5efaf6a8d06f96a45533361bfd2d84c81e990d7793095857 |
""" Module with physical constants for use with ipython, profile
"physics".
Definition of Fundamental Physical Constants, CODATA Recommended Values
Source, Peter J. Mohr and Barry N. Taylor,
CODATA Recommended Values of the Fundamental
Physical Constants, 1998
Website: physics.nist.gov/constants
"""
# License: BSD-like
# Copyright: Gael Varoquaux (gael.varoquaux@normalesup.org)
# inspired by maxima's physconst.mac by Cliff Yapp
#from math import * # math MUST be imported BEFORE PhysicalQInteractive
from IPython.Extensions.PhysicalQInteractive import PhysicalQuantityInteractive
# Math constants:
# Pi mathematical constants
pi = 3.141592653589793238462643383279502884197169399375105820974944592
# Universal Constants
#-------------------------------------------------------------------------
c = PhysicalQuantityInteractive(299792458 , 'm/s')
c.__doc__ = """speed of light in vacuum"""
c.__doc__ = "speed of light in vacuum"
u_0 = PhysicalQuantityInteractive(4*pi*1E-7 , 'N/(A**2)')
u_0.__doc__ = """magnetic constant"""
mu_0 = PhysicalQuantityInteractive(4*pi*1E-7 , 'N/(A**2)')
epsilon_0 = PhysicalQuantityInteractive(8.854187817E-12 , 'F/m')
epsilon_0.__doc__ = """electric constant """
Z_0 = PhysicalQuantityInteractive(376.730313461 , 'ohm')
Z_0.__doc__ = """characteristic impedance of vacuum """
G = PhysicalQuantityInteractive(6.673E-11 , 'm**3/(kg*s**2)')
G.__doc__ = """Newtonian constant of gravitation """
h = PhysicalQuantityInteractive(6.62606876E-34 , 'J*s')
h.__doc__ = """Planck constant """
h_eV = PhysicalQuantityInteractive(4.13566727E-15 , 'eV*s')
h_eV.__doc__ = """Planck constant in eVs """
h_bar = PhysicalQuantityInteractive(1.054571596E-34 , 'J*s')
h_bar.__doc__ = """Hbar"""
h_bar_eV = PhysicalQuantityInteractive(6.58211889E-16 , 'eV*s')
h_bar_eV.__doc__ = """Hbar in eV"""
P_m = PhysicalQuantityInteractive(2.1767E-8 , 'kg')
P_m.__doc__ = """Planck mass"""
P_l = PhysicalQuantityInteractive(1.6160E-35 , 'm')
P_l.__doc__ = """Planck length """
P_t = PhysicalQuantityInteractive(5.3906E-44 , 's')
P_t.__doc__ = """Planck time """
# Electromagnetic Constants
#------------------------------------------------------------------------
_e = PhysicalQuantityInteractive(1.602176462E-19 , 'C')
_e.__doc__ = """elementary charge"""
q = _e
capitalphi_0 = PhysicalQuantityInteractive(2.067833636E-15 , 'Wb')
capitalphi_0.__doc__ = """magnetic flux quantum """
mfq_0 = PhysicalQuantityInteractive(2.067833636E-15 , 'Wb')
G_0 = PhysicalQuantityInteractive(7.748091696E-5 , 'S')
G_0.__doc__ = """conductance quantum """
K_J = PhysicalQuantityInteractive(483597.898E9 , 'Hz/V')
K_J.__doc__ = """Josephson constant"""
R_K = PhysicalQuantityInteractive(25812.807572 , 'ohm')
R_K.__doc__ = """von Klitzing constant"""
u_B = PhysicalQuantityInteractive(927.400899E-26 , 'J/T')
u_B.__doc__ = """Bohr magneton"""
ueVT_B = PhysicalQuantityInteractive(5.788381749E-5 , 'eV/T')
ueVT_B.__doc__ = """Bohr magneton in eV T-1"""
u_N = PhysicalQuantityInteractive(5.05078317E-27 , 'J/T')
u_N.__doc__ = """nuclear magneton """
ueVT_N = PhysicalQuantityInteractive(3.152451238E-8 , 'eV/T')
ueVT_N.__doc__ = """nuclear magneton in eV T-1 """
# Atomic and Nuclear Constants
# General
#-------------------------------------------------------------------------
# fine-structure constant
alpha = 7.297352533E-3
Ry = PhysicalQuantityInteractive(10973731.568549 , '1/m')
Ry.__doc__ = """Rydberg constant """
Ry_INF = PhysicalQuantityInteractive(10973731.568549 , '1/m')
a_0 = PhysicalQuantityInteractive(0.5291772083E-10 , 'm')
a_0.__doc__ = """Bohr radius """
E_h = PhysicalQuantityInteractive(4.35974381E-18 , 'J')
E_h.__doc__ = """Hartree energy """
Eev_h = PhysicalQuantityInteractive(27.2113834 , 'eV')
Eev_h.__doc__ = """Hartree energy in eV """
qcir2 = PhysicalQuantityInteractive(3.636947516E-4 , 'm**2/s')
qcir2.__doc__ = """quantum of circulation h/(2me) """
qcir = PhysicalQuantityInteractive(7.273895032E-4 , 'm**2/s')
qcir.__doc__ = """quantum of circulation h/(me) """
# Electroweak
#-------------------------------------------------------------------------
Fcc = PhysicalQuantityInteractive(1.16639E-5 , '1/GeV**2')
Fcc.__doc__ = """Fermi coupling constant """
# weak mixing angled W (on-shell scheme)
wma_W = 0.2224
# Electron, e-
#-------------------------------------------------------------------------
m_e = PhysicalQuantityInteractive(9.10938188E-31 , 'kg')
m_e.__doc__ = """electron mass """
m_e_u = PhysicalQuantityInteractive(5.485799110E-4 , 'amu')
m_e_u.__doc__ = """electron mass (electron relative atomic mass times amu)"""
me_J = PhysicalQuantityInteractive(8.18710414E-14 , 'J')
me_J.__doc__ = """electron mass - energy equivalent """
me_MeV = PhysicalQuantityInteractive(0.510998902 , 'MeV')
me_MeV.__doc__ = """electron mass - energy equivalent in MeV"""
# electron-muon mass ratio
memu = 4.83633210E-3
# electron-tau mass ratio
metau = 2.87555E-4
# electron-proton mass ratio
memp = 5.446170232E-4
# electron-neutron mass ratio
memn = 5.438673462E-4
# electron-deuteron mass ratio
memd = 2.7244371170E-4
# electron to alpha particle mass ratio
memalpha = 1.3709335611E-4
echargeemass = PhysicalQuantityInteractive(-1.758820174E11 , 'C/kg')
echargeemass.__doc__ = """electron charge to mass quotient """
Molar_e = PhysicalQuantityInteractive(5.485799110E-7 , 'kg/mol')
Molar_e.__doc__ = """electron molar mass """
lambdaC = PhysicalQuantityInteractive(2.426310215E-12 , 'm')
lambdaC.__doc__ = """Compton wavelength """
r_e = PhysicalQuantityInteractive(2.817940285E-15 , 'm')
r_e.__doc__ = """classical electron radius """
sigma_e = PhysicalQuantityInteractive(0.665245854E-28 , 'm**2')
sigma_e.__doc__ = """Thomson cross section """
u_e = PhysicalQuantityInteractive(-928.476362E-26 , 'J/T')
u_e.__doc__ = """electron magnetic moment """
# electron magnetic moment to Bohr magneton ratio
ueuB = -1.0011596521869
# electron magnetic moment to nuclear magneton ratio
ueuN = -1838.2819660
# electron magnetic moment anomaly |ue|/uB - 1
a_e = 1.1596521869E-3
# electron g-factor
g_e = -2.0023193043737
# electron-muon magnetic moment ratio
ueuu = 206.7669720
# electron-proton magnetic moment ratio
ueup = -658.2106875
# electron to shielded proton magnetic moment ratio (H2O, sphere, 25 C)
ueusp = -658.2275954
# electron-neutron magnetic moment ratio
ueun = 960.92050
# electron-deuteron magnetic moment ratio
ueud = -2143.923498
# electron to shielded helione magnetic moment ratio (gas, sphere, 25 C)
ueush = 864.058255
gamma_e = PhysicalQuantityInteractive(1.760859794E11 , '1/(s*T)')
gamma_e.__doc__ = """electron gyromagnetic ratio """
# Muon, u-
#-------------------------------------------------------------------------
m_u = PhysicalQuantityInteractive(1.88353109E-28 , 'kg')
m_u.__doc__ = """muon mass """
mu_u = PhysicalQuantityInteractive(0.1134289168 , 'amu')
mu_u.__doc__ = """muon mass in muon relative atomic mass times amu """
muc2_J = PhysicalQuantityInteractive(1.69283332E-11 , 'J')
muc2_J.__doc__ = """energy equivalent """
muc2_MeV = PhysicalQuantityInteractive(105.6583568 , 'MeV')
muc2_MeV.__doc__ = """energy equivalent in MeV """
# muon-electron mass ratio
mume = 206.7682657
# muon-tau mass ratio
mum = 5.94572E-2
# muon-proton mass ratio
mump = 0.1126095173
# muon-neutron mass ratio
mumn = 0.1124545079
Molar_u = PhysicalQuantityInteractive(0.1134289168E-3 , 'kg/mol')
Molar_u.__doc__ = """muon molar mass """
lambda_C_u = PhysicalQuantityInteractive(11.73444197E-15 , 'm')
lambda_C_u.__doc__ = """muon Compton wavelength """
uu = PhysicalQuantityInteractive(-4.49044813E-26 , 'J/T')
uu.__doc__ = """muon magnetic moment """
# ratio of muon magnetic moment to Bohr magneton ratio
uuuB = -4.84197085E-3
# ratio of muon magnetic moment to nuclear magneton ratio
uuuN = -8.89059770
# muon magnetic moment anomaly |uu|/(e /2mu) - 1
a_u = 1.16591602E-3
# muon g-factor -2(1 + au)
g_u = -2.0023318320
# muon-proton magnetic moment ratio
uuup = -3.18334539
# Tau, tau-
#-------------------------------------------------------------------------
m_tau = PhysicalQuantityInteractive(3.16788E-27 , 'kg')
m_tau.__doc__ = """tau mass """
mu_tau = PhysicalQuantityInteractive(1.90774 , 'amu')
mu_tau.__doc__ = """tau mass (tau relative atomic mass times amu) """
mtauc2_J = PhysicalQuantityInteractive(2.84715E-10 , 'J')
mtauc2_J.__doc__ = """tau mass energy equivalent """
mtauc2_MeV = PhysicalQuantityInteractive(1777.05 , 'MeV')
mtauc2_MeV.__doc__ = """tau mass energy equivalent in MeV """
# tau-electron mass ratio
mtaume = 3477.60
# tau-muon mass ratio
mtaumu = 16.8188
# tau-proton mass ratio
mtaump = 1.89396
# tau-neutron mass ratio
mtaumn = 1.89135
Molar_tau = PhysicalQuantityInteractive(1.90774E-3 , 'kg/mol')
Molar_tau.__doc__ = """tau molar mass """
lambda_C_tau = PhysicalQuantityInteractive(0.69770E-15 , 'm')
lambda_C_tau.__doc__ = """tau Compton wavelength """
# Proton, p
#-------------------------------------------------------------------------
m_p = PhysicalQuantityInteractive(1.67262158E-27 , 'kg')
m_p.__doc__ = """proton mass """
mu_p = PhysicalQuantityInteractive(1.00727646688 , 'amu')
mu_p.__doc__ = """proton mass (proton relative atomic mass times amu) """
mpc2_J = PhysicalQuantityInteractive(1.50327731E-10 , 'J')
mpc2_J.__doc__ = """energy equivalent """
mpc2_MeV = PhysicalQuantityInteractive(938.271998 , 'MeV')
mpc2_MeV.__doc__ = """energy equivalent in MeV """
# proton-electron mass ratio
mpme = 1836.1526675
# proton-muon mass ratio
mpmu = 8.88024408
# proton-tau mass ratio
mpmtau = 0.527994
# proton-neutron mass ratio
mpmn = 0.99862347855
emp = PhysicalQuantityInteractive(9.57883408E7 , 'C/kg')
emp.__doc__ = """proton charge to mass quotient """
Molar_p = PhysicalQuantityInteractive(1.00727646688E-3 , 'kg/mol')
Molar_p.__doc__ = """proton molar mass """
lambda_C_p = PhysicalQuantityInteractive(1.321409847E-15 , 'm')
lambda_C_p.__doc__ = """proton Compton wavelength h/mpc """
up = PhysicalQuantityInteractive(1.410606633E-26 , 'J/T')
up.__doc__ = """proton magnetic moment """
# proton magnetic moment to Bohr magneton ratio
upuB = 1.521032203E-3
# proton magnetic moment to nuclear magneton ratio
upuN = 2.792847337
# proton g-factor 2up/uN
g_p = 5.585694675
# proton-neutron magnetic moment ratio
upun = -1.45989805
usp = PhysicalQuantityInteractive(1.410570399E-26 , 'J/T')
usp.__doc__ = """shielded proton magnetic moment (H2O, sphere, 25 C)"""
# shielded proton magnetic moment to Bohr magneton ratio
uspuB = 1.520993132E-3
# shielded proton magnetic moment to nuclear magneton ratio
uspuN = 2.792775597
# proton magnetic shielding correction 1 - u p/up (H2O, sphere, 25 C)
spc = 25.687E-6
gamma_p = PhysicalQuantityInteractive(2.67522212E8 , '1/(s*T)')
gamma_p.__doc__ = """proton gyromagnetic ratio """
gamma_sp = PhysicalQuantityInteractive(2.67515341E8 , '1/(s*T)')
gamma_sp.__doc__ = """shielded proton gyromagnetic ratio (H2O, sphere, 25 C)"""
# Neutron, n
#-------------------------------------------------------------------------
m_n = PhysicalQuantityInteractive(1.67492716E-27 , 'kg')
m_n.__doc__ = """neutron mass """
mu_n = PhysicalQuantityInteractive(1.00866491578 , 'amu')
mu_n.__doc__ = """neutron mass (neutron relative atomic mass times amu) """
mnc2_J = PhysicalQuantityInteractive(1.50534946E-10 , 'J')
mnc2_J.__doc__ = """neutron mass energy equivalent """
mnc2_MeV = PhysicalQuantityInteractive(939.565330 , 'MeV')
mnc2_MeV.__doc__ = """neutron mass energy equivalent in MeV """
# neutron-electron mass ratio
mnme = 1838.6836550
# neutron-muon mass ratio
mnmu = 8.89248478
# neutron-tau mass ratio
mnm = 0.528722
# neutron-proton mass ratio
mnmp = 1.00137841887
Molar_n = PhysicalQuantityInteractive(1.00866491578E-3 , 'kg/mol')
Molar_n.__doc__ = """neutron molar mass """
lambda_C_n = PhysicalQuantityInteractive(1.319590898E-15 , 'm')
lambda_C_n.__doc__ = """neutron Compton wavelength"""
un = PhysicalQuantityInteractive(-0.96623640E-26 , 'J/T')
un.__doc__ = """neutron magnetic moment """
# neutron magnetic moment to Bohr magneton ratio
unuB = -1.04187563E-3
# neutron magnetic moment to nuclear magneton ratio
unuN = -1.91304272
# neutron g-factor
g_n = -3.82608545
# neutron-electron magnetic moment ratio
unue = 1.04066882E-3
# neutron-proton magnetic moment ratio
unup = -0.68497934
# neutron to shielded proton magnetic moment ratio (H2O, sphere, 25 C)
unusp = -0.68499694
gamma_n = PhysicalQuantityInteractive(1.83247188E8 , '1/(s*T)')
gamma_n.__doc__ = """neutron gyromagnetic ratio """
# Deuteron, d
#-------------------------------------------------------------------------
m_d = PhysicalQuantityInteractive(3.34358309E-27 , 'kg')
m_d.__doc__ = """deuteron mass """
mu_d = PhysicalQuantityInteractive(2.01355321271 , 'amu')
mu_d.__doc__ = """deuteron mass (deuteron relative atomic mass times amu) """
mdc2_J = PhysicalQuantityInteractive(3.00506262E-10 , 'J')
mdc2_J.__doc__ = """deuteron mass energy equivalent """
mdc2_eV = PhysicalQuantityInteractive(1875.612762 , 'MeV')
mdc2_eV.__doc__ = """deuteron mass energy equivalent in MeV """
# deuteron-electron mass ratio
mdme = 3670.4829550
# deuteron-proton mass ratio
mdmp = 1.99900750083
Molar_d = PhysicalQuantityInteractive(2.01355321271E-3 , 'kg/mol')
Molar_d.__doc__ = """deuteron molar mass """
ud = PhysicalQuantityInteractive(0.433073457E-26 , 'J/T')
ud.__doc__ = """deuteron magnetic moment """
# deuteron magnetic moment to Bohr magneton ratio
uduB = 0.4669754556E-3
# deuteron magnetic moment to nuclear magneton ratio
uduN = 0.8574382284
# deuteron-electron magnetic moment ratio
udue = -4.664345537E-4
# deuteron-proton magnetic moment ratio
udup = 0.3070122083
# deuteron-neutron magnetic moment ratio
udun = -0.44820652
# Helion, h
#-------------------------------------------------------------------------
m_h = PhysicalQuantityInteractive(5.00641174E-27 , 'kg')
m_h.__doc__ = """helion mass """
mu_h = PhysicalQuantityInteractive(3.01493223469 , 'amu')
mu_h.__doc__ = """helion mass (helion relative atomic mass times amu) """
mhc2_J = PhysicalQuantityInteractive(4.49953848E-10 , 'J')
mhc2_J.__doc__ = """helion mass energy equivalent """
mhc2_MeV = PhysicalQuantityInteractive(2808.39132 , 'MeV')
mhc2_MeV.__doc__ = """helion mass energy equivalent in MeV """
# helion-electron mass ratio
mhme = 5495.885238
# helion-proton mass ratio
mhmp = 2.99315265850
Molar_h = PhysicalQuantityInteractive(3.01493223469E-3 , 'kg/mol')
Molar_h.__doc__ = """helion molar mass """
ush = PhysicalQuantityInteractive(-1.074552967E-26 , 'J/T')
ush.__doc__ = """shielded helion magnetic moment (gas, sphere, 25 C)"""
# shielded helion magnetic moment to Bohr magneton ratio
ushuB = -1.158671474E-3
# shielded helion magnetic moment to nuclear magneton ratio
ushuN = -2.127497718
# shielded helion to proton magnetic moment ratio (gas, sphere, 25 C)
ushup = -0.761766563
# shielded helion to shielded proton magnetic moment ratio (gas/H2O, spheres, 25 C)
ushusp = -0.7617861313
gamma_h = PhysicalQuantityInteractive(2.037894764E8 , '1/(s*T)')
gamma_h.__doc__ = """shielded helion gyromagnetic (gas, sphere, 25 C) """
# Alpha particle,
#-------------------------------------------------------------------------
m_alpha = PhysicalQuantityInteractive(6.64465598E-27 , 'kg')
m_alpha.__doc__ = """alpha particle mass """
mu_alpha = PhysicalQuantityInteractive(4.0015061747 , 'amu')
mu_alpha.__doc__ = """alpha particle mass (alpha particle relative atomic mass times amu) """
malphac2_J = PhysicalQuantityInteractive(5.97191897E-10 , 'J')
malphac2_J.__doc__ = """alpha particle mass energy equivalent """
malphac2_MeV = PhysicalQuantityInteractive(3727.37904 , 'MeV')
malphac2_MeV.__doc__ = """alpha particle mass energy equivalent in MeV """
# alpha particle to electron mass ratio
malphame = 7294.299508
# alpha particle to proton mass ratio
malphamp = 3.9725996846
Molar_alpha = PhysicalQuantityInteractive(4.0015061747E-3 , 'kg/mol')
Molar_alpha.__doc__ = """alpha particle molar mass"""
# PHYSICO-CHEMICAL
#-------------------------------------------------------------------------
N_A = PhysicalQuantityInteractive(6.02214199E23 , '1/mol')
N_A.__doc__ = """Avogadro constant """
L = PhysicalQuantityInteractive(6.02214199E23 , '1/mol')
m_u = PhysicalQuantityInteractive(1.66053873E-27 , 'kg')
m_u.__doc__ = """atomic mass constant mu = 112m(12C) = 1 u = 10E-3 kg mol-1/NA"""
# atomic mass constant mu = 112m(12C) = 1 u = 10E-3 kg mol-1/NA
amu = m_u
muc2_J = PhysicalQuantityInteractive(1.49241778E-10 , 'J')
muc2_J.__doc__ = """energy equivalent of the atomic mass constant"""
muc2_MeV = PhysicalQuantityInteractive(931.494013 , 'MeV')
muc2_MeV.__doc__ = """energy equivalent of the atomic mass constant in MeV """
F = PhysicalQuantityInteractive(96485.3415 , 'C/mol')
F.__doc__ = """Faraday constant"""
N_Ah = PhysicalQuantityInteractive(3.990312689E-10 , 'J*s/mol')
N_Ah.__doc__ = """molar Planck constant """
R = PhysicalQuantityInteractive(8.314472 , 'J/(mol*K)')
R.__doc__ = """molar gas constant """
k_J = PhysicalQuantityInteractive(1.3806503E-23 , 'J/K')
k_J.__doc__ = """Boltzmann constant """
k_eV = PhysicalQuantityInteractive(8.617342E-5 , 'eV/K')
k_eV.__doc__ = """Boltzmann constant in eV """
n_0 = PhysicalQuantityInteractive(2.6867775E25 , '1/m**3')
n_0.__doc__ = """Loschmidt constant NA/Vm """
Vm_1 = PhysicalQuantityInteractive(22.413996E-3 , 'm**3/mol')
Vm_1.__doc__ = """molar volume of ideal gas RT/p T = 273.15 K, p = 101.325 kPa """
Vm_2 = PhysicalQuantityInteractive(22.710981E-3 , 'm**3/mol')
Vm_2.__doc__ = """molar volume of ideal gas RT/p T = 273.15 K, p = 100 kPa """
# Sackur-Tetrode constant (absolute entropy constant) 52 + ln_(2 mukT1/h2)3/2kT1/p0
# T1 = 1 K, p0 = 100 kPa
S_0R_1 = -1.1517048
# T1 = 1 K, p0 = 101.325 kPa
S_0R_2 = -1.1648678
sigma = PhysicalQuantityInteractive(5.670400E-8 , 'W/(m**2*K**4)')
sigma.__doc__ = """Stefan-Boltzmann constant """
c_1 = PhysicalQuantityInteractive(3.74177107E-16 , 'W*m**2')
c_1.__doc__ = """first radiation constant"""
c_1L = PhysicalQuantityInteractive(1.191042722E-16 , 'W*m**2/sr')
c_1L.__doc__ = """first radiation constant for spectral radiance"""
c_2 = PhysicalQuantityInteractive(1.4387752E-2 , 'm*K')
c_2.__doc__ = """second radiation constant"""
b = PhysicalQuantityInteractive(2.8977686E-3 , 'm*K')
b.__doc__ = """Wien displacement law constant b = maxT = c2/4.965 114231... """
| alexdu/robot-sandbox | sim-files/dist/_ipython/ipy_constants.py | Python | gpl-3.0 | 19,500 | [
"Avogadro"
] | 94ac339631fcf703c695e39ed8454f25795bed0a32fcc20d211975a5c7f1570e |
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
#
#
# this is the file to be included by dds_driver.py for product (e.g., espresso) specific setting
#
possible_ivy_dir=[os.path.join(os.environ["HOME"],".m2/repository"),os.path.join(os.environ["HOME"],".gradle/cache"),os.path.join(os.environ["HOME"],".ivy2/lin-cache/ivy-cache"),os.path.join(os.environ["HOME"],".ivy2/lin-cache"),"/ivy/.ivy2/ivy-cache","/ivy/.ivy2", os.path.join(os.environ["VIEW_ROOT"],"build/ivy2/cache")]
zookeeper_classpath="IVY_DIR/org/apache/zookeeper/zookeeper/3.3.3/zookeeper-3.3.3.jar:IVY_DIR/log4j/log4j/1.2.15/log4j-1.2.15.jar"
# espresso use -2
kill_cmd_template="jps | grep %s | cut -f1 -d\\ | xargs kill -2"
kill_container_template="ps -ef | grep tail | grep %s | awk '{print $2}' | xargs kill -9"
# This is not used in helix
afterParsingHook=None
# some global variables
router_http_port=12917
router_mgmt_port=12920
storage_node_http_port=12918
storage_node_mgmt_port=12919
curl_kill_cmd_template="curl -s http://localhost:%d/pid | xargs kill -2"
# used to run cmd, can combine multiple command
cmd_dict={
"storage-node":{"start":"%s; %s" % (curl_kill_cmd_template % storage_node_mgmt_port,"ant -f espresso-storage-node/run/build.xml run-storage-node"),"stop":curl_kill_cmd_template % storage_node_mgmt_port,"stats":[get_stats,"EspressoSingleNode"]}
,"router":{"start":"ant -f espresso-router/run/build.xml run-router","stop":curl_kill_cmd_template % router_mgmt_port,"stats":[get_stats,"EspressoRouter"]}
,"zookeeper":{"start":[zookeeper_opers,"start"],"stop":[zookeeper_opers,"stop"],"wait_for_exist":[zookeeper_opers,"wait_for_exist"],"wait_for_nonexist":[zookeeper_opers,"wait_for_nonexist"],"wait_for_value":[zookeeper_opers,"wait_for_value"],"cmd":[zookeeper_opers,"cmd"]}
,"cluster-manager":{"start":"ant -f cluster-manager/run/build.xml run-cluster-manager", "stop":kill_cmd_template % "HelixControllerMain"}
,"mock-storage":{"start":"ant -f cluster-manager/run/build.xml run-mock-storage", "stop":kill_cmd_template % "MockStorageProcess"}
,"cluster-state-verifier":{"start":"ant -d -f cluster-manager/run/build.xml run-cluster-state-verifier", "stop":kill_cmd_template % "ClusterStateVerifier"}
,"dummy-process":{"start":"ant -f cluster-manager/run/build.xml run-dummy-process", "stop":kill_cmd_template % "DummyProcess"}
,"mock-health-report-process":{"start":"ant -f cluster-manager/run/build.xml run-mock-health-report-process", "stop":kill_cmd_template % "MockHealthReportParticipant"}
,"clm_console":{"default":"ant -f cluster-manager/run/build.xml run-cm-console","stop":kill_cmd_template % "ClusterSetup"}
}
cmd_ret_pattern={ # the pattern when the call is considered return successfully
"storage-node_start":re.compile("Espresso service started")
,"router_start":re.compile("Espresso service started")
,"cluster-manager_start":re.compile("No Messages to process")
,"mock-storage_start":re.compile("Mock storage started")
,"dummy-process_start":re.compile("Dummy process started")
,"mock-health-report-process_start":re.compile("MockHealthReportParticipant process started")
}
# the mapping of option to the java options, if not give, then use directly
direct_java_call_option_mapping={
"dump_file":"-f "
,"value_file":"--value.dump.file="
#,"log4j_file":"-Dlog4j.configuration=file://" # this is only for cluster manager
#,"log4j_file":"--log_props="
,"config":"--container_props="
,"consumer_event_pattern":"event_pattern"
,"cmdline_props":"--cmdline_props="
,"cmdline_args":" " # just put the cmdline_args directly
,"relay_host":"--relay_host="
,"relay_port":"--relay_port="
#,"jmx_service_port":"--jmx_service_port="
,"bootstrap_host":"--bootstrap_host="
,"bootstrap_port":"--bootstrap_port="
,"http_port":"--http_port="
,"checkpoint_dir":"--checkpoint_dir="
,"dbname":"--dbname="
,"tablename":"--tablename="
,"dburi":"--dburi="
,"dbuser":"--dbuser="
,"dbpasswd":"--dbpassword="
,"schemareg":"--schemareg="
,"schemareg":"--schemareg="
,"db_relay_config":"--db_relay_config="
}
# has default value, append to the beginning
direct_java_call_jvm_args={
"jvm_direct_memory_size":["-XX:MaxDirectMemorySize=","100m"]
,"jvm_max_heap_size":["-Xmx","512m"]
,"jvm_min_heap_size":["-Xms","100m"]
,"jvm_gc_log":["-Xloggc:",""]
,"jvm_args":["",""]
,"log4j_file":["-Dlog4j.configuration=file://",""] # this is only for cluster manager
}
direct_java_call_jvm_args_ordered=[
"jvm_direct_memory_size"
,"jvm_max_heap_size"
,"jvm_min_heap_size"
,"jvm_gc_log"
,"jvm_args"
,"log4j_file"
]
# mapping from option to ant
ant_call_option_mapping={
"dump_file":"dump.file"
,"value_file":"value.dump.file"
,"log4j_file":"log4j.file"
,"config":"config.file"
,"jvm_direct_memory_size":"jvm.direct.memory.size"
,"jvm_max_heap_size":"jvm.max.heap.size"
,"jvm_gc_log":"jvm.gc.log"
,"jvm_args":"jvm.args"
,"cmdline_props":"cmdline.props"
,"cmdline_args":"config.cmdline"
,"relay_host":"relay.host"
,"relay_port":"relay.port"
#,"jmx_service_port":"jmx.service.port"
,"bootstrap_host":"bootstrap.host"
,"bootstrap_port":"bootstrap.port"
,"consumer_event_pattern":"consumer.event.pattern"
,"http_port":"http.port"
,"checkpoint_dir":"checkpoint.dir"
# ,"db_relay_config":"db.relay.config"
}
# class path
import glob
#print "view_root=" + get_view_root()
cm_jar_files=glob.glob(os.path.join(get_view_root(),"../../../target/helix-core-*.jar"))
#cm_jar_file=os.path.basename(cm_jar_file)
#print cm_jar_file
cmd_direct_call={
"clm_console":
{
"class_path":[
"IVY_DIR/com/github/sgroschupf/zkclient/0.1/zkclient-0.1.jar"
,"IVY_DIR/com/thoughtworks/xstream/xstream/1.3.1/xstream-1.3.1.jar"
,"IVY_DIR/commons-cli/commons-cli/1.2/commons-cli-1.2.jar"
,"IVY_DIR/commons-io/commons-io/1.4/commons-io-1.4.jar"
,"IVY_DIR/commons-lang/commons-lang/2.4/commons-lang-2.4.jar"
,"IVY_DIR/jdom/jdom/1.0/jdom-1.0.jar"
,"IVY_DIR/log4j/log4j/1.2.15/log4j-1.2.15.jar"
,"IVY_DIR/org/apache/zookeeper/zookeeper/3.3.3/zookeeper-3.3.3.jar"
,"IVY_DIR/com/fasterxml/jackson/core/jackson-databind/2.11.0/jackson-databind-2.11.0.jar"
,"IVY_DIR/com/fasterxml/jackson/core/jackson-core/2.11.0/jackson-core-2.11.0.jar"
,"IVY_DIR/xpp3/xpp3_min/1.1.4c/xpp3_min-1.1.4c.jar"
,"IVY_DIR/org/restlet/org.restlet/1.1.10/org.restlet-1.1.10.jar"
,"IVY_DIR/com/noelios/restlet/com.noelios.restlet/1.1.10/com.noelios.restlet-1.1.10.jar"
]+cm_jar_files
,"class_name":"org.apache.helix.tools.ClusterSetup"
,"before_cmd":"../../../mvn package -Dmaven.test.skip.exec=true" # build jar first
}
,"dummy-process":
{
"class_path":[
"IVY_DIR/com/thoughtworks/xstream/xstream/1.3.1/xstream-1.3.1.jar"
,"IVY_DIR/commons-cli/commons-cli/1.2/commons-cli-1.2.jar"
,"IVY_DIR/commons-io/commons-io/1.4/commons-io-1.4.jar"
,"IVY_DIR/commons-lang/commons-lang/2.4/commons-lang-2.4.jar"
,"IVY_DIR/jdom/jdom/1.0/jdom-1.0.jar"
,"IVY_DIR/log4j/log4j/1.2.15/log4j-1.2.15.jar"
,"IVY_DIR/org/apache/zookeeper/zookeeper/3.3.3/zookeeper-3.3.3.jar"
,"IVY_DIR/com/fasterxml/jackson/core/jackson-databind/2.11.0/jackson-databind-2.11.0.jar"
,"IVY_DIR/com/fasterxml/jackson/core/jackson-core/2.11.0/jackson-core-2.11.0.jar"
,"IVY_DIR/xpp3/xpp3_min/1.1.4c/xpp3_min-1.1.4c.jar"
,"IVY_DIR/com/github/sgroschupf/zkclient/0.1/zkclient-0.1.jar"
,"IVY_DIR/org/apache/commons/commons-math/2.1/commons-math-2.1.jar"
]+cm_jar_files
,"class_name":"org.apache.helix.mock.participant.DummyProcess"
,"before_cmd":"../../../mvn package -Dmaven.test.skip.exec=true" # build jar first
}
,"mock-health-report-process":
{
"class_path":[
"IVY_DIR/com/thoughtworks/xstream/xstream/1.3.1/xstream-1.3.1.jar"
,"IVY_DIR/commons-cli/commons-cli/1.2/commons-cli-1.2.jar"
,"IVY_DIR/commons-io/commons-io/1.4/commons-io-1.4.jar"
,"IVY_DIR/commons-lang/commons-lang/2.4/commons-lang-2.4.jar"
,"IVY_DIR/jdom/jdom/1.0/jdom-1.0.jar"
,"IVY_DIR/log4j/log4j/1.2.15/log4j-1.2.15.jar"
,"IVY_DIR/org/apache/zookeeper/zookeeper/3.3.3/zookeeper-3.3.3.jar"
,"IVY_DIR/com/fasterxml/jackson/core/jackson-databind/2.11.0/jackson-databind-2.11.0.jar"
,"IVY_DIR/com/fasterxml/jackson/core/jackson-core/2.11.0/jackson-core-2.11.0.jar"
,"IVY_DIR/xpp3/xpp3_min/1.1.4c/xpp3_min-1.1.4c.jar"
,"IVY_DIR/com/github/sgroschupf/zkclient/0.1/zkclient-0.1.jar"
,"IVY_DIR/org/apache/commons/commons-math/2.1/commons-math-2.1.jar"
,"IVY_DIR/org/restlet/org.restlet/1.1.10/org.restlet-1.1.10.jar"
,"IVY_DIR/com/noelios/restlet/com.noelios.restlet/1.1.10/com.noelios.restlet-1.1.10.jar"
]+cm_jar_files
,"class_name":"org.apache.helix.mock.participant.MockHealthReportParticipant"
,"before_cmd":"../../../mvn package -Dmaven.test.skip.exec=true" # build jar first
}
,"cluster-manager":
{
"class_path":[
"IVY_DIR/com/thoughtworks/xstream/xstream/1.3.1/xstream-1.3.1.jar"
,"IVY_DIR/commons-cli/commons-cli/1.2/commons-cli-1.2.jar"
,"IVY_DIR/commons-io/commons-io/1.4/commons-io-1.4.jar"
,"IVY_DIR/commons-lang/commons-lang/2.4/commons-lang-2.4.jar"
,"IVY_DIR/jdom/jdom/1.0/jdom-1.0.jar"
,"IVY_DIR/log4j/log4j/1.2.15/log4j-1.2.15.jar"
,"IVY_DIR/org/apache/zookeeper/zookeeper/3.3.3/zookeeper-3.3.3.jar"
,"IVY_DIR/org/com/fasterxml/jackson/core/jackson-databind/2.11.0/jackson-databind-2.11.0.jar"
,"IVY_DIR/com/fasterxml/jackson/core/jackson-core/2.11.0/jackson-core-2.11.0.jar"
,"IVY_DIR/xpp3/xpp3_min/1.1.4c/xpp3_min-1.1.4c.jar"
,"IVY_DIR/com/github/sgroschupf/zkclient/0.1/zkclient-0.1.jar"
,"IVY_DIR/org/apache/commons/commons-math/2.1/commons-math-2.1.jar"
,"IVY_DIR/org/restlet/org.restlet/1.1.10/org.restlet-1.1.10.jar"
,"IVY_DIR/com/noelios/restlet/com.noelios.restlet/1.1.10/com.noelios.restlet-1.1.10.jar"
]+cm_jar_files
,"class_name":"org.apache.helix.controller.HelixControllerMain"
,"before_cmd":"../../../mvn package -Dmaven.test.skip.exec=true" # build jar first
}
,"cluster-state-verifier":
{
"class_path":[
"IVY_DIR/com/github/sgroschupf/zkclient/0.1/zkclient-0.1.jar"
,"IVY_DIR/com/thoughtworks/xstream/xstream/1.3.1/xstream-1.3.1.jar"
,"IVY_DIR/commons-cli/commons-cli/1.2/commons-cli-1.2.jar"
,"IVY_DIR/commons-io/commons-io/1.4/commons-io-1.4.jar"
,"IVY_DIR/commons-lang/commons-lang/2.4/commons-lang-2.4.jar"
,"IVY_DIR/jdom/jdom/1.0/jdom-1.0.jar"
,"IVY_DIR/log4j/log4j/1.2.15/log4j-1.2.15.jar"
,"IVY_DIR/org/apache/zookeeper/zookeeper/3.3.3/zookeeper-3.3.3.jar"
,"IVY_DIR/com/fasterxml/jackson/core/jackson-databind/2.11.0/jackson-databind-2.11.0.jar"
,"IVY_DIR/com/fasterxml/jackson/core/jackson-core/2.11.0/jackson-core-2.11.0.jar"
,"IVY_DIR/xpp3/xpp3_min/1.1.4c/xpp3_min-1.1.4c.jar"
,"IVY_DIR/org/restlet/org.restlet/1.1.10/org.restlet-1.1.10.jar"
,"IVY_DIR/com/noelios/restlet/com.noelios.restlet/1.1.10/com.noelios.restlet-1.1.10.jar"
]+cm_jar_files
,"class_name":"org.apache.helix.tools.ClusterStateVerifier"
,"before_cmd":"../../../mvn package -Dmaven.test.skip.exec=true" # build jar first
}
,"mock-storage":
{
"class_path":[
"IVY_DIR/com/github/sgroschupf/zkclient/0.1/zkclient-0.1.jar"
,"IVY_DIR/log4j/log4j/1.2.15/log4j-1.2.15.jar"
,"IVY_DIR/commons-cli/commons-cli/1.2/commons-cli-1.2.jar"
,"IVY_DIR/commons-math/commons-math/2.1/commons-math-2.1.jar"
]+cm_jar_files
,"class_name":"org.apache.helix.mock.participant.MockStorageProcess"
}
}
# file the log4j file
def log4j_file_store_value(option, opt_str, value, parser):
setattr(parser.values, option.dest, file_exists(value))
# configure
config_group = OptionGroup(parser, "Config options", "")
config_group.add_option("-p", "--config", action="store", dest="config", default=None,
help="config file path")
config_group.add_option("--dump_file", action="store", dest="dump_file", default=None,
help="Event dump file")
config_group.add_option("--value_file", action="store", dest="value_file", default=None,
help="Event value dump file")
config_group.add_option("-l", "--log4j_file", action="callback", callback=log4j_file_store_value, type="str", dest="log4j_file", default=None,
help="Log4j config file")
#config_group.add_option("-l", "--log4j_file", action="store", dest="log4j_file", default=None,
# help="Log4j config file")
config_group.add_option("--relay_host", action="store", dest="relay_host", default=None,
help="Host of relay for a consumer")
config_group.add_option("--relay_port", action="store", dest="relay_port", default=None,
help="Port of relay for a consumer")
config_group.add_option("--http_port", action="store", dest="http_port", default=None,
help="Http Port of the current started component")
config_group.add_option("--db_relay_config", action="store", dest="db_relay_config", default=None,
help="DB relay config file")
config_group.add_option("--cmdline_props", action="store", dest="cmdline_props", default=None,
help="Command line config props. Comma separate config parameter, e.g., --cmdline_props=databus.relay.eventBuffer.maxSize=1024000;...")
config_group.add_option("--bootstrap_host", action="store", dest="bootstrap_host", default=None,
help="Host of bootstrap server")
config_group.add_option("--bootstrap_port", action="store", dest="bootstrap_port", default=None,
help="Port of bootstrap server")
config_group.add_option("--checkpoint_dir", action="store", dest="checkpoint_dir", default=None,
help="Client checkpoint dir")
config_group.add_option("--checkpoint_keep", action="store_true", dest="checkpoint_keep", default=False,
help="Do NOT clean client checkpoint dir")
config_group.add_option("--consumer_event_pattern", action="store", dest="consumer_event_pattern", default=None,
help="Check consumer event pattern if set")
config_group.add_option("--dbname", action="store", dest="dbname", default=None, help="Espresso db name")
config_group.add_option("--tablename", action="store", dest="tablename", default=None, help="Espresso table name")
config_group.add_option("--dburi", action="store", dest="dburi", default=None, help="Espresso db uri")
config_group.add_option("--dbuser", action="store", dest="dbuser", default=None, help="Espresso db user")
config_group.add_option("--dbpasswd", action="store", dest="dbpasswd", default=None, help="Espresso db password")
config_group.add_option("--schemareg", action="store", dest="schemareg", default=None, help="Espresso schemareg ")
config_group.add_option("-x","--extservice_props", action="append", dest="extservice_props", default=None,
help="Config props to override the extservices. Can give multiple times. One for each property. <entry name>;<prop name>;value. e.g., databus2.relay.local.bizfollow;db.bizfollow.db_url;jdbc.. ")
config_group.add_option("--cmdline_args", action="store", dest="cmdline_args", default=None, help="Command line arguments")
other_option_group = OptionGroup(parser, "Other options", "")
other_option_group.add_option("", "--component_id", action="store", dest="component_id", default = None,
help="The compnent id (1,2..) if there are mutliple instance of a component")
parser.add_option("","--sleep_before_wait", action="store", type="long", dest="sleep_before_wait", default=0,
help="Sleep secs before waiting consumer reaching maxEventWindowScn. [default: %default]")
parser.add_option("","--sleep_after_wait", action="store", type="long", dest="sleep_after_wait", default=1,
help="Sleep secs after consumer reaching maxEventWindowScn. [default: %default]")
parser.add_option("","--producer_log_purge_limit", action="store", type="int", dest="producer_log_purge_limit", default=1000,
help="The limit on number of logs to purge for producer [default: %default]")
| dasahcc/helix | helix-core/src/main/scripts/integration-test/script/driver_cmd_dict.py | Python | apache-2.0 | 17,093 | [
"ESPResSo"
] | fd68ddf6d1a439c52df6c1623e9e2779b4f55c320f453b2ed1ea3a1c4313006d |
import lmfit
import numpy
import scipy.optimize
import numbers
import copy
import suspect.basis
def complex_to_real(complex_fid):
"""
Standard optimization routines as used in lmfit require real data. This
function takes a complex FID and constructs a real version by concatenating
the imaginary part to the complex part. The imaginary part is also reversed
to keep the maxima at each end of the FID and avoid discontinuities in the
center.
:param complex_fid: the complex FID to be converted to real.
:return: the real FID, which has twice as many points as the input.
"""
np = complex_fid.shape[0]
real_fid = numpy.zeros(np * 2)
real_fid[:np] = complex_fid.real
real_fid[np:] = complex_fid.imag[::-1]
return real_fid
def real_to_complex(real_fid):
"""
Standard optimization routines as used in lmfit require real data. This
function takes a real FID generated from the optimization routine and
converts it back into a true complex form.
:param real_fid: the real FID to be converted to complex.
:return: the complex version of the FID
"""
np = int(real_fid.shape[0] / 2)
complex_fid = numpy.zeros(np, 'complex')
complex_fid[:] = real_fid[:np]
# the imaginary part of the FID has been reversed, have to flip it back
imag_fid = real_fid[np:]
complex_fid += 1j * imag_fid[::-1]
return complex_fid
def fit(fid, model, baseline_points=16):
"""
Fit fid with model parameters.
:param fid: MRSData object of FID to be fit
:param model: dictionary model of fit parameters
:param baseline_points: the number of points at the start of the FID to ignore
:return: Dictionary containing ["model": optimized model, "fit": fitting data, "err": dictionary of standard errors]
"""
# Get list of metabolite names.
def get_metabolites(model_input):
metabolites = []
for fid_property_name, fid_property_value in model_input.items():
if type(fid_property_value) is dict:
metabolites.append(fid_property_name)
return metabolites
# Get standard errors from lmfit MinimizerResult object.
def get_errors(result):
errors = {}
for name, param in result.params.items():
errors[name] = param.stderr
return errors
def phase_fid(fid_in, phase0, phase1):
"""
This function performs a Fourier Transform on the FID to shift it into phase.
:param fid_in: FID to be fitted.
:param phase1: phase1 value.
:param phase0: phase0 value.
:return: FID that has been shifted into phase by FFT
"""
spectrum = numpy.fft.fftshift(numpy.fft.fft(fid_in))
np = fid_in.np
phase_shift = phase0 + phase1 * numpy.linspace(-np / 2, np / 2, np, endpoint=False)
phased_spectrum = spectrum * numpy.exp(1j * phase_shift)
return fid_in.inherit(numpy.fft.ifft(numpy.fft.ifftshift(phased_spectrum)))
def make_basis(params, time_axis):
"""
This function generates a basis set.
:param params: lmfit Parameters object containing fitting parameters.
:param time_axis: the time axis.
:return: a matrix containing the generated basis set.
"""
basis_matrix = numpy.matrix(numpy.zeros((len(metabolite_name_list), len(time_axis) * 2)))
for i, metabolite_name in enumerate(metabolite_name_list):
gaussian = suspect.basis.gaussian(time_axis,
params["{}_frequency".format(metabolite_name)],
params["{}_phase".format(metabolite_name)].value,
params["{}_fwhm".format(metabolite_name)])
real_gaussian = complex_to_real(gaussian)
basis_matrix[i, :] = real_gaussian
return basis_matrix
def unphase(data, params):
unphased_data = phase_fid(data, -params['phase0'], -params['phase1'])
real_unphased_data = complex_to_real(unphased_data)
return real_unphased_data
def do_fit(params, time_axis, real_unphased_data):
"""
This function performs the fitting.
:param params: lmfit Parameters object containing fitting parameters.
:param time_axis: the time axis.
:param real_unphased_data:
:return: List of fitted data points and amplitudes of each singlet.
"""
basis = make_basis(params, time_axis)
weights = scipy.optimize.nnls(basis[:, baseline_points:-baseline_points].T,
real_unphased_data[baseline_points:-baseline_points])[0]
fitted_data = numpy.array(numpy.dot(weights, basis)).squeeze()
return fitted_data, weights
def residual(params, time_axis, data):
"""
This function calculates the residual to be minimized by the least squares means method.
:param params: lmfit Parameters object containing fitting parameters.
:param time_axis: the time axis.
:param data: FID to be fitted.
:return: residual values of baseline points.
"""
real_unphased_data = unphase(data, params)
fitted_data, weights = do_fit(params, time_axis, real_unphased_data)
res = fitted_data - real_unphased_data
return res[baseline_points:-baseline_points]
def fit_data(data, initial_params):
"""
This function takes an FID and a set of parameters contained in an lmfit Parameters object,
and fits the data using the least squares means method.
:param data: FID to be fitted.
:param initial_params: lmfit Parameters object containing fitting parameters.
:return: tuple of weights as a list, data as a list, and result as an lmift MinimizerResult object.
"""
fitting_result = lmfit.minimize(residual,
initial_params,
args=(data.time_axis(), data),
xtol=5e-3)
real_fitted_data, fitting_weights = do_fit(fitting_result.params, data.time_axis(), unphase(data, fitting_result.params))
fitted_data = real_to_complex(real_fitted_data)
return fitting_weights, fitted_data, fitting_result
# Convert lmfit parameters to model format
def parameters_to_model(parameters_obj, param_weights):
new_model = {}
for param_name, param in parameters_obj.items():
name = param_name.split("_")
name1 = name[0]
if len(name) == 1: # i.e. phase
new_model[name1] = param.value
else:
name2 = name[1]
if name1 not in new_model:
new_model[name1] = {name2: param.value}
else:
new_model[name1][name2] = param.value
for i, metabolite_name in enumerate(metabolite_name_list):
new_model[metabolite_name]["amplitude"] = param_weights[i]
return new_model
# Convert initial model to lmfit parameters.
def model_to_parameters(model_dict):
lmfit_parameters = lmfit.Parameters()
params = []
ordered_params = []
# Calculate dependencies/references for each parameter.
depend_dict = calculate_dependencies(model_dict)
model_dict_copy = copy.deepcopy(model_dict)
params.append(("phase0", model_dict_copy.pop("phase0")))
params.append(("phase1", model_dict_copy.pop("phase1")))
# Construct lmfit Parameter input for each parameter.
for peak_name, peak_properties in model_dict_copy.items():
# Fix phase value to 0 by default.
if "phase" not in peak_properties:
params.append(("{0}_{1}".format(peak_name, "phase"), None, None, None, None, "0"))
for property_name, property_value in peak_properties.items():
# Initialize lmfit parameter arguments.
name = "{0}_{1}".format(peak_name, property_name)
value = None
vary = True
lmfit_min = None
lmfit_max = None
expr = None
if isinstance(property_value, numbers.Number):
value = property_value
elif isinstance(property_value, str):
expr = property_value
elif isinstance(property_value, dict):
if "value" in property_value:
value = property_value["value"]
if "min" in property_value:
lmfit_min = property_value["min"]
if "max" in property_value:
lmfit_max = property_value["max"]
# Add parameter object with defined parameters.
params.append((name, value, vary, lmfit_min, lmfit_max, expr)) # (lmfit Parameter input format)
# Order parameters based on dependencies.
in_oparams = []
while len(params) > 0:
front = params.pop(0)
name = front[0]
# If no dependencies, add parameter to list and mark parameter as added.
if name not in depend_dict or depend_dict[name] is None:
ordered_params.append(front)
in_oparams.append(name)
else:
dependencies_present = True
for dependency in depend_dict[name]:
# If dependency not yet added, mark parameter to move to back of queue.
if dependency not in in_oparams:
dependencies_present = False
# If all dependencies present, add parameter to list and mark parameter as added.
if dependencies_present:
ordered_params.append(front)
in_oparams.append(name)
# If dependencies missing, move parameter to back of queue.
else:
params.append(front)
# Convert all parameters to lmfit Parameter objects.
lmfit_parameters.add_many(*ordered_params)
return lmfit_parameters
# Check if all model input types are correct.
def check_errors(check_model):
# Allowed keys in the model.
allowed_keys = ["min", "max", "value", "phase", "amplitude"]
# Scan model.
for model_property, model_values in check_model.items():
if not isinstance(model_values, (numbers.Number, dict)):
raise TypeError("Value of {0} must be a number (for phases), or a dictionary.".format(model_property))
elif type(model_values) is dict: # i.e. type(value) is not int
for peak_property, peak_value in model_values.items():
if not isinstance(peak_value,(numbers.Number,dict,str)):
raise TypeError("Value of {0}_{1} must be a value, an expression, or a dictionary."
.format(model_property, peak_property))
if type(peak_value) is dict:
for width_param in peak_value:
# Dictionary must have 'value' key.
if "value" not in peak_value:
raise KeyError("Dictionary {0}_{1} is missing 'value' key."
.format(model_property, peak_property))
# Dictionary can only have 'min,' 'max,' and 'value'.
if width_param not in allowed_keys:
raise KeyError("In {0}_{1}, '{2}' is not an allowed key."
.format(model_property, peak_property, width_param))
# Calculate references to determine order for Parameters.
def calculate_dependencies(unordered_model):
dependencies = {} # (name, [dependencies])
# Compile dictionary of effective names.
for model_property, model_values in unordered_model.items():
if type(model_values) is dict: # i.e. pcr, not phase
for peak_property in model_values:
dependencies["{0}_{1}".format(model_property, peak_property)] = None
# Find dependencies for each effective name.
for model_property, model_values in unordered_model.items():
if type(model_values) is dict: # i.e. not phase
for peak_property, peak_value in model_values.items():
if type(peak_value) is str:
lmfit_name = "{0}_{1}".format(model_property, peak_property)
dependencies[lmfit_name] = []
for depend in dependencies:
if depend in peak_value:
dependencies[lmfit_name].append(depend)
# Check for circular dependencies.
for name, dependents in dependencies.items():
if type(dependents) is list:
for dependent in dependents:
if dependencies[dependent] is not None and name in dependencies[dependent]:
raise ReferenceError("{0} and {1} reference each other, creating a circular reference."
.format(name, dependent))
return dependencies
# Do singlet fitting
# Minimize and fit 31P data.
check_errors(model) # Check for errors in model formatting.
metabolite_name_list = get_metabolites(model) # Set list of metabolite names.
parameters = model_to_parameters(model) # Convert model to lmfit Parameters object.
fitted_weights, fitted_data, fitted_results = fit_data(fid, parameters) # Fit data.
final_model = parameters_to_model(fitted_results.params, fitted_weights) # Convert fit parameters to model format.
stderr = get_errors(fitted_results) # Get stderr values for each parameter.
return_dict = {"model": final_model, "fit": fitted_data, "errors": stderr} # Compile output into a dictionary.
return return_dict
| bennyrowland/suspect | suspect/fitting/singlet.py | Python | mit | 14,306 | [
"Gaussian"
] | 81251b07f4a02618a502e413d5c8aa809603f94361916f11daad719502dc6a5e |
#
# Gramps - a GTK+/GNOME based genealogy program
#
# Copyright (C) 2001-2007 Donald N. Allingham
# Copyright (C) 2008 Lukasz Rymarczyk
# Copyright (C) 2008 Raphael Ackermann
# Copyright (C) 2008-2011 Brian G. Matherly
# Copyright (C) 2010 Jakim Friant
# Copyright (C) 2011-2013 Paul Franklin
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
#
# cli.plug.__init__
#
#-------------------------------------------------------------------------
#
# Python modules
#
#-------------------------------------------------------------------------
from __future__ import print_function
import traceback
import os
import sys
import logging
log = logging.getLogger(".")
#-------------------------------------------------------------------------
#
# Gramps modules
#
#-------------------------------------------------------------------------
from gramps.gen.plug import BasePluginManager
from gramps.gen.plug.docgen import (StyleSheet, StyleSheetList, PaperStyle,
PAPER_PORTRAIT, PAPER_LANDSCAPE, graphdoc)
from gramps.gen.plug.menu import (FamilyOption, PersonOption, NoteOption,
MediaOption, PersonListOption, NumberOption,
BooleanOption, DestinationOption, StringOption,
TextOption, EnumeratedListOption, Option)
from gramps.gen.display.name import displayer as name_displayer
from gramps.gen.errors import ReportError, FilterError
from gramps.gen.plug.report import (CATEGORY_TEXT, CATEGORY_DRAW, CATEGORY_BOOK,
CATEGORY_GRAPHVIZ, CATEGORY_CODE,
ReportOptions, append_styles)
from gramps.gen.plug.report._paper import paper_sizes
from gramps.gen.const import USER_HOME
from gramps.gen.dbstate import DbState
from gramps.gen.constfunc import STRTYPE, conv_to_unicode_direct
from ..grampscli import CLIManager
from ..user import User
from gramps.gen.const import GRAMPS_LOCALE as glocale
_ = glocale.translation.gettext
#------------------------------------------------------------------------
#
# Private Functions
#
#------------------------------------------------------------------------
def _convert_str_to_match_type(str_val, type_val):
"""
Returns a value representing str_val that is the same type as type_val.
"""
str_val = str_val.strip()
ret_type = type(type_val)
if isinstance(type_val, STRTYPE):
if ( str_val.startswith("'") and str_val.endswith("'") ) or \
( str_val.startswith('"') and str_val.endswith('"') ):
# Remove enclosing quotes
return conv_to_unicode_direct(str_val[1:-1])
else:
return conv_to_unicode_direct(str_val)
elif ret_type == int:
if str_val.isdigit():
return int(str_val)
else:
print("'%s' is not an integer number" % str_val)
return 0
elif ret_type == float:
try:
return float(str_val)
except ValueError:
print("'%s' is not a decimal number" % str_val)
return 0.0
elif ret_type == bool:
if str_val == str(True):
return True
elif str_val == str(False):
return False
else:
print("'%s' is not a boolean-- try 'True' or 'False'" % str_val)
return False
elif ret_type == list:
ret_val = []
if not ( str_val.startswith("[") and str_val.endswith("]") ):
print("'%s' is not a list-- try: [%s]" % (str_val, str_val))
return ret_val
entry = ""
quote_type = None
# Search through characters between the brackets
for char in str_val[1:-1]:
if (char == "'" or char == '"') and quote_type == None:
# This character starts a string
quote_type = char
elif char == quote_type:
# This character ends a string
quote_type = None
elif quote_type == None and char == ",":
# This character ends an entry
ret_val.append(entry.strip())
entry = ""
quote_type = None
else:
entry += char
if entry != "":
# Add the last entry
ret_val.append(entry.strip())
return ret_val
def _validate_options(options, dbase):
"""
Validate all options by making sure that their values are consistent with
the database.
menu: The Menu class
dbase: the database the options will be applied to
"""
if not hasattr(options, "menu"):
return
menu = options.menu
for name in menu.get_all_option_names():
option = menu.get_option_by_name(name)
if isinstance(option, PersonOption):
pid = option.get_value()
person = dbase.get_person_from_gramps_id(pid)
if not person:
person = dbase.get_default_person()
if not person:
try:
phandle = next(dbase.iter_person_handles())
except StopIteration:
phandle = None
person = dbase.get_person_from_handle(phandle)
if not person:
print(_("ERROR: Please specify a person"),
file=sys.stderr)
if person:
option.set_value(person.get_gramps_id())
elif isinstance(option, FamilyOption):
fid = option.get_value()
family = dbase.get_family_from_gramps_id(fid)
if not family:
person = dbase.get_default_person()
family_list = []
family_handle = None
if person:
family_list = person.get_family_handle_list()
if family_list:
family_handle = family_list[0]
else:
try:
family_handle = next(dbase.iter_family_handles())
except StopIteration:
family_handle = None
if family_handle:
family = dbase.get_family_from_handle(family_handle)
option.set_value(family.get_gramps_id())
else:
print(_("ERROR: Please specify a family"), file=sys.stderr)
#------------------------------------------------------------------------
#
# Command-line report
#
#------------------------------------------------------------------------
class CommandLineReport(object):
"""
Provide a way to generate report from the command line.
"""
def __init__(self, database, name, category, option_class, options_str_dict,
noopt=False):
pmgr = BasePluginManager.get_instance()
self.__textdoc_plugins = []
self.__drawdoc_plugins = []
self.__bookdoc_plugins = []
for plugin in pmgr.get_docgen_plugins():
if plugin.get_text_support() and plugin.get_extension():
self.__textdoc_plugins.append(plugin)
if plugin.get_draw_support() and plugin.get_extension():
self.__drawdoc_plugins.append(plugin)
if plugin.get_text_support() and \
plugin.get_draw_support() and \
plugin.get_extension():
self.__bookdoc_plugins.append(plugin)
self.database = database
self.category = category
self.format = None
self.raw_name = name
self.option_class = option_class(name, database)
if category == CATEGORY_GRAPHVIZ:
# Need to include GraphViz options
self.__gvoptions = graphdoc.GVOptions()
menu = self.option_class.menu
self.__gvoptions.add_menu_options(menu)
for name in menu.get_all_option_names():
if name not in self.option_class.options_dict:
self.option_class.options_dict[name] = \
menu.get_option_by_name(name).get_value()
self.option_class.load_previous_values()
_validate_options(self.option_class, database)
self.show = options_str_dict.pop('show', None)
self.options_str_dict = options_str_dict
self.init_standard_options(noopt)
self.init_report_options()
self.parse_options()
self.init_report_options_help()
self.show_options()
def init_standard_options(self, noopt):
"""
Initialize the options that are hard-coded into the report system.
"""
self.options_dict = {
'of' : self.option_class.handler.module_name,
'off' : self.option_class.handler.get_format_name(),
'style' : \
self.option_class.handler.get_default_stylesheet_name(),
'papers' : self.option_class.handler.get_paper_name(),
'papero' : self.option_class.handler.get_orientation(),
'paperml' : self.option_class.handler.get_margins()[0],
'papermr' : self.option_class.handler.get_margins()[1],
'papermt' : self.option_class.handler.get_margins()[2],
'papermb' : self.option_class.handler.get_margins()[3],
'css' : self.option_class.handler.get_css_filename(),
}
self.options_help = {
'of' : [_("=filename"), _("Output file name. MANDATORY"),""],
'off' : [_("=format"), _("Output file format."), []],
'style' : [_("=name"), _("Style name."), ""],
'papers' : [_("=name"), _("Paper size name."), ""],
'papero' : [_("=number"), _("Paper orientation number."), ""],
'paperml' : [_("=number"), _("Left paper margin"),
_("Size in cm")],
'papermr' : [_("=number"), _("Right paper margin"),
_("Size in cm")],
'papermt' : [_("=number"), _("Top paper margin"),
_("Size in cm")],
'papermb' : [_("=number"), _("Bottom paper margin"),
_("Size in cm")],
'css' : [_("=css filename"), _("CSS filename to use, "
"html format only"), ""],
}
if noopt:
return
self.options_help['of'][2] = os.path.join(USER_HOME,
"whatever_name")
if self.category == CATEGORY_TEXT:
for plugin in self.__textdoc_plugins:
self.options_help['off'][2].append(
plugin.get_extension() + "\t" + plugin.get_description() )
elif self.category == CATEGORY_DRAW:
for plugin in self.__drawdoc_plugins:
self.options_help['off'][2].append(
plugin.get_extension() + "\t" + plugin.get_description() )
elif self.category == CATEGORY_BOOK:
for plugin in self.__bookdoc_plugins:
self.options_help['off'][2].append(
plugin.get_extension() + "\t" + plugin.get_description() )
elif self.category == CATEGORY_GRAPHVIZ:
for graph_format in graphdoc.FORMATS:
self.options_help['off'][2].append(
graph_format["type"] + "\t" + graph_format["descr"] )
else:
self.options_help['off'][2] = "NA"
self.options_help['papers'][2] = \
[ paper.get_name() for paper in paper_sizes
if paper.get_name() != 'Custom Size' ]
self.options_help['papero'][2] = [
"%d\tPortrait" % PAPER_PORTRAIT,
"%d\tLandscape" % PAPER_LANDSCAPE ]
self.options_help['css'][2] = os.path.join(USER_HOME,
"whatever_name.css")
if self.category in (CATEGORY_TEXT, CATEGORY_DRAW):
default_style = StyleSheet()
self.option_class.make_default_style(default_style)
# Read all style sheets available for this item
style_file = self.option_class.handler.get_stylesheet_savefile()
self.style_list = StyleSheetList(style_file, default_style)
self.options_help['style'][2] = self.style_list.get_style_names()
def init_report_options(self):
"""
Initialize the options that are defined by each report.
"""
if self.category == CATEGORY_BOOK: # a Book Report has no "menu"
for key in self.option_class.options_dict:
self.options_dict[key] = self.option_class.options_dict[key]
self.options_help[key] = \
self.option_class.options_help[key][:3]
# a Book Report can't have HTML output so "css" is meaningless
self.options_dict.pop('css')
if not hasattr(self.option_class, "menu"):
return
menu = self.option_class.menu
for name in menu.get_all_option_names():
option = menu.get_option_by_name(name)
self.options_dict[name] = option.get_value()
def init_report_options_help(self):
"""
Initialize help for the options that are defined by each report.
(And also any docgen options, if defined by the docgen.)
"""
if not hasattr(self.option_class, "menu"):
return
menu = self.option_class.menu
for name in menu.get_all_option_names():
option = menu.get_option_by_name(name)
self.options_help[name] = [ "", option.get_help() ]
if isinstance(option, PersonOption):
id_list = []
for person_handle in self.database.get_person_handles(True):
person = self.database.get_person_from_handle(person_handle)
id_list.append("%s\t%s" % (
person.get_gramps_id(),
name_displayer.display(person)))
self.options_help[name].append(id_list)
elif isinstance(option, FamilyOption):
id_list = []
for family in self.database.iter_families():
mname = ""
fname = ""
mhandle = family.get_mother_handle()
if mhandle:
mother = self.database.get_person_from_handle(mhandle)
if mother:
mname = name_displayer.display(mother)
fhandle = family.get_father_handle()
if fhandle:
father = self.database.get_person_from_handle(fhandle)
if father:
fname = name_displayer.display(father)
text = "%s:\t%s, %s" % \
(family.get_gramps_id(), fname, mname)
id_list.append(text)
self.options_help[name].append(id_list)
elif isinstance(option, NoteOption):
id_list = []
for nhandle in self.database.get_note_handles():
note = self.database.get_note_from_handle(nhandle)
id_list.append(note.get_gramps_id())
self.options_help[name].append(id_list)
elif isinstance(option, MediaOption):
id_list = []
for mhandle in self.database.get_media_object_handles():
mobject = self.database.get_object_from_handle(mhandle)
id_list.append(mobject.get_gramps_id())
self.options_help[name].append(id_list)
elif isinstance(option, PersonListOption):
self.options_help[name].append("")
elif isinstance(option, NumberOption):
self.options_help[name].append("A number")
elif isinstance(option, BooleanOption):
self.options_help[name].append(["False", "True"])
elif isinstance(option, DestinationOption):
self.options_help[name].append("A file system path")
elif isinstance(option, StringOption):
self.options_help[name].append("Any text")
elif isinstance(option, TextOption):
self.options_help[name].append(
"A list of text values. Each entry in the list "
"represents one line of text." )
elif isinstance(option, EnumeratedListOption):
ilist = []
for (value, description) in option.get_items():
ilist.append("%s\t%s" % (value, description))
self.options_help[name].append(ilist)
elif isinstance(option, Option):
self.options_help[name].append(option.get_help())
else:
print(_("Unknown option: %s") % option, file=sys.stderr)
print(_(" Valid options are:") +
", ".join(list(self.options_dict.keys())),
file=sys.stderr)
print(_(" Use '%(donottranslate)s' to see description "
"and acceptable values")
% {'donottranslate' : "show=option"},
file=sys.stderr)
def parse_options(self):
"""
Load the options that the user has entered.
"""
if not hasattr(self.option_class, "menu"):
menu = None
else:
menu = self.option_class.menu
menu_opt_names = menu.get_all_option_names()
_format_str = self.options_str_dict.pop('off', None)
if _format_str:
self.options_dict['off'] = _format_str
self.css_filename = None
_chosen_format = None
self.doc_option_class = None
if self.category in [CATEGORY_TEXT, CATEGORY_DRAW, CATEGORY_BOOK]:
if self.category == CATEGORY_TEXT:
plugins = self.__textdoc_plugins
self.css_filename = self.options_dict['css']
elif self.category == CATEGORY_DRAW:
plugins = self.__drawdoc_plugins
elif self.category == CATEGORY_BOOK:
plugins = self.__bookdoc_plugins
for plugin in plugins:
if plugin.get_extension() == self.options_dict['off']:
self.format = plugin.get_basedoc()
self.doc_option_class = plugin.get_doc_option_class()
if self.format is None:
# Pick the first one as the default.
plugin = plugins[0]
self.format = plugin.get_basedoc()
self.doc_option_class = plugin.get_doc_option_class()
_chosen_format = plugin.get_extension()
elif self.category == CATEGORY_GRAPHVIZ:
for graph_format in graphdoc.FORMATS:
if graph_format['type'] == self.options_dict['off']:
if not self.format: # choose the first one, not the last
self.format = graph_format["class"]
if self.format is None:
# Pick the first one as the default.
self.format = graphdoc.FORMATS[0]["class"]
_chosen_format = graphdoc.FORMATS[0]["type"]
else:
self.format = None
if _chosen_format and _format_str:
print(_("Ignoring '%(notranslate1)s=%(notranslate2)s' "
"and using '%(notranslate1)s=%(notranslate3)s'.")
% {'notranslate1' : "off",
'notranslate2' : self.options_dict['off'],
'notranslate3' : _chosen_format},
file=sys.stderr)
print(_("Use '%(notranslate)s' to see valid values.")
% {'notranslate' : "show=off"}, file=sys.stderr)
self.do_doc_options()
for opt in self.options_str_dict:
if opt in self.options_dict:
self.options_dict[opt] = \
_convert_str_to_match_type(self.options_str_dict[opt],
self.options_dict[opt])
self.option_class.handler.options_dict[opt] = \
self.options_dict[opt]
if menu and opt in menu_opt_names:
option = menu.get_option_by_name(opt)
option.set_value(self.options_dict[opt])
else:
print(_("Ignoring unknown option: %s") % opt, file=sys.stderr)
print(_(" Valid options are:"),
", ".join(list(self.options_dict.keys())),
file=sys.stderr)
print(_(" Use '%(donottranslate)s' to see description "
"and acceptable values") %
{'donottranslate' : "show=option"}, file=sys.stderr)
self.option_class.handler.output = self.options_dict['of']
self.paper = paper_sizes[0] # make sure one exists
for paper in paper_sizes:
if paper.get_name() == self.options_dict['papers']:
self.paper = paper
self.option_class.handler.set_paper(self.paper)
self.orien = self.options_dict['papero']
self.marginl = self.options_dict['paperml']
self.marginr = self.options_dict['papermr']
self.margint = self.options_dict['papermt']
self.marginb = self.options_dict['papermb']
if self.category in (CATEGORY_TEXT, CATEGORY_DRAW):
default_style = StyleSheet()
self.option_class.make_default_style(default_style)
# Read all style sheets available for this item
style_file = self.option_class.handler.get_stylesheet_savefile()
self.style_list = StyleSheetList(style_file, default_style)
# Get the selected stylesheet
style_name = self.option_class.handler.get_default_stylesheet_name()
self.selected_style = self.style_list.get_style_sheet(style_name)
def do_doc_options(self):
self.doc_options = None
if not self.doc_option_class:
return # this docgen type has no options
try:
if issubclass(self.doc_option_class, object):
self.doc_options = self.doc_option_class(self.raw_name,
self.database)
doc_options_dict = self.doc_options.options_dict
except TypeError:
self.doc_options = self.doc_option_class
self.doc_options.load_previous_values()
docgen_menu = self.doc_options.menu
report_menu = self.option_class.menu # "help" checks the option type
for oname in docgen_menu.get_option_names('Document Options'):
docgen_opt = docgen_menu.get_option('Document Options', oname)
if oname in self.options_str_dict and oname in doc_options_dict:
doc_options_dict[oname] = \
_convert_str_to_match_type(self.options_str_dict[oname],
doc_options_dict[oname])
self.options_str_dict.pop(oname)
if oname in doc_options_dict:
docgen_opt.set_value(doc_options_dict[oname])
report_menu.add_option('Document Options', oname, docgen_opt)
for oname in doc_options_dict: # enable "help"
self.options_dict[oname] = doc_options_dict[oname]
self.options_help[oname] = self.doc_options.options_help[oname][:3]
def show_options(self):
"""
Print available options on the CLI.
"""
if not self.show:
return
elif self.show == 'all':
print(_(" Available options:"))
for key in sorted(self.options_dict.keys()):
if key in self.options_help:
opt = self.options_help[key]
# Make the output nicer to read, assume a tab has 8 spaces
tabs = '\t\t' if len(key) < 10 else '\t'
optmsg = " %s%s%s (%s)" % (key, tabs, opt[1], opt[0])
else:
optmsg = " %s%s%s" % (key, tabs,
_('(no help available)'))
print(optmsg)
print(_(" Use '%(donottranslate)s' to see description "
"and acceptable values")
% {'donottranslate' : "show=option"})
elif self.show in self.options_help:
opt = self.options_help[self.show]
tabs = '\t\t' if len(self.show) < 10 else '\t'
print(' %s%s%s (%s)' % (self.show, tabs, opt[1], opt[0]))
print(_(" Available values are:"))
vals = opt[2]
if isinstance(vals, (list, tuple)):
for val in vals:
print(" %s" % val)
else:
print(" %s" % opt[2])
else:
#there was a show option given, but the option is invalid
print(_("option '%(optionname)s' not valid. "
"Use '%(donottranslate)s' to see all valid options.")
% {'optionname' : self.show,
'donottranslate' : "show=all"},
file=sys.stderr)
#------------------------------------------------------------------------
#
# Command-line report generic task
#
#------------------------------------------------------------------------
def cl_report(database, name, category, report_class, options_class,
options_str_dict):
err_msg = _("Failed to write report. ")
clr = CommandLineReport(database, name, category, options_class,
options_str_dict)
# Exit here if show option was given
if clr.show:
return
# write report
try:
if category in [CATEGORY_TEXT, CATEGORY_DRAW, CATEGORY_BOOK]:
if clr.doc_options:
clr.option_class.handler.doc = clr.format(
clr.selected_style,
PaperStyle(clr.paper,clr.orien,clr.marginl,
clr.marginr,clr.margint,clr.marginb),
clr.doc_options)
else:
clr.option_class.handler.doc = clr.format(
clr.selected_style,
PaperStyle(clr.paper,clr.orien,clr.marginl,
clr.marginr,clr.margint,clr.marginb))
elif category == CATEGORY_GRAPHVIZ:
clr.option_class.handler.doc = clr.format(
clr.option_class,
PaperStyle(clr.paper,clr.orien,clr.marginl,
clr.marginr,clr.margint,clr.marginb))
if clr.css_filename is not None and \
hasattr(clr.option_class.handler.doc, 'set_css_filename'):
clr.option_class.handler.doc.set_css_filename(clr.css_filename)
MyReport = report_class(database, clr.option_class, User())
MyReport.doc.init()
MyReport.begin_report()
MyReport.write_report()
MyReport.end_report()
return clr
except ReportError as msg:
(m1, m2) = msg.messages()
print(err_msg, file=sys.stderr)
print(m1, file=sys.stderr)
if m2:
print(m2, file=sys.stderr)
except:
if len(log.handlers) > 0:
log.error(err_msg, exc_info=True)
else:
print(err_msg, file=sys.stderr)
## Something seems to eat the exception above.
## Hack to re-get the exception:
try:
raise
except:
traceback.print_exc()
def run_report(db, name, **options_str_dict):
"""
Given a database, run a given report.
db is a Db database
name is the name of a report
options_str_dict is the same kind of options
given at the command line. For example:
>>> run_report(db, "ancestor_report", off="txt",
of="ancestor-007.txt", pid="I37")
returns CommandLineReport (clr) if successfully runs the report,
None otherwise.
You can see:
options and values used in clr.option_class.options_dict
filename in clr.option_class.get_output()
"""
dbstate = DbState()
climanager = CLIManager(dbstate, setloader=False, user=User()) # don't load db
climanager.do_reg_plugins(dbstate, None)
pmgr = BasePluginManager.get_instance()
cl_list = pmgr.get_reg_reports()
clr = None
for pdata in cl_list:
if name == pdata.id:
mod = pmgr.load_plugin(pdata)
if not mod:
#import of plugin failed
return clr
category = pdata.category
report_class = getattr(mod, pdata.reportclass)
options_class = getattr(mod, pdata.optionclass)
if category in (CATEGORY_BOOK, CATEGORY_CODE):
options_class(db, name, category,
options_str_dict)
else:
clr = cl_report(db, name, category,
report_class, options_class,
options_str_dict)
return clr
return clr
#------------------------------------------------------------------------
#
# Function to write books from command line
#
#------------------------------------------------------------------------
def cl_book(database, name, book, options_str_dict):
clr = CommandLineReport(database, name, CATEGORY_BOOK,
ReportOptions, options_str_dict)
# Exit here if show option was given
if clr.show:
return
# write report
doc = clr.format(None,
PaperStyle(clr.paper, clr.orien, clr.marginl,
clr.marginr, clr.margint, clr.marginb))
user = User()
rptlist = []
selected_style = StyleSheet()
for item in book.get_item_list():
# The option values were loaded magically by the book parser.
# But they still need to be applied to the menu options.
opt_dict = item.option_class.options_dict
menu = item.option_class.menu
for optname in opt_dict:
menu_option = menu.get_option_by_name(optname)
if menu_option:
menu_option.set_value(opt_dict[optname])
item.option_class.set_document(doc)
report_class = item.get_write_item()
obj = write_book_item(database,
report_class, item.option_class, user)
if obj:
append_styles(selected_style, item)
rptlist.append(obj)
doc.set_style_sheet(selected_style)
doc.open(clr.option_class.get_output())
doc.init()
newpage = 0
for rpt in rptlist:
if newpage:
doc.page_break()
newpage = 1
rpt.begin_report()
rpt.write_report()
doc.close()
#------------------------------------------------------------------------
#
# Generic task function for book
#
#------------------------------------------------------------------------
def write_book_item(database, report_class, options, user):
"""Write the report using options set.
All user dialog has already been handled and the output file opened."""
try:
return report_class(database, options, user)
except ReportError as msg:
(m1, m2) = msg.messages()
print("ReportError", m1, m2, file=sys.stderr)
except FilterError as msg:
(m1, m2) = msg.messages()
print("FilterError", m1, m2, file=sys.stderr)
except:
log.error("Failed to write book item.", exc_info=True)
return None
| pmghalvorsen/gramps_branch | gramps/cli/plug/__init__.py | Python | gpl-2.0 | 33,260 | [
"Brian"
] | dd1e587d1159d5745c8644941dc8c6a1e11cc63c58749f4077ef46a8b5048744 |
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
"""Namespace for ops used in imperative programming."""
from __future__ import absolute_import
from ..ndarray import numpy as _mx_nd_np
__all__ = ["randint", "uniform", "normal", "choice", "rand", "multinomial"]
def randint(low, high=None, size=None, dtype=None, ctx=None, out=None):
r"""Return random integers from `low` (inclusive) to `high` (exclusive).
Return random integers from the "discrete uniform" distribution of
the specified dtype in the "half-open" interval [`low`, `high`). If
`high` is None (the default), then results are from [0, `low`).
Parameters
----------
low : int
Lowest (signed) integer to be drawn from the distribution (unless
``high=None``, in which case this parameter is one above the
*highest* such integer).
high : int, optional
If provided, one above the largest (signed) integer to be drawn
from the distribution (see above for behavior if ``high=None``).
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. Default is None, in which case a
single value is returned.
dtype : dtype, optional
Desired dtype of the result. All dtypes are determined by their
name, i.e., 'int64', 'int', etc, so byteorder is not available
and a specific precision may have different C types depending
on the platform. The default value is 'np.int'.
ctx : Context, optional
Device context of output. Default is current context.
out : ndarray, optional
The output ndarray (default is `None`).
Returns
-------
out : ndarray of ints
`size`-shaped array of random integers from the appropriate
distribution, or a single such random int if `size` not provided.
Examples
--------
>>> np.random.randint(2, size=10)
array([1, 0, 0, 0, 1, 1, 0, 0, 1, 0])
>>> np.random.randint(1, size=10)
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
Generate a 2 x 4 array of ints between 0 and 4, inclusive:
>>> np.random.randint(5, size=(2, 4))
array([[4, 0, 2, 1],
[3, 2, 2, 0]])
"""
return _mx_nd_np.random.randint(low, high, size, dtype, ctx, out)
def uniform(low=0.0, high=1.0, size=None, dtype=None, ctx=None, out=None):
r"""Draw samples from a uniform distribution.
Samples are uniformly distributed over the half-open interval
``[low, high)`` (includes low, but excludes high). In other words,
any value within the given interval is equally likely to be drawn
by `uniform`.
Parameters
----------
low : float, ndarray, optional
Lower boundary of the output interval. All values generated will be
greater than or equal to low. The default value is 0.
high : float, ndarray, optional
Upper boundary of the output interval. All values generated will be
less than high. The default value is 1.0.
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. If size is ``None`` (default),
a scalar tensor containing a single value is returned if
``low`` and ``high`` are both scalars. Otherwise,
``np.broadcast(low, high).size`` samples are drawn.
dtype : {'float16', 'float32', 'float64'}, optional
Data type of output samples. Default is 'float32'
ctx : Context, optional
Device context of output. Default is current context.
Returns
-------
out : ndarray
Drawn samples from the parameterized uniform distribution.
See Also
--------
randint : Discrete uniform distribution, yielding integers.
rand : Convenience function that accepts dimensions as input, e.g.,
``rand(2,2)`` would generate a 2-by-2 array of floats,
uniformly distributed over ``[0, 1)``.
Notes
-----
The probability density function of the uniform distribution is
.. math:: p(x) = \frac{1}{b - a}
anywhere within the interval ``[a, b)``, and zero elsewhere.
When ``high`` == ``low``, values of ``low`` will be returned.
If ``high`` < ``low``, the results are officially undefined
and may eventually raise an error, i.e. do not rely on this
function to behave when passed arguments satisfying that
inequality condition.
"""
return _mx_nd_np.random.uniform(low, high, size=size, ctx=ctx, dtype=dtype, out=out)
def normal(loc=0.0, scale=1.0, size=None, dtype=None, ctx=None, out=None):
r"""Draw random samples from a normal (Gaussian) distribution.
Samples are distributed according to a normal distribution parametrized
by *loc* (mean) and *scale* (standard deviation).
Parameters
----------
loc : float, optional
Mean (centre) of the distribution.
scale : float, optional
Standard deviation (spread or "width") of the distribution.
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., `(m, n, k)`, then `m * n * k`
samples are drawn. If size is `None` (default), a scalar tensor containing
a single value is returned if loc and scale are both scalars. Otherwise,
``np.broadcast(low, high).size`` samples are drawn.
dtype : {'float16', 'float32', 'float64'}, optional
Data type of output samples. Default is 'float32'
ctx : Context, optional
Device context of output, default is current context.
out : ``ndarray``, optional
Store output to an existing ``ndarray``.
Returns
-------
out : ndarray
Drawn samples from the parameterized normal distribution.
Notes
-----
The probability density for the Gaussian distribution is
.. math:: p(x) = \frac{1}{\sqrt{ 2 \pi \sigma^2 }}
e^{ - \frac{ (x - \mu)^2 } {2 \sigma^2} },
where :math:`\mu` is the mean and :math:`\sigma` the standard
deviation. The square of the standard deviation, :math:`\sigma^2`,
is called the variance.
The function has its peak at the mean, and its "spread" increases with
the standard deviation (the function reaches 0.607 times its maximum at
:math:`x + \sigma` and :math:`x - \sigma` [2]_). This implies that
`numpy.random.normal` is more likely to return samples lying close to
the mean, rather than those far away.
References
----------
.. [1] Wikipedia, "Normal distribution",
https://en.wikipedia.org/wiki/Normal_distribution
.. [2] P. R. Peebles Jr., "Central Limit Theorem" in "Probability,
Random Variables and Random Signal Principles", 4th ed., 2001,
pp. 51, 51, 125.
Examples
--------
>>> mu, sigma = 0, 0.1 # mean and standard deviation
>>> s = np.random.normal(mu, sigma, 1000)
Verify the mean and the variance:
>>> np.abs(mu - np.mean(s)) < 0.01
array(True)
"""
return _mx_nd_np.random.normal(loc, scale, size, dtype, ctx, out)
def multinomial(n, pvals, size=None, **kwargs):
r"""
Draw samples from a multinomial distribution.
The multinomial distribution is a multivariate generalisation of the binomial distribution.
Take an experiment with one of ``p`` possible outcomes. An example of such an experiment is throwing a dice,
where the outcome can be 1 through 6. Each sample drawn from the distribution represents n such experiments.
Its values, ``X_i = [X_0, X_1, ..., X_p]``, represent the number of times the outcome was ``i``.
Parameters
----------
n : int
Number of experiments.
pvals : sequence of floats, length p
Probabilities of each of the p different outcomes. These should sum to 1.
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then ``m * n * k`` samples
are drawn. Default is None, in which case a single value is returned.
Returns
-------
out : ndarray
The drawn samples, of shape size, if that was provided. If not, the shape is ``(N,)``.
In other words, each entry ``out[i,j,...,:]`` is an N-dimensional value drawn from the distribution.
Examples
--------
Throw a dice 1000 times, and 1000 times again:
>>> np.random.multinomial(1000, [1/6.]*6, size=2)
array([[164, 161, 179, 158, 150, 188],
[178, 162, 177, 143, 163, 177]])
A loaded die is more likely to land on number 6:
>>> np.random.multinomial(100, [1/7.]*5 + [2/7.])
array([19, 14, 12, 11, 21, 23])
>>> np.random.multinomial(100, [1.0 / 3, 2.0 / 3])
array([32, 68])
"""
return _mx_nd_np.random.multinomial(n, pvals, size, **kwargs)
def choice(a, size=None, replace=True, p=None, ctx=None, out=None):
r"""Generates a random sample from a given 1-D array
Parameters
-----------
a : 1-D array-like or int
If an ndarray, a random sample is generated from its elements.
If an int, the random sample is generated as if a were np.arange(a)
size : int or tuple of ints, optional
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn. Default is None, in which case a
single value is returned.
replace : boolean, optional
Whether the sample is with or without replacement
p : 1-D array-like, optional
The probabilities associated with each entry in a.
If not given the sample assumes a uniform distribution over all
entries in a.
ctx : Context, optional
Device context of output. Default is current context.
Returns
--------
samples : ndarray
The generated random samples
Examples
---------
Generate a uniform random sample from np.arange(5) of size 3:
>>> np.random.choice(5, 3)
array([0, 3, 4])
>>> #This is equivalent to np.random.randint(0,5,3)
Generate a non-uniform random sample from np.arange(5) of size 3:
>>> np.random.choice(5, 3, p=[0.1, 0, 0.3, 0.6, 0])
array([3, 3, 0])
Generate a uniform random sample from np.arange(5) of size 3 without
replacement:
>>> np.random.choice(5, 3, replace=False)
array([3,1,0])
>>> #This is equivalent to np.random.permutation(np.arange(5))[:3]
Generate a non-uniform random sample from np.arange(5) of size
3 without replacement:
>>> np.random.choice(5, 3, replace=False, p=[0.1, 0, 0.3, 0.6, 0])
array([2, 3, 0])
"""
return _mx_nd_np.random.choice(a, size, replace, p, ctx, out)
def rand(*size, **kwargs):
r"""Random values in a given shape.
Create an array of the given shape and populate it with random
samples from a uniform distribution over [0, 1).
Parameters
----------
d0, d1, ..., dn : int, optional
The dimensions of the returned array, should be all positive.
If no argument is given a single Python float is returned.
Returns
-------
out : ndarray
Random values.
Examples
--------
>>> np.random.rand(3,2)
array([[ 0.14022471, 0.96360618], #random
[ 0.37601032, 0.25528411], #random
[ 0.49313049, 0.94909878]]) #random
"""
output_shape = ()
for s in size:
output_shape += (s,)
return _mx_nd_np.random.uniform(0, 1, size=output_shape, **kwargs)
| mlperf/training_results_v0.7 | Fujitsu/benchmarks/resnet/implementations/implementation_open/mxnet/python/mxnet/numpy/random.py | Python | apache-2.0 | 12,205 | [
"Gaussian"
] | a0907c4301c25321264e81c0aea8755a919ffe305e64649634b6c820d91934f0 |
# Copyright (c) 2015, Ecole Polytechnique Federale de Lausanne, Blue Brain Project
# All rights reserved.
#
# This file is part of NeuroM <https://github.com/BlueBrain/NeuroM>
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# 1. Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# 3. Neither the name of the copyright holder nor the names of
# its contributors may be used to endorse or promote products
# derived from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
"""Test neurom.sectionfunc functionality."""
from nose import tools as nt
from pathlib import Path
import math
import numpy as np
import warnings
from io import StringIO
from numpy.testing import assert_allclose
from neurom import load_neuron
from neurom.features import sectionfunc as _sf
from neurom.features import neuritefunc as _nf
from neurom import morphmath as mmth
DATA_PATH = Path(__file__).parent.parent.parent.parent / 'test_data'
H5_PATH = Path(DATA_PATH, 'h5/v1/')
SWC_PATH = Path(DATA_PATH, 'swc/')
NRN = load_neuron(H5_PATH / 'Neuron.h5')
def test_total_volume_per_neurite():
vol = _nf.total_volume_per_neurite(NRN)
nt.eq_(len(vol), 4)
# calculate the volumes by hand and compare
vol2 = [sum(_sf.section_volume(s) for s in n.iter_sections()) for n in NRN.neurites]
nt.eq_(vol, vol2)
# regression test
ref_vol = [271.94122143951864, 281.24754646913954,
274.98039928781355, 276.73860261723024]
assert_allclose(vol, ref_vol)
def test_section_area():
sec = load_neuron(StringIO(u"""((CellBody) (0 0 0 2))
((Dendrite)
(0 0 0 2)
(1 0 0 2))"""), reader='asc').sections[1]
area = _sf.section_area(sec)
nt.eq_(math.pi * 1 * 2 * 1, area)
def test_section_tortuosity():
sec_a = load_neuron(StringIO(u"""
((CellBody) (0 0 0 2))
((Dendrite)
(0 0 0 2)
(1 0 0 2)
(2 0 0 2)
(3 0 0 2))"""), reader='asc').sections[1]
sec_b = load_neuron(StringIO(u"""
((CellBody) (0 0 0 2))
((Dendrite)
(0 0 0 2)
(1 0 0 2)
(1 2 0 2)
(0 2 0 2))"""), reader='asc').sections[1]
nt.eq_(_sf.section_tortuosity(sec_a), 1.0)
nt.eq_(_sf.section_tortuosity(sec_b), 4.0 / 2.0)
for s in _nf.iter_sections(NRN):
nt.eq_(_sf.section_tortuosity(s),
mmth.section_length(s.points) / mmth.point_dist(s.points[0],
s.points[-1]))
def test_setion_tortuosity_single_point():
sec = load_neuron(StringIO(u"""((CellBody) (0 0 0 2))
((Dendrite)
(1 2 3 2))"""), reader='asc').sections[1]
nt.eq_(_sf.section_tortuosity(sec), 1.0)
def test_section_tortuosity_looping_section():
sec = load_neuron(StringIO(u"""
((CellBody) (0 0 0 2))
((Dendrite)
(0 0 0 2)
(1 0 0 2)
(1 2 0 2)
(0 2 0 2)
(0 0 0 2))"""), reader='asc').sections[1]
with warnings.catch_warnings(record=True):
nt.eq_(_sf.section_tortuosity(sec), np.inf)
def test_section_meander_angles():
s0 = load_neuron(StringIO(u"""((CellBody) (0 0 0 0))
((Dendrite)
(0 0 0 2)
(1 0 0 2)
(2 0 0 2)
(3 0 0 2)
(4 0 0 2))"""), reader='asc').sections[1]
nt.assert_equal(_sf.section_meander_angles(s0),
[math.pi, math.pi, math.pi])
s1 = load_neuron(StringIO(u"""((CellBody) (0 0 0 0))
((Dendrite)
(0 0 0 2)
(1 0 0 2)
(1 1 0 2)
(2 1 0 2)
(2 2 0 2))"""), reader='asc').sections[1]
nt.assert_equal(_sf.section_meander_angles(s1),
[math.pi / 2, math.pi / 2, math.pi / 2])
s2 = load_neuron(StringIO(u"""((CellBody) (0 0 0 0))
((Dendrite)
(0 0 0 2)
(0 0 1 2)
(0 0 2 2)
(0 0 0 2))"""), reader='asc').sections[1]
nt.assert_equal(_sf.section_meander_angles(s2),
[math.pi, 0.])
def test_section_meander_angles_single_segment():
s = load_neuron(StringIO(u"""((CellBody) (0 0 0 0))
((Dendrite)
(0 0 0 2)
(1 1 1 2))"""), reader='asc').sections[1]
nt.assert_equal(len(_sf.section_meander_angles(s)), 0)
def test_strahler_order():
path = Path(SWC_PATH, 'strahler.swc')
n = load_neuron(path)
strahler_order = _sf.strahler_order(n.neurites[0].root_node)
nt.eq_(strahler_order, 4)
def test_locate_segment_position():
s = load_neuron(StringIO(u"""((CellBody) (0 0 0 0))
((Dendrite)
(0 0 0 0)
(3 0 4 200)
(6 4 4 400))"""), reader='asc').sections[1]
nt.assert_equal(
_sf.locate_segment_position(s, 0.0),
(0, 0.0)
)
nt.assert_equal(
_sf.locate_segment_position(s, 0.25),
(0, 2.5)
)
nt.assert_equal(
_sf.locate_segment_position(s, 0.75),
(1, 2.5)
)
nt.assert_equal(
_sf.locate_segment_position(s, 1.0),
(1, 5.0)
)
nt.assert_raises(
ValueError,
_sf.locate_segment_position, s, 1.1
)
nt.assert_raises(
ValueError,
_sf.locate_segment_position, s, -0.1
)
def test_mean_radius():
s = load_neuron(StringIO(u"""
((CellBody)
(0 0 0 1))
((Dendrite)
(0 0 0 0)
(3 0 4 200)
(6 4 4 400))"""), reader='asc').neurites[0]
nt.assert_equal(
_sf.section_mean_radius(s),
100.
)
| wizmer/NeuroM | neurom/features/tests/test_sectionfunc.py | Python | bsd-3-clause | 6,602 | [
"NEURON"
] | e53e80eb47075729c6d444bbe76f849ff6c8680416b0ce2f638c043066aa592e |
from modeledcommandparameter import *
class Distribution(ModeledCommandParameter):
"""
A Distribution is a:
(1) bdistyp (I) beam distribution type {1:Gaussian 2:uniform circular segment}
(2-13) 12 Parameters for bdistyp
"""
begtag=''
endtag=''
models = {
'model_descriptor': {'desc': 'Distribution type',
'name': 'bdistyp',
'num_parms': 13,
'for001_format': {'line_splits': [1, 6, 6]}},
'gaussian':
{'desc': 'Gaussian beam distribution',
'doc': '',
'icool_model_name': 1,
'parms':
{'bdistyp': {'pos': 1, 'type': 'String', 'doc': ''},
'x_mean': {'pos': 2, 'type': 'Real', 'doc': ''},
'y_mean': {'pos': 3, 'type': 'Real', 'doc': ''},
'z_mean': {'pos': 4, 'type': 'Real', 'doc': ''},
'px_mean': {'pos': 5, 'type': 'Real', 'doc': ''},
'py_mean': {'pos': 6, 'type': 'Real', 'doc': ''},
'pz_mean': {'pos': 7, 'type': 'Real', 'doc': ''},
'x_std': {'pos': 8, 'type': 'Real', 'doc': ''},
'y_std': {'pos': 9, 'type': 'Real', 'doc': ''},
'z_std': {'pos': 10, 'type': 'Real', 'doc': ''},
'px_std': {'pos': 11, 'type': 'Real', 'doc': ''},
'py_std': {'pos': 12, 'type': 'Real', 'doc': ''},
'pz_std': {'pos': 13, 'type': 'Real', 'doc': ''}}},
'uniform':
{'desc': 'Uniform circular segment beam distribution',
'doc': '',
'icool_model_name': 2,
'parms':
{'bdistyp': {'pos': 1, 'type': 'String', 'doc': ''},
'r_low': {'pos': 2, 'type': 'Real', 'doc': ''},
'r_high': {'pos': 3, 'type': 'Real', 'doc': ''},
'phi_low': {'pos': 4, 'type': 'Real', 'doc': ''},
'phi_high': {'pos': 5, 'type': 'Real', 'doc': ''},
'z_low': {'pos': 6, 'type': 'Real', 'doc': ''},
'z_high': {'pos': 7, 'type': 'Real', 'doc': ''},
'pr_low': {'pos': 8, 'type': 'Real', 'doc': ''},
'pr_high': {'pos': 9, 'type': 'Real', 'doc': ''},
'pphi_low': {'pos': 10, 'type': 'Real', 'doc': ''},
'pphi_high': {'pos': 11, 'type': 'Real', 'doc': ''},
'pz_low': {'pos': 12, 'type': 'Real', 'doc': ''},
'pz_high': {'pos': 13, 'type': 'Real', 'doc': ''}}},
}
def __init__(self, **kwargs):
if ModeledCommandParameter.check_command_params_init(self, Distribution.models, **kwargs) is False:
sys.exit(0)
def __call__(self, **kwargs):
pass
def __setattr__(self, name, value):
self.__modeled_command_parameter_setattr__(name, value, Distribution.models)
def gen_for001(self, file):
ModeledCommandParameter.gen_for001(self, file)
| jon2718/ipycool_2.0 | distribution.py | Python | mit | 3,019 | [
"Gaussian"
] | 2af8f5343f3b3a3cebbef6d6eb9c37fde8237981f2c1b6147ae4dcf9cd816526 |
#========= math
pi = 3.141592653589793
e = 2.718281828459045
#========= physics
lightSpeed = 299792458.0 # m/s
elementaryCharge = 1.60217657e-19 # coulombs
vacumPermeability = 4e-7*pi # Tesla . m/A
StefanBoltzmann = 5.67037321e-8 # W m^-2 K^-4
universalGas = 8.3144621 # J /K /mol
#---------- particles
electronMass = 9.109382910e-31 # kg
atomicMass = 1.660538921e-27 # kg
protonMass = 1.672621780e-27 # kg
neutronMass = 1.674927351e-27 # kg
#---------- units
Celsius0 = 273.15 # K
eV = 1.60217656535e-19 # J
#========= chemistry
Avogadro = 6.02214085774e+23
#============= Space
atmosphericPressure = 101325.0 # Pa
gravitational = 6.67384e-11 # m^3 kg / s^2
AU = 149597871.0e+3 # m
| ProkopHapala/SimpleSimulationEngine | python/pySimE/constants.py | Python | mit | 876 | [
"Avogadro"
] | 10bee8c87087df7f6dfb45c06e34458e7cd0b8976b7b021bc7925c90de5ab9af |
import collections as coll
import numpy as np
from scipy import ndimage as ndi
from ..util import img_as_float
from ..color import guess_spatial_dimensions
from .._shared.utils import warn, convert_to_float
__all__ = ['gaussian']
def _convert_input(image, preserve_range):
if preserve_range:
image = image.astype(np.double)
else:
image = img_as_float(image)
return image
def gaussian(image, sigma=1, output=None, mode='nearest', cval=0,
multichannel=None, preserve_range=False, truncate=4.0):
"""Multi-dimensional Gaussian filter.
Parameters
----------
image : array-like
Input image (grayscale or color) to filter.
sigma : scalar or sequence of scalars, optional
Standard deviation for Gaussian kernel. The standard
deviations of the Gaussian filter are given for each axis as a
sequence, or as a single number, in which case it is equal for
all axes.
output : array, optional
The ``output`` parameter passes an array in which to store the
filter output.
mode : {'reflect', 'constant', 'nearest', 'mirror', 'wrap'}, optional
The `mode` parameter determines how the array borders are
handled, where `cval` is the value when mode is equal to
'constant'. Default is 'nearest'.
cval : scalar, optional
Value to fill past edges of input if `mode` is 'constant'. Default
is 0.0
multichannel : bool, optional (default: None)
Whether the last axis of the image is to be interpreted as multiple
channels. If True, each channel is filtered separately (channels are
not mixed together). Only 3 channels are supported. If `None`,
the function will attempt to guess this, and raise a warning if
ambiguous, when the array has shape (M, N, 3).
preserve_range : bool, optional
Whether to keep the original range of values. Otherwise, the input
image is converted according to the conventions of `img_as_float`.
truncate : float, optional
Truncate the filter at this many standard deviations.
Returns
-------
filtered_image : ndarray
the filtered array
Notes
-----
This function is a wrapper around :func:`scipy.ndi.gaussian_filter`.
Integer arrays are converted to float.
The multi-dimensional filter is implemented as a sequence of
one-dimensional convolution filters. The intermediate arrays are
stored in the same data type as the output. Therefore, for output
types with a limited precision, the results may be imprecise
because intermediate results may be stored with insufficient
precision.
Examples
--------
>>> a = np.zeros((3, 3))
>>> a[1, 1] = 1
>>> a
array([[ 0., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 0.]])
>>> gaussian(a, sigma=0.4) # mild smoothing
array([[ 0.00163116, 0.03712502, 0.00163116],
[ 0.03712502, 0.84496158, 0.03712502],
[ 0.00163116, 0.03712502, 0.00163116]])
>>> gaussian(a, sigma=1) # more smoothing
array([[ 0.05855018, 0.09653293, 0.05855018],
[ 0.09653293, 0.15915589, 0.09653293],
[ 0.05855018, 0.09653293, 0.05855018]])
>>> # Several modes are possible for handling boundaries
>>> gaussian(a, sigma=1, mode='reflect')
array([[ 0.08767308, 0.12075024, 0.08767308],
[ 0.12075024, 0.16630671, 0.12075024],
[ 0.08767308, 0.12075024, 0.08767308]])
>>> # For RGB images, each is filtered separately
>>> from skimage.data import astronaut
>>> image = astronaut()
>>> filtered_img = gaussian(image, sigma=1, multichannel=True)
"""
spatial_dims = guess_spatial_dimensions(image)
if spatial_dims is None and multichannel is None:
msg = ("Images with dimensions (M, N, 3) are interpreted as 2D+RGB "
"by default. Use `multichannel=False` to interpret as "
"3D image with last dimension of length 3.")
warn(RuntimeWarning(msg))
multichannel = True
if np.any(np.asarray(sigma) < 0.0):
raise ValueError("Sigma values less than zero are not valid")
if multichannel:
# do not filter across channels
if not isinstance(sigma, coll.Iterable):
sigma = [sigma] * (image.ndim - 1)
if len(sigma) != image.ndim:
sigma = np.concatenate((np.asarray(sigma), [0]))
image = convert_to_float(image, preserve_range)
return ndi.gaussian_filter(image, sigma, mode=mode, cval=cval,
truncate=truncate)
| kenshay/ImageScript | ProgramData/SystemFiles/Python/Lib/site-packages/skimage/filters/_gaussian.py | Python | gpl-3.0 | 4,655 | [
"Gaussian"
] | 12f45cf9c1e8a6d58c3260b4e849e557f19b211549aae041fb80bdd231bd519a |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# -*- Python -*-
"""
DoCoMoScenario.py
Service Server for DoCoMo Scenario API
The project is hosted on GitHub where your could fork the project or report
issues. Visit https://github.com/roboworks/
:copyright: (c) 2015 by Hiroyuki Okada, All rights reserved.
:license: MIT License (MIT), http://www.opensource.org/licenses/MIT
"""
__author__ = 'Hiroyuki Okada'
__version__ = '0.1'
import sys
import time
sys.path.append(".")
import urllib2
import urllib
import json
import rospy
from std_msgs.msg import String
from trcp_chat.msg import DoCoMoScenarioReq
from trcp_chat.msg import DoCoMoScenarioRes
from trcp_chat.srv import DoCoMoScenario
from trcp_chat.srv import DoCoMoScenarioResponse
class DoCoMoScenarioSrv(object):
""" DoCoMoScenarioSrv class """
def __init__(self):
""" Initializer """
def run(self):
""" run ros node """
# initialize ros node
rospy.init_node('DocomoScenarioSrv')
rospy.loginfo("start DoCoMoScnarioSrv node")
service_server = rospy.Service('docomo_scenario', DoCoMoScenario, self.Scenario_handler)
rospy.loginfo("start DoCoMoScenario service server")
self.APIKEY = rospy.get_param("~APIKEY", "xxxx")
# get scenario APP ID
self.APP_URL = rospy.get_param("~scenario_url","https://api.apigw.smt.docomo.ne.jp/scenarioDialogue/v1/registration")
self.api_url = self.APP_URL + '?APIKEY=%s'%(self.APIKEY)
self.req_data = {'botId': 'APIBot'}
self.request = urllib2.Request(self.api_url, json.dumps(self.req_data))
self.request.add_header('Content-Type', 'application/json')
try:
self.response = urllib2.urlopen(self.request)
except Exception as e:
print e
return DoCoMoScenarioResponse(success=False)
self.resp_json = json.load(self.response)
# self.app_id = self.resp_json['app_id'].encode('utf-8')
# rospy.loginfo("DoCoMoScenario:%s", self.app_id)
self.urlS = rospy.get_param("~scenario_url", "https://api.apigw.smt.docomo.ne.jp/scenarioDialogue/v1/dialogue")
self.api_urlS = self.urlS + '?APIKEY=%s'%(self.APIKEY)
self.appId, self.botId = '5pB2Nv_6FQtIh8OIjVCfztSZNIlpzZZV','APIBot'
self.initTalkingFlag, self.initTopicId = 'true', 'APITOPIC'
rospy.spin()
def Scenario_handler(self, query):
rospy.loginfo("DoCoMoScenario Query:%s", query)
req = query.request
self.req_data = {}
self.req_data['voiceText'] = req.voiceText
# self.req_data['appId'] = self.appId
self.req_data['botId'] = 'APIBot'
# self.req_data['initTalkingFlag'] = req.initTalkingFlag
# self.req_data['initTopicId'] = 'APITOPIC'
self.req_data['appRecvTime'] = '2015-10-30 21:21:16'
self.req_data['appSendTime'] = '2015-10-30 21:21:16'
self.request = urllib2.Request(self.api_urlS, json.dumps(self.req_data))
self.request.add_header('Content-Type', 'application/json')
try:
self.response = urllib2.urlopen(self.request)
except Exception as e:
print e
return DoCoMoScenarioResponse(success=False)
self.the_page = json.loads(self.response.read())
res = DoCoMoScenarioRes()
self.sys = self.the_page['systemText']
res.expression = self.sys['expression'].encode('utf-8')
res.utterance = self.sys['utterance'].encode('utf-8')
res.serverSendTime = self.the_page['serverSendTime']
return DoCoMoScenarioResponse(success=True, response=res)
if __name__ == '__main__':
try:
node = DoCoMoScenarioSrv()
node.run()
except rospy.ROSInterruptException:
pass
| okadahiroyuki/trcp | trcp_chat/nodes/DoCoMoScenarioSrv.py | Python | mit | 3,839 | [
"VisIt"
] | bc742666dfef4392273c12c9828dbe6197a1cb6d4d81f864801cebcd8f612933 |
from __future__ import print_function
import sys
sys.path.insert(1,"../../../")
import h2o
from tests import pyunit_utils
def link_incompatible_error():
print("Reading in original prostate data.")
prostate = h2o.import_file(path=pyunit_utils.locate("smalldata/prostate/prostate.csv.zip"))
print("Throw error when trying to create model with incompatible logit link.")
try:
h2o.model = h2o.glm(x=prostate[1:8], y=prostate[8], family="gaussian", link="logit")
assert False, "expected an error"
except EnvironmentError:
assert True
try:
h2o.model = h2o.glm(x=prostate[1:8], y=prostate[8], family="tweedie", link="log")
assert False, "expected an error"
except EnvironmentError:
assert True
try:
h2o.model = h2o.glm(x=prostate[2:9], y=prostate[1], family="binomial", link="inverse")
assert False, "expected an error"
except EnvironmentError:
assert True
if __name__ == "__main__":
pyunit_utils.standalone_test(link_incompatible_error)
else:
link_incompatible_error()
| nilbody/h2o-3 | h2o-py/tests/testdir_algos/glm/pyunit_DEPRECATED_link_incompatible_errorGLM.py | Python | apache-2.0 | 1,102 | [
"Gaussian"
] | a73d9209b5132a50bcd1379146da443f7314b0c811a8808581b0941762dc3fd3 |
# module handling configuration and preferences for the BCMD GUI
import sys, os, os.path
import pprint, argparse
# environment and default settings
VERSION = 0.5
BCMD_HOME = os.path.dirname(os.path.abspath(os.path.join(__file__, '..')))
USER_HOME = os.path.expanduser('~')
PARSER = os.path.join(BCMD_HOME, 'bparser')
ABC = os.path.join(BCMD_HOME, 'abc')
PREFS = os.extsep + 'bcmd_prefs'
WORK = os.path.join(BCMD_HOME, 'build')
RESOURCES = os.path.join(BCMD_HOME, 'resources')
MODEL_PATH = [ os.path.join(BCMD_HOME, 'examples') ]
INPUT_PATH = [ os.path.join(BCMD_HOME, 'examples') ]
PREF_FIELDS = [ 'model_path', 'input_path',
'model_name', 'model_src', 'model_dir',
'input_file', 'input_dir',
'debug', 'match_input', 'match_outputs',
'coarse', 'detail',
'coarse_name', 'detail_name',
'generate_name', 'generate_dir',
'use_generated', 'run_generated',
'graph_unused', 'graph_init',
'graph_self', 'graph_clusters',
'graph_params', 'graph_LR',
'latex_tabular', 'latex_displaystyle',
'latex_align',
'export_derived',
'param_file', 'use_param_file',
'use_explicit', 'omit_non_model_params',
'steady_duration', 'do_steady',
'match_inputs',
'time_from_file', 'time_file',
'time_rate', 'time_duration',
'priority',
'data_file', 'shared_data_file',
'data_source',
# 'presets',
'output_header', 'output_subset',
'output_model_only',
'max_inits',
'auto_parse']
EXTENSIONS = {'model': os.extsep + 'model',
'modeldef': os.extsep + 'modeldef',
'input': os.extsep + 'input',
'log': os.extsep + 'log',
'out': os.extsep + 'out',
'detail': os.extsep + 'detail',
'stderr': os.extsep + 'stderr',
'stdout': os.extsep + 'stdout',
'parsed': os.extsep + 'bcmpl',
'graphviz': os.extsep + 'gv',
'pdf': os.extsep + 'pdf',
'gif': os.extsep + 'gif',
'braincirc': os.extsep + 'dat',
'txt' : os.extsep + 'txt',
'csv' : os.extsep + 'csv',
'latex' : os.extsep + 'tex',
'html' : os.extsep + 'html',
'sbml' : os.extsep + 'xml'
}
FACTORY_PRESETS = { 'Noise: N(0,1)' : [{ 'kind':'gaussian', 'lo':None }],
'Noise: U(0,1)' : [{ 'kind':'uniform' }],
'Random Walk' : [{ 'kind':'walk', 'sd':0.1, 'lo':None }],
'Sine 1 Hz, [0,1]': [{ 'kind':'sine', 'freq':1 }],
'Saw 1 Hz, [0,1]': [{ 'kind':'saw', 'freq':1 }],
'Square 1 Hz, [0,1]': [{ 'kind':'square', 'freq':1 }],
'NIRS mix, [0,1]': [ { 'kind':'sine', 'freq':1.00, 'lo':-0.6, 'hi':0.6 },
{ 'kind':'sine', 'freq':0.25, 'lo':-0.2, 'hi':0.2 },
{ 'kind':'sine', 'freq':0.10, 'lo':-0.9, 'hi':0.9 },
{ 'kind':'sine', 'freq':0.04, 'lo':-1.0, 'hi':1.0 },
{ 'kind':'gaussian', 'sd':0.053 },
{ 'kind':'rescale', 'lo':0, 'hi':1 } ]
}
MODEL_NAME = 'BrainSignals'
# numeric 'constants' representing choices
OUTPUT_DEFAULT = 0
OUTPUT_ROOTS = 1
OUTPUT_ALL = 2
OUTPUT_SPECIFY = 3
OUTPUT_DEFAULTS_PLUS = 4
TIME_FROM_FILE = 0
TIME_SPECIFY = 1
PRIORITISE_DATA = 0
PRIORITISE_TIME = 1
FILE_DATA = 0
SYNTH_DATA = 1
# some of these details may get overridden by prefs file, but set defaults here
class Config(object):
def __init__(self, args=[]):
self.home = BCMD_HOME
self.parser = PARSER
self.prefs = os.path.join(USER_HOME, PREFS)
self.work = WORK
self.resources = RESOURCES
self.model_path = MODEL_PATH
self.input_path = INPUT_PATH
self.extensions = EXTENSIONS
self.model_name = MODEL_NAME
self.model_src = MODEL_NAME + EXTENSIONS['modeldef']
self.input_file = MODEL_NAME + EXTENSIONS['input']
self.model_dir = MODEL_PATH[0]
self.input_dir = INPUT_PATH[0]
self.debug_verbosity = 5
self.release_verbosity = 5
self.debug = True
self.match_input = True
self.match_outputs = True
self.coarse = True
self.detail = False
self.coarse_name = MODEL_NAME + EXTENSIONS['out']
self.detail_name = MODEL_NAME + EXTENSIONS['detail']
self.generate_name = 'generated' + EXTENSIONS['input']
self.generate_dir = self.input_dir
self.use_generated = True
self.run_generated = True
self.graph_unused = True
self.graph_init = True
self.graph_self = False
self.graph_clusters = True
self.graph_params = True
self.graph_LR = False
self.latex_tabular = False
self.latex_displaystyle = True
self.latex_align = False
self.export_derived = False
self.default_width = 800
self.default_height= 600
self.param_file = os.path.join(self.input_dir, 'params' + EXTENSIONS['input'])
self.use_param_file = False
self.use_explicit = False
self.omit_non_model_params = True
self.steady_duration = 1000
self.do_steady = 0
self.match_inputs = True
self.time_from_file = TIME_FROM_FILE
self.time_file = ''
self.time_rate = 100
self.time_duration = 10
self.priority = PRIORITISE_DATA
self.data_file = ''
self.shared_data_file = True
self.data_source = SYNTH_DATA
self.output_header = True
self.output_subset = OUTPUT_DEFAULT
self.output_model_only = True
self.auto_parse = True
self.max_inits = 20
self.presets = FACTORY_PRESETS
# arg processing precedes loading so that we can specify a different config
self.process_args(args)
self.load()
def process_args(self, args):
# TODO
pass
def load(self):
try:
with open(self.prefs) as f:
prefs = eval(f.read())
for field in PREF_FIELDS:
if field in prefs:
self.__dict__[field] = prefs[field]
except IOError as e:
print >> sys.stderr, "Error loading configuration file %s: %s" % (self.prefs, e.strerror)
def save(self):
try:
with open(self.prefs, 'w') as f:
pprint.pprint(self.__dict__, stream=f)
except IOError as e:
print >> sys.stderr, "Error saving configuration file %s: %s" % (self.prefs, e.strerror)
def set_model(self, fullpath):
if fullpath:
path, file = os.path.split(fullpath)
name, ext = os.path.splitext(file)
self.model_name = name
self.model_src = file
self.model_dir = path
if self.match_input:
self.input_file = name + self.extensions['input']
if self.match_outputs:
self.coarse_name = name + self.extensions['out']
self.detail_name = name + self.extensions['detail']
# TODO: actually search the input path?
self.input_dir = path
def set_input(self, fullpath):
if fullpath:
self.input_dir, self.input_file = os.path.split(fullpath)
if self.match_outputs:
input_base = os.path.splitext(self.input_file)[0]
self.coarse_name = input_base + self.extensions['out']
self.detail_name = input_base + self.extensions['detail']
def set_param_file(self, fullpath):
if fullpath:
self.param_file = fullpath
self.use_param_file = True
def get_model_path_list(self):
# may want to be a bit more sophisticated about this later
return [self.model_dir] + self.model_path
def set_generate_dir(self, dir):
if dir:
self.generate_dir = dir
def set_time_file(self, fullpath):
if fullpath:
self.time_file = fullpath
if self.shared_data_file:
self.data_file = fullpath
def set_data_file(self, fullpath):
if fullpath:
self.data_file = fullpath
if self.shared_data_file:
self.time_file = fullpath
| bcmd/BCMD | bgui/Config.py | Python | gpl-2.0 | 9,214 | [
"Gaussian"
] | e7ce1a086fe4098f5b92d07cd158a0750cbd540fc344f8cc3dfe2fab2d09615f |
#!/usr/bin/env python
import pyscf
from benchmarking_utils import setup_logger, get_cpu_timings
log = setup_logger()
for n in (30, 50):
mol = pyscf.gto.M(atom=['H 0 0 %f' % i for i in range(n)],
basis='ccpvqz')
mf = mol.RHF().run()
mycc = mf.CCSD()
eris = mycc.ao2mo()
_, t1, t2 = mycc.get_init_guess()
cpu0 = get_cpu_timings()
mycc.update_amps(t1, t2, eris)
log.timer('H%d cc-pVQZ CCSD iteration' % n, *cpu0)
| sunqm/pyscf | examples/2-benchmark/ccsd_iteration.py | Python | apache-2.0 | 467 | [
"PySCF"
] | 2d1c0fefc92fb767cd1c531e5f21d361db53e5d6a5d4fd43e14762bee74bb486 |
import re
import numpy
import math
try:
# Python 3.x
import collections.abc as collections
except ImportError:
# Python 2.x
import collections
import PyQt5.QtCore
# Load dependencies
import ovito
import ovito.data
# Load the native code module
import Particles
# Inject selected classes into parent module.
ovito.data.SimulationCell = Particles.SimulationCell
ovito.data.ParticleProperty = Particles.ParticleProperty
ovito.data.Bonds = Particles.Bonds
ovito.data.SurfaceMesh = Particles.SurfaceMesh
ovito.data.ParticleTypeProperty = Particles.ParticleTypeProperty
ovito.data.ParticleType = Particles.ParticleType
ovito.data.BondProperty = Particles.BondProperty
ovito.data.BondTypeProperty = Particles.BondTypeProperty
ovito.data.BondType = Particles.BondType
# For backward-compatibility with OVITO 2.5.1:
def _ParticleProperty_data_attribute_name(self):
if self.type != Particles.ParticleProperty.Type.User:
return re.sub('\W|^(?=\d)','_', self.name).lower()
else:
return None
Particles.ParticleProperty._data_attribute_name = property(_ParticleProperty_data_attribute_name)
# Access particle and bond properties by their name (not display title).
def _ParticleProperty_data_key(self):
return self.name
Particles.ParticleProperty._data_key = property(_ParticleProperty_data_key)
Particles.BondProperty._data_key = property(_ParticleProperty_data_key)
# Implement the 'particle_properties' attribute of the DataCollection class.
def _DataCollection_particle_properties(self):
"""
Returns a read-only dictionary view that provides access to the :py:class:`ParticleProperty`
objects stored in this :py:class:`!DataCollection`.
"""
# Helper class used to implement the 'particle_properties' property of the DataCollection class.
class _ParticlePropertyView(collections.Mapping):
def __init__(self, objects):
self._objects = objects
def __len__(self):
# Count the number of ParticleProperty objects in the collection.
return sum(isinstance(obj, ovito.data.ParticleProperty) for obj in self._objects)
def __getitem__(self, key):
if not isinstance(key, str):
raise TypeError("Property name key is not a string.")
for obj in self._objects:
if isinstance(obj, ovito.data.ParticleProperty):
if obj.name == key:
return obj
raise KeyError("The DataCollection does not contain a particle property with the name '%s'." % key)
def __iter__(self):
for obj in self._objects:
if isinstance(obj, ovito.data.ParticleProperty):
yield obj.name
def __getattr__(self, name):
for obj in self._objects:
if isinstance(obj, ovito.data.ParticleProperty):
if obj.type != ovito.data.ParticleProperty.Type.User and re.sub('\W|^(?=\d)','_', obj.name).lower() == name:
return obj
raise AttributeError("DataCollection does not contain the particle property '%s'." % name)
def __repr__(self):
return repr(dict(self))
return _ParticlePropertyView(self.objects)
ovito.data.DataCollection.particle_properties = property(_DataCollection_particle_properties)
# Implement the 'bond_properties' attribute of the DataCollection class.
def _DataCollection_bond_properties(self):
"""
Returns a dictionary view that provides access to the :py:class:`BondProperty`
instances stored in this :py:class:`!DataCollection`.
"""
# Helper class used to implement the 'bond_properties' property of the DataCollection class.
class _BondPropertyView(collections.Mapping):
def __init__(self, objects):
self._objects = objects
def __len__(self):
# Count the number of BondProperty objects in the collection.
return sum(isinstance(obj, ovito.data.BondProperty) for obj in self._objects)
def __getitem__(self, key):
if not isinstance(key, str):
raise TypeError("Property name key is not a string.")
for obj in self._objects:
if isinstance(obj, ovito.data.BondProperty):
if obj.name == key:
return obj
raise KeyError("The DataCollection contains no bond property with the name '%s'." % key)
def __iter__(self):
for obj in self._objects:
if isinstance(obj, ovito.data.BondProperty):
yield obj.name
def __getattr__(self, name):
for obj in self._objects:
if isinstance(obj, ovito.data.BondProperty):
if obj.type != ovito.data.BondProperty.Type.User and re.sub('\W|^(?=\d)','_', obj.name).lower() == name:
return obj
raise AttributeError("DataCollection does not contain the bond property '%s'." % name)
return _BondPropertyView(self.objects)
ovito.data.DataCollection.bond_properties = property(_DataCollection_bond_properties)
# Implement 'cell' attribute of DataCollection class.
def _DataCollection_cell(self):
"""
Returns the :py:class:`SimulationCell` stored in this :py:class:`!DataCollection`.
Accessing this property raises an ``AttributeError`` if the data collection
contains no simulation cell information.
"""
for obj in self.objects:
if isinstance(obj, ovito.data.SimulationCell):
return obj
raise AttributeError("This DataCollection contains no simulation cell.")
ovito.data.DataCollection.cell = property(_DataCollection_cell)
# Implement 'bonds' attribute of DataCollection class.
def _DataCollection_bonds(self):
"""
Returns the :py:class:`Bonds` object stored in this :py:class:`!DataCollection`.
Accessing this property raises an ``AttributeError`` if the data collection
contains no bonds.
"""
for obj in self.objects:
if isinstance(obj, ovito.data.Bonds):
return obj
raise AttributeError("This DataCollection contains no bonds data object.")
ovito.data.DataCollection.bonds = property(_DataCollection_bonds)
# Implement 'surface' attribute of DataCollection class.
def _DataCollection_surface(self):
"""
Returns the :py:class:`SurfaceMesh` in this :py:class:`!DataCollection`.
Accessing this property raises an ``AttributeError`` if the data collection
contains no surface mesh instance.
"""
for obj in self.objects:
if isinstance(obj, ovito.data.SurfaceMesh):
return obj
raise AttributeError("This DataCollection contains no surface mesh.")
ovito.data.DataCollection.surface = property(_DataCollection_surface)
# Returns a NumPy array wrapper for a particle property.
def _ParticleProperty_array(self):
"""
This attribute returns a NumPy array, which provides read access to the per-particle data stored in this particle property object.
The returned array is one-dimensional for scalar particle properties (:py:attr:`.components` == 1),
or two-dimensional for vector properties (:py:attr:`.components` > 1). The outer length of the array is
equal to the number of particles in both cases.
Note that the returned NumPy array is read-only and provides a view of the internal data.
No copy of the data, which may be shared by multiple objects, is made. If you want to modify the
data stored in this particle property, use :py:attr:`.marray` instead.
"""
return numpy.asarray(self)
Particles.ParticleProperty.array = property(_ParticleProperty_array)
# Returns a NumPy array wrapper for a particle property with write access.
def _ParticleProperty_marray(self):
"""
This attribute returns a *mutable* NumPy array providing read/write access to the internal per-particle data.
The returned array is one-dimensional for scalar particle properties (:py:attr:`.components` == 1),
or two-dimensional for vector properties (:py:attr:`.components` > 1). The outer length of the array is
equal to the number of particles in both cases.
.. note::
After you are done modifying the data in the returned NumPy array, you must call
:py:meth:`.changed`! Calling this method is necessary to inform the data pipeline system
that the input particle data has changed and the modification pipeline needs to be re-evaluated.
The reason is that OVITO cannot automatically detect modifications made by the script to
the returned NumPy array. Therefore, an explicit call to :py:meth:`.changed` is necessary.
**Example**
.. literalinclude:: ../example_snippets/mutable_array.py
"""
class DummyClass:
pass
o = DummyClass()
o.__array_interface__ = self.__mutable_array_interface__
# Create reference to particle property object to keep it alive.
o.__base_property = self
return numpy.asarray(o)
# This is needed to enable the augmented assignment operators (+=, -=, etc.) for the 'marray' property.
def _ParticleProperty_marray_assign(self, other):
if not hasattr(other, "__array_interface__"):
raise ValueError("Only objects supporting the array interface can be assigned to the 'marray' property.")
o = other.__array_interface__
s = self.__mutable_array_interface__
if o["shape"] != s["shape"] or o["typestr"] != s["typestr"] or o["data"] != s["data"]:
raise ValueError("Assignment to the 'marray' property is restricted. Left and right-hand side must be identical.")
# Assume that the data has been changed in the meantime.
self.changed()
Particles.ParticleProperty.marray = property(_ParticleProperty_marray, _ParticleProperty_marray_assign)
# For backward compatibility with OVITO 2.5.1:
Particles.ParticleProperty.mutable_array = property(lambda self: self.marray)
# Returns a NumPy array wrapper for a bond property.
def _BondProperty_array(self):
"""
This attribute returns a NumPy array, which provides read access to the per-bond data stored in this bond property object.
The returned array is one-dimensional for scalar bond properties (:py:attr:`.components` == 1),
or two-dimensional for vector properties (:py:attr:`.components` > 1). The outer length of the array is
equal to the number of half-bonds in both cases.
Note that the returned NumPy array is read-only and provides a view of the internal data.
No copy of the data, which may be shared by multiple objects, is made. If you want to modify the
data stored in this bond property, use :py:attr:`.marray` instead.
"""
return numpy.asarray(self)
Particles.BondProperty.array = property(_BondProperty_array)
# Returns a NumPy array wrapper for a bond property with write access.
def _BondProperty_marray(self):
"""
This attribute returns a *mutable* NumPy array providing read/write access to the internal per-bond data.
The returned array is one-dimensional for scalar bond properties (:py:attr:`.components` == 1),
or two-dimensional for vector properties (:py:attr:`.components` > 1). The outer length of the array is
equal to the number of half-bonds in both cases.
.. note::
After you are done modifying the data in the returned NumPy array, you must call
:py:meth:`.changed`! Calling this method is necessary to inform the data pipeline system
that the input bond data has changed and the modification pipeline needs to be re-evaluated.
The reason is that OVITO cannot automatically detect modifications made by the script to
the returned NumPy array. Therefore, an explicit call to :py:meth:`.changed` is necessary.
"""
class DummyClass:
pass
o = DummyClass()
o.__array_interface__ = self.__mutable_array_interface__
# Create reference to particle property object to keep it alive.
o.__base_property = self
return numpy.asarray(o)
Particles.BondProperty.marray = property(_BondProperty_marray, _ParticleProperty_marray_assign)
# Returns a NumPy array wrapper for bonds list.
def _Bonds_array(self):
""" This attribute returns a NumPy array providing direct access to the bonds list.
The returned array is two-dimensional and contains pairs of particle indices connected by a bond.
The array's shape is *N x 2*, where *N* is the number of half-bonds. Each pair-wise bond occurs twice
in the array, once for the connection A->B and second time for the connection B->A.
Particle indices start at 0.
Note that the returned NumPy array is read-only and provides a view of the internal data.
"""
return numpy.asarray(self)
Particles.Bonds.array = property(_Bonds_array)
# Returns a NumPy array wrapper for the bond PBC shift vectors.
def _Bonds_pbc_vectors(self):
""" A NumPy array providing read access to the PBC shift vectors of bonds.
The returned array's shape is *N x 3*, where *N* is the number of half-bonds. It contains the
periodic shift vector for each half-bond.
A PBC shift vector consists of three integers, which specify how many times (and in which direction)
the corresonding half-bond crosses the periodic boundaries of the simulation cell. For example, a shift vector (0,-1,0)
indicates that the half-bond crosses the periodic boundary in the negative Y direction
once. In other words, the particle where the half-bond originates from is located
close to the lower edge of the simulation cell in the Y direction while the second particle is located
close to the opposite side of the box.
The PBC shift vectors are important for visualizing the bonds between particles with wrapped coordinates,
which are located on opposite sides of a periodic cell. When the PBC shift vector of a bond is (0,0,0), OVITO assumes that
both particles connected by the bond are located in the same periodic image and the bond is rendered such that
it directly connects the two particles without going through a cell boundary.
Note that, if the PBC shift vector of a half-bond A->B is (n\ :sub:`x`, n\ :sub:`y`, n\ :sub:`z`), then
the shift vector of the reverse half-bond B->A is always (-n\ :sub:`x`, -n\ :sub:`y`, -n\ :sub:`z`).
"""
class DummyClass:
pass
o = DummyClass()
o.__array_interface__ = self._pbc_vectors
# Create reference to particle property object to keep it alive.
o.__base_property = self
return numpy.asarray(o)
Particles.Bonds.pbc_vectors = property(_Bonds_pbc_vectors)
def _Bonds_add(self, p1, p2, pbc_shift = (0,0,0)):
""" Creates a new half-bond from particle *p1* to particle *p2*.
To also create a reverse half-bond from *p2* to *p1*, use :py:meth:`.add_full` instead.
:param int p1: Zero-based index of the particle at which the bonds originates.
:param int p2: Zero-based index of the particle the bonds leads to.
:param pbc_shift: A tuple of three integers, which specifies how often each periodic
boundary of the simulation cell is crossed when following the new bond from *p1* to *p2*.
This information is needed by OVITO to correctly wrap bonds at periodic boundaries.
See :py:attr:`.pbc_vectors` array.
"""
self.addBond(p1, p2, pbc_shift)
Particles.Bonds.add = _Bonds_add
def _Bonds_add_full(self, p1, p2, pbc_shift = (0,0,0)):
""" Creates two half-bonds between the particles *p1* and *p2*. This is equivalent to
two calls to :py:meth:`.add`.
:param int p1: Zero-based index of the first particle.
:param int p2: Zero-based index of the second particle.
:param pbc_shift: A tuple of three integers, which specifies how often each periodic
boundary of the simulation cell is crossed when following the new bond from *p1* to *p2*.
This information is needed by OVITO to correctly wrap bonds at periodic boundaries.
See :py:attr:`.pbc_vectors` array.
"""
self.addBond(p1, p2, pbc_shift)
self.addBond(p2, p1, (-pbc_shift[0], -pbc_shift[1], -pbc_shift[2]))
Particles.Bonds.add_full = _Bonds_add_full
# Implement 'pbc' property of SimulationCell class.
def _get_SimulationCell_pbc(self):
""" A tuple with three boolean values, which specify periodic boundary flags of the simulation cell along each cell vector. """
return (self.pbc_x, self.pbc_y, self.pbc_z)
def _set_SimulationCell_pbc(self, flags):
assert(len(flags) == 3) # Expected tuple with three Boolean flags.
self.pbc_x = flags[0]
self.pbc_y = flags[1]
self.pbc_z = flags[2]
Particles.SimulationCell.pbc = property(_get_SimulationCell_pbc, _set_SimulationCell_pbc)
class CutoffNeighborFinder(Particles.CutoffNeighborFinder):
"""
A utility class that computes particle neighbor lists.
This class allows to iterate over the neighbors of each particle within a given cutoff distance.
You can use it to build neighbors lists or perform other kinds of analyses that require neighbor information.
The constructor takes a positive cutoff radius and a :py:class:`DataCollection <ovito.data.DataCollection>`
containing the input particle positions and the cell geometry (including periodic boundary flags).
Once the :py:class:`!CutoffNeighborFinder` has been constructed, you can call its :py:meth:`.find` method to
iterate over the neighbors of a specific particle, for example:
.. literalinclude:: ../example_snippets/cutoff_neighbor_finder.py
If you want to determine the *N* nearest neighbors of a particle,
use the :py:class:`NearestNeighborFinder` class instead.
"""
def __init__(self, cutoff, data_collection):
""" This is the constructor. """
super(self.__class__, self).__init__()
if not hasattr(data_collection, 'position'):
raise KeyError("Data collection does not contain particle positions.")
if not hasattr(data_collection, 'cell'):
raise KeyError("Data collection does not contain simulation cell information.")
self.particle_count = data_collection.number_of_particles
self.prepare(cutoff, data_collection.position, data_collection.cell)
def find(self, index):
"""
Returns an iterator over all neighbors of the given particle.
:param int index: The index of the central particle whose neighbors should be iterated. Particle indices start at 0.
:returns: A Python iterator that visits all neighbors of the central particle within the cutoff distance.
For each neighbor the iterator returns an object with the following attributes:
* **index**: The index of the current neighbor particle (starting at 0).
* **distance**: The distance of the current neighbor from the central particle.
* **distance_squared**: The squared neighbor distance.
* **delta**: The three-dimensional vector connecting the central particle with the current neighbor (taking into account periodicity).
* **pbc_shift**: The periodic shift vector, which specifies how often each periodic boundary of the simulation cell is crossed when going from the central particle to the current neighbor.
Note that all periodic images of particles within the cutoff radius are visited. Thus, the same particle index may appear multiple times in the neighbor
list of a central particle. In fact, the central particle may be among its own neighbors in a sufficiently small periodic simulation cell.
However, the computed vector (``delta``) and PBC shift (``pbc_shift``) taken together will be unique for each visited image of a neighboring particle.
"""
if index < 0 or index >= self.particle_count:
raise IndexError("Particle index is out of range.")
# Construct the C++ neighbor query.
query = Particles.CutoffNeighborFinder.Query(self, int(index))
# Iterate over neighbors.
while not query.atEnd:
yield query
query.next()
ovito.data.CutoffNeighborFinder = CutoffNeighborFinder
class NearestNeighborFinder(Particles.NearestNeighborFinder):
"""
A utility class that finds the *N* nearest neighbors of a particle.
The constructor takes the number of requested nearest neighbors, *N*, and a :py:class:`DataCollection <ovito.data.DataCollection>`
containing the input particle positions and the cell geometry (including periodic boundary flags).
*N* must be a positive integer not greater than 30 (which is the built-in maximum supported by this class).
Once the :py:class:`!NearestNeighborFinder` has been constructed, you can call its :py:meth:`.find` method to
iterate over the sorted list of nearest neighbors of a specific particle, for example:
.. literalinclude:: ../example_snippets/nearest_neighbor_finder.py
If you want to iterate over all neighbors within a certain cutoff radius of a central particle,
use the :py:class:`CutoffNeighborFinder` class instead.
"""
def __init__(self, N, data_collection):
""" This is the constructor. """
super(self.__class__, self).__init__(N)
if N<=0 or N>30:
raise ValueError("The requested number of nearest neighbors is out of range.")
if not hasattr(data_collection, 'position'):
raise KeyError("Data collection does not contain particle positions.")
if not hasattr(data_collection, 'cell'):
raise KeyError("Data collection does not contain simulation cell information.")
self.particle_count = data_collection.number_of_particles
self.prepare(data_collection.position, data_collection.cell)
def find(self, index):
"""
Returns an iterator that visits the *N* nearest neighbors of the given particle in order of ascending distance.
:param int index: The index of the central particle whose neighbors should be iterated. Particle indices start at 0.
:returns: A Python iterator that visits the *N* nearest neighbors of the central particle in order of ascending distance.
For each visited neighbor the iterator returns an object with the following attributes:
* **index**: The index of the current neighbor particle (starting at 0).
* **distance**: The distance of the current neighbor from the central particle.
* **distance_squared**: The squared neighbor distance.
* **delta**: The three-dimensional vector connecting the central particle with the current neighbor (taking into account periodicity).
Note that several periodic images of the same particle may be visited. Thus, the same particle index may appear multiple times in the neighbor
list of a central particle. In fact, the central particle may be among its own neighbors in a sufficiently small periodic simulation cell.
However, the computed neighbor vector (``delta``) will be unique for each visited image of a neighboring particle.
The number of neighbors actually visited may be smaller than the requested number, *N*, if the
system contains too few particles and no periodic boundary conditions are used.
"""
if index < 0 or index >= self.particle_count:
raise IndexError("Particle index is out of range.")
# Construct the C++ neighbor query.
query = Particles.NearestNeighborFinder.Query(self)
query.findNeighbors(int(index))
# Iterate over neighbors.
for i in range(query.count):
yield query[i]
ovito.data.NearestNeighborFinder = NearestNeighborFinder
def _ParticleProperty_create(prop_type, num_particles):
"""
Static factory function that creates a new :py:class:`!ParticleProperty` instance for a standard particle property.
To create a new user-defined property, use :py:meth:`.create_user` instead.
Note that this factory function is a low-level method. If you want to add a new
particle property to an existing :py:class:`~ovito.data.DataCollection`, you can do so using the high-level method
:py:meth:`~ovito.data.DataCollection.create_particle_property` instead.
:param ParticleProperty.Type prop_type: The standard particle property to create. See the :py:attr:`.type` attribute for a list of possible values.
:param int num_particles: The number of particles. This determines the size of the allocated data array.
:returns: A newly created instance of the :py:class:`!ParticleProperty` class or one of its sub-classes.
"""
assert(isinstance(prop_type, ovito.data.ParticleProperty.Type))
assert(prop_type != ovito.data.ParticleProperty.Type.User)
assert(num_particles >= 0)
return ovito.data.ParticleProperty.createStandardProperty(ovito.dataset, num_particles, prop_type, 0, True)
ovito.data.ParticleProperty.create = staticmethod(_ParticleProperty_create)
def _ParticleProperty_create_user(name, data_type, num_particles, num_components = 1):
"""
Static factory function that creates a new :py:class:`!ParticleProperty` instance for a user-defined particle property.
To create one of the standard properties, use :py:meth:`.create` instead.
Note that this factory function is a low-level method. If you want to add a new user-defined
particle property to an existing :py:class:`~ovito.data.DataCollection`, you can do so using the high-level method
:py:meth:`~ovito.data.DataCollection.create_user_particle_property` instead.
:param str name: The name of the user-defined particle property to create.
:param str data_type: Must be either ``"int"`` or ``"float"``.
:param int num_particles: The number of particles. This determines the size of the allocated data array.
:param int num_components: The number of components when creating a vector property.
:returns: A newly created instance of the :py:class:`!ParticleProperty` class.
"""
assert(num_particles >= 0)
assert(num_components >= 1)
if data_type == "int":
data_type = PyQt5.QtCore.QMetaType.type("int")
elif data_type == "float":
data_type = PyQt5.QtCore.QMetaType.type("FloatType")
else:
raise RuntimeError("Invalid data type. Only 'int' or 'float' are allowed.")
return ovito.data.ParticleProperty.createUserProperty(ovito.dataset, num_particles, data_type, num_components, 0, name, True)
ovito.data.ParticleProperty.create_user = staticmethod(_ParticleProperty_create_user)
# Extend DataCollection class by adding the 'create_particle_property()' and 'create_user_particle_property()' methods.
def _DataCollection_create_particle_property(self, property_type, data = None):
"""
Adds a standard particle property to this data collection.
If the specified particle property already exists in this data collection, the existing property instance is returned.
Otherwise the method creates a new property instance using :py:meth:`ParticleProperty.create` and adds it to this data collection.
The optional parameter *data* allows to directly set or initialize the values of the particle property.
:param ParticleProperty.Type property_type: The standard particle property to create. See the :py:attr:`ParticleProperty.type` attribute for a list of possible values.
:param data: An optional data array (e.g. NumPy array), which contains the per-particle values used to initialize the particle property.
The size of the array must match the number of particles in this data collection (see :py:attr:`.number_of_particles` attribute).
:returns: A newly created instance of the :py:class:`ovito.data.ParticleProperty` class or one of its sub-classes if the property did not exist yet in the data collection.
Otherwise, the existing particle property object is returned.
"""
# Check if property already exists in the data collection.
prop = None
position_prop = None
for obj in self.values():
if isinstance(obj, ovito.data.ParticleProperty):
if obj.type == property_type:
prop = obj
if obj.type == ovito.data.ParticleProperty.Type.Position:
position_prop = obj
# First we have to determine the number of particles. This requires the 'Position' particle property
if position_prop is None:
raise RuntimeError("Cannot add new particle property to data collection, because data collection contains no particles.")
num_particles = position_prop.size
if prop is None:
# If property does not exists yet, create a new ParticleProperty instance.
prop = ovito.data.ParticleProperty.create(property_type, num_particles)
self.add(prop)
else:
# Otherwise, make sure the existing property is a fresh copy so we can safely modify it.
prop = self.copy_if_needed(prop)
# Initialize property with per-particle data if provided.
if data is not None:
prop.marray[:] = data
prop.changed()
return prop
ovito.data.DataCollection.create_particle_property = _DataCollection_create_particle_property
def _DataCollection_create_user_particle_property(self, name, data_type, num_components=1, data = None):
"""
Adds a user-defined particle property to this data collection.
If a particle property with the given name already exists in this data collection, the existing property instance is returned.
Otherwise the method creates a new property instance using :py:meth:`ParticleProperty.create_user` and adds it to this data collection.
The optional parameter *data* allows to directly set or initialize the values of the particle property.
:param str name: The name of the user-defined particle property to create.
:param str data_type: Must be either ``"int"`` or ``"float"``.
:param int num_components: The number of components when creating a vector property.
:param data: An optional data array (e.g. NumPy array), which contains the per-particle values used to initialize the particle property.
The size of the array must match the number of particles in this data collection (see :py:attr:`.number_of_particles` attribute).
:returns: A newly created instance of the :py:class:`~ovito.data.ParticleProperty` class or one of its sub-classes if the property did not exist yet in the data collection.
Otherwise, the existing particle property object is returned.
"""
# Check if property already exists in the data collection.
prop = None
position_prop = None
for obj in self.values():
if isinstance(obj, ovito.data.ParticleProperty):
if obj.name == name:
prop = obj
if obj.type == ovito.data.ParticleProperty.Type.Position:
position_prop = obj
# First we have to determine the number of particles. This requires the 'Position' particle property
if position_prop is None:
raise RuntimeError("Cannot add new particle property to data collection, because data collection contains no particles.")
num_particles = position_prop.size
if prop is None:
# If property does not exists yet, create a new ParticleProperty instance.
prop = ovito.data.ParticleProperty.create_user(name, data_type, num_particles, num_components)
self.add(prop)
else:
# Otherwise, make sure the existing property is a fresh copy so we can safely modify it.
prop = self.copy_if_needed(prop)
# Initialize property with per-particle data if provided.
if data is not None:
prop.marray[:] = data
prop.changed()
return prop
ovito.data.DataCollection.create_user_particle_property = _DataCollection_create_user_particle_property
def _BondProperty_create(prop_type, num_bonds):
"""
Static factory function that creates a new :py:class:`!BondProperty` instance for a standard bond property.
To create a new user-defined property, use :py:meth:`.create_user` instead.
Note that this factory function is a low-level method. If you want to add a new
bond property to an existing :py:class:`~ovito.data.DataCollection`, you can do so using the high-level method
:py:meth:`~ovito.data.DataCollection.create_bond_property` instead.
:param BondProperty.Type prop_type: The standard bond property to create. See the :py:attr:`.type` attribute for a list of possible values.
:param int num_bonds: The number of half-bonds. This determines the size of the allocated data array.
:returns: A newly created instance of the :py:class:`!BondProperty` class or one of its sub-classes.
"""
assert(isinstance(prop_type, ovito.data.BondProperty.Type))
assert(prop_type != ovito.data.BondProperty.Type.User)
assert(num_bonds >= 0)
return ovito.data.BondProperty.createStandardProperty(ovito.dataset, num_bonds, prop_type, 0, True)
ovito.data.BondProperty.create = staticmethod(_BondProperty_create)
def _BondProperty_create_user(name, data_type, num_bonds, num_components = 1):
"""
Static factory function that creates a new :py:class:`!BondProperty` instance for a user-defined bond property.
To create one of the standard properties, use :py:meth:`.create` instead.
Note that this factory function is a low-level method. If you want to add a new user-defined
bond property to an existing :py:class:`~ovito.data.DataCollection`, you can do so using the high-level method
:py:meth:`~ovito.data.DataCollection.create_user_bond_property` instead.
:param str name: The name of the user-defined bond property to create.
:param str data_type: Must be either ``"int"`` or ``"float"``.
:param int num_bonds: The number of half-bonds. This determines the size of the allocated data array.
:param int num_components: The number of components when creating a vector property.
:returns: A newly created instance of the :py:class:`!BondProperty` class.
"""
assert(num_bonds >= 0)
assert(num_components >= 1)
if data_type == "int":
data_type = PyQt5.QtCore.QMetaType.type("int")
elif data_type == "float":
data_type = PyQt5.QtCore.QMetaType.type("FloatType")
else:
raise RuntimeError("Invalid data type. Only 'int' or 'float' are allowed.")
return ovito.data.BondProperty.createUserProperty(ovito.dataset, num_bonds, data_type, num_components, 0, name, True)
ovito.data.BondProperty.create_user = staticmethod(_BondProperty_create_user)
# Extend DataCollection class by adding the 'create_bond_property()' and 'create_user_bond_property()' methods.
def _DataCollection_create_bond_property(self, property_type, data = None):
"""
Adds a standard bond property to this data collection.
If the specified particle property already exists in this data collection, the existing property instance is returned.
Otherwise the method creates a new property instance using :py:meth:`BondProperty.create` and adds it to this data collection.
The optional parameter *data* allows to directly set or initialize the values of the bond property.
:param BondProperty.Type property_type: The standard bond property to create. See the :py:attr:`BondProperty.type` attribute for a list of possible values.
:param data: An optional data array (e.g. NumPy array), which contains the per-bond values used to initialize the property.
The size of the array must match the number of half-bonds in this data collection (see :py:attr:`.number_of_half_bonds` attribute).
:returns: A newly created instance of the :py:class:`ovito.data.BondProperty` class or one of its sub-classes if the property did not exist yet in the data collection.
Otherwise, the existing bond property object is returned.
"""
# Check if property already exists in the data collection.
prop = None
for obj in self.objects:
if isinstance(obj, ovito.data.BondProperty):
if obj.type == property_type:
prop = obj
bonds_obj = None
for obj in self.objects:
if isinstance(obj, ovito.data.Bonds):
bonds_obj = obj
# First we have to determine the number of bonds.
if bonds_obj is None:
raise RuntimeError("Cannot add new bond property to data collection, because data collection contains no bonds.")
num_bonds = bonds_obj.size
if prop is None:
# If property does not exists yet, create a new BondProperty instance.
prop = ovito.data.BondProperty.create(property_type, num_bonds)
self.add(prop)
else:
# Otherwise, make sure the existing property is a fresh copy so we can safely modify it.
prop = self.copy_if_needed(prop)
# Initialize property with per-bond data if provided.
if data is not None:
prop.marray[:] = data
prop.changed()
return prop
ovito.data.DataCollection.create_bond_property = _DataCollection_create_bond_property
def _DataCollection_create_user_bond_property(self, name, data_type, num_components=1, data = None):
"""
Adds a custom bond property to this data collection.
If a bond property with the given name already exists in this data collection, the existing property instance is returned.
Otherwise the method creates a new property instance using :py:meth:`BondProperty.create_user` and adds it to this data collection.
The optional parameter *data* allows to directly set or initialize the values of the bond property.
:param str name: The name of the user-defined bond property to create.
:param str data_type: Must be either ``"int"`` or ``"float"``.
:param int num_components: The number of components when creating a vector property.
:param data: An optional data array (e.g. NumPy array), which contains the per-bond values used to initialize the bond property.
The size of the array must match the number of half-bonds in this data collection (see :py:attr:`.number_of_half_bonds` attribute).
:returns: A newly created instance of the :py:class:`~ovito.data.BondProperty` class or one of its sub-classes if the property did not exist yet in the data collection.
Otherwise, the existing bond property object is returned.
"""
# Check if property already exists in the data collection.
prop = None
for obj in self.values():
if isinstance(obj, ovito.data.BondProperty):
if obj.name == name:
prop = obj
bonds_obj = None
for obj in self.objects:
if isinstance(obj, ovito.data.Bonds):
bonds_obj = obj
# First we have to determine the number of bonds.
if bonds_obj is None:
raise RuntimeError("Cannot add new bond property to data collection, because data collection contains no bonds.")
num_bonds = bonds_obj.size
if prop is None:
# If property does not exists yet, create a new BondProperty instance.
prop = ovito.data.BondProperty.create_user(name, data_type, num_bonds, num_components)
self.add(prop)
else:
# Otherwise, make sure the existing property is a fresh copy so we can safely modify it.
prop = self.copy_if_needed(prop)
# Initialize property with per-particle data if provided.
if data is not None:
prop.marray[:] = data
prop.changed()
return prop
ovito.data.DataCollection.create_user_bond_property = _DataCollection_create_user_bond_property
# Extend the DataCollection class with a 'number_of_particles' property.
def _get_DataCollection_number_of_particles(self):
""" The number of particles stored in the data collection. """
# The number of particles is determined by the size of the 'Position' particle property.
for obj in self.objects:
if isinstance(obj, ovito.data.ParticleProperty) and obj.type == ovito.data.ParticleProperty.Type.Position:
return obj.size
return 0
ovito.data.DataCollection.number_of_particles = property(_get_DataCollection_number_of_particles)
# Extend the DataCollection class with a 'number_of_half_bonds' property.
def _get_DataCollection_number_of_half_bonds(self):
"""
The number of half-bonds stored in the data collection.
Note that OVITO internally represents each full bond as two half-bonds, A->B and B->A.
See also :py:attr:`.number_of_full_bonds`.
"""
# The number of bonds is determined by the size of the BondsObject.
try:
return self.bonds.size
except:
return 0
ovito.data.DataCollection.number_of_half_bonds = property(_get_DataCollection_number_of_half_bonds)
# Extend the DataCollection class with a 'number_of_bonds' property.
def _get_DataCollection_number_of_bonds(self):
return self.number_of_half_bonds
ovito.data.DataCollection.number_of_bonds = property(_get_DataCollection_number_of_bonds)
# Extend the DataCollection class with a 'number_of_full_bonds' property.
def _get_DataCollection_number_of_full_bonds(self):
"""
The number of (full) bonds stored in the data collection.
Note that OVITO internally represents each full bond as two half-bonds, A->B and B->A.
See also :py:attr:`.number_of_half_bonds`.
"""
# The number of bonds is determined by the size of the BondsObject.
try:
return self.bonds.size//2
except:
return 0
ovito.data.DataCollection.number_of_full_bonds = property(_get_DataCollection_number_of_full_bonds)
def _ParticleTypeProperty_get_type_by_id(self, id):
"""
Returns the :py:class:`ParticleType` with the given numeric ID from the :py:attr:`.type_list`.
Raises a ``KeyError`` if the ID does not exist.
"""
t = self._get_type_by_id(int(id))
if t is None:
raise KeyError("Particle type with ID %i is not defined." % id)
return t
ovito.data.ParticleTypeProperty.get_type_by_id = _ParticleTypeProperty_get_type_by_id
def _ParticleTypeProperty_get_type_by_name(self, name):
"""
Returns the :py:class:`ParticleType` with the given name from the :py:attr:`.type_list`.
If multiple types exists with the same name, the first type is returned.
Raises a ``KeyError`` if there is no type with such a name.
"""
t = self._get_type_by_name(name)
if t is None:
raise KeyError("Particle type with name '%s' is not defined." % name)
return t
ovito.data.ParticleTypeProperty.get_type_by_name = _ParticleTypeProperty_get_type_by_name
def _BondTypeProperty_get_type_by_id(self, id):
"""
Returns the :py:class:`BondType` with the given numeric ID from the :py:attr:`.type_list`.
Raises a ``KeyError`` if the ID does not exist.
"""
t = self._get_type_by_id(int(id))
if t is None:
raise KeyError("Bond type with ID %i is not defined." % id)
return t
ovito.data.BondTypeProperty.get_type_by_id = _BondTypeProperty_get_type_by_id
def _BondTypeProperty_get_type_by_name(self, name):
"""
Returns the :py:class:`BondType` with the given name from the :py:attr:`.type_list`.
If multiple types exists with the same name, the first type is returned.
Raises a ``KeyError`` if there is no type with such a name.
"""
t = self._get_type_by_name(name)
if t is None:
raise KeyError("Bond type with name '%s' is not defined." % name)
return t
ovito.data.BondTypeProperty.get_type_by_name = _BondTypeProperty_get_type_by_name
class Enumerator(Particles.Bonds.ParticleBondMap):
"""
Utility class that allows efficiently iterating over the bonds of a particle.
The class constructor takes the :py:class:`Bonds` object containing all the bonds
in the system, for which it will first build a lookup table.
After the :py:class:`!Enumerator` has been constructed, the half-bonds of a
particular atom can be visited using the :py:meth:`.bonds_of_particle` method.
Warning: Do not modify the underlying :py:class:`Bonds` object while using the :py:class:`!Enumerator`.
Adding or deleting bonds would render the internal lookup table of the :py:class:`!Enumerator`
invalid.
**Usage example**
.. literalinclude:: ../example_snippets/bonds_enumerator.py
"""
def __init__(self, bonds):
""" This is the constructor. """
super(self.__class__, self).__init__(bonds)
def bonds_of_particle(self, particle_index):
"""
Returns an iterator that yields the indices of the half-bonds connected to the given particle.
The numbers returned by the iterator can be used to index the :py:attr:`Bonds.array`.
"""
eol = self.endOfListValue
currentBondIndex = self.firstBondOfParticle(particle_index)
while currentBondIndex != eol:
yield currentBondIndex
currentBondIndex = self.nextBondOfParticle(currentBondIndex)
ovito.data.Bonds.Enumerator = Enumerator
del Enumerator
| srinath-chakravarthy/ovito | src/plugins/particles/resources/python/ovito/data/particles/__init__.py | Python | gpl-3.0 | 46,733 | [
"OVITO"
] | 641502bf2fdce099009f21f848fa06b21d8b6e2df11061c744c6e982239bbef8 |
#!/usr/bin/python
#
# Copyright 2010 Brian Dolbec <brian.dolbec@gmail.com>
# Copyright(c) 2010, Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
#
"""Provides a breakdown list of USE flags or keywords used and by
what packages according to the Installed package database"""
from __future__ import print_function
import gentoolkit
from gentoolkit.module_base import ModuleBase
from gentoolkit import pprinter as pp
from gentoolkit.flag import get_installed_use, get_flags
from gentoolkit.enalyze.lib import FlagAnalyzer, KeywordAnalyser
from gentoolkit.enalyze.output import nl, AnalysisPrinter
from gentoolkit.package import Package
from gentoolkit.helpers import get_installed_cpvs
import portage
def gather_flags_info(
cpvs=None,
system_flags=None,
include_unset=False,
target="USE",
use_portage=False,
# override-able for testing
_get_flags=get_flags,
_get_used=get_installed_use
):
"""Analyze the installed pkgs USE flags for frequency of use
@type cpvs: list
@param cpvs: optional list of [cat/pkg-ver,...] to analyze or
defaults to entire installed pkg db
@type: system_flags: list
@param system_flags: the current default USE flags as defined
by portage.settings["USE"].split()
@type include_unset: bool
@param include_unset: controls the inclusion of unset USE flags in the report.
@type target: string
@param target: the environment variable being analyzed
one of ["USE", "PKGUSE"]
@type _get_flags: function
@param _get_flags: ovride-able for testing,
defaults to gentoolkit.enalyze.lib.get_flags
@param _get_used: ovride-able for testing,
defaults to gentoolkit.enalyze.lib.get_installed_use
@rtype dict. {flag:{"+":[cat/pkg-ver,...], "-":[cat/pkg-ver,...], "unset":[]}
"""
if cpvs is None:
cpvs = portage.db[portage.root]["vartree"].dbapi.cpv_all()
# pass them in to override for tests
flags = FlagAnalyzer(system_flags,
filter_defaults=False,
target=target,
_get_flags=_get_flags,
_get_used=get_installed_use
)
flag_users = {}
for cpv in cpvs:
if cpv.startswith("virtual"):
continue
if use_portage:
plus, minus, unset = flags.analyse_cpv(cpv)
else:
pkg = Package(cpv)
plus, minus, unset = flags.analyse_pkg(pkg)
for flag in plus:
if flag in flag_users:
flag_users[flag]["+"].append(cpv)
else:
flag_users[flag] = {"+": [cpv], "-": []}
for flag in minus:
if flag in flag_users:
flag_users[flag]["-"].append(cpv)
else:
flag_users[flag] = {"+":[], "-": [cpv]}
if include_unset:
for flag in unset:
if flag in flag_users:
if "unset" in flag_users[flag]:
flag_users[flag]["unset"].append(cpv)
else:
flag_users[flag]["unset"] = [cpv]
else:
flag_users[flag] = {"+": [], "-": [], "unset": [cpv]}
return flag_users
def gather_keywords_info(
cpvs=None,
system_keywords=None,
use_portage=False,
# override-able for testing
keywords=portage.settings["ACCEPT_KEYWORDS"],
analyser = None
):
"""Analyze the installed pkgs 'keywords' for frequency of use
@param cpvs: optional list of [cat/pkg-ver,...] to analyze or
defaults to entire installed pkg db
@param system_keywords: list of the system keywords
@param keywords: user defined list of keywords to check and report on
or reports on all relevant keywords found to have been used.
@param _get_kwds: overridable function for testing
@param _get_used: overridable function for testing
@rtype dict. {keyword:{"stable":[cat/pkg-ver,...], "testing":[cat/pkg-ver,...]}
"""
if cpvs is None:
cpvs = portage.db[portage.root]["vartree"].dbapi.cpv_all()
keyword_users = {}
for cpv in cpvs:
if cpv.startswith("virtual"):
continue
if use_portage:
keyword = analyser.get_inst_keyword_cpv(cpv)
else:
pkg = Package(cpv)
keyword = analyser.get_inst_keyword_pkg(pkg)
#print "returned keyword =", cpv, keyword, keyword[0]
key = keyword[0]
if key in ["~", "-"]:
_kwd = keyword[1:]
if _kwd in keyword_users:
if key in ["~"]:
keyword_users[_kwd]["testing"].append(cpv)
elif key in ["-"]:
#print "adding cpv to missing:", cpv
keyword_users[_kwd]["missing"].append(cpv)
else:
if key in ["~"]:
keyword_users[_kwd] = {"stable": [],
"testing": [cpv], "missing": []}
elif key in ["-"]:
keyword_users[_kwd] = {"stable": [],
"testing": [], "missing": [cpv]}
else:
keyword_users[_kwd] = {"stable": [cpv],
"testing": [], "missing": []}
elif keyword in keyword_users:
keyword_users[keyword]["stable"].append(cpv)
else:
keyword_users[keyword] = {
"stable": [cpv],
"testing": [],
"missing": []
}
return keyword_users
class Analyse(ModuleBase):
"""Installed db analysis tool to query the installed databse
and produce/output stats for USE flags or keywords/mask.
The 'rebuild' action output is in the form suitable for file type output
to create a new package.use, package.keywords, package.unmask
type files in the event of needing to rebuild the
/etc/portage/* user configs
"""
def __init__(self):
ModuleBase.__init__(self)
self.command_name = "enalyze"
self.module_name = "analyze"
self.options = {
"flags": False,
"keywords": False,
"packages": False,
"unset": False,
"verbose": False,
"quiet": False,
'prefix': False,
'portage': True,
"width": 80,
"prepend": "",
}
self.module_opts = {
"-f": ("flags", "boolean", True),
"--flags": ("flags", "boolean", True),
"-k": ("keywords", "boolean", True),
"--keywords": ("keywords", "boolean", True),
"-u": ("unset", "boolean", True),
"--unset": ("unset", "boolean", True),
"-v": ("verbose", "boolean", True),
"--verbose": ("verbose", "boolean", True),
"-p": ("prefix", "boolean", True),
"--prefix": ("prefix", "boolean", True),
"-P": ("prepend", "char", None),
"--prepend": ("prepend", "char", None),
"-G": ("portage", "boolean", False),
"--portage": ("portage", "boolean", False),
"-W": ("width", "int", 80),
"--width": ("width", "int", 80),
}
self.formatted_options = [
(" -h, --help", "Outputs this useage message"),
(" -u, --unset",
"Additionally include any unset USE flags and the packages"),
("", "that could use them"),
(" -v, --verbose",
"Used in the analyze action to output more detailed information"),
(" -p, --prefix",
"Used for testing purposes only, runs report using " +
"a prefix keyword and 'prefix' USE flag"),
(" -P, --prepend",
"Prepend the string to any list output. " +
"ie: prepend '* ' to the ""front of each package being listed."
"This is useful for generating preformatted wiki text."),
#(" -G, --portage",
#"Use portage directly instead of gentoolkit's Package " +
#"object for some operations. Usually a little faster."),
(" -W, --width",
"Format the output to wrap at 'WIDTH' ie: long line output"),
]
self.formatted_args = [
(" use",
"Causes the action to analyze the installed packages USE flags"),
(" pkguse",
"Causes the action to analyze the installed packages PKGUSE flags"),
(" ",
"These are flags that have been set in /etc/portage/package.use"),
(" keywords",
"Causes the action to analyze the installed packages keywords"),
(" packages",
"Causes the action to analyze the installed packages and the"),
(" ",
"USE flags they were installed with"),
(" unmask",
"Causes the action to analyze the installed packages"),
(" ",
"for those that need to be unmasked")
]
self.short_opts = "huvpGP:W:"
self.long_opts = ("help", "unset", "verbose", "prefix", "prepend=",
"width=") #, "portage")
self.need_queries = True
self.arg_spec = "Target"
self.arg_options = ['use', 'pkguse','keywords', 'packages', 'unmask']
self.arg_option = False
self.warning = (
" CAUTION",
"This is beta software and some features/options are incomplete,",
"some features may change in future releases includig its name.",
"Feedback will be appreciated, http://bugs.gentoo.org")
def run(self, input_args, quiet=False):
"""runs the module
@param input_args: input arguments to be parsed
"""
query = self.main_setup(input_args)
query = self.validate_query(query)
self.set_quiet(quiet)
if query in ["use", "pkguse"]:
self.analyse_flags(query)
elif query in ["keywords"]:
self.analyse_keywords()
elif query in ["packages"]:
self.analyse_packages()
elif query in ["unmask"]:
self.analyse_unmask()
def analyse_flags(self, target):
"""This will scan the installed packages db and analyze the
USE flags used for installation and produce a report on how
they were used.
@type target: string
@param target: the target to be analyzed, one of ["use", "pkguse"]
"""
system_use = portage.settings["USE"].split()
self.printer = AnalysisPrinter(
"use",
self.options["verbose"],
system_use,
width=self.options["width"],
prepend=self.options["prepend"])
if self.options["verbose"]:
cpvs = portage.db[portage.root]["vartree"].dbapi.cpv_all()
#cpvs = get_installed_cpvs()
#print "Total number of installed ebuilds =", len(cpvs)
flag_users = gather_flags_info(cpvs, system_use,
self.options["unset"], target=target.upper(),
use_portage=self.options['portage'])
else:
cpvs = get_installed_cpvs()
flag_users = gather_flags_info(cpvs, system_flags=system_use,
include_unset=self.options["unset"], target=target.upper(),
use_portage=self.options['portage'])
#print flag_users
flag_keys = sorted(flag_users)
if self.options["verbose"]:
print(" Flag System #pkgs cat/pkg-ver")
#blankline = nl
elif not self.options['quiet']:
print(" Flag System #pkgs")
#blankline = lambda: None
for flag in flag_keys:
flag_pos = flag_users[flag]["+"]
if len(flag_pos):
self.printer(flag, "+", flag_pos)
#blankline()
flag_neg = flag_users[flag]["-"]
if len(flag_neg):
self.printer(flag, "-", flag_neg)
#blankline()
if "unset" in flag_users[flag] and flag_users[flag]["unset"]:
flag_unset = flag_users[flag]["unset"]
self.printer(flag, "unset", flag_unset)
#blankline()
if not self.options['quiet']:
print("===================================================")
print("Total number of flags in report =",
pp.output.red(str(len(flag_keys))))
if self.options["verbose"]:
print("Total number of installed ebuilds =",
pp.output.red(str(len([x for x in cpvs]))))
print()
def analyse_keywords(self, keywords=None):
"""This will scan the installed packages db and analyze the
keywords used for installation and produce a report on them.
"""
print()
system_keywords = portage.settings["ACCEPT_KEYWORDS"]
arch = portage.settings["ARCH"]
if self.options["prefix"]:
# build a new keyword for testing
system_keywords = "~" + arch + "-linux"
if self.options["verbose"] or self.options["prefix"]:
print("Current system ARCH =", arch)
print("Current system ACCEPT_KEYWORDS =", system_keywords)
system_keywords = system_keywords.split()
self.printer = AnalysisPrinter(
"keywords",
self.options["verbose"],
system_keywords,
width=self.options["width"],
prepend=self.options["prepend"])
self.analyser = KeywordAnalyser( arch, system_keywords, portage.db[portage.root]["vartree"].dbapi)
#self.analyser.set_order(portage.settings["USE"].split())
# only for testing
test_use = portage.settings["USE"].split()
if self.options['prefix'] and 'prefix' not in test_use:
print("ANALYSE_KEYWORDS() 'prefix' flag not found in system",
"USE flags!!! appending for testing")
print()
test_use.append('prefix')
self.analyser.set_order(test_use)
# /end testing
if self.options["verbose"]:
cpvs = portage.db[portage.root]["vartree"].dbapi.cpv_all()
#print "Total number of installed ebuilds =", len(cpvs)
keyword_users = gather_keywords_info(
cpvs=cpvs,
system_keywords=system_keywords,
use_portage=self.options['portage'],
keywords=keywords, analyser = self.analyser
)
blankline = nl
else:
keyword_users = gather_keywords_info(
system_keywords=system_keywords,
use_portage=self.options['portage'],
keywords=keywords,
analyser = self.analyser
)
blankline = lambda: None
#print keyword_users
keyword_keys = sorted(keyword_users)
if self.options["verbose"]:
print(" Keyword System #pkgs cat/pkg-ver")
elif not self.options['quiet']:
print(" Keyword System #pkgs")
for keyword in keyword_keys:
kwd_stable = keyword_users[keyword]["stable"]
if len(kwd_stable):
self.printer(keyword, " ", kwd_stable)
blankline()
kwd_testing = keyword_users[keyword]["testing"]
if len(kwd_testing):
self.printer(keyword, "~", kwd_testing)
blankline()
kwd_missing = keyword_users[keyword]["missing"]
if len(kwd_missing):
self.printer(keyword, "-", kwd_missing)
blankline
if not self.options['quiet']:
if self.analyser.mismatched:
print("_________________________________________________")
print(("The following packages were found to have a \n" +
"different recorded ARCH than the current system ARCH"))
for cpv in self.analyser.mismatched:
print("\t", pp.cpv(cpv))
print("===================================================")
print("Total number of keywords in report =",
pp.output.red(str(len(keyword_keys))))
if self.options["verbose"]:
print("Total number of installed ebuilds =",
pp.output.red(str(len(cpvs))))
print()
def analyse_packages(self):
"""This will scan the installed packages db and analyze the
USE flags used for installation and produce a report.
@type target: string
@param target: the target to be analyzed, one of ["use", "pkguse"]
"""
system_use = portage.settings["USE"].split()
if self.options["verbose"]:
cpvs = portage.db[portage.root]["vartree"].dbapi.cpv_all()
key_width = 45
else:
cpvs = get_installed_cpvs()
key_width = 1
self.printer = AnalysisPrinter(
"packages",
self.options["verbose"],
key_width=key_width,
width=self.options["width"],
prepend=self.options["prepend"])
cpvs = sorted(cpvs)
flags = FlagAnalyzer(
system=system_use,
filter_defaults=False,
target="USE"
)
if self.options["verbose"]:
print(" cat/pkg-ver USE Flags")
# "app-emulation/emul-linux-x86-sdl-20100915 ...."
#blankline = nl
elif not self.options['quiet']:
print(" cat/pkg-ver USE Flags")
#blankline = lambda: None
for cpv in cpvs:
(flag_plus, flag_neg, unset) = flags.analyse_cpv(cpv)
if self.options["unset"]:
self.printer(cpv, "", (sorted(flag_plus), sorted(flag_neg),
sorted(unset)))
else:
self.printer(cpv, "", (sorted(flag_plus), sorted(flag_neg), []))
if not self.options['quiet']:
print("===================================================")
print("Total number of installed ebuilds =",
pp.output.red(str(len([x for x in cpvs]))))
print()
def analyse_unmask(self):
"""This will scan the installed packages db and analyze the
unmasking used for installation and produce a report on them.
"""
self.not_implemented("unmask")
def main(input_args):
"""Common starting method by the analyze master
unless all modules are converted to this class method.
@param input_args: input args as supplied by equery master module.
"""
query_module = Analyse()
query_module.run(input_args, gentoolkit.CONFIG['quiet'])
# vim: set ts=4 sw=4 tw=79:
| zmedico/gentoolkit | pym/gentoolkit/enalyze/analyze.py | Python | gpl-2.0 | 15,721 | [
"Brian"
] | 3a72a0a128cf1e4352879ec4a7ae3781297144c41bd3392b22b3f40e26c496d6 |
import os
import shutil
import sys
import glob
from setuptools import setup, find_packages
setup(
name='circlator',
version='1.5.5',
description='circlator: a tool to circularise genome assemblies',
packages = find_packages(),
package_data={'circlator': ['data/*']},
author='Martin Hunt, Nishadi De Silva, (this small edit is from Nicola De Maio) ',
author_email='path-help@sanger.ac.uk',
url='https://github.com/sanger-pathogens/circlator',
scripts=glob.glob('scripts/*'),
test_suite='nose.collector',
tests_require=['nose >= 1.3'],
install_requires=[
'openpyxl == 2.6.4',
'pyfastaq >= 3.12.1',
'pysam >= 0.8.1',
'pymummer>=0.9.0',
],
license='GPLv3',
classifiers=[
'Development Status :: 4 - Beta',
'Topic :: Scientific/Engineering :: Bio-Informatics',
'Programming Language :: Python :: 3 :: Only',
'License :: OSI Approved :: GNU General Public License v3 (GPLv3)',
],
)
| sanger-pathogens/circlator | setup.py | Python | gpl-3.0 | 1,005 | [
"pysam"
] | 8d6aa9233fc57ee20d683ea9dc788f903e0cfa0c3b6b321918c2bb622b4a2577 |
#load libs
from wx.lib.embeddedimage import PyEmbeddedImage
#----------------------------------------------------------------------
Icon16 = PyEmbeddedImage(
"iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAD2UlEQVQ4jU1TC0yTVxS+pbWI"
"zARWCbgYrdINZ1egMCHDTf/BxAV84GiRBIabQlszLGQwNVKyOQVEoMACpQJFoFHDU7bVwBxD"
"tGggI0EeY8CmMCdRRJB2ZaXtf+9Z/xKTneTck3vOl+985+YeBACoo6MDaTQapNPpUHV1NavG"
"6SUlJai5ucWnt7dX1NTU5FNcXIxqapw1p+tqa134trY2hBiC8PBw5DQWh8NhohtznFRmFE5M"
"TFinH007mCiXKwrRqrmx2WwXPjg4eJWAoigWk+HxeB5MpHZHRDnzQNO0DVbNNjo2BgJ/fpSH"
"Bxd5e3m5cBEREaxXCpiu3DVcrouZzXFnRUYfqMzKysZnzuTQcXGH8bp16yuZ2v+Ucp0K3BDG"
"GCmVSrfo6I9RbMw+/vGkD2XKOL/yC5+9ceNkWrzZ09MHEg9HmusvSW+oFOHl0tgg2dsBW/j+"
"ggAkTTji5lKQJkv1rNeV6MxzPY657kPk2S05EIcJTC8XSHlZGe6/30eYOawPtUCeVBHLs06H"
"viZXdzQl2RP9Y/kXNeiKzwLMgulhqWW4TmgfMZy2vLTCcmv7j3SRWkNqr+hpY//Y8p+Desvc"
"mNZuXTBaYMUI2orzZ5HZQlCdRp6JTQZ4/lvR8tTVELh3kY9HG+MgT7aTHAz1xPlfUGSq94JT"
"QSW2/t0C5qe3l1+MaqDwtDQTWW2Acr6MiSFPsgHPN68sTZTCdLeK7lQF4nOxr2N55Baslglx"
"a95u3FoQRY/fTIfFSc3KyBURHDsoikE0BpSu+ES0NKUCmK9y0KYW57RDeG40D9/WUvhqBh9X"
"HHoNl+11x7fObcUPGnfBrPGYY7BBCCkJlGj1EdOO8maGvl2EeS04zD30YEUWedyjwl35MdiQ"
"I8Z18b64I9UP/5IvJkP1FP20LxW6y4WLSQkHeAwBKykpGQ12Scbhudp5Hbb35WbAZEsOrkr5"
"CF9TCHFmqC++JAnAX3/Ah77yXfaF+8lwXbV9XCKRun4id4dQjBpL3zPA0mWgHcMrj25qYObn"
"fHLnooS0K4PJNYU/afh8G/nhVAgMaN9fedH3KRTINhve3C5yEbgLBIHom1NiHUAnLM7eM2E8"
"YZ8Z0Fo7ixJtDek7bfoT79javxJYf60Otvd+967ZPpAImQkbGzZv3eEiYIeEhiG/DWxq6E7Z"
"X9g+CYQ8IMt/1MP49RPkbhFFunKDyN08IYxUisjv+j3wU/X+xxt53H2BgeJXy7SH5eu3Ca1d"
"6+EtDtomzUiXlJSeT+jQqCijOv2t/oLj3sbs+PXfSyK81Ju80REOZ80GZhnCwsJZ/wGeWyTK"
"lr1tSQAAAABJRU5ErkJggg==")
getIcon16Data = Icon16.GetData
getIcon16Image = Icon16.GetImage
getIcon16Bitmap = Icon16.GetBitmap
getIcon16Icon = Icon16.GetIcon
#----------------------------------------------------------------------
Icon32 = PyEmbeddedImage(
"iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAMxUlEQVRYhYVXB1hUVxZ+zAxF"
"mghI0VhQkWBDURB0NRbEjsYYXNauseyqEHtWI1aUiAmJgGhE2kqNolKlioCowNCGIp0BBQWB"
"oQ4zw9x/7xswG/eLu++b852575177n/PPffe/zAAmN7eXiYhIYGJj4//pMTFxbGak5KSwouM"
"jGSCgoKYkJAQJjw8XKHZNvs+OTmFx9oN2f+pH3YsVnd1dTEMC6C2tpbhcrnM/3uUlJQ4VHFM"
"TEyWODs7e/r43EgICg7O9PbxSTh48KDn+PHjl7Dfh+w++XwYq6ioaBBAXV0do66uzqiqqn5K"
"lFRUVBgtLS09Oss42gdy+rCa0OdDm/1z288vjvrS+9Dvv32xftixWBACgeB/R4DORKFpJx6r"
"/fz8HrCDtba29tBHQqWfLp9Cd9N2U1NTT5+4Hy7fHn7A2isrK/P+6OeTEWAB8Hi8T4Wdy3bX"
"UFc3FgqFLTKZTNLfL8HQ7DE0e/T09qLx9Rs8Sc+QfH/GtYWObczhKA32V1Lo34F8GKu4uPhj"
"ABwOh2FtqFaibaUPSOlMFGsa/K/QrDrha7x4mdNTU1uHquoaUlFZJS8sEpCnGVkIDL7bc+To"
"CcycaZn1h5wZnIjip5A/j8DQy49jpUgoRnmYmrIGGwaDkfoWW7durT1+8jROnTlPXM9dxKnT"
"ruTgQRes/3IjmTXTEkYj9WtVeFwLVRUuo6bK01BW5ip/AMKOQSfDqKmpKX0EoLq6RpEYmpqa"
"CiMdneEqo0ePUtHXH0nbyr8vhsIJj34y0veYMcVMZDpxMkYbGslH6upjlIGeSF2F60Exj/7P"
"pP+TS8o8jgqbTn8agdLSUmbx4sWMm9sl3uXLbrxDh75l7JYtZ+bZWhusWj5/9V4n63Nnd02J"
"9NlnXBB+Yrgw+vsRNedP7unf4LgNnxnoEZPxZnC/cLS/IMqpJjVggzDC06HA48TSyG8cLc9Z"
"WYxZTSNhoKKqwVhYzGZWrljOs7NbyjMyNmby+fxBACySdescOFevenDmzrXlrnewW+vjeeKB"
"IPtGe2vuEbxLdCBlXmYoC1iK1kJfCJ4/wqPYRFz38sF82/lYsmgxXf9QVJdlQdycim6BO3ry"
"nSGrOEf6q39GxYsf2+94OT9wclyxdtEiO67vzVucNWtWc7KysgYBlJeXc6ysrOmM504O8nPP"
"INIq+rqS9FVdQdWjlZIX3tPF/AAHcZtIJJUCssbmNilNPhIaGoY9u7/B/r37ERERQVrauqWi"
"HpmsraNTKnx+XlyfeVzcVv6rRNocDtKfQuQ9T3HTc1+G9ZzpZtOmWzC5uTkcFgC3qqqGMRyp"
"Pam8NOMt0I2+zuL+ttq7/cL0zfK62HUQ/DoFtcnH0dMnhai1HjLp4DasqalFdvZz5PPz6f8a"
"xTupuAPtnX0Q5vmgs8QN3XVh6BJGyruaEvvFotx+oBBl/MC3w7U1JxUUFCgioPYyJ5f57ujO"
"q7Q73jVmdEKcj+6aq+RN2ga8Cl9Aiu9YEsG9baSjs4cMEJC6hmakpqYhOTER2VlZSEtNVbRj"
"4pKQkc0nrW2dpCLLg7SX/Eg66+4TcXM0pB0ZBOICCItDOwEBjhzefTUl5ckggFy+gHHeu+g8"
"UAGx6KV4oOsp2krPyoVJDuRV6Dzk+85Anq8VKlNc0VGfjYK8Z1izeg3oqQEtdS3o6ujCzs4O"
"bhddkRgdgM6GJ3hb6InOytvoqg1H39tkIm57Jhe/TUBbdbAYA3zs+tvK80/SMxUAVPkFlcw6"
"e6Mt6PVGZ2sOBZCCtpITpD5uISrCF6DotjVyvKzx0mc+Xt6wRbLnCnh/a4NTWz7HmZ2z4LrD"
"GrfPrEFy0H4UJriiIdcHddkX0VpykwIIQ++baHQKo0h3fQREzdni9pcXMGcss+VZzuBdoCwo"
"qWQsp+stxOttkLz5RTbQ/QI9TVFoTN+FisgvwPc2xbPLo5ByciQyL5gh9dxUXN8xFuc2GsJ1"
"wyhc2jQBIadt8SJgHYQpB9CV9y36ys6it+YmRJX+6KiJQFdjMkS1j1AZv1eWdU4TY3WYhTn8"
"wXOAW1FZTZNQ3URUurUPb45B3vQzIIqFvCMF4pYnaCn2R1X8P1EU6IQHB8bCf6Mqzq8yxL55"
"xthuOxIHVk2E72FrJF2bh2hPO4RdXgb/7xch7MIiFEYfw/tXAXhf5onGzB0QBNIJXDTo01Bm"
"TPILiz9cx7WMtraWxqt0RyHen4WsyXcAzT+ACE8SdEdSkwLIpXkY6M5E7oOjuPaPqTi8fiyc"
"bPXx5SxtbLQcDseZ6thmrYEdlsNwcpk2buw0QJLHNJRGLkN1nANpfr4bdWlbB6qjbPDokp5Q"
"mcfTEAiGADQI67h6+sZMSuSmbHRdRn/TvyRo8QVpukaIKILu4UTIO++ht8ELPZUX0cXfg/oH"
"dihnc8PNDE+OfYZUZwM8/KsWYjfr4NmZMSjytUBx4DyUhC5BdfxfSXP2flTEbJQIoy1x5zvD"
"bK3hBkxpSSFXAUAorFH9bIwpE+i1IQz9NyF+QzO19QZISzBBTyIG+nLR1/YUImEE2kt/oGfC"
"HjSkbUdhwBfIumqBbDdzhDqOgPdCVdxeo4mYo6PwxH0ysr1mQRC6GJUx60lT1k5UJ20Wv463"
"gvvfR4UZjjZlSorzVYduwyo18ymWzBXXDW6QRaG//gcxWrxB2u8TuSgF7XVPELx8KmIOrQbp"
"+g3Zfjvxw+ppCDmyAPe+t8FFeyPc3TEe4V/rIn6fERJOTsRz7/ko9F8AQchiVMVuIE3PvkFV"
"gpO4Onwajv7NxM3UfA5TWJCjpgBQVflKbfZsG8b5H+t2o8MDstrj/WjyADrCiOzdQ2rShaQd"
"KxC3fg6k3bF4neWKnVoa8Ntlg6rI5ThupYuvdFXwwMUcFxaNQLCzBU7O1EfUMUuUhSyiUbAn"
"r59uQ8XDL/sLb0zC9tWTd1vMns/wc58PAigpKVJZvmI9s3vLgqXisrXAa1cpeX0N6LxHZC3R"
"1OQ9np/fg6gVU9DX+gBN2edwcrI+/LbPwsufbBF5yBxfU1eBeyzgumIcQk/OxcGJmoh0tqLb"
"2A7Fd+1IQ9pm1MV/Lc1wH4PNDjZLlyxbxTzPzlQZjEBVBdfIeAwz7XOjye2FjhI0udKt6Euv"
"hRhIW1OpSQuyrhyGl5khJB2P0VV9C+4WRgjaNAP1sV/h1hZTOOooI/7cPJyeOxJBhxfCZYwW"
"7u61xKvf7FEWsRKNGbsgfPw1Ut0nSc0nGE3W1Teg13HeYBLSi4SlYAyPywyvfrq+Ce/oVnxz"
"awCdcSB9fCLtKUGBnyvub5qPmjS6n1/8jMvmI+FlPxHp19fihLWBAkT08an4+7hhiDxshfvH"
"rJHmTndByBJScW8VapOcBhqTvkLsZfMmSk6GDxESpaEIVFPSqaagKakh9jnougRJwy9SdERB"
"3ldAiOwVNauFrCcHrYJbeF/sgfJoF2RdX4O4MzZ46jYHmZdMkUy3X7anBdIvm4P/62wUBNgi"
"75YNKQuzQ8Wj9dJ3Setw+/ikXMqaKO9kOAUFhYPnQCU9CTU0VBVU1d9zYTy6rqKvwa8f4seQ"
"i/kEA1VE0llIpB3pRFQTSJ757CNPvbeSu87W8N87C8H7ZyDkwDRyZ6cZiftuHMm4Mp5k/TKV"
"5PnNJYX+fyFVNA/KotZKmimAK/snJCtomRLDy/8dAOUDmkMA9mwyvQ74oPddTJ+k/fmArKdY"
"TmQV1KwU4neJaMq7ibzAU0jx2Io4tzX47cQXCD5gRUFYItxlDh4enYF0ei4UBsxC/p25yPdf"
"IC8Os5dVxjmKJXmbseELgxuUJWpwOQy3oOAPrJil5FwuhwVhfvHYkofsASQntbT6qYZMXCQT"
"d2ZK3giCJEUx7tKSx24D6Te2yR+7O8ijzy4k97+zkocfniEPOTRlIOLINGnChSmStCtmkswf"
"LWQld2zwJmaVvCF5E5w3mz+k/i1pzaD+UV1ACw5F2aStrc1MmGDCMlejz02Nd/3ktvtxVXFo"
"OxkopGa5tAJJomfDXYjL3dGY9A3Kwx2QR6/nPG8LKibI+3kUyvzGo+j6RPCvmeHFTzMQc2V2"
"+6kd5o9Nx+nsoX7H6Y7Q0WDZN8uUWTKsAFBfX6+gySNGjGBcnJ2ZefNseFwuj+XyOjweZ+70"
"aRP2bN9s/8ul046xgZ5b+DF+22ujPe3fRl+d3xbtPqv93tmJbYFH9d76HNSuPb9lBH+v/YjY"
"lbOHXx9vqLKPcnNb6kefDqjK0nI1tWFsXfBxZSQSiRgXFxdF0cAiU1NTp/WgMmeYmgqPXZoP"
"JR0VTTY6VCZRmUFNrahY00GsaNuCiikVY+pEmy2o1IZpKBkaGnLGjDbiGRsbcnT19Bl9fX1a"
"d+gwTk5OTFtbG/Nv+dNu50tIL9UAAAAASUVORK5CYII=")
getIcon32Data = Icon32.GetData
getIcon32Image = Icon32.GetImage
getIcon32Bitmap = Icon32.GetBitmap
getIcon32Icon = Icon32.GetIcon
#----------------------------------------------------------------------
Icon48 = PyEmbeddedImage(
"iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAYAAABXAvmHAAAABmJLR0QA/gD+AP7rGNSCAAAA"
"CXBIWXMAAABIAAAASABGyWs+AAAACXZwQWcAAAAwAAAAMADO7oxXAAAWW0lEQVRo3r2aeZRn"
"VXXvP+fc6TfW2NVjNT3QAzS0Agra0AgoBI3YT3BI56mJQ4yumDxDSJSQQU3eA595SOKACfoy"
"OOEDEzCK0K2oTE23DA1Id9NdXdVVXfPwq6rfdH93Ome/P34FjU9deeJaOWudde+6697f+n7P"
"3mfv79n7B7/CcF0XgEsvvYR169arRqOh0zRFRH7mXRF5fuqbb75ZPf/c97xfBQLqpX7oOA7G"
"GACOHj2qVq5cKZ2dnfrKK688d/fu3a8988wzz9Na94qIRqnm7MzMsT179z7w2c985kGgdvCp"
"p9Q111wjJ4aGcFwXk2W/EpFfGvzzq7x37x4lInzsYx9728DAwNFWqyVJkkiapi/MJEkliiIJ"
"w1DGxsZqd95556eBDhEhn88jIriuj1IveT1/eQLXXPMWRESJCPfdd99XsiwTa62J4yTLstRY"
"a60sDWutzbLMtqIoazabpl6vyxNPPDm+es2a0wH6lvcB/OcQUEqRy+W49dZblYhw553fvElE"
"JEnSNIoTMcbILxpZlkkzbMnU5JQ5OTpmv/yVr54AciKiXyr4X/orpRRKKYwxWilVmJmZmezr"
"68vFceJmWYrrebiOi9bqhRUVEYy1JElCKwypN5o0G01z4Mc/dv7tX//1vw4MHLt9YWFezc7O"
"yi+Lx32pVgAE6DbGFuI4FsdxQHlYa4lNfOplASuWLM2Ik4QwDKlWqzz33FE9NDREFLVOW7du"
"HQCFQoGRkZH/NAIKGB8dGx8OgmD98MhJisUChUIB3/fQSiMiZCYjjhOazTbwSqXC8PAwx44e"
"NaNjY+6hQ4f2T01NPr8gvzyWlwJea82uXbvU5a97nYxPTL5p0+at/16r17Nisah939ee5+Ho"
"NoE0y4ijiGYYUq/XmZyYYHT0ZDYxPu5OjI/def65r3z7wZ88pecqczaOY6y1PzePvGQCu3bt"
"AkBrTZal7Ln3XvKFPGedfTYnT46rWr0uW7ZseeuZZ2z7cr5QyOfyeVzHQQCTZSRJQtRqUa1V"
"mZoYZ2ZmRqoLC6rRqP9LnGW/s75/rR0eG7XFgkczTMnnPKL4VE74j8j8XAI33XQTjuNQrVYJ"
"Ap9Pf/oWxCZUa6H679dfzR/+zqWq2F9GgvdYfSp6dHT2nPYHhZzzrrwnW42xAqLSNCNqhbRa"
"LVJrFzOT3QP8DfC067oqTVeL8KBi+J/0/Y9My+9//G45enxKNqzr5xUXvIotm7Zw4003ccst"
"t3Dttdf+xwQ+8IEPMDp6kssuuYA/+egnuPCCberv/vYG9cod7wCwF110Efv27QNU0L2if9Vr"
"z4rWbVnpbFzW4Z7WkbPlZqQ2/mD6oqsX56ZkdOSkqi7MA/Dy83dw0ctKz160Nbx/esE2K4vR"
"9MhEfWjPvrETR4dmxkWOLxYK2wnDEEBNjn5LfeqvvyB/+8U98gcffAvFrs3s2rWLhx56iI9+"
"9KM/S+CTn/wk119/fdtd3GVcdeXp6pt3/Uj5ft4uvdL1395/5Y7XXLjtstOWOztZPL7Jzo32"
"2bSF6xq00yCrL7BYupgfzl6KJDUefuABxsdGMVnG5W+4istetY43bD9OagK0U8CKJo0atDIJ"
"mxHDs4vpkz8ZWPjBF7++74GBEzNDSy6k7v3OP6lff9N77cjAd1m3+de57rrruPnmm4EXRaHn"
"wQMMDRxQ6zecLr6f9z5y3W9e9eZdr33fhjXdlxXdVj6eeYLFk09Rr1ds2GhmaVJTQf8G1XPG"
"b6kkfzYzM2XO6plSxgrPPPUUSRJjjaVUzNPZfwHDaoec3m+I558RUx8UrR06iiro7clv27yx"
"c9vOVxfe+Z53/RrTC9Gzjz81/PWVy0r/Ml1pTjzy8F3qC//wRUREdl99EUqptgTZunUrxweO"
"YaxwwXkb2Pfog8oN1vI/b/qj9739bbs+sWZl9xoXS6t6wi4O/siElTGdZVaJVVo7Vp/x9s/R"
"cfrV+J5icHCYlbZCueAiInR1dVEqFtFKYbKUtav70NpRqmcDvWuvUK3aGK3jX8IkcxgrZATi"
"Oh0SuL5s2tB39tatW2+86k2XffzAE8e+fNlrr/6zJGGmp+9/qG/c9Yhs+7Pf55O3/O+2C4nI"
"i3XIiicfv/eul79s2w5lY5vGDbFp1amfvId4YZyoViGuh4Tzc6x51XspbP8jfJr4uQJRK6JW"
"b9BqtVhcWOSO//MNgiBoiz8rvG33b7Bq1UrK5RJiDY1mRMENmXvy4wQda/GCLpyggHILaD9A"
"uwXrejlxi0VnYvAnjVs+f9c7kzT61uxcpr7+zR+KH3htF9p+9lmIiFJK9Q0OHDi4cdNpq7Kw"
"apDMURrS2hHExNgsQbIUMRna1WQqj+9Cq5lhifF9n76+ZThaczSK2LlzJ47r4GgH13WxJqOr"
"s5MwbJGZDMfRTM1WcbUPykU5ufbUDkoHaCev0T4mUdLd2Zf7ixvef/c//PP9v3XxpZu/8rEb"
"PqSSOBV3eV8v//blD2rAPrD3s5/ZuGnrKhPNiMI4IhmSNTHRDDaLkSzGZina9XADjzS1RI0a"
"pVKBJMmIogjX81CeT9/yPnp6exERHEfjui6O4xDHMSJCkqQs7+vl6YMTnFnqBu2hnAClg/a9"
"9kG7KOUhFiUqcH3Xzd79jl1/v3zd5feKSEUphTszW2HzebuVUsodPHrHxZBYpURbGyM2wqYL"
"ZNE0Jq5hkiYmjRDrAy5ZbRDRAYiQz/mMnBzl+OAJhgYHyOdzlEsdOK5DHMWEYUiSZhSKReYq"
"FbZv385ll15KT8mi3RyCApE2eKWXshigNUl9BslaWFVU+WJn4boP/94rlVL3nbFl4/NR6H5E"
"JDuy768W2Hz+arERSIpIitgWYmLEtl1HoTAmw6SW5vgT6Mf/Gv+c91BYtoXIuBx6bojP3vJp"
"hoePvxDVfMejb8Uqtm47iwt3XkI+lyMfaMKpR+nSw1jl4bgF0A6IBe2DckAJaXMBkzbRjoeY"
"GkIn+x/50SxAZW4Ot1wqMvnE7bLqFQO0ao8NJ5XtZ7nF0xDJQCxKeUsS2kH7eVScYcMIEydo"
"t0Rt7CC14YfxS6swhU1sLAqXv2oNA8ssqVGgNKVCnlWr+zhz80peviWmp9Si1+4jra/DWAXK"
"oN0CoJAsRHkFtJMnixtk4SJOUESyGl7HZo49cId95PHDoyKitOOKW280eexZkdf3P8yJqeqR"
"c+O9b4zUbnH9vJJsGpRF0Ni0gUlCxFqUo9GeRzI/gyr04BfzxPVZKkMnCOdDzulucd6rNa4X"
"gPaJW+A5i3QFFqcR0kg7KJU2YtKIQKYBjTUhigDld6OAuDGDzVKUxNjU4nW8jKmDd6jD935q"
"EnYvcM9WLdYYF+CmzzzK44eWs6I7f0xJnVx4t1h9hSK/DckqaLeAzUK046J9jUraFnZ8n+b0"
"OKFReOUyrlskNR4zlSrVMMLTHigXR3l0d5fwypZuKxS8jJydpjUz3Pb/fBfKSXG9MllSJ62d"
"xPFKOEEfOliLSWKGf3ADc4fu0wnepMi30/0fSzSAu3nzZg4cHGD/k3Nc9/4zB5MMPMeKEz6A"
"Ew8g5Z10b7uBwuphmlP7aUzsJ64dIQ0XScMUx9ekzZTW7AxpK6FAjrJbJl/wmF2MMcoSlDVd"
"3QVWLfNZHczgeZ04mcFxNTlXkSsYMlOjUZkDbxkdq85He12YeIbmxHdZHPo+0eKCuH5Z1cLK"
"IHekHBpr5y23rdsREVHLeosjf/En5+I7gC6BxKjwcVR1D3m3h/yWi1l29rvIophWZYz65CHq"
"k4dZOPEMk8eeJo00SsU0Gh4mMSgRPFehlVBfCEk7DA3XpbloqcU1pqvC6HiVubFJSjlh29lb"
"uOiKy9HyfWw23d7TWYJb6EQ367g5mGuqI7f/QNjzLLJjo8a1gOs6wJCqzIdTJBJScHOgQfmg"
"C6CqkExD9Yfgd+Lm+ymvCCj1bmDV9nOozl3Js7d+mocHn2VkeJap2Qb1WIhMWwc+L7kDD3Iu"
"lPOKQAzr+3y2nV7iivM72LC5j1KXC7UHCU0XXq4Dp9SJNRHWGLSjxC0qNdtkYM8BODIv9K1e"
"jzs5Ps7yZT3A1xCR5vEfv2u0s4etYNrgdR5MCGhwyuB0gnLBJpi4Tto8jG5VeMdvn8Put66h"
"VZslnK/Tqjapz1SJ6y2MEVSSYEyGwhAuWJSryPfl8TryiO9hMkvUzAhKRcS0DzE2ichaLSSz"
"KK1EBZqBUQYfHQfPc2Vx8AS63mhwz3fu4M5/3Af8iIW6OoFbBl0EHYBowAG3o20RFQAB4C9Z"
"qIhyu2hFimrDUK1nNFqWRpiSKocUTWyEZiIs1jKOHw2ZnEpYbFoaoSG1FsdzUIBYi4mTdgnS"
"GKzNsNaiHIWbc4iaYvceZkzkdWpZb0/bugC3fekO5qYSge8TVtMhdAFRBUEHkC2C29OeugAq"
"B24Bgk7ccg+5rh5Ao7SLH+TxciW8wMfN+XiBR1AqLIk5qM+lKAuuo9AaHE+jHQ1qKQvD0j0I"
"glIax/dRWqMVqhWzCHYOhlVlfvHUeaDeqHNivME3/v5BanH5yMUqh8IVRCnSGQj6l1Y/D16J"
"6SMzVAaHmBsZYW5snDd95M2ErUXGR1oExeV4nStw5CSNcAZyGV2lHPPJAm4uIUssSoMTtIGb"
"TOFYsLYNXntum4PJAEE7DmIsYqxuRIyIXBX/5IsHnSRJuHDHjjaBMGzynf1H+Jtb63z4g+cP"
"aFVG/F6h+QyIAtME11kymINSPlnL5fHrP0V580rUX/4uVkYo9/Vz2x9/lfFDg6w4exOv/Y0z"
"ePaxY+y/f4RNZ3Zx8QUrkNFptLZ4XkC+UCLf00e+s4xNQyRNkcxgM4Ob06A0WRSRhokoY9T8"
"rBnmiYf59oOZvPLc7XT3dLddaOfO13B0sC4A+x98fCTMOlCtZ8HW2ma1zSUTx5BF9G3uY9tb"
"30DvGo+ibWEzDxFhzYZezthxFkUH1m9ezXmvKPL6Szp54zWbeO7RaW7/+gl6N62ha1UPEw2f"
"Hx/JuPvrQ3zuD7/H+LCglSYNI0yaYNMUyVKyOMJmhqSRUlkwA/vuhal55J3vfi/33PPdNoE4"
"bmEFRJ7QBw7LVG3mrgbpYNvDxCwdnU3bGmRgBNfxyZV6MM2IpBWhEEwaky/k0BYai3XCWsLw"
"kTm2bCrgd/lQbzFXczg0avjS7SNc+frT2HnVVhYqGdOjNRzXQwRMHGPSGGtSFGCNiDXC2Lwc"
"ufEbi4wuaJr15qk98Kd/egNbtmwCvoCILE4euHKejvWnIRk4XjuUKm9JJfqIUig0dPbRmJgm"
"bUZov4TYkGJHDgS0hSTW+DkXz/PpLvvEUUKawtp1Pbzv3V08emCWkaGYvAOdvT0oR6NshuP7"
"OJ6P0g7a80BEskwYGE8H7zkERbcmdz/656ei0I033sjAsePI4SHgS0zPx0M4qr3yygGdW5K3"
"OVAeCgEUzvJl1FrQWqiivRI4OYodZcoO5FoNlJfDL+dRvk+WWmILK9eU6V5W5MD9A6w5rZ8d"
"l6zHNWCtaW9kQDkOKIVyXFAKx3ckjiwPHg5HRYTIKnzfO0XghhtuYOWyHB//3CDwXSbm4mNo"
"jaAF1RZk7czsAj7WwMLoMPFCSNqAZq1OrlRExGHZmlXkPcAaglIHvav7mJyOOTERct4VW+jr"
"ha99/iBqrsnCVI3nDowRlKAyWV0C3Y46KNUOTVZQWukUNV8NmWH2Eu1oIU3Tny6rTFcivvfI"
"gvyXrx0nnNPHyRJQShCjEMMLRJSP9jwaEyOc9963sOYVZ3P83/cSNV7O8rVlnt6zj8TC+NAk"
"R58cZ/TILI89dJLfft921vcr5sYmuPjyfkYH63hEvOE3Tyd5y0byeUNUq+EXcyhHt/eB6yDW"
"4nqOjoU5kcGQx3br5EXdqBdKEUrBmRtLrLYNdrxh/a4//8jrvuXp5UY53Q5uRzuRBavA6wLt"
"gdtOOEiCjSrUJwaJF6dpNRPECvOjx5ifmMUlJp8XGnNzNKtV3JwlX+ogVyyQpSmiwfVdvEIO"
"13HQSuPlcnj5HF4hwMSZmFZVPXlo/Du7/2rTm756/RH94c+P2YWmaZ9AX0xgcjbi+yfgrj0n"
"x0T0KddBt6ORZO2r0pApbJyRVCu0FmbBZgTlAuXeHGljhNFjYyxf4XJyuEIcRgSlgO61vfil"
"ToxWxFGVLA3RKsPxQGlBrGDSFLEWsabdW8gM2lFML2RjAA8905R6ZF9I3C+4kLXQaFlEBrRS"
"m9MwjE3QWwBdBt0NTnFJB3Gqki8pSnuAQ6uZsvfv7qOwrEzHcsvTj82SZIrnnm2R7+5lZiQi"
"jTOUKDQp2891UY7BDTRe0QPROMpBOz7K0Yi1S5nZE2W0GhiPFpW6r7h1bS5Ms1MVa/fFFkhT"
"yyf++K0OkEzONsa7+1iLyrVVqNvZDqc4bceTDCRDbIYTeJR6+9h28bkkaczE4HPsvGo7tZkq"
"67cuozYfEfguK9Z2EPiQy1scXcfatB1xrLQBe+3Ipz2vPV0PK64Vo/SPnlgc7Cj7XcNTSego"
"WBKsOLxofOhDF3LrbU+q1DiFw4cnZt9y9TlvDAqrrKVDlNut0F67cqAEJMOkIUrH/PC2u0Fp"
"yqs6UW5G7wqHtBXheLB+Yx5sSq4gNKpNmrWEqfEWkxOCX8hRymdYaRcNbGJQAm7g43i+OEHe"
"5j1x77hn4Ftf+97UHZ5DNU6kYV/UMvgpAo8/PsbLX7ZcpqYadmQynd+z9+knL75oy/nL157d"
"CUbEigWrlEJBjJgIGzdYdcY6sijGJjVmTowze3IGNEwMz5JlEYvzIUGgCAJLuWxZ1e+x8QyP"
"Qi7BGksW26WtpUV7rnVdV+UCR8VGmc9+7dBtn/ji4c/lAqcaRmZKwLwY808RyOfzjJxcpFzu"
"SBRp1Ail8r8+971vT448O9Xf37G6q6ewzCvmFI4DklibhDZLQsS0yOcTcnmluvo0XT0JhWJK"
"X68h58X0dhtKHS1y+QZa6rhuJNZGpJERk1grRqG1Urmcq1zP1Qstavc8Onv3O65/8C8ffWrm"
"+4XAWQgjMw7Eeql19TNh9PnR29tLpVLh93737dx62x3exvV93WMT1VKSJB2nrek44z3vefPO"
"K37tNTvW9K/YuLqbLmyEiubJwhpp1KI+N0mjMk0SR6RRE8lCTNZCsibWttAqRbs+YhziuoOI"
"S5jpZD5Uo4OV7Ml7H1t8+NGfzB9UikpvVy5qNNOFKLE1EWt+Xi/5p554nkehUGi3g9IUay39"
"/atZmJ/zTt+4sjA3HxUmJ2cDpciL0NPVVVpzxWXb123fsnLD6r7iyt4Or88ztS7VWiwhSaBI"
"HbERaRRKEjWSZisKW3FaXWw6lZkFmRmryMmDQ/GJwYl4XClmRGj6rkr7lxfi2cWkXg/T1ub+"
"TjMwXgU5tbi/kADAhRdeyL59+7jkkkt46KGHXviXyfPv9y3rcNeuXeULKgibDe/Y8XFXrDhL"
"Ee3/nfpFP521JS3p0jUDTFfBMT0dbobScSslnp6Pk54O38wtRgQBxHG7M2qtRSnFq1/9avbv"
"3/+LCbzYGtdeey233347Y2NjiAhat7sinudyzqtezzM/3ovjKOV7ju4s552OcqB9x2pMqq2x"
"2opVIgasFREjxlhJM2uaMbYeio0zMdYijqNFoVnTUWRofvEFUff/M/4vFuIu2tG1f2cAAAAl"
"dEVYdGNyZWF0ZS1kYXRlADIwMTAtMDQtMDdUMDE6MDQ6MzAtMDc6MDAcrxQlAAAAJXRFWHRt"
"b2RpZnktZGF0ZQAyMDEwLTA0LTA3VDAxOjA0OjMwLTA3OjAwQx5iEQAAAABJRU5ErkJggg==")
getIcon48Data = Icon48.GetData
getIcon48Image = Icon48.GetImage
getIcon48Bitmap = Icon48.GetBitmap
getIcon48Icon = Icon48.GetIcon
#----------------------------------------------------------------------
Icon128 = PyEmbeddedImage(
"iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAYAAADDPmHLAAAgAElEQVR4nOy9BXQU6dY13AmE"
"BBLc3V0Hd3d3d3d3l+AeCE6ABA0eCIQQJ4G4O3F3t+5Oav/nPN1huPK978zcd907c9dfax0q"
"bdXVz95nn32q6ilkAGT/5aGhjn/3Z/8S8Q9PSJIk1rt375bNnTtXtmzZMtmiRYtkixcv/svE"
"kiVLNHifFyxYIJs/f74Ifrx06VLN5cuXl1m1apXW6tWry1Fo/xTl+Hl+nd/H7y/9LG+HH/N2"
"/9O/7feGer/FOjExUWBbXFz8/yZASUmJWLdq1UrGS9myZcVaQ0ND9idf/n4H+bEWRXkK3Z9C"
"j6IiRSWKyj9FJfXzen/3/vLq7fyz7f8lFk1NTbEOCQkR2CqVyh/J/v8kQKdOncSHKlasKNPW"
"1pZVqFBBVr58+T9taGlpif2sVKlSuapVq+rq6OiUAl2Doik97t60adNxXbt2XTRl8uStCxcu"
"PESZfoyyRARl+aFJkyZt/YVeb0Lvo21158+pP1+Rt8fb5e3z9/D3/ad/828J2m+Zrq6uWIeG"
"hv52AvzVFKBMmTI6xPTSrK5HAPXr0aPH2u3bt995/tzUyc/PLzYzM7OguLgE/9OiUCqRnp5e"
"4OPjE2tqauq0bdu2O927d1/L2+Pt8vZpLCrx9/1nf/FvX/6QArRu3Vp8iJleuhEmwZ8lSn8U"
"ZaM27WMV+rMaPd+xb9++665du2YWFRWVzIDSj/wBLtU+5Ofnl2RlZSkzMjIUfx9Z2dlKfl2u"
"UPwDMSIiIpKvXr1q1qdPn3X8Pfx9/L3lypXT/jOOT2nwQmT9/QT4MyuA+sdp0OBXopUAftKk"
"yQednZ2Dfga8qKioOCcnR56dnaPIzs4uzs3NZQKgsKgIcrn8RxRx0HOFhYXidfoMSC2K09LS"
"FKmpqXL+LI2L2CYNHuzt7YPGjx9/kL+Xv7+clhbvx59ngP5u+UMK8CcngCYlfjX6s0G3bt2W"
"Ozk5Baqy/VfQaSnhjGfAOKN/hFyE9PdRWCSXiAi8VhGilBxEjAIiBalGSUpKijwzK0uQgcPi"
"06fALl26LOf9IDLy/mj+Gb3hfxsBytJg16R1G2pVjWh/S+iHSAUFBSTfBcpSBVAS+JzpDKpC"
"oZDoR0vFymKUgsfB7+UofcyE4VAolFCRokgqKCzkbQt14GAVSUlNVSYlJyuL6D1ZWdkla9et"
"M+L9oZLA+1X2Pzw+/7D8NxGgDA1yDfpBXUxMTKwZ6Ly8fEVBQWHx3wLP2ayg7CfAi4t/gP1b"
"l1JSCDKQgvC2iAjIy8+Xcqk8cIkgRUB8QkJxTEysgl8/pq9vTfvXpSztH+/nf3qgfl7+Wwig"
"oaUlZLbDkydPbBkoyr4ixpUB4wznYDA4g4v/APD/SAQVCUrLSEFhEREuj8GXUlJSOZCYmITg"
"kNCixKRk7Nq9x5b3j8aM9/M/PmCly1+aAKXmimo+9/QN9PX1TRgcMmaFvCawVfLOmc91m8Bn"
"wIr/RfBVBChVAqUgFZeU3Dz2A9lITU1DfHyCFBMbSxEHbx/fQhdXN8yaNduE97NsWa2KP+//"
"f3L5yxKg9DtJ9svRqkrPnj2XMSCFhUWiT2PgGRh+jg1bAQGkUBPgX83+vyVAsTCP+VQGcsgD"
"ZGRmIjk5GXFx8YiKikZw6HcpJPQ7PnywUDx+8hRNmzZdxvtL7Ve5f/ug/ZPlr0wA8aVk+vio"
"XpNnz57ZMjBkxn4QgOs8A85Gjes0q8D/RQn4Gx+glv9cIf8/sh/R0TEIC49AYGCw5OcfiFev"
"3xABnmHlytVcCprQ2On9p8bu5+UvSwD1zvPe69WpXXtcenp6HoOjNv4/QC6i1o3d+c8k4Jot"
"SsHfEOF/J8PPXYGo/WwACwrV4GcR+Kls/hAdowI/KDgUfn4BcHZxw8OHj6UbN2/j+PFTeXp6"
"FcfSfutyy/ofGbi/HUOx/ksR4Kfaz4ci9UaPHr2NAcrPz1eogZJUQElC/pkAHGzS8kuJIHp6"
"xY+yUNrm/dwK/hwqw6dqA/k4gNr5I5tcf0YGyX5KiirzBfiRbP7gS+C7e3jhvflH6fqNWzh7"
"7oLy5KkzaNa8+VbebyoDWqU/6d86gD8tf2kC6Ojo8KHWinPnzj3DwGdkZMjV2SmV9vGlPT+D"
"9TdEoMelZGAJVx8XEKQoPdij+lt1gIgJw+/hz3DGZ2ergC91+6Lmq2VfBb4/nMn4WVnb4uat"
"O9L5C5dw8OAR+cFDR9C2bbszvN80fto//57/xPJfQYCZs2adYgIkJ6fIyQQyuBJnfmmbVuoF"
"5D9lbm5u3q+EUJPiBzEo+D2lz/F7uL+n7oIPAyMtPV0An0TtXXxCImLV4H8PC0dAYBA8vbxh"
"/8UJnz5b467RfZw8eUY6ckQfm7dsk2/evA3Nm7c4xftNCqBd+pP+rQP40/JXJYBYkwEUJaB/"
"/wHrc3JykZCQpMwkI8ZmTJXp+UhNSxPOnP8uEp1A6WFf9aFcPsZPWS1IUQr2T4BncVB9Z+DT"
"MzJoe+kk9wx+krrex4qsZ+A9PL3g6PQNFpaf8fadOe7cuYejx45j774DDD6Wr1ilXLBwMWrW"
"rLme95sGX+t//KH/huUvSYDSRa0EupUrVx7q4+uXkZSUwnJckpycirS0DCHN/gGBIjMjqSWL"
"oxpNKoH09AwBbM6PzP8167mXZ3VgQomMJ/CptND20pCUnPKrww8TDh9e3j745uwKWzsHfLCw"
"xMtXb/D46XNcNbyOffsOYtu2nVi7dj0WLV5aMnPWbAwfPjKDxm2oTHVByf9/HOCPLj8ZQW6n"
"6p84cfJNekYW1185A03ZKTl9dRbAfP3mClc3D5JmH2HMAgi44JDvghjhEZGCHCzhnM2lwY8j"
"IqNEdnMfHxgULD7rQfLOtd3B8SusbOzw4aMlXr99h6fPXuD+g4e4dccIp06fxdat27Fu3QYs"
"WbJMmj1nHsaNnygfOWoMmjVr/ob3lwZer/Sn/NsH76flL0uAn34A70SVBg0aTPb29s0LCQ0r"
"iYyMlrj+Gj98Ir189Rav37wjJ26Bj5+s8NnKFja2DrB3cMSXL1/hSCT5+s1FZHFp8GMmzxeS"
"c3sHJ9gQidjMWdDneTsMuOmLV3hEff29+ya4cfMOLhtcI5d/Ebv37Kdefw0WLVmKmbPmSBMn"
"Tuasl/r1G1DSoX3HPK2yWpN5f2V/khNDf2kC/HQwiOW09uTJU06GR0TB6J5x0Znzl2BgeEO6"
"YnhTunnbCHfuPcB940cwefRUSPRT05cE4mu8IMl++fotXr02w6s36qDH/Dy/zu97/NQUJg+f"
"4B5l+O2793H9xm0YXL2Ocxcu4wS1dUePncCevQewctVacLZPmz4TY8dNkIYOGyH17dsfnTv/"
"UtSyeUtUKF/+JO8n7bZu6U/4jwzcT8tfmgA/L7QvnFVNR4wc/eDw0ePYf/BI0aEj+pL+idM4"
"QS781Onz0hnKUAbtwqUruGRgKEC8YngDV6/dhOG1WyL476v0HL92md5z8dJV8ZnTZy6owNY/"
"iYOHjgrAt+/cjU2b2dytxnQCfdy4CRg5crQ0cOBgqVfP3ujYoaPUtHHToto1akJbq9wD3j8a"
"qyr/6bH6efmvIQAtGrQ/1WndvFv3Hne3bN2BLdt2FtNauWPXXomleS+Zsn37D0tEDukAgXjw"
"8DEcOqxPoVrz4wOHKA4ewb4Dh7GH3r+LPrdj515s3bZLgL1u/SasWr0Oy5avAjv6yZOnColn"
"0Hv37ovOnbqgZYtWUv269ZTVKlcprli+Aspqat7l/aJx4v37UwxW6fJfRQAKTfXp1kb16tff"
"M3XajIyly1ZiydIVxbRWrFi1Rlq9Zj3WrN2ItQTkug2bRazfqFozuGvXbcRqcu0M8gqq5fz5"
"xUuWY8GCxZgzdz5mzpyDKVOmY9TosejXrz+6/tINHdp3QPNmzVGvTl2peuWqikoVdIv1dMqj"
"fDntjDKamnt4fyjUVwX9FxHg33VR6G9d1J5Ao0yZMnz1by3avxFt27Z7P3LkKOWECZMwcdJk"
"zljFlKnTldOmzZS4Vk+fPksVM2aJ2k2kEQBPmjQV4ydMxpix41nWMXTocAzoPxDdu/dE2zZt"
"0bhhY9SrXQc1q1WXqlSsqKRMVzDoFSlordTW0npPuzOC90OmuhpZQ/YnA5+Xv7wCiFHVEFF6"
"PajYGfphFejPqvRnAy0t7Xl16tQ3a9midU77dh2pNndBl85d0b1bd4oeIrp17S6y+ZfOv6BT"
"x87o0K4D2rRqg5bNW6Bp4yZoULcegw0CG5V09UBZjorlKcu1dERUKKcDHS3tnLKaZc1ob+bx"
"91Lw91dQj9FPy5+HCf/SZeE8CYI3wErAZPi/CN4Wufofwc+VnjRTAa3xA+T/baG3ldUqW6aK"
"poasOm2hmXZZjSl65csZVqtUwa9G5YoFldVAVtGrSMBWQlWKauo1Bz/Pr3NmVyinLUKXQqes"
"lojyWuVQWbdCQRW98n66OuUMtbXKTNEqq9GsbBmN6mXKaFahvfxNrd7PxPity/+Vsv7ZFeB/"
"lE3+3rJly5Qpp6Wppa2lqUNRXruspm4ZTQ1dTQ2N0mlcnIGcifVlqgMwzN5+NWrUODZo0BDO"
"8uImJOd1atRC9SpVUa1SZQE8k4MNnJ5K0sXfLO9MjEb1G6JVi1bFAwcOQvXqNY7x9tTbra+O"
"0szX1dTU0CtbRlNXu1wZ4kjZ8hQ65bTKaBFByvxPo/YHOPGHlj9EgLZt24oP9ezZUzZ9+nTZ"
"xIkTZVOmTJFNnjz5f41JkyaJNb9/6tSpYj1hwgTZ+PHjeTsatD2N2bNny+bMmUuvT5NR/Zb1"
"6NFT1qxZMw3dCiSyNIDly5erwIMqU83V4+BZPzzotSkaU7Tn3auiqzmqXg2tma3qay3r1057"
"+/AuOscn9Kp4Z+nQMo/XzOzoPG/RStA+lIwdNxHDho9Ef6rx/foNELJfRbcialSugupEiOq0"
"rlm1GqlDZbRo2hzjJ07BFPrcvIUrsGnJYOeNM5s9njGi+Z1x/RscH9Kj7va2Tassa1Bbd2bV"
"SuVG8X6o96exev+qqvdXj8BlcujpaJetQCGIQYT5p5j/zAdelSrlv6K+vJ1SAgQHB//vBOAn"
"Odq3by8+xDOEr1y5Ijtx4oTs3LlzstOnT8vOnDnzT4NfO3v2rHgfr0+ePCk+R69pGBgYaFy9"
"epVeOy/bt2+/bPny5bIxY0aX6dy5o3aDBnUr6FYoXwo0X0tXjfabs6xdhQrlBzZrUmtW3y61"
"tk4eWP38phn1nh5f1sDOaHtj/xeHmsRbn22a882gebH7labwvd4EAdcbwutyAwRfqYanp8Zg"
"0YotWLxoIWbMmi9M4CRq6aaRIWQfUKNyVdSrVRu1q9dEnZq1UJf+rlW9BlqS2585ez59bhEW"
"Lt2Ad7dXocBlPlIdlyPTeRVSHFchxno5vn9cUuzzemGOtdGM+JeXJ/lf3jvMbu+qPk9nj2t3"
"fkD3Rlsb168yi0AfyL9D/XuqqX+fXhlBCi0mhTYrxT/jg+z/yEb8LgUonR5eSgDOYH19fTFd"
"/ODBgwTePtn+/ft/BD/mOHDggHh97969sl27dtFr+zT09Y9pHD9+QrZnz17Z/PkLZIMHD9Zo"
"0qSRdvny2j/P0uWDJjznrmO1KhXG9u7adMPyuQMuXzw6w/ztnUX+3x7PTvN7NKo46EEvhBh1"
"QfCdTgi80R4+V1vD50ZreN5oBderzSSnsw2L7c/UU9qfqqX4dLSRwu5oRcWNY3OUW3cfx5bN"
"m6jt24SVq9bwCRssW7EKPcgcMtgN69VHfXL6DerUE3/zukXTZli+Yi22bt2KzTuP4N6lDcrw"
"D9MUQVarFeHWyxVh1quUEdariqNt10oJjpuQ6rwFGW7bkee9C/neO5HnuR3p3zYh2nZ9sfvr"
"5Wmvrs/yO7t7tPmSGd0v9/ql0YbqVXT5aqGO6t/Nv7+imhC62tpafPpYo3LlKrJOnTrL+vTp"
"K+vdu7dGly5dNDp06CAm7f7yyy8iOnfuLKPn/yFKX+vevbusYcOGP4jwhxRgxowZIrsZXCbC"
"kSNHZEePHhXBfx87dkzEoUOHZIfoPZT1GufPn5cdPnxYtnTpMtnAgQM0GzaoT9JXthRwMXmT"
"6nrXVi0azJwztb/++SNzzKxMtwVHu5/NL4w0gOL7UWR+XYbwZ0PgdaUjvp5qJdnpt1RaHWkh"
"t9FvIbfVbyl3ONVc6XSxWbELge9+vSVcDVrC5WJzOJ9vBqcTVeB8uSnuXjuBI8fP4eChw+qD"
"PXvEgZ5t23ejT68+5PrronmTpmjSsBGaURfA0aJJM4qmWLN2A44cO45DR0/j/u2LiPgwD3H2"
"i5Doul1EnNNWxDhsQIzdeinKbmNxpN1mZYTNZnmY1Qb590+r5WEWy5XR1iuk5K/rkeWxCYX+"
"OyEP3Idsn30Is92a/8l4RfCZvRPNpo3tot+4QbWZJNVd1YTg8amop1tBr2XL5jojR47QXLt2"
"nezUqVMyQ0ND2cWLFzVOnjxB43zqh9L+rMr8Nz9//Phx8X7GjxeeHxgYGPj7CcD1n6Wcs5wB"
"ZyIw2AwwPy5VAtopDd7J9Rs2yoYMGSKrW7e2NoEsQFe3ak2rVa04cszwrrtPH1rw2tFcPyIl"
"+IayJPEukHQX8mgDpLjtRPDbacXut3vJvxp0lH+92FH57XzHkm9n2hEJWjMR4HyuFVzOtoDr"
"pdbwuN4BHjfbw9WwGb6dqwEHfT3JkeLL1Z7Su5fGkpHJc+nK1Ws4K47nn8Wx46fEkUA+jNy3"
"dx+R6e1at0HrFi3RtlVrtGnZCh3athclYNWqtTC4egOXLl/FPdrO+zdPpUDzNVKk5Rwp0mqR"
"FOuwGnHftiHBZQ+SXPch0XknEr9uQSIRI+HLRsTZrkaMzSpE2awqibBeqQy3XiOPtF0vj/my"
"vjjFdSsKAw4CUWcgRV9Cmu8ppeObHRGn9097PXJw+92VK5YfKROHlIWXqEgKrlezZjXtgQMH"
"ytasWSsSkZJOg1V5z549AhNW4FI15sf8Gpdf9l2lBAgKCvpjBGBgGWTOegaf16ov3S8ynl/n"
"bG/Xrq2mrm4FdsY8WZKZ3LhG9UqjZk0beMz45g6HaD/jHCnbAsi3QHHKM2RH3JVSAgwUMc57"
"5d8/zlYGPR0iBT0eBA7/B/3gee0XOJ9tSxndksBtKdkfayZ9ITUgUpDkt6B1Hbhcrg3P2x3h"
"bzoVUQ76CP12HzY21jD7YA3T5y9g/OiZOLlzTX1y5yIByucL+vXui47tOuCXTp3RuWMnWndB"
"l46d0bNbD0GCxVQqjB89hdGDR3jx8hXemn+m7dogyvcdUgIeIfbbMcTYb0SM7Qpar0Ws004p"
"3mkXEWOzFG2zVoqhiLVdS6qxhoixASkuW5HqugMppB5JLrukRJf9yniXA/JE9yOKzIDTkjLa"
"EEh7gJIUY0R5Xswxub7GYc60vsdq1ajMJrOxejwrVayoW6FDh/aay5evKM14jUOHDoqELFVo"
"XjM+rARsxv/PCMBSX5r1/CUsNwx8mzZtNLW0yuqq5as6y/uQgV223jbc/jkh9GUulK5AsQeU"
"mfbIinmjTPtuIs+IeFicGUJZ77wB0RaTEf52NEJfjELg06HwfdBP8rzVXXK52EHizHc60Qpf"
"9Jvjy4m2+HKyBZxO1YHX7S74brEWiQEvkJkSgSKlhLRsOTx8w2Fn/wWfLC1h9t5CnPl79vyV"
"ODv4wOQxHjx8gstXrmFAv/6iDJQGE6IvxSDqEvrS4+nTZuD5q7fgU81m5hb49MkSdg5f4O4d"
"gpSMAhTKi5GVFouMKHskexsi7guVBJsViHXYhHjH7YglcsTar6cSsZqeW0fk2CIlfN0mJZJq"
"pLjvQ6aPPnICzyIn6DyyAs8h1f9CcUrAVXla6G1lYdxDIPcVxWvE+t3MvXVp1efB/dtv5XHl"
"8eVx1tIqo9u6dWtNHv/ThA9jw9nPROAE5b8ZH+7e/mUCcAlgiWHweU11R2Pz5i3iYBFtuILa"
"yNSqWLHC4GWLxl90sb8TUSL3oM0FSyX53shJdlJkxVsr8pI+SUXJ71GU9AaZQecQazMfEeYT"
"pLD3E6XQ12OlYNPhCHg0CL73+8LzZne4XGiPrydbw/EYg96OwG8Ar7u9EO9mgKzUCOQVloCv"
"EVYUA1mZGQgM8IOnh5s432/n4CTO73+0+Ix35h+JDB/wQoD5kQhgiCEDB2PUiFEYPnQ4Rgwb"
"gZHDR9DjkRhNz40dPQYTxo4X1wJYWtnC8rM17B2+iotOPD3dERQYgKysTCiIdHmFEnLylchJ"
"j0Nm+BsBPkt/nMNWxNqRAjisQ5zjesQ7bQKDn+SyHclu+5DmdVzK8L8oZQZdkbJDDJEbdg0F"
"0UYoiH2E7ChjKT3cRJEZ/VShTH9PP/CzVJLzDi5WZyKWLRx+sVLF8oNlqsPPVcg8VmAcNm/Z"
"IvzAzzgxAbgl/90E+LkLmDZtmtgQu/vjlPWkBhpDhw7lHlNLXdtr6OmW779+zczrEUFmqVTY"
"IJWEoyDTszgnxUVelOkuFee4UfY7oDDFEnnxb6RUn8NSnP1iKcZqDqI+TkXY2zEIfTkCwZT9"
"AST/Pka94UHyTwqAb6wAJ8kDnG2CKNsdKMhNQnYBAZ5TgNwcAkGeT1GEpORUhEfGIiAoVFwV"
"5OLqLi744ItCrG3sRZh//ARbUoezZ89jzKgxmD51BiZNmIQpk6Zg6uQpmDZlGqZRmzhn1hxM"
"njgJV64aiu04EJnc3D3ElUIBgSH0PdHi0jGFQg6lohB5uXxdYR6y8pQozEtDeuBdahNXkvxv"
"oOwn8B03IsGJ4utmIsBOUoD9SPc5RZlvgOzQm8gJu4PssDtSdvhdKTfqoZQf+wTypBeQp7xC"
"XuJLKSPmhTwv0axYKrIBJAdE+Bqlrl894bqerk5/Hn/GgfEYOnSYwOe4/nGBF5eAf1kBZs6c"
"KRzlUWIVGQuNpk2b8dO6xDyWojZTJw09GupvlgjEo0QZLeVnBigKMn2UJfm+kCiUOR4oyvgq"
"FabaS/mJ75Hue5hq4kokOFLttJqFyPcT8P3NKEGAoCeD4W8yAD53esHDkAhwoR25+k5wvtAC"
"SZ5XQImOlLQMZKSnID8vF0UKpZjqwZd3p6enIzYuTj1ZI0Rc2uXp7UPAeYpJGxxMBhdXDxw9"
"cgyzZ87G0sVLsHD+fCxasAiLFi7CkkWLqfdfjJXLV2LxwsU4dPAwvLx94e7pBZ75w9vl7fP3"
"pKVniAkpJXxPAp42RvuTmZEm9k9ZAmRHviMlWEngb6LywAqwUShAsttepHgcpnE4h6wgQzUB"
"jJATfhe5kfeRG/1IRF7cEykvwVQqTH4DZfoHKDM+ITf5gzIv8YOipOALfasbQn3uJU6d1Pco"
"40C9PuOh27RZM4ETqwArNx+E+91dAK/btWsnPsgScunSJdnKlSv4vAAfpmK5r127VrXxr0wv"
"OgMJKFbGlxRkBSqKcoNLIP+OkoJAyHO8JXm2hyTPcmUCoDDVFhnBZ2gANiHJmaTRbgGiLacj"
"ggnweqSKACT/fg/6wvt2TyJAZ7hd7UoEaImIT+vAS3JSPNIz0pGbV4D8/AIBQOlkD77aly/l"
"TkhM+jFrh68JDAgKFuD5+PqJizt5Esf+ffuxbu06bNq4CRvWbcDGDRuxacMmbKbHWzZvwbYt"
"W7Frx07s3LELjk5fxTWFod/DEBMTi4SERPE9/H3FJarvZgLmi8vQCwQRk1MSxf6m+hmSB1hF"
"4G8mImyg7N9N4B9Bms9pZPhdJAJc+5UAEQ+IACYE/kPkxjxCfvwzFCS+RAGVy8Jkc6ko7bNU"
"nG0L5NjSeFqX5KVaKUqU7jTeDnhyfYVzrZqVJjAujA/jtGLFCpmBgYFs7NixPw4G/S4F4IMO"
"vPA98rZQfSGZ0dTR0WaWNRo3ut+B1CS3bLKtKMwJU8jzwkqgCEdJYSgUeQGSItePwgeKbHfI"
"Mxxphx2RHX4dKd40AO5bkei4DLHWcxFlMQURZuPw/dUIhJiS/Bv3h69RL0EAd8NOFD3gRv19"
"dqS5yKpEIkBmdq6ovzzgfLl36eRQBoKncPGVwHxZN0/XLr2Wny8IZQAjSLq/Obvg4IGDOHL4"
"iFgfOnhIxOFDh8Vzx44eE3Hm9BnoH9PH69dvkJyaJq42FlcaZ2WL7ymdYcTfX6C+tYy4tDwr"
"B0lJicKXFKa6UZewHPHUHrIH4HYx1fsk0v0uINOf5F8owC0iwF1SAMr+qIfIi3lK2f8c+Ymv"
"1eC/Q1HqJxpHW8gzbSVFho1UnOsAqeArFDlOJbmkCFLaU8T5XckZPbTLAcZHR6dcdcZr27Zt"
"Mj7kzgsfFv5NCvD35wL69evHt17TVEt+q/27FpuQEENeGKssyv1eDGUsJHkElPnBkjIvEMo8"
"fyIBgZ/rTTv8jcIJ+XGmSPPbJwiQ7LIWCQ6LVNlvPkG4/5DnQxD4qD/87/chAvSG960e5AG6"
"UJ/P63bIjrUTGZWYGIf0zCwyfFniku4f9/tRKMB3/yqdzyemcefmicu9OVt53gADyLJtTa3c"
"hfMXcM3wGi5fvgzKEooruHrlKgyp5l+/dh03r9/E7Vu3YXTXCI8ePiQyJQnFYaCVauD5+/h7"
"xUwicV8hKgG0X7x/iYlUDml/sxM9iQBU7r5uFZHsfpB6/jNI97+IzIAryAq+juzvdwh8I+RG"
"MAFI+mMJ/Pg3lP1mKEg2I9/0EUVpVkQAOygy7UQnpcz+QslFZaDQhUqDBdJCjIrz4p8qkfUK"
"OzdMN5HJNFpRwlevUqWqZs+ePQSOfE7gNynA358NJCJpaGtr8THsVmf011Bvkofc7MiiEnm0"
"BGUMlAXhkrLgO4rzg4gEagJw9pPxk2d+RVG6LRmci/SjDyLFa6eQ/3iHhYixnKEiwBsigOlg"
"IkA/+N/rLRTAizoAj+tEgBu9qBvogMSg94IA2VkZSCSzx5NAOBN5Ygdf8y9u4aKeGl7801w/"
"1Y0dVNO9eF4Av/eThQWePnmK56bP8YzWz6L1goAAACAASURBVJ4+gynHM1M8f/4cr16+xBvK"
"erO3ZuK95ubmoIET3y+mnUvSr8DzZJO8PNUdQ0h5eL8Sk1KIfNmCAD7fXlMXsIYUYBsSnXeQ"
"+h0m+WcCXEZmIMs/Z74xxQMqAcbIi37yKwGS3hH45pT9lpDTGMozHKDI+krgf0VxrjOK81xQ"
"ku+G/KT3UgElWH78KyktwrQIys84eWjlK8arvI64j5LGH7pLGLUW4kRERT1dPqvVcM+WKXeB"
"THLe0YWUi5CUsVJxQZhUTLJfXBBMBAgUwQRQcvZnO1O4EpNfEdP1BQGSPakN+kY10W6+mgDj"
"iQAj1QRQKYDP3Z5UAnoQ8N3geYvU4E5nRHm9QE5uEe1Wsaj/nJGc1ZzhPPhi+pd6ylcpGVSz"
"g4sFYCzXvPDkDwd7ezg5Ooq1g72DKhwc8IV6fMcvX/DV0Qnfvn6Di7Mz3Fzd4EHu39PTk74/"
"R2zzx5QyUpg8MfVMNWU8JZUnlSQTEXLFd/kGhMHizQ2kulA7+HUnkl33kAIcFvU/3f8S1X+q"
"/eFU76OeURDwnP2l8i8I8J5KyCfKfmsC/wvkWY6U9d9QnONK4LvTWHsQATxpfD8iN/atRO+X"
"5CkWSA5/XogSR+zaspSvUWyorV2ukvpUgMZvOhegJoBGixYt+UN8M8Sq/Xo0XI8icvNFaXIg"
"idx+vFRSFEHxXQV+AWd/gCryfEkBvGhnnYUC5EXfoZ6fjI8vD8Am0QHE281FtKj/Y/D9xVBq"
"/waoFID6f78H/eB7rw8B3wPed/sRGTohxvcVEhNSkZ4SL1w/T/0qna3LA59Of/NEztKpYqVz"
"/0onh/KaJ39GRETAy8sLvr6+8Pb2ho+Pz4/w9fEVz/uRWfTz84O/fwACAgJAgyYiNjZWkCuf"
"t0/B38flhb1GIgHPZFSo7y+Yl5eDj5YOsH5/B8nOWxHvvFfIf4rnCRqH80gPMKCkuE0EIMcf"
"ZUrxlOIxEeAFgf8a+Qks/x+JAJakoHaCAIqsb5T9LuCWWhCgwJMSzZ3ea0Eq8InCUspPspDk"
"VC4y483lxTkuGNi3J09Pq6pdrpyOWgE0frMCtGwpCMAnb9pbvt7lC6TTICYqyYujRBEjSXI2"
"fSECfJH5+ZT5eX60UwQ+sVROclWY9pnM3wVBgFTvHWSC1lH7twRxNrMQ9WECwt6MQOhzPvTb"
"l2IAAkxIBcgI+j3oD597ZAbv9qWWsAuifV4hOZkcfnQYUmmwiwoLxKxgBpWBKJ3Lx8E3byg1"
"a6X3BSxSl4B4MoVx1MIxmLHk6GPIIMbEqIIfx8XGIT4+npx+ApISE8VdQHiaWQoRjSeJMtmY"
"dNxpJKlBZ7VRlt5HSF4k2sK83Cx8snaC1bs7SHXbhUT3o0j1Ok5jcIq80HlkBF5FVgg7/6e/"
"EiDalOT/lQr8pA8k/6XZ76AmAMk/g59D4BPwJQXeRI4vggAFSVZEGCvkEQn4MzlJn8kIucHa"
"/L4v41eunOp2Nb/xdHAJBWQd2rdRTcrs2WiVMsOMfmQmFcBElBTHS5IyGlIRE4DB96cg4Mn4"
"qcAn55/tJCSL25isoIPI8Ofs30B9MGW/wwLEWk2j/n8cwl4PReizAYIAgSZ9EEAtoL9xP/gZ"
"D4DvA1IBo/6kBJ2IAC8JEMq2uEikpSQhMz0VBfl5kNQ3byy9RQxnu7iFC9/IQbRjBBaVCzaA"
"sQRuDANP6zhBhHgxB/DXoOfi43+8Fqd+zGDzdoTKkNHjW8WxAWTAWYW4RQwODhXdBncBfB8K"
"9gAWVo5EgNtI9diHJK/T5H+IAF4nSQHOEQHY/ZPpi3xGCvmSgjI/hsCPe4u8+Lc0buZEgM9E"
"ABtSUUehpIos518JkOdF4+1JnQJlfiIpAJWB/OTPKEixRn6qjcSEyUu1UypzAtC7R5dVjGPZ"
"smW0futxAA0aT1nnju2E/O9eN+gWip2o102Vc89fQrW/RBGJEur3iwu57vvQDnn/yHxFDjt/"
"kq1MB2L0fQJ/B9U9csBuq5HgRNlvOxMxnyaR/I+i9m8wQp71R+DDXgR+TzKBfYQC+JsMhO/9"
"3vC60w+eN9oh2v0eZSAZrJgwIkAqcrLSBQGKS02Z+gYRPLOXZZnNGD/mzC+9w+fPC2dpMf2j"
"4Nu/qEOYx39yOxm+AQX3+bxNJgZPRLWytoHxw8c4f9EA9x48ErOF+dgDfydvOz83Ex8/O8LJ"
"8hYyvA8JAqR6n6A4LUpAhjCAxmoCvCLpfy3AFxH/jghQqgA2oo3mbkpB8q8k8PnAWkmBLwrT"
"7bn2E2HeUbBqWAgVKEilVpHUIivRhvCKxfaNy26VlgEqaaK8/yYCdOrYjm+TXvvq8UlmkNvS"
"YCbKS4/2lSgiUFLE5o9rPoPvIXZO1P2sL9T326CISJAbfR3pvhuJ+euR5EL98Jf5lP1TEP1x"
"LMJfDyHwSfoJfP/7XQn87vCjDoAPBIkSQO2g1+1ecDfsiO8Wa5AUH00KEI/UpFhkZ2aIelx6"
"6xcGOo3KAPf6X51d8fbdB9y7/xCXDa7i1Kkz2Ld3H44ePowb166Jtu7N69f48N4cdja2qrC1"
"xccPH/COnL/ps2e4Z2SEy5cu4/jxE9izZx+2bN0uYt/+w2LWEJ9O1j95BmfPX4Lp89dwcfMg"
"BYgVdxIheRRG0J6MZZTrFQF8svdpIf+p1AFwCUgPUJWAHwoQ+4bM3xsiAEXCe7UCfKISak0y"
"7yBa6R8egMaaEy037h1yY15SvKDPqkpHfpJQAklByZcZ/0kOKRaXTu0zYxyJAOV/HwE6CQLU"
"unB4wgvkvkBhfiQRII4IQOZPEUbyz+aPpd9LmBEFmQ6Wfc7+onQyLxlWVOOo/fNeQzK4huR/"
"MeLsZ5P7n4io9yMQ9mIAQp70QpBJNwL/F/jd6/aDAGwCvW73FCeE3K92ge/D0YhyOkkKEEpA"
"kxRnplGWZYnbt3HO8q3huAfnAz6q27VYwPD6LXHhx/iJk1Gjek3QbwH1wmKtSVFGpoFymmWg"
"XaYsdLTKQYfWfAVweW0dcfVw3dp10apVG/Tq1QfjJ0zC8hUrceiIPi5euoLzFGIq2dmLePjY"
"VJx8ioqOFFPNRbuamYxIr0eI9TBACoHPkepzlsC/KFpAVoCskDvCBDIB8ksJwNnPmUyhIsBn"
"tQlkRf2i6gJyqfVL+ICc6OcC/NyY50QgKiEJpB4JpAaJ5pI8/TMyYt/LURKHM8d2vGActctp"
"/V4CtBclYOWCPheQeh15Gc4qBZCHSCXyUCIA135vAb6SwOed4+yXZ5JapJN8ZVjSDzz7KwG+"
"LkSsHcm/5QREvRuO78/7IeRpHwQ/JOl/QCS434MI0FN1IOgOgX+jK2U/hUEneD4YBV/T6Qi3"
"pC4ilIxlVibJsiTkuaSYevLCPHEIlieNurh5itPA128aYS9l7LwFi9CxfUfUrl4N9WrVQp0a"
"NSlq0OPqqFWtmljXpsd8WVjj+g3EFUJ8kUjXLl0xYMAgMTtoxszZYgbRvgNHcOrMBZw8fY7v"
"BYQLFy/hqekLfHNxR2RMIvkPakXTApEZ8ghR7ncQ6WqIVN/TpABnBAHS/Q0I/OvIDL6F7O/U"
"/0c8JpV8ri4B71TZL6TckjoAa2ECi9JUxwCYAErKfJb5HPILOQL8l4I4eXGv1d3DW0GAorT3"
"RAArORQJWDxv4gXGkYzgby0BahPYoS2bwEqD+9ZfL485jexoY2qqv0NSBJP8BxABuPaT9Oe6"
"qgnAxo92NIsUIO2jIEFOBMmd1yqkuK+g+j9XKEDs50mkACMR9nKQKAHBj3qTAWQP0Au+3Prd"
"6gavm13F2UDOfteL7eF5fwS8nkyDl/F4BDyfhgi7g0gL+wxFoSrjFFTmM7LyRJvn5uYGc/P3"
"uHnrNvbu249Zs+egWZNmIrt1tXmSh7aY4CGCHuvqVIBueT1UrlARVStVQc1qNdGwXgO0bNEa"
"3br1wNBhwzFjxkysWbsWR44eI9AviwtKTpy+iGMnL8L40Qu4uX5FXKgD0oKeIc2fnH/QY0S6"
"G1MJMESKzymKs0SEC0L6M4PvICv0AbLDHqm6AHUZyI9/T2FOhu6DALkozUEcRCuiWs/B8l+Y"
"YoOcKJb911T/XxPwpR6AvcMrNQFIRZLfIDvJt7gg4Ru6tKzOrWClMpoyrcCg33JNoLoNbNeu"
"FR8+0mvTvPyM3O9birMibhAr35J7Ivkv8iEj4kkEcFMTwPlvCZBuoSJA5GVSgNWkAKtIAeYj"
"zmEueYCp5AHGIeLtSHx/QSR42k9tAnvBh4D3uv4LPK91gduVTnC9THGBCHBvOLweT4bHvbEU"
"4+B1nxTh8VgEv1uOOBf6jkhbpCV8F8f6XTwC8Pq9DS5fu4/tuw5i+sy5fH0/qlWsiNrVqoqo"
"W6OaKlgValYnZaiBhnVqoUn9emjeuBHatGiBjh06gGf/Dho8jMrINMxftJK2dxj6py4KAty6"
"fglvnxrA3+EW4j0Mkeh5Fan+D5AZ9hrpoaaIcDNChPNl6v2PEgGo9vtfQUbQLVKH+8gi8LPD"
"H4sSkBPxULSB+XFmQtpV8m8rar8q7GlMndTgv6L3vlARII6Bf08kMPuhALnsBZJIHeLIg2XH"
"IdBse3F1LdkMmab431PKBAf/riOB4lCwXqWK2oOiv41JVyZcQEbE7RJF5icqA/4oyXcVhyMZ"
"fGXOVzUBaGcz6cvTVATIi7lFBFil9gCL1AQgE2gxAZHvRiPs1VBSgQGCAFwCfG51JfA7w82g"
"I4HfgdadxUUhnveGwfPhJHgYjYK70UhShLHwejAOHneHwePWAHgaDYPf05kIer8Jfp/08fX9"
"BbwyOYfzJ/dhxbKFaNumDcqXKw/tsuWhIdMiH1D276IceQIdaJXVg55uNdSpRQrQsi369u2H"
"aVMmYPP6pbh8agfePjwJ5w8XEGh7FhFfTiLc/ghCbA7h+5dziPW8i5TAx8gg8NNCniHc9S7C"
"v56j9veQKAHpAUSA4LvI+m6iIkAYEeD7A+SE3UNuBB8FfKn2ACz/nPWOos9XUAuYT4qQHfEC"
"2ZGmRAIiQKwZckkt8pgEsa9UZSCWSkm8KZGASkRyaEl2uDmerNNLL6cpG6ShvlNJ8O85FNyy"
"pSCALhGnk9u7gSFIWYz0MMPi/PjHDK6kUgAV+MpsR3KpdgJ8ecZnMi/m9J4PtGP3qQSsphKw"
"nBSA+n978gBUAqI/jEH42+EIfTkQoU+pDTThFrAHfG93Fwrgztl/qT1cLnWEy/l2cDPsBQ/j"
"sXC7NUwQwMNoBDzuDKEYCs+7I+F6Yxi+XhkEh8sDYH+pHxwMBsLp+gg4G02E070ZsLw+Fa/O"
"T4LJyYm4eXAsDPaMwemtI3Fq6yic2U5/bx+Lc7sm4ObR6XhwZg5eXl0My/sr4fRkLTxeroef"
"2QYEvKMw3whvs01webEBDk/Ww+bReriZ7UGo/WnEul9Dir8JMkKIAFQCmACxrmdIAY6JLiDN"
"7xIpwG1kht5DJgEvPEAYx33ksQKIg0DmJN/WRAA7QQBu//KTPiMr8iWyKfuzI56RqpqqS8Ab"
"VQngUhBDZSSeM99Wykv2p/rvWuxt2BYGs2UhMplmp7JlxOyp33UuQKN585ZqAsiaPLnak/qK"
"WcgLXqgoTDSmOvNWKkq3IvlnBXD6AX5RBveu1MKkmYlykZ/4FOk+65DiukR4gFibKYj5NJay"
"f5jwAKHP+1Mn0BeBxj2FAvje6Q5vPgdA9d/tMoF/oQOcz7UXVwQ7X+tH4I+C662hRIQhcL89"
"mGIQPG4Pgev1AUSAgbA5NxDmx/vBdG9P3NvUCTfXtcP1da1xeVVTXN3QHCZ7OuLZoW54faI3"
"zE73x7szg/DhwjC8OzsMZmeH0/PD8PTQIJjs7Q+jHX1wa2sv3KC4u3cgHh0fg7dXZuDT3UWw"
"vr8MDo/X4OuLTfAy34MQuxOIoZYv2fceZfkjUoIniHa9jCT3I0j2OqHqAoQHuEavUxkIvk1d"
"wF0iwQNV9rMRFMcAPvyqAGmOlM3mavCppkeyAjwnAjAJnlIXYCo6gNwYU/rse+TEf0VuSqiU"
"G/cNTpe7KlwOybBvopYD46dTrkwpAX7zoWCNZioCiGMBp3a3e4LseSgImixH7GrqUx9J+WRS"
"CvkgBfX+CuH+P4msL0rj89dviMmm9GNMkeG/HckuC5HwhbN/HKI+jKD6P4jqP4H/rI8wgQHG"
"PagT6Amf2yoD6CU6ADKATILzRIDTbeBwtDm+XugO19tMgEGU9f3hdnMA3G8NJgIMgiNlvvWZ"
"vvhI4L4+0A2Pd3bB3Y0dcWVVaxyZUw87p1TD3mnVsWtqdeyZVhO7p9ai52ph15Q69By9PrUB"
"to1vgM1jGmL35GY4OrsNzq3oghvb++LR0eF4dXY8LG7MhLXRAljfWwwbk5VweLoBnu9ZAU4S"
"4AZI8r2LtEATyvjLSHQ5iCS3w0j2IA/gfVLVBnIXEHSTfACVAjKDXAJyCUwh/9wFUE0vTKLS"
"mfCRQH+OLDKJWQR6dsRzAb5QAHoum3xDduRDFQHibZCb6IOCjGgqPe8l96vt8GGnTO6uXw5L"
"+8ueMH465TTL/1ECiFZw8Ywm55E9nwgwgwiwCCXRayVFshEKMl1QlOMnzv0rsvnUL7n/lOco"
"FOA/IRIQe0OOIenbLMTbk/mzpH7efDgi3w4mBSD55wNBj3qRB+gtDgWrFKCraAE9b3QjI8hd"
"QAdBgC/HWsBmf2PYHW4piOB2cyCVgEFEgIFwMeyHL+d7qwnQFy/29YDx1s64vb49DJa3xLG5"
"9XFgVm0cnVsPR+fVh/78hjixqAlFU5xc3JzWLXF8USscndMKh2by+9vg7JJOMFjXDTd39IXx"
"wSF4oj8K7wym4vOd+bC6uxA2D5bhy9P18DTfhxCH80SAq0h0v4D4r3sQ77gVCd/2Egn2kwoQ"
"CTyPqw8CXVS1gSF3VOcCwkzUBHiFAgKdPUAWGcN0UomM7/fJUD6kx0yCF0IBsqhkZH8n5SDV"
"yIn9SMC7UdsZjry0EMR9O4dvF+pLjkfKw2Kvrtz5gAyjOmicZ/yIAL//ZFBz1dlA0QoO61dz"
"C1LnQh4yXYmYpZCiV0uIWYOSxDNkUmygyAuFMj+ciOAv1KCQFCCfSkVB4hP6gVeoBCxGguNc"
"xFhNoPo/EpFmQxD+Zii+v1QdCg56woeD+8GPTwWrCeBxvatoA92oE/h2pi2+HG9J4DeD1e4G"
"+LytHqz3NsGXkx3gYtBbVQKuDobNhYGwONUPr/Z3h/Gmjri1ph0uLW1JoNajLK+BXZMp6yl2"
"TaqN3VPqkiLUp2hAfzfEzkmNsHNCY+ye1BQHprfAqUUdcJkIcGtnPxgfGopnx0fhvcEUWBIB"
"Pt9djM/3lsOefIDPh90It92HaNvNiLFZLSLWYQvivmwjMuxEousBJAkVOCV8QHqgoTgOIAgg"
"DgS9oPr/lkB9TOpxnTqJKyoCEDmyqFPIDH9CRHhE4JsIMmRHk9wnuBDwYZT1kUj/bo6QNzOp"
"VNbE17N1JMdjVfFpl5bSYa8mfmkk28L4aWupblb5u64HaKEygdQKaug1b6w7B1GzJCl8loSo"
"hUD0ciBmIxBLEbcHJSlG4iCFoiAOyqIUihhxTUAhdQP5cQ+oBMxDvMM01XEAq2mIsZyCSPPx"
"qrOBpgMR/KSfuB6ADwQJD8BG0JBbwc6qTuB8BzidbCUIYHOgCax3N8SnLXXwcV0NWGysjc+7"
"G8P2cDvYnOgGixO98GJvN9xd3wGGy1rjzNxmAvCNY6ti67ga2DK+Jkl9LYo6BHo97JhQX0j/"
"1rENsWdyUxwkBdCf3xanF3fA+ZVdYLi5F+7sHoBHx4gAV6bB+vZsOBrPg/uT+Qh4uwiRn5Yh"
"ynIJIi2XIdpqJRFgLWJs1yHWdj2RYAsSXPYKL5BCXoB9QJqfqgywAeRrAbLDTUSLmMzHCgIM"
"kUb+ID3ktlAAVoOsCFMC/R0bPOQleVG2hyM/PRKZUbaI+bIHvg8oWQwb0zi1ojGqDYcjlWC9"
"T0f6tF1DqldFNoc7Oa2yqsmnf+T+ABoammX0KuqVGZbiOSUTMbNRErGQsn8VpJj1BP5Oir0U"
"u4AEfZSkPRYnhYoVaSgplqNEmUstY7w4SJHqtVu0gdEWoxH9cQyiPk5E5MfJiHjHF4WOQYjp"
"MEEAz2ud4HG1IxGgs/AArtQJOJMPcDzZmmcHwf5Ic9juayyUwJKUgIlgsakmEYHIsKk6Pm6q"
"BbN1tfCUTN+t1e1xaUELHJ7WEDvG1xaxZUwtbBxRCxuG18J6ik2j6hL4RIJxRADK/iNzW+H4"
"gra4tOoX3NzaGw/2D8TL02NhYziG2s2R8Hs4BsGmE6iDmYwws9mIsFiMiE9LKZYRGZbQ40WC"
"DFGflyPWbj0SnHcSAQ6IbiDd9ywyAw2EAvAxgRTv80j0OE5G8TRSfM9T9l+muEoKQCUikpx+"
"vD3yU7wJ8DCKaOSnfkdWtBUSXI8h9M0Y2pdfKKhs3iGvdKmRIID9kSqS/QFtmK7VyNQtJxvG"
"BCijqanxB64IUl0Spq2txT3kL76fxoUjaT4UYfOL2QhKMRslxG5RkSD+MBHguHp9FlK6KUry"
"vFCiSIUE1dU4fJJEkfud6t0bpHkfR5wdDZo5nxIeQoM5CMHPBiKATwLd7QPv273hebOXyH7n"
"c+3EnEDHE82JAM1gf6wp7A40gtWuevi8oy4st9aB5fa6+ERr8/U18X51NZitrgKzVVVgvKYl"
"ri1ri6tU3y/Na4nLC1riwrwWODerBXaOqo91g2thy8h62Da6AXaNb4x9U8n8zWuN46QA9/f0"
"x8vjw/Dq9GhYGY6D792BtG+DKeNGCBIEPJuEkFczEW4+n4i8EJEEfPQnjgWkcAsRZ72MfuMa"
"UoFNohQkUClIcD1CcZRU4RCVhv1EClaGY6ouIeA6ZT157WhL5Ca5oyA9HIVZiSjIikdeij8R"
"wozMJXUbdvMQ/n4kEWAkgp4Pgf+jbjRebeBq0Ez6dqYObA5VLnY8pI0bizTCGTe+P0Hp3Vf+"
"0CVhuhXEVO7mb+4M+YaMhSgKmatAHClAFPmA2M2q7I8/IBQACWcozgNJF4Hka0DGE0i5jpDy"
"/SEpc9QnWFWnXEsU2ShM96La9piyZD8N5CwEmPSjDqA93K+0osxvRZlP7d/ZdkQC8gHnO8Hp"
"TAc4nm5HHUFL8gCN8Hknk4AIsLU2LDbUwIfV1WG+oirerqwGcyKB8fJGODenJc5MI8M3pQlO"
"0fr45MY4Pb2ZIMCaQTUFAbbS3zvGNcL+ac1wmIwgl4Db1P4Z7+mLh2QArS7SQN8lcpLp9L8/"
"hPzKSCLsOIS+mobwd3MQ9n4eQt/NR6jZPIS8nYMQ+vu7+SJEWfEhcJ4XuA2prjuR8nUrmeF1"
"iLbbiDCrLQj6tAMBlocQ6fIAWfHuoqYXEuCFmQR6ahAZPRtkhBqROhwmwqxFvNMSxH5ZSOoy"
"A6FvRyLwGfmmh0SAW+2IAE0l57N1YH2ossL1mDYOT9H4xriV1eRWXhBA43cRoM2PawK1eepX"
"HYMjPcnSL0FB8Fw54laqCcAKsJsIcEhNgONqAlwFUu4CqbeBdGN6z0GKY6QMryGRMkjKTPz9"
"UlJcQD88mOqeOWXIeXx/txLeRiOIBB3hqN+YpK0udQE1YbWnOqx21CTga/1QgI9UBt6T7L9Z"
"Xh2vl1aF6aIqeL2sEowW1cMxqutHxzfEIQL4wKgG2DucOoJRDbF5aF2sHszloA42jayL7VQC"
"dlEJ2EMqcGhWKxis/gVX1/4Cw0298P5EH7hd7YVvV/pS+6lqPb3uj4T/4/EIeUl+5j15G8r8"
"ZFK1dKeVyPi2BunfCDDbFQh6MxeOd8bj3dnBeHSwD25t6w7DDT1wbVN/PNKfAZtHRxHsRH1+"
"gp9w9Rlhr4QRTPLaj0S39QT8ajKRmym20d8bEOdIxPo8hUhHpegVEfIRlwAVAVzOkQIcqSL3"
"OKGNtcM0XjJuWmX4Njb/EgF0uIWotmZhm8vIXkqt4BwVAaLXS4hn+Sdw44+oCXBSlAAkXSIC"
"3CQC3CMVMBXgI5LUIob8Qjz9nXyFnn9OZHCCVBQBqTj37+igUgmpuAhFWZHIirKnATFBpPUx"
"BJiuovIwnpSgB5GhkfAAnzYTITZUh+XqqrBYXgXmy6rAclVlPF9eG/qTGuPYhAY4OK4B9lG2"
"7xxWB3tH1sfW4XWxdkgtAf5mfn6CSgG4DOjPaQ0DNoAUNzf2xNeLvRBm1Bsh9/oj/OFgRDwd"
"ju9PR5F5HYPAp+Phem8s7G6OxdtzI2G0dwBOr+qOrZNbYF7v6hjfRgdDm2hgWGMZxraSYUEP"
"PWwb0wRnVpBZPTMDzs82INRqN6K/bEWUDZUQ61mIsZ9Hbd1KAnwjBYHvuZ1aya3UVlJJcVxM"
"ZnP6DwIEmvaE7z1SzWvNJPerdWF3sorc64wOxnfRuMy4EQF0/hABSkuAnq42/89XlSYMb7QL"
"aUupFZyjRCwRIGYzEWAfAU6AJp5UxQ8CXCYC3AHSiADpT6lboBIRzaXiBMUpei+9J/kCvU7v"
"yySVyH0BFNgSGUgd+GITZQqBn/8PKqHyEqorfHLTYuD05DCMd43G2XldcGBqU+wcVxs7R1TG"
"rqEVcHhkBewfWRGL+1TDIop5vaphQU9ad6uKuRS8ntW1Cub1rI4FvWtg6YDaWDakHlYMrY+V"
"wxpi+bDGFI2wfHgTHJ7VGMfnNcG2CQ2xksiycFAdTOpeCwNbV0HXhrpoXrkcapfRQGUaTm0K"
"GjCQ7qIWRZvyMgxoIMPsblrYObE6bmxojbenesLp1iD4EpGCX6nqecjb0Qj/OBXRNgupjSQD"
"6biSvMMqJDqvJZO4nbzCdiLAOqEA0dY/EeBZT/g96ACvOy0kr1v18c2gmtLjnA56NdfYxbgR"
"Acr9UQII49CieVNxVrBdy6rkbpagJHxeCWJWQMh/wn6Kw6rsTzytAjaR678hEYCATTNWESBm"
"DxGAO4ZDKjVIpDKRep1eo/dkGgE5jEik0QAAIABJREFUj4A8IkHhO54JCyhtAPlnSAVWKM61"
"E6eblbl+UOZHQVmYQixQIC8jFY7Pr+DqpqnYPK43JvRsij6tqqJD/bJoXlWGBroy1NWWobaW"
"DDU1ZKhKP7UyrStR6GlqoFIZGSqWpaB1JXVUoNfKq0Eso75wRPYbgjIF5JTRQFsDnWuUw+gW"
"5bG4dyXsmVANV5fWhenuZrClVtb9Vnf4P+xL5m0wgkyHIODpUMpgAv8NdULmUxFuMQORn2cT"
"wPNJBZYQ2OQhiABJnttUCuC8hsixgLzFNISZj0HQy4GCAP4mHeBj1AKet+vD7Xq1EseTOmhY"
"TbaAcWvYoF4Z2R80geJDHTq0ZyXQq1FNZ1SG3/wcxCyi+r9CQhxJenxp/T+qUgA2f0lk/lJu"
"URCwaSaqYPBjSC1iiSxx+ioCpBgQAW6oCUAkyTcjAliALz+DwhooekcG8jlKsk2gSDeCnAhV"
"lHAN+bGGFDeRHXENMS5H4PlqFT5emYF7B0bgJLVuG0ny5w6sRhKoh35NdNC+uhaaVNBEHcrQ"
"Kmqgyv0TcBnEshQ66qhIJKlSVgM1dDTRoGIZtKleFp1rl0XvxloY1VoHM7tUwNJ+utg6uCL2"
"DdXDhWmVYbysBsy214fdkcb4dro5XM+SmT3HDp3atGtd4HqzO9xu94LH/X7weTSYPASR4Nkw"
"BL8cRSZyAinANGolZxPA8xBtu4jAXkbGj1TAbSOS3KibcFpBCjEHUZ+mkEcajcDnA2gb3eFH"
"BPAzbgnPu/Ul7zvV8OGATk5FbdkoAl6vVcuWGjL1Tcl+z7yAH1PDBg0eLKtQXoc7gW6BNjOj"
"kbwcyogVxYjfDClupyQ6AG7/mADJBGoyZXUqgZr6gOr8U1UpiNqiIkDMAVUZSDxHz5NRTKfX"
"Mo1VBMh7RQQwJwJYqQnwkTzCO5TkmEFJfkGeYkIEuIP8GEPkRpxDdugRZAcfRG7wHuQF7EC+"
"/w5kuVG2UIbEWM0kiZwIn8ej8O32INga9MKns93xTr8L3hzsiHvrW+HG0iYwnF8fBrPr4soc"
"inn1cWVuXdyjjDVaXAcPFtfCg4XVYbK4Op4uqYZXS1Wt5ce11WCzuQbsttTCxxXV8H5JVXyg"
"9Ye1NWCxuQ4sdjbAJ/Imnw80xefDzWFNHYvdqbb4erkT3PggF899NOkP34cD4fd4MCnACCLA"
"GOogJiKMCBDxkVTAkkBmAtgvRcLX1WSK14lSEEuqEGU5ExEfJuG72Sj67AACvxsTQAp42Ape"
"DxoWBz+shodbdaIZLz3dCrp9+/WTqQ7oaPwxAgwZOkxWtUolJkDLT4/GuyJjHYq+r1AgYYuK"
"AHHsA8gEJnFdJ1CTOfMfEgEo8zNfqjqCyC2qMhCzX00ALgGc/feBLJJ/ynTkvyUCfCACkPwr"
"KIosqH00R0nuOyhpO/LUhyhKuoeC+LvIi76GnHC+ulYfqV57kexKDvnbJuq7l5N88qRTktP3"
"48TE04jXVFtNhyLk4QCEGPeDP2Wg//Vu8LnUAR4nW8HtaHM4H2oGlyMt4Li/Kex2NoLd9oYE"
"cj1Yb6mLzwTqx7U18WZZVbwig/l+bXW8INAfTKUuY4IeHkyphMdzqsB0aXW8XVsb5lvq4zO1"
"qPZHmsHhREs4nmkDR77NDZ/a5kvc+FrHe33h/WCAUICg50SAV2MR/HoclYEpiLCYSS6fFMBu"
"MeK+LBcEiP9GwdPpbReSQsyg1nM8Ql+PIPkfILoAJkDg41bwftxIEfG8Os4v0XFlvKpVraQ7"
"YMCgHwT4I/cH0JgydRr5gMbcCta7fXaoGXK3oTBsvRyJ24kAuyXRBbAHSCJTl0KgphCo6U9U"
"tT+TQE2gbI/eQfJ/UFUC2ASySUyjMpFJJMl6RgQgouRT/S+0JPDtyQNQFFkSAT4SAcyhzHoL"
"RdozIoAx8pkAMTfEBaeZIaeQFXAEmT57kOFBRokHi6edfaZM+jAR31+PRdCzEVQjB1GrpDq4"
"5GrQHU7nOuPL8bawO9wK1nuawnJHY3za3hgftzbCh80NYb6uHj6sq0NRG+/W1MS7lTUEAcxW"
"Unu5pDIeTtGDyYSKeDSpIh4TAZ7PpeepBX23jglQD592N4LN4WawO94CDkSAL2fbCQVwJeJ5"
"8L0P7vaB1z3q4akMBDwdhqAXowUJQt9OpDIwXZQA9gBcAtgHsBmMc1hK7n8uIi2mqwhAxpFL"
"AHuAwGedpJDnreH1uJE84mlV7JxSnq8ErteiWaMKEyaKewRp/O4bRKinh2tMnzFL1rmTmCNQ"
"ffvqbteQuxOF4dvkSD4AKf6A9MMAJl9WGT/OfAY/nSQ9gyKWTF8smz/uAE6qCMFKkU4dQiYp"
"RTZlfx7V/4JPBDpnvyMR4IsoBb8S4A35gOcoSn5IBLgnrjTik0xZoeeRGaCPdO99SHUjk/Rl"
"JeJs56tnHpOkvqGsesHt2hD4U931YxIYdoP75V/gdr4Tvp1sB8dDLWG/lzJ/TxNY72qCzzsa"
"wXILyfiGurBYX5ukvRYRgLJ7eVU8nqmH+xMq4P54XRiNpr/H6MF4UiU8mV0Fz6lUvF1VCx+2"
"qRTA7igpwOlWcDxH8n+xA5yvdobL9a5UBnqQCvSCl1Ff+BgPVJNguCCBIMCHaT8UgEtAHJPA"
"iboC+8Uk/3OoRJABNBsvDgSFvCEz+aIXRWcpxLQ1PE0ayr8bV8Xs/uWvMV6dO7bVmTxlmsDx"
"N08PLyVAx44dxQfnzV8gGzpkAN+8sPLcyW0PIGsHiiJ3KpB8CFLCYUll/jj7yfylUk1PJUlP"
"p6zOfK8ig6j76vYwkd6XxD6BlCKdPELmYyIATzim2l9A2V/EBvArEcCJCGBHXcBnlORZqBQg"
"/QXkyY9RkPBATYCrRIBzyKQykO6zH2nu25HktIYUYBEpwCxRJ8Pe0EDRwAY9Hka9cn943+oF"
"9yvd4HKhC5xJBZxOtIcDqYDd/uawISWw2k11e2djWG5rJAjwgST9PSmA2TLyApT1d0frEPAV"
"cGdEBRiNIvDH6+EhlYKnVAJeLCECrFERwJIIYMsl4BSVADKBX6ncOPP1DXyK+4aaAKQATABf"
"UqeAJ8Mom0dRK6hSgEhLKmPW5GVsiQRcChx5TgWfbJpHBOFb6owTHiDk7WCEvO5NZaSzFPSE"
"PIBxQ4XfjcoY3qk83yeg8tDBA7RnzZ4rcOTbzf4RAog7fE6eNIFbwYo9OtddgvgtKInbW4JE"
"yupEyu4kdUanljp/ApWyFZkf6XVqB2OPqo4OJl5S+QEGn41hulr+s18TAaj2E9goIulXuEDc"
"VUz+hQhgQwT4DEXWO8jTXpICPCEFIALE8qQKQ2SFnFMpgNdupJECJH1dj3jKmBjreZQpU2ig"
"iAAvqb5yGXgwED53+sLDsDtcLnaG81k+zdxRkODLkdYqEuxrDisuCUyATfXwcUMdIkAtAfLd"
"MeVxe4QObg2lNcXdEbowmUglYHplPJtXBS9/IoDV/sawZQU41QpOF9pRb94JztQFuFwjD0AK"
"4EFK5H2/P3wIfL+H3A0MFQRQKcB00QlEfp4r2kE2fvE8oZY9gM0Cem06wt79qgAhb/owARDw"
"iDzAg4YlzucroU197SWM1xTCbdbsOQLHP0yABQsWyhYumC/+A+fGDaqMyw5an4/kw5T9RyUk"
"n1W1fimGKuefdl9FgAy1/MdRaUhQA59EwCffVZPEWNUhZFHtJ5ePfJL/Qsr4IidIcjdq892I"
"APR3ob0ggZRPSpDzAcUZr4kEfBOFu8iNuo6s7+QDAk9SCVArABPAfjkRYL7KLL2ndun1eIQ8"
"H40AGmhWAY/rveBGKuBKKuByrgu1a53gdJyU4FAr2DIBSAUstzYkAtQXHuDxjCok+RVxb1wF"
"3B6pg9vDyuPO8Aq4R/JvMlFPEKBUAd5RybDY1QDWh5rAjm9rd4YJwB1AR6EAbALd1ATgEuB9"
"f8APBQhiBXhDraD5NFUXYEVeRnQCSxDH91QiH8AmMIrvq/Rx0t8oQDARwP9RKyngcSNYHa+Y"
"X6dKuXGM16KFCzRnz/mDBCi9RQzfLHrjxk3ioGDZsmV6BtsviUPWKSjjThYj9RKk5CsSUq4T"
"Ae6qev5UIkCmmQrw2OOq4wLJrA5U81MJ+LRHaoNI4GeTSczlG0dS7S+g2l/sTrvgR+EPSJ4o"
"KeQZsaqJJgVJZtQBPCPwH4prDPKibyE77Aoyg88hw+8I0jx2IZ1UIMV5/f9X3HeARZUlUTfZ"
"POaIGbNiTiiKOQfMjDmOWcecE2JCQAVMCAjmnBMGQEUFBbOY8xjGnEDSO/+p+147rrv777+7"
"M/vzfddusPvRvDp16lTde+uqBlRPGT8f8yY+ZFp1b08b3NpK0URPuxJcD3Gra1ML1MAFCsIY"
"nyqI9qyI03PLInIGReGkYjhCBjg8yh5b3YT6f0JIGzIAqV9YILCZ0L8OgFARgsz/t/aQDIEA"
"GJGH9M8MYlYRRHoIAErhjMEAZ2Vdgx+1x8pqDAG19BBAVhIGUAAwUsFvADjeC48jRAj2UyJQ"
"ACDh4PEJNwpBvQ5we28DYQAKQEemlSVT72wvhM0TMz+1srSS7uWZpJWfuVXsv60BzACQHjMT"
"J04ySWNCflv6+JbOF/F5EZKeLEqRUq72wk/T6/5BhnG36yFAjP+bl258ZfhNOjvIo/z/e1L/"
"B+qEz8z7v5wk/Z/Tl5W9PauvM/xwlt4vDSYv8mNd5ojjOEc2CMOXZ5tUGPh4bzne3/TGu6vu"
"eBM3hXFyNGlzML3kFzw4Nhj3wwbi3uHevFmdcXN7K97oxrgS2hCxAXUR418LMX61EL2sJqKX"
"VsdZz0oMB+UZDkojcpoDdg8sQHGXk96dHaFtmfI1z6hAENRCjJ/RAEAmJQC39hQA5MT+UXmZ"
"ARTE8VlFETnPAacWliIDlMNZXwLAl2GHDBCzQgeAHgJEBDYwvJ+0vredAsD9w/RyKQZJWViF"
"AAKAqeBT6oDHzHIehnVQAFAicEctAqAiLm8olfJwT2H4/pLxIkN+aVkJPGXKVNXm7z8CwHeN"
"Ii3meswz5c2TU1LBAoFezQ8hyQuJjz2T8MaXDOCvKfGnqn4EwNvdOu0/kezAlwwgAKDaf02v"
"ZyqnHt8SJO/JEh/p/Z+P0/sp/BLPAmn3+BE+0PvfQhpRJCVcw+/3j+PakTU4tnwyVvVsQoT/"
"jGTqi08PgzlWEgAMA9eoA+Km4usdd6Q9WYSEux74wPTw/TV3tTv39fmJFIjD8IQ39cG+drjP"
"7ODedmqDjY1xNdgFF1eJNqiJs4sr4+R8R+wf7YBdvxTG3iGFsK13XqzvlB3BLTMTABl1IDD+"
"B7ekAGQKuKV7Nmzvk52vz4UDo/MjTFLAmcWoAZhdzC9NAJSn8fX4f44ZSPRyAwAhpP/19XFt"
"U0MdAGSpO/vbM767Ugd0JnjdVDooXv+bCgFGLSCCf8Ph9ioExG93ZgZRgxmAIy5tKJX0aGdB"
"TOmU6ZDYKXfOrBnmL1hkateurSoD/tvNos1t4oggiwULF0ktQFaW5pw8olYAkpYi8YlvEt6t"
"JgBWaSr2v6GR3+7Q4/zDiYz/C3QgvCQ7/B5iMMAmHQQCkg9U/h/DlPenfTylqD/+0AocmNQP"
"W/u1gn+90vCpUggeRTJgckYTJmS0xmh+3AWViiLpXSQZQJZGB+HD7WV4fZkGp7GDf20Kz85V"
"sHVaa+zz7o0w30GIWDMcp0OG4VTwIJzbMABRa7sh3L8FwrxccHSxM05418VJv3qI8nXGpaD6"
"iPOtyVBQAWETy2D30GLYMaAQtvTMi9AO2ej1mVX6F8wR0lroP4vu/f1zYveQPDhA3XBkEtPJ"
"GQ4MAWUYAigyfZhx+FXlqEYAVEfMcmYBq5mOBulZwDWpA+ygN1Ow3tknAGjPDEbmBLrrIlCy"
"AAHAuSFGLaAbtU0bY0GIMxmkmnZzUwVcXFcy6d6GAujpkj5A7FSssH16z8XeprZt2vx3AHB1"
"bW/h47PUVLNGFZUK9uhYbg4Sl0pZNhnvQ6C9DtHwZqNu/DdbafxJ+pAQ8EzmBqgPXq7RNYBU"
"CIX+FQBI/5+Oqdif9onxH/G4vGMZwueORlyAO47PHoJlxbJgub0Jq0pYY1Xp9FhaxAL+NQvi"
"0/NI1T7t0+P1+MAw8ObaInr8fBxf0Q8Bw1pheNkCaMs/zS29JTrZmdApgwntOVyzWKBFOgt0"
"K5wNfcrkQSf7zGic2RpOFia0ym6D3uWyYVj13PDu5oB9k6vgzPxqODS2NLb1L4zN3QmC9tkY"
"Dn5Suf96aoNNXbJiy8/ZsaNfbmYA+XB4bGEcn1YCERSVkYsq4eTiqgRADZzxq80UsA5iVskj"
"RegqAiCgthKBkgHES61iZ0t9UogAuGcGAEOA1AGkEighQETg/cOdcGc32Wt7I4a0OgoANzaU"
"R2xgieTrq/OhWaX00jjyp2pVHO2W+fqbWrVqaT5g698rBH0HAJOPzxJTPWcnOTwoc+2q+Qbh"
"jRdSfw9NxbvNal5fzfm/369P9Dwcx9x/hl4AEg3w3E9nATVHsF6vEUiGwNQOH5n6fWb8TzxH"
"DXABWuojfoSvSPn6Rk35ngvxwsIsJgSWsIV/ARP88nOUz4G3j08yLQzDJ2GBewF4F78Eby/P"
"w9cHPmohypfHGzG9bgkMyW7C6IK2GJzThGH2tuiRzoSQkW3xMtaTWcJg3vQu9P7GCBpeE90K"
"Egy8HS3tLFDPko85bTHexR4HZ1anUStgS297bHTLiw1dcmJjl+zY3C07jZ+DDJALuwflx57h"
"hbBnZBEcmFASJ9wrMfen0AyQxtfNKPaakfYb0fAu1B/1cH6F/B+zgGDJAlxwg2mqFIJu7aJn"
"72mnp4IEgBjcDAA1EURGuHfQVTXVvr7JBVfX1VYrgq6uLYcLK4unxnjnQbmCtoPETnWdalkv"
"W+ZHALQy/VcAkHbjS5cuM3Xo0F6lgkUL/dTuy0OPr3jPOP6OnvxexkF9OdijUXq5Vyp/ogFU"
"GBAW8NdZQApDr7fqbPF+j6EBwskCUvi5qFrLJX+8iIQ3sdQDd/Eo9ggW5zJhfSlLrClK4zlY"
"YHVxG7y6cQSpH08zBMju2kAdAFcW4PdYD9w7QS3wZB18B7YCEyD8am+HvplM+CWvDdxsTYgM"
"nKRatV5eL4s56EXrnfFwf1ucXdUMgyvnRsfMJvTKbQVXvqeptQltc9li7eAKODZFQFAQW3vn"
"x6buebClVx7m/vmwo38B7BzEtHF8CZyd54hoL1L9sro4tawxQ0xjHPdqhpP+bXF1S2fG+9aI"
"Xd2QxmeoCaijWuBcFhZY3xDXt5DSd7TEHVUL6KxE4GOhfwEAQ4AIwIdHf8Zd6oSbW5uolrpX"
"QmrhcnBlXAooi7gVMvGU82v+7DbSHTqTa/t2lr6+fwIApNest7ePqWfPHioVtLUxOd2LnvQC"
"Xw8g9fXONHxini5rAB4OptEn6RM+CgQe+hAQPF+qM8DvoboIFBZ4Txb4eEDPAgQAicz9UyUF"
"vI+0VBGDz/H6UTR8i6XD+uI0PgGwroQlVpIJnkbvgpZ4gQCQFmtBBICPAsCHG9KLZwFSX2zC"
"6mHt8DMNOKGwLQb9RAYoYItu/P7A4kEEwAxSbzNcDaFHkpbD5zrilEdlnPZvhA75MqIDNcfP"
"2SzRI6cFOhEQTdNZYcOoSjhKEOwcVAS7Bhem6CuEHQML4cCIYoicXha7x5XFnBb50bdcVnTJ"
"nxHtM1mhO6/Ri2Gnfy4bDC+dDWGezZivt6K31sfF1c5kAyfVCe3y2vqkclkbQDG4szV1QAfc"
"O9TFKAT1wxMa/4lMBDE7uMMwcXNzY72ncnBNXA6sxGymVNol36LYMi7HCxsrCyexkxTwli5d"
"+u3AiP8YAHJmkBwBM3ToUFkhLKlg2ai9g64i5SBp+HAKXnlBezhAw2NZ8jVOB8DT2cYcgLse"
"FqT+L3WBV2uNNHCrDgBVBzhCAFAEfo2GliTrBeORlnJLZQSfP9zC6kpU4YVN2EDv31jSEqsY"
"Bu5H8BpfL+HjQ9knxxBwYzEBMA9vry7Ab+fckfJsPdZNdkM3UvkkAuAXAmCkvQ6A3fP74nXs"
"NN70BgoA55ZUw4np5XBgXGnE+Tlh9ZAqaGxFFshlCVfqhp65rNCRj70dsiKSovHA2LI4+Gsp"
"7B3hgOOTy2D7yFIYUj0HGmSxxuBqebGkZxlsm+QEb7dy6C7AY/gZnodA4DUnVS1AL+/CEEAG"
"EAAQfFKTuBREbw6tT0XfhLG9BQVeW9xlOii1fxGBT072Zf5P+j/QAbeksrmpEVmjHt9XU7u0"
"uiLO+pRMuepXFCt+yXZV7GPLlF2OmfHx8VGntf1HAPj+vAA5lWL8+Imm/PnzCAAKrvPvSrc9"
"iMSHU5LxtBe0R0M1PBpO44835v1nGgCYY8wDeBkLRYKNWsEWoxC01wBAuKoDIOkSQACodDDl"
"LlKSnyCkdnFsLGjC5hIW2FbGBgG8oTe3kVHSrutbpAQA1wmAy3Px7ooH1fIsJP8Wgp3zBqAH"
"b/rkIrYYmpWhoKAOgM1Tu+H385MZf13ofc44Nq0sDowpgbDJZRE+uxJOLXVBB/uMcBUWyEEG"
"YCjoKyGBYjJoaDWc9a6DPQRB5JzK8O9eHI1z2KIyb2PgkEp4wHTu0poGuB7ahF7shkHlc+Hn"
"9ARBXmsMzcHHIlkQE+SKi4ENcGGFAKAOh3REqUsAuKhQcIOp6S2mqHf2tseDQ51V+fdxZG8+"
"dsd9guK2TB0LAxAAF9fU0C6urIAz3iWT41cUxfQuWY+JffLmzpFxwoRJJk/PRRb/0XkBPx4a"
"JcfCTJs2g6lgEdU3aM6YWmvxYSASb7sm4beB0B4M1NROITMAJAQ8nq3rALUG0MdIB4MMIbhV"
"B8BHyQSYCiac+A4AN8ELkuLJAniNHZ3qYn1eEzbR+zeXtsEaCruLq2arrEG2U316uMYAgAdZ"
"wF2tvU9+GoqDfqPQ28aE6YV1AIwiA3QlINaN64BX56dQmDVU28oO0viHxpZUADhMir9Iwwyr"
"kw9NrHTv78YQMCCPFTpTP8xqUhTR/g1xbFZV7BxfCTWtLdE0gwVaESzDa+dFxOLaVP51EOnt"
"jJjA1hjkmBddCJxh+azRl68Zyqwmbl1Hxv8GNHw9xDIziFvthMsGA1ylILxOENzc2lwVhe5T"
"DD486kYA9FIAEEDc2d1aTW5JI624gOrapVWOiPIqmXRzZREMaJp5rdinWBH79NOmz6TjLrD4"
"r4+M0c8LmGsxx93D5FSrqkoF+7bNOQ/PmyPxbne1WVR7MOhvGUDm/hUAZAp40Xca4HsG2Gmk"
"gkcMAJwBkgmAZAIAD1TzSSkK7enTFsE5RAhaI7SkNVYSAGe8+Xs0AYA0WAxhCPAiANx1AES7"
"UwSuxfE1E9CHqn9qIRsM+Q4AgcNbMwRMZwrWCCdlK9n4UqT0EjhKABycWA4XlztjrmtJNGJq"
"2I+GdyMA+pEBuvJao6vlQ5R/M5zzqo0pTYugEUHRI78tOpDq69pYYO+c2jjvL8vGG+FZeF/0"
"LZ8Hbnzf0Hw26EMmGVcuJ+J390NcYCN6bwMav65qhXcpuB5DUj0FgBubGpPhWqp0UFYHKQBE"
"9FIhQAFgTxvEb2qoABC7sqp2SRjAp2TSdf/CaFU98zyxTy2m7GKv+fPmWXx/XsB/BICuXbua"
"5nl4mOZ6zDc1adxA7xtULesw3G+BlAduqXjSjxpgEEUgAfBoLMdkPQ00A0BNBvn+rQhUaeBu"
"XQR+YiqYIAtAztL4l6ElxyshKD2HBQBh4/tgJQ0YSgAEl7CGXzYTjk3owf+7pTpmfH6y0cgC"
"5qkw8CJmLhIeBePMxhnox9g9sSDpl+8ZTQD8TEZYPbg1tcI8xCx3QaRHNXp+GRwaV1IHwKTy"
"BEB9rPqlEloQLAMJgB5MQ/uSCboIlVfIiXMBbRHNMLCgQwnU5u3rnNEK9fk41rkQRRnVeShV"
"v29DzGjtgE5MJXsTHIMJoAEEwBTqmTsHh9LgDBVBkg04q/gvIlAY4BqFYLxZCO7vwFS1K4Vg"
"d6UBnkT0UrOEd/e2ZQhohCtr6wgAELe8AnVMydQLXgVRpXj6YWKfxo1cbDxorwXz5ysN928D"
"QB6/DwHqnED3uaauXTqpFcIlCqXvmHSlQQqe9KTh+9BhB3AM0df+CQDMWcBvnno5+KWxUsjs"
"/W936ZVAof/P9P7EKFUHQNKV7wAgGcF7nPaZAj/exHUEwBoHK/iSAfYNaE0NcEt1yvj8dAve"
"31qOd9fIAlfn48X5ufhybzUu7l2AAfTeqfZWGMn3jCnIdFAA0K8J3vC1Z7zr4jQp+/iMCjgy"
"qTSOTS3HEODIENAQgSOrozW9+xeKt54EwEAasCfBNLZKPlwM7YjweaR6LxesHFAZHm1KY9OE"
"uhRnHXDCpz4mNrZH059sMbZRefSxz4A+/AwjyACD+P45dYri3tFROgDWNlYAuLhG2uKK9zfA"
"DaaCt3a0ope3ZxbQWYlA0QBmAEgaeO+Aq5rYuhLshLiV1RC7vII6Qu/kPPuUgrnspPCfqUvn"
"jlZiLznY678OAW5ubt8OJOzTp7dKBTOlt6r36HidV3jeA6n3eqfhkegAAcBofe3f0zk69T/z"
"/mM20DwhpNYKUPzJ8XFMIdVEkMwDMANAsgBAqP8ekj9fUQCIWbMIPoyfoYz/q4tbYRlF4Lbu"
"DZCaFE/v36u6a0vPfTl/5911T7yMnY/Pd1Yh/thSDMlugRn2FhjL90wsZIehjMdrejfG89gF"
"OEexd25ZfZyY7YijzALCZ1VE2IzKuLymKdZQ7LUhAwzKSwbILDUEPvK97o0dcCmkPU7Mr0Ng"
"NsDFoBZ4crg7ohnvZ7YpjkbpLdGtaE5E+HWk4Uajd9Gf0J/vH1fABkPJIAsblsKD4yMZAprR"
"45shdjU1wConFQLUmgDx/l3i/R1xn97/MOxnXqeXDgBZEXTUTdUBpBB0lWngpdXVEONbnilg"
"KeyenO9VBjsrOaY2U58+fb5GJuFRAAAgAElEQVQdICki/t8qBad96xKmp4EtWrQwjRkzxjRy"
"5EhT7959eCELyQQqxGyuGo/fuyP5bu8UPB5EAAzT9NW/U/Q00DwXoErBgcaE0CZ9tlBWC31k"
"IvE5ggA4rVcCk+KMEHCd8f2OAYDfcf1AMLxI4avF+4tYwis31Xjjskj+dEX11Pn8dLtqtPT+"
"5nKCYAl+v7QYn26vwp3TyzEifzrMyMf0i++ZWdgGYwmk1V2c8PjUDJxf1QIxKxohcn5VgqAi"
"IuZWwdE50q20BZb1qqQAIOLv5+9EYPAwJyr4FghjrD+3rCFiVrbEgk5l0JIe78JbOb5WEdw/"
"PBT39nXFCT9XdMuVDoMYvsblt8ZIXme+iwNu7x9A47WiCG1C76+na4AgZ2NRCMXfd3UAFf8F"
"ALIiiMNcCLq9o5lkAdrlwOoEcvmUK8tKImhE3nixC7O9jH369DWNGDHCNG7cOFPjxo3/vTTw"
"nx0fbz7xOp2tOtG78KZFZSLwpjszgV7Jarfwo5GaXgcwr/834r/y/u8mg97sMABwnABg7P8i"
"RaBoSDt6CQEQAJABUlUoeIkHMQewgBTuW8wS3oUIAGYE/tUL4vPvMUh8cUgHwP1QhoFVCgDS"
"hOHj7UA8vrAW45l2zeDrBQQeha0xmaHEt2UFPAifgovBrrgQ0AynvWohkmLw1OJaOOFRkzG8"
"NaY3d1AA6JvbEl0ZAtx+ErGXEaf8WuLkImdELKyDU0saYXCVPGhmEo1gid7UCadX98C1rV0Q"
"HdAaF7f0Rfc8GTGU751A/TGIKehS14p4enoUU80GNGAzxK2Rxaq6Dri6XqaFm39XCOqsDG6e"
"DRQAyJIwMwNc31hfuxpcQ6abk+P9S8L955wRYhdba+WgshXg28HT/9Hx8WYAyEoSnUL0Pebp"
"7Sz1vkGjimzEGzck3O7NVHAIATCKmYC5EGSEALUELNAoAW/+I/5L6fjjCd37E0j/iRf0EJB0"
"mWngDXXmQOK783x+G79dPQrPAlZYXsQEr8JWWJzfBJ+KufDuySkkvTmOj4934MM9HQDvri9V"
"3Tjfx6/BixtbMKNMLsym988uQO/je6eTSXyblsPDk7NweV1nxAW1wpkluhaQx1Ne9ajgW6Bn"
"6exoR/XeLYsFetCwLS1NWNG/GlV7UxyYStr1b4ShVfMq449imtmD9D6mQl7cOzwS5wPb4sWp"
"Idg7vxXcKPxG57bASGqJEfzdM6vnwbgaBckk1XFnR2vV4+hKiAvZwEWvBJo1wF5X3A/rZswG"
"9sbTqIH6XICsCVQAaErBWF+7FlITZ5aWT7q1shSGtsy6UexiZ2ORXg4dF4c1TqL/7wDwdwxg"
"ZympYNa+7XJ74nVXpoL9kvDUYAAFgCn69q/fviv+fFsQsvkPAHwK170/gYb+GqfXAJKv6oUg"
"vENq6u98/IiX9y9iob01AgiAJTSkZ34xph2eX9mneuh+ebYbXx5vwIdbK9U5PO/il+PjHYaE"
"R/vgUakg5hAAHgUtMI8AmEo69mlUGo/PzMPVjW4qnkf7N8D5lQ0R6VWf8bgpds9whjPFYgd6"
"fo/c1mjFWzTVpSjiglvj4NQqOO1ZG1vH10BLxvtfqC368HUDskrGYIfwFT1J8X0RPLw2+hfJ"
"iiE5bPBrLhNGMo0dkskSvUSE9qlOD+/O+O+iqpGXQyQDaEAGaIjrm6QS2FIHAOlfbRGjCHx6"
"ur/OABSFkgXoDOCiXQuVHcsVkm4HlEbr6pk8xS4EgN2fygDfAGCgydbGQu8bVCPLaDzugOR7"
"fVP0jiGjNTwxtoB9Y4DluvoXAKjl4sIAFIDvmft/ovj7wtifSON/pecn0fhJ16kBbiE6eAEu"
"bfTEo3PbsWNwZ3jTe0LKpcPyYmSCcpkwj7R+J5KaIikGr6+H4M3NILyT5ks3/NVRbS9i/fHm"
"zk4sciqBmdkEAJZwpxicTEPNpwfeOzETVzZ2p1Fdcc63kRJ00X5NSMWt0adcLrSSEnAeGzU7"
"OKFOIVygVx+nPjg4yRGn5ldHyNBKanp5eD4r9MtpiSH5rAkGCwzIZ4feeWzRv1AWxG0cAO8O"
"zASoHcYVycAMoBAifBnXw3qT+qUO4EI9oTOAAODaxkZkgGaKAcwhQGr/+j7BPooJHobpaeAt"
"MsD1TS7a1dBaTGcdU64uL4VqDulGm9RmUGUf826wPw8AZjqxtrJQqaCDvV1X7UarNO1hb4q/"
"gTT8KI4J+k5gxQCSBSwzqn+hRgVwmx7/P8g0sOH9iaT+rzQ+Y76WxAxAu4dru1cifM5wbO3e"
"FEFV82Nt2UzwzcMQQCG1JIc15vOmrnN1wueXx6F95rU+7aXXryb9+6oaQPLzzUhmiFnoUhaz"
"6IEeRWwxt5AVJtET5zjmpQh0x82dvXF9czfc2NiBoz3OrWyFsbXt0Ype2jmDBdpS9c9vX4JC"
"rxmOzaqCQ+PL4sC4UgibWh5H5tREzwIZVGGpe0YLuPG1PdNboC/j/eI2pXBzd19c29wRsWvb"
"I3xpG5wL7II7B/oifntHnPOXNYkuZJs6zCIEAPV1799izAPIlPDutvq6ADUf0A2PI3rqhaDD"
"XQiOdhSK0qamIXWEzCVU1KKXlEizz2nd1aTawZhUP6Dv7P/nAsCglkxZMlg0fH6y0Vs87YO0"
"+wM0aRilfQPA7B9mAY1JIKH/bwCQ+M/Ynyjef0MBQFUBU2/z179VRSDJAtJSH+HdozOM25uZ"
"O89D+NQ+2NOrIQKq5YevM9VvnybYNcNNHeD8+V4Aru6dijOBv2LDyHYYxdg8I5cFptHwUzkm"
"SzwmI2yb3BIXQnsgYmlr7JvdEJ5tHdAhs073/XNaYUpde+ydWR8XljfA4UnlcWBsKez7tRj2"
"jy2KQxNLMGOojINz6mB+i2IYVzU3pjkVgJ9beRxd3IJKvgvO+jXAGV8XxKxqSIpvzs/dlBmH"
"3s8wjp6vSsABBICaCZTtXY3URFA8ASDzALd3CQBc9QWihzuTBdzUUvcHB2VXUDvcEQBsa0jd"
"4KTdWFcVh+cWe5vBzqKh2MXib23/5wNAF4QW0jeo4qUdTnfwvDeS7/RLxZMR1AHjCASzCFys"
"A+DF93MARgbwIYxeyxRQFn1+pfJPMowvICAA5Ni5pA/n8fW9NKOOM3TBfcgJGKQZpPF7OZHs"
"92tbcWm7OyJX/src3h+JjwNxyLM3821HeDUsi2UNS8OzViEsqJIPc8rnxIRiWfBroYzM69Nh"
"mEMODC6WDYPyZcTggpkw16UQ1g6qikMeDZmXt8Y5ikIx/IFfHbB3ZGGOAgRBfhyaUASHpwgI"
"KuECjXpueWNcWNNcFXdi/J1xYl4VRC2phXN+tQkEikvf2qrL6fkAZ8QG1uVr6yBWTkIJcEJc"
"oL4oRIpAAgAJATIPIGFA7RHYJxNCHRUAHh1zU3MDeghopt3c0gCX1jml3tlcDRsmFr4j9qBO"
"y/Sj8f9UAJiFhZ2eChbbsaRSFF73ZSrYP1m2i2uPxms6A8zRq4CqEOSvt4sxrwt8u4cAMDTA"
"Nwa4RuMbLJAqcwF3VakXaTfU/8kZOUnSlPL1aSS+jEDCi6Oqt/7XV/ugfdwP7d0OhoBV6jze"
"L/f8kPTbWnx+Eop3d0KpD0Lw4nIA7hydiivbhzA298PFDb1wPqgLFXtnGqM9KdgVV9a1ZQbQ"
"BGe9nXB0uiM9vwzCJpbEvlG68feOyIP90otoUgEcmUYmmOKg2ODYjLI4Pqscjs4qi/C5FXBy"
"YUWOCkwrHanQK6uFoOf8q+HssqpkgBoEAQ0f5MTfS/peY14PoK8Mur6xMeJlSnhbC1UQkrr/"
"vf3t8OBoZ7Ur+N7+Dmoy6OaWJtrNzWSS4FrJD7ZUw6IB+aPEHv8oBfxLAGCkgnl9JpTchnf9"
"mAoOSlLbxR9P1NREkADg6XxjSZivUQ0MNFYNyzzAIQMAMboGUPn/jW8hQEu5qSqC2tdraqQl"
"XlGnZMlBiSkfT0NOxJBTNT8+3oK3t6SJki/eXvPG2ytyNrE7VfNUPDk1BU9PTVbTw4/Dx+P6"
"1p9xc1cvxtpuuBTqSu9rhfP+jXHGh3n9vBo4NrsKjs6oiLBpFXB8enmETS7FuF8UB8cXwsFx"
"BZTxD47PgyNT8+PotMI0ejEOBwKgBPVKKUR4lCYrlFI/C59TEicXlFFLwmVT6JmlFfWVwbIk"
"PLAWDUcABNRW5yLKuChACKqrg4DhQLGA7BaWquDe1rh/uKNignt726np4PhNjRQALgTVSnq0"
"tRp+7ZBLTgXJp6eA/wMAMBVUm0V/6VRgKd72RcLdIUl4NsYAwHR9EYjaFWReDrbC2BwSolcC"
"v6WBZ3QWkCxAAJBiaAAZAgKGBu1rvDokSY5Kk1Mzv74Ok8OUkfBcnwf4/Hg9PjH2v49fgvfX"
"ZavYQry/Ng+vLs4hGKap83rv7u/P2OzG1K8r4tZ2oPpvS7puijPe9XFqYW2cXFQTUYtr0XBV"
"cGIWAUCvPja9NJmABqahj9Dghyfb0/j0/qkFcXhqYRyZThDMLooTc4rqj+4cs+V5MbUrSLaF"
"nfIsLXm62hl0xrei2hso28Nld3AsDX9hRXU14mRNgByRRyaQ6eB4CQWyPGxnKxq9DQHQAQ8P"
"k/73CP031wGwqb4wQNJDAsDV6Sc/kxwL8z8AgMkIAZJrZm9RN9tUmQ9IejgiBc/GQ3syWdPb"
"wMw1JoKWGqVgY9+gzAaaS8HfA0BSwG8AuKOPlFvqdBIt6SYZ4DrDQJwCQNKbY+pI1YQXu/Dp"
"8UZ8vL9WHcD87oYvXsYuxIvzHvjtzEzl+Q/p+Y8jxtD73RAT6Iob27tTOHWiAVqqYs65pfUR"
"49uAhqqDA5MrMtUjC8ysSMNT0E0vS0OS2mXf4ALSu0cpHJ5enFTvgCivMkwby5HqHRAxvxj/"
"ryjpvwjC3TnmyLYwfWNolHdpnFsmO4Md1daw83IG0poaal/AhVV8ZEi4sLw6YvkoLHBVVgXJ"
"jODmpmqRqGxvF9EnDCAAEEa4ubWprAdQDHB5Y92Uu5uronbpDLOEAWysLTIYAPjLNID+MysL"
"aRyVu2ThdINxuzPSnoxIEwDo3ULcjWZQi40VwYHGnsC13xWCDv8BgESDAZQOiNeNn0YNkHJH"
"1QR0AOg6IEXOJXp7Qh2onPBijwLApwdr8e6W9N5dja/PQpkGBiHxiZxWuhRf7vvj9cXZpH03"
"rBvrgp657eDRsgSubuqIaNJ/9IqmGFoxJ3rYZ8Da4dVVODjr48TQQLHmX4fMUFXtHjru4Yij"
"HFHelXFsriPWDiiKNb0L46h7KRq+uDL8CffCZAAOPo+cXxxRniVxZokApTw9X9rDVKEQrIbY"
"INI+GUAE4LcQIEvEqQVkVZCsCIqXBaJb5Vg9MwA6MAR0wF2mh7d2tFCbXeMpAq9vddYuBVVG"
"oZw2UgMowhRQDogUa/81DGB8yVMJAQWzZbbs8Xt0m894Nhxpj8dq+o7hBXoLGPOmECkAyZbx"
"18ZycHMaqApBUgaOVev7FADMDGAsCVMM8PWG0gDqfCJhgLfhFH/H1F7BL0824d1taRsTgm1T"
"OmONmzOOLvkFQQN5Ew/OwRGvvgjz7oEnx4fjXFBXTKxdFF3SWWD7tIa4v7MLNoyvg/4lc6FX"
"TlsKQlcaqzHWj66KVX3KI2iQIy5S2QcNLIfQ0TWwomcFrBtSAaPLZcOGUdWxvGcZMkI5Gt9B"
"bQY9QQY4Id4/ryjDClnCuxSFXxl6vSONXpV0XV15f2xgTSUCZWvYpaA6OvUH66uDFQA2NVEA"
"uCn9Amjse/vaqh3BDw931kWg7CDaIe1hGmpy4EbE0vKfM6ezkKXgZWghOSzazgDBXwIA+Ud+"
"kJGpoAMfO17a0+g3vBqB5Idj0vBiFjTpFCb9f6RRlPQJVNvFd+qbQd7u06uAH5kCfj5rFILi"
"fmCAuwYA7qjCkPb1KlIpANX5RHIu4duT6jj1L8/3IOHZFryJX41UppeRfiMxlH/OnZMBcK9U"
"AguqkobXTkNn/uz0ip44tbIbQsc1wWSmhcNLZseVLd3h168alvWogvbWJsTv6IVF7UtgaIW8"
"OODRHC35viPzmmJQiewY75gbOybVx/65jTCmWGYMz2eDZR1I+x5VKRxLUDiKICT9zy2KyAXF"
"cdqzBON+abJMORq9InVHNcSFSGuYmqpDSFwQPV7a4oY4G4Y3tonLfMCmxmrEk+p1ADALCGMW"
"cKQz7stuZ+kltLsFrm1pmPZwnwu2zi71jHbobmVpUUXCAEcmw0Z/binYDAA+CP3/ZGNjKU2E"
"2h4JdrqJt8Px9cGvKfh9NrQX3prq/6OML56/7Y/y74djHKT+T1H0flJ/QpxRCbysG18xwF0j"
"BAj9X4eWKOo/1hCBfwBAdgZ9ebZVtVL9+nwbbuxfgBlZTGqX0ZZfmmN1swqQzaQjclji+IIu"
"uLhtCD3ZBceXdUJXOxNmNHRAmE97BA+prXYPXdvSA+E+LeHVuRKZoT6G57XGYY8WCFvYHO5O"
"+dA/qwVW9qiAQx6NENTXET//lI4hoDbCZ5cmAIrT+4sjUvoZLywha/To/aWZ9lVgvCcAgqsS"
"ANW/ASA28Lvt4aH6WgC9DtBUxf8bUhTapoeA+wdc8fColJC7qkWhd/e316T30bWtjVOe7HfB"
"qrHFb9IOna2tLWRHcGFaKRsfbf9KAKjOoensrGT7cGPPSeVO4N0QJNwbnaz6Brzw0lQPwNch"
"f1v7/0Cv/0jaZxqHz4bx6dlIvPJPRKCUhpkGEiBpXy4YDHBG7QtMeHlYnZCV+HIXPj5Yj+SX"
"OxG9YRrG8M+5e3w5Ars3xswCP+Hlna3oaWHCtpHNcHX3cCxwdcSLc2MwsWo+jHTIhWcnR8Gn"
"iyOa8n1xa7thVoviaGNrje0zm6CjSVYPVceCTuVwaEELzGtWHKt6VsGidqWwYUwNbPyVuf1S"
"J4SpbKEkwmZIxuDA+F8SUT4Uf77lFP3HBVZWIeBCYDWcX11NbxIlDCC7g0MNAGxo+EchSGoA"
"O1rpdQDm/A+kZcyxrqoS+PBIN2khoz3Y3xrXtjdJfnbQBeO65A+nHVra2VjW5mMx2ifnj2Hg"
"zwSApQGAHFScsmKkXrVymedpD5kJ3BuZgufTGAIWaXq7mCC9D4ACQBgBEEnPP6sb/wu9PoFe"
"T3EH5vnmiaC/TQNJ/7JEjABI/SJH051Fynvd+5PfhfH5IXx4tAXv7m9UJ3A9v7wWj06uxOMz"
"Abi8ex7OrR6PW8e8GLcbYc/M9jjs1QleHaqoQtBRr/Y0qiuu7+iNZd0rY2GLktg22QXbJtTB"
"XBp6+xQXhA6uim3ja/O9zggZUhnHPRtRxDXHKZ8GCPesh7N+9ZhF1KLar4SohXoj66iFZdWO"
"4FOeZaj+yykGOL+qEsOACMCqRm8AvUuY9AcQBrgk8V+qgebpYFUKboPbe/WNoqoSeKK7mgx6"
"JEvCDnXSHh5sy8/eJEXOWypbKP0CcUQK85p8dKCVcpn0k17+GgAIugyUFbe1tazLxw6r3Kuc"
"xcfR+HxnUhLeeSPt5XJNk00gatOoAOCYYXx6/Rcannk9Eml0Cjw11FzAd5XA1Hg1NaxRHGqJ"
"cep4utTPUepEbSSdRnyYD86um8bXyOlaB5D0ci8zgN1IfLYLSc/IDE+3IvH5TryM88Hzc9Px"
"OHIibu8fQk8aiRs7++HugYG4s38gLgR1JPW7Ma72ole2Y24uRRZXXJHzCVc1wYWVjZguNsDF"
"1Y1xxL0WTnvXpdfXZVrnjOjl9QioYjg4uxr2TilPoJXA2oEOOLukMkVgGb0xBFkg2l/6A1am"
"90uLuOrfmkTFSSUwoPa3DEAtCd+sTweryaC9+mTQgyNd8Chc3yf4IMxNe3qsE65sbZ70KqwZ"
"ZvUtKh3BO9laW8q5AJVpFznmxcwAf00IMOJLVo4iHJUsLS2aZLCzGHxme/PH+DQLXx54JuPd"
"KmhvQqC92qzh3T497pPC8YWGT6DHJ1w3vD9eH98AcMMAwA19feDXOALgPON/FNI+k/pfHOJr"
"I3GLAPBrVRPXDizCmeDJuHnUGy/IAK+vkwXOLsPzC354edkfz2MW4M6BEbgfNppjOI0+iOKv"
"D8KXtUcEx909PUjRrWmoJjjPlDAuoBkOzqyJPVOqIXx+LYQvdMKBGdUR5l4d7s0KYnmv8ojw"
"rIvVfcsiZKgjFruWwuK2pTC7QWF4NC8O98ZFeK3aqgJ4alEZ1R7mnG8F1SEsZkVlvQ6wujqf"
"EwiqCFRDLwKtqaPvDJIl4WYA7HP9ti/g4YkemiwKfXr8Z1zb1S751dG22Dy70mM7a4shvP/N"
"aQehf0fDJln/Ug1g0hWmKM38HKX441r8EC2yZLQaGbWt7WMkeSPh6YrktFehmnQA0xj/tQ9R"
"msY0Dl8Y879cNQBgGF8xQLwxG3hD934FgMsEgByVLidmn1I9g6UCKM2kHp3zx8ah7bB1TE+E"
"LRoOP9eaeB2/HneOLcLiVtWxfmQ7rB3WCuF+/bFpXFOcWNoD2yc2w4ZfG2BJp8pY92tDrBlU"
"G+t/dYIv07sra1uT7qshYGBFzG5WDAs7lMSCdsXh0aoYPFoUwZzmhakBimJG/cJwb1ocE2rm"
"xYTqBbC0Q2n4di6D0F8qY8voytg7tToNXksZXzWH9CpNPVBOVQLPEgTn/CqrPkHR/lJfoCbw"
"r4bYlTV1AITUMwBgaIDdbWRpuPaIAPjtVG9hAO3W/q7JH6K6YYtHjccZ01mO4n1vRYM40w5V"
"OUqb/gdZwLcwwJGNPyrMx/K8fh1rK8uWdnaWg4Lmu1zAZy8abEta0u/7U1M/RGiq2POF3vzp"
"gqZ9Oq+pMKAY4Lo+vk0HX1exH6mSEl4kAGIoAKN4LTk79wSS1alkckzqDtyPWkkgBOLWcT/s"
"n9NX1RduHZ6NwAHNsX5Ue6xwa4iVPetiTt0SWNG5NnzaVEfk8t7wca2M1QOcMbNRKcxt74gh"
"VQri6KKG2PRrVYyonBdzmxSjMCyLuU1J73PqwbN1MSzvUQ7+bqWxdlAFhA5xxMZhjjgwswa1"
"QF1E+TIkLK/NkFAD0b6kf096/8LSqlqoBtngtBx541UeZ3wcGSIqMYwQCMuqqCqgFILUPEAI"
"GUBfFKLd3NZSu00APNgvu4M6arcPu6W+iOqX9i6qJ+YNc7xgZ2PxC9O+VpYWJmkDWk1swCG2"
"yGb6i+sAZhaQRQdSdszFnxdTILAw1ba1sWrG513aNy4c/OT8+A/APvFgLfF1dErq+7NpagUQ"
"PVpSQO1LnKYlXCY4LhlTwleNJWHX9F3CybGk/zMEwEkCIBwp744SAAfIAjvxleo/6fVepH48"
"wjCwAM8vBePzg3V4fdUPv19ahkdRC/Hg5EJc3fErzgT0QXRwP5z07467h4bhyMI2FHZNsX9W"
"E+yf3RA7pzqrBZ4nvV2w390ZYfPqYu+06jixUGJ9XZzyJnC8qjH+V0HEAkeKuyr06or83hFn"
"llD8LSnP52VxcnEZRC4sxTSwFE4tJgA41HOCIXIex3zpGCIgIBMsIwB8mRksr6G6l15cU0e7"
"HFJfk3UBtygE7+5shRvbW6Zd3dw85eEhV+1TbF/EbO3wvkmtfMFyf22sLVvSHM6G8aWdW1GT"
"Lv4yGLb5SyuB6lte1Jo/y2iAQD5AOaYI1W1tLGUdcsssGa1HzBpd9+j7u0sTgZNq9+/XV+Ep"
"X1+Hp6o6gNoIEqcqgVpirEa612R3MFLIDqlSF4jhz08z9ofT0Mep+sOU0QUACc+36/sBJAV8"
"vR2fHoTg/c1V6kCmt7JBhOP1lUV4cnIcxxiKv+G4d3gglXN3Umt33NzRFdfWt1HHzsYFNCJt"
"O9OotSj4nBDtV5P0XB1nfarQkOUJACr7RUz1ZhfFMfciODqrCMJmSSPoogSEA077SNpXkiAo"
"qfL/04tL0tAl1IiQo+7cSyKcI4IgOLWwHIEhwKkkQNJi/KtpogGuBNXBNekaup6CM6RB6qX1"
"jVMe7G+Lt5FdcHWXa+LoXhWOZspgPZL3tRWN35T3W2K+FH7KG/dejJ/xR+r/ywAgF+TPZdWp"
"jZWV6h6Wk88LcUgcqkgmcLaysmzC521z50g3YfroBoefXFr8AWnUA9ppaB8jtYRX4clf30Wm"
"alIOTonVu4GlXFJDSyE7JJ3T0hJOajoA6P3vDhMAeygEtxEAW9X4/GQd3sb7q51B72/qU8Kv"
"Ly2k+p+PZ+dmqjX4t/b04ehFj3JD/I5uuLSuHWICmpK2XSjYnGnA2hw1aMRqpO9KNFxFGr6C"
"8mip5kUtKcHnxRAxvxCOuxegIe3V88gFhfi6wqT2IqT5onxelB5fTM0DRHgUU0WhiLkOBEAJ"
"nJhTUjsxp5QW4VFGi+K1hQHO+1VF3MrqSgPErKiVGr3KKfnKugbakz0t8Pxwe5wMbvZhxM9l"
"j+TImk4OfmhrZWXRlGrfRbyepqho0mN+Ibn3tEdGDpt/ZPw/DQDff8kuE2k/lilTJiUKbWxs"
"ZBpS4k9+gqA4H8vyd1ZNZ2tdn98LI7TOmN56uFv7SuvCto65/fXV5lTglKrUaYlRWuK7UykJ"
"70+npHyJTvvWFk67oFI+LYH0/+EIkt4e0L6+2qUlPNukfX4qp22H4sP9AHy8t8LoFLYIby8v"
"wKtLMhXsgefR06n6+3D0JABkLUA3XN/aAVc3tcXFdc2ZijWgEpd0zokeKQ2kmc97VVR9faN8"
"yhAcpQiA4gRHYQLAHifm5sGx2bkQ7pGHAMhLus9PoxfASU97gqAgTi4qRMPLFHER7djMItqJ"
"WcU0AUAkWeCkh2zdIgMwDJxmGDjp6ZgWucgx5ZRX5RTqAO3Oemc82d0EVzY2SQ2aUeN2a+cC"
"69LbWY3gfWvD+9fEzsaqIdlV8vxKNL5s2ZJ7LCI8m3HvrQ2H/Ef2/3MZwHwx2XUyfvx4U65c"
"uSx0TFjZ8f9kNkry0IIcDjoQLKqmT2dTz8LCUtasiUZwK1Io28yRg5rsOrFv1v2EV7tSgPPQ"
"pDkkDZ+WdEFL/HQ2OUA1UD8AAAmLSURBVOFjZPLXDydSUz4d09I+Hkbah/1Ie7cbya8kx9+A"
"L08C8eGuH97d9KbnL9DeXPbQXsXN0V5emKm9OD9De3JqrHZzF71+Zzd6fydc3+KKaxvbkAFa"
"IHYt076V9ZTxz/nXYAioqmJzlGH8KG+ZyStO76eH+9gzBOTFCY+c2om52bXw+Tm1yIV5tEjP"
"fNopr/zaaW8CgOPkooL0eGkRVxiRc8gI7mQAOe52toN2dGaJ1EPTS6QcmVEyJWJuGe38koqI"
"D6yO2+ucELPaKSVwSqX7PVoU3FUgd/qZvD/S3Lc5b3fjdLZWLrx/tYRVOcoZeb69cY8z836L"
"4LOyt7e3kC18/xMAmB+lY4jsP5s1a5bJyclJfii/xZpASMeRxaTHpYIGWkvzbZXS2Vk72dpY"
"u/D7Rvy+hfyxBfJlm9qja/11wavGnb91df3r1ORoDZBlYbJDSNYMHqf370n79Gxz8ofHG5Lf"
"PVyX8v7BmtT39/y0D3d88PHWYny8MR8fr7nj/eXZeB03Ha9ipzF1GsV8uhtHV8QTANc2t8PV"
"Da2U98cGN0JsYH3ErHJS6l3auMcsl+VbTNd8Sf1LSihaP7OkIAFBT/fMy5GTnp6dLJEDZ7xz"
"8//yEjj5cHZZAQWAEx4FtLDp9qkHpxZKOTilcPLhqUWSj84oliZH3kZTCF5aVh6XmQqeXVpJ"
"2z67wuvZ/Yufb10n97rc2e2m8j50N+5HI8b4hna2Vs783izwyvC5g3Ev5Z7KvVVeT1tY1qpV"
"y2L+/PmmsWPH/o2x/3IAjBo1yuTu7m6aPn26ydPT0zR48GBToUKFFBsY2iA96SmLVA35fQGT"
"XqQQBJejPiAr2DrZ2FhLGiPM0JTDlankoNKlC7v3+Lnpet8lo6JOhy979PLh1gRpG4+0MI4D"
"FI271FF0X58y9t/20V5fW5j6Im5OyrPo6clPz05NfnR6UsrjU+NS7ob9knp1a6e069s7p13b"
"7KpdWd9au7y+JS6GNqPQaoy4YBdcWFNXLc6IDaihKnXRKyRfL4uopQSATxF6uL0W4ZkvLXxR"
"nrRwz+ypEV7ZUiJ8cnDkSjnhmTc50idfykmv/KknFxXQTi20R7RnEcR6F8dFbwcOsohnSaaS"
"JRJWjS76aFyXAlEtamZfXzR/enemcDJ962owYiNrK4sGdraWzvx5DcPbpcxekvdOBF4Bw+PN"
"hpdYr5S+hGJ6vylnzpymLFmy/LkMYD4zyLw17EcADBs2zOTh4aEAMG3aNPVcACH9BPLmzfsN"
"CCa9Li3FiWz8Pg/fLhRW1ABDWYKhcrp0trU4nPlBXb4DRFuOnj9lyfhrpQrFFnbpUDd05sQu"
"R9etGnbl9MEZv92NWfDpza1laV8f+EJ74gs8WQrtgTdS7s7H11vueBM9Gg/3d1Pjzg5Z+98a"
"V0Kb0/hNtLi1jbSLaxtol9bV1y6F1tEuBtfUYoOrajGrHbXo5WXJCKXICMUQ41sQF/wLIHZF"
"PlxckRNXVufA9TW5cC0gD66uzI+L/mQAMsRxj/xpO6fm+7RmZL7fZvfIfWVA8+xHG1fJHFqq"
"YLqFmdJbygHOcoBTO+PvEvZrYGdjWZ/DiRQvni5VvDLK6PqEjnh7HpOuqzIZ9/Cb4f+hlf8v"
"XwKUfxsA/4oBZLewGH3mzJlqH7oAQZ7LVnL5ufQYdnBwkHRRhQaTXp4UBGfmJbIbYBB0SwFD"
"agmCuHLW1lZVBBDp09nV5XPZ7mwGhWQV0vVQ9sD3zpjBbmQh+xzTa1Qu6t2uWcXg/l1r75w5"
"utlxr6ltYoI9O1/fsazj/V1eTZ8d8m3x5sTyph9Pr2ySELWq0dezAQ1TogNc0qJXOadFB9RJ"
"O7eqRtrZ5VXTzvhVTDu1tFxaxOKSKUfnF/160N0+YceUPB/Xjcn5ZvWwbM+WDsh0f3a3DNfH"
"tM0QM7BJ+uNta6TfWb+cbXDZgtbeebNaTU9va5I0TfbPy37sVsbnlc/dgJ7tQmM7y4wd1bwY"
"/JuXm/QQWcRwDDG6LOrIbNwrW+Pe/d0qH/OX2Edu8T/zfvn6jxjA0dFRvSlz5symdOnS/V02"
"kDVrVkU9OXLkUEOey/jpp59M2bJlU9SUP39+8y+3MP1RQPoeDJn4ubPyw0uYyGvSBY4ZEMIQ"
"jH8WjjY2BIWdTQ0Cw8nOzkZSTAGGhI8Gxk2WTKOZcePF06RFdneOPhwD09laDs+a2WZMjp9s"
"J+TNkW5K/pzppufLYTc9X3YZtmrkzWYzPR9H7qxWU7JlspyQJb3FGDtr03B5P0df43qdjOu3"
"Mn5fY7ORBaj8U+vbWlvUs7OxqGNrY1GL1C4pWyWTXqkrrf9NFsX5NxWh59tz5OWQv13uAe+F"
"RXoOWw6J71YWf3yZ/tn4/uvH/xObpU+f3pQxY0Zlw9u3b/9phaD/5ssMBjMzmMOEVLEyfwcI"
"8QZJdYQOJd+VsCHeUtIARnkCoRLBUdXOzroGAVKLw4lCsw5FVF3qCYmp9Zg+1TfAIsPFGA3+"
"xXAxv17KrWJYayuTs421hTMNXJfDiaM2R03+vBr/Xw5pFo8pZxja7NnymQXQBfl3MUVWHp7D"
"pE/YZDb+ZjO9f+/pf9rNlq9/iwHMLWImTpxo6t69u6l3796mQYMGCZ2ri5jjiVz0Hw0BilEo"
"+oc1hH/wZQaDmR3kZkh6IwwhRSYzKCRs5DKAIZMeEj4EHHKDi5j+AIh8UDGAGELiqhx8WJ5A"
"qMBRkaCoZIzKfztMavCjV6LRK/J3ikFFhYv3ljWuVcq4toPpDwMXMT6DfBZ7s6E5chlr9MzG"
"lr8lva2trV2GDBls6JnWHFYclhwW4ql/xhBPz5Qpk7KBNPkQ2/Xq1cskXUOeP3+ubJuamvrN"
"3n8HgB+BkJCQoB7lAvIlv0RZ7c9jhB/B8D1DfA8KCRviLWZgSBUqiwEOEZg5DIDkNjxNQooZ"
"KDLsDSOZGeX/NsyvszeGvD8ff19ew7i5lYEtTDmMJVhiZFHpmcyGNj6rrekP77Yy/a2H/+k3"
"0GwTs43EZt/b0GzT78c/BYC8KSkpyfT27Vv1fY8eqlWsQtj3v+x/8PUjKMzA+BEcMoQ5zCAR"
"elVAMYZ4YRZj/PQvhvl1mb97f0bjmmbj2hnjRyObDa2MbZTnLMzZVP/+/U3btm0zrV692hQS"
"EmIKCgoyBQcH/2lDrhcaGmpauXKlKSIiQoX0T58+mRITE7+F9/8nAPx/YoB/98vC9I8B8iNQ"
"zGD5cdj8MP7Ra76/xo/X//H3//0H/MErxUj/yiv/l+P/AOfLCUkdQZ73AAAAAElFTkSuQmCC")
getIcon128Data = Icon128.GetData
getIcon128Image = Icon128.GetImage
getIcon128Bitmap = Icon128.GetBitmap
getIcon128Icon = Icon128.GetIcon
#----------------------------------------------------------------------
Icon256 = PyEmbeddedImage(
"iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAYAAABccqhmAAAgAElEQVR4nOxdBXgUydadKO6y"
"uDvBHRaWXWSxRXaX3cUdgru7Q3AIuri7u8YTPGhIIAnxEHcZ6fvfU92dDAF2973/vQf73tT3"
"3a8nmZ7pqpo65557q7paQ0Sav2oGg0GTlpZmMpOZ7As2rVb7lzH9l080mclM9t9nf/imJEni"
"qDLK48ePNQ0bNtS0a9dO06pVK823336rad26tcm+fDNTjX8z8z8z4/O/gLqb7E8MOAQegUvg"
"c8KECe/hVsXxP00AkBU43rlzR4OSLVs2cTQzM9OYyhdT8GOYs1mwWSpmrVg2I8vOlkOx7EZm"
"/D/j89XvUL/TQrmO6cf/QoqKQxWXIAVj3P7LCMDR0VFcIG/evBpLS0tN9uzZxUVN9h83Mxj3"
"vwWbJZs1/53NysoqO/8uOdhyseVhy8dWgN8qkjNnzq9y5cpVInfu3CXz5MlT2sjKGP+N93Ee"
"zsfn8Hnle/Io35sD18H1cF3l+hZqnb6AvvmfM+AQeAQuUaAE/i0EYFIAn7WoHl717KrXzs2W"
"j60w/x4lLCwsyvJgqMhWla06mw2/B6vBVlM5qq9tjCzrezja4PPK9+D7KuL7cR1cT7lubk2m"
"clCVgkkh/AfLf0wBODg4iAuAcVDMzc3FxU32bzMU7mZzKzb8ugBaLrZ8/HdR/sHL8G9RiU0F"
"ek3F6rA1YGvK1jJPnrwdK1as+Fu1atX7169ff2STJk3GNWrceGzjxo3HwRrBGjYSf9erV29k"
"1WrV+leoUOG33HnydMTnle9poHyvuAauh+vi+qgH6qORCQH1y4H6ot6ov9KOz92X/7UGHBrj"
"8t9GACYF8B8pwtNz31qwwaOqoM/P3rc4931Ftur8o9fi/9Xkc+rysQnL8nY1atQY2KxZs2mj"
"R49ev2PHjhNnzpxx5N/shY+PT0B8fHxMampqgsFg0JFcpI8Y6fV6XVJyckJMbGyMl5dXwI0b"
"N1+cOHnScevWrSdGjhy5nsljWvXq1Qfieriucv2aqA/qhfqhnqivUu8caAfaozEpg39LUXH4"
"b1cAJgL4txYV+PCaoPKcbPn4NWLxCmw1+LUNW23+f+P8+fN3btCgwbhJkybZnz59+o6np6cv"
"/06J9IkCdBsMEqWnayU+z8jS3zOtVisxSRD/9p/6KkpJSUl8+PCR78mTJ+9MmDDBnlXDONQH"
"9UL9UE/UF/VG/TWyMsiJdqF9GhMR/EuLiQD+3iUr8BFTI/FWChKb/wdPD9A3/eqrr3r++uuv"
"Sw8dOnTt9evXgcC0MVAB3NTUND0DVMveHqbj1zr8TwZ4mpSenk7pWu0nLY3fZ5NgySkp+sTE"
"JB0sKSlZy8pAm5KSyiLBkEks8vUNr169Cty/f/+1nj17Li1atGhPjRw2gAxqKSFKKbQL7TMR"
"wb+2mAjg71kyknpGwC/I0rqMtbU14myAvn7u3Lm7/Pzzz4tOnDhxKyIiItoIdOzN0w0AO4x/"
"I70BLt4ImDqdjvj/lJycTElJSYolfsKSMgznw5hASBCGQhpaYfydrBKYDEAO2sTkJFzbYFyv"
"sLCw6CNHjtz68ccfF6H+aAfag3ahfWinRiECjSlp+P8uJgL4+xV0HGL8bGyIk+HxSwMg/DcS"
"bU0qVKgwYMmSJQf8/PyCVHDB4NUZnFoGpd7Y++MlPDN7egZxspSQkJBhiYmJpJox0FUzft/Y"
"+LOU5XvEd4EcQCxCNTDJ4JjEaiE+MVHL7+sMBn1Gvby9XwUtXLjwQPny5Qdo5JxBHbQT7UW7"
"0X70g0ZeX2AaUP9EMRHA36eoXh9yX43xizEgkNQD8JtWr1592N69+64kwS0rwGfQ6wF69ugZ"
"2hvOHt6YTeL/i/idlQADVwa06sWNDe//kX3sM58iCmNSwHtCLYgwQofPGeLi4rTxCQkcLshk"
"EBMTk7hjx44r1apVG4Z2or1oN9qv9AP6wxQW/BPFRAB/jyK8Phsy4nk0styvwJ4QwG9YtmzZ"
"vjt2/H6JPXsqAMPAkVRPb+zhAXgZ9HoJ4ILMB/gEYI0Bzf8ztlT22H/Fsn7uYwTxZ4SAc6FE"
"kE9ISEjUR0VHa5OTU4RciY+PT924ceOlMmXK9EW7LSws6nAfVEB/KP1irTGpgX+omAjgyy8q"
"+BHzisy+IvfrWVtnaz9nzpzd8fEJ8QAIx9kGAB8EYOTpFdDrQAwi2afG98aAT2XACSCnpyFO"
"ZwBq5aMSu/+ZwXuLz6Rnfvaj5PAHhMCAV0wmg+QUVh6paZTAryMiI7Vx8fEGOU8QHj9lypTd"
"3A/t5X6wqmk0Y5BdYyKBv1xMBPBlFzXRh/l8ZMGR3a/Hx4bNmjUb9/z5cx8AAvIeGXsAH96e"
"PXyGvAfoVeDDkIwz9uwq2NONwAyCyGrq93zKsp5vTA4ZhKCQzB+RgXEOgYlNYq8vcThAiUnJ"
"xAQghb97p4uNizNA0Tg7u/g0bNhwHPqDxxX6RZ0tQH+pCUJT+YNiIoAvt6jgR6IPErccy936"
"fPx66tSp27lftUC7AnyDTAQq8DOBqQKfTxKyOgWgz8jMvw94Y0Crn8tqakJRtY+d8yliyFAK"
"nyADYyJQCIDi4uLZ4ig2NlaKjY0jkEFUTIwhKChYl8hq4V1EhNbWduR2c3PzrzkkQP+UU/oL"
"/WYigT8pJgL4MosKfiS3CvLgxgo5eLkOR44cuQmwA/jszfV/Bnzh9RHrC+B/GvSfAvk/Uj5F"
"DlkJITNskNcOfIwIEqEGBAnEE4DPBEAxMbEUFRUlRURFU1R0DAWHhOoDA4N1qWnptGbt2pvm"
"ZuYd0E/cbxU1Mgmg/0wk8AfFRABfXkHHZICfBzQGc8OiRYt2d3f3eA6gJSUlp6sgU4H/KfBj"
"qi1V8fi6PwD+PwP4f4QUspKBWo90hQiQe8ggApUElFAACkCAPzoaBACvT2Hh4RwORFBo2Dt6"
"/fpNenRMHP2+c9fzPHnydue+awjS1MhrBlQSMA24jxQTAXxZRZ3jFzE/gx8Z7gYA/8OHD18C"
"UAyMdBwR3/8Z+IV3zSL1jc/7Zz39v4oIjEMDOeGYqQaMQwGEASCAyMhoimDwv2Pgh4eHU0ho"
"qBQUHCqFhIaRD5OA/9sA2rp128u8efN2R78xCaD/1JyAKTH4kWIigC+rQKqig5Dtx62z9QsW"
"LNhVBT9W7eGINfcq8P8I/GkfAf+/2+P/WTEmgqxhgRoSCAJgFcBKhxIS5TBAJoAoBfzvMBNA"
"ISGhFBQcTG/fBkoBgUH00uuV9t79+7Rxo/3LXLlyd0X/8Ugrq5FnB7JpTKHAB8VEAF9OQYdg"
"MQvms4uz96/L9t3Vq1fdARwGv/D8AL8MmvfBbwxuLL9NNUr0fcrzf66SlQSyKoHU1DSZAJQw"
"QBBArEoAAH8YvD8FB4dQIAPfPyCQvH3eSG/56OLqln771h1asHCxO/fjd+hH9KfSr1Yakwp4"
"r5gI4MspqvQvlD17dqznb7RmzZojAAxL4TQcMd2HpbIfIwDjaT51ei89S8xv7P0/Z/kjFZCW"
"JtcfBJAoFEBiRg4ABADvH8qSPyQkhIKC2Psz6H3939Lr1770ytvH8PyFF506dTrt+o1b1Ld/"
"/yPoRysrK/RnIaV/LT7rr/yFFRMBfBnFTLl/Py9W+PGxTvv27adwv+lxow5Agzn+9wHzIQHg"
"qC7q+ZIJAOVj+QCVANQQADMB8UoSMDomhuP/SCT/FOkfQpD9fhz3v/H1YwXwmrxeedOTp8+l"
"q1ev09Gjx/UnTp7S16xpMwX9qeRT8ir9bBp8SjERwJdR4JWQrS6KW2Bz5szZ/unTp14Aig7r"
"dsVSXj39GQGo8XOqMtf/R/H/5yyfUgDp6dqMJCDkf8J78j9ayP9Qlv9C+gex9Af4/fyRAIT3"
"J3j/J0+f0eUrV+nwkWP6EydO0eLFS70sLS3bK7dGF1X62aQClGIigM9fzJT72/Nw31TiY+0R"
"I0asAlBwXz6Oer1ByrrQJisBAEAZy3qzLPb5EnMAH3p/rbgHQJ4ByOL9o2NE9h+Jv+DgUAF+"
"If39WPq/YenP3v+l1yt69vwlPfJ8QufPX5SOHjtGe/bu1R48dIRatGi5Cv3KRID+zaP0t2kA"
"akwE8CUUZKaxfh0bZda0trZu9+xZxhJfsQUX7tXHuv6PEYBKAuq9+++RgPbLIoFPTQVmgj/t"
"A+kfw9I/MjJSxP5I/CHuD2Dw+/mz92fwq9L/OYOf5T/du/+ATp46JR06fJR27dqj271nH82c"
"NdvH3Ny8HY+5mko/Z9eYZgREMRHAZy7Kfnc5GPiYrqr5XZs2iP1Jjf0/tew2KwnAa2Le/L0b"
"fBQSSDMigc81HfhJ8Kcbef73wB+fJfGngD9QAT/ifpb+Xq986MVLLwF+T8+n5OTiQocOH6F9"
"+w/Szp17aOOmzfrNm7dRxYqVkAuoiZ2JNWJdgJkpDNCYCOCzFyP5X5WP9bdu3XYKgMFdfQpw"
"JBVAxirAOH4GuNUNO967f1+9lTc9c1bgY2rg37Uo6NPElXmTUKoC/qQ/9PxhYr4f4Pd/mwl+"
"xP0vXrL0f/aCHj32pAcPH3P8f4327j/A3n+vtG3777Rm7Xqtvf1W6t6jxyn0L4cBVTSZYcD/"
"fDERwOct6ARkpbHkF3vpt3b3cBfyPyUlVch/9dbej3tRGVBInuE2WuNde4xJIJMI0t+78++v"
"3g/wZ8TwsXM/RlQZC34ygJ853y8n/BLEun+R8RfgD8+U/YEc9wvwZyb9Xirgf8xx//37D8nV"
"1Z2OHT9BO3ftIQa/tMl+C620W61bu249DRtu683928pc7ucCSr//zw9CEwF8xmImd0I29krY"
"2aZa1apV+8TExsbL++nJq/30hsyY/eNeVRIxtPE99R9VA8aKQLkx6GN3BP7VuwI/ZX94J6BR"
"lj9joU8WyR8VFS1W+2Ws9Asy9vwq+F/L4H8O8D8Vcb+b+126cvU64n7azp5/w6bN8P60fIWd"
"tGjREpo2bUZcgQIFe3M/Ywcl7B2Agfg/PwhNBPAZi0IA2a2srErysXqDBg1GY6Uf7oMXS3nT"
"5Kk848Qd9ujOJAHZtDptxg00GUSQ+KEi+KgqMMoTGN8t+Kl9Af6KfbBJSJq8ui8r8NV1/rjT"
"Lzo6Wszzqwt9gpWFPhng9/N73/NngP8hObu60W0HR0LGf+u27QTPv3rNOoAf04A0a/ZcacbM"
"2VKxYsVGo59ZbaG/TQSgMRHAZy3cB2IGwNraGrvdVmvRosUMeHmWwLpUOasvAThY2mucvJMJ"
"IJMI5Hv9Fe+ahQg+tqnnx5TBB9t/Ge8MZLQ70HuW/nHL2AVIWdFnDPpEReqLOD8L8IXXV5b4"
"ZiT8lJg/A/xeXvT02XMR83vcvU9Ozi4C/KdPn6UtW7Yh6ZcB/oWLlkhz5y6gyVOm6aZPn0kl"
"SpScjn5mAkB/m2YCNCYC+KxFJQDuE2Smq7Zs2XIWCOBdRKRWzIVjWywB1FR5J10GlyACw/tT"
"eUJ6y3sCvJdYS/4DMkj8yFbeH2z2mXWPv79g6jXfu25C5m29wtsjwRcVJQP/nQx8sbxXXd9v"
"vMT3jS/5+LymV5jqe+FFnk+e0f0HHO+7eZCDozPduHmbLly4TFtZ9q/fsIlWr15LS5etwL0A"
"NJs9P4A/dtx47cSJU5gASsxCPyszASYC0JgI4LMWIwWAba6rNW7SZDLAyzGwHrF8XHy8kPIy"
"SGVApimKwDg0kKW3EntjWtB4s43U9++x/7PtvD+2x/+fWdbdf8VuPspmHirokdXH/fyY1gPw"
"M+7qCw9XJL+yvFes8MMiH38Bfm9lkc8T9voPHz1mr3+PnFxc6fZtBxHzX7h0mX7fuVt4fTu7"
"NbRkyXKaP38hzZw1hz3/dBo/cRKNsB2lHzFiFBUtWnQy+tnc3Bz9bSIAjYkAPmtRCACP5sYT"
"c6vVrl1neFR0jBbAiImVJXIsAyguPkFO7gFkyg6+amggds8FcI3221fDhfdus037yM47ijRP"
"+gvEoOYVlE07MwxyXga6CvbM3XsAenh7yPzIKBX8ERngDxWSX473A5UFPv4Zkl8G/tNnLxj4"
"nnSX5b6LC8f6dxzp2o1bdP7iZTp7/gJhoY/dqtW0Qkj+pQTJP336LJo0eSp7/glkO3I0DRo0"
"lPr2G6AtUKDAcI1MAOhv0+3BGhMBfO4iZgF4QBbhYw32UN2ePHkWBsAwQAzIiEdFAUQKETDI"
"ADg5wScv+gEIsUYen1H3zMN99EItpKdlPJVHp83MxKvKIEMdqNJdVQl/vKe/EfjjZfCrBgKI"
"e58AsHUXwB+BW3mzSP5go5t6/I1u6sHcPhb2PFA8vjOA7+BE167fpIuXr9Lps+fp5KkzAvwr"
"VqyiJUvZ6y9YSLNmzaWpU6fThImTadTocTR8+EgaMHCQgcFPnTv/EGZlbd1NIz+6HP1tSgJq"
"TATw2Ytyd1o+POiCj02PHz/+ICEhCTGwNkKsgouQcMTNMAATVEGcIIM4QQIAkp/fW7FQJphj"
"aHhWzKHjXJUQcF5GCJGWqRzwOs146+6UVGEfkkGyuDVXZO4TkzKUQLy6cadCALGKAgD4oz8h"
"+UONpvfk9fzy1N5LL2/h7R89fiIy++7ud0WC7xZL/asM/AuXrtCZcxfo2InTdPjoCSH7lzLw"
"Raw/Zx5Ng9efBK8/nmxtR9GQIcOkAQMG0S+/9NL++ltvatq02QON/FAR9DM2CLH+rD/8F1JM"
"BPCZi7IiLTcTAG5UqTN27Nit8QwuX18/bRgDhr2kBI/JRMAgiiSVDKKj5T3ysAz2ORvmxl8z"
"kACotwEBQlLDw+KzAB9AiPNVAgF4ExKNworkFNmQ/FPCjMwYXyUB4/3735f/xsCPVuR+5tZd"
"YZm37yrLeOW5fC+O7WXQ33/wiNw9ZG9/h709knuXOcY/f+ESnT5zjo4z8A8eOkr7Dhyibdt3"
"IsNPc+bOo+kzZtPkydNo3PiJNHLUWBo2bAR7/cHUu09ficFPP/zQXdu1aw8qV678VvQvEwD6"
"Gc9SNK0E1JgI4LMX9V4AS0tLzE3XqFKl6kBfv7cp/v4yiIOEhQgww9uDFEIZVJDV3j5vyM39"
"nlgCizgZGXLMj4MUcIMM5DQSabhrDok1ADBIIQbxXSAWluTYZBOqQaiMqGhx9120Gr8LUCvA"
"jpYtKiOmj1RkfYRcL1XWKyv3jKfwvLzlNftPn8nz96jz3XsPyBWeHkk9R4D+Dl25diPD259g"
"mX+Evf2Bw0dp99799PuuvbRho70c58+YJYA/fvwkGsXAHz7clmP9IdS3b3/69dde9OOPP1OX"
"Ll2p/fcd6Jtvvk3JmSPnQPQv9zf62bQxiFJMBPD5i5nygMsCVlZWiE+bbtm67da7iCjc6KIN"
"CFD2vAsIosBgmRAANMjnW7cdRWzs6OTCntNdgAlz45DQABg8K0gBoHv+4qWIrUEM8L4AJcgB"
"AIVq8PN/KwAL9YAlt0jIAcSYi5dfB4prqu/jfBALPi+m6vj75DvzfETyDtdD5v7xk6f08LGn"
"8PAe9+6LOsLLYwrvJst7JPQuX7lOFy7KoD956iwdPXaSDjLo9+0/RDt37RMef/PW7WS3eq0s"
"9SdPZeBPzAT+4KHUj+N8SP0ff+pJP3TtJnXo2Jm+/batlo0qV65ySyPLf3UZsCn+V4qJAD5/"
"UfcDyM0qAPPTterVqzfG19c/3cvL2yB7UNmL+/kFiGQZ9sG7fuM2nWbAXLp8je26iJPhQUEK"
"dxycM0jBxc2D3FhaA3wghnsMRFUxwBN7ej4Tm2gArCAK3FP//IVMGLJ5KSb/DYXxlA3SHeTy"
"mO3R46fi+/C9+H54dsh5F3cP9u4Mdq7L7TtOdPPWHRnwLO0vspc/e/4inVLk/ZFjJ4TE34u7"
"+Hbvo+2/76LNW3awx99M69ZvokWLl4rkHjL7I0eNoaGqx2fg/9arN/30c0/q2q0HdWTgt23b"
"nlp98y01a9bC0KB+o/Ts2XOMQb9io1VNpvw3DUCNiQC+lGKu7FdXEM/942PjRYuWnA0JCaMn"
"T56lw0OzZ5Ug+fH6IoMesfAR9pRHj50WXvP0mfN09txFjpkvM7iuCq965dpNAbgbt24Lb3vr"
"DpODo0wOTs6uwhM7u8ok4ep2V3hnJN8A3o+Zm4d8jisDG58BwQDg+D4HRxdBPCAgAP36zVuC"
"lGSwX6VzHMuf4fqdOn2Wjp88Lep+6Mgx2n/gMO3Ze4A9/V7Z02/ZThs3baG16zaQ3ao1tGyF"
"Hc2YOUfE9yOQ3Bs6XMT4fSD14fF/ZOB37Z4BfJb7UosWLalhg8bp9eo1oGJfFTuL/lT2AsBz"
"AtDP//PTf2oxEcCXUdQdgXNzv+D5dnUKFSr0EwMrBMtfnzx9bnjF0hoG8Gy03ybi4R0799Iu"
"Bs9elsr7Dx5h2XxMxMzHjp9ir3qGTp4+J6bMIK3Pnb8k5s7heS9dvkqXmCAESVy9IYB67cZN"
"wkaa12/ezrAbimX8j1UHCAXnw/BZfAcICXG7PDd/SVwPibsTTEzw7kfZux86cpwOHDoiZD3i"
"eQB++45dtGXrDtpkv5XWbbCnNWs30Eo7rORbSYuXLKO58xeK5N6QIcNlmd9/IPXq3Zd6/vIb"
"9ejBMf4P3ahDh07Upm07AJ+aN29JjRo1oTq16xpqVLehsmXKhrDs/wn9qZGfG2jy/lmKiQC+"
"nGKu5ALyK1tX1fv665bTXnp561mW6yDXGTTS8hWrpLUsiWEb2FNu3LyN4+MdtJW95/bfdwti"
"2LVnP+3ed1AmhgNHhLQ+yADE9JlQDUwQmE47fvKMSLSdZK98iskCBuBCTQg7a2Rn5PdwDogF"
"nwMZHRMAPyWI5zBfA7E7yAgKZc++A1yXfaJOkPRbt/1O9mK9fibg7VatpeViLh/Ld5fS3HkL"
"afac+WIV39BhI4TE79OnP/2CxN7PvwiZ36nzD9T++4703XftWOq3ZuB/DeBLderUk2pUr0GV"
"KlTSlSlZWm9tZTUN/ciG/syvMS3++aCYCODLKeojwfBQy8LcTzZ8bNinT99N7u73aNGS5ekL"
"Fy+npcvtpCXsIZevWE0r7NbQSgbQqtXraTWDae16e1rPwNpgv4U2KcSwhUG3dYdMDjt27hFg"
"RIy9i73wblYPMlHIZAHvvI8lOWy/Yvsy7JDYZUecy5+BbN/NRIPv2inUyB5xDRDR1q2/CykP"
"z75eieEB9lWr1+H+fFq23I49/ApauHAJzZu/iGYx4DGdN3XaTJo4eZqQ+r169xOg/5lB3637"
"jyKj36EDy/x231Pr1m2oZctvqGnTFiz1G1Ht2nWoerXqUqUKFal0qdLpxYoUJWsr603oP+5P"
"9CO2AVMfFmoaeEbFRABfVoF3Uh8O8pWFhUUd7qfm7OX2z52/mGbNmpcODzl/wWK2JdLCxctA"
"DLSYvSdIYenyVTIxrFzNQFtDdgy4VWtkclizbqNQDes2bGZQbpHVAwMUBq8s2w5BGu8Z/sdg"
"the2TRALQpAN/Dl8x3r+PnjztesUkPP14NVBTsKzc70WLcaCHRnsc+YuoJmz59I0BvyUaTNo"
"4qSpLPMn0ZixEwTwe/fpJ+S9DHqW+Bzbt2vXgb19W/qmVWts8EmNGzclxPc2NWtR1SrVpArl"
"KlCpEiWpaOHC6QXy5iNLC4t93H/NzWTp/5Um86EgJu+fpZgI4MsrGKRidSBbcQ4HIGGbfd2y"
"1f6Zs+bRpMnTtVOnzZJmzJxLM2bNlWbNni9AhXh5Hohh4WJasGgpCXJg4C1WCWLpSlqyHCRh"
"R8tWrBLgXM5EAQNYVVspbG2GGb+3Qpy/Snwe3wNwL166Uvbmi5fydZcIchIynus0a/Y8mj5z"
"jpi6mzJ1Btd9Go2fOIXGclw/esx4sh05hoaPGCWkPpJ6AH1nlvfvgZ5j+68Z9E2aNKMG7O3r"
"sLeHzK9csRKVLV1WKlGsOBUuUFDKlzuPNk+OnGRhbrEf/WUmS/8SmsxVfybwf6SYCODLK+IB"
"oRo5XkXcWgLPvedjszp1620dN36yNHbcRAN7TD28J0tmadKU6RIAxsQgPCtAN3PWXAFAxNMg"
"CEESDExBFOyJ57GiEITxCZunGp87F8afnQPj78F3zpozT3w/iGj6DIAcHn2miN2ZpGgCPPsE"
"TNsx2MeOp5GjxpGt7RgaNnykyOQPHDSE+g8cLJJ6iOvbt+9Abdt+L0DfSvH0maCvy6CvSVUq"
"V6EKZcvD20tFCxeR4O3z5sylz509h4FNsjA338H91JwN/VVCkxn3mx4M+oliIoAvs2SQAPcT"
"BnFx5Rl3jUuWLDW//4BBsfCeQ4aN0I2wHS3hxpdRo8cz0CaAHBh4k2j8hCkChIip4XmZJGgy"
"kwRsChPFVNUYuJ805RwBbPHZ6eJ78J34bnhzgBwSXgCdvfpIrovtKPbsLOeHCrCPEBn8/gMG"
"i4Reb47tf/utj8jkI4vfpk07Bvy3IqZv1qyFyOLXr9+AateSPX2VSlWoPIO+dIlS9FWRolLB"
"/AUoX67cBMDnypZdx0fKZZ09lsE/H/3Dpj4L0AT+v1BMBPDlFiMlYAYZW8zc3BxPt6mfN2++"
"Ad9+1/bxAPai/foNMPTtO0DHr6XBQ4aJKbMhQ20leFrIayYIIbVtR40V4DQii/dt3AQaI7x1"
"lv8zqHE+Pou5eNuRbPydiNeHjRjJ8t1WgBzXHjhIBnq/fgNF5h7e/ddfe1PPnr+K+fruPX4i"
"rMvH1B2y902bNqfGjZrKXr5OXapZw4aqVa1GlSDvy5SlksVLIK6ngvnySwL0LPFzKcDPw14/"
"T/aclM3K6jH3yQCN7PXRP9hfUX0asAn8f1JMBPBlF5UExHMD2YowCVTFY6/Zvq1QoeK2Ll26"
"JvTs+RuWwBp++vkXHTLnv7KH/a1XXyTUJI6tJXjefv0GUb/+gwVABwwcQiAPABYGDz1o8LAM"
"Gzh4qPKefB6kugB2/0HytBzH670VgMObC5CzR//551+phwL0bizrkcTr1KmLADxi+tbfthGg"
"r1e3PtViD1+zJgO+igz48gx4JPKKFf0KMVqiM3AAACAASURBVD3lz5NXYnkvwcMbGTy+AbE+"
"k0ACe/1t3CffamTwY1v1Iko/mcD/F4uJAL78YkwCWMhSgPuunLm5CAkaZs+eY0BNm1p32rfr"
"oO/UUYBN37FjZ23nzl2lH1hiI77u1u1HqXt3NgZmjx9/Ft6YyUJMsQljD/2B8f9xDs7tIexn"
"AWz+HgHuH7p2lwHe+Qfq2DET5Ijjv1WSdy1btqIWzb8WWfu6depR9arVBdgrlK9AZUuXER6e"
"Zb0AvIjnZS8P0BsDH6+1bHp4/NzZcuitLa0wmOD1G2pkyV9OI6/xz630kwn8f7GYCODvU5DF"
"xjw2lrKqIUF17kcAoHme3HmmVK9W40HTJs0NX3/ditgkNm2rVq0NrVt/R9+y98XCGcTcbFLb"
"tgBrBwHadu2+/4jJ7wPQ4jMManwHvgvgbtWyNa5BLVp8TU05dm/SuBk1YinfoH5Dqsdgr21T"
"m2qKbH1lKlOqNJX4qhhhfr5IwUIC7Ply50ECT8h6Ec+/7+lJSewB+FIe5W+W+w+4vXjCDxJ9"
"aDfu7Vclfw6lf0zZ/n+gmAjg71WM1QAWtkANlFVyA5jzbpUzR85p7FmdqlaukmpTsybVqlkL"
"YNTXqVVHy8A01Gf5Xb9eA5FoA1gbNlCs/ofWQDFIdlhdjtP5e8R31qxRk2pUq84SvipVqVSZ"
"KpWvSOXLlqOypcqwlC8hwF4wXwEZ6OzZ82SCPcMAepbyHwO9HqCHx8+VLUdqNksrJ24nVvW1"
"UtqJ9uLGngJKP5i8/j9ZTATw9yvoOGM1gEUuhbg/KyhEUJutuYWFxbA8uXIfLVKwcDC8b8li"
"Jah08ZJUqngJQ+kSJbXlSpeR2BiwpYWHxmvxt/ifeixNZUuWEhn40izXIdnxXcU5Ti9WuCgV"
"LViYirB8L5S/ABJ1smcH2OUYPQu4+XWWv3FeHlnya3MrST0h8/n9HNbZgq0sLI5yY4dpZI+P"
"dqF9FdBepd3GXt80oP6JYiKAv29RiQAr3FQiKCwTgVkt7l5I5EZ8UjcLc/MF2a2tr+fJmTO8"
"QO48hoJ58wr5nS9XHirIoBXGAC6Yl0GcJx/lz52XLY+R5ab8DOx8HzG8j6OQ8x/K+PdMAXyG"
"gSByWFlTXvzNBJAzW7Zwju+vo76ot6g/t4OtlpkM/MKaTOCrK/tMA+n/UUwE8Pcp6DF0mzmb"
"hWKWbNZs2dhys2HuG94R8+CVNXJ2HHPjTdnasg00M7NYZGlhebRUseIJXxUqzMDNKamABBBV"
"UBfIk/ejZvxefiWOz5NF2n/MAPacDPYcivFrCcqBQ4UEczPzo9y0RaifUs+mSr3rK+1Aewqh"
"fUo7synttjTqC3MzmQxMA+sfKJ+VAFimaiwtLf82hvoam5WV1Qf2/yG2LADH4LZSBjpiXHQc"
"9rLPoRhiX2S9Me0F4ONe9yJ8bkkLc015tiqWFhobKwtNY2tLs7Zs3dn6Wppr+ufIbt2/Q8cu"
"wbijrnGjJnqbGrXENBykfRF5Ck7E7CopqJaP/5cV9Fmlvnj93t9yLA9lUZQJB+EGVvU1athY"
"j9V/HTt1Cc6ZI1t/K0uz/tZW5n3ZurO1ZWtsZWluY2lhVsXC3Kw82qWRp/kKKu3Nq7Q/l1Gf"
"oH9UcrBW+s8yC0GYilExKYD/fEHTVaBngFwjAxyGgZxTIw9syF1kuAvyOUUZCCUYKKUZyOXZ"
"KrJVZqvKVoMNYEGMrBqSZfCgmCqDR/3O3Nz8Zz7+mj9/gfG//tY7GdN6P3TtLrbPUu+ya9a0"
"hUj81a5dl6pXw621lakckwOA+1XhIgL8wkAK6msjE6GBEjogtOCQQ+QNsMoPMwht23UQa/1x"
"XVz/l197J6M+qJdSv++U+jZU6q8m/WpZWpjXsraysGGrwVaVrTJbRbbyTBalLSzMSqCfNDJJ"
"5FP6L5fSn+jXbEbqQSUH/A7/s8rhP04A1taZuzF36NBBM3z4cE2/fv00gwYN0gwcOPCLMtRp"
"8ODBGda/f39Nnz59NH379hXHYcOGaUaOHKmxtbXVjBgxQjN69GjRpu+++05Tr1490b8WHNDy"
"0QLbfilbgBt7chXkQrqbW5gXYxCXYu9Xnq2StZUMbgY9bmmF1VSOMCTFcJFGbM00SPyZa9rk"
"z6XpXqqQeZ9KJSyH1yhjNb5OBetZ9SpkW9KjifW2vt/m3DepW7ajk3tVuNl/kK2hV69eYo4f"
"c/rsiel7VgTtxJr89vRdm/bYU0++9bZVa/qGj9WrVqNCrA6KFizESiE/FWEJn2kFZSuQaV8V"
"LEyF+T0kH9vwd37/fSdxHVwP1+3Vqzf1HzTcMGdEi5tzh1Q9OqxH5X29vy+zrbFNkSUNaxSe"
"VbtygfHVyuUbXqZYrj4F81p3575po5ETgs2UdtdT+uG9/rGyfI8kKikEUcrc3AxThoWU/lbJ"
"IatysFIVg+Z/gBT+4wQAmawWgH/Dhg2aJUuWaOzs7DTLly/XrFix4rMa6qHasmXLNEuXLhWG"
"Oq5Zs0bUd+3atRp7+02aCRMmCALo3bu3pmLFCma1a9cyz5kzJ7LSVuzNAPaPAb0wPBUPyjLZ"
"rC0rslXNZm1Rw0L23jZGBs+neu9WubObdS1T1Kp/jXLZx9SplGNmh0a5Vo3pmn/vvL5Fzq8e"
"/pXDpjHFPfdNLeF3YWHx0NsrSsa6rymZ9mBDKcnTvhQ9sS9JnhuL0YP1pchrS1G6tLoZDRo+"
"kQYPHkS9+w6kX3v1EYt/esiKQCzuwb3337eXCQHrACDXbWrYUKG8+QWwAfqiDHJhTAiYEci0"
"QuIcKAbkGUoVKyHIBRt2YoHRb3y9Xn0H0JAhg2ng0LHktL8fxdz5mUJu9KaI270p/FYfft2H"
"3l7pLflc6JX25ETPWNf93UPPrO/ot3dxW8+tc79xsJvY/Py0wfX2dv+23KqGNb6aWbtK4THl"
"S+btnzenVVeNPF2oqog6xv2qqAiQQxVra4uKVlYWZbnvkWMorPkIMWSSgpnlfyMpfFYCgOcH"
"sGbOnKmZN2+eZs6cOf9xmzt3rrg2DK9RF9iMGTM0ixYtEiSwePFizcqVKzVDhw4VKsDGxsas"
"RIkSZjly5MDcs6Wyqacq3zF4EJ9ijr4oe6NSDPIKbDzgLBno5sZAh/cSILe0tGxTqnj+X6uX"
"zTmyQdU8s3u3KWQ/Z0CpU2vHlHfaNb2i18VllYNdN1WNf/x7dYPX3hrkvb8aee+tSq/2VCGv"
"nZXJa1cleratAj3YWI7uri9DrqtLkdPKkpLj8hL6m0uKaW8uLKK7Or+4zml5Id3uhe30o8bN"
"oJEjbWnQkBFimS+W92Jpr9iEg8kAqwDV1X9dhMf+mWrXrCWAj1wBgF2MAf6eFSmaYcUVE9OG"
"fOzcuYt8M1CffmIp8qDBI2jUyFFkO2YqHVk/SO9ztpvu+fneOp9LvXWvLvbRel8eoH99daDk"
"e20wvb01mIJuD6MIpxEU7WpLkS62FO02iqLdR1OsxxiKdB3F748weF0cHO96qFfwifXdvH5f"
"3NFp+aRvTg3+0ca+Se0Ss22qFB1ZsmjuXzmMgopQySFDPZgzATMh1LCWf6cKUAxKOFFA+T1V"
"UsimqDmRW9D8A4lH5JHUXJFxTulz5rQ+KwFAVsPTAnwggoULFwrQ/bsM369eA6CG4bUKfry3"
"atUqoQTg5UeNGiVAX79+fbNy5cqZsXfHD26lbN2Vnb18TnNzi9xs+bhDC+fMmaNk9mxWFWSv"
"bllT2Y0GshSgbyCAbm7WrkLpAv3r25Sa/FOnOnar5nY/vm/NLy7ntvzw5u7eNlFP9jbU+Rxu"
"TD6HGjLI6zPI6zK4a5Pnlpp0d2MVcltfRXLdUFnnuqGiFuayHlZB57ymnM55ZVmd2+rSBvf1"
"pSWPtaXJY3VJcl9VglxXFiPnZUXJYVlJur+mEO1e9gtNmLqQJk6YQCNHTxA3DX1w117ffvJa"
"/97ynXvYoaeOTW3h3UsWKy6DnIkAVsLYGPBi3cFXxfnvYlS6REkmiyJC+uMGpUFDhsk3KI0a"
"TxMnTqLxU+bSoU1jKOhyd/K93p+CHQZRkONQCmKwBznbUqDjKApwHCn53xpheHN9mM7n6nC2"
"Ybo310Zo31xnuzFC+/raMJ3fjRFSoMMYCnMdT3H3J1H8A9Wm8N+TKcRpvO7FxRFRl3f89mb3"
"im4uy6e0Od6jXVW7ujWLT8Lvgd9FIYYGyu8lfj8mg5rK71nB0tK8pJmsFJBfQAISuYXsGA8y"
"KfxjhPAllM9KAIizATZ4YgBxwYIF/3KbP3++MLxWCQCvcc3Zs2eL9xB6APj4H0ipe/fumtKl"
"SwPwYsGNErtn597iH9yMf3gz7NsH716GPUUlthqYq9bI3gTbT8O7NC+YP2d3m2olbdu1qr5w"
"+YwfDu9d19fF4dR4v4B7i+ITX62gpGezKMKhPwWe+Z5e7W9MD7fUIY+NtSSnVTV0jnbVtY6r"
"qmkdVlTROS6vrHNZUcngtrqSdHddZXpgX5keba1Cj7ZUoofbKtPDrfhfBbq7rjx5rC1DHhvY"
"1pUm9zWlyNmuhOSwrLjksLiodGdJccljdRFp84ox0oy5y2nG9Bk0cfJ0cTuvuJUX++yLDTps"
"afBQeSPOgcpmnIOHDKdaNW2E5weo5cVFxYVB4gsrnmk4B8dypcoIksDy4rF8HVxj/ITJNHHS"
"NJoxYyZNm72EdqyfIfmd7yq9vtJHCrgzSHp7Z6gU4GgrBTqNpEBnJgcXNufRTAwjKdhpNNsY"
"BvRYCuH3Qp3HiddBjuOYNMZLAQ7jDf63xur8bo3R+d0crfW9PoqJwlb39tZIKdhhNMXcm0SJ"
"j6eyTadk7v/oRzMk3zsT4m8fHOS3x+5nl6WT2x1u06LSwppVvrItmC9Hd/yO/Nvi9xS/r4W5"
"eS0mgxpsyC2UUVQCQgdjQrA2DhlUkJUpU0ZTo0YNTbVq1TRly5bVlCxZUlOqVCkNOxdNhQoV"
"hOE13oPh9b/D8N24VrFixTKw+F9LAAA8PP2nQA/Pj2RfgwYNzAoVKiQSdhp5kQn/kOY52HIx"
"n+cTgLeyZMBbVOa4EU+YEQNCWYvfJHs2y++rVSo+tP03NReunNPz6PEdtvef3poXGvtyjVbr"
"v570ARvY1lL8i3n09sYA8tz3ncFtfW2ts10VrZNdNZ0Lg959TU2D++rq7LWrsfdmW1uN3FdX"
"oburq5K7XWVyW1WJ3JkA7m6sLN2zZ9vMtgVHJoZNFST3teUkt9VlyW1NaT63FLnalSQXNsdl"
"xchpWREOCfj/q4vS5jUzaf6SNTRv/nyaMWu+2LEHG3lMnDQlY3uuUQohiF172HPjCAIA8LFi"
"EAAvU7LUR6y0WEEI4ON1RWzgweTQ6utW4jrYxAT7/82YNU88xnve4lW0feMSen2mG72+0pcC"
"WQEEOg2jQBeW9a4A/zhBAIEM+gCHUUwOsNHw9lKg4ziJgS8fnSdQsMtECnGdTOFuU1gJTKJQ"
"/jvUaTwTBH/PnZEUcHO4wffqUN0b2I3hWt9bI7X+d0YbQlzGUuyjaZT8fA6l8u+T/GIBRT6c"
"q310cWzokY297y+f1ulou6+rLKxasejQ7NksvsfvrSy0ssGiK4UQMC7KaGRCgEIQIYOZTAgY"
"TxYlihc3//rrr82QNEZeadOmTZp169YJDEAB438INaGKcfxX57cw5vHduBZyWcjBqUXF5X8F"
"ARiHEpD3AD3+/yegZy9vlt2MZT1zdh4+FuR4vaSVlTkSRbjpprYCeGSemxYqkLtrXZuy40cO"
"bLNp36YRt10vzvGP8d6cagjdRfqgHaQP3EIJ3qsp8slSCn0wV/fWcZTW63QP3cOdzfT3N9WW"
"HmysRY/s69KjjXXo/rpadHdNDXKzq0Yuy6swWKtIziuqSC4rWe7bVZVccVzJBLCaCWAtE8Cm"
"ynR/M9sWtq04VqJ7rAA81pZj4Jfl+L80y/7S5LKiJDkvB/iLktOqMuS2Mg/dtv+GNm+2F9t9"
"LVlmJ7YPw24/2Jhzxizj7bumC7BOUDb9gEKoVcNGgLxC2XIM8NJi7cD7Vk7s2IP3KyrHKhUr"
"CTJo2qiJ2CZsxqy5YpchXBfXRz02b9lKD07aku/ZzhwGDGSgD2GPz97edSzbeCaCcQoRjGMi"
"GMthAXt8J+HxBehlm8Q2WTbnyVKQ00S2CUwU42SyYAIIvGVLwXdGUIiDLYWwmgh1Gc0qgq/D"
"auPtnRF6v9sjdUww2rcOY3QhrhMp5tFMSvWaT+mvFlGa93KKfLQo1eXkWP+9a/vctu3bYlOd"
"GqXGs8pD0rGpMi5ACLWZDKojwWvJ40cjT0nmUdWBRrlvoUCB/OZ16tQxQx4MOSeVBDA2kX/C"
"mDXOTf2rcl74PlwP18K1/+sIwNjbw9DQ1atXi9efBL2ZAH1e/hELM+jLWFtbVOF4T/XwAH7j"
"vHlydK5Ts+y40UPabzmyY5zzE8cVoenB+wxS+H6SwnZTWsB2inyxikIfLdGFPFiiDXu8VBfu"
"Od8Qyt7L90J3enHoa3q6qzE93tGQ5XtDum9fjyV7LcljVXXJbUU1yZXNZXlVcl5aia0yA7cK"
"e3CO+VdVZWKowqqAbU0l8lhfhe69RwBVxPHe5oos+8vJnn9lcSaSYmx8XCmSgfyawb/zF7GV"
"9/adeMbeFlq1ZoPYExD7BWLH4fkLl4jtv2aLjTvnCbBiizFs+wVlYFO9JgO7AlWuUEnc/JPV"
"KleoKN4D6GWrTFUrV6Eq/L96teuKrcqwPyH2EcR1cX3UY/vve0S97p2dSW/O/kC+1/pz3G/L"
"wGe5z/0XrCiBYFf28uzZgxTQB7lMYI/PwGevH+w6RTYmgBBBBHwOqwKEBoF3RlPgbaEAYFLA"
"Lbbbw5kYbCU5rLClUL5WuNs4euc+nm0ChXtMBPkYApzG6Jh0tIEuE3Xv7oEQlpLBbw0ZWNWl"
"vllr8Lw2I/Sw/SDn0QO+2VK7eqlxeXNn76yRH0QiHAY7j1qsDqsgXLQwtyhsbm6R18LCMie/"
"n0EGRYoUMW/UqJHZkCFDBECRf0LyWSUANWdlnMP6Z3NgwAO+E0oA4e5/DQGoDVQlPr4XMmrs"
"2LGabt26abiT1TvprD4C+rIM+mpKhl7sumNuZtayXOki/X/q0mTFro2jrj+6YxeYHnpERzEn"
"iKKOU2rwHop8uckQ/nQtg32FLvzxUn3MyxUU98qOop8uZAk6it6c70rP9n9NT/Y0lZ7sbS55"
"7mwqPdreUHqwpR7d21Cb7q61ISYAYgIgl2VVyGUp25JK5MTmkkEAVTIJgL2/xwYmAPuqDHoZ"
"+Pe3VGTwl+f/laO7G8qzsUrYUJHPrcCfhwooTK6ritDtw1Po7KVbYh9/bO29bcduscMvdvQF"
"EFesWkvLVqwWG4dip+EFi5fJ6oAJARuMIm6vUbU6VWNAf9qqirsDqwurJs7H0aZGTXGcPGUG"
"rVm/SWxlju3CcX3UA1uSo15nLtwkj8tr6fXZHvTm0m/kf3sYKwEGvvskCnFnYPMRr4Pd+G+3"
"yQL4IW5TFZsmDCQQAjXgDGOScBzPYQUIwJYCb45gFcDhxW0+3h4ucgoqAQQ5j5aCXcZJoa4T"
"pFC3iVKYG5MAE0HEvYkUeX8KRdyfSlH3p1GYxwx96N1ZurD787XvHi82pPisJgq2Z9tCaf72"
"ugfXZgfuXDvg+o+d660oW7pQfx5fLTXKbkUIF6ytzKtZmJuVNdOYFeZxmFeMQ1kZiDChcOHC"
"ZhivGLdqGIDxrKpYjHHjvNY/gxPgDd8L/P3tCcAY+GC2rN6eY3c1kZeN2TcHgz43WyELc/PS"
"DPqqRnfQNbC2tmxbx6bcmOkTftx95cQCz8jX+xMp4SJR/HlJH3GKYnz3GSK9d2ojXm7TRXtv"
"NiS8tqd473UUB/PZQFHPlvCAGi75nO4ovTzUUnpxqBV7/tb0/EArerq3GXv/RvRoWwN6sLku"
"vD/H+TXJw646ubLnd1lWWRCAMx+dlkABVJYJwK6qDH6hACoLBXB3E0v+zRWE9H+wvTo93F6D"
"HmyrxuRQjj9TiOP+/Px9efgapen+9obkeN6erty6S+fOnaUTp8/R4aMnBQngyUJbtu8UQMRW"
"4dg2HFuIYztxdSdgeGu7NeuZACZR1UqVRRgAYNesViPTqssGhSCMAV+bz6uDW5H5WL9OPfEZ"
"PMxzy7adtH7TZtq6Y5e4PsCPB5agXufOn6NL113I/eZBenNlBJNAL/I59yP5XvmVVUFfDg0Y"
"sBzfh3hMp9C705kQplAoW4g7E4A7/+02nQlgqkIARgrAYYxQAAgBAm8x+BEO3GHQQ2UIAhjF"
"imEsq4DxFOY2kcKYZMLcJ1Iok0Cox0Qp/O4UtulS5INZFOs5n+KeLqB4/q3jXnBY8GSJIfwR"
"q73Hy7VRz1YZtAFbicJ3SxSxl8Kfr0+8dHiS57QxHXfXqVlqDMaXRp5lqG0ur0eoymRQGuMR"
"4xLjU5lhssS4xfjFOMZ4xrhWw1lVBfxPE0BWjw9Jg7+RwVe8vbhTzsLCAtN1SMjgRpISLMkq"
"c9/aqJ6e/27bsH6lcYtm9TnocmXVq7SIC1pKuUmUeJNSws5RtP8JXbTvYW2s/0F9UtAhSg7c"
"S4lvd1G87xaK9d7ItlmKfG4nhbiNl/wu9SDv423I6+h39Op4W/I61oZeHGzFKqCFTAC/N6GH"
"TAD3N9UhjzU1yZ3B776CJf4yJoClCgEslRUAiMBlJVRAVZEUdF+FJGB5lvmVWPbXoEc7bBj4"
"1ZkMSrG3L8LEUIQe7qhFL453pzc32GO9OEHv/O/Sg/vudNvpPl25gkd3XaXTZy/QMeXZfHiC"
"z+69B8XDQrbhMV3iyT3bxbMC4KHXizBhvSCI0aPHCRA3qFOfgV2b6trUybRabLXrCJkvrE5d"
"AfoG2HuAj40bNqY6NrXEyr89+w6Ka+1RHmeGeuAJRajX+YtX6Oq1q3TLwYMePLhL0SHPKS7A"
"gcIeb2Ngz6e312VS8L3Sm96yJ4e3D/OYxSCdkaEERBjgnEkAwUIBIAk4isE/UiQDxWuVAJxG"
"MmGM4VBiHH9+okIAkzkEYMPx7mR6d286vbs/m6IezqeoRwukqMcLpWjPxVL002VMAiso4dVq"
"SmQnkOiznqJfrtNHPN+gjfKy1yX67SAp8gBRzGFKDt6ldbow59XC6T8ebFS33DgOCdqqygDj"
"EeMS4xPjFOMV41ZRBeYYzxjXGN8Y56oi+GeI4G9PAH8CfBHbs3y3ZgaVvb1GU8jCwqwsFuGo"
"G2dYWVl+Y1OjjO3c6b32ud1Y550WdVlLOheSkpwoKeyaISboojYu6KIuJeyilBp+nlJDT1Fy"
"0BGKf3uA4v12SrE+26Q43+3s9TdTxIOZFHD9V5b7Hen1uU70+kwnBn87enXsOyaCb+n5oW9E"
"GPB0b3Py3MkEsLU+3d9Ym71/jQwCcBXyn70+PL8SAiAP4LKCCQDJPzuO71dX5djfhr2+DYO+"
"LAO+KN3fXJaeH2lPbx1mUaT3BYqPfEPJKWmUbuAoJS6NPJ+/Fg/wvHPnNl276SCe4Xf+gvzs"
"Pnjcoyy74X0PiKfyHhJPCsKTfvCUH4BUDRNAEMOG2Yp1AE0aNaEG9Room4Y0UEzeQKQRrEFD"
"sTNQ44aNxLkAf4umzfm9RtSlUxcmgEPiGYFQIbg+6oH6oF4XL1+lazfucH3viHo/fupNkTHJ"
"lKolSuJ2JcUGU1yQO0U+282gnUn+1wbSW+QLWN6HsOcP9ZgphwDKjIAgASYAMUUIc+BwAglE"
"Rw4JHEZmhAAhzqMVApgkwB/GqiLcY4pCAJD/s/h3nsvgX0jRnkso+slSinm6nGKerWBbRrEv"
"7KTYF2ukuFdMAm/sKYnHRkrATkrw3ylF+fyui/LZoY3z22UwxBxjx3KSx9N+reuVhd5zpnTf"
"V7NaSVsG/zcYlxifYrGYuXiKsVAFGMfm8jS0yBX8f4ngb0sA6nSeunLvk8C3sMRcPVZuFeWO"
"rcRgV2+MaVisaIGe/Xu3XX3t7IqHKVFX00nvTlKqG6W8u22IC72pTQy/pU+PdqT0mNuUHnWD"
"FcAFSgw+LSUGHpUSAw5LCf77KOHtHiaB3Sz3l/FgGkJ+l7uR34Wu5HupG5NAZ3p9uiN5nwAB"
"tKGXrATeVwCNBQHc21CL3EEAK6uRG2J9Nf6HAgABLK6sJAIriBDgHmYKNlZniV+CpX85enGs"
"I0vgNRQX8oCSk+MphQGSmCpRQnIapSQnUnhYCD196kn3790lN/e75ODkKp7Ye/X6LZkExEM8"
"L4pn/p04fZbj7zPsiU8xKI+LB4zCM4MQ9u4/TDsY/AcOHaN+fQcwyOtTy+YtqGnjJtSsSdMM"
"a87Wokkzas5AbyGsBX3drAWf+zW1atFSWOtWrYXZb96eoUIAfNRDPLSU64X6oZ4Ojq6i3vfv"
"36dnz57Qu/AwblcSJSSlchu1xM0U7UyOfkVxr08zcOcwGQwi/xuYQhzPYcEMeVbAaZxMAE4T"
"FDLgoxMIYcx7BBAsCGD8hwQAuzuVwT+HIoT3X0QxngD/Cop9vkpY3IuVFPdyNdtaDgfXs1Ow"
"l+Jf75ASfHdKGCspgfspJfggK4ADFOu/Vx/tt0+bEHjQIMWfIUo+T8mhh9OvnZz9sP9vrVYX"
"K5qvp0ZZvozkIcYvxjHGM8b1p4hAnSlQE4X/dQSgTufNmjVLZEfxt5LYU4GfzQj4xaytraow"
"c9aWWdWsZb06lUZvsBtzLvT1yWiS7pKkvUdp0S5SQrizNinSVaeL8yBdvAdpY10oNdKBkt/d"
"kJLDr0oggKSQM5QUdJwSAw4REwHFvdlGYXcnUuD1nux9fmL7mfwY/L4XGfxnO5LPqQ5MAO1l"
"AjjC8T8IYF8LJAIFAYj4f60s/92E/GdPv1j2/iIRiGnApRX5iHi/Nt3dWIPubihDnrsbUYDj"
"DIoP4jqm8OBPJ4pP0lFsXCwlxEUxIBJIp0unmNh48n7tT89fvKKHj56Qx9374jHgDg5OdOu2"
"g3jC7+WrN4S3BfDOKU/zPXVGJoPjYGV2BwAAIABJREFUp86IhByk+ZHjJ8XDPvEw0Z4/92SA"
"N6NvsR/g163om5bfvGetYQrIcQ7su9bfURvsRdj6W+rQ/nv6hj+3ePEy8WRiPHwUTypGPVAf"
"1Av1Qz3h/VHvh4886dkLL26PH7crjtunFcBPiI/hdsdRXAKrAia+tLRkSol6TlEvdlPAnXH0"
"lokA4IcqCAb4jQggSCgADgkcRskE4KQSAM6f+CEB3JvGBDCbCWABRT9eIsAf8xyAX0exbHFe"
"bK/Wi2O89waKf72FEnx/p0T/Pews4DD2S7BEJoLUsCOUFn6CUtkSgo7rYgOPa5NDT0pS0gWi"
"1AsU/GJH9MaVg8/Vq11+NMYtxq+lpUVtLE/WiL0PM4ggm0oEwIG6ZB34UGcN/isIQJ32wPtg"
"N0yP4E68ggUL4oZa3GFnbWVpmQvZfP66r6y4o/A8PX5dl99o/0On5gsunba7lxrnyHDxJF3S"
"PUqMcNUlRXnodAmPyJD0mPQJDyk99h6lRrtKKZGOUmrkbVYE1ygl/Aolh11kAjgtCCAp+CTF"
"8I8c4jqcAm78wgTwCwVc6ykUgO+FH+jNhS5MAB3I5+T3cvzP3l8QgEgANqcnu5rQo+0NRfx/"
"l+N/zPmDAFwh9RdXknMAyAUsr0Tua2xY7vN59uXIc18zCr2/htITg0nL0j4+WU9R0TEUEx1B"
"ifGxlJqWRjq9RAaJKC4+gfzfBpC3z2t69vwFPXr8hO7df0h4uKizqzsrARe6fcdReFkA7srV"
"mwKMFy9lksHZcxeFh4bhKcAgBiiC7t16CDC3b9ue2n7Xltq1afeBtW/bTrz/Pazd99ShXQfq"
"+H1HBn8H6oon+vI5o0eNZpl/W4732eNfu35b1Af1Qv1QT9QX9Ub90Q60B+1C+wzcBzqdQbQ7"
"MSGOYmMiRX/EJ2kpXcfvpUQySZ9icDNJ3xoi5wMwLeikhADIB4AAHEfJyT+AX+QAxvJxnJID"
"MCaA6RkKIBre/xl7/hcA/kYGPpLAmyneZwvFv9rER3tKeL2VEt7spEQGf2LAAbaD8jHwII+h"
"I1JSyDF2LMcpPeIsaaMuUFrEOYoPPqGLCzymS486yw24yk7oZPqlE3Pu/dCx4QKMY4xnCwvz"
"OlYyEXyF8Y5xL1aoMg6AB+AC+ABOgBfjVa9/GwIwntpQCUGV+5gWqVu3rhl/3lz+Gius0ssj"
"S33Lygrw62XLZt1pQL+Oa+4573ot6R9JJL2g9LgHhoTIu9q0+EcGQ8oT0id5kjb+Ef//oZQW"
"d19Kj71LaTGulBrlQKkRtzIJIOQsGyuAwGMc9y2iUBceUI4DKPB2Hwb/T+R/ubvs/c93ETkA"
"n9PtFe+vEMDh1nL8z97fc5cs/wUBrLNRFACTAHt9V8h/4f2xyq8u3dtSnR7tqkvBHstJmxxG"
"eu7A2PhkiogIo2gAPzGJUlLTKY1HvFanY1DoORRIovDwdxQQGEQ+r9/QS69X9OTZc+FF7zOY"
"4FFd3TzIyZnVgKOzTARQBDfl0CCDDK5cowvwzEwKIIPLV6/T7j37qFOHTtSlcxdx7Nyx80et"
"S6fOIs7/oTPsB+raBdaVuv3QlXp0607du3ajXr/1ojNMLrf4+jcAfPb4qA/qhfqhnqgv6o36"
"ox1oD9qF9qGdaC/anZrOiiCVVQD3R0x0JPdPOCuDJGJ+IEM6k6TPMXkKkL19iPNkCroDz696"
"fznzH+w8NjMJiFkA1wmCBMLdJ7H8n2ZEABz/P1nOsn8Ne36An4HvzWD32cZef7uwBFaHCb47"
"2HYpBHBQUY6H2Ikc4bF0nFJCT3BoeZKdy2kJlvIORHCetNEXedydM8QHn9KmvjtjoPRrHJ5e"
"kR7cWfN6QJ/v1mTPZtUJ41sQgZUFdkkqivFvaWmVQ8GDOfABnKhhgTGOYMDX34IAVBZTGwCZ"
"owDfwtLCIhuDXWyEyfKoPMt9SP263EEdBvTttObZg8P+RC/IoPei1FhPfXLsE50++QV35gtW"
"AE8oPf6RlB7/UNLGPyYtq4D0+AesADyMCOCmTABhl9jOix8w4tF0CnMZSqGuI2QCuPUbE8DP"
"9BY3sFxk8CP5d66DTADH25HXERn8L5QE4JPdTcQCoIdbZAK4BwJQcgAiCYhpQAb/vQ11mSSq"
"kPe531jSviSUhKRkEdNH8QBPSExmAKRSckoKpaSlklarJe5nAYa4+HgKfxdBgUHB9MbXn155"
"+9CLl14CRPCkDx4+onv3HpC7xz0G2l0hsx3Z495hAIIMIL8ByOs3b7NXZs/MR8Tlt+440caN"
"9tSpYyf6GXcHMoh7sBr4qHXvQT92/1HYzz1+Euf3/Kkn/fLzL+LYp1cf+rHHj7Tj950ixsd1"
"XVw9BPBRL9QP9UR9UW/UH+1Ae9AutA8qAO2V261lJSD3R1JyCiUkJHI/RTFRhIm+QtEmBlL4"
"gxW4W5A9/iQF/KOFCgjG4iI2LAWWCWCCIIBQsQYgCwEg/n+y4n0C8GHQv/5dePyEN7sE8BP8"
"YLszCCCJx09S4GH2/kcpxYgAUsJPsZ0mEAAbE8EFKT3qMunjrpI25golhp/XpYSf10tpN5nN"
"btGzu5v9B/RpAyLoIBSutWVtjH+NSHJb5GETYQFwooYFwI+qnr9oAlDvxFNlPzKb6n34lStX"
"FlN6oDiO67GCKh/HQCUZ+JjKq8ud0LrbD60WPbl7+A3RKzLovCgl1lOXEvdSR+lvSErzYeCz"
"Ckh4ImkT2fMnPJaNFYA2nuV/3H0jAnCUCSD8siCBhLcHKPLBFI75bXlAjKJQ56EyAdxkAriq"
"KABI/zMdWP635/i/HRMAe/8j3zIBfCMTwL6vFfmP+f96dH9jLVkBiFmAarISWIkMfz16uK0G"
"BbktJsmgZS9noMiodzzo2avFJ4rBnZiYIDygDH4d6fV6AQTuY4pnAngXGUkhIaH0NiCQXr/x"
"E+CBB332/CV5PnnGwPKUiUBRBG4MOhcGH8jAydmVHB1dOAaX1QGIAWEC3lu8eIkANQD8a89f"
"6LdffjWy3zKs16+wXsLL9/6tN5/P1rsP9evTl/r27kuDBgwS7y2cv5Dr8IjB7053GfT37qvA"
"9xT1RH1Rb9Qf7UB70C60D+1Ee9FutB/9gP5AvyQmyv0UG5fI/faOoqIiSY+YQdJTzKvDYjGQ"
"vDhIIQBnVQGMEwQAMlDXAoR7TCWs/HuHGYCHcylCxP92LP8R77P0f7VFJgAB/t2CABKNCCDp"
"7YEPCCA55BgTwHH2/ioJnBEEkBpxnkOBS5QWeZnSoq5I6dFXSR9/g6R4HosRl3XJ7y7qDOm3"
"GUaO5Olm/6Zbl6aLMO6VUBerVUsCF8CHlQwwc+BGxZA6U6DiC3j7oghAVQBqvI8bJBDTFChQ"
"wMzc3NyCG4bbLRWvb1mJGy8elFm3TtXR1y/aP2DgSwadDwP/iS41wUtP6b5kSPMlXbKPpEvy"
"kkAA2sRnbE8Y/J5GBMDeP+4uE4A7E4ALE4AT/xjXhSW83U+RjzAIxrMXGM2eYTiFOg1hD9Jf"
"IYAfyf9SV5b+mPr7no0J4DQTAOQ/e/+XDP7nB76mZ4j/d4IA6gsCwAwAkoCYBhQLgVZVowf2"
"DVgh2FDoww2y19Km0TsewBFR0TyY4yk2No4HtgJ+9naIf2Xpb5AJID1NDPzomBgKY5kcHBwi"
"QPPG14/j5zfk9cpbeFPE0zIRPGGJ/ZjuP5DJ4C6TgQeTgZu7rA7glQFOKAS8njp1KgO6F/Hv"
"Rf369qP+/fp/aP3704B+A2hA/wE0sP9AAfZBgwbR4EGDaejgIWxDafjQ4cLGjhknCAYyXwb+"
"UwX4L0Q9UV/UG/VHO9AetAvtQzvRXrQb7RehAPcH+gX9g36K4/6KZaKIiIzmsCCCdNp00a9x"
"vmcp2GGUmCEQIYDzGGEhQgmMFSZCAOQA7k7n334WvWPwRz5aSJGPkf1fzQTA3t9Llv+ZCmCX"
"EQEwGfjtYeAfkKW/IAAOA7CGhAkgGQTAJiuAM5T67hyD/4IC/quUHn1NWFr0NUkbc00yxN8i"
"KdGBUmJu6pMjrzIROLIicJRunF/2oF7diqOBA0tLczhChAXYHj4P8ALcAD/AEfCk5gW+SAWA"
"eEVd4ogK4iYJRfJjRRSWSubjBpVgry8W7+TOnaOL3dLxx7TJj3kk+FFa/AtdWuIrdge+7PFl"
"4GvZ9Ck+pE/2YgXw3IgAVAXwkO2+EQFAAdwRswD44SI9Z/EPP4Ui7o2jMA9bQQAhjgM5juwj"
"koBvr/Qg/4s/sPzvSK9Pf0gALw62pOci/m9Gnr83psfbmAC2sALYVJvurQcJYCVgdXq4uQGT"
"gw0FucwTg1TSpXKcH8feLkoMeIA/nmVvUlISD/BkjnlTKY2lv86IAOAFk/i9OCaLyOhoARZ4"
"zMCgIPJ7GyC8KBJpXq9kRfD8xUuW2EwGT5/RY88nAogPHz7OUAeqQkAsfuuWA40bO04Ad8Qw"
"BvCw4RlAfs+G4f0RNGL4CLJlGzliJI20HSk2/UDib+zoMTRm1BiaNGGi+P+Rw0dFfR57PmXQ"
"vxL1wt+oJ+rr5x8g6o92oD1oF9qHdqK9KgGgH9Af6Bf0D/oJ/YV+Q/+9i4jkY6xQVSgx3gdE"
"GCAWCYkkoBICKOEACCDcY5ri/dnzP1rAY2EJRT1ZSTHP1soEAO8PAvDephAAg953DyVC+jP4"
"E/33ZyiADBMEcFQGPxQAy/9UEIAAP7z/FSaAayz/b7DdpHQ+6mL5dexNSRt7WzIkOZGUzGM0"
"5o4+LeY6d4A7q9oractm9zyWO1f2Lhp5JWst4IRf51dwYwkcAU9qiA2cAW9fBAEMGDBArHdW"
"433cqGAk+a0tzM2xkKcgxzcVsmWzFltct2hed/Jrr4sBRAGUluSlT0vw1pMugKR0f9njpwD4"
"r/m1N+lTvBUCeJGFABTvH39PIQA3So12EiEAEn9RzxZQxBNM/Uymd3fHMAGMoDDnIew9kADs"
"RQHXEf93Iz8QABYAceyfQQDH2wjv/wLef18LerqrKRNAo4wcAKYBH2ysTXeZBO5vqEOPttUj"
"r5OdSZsSJQZoMseyYe8iWb5GiYGLQf8BAaSnvxcCAAjwgjgH50cxWBAvh4aGCe+JBBoABY+K"
"hNor79fCywJ0sjJQCeG5AKTnk6eCDPD/c2fP02gG8UQG7tgxY5kMVBv3gY0fN17YhHETaOL4"
"CQLskyZOosmTJtOUyVNpKhv2IJgyeQqtXr06ow4APeqF+qGeqC/qjfqjHVEq+Ll9aKdKfGoI"
"gP7ISgA4H/2HfgwLjxDvoejTEzikm8/gh8cfr4QAsvcXSUBMA3pg5Z+c+FPBH/V0lSCAuJeb"
"PiQAXxDAXgH8RP8DwmQCUMKAD5KAp2Tws/eXCYDBHwmvD/DfYrvNwL/FBAC7Tbr4OzxeHSVt"
"vJNkSHYjSnFjh3VHnx57XU9RB+mZ0+KA5o0r4ZFpja2sLOoDL8ANk0Ee4EgNCYAvNS8A3AF/"
"n5UAsM4ZTIQYBbfqVqpUSdywk03enUAs5mFWq84NaWBpZdl+5bLxR3VpL7UGvR+lxHvppPS3"
"7P4CGej+DPo3Aviy+cgEwODXJ78krVAAT40IgGN/4f059o9FZzoLAkDsH+O1nCKfzeMffgZF"
"POBY8O5oQQChToMp+E4/lv+/yPP/KgGc65BJAKfa0ivE/wfY++9rLrw/4v8nTADIATxkBfDA"
"vi6rgLqsAmzo0VbcHViT3nluFYOT2EtFx8bzgA0Xgz4m9iMEoIQA6TzwjVUAwCBIgM/B+fhs"
"pEoEYeECUEikQVL7+r9VyMBXSG3E2vC+aqggZhBYHXjz+3v27BXgnzVzFk2bMo2mT51O06ZO"
"+8CmT5subAaMQT5z+kyaNWMWzZ41m+bMnkNz58yleXPn0Xy2RQsX8XE+Obu4CrC/5rrgGKgC"
"n+uLekcqfSDaz+1C+4xJD+1HP2SGAO8TAD4bpSii6Jh4kQsQidWAS6wCbMXCH2wwIucAmADc"
"JsjLgO+y93+4QMj+SID/2WqKfraOYp6vNwoBtnEIsIMJQM0BwPPvU0hAjv1FCID4n8EvkoCh"
"LPvDTivS/6xCABcZ/FfZ+99gAmDwx97JMJ0wEIAD6RKd2FzYXCV9ojPHfR6kT3CQIr136dKC"
"91BywFbdwmk9jjJ0vjc3N2tgbWVVQyMWEWnyKniyAL6AM+ANuAP+PrsCQIUgT6pUqSLAzzIf"
"a6Cxbr94NmtrcZNO7ZoVh3i4HPYiCqW0RG+9LsXXQPpgjvPfSvpUf8mQ6kf6VF8BfNm8mQBe"
"CfDrkxn8Sc/eJwAR+3sIz4/YPy3agb3/bYr1Wcs/9Hz+wZH0mUYR95ENHklhbkNZ/g+goJuK"
"97/K8v/SD+R3oTO9OcsEcLKtAL/38W9l+c/S//mepgL8njsbk+cOBvr2+u8TwIZaDP6mTBL1"
"KOndY9k76dI47o8RCazILASABJdKAHIYkKkCMknAwIDQinNwPhJmKhFACovQQFEFIIMAJgPM"
"r8uE4C+k9+s3vsIbe7NKADFsWL+B5jKAZdAygOfNl22ukfHfC+YvyLCFCxbSogWLaPGixbSE"
"beniJbR0yVJasWy5sNWrVtPypcvp6JGjDPYwAXyAHvVDPTOBHy/agfagXWifCv4M76+Vvb9K"
"AHK7MwlAJUHkA/R6OReQFu8rA991oggD5GnA8fK9AIj/781WvP8K4fmjn68TBCCD315JAm5V"
"COD3zCSgIv8FATDwsXAsKegYg/8EJYWcZPCfYfCfFSbA/+48E8BlIf3ToiD7AXyHDNPFwZgE"
"4h0Z+M6CAPSJrmRIcmFzk1gZSCnBRyjOb58h5vUOHcXsJ9fLi71tqlcYCtxks7aqbWYmNjzN"
"b21tDVxZAGfAG3D32RSAukUSYhDstFu+fHkBfn5PBX+p7NmsscFC426dmy9JjHmUKEnBlJr4"
"UifpAiUJXj8tQGICIGGCAN4o4AfwX5GWwQ/pr4f3T1LAL2YBMPUny/70WAY/x/3p7P1xg0/0"
"83kU9ZzlP7w/x//v7o2lcDf2/q6D2Pv3pSDE/tcY/Fe6cfzfhfw4/n8Dz88E8Op4a/I62ope"
"HmwlvP/zvc3o6e4migJonKkAEAKABNhwc9Dzwy0pNfa1LAD0WopUCEBVAGoOAMkvYxUghwJa"
"AQJjJQDT6fSUlsbA4HAiIyaOk2PiSJbEKhkAdIIQQkIoKDhYxNwgBn8mhCAmCSQKV65YSavs"
"Vonjn5ndSjthOB8GoK9ZvYbWrllH69atE2SyacMmst9oT1u2bKFtW7cJksFCHhGrG7UX9Ub9"
"0Q60R22b6vll6a99D/z4DPpJzQGoCkAQamQMf1YnJ1mTQhjwuG14QuYsAO78EzcBTRUEEPlo"
"MUt/O3YGa2QCeL6BCYDl/0t7ZQ0AFMDvRrMAu+UcAFTAW3j+Ixz3HxMLyJJDTnPsf1bcXJYS"
"LlvquwsC/KmK90+Pvp2FAO4oBMDgj1e9v0IAbBKHAtrYmxTvt09KDsRNagdYDezU6cL3UpTP"
"zsRO7ZstAX6AI8ZbKeBKwZcF8AbcqTkA4PGzEAA2JKhdu7Yq+1G5AvxWaWYuxPstF88ZtJ8k"
"f9Km+uu1Ka/Z1bHXZ9mvZ89vSAuQwZ/mzwTA3j/1tRzzCwLw4h/5hUj+6QH+DAJ4TOkJmd4/"
"PcaBjaV/2FmW/kv4R2bv/2Sm8P7vHk4S8X+46zAKce5PQZj7h/dn8PvB+5/vRL4iAdiOfNjz"
"vzrG4D/cguV/CwZ/c3q2p6m8AEgogIasABqIHEBGHoAJADcHPTvUklJi3pASAzBQE+SkV5Sc"
"BMyqAj4kgfSMcMBYDQgi4L/TtZnxcVbvKBOCrA7gJXFdGMCP/zvccaB1a9fR1i1bM4C7aeMm"
"2rghq20k+032ZG9vL46b7TfTls2bxecA8u3bttOO7Tvo9x2/066du4Qd2H+Adu/a9X/cvQd0"
"1NXW/k9TuddOR0BpimJXVLogCIKFooL0poAIijTpvffee++dAAFCSAglgUACKRDSe++BEJLn"
"/+x9vjMZuFzf9/eudblr/bPWXt/JJJMyM89nP/ucfc6Bq+s5HfcQQMn/lmWNc8jfnffgYeHL"
"/2ez/ba631H8j///kvR/ktkUeX7lIzMlHGGug3XZb6Rb4UrAGB39H4n4KywBr0ntP+cRAIgD"
"WE4ASP2/GulB66z5f2sQ0FYCKAB2agdpdtR+bSbLjhHhH2EcloYfiv8YQ7r+nOlAmf2Tz+r7"
"8WEHQPGnUfzp7jb77wCAizprkCG/T9aphG0puBezE6mhW/MzwjY8yE/ci/F/9d5cpGixRnTV"
"H1FzVURfls6Ki+5sG4I8UQA4ngz00ksvyYaJxUuU0KWPsrGiTfyfr1r0x1Gx/NlZd/hOiORr"
"FyNiL2DdLxAoFD9D7f9dyf4BJrTudwSAEb/W/mky8HeRT7a7PuH3SN6M4CVI8Z9sHIANAKz/"
"46X+9/hZARBlA8CJtpb9LwRA4C7J/o3gv60B/DbVo/g/MwBYzzJgrbUL0MqPtBNQXIA6AYbP"
"2rq4sbUhUmNuGP0XPNA3t2TmhMRElgNJ9qz4dxAwYwKFbuBREBTWy7m4K6KxnIGZN8+wOwQR"
"TUqKyZoCgAP7D6hYN23chHXr1mP9+vV2AT8a8jWJDes3YOOGjfqYzZs2q9C3btmKbVu3Ycf2"
"Hdi1cyd279qNvXv2YP++/Th08KD+r7m596225n/9223Cl/9P/k+t+f9G/DoDwP9Fnj/52fJ8"
"5mrTlAHArZsXEXr2dwMA90F2+x9zcbip/69MoP2fTvs/1wLAQiQz+6f6LzMAuLWK2X+d1v1m"
"BuARAITv0O5RA4B9pqOU2f9u3FEDAc3+1sCfZv8zFgDccD/NneGmkZd+3kSGB8V/UeNB1iWx"
"/wTAJR1AzJBBR/6uTDqOjAhpM96n7euJdzbkIvsIls8fdZRq+9zSlUBAZghkn8Lilv4e0uUT"
"BQCjWPHixWWUUjZRrPT00yVU/GsWDzwORPKFDc4VCBTkRRfk5xrrX5Abbgnfqvs17thH/E3d"
"7wgA2+i/N8Oa9lMAnNMSIDtmL1/Q6UgNnG4A4Du6EACXWP+f72MA4NLZLAA60dbBAbD+l4E/"
"AiBwp3EAfrT+N9YXAkBnAJj9BQCyGYhAwFtAwNvX19WF3/bGiA66qLmpwLKo8kaWN61kL5sT"
"cISAiNYGgYdBkKtTYo+C4HGCkvnzXGZREdNdyyFIyM/OybmLSNble3fvwb49e7GHgt2ze7cK"
"18Qu7LJit2PsNt+3Z4953P69+wiR/Th44ACFfghHDh/G0SNH4XTsGJycnHDq1CmcOH4Cvr4G"
"gPJ3qQ+y/mZH4d9T4T+c9Qttf8bD4rcyv4Q8j+n8eoEhLB1GLk4e241I2TpMxgDOmxZgsf8x"
"kv1p/xUA16ZbDmA+xb/YAoBkf5v4N1H0FHuIxCZrFkD2itiCrPCdjwWAiP9u/FHN/jrwl3iK"
"ADhjz/65qSL+8wza+/QLeGBFXoYI/7IVnsin+POzPa1O1Z1aZuh6lWgR/4EClhsF9/h7EoLW"
"5yLLCasWjj8uunrqKdWX7FP4ouhO9PffBEAxfjxlNfhU4B8nzT0NVsztfQS4wxc3jOKPQ35e"
"TEFBXhQ0BAD2zG8J/26QQ+3v/zcAuMpg9k+/ZADAJ1uW/maEriAAZrAEmGY5AAHAcL4J/rAA"
"wPr/XFc6gE4WANr9CwBuPeQA6usA4A2r/hcAXF/9sYHAqjoqfAGAwOA6AeG383NEBJ5HqjVK"
"XWDeqUjlGzracgIykPVoOfCoG3jUEZjS4GEYPOoMHoIC62zJvlJz5/O+mzdv4ujRozh54iQF"
"60TBHjdXivfYI6GC1q854Ti/78Tx43zcCTifcMYp51M4ffo0XM6cwVmXszjn6go3Nzecd3eH"
"x3kPXLp4EZcuXEA6HYh85Mnf+6Aw29+zIPU44duy/r/Yfj5fCYlJ+vwZ6y9QKVAAuF/wwoE9"
"Gyn4Ebq/oMwExEgw+8cqAMYqABK0BJhtZgBo/1P8ZPCPdf+tdbT+FHrwNgqedX7odsY2HfjT"
"KcCwrQYAuoBsz0MlgDiAu/FOhdlfAKDiP6fZXwGQ7sG4yJBRfgo+g9dMEb4X44pGfvYVdQJZ"
"0Yf4e/bz9xzQVavZ/Fx+T1Y0wRB9sOB+0nEk3NlIap7BsvkTjoi+aPVFZxVEd5b+iv03AKDW"
"nyE79ZR+5pkScnjGp6N+b7UWuEyLGknxx/MNG0fxqwOwABBOAJjsn6/ip/Dvmro/Lyfg3wDA"
"17L/VxiXrfrfQ68yEJMeNIdEn80SYAqSb4xFog/fBN5DEec1CHEXZf5fANDFAQDiAGQA8CsE"
"H2z5MADEAWxuoAOAN2TwT+p/2xiAlAGrTFyzrj4CgB3GAcRExyItOcEaCzAUkMxlRsYTNJsl"
"8c39aEkg3/MoCB6Fwd1c4wykvHgcEByhIB/iDDw9PVWk58+f16u7m4Tb/xDu9seIuC96MChu"
"EfnlS5fgefkyvPhzJa54eWl4X72q18DAW/Y5/X8n+oeE/2jWlwE/+yCnGc9Iz8g0z6b1f/n7"
"+2PnnsM4dmg7HcAwhYAI34j/Lx38k+af+CtmCrAQAAsNAAJZ99+m7Q8Wse+k2Jnlw+RqQJAl"
"tX/4dgcHYAGAorSVAKbuF+vvrCP/MgOlyYhuVEIyv4jfAMCTYQk/+6o9Cu5eV0hkRfLnRh8x"
"EcOIPaYrWOV2Fm9nxh4tyE12RmLIZkLACyOH9l8rOqMGRW/SNSgrCvUwkycNAMJH1zS/KAdr"
"8PpBq2ZvjcxP3pufezeMPjgR+Q/iWbLFMSlaALgfyQizAHCHALhtDfrd0rq/EAB+Gv8KAMsB"
"aPY/r9esyI18QWeqA0j2Y/a/MZq131+Iv/on3wwDLQD0RJRrZ0Se7oiIkz/oDEDI0a+Z/Vvi"
"jgwA7mn6sAPY7DgIWM+MA+h0oDQDfap7Akh4r/5E9wjw2/E5om5fQFxsAqLDg5GanMRSIB+2"
"D7Hnks3kDS1uIMnmBlIeAYGSu9HPAAAgAElEQVQ1U/B3MMgRGGjYgGAcgpQDkv3v55puOVlM"
"I2L19jbivGqJ9e/i6pUrGlesqwbFLQL39vbGNe9ruH6Ncf06fHx8GL64Qet/48YN+Pn56VV6"
"/UX8tr/5UdHbRvgftvtG+PK8yOPN85Skz5uj+EPDIlhynMb+Q8dx5MBWs4OQBQBp/In1HM0Q"
"+z8OCVcnmzEA+yCg5QDU/m+0AMC6O4xZXiGwSyGQFWaJP3wXsil+nQGwA+CIlf2tgT9a/3tJ"
"LgTAOQsAkpQuqLDz0i/T9l82AMiUbH/VAQDeBIAvH+fGTE+xxx63R07cCY3sWCcT/H1Z8U4K"
"gdTIfXl5Kd75rVs0GSl6o+MW3UmHreiw2JMEgBQdJeSEHZnr5+33ypR6rk3gxSmRuOfDbJTE"
"lBTPawLsALhv2X8FQPAjAAi0AOCPPAo/TwFwU5t/8mj/H9gHAOkA7NN/HvrkZ4YupQOYzfpf"
"ZgDG8QUfSfIPU/sfJzMAF35BjFtPRJ/rrFOA4TL/7/QNgg+3QvCBLxG09wvc2v05ApnFA3Y2"
"VAD4Ww5ApgK1E5AwkN2ADAQYVm+AAEBLABsAYuIQGxWGmMgIJMZFI5dCtX1Ihs7IlAUuiYgR"
"R+AAAsl8KY+6gkdg8DAQcgwQbFC4a4OCBQYK8Pbt2/ClQG9SlL4+Vvj66n0SImDfh8LX+voN"
"u6hvatxkKeEHPwk/f83A/gEBCJCFPoGBuHXrFm7fus3fF4SgoCCEhoba+x3+TvTG6hu7bxN+"
"XFyCzmbI85RvAdQmfvl5vjf94cryY8+BYzh6YJtuHqoAEPHT+ov445j5RfwJ9uw/3xoAXEyH"
"KPX/mscCIFNcgDgAGfzT7G+Eb2z5QZOd444RAMcfBgCz/z2x/mr/PTQpycY0BgCe/xYAsqQ9"
"J8GFP1fEbiInztlEvLOBgCxn5+/Kjj+hPS5ZCcfzpeQNvHoisnTpF9uI7qweAem2LWHp8okB"
"QEf95QAFXj+eOfbbncg5yDdlBK1/kpX9BQDxlgOw7H9uKAFA8d8LIgBs4ncEwE0T1tx/XuZ1"
"hrfJ/uleaquUtmketGOHkHFnngWAyQqARJ8RSPAeovY/9jLrf4/eBEAPAwB7+y9r/8Nf4c6B"
"5sz+TZj9GyNwO8W/oyEC5LqloXEBjBsa0hJsg0Bdit6AQFyADx1CIQDiKf5QxEVHEQThvEYi"
"Iz1V7brtQyx7RmaWjm7rlJ0uGEoqdAWPwMBx0PBRIDzqEmxttmKhRZwiShGoRKAtAgOtuPWv"
"YX2vLQQiEkGWuO/cuYNgRkhwMCMEYSGMsDCEh4drREoPQkQE4vl/qejTMuz/w+NEL39nnGX1"
"JeNLSZBnDSIqNK2xDRsAbvoHwMXFBXsPOqkDiPIYwdd4lBG+in8CS78pfP2nEQAztAEoyXce"
"km4uoPiXMmSsaC0ygjYjI2S7BYA99uxvACDi36N1eXaU1P2HVfy6tNwOgJMEwCmdfZLsf8+q"
"/W2uVMWf7ukAAK+HAJCfw/c0y4LsmJMUPsUeK3tXnKLwT5vQ1azOBADv5+/K4e/KTjxTILML"
"qVHHWFvdwqxJQ3eK7p555um3rNm3kk8MACVLPiM1xz9LFNdFC+9Wf61013i/GWm5aef5bSl8"
"1eL46lnZ314CRFoAkMU+QZr98+8GPjTtZ7K/DQBm4E/En5d5RUf/NfunSecfn3Q+4dmRm1T8"
"aSwBUv0nWvU/AaD2/zdmh346ABjtyvr/7E+0/+0RptN/rXDn4Je0/18gaA+zPzN/wLb6CNjR"
"gABohICtjXQdgHYDWusB1AkQAj4b6lsAMGWAuANHAMQSALFRkSr++NhoJNAJpCYn6n54DxxA"
"IJlNsreUAUYEcVa3W9K/OIPHAcERCo+CITo6GuE2YfIqIg0LlWuoRqh1DQsN1a+F2r8nVL/P"
"PFau4YgIj1BRS4jAoySiovR3SMTIQp+YWMRK6684G/kfmMXl/7L97fq/2EVvZXt+n2T8JH4u"
"+wCYAT7zIXskiP2XcQzbrIIA4MZNAuDsWQsAdAAXCADPsUb4zPzx3lMRT+EnSlwXAMxWAGj9"
"77+MIQOA0vCzlQDYodnfOICdxgGEifXfXQgAHZA7jJyYo7q5TI5kYpv4rexvpqLdHQBwQa1/"
"Ht2qhNb/dgfgbc/+Ao6sGLH9p/4NAAgHcQL8XTmJ/JwOwKx1OV2Qk3gJCSGX0qpXrdS1iO5I"
"XFx0+E9Ll/9xABQtWbKkTPu9UPKZp2R7ow9mjGm9DambkZMeyAI0jYKPK4BmfhF/LCPaAkCY"
"AsCI/xafCKvmzzE1vxG+rz3ua/a/qrTMtcSfSwoqAJLPGPt/ezpt3RTWd2P5Yv/FF38I4r1+"
"1+wfc+FnZv/uiD7L7H+2AwHQjgCg/T/C2v9gc9zZ1xS3dzcuBMD2+loCBFgOQCCgANhsg4C4"
"gAbwoRNQAKz9GwBEMRPGRCEpIU63/kpLSUJmhqyDv2t/U9s+JOuJrRfR2Dr8RCDaUmsbONQo"
"FJVt/EDBkJquIVBIpshkAU4syxG5alCk0TExev3biHEMEbUl7Nh4I24HgUskCqwoYA0HaCXb"
"/14jeoGa7f/SBil+7mjz9TnIy9M+BtPxZ9yAlDL5jgDwcwTAVj1DINZrvBG+in+6BYDpBMAs"
"uwMwAFiOlIBVZgBQAKADgHuQGb6XANhthB++R8Wfrdn/4L8BwCkLAFbtn3LeWH9biAPI8HQA"
"gBVZIv5rDNnW7qpV55+wHACzvULAuRAAvGbHi/hdTBA2OUnnCmSKMTXmLAkZhhkT/9gm+qPw"
"31A9Gl0W/Y8DwFqYIKei1H7u2adb+Z4dHv4gcR/ycqP4aiWr7Ue+g/gfRFr1f6gDAAIJANPn"
"b+IGASDCv667/uRZLb+S+YWouekXIQ4jN9VVASDzsOlBcorPJGb/sUi5ydr/+jBmf9b9Yv0v"
"9UW0Ry8CoBuiXZj9z3yPcG3//Zr2Xxb+mOx/e3cjOwD8GX5b6sF/c33TCixjAFICbGporoSB"
"r2wOItuDr6/72BLgUQAkxsciJSkB6anJCgBxAjI28CD/wUOj9nbbS1HIG9/sjJOio+G2hTWS"
"OY1DEKEVOgSb6GzZVkSnkWQybqIlUhGWLRKscLzPLmbHEGHL70tOsQ9cpqQ+Pmxz9wlWhpcW"
"ZZu9l6k8+b+M/TEX2RREOhZlabMsZZa9BELoQOTx4mjuPeoA/B51AH9pzR9/TSz/dAsA07UE"
"EBdgVgDOtUoAOoCA1Vb9v03tf1YYxR++j7HXiJ9Xu/ijDikAsrT+JwRinewAuJdoBv/M1J8N"
"ABd0SbrMTBkAeBkASPbPvGqJnxDI8dW1K9kxx9Tii/ANCOgGZABQRK9b2p3WMYKcpLMadwmb"
"nGQzzpCV6P4gL/0Wblw6HP78c/9sRS3KoqEyli7/4wAoVqLE0yWLF9OOpDfrflRlcF70AmRE"
"HXkgtb/U/VAA2MQv8/8Rxv4TAPm5d0z2vyuZ3wj/AYX/QLO+jwWAa5r5czNMzZ9nF788AXzi"
"U/lkxO2l+CcyJlD8I5DsM4wv+mBawQGIk5V/F/og+jxrf9fOiDrD7H+6HcKdvkOodv81R5DY"
"/70WAMT6KwDqMvN/hpsb6xYOAupYgDiBRhYALAdgbRB6fT1BseUzRPq7MFMyy0WGIDY66n8G"
"gPXGti+J1WaZ+//iDtQS55m9AsQBJCQk2RcESQgcjFNIdhhHYL2dZjbUSHtMSKb9d2G+J80K"
"fm96WmGHofblmzl6+1Qd3UEU3YOEgirBLP3Nysp+rNORx8j+BfsOHNIzDGS7ctm2TLYXkxWM"
"YSw1/icA7Dl4HE6HNpue/6us+Wn3peaXEAAYB1AIAJsDSA1cy6QhDT/bCwEQsd9AIELigBG+"
"HQCHdZ7ejAHYAODsAAC3QgCkGfHft2r/QgBQ/JnXdA/LB9ny/vZGlgheABDjxJ9/zH5bZwHE"
"9iectgNAhG/CHXdlv4sUD9VEWpzvgwdpAaj7yXuDRYdySlaJErpOoNh/GgDF+Yv+Wbx4EVmv"
"/M4ffeouRdJKpEU53TfZP84aA4gx4pfsnxeOfNr//PshBECQqf0VAEb8IvoHKvzrVs1/VZ/E"
"XJ1LvaCtlGL9c9OEuGbFVXb0ZqQFjDHZ/8YwJF0fjMSrg2j/TfaXxT/Rbl2Z/Tsg8nR7RJxq"
"gzCnbxB6WOx/MwTta0IH0Bi3dzUy1n8Lxb+V4t/0Kfw2EAAbDABs4tdSQAAgJYB2B36Kqys/"
"YikgkKiDSJ99BgAR/zcAyJtdNgq1lQFxDlZZauFHnYLtsZJFRahiycWux9gXBkXrwiBZoish"
"n2tEm6W6/y4iKWTb9+ryXmtxkfzMqGgDHPnb5Pel6dZej//bpKaX/0cee9nTCwcOHsaadRv0"
"TEFzuOhMPb1IThSSbctk8xJxArLU+e8AIAeO7D7gBPeTG5HoyRLg6jRd8aeZX0DA24kaswoX"
"AvktYvZfYQFgszqADEcARBww10gR/mFj/aMPm9AS4JgDAGQM4PQjALhg4lEAqPi9LQBco+P1"
"1f0qMiMP6fRfVvQRZEVJHLJAc8xMA+oswCkHALiZkB2vkj0K5OenxfpqGfDHr12Wig6LFy9W"
"3dpApPh/GgD8PU89RwDIHOSHa+e2P4LEVQTAsfsy91+QH+sAAIr/AbN/noif2f9+sAMA/Izt"
"16x/zQpL/JlX7LbftFW6adY3ff+0YCkufMFWU/wjkeo3itn/DwLgd9r/AYj37IfYi5L9uyPq"
"3E/M/hS/c1uEn/wGYUdbIfigZP8muL2nEcXfALd2UPxbKfqNdeC3qQ4z/ye4uf5T7QS8KWsC"
"bA5gc0PrkFAzCHhtzSemJXi1jAN8grDzU81gmJYA/zcAyACeACCG9bus9fe94Vd4JsA5d91y"
"W/bfE6HIMmDZKks3yfhX/f3th60999F4nPv4uw/RvQhVBgNlH4LzHh4U+iGsXbsBSyhuObR0"
"6ozZdsFPnzlHjymbt2CxxrIVq7F9114cP3lKNxSVfQxsAMh4DABu+plZgP2HnBB0ebVp+b02"
"S0WvDkCujwOAOoClSJEpwKBHSwAbAJj9pSlHAKAuwIKAZH8bAOKOPwSAwkFAqwRIu6gD1YWz"
"AFeM+DOt2p9QyGTGzxTBS+efdABGHjC3xXVor8ExM94g4wFSCoj9Typ0ATnJ5wvEAaTG3biP"
"nHCsWzpZugNlp+GaFKZOBz4JADxPANTi7TrblnY4JwBIDd9LANDyFwgAYggAq/Z/QOufJ9Y/"
"xNj/XKn/AywA2Gp+m/AlhJzy5F3Sqb776bKoQkb9pfY/yyedFowuIDNsCcU/nPZ/GJKvD0Si"
"9wAkMPvHef6C2AvM/u5dEOnaAVG0/hEnvkX4idbM/i0QLLX/3ka4tas+bm2vi8BtFP/mjyn4"
"jyh+iToKgBsCAZYCthkA+yyAZP91n+khobowiCGfBzn1RLS/EyEQr2VAHEXxfwWAZPLQ0HDd"
"Zkt29TlL8cv23nLSz6IlyzFx8nQ9pXfQ73/i1wED8csv/XQfv1/69MGEseOweOFCbNuyRVt5"
"Pc6f166927duIcDfX69xcXEKj8RHIp73y7RfQEAAgniVRqBLFy/B5fQZXfgjKwFlafCoUaMx"
"cOAg9OrVBx07dkLbdt+j9dffol37H9C1e0/0/3Ug/ho5FjNmzbOLXUIOLRUHMNMKOcNwx+59"
"OOF8WkH3dwDIysrh3++HE6fOwcudbuv6YkR7TtGBvnhL+IUAmGU2AdFBwPlWF+ASaxpQ1gBs"
"KZwCVPtvCTHSsv4y/UdB5igAjloAOGYBwFkHAe9aHYDSzPOwC3DsA/CySgAzBiC2PjPysAIg"
"M3IfMiP2amRF7rVagc14g/Qb6JiAzgKwFEg8o7MAOUmuvH22QNYZpMbeUAewfd2cc6JDAqAW"
"hfn8kwDAU44A2LHMACAlZDML2GCrBIiChIr/QRgBEFKY/e/dMgDQ+v9hANzX6T5PhrH+9yzb"
"L+uq77H2v5ciUy9m26XMkAVIvTmU9v9PZv8BtP/9CYB+iLvcB7EePRDl1gmRZ39E5Clm/xNf"
"I+x4S4QcaoY7+1j372Hm32nEH7D1E2Z+Cn/9h3YA3HgUABsb6MagZncgcz6AAmCltTx4xYfw"
"P9gVYa7DEX37PAVMC08IyDRgYnzc/7sDIACCQ8Joef11bz9XN3ccO3YCO3fv1TP/5Cjw8RMm"
"UfyD0P6HDqhXryEqlKuAYnw5izpEESueKfEUyrz0Mkq98CLKvlwKNatWwxvVa6BWjZr2kKPB"
"5VqxbDlUKF0WlStUxEvPv4BnS/5Tr2X4uPLlyqPyK1VQo3pN1K79Dj7++FN8/nlTfE3xd/yp"
"M3r1/hkDfhuE4SNGYcLEqXoysaPg5bacWmyLpXQAfwsAa+sw+ZBTk3xu3oanxwkk+q1H8KXF"
"zP4UO7N8/PVZlv2n8K/P1vvMKsD5ugmIlgA6CLjS6gPYZE0D7lEHkK3Z/6Bpy9X635QCMvov"
"3Xg5trA7AGerD+CsAsDeCJTibrUCWxCQHgA6gXy+v+X7Mvk7MgmaDAInM1LEv7sQABYEbB2H"
"Ap5snXmQXgDbdOAZZCc4FwhoUmP86ABCsHPD3EcB8NSTcgAy9fDRunltjyNxBZKDVt0vyLnC"
"d3Q839HhBECEBYBQAoDiv29l/3sBrIX8rPrfx8H6U/zM/tLrfz/joi6ouKeDfq66t5oRv0y/"
"OCkE0u/MYPYfgmRf2v9r/ZF4pR8t4S+Iu9QLMee70f53RITL94h0/g4Rx1sh9NiXCDn4Be4w"
"+9/eXd8AYGsdBGypUwgAuoAbGz42DmDdp2Y9gGR+2n5fW+bXNuBP7KsCFQDL3ofPzva4dbwf"
"wl2HISrwDLNsonEAcVF64EV6WqoFgMz/FQBCCACxvLLrrziAI0ec9Mw/Of13+sy5GDl6rAKg"
"Y6cu+LJFS7xDQZYvXeaxIaJ/mSK2xfP/+CeeK/kPvdrihWefw4vPPY9y/N4KpcooCF6tVBnV"
"CYua1avjrddr4e3ab+OD9z7Ap598hoYNG6FJky/Q/MuW9uzfuUs3/Ew38sfgoRgzdqICwFHw"
"j8bfAyDLcgDS2lyA7Jz7CPJzQ5L/BoRfXY2gi0sdxG+VAfw8wWeuZv2kGwspfolFugrQNg1o"
"B4CtDAjfp+JX+x95uHD6L9oM/OnIvHbonXQYA3AEgKs1HehqrU51t68F0FZgeU/TFWjmV/Hv"
"RUb4HgrfFnt1vUEWHUGWQ8uxDkBq96G0A0tH4EkT0hac4oWUaAHAHWxYPk1WCX5EALzxpByA"
"AOBZawzg/UlDm25AwhIk3V56X45JKsiPMgBQ8YeYyKP471P8ucz+9/wJgJs6HWLmRCn+rCtq"
"++9LiPgz5Ak8TwDwCU07awHglLH/yUd1E4X0oOnM/n8UAoAOIN7zZ9b/PQmArgRABwKg/UMA"
"CD7QhPa/IQFQzwBg+6cOAPjoYQewzowD2DP/epP5dTWgtSeAbBGum4PIxiBbv4Hvno64dbQP"
"wlwGIfL6DtMHkJRMBxCH9JREPRNAt8ZSAOTpG/t/DYCjx7Ftx26sWLWWwppPgY1XAPzY4Sd8"
"TiHWqFbjIUE/Gi+KwK0QJyBR+sWX7CEZXoO3y9ItKDzKlEGFsuVRiW7gtcqvonq16qhFELz7"
"znvM/p+gfv2G+OKL5gqA73/siG60//36D8CQoSMwbvzk/yMAInXa0NYzka8DjPlIj76AJL81"
"iPFZj1sXVyDEayVFP4cQmPPvAeC31B6S/VN1GlAagTbbW4EfWwLoAODjAOBs7wPQEkCbgc4+"
"AgA3a+D6kn0tgIzwZ0YcRAZFnhG+W0MdgJQBInxb6KpDqwyQKUgBQPwxXQ+QnSBxXAFwL/Um"
"UqJuKAAmjRm0QXRojQE8+yQAULxEiaf/WbxYETnR5N2m9auPy4/hk357SV5O1HrJ7HxXRwLM"
"+gUad1BgE38us/+9mzoa+kCP9zKZX+t+zfyXLHp66KYKCgDdXJFPdorU/rIC66i6gPTbU5BC"
"8SffGEwA/GoAIPb/YnfEuHdm/f+j5QC+RYTTVwRAcwTvl5H/BpYDIAS2f6ZlgP9mQoCZ/8bG"
"j+2DgL7rPtXlwLIjkI9tU5A1deyZX0RvgiBY8j6ubWmN63QB13d8j8DDvRFy4mdEnJ+OuGDa"
"NYo6IyNLzwHMzkwzALBGzg0A8v6fATB6jAFAB1rvZs2+VGE6ZvlH4yVmd1vYQOB438sEgoSU"
"CuVeLo0KZcrilfIVULliJYqftr9qdbzBMuHtt97Ghx98hM8+q4dGjZvo75YSQEqRrt16oG+/"
"X/HnkOEYO37S/xoAx53P4OLlKwYAYWE6PpGZfQ/37hOM6RFIDdqLxJsrEee7GSGea3Hn8hpe"
"VykAEnxMJKr4Z+vtJLH9N62sz7rfTAGuRqouAzbizwgxDkAbgSIMBLLtK/OOajwEAJ2ekx4A"
"F/s0oLYC2xuCHEsAsyBIsr+M5meEH9KRfxG7zQGYAcCDZgYg6qAVhcuOCwEgDuCoFfL5mYJ7"
"yUEEwLW8goxAfNG47jjRIQFQTWbnnsQsQLGnnnr6H7Lnn/zi2m+83CfZf1xWevAS1lRL9YQU"
"tf8ifI3bBECgJX4/1v83kE/rr40RWY6DfjYAeGj2/1cAUPwpsvfaEdLXiRSfSQAMpAP43SoB"
"aP8v90Lsha4EQCfLAVgAON7aOID9NgdQ/6FBQJ0FkOm/zcz6mwgA2Q1IIEDR+6z95OEtwWzZ"
"n6KXI8K8FpuwAeDa1ra4tq0tbu7pgqCjPXHnZD9Eei1DUqSPCvxeboECIO/+Pd08RAGQX8A3"
"e57OnaekpOgmm/9rAHTsrFn4jZpvPCTo/004AqIUM38pK/trGUAAVCwn2f8VUwq8Vg2v13wd"
"td+sjQ/e/xCffloXDRt9/n8GwKw5C7Bk+Wo90vyk8ylcvnwZfvx/QyNidVPV9MQQpIY4IdF3"
"hZ4YnBS4A9E+m2n/N+EOIRDiuRLx12ab7G8HAGEgvf8KgMVG/Mz6Mvov4k+zmoCkD+ChtQDa"
"AegIgGOFANDa/6Q26MiZk/eSXK1wsbL/2UIAiPhlEFCC7+m7CS4EzAFmf4o/gleKXur/DAGO"
"jv6L+M10owHAAWvlodkXQJYDKwDi+HWJWLqDRG9kJQQw/BB/yzmrZpWX+ogOGZWfevrpfzyJ"
"PoCiTz+tHUflCZt3y75cpF2QR5+YnPClSA9Zkp8VvlJtPPLDVPgFebd4pfhz/U32v+tDAFhd"
"UZb1LwTARQsAZkslGfnXEkDtvwz+ySYMNgDMsgAwCEnefZHo1QdxF3sg1qOLOgCZAox0+cEq"
"Ab5GqFMLHQMIlkFAQkABsKMey4C6CNj6Gfy3fGbvAxAA+FL4Psz4uhHIyo/1UBDZ/99sBWay"
"v+cic0CIl+wOvPVrCwBt4C2x6Vtc39Yefge6IvBId9w5QRBcmofk8Au4l5Nhn7mTLa4EBnfv"
"5SArM1OPBo+JS0BIaIQeD/7/BwDMsgRvizn8fO68BVi+cpUeW+508iw8Ll0jAG4i4vZFxAfs"
"oZiXM1YgOXC7OgAFgO8WhF3dSAewFsGXV1pTgLM08wsAEn3nMuab2t/P9P6nBq6j+NdT/JuQ"
"FrSF7xsbAHY8vBxYxwIOI0fFbwFAGnTsADitB87cS3Y3A39JZx8ZAzhnXwsgm4DcSzyLjLAD"
"av0NBAwAZBxA+wBU8Ie1F8A0HDk6gAOFDkDFf4TBx8bJmoDbSIu+mv8gMxTu24bFUPHtipZ4"
"RgBQ/plnSj6RTsAiVs9xqWeeLiG/uPHZXc38kLAQSbcW5eVEruQ/u6kgP9fPyv4BDEv893wJ"
"gGsEgPRFe+kOKX8PgEccQNIJCwDH+ALORYrPQDMG4N3PAOBSz0IAyCyAawedBRAAhMk4wOEv"
"zTSgQGA3ncDO+toHELCt7kMAuLGe4qfwr6/6SLcC163AVnzosCW4ZP33CgHAuLalFQHQjgD4"
"Dt5bvsE1AsB749e4urE1fHb8AL99nRF44CfcOtoVoa5jEO+/C3eTWRrl5SoM5NjwrOy7SE5K"
"RExMlK64k/l+ryvXCIDzBMAJbN2xF8sfA4BmBEAt2vOXX6Co/8MAeJsA+JAA+OyzumhEADQn"
"AL6RMQALAL/0/RV//DkcY8ZN0mlAEb8Kfn5hCASmzVyABUvW6MyGu8sh3PLajdjr65F4fYkK"
"P9FvM0W/Eym3dhIAu/ne2o3oG1sRdmUDghQAKxB/dYZpAb4+wwDgxjyGVfv7S+OPZP4NSL29"
"QcWfZhO/HQA7NbJ0EdBezcp24UfL1N9xMxIf56zZ/27iuUIAqPBdC1cD2hyA9K/w6xnhBw0A"
"CBYNHfk/aEoBbfw5YpqBHB2ALj22ACC7AsVI1hcnQLcQKyDwKchOYP0f7Zv3INELS/pX9xP9"
"PW10WMrS5RNZDSjbj75Y8pli0oNc9+DqD1yRPAYJgUvy7katoBNYWZAdt48AEAfgTwDQ+uda"
"2T/HG/m6LZIjAC7rvH8hAB4tAc6YMYBkBwCELkKyzwCHWYC+OgMQe6GbGQR0k3GAjog63R6R"
"J79DmEwFHvkKIYda4M4BWxswncBOWQQk/f90AQSAtALfWCcA+IgA+JCZ/0N4M+NLyGi/ngy8"
"2GR9Eb8tvDd/xfrfAsDmb3B1Q2tcXf8VrmxsxdutcG0zQbC9HUuDDvDbQyDs/R6Bh7oj9OxY"
"xN9klov2RnpKLFLTcxCbkIaQ8FjcDLgNL68rcD3niqNHj2H7jp10AGsUAKNGj0f/Xwfhhw6d"
"0aRpc9Ss/jpe+OdzZjT/2ec1CoX++Cj1wgv2KP3SSxrlXn4Z5UuVQsWyMgbgAIBXq+nveLPW"
"W3jv3Q9Qp85nqN+gMZryd7dq9Q3afU8AdO+B/v1/xbBhwzFh4iQKf55m+plzFmLaLCso/MWL"
"5mPr+vlwP7oYoZeXU7yLKfyFzOjLEOuzDnE3NhMAWw0Abu9B6p19SOZVHYDXOgRdWoU7F5cg"
"7spUXf6r7b8KgAVIuoHLIjAAACAASURBVCmDfmbEX2y/AcAmpN/ZTgBsR7odANt0SzAzFrDN"
"uAApA6JMR152tJMFgBOW/T+r504a8bvZbf+9FIdpQNb+2ukn4mfWzwhjza8LjvYZByDz/1FH"
"GLYuwMPWOIAV1lH2sv24wCBTjrWPYbkQs5fZ/zIyEwIKsmI8kZEUmhfnNh4jvyziWqTI03Wf"
"Kq5rAV60dPnEAPB8yWeKy1RgneVT396NtO58wWbfz45YhvSwVQUZEWtJzGMEAB1A7g0r+18n"
"ALwIAE+zOaII3xY6+u8IAKsESHUpHAR0cABZkastB2CNAVztZw0C9tBpQMdGoMiTbRDu/C3C"
"j32NENkHQNcCNH2kFdjBAaytAx+K//pKEf77KvyrS99j3f+ulfltAHjPCssB7Gir2d9789fw"
"VgC0wpX1LRUE1wiCaxu/0rjO7/HZ1hY3drTHjW1tcHN3O/jv78gy4Q+EuM1A6JVtuHPjLPx8"
"LsOTJYCLmycOHTuNLTsOYNmqDZhBAIwdN16bcTp17owWX37JzPwms7eM7L9gF7gNBM8TDI+L"
"F/g1W7z4/IsapV6QWYGXUbZUGZQrU44QeAVVXqmMGlWr0WW8jndrv406H32MBvXro0mTpmjZ"
"oiXafNcGP3boiK5de6L3z/0xYNAwjBg1CZOnm7n/JYvnYdOaeXDaNRfezvMQdnEhy7fFGrFX"
"FiDs0gIEX1iI0EtLEHl1NQGwCYn+2/l+2mUAELwPSRYAZBDw9sWVCLrAx3pONIuBZPGPDQAy"
"5RewknX/Wq35025v1uwvANAI3mEGAWUmQGcDNplNQXUvgN2mCUhnAY5ac/8ncTfeZP+7Knx3"
"e8ign138tP53afvTQyn60L2W+PfpIGNm+H6T+bX995gVRx0AcMA+CJgVtc9sDBrFx8ntGLqU"
"2PMEgB8yYq8V5MT7IiHY7b7XzPL4tVGR3Sz56zxdQqfkqccnB4ASvDxLANSQKYjeHarMQ1oH"
"ZN3uZwAQurQgM3IDMiI28Uk5DigAKP67shmCNEZc1g0RH2Re0sxv4oI1/WcrAaT77yyf2DOF"
"YwBJZhDwXtIxXQuQwvo/2WfQv04DenRHlADAagSKoAMId6YLIABCj7RC8KEvzWIgazWgHQAy"
"CLjxE+MAaP0VACvep+2n+CXrL35HjwMzAHjPyv68LnjHOICdbTX7e2804r+6jg5gfQtcWdfS"
"En8rDe+NLfj1L+C99gtc28CvbfoaPlvbwXd7W8Z38N/zPQJYLgQe7g8/p+HwdpoKt4PzcXjn"
"MmxYsxhz587GX6PGo3ff39GmfSfUa9gMlSrXwNPF/4F/PP1PPPePZ1XUau2Z3cu9/NK/j1Iv"
"a5QvUxoVGZXKlkHlcmXxasUKeK2SiL8SXqtSBdVerYrq1WqgRo1aeKPWu3jnvTr46JMGqN/w"
"CzRt1hrftv0Bv/zcC6OGD8KCmSOxZ/0U/s2zcNNlDgXPuvy6xEIkXCEALvD+U5PhfWwsrh0f"
"Bz/nyQhyn00QLEWU9xrE+m6kA9hG208A0PqLA9ASgAAI9SIALqxAkMcCxHmOtwMgwWeWBYBl"
"mv0NAKTu36bWP13DQECWA2tL8B1ZGiybg240G4KG7XJYCmwtAFL772IAoA7gvAnp/tNw14E/"
"+Z700P0WAPbwulsjM2yvGQeIPKzCFwgUOoBD1mDgfgsA+8wJRFG79TSizEiWKTEUf6wvsij8"
"tMjLBfdS6Ao3tLt/blgRtHj76Xmiv6efKlbD6FF1+cQ2BPkHL1VlIUKjT14egeROuH+n7YO8"
"8OFIC15B6jGiaK2itqt11+x/1/sxALio4s9LdxB/+jk+qa7a85/L7H9f6n+x/9IEJLMAidKh"
"tcM0Al0fYC8B4i/3thxAV4dOwDYGALoWoDVCWAY8tBjIBoDNMgvwiekDWFfHGgOwHAABcFWy"
"/yIjfk/L/l9eYABweV5tir0prlG8V9Xyt8SVtRItFAACAm/ep7HuS4q/Oe9rRgA0w9U1TeG1"
"6nN4rmCsaobLq1rCc903uLKJ5cQmgQLdwe72uLXnR9ymS/Df3xPX9vwMj+39cHj1L1gzvRsm"
"/tEW3dvVRcMPq+LDNyvh9Srl8Gr5UihN8b9EEBQv+sxj4ykCw0RJPFXinxoln3oW/3z6OTz7"
"jxfx3LMvaQ9ANQLgvdpvoF6dd9GqaV10aNMUA3t/h0lDO2HljJ9xcO1gXNg/Cv7OkxDlMRUp"
"3jOQeo2CvDoT0ZdnIMR9GvxOTcDVI6NxYd8QuO36gzEIl/YNxjWn0fA/M4UAmEsHsJgAWE0A"
"bCgsAQiB1KA9CoAon80I9VyjAAghVGTn37grkw0ApAtQxgBso/8EQKo18JcWRBdA0UsICKQV"
"OF22BA8yZwIoAMK2GwBE7LN6AcQB2Oy/DQAifg/t/ZeTqM0agIs6QKjiZ80vVwVAyC7GTssB"
"HLBq/yOFJYAl/kzdEXi/1Qew1wrZjJSPjXGn+H2QKeKPuIjs5GCEnR6Lo4OLPHAb/TRqVywy"
"okiRou88XaJoVaPHJ7MhiABAtiH+B8kj+5O/8/5bz/fND2t3Nz/0ByCsPbJDJiAtbA3Jt46k"
"k/PUd/HJO44HOVcIgSsOJYAlfjk0QWy/Zn5XhtT9Ltrzfz/VGbnJx2m/jqn1lz6AnIRDuhw4"
"1Z/cud5PBwETvHpb04DdTB+ArRFIAHCC4j/+la4EDJGNQA40xe29jRG0u5FVAtSD/6ZPLAAY"
"B+C7po6OA+gYAEsAY/+NA7i88G3N+pcZngsIgLlvwXNJHXhv/Votv9f6L+G1pjkB8KVxAGsl"
"41P46yh8Zv0ra5tqiAMQEHit/gKey5vg8vLG8FjUCG6LGuPsgs9xZv7nOL2gKU7Nb4YzC77E"
"2SUt4bGqNR3Ed7i56wcEHezEsqYnok/+jDiX/oh1+RVBR/vCZ29vXNjWA6fXdsHxlZ2wc157"
"7J7/PdZP/Q7zRnyFhSNbYcFfrTBfo7XGglHfYtHY77BwzHfYMvsnHFzWEweW94TL5v44v+N3"
"eB8agkDnkYg6Pw4pzLoZ3pORfmUS0rzGI+HiaD7fIxB0Ygh8D/0Oz72/4eLuATi/cwDObf8V"
"rlv7wY3ActvB+3YNxPndf8CdELi0fwhdwCjCYTJuu82iqBci6uoqxPqsJwC26Mh/skBABgF5"
"jbq+iSXAGi0BorxmI0Hqf2sjENMINMcaBJQxgDU6+v/QICBLAl0OHGTZ/zvWWQAhW3QTULMf"
"gK0EcLJv0KH1vwLA3Q4A2+o/2dHHiL8wCgHAciNUGn/2OowBHC6cBYi0LQhyaAem8KUEkJo/"
"Q8QfJ5mf4k+6g5grq+E6oThOjSwOp8FF7lYrU7Sv6K9E8aKVLAAUe1IAkL3HnuEvLs/r21Ve"
"eebHJJ9vEhH5AwpC2ueDIMgOnYL0iC38hzfzSdprDlNMOqlZXw5EeJB10QEA5/XsNBF/biot"
"P22/nK1+l7Y/l5k/N9lJxX9X6385lWU/X5SDSAsch2Tvny0A9LLPAkS7dzKNQGfaWX0ArRDm"
"9KWuBdBZgP2fKwDMIGADMwsg03+6GpBhB8DHZhZghYGA15J3HwbA/Hdwae7bBMDbuDDzTQq5"
"Ma7Q6nsys3utJQAIAa91BgZG/CbjGwA0sQDwBR/XlAD4XAFwYWkTuC9uogA4PachTsyohyOT"
"P8P+8Z9g1+gPsWXYB9g89ANsGvEhNv/1MbaM+hjbx32GHRP4PdMbwnlxC1xY34ZupANu7u2C"
"oMM9EerUGxHOfRHtMgAxLr8RFIMQd+53JF8cyhiGpAvDEec2BHHuQxF3figSzg/j14cg6swf"
"CHUehFtHB+Dmwb7w3t0LHhs749Ty73F4/rfYO/MrbJvcHFsnN8O2KV9ix7SvsHv21ziyuB1O"
"ruqEMxu7w3XLzzi3tS/ObetLCAwgBH6D285BcN/5uwHA0ZEEwCTcPjcDwRfma89EzPV1SLi5"
"CUn+23UaMOX2TiQGbEf09fUIvrwGoZcXIf4qM//VaboZiMwCSAmQ4GsDgCkDdBZAnMCttQoB"
"bQSSHYGCNhkHYDsYxKr/szT7H7S26H4cAEwJYA6k9aBQTzDRHUJ6+CHL/jsAwCoBMsIkpPlH"
"moD2mEYge+fhfnsnYGbkHj0ZSMYGMuOuMW4wfJj5LyA7MRAx3uvhNuWfcBlXPN9lTFHs6l8k"
"scyzRX8U/RUvpjp85klvCipzjqWfKlHsHV6bXjz0xW0k/4TcW23zEPYjQfBDwd3wmciIEgew"
"nU/kYeQkntBFDWL1TQlgA4Cp+WXOXyx/buopAuAkASB9/8cIgKMq/LuJhxgH+bP20QUc0F6A"
"JO8+SPTuaxzAJdp/j06IPkfr79IOEafF/n/NLNkCoUebMfs3Nc1A+xo9tBxYAbC5sBHINAER"
"AGs+1j4AnQaU48CWvm/Zf5P9L817mwCojUtz3lIAeMyiE1hDQa9rQVE3U+HL556rKPg1TRi8"
"rpbr5woLb34ujuAhACz5HG4LG8NlLsU8sz6OKwDqEgCfYtfIj7CVANg0+D2s+/0drBzwFpb0"
"ex3z+1TF1K4VMfbH0hjbsTQmdCqD6d0qYkbPSpjd5zXM7P0a5vergYUDamHxb29ikcTA2ljx"
"53tYMeR9LB/8ARYPfA+LB73H+9/n19/HvH7vYmav2pjV521M6/EWZjCmdnuT19qY3esdzO/7"
"ARYN+AhLfv8Ea0bUx6bxTbBrRiscmPcdjiz5HidXdyYAesBlU29GH5zd3Icw6EcQ9CcABtIB"
"EAAHhqoDuOk8EbdcpyPEYy4iPJcg5toqJNzYqC4gOWCbAYD/ZkRSBDJrEOc1hdZ/EmOKQ/Y3"
"AEjQPoBFSLZ6/wUAKbfW2GGgh4LQGSgAgpmgQrZbfQB7rVmAg/ZmoMIGIBcd4JM+gNwU1vuJ"
"7hTxYaSF7qXgD1pxQOv/dBkAVADssQCwS7cf0wjbaT6XNQD2VuD9ev6AnkIc48Ja/6aD+Fle"
"JAUx86+H66TnC85NKAHn0cXyzo8tggWdit4W3RUvVoT6K1r6SQNALjLn+NIzT5upwMPr6rkj"
"tRPuBba5j3BxAh0KENYRdyNm8R87oFk7J5FUTTpDYbO+TzPnpOVpzW/m/XPTpOZ3NpFywlj+"
"5CPITaLwJSj6u4lyPPMe/XmZYcsIgN4EwC9I8OyJOOkCPN8RUa7tmf1l5P9rZv+WCDvSHKFH"
"RPyNcWdvQ9b+0g3YwOoDqKeNQH5SAlj7AUgfgC/Fb8YBzIlA16T9d/kHZhZgsRkHsANg9lu4"
"yDg//XXGm7i8orGK32sVxS/iXiV1fmOt9fW6upFCQAGgYwBNCIDGuLSskZYA5+Y3xJnZDQiA"
"ejg+vR4OT/wM+8bWwc6/PsKWoe9jIwGwdtC7WPnb21jWvxYW/lIT03tUofDLYxJBMK37K5jB"
"mN6jEqZ0fQXTCILpPSrz/ir6fdMYU7tVwZQuVTC566uM13hfNUYNTO1eE5O7vI5JnWpi4k81"
"Mb7D65jYqRYB8xZm9XgHc3q9h7l93sfC/h9hKcW/Ymh9rBvZCJsnNKUDaInds1rj0II2OL68"
"A06xBDm9rjtOr+9BGPTC2U2/sBygE9hhAUAdgAGAOIAQj3kEwGJEe69EvO861vOb6QI2I/nW"
"VnUAUd4rEHN5MgEwUWt/gYDdAdjXAsyx1gEse7gT0BEAt9c7nAy0sxAA9g1Bjtr7ABQCcRYE"
"kt2RzdvpYfss8duulv23AGDL/gqAUAHADo30sO2MHQoBsxBotx4LpgOEcVcofn/W+wRA7HWk"
"R3vR9gchgs/JucnPwWV8yQK3iSVw8q8i9y+MLYrx3xVxF92ZKcCisivw00/6YBCZcniBAJBl"
"wZ+snvnhPqR2xj1xAAqAjgUI7QKEdUFe1DTtY1YHkORstjeijborZ/ylX7am/c5aADil4je2"
"X0b8DxEABzTzKwASmP3jdisEsqLWIem6zAD8TACwBLgg9v9HRLm0ZfZn3e/cCuG0/mFHvkDI"
"kSYIZuZX8e+x1gLsqKudgP5bPjUAkDGATdYsgEMjkALA6gSUBUDaC0AASAlweZ6UALVxYRYd"
"wIxacJtcA+cm1cTFhZ8SAs2MAyAQPFc25LUhvFY2UgCIA7i6WgDQxABgxee4uKwhzi9oANe5"
"9XBmVn0HAHyK/eM+MQ6A9n8jM/eaQe9gxYDaWPzL65jbqxoFWokOoCzGdChLEJTD5M4VMZEx"
"ucsrFHUlir8yxf+qxtRurxEMr/H+qpjes7oKf1p3ir/n63YATKD4x/1YA2O+r4GxPxAGHd/A"
"lE50AN3expze7xEAH2r2XzG0HtaNaoQtE79QAOyZ2RoH538Hp2U/wnkty4U1XQmC7nDZ2JNB"
"J7CFEJBSgGWAAsBptBkDEACwBIjwWmoAcH01s/lauoCNzODbKOxliL08XiPOmv4TEJg+gGn2"
"5cCyPkCWASfJYKDfMmtK0LQCGwCsNQCgA8jUrcEsAIj9Z22eY60DKOwEPGb26WMpkBHBsjN4"
"hwo7jTV+GsWdFrKXsccSvoMDsI0BMNJDtjG28mu80gWk6w7EdB8y7hBzTtt6sxIo/oSbyIjx"
"Jgxu6Od3Tgzh+6kk30/P4SwB4DquGI6PoAMYUwSDmhXdJ7p7SpflF31B9PikASBTDs8RAHoq"
"0G89qi9CWjcCoB0dwI/GASgAegHh3ZEfNU7XCWTrziauBIAHwxP3MuS47+vWlt9SApxQ+y+1"
"vwHAAeQm0j1Q+Hfj9/BniPh38cVhWaEzAcOQeKU3ASBtwLT/bu0ReeZbZn/W/cdb0P43Q9gh"
"iv9wY8sBNCoEgC4G+swCwKfaB6B7AkoJIA7ABoCVVqwyh4LK0eDiBGQWQCFAAFwkAM5Pe511"
"Wk2+YNVwdlxVnJ/BMmFZAzoACpzC91zeAF4CgVUWAOgIrqgzICCWNcbFJQ3gPr8eAVAfZ+Y0"
"wKlZDXCcZYAAYN8YOoCR4gBYAhAAa39/Fyt+FQC8gXm9qmNql8oY26EcS4By6gQmdqqgALDF"
"5M6vUNiVNSYxJnauwqvJ/pO7VMWkztXoHmrw/uoUP0X/Y3WMpfhHta+BcT+8rgCY2sVyAQTA"
"ogEfY9ngz7BqRANsGPO5AmD7lBamDJj7LY5JGbCmE8XfTQFwZgNdwIZeLAd+tgBglQBOY+B3"
"eqoZBFQALCEAlhkA3NxACKyi0KciWrYAvzSaMU6n/2KtiLs6ycwCSCngY9YFmNWAi8wqQH8H"
"AIj1dygB7A5A1wJYAJC9+RQA1k5AcSeQwftT79CJBK0nALabCJHYyditYSz/PhO8XxqOdNYh"
"eDNji4FAKD8P2UIHsAOZ0Scp9GvM+gFG/LT8GTHXNOunhrvDb1dbnJ/yDB1laZyb+CxOj3mm"
"4OzYEjg+rOh9AcA37xZdJLp7SlflFrUdDPJEAaBnAxAAsirwncaflR2NVAHA99YYgACgExDa"
"jQDoB0QwoobhfsI23E1h9k+9qKEAyLypx4DJEeC56TLK6qS2PyfxsDqAe4l7SWAKP36nibid"
"yI7ZiruyMeitiQRATwsAPz0CgC8VAGL/Qw5/jpD9n+POvsa6IOiW1P8EQIAAYOun2gfgL9OB"
"W+vpMmAdBLSNAaww2d+cEGytBlQXID0A72oZIGMA56e/AXcCwG1SdRK7Gs6MqgKXsVXhNo2Q"
"WFaPojeCVzfAuGLBwHNlY1xe2hAXFtd/CAA6CKgAeHwJIABY1Od1zKF9n9y5Esb8WE5jbIfy"
"mNCxAsZbMe6nivz8FUKhEoVexQqKXwAg4rcBoEt1fk8NPqaGyf7tq2N0e3EABEAHAqAzAdDz"
"HS0BFv36EQHwKVYNJwBGN8YWlgAGAF9h/5xvDABWCwDoANb10DLg9PqeZjxga3+cYxlwab8N"
"AFMIgJkWAJYh+tpKxF1bhhjPaYhyH4LIc4MQdX44Yi6MRMzFMYQA4/JYAwAZC5CTgHQqcKYF"
"gHkOKwIFAKstAKyzDgbdoLMAmSE2AFhtwLIJiIP45fPUO1tYhqxkGbIGKXxcatAW3rdV7zcw"
"sNyAQoDvR83+Oyh+mX7cSNBsVtik39nAr28mTI5R7Fcp+kCNzPgbJuvH+6n4466vh/fq93F+"
"5gu4OKci30vPw3X8szgztmSBy+jicBpaNM99VBG8U7nIaNEdAUD9FdVVgE/8bECZenjqqWKy"
"O/A7H7/70q+I7Hj/QfCPkFkAhHaEcQA9CIA+BMBAINJEfuwi3d4rJ+0aAXCVALimx4Ddzw5A"
"XnaQORQkzU0H/e4l7EIuI4fZXzN//HbWYTssAOyhxVqIRK+eOgagADjXDpEu3yH8VGuEnWip"
"JUColACHmyDkgG0QsLGZBdhZnyVAPZ0GDNgqLcENFAB+G+uaQUBbGWB3AB8/tBxYVwIuek/L"
"AAXADAJg6ut2ALiMrYbToyrj1LBKhMFrcJtaG5cWf8bSQMYAGOIKCILLBIHn0ga4SAicX9gQ"
"5+Y1sDsAAYAOArIE2PnXh9jM7L+B2X/NbywB+r+Fhb1fx+zu1VTco74vi9EEgMSYH8pj9A8V"
"CIQK5vqDDBK+QnFXYoavwmsVPuZVuoXXMP6n1zCuQ1WM61iN12q0/SL86hjVthpDbtfEeEJA"
"SoDZPd/FvF8+wOLfPjYAGGEDAB3A5C+xc2pLAuBrHF3cHidX/WQAQAdgxgJ64szG3goAGQe4"
"zBLguuUAgtzmEgALEH5xDiI9JiDK7U9EnOVbyvU3AuAPBUG0xwjGX4QA49IohUCcl60ZaIru"
"C5j4EAAWWxuBrLTWBawzW4LphiBbCQBzOIiZ/rM2BFHxO6nNT/ZfzRJkKZL5+GQ+PllmE/hY"
"Eb8BwDakBu+0AGBdpUQI3qHNR2niGG6v4W3+vvAjtPuXzUq+xEAd7MtgrS9TfTLFlxbhgeDj"
"/XFlcSVcWlARl+ZXoaN8iSXAi3wvPScA4HuoOE4MK4qTQ4vcr1muyK86Bai7cxfVVYBP/HRg"
"OSOkePGiFeQPqVq55E9pN9slIaIjCoK/z0foTwRAVwKgJwHws3EBCoA/6QR+B2LG4X7Sbtp/"
"bwLA3xz/nSlnAwQyggmDUIIgwLQESwkQt40hswm7zBgA7X9OrBzhvFZXAyoAbGMAZ9uZQcBT"
"MgX4FcJkFkCcwKFmVh+ALAhqqn0At3Y1RKAcCSYHguywAaCebggiDsC2GEhWBHprCWABYFkh"
"ADznv62DgB4za8FdyoDJNeA6gRBg9j8z+lWcGfkqThMCzoMrwHnoKwRDDXjMpoNYVh9X1n6u"
"zkAGAQ0AGuggoAuz/6nZDwNgx4gPsYniX0fxrxrwNpb1fRMLetXErG5VNcOPbF8WIwkBuf7V"
"thz+aleet8vrdVS7CoyKGP39K4QB3cIPlZnlq1DwrxIMr1L0r/Frr2Fku9fwV5uqGMkY1aYa"
"RreTcYCamPDjG5jS2ZQAAoBFv1klwPD6CgCZBdg2qTl2TG2BfbNbW1OBHXFqTRd1AFICuEgJ"
"sLGX9gW47hikTUFXncbC//Qk3HEdj1DXoQg/0x/hp/uq+CPOUvwSrgMR6fYHX9shBgTnh9IN"
"jDAQ8BpnAKClwBR1AUmyKYhuBbbEmhJcYfYDCFxrbQiy5ZHlwLYBwKP6uTQRJdA9SFdhEh8r"
"C4uS+fhkcRE2B0CAiANIpdhTtSSg6IN36ecm+2/Qa3rYUWZ4S/gS1iCfiD876TbLgJuI8VqK"
"G5vrUfwV6SxrUvyvMvuXh8f0MrT/BMC4Z/meKSnz//mnRxTF3gFFk8o9X/Qn0V2xokUqiA6L"
"/BdOB5bzwXUqsETxYrIaqZnX0RZBSOqK3MB2eQj/iWVAlwIDgN6MX+gCfrWcwDBCYCivQ1AQ"
"Nw95qc6mBFDxywlBFH72HeTdjWBEIy8nhJDw0lkBhUDsVlJ6h4nYXUj2HYKES10Qd7GbzgJE"
"n+vIN84PhEBbRJ78BuHSByAgOCLNQF9pK7CcCxi0t4meDHRrVyM6AQsAcjqwnAAkALBmAbQE"
"sK0GXPahit/uABabVmDpB7gwW1xALWZ6AUA1tf9nxggAKuP0cHEClXFySEUcH1QOxweWhfOf"
"rxAQ1eE24z1cXFgXl2QacFlTuC9pirPzrT6AmfVwREqAMR9jO+3/hoHvYA2t/4p+tbGkdy3M"
"614D0zszg/9YEcO/K4NhbcpgRNuyvC1RDsPbMNqWx4g2FTDiO0abiqzrX6HYKzOzV+btyoRF"
"Zd5fBcO+rYLh376KEd8SBMz+Y9pV10FAGQOY1PENTOtaWx3A3J/fx0IpAf74FCuG1ce6vxpi"
"41gZB2imDuDAXCkB2sNZHMCazsYBMPufWt8bpzb0gcuW/vDYNQDXDw/E7RMDEHa6P8JO9UHo"
"qZ95uy/CBAJn+iHcpb9xAK6D6AJ+pysYjKhzgwmCP+kEzNHgsbYzAaUvQGYE9ECQOQ4AWGpt"
"CLLGAQBbH14OzPrfCH+dthMnMBJF/BS+AiBwlWb/ZD7W2H9m95BtmvVTVfQ7NfOrOxDbH7IX"
"GVEupsan6DMlxOrzcxF+lgg/4RYSA/Yi6HAnJpmauLa6FpNMbSaT1yj+SnwvVaQDKK0AcBn3"
"bMHZcSVxYkTxPPcxRbG4c5Eg0VvxYroPQGlLh0WeOACKFStqTQUWl7PK6x3b1PgSUrrjXkD7"
"+4gQAHQuQGgPayDQEQB0AFFDGKN4ezivI1EQvwJ56ecofgo/J5QACLJuhyEvNxYP8pKQfz8R"
"D7Jvs3xw1VmA7Kj1hMA21nVT6QC6I+7yz4jx6Ixot58QpY1A1p6AsiuwLAZy+lZPBgqR7cH1"
"aPBmCLIOBw3Y0UiPB5er36Z6BMAnDmMAZkXg1eW2XYAs4TMUAtIWLGWAzQVMrakAcNUy4DVa"
"N0LgrypaCjgPewUn/qyIE39UIAjKwmlAGTj9VgYnBpfH6ZGvwWXiW3CdUQcus+vhzLzGODm3"
"MY5Mqo89o+tg25D3sf632lhN67+c2X9xrzcwl3X7NFr4MRT1kK9LY/A3pTHk2zIY+o1EWfz5"
"dVkM4XXYN+UwxBAHYQAAIABJREFU9OvyvK8CwVCRgn+FQKjE+yvxfl6/rszHM1pX5u3X1P6P"
"+6GGTgNO+KkWpnR5EzN7vK0AmNPHBgAzC7D2rwbYOMYGgBY6BnBk8Q9wWvkTjq/sDOc1XXF2"
"Yzd4bOmGqzu74ub+Lgg60hWhJ3ogzLkXXxuK3/lnAuAXgsBEOGEgEDBOYICGuoGzAwmBQXQC"
"f9IFDDdHgsvxYFcn2lcG6nbgvgv0SHDbzkBmR6D15mSgO+Zw0CxZqUerL6WB9A/EXZupW4ol"
"8nEGACsJgJWa/VNur2UYAIjYzeCfsfwGCLuRHuGEzJgLFPdN2vzbVo3vy5qfoo/z5X23VPjJ"
"QccIud9xc9vH8NnwNnw30mGueRtXl9VgMqnG91Flvo/Kw31KIQBcCQCnYcXvXyAAprQrckn0"
"xvpfdPdSsaKqw/8KAEo4TAV+unH+Z4eR2sMAILxjIQDCBQB9HQAw2DiAqBGM0UD0OIUAosej"
"IHEtHsiqwJxwK/vLlZEbTQAQAnkZGg/uxeG+DCAmndKdiOIufI9Yjw7aChx7oSezRFezI5C1"
"FiBCFgWdaEcn0AahTnJAaGsEHyQEDnyJ23u/QOCuJgiUY8J3fq6nA9+wHICWALblwAIAcQBL"
"rWXBtP9SAggALs17RwFwfrqUATVxTsqAiSwDJlZVCLhYEDg94hV1ASf+KI+TgyUqmM95+8Tv"
"ZXCcIdeTQ1kujKiCk6Nr4NjoN7Fv+FvY/ufbBADt/y+1sITin9+lBmZ2rIqJzOYjvi2PQa1K"
"4fdWhEDrMhSzEf/gVmXxx1e8flWOUV7jz1YVNIa0qog/W0sQHq0rqfiHtK7yEAAm/PQGJnWp"
"hand3lIAzOltADC/34daBiz9g2WATAWObIRNY5tgx5SWODTva5xe3hbua9vCc2MbXN/WFv57"
"2iJwX1vc3t8OQYc6EACdEOzUHSEnehMCBMDJ3ghxNi5AQgAgriD8NG+f7qelQYQVka4D6AZ+"
"Ny5AjwWXA0JlRmCiHgtuzgWcV7gpqP9SpFrLg2VLMF0GTAsvm4XIBiJ6pBgfE399ru4olKgO"
"YGmhAwhYpfY/WboJRexi8SVkrj9cRO+B7EQ/ZCff4fW2juqr4EX4BIBmfIo/5c5xRJwbxuei"
"iYrfb5ecKvUprq97h++zNwmAN+C5sCodQGW+j8rj/NTS1hiABYDhxe97jC2KYS2LHha9mSnA"
"Ii8QACX+mwB4jg7gdZmSGPVbrZVI64V7gd8/AoA+FgAGMAZZ4wACgL+MC4gew5gIxEzidSyv"
"kwmCdciXzRVzWAbkJiLvfjwBwMhN4DWFEMhEQcFdRg5hEKVbKSX5jlUHEHWWgndpqweCRp+V"
"w0FYEpz5QQ8H1fMBj3+HkGPfGAgcaoWgAy0IAYJgXzNCoCn8tzbWmQAFwEobAD50KAM+sANA"
"VwRaLcHSCyAzATodSBcgcW5ydXUCZ8fQCYwkAEYaF3ByCAXOOPlnBZzQa3k4DzX3OQ8hDIaU"
"JQhKs1QoBaeBL+NI/5dwsH9p7B78JjYNfh+r+72Fpb1YAhAC0zqwfmdG/7NlGQxqWZpRCr99"
"WQoDmpfGr81LoV+zUujftDT6NS2DAc3K4rfm5fBbs3IY9GUFwqECISEQqKQOYOjXBMA3LAG+"
"q6oAmNSZtX/XNzGtm3QD2noAmP0HfULh18WGUY2wY3JzHJjTCk5L28F11Xe4tu4L3NzcHH5b"
"W7Ckagn/HV8jYPe38N/dFgF72iFw/49qfYOPdSMAeiKM4g892Yu3eykIQgmCMGe5T74m0Ysw"
"6G3B4Be+toTAuYFaCkgZEHN5FOK8xtqPB0/8l8FAczJQmjgAAkBmBmQ3odgrUxBnLSTS7cRk"
"k1HZVYjgSPRbTvGvMg5AxgD4+CSWAqlBWyn6I7pKLzvxBnJSghmhulAnOzFAM35WnI9CQAb3"
"pLkn5c5hPcj0zuHWCNzbEAF8n/nvJgS2f4obWz6iC3iPAHiL77E36CirKQA8Zvx7AHT4uOhK"
"awpQdPfcfxMA1lRgcT0mrHnD8uMNAH7IMwDo5ACA/hT/bwyx/386OIC/LACMNQCImQ7ETjdA"
"iJrK0mAtQXAOD3IjKPp04wDupzKSUZCXioL8DEJAto4Gb+fSFdzRxRaJ1yfyDdKDJcDX2g4c"
"ceo7RJ0mCE514u2OtJ/tTDkg+wPQCQQd+Aq3D7bArT3NELCtsR4NJjMBhQ7AAoBtAHDRuw/1"
"AVyaUxses8xMgHQEutshUIM2jhAYV5UQeBWnR1XCqRECgYqW2CtothcgnBpGR/BnObqDsjgu"
"MciUB8d4PTKgFA71e4lRCnsGv4GNg97F2v61saYfS4K+tbGsF0uC7nQFXWtqWTCHYJjRsRrh"
"QIfQ9lWM/aYKxnxTGb83L4/fmhIAX5THwOYEQEuK/yuK/yux/lVM/U/xj2b9P6FDTbX+07u/"
"hekEgGT/LWMaYdfkL7B3anMcnN0Sh+e3wrHF3+Lk8va4sO47ZrMm8F3fBD4bm8NnUwv4bmmJ"
"G1tbwX/nNwjY9R0C6QRu7fuBz3UH3DnaRV1AKCEgIAg5bl0ZoRr82nGWCse76+0w554sF3rT"
"BfxiXIA7XcCFoYi59JeWAjojcHWSLhJK0PMBZ2pPgJ4KxDIg0XcRvz6NwBhH8UvJMF17CLSR"
"SDcXnU/xi/1foqsKNWQcIWAt6/zdyIg+h+wEXwo+BDmpEbyGI0eyflKgOgAVfWKQCj8z9hpd"
"w05EXxpOgLVj2Um3efQbgq81AvY2IRSZ/XfWoxP4BL6b3sf1tbX5/nqd7ysCYK4FgGkWAGQM"
"YGxJHBtaPM+DJcCHVYqMt6YARXf/JACK/7cAYFsV+Cqv79Z57+WBiOn+IO/OTwUIk1mAzozu"
"FgD6GfsvANAS4E9rMFAAMNoBAFMNAGJn8fYc3j+TV95OXIOCtNPIv3uHECAAHjD752cbADyQ"
"siCNt+/C/iF77eVEISfuHFJuzkfsxd8Q4SzHg8sW4V9pGRB2vD3fXO0R4tQOwYe/VSdwiw4g"
"YGtDh30BPzEzACvMbICZAnzfLAe2OgFlLcDFmW+a9QC26UACwJ0gcJsmnYHiAlgKyIyATAuO"
"EAi8QsFbANCgA1AASClQDscGUvi/lsax/qVw9NdSOPLryxQ/oy+dQN/SWP/rm1jR5y0spwtY"
"QuEv6vY6oyYWdqmpt5fyviU93sDSnrWwuNsbWNj5dSxgDG1eEYO+YDnQjJmfABjS8hUMa0Xx"
"t6T4v36V4qeb+K4axravgYkdX8fkzrWY/WsrCOb98j52TmqKHROaYDchsGdKM+yb0QIH53yF"
"44u+gfeaz3F9TWP4EAI+65uytm2OG5u/ZJZrCb/treC3gxDY3YalwPe4deBHZsROFEVXPv/d"
"FQTBTj0IAZYFx3vo+ECIiN+pC7/eVW+LGzAA6KsAiDz3G6LPDyYEhiH20sjC8QBZoXh1sjki"
"TM4OoOhlyjBKpw9HawdhrNckxHgyvCarE5DBQ7OpqBkDSFLR70dG1Hm18SJqyfQ5KWEUPbN+"
"8m3kiPCTbqn1l69J3Z8e6a7AiL08lH9fF0TQhYaf+Yn/z/cIpuMMOticDuAL+O9qBD8CwG9b"
"HQWAz7pCAFyaRwDMqkAAlILbJB0DwJnRJXFiWPGC0yOKPni9fJGBorcSxYqI7v5BABT7bwFA"
"Fh+ULFG8aEUhUs2qz3XNDOiUinARfkerEai7NQvQzyoBfjODgAKByKEOABin1h8x0wwAxAmo"
"+Ofz88VA/BIgjteE1ShIOYiCbG86gDirDMhTF6BA0DGCTAWE46F5cl9uWoA2a8R7T+aL8wtB"
"0NrMCBz8QsUfdKg1y4CvcGvXlywDmujBILIrsOkGNJuD2EsA2v9Lav3f0ewv04DaDmwBwM0O"
"ADMecE5mBSwAnP6rko4FnBpekRCgE+DV2H+K/w8zQ3Dst9I42pfC/4XBrH9YxG85gCOEwvq+"
"NVkCMOtT9As618T8n2pgbsfqmP1jNczuUA1zeHtWh+p6eyavs36Ur1XHnwTAgM/LYlDT8hgk"
"EGjB0qFFJZYPhECrKhiuEKiqfQATOtbERCkButTCpE5vYEHfD+gAGmLT6AbYPu5zhcEeOgFZ"
"FXh8YUuKvxGuWRC4Ltd1AoFmuEEncHOrQKA1ncC3dAHtcGv/98yGP+HOkc4q8GAnlgOMYAsG"
"kvVDKH4DgC7GAZzsYQDAUiDCpR8i1AVIk9BguxOIvzKeJQDFf3Ui4i6OJCj+QJjLbwhzHYzw"
"8yMQef4vZuVx2kCU4D3ZGjycjLhrC5Bwcz1SQ0/Q3ntpe67YehW92HvW8bIqLzspQDO+Wn91"
"AWFa66eFHkKS/3z+3D+YbH5GzIVfEOVBULnxbz7dgf9PGwTTcQYdasES6AuKvyGjrgHAxvcs"
"B/CGAcD8ynwvWQCgA9BGoDElC06PLI5DvxdLfeWlol2tKUDRXcmiRVWHTx4A1i+WT8rw5jtP"
"PVXkKz+XNqGI64G8oB8fILwTCkK7FRgA9LWivzUO8Id2BhaWADYAWA4gZgbvs1xA7AICYDlj"
"jQlCAImM5G1AhgsK7t6i8BMp93yVvGy1XZB/j84gy3IJ9xxgYK7599NwL8VPR29jPSewxuyF"
"23xhArZ/pisDb+o5AXI0WCP4bpBDQRvwRapLF1BHdwjyXEjRz32T9Rpjdi1cnPWWmQXgVacC"
"p9EFTH9DAeA2xQBASgBHB3D6LwMBWzlwcrARv8wMSPYX8R/+mfHLyzj4s2R+CToCgmD9z9Ww"
"sFstLPiJdp8in/UDhd6+Kma0ew0zeJ35Pe0/r9PavIZpbatiOj+f+WMNDP2yIv4/5s46rMqt"
"i/absrEVC0SxO4/d3d3d3d3d3YWBIqJggojYiB3Y3Ypid2Aw7phrrQ1bv/Pd+9/1O88zn72p"
"zZbzjt8aM9Z6u5VNhV7lU6M304D+VZkCGAgMohMYUtsNIwiAUVYAtNBFQBkFnt+tANYMLY7V"
"g4vDa0QprGc6IG7Ad2Jl7JldERdWlsT5FWUMCMoi3LOcdgNrCYENVQiB6rjmU4upQD2mAQ25"
"GjINCGiBe7uZCuxu/R8AuGvEf08VC9upOoHUAx7t74THh7rhyZGeeHq0F54e64vIk4O46g4j"
"DAbj/v7euB3UGbfkWPY9XQiKPhTlEESeGo7np0cQFKNwP3Qkbh0YiSt7x+PqgUW4e8oPz26G"
"4uOLW8ria8FfNxX9K+q5WvnfaNFLrv/+UTBe31hO5zAakef5Hs71pbPoh8jT/fg7CKewDngS"
"2hoPDzVn+tKQ/0YNAO0ANACueBehW8obUwM4uygWAMemphAHEH1kXEKEjIz38+gYB6zqYHff"
"wc5SncqTXbgpRX9/EwAMtSswWdw4DvKGSu7dWOUs3nTUdYBHrRB9zwqALjYA6GUAMMRU/0ep"
"DsBvKYACwEzjAOZrB/B8CWMFxb8GeLXeBJ+/9ub38ucilwGfziI66rk6bttm/afuowiCLypN"
"kPP4bXIFA4QP+Pb2Bt4/2MMccRJXnK646V+T+ayMAOclnXNx5c9p2oCSBhTGqXkFmAYw5uQl"
"BHKpOYBj07MSABT8pMxc+TMx3HF4fCZdAxipZwJiADDUOIBBuggYTAAE9eLq352rPyOgswbA"
"zs4EQKek2N45CQGQDAEEgVcnV8ympZ/VWERvhE77PomPk+q6YVIdN0ygmMfXdMUE5vbj+XwS"
"hT2Qq363MgSAOACmAH0JAHEB/ZkKDKwhbUE3DOP3yQRgbBswG8Y0ZXpBB7Cq/z9Y3rcoPAf+"
"g9VDStANlMZ6uoG9s7jqryjJFKk0/16MlaWVG1AAWF2RIK2MK5IKbKyhXICkAjdjUoHmqih4"
"m25AUgKBwYM9bdSq/zCkLVM3EX1HPDlA4R/orBzAA+kWHOjGlb0n7h/sjjvBnXF7N6HBeMKv"
"RxzqiWeh0jbsieuBnXDerz2OrGmOwPkNsG12I2yf1wq7V8iehPE4v2cVbh7fgqfXD+A9c3fV"
"unt+2Yj+nrH999Q+/fcP9zA9WIoXF0bSbfRmOsE4PwDPL9B9hA+lAyAIThFMJ3vQlXQmBPj+"
"DxIA+yTVrM1/YzXc2F4RN/zLqhRAAWAtHcAqAUBWVQSUFOD4jLQaAJOSRB+dkBDBI+L9ODne"
"AdOa2J0VnTH/F70lo/LjGP3/VQAkJgBy8LGY94IyQXjTCd9uNvkeA4CYaUADgMd0AE/62wBg"
"tAHAnw6AAHg21zgAAQAF/pwr/wtPQoDxyku7gNe+fF26iXtMMx7IfMEkfp1w+HgC+P6Ub91W"
"8Eb0KmX4qp3Cr++/pQvW7/nx9Tk+Pw/Hm5v+eBQ6Grd2dmBOWwlnFsn+fzfm+RkQNon52iQ3"
"/s/KRgAwHZibn84gL8Km5yYIciF0cjYzFShtQFn102rhD5GpQOb9FL0S/wBt/wUAgd1TYpfV"
"/hMAOzolw7YOSbGtYxJs75JUAWBDx7S0+B5c9WWFz4iJFO7EujrGU/Bjq2fAaK7qEqOqyvMM"
"GFvDDQMqEgBMAXpV0kVA6QRoAFD8NbUDEAAMlynAhnpDkOwGHN2IqUaXAljSqxAW9yiIpb0L"
"Y1nfIvAcVAyrh5bGvlklEb6sOM4soQtYJlFKuQFxARc8K/Air8hctwoBUF11BW5sroNb/vVx"
"exuFsasJ7gU0w73AFtryq9y/Le7sbqPidmBbJe47QbKid8DDg13xjCv/8zCK/FBHPOTPPNzd"
"kmlFE5xeXw8Hl9WG/9QKWNqvAGZ0yIlJBOU4/hsmtsyF2V2LYfngKtg8tRn2rOqFY5vHIXzP"
"YtwM88aTK3vwIfKKrugzpI//7nGoKuZJm/DpWaYZp7pxle9J8fdl+jCIgh/IlZ8AOD+QABik"
"UoDIM3QChEDECUkD2tGBGAAE1+W/pwZu7aqMG1vL4eqWkkyLivxeBFxoHMCstIRASrrIpNFh"
"kxMhZFS87wKAYbXsgkRnBIDoLfH/AgBsW4EFx/XP64m3XQiApgRASwKgbbQaBHrQWW8IkjqA"
"GgQapMVvnQOIcQAU77MppgYgKcAcA4AFJg0Q+7+a4l9nALBeQ+DRSA2BR3ydR6P0x4/lNQmR"
"F2uB9/vBNwX8fPevYofUERQMNBDEQfzbfwoKLy/j9a09eHx8Bm7u7I6L6xrizOKitP8etGzp"
"cGR8GhwckxoHR6Vi7ubC3N+V9p8uYLQHP58ZB0ZmJAhcY4aC9gwwcwCS/8c4AFp9ij+wYzLs"
"6kjr34Grf6ckKhUIJAB8O7lgWuPMmFqPoq/tqlb6cbUyYAxFPJpiHlE5HYZXSodhFdKqRwkB"
"QX8CoKukABWYAlR2UQAQJ9CvinYAg2oRAHQRw5g2yDTgCNkTYMaB53TMh4VMAxbIXgA+Lu5e"
"CCv6FcaqwSVxZHZxXFz2D84tKY4Ly0sqN3BhVWlcWl2OIfWUCqo1eGV9VaYD1XGJcdm7Ji5v"
"qoOrm/XJyFf9G+Pa1qa4sbMFHnD1j+Cq/zy0M14d64ZXx7vjNW31qzCu9rta45hnTQTOLI21"
"gwtjcpssGFAnLTqUSYZmheKgbk4LGua1Q+si8dCVnxtcKz3GNcmO6R0KYFGfUvAcURWbpzfF"
"7uXdcNhnLM4GLsP1o5sJgP1qJ97r29sReWGRquA/OtKeAm6Bx0fb8eNueCriPjtA5/qnezOY"
"XojoFQAGaxjI18QFxACgBR7ua0RHYwuAsrjuX5JuqCj/HgWYBuRC+PJs/PtlxukFrjgxJy3T"
"yxRcRJJGH5tCAIwmACY4oFUxO0/RmbUFSOk7/m0A2LYC81avkH4i3nej1poZB9D6DwD01h2A"
"iGE21n+8mQOYZByALQBmaghELjApgBUAFP+rDcYBbOLr8vUeMK14OEwDIGKi/vkI6STIa0lx"
"ka7iJVOId9uAz+IO5C7GH/8FCH9A4WeUjl8//xUK8r3fPz9VLaI3dw8i4tRS3N07FFc2tce5"
"FTVxfHYhgsEd+4ck56qfhLY/OfYPToEDg1Ni/6BU/Dg19g1MjZABdAC9U2EXHcDOrimwvUMy"
"bG2TFP5tk8KvbRIVW9prJ+DTISUm1XfDWCV6rvQSFPCI6hR7VR1DKPbBjKGV0mJoZYKAbkAA"
"0J0A6FmeEKiYWolfpQJV0mJg9fSqFTiMqcSIBhoAIxtmjnECMzvk1YNAfJzTIR/mdiIQZCKw"
"TxEcmFqIK1chHJtTBCfmF8WJBf/g5KLiar/DmaWl1S5IORXpklclNRtwx68mHmyvh8eBDRC5"
"pxGe7mmCp3ub4fn+VojY14YwaIawtXWxd3EN+EyohFndi2BQwyxoWTw1qngkQvE09sjrbEGe"
"RBbkT2xBoeQWlEpnQfUsFjQu4IDWxROgR4VkBJrsgXDDONnN2CYvZnQuhsUDKmPDhKbYtaQb"
"jvoMQfiuMbi5byjuH+qNewfa4W5wHa7W9XF/fxOKty0eh3aile+GJ4SQggBBpMXPOBULgBcX"
"htAJDKIz6M+v9bJxAATA/kZ0NnWY4lTnomEAsLUUrm35B1c2FsCltblxYSUBsDQzFxM3nF6U"
"jn/PVHSVSaOPT0+EfePifz9FABR1t0wUnVlbgJS+w18FgIODvW0rME+xgin7I7Izvt9p8UsX"
"Aa0bgrqYLkBfXfyLGEFhj4td9WOsv20XwBQBYwBgCoGqBrBO1wBE/K8IgYdMJx7SVTzk6z5i"
"SvFknE4FIqbp14g0LuKFdBL4/BWfv+HrvePPftwDfD3D5f0RgfCe/9T/JnTEQOHXT2tEqaLj"
"f/12pho/vjyja7iC94/O4vHpjTjn0xWH51XHnrGFETAkK3b0y4idvdIjsLeLcgAhvVJgX+8U"
"2NstGYI76djdKSmCOusI7ppMpQmzG/PC5uo/rrYGwHDm80OrUvBc1Qcwx+9dlqt8mdToxZDn"
"fcqnQc9yqdGxVAp0KpkSXcqmRDd+X4/yjApp0IuQ6Ev3MKCmGwYRAoPqZMSQOpkwuG4mtS14"
"euvcmNY6Fx9zYWa7PJjfOT8W0QWsHVQUZxcUxrXlRXFtxT+4sao4bniWxM21pXF7fVnc3lAB"
"9zZVxO2NlXBueQWELiyH3TNLYvvEYvAdXxzzuhfAsCY50KmqGxoWTYVKOVOhcJqEyJLAAWns"
"LEjKyzQ5IyXDhZHR0YIcCe1QKJk9SqSxQzlXe1T1cECtnA6ol8cOTQrYo3mROGhTLCG6lEmu"
"0pvh9bJgWvt8WD6wBNODyjiyqjbC6Tyub6+D27uqM82oTnHWwu2geoR3U9wLoQvZLwU8aeW1"
"IQQ64vGxzqqyH3FCcvxeeCZxqpcCgKz+Ly4O/U8ASA1AAaCxdgD8Pbd2VcFNpgACgOsCAO8C"
"uOyVBxdXZ0f4Cg+cW+aGs8vSMdVMhVPzk+HkHGccmhj/V+gYB+RIa+lvUQeB6hYg5Wf/tx2A"
"tRWYTt5YDo/E7b7ebvseDyj8+zIP0MZsCe5s7H8/PQAkrb+n42Mtv7X3L6v0bwCYrQFgTQFe"
"WAFgdQC+GgRi/1UKYKz/kwkGAPJa0/mahMBzCv/lYsYy/hydxBtPBt3EWz6+J1A+EAafdzBV"
"OAREnSUQ7hAIL6niz1CFxP/63y/dhhQg/PjC0GD4DQ7m8dvXL7h38SiOb1+KrXP7YPmQBpje"
"tgJG1ecKVzsXelXPjG60710rpEL38snQr0JiDKyQAKMqxMf4KvExt05CzKuXCIubJMbgqinR"
"t3IqHVVSo181ip6PMuk3sIoLBlbi57jS9y2nox9tfx++bg8Kv2e5lOjNj/tWckG/ymlUN2Aw"
"ITKEQBlJ+z+qQSau+pkxhjFWRoKbZCEEsmF4g6wY2SgbhtbPimF8PqJRDlUoXN83Czx7ZYVn"
"n2yY0jwzhhMenZl2NC/jggaFk6NK7qQokS0JcqdOCPfEcZE8jgMS8fKjfeRVqB+twasLzowU"
"jLR2dnBzsEfmuPYUvQPyJnVAfgq/QDI7FElhwT+pLCgm4WJB6fQWVHa3oFZ2C1oXi4fBtVNh"
"Rnt3bBiRF8Fzi+G4Zxlc9qmAm/4VcXNbJQZX4m3VcHNHba7KdSjM+rgVUA+3d9fFXbqSeyFN"
"8fBgK0KAIj7SEY+OdsbjsM7aCZzojmcnehACvZkO9DcAGKYeVQogAFBFwHZ4fIQAONA4JgW4"
"yRTgNwDQAVxenweX1uTAhdVZcH5FRoIyPUGQGmeWJCcEnKOPTouHPUMd3rsms7QTnTnYW0Rv"
"8WKbcX8JAEmTJrW2AlOJNUkY377W7dDGj/C8E/XT/CcetqELaBetU4BeagcgIpj7Px1tAGB1"
"AFYATNchwz+/1QBMETAGANIB8KZ4/fTH9/tpF/BINhiN+RcAGIi8XKIh8Joweb1MA+AdQfJh"
"M53AVgJgO/CFEPiyk64gkCDYy1ThCGFwko/n+Ci3O3tCk/CGuv8SI+z/bgF+qZqCGlxifHod"
"gdunA3Hcbw62ze6GFYPrYHq7isy5S6BbtXxoUjYLqhfNgIp5U6Nk9sQomjk+8rs6IFcarnop"
"LchCq+uRzIKsSS3ITOubJakdMiVmONvBI4kD3BM5wJWRNakjsiVz4ueckJnhzsiW1Am5Uzgh"
"R/LYyMmPc6WMg9yMPKniIF/quMiZMh4yp4gHj5Q6spqPXZydkDqREx/jIHk8RyRxslcRz4jW"
"3oj5/xZ2RuTyM4ko7iQUd3JHe6RkpOZrpYvL9x/PARnkuaMd0jtYkIEuIL1FR1qL/jhTHAuy"
"x7egCP8mVT3s0KJwPAyo4YzZHdJg04gs2DM9D06vLIqrPqUpsnK4IdN3Wyrg8qYKuORTEVd8"
"K+Hqliq45id9edryHTVxa2dt3AoUkTYgABoTAM3oAijeg63pAtrjUahAQNIBugA6gacEgXIC"
"tg7gPwAg8GipAbCX7iKohk4B/HUN4PpmGwCsNQBYmZGRAedWpo4+vyw50ynnn6dnx8f6bg6P"
"4jpaaln03YBFb3FFf38VAJUrVxYXENemFVhq/6Ya4XjXHd9uNv+BR21tANBT7wOQ/N8KgAgb"
"CKjVn6I80q/lAAAgAElEQVSPnKlXbFn9RfwyCPRCVv/lJgVYa1Z/AYC/ngu439OkAcNtUoCJ"
"BgAzfgfAKxH/Coqf8VYAQDfxwYcA2EIAbKP4d1P8IYz9BADdwPfDDH4cJUDYiehPfoj+6Ief"
"n3bi58cgxmF1w9Nf327j1/dIAuLdf3YWDCi+fPyAO+cP4Pi2hdixoDc8RzTA3K7VMK55aQyo"
"XxAdq2VHi3IZ0ahEGtQsmAwVcyZEKQ9H/JOReW5aCwVqoWgtyEbxZ0pIUVAIaWiJU9lpm5xE"
"hGUE5sRw/GN1tTci/Ddh/r/Ea/s6jub1JeJSyPEYCeztkNDBDokYiSUo4CROdkgahyJnpOQq"
"npzCTiqf59eT2vP92unVXiIhI455TXn/CWycgEdcEbs9qmSOh9ZF42NQdWfMb5sGPgNdETgu"
"M47PyY3wlQUpoMJcSYsifPU/OLuKqYlnMZzzKoVw7zK4tKk8rhAAV30r4urmigSCzORX4Ups"
"ALCrLlf/+rgTZAOAfc0JAbqAA23x8DAhcKSDqglEhHUhAEw94ExfUwOQIuBAPOfH1jbg49A2"
"BIi8jhQB6+CuOICdlRQArm0piWsEwNVNBZkG5MHldTlwcQ0B4EkArKIDWJE6Onx5chyb5/wj"
"fF58zGppHy76smkBxtX6+4sAKFeunIVpiLpZKAGQk4/FtiytGIJ3PQmAFv8CANP/f2oKgBHj"
"fq/+y+qvACDW34g/cokWvwj9xWoDgPUaAgKASLqD+310IVClAGNiAfBksnEAcwmA+Xr1FwC8"
"WanjLd3DO77WB6YSH/11CvCFQv8axODqH3WA4icEog4yCIFve5gR7CIEtuEnf+Yn4fHj9Wr8"
"eLUKUXyPUc8ZkWvwLXIDvj3fjKiXu9Xto6LeX1DbnGWK7P65XTi5Yz62z+2NZQMbYGrbynQA"
"JdG1al40K+OBOkXTo1r+VKiQOzHKZI+HkgRAMVrbIhlofdPZI4+LPXKlsEd2WmGPxLTHieyR"
"MYE9MsTjqkmhuZhILaKLY0RnFSVF6sxI9GcY4TrbRBKuykmdYkMEbQ3b70tEIUsktNORwM4S"
"4wqcDDD+G2DsjdiT8efTJbDQiTiijFsc1M8VB51Lxce4usmxvKMLNvZJi8CRbjg2zQOnZ2XF"
"6dnZGDnUTVmOz86No7NyI3ReHhxbmB8nFhfEKRnYWl0UF9aVwIX1pXHRW+x/OZUCCAQu+5RX"
"ILi2pTKu+1WhC6hBB1DHBgBMAfYaAOwTC08hH2pHCLSjE6ALYDoQcbQLRU4XcMqkAYSAPEae"
"7oOnTBGeHO2gxoEfHmiq24B7TAqwnQDwK0sHUoLip0vZWBCXNxAA63Pi0roshJc7wj0zEAJ0"
"AATA8QUaAKPr24VYdAtQdJaE2b+T6O+vAqBChQrWVqAzASA3KSw0e3TRDXjfC99utfqOR+0J"
"gA7Rejdgr9gJwAhr/3+c6f9PNNV/uoBIKdpRrM9k/HepHv55Yfr/LyjYl+t+B4AU+e731fZf"
"Vv/HIn7C5fF4Xf1XDsAA4MUiGwDQTbxda1KATQYAO40D2KNdgAhfHECUuAF+7lsgAbBDAeDX"
"B3/8er8FP9/64scbH0QxJYl64YWoZyvxNWIhPj+ajU/3p+PjvWn4cGcy3t8ay5iI19cm4Vn4"
"ODw4NgzXg3vjuHc77FnUBN7ja2JBv3IY27EQ+tbPhnYV06N+oWQony0eitIB5ObKnzmRBW7x"
"9cqf2uH3VT++EZ3jHyu9nY0Q7W2+9t/C+j3/L0fwf3MK8l6cKeoUXLldmZ5kT+6AIumdUN49"
"DmrliIPmReOhVzlnTKmbFLNqJcaCes7wbJkE27unxMHBaXB4ZDocHeeKsInuODbVHWGTM6uJ"
"ygMTMmP/eMYED+wbx48nZsGRaTlwbG5unJSDWmXL9vLCZvUvinOri+H8upIGAmVVCqABII8y"
"kltZuYAbW3Ut4FaAdgHKAQQ3pW2XaK4Kgg8OtompB1hdQMQxqwvoo8T/zDoDwK89PiJDQC0o"
"/iZ6Q1BQHdwJqK4Gga5vMXsBfKQNmN8GAFlxcZ07LqzRAAhfqQDwPXxOfHSpYL9B9EUAqJuB"
"SgtQ6+//MwCcnJxifmnbtm0tGTO6SSswYcIEceUmhfka1czIK74PAdCaAOhgANDNZjeg1AGG"
"2gwAjTcQMGmAFQBW8avWn7H+L71ixa9SgK0635cW4KPhugWoioB/AmCOLgLGAGCVKQB66U7A"
"bwAIsHEABgDfD+h6QFQQARBAAOzAr49bCQFbAFD8fI/iAL4+XYUvEcvx+fESfHq4GB/vL8CH"
"e7Pw/vYUvLsxFm+vjcG766Pw4dowfLwyGB8vD8KnK4xLg/AxnKsIL7C7wa1weUtDnPCqhcOr"
"qyFoUVkEzi+JVUMKYmGvvBjTIgv61M6IHjVd0axUCjQulhyNiknBLQmhkRjlsjmjbHZnpg+J"
"4JEoLjyc48I9YRy6hThwS+AEV0YG8+iW0AkZmd+7O+tw5fMC6eKiqFs8FHElgFzjojijsgcj"
"cxwV9fPGRT1Gi8Lx0aNUAgwolxAz6iTGjLrOWNjAGcuaJcaaNonh2ykZAnqkwJGBqRkuCB3q"
"gqPD0mC/HIjSRc87BHRKrluf3VJia7dU2N7bBbsGpEPgoAzYLdOTcqbCuExqwlLtsJQR68lZ"
"+ZgNR6fnRBgdQNjcPDhBCJxcUhCnxQEQAuc8bQCwgWnARrqAjeWVAxAAXNusHcB1fwJg+x8A"
"kG5AcBOu3IRASEvcP9Cadl6q+rKyd6ADoAswacDT0731AJC0BtXq3wmPDvH799NF7BX7z9fc"
"LbsBq8UCYJMeBZY5AEkBrmzISQhkxSWvTIRABoSvcYm+6EkALNQAKJ3VfproK35cR3UzUNGd"
"6M+6GIsu/78BwF51/yyWXr16WfLkzq1agYkSxsvIxzwlCrkMwIue+H633S8FAOtuQHUmYD89"
"BBRhOgEqDRhragGmFRhJ+/98oR7tfe6pQ3r/svK/XP97///NZm37FQBMCqAgYAqBMTUAvmYk"
"XcBLAcAyAwC6ibd8rXc+JgXwM0XAXcYBWFMAWwAEI/qLAGAnAUAIfNjBNGArAbBZOwC+Pw0A"
"cQEEwCOK/+FCAmAuPt6dQQBMJQAm4M3VcXh1aSRehg/BizPMG0/1Q+QpXkDH++BZGC8oAuBp"
"aFtEHm2F56HN8eKIRFO8ONwIzw40xLOQBni2pw4idtfCk11V8Zi28qF/Rdz3q4B7vuVw36c0"
"bnuVwG054XhJUa6ceXFwbG6EjMiB4MFZEDQgMwL7uSOwL6OPOwL6ZERg/0wIGpgZuwdkwo5e"
"bjgyyh0nRmfCsREZcZz2+/gIWnCKMWxwOoQOSstIowR9aIALDvdLhUN9U2Jfz+QI6ZMcexkh"
"fVMgpHcKBPdOiSDGzu4psKtHKmyj0Dc2S4L1DZ2xgY+bWiXD5tbJ4NcxObZ3la3PqbC7rwv2"
"DEyH4CEZEDLSFftHufH9u+MQV/+DXP0PTcqCwwTAYdl2TQdwVA5jmZNbA4ApwOkVBMBKAcA/"
"MQCIcQGEgIAgJgWg+FUhcHstXQcIlDSgESEg4m/8OwAOaQA8oQvQdYAetPuMUz3VUJCCAV2B"
"tA0fHmilVn+947Qe7gbUihkFvkYAXPEhADYUxmWv/BoA3rk0ADZkwiVvV1xc74JLa1Pw3+P8"
"68TUeMiV3m6A6CtBvDiis/i5qTvRn/wnevwrAOjWrZslV86cqhUYP35c1QrMkz1Zx+/3u3yK"
"lrz/oaz+tucBGACoMeARZgpwjAaAqgFIEXCO2f23XFv+F6bvL+J/ScG+8tEAeOOnHYGM/6oW"
"4FBTBJQ6wGjjAGwAoGoAXP1frYhd/QUA72X1J0g++RsAWB1AyL84AAHAbrqAQPz6xPgYgJ/v"
"t+PHWz9EEUhRfH9Rkevw9dlaQmANvjxZhU+PlhEAi5gKzFG3M3t3cxIBMB5vr9IJXB6BNxeG"
"4nX4ILxmDvn67AC8IggiZXVhvvlYLqK9TXgxNuSFWZc2tRYvVtlTXoOrV1WuYpVx2Vt23ZWh"
"bSyN854lcW5lCZxbXkxNJ55cUAQn58kx5gXVjUxPyp4FiiZsogeOUkxHx3JVHe1Oy82g2EPH"
"evAxMw4My4igQa6EhCt298tAUMicQjoE9E7L1ZyrMyOglzymprBTYUeXFNjGVdyvPYXcIQm2"
"dk6qti8HyFZmCj+IDiCYK/5Oity3KUXf2BmbKf7NzZPAr1VS+LdJhq0dkmNbl5RMA1JhF187"
"sG9awig99hACe+VEJdlPMT4TDk0UANAFTKUDkJ2X03MgdEZOHJVDWWSX5uICOL2sMM6sLIJz"
"qwiANSUQvq4ULniJCyhLcZXTNYDNlbj6V1X2XwBwgwC4sUPm9evFAsDGAegUoJ1KAZ7EFAIN"
"AE52xzOKXxxBBFf/x4fbc/Xnz4TIzzfA3cA66kAQ625A2Qx0xeoA1usUQDmADVkJqEz8mhsB"
"kYYfp4g+uywx9o+N+8k9pV1H0Ve8uE6qBZiTuhP9/VUA9OjRw5JTAyBu3DhOqeUNpkwep/7j"
"M62f4llP/LrfiS6gC11Ajz9qAMYBPLHuBJxg7L8RqgLACj3G+8L0/KXt98rM/r+haN9uMx2A"
"AVr4MV2AfwPAHO0qRPyvPY3412v7/96s/p+2mRQg8I8awBGGKQISAtFfCIHPQQQA42MgAbCL"
"LmA7opQLYCrwfAO+Ggh8iVhNF7ACnx5IGjAPH+7OJgCm4c21yYQAncCl0RT/MLw6N4QxCC9O"
"0zydoJ0M60oHQJt5pDUimEc+OSB5ZD08CKqN+3Ka0a7auLO9Bu7w4r1NC3tzk5xjUBbXvErh"
"ytqSuLKmJC6uKo5wGc9dVJjiL4iTs/Mxn+ZKOZGiGUfxjKbYR2bCweHuODCU4hohW5Yp/uGZ"
"EDIoI/YPdcM+QmDfwAzYz9hHCIT0SctIg5B+adQpx3v7uVDYqSnwlNgt25Y76Z2Lcm6BnGMQ"
"1FMiBQK6pcBm5vjrmRp4c+X3IQC86yeGdyPCoHlSbBEH0I4A6JwCOwiAgF6pNQD6awCECABG"
"awAcpvgPy2Ersttyeja1+h81ADg2Ly9dQH6cWlIIZ1QtgP/+1cUVADQEmAZsKKe7ATEAqK6K"
"gDe21VIQ0MVAipbi1zUAKQYSxId0J0BPBnZRK70AQGYCrPFE5gT4/+0Rv1eKhwoAklIEECw7"
"a+DWDuk6VMA1XwOAjQSADAIZAFzxzkbhZ8aVzW5ME9IQVil+XVjpjC394z5NHM+uvugrjtZZ"
"XNGd6O+vAqB79+6W5s3lhGJLHHsHx+SOjnbSoihzxL/eVbwfgG+3u/5ARC8CoFd0zDkACgC2"
"B4GYQqDqAMz5fe5fAPDSWH4R/ysK//UWbf3f7tJzAg8GmQLg0NgUQGoAv00CClQWGwCs1iv/"
"W77eO4r//Rad/ysA7DBFwGDGPt0B+BFqOgH7FAQ0APYYAOwmAOgC3u3AdzqSqFe+/wmAx3QB"
"D+kCHizEh3vz8P7WDLy9MZUQoBO4PAZvLo5QEHhNCLwUAJzsqwAQcaQ9njCPfLS/ucoj76k9"
"5RT+Tl5M22vilj8v3C1Vcd23Eq5xVbuyTmbv5QwDiZIIpws4SxdwZgFXwwUF9a7FGeIAsiNs"
"kkDAA6Fc9WX1PzRcdivKoSWZuPq7Y9/gjNg7xA3BA10RTAcQTPHv6ZUWQb3S0NLLgaYSLtgt"
"Qu2ZWglcdi5u75gM2zrKzsWk2NU1mRL/zi7JKPhEWF+Pom+QGBsEAvUZ9QiAhomxiY5gc4uk"
"BECyWAD05uv20wAIksNUh7sqB3BY7rkw0QBADl6ZmV0BQByApADKASwqgFNL+W9eEesAlAsg"
"GMUFXKILiO0CVIl1AHRWN/h3VcXAXRRtkNj/JgYAUgQ0rUACQBcBu6oiYIQZDIo43lVZ/yfS"
"KaBbEADc38vXCBIA1PkPAKgioOkCXPXJy8jFj7MRTJlx1S9j9A3/tDjvleLH1ZWJMb9d3Kui"
"Kwc7Sx4HR6fkojfRnejvrwOgT58+GgD2DkmcHO2kRVHcf2XVg/gwEN/u9PyBp/0Q/ahftD4E"
"ZKCZBLSeBWi7CcgAQAp1L1bo3P+FWH+u/K99dM7/msJ/429ih27zPbQK38wAxEwCTtaHiqj8"
"X2YJZAZAzhGQ3J+v+Y6v946v995fDwF9ov3/TPv/xaz+3w6YIaCjDHEBsqFo3x8ACDQA2EkA"
"bMV3vr/vzzfiW+T6WACoNGCldgH3FuD97Vl4d2M63l6fgrdXxhMA4gIIgfN0AWcG4qXUA8K6"
"GQC0xOP9TfEwRBeS7u2uoy6mOwIAqVzLBSyFrI28oOXi5oV+cbXc2KS4AsC5JQKAQjg1Lz9O"
"ziIApufCsSlcLSdlNy6AghrhrlzAQQpfxL9/SEaEEAAhBMDeGAAwH2cKEEwHsFfETwgEUfy7"
"u8vuRYbk7tadi52SKhcg9n87YeDdKCE21EsIr7rO8KqVCF61E2FDHQKhjjM/nxg+TZLAt7kB"
"QKcU2N5VUgANgEDjAPYKAEZnVAAQB6CKgLL6z8qBsFm5CIFcv9cAmAKoGoA4AP5NxAWcJxzD"
"15Ribl1WFQKtXQBxAaoOsJWp1faaxgVILaChrgEEaweg7X+H2C7A0c7KCejx4G4xAHh8iKnC"
"/lZMG5rbAEDAXUMdOxdTBNxSQs0BXPMtyI/z4frm3Pw4O6HkIQ4g+vrmNDi3NsWPK8ucMb6x"
"00HRFQGQ097BKYnoTXT3PwGArl27ylNHe3tHZwJAWhSF548vuREfBuHb3d7f8Wwgoh8PjNZ5"
"/zCzD+AP8T81xT9ZqUWoYu2frzEA2Bgr/tdbtfi54qpU4NEYHY/N8I/YfrXyTzGr/0w9TBS5"
"WM8SiPjfeMUCQFb/D1z5P1L8n+govpjc/5uIXey/iP8YH0NNGrDPJgXYbeMArADYgu8vNqk5"
"AA2ANQSApwbAw6VMAxbi/Z25eHtzFl0AIXB1ItOAsXh9YSQBMJQAGPQ7AA63JgCaxQDgvoyp"
"iv3fUQu3ZYDFCgAfDYDLa0oqF6AB8I86t0AAcHq+nFsgNYA8OD6NYhEITMiGI2M8tPVnzi8A"
"kMf9Qw0AhmoA7O2vHYAVAMHMz/eofQt0AD24WndjdKHN76oBsN0AYHMrZ1p+ip+xngBYR/Gv"
"rZ4I62pQ/Hy+vja/XjcxNjYmAJoxDWibDFs7EgBdUmJnDwKgj64BBMuR6iN1DeCwHLKqxJ+V"
"tp+r/yy6mdm5VBvw+AICbpHYf7qdZdoBnF3JvwH/Fuc8DQDWEgDrjAsQCPjQBZhW4HW/6lyd"
"aygncHOnzO1bAdBUO4BD1mEgXQNQcdQAgOJ/cqyzyv0fH+D37mtp0ofGMSlATA1AzgMwuwFl"
"FPi6X2FGftzwz6MAcMWXKYCvW/Q13zQ4uzr598uLndGzisNG0RUBkI0OwFn0Jrr7awCwtgG7"
"dOliGTRokAKAxWKXME4ce2lR5G/VIMtMfBhMAPQhAAYTAEOjteUfZaYAbQ8AmWZT/JMNO8v0"
"fn8l/g02AGCe/ppifcN4F6gdgmz+eTzB9P4p/CfTtPAjbPYSqFHixXon4Gu+5huT+ysA+GkA"
"iPg/0/p/2asnAEX836T4F0YAHNcgUGnAAQIgxDiAPQYAu0wKIADwMwDwJgC8CIC1BMBq4wCW"
"qmLg+zvz8PbWbAJgJgEgacA4AmAUATBMOYAXJ/vYAKAt83/ZTtpYH2QaVFc7gB01FQBuSQ5r"
"dQDry+DyWgFASQ2AZVwBCYDTtP8KAHMpjtn5mAbkwbGpXDUn0AWMzYLDozJrCNi4AAHAPgUC"
"N4QoCFCIfWwAYCAgAAgUCNABSAqwo7NOATY2puDrJMCG+rLyJ4BXnYRYW5MAqMYgALysAKhn"
"ANDcAKCDFBNTqjRAagBBgwif4RoABwUActCKAUAYxX9sTg4cF/HPI9i4+p9YbADAFEAVApcX"
"wZmVTIVWaQiIA7ggJzzxb6WKgd78u/lY5wGq4Zq/TgWUAwhowDSgkSkCWmsAuggobcAnYveV"
"C+isxC+PvwFAagjBchJQfYpfOwABgNoLsL08f08pCr8YQVCY4icA/OgAfLOrGsClja7RV33S"
"4PSK5N8vzHdGpdwOM0VXjg4WD4udfULRm+hO9PdX2oDW/1q3bm1ZtGiRxd09o9oWnCB+HHcp"
"VJT+J+1QvB2IqPv9f+LZEETLyv/UWvAbY/L+SabtN0P3/p9bhbpct/2s9v+lrfXnyv9WIlBv"
"9VVjv5PN2O+U2C3A1m3EavVfqGsKMkvwmqv/mw0GAJL/01F84Ot9ovXnqo4vZgRYNgR9E9vP"
"1f/HCUaY6QbIEWR0AZ+D8UuCEIitAVgB4Itvz72VC/gSsU7dxvyTKgQuIQAW48PdeXh3aw4B"
"MANvr03G28sTmAaMYRowXDkAXQPohqe8wCJkO+qBlni0j6tQsAyT1NWriTgAuVD9dBpw3acC"
"rsqqxhUuxgEIABbFAuC0nF5kA4CwiToNCKULUBCQgiBBIEXA/UPdsY9uIGSQBkDIICsENACC"
"erroFEAAIA6gsz7CbCtt/Pr6CbC2dnxGAh01GTUSYE31hDEOQAFAUoAGJgWQjkBr7QC2dZaW"
"oXYAvwFgrHus/Z+h8/+w2QTAPAJgvgbAySXSASikHMDp5QIApkAr6AIIgXOeVgdQRgNgAwEg"
"BcGN/NttqkTxyd4ASQVqKADc2d1QA8DqAA621XWAQ3ok+IlKBRhqf0AnDQAZFRZQ7JNzDJsS"
"HnwN2V+ws5aqAcgcgJwHcHMHAbC9NH9XcUYRBYDrWzQALm8UALjh6sY0BFnyn2dnOiOvq8NQ"
"1QGI4yj6SuCeMaOD6E70Z/3vrwCgTZs2lnnz5lnc3FzVLEC8uE7p5Y0WyJ2ia/Sj3l9/Sc7/"
"1Gr9rYd/UvzPJsTuAlQAML1/tfqvtHEA3rrw92aLXvkFAO92axiI3X9szfWn6Wq/dfuw2kOw"
"QItf7P9zQuXVan2AyBvT+1f5P1/zA1f/TwQKV/VYB0CxfxPbf1xvBFJpwBEFgeiv2gX8+sz4"
"tBc/PwQRALsIgG0EgD8BsIUA8FEu4EuEFwGwxqQAyzQA7vwJgPF4beoAr84MZgrQH5HHemgA"
"HGlHB9BKH2W+t2FMQemOtKtiAEAXIBfwhgq4LBc3xS8dgPMEwNlFugB4ep4VAPlxYmZeAiA3"
"AaDTgNCxWXUqQAgIAGIgMMJduYB9Q9ywnxEyIMNvDiCohwZAQBcNgG0U/7raCbGmZjysrRUf"
"q2swqiVg8LEqH6sYAKjVPxE21HXGxkZJYgCwpc0fKYA4gIGSAugugDiAQ1IDmOyhU4CZOgVQ"
"DsAKgKUaADIIdMYWAKuKxaYAXlYAlMWl9f8CAJUCyN79BrETgSJoWdnVMFA7rvQi9PZ6xQ/t"
"oBxAhBwEKjCQFiC/T4qHcuL0nV11lAP4EwA3d5ahEyihAHB9S37+/tx0I9kUAC57u+KSlwtO"
"L07OtCfBVw8Xu66qA+DkIPqKL3oT3Yn+/ioAhEALFiywuLm6qlagk5Oji7zRNKniNXx2vmMk"
"Iofg1+Mhv/B0JKJjHIAtACja59YxXbPh5+XKWAcgPf9XvrGr/5udFG6wrg+o3H+SDmuxT+0f"
"mG/C7CNQuwjNayoAeOvV/x3t/3vm/h+4+jOf1wAQB3DAAEBsv6z+p7QL+K5rAdFfCYEv+wkA"
"xqcQAmDPfwfA0/UGAJ4EwAp8ZBqgUgBVA5hhUgCpAViLgIMMAOTAyy6IEJspwycHTE/5TwD4"
"Sx2AF+0mWtgNFTUAmAIIBC6oGkAR3QGYm0+lANIKPEkHcHw6ITBFXEAOnQqMz4rDY7LQBWTW"
"rcCRHuq+hfuVGyAEVCqQAXv72dQAVAqgC4Hb2ljFn0AJf1XVeFhVJT48Gasq8VGiMr9eRQNg"
"Q91EugsgbUDm/9IFUClAJ+MAepgugE0NQAFgYubfHMCxOTmV+E8slPw/FgC/OQCTAggA1CzA"
"+rKx8wAbyisAXFFpgNUBaADEFAElBdhLS79Phzon4EAbtdJrAHRUNQDZHKRSgiMGACHN+bON"
"cCfAxgEEVNPnATAFuLmjDG7tKIGb24qoGoAVADIIdHmDG857pv51fglTqkHxI5MlsDQUXTk6"
"Ooi+4rpSb6K7v+4A5A3Mnz/fUqdObfkwDvOT5I4OdrJdsVzY9kbX8WEkoh4M+YHI0YiOGBOt"
"xc+V+9lE0/efE9v3jxG/p97iawWAsv9btfjfUqzvaNUjCI3Hstlnijk+fJY5P3Ch2UNgu49g"
"lTlHcK0eH34j9n9LLAA+CgD4mrT0sQDgav9NbL+IX84GOK1hQAhoABwkAA4QAPsIgGACIBDf"
"3+7UEHjlh28vfWMA8PkJ04DH2gV8vL+EAJhPAMzWRUCZB7hkAHBusOkCDMDzY73xNKw7AdBZ"
"rShqIIhpgMopxVLuMq1AuVglb5WjzHkhX+bFfWkdL/I1ciwXL/wlBMBC6QJQHFIEnJVXFQJP"
"8PG4pAJT6AQm50Qo04Ej4wQCdAKjKf5ROvaPyKy6AnslBSAAQvpLHSBNDACCCIPt7VMwx3fW"
"AKiVQIl/ZaV4WviV42NlRUJAolJCrCYE1tUkAOpx9W+g838BwJZWugvwGwCMA5AOwH4ZBZY7"
"LNkA4Nhs2QNgBYDJ/wmAmBrAct0JsOb/0gq8sM4WAOVVDUADoIICwPUYB6CLgDE1gL0U8z4r"
"BFopgSsASEEwrLMCQEQMADqYNmDzmCJgjAOQGsBOOYug3O8OQACwKZeaAyAAoi+vd2X+n/rH"
"5SXJsbhj/OuiJwc7S147ewfVAqxTu7bS3V8HgFgQeSMdO3ZUX7JY7JLGcbLPxefFd6yuGYqP"
"o/BNAPB8LAEwNlrN/T+TE3ytM/9WACyOFf8rs+FHDQCJA9hiAECxvtuji4GPJ5tTg2eZk4Pn"
"6VODZMVXI8TL9RyBOkbcjBHLISIi/rebdOvPmv8LAGT1/7yPAKD4vx7S4v8mgpeTguQcgDM2"
"AGvAFigAACAASURBVDhCABwiAA4qF/DzY4hKA76/CyAAdhAA2wgA7QIUACLWxgJAHMBdAkBS"
"gOtSBJxKAIwzADAO4PQARB7vrQZNVKtJAKAuKLmjkWkrCQR2yM1MatEFMGelC7juUwlXJadd"
"x4tbrO4qWt6ldAGLCtEFSAogrcB8OM04aVKBE3QCxyUdmJRTOYEjdAFHRtMJUPxyG/MDIzPp"
"YqAUApkC7DUAkHkAmQPY0TElc35n1eKzOgDParL6CwT06r+ygjgAnQKsqWragHQACgCmBbi5"
"pXYA/h00AKQNuHtAOuwZLKPATEHGZNRDQAKAqVm4+lsBkEsDYAHBtiS/cgBWAKhBoBVFlf2P"
"7QKUVjWAmHkA798dQAwAdsjGHWsRsIl2ANLaUw5AtvjSARxsq1IBDYBuehZAOgKhnRQAHu5v"
"EQPte7vr6i4AUwAFgO06BRAHoADgrx3AlY0EgDcBsIEAWJn6xxUCYHKzeKGiJ0d7Sy6LnUNS"
"0ZnoTXT3P5ECyBtp2bKlAYB9YicnO7lpYZGVM8pvxcfRBMDw73g+jgAYF60q/5HM+5/P1tbf"
"CgBp/b20Hvax1oz+bvgXAHCVfrZM236x+09Ni08Jf6keH36+KnbnYMzuQTNJ+IbW/+0WLX5l"
"/5n/f5TVf68R/xFt/aOY+0fJISBnNQDk8ftJ9flofj36yxH8UhA4QACIC9iLH+9248ebXfjx"
"ihB46YeoyE34SgCoQuDj1QYAy/Hh3kK8uz1Pu4Br0/D28kRdAzg/XNcATvfXADjaTacBkm9K"
"7inbUkPkJhONzd2M6uGOHGm1jRCQFtYmuR8fL2YvAoB57gXPEji/jBf/0qLGCZijzCn+U3MK"
"0hEQAjPy4fg0XRM4OimHcgECgIMjxAGYFEBagrL6DxAHkF4NAklsp/g31E+sKvnaASSKSQE0"
"BDQAZPVfXSUB1lQzNQAbAPg01Q5AQaC1BsCOrqkQQLgEDdJ7AfbJicrjf8//w2bpAqA1BVAt"
"wMX5FAROLS2oJgElFbB2ARQAVBegpOoCqFRA/k62RcAtVWO6AAKA37sAei+AOhtAagCH2mn7"
"L0U/GduWA0LUMJCGtkwCyl4A2Qx0XzYDWW8MElBNHQjyWw3AX7cBZQ7A1ACir/q44uzq1N+v"
"LJVzDZ22ip4IgOx2dg6JRWeit/8JByC7kebMmaP6kU6OjrItOGHcOA5Z+Ji/V7s8CzQARn7H"
"i0mIfjopWhf9uHI/t078LTCDP0uNA/gTAL5m8s9f23+ZA1BVf+tdgxbYCN8qfhsHoXYPeptU"
"YpM+Qeidvxb/e6YUH5j7f9xrVn+u/F8p/m/HtPijTplTgMINBM4oCERHiQs4SgAQAp8JgY9M"
"BT7sw4/3IfjxNgg/Xu+iC9iK78834+uzjXQAXvj8WEaCV+HTg5UEwCK6gAV4d2ueaQVOMS5g"
"FF6dHaocwPPjfVUd4JkAQGymDKEoCMjegOZ6Rl0s6k6BAO0lU4Ebm3kBiwsQa7u+HNOAMji/"
"ohTOLaMFXmKtB9Aaz5WiYCENgVmxEAibIq3BHKooeGhUFp0CDM+MEEkBZCBogJ4HCOmXDrs6"
"p1IFvA0NkmgA1HZWbb7VNWIB4FlN1wAk1lSTLoCeA7A6AO96sTMA1klASQF2dIsFgBT/9o+V"
"26ZrAByZEguA31OAvLoNKHMAi/nvWlxItwGNA9BpgC4CxgBA0qUNsSnANd+qMXMAMW3A3Y1i"
"awCqCNjmX7sAqgagDgExewHk/9dBKRjKeQKNY3cDBugi4C0C4JbVAQgApAgoANgkDoAA2OSG"
"M54u3y8tSoZ6hR0XiJ6cHCyiq4SUmaPoTXRn3Q341wAgVmTy5MmWadOmWbJmzapagQkTxM0k"
"BYuyxdINx/sR+PZw5A+8mILoZ9OiETndpuW3UFt/VfxbGlv8sx75Lf1/BQA/M/xDsT7j9z2S"
"yr+5aYgq8hm7r3L9taZ7sN60EE0XQdURtujtw3Iq8AcRf6AW/6f9BABXfwoaX49p66/Ef8aI"
"/0IsBJgK/OLXf/H7or8YJ/BJQ+D7+334/nYvvr8ORBTTgCi6gK+Rm/H5qbeqA3xWLmAVPt6V"
"QuAiAoCpwI3ZJg2YQACMxqtzphWo6gB98SyMF9WRLkwDOqqq86ODcqsppgOyIkmbSTat7NIQ"
"uMlU4IYUsjbSzm6UO/TK7blK4/zKEji7vDhdwD96NHhhEZxmnJpXmC5AIFBAQ4DpwNHJuRA6"
"XuoB2XCYTuDAiMxMAdzVPEBwf90SDOyeluJPBp8mSbmKxwJgTY1YAFhjTXXdBfgTAN71nH8r"
"AkoNwN9sBlKjwLIb0BYA4/QQUOhUAmBa1pgCoKQAJxbkUQVAKwBkFFgAcGppIQWA3+YArG1A"
"sydANlJZUwDZXKUAoHYF1tNdAHEAQU1iHcC/AMBaA/gNADIwdKgNoyX/fzXRAAiqrc4DkCLg"
"rZ0EwK6yNgDIp2oAygH4ZI6+5uuGs54uP8LnJUU+N4fhoqf4cR1FVwmyZs3iIHoT3ZnU++8C"
"YMqUKZZJkyZZPDw8dCswnlMGecMF86TsjicDv/16MppCnQItfuvq/ycAbKr/r8yq/VLsv5+O"
"tzs1CB7JsM9U3etXq7/tqu8VOzj0yho+sRCRw0PebddThFL5Z96OjxT/p4MU/2GKn3n/V4r/"
"G8UfRfFHnafgLzIumcdwVRD89fUUV/6T+Pn5GMUfxhQgVMWvT4cZB5Ub+PkuiC5gO7692Iov"
"z7bQBWgISDfg432mAXeW4P0tpgI35jANmIE3kgYQAK/PjaALGIIXpwfh+Yl+dAG9mAbwwgrt"
"zotNbovdjSDoRHvZnhDgBRnSQl2gd+UwS4GAn4GAjxy/Lfflq8CLviztrzgBgmAp7fDifxgU"
"xaJ/6AgIA4Lg1FzCYHYBHJ9KJzBJnEBOgiCbcgIHZXMQXcD+Ie4I6pMBW1qkwqamKShcDQFv"
"QkBSABnwWS2Ct0KAz9fU0LFWhZkErGkcQH2dAqj8X+x/ew2AndJa7JuG+X/6mPz/wDjjAKZ5"
"6D0A05kCyJ2Y5uRS+b9sAFIA4KOMAp/8txRgjU0b0EsPAqni3yY9DSg7LG/sqKV2XN6yLQIK"
"APa2UDUA1QYUAFDgT9TxYB11CmALABkPlvMDD8vWYTkPsFnsgSDqVODKuL3Ttg1YOLYNKHsB"
"fDMzHXHje3VB2LQk37K42Mu4X564cRxFV/E9PDLbi95Ed/8TABASyZvhG7PuCkwjbziTa6Lm"
"b6/1eoXIsVz9J/3C85mm3z/3vwBgVSwAXluF66/Fq1Z/rvaPxpthH5nwW2yzYWh97GYhFT4G"
"INYRYj9dR4gBgKz+wRQ/V/7PFP+X0NjV/xvF/+0sc/0LiP5+CdE/LvPxonEC5vF7uAZE1Dmm"
"Aqfx4+MxfHt1EF9fBOPr8yBGAH68DKD4t+HLUz/GZnx6sl4VAz+qNIAu4PZCvL8xF+8IgLeX"
"JuHthbF4fV4AMEwD4KTUAvrhGZ3A07A+eHK0Ny+6XoRAT15Y3ekGuvLi6kCLKbfPbsEcU+63"
"V4cQ0JuEpK991ZsQWF+Bq145hNMNnFtRgiDQd+8RIMiNPM4SBmcIA+UIBAJ0AmGTc+PoRIFA"
"DhwekxUHR3pg35BM2NohLcXqQtGmYqTEphbJaeOTYn3dJBS2sxr2URAwsab6HwCQqKn3AmyU"
"jUAtZGQ4GR1AMvgJADqLA5AOgAaAdADkMJADsg1YDgKhAzhiNgGFzdIOwDoCfHyRcQAGAKoT"
"sJQOYLmZAzD5v+oCrDdtQMn/fc2uQK78N+VgUDkheGesA9CbgqxHhbfSLkAKgFIHONLhNweg"
"DgqVsWBxAeqmIq00AMytwcQBWGsAahBoW3E1CWitAcggkOwFuOqX8ddlL7qgMc6vXBJbZLdd"
"njhOjqKruKIz0dv/lAOQaNhQWpWWuPb29ins7VUrsNKZPa1u48MkRD2eyDRgFkEwO1oB4MUC"
"M/izJHb455XZ9/96gwHAZpP/79JCFvE/Mbv7rLm/Wv3XxVp9Fb42zzfHAkC2D7+jk3hvXf1D"
"DABo/b/I6n+cwmfu/+20Fnn0Ff6zbzBuMq4DP68qIPz4cg5R70/peHsS39+dQPTXs/w6fwYE"
"BAiHX2fw9eVeRL3RKcFngQBdwKfH6wiAVTEAeHdzPt5JN+DyZD0NeH4UXcBwXRA8N1THGXEE"
"g9UNMCOPD+QFNhARxxhH+3Ol6UOb2YM2s7O6e+69oOZcXeqr021uyJkBvtWZDshtuivi4lpJ"
"CcoifGVZnFtVBueWl6YjKMnUgM6AIDi10BYC+XBseh6CIA9BkAuHx2bHrm5u2N4lA7Z2TMd8"
"PQ1XbBdsaUM30CwFNtRPSmufWNl8z2oJflv9ZRhICoBrzOqvUoD6znoAyLr6t02uCoCyEWin"
"bATqnxZ7hqRXU4D7R7vh0DjTAZC7LcspQDOsANA7AEX40gaU04BULNUpwKmlRQwAimsAqOp/"
"OSN+sxdgc2VzOjABsKuOPhUooL7uAsg04G4rAJrjvuzwkzrM/ta6C3AktgtgdQBPpRNwrAud"
"gRQJW2sAhDSIuTfgzR361mByLPgN/2L8/YUY+bQD8M0efcPfA5c2Z/xxc70LVnVPdFt0ZGdn"
"yWtv75BC9CU6s2rufwYAQiNzOEEci8Xe2gosEehV/zg+T8K3R5O/49VcREfOjVbiVzfoMKu/"
"zOir9t86c7MPM/sv1X8FgJ261y+3/ZLcP2KOGfKxAmCtDQB8tehjwjd2jkABgDB5z9X/Q/Af"
"AODq//Wktv90AL++nMWPz+cp9ov4+fUSfn6hG4i6TCgIDO4yHsXGr7t49/Qo7pzZgjDv6dg0"
"qhOm1SqG4fndMbpUTjy57IMfb4LoAHwUBGIAIHUAAuDttVl4e0UAQAcQPkbVAZ4eG0yhD+EF"
"xQgbwotsEB4eHYRHYcP0ba6PDeMFxjjCr4UO5krTjxdaL16YXbnatMOD4Fbqwr29oy5u+dei"
"I6iB675yd96quLKhMi4xNbi4Ru7bJ0DQxcLzcnNPgkDcwOn5RXBibkEcm5Efx6blQ1D/LNjV"
"MxMCerprEHR1xdZOBEH7NBRxKrqA5PCiC1hTw5mCl1pAQr36ixOomlC1AOXzAoD1MgFotgH7"
"tuTK31bb/62ddf6vWoD9dQdg73CmAKPdcVCdBJSFaUAWHJ6aDUfkNuwz9f5/DYACSvgi+tNL"
"CqvV/6R5PL3CCoBSuKAKf7L6l1WrvxUA1/2rmv6/PhDkNld/iTsCApUKNMVdmewLaWFaga1M"
"G7D9fxQBrQCIORTUWgMIjL05qOwGvOYXeyrwNd98ugi4mQDYkhnh3q7fb6xOjemtEh4XHUkL"
"0M5etQDjiM6srvt/BgAS7du3l085WuzsEzs5qlZg0TVzqmzXAJhGAMwnAOZHK+HL8dzK+i+z"
"qf6bs/4VAIyARfxi82XLr7T+VPV/jo0DWGEDAJ/fRR/z3E+3EGUPgRI/V/8Pe03+f4gACDUA"
"0OJXlf9orvi4z3jMeKriR9RNvHt+Eo8uBuLCrpXYu2g01vVshBnlC2BEznTolsQR7fgn7WRv"
"QXcnCwYktEOPxA64e5KO5tMRfHwsXQFffHy4Bh/ur8D7u0sIgAV4e50AuDyFacB4vCIA3l4Y"
"gy+3puLTjan4eGMKPl6bgk83p+HTrZl4f3ka3l+ZgdcXp+Hlhel4cWEqnp2ewAtvNB6HjcDD"
"w4Nwe09X3Axsr+6xd21rI9pJuf9eTV7sck++anQClXHesyJdQHmmBOXUrbtOLS1B61yCOXQJ"
"HJ/3D47PLYqT86RgWBQHx+SmILNi94CstOZZENgnswLBdoLAv2N6+DIl8Gn2BwS42suKv0Zg"
"oPr/xgHUMgBokFgfBCLil4NAbEaAA3qlUecABA+Wk4AyYj9X//1jPegCsuLQpKxMA5iaTM+F"
"o7PoUOblIwD0ScBi+5Xol4j4i+DU4iKEAWN50RgHEL5OjwBfNLsBVftvcxVzLJhJAQLMsWAB"
"BgABYt/pAPbaOoCWeCTTgLYAkJOBTnTX8xuyLyC0vaoBPAhprPZw3Amo+fuZgJvNeQBWAKga"
"QPbo676Zcc7L9fu1lakxvF687aIj1QK0Vy1AR9HZ/4wD6NChg2Xq1KmWiRMnqnMBaP+tNwuV"
"lkWBAV0KLMHnyfj2eMZ3vF6C6OeLo/VmnxU6XlhX/7Wx1l969W/M1t+XfP5ghD7p57E1BZCR"
"XzP0owBgHRv2Ng7A93c38Nq6iYjW/72Ifw9jHwFwkMJk/v85zADgtM79o8Lx8nYQru1di1Ob"
"5mHPjAFY16Y65pcriOmFM2O4S0L0459usKMFw+JYMDqhBROSWzA1gz1mZIqD6ZniYmpGB8zM"
"Gh9Dk1pw68Bq1T34+Fi6AtsIgPX48GA1AbAc724t0A7g6nS8vjCe4p6Ie/uGYGqToljUoTw2"
"Dq+DHdOa4ODyLgj16o3T/kMZw3EteDJuhUxjTEHEqTl4emoGnhybRAjI+QLT6CQmMG0YxpSh"
"PyIOd+Vq1RGP9jF3DW6OB8xp73N1u89c996OWri3vSbubquKO35VcGtTRdySgzJkpeSKeWhS"
"QQQMzIHAwTkQNDgn9g7Nydw8OwL7ZVWOYFtnN2xplx6bWqWBT/NU8G6UHGslFSAE1pqqv0BA"
"dgGui9kBSPvfKLHeASjz/5L7d0pJoKQmAFywq3daOg7m/0NcmQK4Y58cUTY2Kx1Adtp/Ofwj"
"N0JnMjWZnQ9hc+lQ5hckuCh6Cv7k4qIEgAnm/6eXEWLLrJuBjAtYp2cAVArgq/v/cm8AXQOo"
"o88FpPBvxwCggQZAzOrfWk8CHvxjFFjOAzRnAqoioJwLcKC5md6UA0GqqwNB5EiwGAD4FFU3"
"BrEeCHLFJ1v0VZ9MOOOZ4fuVpanQuJjjEtGRaQEmYmrtKDoTvYnuRH9/FQDt2rWzzJw50zJ8"
"+HDL7NmzpRBo2wrMW76E6xh8mkgAzPyBN8sR/WJltNqUYw2r+F9Zxb9Zn/WnbPs2veqrI7/k"
"wI9x/NjcNlwNAFmn/qxpgJdp/Vk7AGb1F5CoHYRi/3cb+39Ar/6fQjUAJP+PouX/SAjgFqaU"
"KKBW82FxnDCYj8Pt7DCaj+O5us9J5YDlOeJjqYcTlmeLg6VZ42BhJnvMc7VgVnoLpqezw5TU"
"fO4eB8PjW3BhK2H1M5z5/w58exHAx034+Ggd3t9fiXe3F+HNNekEzMSrS5Px4epU3A4ZgvrJ"
"E6E4f18p/t7yfKzF31vTwYK6iRwY9miRKgFauzijRRpndMqeGp1yuKB91lRomz0VehbzQM/i"
"Huhe3B1di7qhZ4lM6FXCHb2KuzIy8OvpGGnR4580/Hpq9CiZFt1Lp8fgihkxq1F2rB9YALtn"
"lsah2aVxYmYxnJpTDMemFsL+Mfmwe2huBDGCh+aiSLNRsJmxtQsh0F5DYCOdwPoGsi8gCQWf"
"mOGsioPyKJ0C2f8v1X9l/1UBkLl/u5QEQCoCwIWvl1adO7hbZg6GZmQKkIkAyKLEf3hyLlr/"
"PBR/Poo/P8JmM0WZWwgnFjBdYdpycvE/FD7f79JiOLmUzyn803I2opyMtKI4IVCCECiptwR7"
"ldEpAIGnTgXeaj0TsJY+EUjmAHbV/08AmCLgo5giYEebGkBP5QLUkeCH25lDQZuqyU21F2B7"
"ddzcJm5Dnwl41VcfCaYAsDGv9VDQ6CsbMuHksvQ/Li1IhQLuTmNER9YWoEfmzA6iM9Gb6E70"
"91cBIHZE3siIESMsM2bMsGTKlEm1AuPHi+PKxzxF87v0xouRP388nR2t7sf3yvT5ZVtuzC2+"
"zYk/MTv+/LRgZab/Xl86gGHmrL9xZgRYdv3N112ASHN0mDo9yDMWBLYAUFOEO2zy/z0GALL6"
"HzWr/wlV0VfFPFzHleDVuLJ9CSJObqPF3oWnZ3bhyYmtOOM9ByvK58YMruyLM9pjIQW/iMJf"
"5CYf89HdDgvc7RUI5mWJizGJLDjhNRX4dQWfngQi6qXUAvzw6ZE304DVBMASvL0xjxCYrVzA"
"G1r61xcm48GRsbiwcwSC53bBgpZl0CVDQrTn7+zuYo/OKS3okNwObflxyyQWNE1gQaN4FjQg"
"bOrwsbq9jmqMKoSGgESimIl/GIVMFGCU5PeVp5Mp5qA/Liyfi+uAaknjoXn2JBhRJSO8eubF"
"/onFcW5BaYROLow9hMDuIbmYp+eiYLPQCbjDr0MGBYENTVJylU9GsSel6JMo0W+oJ/MCSVTL"
"UMZ/NzVNCt9myeDbMjn82nD175Qa27umwQ4CYFfv9EwB3PjamRAyIgsOjMuOQ0r8eSn+Agid"
"XYgrfxGdqiyk2BcXp+BLUPAlKPiSXPX5uKw4Py7Oj4srCMjjuZV0ADIeTQhcUIeCyBCQtQag"
"twFfl2PBzCSgmgWwFgODmpgiYEsNgENtVRtQHQqiTgTqru8HINOAciT4wbYxR4Ldlc1Acuch"
"uqwb/pJylONqX0qdCnxVAOCtjwW/7JWT6VkWhjvTl3TRJ2ek+JkjvWNvi24Bip7iZ8rkbi86"
"E72J7kza/fcdgPUN8Q2qE4LjxnFKK2/cI2Pilh9uDniNl8z/X3pGqwM5rDvyVK6/MXblf2s9"
"7GOXbuvJab8PhhgAjNRdgMfmmC+168+64We5ET+dwHPbdMCcH/jaAEBmCX4DgDX/P276/xT/"
"N2ntXaBg75vc/znjpYkXQPQbfPv6CJ41imB2CguWZ3XCMgp/eWY7LMtkwTJ3C5YQAvMIgMVZ"
"4mBSYgsOLR6rioefngbj26u9+ByxTbuAB2vx7s4KvLu5CG+vzyUAZtK+T8UrAuD1pWn4yPTg"
"8wNPfHmyCZeDZ6F/vgxoQ6D0TG2H7inMYyo79CAUJLqmtkeXVHxM44gujE4ujuiQNi7mtSqL"
"gBmtcWRVV5xY1xUh85ti07BymN+qKAZUcEfT9AlQJS5dRiI7NOfPNU1pj7oES1WmNqUdNDSK"
"OtihVpqEGFE1I7YOo7WeVwqhU4sgcFheBA3JjcC+WbGta0b4tklPF+CiIODdMDkjGUWfVEfj"
"pPCh8PXuv+R0AMlVK9G/HcXfyYUOIC0BkJ6vRfEPckfI0CzYNyobDozPSQDkIwAKIXRWEYTN"
"L0bhl2DeX4rCL4NTy8uqOC31jJUS8rw0zqwoxecl+VhCOYBzDBmKCl8taYBsCY5tA15Tx4LV"
"iD0RSKYr6QBuKwhIN6CJulOQFQAPjf1/Yo4FkyPBdBGwq9rBqTYDyW7A4EZqO/BtOXNQ7kDk"
"V5F5flkKviThU8wcCppf3Rvwotwc1NMD55a7RZ9ZmA57xyR9nS6pnczYSwtQ9BQvk7u7na3e"
"/qccgDwWKFBAzQLYOzikFOtib2epenF/x3v4tBjfn3v+lMM4o197R2urbw3rqK8p1EnBTp31"
"b273rW75PcoAwOz+izCFwBgXYHb9WdOBmJkAaw3AvPY7awtwnx4AUgAI+x0A3y/g55dw/Px8"
"Eb++XcHPb9f48RVER93Et7fS6nuLawf8MJZiXEGRL+fq70kArCIAJFby+RK6AkkPxCmETO+v"
"Coqfnu5H1Ot9BMAOuoDN+PjQCx/uMA24RRdwfT7eGQC8vjgFL8OnIPLsRLw4NxXPzszCzxd+"
"uLx3Dpolc0BXET1dQDdCQEDQLbmOzoyOdAbtCJ0uqZ3QiCu7z6g2iIrcjufnZ+LF2XG8OPsx"
"d+2KRyHMY/c0ZTTHqbVNsGFoRXTN64KKdhbUT2yHhkns0JiPzVLYo3FyAiGpHSrG0zAom8AR"
"3f9Ji60j/sGZhWV5oRZA4GA6gT5Z6ALc6ALSwqe5Lgz6NEvJSMEVPxk/l5ziF+GnwJbWjFYp"
"sbl1KgLAhSmAFn9AHzeu/u4IHuxB+58NIaNy4MAE2v5phWj3i9Hql6TFL0tRV8BZz8o4v7oq"
"wtdWY25fjaKuxudVcZ6fPytFTsLgLGFwliA4K3MPy8UBlFTHpysAeJnzAGRoSlyAzYlA6iYh"
"O5gGSCqws74GwH9zAFYAqFOBu6jPx24HltkMvpY4jM38PXJ/wo2lKfgSFP4/MceCX1yTm+LP"
"Hn1hpQdOLnT9eXFxOqzrleQeNVRVdOSg9RS3QIH8vwHgrzuAPwHQuXNn+bRsC07m5GSfm89L"
"7tnY5DS+LcK3Z6t/yEEc0a+3RKuRXFnxVWw3YVb/CLnTj/VWX6N0+08O+pTDP2ImAWf+fu9A"
"NQ68wqYesOEPB2B+zztTCJQR4Jg0wBYA4doBRF9l3OI/+w50N0BHtDxGP8TbF5cxgyvyIhcL"
"1mRxwBoKfw2F75lJw2ClQCF7HMxLZsHu0Z0h3YTPkQcR9eYAPj/dhU8RWwiADQYAS5kGLMS7"
"a7Pw5tJ0AkAgwHTgMuOKHCC6GM/OLcDXiK0YUTEfmjpZ0D+9E3pQ8L3oAnqmIggYXQgFSQ86"
"EQriBtpRuNf3Lsary0twK6gvbgd2xtWtjVVH4NLGykYEZWhNa+CJbHMN6YZl3YuiIp1AbUYT"
"wqsJIdfE2YKGhErDZAQDgVCTz0sSFBUSOmJi3awIm1cW+8cVQMCAHCod2NLeFb6t06l0YFMr"
"F2xqnoqRksJPpQS/heHXJjW2tHVRbUR/in9ntwz82YwI7JdJiT+E4t8/KidfNy8OTCyAg9OL"
"4Mis4jg6rzSOLSqPk0sq0uJX4QpfDWdX1aDga+DcmlqMGlzZaxgQVKTgyzMIgeWlCICSfF5a"
"A0DtByiri4HeZjOQ7KWgUK8rCMQCIDYF0DUAuVGomgSUnYDiAMyhoDEAkANB9ulR7bvM/2Xb"
"9k0/mc7k79nI37ehFO1+caYg/+CSV2Fa/ny4uDoXwldmi76wPDNB5/rj0qJ0mN3W+bTox9He"
"ktvO3iGZ6Er09T8LAMlNjCWJo3cF2ufg83+8F9UKwteFBMDa77INN/rN1mg1jSdiVxFgxB+o"
"z/J70Esf8f14uDnhd7w5/WdiLABUO9B6AIhNR+C5zVmCr6yzBFtt5gBMGvDxjzagFAFV3CCu"
"wwAAIABJREFUF0CnANFRl+gErqrbgeMnQfDjtn78dQ+/ou4QBJFYVDY/5lAkXtmcsIbWf62H"
"HVYLCOSRacE6AmAxRbq1ZXn++Z7h6/NQAuAIPj8LIAD8DABW4d1tAuC66QZcnqEg8OrCVLy8"
"IK0+fnx1IV5cWkQHtQ0Tm5RHQwcNgF4Ueh8CoBfF303En0KHAKALo2Oa+Li8ZyF/fjHuHxhA"
"S9qZF3Qj3NxSQ218uSI5sOwXWFOWYqiAS96ypbg6to0vi7qpE6EWU4AmFH0zpgMSTSj8BoRB"
"Y3lOENSlQyjBS6h1jmTYO64kDk4qhF39c2JnDw8KW3cHNrdLRxikUa1C3zYuSvRb2qbh19PC"
"v2M6bOuSgeJ3RUDPjAjqnxl7h2ZF8NBs2D0kO4KG5UTwyDw4wtX/9CLZ3lyJ77cm33sD5utN"
"uUq3oEVvTbC1w53d7SnU1ri5rSnOe9VGuFcN/rsMBDwr0PqXY5RGOAEgE5EX1hJ+Ji6t17WA"
"q7KbUjoC1kNBZKdlzEhw7CSgvj1Ye30mYGgnm/MAzKnAh9upMwFlG/HdwHrq4BY5tu2atB29"
"ZQ6hFC6tK074FOXvL0jx58OFVTkRvoIAWJYZYbMzfL+4IC3GNE4UJPohAHKYFmAc0df/VA3g"
"Twdg2hIyC5DIyckuK58XHD+wuCe+zse3yHXfZf999Nsd0UqIInjZ368gEKRvCf5A7iEo5/wP"
"puBHmpV/XOyhn1IDkENA1OGfNod+qmO/lpkagHEAL22nCc1R4jIK/F62AO8xg0AHbeYABADn"
"tANQo78EwE8C4JeIn6L/yUc8wI/PMiPwHitrlsJMisQ7R1ysoeC9KPx1mSl8Pq7lx+sJgGUU"
"pm+tIoj+9QTfXh5Tdwr+8mw3AeCPj48IgLueBgAyEDSbAJil2nivmAK8knrARTk2bDGehy/E"
"98htmNqiIurT2vc1AOhLAPQhACQl6GIg0ElSAn6+NeEUHjCbAFiC23t6USTtuLrVVZOBl7jy"
"XVhTCuGeFBZz4isUwYl5xbFvYmFeqNWxa2olVE7syHSAYjcAaM7Xa8ZoyueNBQT8WrOU9ihH"
"INVPnRjB40rh4ARCgE5gV88sFHdGru6uqjjo1yEd/Ch4fz76d0qPrYxtXVyxo3tG7O6dCUH9"
"PBA4MCsCBmVH8PCcODwhL8KmFsDR6YURNKYI/IYVxZpuhTClXg6MquaBwaXSo38BFwwslBZD"
"iqbFhJrZsKRdEQRNp43f2gKXfeohfF11ip1pwqoKTAfKKwiEryrDf3Nppg6ltBNYI+cDlNUQ"
"8K6IK76EgMwF+OkbhchotdQC7gY2jhkEkjbgI3UYSPuYvQBPjnXR03/WsxvUHg19GpA4LDm4"
"VQBwRe5PuJ4AWFuMDqwobX8BCj8PIyfOLc0afW5xJhydSQDMT4v25eJ6in4IgKwEQCLRlejr"
"f84BTJ8+3TJmzBjLhAkTLGPHjrW4uKRWrcD/w91Zh2d9bds6hhVogQrFg7u7Bnd3LQ5FilOg"
"eHCHKAQLFhyKuxMkJMSI4V6kuCeQccdca32StOecff+5p7372ev5JSFE6DffNaanSZMij/gv"
"jWq5TsX7+VQABMCb3QTA7kR164vRq8j8YV0WfLsvDZ/+8t3hPKMNACbauQDuOgYgAFDPmSYg"
"OF+7Ao/NLkFrY9AGW1GQgsBWAwBLG/BB0wl4yq4QKFhlAyQOgIQrBgBX9e0vRwEgVgFgy8AO"
"GgCFU2INFcD6fI5Yn5eGz+dqV60MltFF2FC/GD6+u0Hjpyf07CyVwEECYAcBsB6vb64wLoAA"
"YAEBMJcKYKYGQJgEBGVsmCcehy2hAtiJZQPboBn/s/1CAAwWAGTWALCoAIkP9JRsQZYUaOvi"
"gHMbpuDV1WV0AQQA3RC7pQlvodr0OaupYFjI0so0iio4N78sjowvhsC5FXB0RnnEbmoE735l"
"Uc1R3/biBnSiO9Mpg4aBgECAICDo8J0zaqXk29m+wYnZ1XCEENg7UmIC+WngubGzvyt29M+l"
"zs6+UkWYk7d+TkLCFfuG5MXuIfmoHPLj6ISiODujJA5OKIG1AwthYqMc6FokAxplSImqdHtq"
"SDqUv1NzAkd+N3GFOvL7dubpyPfbODmiBT82vnZuhAV0oJvTQsUGLq+sowqeQpZKxSOPX1W1"
"Qk0FA2VPgIKAjAerhUjpolTuAFXANt7cCgISCKQx72+r14Ud6mQmAuk0oBQC3Tsjz566A/Bo"
"ZzUPUMqIr+1qmmRikwLAGn5PAcCqcgoAl5cVpfEXwiWPfInBi1xxerYGQMX8KaaK/aRO6Sx2"
"9FXmH35wFvsSOxN7E7v7RwBAWhPlB5MfSqiUP39+lQr8Kk3KnHwWq1DqxyH4c3piwmP/RNWF"
"p/zwvcb4j+h+ALVHcDCN/ReeEWbLzziz4muycQGmacMXFWCZBXjfpAX/sLQGL08GgI16f4AA"
"4MXWv+kGPGKagSxxgCAbAOItAIhTEEg0AIhXAHiJg3NGY85XNHACYC0NfgMNfwMBsI7PtXQF"
"/Au4YHkWgqBGAbx9EYuElyEEQCABcIgA2K4UwKsbfnhx1UtlAV5emWsDgBi/KIGwuQYAHvj0"
"x3b49m+BxjTKwVm1AhhOAAz5ge9LHMAAoDcNdaAAgMZwYbM7XsX6EAADeCN1QQxf2JGqDJiG"
"sFzPCri4uByO/FaYpyiNsDjOzCmP0/S3I9Y0Rt/SWVGLBteREGjPG79zRm34ltOJaqNNOj4J"
"ATcqk2E1ctLfrod940riwOii2DOsgIoL7B6YB7sG58HuQXJyYy8NX6oKdw7KiyNjCuHUlOJY"
"N7Agfq2VFU3puhTlS7MwT2n+rg3TpUDnH9OjU5a0aM5/75/4s/TL7IxBPzpjCM8vcrI4Y+AP"
"ThjE37sl/96slsUo3bsjZGVDujcNECIqYGkN1f+gZiT4VVEBQZUSXCkGKaPU3KypwajN9VUv"
"hQDgqrgCu1vhGg36upoS3FFJfEsvgAUAaiXYcT245SZhcX2X3P56ToMa2ioKYH11FQNQCmB1"
"OcK3JP8bFEGwZ0FcWpQXQQtdqXqyJ56fkzmxUDaXIQ5qF6CL2FEasSuxL7EzsTexu38EAIRE"
"8gPJkeqkXLly6VRgKp0KLJT3m58+3PztlUoBvtyTaDP+g7o78E4vngG29eEWBSCbfiwAkE0/"
"YvB3p9mM3wqBmVoFqAnAS23z/6yzACwAsG8H3m03D+AEAXDGNANdNAAI1wBIiNEKIAkA4hQA"
"Ti2diVmpHLCxUEqsIwACaPgB+QQEVAF0Bdbkd8LqHA5YVSEbnj+4jC9vIvDh6Rl8fHJYA+DO"
"Wry6vhQv4zx4+xMAUgcQOUsB4FmYKIBZeCouQJQHXYAlBMA2bJ3WB41FAWTVCmDEj44YSgBY"
"3ABJC/YRAPDPW/FWPL5yDF7GeuPqvp+pADop3z/SvyZCCYAQqf33qYTjk4vhwK8FcXhcYRwm"
"BE5MLYkTM8rSMGpj+8TqqEGQtMrgqKR/hwy229/ytkChfXoNifq8jTeMqoxL3jWxfyxv87HF"
"sY8uwV6CYO9QHlVSzOfwguqcnsrbvm8BddNXTO2sDL+8Mw285Hfw/Kk4drtXxSmvBgj0borT"
"3s3gN7gyWn2bEp35/fry+/a3Oz/L781/k0GEYrcMqRC4rC1it7ZBsGQK+LtYABAiAUH+7pIS"
"VGlBcYNWVdcQUFOC9XiwWLoBMmMhbhshQBWgKgNlQIhsCqLEt5YCixsgk4Gl9FcAYLn9pZZA"
"AaCBFQASBIxYJzMbK9D4y+CybwmEeBVGsEcBXFqSDxcXuCaem5sdx9y/f5XreyeZ9mFNAYpd"
"iX1ZbO0fowDsASBvly5dWqUCXVycv5dfIN1Xzk2unRt0F2/WIOHPHZ/xZh8SXx1IxCNK+jvd"
"aNQ/m0MFcCcZANSqb0scQIKA5va/a4Bw3+wCsPYH+JoZgKvtRoptsrkAKhC4MxkAjpl5AIG6"
"G/BTsAFApAaACv5dQ6IEAnHHqgAub1uOmSk1ANbzxt+U3xEbafxyAowSWCdZgVKZ8OT6eSS+"
"j8b7p6fx8ekR7QIoAPiqDIDI/5dXaPzhM3im41nodDwN1YHAF1cWEQCL8enRVuyY1Q9N+J9t"
"KA18iAHA8MwOSgWIGzCQAOhnANCahrtzdj+8ivFG3L5+fAF3QPTG+rx9pAdAG8HZOaVVaa8A"
"QEOgCI5QBZwiAM4sqEKDaILuxb5HTaMCxBXoYGf84g6IW9CJz27fOaFFaoKoRGbevE1xdFoF"
"HJ7Irz+mGPaNLKzOgVFF1FPcjSOTSmK4248om8oJpSjfK/N7dHb9Br9PkZ79BryR61EiU76v"
"qE1/uT5CVtXHA/rfXr0roiE/ty9VgMBugFE/A/lvMJCKZDA/3p7/XbZPaEDfvQuC/Ph1VvHr"
"+FbXZ5mGwGWqgFA/7QLJ4BQdC9DLQq4E1NUDQuT23tKQhtzMbkpQOxXhvysNQWosmDmne+gx"
"YIfaJwGAdWy71BxIEHBNFYSvrEAFogEQ7FmY8r9AYggBcG6e6+eQhTmwaWSmu6lTODRx0JOA"
"xY5SiV0lt7V/JACSpQJlWWiVo5s7h+LTCt5+uxLwZhcSH4xMxJ3OkM3B+gwwAPjFDgCWNKAl"
"DmBiAAoA7rbdf5ZdAEoB2JcG280IsE4E2mHnAuyzTQSyjgP7LwAgQUArALQCiDu8BdMoezcT"
"AAFUAFsIgM00/s35BQa8CakCAgq6wOdHBzw4x++ZeAvvH53Axz8JgPvbCAB/BYCX9gCIIADC"
"3PFnqDueXp6GPy/PoFuwEI8vL6QC2MwbfSxa8D/b8GwpMPQ7DYARBMAwUQEKAo7qZhxAKdya"
"CmDP/IF4Fe2DuL19bQBYWUPNBQjyqKBufQHAQQOBQ2NFBRTDqWllcHxGeUStrQ/vAWVRnt+z"
"TSYntElvM3xLYLAzTzd+Twk6dsvkiObpHLFneh1c8qmDgxPL0tBL4+C4Ejg0voR6Hp1cEjuH"
"F0eLHOnAFwfqpHVEA7oXzb9PjZML69FProfT8yvh9NyKdEUq4+yiagjyqoVznnUQGdAcRz1a"
"omFaJ3Th9+zJ08/UQ6h0KAEg7oAAwK9vVRoiAbCsLhVPHbomNVQcQKmAZTr+oWoDCIGwFdW0"
"AqALoEaFr5epSnXUYJUYqqa47U30nEA1Kag1bh1op6S+FPzcVduCflIDQBQAJP9PpSAugE4B"
"NtBBwAALAKoibHl5ft/SVGDFNQA8CyZe9shHIOdKiPTIgcW9MoY66BRgMfsU4D8eAOKX2KUC"
"vzGpwIoBPi0OIt4fHx96J+CPvki83S4Rd0X69+QhAO705xlkB4BRtmWfav6/AYAYvuWZfCS4"
"GgVuCQSuNjMB19spAMtIMDMQxDoTQOYBHrcDgCUGEGnSgDoLoE7ibSR8EBA8xcMrJ7Awiws2"
"5uXNzxt/kxi/5RAGG0QVFEkJHxrKjQPrFDzePTxmALDdBgDVESgAmK3k//NwGn7oFAUAUQHP"
"owiAkEWIf7QF5zfPUEHAkdlTYDgBMNoeAN9rAPQxMQABwPbpvagAfOkCCADaEwC8WVe5qRf9"
"Kffi2vhH0/hHFlBPicDL7XxiSimcmF4Wwd7VcHBuTVRPmwKNaPxtvtFZgfbG+DsZ4/+JhteN"
"H+tNP1wCdXM7lFDq4dDk8jjqXg5HJpfGYYJAZQlGl0LtTGlQmr9HQ7oWDdM7oj59+xYEwKG5"
"9NVX1MSZ+ZVxwaMazi2pjvOeNRDkWxOXljdA9JaWOO3bGs0zpUXbdA7oTuD0zaQBIC6QqB+J"
"DbSh+vHqVpEA6IyLy+rQBZBAYDIAiBuwrJJyAcLoAlhiAKIAFATW1VKj1aKpBqSdWlcHagCI"
"j3/7cAcVDLwjgb9TEg+wA4DEAPi516S3YKvNBZAgYLh/ZQOAMhoAXloBXPYkAOblSojwzIHJ"
"7b8+KHZjUoBqGajYlSXe9o8FgLxtlwpMTwDIstAys8dW9cfz4fgY1yQe9zsg8U63RCX/7/Tg"
"6UPXuh+fA20xgDv2ADAugFQC3pli5P90uyzAPJMKtK8FkInAa5MBYKudAjBZAAWAowYAp+0A"
"EGoAEGczfjlfbuHLp5uQMuFn90PhU/g7rKefv6mAEzblddAxgLw6HqAAUJgA4Av0yjYfDYA/"
"jhMARwmAHaoOQMcAlliDgAoAogAuEwDiBoQJABbhSdgSfLy/GUG/z0FryuzhfJGPpMGPpvGP"
"TOYC9LFTAKt+aYHXcUsVAK7vpQIIkHbgWriwpAIO8fY/NLoQDo60A8AYAmBCMRyjPD81sxxO"
"zymPEL/aaJcvA6rx60lVoLgBlptfbuGfeHrwd+zO9/sQAK1S8Wcpm1lF4Y/PrIxj0yviuHsF"
"HJxUljdcZXQv/i1KSkQ/o5My/Ob8elJ6XIe/V51vUuN398oqan+aEDgvAFjiRgDUopSvj6jN"
"LXDSpxUVQ2q0Tm8DgKqK/E7HBQbw30YCoJt+rYtb+7tSAdgBYJkZhGIpDPLT8t8eAMoNWGtR"
"AQKAejYAWOYD8Ia/TTfgztHOuEO/XwOguxUAt1QNQCtVBRhnN7I9cq3UIBA6fuWUC2BVAEsK"
"KAUQON81XgDQv34af7EbAqAAAaCWgYpd/WMVwIQJE1SL4uTJk+1TgWnTpHaRZaElmtXIOA23"
"quFjrACgIy/SjhoAt3uYDAABcHuAUQAjjAswxi4GMEkbvjruBgDJagEe22UB1FljmxOQHACv"
"9v43ALhkywIkB8Dnm3QFbvHjd/Hu7S34VsgHfxrglkIuSvJLKnBtXvOUwKAAgC/KYP95dgA4"
"RgDsVGnAV1IJKEFABYDZ2gUItwBgmur5fx6pAfD+bgDCDi3m7euMoZkd8Su/7690L0QBDDWZ"
"AAsAJA0ot+DaEa0JAD9c3duPL9xOiBIArKpFH78UDo+V9t5CODCiAA4MNwD4lS6A+OcTS+Kk"
"uAHTy+HK2roY4JZTNRGplKDJBojxdzNHINCdp9e3jujEP++SNT1OezbFOQ83nJxZBUcIgMB5"
"VbD65+IoJ5H99E6U8Q5oScNvwdOUb7f5zlk1JvUq9T0i19TFmXmiAggADynnrYugFQ1w/fe2"
"2L+wGaqlckL7DPp79jWFT5IG7W0AIC7AtgmN1KSkkOX1aeB1dS3AclE/ZlqyX1UaYhVl/FYA"
"rK1hA8A6AkDKhDfWT6YA2hAsbRUApOFHjF7k/73T9gBor0e07W6mFECM7B2QGQQCgJWyubmc"
"cgF0ELCIFQBn57rGiwtQtXDKaWI3qVM6i/2ktaQAxb7EzsTe/nEAkCkl48ePd5g3b55dKjCF"
"SgVWLvHVCFytgfjYJl9wrx0B0IkG3/VvADD4r0FAiwtw13L7m3SgVAOqkuD5ehXYY9+kAPhL"
"DMAA4NUuOxfAPgYgOwHOmRhA6H8NgM+3kfjxFhI+P4Rf9eJYzhfflsIpVCBQagCkGGhNPlMM"
"VEhXA55aNI7/hPcJgBNaATz8nQAIwOsbK3UvQOwiDYDw6XYAkEDgbDyLXIgn4Z54d3sDIo4s"
"QaeMKdVtPyqzVgAjjAIQAEhpcG87APgNaoZXAoB9/XF9T2fEbGlCWV8dRycVU3n3Q1JtRwWw"
"f3h+7Q4QAId+K0oVUAKnppUlAMojYmVdTGtWxAqADjTwrvyduhrDTwoBR3ShYbb+NjUOL2qG"
"YL+6ODlLA+ACffnx9fOoLsQWvP2lyEhcitYCAYkBfO2oVECnApnoBtTHucVVlQK46O2mSnuD"
"xAXY3BJ7FzWHW2onBSGJAYgCkDhAPwMAcQE6EQC7p7dW49JUebD0C9iVBof4VdNlwSuqaQVA"
"/19iAJb+AAGAigFsrKtjANuaqG1BogD0iLB2uH3IAEAUwEnJCGgX4K6UARsFcD0JAPh112gA"
"XPYtixDfUsYFKKKyACoION/1S/CCbCiaI8UIh2QpQLErsS+xs38kAGRSqTzFT7GkAvkLZJVf"
"pFjeVD3jgyu+SbzahEZO/18BoJstBnDbXgFYXIAxuilIBQEn6nZgewCo23+hbRGobAC2+P9P"
"7W//zXaVgKYcWFwAa1PQMQOA02YkeLBRAFEGANdscYAEEwd4d1UFAlfWqQifr7XUX+NqDN9U"
"A640APDki/PwNIJN9QOcUArg3cNdeHtvE17f8sera74GAHM0AMKm6hgAASCFQM+oAJ5GeuP1"
"zbW4GbgcvbN9o5p/Ron//4ODNQtgUQCWIGA7GsH8TnXw+toqXNs/EDf2d0PUpiYInEtJPrUk"
"jk4splSAigGMogoQBUCX4PA4AmBicZycrgEQ6d8Aq4dUVC3FUvknLcji81tu/Z/sjhh/V6oA"
"kfUHF7VA2NqmODW7Ko7SDbhIAAyvnhOVqQBaEQCt0+pqwjZi/HQFOv2YAtVkBkP9/DSaJjiz"
"qAqlem2c865JP543OH+OB4e6YN+SNqj9lRO68GfokVE3QVkAIL/7YAKgG92Q08v64t6Jwao0"
"OGJtY+UGXF5Rk8YvNRDVFQCkKlBKoWVeoiiAcIsCoP8fvbEejZ/yf3NDxG1vagCg+wJu0fjv"
"HOqoACDFP5IB0GlAUwh0sINSAAIAaQSyB0DoyopJAeCpFIDUASReXOBKdZblTZ7MzuJHSxuw"
"2I9KAYpd2dvZPxYAUqtsUoGpXVycf5BfJENax2a39pW+j9uN8flG28+42xmJd34yNQB9dBXg"
"HQOAO8N4RuoxYKoT0MQBrArAZAPUaHDLElBPAwDLkNC1yfYK7LST/5YioIO2rkCVBkyeBbDr"
"BbBAQDIBBED8W8kEvMGWns2xJJ1I/VTqxhfDX0UArJTGoJy6H8CDL9CdPRrw8x9oBfDMNATd"
"34LXt9cRAMsIgCV4GTUfLyJmmSCgZAEEALM1ACJkq/Ba3LqwAn1zZsTPGTQAhtPwh9kBYDAV"
"QL9MOg3YiUbg2aMx3t5aj+sHh/JF21N1z52eWUH598cmFceRcUWUG6DlvwbAIQHApBIEQDkC"
"oAIB0BDbJtZQxtmZAOjytfje2u/vmckGgW6ZdDqw+w/OanjJ3tktcCWgJU4TAMdnVEHQ4uqY"
"2aKACv515Od0opro9r2zKiJq+60zajvpkuKz3o15E9fB2SU1cNbDTZXzxmxqzI83gEefSuiQ"
"71vlMnSh/98jkw0AP5sg4JAsLuhK9XPKR0pzf0HomhaI3NCMt3xdfi0pCa6hABC6Ukt/682/"
"Rvv/OhVYWwNAFq9ubazSgGpACH1/qQaUVl9p+LlztIvKAggApBZAVwJ20a3AUgq8uzmuyrAR"
"aTmWQaT+VZMCwLs4LnnqOoAL8/N8vrzYFdtG/3A/bUqHZg46BSj2k1rsSezqXwGApKlA54wp"
"XBxkQnC1Y35FIvGgMT5ea5uA+10EAIkKALd7azfgVn/dCCS1ALeH/xUAlm5Ai/x/aBkOajcY"
"xJL+s+4HsB8Jtss2FMTi/0tD0LsTdoVAQXaFQP81ABLe6nLgA5MGYoEpB15lB4DlpiNwpQCA"
"L86AJuX59+7qhqBnJ1Q/wDuVCZA4wHK8jPPGy+iFqhLwhSoEEghMUwD4M2IBnl3xwvPYlfgz"
"bhOGlciJPvyev2ZzxojvJRVoSwNKc5BKhREAcgsu7FQbb25vxI2jo/jC7Y2LHjWpACrRLy+r"
"VcAEowLGFFQgEJdAKwACYEZ5fl5lRKxuiO1T3VDThUYnRptBG34Pu6NAIG4BAdDzeyc0p5Q/"
"ML8VFUcbnJpbHafnVqMSqIITc2uga8Fv1ZSjZimoFPg1JadfL7UjBpXPhjPerRG5Ud/+YZTs"
"0Rsa4TD/zqRWBVH/+7QoxL/n5qJTkOJ29DIA6G+yAPK7D/3RCT347xO4cgDuEwDh61oiYn1T"
"A4DaygW4vCIZAKQGwL+mdVNQVIC0Bzc0hUAEwE4asikEukH/XgFAzQXsagXAfQMAWeOmegEO"
"tKW70FI1A6lSYAIgYrVUHxoALC1N/784gjwKJwoAzs7NkxDllRsefb+LFHtxcVLLQJOkAP81"
"ALCmAh2dviEACvPtStvm5TuG+42SAkDFAAiBW4TALboBt37m+4MNAEabSUATk5YCq3kAxu9X"
"Q0GSzQZUBUB/Nw/AMhLsgM34VTOQZSNQkOkFEP/fvhvwWjIA3KICiFEuwEnvaZiXRpcDS0eg"
"v+kIlJkASwmEFQVSwJNGurZBCXx6d43y/xzPSbx/tF8NBnlzJwCvJA4Q54tXUg8QtQDPI+eo"
"mQB/hs1QhUB/hs+jCvDEs5gVeEYADC2eE734Ah9DAPz6gy0QOMwAQIphpE6gBwHgXqcEAbAN"
"t07+hugdXXFhsRvOL6AxzqlAAy+D45NL4Oj4IjR6Gv9Yc/v/Vlzl6k+JUuDtHb6iAfbOq496"
"6V1UP0B3Y3i97Ixf3u6dyfbxjt+mxHHfTjQ8KoD5ktarofoEzi10wwXfBlg1qBKmNS/KUwJe"
"XStg35xGiN7WGZfXNVY5++iAhtg7vSpG1suNuhlTo6iDIypSIUxvUw5LelRHU7o3vagexOe3"
"zEUYSAAM/s4RQ+SZ/Stc3jGWEn0gwgPa8FZvpoqJ5GtfFhUg05AJgTA7CFgBEGDpBdClwHE7"
"mqqZAJbb31oJKLe/qQOwB4Be4Wa6AQUAKhVYX6UBkwDAV9cBCABC6AKcnZ074YpnbkzvkumY"
"g14GWtjR0ZYC/FcBwJYKdE5PAEgqsOyS0TkCcK8hAdAmXgHgdjcNgFsCgD4GAHQDblEF3B5m"
"ADDOtARPNW3Ac3TgzzIQ5JH9QJCVJvW3IWkFoJoJaFaLv5KBoHbGn2QewCVt/KobMMIEAQUA"
"ceZIW/BVOwC8QNAGb8ygoa0rmFQBCACW8X2//C7wpnGurFEAb55FIf75RXx4SgXw6ADePpBM"
"wEYTB1iOV0oFLCEE5quJQKobMGwOITAPz6O98SRyKT4+2offqhdDLxlGmjMFxtDox2ZxVMFA"
"iQVIduAXGsPoHCnQn2Ca06AUQbMLt06MR2RAe1zyqacgcHZ+ZRq4VgHHJBYwXqKeoFCGAAAg"
"AElEQVT/RVQR0NGJ/NjUMjg9R4pxqiNydWP8PrMu6vCW7mIkf89MtmOBgOpC/E43I/XKlg5n"
"l3XC5VVNNAAWuOHUvOo4ya8X6CHruJohdntH+sk/8XbtyFu/JULXNaJiaKpqAUbWdoVbWhcz"
"F5Fwq5yLiqIj/qRbtGF8c9Thx3tldkGfDNrwpQZiKM8QnuESDM2aCsFbRuH20UEEQGsadjNV"
"XSjZgNAVbsr/V01BkglYaYqA6ALoCUF1Eb1FtwRflcj/782tzUBi/DId2AoA2QGYBAA/mUWu"
"Zh7APpMKFAAE1LLFAJaW0wpAALCkUGKIVgDxV6gAhjVNHyD28ncpwH8cAGQssTQoSIpCxhRL"
"mkKCFYMHD3ZwdnbWy0JTOKpUYNdGGefibn18jGuVFAC3LQAQF2Agzy8GAKPsBoJQATyYpW9+"
"ifo/WGjkv69ZD+ZnxoJZIv8Byfz/PXq7kIwDf20Cf8lnAloBEG4HgBib8UtjkAQFcRPxb7QC"
"iNy9FpMdta+vfH6LAuARBeCbxxk+2fikvH12LxifX4Xg/ePjpiHIAgApCV6F11eX4mWMJwGw"
"UKuAiDmEwFxCYD5exPjgcbgvEp4exPgaJdGbPu6kXCkwjgAYl9VRqQDJCoyUwCAN4jcCYDBV"
"wpw6xdQswqsHRiBiQ3uE+DVBkGctBC6qRgOnj+9ekiqgOI5NKqZAcIzS//iU0vT9y+LMvCo4"
"Pa8GotY3w7ZJbnDjy6U75b3MIkwu/3vJ/AHpQvyBLgK/7+AiPyB8Uxec86yHswtqKwicmu9G"
"JeCGwMW1CYE6uOBdH2f450HLZT5BSxxeWB9j6uWF21cpUJW3fSMCrPV3KbB8sBuuHxiCq7v6"
"0PgGwG9wTQ2AH5y1z0+DHyaGL5WRVEDDpEsyV3qEbR9Ng+2HCFEACgDSGFSPKsAEAlUhEG/k"
"5VVVFiBirWVNuAHANgMAtSWorZL+aizYoU5qN6NWAD/ZYgDSESilwSd+ss0DMApABQI31laV"
"gGGrdBpQAcCbAFhMACzJj7NzcseLC1C/ZOq5Yi+8OFUKUOxI7EnsSuxL7EzsTezuf30suOwn"
"l7SE9CdLl5IcmVgqP6yZECypwFwS0KhWKh0d0Vr4FNfiM+5KLYClDsA+BpAcAL/ZFMADy0Tg"
"BXYzAe0AYK3/32A3DGSbDQBJbv+TtonAaibghb8BgBQCRWvDtxxRBIk3EK9mAjzDzfO7MfUr"
"mQrkoqcAie9P4/eR2YAEgJerHg+2uFgmPLoq+wPD8e7xMXx4IgDYRQBswZtbUhC0mgBYRgB4"
"4QVVwPMr9Psj59H/5wlfQGXgiycEQPyT/ZjVujp6CgCoAH4jAMYTAGMJgDFyqAbELRifwwUj"
"vqZkrpwXT2I2IW7PQBpCR8rfZrjkXRfnPGrQwCvi5PTSqvlHQYDugBQAHZ/Kj9H/D5xfTQNg"
"Q3NsmVATtZMBwFIA1MMAQIaW9jd1+DObFUfcrp/07b+wFk7y6wgA5Fz0qoeLSxvioq/42G1x"
"zrcppjQviFrpU6gbv/nXTmroSJdsX+OQp0jqwYjaTHitaYm7R/pjaX839bP04ffqn9F260s8"
"ZDT9/6H82Mj8mRC1ezSu7e1hANBcA2B1PR0IXG7aglVHoAaARP6lFVjmASQBgCiAvdr3FwUg"
"AJAb3goA6QM40xMPAvuYgSA/KUBoALT4KwBWV0boMgJgWWkESwxgUSEEL86PwNm5P4ctdkUJ"
"11SjHPQyULGbNDIJWOxJ7MpiY2JvYndif/+rAOjXr5/DkiVL1A8jUUo5QijZXZ4nT25LKjCb"
"/ELF86XunXC52tvEay1o4FII1DUpAG7/bAcAEwRUhUCTjQswQ7sA1klA3nbyf4WtBVgNAglI"
"GgCU2/+V3P5HzSiwU8kAcNEEAC/bBoIIBP4CgDjVGPT5owQBH+Lx9UDMyZ0OS2nky2j8Prlk"
"KKgDPPn04FmU3QFL8rhgOl+ct89tV3//3cMjqiFIzQa8u5UA2KAAoNyAWF8au8QCFhkILCAA"
"FhEMSxUAPhEA87rUQ3ejAMbT2CcSAL9lcVBHYPAblcBkAmAkATCnekH8EbYKsb/3x5Ut3XDZ"
"vwWClzbg7VsTgQsr4/TscoRAKe0KTBHpr0uAT86qwD+vrgAQHdASy/tXUreuAKCrSQNacv8W"
"CFgqAaVScevEhriyqR1Ozqmh3IiTc6rhhMj/RTVxdrE0+DRB+LrW8OlXHo2/+0rVGDQhSDvT"
"r5dCo04/pMF5/59pTENp+C0QtaUNwja0pgH2wbTW5VD3vwDAqMwEAH+WIbkzIHwbVcOen2jQ"
"belytFAACDeZgNCVbioGoNKAK0wloLgAVgXQkC5AEwOAZPMAJAYg6b9jxgUgAO6f1ctBZESY"
"bSKQCQLKspHtBMAmDYBw/yqqElAUgAUAF+blS7wwNw/OzsrxNm9ml94OOgUodpM6T+7cjmJP"
"YlcWGxN7E7sT+/t/DoBUqVJZv+mPP/5IQ88jeX8HV1dXdeTtvHnzOqRJk0Z1BTo7OWaWXyhz"
"RqdWD4+W/wO3WuDLzQ5fcLcbVYAFAKYUWAqBrGnAMTYFoJaCWKr/7PcCLLXL/VvGgG20Gwu+"
"Q28XeiEtyAcJABr/mxPa+K0AOP83ALC4ABYAxNiB4Co+f7qqovovHkdgXtEs8ODt65PHCR4E"
"wRIa/pKc8nTEAsp/j/wpMYWyOO4AAYXreHP/kCoGEt/8rSiA2wIA6QtYoYZ3KBUQtViVAD+7"
"soQQkB2CfngS4YdPTw/wBmyJni4aABMyawBMpPFPyuqAKdkcMZk/y9ScLhhD45hZKTdun11I"
"QxhIAPyEsLVteOs1RpBvHZxbUk2pgNOzyiklcHJ6GZX7PzWrPE7NroTzi2rg7CLJh7fGjDYl"
"rQpAANDNFAJZioAk/y99+u3TEQa5M+LSmo4IWtYAp+by1p9N459VVQUCT8+ryRuwCY7Nb4je"
"JTKjKr9m49SO6PidpcDICS2oIHa4t8G9U8MQTGBd2dSW7ksrXF7XBreO/IwZbcujHv9e/x+d"
"VQuwVEGqbIj0RmRxwmD+fCOLfM9/79FUIYTe2hYI5fdUMQD/ujT2WgSAnBoKAOqsrGYXA6in"
"MgACADUQZGcztR1IAcDEAZQCIADUUBC1GKSvWQrax8wE7GIDgCiA7XooaFSAm5oIZAHAJc9i"
"CFpYEOfm5P0SvCAv9ozP8kfGtA6txF6ctN2kEjsSe0puY2J3Yn+W/1ns8v8ZABwdHR3+p//x"
"U1LykSmFi5OkAt0C/YvH4EELfLraLgH3CIBbPRJ1JaBpBro7NFkzkCUGMFmPBLMCYLHdbsBV"
"doU/G5FkMehzOwC8sgfAKe3/vwu0A0Cw3UgwiwsQZYw/xg4CcUiUgqD4m/jw/iYWViiA+TQI"
"77wu6sZfSMNfRAAs5nOhACBfSkxO74CQzR6ExjW8eXCYCuCoKQaiArgtFYFrtAq46mfiAATA"
"lYUaAFE+eBW3Ek8jVyD+z0NYP6orehEAUwiAiXLbi9HT+KfyTMuun1OzO+E3GsW4QpTCeyfT"
"hx6KyC09+AJvzxd7UwQtrYvzXjWUCpABIKdmacNXHXhzK+HUnCo4v1hu69qI29oOQ6q7ohZf"
"LpK3l0IgqQTsktF2ZFiI/Fkj/lyLupZDzNb2ODFH3IwaOD6rCk7NIwTmyDCO+lQH1VA/YxoV"
"U+hEg5fCIenv702fvj3Vw7ga+XD72K+88dshkrd3KA04kmpC3r9zdACmUwE04N8dSAXwSyad"
"/RhuBQChQAiNK5sFVw+NQtTWzri+uxNiNrckeOrrVOCq2oRATSsArArA380aBFQjwSwA+IsC"
"6GgAIFOB7FaDnetvjQNIfYACgKwZ26ldgNgtkt1wUwNBpBnIACDxEhXAmdl5E6545oPfoMwx"
"Yicuzmq5biZH1VT3P9mY4/8eAJydnR1cXFz+9sif8/+iS75JlVItC630+6KCp/CgGT7GtYvH"
"va52APjZlAETAPfsegGsA0EsCmCOLQPweKndCLC1tltf3fyWAKABgHIBLACwk//vaPzvL9rN"
"A7R3AZLHADQEElV14A18fi/VgI/g4VYKs9LrHQEWACzIqZ+yIGRx3pRqhPgZvxlaATw4YqoB"
"95iuwI0EgA4Evrq63KYArogK8CQEvPnxVXh6ZRXinx3G5gm90ZuGNpUAmEQATCUAlPHze03n"
"cefb7jmcMJFGMYE3YczBGbhxaASitvfmbdqZtyDdAD/tBki57dn5YvQVeENXVDMAzsyvwo9J"
"J14tfo6M2G6ODrkyon4KqfJzsjYB2Q8F6ZTRUVX1dc6eDueXt0GQTz26ETT6mVVwUgqBCIGL"
"XnWwfUI11EjtgkY09C689VUHoRT0SFtvZhdVvrxxTFMa1zCErmuL8IC2CKOrELOtM0I3SPPN"
"IMzuUBGNHHTFnwBAFUPxDP1WiqOcMYD/LcaUyoL75yYhbk8PFV/4fUoNSvCmuLyiDiV4baUC"
"1DBUc2QkmCgAyzAQSwxAUoAyEej67laEKH36g+3VSLDbIv+T7wYkAKwKgABQWQAZCmoAIC6A"
"FQArdDcgXYDE4MUKAPHRXvkw+6fvT4mdpHBxFHv5hqadQuzov7Ixsb//VQD8BwpAAJCeAJBl"
"oeV8xuXajHtNCYC28VYFIKXAloEgSgGM0C6AKgWeYOS/u54Y/ODvOv/8/7odWAFgmxkHboaO"
"qhjAcXP7n9W3/7sL2vg/XDITgf8OAHLjx5q3Y/TbEgh8w/fxAr5Nq2E6/Ve/gimxJLu++QUA"
"83M6Yg6NcREBMJnGcXjeaPX33jw4SgAcJwD2EQC/UwFsSgIAGeBhA4CXVgAKAKsR//wojniO"
"QV9nGrtrCiX33bM7wj2bBsCM7BoC0wiASTSKyYW/Q+yRuXzBjkH0jr64srkL3QDK6RWNcMG3"
"tnIDAhfR4KkEAhfKk0Cg769v/1oIX9kQu6fXRJWUTmhmBoRaxoHZzwXs+r2LKuhZOagaoje3"
"wbEZVSj7q+D4jMo0/qq6GGhhbbTIkl5NDeoqxp/elO9+pwOIAgApXz7qwVv0+HAaf3tc2dqR"
"yqUDwgLk2QXX9v+MvsUzq0DjYPr7MhRFYgC/fKfTgJINEJegL7/+wo4VqSZcUY4vc98+FWjI"
"rRBCAESsrasyAWGyLl2VANeke1BTzwQM0NOBZXKSLAq5KiPBduiRYHoeYEczGtxsBz6hJwLJ"
"UNCH5/ubvQA9VJuwNQhoBYBxAWQi0MoKVB9lEeJTIjHEozDOzs0XH+2dD6NaZtgsdmKW66Y3"
"9vPPVQD/AQB0KjClk6Q0SvZq8d0C3G2Mj7EEwP3uSLzTSwNAKQA7F8AKgPE2+W+/EEQBwM80"
"/vjb6v6tCiBZAdBfABBod/tf0re/AoClDiDSbiSYWQkuewK+xGkF8OW6GQ76ApuGdob7V1L0"
"k1JF/CXyv5gAWJBLA2ChAcCuCXRzcBNv1EwACwB2UgFsVi7A62sr8Sp2GY+3GgP2PGqJVgAK"
"AKsJAH8kPD+GI15j0d/JAbMJgGn0/acTAJbb3wIAgYLAYWyurxCxZwZfpJMQtaMPJXE3hEsc"
"YGUT5QZc8HKjCqiu+u4D5SyqTgC44YJHHZyh/39lbRPM61xcNfC0pFxvld42GVgZP5VNFxp/"
"U97cY2vlQ9S2Tjg1v6Yq/T0ytQIVQGUcnloRIb51MLNtYTVGvFMmZxVHUMZvGWGeQbr4XNCB"
"hn3EoyeNbCQurW6rbv2Qde0Qs7Mbb/N+GFOnAFrI9uXvnVTBzzDTCTnE1ACoIiCqAtmZ0DWt"
"kxqesrJfVUr2Pghb05i3fD3l/4sLEO6vjzT+RIjxr9UAkEKgqI06DhC3vbEVAKIALMtB1e0v"
"GQA1GLSnBoAlBiCLQY7YuwD8GtvqqyyAVgB2APAtkXjZuwgVV/74aN98aFouzQKxk5QuKnWe"
"1tjPvxoAKhWYKoWjLDcsVqNM+rG4VZ8AaJOgAdA7UXUCJhkIYlKA9kFABYA5Jv+/2G4A6Gpb"
"7b81/We2A1trAHbr8eMyfdgSAHx3zgCAxv/BGP/HMG38n8ztH6/HgifGx/K2j8SXT9HK+BOl"
"LgC38Ok1AYEnWNm5AdzTSNlvKrUlaGluR7UnUJTAXAOAKXzBr+/ZENIS/NYKgL0GAJt0DODa"
"Cvr6UgtgAHDFUymA51FL+Wdr8DRKAHAEwVvmo58dAGbQ2JMYP8+UrI4qQzDWNS0i9s6kTJ2C"
"qJ39CIDuCKdBha5uhkvL6lHiU+Z7uuE8zzk5iyVPX0ul6s57SfNME7TNnQlVZfR3RifrXoAO"
"xvg705hb8nfv4SqBv7a46Fsfxyn7j00rj2Pu5ekGVMTRGZUIlLromi8j6vLn7sHbubep35cy"
"XgFAH9PG24muwVz6+I8uTMS1fT1xc39PXNvTHSd922FY+ezK9++XOaUycCl4EtkvKkDeHpRJ"
"j0kfkc2Zbzuid3pHrB1cC3dPDkXkZqkGbEjDr03D0wAIk8o/1QJcS40Fj1xXW08FNm6ACgQq"
"FdDU6gLIenDLduC7akloNzUH4H5gH5MF6E0XoHvSseAKALbNQJHrq+mhoCttADi3MH9CFBVA"
"qTypxoqdUAGIvaQx9vOvBoBqC+YvlF1+sdIF0/yMyFofv1xtA8kC4G5v3Qp8x+IC0Pjvjfzr"
"PADlAlgKgUwA0LIMVPX9r9X7AK0pwI1GAVgyAAKAo8b/P6MB8J7S/30wARCqNwIpAEToI8Yf"
"H6Pz/l9uQ+8GvK3SeF8+ROHzO3EPbuLjh/uYVSov5vEFuDK/C5a5agBIDcASEwNYmCclptFg"
"ljcoQ5hcw/tHx/HhyVG8VwDYYQCwVgHgZaxkAXzUzS/VfzLT3x4An58dRcj2BUkAMDOHI2Za"
"pL85EhQUAPyaMzXC90ynNHXXANjWA+HrBQAtEOLXkL56HVwkBM5711bbds4tqYNg3waU/3V5"
"IzbFsp/LqRRd0wy8TcX4M+jTSiYBf+usOvq6ZvkGp7yoKvyb0vir0vAr4NDEMjgyuSyOTi1H"
"FVCRH3dDu8zp1PLSPt/pIR6yw8BSyy8Q6GeendI5YnbrMjg4rwU2/loLUxoVRtvv0qk05LLe"
"NbB9Sjv8xK8zKmcqVfgzOqszRmV1wfAsThgo8YSUuhBo78wWNP5fELmxNSLWNzG9ALUIABr/"
"KjeEryYA1rgp49cAsFMASQDQTAcBD5j1YLIbwGQBrKXAMhX4bG89JVgKgZLsBWisKgHtASBj"
"wUMJgNClJdVQ0IuLC+Digjwf82dN8bPYiYuzshdJozn9uwGg/i+pQAeVCsyR2bn9s9NVnuJG"
"a/r/Xb/gbk9YswACgHuU//dG/XUsuKUUWGIASQDgbwPAU8sEoA0mBiABQNk6tI8AMPL/DY3/"
"rfH9Lcb/wRj/x3ADgCvK1//yIVLd2E9vnkTgyjl4dvMU3r4ORyLu4fPnO3j3JhpbR/bABN6A"
"vrlcdC0A5f9SQsCHEPDg2wslGJjbBXMoxxdVyInn987h07NApQDeP9qHN/e2qxjAKwWAlQSA"
"H17E+FIBeGsARPvgWbRMDfLHnzFr8fGPA4g57scbz4kGr29+OQIAUQAqFsCnZAcm8iYcrLYT"
"j8LDCzPoAvRF9PZeiAjogFD/VioXH7y0PoK86xIC9dQJXtYQ57zq89kIZ5c0RMNMX6mZ/23M"
"VGCJAbQ2Y8Cb8ffulOVrnPFpq0p5xdcX4z88sSQOTyipnkcmlcGx6RUIgOro8GM6NTRURpf3"
"NQtMLH0EfcxAj/5qs5GjmmYk04+lWaiJ7CZI44SAEfVx++RYXD04BAMLZ0Z7/vmAb5xUyXMf"
"nu48g3J+heU9qxF2v+DeyYEIW9+C8r6JLgBaUVsZvzQDSQZA/H8l/60KwBID0L0Akgn4SxpQ"
"IHCgvZr7f+dIJ7uRYN2TlAIrAEjvgD0AtiRVAKGryiLMr6R0A34J8SyII+45n/7wtWN7sRMn"
"R2UvqbQJ/YsBYCAgf8GSCqx1fn2ZONxrhU9XOyUIABJvWdwAEwMQANyzAGCiMf5ptiCgpQrw"
"L91/a22ugOoBsJQAG/mv/H+7yL8A4H2oNvyPYvg0+E9RSOSRMeAJcsvjIW6e245B/Keaks4F"
"s7OnwYIiWeFRNi/mFvgOM+Rmz5sKqwumUMcvn7MqBvIiDDwkIEh5viCLFAOlUHGA0J1ehEsU"
"nt/YiQ+PD1AF/I73si5crQlbRUNfqsp+X0RbAODLI1ODVuFZ7Fp84t+JPrEcv/yQUkX+Lbe+"
"BQQCAMkKjKM/PDG7CwbR4C6sHolHF2fiyra+iNneExEbOiJ0bWsCoDlVQCOE0OgvLWuAoKUN"
"ELhEbskmuOjTBJ3zZVKz/mUkuET4JdXXMaOjuvkbuuh8/ynPFlQUTXFiVmUl+Q/9JoM/Zcx4"
"ERwaW0ztDBQIBC5wQ/c8GdBSKQAn9PpGG353SyFRRu0GSD9/P97isvdgcPYU6EHYDMmXAQfm"
"t8btY7/g8vq2dGM64aR3G0xrUAC/lc6MSRWyYknbMtg+oTFCt/TDg7MjVf4/dG0zujuNcVm2"
"A8kwELUeTDcByVh0Hfm3KYArG+rqIiCZBrzVVghk3Qsg/f1qHFhb5d/fFgioVWFdDQB62C0G"
"6WgFgCUIGLe1LmI2S7Wh9B1U4s9QLjGcADi/uHBC9NJCWDUka5zYhyUFaADwP9vXPx4AuhYg"
"g0kFVt7rWTQQ91viY1zHBNzrQQD0StTzAAbapQF/te0FsAJgtgaABAKVClhq6wBUKsCuFkD5"
"/6YB6MV+vYBE+f92t79V/odbjR/08xEfbeS/af6h9H/7JAg3j6zFhaXTsK1jdfiVc4VXgXTw"
"4a3lQ6Pw5YvYl0a3NIs0AjmpjIBfgZRYVjAVvPO4wDt/SsyjJPesmg/PH8gmogt492APXl7f"
"iOexa/AsZjleiPyPTQqAFwTAixg/vLrqjydRq6gWdiD2pB8G0AjFz59m0n/uSeS/I8ZICpAA"
"GPyVA054DqR/OgPROwmAnT35AuxMCLTT2YCVzXFxaSOc86hHd6ABoje0xJE59dCVfn8tR5nY"
"46ii/F0yOaELb/1WaR1p/I6YUD8PLhIgwcvq8YavhOPu5XBoXHEc/FXGfhfE3lEFsH90QdVu"
"fJBq4KJHdcxpW1DJ+L5ZXNQac3EFLACQUWL9f3BScYABVAhym3dKwd+lRk5cWt+TN29fBFO1"
"hK2jclndjDc1DfFAD8Ts6o3rBwfwFh5Co+uH2B2dVN1A6Jpm/P0a8bavrUaByaZgvRSkmlkN"
"ZsaAy3LQdfr2V6PALbsBVSegLAhtpgBwdWcLXJV14XYzAW8JBCQmcKyznggkMwEFBvyYbgRq"
"rdOAvzdR68Hjtpn14Jvc1HbgMP9yiRErSikAxPoVwoLemQPFPlLqFGAGYzf/XwBAUhlfm1Rg"
"+dVT8+38bwFg2QxkWQ2magDc7UqBLQAwOwCsE4DMPkDrRmB7/58AeH3SDgAhNP7LPGHm9rcY"
"Pw0/PtZ2vlyn334ViSoO8CekAUjOFzzCs/tBuEEohKxbiENjfsLmBiWwqloeeORKgYW8LRfz"
"xe3JF7cHX9AeNH5fVxcsoMF61ymKsN8X49md3Uh8fxKJr/fRt9+Ot7dWGwj4WgEgm31lGMiL"
"6OV4FrVazS7Yt2CIqgNwz0UVkEWn/KQC0N2cSdIb8L3uFhworcrDmuJJyCyEBXRDxObuuLym"
"A/31tghe1ZK3UAtcoVHF0E++4NsEHl2Lo1H6FGjgrAdudJfbWoZ3EALN+D2750mP9SMqIzqg"
"Fc4troGjU8qrib8HxxalwRfS+/2G58Pekfmw/9cCVASy4bcEAVFWpRXH1c6Jlvw6ndI4okt6"
"W2dhD6kuJKwkC9A5vRPGlM2Crb/Vw7V9krpsj6BljVVnoSiV4OWiWOi6+NY3G4Ebq+3AwSsa"
"4vJq2Q7cWC0GDTHGbx0HvkzvApCNSLoDsLoGgLr9deRf7wW01QBY2oFlMcjV3WY5iB0Abqmx"
"YB0JINkR0E3PBJTNQOIqiALYR2DsooLY2cgGgM1u/DevzJ+zfGLk6tK46FlEAWBCx293in2Y"
"FODX/0kK8N8CAEllpCMA8vFZaniXLN641xwfY9vH464FAP3MdiAzFPTeGBsArDGA6batwElS"
"gQYAf1omANsVAFldAFEAJ40LYAGA+P80/o9XtPF/ijEAMBBIMF2ACgJxKvCX8DYc8a9C8eVt"
"hJoPyB9AZQKkMejLlwd4/Wc0HoYf4m27FOeWTcO+X9pgY0OCoUZeeORLj/l8obuncsQw/tOP"
"zZYWs2sVQsDIVjg4rx9un12ENzf98TzKR6kACQC+EEVwbSX9/1W4G7Ic+xcPweAsaTH6W33T"
"SyHQpB+1zy9vy1OM/1cqk19/cMRQuihD83yDoPWDeUsN54u3P1+QPRAraTUpk13TDvtn1MOi"
"TsXRJWd6VWPfKYMz+v7ogl4y659G2S4Vb21Xqp0eZRG8uhUi1zRWk4KOTSmDI7zd948ujP0j"
"ZdsPDX9EXgLAlU9XugF56Q4UxOEJhfm5JXBqbiUabiNsHFUN46plQ99cX6PzD6nQ5fuU6M/v"
"PaLU91jcsSQOzmmCK9u70/A6q6ahC751ccmvLi741OL7tanCavPr0LhX1FOzA2XKkXquqse3"
"+bHldZTxB1tufjUJuIpu/TXbgUPNYlA5kWobUB01BEQVAW3WNQAKAnabga7u+asCuHWwHQEg"
"48E74u7xLknGgstIMFEA13c1tQIgZosGQNSGKohYXzExal1ZXPAqEh+7vBA6VU/nLfZBBSB2"
"ku4/SQH+WwCgloUSADoVWPab8TIa7GN02wSZDJx4s2eiageWZiD7qcD3xiUDwMxkswDMFCDr"
"RuC1RgGY/P9fFIAEAU+bGECwVgAfKf0/Rmnj/2S5+e1UgP08QMiRgSBSCxCDz4RH/KvLiH8Z"
"ivgXl5EgAcIP0SZr8NCcR0j4dBOvn17GH1f2I3a3Ny6tmY7DswdhefPymCUgxQ4AACAASURB"
"VFL4R4x2zaQCWt5daiL+yVY8u+KDZ5FeeH9nBbx6uKH3t2kwrkhmDPo+FXpSlkuN/xSR/jld"
"MC13Cri7plBFQaowKIcLxlP6i/wfm9UZv/L5M2/yATm/weyWJeDZrSI8upTF7DbFMKFmLgwq"
"+B3af5MCLfl1O9LQu4vcp5/eMYWk6/g16F+vGVwVl1a3o0F2VAHDY5T7x6aYW39UQRo8b/2h"
"ebB7qCt2DcmJ3cNyYM/InNg3KhcOjBUIFCAoiuCoNBrNKE9/vIGq7T/r1RSH5zfAkUWNEbi0"
"NSI2dqTf3UE17kivwtlFNXDOqybOe1ani1JNPS948/jU4KmOi741qAxqEgZuBIMb33bDpeW8"
"8ZfLswaf1XmqEQTV1ARg6fyz7AMMXVnFuibcuh48oK7pBKyvMwBSDry1oW0ikCgAmQoscwH3"
"tsKt/YTAQULgcHsavswG7KLHhEvL8P52eibgHtMNKC6AiQFEbarB71cFkRsqJkavL4uL3kUT"
"YqgAyuRNM97BlgL86j9JAf5bAJAkFVimcNoBiKoX/zmuDXCrK08P4GZvu6nAllZg+1Jgd9sk"
"IBUE9EjWDCTlwP62PQDPk7kAkgWwpgEDTf7/spb/H6P+RgHE2A0DuabVgBQFJUThy6dIfCE4"
"Ej9doTLQQUM5Xz5c0QpBloA+v4SPz3j+vIBPzy4i4WUQ4UDF8eUKPy8En98SQvFB+PTyOF7c"
"3o67QX64e84Lr2+uU40/f4Z74N0tPwSMaYXRBX/E9LI5MbHwD5hWOhsm5v0ak/KkxciMzhhC"
"Yx2a1gHDeFOP4PMXPgdIVJwf702D7sFnT77fmbJbimJkrZjk0qWUVpZotuXpIgE9Gv6A7Gkw"
"vGBGTKN/v3ZQNRxd1BSRGzuouX5BPnVVSe+pWZXUvIBDY4uoceJ7hsp2Xxo/DX/X0ByEQHae"
"rFQDPCNz0A1wJQDy4tB4KoGJogSKaxDMLI+zC6oQKCLR6/BZiy5CdZyaX0Wdswur4NySKji9"
"oCLOzK/A9ysicHFFgqAizntVxgVPc3yqEAT8OkurEgA8fvp5SQx/RVUE08jlhPDtkOWVNQAE"
"BAKBVRY3wE0vAjHpv+jNRgVsbqgAoHYEms1Aaj0YIXCDSuDmvtYq1WcFABXA7aOd1LRgrQBa"
"qZmA1yx1AFvsALBeAQBX1sposGIyEzC+YPaUAxz+L1OA/w4A6FRGamcnB2ldKuaaJWXHF4Fu"
"f+J6W97+Xb9YR4IJAKwxgFF2y0Gn2AFggZ4E/HCxbR6AtSHIP1kW4HeTBjRBQGsfwDkbAP7i"
"AsQmdQOsw0AsAIim0YvxR9CQw/V5z/MujC6CPonvRQlE6I+/DaUyIAieB+L9k+N4e/8A3tzb"
"jTd3t+PlzY14eUNWhK/H+3ub8OEe34+VXgBfNRNA5gB8uL0cHx8E4BU/99GV1bgdtBzXzyzF"
"tbMrELl7PsK3z0bwpmk46fMrjnuNoCvRE5t/bQX/AfWx+ud6WNmvDlb0ceOzJtYMrMWPu8H/"
"5xp8uybW8WwYXANbR9fG/pkNcWZpW4Rt6IyYHbJEtB1vyEY4s6A6TtDopaDn1KwKOE7jPTK+"
"KA7/KqPExfhzK+Pf/QsNf0g27BmShc8fCYAfcWB0VhwYkwMHf8uNQxMIgYkFCIJCBEgxnJxe"
"EsenlaKaKI1jqv24HE6prcTlcWaeNCWVw+nZZfixMvxYGf4cZagIeBaXQeCScgRBeZznueBV"
"ARd9KlIZVOJNWlG9fdG3IkFQmQCoghBZgc5zmUdu/ssCgRU8qyzrwSUbUN0MAjV1ABt1PEBB"
"QJZ6yHiwrXovgAQF1XwAQuDmXg2BW4fa0vA7KAjItiDZF3BzX1ve/i31VOAdjVQloKoD2CSg"
"qa4AcIUACPcv8yV8eTEcn53nzywZnTs66BSg2Elqh/8gBfivAID5ReQvfefk5Fic79QL31bh"
"Bu61R/y1rp9lMGjirb6JOgg4zG4xSDIX4C8TgZbYzQM0G4GfrLG1BVtnAdgDIJkL8CFcuwGS"
"+5dAoCUDQJ9fPT9bhoLGWhWABoA5ogRo7GL0n9+F8ma/jM9vQmj0QUh4dZGuwXnEPz9LFXCK"
"57haC/bhyT68f7QL7x9uw7u7G5Xf//LqCvr9SwkAH7yK9sTzSJkFMB+PQmbhj6CZeBI6H39G"
"LObnSGPQCry+5o93dwLw/sEWvLu3GR8e7sTz6GX448J0nql4cGYs7p0ciTvHh+HWkUG4eZC+"
"/75+uLq3N33ZXjy9eaP1QPTWDpS+bdQJX92Ut2ot3rjSv1+FR7oCK+E0Df/E9DJqTqAY/6Ex"
"BWnc+bBvRB7sGZaLBp+dSoDGP4zG/0tmKoAfePtn5udk4e2fnUafCwfH56YCyIvDE/LzfboE"
"Sg0UxYlpAoMShEsJnJxZgi6CflsfWVJajCAoTigUx9l5JagaSlAJlCIASlMJlFHngldZugc8"
"HvSnPcvhold5qoCKVAGVaPw09tU0/FUCAQJBjF8gsNIMAlGbgatpCKyxWw+u+gH0WPCYTXoy"
"sADAAgEx7BtyKPFvHiAEDkunogwLaadiAzfVSPAWehYAASALQq2lwBsEOJUTr6yvwJ+j9OdY"
"/xJUejlu0j7qiX2InTj8hzUA/xYA2KcCi/JZ+YBvySA8bIePcV0TcK+3AcAgWyWgNQg42SgA"
"u4Eg9nGAP7ySDgWxzgXYkGwc2CENAFUFaEkDhthlASKTAiAhNtk4sDjTDRitpf8n4wJ8FEmv"
"b3sNgGAC4BIBcIEAoPG/OINPz0+p7r8PT/bT8HfjHY1VdQHe3YQ3t9fjza21eH19JQ3bV7cC"
"R8swkPlqJNiLyDlqPJgMB30cShhcnoWHQTPw8OJMPDw/HQ/Oz8CDC7N4ZtKoByB6e09V7Rex"
"pSsipPNvfQeErm2Hy/5tELK6FY2iKX3mxmoaz3mPOghc6KYm/5yZV1Wdswuqqo08qiVYDN+9"
"DA21FI2/OP143vzjCuLQ6Pz0/XNj/2gJ9uXEXvr8+0YIAH5Uxr97+PcaAGN+pLFnxaHfcvAQ"
"AhMIgQkCgXwEQH4+BQQFqSoK4wTPyWlFCAOeGUVo+PrtE+6F+CzE9wsTREVwZm5R/ozFcW5x"
"Cf78JWn4pXhK2w7BcNG7LIJ8K9D3r0TD1wAIWVVFwSBkuUUFGDdAbQaW7UBVlTtgUQM6JmBb"
"DqriATsa21TALhq/HEr8G/tbEgA6FqBiApL+k9t/l64BiNvW0LocVAFACoHWVE6MIgCCV5RO"
"uLa2BJb8nC2IdlElpYujLNP9j1OA/yYASERTUoFqWeiaaQX34EFbfLxKANyXZaH9E5MWAhkA"
"3LcY/98NBfUwboCX2Qq0TAcEVUZggx4JZu0GPGhiAGeMAghKVgdgKgCTAMBy+19NMhQkMT7a"
"6vdr3z/SDgAhNgC8PMvb/yQ+0fg/Pj1EAOxVN/+7h9vx9sFWugKb8Pq2uACiAGQ3gNT+85an"
"8evJwLPxTKYCh85Qi0Ifh7jj0SV3KoLJeHhpCh4FT8OjIH48mAAInEj/tCdieWJ2dqeM787b"
"vSv9zc6q8i9iQ1uV95dZAKrwx6c+grxq4+JiN1xYVF11AirD540v48CP0/BF7sutr7YIycDQ"
"sYV4ZIVYXhz4NTcN3JU+fi7e9NkJBPH5s1D6Z+bzB8IhM29/AmCcACA7DlMFHJ7oykMITMpD"
"w89rFEFefo98hEx+HJvK416ArgGPPOX9Kfqc4PunphekGihEhUIILCyG80sIgiUlqAZKqqOB"
"IAAogyAfQsCvPP1/qoDVcuNXVre/FQB+FRHipzcDqxXh/LMwcQlWGzVAJWAFwMZ6NgDs0MVB"
"13+X00SrgH0tePO3pvyXKsE2uEXf/4bc/jvNenDLclABwEbtAmgFwJ9vOQGwpgQmdc68R+wi"
"hYujTND+5j/NAPzbACCpQLUsdFyvbMvwoI0AIB73+yHxzoDEJKXAVgVg+gDUMJCZZh3YHDsA"
"eJlgoI+ZD7DcTgUEmInAu+16AU7b1QKYRiCrCrAHQFzSIKB6xhoAxNDw5RAEH6NV8E9UgIoB"
"2CuAl2cIAGn8OYSPTw7gw+M9BgDbqAA2q5HgMhD09c1VCgAvYz3VKDAFgIjZGgDhs9R+gKeX"
"p9LQJ9PgJ1Hij+fN/5s69wPH4uGFCbh5aBB91w64sqULIjd3xhWeCL4vjT9ha1vrUWArmuCS"
"zOLzqqvafc8vrE5ZXZVGRaOfXUEdCc6dkJVgU0rT8EuoDUGyQuwIffcj4wiA3+jHS1BvXB4a"
"NX378RLky4mDY7PjwNhsBENWQoH+/9gf6fvT+Cdk48nBr5OLXy83jZ1nSm4adW7zfh51jk3h"
"mZoXx6blpfGbM1XgoJ/Hp+ejCijAn7UgVUAhnJ1fGOcWFNUQ8ChhQKBhcNGbEFhajm5AORoY"
"DX2V9vmtEFhWCcFLK6gTslQm9FakEqik3AHJDoQTAhH+NfR24PW11HZgFRA0ANAQaKIAcN0A"
"4ObBVioWoBSABP92NddVhPJ3KP/VYpCAmjYXYE0lCwDir/kXR7daXy+nXZRL+X/RBvxvA4Ba"
"FmppC65bMcNU3JNiIAFAfyTeHZiIe6YK8L6kAMfaFQJNtQPAHFMNaJ8J8DXGv8zUBaw0AcEA"
"7QZYAWCpBvy7ZiDjBqgmIHP7W+oAFAAsbkCc6g5M/BSrIaAAwPM+0gBAK4D41yL/xe8/agCw"
"XwPgj51492CbWgv25s4GAmCNkv8KAHFeRgHMIwDmaOMPm6G3BIVMxuNLkzQALk7Aw3Nj8eDc"
"GDw4O5pv/0pZ+hNvl/aI2dYFMVs6I3pLJ0Rt5s2/XibqtKIMbs4XWyNc8m2Ai5T+53nzn1tQ"
"jfKfsn9uZRpVJZ6KOCMQkJVgk+0AMLEojk0ugmMTZXNwQb6fnx/Pp4zzMI1XbnXx8w9NoMyn"
"3D84Lps6+ubPqY1/sqsy/ONTaejufKqTh7e9OXz/xPQ8PPrPTshRoJCP5eXtnxdnZsnk3AI4"
"M6cgwVWIqqUIDZ8Q8NBKIHBxcQOAMsr4L4kCkJteVICcFZXUrS9GH+zLP/MpjxC6CgKAy8sq"
"GnegqnYHqAL0fkC9HVgBYLtUBzY2LcK8/akClAuQHAD7Win/Xz4nbntDDQC1HryWmgdwZYN8"
"bboAGwggugBXVxdH+QJpptMuyhIABQwA5ML8/yoGoGoBUqZwdOWzVPmi6UfgapPEhGtdEnH/"
"Zxo6b//7BMD9kXYAsO8EnK6zAPfn2joCLUtBLAB44meXEjQDQu2Hgr4+bAcAu34AAcBfXIA4"
"XQacBACxNgBYIRCLLx9jlAr4/C5cBwFfEwCvzhkAyPSfg8r/1wD4He9U7f9GtRUoKQC8zUBQ"
"GQs+34wFn2kUwDQ8CZ5KF2AKATCR/j8BEPgrz2jcPzVMBfPC1rfB5bVtECpGL2+v5s1Pv/+y"
"f3N9+0v3nzT9eNRS8/6UApBg38xKOE7Zf8S9LA5OKqV2AogCkCGhR9Wk4GIEACEwkRCYVJhv"
"F6IxF+TnFcBRyvQjU+nT85Y+QmM9PCm3AsGhiQIEV3XkY8do+Mdn5KXCyIuTs3hm5uGR9/kU"
"w5/mqoz/xAw5roQCz1Q5fH9abgWAU7Py0fh55hIA8wvhnAKAdgXOm9tfYgIXfcrg0jK5XQUA"
"5ZXhB/OGFxgELxPjr6AAcIkACPbmn1tAQGWgFMAqrQBsAKirMwHbG1mPpPZu7GqqgoASA/gL"
"AKgApIgoVuS/VBcG1FaLQZQLsLG6qgOI2kjVsbpMYviyIomFc6YaQ7so7+KsioC+lklABgD/"
"/mYgOwCkdXZ2zMFnmXw5UvV5E1T3JW52pd9P///+LzTu4dr474/RALg/wa4M2K4XQKUBlyS7"
"/ZfbyoItRUEqE7DdrAUzMwGTKAB7AJhMgLUNOM5uMeh1OwhcVVWB9ipAAyAan99HaAXwOsgA"
"4LQGwNODKvL/4fFuugAEAP3/t3cD8Ob2OrUURAcAZTGIL17LMJDoJWof4LNwGQk+B09DZxIA"
"M/EoZDr9fh6JAdANuB9IBUAlcPf4L5SVbfmi64p7R3rh5r4evJm68gXahTdOW0rgZqrzT4Z0"
"yliuCyL/RQEsrIFLXrUQtrQWQrxqINizGi570yWYVZ4GW1ZF/o9Lmk52B0wtrtJ3x6cUxUl3"
"nulFKcsJhGmFaNiFaMiF+SQU6L8fdRco8FAhHHPPr87hKXx7Bn15SvgTs/PjNA351Ox8hIGA"
"QBu9Nv5c/J65+L1dNRTcNRgEEqdmGADMK4jABYX5OxSh4RfFBc/iuOBVAhe8S+KCT0m6OWWt"
"AAhZXsEGAMkMiPT3tTsWACgVUEmlCsMtxUHra2sAbKijMgG6RFiGhDRS0j4pANrg9hETBNzb"
"koCQZSACAJH/BEiALQYgdQDRm6pRoVVOvLKuHE4vKPAqWybngbSLyk5OaheA2gbE4/z/CwAc"
"zS+Tlicb/155Z2eHNpG/V72LB10Rf7PfZzwcgsT7IxLxgAB4IMYvAcBJNvlvUQBJCoFkJ8Ay"
"bfzq5l9hZ/zJpgJLKvB1soEgahpQcNJMQLzJBFhdgOQAuKZ7AwQCn/RJCoBQowAuIP7lGQJA"
"xwA+PN5nYgC78fbBFrUaXCsAf7UaTGYBPI9dqub/vRQIxEhA0EPBQMaDPYuYjyfhc/E4ZBZV"
"wHQ8lgAglcCjoIm4vr8fX5gdsHtKXawcXAV7pstarYbYMakOTng0423TBpco/2UO4EWfuoRA"
"bVzwqKVn9I2piA1Dy2LjsLJYM7AEptbPhd3jytI1qIxj0/ninFleTQ2WJSJn5MwuzZu4JD9e"
"igbM55ySODWPgJhFlTCDUJhZFEenFSYEChEGdBmmFCIMRLIX5c1dDKfnFlHS/cSsAjwaACdm"
"5NEAmC43vwGAerqqIwrgJNXDaVEAc+kGLCiIczJK26MIT1FK/hL8vSj9feX2L4UgAYDI/xU0"
"7JUVtfTnuSxPSQ0u00pAjD7E1zyTAKBaUgAYBSAAiBE5TwhoBdBMlfre2N/KpgBMEPDa781U"
"BaEKAMqGYYHAxlqqDkAAELOF32Nj5c/XNpbH5t9c79FAujg5OtagfQgAZB+g1AGIG+D0P0Hg"
"nw4AR/NLOPPT0/GZNVVKp0p8Nj60rEwEHnXBx+t9EvDwFwJguAbAw3E0dPr+D3j7P7C0Ac+0"
"C/4t0sE/i7//eJW5/S27AdcnGwm2x64S8O8AYIkBRNhUQEKMDQBfbqh+AA2C6/8FAK5oAEgm"
"4HUwAXDeAMCS+6cKeLwX7wkBUQBvLArgpr8JAvrh3a1VeH9rNV5G+eBp2GI8Dffgrb8AfwTN"
"5c0/Fw8vzcaTiAV4HDoX9wKn4u7pCXhwfiKu7e2DmO2dccKzBRb/VB5N0qZSlX4Npcov+9d0"
"BzpSauoYQMjyhrwt69LXbYCd46uggpMjavPIhN42mdNjWV/6/3Nr4MISNxpbZd7sFWjM5RQM"
"TsyuoIp1AudX4J+V4y1MIMwrq4p1Liwurwpxzi7hxxeWwUnC4dgMynO+LQU7O8cUwkH3Ytg3"
"qSh2jqYfP4/qwT0fVUReZeBy2yvj5zk2NSeVRk4+cyk3QABxiu6C3P6B8wtQuRSk7C+sjP+C"
"Z1EE+Zak0dPwl5XmEfmfFAC6DqCySQlWVVkAnQHQR2UBlle2xgAsAIjaoLMAFgDYOgUbqvSe"
"pQ5AKwApCGqjagKkQOj6783VJCFVA6DcgLpqKKiqBNzslhi3tTrCNlRKuLWpHDwH5oyiPbSl"
"/1+bz3y0E6kD+MrBpgL+Wwj8GwAgv0QKfvrXfGYzAGiydlaRk/ijMz5e652ABwOReG+oAQBv"
"/4e8/R/S+B/S8B/ONme+XSuwjwn2rdHFP9aOQLt2YJkH8Hy3kf+WXoCTSV2ADyG2gSD2cQD7"
"IKACwA0DgBtqqo8NADFqQpCkAnUlYKgtBiAAeK7XgX94epgA2E8ASB2AvQuwBi95+7+hCrh/"
"YSGuHZ+JF7HL8f7uerylOkh4vIlnIz7c9ScgVvDmn4c/QubjzXW6C1e96BrMQuyOnojb2QPX"
"dvXAi5ARcG9aCN0yueAX1zRqfp5Xj3K4vrcbb8hGCPNvhvM+DRC1rjmGVcuJxt+kQJ9sqdAm"
"lQOWdC6FR8e66yyBR22cnFdVleqGr6pHw6jD27EO/WZZ9FkZgYur4szCygjyoRuxtCb2TS6H"
"XRPK4MisSlQVogjK4qJnJSz9KS/650uHYaW+w4gy36J5Skd4d8qDIM8yODQpLw0+rwoMitRX"
"fv90rQCOT7UogdwqXnB6dl6c5e1/bkEBdfufX0wAeNH4fYrT4EtR4ZRG8MqyNHqe5eX4pPRf"
"Sb9+VSUrAEKl+s+/mgryqWrAFdrwVR3AyipJ04BSCyArwk0dgPQGKOMXFUAAiGGrNOCe5koB"
"iPFLMZBSAFIHIK3DhIBaDCpugxkIorsBaybGUQGErq+UcJMAmNIty1naQ3sCoA6fBRx1JaDs"
"BEzjoGMB/60r8E8GgOX2FymTip8uvk0OAqCKAGDKz7l24GFHAqBXAu4TAHeHJOL+KK0AHk7m"
"LU/Z/wcN/w+ZBCwdgKYE+JGnKfxZbVqA19tNBd5sCoCStwPz9n99wi4NaGoB/gKAyL+6AFYA"
"3DAAuGpiAMnTgKFJYwAvTysAaBVwVKkABQDJAggAJABII395fYVqBY49Mg2TahbGr0VzYHJZ"
"V5zzH4e9s3tiRoPi8OpWE8e8BuHdPZkfsALn1gxFoP8wXNk7Tk3QvbG/P8ICuip34Le6+TCr"
"RRn0y54OnVM7oHvW9Di/sj2iN7fjDdmMcrQNdk2uid4ls2FOq1JokcIBndM4YHbzooja0onG"
"LbX59VW9wI7fKsK3exHMa5Uffj2L8+9JNV1DnKcbccm3DnZProSBhb/B8HLfY3brfOjnmh49"
"s6ajATaA/8/FUI0vscXti+L69taI8G+AEaW/hWf7vMr3PvBbXqUCjk7JowN+0/Q55q7l/0nx"
"/WfmpqvB2392Pg2AhQTAYgLAozAVRzEafwmJpCNkVVmErC7Hw1t/VXkFAKsLYIqBQnnCBAA8"
"oat1yi9MJP8qfeurNeFrahgAmDqAjXU1AFQMoKG6/SUIeHV7QwOAFrgpADjc1hYD2J+0ElA6"
"AS29ALFb+TW31tQKgAC4sbEc+tTPsNsAoB6fRWgn0gsgboAo5lQO/4Mr8E8HgLr9HfSAQ/ml"
"chEAVQUAjat/64sH7fDxag+tABQARvKWtwPAIxr/Ixr+o0Xa8FXpr68p/V1ra/6xrAFTZ4cO"
"/Knbn77/S/r+ryx9AGYi0LuLyQAQ/n8JAEsdwN8UAikAiAtwVlUBfnp2Qo0A+/D0kHYB7lsU"
"wBr6/6vw9rY//oxayp/zd1wKmISu0iqc3gUT8mXAmkGtsbBVVfTiTS4nYEhzwsCNxp0BnVI4"
"oefXLlg1oBYenB6NyM0/4enFERhRJQcCxjTCwk4VVMNPp3QOBEIJ3D7YC+d8muDu3q4YXCkn"
"lg6qgmW9KylXofs3DpjfpiQlbC8alkwHaowRlbOic54M8O5ZHlMbFECTr1zQ3NEBc5rlQ9ia"
"lji1uDY6Z06DThnSED5d8PB4fxxb0ATDin+v1ngNLfotOstK7ypZsapfaRycUUW18h6fXRFn"
"ZpXGkSkFcWRyfhydlAdHJ0rKT/v8AgF18xMApwiA03Ns8v/84oLK+C94FqH0L87bngBYWYYG"
"XhaX/cvxlOfbFYzvLxkASx0Ab3t/3vBrq9PIq2sQrNbtwBH+pgJQDQjVRwaEWAAgacDojfWs"
"LoBSAITA9Z1N7EqB7QBgKQVWvQBmIpBlIMg2KopttRKvbq9BBVAx4UZAWVQtknYF7aEdAdCA"
"z+K0E9kJ+L2DDgb+jyrgnwqAJLe/g+5vFt8mT8oUjgKA5uWKppuDq82RcK1HoigAXQdgAPAH"
"/f8/ZmgAPF5Cg6fP/8TXtgXYugg0wFbyq4z+d9vNr4zfVADKMBA1D/CCMf5Ldv0A9vMALUFA"
"SwzgejIX4LqR/9F/UwosXX6XDAAuEgCBBMBpAwBxAw7g/SMdA3jLm/zNbSkCWq1A8DxuFT4+"
"2ILIvbMwjpJ8xg8O2Da8Nf/Zo/Hu8VHMr5ofEzM64P+09x1gVZxP90tT0+xR7Nh774qKvffe"
"EGuiJmqiJlFjAxWlW1DsYq/YK0rvoICoKPbeFex6Lzv/M+/uwnKDJvnK72/yfPd55tl74fa7"
"58yZeeedmYGYPmKzo6gsXNa/KX0vtvDmoGjf0XT5yA8ggknk2LUGrR/fis76fQfJbS5acA3M"
"l5MClnKTysF0yqMT9SmVny4ibFjQqwZ1tpDERF+3PrXp4sERlOTbnVwH1KTaOD2Gl8hDMev6"
"UVrkeFrQuRwNs5Ro9LdfUTT+tndmc+qK+0wqnoucWtrQpgkIDXy6U/jK7qL2wLF1KbHNeVRO"
"cxqaQyKHb61ocs38dMypscgjnJzDy4lcElyG/H9XioROzVXyAQL8zoj9nQF+l7LcNpvCRewP"
"7w/wR3tXhfdnAqgJcNdRwO8L8G+E7N/AcT8Dn1cAGigEsDYrAST6KlJf2Q3IHr+50hqMNwRt"
"tsvoD5CFAHg5b2dbsUNQEMC+zln2AggCON5PhAHXuHEICEC0BNvXRSgGJoBLewQB4IjX29pI"
"Pru2FlUukcsDeOhvaSEIoJaZkggsIiltwf5UBXzuBCC8v6R0OCmEYzl8UCaAHhVK5Zrz+nTH"
"N3RtuNIVWCsEuqcSwANnAB4x/yN4/scA/+NVul1/m3SZfnWtnwt+uAGoAP5RxfOnAvxpkP4v"
"AP6X3Ao8VjHeB5BBALq2YFlKgbMjgMuZ8l9sBuLdgAkweP/XcUoloCAAXgWIyIYA1BCAKwFv"
"KUlAng78PGU9fbi3h64EL6UZpb6hOV+CACb0pJf3/OnZld3k2qomTYb39WlbmR5dOkiGJ0do"
"88/9aCyAOz63RGErxtDNIA4HJpBTtxo0p1M1epU0nebD8w+AvLfHvqbIUgAAIABJREFUfX6x"
"LUPPoyfStPblaW6PmpQa/SPN71aNuuVUGn949K2LEGI0ANGdtky2pf4FctH0JqUoYt1AOuHW"
"mX6qU5i+g5qYWDIXhfj0pdgN/WhEsa9pKLy8vbnS0cehUA5y6VGRYtZ0E+aB679Wzkvf5Ten"
"kV+aie3H0+oWgudtQ/4zq4h6Ai4H9v+9jCgRFsVCjsqyXwjAHyLW/eH9XSsgNGHvX0l4/+jl"
"mvxXCYAVgCCA+hTvCwLY0EglAKUQSBCALgRgY7mvePsWGaA/t72N2AgkNgPtaCc2BHESUJgg"
"gHYiD8AEIJYBDylLgJmbgfplKgCuCMxoCMLFQ3gsCOAiCCB5ZzM6v70RRSyt9qZEQSsuAhpg"
"YS4xAdQBcLgYiJfLWQXkljJVwD+OAFi2cCaTM5p5zRRWq4APassEUKKw1bQn4W3TeEKwfGMM"
"VMAEUnIA03UE4KF4/8eQyI81z++rA/8uVfKr4E/1V4y9flqACn5I/5eI+1/B879WNwG9OaOY"
"6AqUoCOAZF0lYIqOADKXAhUCOK/sBHzH4D8DO62APwsB6BUArwQcpbdiM9AeeikIgCsBN4lk"
"YOplX3p7axddi/Qhx4rf0mx4TN/O9enD8zAyPPUnj7Z1aQpA5tWgBF2N3Ejpzw7TjukDaTRi"
"/B+/keiUJw+pnEl3gyeR5+AG5NS1JsKBKQDvEHIo8Q3Zf83DPK1o+7SONLp2CQpc1odunxpN"
"K0c0hEqQRPNNR7sydCvwB4pZydnrgRS1bgDu356mNi5Jv7YoTRNrFBIE8FOpLynIuz9O7GEU"
"trwXLexYkaZUzk/2X5kB5ObUG6fVzinNRJ6BC5OiV/ekfTNbkGeP8kIJODYrCu/bAR6fC4wq"
"i41BXFnoPxMEwJWCMF7247g/ZFF5eP8Kmdl/JoBlivxnAhAhwJraIIG6mSpAKADeCNRQUQBq"
"JaAIAzjuR/yf4KsSgC8n+7g+v1VGSzDRFGSHsg04mbcEcyXgtnYiBGDwc4GPWAWAd8/YDuwP"
"BXByAN040Q+hVt+MjkCcH+DW4Ff28WPw2L1QAX6t8Py28oVtjSjAvXJaoTzmvzMBmJtJ7XCs"
"B+P9ADYwTgbmlbKuCPwjCYBlDMuZojCudW5sYWHeC8excbua3qF7w+jDldFGujuBZKEA9ATg"
"qRLACpUAfHVtvzXpr4KfM/0c66cFKcAX4A+BhSngf8XeXw/+BGU78Fu9/Ne1A8uSA8gsB87Y"
"DPTurGjyweBPf21KAJEKATwPoXdPA5RVALUa8PU9PxCAWgtwnWsBlJ4Ar29sp+fX9pBrk3Lk"
"CKBt6dMICiCA3j04Sj4DW9AvVoi/EV+f919B8rMjtNdxBI3A3ybgvkfmDaRbwTOhACaRz8hm"
"5NilOk7KcWLb76qxzYRUH4fQoifkvtfghnTt+Fi66GdPK4Y3pE5QFsPgvWc0KE5Xjo0T8f3h"
"Be1oVKWCYiLwzFYVQCw/kPvAWjQMAB5XNCed2Tacji3qQN4jatHj8LEU4t1D9BSY1dCa+uMx"
"R+d1pB9rFKYFHUvT+S09AJzetGF8fZFvODCrGcUubwmgKwRwcmYFOjmLC4fKgQDKiZWBQK79"
"dy5PIQtVAuAJul689l8J3r8qxfhA/q+qSXFramXkALQk4Bl4/ri1ahJwdYMMBSAIYL1S5pvA"
"YcDG5urOv5ZZCEB4fpH176Bk/3k3IB85m+/XCV68k/Do1yD/RVcglQBuMgFwf8ATUAJH+4nO"
"wRweCALYz0NGO1LK3nZ0eX9rStrezHh1d2PaOq3cHeDgBwsLM+4FwKsA9WHcFLSMihctDPjH"
"EYA+/uclDY7/i+MhzG4Nc+Yw74Hj0E0LqkXR/SH07vIoA939keRbXAvwm5IEfLBAVQAcAiwH"
"8CH/n2zM7P0nMv1aou94JvhZ7mcYPP9LxP0AZhbwv1E9v2gIkqTbDpxsEgLoC4EuqZuBzqvy"
"PzsC4BxAtG4ZMJjeimXA4/D+mbsBmQBecS+Am1uVTUHXtoIAdlLS4YU0rURBmo6fZlmD8vTk"
"6mExx3DzDz3oN0h195oF6UYMwp93weS/dDx9B+8/pYBEJ1yG0t3w2fQocipt/qktze5YlZ7H"
"T6P4LQPp/N6RNKZcfhoOohhf7Bs6veU7sW34yj578v3Blnp9Ac+dV6IFbcrRnZCJOOn70g/1"
"ior+gPbWVhSzkdtcj6ZxIJ/v8kv0A0KAgCW9ad+c1tTxSwvaPtUW3rgrxa3vTWPK5qZxpfLQ"
"xX0O9EPlb2lQgS9oTrvSNK15Ufq+Yh7aMqG+aDTCw0iDFtQECSh7DE7NqghFUEHsBjzlVJ4C"
"QASB88pTkLNS+BPmpcT+XPwTs6IaxayqDnAz+Gsr8h+WsQy4RtkHEMubgVYplYAZqwAq8BN1"
"BMAhwLnNLTN6AgoSUJf+RE9A7gWwu7PSD2Cf0hOA43pe71cagyoJwJsBg0RPwFs8PozbggsS"
"0PoCggD2CwKQmQASt9karu9uRI4OxaKAA4cclmIegB3w0QBH3hLMJcHFVdx8I2XNA/yjCCCX"
"+gE4nimBh/B24Po5rcy74DigW4sCq+km9wVwMNDt8STfnIQw4BelEEgkAd1AAEsUAni8Won/"
"hfxXR3+Ltt9HVdmvEUCYAvwM8LPnP6MY4nVhDHwe/MHdgERHIK0t+McqAa9kbAnOngBU8L+M"
"IcOLCLECwMuA77gO4MlJsRvw/ZMjohxY9AMQeYCdak8Angy0BceddNxrLK0f3YG2DrCl5S0Q"
"H7v/SJdCVtL0GsVpVokvaCo88PaJfenFrb20cmR7GsRttmGePetRytGplOz3PS3oVoPsi3xD"
"SX7jKH6bPU7CMbRrVkcxaGP54MZ0K2gKpHI/xKJDyLl7NeGVh1hKNLZEHjrh0QMesS9NbFCU"
"2nLLMEszkMBX9Fur0jShjjUNxOv3xX2nQi1sm96CHMrmockNitHvLcrQDyCI31uUovAVvcQO"
"xB2TG1Ho0o503LkVHXFqAe/cGbF3B8TytgC1QgABTlABc6pQwJzKiP3ZKlGQU0UKmldB7P4L"
"XFCBQtTS3wgvxP5L1bX/VSz/a/F+ekECp9fUEQQQu4aLgJRSYEEAq5UkYLxuGVABv0YEzdUk"
"IOcBuBuQOhtA7QGQ0RTUT2kHxn0B+cjZfdERSN8SLGioMhdANAYdKIaHMDlcO8zJQB4vhufa"
"145S9oEAtjQ1pGytT7bVvuYVgEFWlmY9cWyuEgA3BSkvZeYBvpGyVgZ+9gSgXwHIQgCSEgLU"
"hbXB4wdYWkgTz+5tfpdu2yMMGJNOtychDOD9ADOUQiBeBXjEqwDeymYfTgI+8VVCgGd+f1zq"
"EwSgAv9ltOL5XzH44fFfM/gTVfCfU3oBCtMIIOkTBJCS2RDkwznREowTgAoBxIEAAHyEGYaX"
"ah8AgP/D80BRCvz+yQl69/govL4fgL9XbQiyW5DAi9s76QUI4OV1th1keHKU0l8EQUWE0puH"
"p+hZih/dT9xElwKX0ZXwNXT+gBtFbZhJV0K9adsvPWjDuLa0dVIn8uhXh44s6gu5b0sTaxal"
"6Q1saG6byrQbwL90YBRdPDCW5rYDoLzhpU78QBGrepL7gFo0oW4xmgYAz21akn5vXJRmda5A"
"fjPtKMSzE81sWxaALk4uPavRCddOdHbHICiRJrRlYhOK8OlK4cs6IIaFXN7Wl065tqHI5Z0A"
"HMT8KztQ2OJW8NRtKGKJHcXieHpVWwpd3IxC3JuAABorLb8W1YHMr0Uh3A1ofjWQAYjAqTKd"
"mMlqACQwvxL+r1iYi7L5hyv/opdVRxhQXYQBMStrAvC1QQR1MhQAVwLG+NTLQgBnMkigqS4R"
"qKwCiI5AXP3HvQG1lmBZCCBrU9DLB3qIZp/XuDEoKwBIfvb+PBfgNo8JAwnw6DD+u54ALoMA"
"Lu9vR+d22qVf3mFLO2ZVvGthJv0EHAwGHjrCmklKDuDPCCAL8D5HApA+QQBc6VQHR1uEAb1x"
"HDK0i/Vmuj2Q3l4cbuAdgfKtKXK2BCAUwHpl/T+DAPbrCCBQ8f4vIwH6GNhp1fMD+K8TVfAn"
"qQaQv7uQSQLC+5/LDAMyGoJoW4I1AjivgP994h8JgMEP8jGkMQEEgQAC1O3AJ+j1/QMkvz4F"
"cjgucgBvH+4DAezB33l3IM8H5B2CO+l5ylZ6dmkzPU/eTKmXECJcx99v7KI3uM/r23tFOfGH"
"x4coNcWXnsTz3oD59DBuAT2Mnks3Tk2m66d+EluFH0bPhEeaSpcOjaMLfiNhI+jqsQm4PRYn"
"oD0lbu2POHQgXT0yWuQKrvv/oOQM9tvDo3YVQ0Ev7upLyXsGw3MNpbObelAUAJ/o25XObugK"
"ALaj8MUtIctbUYALd+1tSaFednRyQVMKdmtOEYtbUAh3GnKHedgC+E0pYqktnoOnEDfF43hk"
"eANRRnzKsQYFL6gBkNdEzF+NYnlHn1dNCnOtDpLgPQSVcb0yhbvx7j+QwDKEAN7VhRKI4c0/"
"K2uLSsBYkEDsahDAam0rcD2hBEQIsFbtA7he2e4brxlX/6mVgIIAOB+wTWkOqnQFVhqCKoNB"
"9F2BeyH+7yXagl/ntuCBQ0AA9mIu4O0AlQA0BXCECYCHi3SQr4IAErY2N1zd3oQ6Nci7Gee/"
"vZUi/1sDF01V5/iPVwB6AsiSA5CU2KYGOIyrAdtZWZkz+40/uLLhebo/nN6mfG+ge1OhAmbI"
"SiGQmy4HoHX7QQz8dFvmXv/n2lp/iAr+ODXm14B/NvMowH9OBb/ORFNQfU/AZF1PQLUdmIHH"
"hScp4H+fAAKIBwGc1hEAwI/3YEgLBviDhALg6j8DwpNbcWvJtSNO0h2O9OHpUXp2ZasA//PL"
"2yn1yg5Ku7qN0q5tBwnsptc399CrazvpFRQB5wbSrmymZ8kb6OmFNfTkrA89jPem+3GelHJo"
"Il05+jOlHJ5EFw/9QClHfqCLB8fS+T2j6fzuETiOQEgwks7vHEbndtnTmU2DAPqhsMGUsLkf"
"ZHofeM2esB4ATzeApQs8Z2elXdiydgB0G8TcbQFkOwDZDhLcjoIWNaUglyaiZXeYV3MK5W5C"
"uB7s0hRS3ZbiVrDnb0nB3GLMoynu11Tp8uvZhEI8lG6/h2bXpyFFvySvfuUAulZ4DMjBqz4d"
"nFkdj6tHXr2Lk1vP4lAKDSjcoxaFcQcglyoKCUAFRC5W9gBEebOBBFbUUkhgVR1hohRY3Qoc"
"x6EAbwNerWwE4l6AGXsBVqt7ANYorcLPrm+epTuw6AGQMSEo62QgbvqZMRjk5EB1MIi9CAGY"
"AG6qBKDsDeCKwM7ytQMdKGlbK8N1PztaNqEc1/+PB/iH4tiJcQtrDGPn+K/IAXxsFYCzm1XN"
"lGynnYW5xMlA+xKFcsx5GNU1Vb4+igzXJ6XT/ZmUfm++nJEEfPQJAhDFPqdU7x+tk/wMfAD+"
"Dds55cjgf8teP1k1EwIwJYFsCUAF/7szKgHEUvoreP+XYQL8hlRIf+H9/UEC/pD++/AaITSl"
"XHFa49AJX+VpkQ94B09ufOFPhme4/uCA8PIvru2iF1dBCDwyLBle/vw6enR2FT05t1qMD3t0"
"dgU9v7RWbBK6FfQLPP5U4flv+k+mK0d+pMtHxtLVo+Pg2b/HSTtKVAfySPDkPcPo5snvRfFP"
"kmgT1k+0CDsL441CZ9Z1hefkngEdxfCOKO92IAPFy8csb0WRkPIM/FB48hCAPXBhE+HdAxfy"
"rsGGwngM+Jz2JRAylIGX7SDGjodC8kd7NweptKCo5S0AvNYU5dOa+nxtRUsHVKX9c5rS77aF"
"yKNPGeqX25JmNCtELt3Li81M/osaU+zyRiCgqgB+NRAASMBFJQFPdSuwCAdqChKI5g1BHA6w"
"AjAhALENeGUDpSEI7wb0UVqCaZuAlF2AzdV6AKUpqEgC7uEuQF11BNBTKACO/Xm578aJAWI0"
"WAYB8LRgbTjoMa4M7AXV0BXg74Tna5N+aVcrCvWun/ptXss5OO+HmZtJvBrWBsZL4xz/15L+"
"JasAf6gDkJR1TRsYJwJrmSkqoC1YsD+ODi3r5V/+PmWg8cP1cenpt6fJ9MiZ5AceMj1epiYB"
"12SuAmghgKj191dif7HWH5sJfgH681mPggAY9Bd1lmyiAHTzAdU2YBz7KwRwViWA07A4EADA"
"/zoaBBChev8gEADi/udKJ6APz4+LFuCUHkEeraqSW+NStHfGINrxSx96fmMfha+bTheOu9Gt"
"6JV098waSr26E7J/J1TBFnp7bzd9eLCbjI9209tbmylNdAL2pafnVtKdiPnw+hPoZvCvAP0E"
"unwI4D80Hl5/JJ2D9z+73YEu7huJv42B93cQ+wT8ZrahmHUDBAHEwvPHrOoKUHYUY7diV8GE"
"50fcvrQNANMOHp579rehE/ObUCC8e8xSeH14c57zd9qHuwc3Ff0EoxDbh7o2oVhvOxpi8xWN"
"Lpufold1pt2/1oOXbU1+v9ahxYPK0ZzWJcipfUm8l640LK8VrRtVl7b83JQQ+FKoT1eaWiEf"
"uXUrTfEbupHDVxLFrOUORtyotBpFeFYTOwhDFyntwMI9KkMJVBG9AKKX1czoBxDjUxtkoHUE"
"UlYBYgH8mBX1QWQgA10vAG0LMO8HUPYEcC9AtSHotraZBLCni8gBXD6oEMDlQ8o8AO7/z57+"
"Js8GFCHAMDEd+NbJwcpw0KN9QcS95OtHuDtQB/kiCODClubGuuW+Xo7zfbilsvTXHjiwkxTv"
"z/F/DRUfNtK/oA4gSyWglJkH4PiG45x6eAreA90+h5X5IBxHtGtccPX7K/ZGw42f0o2356TT"
"Uy+SH3rLohAoYxlQ7fv/fF8mAQj5H6WT/pr318B/XvH8Gd7/ok4FJKuTgfTyXyWBLASQpBJA"
"vEIAbyH938aAACJBACz/Af60QBDASRAAdwI6CgI4Si8Q25McTt69G9DiJhXo1eMQGmMuCfBv"
"/WUoOVhIdDdhMy3t14yuBC2md/f2wdOvoZ2/96WjbqPpuNsY3Hcy3YrypJhtU+jh+ZX06Azi"
"/5jZlLjjO7oRMJVuh06nq8cniT0Bd0NxO+gnuhf6M3n0r03+7n3owv5RYgLQgbkd6ebxUZS8"
"awCl7O5PF7b2ENOAGfA8Hjx2BY/Rbg/530ps6Dk0szENLJWbdv1an47ObUgHZtWn/dPr0/rv"
"AEiPFrRmVFWa2aEYLehaAjF1W5rWwppGF/uSFg+pKgaB+i+wo5/qFKKZrUrQ4n6VqLuFGUWu"
"7kr28PYbxzei4wvakX0uCZ9hFP1cKi+5dilNh53aiCEmpzzsAFCoCFdFAYhcACzUtZLSEUio"
"gGqiJRgbE4DoBwACiF5RV+kLwL0BfRj8OHqzgQSWgRxwWyEBZTtwBgFsVKsCt7bJSgB+mUNB"
"FAWgTgdmAuCBoGI4qINuPPgAKLF+8m3/vnhc1/TLfh3SL25vaWxUOQ/3/hsJpzcEx444/3kL"
"MMf+7P1rw6pKWeP/f3QlYJa9AJIiZ7gakEcfCRUAa6gyYMdcOc2HKiRQaPX7FAej8c7U9A83"
"5hnp2TKSn6yUZU4ACvm/Q6n+y+j1F5hZ6ScSfwnZkwB7/rfJJgSghQAaAVwwIYBkHQGc1REA"
"gz9WJYAIEADk/wuAPy1AIYBnnPk/TIbnh+nFDbxfYwhA05l+K1qQeFyYW50y5GvfluQP0TSt"
"5Ne0+fvOdGr5RHp39wDk/npKf7qP5rSoQsPyfU2HXb8XJbRrvmtHvzYsTXNtq9LVIEeaULEA"
"7ZjWiebaVaCoDWPomGt/cu5UiVaNaEjz25enzT+3FFOAVo60pYBlfWl+58rk79GTVo1tSC69"
"KpPnoCo0pVkx8p8PsPN48BVt6OTCZjS/e1nyGlyZ5rSxoel2pQiuiVaMrEGLelak1pYSjaue"
"j+xL5yanTqWpX6EvyW9GI2qJ+6weXZvmti1Jk8rnofhtfamXmUR7ptrS1sn1aXbrkrSgbSn6"
"vlBOClvVg/qBANc41Kb1Y+tTTwa7Z3uaAaLwHlCe9v3emHZMrEXh3q0A3CYAO4Nfkf+cBxAK"
"gM2TrSpFeCkEELEUKkCogVownhdQG+oAZACwc6vwaCYABr9qmgqIX6WogMS1mQTANQHJu3R1"
"AHs6Z7YE58lAh3uLASBZpwM7gHgdRBiAEADg708X93c33jjUNf3ijjbGRlXyMvhH5LQyt8ex"
"M857Lvxh6c/b4zn5p3n/0tK/YC+ARgIZuwElZXcTs5qWDORYh5MejVQm7JQrh4Uggaa1Ciy5"
"Fz3oOT2ZQe+uLzDKT5bL9HwDiGCrLD/blbXVt6jzVyv9BAHEK/ZKPYoEoJ4ALmSTBEw2GQ12"
"QWkMIghAyf4rBMAJQMT+7xj8kP5vFO+f/jJUVQAaARyn94jxPzw5SC9vgwBenqCTy36g5X0R"
"bx7yIKcaxSjE+xd8rZfo2MLvaCR+iusRPpD8B+hh/AqxM3Dbz91pdu0yUBqn6Pt8VhSyajKU"
"wC806ktzuh48j+a1q0jHPQbRxCJ5yWewLSXsnEJd8Dwbvm9Ny4c1oYMLe5F9Ton8pnWhuO2j"
"BEi3TW5NPqMbElwO7fitJXX40opmtC1LSRu7ITZuTeu+q0WNANyFXcrTxomNaMdPjakjbses"
"60H+zq2EVz88246uHRxAY8p/AxLKT/dxwvf/woLc+1Uh1x5laXKFvBS7qRe1w323/9iYRpXK"
"QyNLfUWuXcuSQz4LqInGNKd5Ydo6qT4dnNWEDs1pSMGLW1Lc2taQ4G3FLD8e3R3n0wTgVpKA"
"IZD+QgG4KzmAcO3oUVWEBxFe1ZSmoEwGi7lFOEgAFrm4NsKEOsKihdVVCMBbRwDcE0BsCW4u"
"NgXxhCBOBGYZDaYVAgkS6KaOBustVAAnAZUQwIFuBg6T7wbbszKQk/f3Mj481Zsi19k9r1U+"
"9xI+r3Nkgp/jfl7206S/Fvtryb9//G5AjQBMVQBvCebYhrc88qYHDgWY/RqrJNDRSoQDZiOK"
"Fso1++T69pcpbSa9u7PAaLi3Ip1St5Ocuhd2xCTzr4JfWJzuGKsmBc+qqwBaElCzC1lnA75X"
"ga9ZBgGcE+AnA+L/9xz/w/O/jQIBAPyvQkEAIZkK4DkTABf+HKK3D/cKe3NvD717dFCQRErA"
"EroTv4nePg2mO6d96WacL20Y0YFe3dpHL69thgLwgRLYTO4gi0G5ctC18CU0+IsctO2XfhTs"
"M5lwBlHysd/p18qFaduULjSvhjWt6lmX7sZ70fgvJTq3Ywq9vbGY4hEeOHxpRgHuA+h2xG80"
"6CsL2j2tPR2Z34UGfmNFtwMn0Pjy+Wlup7I4qQcAQC1wXztaOrQ62cNTT65jTdsRozMB+Lu2"
"o32OzcVsQb9fm9Hl/X3Io2cZGmH9Fe0AoAfmt6Djzq1pTqviNLlaftr1SyP6pUEBEE592jOl"
"Aa0fWY1OuTXH87eg2DXtEGN3ocSNHRB+2AHsLenMGlsx2SfUE4B3r0nBzkoLMfb8YhaAKv85"
"9g93z0oA4e5VlZUCdV5AhGcNWE2FCEAgkUvqKEQAi8Z1xfurfQBV+a8RQKJKAGIr8HZlNNjF"
"nSYEwJWA+7uCBHsopcA8DixgMN0JcUDY5UDXTgxOv35sgPF56ABaP6ve5UL5LGfz+azKfg38"
"zVXwczKcpX81FQ+lVHz8K/oBaCSgVwG8pFFAUjKcNpJSGKQnATsmAUtL8/7m5mbDLS3NJv46"
"qtqRN5d/fE+pbvT+to/R+HR3Or3yJ/llEMmi6Ccmc+mPAS9ux2QtBtLCgoxaADUhmFEJqNYA"
"ZBDAOcUM53XxPx77AfL/fRwIAOB/C/C/CSXjqxAyvsz0/obnJ+iDIICDCvgf7Ka3D/aABHgP"
"wB68jwCQwWF68/AQLe3VhDy71KGkw6709t4BSr20ntIuraFnF5ZT/O7pdGrZOLpwbB5tmtCF"
"DiwcRic8vqO5tUuQ/5Kh9EPRb8hnSCNyaVmafq9UkILXQEnk4p4B7ejK8ckUv92BRnz7NU2r"
"b0N+jh0FeD371qbV39sKWX9oUScaYg0vXsua4uGxk9ZzE4/q5DKgBvlOakg/1/2WTrm0pf55"
"LYQiWDe2Nv1UNR9tnsDLbO0oBoph28Ta5GNfgY448Uy+VnR0bn0K5ulCHjx8sxXFrmqB0KIJ"
"QoymkOM80LMhRSyuB5Crs/48alGoWw0cAVqvmmLiD8f7EQA2y/0ggD9kkdIFWOkErMh/7XYY"
"yCDMjZODlXG/KoIwxPQgN6gBPGekZ60M8AsCgApg7x9r2gh0bdOMfgBKDqC12ALMo8Eu7uiQ"
"SQBiLoBSCqwMBeklNgDdCRoM7z80/cqJIcZnkQ50+WDv96N6lDlsaWE2QZzHSsKvoyr7Nc+v"
"B39FFQ9FVXz8KzoCaQRgLmVdEdBCgWKSEu/oSaCRSgI8J61XzhwWDrg+skalfG4hW3tfpefO"
"ZHy6Un53f4cxPfWUTG+ixPZe+WWMLDPYBeijFFXA238zioLi1FJgbR/A2czNQLwTMGM8GO8I"
"1BkDX8h/vo7HGc4I7y+/Rdz/JgwG8L8KBgGw9z8l1vwNT4/R+6dHQAAHAPS9AvyKsRrYT2k3"
"d1Daje3i+pOU7XQ5aCm9urOfXl7fJjL9qSCA5xdW0Ltb6+n93Y2UdtGH3uB62uWVlJqyVvQR"
"eBAzn26Fz6GkvRPpsv80Stj9I53Z9j1FbxpDcZtGi4If7g7k79qDdk5tTdHrB9Ihxw50yqMb"
"nXDpSAdmtcT1jrR/Tgs6AEkf6cPLf60p2MOOdv/aiPZMb0TRq7iFWEcK8mpJkctbw1u3pXOb"
"u1LC+o7wqjy9l5tr2sKLNgWwG1CQS20KcalJAfOriOagp3i0l3M13K5K/twkdAHfhpyHZw/z"
"qA4CqE7hYroPbiOWD/MEeNkA8hDXSqL7b7BLRRBERQpx4zkAIAC3SqItuDAOC2AhXC24QLWF"
"eOzCKkI9hPMIMVYC8PpRS2pnhgBZCKChkgTkXoAIO3gikAitShrrAAAgAElEQVQBtH4AYjZg"
"O6XBp0oAvBkoZS+v63elG6IhaB855Wg/44NwBzk1egRtd7G7Wskmtxuft5D8w83NJC54a68q"
"XC3mNwV/aRUPmvT/1/QE1JOAFgpwd+C82ZAAfxmcE+DEILNkGxy7gAQG47UcmE1H9qm061b0"
"+Gf0ehmlP9suv3t4xJD+IlwWzT1fR0MRRMpyWri6HyBUSQ4yEbxSVUHGduB4dUeg1g9A2xKs"
"2gfVBAFo8h/3NZwW3l9WvX/66yABfuPLAB0BKN7//eN99JYJ4CHAf18xVgFvHuwVG4Je3NpO"
"r27vJMMTBv8WenFlA6UB4KkXV9Lz80vFQNBHp13pSYK7aAr64LQLPUzwEA1BrxyfCKn5M90O"
"/YVunPoZ3udnMQj0xskJYhjoxQM8I3AIXTk8kq4fG00X9w4VFX3JO/vR+S09cWLD42/qAkAr"
"xu29Irxs4aUhgX3bwxu2o4ilStVe9NLG+F8DALEerL5oBhruXhuArQnQV6eARVUpEKDj1uDc"
"DvykU3mAnzfyVBS1/AELuKa/IgXMw5Hr+/H3YHj1EMj4UIA6TLVQYRUVA+jFJiDXCriuWJgw"
"PM6lAkKEChSC5wrG8wbPryj2DwTimEEAi6qJ5GG4O1SAV21FBYAIYrQcgF4BrM5cBRB7AzYp"
"/QAFAWizAREGJAP4F/06y9zx9xrX9u/vKifv7W64dbK//CJuBMXs6v2sX3ubXRbmZhP4fAX4"
"h+LE78bOTHVqTVXwazF/duDPq+LjT6X/P4kANBKw+BMS4BioqvrlMEM2xUu0xLE9QoLeVlYW"
"w3B9eP48OWc4/tT4ZGryjNf0bgPnBOR3j44Zjakh6fQmUrT9kl8E4+/BsixIIEwlAW4FFqOY"
"GA6qGrcFe3dGsfdsIIQPCYox8I1JIvZn8JMhViUAxfunv2bwnyLjC4A/DeBPPaESALz/YxX8"
"CAHe3EcYcG8XjnuUrsBqP4C0q+vp2aXVlHaFPTzPBliltAU/v5hSL/A0YG4J7i6mBT9OcKHH"
"iW50L2oWXT0+nq6dnEhXjo0XdungaEre60Dn/ezp3O7BdGHvYBDAQErc3IdOr+9Bpzd0pTh4"
"dM70Ry5rSRFLWgDczUSlHg8EjQDQIzwbU6h7Qwp2bUDBADqDPtKrPu5TF2CqJUAf4VFbTOkN"
"hXfleDvMi5cDqwgPHejMwC8H4yEgpemUUxmdlaWTjtwDsCyAWg4g5l1+ALRnBQpn81Buh7qV"
"h+cvL47cAyCUCQC3w9gWlRdtwUMW8pzAChTEJDNPmRsY6ASbByJYwKpAUQBhrtVEOXEEhwFe"
"tUQIkLEKoC4DagSgNAdtKvYHnPVVKgK12YDnt7SRL+xQOgFzc4/kPV3Sz+/pYrwFz58aZU/n"
"D/R9/fOw6ifzfJNjBs5PxPrmw+Cs+uJ6B1Xya/E+L/Wxyq2pnucV/gT8/5q5AOrdzcwscJGU"
"uMaUBLScAK+BVlG/JC0k4C+Qa6U7Qw0MQGjARDCquPVXToum2QU9T54NIvBFGOBH7x8eMr5/"
"csKotP8OFs1A5DQQQVqIrCwVRipzATUTfQFjAX4mAZDB+9MKCQgCiFcJ4Kwq//F/A+T/uwgQ"
"ALz/m2BVATABnFQJ4Dh9eHoY4N8P+e+ngP8BA181kMDrO/D8t3j3Hzz+tbWiLfgLgP9FykrI"
"/eWUmswjwjzFePCniS70FMB/FL9Q1P0/inemW8FT6PLR7wQJXD0GqY/rV46MopSDDnTpgD1d"
"2j+Ekv0GKaO/d/SlpG28O68LYvKOiN3bCqkf69OKopY3h3e3hXy3BUAaA4gNRflt5OL6uK20"
"9xag96wtSnLZm4YAVKGIucMh1cO94ME9IbvhqYMB0EBnAH+BDQigJKwEBTiVULr8wsS0n3lK"
"v78g59IggDIglbIggHJ4rnIgk7LK0R3k4FoWoGfj6+WVYSDOuL5QseD5AL6TAn4+Bs7NJIGg"
"eRWVScILqwoCCHeroRBARg6grqICeBXARyWAjOGg2phwTga2lBEGyEwAlzgPsLMDJe3oaDy3"
"qzMDn56FDaYkv16vfx1RI8i6wBdOfD7yeQmvP5BVq6SoVzvpj5K/hnp+l5cyY35T8Ovj/n8N"
"AXyKBDjm4ZpnXvssKSk90Xg9tJr6pdXnqkFYC/5i8UV3AxEMMjcz4yWVUUULfT13xoRmx27G"
"THtGbzcCyHshqw+kv31wyGB87i/TqyCAPVgQgvwyVJZfhsn0OlxtDa6OCBMkEJtJAgx+QQAw"
"Y6KOABBmvAtXCSBEJYAAlQDg/VOP6QiAvT8Df6cK/h3w/hr4fQH8tSKuT7u8AtLfB97fWx0P"
"7kXPznnA87uok4EWwpxBAE706Mw8uhE4iVIOjaLLh0fT5YMjIPNH0OVDDpRyYBhd3DcYHmog"
"Je8eQOd3Avxbewjwn0HcHremHcWuag0VYEfRy1uIjTkRS9jzN1Lq7hfDPOvhdl0AHqB3B+hd"
"Gfg18f8a+B/H7lWEXA/3Qjy+pCKOAKgHgOlWBvE6wD6/BLx9MVhRYQHzigH8xfH34iCIEvDQ"
"JSD/SwLcpWA2UBI2AL0NXq80yKAMbpcB6GGLyohmoNwWLHiB0iEoeL5yWwF+OYUEnFTwz1Um"
"CgsScOJ8AIcBVUEA1cVSYuRijQQQBiypm1kItEKpA1D2A9jK8ett5aSNLeD5W1HytjbcHFRO"
"2NjacGFnx/R7/r3pYWB/CvXt9Gz8wMpHCxXI5YjzbzTOQwDfYrC5udQdt9txrK+GsHqvr0n+"
"Sur5XVI93wuq5/9/Cfz/CAKwtFQmHZcsWVKqUaOG+GB4DnVWgBk/GSc8uOKJs5+FJWUdVAsJ"
"mC2ZNTk30EDdMWUHa2thYdY9Z07LQaoiGJH7a6tp9n1r7YjY/8N1w5OV6ZTuBwVwgN4/Omh8"
"9/ioIT3tlExvQwB2ngsQSvIrkMGrcFlmIngLNfAuRiGB93FqKHA6kwCMpgoA3v9NkBoCnAQB"
"nKAPDP7Uo/Th2SGEACoB3Afo720HAcDubgMBbEXcD/DfhOS/uloF/zJ4/iWUBrkvZP95lvyu"
"8P6LMkaDPYI9PD0PBDCfrp/8Ed5+OF05NBzHYSADexyH0qV98Px7B9KFPf3h/fvQecT5Z7dy"
"g87OCAPagwDawPtzcU0LEAC8v3dTilyC+J6BD6kfLoCveP0wDfjuCvC54Cbcq4rSk39xRTym"
"Ah4L7+0FT+5pAwIoCQJgjw/gOxamk3MLw9tbA/xFYEUpcAGIwLkYYvTiAHhxqAg+lhCPC3Ur"
"BRIAIbjZCGIIccHzLVSagvK4MG2YaBDCiAybpyiBQKEE1BBAGPcSqATCQFjizMVD1TJCgIww"
"QF0K5DxArHd9+bRPQ5mnAyets6Uk7hjs21w+s6GlIX5ja+OVPR3o4fEevOSXvmNR8+s9WxXf"
"8dUXFtP4fGPg57SyGIKYn/fycz+/Vqpa5RL3hpIS6+u9vib5i6vneQH1vP9SAz87RzMFWH89"
"wfa5EoD2f40AypQpI7m7u0ulS5cWHzBHjhxaToCzndoSIa9/aiEBr4kyW3KihGMmLSxoaEIE"
"3XLltByoKgKOvyY2qlN82fJFfSLuJy1Mpfc7SU4/Au/PnvmQ8d2TY8b0lwEggzAAHgqAY3oo"
"AflNlCy/jZHpfawaCmgEgHDAeEbE/5kEEKISQICOALj09wgUABPAPhAA4n4G/j0G/hZI/80A"
"/0Z6CfC/uL4G8h/e/8pyeP4l8Pwe8PyuYjLw86RFkP3Owh4nLAABzBee/2GcIz0CCVw7Pk7I"
"/JSDDPwhdHH/IHj+gXTRbwA8fz+6sLsvvH8vOretByVu6UoJmzrRmQ0ggLVMAHYU490MBGAr"
"CCBqWSN48gaZXp9jfdeainlUV8EPILnD6zP44fUjl1YAAbB0h/f2BHg9GMjF4dkB9PnWAH8h"
"OgULmFcYoC8MyW8N4BehoIVFAW6YWzGAXTEmgzD3EsJCQQYhIIAg55IgDGU+ILcK507BAdws"
"dHZpePoyggB4TqAIBeYpBMDSn5OAgfMrKQQwr7IIBUKdeUmwhiAzJgKoATl6cR2Zw4A4qIB4"
"qICElTwqvKEc49PEELu2meHC9tZ051AXunO0O4WubZM697vqETXL51nGyT2cXw7mZtKwHDnM"
"B+F2dxX4LT8B/Krq+VtWPZ81yZ9PylzqywGsWFpZWf1t8H/WBKBdFMWvKABnZ2dp7ty5UsWK"
"FcUHxYc2x0UjAd7zrIUEejVgIykVUlpYIIgALw8iEB2GRWiA612gCPpZWopqQhEeFMj/5YwB"
"PWtv2es7LunJFe/XJB8kmU4A7Mfp3dOjhndP/Q3GF8Hp9B5E8CFGAfmHWFHpJ7+LkeUPZ2RZ"
"yP/T6v+iTRQAE4A/CACxfyrA//wwfVATgO8e7QIBbAMBbFUJYBPk/wbIf8T7V30U8KcspdSL"
"ngC/Gzz/Qnj+hZD+zvQkfh6Ar9ij0wx8ngw8S8wCvHp0FLz9YErZPxjHAXRxL4C/h0eD91U8"
"P8B/fnsPOsvg39yZ4jd1pDMb29PpdYj9VzEBKOCPXtGYorwbUdRSxPyL6yqxvltNETeHuQP8"
"orquqgB/GPfkW8zgLw8rAyCVxv8Afk8A1wPgB7CDFrLHB/gdC0L+F4DsLwggF8LfC+H/hSnY"
"1RoALwKgsxWF3C8uSCAM5MEkIgjApaRCAPOU4SAnZ5YCCcBm2wgCCGIC4ESiLgTIIADNnFQC"
"WMBWVQ51qSZzMjDSoyZFL6lFsUtqUyxXBy6pkx65tL4hankDwzl4/pt+7ej2oU4Uua7l66W/"
"1E7q3LTwlrzfWHFib5TEjsXSbGhOK/P+OO+64jYP8RDAN/s48Cup562NlNXra5Kfz3cBfjhD"
"ke1nhcw44YvmOP/xBKB9EHh+aeHChdLvv/8uzZs3T+revbsEAhBLhCr7aXkBTQ1wYoRjJGsp"
"Mywonw0RIDQw4x+BWZjXWjtYWVr0ypXTahD+ztVXHCJ8V6RwbsfBfRpu89s0IenJ9bWviYmA"
"ggDsYF7CS3/7PNDwPi3EKL+NlAXg0+H15Xgh/+UPcVy3D0KIlLkAKKsCOEHGNJb/AP+zAyAA"
"eP/HfiCAnToC2AwC2AACWAPv70OpV5ZRago8/yVPeH93gH8RvL8zPUtcAOk/n54kIN6PnwvP"
"D4ubTQ8B/vsxM+h+9DS6ephHgQ2gFHh9PgoCAPiTAf4LKvjPbetKSVsA/o0dYR2gANrS6TWt"
"oACaU+wKW4r1aSIIgOf5RUMKRy+rK8plhVT2VIpxGPws+8X6uydP5GHPXxZHxOzw/BGLS+AI"
"EHuwZ7cGcAsB8N/C8+eD5cf1/PhbASiDQvh/YXh+EADAzxbqXgSgLybII0y1UDfODyh5gkCn"
"EgB+SfKfWZJOzuJZgTbw/joCYOO+gY5MBBVEHoBzAKfmVpAD5laUA0EAIc6VKYzzABwGuFXn"
"4iA52LWGMcy9liFyad30Cxtt6fqulnRzb1uKWN3s9eLJNZO62Bbe9m3eHHNxvnwPc8C5ZZ8T"
"3h6qktfyed8+Z/W5d18zMyXG/xjwy0uZct9aPY/zSplePyef76oKNgemzLp16ya5ublJ5cqV"
"y4Kbv6q0P1sC0BSAjY2NtGjRImnWrFnCPDw8pCFDhkj58+cXJGChXEzVAMdIWljASZMS6her"
"KYKq6hevJgvNGsM482onKQnDLjlzWPbNkcOSiWAo3rIgA+vCeeb26lx3k6/P+NgrCSuekMFf"
"likKH5Pj/Ej68DLU+O5FmOH960hj+vs4WSED/C+dVUCkUADGVwEyvL9sSDsmG1IPwfvvBwHs"
"BQEA/I9360IAEMCdjfT69hp6dXMlvbi2FLE/4v0UD3h/V8T9DP4FkP7zQQBOkP5O9ISBfxrA"
"j5sJ8P9OD6Jn0D2A/17kL3QZ0l8D/kW//pTsp8j+Czt707nt3SlpWzdK2toFCqAT5D8IwLcd"
"nVnfhk6vbUlxggCaUgwTwHJ4f28e6llf2SyzjJNktSh6aU14x+piv32EF/fi4468PJgD4Pcs"
"LcAf7lUSBq/tCRC7F4WHtxaePmhRQYA+v2ILC6gE8C0IoJAggFBYmIc1HlsEBu/vyY0/igsi"
"4XCAcwSBTsUpYG4JAXx/KICTs0upBFBGEAAfT4lxYuXkAMdyMsAv80oA1wKEIAwIQQgQDAtw"
"rCifdKxkDFhQ1RC8qIaRJf/FjU3oyrbmdHFrc/mwe/0n88dWjm1dr+DmgvkU0ONEdMDRPoeV"
"+RBYP/Os3r6FGnpqWX0tuWfq8Uur52kRKVPu55Z0Xl9Sl/lwrprnzp3bbODAgcI5sjouVapU"
"Ftz82eWzJwCNyZgA+EPOnDlTcnJykqZPny4tWLBAcnR0lGrWrGlmogb0uQGNCPJLWYnARv3C"
"OcbiJEt19QfRwgNWBZyNtYO1Q8zWFSGCngw4TBid+5svfm3coIL377/2O3ry8MLLT+/4vSJC"
"rE9n8bHPA/gJ9OFNRPq7lyEGmPHDq+B0+U0g0dsA2Emi18eIXvLOP4D/6R56/2iX/PbhTmFK"
"/A/vf3u9AP/LG8sh/xdD+usJYKEA//MkJ3qWMJeexs+hJ6dnwfMD/HG/08Po6SCA30AAv9Ld"
"sJ+E9NfAf3EPt+1SwH9+R094fhDA1q4C/ImwM/D+p33bQgG0RggAAljTguJW21LMKlYAXL6r"
"7JPn7bPRvI3Wu5ZosMGddiK9QQBLq4ikH2f7w9zLimx9uAcIANKfCSCMvT9kffAiawHyYBBA"
"iGt+1Qoo5lYQJPEtzFpYmKc1RSwpAitG4WyLOQ8AAnApBsIA+B2Lw5MXFwrg5CwQwJxS8qk5"
"NjJCAJlzAUGOZcQqQDDi/5D5MIQAp3jC0Ozy6SfmVjD6O1Y0nJpXxRjpUYOSVtWjZN/GlLyp"
"CQUsrftq5a9VL4/uVuxojXLfeH/1hfmv/PubKQpxqJUGenMzLt7hHv1cg8Kgt4WZevua6vlW"
"RT3/NKmvB35+KRP4X0g64Euq12/UqJEZO0UvLy9pzpw50pIlS0SuTI+bf7wCMCUADgEY9Gys"
"BPi2p6dnhhrgi0gMIJg3CQt4c0QeKZMItNCAKZO/NS080KuCeniOP5KBhTnIwKoPjFcROGcw"
"BPcZjuO4okXyz2llV2vVAsdRJ0+dWHLl4d3DL4jOyESJ+BoSQAggBxDA22dHjW+eHjS8frzf"
"+PrxXuP7Z3tl43M/Sn+2mwxPd5HhyS56/3A7vb23kV7d5hJebxneX0674imnpnjKzy+5y6nJ"
"izIVwFlHlQBmQwHMhgKYpRBADAggCgQQOYXuhk4EAQyCAuivkkA/RQHs6i2kf9JWeP8t7P07"
"U+LmThny/8z61nRmXSs6vb4llABUwCpWAY0QCijdcrQuujEraotR21HLawgC4FbcnPiLWKwo"
"gHAogAhWAB4lhOdmAmCvLiS+Kzy9WwGAPB/+DvPMj2MBHAvgvt/iWFghAC+FAMIXF8V1DgOK"
"yaGuxeSghcXkgHnFZIBf5hAgkKcDO9qIUWGBUABBDH4lISifmFnaeHx2WYC9nOGkYwUjx/ux"
"i6vT2ZW16PyaOpS4pr58zKX6C58pla6M71nsZP3K36z6Nq/VHP59cdry7zzU3MxsKAA/GNZX"
"Bb1I6EnZg55XoUy9fXn1vCslZUp9Dfh51PP1Cynr8h4rXZH/atKkiTRp0iRp8ODB0rBhwyQH"
"BwdpzJgxkrW1tcDLv1YBaAQwe/ZscWTZo1cD+tyAiAlwMSECfWjAsRUnV7iairMnWnjArMwz"
"CLRcQW283ezIgAs2OkEV9AQZ9FfVgaoQzEbgOM7aOv+shg0qe0/6sc+BnVvnJibGrrn/5tmR"
"99zkg4gtBKQQSMYXB+nN493yyztbDC9ubzSk3fI1pt3YYHx5e538+vZqent7Bb25tYxe31hC"
"rxAGvLziRS9SoABAAiIBeHae/DRhrvwkfq78+PQc+WHcbPlB3Ez5Qcx0+T6k/73In+kOCOCS"
"yPj3yyQAoQAQ+7P3B/g59lcIgOP/9iIEiPdtAxJoBQMBrGsOJdAM1hjWUBmfxdN0uYnmqjqi"
"0y533Y1aXlVM4YlcqhAAx//hiP8j4PnDRdwOCe9RRPHsbgxueHoGvFc+gBu2pIAcvqSgHL60"
"oByxtJAM4Mu4L45F5MilUAAggHAPNqgA12IUsggGBRA8vzgFzUfc71RKPj67lPEY7PgsGwNA"
"bwhwLCNzUVCcZyVK9K5CST7V6OyqmhTsUeX95hnl7zuPsUkc0LLggWqlv/IukNtilqQAnn9H"
"QfJWluYM+gFWlma9cIJ1lv7o6fUJPT3oq6nnk+btS6vnWzH1/CsoZZX6euBneH3pb2b4/8rl"
"H0sALHmYBDQi4NCAFYGLi4v0448/ZgkLcBFckA0RaMlCzq7y7EGWX3pVYEoGQhngrSNMMOPk"
"IbM85ww4gcgnAquDLiCD3iaEwMaeYzT+Prl8uaLOrVvWXjPjlwFHt62flhB+0u3Oo+tbXqW/"
"PEhkOEr0Hsd3+xAa7Kb3D3zpxY1V8tPLSwxPLnkaHie7Gx6e9zA+OudqfHp+YTrAL7MKSLvg"
"TGnn5lNq0jx6nuhITxMQCrAaOM0q4DfYVLoT/KMi/f0g/UX831e+sLuPfH57TzlpS1f57OYu"
"cuLGTnLCxg5y/KYO8mnfdjIUgHzGt7UMApDPrLPDsbl8en0zWFNcb4K/NZJPr2sox61pIMet"
"rSPHrq4lR6+oLoMA5CjvKnLksooAbAUcy8nhi21kyH85zKM4rJgc5lkUVkTI+jB4+XCvggB2"
"PpBGPoQTBaAoCiLEKAhCKQQysaYoeP5ItqUiByAHuRVND1hY1HhyXhGj//yiBn+nYoaT84ob"
"gpxLyeEuZSjOqxzFL2GrQGe9K1EMwpHj88u+Wj+51N15w4snDG+f72j9Sl+tLVEoh7OVhTQZ"
"v88Y9XcSv5mVhZD1ALx5H3NzEc+zlxeJPFgzjulVT88FO5q8/xjo9d6+iHq+FZAyk3t/Bvws"
"gGH84PwWnp6NccL2dwvs/lEEwOBmkPMqAHt+LRTg65wX0IiAlws5Izpx4kSpTp06XDMgiIDD"
"As4R4MhfsJYs5EIKLTzQq4Ki0sfJgGWcljOog8+iVwcaIfCKQjvIw845clj1AvD7KSGD6Fyk"
"J4UxeNyEkiUKOtWpVXZJzy4NtyycM+TUjnU/J4UcnnP35tllaW/ubEin55uJnnNHow1Ke/MH"
"a+j9jWX04qIbPU1aJD+Mn2e8H+douB8713AvarbhTuTvxlsR0423wn8z3on4Jf1O5JT0W8ET"
"ZAb+pb196RK8/+V9/SiFr+/qScnbu0MFdKWkTR1h7enspg6UiGPixrawNsLO+rZUdrxtwXEr"
"b3yxpbMbm1CibyNK3NCQEjbUo/j1tcXQzbiV1SjOpwqsEsWuqAgrBzCXpphlJSkKcXvU4mIA"
"dFEV1CzrBQHIoR750kNgwV75jSFeBVT71hDkXtgQ6GptCHQpbAxxhRJwx2MRRpzGc53h45IS"
"dGZpKRxtKNSlVPrB2cXTVv5Y7O58h8JJ47vkPWVX/cutlUrmWlI4n4UTToaJUibYxe/BoVwO"
"S7NBOSzN+wkPr5TksofXA15Ie84RSZmJPH1MX1X6OOiLSlm9vSbzv5Qyk3ua1P8o8P+nL589"
"AWixDGc3GfjTpk3LiP2zM/4fhwS//fabIAQmg7Fjx0pVq1Y142hAUr5YbYuxlizMThVwLJYd"
"GWhhAldmcSzHiRxNHdRS1YFGCOwdOPOrKQRu5tABPMQ5hAxSsLLKohQ4uciycwxOyglFCueZ"
"XaNKSY/mTSquGWNvt3fRrL5Bm7zHJB7d9tPNMyd+f3z7tPPr1Avu6cabS0mGpV9fTMarHvTh"
"iit9uLyI3l6cT2mJc+hp/Ay6GzZJFPyc39NXTtrZJz1xe09DwrYehvhN3Qzxvp0Nces7GmJX"
"tzNEr2ptiFrd2hi1spUxalVLY9RqOxzZWhhj1jY3xm5obozZ0BTXmxhjVjc0Rq+uj/vWM0au"
"rGWMWFHTGLasujF0aVVjqFdlWAUAuLwhxKsszMYQ5FbCELioGIBc1BDgwoC2Tg9yLSxzoi/M"
"oyBFeuWnaKiA00sKwApS3GIcF38Lb16Y4jysKdq9MAXO/zb98MxvX2/6ucDjJWMK3HQcnDdx"
"fOevg3o0yLW3dplca8oVtfIo8I3ZbPwWXHzzHWyk+r2K79jC3GyIAnaz/rDeFkoMz8M12qq/"
"E/9eGR7+I4DXvHwV9TyoIGXK++xAn1/K3ttnSe5J/yHga5fPlgCyqwRcvHixIAFWAgxsDgmy"
"M86M8n04L8D35wpCzpBOnTpV4sxpsWLFtC9YTwR6VfAxMtDCBC1nYCNlqoPsCIFPFE0hcMjA"
"S0B6lcAnG3uY9lAGXUAEPURyMYdVf5hGDDz7QCMHzjjzyczea9yXX1j9Wqp4fqdqlYp6NKpT"
"emXXNlW3TBze7LDzr51DVszrHbdt6eBLB9c43ArdMebh6YPjn108Pv7N+d39P1w+MIBuHB5E"
"908MojtHB9Ltg/3o1v5edHNvT7q+pxtd3d2FruzqTJd3dKSUHe0pZXtbStnahi5tbUUp21ri"
"th1d2t6MLm1pSpc2NaaLGxtS8oYGlOxbl85DAZyDAkhajfh6ZRU661OREldUoITl5SjBuzTk"
"eEnhteM8iwHQkPILC1GgU0E6Pjvfh/2/5X6zddLXz9aM+/qhp8PXtxYM+urSbz2/iBvfPldI"
"/yY5D9tWyrGlWimrlWWtLTys85o55bKUOBM/Tv0+RqrfTwaZWlqYIW4349FZAwD0Prjdw1zx"
"7CzlmYxZpbVQf4um6p4R3kCmSXotjv8U4Muo54EW02vy/mOg13v77GT+fwT42uWzJQDtoikA"
"zm5ylnPo0KHS8OHDRdbzz4zvN2LECMne3l5kS0ePHi3UAP+tRo0a6tswy04VaLkCUzLQwgQt"
"Z8ApV00d/BkhsETUVEIWUlBDB1YKnFzkE5JPTD5B22Vl5PYAAAcnSURBVHMIgaile84clr24"
"JgEGcrAclIPJQSlU0hMEy1mWtQyG0ZLi/cYjjp2a95ucM0oVzTOvXIncLlXL5POqXbHA8vpV"
"vl3Too61r33HUvv6ty7u92PfCid+s68cPGVQxaDfhlYKcR5b/cyicdUTFo2tkrDw+yqJzmMq"
"wSokOo+GjSmb6DyqTKLzyNKJC0baJM4fXgpWMnG+Q4nEecOKJTjZF0mYM8T6zMTu+UN+6JI3"
"aGK3vMEj235zomu9XH69G+Xc17BCDt8aNjnWVC1huby8tYVXyYLmLtZ5pHlf55BmWJlJU/l9"
"q+9/tPp5HNTPlwFwM0kAfKgGclhflu8MdN79KSlAbytlBTqTbxawmylg19blNbBrkv5TgNe8"
"vLWUGdNr8t4U9NnF9v9Rb5/d5T9GAEFBQeIFcuXKJY7weOLF9fb/8aJnX40IPkUGHLtxxtZU"
"HXyKEHjZh2PD7EihJj5+bXwHdT9CDHzSauSgqQaOTzty0tHKMoMgoB4s+zFJ5MhhORA2GOQx"
"BM+tkcRgScpyXSMN0StBNQ4/GHBcwsrgG/NftNGqjVJthO41hkkmYNa/J/wIg60sOAknjgNh"
"/XkEFqwPrLelhdRd9eQd1e9B8+Z26nfE35WtTsJrQNfL+E+BvaL6e/0Z4PVePrd6XnwK9P9f"
"vb3+omGOccgXDZefnQLQv2Et0/l3TZ8p5czpn9RJ/xkZ6HMGnMDRq4OPEQJLQy7y4NjQRspK"
"CppS4OQRn4BaglFRC0IxmGmKob6OHDi/kB1BaApCUxEMEG4u0Qmxbhd4x25WlubdYT2hDHrD"
"+qjWF9ZfZ5DN5gNVG5S9mWUxqz/aQNUz91etn+ql+2hgBrh7MaAtzKVuDGozpWS2g/q+2Xu3"
"lrKCu7n6Wflza568sVK8JXZ81jfLlO9avJ4d0CtLmZ7dFOyl1N+rmPRxwOu9/JdS1pj+swR9"
"dpf/mAIIDg4WL5A7d24BQGYcflG9aWz0GV1MycA0TDDNG2grCnxi6BUCS0Mu8uCEkCkpaEqB"
"k0e86+tTxKBXDVo4UVsNKeqakERD1fNpRKEnC40w2BhQDCw71VhhtNJZa9Xa/A1rrTtqAG6p"
"ew0NyJo1U99TU9UUUEsZ3jsT3FyPkRXgtaTMpbfqqlWTPg30sur3baN+/6ZgL6z+XgWkrB7+"
"Gykzc28az39K3n9WoGecaZhjHDIeGZd8adu27eepAD6Dy8fIwFQdZKcQtJBBrxI0UmDPwicc"
"J4+08EEjBm3VgT2TKTlo4YRGEHqSMCUK9oCsJmqbZdQxCKuns/qqNVCtoWqNdNb4b5j2GO15"
"tOfVXkcAWbW6Zgqg9aDWe24N3Npnq6r7zBrAK0p/BHkZKTMrrwFdk/FF1O+9kPRHsOeRskp6"
"Uw//MS//2YL+Y5f/dQXw4cMHcYyPj5fq1asnGKZ58+ZSy5YtxYvxkW+3adNGyps3r3gTn6ES"
"yO7yZ4RgGjLoVYJGCvrQgZNH2REDe6SPkYONlEkQ2ZGEnig0sjAlDFPS0KxGNlbzb1h2j9c/"
"vx7MpoDWQK0Hdnbg1gBuI30c5JpHNwV6PimrlDcFey5uOAPjLbfcfMZSNQvVzFXTX/6Q1/pc"
"jC9aQj1fvnwCb4y7Vq1aSc2aNRO4ZHxyebEet/9lAvgrZqoSmBD48g9UCWbSpwkhu7BBTwrZ"
"EYNeMejJgePQjxEEy9ji0h+JQk8W2RGGRhqaVZCyEsjHrJKUFagfM/3z6V9He21TQOtBbQrs"
"4lKmXM8O4AWl7EGul/B6oOsTdtnJ+U95+H/ECfrf8fKfsr915/T0dPGCenv79q1kMBiktLQ0"
"cR9mJP0b/QcRgOnF9CT5FClkFz7kkrJXDNmRgylBmJKEnig0stAThp40NOLQyEOzUv8N0z+P"
"9tz619PegwZoDdR6YJuC2xTg2YH8Dx5dygp0vYzPFuxcSs677kzsD7mrz91M4/zWrVsLvDHu"
"GH+MQw2Tmuf/HyeAf7kC+CuXT5HCp4jhU+SgEUR2JKEnClOyMCUMjTQ04tCsUDZW+C9Ydo/T"
"P6/2WvrX1wBtCmo9sLMDt6knzw7knwS6lL1n/9ecfJ+FAtBeSG+sCvjvzEB8bNGiRZY3+i8j"
"gOwu2Z10nyIGPTlkRxAaSWRHFKZkoScMPWloxKG3PP8NM30u/evoX197T6agNgW2HtzZAdwU"
"5H8F6OJE0843XirmC28zj42NlU6cOCFWsQICAkQy+59o/N75M/j7+4t8HOPNaDRmi8v/UwCf"
"x+WvkEN2BGFKEnqiMCULPWGYEofevvhvWHbPZ/qapu9J/35NP0t2n9f0O/koyD/5hZt4SgbO"
"/4Sn/Lfa/xHA/7/Lx07wj5HEp8jiU8SRnVn9Bfsrz/Nn7+Vjn+HPPvt//Us1IQD2/HxeZhcr"
"/5Pt78T5/0cA/+zLn4HlrxLH/4b93ff2v375PwXw9+z/AcBkyjWvAE8GAAAAAElFTkSuQmCC")
getIcon256Data = Icon256.GetData
getIcon256Image = Icon256.GetImage
getIcon256Bitmap = Icon256.GetBitmap
getIcon256Icon = Icon256.GetIcon
#----------------------------------------------------------------------
Icon512 = PyEmbeddedImage(
"iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAYAAAD0eNT6AAAgAElEQVR4nOy9B5RVRdb+fZzR"
"/5gVJOeclYwMWcWRnCQIgkhOklEQULLkKEHiS8bwSWgBHSV3N41EGVIThyYJtCQFYTnvvPXV"
"U1X7nDrnnnv7diDY1F5rr9tA970n0b9npyqLMWYZN27cuHHjxh8uv+8HYNy4cePGjRu/937f"
"D8C4cePGjRs3fu/9vh+AcePGjRs3bvze+919c2PGjN1LeyQM/0sYHs77GDNm7B6aEQDGjD28"
"lhDI/+rxRz3+WBLc+x7ez0hIOBgzZiyFzAgAY8ZSt4UDeC/Q/5/yvyl/XPMnlD+ZDKf30N+X"
"Pos+2ysYwhEIxowZS4QZAWDMWOqxYLDXQe8FvA52wPkp5U9zf4b7s8qfU/685mmS4PrP03vS"
"ZzyjPpeOgcSCLhJ0gRBMGBhRYMxYGGYEgDFjf17zA74f7An0OuR1wBPYAei03F/gno57eu4Z"
"lGfknkl5ZuVZfDyr5n7/Tj9L75VR+4z06nNfUMdBgoFEgi4QdHFAwiCYKDCCwJgxHzMCwJix"
"P48FA743svfCnkCvQ14HPEGdAJ6dew7uObnn4p6bex7ueZXnU57f4wV83Ps99LP0XnnU++dS"
"n5dDfT4JCBILukDQxQEJA68o8MsUGEFgzJhmRgAYM/ZgW7AIX6/XE/Apstdhj2haBz2gms2S"
"kAVwCe4E9ILcC3EvzL0o92LcX+T+Evfi3EsoL6m8lOalfVz/d/oZeo/i6n1fVJ9TVH1uIXUc"
"JBhIJORUx51NnYcuDF6w3KKAMgW6IKBrFixDYMzYQ2VGABgz9uBZQlE+Ut4U4evAp8jeC3tE"
"1QAoIm6CPAEe8CWwA9JluJfj/jL3v3OvwL0i90rcK3Ovwr0q92rKX0mE089UVe9TWb1vRfU5"
"f1efW04dRynLEQovWo5AIHGQV51XDitQFFCmQBcElCHwKxkYMWDsoTMjAIwZezAsIegjitVT"
"+qiLU4RPwKf0fS7LgT2i6SKWA3pE4AR5ABfwBYgBZUD6Ne6vc3+Dew3utbjX5l6Hez3u9bk3"
"UN5QeSPN39Rc/3v6XvrZ+ur96qj3r6U+7w31+a+p46mqjq+iOl4SByUtRxgUUedJoiCX5ZQR"
"SBBQhuA5y10y0LMDRgwYe6jMCABjxu6vJQb6FOUj5Y3mOUS8OvBRc0eEjHQ64IgIuiz38pYE"
"KKLuapaE6z8sCVzAt64loQxQN+beNFOmTG179+49omfPnqOWL1++dO3atasiIiJWw0+dOnUk"
"mJ88eerIiRMnjhwnP37iyLHjxwN85apVq+Gr16xZtXjx4qXduncf1aNnzxEZM2Zsi89Xx9FI"
"HVdddZw11HG/ps6jijqv8uo8S6nzLqauQwHLLQiyqOuW3nKyA4kRA8aMpSozAsCYsXtvwaJ9"
"Pb3vB32K8imlTxE+AR81d0TISKcjakYEXd1yQI+IG1E44NqsT58+I7hNAdx37twZdfr06SPX"
"r1+P/7//+z+WFP/vf/8b0v/3f//X5f/5z39s/+MP+B/sDvzOH+zy5fh4CIWo6OgoiIShw4ZN"
"4WJkBI5bHX9DdT4kDKqr862szr+cuh4kCChDQCUDyg74iQG9TGCyAsZSrRkBYMzYvTMd/MGi"
"fUrve6GPBjg0wyGqRcobzXNIg1MqH9EwAIgIuablwL5JxYoVe4wcOXIyoncd8sm1xIgD7/eH"
"+nk/0SBEwn+kSODaIB7ZhVWrVq0ePnz45PLly/fAeVqOKKiprsMr6rpQ6aCkum5F1HXMo66r"
"VwxQmSBUVsAIAWN/ejMCwJixu2/B0vx6tI9GNdSo0byGNDVF+l7oI6pFoxya56pZsl5OwEfK"
"vFnv3r1Hrlu3btWRI0f23Llz51ZKwtwvkk+sB8sQJDbToIuD3367eevAgYN71qyJWNWjZ8+R"
"lswUNLIcQfC6ul6V1PUrbQWKAcoMZFT3IY26L3pWwJQHjKUaMwLAmLG7Z8HS/BTtozNdj/Yx"
"845aNaX3deijzg14IapFoxya5xDxNm3WrNlAAD8uLu5IUsEeCFnd/8v+w0Er0/Qp5Fr6X/eE"
"xEK4wgDvhV6ENWvWrGrSpMlAS/YVNFTX7Q11HSup66qLASoTZFf3Q88K0CQBZQWMEDD2pzYj"
"AIwZS3lLCPxU20dnOkX7SEWjYQ21anS2o6GNIv1XLQf6jdCgN2vWrDm7du2Kogg/8VBPuGYP"
"6KMmf/vOnbvid6jm73GvWAgmEBISBroYuHnz5q2YmB1R06ZNm6MaDRtZjhh41XIyA6XU9S+k"
"7geVCDKq+0W9AkYIGPvTmxEAxoylnPnV+IOBHzVnzK7nspxoHzPv6GZHZ3s1S9axbejPnDlz"
"7uHDh/ckJnJPiqPOfvv2bfb777/fXcdn+HgooZAYYeDXU/AfJQgOHDiwZ+rUqXM9YuAf6rpX"
"VPehhOVkBXKp+5XJCk8ImB4BYw+8GQFgzFjyLVzwo65M4EeaGbVndKijOQ2paDSsoZsdM/EN"
"FPTnBIN+cmHv7cgH9G/duoVo+a47PieYhxIKiREGzvn91yUM/lfLDEDs7N9/YI+WGWigrn91"
"dT/Kq/tTTN2v3JYjBNJZRggY+xObEQDGjCXP9HS/3txHNX494qf6PlayQ5oZtWd0qFezZPSJ"
"effGqOljLI8D+ZY/8JMGeT/HyB2g+9tvv913D0coJCQM/ERBYK/B/wqXIsARAr/+9tutKG6N"
"GzdGz0BjdT8oK/B3db9eVPeP+gT0jAD1COjNgqYsYOyBNSMAjBlLmnmjfhrno65+NI1RjZ8i"
"fh38mFVHIxpm2OvzaL/NjBkz5l68eDEuqcAPBnkCnu63b99B53yKgdrP76ZASIoogBiQr37+"
"H/vrO/xnzp49GzdlyhSUCNpYctXCGup+VbAChUA2y+kReM5ypgZofNBkA4w9kGYEgDFjibdg"
"6X59nA/Lz6J5LJclU8cEftSX0XSG0bSGlSpV6o6FeCjaDxf4iYG9G/y3XeBPqbR9KL+bgiFB"
"UeAVA3f+sF+l3wnquFbXr1+/tXLlqlXly5fvbskpgprq/lW0HCFQQN3nrOq+6+ODwcoCxozd"
"dzMCwJix8M0v6qdZfqrz0zgfusfRPIYNbPSIX4Afi/MgzR8u9JMCey/4kwP15Db8JVcsJEUU"
"hBIELmFwm/y2y8X3/H7bPv5t27ZFvfzyy1h0iISAnhEoqu53TssZH6T+AH0NAZMNMPbAmBEA"
"xoyFZ95avzfqx6w40sCoC2N8DGvRU3NfNUumkG3wh5PeTyr03TX+O8kHe5Bu/UR7MoRCOKLg"
"11+lJ5QhsD/L9tvCCfi3fr+tHY9zTDfVcWzdulUXAjXU/aVmwcLq/mdXz0Nayz8bYHoDjN13"
"MwLAmLGEzS/lj6iOmvwQ7WGjmVyWrAtjURksPYsucjSRocbfdufOXZGJhX5igR8M/EmFe0rP"
"/idVJIQjCvyyAcEEQcD7uQSBBP9NDfrOZ9y033fLlq2RGTJkwORAfXWfq6j7/pJ6DnKp54Ky"
"AU9bTm+AKQkYu+9mBIAxY8EtWMofnd5+UT+l+1EfxhhZHTT3ocbPI8tbKQX+UF39aGJLzsx9"
"uIv1JNWTLBDCEAWhBIE3O+BXChFfYyLiptfd4Iff+PVXduPGr+zS5cu3vvjyy1Xp02dAs2Ad"
"dd+pP6Co5Z8N0CcFTEnA2H0zIwCMGfM3P/hTyh+d3pgBR603l+VE/VhJrpol68NvYgOea9eu"
"x99t6Otz/CFr3UkAfIou/6u68JMiEBISBMkRA7ooEF/jVfNff4N74X+DXYdfv8H4PWZxZ87E"
"Dxo8eDLuu7r/1dTzoGcDMqvnhiYFHreMCDB2H80IAGPGAi1YvV9P+aPjGxvIYKU4LB9LUX+9"
"ihUrdT906PCeuwl+/b3u+AAyXNiHA22/NfuT6kkRCMkVBAn2DYjXXwP/TfkNgj65Av/169cF"
"/K9eu8auXr3Grly9ymJiYvaULVsOEwP1LCcbUEo9J3nUc6OXBExfgLH7ZkYAGDPmtmD1fnRz"
"Y7yLUv7o+MYIGJaMrWqpqH/58uVLOYB80/3hgj/cnfSwoU64S+iGgn044E7uDoCUpUiKOEhI"
"EIQSA6EyA24h8GtQp3T/deEy8r+mIv+rcA7+K1ekx8dfYefOnb/12Wezl1pONqCqek5eVM8N"
"lQTSWM6UgOkLMHbPzQgAY8Yc84M/LeWL+i1WfcOYF+a+i1uy8xsz4aj1tz116vSR8JbdTVq0"
"r78XgS+x0E8O4JO6t0ByxEFiBUG4YsArBCgLANBLv+Hy63rKH5H/dXfkH3/lioD/5cvx6Atg"
"ly5dZrt27zmSLl16NAnWUc9JefXcFFDPUSb1XNFSwkYEGLunZgSAMWPSgsEfTVtY4Y3q/dgl"
"DuNeSO1ij/kGvXr1HhlO1J9c8Iuo3ycCTizwUwLwCe88mHyBEI4gCDszkIAQ0LMAItq/TsC/"
"7vJretr/GuB/zY784+PjpQDg8L946RL7+eJFFhd35lb79h1GWnKPgdfVc1NSPUe51HP1guU0"
"BxoRYOyemREAxowFwl/v9Cf4Y8lXzHiju7uyJee/30SHf0pH/cHeK9xIPxzoJwfuKeWJXwMh"
"aWIgXCGglwNcdX4b/NeEI+qnyF9G/1fZZYr+bfhz//kiO3/hZ3b+/AW2aNHiVZYsCdRQz09p"
"9TzltgJFwN8sIwKM3QMzAsDYw24JRf6Y40bzFka6yliynlsrc+bM7wZr9EtJ8MNFh38Sov1w"
"3j8UoO+WJVYUJCQGUkII3PRsiGSn/lXE7wv/KzL1L+DP/RIJAAX/Cwr+586dZ2fOnmPfrF27"
"59lnn33XkrsNVlXPU1H1fGWxTCbA2D22u8Lou/Gm9psbM5Zypo/6JQR/NHFV4167UqXK7/Ff"
"8HH3Av6U8g8X/Am9772GfbgWriBITFYgMULArxxgCwDU+z1R/xUO/itU94+Pl/C/HBj9n9ME"
"wKnTcSwi4pu4woULv4fnSD1PZa2ERYAZETR2V4wZAWDsIbZw4Y/V3bDue5233mo+INiiPima"
"8ud+JwH4Jxf8D7IlVgyEIwRCiYBbmgjAoj9OPwBlAZQAuOKGv133F/CXAuACon8IgPM/C/if"
"PXeOnTlzlp2OO8OOxB5l3373/a0qVaoOsGRz4Cvq+QpXBBgzlmLGjAAw9pCanvrXR/2o5u+F"
"f917Bn9V708u+P9s0Pez5AiBxGQDbmk9Ac6qf/4CQHb8x7ua/i5x8FPj3wUt+j+rov84JQCQ"
"Bdi1ew9bv/7bW5UrV4EIqGsFigDqCdBHBE0pwFiKGzMCwNhDaH4r/NGoHzX8YeEWpGcF/Js3"
"f7Dhn9rA72ehhEA42YBQIkAXAIFlACkCaN7fifwv2yN/qPtf1ODvEgBnzgn4n+bwP3nqNDt2"
"/ATbtGkzW7duHRcBlXURUFY9d9QYSCOCfisGGjOWbGNGABh7yMwP/liRDYuyYC47lyW7s9Gg"
"VY17HQf+CTepJQf+/7kL8E+NlpxsgJ8IsAWApxeAygB+AkCf95fwV41/P/8cMvo/efIUO3Hi"
"JNu1aw/7/vsfWMQ3a29VrFSJygHV1HNXWD2HmdRzSSsGGhFgLEWNGQFg7CEzve6PcSusyY5l"
"WTNwz2HJ+Wws3Yqd3Wq3aNGi/+3bdx/+SYn8Q9X5U7slJRsQTAToZYCb2AWQ9gDQ+gBoDNAl"
"ACj1r+Dv6vw/f94tAE6fEdH/CS4AjnMBEBt7TAiA9d9+x1avjrhVsWKl/pZsDKyinr9C6nnM"
"oJ7PpyxnPNAIAGMpYswIAGMPkXnr/tT0h7XZs1lyhbYS3Ctxr1m5cuX3HPiHFgDhpv5DwV8X"
"AMmJ/B8WSxERcOcPjwBQI4GqDHBDEwD2qn/6gj8XZd3fhv+FC/7R/ykn+kcJ4Oix4ywqKloI"
"gLVr17Ovv151K3+BApgOqKmevxLqecymnk+9KdBkAYyliDEjAIw9RIZfmN66P3X8Y9tW7Nz2"
"d+5vZM6cufXFixfjJFjubvQfasbfwD+0hSMCQjYGugTAbUcAaI2AtCKgWwDI9L+E/88a/M/L"
"zn8Ff/ipOHf0D/jHHj3G9uzdpwTAOrZmzTdswcLFcU899XRrPH/qOXxJPZc0GeDtBzACwFiy"
"jBkBYOwhsWCpf6r7U8f/a9wbHj58eI8DlZQRAH7vodeiQ0X/D3PNPyFLThbA2wegZwB+9RMA"
"qgQg6/963f+Clvo/x6P/s3b0f1LU/k8L+FP0j3HAw0di2fr1JAAi2MpVq9nkKVP34PlTzyFN"
"BuRSz6kpBRhLUWNGABh7SExv/MNoFaX+sTMb9mvH0qzVuNfDjn5uqNwdAfCHD/xN9J94C5YF"
"SFAA3PEXAL/dVAJAbQNsb/srBICcALCX/NXq/ue16P+M3vhH0f9xLgBU9C8EwOFYtnHTZvbN"
"N2vZai4Avl65in355desW/ce2EmwnnoeS6vnM7vllAKesNwNgcaMJcmYEQDGHgLzRv/oqsaI"
"lZ76xyYtNdH0FwiUxAuAhNL/+LO+m58RAEm3xPYC+AkApP+pCVBG/ze1jYFIAMhFgC6TALh4"
"0Tf1f0ak/s840f8pRP+nAqL/Q4ePsMioGPZNxFo0AgoB8MWXX7EVn3/BypYth6bAmuq51EsB"
"adXza7IAxpJtzAgAYw+BeRv/nrNkdzW2ZMXcNVKt1bm/eenSpbh7IQC82/kaAZA8S6wAAPxJ"
"AOhjgHr6/4Z3AuCqPgGgFv3R1vs/pzX+xXmjf632f+SIFAAHDx1m0dExWB6YrVq9hn399Ur2"
"xRdfseUrPmczZ86Ks+TmQdXV81lEPa8Z1PPrbQg0ZizRxowAMJbKTY/+9ca/rNzzW3JrVoxe"
"1V2/fv1KL0zuRgkAEKLGMyMAkm+JbwT8w1cAUP1fRP9iQyBZ/3etAqgaAC+q5j+97q+n/sWi"
"P9xPnHJq/7FH3dH/gYOH2M5du1X9fw376quV7PMvvmTLlq9gS5YsY71691lpyUWCqqjnNL96"
"bvWGQJMFMJZkY0YAGEvlRp3/FP2jkSqj5TT+lef+RuXKlbvduXPnlh9UUloA6OvQ+23xm9Qm"
"wIfVEtsE6IW/u/7vjv7d3f+e6P9nZ7MfAf+zMvIH/E+dPi3hf9JJ/SP6d+B/mO0/cJD9uHOX"
"Sv+vFvV/pP+XLVvOFi9ZyubMmXcrZ86c3Sw5FVDechoCM6rnWM8CGAFgLNHGjAAwlsrNW/un"
"6B8z1lhwpRr3+rt27YoMDpWUGwMU0T92oEukADAiwN8SX/93on+/+X8n+pdLADvNf1edTX8u"
"XrI7//3q/nrq/xhS/3r0f1im/hH9/7T/ANvx4062Sov+kf5funQZW7R4CZs/fyEbOGhwJJ5P"
"9ZyWUs8tZQG8vQDGjCXKmBEAxlKxUfqfOv+p9p/Lckf/73nhGSgAEr8QkJ8AuK3vRR9GGcCM"
"Aoa2pMJfj/69o383fGf/r8jUv9b5f+7cBXvkz7frn+AvGv+OCfgfOuRE//t+2s+iY3awla7o"
"f4WI/hcsXMzmzVvAZs+Zx7Jnz4EFgrxZAOoFoIkAUwYwlmhjRgAYS8Wmp/8xP02d/1T7r8q9"
"3s6duyL94JnSWQBACGvNewVASvcCPCwiICXg75f6v27vAHhdwF90/quV/yj1j9r/2bNa9E+p"
"fw7/kwr+MvV/wm78Q+r/oIC/jP737vuJbd6yVTX/yeh/CUX/CxayOXPns1mfzWHvv98fWYB6"
"6nmlXgCaCHjKMmUAY0k0ZgSAsVRsevMfzf1jfXVstoLO6n9UqlSpmw7Q4IBJ/nLAdzBupguA"
"BEoBRgT4W3LS/rd9Uv9u+AcZ+wuV+rfr/nLBnxMnFfyPn3DN/Oupf0T/WAlww8ZNPPqXo39L"
"faL/mTM/Y9Omz2TZsmVDL8A/1HNbWD3HeJ69zYDGjIVtzAgAY6nU9PQ/Nf9hNTXst465aqy3"
"XmfdunUrJTz8wZmSWQDabjalRcDDJASSB/+Emv4C4R+vwf/nhOBv1/1PaKn/o1rq/xDbv/+g"
"gv9PbNfuvWIRIFH7Xy6j/4WLZO1/ztx5IvqfPmMWmzptOmvXviMmAuqo5/Yl9RzT6oBPWqYM"
"YCwJxowAMJZKzS/9T81/WF0N+6834r/o4//XhkhoAZAcEQCA0zazyREB4WYDUpsQCAX+FIG/"
"74p/VzT4X7QX/HE3/cWFrvsj9X+IUv8H2U8/ydT/7j17xQTAV199zZav4NH/0uUi9b9gwSI2"
"d+589tnsuTL6nzaDTZ4yjY0YOToez6t6bktbTjOgKQMYS7IxIwCMpVLDL0J99p/S/1hQRTT/"
"vfXWW/3tCN0DzWDwCacU4CcCbt++YwuAhERAYhoDE8oG+AmBP4sY8Dvu8MDvjPoJ+N9OqOYf"
"Hvxl3T80/I8p+Hvr/gfsuv9+Dv99Yv5/67bIoI1/s2bNFqn/KVOns4kTp7Bx4yeyIkWKYnVA"
"agYsYgWWAYwAMJYoY0YAGEul5u3+D0j/b9y48TsJUzc474YIAOCxuxzcKwISagy8m0LgQRMD"
"4UA/1Iy/HvXro34JdfsHT/t74H/Wgf9pBf+TWuR/1AV/Vfc/4K7779y1h8Xs2Cl2Aly2/HMB"
"/4WLFsvU/xx36n/SpKls/IRJbOzY8ax9+w7fWe4yQG71XHunAYwZC8uYEQDGUqnp9f80lrv7"
"vxr3hmfPno37QwHVKwIImMHglFgRcBMbzCgBkKAISKYQCEcMPCiCINgxJHRdA8Hvifp9U/7a"
"nL8L/tecbn/fmn/C8NcX+/E2/Tl1/31s1+49YvY/KnqHmP131/1l1/8MAf8ZbPLkqWwC4D9u"
"Ahs9eizrP2AQlgduoJ5ffRogjeXuAzBmLCwLl7uJcSMAjN1v89b/sWhKNu6FuJfhXj1Tpkzv"
"CqByT6oISExPgNxbXrpXBCQ2GxBKCCRVDIQSBMkRCOG+Z7BjCgX9cMHvjvq1RX70OX8a9VPL"
"/Pp1++vL/MpxP6z05xn3C9r054Y/dgHUR/786v4TJk5m4zj8x4wZy0aOHM2GDRvB/vrXv7a2"
"5P4AeI4Lquf6BcvpAzCNgMbCNiMAjKVGIwGAVdJ86/9Dhw2beFuB1REBfwQVATr4whUBBDCA"
"CpAn8OsiIJgQCJYNCDcj4CcE/MRAKEGQWGGQHNAHA34w6Hs39PGC313r94/63ev7u5f4Pe9d"
"4pdH/rTBj1jmF5F/kHG/hOC/NTKKrVy1WsHf0/Q3XcJ/IuA/fiKH/zg2chTgP5J9PGQYK1Wq"
"9AgreB/A3yzTB2AsEWYEgLHUaCQAaP6fVv8rxr0C91qrVq1aeevW7zZQ7wgnEfAfV2NgckUA"
"LQBEkE9ICOjZgHBLAwmJgcQIgnCFQXI81Of6Had+Hjr0Jfj9d/QLXNdfW9pXX9tfq/eLFf58"
"4G9v8HOK1vjXI//AZX4l/A/4wn/jpi3+Hf/TZ/rDf/hINoTDf9Dgj1njxk0xDlhLPcfFLGdV"
"wGct0whoLJFmBICx1Gj6BIBfA2DdyMioSAlYgPW2WKLXKwJkNiB8ERBMCPyh1v8noOsiINyM"
"QGKyAl4xkBhBEI4wSCkP9fl+xxsIfkA/OPh/pdl+bUtfp9EvcGMfubOfF/767n4U+Z/yTfvb"
"8Me4335/+G/aslXs/Bcu/Icr+A/+aAgbMHAwa9nyHawK6F0PIKN6zmlBICMAjIVlRgAYS41G"
"AgCd0bQAUF7uJSy5tWr9w0eOHBGQVSLglhIBtzURoJcEgmUDgouA/3MLAG0PAL9sQGKEQHLF"
"QDBBEI4wSGkPdgyu4/XU9r3RflDwXw8FfnfUT9v6Bt3cJwD+Tre/F/4i7b/H6faPjIphW7dx"
"+G/eyr797ge2cOHiMNL+Y1zwH8jh/8EHA1j7Dp2OWHJzoCrqec5rOQsCPWEZAWAsEWYEgLHU"
"aPgFqK8AmJl7PsuZAGhw8uSpuN9+U4C1wapKAj7ZgIC0uKcpLpQQgABw1ak1IRBORiA5YsBP"
"EAQTBeGIg5T2YMfgrev7NfaJyQp17Rzw3wgf/KLRLwz4e+b8Q8FfzvljkZ/dHP4/Cvhv2RrJ"
"4b+F/bBhI1ux4guxyh/gP2PmrKDwH+YD/779PmAdO3b2TgLkU8+3viKgEQDGwjIjAIylRgs2"
"AojtVLGSWkNEiOgIBzh+E2C9FSQbELo34L9hlAVoJcAAsPkIAW+PQKisQIJiIIggCCYKEhIG"
"d8P9jsEb5buhf9OG/m9atH9Dn+d3gT/eAb/ayc+O+tV8vwD/uXOJgv/hI7HC9fX9scKfSPnv"
"3MWiY35k2yKjOfy3iY7/73/YyCIi1tpz/vaon6vb313zHzx4CBswwIF/7959WY8evfBLsKF6"
"jktZZhTQWDLMCABjqdESEgCNAAvUhgEPCVmCqpYNcPUG6JMCoZsE8aILAKp361FvQITrIwQS"
"EgNJEgQhREEoYXDX/LY/8G9RqcRXGP3qRPuu+r4z0ucC/0VZ56eo34H/eRf8qd5/ivtJHf7H"
"Ofw5+I9y8MfGSviLFf4OOdv60up+MVTv3xYldvrbsHEz++77DWz9t9+Ljn+s8Dd9xky5yI9n"
"zn+EGvX7+OOhHP4fc/gPYu8L+L/Pein4d+3aA78EaUlgIwCMJcuMADCWGi1BAYBIUYiA6zfE"
"UrDhC4E/XELgP0GEgFcAeJeq1dPfXiGQkBgIp0wQTBAEFQVhiIOUdgn53wOOz1/8aNC/ft0Z"
"5dOjfbWQD4EfDX4O/CX4Cf7nNPif0eFvL/BzWkT9x70L/Cj4e6P+H1XUHxkVraX8N4ma/7p1"
"34oV/6jZD8v7Tpo0hY2fMFHAfxTgP2IUGzpUwn+QDf/+rG9fDv9efVh3Af/urFPnLkYAGEsx"
"MwLAWGq0BAXAlasSHteuO0LALgvoQsCnPyCwUVAJgSDrB3hH33xH24JkBXQxEG7zYEKiIJgw"
"CEsgJMNv/R4c9oHn5AA/OPTlKJ8zzucD/otOyl9v9jvL4X/mnLvTP2S9X8FfRP37tVq/HfXH"
"+Eb936xbz776epUr5e/U+8ezUWj2E/AfzpxDSqQAACAASURBVD7i8B846CPWv/8g1u/9/qxP"
"336sp4J/ly4c/p26sPbtOxoBYCzFzAgAY6nR9CZA/GJEk5RrGWD+yz4eALkqhMB1fyHwmzcj"
"ICFmC4HbgT0C3qkBfP2H3UT4X/H37mWC/2MLiT8S6HwPNzsQjgcTBgmJg8T6Tc9xOsd7MzC6"
"DwJ8Su/b0FdNfZTmp1l+Hf6utP8F2ex3Toe/GvM7Dfif5vA/FSeW9Q1W7z946IjT4a/W89/x"
"I6L+HVqt34n6167/lkV8s06M/KHhT0T9k6eIlP84lfIXq/t5m/36D5Tw7wP492bduvfk8O/G"
"Oir4t2jRErsCNrTcywFnttwCwDQBGgvLjAAwlhrNOwaIX5A0BliVe/29+/YdERC5IqHiJwSu"
"u4TAb7YQoGZBlAZ+9xEC9igdhzxgrpcQ8G+B8/DuLWy9G9r4NcgllCFIiigIVyCE8lDvSaAP"
"Gt0HAJ/W6HdS/OHBn+r9F2WX/wU53+9E/efc8/1qTf8TIuWPer8z339IgP+QWtTH3eTnpPu3"
"CvAj6l/37Xfsm7Xr2eqItQL+c+ctsKP+8Yj6xyLqR8rfW+8frOr9qtmvJ4d/t56sc+eurEPH"
"zqxduw6sdZt2rEGDRjQGWNVyxgBpCsCMARpLlBkBYCw1WqiFgCpzrxsVFb0H4EDNWBcCV4IK"
"gV/tVLsNvFtaVsDTMEhiAIJB/Jz4fvo+p6lQHzF0CQFvZiBMMeAnCrzCILni4FetKdELdTfg"
"HcjTeJ7063bHvnQ39BHpi2hf1fbJXfAXAuCyDf+LWtr/gg7/8xr8qcs/LniXvxPxHw4AP+r8"
"NNpHc/0i3f8Dpfu/ZWs4+FetjhBpf2zyg1q/0+inzferlP8gkfJXUb+r3t+DdQL8O3QS8H+n"
"dVssAsRq1qqzB8+veo5pISDaEdAsBGQsUWYEgLHUaH5LAWPr1Be5V+Ree/ny5SsvXlKRYzAh"
"cPWaBJQtBEKVBwJLBIA8jaUBeICgPXaI71ffq4sBIQJ8trhNKDMQbKGcW2HU3kOJgl+1GfvQ"
"oHfD3gV+Lcr3i/ZDC4CrLvjbTX4K/hdpvI/D3w1+z5K+Z9y1foK/AD8i/lgd/Fqqn8AfEwh+"
"jPatR7of4P9mnQD/1ytXsy+++potWbpcjvdRrX/0GDZi5Cg2VET9PiN+ffrJqF+k/J16f9u2"
"7Vmrd9qwtzn832r+NqtQsRKWAq6tnuMX1XNtlgI2liQzAsBYajS/zYByci9qyU1UagwcOGii"
"mAkXKWNNCFxWQiD+qhQDBCW7YfCG0yegJgeCigH+iqgU7433pVLDNRpBBEBRC7/pNN/d1gTB"
"H74r5+li4I7LkVkgD+y4Dy4KboZRqw9M5/uLAr2OHyACPELg2nUnA3DVIwCu6PV+0d2v4B/v"
"NPsB/j9f9M72a+DX0v36bP8JbTU/keYXXf2H2U9o7sNIn13j36lS/Qr8aPDbROD/XoAfdf7V"
"a74R4P/yq5Xs8y++YosWLxXwHzt2vDPep2r9H6HWr6L+999XXf69+8qov1sP1rlzN1fKv1Wr"
"1qzF263YW2+1YE2aNGMFChSciOdXPcdF1XNtNgMyliQzAsBYajR9O+CnLbldanZLbgdclnv1"
"smXLdjuvOsMlQKQQuKgJgcuqw9xdHpBZgeteMeCa05fwxPcj9QwgYf4c6emLlxyRgfe8pmUH"
"pCAIzBDIkoHTX/CHPUEQjhjwjN/9Lt1PENzUxYBaac9ebc9egOdmYHbAVRZQIkBbh9/ltEqf"
"8qu0cM+1a+J6XaG6/1UpwGTU7+7yv+id7dcX9VHwp3S/nupHtO9u7FNpfjXOt3v3XjHLv2OH"
"nOWXzX2RWqrfE/ED/Ksc8C9b8QVbvGQZmzhpipbudzr8abxPX9inpzfq79BJRP2U8m/eoiVr"
"1qw5NgFiDRo2Yk888WQ3S24HXFY9z9nV8/20et6NADAWthkBYCy1Go0CYp9039UAjxyJjQcw"
"kC4WY2K2ELjEqDxAjWbxLjFwzUcMaBMENyQMASLsGw8IIQoFlNCFDlhJQeBkB0gQ2JkGXRD8"
"5nTn/x7Qb+A3QaAJgTt31MSC4yQCHDGgZwWke0WAFAJuMUDb7OoOIXRDEwHXPSLgmi4ArikB"
"4Gn4S1St36fOH2dDX9X2begfFd38coafRvn2sV082v/xR5nmF+N8kVFsM7r61Sy/M9Kng3+N"
"C/xLlq5gCxYtEfX+kTTah3T/kKFs8Ecfi418PviAOvzft8f7ZNSvGv3ad2RtEPUj5Y+ov/nb"
"rGnTt1ijRk1Y/fqNWI0atWgCwG8E8CnLjAAaS6QZAWAstRoJAH1DIDRMFbdUI+D69d9uO3tW"
"joWdOycjyPOaEKDygCsroJUIrgTNDMi0NqCDiBPpZnSYIwoFmKQgkKvPOYLgoi0ILl2W4EPt"
"G+nwa1r5gcDqLGF80y45/O4aUdSXMtZX3vOKAW1G32dhHl0A2GUBOxNw0xP9S7/haQDUm/+o"
"8e+qK+3vXEvfWr8Ofi3ip/q+XdvXVu4T6X1thI8W7tm3b7+9S59cr1+L9rdFOmn+DRvlIj7r"
"ZVc/NfdRqn8FwL9cgh8p/3nzF4lGP4BfdPfbo31Okx+l+6nDXx/vk1F/m4Cov2HDxqxevQas"
"dp267OWXK2yznAbA4pbTAEgTAEYAGEuUGQFgLLUafhHSJAA1AlIfwN+51/igf/+JFJkDJCQE"
"ZFYghBjQMgOXXWLAyQwASIAO4HPocCw7HHvUFgTHfQWBOg5VMrA/G2WDi+7+BNlLoAkDFV1L"
"ceD0JJBAoGieonsd+DIL4J0gcAuBgHLAb9ocv2ciQIf/9TDg72r086b69U17tNR+nGd2X+/g"
"17fmRXpfrtanIv3dex3ox+ywa/ubtzgz/BTt0xw/6vsY50NX/xdfcvB//qVY1Q9Nfgs5+Bdg"
"Z795C9l4Hvkj4rdn+tWCPmK0r6822od0P1b06+R0+FOt/22q9dtRf0NWp259VqtWHfbGGzVZ"
"9uw5qP7/d8up/+sNgI9aRgAYS4QZAWAstZpfH0A27gW5l+H+Gvc3jx07ccsGMHchBLSsgITx"
"BVeJwJsZuOQSA7JMgBTznn0/iW5yQAgwQqMZCYIjmiAAvAAxRK8JiwLVs+AtU8Q74uDK1auu"
"xkV9iuH6Db1rX2/gc6fyAxv+vFMBXuD/qkX71wOBD9i70vtXRGrfqedfco/uabCPCzGy56zQ"
"56T2cc1FTV9tySvH9yT0t+nQx/z+RtnUFzTa5+D//Muv2XIO/qXLPmeLAf5FS8S6/pjxnz1n"
"Hhs7doIT8evgF3X+fnadH0v56nP9erq/eYu3WVOq9TdoZEf9NWrWZq+/XoNVq/bqLTyv6rkt"
"o57jbJap/xtLhhkBYCy1Gn4R6ksC6wsC2WWAiIi12+RY2BkRVZ6OO6vAG0wM6P0CNEXgwBhi"
"AGDCKnGINgEgRJ7oLN/rEgQHVYbgsOhCR306IVEgjtElDM4JUOoihTriaTW8S7ZIoAyC088g"
"5+uv2qIh0K95XB/No5S9nrbXU/fx9mcT4H8OmM+X19ZvTC/UFryHDuu78B0Us/oC+HtVlI9G"
"vh/VYj3RMSq9r0X6Gzc50MfCPZ7avhPtq/r+shVs0ZJlosaPVP+cuQvYZ7PnsRkzPxNr+Dup"
"/kGqs5/A34d1797LBX6k+9v4pPvR4S/S/Yj669RjNWvVFlH/a6+9zl555TVWokQpb/pfXwBI"
"XwLYCABjYZsRAMZSs4UqA2CM6o06der2P3FSbv5y8pScDz8dIAbO+YsBV5lAigH8GallQAev"
"qC8j+ozhQNqhCwIenWKBGaSnATCATGYJdFHgyRR4hIG/ODhjCxgSCfKYz8vjVcdsCxnXJASd"
"x0XXOvoBf/+z2lxH211P78R3tth1RvEI8HIRHnmdT9EKfEHX3ifYy+geokmk9MWM/k8qrb/H"
"AT7V8ynKpw5+Su/rkb6CvpPid7r5l3Poi2h/iUzzz0eaf/5CNnvufLGs78xZs8W6/ljMh2r8"
"LvD36u0Lfr27vwXAr0b7qMmvLtL9teug2Y9Vr/4Ge/XV6qxqtVdY5cpV2DPPPNMfz6vlHv8z"
"6X9jyTIjAIylZtPXA6AyQFbuBSzZRV2Ne4OtW7cdEVA9ARj5iAGAlcTAGU0MnJVg1RsIASKM"
"jG3ctJVt4hEnIIToUxcEiEwhCuwswe5gokBmCpzygSMM7IxB7DEOzONKIJyQAuH4SQ7UU7ZI"
"cITCaXsRHED4tFoRT56fcgJ1KFffa//8aWdxHVGXB9hVBI9repyW2OXHhmMkyHt32KOofj8i"
"eyzGEwD7vXI+H3V8FeFL4EcL4IuRvS1bVZQvG/mcmr5K76tIPxD6X7Klqra/aDGP9hdq0f6c"
"eWzWZ3NExI/d/CZNnibm+e2u/r7v2yN93T2pfhf4MdPPwa/X+ZHur4t0f20n3f/qa9WR8mdV"
"qlRjFStWRvSP5X8bqOe1lHp+s1pO+t/M/xtLkhkBYCw1GwkAvQyQ0XJWBazAvWbrNm1GuOFJ"
"YuCUIwZO6WUCp2dAzw5g3fh167/nwPmBfcvBg4jzex55SkGwRUSjSEMDVAAWwBVUFHDQCWGw"
"RxcGbnHw0wEna6ALBNF0eET6Ea20IP24LRjcLs9f+knlJ3z9qPDA99ChThG8hDsBnkfyBPkD"
"DuRlCj8Q9LgOuB64LtE7JOwpu6JH+Li2tDKfAL4W5YtGPqrpU3pfg/4yHfp2bZ9H+3Pmc+jP"
"5dCfzaarnfwAfnT6I+pHfR/jfL16OV39crveIOB/u6Uz1ueq89djNQF+le6v9sprrErVV1il"
"SlVY+fIVWdmyL7Nnn31uBJ5T9bzS6n8ZLXf63wgAY4k2IwCMpWajPgAqA2C1tHSW0wxY2lJr"
"AnCQHPGPpL1i4LQSA+7sAIAX8Y3cBAZRZgSPNteu+84RBN9xQfA9FwQ/bGI/bNjMgbXFXxRw"
"uG1TogBNa25hoPcVOFkDEggkEtBnAKhSaUEKBSkWdMEAGB8M6kc0P6y9KsfPHzys3uuQ/d7i"
"8/bLVD0dA+CO4xKA37tPbKMrIM/PAQvvBIAeHfoU2VP93gN7pPRFHV8A/3sH+NTEp6J8ObaH"
"mv7XoqZvp/cF9JfKur4O/dkc+rMc6E+eMp1NnDSVjZ8wWWzi069ff5Xml3P83br1EON8WMTH"
"nuW3a/wE/hYB4Jd1/jquOr8Af+UqrEKFSqxcufKsdOmyrHChIoj+afa/tOU0/6VTz7Oe/jcC"
"wFiizAgAY6nd9GkAygJgdlrPAtSoVat2fxktH3Ol1Z3IWIoBV6lApbrxb4A/GsfQNf4Vh87X"
"qyJ41PkNW72GC4KIdeLfv1n7bQhRIDMFqFejO90rDLA4DZURAEdHIOxUAkGKhB1KJKAubmcR"
"lFiQvs8WDVI4kP/k7/v8/n6fAjn5XpGpoM8Qn7tL1uZtuGuAp9R9pKrXU0SPcxWgVx36G1Qq"
"367fU3TvSek7wI8Q1/7LrxXw9Sh/2QqxSp8c3VPpfdHFLyP9mQL6n3HozxTQnzR5qrOWv+ry"
"19frpzR/R1q9j8b53tGa+yjV37iJO+JX4K9enYP/1ddY1aqo81cV4H/55QqsDAd/yZKl2EvF"
"irPHHnsMtf8aljv6p9n/Jy3T/W8sGWYEgLHUbvo0gDcLgFoqoqpq3OsvWrT4u8OH3anzIyQG"
"jiox4BEESHl/tXKNWBAGkSW6xpfzSHPFF1+zzyEIePSJWvPX/HtWro4QoPITBQAawAbAOcJg"
"o4AfIEhlBF0ciP4C1WMgRUK0nUGIJFdiAdAVvsNx0ZzodQVq6bv8v0eAfKf9nlExMmonqNNn"
"63CXgFeQ58dOkLcj+o2bRbmE0vho1kPtHpE9lt4F7CN02NspfRnhf+4Cvuzct6P8hUjty0Y+"
"d02fIn0v9CcJ6I8aPY6NGDmG9R842F61T0b7zsp9SPO3btNWjfNp4G/i1PidiL+2L/hR5wf4"
"y5Ypx8FfmhV/qQQrWqQYy5Y123eW3Pq3mnpOC1iB0b/p/jeWZDMCwNjDYPgF6c0CoIaay3Im"
"Av6RJk3ad/fu23/rkJjVPyIWlJGC4CizswNHnewAatuAPaLJ+RwyCxYt5RHmMrZoyXIOnxUc"
"Qp8LGAFKK5Qo+MIrCkSmQAmDCF0YrBcpbZkx+E7AkMSB6C9QAgHQtLMHJBKEUCCxIGG7mZxE"
"gyYevL5V8y3a6xYVpZNvFu68NxrwNimBIsAu4O5E8Q7gnWheQP5bJ4UvQS8je1m7V7Bf6cAe"
"1xA1fLEoD1L6oo6/QnTtU1ofwKcmPkrtz5xFjXyz2JSpTnrfC31ayhdd/oj6xTr9iPY7OtE+"
"ZvhFmp8262n+tly9D+N8ahEfdPVjlt+u8VeXqf4A8Jctx0qVKsOKFy/JihV9iRUuVJjlz1cA"
"c//v4rm0nM7/XJa79k/Rv+n+N5YkMwLA2MNgflkAmgjAeuolLDlfXbtHj16TqKFOLNpjiwEl"
"CFQHPuremA2fwaEya/Y8HlXOZ7M5bObMW8gjzUVsHgeQLgoApyVKFCxVokBmCr4S0Ssa00gY"
"IKOA6FZkDFQZwREHsr8AmQMSCCJ7QBmEb6m8QJkE5T+opsQfHOFA/kOYbv/MD5vs9/lOAV36"
"BgfsKlWPcgeOb60NeFWnF9G8hDxG8SCCRM0eUT3V7dGsR5G9Dns7ul/GFi6iCH+RjPDnacD3"
"RvlTp4tGPmzWg5r+2HFI74+3I31n/f7hYu1+pPopxd+uHdX2ebTfSm7Pq6f55WY9ao4f4Ne6"
"+qnGHwj+l13gL1KoCCtYoCDLmycfe/KJJydZctvfyur5zG85nf8m+jeWImYEgLGHwUgA6FmA"
"5yw5R52De2FLrq72KvcGHCbfHUCznBq/oxX8SBBg1zg0jU3mUeQUDpapPKKcNuMzNp3DBoJg"
"5mdzwxIFTqZAlg8gDJbpwkCUERxx8KUQBzJzIATCqghbJFBpQQBViQXRjPiNzChI0aCEgxIP"
"UkAoEaG7Arb9tf1v39ou30e+LzlBfY06BhzPKgF3GcXrgEc3/pdfO5DHucomPQf0S/l1cSJ7"
"N+znEezFbP48Vcd3InwAH1H+pCnT3FH+uAls9JjxPMofK6A/bDiP9BX0B388lA0c/DHr0+8D"
"1oFH+wT91q3b2rV9McbXXK3aR9G+t7GvRi1nnE8Df4WKlVzgL0HgLyzBny9vPpY7R26WLk1a"
"pP4bqOexjHo+c6jn9TkrMPo3AsBYkswIAGMPi+kTAZibpl0CsZoaGquKWXYpIE3rzZu3xu3f"
"73TPH1Dd86hzT+RRJGCCKHL8xClsAgcMIstJU6YnUhT4CYOlAna+4oAEgp9I+HKlgOkXEAoi"
"k6B8JYkGRziQCwFBvjoMFz+zxga5eD/lInOhoC7ECo7ly5UqXS+jeAH4z7/0QF6l7xHRL1km"
"UvgO6GUan2r3AvZzdNjLxj2R0kfHvh3hO8Afq4DvRPmjeZQ/kg0ZOoJ99DEt3/sx6z9gMPug"
"/0BR5w+AvpbiF7V9Ldqvq0X7sr4vF/ChOX6M81FzH2r8rohfA3+enLlZjqzZWcYMGeP4M9ja"
"clL/xdTzmdlydv37m2U6/42lgBkBYOxhMsoC0C6BfqWAStxrFi9e4r1du/bcEvP2EALcV/NI"
"diQHySgOlNFjJwgfM24iGwvQcB+nCQKIhNCiYLZIUc/yCIOg4kATCJQ9kCLBKxQok0BOgkGJ"
"Bt2/cFwICQK15+9df0cQJ1/hAB0CZelyDewqVY8I3o7i9Uh+4WIb8ojokVWhmr2I6kUaf64Q"
"UNMR2SOVP32mPZ7nwF6l9NGxrwN/lAL+cAl8uV7/UDZoMLbn/YhDH2v2y8V8sEtfWx7xB0Df"
"7uSX0Je1fa2bX0X7TprfA/5y5VkZgB/NfcVLuFL9FPED/FkyZWYZ02dA3f89S878V7L8U/+0"
"65+p/RtLthkBYOxhMj0L4FcKwIw1Vlqrwr3O66+/MQDbx2KkDZEm0sXDOFCGjxwtoskRo8ZK"
"QZCQKOA+QRcGJApcwsCbMdCyBgECQYkE7gKeC0gouMWCEAyaaBDCQYgHR0DYQsLH3d+jfm6x"
"4wRzcjTfucAuUvXSBdxx3CqS1yEfENEL0DtRvR/sMZ6H6J5q+JTS1yN8AfyPAfwhbAA26RFR"
"/iAO/AEizd+7z/usJwd/5y7d1Cp9WqSv6vpYn7++Wq0PKf5avtG+u76PBXxojh/jfNTVj+a+"
"AvkLsLx58grwZ8+aTYA/U/oMLH2atPjlNgDPnXr+Sqnn0S/1b6J/YyliRgAYe9gsWCmApgKo"
"HwALr9Tr3bvPbABl8MfD2EdDhotaMeCCv0NkCVEwXIiCMf6iQAmDMSQMlDggYRA0Y6DEgS4Q"
"ppNAUCKBSgskFHSxQD6bSg7kSjzoPlf3+Z5X9bX8uQU2xOcoMUIwF0Cfoz5fB/tn8jgF3HkU"
"LwGv1elVrd6GfADoJ6lmPSey12Fv1/CHDlcpfT3CH6wifOzM118Av5e9iE9vke7H7D6W5m2q"
"NuSxI30N+kjxyxE+RPtvONG+X5q/7MusNOr7JUqKOf6iRYqyQgULoauf5c0N8Oe0wc8jftT7"
"WZpnn2N/sR6ZjedNPXdU98+lnkuT+jd2V8wIAGMPm+kNgfpUQFrL6QfAyFU5SzZh1X+t+uuz"
"ARNABfViRJQAjS0KhgaKAsoUDFeigIQBlRBcGQOvONDLCZpAcIsEKRTs8gIJBXIFWhINXicB"
"kaCT4FDuep8ZHqCTq+OZooSMgLsWxbsAr0N+3AQ36Ee7Qe9E9jrs1Ra8A3l0j5R+fwI+j/D7"
"uoEvFvDh0EfEjxl+pPcbq814RE0/APpOir86h75e2/dG+3LxHjnDr9f38+fNz/LkzsNyZs/B"
"smXJyjJnzMQypkvP0j2fhj3/zLPsmSefwi81wL++et7KqeeP6v5pLXfXv2n8M5ZiZgSAsYfR"
"vFMBej9AFktutYpV19CEhf3XG/CIb3Y/Hk0iokQa2REEQUSBEAYjRHQaIAxUxsAlDjyZAz17"
"QGUFcr28QEKBHGKBfKKeWRDCQYoH8smaT/J8HdTVe02cPFW483lThI9XYCe407HaUbwC/Ogx"
"49zRPDry/UAv0vjD2CDVrDeAYN9fhz025PlARfh9WQ8N+F0E8GmNfjnS93bLVqJ7v0HDRrKR"
"Lwzo2yn+SpXt2j419TnRfjFWuKBM8+fLk4/lRmNftuwsa+YsLHOGjCxD2nQsLQf/cwr8Tz/+"
"BMG/gXrOyqvnLq96DvW6v+n6N5biZgSAsYfV/PoBsLUqVllD05UuAqpzb1C12iuzARnABtAB"
"fPxEgZ4pALgcYUAZgxECcAHiwCUQNJFApQVNKOjuEgyaaAgQDn6uAdr+mv6s3PuzYyhrYcN8"
"vB21j6LjUsJmhDp+EcVjzh6AR1OeN5oXkFcRPaXwVVSP7nxq1nPDvp+EPZbnxUp9AH5XAn43"
"sXBPhw5qxb52HUSDH1L81L3vqul7oa+N7wWk+EuXYSVLlFLRfjHfaD97FifNn16l+Z97+hn2"
"zBNPCvB74F/dcuCfTz1/6dTzaOr+xu6aGQFg7GG1R6zAfgBqCkxvySVX8cv4JUvLBFSuUnV2"
"9559OHj6sp4cQL04iEgU9OFw6gtRwB3Aer//IF9h4CsO9MyBn0hQQsEtFqQPJ9FgCwe3gPDz"
"EQm69vP6+wuQS5jTcYjjEseojlmBXYe7OE87ZY9I3qnTU3OegPwHPKL3gr5PP9Gsh2uOay+j"
"eyzNGwz4arU+LNyj1udHU1+duk6UT418VNO30/s+0C8noO809MkUv6ztF8hHTX2ytu9E+06a"
"/1lE+xr4g8D/JfW8ZVPPHzX9eev+RgAYSzEzAsDYw2zefgBqCgwlAuoVKlxkZMfOXW8BQAAR"
"gCRFQR/Wk0OqFwkDiAISBj4ZAxIHfgJhIASCcoKnWyxIweAVDboPSaS7fl57X/qcj9Rnu4Cu"
"oE6ROx0/nY8L8DbktdQ9gR71ertJT6XxQ8G+E6X0nQhfBz66+rE2f9OmzUWk74ryqwP61UUj"
"n7em7470FfSLe6CvUvx5VIrfru17o32V5tf9qb89jlE/rPJX33LS/n7wp6Y/U/c3dtfMCABj"
"D7uFKwKQnn3Zko1adbNlyz6gdet28QARgAQwAVAAFVLRSEl7hQFlDPzEAWUO+ilAUvZAFwm6"
"UNDdFg26awIiXB+oonOvB37mYNcx2XDHiJ0H8AT53gLyHziQDwZ6VbcPDnu5LC/tvveOWrDn"
"7ZZyTf7m2kp9qO2//gYBX27AQ/V86t6nRj6q6aOD30nv+0OfGvrsET7U9p973qnte6J98if/"
"9ni8JUf96qrn6GXLSfsb+Bu752YEgDFjCYsA6gnAqmzo0q5myXXa2zRp+tYRwAhRKBrMsEsc"
"1o/3CgNAjTIGjjjozXp4BYJHJOhCwRYLSjD01QSD7lR+SJL7vB+cPk+HuhO9a3D3ATzOEecq"
"IM/P3Y7o0aCHbXU10Is0Pr+GYv19LbLXYU/RPeb2mzeX6/E31Wb3Ud/Hjnt6A59flI/Ufpky"
"ZVmpUqXtRj6q6RP0kd4X0M/mhj419AVL8Xv9iUcfO4LnRT031dRzVEw9V1ktA39j98GMADBm"
"TFooEUCNgXksOaKFOW0s1oJ92t/kgFkFMAFQSEG35sACuHRhgOgVUSzEQSdNHPgKBI9I0IWC"
"LRaEYJCiQc8spKgTyHvLGjx9Lh2HDnYX3MW4nTuSd0G+Uxc7otdBL6J6lcbHtWzZSkb2Ouzf"
"euttB/ZqhM9erIeDH5F+UOCrVfm8UT5m9bFIj2jky5ffXqiH0vtZMmYKhP5TTycIffK/Wo+s"
"wnOinpcq6vkpqp4nA39j982MADBmzDE/EaBPB2A0C/PZWKSlJPeK3F/n3iB37jwjGjVuGo8U"
"NGAFaAFeiFZbvdNWAK21jzhwC4TOIgKWkJQiQRcKwnnELMCqBAO5LRxCOYkKDdYJuf4ZNtC7"
"dncdEx0nwd2J4h3AeyEfENHroFdpzSZDXQAAIABJREFUfG9kT7Bv0ECN79XF+F59VqtWHQF+"
"SulXqFAxEPiilu+M6+lRvliLn7r3qZFPzeujpk/p/XAifZ+U/whLNvu9rp6XUur5ya2eJ73b"
"38Df2D01IwCMGXNbKBGAuexM3HNacpnW4pZs4kI9F0u4tqlUuco/EZkCWoBXs2YtRNQKoLnF"
"wTsCfIhySSCI7IESCW18hALq3yQWSDBIl9DtqDIMJCB076QJCtt9vk+HuAR5F/tz6HMl1APB"
"LlL1BHcb8DKSl5DHGvtuyOPa4Bo1VRvtyKi+qQ16rL2Pnfb0sT2ni7+WaOSz5/KR0i9NKX0Z"
"4QcDfl4OfHTu21E+UvvUve9t5EsE9MkffeQv/7Rkyr+Oej7Kq+eloHp+MqnnycDf2H0zIwCM"
"GQs0XQTo6wRgURZaNji7JZu3UMctazklgYZZs2YbWbNmnXjACxADzLDwDGbQhTjgoLMFAo9y"
"m5FAaN7SFgkApVsokFjQBENrLbOgO4FYuS4mvN7G870EcN31z8Jny6i9jX1cOEYRvWtwF+l6"
"EcW7I3kB+cZyyd2GDZsEAb3cYa9WLQ57DvoaNWqpkb0a9sgeUvxivX0V3WNr3ZdeKq6l9DGb"
"Hxr4GNfTo3xK7T+TBOB7ov6ReA4sJ+VfVj0n+dVzQ8v7PmM5c/4G/sbuuRkBYMyYv/mJAKzI"
"9jT35y2nORB1XCoJVLDkaJfIBpQsWXoVolVErbVr1xNgA+AAOqSwXQJBFwkkFJo6QkFmE9yC"
"gVwAtwWJB4+/LcVEaG8V8HP6e+qfRUBvpo7JBruqyYtUPeBup+vdgHdD3h3R66AXnfuvekb1"
"1Gw+xvMc2BcTu+shui+Y36nh58mZh+UMBXzU8pMZ5Qep9VPU/5p6Hkqq50Ov9z+vniNa4e9R"
"y8Df2H0wIwCMGQtuJAL0FQOxJjs1ByKFi/XakdItYMmRLsoGvMG9waOPPtajYsXKRwA0gO31"
"12uK1DVgh+hWCIRadUXEiy1mAcY6dTWhYIuFRqLRrYFyXTSQ2+JBd0A5HPf8nA1xcvV59Pni"
"eOrLWrwL7B64iyien6MTydcS18CZx5cR/Stq5T0CfSXVvFf+ZWdED1F+YQ/sxWieiu71Gr5o"
"3ENKX4/wUxj4ng7/Hpas9b9hOVH/i+q5yKmekxcsp9nvccu9wp+Bv7F7bkYAGDMW2vQVA719"
"AVQSwHatmOPWswF/t+TObrW4v5kuXfqR5cqVj6tSuSqryiGHqBbQgyPSBQgBxOrVawg4IhIm"
"oVCjRm0pFmrWsQWDgKvKLJAL8aB53bqJc+/P6+9Nn4eGOwl0groDdid6d+BOUTxF8jh3XAOC"
"fEVAvrxq2isrQY86PnXqA/qYxdcje0rlO7B3ont06mMFPlHDp5R+CgPfTvc/9rc4S6b731T3"
"+RV13/WoP5t6PvSUv1+938Df2D03IwCMGQvPEioJoJubsgGo9aLmW9qSnd9UFmicNUu22aVK"
"lo5HVAvoAX6IdAFCdLFXVo5IGI6oGODUBQMiZhIN5CQeyGW2IfGuv4cNcXL+ma96gK7P2VP0"
"LuCOjnx+ThU0wFMkTwvuEORLcsgXf6k4e6mYrN8XLVxEbKqDtfVpiV2k8bMija8ie5HK12CP"
"+v1zCvbJqeEnos6PpXwbW066v6K631Trp6g/nWVS/sYeUDMCwJix8E0vCejbCdOUAGUDUOvF"
"mBc6vrHMK9LBlS05CoZV4JpkzJBxTtEixeIR4ZYsUVKAkKCICJhAicVqhFjgXh6CgXsFBdaK"
"mldS0CWvnET3vo/+GfS5dBx0XDhGOl6K3m2483MrYQO+OCtWpJiAPOr2gHyhAgVZwfwFWAGR"
"zs8rmvWw6E6WTA7oRVSvp/G1yP5uw94H/HNw/9R9fF3d17LqPhdU9z2r5UT91OXv3c7XwN/Y"
"fTcjAIwZS5z5lQQoG6D3BmDMCx3fWOkN6eASllz9DfVhEgKNn33m2cl5cuY5AhAWLliIg7Gw"
"GFkDJAFLrEwHcBaHc4iWeKmEiJiFC8CWYqVKOuIhpR3vTZ9Dn4tjwLHgmGj1PBvs/NhxDjgX"
"gjs8f958NuCxsh7V7EUqn0f32dQmOmItfa1e7wL9PYS9T41/siUjfgJ/FXU/S6j7m1fdbxrv"
"o1o/Rf0m5W/sgTMjAIwZS5r5ZQP03gCaFEAaOIclRwZJCGANeAAEO8Ehhfwmf7MPM6bPEAUo"
"5uFwBCTz5szD8nFgApwAKByRMkEVjXDwQgUKCeCSCxGRDNffC+9Nn0Ofi2Og48Gx5cudVxwr"
"jjmPAntODnYH7jJ9j8a8zGpVvYxqZT17oR01fncvI/qE/LG//DWK35sPLVnjr6PuVxV1/wj8"
"+dT9zWw5Hf7Bav0m6jf2QJkRAMaMJd282QDvpACVBQAGrPqGujCAUcRyMgKVLFlDRhMZZsfb"
"PvXEE8sypk0XD1ACmnAAFA6YwgFWcsDW5QCwj+cWnlO5//cQvHVHDZ4+iz6fjoeOD8eqgz0D"
"Bzvgno7DHYBPyyN61OrTPPOsqNc/z6P755I5c3+30vz8hi7DfVD3o5a6P5UsJ+Ivou5jTnVf"
"01tOut/b4W+ifmMPrBkBYMxY8s0vG+AnBFAXBjD0jABWh8Pa8GgiQxc5Fo+pZ8l088AnH38i"
"isPyVhoF0LQKqOnIn08jQEsu4OvjqKVnVIC2XdXX/Vx/T3wGfR59fhoN6DrUw/EHDfzYoldF"
"+wPVda+n7sMr6r6UUfdJj/izWO46vw5+E/Ub+1OYEQDGjKWcBSsLUH8AQJHWcgsB6hFAExlA"
"gzGyatz/Ycm0cyPub3Gf+sRjf4vi8LwVLmgfNH+QwK9Bf6q6vo3U9f6Huv5/V/fjJcup8evg"
"T2s54H/CMul+Y39CMwLAmLGUM29JIFQ2AONhaBjDnHguS46OIbWMSBNd5VhFrprlCAHUoVtY"
"cqW5Tx9/9LHvn33yqfj7DfVw/Nl73K0fKr3/6CN/+R7XT13HFpZT3yfwV1DXv7i6H/nV/cmm"
"7lc6K3TUb1L+xv40ZgSAMWPh2yMe/4vHCQCPKif461kANIihQxwRJGrHXhFA2QDMlGMDGYyZ"
"oQZd05IrzSFafdeSAIMP4VBb/tTjj+9Jj+VtHwDg6+C/n8DHMTz+10f38Bu1HNdJu2bvquvY"
"QF3X19R1Lq+uO0X9XvinV/ftOXUf9eifRADde10M6O59howZu29mBIAxY46FA3cv4AnyBHo4"
"okKA4UnlAAUWgkHUCHgggsSoGFLJ6B4HYNBQhjQzlo7FXvGIQL0iAA1pSFVTJsD2dOnSD8Gy"
"vJjXx4I6aOZDzf5+pPnvF/jx2WhUxP4AFcpXFMsU47p4r5W6fo0sp8FPh39xdf0LqPuRU92f"
"zOp+vaDu33Pqfj6t7i/d6yfU/adngZ4Nela8AiEhkWDM2F0zIwCMPWwWDPJewCcEdwL8U5YD"
"eESFz1oO6DESlsZygI/0MaJI7AaHiBL1ZMyOAzJYNhYRZyHLLQAwcoYOdGoQrM+9meXOArTJ"
"kSPnWKzZj7X4sbFO9ddriFX7AMISxUuwAvkKiK79tHdJFNzr+j4+D1MH2AsAaxFgtUGcL84b"
"54/rgOuB62K54f+uun71LafRr5K6zroAKKTuRx51f7Kr+5VJ3b/06n6SIEij7jcJg2fV80AC"
"gUQCPTsJiYRgAsGIA2MpZkYAGEuNlhzIB4veg8EdKWEd7hmUZ1KOyDGrckAEjWQAClaMA1zQ"
"VY5ok8CPDWQwagYYYewMNWnMnnvLAK6otnKVqquxM1+Dho1ZnTr1xDr9r79RUyzhq2+0g9X9"
"sIpf8ZdKiNn+PDlyizE+TAQ8iGl+LAKEz8iRLYdYGhiwx7LCldRyyTgvsZ8CP0+cL84b54/r"
"gOuB6+K9VlZg+r+Kus7l1HUvoe4DCYEC6j7lUfctp7qP2bV7m1m75/QM6CIhrZWwSPDLIhhx"
"YOyumREAxv7MlhDow4E8RWfPWA7kn7ccwL+gnOBO0Tt+4SMi9II9l+XAHSlkRJEACJaJBUxQ"
"W0ZzGdaMB2RQbwZwSlmy6xwQQjoa42cAUzVLLkADWNF4YEvLA7WqVV9dja17sbMf4IfNfbB5"
"Tw0SAtXfEBEyrd1fWYmBirTrnlqvv0yZsvY2u1i1Dwv8oJyAVfrIMf6XnGgfP/usAjsc0TwJ"
"ChovRPkCPQ3kWG5YLHGs7Y8g9kTALov8/HCeON+69RqI88d1wPXAdfFeK3X9aNyvprq+1dT1"
"rqiufzl1P0qp+/OSul/F1P0rrO5nQXV/86v7TSIhlxUoFLJYjlDIaDkigZ4xEgjPW444oF4D"
"PYMQjjgwwsBYgmYEgLE/gyUW9KEgHyyC9wM8fmmj/kuAz2XJX+74RY+IkOBOYEfE6AU7doZD"
"VAmYoLucAI8xM8AG6WfUoKtaMh39qiWBhK50wKm2JUGFmjVS162sQKC14dHukZatWrO3mr8t"
"4If0N2rgSIVjBz8SAkiR0xa8+kY+lStXZZXgHlFg79SHNf+xmQ8HMbbjTfdcGs2fD8PTuP35"
"QE/v8rSutQggTGzoY/MjbF5E4Ofnh/PE+eK8cf64DrgeuC5+10tdx2bqutZT17mmuu7V1X14"
"Rd2Xyuo+VVT3jQRCWXVfS6v77BUKRS1HKJBIyKeeHxIJJBCyWe5Mglcg+GUQEhIHRhgYC2mp"
"UgAMHTrU+J/UreSDXk/XU8NdMMh7I/hclhvwFLl7o3bUifWoHSBADRlgQCoZoAA0KIIHSJBq"
"JrBjz3jABk1oGEHD+vKoSSMtDSBhNA0bzgBQzbm3fObRR7rWL/fIuAbl/jIe3rb6YzPGtXlm"
"DffVY9s8u7pj+3fiW7dpz95u2VpEvk2bvsUaNW4qomESArV5hIytfLF9ry0GVGbA3q6XCwJb"
"FHiEAYkDlA7SBwA7qe4GvVjMyOtp04mNhmzo8+PHeeB8CPw4T5wvzhvwx3XA9ejUsW38zA9K"
"rZ7VvzR8TbcmeWe0+EfW8S3+kW18ixpZxz33xCNdLZkRaK6udxN1/Rup+1Ff3Z866n7VVPeP"
"hMJr6v5WU/e7srr/FdTz8LLlCAXKJhS3ArMJlEkIJhAogxBMHHiFgV5WSKowMJbKzQgA4/fN"
"rfBgT2nOxy1n5z0v6INF83ok7wd5PYL3Al6P3Clqxy91b8Sugx1NZYAEokmCOpaTBUyQcm7K"
"vdlzf/tL+6aVHxvVtNJjozvUfOLTiR3SrBnX9vmIGV3Sblj1UYbYlcq3jstyK3piFhY9ITOL"
"Gg/PJF4jx8s/R0/g/zYxK4uelI117daDtWvfiUOvnYh8IQKavdWCNdGEQP0GjUSKHDVyWwzw"
"CPoNTRDQFsCvalv/6tv+wgsXKhwA7cR6AOSF+6xgKDy92IDIhj4/fpwHzofAj/PE+eK8cf64"
"DrgeuC5HvqrLYr+ux2JXNmBH4asacm/EjnHH69HVb3Jvwg5+1fDW5rk1YzfPrcW9duySkVU3"
"zP6oYsTcjyut6fV24U9b1807unXdPKPSPPOX9pYUC03VfW2k7jOJhdrqOahhBQoFPaNAIoHK"
"DZRJ8AoEPYMQTBxQ5iBY1sBPGND/Kb2UYETBQ2RGABi/J26FD3u/qN6buvcDvR7NU5OdHsnr"
"kNfT8zrgkd7FL2aK3PV0PMEdkSBSxhSt22Avlv2Rnm9VeWJ0p9pPfzq5S4Y1EztmiPjyoyx7"
"I4Znj40Yni1218w8bOd07tNysx/hU3MK3zE1B9sxOTvbMQmejcVMJM/KojjkBfTHcR+bkW0b"
"m4ltG8OFwFiIAYiDrOyH8QVZ9x69WafOXTn0OorIt9U7bXgU/I5LCFBpgLICQgwgM6AEAVLp"
"aKJDhE2iQBcGQhxwx85/cr1/3cOHuu9SxQr0wtM5nkl4BlaqZGlxvBTtU6pfBz/OF+eN88d1"
"wPXAddm5rBGHf30B/mNr3mTHIhpzb8KOf9OUHeev+PrYmmb8tRn/O/hb3Jtzb8FOrCV/W/hx"
"vK5ryb9uxV9bsa0LG8TCf5hTb+/cIdUi5g9/dU3vd4p92rZBgdGlCj7b0woUCg3U80MZBV0k"
"vGo5mYRKlrvcUMZylxm84gDPud6kmJAw8CslBMsWGFGQSs0IAOMp7pZ/zT6xsNeb8NBJ7RfR"
"66CnaJ5q8d5IHmlYPYonyCMyw/aulJbXAW+n4l/M+UjPFq8880nnus99Orlblog5fbNtWDs6"
"b+za0Xli98wuxPbMKcj2fFaA7YbPyi98F3xGPunT8/JXDv9P83Do5xa+YwqH/+ScLGZKDhbD"
"4R8zMbsA//YJ5FkF5CMV9Ld9kpFt/SQT2zKKfz06kxAFUfx7IsaWZr169+PRbk8BvfYdOrE2"
"bTuwd1ojG+AIAaTG0RkvxACPmhtxiDZUmQESBGge9IoCIQxIHHDHVsAZbWgnwtOlD+qZNNjT"
"xkLkmbljF0Icb2MV7eM8cD4EfpwnzhfnjfPv2KmruB64LpsXNOeRf30B/+Nrm3JwN2Mn1jdn"
"J79twU7y1xPCOdjXt+R/R96K+zvsFPeT38mvT37b2nldT6+t+c/x7/vuXen/bCv89A/t2Onv"
"23NvJzxqSdPY6KXNYldMqLVh3rDXI/q0Lvlpu4aFPyld6HkSCVR60AUClRteV89pNcsRB5Q9"
"KGsFZg6o98CbNQgmDPRxRj1bkFhRYHoK/mRmBIDxZLsVGvh+NftQsPdG9WiOotR9sLE5Ar23"
"ix6p1mqWE8nrkKf0vIjg0zzxSPu3X3tuVJd6L3w6tWfOiKUfF9i+flzh2MgZxX75aX4Jtm/e"
"S2zvnBfZ3rlFOeyLsD2zC7Pd8M8KcdgXtMG/axZ/nZlf+M4Z3Dn4hX8qo38B/8m5OPy5T8oh"
"PIZH/zEU+XOgbx9HDvjzyF/APxPbOioD2zIyI9vMfduojOLfIAA+H/0K69uvP+vRs48SAd1Y"
"h46dRRTcpm17AUbKCLR4u1WgGOCRtBAE3ClDAFFAwqAehIEmDvLnyacBOwmePhDyBHrh2sRB"
"FuX4TB36OA+K+CX4ZdSP88b54zrgeuC6rJzZVgoAHvmfWP8WB3oLDumW7N/ft2L/5q+n+Oup"
"71uzUz+0Yf/+4V3ueG3LvZ183dBGfc39ezj/OwV6+Mnv2qi/x/d0EB63Ad6RC4EO3Nvz98Yr"
"/zP+bmMn/tqZeyd2ZlNn7l3Y4W/a/RLzeavYb2a9uX3ByJoR/dqU+bR9oyKj0j4ryg2UQaAy"
"gy4OqltO5oD6D7xZA10YeDMGudT/r2yW02OgZwuCiQK/ngIjCP5kZgSA8US7FTyd/6gVPLqn"
"mr3emKdH9l7YU1RPTXiUuqeI3m9cDlESpeupe54i+aYvPP/X9h2alxk1pv8b86f3Kxqxekyx"
"fesnFj/606KyTPjCMmzfgtLsp/8pyfYuKMGBz31ecf76Eo/ui3GoF+WQL8x2zSzEo/mCbCde"
"ZxYUXxP4dwnPJ3zndO6f5pU+LY9I+wvwT+RR/yRNAExxBACi/uhx5FIAINoXkf9ILgBGcAHA"
"HYIAGQCUABaOrMs+6D+I9en7gYBet+69WOcu3UUU3L4DCYEOoi7e6p22dlZAFwNwpNJJFDSB"
"KODeSAkDkS1QXjBfAQfWSfKMLsh7YS9cbTMstkLOmFk4QR/Hj/PA+eC8cH44T5wvzhvnj+uA"
"64Hr8sX0TnYGAALg1D/fFtA/vaG18H9vbMNOb2ovfTOcw3ozB/UmDupNHeWfN8I7Ku8gQP7v"
"DR0U8Ns7/8aBfnpjZxvscRz2ceJ7O/JX/jX/t7hNcPxbF3ZmM7yr8m7i9eyWbty7S9/aQ/iO"
"L9sc3byk5b6Fo+tEjOpddX67Ri+OesERB3rmoLZ6/vWsgVcYUMaASgnUhEjZglyWvyhIZzl9"
"BbQc8tNWwlkCUzZ4QM0IAOMJuhU8wvcDfkLRPTqYaflbP9ijrumN6tFJTan7apaMePALTgc9"
"RfPNyr6YqVeH5mVHL5vaYs0/F3fcvndd79izOz76/cKO93m01pId+rwa+9eicmz/wrJs3/9w"
"6M8vzUFfiu2ZW5JH9cV5dF+c7frsRbZrOveZxfhrUbZrWhEevRfmIC/IdkwtwH6cwn0a908L"
"8H8vIMEv0v1O2l8IAMoATJPRfwyP/mMmcAEwUQmAyVwATKUsQHZR948eH1wAIPpHFgB/Rz0A"
"M0a2YwMGfcze/2CggF7PXn1F7RtRMAkBmRHoxNq2k1kBwPOd1m1FBI2mORIEfqKAhIFwLg4K"
"FSgoIO0H8ZBQd3kmF+Ql6B3YY9VC8myZsrBsmbOIz5fQby/OA6l+nBeBH+eL88b54zrgeuC6"
"zJnUV/QAkAA4CQGw4R0O6zYcxNy3tOPOI/YtPCLfBufw3soBvZVDGb6Nf72F+2aAu5N0BXIZ"
"zXcSsBfOIR4nIM5/bks3CXj+ff/eqKDP/y1OfM974lXC/j0Jf7xu6aYJgPdsIXCOi4BzW3sq"
"78W9Nzsf1ZuLk56/71zZMXbdvBbbF49rsKZdk+KjyxRNT2UFyhp4hQFlDKiU8LIVmC0oYgUX"
"BZktZzXExGQJvILAZAjusxkBYDzAreQD3xvd6zV7SuPrkT1+6dBIHdXpKX1PUT0aptBhbUf0"
"ZYtn6dmxxcujl05tFfHPJZ23H9n04ZnL+0axy/uGs0v7hrJLe4ewS3uG8F/S7djR1XU58F/m"
"EX45DnwO/rkc+nM48D8rweHNgT+jOAf1ixzoxXjEXpTtAPAnF+GwL8xBXYj9OLEQhzOH/6T8"
"HNT5xesOiICp+fn3y3T/run53QJA909VBmBy7gABsGMa9ynZZSPg5Gxs+8RsSgRoAmAUFwAj"
"lADgX6MsIAQAFwzTRnVngz8exgYM/EiKgH79Re0bUXD3Hr1sIYDUOIkBwBMQbduug0cQ6KJA"
"CgOvOMibM3cAvEO5DXWvZ/IBvYK97ljfH45+BR36OB8H/DLqx3nj/AX8+fXAdZk1cYAUAKsb"
"ifo/MgD/5pG/gP/mthzu7bnzCH2rgj8H/pltAD8HcSQHc2RX8ee4LV2lCNiswxzeRcJ+i4R4"
"HAC+Ff6egDlEwOlNFOED8jKyP7OFQ31bTwV3GelL2Cvwi++V4kCKgffE30lRoH52GxcDURAD"
"fYRf2N6P+/sMYnfn6s5H1y14Z/vi8Q0j2jctMbqsFAZ6xqCu+n/1D8udLaD+AhpdLG65MwX5"
"LPcSyVmtwCyBEQR/AjMCwLhwK7wafijgU+2emvT06F6v2VMaX4/sCfbVLVnXxC8lPap/q1PL"
"CqNmj2u+fPXcjhv2ff9hbPyBcSz+wFh2+V+j2eWfAP0RHPrDBPAv7h7ELsT0ZCciGnHoV2A/"
"zSvLYV+G7Z1diu2exX1mSQF8RPg7pnHYTy7KI3C8FmHbJ3HoTy7MXwux7eO4c+jHjOc+rgD/"
"M4f/hHxsO3e8xkyGCMgvRYAuAKYrASD6ABwBsPNTlAC4c/jHCHcyALoAQDlAlgKysG1jMot0"
"P6J+CAC8IhsgBIAaAxw1ZjwbOmwkG/zRUAE9pL37vT9ARMEAYs9efURk3K17T9alaw+PGOgi"
"0ucAK1LpUhCQKCBh4BYHgLIX3gm5DXcfwNugz5zVhj08R5ZsLEdWx994o6YNfZwHzkdG/Ar8"
"/Hxx3jh/AX9+PXBdcH0wBniUC4Dj65pKAbCxtYI/j/63thfwjxPw1wUAh23ke0oEdBOCQGYC"
"lG8hUdDVRwDwn9vaXbr4O+3PHNxnObjh5yJ7c+8lYR6JvwfYlRiAABAuSwRnN8GRUeB/3qRE"
"Bn/fc9u6i5/Be5yP5mIgmouBmL7cuRiIeZ/9vOMD6T9+yH7eOZDtXtMt9uuZLTbMGlFvecdm"
"pUdZcmlkPVtQy3L6C6pZjijQMwUvWe6eAj1LQE2G1EsQShCE00Ng7C6ZEQAPqVvhRflUw9d3"
"s/NG+DrwqSOfuvH16B61Rxqzq2a5I3uCfZMMaf9fu04tK36yYlaHNRtW9NoeGznszNXDk9iV"
"gxO4j2O/HBzLfgH0/8Whv3+EjPR3f8R9EPt51wD273+2YodWVOew58AH7GeUYntmcOBP55H+"
"9JfYzmkvcWDzSH9KMQH+7RM57CdwH1+YQ70wi57AI30O/2gO/uixBfifAX7uY/Oz6DH5+ffl"
"Ex6OABBTAHY/AEoBqvt/kiYAPD0AKAEI+I93CwCRARiZgb9yATBajgFiHYBtk/KyseMnseEj"
"x7AhEAE84h046GPWf8BgEQX3VUKgd5/3RWpcZgV6izo5ImevIOjYqYtHFEhhQOIALgCdOZGe"
"xd8F5D2gl56d5cxGnkN4taqviOPG8eM8cD44L5wfzhPni/PG+eM64HrguuD6HPyqkRgDPP5N"
"E3bquxbs9MZ3OazbsTMc/me2dZCp/8gu7GwUnIM1igM7qrt6lUIAgiBOpPZV5C8EQDfxCuAL"
"AcABf0ZB2QY+9zgAXYCfOwf+WQ5+ONL45yL7KCHQW/w7QG4LgC1KAFCJAT0FG2UJ4uwm7lyI"
"oNxwVomOc5FcDETx94juxYVALyEILmyH9xFZgQs7+rMLPw5gl3Z+yH2Q9N0fs8M/9Dnzz0Xt"
"ti+b2mxNh2alP0n//F/bWXIyQRcFeqaAxhTLWYFZAhIEua1AQeDNENC6BNRDkGB24H7/7vwz"
"eLhmBMBD5FboKD9YWp+a9sIBvr6RDUX3aNDDAiioPVIHPtKPol7fuVXlUXMmvLNiw5d9t8ft"
"HvfLtdip7MqRqezq4cns6qGJ7MohBf4Dozn4R7J4Dv34n3ikv+9jdnHvIB7t9+e/NDuyY/9f"
"LbZv/stsz8zSbPf0ktxLsN0c9junFufOoT+5GPtxEoc+9xge5QP2MRz2UeMKcpgC9tz519Hj"
"edQ/Aa8c/mMKiFcIgBiIAQiAcfn43+V1BADgP82nBDAzv0sA7JrBBcAMVQYgATAhh/Dtk7LL"
"sb/xcHcToC0A4KNl7R9rAUShAXBiFvbd5Aps/MQpIsolEfDRkOFsELIBJARURgAd8VIM9OMR"
"sxQDPXr2FulzXRB06drdFgWT258fAAAgAElEQVTSuypx0FWUBgJhnRTPLiHvAr0De3ju7NLz"
"5MgpvGzpMgr6MtrH+eC8cH44T5wvzhvnT/DHdZkwaSqLWdFGLAKESYCT3zZn/97wjoj+hQDY"
"2kFG/lEcpNEcpNEc+NGAP4+qIQKiHQFwZms32RcgwO+4BP17IoI/s7WHisgdPyMi/F7CJfz7"
"CKfUPYkAlwBQ9X9RAiARwOF/Bs2E6DvY2JH/HX/d3Fk6FwLnIt9T3l06FyLno5RDEEAIxPRl"
"F7kYuLjjA3bxx/7s4s6B3AcpIf0Ru7x7CLu8Zwg7ue3DX75f3GH77FGNVnRqXg6ZAuoraGA5"
"kwivq//ftKES7apIGyqFIwj0psJg5QLf7MD9/p36oHq4ZgRAKncrvFo+RfmU1teb9vRta3NZ"
"oYFPHfloMtKjeyyA0rRcyRy9xg9pOj9ica8Nx3aMOXPt6Ax2FX5kOgf+p/x1GvfJ7BcB/vHs"
"yoEx3BX4OfQvc+hf3jeY/3IaKMB/6p8t2MEVr7E9s0pzLyWh/ynAX5zt4tDfyaN8Af7JAH9R"
"DtsiHLBFRLS/fSwH/VgJ/6jR3MdIAQBBoAuA7RM8AsCbAfAKADUJYK8D4CcAOPy3T8jJ3ye7"
"9InZJfzHZRPjf9FjybkAGK0EAMA/JiOLHJdJrAQYPV4KgPWTX2WTpkwXUS5gN4JDb+jwUezj"
"oSPYRzwKBhBFRkCVBhAlu8XA+yJ9DkGgZwgoS0DCgMRBs2YtNEh74e3nOYI6Ad4Lesdzi34D"
"8kL5CzrQ5+eB88F5DSTw8/PFeeP8Ryj447rg+mxe2lWsBCj6ANY2Zae+byl6AJwMQGcR+Z+L"
"hnNwRnMAc5evSgBwoAoRIISA424BoNL4kQ7w4WcQ4UepSB+vUX2Fn4/mjq/tLID6ma097SmA"
"M1tUL4EQAJ2FSwHQwREBys9u7SpLA9v467Yu4s/n+Ou5yK78c97jn9eDe0/2MxcDP2/vLT2m"
"nygRXNpJmYGBIqN2aTf+r33M4vcO5T6c+wgWu+nDM6vntNkwfmCd+eWKZ+5lyZ4C2k+BsgSv"
"Ws7GSqEEQS7Lvc2y3lSolwuesMLoHbjfv2sfJA/XjABIhW6Fl9pPKMpHt6++Tz2l9P2AT+l8"
"dBpjThlNRs26tH5l1NzJbVfs+HbIvouHp/9+7dhn7NrxWQzgFx77KbsSO43Dnkf9h6awK4cn"
"8ah/vEjzXznwCfuFR/u/7B/GfvmJg59H+5f3fMh/YXVnJ9c2ZPv/pyLbN7cs2/cZj/hn8Ih/"
"Rgm261MOfhv+L7KdiPgnFBUew8EfA/CPKyxq+9EAPgd85GjpUgQUEL59fAElAApKATBWlgDg"
"AT0AiRUAUwMFQDSP/qM5/KPHZhPgjxpDnkXAX7hY+Cejtgwwf52cj30xuz+bOn0Wmzh5moDd"
"6LET2MhRY9nwEaNdQgD18IGDh8isAMQAZQY8goBEgcwSOMIAdXaIgxYtWvmAOmcCIA/muW3X"
"QQ/PlzuP5nlZ/jx5xVoAffq+L44f54HzGewBP84b54/rgOuB64Lrs3rpWHb46yYyC4BpgHVv"
"iXUAaApACoCuLgFwLrqnIwCQCYhUHtVDRvo8uhYpfxX5O/V9/nNRsjmP/KwCvoQ/vF9oAYAe"
"AdUYSALAyQIoAbCpoxIAjp/dys9jaxf1yn1LZ/5enW0RcA4ihwuBC/wcL/Dz+Jmf14XtPYUQ"
"uLgDmYF+Mjvw4wfs4s7+7NKuAezyroHsMjIDe5AZGMau/jSS+yjuo9nPe0b8HrO69765Y5ut"
"6Px2ecoSvKl+D9S2nLKBnyCgkkF+y2kqpCmDhLIDRgyEZkBYZgRAKnErcdD3Nu/pUT7SdPks"
"2e1LTXtUw6eUPkX4XuB/8vnc7hGHIsfG3jg+j10/MYddPz6bw36W8KtHZ7Krx3i0z6F/NVam"
"+a9Qff+AAv9B1Pd5xP8vHnH8NITF7/uI+yD+S/pdduzrGqKpb/+C8mzfvJdlY5+o88uUvxAA"
"U53ofyeP+ndw8MMB/hju0WO5j+EC4BMO+E/yc7jmZ5GfkAjgr5oAQIbAJQCQCZjARcDEfNKn"
"JFEAqBKASwAg4h8Dz8KPQ7lK/wsfi8hf7gUQxeEfObUYi/h8Jlu0ZDmbMWsOmzJtpoDduAmT"
"2ZhxE2U2QBMCSIl/PGS4LQYGcXgickazHNLnEAR2hoBEAQkDTRzUr9cgANaJ9zwewEvIk0vY"
"S+AXyKt5vvxiAsCGvkr1E/hxvjhvnD+uA64HrguuD67T2lUL2YGVLZUIaMxOrntLLAh0emMb"
"MQUgegCEAHjPJQAgCM4KIdBTOP7+bBRq+T35z0ghIBr4+Neivq834yk/y0F/LrqfJgLcAuA8"
"CYMQAsDOAFAJIBwBsJUEAPdIiIBuwi9ABAD+kfx1ew8pAmJ6K+/DRYD0Sz9yUfBjP3ZJiIEP"
"uRgYxK7sHcKu7BvGfQS7+q9PuI9m1/41hl07OE74/u8Hxi6f0TqCC4JPLH9BQBmCCpbTQ0BN"
"hTRlkNsKzA7ovQNGDBgB4G/3++Lfw5scLvT1Bj49tU+1fD3Kp7Q+jeSh2Uev4SPVJ4Hf9tVP"
"Pp/XgwN/QuyNUwvYjVPzuc9jN07MZTeOzeHRPo/4j3HoxwL6SPFz6MfyKP/IRA7/8XZTX/y/"
"kOYfw30Uu/KvEezyfgn/y7sHsNMbWrLDK15j/1pUkXsFRwDMVQLgs9Jsz0wpAkgA7JzCBQBS"
"/xN41D+uiAD/9jGFRNpfwJ9H9lEc/PBto/KxyFFSBIQSACgBxIx3BIA9BjitQKJLAFgJEAsB"
"ifq/EgBRY52oP1IXAGPkSoBi2V8IAA7/rbNeYWtWf8W+/HqVANvsuQvY9JmzBeyQ7kZPAGUD"
"AESRERg5hg3TxQAyAxygg1WZwBYEJAq8wkB53Tr1bEDr0A7XHbhLwAdAPm9+6Rz2BYUXEF4o"
"fwFRAmjcqIkNfZwPzmukAj9F/Th/XAdcD1wXXB9cJ1yviIhVbN/qrlwENBQi4IQtAtoKEXBW"
"iID3ZPo/SsL/HAfkOQ7Ic9t7ieY66b2Fn+WRPlz8OYrq+72UAOhr+1kO//MQAML7hicAgvQA"
"xIlFhTr6CIBOjgAQ6f8uHgHQVUT/TgZAORc08J9jeklHWWBHL+EXhfdml3b05WKAC4EfP2C/"
"7B7IruwZLIUA/796ZT8XAvtHsasHuBA4MFYKgUPj2fXD8AnswIbBsStmto3o3LKiLgjqWe4e"
"gkqWM3qolwsoO0C9A3qpQG8kNGLACABp9/vi3+Ubm5RIH/9ZvKl9quVjwQ9vlI8dy5C2w8Ih"
"aPZBJ3DTN+uUGTx/SqcVh6Mmxf56ehH79fRCDnzyBRL+Jzn8T8xm1xH1H0Oaf5oT6aOh7zCH"
"/qEx0g+MYvHwn9Dch6h/BBcBQ9nF3R+wk+ubsMPLX2UHl1RmBxdXdATA//yd7Z8PAVBOjfZJ"
"AbBnphQAEv4vsh959C8FAI/8Af7RBRX44Rz2HPpRHP7bRsLzCxEAARAVTACMUwJgoloHQKT/"
"lQD4VC0EpDUB+gkAbAb0I9YDwGqAk+UUAFyWAJy6P0QAxAC+FuAfp3YDnJCJbZnflH2z9lu2"
"cvU37IuvVrElyz5n8xYsZp/NmS8iXaS7J0+dIaJfEgKIiEdDCIweJ7MCmhjAmNwQLgZIEIgM"
"AWUJSBho4qBWzdoK0l5wh/L8bs8XCHjh+Qn0EvaFC5AXYoULFmJFuL9e/Q1x/DgPnM9oFfET"
"+HHeOH9cB1wPXBdcH1wnXC9cN1y/nRFD5Y6AEAFrm4n1/v+9oa1YEAiZgDNiEkCVArarbMD2"
"3rK7PkaO2Z2Db4ersTse6Z9DtB+pov/t/aQD+Nvf51+/L0UAf5XZgH4+AoDGAnvbjYBSAHQJ"
"FACuHgCVAdjSKbgAEOn/7sIv8PMi8MspgV6aAMBrT+EkAERGQGUDftk1gIuAD7kPZr/sQzZg"
"KLv6E7IBo0RG4NpBZAPGsuuH4FIEXD8ySXrsFHZw05DYeRNbrmhU88XBluwhaKh+z9RQv3eq"
"WoHZgSKW0zvgLRXoYsBkBowAuP834C7cUB383u59fVwvIehTah9jO6jFeaN8NPIgXdc4Q9on"
"2k8a0Wr+ljXDtl85vuD33+KWcujDl3BfzCACbAFwch67fnIO98/Y9eMz+X90HvUfnSqa+q4c"
"Vk19PDK4wn8p/HLwE+6jZHPfv9DVP/z/Z++9o6u40nRv/TFfutPzzayZabt71r3fzL3TbbdD"
"O2Jjg3NObRucc9vghAMmO+IEDTYm2mREFIiMSJIQQUJCQhJKoIAyyhGUExJ4f+/z7r2rdtWp"
"c3QEfd3dHs5azyplOFXn1PN7w343q+bwe6I08gmK+O8k3SFywm53AsBKMv/lN4ssTv/f4AAA"
"zgDMu1qZP0X/M5H6h/nL6D+RjB9p/4Spl0gAIOO3AeA3ngBg9QB86wEAc84fAPQo4KTZxioA"
"DQLYC2DGv8m1/t/JtH/spi/F7qgYsX3nbrFl2w42tLXhG8XK1WvF0tBVbHYLFi0V8+Yv4ujX"
"BAGkxC0Y0JkBFxA4oMAAAy4dKDi49ZZbDZM+H13KEwUvu8Tb6C+/9DKp310mrvjd5awrL7tc"
"DL5hMP//tenjeZnGj+eN54/zgPOB84Lzg/OE84XzhvOH83g4aoEFAdgBsDjqJVG69488Erg8"
"9k3u9uclgLonQGUB5Bp7uc5eC0vsGAqSxjMEVBMYWACQNF4BwEQJAXSsSpxgAIBaBeAFACgB"
"uABAlgAMAMAKAAUB/gHgbRX9SwCoTRxtNAGOZQiQ5j/aAwDGqv4A2SNw8sgkCQFHPhEnMz4j"
"CJhMAPClaEImgN7TTdl/ktmAnGkSBAj6GQLoPtCSP0u0FswhzRWthfNEfe7srgNbxiXN+uKp"
"0Iv++f8cGSJXGTym7kPu7MD16r6lSwXBwIB7eaG5muBnCwLBPi4AwF+xQgJH++7ufXdN35/p"
"69Q+hnugFoeBH0aUf+OnG0PH7SjLXFTRXhEu2ivWifbytXSUaqOPGQLK19gAULJCAkDxQmn+"
"hT+IZnT0E+036cgfAJALAJhuAMDXDABVCa+L0p3DxPH1d5HutAFgzW0SANbcYgFA1vKbRBai"
"/8U3WCUA3QPAy/1mEQDMROMfAYBO/U9XUT/q/SYAqBKAPwCQGYBLpfHP6D8DkDY/cAlAbwcs"
"dwLEhkBqENDs/6E2AvofcjMglpwJgE7/xDm/EXGRa0TM3v1i5+4osX2HBACktMM3bOHodvmq"
"MI50ke5euHgZR78mCCAljuVw/mBAAwHS6YACdNEDDL5SYPAlwIA0ZPAQNulzkcPYDYPX0kZ/"
"xWXS7K+87Apx5eVXiKtYV4qrrrhSXH3FVfx/xPPA88HzMo0fzxvPH+cB5wPnBecH5wnniwGA"
"zh/OI85nwv4tIj/iOVEYgW2BCQJ2P887AZbGvCpO7NMgoAYDqQZALgFQ1M8ZAA0AKVhjLz8G"
"BGAAj9REPlbB/A9PkhBAX8PnTgAY4wsA5ioAEwDMJkBeBvi2BQHeAKAbAN+TZQ00/yWZqwDG"
"MQQ4AUCqLmWsSv1PEPWpE1UJ4CMlAoBMBQCZAICvSBoAkAlQ2YC8b0Qzvfeb82bQfWGmaM2f"
"LSGgEBDwA6utaL5oK14gilOnV2xY+taO4Q9d484O3K/uV7eG2KUCfzDg7hlwryb42WcFgn1c"
"AIC/QoX4Rvva9N11fd29b9b0/Zk+hnbojn2k2jAGdPjFv/xvIyZPeGbewV1Tk5pKw7s6KjeI"
"jiol+ri9cr2QIBAuOhgG1pH5h6kMAKJ/mH8omf9iEpl/0Q8EAPPojY56/2zRdHyWygAoCMiT"
"jX4AgOpDb4qi7Q+L/A13sRgA6JgXfldwAEDRf4Za/ofoP2UOzF93/gMAficBYJoHAEz9rQEA"
"sgSQMO23Hj0AHgCgewC8AGChaztgfwCAXQHn/DuL9wKYJfcCSNYDgXCcRQCwaKiIj9sr9u2P"
"E1HR+ywAQCp745YIjmrXrd/EJodIF6a3ZNlKjn5NEEBK3IQBRMxuIDChwASDqQADJRgzDNoy"
"62B0ma/Y3LVMk1eC0Wtdc+XVUlddI64lYYWCNn08L9P48bzx/HEecD5wXnB+cJ5wvnDeNADg"
"fOK8JsTHirydb4uCiKcJAp7mbEDRrhfkNr97XpG7A+6TG/5gDHAFL7N736r9V6LeDxBA1H9Y"
"Rvly6M5EOXgHhn84CABwrwJwAMAoxzLAin066n9LAYCEAN35bzcDKvNPkOl/LAHkZYCeAKCy"
"ADgmS6EJsD51gmwCVMsE2fjRA5A+WZzK/FwBwBd+AGAamb8CAIaA7wgAZikIcAPAQoaA1pKF"
"pEWiIf+HrriID5M+G/vIvIv/5f/GYKLh6r6lSwW3qfuaPxgwewb0aoL++gV+FiAQ7OMCAPyV"
"KMR/tO9eq2+m+LEhB7pkdSOfrumb6X236T9x8S//fsTsqa+FZhyck9lRvVl01JCqt5C2is6q"
"LaKzWqqjCtpExg8YWE8KNwAAPQDK/Dn6X+QBAHPsEoCGgLxvOdVfsvtRUbT5fpG/8V4/AHCn"
"XQIIAABc+1dL/1L0sr8Zdu0f5s8AMFWafjAAkPitWQJQo4Bn2E2AvAwQEKCbAHkzoEuCBoBU"
"NAJCc/+d5d4L4GjY/aIoeozIjvlGJB5OEbFx8WLvvlgLAHbsjBTbtu+0sgDrN261IADNbjob"
"ACPUGQGkxP3BgBsINBSYYKCnDSIKZ11+DrrCjuIdulLKNvqr2ehZV0PXiuuukbr+2uvEiBGv"
"W6aP56Ujfm38eP44D9r8cX509I/zhvOnAQDnFecX57kwZbWoTf9BlMdN5GxA0Y7nRPGu5wkE"
"XhAlkS+JkuhXRGn0H3lbYN7Wl8cBvyNXAehGQJXyh+nXsvlPYhAAANQkfyghgEFgEvcBcH9A"
"ghcAjHGuAnBMA5QAUBkrJwH6BQBkAeKl+dszAOSEQF8AGCfqLAigY7JUfep4GfnD/I98RMIq"
"gMlKn4tTWV8wBNglgKmuEsB0CQCI/tEUyBmAWVKcBdAAsEC0kekDAlpLFrPaoNIllo7s+yJz"
"5pfPhl78L/8PYOCJEF8YMMsEumdANxD+m7pfepUI9IwBEwT+pmEg2McFAPjLXygv43dH+3qt"
"vk7xo96lB/Po7v2rQmzT1+l9y/RvuuE3o2dPGxGaeXBeZmfNNtFZGyE6a7bLo/64Zoc6QvS1"
"6ggJBpUbJQBUhJP5GwBwYrmK/pf6AECLLgEYAFCTMpZuoE+I4u0PieKIh0TRFgDAfQoA7ibz"
"v9sBALkePQAmAKQvus4CAKz7T55lmD9F/4enX+oLAFN+69EE+BsbAKZJADj0rR4EFAAAdAZg"
"/iX2dsADBIC0RVeKgp0jRWUy3RArEwUeZ86cFeUVlSI55YiIT0gUB2IPSgCI2Sd2RUaLHbsi"
"rSzApq3bLQhAmntt+AaxOiyco18NAqiDwyB1VkDDADrkTSDQUGBmCbQABxMmfMimDINmXRmk"
"rvKVbe62tMmz0V9zHZs9NOja68Wg664XN1w3iKcBPvrIo1a0j+eF56eNH88bzx/nAedDmz/O"
"k47+cf5wHnE+cV5xfnGecb5x3nH+8ehqzBWnCjaJmtSZojhqpMwK7HpRwkAUwcCe10RpzAje"
"EpgNGEaNZYDYnCdpHG/KU62EiL9Gm3+QAMDDgBxzAPRSQCkeA6x3HvQLAMr8TQDQxu8GgGQJ"
"AXX642Qj+mfzl/MATmV8YYuMH2rKUtG/GwDY/HUPgGwG5OgfMksAiP7J8NtLljhMv+3EMtJS"
"qXJS2VLRUR4q0g9MzZz99fOhN1//79jgyIQBs0xwvbov6tUE/6Hum78OsUsEesaAOyvwNw0C"
"wT4uAMBfh/H3V9vX0b6Z4scmHBikgY050C2rG/nuD9GR/kV/P2LOtJGhmQnfZ3bVk6nX7RBd"
"rJ2k3aRI+tpuqdpI/ryrdheJvl+7Q3TURHBWoKNyEwMA+gFkD8AaBQA6+l9iAMB8AoDvRUv+"
"96K5AJmAOaKWooiymKcp6v8D3UAfIQB4mCGgaMsDIn/T/Wz++RvvlkcAwHoXABgZAKsJEACw"
"EHP+r7EG/yTPvMJa9hcIALjeD5HxHwQAfG0AwJ9+KxK/oe9h9v80bwA4POs3ImU2dgK8lAz9"
"UjL3S8nwlfEvCgwAWatvFSX7xouG45tEd2slG01fX5/o7u4W7e3toqmpWRzPLxRH0tI5KtUA"
"sG9/rIjeu5+b13QWIGL7LgcEIM2tswFh6yQI6IxA6Mo1FgzozIAXEGgocIMBNG7cRDLn6xxG"
"PVCxsWtdq3W9NHll9INg9Gz2N7BuhAbdKAZDNwwWN9042DJ9PC8d8eP54nnrqF+m/W3zx/nS"
"0T/OI84nzqsGAJxvnHecf1wHXI/Ori6+Pnj0djaI1oqDoj5zkSjfP4ZLBCWRrzAMnCAQKNs7"
"Um4TDFPm2QAfyFn/SPHD7AEDVinABgBzFLAPAMSPNrYGfpchQIKA3gzoHQMAVN0/EAAkjeFx"
"wBzlJykxAIxXQ4DG2QCQoqJ/tf6/AZMB0yarGQBfSVHUL5cBTrFWAcD8TQCQywFnSmkA4Oh/"
"ngIApP8XifbSpSTb+NtZoZbaypeTQikQWUH3I1LFclZGLGDghdCLf+nIDNwfYjcQ3qjuk1eq"
"+6ZZIjCzAv31CvzNgMAFAPgrVUj/TX16zb5Z29cDekCxOsWPuheWytwRIrtlMWRj2K8u+sWI"
"OdNfD808NJ9Mn4yc1F2/S3Q3kOE3RJH20MfQXvoeqSGGv9ZVR6rfoyBAAUC1BwCU2fV/TwAo"
"lk2AWAWAJr+Kvc+L0t2Pi9Jdj3kCQAEAYKM3AHiVAPwCAMb9Guv+NQDo7n8fAEAToAEAXAbg"
"kgB9b7qUBACYvlQywUAyGb+d+lfmv4C06FL6/1ziCQCFu98UdVnLRWdDnhXhd5Hht5HBNDe3"
"iKbmZtHa2sbH/IJCkZ6RJVJS08ShxGQJAHHxbFQxew9w2hrRqwkBuhywaWuEAgGZDYARIhJG"
"KtzMCrhhwA0EGgo0GGiNHPmmNGbSIE9d7yHnz9xgmbuWMvlBWjB5afTa7G+68SYxZPBN3IAI"
"Db1pKPcl6Ggfzw/PE88XzxvPXxp/hJX2N82fo386jzifDAB0fnGecb5x3nH+cR0AAfq64Drh"
"euG66QxBd2u5aC6NFjVpc7g0wOUBZARiRvKGPYjWK9WY4AretnestSRQrgIIPAfAAgDXdsHY"
"Cpi3A9bjhw/aEKDr/vY8gFF+AGCcofH+AeDIJDUJ8FNrGqA0fzL+zClk/lNZTUflQCBWzvQg"
"AADR//eitWgBq614sQKApSrqX06mTypboUQfl6+ke9AK0Vm5iu5Hq0k4rhQdVSvpa6SqVSIz"
"7k+Zs6e8qGFgmLov3qvuk0NC7H6By9X9VA8cMnsF9GyBgE2Df2kv6cdnLgDAX5P8GL9XUx/S"
"UljOomv7OtrHYAysidUpftS9MEgDG3M8/eUnL85NiJmV1Fod0dXduFv0kNl3N5Iaoum4V/Q0"
"7hPdJ/fTxwfoGEufx9L3SPT1rkYFA/UxVhYAZYCO6m305tosSwBqRYA3ACx1AEBT7nS6Ob0u"
"yvY8KU5EDfMLAMVbHxQFmwkCNt7DOlcA0IN/HADwjR8AmHqJHwCQWQAAgJUB0CUAGP/MSynq"
"/x0Zv4r6F/yODP53ZPhS6YsJABZJAMgIvV6UHpgkmkr2Cv1AFNne3sFGcupUEx9hLvgaosxT"
"ZDYFhUUi62iOSEvP4HS0BgDUqPcfiON0NaLWyOi9NgSocsA2lQ3Ysm07N7tpENAZASyDQ3Ss"
"YQARsxsINBSYWQItwMELL7ykjFmZNJn1jUHI+nmHyNgtg5eSJi819KYhSkPFLUOgW8StQ6Fb"
"xW233CrGjBnHzwfPy474pfHj+eM84HzgvOi0vzZ/nD+cR5xPnNdYAwBw3nH+cR1wPXBdcH1w"
"nXC99PVroiO+prMDeHTUpYuG7KWibP87omzvCFG+93W5Zp9goAxb+KqmPt70h0y/0gKA8QoA"
"xnkDgNogSH+t6iCmBKothDUEOABglL0KwAEAo70BIHmCEwD0EZ3/GAWc9oky/8mkL5T5fy3H"
"AfMkwD/JSYAYAsSDgL5hCPALAHoZYBFF/0ULSYs49S8BYBnfV9pOkOlDZauUYP50JNPvJPPv"
"rApTWkP3qDV87Kqmz1lrRHPZ8q74yC+Tvpg4fG6IXE3wuLpf3h1ilwiuU/dVnRXQvQIXhdjl"
"AXfT4N8ECFwAgL8SeRi/V33fneb/jxA5DhO1K3e0j1Gaqq5/yQdbwj7bUV+68WR3YyQbfs/J"
"PSQyfDL7nlMH6Ehmf+qg1Ml4Eo5xBAGkRmg/AcA+FwDs5B4AGwA22ADgWQKQANBc8L2oSx1L"
"N75nRHnMU+JE9BPiRKQy/12PSgDY+YjVA8AAsIW06V4GAGcPgLEKwLMHYJDaAEjW/1PUZj9W"
"8x+n/y9RI38v8W0CDAQA3/6W+wB4FcAsMv9Zv6N/4zJx5PvLKdq/jEz+MjJ8Oi6Rx/TFvxOZ"
"KweJysQporMxz8f0YSJO028XnZ2dHE329PSKRvpeQWGxyMnNE5lZR9mAUsiIkJJOOHRYxB1M"
"sMoAJgTsjoyxIICzATtkNkCDgJ0RsHsEYJbr1m/kiNkLCDQUaDAw4WD4sCfZlGUkftMARWZu"
"yjB4Nnkfo79F3KbM/rZbbhO33wrdLu64DbqDJwLqGr+d6jeNfyefD5wXbf44X6b56/Q/zi/O"
"M853igIAXAdcD1wXXB9cJ1wvXDdcPxMGTnG5wAkDPW0V4lR+uCg/8D6XBk7sfUOWBw7IXoEK"
"juhliUBmAMb5zwBYOwmOUV83AeD9fgHAbgIcAACkjDcA4FNl/nIvACcAIOqH+WMM8Ayp3Bk8"
"DVAOAjJmAPAcABX9WwCwSEb/JdL820tDubkYAQabfjmZfvlqqUqpzkoy/Oq1UlU4rhNdNdB6"
"pXC6f61jAQrqC5ae3CuaCpsAACAASURBVLp6zI6bBv0vbF6kSwT3hfhmBS5T993/CPEuDwTs"
"E/hLe43Ldy4AwF/4AgRr/NjwQq/bRzoKnatYzoJxmLq2b0b7z8ybMWpZUdaq/O5Giu5PRpOh"
"x5D2seGfboojxZMOiR7SaUP4vOeUhIBuqPEgZwSCAgCrB2CdJwA0ZHwqKmNfFBX7niXzf5r0"
"pB8AeFiavz8A0HMA1rkAYOUQBwCkLwIAXCvSvpfd/wwAxuAfBgCY/1QFAFN+G2AVgF0C0E2A"
"Saj7f3cZRfyXk/FfIdLmkxZeKTKWXCHSl15Ox8v5WBb3sWgu3Wfd+JEeRqr4VFMTGccpTh+3"
"tLSKtrZ20dEho33U+3t6e0UvqaGhURSXlIrj+QUiOyfXBoDUNHE4OdWRBTAhQJcDUMt2ZAN2"
"7lYZAQ0CO1SPgBMGfIHAzhBoKNBgoAVD1ubMGiJ1SxCyf+9WS7dpkcGzyd8iTd40eujO2+8Q"
"d91xJ+vuO+9i3XPX3fT/Xc/PC88Pz1MbP54/zoMZ9eM86bS/af5m9I/zjfOuAQDXA9cF1wfX"
"CdcL1w3XD9cR1xPXFdcX1xnXG9cd11+XCfDorM8QDdmhBAJv8OoBCQKjRHnsu2q74DF2E2C8"
"sweAPydVm9+3AMBZBnCUAAICwJggAGACwfxEFwB8Qe/zr9RmQFN4M6CmbET7MP/vyPhnKn3H"
"Mhv/Wo7PVpMANQDMI/Ofz+bfVryEjZ9T/iek+bfpyJ/Nf40TANj0w9n4+VizgUx/o+iu3Uz3"
"LmgT3cc20nGjBILacJKEhIK0eflzp/9xWYgcSWxmBXSvwDXq/nuJuh/ruQL/+rcEAhcA4K/H"
"+P+uH+PX9X284NCkotP8WNaC2hWGYDxx842XfhAT8c2+tppdXT1NFOFDpyjKb6IIv+mgNPnm"
"RNJh0duSLHqbU+jjZKXDpCT6OdKpQ5wJkAAQR+ZPANCwT5q/0QPgBADXKgADAE7RG7smCV3J"
"z4kKivwrVPTP6f/o4U4A2EUAsOMhUbTtQSn0AKAE4AYAMv/cdbdLAFh9i8jW6f8VZP5qDDC2"
"AE5bgPX/9uCfw8bgH0T/SZj3P0Uq4WsXAKDZT20GFG8MAcL2wIdnkijiT5kL0/89Rfi/F5lL"
"riLTp+OyK8XxrU+KU4XbxJmeVr7B//jjj6Krq5sjwYbGRjYBn2jfMH5Eimz+jadEWXmFKCwq"
"FnnHTQDIFKlH0jkdrbMAJgQgba17AqJj7GyACQKIfGGEukfAhAGdGdBAoEsFAAKpTQ4wQLZg"
"0eJlypRJyqQHqjtcxm4b/J2WpNHfxZJmfzcLhn/PXfeIe++G7hX333OvmDlrjh3t61S/EfGz"
"8euon86Trvnj/Jnmr6N/nG+cd5x/DQC4Lrg+uE64Xr3q+mkQwHX1yQrQ9Zevg2Z+XeD1gcfZ"
"Pvq56kOiJuVrAoG3RNn+t1QXvyoNqGi/2oz2lfFX6881AMQZ6X+jD8ABAIGWAR4e678HwAcA"
"PnEBAHYC/JNoOjqdzH8GiUw+l8w9bzarmTXLNv78OXScY31s1v8lACD6l+bffmKlWmJMZl+m"
"zV8DwBpWZ5Uy/ur1bP6dMHxSd91WpW187KrbQlCgYYAgoXa9Et3HKsO69m77bN/NN/ynzgo8"
"ou63ejnhdep+rEFA9wn4A4G/+2sCgQsA8JcxfndXf3/GjzWqGFyBOhSWrGCoxR0hsoMVm2U8"
"9d7bj0/LOhya2dMEs99PRk9qpii/haL85kNs7KfJ8E+3pJLxQ2mit/UIC1873QxJGPAFgFhp"
"/g3K/Ouj6c2xWwHAdl8AIJkAgA17KuNeFhUHXqDIH+b/tKig6L9sDwDgCa7/n9j9uDT/nX+g"
"4yMGADzAywDRBKh7APwDgNoDANH/ssFkxjdIAOD0vx78I7f5NQEgEcYO40eX/9e/VRsAGQCg"
"1v3D/BN56M9l4vCsy0UqRfxHKNpPX3i1yAi9mkz/avp3rxbl8Z+K9pojPtE+jIGjfbrhN7cE"
"Nv4zZ86QifSJRvqdyqpqUVJaxrVmDQBZR7O5Ce1ImjMLYEEAygGqJ8DMBniBQCAY2BqxwwUE"
"biiwwQCaNXueZcznKx3FO81dGrxt8rbR33/P/eL+e+8XD9z7gHjwfuhB8RDpgw/G+pi+P+PX"
"UT+bP50/nEdt/mb0j/OO84/roAEA1wfXCdcL1xnXD9cxIAjQ6wCvB/w8Xh/urEB3U4FozF0p"
"l/UBAmJls6AGAc4AeAEAygJWE+C7PgBQFT9KlQC03MsAzUFAY/sBADQAfuQNAEeR+v9WRfxk"
"9Llk8HlzpY7LZcCt+RAZfQFWBdHX8ueyOPpH978DAKT5I+pvI7Nvs4w/zACAMFZnlYz6pTbK"
"iJ8if2n8EaK7HtouPwYQ1AMK8H3AgASCnvoNlo4emp353psPTMP9Vt1371f34ZvVffn36j79"
"vwYIAn+xVQMXAOAva/z/RxDGj8YTrFFF/Qn7ZGPJCqf5f3XRP4yYN+P90IbynSd7minCJ51u"
"oSi/JYFEpt9CEX1rijR9NnuYfgYp3VAafd+EAA0ACdL8uQcAALBXrQIg86+LYgDorN0REACa"
"CxeJ2mS6kcS/agPA3qc58i+nyL8s+gnScFHK0b8yf9bDoogBgMx/6/1yEJCxCsAaBWwAQPYq"
"AgC1A+DR5YPlJkCLB1H0f504EhQA/MYbAJAhgPl/Sz8743ds/CnfXylS518l0pfC+K8h479W"
"ZK24VlQkTBY97dUO48dNvr6h0dP4OdWvavzdPT1sGH19Z8TZs2c5gkS6uKa2jtecI71sA0Ae"
"N59lZNpZANSk3RCAmrU7G2CCAFLdkVGBYcAGAlKEEwpk/4AEAw0HH374CRuybc7nI23sToOX"
"Ji+N/gFl9Gz2D0APiYdJjzz4sNRDj4gnhw33NX163nj+nsavov44L/M3on+cf1wHXA8NALhO"
"uF64brh+uI64nriuuL64zrpHANffCwTwesHXTBDo62oUp/JW0XsITYLvcH8AInsr2o93TQfU"
"KwFi3/MLACw9/S/hXQcAWKOArb0AxgYGgLSPnT0ADAB/4rp/07EZbP7NubMN4/+eVwC15M8n"
"o1cqXCCPBAMtBAP20r+FTgDgtP9qw/jDDABA9L9WtHP6fz0bv5YPANQpAKhXMNAQoSBAwUD9"
"FjL+zaKnAdpEH5MaNoqGkjUn533zWuivLvp7rCDQ5YE71f15kLpf/y4IEPiLLx+8AAA/nfm7"
"6/zmcj7d3BfI+O9SL7RhF1/0DyO3hU/d0Va3r6uXDL8XUX5LIpl9Ehl6MomMnNTbRobfpoy+"
"LUOq1ZQCAIYAfwAQ6wEAegXADu8SAKkpbybdNN6kiGSEBIDYl0TF/uclAJD5l1PkXxY1nKJ/"
"Mv/Ix2wA2PEI1/+Ltj8ozR/adF9gAFh9q53+BwCE3kgAcIPIWCjn/wMAjszVJQBfAOASwNd2"
"GcAaBax2BjxMxp8E4597pTiy4GqRvuQakQHTX3kdCcb/eUDj16l+R43fT9QvzaLP+v3q6hoL"
"AJBiRq05N++4OJptZwFQizYhAGlqDQIH4w/J5kAvENh3gBvdMOgGUbAXDGBHPA0EbiiwwMDK"
"FuwUo9//gKPvB0zdO3BpU7f0gG3wWg+TwT9sGP0foIf/wHr0kT/wIKDH/gA9JlavWcvPD88T"
"zxfPG8/fbfwHlPHjvGnjx/l0mr8d/eM64HrguuD6aADAddNGjuuJ6+ovG2D2COjSQEAQyF8j"
"swFY78/NfSgJfGD0BTgBgE1fA0DcKAUAZPrx77LxS73nHwASP/AdBMSS6X8vAGjM+FpF/+j4"
"/47NvzkP0T+Z+3Fp/KyCBdL4Cxcakl/jqX9FC3ntP+r/bSXLVMf/atFRps1/rejAHiQGCHRU"
"rSMh9S9r/pZU7V8CgBIZf5cGANY2AwYixGk6nm6EtpL5kxoJCho3i16Cgvbq9V3bwibtuPiX"
"/21kiFxK+KC6TwcCAd0s6F4++BcpC1wAgJ826tcNfnqAzz+G2F39urlPp/q18aPxBDteDb95"
"8GWjk2IXJ/U0x4seivB7WxNFX+th0deWYpt9e4boa8+UZt+eRVIft2VKtWa6ACDdAIAU7gPo"
"aUpUACCj/+6GAz4A0KnS/5gWaI0Cxp4AZWuJ/j+mm8bbFgBUxf9RNv6ZABCtUv8w/90KAGD+"
"Ox4mkflHPCAKt9wnteleNQlQzgBwAMBaO/o/tgLmP1hkhd4odwHU8/8BAPN+r0YAmz0AHk2A"
"U429AGD+BAspc67giD9t8TW8dC9rxSCRufJ6UbZ/rMP4UcPFjbyuvsGq8evmPn9Rv9v8ccTP"
"IBrE36lSAIDUMgwG687zjudz5/nR7ByRmeWCgNQ0rlHrbIAbBNwZATcMODIDUTEWEHhCgQkG"
"qqnw5ZdeYUN++Dz1yEOmHpEG/7AWmfwj2uRJf7CN/vFHpYY99jhr+OPDSMPF559/6WP6XhG/"
"afw66sf5xHk1zR/nHecf1wHXA9cF1wfXCdcL1w3XD9cR19O8vhYE+MkG6GZB3SOAv4PXle4R"
"YBDoJrjMXmyv9/dYBshf1wAQ945d/wcAKNPnjX8S3vMBAKT/HQCg+gGwGyBPAWQAkOZvlwDs"
"JsDGjCkq+v+WAGAmm38zR/8q6s9HtE9mX0DmXggtFq1F0BJ1XKSMn1Qizb+tJNQ/AKhNyDog"
"Mv+OqvWiqxrGv8mWbv7juv82qfptTgBo2E7aQdrJx9ONO8Xpk6TG7VInIwgAIkRv4zbRe3Kr"
"PBIcJO2bkXTzjb/BtMHh6n59twECujSgmwX1qoF/DLEHCrkbBX+SbMAFAPhpjP/vQuw6v57T"
"j0ESWEeql/NdEmLX+HXEz8Y/5KYrxiTFLknqbZWmf5pM/3RbKhl9Opt9XwcZfccxOtqS5q+k"
"o3/OACgAYBhwA4BsBOw5ZQLAAXoj7DcGASkAqJENgJ01WxUAbOQUXX3q+6IuaRTdMN4SNYlv"
"SAA4+IpM/7sBIPJxCQC7/iBKdyrz57X/ZP4R99sAwPsAGHsBhN9JQvRvAwB3/3Pt/0bSDXL5"
"3wJfAMD2v3oVgHMZoJoDYAkp/8vY/NMQ9S+9VmQuHySyVt0gjm99VLTXpgnzgSYuRGzeUb9a"
"x083+kDmD+F7MAH8vhsAiopLOM2sswBIPZsQkJ6RybXpVDIrRKvJRjbAszTgBwasMoEGAjND"
"4IICBxiQYMaWHnnUNulgZfz+Yw49Jh57VEqa/OPi8cekhj02TAxTRj982HBO+T81/EnSU+Lp"
"J6GnxYjXRvqYPtf4PVL9OupP1lG/VfPPdJg/zr+O/nFdcH3cAIDriOuJ66qvsT8IkL0BHRYE"
"uLMBEF5n5qOnuVDUpnxh7QdgNwCO5gZATwA4+I4yfTvSx8d+ewDI/GvoY5h/DX3eLwBkfCka"
"M6eq6H+GAQDzbABQ5t9Kxt9Gpt9WtJTvH23Fy/jj1mL9uTb/5Sy95t8NAB3a/CvWsfn3DwBK"
"ngBA5t+4i3X65G7SLqWdlvro896TO5QICE5B20XS/hlJQwZfMsYAAZ0R0D0Cl4TYywcvCrEH"
"Cv19yF+gP+ACAPzvMX+vdL9Z59dz+jFmElOmsJwE3aRoJtE1/mHS+JclwfR7W5M40u9rT+Mo"
"v7f9mDjTmUPKZfV15Ik++ryvI5u+Bx1VCgAAqiQQNADUq/q/CQC8GdBmbt6pS31X1KWMIgB4"
"W9QcepNuGq+L6vjXAgPA7ke56a9khxr6E0HRvwcAHN9wjzJ+GfnnrbudzP92FwBQ9L/0BpG5"
"VG7/6wkArjkAehCQNQpYpf2Tvr2Mdw2E+Wch6l85SBwl86/LWuK4ASMqQ7RW3+CM+nWtH+av"
"o/5A5o+/00uf42dMAEAquaKyirvLZRmghKNNNwQgHY2aNEzKzAYEAgFHVsCAAS8g2EuRswUF"
"qmzAirbhIDR0pTRjl7RRB5LX7zmMXYsN/kkpZfJPPSkFo3/mKegZ1rNPP8t67pnnxHPPPic2"
"bdnqMH08f3/G7xv165q/r/nL6L+Erw+uE65XtQsAcF1xfXGd+4MAWRJos3sDjGwAXmf43MwG"
"4NFWHmk0BuoywGi7CVADgJKM+Ee7AOC9fgDgAwMAxvsBAKT/vwoOABD1FyrzL1omzb841D6W"
"hErzx5r/0uUs/wCwTqoyPAgA2OINAEb034MhaY0w/0hx+pRWlPVxH33cx0eIYKBppxIBQfMO"
"kXTgOw0CujRwp7q/X6fu979V93+934DZH/CTlQUuAMBPF/XrdL+u82OiFAZKYD0plpPcESI3"
"qXj85psuH50UG5oE0+9tSybTp2i/LY0j/b5OMvcOMvzOfHGmS+s4fQ4BBHIMAOgnA9CWYWcA"
"mr0A4KACgH12978HAGCaV/0RivxT3ukHAJ4T5QwATxAADHcCAEb+Rqiuf5j/Npj/vVIWANzB"
"gvl7AQDS/6j9Zy4ZZG8ABAD4/irZA+AFAHovAJQD6PNEfA3r+meT+S+8lsx/kDi2+kaRv/Ux"
"0VGb7rjposFLR2bo4Han/AOZv2z467PMH0cMkcHP4/ctAKipFVVV1RxVlpaVU5RZapUCNATI"
"ckAuN6QhOs3IzPIGAVePgCcMuIHAAwp8wEDBAZbbaTNmDT9PKVM3pc3dNvlnlMkroyc9/+zz"
"4vnnnhcvPPeCeOH5F8SLz78oXnzhRfHN9G/9mr6V6vc0fhn14/ziPON8O82/mK8Lrg9H/3S9"
"cN1MAMB1xfU1r7dc5tk/BDhLAnY2AK8/89HTUkRm/KVPFqAqXu0R4AIAnwxAooIAEwBg/Fqc"
"ARijpv+R+afA/D9k2T0AX3D9v5EbAL+V9f/sWZz+b0bj33Ej/c8AsNQwfkNI93PUH+oBAL4l"
"gOAAYJPVCOgNAMr8G3aR+UeyTp+MUsYPRYvTTVJ9TXtEX7M60tf7miNZvc0EAy2k5p2spAMz"
"k26+8bcoDTyu7u93qPv9Ner+/58hzv4AXRb4SbIBFwDgp4n6zXS/rvOjQQQDJbCeFNOmHvvV"
"xf80ImLjjB29XNNPkcaPmj6MnyL7M515bPh9nQWir6tQnOkmdRWorxEAdPgDgMwAPQBm/X9g"
"AIDU/8mjXxD9jyEAeE8BwNs2ABwa6QQAHv7zFEf/ZVz/VwCwEwCgzH/b/QQA90kA2HyvFC/9"
"8wCAMEgBAJb/aQDA9r88/pcA4HsZ/WMVgA8A6L0AUApASQClAfpe6jyY/3Uia/mNZP6DRcne"
"t8SZ3jbHzRapWNzgzZR/QPPv6pIT/QzzN6N/fAwTwO/oDAD+dm1dPUeTlSoLIEsBTgjQPQFm"
"NgDr03VZAEaGzWvcPQJeMOAGAp0hMKHADQYaDiZ/9jkbsY68nXomgHx/Xhq6KRi7rRfY4E2T"
"l0b/0gtSL7/4Eull8cpLpJdfEa++/Kp4/733fUzfXePHedLGL9P9zqhf1/zd5o/rgutTqaJ/"
"XDdcPxMAcH1xnd1ZAA0BXUZjYCAI0CUBvP7cJYGzfV2iIesHxywADALCpkNy+aAGAHcPgBMA"
"NBjUJL5vAYCeCcDNf2T+9aly5z+5+x+WAH6m0v9TCACm2dF/zhxl/j+I1uM6/e8FAMuVAgHA"
"Sjb/Dqvpzz8AuJsAO30AwOwB2K7MH9odBADEkOEr4eOWPfJjHFujCQKiSAoISBHrP93xq4t/"
"gVUDj6n7/W3q/n9ViN0fYJYFfpJswAUA+POZf39RP+ZHI+2DoRG6zn9PiBws8XTYyi/DOxoT"
"uvraj5BppyvjP8pp/TNdZPxk8NLsi9j8+7qKCQCK6PNCAwBy+geANhcAtJjp/2Q5CAgzACwA"
"iDUAQJl/7W5O+5889pVoTB9PAPCBAoBRojb5LVn/P/QGA0BV/KseADCcAADmjwZAueyPU//b"
"VNf/NhcAcOMfaZ0BABT554TJCYDZK4e6AOA6GwCwBbAJAOgBcGwGpDTjcoaD1HlXiQz6/awV"
"g8WxNTeLqsNfCfejhW7IXuavh/r4NPwp83dH/4EAQE+Mw79To7IAFR4QIHsCCnkZms4GYF26"
"CQJ2aUD1CJDRcZ+AggEzM2ACgRsKfMDAgAPorTffYiN+wdRzbj3vX67ffVHrhRctscGTuWu9"
"TAYPvfISTF4a/WuvQK+J1159TYx4dYQY+Ro0Urw+4nWxa3eU9ZzZ9C3jz+Dzo1P9TuN3Rv04"
"3zjvbvPH9cF1qlHRv57wGCwA6CyAuTpANwbq4UFeEIDXo/vRXLBOzQgYIwcGoUkw4X0LAnxX"
"AdgAUGVIA4BsAlS7AVL0X09Rf30qmT8Zfz1H/p8Z6X8NABT951D0n6Oa/8zo/3wAAJ3+MH80"
"/rkBoGKdagK0VwF4LQXUTYDWLAALAFT0fzKKdfpktDR+BwDsMQBgL31MaoH2k/nvU6Lvte6x"
"QOBMK903G3Z0hS0bHx4i9xx4RN3/dX/Alcof/r+QILMBFwDgLwgAId4d/oGifiwH0el+Xed/"
"4v13npl2qubAyb6OI9zUd4aj/WOczmfjR4q/u0AZfaECACn5OX2v0x8A6B4ALTcApNGLEzMA"
"7Oj/NK8A8AcA2vw3UuT/Gb3RJxIAYC/w0aR3DQCg6D/hdRIaAP8oqqwhQM/y6F8NAKUU/Zeq"
"oT/FEQ/4AsAWAwDCAQC3MwTkIfUfdqs9/ncF6v8KAJYMCgoAkmcofSeVMvNKzhagd+DoCor8"
"1wwRVclfBzR/R81fNfzJ6L/dM/r3V/s3AQA/r5eEObIAHhCAmjMaz+xsgFwh4A0CukfAzAoo"
"GHCVCZKN7EAgKDDhYHdkNBswom2Y8SvKmM9VryhTZ71sm/urr7gNXpr8iNeU0Y+A0Uuzf2Pk"
"G+KN198Qb77+pnjrDegtMfO7WdZzlqZvR/vS+LM9jV9G/YVG1C9r/m7zx3Uyo3+99BPX1QSA"
"QL0AvlmAdkdjoLMnIBAEhJPJj+XhQHJq4GiVCXjXAIB3AgDAuwwA9jLA8TwOWEb/GgA+JSHy"
"h/l/KdP/BAAns6ar6H+2aM6dFwAAzB4AfyUAmP8KVvuJVX4AQIq/VrWWlwICAGzzN4YBcQ+A"
"CQA7WD1W7R8AEM06fWqPoRi6P0o5AKBZmX9LLJn+AdHXRsc2OrZKIOhtiRFn2qIJAqJYTVWb"
"T45+51EMFHoixO4PMMsCwWYDzrskcAEAfpqoXy/rw+5SnO4fetOVo3MyNmaiqa+vI4ON/0xn"
"Npt+H9f1C6QQ5XOkb0tmAFwAgCbAYADAKgGkKwBIdQIAZwASXQCw3wIALPc7eexzeoN/RG/2"
"CaIxbawvACD6ZwB4TQGAnAFQvu8Zq/7PAMDd/2j+e1AUw/w1AEQEAgCZ9mcA0ON/yfyP6fX/"
"i10AoEoAZg9AMs8DkEeO+mdfQd8n818M8x8sshH5e5i/mfbHzVdHeKb5n0v0rwGA08DGjnI6"
"C+AFAbonwM4GyBUCZlnABgHZI+AfBvwAgQkFrrKBGwzWrVvPJuyjV916zY9GWEZuauRrdgTP"
"UubOGuk0+TffsI3+7Teht8Wot0aJUW+PEu+8/Y54Z9Q7YtzYcVak72X6OE861S+Nv8BK98uo"
"v8SK+nXN38v8zegf1xPXFdfXHwAEmwUwIUBOD2z0Ww7QEMAbCSWoQUHx7ysAeNcvAMgSgJ0B"
"kAAwlt7bEw3z/4j0CZt/ffpkaf6ZX6vo/08UIHyrov85CgDmq+V/qvvfAoDFLgBQWQB0/CPi"
"18fSlSQy/xOrfQCgXX9coT62AGC9ZfydZgnAWAYoo3+d+t+lACBqAACwT6rlgAIAmP9BUpwt"
"goKz7fsIAvaSFAyQctOWZA696RLdH3Cf8ge9bPAnyQZcAIDzj/r1un6zw19H/brJD92fWA6C"
"PaefClv5dXhnU3KX0/hliv9sd7E0+m6V4udjsQcAFBoAcLwfAHCn/5X5YzpgQACIcwBAR80W"
"cTKb3uhHP6E3+Ucy/Z82hpf+AQBqk98mvSkBIB4DgGT0Xxmron/VAIj6f1mkBwBsdQHAZl8A"
"QOof5u8GAET/R5e5AEA3AfIqgKt4N0C5I+CVHPEnk7A9ML6HoUHS/IeI4siXfW6kuEnrm7s2"
"/3OJ/v0BgJz+12c1grk3j9EQgPQy9wRUVZHxVHL0CSOS2QA3CAQHA3aZIEsZowQCNxTosoEb"
"DKC5c+ax+bIRs6QxOzQyCBk/b/2tNwxzJ2N/601l8G+9zRoFscmPYpN/b9R74r133hPvv/M+"
"1/1Hvz9afACN/kCM+WCM2LRpaz+mn2+l+t3Gj/OM8y2j/kq+DrgeNR7mb0b/uK64vu5r3h8A"
"9JcFMCEA/76506B+NGTOVNsIj5WlgIMq7R9vDwGyVwH49gBoAOCmvxRt/qj9f6Z2/vuCjP8r"
"uicg8p9G5j+dNKN/ALCWAS61zb9khSWe+sfmj8h/NYvr/64eAOc0QG8AMAcBaQDo1gDgMP9I"
"AwD2iF4y/d6mvUr7yPz3sjjtz9H/fikfAIASSPH88dn2OFIs60wbwUA7YGCPaK1a17XqhzdR"
"FnhK+cNdyi+uDXFmA+ArOhvwZ5sbcAEA/jwpf6zjxL7Q7lq/jvoxM/rxZ56695Oa8n0VZzrJ"
"+DuPWhG/Nv6z3SXibE8pGX6JHfl7ZQB0E6CK/oMHACP1z0r1BQBVAug+pacAymWAHTXbxalc"
"Ivxjn0kAyPyQ0/9c/095X0b/h8n8D78hain6rz74GumPPAEQAMDR/96nePQvzL/MWv//sCwB"
"MADc55sB2GIDAMyfAWANAcAaaf6Y/68BgJcAMgBcr1YByGWA2AsAuwGmzpEQkEKmjy5/y/wJ"
"FDA/AOZ/fOP9orejxucmqgfzDCT67w8A3BCgU8FdfnaQ05EexszCdBB1VqpsgBsEdGnAmRXw"
"hQFZJnADgcwQ2FDgzBRoMDDh4LNPJ3OUDSP2kTbpgBrllPH7OnrXgrlLg3+PDZ5N/j1l8u9/"
"II1+9Bgx9oOxrHFjxnLkP37ceDGBNPO7mfy83abvG+3LVL/b+HG+K3XUD/On62H2hLh3dtTR"
"f59aBmiaf7AAGql6aAAAIABJREFUEGwWAK9T9+NM9ykC88/kVsIqCyA7/11NgC4A0KsA9BRA"
"mH9dijb/Twn+P+emP+hk1lQyfZj/Nxz9nzz2nUz/EwC05H6vJv8tCAwAJQYAIOI/sUpG/jie"
"WMOyAKDMPQbYzgKYkwAt8+dVAFssALD3A9Cd/4b5N0ar7dLJ/E9J45faL3op2of6mlTkrwGg"
"1Q0A8RIA2hP4eLYDiicAiJcw0HGAIGCf6KwNFy2F80RJ+syKZ4bd9EmIzAbcH2JnA9y9Af+s"
"/ObPUhK4AAADS/lDXil/zHn+txA54MFd6+eof+e2udvPdGaSWWe5jL9IGf8JqW4AQKkz6vcC"
"gM6CcwQAO/rHuODTFgDA/JN4K+BucwZA437u/m8umCtO5hDpH6M3/tGPRWPGRCL/sQQAowkA"
"3uPufwaApNcJAEaS+b9KeoUnAFYeUMv/YjD/fxib/wmu/3sBwH3OHgALAO6SABAmzT93zVAJ"
"ALz87yaO/rPUEkDImgMw/1qShIAjc69ipTAESCDA9/DzGCOcs/YWUZ8d6nMDRWo1mOg/WAAI"
"mAXoU/PiPSDAnAxnZgPMsoAGAXePgAQBGwbMzIB/IJBQ4M4USGVZcHAwPkGZrxQibhjyaGXO"
"A9FoFbGbMo1dmruM5CE2eRj8mHHS5MeOV0Y/QUwYP0FMnDCRNWniJNaHkz4UH3/4MUFLmhHp"
"S9PH+TGNX9f4TeOvMI1fRf1ekx9N8+d9HvoCR//nCgBeWQCvUkBbRQwZ+jiZCUjA+v/R6ugG"
"gHdV+l8BgDUCeLwNANr808n8VdrfMv9jM5TOFwBWWVG/VJgDAHz2AnAMAvKaBLiZAaAbssx/"
"uwsAlPk3qq3TLfPfr3SAzF+qj7XfPgIAWuOk3ADQfogMP5F0SEnDQBwDSmvRQtFS9INoLZkv"
"tqx8b3uIbzbgGuUr/6F8Ru8r4C4JDHiVwAUAOLd6v07560Y/jHfEek4MeEBHJ/aMRk3n8aE3"
"//6DkoLoAjb+Lhh/Lpl8vm38ZPZne8psdZ+QGQB0+aumPycAFBoAIM3fBIBen0FARz0AAOav"
"m/9M86fov4nM/1S8AoD9PP0PG3Mg+ncCwAQJAKj/p7zrAABO/8cBAF4m88f6/2c5+vcLAFYJ"
"wAUAXAK4RxSsJ/Nfdyebfx6ZP1L/OauHsPlnY/6/AgAuAQQCgHlGKWAusgLX0M9dx70D2QQU"
"+Zsf8Fnuh4dX9H8uAOCvDODuBbA2jTEgwNxC1swG6N4AfxkBGwRsGHBmBpxAYGcIvKAgV6XM"
"nXCwdes2abwkmDCbMQnGfD7iv2XINndp8BNh8OOVwU+Y5DB5bfSfQB9/Ij795FPx2aefsSZ/"
"NlmsXLnKEem7o3238ZsRf7Vh/O7Jj2YZyDJ/tSugaf7+0v/nCwD+sgBnz3SJ2pTJKgswho4f"
"SAgICAB6O+Dxaukf1vxjyZ/e8Q/r/adyx//JY8r8s2cqzbIAwLsEsMjZBBgUAISR+YfZPQA+"
"kwDXGZMAN9hRP5v/VhX5b7VT/z4AEK1S/9L8e07pqF8bf6wLAKBYJwBw3Z/Mvz3eMv++9kQF"
"AIkGCMisAP6vaHRsLaFzUUznqOh7UXRkesXg6/47th/WvQG3KF+5QvnMfw9xNgjqksCA+wIu"
"AEDw5t9fyl+v678jRI6AfDJs5ZTwrta0rrNdx8isc8jIlfH3yFS/1AmH+fsHgEJLEgDkACAJ"
"AHkMAGz+DADHPAAgQ20MlGabP3YLxLr/5kSO/KXiFQDEMgCgA7cpbyoBwFf0pv6c0/8NqgEQ"
"9f8GjP5NfscAgJGiBun/2FdU899zomKfiv49AUCuAPABgK3K/DfdLQow/W/tHWz+iP5zVg0R"
"OWT8WPrH8/+XDXYCgFUCuFaWABwAcDWZ/1Xc9IcmQRn938TRf236HJ8bJ27Y5s1+oAAQqAzg"
"lQXwggBz+1h/68E5I2CWBrhHwAsGAgNBICgwwcCGgzyxZMlSy3wtTbClo/BgNUkbujL1Dy0p"
"Y5/0sRQb/CfS4LXJK6OfrIz+888+F19M/kJ88fkX4ssvvmR99eVX4pvp3/Dz0oaP8+IV7eM8"
"mql+L+N37/dgbfTkYf7u6L+/9P+5AAD+j+5JgXi0lm3nLEAVmgIT/QOAPQjIDQAfibojn1rb"
"/WLaH8y/EZF/Nsz/O3GKjP9U9mwWm78FAOYqAACANH9eBmj2AGhZqf9VHgBgzv831v9rkfl3"
"cPS/RRq/lrEBkL30DwCwywAApP5h/vtZMuqP9REbf4sXABx0mb8JAIdsCOiEDonO6k2ijZ4j"
"Vji0ltD5KF4oWop/EPV5s7qWzebegCeVn9wRYs8NuCQkyJLABQA4RwDwY/56jj+6MjHC8T9C"
"7JQ/UjXYAOLRX130/44oKYjKP9udTYaeI86SUZ/tLlDGrwz/dLnT/P0CgFvS/G0AyFOjgHOD"
"AIA0NfgH5p+sACBJAUACveDjSWoL4JMH6I0VRuY/RUb/uV/SG3yyAoAP6QaABsAPCADeo5vD"
"KNJbZP5viJrEEQQAr4qq2JdIuvnvKWn+aACMlsN/TuyW8/9NANAp/6Jt94qCrcr8N94l8vXS"
"PwDAahn1Z5Pxo/Nfjv+9keXVBOgJAN/L6D994fW8cVA2/c2cdbeK7uZCn5smpq2dCwAMJAsQ"
"CAIwPc7cMMbKBrR4rwm3QMDMCnjAgJkdcAKBXTIwywa+YGDDAQwV5usWjNlTH3roY23kvn/H"
"jN5Nc9cG//lkmPzn0uSV0X+ljP7rr74WU6Cvp4ipU6aKaVOmielTp4vp06aL6OgY61z4M32c"
"x0DGb498dm70hOsWyPwHEv2fCwC4pwTya7mDnlPieC4DMAAkqD4An90Apfk7AWAiR/+y8U9P"
"+1Pmf+xbMnyn+Z/KRup/npLaAdAaBNQfAISqJsCVvgDA5r+O1V4RTqJoH6rcYIvMv6NaRf21"
"22w5tgDeYUX/3TD/hkg7+j+5TwEAmX8TDD/OVos89kEtCgSQCUDtv1Wl/h3m7w8AkhgCOglS"
"2glq2srWEAgg87GUQGARQQCdJwKBnIRv8ofedMP78JUQOTdgSIizJPBr5Ud6P4EBQcAFAAjO"
"/M16v+7yxxaPl4fYKX80bgz76rORcztbKOqH8ffkkQrEjxz1q1T/aWX+DADlBgDI+r/sASix"
"0v2m8WvJsb+2+WNPgF6d/vcBgCwj/Q/zP+Iwf276Q+SvzL/nVBxH/521EaLpuIz8T+WQ+ed8"
"Tm90mf5vyJxEN4Fxqv7/rqg7/DYJo38p+k+k6D+Oov8DL4pKRP+69r9nOEf/J6Io+qfI/wTP"
"/3+IxQCw9T6O+Fkw/81k/hvuFPnQOjX1b/VQkUvRP8w/e8Vg2fkfeqMFAHYTYGAAwNJAfJ3X"
"/BNA5Kyhv0sA4PXooJvwQABAbvzjUQZwZQGChQDHGnEjG+APBNxG4A8G0MGugcDMEHhBgZkp"
"MOEASk5JlZH151+y+X5harI054FIG7lbOnqX5v4Vm7vD4ElTlcmz0U+1jR7RPsYAf/vNt2LG"
"tzPEdzO+40bARQsX8XkIxvR9rrth/O6o35z1EIz5u6N/r/S/nggYLADgdev18AUAexiQAwCS"
"xrCcAPAJAcBkY9rfdDZ/pP5PZc+k+wQZP0X8FgBg61/WD+cAAKr7nyHABQBk/B3K/NsrlOlj"
"N1LWZl6t1MHRvzR9U1bjnwUAu0iRjsY/CQAH6N5I5t8UFxgAWuIkBAQFAIkeALCZAUBqtYSA"
"E6GitRSbIC2k40JRn7+wa/KE1+aGyH0F7g+xSwKXKx/SqwTMpYJBQcAFAAje/PUSP13vR3fm"
"DaTbQ2SK5ql9O+fuZeM/nU+Gflz8eLqQVCJ+hLmz8Vco86+QChoAVLOfGvvbS8bfy+avAKBD"
"A8AxFwCYewGku1L/ZP7Nh+hFnsBpf23+PSfR9R8jWvK/oej/awKAL+nN/IUz+s+cyABQT9F/"
"PaJ/BgAV/R/6o6iOfZnM/3lRic5/TP6LeUKaPxT5qASAnQ9LANhO5h9xvwMACjZT1L+JjH/9"
"HaTbRf5atfafzN8LAHxLAP4BIA1zAX5A+v86/tmj9LdywoaKwp1Pe94w2+kGHAwABFsGCNQQ"
"6AUB2jTMbIAXCFim0OQ2hQZvGDCAoLLSzhD4gwITDEw42LRpi2W6phBxTzHMeUDC7yqZfxOm"
"rgVj15IG7zR50+ihWTNnidmzZovZs2eLuXPmkOaKeXPnicTEw35Mv8F5rZt8l3uaxu+O+v1d"
"x4CNf0Gm/4MBALxuvR516dO4D4AjfN4L4F0jA6CURN9LGsuyRv9qAODOf53+/8Zq+DuVM0sB"
"wFwJAZj+B+N3AMD8cwCAFSoLoAFgnQIAMn9sP15J0X7lJrUj6RbemwQ7lGKb8q5amP52QyYA"
"UORfv4uj/25H45+M/mH+/QMAdFAeuQFQA4Bt/E4ASHKVABLlMsYy3c+whmGnrWwVQQDKIMvo"
"uJQgYJFoKVkkdq3/Zm+IbBB8SPnODcqHdF+A3lQoaAi4AAD9m/8v1ElF0wU2bdD1/sEhssv/"
"kYsv+sWIquLdFWe7c8nIyfxPF5HxF0nzP32CZEb+FUYGoMwFACUsuQLAjPzzVbe/bPpjAOjI"
"tcz/jBX9H5NqN7cDltE/b/jTqlL/bP6JpAR6kZvmH0tC3X8JRf9TCAAQ/Svzp+i/8ehHbP71"
"GXr9/7sSAJJU7f8QRf8JL1P0/wKZ/3MkGf2X70Hk/7iM/iNl9M8AsP1B0v2q/q9r/neR7hDH"
"N9wujoffJoXO/9W3ipxVN0sAUCUAAABKAAF7ANAEuOAaMvxrOO3PuwPSx+kLrqefvcGq/5cd"
"eM/zhtnd3RMQALyzAO3nBAH+GgN9No9xgYB7L3l3VsDLIBxAYEFBtQ8U6EyBGwy05s9fwGYL"
"4zVlm/K5yf33TGPX5m4a/EwyeMvkSXNmzxFzlMlDP8z7QcyHfpgvFtD/eeGChZwBCA9f73l9"
"3dG+WeN3D3nSxt/n6vT3avg7F/PXkOeO/gMBAF63Xo/GnIUKADAcaLTvXgCQBQDj7F3/kidx"
"/R8AoDf70cv9TnL0bwIANM8FALoJ0OwBIHNz7AK43DUIyAUAZb4AIM1/szT+ajL+6m2cvYS6"
"are7AGA7AYAc/MPGz+YfpQDArv2fVtG/JwBYPQAmAByU5t8aHyQA2KWA9jIDAHh1A1Y2rOYd"
"D9vLVoq28hUEBNgRcbFooftyccaaiot/+U/YU+AR5T+DlR/9VvnTRcqvfhEMBFwAgP7NX3f6"
"o+kCzRdXh9j1/seeHjb0k7a6A10/9sL4C0nFyvTJ/Hul+f+oDV+n/QMAgDUAyAcAjlvq5Xq/"
"TP1LANDmf9QDAPSOfzr1n2xE//H0YjfN/wDXpJqO/0lF/zD/zzj133jsY3rTT2Lzr7fW/78j"
"6in6r018gzSCbiiviOr4F0UVov+9z4gKdP5z6v9xGflDu2XdH9IAgKa/oi3K/DcCAMj8198q"
"jq9TUkN/AAAQA8BK1QOgmgCtEoAbABbIo5UNUBkBAAB+Xi//K977tucNUw8ACmgQAbIAwUCA"
"V2OgVxRplgU0CJilAbdhmDDgzAw4DcPMEPhCgQkGTjjIzy9go9WmqzVLmbHWzAGKf8/1Ny1T"
"V0IEz5o7Vxm8MvkfDJPXRk9avGgxa8niJWLpkqVi2dJlInRZqAgNDRX5BQWOSN9t+m6gs1L9"
"Pc4yjvtauaN+v2l/P+YfbPTvBQBeA4HwKE+ZKZcDJo5VKwHe9wCAMWz+Nbr5D+bPy/8mSwBQ"
"s/4x7Ed3/fsCwFyjBCCXANrLAFX0T+bvAIAS9yCglUYfgAaAcAUAMP+N0vyrDPOvhvlvZ3XV"
"7TBEn1uNfzLt390gzb8b5t8oo//TDACxPwkAoGxgpf8dMw3WSAEGKrDEEVmB5dwf0EIgUF+0"
"o2v4o3djZsBjyoduVr6kmwP1CoF+IeACAPRv/hcb5o/mCzRh3EsaNu/bN5diy94fewvFj30U"
"8feWSvPvLSeVySMDgJEB6DEgwDR/9Aj4AECBBwDkuQAgm3TMBQBH7ei/XUf/qcr8DxvR/0EF"
"ANL8uxv30htzBtf+ZfQ/mcz/E3qjk/kf/dCK/uvTx9LNYLQBAK+TKPqPp+j/4POiiqL/ipin"
"CQCelIN/OPJ/lDf+Kd31sCjd8RDLAgCK/otQ8994pyjYcIfI3ygBIG/tUNbxNUPJ+Idy53+O"
"iv4ZAFZIafPPWjrIdxBQEACQSwBQEPWG5w0TDximBoBgswDnCgFeJQEvEPC3naw/GPCJHpu8"
"DcQNBSYY1GgwUHAQH58gFpDZzrekDJiM+AfWPId0NB5ITiM3BVO3pc1dR/KQ2+S10S9TRr88"
"dLlYuXylWLVylVi9apVYs3q1CFuzRkRFRvWbxfG3ksPftQmU8j8X8w8m+tfXDq9Xf4+8A18x"
"ANQkBQsAE63lfzD/ep76NxAAQBYA5r+Q1Zq/yEr9txaFsuwpgB6DgHQTIBvlWgUA6w0A2KIA"
"YJsPAHTX7STj32kAgFn3j1IAsIcUo9L/+w0AiGM5zd+rBBAvBfNvTVBr/00ASPQuAXTgHrzf"
"AIC1tnh1Q5hc2lgZLtor10kQKFslWgkEuD+gYoeYNW3i0hDZF3BviN0cqCHg4mAg4L88AAQw"
"f532N80fOzdhXebwrWs+3t7XdoRMnoy/j6L9Pm38FaRK9bEJAKoPwDL9csP8vQBAGX+Xc7lf"
"/wBgmn9mwNo/AICj/1My9d9OL66W/Gmy8z/vS3oTI/r/2AkAqP0j/X/kfQMAkP5/VQJAHADg"
"2QEDQOHmu6T5o+a/gcw//BaRFzZUCsv+AACo13P93w8AqOifewBMAFioAUCXBK61AWCVDQC9"
"Pb4DVPDw1wfgzgKcDwQEkw3wZzbBzJP3CwQtLY6I0gkFTnPR/QRaGzZsZJOF4WppE2bBlJU5"
"D0SOv2GYuhabO4xdiSP5ZdLgl5PBa5NftQpGv5qMfg0b/dqwMNJasW7tOhG+LlysD18vNqzf"
"IDZu2CDKy8t9rlWwY5wDGb9X1H8+5h9M9O+v/o/r5xcADo1W3f8uAEhR0b+q/9enf6nq/9Ot"
"9L8vAMwzSgAGAJip/0JE/8tZZtrfPwAgVY7uf2X+ngBA5l+zXQEAGX3dLq7zSwjQALDTEf3L"
"pr8YTv+f1ul/BoCDrN5mKF4dD0oA4KhfGX9LghSP/T0kZRl/kqWzHYcVACRZPQAoQdgAsM5W"
"xTq1vFHOM8DmaxBWPbQRFLShNFBG569is9gSNg+Dg4YrXxrqgoB+ywH/pQHAj/nrhj8v80cH"
"5hMJUd8e6m1JJNMvJlHU30cmf4aMv69SmX+VAQDlHgBwwmX+J9QI4GIDAJTxaxlNfwEBgKN/"
"Gfnzuv82td2v1fmfqMw/3gCAA/Tm2ClaCr+xASD3CwUAn/QDAG85AeCgBwAYJQAGALMEEKEA"
"YNNdZPwAgNsUACjzDxtCAKDS/ujYx7x+BQHOZYASADDYBwIAZCyUEGABwPxrJRTQ5xkLB/Hv"
"mQDQ0uQdOeHmrk3PKwtwXhAQRDYgGBAIBAPdru5yNxD4dJgbUGCCgWk6JaWl0mRJK1dK09WC"
"CbMZk7Q5Byv9e9LMpfjv8r+zymHsrNXS4NeQwYexwZPW2iYfHm4a/UaxibRl0yaxddMWsXXL"
"VhGxbZvYvi1CxB+MF53qHHUPwPT7M/5AUf/5mL+/6B/ymgGAB/Zw0ADgKAGwNACMNgBggg8A"
"NKR/per/33gAwBxp/rkYHPaDTP1Dxxew+bfA/Atk5N/Gxr9CqiRIAED07wMAm4MEgB18j5ON"
"f2bdX5o/Ov99ASBemj8ZfG+L/liqr4WMvtUQm782/cMuJZPhJysIUCDQmSQ66f8kmwDlc5Or"
"Gtbbyxsr5XJGqS38XNurNok2ZAVQFqig81i1UxyMXHUoRO4seH8ACPBsDPyvDAD+1vmbDX8e"
"5v+nQz3NsdL8z1DU30cGf6ZSqq9KmX+VnQ04Xa56AE5IGaZ/xhr7q+f/FxsNgEbaPyAAuHoA"
"rGV/0vx7244Y6/5V8x+bf7zoaYqzAKD9xBIbALD8jzMAk+nN/al/ANANgA4AeMHoAdAAMMwv"
"ABRHyPq/LwDcIksAAAA2fzL95Tf6BwAy/6wl17sA4Hpe688rAiwYUN9b5AsAdTV03ehG7vXw"
"Wg44UAjwagz0WiYYDAicCwzonoFuj+jTNB9/YGDCweHEw2yyWjDdtdqASWGm1oSxQftTGCvM"
"lvG72tC1pLErc1dRvGXw2uQ3bmJtUSa/bStERh8RwdqxfbvYuWOH2LVzp9i9a5eI3L1bREZG"
"0rWtP2fT78/4/S3zczf8DdT8g13+h7kAWyN2BgkAYzn6rzHT/6mfBgAAI/pn81cAAONnIfpX"
"Hf+FMH9l/MUrWe0lUtL8V/oBAFf0P2AAIFld/1HS/Bu1+ZPxn9TmrwGA7pEc+cP8D9lqlTrT"
"mqiUpACAzL9NGX5HslKKdTzbmeKEgM7Dor16qzR+Nv8NpI1S1uoGAMBWFq9soOfYQWpnEEAT"
"5BoFAVGBIMBsDPScE/BfHQD0eF9MUtLr/LGkAl2VaKxAbeU+af5TyPz3y5Q/zJ+Nv0qpmr5e"
"bQBAhQKAChsAdKpfSZp+icv8i6wd/sy6vym/AGCt+1dDf1ipdvrfAIAeRP8KAJAaay381gEA"
"sgfgc/8AwEsA3yYAeEPUHhopl/8RANhNgM8aTYDD/JQAHvAAAFkCsHoA+gEAngOw5AYfAMAa"
"fx4HrABAZwP4a/jeYvqdZfS3VtsAUFtVIdpafMeo6gfq5ucDAeaMgGCyAV4gECgr0B8MWEDA"
"JhUgJe0JBk44iNwdyQarzZZF5rvRlDZlQxsCyOfnVcRuSZk6G7s2d2XwiOQjtimDj9hOJr/D"
"MvldO3eR0e9mo48io4+KihLR0dEiJiZG7I3ZK/bt2yf279svEhMTgzL9QNF+f+n+QFG/CVzn"
"Yv5eI4D1A3s5bNi0zaMEMNqSHgBUc3gcm38Nmv/0tr8uAOASgNUDoKL/3HkuAFgolb9Ypvwt"
"84fxryKjX81qL9XC11ZJCDABgLvjBwoAsgeAI34t7vxXa/5h/o1qzf9JI/LX9f/meO6T6m3W"
"5p9IShLo+YJg/GfacDwsIaAtiQHgDEX7Z8jwpVL5aAOAUkcyH9srNtHz0KavljNWbnLONKiW"
"Sxo7a+i5VW/nTdkYCrDssRoQgEzActFaudeEgPuUb12tfEwvEfxH5XPm3gH/JQHAjP71bH9M"
"UsImCxiq8JsQubTiZnUyh8fv/vJQJxnlWTT8nSmT5n+WDP9MjZICAGQB+kwAUCUAs9bPEwEN"
"07fS/kbznx/zHxgAHFEAoNL/rhKABoD2cjTjzAgaAOrSPnAAQE3CaySsAHjJyABoAHgiaAAo"
"8AcAKAGs0CWAm3wHAbkAAD0AGYsHsdIp0vcCACwBzAodzFMATQCA+jymqOEBE2g81eQoBwQD"
"AYGyAf2BQDBZgYHAgO/SNF8osDIFrmyBhgPUy2GuLDJaRNRsukocaZMZRzi0bQCKsKJ1qe3y"
"3+B/S/6bu3bsVOYuo3ht8AATmHw0TD6KTD46Rhr9XtvoD+w/IGIPHBBxsbHiYFyciD94UCTE"
"J4hDCYdEfV1d0Kbfb7QfpPF7Rf0DMX8Ir0t/qX/8rU1bInwBAFmARD0WWE7+q0kao6L/SaKG"
"t/5V0f+Rz7gB0O4BmOZaBmgDQBOZf1PufDb/Vph//lJV7yfzL0KET5FrSRiZ/FoWd/iXQmuU"
"yNRKjX0AuEZupP91dFy1qd8mQCcAkPk3GNE/A4Cc+Gd2/nP6XwOANv9Wbf6HWWdayejblPB5"
"uzJ/BoBUpSPW8WwnlKqUwmWF9goy+EpTW6T0TIMqZfw1CmyqdxAA7GAIwNd44FH1BtFeReey"
"YpVorTqoIUD3BNysfOw3ytf+Vfmc3jsg6CzAzwkAvOr+2FABM5UxVhGTlTBcAbv5YfTisITd"
"XyR01KynKL5AmX+VNP+zMP5aFwBU+wJATyAAMLf8dXf9+5p/cACQrswfSvEFgGa7B6Crfrdo"
"LZ7pBACrCdAuATRkTSIAmMArAOrSRhsA8DqZ/6sMAFUHX1RNgM8ZywDPDQB8mgBXDuHoP2eF"
"TPvz+n8PAJBNgNc7AWCRFwDQ7y1XALDOCQANtdV+SwH9QYC/1QH+sgH+QCCYrEB/MBAsEHjX"
"sU0wMOCAdPToUY6gWVHRbLbopIfxRmrt1pLGDIMOJP1z9u8pIWLH32ZDl4qJVsYeLSN4lmXw"
"+8jgtcnHWiYvjT6ejD6ejD5BJB46RErkUsbhw4dFMitZZGZk8HP1l973Mv1go33vUotv1O+v"
"2/9czB//3+iY/R4AMI7r/HrgD2AAUMBKntAPAEwxAEAPArJLAAwA3Pi3iMx/iWgtCGXzb4X5"
"FyPSJ9MvDSdzpwj2BI7rlNZKlYZZg3/08r+BA4AuAVDUXx8pBfNnAIhxAQAi/zir8U+n/y0A"
"cJh/MutMa4oCAHVk8zeNH0qzdLYzTUGABIGepgMUvSOSJ/Fxmy1O9cuIv5MMn83fAQA7+Pmh"
"h6Cjln62ZhNBAMFUZZhorU4S8VGrE0Lk6oB7lI9dqXzt18rn/iFkgP0AP0cAQApE1/2xXAIb"
"K/xHiByviAlL2IrxsZXzXl/XXrlK9HVkCoFGPzZ/MvyztVIWANQYAFCtAECtAnCl/hkALPMv"
"VCpwdv4PFACstf8ZBgCk0ovVDQBqFYBaBtgBcvQLALoJ8CMJAFgCmDZG1KkGQMz/r0vUAKDq"
"/0EBwIMsNABaAOC1CkAtA8xbPdSxCuAYBgCF3qiG/9xgAMAgTwDIWGyXA+TXAgMA1Fhf2y8E"
"mOUAr9UBwWQDzgUE+oOBYIGgPyjwioDx/4OpQjBYGK2t/Rxh71dGvO88JP/OfmXm+61/A/+m"
"VlxsHEtH8drgExJkNA+TP5woTV4bfEqyrdSUFEtHUlNZaUeOiKqqKk/D79f0/0zG739VhrPh"
"D6+//sy+9j8VAAAgAElEQVQ/PiFRbNu+ywUA42WUnzSBj9VJUvw1nf4n86/VzX8w/34BwG4C"
"lACgon80/RVQ9I+UP8y/JMwwf6mOMgUCZSYIhLmWyIX7lgAcABDhpwdAdfw3RNsT/yzz15v+"
"xPFyaN0bxRlS3B91+t9l/gwAdG+V5p8qBfNvV8ZPZs+yACBdnO1S6kxnGMAuqx2VFMVXQUjr"
"b2fTZ9Vo499Jz0NJfd6h1Fm7S3TWk+ro81qUBjaL9up1oo2AorX6iFi+aPq6EDkn4C7lZ5cr"
"f/uV8jvdDxBUKeDnAgDu1L9Z90fH5KUhcsYyxiw+8sWER+e0VyynF8deNn+ho/6zdbbOGBAQ"
"DAB0S/M/6zD/QmPJX77o68Ksf2/z9waAYx7d/zD/VH6xWubPPQB6CuAhrn+1lcxxAYA9BOgU"
"ov9jH9Gb/UMCgIkEADL9DwCoSxnF43/r0AAYEADsVQCleggQRf6legTwtnuDBwDMAXADQOiN"
"vnMAlgzyAQB8HY1/+nv9AQCEVQGBIAANcV4Q4FUS+HOAQH8wcC5AMFAoqKyoZFNF9Cyj6ENs"
"tofYdBPYfJFOZyMmxUNszv0p3jZwVoKlQ8rQD6l/T0buSlb0ftjT2E1zN02elZYm0qH0dFZG"
"egYLGY6Ojk6/hh+s6Z+r8QdK+Zvmj9efP/PHdcXujbsio/0AwAQFAFLV+DhZqlaZf20KNv/5"
"1AEA3APgKAEEAgBE/6j9r2DzR+q/vXSdMv4NZO5SAACGgLJwKQUBHWVK5ar+3x8A6Ei5docN"
"ANr8G/TAH2fnP9L/DABN8cr0E1SAdEgBQGIAAICOSMHo25Xhk8k7lUHm71RHFRl31Q6O6qV2"
"2oLB15C51+wmg98tzb5Wfr2DPu7gz+nrBDed9fgZ+hpnA7YQBISLtuo4hoDJk96eEyInBt6u"
"fO1S5XPufoB+swA/JwBwp/6xk5Ku+6NpAhstPPj0o9d+dKp4UVdn9XpO+8P8hWX89QEAQPcA"
"lHsAgG3+Z72G/aglf94AkGvJPwBkeGQA/ANAZ80GelPOJgD4TjUBThfNx6fI+f+5kwkAPrEB"
"IHMCvfll+r8OOwC6AQD1f5h/3HOOZYC+APCgDQDb7hPFW6X5e5YA/AGAUQLwGQWMaYAEAhlL"
"sDHQDdzsh8/560uk+HtLFQCs8Q8A/WUC8DBXBwSTDegPBNxDaP5cMBAICLygwAsMoKzMTIe5"
"piRL2Z8n/xmV4mnmAU1dKd1l7tLgSRkZljIzMkUmPZ+szCzW0ayjbP7ZR7NFaWnpeZu+1+yF"
"gRh/oAFN/rr9tfkfPZoj9h+ICwwAhydaAICPa5OhSaI29WM2/1qO/hUApE3m6L8BY4CDAoAF"
"BgCsVACgo/8NCgA2sjoYAvD5eikAAJr+tDj63yDltwTgAgCu/+82AEAN/GlUxq+a/yQAHDQA"
"QJt/Iks3/vXRfZTV5gaANCkV6bM8ASDTEn6/o3oXS5o+zD7SFsy9NlJ0QXVR9FwiJQjUwPx3"
"s/hr9Ur0HBkE6ndySaAdWwzXpIjGE4ldTz1+70fwM+VrV4fY/QD/EuJbCvhZA0Cg1P//DLHr"
"/vde/K//1yul6d9WdFSuJKpLJ+OvYfMXZxvIDLTqDQCo8VgFoKYBWgCAur82/0KWucNfYABQ"
"Zu8JANlBAkCSvQpAlQDaTyygN+Usjv5bYf4FfxLNaP7L/ZzeyBT9Z3/M8/8buf6PCYAy/e8D"
"APF/tAEg9llRhegfAMCbAMlBQHb6/wFO/ZdEwPwR/cP87xSFG+9wrAJw9ACs9pgEyEOA5HyA"
"o6HGkkCCgKxl0uAt8ddu5KgfIOANAG96AoCGAH+NgXjAQP2VBM4PBHyzAv3CQAAg6A8KvMDA"
"hIOGhgbbWF1yG/A5y/13lRz/nsPUM2yZxq7M3cfgDZPPzoZyRHZOjsiBcnNFLiuPouc8jrDd"
"hh+s6XtF+wM1fn8pf39jfvFAAye2dMYujQMHgEky+k+V5m8BQNpktQnQ16QpzlUAVhOgbw+A"
"LAEEDwAweG8AWG8BQGfFRtFZuYnFXfIMAFudAEDm3+lO/zMA7FUAsN8WhqB5AYC6X0oAOKwA"
"IIUAQMoBAO3a/DP8AIA2/ywW/j3b8Hcr04/yURdUv4cgIFqCQG2kLQcARLO6+BgpOuoiCAT2"
"EARkiJKjeyp+/etfvxIipwXqfoD/GTLAUsDPBQB09K+7/pEKwTpJ7K2MFAk2V3gscsMHMR0V"
"S3lkpPixWpl/PakxMACw8ethQGUKAE4QAJQGAIB8vwDQx4avjyYAyN3/znRmKwA46g0AZgnA"
"ivxlE2BXw27RVjrPAoCWgmkEAFMJAHTz3yc8BRDd/42ZMv1fn/6BEwCSCAAOjXABwDOici+Z"
"/56nCADkEsCyKLX+fxd2AHyAzb+EU/93i6LNd/LmPwUbbpfm7zMIyAMArOMQkb1qCBn/zQwD"
"x9QGQSgLsOkzABAUoEwQKmEAIOAAgNX9AwCEGQFdnd4T1vQDUZk5Ke9cQeB8YSAQEAQDBV5g"
"ABUVFrGRWuaa4ZY0XzPKHqgy3SZumHmWQ1mGsdvmzsauRQafk63MPSeXDT7HMPg8S8fF8eNQ"
"vsjPlyooKBAlJSV+Df9cTP9cjV8rUNSPBxo2sXdDDj2/gQEAjsr8NQCQ8deqyL8hDal/iv4p"
"8m/I1OaP6F8uATyptwHWAJA331UCGCgA6Kl/4U4AqIDxq2V/VbpbXu0BoM0ftfK6XRwxd9dH"
"BQCAA8r843g3VKv+r6N/BQB9LYft6N8CgNRzAACY/1FWV/1e+n9GS8Hsa2Du0bbqpLrqyPzr"
"YyQEQPy9KFsNWjB/+jl6bp2NMfJrBAHttUmirTpdRG1dHBMi+wHuVD73O+V7vwyxVwUEzAL8"
"rQOAO/rHaETd9Y+tFHXq/6F3Xr1lStuJ+fTCoui/K5cAoO7PAADK/B0A4Gr6cwCANH1TNgDk"
"GABwjKP/M9b43wxXD0CKBAAj7X+6SY4B7qzGEpy5TgDIn0IA8AW9oT/j6P8kzD9romhE81/G"
"GLoZqPR/6ruiTq0AqD30mh8AUOl/HgMsa/8lO+XoX5g/Uv9Fm+8ikflvBACQ8YffKhUIALAh"
"EFYErIb5D2UdW0EQsHIIz/U/itkAnAmQysQxdPB5AwBDQHWlaGlq9Ft3xQPfQ8rXX1kgEAgM"
"BAZ0meCcgMADCrzAwIQDRMM5OlImceScnW3LNN6jR30+t6JvNmkvuf+GaeJ2tG4bum3quQ6Z"
"5n5c5B2XOq6kDV6bPFRYWGipqKhIFEPFxaKEVF9f34/hD9z0B2L8eB3h3wj0mtMPXFds2DQg"
"AFDr/WuSP7QB4MgnBPqTRR2v+/+S6/4c/ZP5N2Qay/+OGeafO5eXAerovylvkWoADB1gCSDc"
"CQBW8x/9XAWZf+VWGfGje97qltfRv2qOI/PvsgAg2hsALPM/6AKABAMATPMPBgAClQAkAOD7"
"nRSdd9bGqGO0S4j4Y2wRLFgQUKfhIEoeG7T2KADYT9pHEEC/QxDQQXDRVpspWqvTxKjXn5kS"
"IrcR1qWA/wyxVwX8or8swM8BANzRP6Yj/TvpMtKNIXLJxBPVOd+cbC9bTC8WRP81pHpl/g0e"
"JYB6PwBQYZv/6VIDAGzz9wUA1fXvAIAcFwDkKADIZvWR8Uvp2f/pUpgBoKJ/pK+cnf9yCWD7"
"iYUSALgB8FtfADj2Eb3RJ1H0P96K/us5+n+XIoR3RN3hNzn9X8v1fxcAxDwlyqOHk9QI4N0P"
"S/N3AICM/gs33U4AQMLuf+FK62+RAODuAcDUvtXYFwAAIM2fjyuHymwA6egKggDsDxB6k4QA"
"HFW/gIQCDQKDGRaCKQGYAAA11Nb2mw04c+asaCEjCAQCfw4YMHsGBgIEfsHADxyUlpVJM83T"
"ynN8nOul3HOQx99x/FuGmdvKdxh7vjJ2t8EjgwGDd5t8SXEJR/uo+0Nl9FwhzDuAWltbHefX"
"q6Z/Pqbvz/jx+sHrKNhH8AAwwTb+FLncrwZNf6kfcfRfR5F/HUX9darmj7Q/i8xf7gEwwwcA"
"mtj87ei/6bhK/xdg+M8qufbfWv6nzX+TCwDCPQBAN/7JdfLS/LexZOf8drVcTpp/V600/+AB"
"ID4IAEgJAABHVA9AIACwMwA9FIBJ85fqsiBAG/9eZfp75ccN+2wIqKOfZUVbANBlmT/9DD2v"
"rpMHSLESBOp3ifa6FC4FVOXHngyRQ4LuUX53mfK/i4LJAvytA4Du/Dej/38LkQ0RGJl4G+mR"
"TaEjItpOfC/aK1bIZX8/1ioAaDAAoD44AGDz1wCgzN8HAPKDAAClDi295v8YG38fGX8fR/32"
"7P/e1iN29N+aZKX9eW0rvci7GyPpzfg9aQ4BwHcEAN8QAPyJAOBrFwBMpDf9OHrzj1UA8B6b"
"f22KmgCY+BoBAMz/FRcAUPQfNYwkt/89seshmfqHtsvGv2Ku/d8hAYAifgYAMmLW+qHcA3B8"
"rRJ2A1x9C5t/7mpp+hYArLmFjreobIDMAshMgOwN6B8Ahg4YAOprqkVDXbVoamwI2BugQQCb"
"s5ip3EBZgfOFgf4yBMFAgRsOWij6N6NkqMBlsjqiztfKzz83qd93/32W/ncd/xfb1B3mXlTs"
"a/DK5Ms8TL4CqqhgVUKVlSwsCaytqfV7rgdq+v2l+SG8Xvozfr1E08wMDAwAJona5I8c9f46"
"6MinZPww/69EvWX+U6V8AMAuATAA5Ono3wCAwuUEAKvV4J91BADr/QCAaxVAWbiR+t+ohuRs"
"tQGAo361VI7Exq9VH+kCANkA2N3o7Pz3AQBzFYAuAVgAAKWy+fdZxu9aBeAJABkOAOgyzF8D"
"QJdp/nUwfC0AwH4bAuhnOgkEOutUScA0fzJ8af5xooueVzcggL7fWR8r2muPirbqNLFlzZyI"
"ELkq4Dble79RPmhmAfSKgJ8NAOj0v1f0j7WRg0n3XvTPf/fHhvxvu9rLF9KF2aCi/zoDAOoN"
"AKj3AAD3CGBl/qdLDADQ5p/Psjf7GSAAtMumP0AKzL+Po3579r9V+0f035IoeuhF3UPm39Ms"
"011dtevpDTmXVwC0Fc/g7v8W1P/zvxLNuR4AkK7S/0co+k8ZRTeOt0Qtp/9fZQCoPvgSSS4B"
"rDzwtKjc8wSZ/+Nc+0f0X7rrQWX+WPcvo38LADbeJvLJ/PPXDSWzVwpXALDuVqmwW0XumlvZ"
"/HPJ8BkGFBQ4AWCoXQpANoAgQAMA9wGYAEBfR7ZAAsCt5wQAaA481VAn2lpbRF9fYBDAjbqr"
"q9vRLGiCwLnAwECBIFCmIBAYwARhoKxiLWmwlopMFVlymnOxJfPnnV8zDLzI+W+UuAzdMnUz"
"ejfNvcww93LD3F0Gb6taVFdr1YgaiMy/trZOnKLr5s/wz8X03dE+dl7E66O/VD9Mv7fPuRXx"
"uQEA0v2fWLX+2tTPVOT/ORk/zH8KaapoRM1fi8zfLwDkmdH/ItISFf2vJK1RU//CHal/KY9l"
"gCy78U+OyDUAwDEkh8y/RkX+unO+PoohoLveaf7djto/NkKLVwCQ4LEMMNEGgDZt/EcsydT/"
"kX4AIMMBALgny7T/HgMAYpwAUL8/AADskQDAJYEYZf4x0vyR/ofpMwAcpOcax19DP0BHfSZn"
"ARpOJHZd/Mt/+mOIbAgcrPzPKwvgUwb4WwcAve5fd/7r2r+O/v+wadkrETDFjopQfjFY5v9j"
"gx8AqHP1AJjp/wqH+f9omb8BAJb55/ns+CcbAHNcAJCtZE/86+uQ5t/XnuYY/cvDf1p15/8h"
"9SJXs/8x/KdssVr+N1NG/4XTRAui/+NfiiY9/c8HAJD+f4fNvyaZzDJpJANADeb/x71AkisA"
"Kg88JSr2DBflkY+Jssg/UPSvAADmv53Mf5s0fwkAtxMAkPmvv0UBwBApLwAIu80/AKwcagMA"
"a4gEgBVDyPxvtgBA9wBoAAAoZIedPwA0nWrg3oCOdqRs/Xdo6wdu3kjv1qub/0BhIFggCAQF"
"wYIBon+OjC0jLbeiZjZYw2y18QaUNmnDqANJ/hvljkjdbeq2sVdaxs7mbhh8tcPcpcFXK4Nn"
"k1dGX4frQaqHcE1IDbgepP4Mf6Cmj7+N10Ggrn77NXPGGsWM3ozzAoAktdY/laL9NFnrR8pf"
"D/ph8yfDr2fTp6gfkb8JANbyP3sfADcANB9fqqJ/DACS0X//AGCIzX+jlAMAtknzx9p5BwDI"
"JXMsMv4ut/k37pPmf1JH/2rgD+uQMfwnEACkWbIBwN8yQGn8WgAAROV2rd8PAPjNAMQ4AaBh"
"r4r893oDAEMAPt9LEJAi2uuOckOgygL8wcgC6F4AvSJAzwX42QCAbv7T6/7Nzn9MSLqHov9X"
"GvKndbWVLhAdVWvEme7jyvwbPQDAGAJ01kj/OwCg3Bn9G53/DABk9mct88+zQcACgFzb8DuV"
"HACQJQGg3Q0AqeI0Rv9y538im//plgQFADD/WDX8Z5Y0/2K5/A/Rf8vxr+jN+zkBwKfc/X/y"
"2CR6s6P+P0Y0YPhPGpr/ZPRfcxjp/xEy/X/wRVEdCwB4jsz/GVG5/0kDAB4h88fOfw+Q+d9H"
"0f89FP1L8y9G/X+jTP/7AMC6IdwDwOn/YDIADAC3WGUBLgWobAAg4KhaHWABwLL/PQDQ2twk"
"2lqbRSdAADf1IBq3urt7HAOFAsHAuQDBQKHACQdtZIZ1rijZpUqn6Z6vqlxyG7l/Q5eq0ZG7"
"EcFbJk8G7zB5bfCGyTdSJK6FqJ+F89sUvOH7M31zgA+i/f4eMPjOzi7+d3AdAWd/HgCYKAf9"
"WLX+r0hfk/nLtH995lTSNA8A+IYlzd8LABao6H+xaMb8fwwAQvqfASBctPEAIDv17+4B6DBN"
"v3yTavzbqObkb1UAENEPAEQbAKDN3wAAVft3mn+ilDEAyFECsKL/YAHAaf5nOrNU81+UHwAw"
"mv6sHgB/JYC9LP6aavqTxwOW+UsAiGcI6DqFfoAE0VGfI9pqMnUWAMsC71H+Z64I0HMBdDPg"
"3zwAmOl/TD3Cloh63f/vQ+S2iQ8vn/302rbSmfRiXMrDcSzj9wEA3fnvGgDkCQAlLNn5b9f9"
"z3bl2wDAKf9cBQH2oB8Z8R/zIz3xL1OZfzq/OE9Drdr8k9j4pczon14kddtU3Z/Mv2i6aIX5"
"I/UP88/7TDRx9z+Z/9Hx9KYfS9H/aBn9H3lX1KW8zdF/jRH91yD6j8UAoGdl+n//E6Ii2g0A"
"KvrXAEDmj+5/pP/9AgAUpiBgDer/t8oeAL8lAC8AGCozAdwTYPQAmABwHj0A/gCgva1VdHa0"
"i+6uTu4RCKaDGz8DGAg2M9AfELihIBgwcMMBfqbu/2fvPMCzOq88r2R2dmd2N7OZ7GzixHGK"
"a9xNxxQDxgbbVIPpvRjce8U2mN47AtQrqFdEFagiUO8ICfWOKkUUgx2fPee87733vff7Pkl4"
"kklM4Hn+z/0kME2f+f9Ol6bJUsxUlzRaPaJWVG+SHXPujho0NVrMXNN5W2N3YO4ODV41+fYL"
"DqP7zgy/O5E+fX27816gA0x0mrimFkEH/6z0c//lAYBG/Sj6X66n+8VTi/4lAJhKAAgAevTf"
"NQCI9L8jAEBVh/KTDb9KMX42/xDR+Kd3/kdKyaY/mxKABQAo+m+OdQAAiQYA6KPRKcaklKkJ"
"MO0WACBbSDV+qesIHV0BgFYeMLr/FQBoFlkBAwBkw59u/nFG5M9KlhCQxM2BV1vOyixAJnju"
"XrmPfE/63+NOxl6An0uftCkD/JgBQE3/U7MDbUGiO8k9ncRc5Mu12UtbL1duxzeeN3eIwvet"
"0vylVABwZP7fKebfKQCQ+Rex1O1+AgBEl7+I+PNlh3++0u2vdPxfzubIX7wxMfK/lC7MX9b9"
"yfjFQYtEI/pHAODxv7L1SOdrMfJfhea/HC6cXYYAgOZ/5gtoy/8M/yf/WJh/Npn/W9BEXf8Y"
"/Z9Po+j/VQSABXz+lxr/CADq4qaJ5j+K/o9PQAB4Gc1/rAEA0SOF+UcMh9IwNP+QISxu/usU"
"AAbwFIDeBOhjNAE6BAD8XIEvlQEGMQTkMQTIyQA5EigWA/VTegD+OgBAkwLX8R/lm/gPNmUE"
"uvOPv/aNDtJQat7aM2AFgs4yBN2BAntgoMEBmaRqnrqksTbZk2rA2mtpzI6k/ji7P6ciG0O3"
"mLo9c9eNXZWdv4fOzL6zCN9elE9fN/r63eyiSVQ1fYKY4pJzvML3XGkZVFXX/FUB4HzGMhn1"
"k/mvkXP+qy0AsFpvAtQzAMoGQD4HrDcB2gGAMj/UPmn+NP6Hxl4VKlQdxhCgmz4DQKiQZvxa"
"2p+MXxMDgNYEGG00AdoFgOPC/FuM+r++77/9pMX8TxlPhwCQoQCAIm0PgDXyv5rLvVqi298R"
"AGh9AdoeAAUCGACkGACErjXLbv/WOL3z/7oS+QsAOAnX8c9JWYCrrXkyC6BPBLws/a+n9MO7"
"pT/aLQP82AHgfyjpf9qFTCMQ1AQxYtKohz+/eG4NkqgzXKndx0bqGAA6Mf9vaxQAqHIAAFr0"
"f4b1nWW8jxf76Cl/Yfa68XPKX3T9k/nfuEzRf4a+mUpE/6eEKPUvzf/GhQRJvXF8+KKjajdG"
"/mt08794dima/5dw4cwSJPnPEAA+Ean/nPcw+kfzz3idI/9GNP/G1EVs/vUp4vpfQ9JMCQBT"
"UZOF+ceOh5rDGP0fRACgBkBa/Rst0v+lEc8iAAyVAPBMpwBwZh+N/D0tIEAdA/SxjAHaAwD8"
"XD6DwCAFAGRDoF4K+OFjgD8EAKhJkLbp3QoEaN+07IAjILiVLIEjMLALB4phmn5sm2PZM+Nb"
"VWc/v10z78LYOzN5e0bf3ejenuF3N8qnb3RvgKL8nJw8SEhMRtPOgGx8/V8CANTxT3V/aviT"
"KX8x598ZAGg9AOtNp4ANAHCW9X9XBAD3bgGAkAoBGgCEoflHCDkAAH0MECFAbwLUegAUAGDz"
"7zYAkLTV6akKAKhNgCoAZAlx9J9jFwDE6N9hCwDIaN+0C0D+mPMaBNgCgP66JV4CQLxe+zcA"
"IEmavxRlAdqy4EpzEXQ05vJeALkieIT0wYedjBsBP3MypgF+9ACg1f+pu5GOH/zKmv4/5D/n"
"CKXCO6pd8c0VzKZrAECzLAE0yWVA523N/1tp/t9WG+ZvAgCt/k+d/1r0rwFAgVm81IcAIN8C"
"ANq4n0j738A3H6X8v+1I593UJFPdnxtZEqUM8/+m7biY+z+3itP+F4uXwUU0//Yzn0N74afQ"
"VvAJtOnR/zvQnEmR/+sc+ZP5N55eyOYvAGA2NCTOQACYjuY/BTUJzR8B4Ng4qKbo/+AYCQDU"
"/f/8LQLA0wIAfPoJCNCW/3g7BgA9G+DXCQAoUwDdvQXw1wQA66Gd7n7TgIDGxcj0yIC6ggJ7"
"YHArcNBZBuHvRZ39vrtj8l1F9prZk+jvnf7+b8Xw6VtTczPk5hVCVPRBCAgKg0h80rnevwkA"
"UMNfjpbyXwfNuRICctf+JwBARP8XtPl/Sv+X77cFADb+cKGaMN30hajmH6Gk/SN187+mH8/5"
"SwPAKeVmCimNm6nV0T9bACDzzxYi87+Sa5P6/xY/vsJb/w5bJD+nbwJUxIt+rABwXAGAOAYA"
"6vTnbn9+auafrBv/N+0pqFP4Z6aPs+FqSzF0nM8X2wHDXI/YKQP8Svrkv1r7AP4qHv3X+En1"
"n9wAAK3+r3X/0+xjDydxIWl8WeqnNXQM50qNJ76pwvloD3zf1gkANBhd/10AwJ9vaMt/SoT5"
"XxfR/3fXCoXY+PMNXcljCDDMX5NS7+/IlPV+af68p/q0ue7P0X+CVLxu/t+0HUPzX41aqUT/"
"S9j82/M/xuj/I2jLJfPH6D/7bQSANxAAXoPz1PWfSqn/+QIAToq5f+r8r6fd/ydk7T/2Zag+"
"NlYAQIyY/6f0f3mUTP/bBQA0/4CBOgAU+aPh7+sPZ/z7CQAgefcX63+9+jsGAL/BLBUA7JYA"
"tE2AdA2QjglRX8G+QVAU/MLfBAC0M7v0D7pYwfvDMgX031NjGUWhZE5kNN2Bgs7gwBEgdBcW"
"/trq6vfm6M/k6O/AntnT3yP9fdLfK/39dqdjX/1GgEBmfujwMXBx9YBNW7aD8x5X8PTx/5sA"
"QM3Jz/H/40953p/S/xzxs+E7AgA7Y4A6ANj2AGjR/4UST6P+7wgAaiIUANDMP1yoVjN9RwBg"
"mL+xB+CQZQqgKwBIdgAAqXKPCv4beynDAgBaD4CM/DEoYzEA5JnMX0T/yfj7VA79KPv/r9Qf"
"NK7+mY4BHZargI8p9f9YEwBcb0kw6v025p8izZ9GwE+jTuHn0uBqWylcaT6j3wgg/5M+2EP6"
"ojYNoPYB/OgBQK3//9ZJnETsjRr+y1/8dM7FkhU8Enelzhf/8iN5Z78AgOZOAEBN/WsAUAV/"
"lub/55uVwvxvqLP/BABa01+BEBt/niEiSKXWz8avz/qr9X7R7PftZTJ/6lRNMer+F5P0yP/G"
"hTgWm38rvYFC4VLJShSZ/zL8n5VS/59LAPgQ/6f+AFop9Z/9Lqf/mzNUAFgoAODkXKjH6J/m"
"/sn866nx7/grCAAU/Y8XAEDRf8woBIAXefFPuRb9h1Pz3xD7AKCZP6sfmjnKu68AAC+M1L1s"
"AUBE/Wj8voM7AQCjCZAjf+0aIIpGA/OprEAAEDgMGmvO/c0BgP4Rp/E7rRFPRJnX8cfdeumA"
"lskQUNDP0RUYdAUInUHCDwGHW9Gt/Lqd/f4d/ZmtRk9/XwLEur+FT/umGT6Zr7evP2zYtNWk"
"vyUAhIWH885/Eq36beLtfmT46xwAwFplCmCtnR6AzXIT4HaxBOjsHgUAvGT6XwKA3gRoAQBW"
"uCL5uVoy/Ggj5c+voxUAsDMFYAMAcvmPCQAS7ADAqW4CQKb4d1iN/DsBABrTvoLRfUedZvJC"
"ZPxC2jVAeQ5YgwE+9nNY3gJQNgPaAECSRY4B4Jv2dLjWXgZXqBmQywAZIKcBhks/fEj6o9oH"
"8BJxun8AACAASURBVKMGALUBkLYc/YdS/6dViCPemdd7xaWSVbwS90qdvwIArdL8m+QiIDL/"
"RpYw/3ph/t8p0b8EADZ/BoBSBQBE+v87BoBCaf4CALQoX4yKCKkb/vRRv8vaGzFNb/b79rIw"
"/28vnZQjfxoAJAjzbyedkLevqdkkQJh/saz7Y/R/4cxn0F6A0T+Zf9570Eqp/yyM/rPeFPX/"
"9MUIAIvwH40F0EDRP5p/XfJMBACK/idj9I/mHzsBIYCi/3ESADD6P/ASaiSn/8sjhwvz1wHg"
"GQMAAgdyzf+sf38o8iP1kwDQ1y4AGLcA7AGAuQTAUwDqGCBdA3TtDVl7e0H23t4MBDQJUOiP"
"EBI+GhpKEv+uAIAMif7xb2g8D7W1dVBTU8dmRbVw+nH/mW83ZbaBzE4rJXRWTrhVWPivUnd+"
"n2raXkvdaybf3SY9R9+oMTEzK1uP8K2G//cEAHFHgqAx/Wv8f/kz0QBIqX0yfQ0AZA+A9rlm"
"GfHrQuP/QQBQtq9TALhqAoEIGf1HmwGADNIuAKD5Nxx0AABHjQmA7gCADgE/FADU6D+Ha/Md"
"aPIddQfQ7DXFGK/rDvCf7wpJljT4z8nngLWGxmOGzsfqDYBGBsA+BJgBANWegQBQLssAYhrg"
"7cXTVsg+AG018O+kT/5vJ0sjIPyIAUBtAKStR4+inka9GOI6JYLq4bQW90q9FQCaOgGAOgUA"
"hPl//22lYf43KxwAwBlT6t+c6hfRvgEA2Z0AwGlu9rt5ie5Vn0RpqX+M/C/SiEuCbv432kX0"
"f731KL7ZPETdnyL/oi8EABR+Am0Y/beR+ee+iwDwNtf+Kf3flIHRf9oiBIBX8R+N+QgAc9j8"
"65Io+p/C5l93HM3/2MsIARj9H0XzPzoaqmPQ/KNf4Oa/cu7+HyZS/2FD4FzIYDgXPIhVEogK"
"oLp/fzjrR/V+MnwUmb9vHwMAPPveOgDQFIDcBkjNfrwIiKJ/FwUA8GPKDBT6IYSEjYa6HO+/"
"awAor6iCknOlbBA5uQWQkZnF/9iXlpVDNZoFRct/qW9a9kCFBBLNsGtGqjUkquqOIf9QWX+t"
"FqUpkH5f6u/zpl5OufUo3tG3Cvz7T0vPYGMNCArp0uz/3gCgMMUfGggAUpeI7v8cw+jNAECf"
"W3+LAKCNAbrYlgBkE2C3AIDMvzbKFgDkazMAHOCI2T4AHHYAAI7GAB0BgLUHoDsAQGPaGZz6"
"J/PvwN/7Ffz9stHXWZ+RhjQIoEyAVtLQLgE2HTUBgN4DYAMBFgCgHgCGgEwFAEQfQLjf1gjy"
"QemHj0p/tNsICD9iAKDFBtr6X1MDYLDLlEiqiV+u2CUyANwDoAHAeUPS/OHPSu3/uxohGwCo"
"uEUAyDGl+r/TX2eZ6v6a+YuGP1Hzv3lJmP9NfeQvQUAAAwC+4VnH8Y1yjAHgSp07mv9XqC+U"
"6F+Yf1vuOwgAqOy3oInMP/N1aKLoP+1VaKTo/xTV/mex+dcl0tjfJASACVAX+zKn/mso8j+C"
"5n/kJaiizv+okSgy/2ehLHwonAt9RojMP2ggi8y/eD9G/f59oQgN/4x3byHf3mj0BAASAggA"
"0MQLvfoZ54DlNUCbJkBtCsBnoO0mQAUAsvb05tf0+QKEiqKQF6Am6VNoqCr8UQFAyuk0iEfz"
"OBZ7Ag7EHIaw8Cg2lUOHY/H7s6GoqBhqamq5jPBf8Y3+TJr5/iX1Q6Ynfsg3OrlLB4eST6ZA"
"9IEY2LZtB6xYuRY++fQL+Grpclixah2s37jlB5n/3xIADkSHQ1uRJ9SkfAWNaV+KPf85aPJ5"
"6+2UAG4VALYZtwBoCsDUBOhgCkBrAuw2AEQZvQCdAYC+CtgBANhsApSLgGwgQGsCTLNzCyCz"
"EwAQEwCUrqc0vw4AbPYR3NwolhrJ13WaDAgwbhwchKvnlf0GvAjouM0UAPcAtCYqMGA0AlI5"
"gHUhXQBAawkCQAFcbtC3AlobAbW1wP9yOwGAOgHwhJM4iTi68MRbxQIAdvIGwKv1YbyXXzQA"
"WgGgQQGAWgUAhPl//y2ZPqX+rQBQ4gAALHV+fa1vtmnFr1CGGQC44Q+j/0vC/M0AQOYfr5v/"
"N+2xEgCO4P982zn6v1j0uTD/M58gALyPAPAOtOW8Ba0kmfqn6L8pnaL/hQgAGP2fotr/TDb/"
"2gTR9V93/GWoI/M/Og4BYAxUHX5J6ABG/5EjEACGs/mXhT0jIv8QMv8BaPxPs8j8i/f1gyK/"
"PlDkg6bv1UvIpxeaMn1sBoACita98MmZgAHGNUAVAGgRkO9A8y0ADwsA7OnJEmWA3pBPvQVB"
"I6A64WOozXD50QPAvoBgNpg9Lu6wdbszrNuwGZajiS35Yik4794LW7Zuh8jIKAgJCeMzuzk5"
"uX8p//xRfMvOzsE/cw74+PiCn58/fPrpEvy7+QomvDIZpk6bATNnzYF58xfCosWvw5tvvwvv"
"f/Dxjx4AitP8oanQHWpOfQ2NGcuk0W+QALAemmQmQE3/3woA0DlgcQ1wt/1NgHYBQIOA8M4B"
"wDoNUC9LASYAUI8BaQBg3gRo3AJI0G8B2AWACyILQBBgew0w3dIEqE4BCPMngGDzl+n/jlrN"
"/MPxdZhJVzRpEEBZgAajuZFOG6sQYLMISLv+Z10DzHsAknkPgHhmmAGgPgvOpEUXO4njQIOk"
"L6qTALcFAPw3BQBo09G9TuIW8mDUWAMAduAXwQffXEFwsyNd1v8bDbH517P01D8DQLUFAEjl"
"UueEvlEaAHUAyLcAAJl+lm3UT8bfoY37CfO/qR34odT/JTL/RBYf+qGZ/wva0p/jUiL6v956"
"GC6Xb5IAgOZfiOZf+CG057+L0f/baP5vQkvOG9DCqX8CgMUIABj9py6ARoz+Kf1fnzwDahOn"
"IgBMRgB4hQGg9hia/5ExCAGjJQC8AFXRaP4Rz0F5JK39HQKloZT2x4ifFIjmv78f6yya/1l/"
"jPx9e2HkT+bfU8inJ0b59HFvzgIQAOTTyB4+C7kfwAIAyipg/RaAl5b6lwDgbgsAWXt64ce9"
"8Pv6QMH+4VB+/D2EgE+gviThtgWADz78GF5/422YM28hTJk6HUaPGQfDhg2HPn36wUMPPAS9"
"e/aC0S++xFq3eq2u5KQkXXQf4O/pG53rTT19GpUKqampsGP7Dti1Yxc473KG+fPmw4IFC2H0"
"6DHQt29/GDBgEAwaPASGDBkGw4c/DyNfeAlGjRoDY8e9fNsCQNKJMI7+a7N2Q23qKjiftUqa"
"+8auASBvvWz+kwCgLgFSzgEbAKDdA1COAclNgBoA8PY/UxZAq/2L+r+QGvVHmACAzP9ag9E0"
"Zx8ArKuAKRA6Lk8BqwCQbAcA1EVAqYqMpUC2ewDELoBvr2SKxj/N/BFiGADwz6Ybf02oLrHm"
"GFUXbh8CGmMkBBw0dgTotwCOK6uAlVPAcjzQKBEkiDHAtjJZAhAZAAkAY6UfPin98S4FAP7b"
"7QAA/6oAwH3yD/qMAQCyCbDWG8kzgK/midp/gyFp/vDnOrP5MwAI8//+23LF/MuF8bPUBkB7"
"AJBtAwA3tY5/JfKnS1JCp9j8v6HU/yUy/wSWMP94ofY4PfoXAHBEnAAu34jmvwQuFH2K5v8R"
"R//t+ZT6x8g/G80/+3UEgNdE9J+xCJrSMPpPnc8AUJ8yWwAARv9mABgLNYdHIwCMQvN/EaoO"
"jYBKavyLQEONGMrmXxo6CEoo8g+iyL+fAQD+fQUAYMR/xqsHFHr2FFIBgLIAnn0g38MxAOSr"
"x4C0a4CdAQCVAHb3ElkAVA5+nO87FEoOLYaq+I+gJvlLqC/P+ocEgF/9x/+Dn//vn92Sfn/3"
"b3VosOqNxa+ZQIK0fq0DrVun68033oCxaNrjxoyB8WPGwstjSePg5XHj4aH7H4Df/OouuPuu"
"38Bvf3M3/A5//T/e8zu49/d/hPvvvQ8euO8BeOjBh+CRPz0Cjz36BDz1ZA/o1bP3PyQAxB8/"
"AE1nfKDtrBeUnNwOdenrxNY/MvY8AoANDgBAgIEBAOLHk4xLgFttSwD6OWBXeQ5YZgEq9us9"
"AAYAhJsA4Kpu/hoARFoAwDD/a7JOflU3/kMOAECVdg7Y3jVA5Q6Asg74pn4S2LwUiC8A0ipg"
"EwBkcX1emL8w/g78s3Twn4cAQDP+ECkFAPRMQLjsBZA3DxoPKDoodwTI5sCWY+aDQK0npOL4"
"ENB1/YlQ0JaL0f85uNp8VvQAmAHgGemL9ykA8K//OABQvo33ANAmwOvNMXLsr0GRMH8BAIr5"
"f1dlBwDK5Py/FQC0db8FnQBApg4AN2XTH1/3k5G/UAqb/zcXZfSPxn9TM34a+bugmj+qjepg"
"h1EH8c+5Qab/P+Haf3vBe9Ceh9F/7psIAGj+2a9BC0X+Mvo/n4bR/+l50JgyF+pPzoT6pGls"
"/rVc/5/IjX+1R8dA9eFRUH2EzH8kVB58Hioj0fzDh6FE9F8aMlCYf2B/KN7fF4r3CZH5n/Xr"
"jQDQkwGgwLPHDwcA7wHiBgCaPwMANf95aADQF3LdyPxtASBrdw9WrtdgKIqeB2Wx70BVwodQ"
"k7IeGixjgXcA4C+jf//Zv9nq3/4P/OL//FzXf/z831m//PdfsH71i/+Au/D3dtf/+yX8+pe/"
"ugMA3QCAhPg4qMnxRfP3hIZcNziLAFCfuVGO920Q5m8XANaL8gCqVUb9Ldrcv3YCmOb/C7aJ"
"6F9vArSeA3Y3LgKWa1mAYDMAyB6AqxIArnK0bA8AouQUgBz708bl1OY/Uw+Aeg2wKwBIkpMB"
"ScaEgASBm9xrpWQCLqcZAEBPfRVwJmcSjKifjD8CLiPcXK4Jl+l/zfyD7QCAAgL1EfYBgKHn"
"kAEB+Ofjk8DNx5SrgBZpUNBWZAaA+n8cAHBUAhhTeOLNYp6LL9+CXwx3fDPSJECgNPt6U+QP"
"f65lmczfBgDk7D8DQLFu/n++pkb/Bfrcv30AyJQAoJl/mgIAovGPzJ8yFRz9o/HfZNOPk3V/"
"SnEJ4xc6ogMANf8ZAPCBSP/nofnnvI4AgOaftRgBYJGo/acvhPMU/Z+eCw0U/Z+k5r+pbP61"
"sgGwNnYcAsBoBICXUC8I8495DiojnoXysKFQFk7jfoPgXMgACwD0YZ31I/WyBQBvAgCUZy8G"
"AC4BqACgNgFKANAjf4z69cjfnfb+i93/OQQAe3ubAWA3AcBTkLXrKfwx+HNFzIKzMQugMu49"
"kQlIWWeCgDsAcAcAfiwAkJ6WCnV5ftByxhNai7yh9NROKDnlDA1Zm6GZGv7y1pt6ALSmPxaD"
"wUYWR/t5UhTxo9p0CfNvU6N/eQvAFgD8EAD2QUdFoLwAqAAAG7+s/ddGSwiw1v7FrPw1ZexP"
"mOER2SB3VD6PgO05YBUATigAkCgOpdFUAE8GaErSzwLf5F6rU/Lf31S5eVUBAO4HyOB/p6/I"
"er8wfzL+MFQoXKajR7Vq5B9sLgHQ4SMVAGQWwAQAsifgSmMMSvQFXG1GEGg+gpIg0CJ0teWo"
"kh04zseCaAkQ1f95HbAcAzyTFkUAMOZ2LgF02gSYGD4v+SIBQNlm6Kh2wTekDx/Lobq8rfnX"
"sMwAYJj/99+WKQBQqgBAkWX7n7b8R63/WwEgQxq/Js38ReMfmT/V/AUAxKFOKGl/sfGPjF/o"
"MKf/r7fEIABQ+v8zBICPGQDa8t+Bttw3BACQ+UsAOE/Rf/oCBACM/k/NgYaTs6A+eToCwBQ2"
"/5q4iTz3T+n/Wur8P/QiAgBG/zEEAMOhggFgCJSFUePfQDgXbAEA/94siv67BABvBQA8+tgA"
"AKf9vdD8vTDy9xTz/nkefaXpa+rD8//ZPP6nRf5Szk9B5q4nIdvtaSgIncYQUHJoIVSeIAj4"
"AGpOLtfLAXcA4A4A/BgAoPhMBjQW+qL5e6D5+0BV5l44l7ILzqXuhcbsrYbJdwkAMtVPtX4S"
"Gj6pTZcw/za99t8FAJT7IwDIXgC+AhjWPQDQ5uPr1aU/6spcbU7+qFye0x0ASBDSASBBTk8l"
"CAi4ICDAMQBoEiBAvwfD/CMU8w9hGeZvpP9tASCscwCgUcIGkiwHNB2SMkBAiLIDMkNAINB6"
"SkT/LcW8CbCjUQBA0mHf5Nu9CbDLMUDaBHipbCO+IffgG9KTpwG+aT2qp/xZ39Xo0iN/Mn8d"
"AMpQ0vj15r+zQiYA0NL/xqYoQ0bTHzUi6pE/SwEASv9fSJQAEG8HAGIlAByWOsTRPwHAhbMU"
"/X8KF6j5j7r/HQLAQh0AGk7NRgCYKQFgMtTEv4IAQIt/xtsHgAPPQkX4MCgLlQCA5n8uWJg/"
"QYCeAZAAUOT7AwGASgBa2l8HgH5Gxz8Zv0z5Z5P5u8iIXzV/DQB2PglZrv0hP3gSQsBUhICZ"
"UHpwEVQefwch4H2oTloC9cXxdwDgDgD83QNAQ1U2NBd6SfP3hoZcTzh3Cs3/9B4EABcJAOsV"
"k78VANjOaivcYQjNv+0Mjf/t5kVAwvxd8N8aN24CFD0AXQCApQRgCwDRDgBArsu1AkDz0S56"
"AOIMCDABQLyUBgBJYs/KJaUMcFmUAb5TIIBq7B21Ws0/Qkb/mvkHs6zGb9ME2CUAiHFIMwBY"
"IcDQNQ0CWhAIWkT9/woBQNMZ3gRIABDmt/UfYgxQXQT0BydlEdCWZS+4XSxZDpdK18Plql34"
"pnTjZsArtf5s8lraX5h/NUs3/u8qhGT0//235wzzZwAoErpOh3+k+V8zon8aF9Ejf5Zs+CPz"
"70g3jJ+lRf8neeRP6/g3A8AJU91fM/9v2g5yX8P15mg9+r9QSOn/98wAQCUA7gGQAJA2H85T"
"+v8WAaCCAWAoAsAzCACDbACAmgBFD0AfGwBg87czBaD3AGgAQD0AvA9AQEC+59NSKgBoHf9o"
"/HuF8Wc6i3o/P50tALC3H+QFToS8oImQHzoZQWCGyAQcfxuqqCQQ9z7U5fjfAYA7APB3CwCX"
"6pKgpdBNT/s35nlCGRp/aSrJBUrTXBEAtsnmPmro26T3AHQbANj0d9lIAIC8BMjbAN1k9O8t"
"mgAdAUCXUwBRPwAARF1c3AKwTgHISYBWBQJsMgBJ3QSANM4QCPM3AEBE/yG2AEBlAEdjgKaR"
"wHDuAzCfPO4KAKgkYMgAgGMi+m8t5jXAfBK4MYcvAm7d8KWbk3kR0B+cbqNFQE5Oxipg+gNp"
"q4AfQfVHjZz40gNLLhZ/jQCwFi5Xbsc3pgt+ATx4JPDbS8l62l+YfxVLRPya8aNuovnfLEVp"
"5l8ixACA5n+9EAFAmr8OADliZMQ0629snDKifwkAuvnbA4ATCgAcE1IBoJXM/wAqCgHgEzT/"
"jwQAaBkAvQfgdQsAzEMAmAMNKbOgIXkG1CVPg7qESXYAYBQCwAuoEVz/1wEgZDBCgD0A6M8T"
"AOYmQBoD7GlnDFDsAdAAIF8BgALv/hz1UzZAmH9/AQDufXmsL9tVAQDZ7Je56yk2f37uIgjo"
"oQNA5h78bwNfZuUFTUAYmAT5IVOh5OACqIx9g0GgksYET66FxrLUOwBwBwD+bgDgZkc9XCwP"
"Q+N3g1aK/M/6wvl8byhHwy9Pc4OyNBeUKwKAmy0A5G+0lAOsPQCy25/S/xz174T2M85Su6Gt"
"yJkl1gDLS4D6IiBp/qXC/DsHAOMIkHkVsGH+AgAOsvl3DQB0A+C4mP/XAeCENH/rUiCtB0Bp"
"BOQegOROAYBKAldp3r87ACDNXywBsrcISFO4LlsAsJYANAA4aKNrnAVAtaZy7f8qmT/X//P5"
"GBDdApg47rkl5IPSDx9xMlYB/8zJWAXs9GMGAO0YEO02/r+oe1B/chK7j59HTW4q+OraRd4F"
"sBXlzGeBO6o9ZTNgtRCbfyVLN36O+g3z//6mNP4bxULfFApdL0AAIPPPE+Kd/9k8MmJ/1l/W"
"/fWmP3XlryMAMGb+7QNAtAAAjv7tAcAbZgBIk/X/0xj9p8xEAMDoP2mqAgATJQCM6QIABkoA"
"kD0ACgCoY4BFvr27XASkAQAtA+KdAF79hOnznn+t9t+Pu/1puQ+n/rneT5KR/86npPkLABBS"
"ACBgvBCBQMAEzgjkB06FswfmQvnRxVBx9C2EgXeh6vj7UJfrD80NFXcA4A4A/M0A4Nub16Cj"
"/iS0FLgK8y/yhDY2f6r7u0NlhgcCgDuUp7siALjZAACbfP5G3exb8iQE5G20AICs9xfKdD+P"
"+slxP/n6Am8A1O4AeFhuAfhzA6BoAtQAAE2xOtT+FUBtEZBu/DFSVgCw9ABoohn5Ztr+J01e"
"PQbEph9nCwAOpwDs9QAIALjaeEQYf400/5pIcwlA7QHQzV8z/ijzKuB6bSVwhAIAEcL4Ndnt"
"AZCmfx7/fpo00Sik0NWWAq79c/c/Rv/cANiQBc0VKdfI/6QP9pW+eI/0Se0WwI/6GJAGAHTW"
"ULsGeDfqQVQvJ3EFaWJh/NslF8+tgkvlm5FQd+Kbcg+KSgFeHIXbAkCZXvNnSfP//qZs+tNr"
"/4VSGgDkCvHGqCwJANL4NekAkGoBgJPdAABK/x91CADXmiMRAD7i+v+FwvdlCeBtO1MAr4r0"
"f+pcaDyF0X/KjG4AgFYCcJQB0ABggHkREAHAvr5Q5CdWARc6WgXsJU1fAwCGgb5s+PT5PHdS"
"X5be8EcAsEfr9BeRfsaOJ9nwM9j0pXY9aQcAxkPOfoQA1iuQFzQJCiNmQNnBhVB+5HWoPPY2"
"lJ+g/oBPoa4g5A4A3AGA/3IAuNyQjmbsxSn/1kJ3jPq9oK3YD84X+kF9njdUZ3kjBHhDRTpC"
"QLqbGQBylCjfHgDkb+oCAPbIcT8X2fSnmb+bbv4Xz/mIFcCaaA8AiqcAFAAQEBDqAACk8dPI"
"H53OrY9xAABHpfnLq3nNYgTum9Z4qTiz2uI7BwBtD8CFFNMYoAoA18/HouFHCfPXASBCAYAw"
"yxRAmDR+zeijWcYxoCgDAOoFBPD4Y0OkoXph/ld4OdAhAwDI/M8jFDTh952P5id/vjlZmD83"
"/2H031QAl2X9PyfRt4T8T/pgL+mLdzsZ1wBvm3PA9Aeh+8Z05/g3qAecxP3joaiXw1zHRfMk"
"QPlGfKNuxzemM2ovfrHcuSGQzF6YfwXLMP9zQtL8v78pjV+v/Rfo5v9npe6vRf/f6U1/GgCk"
"WQBAq/tr6f9kfe9/5wBwVHb/k/kfNAHApXMrOPq/UCDr/3lvmZoAm7NehWat+z91DgIARv8n"
"pxsAkDhZmQLQAEAZA7TXA6BOATgCAL4FQId/+liOAdkDgL6Q796HlUfiGX8x55+LkX+OC0nW"
"/dH8M+0BABo+vRZ6AjJJVgDYRxCAr/01EJgA+YFToCRqLpQfehXKjr4O5bFvQRk1CiYthfPn"
"jt8BgDsA8FcHgMsYwbWd9UeT3ovGTyl/jPqLfKCtxB9ai/YjAPhDfb4v1GT7QlWWD1RkeJkA"
"oAEBQOz918YANzgAACEx8y+7/1UAkLP+7Wj67Wz87or5e8NFTvvvN2QPAKrkUqBqrSGwuwBw"
"yDIGqAIApfxPoMjg5cY/eqogwLX/eEsPQKIZAC6KbYDfKtsAtWVs3PRXLSN+hgDtNZp/TTgD"
"gIAAAwT06N8KAPWizGEfAFANEYa4B8AKANL80fivsKJYtDnwCkb/XPdvPiua/yj9L+v/Hhte"
"jSb/kz7YQ/rib6RP/s/bBQDUZUA/d7KzDGjf9p6BAgA2IABsxTfnTrhcuRu/kK4oDzTZOGn+"
"5Sw98v+2REia//c3i4y6P9f+84Wu5SEAGEciNPMXAJBuAYDUbgJAggUAYs2z/61dAcC7CgCI"
"6L81axE0Zy6E5jQy/7mc/m+k6N8EAHIMMP4VAwB4D8Ao1It2pwCMPQADDACQZQBaBVzM64BR"
"aPp0DdDROeB8T1kC8JDG79YLcjHS10yfX7vSmF9P/LinUfdXAEArAaSj4advE8rY/jhkbHvc"
"1AOgA8C+cZDjrz3HQe6+CZC3byIUhk2Hkpg5UHp4IZQiCJQdRRCIfRuqk76C82fwf/oLjXcA"
"4A4A/MUAoKmpAdqqkqClyBdNew+05LtAS4EbGr83Rv3+aMD7of1cILQUB+D7bx80FPhBTY4P"
"AoDvDwKAFoz6m6U0ABAjf9Tw56xH/0a6H3XOE6WZvy/K3wIAAWIRkA0ABKP5BwsIYKOMFKOA"
"dQfgGpo+yQwAEgL0RUCHTQBwvZnMX1zK+6Y1SSz70SBAi/xN5t8FACirgCkTQD/f5epIBQBU"
"mQFAZAOoJ8B69CeKdwbwOWAuccgRv/puAoDaA6Cbf5Qi/DtsOslRvy5K/9P4n6z/fzbufwQ6"
"2V8C9HMnyxKgHzsAqKOA2i4AfRTwvXl3r7te/j4DwCUEgMuVO1C7ZCmA+gHc2cThuzKWHvl3"
"CQB5QtdyEQDI/LOFGAAyWPYBwDL2d8l89Efs/XcEAHL2v/WwNP/uAsBiBACM/jMXIACQ+WP0"
"f3qWGQCoCVDeAeBlQNoeABUADqp7AIYamwBpFTDdAdABQDkGhBIA0E+Yv19/CQD9zABA6X73"
"3gwBeWj6DAC0xx9Nn1b5CvVkAMje20Pf8MdNf7TsRwMAjP7Tt2sA8DhLAEBf+wDgR+Y/BrL8"
"xkKuL0KAH2k8ZwSKIggE5sG5g4ug9MhrUHbsDYSBN6HqxEc8ftXRXnsHAO4AwA8GgOqKs9BY"
"fACa8lzZ+Jvz9qI5u0JLoQdG/mj+Z/dh5B+A5h8MF0qDobU4EAHAHxryNQDwgYp0Tx0AzqW6"
"QkPWVgUA5DVACQHaxj8CgJb8LSyx+EeO/qH5t53ZrUf/F4o9+Owv6eI5kfYX5u/XNQDoEBAE"
"V1jBshcgQgAAm/2hWwQAjP6b4+QefDL+ZKkkOwBg3QPQNQDQ95HRX65GY6+Whl8tVRPhAAAi"
"5TGgKMX8yewPsOwCgNYDUBdhBwBEHwCPBqrm32iY/5Xzh3jeXxea/xWM/nn8ryEL/436EsY8"
"8tN1TrYjgL9ysjMCeDsAgDoKSDeP9VHAgT3/+/vfV09H81+P2sLTAHQdsKN6Ny8Hon6AzYBa"
"FQAAIABJREFUq41BDgDAMP/vb0rj15v/coWu5SAAkPlnCXH0bw8A1B6ArgDAugdAzQB0BgDL"
"0fzflwDwrugBuAUAEKuApyirgMcZAKCvAh4hVwE/K24BhD1jcwzoXOAAVvH+p7sHANwEiELT"
"J5H557mKSD/XRdvnT+qBr4VE1K91/otav5b2dwgA1hKACgC+YyDHB+U7Fp9jIZuAwH8cNwqe"
"CZ8BJQfmIggs4P0BZYcRBo6+xmWC2tRN0I7R2x0AuAMA3QWAsoI4aCjcj0btDE25u1F7hPEX"
"uKP5e3ImoPWsP0b/ZP5BaP4hcKEsBAEgCAFgvw4AldwDYAWALdCUbT74o2UDWvI3SkkA0Lf9"
"ydE/jPzbivYq0b+I+s2RP5p/mT9qXzcAIMgOAITLEoCRAWCzRxi4Wn+wkxKAjP6btfO4FgDg"
"zX/xSt1flgesq4C5+z/F5hgQ3QroqI5G8w8XAFBFxh9uqEZRbYTJ/BkA2OAN42c5ygDoY4Ba"
"D4A9AIhm82cAIPNvjBTm34j/fVMWp/yFCrn2z81/jTm8Avjk5kfhgX//yftO5hHA3zs5GAH8"
"MQOA1gegTQJoo4APo/qhRqCmQPV4uFb+BW8EvFyxja8DCgDYi19oF84CUI0dvlNS/2T+OgCc"
"QRVKACgQup5jAYBMIWn+PwwA1B4AFQCUHgAuAagAcEACAL1pt3L93wwAb8gSgAYAWgnADAC0"
"B0AHAHkMSLsFQMeAqo+8JI8BIQREKdcAbc4BDzQAIGCAAIB9/R0CgDYGyGl/NH1SrjT+HJnu"
"z+ajPorxY8SfKcf+uN7PjX6U7n+Ca/52AWB3H8jZj9F9wDiGAAEAY9nws/1GIwCMhmxvKR/6"
"eBTkeI/i78v1Hw/5AQgCIVOgOHIWlEQjDByaj1oIpUcW4/M1KD/+ATQWeOP/iDl3AOAOANgA"
"QGZKDJRmBkBj9m5p/M4y6neB5nx3aC30QvlAyxlfaDm7X5h/SRC0lwZLAAiF1pJgOF8UAA0F"
"/hIAvLgJkNP/aP60CKghczM0Za0W54Bz1uKvswYl9v/rAFAgzL9FNX+K/nXzN5r9dAAo9TGZ"
"f+cAYNaVqkAJAKFGFkD2ANgCwCEHUwDHuwEACaa6f3cBgFL/V+oOcuqfzF8AABl/mCLV/CNN"
"5i8AQDP+GKkDnfcAdAUADVrkHymF/00jwlNTsoj4NeNn89ei/2yoTXOBw+87kUFOkf7XT/qh"
"NgJoMwFwuwAAdTbSiMNvncTIQ2/Uc6hJbTnP1UD1LLhUukmOA6oAsJezAB01XpymtwWAIgUA"
"ChUAyBYQcA2fHP13BQDdKQF0BgDaGKDsAbACQBO9abdAO5p/e8E7BgBoUwDUBEg9ANwEKHsA"
"qAmQIWCmAQBcBpiCADDJcg54lHIOeCRURCIERD0HZREIARHD4FzoM0LBBgQwAAQ8rQOA6AEQ"
"AHCG5CMhQEv7OwKA3Wrk/5QAAFPU/zhL1Pw7A4CxOgTYAIAPmr2Xphch0/tFhIGXEARekpmB"
"MZC3bxzk7Z8AZ8ImIwhMh7NRM6HkwBwEggVQcnAhgsCrcO7wIig/9h40Ffjg/5Q5dwDgHxgA"
"YmP8oCDZE+qzdsH57O2oHXA+Z5di/G5owp749MT3izc0o/lTo18rGn8bmT8DAJp/aSgCQBh+"
"PsQGAGgMkHcAoPmfO70X6jM3IQCsQshYjVpjPOncLwPAJmn+26FFNX9O/bvI1L+M/ku8JQBg"
"9F/mpxu/EBl/gAUA9osxQBa+rgzQxRDAfQByIqBWW/8bYwGAwyYA0PYACPOPg+stIv1/Xa//"
"qwCQCOopYLvHgCwAcBN1pf6QNH8JAGT+VWE8wXC5KtQ+ANRFiaNArAOG6evmf4DLAdqRIwMA"
"5EigCQAkBMgzweJcsGH6rAYEJ4QhI+KXxs/K0wHg1NbHIGDRT2rI96T/9ZZ++Fvpj//rdgQA"
"dRJAHQUchppYlzqsGKonwNXyrxQAcOb1wBoAXKZrgfX+8B0aujD/s0IMAIUKAGjNf9nS/DPh"
"z3raX3umKwCQZsghAHTWBNg1AFxrjpIAsF0BgHfsjAEuQgBYqEwBzBJ7AOgWwMkZCADTbQCg"
"7th4NP+xqNESAF6EqgMvQmUUQkD0CCiPfA7KEQJKw6gcMERkAoIEBJQgAJDO7kcI8O9vagLs"
"FAD29kAA6GGk/dHss9H0s/eIWn+W85P6fD83/BEAbJdmv10zfgMA0vF/igzn3nYBIBuNPduX"
"AOAlNH40fM8XUS9AptcL4skgMIphINdvFOT6j4ZcgoGA8VAQIGCgKHQaFIXPQCCYjUAwD0pi"
"5sO5AwgEMQuh/Og70JjrCe3VSXDt6sU7AHAbA8DWbVshfN82SD28A2rTt0Fj1jZp+qSdaMS7"
"OOXfTDX/fFd8X7hCQ447NOZ7QTPt9i/yh9azARIAgqH9XAgCAJp/aRhcKA/Dz4UKAKASQLY3"
"VGZ4ikVAbP57oOTUbqjP2ADns1ZCUzaJQGCVAQBc/9/EkT+Zfyt3/Uvzlyd+289q0b8GACQf"
"jvwvoemTbABAHwPcBx3ltAtgn7wOKHcDVJL2IwAEyZFA2QxYJyGgKwBQ0/8tiQ4AIMlS60+2"
"BQC5/EfvAUAQMEX+VRGiBEDmX0nmH2IAAKf/reZ/QEqJ+mXkz70AtZFGX4C+B0ABgDozAGiZ"
"gY56KhGECdNvCBXPRvx5m3It5p8nlcvp//oMdzj6kRN4z/8JHQGaKP1PHQG0OwFwOwEAdTj+"
"GnW/kxh9GIIanxDU7zgBANTOxDfkFj4P3MGrgXczBFyudkV54BfSG/+ig+HPZPjfFgnJ6P/7"
"m3Lsj7v/qfkvS4gBwDD97zrS5et0CwCk/tUB4Eq9J5cAHAOAZQ8ALwKaJQGAsgB0EXCaHQAY"
"BzXHxkD1EVEKqI55CSqjEQIOjITyqOcZAkrDhwkICHkGSoMHcyagJJBEADCgcwBwJ/PvBXlo"
"+qTcvU+xyPDZ9OmYD0EAG/8TrIydMt3fKQA8oQOAVgJQASDbf0znAOAxkp+UESDl+KB8EQQQ"
"CHKpNID/Xd4+ygwgDAS9DIXBr8CZ0ClQFDYNzobPguLIOVASRUCwgDcOEhRUJS6DxsIwaKnJ"
"vgMAtwEA+LhtgSMhW+BMwlZoyNgCjZlbUWT+26ERo/4mMv7cXZzyP5/jjBH6LqhOR2U4Q222"
"GzeTni/wwejfDwFgHwJAIKf6dQDAyJ+ifysAVGd7iUVAqRT974VzaP50DbAufR2cz/gazmd+"
"DU1ZKxACVogsgAMAEIt+tAM/NPInU/+c/vcR5l/qi8a/TwcAAQFWABCm3yE3Al4u19YD+yEQ"
"+AkI4CxAsICA2gjlCmCMbAK0lgDEJsDrWvMfRf8EAGj613XjVwEgSQJAsgMAOKnvAPgGQeBy"
"bTRH+yZpAICyBQCZ9ifTx9+zIdHIaET/UQoAqKOBGgDYTgFcqReNgWT+HWT+DAAhqGAGgI7z"
"2Ua6X4n6hXI4+k/Z/Ec48qETrH35p8fJ96T/9ZB++Gvpj7cdAKijgPbOAo897NMrigGgZhLc"
"rPoQ35Rb8Qu8A7+4zjwSeLlqL37h3fGL64XyxTdeuAEB0vy/v5lvmD8DQKbQ1QwEADL8NGH8"
"aPasK5bonwHgNKtzANCmAOJ5RNG8CVAZA7QCQDO9kfzMUwAOAUDsAtBXAdsAgOgBMAPAWKg+"
"ihBATYExo9D8X5IAMAKFAEBZAIKA0CECAlAlQYMRAAbqAFCk9QGYegD6KADwFCtnDwlNfzfp"
"CQaArF1PsDJ3Ps4SaX+Z7u8mAIj6v1C2P0nU+7N9R+kAICBABYCR/DEpx+cFAQFeAgRyvF9E"
"CMDXlBnwe4mzA3n+YyEfIaOASgWBr0BRyFQoipjJ2YHiyLlQEj2fMwRcNjgwH8oTVkNV5j6o"
"Ppt8BwB+BABAhn84eDPkHNsMDembUJvZ+BsyEADI/LM089/JIvOvzdgGFae2wLmkDVCesgUq"
"U3dCTeYeqMPoXwCALwKAf5cAoJcAJABUpLtz9F9Kh4AQAIpTdkFd2lpoTF+KALAMtRzOMwSo"
"ALBRLwHoACBT/+3F7tDOHf8+Ur5641/nAOAvzL7MV4jMv4wOBAl1VPiiEA6q9hsQUBNmOQYU"
"Y9kDcNho/mtSon8TAJBOGr0AZPxtSTYAQA1+LA0A8DWZ/6VKNPlKkeYXCtOllQCM9H+ENP9o"
"Nv0r9Qd1dQ0AKgRoUwBhQhzty4i/Dn89/FwHPq/Uh7L5d9SHoNmnG8bfqBq/iPzJ/EsPfwpH"
"P3aCIx84wbLRP41yEiOA9s4A24wA3g4A0OlVQBoF1AAAqqfgm3GNmAbgnQDOEgDc8AvsyQDQ"
"Ubcf33wRbPjf30AAuIEAcEMav979nyF0NR0BgAw/VUBAhyFu+iPj16QDgGr+KgBoUwDxdgAg"
"tgsAiGQIsAEAh8eA5hnHgFJmdxMAJARoABDzAlREj2QAKIsYrgCAEANA0CAHACDNn0QlgE4A"
"gBr8BABoxv8YGr9h+unWHoAfAACc6rcBgBGQ4TkCn/YAwHhm8+dH4n87Aj83EnK9R0KeF8HB"
"KAkE40V2IBhhIHQGnCUgCJ8NZyPnQHHUXCiOnsdgUIxAUHLsMzib6AwFJwMg8/SROwDwNwQA"
"1z2bIcRvM5wI3wSFcRvR7DdAfdpG1GaWbv4U8bPQ+LN28MflJ9dDcfxqKDi2HIpiV0JJwjoo"
"O7kJQWArVKY5IwDshbpsN6iXGYCmbgFAsAMA2I0A4IwAsBPqUlcLAMhYylkA+wAgMwD60h8N"
"ADwMAJCz/qLpz79rACijLIGPuA9QZlZHhY+RBajcLyYDakLhqpYFcHAOWG/+a1KifxMAoPm3"
"pxggwEafbBF9LkWIav/4ucs1aP4Y7esAUBnCukSqIoVyCUAAQLgcA4wUa4G53n/wFgBA3gYw"
"AYAwexZH+/QaoagWDb8ODZ9e10nzb0yX0X6eYvrS+Nn8c/B9cQjil/4rp/8JAByMANq9Ang7"
"AYDDUcDpY//vFwYATILvq+fiF1yOBFbuQgAQZYCOWg8UvmHr9uEXIADffJHwPZr+9zfyFQDI"
"kc1/6Q4AIFXKqPkLkfmfYtkCgDoGSNF/HOvmRWH+N9uti4BspwCuyyzARboHYN0DcAsAwD0A"
"+hjgeNEESD0AOgAoGYCYF80AoPUCdAIAVAbQNwF6KQBAPQDWEoACAHrkv/0xCQCobY9BWqcA"
"YPQApO/opUwBWAAAo39R839RCA0/w3Nk9wAAP5ftTeb/PGR5PQfZHs9BjifKbThkez6PP2YE"
"ft9IfL7EvQMEAwWBE1CTEAqmwJnQ6QgDCAQRCARRc/BJQihAnY1ERc2D3JjPID1mHSRFbYND"
"4e53AOCvAADbN34FQR4r4UjQWsg+Qka/DrUeDXUjqyGDtAnq0fTr09H002XUnyEi/upTm6A4"
"biXkHFwC6REfQWbMp5Bz6AvIP/o1nDmuAcBmBIBtUJm6C2oy9kgA8OAegKZCP2g5o/YAUBNg"
"sNEDUCYBQI4BWgGgBKP/4pM78Pe80j4A8Hrg9ToAUPTfOQDQrL/R9HdJf6oAINP/GgDwcSAy"
"fS8pCQDl3iILUOmvAEAIAkC4AQHyNoAAgMO3CAAn7QCAFvWn6KIegUtVEWz8VgC4VBksFcRP"
"+pwOAFrq3wIAegnApgdAmn9tROcAUBtimH8d/Z0E4a8hVaeav8X4G0TUryl9Ty849qkTp/8P"
"IwAM+v1Pv3C6hRHAHzsA0LeuRgGnqgAA1ZPh26p3ZEOgBgEu+IUW0wAdtf74BdmPX5wgfMNF"
"IwRkSwDI/QEAcNow/0saAMioX5eI/IUw+m+PY3H0304AQPv/j9lZBBRjAwCXSr62AMBr9ksA"
"KgCoTYDWPQBWAKDbANQDoAJApCwBkLrIAAgA6CNuAXjJg0AeyhhgdwBguwEA5gyApQSw1QCA"
"tC2P6U2A9Mz2G4MahaaNET+auoj4NY2Uxj9ClABMAIDSXiMkZHuPEOaPpp/liabvjvJ4FrLd"
"noUs92f540x67fYcPvHno58Tf/4s6ivwppIBNRNOZBgoDJ0GZ0KmQ1HIDCgKnQVF4SgEA/Gc"
"BWfD8EmKmAk5YYshJfAdiPFeAsGun8GeLV/BquVL7gBAJwCwcP50WPLhq7Bnw3sQ5PIJnAxb"
"CoUYodefXi2Uuha1TgjNvx4j/rq0TRztN3J9XzP97VCDhn8ufgXkosmnoeGfDH4PToa8B6dC"
"P8CPP4SMAwQAXyIALIMzsSsYAEqTN0E5ZQCoBGADAL4GABQjABQHKWOAod0DgJSdaPzL7JcA"
"TACw1dwD0CUA+JvG/0xjgDYA4GVIgoAAAK0PIEAAQDUBQJiSBbBeAzxiLP8xAUASmv9J1o02"
"Edl/o+ukYfxq1I+i0cHL1VHS+MN1EDABQAWZfyBDwOXKYHMGQAEAc/1fBYBo2QAozL+jNlwB"
"APUaoAIAdSHC/BUAuEwA0JimR/3WiF81/5KoN+D4505w9BMR/csRwKlOtzACeDsBgHUUsI+T"
"HAW8UvRSqwEArwBUTYJrFZ9zPwBNBVAWQFsP3FHrh1+QfQwAVxuC8U13AE0/ywIAjkoAZP6n"
"+alG/QIAUhgCBAAkK0rkyJ9F6f92cf5Xi/5vaql/HQAOSfO3AgC+WSs2iCbAPFH/ZwDgPQCL"
"jSkAbgJUewCUMUC5CbDuxAQJAGMlABhNgFVaE2DMC6IHIFKm/+31ACgAwObvYwWA3qIHQN0D"
"oAPAU7YlAAUA9BKA9loaPmcFtmofPyYAYPNjHKnn7BuDEnP+ZPxc3/cWhp/pPlJqhC0AeIwU"
"kT7JQxq/u2b8KDR9khUAstyGQQZp7zBIR2W44NPlWUjbMxxS9zwHp/c+B2muIyDdnUBkDG8h"
"LNj3ChQGTIaCoClQEDwN4WAqggHCQfB0fM6AM2H4DJ2Jz5kMBWcJDqikEDWPleS/AI64zwfv"
"9bNhx7Kp8N7CMTB70rPwwpCetzUATB7/HCyYMRreWzQBti2fB+4bF8HxfR9CStinUJuynFWX"
"sgLqTq6UWsGqP7UKAYC0xgIAG/WIv/rUWig+sQzyyPDDyfDfQb0NJ4PeEeaPSg5+F1IQAtLC"
"P0AA+ERmAAQAFCesRQDYyD0AFak7EAB22wcAGgMsDkQACBQAoC8CCtUBgG4BVGfZlgBKT20X"
"pi+bAM9nyiZAFQCoDMB7ALbJMUBnowlQ7QHQN/75iddlfgoI+ItNgJr5l/qZSwAMAJ74OSEB"
"AEYPgGMAiDGaAGX9/xrV/7sAAE3f8POk6XNk/tea4/Df90hh+qrsAUBFACrQAgBqA6Da/a9O"
"AWip/0j9IqAZAOgZJtQpAOCv25hqa/4NVvPPgdrTzhD/hRPEfuak1//DXv9Jq5MxAtjHqRsj"
"gLcLADgaBXzWiUcBhxcLAHhFAgCqcgpcrViOX/Dt+AZwRkJ04V6Ay7W+EgACGQCuNoayyZLJ"
"2wKA2gSoAoBm/inG85KQqPmrUb8wfqE4BQBiOfq/2X4E3/By/z/fALAFAO4BaCIA2ALt3Pz3"
"lgIAi41bAPIYkDEFMNO8Cli/BfCyAQC8B8B2DJCbAC1jgJr52wAARf8+8iAQAYBWAlAAIF9u"
"AOQxQG0KYPeTShOgLQCw2W+T5YAtj9kHAPx86qZHIdNlIGT7j0K9xE1/WRjFZ2IUn4lmn+Hx"
"PBu/0PMWABDlAC3aF8aPchuuG3+WxzCWAQDy+xACGAD2DIX03ag9z0Da3qFwatcQOL1rGJza"
"OQxO7noWkncOh+Rdz0HiTqGTziMgxeVFSPMYjb/mOMjfPwHBYCI+J0F+4CQoCEQ4CEIwQEAg"
"IChCIOBsQcQcoUjSPCiOQEXNF4pewCo5sBBidr0CAevHosbBx3MGwCek+QNg3NCHYXjf+3Xd"
"88tf/E0A4MF7fwdjhvWAscN7wbjnesPMcQNh+XtjYPn7Y2HFB+Mh2vU1iHFbDPH73oGapK9Y"
"tUlLpZbxs4aUrGkZP2vxqStJfFx3aoUQZwLWQkXicjT7LyHv4KeQEfkBJAe8gUb/JpwMfBNS"
"0PRTyOhRDAEIAGT8LIaBdwUARH8M2QeXmAGAmwA3Q8Xp7VCd7owA4OoAAAKMRUA2mwD3QX2e"
"jwUARBNgddpmHgFk46fIXxsHzJEAkLtOvwWgNQK2qWUAAgCaAjhnjP+pkwDC+CUQnPOVkb+f"
"DgBCPiLyVzMA1ANQqTQAchOgLAHoPQAxxhigsvznGpk/TwAkdgkANy6cMp5SBBAc9VfJqF9/"
"iteXGQKsAEA7DYJ4CkBfBFQTYYEAMwiI6N8OAGimzwqVABAqjN8CAB11+N+czzTm+m2ifgME"
"mgpCIXndv9kAgI8xAvisUzdHAG83ALCOAg51olHAwP7HDQCYiOZPwo+rpuMXeyN+0Xei+cuR"
"wBpvvhR4pT5AB4Br58PRZKO5Zm9uAuwOAEih8X/LKf9kw/gvquN+Iu0vOv4x+r9wjKP/m+2H"
"4Xorqu2gkJ7+jzGNAV5rojeZGwKANP+8N6AthwBgEbSQ+dMmwHQ5AqjvAZhhugYozgFPEMeA"
"eBWwtgmQtgC+wJsA1UVA5RHDeREQ7wAIFRsBaQyQZEwBPC0BoI8dAOhjAoB8vgHQU+wB2NOD"
"GwJNAKA3AUrTp+h+26NmAOCUvwYBBACPMgCkbXmCzT/bTyz6ycRonlPyaObpHpSif15IAQCR"
"GRBQIFL9z3M6n6N+N2H8me6GKPI3AYCHHQBAndpJGgIpO4ZA8o6hkLh9GGooxG8dCnGo41ue"
"geObn4Gjm56BI+uegYNrB0HspmH4fcMhAQHhtOsoyPBGMPCfiDDwChRQxoCyBSHToTCUMgSU"
"KZiFYDBb9BVEztWlA0EUwkCU2FdwLuZV1CI4d3Axq5R06DWLXofSw29ATtirELj5FQhiTVI0"
"GYK3kKagplo0DYK3TofgbdMhhLR9BisMVXjgPaiK+1RXdfxnQgmkJagvpPB1ovi4JhE/Zi2R"
"P2YJ1NDn4+mJiv9c+Tk+lc/P8Ps+F9+PKo39BM4e/gCywt6EtJDX4FTgIjjhPRcS/BZA4r5X"
"IcF/ET4Xo15DCHhdCCEgOfAthAGK/t82AACfSfQ5FQBiPoe8I0sFAMSvgXNJ60Uj4OltaNa7"
"oC7LBeppD0CeJy+OajnjhwCwTwcAzgKcC+JbAO3aLQC6BsjngD0RAMQOAB4DRAhozFwjlgCR"
"sleZ9wDkKKuBaRQwX2QB2s7slHsA9soxQHd9/7/dTYBs/gIQLuPry6U+4lnma4EAb2UKwE/Z"
"AxCi7wIwon9jFJBT/zT6d15c/qPo3TQBwACQ7BgAWKdZVxuOoslHKsYv6v56CaBLAAg2RgFt"
"9gAoIGC6BWAFgFBbUX2/VjT96QDQcBA6mnKMrX682Mec7tcg4GJVMqRuvQcSlv+EAYBLABIA"
"1k3URwCHOnVzBPB2AIAurwIe9OwdzQBAkX8Vmn/VBAQAfF1BmQDaD7BZjAVWuTAAUBmApgGu"
"NgQhAIQIADiPRtsSwx37AgCsY4CpnQAAmX8yS9T8ZZf/RXO3P+l6eywKzf8Cmj9G/jfbJADQ"
"3v/Wg/wk4xeK5mZFiv4JAK41YOSQ/yZ3/1MDIAFAS9arCABo/pnzjVXA9s4BJ0wyA4DNMaAR"
"QlHP8yrgikhh/qZNgCoA6HsALADg29vcA2AXAHqaFgHR8h9tDLB7AKAJjX8zAsDGR+D0hoch"
"Y+9AyPKlBT/U6S9q8hlo/unuz6FRC2kAIJ4CCDK1qF+P/FGuw/5zALALAQAhIHn7EEjcNhQS"
"tg6BuM1D4AQa/7FNg+HohkFwaN1AOLR6IBxY+TREoSJXPA1hS/tA8Fd9IPCL3hD4eS/+fPTq"
"QXB0y7OQ4DwCTrmPhkzfl0WGIGiagAFdM7mngEsG4XM5Q8CjiTIzUCJBoJRhwCqx9liIYID0"
"JpRJlR99i1V29G0oO/aO1LtS77NoZTLrBOlDVuWJj1Af66qKQ2lPhoLPpPB1/Cf41PQR/jj6"
"7z+ASvw5q0ix7+MTFfseVMa+C2cPvgG5YQsgNXAuJHrPgKN7JsER54kQumEMRGwZB9E7JsDB"
"3fi5vVMh1mMWA0C87zw0/wUIAgICEvwXSxBYDEn7X0e9wRCQHER6m83fPgB8BnmHvzIAIJEa"
"ATdyH0BV6g6ozdyDAOCGAOAhNgEW+kIrZQF0AECdE1mA9tIg7g+wCwBo/tXpWw3zz1otov5s"
"+cxdy1MA3QIAWgREEMDy0K8B8i0AHg30lnsCPKX52wEA0xigr+z+DzB2ANA2QC3615YB1Ytl"
"QH8RAMDXHfVH4BLV/Lnur0BAVwBAPQBUArACgHoPQD8GFKnLaPCzlwHQzF9E/Zzm1wEA1Rhn"
"XunbqBp/lqJsuFCVBJm7H4XE5T+FhK8FAMQqALBszE/pDHC3rwDeTgDQ6VXA1R/dt1PPAJD5"
"6wAwUYggoHKrGAms8ZLjgPtEFqAxGN+UYToAXGs5gm+yOF4AZABAqgSA0w4AgMw/iXXjUiK+"
"UeNQJ+DGRaPb/0Y7Cd/8bUdZN9rx10Hzv9F2CE3/kAQAVAs9o6W06J8AgDIVIXCBegAYAF5D"
"AFhsHwCUc8BU+69LmoIAQOY/EWpOaOn/0VBLTX+HXkQAeEFeA3xOHAPCyF+/BRA+xAQAvA6Y"
"FwGJbYD6KmCtBIAAUODT29QEmK8AAI0E2qwC3i0XAcmGwPTtj9sHAM38N4u0f9rmRyBtE5m/"
"AIBT+Mzyfp5T+xkY0WeQyVsBgJ4ewvQpMyA+P9yo99sFgKGsbDR7mxKA61AbADiN5m8CADT/"
"BIz6yfyPbxwMxzYMhCNrB8DBNSgy+OX9IWJ5P2H+X/Rk49//SU/w/+gp8P3oSfD+8Enw+gD1"
"4ePg9u5j4Pruo+DyzsPg8cFj4Pd5D/DHHx++cgCE4s+TuOcFSNz7IoLCOG42pAkEWlpUrGUH"
"CAYYCCxSIKFEB4TXoFSq7LAGBSJTYOhN1NsogoN3hGLf0SGhAgFBF35fpfY6lr4kNhInAAAg"
"AElEQVTvPUXic+XH3sYf8zbkhs6D9IBZkLl/FhzdNRaO7RoPYetGQNDq58Hni2fA5eMB4Pbp"
"IPBcMhi8vxoKfl8/C/tWPQ9Ba1+EEASA8M1jIXLbeIjZOREO75kCx9xmwHHP2RDHWYD5EO+3"
"UECAH0HAq6xE/8UMAKwA0pts/BoE6D0AJgBYziOB5xLXQlnyBgSALQgA2xEAqAzgAg25HnC+"
"gLYB+shGwP2stuL94hpgSaA4B4yfayz0g/pcL6jO9ICKNFcoO70X5YzR/0qxAVCDAAsAGJcB"
"1ysAsFW/AmhsAnQVtwCKJQiUSMlzwML8BRRc1rr+CQK0HoAyHwUA8Em1f30V8A8AAL0EoEwB"
"tAoIsAcA9H0dtYfQ+KMlAMhndwDANAUQrAAAqjpMKhT9IUQqTCpcN32hcDsAII2/JlgCANX7"
"ESwaTynb/fJk5K+Yf32mVBZcqEyEtN2Po/H/E+qnEL/sJxBnAYAZfX+60+kWrgDebgCgjgL+"
"wUkZBfxgwW9XG02AE20BoIKyAzPFgqBqbRzQnwGAFjJYAeBaC5n0Ce727xwATkoZNf8bFxMM"
"AGCR8cdKHeV6/3Uy/vZDbP43ZNr/OtX7GQDw2RKlywoAF89+IQFgMQLAIgUArMeA6AjQNKhP"
"RPNPnAS18cL8a05Q+l9E/zWHX4Lqgy8gBGDkH4MAcOBZqKRzwHwNcJhxDMh0C0CoxM4tAHMT"
"oBwD9OxjXAN07233GqC4BSDXAGuLgLY/bgMAFPGnypR/Kho/a+PDbP6n1/8JUtb9Cb//yS4B"
"QHw8HNLdyMCHc/OeiOjJ+EVkn+mimL/bEFYWmn22h8gEOOwBsAMAZP7xmwfDcYz6Y9H8j65/"
"GgHgaQSApyEGTTvq634QvrQvhH7ZG4I+64Hm3wP80Pz90PR9PngCPN97HDzeRb33GOx961HY"
"89bDsOfNP4HzGw/AtsX3weYFf4R1834HK2bcBcun/wqWz7wLVsy6C1bNvgvWzvsNbHn1d+D5"
"4WPg+dFj4PXx4xC4rC9ErX0GNVg81+Pvb88oOOUxHk55vgynvCbAaZLnRKlX4LTPK5AXMgvh"
"ACHh4Ks6KJDygufAae9J+GOmQSrJdxqcJvHHUyHVbyoke0yCmM0vSr3Az6BVz4L354PAZwnq"
"i8Gw862esOW1J2Hr4qdg62tSi3vAttd7wY63esPOt3uB87t9YNe7fcH5/f4IAU+D+2cDwROB"
"wGfpUPBf+RwErnkBQtaPhvBNY3QAOLR7MgNArCdlAeZAvC8CgO8ChoB4hoCFQlwWEFmARMoG"
"2AMAngL4RAeAwmNfw9m4VVCSsAYBYD33AVSd3gY1GVQG2IMA4Abn8z2hucCbywAtZ2kfwD4L"
"AATwquDGAh+oy/WEqkx3KE9zYQBoyFjHdX9WlgQB/QbAGuMioBUAUG2FdApYrAQW0wAuCggI"
"82/n40DuuvFrGYJLCAVCXmz+JgDQzL9ivzwGFKTcAghTNgHeCgBICGhNVADglC76scLww43I"
"X88CRCgQYJQDbPYASBAwAMCqIPSHYEUhDAUdbPSi4Y9ed8inFv0L80fTrwmUY34xcKUp27za"
"V43+67OkBABcqEjAfz+egITl/wwJyxAAliEALEUAWCJ6AI58JEYAxz7+k9VO5hHAPzh1MQJ4"
"OwCAk/yD/Xf5B7WOAo50olFA0xTARMX8JQBwT8AscSeAsgA6AAThmzLUBgCutR7HN2I8N/bZ"
"7wFI0QFApP1FzV8AgDR+VixH/kJk/odYN9oPsvnfaJORP0f8B3g08XpLBCqSn1r9/1pTCP4P"
"hG/IivUi/Y8A0JqN5p+10AwAfA54JgIAmn/yFAQANP+EiVAbR+Y/DqqPU/QvDgDV0PGfmBFQ"
"RdH/geFQgQBQwQAwDCXPAYcNltcABxvHgFDWa4AMAOoeAF4E1Nc+AHApAOXay3wNkMsBchWw"
"nSZABoDNFgBg8zcAIGXdQ5C6rZdDACCluwnTTyPzdkETdxkqo/xhhvFrn3PDCN/1GRYDAJUC"
"KDvgbgaANOchZgCQPQBJ255BABgMcZsGQuz6gXBs3QA4sk4AQMzq/hDzdX+IREMO/6oPhHyB"
"APBpD9j3MZo/Rv2+7z0B3u8/AR7vPA7ub6PeQQB4EwHgjYfB+fU/wc7XHoCti+6DTfP/CGvm"
"3ANfT/sVLJuKQgj4esavYMXMX8HqOb+GtazfwNq5dyMQSOHrNXNQ8+9GeCDdI/U7WD//97CB"
"tPD3sH7BH6T+KDSfdC++vhfWzb+PtX7B/bCB9OpDsH7hg6gH8HMP4ff9CX++h2AtPtfO+xP+"
"evgatWY2vp77MKxGrZnzCH7fI7B+3qP44x/FX/cx1BOwcQHpcdi88EnYsugphICesOPNnrDr"
"bQIBgoB+sPcjBIBPEQCWIAB8ZQBA8LpRELZxNERsHQ8HdkyAQ86T4ajLNDjmPhNOeM2GOJ+5"
"EOc9H58LUAgBvkKiLLAYEv1f496ARMoEIABo6goASpPWIQBsQgDYCjXpOzkL0JDjAufzPBAA"
"vKBFuwmAaiMIKNmPAEBngffz5xvyvaAuxwOqMlyhPHUv1KVvgibN/BWJ+j+Z/1q7ANCcv5nV"
"yieBJQQo54BtAUDJCmgAgDAg5MkjgAIAtBXA/vIgkL1rgOHyFoAKAPaaAJUpACoDcCkgwS4A"
"XG2MlXX+MKkIafSRSglAzQKEwUXF/O0DAI0DkgINVQWgAqUIBoIYAjiarw2V5i9VI1P/NSEi"
"8ifzrw7glL/pop/poI8KAIr573oKo/5/Qf0zGv8/oRAAvkIAwOifdwB8ZBoBHOlkOwL4M+mP"
"/2TPPG8HALCOAt7jZB4FnPxdxfirOgBUTkDTVyUBoGIyfv9s/KLtQQCgRsD9CgBESgA4bAKA"
"621i3eS3+g6AUywNAG7qdX8NAOIlAMRKHePIX+iwjPaF8d9A47/RdkBG/zLtz5F/uISACKP+"
"zwCA/6NV7ZILgBYhAKD5Zy1QSgDaJcDp0HgSASBpMtSR+cdPQAAYj+Y/Fqpj0fyPofkfeRFq"
"qOkPI/+qg8+h+Q+DiuihUEFRf+gQjP7R/EMHs/gUsPUc8P6nFQCQ0b+WAXAEANL8VQDI2dtL"
"7wfga4DOTxq3ACxjgJ0CAD41AEhe/SCkOvcThu8xXBi+q5QNANAIH5n8EDZ73fj3DpHGP6Qb"
"ADDEBADUA5Cy4xk4iUraNpij/7iNCABo/sfY/PvDYYr+V/WHAxj9Ry7tA2EEAEt6SQDoYRcA"
"3N5+FPa+8QjsRvPf9dpDsGPxAxjd3wsb5xkAsHSKAADScoSAlbPugtWzfo2m+xuUMP3V+Jq0"
"atbdsGqugIG1c++R+h0a8u/RuFEIAfRa6A9o2qg5JPz18NdcPede1pq59+H3o+Y/AKvnPYDP"
"+/H7H0SDfxB/7IOwajZq5oOwYsYDsHL6A7Bi2oOwfDpqxkP4fAhWzkQomIUwMPthWDv7EVg3"
"ByFg7uOwYd7jsBFhYNNCkQnY/kZP2EmZgHf6gvN7/cDlowEOAOAlBoDwLWMhevvLcHAX9QFM"
"gaNu0+E4ZQEQAo57zoET3vPw9TyEAZTPfIhnGJBlAeoLUACg+xkAMwDUZ+9FAHBHAPBEAPBB"
"o/eTAIAq2YcAsN8CAO5Qme4CNWlboDF9uRj9081ffGwXALQegLyNqE2s1oItKO0s8G6GgPaz"
"xm0AMwC4dgIAXmIPAAOAPx8EEpcAZfSvA0A4nwPma4DyUp75FoDcAcBjgNoeAHkJUL8GaADA"
"9VZa63tImr4CAJXS6K2jf3YAQFv84xgAAnRdqtyPP0eAVKCeEehgkw9h01dF5q8DAPULnM+0"
"mH+BvuLXlP6XAEDmn7GrB0b+/xPil/0LCgHgKwMATmD0f+wTsQQo+h2nq+RzTuYRwHucuhgB"
"vJ0A4J/lH/QXTnZGAWtTRxabAKDSCgCTeTQQKqcCVM2AqzW7bAGg+YAFAOIYALgx5aJY+iMA"
"QFv2k+wAAI7bAQBR89ca/cj4b6Dh32iNElE/PUnNGPk3h0sICJflCWpUDGYAuFrvIxcAqQCA"
"5p8xD5pl8x9F/w0nMfpPegXqyPzjX4Zaiv7R/KvJ/I++hNH/SKg+iNH/gecQAjD6jyYAGAIV"
"GPWXYbRfFjYIStH0S0Op5j9QKGiALQD494Mi3762TYAqAFh6AMRZYBUABARk7RYQkMGngJVb"
"ADuMpT92AWCDAgBrH4TkVQ9A8sr7IWUT/lzuwyHNVYv0BQQIIHiWAYDMP32vYfIZ/Bq1lz4e"
"rH9eLwFoAOAmJHoABACk7RkMqbsRAHYMgpTtg+Akmn/ilkEQv2lQpwAQgeYf9mVvAQBKCcAe"
"AOx5/RFwfg0BYDECwKL7YcvCe9Es/4CG/lv4GqP/ryb/EpZOU7MAd6H5CghYPYtM/zdouJoE"
"AHAmAAFC6Hdo6L9jEFgzDzXn91L0a/weRU80/7kGAAgIwOdcBIC59zMQrEbjX4nGv3LmA2j0"
"KDT+ZVPvh2VT7oelk0kPIKzg56YgCExDCJj+J1g540+wZiYCwOzHYD1CwPq5CALzKBPwpAkA"
"KPrf/UF/cP14IHhQH8AXz4Dv0mEMAAGrR0LQ2pcgdMMoCNs0BqK2jtP7AI66ToNY9xkMAbEe"
"AgIYBLxIIisQ7/OqgACtHGAFAHUKQAEAvQeASwBmAGjMc4OmfJkFoLPAfBoYQaAYIaB4H4OA"
"DgC0PyB9PTSmLUN9Leb+M5ZbAGClXAG8xrYJMG+DhICN0MpZgG16L4BxGXCvXA7k5jgDQOl/"
"OwDA5i+jf7sAUCs3/8ntf46OAamZAPM5YLkNkFL+bOqhUmHGa2nwF7Wtf6YpAFsAELIHAIFd"
"A0BVkIzwNRAwgOAKvabph8Z4uNJ8Bo3/jJ2TvsrMv1L/byoIgVMb7obEFf8LI38EgKUGAMR9"
"9VOI+xIB4FNZ//+w0xHAX0hftDsBcLsBgLYLgEYfHnAyRgFfzjww5BRtAbQPAJMlAExDTReq"
"mgs36zfLHoDuAcD1i6lo8Klo+Kc7AYA4CQDHpND829SGvxiO+G+0CfO/0Ropo375bMbIvzlM"
"QkCY/L1pAICw0hjAuwAcA8AMAQDJGP0nThQAEDcOak6g+ceORgB4iaN/qvtXxzwnAeBZEf1H"
"PQPlDACDoIyMP2QgQsBAKEHjZwU+DSUBT5sAoMi/LwJAHwcAYNkE6NpTnwKwBwBaKSDT+SnI"
"ZAh4Uo4GKgCg9wA8au4BUAFg9YMMAEnL74OUjU9CGpq5WNTzLMsGADBqz3AZDOkug9DMB/Nr"
"fnYbAEQPAAOA82Bp/oMgeetASNw8kM3/xIYB9gFgWV8jA/CFpQfgfdEDQADg9pYZAHYuehC2"
"v3o/bF5wLxqlAQBfIgB8NVVAAGn5jLvQWAkCfo36DUbhhlQAoP9eA4DVBAHyuWqWpt/jj/89"
"Pv8gREAgzX/VbAkCaP6r5pDuQ2G0Pwuj/Rn3s/l/Pe0B3fy/euV++BL1BeqrSfh9Ux+EFQgB"
"KxACVs94GNbOelQHAD0D8FpP2P4mAsDbvbn+v+fDp8H1EwSAzwaD95dDwG+paALUACBkvcgC"
"RG1BANiBALB7MhyhMgBlATxm4nMmwgCBgBkAuCTgIycEqAwQ8JYOAdY9AGIMcLkZAKgJUPYA"
"6ACQ6wpNCAHN1AtQSKUALwQAH2g964sAIDIB1B/QkOcBDRkb0PiXKgCwzBYAsrQywGplDHCt"
"FGUDNrBa8zcJANDKALwXYLeyG8BV6QFwVwDAzQEA+AnzrxDRPy/9MQFABFytVSP/GAUA1GNA"
"h/gc8FVlJ4AKAB11h6VhG7qoG3iIMPiKEAkBoYrxh1oAwN4q4CAxBaCZP/552PgRbC5Voqr2"
"SwkIIHVUawqST2H8otafY2v+6mW/xjyb7v+607vh9Obf4r9R/waJy+0AwJcIAF/8BI5LADiM"
"ALBt6k9Pkc85GSOAD0gf7HQHwO0CAI5GAZ9y0kYBvfpFCwCYJHoAdACYKAFgijT/GTwVAJVz"
"8MfOhe9qVxlNgAwAR2xKACoAXL+Qgc8MuEGnfy/ZKwFYAUAz/8Oy4Q9/DYr824T532g16v38"
"1AGApJj/eTL/QAaAi8VLJABoPQBmAGhImYoAMAnqEiZAXdx4qIkbAzXHhflXHUPzP0KNf88j"
"AAyHyuhnoTJmmEMAOBdC5v+0UEB/KWH+xfvoAJAFAEwlAMcAwE2AVgBg9RCZAOcekLFLyQbI"
"3f/aFACN/xlTAEoPgAUAkpbfC0krH4LTzgP1bX1p1PxHT9ehOgCQ+afvRTkPMkBAB4DBegkg"
"i6YBqE/ATfYHuAyxAABF/wMRAAZC8pYBkLDpaYhD8zcBAMoKANQDoDUBcgmgGwCwbeH9XP+3"
"AsCXU4QIBL5G81/B+jWb/nJ8LpevCQBWsvkjCMz6Lf8cq2ffg4aO5k+mj69XzqTmQkM6BCAA"
"rJr9R9bKWQgBs/7I5r9yNule/Nz9sIKi/+n3o/nfz9H/0sn3wdJJ98GXE++DL1BLJhIMyCzA"
"1Idg+bQ/warpD8OamQIAqASwaQH1AFD03wujf2oC7MvR/96P5BTA53IKYJkCAGtehJB1L0Ho"
"xlEQuWUsHNg+AQ7ROKDLVAkAMxgABATMNgOAt+wLkP0ACdQQKCFABwAqAaiLgOxMARgAsAcB"
"wAUBwBUBwB0BgEoBntB6xhsBwBvaGAL88PNu0JixAk3/KzsA8LWxBTCDTgEvF4uAcjQIWNsJ"
"AGxlCGilLACtB+apADkaaAIAtQnQzUEPgAMA4AbAMAUA8N84afqG5C0AggDUVYaAIwoAnMDX"
"sWjcEXChfB8afJBu3BfRtOnjixWB4jUZPwGA1CUSm38nAKDuASgPMMyfjJ/ljz/OX0AAy4AA"
"qu13VO+XzwAGgCuNJ4XxK+bfefQvAKDsyMf479Qv4OTqn0PSip/ZAEDcl/8EJ774KRz//CcQ"
"+4kEABoBHGsaAXzKqZsjgLcTANgbBXwCNQg1evXHD+yka4AMAVVyGZDeBGgFgFmouQwAUL0A"
"vq/7VBit3gR4zD4AXDhtAEBHNioXzT/VQQmgEwBokQCApn+D0vxk+hjtc9qfjT9El27+5wN4"
"DwABwKXyDZYpAAKAudCUOpu7/yn935CE0X/CeIz+x2L0PxpqYtH8j77Aqj6M0f/B5yQADIPK"
"A2T+Q6BcBwBRAtABILC/AQD7+/GTzP/svr4WAJBNgHwNsK9eArg1AOgJWVwO6AmZzjIbsNO4"
"/mezB8AKAGtECSCJAeBeVvyyP0LSsvvg9NZe0vhF5J+G5k3p/04BwEVKAwDKBFCfAPUMUKmA"
"AUCWAHYPhtO7BkLKtgEY/Q+AJCsAyCZAbQqAmgAJALgEoGQArADg+a6lBLDYDgCggS+bIgFg"
"sgEA3AswnaYDfi0049cKBNwNy6ksMJP0W4aAVbPuERH/TDR/fE2mv3zGPajfsawAsBKNf+VM"
"qdkGAKyYiZE/R/+G+X/5yn1o+Gj+E9D8JygAMBlBgUsBZgCgDIAJACj6f68vR/97Px4A7p8N"
"Ai+q/y8dZgDAqhEQuPoFCOZxwFEQsXkMRG8bD4ecX4HDe0UZwBEAUD/ACS8BAfYAwOgB+FQC"
"gDgGpO8BcAQAOXuhCSGgmbIABR6sVs4CEAD44Od3QGPqF1JfmiCAASBdQkCG/Djza5kFWGkL"
"AFoJwAoAfCJ4h8gCaCuCbQDAU4eA7gFAsDL+pwCAtvbXBAF2AEBZC9xRewDaS33gAv4aF8r9"
"hdnrCrA8Q/4/eW8BXmWWpW2f6pmer6enp6u6oLBAcC/KcNegIQmSkEBw13gCIURwdwluIbgE"
"AkRwd5cgCXFcCorqv6q6en1rrb33K0cCVM/MNz/NdT3X++acGJCc595LDSJzV5GBbTbLgLST"
"fwbNAIiHV+liz4Fm+iwjAMSZAeCBMv94eE3jjnNT0eivCtO3Z/6mwj8dAF5mHYdbm7vga1Uh"
"GwA4HPVHODTuDygEgLEIAOEGAJAdAL51P6EWQFfpd19Z3rMF8GMDgP9j0dcCl0F9iWpg4VZA"
"50mQjSZPyvS0agM0pgBsAQCyBgLkjoK/Pop3DADUh8oAcE4CwGXUVdQ1BICrqFPvAIB9VgCw"
"ywAApG2svz4mbUHzFxJhf3HyVwBAew1McwDw9P/4XC94fNoXT/+U//eCvGN4+j/sDjkH6fTf"
"AbJS20FmUhsUmv8+NP+9LSGL2v4SmiEESPNXALANtb0x1wDYRAAIAOLJ/I0AIAsA8UrrgG+S"
"1kqtqmOqATABgGwDFEWAwvx5NkCs6A64QBCwWKYD5oltgGc5ClDDPgBMqQwnJlP+3xYADo9D"
"RZbF56qgSddn0z8T25iL9ujkbhcAVFpgqYCBi0spDYAgQPUBS5sgADQRALAYP8ciUiMGgBNz"
"6uPpvz4cm1VfAMAMkQY4MF10AiRPa8BzADQAwJO/VgMQVjAALB5SDRYOqgzzB1aCOf3LcwHg"
"NDJjNPBILwQATzMAUBogmlUMVRyiuxtVAqK1lIATTOhRUhg/CU1/vK99AJjgWwZNvoxm/uN7"
"SPUsz6KIAJl/NJp/DJ7+I7uh8fPJv5w4/RcAAPZSALMGfqMBwGL/ujoA4Ol/9VgdAKgGIH5C"
"a4SANjoAzHSF3XM8YO9CBIAlXhoAcPif1ctUB6BBAHUGUDHg+wDAkSlyEuAMOwCw2A4ArICn"
"N/B6dTGbfN6pUFQY5J8Zo0PAGYSAM5Fo/kIPDbLZBXBpMjxRRYHWAHBttoSA9wUAAQHmFEBB"
"AEDT/7a/BwAk2gUASg+8TKeBSKsQAFbDC/w6L+6vQ6OON4vNX2mL1LsAYKs0fjo0bWTzp70H"
"39MK5PT1uhQIWAOAFANA7l5u7bM2fZPxWxX+qU1/T28ncGTz9IwicGoaAsCUz/GQYgCAyD/i"
"qf8PqN/DwTH/guaPADAaASDE0AL4pdYC2ED6XhmLvgbYYQvgxwIAFou5FZB6H6kFohqqnkW0"
"RvjoAOAlq/67iGmAGgB4yyiArwSAvqgBqMH4ccMAckbCrw/nfTgA/HAddQN1BX76/rgZALj4"
"T/X8J3L4XweAHajtaPykrUJo/j8+3oQQsJn1Fs3/LZn/w3gNAAgIXtA4YA0A8PR/ricCgAz/"
"2wOAlLZs/g+SXAoEgAwjAFAXgLEGoCAAIPNfXxdubagHNzfUx7dJeL+6rrkLwFgEaJgDwFMB"
"FQAsrYWP1eQogEgHfCPrAWQqYI4tAJzi0781AJQ3AwDqUEQZ/EUrDSemfAmnFjdk0yax+RME"
"LG6k1wAsNesCmT5dteeotgAhYRGCxELUooZwekGDAgBAzAFQg4D+YQDohwDQpyxMJTNGAzcB"
"gFSkd1FODUR7IwB4FxcQIBXlXQIiu6u3nfC07oRGXhJVSsi3lDR/AwD0QADoQeZfRpp/Gfy4"
"sii8+pZnjfcth+ZfHqLQ/KO9y/8mADB2AbwLADgFEIkAML6lDQDskHUAe7kQ0A4ArNQLAQ+s"
"6sPizoC1/QUAbBgKR+OHvycAzJSTAO0DAKUBHqP5P7m6FI18IuQeDxQ6EQx5J0Mg/zRCwGkr"
"CDgbIWQHAB6pWgCEAA0AuCXQCACzJAT8YwAgJgGuNxcBKgDg6n9ZAFgQAGhRgEQGACroe45f"
"//md5QgAK4Xwa4lIwAapOCEybxYBwWYDAGy2BQCZAuDH2fzj5cfS0qO1+PdZh4/RcCOpjPW6"
"HphTAa+zE9DQz6Hx3zKE/K1P/OrUb3v6f3BwHJyd5wRn5pTQAODEZASACZ/ia9N/wpFoMwAc"
"GP0vkBr2O0glAAjW1wCTv0mfqyd9z9mizwBw2AL4MQGAo1bAOigXlJcAADR5SgWQ4Wd0dQAA"
"PWQNQF9x+s8eghrOAAA5owDyo+Enas0zFgE6AoDXBgB4ewt1E36mxzkSkMKtf6Lffy9X/pP5"
"//hU5v8ZALbJ0/8WITT9Hx9vlBAgzP8tmv9bKwB4dTtcAsCADwAAqwiAVQqAagAydjS1agMU"
"XQB3SFQEaA0AcXW4DZDNP64+jwa+Fd8A35YQwABQ1wwAqg2wIACIRQAgCFgiagIEAHwtOgPk"
"OmB7AKBSAFQDcHy8GQDI/A9FlIaD4aXh0FhnJG1nOD7pSzi9qP47AYCeu7AERVd6n1jxfueW"
"iKjB2YWN4MzCBjoAaCmABiYAODCjkRkArLsAHLQBcg3ACAMADKgEs/uWh+l4+p/SszSMR/Me"
"hwAwtmsRGIvGH+4pFIGPRbKKCXXTNc6rOEQgFER1I5UQ8nZC80bD7y6NX913dzaoND5XWpg+"
"KpquPqge5fGezL8smj8CAJp/FJm/lw4AYzuXg/BO5UwAEEmFgF6iDoBSABoA9LNTA2AnBUBF"
"gNwFYAKAtlwIaA8AUld0NxUBqm4AawA4tG4gHI4bokUBHNcATHYMABcJAJbAoyuxqCVo4JMg"
"9xia/rFRKH8hCQH5p0JRAgLyEQLyTxMIhAsgOCtTAxoA0DpgsRL40cWJCAAKAqaaawAYAGZp"
"aQAaD/zCtCVwmf0UgNUgIO4AUC2A9gAgR57+c3Y7rgGQAEAjdV/cpU6IJfD8dqwGAc+pLRG/"
"HkHAy3vS+CklwJKbCtnINxsgQNUH6BAgigO36nl/AoD7wvxfUjTj3lptuBErXQJBBurBeqHM"
"Lby2VzN9q3y/2fiNEub/POMg3NrqAefml0Lzd4LTs4vDqekIAFMRACb9BU//n8LRKASAKPsA"
"kBL6CaQEmQDAS/pcHcsHtAB+bABgrxWwFqolqmvOmfZpJgDgKMBvAIAcP4DcYPjboxVo/kcF"
"BLwTAK4L8yf9cBt++fEegsAl0QpIPf/c9y/M/8enoviPzP+np1tFjz8bP+X6N+E1ngGAQMAR"
"AHx/f5qsAbAHAJ6Qd7STDgAHXc0pgP0udmsAuA2QhgBtbwrpCAI8CGibGgTUiNsAVSEg1QBo"
"cwDi6gnz39CAtwMqAGAIWFMPrq36EACoaQUAIgpwYQHVAiAAzFf1AF/JVVQIltYAACAASURB"
"VMDVzQCgigAJAhwAwIFwZ4SAUggAqOCScCAMQWAyfq7FDW0AgKGA0wMN3w8AZA3ACQSA4zYA"
"0FCLACRPbSAmAdIgIGMXgBwEtC4QAcAPAcCfTv9fovl/aQMAs/qUg2m9dACg0394FzMA0D2B"
"wTiODhRDICDjF4pAAAine09SCVaklxMaNxUUlkRzx6tPKSlnlgKAaJYw/yhvKZ9yUmXZ/IXx"
"46m/aznO/2vm70FXEQUY21l0BUR5VoLobpVhgk8VDQBoGNBMGgRELYDDzQCwNLShiABIADBF"
"ACZQISDNA2hnAgAqBFQAYIoAUEsgq/d7AkCYXAesRwBoG6AGANQFQG2APA1wEeRfWoiGPgly"
"0Phzjo6EnCMjIBevuUf9hI4HIAAEiSgAAYCCgFNo/hQROG2GgEcXoiQEREkImMCRAIYAhwAw"
"R2sJfKGNBxYQwG2Ad1bYAQA0/7trtAFAb9I36CkAao/LVPl/Mv9dmvmzTOavA8D36ZvQ+GNR"
"iwQAkBBCNAigVACNJb633mD+QjoAbBIyAYAhKvBApgbSRfhfhf5f3SewWC1TGgYZAICGAL3J"
"P2Zr/DbmbzB8o/DUn3tyFlxdUQMuLCqDp/9SaP54+p+FADCtCL4+FcLXJh0ADke+GwDWDeAW"
"wK7S52pZPqAF8GMEANUKWMIiWiG+s8hWwDuHXS5Bto8BAKwjAKoGwJgCGGhIAYywgoAAgPwp"
"aNbJaPwnrQDgkgEAUG8kAPwgAeDtXan7+NxFsQuAZvvTcB/K/T/bDj892YraooX9HQOAdQqA"
"6gBi9S4AmxoAAwBoRYAdzEWAxi4AAoDdUmoS4E4aA9zUdhTwpgayC6C+GAVMy4A21JcA0BBu"
"b2xoHwBW1HKYAjDXALwbAM7PEzUBPCGQAaCaVgNgDwCORIv8v4IAEwCEoEYjBISg8LEj0ZXg"
"7KJ6DAJaXUBsQzMA2KQABABwCoAAQHUBGNoAeQ7ANL0GQABAAx4FbJwEuCn0G7EDAE/+a/Hk"
"v5rC/2j+y4aTqsHiwVVhwcDKMK9/RQ0AJvuW5vA9nf7HdP5CM38NAigq0LUowkExCO9aDMZ6"
"CtH9GLqnx7oWZ0UQCHg5CRDwKYlGXooV2U1cBQiUxuekvEvj+0t1K8uK7FYG38bTPhr/2C5l"
"0ejFyX+MB96jxrjTPYogoFMFiOhSASI5FVDJBgAo/E8tgGIUcC37ADDOkAIY78IQsGlia04D"
"7JjRAQHADRIXiE6A5KXeZgBY0csuABykjoDfBACzeQ5A1tl5kH1mNmSfGIuG74fGPwqvwvyz"
"jwzHt0eIx46O0qIAeScpFRAqFYYaLdMCo/X6AISAR+cRAs5TJEBGA1RBIEGAoRPAEQCINMBi"
"NH8BAWII0HJTJ4ACAN4FYJz+Z8j/v8ncagCABN38beYAJPLCnedp1P2wWOjWYh0AEEIYAiQA"
"kF7eW1cgALyknL4y/nRVLLhZrw8g8083hP9tAIC2IAp9n76Wowdv8o5Kk7+pF/kVePJXoX79"
"1H9nR1d8TasAFxeVg/MLSsPZuToAnJyKAEDhfysAODSuYABY1vuTSxa9BfA76XslLO/RAvgx"
"AcC7WgHd966ut1sDgExrALDXBWAAgKyh9gEgNwQgLwR+fbrSDACvEQBeX0FdRYOXAPCDAoBb"
"0vzvoO4hGCAEvE2HX364Dj89T+Wiv4IBYKMJAH58qJ/8tfv8DbwTQAHAk/O9TUWAogugk2wD"
"RAg4IIYAUSsgtwFyJ4CLPgeAJgEadwFoy4Ca8Trge9ubiUjAZgUBDXgbYBoafhqd/Pn0jwCw"
"yQwAt9bUh+urEAJ4KZB5F8BlDQBqCuMvCAAWfsPiVIAGADV0ALCeAyABgHSEICBKQUABABDk"
"BCmBJSA1uAQcGFsOTs361g4A2KsBaCRrABrJNkA5BwB1dHZDODyzIY8CNhYBFggAQV/DWgr/"
"j6wBq0bhyX94dVg6jFQNFg1CAMDT/9x+OgBMonC8jxOf/gkAxnQ1CiGgMz7eiVQUnycQEBrT"
"uRiE0T091rk4PkYqgXBA0QQnNHNKK5TEe6FxXggB3ZyFEATI/CO7lcbnpLzKCOH92K5o9J1R"
"ncqgyrL5j3Yn8383AKguAHsAoGoArAGAUgDrYyQAoDYiBGye0ha2T28Pu2Z1hMT5nWQrYLcC"
"UwCiCLAvTwnkdkBDJwABwJntAQUAwAweBJR1cgJkHQ2ErEPDUMPZ9JXI/LMPD8P74RIIUMdE"
"FCCPogBUD6CJIgIhIjVw2lAkeI5qAsbpAKBmA5C0roBp8EwNA9JSADoAPFftgAgBL9OW6pMA"
"DQAglgGJ6X+vOfQvzf/BZjb/N2T+1hGAHGn+ahIg6tX9jfAUv+Yz/JoFAgBHAVZKALCOAMTZ"
"BYCXHA1Q3QGbNCB4SZX+UvYA4NW9VSxqIXyTf9pg/DcMslPsZyfPT8o+MQlP/VXwtawSvl5V"
"wMNKWTg3rzSv9jVFADj/jwAQ8/4AEO3OLYDult/QAvgxAgC1PHxqsdMKGDvxy5UCALwNAGBs"
"A+zBS4Egs5dVEeAg1BA0/eESAowAEIwAQBoNkB8DP7/YiwBwDo3/ogMAuCEB4I4VAJAy4Jcf"
"M/ExfN8XRwwAIFMAT2QagM3fCgAe2QIALQbiQUAaAIglQPknu4k5AEc7y0mAHmISoBoFzJMA"
"28pRwHIXAG0CpIjArpaQsROVILYC0jrgezuktjXlVcBiG6DYCMgAQMZPp38NABqaAWA1igCA"
"ZgIoAIh1BACqC8BcA+AIAM7N1tcBn5KjgE9QHcAkWQcwQQGAhAAEAK0GINwIAE4mAEgOLA7J"
"AcUgGR87ElMZzs6vDRdiGxcMAIvFICCbSYA0CnhmI8MyoAZyG2B98y6A8JqwKUQuAcKT/2o8"
"9a+k0/9QNH9WVVg4sArM718J5vStCDN7l4OpPREAujtz/p6MfjQCwOguQmF0T491wnuPIqii"
"EIYQMFqK7kPR/BkMOhXX1Zk+F4JAV5KTFEIAapxnKZQzwgHKyxnN3hmfQ8Pv4gzhXdHsu5RG"
"iHDGz18Gv14ZNH28updh8x/tVkYDAEcpANMcgH41NADgFIB1EaChBoBGAfNGwJj3AIDl3cVy"
"INMgIGMXwLsAwLYG4P6xiZBxZAw8INM/OERqKCsHDT/bSjmsEQIAKBKAEJBHEECRAFUceJzS"
"AkEcGTBBwLmxdgBAShsTPBUBYDpqpk0NQIEAYJgEKABgPZv/az79S/O3AQBjDUCCHAW8S4T7"
"8Ws9lXIIAMr8JQCIFECcXgBorwiQTV6CgAIAeU/mTwWE399X5k/wsE4HAEptPNiNxn9SK+Qz"
"G/87KvwNVf5Pb2yHGxtbwJUV1eDKssr4uoUAsKg8vk4hAMx1hjOzSqL52wLA0ehP4UikYwBI"
"DtEBYFiz36202G8B/FT64T8NABhnAVi3ArYP6Fd6MuQYAIDMP90BAGT2NQDAQAEB2UNFKiB7"
"JAohINcfFYTmTwrDexKCwJP58PPLYwYAkBDA5n+DQUCYf5oEAEMUgADgxywheuzVcdkKqIoA"
"t2gAIIoANwnjV3MA8uOl6JdyrgEA5BwANQr4uBePAs470lXuAtCXAWWnuEJ2koAA3ga4v41Y"
"B0xKaA0Zu1C7W0N6ggukIxDc29lCaHszuLcVIWBrE7izuTErbRNqYyNh/kYAiGsgtNYBADho"
"A+RBQEvkHADVBWANAEq0I2D2l9pUwFMEAdOqwIkpAgJOTEQAmKgDAEUAuAuAACBCRAEOhhYA"
"AP7FIElpVFFIDSrJRYNnF9S1UwNgBIDGcBKldgHQMiCCgIMzGpuKAI0AQDUAW8bUhI0hsvhv"
"FJ7+8dS/gk7/Q6tB7BASnv77V4Z5/RAA+lSAmb3KwhQ8/U/0EQBAp/xQjy8gtJOuMDZ/vHcv"
"AiFuKHd6nyLC/BEIQggGCAw8ikkVR5XAx/DzdUEQ6KIDAKsLqRSMRRAIx2t451IIDM74tUuh"
"6ZfGj3VGlcKvVxpC3fBtkgIAd5EC4BoAWQTIp39DEaCxDVABgFYDYAUAahDQagKAiGawLqo5"
"xMW0YghQAGA3BfBBAOCgCDBxDFxPHgt3D4ZBRiqZ/mB4cEAa/4HBkHmQNAQy8T770BDUUJNs"
"AIBSAcf9RT0A6VgAFwvmnQgUkQFDJODh2XDHEQAJABQFeHp12rsBACUAwHYUsFgFHKcDgGb+"
"IvyvpwD0LgCKBtCKXSruo5XET2/MswUANP1nCB46AKgiQAkAVASodQFImdoCN7PxK73SRMYf"
"r3UPvLqvzB9P//h3eUWRjOwkNPCLtub+Lj0y5/1fZhyC+/uGwNXVNeDKyi8ZAC4vRQBYXAlf"
"p8qj+ZeBs7Od4fRMBICZCAAzzSmA9wKAQAEAHWt8Mpn8zWK/BbDAGQAfEwBYLLZrgY2tgG2L"
"F/pkAOR0B44CZHYT4f90tQ3QS08BmACgvz4LIHuwhIDhqBEiCpATiKYfKFIBLIKAcNRY+PVZ"
"HPz0/QUHAJAmddcxAPyYA7/8lIfXbPyYq/Dj0z0yGiDSAdQGaDMHQAOAOPghdw0PAVIAwJMA"
"KQpwioYBefMyoLyjNBK4q+N1wPvaIQC0g8x9bVFtIHNPW3iwG7WnDUJAG4aA+7taCe1oIQGg"
"Kdzd0oTFIIAQYAIAqgOIk5IAoKUACmgDVLsALshJgGz6vCHwG1EDYA8A5ojJgAQBHAWYLgYC"
"MQRQFGCiIQVgaANkABjrbAAAVLATpAY6OQSAJH/UiCKwD5UaWBIORVWC03NqOwCAJoZtgGId"
"8MGZBACNIWWGnSLAiFqwZfR3EB/0lTj9j8TTPxr/8mHVYCma/5LBJDz9960Mc/tUhNm9K8B0"
"37Iwyac0jO9WCiK9SvBJP8StMAS7C4V4FBYg4E6PozrqECCEAMDmjzDgXgyfk3JHCCBxNMCJ"
"ISAcjZ/vO5dkjUGNRtMP8yiJH4tX95L4sc4Q3LEUfh287+iMQgjoKACAUgBcA9CpHLcB0iRA"
"HgVsaAOkUcBqF4DWBTDAtgtATQLkUcAEARQFGIsQQAAQ3ZIBQK8BkHMAVBGgAQDUICB9J4AR"
"AKxqAOKHMwBcTPCD2/uGwb2kwWj0A1GDhFIHIggMRMMfZNBgAQAIA1lKEgZMKQCtFsBP7ww4"
"SgoQUYETIgqgIODh2TEiDXBeFQTGWA0GmswyA8AcAwBICLi1qAAAWG0fANj8dRnnABAQPMeP"
"fULriK/PtgMA0vwVAFAHAEl2ALB4HoAZAGzmABQIABu07gFl/iK/f0wM8LHXxufQ8I0S5v99"
"7hnIPT0LbqyvCdfWfAtXV1kDQEV8rUIAmIMAMAsBYEZJODWjBAoBYEoRfE2SNQAxjgEgJVQA"
"QLIEgP/85JMB5G8W+y2AagaAwz8fEwCoVsA/WfRWQFqLqFoBuwkAoFn/3hIAjEWA9iYB9sP3"
"7ecAACgV4K9HAigdwAAwRihvLED+eASBeAMAXP9wAPgpn/Xrz0/g1x/vwU8vjsphQEYA0E/+"
"QnHwY14cPL8eyF0AlAIQANBLrgPuji8etBHQG19QukHuEU984UEIONQZcg4gBKS4Qk6SK5p/"
"B14NnEkwkIRKbI/mj0psBxkIAxkIAvcTWqMQBCglsI1SAc3Q/JtaAUAjoU2NEABQGwwAYF0D"
"YKcLgNcB0zbAxd/IXQDf8ChgGgKk7wWw1ldwXhsPjAAwo5ppKyDNBKAogHUNwMEIMwAcHEOR"
"AAMAhJSAlCCRAmDz90PjH4nyK6IBwH7SSLxHJfkVgwPjKuDX+4rbAGkbIK8DRh2f1xSOzmkK"
"h2cjAMxqwhCQMqMRJE9rKGoAEACoDXCbagEMFACwakR1WInGv5xO/4OqwhLU4kFVYF4fPP2j"
"+c/qWR6mdS8DE72dYbxXKa7gJ6MP6lgYAqWCGAbI+BEGOn4Bwa5F0KAFBNCVRREBjg6g8XdE"
"IOhYDB8vxtdQdxkN6FSCzT/MwwlGo8jsQ/Ea4kZG7yQNvyR+/lIQROpQEuXMCnHVASC8U1me"
"AzCOdwDg6R9P/pF48le7ACb60jbA6qZtgNQGSFEAXgcsRwFruwBCGvI2wJU0DjgcASCSRgIb"
"AGBqO30QkAEAUpb5QPIyBQE9rQCgnxgEJLsAaCfAua394drOvpC+ry9k7O8ND5L7s7JSB7Dx"
"Z+I1M6U/ZKTgld8eqANA6iAJChIWrAHgMNUFCHGHgISBnCOjuHgwV9UHcIGggAD7ABBjqAEo"
"AAB4JPB8+wCgigB5DoADADBFAMQkQLq+vLMGnlydBY+vzIDHV8U6YoYAIwCw+ccaAGCpyP9z"
"+5+cA8BtgGvN5s8AYJwMuMWQApAdARoACPOnz/E6ay+8yadWvtsO+/jthvvttvddg7yzc+HW"
"1pZwI74OXF+HALD6GwEAKxAAlle1AYAzM53xQFISTk6jFsDi+PrwBb4evTsFkBJijgCQr1n0"
"FsCqFr0F8E+Wd7QAfowAYN0KWNliaAXMPtPhjgAAH3HyT7fuAlCDgHrzQiCOBGgAMMQKAEbK"
"WgA/GQUI1tMApLxwVIRQ/hT49cVuAwAYUwD33x8Afn4m9NMTjizQpsAfVSugHQD4/u5EBIDe"
"oguAUgAMAD05FZB/ojvkH++OLyA+eJpANjosIEAAQEcRBUii9cAdIStZam9HyEx0hcy9HSAD"
"YSADQSB9d1tIT0AQ2IUQsL0F6+5WKgpsigDQRADARqE0BILbDASNBQQUAACc78fT/iU0/UtL"
"xEnfLgAsEFMAeRCQ6gL4DQCgdAgh4PC40gIAwmQqIAwVUhJSg5zgAAFAMCqwOCQFWAEAGv7+"
"UcL8k/C6T97TY/R2UkARSEWoOBRZGY5MrQlH0fgJACgKcGhWU4aA1JmUBmikAwDNABjzHRcA"
"agAwvDqsGFwVlg1B8x9YBRYPqAKLBtDpvxLM7lkBZvQoB1Pw9D+hmzNEU5Fel+Js9AEdCoG/"
"q65AVwQB1hcmBbKKQCBFBAgK0PyDXYuiaReFwA7F8KpAoDiEulFEAAHDjYSG7+qEz5XA93HS"
"FExXNP9ANP/A9k4ovG+PAIAQEOomAIA6AWgUcKSnvg0w2puWAKH596gCk3pWRfOvDtPI/K0A"
"QC0DWjiqNq8CpigArQNezguBGsHqMbIb4B0AQDUAKcu8EQS6SwjwFR0AEgAOr+kLZ+J6w8Ut"
"PeDmdm+4m4Da7QP39nSHjH29GAAykvsxAGSm9mfjVzIBAGsQPEgl4x8gYIEgQEUBDg9FDcff"
"R1kXoKUFhkshEBweKdoFCQJUKgAh4OHZ0aixCAAEAZFyNHC0XgNwSUDAU64DmCEgQOsCmCel"
"Lwd6qToBDMOARP5/bcE1AKhXd9fC02tz0PinGzSTAYAh4MbcdwDAMgMArLIZBKQDwGbu6xd7"
"AbbKOQCbdQDgGoB4fu517hE0+mvS9G9Zmb95aY99ADC39z2+ug7u7e4MtzY3gBsb68GNDbXh"
"+lozAFxehgAQawcApjnhaxGe/qcVw9P/F2j+n8Ox8Y4BIDVMAECKrAFYP/CTOxZzC2Blywe0"
"AH6sAGCvFbA5qnPO2Q5pkN1DAIA2DMjeJEBrABjkAAD8JQAEOQCAsToE5EYCPJwKv77c4wAA"
"MqwAINsxAPz8HPUC9ZLfj6ICbx9uRgiIMwHAm+wl8JTM3wYAekL+yR4IAD0gjyDgqLcAgMNd"
"EQA6QU6qO0KAG57+UXiflUK1Aaj97pC5zw3VER7sdUUhCOxpLyGgNaTvRAjY0QruIQTc29Yc"
"7mxphhDQFNI2NRHa0gRuIxTc3thEQMC6huYUgBEAqPcfzf6DAGCePQAQEHB6ph0AmFQBjlIn"
"QLReCEgAcCSqDF5Lw6HRNBgIIWC0jAJQKiDMCU28BMIAAgBBgDEFQIY/SlyTEQz2Exz46c8l"
"IwDQfbKfvPoXgRQEgpSIinBwwtdwcGrdggEgoAasGfWlDQAs6l8FFlLuv1dFmOVbHqb7IAB4"
"l+bTf2SXklzFT0bv374QjDIoAB8L7KAkjD8Ar/7tvwC/dih6rD2pKCsA5d8O70muCAKuxVls"
"+HR1JeMvgZ8L1V4JzZ9MH80/oP17AACtA6ZVwD54+qctgD0qwyQ8/U/qVY0BgIyf1c8WAEQr"
"YF2ZBqgPy0MamAEgskWBKYCkWC80/268GZAg4MhKHzi5zgcubvKEa5u7Qtr2Lixq57q700sH"
"gN3dIX1fTwEBSX0ZAkwAgG9nEBQQBGggYAUACgJQ2QcHiXqAg6o+YAj+fg61qhWgdsHhAgKo"
"PuCEaBXMP6PqAMZyFOAh7wcQUu2ABAEEAE+5EHCGNhJYB4D5IhVAUQAuBDQCwGpR/c9ab+gC"
"0AHg1b0NaPyzZduhNP7LdgDguj0AiOXwvx4BWG6AAD0CYB4FXAAA0DKgHJrRfwXePrsDb5+m"
"OTB+O1v7DBBgPcr30TU0/j1ecGtLU7i9pXHBALC0qiwANKcAOAJAADC1GByfKADA2AVgPQiI"
"ASDUBAA0A6Cz9LcPbgH82ADAuhWQ1iGqVsCmKPfElY12CwDorgNAuqcYCmQzClgCANcA2AMA"
"SgEE6N0AWg2AAwDIi+Ipgnx9PANBYK+pDfC3AgDrl+9Zv/xwE356flADgB/y1sGzy0MMANBT"
"jwA4AIDcg50hFyEgN8UDTd+DgSA7VSqpE2Tt90C5wYN9pI6QkWiAgF1tUK0RAlzg3o6WcHdb"
"C7iLEJC2WejOVoQB/IVJ29hUQMD6RnBjTQNRBGioAeA2QEcAYKwBsEoBqEmACggcAYCqAWAA"
"mCgg4GiMAAEaDHQkugxeEQJkQeChMajRoijw4GgCAFkLECQBwK8YmntRNn1h8GTuRUWEIKCo"
"ED2mAUBRDQBISYFf4HNSgfj4aGfYH14JEiO+hISxXxUIAHT6X9i3Msyn3L9vBZjZvTxM8y4L"
"k7uVhpiupWBcJycY7V4MzbcwjGpXyCR/NH56XEgZf2Hwa4vv2+YLGNlW3Pu1LSLUhq4IAW0F"
"DAS0K2al4kLtSSWk0PDblWDzf18AiPJG88eTfwxqgq84/RsBgEYA8yAgOwCw0A8BIMAxAMRF"
"t7IqAhSDgFJiu8DR5Z3h9Ep3uLSuI76Qu8LNjR0RWN3g9jZ3lAeqE+uOgoBd3TQISN/rKyBg"
"fx+GgMyUfhoAPEjuC+kUGaB7Epo9mf+DlAEaAPD70hXBgR87MFiIOwZksSABAd3zldoFh/HM"
"AJ4cKFMB+WdCUaMRAMJlKkDNBIjkwUAKAp6iOT+9Mk1AgBwJ/JzXA8sVwTcFBLy4TVGApbIN"
"EAHgrlj9y2IAUHMANuKJfz0a/zwuMnzMQ4em6gBgLwJAAHBjgaEGwAgAsVaTAJebagDeBQDf"
"5yTDDw/PwI/P78Fb0rO7VgBgu7Dnnfl/NP/H1+Pw/9oH//9b4s9CCwaAW5sbfRgAqCLAGQIA"
"TkwRAMApADUHIPrdAGBoAWxq0VsAi1veswXwYwUA1QpIvZDlLHorYMeNC+tshGw0+KweshDQ"
"swAA6CtqAFQroA0AqCJAawAw1ACw8Y+TMgBAXozQ45nwt1cpHA2wBQB7KYCnBgB4aQMAf//1"
"tdAvLxEGbvEK4Zc3x8hJgML4RQ1ADy0FoAHAES+GgNyDXQQEoOHnpKAOdEbzR9E1qTOaPyrJ"
"AzIpGoAgkLEXIWCvK0NARkJb1n0Egfs7EQK2t2IIuLNFaltzSNuK2tRMQEBcY7ixtiFcp2FA"
"1AWwTOT+ReW/EQD0GgC1DljbBmgHAAQE1LCbAtC6AAgAJleEYwwASqIo8Oj4smJA0FiRDjg8"
"VgIApQJGyyhAiAAAbgdECEgOLAYpZOqBxcRjZP6BAgAYDvi5InzP7xcggIChIEiavz+pMOz3"
"Q40iFYLE4Z/DniF/gV3DisPW4U4QjxDAaYAh1WAZQsCifmj+vSvBvF7C/Kd7l4Op3crCRE9n"
"iOpcEiIoL+9GJ/dCMLLN52jquvzaF+LH/TSjJ+MvDCNbF4YRqOF070L6gjWiFcqlCIwitSEV"
"hVGtpdoUA39UQNviCAgEAmYA4PA/5//NNQBUDEgdAAQAtA44ikL/ePqP6UGn/yowsWcBACCL"
"AKkGgAGA5gGMqsNRgNgg+wCwcYIL7JjWDvYvcIfjS1zg7LI2cH29C6oN60YcakM7uBnfXgIA"
"aisCwFYPTWkKAnZ6fhgAKDEIDOCrZv7J6mP6SomPNUUFDgzS6gWyDwwRAEA6pkcB8k+HiCjA"
"OUNL4Hmpi/pgoKcyDSAgQNQCPKcoAEumAxACXnAUINZQB7DaBgAo1M85/kuTUVNsAID2D3D+"
"31ADUDAALHnHJMA4KwAQYf7vsxLhh0fn0PDT0Pjvs/mbAIDM/6kh52+3v98WAF7nn8fvcRP+"
"f/SGe7vawl18bWMA2C4BYFMjuLkJASBeAsA6vQjw8vLqGgBwCmBheXxtKgtn50gAmPbbASCs"
"3e82kq9Z9BbActL33qsF8GMEAHutgDVQDVEdAvqXmSIAwFcWAr4LAPobAEC1AY4QrYC/CQBi"
"pCbg2+O5SBDyJwI8mg7wYhf87ce7vwEAXtgCwK8/SL1FuMiGH3J3w4trYQIATvWQa4GNNQAE"
"AN0YAnIPSQhAw89J6WwGgGQyfxReM5M6oTxkJMBNRAJ2t2elJ4howL0dCgKktrdECGgBaZsJ"
"AiQArGsEN1bX5ShAwQDwrXbl1r8CAaAGTwI8N9u2C8AeAPByoIkVJAyUx7fLIQggBERQcSBC"
"wFiEgDEyFTAGAWC0ExwIFbUAaiZAShAqQIKAlAkAyPiDivIJ3wgAKYECAJLQ/JP8SGj8I5UK"
"wR4JAAmDSZ9BwrCisCXka9gU9DXEB38Nq0eIjoAlHAmoBLN7VIDp3crBhC6lIBLNP9ytBBpt"
"UTy9F4LhLp+jqQuNYBgoxI+PYgnj18wfjX+oC35Mq0IwrGVhqS9YI0gMBEVgeEuhEa0QAlyK"
"gV9rVNtiOgSQ+b8LANzKcBGgAoCY7pVgvK84/VsDwDS1CEgOAqI2VjC3QwAAIABJREFUQBMA"
"jKwNy4MboOk3hviYlrB1UmvYPceVDf/w8q5wZKUnHFvlCRdXtoJrq5rjC3VLfMFuhWqtA0Bc"
"W3whRwCId8UXdwSALSSEgC0erLStnRACOqMJeGpRgPREXwEBVAeAEMCGTqkANn0EAIQCuj7g"
"az9DsWB/YfzJffBtocxk9fEKBvqh6avIgEoVDEZgHyJqA7QogD/knwpGCAiF/LNhKAEBj87L"
"CYHaeODxCACTUFNkKmCGBgGqKPD5jbkSABaKNMDtZVoUQKUACAaeXp0ND2n3wIUJ+HnF9kHV"
"amgEgCf4+YVkASAXAVoDgOwCsDcHwAoAVBTg+6y9eNI/jQZ/C358kS6N/74GALanf3sAYAsB"
"pNf5FxBUVsKDVAK8jnAfDzkOAWBjfQEA8XXw56cWXF9rBgBRA6DPATACAKUAqAZAFQEaUwA2"
"NQCh+hwAtxq/m0K+Jv2thuUDWwA/VgAwtgKWRlW3yFbAhjX/wx9yeqKB95SFgF4GAOgmCwGt"
"AcAwDphP/4Y5AHYBwLoI0AgAyvQnCON/KK+k3En4PjMQBDYhCKT9YxEADQB+ZAgQ+ivDwJuc"
"XfDsSpDsAvDRAUAq97CCAKoHQCEMsPkTECTjfRIqRUBAVnIneLAfIWC/OzzAX5AHezqw0iUE"
"iEgAgQCKrvSLg0BwZ7OIApgAYFUd8yAgRwBgmAOgAYCqAZDbAIXEyV/NAThtPQdAAcAkMv6K"
"UggAExAAJpZHEEAIiBTpgCMRpeEItQdSKiBcAkCYE/4yEgQU54LAlGBh+hoABNGgIJka4MfQ"
"+EMEBGgA4C8jAIHC+JNGCePfN7wQ7BthBoDdQyQAIAjsHFoUAaAGA0BcABUFyrQAdQZIrRhK"
"EYJqML8XQkGvijCpSxkY7+HMCulQlBXcvigaPsIAGv0IFzL9QtL8C8HQloVgCGpYC7xvXlhX"
"C4SAFgIE6Dq0OakI3gsIGIkQQNEAvzYiEuDfFiGgrUgB2AMASgF8CADMxlP/AjT7FcH1YSWe"
"8NfgCX9DdHOIR+2c3hp2zWgDCTPbQuLcDrB3vhvsX+gOSYs6wcHYLnAEAeDoqq5o/i3hyoqm"
"GgBcW4swsNYFrjEEKBBohxDQAW5tRAigKMAWNwkB7gYA6KpFAdITewgI2NeLIUCYuTL9PggA"
"fdj8M/CakSzqBLhWQJk/P48fl9QLwbqXvO+tQUEWgkBWaj+p/txhkH1oENcGUC0ARwGO+SEA"
"BIkJgZQKODsaFQ6PFAQYAOAJjQamWgCOBKhUwAwxItgOAPBeAI4CiELAp1dmIVxEwcPz0SYA"
"YMlCQ1UDYAKAa7IFsKA2wAJGAVMKgAf1PDwlTT/DIDsAwOZvffq3BwA6BHyfcxr/HnMh6yD+"
"X/BrnLsOAPi6dneXEQCamAFgowSAdd/iz9ZX3AbIRYBL3wMAJkkAGG8LAAfCEQBCDV0ACACV"
"C33ib9FbAKtLv7NuAfynAQD6Y2wFLGwxtwK2tnAroDUAqCLAggBgyAcAQCg+jsqzjgJES+NX"
"AICG/5A0WdznoXKn4P10FILA07Xw99dnCqgBeF8A+FEDAKGfWL/+9Bx+yEvCX/RJAgSOCuUd"
"7gZ5h7wg7yCCwEEBAzkHBQjkpHSF7GRUShc0/y4MAQ+SJARQJCARISDRVQAA6n5CO4SAdkjN"
"Sq3xF6cVpwM0AFjb0AAAohDQtgbADADUHqgBwAJ14q8BZw05f7UNkCYBkkyDgKaIIsCTBAC0"
"IniSEAMADQiahAAwoRwcjRS7Ao6MExBwOBwBYGwpDQBSw/S2QLsAECzeVo+lGgCACwP9xKl/"
"P57+OeRPpo/mv3dYIQkB9gFg1yDUkKKwJbAarPcXXQE8FwANf+mgqrB0QFVOD8QORPWvCov7"
"VzGJiwb7iqv+eFWY2b0CzPApz5rerTxMcC8NER1Kwbj2pSCiXUlUKQhCYx9FZo8a1lyK7lsU"
"1QCAowBthPkzALShNEApzv3TDIBQngFQRpv+R/3/47qI/P94n0owgUP/VUXlPxr/lJ56C+Dy"
"oHqwZXwL2DqhJWyb2Aq2TW4F2ye1gh2TKbTfGnYgAOya0RZ2z2qPENBRQoAHpMZ2hmPLO8HF"
"5Wj+y5voALC6hYCANS4MASIdQBDQliHgZjxCwKYODAG3NruxTACwwxMhwAvNwQfVHY2iJ0oZ"
"eB9N6Zwa6CM6BZJEmoCu1uafsd8Xf59IvYSShDKTe2vpgSyKCKQOgOyDA0WBoKEWIO9kAE8I"
"VKkAEQWQEKDtB4hB8ycImCBAgE7rqGfUGnhNFAUyAKBBGwGAtgQ+uTzdsH7YMQAICCBNcwAA"
"cwseBET5fwMAvOTpfGT6t4W5k9mzHAGAndO/NQBY6UX6Pvz7TIDswz6Qdagb/lt72gLA7nYI"
"APg6tlPVADTRUwAbDQCw/jv8efpK1gHISYByEJCWAphpBwDs7AI4EI4AMOb3eOAwdwFYRAtg"
"a4u5BbCw5T1bAD9mAFBrgUta9FbAVijPJ1c8siG7lywEpDqAbtL8rboAeA6AFQDkjHAAAEE6"
"BOSEGADAWAgYJY1fnfql+T8k08drHl7zpkkAmImahZqNILACQeAYGnbuO4sAHQPAjzYAYBTB"
"wI9PTsCLtHkIA70lBHSTAOCF5o8QQCCQ6oUA4AnZqV01AKBUgIAAGQVACMjY4woZBAIUDUgg"
"EGgvQaAN3N3hIgCAogAbmsgIQD2uA7i6QkwDvCJTAZek6ZsAINYAAAtFtT+f+FW+X5O+Dlid"
"/kmqC4D2AvBuAAUAckQwRQQYACgKEIUQQKmASDMAUBrgoAIA6ggILo7mjgo0pwDMEQADAATo"
"ALB/5BewD0//dOLfN1yc/vcO1SGAAWCoLQDsJg0pBBtHVYWVw6rzqZ/MP3aAMP3YAWjq/SrD"
"4r6VYUGfSkK9heb1rMia36ui9ph4vjIXFBIc0P0830ow17cizPWpKK6oiXhS90Oz92+JJt9C"
"qpWQfys0fZcSENjWCYLbloQQNH1ScNtSENreGcLQ/Ee7OcMYMn43NH5UBJp/RGc0/67i9E89"
"/5NU4Z8JAAQErBnTADZFN4PNCAEkhoGJLRkCthMETGkNO6e3gYRZ7WD3bAEB++e7w+FYN7iM"
"pk/GrwDgKgIAiyGglRUAtGEIELUABAEiHSAAwMMAACIKcH+3NwohILEHylcY+n5dGgBwp0Bv"
"DQbI2MX7kvlTJ0EPvCf1RKimz9OToSAzuZdIDTgEABEFyDvhxxCQf1qmArggUEDAQxUFQAh4"
"cpGEIEDRAF4XPIkLAwUEzIJnN+ZoAEARgUfnx0Pu6TGQdyYcoULsG7ABAKWLE7UthFwTcGUa"
"5/8FABjMn7WA9ezGQhMAPL+zBl5mJPIs/rdPb7KRi5y+4YSvQYBBNubvCAAEBLx5eAm/1nb8"
"u4RB7vE++G/YG7KP9EAI8IZMfL0zAkA6AsD9Pfg6lkAA0EoHAFkEeHNTfVRduLnBDABXV9oH"
"ABoFfGp6CdEGONkMAKoN8GAEAsCYP0DqaASAED0CsHnoJ9nkZ9LXVAtgSct7rgH+mAHA2Aqo"
"1gLXtGitgG5pkN1b1AGw6XsbTv9qGFAv0QZonQLQAEDVAATIQUByImBOsC0AyMmAegpAnv7z"
"pfkr5U2VADBDAgCaf/4cgMfzUAtQiwBe7oe///W2AQBevKMG4P0AQNPff0b9Ar+8vg+vH8TD"
"k7N+nBLIOSRFAJDiZQMALIoC7HVjZRAE0C8MRwNcEQA6OACApnBzXWO4saY+RwGurawD1xAC"
"riyvzRBgHgT0rRgFrACAOwEMADDnSzhDpj9LhP7PzqKTP5r/tKq8DZB2AegAICFgqhUATC4Y"
"AFQKwAYAQlChCABBshbALgAYUgAKAEYhAIz4AvaOLMyGz8Y/9HNIHKIgAM1/mC0AkAgAElCb"
"hjrLcL8w/iX9hfEv6iuNvScVCArDn+tbAeb0QHUvD7PwlE/39BiJnp9DYEDv20tAAj0/G99v"
"dje8dhea6FEWRjbHkz5CwMiWQgoE/AkCXIrjib8EBBEEtBMgENSmJN47Q4gGAfL07yZm/9P0"
"v3ESAGJ8KnHvP0cBfAUEUBvgRFY1iItoAhsim7I2RaGimzMEbJmgQMAFtk8RqYBdMwkCRCrg"
"eGwbYf5GAFjZTGgVqSVcXUO1AC5SIgpwM44goB1DwM2NqiaA0gCdtZZAigLcS+gmIGBPD4aA"
"DNUWKHV/X29x+ud5AWJmQPq+3nqof78weg0A9ol7fux9AEBCQO5xggB/yDsViAqW44FHCzEE"
"iG2BTxAEnhAIkGQk4OkVOR+A0wCzeWlQ/pmxkHM8BHJPoUGeGs0QQI8JCIgUAIAiQHiodEGI"
"Ug1cF3B5qgSAWfDEZP6k+axnCAEv7m6EV1mpaMqXDeZtkCzqM4f5bWXP/K0B4HX2EYSNVfDw"
"9FD8dxqM0DQQck/0xb8rQYCviAIcQABI6cwAkLGPXs86mAFgu7kL4DcBAE0CVIOA7EwCNAJA"
"qgEA4swtgDUt+hrg924B/FgB4F/lP4BqBayA+tYiWiU8Elc22f2bAUB1AJgmAcrFQAQDjgBA"
"iwD8FgCYj1qIWoxagloG8Cwe/v7mjIwK/NcDAADpb6xf//YK3uSlwgs8EeSfHCwBwBNfhBAC"
"Urrgi5IUQcA+D9aDve46COwpAADiEQDimsDNtQ0YAng1MELA1RV1OBrAi4BYEgQkAHANgAMA"
"EDl/kfc/M90KAKa/AwCmEADQfQW8IgBEl+eOgKMFAAClAmg40IGw4nCA6gEUBJCMbxMABIsi"
"wGQ5H4BO//vx1L8XT/9k+omDSWj4KLomDiHztyoCVAAwWADA9qHFONcfO7AKm/8iOsGjgS8g"
"IydjV6ZPZk7G712ONaNbOYYAeoxEz8/y1u/J7GdSOgAfm+mF125CMR1Lw4jmRQQESI1qUZSj"
"An4KAFqXgEAK+7NKsigKENJeKLRDaQhzRQDoKFIAEZ31FECMtwAABQFs/gwDVWB6ny9hXURj"
"hIDGDAJx4xojCDRDEGimQcCWSa1gq4SAnTPaQsKs9rBnriucW9pCM36+LkcAMMEARQKoHkDU"
"BFxfiwCwrg3coHqADSoS4Mri1kAqBtyuQ8C9BC8BAXu6MwRksIH31EDgvgYDPUWdwL7efOUQ"
"PwGBMnwCAHlVAEBRAAEAvRkCzAAwWA4OGsoQkHt8BIpSAQoCQuDhmVBUmJwSKOYDPL4QiYpi"
"cRSAOwPEfIBHeLLPOR4IWTRxEK85x4Mh52SoAABUHkGAQwCI4YgARwW442AyRwBU+F8AwHw2"
"/2dpa+HF/V3wKoeG81wXZm3P+D8IAGxD/0o05/9legI8uozf77mR+D2PwH+XYQhJCACnBiEA"
"9LMCgG4SADxsAODurlaQtuMfBIDZYheADQCMNw8CUimAVEMKIMaDWwA9pK99K31OtQD+Ufrg"
"Px0AOGoF/BrVGNVx35qmCZDdR3YC+BgAwFtCQA9DCkC1AaoxwKoNUG0GJPOXIOAIADgFYKwB"
"UABgSAEwAEwpAAAWmQHgyXKApytRq2RU4LrDLoAPB4C/aeYv9KtJP79Oh9dZu/B0MB5/SXrg"
"L0hXoaTOkLm/E+sBQcA+d8cAsLWlKASMbwa3OArQkCHgOqUCVtfFXxiRDriyjFRLRAPkQiAT"
"ABhrAAoCAJUCMAKATAEcmywKAB0CANUC0GyA9wUASgcEF+O0QEqIrA1QABBkHBhUhM1fBwA0"
"/IFCe0iDBAjsVmZvBwBIO4cU5dA/dQGIUz8afw9h/nP49F6ejZ00E01/hmdZmM4SEECP0XNs"
"8F7iMdJ0g/gxT3y+K76NMDCiaREY0cwoCQOUFkAA8LcDAEEyHaADAFX/l+XVv+FyBoDWAti9"
"Es8AYBDoocPAzP5fcQpg7ZiGsHYsqRGsH4sQMK4pQ8AmBQETWnI6YPs0CQGzO8C52KZweXlj"
"af5N8L6Jdn9lBakZXGEIkIWBnBJoDTfWoeJay9bADrImgCDAndMACgLMANAdMvb2MABAT7i/"
"V78XANCL6wXeBQBk/qIGwB4AGCFARAJyj4koQO4JBQFBIh1wJkRGAcSUQBsAuIhGjsaefWgE"
"ZB4YBpl4zToyErKP+aMhBkkACGPlIQTkcyqA6gCipWJ0AFBpAU4DTOH+fz79X1uApr8ZT/kH"
"8ZR/URq+waTV2wWBgAYBtnrrIPT/KisFnqetxtesYPx+guDRBb/3BoCs1C6c4szY7+YYAAw1"
"ACYAWEMA8KXdGgDeBlgAAFivA+YiQMMkwPGdfpdgES2AjaW/fXAL4McKANatgLQeUWsF9O9X"
"bqoAgJ5WAGCsA7AHAEP0fQBZQ8V6YKoFUBMBOR1gXQNgrwjQDgDYrQEgAJirh//Z/GMFAJAU"
"ADxbjVoD8GIDwOvDAD8/+G8FALP+Dj9/nw7fZ+2Ap5fGQ87BHpCV1EUHAIoCSABQRYAaANBc"
"gI3NEQCawc31+Au0DgGA1wPXEwCwso4AAEoHLK8Fl5fW4uJAUw3AuwBgRlW9BsCwDOh9AeBY"
"jBkAHNUAMACMpmtxkQqQNQHWAEBzAMTOgC9gH2m4yPsnDpcn/wEkNPYBCgLQ7AeSPuO8vz0A"
"2I0fR8V+i/tXFvl934po/ML82fiVqeOVjb9rGb5OkVcCAnp+KgLBlK5lYRqpSxmYjCfzyXg/"
"xbMcw8IUqckIAcPR9Ic11TVcAgGnA1xEHQBFAYScWIFtBQQEt3eGYBoAxKd/Uf3PAOBZAaK7"
"VTABgAYBNBGwexWYM/hbWB1WH1aHCq0dTTAgICBuXBPYQCmBqOawKUYUCW5lCKBUQFv82WkI"
"l5c1ZggQkua/rLEWESAIEOkAGQ2glMBaF7ixvrU2H4B0S6UCZC0AQcC9XV4CAnb76ACw11fT"
"hwIA5/+5BkAUFCrz19MA/SH7AGkAdwMQAFAUIPcYQcAIEQk4IYoC80/RfIAg7gxQUwIfXxjH"
"5v/oXASvFs5IHgwPUmg4EU0oHAqZByUEHPWD7KMBkHMihCGAlKeiAGciIP9cFIshgMz/XLQG"
"AA8vTIKc8/Mg+8I6yL26Gx7eOQLPs87Bmye3zWZvOKW/FwjYGL2t3uSd5JTCk6sIOmT8l4Ue"
"XQzE788Pv88REgCG47/NEPz7WAHAEQSAg94IAfh6lmwLAKYUgBUAqC4A3ga4wn4XwLl5pU0A"
"QMuA1DbAd7UBpoR+Qi2AUy3mFsCylg9sAfyYAcBeK2B9VDsftxJjIYcq/GUhYIa3oQtAAYBK"
"ARgHAQ0WV4IBrSvADgBQFwB1AxQIAO9TBPiBAMBaB/B8PcDLnQBvzsDff877bwcAa/30+j4D"
"waOLkZCZ5CUBoL0tAJA2IQDEoxgAGoqpgGvqwTXaD7CqLr4oq3RAHfwlIgCgSEBNxwBgaPvT"
"AaCaGQCmVUXpKQANANj4ZQ2ANQBE2hYBGrsAUhUAkPlzTYAEAEMKQPX9i5M/mT9qWGFW4jBb"
"ABAQ8BfYhW8nDEAAYAgQIKAVAUoAWNq/IizsU5mL+jh8z6f+sni6R6GJT/VCkemj4U7pVBom"
"ayoDUz3K8HN0PwnvJ3cuDRPdpNxL82OTupRl41ca3uwLaf5fCDUT3QAjWhSFUa2Kw6jWxW0B"
"gKMAJREASkGIK9UClOZiwHC5BZCnABIA0BRAHx0AYiQAxKDmDf0WVgTXhZVKIQgCYQgBoxvC"
"uvBGIj1A9QFRzWAzQQB1CUxygV3TW+PPTQO4RBCwtJEAAWX8GhQ05SLBqytlbcCqFlwXcJ3S"
"AetdRCogTnQG3Noo2gO5LVBCwL2dngICdnszBPxDAKCKAEmyRiAzpY9hSJCYDeAYACgKoCIB"
"fhwJyD8VIKMAIg2QfzIE338Efr3+kJ40kPUgeSBDQEYKrS8WEJB1dBSaoT9kIyRwKgCVq0EA"
"RQHGiUjA2SjIPRUJdw+NgxvJ0XBp73S4nBQLt47Gwb0z2yD7yn54mIYAkEkAcMvW9O3pXdEA"
"K/3w8By8vL8dnlyfLAz/Sgie+kMMAICn/4sBOgCckwBwZqgGAFQHkHu8J+Qc7Q5ZhwgAuiJ0"
"UbcTFQK+uwZA6wIoYA7AhQU6AKgagPcFgFQJAE3K/W4s+Zn0td/UAvgxAgD9sW4FpPWI1CJR"
"16K1AiIAUB1AZg8BABlehhSAIwAYpNcDZKmpgCNlKkAVAhpmAZjC/5ESAAzDf2wAwF4NgBEA"
"DCmAx0sBnqxArbQCgLUCAJ7HoeKFXu3B60aAn9L/RwDAWj+/zedhHQ8vTUSi7g13d7bmoUAm"
"AIhrzBDAHQEcCRDRgKsr9WjA5eW1GQIuLa1lKgK0CwAzqtmNAKirAoBT06wAAKW1AU7UawCs"
"uwCs2wDtAgCav7ENMJlHAksAGPYF7CUNLcxKHFpIhPytAGA33u/qT/oMdmoQYAsAKweWgwW9"
"KsHcnhVFjt+zHJv/VDzJT0Vjn0LG7oGG7y400aDJbPLifgKa8viOzjDeVQrv6bGJ+PFCZVn+"
"LYrBkCZfwJCmQhwFaCZSADQMiAGgjYSANkoIAG0FAIR2FADAxYC0Cpg6AbQ9AGIUMMtHwACJ"
"3l445DtY5l8HlgfWRtGVQKAerJIgsGYMgUBjBIEmEBfVFDbGNOd0wJ4ZLfBnBgEgtqEOAUsb"
"C/One3sAQOkAhIDrXBjYSgCAhACqBxDzAUQtAEHA3R1d8Ge7K0JAN04FpO+h2QDdpXrAPTUo"
"iNoEFQRoANBTAIBWBGhoAzTOAaDQvyarCIBMA+gAYKwHkBBwOpg3C97f1w+/NtUg9CsAAIbA"
"AwKAIyNRCADHAjXlnhAQkJYcAJcSRsLxuCGQsnIwJK0cAYfWh8CJLdFwLmEWXElaCjeProe7"
"p7dA1uW9kJ92CJ5lnoU3j2+ajJ6K8woGAMcQ8Dr/HLy4vw2eXKO5BoHwhIz+kgj1C9N/fwDI"
"O9lfAMCJXgwA2YcoCtBV1AEkKwCgVsA2Wgrg9ja5C2CLfQCwXgZkAoBZDgDAMAnQBgDCBABY"
"9BbAutLfnC0f2AL4sQOAsRWwCqq2RbYCvr7d7RmnATJ9DQBgrwiwn14IaBcARvyDADDJqgjQ"
"ePqfIwFAFQEqCFgqAWC5BIBVdgBgvQ4Azzfj32c4CmElF7/2i20IA5n/YwBgFn7Uz2/g7ZML"
"8PzGEsg63A9hoC3c2tCEdXN9Y04HXKfxwKhrq+pzNIAggFIBl5cLAOAaAF4I9LVhANCX0vSV"
"qpprAOh+hh4JODVNAMDxyRXtDwLi0L/sAqA5AHYGAZkAgGoA5Mlf1AAYugAC1G4AKwCgan/U"
"HgKAge8AANanGgSoLoAEBIc1/ctw9b4q8pvehUL50vilwU+iq5sQ9fez3JxhIpm8mzD7mA5k"
"/KUgur0ueiwGYYCK/2I6iusoNHsGANRQZf58+tcBgOYAmGYBtKVZALQYqCTPAlATAGkMMAHA"
"2C7l9W2A3cRCILERsBLXBozzqghLRtaC2FG1YZlfbViK4nv/2rACQYAkIgINRVogojGsj2zC"
"XQJ7ZzQVAGCAgEuxjSQIUESA1IQhwAQAK1vwnAARBWitQcBNSgPE67MBKBJwZ3tnCQGerPu7"
"vbgrIH2PD4s2BioY0EBgr69+0ucugJ5a0Z/dQUApxkFAVjUAdgFARgGOjuChQ3cTfODOLh+8"
"0tAiApC+DAHp+wcUAAAj8PfUD+6njIALW/pAypKusHVye1gzrjWsjWwP8RM6wbbpPrB7QT/Y"
"v2K4LQAcWQd3T22CzEt7IP/2QXj24DQCwA2rdrxbPKHv3RAgQIDW+L64tx2eXpvAhv74ktTF"
"QLwG8pUef6RBQJABAAKtagAEAIg6gAEINv1sAYDqAJKpE8AV7iciAOxBAEhAANjZEiGgGaRt"
"w9evLQ3NAKBSACvlOmC1DXChTAHMdbYLACcm/QWOT/gUjsUgAESbRwHTOmCKAOwa9ckzi94C"
"WFv62we3AH7MAOCoFbAFqkvO2U5pAgB6SuO3BwC99W2AmQMKiACM/AAAsE4B2AGAh7NQRgCY"
"ZxUFsAcAq6XsAAClChQAZAWgQlGjxdTB51sBfrhmAIBf/tsBwN6fn3/I5Y1dT68vxF+23nBr"
"kwvcWIcAsLoBQ8A7AWBODe77Fwt/jABQxVQEqKUCZqi5AJXhONUBSPM3jQLmk78+CZBP/zQO"
"WI4Cfp82QDUKWC0DSvKX64ENAECV/3uGfK4BABUBGgGAjH9Xv89gB8sOAOD7rxvghKd/UeUv"
"cvji9E9hfTZ6VzzFdxTSzN9dGPp4Mnky/Q6lIKpdSYjEUzpdo9qVkvf4eFtniOogFNneWQMA"
"Mn8K/w+XUwBHIADQICAeBiSLAZWU+Qd3KMkpACMAjOZhQGUhgiGgAkcCqCZgnKd+H+lZERYN"
"rwmLRwgtoSu+HYtQsFQCwfKguiJFEFof1iAIrBvbGOKjmkLKzMZwcUl9VAMdBJbISECsHhHg"
"ugAEgCsrm+oAsKoFdwYICNABgKMAPBdA6M42D6HtNB+gC9zf1RXuJxAEiPbAu1wboIYFCQig"
"dkFh/naG/tAY4CQ1Gth6CmB/vQvgoH761wGA9gMM46VDdxN8IW27J8oL7uzshgDgDXcSuuPX"
"7ukQANIS+8GJNV1h+9RWsHpMfZgz6GuY3LM6TOv7Nd7XhoUjG8LS4OawKqItxEV7wJap3pAw"
"vy/sXz4MDq0LZgA4u2smpwBuHl4Ld07Ew4MLCZB3E3/HM07B60fXrYbwSAigNj0paxCgwsFn"
"t9ejiUfCwwuj4OFFf2HyCgAu6np0geQvnwsyAECwFQCgziIAnEUAOEN1AAYAONZDFAJqAOCB"
"cNZRRAES28K93S7479gK/02b479tE7i9FQFgc31TDYCxCFDVADgEgKkIAFMKwQmGgM8QAv6M"
"r0X/ga8/f4RD4wwAEPY7iBvMLYBdpJ/95hbAfwYAsG4FbIbyOLK51QHI7qsDQKZqA/SxAoA+"
"VgBgpwaAugB4GJA9AIj4BwFgzrsBQNUCcD2ANQBsxPeJlQDqHG3tAAAgAElEQVSA32dWoA4A"
"2QgnOfh95USL1MOzTQBvLyEIvPkfBwC7UPAmB77PSoEnV+bii5Q3XI9ryhBgnQIgAFCDf4wA"
"wKF/2f5nbAPUAGC6fQA4Ml6OAY4WuwBoNbD1LgAWRQFUJEABgAr3+9vfBmgXAAYV4jC+XQDA"
"0/9ONP6dfdH8+woAUKkAKgxUALCxfzGY06M8TPcqB1Mp509h/8508scTvjuafAcK5ePVTReZ"
"v9H0x7UpCWNdnCCitdDY1iU10XORbUoJITAQAAzl3L8YAzy8ZVENABQE2AAAzQWg07+rfQCg"
"jYBUDEiRAAIBSglEIAyQ6LEJ3arAwqHfMQQsHIbXYd/i298yBCggiEUIWBZQm6cF0qjgNVQb"
"ENEYjsxC819cT6q+EEIAmb8WFYhtBJeoLmCFbBVcKboCxLhgMS3w+lqxNIhnA2yQA4IoFYBK"
"2+ImJJcF3dvZGSHAEyHAk0HgrpoTQErsLgcG2QOA3uZdAFJm83cMAJQOSEdzT9vWFU+lXVBd"
"8d5TQMAOLx0A9vji+/WBm9t7wKElrrAmvC7MGlgVRncqCaNaFYGgDsUhDH92xnUuCzFeNJyp"
"OkztS/sXasP84Q1gcWAzWDGmDayLdEcA6Aa75vWBfcuGwcG1QXB8MwLAzhlwad9iuHFoNaQd"
"3wAPzu9EAEiGp+knEQCu6eN3rSFA6dEVeHE/EZ5cXYDG7A95FKY/h2aNenhhJMpPhPPR6Nn0"
"EQgek+lr8pOAEGgfAM6Pwivq7Ah4eHaYBgB5p/ojBPSGnOO+NgDwIAkBgKIAe9vBvcTWCHUI"
"AbtaIPQ1hdvbGiEANEDZtgFqXQBLDEWAxi6AGcXxtagIqhCCAALAZASAiX/GgwgCQMwf4XDk"
"H+BQhA4A071+d8AiWgCbWey3AP5TA4BxLbBqBaQ1iaoV0C1xZdPdDABUCEiGn+ltBwD62AJA"
"tjR/1QXAbYB+0vyDDbsArAsAIx3sApj4jhSAAgBjGmCpbAVcYY4AOASAZeL0n+lnAIAxZgDI"
"jUHJfQT508TnenMcXTj//xkA2Pvzt59ewevck/hLPJ3Dk7c2txU1AHYiAKfp9E95/qnC/E+q"
"OQDTjBEAYwqAlgLp2wAPs/GXsVkGpLUB/qMAMPQL0fcvAYCL/lQKoL9QQr+/sPHv7POpCQBI"
"RgDY1L8o9/RTNf+UzmVEgZ+HCPHT6T6Gwvl07SjepvtINOMoGvErDT+8lVIJCG9RAsa0LKE/"
"hmAQTjCAAEAKaF4MBlP+XwEAjQGmwUAuRfUIAKUBSBIEAtqWMgFAqFtpNBiqASiD17KiFoDX"
"ApdnEAjna3k2f7qORwCYP/gbmD/kW1iAmj/4W/n2d7AAQWARwsHiYQgCo2rC0gCRFlhFkYDw"
"RnBsdj2ExTqouvgCrIPAJauIwCWqC6BWQTUwaIUYFHRttYIAsTSIOgJuxsmNgVK3NyMEbO6I"
"AODOEHBvB0LADioO7MIgcEeLBnQTkQC7ANDbUPFvXAbU17wMSAGAIfdPkwXTdnrDrU0e+HvR"
"CY2f1NkEACnzWsGasJowb9iXENChCHSv83/Au+a/Qg+89qn/RxjY5M/4//m5CQAiOpWFaE8a"
"z1wNJvf+CmYMqAXzEAAW+TeFZWGtYe04N9g8xQt2ze0De5cOhQNrCACi4MyO6XBp7yK4fmgV"
"AkAcZJzfAbk3khAATkgAUEt3dAh4nXMcnt7cgEYfwRP5co5TTp5O5YMEAJBREwTgyT0fDZwg"
"QICAvzDz80p+Is8vowCPKC1gAgB/fr/H9DHnRmoAkH96oBkAjlAawJMBIDPlHQCwvRHc2toA"
"/73r4c9DbfwZ+Q4h4GtOA/AcgOVVEDj1IsDz80vDmTml4PSsEvi6hQAwvQi+ZhXC1yQBACcm"
"IQBM/JNdAIjpxDMA3Cx6C2B5i94C+F5rgD92AHhHK2D5qZBN+f3ewKN/M9VAIGsA6GsLAGor"
"oDYHwE+af6g0f+PwH2X+BQHAZKsuAMMYYAYA6zSAPQBY4yAFIAEgE0//mf52AAC/v5woWwDg"
"TgR5fYTw8WovwI/X0fNf/j8FAEd/fnhyFV7c2wk5Z6Lhzk4PuLq2mQ4AUwgCKgsAUJMAbboA"
"KrwbAGQKQGsDtAcAQcXsrgPWAMBYA2AAAEoBiBO/OPUn9FX6zBYAZD1AAkOAAIBdgz6Hmd7i"
"9E9hfzr1T3B11kL7lMuPIsPvIK481x9P5GPboFxKsOmPbikU1gJf+JujWuiPjW7pBGMYAgQI"
"0NS/wYYiwOHNxW4AIwBwPQBLQkBbkQagfQC8CKgjAUBpBgClMbIjwBYAysHE7lV5EdCcQd+w"
"8c8bJDR3IF7x7QUkBINFw76DJX61YFlAHS0KcGZObXzRJQkIEKoHlwgCGATqSwBoZJgV0FSv"
"CVjVTN8ZsLaVaAtcr7cFkm5v7AC3N3WQUQB3uLvdA6VDAI8LJggg7dGjAKLgr6cBAMQyIB0A"
"+tkBgAG8DIgKAe/s9IHbWzvDzU3uLAKAvdOawJrg7yCmRzkY7PIZeNf9N2he2gKtylmgbUUL"
"dKhiAY9qFujy1Sfg9Z0AgN4IAAMaWwEAAuRY/D+J8qThTNVgUu8aML1/TZg7rD4s9GsCS0Nd"
"YE1ER9g02Qt2zukNe2OHwIHVgXB04zg4vX0qXExcANcPrIDbx9ZDxrntkHt9PwLAcXj98Cqv"
"2f0+5xQ8TdsOjy4vhOxjgyHriC9kHe0N2Ud7CQA41g9yCQJOojHTxD4K1SsIIOMmCJAn+Ycc"
"zsfH6PFzfuI5FQUwAADPAaDUAEcO/N4DALx4FoBDAFApAASA29saIgTUw/+D2nBzQ024Hvc1"
"/swgAKwyAMDiCggB5fDnrzScnVcKfzad4PTs4nB6BgLADASA6Z/DySk6ABwdLwFgHALAGAEA"
"/1UtgB87ADhuBexYAhGzP2h1ANo8gAIAgAsBDRMBtUmAAcL880YbRv+i+edHms3fbgrAHgBY"
"7QJ4hBDwyAgAsVYAsNpQBLj+/QEgC7/PnAgRBcilKMAEKwCQS4kekvD7eTRL6Bl+3ddHAH66"
"j57+V/jfAACO/vzw+BLnDrOOh+MvbQ+4vrENnJ39jWkXAG8DnGAAAEMKQAGAcRvg4QgEABkF"
"UABgMwnQehSwLALkzX9+dmoAhhYSAIAnftKu3p/Brj547WMFAH0/5VoArgsgDRBtgrsQAqZ7"
"ofl3Fjn/8R3J+Euy2PhR45TQ/MeiEYcjAIS3odM9GjwqrGVxCG0hFIInfLqGERC0EhrdyokV"
"hgDgbwUAlArgOgCOBMg6AEoHtCQVh1FqOBADgJMOAG5mAAgzpAKoMJBFMIDXid5VeRAQQcDs"
"gV/zdRYBQf+vYS5e56HmD5IQMFymAwLrcBTg3JyaeOKqharNYhBYIKMBxogA1QMsa6TNCaDC"
"wKsrDACwWk8F3JCRALU++PbG9gIC5ObAu9sVBAgQSNvRBe7t8mSJKEB3hgBR9a9a/sQ+ADMA"
"mCMAmWj6tHXw3EpX2Di6DgJRVRjt6Qxd0Mhdq1ugZiEL1C5sgbpFLFC/qAUalbBAY2dLgQDQ"
"vbZ9AAh1K8VtmpFdBQBM7FUDpvWrCXOG1ocFo5pArAEAdszuBYlLBkPqqgA4Gh8Bp7ZOgQt7"
"5sG11GVw++haAQBX98DDaxvh4aXFaPRD4MEBL5Q3ZB70gczDaP6HeyAE9GIAEBBALXkEAQMg"
"99RgyKV+fRkJyKPc/bkRDAJ0mqeq/ocUzmcAGCWu9gCAIYAKBf1Z7wUA1AqYImsADABwBwEg"
"bYcAgDQCgO0NEQIQADbXgZvxNfHnAgFgLQFAdfw5QgBYWglBUwLAojJwbn4phAAnVAk4Paso"
"nJ5ZCCHgczyoIABM/jMcn/QnfF36Dzgc/Qd8Hfo9vuYIAGhc7ncRlv+CFsCPFQAs8h/AUStg"
"G5S3AAAy+F6G8H93qZ62RYAmAJCnf1oGlBeEstP3nx+ti8w/bzzYDgKa5AAApPkSBNgFAOs2"
"wLVSqgUwTpj/801WABCk1wAYowC5URIAJhraERUAzDQDwBP8Xp7MB3i6SOjVZoC3JxAIHrwH"
"EPzv+PPL//cCweAQPLm2Al+IxiDJe8O19S5I39UZALgIMEavATBuAyQAoCgAdwMoCAiVbYDB"
"Vr3/jgBAzgHgNkBDFwCZP536GQAYAgwAoNRXFARSYaDoEBAAsMC7FIf+YzqKoj5l/BTqj0DT"
"ZbUVIvMf0wZNvbVQGAJAKBp1MBq/LgQBAoKWQgQBIahQFyfwa16UAUCTIR1AWwGHa+YvAGAk"
"RwHUVkARBQh2FVsBVRpAAQCnAzqRdAgY7VEOJveoBjP61YCZqBl96fqVuPZFKEAwmEMiEBj8"
"DdcILB5RC2L9a0P8mNoIfd/BubkIAfNqCTEI1IGLlBLgtABJ1gWYZgUoAFCLg1rI1kBVDyAj"
"AQgBAgDacxSA0gF3tyEEbHPXlIYQcFdGA+4leMm9AT6y999XbwNUo3+T+sC1rd48y2Dl6EYQ"
"5lMJ+rcqCh2r/yt885kFKv3RAlX/wwLV/tMCX6K++tQC335mBoAG7wkAPggAveoJABjS/C8w"
"smUR/D9yDACzh9SD+QoAxnaEjZM8YfusXrBn8SBIWekHR+LGwsktk+B8wky4vn8C3EkNgfTU"
"AZCe3BXSUzxZGakouqYgBKR6w4ODPRAEuiMEoPkf6SkhoC9HATgVcHIQQ0AeVesTBNAEP6rg"
"J9M/P9IMACoSYAUAPAmQ2gKpMFAVDzI8DLdfA2APAFQR4B4HALC9Pv7/IwBsRADY8A1cX/cV"
"giMCwMoqog4gFgFgsQCA8wud4dzCkiiEgLlF4czswnBmFkHAZ3hI+TOcmPInhACqA/h3OByl"
"AwD5l/QxRy2A//K+RgkfKQBYtwLSmkRjK6DX3zJ933IawC4A+IrHbVIAQ/SVwLwEKBjNMlie"
"/o0V/1FonjGGkL9s/SPDV6f/AgcBvScAPF2lt//ZAMAm0QL4cKEBAILNAKBFAKLsAMA0+xEA"
"awB4thiF39NLBI0X+D19vxPgr2cAfs5Cz/8J/jcCwLv+vHyQynpwMAQVDJfxRZ90mCBgnLMO"
"AOFWAPCONkAFADwJ0AAAiUYA6GMFAKTeVgDQVxQGikjAXzgFsMjbCSZ6OEO0K4X60fg7CNMf"
"J69j25VA40fDb1OcFdIaTd2FjB1P+6hgNGv/ZkUhCM2drqSA5kIEA4GthIIQAjgC0LSwMP/G"
"eG0sQIAgwBYAhEa5lDBFAYJlIWCoOwrNP5QBQK8HINMnKQiY3L0qTOtdHab2+pKv01HTetEV"
"gaBPDZiFVwIBSglQXcAirgeoBfFhNeHMzG/h3BwBAToIqEhAHS0lIKIACgIMAKANBxLbA6+v"
"UfMB1ObA1nArvi2qnVgdjLqz1RXlxiIYuE0goCAgwRPuye6ADRFNIX5cM/BzrwB+HuXBpcq/"
"Q+uq/w74ggXOn1ig9O8sUOZfhMr9qwUq/JsFKv7BAAB/skB1AwDUQvOv84UF6qH5NygmAKDJ"
"PwgA47rQYCYBAFP71oRZCADzRjaG2JBWsDrcFTZORACY2RMSFw+A4+sHwKUtveEWTUXc4wr3"
"9rqx7u/vBOn7O8P9pC6s9OQuAgiSFQT4QOYBHwQANP/DvgICjqAREwQgAOScGAg5tLCHRvae"
"pmiADgGa+dP9WQUCIzQAUEWAT9RgIHsAcHboBwOASgFQDYAJALZYAcCa6nBtVVW4sqIy/lxV"
"gEtLyuHPWhm4sNgZzi8uiXKCcwuKIQQgAMwphBDwF4SAP8PJ6X9CCPgPODpeB4B9wZ+8Jf+y"
"mFsAS1l+Qwvgxw4Av5f/IJ9b7LYCdk6D7P7ypN/dCgIUAPQRAMCnf0Pvf7aq/A9BswyRp38K"
"+0fJU78yfxXuVyH/KRIC3gUAahiQPQBYajUJcI1VCoDMf4Mw/xebxeegAsDMAAkAYYYUgKoB"
"iDYAgCxIzJ8qvpeH0w0AMFsCwAIJAAslACxB18Tv68VyAQGvVuPb+P28WgfwegcCwWkEggxZ"
"Q/D/8z9//zs8vZcK6SeXwKVNvnBqmSscnt4QUmNqQHJENYcAoGoATAAg5wAkFhQBIPPv9Sls"
"N0IAiqICRgBY3rMYTHB3hihXGepn4y+B1xJs/qPb4gs6G38xVjBdXYTxB7ZEw0ej92tWBEY1"
"VSoKI5ug8N4PYYBO/Sw0f+oCGIjGTxrQqDAMYggozJEALQqgqRhrhJwQ6NfWCfzblYTADs4I"
"AfYBQECAGQCm+FaHKWhCk31pPXB1cUVN7lkNoYBg4EsGAYaAQQoCvoMdkd8iAHwDZ2ebIeDc"
"3FpwgdIBJAkAFxgAZCpADQvi1sAmsjWwmS0ASN3a0AYlIQCVtrk9LB1WC5YNrwURnlWhd0tn"
"8GpQDBo6/xvURIPGV2v4AlUEVVSqGKo4Cl+soCSqlJSzhICyCADlEQAqGACgagEA0BABoLGT"
"AIAWCAAu5QsGgP7vCQAzB9eFuSMaw7pxrWDPnHZwfFUHuLalPaTtasu6k9Ae1QENsgPcS+zI"
"ur/XA9UJ7u/rBPdQDAQEAkldIYMhwJsjAZmHKBXgKyDgsAQAigIoAGBRNIBO7MNYDykdgDAg"
"AAB1xggAsguAzP9q6DsBQGsDtAaA1E6iBsAaAGQRoF0AiPuaAeD62i/h2uqqIgqwvCL+XJXH"
"n7GycHGJM1xYUhLlBOcXFYPzCwrDufmFEAT+AmdmfwqnZyEATEMAmKADQNwQhy2An0u/e+8O"
"gH8GAFCzAKhFoqJFbwXsdCGxwykBAH3sAEBPCQC9rQBgmL4KmCv/KfcfKnL/+eMM5j9B5vfV"
"qZ/C/GT+U3XDdwgAyvwdAYD1KGB7ABBvBQB4+s/E7zcbYSUbASA73KoLQAEAKk9+LzYAIOsR"
"6PTvCACe4/f13BoA8Ht6jd/P600Ab7YAvN2NQEAdBmkIBM/wv/Tn/waX/m/8gwDw9vun8Dj9"
"Kty/kARXUtfCyW1zIGXFWDwFDYa4GB9YFuoBS4Y3hfn968Isn+9giW9lmN+tPCz1dYZ1vUrA"
"ml7FuXLfehCQ3SJAAwAYxQCg0gD4sWt7FYXx7qUgqqMTmz4bP2pMe6Gwdmj+bYTpB7UWCqR7"
"NP8AmuFPw3xonj+e5odbaUSTIrwAiJ9HMKD7AY0KwYCGhVkDFQRwKqAIQgAav5IBAEa60HCg"
"EgwBAgBkFMCttNYVYA8AKCIwyacq1wFMQE30qYLXKjCpO91X5fTAVISC6X1ESmBO/28YAhYM"
"/Q4So7+BMzMMAGCAAB0AZBRgUT1REBjbQEKABIAVjeV8gGawa1xdmNe7Bszv8zUEdawIXg1L"
"gGeD4vBdkd9DzWK/h+poxP9p0fWp1GdS+GIE+EptAoAiVgBAKiFBQAFA6X8AAJqi+bcoY4HW"
"BACVdADo/J4AQCmAyQhZK0Nqwo6J9eHYkqZweUNzuLmJRuG2glvbXeD2jtaoNpBG2tkOjbE9"
"3EUQuLvblXVvjxvKHWHAA+4mugsgYBAgCCAA6CYAgPaJHOrBECDSAX1kGmAAQsAALRqQe3Kw"
"KAw8PZTNnwFAwoAAgJGiRVDNAbiC5n81DAEgVNQB8MwAf3MK4JQZAHIIAA57yVZAAgC3DweA"
"9QgA675EYEQAWIUAsLIS/kyVh8vLEAD+L3vnASZVmbz70V13VTIKKBkUBFFJkiSoIDmKYAQM"
"IBIFiZJzzjkzMEMachjCwMCQkRwMoCiSc44Cu9at9J3zndPdMwP+w9572eep5zQoMLQ7/f6q"
"6q2q8VkwMmFkQAh4Dv//lwZBACFgVCqEgBTw3bBksGVQEtjU5ylY310AYHTdx7eSfoW5I4A5"
"VN8eeAfA/8sAYI8C0mykPQpYKoxHAd9eCsept/+5rAQOCQCfawvADwCtded/ex8AaOZ/xurx"
"c5+fxH+AFwKCAoAl/gYAnCmAsYHXAD0tAJP92wDQPwQAdJbsPwAA+ggEBAWA4fhnjkoAACbF"
"DwA3FiAELMJYAnAbYeD2MgSCdcgBewDuk7HwEsg54v/Q/3kAIEYBYDisntKZASCy+4cwsW11"
"GN6oPPT/tDR0q1Ucs9wi0KJyAWhU4VX44p1c8PHbL8J7JbJCtaIZoVLB56BqoTRQu1hqeLdI"
"Sqj7RnIU2uTQpFRSFNanoV+FpNCv3NPQG2NopadhQT0vACyiXQENUsOMemmgB35gd6mSgYW/"
"Ewp+B/wQ/7aiRDuKCij45Un8UfQxWr2j4l+GzvuSyKeBJijkjVHQG/micQnM7hEGGlOpH58N"
"ij8D9d+QoNcCAWmkHYCA0IiWBdG+AISAJhYAmCrAN5UyshmQqgAUBAJtq2VF0ZEwIMAwUD07"
"9Kz9EvSo9RJ0ryXPHrUlaD9AH6oMKAT0/1R9AewHyA9regUBAIWAcfVyQf+aL2rkgCr5n4Wq"
"BZ+FagXTQMkXksJrz/wNXnv2b5ARxRc/WT2RJEgktSIxAPBsEAgIWgkIAQC5HgAAyigAVEQA"
"qGIBQO38gQDQptJzCFPZYUaHV2HlkMLw3dQ34MDsN+H72W9pkPgLAPw4twz8NO8dODgfIWA+"
"QsCCcggBFRACKjEEUCVAqgFVMarBL8skDkdTa4AgoKYLABSxHwsAMATU4zYAQcBxFH4KAQCC"
"AakCUNAxH4ozCANcBUg0AOgUgAMA9RMGAGMCVA9A0BaA7QGwAOAAAsD+qQgAU15EqEQAmKAA"
"MCEjPp+D3ePSIAg8ixCQGnaMTIEQkAy2DkEA6IsA0AMBoOPfoGdNZwSwVJh3BDBl2AOOAP6/"
"DgD2KCB+XzmjgCUwqvRu8+ooAYAv9DLgxz4ToD0J0MDt/zvu/zYy9neaopMCgNX3N9m/AQAW"
"fwMA/bUiYIXTe7fHAIfqGKDZAxAfAEQoAOgGQBL/yyi4x7vEAwDBKgC9FQD6iQ/gjC4n4krE"
"cBF9Dh8AXB6Pf65CwFX8ui6H43O6BQBRQQAAxf92NALAcoyVGKsA7q7GWIMMsBWDRg+PoOhS"
"6+A/BAoYAC4iAByAX3cjAMRGwNYFBABdAgHgs9LQvXYJaF+jCHxTpSA09gFA9WIZoUqh56FC"
"/rRQ9rXUUDpPCngrdzIomfMpeOPFf0LhbH+H1zM/BgUyhUG+9GGQFz/QX8UP9lfShsHL+CH/"
"Gpm8suMHfbYwKIYf8AXx33vjhcfg7Zf/gb/PP+DNXBRPQJk8T0L1oimgWpEU+Oclh8qvJ0fw"
"SA4VCiSHaoVSIHCIk7/Jmyj2JZ+Br4pLNHzDChT4r4pLpk+v/QDggYA3AyHAtAD8AEDRqpKC"
"QFU3CAbaVsuGMCAngz96KwO+X89D1aLPQRWMqkXxNf84PZR4KRUUzp4ciryQHIq+kAKK5UgB"
"rz33JGRL8hjkTPEY5MLInfIxFt8ng8RTIcIv+sEAwP5xfABgICCVBQEGAOxI+yAA8LQAABkB"
"X0UAyBfEA+CvABAAVLUAoE7RfyJ8PQNjGmeDBd1eho2jC8Le6W/A/sgSsH9mKdg/qxSLvgMA"
"KPwGAH6YXdoDAT/NK8txcAFVAiqiOEolQKoBVTBcCPAAwEryAnwgXgAEAPYCMATU5TYAA8BG"
"BQA1BZoqAFcCtkqc3tpYWwH/TQAQUw2OrKwCv1lTAP4xwJAAMP1lOBDuBYA9ExEAJiAATEQA"
"mPA87JmQBkHgWdg1NjXsHI0AMBIBYGhS2NTPBYC6RR8fRfqlOmZGANOFPcQI4P8PAGBGAWlG"
"MivGK2E6CtiqQY4+cIJK+w30MmCdICZAGwC+UgBo4V7+o97/aQod+2MA6AGBHgB/BUB77Cz+"
"CgZBASDYJsBgABAh5f+LmP1fnq0x1wIAywPgaQH4PQAKACf7WF9zCAAg4WcT4DgxATIAjFcA"
"wK/t8lQFAISS67MTAIAVFgCg+N+NBbi3HiMOYx3+mCoEBAZrkQO2YxyGP+8fhz//NzwF8QDA"
"wsGNpAVAANC4Agz4vAz0/KAkfFuzGLSq9jo0rZQX6pfNzQBQq2RWePeNTFCtcHqoVCAtlM/7"
"DJR5JWEAeM0CgNzPhMFLqVAM8MM/R3IUCBSDrJgVZn4KRQNFIsM/wyA9CsbzKBzPoYCkRSFJ"
"85gIT2oVopQqTsk1klkiZgvc05q1ZsTfM+OT8kxvxfMU/5CgP5P+bDsy4s9l+qdEZoon5esI"
"Jsj/0xEKABKCAD8QJAQANgTYVQAbBOIFgL+5AJAjBADQFIADAOlcEyB5AOoWfQyBKin0r5cW"
"5nXOARtH5IUd4wrCjgmvw65JhWA3Hd0KLwp7pxWDfQQAM0oyBJD4+wHgh9kCAAwBUaW9AECV"
"gPnluRIQAABUATAtAPYE+ADAmAFpIoAAYF09gYANXyAEaHAlAAGAqgCb6YiPxGmuBjR2jYG8"
"CCiIByAkAATxAPgBgH0AvjHA+aV4EyAtAqIxwAcCgImZYM+kjPgaAWAiAsAEAYBdY1LAjtHJ"
"YNswBQBtAVTP91ifMHcE8BXVtbRhDzEC+P8sAHTv3j0szB0FpDfGjAK+jFE0TEYoPnIB4FNd"
"C/yJxoMCQBcvAPDMvx8C+rnib0T/7AB12Q8U8T9lXwK0jwH5rwH6PQAGAGYFAgBn//YYYPsg"
"ewC6yaEgCk8FIAEAoLgUCgDCtQVgAGBuCACwsv87MQoAa0MAwCoNAoZl8Cf+Hn/eXIgRi683"
"wZ/3vkcwOAF//uvSf73wm/8ZADhCALAa9jMAjIA1U7vAoqFNYEbPjxkARjSpCAPrl4VeH70J"
"HWu9AW1qFIKmlfNCAwSAT97OAbVLZoOaxTNB9SLpoUrBdFAh3zPwjg8AiiAAFMryGGf2+TL8"
"1wBA2r8AAE9Zz6eCCOk/ffG/Lex/VfwfBAIeFACCtQL8AJA+BAC8QACA/41fIggIAgBVMbv/"
"tNjj0K56Uhj75fMQ1TYrbB3+Cmwb9RpsG5MXto/NB9vH5UfxL+ACwMRCsGtyIdgztQhCAAJA"
"RHHY5weAOfEAAFUByA8w9x2FgBAAEC0+gF9XqAcgGC9PubcAACAASURBVACQF4AhoA5DwDGE"
"gGPrP4NjGz7j0UABgfriC8A4RYuCME5v+coHAC08q4BF/I0JMHARUMAxoLiPfCbAeABgXnG+"
"CEiLgAgAfprzOvw4K5/6ABAAIoIDwJ5JCACTfQAwDgFgNALAqEAAIN1S/SqqemZGAJOp3v1N"
"9e//ewAINQpYGKMsxvv3j9S7Bce/tPYBGAAI5gHQHQDcAvjGagHYANDdnfsPqAT0CQIAtGlP"
"R+2M+Y/uAHCg2J7R0v95FNrz42SvvwcAwr0AcCkIABxpngAA0B6ArroNsEfiWwAOAODXdHGC"
"egCsFgB7ACJ9ADDPBwCY/d9e4Yr/ndWS/ccLACuDAMAC+BPh4l/Xo+Bf12ZjzIJ/XYmA+1eW"
"4eu18OftvfDnH4fhX/dO/fcBQHhXBICmMLPnJ2wCHNm0EgxqUA56f/wmdH6/OLR9tzA0q5IP"
"GpZ/GeqWyQnvl8oG7xXPDDUQAKq+ng4q5kcAeDUlvP0yAsBLCAA5/glFEQAKZ30MXscMrgAC"
"QL7nEQCoDfAfBgB+4f+/BQISI/7BACDYz4UCAPO++r0AKcOCVwGMFyAxAFDppTD4uPBj0Kzs"
"kzCk7rMwo1kG2Nj/Jdg44CXYPDAXRm7YPCgPbB6SB7YMewW2jkwAACYJAOyZWhT2TS/uVAEO"
"zIofAH6gNkBUGYx3OH6aS5WAcnBogW0IrMLlfxL/xALA0VgEgLV1JeI+Ywg4biBgwxdwgiBg"
"ox8AGrkAQFsCA/YAtHE3AeotAD4GxNcA5RzwiY2U/VMb4kPnFoDZBOhpAdBFQL0G6ADAXFkE"
"xAAwGwFgZl6EAAEA9gGE50QIQACYkh3F3wcAE+IHgFXtHjcjgGVVx4KOAD4CABcAQo0ClsGo"
"dWL7+4dkvl/3ARxNCADMBcCWrgmQPQCdFQK6xQMA1t5/DwDooh2T+Z8ZpuI/AmOUV/zPmyNA"
"k/QAUCgAmCPiT0uC6AhQyBaAAYBuXgBwWgCmQjE0fgAg0ac9AJcmhgCAOQIANx8UANY/AADM"
"QwCY6wLAVQSAyxiXpmNMg3sXp8JdhKa7FyZj4I8vLcF/vhZ/zU741+0j8K+7Jx4QAL6H3wgA"
"1kbC1oUjITa8Gywe1gxm9qoDk9q/CyObVYbBCAB9PnkLOn9QAtrVLAzNq+aDryrkgXrv5IQP"
"38wOtUtmhneLZYDqhdJB5QLPQrnXUkLpPMngzVxPQQkEgGLZ/w5FEAAKIQAUzBgG+Z93fQCJ"
"AQAq02f4iy0AGwL8wpiQ+NsQ8J8EAw8q/P6fSwwAGAiwAcB+bSoB8QEAtQDexP/2lXKFQcO3"
"/gEdqyeDUZ+lgWUdssB62lbZ+wWI6/kibOz7IqzvkwOfOSX654RNCACbCAAGvhwvAOwc/zrs"
"nCDiHwAAESUEAqgKMLOUxwToAoC8/tGCAKkElONWAHkBCAJMBeDBAOATzL4/UQD4VABgvYDA"
"sfWfKwCQaH/JcWqzaQNgRk/TADu+1quALd3TwLoKmA8CMQDIOeBT26idQP6CzwQA+BBQPABA"
"JsDFIQCAVgHPLugBgB8iEQCmIwBMewn2hyMATM0OeydndQFgUvAKwHfDkjAA0BjgrCaP0whg"
"LdWvkCOAjwDACwBmFBCB2jsK+PP6mntE2M0+gDqJBAB7DLC9awJ01v52CwEAxhDY3wsAZ62y"
"Pwv/SBH/M2MsAJggW/14A+BkEX8HAIwJ0AYAFFsUO/i9pYi/YwL8VgyAx1X8nRZAD+smQG+Z"
"BuAWgB8ARoUAgEkhpgAMANDp4fkYC0X8aRyQyv+3rf5/ggCwUmM5TxC4ALDQBwAYCB/3L2Nc"
"iuC4h+/T3QtTJfD9u3tuItw9PQFjLNw+ORpjJNw+MRxuHx+G/2wu3D63GO5d3gT3ru2C+7eP"
"ISCcTRQAzOpdFyZ3eA9GNa8iAFDnbejyYUlo/14R+LpafmhUMQ98VvYl+KT0CwgBWeC9NzJC"
"jcLPQRUEgPJ5U8I7rySDt3M/BSVz/hOKv/AEFM32GBTOIgBQIH0Y5PtfAAADAX8VAP5TIOCv"
"AECoqkAwAEhqvafBKgL0/udJLj37mq8+BnUK/x26oMgP+iA1rOmSGdZ2zwJru2XliOuRDSM7"
"Cj4KP62splAA2EAAQKesEQI4+iEADPACALUAGABG54XvCAJsANDyv2kBEADsnfYG7EUIoNgf"
"WdKtBMx6C+NtR/h/wNff488JBJRhCBAAKIuiaBkCF1eOpwVAo4Dvw5EYjNUKALQdcPXH+LQA"
"gIPaAZ96AYBWBVMrYNOX4gcgCKDRwO1aBTCtgD2tPMeA6BwwTQ1Q1YAqCCdZ/Gn3AJ0CRvGP"
"/UDL/9Y5YDMFQOX/RWXg0AIEgHnmHLBeA5xdiFcB2y0ABoCI3AgBL8EBBID94QgAUxAAJmfC"
"Z0aEgedh7yQLAMakgJ2jEQCGuwAQ/uVje8ICRwDTh/lGAB8BgLwBoUYB84XJCEX16CllljoA"
"cMycB64TeA7YswgoxB6AeDcB2gDQx60CMADogp0zKv5nUWDPosCeRfE/a2f+EzWm6BlgAoBp"
"PgCwTYDzBCp+/0ZvALS2sv8uEjwF0FVbAN11IqBXwgBAY4AhAcDeAxAZBAAWifjfWvZfBACL"
"HAD4N7UBrs2RuDoD7l/BuCQgcA/fI8r87+L7dvc8QsC5SSj+BAHj4PapMRijEAAQAo4Ph5vH"
"hsHN34fAzaND4PqRwXD9t4EY/eH6r33gGsb136fA1V/Gwcn9U+Do9uFwYPVA+G5BV1g14WuY"
"3edTmNKxNoz+uioM/rI89K1bGrp+hABQqyi0qJ4fGld6Bb4onwvqlnkRPn4rK9QuLgBA42cV"
"EADKvioA8OZL/4QSLz4BxbI/BkWyhkGhTMEBIBcBQEoFgGQPDwApwuIHgCR/AQD+k9oCiRX/"
"hwEA/0hgRnyvX0Y4K4D/rSrmfgwq5XkM2pdLAh0rJIWlTTGTb54OVnzzHKxs8zzEtMsAMd9m"
"hNUdMsHqjpm9ANA9K2b82STr7xUcAOJ6IQT0yiFB1YB+LyEECABsGaoAMOLVhwIAqgQQBCQE"
"ADIVYFoBZQUCjBdgUWWEgCohTIA2AHwo44AcHzEAUCvg6Lp6cJTEn/wAcQIAbAzcoAeDbADg"
"HQGmFdBcDgU5Z4O/cc8B72zGo4M0QUBXB0/oISIy/3H5P5b6/5T910QAqA5HVlRx9wAoAByc"
"/yYcnFsS/64EAMVcAJipJsAZrwUCwLQcsH9adtgXnhXFPzPsnZrJAwC7x/sAoK8AQM/3eASw"
"uupXvrAQI4CPAMAFADMKSGcSzSjga2E6Cji+T+EpcAIB4ITZB1BPsv/fjfjTyWCCg4buFUAP"
"ANibAH0XAIOuAlYAOG0AYJA7X29K/iz8KKxnUVjPovBfMMI/SbP/qQoA0xQApscDAAMtAGij"
"2X8nBYCuugdAAYBfd7OOAoVoAdiLgPwA4GwCxK/ryvRAD0AAAET7TIAPCwAYN+YjACAEXIuS"
"uDoTAQDjMsUMuHcpAsUfIYAqAecRAs5NgbtnEALOjEfxH4tBVQCEgOMjBACOUgyFGwgCNxAC"
"bhwZADd+7csAcO2XXnDt5x5w+WBXuPxjF45LP3SCSwc6wOXv28OlvW3h4MpG8P2yBrB5+kcQ"
"PbwmLB5cHcY2fxsGfvYG9KlbFOq98yJ88nZWeL9ERni3iAJAvlRQ7tXkUPplBIBc/4SSCADF"
"EQCK+QCAjIB5LAB4iQAgRXAAMB6AdPEAgF0FSCwAGEF9GAD434SABwWAYD+fO7lEfvxvUCnP"
"36DSK3+DOm88BZ3KJ4fOFZPzPYjlKPALPk8NCz7T+CI1LGzwDCxq+CwsaZwGljRJA0ubpYXl"
"LZ+DFa2fg1Vt00NMe4IABIAOCACdM0Nst8yJA4A+L/LTxPreORAKXoKN/XM5AMAtAASAraMQ"
"AAgCxuYLCgA0CbB7CkJAeDHYoxDgAAC1AhIAADEF2gBQjqsAP9NegEVV3DHA5dVlDHC5BQC0"
"DyAGhR9BQIIqAR9zK+DoWgQANgRa7QADAFwFqO8FABoLpJFAcytgpzkb3FJOBZNHgNz/WzX7"
"p/FCEv84U/5/H4W/Nov/0RgEgFUWACyrwEuAGADmKQBQ9j8HAWBOEfccsFkEFOm2AAwAHJj2"
"AkJAVoSAzBguAOyZiAAwITXsHpsSdozRFkCfp/gYUNMyj08Jc0cAXwtzRwBThFkjgI8AIBAA"
"zFngrGEyOvEGRqVv6ufsCycws+dpAHMXgOIzHwBYVwAJAJxVwG18x4AMAHTxtQAUAJwIBgAj"
"ZW8/O/3HWyt/KSZJOd8Y/1DAWPQvGOH3TwFoC4DE/ahm/57+f2IAoF8IABgRDwCY8T8CAPya"
"rs6IBwCWWgBg+QAS5QFYrh4AhICbiyVuLEAAQAi4Pk/i6mwEAIzLszjuXYpE8UcIoErAeYSA"
"c1NR/AkCJqL4KwRQK+D4SASAEQoAwxEAEAKOEAQMRADoFw8AdEYA6AiXf0AA2NcOIaA1XNrT"
"Ci7ih87FXRQt4CJmHRd2tIAL2/H5XXM4jxnK77GfwfqJ1WHt2MqwZmxFGNrgdRj0eX7oXzcv"
"fF42M9QumQ5qFn8WahRLDQXTiw/AmQRAAMgdDwAYE+BzPgB45i8CgC2otqj/w4qHBYD/CUDw"
"iHlSNwo8I5m6xOPQodzT0KFsEo45KOYrmqWBlRRN08LK5mmd1c4xrdLKymc6/9wyHSys/wzM"
"+ywVzPs0FczXYBhokNoFAIyl+PtEf50OllMVoHV6WEVVgPYZBQK0ChDbNUuCLQDzDACAfrlc"
"DwBBwPBXuQ3w3SgXAMgE6HgAbACY6gUAigMzSjlVgB9mvyXiP/OthAGAqwACAD/rQiBnD0AI"
"AODXqz5AAZY2wNG1deH3tXXwKRsCyRR4nKoAGCTeBAGn2BDoBQDxAlitAAIAdv43Ffc/7RKg"
"sUIyF66vJ/sH1kr2/3tMLc3+33UA4NfoSnB4WXn4hQyAPgD4YXZRjMKY/b8uABApAOB4AKgC"
"EPESQgACwHQEgOnZYN80BIBpCABTEQCmpIU9k55FCEgNu8alhJ1jyQSYBDb2FgConu+xvqRb"
"ql/2CKBnB8AjAMA3wBoFtM8C26OAFZ5P81gDAYCGrg8g0QBgjICmFeAHgO7grgbuYV0D7G21"
"ACwA4NL/WK/4n5tkAYAp+0/XzB8F9oIt/sYEOEeXAM2TzN8DAPh1Hu8QvAUQLwAMsVYB+wFg"
"gvT9r0y2AGC6AsBMFP6ZFgDM83kA7D0AiQUAMwYYjQCwzAKAhQgACAHX50tci0IAwMD34z5C"
"0b1LM1D8IwUAqBVw3gDAJLhzegLGOASAMXD7xCi4SRBwlCoBBADDUPwJAgYpAPSFa4d7IwD0"
"hMuHusGVH7tyJAoAMC7sbCkQ8N3XCADN4PyWxnCWspcNn2N8CqfiPoET6z6CE/ghdAI/hI7H"
"fgDHMRM5troWfgjhB9HK6vD7clpJWhVmdSgCM78tApHtCkFEm4LQulI2qF8mI3xeOgPUfSsD"
"fFIqPbyTNwUUyvIEvI5RMPMTUCDjE5AvwxOQN/0TCbYA/BDwIACQWBB4UEjIgkCTM7kGAk/O"
"pBIFEYxK5/w7x9v8xMz81SegzdtJoG1pE0/DsobPwJIvU8OShqlgyVcUKWFpo1SwjKIJinzT"
"Z2A5Ppc3wSe+XtH0Wf45fvoBoCW+/tqAQDr8fZ+FefVSwtw6Iv7z6qH41/MCwEL8dxY3MhCQ"
"ltsA0S2pFfA8rGyTAVa1zYggkEkgoHMmWNM5C8R2yQLrCALoRHUPrQSoCXBdDxcAnBaABQCb"
"CAAGu5MAW6gNQBAwJh9sH5s/YApg92QEgMnBAUC8AKUw3kThf1PE3wcA1ALweAAeAgD4ubIW"
"xgdcBSAvwO+xdRIAgC+8ALCtkQMAp3dIK4AAgEBADgfRwqDGcJp2CRgAoPXDDAAIHmtqCwCw"
"+L+LX4uuAV6GALAUAWDxO94WgAGAWYVR8F9H4fcBwIyXEQIQACIRACJyYAgA7J+eGSMT7AtP"
"j5EWISANQkBq2D3eCwDrujwByR5/rAHpVph3BNBzBtjSvkcAEOaOAtKZxKCjgC4ANFAA+FSF"
"/zPdEmgBwIlmOgbYwgUAqgA4ANDJBwDdIPAcsA0Ag3XV70jt+49T8Z/khj/7v+DL/C9F6vrf"
"mXIC+LKuAKatgL+38HkA2gUxAXaxAKC7mgD9AGBWAVvHgBwPgB8AwsX8d2WGAsAs7xggA8Bi"
"3yKgUHsA/AAQ41YBCABuEwAskWAAwLiucW0e3L+KcWUuxhwEgJkKANoKoDbAGYKAySj+EzHG"
"w51T4+DOiTEIAKNR/Edy3EAQEAgYDDd+6w/XKA73QQDoBVcIAH6SCA0A3ygASCQKAOI+dgFg"
"DQaKfzAA+G1ZVfh1SRWJRZXglwUV4Bf8sKU4hFnYoTml4RB+MP+EH9Y/4Yf2T5GlMPsoKTEN"
"P9SnFofvpxTDKAr7JhSBveMKwZ6xKAajMUbR1byC0LNiNuhRISt0eycLdC2TGbq8nQk6lsoA"
"HUqkh/bFn4d2xZ6HtkWfgzZF00HrImk5WtGzqEaxtNCmOEaJtND+zXTw7VvpoGNpiW8x2r9F"
"P58Gn2kg9tusENs+C6xukxlWt8IMmJ6tUQTtaIXC2CoDrG6ZHmK+xoy7GUbz51CcUURJmJtg"
"Vo3CurwZXVvE143M1cVnYdlXcnNhcYNU8QNAYwSAxhYANHvWBQAGgjTy+mt5Lkcxn1c3Jcz5"
"MAVEfZwSoj5JySAQFAAaPAOLv3IhgKoAy6gK0PJ5WNE6PUPAyjYIAe0RAjpqJaBTZhSArLCu"
"azZYhxCwvkd2jrhe2RkAuAXg8wA4ADAgN2wahBBAMfQVrgIwAIxGABiTHyGgQKIBgCHABwAH"
"8PUBfO2YAD0AIOV/MQLGDwC/rqwt0wAEAiz+FJiFr/qQvQCJAgDbBGjdCDhNmf6OZtz3JxDg"
"qsB3tDa4EZzaLOV/WjlM4s/TB/g99zt/v72n33M1BACiFQDsCoANALMQAGYWQqEviAKfXw4B"
"KQD8OCOPQMCMXA4AHIjIBgcis2AQBKTHSIsQkAb2Tk4NeyYqAAxNCht6PskAEBZ6BNCcAX78"
"EQAEAoB/FPAljNfDdBTw+Hcf/cw+ANoHQKJvnP/HTPbfIAQAmBZAG20BfOv1AZD4syGwqwUA"
"vQMBgFf9jrIAQDP/c5MlzMIfY/qjrN8BAPv63yw5AWwAgKCBZv8JAHgE0AaATlYYEFAACLoH"
"IMg1QA8A4J91RbP/y9Ok988AMMu9AxCwB2Cx3gJ4UABQCLizHAEgWgFgKQLAYgQAjOsUSxAA"
"FsC/rmJcmceVgHv4/ty9qFWAC9oGOBOuADBJIODUBLhzchzcPDEWxZ8gYBQCAELA78PFC8Bm"
"wAEIAH3h2i+9EQB6oPh3VwDoApe+7+QCwL42DAEXdyME7PrGAYHQAPAZRj0vAGAWcpxiNRmR"
"3vtrAIDinxAA7BtfGAEARWAMxqjXGQB2jsAscXhe+G4wisagVzHywNZ+L8OW3i/Blp45YFP3"
"F2Fj9xdgQ5fsEp1QoDpi6DOuAwY9O6JodaZ4wY1O2VH0s0Fsu6ywpj1FFg8ArEaxj2lFop9R"
"QACfa77B19+g+Ld4HmJQ+Fc2EwggAFhJgYJKwr+8edrQAEAHl76kK4oCAAQCyyhI+Cn7DwEA"
"y5sqCDTB3xNjBQLAwi9Swaz3k8Ps2slhzgcpYM5HFClhbl2KVAgGCgHkA6hPECA+AIEABIAm"
"UgVYjn+f5fj3WoFws6J1RljZLiPEdMC/f4fM7AlY2zmLQEA3fC+7Z5ewAICmACjzl+xfTIAE"
"ABv75+ZpAIaAIXkcACAz4PbRPgDA2E0QMKlwSADYF1kSo1RoAHCmAMwYYAU1AVYSI+ASCwCi"
"/QDwHkb8ACAegBAtAAIAsxLYPhS0XSYC2PVPc//0cwQJtEIYfw2tF6Ztg7R9UACAsn/8fltZ"
"U8R/RXX9fqvkAoDPBPjjHB8ATFcAiIgHACIRAGZkwfcxM75Oj5EOISANfl8+A3snpYRd4+QW"
"wPoeT8LsZn//OcwdAXxddSzoCOAjAAgEAP8oYAGMtzHePRRXey9XAWgfAGX8PPZnA8CXiQMA"
"2glwsoMPAOzRQGMENAuBBvoAwLj+J4nJ75yGk/mb7D9SS/+RvuM/5gCQLgA6NdS9AeCYABUA"
"eBFQB98+AD8ABDsHPEzHAM0K4HHq/Mev8Yru/3cAYKYAwA1dAxywByAYAKx+QABYLj6AW1IJ"
"+DeCwL9vUCxDCFiEALAQAYAgYC7cuzwbxV+rAPj+MQCcRQA4OwXunNEgEDg5EW6dGA+3jo/D"
"GAM3CAJ+H6legEEIABjUCvilD1z5uSeKv0DApR+6IgB0his/dEDxJwhoiwDQBi7uQQjY1coC"
"gG/UB9ACAaA5AkATCwCoAlAHThIE+AGAjUgPCwClQgPA1DcYAhwAGFfYBwB0OAezxSEEAQQA"
"rwQCQDcLAEjkbQDArD6uAwoXgQAKPol+AAC0RdFvR4HZLj1bGwBAESTBb6XRkiID/hxl/8+z"
"8BsAWIkiSrEKIWA5iuqKrzGapOXs3AaApdSHpwuKDeiKYkqEgNAAEN0EAYCC2wIKAPRsLKec"
"59ZJCTNrJYdZtZJhIAS8nwJmfygAQFUAbgXUUQj4NDXM/4IgAAHgSy8AkBkwGmGGqgAGAlZS"
"K+Bb8QPEKACs7UxVAG0FBAEAewzQBoCNAwQCQgIAGwElPAAQ/oYDAQ4IxAcAZg/APGsRkAUA"
"hxYSAFRhCODrgA8NAJ/6AKB+aABgCNAbATtE/Lk9QG0CWiBEo4S0WIigggCARhBXWwCA4n+E"
"vt+iq7D4/7qsorQAfBWABwaASASAGdnwPcyC711mfGbASIcQkAb2T3sG9k1JBbvGuwAQ3vBv"
"e8NkBPBt1a+QI4CPAMB9E/yjgHQ20YwCvhlGo4BT31kKJ6kN8JVk+0e/CAIAjYJ4ACwTILUA"
"HADoJBBAmwH9AOAcB9LSOomqBwDGW05/DVrmY0b9HABQ8b84MzQAsAGQsn/t/x9rqwBAmwC/"
"lXAAwDoNHBIAzDVAWgQ0Vrb/XdTy/6WpOvqHX99ljGszBACuofjfoCuAUVr+N3sAgt0CCDUF"
"EKcAsMYCgBj+NX/exrgVLXETRf9mtIj/jWiuBPzrGkLAlYVcBbh3OQruXpotVQB8/+6en47i"
"LxBw58xUidMIAacmwy2GgAkMATeOjVEAkDbAdYKAXwfA9cP9EAB6KQD0gMs/dsPsn/wAneDS"
"foSA/e14GuDinjZSBeBKgAGAlkEA4HOBgPV1BQDIB+C0AAwA1HABIJoAAD+UFleWsAGAPnwJ"
"APADOQAApon4fx9e3AsAE4uGBICdIwgAKF4LDgBOBeAF2EgA0EkBAEV/3bdZGALWfSuVABL9"
"uE4KAB0tAODIzNl/TKtAAIgh4W+B8XUGWIXZ8io/AFA74GsEABqta5ouAACiKftvmNoFAL6i"
"mFIhIBUstQGgiQsAXAngcAGAri/OwoyfwgaAWbVSwCyCAK0EUDtg7icKAfUQAD4nCAgCAGQG"
"xL9DtF0F4DaAtgJCAIDtAWAA6JtTggCgv0wB2ACwibwAw16VcUCeBqA2QAHYzkbA1zlkIRD+"
"/2BKUQcC9k4rzrFvugsAbAgk8ad2gNkDoNm/0/cPAgCHFlfhoOuAfB6YRwF9LQDbA2ABwFFn"
"LbBvCmCTNQUQFAAaMQSw6U/H/k7x4iD8dbRRkH4v+r1jP/IAwBEEgCMr5Hvt12X4PbaUxB9j"
"STnXAzDvTfgpqoQLAMYDEOECAE8B2B6AyBz44xfgewKAWQIAP8zKgJEOISAtHIh4BvaHWwDQ"
"/UnoXdsZAXwzzB0BfD4syAjgIwAIBAB7FDB7mDsKWHX26Ldmw8nGIFWAL10I4P5/g3gAwIwB"
"+gDgJIrqScsMaFoATum/v2usO2cd+2EAmKBz/lPF6X9+mm/MTw/+sPjPUgCYLaV/jrli/qM4"
"2kay/6NtRfyPtRMAOJZYAPC3AAwA0BVAWv+Lmf9F4/yfpsY/Nf9dmyn9/2tG/PUGwM0FITwA"
"CQFAXBAAWIkAgHGLqgAIAjeXIwAsF/FnAFiCAIBxdRG3Au4jFN3F9+gutQIuIAScj0Dxj2AI"
"uHMGg0Dg9FSOWycRAk5IJeDmsbFw4+ho8QIc0b0Avw5EAOgPV6gKcBAh4GBPBIDuCADdEQA6"
"w+X9HTG+hcv72iEAIATsJghoDZd2o/jvaoUA8I0CQDMFgAZwml3MBAD14OT6OnBy3ccIAB+o"
"CbCWNYpUFY5gNkIZyW/LKocEgJ/nlhUImF3aBwAo/tNI+PEDfcobXgCYUCQEAGCmODQIAPTK"
"CZt6CASw+He1AIDEnjL/9kEAoGN2rgbQj2Op9N9Gy/4GAL7JxBEAACj+Mc3To8g/z33/Vc1c"
"D8CqFgQAAgHsB2iRlj0BQQHgCxT/+iklFAJCAgBm+tEmUPznf5oSZtRMDjPeE/G3AWBmTf1x"
"bQMBNgBgfCYQsLBBCABAqFneMj1CALUBEHTahQYA9gH4AMCzCXCA9v+N+DsAgP/9nGmAfFoF"
"KAg7xktIK4AmAYrCbgIADA8ARCAARKD4RwoAGBOg2QQYCAAV9TKgAsAiCd4MyFUA2QVgAMA/"
"BWBMgDQFcJR3ANRzNgGadcC8CMjeBOgBgEac8fPr7Y3ZH3CSl/4QMOCvpd+HKgoIAEfX+ABg"
"xbuS/VOlbSl+jy0h8cfvscX4/bWItgCWFgCYEwQAjAkwwh0DDACAmdlR/LPi+5YFf30G+HF2"
"OvxxWgQDBIBpKQUABgsAfFv18dmkV2HuCGD2MO8I4CMACAEAwUYB6YyiGQXsJwDQRLb9seB/"
"aYk/tQbonzd1AcCzB8DnAWAA6GRNBHTTSYDe1gZAFdRzagAMAAAV//O28M9ws/6LmvVfnG25"
"/tX5f2W+/PPfWysEtBPxjxcAOicAAFr+J1ihqthzhwAAIABJREFU7P+CyfwnW33/CBH/K/i1"
"XsOv7epsCwDmKwAs1DHAJb4xwGB7ADZo2ACwWiOG//0/b2PcWinBALACxX+5xPWlCAAYVwUC"
"7uP7cvdSlEDARYUAAoBz01H8p0mcEQi4dWoKiv8krgIQANw8OkYBYCgCAMZvCAGHB8LVX/qh"
"+BME9IbLPyEE/EDVgK5w+QBBQAcEgPZwcW9buLRHY3er4ACAH16nNxIEfI4A8KkCwCdwcu2H"
"CAAfOgBARqQjy6sgAFRmQ1KiAIBMWY4HoCRn/t+Hi/Dv4/5/saAAYEyAgQBgeQB6o9BQFQBj"
"Y9cXEwcAKP7rOLLxz61pFwIAWmZi8V9FZX98Uva/isS/WXon6w8AAIyYFoEAEN0oOAAs/MIC"
"AKoCNAoNAOQdmIWiPvO9ZAIAJPb4moIBgIDgXfPzCgAfIgCYKoAPANgHEAQAolsgACDsLG8V"
"HwBk9wCAtAB0FXA/7yrgAAAgIyBXAV6DbSOpCpCfqwA8DWADwOQigQBAT4SAvdNLIgBQCABI"
"9v9gAPCzcx2wOrcBfqXs3wIAswfAWQa0VhcBWTsAzC0AFn9zC0ABwBF9GwC+M0t/xPh3chMG"
"/V5c/q/jBYBV+P22HAEguqoDACT+hxcTANAZYMz+F9ARJAsAdAyQACDYHgACAGoB/DAjJ/ww"
"80WEBQSAOQgAcxEAojLAT1HP4RMBYOazAgDjksGWgUkgrtuTUCP/4/3C3BHAV8PiGQF8BACB"
"AGCPAmbByBOmo4AlCqZo4QDAicYKAV+JJ4C3BDay+v+2ByA+ALAXAnW3FgH1t7b/DdPyv177"
"MwZABwBQ/M8HE39f5m+EnwNF9soCGSc8qlk/CT6X/dtbLQDbA2CZAPkWQB9fC2CQbCk0lYoL"
"4ywAUNf/5Qjt+6v5j4T/KsY1k/0TACx8MAC4v0GCqgABALDaBwD4JPH3AAAdAlpmAcACuHdp"
"rkAAgtPdCzNR/GeEBgCtAtw8Pp4B4ObRkXDz9+Fw/fdhCABD4Pqvg+Dq4f5w9VBfjD4IAL3g"
"8o892RB4+UAXjI4IAN/Cpb3tUfzbSewmP0BrCwCaJwIAPtAWwLt/HQAiSoj4h2vWbwCAYGBS"
"sYcCgM09JTZ2SxwAUJAfwAGAtllCAwCK/6oWGbjvv+prEf9VTZ9HYQ8BAF8rAFgtADIBMgA0"
"DAEA9VMwBCzRKkAwAFj4eSoU9mQQWTMZP2eg0Ee+q68xZlKQ+NdIzv9sRk23FRD1kUAAAwDt"
"BAgGAOoB8APAyrYZAgGgmzsF4ACAuQVgSv96DMgAgLcF4FYA4gUA0wIgAKA2gGkFBAEAuwJg"
"PABeALBaAPTkrYBqCFyiXoAVtTzjgM4iIGcPQCgAcCsAp3X+n7J8fnoAoJEc/NHs/+QG8g5g"
"kJdgXSAAHEk0AJTyAAAvApr5umwCJACY4XoAfpyJEDATAWAmAsCsF/HfzY7vV1Z8v7JgZMTf"
"CwFgrgDAvnCZAtg8AAGg65OQK81jLcLcEcA8qmOeEcBHAOADgHhGAXOHyShFOYwP4CQK/Mmm"
"WgVoLBm/EX7eAEj/rLmKf0s9BmRvAvzWmgKwPABmDDAAAIZaAKDX/s6NDwIAlsvfZP6U9V9U"
"x7/T8yfxR5G9jAJ7ZZGcFj5qZfts/FMQOK6Z/7GO7hSAcw2wp4j/KT0FfNrsABjuVioCAACz"
"/8uRsvSH+v5XZikA4Nd2bW4CALDcdwxIDYDU87+/UYMAAONerBoE1yQCAFZYAEBVgMUCAPge"
"3WMAmJM4ADg5CQGAqgDjZCrg9xEIABhHEAJ+HYIAMADFvx9DwOWDCAE/9mJD4OUDXQUAyAtA"
"ELCnvYAAtQIcAGgJ57d/Dee3NlUACNECWPM+HIupqfPI/hZAYjwApRUASv4FABAPgJgABQC2"
"9snFELC5V06Ojd1yeAEgwANARsCsPBVAws8QQOX/RACAm/0/zwAQrAJgewDIBGhPAVD2H/3l"
"M7D0S9cDEBIAGosJkEv++JxXJwWKfRKIrJGURT+yBkZ1ec7QH8+gqE6hAPCutAEIAuZ8kFIg"
"oG4QAPjKBwAttAVgA4DuBIjtlHgA2DQwOACQCdDjARiVTwBAWwBBPQDGDGhAgKsBJWB/REm3"
"DRBwC8BrAjRjgIcWVFIAqKRngskQiACwlLwAKP4rLBMgQ0DCAOBZBby5oWcRkIwDKgCQN4AP"
"/ojrn+b+T2KcIPGn/v/aT/T+wAc8AugAgNUCSAgAeBOg/xbAzLwo/K/i6zwaufCf58R/FwEg"
"6gUUfASA+S4A/DAnLb6nCABTUsKO0clgU98ksK7LkyR8H6heFVb9CjkC+AgAAgHAHgXMGOYb"
"Bbywv+5xAQBT5lcYMFn/8eZu5s8A8I0uATK3ADpYewAMABjxN9sA+wQBABqpG6NnfnX+3wGA"
"CDH72WN+nP3PEQgg8b80zxJ/zPwvo7heWSwl/aOm1N/BAoBvdRFQJ2/p/2R3EX8HAPq7AMBf"
"q2b/BCsEABd19M8GgGsq/gwA+LVdReG/Nk9H/2wAWOy7BbDSvQR4J1ZPAKPg39+kALABBZ+q"
"AWu1OmAAIOYBAGAJAsBCAQB8v+5djIJ7F2bBvXMEAREo/tPjAYCJKP7kBaAqgI4FHhkO138b"
"igAwEMW/P0MAA8BPveEqGQK/74ZBbYBOCAAIAXtNJaAtAkAbBoCLGOepCrC1mVMBEADwmwBr"
"WwBQA35fUU2yEpOZMABUgl8x02IAwA/ehADgAH6YH6DRv8lFE9ECyO9OAVhjgFv75mYI2KwQ"
"sLF7DqkCdHkhKACsbS8QYF5zkOO/TfwAsJL6/pT92wDQXEQ/prkFAM3dMUDaAxDdlJz6abwA"
"gOK/tL4PAOwWgAUAS79KDXM+omwehb9GEoionhQiUOgjqmFUxaguIEA/jqyG/w49qxIQJMef"
"d70ANBoY9eGDAUB0Cy8AUBUgtmPmhAGAxB+z/02D8L/JoNx8DpgWAZkWgAEAMwXAJkACAGMC"
"tKcAFABMG2DPFAsGwovD/uklAgDAuwionLMGOBgACARQJYDGAhEAlr2rEwG1gwOA3gA4vt57"
"DjjoKmADAlu/Cg0A+PucWP8pnOBzw3X46uBRc4Mgxg8AVYIAgHgAuAUQVUJWAestAOca4Jz8"
"fBHwpzmvYbyCkQcjN8ZL+O/nwF+rAEAVgLkZuQVAHgACgL2TU8L2kclgY58ksLDVP46HBY4A"
"ZgwLMQL4CACCA0CoUcCaJ3Z8fAhONhMAOGH6/Eb0Nes/2dIV/xOtZAKAjH9c/rcyf2cM0Bb/"
"XrJb3zkANNTaqz9Wjv3w/L+ZAJim8/72mN9sjSjN/OcpABjxVwAgI6Aj/B000+9gib//GFB3"
"zf57STgAMEBOFPMK4JEi/tSquKgGQBJ/cv+T6//yDLfvf2W2AgB+bdfmu/3/G5r931wi4n8r"
"WsT/tpb+Kfu/Y8x/GxQAFALuEQisUwBQCGAAiElEC8AAwCIU/wUCAJcIAGYjABAERKL4R4QG"
"gBMGAsYhAJAZECHgyAgFgEFw9ecBDAFXDvbF7L8PXCVD4PfdMcQLcGlfRxT/Dh4AuLizlQ8A"
"GnoAwL8HQACgphcAlnsB4DBmWgIAZTkEAOwWQHwAUDRgCkAAQEYAA/YA9M8jAICxpbdAwKYe"
"CgFdZbwvOABk4axfAAAz2rYPCgAazWUKIMYyAppFQFz2R2GNbpJGnl89OADQWOCs2ijq7yXB"
"bD4JA8B0FPnpKPLTq+CzcjKYRk+NyKpJWfwZDAgQqpEPQM2AWgUw2wEZAHQUcFFD2QbIHgAF"
"AGoBGABgD4AfALpmFfH3nQPm2X8bAAbnluU/BACDXg69B8BMAUx83bsHQE2A3AqY4j4FBBAA"
"uApQitsAZgzQXgXsbgIsr+2Aig4AHFxYyWoFVOE2wC8EAGwIrOUAAJsAjQcgCAB4bgGYVcB6"
"GpiNfroU6NS2r4IAAIr/+npwPFbFf81HKv7vewHATNv4TIABmwDnvsHXAPkccFRhFPnX8Zkf"
"Ix/+89cwXoGDUQgAUQgAUQgAc10AYA+AMQHOkikA2gPw3fCksLF3Epjd7Ak6A1wzLJEjgI8A"
"wPtGBBsFfDHMHQWsET2t3FIXAIzJr4Ul+q205G+Ev41k/idRVE/bpf9g1wB7ufv/nfO/wySr"
"poU6fOrXLP+xDIAMALb4z3Gzfkf450vP3wAAZf9kJCTRP9bJNfnxs6Nm/Cr8x7up+FPW38s6"
"A9xPWgjc/7fWFJ/X08TG/X8pXIL6/zYAXNXLfyT+1xe44n9jkWT/Nyn7x8z/1goR/9ta+qfs"
"/491FgBs1thkAcBajTW+CkAwE2B8ADAX7l00ADBDAWB6/ABw3ADAaBkL/G0YXP11MALAQIaA"
"K4f6IQCQH6A3XPm+B4Z4AS5RFcABgHZwcTdCwM7WHgA4t/krAQD/GGAwAPDvATAtAKcCEAgA"
"BzFDsz0A8QLA2ELWJkADAN49ANsQALb1exkDAaCPQMCmHgoBXV+UXQAGAFDoSfg9ANAuSyAA"
"2GOA/haABQDOFIBvDDAoAKDALmv4bNAWwGKFAAIA0wKg7YDzP0sBM2qh8KP4R9b0AgCJ/rRK"
"GBWTQnglfY0RUTWpiH8VhYCqagashQBgqgCfhACARmlhSZNAEyBPAehdAE8LwAAA3QLo84KY"
"//rncEb/AgAAgY1XAQ/Wg0Dc+/duAjQAwBCgLQCeAsDYNUmeuyd7AYAMgfune9sA38+0LgLO"
"QQhgP0A5bQdUYAgg8XcAgJ8WACyr8ZcAgGMznQY2ENBQWwENnZCrf5j9x9XDqMsAwAeHaNTQ"
"MR/6ASDIGKDuAaBzwAQAdA6YIOCneUVR6AtjvI4/XwAjP0ZeODTvVQyEgLkuAHALIMoFAHsM"
"cM+ElLBtWFLY0Otp6CMjgDXC3BHAF8PiGQF8BADBAcCMAtL5RDMKWDKMRgHHvD2bAYAhoLmb"
"8fOsP2X8rVX42+q4n2X6O41Z9WmT/Xd1M/8zvSzx72u5/62e+vnReu73YQBggfb87VgiWTuv"
"+u1irfxV4T+pom/COf2rzv9TegHwtI7+nVFQOas+BfpaL07GUOc/BRn/GABmBgEALfuT+N9Y"
"IuJ/M1r6/k7mj/EHif9aBYANKvhbNAgAqBIQh8+1GrEJAECwFoAfAObAvfMIAednovhH+gCA"
"RgEFAlwAGK/TAAYAhiMADIWrvxAEDEIAGAhXDvZnQ+CVH3oyAFw50BUBoLMCwLcJAEB9FwAc"
"D8BD7AHgFkD8ABDgAfAAAK0CLgi7RroGQHsPwPYhmEEOfFUgoP/LsKXvywwBm3oKAGzqloNH"
"ArkKEAAAWb0A0M4HAO28Y4A8BeDxAKT3jgE2pZL/c1z6dzYB+gEAhZb2/xMAkAmQ3PweACAP"
"AD6XIATM/jAZiz4HCn+Ein9EdQQAFPnwyir+FTAqymuKiCom4geAuToJsOCLZ6QN8KW0Afgm"
"QJN0EN1cAeAb3QNAi4CsTYBOC6CnBQB9cqDo59DRP+n/OwAwWO4AeK4BhgIAswfAmAAnFWHx"
"34VPEn8HAKa+4QLAtJIMAfutxUAMAbMQAmaXwSxY/QBcDSiPQX6AihxiDowHABgCPgg5BeA5"
"B2wDwCYfADAEmNcN2PnP5X8EihPr6uD31ycKAB/i99dDAMDCt+DQ/FL4dyoBB+cXx0AAmIsA"
"MLcQ/n0RAOYhAMxDAJiPADAfAWDeywIAUTkQlnQKIIp2AbgAsH9aatg9DgFgCK0Bfho6VXNG"
"AEuGuSOAz4WFGAF8BACBABBqFLA4RuVv6ufqBydR+E9aRj8W/1ba629rOf1Nv1/X/pL4n+6i"
"0d3N+nnpj1n80083/w1xy//UUzfl/wtW7/+CvfDHBoAoKe9fWiBB4m9Mf5T5cyzVzL+zXPtz"
"rv51dV3+J+1sv4/s/Wfnfz81/w10zX9nhmv/f7T7tV6copm/Lv25olv/nAoAbf1D8b+2QAHA"
"zvyXSfYfkPmr+P8RZwHAVgWAzfjjzWIGpK2AHLEMDm4LwAaAFQkAABkB1Qdwfo4CgFYBaB/A"
"6XAFAIGAQACgxUDSBrj26zAEgCEMAVcIAg4OYEPglR96YXRHCFAAoDYAeQH2tHcAwDUB+gGA"
"TIB1eQrAmADdPQDvPuAioHimAHgM8A0PAPAtgDEGAAp4AWCoVAG2DyUvAArIgFcwdCIAIWBz"
"z1wCAd0JAGQvgLMJ0JgADQBoeEyA9EQoWNPWuwiIxgAZAL4OAQBN0gUCQCO3BUAVgIQAYOHn"
"KVCsUeRrPC2GPxL/GhKRJP7VknD2T1k/i3/5pDC1ggsA0ytLhAaAlC4AfIoA8PkzXAXgfQAI"
"KTQNYACAPABmE2DQVcC0AwDFf0PvF5zePwPAgJxi/huUC0U/F4q+ngHmsT9y/rvngD0AQC0A"
"ew8AgcB4gQAS/50TDQj4AIAWSVEbgCCADIG8FOgtjh8sCKBKAMVB8gTMLR8AAJ4WAAGAmgEd"
"AHD2AMQHAF8464A9AKDjgSc1CACc/r8PAH6n8UOuOtTmGwBHVr4b2AKwAWBpWfgZIeDnRW/D"
"zwvexL9LSYGABcVQ5ItgIADML8BxaH4gAJAJkMcAZ2d1NgESAByYkRb2TU0Nu8amhC2DksL6"
"Hk/DuzICWFn1KsERwEcAEBwAgo0CFguTUcCWXgDQzP+kyfzbW6KvRr/TWvI/bQx/3bTsbw7+"
"9LUW/5jNf3pQ55wlqnztz9/7j5T+fwAAzLMAYJFr+qPMn540OXCsM3jP/ZqM34g/iX4/CRb9"
"vm7f/5Qa/6iKEAoAuPc/TUv/iQUAzfy59L9SxP+2mv7uWOL/x3oRf874t7oQwACgOwEYANYy"
"PPyJvwf3/x0PwMogALBEpwAWJgAAkQgACAGnpyEAhCcCAEZaADBEAWCgDwC6IQB0QfHvJBDg"
"AEArdwyQpwAaWlMANAaIEEArgZ0xwFqhbwH4TYC6CjhxewDeCDwGZAHAjuFiAHQAAMV/BwHA"
"YIyBrzIEbO0nEGADALcBCAI6veCO/pHz3wIA89rZA2AAwLMKWKoAPAaoVYCgANA0CAAYEyBD"
"AIp/g8AWAHkA5tdLzoI/rdpTGE9zth+hoj8dfzy9ahKOaZUfAACqWQDwfnAA4CpAfaoCWADw"
"tW4CjO8WQDwAwOJPMSQXbEUA2IoAsHWoiv9wKf9vZfd/XrkGaAPAOImdtBaYYkJhFn8PAFAV"
"wAaA8BICATYA0GggQwABQGn3QFBUOYzy8NO8ChzcEkgIAFYGAwDfJkAEAVrlS3GSJwIauLG5"
"gVYC5HWiAGBlLdkBgADw2/IasgVwKQFAJccD4AAAxeLSCAFvYZTEv08CAGBaAHMQAGYLANAm"
"wO9nIQDMMKuA6SJgatgxMgVs7p8U4ro/DbnSPtYyTEYAi4UlYgTwEQBYb0SQUcBnw4KOAhIA"
"GKe/yf5N2Z96/R2tUn9nFf6uVuZvsv/e4vg/S47/ASr+WlLnxT/D1FE/Rvr/5tRvAACgqF6w"
"y/9ztfRvMn8U/MtG/Jdq+X+Y19znCL9x+Pdxe/xOGMc/vabsf4jEGeP+H+l+rdSqIOPfpeni"
"/L8c4QOAOeL+p97/Nfwar6vp7yZm/je1739rlYj/7TUWAKj4/7FBxJ8F3waALRYAxAkA/BGL"
"ALDGBwCrBAIoHgAA/jg3AyMS/jgbAX+cnh4CAMZZADBaAOC3YXANxf9aAAD0xiAfgIwEXtrX"
"WSBg77fxAgDtAThN40kOAHyki4CCnwP2AABVAAgC5ldQANBdAKYFYK4BTivxUACwYyi+Hpov"
"NAD08gKAeAFk3e96M/vfIauzE2CdjgPSJkBzCyAoALTKFHoTIAl/Y4GAYABgVwAYAIwJUPcA"
"zEPxj6j+lIh/VYqnVfhJ9J/GrB+jMon/0yj+SWBqxUQAAE0DVA80AUZ9nEonAf4CAHTVc8AW"
"AJD5b9PAnKEBYJgXAMT9jzFWzgFzCyAUAGgEAEC4tAA8FQD2ArgA8P2Mt7kSwFUAagdElRUI"
"mFee4+D8Cp4WwGFjAgwCAJ4WgHoB7FsAXgCo70wFnHAgoL4DANwCsD0AnhaADwCia0j2v4QM"
"gJVU/CvwLYDDKP5SBSgNvyxGAFhcCv8uJfDv9AaKfRGMQgg5BSRCAABtAqRbAA4AzEAAmJ4W"
"9kxMDduHp4BNfREAuj0dagTw2bAQI4CPACA0ANDIBM1O2qOA72DUvnGo/kUGgJM643+qdXAA"
"OG3O/XbxAUAPq/Tf1wUANv7Ze/81oz43VlbqBgCAyf5RUC/Yvf+5avwzmf8SK5ZKUMbvZP5G"
"+HtZDn8bALTUz8+BVuY/THv/w9X9P0q+VuNVYPOfAYBIHwBE+QBgcQgAWJMIANimYQPAercK"
"8Mda+BN//Z+3YiRI/G+tUgjAuB7t2wNgtwDmBwEAjLMIAWciEACmJR4ADg8NBIAfEQBoKdD3"
"PRAAusFlUwVgAGjnawE0daYATmN2EgAAFAkCALUAKsNh/EANBIB3EADehoMz5CSw3AIo7tsE"
"6AOAUQUeCgA2MwDkdABgY5cXdSJA1//qdcAAAGjvXgP0AEBrvQbY2oIAAwDNAgHAOQfcyOcB"
"oPI/iv8Sii9S82KfqA+TQXgVI/xP8evwyir6LPxPw9RKKPwVJaZWSMKiH14+CQMAewAquQDA"
"HoCqZkeAtRL4/RR6JRAhoI4CwBfaAqgvLQDbA8AtgIcEAO7/UxtAWwAhAWBMXtg+Dv97jpMF"
"QNvHuS2AxALAfiP+0y0AoIkAAgAObyvgJzIFzinL44EOAHAroLIXAGghkA0AtgdAZ/aPrtO1"
"wNwK+MwLADzj/4Vk+noj4OTmLywAkOM/9hSAYwJ07hDQDQAS/+rw29IHBIBFCAALimIUxr9b"
"QRcA5r3KkwA8BRAKAOga4LQ0sHtCavhuGAJAn6QQ3e7pi6RPqlP2COAzqmePACCRAGCPAtIZ"
"xZwYBcNktOK9EzvqHAoAAFryY4x/pzr4AEAX/ZzB5xky/dGxH1P69wPAYKv0P9I11F3Q/r+n"
"BWABwEULAOxZfwcAUPSvUiwT34BT+qfMv6db8ne2+/XTUv9AFf7Bmu1rxn96qJT9Ten/rM7+"
"nxvnehWo/B8UALT8T+N/VPq/huJ/falb/o+3AqDi/8fGIACw1QcACgF/rEMAWCttAG4FxCAA"
"YNzUuLEC/nV9OYr/MssDoFUABoB5KP5zGQL+ODcLA0HgLELAmcj/ZgBojwDQJugUQOIAoAYC"
"AJ0nrea7BugHgLISUQgAs0vDwUiBAHMJkAGApgB4EqAo7MUP+r3jXofdYwomHgAwPACgEMBL"
"gSgIAPjynwUAHV0AIBigY0Br28sz9tus7jlghIA1OhUQ2yYTwwBdA/QDALcAmrgTACsap3FN"
"gJhdL21gAQBm/0s+Tw2zUZxJ7Fn0TVR+CqZypo9iX9GK8hJTyiWBKSz+CgCVRPh5CqCKBQA1"
"rEVA8QEAfl1yEyABALCuARIAcAvAMgEGAwAyAW4ZkjvRAMDXACe8Hi8AeEyABgCmBwIAjQY+"
"DAAEjAEGmABV+Glj39oQAGCqAea5USsCdgXAWgR0YoO7B4DHAGPMJUIq/1eHX5dVEwDQFkC8"
"ALCkFEJASYw34OeFRTEEALgNMC8vxqsyBjgntywC8gEAnwOOSAf7piIAjEsN2wYnh429k8Kc"
"r5+kEcD3VKcKqm5lCItnBPARAMQPAPYoYH6MtzBqxEVVjU0QAIzxzwMA3VT8rezfAwCD3NE/"
"x/lvBHVi4gDgssn+F0rZ/7Ia/q6g8F+NljgzQo1/mv2fMJm/bvZzZvtN5j9Iy/1DRfwd4cev"
"8cxIeZ7V2X/aUmi8CgEAMMO7/Y8BYJEFAMsUAFZI/98BgNUhAGCzCv53GgQAW3UfgLkPsJ6r"
"Bn/eWSdtAG4FrEYAWG0BwEoEAIQAfG+oChAaAKKCAMB0FH9pA9w8MVkBYAIvBLpBx4F8LYAA"
"D4ADAMFaAAYAWsH5HS3h/LbmcG5LIzi96UsXAPCD6WRcXQQA2gfwsWwD5AMldJ8cIYCykyAA"
"IC2AilYFACOqLAJAGRR/gYAfpmkVIFwAwEDAXq0ACADYLQBdBMTibwPAawIA/aUKsLk3QkDv"
"3G4VgFsBliEQQcAcALIBYC0FiT/BQAcBADYGYsS2FQjgJwEA3QSga4A2ANAUQFMFABTSFVRO"
"b+gFgKVU/q8vAEBreymzZ7GvTML/pIr/UzClIj4roNiXN4E/Lkfij1E2CUPA1HJeAODsX8cA"
"aReAswrYBwCeFkCwKYCm7jGgUOeA2QNgFgERBNhTAP83AoDTAqBlQDVCTgGQB8CcAz5KM/sM"
"AfW4DUAhok9l/c90wc/nIvC06pcAgIR/i44C2quAzSbAtXXUB6AAsILK/9VQ9B8CAJYUh58X"
"FRMAWKBTAHPzSvY/Jw++FwgAs2QVsAMAMxEAItJz+X8vAsCusQgAg5LDhl5JYGjdJ2LDZATw"
"LdUrewTwEQAkEgDsXQD2KGDeMBmtqLYiosKSoADgzPt3DAIA3UMAQD+r9G8u6Y1Q8TfldBsA"
"/C2Ame7WP2fVr8n+l0iQ+BsA4PJ/D8n8j3cPAgD9dbZ/kJv1c+Y/THwDXPYfLhBBWT8L/2g5"
"UMTlf+vrZACIsABgprX8B7/Wq/MVAPBrvL7svwAAtuGPt+k0gO4EIAjAX/PnHYSA22slbq1B"
"AIhF8cfnzdUKABjXHgIATkeg+E9TAJiC4m9WAk9AABgHN46OdQDAOwXg9wDYJkAzBdDOBwBf"
"IwA0htNUBdhUnyHgFH1wkRlwXR02Kp2I/RCOrflAb5SHBgCqABxeUEkBQCEgqpwCgECABwAm"
"vuEDgMLqAXjdUwHYMSyvjAEqBNgAsG2AQMCW3i9zbO6ZmwGAo1tOpxqwvksO5wTwug5yECgO"
"n2vxuRafsXQauCMBQVb1BWC0yxIAAKt5IsAHADoFwBUAewzQAAAK/+LPUvG1PurpMwBUEtGf"
"WulJFv4pFZ6CySj4U8pJTC4rMeUdEv+6s8f8AAAgAElEQVSnYfI7SfDH+GspykkLgAHALALi"
"jYCBtwA4+/eZAM0EgA0Azjnglr4xQASA1fEAAFcAfADgtACG5ZG9/yNedUcAaQEQ9f8fFgD4"
"LkAJ3gRIYs+huwAeuAXgB4BgFYAY9xzw77Fq2KMnLfBZJ54AKufTRb8TFFza/8wFAPIA0AQA"
"ij8tAqKxQDYI8tTA54EAwC2AeACApgCWIQAsKxcSAH5ZTABQxK0ABAOAmS/yOeADM7JgZMb3"
"Mz3sD08LeyY9CztGpYKtAxEAeiaBfh/8fQnpk+pU3jDvCGDQHQCPACA4APhHAbOFWaOALevn"
"6u8CQGs98tNOx/9M+d/fAggGAP3cmf9z5uKfPfanbnoHACYHAsBFzf4ZAKw9/w4AUPYfLUEA"
"QGuDOfPvqWEAoLcLAM5s/1AR/dPD3KzfiP8Znfk3ws+lf4KVSe7X6QDADAsA5sjef8r+AwBA"
"y/83V/oAQDf/3VmnAIDC/scmEX/O+LdrIATc+85tBdzTvQAIDH/eQQi4vS6RALAkCABEBW8B"
"BACAVgEYACYoAIyCa78O9+0BGGABgDUGGLAJsLUPAJogADTCMCuBEQLwQ4yqACfWYcR+BMdi"
"9UrZypqJAIAK8PM8hYBQAEAmronFxQcwWTwA+8YXcRcBGQAYRs7/11j03TFAjAHiASAAoNjS"
"Nw9s6YMQ0Cu3LAXqmQs298iF4i8QsKErQQB5Al4Q8ddYy5cBX8DnCwIDHbUd0M4CANMCcCYC"
"4tkDYK0CJg8AAcDiL1Lzvv5pVZIIAFQWACDhn1z+SZhUDqMshSv8k995CiaVwWcZeT25jEDA"
"lHcIAsQE6ABAtaTeWwAOAKTkNcB8C6COuwfAAIAZA4wXAMgD0NE3BaAtgGAeAMcEyOKP/31o"
"7/9IjVEIAGMCAcDxACQ0BTCF7gG4twACACCICZAAQCDgHYwgAMAtgKrBWwDkAViFABCDALDm"
"E4yPrRAIoDiO3yMUJxQGXAD4QkYBt36pmwC/ih8AdBMgeQBoAsBpAdgegCAAwFMAi30AsKgI"
"QkBBrQIEAYAZL+B7hQAQiQAQiQAwLT3snUIGQASAkalgS38EgB5J6Apg/zDvCGC2sARGAB8B"
"QGgACDUKWPGjapk7ewHAzP7rql8Wf+P8tw79eACgr+77H6TiP9zt+58zpX8103FWbQBgaggA"
"iLKyfwMAdukfhfXqCinjG9HnIAgwy31M6d/M9g9zxd4Rfc38z4wS0efLhHqfgGHFBoDpFgBo"
"+f9KlA8AqPyPAHDDBoBV8QDABgsAtmrGvwNjpzzv7dBKgIGAzfzvuwCAQeLvAYAYBACMa+ID"
"EABYLBBwCSHgogsBfxgIIAA4TS0AAwDhCAAIAce1CnBsogDA72MsABjiWwRkAQAvArI2Aeox"
"IFkF7AWAM5upCtCQWwG80nQDQkCcjithxnMMIcAFAOlRBrYABAAOL6iIAOBCQHAAKCGjXDQJ"
"MLUY7JtcRG8BIADoJMAOvgOAADAcAYCWAA2V4LXAA18RAKAqwCDMLskQOCCP7ASg9cC9cks1"
"gDwBPXLCBgSBDV3FExDXkdoBVA0Q4XcAoJNAQOy3GO2yMQCwH4CWA7U2PoAMEIMiaW8CZOFv"
"ruEDgCUotnS0h4TaBgBH/FH4J76DUYaeKvYq/hNL4+vSAgGTSj+NP4cAUEYhoLz0/+n3ZfHn"
"o0DJ9VSwZP+zzSGgj323AIIAgN0CsAGAsv81nTKL+AcBAG4BDHTFfwtl/34AIOEfpeV/dv8L"
"AASbAnD3ABThPQC7JlkAMDURAMDibwOAhEwDGABwxwDj9QCsfB8BQKsAKNBHPADwsULBJyj+"
"dTgEALQFwCbABlzyTxAA6BiQuQVAi4ASOQXgjAEufFMAYEkCADBbjgHxNUAFgP0RWTAy4fei"
"AMDu8c/C9uGpYHPf5LC+exJ4M+fjnUmfwh5gBPARAPjejBCjgJnDZKSiSJiMWHzoAgBm/6fb"
"6Zpfs/Gvszr+u2nvv7tu/Ouu4t/bKv0PsTJ/n5PeGP9YVLWsnmgAWGyV/lX8aRzwWE/N+PuI"
"8NuZ/ynb4W96/drnP6Oiz2X/MXJGmI8STVBI0a/z/GT36yTxv0Tl/5kSVP43h39CAsAKBQCK"
"GAsAUPzvxCkAUFa/WcSfBX+Xxk798XcKAFtDAMBaBACMmwoBDACrFACiBQDwvbrHrYBFCgEy"
"DsgAYPYBmAoA+QAwbp6YJhBAlQAGgPHqATAAMFQ8ADYA/BgKAFqHAIBmCAAKAZsaugBg5pXX"
"IgDQmdI1tbUNQB9QUgX4lT6gdCHQL4sqSRWA5qsJArQScND4AGhXO2Vo1Kel3q0FAXsmFgsE"
"AKoCjNRbAENe0xDBZxPgIAsAyA8wkPwAr8DmPij+fcUTsInHA1H8CQJoSRBCQBy1AtQXsBZj"
"XSd5BgBAW50IQOFfpeOAbAT8Jj3E6C2A+ACAJgBIkKdXDQ4AlPk74s8RCACT3ibxTxwA0Elg"
"Gv+b+Z4PAGgNcL3EA4C9CIiy/zVsAMwaYAL0A4CIf27YMjR3ggDAzyB7AAgAdk0oFHwT4H8H"
"AATZBOhOATwkAOgUgBj/EgAAGin0XwO0NgHaewDMMaCARUA+ABAPQBGvCdAGgBk+AJiOADAV"
"AWByWtg17ln4bmgq2NRHAIB0SfWpiOpV5rAERgAfAUD8AGCPAubCKBTmjAI2uCgLgAwAdNAw"
"4t/Fyvx13S9n/2b0z1r36wEAzf4v+Mr+tFXvYji+DrdWAEdaV//mJgAAK+WA0PHeQRb8GMOf"
"r+fPWT8Jv5b6Tbn/rMn8J+pZYp/w09d5cZqIP10ovDxLwjH+zZf1v7wAyAcAlPnfVPG/peJ/"
"O1YBYL1m/5jZ/7FVyv0s+Ls1CAB2KgBscyGAAWADin+chAcAMG6shn/dWCUQcH053L+2DMV/"
"qUAAA8BCFH+BgD/Oz9UqAELAmRkIANNlEgDjpqkCqBkwOAAMRQAYBFd+GgBXD/ZDAOibAABQ"
"C6A1AgBCwLaWDACnSfzJDEiXzDa7bQCeV8YPt2NryQ39gVQBeFNZTXUqV5VYUgUO44cpA8Ai"
"LwAcoi1sc2Qa4MeIt+BHhIAf8UP7h3DZC7BvanHnIuCe8UUUAF73AYALAdsGSf+fKgH0mmIr"
"BZsCqR3wioS2BHhHgLkVQO2Azi9KO8APABziBeA2QHsBABoFXEXlfw8ApLcA4DlY8fVznhYA"
"Gf8i303OV/v4iE/V4ADgqQCUEeHnQNGf+LYLAHYLgAGggmsADACAWtr//zCwAuCsArY2ATq3"
"AFrIHoCVlP23zwQxHTNx9s8A0E36/8FaAJsH5RTjnw0AwwMBgMx/DwUAU4IAwPTgJsDAFkBi"
"AKBqwCIggQAvAPiDDYGxfgD41AcAav7b1kgAAEGAlwPxiOAXPgD4iCGAv8di5HvMPgccsAjI"
"BoAlvgqAHwDmvZowAFAFgAEgJYJzcljePok9AlhI9SrBEcBHABAaAEKNApYOc0YB/QDQ0Zr5"
"t0v/KvxnraU/jukvFABYrn8GAEtYSfxpkx9NAAQAwPwgALBCAOAk/tkn+qrwD1R3/yBX9B2T"
"3zC31G+En0V/vFvuP6fl/nMm81fxv4Bf28XpEpcjrdL/bMv4t0DEn+b/ae+/AQCz/c+IP4o0"
"YMYOt9dK9n9no2T+JP5/kMBvV8E3ALArBABsQgDYaAHAOgSAdQIBDAIEAKsVAFYgACxH8VcI"
"oFbAJYSAiwu5FfDH+Xk+ADAVAAIAzf4ZACbADYqj43gboAcAfh6MADAQAaC/AkAvBIBuXg8A"
"twBsD4CMAp7b2lTEf8tX7AM4tUkA4CQDwKfsA5APKAMAtVwvQHQ1iSW0E4BaAeoHYC9ARfiF"
"WgHkBZhTFg5RHzYSP4ynv8kQwAAwVbYDMgRQFWB8UfYB7FEfwK4R+THcCQDyA2xHsd8+8DXY"
"MVhfD5b1wFQN+A4BYFs/ilfEF9BbfQE9BQIMAPB0QGfxBFArYF1nDa4CuPsBYrT8v4r2AHwj"
"ALDKbgE0VQBoTpMAMhK4FEWV5vAjayQLDgCVng7o/wsEuABA4m8AQHwAlgmwrJoAqwgAOB6A"
"GsEBwOMBsBcB6RggXwNEgJElQBkcAFjdOROLf2wXAYC47roHwABAPwKAnPECwNbhbv//QQDA"
"bgF4jgEZE6DuAaBlQPum6zbAoAAQ3ANgA4CcBK4RAgAsD0DsJ14PAI0Drq0bxAPweXAA+K4R"
"XwdkUyB9jxEE0CSBfn9xm41iDf65q833WHWBgOgq7irgpeW9ALDorcQBwByrBTDzRTgww20B"
"7KcWwFRpAXw3JBUDQFSLp8wIYOmwBxgBfAQAiQOAgFHAndHvbRUAaIvC2d67/CcoAFDW39fn"
"+A8CAHxJzyz9mRSYVVPQHP/5iEQCQLSI//mZWvbvJyBwarD4AVj4h/vK/SNdg99ZzfjP6Rli"
"LvdP1nPEU+S1c5tgmmwnvBgpwaX/WWL8u6Kb/67q2t9riyRuqAHwhpn9X2ll/nGS9XNswNgk"
"2f/dbRIeANglz3u71AtgIGCLBQAbNOLg37ctCLi5BgFgjfgAEAIYAK5GKwAsQQBACLi4iKsA"
"BAB3zkfBnbOzGQBun460KgBTtQIg+wBcABgN12gS4JdhCgBDEAAGWQDQm8cAL+3viuKvVQDa"
"ArirrQsAugzo3FatANAkAIYfAE7ihxyNA1Ib4Njq9+EY7Stf+R5+OFGGUgOORFfn+HVxNQwB"
"gcMKAeIHEDMgLQX6kbaz4Qc0QcAP00s5ewGcKgC3AaxpANoKOMY9DLRjWD4WfIodxhg4JJ9U"
"CPhkMIIAQUB/AwF6KwBBYFMvqQJ4AADFf30H9QJ0Vj8AjQa2y+q0AGIp8//GAoBW6R0joIwB"
"6jVAEv8v03AJnrJ/2sjH4h8EANgEWMEPAYEAwB4A/Hl7DJCnACoFAgBXAMwCIAMAJj6RMcC5"
"9VwAoCkAPgfcLC0sx7/PilaU/bsAsKZzZhb/tSz+GD2yQ5wR/94vwMb+L8LGfjlR+F/yAgB5"
"ACwA2DrCCwAuCPgAYGwBNQHKLYCdE30AEGQToA0ApiXAUwAWAASbArA9AMEAwLsK+CN3DDDI"
"FMDxOAmZAvjMBwBfWgCA32P4ZCgg0Kb9ALRSWI2Ax9Z+zABwLPZ9BO1a3AqgA1xHVlTXxVuV"
"8GsUE6ANAM4UgAcAgu8B8IwBWlMAB6anh33hCAATpQWwsVcyGN/gH1vDgo8APgKAhwAA/1lg"
"GqV4IUxGK0phVIueVnGpCwDfeo1/ZPYz4m+u/VHP/xwK7zly/A8R4x8f/AkGANbSH86qwwMB"
"gMv/MxMBAFT+XyWCT73+E6bkbzv8R/qyfbvUP17OBvMFwsmW4E9140K4lfmr+F80pX8S/7kS"
"3Pe3AQC/xhtL8ccIKTdWWNm/lv1vG+Hf6Pb9725VANDy/71dvgqAHwC28q/7885mCwLWIwDE"
"WRWAWAWA1QwB968hBFxdDvfx/bt/GePSErh/cTHGQriHAHDvXBTcYwCYhQAQAbdPTcfQSQCa"
"AjAtAAaA8S4A/DacIeAK7wIYDFcPDUAAoDZAHwSAnrwISPYAdPSOAe5UDwBXACwA2NRQglYD"
"4wfZSQaAOnCcAeAjHgc8FkMlSqkEHEEQoLllAoFflxoIsNoBCAFsCIwqrwBQBgGAIIDMgKU0"
"SjIA0ETAngn4Yc/TAIVR/HUiYCwBgIn8cheAAEDFf/uQ/AgACgEMAAoB/Uw7wABALgEAqgJ0"
"kx0BcZ3EFMgTAJ1lKiCWFgPRGCDdCNCjQDHaAljDLYAM7AGwAWB583SwjMS/ZgpexkNBO/m5"
"/88egGSBAMDjf09aEOD2/7kFoAZAGgMMugioincKwA8A5AGYo0F7AKLquADAJ4FpSqFJWliG"
"X/vylggArQUAVrWVBUBruiAAdEUAYPHP5gAAbwHsgwCgVwA9AOAzAToAQFWA0Xl5CsCzCpgA"
"AIPEXwCgoGcKwOMBcHYBeG8BOACAQEkRdAzQswq4QlAAOJwYANCyP2X+x9Z9yiFZv3H/f+4x"
"AXqmAAwA0IlgBoAGvDzoeJwaAel7jIIAgP027vbNIysQAKIrIwBU8gLA4tIBABB0D0AwAPDt"
"Adg/DQFgggGA5NDngyfoDHA11ae8qlfPhcVzBvgRAMQPAPYoYLow7yhgld5tC47yAMCZzrLp"
"z+n5m41/vTTzR9E9N8AVfxb8Ybr0x0wAjHoIAFADYHwAcHGeGv8IAIzZb5iV+Y9yy/zs7Nex"
"Pi736/lhj+iHuxl/QOY/U/r+l2aK4/+K9v2N6e/qQnf0j+IGiv91/BpvqOufS/+xUva/reJ/"
"R8Xfyf5R3O9uVwAg4d+jsVt/rNMAXCHYJgBwbwsCgFsJ+DdBgGkF3FyLAIBxXSDg/jWKlQoB"
"0QgBSwUCLi10JwIYAhAAzkQ6EHDrRDjcOj4FYxJPAtwgCGAAGKcAMIIh4OrhoXD15yFw7eeB"
"cPngAKcNcPlAd7i8X5cB7ekgi4B0HbDbAmiO4t9UIGBTQ10KhLFBqgAnucT5iXw4EQSs/pAd"
"y0dpdenK9wUClteE3/BD9LclNbgKcNiBAPyAnV+R2wCHMAP7cRYCAH0oEwBEqCEQY59CwJ7x"
"xWD3OIqisHMsfvgjCOweWwh2jsLQSsCO4QWkJaDizwBA+wEIAgblFV/AAAGBLeQJoEVBCAKb"
"6Gxwj1wyEaCtgLhOLzIAxOpIoJgAszEE0FrgGOcoEEYL2gOQUW8CiAlwVVMZB1z6VVqY9X5K"
"FOEUEEERBADC+aBPcAAQCPCOAFLwHoBytA1QVwGb8AEA7QHwtwAMANgVAHsREJf/fQCwisx/"
"7cX8F9s1M2f/NgCs75VdxL/vQwCAMQLax4BG4387AwA8BigAYK4BmimAkAAQHgIAfC0ArgBE"
"Sf9fRgArBuwBYACIrhk/ADjhWwRkNgGSsc9eBZwoAPiUWwjH6HuMv8/weyu2NrfbjsbI9s0j"
"K2n9tg8A/HsAEAB+WRo/AJhNgB4AoE2AERnwvRMA2DYkJWzsmQy+KPX4KNKlMO8IYLqwBEYA"
"HwFA/ABgRgHNWWBnFLBVg5f78BQAjQBS//9MF9+Yn3/XP437DVQAGKaCr3GeMv9RuvzH3wKI"
"DwBM9m8DgJoAef1vtAAAiXxIABihJr+xbo/fHu3jzH+KK/wX9M8/b74OyvojJOM3FQlzlZAz"
"f836WfzpuUiMfwwAS6X0fx3F/wZm/jdXS/bPvf84DBX/Oyr+f2zzAcAuHwBg3NujlQADANu5"
"CiAAsFkgAH/ffxME3CIIiEMAQAhAAPj3DTIEIgRcW6MQsAoBACHgMkLAJYKAxWIGvGAAYA4C"
"wCxuA9w+rRsBTyAAnJiEEDBZxgGPTlQAGKUAMAIBgPwAwxACBiMAyEQAVQEuaxVANgJ2hIsM"
"ATYAtITzW2US4BwCwFnaB7BR9gGc3kAlyi+4Tyk+gDo8riQjS3LA5Kizv1wg4Ah+kB4xlQDy"
"AyzED9j5uiKYdgLMotsA+IFsWgEIARRcCQgvCXsnlYC9E4vD3gkIAewHkN0Au0dJMAQMxxiG"
"gjGM1gPTE7PIoQX0ZLBAAO0NMBDAlYB+Ygrc3EsgYCPfDFA/QCepBMR2yi7jgCz+2XgbYExb"
"NQFStHQvA9IoIBkBaSvg8kZpYTaK/6z3UggA1CAISM4QIOX/ZHzNbyqKNh30mVLxaQ0vAJhF"
"QAYCeBFQWbMOODgAmBYAA0B1vQJoTwFYewCMCZCz/y99ANBCAaCdjv5R+b/bQwKA3wSoewA8"
"1wDpHDCJP0cBHgd09wC4HoCg1wBNC8APAKYFENQEqC0AAoAQ54BtAAjwAHgAoK4LAMFuAWz0"
"A4CvBeAAQH0XAKiNQGZbhoAPtQ1AECBnuP0A4N8E+AsDQCkGAMcDEGQToAcAZmSzVgFn4AoA"
"TQFsHZQSNvRIBu8WfKxPmHcEMKvqVrwjgI8AIMgbom8KvWH/0DfQjAK+jFEUo3wYjwK2tCoA"
"BgB6qdmPop+O+5llP/bM/0g3HOEf8wAAMCMeADD7/1FcL8zVWf9gADBCe/7G5KfmPjvzJ/E/"
"Z7J+Cz6cS4SRrvg754jnSFyZL8HCr6a/a+r6p74/lf5p6c9NFf+bayT7v7VOyv+3VfzvqOv/"
"DxV+Di3/s+Dv09irP1YvwD0ZC/zz3jb4N/76PxEi/qRqgAcAMG7GSSgEUCXgPkNADAIAQsBl"
"hIBL0gq4d2Ehxny4e24u3D0bhQAwG8V/pgLANBT/qQoBNgBMgOtHRqP4EwSMRAAYIQDwyxAE"
"gEG8FIgBgKsAPbQV0Aku7u3orgPmq4AIAdtaIACIF+ActwJ0IRCJP7UB1hEAfCqnUKn0GUuB"
"H1YOBGg1YHltgYBo/CDFD9VfyRhIGRbNWqsh8OAcGgnED2OaCOBWgIAAVwPCqQpQUgAAYzdV"
"A8bKZMDOMUVg9xiCADoWhDGCQqsBGNuHFcQoINWAwWZZUF6nHbBF2wHcCuiZGzbqkqANvC6Y"
"tgS67QB7EZDsAcikkwAYLTLCSgKAFnIYaHnj52BO7VQwq3ZKrgDMepdaANIGiEBBnlaVggAg"
"GYp/Ej7q4wEA3QJowlkFTCBQLnEAQOV/BwCCLAJypgBQ/OebNcANn+UrgGQAXPZ14gCAzX+9"
"s4v4930xEAC4/++aALeNQAAYqSOAPgCQq4AIa6MUAMYU8HkA4geA/ab/b1YCKwCEngLwAcAi"
"yv5N+b86HwPyA8BvK2rrFMDDAkAID0AoAIjD7ymM43EfIQR8EAAAR1ZUcQGAFgFRGABY+iZG"
"EACYSwDwGmb/OgY421cBmJUFX2eG7wkAwhEAxiIADEQA6J7MjACWV316OcwdAUymOva3eLTu"
"EQCEMALao4B0VtGMApbFeP/+0ca3ZArAAEB3mfHnkn8/zfz7WwBgzvzaM/+m7D/WCr8J0Ii/"
"uutZfE353waA+e75X97/v1yyfF7401tG/k4McAHAMfvZ5X57tG+KK/zO5IGaDxlAzHOm7xjR"
"XAkHABYqANh9fwKAFSr+KPw3Y1X8Mfu/FSflfwYAFP87Kv4OAKD4392pWT+K/v39LgTc22d5"
"AmQ08M973yEAIATg7/Nv/P3+vL1JQz0BDAEYN9Zx/Ov6Wrh/3VQBVisErOBWAJkB715cAHcV"
"Am5bEHDrJLUB9DiQMw2AEPD7eAaA64cFAq4eHqkAMBTFf7ACQN8QAPAtir+aAXfKNMA5GgfU"
"SsDpzU3g9Cb8kNrYED/UvhQIoPJmnO47X0cly08ZBI6udqsB0g5ACKBlKtHvcjvgNwMBNBVA"
"H7xsBsQPYurLzizN8SOFVgP2TSuFEIAf7FOKwx6qApAnAGPXWBQDageMKSTegFGFGAJ2jETB"
"wNg+oqBAAPsBCAKoEqDVAPUF0IjgVmoFIARs7EEQ8JJAAAVCQJxCQGwH9QG0zwqr2woExHwj"
"sbplJvYD0GXAVQgAc2o/A7NqEQCkYgCYXSslCzBDALUAqmj5v1IyrQAEAQAr+ABQBe8tgMQA"
"QHybAAkAaA8A7QBYoNl/AAC0fB5WtgkBAN3iAYB+1hTAgwLAKC8AbHc8AK4JMD4A4GuAehHQ"
"HgMk4fcCgNsCoPJ/KADwTwH8VQAIaQL0AQB5BwQC6mh8ZFUBfAAQTUbACl4AWPIAADArl+MB"
"+GFWdvhhdlYBgBkCADvHPANb+qeE2K5Jb5EeqS6ZEcBMYYkYAXwEAPEDwBP6BqYO844Clgnj"
"UcB6hxwAOG0AoI8l/gO09z9ISv/ngy39GW0J/zjr+I8fAEyp3WTeJvs3AOAv/9PVP/z542br"
"Xx8x/50043+m9z/Wyvwn+Ux+02Ta4Lwv279gC79lRHROERsAwK/nCon/Yin9k/hz2X+Z9P2v"
"r8LXKv4312rmb8R/gyv+d7YpAFjif3eXiv8+BQCNe1oJsIyBf97bjgCAcRsh4DZCwK0tGJtd"
"ELi1CQFgA4o/QUAcAsA6BACCgFi4f5UAIEYBIBoBYDECwEIEAISAc/MRABACzsxhCLh1eoZA"
"AFcCzGZAhICjE+D67+MQAMbA9d8QAg4jBPwiVYArPw2Bq9QG+KkfAkBvCwA6MwBcQgC45ACA"
"7ANwAID8AFuaIgDgB9VG/KDagB9e6xECNjTADzmMuPocx9d9rhBQTyoCBAGrPsL4UM6a0kIV"
"yqaWVRdPwEJZFXxobgXeC+BAAINAGYUA/OCe/hbsCy/FlYA9DAH4gT+5GIq+QAC1BHaPRhAw"
"EDCyMD4LMwTsRCDYSRAwVFsCBgQwtqk3gCBgc588sLnXy7oqmNoBuTDjkWoAVQJoEmAdtQEw"
"VrfLKgBA0UrOBMdoJWD+J2kUAFIrAKSC2fgkATYQwC0ABQAa3ZtSIWnCAGAgACO8grzmc8AV"
"5fyvAwCVrUVA1QNbAHNM9s+LgFJ7AGDxVzQB4ALACgaADBDTPqMu//EBAM//ywVAU/6nEcCN"
"ffUA0AAt/w96GQEgjw8A8vLTAID5OQcAVPy3WyZAGwAcE2CoY0A2ACBIsujj/5/8JsCDtJUS"
"xf8gl/4NAFRxAcA6B/w/AwAN+NfQrz1O9wTW19X4GCGAAOADOPZ/2DvL+Civre3nnOd529PT"
"llLc3Z3i7u7u7la0uAV3txAIISFEIARCgOASLERJ0ODaUqyUQinldL3XWnvfM3uGCdLzfOTD"
"9ZshpClJ6X39l+9vhX+/HQCkDBBW37YKmAHgyo4aAgAuSwDJAABfAzznDwAIyEHnA7gRUDUB"
"Rq1MQydm4+/MsC+tEcBabo4jgKm0fyU7AfAJAN4PANYoYCYor5t9FLBFVFibk3YAmOgCAOYp"
"PdC7/j8IANa8AwBMA95sj/zZ/B/pE8AS/WsA4Cj/tl71K9v+8Ge5q+f+pfZvpf6NdL9ty+BG"
"u+nLv89PZx20bCWIzU4AsEWXIrboyD9EA4BV999pb/z7FdH/8wMaAA7pyP+INv8Iu/n/rs3/"
"lWH+f8TYzf9NIl4T7BDwxoIA1earMNsAACAASURBVBfw1+soAMAZRP+RSgwBAgIaBn47Tm+e"
"R0DHoKMw/iP0+hdAwDNAwC/7NQRwP8Buev14JwCAISAEELANALAF5q8g4MV9QMA9P7UXQLYC"
"btAA4KkA4MYqgQAGgGdJOgtwUZcBLswFAMzSADBVNwIyAIyjx9Fj9E6AUQCAkQCA4fTgtGoI"
"/OnEYGgA/cQQEME9AQPwYBuAhxp0tJ8SoODO4d6AgJ506yAehPu7IlrprDMCHdSDkx+gHFEh"
"sroW2lSaApO2NtJrghUESDlgMx7Q0hdQC5FITUr0Bgh4VwMEVMUDv7KAQAxAwCoJqHJAWQGB"
"6BXlRFF4H8UgsLQMneHMwBIIMGDptDUpwBAwqyidmKEvCE4rCBDQJQFAAB8NOjQBEDAut1wN"
"3D8mB+0frTIB+/VkAINAcLf0FNQhDQW0S0P+bVNDqfA+FYxXlQM2tYK4H6CZhoBGdgAQc3dZ"
"BnA6BQxtsMkJABroTYCN3t4DwFMAAR34AqA2/852ANja8yMAYFJ2RIJ2ADjs/g4AmFNA3QGY"
"BwBYWMio/xc3AKC4OggkHythq/+fdpoCOLPa8RaAAMB6tQiI9wAkCwCc+verbov6z3OZKaCW"
"6CIvo9raQExfGb8l1QPwbgBob9sD4PIa4BElyZR9TAlA7wO4q88D3z7S1READjIEtKKbfIUz"
"vNlbAHDZBID3TQGYtwD4HHBAHigXnQ/MQReCsgMGVA9A1Io0dBwA4NH7Cx4BbOFmHwHMq/3q"
"vSOAnwAg+R9KcqOAJdxso4ANQ98GgBkaAKxlP/PtjX8uAcAsARj7/5MDgMdWxO2vom02XBGn"
"20Pejv5v67W/NgDQ8/9W9C+R/zrHdL+tvq9N/6E2eXnV/34BAH/95/C3p/4fW5MIW7X5mwCA"
"6P9ZmGPj33Nt/r/B/F8cMVL/x3Xq34j+BQC0+f9hRf4JGgAsCEjQAGBBQBwAIAbGH01/vYpC"
"xH9GJCDw4jR0CgBwit78dgLmr0Dgz18BAc8OSyngzbMD9AYQ8OapUQp4HCZjgX88DKHfH2yj"
"33/aqiDgfiDMnyHAVzIBshqYbwPcAgBIFkADQNIKAYBnl5cIADwDADwDADwFADxNmAZNpafx"
"kwAAahrgcfRYAMAYOwBEjtAA8D3MnyFgEP3EkwERA2VC4O7xgXhQaR1lEFAwcPtwPzwEAQMH"
"AQIHekAWDOCBGQ4Q2NMWD61Waq85ICBpWxO6zKOBeBjLimDeEMjpWckGqDFBgQCfGhTvXV2V"
"BLyrUOwagMDaiqosAAiIkQkBzghUEMnHVkIWDCyzYEABAZcHTi9SGYGTczUEzCqsewIK0THu"
"C5jGGYH8dGRiXjoyQe0IUBCgpwI4IwAICO6egbZ2SYfoOi2MFmoHAGifGhG3ggDOBHA5gCHA"
"R7IAKRQANFTG7aWN3g4A/7YDgBMEeDd8NwCwfJvYxwA3t0kh0T+bv3T+a23pau8BcC4B8AbA"
"3cP0COBodf1v3wQnAOARwA8AAMkALLRfAvw4ALD2AagygDMAxHlVlE2A7wUAh8gff7eC6qjO"
"f/y9uwTDZ13e0VjMX0oATrcATABQZa12dH2fWgXMewCsLIB5DdA2BnisR/IAEMkAMEBNBPDS"
"Lf54hNoKqKYHAACsI51UGUAAoLUqA+x1AQA8BqhLAA7ngLeVf+cUwIWA/Pi55IX556bzQQCA"
"LdkBA5nlHHDUitR0fFZKmtX+M3MEsITbR4wAfgKAdwOAq1HAYlBlqPGa2ZXXv10CcAaABf8l"
"AHjZAUDG64zrfw4AEKwBQF//c47+efsfb/27a238s2r/a43I36jx20YMoYf61Yz4Hxq/b9b+"
"bQAQ/A4A2A1x+n+fSv1L9H9UiTv/Xx43av+ntPlHKYn5x2kASFDG/+acIwS8sUoCVl8AIOCP"
"WABADP3FIPAyGgAQBZ1RehEJADitdRIAcAIAwBBwBNH/IQgg8AtA4Ol+XQ7YAwAABDzcCQAA"
"BPxkQcAWQEAAAGCzAoC7+jbArfUAgLUAgDUCAc+kDKAB4MIiFwDgrgAg3gkAokcDAEYBAEbS"
"z6eHiR6wTg4DBAzFg4qB4HtAwBBAABQxGBDAwvtjgxQIHGH1pzuH+gEE+tBtzgjorMCtfZ0F"
"BK7zwxQgcIXHrXjsSsYDrYNBnJ7l6QAeE9S7Anx0JoBBYGNVezZgXUWdDQAMQNGr+b0aHxQQ"
"WGmBQHmVHViuSgQMAlaPwKn5JVVJYK4eEZxWWCAgQjYGFlRlAQaByXlVOWBcbrkPwBMCYQOy"
"0tbuGWlLtwww1vSQAoFALgd0TEOBAAH/Dqlpc3tAgM4C+HIWoFEKGwCs53S+TvFbxm/Jy5Q2"
"/g8GgJYpVO1fxv7eBwBpAQDp3gYA3gEwxn4DQACAmwCnAQCmAwBmawCYk4eOzgEEzFX1/wh9"
"BZDNX04BW1MA+gQw9wFw+v+kVRIw6v/2EoAy/zMrYf6rnc4BGwDw1jlgHzsASAnABIAgbvyr"
"CzNsoGb+dyjzT9qhxv8us/m7uAVgAwALAva2BwR0MFYAd7ZvAnReBPTWLQADAE4PVO8ZAnQm"
"QNYCSxagm2sAkDJAM8ceAOc9ANur0qWQylBFAHZ5fL9l9RKg5AHgQlBu/Gxy0oWtOehcgMoA"
"nFkOAJiZkobW/ed6NzUCWFn70wePAH4CgPcDwOdu9rPAOaAiUEWo4YjehWcqABjzgQDAZYAl"
"yZQAjPS/eVHPtmTHR0X/NgAIdAIAo/mPt/7JyV9d++fNf3fnqtT/Pav5zxr78zS6/I3I33Zk"
"yGo0DDB+baT9ban/QKMEoHsRbLV/PfL3TDf+8cw/m78AgE792wAA0f/LExoAzOifASDaAICz"
"2vDZ/M8r8Xv5dYI9O8B6fZb+eh2vIQD6PYb+89ISYOBFFIz/jNZp+vM5Q8BxAwIOw/gPCQT8"
"KRCwj/58HA4I2E2/PwwDBOwAAAQDAKD7nAnwBwD4AAA26jKAlwsAWKoA4BKXARYABCwAmKEy"
"ALwW2CoDRI+D+SsI+PnMDwIBchvg9Ah6wD0BeP0JIPDT6eEAgOEAgaFKEd+L7loSEFC6cwRA"
"cFjBwK1DffEA640HWE9EMN3oZjgiqD3t6VpYazzAWuAB1lRNB0g2oKFqzgqqh4dTPVnZen5T"
"HUr0rakFCPDi3oAq0iDI2QA1KqjesxgCBAQkG2AHgWgNApwRiJTSgJoWOL0AEDAPhgQIkANC"
"OhtwYnphOsYZgakFpTfgyOR8akJgYl7aNTg7be+ZmYJ7sQAB3TPAWDNQYGeAQJd0tIWzAp0B"
"Ax01BLRJRZtaphQA8GmSQkFAg69pfb2vDNPXAKAzAlb9394DoCYHzB4AgQCrB8AqATT/GsCh"
"ov8AGftTACDpf10CMAGARwDlCNDg9I4AAPO33QHgDMAUJwCYpVYA8xGgo7NVBkBS/3IJsCCd"
"mA/j1z0Aav5fA4DWSdt7nQFY6RoAzqwuowGgnCMAeNuPAam6/9vHgFQJgLf/GQBgLf0RAODG"
"P1ZTqf+LkmkCdAQAaydAJ30O+CNvAbyVAegntzf48+QuwLFuSkeTzwAwADhvApRVwCFV8P0B"
"ALZVhPkDALaWgekbPQBBRVwDwFYFAJwBiPdKh/9HUlPEjG+sEcCG2peKuNlHAFO4vWcE8BMA"
"JPNDmWofBTTPApujgPUzpP5nbxsAyBSAu+t9/zYAYC1VsgDAjP7NA0Dm7v9H+qxusgCAiPux"
"kf5n0789VUX/vPufm/+48e9Ha/RvubHb3wIAb3u938H8TQAIcPp4oP5zvAsAthvmH6ZS/7/p"
"6F8aAE0A0NH/S6v577QLAIg10v+J2vwvGDqvMgICAzor8DoBAAAIeMUCCLyKo/+wfmfFAgAA"
"Ai8AAr+xAAHPzwAArEwAKwIQcAw6Qq+fHoYO0esn++n1o/30+6NwQMAuQEAovfxpGyBgq2QB"
"XkoZwEeXARgAPOnX6zwOuFqNA3IJgMcBBQIAABf1VsBEtRb4ydlJ9DiOAWCC9AHwNMDD6NH0"
"8MxoAwJG2d8LBGidGoGH13AlAMHdiOGIXobRHbzeOYaP4fXusaFKRwfjITYQD7EBeDD2xUOy"
"F6IYBoHueJh2xoOsPR5kAIHQ5uohvB2RmGQEGtGlLQ3wcGqgQIAzAr61pUFQ9QVUp0SvatIk"
"eNYTr2uhdVUplrW2CsV62EEgekVFirJggPsGAAFnlsNYlpWx9QeoBkGYkrUwaA5AgPcFTC9C"
"EQCBiOkaBNwL0t5ReWhH72y0vU9W2sbqDQjomQnGqkAgqFsGCu6enrZ2S0+BAIGATgCAdqnI"
"r9W35Ns8Jfk0/YY28khgwxSqEbDel7SunhH5W+bfUJcH6inJ6t966vqfCQDejYwpgOY6+ucF"
"QO0tAPhWzf53+Za2cv2/m9UEaEX/AIBBagdAmLUGeLQdADgDcHByNnUFcEpOOsI7ANzVGuBj"
"M2D+06EZRglAzgEX1E2ARdQSoKU63W8AwKmVvApYz/+v1ADA5r9a7wJYCUDjQ1BvAUAFOwBI"
"yt+++z9hU1VK9Ksm6X/VA+CY/n87A8DHf1gc+TeT8T/bFAA3rvIECy+22tXaBQBwP0AHh2uA"
"ao3vBwCA2QOAj3MJQI5vneiDz+2VDAA49gA4AMD22vieAADB1fD9VaaLwZWgCjD/cjD8Mvj+"
"S0IlIN0EGJA8ACRuzkxxnmnp9CIAwPRvKMX//rM3+5Gb4wigwxng9/jcJwB4RyOgdRbYHAUs"
"66ZHAW3HgH7UPQA8Aigb/6zmP2PzH0f/FgCYi38esvmvMQ4AOZn/I197+t8lAARrAAhVDX23"
"8We5466jf+vwzwK1EOj+sr8BAIGG2Zsw4AQAT4Ls6X8bAOjGv2dW578R/TsDgET/DADa/JMD"
"AFvtX0f+/7mI14sGBJyzZwM0CPyFz//rD+gVv54FAMTD/PH6Eq8vAQIvWAoG3gAE/nweCQBg"
"EDgNnQIEsAAFv5ygOwlBFBe2kOJC59OlYysBAfvo9cM99JIhQLIAgQCAzaohkLMAtzQAyD4A"
"nQEwAeAijwPOSwYAFAQoABgj+vkMJOUAKEoDQSReI/l1FB5co+ju6ZEw/x9Ed0+xRulXrWMj"
"lI4CDI4OxUNsCDQYDzIGgX54mPUBBPTCgxQgEN4Z0VZbPNDaAARa0hWOwgAClwQCEK0xBPjX"
"g+pKWSDRB9pUixI31qSz3tCGGnR2XQ3AQDUYAwDAs4qCgNWVKdqDBQhYqUoErKiVFWAuXBIo"
"p/oClqhswOlFOhswHxDAmgvNhmbw4iDeG1CYDo7PR6H9s9OO/jkodABe+7KyUkhvgECvzFAm"
"RNYAgR6AACiwa3rJBAS0T0N+7VQWgAHAu8k3ah+ANAJ+RZ4wdgcAMECAywQifQNA7gDUNwBA"
"m79PU1375+i/jTL/gA7K/IPE/DUAdE8t0X+wjv63D9AA8D0AYLjjFsC9Y7JJH8BBvgI4ic8A"
"w/inMgDkpsPT8tBR6Agg4MisfHR0Dk8AMAAU1A2AhenEYmsDoKr7S8e/NffP639X6ahf6zSi"
"fgYA+dhqvF+F/zZrXAEAm39line6/mcHgBoiBwDYUlcDgL0HwAKAK5b5h7FaCgDIa5jqB7gW"
"xsutGAJ42VV7BQG6FMA9AdZhoOQA4J1NgC4A4G5Ed0cAcJoCUPV/JwAIro7/Z6rSxa2V8X1W"
"FAC4GFQW33tpRPUlIQBAgAEAgQCAQHsPwIWgnHQ+KDsl+mYCOKelk/NT0bFp37DRWSOAZd0c"
"RwDfeQb4EwB8GAC4GgUs7aZGLlrfOdPzkroGOFFnAGbrsT/d+f9Ap/1l25+19c9c/rNKm795"
"/tfLPvNvbdmzov/Hxuy/DQBgto+3q/e3J9sBQGr/c1T0f2/hOwBgvVECcAaAACcAsN4H2F9t"
"PQA6+n9qAkCoAQC79ejfuwDghBMA6Oa/V1b3f5xT9A/j/88lJRsEcDnA0gV5/Qsg8NfrRKVX"
"5+g/f0CvEgEBlvDrF3h9EU9vXiZCcaKkU350InAeBUzsTRPrlqIeGT+nDp+7UUfWZ27UHq/j"
"65UABOwHBOymlz/tsGUBVC+Aj2QAnt9cpwBASgCr1CQA7wOwAcB8enJ+Dsxf3wWQw0CTlAQA"
"xslI4MPosTD/cVpj6cGZcRBeI8fQT5Fj6afTeMWv75+2NF5079Q4LfX+7nGle8fH4GE2GjDw"
"Ax5mI+n2kaEaBAbSzQMD6MaBfpIRuL63Cx5snfCQ7QgYUCBweXszRDSNVVkgqCEeVPUhLgtA"
"mxgG6tI5nzpQbTrrU0uBgFd1RC8MApAFAgIDgACRBQIVAAXl6cwyzgaojMDppaXp9EI1Onhq"
"YQk6xRkBLg3MK4GHYXE8DIvQzoE5aefgXBQG8fvQQTloJ4AgtF82CmFJRiALBffORMEAgSCG"
"gC7pKbBjWvJvl4Y28Whgi28VBDROAYNXEKBKAbwX4EuHsb8NsgeAMwTa/Oto1VP1fxsAwPx9"
"mxnRvwkAXVTdXwCgm0r9B/dOQ9us6J+PAPEZ4CHqCmD4yMxOAJAdAMANgOoE8OHpueiQex7R"
"kRmQuwKAI7MK0LE50FwAwHyY/0KA02Jt/pak4U9H/hoAIldyql9H/AwADAUrlPmf5t9bDUjz"
"KGPbAxCzzgKAKgCAagYAVP0bAND43QCwUx8GAgBwFoBLAdfC29G1ve0+DACOqLHAd24CfC8A"
"tJergA6bAJ1uAVwKqQXjr4b/T6rAyCtBFfG9lsf3XRbffymohChZAOApABkDzEZnN2bC/xsA"
"gHmpaMvwr3kEsLX2o9JuHzkC+AkAPgwAnEcBv4NqQC0uHe0cR/dMAHA6+PNgsRHxW8Zvbv4z"
"U/9m17+e+bft13cFAFb6XwMA1/hvjQcATPoIAFirpwCSA4DADwQAcxGRFkf/v7D571ISANhr"
"N//nB5IBAD3693ukAQBW9B9nNP85AYBAwCUFAX9e1Lok+gsgIPrjoug/f1wCANj164NoOn9k"
"E+1eOYFW9WtF7g3LU4f/daPO/3KjLlD3L9yo57/dqN/XbjQghRsN/EapH97PblWZXj+JAAQc"
"oJcPwgAAIdIL8OIeIODuZhkJfM5lgBtrZRzw2XUTAJY6AcAMAYCnZ6cYADAR5j9e9Ch6PD2I"
"YiDQ72MmAgAmIPKfAADg3xsPAJhA9/E5P52ZCCCYSPeiJuH38Ipf3zs9GR+bjNdJWvjYSRbA"
"4OQ4PNRG46E2Cg/GEXTz8DC6eXAQQKA/Hqa9IYBAeFc8ZDviYdseD+ZWgIDmgADOBjSmS1tU"
"WeBiAIBASgP16dymenTOV4HAWe9akhGI86pBcd4aBNayqlLM2soUs7qSNAxGa8WsVKWBqOXl"
"VV/AElYZ6Q84taQUAKAkjF9lBU7MKU67hualsKF5ECnngVnmprDvWYABhoJBnBHIIdmBkP4a"
"Anplpi3dM1Fgtwzk3zkd+bVLS5vbpgYEpCIfhoAmdghYryGAU/uyIKieUe+va5i/9d4AAF4v"
"zObvAABtUwoA8OEfafrrBvPvrqJ/Sf3r5j/L/KUBkFcZc/1/hAaAsdloL08BsPlPzikAsH8y"
"zH9qbggAMCUPHZ6alw7PyC/mf2R2QQAAhOj/+LzCdHxhUQGAE5wBkK5/gNTykvZ6P5s9m74t"
"A1BKw4BK/bP5n15Zms5wFsACgHUGAPD2P5+qyQOAbP3j8b/afw8ArFKAqOWHAYBej32br2aa"
"R4FMAHC6BWD2AJglAKsJkBcBqdPb+hbAbusaYPIAcD6wIlQO338ZgPK7AYDHAGUPgH8OWQUc"
"vyEj/p9Ig7/zqch30JdxbmoEsIb2pY8aAfwEAO/+wTiPAvJ5RXMUsFnYxiahAgDcA/DTdJX6"
"/3mR3fwfWNE/p/ph/A9XOW3+W+0i+vc2AGCTAQC6496a/xfzD1YA8DNA4daYDwAAswfAOvO7"
"Tk8BWFv+zCZA0/ADjH+/CQBm7T9ENyNa0X+YNv7dKv0vAKDN//lB+/jfiwgnAIDx/25F/lb3"
"v7X21wKAi8rw/5MEXVF6k6Qh4LIWfv3nFZg/K4l+exRLl08G0QHvWRQ0fSAtbFmVvs/+OfVC"
"JN8HJt+XTf5LN+oPox8Ecx8Mkx+S0o2+/9aNhqVxo5Fp3egHaLTWCHxsaZd69PqX0/TqyWF6"
"/fNeevlzKAAgmF5YY4F3fAAAG+j5jXUCAc+ur6Fn13gccLkCgMuLnQBgugIAgQAoRp8JjoHR"
"R0+mn6Om4HWKeh8zRYl/HTUZAACzx3tR1FSlM+52RU1XipwFTcP7aXQvEp/DOgUwODmB7p4Y"
"B43Fw2003ToyEhHT93SDswH7++Fh2hsP2O540HJZoBMezu3wgONsQAu6vK0pHtxN8JBrDDXC"
"g6whXfAHCPjVp/MMARtriywQOLuhJsV7AwY8qwsESCZgXSVbb0CMB7SqEkWvsrIBZUWRS6Fl"
"ZZSWAAYWfgcjLAhzzKcgYBiDgHrdBRjYNZSBIBcgQIMAQ0C/bLStX1baAggI6paRAjqnp83t"
"05G/AQG+Lb+ljU2dIEBv9xMY4PIAZwa0+XvZAIAXCKnmv7cAoIUCADF/RP6B2vzl8E+PVLRN"
"rv+5AIDBGQEzmfA9ZbYBQDii/71js9PeCQoA9k/JBcH8J8P4p+QV85f0//T8dHRWQTo6sxAA"
"oBBFzClMEfOL0PEFRen4IkT9Szj6ZwAAUNma/UqJIleo95b5n16Jn/kKXftfqSVlAPy3MUoA"
"vAOAJwDivK21v45NgNIDwAAgs/92ALi41cUUQKjRA/AeADBLAG/3ADgBwGFXAGAeAxrgMAXg"
"0ARomwLgrEJbx3PAYWoNsJwDDgUA7KjtAgAqKADY/DYAXAhQi4CsHgBZBMSbADfnkGuAcesB"
"AMsUAMzp8AWPADZzcxwBzOj2gSOAnwDgwwCARym+cVOjFbncjFHA1bOrrrcDwAzV+CfNfla9"
"34r6Vyvzl3q/tfFPd/6b0f8jAwAe67l/W/RvbNt7ZNX+IV4CdGsyNNYRAKwJgA8GAFdjgMkB"
"gL8TAFi1f2sR0Q5l/s903V8UDu2zm/9znv8/8h4AiNap/1id/tfmz6l9y+j/cxW6pl7f4PXN"
"VboSuY0SDm6i8DWTaPPY7rS8fS3qh4h+AKL5wdAQmPzQr9xoOEz+B5j8aJj8GJj82NQQTH1c"
"WqXxrHRuNCE9lMGNJkGTM+IVmoj3Y/F7Y4t9S3/+Eg0AOEGvH++nVz+HSUPgi/tbAACAgDub"
"AADe9Fz3Ajy77mEAwDL65dIienoBAHBuLj1JnKUBwN0OAHGT5fVR7FR6GDcVhu9Oj+Km06OY"
"afQw1p0exk/Hx6FY1kz8ejY9iJuD97Pxuay59JAVt1ApfiF+366fYhfQg9h50Fz6MWoG/Qgw"
"YN05OZnunJiIhyODwAhEOsMAAoMFBK7t7UVX93SnpF1d7SCwszXUEg9vKLgZHniAgcAmeLg3"
"xoOsIR5g9ZUYBnzr2IAgcWMtaRyM3cDjg1XUKzcLeqgeAWkYlJKAEi8XilqulgoxEByaWJT2"
"jClIe37IT7tHFaDdIwrQrhH5aPdwAIElgQA7COwYmJ229cmGaDuLygJ0yUj+HQABHflSIENA"
"GvJrCwhoriBgQ0M7BFjGbwcABQEMAJwN4BPAvEqYm/+4j4CXC/k2/1puDljLf3j8L6CzTv13"
"U6n/bT308Z/e9tG/HQPS48+ankIHZZAMgAKALLRnVFbaNxrR/5jsdECn/w8i+j84SQPAtHx0"
"eHo+AACi/5kF6CiM/+hsAMDcwlARAADMf2ExOr64OJ2ATi4tQaeWf0eneNWvJTH90jYAOL2i"
"DFSaIldDq8po80fkDwCIkjKAvghoXAKM3VDZtgJY3QFQIOAAAHL+t7aY/8Wt9VxPAXwMAJhT"
"ANr8bx5wbAJ0BIDu9kZACwD0GCBDwP2T/R3GAHkPgCwCslYBH9AAwNH/rqYKAEJh/jvqQ3Up"
"absLAAgAAAQYALAZALC5OMy+mN4CaCwC8rdfA0zwzUqxnhkBvrwEKBUNa/A/ziOAubRPfaN9"
"6xMA/JcAYO4CeGsUcHjvIrNUCUADgKz8NZv8dNTPUf4jq9ZvyDz9a+v836jN32r8g9k+CbCv"
"2LWl/jUA8Fz/zR8MALCaAGc4NQHi8+6ZK4BNAHBaBPTIWvTjagIgwBEOpBch2DhDrKcRbKl/"
"EwCs6P+QBoCj0DEAwHH7BIANAKzIP0at+H19Vjf1XaDfn0bTjdgddDEigA5tnEFb3fuQZ6fa"
"NC7Xv2jwZzB3RPPDoRGI6Echmh8Nox8Po58Ik5+UCiYOo3eHeU+Dsc/IoDSTBWOfAU1nZXLU"
"NH7Ngt/PrH7tnllBAGcE/nx+ll49PUmvHh2EdtPvP4XSix+DNQQEAAB8AAAb6PlNL3p2AxBw"
"bY00AzoCwDwAgG4ETFAAwKb/RMzfnTYOrkudC6Wlee0r0IL2FWlBh0q03b01HVzekQ4s70yR"
"vv3pceJSesQ6x69L6FHCMrxfobVay0ML7xNX08OEVfRzwkr6OX4ZtIR+jl0IzQcMzIFmAQam"
"013AwN3jE+j2sdF08/AIuilZgYEAgb50bQ9gYFc3PJgBA7s748HMQNAWkU8rPPha4GHejC4x"
"DGxpQpe2NAYUNKKLAfXpon991S/gDyDYBBDwrUUJ3tUpYWMNSvCqJopdV0UUY8mzstotwFpb"
"kY7O+I72jS9M+8YVQkRcSEAgfHRB2v0DgGAkYGAk3o8AGIzMDxDILxkBLg1wf8D2vjkoGBCw"
"pXsWCuqWmQIYAjplEAjwa68ggLMAPs1S0obG35CXHAn6mjbU/9qhyU8ggFP+9dTMv6T+Yf4+"
"XPtv/DX5NIGa2QFA6v/t7Gd/pe7PANDTiv7TUgg3//VPrwBgcAbaMUhlAHYNz0x7AQB8+XDf"
"2GwUPjYHhY/PKdcRD0zKIzo0NR8dcofxzygAFXQw/mPzlI4vgPkvVOZ/YkkJCNH/0u/o5DJE"
"/Mu/k9Q+R/vK9NnsywIKXi0WPwAAIABJREFU8B6GH6kltX/eAbBa7wJYA/NfW952EjiGVwF7"
"6UuAtmNA+giQMwDIAiBe/5sMAOgxQGsK4IorAAjT44DWHgAHAOgschgDTA4AEPX/GDlQAQDL"
"AoCIPqphkDcBHu5sPwe8n9P/reiGRP9NYP6NxPyTtiP6316HLoc4A0BFRwDwK0Xn/EpAAIDN"
"RZX5+xVyuAXA1wDP+mQHTGWlmDUAgEUAgJnfUovS/5jllvwI4Ht3AHwCgHf8YKZ+6CignASe"
"qAEARvsQBvtwpT3af6hN/pEhMf21So/Y/Nfbzd/W9e9nNNgFugYANu3rIzQAcAlgHDTBCQCs"
"McBFTnsAzEbAdcY+AGsNsN4C+NAqB1ibAP3JYfe/NYlgu0PgCgDCnTb/6e1/AgARCgB+N8b/"
"2Px/j7FH/jD/exdDaU3zUjTgHzD4/wdzh9GPRiQ/FpH8BJj8RGgKTH4qonl3GP10mPx0RPPT"
"YfSzYfRzYNbzYOzztRbAxBfBxBfB1BdmxSu0MIvSgmz4XPx6Ht7PwefMhmbh/WytWRoEpuBr"
"jGUA+C2BXj+NpFePDwMA9tKrn3YCArbTy/vb6OW9LfTb3c2AgI0CAb/eWK+yANdXaQBQNwEE"
"AM7PkZXAnAV4dJabAd0BAIj4Ed3Pa1uOquJ/mVpQHfwM6v6PG9WD6uNn0eBzN2qEn0dDqAFU"
"D2qdOyX1KZuHepXNC+Wh3tCyLvVpWef6tLRTXVrSsQ4t6VCHNo8FRKzuTwdX9aMDK3oDJnrS"
"vsXdKHxBR6gDxW8dKVmCn6LmITKaRXdOudOdk5PodsQYPExHAgaGAwYABPsH48E7gK7u7UdX"
"9/QUKLi6uwvAgKGgPdQWao2HekuouZQMLsu2QUDBFi4Z1JcrcDxSmOhXm85vqgmzABD4aG2q"
"oQEBcOBdlSKXlkf0W5z2TSymNKEoVJj2jlcKH6M1GmAAIBAYEBDIR2GDc0smYHu/7LS1F5cC"
"FAQEdnOEgE1tUktToHfTlKoUwPsB6qt7ARzdKwj42n78p6FO/TfRxq8BwFr/68/p/7a6BNBJ"
"j//J6F/qtwAgBACwfWAGif53WgDAh41Gqua/PYj+w0crANg/ITcdnJIXQuQP8z/sDvOfBeNn"
"zSmsjb8oHZtfTBSxoDgAoIToxCI2/1J0allpJW64XFEWAFDWBgCRq9n0yyooWMVZgLJi/me0"
"8fMEgACAh5ZnBYpeV4Fi1leUfoB4DQJ2AKjhAAAXtyQHAPZFQLIGWO8BuGIeBTIAwJ4B0ObP"
"kb+5COiQkkMT4FvngAc4AYDeBHislzb/btr8O+ojQK3p+p6WKvrfieh/R0O6sh0AEAIACGEA"
"qIXvpya+R0cAOOdfFkZfGvD7XbIAcM4PALApN35mOSl+Y3aKW5+VolZkoFMLeAfAt//1COAn"
"AHj/D8fVKGBBNzVyURdqpwBggj0DILX+lfbavs3grVctqfm7MP9HZuRvGL902RsAwCZ8c5xr"
"ADD3ANy1TgCbi4BWGhDg4bQQyNu4BWDdHjBvAVi7/502EToAQKhTCcDq/j9omP8RFf3/dtwA"
"gFMq9e8AACr6f/X0NPWD8Q2H4U2A8U+D0c+C0c+B0c+F0c+FEc+D5sLs52dQJr8wkxIb/RKY"
"9lKY+lKY+zK8LodW5MBrdiib+vgSfGxJNqXF0EJoflYFA3Oz2DWHIUBnAiYAMG6f3QkAiAIA"
"HAMA7KdXD3ZJFuDlj4CAe8EAgAD67bYqBfx6iwFgrQKApBUyCSAAcH6BDQJ4GuARLwU6O52e"
"xk8DDEyn+e3LUw38L1PvnzB7/Aya/suNmv/bjVrhZ9EGagsQagsIao3Xlqbwey1Y/1af3/wL"
"/LNQY6gRvkYDqD5UDxBRV6sWAKImVAOqrlUN/84qn9lVCb+uqFWZf+8d4t+v5CT+5ypo1cr4"
"BTUvkI4a5U1D9XKnotGV89DwCrlpVdsS5NsXhrO2ppoyCGgoewfifGpQxNyydGR6KTo8/TvR"
"gaklEQGXAAwUp70TigMOGAyKAgaKIFIuAggoTHt0RiBsGENAHkTYuWj7gBwU3CsbICCrPRPQ"
"MT1tbpeeNrUFBLROTT7Nv1WjgY15PDCFlgUBTq8sNv+mLHVq2Pnwj9UAGNgpFQAgNZSGgnuk"
"AQCkFQDY3g/m3w+R/4CMAICMugcgM4Uh+g8fkZV28/ljRP/7xuWifeNV9C8AAOM/PL0gIv9C"
"AAAY/xwY/1zL+IuL8UcsgOkv+E5pEaJ+bqjkxsrlZUWnWSuUIleUg/ErCRAAAhgEzrBg+Cwb"
"APAlSK1YyQQwBAAA1qutgPGsjVXsAOBX09YEaAMAowQgq4BD7HcAbKuAeUPl3wUAcxPgUWX+"
"st3P2gNwqp8AgEMJ4EQ/1fzHI4N8DRAAweZ/80AH6f6/sZdHEFuo6H8Hov/tDeiKmH89AG5t"
"iKN//P0Nqoa/w5WhijD/8gIA5zY5AYAfAMCvMD5WCCpAib55KdEnNyL/nACpbBTrmYXOLMtA"
"J+cqAGD/0T5UVvvSR40AfgKADwMAcxQwC5TfzRgFfJjY/7YAwI/TVQPgI13rl2jfSO0/xutj"
"b232G/THdc3/sY+R9reM3xqt02d1pcve2P3Pkf314ckAwBRjE+BsYxPgEjsA/LjKuAZojQNa"
"a4HNa4AGDLgCAHP2/4MB4Iiu/+vo/8UJRwDg2v+rWAMAeKPfeRoE8xsL45oO85+bCsYM45/P"
"gvEvgObD/OdlsAPAAg0AizMr82ejXwnTX5ldS79fkV2BwDJDSzUELIIWZFUgYMIAZwVm4GtP"
"BABcObmVXj+LoVc8DfD4IL36eS/9/iBMQcD9EABAIP12xw8Q4AMA2EC/Xl8nzYACAElLpAzw"
"5CIA4Px8eqK3Aj5O4M2AM+lx3AwAwEw6vbEXIvcqNLJGIeqS71tq8S9l+u1h+p2+caMu+Jl0"
"hjoBijrp99avO7JSauFz20NtoTZQqxRKLfF1WuDrNYeaQo2hhl/a1cBQfageVOffjqqbjKzf"
"rw3V+kKpJt7XMFQdH6uC76kiAKQcoKDs/7pRaaiUfi0DNc6XlgaXz0PjquUlnz4cvVakUwsr"
"0vEF5ek4gODYDADBtFJ0xL0UHZwKKJgCKJhSXLIDe8cVkYwAlwd2jSgAMwUIDM2H6Do3jDYn"
"BffOTlt7AgK6Z6HArplUJqBDOgcI2NgkJW1srPYEbGycQrICAgNNUsgGQTb8jVq+MH45Ndzi"
"GzF/OwB8q9QBAgAEdVEZAAaAkF7pKKR3egqB+YdoANgxMCPtHJyZQr/Pour/w7NR+KgctJfv"
"HYzNDQDg1D+n/dn8C9BRGP/RmUXoKKf85yrjPyrm/52ITf/EolJ0cnFpmD+0tAwifzb8cqLI"
"FeVh8lqrlc6sUopcrYEAr1H4uAiGb8FA9NoK8utYvMZ6KsUxBOjVwHwrQu0DMMYAA2rbSwAW"
"AAQ31MeAGtrOAV8KsVYCN7MfBfpoAOgmsm4B3D3GI329dfTfzzYCaMsAWADAzX9Hegg8cA/B"
"zf1s/u11+r+lvp/RWAOAjv631aXLwTz/D/PfUgPGX5Uu+HP9PxkA2FQcAgBsAgD4FoTx56fE"
"jXkpYSMAYEMOgFQ2ivHIQpGL09OJOalp55iUt90cRwDza3/64BHATwDw4QCQ3ChgyztRvS/R"
"/fEw0mk6AwBTfeRhj/gfb9Ambxn9Rt3o5+1U77cif8v4rc56a7Y+WJktmz+b9o1hEMz/xkgA"
"wGjdA2AAgMMtACcA4FsAP640AMAaB1xnf3XoC9AQ8MiYEHAFAA5NgDuNKYA9LgDg6EcCwAU6"
"HbKY7iSE090L++neRXyd/9yB7kH3Dd0T/XwzkqJ3+dLGPs0l9b8ws4rwV2QzzD+HIwSYsoBg"
"qc4IOIPAXJ0FmAzo4KbD17/G0+unJwEAhwEA++n3n7kXYKdkAX67txUAsFllAW556zIAA8BK"
"VQa4vBgAoLMAF+YBADgLMJuenIXiZtKjeIAAIOBx4lyAwRJ6enEV3YtdRkfWDqZ1fZvS4FJZ"
"BAC6wui7Qd0BR71Yqd2odxr12lOLf4/VDer8rV0MCR3wNdpD7aA2UMtv3lYLqHkKpWZQU6jx"
"11rme0ONoAZQPa26UO2vlOrwr79SH6uD11pQNQBB1S8cVY3FgPCZAoQy/wM4ABDWzZ2ShlbI"
"SX79Ec0urkTHF1YQIDg2G5pRFlFxKdoPENgn5QKAwNjCql9gZCHaNbKg9Abw6OD2frkopG92"
"GHE2CuoJCOgCCOioIMCnTRrybZWaNjb7lnyb8LIggICGAB4XVIb/jTL9Zuq8MIvvC/C5Yb/W"
"SgwA/u1SyiVCAYAOAIBOqWlLl9S0rXtaBQB9AAB9M0gGIHQgZwAyAQIyAwKyAFqyAQKyU/gP"
"OZT5j8lD+yfmQ/Sfnw5NK0iHJfKH+c9mAChGEWz885XxRywsBeMvTScWl6GTi8rC/KFl5RD1"
"s/GXR4RfERF+BZi71poKMHWt1UqRa2D2FhSsUYrSr2c0DETpDIAFAAIB6ysJBEgfgDQCqpKO"
"uQfA1gTIUwAsGP9FyQY0sJcFtr8bAKQHINypCdAJADj1b10DtAGAbAHs/xYA8K8lMyAAwNE/"
"A0AnMf8b+9pBnP5voU5phzaiq9sbIvoHAASz+dehS1sR/Yv5V8f3WZnOb66E77kCVN6xBADz"
"T9xUDK9FYP6FYPwFKcE7PyVsyIPoPxfFr8+Bn2NWilqVmU4vAgDMTkVbRqbgHQAt3f6LEcBP"
"APD+H46rUcA8bmrkohrUfJdP01AFANPV+J8t+tcRvmX8T3y0yVvRvi/ZLvyZnf7WRj02fZ6n"
"t83Wawhg8705CsaP6P/GKCUbAIx/DwAs1qeATQBYYzQDrlPZAL5H8LM1HbDBqTnw/xoAYPwv"
"Thrnfy0AMHsAVAZAZvtl1I+7/m9AN6Fb0G1Dt4yP3cXn3qOkyD20sFxmyQ5wNmClAQGrtFa6"
"kgEDSzUELLRKA1wOwNdyx9c84b+EXj9PlD6A3x8fpVcPDwIAwgEAuwAAO+jF/W30290gDQA+"
"9PzmBnp2Yy39coX7AFbIOOBT6QVYBACYT0/Pz3UNAPGz6dHZefTk3FKBgKdJXvgavoCJAIre"
"6k7uDctJ1M8QwADQD+Y/IK0b9Yf6GeqLj/fRYGCqJ/6ZHhoQuqZSQGEBQhcNDJ0MtYfa4t/X"
"iqHgGzsQNNEyAaC+Nn42+zpf2QGAf93QgocU6nPrGp8r0PCV/Z+XzIGGgSqfu1FlqMJnKmNQ"
"Jd1n1KFYJlrcpCgi2eowuSqAgYqIisvREffSMMrv6MDk4rR3YjEKH1+Udo8pQrtHFaSwYfkp"
"dEhe2t4/F4w3BwX3BgT0yIIIPSMAID1tapMOAKAggBsDeTrAt1lKtTrYMnzrtYWO+mH8fGSI"
"Tw4r00+pmv/0JUI2fwGAzgwAXALQ0X8flQHY1j8j/iyZaPsgmP/QLLT7e2X+e0flhHIDZGD+"
"4/Pi+4H5T+XovzAdRuR/ZHYxOjqnBB2bVxJi8y9FxxeVoeOLy+HnAS0rD9NnVaBTbPor2fAr"
"23SG5cGqQlFr9atHJZg85FHRDgQeSlEiqxRQQYBAAEAgAJG/DQAqGY2AdgCQWwAOY4D1BQDY"
"/C/KSKABACGNBQCSKwHILoDwdsYY4HsAgM3fBgBvZwBs54B5+Q+fFOb0P98VEPNvJ81/13fj"
"3x/aVJt/Q0T+9ejy1jqiS1v4vDHMP6Aavk8AgF9FZf5+rgEg0bcIIn8AgHdBOuuVD8afB8qF"
"n2V2il6Tlc6syEynFqan47NS0ZyOMgLYXPtQCe1LHzUC+AkAPhwArFFAPrNojQJWgZoErKzv"
"b8sA8Aggb/aT6H+DTv3rKP8Jy4r0/Zxk1vy3aPO3LvwZ4t/jLn82f4YATv2z+d8c4zgFwD0A"
"DgAwBwCwQAHAfT0J8KPRB/BANwOaAGCVBWyrgp0BwEUT4AcDwGGnEkAyAPDKBAA9/vfnZShJ"
"xv3ozXWY/HUNA9CbG+pjb/R7BoQ3t+ivN3fpx6unaGpq1QjI/QBWJmA1jH6N1moXWqVBwIIA"
"s0dgQRY1NXDIax69/vW86gN4EkGvHh0GAHAZYDcAYCcAIEQBwJ3NNgDgLMAvVz3olyTuBVgG"
"AFgiAPD0/EJHAIDxPzo7QwDgURwAIG4O3i+gx4mAhfMr6OllfI0rAIGrfvTL9a20bVo3SfF3"
"+VaZen+GAA0CA9LYxR/v60IWGFgwYMrKHHTTgMAQ0A4aWaEA+QxrRKe8h9LxdQPoQexSehA9"
"h+5HzqT7p9wpac9I2r+4Ke1b0JA8OlegRY1LU+8S2ah2+v+ViL+ONvjGBjywmuqMQwsNGFYm"
"ob6GAgaE2rqEwEBQScMAZwiqpf+M+pXJTmETKsLsqtlA4CBA4ABAYP+UErR3QjHawxAwspAN"
"ArgvgDMBQb2yUkCXzJIF8GuXnnzbphUI8GMIaJUKUlsDNzEQtExJm5orsflvaq2MX2SZP4w/"
"sKNSQIfUCgA6pYH5p6WtXdPSth7paVsvFf2z+YcMyEQh/TNT6KAsAIBstHt4dtqDyD98ZC6J"
"/PeNy0v7xuej/QCAg+4F6dA0BgBl/kfnwvwl8i9NxxeWoRNLy0MVlOkvZ9OvDFVBxF8FZl4V"
"Rl6VIj2qifh91NpqSp7VIX6tIiBwZi1DAYNAJYpeW1EU5VFRQ0B5ivFQGYEYPgUNcSkgDhDA"
"TYBxMg1QRQDgrGwI5GuANR2vAepzwBf5BHVwg/cCgLxCNgAIAwDoewDJAYBVAnAAADZ55x4A"
"fQxIACDCBQDsbavS/7sAADuaKADAn/UyQ0xQbZg/q6YAwDn/qvheK8PoK4r5J/qVw/dtLwEk"
"MgD4AgB8AAAbC1GCVwEYPwDAMzfFrc1JMWuyU9RKrv9nopPz09HxmaloUovP/Nl/tA9ZI4AZ"
"3D5iBPATAHwYALgaBSwKVYIaDe9TdDbdHwdDnaYW/3D6//F6Xe/X0T+bPpv/k81a/nqxj34v"
"Y35Ww1+wfZuetVTnqTZWPukr5j8SZq/r/jbzH+cIALYeAAsAeB/AIn0OWJcBzGZAKQN4GgCg"
"ywLWqmABAKsEsNlpDHCrAQDGIiBrE6AAwF77+t+3AOCEAQCRLgBAlwFs630v6kU/V/QOAHMP"
"wBU7HAgI3AQAMATco0M+S8gd5rYgozLzldr4PXK60VpDHoYsMODPtbIBAgPQ4qxuNCeTGx31"
"WUx//nZJ9QHIOOAR+v3hAQDAHvpdAGAHAGAr5E/Pb/sBALzpOZcBrq6F+a+WUsDTy4CAC4s1"
"BFgAMMsOAPGcCZiF96zZgACAQOICepKwmJ5cWE1PkxgofKEtFLZ4gNT4O2sI4KjfBID+71A/"
"DQG9U7vIEGgxADBg9MybgqKCptGji3708PxaehC3lO5HzaW7p6fRneMT8bAdjQfvCLp5YAge"
"ygPoenhfurqrh0wIXNvdCw/rPnR0RQOaXbM4tc7zrRh6A23+zfDnb/2NyjCwWhjlh2YGJDS0"
"sgsMA1+qDAHDQNXPFRCUBwy0LpyB1ncvRacZBBZWpGNzytPBGWXowNTSAgJ7OBswqjCFjShA"
"od+rTMC2ntkpsGsWCuicifzaZ5BFQbwtkLWpdRqYu7oiyPsCRAACP0T8fu2+hekr+YtUxC/m"
"3ym1pPyD+Bwxq1Na2tKVlY6CAQAhvWH+fWD+iPxDBmamHTD/sO+z0q6hMP9hOQEAuWjvGET/"
"Y/LS/nEw/wn56cCkAvg+CtOhGUXpyMzidGz2d3RsbhmKWFgWUX9ZbfyAoBWW6cPw18Do19SA"
"kdeAodekaM+aMHclfh/tWUu9rqul5FlDC0Cwtqoo2rOyiLMEUTozECNSIBAjpYCKEv3zZch4"
"GwBUUwIEJHIWwM/xINDFLfWg+hoE6rsEAFszIJcCZDqghYaA92cA3gaAXk4AoLIAXBK4e0Kf"
"AI7o+Q4AaCYAcCWkASUF89lsRP5BiPwDWTXogkT/AIBNleicTwV8z8kAgE8xSvAuTAkbEP2v"
"BwCsy0txHrkpdk1Oil6ZDdF/FopcCgCYpwCgVel/zmb/0T5U1O1vjAB+AoAPBwBzFDA7VBiq"
"ANWvXDr1MAUA7ioDIADgpSN/q8bvp40/0JBp+pasdbpW1G9E1GzCN4dBI2D0o3TTn2n8rAnJ"
"AMBsBQB3F+J1kS4DLHfKBFilgLUGAHjaVwW/FwCsTYBaAgChxhrgcL0F0CgDCABYY4DvAwDr"
"xO95YxFQktMmwKsaAEwIuA7zZwi4TS+eJdE4mMbM9KoUsAoQsCa7Mn1PaJ2Wp6G1BgisMkoD"
"Vo/AAnydbe6D6M1vSdIHwNMKvz88pgBAygBhCgBkGiBQAcCtjQIAv15ZS8+urJYswNPLy2H+"
"Kgvwy/l5yQMAlwTw8Ydxs+nh2Xl4zyOEywwI2CSZgJE1SlC7FMqo+6RWxj8wrSMADEjzdlag"
"n84EuAIAS911OWDfsu/p0eUAepCwjn6KXUZ3EfHfPjYJD8pRdOPgUBh+f7oKo78a1hUP7E4y"
"Cng5hLcG4iEe0hzvW+PjHQECvfHAHkj7FtSnKTWKSaqfjZ3LCVZpoYUGAlYrLQsKrNJDIycY"
"qKWbC6tqEGiQNzVAgBfeVKfjCyrT4Vnl6YB7GckI7BlfjHb/UIjChuenHUNUT8CWHtkosEsW"
"2tw5o4IAXhbUTi0Lkq2B7dLIDQE+JOSvtVnL3xBH+3x6WMy/Mxu/Mv8gif7TyWXCbT1g/r0y"
"AgAy0fYBmWk7R/6DswEAstOu4TloDyL/8B9y076xHP3no30w//0TCgBgCtNB9yJ0eBqi/1kl"
"KWJuKYqYD/NfVI5OLKlAJ5dVwvcL41+JCH8VtAYm7lETqgXzrk2xnnUodl0dGL1S7Pq6MG28"
"h+JswuetZxioic+vLtmBWMkGVFUbG6VEYL/jEKOzADYAWF9ZQQADgHdVmxI0BJzfbN8IeDGo"
"rjo3DQhgSUnABIDt6iplEmcCLADYYSwD+ugegF5GE6AFAGoNMH9cfV4PmRxQDYAdVfofAMDj"
"f9fC8O/f3lii/6St9RQAsPkH1KQL/lz7h/lvroIIvyJMHgDgWw7fMwDAr4wAQKIvAMC3OMy/"
"KJ31KqzNPz+i/7ww/9wUszqHAoDlmen04kx0Yg4AYEYqKpj+H8Pc1AhgBe1H2d2cRgA/AcB/"
"CQBT3x4FTOPmchQQRvzjFNUDIA2AG7T5c+3fT5n9U5jl0y26o99q8tMd/k+3Go1+JgBo8+fe"
"gFsc+VvR/2iY/Fhl+rdM459kbAKcrksAxlXAuwtUL8CPVjOglQkwAcBqCvRwBACeBnBZAjAB"
"wPkWgBMA2DYBWlmAY+8AgFg7APxxVgNAogEAOgtgmf9/rhjmbwHANdFfb27oLMBdWtuzmZQC"
"eDqAAWBtDmX6653kDANrXWQEWAwS/j90pzcvrwAAEgAAVhngEABgn5QBXkgWAABwLwgAwGUA"
"XwCAlw0Anl1hAFhBTy8ulSzAL+fnAwDm6BIATD9hpnrlHgDJAsyULMDDs1Y5YCk94nLABU98"
"HW96ejWADqwYImOA3NzHUTv3AQxKa4cASwPTvg0AyWUArCxA99SqYfDptR0S/T84u5run5lD"
"tyPGw/hH4gE5hK7u7S3LgZJ2dtBLgZrKzYALgXURFeFBzw99af5qRBe3taLLAIHru3vggT2E"
"YjZ3o36lc4mR19dRPkf7LTUAtNNqq18tIGBYaKp7CSQzoMsEtb5UIFD5MzV+2LpIBto1qQqd"
"XFqNIuZVooOzytK+KSUpfEJRChtRkHYOzUc7BuehkD48IphVIMC/I28LVD0BMibYMR35t1cZ"
"Af/2CgSU4afG56WmgPZaiPRZbPZBHO13SUdbOvP7dHKOOKhretrana8TIvLvzeafhbYPzEY7"
"B2XHnyMH7R6RE8pFe0Yg8v8hj0T/+8bmp30TC9K+yYXowKQidMi9GB2eWZKOzilNEQu0+S+F"
"8S+vTKdWVqXTq6tT5GpE+Gsgj9oUA9OP8axLMevrwaDrU9yGBhTr1YDioHi8j9/YkOK8+T3/"
"Xj281sXvQwwCAgE1KGZtda1q6pYDn3bWEBDLmQAPvK6tZM8AWFkA2QhYTU0EcCkAUlmA2rIX"
"QP5+BNoBQGUB3gMAoS3eXgSk9/8zANzi5j3b7H/3d/QAvAMADtknAMT8w9tIA+DVnfj3hzAA"
"cPRfF+aPv9P+MH/ec7C5Gp33g/lv4u8VALCxvABAAkMAA4BvKUBBSUrYWAzmzwBQSAGAZ36K"
"WwsAWJ0L5p+DopZno8glXP/PSMdnp6UIAICb6xHANG4fMQL4CQA+DgB4tIJnLM1RwNpQm4eJ"
"A2/Tj5PVIiDJAHjbu/slxb9Fm7+Z3rdk1vm3vQ0AUvcfqQDg1giV+r+N6P+Ole6fqK4A3tGS"
"EUANALen2/sAeGzwrt4KeN9aC2ytBl5p9AKYIGBeCzQnAVz1ALwDAAQCwtUtgN/2G6uAuRHQ"
"2AToCgBexWsASHACAGsVcJJeB3xVmb4tE2ACgJUFuEv71s2jiSnVmOCKrMrY2fC9cjnKhAAT"
"BpwzArxTIGhcT3rz4hoAIJFe67XAAgAP90kZQAHAdgUAd94FAMukGfAXbgTk1cAJgACYPo8E"
"MgxID4A0AqoywKOzc6UM8PjsYnp0bjk9ueCBf349PbnCWYBt1ORfauSPI/b+2uwtCDDl3Bfg"
"bP69DfXU9f/p9Srg3xNCDxO96aeYpXT3lLtE/tf3IfLf05eu7OqG6L49Htgw9+CmdHFLQxh+"
"fUrkk8E8AiY14OqIkmrKAqBLQY1lSVDSjk6SEbi+fwgFjKhJddL+k+p8qWr/zhDQ1gkG2hhl"
"gqYp7DBgTSBYY4jVPofwd2BqncJ0alUtyQYcmF6G9k4sQeFjitghYGBumHIOCuwGCOAdAZ0y"
"KRDomEHENwT8O6RDxK8yAnxW2L8D3ndMKxG+iI2fDb9zOkn1swLxz23pxspAW3tCOvIPReS/"
"cwDM/3s2/5y0C9rvqCtAAAAgAElEQVTD5j8qN4WPzoM/W14KZ/MfXwAqRPsnFqEDU4vRoekl"
"6MicUnR0fhmKWFSeTiyuSCeXV0HkD/NfaZl/bYqG+UdzxA/Tj13Ppt8QRtxYFKd11qeJKN6H"
"3+P3fBgGFAjEbaijIGB9LQUBntUlIxDrCQjwqKqOOTEAaPOP9awMAKhsBwCdBYjfWFUBwEaV"
"BTgnDYG1pB/ggmQC+DBQPZEaD2wANaTLMgngBABmD4AzABxQWwAVAOjxP2cAYJN/HwDwtkDO"
"IuBr3uSvHc7Rf2tV/+djRSGNKCkY0X9QXYn+xfzxd/u8H9f+OfqvjO+1ggIAHwCAT1lAAKL/"
"jaUQ+ZeksxvY/IvA/AEA6wAAawEAHnkoZpUCgDNLsyL6z0wnFwAAZqWlnWO/5RHANtp/zBHA"
"1NqnPgHA/zEAmKOA1lngUm62UcC+l+j+ZHUK2AIAifxhlE+DXDT1WfPy25VRWu8dUv8hylTv"
"ILq/NVSbP0DgNkf/49TH70zSxj8V5g7dmaLe35nmAgDm4L3eCnjfaga09gJoCHiw2gUAGE2A"
"fwsAzH0AFgAccAKACCcAOGMAgKsMwPl3AIClaxoArusMAAPAHUo8HExjvlabAQUAssPsYfgb"
"nGQCgHNmwMoKMAjwRIFnm4oAgOv05/ML0gfwxxOzDyDcCQD8NQBseCcAPD43T2cBEOUnzBbZ"
"AIDf4+M8EfA4caHOACynxxfW0OPL6+mXKz5SBuhaIie1+UpNBXBkz+Y/BBpsyMwKOEf/vV0A"
"QC/dA+BeVwHAz4le9GP0ArpzkgFgBB7Ag+jqrt5QZzyoEfnLCuAGtrW/vAAmkVO/PlVF53wA"
"ApsQAQIMZEXwVq7vtsEDviPFb2pABxfWpub504h5N9BlAQsCTABopwGgjVEm4IxAC91P0EyX"
"CCQzAKCozaWBzwAV+No7J1aCcVamIzPK0L5JgIBxnAkoZIOAYEBAUPesqiegC0Cgc0ZZGBTY"
"GRCgNwf68zEhMf90oqAuWmz6XbTpd81AWxDts/FzxM9nibf1ySzXCXf0yUI7+2WjsAHZKWxI"
"Dto1PBftHgnjR9QvGp1PzH8va3xB2j+hMO2fVBQAUJwOzeDovwwdm18O0T/Mfwki/+Vs/jVg"
"/nUoem09il4H01/XEFF/I0T6bPZs8s0o3rcZnd3Ugs76tdTC+80t8fHmlLCpKX4Pn7exEQwb"
"sMAQ4KUhwFNBQOy6GgoCJBOgIMACgDgGgHU8AVAFYgCoIrcB4r2riqQMAAhIFBisJRAgmQB/"
"bgisK1IAUF8A4FIwZwGaOACA8zVAEwD4BgCn/m0AcFSd/+WlPqq239tpD4AGgFPqDLD8nnx+"
"d7p9oLMGgPYAgDb4d7VS9X9eVQwwkfQ/9zBwFoPNfxOi/01c+4f5GwAg5i8qDfP/jhI2lJDo"
"P359EYpf5xoAIpdkRfTPDYAAgJlpacuIb8wRwFJu9jPAHzUC+AkAPh4AzFHAkm56FPDI1rYH"
"1D0ACwA22vf3S3qfDZG13X4ml83xaajx3oIAq+4fosz95mAY/zCVBbg9yh7935mozR+mf9dd"
"A8BU1wDAvQACAHNUJuC+7gWwgYBzJsDYDeASAMweAGcA0K/W9+owDcAAsM/pGqCGAD4GZFsF"
"bOwCEAAwswDnNABcNADgimMGwAYB151KALfpalQ4jYYpzoHprcgC8wYAeOV8GwCsLEBy2QGB"
"AS4HZFflhDcvbkoj4J/P4umPp6fpj8cRahzwwV56IX0Aah/AWwBw1cOxBHBxkR0Azs2lpwnc"
"7KcgwKr9uwKAJwIA+DqXPOmXpI3SDNivfCFq9ZXuA7AAIJ0hAwKcAcA0fOdMAI8ETq5Tjp4k"
"bcOfhQFgIQBgCt04NFzV/bnRb2cnRGstEdk3xEOxnjzU2eQTfWsoAOB68AYtXu/rW0N+X0Ah"
"sCFMi80LUaZXXTrtUZ+GVcovEGCVA1pok2/nlAVoa0BAa2vZkX7fwmog1KOJvJyoOjcMpsR/"
"1x6l6fgShoCytG9ySWkMDBsOCBiSl0L654ZJ55CegKBuWSiwe2a9OjgToECtDw7slF4yAgFd"
"lAJZXdNLij+oqzJ9FfFnpK3dM8H8M1NwH2X8O/plpVBO+w/W5j+M0/4w/1F5RHtg/nvG5Kfw"
"MYj8xxWU6J/XHh+YCACYVpwOz/yOjvIipIXlYf6VKHJpVTqzoiZFralDUfjZRcP4Y2H4cTD1"
"OF+Y+ybIrxUl+LeB2lJiYDtKDOpA5wLb4z0U0EYg4Ozm5vi8ZgoCfAAOGxtQHJcFvFRfQByX"
"A9azAAG2ckBVFf2vq6wBQGs9tMH+3zzeeu9dVf19AAQmCgjWUn8PAvH3JRAAwOOBW1QWQBYE"
"bWssmYCk7U1dA4DVA/AhAGDrAdCbAK1zwKf6ChRYu//l+p8GgBt8apijfwaAMG4AbPzBAJDg"
"DQDYWBZ/38tApWD8iP69NACsAwB4FoQUAMSuAQCsBACsyE6Ri7Mi+s9EJ+ZloAgAwNKeXx9w"
"s48AlnRzHAH8BAD/xwBg7gIwRwGLu6kRjKZ7NjXfIfcAJAOwRs38PzXMXyL9EHtULKYPU/xl"
"l361IMAAgHuzYfxs/kNg5BYA/OAEAFNcA8BdbfyuAEBWAy9QFwItCLBlAnQ/gGQB1r49BugS"
"AMweAEPy/ULPQhUEWH0AvxkngbkZUK4BHrNfA/woALjk1APgDABWBuC6DQD+evMjjYIpzobR"
"rcgMAICJb4CZe7vIAlggkNzHLQBYnBEA8PImICCJ/vyVASASAHBcZQEAAC9/2qUbAQ0A4IVA"
"zgDATYA2AJhPvzAEJMylx9z1H28BwCwFAPi4HQCWGQCwXgDgyTUAQLkCsiq48zsAwIIAzgKY"
"JQBnCLDec0MhlwCm1FMA8HOCzgBEAAAODKVr4f3UHYCd7elSSDMBgAub8TBHhHeezV+6wPHg"
"R0QoWq+UIEbAqWBEl141ZJmPmBkgIM67HoyoBQ2rUkBM2+wJaOMEAc4lgTZGpsBsILQyAnXx"
"86nBI4SfudG8BkWlL+DgrPKAgO9oz1jdE8A7AgYCAvrkoBBAwJae1v0AfU2Q1RkQAINnsw/s"
"wZF+Rvw+fs3vEe1vYePvhYi/J9QLUX/fLHKRMLQfC8Y/EBqcg8KGIvIflpv2/JDXZvx7YPzh"
"Ywsi+tfmP6kwBPOfUowOTi9JR2Zx4x9H//h5LatGp1fUojOrEPl7NqCYDU3F9M9u1mYf1JHO"
"belMF7Z1hbrRhZAedBG6sKOnvL+wrTtdCO5M5wAEiQFt8c+0prO+DAJNKd63EUCgAaL3etIc"
"GLuulr0ngM86eyoIkPPOnlUEAuI5A2BBAP/31sZvwoDcd8B/e4ZDGQ3kvyt8F0IfCpJsADcE"
"CgQ0cgAAhxKA8x4AhxJA17dLALzfX24B9JZ1v+oaoAIBhgIBhiOqcfAtANiFf+fOpg4AcInv"
"GnBJSwPAOd8qrgHAGwDgDQBYXxI/n+Ji/nGehfFzK6ii/zX5EP3ngfnnpKjl2en0IgDAfADA"
"XAUA8zp/uYN9R/tPcTfHEcAP3gHwCQA+HACcRwFzupmjgL2LzVEHgeZqAPDVAGBG/dvtnfE2"
"84cpPtutf20AwP1ZiPwHagD4HkY+/B0AMNkOAlYJ4K6eABDztwAAQHFntnEhcL7aDSBTAYsN"
"ALBKASYAbHBcCSx3ASwA0BBgNTVakowHA8AOBQG/6jKAAMA++0jgWwDgvAvAAgA9CfD6nIIA"
"GwAkfQAA3NC6LeOAI/DAnwEjW55Zmbi3BgBXsgzf1cf4n13DAJDJjZ7cjdcAkEB//HIGEHBC"
"AIC3Ar78abdrALi2zgCA5Q4A8EQAYL4BALNkIZAAAL9PmOMEACtsPQBPk3zol2tB1Kd8AWr5"
"b7UamE18gDZ8ZwAY8p4sQG8nAOgG/VClqEMJ4LYGgKt7+lCSdP23xQO7KV0MbAAAqI2HoYr8"
"bea/jqPESnitiAdhJflYwoaqMIlqdGxOaRllYwg4hag80qOm1KE5Um2eP60tE8Am3soZAlIa"
"MrICbQ0QsDIEnEVorJsFa36hIGBBw2J0cnk1mGp52juxpOwJ2DmyIO3g8cCBeWh735wUDMOW"
"1cG9s8r64C09AAI9MgsMBMHgt0BbWT3UazB+bytMP7inivqD8c9t7wMN0KY/OCei/5y0awg0"
"PA/tHmkZf0ExfmX+MP6JbPxF6CAb/1Rl/odh/sfnlaNjCyrhZ1WdolbXod3u1ch3cHma3Cgf"
"uTctRN2Kp6We36Wj9jm+oIa8UplLH1pNoWZQ19z/piHls9DEBgVpdU8A0LxmAIEugAWAgGQK"
"GCKawcwaU5wPZwLqwtQ5C6BLAWtVKSDGEwDAWltFJgU4CxALwOP/1rHmRIDVFOil4E9BQHUF"
"AZsAAf74OxNQWxpF1clgPR7IABDcUEoBV7Y3cZwC0HsArrFJs6xSgJ4CsMzcWgUs5q8BQPUC"
"WP0AfWT0Tz5PLgd2odt8VVDq//i6Ev3rBkAGAPx5knj+3wQA36oKAHw1AHgDADaUg/GXxfdd"
"BvoOxl8Chl8MP6vCFOsBAPAoCPNH9L8qL6L/3BS1LCedWQoAWJjFDgAz0lLL0v+c4+Y4ApjT"
"7W+MAH4CgI8DgORGARt0aJp7gloGNFttAuTmP47+HUzfjP53JQ8ADxCB3xwADVLRvwDACJ3+"
"dwaAyS5kAsBMNQVgA4BZRkPgXPupYJkMWOrUC2ACgJkF0AeC5CywBQAmCATZlxnZAAD6NUzv"
"A7B2AgACfjuYPAD87jQK6LAPgAHgglECSDIAIMkRAhx6ABgA7tPkPF/RTJjYikwqA8AAsDG3"
"G/m40EZDzgDAZQAPAMBSfJ1bZw/Sm9+u0J/PGQD4MNBJ+uPRMSkDvHwQTi/vhwIAttFzGQXc"
"lDwASA/AAnp6fj49TpivSgAWAMTNeBsAzi6U9cCPBQBUBuAp9wBc20rz2taWI0B8A6CnKwB4"
"RxagjxMIWGUACwDYTJ8KAGxQAHDSAIBQrv+3UWeAA+sj+q8tdV5J+0sUWEkBgGdFpbUQQCDB"
"qwpFzClFh9wR1c5QaW2BgKW8iKamNKRFejamhjlSSCagkYYASfVrw2+f0lEMAs4A0E7vFrDK"
"A010o2AtPSmwsFFxOrmMIaAs7Z2kywGjClHo9/kodJBaFrS9P58Tzk7bAALBfbOJqbO583XB"
"4H5ZJcoP7g2zl0ifBcPH7+1A1L+jf3bagYh/x4AcyvS/z027hrHy0K5RMP4fEPGPURE/ry7e"
"i4j/wOSitJ8b/txL4GdTUtL+R2aXJe9eRcm9Xi7qWzYTtcj3DVX5pxvVgGrD6Ov+P3Ulsunn"
"gJ0v9NEoqD2ApwNPiGh1YuHjHfn38XktP1dw0CH7v2h+2+8o2qetlAYSNreis1wSkCmBejD0"
"OhTLPQHraspEgPQCeFSDuAxQVcoBcZ4MAQr2WPEWBKzXALC+sq0UcNabe0MYAmrqpsBasiNA"
"TQjAXIOsXgAFAEncfS8QwNv4YMjSCNhWQcAeLgfobIA+CayOAQEADne3HQOyXwNkCLC/MiDI"
"5x/k88H4Z231/7Z0HdH/VQaAUIYQbgBsYAcAqwSgASDRpxLABn/fLQBg8/cqDRkAAPOPXVOI"
"YlcXgBD9r8gL889FZxbnoMjF2ejUAgDAPB4BVABQo8A/J7DvuP2XI4CfAOADfkBTHScBrFFA"
"PrvIoxfl3NQoRnu1C2CmugQoJQALAHbqhTjOqX+tZ7vsAMD792/2helz9A8AuM3mPzQZANBN"
"gDL65zwFMO1tAGDjvz3TPhYomQB9Lvj+fPuCIM4CPLD6AKxFQDoLIDcBLADw182AAS4AIMgF"
"AOxUWYDnAJ7n+jywAMBh1QfgAACR6iKgZAGgP/RaYBMArEkAGwAkOe0FSC4DcJ829GhKM1PZ"
"SwAMAGz2voY2afkaIOAKALiJkDMJtxIOAwCuAgDOAQBiAACnAAARdgD4MSxZAFB7AJa9BQBP"
"E+cJADxJmKX2AAgAzLQDQPxcGwCoKQBHAFjZvYlc/7MmAUwA+F4ruV6AvskAQG9dAhAAuLaD"
"HpoAsB8AsLuPzPYnbW8tnf0X/etK+l9S/146EvRSxi+z4npjHOvUotK0fxJMbnIxOjK1hFz7"
"OwYIOLGAl9lUoei1iDgBAQEjq8lsvwUBza3JAG36HQy1T+miRGB8Hn8fLVM4QgBfO1zdsRSd"
"AATw9sBwvScgjDcGDuXbAQwBuRHB54Sh56RtfXNQCMw8BCCwDebOkvcw+239siHah9j0B8D8"
"B7D556BQRP6hg3JRGMw/jI0fUT9H/ru1+YdP4Dp/EdrP0b57cTqkU/1BQ4rRyKpZqTHMvgK+"
"/7L/cKPyMPzK/wPjh+HX+VxdeGzyhboAySWgdvi+OqZQB6O66lXR3aEePCKq10bza3f+PV4g"
"hc/vgH+uNX8NfL0eRVLTgfnN6UJwR0pkCPBtSnEMAV71FABIU6DuA1jDuwEQ/YsYBCqLYjTs"
"SVOgBQL6VLCCQqspsLqCAG4W1ZsCzwkEcCmAswANVClgm069CwQ0UwCwE8a8qzX+DnKNvrVA"
"AMPAjb0qE3CbjZzPAVvXAI8aAADd4aifl/5E9FCnf/l88MFOolsc/Uv6v42O/pur6D8EMII/"
"jxoBdOwBsAHAxncDAEf/MasLUcyqAoj881H0sjx0ZkkuilwIAFgIAJjvCADsN9p3ymkfyub2"
"N0YAPwHAxwOAOQpYACrjpkcBnycNeyQXAfkcsJQAgnUTXJgdAOR9MgDwEBH2rX4AgH7K/Dn9"
"/14A0LP/DmWAqckAAHR7hn03gPUx2RI4T5cC9JpgzkK8BQDeyQCAv74O+A4AYBCyvv/n1mbA"
"cDURIGUAZwA4/W4AeG0CgJEFkM2ASe8pAdwFADShGd/qDAAM3NvJ9Fl+Ws4QwDIBgP95biY8"
"fziY3ry8Rm8sAHhiNQIesgHACxMAeB3wNU8NAHoToJj/QrUHQAPAEwcAsEoAs9/OAJxboZYB"
"XfLUJYCttLxrIzGCdi4AYKghEwKcswCuygD8tTjifnp1OwDAi36MAgAcn4CH7Pd4+PbWANBc"
"Ijap/3ODFz/cvVQ0KILhx6wqr1WOolaUpYMTC0NFaB90cFJROjSthGQCji0ABCysIPv9GQLi"
"/ZrQ8CoFpIGPrxJyU581FdAh5dtq5yTnLEEbDQFN9f4AGRdM9Q/aM606nVhanQ4BAvZOKUV7"
"eDpArw3eydmAwbkpdGBuGHpOCu2Xk0L6aRDQ2gEw2A6J6feH4Q9Upr9zMMSv3+ehnUNh/sPy"
"0p4R+WgPR//jCtHeCUXkcBHX+A/D+Nd1LkBdS6alKvi5l4HZl4XK/486q8ywUh0mXZvPOvOJ"
"5y/VNUdu/mzNRv6NygCx8Yvh42v0hvpAfVPb1Y9f+eMaCBgGuuLn0elrlTVol8GNTq5vTxdC"
"OgsExG9qSvEyHlgXIMAAUFMBAJv+mioAARbM36OSNAXGrK0oECB3ASwQWF/JWBRURSBASgEb"
"1cVAuRfgp0cE/WsLAFxgAJAFQY1sAJAUwrV4VQbgLMDVXdwPgFdO1dtWA3eQLX4MAe8EAL4S"
"GKFq/7cYGPifOdiRbvHX4MwCf91QPYLI0T+v/8WfhxsALwXUfrsHgNP/DAGuAMCzBP4/KCbR"
"f8yqghS9Ij9FL0f0vwQAsCinAMDpBQCAeVnoxNyMAgDhk9I8crOPAJbRPvS3RgA/AcDHAUBy"
"o4A1oVZ3ovtdknXAPy9TC4AkAxCaDACEOQLAQy9l/rf6a70HAGQM0NoDMEk3Ak51agKc6dgH"
"cNdqCrQaA6erj921sgALYP56S6CUAdYYewD+BgBYPQCSBdmuMwEWAFgNgQYASBmA9wGYC4Gi"
"lN4FAFIGuOwIAG/MDMC1twBgz6rJNA0PuuUAgHXZlKm/DwBMCLABQC4FACsBAKe3esoo4Jvn"
"5zUARNIfvA/g4WEAwF59EyCYnt8J0ADgRc+u8UGg1XIW+OllawJggWr+kzFAEwAUBDyM1zsA"
"4rkJkMsEizQALBcAeAwAeCJTAIG0rEtDavQvZYzd9C6AQQYADNOyMgHJlQH6OJUE+Gux4T69"
"GkIPE9bT/aj5AIDxGgB4818HeSjzWJ+k/31qSH0/Yb0aB+MsQAwAIHp1OUQ8EMz/yFSYnm5y"
"OzgBIDCBIQAGCAg4isj32LxydGpRRZlrl8mA1Q2oTuZ/Uy18fw2+UrP/bd6RBXAlEwraGs2B"
"DfWEQLP8qShqQ0M6uayGQEA49wSMLkq7RhVSJ4WH50cEnxemDiMHCLCx7xicE1ImHzoIYKDr"
"+zsBC2FD8DlDc9uMf+fQvLRreF65SLhndAGp8+/l2X73YrRjZFEaWikLVcSfrdQ/7KbPi4y4"
"TMEZEG5e5O+/Doy//r/V2ebGDERfqtPOfOaZv89OxoEoNn42+wHQQP3aX78O0Lcj+Pf7GTDQ"
"LYUqFQyrkouu7OpN57d2RHTeQo8HGqOBPBHgoUoAMRYEeFRWUwEe6r+5VfJREKCksgEaALyr"
"qb8rPtX1vQDdGOhv7QewA4A0AwoENJUswBVeDxzWEn9GzgS0dASAvQwAHWWZzx1bQ2CP9wKA"
"/DMHOtBNqf23RvSPr8uriBk8tnH0jz9LYD0x/0v+tZJvAnQBAHFri8P8i0r0H70SALAcALA0"
"D0Utzu0AACfnAgDmZKTjAIAto1LyCGAr7Tv/1QjgJwD4ewDgPApYHWp+lEcBZR3wUg0AwQYA"
"hNnH4Wxd//o9nwy+3UcBwG02/wF4tbr/hyYDAGPtfQAmAPA0AC8BcmgCnG43+7cAYLrKAtzT"
"jYHWlkDuBbD1ARhXATlLYTUCJgsAesuhSwDAz+P5TqMhcL8qA1jjgG8BwBknADjrCAB/XnTs"
"A3hjbAS0bgTYpgCsmwB36dDGRTQVD8VlGRUAWOl/PwMANudRcpUFsMoAtkkAAEDkNi968zsD"
"wAUAQNw7AIDvAfjSrzf5FsAaAIA6CayOAS3UADBHnwSeJ3sAGACeJMykx4j+HQAgYZ4jAJxf"
"RY8vMAB4AwACyGtIS2rItd8UygBMAGDjH55eaaiGABMArDKABQJmRoBLAC0FAHgKYB0AYJ5s"
"AbzOALCrl54AaKLG/yT9j4e5V1U87KuohjBPtS0uemV5ikb0f3xOSdXhPraArdOdIYBT4Nzw"
"ZkFABE8GLK4kG+24H2BxizIyy1/336qZr4XOAiRn+O8CgA4p7ZMCzfQlw3r4ujMblKAz6xrQ"
"8cXV6MB0HhEsQeFjGQIKQ+qccNjQfBQ2OI8oVASTH6J+vROmL2l+mH0YzJ5NX97jn9k1PB+F"
"j1Ipf1nsM7kIebTJSw0LpKSS/1Dnjtn4K/w/1aDI0T7fOWDjr/kvVa7oXSoLDauYmxY1LU0L"
"mpahhc3L0oxGJalb8QwCAzz6yN8XQwCn/RkA2PAH8t+FNOrVthXSek1trIxOrUCgW0rVN+A/"
"sh4lbe9K5wJa01mfpqoh0LuuHguspUcBq9kyACKGAA91PMgq90jpx1MBgQMAcClgQ1W9JbA6"
"JW6qbgeAAAMAeDFQsNY2XsajmgGv7GwpEOAAALoX4Nb+jpIFuGPbCmgCAL/2UABwrLsjAOxv"
"Tzf563BmgY8QbW+SPABsruE4BuhXxQEA2Pzj1pfCz6okxa0BAKwCAKwCAKwAACzL914AWNoz"
"hTUCWN3tvxwB/AQAH/5Dcj4LzCMXud3UCEZVqOkun+ahdH+qBgBvxwyAbMPbae8HsMRTA2z+"
"rgDgtgkA5hTA6HcAwDQDAEzDfwcA8Pt7s4wswGL8uZYZ64HXqt4EhoCHG+yNgLaVwH8HAPRe"
"AGsnAAPAyyNGGUDvA3ilIUAAIO7tDIBLADAzANedSgC3ZBkQA8BkPBiXZUAUzwCQ0zHq9zMA"
"wIQAswxgQsCarG50YO1MevPyhgaAeAUAPAooJYC9qgQgABAoFwF/vaEBICk5AJhNTxJnqXsA"
"CTOcAIDLAHMEAB4lzHcCAA96CgB4ciWQjnmPpYacAUihSwB4oA/WZu8KAMxpAPM4kPOlQN4D"
"wGZ7N9aXfj63XgHAsXF0/eAQ2QGQZAEAHoznN6n6v6T/vaqoHgAPtTOeMwBRy8qK+fGM+16W"
"AQH7xqtSwOGpDAElKWIOH7kpT6dXVKPo9XUp0b8F1c70hZghd/I31VMBzil/57S/q9/rYEBA"
"G70zQE4aZ/wfOrmmMUV61KGIeZXldgBDwJ5xxRC1F7FlA3YNyw/lo51abO6WwvDrsBH4fWj3"
"8Pzy+bsR8e8Zo+f5JxelhXVyUZXM/6JiMP7v/qnOG7Pp87ljjvbZ+Fn9SmejNV1K0253vjLX"
"hM4FNqPzQc1FF7a0wGtLqDVd2NqZQqbWp87FM1KzrxQY8aloKwvQP7XTHYjU9o8xGAzWr4P0"
"7/Xik9D4eUyqVxgRdi98/faUsKkZxXurLIC1JjhmjbUVsApFcwlgTUUNAZX0euCKdgDQGYF4"
"zgLg7wbLAoCzG61bAdbVwNqyMfJCUH07AHDtXcSZgCZqNDC0hToVHKYBYLduBoR4jS9DAI/0"
"3dFHgRyaAY91fxsA+J/h3f+71eif1P4/BACMTYAMANwDcNarLGAHAOBZCt97Cfr/7L0HVJVn"
"1v59MpMy6XXSe51UjV0EkaYoYm9YsLdoYqLRqLFjRRQERZEi2LDX2AVRUUSkd8FuyiTW9Elm"
"3v3fe9/3fZ77POc5gCbvvN9an6611wECCMesc/12u3bO4vcge9E7GJT9/0MAQKRsAYS/bACA"
"bAEQAMzpeR+dAW4jdaeW1KEnbTd4BvgWANw4AOirgE/YTKuA00fVjoKvJst7AAnS53+rIwCo"
"dgAFzQuc728AAIn/+aEyPqweAKgNYG4BcAVgigsAwDg3Tc4H6C2AGRIAQo21wG8WaKZANwoA"
"6ywAgGYBtlQBAKko/AQBsg3wyxETAJyQAFBVBUBbA7Q7AmoA8LvaArgAZ3L3wyTM8CIIAFC8"
"VyAArHrVWVSIdo0AACAASURBVPitIMBqHmApQsTmiUOEF8APpfCv63QU6LgFAGw2AYAo/zsD"
"AIp/0UxHAMgLwZjOACDmACQAcBsgHAEg0gCACroHgACwbBy0QvHocr8AAMrwSORHaOJP8bE2"
"C6CqAOb7AINNAEAVgKOrJiIAxMFXxyUA7BsmAIBXAAPxBdufKwBFiZ6Y9TTllbDsOCEE2Zj9"
"Z2H2f3Dquyj8YuJ915g3eP2NIEC0A2QVYBICwBSqAtRDEW4Ix3grwAdyV4gqAGXGaiCwg9YK"
"MA/9OQCA9t/0dkF3+Tl8gVCaBn3W7C3IWREAGQu94dBsN9g3VTgG7hr7ntESGPUPrgY4xSgU"
"fRL+Ufj7jX5Trva9BXvod5vwHqwa9CYEvP4wC//7f7VBvTvESeOmfxP3C2g9seUL98CSHvUg"
"Y4kv5C33x6y7OeRg1n0iUTzmJKEAJ/kLo57lrdi0h1b2itd3huxV3aDjKw8yBNDvFSzL+oNl"
"33+IRXygQcBwVQV4VMwFdMXvc2r3UCjdRLMAHVCoA/BnwL8/TgIAHQqiQcDFsgKwuAnfCchm"
"EGhsQAACQK6sBpBHgJoDcAKAFepqoBwEpHVAuRJYZo9WcHIjzQKQQ2A7vhTIBkEMAZ3gNGXv"
"GDTFTxDgDAAqTABAw38KAHZYAUDL6gFgpbt9C4ABIK4e/s51HACAsv+syGoAgCoAs56EgT53"
"RNmcVwCfsN3ECuAtALhxANBXAV+0aauAIwfWnmHYAcfKVbitFi0A2vOn4z19NQAYpIn/B0L8"
"uQXwkYUPgA4A8giQ5RCgGQDwY+dki+CCNgzIMwCzpS/APA0AFlYBAJohUFVDgHYfBFcAoE4E"
"p6Dwp8oqAELAL9IW+FcJAQwAegtAXQVUZ4HNLQB5B8AOABi/GweBTufthwn3IgA8LioAKwkA"
"XhZCn1xFKBBQEEBBA4Q0B7Bt8lD4z8/nEABOagAgWgB0FMgAgDXWAFCiAID2/2fKsr+4Bngl"
"XwCA2gIQmwCztE2A+QgAC9gLQABAAh8EOpQwBgLuElPgfR8RL+of/d0x+9chQK8CuDoS5AAA"
"KyfDt/nLxCGgQ58hAAyHk3QDYCsBQAACQAsoWuGD2T8BgIfoA8cIIciKbgQZYXWE+FM2PPoN"
"2D36dWcIoHmAie9CypRacFBtBZBB0CIvOJHQAo5GtwSPh24Dr7tFFaDdA463AvTVP7NHgA4A"
"3WX0eFiE2hCg79cS/19JXRDAdrpHwpuyUdC+yfVQwGvDHqoEfPYu7Bz9Nov8DopP34SdKka/"
"hb+biN0s+gg8E2rBgenvw8C6T0Nd/N51MNuvT8KP/1bu5EyIv4vXPeK08WTvtyBzaXPIQ5HP"
"TvARl/zouM9CMvxpis+DJxyP9oLjS33gxFKy/UUwiEdBRhDIT26HENAdlvbzBH/8vh3uF79X"
"HwkBavjPDAKqHWCvADwmqgb0dd3we+wOI6vm3twGyEsKFLcCpDNgdkwzsQJILQAFAfTvzu0A"
"N4cqgB0A5FCgWAnUWwAKAJoZLoHUBlijQKA5R9k6xyrASWkQJCoBogpAQUd8CAJ4sO9AsFwH"
"lBAgHf/okQDgfFqwAAD8fNcVAAEA5etaQPla0wwAtwGaiiFA2gJY1gjy428SAOYYANCpwW0z"
"bI4rgC/abnIF8BYA1PBJkk8UPbF3yifavArYwsargJiN/3OOsAPmC4BbZOn/C7kGSA5/KOgX"
"+tQAAIa79gFg8VcA8HkVa4DTtWzfDAAzDE+Ar1T27wIA1ByASwDQ1gHViWMnADDPAOw0TIHs"
"ACCrAL9IW+BqAaDEAAAO7SYAv30GH89IADhrHwK8+lUBfI4vrhEocvHPigrAahTyNa86x1oZ"
"a0wQoKoBVAWIQwBYP6KrHQB+v56vAQBdBdwj7gF8uQl+PL8avj+X5BoAinUAMMTfDgA5BAEh"
"bAokbgOIVcBLCAECAOgeQAJcO7WaWwCt6SDQA2L6e7hF9k8x0kUrQD8fPFi7EaBaAEeXT2QA"
"+DqTKgBj4dS+YXByuwCA8o0IAMn+mAH5iv5/rOj9U+mfxP94VAPYJ0v/uz9F8ScI+JTW4AQE"
"cDtgnKwCTHgHUifVgrRp78OhWeQN0BiORXnyRkDhqgDoXe9lLpXTCeAAbRagsxUAuFgHJNHv"
"aQr6OMFEG/yeYW0aQO6KtnBskS+kzW4CKSENYM/kOgwBuz9/D39+goB3YOeYtzl2c7zDRkK7"
"x+Lb48VkP4HM6sFvg/sTd0IdzPgbUH8ff3YPOlKE/0963SuuF3pjxPdpiFl2K8zum6PAe8Ox"
"6GZwLNKdHRKPhDeBDIoFHnzul04cZ0Z7w3ECo6W0n+/PFr7FaztB6ZYB0PKx2yDwHvF80O/a"
"V20DmABAnwdQAEBvEywQAATh/0v75yMAbOsDhfi98xEAcvQWQIxoAZxY7K5tArgbACCrANkx"
"jfDjjcSjfSiQ3CE9nAGAPCRWymFA2ipZLasByXQ/wo+9Jsp5JqA1A0C5uhK4XcwEnNohXAJp"
"h58A4Jx9JTAYhb43nD8oQOD8QXyfIOAQfuxALwMAaAaAIMJFC8BpC0AdAzIDQFwDWf6vg793"
"LQaAEwvfNgCAhgAjtS2AsBfsAJAuAcAmVgBb2JxXAO+X+vTXG9S1WwBQwyfKvApI5xf1VcAu"
"v58b8xN8M1OYAfEhIA0A6P0LKPrneroAAL0FMLx6ALgw3gQA0g/A7APgAACyBXBRib8a/ptr"
"AIB9BkC2AL6JcdwG4E2A5fI08CqtFWAGAHni2GEGAJ+LH77QhgD3SgDYj8KfIgEgDcX/kAUA"
"6C2AQucKwL8rTACghgDPOLYAfr/AXgDj8AV33mOiBUAVgORXDLF3iNdkWEAAA4AcBFz0jA0B"
"4Dz8+0cCgAL49VqWHQB+5oNA2xAANkoASEQAiKshAJD4T+O4nDcVASCE4xKCwCXZCricN9cO"
"AOQGeOXkMrhWmQxf5q1kE5ju94sX++EW2f9IDQCsWgH6HID9GuDDEgBWTnAEgL1DEQDIBbAr"
"vjC2xhfoFlC03FsCQBNe+cuivv/ChpA+vRaLPgdn/xgIAFQJIADYzVWAN2EPDcfRPvxEBICp"
"dSBtumgD0MU7ynxJfLZO8uKyOVUBWtxnHAzqbK4CuBB/yvxJ8HuZQs0E8CDdGw9C/pqukBXb"
"EtLne0IqVQGm1od9k+pwRr9nPMW7AgYw9mLQ+3vokd6f+B7sn/w+RAS8BnVRiOui+De6Uwh/"
"MxJ9/Ll9tRjv8SYUJLeFvOXN+S4C+SAcjXCDo/Mb80rkkflu+By4Q/oCBAICAASizMXNEACo"
"SuAHJxAA8lYEQuGajlC6qS90e+8ZHgilFkmQ1goYoFUCzACggt5nA6iHhafEwp6eDHpF6zrx"
"JkB2Ah0b8uEtgBMMAJ7sBaA2AewAQKuACgKWoPBj8KNLABBDgAwAyiGQWgGrxPGoEgQBAQHk"
"w9+SobN8swYA28RmALUCCAIYAPZ05Z3+c7zf34uF/ryy+yUAwMz/Aj0qAOC5AcchwEpeAaTB"
"Q2o9mABgjY81ACQ0grzY+g4AkB39rh0AeAbAJQA8wxWAAyFP/EQ6Y3NcAXzOdpMrgLcA4MYB"
"4A75RD9is1gFPJ81pAy+mSG8AC6vFgJIokfmQOe7Y/RwAQBWWwA1AYAJzgCgtwActgB0AJip"
"lf4VAMyrGQDQOuC3+jqgDgB6C2CDHITcbOEDoNYAFQDsQ+Hfb7QBLAEgxwQANAMg1wCV+JsB"
"4N+nHQHgdwKAiwIA7hEAkPAsAgCK+JrqAMACAngwkNYB6TTw0xIAfqpgO+Bfr6kZgBQNADbB"
"jxcUAMTC9Yol2gxAuCMAFKoWwHQ7BFzKnYLiP00CgKwAkEtgvjgJTPcAaBXwiqwAXDuzla1e"
"FQBQZv/J44boU4yqAQDoQ4A6AGSsmOgEABVsA4xZpwYAhcs8xT44lf4XNYTjEXVhrxr6o+yf"
"rG8xqAWwe7SEgjHy+I06ezvhPUhFAU2bVgcBoD6k0zAgmQPF+bJDXbOn7wGPvwnxpBPA7R8w"
"AMAJBB5yLP3r4h+sRS+tCtAav+/u2eKozpFIb0ib7QYpIQ1h3+S6GO8joNTm4cC96hFDfWz/"
"ZAyEl7FNX4Bat9mg3u2i3E+lfm8p+HSu2F8Gvb9tkidmuwEo5Jj5RzXFTL8JHCbhD2sM6Qg/"
"6fOaQDoBQaS7qAJENmWfhOOLfbgNkJ3Q0g4AJZt6wWjfd6E5/p3t7hPPAQ0E0jpnf1MVQB8M"
"1AcEB8h/9640PNvDk0GvcF1HyKUZgGUtUNx9uAXgDAAq+6c1QAUBGgDENDJ8ASQAFCzztK8B"
"ivK/AAAOggAJAwQCAgLIhEdWAehYEGXnJgCgVgBd8aM2AO30q5VANvs5IIS/WgBQa4A18QHQ"
"ACA/0c0aABa5AIAF5hkAAQDrP33E1QrgI1KXbmgD4BYA3BwAKC8AWr14zWasArY/sSv4KHyN"
"ovttlLADpjbA1yTYQY4AcF4CwLl+GANkDLL2AXCYAfjUcQuAAWCCYwvA4RqgFHx6tANAiGsA"
"+Hq+sQbIWwAKANQqoAKARG0dcLWLGYA/CwCOm9YA800AcNICAE5pAIDC/5szAKz5oAPMwxe2"
"hOdE/3/NK9alf3M4VQE0APj5SgX8++dKOwD8eildrgHuNloAF9ZoALAYrp+MQgBYYAAAzwDM"
"gquFagvAAgDwbZ4FyJdHgQrCeBDwStEihIAlCADLJABsgcA7BABQD5f6/yMfF6L/qQwzAKgW"
"QHUA0IEBYBJ8W2QAwJl9H2gAECAAYIUPFCZ4yun/xjz4lzb5bRZ/FvvRovTPRjh2EBAtAbbD"
"RQDYTwDADoG1IHUanb6tB4fnNIAMqgIspkuCLaHn+y+yqFLv3F9aBKsqgMNRIG0YUJX+e5kA"
"oLcMeruHNAqiqsIU//chb3VbOBbtB4dCPSA1RFYBptZFka8jQMAeKPos/nXx8+rBeM8XoRa+"
"5NX7qxjy85Ti73efcCAk7wF6JBCgasBkr7ehKLk1AoAP9/qPRjbhU7+Hw1X234QrAEcXNGXx"
"J0g4RgAQgwAQR0OBrRAA2sgKQA+Y2KoO+JAtsGwDdNeqAANNswBK9AdrQf/uBA20UhoZ5AEV"
"XAHowAOHDAB8E0C0AHJiVRvAgIATBAAx0hCIZ0FEC0AMATbha4FqBsA1AMhKgAYAAgJEFYBm"
"AcTJ4NZ8MtiYA5AAsKsTQwBXASQA8KQ/VwGCjRbAzQDAWuc1QOUESACQF9+wegBQMwALhBPg"
"8fkIAPMQAOY+wy2A2CEPHSWdsRkrgK9JHbopD4BbAHBjT5SrVcDaNvsqYPttPN1Pq4AUVPI/"
"38kCAHoLCDhHENBfAABbAA82AYBpC+AchSsAmKwNAU7Fj5mCAEBdB7RbAZsBIFwaAcn+P60B"
"/iEA2OgIAMoKWHcC5CFAVwCQaQKAXBMAmLJ/JwA4IwHgrDMADGkPYY+KCgABQLJF/1+JfZUD"
"gbQOSADwjA3OF6ZpAJCpAQDNAJAT4GYJAElVAIBcAyycbQeAywwAUzDrnyJaAHkhGgCEwqVC"
"4QZoAEAitwCoAtBaqwAQAIx6XAj/aBkKAtQMgMr+h7kCgEcNAEj8sDUCQBKfA3YAALIB5gpA"
"Syhe4Qt5Cc14//8EAgAN/tFwnwAAVfqXIcWfT9+OUfvx8u79hPcQAmrzOuChWQQA9VEQRRUg"
"e5k3LAyqx4N0JKzN75Mngx9wvgiol/1V9q9n/WyT+4gR9N+7yo2A4PeehLzkznA8tgVm4U3h"
"wKzG7A0gIICiHuybUg/2T0MYmFIX9iIYpEyrBwk934H6f0Px/4sN3KT4U5ZPP2crKf6B8lFV"
"AAhkhjd6FXJWNMe/z4sFnjN+Ev95GAvc4UiEDgCevB6ZZQeAAAkAnRgAxreoDZ74/LS+R4h4"
"VQCgQn1skAkAEgb5yhZAB24BqAqAHQCWylXAGA979n9iiZuEADf7SqDDFgCtAboCAHzkdsDy"
"6gDA3xEAeAZAAUAHFnCCADL1YWHf30OIvBkA9BkAHQDIBpicAOn7EgQoAFgntgBKqRqxCgGA"
"PQCqBgAaAtQBgGYAshYYAJC1QAOAUAEAc3rdr68A1rb9wRXAWwBw4wBgtQr4HoY7RuvpoxtF"
"sRnQGRTwytb42AYFmwCgm4CAcxoAnMM428eoAjAADDJZAd8EAPAMAIk+gsC5KeLxvPQGOB9i"
"ugVgBQCR2kGgGGMIsMoWQHVbADoASPF3AID9FgBwpBoAKK0CAEwtAAsA2DJuAIQ9IlsALzkD"
"gC7yVfkDUAsgwQEAKiwqABoAXFyLACC3ACqWaABAMwDzpRXwHEcA4BkACQDZKP750x0rAIXz"
"4XIhbQEsEjMADACiBdD99ccg6H6xxz1cAsBoFwDgagBQNwHq+6jIlGnfPnFYIFySAHDBDgB9"
"MDvqiC/EgVCa7A/FyyUAoBDQ8F/K5Hc4q6cpfzsAjHpDZP6fCjtc+tgemgHQKgAEAQcm14L9"
"fCioLnsCpIc2YHfArLhmsCOkKdS93WZvA7QytQHME/9q2t+c9ZPo99WCBh7pa6h3Tk57WYkd"
"EDgC4CivBDaBlOmNUPAbQMpUivp2GCC/AHr/wKxG4PnEHXbxb3a3UfJvJQ2H2jxgBEEAgQEN"
"AhIo+L/yEOQm+UFWbDPIWOguKgELRP8/I0KV/j05+6fTyVkoxNkIALmJAZC/sg0UrO0IxRt7"
"wNgWtaDpX20QcI9wCAzS3QEfddwIGGwS/4ESAHrJmYj9EV3Z8rlofUcEgNaOAEBHgdgMqKm0"
"BXa3VwAocmLc7NsAubwBYKwAOgEAC76nMQ9gvxboZZ8F4BbAaj9nALAPAeoA0JEh4CzNAuyT"
"xkAk8jQQWB0A7BZ3AE7TOuAX7asEgGL8mekYUOFy6v+j+C8jyGmAv289RwCItgAAEv8ICQB0"
"DGi+AQADvHkFsLXUm/dsf3AF8BYA3BwA3GUzzgK/iPEOhpuNVgGDn58BxS0BCj0ATraQANAR"
"o6sEgO4SAoJFEACcRQA4298CAMzHgGQLgAFAbQJMcF4DdAkAtBaoVv9mGxbAVmeB+RaANAGi"
"/j+tAepHgRwAYNV/AQBOWFgBVwUApxwB4HcFARIAfv8ajqxfAqH4AhiLwr0SBXyNi0E/Ne1v"
"tgi2mwMpAECQqMzcBf/+qVKeBM5yAQDr4IdzKxEAEsQlQAcfAAkAqgIgtwBo+M8aAGYLAMjX"
"AWCJdAJcBVdPb4EP3d9hABjwsMjuSfDHPGnEjQAAbQD0UwCAYpD0EQHAcgkAn0sA6IsA0Alf"
"iNtAMQJAoQSA3BgUrzDMkD9/G0UdM/sxb9oBgEv/I1UbQEKBuog37i3eAthPE/QEAJPFfQB2"
"BpyLAIBZcVYMHZJpAU3+/jdwu0tM0LeUR4J08e+mib+a9O9lkf3rAEDv0+fTHAD57G+e2Byy"
"l7eGjEU+cHieOxyY6QapKPKpIQ15JoC2AyhSpzeE1BmNYJLvq1DvNmHhS7cLaFOhucr6HxCt"
"CiX+9HaAbAUQBNDvQUDzebM34cQyXxR4MQtA0/9HeQsAAWCByv5F/z9rqS8CCnkFIACsasOm"
"QMUbg6Fvg5fBA3+GlncLAOghDwKpTQArCFDirwCAZwAIABZ0g8pdQ6B0Y1coXN0Gcpe1RPHH"
"vzdOBwBPXgfMkXbArgAgT2X/KPzOAECPciAwydOxArDKR4q/mAGwBABTC4DE3w4A0hOAWwEE"
"AFQF0AFArQFqAHCGBwE7OR4DcgIAeQlwuQQAyv4TCHQQAGLUCqD1GqAVAOgVgM4N7SuAblJ3"
"XrQZZ4BveAXwFgDcwBMlnyx9FZB2L2kF4y2MRjaxmhEEuQ0QANwBypsDnGqNItwBowtGNwEA"
"ZwkCeuFjVQDwgXEO2MkKWAcAsw/AJA0A9JhmAQCzawAAsabyvxUArHQxBGgBADwDsPMGAEAf"
"Asy2AICymwSALxEAomEGvhAuQQBYoQDgNQEAVsY/5guBKpIkACxW9wB+PuUCAHYgAGwxAODs"
"MgSApQgA0SYACDNmABQA5FMFYCoDAEOAAgAS/zwyA1Inga0BgM6/UqanA8BnGgCMtGgBmAFA"
"rQD2k1bAJIhJw1tLAAjXAKAfvvB2dgIAevFPmfwuD/Sxy5/a//9UAoA6iDPqdekJQBUCYwtg"
"L3kBTKrFfXWeA+BtgAa8DXBsEQoNCmTAm0/xZD2VzxUAmK8E6gBgnvq3ggDVBqBKAmXroYEN"
"IG9VO8hc0hz/bk9eCUyd2RgFnyBACH/KzIaQNrMRHJrjBu4P3wYNMfv3vEscGaIthQAp/u0s"
"AKCNBgFUKWiGX9P00dtQBEUV4NgCd656HJ1P64Duovy/UHoBxJAI+0kACOTTvSVrO0HJxt4Q"
"+MYT3AJodY94TqwAQIcAXfwp+CaAHIpMieoBlXuGQ/mW7lC0pj3CVyvIwb83L94HsukoUJwX"
"PjbjWYCcWDoLLDcB7IeBmojJ/yoBwFOaAVUDAGQRXC0AiONAPAOwywIAaCOA2wC9bggAKrfJ"
"a4ByBsAlAMQ3wt+1PuQuQQCIof7/+66dACUA2GcA5BZA+qynSNSCpM40krrzvM3wALjhFcBb"
"AHDjT5arVcAGGH4YXRgACpoAlPkJADjbXgJAV3w7qGYAcHYoxgdyE8C8BaC3AD43tQAsAEAN"
"BPI1QG333yUARGnl/5oAwKrqAUCtAOrXAB2GAM0AcFCYATkBQO6fAAAXGADKj+2GEHyxXfQU"
"CvnzmPW/7AgAZtc//Vxw0iuOlsDxEgAy+CAQAUCRAABeA0xDANgLP32DAPDVVgEA51fBD2cT"
"4TqdAz5JmwBR4hiQPAV8rUgfADQA4HLuFPg2eyqKv3IENADgUsECAwBKyQlwJQLAZhje5B12"
"b1M+ACNrCAD6DIDK/p0AYERr+K54BXydNR8uHB6vAUAXKNvUForXtMQXaz/IT/CCI2H1GQC4"
"nE99fXLDG/um2P+nFgABAMbOkWIOYA8CwB4EgN3adTyqAOyTcwDcBpjTENLpSuAiDzgR7wsf"
"ub0BDW8X64AkoKoF0M1U9lcAEFwNBPSRoseDgA8JP4BpLetAbnJnOBHrD0cimkF6qAekzXKD"
"A5jtp8xswJUAqgjQlkBSv9qc/dPVPh9pVBTwgDGf0F6DgLYmGFDzADQo6I5fu3WCO6/aqSoA"
"eQEQAByTA4Bc/mcAaC4AYEVrKFhNANABSjb1gTZvPAnN7hTHgug56SV/RysAMIv/ILkFQEBE"
"z+PBxcFwat8IKN8WDEVrO0I+DQImtIDcOD9xECjOW5wHRgDIjZOVAISA7KXyMFCsAIFctgGW"
"LQANAJQTIJ8HtgKAlV5iDTDZ1w4A7MZHq4C0BUD9f80HQACAGACsFgCstgDUMSA5A3AzAJCD"
"AJCzuC7kLEEAWPK+3QegegB4TgeALlJnGtj+hBXAWwBwcwBgtQpYD8MHo9OFXW+VQb4bQKkv"
"QGUAwJk/AwBc3AKw+wCok8A3AgBzLAAgogYAkFiFD4BmBVwlAOysxgfgoDAD+vXoTQBAhWkG"
"4LQlAJwrSIOp+AIbhcKXhACwWm4CJJvc/pTIUySZ3le3APgi4HM2SEsMlxUAeRL4knEMiAHg"
"awKADRIAkuD7UwkIADHyGmCkIwAUuAaAS5YAEAmXS6LFDEBpggCAU5vggyZvQdd7xSlYyug/"
"kb1/En81AzDSYgPg5gBguB0Ayje1Q/EJwBfrFnwj/sDU2gIAJr5jrwIoF0CaAdg5igDgVXx8"
"3WgBjBEVALbNHf8On8dNoRbA1DpcATiEAHAkzA0yIz0ZAGa2qOUAACSu6kSw2ehHL/27ggC1"
"CdBdbgKQQA9u8DLkr+0BJ5a1hIyF1AbA3w3F/gBm/AemIwRQ6X9mYzg02x0+9XyZj/koq+JW"
"cjuhnTw/rMIMA6oKoACAvALWfOoG2Ym+kLXYk62QMyLE+h+L/yJPyFziLfr/y1pADv5swg5Y"
"tABKt/WDNm8+Cd53iVPBXU0+AAMeqVr8B2tVAJoDOBTbF07vH4kA0BuKNnSBghWB3AbIjffD"
"8OEQANDMAgDcBQCo3r8OANIDoEoAUMN/GgCUrtHWADcHCh8ArfxvGAF1FlsArloAVgCwn24H"
"4Ofs7nbjAJDkDADZi98XsUT4AKgWgBUAZEoAOIIAsH70Y7QC2EnqTD3bn7ACeAsAbh4A1Crg"
"0zaxilHHJlcBy7f8I0cAgE/NAMBhC6A6ADCvAeoAICGAzYCmGL1/VwBg3v//KtwCAPThv5pa"
"Aa93BoBrW6oAgH3VAMAxUwug0DQDcFIDgAoXAHBaGwS8wG2As/mpMBFfYCNR5BKfl1bArzhn"
"/0roXQUDwEsCANaN7c8nge0AcOWoCQC2wY9fbkQASIYfzq1AAFiGsRQBIBoBIMpFBSBEzgA4"
"AgBZAX9H9wDyQ3kG4FLhAgEApQQAy+wAsHRwBwcA+Ni0AjjKDADVtAAoej8qMuLPPN+HS6UI"
"ANkRCADUAviQD8VUbg9CAGiPANAaAcAfMsIa8UW/1KnviYn+iW+LWQATAOwe+Ro+vsEhvADe"
"5BO5tAlAVQBaBaQqQMq0OnwXgACApuIzo7wgO745JA5xYwCg40DKEbCbi5K/3vc3A0AvDQzY"
"EfBhcRuABPrDxq9Bycb+mGEHwrHFfnA43JOHARkAMFJmNOTBv8OhTWCY2/P28n8L5U8g2xJ6"
"dHzQAAEFAfS5LTUAINvd7EQfXnskN8CMSA0AosX6X9ZSPwMAViB8JbeFonXdEAAGQLu3ngG/"
"v4kqBvXxawIADjMB0g6Ynq/K/VPhTMooOLm9LxRv7AwFK9vw0GEu/hvkJfhCboKwBTYDQE6s"
"h3SENAGAagGYbgE4AQCfB/ZhJ0CyAy61hzQC2hBgAABXAExWwCj8bAZEh4HMAMDC39uxBUAf"
"J9vgFAEAN9wC+LMAYPYzsOrjh3NsxgpgHak7T9v+wArgLQC48SerulXAtjsWvLiNAaAEAaCi"
"lQCAH/PGtgAAIABJREFUs51NACCHAHkNcIABAPYYaswA6ABg3wLQZwA0AGDxnyiqAFUCAIr/"
"l2Ga8GN8FSFWAJ0AQJX9E03ngFcbAHBZuv/RASQVdAzIDAD2NUDlA7BPHgPSrYAPyhkAagFk"
"mIyAXAFAhRH/0SsCohXwP7+r0DcBvoYJ0g44QboBkiGQufRflfgrAFhKAPCsDdaPG2gBAGni"
"GNA3O+0A8CPfA0AAOJ2IACDWAR0BYLaYAXAAgCkOLQC+BcA2wHMx+5+HABAJl4sXw+XSpXCl"
"DAGgQgDAEgSALvh79tMAQBd+Jw8ACwAYbIKAPhjd8PuN86qDALAavsmJgovpU+Ds/o94OpwB"
"YHMHBgDKBg/PrA9pIXUgdVptzuK5CjDOAAAyA2IvAHYClJsAY4RHwJ4x4iogVwAmkZseAgA5"
"As6oJ1sA6i6AP+ye1Rwa/0WU26lf30Fm/1ZGP71NWb7ZAEiJv2oZUNZM36/Xm4+hoA6GvOQO"
"kLm0BbcB6EogrQQSAKQiAByc2Zg/NtztBWj0V3G+V10r7KSZEimTIisICJRtAPIE6FvrOQSA"
"Dijs3ggA1PMn5z+5+4+/e+YSMf2fFevHE/k5ia0gbyUCwJp2ULyhF5TvGAqd3nseWtwt4EId"
"Ber3iAEBZgCwuhMwSALAxcy5CACjEQD6IQB0hYJV7bjikJfkjyLuJwCAWgHxzeQMgAYAdBI6"
"zt0AgHhxBTA/0VP0//HRcgZAlf/ZAVCcBhY2wM2FFfD6VtIJ0AIAKHPfJW8BkAfAnm68BcAA"
"INcA+Tyw6RgQmwSlSADAryF4EF4ACgACoWJLNQBAGwA1AAA1BMgDgHQOWBkBzRUAENrrQVoB"
"bGv7E1cAbwHAzQMArVw8aLNYBVwy7ql4yGuMAOANcLIlwOm2BgDwEKDaAujtaASkAwANAZ7T"
"AeBjDQBGY3wmqgDnx9cMAOxDgAoAMPP/Uor/Vwuk8EfKUACghgD11T+9959sKv2T8G8Umf8V"
"tf+/2WgBfL/dhQ/AftMxoIPaEKACgCzNCKjQ1AKwAoAKCwCQ9wB+P2e3Ax6Pwhj+mHERkHb6"
"zaV/JfKuIh6/LgZjIX6PDZ8PsgPAb1dPOFQABABsFwBwcS38QI6Ap5MwxDrg1fKFPAh4jQYB"
"1RqgaQjwcu5USwC4XDBfAEDRIrhcshS/zzK4wgCwkQGgs6wAfPCYYf9r5QBo1QIwVwHUKmB3"
"/H4TfOrBpbI18G3eIrh4bBqcTRkJlbsGQeWOHvhC3BFK1gXC0bAmkD6rIU/tp01/H1Km1IaU"
"SWIOgK1+KTQrYHIA3EXl/08VALwpWgCfv4sAUIu/PnWatATGTPvIfHc4Hk2l75ZQtLYTuN1u"
"g+Z3i0y3kwQAPaPX1/30Pr8u/j018VezA0ESAOj7ln/xEeQmd2E/gKMMAB58JfDATAEBCgCG"
"NTYAoKUs/9svFT5kHCzqbAKANhIAaFWQNgG2TPDkif7sBBT7aE84Ft0UMmj1D8X/2GJvmf37"
"IgD4il58UitR/l/TFUo39YP1k1pCwIsP8gBgBwkA9HtST7+fBQCYxZ8dAR81DgJdzNAAYEM3"
"cRVwRSDk0wGixBYMAHkJPs4AENfUDgDG7r8s+2OGzxk/nY5OFCuAVQKAPAZUtk72/uUtALIC"
"FgOA0gGQMnZa31PXAPm4j8z896n+f7A4BqQA4LA4DsRtAQUA+DVn9nTj78M3AQgCFADQSeJ1"
"fg5rgFUBwIno2lUCwPH5r6D4kxXwi5AhAWBk4D3xNusVwAelHt0CgP8SAOheAOZVwFYjgx6Y"
"yQBQ7AVQ7i8A4ExnYwuA1gDtRkA6AAx0DQDnEADOjZQAoFYBEQDOjcMYbwKASYb4WwLALJn9"
"q56/JvzsALiwCgBYbgIAVfpfL0T/Cgr+1c0y85cAwNP/2gVA+xrgHg0AUo3yv9MxoOMmK2Az"
"AJiqAOoqoFYFcAUAUZ5vsB0wrQIue0ms9JnFf5km9FYRh7GUbgE8b4Owp20CAH5AALiWA78o"
"APh2HwLALgkAWwwAOLNCAkAMXKU5gLIFcK00gu2ArxaFwtWCWRgzhREQQsDl3Gnwbc400QLg"
"OwBVAcAquHZaAEAXFMR+D0kAeNyxAuAKAKzMgAaqeYDHxH78RL/6cPnkevg2fwl8mTkdzqWO"
"5lOxp3Zi1rmlE+Qt84f00MaQPrshHJpVH9IQAmiCP2UKijkN9o0T2wBkC8zWvwoE6BiQrAIo"
"ANg34V2Z/SMAhNSFg9MboOg25n344wsRAOJbQgGKsjsKbot7DLFVhjeuVv0UAPQ2AUAPUxAA"
"dJSOgCd3jID85K48CHg0ygvS5zblNkCahIBDswQAzGv9DrcAVAVAB4Ag7TRxF1kFaPegY/mf"
"tgA+83gLitdhlr2iOf59tOtPwk/RjAHgOAIADf9R0BwEX+Zb3hqz/86wpLcbBP7jSV7/U1DU"
"WW4A9HrEGgAGW4j/B5YAMAYBoD8Ub+wuAaAtRgCKtj8KuZ8dABxaABIA8ug0tMr8E5o6A0BS"
"M+c1QHyfbwGo3j8P/bWQ54C1a4Bb28pzwCjQZNqzUwKAXvYn4ScA2K88AHpXAwB0FKg7fz1X"
"ARAARBVAugFuFABgdwJcKQEgkY4AuQCAxbUsjYB0ADg29wXICBUA0LnBX2aSvtisVwBvygPg"
"FgDc4JMlnzDzWWB9FdD/qYf+MgByGwEUNTMA4Ky2BujgBGgGgIFaC0DNABAEjMD4REDA2VHV"
"A8AFufp3fpp2C4AOA80U0//20v8CQ/i/XigdABdpHgDxovyvDgCp8r8dANZKAJDZ/5Ut4gDS"
"1S2m3v927QDQbgsA0MT/58PaOWDdByC3GgA4WQ0AnBLDgBoAJKM4zsUXtphnUeRfEit9ZvFX"
"ABD3khFK+GNlKACYywBwBgGgFH67niMrAAfhFwSAXxAA6CTwj1/SIOB6BIBk+J7WAU8vg+8r"
"YuHayUVwrTwKrhMElIQhAMzlKgDFZXkU6HJeCAPAZbYFNgFA0QIJADEMAFfJCOjURti7eBR0"
"RkHs+5C47KYDgN7/1+8AEATolYChsg2gYsBjYhBwcvOGcLliIwJADHx5fBacOzgGTu0Zhi+4"
"veHk5k5wjMWxCRyZQ0Nx9bkKQACQOuU9h22AfVwFkBCgDgF9KsR/92e0LSDdACfXRnhAgJhW"
"Fw7NbACHEQCORlAP3JcBoGhtZ3C/HcX2HpFJU9++x0PWWb8OAOZKgF4FcLoMKAGgYG03OBEn"
"BgHTwzzh8Bx3sQ1AVQAEgUOh5NLXDLz+fgc0vVNAiWoBKABQx4ZIlNs/aGT+/tIieFzTt6F0"
"Sy8U2EDIXib6/8ej1dR/Mx784zPAmPmfWOYHOSj+easCYGar2tD00TugEcJHUxR/6v3T9H9H"
"rSXSpwoA0N0A1VVARwAIgzMHxnAFgFwGi5I73hgAJNQUADQrYGX+Q1cAqfTPwu8vsm8Sf7oE"
"uPkGAIBEXd0CqBIAeorLgfsIAIIQALqyodAphoC2UEleABtbwckNzY1bAAwAHlCQKI4A5Zq2"
"AOwAsBABIEoAwPEFBgBkznMGgIfu+MsA0heb9QogewDcpJ7dAoAbfMLUKuB9NmMVkM4yqlXA"
"rgwAhZ4AZc0FANAQ4HlXANBfbgEMEHGGIGAIPso5gLNyEPDsxxif1AAAJsuTv9L5jwFghrj8"
"d0Gu/lH2r/f8lfAr/38S/2/jtN6/En8FANL855Ic/LtM4r9JAsBWEde2iVDDf9z332OcAFbT"
"/1T+ZwA4KMT/5yMi+/9FZv+/ZkknQB0AiquoAFSAeTPADgC/nTbmAP79Jawa2A7m4Ava4mdQ"
"1F9A4TdN+JsBQAm+enupjBgEgIUEAE+aASAD/nXpMALAfviF2gDkBfDVNvgJAUBYApMhUKIA"
"gIrFcK1sEQJAJJsBXS1GCCgMxZgjLwOSIdB0tgI2AGA2fFcgZwCKIuBy4UINAFYgAGyCjNVT"
"oRNmf31MFQB9EPCTJ5yPAVm1AuzHYR4TcwBT/RsJACiIRQAIRQAYC6f3fQSndg+A/FWBcCwc"
"M9X57nAkVAOA6TQLgJn8JOEJsG+cBICxKPhj3zCOALH4yyFAAgCtBZASUg8BoCGkh5IhjiMA"
"eD9sAEBXKXZWWb85zBUB80yAvglwcsfHCABB+HcGQMYiPzgyT8wBUAWAICBNAsARBIC4fvWh"
"CUKJ793ioFB7NQcgKwCU/Xd40DABosn/lk/dCYu6N0LxD4bCZDq40wKyYr04+z++sClCgKfM"
"/H1E2R/F/1CkLwx3fxXcH7kd6qPwN8a/05O2D+4WBkbt5UZED1P5X58BsDoIROI/nKoAEhDo"
"/yMCgLMHPoPKLwYgAHSH4jUaACS20ADA2wCA2GoAQJ8BkC2AAh76k2eAafIfM/9i6v1T9r9B"
"lt4dAIDK/+0QTBwBgMr2VgDgcA2wCgC4wADQwwCAXQgVDAFtuQ1wchP+/RvwZ1rrxwDALYAk"
"GmgUR4By4xpCToy2BshzAAYAZEUJADge8TocD7cGANIVm7EC+KbNWAG8z3aTK4C3AODmAcC8"
"CviGzWEV8N1yKGwqAaCNBgAmK+Bz8iAQrQKeGaDFYBFnpSHQ2Q8xRlgAwFgNAMzHgKYbYV/9"
"C5VrfxFa7z/KEH/O/GNQ9GNNtr8rNNMftfq31gQAqgUgAUAJ//UdInj3f48x+c8AkCLK/z/J"
"7J/6/pT5c0jx/1WW//+V5wIAqpoBUAAg4ze5EcCDgF/C/rgQmPmwsPGNf97I/s1VgHiT4OtB"
"/f8lL8gWwFM2OJOzB37/sUwCwDH412UEgO9SEAD2ws9yE4DPAl8gS+BVEgDiEABi4Fp5NAJA"
"FFwvDWdTIFEFCIUrPBBIrQACgOlcCSAA+I42AdgMiM4BhyMA0CrgErhaGsdbANdPb4Cjq6dB"
"R8wAez8osrhPTLcARldzEXCYKRQM0DogicmVii3wXWECfJU1F84fGg+nU0ZA5a5+KE4t4Fik"
"FwKABwKAGw/s0RGfAwgBB0JqQyoPA1Ir4G3YT8ZABADj5IVACgYCkf3vHUerg2IFMHXq+5Aa"
"Uh+z/0YIAO52AMhJaImi3Ak6vvM0D7u1kwDQyyT+/SwgQH28n/bf9c/p/bBxE6DfO49D+c4R"
"kI8AcCKhNWREN4cj873gIANAExnuDARUGTgW7QMbx3hAt/eeBP+7RSbe9n7Ri++oBv5I9Mkj"
"4Ok7YF6b+pC9KghKNvSEwjWdIW9lS8iK98Pnk/r9nqIKsMQLTizFrD+hOQv/hyj8jRB6SPhp"
"5sD9Tmk8dLeAIQUeXdQVQNMAoFXPX50CJvH/UIIA/fcZbRvAl8fmwdnUMSiwg6B0cw8GLwaA"
"pNYCAJKaMwCIlUC6A+HJ4m/VAlBDgPYtAFcAIAf/StaJzJ8BYKOK1qL8v4V6/+2hgnv/GDvF"
"BoAOACz+GOcdLgHWAAD290R46A5n9ugAQKBBZ4EJQFqIOQBVAagOAJZYAED4a6L8H/Yyiv+L"
"cCxUAMDGMU+U2xxXAN+w/QkrgLcA4I8BgNUqoBdGBwSAMihAACglM6A2YgjQCgDsPgAEAP1l"
"aABwhioBH4gqgAMAyEFABwCYLMV/ivD9p6z/wgzj8h+t/F2Uk/8Ovf+Fxulftftvz/6TTACg"
"7/3rALDBBADbDPFn4ZfGP9/vNcr+FD+liuz/p4MaAEjzHyX+v8rs/1/aKeA/DADneBPgUHIU"
"zMAXxEVPGwCQZDEDoANAjAwdABZLAJiH3+ds3l74/YdyBIA8BIBMPgn8y3epEgB2aVcB10kA"
"EIOA1yqWIgAshuvli2QbIAKuFs9jCLjCVQA6+zsDvssVIGAHALIDZgCYLwGANgEMADiyagp0"
"vEsAwBANAD570gizIZDZE2D43x3bAh/IWYBgfO6uVm6D74oT4asT8+F8+kQ4nfoJD4YRAGRG"
"eUNmRFMeBDw8l5zxGsDBWfUgbcb70hcARZ1sfj8nkafTv0r4CQbIBliKP2X/EyUATKsDqTNE"
"+T99Lvnhe0LmIso2W0HBuk7QyQIA+poAwAwB+sf7a6F/Ln0fytjHeL4FZTs/grw1XeFEPALA"
"Qj+EEG84GNYUIcCDIw3F/+BcDzgcRlf88DmIIW/+NrAzpAXMblsPxvu9C8MavwIj3F6FOYEN"
"IaJ9I9g+FUVt6wAo2dgLhb8L5JHF7opWkJ3QAv8ezPRjvEWQ3W6CL+wO8YRutZ8FN4QHmjOg"
"4UfyG2h2l1iDJPFv//ojsGZsG0hdMggC7xMtgO4SAAaYxH+ISfyHaeJPR6SGywuBMxEALmbN"
"hzMHPkOhHQRlm3s6AkBSS4wWKOi0DUAA4IVwJlsBEgBEuDsDgKsKwGpZ+l/XAkrXtxQAQBP/"
"m1QEcvZfsaWtFH8S/k5y+l+IPwOAzP4pm+eyfmrwDQMAQYQzALSGik10Epg2E8QmALcALADA"
"YQtAzgC4AoAMOwA8Th4AHaS+/GkrgLcA4OaeMPMqIJ1jVKuAnjZaBYx8aRsUeGgA4KICwADQ"
"F0W+ryb+ZgAYKo4Lnf1IA4BPTQCAmf9FEn559e+iJvwccyQAzJPDfzLz51gkAWCJBgDxMvtf"
"LsJe9l+lDf+t00KfASAA2C4zf7nuR/GDtvP/Q4oIyvx/RPH/Sa79OZT+VeYvs38HAKjJDIAB"
"Aq4AIHPrcpiKL4qRKIBxz4urfokuhgCrAgBVAZj/DAHAfgkA+S4A4AsBAOwImAw/nFnOcwDX"
"KuPg2skYBIBo0QYoxSgOZwi4UhSKADCHqwCXEAIu0yNvAcyWZkB6BYAAIF4AwKn1kL8jjCsA"
"fR4QFQA6BzwGRX7skyJcQcBH+jyABIKPNDCgSgD1g6+e3o4AkARf5yyAC0emwpnUTyEvsR1k"
"x7aE4wt9IXOBJ2TM88Bs2A0hoCG3AtJm1hG+AFNqQQpZ/E4go583GQDoUiDHeHkJcDwBAFUL"
"anH//0BIXTggy/9HwsgLnzzwyYEuAApQiAgA/OW6mxUA9LXI8vWP6yVxJZKqCkD9+lFN/wGl"
"W4fxVcCsWNkCmO8FhzDbPzS3KaTNJQAQIEDDgenzm0FGNE3pt4ScpDaQv6YTFK7vikLfB7Nn"
"6qH3xWy/F4poV95iyF/dDnJXBvA5X1ptpME+zvbj/RgGdk/1hO7vP8sGQ3RfwENm+z5S9GnY"
"r90rD8Gqj/3h7IEpcPpwCOyOCIaW9+DH7xcQwxUAU8//AxfCTzGCHuUcwIy29cUMQOpYqNg5"
"CEpoBgDBq2ClAQAFy8UcgFgHFABA4p8dJ3wAeBOAnADjTEZAOgDQBUDu+3vJ0r8GABswNrUW"
"pfdNYviPxL9yW3ue+ue+P8XuLhhC/E/v0bJ/2u3n7L83i/+NAgCZCTEEMAAQeBAA0FlgMiRS"
"ANBUzADwISAXABBtAgCtBXAszKgAzA22rwB62owVwKdsf3AF8BYA/DEAUKuAtIv5ss1YBQxc"
"M/OFZAaAEl8EgEATAGhrgGYAOGsGgKGiAmAHgI9NACC9AC7oABAi+v0Ofv+h1gDAvf9oGS4A"
"gLN/FP7vVrsAgPXGDIDK/u0AIMv+36uyf4pR9ufSP4r/jyj+P6Vr5X85+GfP/HM1ACjUAKBE"
"A4ByAwT+owPBySoBgMyAJmFmFI7it/Q54elf1QyAVflfAUC0BIDDqxciAJzkCsC/roqLgAIA"
"9mkAsMUAgLMrEQKSUKzj4frJWLYGvl6+UABASQRDwJXiMHsV4BK1AgpE/59NgNgJMExWAKIM"
"AKgQAHD93E7ocJcAgGGPCpEn4R/3lAgdAkY/4XgaWAn+CDkkqM8KUCWAxJIA4FLJCvg6NxIu"
"ZIRAxY5BCADt8QU/ALKim8PxKG+eBaB1vfQwqgLUZxMfsvNNnVoLUie9y1WAfRPewnhT3An4"
"XMZ4lf3XkuV/BIfpdSFtViPR/59Ppji0G98cRaa1AwC0M627mTN+q3kAV2tx/SQAUAk9ursn"
"it4AyF3VEY4vbYUZvi8cQpFnAMA4GCogQFUDDs7zhKNUCVnkx1WR7GVtIG9le8hfhaK5hgS/"
"A76N76OA5pKhzopAyEYRzU5E8U/E7J/3+v1hT4g39Kz7PDT4qxB+VeInh0GK5hgBT94OER3d"
"4dS+sRhjoHLfZ1CZOg62z+4IfuQCeK/4HdgEyFTyH6aJ/ghTfPx38d8+kC2AixmhCACf1RgA"
"uA0Q64FQKISf3AD5GFAsQoACAR0AkoT48+Af9dTXIACsbW4AAJX9CQA2q2gjxH97BwMA5ODf"
"aXLw29PtJgEgmD/PPgNQIwCgNUUvPgdsXgPkWwB6C0ABQCSJ/xsmADBmACZ3uT+ZdMVmrAC+"
"LHXnD60A3gKAmwcAq1XAdzGaYASM6v7QLMh3Byj2kWeBO8ktAB0Agl0AwEAj+6cZAHsLQAHA"
"SAEAdh+ACdYA8KXs96sgu98v52vT/1rpn0Od/tVbAMr1b7UWOgCsl/v/m+T0Pw3+ofhf+0Jk"
"/9dl2Z8BYL8GAAcwMPv/6bAMMwBkaQCQJ6PgBgBAe98JAM7YzYDO5KXA5/iiGPa48PInT39a"
"B7Qy+4mzEv4XRSx+UQeARQgAFVwB+NfVTAkAB3gTwDUALEexXgbXK+Lg+4qlXAW4VoYQUGK0"
"Aq7QLEABif4sBAACgTkiMPu/zFbACABFUTwDwC2AihX4PdchAOyADpgd9kVBHP6oEPlxKPbj"
"nxKhQ4BVK4BC+QaowUGqIpBQ0FT49dM74FLZSvg6LxouHg2BwnW9IH95J3zxbwMnlvhD1iJf"
"hAAvOBrhgRDQhKsA1AY4MF0CwNT3GALIHGj/hLc59k18W0KBLP3TASDK/qeh+M+oD2my/H8U"
"hfdYFGbXS5rj3xeIANCFV95a3S167EFyBVCJvdoGMFcE+lYBAIOlBW6wBIDYAb5QsD4YRbkd"
"ZEaTDwABgBccpkHAsGZwkCBgLsFAU64IEBQcWegFx6gagqByfCkKe1xryI4PxO9Bl/TaIBTQ"
"Sd1APjOcjZl/diICQBJVAQJgz3Qf6FVX+Am43yFWCvmo0L1ibqAVRkt8e6TnW5C5oi9U7v4E"
"RfBDKN/5AcYwKN/9MWya1hZ8JAB01lwA9Sl/Engl9hSfmIL+vRkA2tRH0JsNp1M+hYovBlgD"
"wIqWCADNuQ2Ql+AlzkGTHwABAAo/HwRaIh5z6SiQ5gYotgCE+Bfy4J9PtQBQsbWdEP8vaOiv"
"M1TKvf/Te0Tmf2ZPEMcNAwB9PDUYLlAloAYAwIOA62gTAAGAqgArPMQ5YP0YkCsACHcNAF0a"
"3T6LdEXqy7u2P2kF8BYA/DEA0FcBX8B42yZXAT1q3fYx5CEAFJEZUIAGAJoR0FkNANQQoNMW"
"gHkI0AwA5mNAU0QLgAFgrtz3DzNc/+wAEClL/yrzX/IHAEDv/UvxZwDQsn8dALjvnyZK/z9L"
"8f/pSDUAkC8BoMAEAKUo8GUWAOC4HfA/v1dYAsDVL/NhLL6Yhj4mBgFjXxT9/gQLD4A4veQv"
"RV9FtFwDDEeISE9eBP/+kQCgAH69mgW/fkdbAAoAdmsAsN4EAIlwvTKBNwK+P7kYrpchBJRG"
"MQQIABCzAJepFVCgLIApCABQ/AvC4UrRQmMGoEwAwLVzX0D7uwQA0Iv8GAkAnz8lQkGAAgB1"
"H0ANBirhV/cDFCRQVYCc4a6f2QXfla6Bb/IWY9Y5GsUAAWBFF8hLag/ZmCFnoUhmLfSGjEgU"
"wgijCkBzAAIAMCbToZ932CCIYj89TqC3hfUviT/1/g/MqAdpMwUAUPn/aLgXZC6k/rg/AwCV"
"1unmfSt58ra7BgD6vr/V9L+rNsAgzQO/M37PnTPb8wZAFgJOxqLm+DP4SvGnNkAzjoOyGsAx"
"j35vL8hAADgW3VxAwBKa6sfnJi6ABwlPJKDw4yODQFIgX/LbO8sPgqXwe0jhp0zf/16xLdBa"
"XhTs8NydkDyqBVTs+RhO7hgK5ZsHirYCRunmAVC+4wPYMKU1eN9hVAB6awBgFn8l+CO1GCHn"
"P4bg18zt4gEX0mfC6b2j4OS2flCysTtm6QQA7RD8AhEAWgkAoDkA2gZI9BYAEOdpAIA8CUwX"
"AXNUJUC2AewAgOJfuNoFAKgWAIk/H/4xAODUzi6y768BwF4XAOBqBiC9Hz5ipOH7ZBKUFlzN"
"EKAZALyhZHUzKF5JB4GaiHPAVgCwSA4BLpAAoM8AaADw1lO3fWwzVgDflnrjsAJ4CwD+SwAg"
"nzR9FfAxm+MqYHMbrQLmNQEobCbcAE91kF4AQa4BwHINsAoAYDdAKwAIsQAAGvxD8f8yXAIA"
"9f7lyp8lAMQ7rv+Zxf+SNP9xGv6T4n9thzH0xyHL/z8cMPr+VPr/WYr/zzcLACVS7DUI+E+Z"
"awDg0L0AvoQx+MI6G18IF0kAiHvRhdmPJvws+DL0t6kCsPrT3ggAlfDb94USANIlAOyFn/9J"
"ALATAYC8AOgmwFoEgNUOAHC9Mh4BgNoAixEAqAoQCVdLwuFqkYCAywwCoY4AUCDOAV+hNcBi"
"DQBOr2cA6CABYLgEgPEo4hOeEqEgQK8C6CCghP8zU6uAhglJQEr2xcB3ZWvhm9zFUP7FEASA"
"YMhfiQCwvAO+4AdA1mIUu0U+DAB0vY6u91EVIG2GmAPg4CM/EgKmvCveniiu/6UqAAipw+J/"
"cGZDODjHzREAlraE3EQCgG588jbgHkcTIDMA6BDgCgB0CKCP0fR8RxTdsm3DIX9NZxTv1nA0"
"0g8OhXtLAPCUwt9MhgCAI+HNIGOBDw8L2gEAoeg4/szHEQKy41H0E6gaEIjPWRs4urg1ZvzP"
"8w4/9fe97hLlfcryA6VLYDsZQ+u/COlLe0HF7hHs909zBUXru0Pxuh5QvKEnFG/sDWX4b7J+"
"Qmvwwucl8F7jDgD9bkNN2b8u/KMeN0K1AAbj16wY1QHOH56GADACAaAP/p1B7ANQSG2MFW1Q"
"+AOsAUCvABAAxLgGgMLlXiz+PPzH4u9XPQBsa181ACj3v/0KALQhQBJ/BQCH+8GXRwbAxcNU"
"bO8LAAAgAElEQVT98WN9BQRQlUABgHkNsCYAsKyx4zngJdoWQKQrAHjRDgA2sQLY3Oa4AviY"
"7Q+uAN4CgD8OAGoV8FmbaRXwu7T3zzMAkBnQKXkP4Gw3x1sA+haAEwAMqQEAVNcCCDVsf+0A"
"ECHK/y4BIM7x6I/u+6/Mf6oEABT/azu17F9N/cvMX/X9HQDgqDEAaF//M7cA1BCghIDfiyUA"
"lDpCwH/KnKoC//P7SQ0C1AyA8AIYc48EgKeFoQ8BgL7zH6uJv13sX7DBQhmLZERhzGMA6KMB"
"wAm+CPjLd2miAuAEAOskAKyA7yuTUPyXOQNAaRQCALUBBARcLgzDTJ9En/b/50oAoP4/AcAi"
"uFIsWwDlCACVogLwQf1X7TMAo1wAgHkewBz63MBnTwhhoO+Xu20BXClfBxePhUH59sFQvL4P"
"FKxG/l3REbPaQG4DnIhG8YtqhoLZFI7Md0OxJGdA0QaglcADU0jkpfDz43tG9k9BdwRC6goA"
"IFdBHgBsikCBALDIVwJAWyhY3wOaodC1NgGAleWvuRJgtQ7YX2sPUDvhk6ZvQNnmwZBH/f8l"
"Afj7+GCGb5T9DyKUHLSDgAIAzP4jRfZ/DGEoE7P/44v94XicFP/ENpCzoi0cjW4Nn3r/Azzo"
"/C/ZB98pBvqU8LdV1wMfFCt9oz3fgpIvRkLlnk9Q/PtDyXoU/LVdMDoiAHSG0g20Stib7xbY"
"AeAeYwhwYBUAQP+2n2rxiRwCHIRfl/RROzh7cBKK4DA4ubW3BIAODAAFCgB4BkC2AJZ5yxkA"
"6QUg5wCyl7rZTwJTC+BGAcChBaAGAKkKsFNO/tun/2ULwBUAkLgfFJk/if/F9AECAPCRqwAM"
"B38CAMQ2gNwYZwDIWvAWHI+QADAfAYDK/3NpC+AlHgL8YtJT523OK4DP2owVwFsA8H8EAFWv"
"Au6uVQYFngClLQAq2wk7YDsA9DIA4Jw6B1zTCoBcA7S3AOQKIAPANA0A1MlfEwBQ/596/19H"
"O7YA9OzffvRHA4DvqgOAbRIAUPyv7TaJv+r7y4l/BoDDJgDIsACAHGMFkAFA2wT4vegmAKBC"
"swQWALB8UFuYiS+GUSjeMS+IKkCsqc+/2CT8JPaRpojAmPusDZJH90UAOIUAIO8BXDoKv1wS"
"AEBmQAwAbAakAIA2AVbC96eWGwBQEYsAgBBQuogh4Cq3ARACiqjPP08CQBgCQBgPAFL5nwGg"
"SADAlbJYBIDlcK1yLVw7+wV82qwWBN8vtwA0AJhoAQHmUMI/3lQtoCoACUfe9ki4WrkBzqRM"
"QAAYikLUFwqSu2M22In72idQnE9g1ptJbYCFJIhNIH1eIzg8W1gD032AA9QGmFZLVAIUAEwx"
"yv8HQmj4r57I/mc3gkPkLjiPTuJSb90HIQMBYGU7SJnfloWOAKCLCQDMfv81hYA+8vMpc44f"
"0hwKNvSDnKT2kBnjD0ciEABQ+NNC5eQ/AcDcpsYMwDwdAFD48WuylrSCE7E0A4DCn9ief+65"
"7euABwp9k9tsXMHwxay/5T1Gtt9BugV2kTcDQts0gtMowpV7R0LZ9kGY7QexGU8BCjFF4drO"
"CGJd2UugBAFgTofG4I1Q0Qa/Z9CDNwcAH1IrBJ/PZcMC4WzaBKjcNZSNimjlU1UAzACQz5cB"
"5RBgnPIC8LCfBGbhj2sC+ToAJBotADMAlK7zR7Bp5TwDoAMADQHK4z/2LQA5B1AdAFDpnwHg"
"6EB8HMhVgItUBXAJANoMwOZqACAOAWCpawDInP8GZM57DbP/VyBTA4BNY5/4X1sBvAUAN/+k"
"Wa0CvmozVgHb7VzwyjbhBdAcoOJGAWCoYQdsBwALJ0BLAFBrgHITQLUC7AAQaQEA+v5/guPV"
"v+9WaQCw2kULQA0AUva/Sw7/ofh/r6381QgAMiUA6GuAWhXgN60KcEMAUG5AwG+VxhwAAkBS"
"/0AIwRfDBU+LaX4l/IstMv4oTfwXPI+iT31/GfMwQhEAprMbYCX8RvcArmYzAPzqAADkBrhV"
"AsB6+OHcGgSAVY4AUCkBgHwBEAKulkYKAKCNAISAK0Uo+oWU9cvhvwJyAcRMvCgarpTEIACI"
"CsBVCQCfNHvPJQCYIWC8JvZ66BUDmiGgVgKJRv4XC+GbwkQ4tXc8lH8xDDPCflCY3APyV3VG"
"gWsL2SR2KHyZ0T6YrVMVwB3S57tBeih5+ZOo14E0qgKEoNCT6E+ldb9aYkVwam3eFqDLfwdm"
"1uPs/yDZCs91hyPzm0JGuBiuy14awDMHySN9udcdqAGAOgCkX/nr5QICzI6BfeXwH30fminI"
"SOgFBeu6w4l40f9PD/OCtDko/nOkCRD+XAoGaADwCPf/vUX/f7Eo+5Pwn1jWDnKXt4fN432h"
"7RuPghtZ9qJA06AebTAEaI6BXR807gWQ+E9tUQcFeDKLP1dcNnZnA6T85PZim2B1BzYQonmI"
"wo29oGTrIJgYUJefl7YKAB6xBoCPLcr/CgBogJTuSSQMDYCzB8Zhpj0ESjf3cgCAfB0AkhAA"
"Eg0AIB+A3HgKx4NAFHYAkOeAaQuAhwBNMwA1BgC1Bqj7AKgtgP0WQ4AMACT+KPhHBiIADIIv"
"jxAADHAGAKcZAEcAKF/v5wQA+XwSuKEBAJoTIAMAZv/Hwl5H0X+Vs//MUAMA5gY/TCuA7WzG"
"CuCrtj9pBfAWAPxxALBaBfSw0Srg7BeTIR8BoMQPAaCtGAS0agE4AIC8BXBOCb+yAtZuAdjL"
"/9oQoB0AlA+AdP+zrwHOlUOACgCiDdtfe+k/3nD/4/K/XP1Tmb/TGqC2/ndlqwsASBGlf1X+"
"55W/Q1oL4IgGAMduAABctQAw/mMeDCx3AQDnEAAuwpqRwTANX+QjnhaDfEtk1k/CbxZ9Fbr4"
"z5cx7zkbzEEACGEAOAW//VjCB4HUSWBlBywqAFvZC4ArAOddAEBFjICAsmgEgCgUf1EFuFJE"
"a4HUCgiXIcSfNgCuFC8WFQBaAyQAOIUAcGYbjEQA6H2fmOKmCf5xUswnPW0AgDkmyv9uDvr4"
"50+KNsDHKBz52xfBxYz5cHr/53Dyi+FQsqk/ClAPbgPkLu8AOfGBwhNgsR+GF5+xPRqBGfzc"
"RnCYjIHmoLDPqisggCsBtUVbYJoc/JtOg3/0OQgMc+hr3OAwZv+0ApgRKdbrsuNaQ96qDpA8"
"ygCAzg84A0BPCwAINgGCfiqYPp+uHlL2PaTe81BC5f/kzsb6X5inIwBQ0NtzPUT2Pw+BJ8IH"
"juHPeGyJP4NKdkI7OBwdCMM9XgMPFH5qWSjh110CuzxoHAzqJu8QjGj0EpTtHC3FnzL/Hpzt"
"F8pVwrwV7QQArO0CRRuCoGhTMJRuGwITWtcDHwSMdvi8dH9QQM4g0wbAx9UAALV76J5EPALA"
"mQNjUWQHMwAUbejCLQAeAtQAIC/RAACaAVDrgAwBLgCAIl8CQIG+BbDWT1z/MwMAeQCoNUA1"
"B3ADAHDhgJz0P9hXZPsk+kcGwVcZBACDBAAQGBAgpPSqOQCs8RargKuaQtFKd/x9mrgGgIi3"
"IFMHABL/OYYT4JSuD6gVQA/bn7wC+P97APgDf6xWAek8o30VcGTQQ7MhX3oBnGwDcBoB4IwG"
"AGf1GYD+hvifHSwvAQ6Tx4DkOWD7NUCLc8BqBoCdAKdqAKCqAKEWACD7/9/Ivj9f/VtmOP+p"
"nv93avBPAcBqDQA2ifK/AgCHFoACgAMiXAIAiv/PGTUEAG0V0AkASjUAcIQAlwDw+0VITZoP"
"U/BFcR6KWtSzIuuPluKvxN4qXAHANBRGngFgAMjmi4C/0EGgf4oKAJ8F/kq6AZ5VZkB0E4AA"
"IBGun0pAAIhDAFgK18kYqGyxbAOIKsAVrgRQKwCFnw4AceZP4r8IPwez/5KlcIVuAZxchQCw"
"DgFgO4QG+UGf+0QWN0oCwEQLAJiofXwyxhRTTJYQMEFuDYxA4cjZPBfOp4cKANgxHEo3DYSi"
"tT0RALrxHEBOQhvIoWG3mOYIAD7cBsiIoAwexTy0AQp6fQaAgzPqiMHAEMz4p9cR7/POf32O"
"g7MJAOjKniz/L2jG2T9tGdBKHfXlx7V4F7z+6gwAVgd+zNUAdQFQ/29B0v+fsvGVH6Kgre0O"
"OcvaQgZm8+nhmP1T+X+2B1v/svjPEgBgz/7ne8HRKF9eF6ShQfrapKEe0PzvfwVP/Dn97hQD"
"izScRyY9HWWZv5s8QdxDHgyiuwH0MxxNGIDi/6k98yfxL8Dsu2Alij8KMAW9X7SGAKA7FG3u"
"gwAwFCZqAEDfs5+2ATBc7v5/bGoBmIcAP5B3ADZPC4IzKbICsEkAAAEIrwEux3+HxFZyAFAA"
"AM0A5C3zsgMAwQBZAesAkOcKAFZ6uQQAGgIsV0ZAVgBgdwMUAODcAhAAwEN+XP4XpX/K/q0B"
"IJivBzoCgJwBMAEAmwHRKuBqTyha5YFAZAKAJQIATkS9A8cJAOYjAMx9DQX/FQaADA0AOje6"
"fbbNcQXwJZvFCuD/tuDdAgDHP1WtAjbG8O/e/J7PIc9DeAGUBwKc6lgNAFDmTzHEEP/zH0kA"
"wOz//CgJAFT+JwAYZwCAfQtgsrEJoDsBWgLAEmPo79t458M/TgCQbFoDXG8cALopADhcDQBk"
"y7ByAjQDQKkJAMqqAAD9KuB5SEmcC5/ji28oCtqCZx0z/wVaiT9cir45wjUAoBbAFASAL4tT"
"4bcfCABOIADIIUACgG92i3sAX6l7AAoAVjEAfM+bAIkIAHQiOL5mAMC7/9T7j8bPWSruAJQn"
"IQCshqu0BXD2C0ga2QP63if6uPSCPv4p56zeLPxTKZ6RId+fYgEAm0P6wfkjoXBm33gEgA8x"
"Sx4IxeuCeQ4gb2UnYQoU3xqz3xZwfIkvn7HNiPLgKgDPAhAEzJYQQO2AGXV5NuAgZ/314BAL"
"P5X+6XMb42MTUf6P8ObBuizKrGPbsLHOR57/sM8AdHrAuHxndd1Pjx6yzE+f312Kb9DDQnip"
"/97h2Tshe1Uw5K3uCFmY/R+JFBcA2fRHB4BQAQDsAoj/PT3cm6f/M2kOAkFotO8bos+PYtz8"
"LtGT72C6ENjTBCWq/bC0ry9U7hsD5V8MRfEPtos/C/+KdtJcCIV4TWcEsG74OT2hdKsAgEmt"
"64LP7QIAaJ2RNgBI0HXjH1cAoNYAaQWwN37twbhBcDp1LANACQHAWgUAbZysgBkAEn3kIKCo"
"BNQIAKQToN0ISAHAegSAjQFOAGDZAqgpANjL/wMlAAxGABgsAUDMAFgCgLoGuE0OAeoAsM5H"
"VgE8oZgAYIU7WwLnxdavFgAy9QrA3BfA+52/fG4TK4CNbVWsAP5vC94tAHD+Y14FpPOMtKLR"
"0GZfBZReAOWtxSrgma4o9EFiBsASAAZrAPAhCvsIGRIAztP+v+z/X1DiXx0AyAoAzwBESAdA"
"BQCxptJ/UjUAoK8BbnANANerAQBl/kOlfycA0G4AVAkARQICXAKAUQWwBgAxCFiUtgnGIgDM"
"RuFe8Iy46qdK/hFK3OWjFQwoAAhDAJj9jACAyqzt8Nv3JTwEKCoABAD7BQCoIUC+B7BBrAIy"
"ANAmwHIJAMscAOCq3Q/A1AKwA8BizPyXIADE4ufGiwHAimS4dnojXD+7A5JG9eQKAAHAaHxR"
"nyCFfrKW1ZvFfxr+LiHPiEcFAToAjEYA+Ai/36pRXRAA5sBpBIByBoBBvAlQuKY7FKzqjGLQ"
"nnf07QAQTZm7JxxdQFWAxiiUDUUrgMVeij5m/CT8B0Np4p+G/hrh2404+6ejO0dk+f84AUBM"
"S3bXIwDo8I+/g/edxunbbvIcsBJ5V6HEX5Xb1dsd5ZW+iI5uULC2B/49gXAU/850sv6lYb85"
"QvwPzGmiAYAYBmQL4Eg64duCd/yD6z8H7n+xcYvC/2/4fe8VkNLtQVOlQs4jBD9iVCGCXrwL"
"SneMgYqdn2DW3Q8K13Vl8aeyPw0R5lOg+Oev7oTPe1f87wIAyrb0gbLtQ2FioKgAdEAA6Pmg"
"6P8Pf8zZ7c8MACP/bmwADJYVgEOxA+FMymcotKIFULwWfxZuQbTFnyMQxV6/BWANAFXNADAA"
"LPN0BIA1vq4BoCYzAA5DgD24n0/rfwIAaPq/vwUADLRvAegAYL8FQACwvQ2fA6ZjQGoLwCUA"
"LJMAsNQFAMgWAA8Ahho+ADZjBbCh1JfnbaYVwP+G2N0CAOc/+iognWWk1Yx/2MSqhi9G5x+P"
"1rsEhV4AZQGOAHC2J0YvRwCwZ/9DUdCHawDwMcZICQCjTQAwwbgEaG8B6AAw21gFdAAA1fuP"
"s+j9r5BX/2Sp3w4AlPVL8b9kOgFcLQCkGbv/TgCA4v+zEn8dAOQdgBoDQLmpBWB83LkFYGwC"
"VGbthNH4YjwDX+QiJABQmAFgnlbu12FA/XcCgFkKAI5/ISsAogXw87cHxQzAN6oFoAEAVQHO"
"rUYAUJsAOgAs1QBADQGGGxWA4kgMDQBKY8Up4JMr4FrlGrh2RgDA8tHB0Oce6QRIAPCkY4l/"
"si7+zxjiP90VBMgKwIcoJKvGBCEAzEUAmIACNQJKtg6B4g19MTPshSLVDfKXozgsE22ArBjM"
"hqO9GAAyIiUAqCrAHAoa9KvPR4MOh2HmP7cxHAqjoT+6I0Drg+4YHnAkwhOOLfDB7yWc9ajN"
"QJlvk7+ICXoGAFkB6P6wIwB0f8gQfD26adFVK7t3ePZ2yF7ZC8WVJv9b8lAfTfqLzL8JHJiF"
"MdPNDgBs/4vZPx0IOobZf1pYc2j13L3gQUN+dwqTonb3OW4p8MyBafiwtwQAAoQ5bd3g9P5x"
"UL79AyiVdwNI7PNWdrBn/vR+QXIXCQBBUIzZednWflC27QOY3KYu+OHf30lWAAZpAPCxKcwm"
"QJ9ID4AhCgDiB4kZgF1DxBbApiAowue+gLYAViGIUQtguQ4A3qINQLMAy7zsFQC+BigjXzsI"
"VKAqAPYZAF8DAEwtgJM6ACgzILUFYAYAXgPsAefoCmAKZf+9Rfm/CgCwqgDQSWB7C4AqAFYA"
"sNY1AOTG1oXsGLEFQABgngEgAGAIQABICXn2EumI1JN6Ul+elXpjXwH8b4jdLQBw/mNeBaTz"
"jK9j1MXwxuh4YXftMgaA0lYCAE7fJABcGCmz/9FGC4AA4IL0ANCHAO0zALNMa4Dh4gQw+f//"
"U9v5dwKAlY7Dfnpc1m8AKABQMwDbXQwBpkkAkKX/nzT3P8r8f0Lx/znTKP//kqVl/tUNARab"
"yv1WAFDmCAD/UgAgNgEulhyEkSgYIfgCF/60EH+11x9hEnlXQeJPK4BUAZiKwngkeaE1AHwr"
"DwJ9RW2ALcILgAFgrQSAJAkACSYAWOhQARCPkXCFxL94oRj+cwCAVRIANvEtgBVjEADuFYJN"
"w3tU7p+slfWnWGT+07VwgACMyXIQkCoAa8f3hAsZ8zArnAQVuz+GchScEgSA4vV0y16sA+Yn"
"teVjPXwhcLGPaANEijbAkXmyCoDZ/uG5DcQjvp+Own94nhsfEeJDQmFN4Og8cWGP+/9RAgDI"
"BZBMdDaP92EAIM97Oq/bSVYAzOIfpIm8im5mAHjQnP0HQTb+/LTOR6V9zvpnCuHnx1my/y8B"
"4BBVKFD8aViw67tPQtM7xM9FrQn9LK/aOFCXB3Uzoj4SXOhn2T6nK5zaOwYFfQgDQOGabjyM"
"SHMPNPxYQOK/pgsGiv/abggICAAbEQC29EdoGA7T2jeAFrfboPO9QsRdAYBVNcAKAE4fGAen"
"dg/Ff+s+kL28K3R88R6Y0/k92QoIhEI2AjJ8ABwAYBlVARAAEpryI0V+grgDkM8rgGYrYF/X"
"ToDaEKDDMSDTGiD7ANAAIIp/zQHAegaAAICsgO0zANsCnQCAxT/ZyyUAcBUgxmILIOxVYw0Q"
"AWDz2KdoBbCj1JO6Ul+esZlWAP8bYncLAJz/6ACgrwK+j9EMo93BuDf2Q0EzAQCVLgCAtgDO"
"DRDl//MIAOcJAD6UYQaAT6UHgBkApmgbAGoNUA3/hRkHgL6KEiuALP46ACxzPPxjdv3j0AFA"
"9f83GR4A17Ts//oesQKoAEBl/z+mS/FPl6X/YzKOG+L/iyr/57oYArQCgPIaAgDGv8gL4JRh"
"CPTvC/AxZmXTJAAset5Y+1PDfvNNYm8Vc58zACAlbg78/n2p2AK4rAAgVQLAbrsXwI8XNyMA"
"rBcAcHqVVgFIgGsVCAEn4xAAlsA18gOQAEBT/wYALOThvytcAYgR/X87ANAGwGYEgF1wYnM4"
"9EXxGYG/47jHRQY/xdTfn2qR/c94VoQOARQEC7QOOBKFYf2kPnDxWBScSZsGp/aMQlEYJtsA"
"vRkAClZ2FnMACa0hJ9Yfjsf4cBVAzAG4w5FwNwkBjfhk8OF5DdktMB3F//B8mhPAmO/Og3/p"
"85qy/3/GArLWRZCI9oMTmJWT38Ak//egCQ3W/c0Gbe43WgDdH3LO+rtKkbeHBgJd5MQ97d/3"
"ePMRzP57osi2E3v/ZPozxx1SKeuf4SaCAACz/4M0BzDXnX0Bjsz3RtBpAUPdXuRJfz9ZlaB+"
"P/19PR42hF9dHeyvAYB6W1UActePgsq9o6GUnlcCABT5/NVdMDrLzL8zPtdC/AtR/IvW0QBg"
"MJRvHcCDmQMbvwwBCCHd7sPv+7AQcx0ARvzduPynZgL0OwAfykuA/fBr147rBGfTPofT+z5C"
"MAqG7m88AH5UecEY7/8aFCW3x3/zViji0glwmQ8Ku7d9GFBUATztAJBP5X6M/CQRvAK4XFoB"
"6wBA1wAJAqoAgIpt7ewAcFqb/ifxP7Ovhx0AhL9/NQCAj+wFQABAJkH4NfS1NQaA1doQIAFA"
"YmPIj2sAeXH1GAByltYWtwAi3xY+APNex5AAEPYyxkuwaPDf99vECmAzqSv6CuAtAPg/BgDd"
"C0CtAtKZxlo2sbLRZseCV7cxAJS0FGZAp7toAKDWAPtXDwCqBaC2AOxDgFYAoBkBqSNAZP/7"
"TZTh/+8AACr7113/km8AALbUEAAOCwBQg392AMgUAPCrAoDsKgDAag3QdBDoP2UO4m8AQLkF"
"AJxhAPgIAWAqvuDOf1oc9Yl+QQwD6oOAeql/rkWESgCYhsKYGh8K//6BACAXASADfv7ukASA"
"fRYAsEECgGgBfC8tga9VyOuAZdIQSA4B1hgAaAXwLALA+d2QTQCAv+PH+AI+/gkU8KeMbH+q"
"FtNcAICCgGlaJeBzsgpGYdg0tR98eSIazqXNwCx1NJR/MRyFaqAAAF4HFHcB8qgNENcSAcAP"
"xdFbrAMuoHJ+EwEB8924JUCP5BMgDIOa8BVBEeK07lEWf2+2ABYX9vwZLtq+/SS4/VVcyCOv"
"/PbaRL1Thl8FANDUPw3+EUSs/8wfitd1gxPxrdn1j8SfRD9lemNImdEYUmdSuGEQADThmQC6"
"DHgkyhfi+tXngT+eSZDDfuo6IWX36hyvDgBmB0JqD9De/tnDsxGuPoOyrYMZACjDL0DBz09G"
"CEDxp8eCNSj+a4KgcF0PKFzfE0o29YaT2wYiPAyCNvh92iMY9bzfcQBwhCb+Hz7mPBSoQl0C"
"pNmB/i/dBRE9PTHjbwSdHr8N2tAwI/2OGIt6NxCHgVa3lgBAmwA+xhwAZf8o9goASPzz5fnf"
"/CQRhcsxVnjbAaCItgAIApIRANZQFcAfytb7W54DdgAAsgKmfv3e7nCWMvf9FgDgMAQ4wO4B"
"UB0AOGwB2AHAv3oAiEcAiK8nqwC1IWfxe/ZbAGwEJJ0AFQCE9n6EPADaSD2pJfVFrQDaPQD+"
"G2J3CwCc/9RgFfDh2ewGWOIvvQAQAM4EGeeA7dn/wJsHAJ4BUAAQIsr/ditgmf2T/S+V/r+W"
"1/94+C/WNP1fEwBQBkDrtfL/jQDAEWPwT/X+Sfx/zpLuf7L3z2EGACsrYOedf2cAKK8GAM5D"
"SKNXYAoBwFOiBbD4BcP9T0FARDUQQAAwByMEv0fy2IEIAGV8EvjXy5lOAKAGAX+8sAV+PKcB"
"QGWS6P9XxiMAYPZfLoYAr5eKw0DkBUBrf+QMWCUAVKwWlwARAL5nAJjPAPAJCsEEFO5pKP4h"
"TxuZfcgzjkN/ISbxdwUAo1EYFvfzhy9zYuDc4VmYZY2F8p0fQukWEqreUGQHgA4CABICIGtp"
"c8hcIkyBCAIyGALcWfAZBuheAL0d7i4y/3APHvpLD/dk5z8CAHL/o8iMRgCgGYDlgeBGTnp3"
"iEt5BADtTEY6XU3C38UCALpKxz362jFeb0Hxxr6Qu7wdHIv2574+CX3KjEaQEtIQIaCRBAAB"
"AVwFCG0qVv+im4P/s3ezuU+Lu4yevxJ/lfkrABj4qHF/QN0gUCeIaW//3JFQPvFL/fySjfi8"
"osjn2wGgi738T62KovU9+AZAyZb+kLO6HwT94zEWaMr++2nZv17y1wHgQ9NwoDoENEzeAqAK"
"Qnd8frvdKyKI7gvQDE3b2lCxvQ8CEwFAIOSTF8Cy5iL7T5CrgBj5CAEUeYlC/CkKae1vuQgH"
"AFgtAECELwIAVQEkAGwMMNYArQBgT1f8/zGIM/+zZOJDg3+pIhwAQFsDrBYArGYATABgOAFW"
"AQBxdREC3hcAoJ8DVrcACALmvQSdG93x/4kVQPpzCwCc/1S3CtgyyPfeCZCPAFDcXHoBdBFr"
"gOdR/M/3EQBw3gQATjMAcgtA9wGwA4BuBKQAYAYKv+YAqM7/OgGAdP1TAPDtckfnP8sZgD8L"
"ALTeP5f/T2iT/zoA5GoAYHUOuKprgOY1QFcAcA6WBLeESfjCFiZnAJa84GgBrDwBXEFAqKoA"
"PCcqAAnDuhkAcAUB4JJ+EXAPAsAu9gL48cvN8OPFDQ4zAAQA35/E7L88FkU/RrQAyqQlMA39"
"FUVqACBnAOwAEI8AkCgBYD0CwBYBAFvCoR8BAL6AT0Thno6/54xnDGHXQcBV9q/PAUx6UlQS"
"xqAwhHdrCl+diIXz6XPgzH4CgI8kAPRhPwAqTfN54GVtMetrjYIttgG4DcDDgLTSRyU6c1MA"
"ACAASURBVBDgwXMBR2g7YAEd+vFg8U8PR1ENl5a65Kq3wJv3/8V53RZ8ByCqc12oL4/n+CkA"
"eNDYq9ez/S5a6ABA73d+SFQOgt96FLJX9+K1v8ylrRBEvHnIj0R//7SGGA1gP0NAQ0iVlQCa"
"ATg4rynbA4d3rsXZv8+dxkpidyn+A7QjQ3qoj6v/1l9uA9AWw8m90+DU/vFQtn0YX/krWteT"
"M34WfU38C+gQ0IZg3hTIXtUXgl5/FAIRQLqgQAc/IHr/ZOjzkQkArKoA5lBtgIEPCwiglcDe"
"5CqI33de14b4bz8UAYDghFwBA+QmgK+xARDfzACAxGY8C0CP7P1PALDCi4MBYLmXIwCsppBV"
"AB4GRKHd0ArK2RCoKgDojj9XTw0Aeon1P3UE6EBvJyMgSx8AAoCUYPs5YOstAGcAUDMAhVUA"
"QPaidyAr6k04TgeB+BywAQDe7/xlAumI7f94BZD+3AIA6z/0D+BqFbAFRjd2AywiACAvAAUA"
"wRh9MfpjDDQAgIcArXwAamIEpAPAHCH+NPxnCQB67z9RRpKLGQAXQ4CWALBLAwDlAqgBAJf9"
"NQD4RWb/dgCQws+RBw6HgCwBwJT92wHAMQwAKNcA4JQdABb3FAAwVwJAzIuOlsCuIMAKACiz"
"TvwwCAGgnAHgt6vHDQD4p7gIaK8AXKRNgPUaAIj+v3AClHbA5ANQttABAEj4hfnPQgaAqzwA"
"uBTFP0F4AGgA8MP5nXA2Kxn6oRCNxN9x4uPiZzQDwPQaij+1Dij7HycBIKK7J3yVE8ergGdQ"
"pMp3joDSrUOghAGgFwJAkASAdhiBkEVzAAwAtCNPswASAiioLUAHgyLJLZDEFB/DaeK/GU/f"
"0+Q/rdax+EeL8j8N53Wt/QyfzfX8G2bc9wkAaCsrAJ00H/2uLsS/syz9q8G/lIj2ULi2K5xI"
"CGTHv7S5Tbnkvz8Es/9p9fGxvhD/mQIADsx24/YAXQSkz++EAMHZP/487e8z7Hf7Wgi/VagT"
"xH3lFcLd83rBmdSJcHLHR5zZF68nS+IgNlvKXy0z/3U9MPvvCcWb+2Lm3wd6/sMQ/174O/V/"
"WAj4MFPvXwcAcyXAAQBkFYC+xyAJKvQ9I3u4w7m0T1EUB0HZVvwZVuNzt7IVCl4L9gHIj9cA"
"IEGIfn6ilxR/Gcu9HAFArwBQ8F0ADQDWSgCgo0AMATUFAKMCwAAgH2sGAL0cbwF80V64AFoB"
"gBoCTG4Gxaub4vPhAQUEAAkIAAkIAPGOAHBi4ZtcBchaQADwqmgDIACQfkgdcbUC+Nf/ltDd"
"AgDrP+ZVQDrTSKsa9W1idaPLv3Ma/QSFftILoHMVAGD2ATABgN4CcOUEqAMAGf9w+V9eALTP"
"AFQFAOYtAB0C1PtrawAAe43zvw4DgGYAQPH/+YTW988xxN8JADTx/63YBAAnjagRAFRoAHAe"
"xr5yrxMALJVXAK0gILwKAGABrf+EBIACBIAsOwD8/M99vAXws7wHQDMAygvAqADQBkCc2ACQ"
"VsBiCDCKzYCuFC10AABhABTDGwDXqPxvB4B1cP3MZvzeO+CHiweg799kC6AKAKiJ+FMFYbwO"
"AEFN4au8eLhAZkDkBrjrEwSAoVCykVYB1SZAZ54DIADIlnMAx3kbwIs3Ao4RBGDQ49GoZvz2"
"UT4fTIHiv0Bm/iiuNImfGe2LENEcTmB2vmuqN9S/TZT/ve+2gf/94noelfE7SlE3Q4C5/99F"
"E/+Vn/iyuGYntuFJfrL0pdL/PhR8En8OBIDU6Q1Q/BvCgZmNIHVWY97/p8uAGZF+0Fhm/+om"
"AU3z99PK/oNMWb/+cRX9HzUAYOz/Y+8toKs617Xt7HPOlrOtW+st7u5uxa0Up1CkSoXiLgmQ"
"hCDBgoSEBHeHADEiWEiIEU9wKVSgFC/S9vkfed853zWzAvR839eefwzWGPeYiwhF9ua+Hm9Z"
"FQHAC07uHw4Fuz7kHf806kc1/0xq/NuKxkvnf3cMgh2enaHLP6Qub5n/PyR9b9b+3XX/PykT"
"MET1AlAZgcx/Ub8mYv6Rn0B+GF0GpHFAlf5n82+pNgC6AsAJhgDd8W8AgLMEQMa/voUFAFIC"
"EACgaQAnAJhTAIVLAP1cpgB0NuBiXH++BfAFXQKkK4Bo/PYtAHsMkG8BcANgLzjL6X8bAHgZ"
"kdEDYI0BmgCwugFkrqwHGSvrPBYAkhcIAByeVewu+YfykTrKV17z+BVGAOn1DADcv/QkgD4L"
"XHgUMJJGAVupXQA9pQegyAyAu0VAugfAmAJwuQXgDgBmumYALABYKpf/vgk10v+rZQFQUQDg"
"sgrYCQC71BngMAcARBvR/yEHAOj0v0r930Pj/z6tcPR/P8O+AkjR/wPD/B+q+v8jh/n/cAoB"
"4GQRAJDvFgDufpvLTYDUAzD3JTT71+UssD4F7HIYqJg9HmgCgNUD8KoYK5nko9snFQAcLwIA"
"9igA2Ap33ADADQSAG/kqA8BXAU0AWOwAgODHAMB+BIBYePf3AgDOEkBRcjsCqKJ/AoDxz2sA"
"aIYAEAKXEubAuRgCgJG8fY6OAuVsVn0Aa3vBCboLsOJNjthT+CRua0gMRFNfQin95qxjZP70"
"pMxAQAte9pNAxr+oJc/UJy5qzaN/PP6HPwft1h/ZvCzUp2M6+PtrjYbX/i/qit5zrgBQFAT0"
"fM7u+vduV53HF2m5TiL+/NTQx6l/b0r9Y+TvVRtVCw541xYIIBEE+NWXFcD+zWH5gJrQ+Dey"
"6a/Ln2XqQNf9neb//mMAQGcBBlBzIv6etkzsKmuA93wMubve5TG/rC3vcM0/G98fXNIDRuCf"
"RXva+PcHqctT099Hpf8Afl3qMADoDIAuAegufycMfK5WBJsgwNG/6gOgX1eYX084HzcSzkR8"
"DCf3oPlv6YWw9xaavx4BJPOX6D89RN0AWNGsCABo/n8HAIw9AAQAZ6PetiYAeArgQD97EZAJ"
"AFQG0MeAHncO+JcCgHmlYNekl4saAdRngH+xCQB6PQMA9y/nLgAa0aBzjXoUsGvaxkoJkNlS"
"AOC0ugfAADCoiBKAbgLUkf8INHiM/C+Ncd0DYDUBTjYAYPoTmgAfBwBrCi8CMo8BaQCwpgCc"
"NwD0DoBIBQAY/d/Wtf/DjtE/nfpPVQCQbpi/BoBMZfwaALT554oo+rcA4JStH086oMCRAbhf"
"AD8+Oo0gIACQeWAjjFB7AOggEDUAPg0AzHPTDEirgGkZkBca5NWzCQYAHDIAIMIAACkB3DlP"
"ALBBAODMysIAoLIAYvgoes/rf5dYGYDregdAIQAIh9uXY2EQmsLwvxUNADOUzMjfFI//veIK"
"AGN0D0AGAsBRAoApGKWOgPw9KgOwZYBsBNzQC9JXd+M+AFoLnBLcDiGgtboQSAd9WnA2IGmx"
"dPgTFBxf3BIS0PiP0S59Mv/FbfBjbXmvflJwWwaA/VPfgEb4d9f4v6T7v72O/pWpOwHAhIBe"
"xtfQbL5vu5r8az6xviscX04Lf1rwvH8sRv5RXnUgyrMmK3oKCiEgmmBgam2BgBn1GBQOzm0G"
"oYNqQ9P/kG1/3f4i44fvFmH+7zkgwAkC76umO1reQzP8o96oDAkrBjIEFOx+H1LW9IPVQ1rC"
"sGaloQ3+N2nUr9t/S3NeP/xvj2lWCk5He0PK5lF8yOdDBQE8Avgv11G/EW4AQEf8n6k9AJT6"
"H1XneUhe9yGcjx0Op/d/BPk7EUK2YOS/oQuauKT+qfYv5v+GmL8JACt1/b+ZGL87ADDGALkE"
"oHoAigIA6gGwFgHt7+mYAniblwDJIiDnOWATAGgc8D01Evg+ZwR4RJA+Fz/AAIDebgHg5HYy"
"/zaFFwEVVQIIqQHpdBK4CABYMezFBPIPD3sEsIzyl198BwC9ngGA+5fzLLA5CtjUg0YBA2gU"
"sKWxC6CPOgc80GgC/MCxCEgBwKURsgPgEkb+l8YW3gR4yR0AOMcA5/5MADD2AWhd2+AAgG1q"
"A+Aeif6/22ffALhpLgBSkf8dtfiHO/+TxPw59Z+mlO6a+ncBgEzX1H8hACDjP23rR/3+lAUH"
"zj0AAgBn4acfzsOyvm1gHP5j6YemtggNLqiYnf7XJQCzIdAcDTT3AmgA4FFA3ga4RwDgutkD"
"YADA5d1uAEDGAG/RCGABQkA+QkAe1fcDDQBYogBgqShPnQB2AYD10gOgMwAIAJ+89nsY9jcp"
"AUx/DABoCDAnAvR7rxdliyABwDgFAJ5NSsLlEyFw8cgcOHtgCpcA8vd+Annb30djGAhZm+Uy"
"YMaa7pC+qisf7qHrgCnLMJIPRHNfQgZPENBS3i9Fs6cU/5LWfHL3+JI23OyXtKStAAAaP9X+"
"UzD6f6vi89AAja8FXdP7kywA6qZS/z0Ng3cHAN3VuB+l/We0rwl5uz6EzE09IDmkI4/80UW/"
"A771OdqPQtO3VR1BoAZEewoIxExDCPCtC/F8pbAZhAyqBc3x19ThD9L89446vqNNXZu/c+zP"
"zAQMVvpQfW6QmgboQdcC6Wog/n47/A5/zwg+FPHTCB5F/T3p2t+fxfz9ezfis8Fn4zx5bn98"
"q4rcCPiB6gXQpQBz499wo9ZPxv+J+nXwrxu/b8VHbeFUxCg4GzMMTu3/APJ29oVs/DOj5T8Z"
"vPynHUIeRv+hKvoPaSFngLUQAHgMcGVzl6U/VgmAGgLdAYA1BdCGpwAKNQHqY0AmAOg9ABF9"
"rH0A56PfZl2MRgAwSwHcB0DTAGoi4PC7AgQ0IcATA/3dAsCZnwkAlAGwACAUASCoGqTRLgA3"
"ADBn0D/1CGBTD9cRQJczwL+U0T0DAPcv5yjgCx72KGBjVCefT19YBJlvyC6AU13VMiANAO/a"
"ewDMWwCPBQAV/V+apABgirEJUC8CmuEAgPk/EwDW2GOB1mjgBtUEqM8AY/R/PUyi/+9U9H9D"
"Rf+3YiX6v606/+/o2X8d/afYkb8WA0CGnfp3AQAj9V8EACTunA8XMhBCfjyDPyadtUBAUv5q"
"CyABwANZBbx1ymAYg/9oev9DlgDRDoBgFflr83cCgNkM6G4/wKxX5CRwbKgfPLyVDfcRAL53"
"AsCVvQoAVAng/Ca4fV4BwFl1DMgEgFyK8pfAdzlLHAAQWDQAnEYAOLuLewBuXYoB3471YCia"
"0aR/Syrf2QPgzAKYi3+0PB0AMJrqwvhnd+XEcl4HTD0ApxgAPkUA+ACy6SYATQJQsxofBuoG"
"qXQXYHlHSCUTRwhIpmY+FM30k/knqR8novEzACylqYF2HPnT83hgO57LX9y7NtT/jQc0pc5/"
"MsW/SCSvR/96GRBgmn83I+qnUoFv2xqQtwfNH6PYlBWd4NjiVrzLnzv+McInoxfTrwZRk5Xo"
"vWd1OICfo6+JQQCIm0lri5tC6KCaDAAd/yAXCfsb6X9n9G9u/tMQYALAYPU91mZAKgfQJsE/"
"S0aARHX+3n+W0bx+Sju9usGZA2PhdMRwXgR0Kvwz2D+7F3THP6f+fxEzN48BDTWi/k+NaP9D"
"1ei3pD+a8s4RcD5uPP4dfw6n9r3P5p+1uRsa95to/h3gxOp2sv7XMP80ivyD6fBPUwGAULX9"
"jxf/oDGuacZmXwgA1koDoEwB6GVArXkTIC8CojHAbR0KXwMs6haA0vnI3tzFf4GyATGqJyAW"
"xVkAjPIPCggwAFDdnxsFaWrgHYYGqwTAh4C6WlMAhQCAbgFsfkIJ4AkAMLj1HxeRfygf0SOA"
"L3j8CiOA9HoGAO5fzlFAmtEsjqrsoUYBR/X7uy9kIADktAU42UVNAvRXFwEH2bsAXABgiHsA"
"uDTWAQBTitgE6A4AHE2ATgBgw9cyIWCtAQB6DHCHa/T/nY7+o9T4X6yK/jUAmKN/7gAgwzZ/"
"y/izlJzmnydiADipTP4MDMb/OQ37TzSl33pAaNe6sH1cfziy0R8OrZ8F59IjUOFwNi0ccg9v"
"g9hVfjCzYUkYh/94+pD5v4T/yL0q0X8ImnyIkf4n89cAYJYBnCeBGQJelyyAL/58S/u1hkc3"
"c+D+d8kIAEfg+6t2CUDOARs9AOc32wBAi4BOrYAbJ5ejggQAaB2wCQA6+s8NlAkADQB5KywA"
"oE2AN8/shNsX9iIARINPhzrw+XOyCXCqAwDcdf+bAMDrf/FjU160SwAuAJARogBgIprNSNlZ"
"v+MD/Md6EEaI78gkwPoevA8gbUUXlQXoAClBbbkfIHmpAoFAUhu+8nfcMP/jyyj13x4j/w6c"
"Pdg6uik0xb872q/fCo22/Z/srv9ez9kz/b0MENBRf1dV7ydgmNa6GuTsGAiZaGTUm0C7BWiV"
"L3X4U72fI/7J1SFyUjWInFjF1qQqED2lGkR71ZAswPQ63AdAdwoIAFogAHTCX1cvBQDvOQBA"
"m/+gf9jrgDUIOLMALt+nRgkHKNFqXuoRoJE8avZ7r8R/QUzAOxgBk/EPhtzd70HOzoGQi8rf"
"8wFMbF8JevxBIOD9v8mFP07x/9Nu7vtIwcjgMr+DgH5NIGPHUDT+CQgUI/DnHcz1/pztffDv"
"tBucWNuRa/608CedzJ/q/iE68m8OacFo+sFNIG15Uz4AdEKt/D2hNv8RAGSyDADAZ/Y6PfrX"
"Um0BlFXAfAvA3AS4s5O1CdAFAPZ1R1E2oLuCgZ4sMu9zkb3gQmQf6zCQWwA4NEgBQH+VKeiH"
"ACAjgIUAwM0iIJ4EoJPAm5ojBDTF3wedBG4ImavqMwBIFqBwCYDGAJPnCwD0bvBbXw97BLCy"
"8pXnPX6FEUB6PQOAol96FJD+YvQoYEVUfQ8Z4cB//VrIKGD+m9IHcL5f4VsA5z8El3PAnAXQ"
"PQBPAABzC6DbEsB8YxXwUuMK4JMAwHEZUKf/nQDA0b87ADhimH8SSq38dQGAEwIAOuq/r80/"
"x5aO+tn88+Vpdf8LAHyO0eA4NP+p+I+bNzV0PSfyxOhoMhrEJHxORE3C95Pxa6bjP6Cz6AAQ"
"Nf69KnX/kJIID6QSAgHBRvRvAYCRBdAQ4HIV8HV1FAjN8ovMcHh4MxUBIAHufhOPABAFd/kY"
"UJhkAC6pEsC5TdwEePM03QKQQ0AMALwGGE0+f6nKAiyV2r8luhMQxE2AAgB6D4AGALoFEMYA"
"MK19bRjyV6nde71sG75Z73e3/18DgGn+EwwAoAuD0gNAUwCT+WJdPgKAnAUWAMjcgP8XoJXA"
"1Ai48i1IC31TsgDB7VkMAcr4E5fS+7Z8RY+ifX5StiCoIyQv7wTbxzSDZn/04DE7Wvvb4U9S"
"9++mIn93m/6s6F9F/TQmGNCtHmRv6wcn1r0JyaHtIXHRG7zKN8aX5vxrKfMX448YXxlVCSLG"
"iaImVIaoSVUREqrBgak1pQzgQ5cLG8EB3+bwBv5vsRNG2z3/UjQADFKLfkgmCJhLgjQIfGym"
"4nUJ4e82FFCfwLgmxSF100cY9Q+BPDR7Apss3hjYi0sw1DCYt2sQrBnaGj6p/QL0+5PM8L/3"
"N4EBkk+nqhD8YUsIn9cXzsWORdMfBWejhnCjX34YAt2Ofnz+N5Oa/dbK6d+0Fa1Z6SFi/mnL"
"KepvhubfVKTMP305ggADQBN7AZAJAHoR0Fpq/GuF/7sR5W5WK4Adx4AKdnZ2AQA9BnhqbzfW"
"6bCucJqee2ljn5wHPhfeg9f4no/oDRei9XEggYCiAYDKBX05a3Auso9kEwoBQCd7FfA2ygK0"
"UlmAFvjrbgbZGykL0AiyViMArKr7VABAvqH8o77yEz0C+BePX3gEkF7PAKDoV1GjgHVRrT14"
"FLDxXchujQDQWTUC9lXrgAei3lUQoLIA5we7AYBRDgDQPQDuAMBsApxj3AJYYBwDCjayAKvc"
"lABWu5YBLABQ6f9vdyrzdwKAqv/firOjfzZ/BQDc+JdcBAAo47+vov4HyvTdAkC+0fwnAJAV"
"twG2fNwZFlV/DuZQVI//WM5DzUX5o+agZv9Lnv5oXgtfVMb/mkT9K1Ar0fBXPAEANAToewH6"
"dLCVEVCHgXxepI2A7/E64O+vH0MIQAD4JhrufhlulwCcAHBW1gBzE2BBsBsAWOIKANQAqABA"
"DgGtUJsA18F3pzciAGyDG+d3w81LkeDVrhZ89lcxbg0A7pYAeTs+5mz+m+AOANKkCfAsjQHu"
"Gy5NgDvQhLbobYAEAL1Q3SGN7gJwM6CUAlJIGNknodmL8bdR5q+j/3Yq8u8MO8aguaJxNUfz"
"b4Pm31FF/mTsvYx1viYA9DQif/rat175Lawd3JRr16mrO0BiUFs4GtCCm/ioo/+Al0r5T6wK"
"kWj0ZPjhYyrA3lHlUOUhnDS2In4OQWAyQgCVAqbV4KkA6gM4svAN6F7yj9Dh9wgef5ZFPmTu"
"7znS/04A0M/3HE2BGgA+NrICH+gRQpUFCHy3OZyOHAmn9n3MUT+ZPd0JoGuB6WspUu8qNwM2"
"9UIwGIB/P+8hqH0CR5a9AzEBffF7PoczZPjRo+FM1DCM9D+Fk3s/5K/L2z0I/y77Q85WWjzU"
"HY3/TUhf0wmj/nZi/svR9Nn4MepHpQY1Q6HZs5qy8dPlPz4BvKKxAMBqdfhnTVMGgKy1qgyw"
"hqJ/AQBK+eeQ+W+l/f+U+ifzb8/ngAsUAJza1dkGAAsCusLJMMoGIAwgBJwKEwggnd3fg3U+"
"HCEgug9CQF8bADgLQCOBAwUA4gfKx3lqoC9nDc7RZAGVFUwACKNfhwKA7e1QCADbWkM+QkDe"
"ljdQzfH3ghBAALCmAWSuRgDgLEDNIksAR2aX1COArZWP/KojgPR6BgBFvx43CtgS1eNSZC0Z"
"BcxDADjV3T0AnPtAsgBcCjDHAHUZYIzRA2A0AVolgOlQeBOglroGqM8B8zVAxypgl3HA1UYP"
"gHEZ0Er/7zIAYK9RAigKAIzUP3f+PwYArMhfA0CuGwAwu/91zf8cwI8XAH66CLeuZsL5jBhI"
"27cGwjzfh+BG/4b5aFbz0LTmozEvRgNchia9HBWCph2qAUBlAAgIlqtdAMscEBBYREZgkdJC"
"1Dz8eWe9LM2AWQdWw32aBOB1wDFwl3sA9kkJgADg4ha4fW6jKwBQ9F8Q9HQAwCUAAYDrCgCu"
"F6xFANgANxAAbp7bxQeBprarDZ/Qilt1DIh2ATi7/M1bAM7mv0mG+WsAGPVvOTGcF+UvABCt"
"AeBjHgOUKQATAHoIAKx6S40EKggI7sCNfXbkT2UBiv7bQ3Iwfj7kTQgeWBdao6G2/C9psOui"
"juv0UCn/t9XBHw0AerlPN7UTgLIEH9R4EaLndICMTV25BHFsUUs44t8E4vwa8ly/bf4Y9U+s"
"DOHjKrLhk/nvG11WNKYcQgGpAkQhBER7VoMYAoDptSFuVn3eGzC3Z1VeAdxNjQEOMI7/FAUA"
"ZgbAORUw+J+OJkIV9X9U8newb1ZPjPo/gzyM0HO2D+ANgSfQ7NPR9NPWdIHUVZ35WmL6KjJu"
"AoHuvOQoe2t/yNs1UE4G4/cWkOHv/QB//C7k7hyAhk/LhShzQCeGu0Pmuq74c9KMf0f8udpy"
"s18aRv2pwWj6wZTul5R/6rImqMYKABojADSW6D8EPxaqAIAv/zV1AQCt7PUtBQA2t5a0/1YS"
"df23k9S/WgHsBABLu9+Ck5QJICkIkExAN27eI50jCIjqzTX98wdQGOHzVEC8lAIuHRrIT4YD"
"nhpQAMAjgD1sAKBVwBoAdrYXCNjR1gKA/K0GAKxvDNkEAGvq4u8dAWBlTTixnO4BFAaA3ZNf"
"pRHAHso/fvURQHo9A4CiX85RwJc9HKOABbtrpAkAdPqfAYC1B8BNE+BjMwCzDQCYh8/5jwGA"
"VVBoHwBPAeg9ALr7f6cBAHttANDjfwwA8W4AIFmZPgFAmkgDgFX3z7bN/0GeXe+3pNL/LgBw"
"2hUCfjqPIEC6KEDwAz0vwa2vM+FsWiQk714Juz0/gNCmL8NS6vpHBVP9HyP3YGoCLCa9AFq0"
"F4AgILCEuhFQTH5sNgg6swIBKhMwC43Wr9bfISMilMsA319VZYAv98EdNQZ4+4IGgLUCAOoM"
"sIwBCgTQFAD3ADgBgJsAA1UPAJUBQlEEAGv4INB33Ai4E26dD4fPq7wInz4ns/t0Dnj6y64m"
"b10GdNP8Z6b/xyuNfcHOAMQFD+c9AJQBKNg3FKPGj9CMbADI2tAXMtb3ZgigMgD1AqTzhcA3"
"uRzAWYBgOhfcnk2fon5K+aeGdELjeBOGtyjBdfXWv5XaOhlrz+fsa3/9jLO/fY2d/vqoD9X7"
"F3arB7loaOlr3oTk5W0hYWFzPuAT51sXoqfpej9F/VU43a+j/n0jy8LekWUgbFQZ2Du6DAJA"
"Gdg/tizCQXmInFQBoidXgZip1SHWuxbEzajLZQA6BtS77J/hrf+WPgB3p38H/cPV+N2NBJof"
"02n/QWoNr++bNSBz24cY7X7EdX7us0DASl/dVbIr+GeXEkIZlg747MB/vjSCmbaqE/7Zd8G/"
"j26cFciiS4KbejEUZHF6n4SR/gZK83fBv683Jd2/ioy/PaSvaIt/J63Y/NPI/IOac9SfgqKI"
"PyWQjL8RQgCKACC4IQJAI/x6VGgjjHwbFwYAEkb+WRz9t4ScDa0VAEgGIG9bOxsAdnSyAMAq"
"Aezo7AAAygR0eSwAnIvsKU2B0X0YAi7EYqQfJ6WASwcHcEbABQAiEADCBQC4BMDqwqOAp3d3"
"htO7OhQNAFQG2IAAsLYB/l7rQcbqOvj7r8UAkB5UFVKXVnQBgM1jX07zKDwC+LLHrzQCSK9n"
"AFD0q6hRwOoeMsLRZV9A2T0/HwCGuFkENMaI/p09AI4mQDoH/MUs9wDw1TIpA1gAsNIGAJcx"
"wA0q8te1/+1uAMAx//9EADBH/1T071L3z3UDAPmG8tyUAE7bIPDjaXsK4MdzDAU//aD2/tP5"
"Xz4BfBGfl+D726fgi/zDCAWrITZkJmwe0gMWvSwZgsVofIsRDBajkS99TS4EEgwEqlsBLmOC"
"xdQFQUOL8Hvm4c/hR53z+I/35invwld5e+DeN7Fw9+tIhAC6BbBLrgFe3AS3Bf5BlQAAIABJ"
"REFULlAGYA03ANIaYOkBCH4qAOBnDkJA7nKBAMoA8EVAWge8G45vmwkD0TiHUK3435IB0NcA"
"TfOfapwF1qL0/2QHAIyjQ0AvSAaAAGDVkLfUGOAEOLXvcwGAHRoA3nEFgLXdDQDowgBAhpUS"
"Quok2QA0q1T8+LohjaDz8//Bp2bb/w7N/I9SV6fVumSqOoLu/w+Jsmnf/tvqpK/e7PdB9Rfh"
"wOz2aGr03+sAiUtawtG5TSHerwHE+NSBA1NrQSRF/ZPMlH95jPbLsfHvHVUa9o7A58hS/H4f"
"QsD+8QgA48tDxEQEgCmV4IBnVc4CxHlLFuDw/OYQP681vFP5H9DdyAIMUtH+AKORb8A/7DXB"
"7/3TdTxw0N9dMwXU8DeldXmImtcTTu39iJv7srb05f4KMv5U2rGwvJOMWYaglrcThcgzFcGH"
"NjGmr+jIdxnSV3VGg+/MJq+VjoBwAqP8E6tJHfDnRa2k72kD6aHU5d8Kfx5J+ZP5p7D5i/GT"
"OAOAxp+Kxk8iAGDzR6VTBoABoEmRAJCjVv5yCYA7/1u7ZgBMANihsgEaAHY5AUCXANwAQERP"
"bgg8F9VLygFU54/rx8Z/Kb6/CwBcoCxBhKT/iwSA3R3h1M4OTwaAtfUkC7C6FmSE1oATwVUh"
"bVlFSFlUwQIA//f/RSOAXZR/VPf4lUcA6fUMAIp+maOAdKZRjwJW9VCjgIETXw9lAMjtCHCS"
"dgG8/eQeAAsAhgkAUAmA+wAmONL/ugQwVSDg0jQpA2gI0EeBGABUCYAmARgC9DlgBwBcW+fY"
"/KdH/7ar+f//EwBINyL/DAUAWYWjf3cA8Cjf0QNw0jB/BQM/GkuBSDz7f9LYA3Aafnx4BnUW"
"fnx0Hp+oBwgFDy6yfkR9c/Y45BzaBUk7QmHHpI9gRe9GsOAVWRQU8LKAAUHBstds8+czwqgl"
"hhbRdAB+30w0XC/8x30smtLsdjUgculYOHUkGO5c2SuTAFQGuLgRbp1dzxcBpQkQxaOACgDy"
"3ZQAcpeh8aPyg+S9KgNcP4kAcEp6AL7M3gDjGpSBwWhEI/4lJu71kqvJa/P3Uk8LBF6W0T+z"
"/q8BgDTqeQGA0fVehUsJs+Fs9EQ4tf9zyN8zGHJ3vC9jgAoAMtf3QQjoAyfW9+IU9Yl1AgIn"
"EATSV7zFzYEUmabic93QRtCvwt/gDTT+thj1d/6DzMD3/otE+wP/bnfOv6sMkprtKAugT/r2"
"fv13sH4IGsrWnlyzTg5qC8cCmsNh/0Zw0K8emzUt9Ymc7Gr84WMk4qdof+9IMv9SsGd4CQgb"
"UQLfl4R9o0ph9F8aIhACIieWRyEEeFWGGIaA6hDnUxcO4X8jYXFrOLKoA0xpVwF6/lnm+DlT"
"oTIWfVXGov/f7d+PNnzd6U8LgPrRcaJiv4U53erB4cC3oWDPB2j8/SFzc1+EqW6QuvotSFlJ"
"GRQ0/OC2qNZwfBkqqBXfXGCp9ynBaN4kBgFUaDuEL4zoQ9vx+5QQet8GQYlkvEfjZy1vyTX/"
"lODmnPbnJ5o/1fzF/BtByjI0/CBUcCMRGX9IY9EKAwC4F0BAQAOARP+trLE/BgDKAmxpwz0A"
"VglgewcBge36HkAnGwD2mCWAxwFAD2sq4Fx0bzb5C7F9JRMQLzcDGACoWZCyBFb0r0oAPzMD"
"kLMRAWBdQ/x91odMhoDakLkSASCkGgJAJSkDKAAY2+25UA97BLCqhz0C+JzHrzACSK9nAFD0"
"yxwF1GeBi3vI6EZDVIeRff85g5cB5XZAAOgqAHAOAeBcUQDwqWoEHPqUAODlAAAfAwDURkDq"
"AaAmwC/VJACPAwaraYAVbgDAOAdsAcAOBwCEFQEAcQoAjCkAtwCAkf/31PiXbTf+afMvVAIo"
"CgBMs9ebAPUSILUC+IEh2gSI3//jw5Oi+yjaDfA9QsH9s6IH50T3EQ7uX7B0MSsWcuK3Q9L2"
"ENgx+UNYhWAQgAa6kPSyeqICXpUMAD0XvioQQOWAaWiYE/Ef+JEYmX6Chjb09d+Cb8casMWz"
"H0QvHQIp2zzh3NEFPA548/QquEEgQEd+OANgTAFYC4HUGGA+Rf4h9h6A0xvY/JO3+cL4hqXh"
"AzQgWgI0TqX/pzqMX5u/Kf1xp/lbAPC8LJAZopbErPy0M5yLncSz5/lhn3AWgPsANvfnRkCG"
"AOoF4AM2fWQ5kOoLOLG2JyQEdoElg2rBoMp/g9b/IUtuaMFN1z+qOffnJAJ+9++uJ3MHKRPt"
"p+r/7xT/HQT1awJpCBtZm3pwpEu3A47ObQIHZzWAeIz6Y6bVgpgpCGI66h9TgWv9+0eXtaN9"
"NP8wjvrJ/Iuz9o4sDvvHlIT94wgCyuD3loOISQIBMQQB06pBrG9NiJ9Vn68Y0k6DNISaQ4u7"
"gE+nKtDvtd8wxFBZoJcqYbxtljHUkzIcA4r/FmZ1rQ27pmJ0i6ZPzXhZ2+gK4NtqmuJNzpbQ"
"YqSkwNZyYInOLAe+IVrmVEv8mjcQhEitIHl5a1YaKYTOKms4aIlw0Io/ZqsVKzXkDfy81PxF"
"zUSUAeDaf0MWGT/V/tPY+CXyTw9tZAEAKd0AgUIAsMEBADQFsKWt1QTIIKCPAbE62mUAAoCw"
"J/cACAD0NACAsgCSCbgY169IAKBpAqn/2z0ARQGA1QSoACBnfUP8PdbH32s9VB3IXFUTMkKr"
"QboGgAABgN6NfjuDfEP5hzkC+FePX2EEkF7PAODxL+dZYHMUsN1Lf/uPD3gZUE47gALaBdAb"
"IaAfAsAAAYBz77qWAM5/gnIDAC4lgMcBAGUA/IwSgL89BVAIAJxngVe7jv4xAOjRv6cFADUG"
"eNvIAnATYKqd/mcAyDIAIMfV+B+YKf+iAKBwtK+NX58E/ulRHho/KRd+eoi6n4tmroQf//F7"
"rXx53suHH74nISjcQzi4dxp1SumMgML3Z0V3ERLunoWvTh2GU4m7IHHrEohePAm2jn2H7wrM"
"RQOdh0//lwQAfDGa9kLjnEBRM/5DP4xAAM3tQ4xwB2GkOxD1zn96wMaJPdDA1/NI4I0CGu+j"
"Rr9ABQBLrWVA6TsmQMLaEZC4fixqPCRtmAjhcz+GdeN6w9iGpXj97+C/yApgMn9K5VP0ryN8"
"p/E7f+z5smvjn2n+YxUA0AIZmh2n2fKgD9tA1s6hcDp8KBTQMqAdCAHb3sN/vAfIaeCt78iF"
"QHpueQe2T2oNC9+pCUPqvQTtf+MBHdH4O9NWOxQtrWHj/6tqovu73SGvzV9HyWSig6v8HYL7"
"N4X0Te9A7g6Cje68dIg2DB7xbwwH6XKfdy044FUdo36Z54+YoNL9I8uiwSvjH14KwoaVhDCK"
"+oej8Q8vBntQYSNfx68phl+LEDC2BAJASfz+0hCuIODApIqSCSAI8KmFsIEQgNBBlwtTVnSE"
"E+t7QOaW3rBnansIHtgIZr5VE4Y2KgYjm5aCUc1KgVfbSrBsQBPYMKINxC3sAbm7BnHHfvbW"
"vghMCEoY7adTU19oJ0he1g4SA9uw8dMK5WNLm8OxJc3ksNJSeqLwY0mB6sdLm4uW4cdQx4Na"
"oOEjCFA0r0Qf44+rz8nHW1qfF+HnljfDz9OYXxP8Wor+GxVSuor805Y3UgBg60SoAoIiAaCl"
"KwBsMQBgqxoDVADAC4FQDACcBehcdBMgPil1XxgAUFG9VRnADQDw4qDePx8AjDFAFwDYgACw"
"HgFgfR3IojLAiuqQFoQAsMQGgL/97j8+IN/wcB0BdJ4B/kVfzwDg8S89CkhnGt2OAjIAZLdV"
"uwB6GVmAQQoA3hcIOPehDQBWI6CjCdDZA2ACgMsiILMJ0AkAywwACHWUAnQT4IYnAIC7EoDe"
"AxCvdgEcdYwBaghQAEDmf99M/ecXAQCOXgCXHgATAAocACDG/yMCxk/3Sdlo/qjvSTmie7Z+"
"uJuLwqf13lQeCkFB6dGdAlSe6HaOUjY8upUND1B3vk6Gcym7ISMyFA6v8YPNEwbCio+7MACM"
"RfMapSDgsz8hCGCk+zHqQzS+mZ2qwq2zGyULUECRfZANALwISDIAo+oXhx5onG9jtDwAv28Q"
"fj+d/f0Af76P0TyHYCQ54p8y+6/N3+sVV7P3VDKjfv25yUbUb5r/GBoBfF6tjv2XLJR5j1Lc"
"1JyH0PF5w+Lg2aESzOtbD/x71YTZPauxxrYsBZ/U+DdG6b+HNxF0upDoeA2KFtT0xt9DP7XH"
"nhbbDFQRP826v6+kl+HwVjz8b05rXxk2DmvNHe3UuZ65kVL+b3GXP60WPuqPkf9MNP/ptXhk"
"j5v80PgjRlfAiB/NfxSa//AyaO62+e9B498zrBjsHvo6vn+NFTYSNep12MtyQkBZiJpsQMD0"
"GhDnI02BVHI4urAFLzVKpaa8VW9C2uoukL72LYSC7tx4l72lD+ptyNrSh0f1MtbTzoSucjth"
"BTVJtmfTT6bUfmArhAq6mUCXE5vCUT6h3ATfN4Zji5qIFiN4LGmMpt9EFNiUlRTYBNUUf45m"
"aPbNWWTmyRjNHycFNWPRj5OXo0Ja8DMFTZ+UzM8mhhrj12qplP/yhra4AbChQEAIPkMbKhBQ"
"ALBKNQOufgIAbFEAoBcBqU2AhQCAsgC7u9g9AHvUiWCCAAYAgYBztBOAACBcgYDVB9BHNQP2"
"4yfX/x0AwCUAugNg7gFQUwDWGKBjDwBPAWxwBYBsAoA1tSBTAUCqAQAeRY8A6jPAv2gDIL2e"
"AcDjX+5GAcuhanvoUcDougUMADQKeLonwBkEgLOqDEAQcPY9BQEmAAxR54BHyDlgvgaobwEY"
"UwAuq4C9i9gDsNBNBiDIAQAKAqwxwPVGE6C7EsBedQPAWATkcgvgoCoDHJU+gLv/pwDg3ANw"
"Elz2/jMA5BvKYwD48WEOA8CPD7JtfZ8lupftoh/uZaHJG7pDymY9Uk/9/tHtTNGtDHhw8wQq"
"HZUGD26kwf2bqfhMgQffHYfvv01CHYP7147CvauH4d43h3gzYH7MMkjb7Q97534GWzz7w4Je"
"9cG3VQXw71wTbl3YJIuBCkINAFjiAgBjGpaEt38rpv8JmiZt+iNRun84muRoNOfx/xYjZ4PX"
"APCSNAJSOWCy0hT1Ma+X7M/rSH+M0ihjb7w+HasPxnykIGDAX8TEycx7/F7MvYsy+66/E0Do"
"g5/ri7/md/4kX9sfwWEgft+gv8rPoY1eL7kZZGzAo5r48PqvwOpP34Bjy3uh6feFrI0yXUAR"
"P3W9J9FSoYVvcATO5j9VjfdNkg7/iNE0z18O9o0ojeZPNX7UUIz6h4nx7yHjH/Y67B6G5j/0"
"VXy+ioDwikDAMAKB12D/mGIohIDxpVClESzKQuQUmgwgCKgEMV5VGQTiZ9SGQ3MawOF5TeAo"
"nThe1IKPHCXS6mNagBSM5o6/ZlIKXUqkc8nL2/HBo2OU2l/aEqP7lmz4RwOawrGF+PMsbAxH"
"FzSGI/Mbso4uaIAfQ+H7BHx/bGFDOBaAWiRKXNoI1RiSUIlLGuGfT2OBgWVN4PiyRih8H6R/"
"jML3x4PF5OmpTT4lBD8W0piVqp6mKOJPcQcArAaQFtLQzgQ4AYDGANc158t/bgFgc9tCq4A1"
"AORv7cAQwL0A3AhIO/rfZBA4qQCAQICMmyDgHEFAuJEJ+B8CwGm1CvhJi4CeBADpwZIBSEEA"
"2OP5eoGHPQJYW/nIrzoCSK9nAPD4V1GjgDVRLTxoFHBPrXTIaiOTAAwAfX4GAAwXALgwSs4B"
"W1kAdwDg47oHwGUToAkAOguw3GgG1ADgzAKoHQDumgBNANC3AG4ecFwD1FkAJwBkOgAg11EC"
"KGoUMN+I9E8ZAFDgAACM/h/lCAAgbIgyRd87dE/0w12tDDR60gn44ba8f3Qn0zD9E/DwVjrr"
"0S00ezL8m8nw6MZxVBI8uH4MdRQe0B2Aawf5FsD9qwfkHgBvBIyAu1/uR+2FO5fD4M4Xe+Du"
"F7vh7qXdcOfCVrh1doMDAJaqVcCL4ducAH7O6lkP+qHJfogG+plh/Cw05VH/EgOn9P2kFwUE"
"JqGxT8D341+0n+ONH09SmviSHPsZrUyfrsdRw98Qpc/UsRjWP9TueIrS8dfxLhr5IIri/yRG"
"T4bPpk/b5/4sn6evI72nTf856SWwluWoJTfv4Mc/rfp38O9aGzaPageJob25CS5ri6qFh3ZG"
"c1KmvxiNckELODy3KRye04jNn5r9KPKPmlyF5/Yjx6H5jy4L+4eh+Q8j8y/J5r97aHEx/s/F"
"+HcPF/PfM+xlhAQ0/xEvwd6RL8O+ka/g8zXYN/p1CB9bHFUCIiaUROMvg/+NcjYEeFaEA15V"
"IHZaNYj3rQXxM+vAIf/6+OtqyDoyrxEaNkbvC5tBIkJB4qLmkBjQgscTKao/Ska/oAk/j8wX"
"sz88D81+XgP8Xiov4M/FqgeH/evhj1Hz6uH31Meftx7+PKiA+ggAqMUIBYsa4M+PWlxfCd8H"
"NsQ/N9SyhnAcn8eDEAaC1BOjeYrq5WPyPnk5GX0jUag8abQvldWYnynU9U9mryDAMn8LABra"
"zYAGANASoKy1zeT0L2UCHD0AtBPAOgakrgHaAEB9AHQcSKYDCmg/AIkgYLedDTizVyDgHPcD"
"qHKAEwBUCYCevCOA9wXg5/f3dCkB0KIhjv4ZAAqvAnYHANQEyD0AjhKABgDKAGyZ8Gq6h4wA"
"tlD+8auPANLrGQA8/uUcBaSzja6jgIvK72EAyKVRwB5PBgC9C8DMABQJAFPdAIC/OgesAUCX"
"AALQ+Jc8BQAYy4DMXgCXMUA3q4BdACDeAAB3GQATAHLcAMBjIMACAF0KKLABgO8E5CkAwMj+"
"IRr/AyWH8f9kmL8NABkWAPyIAKD1g9Ztkhj/o5ukFD77++B6Ikb8CXD/+hHUIYz40fivxqL5"
"k/FHwvdfhcslQDL9K7vhNu0BIPEo4Ba4c34L3wW4w+a/Fm6eXGGUAFTzX3YAfJu9EJ8Lefzv"
"BgLC15mhkLHHD7L2zkLNgYiAYbDLdzDsnvkJbPV6DwL6tYIl/VvDkgFtWXz+VZ2EJQ1Xz5H/"
"Mq7D/dM2fTL4wWrznF4b+57Su/r5nNJflSiip8geTX8ASUX59LkPnhOR8VPUTxr4nGhYjX+A"
"V9vysOLDlhA2tTMkrXwbcim9v60/ZG9+W9Ljq97iOXe6EUA19mMLmrOZHp7bGE22IRp/AzhI"
"B3rQ/GlGP9qzKkTT+t7xFbjLPxzNf/9wMf/dn6Pxf15MjP9zNP6hr3HEv2eINv+X8PkiwgJq"
"OALACNToV2H/WMoCvA77xxeHiIkIABNKQdQUhIApKhMwuQJETyQIqMQQEOdbHeJmIAj41UbV"
"gYN+dRlQDs6uDwcVFBz2b4C/hwb8PDiXlgrRfQF8zkFz96dVw3Xx66isIDo0pw7rsH9t/Hht"
"hADUvNr4Z1EHQaC2Ul0EAdSieggBKHyfGFAPgQO1pB4kLa2PamDpOCmwPpp+A1bSMnkmo7ET"
"BIjxNzZMv7ErDIRoABDpyJ8V6gAA1QOQudoeCcxep7YBbmzFsm4BEAxY54DbyFigUh5CQcEW"
"BQE0HaD3A+y2swGkM2ECAWcpE2ACAO0EiEaj50bAt+EiTQMQAND1wMjCAHBabRqU9H9H6xiQ"
"DQAt+RZA3iYEgE2yCpgXAT0GAHQJYN77L7gbAXzJ41ccAaTXMwB4/EsDgDkKWNLDZRSwWKgA"
"QEcbAAr1ACgA4CkA5x4AZwngaQBgrgKAecYmQIIAdRmQxwGDjdsATgBwdwtArQKmWwDWNcD9"
"jh6AGAMA9CRAknsAcGkCzHWUAh4HAPkGAJx0AECekgDATwgAPz3MFN13IwKBe/REw2fzPyFi"
"40+39APpdpoIzf8hGT9G/Q8p4v9OIn42/m/jMeqP481/32O0fw+N/+5X2vh3YcS/AyP+rXDn"
"4mYe/7tN43/n1uFTCyP/k9IAeCNPov8beWL+17Pnwbc58+F65nzOBPDn8kPhu5M0ObAObpxe"
"r7QRbpzdAjfOb8efewfcOr8Lbp4PQ+3jxUC3LqAuRsBNVhRk7F8AGfsCIHPfYsgIXwyJm6ZA"
"4saJcGzDWFg3sgesGfYWrBrSGVZ+2glWfNIRQj7uACGD27OCP2oHwR+2geUftZHn4Nb4sVao"
"N1ghg/E5uCV+Tyv83taw6tPWsPLjlrD289YQNac7RMzsBsdX9oNT+z7iFbQFe96F3B0DxfA3"
"9JJ6OJk+RfvLO6JRteHd/UfmN+OZfhq7OzS7ARyaWR8j7bq83Cduek04MK06z+gfmEz7+ytC"
"FG3xo0U+aP57qdY/tASavZj/HjL+ocr4h74i5j8Uzf/zF/HjLyIsvAB7R7wE+0eixr0M4eNe"
"Rb0G4eOLQcSk4hA1sRRG/ggBk0tDpGc5BABSeYSPChDjWQlBpDLEeldFKKku8q2JQiDwrS1Q"
"MIuggKR+rHRwJmp2bTH7WbVEM2uyDs6qgZ+rgb//mggOoqPza+GfC6kmHFkgSliIIBBQB0FA"
"dGxhXVbi4rqQxBCAMIAgQKIfExjw5wLrWdJQkIJGTmn+VDTyFFTqCp0BaMSrfgkCuN5vgkAo"
"mT8+Vxh9AAoABAQaWxCQtba5lAOMa4D6HLDsB2jjCgIsBIEtkgngMUELADpzSeCUEgMA6iya"
"t+4HOEulgMgeYvIHBAIuxr4ts/8U/Uf2EmkAoIbCPV1cAWB7BxcAoFPAfA54U3P8NcsxIFoF"
"bAGAOQWwopoLAIzt9nfnCGBJD9cRwGcA8L8UAMyzwIVGAUf1e94PMlsbAEA9AP1dAUCPArrd"
"BOiuB2DK0wGAuQjoygLJAhAEcBYgyLUZ0AQAug/wjVEKcDkHvEtOAnMWoCgAUD0AVhNgigMA"
"MhxjgBoC1ESAEwAeGT/+Ic8BACrytwAgVwkB4BECwIMsAQEy/Afa/LNcAYCzAMr876aL2PjT"
"RLdTUSlo/qKHN4+z+T+8geb/3VF48O1hNP+DGPlj1H8No/5vohAAIpT574a7l3ei+W8X87+0"
"2VoBfOvMat4CeOvsSpZ1DTBvGdzMkwVAN3Ip7T8PrmXORQjwh28zEQSy5uKPF+CTMgJLUEF8"
"GvhbOg5E4rXAqxgOrhesg+unEArObMYfb0ZY2MKLgm6c2cIrg1lnd8B3p3fCt3nr4dKxuag5"
"PN9/4YgvXDg0DS7EecK52IlwLmY8nIkaDWciR/P535P7h8Kp/Z/h+0/RxD9T+gQKSGGDWfn0"
"3PsJi97TCtqc7RTV9+UtdjQimLmxD4sPB6koX68JpnPBibS6dyGlyZtipCvR/iGMoA/NQuMn"
"0/epxR34sdNrQCxG/gemVEGh+U+sAJFo/pHjMPofWRqjeAKA4qrZ7zXb/D9/FU2fzP8l0ZAX"
"8GOooS9g9P887B31IuwfjRrzEhr/KxChACByYnE0/xIY+ZdEAEAQ8CoD0ZPLQNSkcqo5EDW5"
"IsRMq4i/LgSB6VUUDFSzgCDeF+VXAwFGFOcnip9ZHSFAmb0WfWwWyq8a69DsanB4Dsq/GhyZ"
"S6qOfz6io/NrwNGFNdD4a8KxRQgDi2vBMVZtVhIqcYnAAD2PLaqDf84ICYvxqZQUWAcBACEg"
"qD6af32EsPoMABzts/Er818pWYB0FemnaAgIbVAYAFQfwIlQAYCMVZIJ4ANBqxEC1rVgZRME"
"8GXAIgBgExluW/cAsKuzLAxSJYHTe95knUUDP2tlAlAR3VUWoKfKAvThsUAuDdDxIJoU2Ef1"
"/+4WAFBJ4fSeTgoA2lvngPkS4EY6BdzCPge8vgkfA+JFQLQHYE1dyFxb2x4DDK5slQB6N/69"
"n0fRI4C/yg4Aej0DgMe/nGeBaWSjGKqShxoFbFztP4cxAOR0kG2ANAVwtogxQAsAhjsAgNL/"
"Y41VwG7GAK0mQDX+d8UoBTAAqH4A7gVYosoAejWwGgm8utIeCfzGbAjcoLIAW+2GwO/2FAEA"
"8a5TAC5jgHoTIAFAprEISEOAvgWQ53oDgCJ86xpgniMLoDMAeUYGIEcBQLYAgCVt/lli/gwA"
"GSwBADL/NJFh/I9uJ8OjW8eVyPgT4SFG/g/J/K8fRgAg849DkflHs/l//9VeNP89cBcj/7tX"
"KPLfxuZ/5xJG/ufXIwSswYh/lWX8vAr4VDBG/3QHYCkCwGI2/xsU9WeT4aP5Z82B65lz4Bo+"
"r2bgk95n0ucIEObDVQSCq5kB+D4A3y+Ga9mBcC0nGL7NRuUuR4WgyYeKclcorRTlrYEv0PTP"
"xUyB87FT+MTvmahxcDZqJJwJHwanyejDPoaTbOof8ZnZ3F3vQ85OOhozCHK2obYPguytA3n0"
"z1Y/65m1QdbWnlit1gEvp5sAnaRLfrkstTm+rA0cC2jJHfSJAc3x2QwNrQmaW2NUAzg4B03f"
"rx4bf7xvHem696nJ5n+AzN+zCkRPRPMfXx4ix0vkHzG6NJp3Kdg3sgTs1SN+w15H01fmP+wV"
"lKT9wyjqx+g/7PPn8Wueh7ARBAAvWAAQMQ4BYMIraP6vo/m/LhAw2YYAzgRQSWByWQGBKQgB"
"qBgvAoFKEDMdNa0yxE1HeVeBg75VRTNE8b6ig374Ob+qhqrY8q2MfwaV4dDMKnB4NmpOFTgy"
"pyoc8UfNFR2dVw2OLqiO0FRDtKgGGnxN0WLRMQ0F+LFjBAoB9B7BQCkJIeD40rqQHFwPVZ+V"
"GkIQIKaetrIhQ0A6g4Ck+ulzLgCgMgEMACEyHnhCjQVm4PcRAGgIyORDQc3RJKkpsIXdF8Al"
"AQQAfOay8bcuBABmCaBAyRUAOsOZ3Z25g58zAvsQBMK7wTmCgCgpBRAAUE8A7wjQkwJ7u7H5"
"n6GJAgIALisQAHQQAKDofwsCwGYFABsQADY0swFgbUM+BkSrgBkA1pgAYPcAVH7lN8M97BHA"
"SspHnCOAzwDgfxkA0MvdKGAFDxnlaIPqDZmtALLbyzZALgEYJ4EtAHB3DbCoPQBetswxQPMc"
"sNUMSCAwz54IYABQWYCv9Uigvg/gZi8A9wKsV70AWxQA7FQAoEcBoxyjpd6yAAAgAElEQVQA"
"4G4PQKp9B8AFALQMCHAeASKDf+QOAEzluWYAHjrNX+l+tkgDwPeqBGACwJ1UEQNAMpu+JYz6"
"H95IYPN/+B2a//WD8IDNPwbuX0Xz/wbN/+twBIAwif41AFw2AWADai1CwGoEAG3+y+HWSart"
"o/nnL4abuYsQABYKAGDET+b/beZs1CzUTLiaTpqNhj8Lrp5AZcyGrxEKvkZQYGXMxY/PE6Uv"
"gGsnFuBzIT5RmQQKCAisJfyedP4ARvcRw0Xhn4vp7/0YzR4Nf/cHkLfrPcjd+S7k7CCjH8DX"
"57LI2DdiNL+eonna+teLF/zw6t81Squ78SGgVD4E1BGSl7VFY2mNBtMKkjC6JyUGvAHH0PST"
"0PCPzm+CBtYIjs5tJNH+nIZSM6faOZs/Gj/t4PdWUf/06jyHT+ZPaf/oCXSwB813dFk0/zIQ"
"PrYUGngJ2D+qBOwbJQAQNlw6+/cMexWh4BVO84eNeJHr/rvJ/IfaALBv9AsQPgY19kWIGP8y"
"Gj8CwKRXGQCiJkopwIKAKQgBkxACEAToGe2Jvw5UDIHAZIGBWMoIIAjEeVeCeJ/KIjL1Geqp"
"3rPZ0xN1yE9/riJ+Pcq3En68Iv6ZEAhUgsP0nFUZYaAywkAVOOqPml8VEhZUQwBABVRHc6+B"
"hl9TwUANGwQUGBwLqCHvEQQSF9WSLAACwPFl9RgCUjgDgFrRAE1fAcBKAYDUFZLudwGA5YUB"
"IC2kAZp/QwsEOAtApQBqDKRbAatF1BhI0wGyJrilZAHUqGAuPgkGnBmAfKrJWwDgyADsdgDA"
"XtT+rmjyCAFRPdD4e2H034tLAmz81CcQ3h3Ohinz59S/AgCK/ndqAGiDAEAw0hIBoIUrAKwr"
"AgBWKgAw9gCgT/TxkDPA9ZR//OojgPR6BgBPfjlHAV/1cIwCXj3Y4CJk0zKgrgoABjg2ARYF"
"AMY5YL0J8IspBgBMLbwHwLoFoI4CXUEI+GKuKwCwzIZAMxNgHApyAYBNDgBQZYAb++wpAA0A"
"3ACYYACAvgaoIMBaBayPAT0OAFQJwAIAR/Rvvc9XcCBNgAIAGgKMpwaA+1nWFABlAOz0PwFA"
"igjN/4fbFPUnim4eQwBIgAds/IdQ8Rj9x3PqX8x/P5r/XlQY3PsKzf9LMf+7uvZ/Sdf+16H5"
"r0XzRwA4TWn/EIn8tfnnLUIAWAjf5S6A73LmIQD4KwBA88+YiU8/+PaEH5q5H3yd5gtX02bg"
"UwnBgPRVqp8ohTRTaZYodTZ8leZvaA5cTpyB/9B9DAVo+KdRBWz670M+mf6uQSKqz28doKL6"
"fnKIZmNvMX1K36/vLh36bPad0Rw68wIbNv2gdmj6beA4mj7V8ZMCMMKnTnjUsQVN0fDJ9Buj"
"GsLhuWL6nOJH04/3q8uz9XEzKOKvjQZaE+LoEh/qABm/Fxq/Z2WIJvOfiOY/EU13TFmIHCvm"
"H47mHz4GAWBscYSAYrCXlvsgAOwbieY/4lV8vswKU01/e4ZJ6n/P8H9D2EjJADAEjHsRIie8"
"hFH/ywIAE1/F/xZlAhACCAQQAqJ0OUD1BUQTCEym0kBZbhSM8izLQBDrWQFivSogBKCmo6ZW"
"FHNHxfmo9zNsHfQR0dfHTi8v3+ddHmGgAusQfv2hGZXwz6wiHJ6FQDAbQWAuQsA8goCqDAHH"
"AlCLqjMMJC6qzhBAMJCwmMBAzD+BIGChvE9aUgsBoDYCQF2ENgSAoHoS/ZNWCgCkrpTon6CA"
"AQANXkYCDQDQvQEhqkEwRKYECAROrGjE4sbAFU2MjEAT62IgZwKoFKBGBRkANlCzHUXe1AdA"
"AEBrgjuoewFOAOhsAwBlAhAIBADesgBAJgJ6yYIgBoBurLNhNPdP5o/SjYXcAKi2EVL6f5MZ"
"/T89APAioMUVIMKnxEX0iZ6oVqg6HrID4FWPX3kEkF7PAODJryeNAna/EFGvwD0AvG9sARxc"
"uARwabR7ACDTv6SN3x0AzCwCAAIMAFisSgGBKhOAEPDNcgUCK1wXA7kDAF0GYACIKBoArEVA"
"KQYAnHAAQOYTMgBGGcBdE6DOAFjZASkh/PQwB01fK1ue920IkH0ABAEOALirMwAmACSg+R9F"
"HUEA0OYfZ5v/VYz8v9kH99j8UWj+d66o2j/q9hdb4DYBwKUNcOv8OpQAwM0zoXIBsCAQbhYs"
"hu/Q/L+jJj+M/L/L8YfvsuciABjRf4afQAAJAeDqCV+4luaD0b03fJnuA18n+8BXqC9Tp8NX"
"x73hStJ0lDe+x4+xfPG9Lz79lGaiZsCF2JFQwIb/vpyK3UnnYQeJ0PSpbp+DEX/2JqndZ1G0"
"zyt9e6q1vt3lIt3KLmz4qcEdIGVZe0he2paX4SSx8bdk4z+2AE0fo/xj89H45zbmSP+wv+qG"
"J+Onxj6K+NH449H0OeKfUVul+mtCzFQ0/6nVWAcmV+Z6f7SK/KPJ/MeJ+UeNKQ3hGPVz9M+j"
"e8X5uXf06zzSt3/Uazzet28UdfhTCeBF2Dv8RTZ/ivwl/Y9C898/5gWM/hEAJioAmPAKmv6r"
"XAogCIiYWBwBoDhETkEImIwQ4FkKoqcoCPAUEQhEMRCUhtipZeHAVASBaSivcgg05UVo7rFT"
"8elTjsEg3rcCfyzeRxQ3XX3P9LL4HuVdjj9+aEYFOEiaWQEBACFgTiU44l+JMwEJ86swBBwL"
"qMoQkKBFMEAAQNkBlSFgAAiQ7AADAOo4QkDysjoMACmhugTQQAFAwycDAEOAegbX5wkBBoCQ"
"hiob0BANUfoC6Gwwnw5epQ8HNZfpACoFPBUAoHZ2dJQAOvPc/pldnbh+zwBAmYB9XaQMEKnL"
"ALIhkBsEaWcA9Qns0ebfxTpDLMd/yPzbcfRfCAA2ShOg7gFwCwDGLYBdsgOgO+oND9czwL/q"
"CCC9ngHAk1/uRgFLe8goR3NU132LyodBVlsFAL0FAC4gAFzA6P8C1f7J/D9+PADoEsD/GADm"
"uwEAXQoINBYE6TsBK9VEgAEA1xyLgVwAIEqNAca7lgB4CuA4Gn6yZAKsuwAKAh64yQK4BQBz"
"D4Dr3v/CACDZAl4BrAHgvpL1YwcA3DPr/6lGBiDJAIAj8Mgw/wdk/tcOIACg+V8NFwD4ag9H"
"//e+RPO/QuaPkf/lLQoANtkAcG6NAQBBBgBQxz9G/tkaAOYgAJDxS+pfzN9PlD4DjR/NP82b"
"9WXydKVpaOpT0fg94UoiKtkLrqRMhS8TbV1Jwq9JQiDA5+VjU+EU3YXfPpBvwrO29hfTJ/PH"
"99kO888k8+dUfw+O+rX5p9FSHjb/dpASiOa/pLUd9dPc+3w0f4z2j80VHUHjJx2eUx+jVhRG"
"/dTVf2immH8sR/y1eLmObvKL8arGR3iiMeqnlL9L2n+CAEDUhDIQMaYkRv4leWY/fJwAQPiY"
"YrBvbDF8vgbhozH6H/UKAgICwJiXEQpeUqWAF/A9AsBIfI5+Xsx/HIqjf9QEAQDKAkRRGYA0"
"pRiaf3E0fV0OKIG/vpIoAQF6UnkgerJkCA4gEBzwKo0QUwZipqGmK3mXxSfKW97HeYvRx+LX"
"xE51L/p8PH7dQZJvOTg0qxz+eSIIzK2EqgxH5yEIIAQcW0iqqkoCVW0QCKimwEA+pssDSUtq"
"KgBALasNx4MQAkIUBKDhp65soIxfav9k8oUAgPoGguupp4hHBIMRAkghIu4LoLLAysasjFWN"
"LQjgCQE3AJC7kQBAlQFMAOBLgZ2ss8GysrcjnEYwKAwAXdH0u8lEgAEAsjhIA0AXif6tM8Qd"
"ePsfA8DmVpC/saVbAKApAA0AcgmwjgUA5jGguR+9GIY+0c3D/Q6AX20EkF7PAODJL+coIJ1v"
"pBGOah4y0/nmxlllNgkAvAVwWgPAe6gPxfwvkvl/gs8hjhKABoBxrgBgpf/1GWBvpRnqFsBM"
"6QWgUsDTAICWzgRY+wFWqXFA1QjIWQC9HtgEAL0S2AEAVhYgEc1elQK4HKDvAhAAqEzA/ccB"
"QIHdB+ACAKfAZRrAFH7fTw/VLQB3stYCSyngB84CGD0AtxUA3FIZgBsmAKD5f4vGfy0KzT8S"
"7lPdX6X/GQC+RFnR/xa4Q+b/xWYBgPM0+ofR//k10gB4JsQGgPxFcD1voUT/2fNQCABZs+F6"
"pnsAuJbuq8x/OlxNnQZfkZJJUzHKJ/OfApcTJ+Nzsrw/JrrCT0+UFz8vHZ4Iedv6s3K3vsPm"
"n7v9HTT+fvjE91v68Xsaz8vaKAd9MvnEr0T+J9Z25at+3NhHW+2C2lvmn7TYtb5P5p+AUX+C"
"fyO1HIfm3amjvx4cVKKRPkr706gcpftJHPWz8VeT+X5q9ptUibvsD0wm8y+Pxl8eoschAFDz"
"HwHAuFIMAZHjS2D0Ttv7iuPXFZMRvvGvSzf/WBrrewWfCAJjKRPwkjT8jZa0//6xlPqX6D9C"
"p/9ZCACTEQAmv84i449C0z/gVRzNHd970nsEAC8y+5ICAZQR8CzJGQINBwdQMdMQBrS8BQRi"
"fRAOvEsLFODH46aXxj8HFEJD9FT8uqnyPnYqfa6MmL9POTg4EwFgBgLAzPL4Z1sRDvtXFABA"
"JSyojKqiMgEKABgIqjIY6OxA4iIpCQgAoAJrKwCojeYuEGADQEOrAVBAgMYFyfzri+lT1mBZ"
"XX6mLqvHT/p4WhCpnpUR4GxAiEwIpBu9AdbVQCoF0HSAAgGBAGkEpAVBhQGgow0Auzry0h4N"
"AJwRCOssALD/LTgbIVmA81E93APAbhknPGkAQME2iv7b/o8AIMO8BrioAkzr96/N6BNvoZp5"
"SOBIAeSvvgOAXs8A4Mkvd6OALmeBR/Z9fibvAsjvYmQA3kdT/1DM/yKZ/6fK/IeiuesGQAMA"
"Cl0D9FKNf9r8fYoGAG4CdALAEmMxkBMAlttZAJdmwA3GeuCdbgAg2pgC0KuAE9RZ4OPqMqAe"
"CTROA983GwKfBgAKHgMA9lIgAQDjKBA97+da2QABgGwDAE7YPQAc/asSwE2q/yMAfHcYhdH/"
"9QMY/aP5X4vk6P/+NxT9U+0fjf9rjP6/2qUyANvY/O+w+W+E2xeo+c+O/rkB8LQCgJNLBQBU"
"3d8VAJTxmwBAqf90Zf5p0wQAMNIXecKXx6fAV0mT0PgnoslPYl05NtHSF0ft9+djhqDp92Pl"
"sPpCzjY0fHq/WYl21m+Wcb3M9b0gUzf6ofnT6F6aavBLCZHon9L+x5e0EvNf0BwSF0itPwEB"
"4DCbP2p2A8P06UlLcmzz5yY/AgAyf2X8NN8fPYXMX0X/dJZ3cnke+YumsbsJ5dCcSWV4SU8k"
"QkAULeyZhJqIUfmk4ty0RzV7St8zCPBo3ysWCIQjCISPfQn2jXlJAGD8S2z+EROU+U8W89cA"
"EI3RP5l+NJp+jBcZP2oavp9WHMGlhMirhPV5MX9RDEJC7FTUNHw/FYFgGgKBdykEgFL843h8"
"f2B6KYjDj8dNL4nGX4rBgp4x0+VrY3zK4J8XQoAPQsCMsvjnWk40ByHAvzwcJSEMJMytxOUA"
"zgQEVBHzX1DVggDKABxVYEC9AklLEAIw+k9aVgvNv5YAAGUBgqUXgCHABQBUE6ACgFQ0eTJ9"
"BgBUSqAoTcFA2jIFAygNAOlqnJAnBFbKzoBMXQpYK+WAHAQBgQBKvbcRANhWGABEHWRj32MB"
"QEYCNQBwDwDfDjABoHMhAKDsAwOALgGsb46/puZupwAKAcByBIDAiggA5aFnw/+e7WEvAaLA"
"kZYAUSBJAeUzAPj/CQDoUUBzF0AjVIdGVf5zBGTSOuA3VQZgoKT/L34k5n8Jzf/SZ6hhSqoB"
"8IsxyvzdAYDnYwBgln0UyJoCmG/vAXBZCxxolACWGWUA41qgLgXQSOC3ejPgjiIAQB0EunNI"
"egHu6mmAJNeGQGsk8IQDALINAMh37QF4ZNb+HRcBnVMBDAD5BgAo3ddSB4GKAgCjCfAhAsDD"
"m9L1/5DT/woAyPwZAsIRAvZZzX+uALAVtUkAgMb/LqjmP5r9P40AcNIBAGYGIGsOapYBACr1"
"f2IGXDvhA9fY/Kei+XuxtPlT9P8liSP/CWjySgnjLV1OGAeXj4pOhb0LuZt7o/qg2b+NQgDY"
"0lee/F7MP2tjbzZ/Sv1nqNQ/j/StfpOb/dj8l7eH42bqnwGARvnE/BMs82/I6X7u7CfT1wDg"
"J+N9AgAS/cd6KQCg+X4LACpx7f/AlIqoCqKJ5SF6Im3jK8tjeNGTSqP5l1Zp95L8jJ5cgpv1"
"IqleT3X7CQICkRNe45o+iWb9w8e9LIt/KPIfr9L+hvlz5D/ldfz1FBNNRQDwKmEb/jSBAPq4"
"CwhMp4+J4Yvpqyf9GA0+1rck/r5FsWjwLJ+SEI+fYwigr0cAIBiIQ/OP9ynF2YJDM0uz+R/y"
"QwDwKyeiLMBMBQCoBMoCzKuMAIAKqGxDwMIqrKMk+hhlCAgAllL0L+n/5CDJArgHAHvmnwGA"
"Tb0eA4CYfh3L/EmcCXAAgO4LcAEAWha0ggCgiewI4I2B7gGAVwRvp7XADgDYbgOA7gF4KgDY"
"b/YAqPr/DrX9jxsA3QNADskNADh7AAgAUhEAkhEAyr/0mzHoE509bACgDLIGAL0E6FkPwP9S"
"AKCXHgU0zwJbuwBQfWUZUGeAUz1lDJAzABoAyPyHKPMfrqL/pwGAaUYJwEfGAF2mAOYYewDM"
"RUBm6n+ZMn5t/kHGaKBaE8wLgvROgM32PgC3AKCWATEAoO4ekSzAPSMLoCcC/q8AwMknA4AJ"
"AvdzLf34fa4AwL0s1QiY7rYH4OHNY6gjCADxCACxcJ/T/5FGBmA/ai+P/n2v6v/3aPSPAWDz"
"YwAgFAFguQ0AqgfALgHMMUoABAAzlPn7FgEAngYATIEvkyYr8yfTJ7Mfy7pCzyNjRIdHs8Hn"
"buwFuVt6QzZG+Nmb+vClupxNCAP0Ho2frtdlbcDIf52q+69Vdf/VXSBt1Zto/h3Z/FOWq+if"
"R/wk9c9Nf2T+1OXvL+YvG/zqFQYA6vQn838CABygDIBnJRbP2JMmV+DlO7SEh7ruD0wpg19L"
"Ki3pdi8Rp+EpXe8pEBA1CSGAtvpRHX/y69LhP+FVnvenqD9igvxYav667l+Mv55+DjF5Mnxl"
"4kpk9vTxWG+SMn393ls+HkfP6cVR+B6NniSfK84fj5tegn+uePx5SAQMlEWIoY/5CADE+5aC"
"Q75l4PAM1OwycGQmSWUCFAAcmVsBjs6vgBE/QsDCShYASClAIODoAoEAnhZYXJ3T/8cDJfWf"
"HEwQQOZfVwAgRI0EosT48RkiewJSVOqf0/8WAKCWilIJAgIJACQbQOJ+gGB7WVCGmg6gkkAh"
"AHBTAiAAyNuOxkzCCJ1hYEeHQgBgTQHoHoCfAwAKMLj+v62tDQC6BOAOAGgREAHAWgGArLWy"
"CdAEAPSHAR4CAHoLIGWQzS2AegfAsz0A/4sBgDIANLP5Lw8BALrnTLsACADevpXQ5Fu+B3Cy"
"h2wCvPgBmvhHRvT/ORr3cIn+vyDzH/10AEAZgMsU/fu6AQD/IjYBLlbrgAMdABBsm7+VATAB"
"YJ0rANBGwBvqMNDNiKcAAJUFeCwA5LgBgIKnzAAYZQANAFoPtPLkaQFAjtUMKLcA0h0AQBmA"
"BAGAGwcNAKASgG7+288NgJQBsAFgJ9ylBsCLm+DOhY3c/CcAsEaVAFa5AYAlPAVwPWehMQXg"
"jwAwW00BzHQAgC4BTGV9newlOu4lGQANAGj+VxLGKgAYIzo8is3/YuxnkL25J5p8L6XeBgD0"
"UQAg5p+lU/8U+atxPzL/1FWdZZEPmn9ycFse90ta3BqSVPo/QTf+KQA4igBwlDMAriUAOpxD"
"V/TY/GnBjwkAXtVkva+q/x+YUhk/VtkGAP1E86eZe5q/P+CJ5u9ZVj3LSNp8ammI4jp6KRSC"
"gFdJrtdTep6eUdTEN0mBwORX1by/EmUKJirzR0V7Sto/eqqY/wEyfm9RHEbyFLnHKlPnqN5H"
"Ps5SH49XEMDyVfJRT/44QQDCwFRVUuDSAkKAN31vSS4RHPQmACiNAIDyK80QQDo0uywcmlMO"
"zR8BYB4CwDwFACjOAqimQIaABVWsMgABQKLqASAAEOOvg3+3daQHAH+culxBgKnlamMgm79E"
"+iYAJC8RCQjg5wkGVHlAegLqW9sET6xo+H8OAKz2kv7fpQDA3APwtADADYCdZeyPpbb/bVYj"
"gDSRQLV/BQBcAjBXAa9t4LIKOIsBoCoDQOycMt96CADQGmDKGFfxEACgDACVlM0SwC8OAc8A"
"4OleRGiUAaCZTVreQABAyxxoqQPdd+5zPrz+SV4HfLK7HAOiDMClwWL+XwyxAeCLEcr8TQAY"
"rwDAeQp4ug0Al33VKmBV+9cbAV1uATjG/1wAwBgD5CbAUCh8JnidcRxIAYDOAtxUkwCFAECX"
"ABLtXoDvjWmA+xmPmQIwAeDkUwJAgRsAKDAAQOl+HvxIsrIAJgCkqdW/1ASoMgA3TACIVhkA"
"AoD9CgB0D8AeKwPgCgBk/usUAKx+LADczAuAm9wLMF+NAfobi4BmwrUMBQGq+1/r65RpKAKB"
"qQgAXpIF4Dq/zgCMUwAwms2fdGb/e/gPFQLAJhTdqGchBGzpLWn/zXb0n8Xp/x682Cd9NZr/"
"SjT/lZ0gdUVHPsdL5p8cRNE/mb80/yUiACQtlPQ/j/75SwNgwhwR9QEcniVZgDgV/fNaXzXy"
"R/V/7gGYSpv+qgkIeFXlpT8EADGeBAKVRJMlCxAzpQKP0sV6IQzgM2ZaWXyWk277aTR+V4Yb"
"7qJ14910hIFppJIKChAEJslYX8TkYhDBUFDcekZ6Spd/lKrnU0qf6/FowrE+Ur+Pxag8fgaa"
"PIqe8b7q6Wd/jAHAR5k8iQGAvhajfV80fZ/iDAOcDZhGKqFUkp8ED2T+B/G/d3BGadEsGwLI"
"/A/PKs8AcNQfzZ8yAPMro9Gr6N8AAKspcFE12RHA9X8CgFoCAMsFApwAkKJMn7MC+DF6agCw"
"0/4mANSGFIIAVKqVDagr5YBl9a09AQQARZYALABwLQFoAMgnbVMw8DgAIPMP7/pUAECpf077"
"U+f/Voz+ef6fRgBbugAA9wBsJDWVY0DWOeAG6iRwHfy9qAzA0oqw06vYKQ8BgI4eRWcA9Bjg"
"Lw4BzwDgyS/dA2BuA6QlDrTMgTIABAC9YoMrx0EOAkBBNzcA8LkSmf9INOwxYv5fjC0MAOYi"
"ID0F4AIAs+30P98CMK4Bcv1/iV37ZwXZjX/fGBsBXa4Emj0AzlHA3eo8sCoD8C6AWDc9AO4A"
"4IRMAVjm/3MA4PRjegDka9n4C2UA8q1eAAGAPMkC3MtSFwFP2FMAt46jEiUDcOMwPPzuUBEA"
"sE8BQJgAAPUA8BTAFj78wwCg0v+3zzsA4FSI7AE4GcgAwEuAeBFQgCwCQulVwJQJuK42AV7j"
"RUC+vAfgKk0D0A6AtOkIAKjk6TwJIH0AutlvPBr/eAUBCgCOjIaTu94R87cAoLdE/1v6KABA"
"499E5t8To5eekLFG5v3TV3VRm/0EAJKDOoj5L5PaP0X/SQHNOQNA8/5c/5/X1J4CIFkAUF81"
"/9VBQ6xt7/anDABpqoKBaTV4AdABtfkvBkEgdmoVNPpKKA0CCAFTMbLyRE1DGJiOT2+EAG96"
"TzP0CADTUQQF3vI+1keP4JVWYFDKBgFWSSkbqB9He8nGP/oa+lqrcW9GGVRpiPMrA3Ezy7AZ"
"k8j0D1KNnlVKAMBPjF4i/uJ21K81oxj+uosJGPgYmQA0fikLoPn72GWDg76lCgMAjQPORvOf"
"RwBQEf8uUPOlByBxkV0COLaommixKJG0tDqaf01IXlbbBgCt4LpuAYD2BCQHydIgs+nPLAE8"
"LQBYTYDW2WDVBGhMAeSsJwBozfsA6EpgHhk0qRAAdHgMAHRTUwAyBng+yhUAzuj5f7o1sFUD"
"AO3+b83/bU7/uwBACz4GRNcA6RxwzkYEgA2N8H1DFEFAXcgyACDgk5cPoj+842EfAtIZAAIA"
"mgLQewDIY35xCHgGAE9+0V+EuQ7Y3AZIW51ou1OvPQsr7OV7AAQAZ/q5AYChaNgjJf1vAQCa"
"/xfjFQDQCCBG/194GnsAzDFADQDGCmBe/qMBwNH495WZ9tcpf6Pxz9IqYyHQRuMokBMAVBmA"
"VgIXAgBnCeBJAJBTxBSAOQJ42gEBJ8FlQVCRAJDnBgCkFPDDvccBwBEFAHECAFel/m+l/78J"
"szMAJgB8sQnuWOl/BQD6AJACACsLUEDX/+gA0GIGACoFkL7Nmo+mP58XAhEEXMtAnZglmwDT"
"aRzQDwGAtgAiBKSIvkIQoF0AVAb4MlEmAC4nTLCb/44IAORuUal/NPocDQBb35bGvy3SA5Cz"
"UQEAKnOtrPZNX6PH/tQu/6B2+I9/G/zHX0b/kmiX/wIFAAuaQQJpvujwXDrh24RhgEsCvPWv"
"Ac/+H+LlP7V58U+sj1r3O01gIE6J9gHE0U4A72r4viq+r8KHduJoxz4d3fGiZyWIn4byroxG"
"WQlNVTbsxfogCHgjCPiWx4+V56dWjE85gYJpZThLEI1PGrmLpve0zMdLaVpp9XHKHpTmLnyC"
"iFi/shA/sxzEo/EenF2WFT+TjFiMuRAAzMAofkZxAQA2/uIi/Fis9+v4eypmZQfijXIAg4AG"
"Aw0AlAWgZkAyf/zvHJ4jPQBH5pSX2v9cNP+FSgEVGQASF1VBVUXDV1qCAICiZ1JgDfy7rFUI"
"AFL5iaYd8nMBQN5bJQANAI4SgAsA6D0Aa+RSYPZaewxQZADAFgQAjszbCgQ4AMDqAXADALwH"
"gBcB9XIFgH0EAGr+/0kAYI4BEgBsRvMnbWwCuRsb4Y8RAFDZGxEA1tSyAGDWgOcj0B/6e9gZ"
"AAIAfQnQCQBOCPh//noGAI9/6b8I+osx1wHTFieXdcCf9vrXfAaAfFoG1Ff2AFw0AWAYGvco"
"JTT/yxj9XyYAmCDS0f9lL8cBIG83AKCOAOkDQBYAGGl/l8g/xK4PsfkAACAASURBVA0ArLLN"
"/5peBuQEgN2FGwFdMgCHigYAfRnwgVkCyHIDAHk/AwBOugGAAgMACmy5AECeAwDSDADQTYBH"
"FQDEIwDEYPQfbQDAXgcA7EYA2G4BgFX/P69KAAwAK2QK4IwGANkGyMpbyhAg/QCyGOjbLNI8"
"BIG5cI2uAdIxIAUCV3n9L63+ncH6OtVXgYC3lAKSZCLgcoIrBFyM+5y7/3X9n+v91P1P43/b"
"1B6ALajNfREM8HMbeltlgAzKAqxEAFjVGVJXyOU+3vEfiNH/Ukr/t2AdUxCQuECAIIHfy48t"
"OGAQaAyH5jRCw1JbAHnvv0wDcFaAywO1pEQwvSZvBeTTuj7qqh4+D9JlPe+q+L4Kfh/t0Zdj"
"O4fwx4fwfRzt2sdnLAHBDNRMBAW/SkoVMHpH+dITgQBh4ACCAmcL9FPLu5ylWO9yAhS0uc+v"
"PBo+alZ5ODinHKfgCQYOzSqDhl/GAgA2f5UBsAFAid5j5B87XQHAdA0Axe0sgAYAhgIBgEO+"
"0gdA0wCH8b93xB8BgOr//uXxz7g8/rlXwL+PSiwCgKTFVVBVXQAgCaN+ivzpaQEANwDS7L8o"
"NYSi/7rSAPiEEoDVA2COAaqon3sAAus+HQCslZsA5h6AIgFgSxt+kgoBgOMYEN0CcGYAXEoA"
"TgDYZgDAZgUAm1paTYB8C2CjkQEgANiEALCpMf7/qKFAwKZ6qgRQlQHgzbq/X+whGQACgCYe"
"rlMAehMg9Zf9l4cNAL8YBDwDgKJfZirG7AFwCwBvtfizLx8EyusCcPptWQX8RADAyP8yRf5G"
"9H9Zm7+K/Dn97/MEAAhQjX/L7N3/XwUb434mAJi3AMxNgBvVIqCtahHQTvsssNUEaPYAHHxM"
"E6ABAIX2AGQLADwwIKDQFIAJAEo/OnoDHp1E4z9pQ8BjASAXfryXbQCAagS8JRAgY4CqDGAC"
"wLVINP5wNH7VAMglgDC1DGiH2gBoNgBqAFitACCU9wDQKCAdA7p5KkjdBBAIoHPA13kz4EL4"
"lpSjQWC+KANB4MQcPgr0tYKAr1NnshgGkn3hyvHpvPXvSiKCwLHJcCVhIjcGEgicjRgsALCl"
"N/7D1RsOzu8E+7zb8TKgvF2DWPmsdyF31wDI3dGfwYAXAtE0AF/16ywlgOB2UgIIag1JS1rC"
"cYSApCVvqFLAG9IPwNsAUUtb8dW/5MC2NjTg9yQuaoGm2giC+lSGwN6VuFGQFwT51UPDlgVB"
"PCXgUwtNHkVAMINUEz8uOuSHT78aaPjV8D1qRnX1vjqfzz00qxqaclWMzhEU8McH6f0c1EwE"
"hFkIDvT0q8yAEIMwEONTHk1fyRvBwJuyCOpJmQN6j8BAXx+PQBE/qyI+K+DPXQH/GwgCCACU"
"BYifUQYNnsoBCgBm6KbAEjYAaPN3AYBi/DGJ/IupiQEDAKiPgMzfj6L/MgwbR2gSYE4ZODrv"
"CQCwBE2fov2lSoFi/I8FgFCJ/tPUBAAfCFJNgOYUgIwB1rP3AOj3egxQTQFYI4EOAOAeAL0I"
"qAgAcOkBUACQRwDAkkyASw+AWwBw9gD0sFcB7zNKANwDoPf/t+UMgPQAqDFAfQzIHQBsJgBQ"
"WYCN9XgKID0YAWBJBWhQ9je0A8AsARAA6EVA5CWUVdZ9ACYE/CKlgGcAUPRL/+HTX0ZRAEB7"
"nQkAaM/zR3wPgHYBnOot1wAvqikAtwCA0f9ljPwvT1LylOifAOCys/avpQFA7f63AECdADZH"
"/L4OMZr9igIASv1vUOa/Wa0C3vaYVcB6D4ABAHeKmAJwCwBF3ARwBwA/nlHSAHDKFQyeGgBy"
"7R4A5ySABQDHjDLAQQQAtQL4WpS6AWBPAdyztgG6AwBdAlAAcJYAgFYBL+dTwHwOOB8hIH+Z"
"iCAgbzFnAb7NJi0SENBCCJBTwP58HvjrE0qps+Cr9FlyDIjuAhynWwBT0fg9GQK+5MVAE+FU"
"GO3578vz/xTle3YsB43w/57NUPg/Wmj7Hx7QHtXxPz2gw3+J2qIGVX+RFwVlrO/JvQC8/W95"
"B/yHvy2kEAQEtkG1VhAgIJAYiE/8WOigWlAff+4mv/GA5vhzv4E/d4vf4n8Tn01RjfBjDfBz"
"Tf7bg8sGdAqY7wPMkpFBgoA4X7kPQDsDKEtwcBZqdl2MuOvC4dl1MAKujd9TCw2/Fv4YnzPR"
"/OfUwPeoWTXVswZ+j9Ic/Lx/dXxWYxEYxCEYEAjE+iII+Cjhe84e+BIgVGVgiENgoNO8B/E9"
"6dBseR6cjR+bSdf6EA5mlsPvKSOaUQqfpYxJAKMHQJu/AoCYafgkEQTgMwafNAmgIYC+J56b"
"DUtJ2p80u7SYv39ZODq/HBydiwCwsAIkLKxYGACWVsW/p+oIY2T4CAD0XFYDP4ZaVrNoAAit"
"J7P/Kxq4jgFauwAa8npfvQnQZRVwkGH25h4AljoUFOoeAPQqYLdNgAgAuZb5uwIArwGmWwBP"
"BIDufB6YswK0BIi+xgKATtYYYMF2nQUw9gAYAJC3qQWXAHI3UymgqQUAOZulB4ABIKgqXwJE"
"XxjqYQMAZQBqeNirgE0AIH8pCgL+n72eAYD7l2n+GgD0GKBuAtQ9ABoAPryZ0Ow67wI4ScuA"
"BskmwEufyBSA7gEwAeAKAsAVjPwvTzHM3xj9uzwDPz9DnqxZEv2bAPAVRv9X9M5/XesPtZv8"
"+BlqaIVxDlhv/9OR/1Y31wD329cAbx74mQCQbgCA8yaAsQ/gUd4TAOCMAgAjI/Do1M8AgGz3"
"AHDbBICjqhHQBAA6AhQpJ4D1KmBWmCwCKlQCWOPaA4AAcOO0lABunkQA4D4ADQGovEDJAuQs"
"RsNfzM/r2YsVCCAQZC7g3gDStcy5aP6odH+GgK/S50gmIJkgYAZCwHS4kqgyAUlT4IuEyZCL"
"Jp5Haf5t/dR7jPx3DoTdnu3h80bFodPvPKDbHzygB5px7z95QE9Utz96QGf82IqPW/DGQOoJ"
"SKerfyEKApZLJoCie4GAVnz6l5SC0X7X0n+BpmjwrdD02+PP0/mPoo6otvjjBd3RoAPa8TZB"
"yhQkBjTjS4G0O4BOAlsrg/8/9s47LMoz6/+z2exmd9P7phcTe+8NexcVERHsvfeexNi7AnYU"
"bFhQQUEFOwoKSlMBAUHAFpOYmFij0bx59z2/7zn3/TzzzDCoyZbf/iHXda77YWYYyuh8P6cD"
"BuLn15DP4xfAFtakBD9l8X41IILV4AmzVRWL59OvKgQRUABL0Gf8wsrK5lemY/6AhYAqdDSg"
"Mh1dWAnefEVAQAVAQHl4+eXEYnEdh9viABVxeMwxgITABa7j8XXx/jj9KtLBGWXo4FROM5TB"
"40vga3mu/ydqch9P9tOtf2Zunyv9XQHA1PcBAbCpFgCYpiIAqrPAAgDzLOIPO8EA4M+evyMA"
"JC0tAygrh9enggkAYqsg/EGV1bkKALDqIQCwTm8E1CBw2rIg6PTaOmpdsLkLoKZ9NLAW/NOr"
"ainRlwFA2oL02mA9B8A+CtgRAMxdANwG6AoAdArgoQDgsgvANQAYbYDWQUDmLgCOBGxj02mA"
"rbBtgIAwiH9YEQCwrhKlrSxHh+d9ehO6MMymAIDnAPAoYAaA4lpDeKYMtwJyGsAKAf+xVMAT"
"ACj8YQ29GOJv7AJw7gIwUgACAAV7a55XswA6WqYBDrTMARhlLwIUAPgc9qUyBoBvIf7fwvP/"
"dpYW/znKvtH27XwXAKDH/nLB37U1hXP8cm30+xu3b9A7AELtWwBlB8AOx02AZvX/QVX8Z+T/"
"H5oCSHUxCdC6GTDrNwLAeQ0AhvjrzwUALBDgAAB6DsADV3MAnCMAya4BQNIAMQCAgxB/eyrA"
"AQC+DXcsAnQAAM7/r9VFgEEKAs4FSzRA6gFyceasopsMAdkrIP7azq6g6zmwrOUKBDIBApmL"
"AQCL6PtMf/ox3V9A4BqfgAFZ/csrgE/Ppm+TZ8lmwKsAga+PTaDcyO5iOTzvP7Ib3jRhkT0p"
"d3dvygjrRW0AAN4Q5s7P26jbCzbq+pKNuuDs+Byui78g6YHMMB9K3+CBN20LBAS1kKJAiQZw"
"iD+omdQIrB9QUzz/xk9D8CH2ngwV/Hwv4hrnsDofUc529Xy8UIgBInFxI3iy9SHYddUI4YW8"
"KriW2h7oV1uiA7JQCNfHA+rIOuEE/1q4roXTgAIAwcLquK86nfCvgbMm7q+pTtwnxo9dhK8T"
"w+2LAA/+1fB9OJJQiWJhcTC+5uhCPADj0MzKtGFgcZrT7i2a2uINmu/5Dm0eUoKWdPmAmuFt"
"buNgCPP88lJjECfpgk8h3Hq0rx4GFOsAAFYIUCkAZwBw8P5nf0xH5xQTi59XjBLmfWoCwAk/"
"2KKSjgCwVIl/0rIy+NuWFwBIhcefCsFPDYIFQ/SDIfpBxllFDQAKNoS/OsSdvf+aLgGART+N"
"1wOv46U+aqLfaWMvgIttgGnGauDVaheAfRKgIf5uhXYBmACwpYksA7LPAbADQK4TADi0AfIg"
"IJddADoFYAEA6zIg3gVgLAOybgPM294MEMBFgU0UBLCFAQLCG9oBQNcAZG0xAKAynQYAhH/5"
"8UWbAgAuAmQAaGBTy4AYAN6zqamyL2ld4XkA7GT+2fYfTAU8AYDCH67En6mMXyCmNaY2fvGs"
"NQACAMc3VjxJ2a4AQA8DkjkAo10DwLfw/r+F5391ll34v51rsXm68t/PAgCLVO7/6grd528s"
"+DFEPsQCAesd+/1/MDYAbrMX/l3XhX83dmsAMIr/9CrgO1r8C40CfhgAWCDAJQC4qgHQbYAP"
"BYAC+r9fXQGA0QZ41jIKONOyEjjdAgCp9i4ACwD8Ip0Ah81aAAUBDAB7XQOAzAHYBPG3dwHc"
"Pq8WAd0uCNYRgGBdDIjbznFNwBpVG8AgkLuabp4Nopu4vpm7SuxGThBgYCVdz16uYWA5/Zi1"
"BCAAGMhYTNcyAgAC/vRdmp+ykwvou1TAQOpcWQl8+cgYOhfZm3IjesF6yibA3AjO8+Pc3Yvy"
"9w6gPhXeEADo/dEz1BPi3/NlG/WAdYZgd4B4B3jXouyIbpS5lVMBBgS00pEANRb4ZFBLOoWT"
"b/cs/iLVf8pGXh8/S+3x9Z0g+p1fUuYDm9y8LOVEdKG0TZ4aAJpJ7cCJRWz1KCHADaJcVzoI"
"EvzU5/F82yI3Or64njJ+HOx4QF0FBAEAg0WAgkXqPL6oDp1YwlZX2WJliUvdKHFZPYhjfZyw"
"5fUpemoVOjS7Kh3zqyGCH+/HUFCDwkaXpUHlnxWRb6GtJaw1GwCnjbatw8rg8VWk3iBWug+K"
"y2IfNmNaILf0SVufCQCwWRYAkDTA+5ICUGDwoTk0yASAuSz+n0ju//jCT5X4+5fA76UAwEwB"
"LGPPvywlrygL4Yf4r6qohb8SvPvKdHINBB92cjUbL/4xlv9ULxIATrkAgDTe6LdeTfJjgT+t"
"N/4ZEGCuA15jXwdsbgNcW1dMbQOs91AAUOuA7QBgFAFaAYBNFQG2kl0AjgAAkd/v6bQN0FID"
"sBcgEOWJx9vXASszxgG3BACooUDnwpviezdWFv4QANhcXXYBMAAEjXgnzaZSAAwAbW0qAsBp"
"Y54h84FNFQJyGoAnzD5rs0PAfywV8AQAHD9chf75hWAqswIADwIy5gAYANA3bGGJGDULAABw"
"obsdAGQZkN4FwFGAQgAwWXn/V2fC4PlfnWMX/avzlbH3L4V/Tvl/zv1fDVS5f3O5jyH0G+wg"
"YFb7h9oL/qzib3r+URYz8v8xSvzv6D0AJgAkOAGAq10AzgDgnAJ4HAC4YAcBKwAUigAYbYBn"
"LbsAMp0AQA8CuuvUBiiTAI+ZAPCLGQWA/aDaAhkCfpYoQJRlF4AFAC4yAIRo8V8rq4ClCDBf"
"FQGm7/yCgoc0pbXDWtCRVUMoectnlBU9ne7kbwQMbKRb+RsACCF069w6usmWswYwsBZwsBow"
"EAwYCAIIrKDrmYCBzGWwpfQ9YOAHtnQGAgUF359eSJdiRlFBVD/Ki+qjIQC2swcEGDCwqzcV"
"7BlAg2q8R14AgPWDW0kEgCGgFwCgO8zneXju7/yB0rZ0kbbB9E1eAgGqNbAN3uzd8WbPLYI8"
"J8CdIiY0EO9/QI33yc+rugCAD0Ci20vq+Ti68HmjEnRuZ3fK2NRBognJK5rDY20C8WoMawiB"
"bwBrCOFuIJa4FNdL+cTnyxpBuJWpa9zO2wflsW4CBsdxJi6pp75meSOK869Hq/uVoenu79Os"
"Nh/Ak/+I5rX/iOa3/5iCepcSUd88vDwe76ZAAcCwpPPH1FwLPUcuwsZUh5A2pZRVTQALdWlM"
"zVfI44828gDohI3iCXvVpfjw8MzS8Pw/1ct8eANgMQ0BOqTPEDDTAgEzP9AA8KFAgNENYMwL"
"4BbCozJfoJhU/ifo4j8BABb/ADsAcARA8v4Q/5QVHPovB+GvAHGH8MPrZ/E/tQa2FsK/tqqA"
"AJ+n1lR7OACs1euAdSTABID1SsB5rW/aWhUJkPtMGODrOkr0RfD13P81yutPX+dmev8mAFhT"
"ACL+TV0AQAt7G2C48v4FACDWbK4BoIN4/0YboEMXAINANAAAVhClJwLKYiDeNMgjgTkV0FxD"
"QFMVBQhnAwRsdw0AMghorQKAGV3fiLXZIwAMALwOmNPGPEWWZwFwHQBHlHkgEEcBrKmA/0hX"
"wBMAcPwoyvtnKuMXh18oDttYRwHzHAAvWN/x3f++QQFABzUOmGcBXHYCgCt6EiB3AUgNgAEA"
"0y0AAPG/yuK/QNtCbVr4v7VM/vt+hW75C7bk9nVfv+ntGx6/Rfil4C9cF/3tUOJvAkC0xfs/"
"4AIAnLcBJv4GADjzGACQ/xgA4FwDYAi/YY7rgF3uAngEAAgE/GhAwEHXAGAMAvoK4n9xA/3E"
"3j+vATa6AM7rWQCw/Ng5tKR7XRFX/IOhzhCSbn+C8P4FIvmMjU5HzqQ7F7dR3Nox5N+1Hn3e"
"oAR93rAkfYZz/aj2lHdkIaBgHV0HECgYWEk/nFlOP2QGAgYCcR2oPj+zjC4eGkUX9g+D0A+i"
"vN394PUDBCJ7ScV/zu7elA8AGFjtXfLE903aABio+KoJAT20YHs9Z6OATrXxNd0pc6sPZWzu"
"gDfs9goCNAik4eRtgX0AE+z9R3zRnBYCADwAFp2eVwBgRBYmNS5Bebt6AQC8ZLcAdwoIAFgs"
"cQlsWVOxlOXNaNvo6hQysDJtHFSFdoyrCSFuSSlBLST1kLyyKSWtaCxiz7AgMMD7CVY0oRnu"
"H5AHvr87hLwDfq/BlV6kYZVfoi6v4nP83T1h7WFheM7kVc2ktXHHhCoCBe1we4en4eGPhpit"
"cYcHzRMQm+D7cXdDExpd8yV5zJbhFSSdwJ0HsdNL0aGpxWWNr6wInqohQCb7GZX9aj/AYVwf"
"nvGBqgEwQv6wOIv4x821i78dAIoXBoAAAMBSAMBSDQAQ/5RV5SDsFQFZlSDqVUT4xdZB9NdV"
"w7Vxqra/k2KFiwBPWQFgHYs/bL0FAAwIWKejAaa3rzx++8a/unSGRX8dBD+knh7+YwWABhBO"
"Xf2/pakDAEgKwGwDVMJvnQOgAKDFwwGAQ/8HvZ3mAHRQZ3QHOr+HowDtVSpAIMAdENBKigL5"
"uYsEAIkC6BqAbXVkEBADQMYaAABeBx+3v22xKQDgSYC8DbCR1gzeI8MbAd/ResLtgOxcWlMB"
"/5EowBMAsH+4yv3zi8A0xlTGIRrO1/AAhw9t6kU0RgEzAPTp4f7SKsriWQA8DKgr0aXeCgA4"
"BeAMADwI6BsDAKZYAGCO3ev/DqL/nZ8yFv/vjHn/Rtufzv1/pyf8ifBvsFf3s+hLlb/2+iXX"
"D/sxXJmE/S09/0bbnyH+1uK/O7HKWPx/ilfif1dPAZQJgI8CgDP/RgDI1euA7auAHQDgZxcA"
"wHsACgGAmgb4i2wEjBV78OMRbYfowbUD9PO1vU4AwBGAUAAARwDUEiATAET8rYbb4OWfDJ9E"
"XSEw/SCSwyBSI+FpjoDFBI6lBR41qPdfFRT0wv29/qqsJ6w7bgse4k638kLpRt5GunJyBS3r"
"1YT6FnuevAAS3gwTf3+K/Hzq0KFF3ejS4XF44xtJBXsH482tP53b1YfOMgDsAgBED6B+Vd6i"
"tn+20eHFXWnHJE/ygdfeFT9PD4h2Nx0FYCE/HuwjXQFnQr1FvNMBAenrPCD+7eT68IJW4v13"
"KfcG5UR0o3me1cj9L7qWQAMA26QmJSkvqh9lbvGW9sKTq1pRyrLmIvQcDWBRD+lfjfpVe5Na"
"v6a6FRrAGhpdC39QXQs9Pv0rLe5SHgCilhSlBCkYSA5sQkmBTWlk7TepDR7XHn/jQeWep6Rg"
"T0rb1InSQ30pY0tnWtajEnX6s/p7RX5Rj1LXulNKcAsaWV159z6Aoi74e28ZBVEL8YRX2xqQ"
"ANgI5BbHhrR/Ri3q+ekfKWJsZSlIPDa3AkS+NACghBoqBAg4rNf6ymIf2SL4oRJ+Q/BnGK1+"
"9kFAakSw9v4BAMcYAOY5AYAW/8RFsCW6/W+ZCv+L97+Svf/yEPaK4vWfhvCfXqdtPYR/fTVc"
"VxMAOL1Oef0OALDa0gboDAAs/iEQfBbvEO3NCwTomgANAcaMf3ueX6/8Xcdrf+sLBJzZwBCg"
"pgAWBQBSA7BF9eNz1b85CEishUsA4G2AjwUA+7zokisAgPFzCATwkiGjIJBrAcI1AGwHAOxo"
"RDkSBaiPn80NpgFgEwAAf/vTeC1aVvrTGujCEJsCAA+bihbzAjkeB8ytgJxK5jTAq1pbOBVQ"
"VEHgv6UW4AkA2D8e5v0zlRlTAPkF4/ANrwN2AADYWDULwIOooLOaBXB5gNM64EcAwHfw/r9b"
"oMXfX1uAEn8u+DOE39j0d83o9V+nPX7DrN7+Nkuhny72kxPCf12H/jnvf0MX/t3cq0L/tw4q"
"8b99WAPAUZX3F+//hF3871k6AFyuA874JwHA0g1QCAB4EmBOEQBgF/9//Jz+EABwnAb4y42j"
"EH8FAQ9MCFBpAAEAaQPcSXfNXQAaACT/rwDgzvl1GgDW0m0eCFTAt3Nx4GZ4+eHUCyIzAp7p"
"xFcgjG8omwDRGw3B3DDam3bPH0z+HevSUDyGbdiLygZBlHfM6EOnI2dTv3f/SF0gtN1gPTiX"
"D8Hth/t74uyM2wK61aXLhyfQhQMjqCB6IN7Y+lEuIIBBgAGgb6U3yR0ieSDAly4eHk8DqrxD"
"3oCAzi8oAGDvnb34ya0r4ut6yRChM5s74g3cUyIBLP5nAAQDan8gLX/s/XPB4ez2lak1fj+v"
"ZxUA9DIAoGlpOhc1QPYPcARB1QHwdsHWtHdaQ+pU/HlqyB0EeK7PmxensLH1aRssZFBt6lHi"
"WWrLnjuEuyN+tw44+5V5DmLUgVJXt1GRAQDEsq5lJHzPj/PF4/bNbENntnalM1sg/pt9KB2W"
"ARBY2r0SeeMxkV82opPr2snI43b4vnxbT/wt++Fv0Pt5joCUo30zGskehOTAxpS0vCHEtoFK"
"QSxxk06EozMrSPtgzLSSEgWQxUSTi9GhL4vRYd4loDcTHtargwsDwEcOAHDUAID5GgCM/P8C"
"1fon4g/vP3Gpyv0nL9cAwKH/VeUpNbhoADgdAuFnCFhfXQHAWuXxKxBwGgRktAFqCJC8/wYI"
"/gaIOluImx0C1qvcfprp9asZ/w4AsF6N/GUIEADYoD6XNkAnABDjLoBQ/hy2rZkUAeY6dQE4"
"pwBMANijpwA+DgBE2wFAUgG8TlgAgE0BQN4OAMD2pk4AwLUA9XFbPTobbgBAVUoXACjLYvWF"
"TQEApwAMAKhlU7MAuBWQ6wB4HsDrWluMVMB/LArwBADsH64AwPD+mcqYzvhF4rwNT3JiAGCa"
"swLAmAenGt2ns+2I8n2JLloBYGjRAHB1qgsAgNf/PUT/+8Xa4PV/zx5/oONqX+nxNzb6bbIM"
"9tlaWPTZ079uMTPsv9sS+of43zS8fy3+t1n842DW0L8h/hD+e9z6p8XfBIA0yxyADBdtgNlO"
"XQC5j9EFYABAgSMASPg/W5kJAEboX3v/P2vxv2dsAkyxTAK0AkACAOCYEwCoOgCeCWAHAMs2"
"QJ4FYEQALqoUwJ2LCgIkGlAA4T+P+87zqmCGhXDqC3EaC0Gf8qaNZvzdRtNhs6q9QpdTQgEW"
"h2EHxTaO8aUxLys4+Ox1G42HjXpFQcHUJmXpyKrxdHrnPFrcrSkNwvMNxWMH4+wL8eoKAQ6f"
"hDfAmLF0ft9QgYBzuwfA+lPB3kE0tW058aj3zfem8wdG0f6F3uQBz9fnOXvuvsuLSsijZ7aX"
"IkIeJZzO44JhLP6HF7hTfQhuu3f/IjUGuRHdaJZHJWrxZ1VIyF9vBYC86EGUCZDgfQOnINyp"
"Qe50zL85PP4/UGP8LC3glft+9Fc6udaXMuGtZ2z0htB0pKTV3tQBUNH5bwpwejKo4GfdOKye"
"1Cekrm4L4XOnPmVekPC8z1/VY/y8K1J2eC8AQFdK2+RDaRsAHyFedCKoPQ2v9irtndGEUtd6"
"wNpJWoCBqv8L6m84ENbnefV9OuPv/lnjd2llr7J0bGEDSl7Bg4/qS4siDyaKnVFWFhQdmqI2"
"E8oo4S8/pkOTDADgKADOqR/Zw/4z9GbAmRbh58K/2dr7ZwBY8ImYav2D928R/6RlKvefsqK0"
"FP4Z3v9JBgAOQ68FAKyrqoTfEP8N1dUZUh0ePbf7Qfwl719DDwH6HQAQYqQE3CQlYAJAiJt4"
"+QIA2ts/s7GBFv36JgDwAqCsxwSAHJ7QZ5kDYAKALgI0AEDa/EwA6OgIALoOQAGAEn8BABZ/"
"sbYCAfk7CwOA2A4LAGwHAGwHAGxXAHBmIwAguCIdX1T6PvTgM5sjAHC6mAGgok0VkbMjyWkA"
"jirzlllXUYAnAPAfAIDH8f6ZzvhF4heM8zc805lfzGY2CwCci6p5ic7yMCAfogs9iS71dwEA"
"YwoDwNXpqgPABAB/BQDX4PVfg9d/DeJ/LdA+7OeaXu7zoksLXwAAIABJREFUg4uFPhLyNwr8"
"jKl+kXbBZ7u+01Lxr3P+pudvDP7Rlf8s/mboH57/3UQt/IbXn6rn/xs7AE4/BABcDQKyAoCT"
"91+oC8A6COicxfvPUvbAsDNm7t8e/of43zvpBAAp9Ku5EfBEYQD40agD0DUA1/YAAKIsALBN"
"zQIQANhAdy6vV96/AMB68fpvF4Q4AMCdyztoesMSNB6iOJWF/y3Y2xCzoe3p3rdHYTF4zv10"
"98o+ytq/TKICn7+uYGEKHv8Fzq2f9aA7Vw7Q7a+i6PalnWITa35Aw1610XAAwmBYXwjZKHjn"
"l49OogsHRwMChlBe1EDxwrk2YG7HqtQM4r1njhcVHBgOCBhBg/AcHf+m2gGN3D2nAobWKUb5"
"0f0oe0cXeNTeEP+OdGazN41uVFy8/+Be9aVt8Oz2bjSjXUVq9rSaKVAIAPYOpsztXSDEHSAu"
"bQUC/H0qiuffAl/DAMKFifO9qlDW9u74PvDYN3kDBrpQn+J/E/Hvj+cc8JL20LtUFVDgSMDp"
"dR7U6ikVIejxnPr92YaV+RutHliHji5pBwjwhhhyV0MHSl3nSSlr2lFyUBuJIgyv+gp1/asG"
"ADz/EPwNB72knqP7swoqOgJCfPFaLPD8RCAgcVFdip9TBSJeHt59KTo0vYSOAHxCB7/4GAbR"
"n/QRHYTFTFEQwCt/DQiIswIAF/3NLibGAJCwQAFA/EKe+gcA8HMEABZ/AYBA9v7LKu//9wDA"
"On3qQkCXAMBFgA8DADMaoL1+AwA2qHA/F/rxxr8zmxqKZW5qoE1N/8uC0GfzAiBnANhiAQAW"
"fwGAprodUNUEWAHAqAEwAeCAlwkAl2MYALgQ0PuhAHD+9wBAuCMAbP+y2GXowUTYYJsCgPY2"
"BQC1bWoWQCmtI5wG4CgA1wL8x6MATwBAfTyO9890xi8SzwDg/A3ncRgAHCIAR9dWSC8MAIMs"
"KYCRRQDADFUA+N08Ff7/HgBwbYkW/xXa9Epf9vp/0D3/P4ZYCv+sOX+91ve6Vfh32UP9N6Kc"
"Cv608LPnf0tP/bt9xO75CwAcd/T672nxN7x+EwDSigAAyyhgh10A/wQA/OIMAJnK7kP472dY"
"wv+nnQAg1SkCkOQIAJIGeAwAMIYBfbVZ2gDvXA7RAKBE//YFZXz903k85gKnDCJoYbuqAgDT"
"IOhz37HRHNimYZ507+pRuvvtAfrp6z14zmg6Ex1Aw19Q3j/Dwoy31HloxWf005WDdPvybrp9"
"MYJun99BIaO9RbiGAwJGvKYggEXySsIMunz4czq/fwTlcVEgICAvejAAoDLhHYnCJrZWdQKw"
"xPU9yAMC6vucpSvgJRUF2DPXk85F9hQPniEgJciTmuJx7d55BuLfm87ivuwd3Wh62wrUFGLe"
"HkLeFWLd2wSAsgCAYYCErlJLwABwGp73pOYlJOzPg4l4GBFHIMa4fSjPdwbCLwCwrRuNcnuP"
"er2gfq+h+B0HSmFhMcra0UtC++kbO1LvMi+IUPPj+P6BVgHH79W72NM006MUxfi5Q/g6AADa"
"UvIqd0qB7ZnemHq8ga99Tnn/gzVIDXpFAUcfhiKOrOD+Tvges9sWo9TARnQioBYEvCIdmVFG"
"1hIfnFxclgsdnFRMIECiAJPVpsGYaQoCjHG/cXplsAr766K/OUbYH56/FQAC7ABgeP9JS8qK"
"+BsAcJIBYHUF/F0fAQA400JqQNS54h+23gIAvAioCABwWQNgAIDh7Zv5/Xri6bNxix+3+mXC"
"y88MhcfPtlmZKfzcASDFfxoCeBJgqP32wgDQvDAA6EFAdgDoaAGATnTpUCcFAPu8dBGgpz0F"
"4AIACna2UnUAEc0fCQBZW2vid69KaUEVKHDou2egBxNgg2xqEJCH1oo6NjULgIvIjTTA/7co"
"wBMAUB9FFf8xhXHxH1docqUmAwATG79wnMdhmuMIALcB9oaNCp1b8hhlAwDyLAAgrYAuAEC6"
"ACbbAeC7ORD++TAO/wco7/8HeP4/wPP/YSUsyL7Qh4f6cNj/R2Ooz0ZLi98W+1hfEwB22Yf7"
"GN6+Ge7fZxf+WxD+W9bQ/1EYPP+fEmAntPhr0TdOEX1XAOBcA5Dp6PmbAGCtAXgcAMjXy4By"
"nQAgUzx/McAHC/8/fk4TM0P/hQDAqAFI/A0AsLswAFxRdQACABdDHADA8P5/usAAsI3ufhVB"
"C9pVofEvqfD/XHj/8wAAwT0aKQD4BgBwJQrPt5u+zwmngRCvCa8o4Z+Jx057SwHAna8AABcj"
"6daFMLpVsI22TOwmwjUUjx0NABj5mhKyrxPn0+Ujk+H9jAUADNUAMJDmelakRvjvOs+7GuXv"
"HUT5ewbiHExftKootQBdX1AAwFEAX64LKPkSnQM45O7oLq2Bk1uXlfB/gG8tKS48C/HPBhws"
"9K5Kzf5ojwAwALBNaVYWkAEAwNdnbPaitLUeAgAxc1tRa/wt2jyjAIC/98KO1Sk7sjeEn4sP"
"OwM6etCQKq9Tb/wcQ15VkMPn1OYl8b37AhQ6CwT4+1Q2AWDAy1q8cfZ9UQl7Fzy3719VlGBM"
"vfcoYXkbgAwgIMhd0ghHAtxpdrsS8lgGhwEvKogQmID1h/XBbT1fUM91ak1LiHE9ip9blWKn"
"l6WYL0sCAAABX34C4S+mTUEApwQYAjgCoKIAelrgTBX2t1b9GwCgcv9q7r8AwBI7ACQtVVv/"
"HgoAa53y/64AYH0RAKAXAhlTAM0ugHWOXQB8mgAQYuT2lfAbnr4Se3j6EHa27K0wvg5VZ/bW"
"ZlrkmzsAgGkOANDMJQCY2wCjPejCXjX9zwAADv+7BgBdBGi0Aka3lwLCgiiuA2ijAEDmDLQA"
"BDSD+DsBgFEDEAYA2MIAUEUAYGrXvydAD8bDBsK62FQXAAMA7wNgAOAich4I9JHNHgV43Wbv"
"CDDmAhRVDPgv+XgCAOrjccL/XKnJlMYtgPzCOQNAL9iIzXNLHFUA0AkA0AMA0E8DAKcBhju1"
"AX4O4TcAYKYGgAXK+5fwP7z/H1Zo8Yf3/0Ow8vxF/NepsP+PutXvx02WhT7bLFX+kZZQf5QS"
"/Jv7lYnoOwv/EUvRX5wFADj0n6Q9/1R7vp8F3wQAttOPCQB6FbCsAzYAwFoAeMEJAIxdAPmP"
"AQAZAIA0Lf6nxUzhLzIC8DAAiDFHAhsAcP/qTrpnbgQMMwFAlgEJAGzU9QAbVOhfAGAL/XQR"
"AHBlF63o3pDGQ0hmvAkBhqjPf1td3716jH5iAID3fwfe/R2c/SGk4zhd8KYCgOkAgJhln+Ex"
"ByD+EXQzfyvdzNtCm8Z1kpw11wGMeU1BAHuw36Qsoq/ip9GlmHFUsG+45OE5EjDbq4IdAPYM"
"EQDIg6WH9aNObz1Fvs/b7AOCcHpDFDeNhDe0uz+dCvGlZri/BYTw9EYeMdxLtgtmbetM4eOb"
"UnNupfubKgLs84qyCfWKUcGBUfDsewAAvPVcgXaUBs89dpEH+XeqRou71KG9czzp3K6+lL2j"
"J20e0ZDGNSxGXhD7Tn9TXvhQHeHgdMfMlqUpFz9P5rbuUuR3ZmsXmtamtIgzw0K/FxUAsHDz"
"NYMA384pAgaFETXe0JGAdpQS3IZS13hQ2oaOlLzGi0JHNaD5nmVpwPvq+/bH7zLgFfVcfTky"
"gtvSNrSVKEDCguoQ8/IUM6UUPH9AwJcqCnAIIBDDws8AMBknrg9P/VjaAw9P+1gmBvK8/3ie"
"9mcCwKd0bIFe+qOL/05w+N+/MAAkL1O5/5QV5R0AgFMA0vu/xlIE+AgAsNcBOAKAsQdAxv/q"
"UcCq8t8CABtcA0DW5oYQ+YYQ+cZqzj+EPIvFf5sBAU1N4TcBYFszBQHWCIA1BSBLgZqbLYHi"
"/etlQBdY/KONLYBekvPnAUAs/JcP++D0cUwB7PGiC3t0IaCIP2wPdxFwFAC2q7WCgJ0AgMjm"
"dE4goIkCgB0KALgLgBcBZYXWxO+vAaDLm8egB2NgA2CdbfYaAAYAHiDHKWSuA+B6Mo4CcG3Z"
"GzbHuQAPSwP8Sz6eAMDjh/85PMOUxi8Wv3BcyMHhHAYAT1hP2PDlEz/eT9m8D8Cb6Hx3oot9"
"1VZAngVgAIB1ENBvAoDVKudfCAA22wv/zP5+Pdnv+k5LyN8I9R9yNLPYT3v9ZtHfUR3+P67y"
"/gIAEP97FuFnwRfRP225tqYAXAGARfwfCQDOy4DyLeuALe1/Zvgf4o/v+X/3T5vi/4+fLaF/"
"wxzWARtFgMddFAEetuwE2CtzAO47AAAPA9oGAOBCwFDZCKjEn43F3wCATRoAAAxf7aRd8/qZ"
"ACARANhMXN8DAEgBIIT/p8u7FAD8RQEA1wDMfEsVDB5a/hnd/mo/AGAHACAUALCJwqf2kG4A"
"TgOw+I9+XYlk4qZROg0wHgDAaYDBAgDBA+pLe938TtXh+Q+RzoDc3f0EAgI61xEPvuvz9lSA"
"RARKv0wZ4f1pbf9GEraf41WNciDWWRE9KQsAkLlVAUCzp1QEwACAvq8oiCg4OEaF9kM7KQDg"
"dsL17Skj1Edy/mcBEsdX+tJMj4rk+8EzUqToia+d41mJhlV/i3q/qHLzw19TIDCzFQAgapBE"
"CDI2+VD6Jm/K2NKVoqe1psnNS1D351Q0gAWcxZ/FW4DgJXU7t/vtn9saP4cnbR1Tiw7MbkSp"
"q9vRyXXtIYqelL7BS54zZqE7fd7oXQUVGgB64PkyNnrQSQGAGgIAh6eWhsiXpMMGAHBBoBEJ"
"4KLAKR9TzLRiIv5H2KarxUEc9jfm/fNaYQEALvzzK/54ABCo8/9GDcBq+xwAl10AlhoAIwVg"
"AoBRA2ABAHsqAACgl/kY4i8pABcAkMWef2hDCfeLlw+xz4aAMwQIAPC1CDtbCyX8YS0sANDU"
"bAM0iwAtnr99HbDeBQDB5vn+F+DRy7S/A0UAABcE7sdtHB3YCwCAnRcIaC/RAI4ecBeBKga0"
"A0A+ACBPrCmdi2xMuREqBcAAkL21NmVurkEZ6wEAqyrQWM9XD0APRsP62RQA8CAgIwLAw4AY"
"ALgOgNPJH9pUavnvtv9wGuAJADwcAKzhfw7PMKV9aHMEAH5RucCDez2HdXd/ea0AwDkvAEA3"
"AEAf1QlgAsDIx4gAcPh/cWEA+HGNJfQfosL/1/WAn+tblOdvtvlZ2vsc8vwHlad/67D29rXH"
"b15D+G8fteT+OfTP4p8MS1Hif88i/IVEX3v9LP73Lfn/B0b1/1kXAHDuMQAgzwkArO1/2Rbv"
"P13C/yYA4Gf9XQBwwz4SWEYBy1bAPWo1MAPAd1YA4AjAVgGAu1wLcNEKARtdA8DcvjQOYjL9"
"DYj/WyoCIADw3TG6980huntlj6QAOBLQHyI1DoI19Q0NALANI70tALAFALCZkrZMkpZABgCO"
"AIx9XXnKSZtHawCYQOf3j9QAMJh2T2tH+MdLC31rCADkRg0QMc/d3ZfSt/SmzsWel3C8MSCI"
"jaMCgT0bU+dPnqOWf7Lhcb0oZyd76z3ozLau8MA70/YJzWTTIAMAdxP0e0UZA8CFQ2Pg3feW"
"wUIs/KdhaRDb9M0dKW5pe5rYpCS5P2MTa/1nAFJbeLMbu9HZXQCmBh8LAHBUY9hrKgUw070M"
"wGWwAEDaBm8IWwdYR4EBbv87ub4zhY5sQlNalKS+H9jk6wfokD5HBHo9zx0O7pS20Zta/cFG"
"k5p9RClBbaQmICUYJqmBNgIqScEe0lnB4f9e+Nr57Uvjd2hDqYENIdzVKXZmBQGAmEml4PWX"
"gNiXoMNTPtEgUIwOcmsgjAGA9wXwrICjM4rRkVkQ/Nlq3W/8XGVH5xW3A4CfHQASLTUASSv0"
"0p9V5Sh1pRb/xwUA3Qb40C6ANXbvvxAAcARgfV17EaAUBtoBgFv7DO/fAICzW5Xgs/Cf3WYU"
"9sHzD2NrYU78yw1TUQA1B8BxHbCIP/f/m5v77ABwYbfO/RtDfooAgEsHO0H8VUHgpb0dBQAu"
"SCTAk87v7SALhAwAOL/bXaIA+TtbqijATgDATgaAJpTLELCjAX7eehIBsAJAs4rPrIcejIT1"
"hfnaCgMA15AZdQAPSwM8AYD/MABY8/9G+J+rMzk8YwUAIwXAYR0O73Cl55AyH/5hAWW5E+V2"
"ICroQnShtxMAjLDUAHzuogbAFQAEugCAjSrsf90I+2+1e/7mYB/2/C3if/uQY2ufiH2cFv5Y"
"S85fe/53dN7fEP+7qY8AgHR74d99bb9YRwBnPwIAHrYO2BgRzHZOCgf/73/OWtr/Ms3cP4f/"
"/+++Ev6iAcCaAkh0BAA9DMjYCnhftwCqjYBqLfD973YBACI0AIQDALY5AYABAZu0+G92AIDI"
"2X1o9AtK1OfrFMBMePZXs3erLoArexUAXImmmY1Kqo4BCwAE9WktRYC3LkbQzQIAwLlQSto6"
"ibo+o1rYRhsAAJFM3jQGADCTLh+ZaAGAoRQ9o73Mu/frUpMK9g+l/Kj+EPNe4qHn7OpDawY0"
"kYJAXhbUS+fxWcT58w6AkqmtK1I+nitnZx/x3rlSny2MUwBOAMARAG4rVADQVyIFMmSHAQA2"
"uXVpiSjw/IB2f1EW3BueVUQvSQVkR/ahsfU+FK97IBcBcnrDAQC6CwD0LP0iLfAuh+f1klD+"
"6U0dpf1P6gjCe1DIkIYi+v1eUlEA9ugPL/KkjM2+1IbrFvD8u79sIMKfzIOKZOIgzuDWdHxF"
"K6kd4CLA3u/ZKH5pa9mFkLi0nuoEmFFeBgLFTCopdngyAGBycZgBAZ+oIUHTPqG4mcVkc6AA"
"wEyI/6xP7Pl/BgFrBEDP/U8MUNX/yUtgy2GBAICVFgAIroCfh+f+VzJTANY5ADIJsIhBQOYc"
"AB4NHOyYBii0DRDin7HePuTn0QDQ0BIB0AAQ5gQA4S31sJ+W4t2rKEBzGQWcK+KP+/Xyn3MR"
"rR4KAOzVFwUAl2PsEHCZz31cD+AN0QcI7PPS5lkIAAp26SiAQEAzmAaAiAZSA5DNALCpBsCo"
"MqWtrEDvv/wHP+jBCJtKDXvb1DIgIwVQTesHAwCnkzkN8L7NngZw7gb4t9UBPAEA1wBgzf9z"
"OMbI/3O1JtOaAQDcBcDDHbjAgws9uOBjwoNTTe5TTns1C+CCngUgdQDDYFwIONpSBKgHARUJ"
"AMs1BDAAcNW/4f07A8A2PdLX8Pwtff1S5HfQ4unHai//mD613db5fsn5H3cUfxF+HfovBABp"
"LgDA1QrgogDAxSAgM/+vi/4cACDXCQCyHIr/Hg0AqboNMNlpGZCaBmgFgPvGRkAGABH/aAUA"
"V3epCMDX1gjAFoh7KEQeYn95szrZuPefxf/CVhMAUsNnmQDA4f8FsFkAgLxjG+je1cPSAsje"
"/08AgQDPGg4pAO4EWN3PXXUBXIwEAGwFAGympNAvHQBgHGwURDJp41j6OmEW3gDtAHB+33B4"
"vp7i9Y5p8Im0AeZHMwD0FG9eIGB3P+pR9nVZGMTC21d78uz9doEIpm7qJ7UDAgBh3UXUuSUv"
"bEJTaqEBoLsTABQIAPSBGPtCMBQAzGpfjhrqGQAMHNxx4PvOU5S3G88L8c8M7ybnKLcPJe/e"
"/xUl/oNgM1qVodzoQXQG3z8dXjy3NXq9/ZQS//WeELr2EDEPWHvx8jO2dqPh1V4TCOBivuHl"
"n6WscO4i8KV2T9vEOuL5NwyuKXMFWPyTVrWmfbMaUM8Sf6H2PEEQP+PGIRw2d5fpg7yA6Ohs"
"3Qo4vYzUARyWNIBKBQgEcCRgKu8K+BSPUcbCb7XYWZ9S7OxPBQIMAIj3K6mG//DUP1n4owBA"
"wv8MACz+AgAVINqw4Eq6BdDSBWAAgN4FwKOArbsAUoP1ToAg4+QoQA17/t/VLgCz8v8hALBJ"
"Q8BmXQOwxQj72wHATAGwyEtvfyuzvS83rKWIf2648vhzIfws/ucg+Oci3NX1jlZ6HXAbuhDF"
"xX+ergEAwv/VEV/8H+iMa5yHYHzu55qATni8dyEAkIFCjwEAOeFuAgBnNlandPzNkxaXsc4A"
"6AHrCGttU6OADQDgCHIZrSXcDmjtBjAmAzrXATwBgH/Dh3X5j/Psf2v+n/MznKdhWuNFQPwC"
"8iAgBgCmOw7zcL5nTNzaShl01oPoXCei8z0tnQAMANZCwIkQ/0k6CjDd0gXgNAPAAQBCigCA"
"MO35G+1+xlAfo9jvkJPnf8wu9g4Gr/+OFv+fkrTnr71+V56/CQDWsD9E/36mDvtnFgEAOUV0"
"AVjSAIb4G2F/9vzFcqWQUAFA1u8AgBQNAElOo4D1JEBZCRynwv86///g2j56YAAAvH+ZBCgp"
"ANUJwABwlwGAawEuhap6gEvaWPwvWQDgSiQdXf+FCQBzdQpgNgCgIH6TAoCv96k6AACAf/vC"
"ALBmQFvcd4juXNpNtwrCJQ2QEDKOukKceCDQ6FftABAbNISuxM/EG98EaQXkcP/5fcMoenYH"
"cofwjqj1Pjzz0TIbIGdnb4htD8qWfHxviprhQe0BFd2eV7lv9r75XNSlHl04MF4KCtlLz9za"
"RXr2M0N9JQLAAMDzBHo4pQDOMwDs5BSAAgCOAri/8RQ1xePb6vHBPty7X/Ndyo/i1ALAIrwr"
"ZW3vRv0rvyHpCH4uFn8uyJvWvCTlRvWXNkFuF+xb8XWZBTCxcTFK3+ANAPCEqLWllNU8NtiD"
"TgR6UJc3VO6fCwF3fdlKWg15VDCLv4e2tjoa0L/c8+SDvzeDkjtuG1LlZdo3vTGEsQ2Eshmd"
"WFKPji/kYUCVKW5WBTrCA4GmlaEjU0tD+DUISCSA5wMUp5hpn6qtgTP5/NTcHhgHIDgK8Y+d"
"WRwgUFxSACz88f4lxax9/8nc+7+0tFT+CwAEuQAA3kgnwl/VLv5FbANMDaqm1gKvqqogwBUA"
"WHcBhLhZBF/PA3ACAOcuAGn100WA2bqi36gHOLtV1wBoAOAtfGy54bhm49tY8PW63nORlusI"
"5f1z217RAOCtACC2C10+AjsMi+lMX8EuH/TF4wAB+zs5AMCFvR7STXA+ygIAu4oAAK4B2FIL"
"v3N1SsPffuXw9zKgA+NsyiHkyDAXiRsAwGlj3gfAswDKai15VB2AtRDQuhzon/54AgCPXwBY"
"FAA0sKkXl8M83Ao4YuaQ9yOlEyC3I1FBNwBAXxgDwFAFAQwAVzgNMAEQ8IWOAky3zwEw2wCX"
"OAHAGhcRAMtWvxuRlnY/o9XvgD3vbwWAO8csgm+YxfO3iv9dLf73tNhbzZrrZ6//vs73CwBk"
"FQEAD2sDdAUABRYAyLUAQHbh9r8HLgDA2v/P3r8AALz/24kwPQHwluMugAe6APC+HgEsAHBN"
"hf9/1gBgpgC4E+AKG1f4q0iAHQC2OADAxRMraEXPhjT8vadoFMRsyutK+DkKMBsCHzlzAAAg"
"Vg0C+moPRH6PCQDG0CAGgFlVX6afvo6RTgEFAKFUEDeXukHYBr2gagDG6RTA1ole9FX8DLqk"
"awDy9w2RCMDeeV4idGPcPsJ9HB0YBq+/P52Vgj5AgKwO7kdDar5PnZ9VHjOLLhfTxQX2poL9"
"Yyh3Vz/l/Yd2lsFAmZs70Y6JTakVntfbCQC4huD8wdF0FgBwBgDAw3sYAGQI0J+U589Dh7q8"
"pNoOY5d1kp8hdV0n+qxpCZVSeEFFEwa+qp5zeMWXaecXrWhGm7ICAP0ACW3Ykwe0DKjyBjx1"
"N4pf0pqOBbSitQNrUs/if5V5/964P3RkIxH/9E08mthTBP6Lph/Rjs8a0Jp+NWi+Vyma61mS"
"5rYvTqv6VKBD8xpDQN1l9XEKLyJa3lDWEccvrA6vnQGgPMXOKKchoDQdAQAoAwRMUyAQM7UE"
"xU6HMQRMh9hPLy7RgFhYHMRfIAAAEDevhGr98wMABJSSmf8cAUjU4p+s2/8MAJDKf2cA0G2A"
"sghojeM64NTgKgIASvidACDYcRZA2qMAANdnNtYrDAAb6pkQYLYBbm1i7wJgANhiBwBV1W8H"
"gHPbWyvbAYtsA3BsA+GF7eKzrbqOdFftelwAyADgUAPQUeX5Yzj870tfxXUFBHQDBOAEBLBd"
"PtgZj7FHAVSHgL0O4Hx0GwUBXAy4q6VAgAMA7AAAbKurOgDWV6O01ZVoQMuXdtocCwC5RqyF"
"TW0DZAAwIgAMAFwIaNQB/NZCwH/64wkAPBoAjAJALtDgQg0DALiIg3cB8I7nljZFeRzuGfr8"
"X2zTHpxudp9yPInyOqs0ALcDXh4M4yjASJ0GGA8A+Bz2pV4HPMv1ICCzEFBP/nOoAXgEABTq"
"7T9iAQDD2z+uTrlOtBT9pdqF3zARfoj+zxnqvJ/hKPqG8BtWCACy1SAgsxvgUQBQYAEALf7/"
"m2MBgMxHAMBJGESfzRR/tiT6FeL/622L+Ms2QIj/DeX9P7h+SLYAPri2H+deeiDh/912AOCF"
"QN/YCwHFAAI/faUhgEX/oiMAXEoMpPDJPrR2iDst83WjpV41acobqhuAowFfQNRm1H6P8o6t"
"pvQof1rVr7l0AYyB6E5+Q3UA8PAg3h1walcAACCabjMA5G2hlFAVARjIC4ZeVt7/UIjp6sEt"
"AQDTVQRg30gJ23MkYPvkdiKGPN3u1NYhdOHgKDq3ZzAEug+d3d6TssN70tldfSh2qa+EvXvp"
"SvpprcvTxZjPKX/vUMBCb/H+WXzZuB8/8vMWIqa8XIgBgCvmDQCInuUpy4h4Nj+LP+f/2779"
"J2qldwf4vqg6Bzq/qOYBDK31ntQFdMDvO6ruB9TleVWLwJ0FXJfAn3sCeiY0/pTSN3pRn4qv"
"yX6DLh89Q23+bJNoANcjcLEj1zvw56Pqvk2RXzaF8PsIhKSs9pCc/5aRNenYkpYyoEgKAYPV"
"gKDkoNaUCtFPDW6Ja710aHkDmQKY4F+LEhZUo2PzKtPRORUg4uXpyPSyEPgyCgKmwqYAAqYp"
"CDgyo6SMDD4yrQTsUzGGAAaCuFklAACAg9m4ngvvf0EJSlioVv4e9y9NJwKMCEBZEwBU9T8g"
"gPP/DjUAlVURoF4FzCuBnQEgNaiKiL5LANDif9qUHxyBAAAgAElEQVQVADilAEwAMLsA7Bv/"
"jJn/MgRoIw8AamyfA2C2AaoUgCsAyNsBTz9CC75e15u3u5261hDA4i/Df5wBQMb/+qjcPzz/"
"K3HdAAHdBQK+OgwIYBA4xADgqyFAA8ABL7qw31M9lwAAvkcUjxm2A4BRBMhtgLwOOHNjDUpf"
"WxX/Lsrfh6s+HTow3Kby/51sKkXc3KacRa4b4zZAjgAYnQBFFQI+AYB/MwA8TgugKwDgvA2/"
"eExybjbVCsiUx3UA3Pc5Nm5NZXsaoKA7IICjAAwAQy0AMA72mYoCfDPFcRdAoUmAgWoQkDEH"
"wIgCmCmA3wMALPonLF5/ovL8f9IFf1bP/16aMkP8DW/fFH0+s5Q9yHYBAE4Q8FAAyHsIAORo"
"AID4/0+WEwBkWLoADABIVQDAwm/1/u8wABynX63ifytOA8ARAYBfDO//B4v3bwGAuxIB0AAg"
"EGDUAzAEbIP4b1UmALBVZgD8dGm71ADcuxJN9745gOeJgR0BTMTRd1mRlBMTTNkHltMPOdsp"
"ffdCCpvSjRa0qU5LfBtQUK/mNKPySzTpdbUbgDcILu7aUDoBVg1oRV4Qt87wpPtAOIdwv/yL"
"CgYGvvcUbRzjTic3DaKktT0panpbCuxTW0Lcnk+r7Xcjqr9NWya0oaQ1PVU3QGQfyt7RS9IA"
"DAXT2lWW3nqehBcX2IsuHBgtI4V5zn4mxPxMqAr/hwxyoy6fPCdbBjtrAOjzsjLZMoifxd+3"
"Om0f15gOzW0OYWlHS32ryejg9nqFMIs/DxDiiYDtAR6j631Ep0N86ESwD3V9V3UicHsiFyN2"
"eZe7EiBSmzrSqZD2NMLtPQrwrSz5fp4MGD2tGW0b60bbRtWmLTBVD6BqAlJWt6MkCH9iYAtK"
"WtFM1ggnBTaDwPN1U/OaNwzK6mEIf+KKhnRiaQM6saQuHV9cGx56DZkBED+/iuwEiJutIEB2"
"A8Bip5XBdWnTjswopWxqCRMEGADiptsBQCBgTgk6xhAwvySeHwDgV8oEAF78IwCw3N7/nxKk"
"2gBTV1WEuFeEiFfSpsXfFQCsgq2sCsipqkHANQAUSgHoQUBGEaCZAjAW/4SoUcDGNkDHrX8K"
"AoyagCzpDngEAESy199OhD9fG3+er9f3Sq7eAABrCoAL/WJ8xPu/HNuVrhztDgjoAQDAeQTG"
"IHCoCyBBQQA//jcBQERjWQecvbk2fr/q8P6r0MoRHxjhf54AyJ1hnP93t6kCQHYWa2nd+FcA"
"wD8NAU8A4OEAYG0BdAYADt8wyXFIh19crgNg2pM0QOkP/+BH2e2IcryI8rsQne+l0gCXhxQG"
"gK81AHw7Q60DdgCApXoPwAoXkwBDdBugUQNgDP2x1gA4pwCcAMDw+CGKduHX4n/3tEX805WJ"
"5+8MAIbHn/0IAHCOBDwOABg1AOfs4v+/Zy0AcEaZiH+GFn9nAGDxT6ZfDWPv/06iiP+vTuL/"
"P6b4x8AO6vD/Xrp/LdoOAFd3OwDAPTMKoEwAwLBLGgQub5P8/0+XwunupR0CAXevROHxewAD"
"e6ToT/L+bNICGKXmAFzeKdd3+LZv9uP7HMJ1DP309QG6lrMDwLCMbp0Pp7Sd02jPwq60dmhz"
"ChnlTpsntKfQCR1ovlc1+qJxcRpb+wPaPK4lrR/eiPqVfYXaQlw5/99Bb83z0Rv22HPvX/EN"
"Cf2fjegjHn7u7gEAg17U9S0bDSjzErz/CVSwZyjl4H7OvZ8J5amAn5KbXt3L+X8PQEWnZ9Ww"
"HBZ+Nhbtru88RQOqv0Pdyr5KAT7cqqbGAYePbUQj3T6iTrifhX94zXdpVtuKgJXWlBXemTK2"
"+lJmeBc6ud6Xoqa0lj7/qGmtpPCQPf9Ta+G1r4SXLlsBW0vePzWoHYROTflLWdVaivmSuKgv"
"kK0lxFwJ/YklTSDmDcVOLGlAx9nkuhHEvhElLmsk2/+OL2Vzw/0Qf/b+F8H7ZwBYWI3iF1ZR"
"UYC5GgJmlYeVg5UFEKiIQOzM0hYDBMDippfCfaXo6MySAAjY7FICAMdwfWwubF5JgYATCwEB"
"AWXoxCINAMvLUvKycmK8BTA5UJ0pgRXwu1bA715R7FEAkBIIW+kEAEGWXQAGBBiTANfVkS4A"
"WQxkTANcb1kGZNkFkGEuBqqrtgEyBPBIYB4DvIWtsQMAONcAPBQAdnvg9JBrydXrAUAX2fvf"
"56UnAGoAONJZvP4rx3oAAnrSV4CAKwwBHA2I6fo7AEDNAeB1wNlb3ShrYy38jtUoDX/TD175"
"gz/e/0fZHMP/HCHmWjF2FjltbKQArADwsc11K+ATAPgviwAwqXHrBgMAj3RkouPcTiub2gnA"
"1Mf0Nz5uXZUMOutJdM5HRwH6qSgAFwJ+xXUAvBVwomsA+K4IADB2APwuADjimP83c/3JTsJ/"
"yoXwG+J/RplV/O9na9G3mgEAVnsUAORaCv2cJv85AAB/LcT/fzJ/OwAAdsTusPd/XAPAUVgs"
"AOAIAIBD/zEaANj71+1/16J0+N+IAEQKANz7JkIDgNERsAPCzxAQrgEgTHv+xonbLzIE4DGX"
"IiDuEeq8FAnbqS2C7gAS7sCzv3UhHOd2un05km5/tRsnL//ZpexCBN0qCJP8//dpK+mrY9PE"
"rhyfSV8fn01fn5iF6xl405uCN8Av8EY3jgq4CPDAMNn+dyFmLF2KnUiXjnwJ+0LVAeD2vH3D"
"6NzugfD++0oEgCftnYsaREeXdaWUTX0pb+9wysH92Tt6U2ZYF7VqFxDA4f+s7T0kx58bNZDO"
"7x0qC4Z4+l/BfpgsI+ovhX0Zmznv7iGV9idXt5GhQBmh3jJMKDtSdSFkR3SnM9t8ROBlZsA6"
"1TJ4SloHPaSDgOFBqvVXNKfEpU0h1M3oOOzEcm247bi2xOVN6MQyePHLIPpLG0PkG8Eg6ovY"
"6lFCQH1K8K+nDNfHF9VX9y/BucRNmxJ/rvxPCAAABNRUJlGAqhDsKgIBRwEBYnPK4ywnFgsY"
"iJ1ZBlBQWoxBIG6muj6K8yjOY/Ngc0op8TcAgCMAC0pLGoAtcakRBdAAsALnCg0AKwAAKyuo"
"SMCqIgAg2JICMCIARgpArFrhNkBXAGBMAtQzAeR6rRL89DVsuH2tsjOyHri+WgS0We8CcAIA"
"IwIgQ34YAIzwfySH/z0UAHDoXyCA2/TaixkT/Hiu/0UeALS/oxJyAQBfBQAQ+98FAHva2gFg"
"lzELAAAQoQAgK7QuZYbUxO9alVaN/Ii9f57/z9X/Rvif+/+ba43gDgBOG7Pj6AwATyIA/x8A"
"gD/+GQDgMA6/oPVsKg3A8wCY+nj4w8jSHz7lR9keqhgwj6MAfQAAg4guFwEAnAIoEgACLTUA"
"6/T6X2cAcNUFYAWAWKfcf6KLYr/T2vM3xD9DmUPo35LvZ/G/D4/8gWFWAMh2DPmbIOAKAHRL"
"oAkAeU6Wqzx/Mf5aQ/wzlHHo3wQAowbgpCMAsOcP6BHxv5OgIgC3De/fDgC/XLd4/z/s0/3/"
"0WI/SxQgShcBRkor4D0jFfC1AoGfrii7yxDAgn/JDgJ3GAIuqNvvXAyDuOP287hdLEwbrgvY"
"ttItiPutgi04cc2f43Z1wvJC6UbeRrqRs56upvrT5bhJyo6yfUmXY3HGKmG/eGi85Pjz9w+X"
"lr+C/bz9b6T05fO6YO4C4M/z9g2nc9GDKDdygIoAcBoAQp8T2Z9yowdLOiAX4p8DOMgO6y6D"
"f7jwL2OLt0QCeHZ/FtcPRPaSWQIyWGgXg0QfmfIn4h+qZgCcXNOWTsIjFwtuLV48386he64n"
"SA/xkgE8fF8qvPaUFS0odXlzeL8weO8py5pL6J5FPQHeevwiCPqSRqY3nxDQkOIDGuB2Fvb6"
"OBtQwmJ1WwLfJieLPZsbxfvXdbCEAG0s9iz6i7Xh8+OLGQBwLqptt4DqEg04tqCqjgZUhJhr"
"CBArR3Gzy1LcXNi8snJ9bK6yeLb5sAX6Ngh+vHj/pTQAaAgI4FqAMgoCOAqw1AkAlleQKEDq"
"SgaAShB2WLA2QEAqe/9BlQsVAZ7UnQAMAKkr+XPdBWDsAnA1Chhnmlht+zUPCYLwp63G/XKt"
"LMMKAJsaOgFA038KAJRQAwD2eKrQv1HMJ73/nfF/oIsCAFcpACsAuKoBMABgd2tzHHBeRFMZ"
"BZwdxh0ODDc1KH11VfrgVdP7729TC4CM6n8eAMTh/zpaL6rY/jUA8E9/PAGA394FYAAA93Dy"
"LAAO5zDZcRqAX2zO+XAxIK+BHLdxVtl4OttBRwF6EV3sbykEdAEADjUAS+01AFIEuNrFJMDQ"
"wnMACnUB6BZA6fdP0Hn/JEvYX4v/XYvHbwp/UQBgzfefdWHZLgDAUgRYqAsgV12bhX7Wtr9z"
"duH/lY03Cp5xAQCG+LsCAC3+P2nxv80WDztqAQCI/w2I//VDCgB+hPcPALgBj/3m+XDVBigw"
"sFeiAAoAIjQA2M0EgMs7XABAmEQAeCmQAMB5JfS387fQbT4h9rfPb1Gf52+G8G+SMb83z22E"
"baCbuWwhdCN3Pd04u5ZuZAfDguhK/FQR+kuHP4M3P14q/i+K8I+T1jsWd7b8vcMoHx5+/v6h"
"4unn7xsq19waKMK/e4B4/DkRfSW/n81iHtET3g4EfQfEPEKlBrLDelIWL+qB1y/izwWAAAGu"
"BTizxUfmAXB4Xn3eWUb/8v0ZEPf0ELUKODWoFYQdog5hT+FTQIAjAnyfO6y1iH4ye/JLIPIQ"
"+ITFjUTEWbxPwDtP8G+ovHQx5bWz4MdD1I9B1I/5wfzd6OhCPutRvF89uS2er/3dtNC72cU+"
"gMW/joOx0CewwDsAQF0VDYDFzKtJIYPK0PbRFejEolomCMQv4LQAIIBBYF4FOePxefx8XC+A"
"zS9PCbiOX1CRjvtVpASx8hD6cvg5y+A5YAwAsAQNAQkMABwFWFRGAIC3AUo6gG0FW3kxBQGV"
"7BAgIFBZe/52ADDaAM05ACYAVMdtNWCOEwGto4BZ7NNW11ZwsLqWutZnWjAes1rdz5axtq4C"
"gI1qJXAhANBtgDzwx0wBGOJvAoCHmQLIZ/HnBT7RnlL0J4V/ezrYAcAsAHQEAFUE+AgAYPHX"
"XQAXzC4AvQ8gohmsCSAFv8NW7nbA77amOk3v+W68TS3/sXr/XPzH4X9u/+PwP0eLDQBg7XjS"
"BfBfBACPOwfgQ5vq2+QXjjsBOJzDlZ0NbCrUY0QBeD3wiOeesc24caLFbcrhKEA3HQUYAggY"
"oVsBJ+pWwKkaAIwuAOs2QKc2QGMLoBQB6g2AMglwuwUAjE1/B/X0v1invL8h/IaddhJ+CP29"
"MxoAztjD/48NANp+sZoBAM5tgJaZACYAWHr+xbTwi2VqAGDxT1f2IE3Z/dPaTmoAOGkBAIj/"
"TxB+/B3Y81fG4n9UAOCXG0fE+38g4g/v/0fl/X+bvpG+qPIW9X/NRgtalaf4kC/o/nf7JB3g"
"CACRGgAiRPwVAIRZACBMA4C+vmB4/iz+oabdKtgE8cd13ga6JcK/HqIPwT8Hwc9ZA8FfTdch"
"+j9mr6Ifs5Rdjv1cxP5izDjl0ePkEP957u+H8BccGCbT/lj08/YOpnxeCLR7kIT68yD6XNCX"
"G6k9dQi/dAGE9aCs8O5i2dwWyLdtx218e1g3vAF2VuH/TZ0ofVNH8dzFNnhB6L3gzfM0Pk+Y"
"Gvl7msP2nPNfxz30relkYEtKCoQXD48+UVuKePjNKHkZG+fmG1Myh+oDGuoQfX1TuJUpMWcv"
"nsP4x/2V4IstgPDPrwurI+exBRD0BTj96poAkLAIZnr7Suzj/Wtr8a8tlhBQWwAgQXv+LP5c"
"BBj9ZVVq8WebrFTGf3ya4f4eJa1oQIm478TimhB1BQLH/aqKJfjj9K8ODx62qBqFjSpFk5u+"
"TnPbv01H5lWDmNfA7VXo+EKAwMKyCgBgAgCG+ZeiE35GFAC2uIykA8SWs5UTk1qAwIp2CBAQ"
"qEwpLP7OAGAdBMSRAA0AqUE1xBgCBAQEBngsMIs/YCAYFoTbYKeDa6rPYWliLgBgHXcENBAI"
"UFMCrQDQXI8C1uLPU/5cAgAsysMCAB3UKF8u/JPiPxX+l3G/Mb52AOAaABMAIPxHurkEgAv7"
"OzrOAYhm799dzQFg738HvP/tjfHz1qfMzVznUJPiFlW8DdGYYVOT/zj3z8XgVu+fw//W/D+n"
"jg0AeDIH4L8AAH7LJECe2MSTm/iF4xCONQ3AhR78ovOLzwMgeBDE6CbVnwuUWoBcX6L8HkQX"
"+gMCOApgAMAkxzZA6yCgfxkAxDnm/X9yLvQzPH9D+DMtdsZ+mqF/I/fPQg/h/iVHnf8OAPg1"
"xwUAZDgBwGlHAPj5pCUCkAwASNTeP7z+O0fF82fx/xVg9MvNOBh7/xz+P6gBYL8JALwFMPPA"
"Iur5lI36/8lG4dN60INrB2Ux0M/fqkjA3W8j7RBwGefXES4iABB9XQPAaQBOB5gRAPb8CzbD"
"NgkA3MrbCPEPgfiHKPFn4c8JVgbxvw7xv561kq5lBYqx6LNdOqSMxf/CwTF04cAoaf3jLYBc"
"uJfHYfzogcog+uc4v7+zn4h/rg758yAgmQMgpsRfQGB7Dw0A3ShzW1cZ+8uePW/2S9/QQYRe"
"xJ5z9SEekqc/tbadePun4Nmfgld/kr3+Va0oeVVLSgYAcO4+CYKfuFzl708sa0rJS5ToJy+B"
"t78IHv6ihipMD+FOWAhh1ibXEPR4Q9AljM/Cr8T+2DwI/9zadHSesjg+F0DU/dwUTBh5fjHA"
"A0MAe/ws/n5a+MX7hy3W4q9rAE4sdcPPW59WDyhLrfCW1+6PNvLr+CmdXNuCUlZxN4EbRBmP"
"WV6XkpbWocW+H9GUVn+n6a3epqN47rF1X6EW+LrWf7BRW/y7GlPrRfxtGuKxtQABlfGzlMf3"
"LmsHAB0NkEjAQg0BixUIJC3RtpRBoJyYAQBiK7UBAn4zAKyqLukA41QwUEsJPov/qhpifC1m"
"AQA5HwUAoboVUAOAFAGK+Le2AwC3++22AkD7QgAghX97de//AV7766sAgAf/OAPAEdUGeEXa"
"AI0uAB81DdAKAJZJgIb3n7ud1xHzbgP8Lhu55qEGVfv0j4E2tfmP3++5BoxnwnDun3v/De+/"
"ttYJowOAnccnkwD/SwHgYbsAeGYzV2wadQBMcs5RAA79cAiIQ0EcEhq/7PMSByjHm+hcF6KC"
"3kQXB+s6gAkaAPQgIJkEGOA4CdBIAfxWADA2/0n1f5ye7a8r/g2v/65u7zM8/3uZykzxz7KY"
"xfN/GAD88hgAYAWB3w0AFs9fAOC0BQAg/D+niPf/D3j//3v3hMX7h/jfgvjfihX75SY8/5sx"
"AIBDEv43vH/u/Zfq/2v76NvMzdT3aRsNe9ZGK7o2xH2xaj3w1SiBgLvfGl0BDACwryM1AGy3"
"Q4BEAMLFBAAuqCiAEn94/OfZ84f450P880KU539uHd3MYc8fXj/E//rZILsBAH7IDKTvTy+i"
"i4c5j2/3/C8cHC3iz3l/Hv5zft8IKtg7TIr5RPjZdkH8d0H8d/UBAPQGAPSmsxE67M/iH9Zd"
"Wzcl/jwi2ACAsC6q/z8U4r/Ji9JlqY9a7yvGor/aXQl/cGuZpZ+8kkW/BUS/hZwnV2rvn719"
"brtb3gTec2Mzh28P69dT3r4fC3ttOgbhV968hgEGAL86yhao+5Tg16K4ObUAAbA5NeTzVT1K"
"0YRGf6dJzd6jHiX/BoFurCr9pRDQDcJbR0OAIf51VfEfBP/E0vrKltSnxBX1KWllI9o6ugq1"
"46mHf7bR8h7l6Mym9rRxWGWa0+4DGlHtRQj/p9Trkz9RGwh9G+6OgPm+aiN/70/oyMIG8nXc"
"hjkOAJC+vjmEth68+mr4OSrg+5cD9JRxNCMSwCCwqLSAQOIibdwiuFQBgEoFVHAAgGQ2hgCO"
"BvwGAEhdCQvk9ICGABF7Fn4AwEp8jvtP8ecaAooCgAxnANDDgWRR0Lbm9i6AxwUADQEGAFza"
"11F5/geV+F9i7/8hAGCdA6AGAXUUAJAUwF6nbYCRXJcA7z8M3v9W/vm5vbEOTfB5i7f+GaF/"
"7gDjibBc+c9F4U21JnCK2Br+N/L/T3YB/BcCwMO2AVoLATlvwy8gkxyHdDi8w6RnRAF4RbBR"
"EMhDIT6LW18zg3J8iPK6E53vp4oBr4xXKYCr01zsAnBRA+AwCdAKAEYNwE6If5T2/g/orX+x"
"es5/giX8f8qp0M8Q/iwny9b2MACASP+Sq04TBixg8CgAsEYDCgFAziMAQAv/g1PK7mszxT8Z"
"lkj/6+z9i/gfEVPe/yHx/lXxnxL/Bz9Emzl/LgjshzdqHt8b3KcZAOEo7jukUgFXo+keQODe"
"N7sBAbt0KiBSogCcDpCaAAYBFn+cAgEXVAHgnYvK+7/F3r8BABz6z4Pw564V8b8J8b+Ry+Kv"
"zYgAZCsAuHrSH2924ywAMFoDwEi8oY20A8D+oRYA6C8jdDnfn8sRgJ19AQF9KIchYEcvcxAQ"
"RwKydnQXz58r86U6n28L66pz/J0oY5OXXuyjAWBNGzFD/BkEUoIYAJT4J63gBTuwwObSZ5+8"
"nMWfIwDwnJc2Vq14LPwwKdLjMD2LPIv9/NoKAtiTZxBY6CT+prfP4l+TYmfDIP6xDAK4Pahn"
"aWr2F5vsDGgNr11+rlX8czWR73tisZuu8q8rQMCjfhOXwjMPbKStsVjyysb42qa0bVx1ao/n"
"6YLnDOpXhTK3edO0Fh/IbZ48ZOlPPLa5IsUtaU7ePBsB/4Ym1n0NfztPOrOlnQxu4hXOXzbE"
"bZv4b4bnX8qpgIqAgHKwsnTc3w4AUhiojdMBx3lKoEwKBAAstgDAcgDA8grKVhgnQwAAYKWO"
"BKzSg4CCLEWAUgegigAZAFIAAyz+KYHqFBhYWcP0/E8GVlcAoD8/ZQEATgGkr7EAwFo3PSXw"
"dwJAFIuycwTAAgD7vcWTvyRz/jsXDQDGICDrJEDLKGBXAJC3A95/WBPK2daIzobWpyx4/8Fj"
"S3DV/2f6/d0I/XMnGLeEc1E4e/8cGa5jcx3+f1gB4JNtgP8FAPCoOgBOA/ALyUTHLy5THld7"
"Mvnx8Af+x8CpAK4KHcX1AFdiW3xP5zoT5fckujhIpwE+VzUA381+yDKghwGAtQ3QWP+rV/9a"
"W/9k4E+SZciP4fmfsXj7VsF/GAAY1f85TgBgXOcUAQBnnYTfFQDkWPL/zgCAn+HXMy4A4KSy"
"+9p+TpbQP3v//4D3/7+G939Hh/4FAA6LSeGfFP8dAABw6J8Ffw89kNY/BQHcDsgAMPZFG80o"
"/zxNKfscDXvORiM+eJq2fN6Jfjy/AxCwl/KOBdKVU+vo3rcaCL7eraMBkQIB0t7Hp0QAtikA"
"OB8Kr3+zCv3nb7B7/zk6588AwBEAFv+cIA0AK+l6JgAgayV9mzxHAYDh/QMAzh8apcwAgL1G"
"CgAAEN1f2S57FEBMQ8BZw3aoiYD2ToDeMiCIrzk1IEWAod463+8pFfss/Fy1L1X97PlzIV9Q"
"K+nRZ48/NVB5+2JyrUy8/2UNRWyNfvzExfUgbLqwz7+e6fmL+BvGUCA5fx32X6DD/nOV5x+r"
"7SiA4OiCOhL2717yOZl34Anx5RoFTlOkrGIwUT/DCYAHWyK8/Y1DytOomq9Qtw//SC3x1ub5"
"PLz1+m9R/JImlLqmBW2fWJO88Fy8hGn1wOrSxrhnRmPx6hkKJtX/O/5WvgCmTjKmuSfEfnKj"
"v1PWdm/KDPOiHs/aqB/+HU1r8ib+nu0pfS3/bWpB1CsVBoCFTgDgV0pMDQkqJQCQuKSsQEDy"
"MgDAsgq4huFajCEgEOLPtrIyzspqDoC1DVDPATDC/ila/FNW4P4V+hqifwqiL+IvVk0+52gA"
"m4oCOAHAGgUA5rIgy3jgQikAowbA2gXwuADAhX/w6q0A8FVs10JdAHYAMHYBeLsEAE4B5BsA"
"sA3e/5aGlL2pHh0KqPL9Myrvz1X/PPzNCP1z9JdD/8bgH8P75/n/7P1bw/+Pk/9/AgD/ZgDg"
"D2cAcK4D4HAM52WMNADna4w0gNENwGTHIR6OAnDRB/8j4DwQ/6PgrgCpBwAEzLwS1woQ0JWo"
"oC8ggGsBOAowWdUAGCkAhzHAD9sFYJ0EuFOH/10BgJH/Ty5c9OcQ7rcKfrbd7ltOAYCzdpF/"
"JADkOAFAjkX0nSDA7PV/FABw7j/N7v3fdwSAfwgAJIn3/4+7xwEA2vu/E6cB4IgTAHAEYD8A"
"AN7/jyz+0bDdavOfXO+jSZXfpHEAgEmv2OjON4fp2rldNL3W+zQEb+JzmpSin78/RAeXj6Du"
"8C57PGWj8WVeJL9W5SkfULBjqg9FLehNp3fO1i2AugZAqv4N8dfh//wQyf/fynWMAkgKgAEg"
"ZxX9cHalad+cmEmXjkygC4fHKwg4OFpV/u8fpY1rAEZIB0Be9BCBAAGB3VwHoGoBJBIAKMjd"
"pSICu6a1hNj3k1kAOQCDmW2LiwB2e/spOhHkKyt6VREgAGBzR92nz96/uwkAUugX1FLZquYK"
"AFj4Oc+/rLHy/GXSHjz/FY0pcQU8bIaAJQwADenL5h/QmAbvqGp/jgKY+f/aZug/wY/D9m72"
"iv6FdUXoVeEfG2Bgfi06hpPvY7DoVfZ5WXDUCYKcsqYDLelSgYZUeYUGlH+BAruXhgDDC1/e"
"iOZ7fiTjg2e3/ZBO4vfy9y5B7Xli4dPKqz+1zp12fFabOuLzbhD7tQNrUFZEV9o3q5mIf088"
"/7Smb+HvyBGULtQL/076AyCm47azO3wBAB2p19/UtMaZzRkUOlD6+haUsrwOfmcAgH95BwCI"
"N1oDDVuo7LgeFyy7AhaXNSEgaWl5XMOWKmMASOIoAJuAQGWHQUApK6tYIgDV7QAA8U9ZXlWd"
"DAEwFv2TOFOXVxMwsMNAdV0PUMuSAqjlEgCkHXBzI7UmeGuzwjUAJgC0eUgRoAaA/R0BAJ3U"
"lj8GgMNq6Y+E+fUIYHMOgAEAuI8jAMYyIIOUXlwAACAASURBVHsKoINZAyD5/0guTOT1xOz9"
"N6CYRVVZ/Gfa1Lx/fl/vaVMpX2Poj7Xwj1PD7P1X1xrhKvz/gc0e/n/V5hj+txYA/ks7APjj"
"CQCoj4fVATwqDWBEAZjsuBaAac9IBfA/Bu4K8LGpfyT8j2UMIGDWldjW31NeD6LzAwAB3BHw"
"mSoE5DZAYwqgeP+B2oJcbAPcbN8FcGM7RH+XEwAc0tX/R3X1v7Xn31r1f6aIFIAVAM5q8ddm"
"FX9Xou+QAnCKBDhvA7RCQJEAYIi/MwCcKgQA/7jP+X+I/71ECwAcU+J/J1YK/xQAxIiJ+N84"
"CADYBwBQoX/2/hUA7DajAH7tq9GYFxQA/HIjEaCQQEdDptBIeHCj8CaeFD4fEBBDUX4DaABE"
"YdCfbXQidAbdu7qfCuJXUVf81/D3qEqXElcqCOAIAOf+Ifzbp3nTprFtaCPs6JqREhE4Ez2T"
"krdMpG9OBgoI3MhdbSkCDDKjAd8kzMCb2URZ93sJEHAJ4i8pADaODMAEBBgC9gyj/OihsCEC"
"A/nRgylvD4AgirsCBgICBtKGkW4i9ueihgASBkh0YFjFlwk0Sx6Am72z20hkgHv+pbVPagA8"
"6fTatnSKAWB1ayn2OymeP8R/ZTPt7SvxT1zGYt9YwYAYIAAnT+XjYT1Jy5rQAs/iBNeJPmv6"
"geTpj0svv5uIOJ/Hjap/8dYb6PB9A9xenyInVqMJDf9OfSu9SENrvkbzOnysw/n15Xv3r/QS"
"eUGgu+J1G1n9FRrv9hZ1xOeef1bFfNyemAxg4b+BO37fwRVfoDTATeSkeipnj8cu6VpeCh3X"
"Da4sof3uEPu1g2oAmAAAs5sJELC4z/P4lM5GdBMA6P03BQAzmr9D2RGdKSu8I/UEFAzg25q9"
"KQCQYQJAZXj2XANQzu79awAw6gAcAMDPWBhUViCAAUDEfzGf5R4KAMkCAWoqIA8GUlZNwv9K"
"9KsC1qpoCMBtLPq4Tl2mDfcLEBgAsAoAsAriH2S0B7oAAHNTYCO1JrgoAHCxC8BhDoAVAA44"
"AcARtfzHAICvj/W0AwB3AZg1AC6WAUkEoJ0O/7egc+FNKQfe/+HF1b9/5g+2WTZV9McD37jO"
"y8j7c+rXOfTv7P2zs2h4/48K//9b8//88QQA1MdvSQM4dwM4RwH4xWbq4/APh4G4GIT/cfA/"
"Ev7HwvMBFATEtQEE9AIEDAQEcEEgFwPOUm2AnAIwAYALABkA1tn7/w3v/0aY9v53aPGPUjMA"
"xPs/rHP/8ZahP9bqf0vbn0P1/8MA4Gxh778QAFiLAF0BgDME/GsA4B+G+DsAwAknAIDw3z5i"
"AYBDGgAOiPj/wqH/H5T4P7i2k+5/Z0QB9tLCdlVpJN6sP3vZRj8U7KX7P8ZT3rF1NA5QMPFF"
"GwX3bkL3f4ilmxejafyHT9NwiMLs2u/SzfNR9G1aKA17G1+Xu1VN/pM6gK0wVfl/9XQwDXr/"
"GYIbQZ0hOhOrvSsnmy9s0/j2lBQ6gaa1LEMTan9A01qUofRdU/B8a+HZTJHBP7lRoykmoBMd"
"8u9IB/286WzUSLoc+xldhF04otsCAQUFYqOoYO8IGQiUL62BQ2RJ0MbRDcidq9ph+cZUwD2D"
"6cgSb1raoyqtGVRXpgAyAGRt9QUA+FDGZi86vUmlAIyK/5Pcx78K4h9oDfs3AQA0Eg87ObAp"
"RKaZ1AHwLAAuCgwfU0M+D/AuRQ3w/Rvh9x5e5x3aOKgq7f6yFo1t+C6NbfQuTWjyHo2EaAd0"
"KkktIap4t6Uhtd6QNMJi35Iyjrhbib/QhoEVyPu9p+R+H7weMtM/sCUNqfoa+fKYYgDAvlkt"
"JY0xru4b5IPXqxOEO3JSfUpd3Yamtf6IhgIWtoyqSYs6l6H+xf4oOXwO5a/sVZnOAHyWdS1D"
"PgCAHgIA1UXo981qIrl9BoCQwTXh7Xeh7LBOkuvvI+H+tyD+3rR+cBUBBU4LjCzzJzy2kkQA"
"UpfXVQCwsJy9FZDFH2YUAMoJ0WcgMABA6gEWlRGTSACLvwUAEpdVAExVsIPA8kqwymIpK3Cu"
"UGcKi31gVfH+k50BYDlfs/BXsQMAPj+5wgoANQQC0jgVYAUAtvWuAcChBsBIAehRwAwCDtsA"
"9ShgcxCQmQLo5JACkAiAKwDgSYDWXQBmEaAGgH2eMgOAlwyx958X3lzC/4eX1LCKv9Hvz3Ve"
"3PXFKV9D/K2hf2vu39n7d67+/4+G//njCQCoD1cA4CoNYHQDFBUF4BeYSY9TAUx/Rj2AtSjQ"
"6AwY89xfGALaKQgoGER0iesBJgMC5uhZAEtU+P9HDv8H6/C/Uf2/WRf+wfO/bgwAilLe/619"
"lsl/8Zbcf7ILAEgvohjQKSVgAkCOsgc5TimAoroAigKAs48AAMvmv1/PagA4Y7dCAJBqF//7"
"KQCARA0Ax2HxAICjDwGAgzr/zwAA7/8HFv9dGgAiNQDsobVDWkm4fwLEvuDERnpwPZ5uXzkg"
"APD5SxCAfs0BAMfw+CO0b/EwGoE39lF4/IGlI2jHtB60fngbuvv1Lrp7cbua/ifV/xuV5YfS"
"1PqfUvenbNT7aQjTosF0++IOmuNegXr8CaKD20aUfAkg4EljqrxNPk8pMCiI86cr8dNo++Q2"
"1Ab/9cZWfYOC+tahIaWeJ/yDIz/PcnRu/0S86U2mee1K0/gab8HepkW+VShqVnsaU/V1GlX5"
"Ndo5vTV+PzcR/o54bp8/ck67Hm37vAUdWNCOlnSvAq+3Ci3uVoWOB/tQ5ORmNNuzNM32KEWz"
"2pek8LH1aEXPyvC6X6U+FV+mxV3KyYQ/Je7Ntfff2BT/MIh9h/eepnav28j7o2fI4w21R2Dn"
"xLrU8jm1wY9XCnu+aqOB1d+kjYOr0opu5Qj/oagxfm93/M07vvMUeeC1aInH9i33Aq0fUEWu"
"2baMqA4Ptjkt9Cohuwk4578MPxMXKo6q9aZ4/7zYKHObjwwyGu/2piw76oLXLHpqY+loOL68"
"BX6/T8gLf/sZrT4if+/S4umzYK8eUJ2ywnzxO1eU/D/ftnYgACDch6JnNCTfZxQUzAZEZIV5"
"06oe5SQtwPAwtuqztHV0dVratQTt+rI2YKMFQKoNZWxoDYACJC2vqSMAPBmwjB4HDPGfp8Xf"
"MH8FAsd1HQADAO8LUDsDysIsAAA7sURBQJJYRW2VYJXVuRRAIKeCgGSL8NtP2DJHAEjBtRUA"
"jFoAOwDULgwAIv4PAQBYbngr+zrgCIYAd1n/K+uAdSRAAYBqBVRdAD5mCyDXAFhTAAYAXInr"
"qUYBuwIATgPs5dHCvG2QIxDN6dy2pnRkeW1n8eeKf2vRH3d/NbbZxd8a+neV+3f2/l1V/xcV"
"/n8CAP+Gj98bBTBqAbii05gLYKQCGAI4F8RkyIRohQAVCfiLbebZva2+orw+gIDBgICxRFem"
"AALmqloAjgIIAKyG0K+35P5Dlfd/0xD/XRD9vbr974DK/Zuhf6Py3zr1zxUAOA0CskKAAQAs"
"9oUAoKg2QKv460l/v/w/9t4DvMoqXf/ezsz5z5xxZqxIkyK9996LolIEpVpQsPeKiFJTSEjv"
"ISGEEnoHCSgtvVcIvSpBQER6SdA5Z33386y19l77zU5I1CnfGfZ13df7ZiekaLLv31NXBel/"
"lwBwwAUA7CkHAHJk7Z9FACCj//+5ZgJAojMAXFLR/wWY/49bFABsYgAoObdB3Px+vYKAeLHO"
"8yXxBl7EKeV/LG2xKP0xRXx/cKP4BG9Pvc8mFr7+hCjBczcBADe/3yHcutQQH8JUpjX5b+HR"
"vbY4njaPmwJ5IoCX/8RBi6DFAIAlwnd4ezEBZk9fo2hrgLh6ch3A4UXxCszkFTxXsMFTXDq2"
"XKycOla8iI+jj93k+QLv/P8Cn58M/0V8H6fSPETRxk/F8zA9gofYtwfwx3yH55+jhjU893pN"
"m3ivyd1iLB0IBEP9tGsNsTN4nHiz4R/F8zC8l/A1F384UKydNlhkL5ogPuhYjUfZaOQt3mOo"
"SI0cJd7vWp0X4AzG82TELza+W4yu+Tvx2F0yKg8f307O/dNpe5Taj+jPotT/YzBCvFqKBN/H"
"uXwQNaGjGITPnb9gmFj9cS8xBN/DCETW7+Jr7Fn6jMhbMJS3BdLHDMb76LTBRL/HRQLkO6q5"
"2OH3qPigR3XxFH6+4Xh/etiT3Hy48sMusuEPP89HPR7C5xotPutbQ7z0VwkARavGyud6Vhfj"
"6fRCaIvboyJj7lDxVqs/i1H4Ou+0uVvsWT5SzIXZ6yg+lhv+nhVzX25nj+IDRjYR6ZFDxbR+"
"NcVY/Dd+u9HvxNReD4p49z5iyXvtxbbZfcWeJUPx9YaI3YufEHmxA0VeTD+RGzNAFMxX9/N6"
"iazQLjwGmO5vAACl/gEAqQGOXQBk+PqkQCcACGzJ+wEIAFghhkJ1X0BbXEntIGn+WWHt5DWE"
"QICgoCOLzD8bVzJ6umaHdbwtAMgMgDR/XgWspgCcAaB/uQDAa4F5KZCCABMANsqSgC4FyJW9"
"8hTAb3kJ0LMSAm4HAPosAHMM8KtRKvon8x+M6H+QiPfrWgzzp5r/J+p122r+ZtMfpf572Byp"
"f/ICa+e/Wfv/l0X/9LgDAI5HVbIAuhfAnAighQ7mWKCeCtBNgSYE6HIA1ZCokWRqYlz/InHk"
"VSGOvwMI+BQQMEuIsz6qFBApMwAXFkKq8//iSgUAau7/crwa+yPz3+Fo/Luq5/71SX8mABQa"
"AFBo7ATYbWkQNGr/nAFQ5u50BoBl9t8OAHoCoDIAsF+t/DWnAQ7I9b9/32sBAJj/LbP7H+Zf"
"ki1T/5z+T1fRf9rtAeCCBoB4AMBmu/mXnFsvAeCszAKsmfWCeLfWXcJvUCux8J2h4srJr0Ti"
"wmniYxjC54hI8zYGi5LzSeLG9zuhbSJ9uZt4/27ZH+DZ/WFx8zSd+rdBrgHmbX+LxOXDC1l0"
"v+LzkWICzOtNmGPRFn8+BGjtrPEMAK/CYHZFf8LnAuSvdxMT8dzrMJ4100aJ05lzRErMq2Ja"
"rzrCe2gL8R3ePrDlC/53b5ExDW8tzuYEiDNZvuIVfO7X/yy1f/NnYkfIC2J63zpi/cxh4sSu"
"z8WMvnXZ/F/Fx32bPFMc2/mpOPL1+yJsQmfxNMECzPQrrxHi4LqXxZczH+cTBUfge54yoIE4"
"uGGi2DzjcY7cSdOfbApzH8FNgLmI+qnBLyt8gFj9URdO8VOUP6HFXxG59xBZ0U+JkOfacCPh"
"6km9xTAY70g6CrhXbUTHY+xnAtDnpZMGR+H7pxR84ZKnue8gH4Aw+n5Zx6d6fkHccETWQwAT"
"XRkI6DmK8otWjhVT+9cSE/D/ayJUtHKM2L1slPis10PiRQMANk7vy5E/1fxfg5GvndxbTKwh"
"I3iCgDdr2cTKST3Ey9Vh9I1h9H2qi7kT24jtc/qLjVO7iYLFT8Loh7EKFw8RBYsex/c5UJr+"
"/P6Akz4w0x5QN0BRN3kN7woz7sQjgGmBrUWq6vq3AgCbv38L3gPA9+UBQFArqWCpdMBAuh0K"
"qD8AABDSjiGAzJ+vBAQhdO3AmQC78HZ2WAc2/ywLALguAcgmQD4LYEFPdTpgH+4BIMkSgAIA"
"Oh5Y9QDQJkBp/goA1pQFgMMbZEngqOoJkBv79FkAehHQOPsiID0F4FQCsB4GtE2OAR7fOlIc"
"30zR/xAGkUXT2hXR67N6ndY1fwrirOaPX2mnur8+9Mea+m9qc+7817X/f3r0T487AOB43GUr"
"vxnQmgXQmwHNxUBmKUD3A9wOAibYZGMgjZJ87vZei83i6OuAgHeF+EZlAggCeCnQXDkFwACg"
"zJ/S/5dV09+Vr9TGP3XqH5t/ejnmn++AADZ9dQCQ+T59GuDNPc59AWYfgH0PQHkAcKACAHA1"
"ClgZAMD38zPg5CeY/618FwCQqaL/NGX+twOAbbL7/8IWBQBk/hvtAFCiAeD7DeK7glhx8cQ6"
"UXp+p8hY4SFCRncR4aO6irnjeoqibZEw/2Rx84cEcePsdm78u3F2m3DvXFN8AEBInDcZABDP"
"y4G48Q9R/+WjC2D+seLSkfm4XyiWf/Y0R+yvwWD2bJ7DewI2+74qXv6TNOT17i/yIUAFG9zF"
"a/8tQWHV5yPEGRj+6fTZgIDXRPhzncWkFn8Rbr0fFm/DzD6EyYWO6SjO5ASL09kBwqN/ffEu"
"gOR9PH8KQEDZgpNJ08WJBOoTmMIAMOGPEhBylr0DAJgMAHhPhE/sxoZIDW8bAAsHN77Gx/GO"
"gCGPwsdHv9xLHNr8moj3GMLR+XCCj841uEGQzJnKAGT+OeEDuPN/bIM/8Rw+deNTdD6mmk34"
"jWkFs3xapIcPZgAYjZ/v0z61uUZPY4aFi54SE1v+lc3/Ofxs+1YBDOKo74BS54PFqy3+LMbg"
"v9Wz+HdJwYNFLsBg9cfd+HskAFjwelexZ8Vo8UW/6hz9cwaAGhjxuSf1fJDT/y9Qev/1juIr"
"937iGfy89DOPxff3bpu7xaYZfcTUAbXEzEdr42enaH44NAyA8hQ0QhQteUrkL3wCEf2jIh8R"
"PaXz8xc8CtPvL3Kje4vsqO7479BdZEV247W/0uzbs+FnBOIaSNe2MH5l/r4t2PxTlPlz3d/f"
"MfvPEEBvBza37wRIDzAAIJDu5RQBTxLgnrYL8mRBMACA1RYwIM2fgCCL7vH9UBYgE6ZPYhgI"
"bS+yQx0wkIOrownQEv2rKQAeA1SnAZYHADwFYAcAyG7+lQAAagzcOExu7IPsxwHrdcDqLIAK"
"AUCXAGgPAP4tjRke20RfZ7B4Z2SdzTY55/+Rep2uivmbdX9r6t9c/GNu/rNG/66a/+4AwD/w"
"UZksgDkRoPcCuCoF6H4A3RSoIUDvCKDGQJoOoBFB2hNAe6Q/G9j13qiLOc9fEcc0BExXPQEh"
"ahRwMYx/OUxfRf9XVM3/CiL/q3TgT6KL1L8r8883ntNX/XH6qssERcYxwOYeAHUWAGcCzKOA"
"jbf16J82/lsHLYuA9jvLnvLXAKAOAPq7Yf5OAJArReZfQtF/htSNVK79/8+1FJYEgMSyPQAu"
"AWCDQwwA641eAFoM9DW0TdyESn7YxguBbv6wS+qcNv+v+Jqx3F28B1M5s3spov9N4rqO/o8h"
"8j8E4z80T1w6HAPFiiWThosX/iDT/VsD3hRXjq8Ueetncrr/ZZjQWrfx4vJxAgAPjv7J4BkA"
"sv3EvNf6iOcQUb/4eyoLjBJn8oLEu3+RewvCx3UWZ3JDAQGBIuDp1gwFHzIA+IlTqR7im6Qv"
"xHEY/fEdk8XswY25tECAkTLvFXFsx6fcCEgAMAbPP4evG/1ab5j9G1wKoJE4Mt15r+K5L18T"
"WwAAlLqnGfsPejzMKXaqu2fznL0c8yMASA19HIbfVjxXQxr9SPx8w/Hvlr3Xiz+eIGIMAUDv"
"WmIvAUCcHDN8t8tDYhx+7vH42fauHsed+PnzB4uC+U+IwLFN2Kyfx7/bPLM/jHeY8H2mEX+P"
"b7e6W2RGDRNZ0cPE603+IJ77s6z3ew6tLxa91VGM+SOt471XTOr+gAh5trnIi3lCbJvdR6z9"
"pKuIn9kTUTul7KUKFjzJK3/zYgfhaz8Gk0d0j7fzYx8TOdH9RHZELxh9T5EdCc3twXP9WeGd"
"oU4iE9FzBgyUx/zIfCnVTwcAkWD86TD+lDmkFo7jgH0d5k8p/4zKAACZfkALexNhGvUQ0Chh"
"ACAgoBXvGMgIaiO/PkQgwKKsAL2tAQBXMn++8r0FACI6O+8BQPTvtAiosgBAuwDUmQCHVmtV"
"BACqHLCBDuoZxg17JzbLcoA8E2CU4zhgdRhQGQCw9wCMQ/Q/mrMIVFbIjXv0Stfmf46yyaN9"
"6XWZ5vwn2GTQRg1/uuZfnvlbu/5dpf713L/Z+f9Pjf7pcQcAnB8mAJTXC+CqIVCXAvRUQGUg"
"gBoDaUSQ5kdpiQRtDHwP+pSaA/M2DjsiIeBjIYrptMDZEgJ+iJF9AJQBuEwAsFWZ/w7D/FMd"
"K3+vaTPPsxi/afTqXvcJ2KHBWBZ0c4/r0wDtY4FK9gOCrMcBH3BuAry1v6z5OwHAQeMEwH0K"
"AJT5/1yoACBPAUAOAADmX0LRf7oUAODv3PyXInVV7v1n87+yS5r/RQ0AX6kSgHP635EBUAAA"
"3TyH93+/RZ0IGA/heg5m//3XbPini5aJwKGtRNSLfcSFYxtEwrxPxYLXnhA3Tm8FAFD3/0px"
"jWr/Rxaw+V8+SAAQLXZvnCpeuM/GNXpKwXsNaSNOpASL5Z+N5Jo8QUD0a4/xEcCUASAAoIZE"
"v2EtxOkcf+ExoKEYj39LJYRDX8/Av/XhRUUEAJ/ca5MAkB0g/Ee0Fh8oADgUP10Up7iJE7s+"
"k1MBX30o5r/ZgxsOJ+LzJ0VNxPOf8OFBERO7i7H/T5przBt9+SyBLZ5DOUomo57c7xEAwCsi"
"fe5ojuopSv+kd12xb/VzMO8RIjfKAQBUDpjY6l6xZ/kobsJb89lA8Xx1CQ0RL3XgnQIEEQQW"
"73Z8ALAwVEwdVF8ULIZ5t/4rR//UwZ+7ANH7wqcQcQ/irXyUBfB44mH+Pt9pfbfwH9lIjMbP"
"/067v4r00McACYPF/FfbCv9RjUXkCy3EusndxJpPuwJOHuX9/TnzBsHUH8fnewzR+gDe5Z8V"
"3kfu9KdrRB+Ye18I93OhSET1ET1FTmQvVnZED07nZ4Z1QaTcSamzvIbA9EPJ9NuJdJgsReBs"
"+n5tuM6fRvKV9X42fiU+Dti3GT6umeMcAAMAdA+AXghEAEHGzxE/v1+avzxWGFDh11J+PYIA"
"/1YSOgIBAgQjGgI0AChVFQCcFgEpACii44AXyvq/AwD6OQOA7gVYJbMB5QOAfNsOAJuGsY4T"
"BNAJflvVqYDbxwAAxomTCc857wFQAMArgWkPAEX/W0Zx9L/Or+eRP/2Om/0+Va/Hr6nXZ3qd"
"pswtBW+/1Pwb2pxT/9bGv/Jq/3cA4J8EAPS4XRaA5jPNUoBeDkTdnPVtzv0AriCAOkT72Rwj"
"grQ5io4QpqYSai6hDlOqN33xwfgmq0sPvFoiTnwkxMnPhfgOEHA2VIhzMbIRkBoAr6jaP0X/"
"iHLFNTL/NCP1n+dCyuy12PSz1SFBWc7/Vh8UdFP1BTiBgAEDpcaK4FJDt7TM44BNANhnXPep"
"4351KUA3/7kAAIr+GQBg/qXZAABE/SVk/mlSN2D612Xk//drSQAAi/lf3gEA2GEBgC8dAPD9"
"OtbN79cCANYpENjIxwDfPPelPAnw7CbWzbN0/yVv/zuWNldMvMsmXocxrnd7UXze4A9i/44I"
"AEC8uE4bALn5b7G4cpjS/zGAgGhx6WAUhOvh+bwEKG/ddJG7epo4mx/BWYFln44Q899+Usx6"
"rLnYFvYmQGAAbyV8C8b7wcN3iQ0eI0XsW304+p9I5xU8bBNftL1HfFIf95Tuh2EunTQUAOAr"
"3PrWFW//RcJD4txXxcnkGeL4to/F0a3v8hhg1CudeQJgPD7/wvf6C5+nW4kVkx8TERO62jMA"
"MW/0EYc2vym2egzj6JrS65P61BcHN04UB9aMtwPApN51JAAskQCQGwnzj+jPS4GoM9/z6eYi"
"e/4zLFrCM+5BfE+BT3IH/tgHZGlh9B9ldiDm1Q7Cd3Qz8TTN4ePnfrv5n8Skng+JLW79RC4b"
"+ABcqZFukNgyq6eIfbW1WPx2a7H+8y68wpdW92bP7S8yI2hnQG8+zY/3+4fKI34zoMwwCOae"
"GUHP0zkAXWGUnRFdQ0FdYNqkTvj4zhCl7xHRh1BU34n399N9Rigi/JCObPaU0k8PaYd7KKid"
"bOyj5T6sVtzlzybt39x+7K8GgKQ5TXFtyuaf5t/M3vmfHtBMmr+CAbkPAB/HgEA7AijSbyGj"
"fzb+FurzkggAWqiRQioxkOh7aG3/vtj8KwEA3AMQ4VgE5LQJMNooAcRKMQAskmuAy4wBmgBA"
"pYCVjykIeEIcXq0aARUAyBXBUkfU25SyJx0HBJyIHyEbAr9WBwNxGYCyAC/ITYDGHoBiWhO8"
"TUb/B9YPLxk/+OHV9LqrXn/pdZhOdH3BJpe5mXP+utu/MuZvrfvXsTkv/dGpfz33/0+L/ulx"
"BwDKPlz1AugsgKtSgJ4K0P0ANNphbQrUEEB1IRoNMSGA6kiUUqLUEtWXJthkyolLAnf/0eaV"
"v3HEEXHiQyG+BQSc8hTiNJ0WGC0XAVEW4LLKAjAApCuZXf+5zmKzN3Rdm3+mAwL0yOANox+A"
"ewIKJQzYQUCdDli61wEFpUWO525pWWFgn8P07drr2PdfBgD2lAUAjv6zOPr/35va/FMVAMD4"
"rycrAEgEACjz1wBwiQBgG/S1AoB4BoBb5zeKEh7/I9NfawEAagrcIHV2ozoBcINxGuBG3G8S"
"Oes8RMiIjiJidDeRvmIWntsirn+3kQ8Eukr7/hkAYqH5CgDmiksHohgELh+KYRC4dBDXA/Og"
"aNbFQ/PUJsAY3C8QFw/TgUHL+BwAagI8nekt4n1GieWTBsGwHxf7tnwuMuPeEb5DmkLNRGLk"
"RLHgnb7Cc1Bj4Y3nvAc3FR6PNhKJ4c/zSYFHtrwpDm95QyRHjhXj77WJZwEBz8LcJ/eoKbIW"
"jRcT6/+XGPVfcgnOG03uFis+Gije7VKDG+wocn8WEfwSfH6q+1P9nxr4CAK8n2ktChcPFzk8"
"809jgGTUg8RTf7OJqY89It7u/KB4G1H+x71riq3u/UXBgmG8TXCn70ARMLaFCBzXQuz0Hyjy"
"FwwW+fMfF4WxQ7ixsCjuaYgOHKLFOX0ReSMaR6SeTYf0RPblSD2TIngy9fDubOjpId1hjl1g"
"gp2gDiLZpwOu7UWib3uRAqUGdOAje9OCOvF9sm87GDGpjUjya8tvJ+PjU/zbsdL8KX0PYw9U"
"QvSciug+TUXTqUFt1DpfqbTglnzAjx7VSw2URp3Cqf1mbPbU7Jfk05SV6tdUmr8SmT8DAKX9"
"yewD1EZAPxMAKNKXsMDGP0cq2buZhe/3dwAAIABJREFUSKYrQYBSKosyAioTENAa0NKG+xCs"
"JQBrD0DFAGBpAtQAoA8DiuvnPAXApwICAJbLo4EPat0GAKQGi2Mbh9gB4Hi87AU48dVIAMAo"
"AMBYAMA4bgbUq4BPkvnvfJ7LA7Q7YGNQ3yN//J3Ny+ZI+et6v+70p42uFKxZ5/x1t7+u+Zvm"
"b236e8TmXPd/0OY69V9e5/8dAPgnAQA9XJUCrA2B1qkAqufQSIcrCDAzARoCiBz72SRNUkpJ"
"9wWYJYF3bXL0ZOoH45uuLj34Von4ZooQJ2cBAvyE+D5S7gW4uB4QsEUImJyM/tOMyD7XSOtn"
"WyL9LMP4M5QyjaVBRv+ABgEGAH2FSlQ2oJSuu6X4XunWHgkETjCgpE3flF72Q6l/lgkAhUr4"
"+jr6L8mUskf+qRIC7ACQ5AIAKPLfLn6+8DWLo/8Lmw0AULV/u/kraQA4K3X9zDqYPmktDJ60"
"DpE+nQhIRwTHS+M/vVlcPwVYOLmG0/9XTywRV44sgmI5A8CR/4G54uKBSFwj5f1BUqS4uD9S"
"XGBFsM7j/Rf2RcpzAAAHBAKn0t3Fd+lu4lTqLFGcMpOvfE/XtJm8I6A4daYoRqR/MmkqIqGp"
"HPUXJ00T3+yawhsCj259mxv4Dm16lQ8IOhz/ltjuP1KkRD7LhwfxmmA6LpgU/wY3AB6gY4JX"
"PSf2Ln+WVwLTuQB7V4wRRStGs/auGiv2rqQ1wXRI0FC5DRDmnx3RHyDwKCL1wY5Dg+jUwFhq"
"2huM5x8XufMGsSiaz51Pb1OEP1DkzB3A0X7efOqof5LT9fRcVmgPRN3dYFZdYfSGEJWnBZNg"
"6IEdYKrSzBO9W4uE2a3ETs+WUAu+T/Rqife3hsG3gVHi6gPTn9MK9y1Fgjc+Bu9PxH0SIuZk"
"b4g+lu5hnilQKo3s0dY+MvZgZfZs+GT0Uva3g1pIBciu/hQ/h8knw8yTYf50TQ9sCjhoxnIG"
"ACoJSEBI8ZXXVG8CCFznNLdPDaSQ6Xs1k+aPa5KXhIAUDQLcZ6CzABICKgQA6xRAhQBgGQNU"
"PQD6MCATAOg8AD4WWGUC7ACwkvoAnqgaAGyWUwE0y09rfQkAvjUyABT9n9z1Ai8LOrx5dMmL"
"w+pS1D9Vvc7S661O+VN/lq736/W+rsy/i62s+Vsjf23+tW2Oun95qX+z8e8fGv3T4w4AlP8o"
"rxTwSyHAXBRE4yEaAiiNpPsCiDKpL0CXBIhCiUaJSidTNuDLqCdzxInJgIBpQpyivgAqCSyQ"
"S4FoBwBPAKQoA89SGQCd7ndh+lczZMaAmgb5tMAMQ2YmIE+KzJ9gQEMAm742fwUHpbsNGFBA"
"QBBwy6Kf9HWvvP/JWPTjBAAEBLstAJCrUv+ZnP7/Xx3930iRug7jv67Mv1wA+AraKhcAMQBs"
"cgAA1/+1+av7s+t4LJABgI7+5eN/CQBg7gCAa6fW8pVA4DpA4MapdXzPxwFT7f94nJr5V9H/"
"kRiO+i/C3C/uC4f5h+A+DPeh4uLeUHEBOr83hHVxX7A4vydEqihM/ICPP18UIb5N+gL6XOkz"
"hxLpOpmv3yRMFid2yfXAVOs/TocFff2xWg2szH/jRBj8S3wsMB34c+jLV+WBQBtflicAqmOA"
"99MpgCue49G8PXGjxO64Z3AdKQqXPMO1/sLFw7hWT6KuferQz4OZ057/zHB5wA71AeRFPYbn"
"YeRk9tGPyRp81KOy9j6X9gX0tdfZs8J6y/Q8ovjM0F5cg8+hKJ8i/BA6OKcTIuoOUHvcd2Cz"
"l0K0jgg92bcNG3qiVyuYfUuxC6a/06MpzB/yaCJ2zm4qdsEcE7ylSSbCIBO8oNm4hxLwcbvo"
"Y7zl24lkpmSiWoi2UxDJp/pLY0+jBjwGALpvwZE6b+0LpverBT5BMGmK4APJ4JtK+TmU5t/E"
"6TmCAYaAoKYSAMjsfQkW8HEkL1kySPFS/QPeeN9sEr5XXJPwMyTRvTdlA5wBIMUHAOAnIYAA"
"gHoTaBLALAGYAJBdKQAwVwE7jgMuuwq4vzMAUBZgxaNOAEDTAIfWDRGHyph/eQBAy4GeUSWA"
"sVwCKGYAGM+bAWlDYPTMbjkq6p9sc0T9VIK1pvx1vb+/eq02N/yZc/6/lfn/U1L/+nEHAMp/"
"lFcKKK8foLIQoEcE6ReHUke6ObCfzbkkQA0nRKE6G6B7Az4f2K1a9MEdLxTLkoCbEN/5AwTm"
"ymOB6TRA3gWQLE38uo78LQBAxk+Gb1eqkoaAdPXvdSYgxwIC+UoaBHRmoEDea5UWOiDglr5a"
"9JM83Y9lB4B9Smr87+/K+Fn4urdyVPo/QwGAI/JnXU90mP+1BAMAdjoBwE/c/a+i/x83ilIy"
"fw0A59bZjV9nA25SXwBlAhgAVPTPAACdWiV1cqW4/u1qRP50vxzmv4wj/6u09OfoQpn+PxQj"
"LiP6v3yI0v9hiOxh+vuDYfykILsukPYEwfgDxQ97ApQC8XaQOFfgA3P/RGrnJOhjRPW43/Ux"
"nwj4zc6PYPp0GuD70LviGK/7fVscpcOAtryBSB/GvxlR/Zd0zO+Lcmf9uhfE/vUviANrXxT7"
"1oznGv6+Vc8imh/H43hFS0dKo18wHC/siNznD5EmT1fqlIep50UPkkLUTw1/2REw/9A+fNQu"
"1dzplD82eMoGRMLsocxImbLPYLPvyWafEdoNho5InurvgaTOfJ8RTNF9Fzb+tAAYP4w+Lagd"
"zBQKILWF2sCUYfx+MlJPRBSf6NUC5g/Td28idrk3ZvPf5dGYleAJzW5i1y5Px/t2zaZrE7sS"
"POljmnKdnlL1Kb5yJ38KmXxQc2XyzcoolUwfRm4qPYCi/SaI6KGAJmz8aT7qaore5yuv9LEp"
"/HWbAEAgb8iTIICu+HxeStr4oUR834n0NmUDKgAAKgOk+1MvAI0DtpdSIJAdagEAYwzQVQ+A"
"PAzIchbAoj5qGZAGAXUssAkAywcqCKAT+J7gZsBD6wYDAAaz4UvjH+roAbADwFO8xOebLSN5"
"NbBsAtS7AORxwDtjhxR3b31PtE2O9+lav476qcvfVcq/n3qN1vV+q/nrUb/Kmn9V6v53AOBf"
"BAD0qGgqoLymwIoggLpBrRCgdwXovgAqCdAvnp4SoGyA3h5IvQF09jR1qE774MWWqy/ufueK"
"+HY6IMBLiLNhQvywECBAOwK2yLMA2ND1KuBMR/TPEb82/RRDen9AugMC7NkE6Eau1M08JQUB"
"JRoI8FxJgZIGAItuFUoY0PpJbvZj8ajfHmn8rCIDAPKV8iwAkO4CABLsxv/3azD+qzul+TMA"
"bLcAwJcWAFhvB4CbGgDOrmXJDACeJ/M/o1P/BABk/ivEteKl4uo3MPtvl8grGT8ifzL/q8dg"
"/EfnAwBixNXD89j8Lx9E5L9fmf9+mP4+GP6+QBg/BLPXOr/HX/yw20/8UAjt9hfndgeIszmz"
"YfDvixM7PnBo54fQB+L4Dpj+9vfEsW0w/a/fEke3vsmmfwTR/uEvXxGHN7+MqH+COLjpJXFw"
"I5k/mf7zvN2ODH8fG/5YPulvD0x/DyJ8nntHVF8YO1jkxzzBJp9Dhh+DaB4RfDal4yOVqaut"
"f2T8mWEkGHtQD6g7DBsKltG8juwztOFTGj+4mzR5asIL6gjzVBE9mb1/B0SpHREFt8d9O5gh"
"bcxrK9PviF5Tg1pDraQCWopkROUUoSchKk5EVEzmvRPmv8u9kdjp2RDmLpWA+4TZjXDfCPe4"
"2kXm35Dvd3rgbQ/5/gRAQZJXY5FIBuwrU/UU0adRpE6GHySVESSjd4rcUwJlpE8mnqpMnSN8"
"/8b4GdTHKRhI9rUAgK+SX2N+O5UgQAMAvo8kD7pKAEjC95YMiKHnkjyU+ZMIBHRJwOwB8DUA"
"gHoB/FpzGYD3EwTLvQB6NwADgGUVsN4DYB4H7AQA3AvQE+oldlMpYFFvUbS4t6McsERmAZwA"
"gCGAAMBxTPChdQoAaAqgzBjgMHGCdgFQ5M8rgcc4LQIq3DjmysQRDSndP029ftLrqFnrH6Ne"
"b6kUS0FYeSl/c72v1fyb2yo2//Ka/v5pXf/Wxx0AuP3DmgX4NRCgRwRpKYSr5kBX2QC9OIh6"
"A8bbZJqKNlJxWQCaHjaz9/bSI5NKxCkPIU77y96AH5aoMwK2quVAakJAA4E96k9Ro4PJjoOD"
"rqpJAjs8UCYgQwLEjWwoR4EArjcVDJRoIMh13BMUlJIKnHVLS8GANv+fdJOfFQDo7QKH+f+M"
"r3ErWwFAugKAFABAigKAJADALjb+v1+VkgCwQ4oBYJsFADby7v/SH3Tkv1YBAEyfzX+NKDmz"
"Rpq/BgCu/SPS1+b/7TJE+zD7EzD7EwtZV44v5Jl/TvsfhfEfmce6coga/iIAAGEAgBA2/osw"
"ftKFfTD9vWT8/mz8F2D853f7wvxJPuIHRP7ncD2TMUMc2/4OzP5dNvsTO96TQID749vx3Nfv"
"iGNk/mz8r4ojX77M0T6bPnRgw3gpmP/B9c+Jg+ue47G8vSvGAgBG8yE/e5Y9DQCg1D6Mf+FQ"
"vKAP5rR9PqfsB7Lpcx0+op/IohQ/j81BYVIMAKE9RHpIT2n8gd1gfN1hjt25bp8Ok2cFqaie"
"jD+wk0rrd8THk+m3h2FS0x0ZvrymwfjTfNvCPFuz+ZPx86IbmH5KYEturCOR+Sf7NRNJMOkE"
"b0T5MEsy/p0eDXCFZjeAmTcAEEAeFuH9BAZ0vxMQsNMd91p4OwngkDynEUy8Eb4/GHMAFARz"
"RlSfEdyElR7URD4fSKL3NeGPJaXAzFOV2Pj9mzAIsLn7a6OX70/zhXzkNRXXVFwp/U+RPwOA"
"O64EJZ5aMHx3JRMAZqu+gDnNywIANQPytTWXAWhyISOoMgDgOA2wXACgXoD5gICFEgIYAKgc"
"sJiyAIAAAgAeCTQAYDmdwGdsCHQCAHkw0FG9CCh+BG8C/Jbq/tvHSvPf9bw48vVzJTPfarud"
"XidtjnQ/vX5Sh7+u9evFPq6ifmvK31WzX0ubY9Tv15j/Py31rx93AOD2D1elALMpsLLlgPo2"
"x54A2ghFvzS6OVBnA6yjgjoboMcF6ReV0lRmWYC2VE25+082r6WBT6aVHp1SytmAM0FCnItS"
"ILAWIEDbArfLA4KuaLPX1yS5OpjXByc7dgkwCOixQtUXcCNLKUfCwM0ceV+SI+9JJbkOELAD"
"QL5DtwocVycAKHR0+pPxs1T3PwNAnhK+xi2Yf2mmAoC02wDATgMAYP6XYf6Xvob5b4XiufZf"
"et4FAKgpAAKAmwCAmxoAEPnT/fXTZP4rIRn5X0PUf+0bMv0FrKsnYPrHY6X5H5svrh6F8R+J"
"ZvO/cjAS5h/B6f9LFP2z+QeIi2T8e/3Z/C/sgfHvUea/G8ZfOAfmT/IGAMwR36V+BoN/WxxH"
"lM+Gv11dt73Nz7O+egMA8BoAYCIAYKI4BOMnHYTxH9zwPOvQxufFgXXjxIE148T+VWMAAKMR"
"/Y/kBr7diPp3x8H4FwxB5P+kKIiRNftcmH9OFMw/kqRq9mz8vWWtnsbqYPqZwYj6g2H8MPw0"
"mH86pfOd1JmvGcGdZWQP8yfTzwjuKA/ECWoPQ6LVuNL0Kdqn1D433tE4Gy25CdRqAQOWdfbU"
"QA0AMDsYaRJMM9EbkbtXQzb8BM9HcK0P1cVz9fi6ywNvsx6RwsckAgIS1ccTJCQoERQkeREA"
"NEQkDgAABJDRpwcpBasrjD89gN7XCPf4OLoPJADAv/NrCPMleMD7FBRIw1cA4KPMfo66n6Og"
"AT8HA4CXNHqK+JPclPF74Of0aCSvbqSyAEC9AFQGSPG2lAD8LBkAEwDUGKC1BJBD9xG/PQDQ"
"PU0FHKSmQCcAgPlvlOcB6KOBaeyPZv/1YUDc4LdlXKn/pC5pf/w91/mnqNdJne6n5WuUVaXs"
"KkX9lG21Rv2uUv5m1G+afzOb85x/ZdP+ZtPfPzX1rx93AKByj18DAXpEUO8J0GuDrX0BRJQV"
"ZQP0pIBZFphgk7/Q1L1K9SwGgSVBQ9JKj00tEafnAASCFQgsBgislj0CMD9xeYcsEVxOkAuE"
"qHmQ4SDJAQf27ICGgHSVCSAQyFRSQHBTg0G2AQOAgNI8Kc4GqPtb+VUAAP12vgsAyJDmX5IK"
"AIDx30y2lABMANjhBAA/MQBsET/R8h86/Of8Bjb/Uh31f79G6uxqAwBWO0CAzP/0Kjb/66cQ"
"+RfD/Cny/4bMf74UpfsR9XPkf5Qif5j/4UgAAHQwQqb/D4TK1P9eAACM/+JePwAAtMcXkb8v"
"zN9HnC+U5n+uEMZP5p8/G9fZ4ruUyeLYtrfY8I+z2RMMvMU69vWbePt1cYzMf8urDACHEf0f"
"2viSOLxpPK4viENk/hsQ+UMH1j4LABgr9iPy37tipNi7/BlE/oj+lzwldi8aLLvu58t0Pzfs"
"RUsAoNn6bG7a68c1fErpZ5DxK2WE9GClBznMP43q+cGdlfkrcS2/g7wGtOfVuJnU1BcAE6LI"
"n8btAtqyQXHHPa3K9Zfb7fhQHNqLH9ycxbX2oKYcbadwmp2iZQIARO3eMHTvR9j0d3nWtSvB"
"ow6udeS9fo5VX4GCkoKExNmPwEQfgfk3YKX6NWBTTwskwdCDpOGnmQpS1wBp+qkEAH4KBPz0"
"c40ZKNjoffA2ZRjI8L3lld/nBeF5Nn4PHfE3uj0AKAjQDYHJswFIXo5JAJLcRtjGAQBmM2BI"
"e3U2QEdeBJTDVxcAQD0ATk2AziUAOwDYSwDOAMBXlgEAVAKg2f/16jCgTfIkwGPxcv8/neRH"
"M/2H48eW+E/qbBr/x+r1kbatmul+avLTHf5Vifpd1fv1et/6Nsecf3Xbv7n50+MOAFT+8Ush"
"wNwTYK4NNvsCzGyAnhKgXzx9oqA5KaDLAnpkUE8L0C+4FQRSLxR9dkWc8RHiLGUE5gpxfrHq"
"EdgIENjiODyIjg++vNMBArxVMEmJygcpUtfTlTLkVYPAzUzjPtuRDShVEFCS5wCAUlcAUGgA"
"QKGM/FlWAMDn+xmf/1amAoBUBQBmBsDsAVAAQMavdfnrCgBAmf9ZEwDW2AHgBq43zqwSN7T5"
"f7sUgvmflOZ/9RuY/rF5DpHxK5nmf0WZv+z8D1Jpf2X8bP4+LAkAiPrZ/GH8+Z7iXJ6n+D7P"
"Q3yb8IE4+jVM/us3ONJnbcHbW1/D9VWpra8AAF4WR+MniqObAQBk/pte4KifUv5SMP+1iP5X"
"jxb7Vo2SALBsBJv/nsVDJQDwqlsAwPzHeBQvF+afO1dG/zmR/VQGQM3dc7e+NP5MGH9mkJHm"
"18Zvj/g7sLTxk9Loiqg/Q83Y00x9WnAbPiCH19n6yxn6NL0CF6afFkLXZviaMP5gKKiJAwAo"
"2vaF+fvUF0lzZLSf4KkNvzb0MKL72qwEj4f5fWz+XnVh9GVF70vE+5LxuVJ86sG067PS/Bvg"
"+8F9IK5BUEADfP9KQQ1ZaZwFwBXS35fMBEgI4LfnSINPpewCmb5XQ1YyjD/ZxxkAEt2l+WvT"
"dwkAqhSQQNI9AQwCCgK8VSkASucsQBvnHoAQF5sAWR3LlAAchwF1++UAsLS/zACsMCYBaApA"
"nQRIJwAe3fyMOL6VDu+Rh/8UrBtxxe+Tjqmqs980/jfU6+MLNsc2P53u10f40murNn59jK+5"
"2Mfs8jdT/rreb673Nef8/63Nnx53AKBqj6pCAI166GVB5tpg3RdglgRcZQPMSQFdFiBSJWIl"
"cqVuVd0fQL/gZUAAmu7+ca/NF/ZNAQj4AQRCAALzZEbgx5VCXFgPENgszxPgzMB2mRnQsoLA"
"9VQoTUEArjcIAgADNzPkle9VRuCmygZQSYBUamQEdCaAIECb/y095lceAOT+KgD4iQFgmwKA"
"rRIALsQbALDOAABt/MaVAECZ/43vVoprp6T5Xz+pa/6x4qrd+BHtH40Sl+l6JErqcLi4fCic"
"6/6X2fyDxaX9Qaru7w8AkOZ/fo/D+M/D+M8j6v+BzL8A5p/vAQBwBwC4ixM73+H0/tGtUhzp"
"x5PZvwzzh7aSYPzxE9j8j2zW0b9M+8u6/7OIrsYBAMZIAFj5DADgGVG0dLgoXEKjfHSSndp9"
"v4AAAOY/byBv3suZ2w/Rf1+1fKePBQB6svmnq2Y+BoAQtU0vSJm/rvEHyk5+GeXLxj6O+tn8"
"5aE1vDqXD7Jp6Rit4+765viYpvjczfA1m8Komsj0ezAMlMwWppwCcyYl+yJy964HE4fBe8Dw"
"WbWk3OU1AUAg9TA+TirBi1QH/7aOSGLVZaXMgXwBAP4OCEgNkCIQSPOvj59BKagBK5XkT3oE"
"35PMHqT4wOB9Gkix6cPsvXHvLcsPpGTqN/CSYhjwlhE/AUDybBcAoHsAygCA7gsAAHg0w8fp"
"LICEANkH0LosAOgDglgVA4BuBiyklcBlAEBKNgL2sTcBagDYt0yn/wc6pgBoD8CGYfjdfYrN"
"/9iWZ/B7PUqc+GqMyF8z/MoHzzehQ3um21wbP/VN6Zl+KqPqdP+j6rWUgqvetrJNfvowH1dR"
"v5ny1/V+c72vXvJzj+3f2PzpcQcAqv6oLASYewLol0GvDdZ9Aa5KAtZsgDkp4KosoPsDKgIB"
"qn3Rhqtpzz7VNO5g0ofF4kygnBigbYI/LAIILFd9AhvkyYIEAtQvQBkBPmAoQSlJZQJSFQik"
"OIDgJsGAAoKbqkRAEFCSraQBILccAFCNgRUCQEUZAF0CSLL0AOx0AACl/gEAP9kBIN7oAdAA"
"QJE/mf4qqTOrFATQ/UoAAHR6BQBgGQAAkX/xYnH1JMz/G5j/8RgAQLSs8x+di6gf0f4RJZj/"
"lUMhAIBQAACEyJ/M/9J+Wfunej9H/kUKAEgw/x92eyH69xLnSPYMgIcCABrpe1VCQPyr9jo/"
"Gf5hGP7RLbjfAuOPfwnve5F1WEf/62H868bB/Mey+R9YAwBYNVLsJwBYPgIA8JQopNo/ov+C"
"RfLgm7zYx0RejASAXDsA9MG1L+/Jz4roBQjoIcf4QrrDNLo5on4yf1qhC9PPCJZRP83sy7Q/"
"Rf1U55c1fq71cxOaw/jtp9jRnD0fe9tMGj9dYfoZoUohjUUazD8tmKLtRwABMNoADQB12cAT"
"yNTZ+GuKne41oJoAgJr8dqJnLYdm10KUXRvX2gwCSXOUAARJPmT+kF9dmHldBQEKBqA0rcD6"
"TkoNkOZvBwC78SvB9JO9YPpe1H9AvQgNuA8hmZoOdeOhp8wGkNEnujdiALCXADwdAJDkYTQB"
"mgDg4QwASbNbqH4A/Lf1lU2A5QJAsAsAMEoAdCxwvoIABoAYSw/AgrIAsG/pAPzOPSrPBaCV"
"wGT+NAa4Si4B4rT/Jor6n2bzp8j/q6hHi4f0fijOJrv6P1Ovc5Uxfl3n72crm+43N/q5qvXr"
"qN+a8tf1fr3eV5u/nvP/tzR/etwBgCo+Zs2aRZfyIMCcDjCXBdG6R3NCwFoSqCgbYC0L6AVC"
"1v4A+gU3QYBKAxNsskeAml8+tMnxl6ktGv8tJGntK0WlJ71LJQhQj0CsEOeXyD6BCxscWYEr"
"qkRAkwS8aTBJis0/WV2hG6kKANIc2QAqC5SQsmQmoNQoCdD1loIAbf50/3NBJQDA7AEgAEgB"
"AMD0byZZAIDMfwfrZ238rK8AAFsUAKgJADsAOMz+5tkVbPg3z8r7m2fobej0cgDAUgDAYnGN"
"zB+68g01/MVAUXbzv3oEpn84DMYfyuZ/5WAwjF+JzT9AXNqn6v6c+vdhOTIAZP6zEf17sTQA"
"fK8yAMe/fgNm/wrrmErxS5Hhj2fDP0rG/yXuYfwkqvuz+a+nqH8sG/+BNaNg/s+w+e9b8bTY"
"s3y42E0AsGQIn2svz7IfJKP/GGn+uXP78wreHF7KQ4fkyINxCACyQrvLcb4Q1dzHaX9q7uso"
"F/bYI36Z6k/3lcZPu/IzAtraT8bL4JW5rXipTjrX+FvwyXdk+pkU8Yc0VSLzbywyoYwQGH/Q"
"I0pkuPXYoMmok30R0XurCN+DTB/m71adtQtK8KiB99UEIJBq85XN30sJ/zYJSgYEJPs9jM/5"
"MD73wzB6Uh28DdHVX0EBgCAtQAvfi399ByhAKb6AAJ9H8PlwpX4Cb2osbMD9Bdx74I6rm1QS"
"NR26N4RxAwLccQ8IIDEAeEnz11MAdgDwtIwBeugSQFN7CUADAGcBVCmAIKDMFIB9GkBCQE5o"
"ewYA7gMI78jGT6LFQAwAc9VCIG4I7KYgwAIAVAJYQun+gfi9e0w2AKpjgek4YDoE6Agd+0vm"
"Hw84XT+8dMnsnkUNav4+xCa3932qXtfo9U3X+CkAMo2fyqXmJr9+Ntfp/s62skt9Kor6rSl/"
"s9Nfr/fVS35u1+3/LzF/etwBgCo+CAAqAQF6WZAJAda+AF0SsGYD9LignhQoDwTM/oB+NgcI"
"WDMCBALU9UpTAzT+QvOvk6DPqU/A/dMB8d8VTj8nvg8X4nsCgQUAgThAwEohLq4DCHwp1wxf"
"UVkBRNPiGh08RDCQCPNPVABgQMDNdBcAAJVmGxBgBYB8FwCwW83/F1pKABUBQKLU9Z3lAACZ"
"vysAWC8BgKP/lWz20vCXy4j/9DJx87vlHPmzOPpfJKP/kwsAANT4N48B4PKRueIyR//h0vxh"
"/FcOBsH4A2D8pEBxeZ80/0t7fcTFojnK/Oewzu/xBgB4GwAwW5UAZnP0zxmAXHdxdCul/CeK"
"w5TiR5RPxi8Fw//yBalNz4vDX0J03fic3fwPrhsrAWDtaAAAXlxXEwCMwAvxCLFn2XCIMgAE"
"AE8wAOTZAWAAH3lLm/jY+OlEPD4VTwJAdhgAIAzRf5gEAHmADjX5dTSMv4Pd/GmUj6WifoIA"
"rvUHqdW53N3fXEb9wdL8qdafiWg/M0xH/o1EekgjXB8BbCC6JvMPpogbRhtQV5oyzJkAIMm7"
"Fpv8Lg8y/ofs2gUleFaH+daA2ZNqsujjk7zVdQ6Zf22YNuSnFFAbpl6bQSCFoUB+rVT/OgwB"
"aQFK/vUs5l8PnwtQ4l0fwr0ahyXiAAAgAElEQVQX9Sc8Is3foz6+n/ps/LuUEt0ABrMgMn83"
"JQUAKRYAkPcKAMxFQJ5N7U2APA2gAYDLAFKpVAqY01KdDdCW5TwO6BoAKAsgNwN2UjDQRRRE"
"6X6ArtwPIKcA1B6AuD6y9r9U1f2V8VOz3+F1FPWT+T8ljsH8U+c/fu79cY3jVX3/c/X69b56"
"PaMAZ4LNUeOvqvG72uanjd/s8Ne1/vo2R9RvpvzNer/V/M0lP/825k+POwBQxYcGgEpCgF4b"
"7Kov4HbZAFdlAWt/QEUgoHsEqFmQul5paoDGB2mPAC3AoKMuqV7G5YGBPevOS1z7ZlHpqYAS"
"WRqIVSBA2wXXAgQ2AgQ2AwK+AgRskyBAQqQtrifB8JNVRiDVBQBkOgCgxAoAuhSQZwBAgTJ/"
"DQD0dl4FAKBLAOUBANX+lflf3irT/xddAcCacgCAtJSj/uskRP7XyfyLpflz458dAJT5H6Xo"
"P1RcPgTjPxgoLh2E2R/wExf3+8L4/WD8fmz+l2D+F3d7iQuF3uICTJ8BAG+zyPwLPWH+MH2S"
"qv+fy3UDALhxrf8I1/Ypyn8RRj9eRf4vsOkf2vScOLTxWakNJEr5j5FaN5ojf47+yfxXPS32"
"w/yLlpP5D4OGisIlgwEBT0J03j2VAGiHfz+RO68fp/1z6Nz7SHkcLkMAov/siO4iK7wbIKAr"
"IvMuvI9fjvPJkT5Z49cLfNqw+XP0T+bPh9G0dkT9QarRT9X77ZE/mb8CgExO+zfExz+C95MQ"
"ZQch4g6G6QbChANgysqck32kmSfA5BMYAKqxdrnD/N0lACR5Qd6kGqxkfDwpaQ6pFn+OFN9a"
"9uifIEACgJQEg4fxPUulB9TBFbJnBSgbQc2Dso8giXoLvOohCq8Pc6aoH+Y/S8oOALMAAFDC"
"zAYiAdcqA8Bsbfra+A0A8GiGr9tcNgNCKV40HkhZAEAY/f/xbyMhgM4HUBBAMJAd0t5eBpAA"
"4NgLkEdHBHMmQG0IjO4mdtPxwLQNkDYBxqk1wJzypyOABznG/NR8/75VQ0ri3LoVdW1+9zyb"
"I83/sXrdotcvmuOnwEZ39VPAo1P9v8T4dZ3fVbr/dlG/q3q/q/W+/1bmT487AFDFhwkA5UCA"
"q7MDrH0BuiRQXjbAnBTQ2QBrf8DtQEDvEKA/Bup6pfFBvUeA6mOULtPlAVqOwVkBaIbbp499"
"mbvjkyPihxhAgM4ILAcIrAIE0MFDmwACdPgQYODadgggcCNBggBBwM1URymgREtlAUp0FiCH"
"9/k7IEDp53wLABS4AIDsSgAAjP+aNP+yAADzvxjPEwA/6R0A5xH9/7AaALBKpfuXuwCAJQCA"
"JQ4AOBkrrp6IgWD8J6Jl+p8BIALRfxgAIERcOkTmH8Dmf2k/ov19Uhz576WI30v8CKO/gGj/"
"Akf9s2H+s+WVzD/fXQJAPkyflDcL5j9LnM2dKY7FT7DX9inNf3ijivS18cPwD1G0zxqLF1hV"
"72eNckT+q58W+zj6Hw4AeIrNf8/SIWI3A8ATonDx46IAAJBPADC/v8iNAgRE9sWLfi+8+PeS"
"IEDRfySi/0gAQEQ3VkZoFz4yl2v+QR14tI+b+/yV+SsIyPBvo86kbw2Db2Vv9kvX5q8AgGr+"
"nPIPU+Yf1ggAAIU8ogCgHq5Ud4f5B8F0Ax+2R+bJvojefcjEEd3PpnT/Q2z8u9wBAB5k/tWg"
"h2DGJAUBc6ojSgcE+Cj51oT5Q34AADb8WlIBpNpSCgLS/GtzaSA9UEOAzASk+KlyhE8dBwB4"
"AgA86iFKl8a/c0Y9sXNmPc4CMADMBAzMfETKBQDIEoCjB6AqAJDo7gIAvABePrIXgJcCKQjI"
"JAjQABBMENCBJUcCOzhGAs0MAJUAYrqJPbE95WFAOupfMRDQ+Zg4sJq2/MH81WrfNX49j7wz"
"ut6X9Dpkc0T7H9ic0/wUyOg5fgpwKNDRe/utxk+vibczfmud3xr117NVHPWbKX9rvb+8DX//"
"cvOnxx0AqOLDCgBVhIDKZAPMSYH6trIgQPWoikDA2iNAfwzm+CCBAKXJzPIA0bTOClAzDfcK"
"NG98X3Co9zM7viuac078uFCIHxcDAjQIrJNHEV/ZLEHgugIBKg1QNoBLAoCAElJ62UyAHQA0"
"BKh7ve5Xp/5/tgJAjosmQFclABMAtgEAlPlf3qIAgMz/S0jV/10CwHIFAMsMAIiD+S8U1yny"
"/5bMP1pcJeM/Npeb/a4i8r9M5n8khKN/af4U/SPy349of98cNn5O+xd5KwDw5Ej/vCmYPps/"
"Kc8NkT8Z/wxoOuu7tE/FUYr4ub4/Xqb6Nz4HPQuNk+bPADAW0T4i/jWjEfk7ov4Da1TUT4L5"
"710+DBGZjPx3a/NnPSEK4mD+CweJvAUDGQC4BEDNf2T84TB+zgQg+p/bHdduIjOiKwAACusC"
"k+4Ik6alPtT1LzMAvMVPZwD8Zb2f0/7BuubfQs72B8j1uumBTWDoTXnEjyN+rvc3xOdugPsG"
"nPZPD67P5p8ehCibIn8y/wAZoScjYk+eI82fjD1htjT8ne6k+wEAD+BtaPYDMP9qDAFJ3pDP"
"QzBqQICvkh+ZvxIZP66pgIE0/5pQLTZ8DQFpqixAEEKZCIIS3YtAzYPJ9gxAXQaARAAAR/8w"
"+53T6zEE7HKrJ7MBDAD1XQJAglsjCQKWKYCKSgD2HgAPAwBUCYCbAb2oF8ACAOZugMB2IiuI"
"1F5kBdMZAe3ti4G4CZCmAHgMEKLjgBf05IY/XvlLxk8H/ayhdP8T+N0cLJKi+5/7YmLjHQ2q"
"3xVsc9T2P7I5on0qX06wOaf56XXM3N6nu/rNJT4V1fitxm/W+c10v9nhX5mov1Lmr3zjX/64"
"AwBVfLgCgNtAwC/JBlBHqS4L/BYgQH8U9Meh1wvrPgGiZ6Joa1ZA9wrYSwTNG98fEjpnzM5T"
"+/zOiQtLhLi0AloJCFgLbYTxEwhsxfVrwACVBlRGoAQwAJN2ygSUKgi4laNkAoDOAmjz12UB"
"bf6krCoAwDYDAGD8lxH5X4L5X9zE0f9PP26Q6f/zaysBAHEq+l8AAED0/+08mP9cKFJcPhbB"
"Nf+rRyntH6xS/8r8Ke2P6P/SPm+YvxeEK5l/EaL+PbMNAPCQxo/rDwVk/LPY+Nn882aK73Ng"
"/jnTxNnsqeK71E8kAKjmvvIBQKb7D8L0HQAwEpHXM3bz37fiKQUAiPyXwfyXDlbR/5OcAShY"
"/KjIXwDFDhB5sf1FbjSi/7m9IUT/ugQwVwOAzABkR3SBOgMCOomsUAkBupucMgAZ1PDnL9P+"
"6eoY3fSQljD5VnwlCJDRv9yjn06rdUOaqIa/RhIAQmTNP4PMPwTmH1IX9zDboIelAmuzUZNh"
"UySf5FPdAQAwezL+XR73w/zvR0QMed0PQ34AH1MNsPAQm34K/k0KXX1r4PPUgOHXUFkAmL9/"
"TQkBdOUMAAAAXzdFZwMgLgUQBATIvoAU3zquAcAdAOAmjX/HNIgAYFY9Nn+CgEQW9QK4AAAP"
"mQlguTWqRBOgnAJIdDdHAcsCgF4OpCEgI0BDQFsYf1uRTeavtgNSCYBHAKner08AXNhL1fr7"
"yj3/MP4Dax4XB2D8iVF9z33xUuOd9avfRQ19ZoqfXnfetjlH+/T6ZKb5zfq+PqnP1fa+38L4"
"a9kcHf5VjfrLNf87APB/DAB+o2xARSBg7Q9wBQLWHgFzfNBcKGSWB6xZAbNXgP4I6Y+R/ijp"
"vGyaswUMPAAYeBYwEHiOQeDyapj/OiGuUEZgEyBAlQdgwuLmLiFgyFwW0NmA0kypW9ZMgAaA"
"POeT/37OryIAJCgAQPR/BQBw5WsAgI7+yfwR+V/YyNH/7QFAmf/pOHHjFCL/UzD/4vniOpn/"
"N5Tyj0T0HyEuHw0Tlw+HAgKU+TMA+NtT/xT9X9rnJQEApk+6oPQjGX4hDL/QDQDgBvOH8mcB"
"AGbC/CEV+Z/NmQrz/8IZAGD6Us9K84fpH95gyQCsHS0zANCB1dL8D6zW0f9wsY/Mf/lQAMAQ"
"sWepw/ilHncGgBiY/7w+MP8+DACsKEBAVHcJANr8YQbZiAZpb3x2hDxDPitMHiubEUJd5VRT"
"lmn/DNXwxwBgdPtnBMoDcjKCmth362cGU6d/I0gZf1B9mfon8w+tg+cc5p8WSKn6mmzcyXOq"
"s6kncYq/Ghs+GX+C5318TZpN5g95P8BKnlMNJl2NAYBBgIzfX4kzAGT6KhMQUEt9PSkCAfk9"
"yBKA7AdwAACZf/KcOmz+SbPrwIzrwMjrwujrAgDqSgCYjvuZdR0AoBsBrQAwS44HJrg1lObv"
"JkFAZgPKGQNU92UAwCgBUCNgipLOBDgAwOgBIPOP7ATj7yIKqNMf0b7u8N+3tB9+twbgd2wg"
"ft8GiYS5fc5NebGRafpT1OsKvb5Qip9G+HRt/zlb2WjfTPPTa1g/m+OI3p42h+mXZ/xmjd80"
"/vLq/K6M/1dF/Rav+Jc/7gBAFR+3A4BfmQ2oqCxg9gdUBgTMqQH6Y9ALhcorD+isgO4VoFEa"
"XSLQMKD7BRww0KRaSMic53ec2h96jkGAMgJXN0JfShC4ARC4sUP2CMCgGQRKCQIyFAhkGZmA"
"3wIAEhQAyNo/mf/fYf4/c+RPgvlf3KgAYAO0Xqb/GQDWiNJzq4wmQAUA3y2BFgEAYP6nYhH9"
"zwMAwPxPIOo/FgYh6ifjPxwkrhwOhPmTAsRlNn9q+pujZADAbk+YP4TI/0eK9tn4Yfr5MPz8"
"GVJ5iPhJuYj6c6eKMzlk/p+Ls1mfi1MpHxlRv4z87aa/AaavtX6MvdPfOfIn439K7F+hAADm"
"7wAAWfeXekwULIL5zx8IDRD5MP+8KJh/JGUAerL550b1EDkwf1J2eDeO/LMjZQaAASBcAUB4"
"e4aAzBCaKSe15SU/mcGy7k/mnxEiV/syAPBpemT8jSUABOEaBPMPbogrAECbf1BdAIA0f5kB"
"gBEHwZQDZPRP0XuSBgBK7bPJq6h/9n326D8RzyXNkQCQBABI8qlmLwGw8QfUgLk7QIAAgJQW"
"WBPfQy2otvzaZPwKRNJJgXXKAADtI6CFRIm0dZC2D84is4fpT686ACS6q6srAChnEZAGAF0C"
"kBMBej1wc7kemLIAc1QpgI8IbssTALwJkEf/1Orf+d3E7oUwfprrR7S/b1l//E4NZOPfFdn7"
"3JTxDXa4MH1d19emP0G93tDrjq7tm9G+TvOb0b61sa+icb7KGL9Z5y8v3f+rov47APAfAAC/"
"AALMbIBZFqgMCJTXLEhjLPrEQVflgfKyAgQDRNr0x0cpN904SPU33S9Af7SUGdAwQOm7qXf/"
"t8171mcjNucmeh0pObe8hCHg+mZoKwBgG8yfMgIJjrJAaZqEgVtZStnK6F0BgKr9k36ij4X5"
"l6ZL88fn+9+biPxvJvD8P00A/M81Sv2T+X8FbQEAbJbmfwnGfxHGf2G9+Ok8AYAyfwaAtWoP"
"gAEAKvV/47uF4gZF/sUxAIBoce0bRP4nyPxDxJWjIQAARPww/ytH/Dnyv3zQFwAA09/vzcbP"
"2gvjL/IEAEC73cWF3R4AAA8AgIr4Yf4/5EnjP4eI/1zONE75f58tI/8zWZ+JM9mfAQCmiJOJ"
"7xopf532H8sR/yFl/FomAJD57yPzh/YuV6l/Ff3vXTZYpf+fFLvtEEAAAPOPJfUTebF9RV40"
"FKUj/x4sjv7ndoPJd4E6SfNnAOgociI78jU7ogPXi7X5Z4e1BRC0hqG0FplhrURmaEvAASAg"
"mMy/OcxGn6rXWO3Wh/HzWl3D/KnuHywBgEw3HQCQChNODZKROaf/DQAgQ0/yeRCSEJDkfZ+8"
"kvH7UORvZAHwdorPQzBtyE9CQKoWQCAtEAqC+QeTAADBtVls/MFSBCUEAWkBehLhYdkASNsF"
"YfyJ7gAA94dh9HU4+rcDgFkCmOkaABLpxMKZDfl5JwDQq4DVJsAEt8ZSlk2ADABcEmhmXwyU"
"rBoCdQ9AKkf+cgIgmxr9aNafmvtiVH2fZvrjeou9S/vi96e/yF3cp2SFZ4cjb42ovfm/7rJ5"
"22RN/zObs+lb6/r0+kKmb0b7ZPrWpj4z2qc0f0XRvnWcz1VzX2WM30z33y7qr7T53wGA/+MA"
"8CtAgOjSCgKUfqoIBOrbnEFAjw/qhUKu+gR0eUBPD1h7BfQooS4REAzofgENA9YyAdXw6MjN"
"L6AZz47qFrdh+eTc7w7PPychgLIB22VZoESDQArMPJ0NnaJ6afRGMyDBwE/qAKCfspVcAABH"
"/sr8GQBg/le/4uj/71fiAQCbpPlfgulfhPlfWAcAkGLjP79GZQBMAKD0P0X/ixH9xwIAYsS1"
"Ypj/t3MBAIj+j4ey+V85GmwBAD/IRwKAMv5L+6C9HgAAaI87AMANAAAh6v8R0T6bf/50AMB0"
"BQDTAABTAQAQp/0VAJAyPhPf7HhDHN7wrD3yP6zS/VLK/Kn2v26Uo+6vGv8YAFYMV+YvAYBq"
"/3sYAJ4UhUtkCSAfkX8BACCfAIBKAAsGQP1EbkwfkRvdW+TO6yVyogEB0Q4A4LQ/ZwDo2knk"
"QNmRHdj8syKoXiyzAFlhMJQIGH8EIstwugIAwgEAYQCAUMoENJcb/pTkQToNea9+mhr3cwAA"
"zD+0joIABQAq/U/mzx38DAAU0T/Exi51P3Svut4vDd9Xv+9B/NsHlfk/BNNXAKCyAKls/jXY"
"/DNCSLVZ6SEKBPheAUBgWQDgFcMw/gQ3mL+bBADOADAEWJoAdQZglmwC5H0AsyQA2DMAbkYf"
"gBUAZjWWontaEezZxN4EmEQZAI9mjikAWgY0x7EIiPo2JMR1FnnzEO3HdhcFHO3L+j5F/NtD"
"up4L/rBZ7hNd/0ab+Waov//JNkdN3xrpa9Onur61oU9v69M7+uk1qZfN9RhfRfV9vcBHj/NZ"
"a/wVGb+1zn+3rexSn19s/HcA4D8IACoJAeWVBXR/QGVAwNosqPcIWMsDOitAfzQVZQUqCwNm"
"mUA3EJrTBLJU0LRGsNu0cfEJW2YXlV76skTc3KkgIFGIUkBAqcoI/JSpIn2dCcD1p1yZ9qf3"
"aTEApKnoPwkAsEsBwA6pazD/q1s5+v/7lc3iZx35a/O/sBbmT1LGz1ptlACoB8BR+79xCtH/"
"yShxjfRtJAAgHAAgzb9SALDX0wEAMP6LhbMAAFDBTACANH4HAMD8c6eKc9lTYP6fQ1MAAFOk"
"+WdOBgBMAgC8zgCg0/52AFg3BqKO/1H25j+u+cP4SWT8UjL6L4LxF8H49ygRABRw3X+QAgAS"
"AcBANn9S3vy+Ii+mN9QLMAAAmAcAoB6AqK6O2v/czmwa2Yj+c+Yi+mchgiQICIf5R5LaiCwS"
"gUAkACACABAO8w+TAEAjf7r2L0/RAwAENOAVv3K/vhytoxS7jv4pDS/H8mSjnh7hk7V8Gc2z"
"wcPoU/zuh+5TV9IDMPoH+JriB/P3fxBvw/wDSNUd5u8EADUALACA0FoSAkKl+curjv7VoiAe"
"RXyYNwkmekrj1wDAJQAuA9RzjAG6q1FA1QSoRwET1V4AWgpUMQDIyH8XA4BK+9NIoFdTe9Nf"
"Mm0B9JYHAVHDH9X5qVGTTR//D3Oju4j8+d1EwYLuonBRT7Eb0X52bI+SmM9aFL05omZ8vWrc"
"ua9T+2b3vm7kM9P7FZk+ZR+16fezOaf4zWi/vDE+V2l+Pcdvbe6rjPHrOn956f5fZf53AOA/"
"CAB+ZVnA2h9QHgi4mhqw9gmY5QFXvQK/FAbMngFqIKTuXUrxUapP9w1QNEAvEDTbO31A35bz"
"QgPe2JGbGn6k9MpXJXYI+CkdylAQoNL+FPX/nCmf17qF6L+U6v9JBgDs5No/69pWZwCgDIAJ"
"AD+uYfP/6fxqafxs/mYT4DJIR/8LxfXieQAARP4nYf7fRohrlP4/TuYfxHIAgJ9M/zMA+MgS"
"gAaAInd79M8AUDhTAQBlAGbcBgAo+v8UAPAJAOAT8c32VxUAjOX0v73zX2cAOPrXo38jXQPA"
"MgDAUgDAUgMAEP0XLC4fAAoW9JcgENsHUhAwr6fIjqYMgASAHKXcSFwjO4mcKDITXKMpkuwA"
"42+P59rhOQKAtmUAgBXanA/3sWcAXABARnA5ABDoAgC4ke8hJRg8Gb3//fi4+6D77UoLBAQE"
"SBCga1rAgzB6KBAQEFgd1+p2ACDzT0f0nxlWFgBY9ugf3xNH/3KVsEz/17YDgMwE1FWNgI7O"
"fwYAcwxwRlkAsJcA3OQooJwAaCSSPY0mQN0ISFG/N9X3Id8WIs2vpUijjX80309lmbB2/P8n"
"N6qTyI/piv/PFO33EFkxXUuWzmh15NNna+/o1PgPtJhnuvo7/lT9XZupfQoCXlavA2ZN/7cw"
"fevJfNr0XaX5dX3fVVd/ecbvqs7/m0b9dwDgPxgAXEDAbw0C5tSAqz4BV1mB8noFrOOEt4MB"
"6hmgxh1zmoBGCyfYHKUCvWuA9nfr3gFKF04f0K/1vNDAd3bkZkYdKb26q4QjfoaALJny/5nA"
"IE0BAq63YP6lKQoAEgEAOw0A2GYBACoB6Pq/AQA/EACsUgCwiqP/0u9p77+M/m9S9P/dItn4"
"VxwtrpPxkxD9XzsRCgAg8w+8DQDoLEB5ADBL/FgwU5UAZjgDQA7MP+cL8X0W1f0R+WdOgvl/"
"LM6kf3x7ANCyAICs+6vof+lQHv3bq9L/e1T93778Z5FsANQ9AGT+BQsBALEEAX2hPiJvvgQA"
"KgPkRHWDusJAoOiuXCvOjabUMdWNoXmdRC5lAeYSALTHc20BA205C3A7AEgPasw9ACxVAiAA"
"SA8sBwACa3Ktnsf3eIzvIY7qU/0fZPOXhg/zD7wXug8mTwIABD3AEMDCfTrMPz2YIOAh6PYA"
"YC8BBNdW439yJ0CKrwQAPlNgtgQAMn7uAeBeAACAGgXUaX8GgJlyMVDCjLIAkEAZgJkN+GwA"
"OQ6olgB5kZqykmjhj1czRPnN2PRTA2jBEiL9EMBXaFtuzKQsTW50J/7/kz+/i8iM6lyyeFqL"
"I5PG1d7RsZHd8L+wOWr5H6q/Y8r26dS+PoBHd+9TUEDBwQj1+vBbmL6r2n550b5Z3ze7+v8h"
"xm+rovnfAYD/UAC4TTagqiDgqllQjw+W1yfgKivgqkTwS2BANxDqaQKCAbNUYGYHCAh0uaAM"
"EAwc0D7abebE+ITtQUUXzmy5In4m809VEEDlgmRl/glSlQUAew/AWgDAaogAYKXUuRUAAET/"
"ZxH9n14Cwfy/o7E/DQAwftI3YQYABKkSQHA5AOCjJgBml1MCMAHAbAKkHoAvFABMBgDo6P8j"
"BoATBADrx7kGALMJkADAKAFQ1C81tFIAQE2AhZQFWPAom3/BogEKBPpCEgB0FiB3XneoG9QV"
"z3XjmnHePEohAwIIBGI6ibwomE0UosxoAEA0AGBuWy4FSABQ5h8G8w9rZgCAPN43PUh2/0vz"
"r8cd/2z+gbrjHsaron8yaAYAGt/zg2lT5E8p/YAHZYQfeD+bfnrwvRCuISQYfggZvrqGPoiv"
"XQ3mXg1vw/yDazgDANX+Qx0AIBsBa9lHEFOV+af6yTME6CyBMgDgIScB5CZAFwCgNgPqRUCJ"
"ahFQopujB4AXAXnSSuAmIsW7iUj1aSrSfJshwm8O0T4FMn3asdAa/33x3zuiHf67E4BJ498Z"
"2P7K3I8aFb02tFp8x0a/j7aVb/iU1ifDf83mmNG3pvat3fvWmn4/2y83fTPFX1G0b63v63E+"
"V819v8T4/+02+v3Sxx0AqOLjtwKA24BARf0BJghYewQ0COg9AmafgC4PVJQVsJYIbgcD1jIB"
"/YETDOhpAqJ+a3aAXih0I6EJBPTCQkBAR3pqIKBGIko1Trv7z3/w/uCdEasXzZ+Stn/3ouKb"
"l74u+d8SRP43d0nd2AEA2FFOCUADwCZjCmCtzABo4z+3HOa/TJSS+XP0v1jcOL1QRf8xUJQB"
"AKEAgBAFAMFqCiDYRQ+Aj9MOANdNgG7OAKDHAAkCDAA4kzVJnKbo3wAAHe0zBNAEgFr8c2gD"
"mb9sAJQ9AGT+I8QB6vy3A8AQTv+XBQA5+y+NfxDucY0j8x/I5l9IEMAAQOWA3iIvViqXQCC2"
"O4AAxk/pYwAAp5Fh/vmxXRgE8hBh5kXDdObBfOa1lQAQ1QYA0FpkAQCyIluKLJUFyApvLg/7"
"UQAgZ/8b2rf+lQGAQDn77wQAAbprv7qs5QdSKl8CAEX70vjvZfPPCL0fekBkhMH0yfjpGv4g"
"vgcAACm0Oj4Ops9ZAFX/dwEAaUF6LXAteT6Anzw8iAHAuxYDAJUAqAeAI39POQ6YRMuAIDoI"
"iDYCkvhsAA95GmCiu+r+h+knG0cCU8SfOqcxvkYTmH0zke7fjEcoM0Pw3zEU/01DEemHU58F"
"wVY7kRLetmTljKbFM16slTam7z2r8eJCnfrT1N/ZZFtZw9dpfW34uoHPVZSv9/A/bnNs5vst"
"TN+a4i8v2tdpfrO+r+f4XRm/WeN3Zfy3i/r/f/+4AwBVfPzWAOACAn4pCOipAb1HoLzygLVp"
"UO8U+LUwoKcJ6I+cYKCfTVK/NTtg7R3Q5QIrEOiSgbWHgJqNaLRoev9+baNnTnth8/oVM3L3"
"5s8rdgYA3QS41TIGuEntAVhXDgDA/M/I1P8Niv5P6dG/KFUC0BmAKgIA9wJ4qjFAdzUGCBW6"
"KwCY5RoAqAegTAbgI3Fs60S55AdGL8f/xpQPAMr8HQAgTb9oiaz/Fy19kpv/9tC1DAA8KgqX"
"DORSQKEBAIWL+uK+D5cBZCmgh8hf2EPWjalTnK+AgAVdpOYTDFBtuSM+tgPUDkDQTgLAXAsA"
"RAAAIppDTdXBP41hso3V7v8GAAELAAQZABAk0/9k0GkaAgJg2gEPyVo+CxF+sAMA2PzDSA8A"
"Ph50KIKu1VgZYQCAUJX2D6rpEgCoBFAGAHwBAHSIkMoA6B4AygIQBPAyIO86MHN1IiAfCiRP"
"BUzygmY3YKV4NeBDf6+GQ8YAABg9SURBVFK8GyG6byzlj2jflxYlNeXdCTRCSaOUWWEtecKC"
"MisrpzUu9nm9du4rT9yzuUPDu3R0P9XmaNrTNXwCb53Stxq+Tutba/nWKN80fQoKytvF/2tN"
"X8/u17c5N/WVl+bXc/zWrv5favz/J8yfHncAoIqPfwQA/ANAwOwTKC8rYO0VqG9zlAjoj0yP"
"E94OBqzTBPRHrmHAVXaARC8Y9MJBQKAPKjKBwCwZTLA5JgwICCgqMcsGJhTM6N+3VfTMqc9t"
"jp37YdrenKjia99vLHENAOvVFMBqVQIgCFgmSs4uETcIAE4DAE6rxT88/w8AOAkAOBlu9AAE"
"qzFAWgQUIhcBWacATADYp/cAUBnAQ1zYo/cAzCoLAFwC+FwBgNkDIAGATv+zAwCZPkuBgDZ/"
"AwD2r3iK5QwAMP8lT0JPyNn/JXrz36AyAFDoCgAW9QEYKC3shX/XE/c98DFa1ETWlZUfS+rM"
"EJAXCwiIBQDEtBM50W1FThTMam4rCMbFENACBtYcAgCEkwAB4Y0RyTaCudH+fwBACACAxv6C"
"FACoEkAG199rydn8ILmkh82aIvdgSu9X45q+KwDIDH8AX/tBu6wAkBFWA1+zhpr7r8kAoCHA"
"3gMQrFL/gRIAOPr3lgDATYBz6EhirTrySGAoZU596BEIEb5Sii/k05CV7tcIaizSA5qw4WeS"
"QprxzoSssOYiyb95yYovGhZPf656+iuP/21zhwZs9jNszmavo3s9mkd/T6+rv68JNueUvtXw"
"qayna/nmGl5t+OZyHlemr0f2Otochl8Z09fje65S/NamPlfRvlnfv2P8lscdAKji4x8JAL8C"
"BCrbJ2BmBay9AmaJoL6tYhgwGwjNaQITBirKDpi9A3oToSsg0CUD6iTWTYU0cugqS6BHD61Q"
"MP3P//0777HP9IibH/F+6tcb3Yp2ZwYXSwBYp8YAVxk9AMvsDYDUA8ALgE4tgGLUGGAk7wDg"
"PQC8CIimAcLEZQUB1BToWASkewCsq4A9ywcApx4A1QRoTgGoJsAjm19yBgDu+h9TJQDYE4eo"
"P+4J6HE2/91xLgBgMYw/boADAFQPAAPAYiiO1A/3vXHtBfUUuwEChYucAaBgAamzKIjtJPIX"
"dITacxYgNwYAEN1GZDMEGAAQCQCIbMpZgKyIJhAAIAIAEN4AEfcjiHTrQ3VkFsAVAITUNIya"
"jJsieKrlV1N1fhcAEOYMACwFAJkGAGTgc6YpAHAsAqoptw8aGQAa+yMA0BkAAgC9B0BfU3zr"
"sVJ9HxGpfqQGUEPAQ0Pee5AW0IgltyA25eVIy6fUKw55u2bRtGerpQ5s+4e4uvfzKJ41sv9E"
"/T1os9fR/avq7+clm6Npz0zpl2f4ehOfWcu/XZTfWb0emKbvyvDNmn5Fpm9N8Vtr+zrar0x9"
"/z/a+PXjDgBU8fHPAIAqgIC1WfCXZAXMEkFlYMBaJrDCQHnZARK9ONwOCHTJQAOB7iHQTYVm"
"2cDMEriCAkprmuUDamringJoRtPG1YPHjOgWNz/0rdSv100tKkzxK7Y3ARIE0BigmgRgCOBF"
"QPN4EyCtAr76TSQfBHT1OK0EVqcAHtVnAchMgDwFEABwQB8GRAcBeTnOAuBVwK42AeomwKku"
"xwDLBYB1o50BYPVIXvtrBQAe/VsE81/0ODRIbf2TVw0AcgoA0f/iAY4SQBkA6Cd2L+0PgOiD"
"a29cezEAsAgCFnVlFSzoJgFggQMA8mPbi1yCgHlVAIAIAEA4ACAMABBWtwwA8EpeBQAZ9ui8"
"BmChOjfzUVOfzAA8IAGAmgBDAAOqB4BT/2GmVAbA3gOgNgAGOkoMaXpHgH9NdfZALVay3fyd"
"AUAeCCQPBUr1q8dKg/mn+TeAlOkHNhJLJ9cuDn7joaKpY+9LHdD693EP38vrdGfYHDX7z2zO"
"afzyzH6CzRHdW9P5umlPp/TNZTy3M3xdy6/I8Ctr+mZ6/3amr1P8vyTad9Xc9x9n/PpxBwCq"
"+PhnAsAvBAFX5QFzzbDOClhHCc0SgdkvcDsY0NME5mihq+yA7h2wlgvKAwK9nlgDgdlUqLME"
"urGQXsyspQOdKaARJV0+oBdGeoGkF0pKhVrBQGYM/mTzHj2sc5y/27PbowNfSctP8Co+nON3"
"jrYB2ksCdBgQQcCJKHUccCTMP0JcpYwAHQpE5QA6D4CyAQf8pAACF/f5qOOA5YmAF3d7MwTQ"
"KYDnC9zF+Xw3cY7KAHmyDMDH//ImQFoEpMsAk8oAAJv9WrkA6BDfj5RyAQA8+79kMAwaUf/C"
"QbjC8JXY9BeSHnUGAEsTYOFiGD+i/91L+ok9ywaI3ctwvwwAsLSKABDT1gEAUa2cSwAAgOzI"
"ZmUAICtCAYDOAASqnfsMALIOb4/+WZS2r66ifxMAaBLgXkTzMhtA1wyaBAiWSuOrGgNUewB4"
"I6Cfmi6gI4J91ImBvG2Q9g7UlIbvo42/llMJwAoAa76oeS7ukxrFU0b/Le39YX/ZPqDl7+J+"
"LxvzdERvNXqdwie4NZv09CjeS7ayZm926JvRvdm0V57hmyl9fcqeafiVreWbI3tm9/7tTN+s"
"65spfnOEz4z29bpeV2n+O8ZvedwBgCo+/hUAUAkQqGp5wAoD1hKBFQbMzIDZM2CdJrhdqUBn"
"B1wBQXkZAr2iuJ/NuWxwOyjQmQKzfGDNFljBQPcW0AvtJJujlEAjUZw1aNLwgeBRQzvGffHB"
"4Pgov/Fpm5d+WJSzfXrx9weCS64co6OBw8UVygRQOeCwPhY4kI8GlocDQXt9IQUCe+aIC7tn"
"i/P244DVwUAEARoA6BCgnM+dAOBo/AR16p9s+pNRv7n+9xmpVc84AEDN/nPzH9X8NQCQ4dvN"
"X538t0Cu/yUAKFhEpj9QjgHaewAAAJQBWCIzAIVL+0C98LZK/9tLAF1YsgcA5s/1/w7cA5Ab"
"005kq0mALGoEnNvKaQogK9y5B4CbAMNkBoD6AGjuP40P2nnYMXMfWIvr/noKQB7co6YAAtQY"
"oNoDkOJ/H3SPvPrdJ5J95TbAZN8HnNYDk+hgoCQfdZiQV3WRCPF1tjxhkO6TZtfAlVRTJAEG"
"qOt/h3vNkkXv318c+MrfiiY//ee0F/v9Mb5/i7viat/DaXsdzX9hc6TuJ9kqNnr6vTVr9tY0"
"fmXM3kzn6z379Ddm3bVfUYRvNfzKpvat3fv1bc41fWukbzV9Vyn+ykT7rtL8/7HGrx93AKCK"
"j38lAFQRBCrKCvyWMGAdLbRmB24HBOVlCKxNheZJhrqxsJ/NkSXQvQSuoMDaU2BmC8oDA0qh"
"6qZDehE2swYaDszMgQSEBvcFP/Nk27jP3hkUP3fOuNSl4RNzs778tDjry0nFlw/4AwCgfRIC"
"LhIElAsAs9RSoBnqUCCZBaBpgLOZnwIAJtoXAR3aOFZBwFhZAlAZgAMkMwNAC4CWDoMkAFAJ"
"YPeix+0AULjQAQAFCgDyFw6A+vFRwHQYUEEs3fflPQDUBKj7AAoW9xIFcT1x7SEnAPQUQGwX"
"OQYY04X3AOTPAwDEdGDzl3sA1BhghDT/LD4LgJYANePufxoDlFc1BhjyCKJ4eQ4AGT9t2ONR"
"O5JvLZHqq7f/VZf7/72rqxMAq9lP+kv0kocAJXrdC90jEmbfKxI87xW7PO4TCR73i13upPvs"
"b0tVE7s8H+JrgvtDeB/u8Xbse/cUL3jvb8VuY+/OnTz8v1PH9/1DfL/mMPi/ORm8NZK3mjyB"
"p5m610Zvpu/H25yjep3G12N4rsxeL97RpTVt9v1sZXfsu4ruKzL8NraqGb6O8s2Rvd/S9KsS"
"7f/HG79+3AGAKj7+1eZ/GxD4pVmB2/ULmDBgbSAsr1RQHhDoFGB5QFBRD4E+1lhnCW4HBSS9"
"k8DsKXCVLdBgoDMGeixRlxIo6nIFBzpzQDVYarqyAoKZQaC07ozG9e4JfvqxFnFPD2qxJMLj"
"mdRwtxFpiwPG5aaueac4dfXbxYcTJl+WAED9ADP5ZMDvc6dyFuAsnwb4mTi25WVxhE8DHCcO"
"bzIXAY0p2wPgqglwqdEESPX/ONkDQFmAfAIBAwBo5p+PAibz53MA5BrgAih/QW85ChjbE9ce"
"uHZXOwAgXgTUiZU7V24B5E2AUe15DTAvAAqXJwFmhLZk46czANKDm6nRNtr+R2qkGuIaiPSA"
"+rhS3bwum3/KHJIesavJ0XcCIvEENmsYNZs1mfaD0tjd7hc7Z90H3QvdA/1N7Jh5j9QMPDfz"
"PrF+0t8ux7z5l+J50MxRf8r9ZOh/pU0a+l+pfZr9bknfpnfF1fqr3dyn25wjeKvBf2Rz1Obf"
"tbk2+Zdtzql7PXanI3prvd40erNmb6bxSTqN38/m2uxdRfc6nV9eDb8iwy8vrW9G+dbUvrWR"
"z5Xpl1fX/y2i/f9Y49ePOwBQxce/2vSrAAMVZQWqCgM6M2DtGdAwYI4WusoO1Lc5A0Fj2+0z"
"BOWVDcqDAmumwFo+MHsK6IWyPDDQDYc6Y2DCAb0oW+Fggs3Ra1AeIOgMggkJelqBlq9oUDCz"
"CQwLjer8JXj4o43joCXDBzZaEjL9ydSQ6YPTfD7snr7YrW9RfMgTxVKPF2cuGH65vCkAvQdg"
"3/KnoGHQUPs5AFwOWOo8BsgrgBfqBUD97RkABoB5jg2ALF4H3B1RvdwCyCuASXQg0Fx1GBAd"
"B0xrZ8PaiaxwWkHbmo8CzgiltbQtYfotYPi0xKYZDL4p1ISb4VL9G3FjHHfHU6c8dc370Nhc"
"HTb+ZC8SLdiBZtcUiZ41YPTV2fjXT74fRn5Pccybf4P+Wuzz/J+LPh7y/9I/GfJfaZ8M/n1q"
"n8a/WyIFU/9LGVPXUbs29sk2R3e91dx1BK9H60yD17X5CbayJk8aZ3M2eVcRvTlvr1P41jG8"
"fjbnNH55Zq8je9Ps6W/KNHtrOv92Eb65ic9q+GaUbx3Zs5q+fo0pL9KvrOnfifYr+bgDAFV8"
"/KuN/heAQGWyAlWFAVfZARMGXGUHrEDQwFb5koGZJfgtoMDMFlQEBrqUUBk4oBdyXVbQgGCW"
"FijSMyFBTytYQYHMRJcbTFjQWQUzs2CFBjs4QDNJg7tVW/xE1wfinujywBKp+5dMGd98h8fr"
"rdLcX2sJtUhzf7V5uhvplebpUZ+1L1rj2bV4jUfX4tUkz85Qp+LV7pBbR6hD8aqZ7aF2UNvi"
"lTOkVsxoVbxyZkvcQ9NbSE1rXrxialPW8i9IjYuXTyE1ghqyln3WoHjZ5EeKl06uJ/VpveIl"
"k+oWB71Wo2jKmPvSp4yERt9LSpsy+p60KSPvSXt/6F939Gv+uyWsZnS9Kw5arH9mm7ORW83c"
"jNR1tG6auk7LuzJ2PTdvmruO4CcY/89fsDnS9WYkr8fsrCZvduBXxuj72Rwd+f9fe2ezIzkR"
"BGE/yu4bICRuHACBEGL3CickOCO4Ay+PfEhtTGzkT5XdrvZMphTX6Sr3rL8vs+xZfkjvCOzV"
"Q3vZSJ8f3lPAx9G+emVPPciXQb+7/ROqBeD1VlUEHiEDPB2oCEH2DMGsFKhnCqpigK8mKjnA"
"yYH9/wf7mBYFYe/sWBJsimDPH+AkAY8bUBZsqmDCgNJgEwabMqA8KIGwyQNOHzD/QP6F/PeA"
"4M/Hz+U1WRdunbgCOELcunMD+V/bpzG8PVRn3TpCHcfy3Ln/tr3s3nlMj4C3cf0ujTyy9yBv"
"D+VxR18FPT+VPwv77Az/3TYGfG+0fwb0G/wHqgXgbdSjZeAqIZiRglkxyORgz/fby2cN7M0E"
"FgSWBJwiKFFgWbCpggmDkgaeMpg8KIGw7OfRKBMoFDaNUPn7hHg/Gz//TwqCWwEcIY7duYI5"
"At26dYO6jeV/2V6Cnbt3g7t18D9vLwGPZ/PYyWeQ59fuZkE/A/urgN/Qf4JqAXh7daYM4NsE"
"0XTgqBDMSsFRMdhvtBU58AQBH0a0CQJKQiQKdtzAUwUTBiUNLA4mDygQKBEoE5bfIX8sCH4+"
"rovXbHsxgDPEEeQMcwa6desVsDPcVQevAI9/RMeD/B6G/FHQz8L+KPCjLt97er+hf3G1ALzd"
"Uv+AKjKgHiD0pgNHhSCbEuxhKeDjgyNiEMkBP2uAbyagIOAEASVhDx8zeLIQCYNJg4kDThlM"
"HkwgUCJYJkwoTCowvy6IrQXXx2u3PdkeGeIGchzBR0BXULfgeP7b7dMfrPI6eAO8/Ylcg7wC"
"PEOe36+fBT2P8RXs90SwPwp8r8v3HuQbhX6D/0C1AHTtNSoD2XRg9LggEgJvSlCZFETTgooY"
"KDmwv1ug5EAJAk4QWBKUKOA0gWXBhAEnCygNJg72rALmp+2lRJhIWD44+bh9Lhhn5qMIrwHX"
"aWvH/fBef9w+gRzfg0eYe906Qt0DO3fv0Zge8+Xmd/Ie5EdBrx7Syzp7r7sfBX401q92+Q39"
"C6sFoIurIgPZUUF0XBAJgXqGoCoFalLAzxTgtECJgTpKqMhBJAiZJChRsOMGCwsDHz+wNGC+"
"2T6fOJhEWBiQKj9cGPX5uN7vtpfwVl25gjn+pTsP6Aj1KtgZ7vwOvQf4DPJqdK9Aj109n9mr"
"zr4Ke3WGXwG+N9avjPYb+hdWC0BXVDMyEE0HMiHAI4NsSpBJAR8feGKwR00MMjmoCEIkCZ4o"
"sCxEwsDSwOLARxIqX1NQKFbH1mJr8/bAI3cFcvwrdxWg42tzBnUP7BncK4CPIO919HsU6LMx"
"PsM+6+6zkT4Df7TLb+gvqhaArpF6lBCoI4PKlCCSAnymYFQM1NTAmxx4xwpKEFASKqKAsqCE"
"wcLCoKQhkggOHlmsiq2B1/aVSLZXBHkV6Aj1CtgR7hHgeVyvOnnVzY+CHs/sq7D3uvtspN/A"
"v2m1AHTNlvcP+EwhiKYEmRQcEYOKHOxBOWBBUBOETBSqssDCwNLA4oBhecAwJNU0oiIXM1GQ"
"VsH1fkHx9szXhq8dX9sM6hHYow4eAa86+QjyR0BfhX3U3T8K+A39hdUC0HVWVWUgEoIZKVCT"
"Ajw+UNOCSAzwKIHlQE0OMkGoSoInCiwLkTCwNFTlwZMILx5oj6T62d7aI4grmEdAR6h7YK/A"
"PQO86uQZ8mp0r0Cvuno1xo86+yrsK8DvLv8GdTsBaIm4RY1MB6pCoN40yKRgRAzUxMCTA54c"
"eIIQSUImCkoWWBgiaVDiwPLgSUQkE1fHW5vah9ovXxMP5gh0D+oR2CO4e4BXnTxDvtLRR6Cv"
"wD57YO8o8Bv6D67VTG0B6IoqujFUjgwqUhBNCqpikMnBqCBEkpCJgicLe95vuTSwOCh5UBLh"
"yUQUBd4sIz9frc/bC+8Zr4cHcwT6u01DPQJ7BPdRwGeQHwF9tbPPYD860m/gX1yrmdoC0DVS"
"o0JwhhSMisGIHFQEQUlCJgqeLKAwRNLA4rDn/RYLhCcT1TCAPRhXE62P98J75WuhYM5AV1DP"
"wK7gXgH8CORHQX8m7Bv4T16rmdoC0HWkspvLrBSMisGMHESCoCYIKAmZKHiywMLgSYMnDywQ"
"LBGRUFwZb028drU/vgYezBHoHtQzsCPcVQcfAX4G8jOgPxP2Dfwnq9VMbQHoOrvOlIIRMRiV"
"A08Q1AQBJcEThUgWUBgiaWBxYHlQAqFEgsNQfUSiz/fWzHvjvfO1UTBnoHtQ98COcPc6eAX4"
"GcjPgL5h/4prNVNbALquqFkpmBWDETlgQfAkIZokVGWBhSGTBhYHJRCeSERh0M5k5PPUetW+"
"1P49mDPQK1CPOvcI7gz4EcgfBX3D/hXXaqa2AHStqspNbUYMKnKQCcKoJLAoRFMFJQwsDUoc"
"PIFQIqGi4HpWss/21uztka8FX6sI6Ax1Bvso3CuAH4H8UdA37F9RrWZqC0DXM1X1BhiJwagc"
"VCcIVVFQsqCEoSINnjx4EpFJxRXJ1uTtxdt7BnMFdAX1CtirHfwRyI+Afgj2q+/PnXtn+QLS"
"BXa91Rq5YWZykAnCiCREoqBkYVQaInnwJMKLB9gzUl1DtI9o/xWYZ1Cvdu4VuGeAH4X8KV39"
"6vtz595ZvoB0gV1dn9fojbYiCBVJiETBk4WKNETi4MnDqFA8OtU1RvvMrlF0faPvpfK9Vn4/"
"Zn7vHlqr78+de2f5AtIFdnWN1cxNuioIVUmoCkNFHKoCcYdU9lm5XqPfQfW7nf3dWVar78+d"
"e2f5AtIFdnWdW7M3+VFROCINI/JwlmBUc9aaZq/JzPU/+p0/ba2+P3funeULSBfY1XV9HQXG"
"UWE4Qx6eOUevyZnfz61r9f25c+8sX0C6wK6u560zQfQogXjGXHHd3kStvj937p3lC0gX2NX1"
"uuoK+L22dDm1+v7cuXf+B8MdoY4LIndWAAAAAElFTkSuQmCC")
getIcon512Data = Icon512.GetData
getIcon512Image = Icon512.GetImage
getIcon512Bitmap = Icon512.GetBitmap
getIcon512Icon = Icon512.GetIcon
#----------------------------------------------------------------------
IconAbout = PyEmbeddedImage(
"iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAYAAADDPmHLAAAgAElEQVR4nOy9BXQU6dY13AmE"
"BBLc3V0Hd3d3d3d3l+AeCE6ABA0eCIQQJ4G4O3F3t+5Oav/nPN1huPK978zcd907c9dfax0q"
"bdXVz95nn32q6ilkAGT/5aGhjn/3Z/8S8Q9PSJIk1rt375bNnTtXtmzZMtmiRYtkixcv/svE"
"kiVLNHifFyxYIJs/f74Ifrx06VLN5cuXl1m1apXW6tWry1Fo/xTl+Hl+nd/H7y/9LG+HH/N2"
"/9O/7feGer/FOjExUWBbXFz8/yZASUmJWLdq1UrGS9myZcVaQ0ND9idf/n4H+bEWRXkK3Z9C"
"j6IiRSWKyj9FJfXzen/3/vLq7fyz7f8lFk1NTbEOCQkR2CqVyh/J/v8kQKdOncSHKlasKNPW"
"1pZVqFBBVr58+T9taGlpif2sVKlSuapVq+rq6OiUAl2Doik97t60adNxXbt2XTRl8uStCxcu"
"PESZfoyyRARl+aFJkyZt/YVeb0Lvo21158+pP1+Rt8fb5e3z9/D3/ad/828J2m+Zrq6uWIeG"
"hv52AvzVFKBMmTI6xPTSrK5HAPXr0aPH2u3bt995/tzUyc/PLzYzM7OguLgE/9OiUCqRnp5e"
"4OPjE2tqauq0bdu2O927d1/L2+Pt8vZpLCrx9/1nf/FvX/6QArRu3Vp8iJleuhEmwZ8lSn8U"
"ZaM27WMV+rMaPd+xb9++665du2YWFRWVzIDSj/wBLtU+5Ofnl2RlZSkzMjIUfx9Z2dlKfl2u"
"UPwDMSIiIpKvXr1q1qdPn3X8Pfx9/L3lypXT/jOOT2nwQmT9/QT4MyuA+sdp0OBXopUAftKk"
"yQednZ2Dfga8qKioOCcnR56dnaPIzs4uzs3NZQKgsKgIcrn8RxRx0HOFhYXidfoMSC2K09LS"
"FKmpqXL+LI2L2CYNHuzt7YPGjx9/kL+Xv7+clhbvx59ngP5u+UMK8CcngCYlfjX6s0G3bt2W"
"Ozk5Baqy/VfQaSnhjGfAOKN/hFyE9PdRWCSXiAi8VhGilBxEjAIiBalGSUpKijwzK0uQgcPi"
"06fALl26LOf9IDLy/mj+Gb3hfxsBytJg16R1G2pVjWh/S+iHSAUFBSTfBcpSBVAS+JzpDKpC"
"oZDoR0vFymKUgsfB7+UofcyE4VAolFCRokgqKCzkbQt14GAVSUlNVSYlJyuL6D1ZWdkla9et"
"M+L9oZLA+1X2Pzw+/7D8NxGgDA1yDfpBXUxMTKwZ6Ly8fEVBQWHx3wLP2ayg7CfAi4t/gP1b"
"l1JSCDKQgvC2iAjIy8+Xcqk8cIkgRUB8QkJxTEysgl8/pq9vTfvXpSztH+/nf3qgfl7+Wwig"
"oaUlZLbDkydPbBkoyr4ixpUB4wznYDA4g4v/APD/SAQVCUrLSEFhEREuj8GXUlJSOZCYmITg"
"kNCixKRk7Nq9x5b3j8aM9/M/PmCly1+aAKXmimo+9/QN9PX1TRgcMmaFvCawVfLOmc91m8Bn"
"wIr/RfBVBChVAqUgFZeU3Dz2A9lITU1DfHyCFBMbSxEHbx/fQhdXN8yaNduE97NsWa2KP+//"
"f3L5yxKg9DtJ9svRqkrPnj2XMSCFhUWiT2PgGRh+jg1bAQGkUBPgX83+vyVAsTCP+VQGcsgD"
"ZGRmIjk5GXFx8YiKikZw6HcpJPQ7PnywUDx+8hRNmzZdxvtL7Ve5f/ug/ZPlr0wA8aVk+vio"
"XpNnz57ZMjBkxn4QgOs8A85Gjes0q8D/RQn4Gx+glv9cIf8/sh/R0TEIC49AYGCw5OcfiFev"
"3xABnmHlytVcCprQ2On9p8bu5+UvSwD1zvPe69WpXXtcenp6HoOjNv4/QC6i1o3d+c8k4Jot"
"SsHfEOF/J8PPXYGo/WwACwrV4GcR+Kls/hAdowI/KDgUfn4BcHZxw8OHj6UbN2/j+PFTeXp6"
"FcfSfutyy/ofGbi/HUOx/ksR4Kfaz4ci9UaPHr2NAcrPz1eogZJUQElC/pkAHGzS8kuJIHp6"
"xY+yUNrm/dwK/hwqw6dqA/k4gNr5I5tcf0YGyX5KiirzBfiRbP7gS+C7e3jhvflH6fqNWzh7"
"7oLy5KkzaNa8+VbebyoDWqU/6d86gD8tf2kC6Ojo8KHWinPnzj3DwGdkZMjV2SmV9vGlPT+D"
"9TdEoMelZGAJVx8XEKQoPdij+lt1gIgJw+/hz3DGZ2ergC91+6Lmq2VfBb4/nMn4WVnb4uat"
"O9L5C5dw8OAR+cFDR9C2bbszvN80fto//57/xPJfQYCZs2adYgIkJ6fIyQQyuBJnfmmbVuoF"
"5D9lbm5u3q+EUJPiBzEo+D2lz/F7uL+n7oIPAyMtPV0An0TtXXxCImLV4H8PC0dAYBA8vbxh"
"/8UJnz5b467RfZw8eUY6ckQfm7dsk2/evA3Nm7c4xftNCqBd+pP+rQP40/JXJYBYkwEUJaB/"
"/wHrc3JykZCQpMwkI8ZmTJXp+UhNSxPOnP8uEp1A6WFf9aFcPsZPWS1IUQr2T4BncVB9Z+DT"
"MzJoe+kk9wx+krrex4qsZ+A9PL3g6PQNFpaf8fadOe7cuYejx45j774DDD6Wr1ilXLBwMWrW"
"rLme95sGX+t//KH/huUvSYDSRa0EupUrVx7q4+uXkZSUwnJckpycirS0DCHN/gGBIjMjqSWL"
"oxpNKoH09AwBbM6PzP8167mXZ3VgQomMJ/CptND20pCUnPKrww8TDh9e3j745uwKWzsHfLCw"
"xMtXb/D46XNcNbyOffsOYtu2nVi7dj0WLV5aMnPWbAwfPjKDxm2oTHVByf9/HOCPLj8ZQW6n"
"6p84cfJNekYW1185A03ZKTl9dRbAfP3mClc3D5JmH2HMAgi44JDvghjhEZGCHCzhnM2lwY8j"
"IqNEdnMfHxgULD7rQfLOtd3B8SusbOzw4aMlXr99h6fPXuD+g4e4dccIp06fxdat27Fu3QYs"
"WbJMmj1nHsaNnygfOWoMmjVr/ob3lwZer/Sn/NsH76flL0uAn34A70SVBg0aTPb29s0LCQ0r"
"iYyMlrj+Gj98Ir189Rav37wjJ26Bj5+s8NnKFja2DrB3cMSXL1/hSCT5+s1FZHFp8GMmzxeS"
"c3sHJ9gQidjMWdDneTsMuOmLV3hEff29+ya4cfMOLhtcI5d/Ebv37Kdefw0WLVmKmbPmSBMn"
"Tuasl/r1G1DSoX3HPK2yWpN5f2V/khNDf2kC/HQwiOW09uTJU06GR0TB6J5x0Znzl2BgeEO6"
"YnhTunnbCHfuPcB940cwefRUSPRT05cE4mu8IMl++fotXr02w6s36qDH/Dy/zu97/NQUJg+f"
"4B5l+O2793H9xm0YXL2Ocxcu4wS1dUePncCevQewctVacLZPmz4TY8dNkIYOGyH17dsfnTv/"
"UtSyeUtUKF/+JO8n7bZu6U/4jwzcT8tfmgA/L7QvnFVNR4wc/eDw0ePYf/BI0aEj+pL+idM4"
"QS781Onz0hnKUAbtwqUruGRgKEC8YngDV6/dhOG1WyL476v0HL92md5z8dJV8ZnTZy6owNY/"
"iYOHjgrAt+/cjU2b2dytxnQCfdy4CRg5crQ0cOBgqVfP3ujYoaPUtHHToto1akJbq9wD3j8a"
"qyr/6bH6efmvIQAtGrQ/1WndvFv3Hne3bN2BLdt2FtNauWPXXomleS+Zsn37D0tEDukAgXjw"
"8DEcOqxPoVrz4wOHKA4ewb4Dh7GH3r+LPrdj515s3bZLgL1u/SasWr0Oy5avAjv6yZOnColn"
"0Hv37ovOnbqgZYtWUv269ZTVKlcprli+Aspqat7l/aJx4v37UwxW6fJfRQAKTfXp1kb16tff"
"M3XajIyly1ZiydIVxbRWrFi1Rlq9Zj3WrN2ItQTkug2bRazfqFozuGvXbcRqcu0M8gqq5fz5"
"xUuWY8GCxZgzdz5mzpyDKVOmY9TosejXrz+6/tINHdp3QPNmzVGvTl2peuWqikoVdIv1dMqj"
"fDntjDKamnt4fyjUVwX9FxHg33VR6G9d1J5Ao0yZMnz1by3avxFt27Z7P3LkKOWECZMwcdJk"
"zljFlKnTldOmzZS4Vk+fPksVM2aJ2k2kEQBPmjQV4ydMxpix41nWMXTocAzoPxDdu/dE2zZt"
"0bhhY9SrXQc1q1WXqlSsqKRMVzDoFSlordTW0npPuzOC90OmuhpZQ/YnA5+Xv7wCiFHVEFF6"
"PajYGfphFejPqvRnAy0t7Xl16tQ3a9midU77dh2pNndBl85d0b1bd4oeIrp17S6y+ZfOv6BT"
"x87o0K4D2rRqg5bNW6Bp4yZoULcegw0CG5V09UBZjorlKcu1dERUKKcDHS3tnLKaZc1ob+bx"
"91Lw91dQj9FPy5+HCf/SZeE8CYI3wErAZPi/CN4Wufofwc+VnjRTAa3xA+T/baG3ldUqW6aK"
"poasOm2hmXZZjSl65csZVqtUwa9G5YoFldVAVtGrSMBWQlWKauo1Bz/Pr3NmVyinLUKXQqes"
"lojyWuVQWbdCQRW98n66OuUMtbXKTNEqq9GsbBmN6mXKaFahvfxNrd7PxPity/+Vsv7ZFeB/"
"lE3+3rJly5Qpp6Wppa2lqUNRXruspm4ZTQ1dTQ2N0mlcnIGcifVlqgMwzN5+NWrUODZo0BDO"
"8uImJOd1atRC9SpVUa1SZQE8k4MNnJ5K0sXfLO9MjEb1G6JVi1bFAwcOQvXqNY7x9tTbra+O"
"0szX1dTU0CtbRlNXu1wZ4kjZ8hQ65bTKaBFByvxPo/YHOPGHlj9EgLZt24oP9ezZUzZ9+nTZ"
"xIkTZVOmTJFNnjz5f41JkyaJNb9/6tSpYj1hwgTZ+PHjeTsatD2N2bNny+bMmUuvT5NR/Zb1"
"6NFT1qxZMw3dCiSyNIDly5erwIMqU83V4+BZPzzotSkaU7Tn3auiqzmqXg2tma3qay3r1057"
"+/AuOscn9Kp4Z+nQMo/XzOzoPG/RStA+lIwdNxHDho9Ef6rx/foNELJfRbcialSugupEiOq0"
"rlm1GqlDZbRo2hzjJ07BFPrcvIUrsGnJYOeNM5s9njGi+Z1x/RscH9Kj7va2Tassa1Bbd2bV"
"SuVG8X6o96exev+qqvdXj8BlcujpaJetQCGIQYT5p5j/zAdelSrlv6K+vJ1SAgQHB//vBOAn"
"Odq3by8+xDOEr1y5Ijtx4oTs3LlzstOnT8vOnDnzT4NfO3v2rHgfr0+ePCk+R69pGBgYaFy9"
"epVeOy/bt2+/bPny5bIxY0aX6dy5o3aDBnUr6FYoXwo0X0tXjfabs6xdhQrlBzZrUmtW3y61"
"tk4eWP38phn1nh5f1sDOaHtj/xeHmsRbn22a882gebH7labwvd4EAdcbwutyAwRfqYanp8Zg"
"0YotWLxoIWbMmi9M4CRq6aaRIWQfUKNyVdSrVRu1q9dEnZq1UJf+rlW9BlqS2585ez59bhEW"
"Lt2Ad7dXocBlPlIdlyPTeRVSHFchxno5vn9cUuzzemGOtdGM+JeXJ/lf3jvMbu+qPk9nj2t3"
"fkD3Rlsb168yi0AfyL9D/XuqqX+fXhlBCi0mhTYrxT/jg+z/yEb8LgUonR5eSgDOYH19fTFd"
"/ODBgwTePtn+/ft/BD/mOHDggHh97969sl27dtFr+zT09Y9pHD9+QrZnz17Z/PkLZIMHD9Zo"
"0qSRdvny2j/P0uWDJjznrmO1KhXG9u7adMPyuQMuXzw6w/ztnUX+3x7PTvN7NKo46EEvhBh1"
"QfCdTgi80R4+V1vD50ZreN5oBderzSSnsw2L7c/UU9qfqqX4dLSRwu5oRcWNY3OUW3cfx5bN"
"m6jt24SVq9bwCRssW7EKPcgcMtgN69VHfXL6DerUE3/zukXTZli+Yi22bt2KzTuP4N6lDcrw"
"D9MUQVarFeHWyxVh1quUEdariqNt10oJjpuQ6rwFGW7bkee9C/neO5HnuR3p3zYh2nZ9sfvr"
"5Wmvrs/yO7t7tPmSGd0v9/ql0YbqVXT5aqGO6t/Nv7+imhC62tpafPpYo3LlKrJOnTrL+vTp"
"K+vdu7dGly5dNDp06CAm7f7yyy8iOnfuLKPn/yFKX+vevbusYcOGP4jwhxRgxowZIrsZXCbC"
"kSNHZEePHhXBfx87dkzEoUOHZIfoPZT1GufPn5cdPnxYtnTpMtnAgQM0GzaoT9JXthRwMXmT"
"6nrXVi0azJwztb/++SNzzKxMtwVHu5/NL4w0gOL7UWR+XYbwZ0PgdaUjvp5qJdnpt1RaHWkh"
"t9FvIbfVbyl3ONVc6XSxWbELge9+vSVcDVrC5WJzOJ9vBqcTVeB8uSnuXjuBI8fP4eChw+qD"
"PXvEgZ5t23ejT68+5PrronmTpmjSsBGaURfA0aJJM4qmWLN2A44cO45DR0/j/u2LiPgwD3H2"
"i5Doul1EnNNWxDhsQIzdeinKbmNxpN1mZYTNZnmY1Qb590+r5WEWy5XR1iuk5K/rkeWxCYX+"
"OyEP3Idsn30Is92a/8l4RfCZvRPNpo3tot+4QbWZJNVd1YTg8amop1tBr2XL5jojR47QXLt2"
"nezUqVMyQ0ND2cWLFzVOnjxB43zqh9L+rMr8Nz9//Phx8X7GjxeeHxgYGPj7CcD1n6Wcs5wB"
"ZyIw2AwwPy5VAtopDd7J9Rs2yoYMGSKrW7e2NoEsQFe3ak2rVa04cszwrrtPH1rw2tFcPyIl"
"+IayJPEukHQX8mgDpLjtRPDbacXut3vJvxp0lH+92FH57XzHkm9n2hEJWjMR4HyuFVzOtoDr"
"pdbwuN4BHjfbw9WwGb6dqwEHfT3JkeLL1Z7Su5fGkpHJc+nK1Ws4K47nn8Wx46fEkUA+jNy3"
"dx+R6e1at0HrFi3RtlVrtGnZCh3athclYNWqtTC4egOXLl/FPdrO+zdPpUDzNVKk5Rwp0mqR"
"FOuwGnHftiHBZQ+SXPch0XknEr9uQSIRI+HLRsTZrkaMzSpE2awqibBeqQy3XiOPtF0vj/my"
"vjjFdSsKAw4CUWcgRV9Cmu8ppeObHRGn9097PXJw+92VK5YfKROHlIWXqEgKrlezZjXtgQMH"
"ytasWSsSkZJOg1V5z549AhNW4FI15sf8Gpdf9l2lBAgKCvpjBGBgGWTOegaf16ov3S8ynl/n"
"bG/Xrq2mrm4FdsY8WZKZ3LhG9UqjZk0beMz45g6HaD/jHCnbAsi3QHHKM2RH3JVSAgwUMc57"
"5d8/zlYGPR0iBT0eBA7/B/3gee0XOJ9tSxndksBtKdkfayZ9ITUgUpDkt6B1Hbhcrg3P2x3h"
"bzoVUQ76CP12HzY21jD7YA3T5y9g/OiZOLlzTX1y5yIByucL+vXui47tOuCXTp3RuWMnWndB"
"l46d0bNbD0GCxVQqjB89hdGDR3jx8hXemn+m7dogyvcdUgIeIfbbMcTYb0SM7Qpar0Ws004p"
"3mkXEWOzFG2zVoqhiLVdS6qxhoixASkuW5HqugMppB5JLrukRJf9yniXA/JE9yOKzIDTkjLa"
"EEh7gJIUY0R5Xswxub7GYc60vsdq1ajMJrOxejwrVayoW6FDh/aay5evKM14jUOHDoqELFVo"
"XjM+rARsxv/PCMBSX5r1/CUsNwx8mzZtNLW0yuqq5as6y/uQgV223jbc/jkh9GUulK5AsQeU"
"mfbIinmjTPtuIs+IeFicGUJZ77wB0RaTEf52NEJfjELg06HwfdBP8rzVXXK52EHizHc60Qpf"
"9Jvjy4m2+HKyBZxO1YHX7S74brEWiQEvkJkSgSKlhLRsOTx8w2Fn/wWfLC1h9t5CnPl79vyV"
"ODv4wOQxHjx8gstXrmFAv/6iDJQGE6IvxSDqEvrS4+nTZuD5q7fgU81m5hb49MkSdg5f4O4d"
"gpSMAhTKi5GVFouMKHskexsi7guVBJsViHXYhHjH7YglcsTar6cSsZqeW0fk2CIlfN0mJZJq"
"pLjvQ6aPPnICzyIn6DyyAs8h1f9CcUrAVXla6G1lYdxDIPcVxWvE+t3MvXVp1efB/dtv5XHl"
"8eVx1tIqo9u6dWtNHv/ThA9jw9nPROAE5b8ZH+7e/mUCcAlgiWHweU11R2Pz5i3iYBFtuILa"
"yNSqWLHC4GWLxl90sb8TUSL3oM0FSyX53shJdlJkxVsr8pI+SUXJ71GU9AaZQecQazMfEeYT"
"pLD3E6XQ12OlYNPhCHg0CL73+8LzZne4XGiPrydbw/EYg96OwG8Ar7u9EO9mgKzUCOQVloCv"
"EVYUA1mZGQgM8IOnh5s432/n4CTO73+0+Ix35h+JDB/wQoD5kQhgiCEDB2PUiFEYPnQ4Rgwb"
"gZHDR9DjkRhNz40dPQYTxo4X1wJYWtnC8rM17B2+iotOPD3dERQYgKysTCiIdHmFEnLylchJ"
"j0Nm+BsBPkt/nMNWxNqRAjisQ5zjesQ7bQKDn+SyHclu+5DmdVzK8L8oZQZdkbJDDJEbdg0F"
"0UYoiH2E7ChjKT3cRJEZ/VShTH9PP/CzVJLzDi5WZyKWLRx+sVLF8oNlqsPPVcg8VmAcNm/Z"
"IvzAzzgxAbgl/90E+LkLmDZtmtgQu/vjlPWkBhpDhw7lHlNLXdtr6OmW779+zczrEUFmqVTY"
"IJWEoyDTszgnxUVelOkuFee4UfY7oDDFEnnxb6RUn8NSnP1iKcZqDqI+TkXY2zEIfTkCwZT9"
"AST/Pka94UHyTwqAb6wAJ8kDnG2CKNsdKMhNQnYBAZ5TgNwcAkGeT1GEpORUhEfGIiAoVFwV"
"5OLqLi744ItCrG3sRZh//ARbUoezZ89jzKgxmD51BiZNmIQpk6Zg6uQpmDZlGqZRmzhn1hxM"
"njgJV64aiu04EJnc3D3ElUIBgSH0PdHi0jGFQg6lohB5uXxdYR6y8pQozEtDeuBdahNXkvxv"
"oOwn8B03IsGJ4utmIsBOUoD9SPc5RZlvgOzQm8gJu4PssDtSdvhdKTfqoZQf+wTypBeQp7xC"
"XuJLKSPmhTwv0axYKrIBJAdE+Bqlrl894bqerk5/Hn/GgfEYOnSYwOe4/nGBF5eAf1kBZs6c"
"KRzlUWIVGQuNpk2b8dO6xDyWojZTJw09GupvlgjEo0QZLeVnBigKMn2UJfm+kCiUOR4oyvgq"
"FabaS/mJ75Hue5hq4kokOFLttJqFyPcT8P3NKEGAoCeD4W8yAD53esHDkAhwoR25+k5wvtAC"
"SZ5XQImOlLQMZKSnID8vF0UKpZjqwZd3p6enIzYuTj1ZI0Rc2uXp7UPAeYpJGxxMBhdXDxw9"
"cgyzZ87G0sVLsHD+fCxasAiLFi7CkkWLqfdfjJXLV2LxwsU4dPAwvLx94e7pBZ75w9vl7fP3"
"pKVniAkpJXxPAp42RvuTmZEm9k9ZAmRHviMlWEngb6LywAqwUShAsttepHgcpnE4h6wgQzUB"
"jJATfhe5kfeRG/1IRF7cEykvwVQqTH4DZfoHKDM+ITf5gzIv8YOipOALfasbQn3uJU6d1Pco"
"40C9PuOh27RZM4ETqwArNx+E+91dAK/btWsnPsgScunSJdnKlSv4vAAfpmK5r127VrXxr0wv"
"OgMJKFbGlxRkBSqKcoNLIP+OkoJAyHO8JXm2hyTPcmUCoDDVFhnBZ2gANiHJmaTRbgGiLacj"
"ggnweqSKACT/fg/6wvt2TyJAZ7hd7UoEaImIT+vAS3JSPNIz0pGbV4D8/AIBQOlkD77aly/l"
"TkhM+jFrh68JDAgKFuD5+PqJizt5Esf+ffuxbu06bNq4CRvWbcDGDRuxacMmbKbHWzZvwbYt"
"W7Frx07s3LELjk5fxTWFod/DEBMTi4SERPE9/H3FJarvZgLmi8vQCwQRk1MSxf6m+hmSB1hF"
"4G8mImyg7N9N4B9Bms9pZPhdJAJc+5UAEQ+IACYE/kPkxjxCfvwzFCS+RAGVy8Jkc6ko7bNU"
"nG0L5NjSeFqX5KVaKUqU7jTeDnhyfYVzrZqVJjAujA/jtGLFCpmBgYFs7NixPw4G/S4F4IMO"
"vPA98rZQfSGZ0dTR0WaWNRo3ut+B1CS3bLKtKMwJU8jzwkqgCEdJYSgUeQGSItePwgeKbHfI"
"Mxxphx2RHX4dKd40AO5bkei4DLHWcxFlMQURZuPw/dUIhJiS/Bv3h69RL0EAd8NOFD3gRv19"
"dqS5yKpEIkBmdq6ovzzgfLl36eRQBoKncPGVwHxZN0/XLr2Wny8IZQAjSLq/Obvg4IGDOHL4"
"iFgfOnhIxOFDh8Vzx44eE3Hm9BnoH9PH69dvkJyaJq42FlcaZ2WL7ymdYcTfX6C+tYy4tDwr"
"B0lJicKXFKa6UZewHPHUHrIH4HYx1fsk0v0uINOf5F8owC0iwF1SAMr+qIfIi3lK2f8c+Ymv"
"1eC/Q1HqJxpHW8gzbSVFho1UnOsAqeArFDlOJbmkCFLaU8T5XckZPbTLAcZHR6dcdcZr27Zt"
"Mj7kzgsfFv5NCvD35wL69evHt17TVEt+q/27FpuQEENeGKssyv1eDGUsJHkElPnBkjIvEMo8"
"fyIBgZ/rTTv8jcIJ+XGmSPPbJwiQ7LIWCQ6LVNlvPkG4/5DnQxD4qD/87/chAvSG960e5AG6"
"UJ/P63bIjrUTGZWYGIf0zCwyfFniku4f9/tRKMB3/yqdzyemcefmicu9OVt53gADyLJtTa3c"
"hfMXcM3wGi5fvgzKEooruHrlKgyp5l+/dh03r9/E7Vu3YXTXCI8ePiQyJQnFYaCVauD5+/h7"
"xUwicV8hKgG0X7x/iYlUDml/sxM9iQBU7r5uFZHsfpB6/jNI97+IzIAryAq+juzvdwh8I+RG"
"MAFI+mMJ/Pg3lP1mKEg2I9/0EUVpVkQAOygy7UQnpcz+QslFZaDQhUqDBdJCjIrz4p8qkfUK"
"OzdMN5HJNFpRwlevUqWqZs+ePQSOfE7gNynA358NJCJpaGtr8THsVmf011Bvkofc7MiiEnm0"
"BGUMlAXhkrLgO4rzg4gEagJw9pPxk2d+RVG6LRmci/SjDyLFa6eQ/3iHhYixnKEiwBsigOlg"
"IkA/+N/rLRTAizoAj+tEgBu9qBvogMSg94IA2VkZSCSzx5NAOBN5Ygdf8y9u4aKeGl7801w/"
"1Y0dVNO9eF4Av/eThQWePnmK56bP8YzWz6L1goAAACAASURBVJ4+gynHM1M8f/4cr16+xBvK"
"erO3ZuK95ubmoIET3y+mnUvSr8DzZJO8PNUdQ0h5eL8Sk1KIfNmCAD7fXlMXsIYUYBsSnXeQ"
"+h0m+WcCXEZmIMs/Z74xxQMqAcbIi37yKwGS3hH45pT9lpDTGMozHKDI+krgf0VxrjOK81xQ"
"ku+G/KT3UgElWH78KyktwrQIys84eWjlK8arvI64j5LGH7pLGLUW4kRERT1dPqvVcM+WKXeB"
"THLe0YWUi5CUsVJxQZhUTLJfXBBMBAgUwQRQcvZnO1O4EpNfEdP1BQGSPakN+kY10W6+mgDj"
"iQAj1QRQKYDP3Z5UAnoQ8N3geYvU4E5nRHm9QE5uEe1Wsaj/nJGc1ZzhPPhi+pd6ylcpGVSz"
"g4sFYCzXvPDkDwd7ezg5Ooq1g72DKhwc8IV6fMcvX/DV0Qnfvn6Di7Mz3Fzd4EHu39PTk74/"
"R2zzx5QyUpg8MfVMNWU8JZUnlSQTEXLFd/kGhMHizQ2kulA7+HUnkl33kAIcFvU/3f8S1X+q"
"/eFU76OeURDwnP2l8i8I8J5KyCfKfmsC/wvkWY6U9d9QnONK4LvTWHsQATxpfD8iN/atRO+X"
"5CkWSA5/XogSR+zaspSvUWyorV2ukvpUgMZvOhegJoBGixYt+UN8M8Sq/Xo0XI8icvNFaXIg"
"idx+vFRSFEHxXQV+AWd/gCryfEkBvGhnnYUC5EXfoZ6fjI8vD8Am0QHE281FtKj/Y/D9xVBq"
"/waoFID6f78H/eB7rw8B3wPed/sRGTohxvcVEhNSkZ4SL1w/T/0qna3LA59Of/NEztKpYqVz"
"/0onh/KaJ39GRETAy8sLvr6+8Pb2ho+Pz4/w9fEVz/uRWfTz84O/fwACAgJAgyYiNjZWkCuf"
"t0/B38flhb1GIgHPZFSo7y+Yl5eDj5YOsH5/B8nOWxHvvFfIf4rnCRqH80gPMKCkuE0EIMcf"
"ZUrxlOIxEeAFgf8a+Qks/x+JAJakoHaCAIqsb5T9LuCWWhCgwJMSzZ3ea0Eq8InCUspPspDk"
"VC4y483lxTkuGNi3J09Pq6pdrpyOWgE0frMCtGwpCMAnb9pbvt7lC6TTICYqyYujRBEjSXI2"
"fSECfJH5+ZT5eX60UwQ+sVROclWY9pnM3wVBgFTvHWSC1lH7twRxNrMQ9WECwt6MQOhzPvTb"
"l2IAAkxIBcgI+j3oD597ZAbv9qWWsAuifV4hOZkcfnQYUmmwiwoLxKxgBpWBKJ3Lx8E3byg1"
"a6X3BSxSl4B4MoVx1MIxmLHk6GPIIMbEqIIfx8XGIT4+npx+ApISE8VdQHiaWQoRjSeJMtmY"
"dNxpJKlBZ7VRlt5HSF4k2sK83Cx8snaC1bs7SHXbhUT3o0j1Ok5jcIq80HlkBF5FVgg7/6e/"
"EiDalOT/lQr8pA8k/6XZ76AmAMk/g59D4BPwJQXeRI4vggAFSVZEGCvkEQn4MzlJn8kIucHa"
"/L4v41eunOp2Nb/xdHAJBWQd2rdRTcrs2WiVMsOMfmQmFcBElBTHS5IyGlIRE4DB96cg4Mn4"
"qcAn55/tJCSL25isoIPI8Ofs30B9MGW/wwLEWk2j/n8cwl4PReizAYIAgSZ9EEAtoL9xP/gZ"
"D4DvA1IBo/6kBJ2IAC8JEMq2uEikpSQhMz0VBfl5kNQ3byy9RQxnu7iFC9/IQbRjBBaVCzaA"
"sQRuDANP6zhBhHgxB/DXoOfi43+8Fqd+zGDzdoTKkNHjW8WxAWTAWYW4RQwODhXdBncBfB8K"
"9gAWVo5EgNtI9diHJK/T5H+IAF4nSQHOEQHY/ZPpi3xGCvmSgjI/hsCPe4u8+Lc0buZEgM9E"
"ABtSUUehpIos518JkOdF4+1JnQJlfiIpAJWB/OTPKEixRn6qjcSEyUu1UypzAtC7R5dVjGPZ"
"smW0futxAA0aT1nnju2E/O9eN+gWip2o102Vc89fQrW/RBGJEur3iwu57vvQDnn/yHxFDjt/"
"kq1MB2L0fQJ/B9U9csBuq5HgRNlvOxMxnyaR/I+i9m8wQp71R+DDXgR+TzKBfYQC+JsMhO/9"
"3vC60w+eN9oh2v0eZSAZrJgwIkAqcrLSBQGKS02Z+gYRPLOXZZnNGD/mzC+9w+fPC2dpMf2j"
"4Nu/qEOYx39yOxm+AQX3+bxNJgZPRLWytoHxw8c4f9EA9x48ErOF+dgDfydvOz83Ex8/O8LJ"
"8hYyvA8JAqR6n6A4LUpAhjCAxmoCvCLpfy3AFxH/jghQqgA2oo3mbkpB8q8k8PnAWkmBLwrT"
"7bn2E2HeUbBqWAgVKEilVpHUIivRhvCKxfaNy26VlgEqaaK8/yYCdOrYjm+TXvvq8UlmkNvS"
"YCbKS4/2lSgiUFLE5o9rPoPvIXZO1P2sL9T326CISJAbfR3pvhuJ+euR5EL98Jf5lP1TEP1x"
"LMJfDyHwSfoJfP/7XQn87vCjDoAPBIkSQO2g1+1ecDfsiO8Wa5AUH00KEI/UpFhkZ2aIelx6"
"6xcGOo3KAPf6X51d8fbdB9y7/xCXDa7i1Kkz2Ld3H44ePowb166Jtu7N69f48N4cdja2qrC1"
"xccPH/COnL/ps2e4Z2SEy5cu4/jxE9izZx+2bN0uYt/+w2LWEJ9O1j95BmfPX4Lp89dwcfMg"
"BYgVdxIheRRG0J6MZZTrFQF8svdpIf+p1AFwCUgPUJWAHwoQ+4bM3xsiAEXCe7UCfKISak0y"
"7yBa6R8egMaaEy037h1yY15SvKDPqkpHfpJQAklByZcZ/0kOKRaXTu0zYxyJAOV/HwE6CQLU"
"unB4wgvkvkBhfiQRII4IQOZPEUbyz+aPpd9LmBEFmQ6Wfc7+onQyLxlWVOOo/fNeQzK4huR/"
"MeLsZ5P7n4io9yMQ9mIAQp70QpBJNwL/F/jd6/aDAGwCvW73FCeE3K92ge/D0YhyOkkKEEpA"
"kxRnplGWZYnbt3HO8q3huAfnAz6q27VYwPD6LXHhx/iJk1Gjek3QbwH1wmKtSVFGpoFymmWg"
"XaYsdLTKQYfWfAVweW0dcfVw3dp10apVG/Tq1QfjJ0zC8hUrceiIPi5euoLzFGIq2dmLePjY"
"VJx8ioqOFFPNRbuamYxIr0eI9TBACoHPkepzlsC/KFpAVoCskDvCBDIB8ksJwNnPmUyhIsBn"
"tQlkRf2i6gJyqfVL+ICc6OcC/NyY50QgKiEJpB4JpAaJ5pI8/TMyYt/LURKHM8d2vGActctp"
"/V4CtBclYOWCPheQeh15Gc4qBZCHSCXyUCIA135vAb6SwOed4+yXZ5JapJN8ZVjSDzz7KwG+"
"LkSsHcm/5QREvRuO78/7IeRpHwQ/JOl/QCS434MI0FN1IOgOgX+jK2U/hUEneD4YBV/T6Qi3"
"pC4ilIxlVibJsiTkuaSYevLCPHEIlieNurh5itPA128aYS9l7LwFi9CxfUfUrl4N9WrVQp0a"
"NSlq0OPqqFWtmljXpsd8WVjj+g3EFUJ8kUjXLl0xYMAgMTtoxszZYgbRvgNHcOrMBZw8fY7v"
"BYQLFy/hqekLfHNxR2RMIvkPakXTApEZ8ghR7ncQ6WqIVN/TpABnBAHS/Q0I/OvIDL6F7O/U"
"/0c8JpV8ri4B71TZL6TckjoAa2ECi9JUxwCYAErKfJb5HPILOQL8l4I4eXGv1d3DW0GAorT3"
"RAArORQJWDxv4gXGkYzgby0BahPYoS2bwEqD+9ZfL485jexoY2qqv0NSBJP8BxABuPaT9Oe6"
"qgnAxo92NIsUIO2jIEFOBMmd1yqkuK+g+j9XKEDs50mkACMR9nKQKAHBj3qTAWQP0Au+3Prd"
"6gavm13F2UDOfteL7eF5fwS8nkyDl/F4BDyfhgi7g0gL+wxFoSrjFFTmM7LyRJvn5uYGc/P3"
"uHnrNvbu249Zs+egWZNmIrt1tXmSh7aY4CGCHuvqVIBueT1UrlARVStVQc1qNdGwXgO0bNEa"
"3br1wNBhwzFjxkysWbsWR44eI9AviwtKTpy+iGMnL8L40Qu4uX5FXKgD0oKeIc2fnH/QY0S6"
"G1MJMESKzymKs0SEC0L6M4PvICv0AbLDHqm6AHUZyI9/T2FOhu6DALkozUEcRCuiWs/B8l+Y"
"YoOcKJb911T/XxPwpR6AvcMrNQFIRZLfIDvJt7gg4Ru6tKzOrWClMpoyrcCg33JNoLoNbNeu"
"FR8+0mvTvPyM3O9birMibhAr35J7Ivkv8iEj4kkEcFMTwPlvCZBuoSJA5GVSgNWkAKtIAeYj"
"zmEueYCp5AHGIeLtSHx/QSR42k9tAnvBh4D3uv4LPK91gduVTnC9THGBCHBvOLweT4bHvbEU"
"4+B1nxTh8VgEv1uOOBf6jkhbpCV8F8f6XTwC8Pq9DS5fu4/tuw5i+sy5fH0/qlWsiNrVqoqo"
"W6OaKlgValYnZaiBhnVqoUn9emjeuBHatGiBjh06gGf/Dho8jMrINMxftJK2dxj6py4KAty6"
"fglvnxrA3+EW4j0Mkeh5Fan+D5AZ9hrpoaaIcDNChPNl6v2PEgGo9vtfQUbQLVKH+8gi8LPD"
"H4sSkBPxULSB+XFmQtpV8m8rar8q7GlMndTgv6L3vlARII6Bf08kMPuhALnsBZJIHeLIg2XH"
"IdBse3F1LdkMmab431PKBAf/riOB4lCwXqWK2oOiv41JVyZcQEbE7RJF5icqA/4oyXcVhyMZ"
"fGXOVzUBaGcz6cvTVATIi7lFBFil9gCL1AQgE2gxAZHvRiPs1VBSgQGCAFwCfG51JfA7w82g"
"I4HfgdadxUUhnveGwfPhJHgYjYK70UhShLHwejAOHneHwePWAHgaDYPf05kIer8Jfp/08fX9"
"BbwyOYfzJ/dhxbKFaNumDcqXKw/tsuWhIdMiH1D276IceQIdaJXVg55uNdSpRQrQsi369u2H"
"aVMmYPP6pbh8agfePjwJ5w8XEGh7FhFfTiLc/ghCbA7h+5dziPW8i5TAx8gg8NNCniHc9S7C"
"v56j9veQKAHpAUSA4LvI+m6iIkAYEeD7A+SE3UNuBB8FfKn2ACz/nPWOos9XUAuYT4qQHfEC"
"2ZGmRAIiQKwZckkt8pgEsa9UZSCWSkm8KZGASkRyaEl2uDmerNNLL6cpG6ShvlNJ8O85FNyy"
"pSCALhGnk9u7gSFIWYz0MMPi/PjHDK6kUgAV+MpsR3KpdgJ8ecZnMi/m9J4PtGP3qQSsphKw"
"nBSA+n978gBUAqI/jEH42+EIfTkQoU+pDTThFrAHfG93Fwrgztl/qT1cLnWEy/l2cDPsBQ/j"
"sXC7NUwQwMNoBDzuDKEYCs+7I+F6Yxi+XhkEh8sDYH+pHxwMBsLp+gg4G02E070ZsLw+Fa/O"
"T4LJyYm4eXAsDPaMwemtI3Fq6yic2U5/bx+Lc7sm4ObR6XhwZg5eXl0My/sr4fRkLTxeroef"
"2QYEvKMw3whvs01webEBDk/Ww+bReriZ7UGo/WnEul9Dir8JMkKIAFQCmACxrmdIAY6JLiDN"
"7xIpwG1kht5DJgEvPEAYx33ksQKIg0DmJN/WRAA7QQBu//KTPiMr8iWyKfuzI56RqpqqS8Ab"
"VQngUhBDZSSeM99Wykv2p/rvWuxt2BYGs2UhMplmp7JlxOyp33UuQKN585ZqAsiaPLnak/qK"
"WcgLXqgoTDSmOvNWKkq3IvlnBXD6AX5RBveu1MKkmYlykZ/4FOk+65DiukR4gFibKYj5NJay"
"f5jwAKHP+1Mn0BeBxj2FAvje6Q5vPgdA9d/tMoF/oQOcz7UXVwQ7X+tH4I+C662hRIQhcL89"
"mGIQPG4Pgev1AUSAgbA5NxDmx/vBdG9P3NvUCTfXtcP1da1xeVVTXN3QHCZ7OuLZoW54faI3"
"zE73x7szg/DhwjC8OzsMZmeH0/PD8PTQIJjs7Q+jHX1wa2sv3KC4u3cgHh0fg7dXZuDT3UWw"
"vr8MDo/X4OuLTfAy34MQuxOIoZYv2fceZfkjUoIniHa9jCT3I0j2OqHqAoQHuEavUxkIvk1d"
"wF0iwQNV9rMRFMcAPvyqAGmOlM3mavCppkeyAjwnAjAJnlIXYCo6gNwYU/rse+TEf0VuSqiU"
"G/cNTpe7KlwOybBvopYD46dTrkwpAX7zoWCNZioCiGMBp3a3e4LseSgImixH7GrqUx9J+WRS"
"CvkgBfX+CuH+P4msL0rj89dviMmm9GNMkeG/HckuC5HwhbN/HKI+jKD6P4jqP4H/rI8wgQHG"
"PagT6Amf2yoD6CU6ADKATILzRIDTbeBwtDm+XugO19tMgEGU9f3hdnMA3G8NJgIMgiNlvvWZ"
"vvhI4L4+0A2Pd3bB3Y0dcWVVaxyZUw87p1TD3mnVsWtqdeyZVhO7p9ai52ph15Q69By9PrUB"
"to1vgM1jGmL35GY4OrsNzq3oghvb++LR0eF4dXY8LG7MhLXRAljfWwwbk5VweLoBnu9ZAU4S"
"4AZI8r2LtEATyvjLSHQ5iCS3w0j2IA/gfVLVBnIXEHSTfACVAjKDXAJyCUwh/9wFUE0vTKLS"
"mfCRQH+OLDKJWQR6dsRzAb5QAHoum3xDduRDFQHibZCb6IOCjGgqPe8l96vt8GGnTO6uXw5L"
"+8ueMH465TTL/1ECiFZw8Ywm55E9nwgwgwiwCCXRayVFshEKMl1QlOMnzv0rsvnUL7n/lOco"
"FOA/IRIQe0OOIenbLMTbk/mzpH7efDgi3w4mBSD55wNBj3qRB+gtDgWrFKCraAE9b3QjI8hd"
"QAdBgC/HWsBmf2PYHW4piOB2cyCVgEFEgIFwMeyHL+d7qwnQFy/29YDx1s64vb49DJa3xLG5"
"9XFgVm0cnVsPR+fVh/78hjixqAlFU5xc3JzWLXF8USscndMKh2by+9vg7JJOMFjXDTd39IXx"
"wSF4oj8K7wym4vOd+bC6uxA2D5bhy9P18DTfhxCH80SAq0h0v4D4r3sQ77gVCd/2Egn2kwoQ"
"CTyPqw8CXVS1gSF3VOcCwkzUBHiFAgKdPUAWGcN0UomM7/fJUD6kx0yCF0IBsqhkZH8n5SDV"
"yIn9SMC7UdsZjry0EMR9O4dvF+pLjkfKw2Kvrtz5gAyjOmicZ/yIAL//ZFBz1dlA0QoO61dz"
"C1LnQh4yXYmYpZCiV0uIWYOSxDNkUmygyAuFMj+ciOAv1KCQFCCfSkVB4hP6gVeoBCxGguNc"
"xFhNoPo/EpFmQxD+Zii+v1QdCg56woeD+8GPTwWrCeBxvatoA92oE/h2pi2+HG9J4DeD1e4G"
"+LytHqz3NsGXkx3gYtBbVQKuDobNhYGwONUPr/Z3h/Gmjri1ph0uLW1JoNajLK+BXZMp6yl2"
"TaqN3VPqkiLUp2hAfzfEzkmNsHNCY+ye1BQHprfAqUUdcJkIcGtnPxgfGopnx0fhvcEUWBIB"
"Pt9djM/3lsOefIDPh90It92HaNvNiLFZLSLWYQvivmwjMuxEousBJAkVOCV8QHqgoTgOIAgg"
"DgS9oPr/lkB9TOpxnTqJKyoCEDmyqFPIDH9CRHhE4JsIMmRHk9wnuBDwYZT1kUj/bo6QNzOp"
"VNbE17N1JMdjVfFpl5bSYa8mfmkk28L4aWupblb5u64HaKEygdQKaug1b6w7B1GzJCl8loSo"
"hUD0ciBmIxBLEbcHJSlG4iCFoiAOyqIUihhxTUAhdQP5cQ+oBMxDvMM01XEAq2mIsZyCSPPx"
"qrOBpgMR/KSfuB6ADwQJD8BG0JBbwc6qTuB8BzidbCUIYHOgCax3N8SnLXXwcV0NWGysjc+7"
"G8P2cDvYnOgGixO98GJvN9xd3wGGy1rjzNxmAvCNY6ti67ga2DK+Jkl9LYo6BHo97JhQX0j/"
"1rENsWdyUxwkBdCf3xanF3fA+ZVdYLi5F+7sHoBHx4gAV6bB+vZsOBrPg/uT+Qh4uwiRn5Yh"
"ynIJIi2XIdpqJRFgLWJs1yHWdj2RYAsSXPYKL5BCXoB9QJqfqgywAeRrAbLDTUSLmMzHCgIM"
"kUb+ID3ktlAAVoOsCFMC/R0bPOQleVG2hyM/PRKZUbaI+bIHvg8oWQwb0zi1ojGqDYcjlWC9"
"T0f6tF1DqldFNoc7Oa2yqsmnf+T+ABoammX0KuqVGZbiOSUTMbNRErGQsn8VpJj1BP5Oir0U"
"u4AEfZSkPRYnhYoVaSgplqNEmUstY7w4SJHqtVu0gdEWoxH9cQyiPk5E5MfJiHjHF4WOQYjp"
"MEEAz2ud4HG1IxGgs/AArtQJOJMPcDzZmmcHwf5Ic9juayyUwJKUgIlgsakmEYHIsKk6Pm6q"
"BbN1tfCUTN+t1e1xaUELHJ7WEDvG1xaxZUwtbBxRCxuG18J6ik2j6hL4RIJxRADK/iNzW+H4"
"gra4tOoX3NzaGw/2D8TL02NhYziG2s2R8Hs4BsGmE6iDmYwws9mIsFiMiE9LKZYRGZbQ40WC"
"DFGflyPWbj0SnHcSAQ6IbiDd9ywyAw2EAvAxgRTv80j0OE5G8TRSfM9T9l+muEoKQCUikpx+"
"vD3yU7wJ8DCKaOSnfkdWtBUSXI8h9M0Y2pdfKKhs3iGvdKmRIID9kSqS/QFtmK7VyNQtJxvG"
"BCijqanxB64IUl0Spq2txT3kL76fxoUjaT4UYfOL2QhKMRslxG5RkSD+MBHguHp9FlK6KUry"
"vFCiSIUE1dU4fJJEkfud6t0bpHkfR5wdDZo5nxIeQoM5CMHPBiKATwLd7QPv273hebOXyH7n"
"c+3EnEDHE82JAM1gf6wp7A40gtWuevi8oy4st9aB5fa6+ERr8/U18X51NZitrgKzVVVgvKYl"
"ri1ri6tU3y/Na4nLC1riwrwWODerBXaOqo91g2thy8h62Da6AXaNb4x9U8n8zWuN46QA9/f0"
"x8vjw/Dq9GhYGY6D792BtG+DKeNGCBIEPJuEkFczEW4+n4i8EJEEfPQnjgWkcAsRZ72MfuMa"
"UoFNohQkUClIcD1CcZRU4RCVhv1EClaGY6ouIeA6ZT157WhL5Ca5oyA9HIVZiSjIikdeij8R"
"wozMJXUbdvMQ/n4kEWAkgp4Pgf+jbjRebeBq0Ez6dqYObA5VLnY8pI0bizTCGTe+P0Hp3Vf+"
"0CVhuhXEVO7mb+4M+YaMhSgKmatAHClAFPmA2M2q7I8/IBQACWcozgNJF4Hka0DGE0i5jpDy"
"/SEpc9QnWFWnXEsU2ShM96La9piyZD8N5CwEmPSjDqA93K+0osxvRZlP7d/ZdkQC8gHnO8Hp"
"TAc4nm5HHUFL8gCN8Hknk4AIsLU2LDbUwIfV1WG+oirerqwGcyKB8fJGODenJc5MI8M3pQlO"
"0fr45MY4Pb2ZIMCaQTUFAbbS3zvGNcL+ac1wmIwgl4Db1P4Z7+mLh2QArS7SQN8lcpLp9L8/"
"hPzKSCLsOIS+mobwd3MQ9n4eQt/NR6jZPIS8nYMQ+vu7+SJEWfEhcJ4XuA2prjuR8nUrmeF1"
"iLbbiDCrLQj6tAMBlocQ6fIAWfHuoqYXEuCFmQR6ahAZPRtkhBqROhwmwqxFvNMSxH5ZSOoy"
"A6FvRyLwGfmmh0SAW+2IAE0l57N1YH2ossL1mDYOT9H4xriV1eRWXhBA43cRoM2PawK1eepX"
"HYMjPcnSL0FB8Fw54laqCcAKsJsIcEhNgONqAlwFUu4CqbeBdGN6z0GKY6QMryGRMkjKTPz9"
"UlJcQD88mOqeOWXIeXx/txLeRiOIBB3hqN+YpK0udQE1YbWnOqx21CTga/1QgI9UBt6T7L9Z"
"Xh2vl1aF6aIqeL2sEowW1cMxqutHxzfEIQL4wKgG2DucOoJRDbF5aF2sHszloA42jayL7VQC"
"dlEJ2EMqcGhWKxis/gVX1/4Cw0298P5EH7hd7YVvV/pS+6lqPb3uj4T/4/EIeUl+5j15G8r8"
"ZFK1dKeVyPi2BunfCDDbFQh6MxeOd8bj3dnBeHSwD25t6w7DDT1wbVN/PNKfAZtHRxHsRH1+"
"gp9w9Rlhr4QRTPLaj0S39QT8ajKRmym20d8bEOdIxPo8hUhHpegVEfIRlwAVAVzOkQIcqSL3"
"OKGNtcM0XjJuWmX4Njb/EgF0uIWotmZhm8vIXkqt4BwVAaLXS4hn+Sdw44+oCXBSlAAkXSIC"
"3CQC3CMVMBXgI5LUIob8Qjz9nXyFnn9OZHCCVBQBqTj37+igUgmpuAhFWZHIirKnATFBpPUx"
"BJiuovIwnpSgB5GhkfAAnzYTITZUh+XqqrBYXgXmy6rAclVlPF9eG/qTGuPYhAY4OK4B9lG2"
"7xxWB3tH1sfW4XWxdkgtAf5mfn6CSgG4DOjPaQ0DNoAUNzf2xNeLvRBm1Bsh9/oj/OFgRDwd"
"ju9PR5F5HYPAp+Phem8s7G6OxdtzI2G0dwBOr+qOrZNbYF7v6hjfRgdDm2hgWGMZxraSYUEP"
"PWwb0wRnVpBZPTMDzs82INRqN6K/bEWUDZUQ61mIsZ9Hbd1KAnwjBYHvuZ1aya3UVlJJcVxM"
"ZnP6DwIEmvaE7z1SzWvNJPerdWF3sorc64wOxnfRuMy4EQF0/hABSkuAnq42/89XlSYMb7QL"
"aUupFZyjRCwRIGYzEWAfAU6AJp5UxQ8CXCYC3AHSiADpT6lboBIRzaXiBMUpei+9J/kCvU7v"
"yySVyH0BFNgSGUgd+GITZQqBn/8PKqHyEqorfHLTYuD05DCMd43G2XldcGBqU+wcVxs7R1TG"
"rqEVcHhkBewfWRGL+1TDIop5vaphQU9ad6uKuRS8ntW1Cub1rI4FvWtg6YDaWDakHlYMrY+V"
"wxpi+bDGFI2wfHgTHJ7VGMfnNcG2CQ2xksiycFAdTOpeCwNbV0HXhrpoXrkcapfRQGUaTm0K"
"GjCQ7qIWRZvyMgxoIMPsblrYObE6bmxojbenesLp1iD4EpGCX6nqecjb0Qj/OBXRNgupjSQD"
"6biSvMMqJDqvJZO4nbzCdiLAOqEA0dY/EeBZT/g96ACvOy0kr1v18c2gmtLjnA56NdfYxbgR"
"Acr9UQII49CieVNxVrBdy6rkbpagJHxeCWJWQMh/wn6Kw6rsTzytAjaR678hEYCATTNWESBm"
"DxGAO4ZDKjVIpDKRep1eo/dkGgE5jEik0QAAIABJREFUj4A8IkHhO54JCyhtAPlnSAVWKM61"
"E6eblbl+UOZHQVmYQixQIC8jFY7Pr+DqpqnYPK43JvRsij6tqqJD/bJoXlWGBroy1NWWobaW"
"DDU1ZKhKP7UyrStR6GlqoFIZGSqWpaB1JXVUoNfKq0Eso75wRPYbgjIF5JTRQFsDnWuUw+gW"
"5bG4dyXsmVANV5fWhenuZrClVtb9Vnf4P+xL5m0wgkyHIODpUMpgAv8NdULmUxFuMQORn2cT"
"wPNJBZYQ2OQhiABJnttUCuC8hsixgLzFNISZj0HQy4GCAP4mHeBj1AKet+vD7Xq1EseTOmhY"
"TbaAcWvYoF4Z2R80geJDHTq0ZyXQq1FNZ1SG3/wcxCyi+r9CQhxJenxp/T+qUgA2f0lk/lJu"
"URCwaSaqYPBjSC1iiSxx+ioCpBgQAW6oCUAkyTcjAliALz+DwhooekcG8jlKsk2gSDeCnAhV"
"lHAN+bGGFDeRHXENMS5H4PlqFT5emYF7B0bgJLVuG0ny5w6sRhKoh35NdNC+uhaaVNBEHcrQ"
"Kmqgyv0TcBnEshQ66qhIJKlSVgM1dDTRoGIZtKleFp1rl0XvxloY1VoHM7tUwNJ+utg6uCL2"
"DdXDhWmVYbysBsy214fdkcb4dro5XM+SmT3HDp3atGtd4HqzO9xu94LH/X7weTSYPASR4Nkw"
"BL8cRSZyAinANGolZxPA8xBtu4jAXkbGj1TAbSOS3KibcFpBCjEHUZ+mkEcajcDnA2gb3eFH"
"BPAzbgnPu/Ul7zvV8OGATk5FbdkoAl6vVcuWGjL1Tcl+z7yAH1PDBg0eLKtQXoc7gW6BNjOj"
"kbwcyogVxYjfDClupyQ6AG7/mADJBGoyZXUqgZr6gOr8U1UpiNqiIkDMAVUZSDxHz5NRTKfX"
"Mo1VBMh7RQQwJwJYqQnwkTzCO5TkmEFJfkGeYkIEuIP8GEPkRpxDdugRZAcfRG7wHuQF7EC+"
"/w5kuVG2UIbEWM0kiZwIn8ej8O32INga9MKns93xTr8L3hzsiHvrW+HG0iYwnF8fBrPr4soc"
"inn1cWVuXdyjjDVaXAcPFtfCg4XVYbK4Op4uqYZXS1Wt5ce11WCzuQbsttTCxxXV8H5JVXyg"
"9Ye1NWCxuQ4sdjbAJ/Imnw80xefDzWFNHYvdqbb4erkT3PggF899NOkP34cD4fd4MCnACCLA"
"GOogJiKMCBDxkVTAkkBmAtgvRcLX1WSK14lSEEuqEGU5ExEfJuG72Sj67AACvxsTQAp42Ape"
"DxoWBz+shodbdaIZLz3dCrp9+/WTqQ7oaPwxAgwZOkxWtUolJkDLT4/GuyJjHYq+r1AgYYuK"
"AHHsA8gEJnFdJ1CTOfMfEgEo8zNfqjqCyC2qMhCzX00ALgGc/feBLJJ/ynTkvyUCfCACkPwr"
"KIosqH00R0nuOyhpO/LUhyhKuoeC+LvIi76GnHC+ulYfqV57kexKDvnbJuq7l5N88qRTktP3"
"48TE04jXVFtNhyLk4QCEGPeDP2Wg//Vu8LnUAR4nW8HtaHM4H2oGlyMt4Li/Kex2NoLd9oYE"
"cj1Yb6mLzwTqx7U18WZZVbwig/l+bXW8INAfTKUuY4IeHkyphMdzqsB0aXW8XVsb5lvq4zO1"
"qPZHmsHhREs4nmkDR77NDZ/a5kvc+FrHe33h/WCAUICg50SAV2MR/HoclYEpiLCYSS6fFMBu"
"MeK+LBcEiP9GwdPpbReSQsyg1nM8Ql+PIPkfILoAJkDg41bwftxIEfG8Os4v0XFlvKpVraQ7"
"YMCgHwT4I/cH0JgydRr5gMbcCta7fXaoGXK3oTBsvRyJ24kAuyXRBbAHSCJTl0KgphCo6U9U"
"tT+TQE2gbI/eQfJ/UFUC2ASySUyjMpFJJMl6RgQgouRT/S+0JPDtyQNQFFkSAT4SAcyhzHoL"
"RdozIoAx8pkAMTfEBaeZIaeQFXAEmT57kOFBRokHi6edfaZM+jAR31+PRdCzEVQjB1GrpDq4"
"5GrQHU7nOuPL8bawO9wK1nuawnJHY3za3hgftzbCh80NYb6uHj6sq0NRG+/W1MS7lTUEAcxW"
"Unu5pDIeTtGDyYSKeDSpIh4TAZ7PpeepBX23jglQD592N4LN4WawO94CDkSAL2fbCQVwJeJ5"
"8L0P7vaB1z3q4akMBDwdhqAXowUJQt9OpDIwXZQA9gBcAtgHsBmMc1hK7n8uIi2mqwhAxpFL"
"AHuAwGedpJDnreH1uJE84mlV7JxSnq8ErteiWaMKEyaKewRp/O4bRKinh2tMnzFL1rmTmCNQ"
"ffvqbteQuxOF4dvkSD4AKf6A9MMAJl9WGT/OfAY/nSQ9gyKWTF8smz/uAE6qCMFKkU4dQiYp"
"RTZlfx7V/4JPBDpnvyMR4IsoBb8S4A35gOcoSn5IBLgnrjTik0xZoeeRGaCPdO99SHUjk/Rl"
"JeJs56tnHpOkvqGsesHt2hD4U931YxIYdoP75V/gdr4Tvp1sB8dDLWG/lzJ/TxNY72qCzzsa"
"wXILyfiGurBYX5ukvRYRgLJ7eVU8nqmH+xMq4P54XRiNpr/H6MF4UiU8mV0Fz6lUvF1VCx+2"
"qRTA7igpwOlWcDxH8n+xA5yvdobL9a5UBnqQCvSCl1Ff+BgPVJNguCCBIMCHaT8UgEtAHJPA"
"iboC+8Uk/3OoRJABNBsvDgSFvCEz+aIXRWcpxLQ1PE0ayr8bV8Xs/uWvMV6dO7bVmTxlmsDx"
"N08PLyVAx44dxQfnzV8gGzpkAN+8sPLcyW0PIGsHiiJ3KpB8CFLCYUll/jj7yfylUk1PJUlP"
"p6zOfK8ig6j76vYwkd6XxD6BlCKdPELmYyIATzim2l9A2V/EBvArEcCJCGBHXcBnlORZqBQg"
"/QXkyY9RkPBATYCrRIBzyKQykO6zH2nu25HktIYUYBEpwCxRJ8Pe0EDRwAY9Hka9cn943+oF"
"9yvd4HKhC5xJBZxOtIcDqYDd/uawISWw2k11e2djWG5rJAjwgST9PSmA2TLyApT1d0frEPAV"
"cGdEBRiNIvDH6+EhlYKnVAJeLCECrFERwJIIYMsl4BSVADKBX6ncOPP1DXyK+4aaAKQATABf"
"UqeAJ8Mom0dRK6hSgEhLKmPW5GVsiQRcChx5TgWfbJpHBOFb6owTHiDk7WCEvO5NZaSzFPSE"
"PIBxQ4XfjcoY3qk83yeg8tDBA7RnzZ4rcOTbzf4RAog7fE6eNIFbwYo9OtddgvgtKInbW4JE"
"yupEyu4kdUanljp/ApWyFZkf6XVqB2OPqo4OJl5S+QEGn41hulr+s18TAaj2E9goIulXuEDc"
"VUz+hQhgQwT4DEXWO8jTXpICPCEFIALE8qQKQ2SFnFMpgNdupJECJH1dj3jKmBjreZQpU2ig"
"iAAvqb5yGXgwED53+sLDsDtcLnaG81k+zdxRkODLkdYqEuxrDisuCUyATfXwcUMdIkAtAfLd"
"MeVxe4QObg2lNcXdEbowmUglYHplPJtXBS9/IoDV/sawZQU41QpOF9pRb94JztQFuFwjD0AK"
"4EFK5H2/P3wIfL+H3A0MFQRQKcB00QlEfp4r2kE2fvE8oZY9gM0Cem06wt79qgAhb/owARDw"
"iDzAg4YlzucroU197SWM1xTCbdbsOQLHP0yABQsWyhYumC/+A+fGDaqMyw5an4/kw5T9RyUk"
"n1W1fimGKuefdl9FgAy1/MdRaUhQA59EwCffVZPEWNUhZFHtJ5ePfJL/Qsr4IidIcjdq892I"
"APR3ob0ggZRPSpDzAcUZr4kEfBOFu8iNuo6s7+QDAk9SCVArABPAfjkRYL7KLL2ndun1eIQ8"
"H40AGmhWAY/rveBGKuBKKuByrgu1a53gdJyU4FAr2DIBSAUstzYkAtQXHuDxjCok+RVxb1wF"
"3B6pg9vDyuPO8Aq4R/JvMlFPEKBUAd5RybDY1QDWh5rAjm9rd4YJwB1AR6EAbALd1ATgEuB9"
"f8APBQhiBXhDraD5NFUXYEVeRnQCSxDH91QiH8AmMIrvq/Rx0t8oQDARwP9RKyngcSNYHa+Y"
"X6dKuXGM16KFCzRnz/mDBCi9RQzfLHrjxk3ioGDZsmV6BtsviUPWKSjjThYj9RKk5CsSUq4T"
"Ae6qev5UIkCmmQrw2OOq4wLJrA5U81MJ+LRHaoNI4GeTSczlG0dS7S+g2l/sTrvgR+EPSJ4o"
"KeQZsaqJJgVJZtQBPCPwH4prDPKibyE77Aoyg88hw+8I0jx2IZ1UIMV5/f9X3HeARZUlUTfZ"
"POaIGbNiTiiKOQfMjDmOWcecE2JCQAVMCAjmnBMGQEUFBbOY8xjGnEDSO/+p+147rrv777+7"
"M/vzfddusPvRvDp16lTde+uqBlRPGT8f8yY+ZFp1b08b3NpK0URPuxJcD3Gra1ML1MAFCsIY"
"nyqI9qyI03PLInIGReGkYjhCBjg8yh5b3YT6f0JIGzIAqV9YILCZ0L8OgFARgsz/t/aQDIEA"
"GJGH9M8MYlYRRHoIAErhjMEAZ2Vdgx+1x8pqDAG19BBAVhIGUAAwUsFvADjeC48jRAj2UyJQ"
"ACDh4PEJNwpBvQ5we28DYQAKQEemlSVT72wvhM0TMz+1srSS7uWZpJWfuVXsv60BzACQHjMT"
"J04ySWNCflv6+JbOF/F5EZKeLEqRUq72wk/T6/5BhnG36yFAjP+bl258ZfhNOjvIo/z/e1L/"
"B+qEz8z7v5wk/Z/Tl5W9PauvM/xwlt4vDSYv8mNd5ojjOEc2CMOXZ5tUGPh4bzne3/TGu6vu"
"eBM3hXFyNGlzML3kFzw4Nhj3wwbi3uHevFmdcXN7K97oxrgS2hCxAXUR418LMX61EL2sJqKX"
"VsdZz0oMB+UZDkojcpoDdg8sQHGXk96dHaFtmfI1z6hAENRCjJ/RAEAmJQC39hQA5MT+UXmZ"
"ARTE8VlFETnPAacWliIDlMNZXwLAl2GHDBCzQgeAHgJEBDYwvJ+0vredAsD9w/RyKQZJWViF"
"AAKAqeBT6oDHzHIehnVQAFAicEctAqAiLm8olfJwT2H4/pLxIkN+aVkJPGXKVNXm7z8CwHeN"
"Ii3meswz5c2TU1LBAoFezQ8hyQuJjz2T8MaXDOCvKfGnqn4EwNvdOu0/kezAlwwgAKDaf02v"
"ZyqnHt8SJO/JEh/p/Z+P0/sp/BLPAmn3+BE+0PvfQhpRJCVcw+/3j+PakTU4tnwyVvVsQoT/"
"jGTqi08PgzlWEgAMA9eoA+Km4usdd6Q9WYSEux74wPTw/TV3tTv39fmJFIjD8IQ39cG+drjP"
"7ODedmqDjY1xNdgFF1eJNqiJs4sr4+R8R+wf7YBdvxTG3iGFsK13XqzvlB3BLTMTABl1IDD+"
"B7ekAGQKuKV7Nmzvk52vz4UDo/MjTFLAmcWoAZhdzC9NAJSn8fX4f44ZSPRyAwAhpP/19XFt"
"U0MdAGSpO/vbM767Ugd0JnjdVDooXv+bCgFGLSCCf8Ph9ioExG93ZgZRgxmAIy5tKJX0aGdB"
"TOmU6ZDYKXfOrBnmL1hkateurSoD/tvNos1t4oggiwULF0ktQFaW5pw8olYAkpYi8YlvEt6t"
"JgBWaSr2v6GR3+7Q4/zDiYz/C3QgvCQ7/B5iMMAmHQQCkg9U/h/DlPenfTylqD/+0AocmNQP"
"W/u1gn+90vCpUggeRTJgckYTJmS0xmh+3AWViiLpXSQZQJZGB+HD7WV4fZkGp7GDf20Kz85V"
"sHVaa+zz7o0w30GIWDMcp0OG4VTwIJzbMABRa7sh3L8FwrxccHSxM05418VJv3qI8nXGpaD6"
"iPOtyVBQAWETy2D30GLYMaAQtvTMi9AO2ej1mVX6F8wR0lroP4vu/f1zYveQPDhA3XBkEtPJ"
"GQ4MAWUYAigyfZhx+FXlqEYAVEfMcmYBq5mOBulZwDWpA+ygN1Ow3tknAGjPDEbmBLrrIlCy"
"AAHAuSFGLaAbtU0bY0GIMxmkmnZzUwVcXFcy6d6GAujpkj5A7FSssH16z8XeprZt2vx3AHB1"
"bW/h47PUVLNGFZUK9uhYbg4Sl0pZNhnvQ6C9DtHwZqNu/DdbafxJ+pAQ8EzmBqgPXq7RNYBU"
"CIX+FQBI/5+Oqdif9onxH/G4vGMZwueORlyAO47PHoJlxbJgub0Jq0pYY1Xp9FhaxAL+NQvi"
"0/NI1T7t0+P1+MAw8ObaInr8fBxf0Q8Bw1pheNkCaMs/zS29JTrZmdApgwntOVyzWKBFOgt0"
"K5wNfcrkQSf7zGic2RpOFia0ym6D3uWyYVj13PDu5oB9k6vgzPxqODS2NLb1L4zN3QmC9tkY"
"Dn5Suf96aoNNXbJiy8/ZsaNfbmYA+XB4bGEcn1YCERSVkYsq4eTiqgRADZzxq80UsA5iVskj"
"RegqAiCgthKBkgHES61iZ0t9UogAuGcGAEOA1AGkEighQETg/cOdcGc32Wt7I4a0OgoANzaU"
"R2xgieTrq/OhWaX00jjyp2pVHO2W+fqbWrVqaT5g698rBH0HAJOPzxJTPWcnOTwoc+2q+Qbh"
"jRdSfw9NxbvNal5fzfm/369P9Dwcx9x/hl4AEg3w3E9nATVHsF6vEUiGwNQOH5n6fWb8TzxH"
"DXABWuojfoSvSPn6Rk35ngvxwsIsJgSWsIV/ARP88nOUz4G3j08yLQzDJ2GBewF4F78Eby/P"
"w9cHPmohypfHGzG9bgkMyW7C6IK2GJzThGH2tuiRzoSQkW3xMtaTWcJg3vQu9P7GCBpeE90K"
"Egy8HS3tLFDPko85bTHexR4HZ1anUStgS297bHTLiw1dcmJjl+zY3C07jZ+DDJALuwflx57h"
"hbBnZBEcmFASJ9wrMfen0AyQxtfNKPaakfYb0fAu1B/1cH6F/B+zgGDJAlxwg2mqFIJu7aJn"
"72mnp4IEgBjcDAA1EURGuHfQVTXVvr7JBVfX1VYrgq6uLYcLK4unxnjnQbmCtoPETnWdalkv"
"W+ZHALQy/VcAkHbjS5cuM3Xo0F6lgkUL/dTuy0OPr3jPOP6OnvxexkF9OdijUXq5Vyp/ogFU"
"GBAW8NdZQApDr7fqbPF+j6EBwskCUvi5qFrLJX+8iIQ3sdQDd/Eo9ggW5zJhfSlLrClK4zlY"
"YHVxG7y6cQSpH08zBMju2kAdAFcW4PdYD9w7QS3wZB18B7YCEyD8am+HvplM+CWvDdxsTYgM"
"nKRatV5eL4s56EXrnfFwf1ucXdUMgyvnRsfMJvTKbQVXvqeptQltc9li7eAKODZFQFAQW3vn"
"x6buebClVx7m/vmwo38B7BzEtHF8CZyd54hoL1L9sro4tawxQ0xjHPdqhpP+bXF1S2fG+9aI"
"Xd2QxmeoCaijWuBcFhZY3xDXt5DSd7TEHVUL6KxE4GOhfwEAQ4AIwIdHf8Zd6oSbW5uolrpX"
"QmrhcnBlXAooi7gVMvGU82v+7DbSHTqTa/t2lr6+fwIApNest7ePqWfPHioVtLUxOd2LnvQC"
"Xw8g9fXONHxini5rAB4OptEn6RM+CgQe+hAQPF+qM8DvoboIFBZ4Txb4eEDPAgQAicz9UyUF"
"vI+0VBGDz/H6UTR8i6XD+uI0PgGwroQlVpIJnkbvgpZ4gQCQFmtBBICPAsCHG9KLZwFSX2zC"
"6mHt8DMNOKGwLQb9RAYoYItu/P7A4kEEwAxSbzNcDaFHkpbD5zrilEdlnPZvhA75MqIDNcfP"
"2SzRI6cFOhEQTdNZYcOoSjhKEOwcVAS7Bhem6CuEHQML4cCIYoicXha7x5XFnBb50bdcVnTJ"
"nxHtM1mhO6/Ri2Gnfy4bDC+dDWGezZivt6K31sfF1c5kAyfVCe3y2vqkclkbQDG4szV1QAfc"
"O9TFKAT1wxMa/4lMBDE7uMMwcXNzY72ncnBNXA6sxGymVNol36LYMi7HCxsrCyexkxTwli5d"
"+u3AiP8YAHJmkBwBM3ToUFkhLKlg2ai9g64i5SBp+HAKXnlBezhAw2NZ8jVOB8DT2cYcgLse"
"FqT+L3WBV2uNNHCrDgBVBzhCAFAEfo2GliTrBeORlnJLZQSfP9zC6kpU4YVN2EDv31jSEqsY"
"Bu5H8BpfL+HjQ9knxxBwYzEBMA9vry7Ab+fckfJsPdZNdkM3UvkkAuAXAmCkvQ6A3fP74nXs"
"NN70BgoA55ZUw4np5XBgXGnE+Tlh9ZAqaGxFFshlCVfqhp65rNCRj70dsiKSovHA2LI4+Gsp"
"7B3hgOOTy2D7yFIYUj0HGmSxxuBqebGkZxlsm+QEb7dy6C7AY/gZnodA4DUnVS1AL+/CEEAG"
"EAAQfFKTuBREbw6tT0XfhLG9BQVeW9xlOii1fxGBT072Zf5P+j/QAbeksrmpEVmjHt9XU7u0"
"uiLO+pRMuepXFCt+yXZV7GPLlF2OmfHx8VGntf1HAPj+vAA5lWL8+Imm/PnzCAAKrvPvSrc9"
"iMSHU5LxtBe0R0M1PBpO44835v1nGgCYY8wDeBkLRYKNWsEWoxC01wBAuKoDIOkSQACodDDl"
"LlKSnyCkdnFsLGjC5hIW2FbGBgG8oTe3kVHSrutbpAQA1wmAy3Px7ooH1fIsJP8Wgp3zBqAH"
"b/rkIrYYmpWhoKAOgM1Tu+H385MZf13ofc44Nq0sDowpgbDJZRE+uxJOLXVBB/uMcBUWyEEG"
"YCjoKyGBYjJoaDWc9a6DPQRB5JzK8O9eHI1z2KIyb2PgkEp4wHTu0poGuB7ahF7shkHlc+Hn"
"9ARBXmsMzcHHIlkQE+SKi4ENcGGFAKAOh3REqUsAuKhQcIOp6S2mqHf2tseDQ51V+fdxZG8+"
"dsd9guK2TB0LAxAAF9fU0C6urIAz3iWT41cUxfQuWY+JffLmzpFxwoRJJk/PRRb/0XkBPx4a"
"JcfCTJs2g6lgEdU3aM6YWmvxYSASb7sm4beB0B4M1NROITMAJAQ8nq3rALUG0MdIB4MMIbhV"
"B8BHyQSYCiac+A4AN8ELkuLJAniNHZ3qYn1eEzbR+zeXtsEaCruLq2arrEG2U316uMYAgAdZ"
"wF2tvU9+GoqDfqPQ28aE6YV1AIwiA3QlINaN64BX56dQmDVU28oO0viHxpZUADhMir9Iwwyr"
"kw9NrHTv78YQMCCPFTpTP8xqUhTR/g1xbFZV7BxfCTWtLdE0gwVaESzDa+dFxOLaVP51EOnt"
"jJjA1hjkmBddCJxh+azRl68Zyqwmbl1Hxv8GNHw9xDIziFvthMsGA1ylILxOENzc2lwVhe5T"
"DD486kYA9FIAEEDc2d1aTW5JI624gOrapVWOiPIqmXRzZREMaJp5rdinWBH79NOmz6TjLrD4"
"r4+M0c8LmGsxx93D5FSrqkoF+7bNOQ/PmyPxbne1WVR7MOhvGUDm/hUAZAp40Xca4HsG2Gmk"
"gkcMAJwBkgmAZAIAD1TzSSkK7enTFsE5RAhaI7SkNVYSAGe8+Xs0AYA0WAxhCPAiANx1AES7"
"UwSuxfE1E9CHqn9qIRsM+Q4AgcNbMwRMZwrWCCdlK9n4UqT0EjhKABycWA4XlztjrmtJNGJq"
"2I+GdyMA+pEBuvJao6vlQ5R/M5zzqo0pTYugEUHRI78tOpDq69pYYO+c2jjvL8vGG+FZeF/0"
"LZ8Hbnzf0Hw26EMmGVcuJ+J390NcYCN6bwMav65qhXcpuB5DUj0FgBubGpPhWqp0UFYHKQBE"
"9FIhQAFgTxvEb2qoABC7sqp2SRjAp2TSdf/CaFU98zyxTy2m7GKv+fPmWXx/XsB/BICuXbua"
"5nl4mOZ6zDc1adxA7xtULesw3G+BlAduqXjSjxpgEEUgAfBoLMdkPQ00A0BNBvn+rQhUaeBu"
"XQR+YiqYIAtAztL4l6ElxyshKD2HBQBh4/tgJQ0YSgAEl7CGXzYTjk3owf+7pTpmfH6y0cgC"
"5qkw8CJmLhIeBePMxhnox9g9sSDpl+8ZTQD8TEZYPbg1tcI8xCx3QaRHNXp+GRwaV1IHwKTy"
"BEB9rPqlEloQLAMJgB5MQ/uSCboIlVfIiXMBbRHNMLCgQwnU5u3rnNEK9fk41rkQRRnVeShV"
"v29DzGjtgE5MJXsTHIMJoAEEwBTqmTsHh9LgDBVBkg04q/gvIlAY4BqFYLxZCO7vwFS1K4Vg"
"d6UBnkT0UrOEd/e2ZQhohCtr6wgAELe8AnVMydQLXgVRpXj6YWKfxo1cbDxorwXz5ysN928D"
"QB6/DwHqnED3uaauXTqpFcIlCqXvmHSlQQqe9KTh+9BhB3AM0df+CQDMWcBvnno5+KWxUsjs"
"/W936ZVAof/P9P7EKFUHQNKV7wAgGcF7nPaZAj/exHUEwBoHK/iSAfYNaE0NcEt1yvj8dAve"
"31qOd9fIAlfn48X5ufhybzUu7l2AAfTeqfZWGMn3jCnIdFAA0K8J3vC1Z7zr4jQp+/iMCjgy"
"qTSOTS3HEODIENAQgSOrozW9+xeKt54EwEAasCfBNLZKPlwM7YjweaR6LxesHFAZHm1KY9OE"
"uhRnHXDCpz4mNrZH059sMbZRefSxz4A+/AwjyACD+P45dYri3tFROgDWNlYAuLhG2uKK9zfA"
"DaaCt3a0ope3ZxbQWYlA0QBmAEgaeO+Aq5rYuhLshLiV1RC7vII6Qu/kPPuUgrnspPCfqUvn"
"jlZiLznY678OAW5ubt8OJOzTp7dKBTOlt6r36HidV3jeA6n3eqfhkegAAcBofe3f0zk69T/z"
"/mM20DwhpNYKUPzJ8XFMIdVEkMwDMANAsgBAqP8ekj9fUQCIWbMIPoyfoYz/q4tbYRlF4Lbu"
"DZCaFE/v36u6a0vPfTl/5911T7yMnY/Pd1Yh/thSDMlugRn2FhjL90wsZIehjMdrejfG89gF"
"OEexd25ZfZyY7YijzALCZ1VE2IzKuLymKdZQ7LUhAwzKSwbILDUEPvK97o0dcCmkPU7Mr0Ng"
"NsDFoBZ4crg7ohnvZ7YpjkbpLdGtaE5E+HWk4Uajd9Gf0J/vH1fABkPJIAsblsKD4yMZAprR"
"45shdjU1wConFQLUmgDx/l3i/R1xn97/MOxnXqeXDgBZEXTUTdUBpBB0lWngpdXVEONbnilg"
"KeyenO9VBjsrOaY2U58+fb5GJuFRAAAgAElEQVQdICki/t8qBad96xKmp4EtWrQwjRkzxjRy"
"5EhT7959eCELyQQqxGyuGo/fuyP5bu8UPB5EAAzT9NW/U/Q00DwXoErBgcaE0CZ9tlBWC31k"
"IvE5ggA4rVcCk+KMEHCd8f2OAYDfcf1AMLxI4avF+4tYwis31Xjjskj+dEX11Pn8dLtqtPT+"
"5nKCYAl+v7QYn26vwp3TyzEifzrMyMf0i++ZWdgGYwmk1V2c8PjUDJxf1QIxKxohcn5VgqAi"
"IuZWwdE50q20BZb1qqQAIOLv5+9EYPAwJyr4FghjrD+3rCFiVrbEgk5l0JIe78JbOb5WEdw/"
"PBT39nXFCT9XdMuVDoMYvsblt8ZIXme+iwNu7x9A47WiCG1C76+na4AgZ2NRCMXfd3UAFf8F"
"ALIiiMNcCLq9o5lkAdrlwOoEcvmUK8tKImhE3nixC7O9jH369DWNGDHCNG7cOFPjxo3/vTTw"
"nx0fbz7xOp2tOtG78KZFZSLwpjszgV7Jarfwo5GaXgcwr/834r/y/u8mg97sMABwnABg7P8i"
"RaBoSDt6CQEQAJABUlUoeIkHMQewgBTuW8wS3oUIAGYE/tUL4vPvMUh8cUgHwP1QhoFVCgDS"
"hOHj7UA8vrAW45l2zeDrBQQeha0xmaHEt2UFPAifgovBrrgQ0AynvWohkmLw1OJaOOFRkzG8"
"NaY3d1AA6JvbEl0ZAtx+ErGXEaf8WuLkImdELKyDU0saYXCVPGhmEo1gid7UCadX98C1rV0Q"
"HdAaF7f0Rfc8GTGU751A/TGIKehS14p4enoUU80GNGAzxK2Rxaq6Dri6XqaFm39XCOqsDG6e"
"DRQAyJIwMwNc31hfuxpcQ6abk+P9S8L955wRYhdba+WgshXg28HT/9Hx8WYAyEoSnUL0Pebp"
"7Sz1vkGjimzEGzck3O7NVHAIATCKmYC5EGSEALUELNAoAW/+I/5L6fjjCd37E0j/iRf0EJB0"
"mWngDXXmQOK783x+G79dPQrPAlZYXsQEr8JWWJzfBJ+KufDuySkkvTmOj4934MM9HQDvri9V"
"3Tjfx6/BixtbMKNMLsym988uQO/je6eTSXyblsPDk7NweV1nxAW1wpkluhaQx1Ne9ajgW6Bn"
"6exoR/XeLYsFetCwLS1NWNG/GlV7UxyYStr1b4ShVfMq449imtmD9D6mQl7cOzwS5wPb4sWp"
"Idg7vxXcKPxG57bASGqJEfzdM6vnwbgaBckk1XFnR2vV4+hKiAvZwEWvBJo1wF5X3A/rZswG"
"9sbTqIH6XICsCVQAaErBWF+7FlITZ5aWT7q1shSGtsy6UexiZ2ORXg4dF4c1TqL/7wDwdwxg"
"ZympYNa+7XJ74nVXpoL9kvDUYAAFgCn69q/fviv+fFsQsvkPAHwK170/gYb+GqfXAJKv6oUg"
"vENq6u98/IiX9y9iob01AgiAJTSkZ34xph2eX9mneuh+ebYbXx5vwIdbK9U5PO/il+PjHYaE"
"R/vgUakg5hAAHgUtMI8AmEo69mlUGo/PzMPVjW4qnkf7N8D5lQ0R6VWf8bgpds9whjPFYgd6"
"fo/c1mjFWzTVpSjiglvj4NQqOO1ZG1vH10BLxvtfqC368HUDskrGYIfwFT1J8X0RPLw2+hfJ"
"iiE5bPBrLhNGMo0dkskSvUSE9qlOD+/O+O+iqpGXQyQDaEAGaIjrm6QS2FIHAOlfbRGjCHx6"
"ur/OABSFkgXoDOCiXQuVHcsVkm4HlEbr6pk8xS4EgN2fygDfAGCgydbGQu8bVCPLaDzugOR7"
"fVP0jiGjNTwxtoB9Y4DluvoXAKjl4sIAFIDvmft/ovj7wtifSON/pecn0fhJ16kBbiE6eAEu"
"bfTEo3PbsWNwZ3jTe0LKpcPyYmSCcpkwj7R+J5KaIikGr6+H4M3NILyT5ks3/NVRbS9i/fHm"
"zk4sciqBmdkEAJZwpxicTEPNpwfeOzETVzZ2p1Fdcc63kRJ00X5NSMWt0adcLrSSEnAeGzU7"
"OKFOIVygVx+nPjg4yRGn5ldHyNBKanp5eD4r9MtpiSH5rAkGCwzIZ4feeWzRv1AWxG0cAO8O"
"zASoHcYVycAMoBAifBnXw3qT+qUO4EI9oTOAAODaxkZkgGaKAcwhQGr/+j7BPooJHobpaeAt"
"MsD1TS7a1dBaTGcdU64uL4VqDulGm9RmUGUf826wPw8AZjqxtrJQqaCDvV1X7UarNO1hb4q/"
"gTT8KI4J+k5gxQCSBSwzqn+hRgVwmx7/P8g0sOH9iaT+rzQ+Y76WxAxAu4dru1cifM5wbO3e"
"FEFV82Nt2UzwzcMQQCG1JIc15vOmrnN1wueXx6F95rU+7aXXryb9+6oaQPLzzUhmiFnoUhaz"
"6IEeRWwxt5AVJtET5zjmpQh0x82dvXF9czfc2NiBoz3OrWyFsbXt0Ype2jmDBdpS9c9vX4JC"
"rxmOzaqCQ+PL4sC4UgibWh5H5tREzwIZVGGpe0YLuPG1PdNboC/j/eI2pXBzd19c29wRsWvb"
"I3xpG5wL7II7B/oifntHnPOXNYkuZJs6zCIEAPV1799izAPIlPDutvq6ADUf0A2PI3rqhaDD"
"XQiOdhSK0qamIXWEzCVU1KKXlEizz2nd1aTawZhUP6Dv7P/nAsCglkxZMlg0fH6y0Vs87YO0"
"+wM0aRilfQPA7B9mAY1JIKH/bwCQ+M/Ynyjef0MBQFUBU2/z179VRSDJAtJSH+HdozOM25uZ"
"O89D+NQ+2NOrIQKq5YevM9VvnybYNcNNHeD8+V4Aru6dijOBv2LDyHYYxdg8I5cFptHwUzkm"
"SzwmI2yb3BIXQnsgYmlr7JvdEJ5tHdAhs073/XNaYUpde+ydWR8XljfA4UnlcWBsKez7tRj2"
"jy2KQxNLMGOojINz6mB+i2IYVzU3pjkVgJ9beRxd3IJKvgvO+jXAGV8XxKxqSIpvzs/dlBmH"
"3s8wjp6vSsABBICaCZTtXY3URFA8ASDzALd3CQBc9QWihzuTBdzUUvcHB2VXUDvcEQBsa0jd"
"4KTdWFcVh+cWe5vBzqKh2MXib23/5wNAF4QW0jeo4qUdTnfwvDeS7/RLxZMR1AHjCASzCFys"
"A+DF93MARgbwIYxeyxRQFn1+pfJPMowvICAA5Ni5pA/n8fW9NKOOM3TBfcgJGKQZpPF7OZHs"
"92tbcWm7OyJX/src3h+JjwNxyLM3821HeDUsi2UNS8OzViEsqJIPc8rnxIRiWfBroYzM69Nh"
"mEMODC6WDYPyZcTggpkw16UQ1g6qikMeDZmXt8Y5ikIx/IFfHbB3ZGGOAgRBfhyaUASHpwgI"
"KuECjXpueWNcWNNcFXdi/J1xYl4VRC2phXN+tQkEikvf2qrL6fkAZ8QG1uVr6yBWTkIJcEJc"
"oL4oRIpAAgAJATIPIGFA7RHYJxNCHRUAHh1zU3MDeghopt3c0gCX1jml3tlcDRsmFr4j9qBO"
"y/Sj8f9UAJiFhZ2eChbbsaRSFF73ZSrYP1m2i2uPxms6A8zRq4CqEOSvt4sxrwt8u4cAMDTA"
"Nwa4RuMbLJAqcwF3VakXaTfU/8kZOUnSlPL1aSS+jEDCi6Oqt/7XV/ugfdwP7d0OhoBV6jze"
"L/f8kPTbWnx+Eop3d0KpD0Lw4nIA7hydiivbhzA298PFDb1wPqgLFXtnGqM9KdgVV9a1ZQbQ"
"BGe9nXB0uiM9vwzCJpbEvlG68feOyIP90otoUgEcmUYmmOKg2ODYjLI4Pqscjs4qi/C5FXBy"
"YUWOCkwrHanQK6uFoOf8q+HssqpkgBoEAQ0f5MTfS/peY14PoK8Mur6xMeJlSnhbC1UQkrr/"
"vf3t8OBoZ7Ur+N7+Dmoy6OaWJtrNzWSS4FrJD7ZUw6IB+aPEHv8oBfxLAGCkgnl9JpTchnf9"
"mAoOSlLbxR9P1NREkADg6XxjSZivUQ0MNFYNyzzAIQMAMboGUPn/jW8hQEu5qSqC2tdraqQl"
"XlGnZMlBiSkfT0NOxJBTNT8+3oK3t6SJki/eXvPG2ytyNrE7VfNUPDk1BU9PTVbTw4/Dx+P6"
"1p9xc1cvxtpuuBTqSu9rhfP+jXHGh3n9vBo4NrsKjs6oiLBpFXB8enmETS7FuF8UB8cXwsFx"
"BZTxD47PgyNT8+PotMI0ejEOBwKgBPVKKUR4lCYrlFI/C59TEicXlFFLwmVT6JmlFfWVwbIk"
"PLAWDUcABNRW5yLKuChACKqrg4DhQLGA7BaWquDe1rh/uKNignt726np4PhNjRQALgTVSnq0"
"tRp+7ZBLTgXJp6eA/wMAMBVUm0V/6VRgKd72RcLdIUl4NsYAwHR9EYjaFWReDrbC2BwSolcC"
"v6WBZ3QWkCxAAJBiaAAZAgKGBu1rvDokSY5Kk1Mzv74Ok8OUkfBcnwf4/Hg9PjH2v49fgvfX"
"ZavYQry/Ng+vLs4hGKap83rv7u/P2OzG1K8r4tZ2oPpvS7puijPe9XFqYW2cXFQTUYtr0XBV"
"cGIWAUCvPja9NJmABqahj9Dghyfb0/j0/qkFcXhqYRyZThDMLooTc4rqj+4cs+V5MbUrSLaF"
"nfIsLXm62hl0xrei2hso28Nld3AsDX9hRXU14mRNgByRRyaQ6eB4CQWyPGxnKxq9DQHQAQ8P"
"k/73CP031wGwqb4wQNJDAsDV6Sc/kxwL8z8AgMkIAZJrZm9RN9tUmQ9IejgiBc/GQ3syWdPb"
"wMw1JoKWGqVgY9+gzAaaS8HfA0BSwG8AuKOPlFvqdBIt6SYZ4DrDQJwCQNKbY+pI1YQXu/Dp"
"8UZ8vL9WHcD87oYvXsYuxIvzHvjtzEzl+Q/p+Y8jxtD73RAT6Iob27tTOHWiAVqqYs65pfUR"
"49uAhqqDA5MrMtUjC8ysSMNT0E0vS0OS2mXf4ALSu0cpHJ5enFTvgCivMkwby5HqHRAxvxj/"
"ryjpvwjC3TnmyLYwfWNolHdpnFsmO4Md1daw83IG0poaal/AhVV8ZEi4sLw6YvkoLHBVVgXJ"
"jODmpmqRqGxvF9EnDCAAEEa4ubWprAdQDHB5Y92Uu5uronbpDLOEAWysLTIYAPjLNID+MysL"
"aRyVu2ThdINxuzPSnoxIEwDo3ULcjWZQi40VwYHGnsC13xWCDv8BgESDAZQOiNeNn0YNkHJH"
"1QR0AOg6IEXOJXp7Qh2onPBijwLApwdr8e6W9N5dja/PQpkGBiHxiZxWuhRf7vvj9cXZpH03"
"rBvrgp657eDRsgSubuqIaNJ/9IqmGFoxJ3rYZ8Da4dVVODjr48TQQLHmX4fMUFXtHjru4Yij"
"HFHelXFsriPWDiiKNb0L46h7KRq+uDL8CffCZAAOPo+cXxxRniVxZokApTw9X9rDVKEQrIbY"
"INI+GUAE4LcQIEvEqQVkVZCsCIqXBaJb5Vg9MwA6MAR0wF2mh7d2tFCbXeMpAq9vddYuBVVG"
"oZw2UgMowhRQDogUa/81DGB8yVMJAQWzZbbs8Xt0m894Nhxpj8dq+o7hBXoLGPOmECkAyZbx"
"18ZycHMaqApBUgaOVev7FADMDGAsCVMM8PWG0gDqfCJhgLfhFH/H1F7BL0824d1taRsTgm1T"
"OmONmzOOLvkFQQN5Ew/OwRGvvgjz7oEnx4fjXFBXTKxdFF3SWWD7tIa4v7MLNoyvg/4lc6FX"
"TlsKQlcaqzHWj66KVX3KI2iQIy5S2QcNLIfQ0TWwomcFrBtSAaPLZcOGUdWxvGcZMkI5Gt9B"
"bQY9QQY4Id4/ryjDClnCuxSFXxl6vSONXpV0XV15f2xgTSUCZWvYpaA6OvUH66uDFQA2NVEA"
"uCn9Amjse/vaqh3BDw931kWg7CDaIe1hGmpy4EbE0vKfM6ezkKXgZWghOSzazgDBXwIA+Ud+"
"kJGpoAMfO17a0+g3vBqB5Idj0vBiFjTpFCb9f6RRlPQJVNvFd+qbQd7u06uAH5kCfj5rFILi"
"fmCAuwYA7qjCkPb1KlIpANX5RHIu4duT6jj1L8/3IOHZFryJX41UppeRfiMxlH/OnZMBcK9U"
"AguqkobXTkNn/uz0ip44tbIbQsc1wWSmhcNLZseVLd3h168alvWogvbWJsTv6IVF7UtgaIW8"
"OODRHC35viPzmmJQiewY75gbOybVx/65jTCmWGYMz2eDZR1I+x5VKRxLUDiKICT9zy2KyAXF"
"cdqzBON+abJMORq9InVHNcSFSGuYmqpDSFwQPV7a4oY4G4Y3tonLfMCmxmrEk+p1ADALCGMW"
"cKQz7stuZ+kltLsFrm1pmPZwnwu2zi71jHbobmVpUUXCAEcmw0Z/binYDAA+CP3/ZGNjKU2E"
"2h4JdrqJt8Px9cGvKfh9NrQX3prq/6OML56/7Y/y74djHKT+T1H0flJ/QpxRCbysG18xwF0j"
"BAj9X4eWKOo/1hCBfwBAdgZ9ebZVtVL9+nwbbuxfgBlZTGqX0ZZfmmN1swqQzaQjclji+IIu"
"uLhtCD3ZBceXdUJXOxNmNHRAmE97BA+prXYPXdvSA+E+LeHVuRKZoT6G57XGYY8WCFvYHO5O"
"+dA/qwVW9qiAQx6NENTXET//lI4hoDbCZ5cmAIrT+4sjUvoZLywha/To/aWZ9lVgvCcAgqsS"
"ANW/ASA28Lvt4aH6WgC9DtBUxf8bUhTapoeA+wdc8fColJC7qkWhd/e316T30bWtjVOe7HfB"
"qrHFb9IOna2tLWRHcGFaKRsfbf9KAKjOoensrGT7cGPPSeVO4N0QJNwbnaz6Brzw0lQPwNch"
"f1v7/0Cv/0jaZxqHz4bx6dlIvPJPRKCUhpkGEiBpXy4YDHBG7QtMeHlYnZCV+HIXPj5Yj+SX"
"OxG9YRrG8M+5e3w5Ars3xswCP+Hlna3oaWHCtpHNcHX3cCxwdcSLc2MwsWo+jHTIhWcnR8Gn"
"iyOa8n1xa7thVoviaGNrje0zm6CjSVYPVceCTuVwaEELzGtWHKt6VsGidqWwYUwNbPyVuf1S"
"J4SpbKEkwmZIxuDA+F8SUT4Uf77lFP3HBVZWIeBCYDWcX11NbxIlDCC7g0MNAGxo+EchSGoA"
"O1rpdQDm/A+kZcyxrqoS+PBIN2khoz3Y3xrXtjdJfnbQBeO65A+nHVra2VjW5mMx2ifnj2Hg"
"zwSApQGAHFScsmKkXrVymedpD5kJ3BuZgufTGAIWaXq7mCC9D4ACQBgBEEnPP6sb/wu9PoFe"
"T3EH5vnmiaC/TQNJ/7JEjABI/SJH051Fynvd+5PfhfH5IXx4tAXv7m9UJ3A9v7wWj06uxOMz"
"Abi8ex7OrR6PW8e8GLcbYc/M9jjs1QleHaqoQtBRr/Y0qiuu7+iNZd0rY2GLktg22QXbJtTB"
"XBp6+xQXhA6uim3ja/O9zggZUhnHPRtRxDXHKZ8GCPesh7N+9ZhF1KLar4SohXoj66iFZdWO"
"4FOeZaj+yykGOL+qEsOACMCqRm8AvUuY9AcQBrgk8V+qgebpYFUKboPbe/WNoqoSeKK7mgx6"
"JEvCDnXSHh5sy8/eJEXOWypbKP0CcUQK85p8dKCVcpn0k17+GgAIugyUFbe1tazLxw6r3Kuc"
"xcfR+HxnUhLeeSPt5XJNk00gatOoAOCYYXx6/Rcannk9Eml0Cjw11FzAd5XA1Hg1NaxRHGqJ"
"cep4utTPUepEbSSdRnyYD86um8bXyOlaB5D0ci8zgN1IfLYLSc/IDE+3IvH5TryM88Hzc9Px"
"OHIibu8fQk8aiRs7++HugYG4s38gLgR1JPW7Ma72ole2Y24uRRZXXJHzCVc1wYWVjZguNsDF"
"1Y1xxL0WTnvXpdfXZVrnjOjl9QioYjg4uxr2TilPoJXA2oEOOLukMkVgGb0xBFkg2l/6A1am"
"90uLuOrfmkTFSSUwoPa3DEAtCd+sTweryaC9+mTQgyNd8Chc3yf4IMxNe3qsE65sbZ70KqwZ"
"ZvUtKh3BO9laW8q5AJVpFznmxcwAf00IMOJLVo4iHJUsLS2aZLCzGHxme/PH+DQLXx54JuPd"
"KmhvQqC92qzh3T497pPC8YWGT6DHJ1w3vD9eH98AcMMAwA19feDXOALgPON/FNI+k/pfHOJr"
"I3GLAPBrVRPXDizCmeDJuHnUGy/IAK+vkwXOLsPzC354edkfz2MW4M6BEbgfNppjOI0+iOKv"
"D8KXtUcEx909PUjRrWmoJjjPlDAuoBkOzqyJPVOqIXx+LYQvdMKBGdUR5l4d7s0KYnmv8ojw"
"rIvVfcsiZKgjFruWwuK2pTC7QWF4NC8O98ZFeK3aqgJ4alEZ1R7mnG8F1SEsZkVlvQ6wujqf"
"EwiqCFRDLwKtqaPvDJIl4WYA7HP9ti/g4YkemiwKfXr8Z1zb1S751dG22Dy70mM7a4shvP/N"
"aQehf0fDJln/Ug1g0hWmKM38HKX441r8EC2yZLQaGbWt7WMkeSPh6YrktFehmnQA0xj/tQ9R"
"msY0Dl8Y879cNQBgGF8xQLwxG3hD934FgMsEgByVLidmn1I9g6UCKM2kHp3zx8ah7bB1TE+E"
"LRoOP9eaeB2/HneOLcLiVtWxfmQ7rB3WCuF+/bFpXFOcWNoD2yc2w4ZfG2BJp8pY92tDrBlU"
"G+t/dYIv07sra1uT7qshYGBFzG5WDAs7lMSCdsXh0aoYPFoUwZzmhakBimJG/cJwb1ocE2rm"
"xYTqBbC0Q2n4di6D0F8qY8voytg7tToNXksZXzWH9CpNPVBOVQLPEgTn/CqrPkHR/lJfoCbw"
"r4bYlTV1AITUMwBgaIDdbWRpuPaIAPjtVG9hAO3W/q7JH6K6YYtHjccZ01mO4n1vRYM40w5V"
"OUqb/gdZwLcwwJGNPyrMx/K8fh1rK8uWdnaWg4Lmu1zAZy8abEta0u/7U1M/RGiq2POF3vzp"
"gqZ9Oq+pMKAY4Lo+vk0HX1exH6mSEl4kAGIoAKN4LTk79wSS1alkckzqDtyPWkkgBOLWcT/s"
"n9NX1RduHZ6NwAHNsX5Ue6xwa4iVPetiTt0SWNG5NnzaVEfk8t7wca2M1QOcMbNRKcxt74gh"
"VQri6KKG2PRrVYyonBdzmxSjMCyLuU1J73PqwbN1MSzvUQ7+bqWxdlAFhA5xxMZhjjgwswa1"
"QF1E+TIkLK/NkFAD0b6kf096/8LSqlqoBtngtBx541UeZ3wcGSIqMYwQCMuqqCqgFILUPEAI"
"GUBfFKLd3NZSu00APNgvu4M6arcPu6W+iOqX9i6qJ+YNc7xgZ2PxC9O+VpYWJmkDWk1swCG2"
"yGb6i+sAZhaQRQdSdszFnxdTILAw1ba1sWrG513aNy4c/OT8+A/APvFgLfF1dErq+7NpagUQ"
"PVpSQO1LnKYlXCY4LhlTwleNJWHX9F3CybGk/zMEwEkCIBwp744SAAfIAjvxleo/6fVepH48"
"wjCwAM8vBePzg3V4fdUPv19ahkdRC/Hg5EJc3fErzgT0QXRwP5z07467h4bhyMI2FHZNsX9W"
"E+yf3RA7pzqrBZ4nvV2w390ZYfPqYu+06jixUGJ9XZzyJnC8qjH+V0HEAkeKuyr06or83hFn"
"llD8LSnP52VxcnEZRC4sxTSwFE4tJgA41HOCIXIex3zpGCIgIBMsIwB8mRksr6G6l15cU0e7"
"HFJfk3UBtygE7+5shRvbW6Zd3dw85eEhV+1TbF/EbO3wvkmtfMFyf22sLVvSHM6G8aWdW1GT"
"Lv4yGLb5SyuB6lte1Jo/y2iAQD5AOaYI1W1tLGUdcsssGa1HzBpd9+j7u0sTgZNq9+/XV+Ep"
"X1+Hp6o6gNoIEqcqgVpirEa612R3MFLIDqlSF4jhz08z9ofT0Mep+sOU0QUACc+36/sBJAV8"
"vR2fHoTg/c1V6kCmt7JBhOP1lUV4cnIcxxiKv+G4d3gglXN3Umt33NzRFdfWt1HHzsYFNCJt"
"O9OotSj4nBDtV5P0XB1nfarQkOUJACr7RUz1ZhfFMfciODqrCMJmSSPoogSEA077SNpXkiAo"
"qfL/04tL0tAl1IiQo+7cSyKcI4IgOLWwHIEhwKkkQNJi/KtpogGuBNXBNekaup6CM6RB6qX1"
"jVMe7G+Lt5FdcHWXa+LoXhWOZspgPZL3tRWN35T3W2K+FH7KG/dejJ/xR+r/ywAgF+TPZdWp"
"jZWV6h6Wk88LcUgcqkgmcLaysmzC521z50g3YfroBoefXFr8AWnUA9ppaB8jtYRX4clf30Wm"
"alIOTonVu4GlXFJDSyE7JJ3T0hJOajoA6P3vDhMAeygEtxEAW9X4/GQd3sb7q51B72/qU8Kv"
"Ly2k+p+PZ+dmqjX4t/b04ehFj3JD/I5uuLSuHWICmpK2XSjYnGnA2hw1aMRqpO9KNFxFGr6C"
"8mip5kUtKcHnxRAxvxCOuxegIe3V88gFhfi6wqT2IqT5onxelB5fTM0DRHgUU0WhiLkOBEAJ"
"nJhTUjsxp5QW4VFGi+K1hQHO+1VF3MrqSgPErKiVGr3KKfnKugbakz0t8Pxwe5wMbvZhxM9l"
"j+TImk4OfmhrZWXRlGrfRbyepqho0mN+Ibn3tEdGDpt/ZPw/DQDff8kuE2k/lilTJiUKbWxs"
"ZBpS4k9+gqA4H8vyd1ZNZ2tdn98LI7TOmN56uFv7SuvCto65/fXV5lTglKrUaYlRWuK7UykJ"
"70+npHyJTvvWFk67oFI+LYH0/+EIkt4e0L6+2qUlPNukfX4qp22H4sP9AHy8t8LoFLYIby8v"
"wKtLMhXsgefR06n6+3D0JABkLUA3XN/aAVc3tcXFdc2ZijWgEpd0zokeKQ2kmc97VVR9faN8"
"yhAcpQiA4gRHYQLAHifm5sGx2bkQ7pGHAMhLus9PoxfASU97gqAgTi4qRMPLFHER7djMItqJ"
"WcU0AUAkWeCkh2zdIgMwDJxmGDjp6ZgWucgx5ZRX5RTqAO3Oemc82d0EVzY2SQ2aUeN2a+cC"
"69LbWY3gfWvD+9fEzsaqIdlV8vxKNL5s2ZJ7LCI8m3HvrQ2H/Ef2/3MZwHwx2XUyfvx4U65c"
"uSx0TFjZ8f9kNkry0IIcDjoQLKqmT2dTz8LCUtasiUZwK1Io28yRg5rsOrFv1v2EV7tSgPPQ"
"pDkkDZ+WdEFL/HQ2OUA1UD8AAAmLSURBVOFjZPLXDydSUz4d09I+Hkbah/1Ie7cbya8kx9+A"
"L08C8eGuH97d9KbnL9DeXPbQXsXN0V5emKm9OD9De3JqrHZzF71+Zzd6fydc3+KKaxvbkAFa"
"IHYt076V9ZTxz/nXYAioqmJzlGH8KG+ZyStO76eH+9gzBOTFCY+c2om52bXw+Tm1yIV5tEjP"
"fNopr/zaaW8CgOPkooL0eGkRVxiRc8gI7mQAOe52toN2dGaJ1EPTS6QcmVEyJWJuGe38koqI"
"D6yO2+ucELPaKSVwSqX7PVoU3FUgd/qZvD/S3Lc5b3fjdLZWLrx/tYRVOcoZeb69cY8z836L"
"4LOyt7e3kC18/xMAmB+lY4jsP5s1a5bJyclJfii/xZpASMeRxaTHpYIGWkvzbZXS2Vk72dpY"
"u/D7Rvy+hfyxBfJlm9qja/11wavGnb91df3r1ORoDZBlYbJDSNYMHqf370n79Gxz8ofHG5Lf"
"PVyX8v7BmtT39/y0D3d88PHWYny8MR8fr7nj/eXZeB03Ha9ipzF1GsV8uhtHV8QTANc2t8PV"
"Da2U98cGN0JsYH3ErHJS6l3auMcsl+VbTNd8Sf1LSihaP7OkIAFBT/fMy5GTnp6dLJEDZ7xz"
"8//yEjj5cHZZAQWAEx4FtLDp9qkHpxZKOTilcPLhqUWSj84oliZH3kZTCF5aVh6XmQqeXVpJ"
"2z67wuvZ/Yufb10n97rc2e2m8j50N+5HI8b4hna2Vs783izwyvC5g3Ev5Z7KvVVeT1tY1qpV"
"y2L+/PmmsWPH/o2x/3IAjBo1yuTu7m6aPn26ydPT0zR48GBToUKFFBsY2iA96SmLVA35fQGT"
"XqQQBJejPiAr2DrZ2FhLGiPM0JTDlankoNKlC7v3+Lnpet8lo6JOhy979PLh1gRpG4+0MI4D"
"FI271FF0X58y9t/20V5fW5j6Im5OyrPo6clPz05NfnR6UsrjU+NS7ob9knp1a6e069s7p13b"
"7KpdWd9au7y+JS6GNqPQaoy4YBdcWFNXLc6IDaihKnXRKyRfL4uopQSATxF6uL0W4ZkvLXxR"
"nrRwz+ypEV7ZUiJ8cnDkSjnhmTc50idfykmv/KknFxXQTi20R7RnEcR6F8dFbwcOsohnSaaS"
"JRJWjS76aFyXAlEtamZfXzR/enemcDJ962owYiNrK4sGdraWzvx5DcPbpcxekvdOBF4Bw+PN"
"hpdYr5S+hGJ6vylnzpymLFmy/LkMYD4zyLw17EcADBs2zOTh4aEAMG3aNPVcACH9BPLmzfsN"
"CCa9Li3FiWz8Pg/fLhRW1ABDWYKhcrp0trU4nPlBXb4DRFuOnj9lyfhrpQrFFnbpUDd05sQu"
"R9etGnbl9MEZv92NWfDpza1laV8f+EJ74gs8WQrtgTdS7s7H11vueBM9Gg/3d1Pjzg5Z+98a"
"V0Kb0/hNtLi1jbSLaxtol9bV1y6F1tEuBtfUYoOrajGrHbXo5WXJCKXICMUQ41sQF/wLIHZF"
"PlxckRNXVufA9TW5cC0gD66uzI+L/mQAMsRxj/xpO6fm+7RmZL7fZvfIfWVA8+xHG1fJHFqq"
"YLqFmdJbygHOcoBTO+PvEvZrYGdjWZ/DiRQvni5VvDLK6PqEjnh7HpOuqzIZ9/Cb4f+hlf8v"
"XwKUfxsA/4oBZLewGH3mzJlqH7oAQZ7LVnL5ufQYdnBwkHRRhQaTXp4UBGfmJbIbYBB0SwFD"
"agmCuHLW1lZVBBDp09nV5XPZ7mwGhWQV0vVQ9sD3zpjBbmQh+xzTa1Qu6t2uWcXg/l1r75w5"
"utlxr6ltYoI9O1/fsazj/V1eTZ8d8m3x5sTyph9Pr2ySELWq0dezAQ1TogNc0qJXOadFB9RJ"
"O7eqRtrZ5VXTzvhVTDu1tFxaxOKSKUfnF/160N0+YceUPB/Xjcn5ZvWwbM+WDsh0f3a3DNfH"
"tM0QM7BJ+uNta6TfWb+cbXDZgtbeebNaTU9va5I0TfbPy37sVsbnlc/dgJ7tQmM7y4wd1bwY"
"/JuXm/QQWcRwDDG6LOrIbNwrW+Pe/d0qH/OX2Edu8T/zfvn6jxjA0dFRvSlz5symdOnS/V02"
"kDVrVkU9OXLkUEOey/jpp59M2bJlU9SUP39+8y+3MP1RQPoeDJn4ubPyw0uYyGvSBY4ZEMIQ"
"jH8WjjY2BIWdTQ0Cw8nOzkZSTAGGhI8Gxk2WTKOZcePF06RFdneOPhwD09laDs+a2WZMjp9s"
"J+TNkW5K/pzppufLYTc9X3YZtmrkzWYzPR9H7qxWU7JlspyQJb3FGDtr03B5P0df43qdjOu3"
"Mn5fY7ORBaj8U+vbWlvUs7OxqGNrY1GL1C4pWyWTXqkrrf9NFsX5NxWh59tz5OWQv13uAe+F"
"RXoOWw6J71YWf3yZ/tn4/uvH/xObpU+f3pQxY0Zlw9u3b/9phaD/5ssMBjMzmMOEVLEyfwcI"
"8QZJdYQOJd+VsCHeUtIARnkCoRLBUdXOzroGAVKLw4lCsw5FVF3qCYmp9Zg+1TfAIsPFGA3+"
"xXAxv17KrWJYayuTs421hTMNXJfDiaM2R03+vBr/Xw5pFo8pZxja7NnymQXQBfl3MUVWHp7D"
"pE/YZDb+ZjO9f+/pf9rNlq9/iwHMLWImTpxo6t69u6l3796mQYMGCZ2ri5jjiVz0Hw0BilEo"
"+oc1hH/wZQaDmR3kZkh6IwwhRSYzKCRs5DKAIZMeEj4EHHKDi5j+AIh8UDGAGELiqhx8WJ5A"
"qMBRkaCoZIzKfztMavCjV6LRK/J3ikFFhYv3ljWuVcq4toPpDwMXMT6DfBZ7s6E5chlr9MzG"
"lr8lva2trV2GDBls6JnWHFYclhwW4ql/xhBPz5Qpk7KBNPkQ2/Xq1cskXUOeP3+ubJuamvrN"
"3n8HgB+BkJCQoB7lAvIlv0RZ7c9jhB/B8D1DfA8KCRviLWZgSBUqiwEOEZg5DIDkNjxNQooZ"
"KDLsDSOZGeX/NsyvszeGvD8ff19ew7i5lYEtTDmMJVhiZFHpmcyGNj6rrekP77Yy/a2H/+k3"
"0GwTs43EZt/b0GzT78c/BYC8KSkpyfT27Vv1fY8eqlWsQtj3v+x/8PUjKMzA+BEcMoQ5zCAR"
"elVAMYZ4YRZj/PQvhvl1mb97f0bjmmbj2hnjRyObDa2MbZTnLMzZVP/+/U3btm0zrV692hQS"
"EmIKCgoyBQcH/2lDrhcaGmpauXKlKSIiQoX0T58+mRITE7+F9/8nAPx/YoB/98vC9I8B8iNQ"
"zGD5cdj8MP7Ra76/xo/X//H3//0H/MErxUj/yiv/l+P/AOfLCUkdQZ73AAAAAElFTkSuQmCC")
getIconAboutData = IconAbout.GetData
getIconAboutImage = IconAbout.GetImage
getIconAboutBitmap = IconAbout.GetBitmap
#----------------------------------------------------------------------
IconError = PyEmbeddedImage(
"iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAABHNCSVQICAgIfAhkiAAABz5J"
"REFUWIWdl2lsVNcVx39vG3fGNgbvQBBJsA1G2MauscMUCcVVlQ+pGkFFaSs1IUrVqhJrEQQV"
"VRWtWuGIhpAUGin5gJVECfkSVapUtTioaVRaiKFqlVBk7GEW2+NN9jDbmzdv64d5b8Zjj2u3"
"Vzp625n7+99zzl1GYBXtl/B9Ad5aja/bJPjNy3BkJT9hJYdX4AdVtbWvfffUKa/s8y11sG2w"
"LLBtbNMEy8I2TX735pvqWCh0+TSc+r8FnIcfraur+/W3jx71psNh4g8eLIUDtm3n7h3zNjSw"
"dvt2fn/1qhoZG7t4Bs4ux5CW+9APh2vq6y8cPHbMm45EiI+OgiAUDPLXxaMwkkkMVaX96aeV"
"yUCguyeR8AzCn1ctoB+OVtfX9x88dsybCoVIBAIgCAiiiLAI7rZSIsxMhra9e5VoINDTm0za"
"g/DpigJegRO1jY2/+tbRo75kMEjy4UMEB+6OXhCEkrnLv3NSYySTmJpG2549ylgg4PenUplB"
"+NuyAvrhZF1j4y8OHDniSwQCpILBHFQUc7Yw/CVG7YILjzZ6Momp63T4/UokENjzlXQ6dR1u"
"LRHQD6ca1q//+TePHPElRkdJhkK5cDsCymWZjR4PCdPELqYUQWsUhTpF4ZFhYNs2NpBNJrFM"
"k/beXiUcCOz1q+rcIAzlBZyHM40bNvxs/+HDvvjwMKlwOB9qBIFyWaa2oYH0vn2sGxkhmc0W"
"RCwQsM7jobylBb2nhzXhMHHHzwY0R8SO7m4lHAj0PaVpUzfgrgTQB5++dO6cEvv88xzcDbED"
"r6mvZ+7sWfQtW6C+nup790hqWm76Oa26rIyK5mZip0+TbWtDNk3WhsM80rS8TyaZBNuma/du"
"5c6dO9/4GM6JeZgskwyFikZk2zYNQPrZZ7F9PgRBQNu1i8yLL7KxshLRmffVXi/lra3Ez5xB"
"9HgQRRH1mWeoBMokCQuwnH7jU1OIipJnyIvraHFYg7rOY9euQUUF2a4uBEFA7+1FkGU2DgyQ"
"Sqcpb20lefx4bqbYNmI6TdWFCwSzWdILasF2BoVlLSPAcVw4nUxBIBKLsenddxFlmezOnQiC"
"gLFrF6IkUXnjBokTJ0AUEQEhlaLy4kUmQiHiqloEzgspKcBdSp0fYNv5RccyTSLRKJvefx9R"
"UdDb23MiursxurvJ5zGVovz115kYHSWeSBSg/0sEsO38fF8oxLJtIsEgj127higI6B0dhVUR"
"QFXxXbnC+P37xGOxIril61iGgeWmI5stHQHbsoo7dcS41W5aFul4nMqbNzE7O4t8pclJpEyG"
"5Pw82ZkZjHgcM5XCUFVsyypEADDq6pZPQb4G3Ei4BSkIVG/eTEVPD5nnn0cURee1k6amJtTn"
"nuOJcJh/DQ2h63oR1DULilKQT5/t7OlYVk6xExH3ffWTT1Ll95N94QUEWUYURSRdR5qacvTb"
"mJ2d2IcP037wIJLHswRsuc8la8CycuaG1Y0AUN3cTNWePWgHDiBIEqIoImazSG+8gTQxgX7o"
"EGZ7O5ZlYXV1IcoyHT4f/xgYQNe0ApgFhVhKgG3bS8Jf29ZGpd9PZv/+AlzTEC9dYuS994hH"
"IrQpCrKiYLS25mqlrQ3x0CG6Kir47PJlTE0rElAyBZZpUr5hw5LwVzz+OObmzeCeBVQV8coV"
"Rj/4gLmREXRN459vv43x4YdIw8O5rVoQsNavx9fYiLJmTRFcEMWiFEgAX4Oa6WCwY0dfn2ym"
"0+jxeL4g54eHqfR4kGUZs7oaz8AAo++8w9z9+/lOTcNg6u5d6mtrERsbQZLwfPQRQ6++SnJy"
"sgj+RFMTc4mEPRqLCR/DOQlgEP7QOz9fPz0+3rGjt1c2ZmdRx8bQZ2fRIhFmPvmEtVVVVI2N"
"MXz1KnNffLGkug3DYPL2bTZs2oQ3FGLo/HkS4+P576IksaWlhVgmY90Ih2MifHkQZovOFP1w"
"saGm5odf7+vzTt++TSIUKuRNkvDU1KBOTy+p7oXPkteLWFZGJhYrwGWZLc3NzKRS1l/C4Zks"
"7P4pPMynwG2D8Mfdqlo9EY3u7PD7FSOVQnv0KF+5eir1X+FuOoxMpiBIltnS0kI0kTD/GolM"
"AL0/gfyev+RMOAh/8mcya8ei0c7O3l7FTKfJxOMrgkuZrCg0bd1KOBYz/j4+/lCEp05DdCGv"
"5Kn4OlzflclURycnd+7s7lYMVc2LWC1c8Xho2raNkdlZ47No9MEd+OprMLmYtdz/gvIbMLRd"
"09bNTE7u6OzqkvVMBjWRWB28rIymbdv49/S0cWtqavgt+N5NSJNb5bMLQcudritdOwkvb62o"
"+M6+vXvLBHdptiwsd+VcYO4727K4Ewzqt2dm7v0Wjs/CLJAA4kDM0bmsADcya4AKoOLHcLIW"
"XlrGt2RLw61LcCoB80CK3DWOsx+tJGChkC+5Qpx7j2MKuZXU7cMCDHIhzuY0kACSQGYxeLUC"
"SvmLjjAXLlA8QUwKtbpi+w9DKwnvvVH2bAAAAABJRU5ErkJggg==")
getIconErrorData = IconError.GetData
getIconErrorImage = IconError.GetImage
getIconErrorBitmap = IconError.GetBitmap
#----------------------------------------------------------------------
IconDlg = PyEmbeddedImage(
"iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAYAAACqaXHeAAAAGXRFWHRTb2Z0d2FyZQBBZG9i"
"ZSBJbWFnZVJlYWR5ccllPAAAH2NJREFUeNrUe3uwXGWV79qvfj9On/cjOScvEgIECAl5EBUR"
"FXEkIwx6GadGGcdxasZ7HRjLa9Uw3CmvluWMxVz/GO8wOEpJIcZBGO+gkYGggkAQAoQk5JCc"
"k5z3q9/P3Xv3ft3f+vbucEJiBIpUjV31pTvdvXt/a32/9Vvrt77vSJ7nET+q1Sp961vfIsuy"
"6Hw+bNsW9+Dn9r0lSSJFUUjTNFJVVfz/fD6uu+462r59u3ittt8sl8t0xx13nJrUeXrEYOjK"
"FStWjPTjkcCD7TcMo7m0tJSbm5ubbjab03ivdD4nEY/Hz3QAez0ajZKu6+/4DTOZzKW/j8fu"
"3bs/uGXLlo19vX1d4Uj4tO+YpkmFQqE2Ojp64tFHH33qoYce+veJiYln8NE7DklG2akHrziP"
"6elpisVi7+iNZFkevP322++amprOe8HDxWi1Wh4MPjUMAwPP/H77kc8XzLvuuuvBrq6uze+0"
"A775zW+esvu8OSCT6dy0d+/eF9oGWbbttSzLcxzHc13vjIeLN8ELwiENXfcajQa+63r7n/v1"
"woYNG278nXJAKBQa2rdv30E2jA0G6Ynhns3yNzz4+4yGSrXqLS4ueflC0fvJT/aWu7u733M+"
"HCCfD5K59dZb//Laa6+9DPYSjCbbAeO/yWt5Uq7j+tnCtgQ59/T2pHfv/uid+Dj6Ts/1fDgg"
"eeONN33I5wBJGO7Yjkh9rSD9sVPaKyAMxsDKU6tlEfiAmk0dwwAxtqheb9DExCQNDQ3tDIfD"
"F7zjhHgeHBCJxqJpV6ykw0TIISGM5v/zCNJOsOT+qjuuI5xjw0kmHKHrTarWqjQJ40+eOEGl"
"UikK9k5ztviv7oDqq0dendy+bcda0zRQYNVQ5MgixaqaSrLUBh0ccipEfISwcZyG+ZpypULz"
"8/M0PjZGxWKRTp48kUeNMPu7gADz3nu/e98Nu3//2qVslmZmZkGuUYpEIhQGErSQRoqsiLrD"
"9VwRHkh/ZATG1+t1qtVqlF3ia6eF8cVCgQ4fPvQgnDX1u+AAOnDgwA9vu+2vdm3fcdVnGd5c"
"4oqhaqLklWQf/rz6HPtWi2FvktFsEtIf5XI5OGAJsPeNX1xc2F8ql74mYPO74ABGwcMP/eiv"
"R4+OVrZt2/75eCIZ5jCQYbwsYt9ffZfj3rJ9BBgG1aoVyufzVCoWqI4wqNcxGo0fW459Oy6a"
"Px8TPV8O4EdjdPTV/zkxcfIx1P6fSyZT71MVLSVJLuAv++zv+qsPKUANhj6MtqwWPkMGdOwX"
"bNe9B3nih/gt43xNUj1bnfzb1FhbvQk44zWv4G9iZxj3xPj42Ct4uaMrk761u7v/pgpyOxtq"
"4ToOAQ4FDpGunl68bx6Ym5//JySHJ3HNDGfR8ymM1OUFCBt/yy23UGdnp5jU8s/YUJ4kpzU2"
"OJvNIT9P0UmkKVRs+B25s6srMdjfGR7pTdqrBjrk4b6MPNidlnvSEa8joZrRirI2c6C8jWrl"
"PDVBeEcPvYK410WtgIvpih1X05Y1rXWXrch+qdRQbiuWzWq+bOYX8/rC7FJtZmaxNjm3VJ/K"
"FRuzyCA5DrXlxvD8eK6cTt8WAtjIdDotHOAE+bqdx9no6ekZOnjwEL127JhstfSVw0OZTdfs"
"GLnyyst3br5wZXh9Ri4OhvRsUrLqiHWXlBCcKJlkgtWZvsZDl9NQboRanWkwfp0mT4z5aJNE"
"+UyDgwPUPRjtuOzicIcW1rioBsrCmINCNkiyCZ6oNh1jMW8sjU2VTxx8LffKgcPzL7x6bOFg"
"XTdPhiNx84rNl9O6dWuIlXa779BGND/fd999pznojBBgw9uwROUlWPlXv3qa9u9/DtVZde22"
"LRuu+dsv3PSha9998bZ1qzIrI16e6gtHqTw/SdUcVrbc5ADGpA3S4ipFOldSrHcDFWgDkX0h"
"rY4VyDQ6qJAvID3GsWoh4WRGX09XmiJd6+m4vobWxssk2QVym0XyHKCEfQmsdCS1SF93auTK"
"y1aM/MnHk+8zHJVms0bhuYMzLz/y+MuPP/nMi4+/+NJLh6/YvNnetesq6unpFo5ge9gBfK/l"
"PY+zkiBDiS96+uln6PF9+6RUIrTzs5/Z/clP/dENH7l449ohUuCg6iKVpp+jwuKr1AJbWwZi"
"2vJEJaeEJOq+eDd1XHgzJQe3UKUhUWlqmjoqeYpiZZ2gSkwBbTwhHg70AmfH/l6EnzpAescQ"
"DfZ1kFWfpVbxJWrlD5BjNciGI7wWagcY1PLAQ6EwrRrJdG24+ML3f+pTv/f+mdnCHQ8/8uwT"
"//Ldn9739a//6rEdO3fo77vmvZRKpQSKfysJMhQLyL0PPPADyucWN3zxC5/54uc//+lbevoH"
"4pgN2YZOFgxpLDxHRnGcXBuszWkNBvCIwKiR675C0ZEPU0iDcfjUKS9SOqFRSMmISUgweH56"
"inp7e8X9uC7wIICYFzoyadQLKikSQ1ehWOd6kuJrKNy9jfSTgK+RRVxCxcm4DuFBSowsByFS"
"N0nWPBoa6E/91Rc+eeNf/PnHbvz+v+177M6/u+fr//h/Dv3iD2/5GG3cuPHcDmAYzs7O0cMP"
"P0yXXrLmEz995F+/dtnmK0fIqZKtVzFJkzxbJ6N8hOxmVqQxj4UNVBsbgKWhgS2foNiaj/jf"
"lxC/zO6dGYRTSAgcFjz84Ayyes1qcU9GgCK4RiMV7/f19wEpEYFEx8X3cV8nPEypVTdQcfQe"
"GI6w0RKICcUXE/wswxRJRfjhZc3GtVH6kz/7ow9++OqN77rtS3d/49577/2Hm2++WeffPKsD"
"OD4Y9nv27JF2/967/nrPD+/7+2g8qbhmGUYCOp4jCjGrMUkOjIdwx8Cqs7rDdewIWZVJCncQ"
"nshwuMCRBcPzTTMdGcDQF0PMK+yUWGyTWH02XlFUoR7597oyGaEQ2+KI56VFQlTV4WwYKcma"
"MFhiFOA1IhvzD/kD75Gk4Xo4pdGk7s6u2A++d+ffXfDVB1Z/5RsP/Hc4vra8JXYaAlh6XrS+"
"/6N79nwbxncongkC4hVgBoIpnmtgMWA8/9/j1edhC2UnM2wB52ajDj4whfjh2sDW4QhVESvL"
"RmqsDJEV1qxdI0JBZJqAnLhS5MnVUBSxXuBqkQmLdQTzxtjYOK1LxgQCmBIlJeIbzD8jUKAJ"
"4yUxVHF9y0YmwRf+91c/98npuerM9x74yZ1YbO+sDvA8J/Y3X/zj26KJEcWz8/6qe9y+5mcw"
"aatIrlnCKjUxTDEYBcIBrPQcmfMmVlinWESiVJJTEQjL4oKHWdg3KJFM0QUbNgQtKRIoYJUo"
"GJp8guRmSK1WF+zNTG63bIQDUqsW91deYk2hCsMlIa4UYbQfCrJ43zEbnGHhCPzfVuiOL/35"
"X9z/w7332bZz/AwHsDRNJyN9V1y2dqNfeXIXBysMw4Fx8exaZXJacIClB8PAAAmy4YomgGJX"
"J+FvhIUXFsax+mNpOzc3j4JpkXLZJQF5rjd4ZRkFXBGyGGKOYFWoQjRZgD/L4k2XXEKdmS6g"
"Q6XOONIr3+dUpeoFTpCD/gIj019c12mBp0qikJSlGLE0XzWyonOov3djy7LOdAD/gGV7rXJh"
"Rieq+RUoG8+O8HwH+PnYFJzgr347PDh24SBbpubSYaod+w5lLvgDktMXCA5AWQCFV6D9z/2a"
"HtzzAzo+dozCMIgdIXFoYAUj0QhluntoeGSELrnkUurp7RPGMdO7NlayeZIyUSBC0vwMgOHn"
"cy9wgCrmwYglrHirURLhy+jgOWNFSDdibkPXG7Isn8kBnIMbulU8OX5wZqc5NiIpQ/7qB/Hv"
"30gKXgOyzMRqWNzXNUBWpk+IvAiViSdJX3iZ6iu3UWJwGy7pAsMrFI6i8AkncDVICrdm1Eke"
"flPj+EWsgrlDkbjgj0wKxBn3qD90kuylKcE7jivaR7h3BCEXF/PxsNKMCj8kQuK9VqMs0Cnx"
"/AQqQKLhQTpy4NelQqk6uzwTvKEOkI25uRMzpL9IpsSEFQs86g9JDvtepvaWltImDz8dIs5d"
"wJlTlFkrUPbwwxg/RmGTIc1L0aY4TL82TbMbLyIDvuWihn+Da4E0yK27K4niJ0ErBmuUTJog"
"L4dCVhVwHoYxID+BSFesuNAnHJoBn4nMgCssHWFq1rA4mk/USM1yZIDMSo1efOTvWT8U5GVi"
"7w0OkLzxydoUuRBvLRCYvBXIYAhVBOxFvPEUUJE5LQyEASNECrIA6ye7XhGVmhZLCIS4lkuN"
"Yg48MEvVmkkJSN/13R6FQ1zjawJ6FuLfwYpFLEwc1zeLMNpMkRpJUDiOlIhMI7fyFJJqYsqi"
"HmEnYOUZDexErhL5Nzg9M8m7NvSIliQ1toH04jzNPX47TZyY4Z5C9RyVoEQnZ4xJlFYUtl9C"
"voex8W0khYZh1Dx+2BBMyxNgTc/Qczn8ZFusjIx0JykymVB7ZrFIGgSJGo2J1eBQaYEnShWw"
"O5wgSzpSI36L19mSRbco04nvx1wQokeIBnwHCpV0EOsYxxkMCiO84zDcFiiURTqEJNTz+A3d"
"d4ZwKsIpsgKASFJx7Amae+6fyC1N0GKdeN/RXK72T1eDikQz880Zt+mJlKpYo6QAym7kclKi"
"lxDFI1iNOAqUfWR5k3iNFeM0aHpBTeCnNIW1hG6iXF4SLC8B4gqMlB3wBgoU2VWRFiUyEQNc"
"/GghJkGNorEQxfDcFWtRMlJFKrUohJRrW55PZghDWQUBCmZHuAExVmNepDk12gXnDWPeXYIv"
"jBIE2slHqDbzPMpn1BVqhObLzalzl8JwwGLOmC+WrXp3n5QQy+thtZovEVkzRNGNFOveRNGe"
"XWQ1y9ACR6mZO0j1uUMwCMCpFGG4ITY2RPpRPREiNtKZDIKMUZKicoxCYdTujkdLQIKn+oWQ"
"Akck4mHKJCTqCgO+iHdUFhjIFiBJgIV4wcHlZFR01BpTQJRKiZ6N1D28VRRFrl2lVu0wtcqH"
"SM8fhXMKmEMUAwoVaF6q0LkdwJOo1p3cQs4sdA9SQsxOYuIDHDiVmCdRLj4PpvAolLyMQkMb"
"KTXyXurd7EERFnDTCdJz44g5PGcnqTz7GtWy8yhiULXZLGZbVG+AqFosuf3MwjDn4SDsirk6"
"ZcIGWRGFWga+XYNAsmtUbniUL5i0sFihAtIpx2Zvd4agAOnSbV1U134JNABtXl2EIJOyAgJX"
"NDhSBcLCEunIoNkqzZ7TAZweDMOsTM3pi5u2yBBBoSC/Kv4zZwHOudDpVAcqWqgnADkJ8RZO"
"92AMU2bthbw3Ipx29Kkf0/7v/F96ZewElGUJq+ZSsQGOsCXR5/LgcBEyiiASYuBwH4Rj1Gzx"
"foEriogo1F93TKKVfSqtXx2nCzd10OrV3eAMnZT6U1S3wtAKKVLCMXBJUoSKyEwc1hAm4SSq"
"05xUq5nKAonizjt7S0woNiOmj0/WZzCr7VwEiWIIsBWDi25GAj9LPNOI7xC3jhCBYGK5bOqi"
"BHXw//6eCn381i109cJKWliYRxVYp2K+Ac1hosy1qFHzw4UNDsngAxCpBjREIWs7EiGK4IMY"
"ZtjVE6bO3hjF4kxuIdLigDXCiIRW8DtHXFPInIbtlhgOVKfHeRbvh6My5etu3pWjeUUxTmv3"
"nR4CqMpS6bQ7PlWfIjkabB2ysSw4Ij4KWBxJASI4PPgz/hk8e1JMVHaiPABx8U5Qd2+aOlNE"
"64axwk0wOjS/pTfJhBPMKoQTnpkPHNPvJ3AocLYwgBa9gnKJCyigxAYizDCgjWdXRZqVHFI5"
"I3kkrgONCsIVChVp1echSSjUEHTJQsmZ18LpikiRv8kB/Ojp7qITU0XUApFAXUVFWhHwZ1ks"
"VFciWH3f+z5P8LMdHOho6/MwYA2jUQuYyBQtAyLHwGtWiE3u16FkRTZglucWpIv012o6VM63"
"4CQYy7o67Pl8IfnhImv+xgqvOBdevNKcjhkNXI4zmgTEWZ5rfmi5tkdT8/ZMMtXRbFRbv3l3"
"mC/s7e2m2YXGtIdUCLyRQEKbB5yab7ySEp0YPwy0ZY7wa3QF+VooM1+n+ooNFC5x80PxB6c1"
"Lp7USBiGBkbB0GrRIrPBvQbu+vhpVRiODCX6pz7H0RmNe4+CD2Txu1yTtL/Ein06601xs3e5"
"DjgDAQyNrq4MjY225ssVp5npRVHuKD7MOfYdxDrKWhEOYoWjPhJU1OVyEgZiaA0QDmsCTRQq"
"LhyicXcn1E2hWIrsaJXUcBHQ1qDW/Fg1kabY+ErdEJOVQYpiD1X0Ccg3XpF8doR28AKCYwPF"
"d5Wg0Sm16xk4WOPKy3eMi/fnizTVs76T5qbp3A7oSKegmrzsQq5ZzAzFoIgCBxhT7V8PVtYX"
"MKg+qDS5SBP7n6Dsq0cof+IkzYyepBu+8jnasGu1IMYTozWaOrZEiUxS8IJrh6lRqiAcEAYg"
"y3SCUSNRqpebIFVyCg0Bb05hDGPROPG4EPLbXsgbvkYTTRF/c8YL2nOnAIHs4YJPOLXU6i7l"
"KzRzYffp+x1naYh4FI/HmItL03P1pYu2Z4bAOMhJyB42dITaLUpSIR0pdAp6oXiShi7fRrWJ"
"k5Tb+xRIC1+voFwOdeDjJeoe6qOFGYu+f+f3yDLBzsh17//0daj6ajQ+XqaXnpmlSEiiiy7t"
"pk3ru4TeaTVN0V1WEN/hSBSaAEVUpgMlckTIXKvZFCzvsqEojVlXiMYIhxIEmW0wulCMwVO5"
"JateNaT5TEfqtzuA9wKi0XhjfLI0S6GeK6h2Ag4Y92Mfyorcph8C7X4BiDHe00Hxvl6sxI00"
"9u1/JgJ/eDUdi4XqDJBNpqO0/cNb6cn79lJxfB4aIUK7PnARacZhumRdP60ciNBD9x6mZx+d"
"opmJDvrQB4dIq1VRl8AYaITjszbVjlfJgMbQgMCLd66gNRviMFAXhrLhiho0aHlfA6jiPiVn"
"FAkOWsxaBVuK5FKp5BnnIM8gQU6FHR0ZZ+xkbkoUOvrzwa605PcGRI/ACV4HTrAtsX8ZiidQ"
"z0cENqxyhcQRJBQlDjdLkJ7C0TBSF4m+Qb1cplpJp9mjS0iRYVp/RT8xby0eLyMLGdSzuo+y"
"TY2+/8giEBOjHe8ZRixLdOgXU7T/P47CsaogSgF18IhtQlGK9GeLbOBx74AHQmChYC+q4Xg5"
"HouegQD5bBuf3T39dOLYkSmq7PN7AeJrgRMk9Q2Xt8nHRcWFGAdUuf5oloqCsHzadoRj2TlS"
"sPtkY3XMhi3yu42wWLkqJYgNWogWp2skQU7/5+NzND3RoERMoVWrOQRignqUkOrrfdnvQYrY"
"58GFkeuIrTQmTK4FOFpncq2ZRDKtc9/hjQg46+7wwEAfjb9cmybd9uMdP0qC+7Sg+GmnPzVI"
"gYpwgAa1SMkUmU6WGsWSaE3JCrwuNwSTh5FUuH+hcs52cC1qABUVHSOlIx2jqOr/Evta1kK0"
"c9cwbccUw7Ew/ehHEzR3skoRfCcBntKiCAGjJBwqGrIhP81yOJDiiuwgsoXLDrCmuru6Pe5B"
"nvOUWPu8YAvlbLbkzdYq3N6RghUOyl850AdCG0SCStDvxakopeV0hlDrUA0Q59QmwQESagYu"
"VmKJKEXwMylIWbthwAgYAgmsRZEuHUksIm9sdPYmiLPYtvesgiZw6Ol9s7Tzmo00srqTuBUQ"
"hRcU1T9oITpDQUudexSSXzwEtYNMFoqwhbI7xYJrYmLi1B7hWTdGeCPi/vvv97fIVMpm80Yp"
"2af0gWZfT4FssOTfxF+vZbszEJChnl4gAFqpUhVpSDQ24SxZi1AimSAIM+4GAvoWaek4UBOj"
"SCIOpVckED/FUgpt3NJPVfDDg987QvOjZfr0/7qOBlYmqTBTINZNC5N5On54iUZGNDjO8oVP"
"sIXvt8htMSUWWTqqzJKuTI+feJ5eefn5M84K/8YTIi2birMLzezay6Q+soIiZFkP0HdGEAoo"
"kwvjkL/TL1B59CipuH9teoaMWo3iYHy7IVEI8E9k0qR4fGTe7wVGElDcXR2UR+l74Okp+Fam"
"D/zBJdSLWuv48RJlx8qUBsie+X8HUcAUqX9lJ3lIr2uuXEl9fYyapljlUwh23YAAHUE/jJJG"
"y2vmq8782zkiU5ucqc9eLbmbllUXPvvLbYkcOAHhEU13UCOUp62f/QyVPjBB+dfG6fnvPkj9"
"W9bQyg29NPr0IZp46ahABziPRp8bBdwHaOZYll54cpJW9Kdo5ydWwHiPivOL0Ptx2nrtMFUL"
"LRpalaZNmzsomekl+4bVFIkB2jWEGHeUuEME+PvpzxRc4ytMGRWoQkXdLVZ1N/t2HGCPT9en"
"/ZOMwcFGz98APeWI9gFYvI71pGm4ZyvRu7YJFvPMGlVmx6meXxC1gmNUaMfHrybnxquouDAD"
"KVyjxYm8gPT1N6+nzi6FTE6N+TIMskXjfNd7EfPhsOgG2WaO9JIsukN6S0ZFqQhCFWlQtrgm"
"9I0PUiA7hI1bqjiL+G/pbR2SOjGtTzOTk6y8rjiE8f7O0alaQAglT7zmHO+h/HVaZVRvEmlK"
"AjK4RKsv7RPd3WalTINr+5ECU2QgU3hOCKtcR9rk9rdJkbQiDFBCUIF2FVwRKEGxm6CJf3nH"
"mbfkRR0gTrJ4ggRdRxZ7lfw+V4jM03O5FlaA9Ld1VnhytrFIpiu2vU7BXewNBLswtAwFUrt3"
"IPuT44GY5FNgjbpHTV1CGSzDAVX6zz0v0/TxLFVrFj3202myPA31Q5yinRlSE4hzrYOq9Qik"
"sioyLztbVjyxDoomiyEFxO3PQ2offfdfB4DlXsBM3sqda6HPhQBlLmvoRq3pRTqBLdEDiItW"
"s68GgwbJqXPgwYaJZwVZRfNFCkTMk99+TLTIXaSmZEeLwok0Pf/EBK2/chXll1rUtKN0+JUl"
"SsUVqpRMkGWE5o+VacPmJGoSRfT5WRQpIe7++huiLPEUxDhvjcttVhdtack/jxhilFg0l29V"
"8EnKhyzZbwUB0VyxVcsX9AaxFBV9cq7Egn6AHA+KImWZ8XYQEl5wZkElLRKjdGcHcndUbFPP"
"jxVoxQX9ILQUBA+rzwhlFxpULhhULduU6ISjkLpGNvWJDKKIzQ8t6B8o/m0c99Rq83ty0GcQ"
"MpiNR5XIqtOyPZrLmoyA+Ovq7c0hgC1Sm6Y3/+0Hjv7yy9+4+CN+FHn+JYwGURApr4eCAILj"
"t8Nlm3JT82IDNdWVpqv+9EaRrxulHJVmxxAKBl3zsStgqEmDK2L4BZtGVsFBindK60fB9IWl"
"OmVzfMBJQh2ggeV5hR3/qK3QFI7gHuGckH8axT8wAWmdUOmhXxXGjs8aB/22NklvxQE8B24n"
"1L5299F71q15duCP/8fHtlALCHCDVpjULoLadcHr4ogLEaNaocOPHaDMUA8NrB+go0+/QnEm"
"uFYNWsCiUg6kh+zQ26dRMV+n3GKDIigTG/UWGQ2HtBATGtJrTKVUR0QwPIsdj8trVQr2/bmU"
"1vz7B2cNuLuUiiLsnsku3HH3sbtc1uP+eULrrXIAX1SGk8c/+YXH73zlWPXTd/ztZ3dnVq4N"
"cZUEHRpoA/lUCHDM8Y6y02pS37oBSnS9nyqLBYI+op4VqBMgkBrlJiU7I8RhWymaVI/5x/KS"
"STZUo3QHjEItDyRTIqVBB0iiEWvzCS8YaDVZ+3tik6R9qpXJVoLz49w/RBb45z2vPfvVu1/6"
"l5puHyV/r7/0lh0A9YZ5OZX28cG77vn1Nx7eO/rk5//yhpv+8L99eEffmrVRP/05wRluKZDK"
"dtCXdyiWlCkSZtHSoI07RuCAMJlgd6upU09/kixkhhb/mZ4XZA+viZ9r4XPD7/aAMxzkfNYJ"
"funBekEWTSqF4x7kyOKIUVIzXffxX8wf+s6PT/zHi0fzvwyMrmPkgmfvLTmAT3Bcc8011s9+"
"9rOSruscDs2J2eq+2//m+we+dte/X/SR6698100ffe/2q666cm3nAAQ9t6UVyF7JFPverscd"
"GcDdqIs2NesMo1JE/i+LYsWC4LKAFN6+5vzP6JFk03/tmT65KX5jVThBbKCqFNJQCahcCEnI"
"Hp57dKw+89SR+Rf3PZ97emK+zmeSCwF6q0BHZe3atU3DMNzZ2dm3lgYZllu2bCH8gPPoo4/W"
"jhw5YkBJ8e5ILVfQ8/fe/+QBjK6+3vSarVsvvnjXrssv2rp53ZoLVuOtTDgFgQflx8pHRbTY"
"4u9/LNURd2whrpClSOUNT4cLGEV0cYSu5w2SmF97iTi3eRMV3sfql3RHn69a+fEFa/LIjPHa"
"q1P6qzNLxji+xqVuMzC8Eax4EyFiZzIZmpqaenNnhZc3C1g2LiwsiD8zvf76673169e39u/f"
"b83NzTWClMI7J8WlbGXqp3uffRaDndMRj0d6hgaAiaHOweGhTN+KvmRPX2c0k06oKc2uxDTP"
"DMMlWD9HAVlKfO6A9/VbpukYTcPSjVarjqeqjiq6KpWzJTe/WHaXForOQq7iLFR1JxvAuxEQ"
"tRUY3gyO1ZvtE+Z8vO6FF15484ell7eL+E9X7r777tNOkHq+h6xgNIM0oAYO4bHYaBjjx8fn"
"VR5B+ml/Fm4PVZE0WQ62ddr39jzxx2WBUa3AEDN4bS8bTnD/1rLRfv9N/XXe8oWW2v/hI6yA"
"ufi7nZtvvpmWlpbezp/gLW8SvHHIy4a0bJy2tREMd9lwgtE20kFsO0Cmu/y835t5vPvd76Yv"
"f/nLNDw8LI7pnuaA5Y+RkRHRGXoHHtKy57ONN9Yeb3TE8vF6iRqN0s9//nMaHBx8a3/QmEzy"
"H3Kf9t7/F2AAvVBYSGyzBHEAAAAASUVORK5CYII=")
getIconDlgData = IconDlg.GetData
getIconDlgImage = IconDlg.GetImage
getIconDlgBitmap = IconDlg.GetBitmap
#----------------------------------------------------------------------
Stopper = PyEmbeddedImage(
"iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAGXRFWHRTb2Z0d2FyZQBBZG9i"
"ZSBJbWFnZVJlYWR5ccllPAAAAyJpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADw/eHBhY2tl"
"dCBiZWdpbj0i77u/IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+IDx4OnhtcG1l"
"dGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDUu"
"MC1jMDYwIDYxLjEzNDc3NywgMjAxMC8wMi8xMi0xNzozMjowMCAgICAgICAgIj4gPHJkZjpS"
"REYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgt"
"bnMjIj4gPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIgeG1sbnM6eG1wPSJodHRwOi8v"
"bnMuYWRvYmUuY29tL3hhcC8xLjAvIiB4bWxuczp4bXBNTT0iaHR0cDovL25zLmFkb2JlLmNv"
"bS94YXAvMS4wL21tLyIgeG1sbnM6c3RSZWY9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEu"
"MC9zVHlwZS9SZXNvdXJjZVJlZiMiIHhtcDpDcmVhdG9yVG9vbD0iQWRvYmUgUGhvdG9zaG9w"
"IENTNSBNYWNpbnRvc2giIHhtcE1NOkluc3RhbmNlSUQ9InhtcC5paWQ6QjIyRjg5QkQzQ0ZD"
"MTFFMEI4M0U4QzQ2NTk1NzRCRTciIHhtcE1NOkRvY3VtZW50SUQ9InhtcC5kaWQ6QjIyRjg5"
"QkUzQ0ZDMTFFMEI4M0U4QzQ2NTk1NzRCRTciPiA8eG1wTU06RGVyaXZlZEZyb20gc3RSZWY6"
"aW5zdGFuY2VJRD0ieG1wLmlpZDpCMjJGODlCQjNDRkMxMUUwQjgzRThDNDY1OTU3NEJFNyIg"
"c3RSZWY6ZG9jdW1lbnRJRD0ieG1wLmRpZDpCMjJGODlCQzNDRkMxMUUwQjgzRThDNDY1OTU3"
"NEJFNyIvPiA8L3JkZjpEZXNjcmlwdGlvbj4gPC9yZGY6UkRGPiA8L3g6eG1wbWV0YT4gPD94"
"cGFja2V0IGVuZD0iciI/PqlZ2cgAAADTSURBVHjaYmRABUJALA3EYkAsABX7AMSvgPgpEL+D"
"KWRE0qQCxGpAzM+AHXwE4ltAfAdZI0iTARCzMuAHv4H4AkgzE9R5ajBNcXFxMuiqkcRYoWpB"
"ehh0gTgShIEKSv8DwcGDBzfCxEBskBhIDiYG0gNyqjM0MMAAqDDCzs7O79ChQ5tAfBjb3t5+"
"BZIjXoE0BgMxG7LTYJpBbCyaQOAXEwOZgAUaT3idChRjQLP1A0WBAwpaC1jEg4J+0aJFT9Cj"
"A0kMlBBOkJ0AKE5yJCdygAADALFea70zE1mzAAAAAElFTkSuQmCC")
getStopperData = Stopper.GetData
getStopperImage = Stopper.GetImage
getStopperBitmap = Stopper.GetBitmap
#----------------------------------------------------------------------
Cursors = PyEmbeddedImage(
"iVBORw0KGgoAAAANSUhEUgAAAGAAAAAgCAMAAADaHo1mAAAAGXRFWHRTb2Z0d2FyZQBBZG9i"
"ZSBJbWFnZVJlYWR5ccllPAAAA2ZpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADw/eHBhY2tl"
"dCBiZWdpbj0i77u/IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+IDx4OnhtcG1l"
"dGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDUu"
"MC1jMDYwIDYxLjEzNDc3NywgMjAxMC8wMi8xMi0xNzozMjowMCAgICAgICAgIj4gPHJkZjpS"
"REYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgt"
"bnMjIj4gPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIgeG1sbnM6eG1wTU09Imh0dHA6"
"Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9tbS8iIHhtbG5zOnN0UmVmPSJodHRwOi8vbnMuYWRv"
"YmUuY29tL3hhcC8xLjAvc1R5cGUvUmVzb3VyY2VSZWYjIiB4bWxuczp4bXA9Imh0dHA6Ly9u"
"cy5hZG9iZS5jb20veGFwLzEuMC8iIHhtcE1NOk9yaWdpbmFsRG9jdW1lbnRJRD0ieG1wLmRp"
"ZDowNTgwMTE3NDA3MjA2ODExOTVGRUM1NjA2QTAxNUM4NCIgeG1wTU06RG9jdW1lbnRJRD0i"
"eG1wLmRpZDpFNjMwRjMwMjQwREUxMUUwQjdDNkJGNkQzMEQ4NDBCNyIgeG1wTU06SW5zdGFu"
"Y2VJRD0ieG1wLmlpZDpFNjMwRjMwMTQwREUxMUUwQjdDNkJGNkQzMEQ4NDBCNyIgeG1wOkNy"
"ZWF0b3JUb29sPSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCI+IDx4bXBNTTpEZXJp"
"dmVkRnJvbSBzdFJlZjppbnN0YW5jZUlEPSJ4bXAuaWlkOkY3N0YxMTc0MDcyMDY4MTFBOTQ5"
"ODU5NDg2NDg4RTZGIiBzdFJlZjpkb2N1bWVudElEPSJ4bXAuZGlkOjA1ODAxMTc0MDcyMDY4"
"MTE5NUZFQzU2MDZBMDE1Qzg0Ii8+IDwvcmRmOkRlc2NyaXB0aW9uPiA8L3JkZjpSREY+IDwv"
"eDp4bXBtZXRhPiA8P3hwYWNrZXQgZW5kPSJyIj8+sdRH9gAAABJQTFRF////AAAAAAD/AMgA"
"/wAAAAAAyFzgwAAAAAZ0Uk5T//////8As7+kvwAAAR5JREFUeNrslVEPgzAIhK/W/v+/PGkp"
"HDWamWCyh6Ev33UtAvME0ELkc4lKOqNEJZ0PISjpLAIr6dwFUtJ5CK6kswqmpPMUppLO2jMJ"
"7uFgBMayfmKRnOk9WIY0GBuO27mhgtdXxi5B52lCefMQhqRsCSYfB4LXa62B937RfgntRJh6"
"ox/AWM6TE4nBLBXI7efJ86FZI23qk2cFxlqBsVZgrBXYeZrg0lA0ga+Pnl+yzoD2jxbNxqwe"
"2HODuSGur+z/ROabBDmMl74C5Z/ghxJoFDOrdC4caOn8egWXPSSnUM+saDdMTtH5cQI1O+dh"
"dp6gX7Rf3fg6QV93VrsmRuDh1vxA27sVPE7wdAZLi85uyO77jV1jses45PfiI8AANeEkeR0W"
"zU0AAAAASUVORK5CYII=")
getCursorsData = Cursors.GetData
getCursorsImage = Cursors.GetImage
getCursorsBitmap = Cursors.GetBitmap
#----------------------------------------------------------------------
Arrows = PyEmbeddedImage(
"iVBORw0KGgoAAAANSUhEUgAAACwAAAALCAYAAAAELW+PAAAAGXRFWHRTb2Z0d2FyZQBBZG9i"
"ZSBJbWFnZVJlYWR5ccllPAAAA2ZpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADw/eHBhY2tl"
"dCBiZWdpbj0i77u/IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+IDx4OnhtcG1l"
"dGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDUu"
"MC1jMDYwIDYxLjEzNDc3NywgMjAxMC8wMi8xMi0xNzozMjowMCAgICAgICAgIj4gPHJkZjpS"
"REYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgt"
"bnMjIj4gPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIgeG1sbnM6eG1wTU09Imh0dHA6"
"Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9tbS8iIHhtbG5zOnN0UmVmPSJodHRwOi8vbnMuYWRv"
"YmUuY29tL3hhcC8xLjAvc1R5cGUvUmVzb3VyY2VSZWYjIiB4bWxuczp4bXA9Imh0dHA6Ly9u"
"cy5hZG9iZS5jb20veGFwLzEuMC8iIHhtcE1NOk9yaWdpbmFsRG9jdW1lbnRJRD0ieG1wLmRp"
"ZDpDODgxQjRCRjBFMjA2ODExOTEwOUZBRDM4Q0UyM0NFMCIgeG1wTU06RG9jdW1lbnRJRD0i"
"eG1wLmRpZDo1QkFCODU2NzU5NDYxMUUxODg5RTk0RjZERTEwMDRCQSIgeG1wTU06SW5zdGFu"
"Y2VJRD0ieG1wLmlpZDo1QkFCODU2NjU5NDYxMUUxODg5RTk0RjZERTEwMDRCQSIgeG1wOkNy"
"ZWF0b3JUb29sPSJBZG9iZSBQaG90b3Nob3AgQ1M0IE1hY2ludG9zaCI+IDx4bXBNTTpEZXJp"
"dmVkRnJvbSBzdFJlZjppbnN0YW5jZUlEPSJ4bXAuaWlkOkM5ODFCNEJGMEUyMDY4MTE5MTA5"
"RkFEMzhDRTIzQ0UwIiBzdFJlZjpkb2N1bWVudElEPSJ4bXAuZGlkOkM4ODFCNEJGMEUyMDY4"
"MTE5MTA5RkFEMzhDRTIzQ0UwIi8+IDwvcmRmOkRlc2NyaXB0aW9uPiA8L3JkZjpSREY+IDwv"
"eDp4bXBtZXRhPiA8P3hwYWNrZXQgZW5kPSJyIj8+pO8lywAAAJBJREFUeNrUVUEOwCAIs4v/"
"/3KnW5YYh4qgB7kYDZS2aATJcFJEayGApJVpQVgpOuNV8fT5NpcTfPd4KDosqcrHlcwmKF67"
"TYJK90ZkWw6zV9AhLQ5hNKQZshJhagsnmmAV2ZowLQBKN+HIFQnT6J529GUOPOLj4OK7nBUe"
"IiZxqXl0JrKbPqCfQJz2090CDAAcZDYU4QC5KAAAAABJRU5ErkJggg==")
getArrowsData = Arrows.GetData
getArrowsImage = Arrows.GetImage
getArrowsBitmap = Arrows.GetBitmap
#----------------------------------------------------------------------
BgrToolbar = PyEmbeddedImage(
"iVBORw0KGgoAAAANSUhEUgAAACMAAAAkCAYAAAAD3IPhAAAAGXRFWHRTb2Z0d2FyZQBBZG9i"
"ZSBJbWFnZVJlYWR5ccllPAAAAD1JREFUeNrs0LEJACAUQ0E/OLibRytnSHGB1x+ZJKtlAwMD"
"AwMDAwMDAwMDAwMDAwMD8zGv04LZTc9cAQYAXRFpP7LCOH4AAAAASUVORK5CYII=")
getBgrToolbarData = BgrToolbar.GetData
getBgrToolbarImage = BgrToolbar.GetImage
getBgrToolbarBitmap = BgrToolbar.GetBitmap
#----------------------------------------------------------------------
BgrToolbarNoBorder = PyEmbeddedImage(
"iVBORw0KGgoAAAANSUhEUgAAACMAAAAmCAYAAABOFCLqAAAACXBIWXMAAAsTAAALEwEAmpwY"
"AAAKT2lDQ1BQaG90b3Nob3AgSUNDIHByb2ZpbGUAAHjanVNnVFPpFj333vRCS4iAlEtvUhUI"
"IFJCi4AUkSYqIQkQSoghodkVUcERRUUEG8igiAOOjoCMFVEsDIoK2AfkIaKOg6OIisr74Xuj"
"a9a89+bN/rXXPues852zzwfACAyWSDNRNYAMqUIeEeCDx8TG4eQuQIEKJHAAEAizZCFz/SMB"
"APh+PDwrIsAHvgABeNMLCADATZvAMByH/w/qQplcAYCEAcB0kThLCIAUAEB6jkKmAEBGAYCd"
"mCZTAKAEAGDLY2LjAFAtAGAnf+bTAICd+Jl7AQBblCEVAaCRACATZYhEAGg7AKzPVopFAFgw"
"ABRmS8Q5ANgtADBJV2ZIALC3AMDOEAuyAAgMADBRiIUpAAR7AGDIIyN4AISZABRG8lc88Suu"
"EOcqAAB4mbI8uSQ5RYFbCC1xB1dXLh4ozkkXKxQ2YQJhmkAuwnmZGTKBNA/g88wAAKCRFRHg"
"g/P9eM4Ors7ONo62Dl8t6r8G/yJiYuP+5c+rcEAAAOF0ftH+LC+zGoA7BoBt/qIl7gRoXgug"
"dfeLZrIPQLUAoOnaV/Nw+H48PEWhkLnZ2eXk5NhKxEJbYcpXff5nwl/AV/1s+X48/Pf14L7i"
"JIEyXYFHBPjgwsz0TKUcz5IJhGLc5o9H/LcL//wd0yLESWK5WCoU41EScY5EmozzMqUiiUKS"
"KcUl0v9k4t8s+wM+3zUAsGo+AXuRLahdYwP2SycQWHTA4vcAAPK7b8HUKAgDgGiD4c93/+8/"
"/UegJQCAZkmScQAAXkQkLlTKsz/HCAAARKCBKrBBG/TBGCzABhzBBdzBC/xgNoRCJMTCQhBC"
"CmSAHHJgKayCQiiGzbAdKmAv1EAdNMBRaIaTcA4uwlW4Dj1wD/phCJ7BKLyBCQRByAgTYSHa"
"iAFiilgjjggXmYX4IcFIBBKLJCDJiBRRIkuRNUgxUopUIFVIHfI9cgI5h1xGupE7yAAygvyG"
"vEcxlIGyUT3UDLVDuag3GoRGogvQZHQxmo8WoJvQcrQaPYw2oefQq2gP2o8+Q8cwwOgYBzPE"
"bDAuxsNCsTgsCZNjy7EirAyrxhqwVqwDu4n1Y8+xdwQSgUXACTYEd0IgYR5BSFhMWE7YSKgg"
"HCQ0EdoJNwkDhFHCJyKTqEu0JroR+cQYYjIxh1hILCPWEo8TLxB7iEPENyQSiUMyJ7mQAkmx"
"pFTSEtJG0m5SI+ksqZs0SBojk8naZGuyBzmULCAryIXkneTD5DPkG+Qh8lsKnWJAcaT4U+Io"
"UspqShnlEOU05QZlmDJBVaOaUt2ooVQRNY9aQq2htlKvUYeoEzR1mjnNgxZJS6WtopXTGmgX"
"aPdpr+h0uhHdlR5Ol9BX0svpR+iX6AP0dwwNhhWDx4hnKBmbGAcYZxl3GK+YTKYZ04sZx1Qw"
"NzHrmOeZD5lvVVgqtip8FZHKCpVKlSaVGyovVKmqpqreqgtV81XLVI+pXlN9rkZVM1PjqQnU"
"lqtVqp1Q61MbU2epO6iHqmeob1Q/pH5Z/YkGWcNMw09DpFGgsV/jvMYgC2MZs3gsIWsNq4Z1"
"gTXEJrHN2Xx2KruY/R27iz2qqaE5QzNKM1ezUvOUZj8H45hx+Jx0TgnnKKeX836K3hTvKeIp"
"G6Y0TLkxZVxrqpaXllirSKtRq0frvTau7aedpr1Fu1n7gQ5Bx0onXCdHZ4/OBZ3nU9lT3acK"
"pxZNPTr1ri6qa6UbobtEd79up+6Ynr5egJ5Mb6feeb3n+hx9L/1U/W36p/VHDFgGswwkBtsM"
"zhg8xTVxbzwdL8fb8VFDXcNAQ6VhlWGX4YSRudE8o9VGjUYPjGnGXOMk423GbcajJgYmISZL"
"TepN7ppSTbmmKaY7TDtMx83MzaLN1pk1mz0x1zLnm+eb15vft2BaeFostqi2uGVJsuRaplnu"
"trxuhVo5WaVYVVpds0atna0l1rutu6cRp7lOk06rntZnw7Dxtsm2qbcZsOXYBtuutm22fWFn"
"Yhdnt8Wuw+6TvZN9un2N/T0HDYfZDqsdWh1+c7RyFDpWOt6azpzuP33F9JbpL2dYzxDP2DPj"
"thPLKcRpnVOb00dnF2e5c4PziIuJS4LLLpc+Lpsbxt3IveRKdPVxXeF60vWdm7Obwu2o26/u"
"Nu5p7ofcn8w0nymeWTNz0MPIQ+BR5dE/C5+VMGvfrH5PQ0+BZ7XnIy9jL5FXrdewt6V3qvdh"
"7xc+9j5yn+M+4zw33jLeWV/MN8C3yLfLT8Nvnl+F30N/I/9k/3r/0QCngCUBZwOJgUGBWwL7"
"+Hp8Ib+OPzrbZfay2e1BjKC5QRVBj4KtguXBrSFoyOyQrSH355jOkc5pDoVQfujW0Adh5mGL"
"w34MJ4WHhVeGP45wiFga0TGXNXfR3ENz30T6RJZE3ptnMU85ry1KNSo+qi5qPNo3ujS6P8Yu"
"ZlnM1VidWElsSxw5LiquNm5svt/87fOH4p3iC+N7F5gvyF1weaHOwvSFpxapLhIsOpZATIhO"
"OJTwQRAqqBaMJfITdyWOCnnCHcJnIi/RNtGI2ENcKh5O8kgqTXqS7JG8NXkkxTOlLOW5hCep"
"kLxMDUzdmzqeFpp2IG0yPTq9MYOSkZBxQqohTZO2Z+pn5mZ2y6xlhbL+xW6Lty8elQfJa7OQ"
"rAVZLQq2QqboVFoo1yoHsmdlV2a/zYnKOZarnivN7cyzytuQN5zvn//tEsIS4ZK2pYZLVy0d"
"WOa9rGo5sjxxedsK4xUFK4ZWBqw8uIq2Km3VT6vtV5eufr0mek1rgV7ByoLBtQFr6wtVCuWF"
"fevc1+1dT1gvWd+1YfqGnRs+FYmKrhTbF5cVf9go3HjlG4dvyr+Z3JS0qavEuWTPZtJm6ebe"
"LZ5bDpaql+aXDm4N2dq0Dd9WtO319kXbL5fNKNu7g7ZDuaO/PLi8ZafJzs07P1SkVPRU+lQ2"
"7tLdtWHX+G7R7ht7vPY07NXbW7z3/T7JvttVAVVN1WbVZftJ+7P3P66Jqun4lvttXa1ObXHt"
"xwPSA/0HIw6217nU1R3SPVRSj9Yr60cOxx++/p3vdy0NNg1VjZzG4iNwRHnk6fcJ3/ceDTra"
"dox7rOEH0x92HWcdL2pCmvKaRptTmvtbYlu6T8w+0dbq3nr8R9sfD5w0PFl5SvNUyWna6YLT"
"k2fyz4ydlZ19fi753GDborZ752PO32oPb++6EHTh0kX/i+c7vDvOXPK4dPKy2+UTV7hXmq86"
"X23qdOo8/pPTT8e7nLuarrlca7nuer21e2b36RueN87d9L158Rb/1tWeOT3dvfN6b/fF9/Xf"
"Ft1+cif9zsu72Xcn7q28T7xf9EDtQdlD3YfVP1v+3Njv3H9qwHeg89HcR/cGhYPP/pH1jw9D"
"BY+Zj8uGDYbrnjg+OTniP3L96fynQ89kzyaeF/6i/suuFxYvfvjV69fO0ZjRoZfyl5O/bXyl"
"/erA6xmv28bCxh6+yXgzMV70VvvtwXfcdx3vo98PT+R8IH8o/2j5sfVT0Kf7kxmTk/8EA5jz"
"/GMzLdsAAAAgY0hSTQAAeiUAAICDAAD5/wAAgOkAAHUwAADqYAAAOpgAABdvkl/FRgAAADlJ"
"REFUeNrszgENAAAIAyC1f+dbQzdIQCepK6YOkZGRkZGRkZGRkZGRkZGRkZGRkfmVWQAAAP//"
"AwC5TQNJT4QhUAAAAABJRU5ErkJggg==")
getBgrToolbarNoBorderData = BgrToolbarNoBorder.GetData
getBgrToolbarNoBorderImage = BgrToolbarNoBorder.GetImage
getBgrToolbarNoBorderBitmap = BgrToolbarNoBorder.GetBitmap
#----------------------------------------------------------------------
BgrControlbar = PyEmbeddedImage(
"iVBORw0KGgoAAAANSUhEUgAAACMAAAAmCAYAAABOFCLqAAAACXBIWXMAAAsTAAALEwEAmpwY"
"AAAKT2lDQ1BQaG90b3Nob3AgSUNDIHByb2ZpbGUAAHjanVNnVFPpFj333vRCS4iAlEtvUhUI"
"IFJCi4AUkSYqIQkQSoghodkVUcERRUUEG8igiAOOjoCMFVEsDIoK2AfkIaKOg6OIisr74Xuj"
"a9a89+bN/rXXPues852zzwfACAyWSDNRNYAMqUIeEeCDx8TG4eQuQIEKJHAAEAizZCFz/SMB"
"APh+PDwrIsAHvgABeNMLCADATZvAMByH/w/qQplcAYCEAcB0kThLCIAUAEB6jkKmAEBGAYCd"
"mCZTAKAEAGDLY2LjAFAtAGAnf+bTAICd+Jl7AQBblCEVAaCRACATZYhEAGg7AKzPVopFAFgw"
"ABRmS8Q5ANgtADBJV2ZIALC3AMDOEAuyAAgMADBRiIUpAAR7AGDIIyN4AISZABRG8lc88Suu"
"EOcqAAB4mbI8uSQ5RYFbCC1xB1dXLh4ozkkXKxQ2YQJhmkAuwnmZGTKBNA/g88wAAKCRFRHg"
"g/P9eM4Ors7ONo62Dl8t6r8G/yJiYuP+5c+rcEAAAOF0ftH+LC+zGoA7BoBt/qIl7gRoXgug"
"dfeLZrIPQLUAoOnaV/Nw+H48PEWhkLnZ2eXk5NhKxEJbYcpXff5nwl/AV/1s+X48/Pf14L7i"
"JIEyXYFHBPjgwsz0TKUcz5IJhGLc5o9H/LcL//wd0yLESWK5WCoU41EScY5EmozzMqUiiUKS"
"KcUl0v9k4t8s+wM+3zUAsGo+AXuRLahdYwP2SycQWHTA4vcAAPK7b8HUKAgDgGiD4c93/+8/"
"/UegJQCAZkmScQAAXkQkLlTKsz/HCAAARKCBKrBBG/TBGCzABhzBBdzBC/xgNoRCJMTCQhBC"
"CmSAHHJgKayCQiiGzbAdKmAv1EAdNMBRaIaTcA4uwlW4Dj1wD/phCJ7BKLyBCQRByAgTYSHa"
"iAFiilgjjggXmYX4IcFIBBKLJCDJiBRRIkuRNUgxUopUIFVIHfI9cgI5h1xGupE7yAAygvyG"
"vEcxlIGyUT3UDLVDuag3GoRGogvQZHQxmo8WoJvQcrQaPYw2oefQq2gP2o8+Q8cwwOgYBzPE"
"bDAuxsNCsTgsCZNjy7EirAyrxhqwVqwDu4n1Y8+xdwQSgUXACTYEd0IgYR5BSFhMWE7YSKgg"
"HCQ0EdoJNwkDhFHCJyKTqEu0JroR+cQYYjIxh1hILCPWEo8TLxB7iEPENyQSiUMyJ7mQAkmx"
"pFTSEtJG0m5SI+ksqZs0SBojk8naZGuyBzmULCAryIXkneTD5DPkG+Qh8lsKnWJAcaT4U+Io"
"UspqShnlEOU05QZlmDJBVaOaUt2ooVQRNY9aQq2htlKvUYeoEzR1mjnNgxZJS6WtopXTGmgX"
"aPdpr+h0uhHdlR5Ol9BX0svpR+iX6AP0dwwNhhWDx4hnKBmbGAcYZxl3GK+YTKYZ04sZx1Qw"
"NzHrmOeZD5lvVVgqtip8FZHKCpVKlSaVGyovVKmqpqreqgtV81XLVI+pXlN9rkZVM1PjqQnU"
"lqtVqp1Q61MbU2epO6iHqmeob1Q/pH5Z/YkGWcNMw09DpFGgsV/jvMYgC2MZs3gsIWsNq4Z1"
"gTXEJrHN2Xx2KruY/R27iz2qqaE5QzNKM1ezUvOUZj8H45hx+Jx0TgnnKKeX836K3hTvKeIp"
"G6Y0TLkxZVxrqpaXllirSKtRq0frvTau7aedpr1Fu1n7gQ5Bx0onXCdHZ4/OBZ3nU9lT3acK"
"pxZNPTr1ri6qa6UbobtEd79up+6Ynr5egJ5Mb6feeb3n+hx9L/1U/W36p/VHDFgGswwkBtsM"
"zhg8xTVxbzwdL8fb8VFDXcNAQ6VhlWGX4YSRudE8o9VGjUYPjGnGXOMk423GbcajJgYmISZL"
"TepN7ppSTbmmKaY7TDtMx83MzaLN1pk1mz0x1zLnm+eb15vft2BaeFostqi2uGVJsuRaplnu"
"trxuhVo5WaVYVVpds0atna0l1rutu6cRp7lOk06rntZnw7Dxtsm2qbcZsOXYBtuutm22fWFn"
"Yhdnt8Wuw+6TvZN9un2N/T0HDYfZDqsdWh1+c7RyFDpWOt6azpzuP33F9JbpL2dYzxDP2DPj"
"thPLKcRpnVOb00dnF2e5c4PziIuJS4LLLpc+Lpsbxt3IveRKdPVxXeF60vWdm7Obwu2o26/u"
"Nu5p7ofcn8w0nymeWTNz0MPIQ+BR5dE/C5+VMGvfrH5PQ0+BZ7XnIy9jL5FXrdewt6V3qvdh"
"7xc+9j5yn+M+4zw33jLeWV/MN8C3yLfLT8Nvnl+F30N/I/9k/3r/0QCngCUBZwOJgUGBWwL7"
"+Hp8Ib+OPzrbZfay2e1BjKC5QRVBj4KtguXBrSFoyOyQrSH355jOkc5pDoVQfujW0Adh5mGL"
"w34MJ4WHhVeGP45wiFga0TGXNXfR3ENz30T6RJZE3ptnMU85ry1KNSo+qi5qPNo3ujS6P8Yu"
"ZlnM1VidWElsSxw5LiquNm5svt/87fOH4p3iC+N7F5gvyF1weaHOwvSFpxapLhIsOpZATIhO"
"OJTwQRAqqBaMJfITdyWOCnnCHcJnIi/RNtGI2ENcKh5O8kgqTXqS7JG8NXkkxTOlLOW5hCep"
"kLxMDUzdmzqeFpp2IG0yPTq9MYOSkZBxQqohTZO2Z+pn5mZ2y6xlhbL+xW6Lty8elQfJa7OQ"
"rAVZLQq2QqboVFoo1yoHsmdlV2a/zYnKOZarnivN7cyzytuQN5zvn//tEsIS4ZK2pYZLVy0d"
"WOa9rGo5sjxxedsK4xUFK4ZWBqw8uIq2Km3VT6vtV5eufr0mek1rgV7ByoLBtQFr6wtVCuWF"
"fevc1+1dT1gvWd+1YfqGnRs+FYmKrhTbF5cVf9go3HjlG4dvyr+Z3JS0qavEuWTPZtJm6ebe"
"LZ5bDpaql+aXDm4N2dq0Dd9WtO319kXbL5fNKNu7g7ZDuaO/PLi8ZafJzs07P1SkVPRU+lQ2"
"7tLdtWHX+G7R7ht7vPY07NXbW7z3/T7JvttVAVVN1WbVZftJ+7P3P66Jqun4lvttXa1ObXHt"
"xwPSA/0HIw6217nU1R3SPVRSj9Yr60cOxx++/p3vdy0NNg1VjZzG4iNwRHnk6fcJ3/ceDTra"
"dox7rOEH0x92HWcdL2pCmvKaRptTmvtbYlu6T8w+0dbq3nr8R9sfD5w0PFl5SvNUyWna6YLT"
"k2fyz4ydlZ19fi753GDborZ752PO32oPb++6EHTh0kX/i+c7vDvOXPK4dPKy2+UTV7hXmq86"
"X23qdOo8/pPTT8e7nLuarrlca7nuer21e2b36RueN87d9L158Rb/1tWeOT3dvfN6b/fF9/Xf"
"Ft1+cif9zsu72Xcn7q28T7xf9EDtQdlD3YfVP1v+3Njv3H9qwHeg89HcR/cGhYPP/pH1jw9D"
"BY+Zj8uGDYbrnjg+OTniP3L96fynQ89kzyaeF/6i/suuFxYvfvjV69fO0ZjRoZfyl5O/bXyl"
"/erA6xmv28bCxh6+yXgzMV70VvvtwXfcdx3vo98PT+R8IH8o/2j5sfVT0Kf7kxmTk/8EA5jz"
"/GMzLdsAAAAgY0hSTQAAeiUAAICDAAD5/wAAgOkAAHUwAADqYAAAOpgAABdvkl/FRgAAADlJ"
"REFUeNrszgENAAAIAyC1f+dbQzdIQCepK6YOkZGRkZGRkZGRkZGRkZGRkZGRkfmVWQAAAP//"
"AwC5TQNJT4QhUAAAAABJRU5ErkJggg==")
getBgrControlbarData = BgrControlbar.GetData
getBgrControlbarImage = BgrControlbar.GetImage
getBgrControlbarBitmap = BgrControlbar.GetBitmap
#----------------------------------------------------------------------
BgrControlbarBorder = PyEmbeddedImage(
"iVBORw0KGgoAAAANSUhEUgAAACMAAAAgCAYAAACYTcH3AAAACXBIWXMAAAsTAAALEwEAmpwY"
"AAAKT2lDQ1BQaG90b3Nob3AgSUNDIHByb2ZpbGUAAHjanVNnVFPpFj333vRCS4iAlEtvUhUI"
"IFJCi4AUkSYqIQkQSoghodkVUcERRUUEG8igiAOOjoCMFVEsDIoK2AfkIaKOg6OIisr74Xuj"
"a9a89+bN/rXXPues852zzwfACAyWSDNRNYAMqUIeEeCDx8TG4eQuQIEKJHAAEAizZCFz/SMB"
"APh+PDwrIsAHvgABeNMLCADATZvAMByH/w/qQplcAYCEAcB0kThLCIAUAEB6jkKmAEBGAYCd"
"mCZTAKAEAGDLY2LjAFAtAGAnf+bTAICd+Jl7AQBblCEVAaCRACATZYhEAGg7AKzPVopFAFgw"
"ABRmS8Q5ANgtADBJV2ZIALC3AMDOEAuyAAgMADBRiIUpAAR7AGDIIyN4AISZABRG8lc88Suu"
"EOcqAAB4mbI8uSQ5RYFbCC1xB1dXLh4ozkkXKxQ2YQJhmkAuwnmZGTKBNA/g88wAAKCRFRHg"
"g/P9eM4Ors7ONo62Dl8t6r8G/yJiYuP+5c+rcEAAAOF0ftH+LC+zGoA7BoBt/qIl7gRoXgug"
"dfeLZrIPQLUAoOnaV/Nw+H48PEWhkLnZ2eXk5NhKxEJbYcpXff5nwl/AV/1s+X48/Pf14L7i"
"JIEyXYFHBPjgwsz0TKUcz5IJhGLc5o9H/LcL//wd0yLESWK5WCoU41EScY5EmozzMqUiiUKS"
"KcUl0v9k4t8s+wM+3zUAsGo+AXuRLahdYwP2SycQWHTA4vcAAPK7b8HUKAgDgGiD4c93/+8/"
"/UegJQCAZkmScQAAXkQkLlTKsz/HCAAARKCBKrBBG/TBGCzABhzBBdzBC/xgNoRCJMTCQhBC"
"CmSAHHJgKayCQiiGzbAdKmAv1EAdNMBRaIaTcA4uwlW4Dj1wD/phCJ7BKLyBCQRByAgTYSHa"
"iAFiilgjjggXmYX4IcFIBBKLJCDJiBRRIkuRNUgxUopUIFVIHfI9cgI5h1xGupE7yAAygvyG"
"vEcxlIGyUT3UDLVDuag3GoRGogvQZHQxmo8WoJvQcrQaPYw2oefQq2gP2o8+Q8cwwOgYBzPE"
"bDAuxsNCsTgsCZNjy7EirAyrxhqwVqwDu4n1Y8+xdwQSgUXACTYEd0IgYR5BSFhMWE7YSKgg"
"HCQ0EdoJNwkDhFHCJyKTqEu0JroR+cQYYjIxh1hILCPWEo8TLxB7iEPENyQSiUMyJ7mQAkmx"
"pFTSEtJG0m5SI+ksqZs0SBojk8naZGuyBzmULCAryIXkneTD5DPkG+Qh8lsKnWJAcaT4U+Io"
"UspqShnlEOU05QZlmDJBVaOaUt2ooVQRNY9aQq2htlKvUYeoEzR1mjnNgxZJS6WtopXTGmgX"
"aPdpr+h0uhHdlR5Ol9BX0svpR+iX6AP0dwwNhhWDx4hnKBmbGAcYZxl3GK+YTKYZ04sZx1Qw"
"NzHrmOeZD5lvVVgqtip8FZHKCpVKlSaVGyovVKmqpqreqgtV81XLVI+pXlN9rkZVM1PjqQnU"
"lqtVqp1Q61MbU2epO6iHqmeob1Q/pH5Z/YkGWcNMw09DpFGgsV/jvMYgC2MZs3gsIWsNq4Z1"
"gTXEJrHN2Xx2KruY/R27iz2qqaE5QzNKM1ezUvOUZj8H45hx+Jx0TgnnKKeX836K3hTvKeIp"
"G6Y0TLkxZVxrqpaXllirSKtRq0frvTau7aedpr1Fu1n7gQ5Bx0onXCdHZ4/OBZ3nU9lT3acK"
"pxZNPTr1ri6qa6UbobtEd79up+6Ynr5egJ5Mb6feeb3n+hx9L/1U/W36p/VHDFgGswwkBtsM"
"zhg8xTVxbzwdL8fb8VFDXcNAQ6VhlWGX4YSRudE8o9VGjUYPjGnGXOMk423GbcajJgYmISZL"
"TepN7ppSTbmmKaY7TDtMx83MzaLN1pk1mz0x1zLnm+eb15vft2BaeFostqi2uGVJsuRaplnu"
"trxuhVo5WaVYVVpds0atna0l1rutu6cRp7lOk06rntZnw7Dxtsm2qbcZsOXYBtuutm22fWFn"
"Yhdnt8Wuw+6TvZN9un2N/T0HDYfZDqsdWh1+c7RyFDpWOt6azpzuP33F9JbpL2dYzxDP2DPj"
"thPLKcRpnVOb00dnF2e5c4PziIuJS4LLLpc+Lpsbxt3IveRKdPVxXeF60vWdm7Obwu2o26/u"
"Nu5p7ofcn8w0nymeWTNz0MPIQ+BR5dE/C5+VMGvfrH5PQ0+BZ7XnIy9jL5FXrdewt6V3qvdh"
"7xc+9j5yn+M+4zw33jLeWV/MN8C3yLfLT8Nvnl+F30N/I/9k/3r/0QCngCUBZwOJgUGBWwL7"
"+Hp8Ib+OPzrbZfay2e1BjKC5QRVBj4KtguXBrSFoyOyQrSH355jOkc5pDoVQfujW0Adh5mGL"
"w34MJ4WHhVeGP45wiFga0TGXNXfR3ENz30T6RJZE3ptnMU85ry1KNSo+qi5qPNo3ujS6P8Yu"
"ZlnM1VidWElsSxw5LiquNm5svt/87fOH4p3iC+N7F5gvyF1weaHOwvSFpxapLhIsOpZATIhO"
"OJTwQRAqqBaMJfITdyWOCnnCHcJnIi/RNtGI2ENcKh5O8kgqTXqS7JG8NXkkxTOlLOW5hCep"
"kLxMDUzdmzqeFpp2IG0yPTq9MYOSkZBxQqohTZO2Z+pn5mZ2y6xlhbL+xW6Lty8elQfJa7OQ"
"rAVZLQq2QqboVFoo1yoHsmdlV2a/zYnKOZarnivN7cyzytuQN5zvn//tEsIS4ZK2pYZLVy0d"
"WOa9rGo5sjxxedsK4xUFK4ZWBqw8uIq2Km3VT6vtV5eufr0mek1rgV7ByoLBtQFr6wtVCuWF"
"fevc1+1dT1gvWd+1YfqGnRs+FYmKrhTbF5cVf9go3HjlG4dvyr+Z3JS0qavEuWTPZtJm6ebe"
"LZ5bDpaql+aXDm4N2dq0Dd9WtO319kXbL5fNKNu7g7ZDuaO/PLi8ZafJzs07P1SkVPRU+lQ2"
"7tLdtWHX+G7R7ht7vPY07NXbW7z3/T7JvttVAVVN1WbVZftJ+7P3P66Jqun4lvttXa1ObXHt"
"xwPSA/0HIw6217nU1R3SPVRSj9Yr60cOxx++/p3vdy0NNg1VjZzG4iNwRHnk6fcJ3/ceDTra"
"dox7rOEH0x92HWcdL2pCmvKaRptTmvtbYlu6T8w+0dbq3nr8R9sfD5w0PFl5SvNUyWna6YLT"
"k2fyz4ydlZ19fi753GDborZ752PO32oPb++6EHTh0kX/i+c7vDvOXPK4dPKy2+UTV7hXmq86"
"X23qdOo8/pPTT8e7nLuarrlca7nuer21e2b36RueN87d9L158Rb/1tWeOT3dvfN6b/fF9/Xf"
"Ft1+cif9zsu72Xcn7q28T7xf9EDtQdlD3YfVP1v+3Njv3H9qwHeg89HcR/cGhYPP/pH1jw9D"
"BY+Zj8uGDYbrnjg+OTniP3L96fynQ89kzyaeF/6i/suuFxYvfvjV69fO0ZjRoZfyl5O/bXyl"
"/erA6xmv28bCxh6+yXgzMV70VvvtwXfcdx3vo98PT+R8IH8o/2j5sfVT0Kf7kxmTk/8EA5jz"
"/GMzLdsAAAAgY0hSTQAAeiUAAICDAAD5/wAAgOkAAHUwAADqYAAAOpgAABdvkl/FRgAAAEBJ"
"REFUeNrs2LERACAQw7DAMTibP0tQpJAnUO01M2lppygYGBgYGBgYGBgYGBgYGJi/rSS3BXOa"
"lsgDAAD//wMAGHwGuyee6zsAAAAASUVORK5CYII=")
getBgrControlbarBorderData = BgrControlbarBorder.GetData
getBgrControlbarBorderImage = BgrControlbarBorder.GetImage
getBgrControlbarBorderBitmap = BgrControlbarBorder.GetBitmap
#----------------------------------------------------------------------
BgrControlbarDouble = PyEmbeddedImage(
"iVBORw0KGgoAAAANSUhEUgAAACMAAAAmCAYAAABOFCLqAAAACXBIWXMAAAsTAAALEwEAmpwY"
"AAAKT2lDQ1BQaG90b3Nob3AgSUNDIHByb2ZpbGUAAHjanVNnVFPpFj333vRCS4iAlEtvUhUI"
"IFJCi4AUkSYqIQkQSoghodkVUcERRUUEG8igiAOOjoCMFVEsDIoK2AfkIaKOg6OIisr74Xuj"
"a9a89+bN/rXXPues852zzwfACAyWSDNRNYAMqUIeEeCDx8TG4eQuQIEKJHAAEAizZCFz/SMB"
"APh+PDwrIsAHvgABeNMLCADATZvAMByH/w/qQplcAYCEAcB0kThLCIAUAEB6jkKmAEBGAYCd"
"mCZTAKAEAGDLY2LjAFAtAGAnf+bTAICd+Jl7AQBblCEVAaCRACATZYhEAGg7AKzPVopFAFgw"
"ABRmS8Q5ANgtADBJV2ZIALC3AMDOEAuyAAgMADBRiIUpAAR7AGDIIyN4AISZABRG8lc88Suu"
"EOcqAAB4mbI8uSQ5RYFbCC1xB1dXLh4ozkkXKxQ2YQJhmkAuwnmZGTKBNA/g88wAAKCRFRHg"
"g/P9eM4Ors7ONo62Dl8t6r8G/yJiYuP+5c+rcEAAAOF0ftH+LC+zGoA7BoBt/qIl7gRoXgug"
"dfeLZrIPQLUAoOnaV/Nw+H48PEWhkLnZ2eXk5NhKxEJbYcpXff5nwl/AV/1s+X48/Pf14L7i"
"JIEyXYFHBPjgwsz0TKUcz5IJhGLc5o9H/LcL//wd0yLESWK5WCoU41EScY5EmozzMqUiiUKS"
"KcUl0v9k4t8s+wM+3zUAsGo+AXuRLahdYwP2SycQWHTA4vcAAPK7b8HUKAgDgGiD4c93/+8/"
"/UegJQCAZkmScQAAXkQkLlTKsz/HCAAARKCBKrBBG/TBGCzABhzBBdzBC/xgNoRCJMTCQhBC"
"CmSAHHJgKayCQiiGzbAdKmAv1EAdNMBRaIaTcA4uwlW4Dj1wD/phCJ7BKLyBCQRByAgTYSHa"
"iAFiilgjjggXmYX4IcFIBBKLJCDJiBRRIkuRNUgxUopUIFVIHfI9cgI5h1xGupE7yAAygvyG"
"vEcxlIGyUT3UDLVDuag3GoRGogvQZHQxmo8WoJvQcrQaPYw2oefQq2gP2o8+Q8cwwOgYBzPE"
"bDAuxsNCsTgsCZNjy7EirAyrxhqwVqwDu4n1Y8+xdwQSgUXACTYEd0IgYR5BSFhMWE7YSKgg"
"HCQ0EdoJNwkDhFHCJyKTqEu0JroR+cQYYjIxh1hILCPWEo8TLxB7iEPENyQSiUMyJ7mQAkmx"
"pFTSEtJG0m5SI+ksqZs0SBojk8naZGuyBzmULCAryIXkneTD5DPkG+Qh8lsKnWJAcaT4U+Io"
"UspqShnlEOU05QZlmDJBVaOaUt2ooVQRNY9aQq2htlKvUYeoEzR1mjnNgxZJS6WtopXTGmgX"
"aPdpr+h0uhHdlR5Ol9BX0svpR+iX6AP0dwwNhhWDx4hnKBmbGAcYZxl3GK+YTKYZ04sZx1Qw"
"NzHrmOeZD5lvVVgqtip8FZHKCpVKlSaVGyovVKmqpqreqgtV81XLVI+pXlN9rkZVM1PjqQnU"
"lqtVqp1Q61MbU2epO6iHqmeob1Q/pH5Z/YkGWcNMw09DpFGgsV/jvMYgC2MZs3gsIWsNq4Z1"
"gTXEJrHN2Xx2KruY/R27iz2qqaE5QzNKM1ezUvOUZj8H45hx+Jx0TgnnKKeX836K3hTvKeIp"
"G6Y0TLkxZVxrqpaXllirSKtRq0frvTau7aedpr1Fu1n7gQ5Bx0onXCdHZ4/OBZ3nU9lT3acK"
"pxZNPTr1ri6qa6UbobtEd79up+6Ynr5egJ5Mb6feeb3n+hx9L/1U/W36p/VHDFgGswwkBtsM"
"zhg8xTVxbzwdL8fb8VFDXcNAQ6VhlWGX4YSRudE8o9VGjUYPjGnGXOMk423GbcajJgYmISZL"
"TepN7ppSTbmmKaY7TDtMx83MzaLN1pk1mz0x1zLnm+eb15vft2BaeFostqi2uGVJsuRaplnu"
"trxuhVo5WaVYVVpds0atna0l1rutu6cRp7lOk06rntZnw7Dxtsm2qbcZsOXYBtuutm22fWFn"
"Yhdnt8Wuw+6TvZN9un2N/T0HDYfZDqsdWh1+c7RyFDpWOt6azpzuP33F9JbpL2dYzxDP2DPj"
"thPLKcRpnVOb00dnF2e5c4PziIuJS4LLLpc+Lpsbxt3IveRKdPVxXeF60vWdm7Obwu2o26/u"
"Nu5p7ofcn8w0nymeWTNz0MPIQ+BR5dE/C5+VMGvfrH5PQ0+BZ7XnIy9jL5FXrdewt6V3qvdh"
"7xc+9j5yn+M+4zw33jLeWV/MN8C3yLfLT8Nvnl+F30N/I/9k/3r/0QCngCUBZwOJgUGBWwL7"
"+Hp8Ib+OPzrbZfay2e1BjKC5QRVBj4KtguXBrSFoyOyQrSH355jOkc5pDoVQfujW0Adh5mGL"
"w34MJ4WHhVeGP45wiFga0TGXNXfR3ENz30T6RJZE3ptnMU85ry1KNSo+qi5qPNo3ujS6P8Yu"
"ZlnM1VidWElsSxw5LiquNm5svt/87fOH4p3iC+N7F5gvyF1weaHOwvSFpxapLhIsOpZATIhO"
"OJTwQRAqqBaMJfITdyWOCnnCHcJnIi/RNtGI2ENcKh5O8kgqTXqS7JG8NXkkxTOlLOW5hCep"
"kLxMDUzdmzqeFpp2IG0yPTq9MYOSkZBxQqohTZO2Z+pn5mZ2y6xlhbL+xW6Lty8elQfJa7OQ"
"rAVZLQq2QqboVFoo1yoHsmdlV2a/zYnKOZarnivN7cyzytuQN5zvn//tEsIS4ZK2pYZLVy0d"
"WOa9rGo5sjxxedsK4xUFK4ZWBqw8uIq2Km3VT6vtV5eufr0mek1rgV7ByoLBtQFr6wtVCuWF"
"fevc1+1dT1gvWd+1YfqGnRs+FYmKrhTbF5cVf9go3HjlG4dvyr+Z3JS0qavEuWTPZtJm6ebe"
"LZ5bDpaql+aXDm4N2dq0Dd9WtO319kXbL5fNKNu7g7ZDuaO/PLi8ZafJzs07P1SkVPRU+lQ2"
"7tLdtWHX+G7R7ht7vPY07NXbW7z3/T7JvttVAVVN1WbVZftJ+7P3P66Jqun4lvttXa1ObXHt"
"xwPSA/0HIw6217nU1R3SPVRSj9Yr60cOxx++/p3vdy0NNg1VjZzG4iNwRHnk6fcJ3/ceDTra"
"dox7rOEH0x92HWcdL2pCmvKaRptTmvtbYlu6T8w+0dbq3nr8R9sfD5w0PFl5SvNUyWna6YLT"
"k2fyz4ydlZ19fi753GDborZ752PO32oPb++6EHTh0kX/i+c7vDvOXPK4dPKy2+UTV7hXmq86"
"X23qdOo8/pPTT8e7nLuarrlca7nuer21e2b36RueN87d9L158Rb/1tWeOT3dvfN6b/fF9/Xf"
"Ft1+cif9zsu72Xcn7q28T7xf9EDtQdlD3YfVP1v+3Njv3H9qwHeg89HcR/cGhYPP/pH1jw9D"
"BY+Zj8uGDYbrnjg+OTniP3L96fynQ89kzyaeF/6i/suuFxYvfvjV69fO0ZjRoZfyl5O/bXyl"
"/erA6xmv28bCxh6+yXgzMV70VvvtwXfcdx3vo98PT+R8IH8o/2j5sfVT0Kf7kxmTk/8EA5jz"
"/GMzLdsAAAAgY0hSTQAAeiUAAICDAAD5/wAAgOkAAHUwAADqYAAAOpgAABdvkl/FRgAAADlJ"
"REFUeNrszgENAAAIAyC1f+dbQzdIQCepK6YOkZGRkZGRkZGRkZGRkZGRkZGRkfmVWQAAAP//"
"AwC5TQNJT4QhUAAAAABJRU5ErkJggg==")
getBgrControlbarDoubleData = BgrControlbarDouble.GetData
getBgrControlbarDoubleImage = BgrControlbarDouble.GetImage
getBgrControlbarDoubleBitmap = BgrControlbarDouble.GetBitmap
#----------------------------------------------------------------------
BgrBottombar = PyEmbeddedImage(
"iVBORw0KGgoAAAANSUhEUgAAAGQAAAAzCAYAAABhaa0bAAAACXBIWXMAAAsTAAALEwEAmpwY"
"AAAKT2lDQ1BQaG90b3Nob3AgSUNDIHByb2ZpbGUAAHjanVNnVFPpFj333vRCS4iAlEtvUhUI"
"IFJCi4AUkSYqIQkQSoghodkVUcERRUUEG8igiAOOjoCMFVEsDIoK2AfkIaKOg6OIisr74Xuj"
"a9a89+bN/rXXPues852zzwfACAyWSDNRNYAMqUIeEeCDx8TG4eQuQIEKJHAAEAizZCFz/SMB"
"APh+PDwrIsAHvgABeNMLCADATZvAMByH/w/qQplcAYCEAcB0kThLCIAUAEB6jkKmAEBGAYCd"
"mCZTAKAEAGDLY2LjAFAtAGAnf+bTAICd+Jl7AQBblCEVAaCRACATZYhEAGg7AKzPVopFAFgw"
"ABRmS8Q5ANgtADBJV2ZIALC3AMDOEAuyAAgMADBRiIUpAAR7AGDIIyN4AISZABRG8lc88Suu"
"EOcqAAB4mbI8uSQ5RYFbCC1xB1dXLh4ozkkXKxQ2YQJhmkAuwnmZGTKBNA/g88wAAKCRFRHg"
"g/P9eM4Ors7ONo62Dl8t6r8G/yJiYuP+5c+rcEAAAOF0ftH+LC+zGoA7BoBt/qIl7gRoXgug"
"dfeLZrIPQLUAoOnaV/Nw+H48PEWhkLnZ2eXk5NhKxEJbYcpXff5nwl/AV/1s+X48/Pf14L7i"
"JIEyXYFHBPjgwsz0TKUcz5IJhGLc5o9H/LcL//wd0yLESWK5WCoU41EScY5EmozzMqUiiUKS"
"KcUl0v9k4t8s+wM+3zUAsGo+AXuRLahdYwP2SycQWHTA4vcAAPK7b8HUKAgDgGiD4c93/+8/"
"/UegJQCAZkmScQAAXkQkLlTKsz/HCAAARKCBKrBBG/TBGCzABhzBBdzBC/xgNoRCJMTCQhBC"
"CmSAHHJgKayCQiiGzbAdKmAv1EAdNMBRaIaTcA4uwlW4Dj1wD/phCJ7BKLyBCQRByAgTYSHa"
"iAFiilgjjggXmYX4IcFIBBKLJCDJiBRRIkuRNUgxUopUIFVIHfI9cgI5h1xGupE7yAAygvyG"
"vEcxlIGyUT3UDLVDuag3GoRGogvQZHQxmo8WoJvQcrQaPYw2oefQq2gP2o8+Q8cwwOgYBzPE"
"bDAuxsNCsTgsCZNjy7EirAyrxhqwVqwDu4n1Y8+xdwQSgUXACTYEd0IgYR5BSFhMWE7YSKgg"
"HCQ0EdoJNwkDhFHCJyKTqEu0JroR+cQYYjIxh1hILCPWEo8TLxB7iEPENyQSiUMyJ7mQAkmx"
"pFTSEtJG0m5SI+ksqZs0SBojk8naZGuyBzmULCAryIXkneTD5DPkG+Qh8lsKnWJAcaT4U+Io"
"UspqShnlEOU05QZlmDJBVaOaUt2ooVQRNY9aQq2htlKvUYeoEzR1mjnNgxZJS6WtopXTGmgX"
"aPdpr+h0uhHdlR5Ol9BX0svpR+iX6AP0dwwNhhWDx4hnKBmbGAcYZxl3GK+YTKYZ04sZx1Qw"
"NzHrmOeZD5lvVVgqtip8FZHKCpVKlSaVGyovVKmqpqreqgtV81XLVI+pXlN9rkZVM1PjqQnU"
"lqtVqp1Q61MbU2epO6iHqmeob1Q/pH5Z/YkGWcNMw09DpFGgsV/jvMYgC2MZs3gsIWsNq4Z1"
"gTXEJrHN2Xx2KruY/R27iz2qqaE5QzNKM1ezUvOUZj8H45hx+Jx0TgnnKKeX836K3hTvKeIp"
"G6Y0TLkxZVxrqpaXllirSKtRq0frvTau7aedpr1Fu1n7gQ5Bx0onXCdHZ4/OBZ3nU9lT3acK"
"pxZNPTr1ri6qa6UbobtEd79up+6Ynr5egJ5Mb6feeb3n+hx9L/1U/W36p/VHDFgGswwkBtsM"
"zhg8xTVxbzwdL8fb8VFDXcNAQ6VhlWGX4YSRudE8o9VGjUYPjGnGXOMk423GbcajJgYmISZL"
"TepN7ppSTbmmKaY7TDtMx83MzaLN1pk1mz0x1zLnm+eb15vft2BaeFostqi2uGVJsuRaplnu"
"trxuhVo5WaVYVVpds0atna0l1rutu6cRp7lOk06rntZnw7Dxtsm2qbcZsOXYBtuutm22fWFn"
"Yhdnt8Wuw+6TvZN9un2N/T0HDYfZDqsdWh1+c7RyFDpWOt6azpzuP33F9JbpL2dYzxDP2DPj"
"thPLKcRpnVOb00dnF2e5c4PziIuJS4LLLpc+Lpsbxt3IveRKdPVxXeF60vWdm7Obwu2o26/u"
"Nu5p7ofcn8w0nymeWTNz0MPIQ+BR5dE/C5+VMGvfrH5PQ0+BZ7XnIy9jL5FXrdewt6V3qvdh"
"7xc+9j5yn+M+4zw33jLeWV/MN8C3yLfLT8Nvnl+F30N/I/9k/3r/0QCngCUBZwOJgUGBWwL7"
"+Hp8Ib+OPzrbZfay2e1BjKC5QRVBj4KtguXBrSFoyOyQrSH355jOkc5pDoVQfujW0Adh5mGL"
"w34MJ4WHhVeGP45wiFga0TGXNXfR3ENz30T6RJZE3ptnMU85ry1KNSo+qi5qPNo3ujS6P8Yu"
"ZlnM1VidWElsSxw5LiquNm5svt/87fOH4p3iC+N7F5gvyF1weaHOwvSFpxapLhIsOpZATIhO"
"OJTwQRAqqBaMJfITdyWOCnnCHcJnIi/RNtGI2ENcKh5O8kgqTXqS7JG8NXkkxTOlLOW5hCep"
"kLxMDUzdmzqeFpp2IG0yPTq9MYOSkZBxQqohTZO2Z+pn5mZ2y6xlhbL+xW6Lty8elQfJa7OQ"
"rAVZLQq2QqboVFoo1yoHsmdlV2a/zYnKOZarnivN7cyzytuQN5zvn//tEsIS4ZK2pYZLVy0d"
"WOa9rGo5sjxxedsK4xUFK4ZWBqw8uIq2Km3VT6vtV5eufr0mek1rgV7ByoLBtQFr6wtVCuWF"
"fevc1+1dT1gvWd+1YfqGnRs+FYmKrhTbF5cVf9go3HjlG4dvyr+Z3JS0qavEuWTPZtJm6ebe"
"LZ5bDpaql+aXDm4N2dq0Dd9WtO319kXbL5fNKNu7g7ZDuaO/PLi8ZafJzs07P1SkVPRU+lQ2"
"7tLdtWHX+G7R7ht7vPY07NXbW7z3/T7JvttVAVVN1WbVZftJ+7P3P66Jqun4lvttXa1ObXHt"
"xwPSA/0HIw6217nU1R3SPVRSj9Yr60cOxx++/p3vdy0NNg1VjZzG4iNwRHnk6fcJ3/ceDTra"
"dox7rOEH0x92HWcdL2pCmvKaRptTmvtbYlu6T8w+0dbq3nr8R9sfD5w0PFl5SvNUyWna6YLT"
"k2fyz4ydlZ19fi753GDborZ752PO32oPb++6EHTh0kX/i+c7vDvOXPK4dPKy2+UTV7hXmq86"
"X23qdOo8/pPTT8e7nLuarrlca7nuer21e2b36RueN87d9L158Rb/1tWeOT3dvfN6b/fF9/Xf"
"Ft1+cif9zsu72Xcn7q28T7xf9EDtQdlD3YfVP1v+3Njv3H9qwHeg89HcR/cGhYPP/pH1jw9D"
"BY+Zj8uGDYbrnjg+OTniP3L96fynQ89kzyaeF/6i/suuFxYvfvjV69fO0ZjRoZfyl5O/bXyl"
"/erA6xmv28bCxh6+yXgzMV70VvvtwXfcdx3vo98PT+R8IH8o/2j5sfVT0Kf7kxmTk/8EA5jz"
"/GMzLdsAAAAgY0hSTQAAeiUAAICDAAD5/wAAgOkAAHUwAADqYAAAOpgAABdvkl/FRgAAAGdJ"
"REFUeNrs0QENAAAIwzDAv+djA5JOwtpJSncaC4AICBABASIgQAQEiIAICBABASIgQAQEiIAI"
"CBABASIgQAQEiIAICBABASIgQAQEiIAICBABASIgQAQEiIAICBABedoCAAD//wMA/FsDY7NR"
"5NQAAAAASUVORK5CYII=")
getBgrBottombarData = BgrBottombar.GetData
getBgrBottombarImage = BgrBottombar.GetImage
getBgrBottombarBitmap = BgrBottombar.GetBitmap
#----------------------------------------------------------------------
BgrPeakEditor = PyEmbeddedImage(
"iVBORw0KGgoAAAANSUhEUgAAACMAAADICAYAAABiWlgYAAAACXBIWXMAAAsTAAALEwEAmpwY"
"AAAKT2lDQ1BQaG90b3Nob3AgSUNDIHByb2ZpbGUAAHjanVNnVFPpFj333vRCS4iAlEtvUhUI"
"IFJCi4AUkSYqIQkQSoghodkVUcERRUUEG8igiAOOjoCMFVEsDIoK2AfkIaKOg6OIisr74Xuj"
"a9a89+bN/rXXPues852zzwfACAyWSDNRNYAMqUIeEeCDx8TG4eQuQIEKJHAAEAizZCFz/SMB"
"APh+PDwrIsAHvgABeNMLCADATZvAMByH/w/qQplcAYCEAcB0kThLCIAUAEB6jkKmAEBGAYCd"
"mCZTAKAEAGDLY2LjAFAtAGAnf+bTAICd+Jl7AQBblCEVAaCRACATZYhEAGg7AKzPVopFAFgw"
"ABRmS8Q5ANgtADBJV2ZIALC3AMDOEAuyAAgMADBRiIUpAAR7AGDIIyN4AISZABRG8lc88Suu"
"EOcqAAB4mbI8uSQ5RYFbCC1xB1dXLh4ozkkXKxQ2YQJhmkAuwnmZGTKBNA/g88wAAKCRFRHg"
"g/P9eM4Ors7ONo62Dl8t6r8G/yJiYuP+5c+rcEAAAOF0ftH+LC+zGoA7BoBt/qIl7gRoXgug"
"dfeLZrIPQLUAoOnaV/Nw+H48PEWhkLnZ2eXk5NhKxEJbYcpXff5nwl/AV/1s+X48/Pf14L7i"
"JIEyXYFHBPjgwsz0TKUcz5IJhGLc5o9H/LcL//wd0yLESWK5WCoU41EScY5EmozzMqUiiUKS"
"KcUl0v9k4t8s+wM+3zUAsGo+AXuRLahdYwP2SycQWHTA4vcAAPK7b8HUKAgDgGiD4c93/+8/"
"/UegJQCAZkmScQAAXkQkLlTKsz/HCAAARKCBKrBBG/TBGCzABhzBBdzBC/xgNoRCJMTCQhBC"
"CmSAHHJgKayCQiiGzbAdKmAv1EAdNMBRaIaTcA4uwlW4Dj1wD/phCJ7BKLyBCQRByAgTYSHa"
"iAFiilgjjggXmYX4IcFIBBKLJCDJiBRRIkuRNUgxUopUIFVIHfI9cgI5h1xGupE7yAAygvyG"
"vEcxlIGyUT3UDLVDuag3GoRGogvQZHQxmo8WoJvQcrQaPYw2oefQq2gP2o8+Q8cwwOgYBzPE"
"bDAuxsNCsTgsCZNjy7EirAyrxhqwVqwDu4n1Y8+xdwQSgUXACTYEd0IgYR5BSFhMWE7YSKgg"
"HCQ0EdoJNwkDhFHCJyKTqEu0JroR+cQYYjIxh1hILCPWEo8TLxB7iEPENyQSiUMyJ7mQAkmx"
"pFTSEtJG0m5SI+ksqZs0SBojk8naZGuyBzmULCAryIXkneTD5DPkG+Qh8lsKnWJAcaT4U+Io"
"UspqShnlEOU05QZlmDJBVaOaUt2ooVQRNY9aQq2htlKvUYeoEzR1mjnNgxZJS6WtopXTGmgX"
"aPdpr+h0uhHdlR5Ol9BX0svpR+iX6AP0dwwNhhWDx4hnKBmbGAcYZxl3GK+YTKYZ04sZx1Qw"
"NzHrmOeZD5lvVVgqtip8FZHKCpVKlSaVGyovVKmqpqreqgtV81XLVI+pXlN9rkZVM1PjqQnU"
"lqtVqp1Q61MbU2epO6iHqmeob1Q/pH5Z/YkGWcNMw09DpFGgsV/jvMYgC2MZs3gsIWsNq4Z1"
"gTXEJrHN2Xx2KruY/R27iz2qqaE5QzNKM1ezUvOUZj8H45hx+Jx0TgnnKKeX836K3hTvKeIp"
"G6Y0TLkxZVxrqpaXllirSKtRq0frvTau7aedpr1Fu1n7gQ5Bx0onXCdHZ4/OBZ3nU9lT3acK"
"pxZNPTr1ri6qa6UbobtEd79up+6Ynr5egJ5Mb6feeb3n+hx9L/1U/W36p/VHDFgGswwkBtsM"
"zhg8xTVxbzwdL8fb8VFDXcNAQ6VhlWGX4YSRudE8o9VGjUYPjGnGXOMk423GbcajJgYmISZL"
"TepN7ppSTbmmKaY7TDtMx83MzaLN1pk1mz0x1zLnm+eb15vft2BaeFostqi2uGVJsuRaplnu"
"trxuhVo5WaVYVVpds0atna0l1rutu6cRp7lOk06rntZnw7Dxtsm2qbcZsOXYBtuutm22fWFn"
"Yhdnt8Wuw+6TvZN9un2N/T0HDYfZDqsdWh1+c7RyFDpWOt6azpzuP33F9JbpL2dYzxDP2DPj"
"thPLKcRpnVOb00dnF2e5c4PziIuJS4LLLpc+Lpsbxt3IveRKdPVxXeF60vWdm7Obwu2o26/u"
"Nu5p7ofcn8w0nymeWTNz0MPIQ+BR5dE/C5+VMGvfrH5PQ0+BZ7XnIy9jL5FXrdewt6V3qvdh"
"7xc+9j5yn+M+4zw33jLeWV/MN8C3yLfLT8Nvnl+F30N/I/9k/3r/0QCngCUBZwOJgUGBWwL7"
"+Hp8Ib+OPzrbZfay2e1BjKC5QRVBj4KtguXBrSFoyOyQrSH355jOkc5pDoVQfujW0Adh5mGL"
"w34MJ4WHhVeGP45wiFga0TGXNXfR3ENz30T6RJZE3ptnMU85ry1KNSo+qi5qPNo3ujS6P8Yu"
"ZlnM1VidWElsSxw5LiquNm5svt/87fOH4p3iC+N7F5gvyF1weaHOwvSFpxapLhIsOpZATIhO"
"OJTwQRAqqBaMJfITdyWOCnnCHcJnIi/RNtGI2ENcKh5O8kgqTXqS7JG8NXkkxTOlLOW5hCep"
"kLxMDUzdmzqeFpp2IG0yPTq9MYOSkZBxQqohTZO2Z+pn5mZ2y6xlhbL+xW6Lty8elQfJa7OQ"
"rAVZLQq2QqboVFoo1yoHsmdlV2a/zYnKOZarnivN7cyzytuQN5zvn//tEsIS4ZK2pYZLVy0d"
"WOa9rGo5sjxxedsK4xUFK4ZWBqw8uIq2Km3VT6vtV5eufr0mek1rgV7ByoLBtQFr6wtVCuWF"
"fevc1+1dT1gvWd+1YfqGnRs+FYmKrhTbF5cVf9go3HjlG4dvyr+Z3JS0qavEuWTPZtJm6ebe"
"LZ5bDpaql+aXDm4N2dq0Dd9WtO319kXbL5fNKNu7g7ZDuaO/PLi8ZafJzs07P1SkVPRU+lQ2"
"7tLdtWHX+G7R7ht7vPY07NXbW7z3/T7JvttVAVVN1WbVZftJ+7P3P66Jqun4lvttXa1ObXHt"
"xwPSA/0HIw6217nU1R3SPVRSj9Yr60cOxx++/p3vdy0NNg1VjZzG4iNwRHnk6fcJ3/ceDTra"
"dox7rOEH0x92HWcdL2pCmvKaRptTmvtbYlu6T8w+0dbq3nr8R9sfD5w0PFl5SvNUyWna6YLT"
"k2fyz4ydlZ19fi753GDborZ752PO32oPb++6EHTh0kX/i+c7vDvOXPK4dPKy2+UTV7hXmq86"
"X23qdOo8/pPTT8e7nLuarrlca7nuer21e2b36RueN87d9L158Rb/1tWeOT3dvfN6b/fF9/Xf"
"Ft1+cif9zsu72Xcn7q28T7xf9EDtQdlD3YfVP1v+3Njv3H9qwHeg89HcR/cGhYPP/pH1jw9D"
"BY+Zj8uGDYbrnjg+OTniP3L96fynQ89kzyaeF/6i/suuFxYvfvjV69fO0ZjRoZfyl5O/bXyl"
"/erA6xmv28bCxh6+yXgzMV70VvvtwXfcdx3vo98PT+R8IH8o/2j5sfVT0Kf7kxmTk/8EA5jz"
"/GMzLdsAAAAgY0hSTQAAeiUAAICDAAD5/wAAgOkAAHUwAADqYAAAOpgAABdvkl/FRgAAAJFJ"
"REFUeNrszjEBAAAIAyC1f+fZwcsDEtBJ6oupR2RkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRk"
"ZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRk"
"ZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZG4WAAD//wMAvUcEjQNPYZUAAAAASUVORK5C"
"YII=")
getBgrPeakEditorData = BgrPeakEditor.GetData
getBgrPeakEditorImage = BgrPeakEditor.GetImage
getBgrPeakEditorBitmap = BgrPeakEditor.GetBitmap
#----------------------------------------------------------------------
BulletsOn = PyEmbeddedImage(
"iVBORw0KGgoAAAANSUhEUgAAADQAAAAMCAYAAAAtUZ4rAAAAGXRFWHRTb2Z0d2FyZQBBZG9i"
"ZSBJbWFnZVJlYWR5ccllPAAAA2ZpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADw/eHBhY2tl"
"dCBiZWdpbj0i77u/IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+IDx4OnhtcG1l"
"dGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDUu"
"MC1jMDYwIDYxLjEzNDc3NywgMjAxMC8wMi8xMi0xNzozMjowMCAgICAgICAgIj4gPHJkZjpS"
"REYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgt"
"bnMjIj4gPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIgeG1sbnM6eG1wTU09Imh0dHA6"
"Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9tbS8iIHhtbG5zOnN0UmVmPSJodHRwOi8vbnMuYWRv"
"YmUuY29tL3hhcC8xLjAvc1R5cGUvUmVzb3VyY2VSZWYjIiB4bWxuczp4bXA9Imh0dHA6Ly9u"
"cy5hZG9iZS5jb20veGFwLzEuMC8iIHhtcE1NOk9yaWdpbmFsRG9jdW1lbnRJRD0ieG1wLmRp"
"ZDowMTgwMTE3NDA3MjA2ODExOEY2MkM3NEIxODVDNUEwRCIgeG1wTU06RG9jdW1lbnRJRD0i"
"eG1wLmRpZDo4QUVFQjM0RTU5NDYxMUUxODg5RTk0RjZERTEwMDRCQSIgeG1wTU06SW5zdGFu"
"Y2VJRD0ieG1wLmlpZDo4QUVFQjM0RDU5NDYxMUUxODg5RTk0RjZERTEwMDRCQSIgeG1wOkNy"
"ZWF0b3JUb29sPSJBZG9iZSBQaG90b3Nob3AgQ1M0IE1hY2ludG9zaCI+IDx4bXBNTTpEZXJp"
"dmVkRnJvbSBzdFJlZjppbnN0YW5jZUlEPSJ4bXAuaWlkOjAyODAxMTc0MDcyMDY4MTE5MkIw"
"QjYyNkVBQTcyREU0IiBzdFJlZjpkb2N1bWVudElEPSJ4bXAuZGlkOjAxODAxMTc0MDcyMDY4"
"MTE4RjYyQzc0QjE4NUM1QTBEIi8+IDwvcmRmOkRlc2NyaXB0aW9uPiA8L3JkZjpSREY+IDwv"
"eDp4bXBtZXRhPiA8P3hwYWNrZXQgZW5kPSJyIj8+5CVwSwAAANdJREFUeNrcVkEOgzAMw6jq"
"/9/LpWMMkAlOSrdyGEhI1IrSODZpUUoZnvSACQGQ7OYY/C0hpdiMN5GixqCXA9acp3wWXz4C"
"ZZoJ2Vy91H3XwDUxxniygFDG3UB1a23QHW5alDBkdidseFJd8AjWlBFkIOImWmZygcQ961H+"
"Q+BoLba9d5ExuacI97aLGv6zQlfJqD1YmQablk/4wXK7akkNgW9/WEvmYr5cUWQIBhZsI8bG"
"YqvhFTLZWedKnKxL1RaO7Wjs8lnjjftuh6Vf36mBeNrV5yXAALCAmBce7Z1kAAAAAElFTkSu"
"QmCC")
getBulletsOnData = BulletsOn.GetData
getBulletsOnImage = BulletsOn.GetImage
getBulletsOnBitmap = BulletsOn.GetBitmap
#----------------------------------------------------------------------
BulletsOff = PyEmbeddedImage(
"iVBORw0KGgoAAAANSUhEUgAAADQAAAAMCAYAAAAtUZ4rAAAAGXRFWHRTb2Z0d2FyZQBBZG9i"
"ZSBJbWFnZVJlYWR5ccllPAAAA2ZpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADw/eHBhY2tl"
"dCBiZWdpbj0i77u/IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+IDx4OnhtcG1l"
"dGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDUu"
"MC1jMDYwIDYxLjEzNDc3NywgMjAxMC8wMi8xMi0xNzozMjowMCAgICAgICAgIj4gPHJkZjpS"
"REYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgt"
"bnMjIj4gPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIgeG1sbnM6eG1wTU09Imh0dHA6"
"Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9tbS8iIHhtbG5zOnN0UmVmPSJodHRwOi8vbnMuYWRv"
"YmUuY29tL3hhcC8xLjAvc1R5cGUvUmVzb3VyY2VSZWYjIiB4bWxuczp4bXA9Imh0dHA6Ly9u"
"cy5hZG9iZS5jb20veGFwLzEuMC8iIHhtcE1NOk9yaWdpbmFsRG9jdW1lbnRJRD0ieG1wLmRp"
"ZDowMTgwMTE3NDA3MjA2ODExOEY2MkM3NEIxODVDNUEwRCIgeG1wTU06RG9jdW1lbnRJRD0i"
"eG1wLmRpZDpBMzYzODFDMzU5NDYxMUUxODg5RTk0RjZERTEwMDRCQSIgeG1wTU06SW5zdGFu"
"Y2VJRD0ieG1wLmlpZDpBMzYzODFDMjU5NDYxMUUxODg5RTk0RjZERTEwMDRCQSIgeG1wOkNy"
"ZWF0b3JUb29sPSJBZG9iZSBQaG90b3Nob3AgQ1M0IE1hY2ludG9zaCI+IDx4bXBNTTpEZXJp"
"dmVkRnJvbSBzdFJlZjppbnN0YW5jZUlEPSJ4bXAuaWlkOjAyODAxMTc0MDcyMDY4MTE5MkIw"
"QjYyNkVBQTcyREU0IiBzdFJlZjpkb2N1bWVudElEPSJ4bXAuZGlkOjAxODAxMTc0MDcyMDY4"
"MTE4RjYyQzc0QjE4NUM1QTBEIi8+IDwvcmRmOkRlc2NyaXB0aW9uPiA8L3JkZjpSREY+IDwv"
"eDp4bXBtZXRhPiA8P3hwYWNrZXQgZW5kPSJyIj8+zVimgAAAANxJREFUeNrcltEOhSAIhuWM"
"+a4+ke/ajZWzhgiKHc/Fya2tqAEfP0qQUnJvWkCBYowiXQgB/gUIheSbj07QGShSGJD8PVnF"
"Z+OP25Erc9x34SZgzpWDreomIVZjx4EyKpT0rihZFWXhqopTYiQOiwLxI3UUGKmqG3n0VxzN"
"rrUe8V/t+w/fP9f1Kxjme+vZe62n5fi1QlYYKQZVZqJNs0Ks5W7VcHTCGaFEGKM/P1DEKaPE"
"ETD92B5V1HoSKTA8eT+wT+eVB6s2UHtDlc4ayyxbMINMBYS3/frsAgwAO46VakCchWcAAAAA"
"SUVORK5CYII=")
getBulletsOffData = BulletsOff.GetData
getBulletsOffImage = BulletsOff.GetImage
getBulletsOffBitmap = BulletsOff.GetBitmap
#----------------------------------------------------------------------
Tools = PyEmbeddedImage(
"iVBORw0KGgoAAAANSUhEUgAAAfoAAAAXCAYAAADjuI2hAAAACXBIWXMAAAsTAAALEwEAmpwY"
"AAAKT2lDQ1BQaG90b3Nob3AgSUNDIHByb2ZpbGUAAHjanVNnVFPpFj333vRCS4iAlEtvUhUI"
"IFJCi4AUkSYqIQkQSoghodkVUcERRUUEG8igiAOOjoCMFVEsDIoK2AfkIaKOg6OIisr74Xuj"
"a9a89+bN/rXXPues852zzwfACAyWSDNRNYAMqUIeEeCDx8TG4eQuQIEKJHAAEAizZCFz/SMB"
"APh+PDwrIsAHvgABeNMLCADATZvAMByH/w/qQplcAYCEAcB0kThLCIAUAEB6jkKmAEBGAYCd"
"mCZTAKAEAGDLY2LjAFAtAGAnf+bTAICd+Jl7AQBblCEVAaCRACATZYhEAGg7AKzPVopFAFgw"
"ABRmS8Q5ANgtADBJV2ZIALC3AMDOEAuyAAgMADBRiIUpAAR7AGDIIyN4AISZABRG8lc88Suu"
"EOcqAAB4mbI8uSQ5RYFbCC1xB1dXLh4ozkkXKxQ2YQJhmkAuwnmZGTKBNA/g88wAAKCRFRHg"
"g/P9eM4Ors7ONo62Dl8t6r8G/yJiYuP+5c+rcEAAAOF0ftH+LC+zGoA7BoBt/qIl7gRoXgug"
"dfeLZrIPQLUAoOnaV/Nw+H48PEWhkLnZ2eXk5NhKxEJbYcpXff5nwl/AV/1s+X48/Pf14L7i"
"JIEyXYFHBPjgwsz0TKUcz5IJhGLc5o9H/LcL//wd0yLESWK5WCoU41EScY5EmozzMqUiiUKS"
"KcUl0v9k4t8s+wM+3zUAsGo+AXuRLahdYwP2SycQWHTA4vcAAPK7b8HUKAgDgGiD4c93/+8/"
"/UegJQCAZkmScQAAXkQkLlTKsz/HCAAARKCBKrBBG/TBGCzABhzBBdzBC/xgNoRCJMTCQhBC"
"CmSAHHJgKayCQiiGzbAdKmAv1EAdNMBRaIaTcA4uwlW4Dj1wD/phCJ7BKLyBCQRByAgTYSHa"
"iAFiilgjjggXmYX4IcFIBBKLJCDJiBRRIkuRNUgxUopUIFVIHfI9cgI5h1xGupE7yAAygvyG"
"vEcxlIGyUT3UDLVDuag3GoRGogvQZHQxmo8WoJvQcrQaPYw2oefQq2gP2o8+Q8cwwOgYBzPE"
"bDAuxsNCsTgsCZNjy7EirAyrxhqwVqwDu4n1Y8+xdwQSgUXACTYEd0IgYR5BSFhMWE7YSKgg"
"HCQ0EdoJNwkDhFHCJyKTqEu0JroR+cQYYjIxh1hILCPWEo8TLxB7iEPENyQSiUMyJ7mQAkmx"
"pFTSEtJG0m5SI+ksqZs0SBojk8naZGuyBzmULCAryIXkneTD5DPkG+Qh8lsKnWJAcaT4U+Io"
"UspqShnlEOU05QZlmDJBVaOaUt2ooVQRNY9aQq2htlKvUYeoEzR1mjnNgxZJS6WtopXTGmgX"
"aPdpr+h0uhHdlR5Ol9BX0svpR+iX6AP0dwwNhhWDx4hnKBmbGAcYZxl3GK+YTKYZ04sZx1Qw"
"NzHrmOeZD5lvVVgqtip8FZHKCpVKlSaVGyovVKmqpqreqgtV81XLVI+pXlN9rkZVM1PjqQnU"
"lqtVqp1Q61MbU2epO6iHqmeob1Q/pH5Z/YkGWcNMw09DpFGgsV/jvMYgC2MZs3gsIWsNq4Z1"
"gTXEJrHN2Xx2KruY/R27iz2qqaE5QzNKM1ezUvOUZj8H45hx+Jx0TgnnKKeX836K3hTvKeIp"
"G6Y0TLkxZVxrqpaXllirSKtRq0frvTau7aedpr1Fu1n7gQ5Bx0onXCdHZ4/OBZ3nU9lT3acK"
"pxZNPTr1ri6qa6UbobtEd79up+6Ynr5egJ5Mb6feeb3n+hx9L/1U/W36p/VHDFgGswwkBtsM"
"zhg8xTVxbzwdL8fb8VFDXcNAQ6VhlWGX4YSRudE8o9VGjUYPjGnGXOMk423GbcajJgYmISZL"
"TepN7ppSTbmmKaY7TDtMx83MzaLN1pk1mz0x1zLnm+eb15vft2BaeFostqi2uGVJsuRaplnu"
"trxuhVo5WaVYVVpds0atna0l1rutu6cRp7lOk06rntZnw7Dxtsm2qbcZsOXYBtuutm22fWFn"
"Yhdnt8Wuw+6TvZN9un2N/T0HDYfZDqsdWh1+c7RyFDpWOt6azpzuP33F9JbpL2dYzxDP2DPj"
"thPLKcRpnVOb00dnF2e5c4PziIuJS4LLLpc+Lpsbxt3IveRKdPVxXeF60vWdm7Obwu2o26/u"
"Nu5p7ofcn8w0nymeWTNz0MPIQ+BR5dE/C5+VMGvfrH5PQ0+BZ7XnIy9jL5FXrdewt6V3qvdh"
"7xc+9j5yn+M+4zw33jLeWV/MN8C3yLfLT8Nvnl+F30N/I/9k/3r/0QCngCUBZwOJgUGBWwL7"
"+Hp8Ib+OPzrbZfay2e1BjKC5QRVBj4KtguXBrSFoyOyQrSH355jOkc5pDoVQfujW0Adh5mGL"
"w34MJ4WHhVeGP45wiFga0TGXNXfR3ENz30T6RJZE3ptnMU85ry1KNSo+qi5qPNo3ujS6P8Yu"
"ZlnM1VidWElsSxw5LiquNm5svt/87fOH4p3iC+N7F5gvyF1weaHOwvSFpxapLhIsOpZATIhO"
"OJTwQRAqqBaMJfITdyWOCnnCHcJnIi/RNtGI2ENcKh5O8kgqTXqS7JG8NXkkxTOlLOW5hCep"
"kLxMDUzdmzqeFpp2IG0yPTq9MYOSkZBxQqohTZO2Z+pn5mZ2y6xlhbL+xW6Lty8elQfJa7OQ"
"rAVZLQq2QqboVFoo1yoHsmdlV2a/zYnKOZarnivN7cyzytuQN5zvn//tEsIS4ZK2pYZLVy0d"
"WOa9rGo5sjxxedsK4xUFK4ZWBqw8uIq2Km3VT6vtV5eufr0mek1rgV7ByoLBtQFr6wtVCuWF"
"fevc1+1dT1gvWd+1YfqGnRs+FYmKrhTbF5cVf9go3HjlG4dvyr+Z3JS0qavEuWTPZtJm6ebe"
"LZ5bDpaql+aXDm4N2dq0Dd9WtO319kXbL5fNKNu7g7ZDuaO/PLi8ZafJzs07P1SkVPRU+lQ2"
"7tLdtWHX+G7R7ht7vPY07NXbW7z3/T7JvttVAVVN1WbVZftJ+7P3P66Jqun4lvttXa1ObXHt"
"xwPSA/0HIw6217nU1R3SPVRSj9Yr60cOxx++/p3vdy0NNg1VjZzG4iNwRHnk6fcJ3/ceDTra"
"dox7rOEH0x92HWcdL2pCmvKaRptTmvtbYlu6T8w+0dbq3nr8R9sfD5w0PFl5SvNUyWna6YLT"
"k2fyz4ydlZ19fi753GDborZ752PO32oPb++6EHTh0kX/i+c7vDvOXPK4dPKy2+UTV7hXmq86"
"X23qdOo8/pPTT8e7nLuarrlca7nuer21e2b36RueN87d9L158Rb/1tWeOT3dvfN6b/fF9/Xf"
"Ft1+cif9zsu72Xcn7q28T7xf9EDtQdlD3YfVP1v+3Njv3H9qwHeg89HcR/cGhYPP/pH1jw9D"
"BY+Zj8uGDYbrnjg+OTniP3L96fynQ89kzyaeF/6i/suuFxYvfvjV69fO0ZjRoZfyl5O/bXyl"
"/erA6xmv28bCxh6+yXgzMV70VvvtwXfcdx3vo98PT+R8IH8o/2j5sfVT0Kf7kxmTk/8EA5jz"
"/GMzLdsAAAAgY0hSTQAAeiUAAICDAAD5/wAAgOkAAHUwAADqYAAAOpgAABdvkl/FRgAABwVJ"
"REFUeNrsXd2W8zYIND15/1emFxvnKGRAgGRvtp25Sb91YiPMz4CwK6p6EARBEATx38Q/VAFB"
"EARBMNETBEEQBMFETxAEQRAEEz1BEARBELfg4R0QETSlJyvDe845pz/LXjN5fvmGAUQRUVUV"
"ETmQPM+1yP95WJI6IC62ra0xYjynqspf8qdv9bVKzoh0/tdiyW55H0XlqvxkqLbgx3Gcn9P7"
"Vvz+1Ya2TelGv/rzp1fiH9f7wwR+jPibjPBNdlU9PMKyQz/P6031j5zD/s1zoOC3MJh0j6F1"
"noTvqc/DkwOcfyrvcH/gsdO2zHFX13eSaRszLvABMffodd1mnDtlfRH530xuwGcl8ONSfLc2"
"OK7Xyj/KGB2rxN5B9ta9Tqzn9AtrG98Yi22u/PCbR8PIFCi54xTavSkd4684z3jTdyf9jByj"
"gf020VlwrPL5TcIRYythEBp+h+zzzKTRd27V9bhOJO8px2gvw/dkohOxevOODeQyc950slsh"
"qIAIv92zzdWyDjKf8pcKjJGcG31+JTE/fS0ggN8GTcYfSdxneN9scWVi8AcZ3Fl5d0mhiQfR"
"53uiNwvvOMs2hnVXu6dARnRTxT+y/kxS/aYWoJoqsJXMEwTCXkOs/sG5vOBsndmzVe/vEtjA"
"xzHgfDNSi8gdSr4tnV/lYhN/eQXKagUE1m0/r1rLqmJ1c5KXqFKrXMuzG/D7Vuw/zw1s/627"
"YbtG3W4JusYikRRA+mQWu2whUeyEtL8DuuPe5wET/c0VztdW9MaorEFZ9p9O+qAiGys6AeeU"
"WXCPWq7dY5nAscjMYXvM7HHC7sbpUM52gSRsSVaqAUCGU8c6NryQ1KOAqu/mI7v8VwyJfbV0"
"s1svVxcHTvWlQRIpdbruSvIDESx3HCayrhRs6tiwevGmYnvB9zsEULKFy9D1kBvb9rM1SeZz"
"lPWRdaxxwckb8Ccr+oB1vtqalYq/G8gzgd4wO9t2+jgGEpLeQOiggzntsbduh3McsutxzYbQ"
"QDv1WnBJW9XmsRJBHWSUqANU9C3Uure2LQvXkETl9Ktdqed6ZVdF71XXZt+6SpJLFVvlXkV+"
"Z+JESWbney6JKnZ6VhKj5+etdrkjt96wvTndi/dkSFX0NuAsOm32pkhRAa2qcpFNehX/rYEr"
"MDidtKxaTuYRvoK8sD1mv+OtY6z2wdrUaVNmAke2rR+RpCmBCmZAKgR6TM5h4HrqSTzS1LRb"
"nZDTbrvdko63z8peZjRUDGJZi6ANtggrZusrmapw6FYJCu5gaDfrc278AtV3KDMgMGWdbQl+"
"zUITDdpNOid3Dodrp5KPiNkjowiw2NVJ8G2Kso+pzW66nb6eVTxHvBcUVfypJGY7JcgAi3rO"
"yNtO8hHLnQWxTHvM6ZxkA5ZGyW6ylmxFL81jsyT9NhwVzS54xDKTQC7oziBbWUqeThI+yaFu"
"GsYbuxlXEHQBZKVFIGz8NXMrsvEepmW2JMrbo0Z+F3XWOoXiSrIPyLcc+fme40LbGXWWruCr"
"FX3UnuzuPR7mUaJtRCCx6OzQhFZaMjuHpAC5ipwhCqbdY9UkiEjUalIR21ECFXs0bd6xjcrE"
"rjaPZSvQq+y/HQiTVYfsqJBvGjgUEDxL8gbvwPjws0YVDjs8aFuqaSeySWZJdq+Wc8exb3AS"
"3b8d55SLDPWoVvDdRK8Bs9vZmrBsu3PeJeZlp58Ns9WgIqsGaXdCPBvszpZs0/C2PqI0Pk41"
"MbxKewySkzMAjaTN26P3qs3ic7mlyfuZjoPOxqmLWVs841fi/NtrQ+qBh1C7xKhlZx7ZaRIA"
"b35CVpLHaK9WJq/b4Lwno6yXxcl1GHtGgr5LZlvMmTmG8vnQ/Tfd2Y4+Qx1Yn3N88Irkvn3i"
"7xEEbnvRj0/EDDdVcavngJVwgTlIQUbr7LvbOyvPNO9gka2E7+h/S3sMBaDZHv1Mp4nqVZwE"
"mj1WZe1W3uy5ZNYG9NYGHmeUYjCSjUHwLd6sdjtGmcCwarWid8kBGP4UsIZ0tXlxYkFbR2WZ"
"rZzopThm5qBTGHldDf2lWLczOXs+q9mt04ne5BFdOPEmsupilp4ZClpwWpGvSFBmVbEmA2pE"
"lqZ/O75gyK/4uSXwm4o9CkDZTs6Odz5ElW+2Kn45M3gznlftRy8V6q6v+3x6+jHF5ozJlg4d"
"Orfzngop+oZEnZdgqv1WPwaJFcYgUK1mZd5d8EEZnBdHLesgkj0zwOt1QzauHW2NVP8bPop0"
"yfvovQnq1XODajodSJIvOJjdVLfVSKwzZ2dPcvtriScBItt5Cp8pvimoe1sJUSv/OMBb8oIt"
"kLSffeG709Ox4lveVx+16xlniC0JmiAIgiCIvwv+b2oJgiAIgomeIAiCIAgmeoIgCIIgmOgJ"
"giAIgrgH/wIAAP//AwCPTk5J9VUYhAAAAABJRU5ErkJggg==")
getToolsData = Tools.GetData
getToolsImage = Tools.GetImage
getToolsBitmap = Tools.GetBitmap
#----------------------------------------------------------------------
BottombarsOn = PyEmbeddedImage(
"iVBORw0KGgoAAAANSUhEUgAAASIAAABYCAYAAABRcPqlAAAAGXRFWHRTb2Z0d2FyZQBBZG9i"
"ZSBJbWFnZVJlYWR5ccllPAAAA2ZpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADw/eHBhY2tl"
"dCBiZWdpbj0i77u/IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+IDx4OnhtcG1l"
"dGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDUu"
"MC1jMDYwIDYxLjEzNDc3NywgMjAxMC8wMi8xMi0xNzozMjowMCAgICAgICAgIj4gPHJkZjpS"
"REYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgt"
"bnMjIj4gPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIgeG1sbnM6eG1wTU09Imh0dHA6"
"Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9tbS8iIHhtbG5zOnN0UmVmPSJodHRwOi8vbnMuYWRv"
"YmUuY29tL3hhcC8xLjAvc1R5cGUvUmVzb3VyY2VSZWYjIiB4bWxuczp4bXA9Imh0dHA6Ly9u"
"cy5hZG9iZS5jb20veGFwLzEuMC8iIHhtcE1NOk9yaWdpbmFsRG9jdW1lbnRJRD0ieG1wLmRp"
"ZDowOTgwMTE3NDA3MjA2ODExOTEwOURDQkFDQjFGMDFEOCIgeG1wTU06RG9jdW1lbnRJRD0i"
"eG1wLmRpZDo2OENDNENFMTlDQ0MxMUUxQUM4MkFCNUFERkQ0MDIwOSIgeG1wTU06SW5zdGFu"
"Y2VJRD0ieG1wLmlpZDo2OENDNENFMDlDQ0MxMUUxQUM4MkFCNUFERkQ0MDIwOSIgeG1wOkNy"
"ZWF0b3JUb29sPSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCI+IDx4bXBNTTpEZXJp"
"dmVkRnJvbSBzdFJlZjppbnN0YW5jZUlEPSJ4bXAuaWlkOjA0ODAxMTc0MDcyMDY4MTE4MDY2"
"QzM0Q0VBQTY0RjRFIiBzdFJlZjpkb2N1bWVudElEPSJ4bXAuZGlkOjA5ODAxMTc0MDcyMDY4"
"MTE5MTA5RENCQUNCMUYwMUQ4Ii8+IDwvcmRmOkRlc2NyaXB0aW9uPiA8L3JkZjpSREY+IDwv"
"eDp4bXBtZXRhPiA8P3hwYWNrZXQgZW5kPSJyIj8+4JE5yQAABcNJREFUeNrs3Y2y4igUhdHQ"
"5cPNI/fbpccZvY0IkSSQP9dXZbXXVgkENvsQwwnjOA4AsCeBEAEgRAAIESECQIgAECJCBIAQ"
"ASBES4Qo/DOMP5//rREBrOOXJgBAiAAIzWpDsygcy/JviBaaH9wOZQLgiABwRJPu5MWMPF+O"
"3AkAcEQALu6IEnfk8j2AfYUIAAgRAEIEAIQIACECAEIEgBABACECQIgAgBABIEQAQIgAEKKv"
"aqD/b/B1cy9AiDYTnSJPIXq+Z40wfdp5cvJ8/bb7AQhROpAuMRCericnMDlHlIrR/e857bBG"
"iIbh9bO2y8UVuGmC5YIRC/JCUZnLeBeeFUIGEKIja07OHeUcyNP9JGIwLhSWWSJ0LyMplxvC"
"d4VmV87ikYjPTyg2MejfnMmcY4nKG6dCrkT00vdkQ0ngjNizuuCOHutAIXr0cCYhcV8/j+c6"
"1L2ch8hxQhCaZQZj9wGx00JsNsz65EwW1u+Tc8o5Q5lT8NVC9FWkV8l6hEfJYvc4IfycEK4d"
"hrh8n18jKjiloYUzScrr4qaAyzsiv13ZN2QkQuCIrtYA01fmQuYHjqsdydpfVgOECAAIEQBC"
"BACECAAhAgBCBIAQAQAhAkCIAIAQASBEWx9gsgWGWxwws/88mbzRWL86qBAVMlrM2odnycnN"
"lFssM91FcaubcVvtPpDUNXciQovBsuDettwOlae82XlrIfq0j/mjXTcpc2lyhz34tEPjGD1q"
"BCj3/rmk3xFqhW/NiXw8ak96mBCPVYcyvO8I2fq7i2UWhCYM19wHaWzUXycnjwaTwqIyY+GJ"
"xe+o3CorOc5slK7xXpJjLAwrNq9PNjy7i1H2jvvktVMurJU65NRsmeZz6+jCpo4hrBSc9Ple"
"4jrWuLOG42PMOdwjOttboxPb0rG8CEtm8MTOJTTuIEXLG4lRGDptlbt00Nd+fSncnipv5bFM"
"bTZXTEyQ+WyPY6jZEbNZX8q8PvYqM504z+CIfs2sZC50CJUnosU6StPYPnJUb3X5EIK1mlGz"
"oUFUpybhw2MGnPNovnZyxOWjTqFwqAiNtyrzpy8f/Tze1lSwwftXO6ZGSh8+ifDzRHZwLVMz"
"f9g7HJTM8Rqie/Tz2GLz/NN21A+zRDEE63UVoqd9dnl6u241Y0mjdzhY6s+XE6JL7139XNTb"
"Kr5OM4fgtCHfWPF66Fnm2fqPdEIVotDZTYxXdJsTLqC2nlcMCVdd4W1gFA5rHAjRviHTyxpQ"
"ppzTOs4vzvQyzhSHZmWeOfy+dZ6Nw4oTmSY0rP17jsAsrmMsGg0HnYXhi4TzRH/meHLTK2qF"
"Wj47ECIAhAgACBEAQgQAhAgAIQIAQgSAEAEAIQJAiACAEA1/d03c8ua+rcvcOn1SqX65+/CW"
"3uJR04Z7nFsch19nOdB4k/st9lq5l7F1mQds01YZVGozW4yPdseXcaucmRfjRslFg3bLPWsm"
"T9/QZme/Yn0y/WzUZziimllx7r+LZ+vnzJhsZP8yg9fmI5vrhpLB8+YaWpYZ5VV7G5Rzcq7N"
"qFuaRqnkipqLYqGMl03lOSJCdDTiwZlmsxh7bAj++M64zNjdnZ7MzpNhon7ZdljZtsAyIbpb"
"5aQDh1zYVXp9ZZiSpmDplZKlajbvNFtnXWSH9nypQ+T8Xv4vSrPUOuVOKIRtL5ONBWtCdLS1"
"kmKG1ej1nmFD1k20EKOJcCwXRjUN05I2DRs6vjHT1m/7KgvNvo/i5fs4y+majrfikm/ceUsz"
"adNBtGWZ6WX65Ltzz5tc1s+sf5Wet2zTt/Wo4W8a5G7nE9dyROOKx6pZe2LN4qWztuq0Nd/T"
"qsyasKsmHG5Qx7BDm/6kaYrOsytlHNFBDy66WhbPntHz/xxXy4SHW5VZciaPct6ep65hhSNK"
"65e6k2ZtmnE7RUeU5mfniAjR3sLTxGkos215S8LBteX6PREhAgBCBIAQAQAhAkCIAGAz/ggw"
"AKJULqU7XoPnAAAAAElFTkSuQmCC")
getBottombarsOnData = BottombarsOn.GetData
getBottombarsOnImage = BottombarsOn.GetImage
getBottombarsOnBitmap = BottombarsOn.GetBitmap
#----------------------------------------------------------------------
BottombarsOff = PyEmbeddedImage(
"iVBORw0KGgoAAAANSUhEUgAAASIAAABYCAYAAABRcPqlAAAAGXRFWHRTb2Z0d2FyZQBBZG9i"
"ZSBJbWFnZVJlYWR5ccllPAAAA2ZpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADw/eHBhY2tl"
"dCBiZWdpbj0i77u/IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+IDx4OnhtcG1l"
"dGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDUu"
"MC1jMDYwIDYxLjEzNDc3NywgMjAxMC8wMi8xMi0xNzozMjowMCAgICAgICAgIj4gPHJkZjpS"
"REYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgt"
"bnMjIj4gPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIgeG1sbnM6eG1wTU09Imh0dHA6"
"Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9tbS8iIHhtbG5zOnN0UmVmPSJodHRwOi8vbnMuYWRv"
"YmUuY29tL3hhcC8xLjAvc1R5cGUvUmVzb3VyY2VSZWYjIiB4bWxuczp4bXA9Imh0dHA6Ly9u"
"cy5hZG9iZS5jb20veGFwLzEuMC8iIHhtcE1NOk9yaWdpbmFsRG9jdW1lbnRJRD0ieG1wLmRp"
"ZDowOTgwMTE3NDA3MjA2ODExOTEwOURDQkFDQjFGMDFEOCIgeG1wTU06RG9jdW1lbnRJRD0i"
"eG1wLmRpZDo2OENDNENFNTlDQ0MxMUUxQUM4MkFCNUFERkQ0MDIwOSIgeG1wTU06SW5zdGFu"
"Y2VJRD0ieG1wLmlpZDo2OENDNENFNDlDQ0MxMUUxQUM4MkFCNUFERkQ0MDIwOSIgeG1wOkNy"
"ZWF0b3JUb29sPSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCI+IDx4bXBNTTpEZXJp"
"dmVkRnJvbSBzdFJlZjppbnN0YW5jZUlEPSJ4bXAuaWlkOjA0ODAxMTc0MDcyMDY4MTE4MDY2"
"QzM0Q0VBQTY0RjRFIiBzdFJlZjpkb2N1bWVudElEPSJ4bXAuZGlkOjA5ODAxMTc0MDcyMDY4"
"MTE5MTA5RENCQUNCMUYwMUQ4Ii8+IDwvcmRmOkRlc2NyaXB0aW9uPiA8L3JkZjpSREY+IDwv"
"eDp4bXBtZXRhPiA8P3hwYWNrZXQgZW5kPSJyIj8+WNWOjgAABclJREFUeNrsnQFypCAQRe3U"
"3P/K7E4yk7RMg4CNIr5XldqsSWRA+PxGpSWEsAAAnMkXTQAACBEAIEQ0AQAgRACAENEEAIAQ"
"AcDtebT8kYi87/kLt/8BAEcEAAgRAMBeikMrFY6Z/D+PuH+4E8oEABwRANyQmsVq7T6Cccwd"
"HA8AjggAYCxHpNeSRMQ8DgDQAs8BAQChGQAAQgQACBEAAEIEAAgRAABCBAAIEQAAQgQACBEA"
"AEIEAAgRAABCtMFzczb9ki8A+POgCVaiYx62fmfPy8JbO0/m/vRZLskLAEf05xKmcQq6Ls+B"
"rb+Wv03gVgKk635kO0QihgoBjugOYVnhz1uUqOVvwnPXyh2OCmAeRzSj5sTu6OVyxArfDKd0"
"hDCEn+JXIsTiFdzLESVmYR3SXDmLR4gHdbQW821D9OdycibaUcUhoLxF71VO/DuIEBCaze6O"
"Uo7I2ZlI6hxv3UuIHiIEtxWiu2TxCFa9ejiTrTteWoys8rhjBjiiyYmTBeREqFUQosXukBF+"
"nBAgRNbAnH1WTtyS9w6PpOB80uKmAKZ3RCQ+XE4NGREhQIjmcz7BcDvWk8t6EdtDDJpOgAjB"
"lOOQjg0AZ8MDjQCAEAEAIEQAgBABACBEAIAQAQAgRACAEAEAIEQAcDrDv+IRb4HBk+BQ2X/e"
"35rbu/z+kH41phB5vH3ecnG3NqKP3/zXQnXUy7heWTSiulonEo/B0rCTZJwt5ND2vbjwZffq"
"erWrq/ilytSJHkYX2q3QLKivEgGyfr+W+BxSKnx7LmRpVhK1L9Gy+O9VLepr6XTuZJkJoZFl"
"zn2QglN/zU4eDpNCU5laeLT4XTk0k8oLJUvnzeSjlD6yZbsLheW7Q8rP3qwfziU6dkkfn+qQ"
"udnSSp/UyYXlPoPsFJz4+7PENZSEiY7jI1gOd0Rn+3C6sJ6OZSUsxuDRzkWcO0jS8ioxkqXT"
"Vrmtg7709KlwO1fezs8imYGX6jvB+Nsen6FkR0y3vmQcD73KjCfOKziir8pKWqGDFF4Ij3WU"
"qtm88NxmXTZCMK8Z1QwNVJ1cwofXDFjz5dK+oy/ndAqFpSA0PqrM3748+nV87Kmgw+/vdkxO"
"Si9bIvy+kB1cS27ml7PDQZI5ziG6o19Hj9v3l+2oG7NEMgTrdReip33m9vRx3apiSaN3OJjq"
"z9MJ0dS3c9+LekfF16kEBXC5kC8UHJeeZV6t/5BOqEAUOruJMKPbzLiA0nrOaOF23eF1MArD"
"qhNCdG7ItFoDMsq5rC268cOPoVIc3Mq8cvj96Dwby44LGSc0LP1/jcA01zF6wvvIWB8Q4OlE"
"n3e3oFioecUDECIAmBa2AQEAhAgAACECAIQIAAAhAgCECAAAIQIAhAgAACECgNO51Euv710T"
"j3wa/Ogyj06flKqf9R5e6yseJW14xrUFHFFzZ1429lh2LO/wMgdsU68MKqWZLcKr3RmZOKL0"
"jNgCL0o2Ddoj96zJXr7FZ2e/ZH2MfhboMziiklmx9t/m2fo9M0Yb2a9m8NJ8ZLVuKBo8H67B"
"s0yVV+1jUNbkXKuoW5xGKeWK3EUxUcZqU3kcEUI0GnpwxtksQo8NwV/n1GXqqfryF9zYeVIy"
"9TPbYWfbArQJ0dMqRx1YrLArdXxnmBKnYOmVkqVoNu80W5suskN7ruqgnN/qZyrNknfKHUmE"
"bavJhgVrhGi0tZJkhlV1vGfYYLoJDzHKhGNWGOUapkVtKgc6vmC0tXxWm9DsbjwqB6gYAyR3"
"3MvOf6w/Rce9BTAkBsgoi8iebRrU2kzwFiarLxjtONICPQzqiMKOr12zdmbNYjVQvGbykvN4"
"lVkSdpWEww51lBPa9HfiUtcZEcIRpQfKKDP3K3/36vtXKl1xTngYl7n0KDPlHlN5yr3cptGm"
"vw8Serdp5rPqMrP1hnsw1JOsHndVagX0DmU63a2q7it7y+V5IoQIAOAweOkVABAiAACECAAQ"
"IgCAfwIMACXR9JmMQbIUAAAAAElFTkSuQmCC")
getBottombarsOffData = BottombarsOff.GetData
getBottombarsOffImage = BottombarsOff.GetImage
getBottombarsOffBitmap = BottombarsOff.GetBitmap
#----------------------------------------------------------------------
ToolbarsOn = PyEmbeddedImage(
"iVBORw0KGgoAAAANSUhEUgAAAOsAAADyCAYAAACs0zKGAAAAGXRFWHRTb2Z0d2FyZQBBZG9i"
"ZSBJbWFnZVJlYWR5ccllPAAAA2ZpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADw/eHBhY2tl"
"dCBiZWdpbj0i77u/IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+IDx4OnhtcG1l"
"dGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDUu"
"MC1jMDYwIDYxLjEzNDc3NywgMjAxMC8wMi8xMi0xNzozMjowMCAgICAgICAgIj4gPHJkZjpS"
"REYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgt"
"bnMjIj4gPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIgeG1sbnM6eG1wTU09Imh0dHA6"
"Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9tbS8iIHhtbG5zOnN0UmVmPSJodHRwOi8vbnMuYWRv"
"YmUuY29tL3hhcC8xLjAvc1R5cGUvUmVzb3VyY2VSZWYjIiB4bWxuczp4bXA9Imh0dHA6Ly9u"
"cy5hZG9iZS5jb20veGFwLzEuMC8iIHhtcE1NOk9yaWdpbmFsRG9jdW1lbnRJRD0ieG1wLmRp"
"ZDowMTgwMTE3NDA3MjA2ODExOTEwOURDQkFDQjFGMDFEOCIgeG1wTU06RG9jdW1lbnRJRD0i"
"eG1wLmRpZDpBMzYzODFDNzU5NDYxMUUxODg5RTk0RjZERTEwMDRCQSIgeG1wTU06SW5zdGFu"
"Y2VJRD0ieG1wLmlpZDpBMzYzODFDNjU5NDYxMUUxODg5RTk0RjZERTEwMDRCQSIgeG1wOkNy"
"ZWF0b3JUb29sPSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCI+IDx4bXBNTTpEZXJp"
"dmVkRnJvbSBzdFJlZjppbnN0YW5jZUlEPSJ4bXAuaWlkOjA2ODAxMTc0MDcyMDY4MTE4MDY2"
"QzM0Q0VBQTY0RjRFIiBzdFJlZjpkb2N1bWVudElEPSJ4bXAuZGlkOjAxODAxMTc0MDcyMDY4"
"MTE5MTA5RENCQUNCMUYwMUQ4Ii8+IDwvcmRmOkRlc2NyaXB0aW9uPiA8L3JkZjpSREY+IDwv"
"eDp4bXBtZXRhPiA8P3hwYWNrZXQgZW5kPSJyIj8+Bpgv3wAADlFJREFUeNrsnVuS2joURa1U"
"TyAj6nzeIeczmVCmoNskFnU41ltHfuC1qijAdGMbtL2PhLXtvPcLAJyfb3wEAIgVABArAGIF"
"AMQKACN8nHnj3H9LGKp2Xzcv7/3Pzd8uehnALZz10fhrlsnlD3EFgcnHlcJMviQeeylkcUOo"
"cE9nFYJbgosFQWREpYXlWh1Ur08I1CmH1et8CPbv3yBauJWzfjV4t4ogCKFWBF6IyUeElRN5"
"bH1OCTV2EPAJEQPcwlk3QgjOFRH2sLPGhJdan3bU2P/hrnCrPmuFqCydtXp9DyEKMcb6szgs"
"3KoMTpa9sVHYSDmrH+eV2Lg+VZY7vka4tbOGwR7dJ1wHg1zCybqdtWd9CcEiXriPWFeB+CU+"
"Ert5Lty1y1lb1ycdXQkWocLtnNXpxq/L0UTZajEa3N6hZUAJboBjPivAxfusAIBYAQCxAiBW"
"AECsAIBYARArACBWAECsALcVa4hUAYD5NJ1uqGbAyJkwBJgBXKQM9mGeqRRqj+vi1gBxPmrE"
"syxVEStBtE+XtXbWsC04NuCsFXpR90tKyL2uWrl+nBgQa0RwrkY8Io1wpL9aLUaxnAnngFiD"
"DkslreifFv+2V8DBdVPZSzgs3L7PujO+QrTh71zJlQFuK9ZKdx11Ua/6sC8J/evjTfo+rgqI"
"9Viq3ZIRYnh3iidFPNztcTmNmp9N9EkTrQJSV41DiAAndtYgdK9E3FKq03eFezlr4TdPp/qL"
"3kI8iSvHNT3GheG2ZTAAnAOmyAEgVgBArACIFQAQKwAgVgDECgCIFQAQKwBiBYDjyJ7IX5GJ"
"lKXzvOCXt1gy0+T0HNre84IJYoPLizW05QpRxsTWI/SaJMXUepyIfpk280ZN45u+PoCiWBtc"
"1YfkhoMoJi1efH0ARWeVzpEsFWWg94SYFVfhvBunmyyivdcHUF0GF/uYQchGGUytZfGQ08l0"
"ixBQXujD4qxwCN8qHESXvDPp7ef6yOOZ27jn+gCKYnUlV1XO82y0E0dVXWKZizzurRik0y6z"
"1wdgIdZU//NIJ/E4K9BnbSxJE+4ZkhD3hNFgoAzOuIdfL1fhE2Vkb98zCD773MLpxPbLknbz"
"PLKPOCscQi7dUDZOkgYBzipWALhOGQwAiBUAECsAYgUAxAoAiBUAsQIAYgUAxApwWT74CP5R"
"GWNDqBqcX6wtV0IfFEzxvQ5KI3ymSTyeIFqgDO4TuaUgY7fNQWnnaYAATWJ1kUa9dxkaxdjl"
"vLo9XXV11rC+ME0Q4HzOKvJxZ6T6OS3eghC8Cm2b5a6bA5Q6sDBtCc4l1uBekwWbLXVjgkwt"
"N3RWH8maIiECzivWCaKIiSTrnjkHNSyFN33WyER8n6oIAE7hrGum7veJIkkeKBLr8jv0WT1C"
"hcv1WVf+RBqqab8tl6a4w08mudFghArXEKu6KJNeNqMMrhGpn91nbakCAGbRe1LEjBFQlxFH"
"9ciwwRXdXO1yToyAU4p1J3QcaOtji3VXiRmhwu7iIN0Q4A37rACAWAEAsQIgVgBArACAWAEQ"
"KwAgVgBArABXofl0w8yJ+yT/AZxFrCFVMPHyIQkK6uDRdcCQs4lEIFrVssHtfnkfke/0smxZ"
"xvcRblQGK6GmQsXMBBhuqtEuKndJHyB8r2jC/6+JGFXLdjoQhfWGmzeclgjvXAYnHNTEVWON"
"MCx7TH0LzqMcyKLh+oFl3bsbcVCAcWdNNFwd1WmCwZzUXtG4xmWWB4jUJHem5MGwWE1FKh00"
"JtjH6yJhMSUaN7AfrnPZnn1zf+Q2wLXFOqtRtsTFuJEGrB0rBMPVLLOkUE3sGvsK79Nn3U2w"
"NUKz6OupEdndR4bF+7mafaQkxllH+nrT+6lhgEk2blE6mzTi3pHhnfrV9F0Ra3c/VfahjnDe"
"F7FYuexyzMhwzTbxcw1lcLNIY/3DYdGuP8dsriUjli3yfpmbsCgrh9pls50VEGt3YzZvTOH3"
"08hIcFFUhn1XV7l/bmA/vSir5b78fW5V1sN7QbohwBv3WQEAsQIAYgVArACAWAEAsQIgVgBA"
"rACIFQAQKwDYUH1ucGGO6SGJexbJhpn3DjxTCGPpgwCnE+vZUEFqJtP1CC2DdymDdWCYmyVC"
"ccuSymsaRE7PA7hmn1WIYspcTh2atiTmrIq5ra15TS37CnBNsYo5llMFW+OWct6pzELi6wT6"
"rMLNZjvOGjnqSm6ZmShu0l+NBZjhtnAZZ11HRL9PbMBZt2zpz44ItVB6A5zbWQV/IkIyCU7L"
"ueWM0V+9+pr3E1GkOC2c01lTjrfnRZImjf5Wr36NId2IFuBsfVavXGh3avuzluVvQrQMZsEl"
"yuCj0Jc7nHlxqNr7xXBbAPICIN0Q4A37rACAWAEAsQIgVgBArACAWAEQKwAgVgBArABXoep0"
"w8S5uMkLKxsHl4XzgRfr911er+YevZdBaaX7dyJ29fk91zd7/nT4/uX7h7Z2WbHGJmGHz7Rx"
"+Rkpnvub2f+eBtL6WWVfb2nIiXXLA+8MQTy3s+JzjEX5vFwJfkSIqY9QTcpwhged6PpLrw87"
"6xFClEdakbW0GDp50VVniTbzuZYOgCPbMF2cQx/Az8337K3bXKJC9MLJu9aVC0vItNHmA9G3"
"ji87NlPFLwdNmxtsIC53Hyv3jabnneU9SgezbmF3fk7Oav2Z99fJnLLkdobfSc3+NyWefDP4"
"8mIfgOUHGz5EZ7kuEQC3ce7El2chWj+wzFqkLlJ++qMcWKR/LNZlqSzHw63ghKMHmZbSulqw"
"HwMb9VaDKKKhvJQmq5hLonUdgu2dS9sr2FgZ7Sq2dXbpvzkwjqRv5P5XvRYLw3ODbSjWToIR"
"5Ereqs/5o+FLrj3Km3y5sdgUNXJn5S6bDzszupsSbW1+k0vFwuw0muyOGoMYEVnrwNLI/1uM"
"BodfCKypEWtu0OPQQSjDBuwjJVHuQ3eVB7PkUTgSfdrd5+51s5rP4QwDTzMdXXWJXGf7kd2I"
"nlxtZyVWvZO58sVf5cvMlUQTB2FiTl4ciY587n7igcv8K1LdCC2W1P7v3nYGnNVn+qC1P1mZ"
"ijXlQNMFmvvpJnLJjd6Dz+Z+bWRVJ08Mlt89rj1FWMucgcKR53se+F2P4EW7dMpRS9dNalrf"
"FZzVFY5mbrBxWt07o8Z7ukZ8lHb22Gd5AsWAs7rG5YvSUN1KSoFphTOYzI5QHQMPL2LtOMul"
"yl1r7898mpo+kOo415rnvevay/GOWOfu32GFWKPCzOT3OpLqAQ4QKwCcA6bIASBWAECsAIgV"
"ABArACBWAMQKAIgVzoecqA0n/H44KQI4Ew2xzmxIpo0pFYMp0XNbj2jIOpXAYhsSYV8ewVIG"
"n/Vg8Mx20geHkNnztfxzmRAMt5aePjYxXR4cIhMqfMd6ki+rA5CL/D8g1nI7E/czEu+SBJGu"
"Qvn1dfuxGMZi6gNDWKYDxHsF2lhRxCoGr7J/4UA+ekqu3tfOSGL2UMiS/VxFuqxC/W29n5nZ"
"S7MOenrZc2J/RJClTCo42lljJZcozZLl2GiplmrPqkxzi6HDrPv1LIPXeYw/Im76O7ZNvSVp"
"EKq8l69HnG50Mnox3lQIddMVOKqfDnVl8MZthAP4TElnKSSfc4QZZdn6nlKYvzsaf5NoG5zV"
"NKNZxW/GcoP5qeCifdZcIzEP+Vbi9+JgIRuUuWDXBvwpFn3OdJRaoVpvgxpwehkPUE7v+f31"
"3GLNlVy9r3WXiQPlXa0I9AHhVyiHH4/XZZ9WJWlpv/TPR7JyMSxJY3E40e9y3V4EezAfFeVR"
"7WDFkECPGnhJ9LPDJSZ/f93/WPuuD9H+WJeZ7WfD9j1zaY0uM6nHApKjveKym1fLhH5/sZ6B"
"IzKIU/1XOTJsIdRVaE7vp1i25AZ8Zu1r4rIh/izfB2I9qVYbGuiQcBLJflHRLh3xkSVxREaC"
"c5+FyzlgTf9fCnBRlx1MuPVm/XCQKDg3GOAaMOsGALECAGIFQKwAgFgBALECIFYAQKwAgFgB"
"3pLm0w33CDADgEGxFmZdHDIjozdeJXF+bXYfzpBwCJTBrUL1yzZZwFkKcI/Ev6VvNstzn2Oh"
"ZwCnKYMT7mPiqrGGLyeiy1Av4Wp7iyU32R7geGfNOcxiHGJWmRAxW4ipA8FLrMxCThFcQKym"
"Ij0o8a9GnLH/iWUZA5xarPbWtm/i31CfFWeFW4u1Rag7jMY6nBXeQaymjfQkiX81zouzwmXE"
"KpP2jvxtVf6MtOe1WHBWOL1YdXCWU4IxSfzTDhuWTUj8e7qjyA6OPsdZ4RTdw9rAtIJI3GgZ"
"Kq9Wlll3TGxOuipnFcHtxQoA1+uzAgBiBQDECoBYAQCxAgBiBUCsAIBYARArACBWALAhm8EU"
"Zrcccb5tYU4rsaeAs7aIaacpaQCQE2tFWoObLGCdIsi8UUCso2IUy2elR5hnEwO8exnspOum"
"UgYtHFZEtSBYgCU/wOQrRBv+bjQSNObWizogAOCsNWVwxE3D42dKRLgZlcAhV+l7zHEBcNaG"
"PmyphDXiT2T9hwS1ARxJMtZFjAa7o5wtsQ1e9WUBbu+sMnJ005esdFhnINRS/xng9n1W6Whu"
"4DEAzCyDAeBazgoAiBUAECsAYgUAxAoAiBUAsQIAYgUAxAqAWAFgHh+t/6BmwvjI/fNPmXsK"
"sIOzJrKWFiHUgD65mBP4AXYug73MUnrcC6f0GXEyMwBg5zLYCdG6SDiaTGtwyza9oSnNQc1f"
"fSmhe18DuIuzSsH9dVhVGpdC0lqF6pSrJ1/L/R9fKdzRWWtE/O/Jz9c+bae7+UgZHn2NFAnA"
"WWsU9XPs9QZyaRMkUQBijYji5WcZUXp67WwDQs2V0L2vAbwVremGyUEkWQozyAOwr7O6WL+0"
"5KIIFWBnZwWAa/VZAQCxAgBiBUCsAIBYASDL/wIMAGnyqGGTjvBhAAAAAElFTkSuQmCC")
getToolbarsOnData = ToolbarsOn.GetData
getToolbarsOnImage = ToolbarsOn.GetImage
getToolbarsOnBitmap = ToolbarsOn.GetBitmap
#----------------------------------------------------------------------
ToolbarsOff = PyEmbeddedImage(
"iVBORw0KGgoAAAANSUhEUgAAAOsAAADyCAYAAACs0zKGAAAAGXRFWHRTb2Z0d2FyZQBBZG9i"
"ZSBJbWFnZVJlYWR5ccllPAAAA2ZpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADw/eHBhY2tl"
"dCBiZWdpbj0i77u/IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+IDx4OnhtcG1l"
"dGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDUu"
"MC1jMDYwIDYxLjEzNDc3NywgMjAxMC8wMi8xMi0xNzozMjowMCAgICAgICAgIj4gPHJkZjpS"
"REYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgt"
"bnMjIj4gPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIgeG1sbnM6eG1wTU09Imh0dHA6"
"Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9tbS8iIHhtbG5zOnN0UmVmPSJodHRwOi8vbnMuYWRv"
"YmUuY29tL3hhcC8xLjAvc1R5cGUvUmVzb3VyY2VSZWYjIiB4bWxuczp4bXA9Imh0dHA6Ly9u"
"cy5hZG9iZS5jb20veGFwLzEuMC8iIHhtcE1NOk9yaWdpbmFsRG9jdW1lbnRJRD0ieG1wLmRp"
"ZDowMTgwMTE3NDA3MjA2ODExOTEwOURDQkFDQjFGMDFEOCIgeG1wTU06RG9jdW1lbnRJRD0i"
"eG1wLmRpZDpBMzYzODFDQjU5NDYxMUUxODg5RTk0RjZERTEwMDRCQSIgeG1wTU06SW5zdGFu"
"Y2VJRD0ieG1wLmlpZDpBMzYzODFDQTU5NDYxMUUxODg5RTk0RjZERTEwMDRCQSIgeG1wOkNy"
"ZWF0b3JUb29sPSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCI+IDx4bXBNTTpEZXJp"
"dmVkRnJvbSBzdFJlZjppbnN0YW5jZUlEPSJ4bXAuaWlkOjA2ODAxMTc0MDcyMDY4MTE4MDY2"
"QzM0Q0VBQTY0RjRFIiBzdFJlZjpkb2N1bWVudElEPSJ4bXAuZGlkOjAxODAxMTc0MDcyMDY4"
"MTE5MTA5RENCQUNCMUYwMUQ4Ii8+IDwvcmRmOkRlc2NyaXB0aW9uPiA8L3JkZjpSREY+IDwv"
"eDp4bXBtZXRhPiA8P3hwYWNrZXQgZW5kPSJyIj8+01H87gAADlxJREFUeNrsnQuS4rgSAK2N"
"vsCcaN7RZy80V9BrdiymKOuvki1DZgQBbRrMR6kqCavsvPcbAKzPP3wEAMgKAMgKgKwAgKwA"
"MMLXyi/OORemqt33xctrPYv9/b8bM9vwkZH10fhrtsntD7mCYPJ2pZjJu8RtL0UWF0SFz4ys"
"QrgtRLEgREYqLZZrjaB6f0JQpyKs3udD2P/+B2nhoyLrd4N3uwRBhFoJvJDJR8TKSR7bn1Oi"
"xjoBn5AY4CMi60EElwipSuKuyBoTzxVCuBL05XFEV/ioMWuFVJaRtXp/DxGFjLHxLKbCR6XB"
"ybQ3NgsbSWf17byJjftTabnja4SPjqxhskePCffJIJeIZN2RtWd/CWGRFz5H1l0Qv8VnYg9/"
"i+jaFVlb9ycjuhIWUeHjIqvTjV+no4m01WI2uH1Ay4QSfADMnALcfcwKAMgKAMgKgKwAgKwA"
"gKwAyAoAyAoAyArwsbKGkioAsJisQU4lqW+p1wQA16bBQeKnqBX1mojWAA181cizlVfDOCHt"
"c3GA9SKB8FpYfABE1gpf1PWWErk3qlbun0gMyBoRztXII6oRjhTcrpZRbMdUQNbgYSmlFePT"
"4v/2Chyibqr2EhEWPn7MejK+Qtrwf64UlQE+VtbK6DoaRb0aw75U6N9vH6rvE1UBWa+l2kBm"
"iOGjZVXnuKn+2WTgJxafipTyuRATkHWNSHqoitiS4u7n6QF4O5LRr/Cbp1PjRW8hT+LMcU23"
"ibrwcbICwFqwRA4AWQEAWQGQFQCQFQCQFQBZAQBZAQBZAZAVAK4jeyB/RU2kLJ3HBb88xZZZ"
"JqfX0PYeOkkhNri9rKEtV0gZk62n5ddUUkztx4nSL9NW3ogO7LlQnpU+cKmsDVHVu2vLNBQr"
"Ld58fwDFMauuXPgsWCYvMv3U243FSEVruf7Vd0b01kh+5v4AqtPg4hgzjPmMajC1psVDkU4U"
"MX8WKC+MYYmssFxk9YmUd3bUWj3SEVlh3TQ4FVVV5PEqbZ49XpTbXOR2b8YgI+02e38AFrJG"
"U96LIwljVmDM2pqSJqKnf/yMcfLkMLPBQBqciR5+P12FT6SRvWPPIHz2b4tIJ16/TGkPf0fe"
"I5EVLiFX3VA2TioNAqwqKwDcJw0GAGQFAGQFQFYAQFYAQFYAZAUAZAUAZAW4LV98BH+oLGPD"
"EV+wvqwtZ0IfFKb4XBdVI3xWk3j8gbRAGtwnuaWQscuhU7q2Rhwga7kh60Z9dhoaxTjKeXV5"
"RtU9sj4LyO3L7GhFsF5kFfVxfURgi6j2Im9BBK+Kts2KrocOSnUs5MOwlqyi3OhMYbOpbkzI"
"1HbDyOojtaYIp7CurBOkiEmSjZ65CGpcq/jlElmI71MZAcASkXWvqftjoiTJjiKxL3/CmNUj"
"KtxuzLrzO9JQTW3JVVM84SeT3GwwosI9ZFUnZdLbZqTBNZL62WPWliwAYBa9B0XMCG8uI0f1"
"zLDBGd1c7XYOjIAlZT0JXQ609bbFvqtkRlQ4XQ4aHcAbjlkBAFkBAFkBkBUAkBUAkBUAWQEA"
"WQEAWQHuQvPhhpkD9zkaCmAVWUNVwcTdl1RQUJ1HV4chVxOJgmhV2wZf98vziPpOL9s2tTSP"
"TpE0uEXUVFExMwHDRTXaTdVd0h2E75UmPH6viFG17aSOKOw3XLzhskR45zQ4EUFNomqsEYZt"
"j6VvIfKoCGTRcP3Atu63G4mgAOORNdFwdalOEwzWpPZK4xq3WXYQqUXuLMmDYVlNJZURNCbs"
"435RYTEljRt4H65z25ljc3/la4B7yzqrUbaUi3EjDVhHrFAYrmabJYVs4tSyr/A+Y9bThK0R"
"zWKsp2ZkT58ZFs/nat4jKTGRdWiCZPY4NUwwycYtUmeTRtw7M3zSuJqxK7J2j1PlGOqKyPsi"
"i1WU3a6ZGa55TVhKGtwsaWx8OCzt/nPM4VwyYtsmr7e5FRZl5lC7bXZkhQ+nerxVkGQ4RctU"
"3U9FzJcxY+7xi4/JD1X+E0cxMV5FVr58gHcdswIAsgIAsgIgKwAgKwAgKwCyAgCyAiArACAr"
"ANhQfSB/YY3pJYctWlQ2zDx3uPmsQhirPgiwnKyroQqpmSzXo2gZvEsarAuGuVkSikv2f1P1"
"mgaRy/NoIXDPMauQYspaTl00bUusWRVrW1vrNbW8V1oH3FNWUTplqrA10XJ/LXqhOjksMGaV"
"0Wx2xNlLjrpStJTCGu03FuUd0RZuGVn3GdEfExtwNlq2jGdHRC2k3rQaWDuyCn5HRDIpnJaL"
"ljNmf/Xua55PlCIl0sKakTUV8c48SdKk2d/q3e9lSA/SAqw2ZvUqCp1O7XjWMv1NSIuhcIs0"
"+Cr06Q5nnhyq9nozfC0AeQEYdwG84ZgVAJAVAJAVAFkBAFkBAFkBkBUAkBUAkBXgLlQdbpg4"
"FlefBPi53bhwWTgeeLN+3u31bO7Ra1korXT9TsTOPn/m/mavnw7fv3z+0NZuK2tsEXb4TBu3"
"r0jx2N/M++9pIK2fVfb+loac2LfseGcI8XydFZ9jrJTPn1UbjcLGREx9hGpRhjPsdKL7L90/"
"HFmvEFH2tKLW0mYYyYtRdZa0mc+11AGOvIbpcg59AH+FDt+zt25ziQzRi0jeta9csYRMG23u"
"iP7p+LJjK1X8dtGyucEG4nLXsXTfaHneKs9R6sy6xe78nJzV/jPPrytzypTbGX4nNe+/qeLJ"
"PwZfXuwDsPxgw4foLPclCsAdInfiy7OQ1g9ss5bURdJPf1UEFtU/Nuu0VKbj4VKIhKOdTEtq"
"XS3s18CLeqtJFNFQXlKTXeaStK5D2N61tL3CxtJoV/FaZ6f+h45xZG1/7rHqvlgxPDfYhmLt"
"JASCXMpb9Tl/NXzJtb28yZcbK5uiZu6sosvhw87M7qakra3f5FJlYU6aTXZXzUGMSNY6sTTy"
"eIvZ4PALgTU1suYmPS6dhDJswD6SEuU+dFfZmSV74Ujp0+4xd280q/kcVph4mhnR1ZDIdbYf"
"OYzoqatdtd/hCabHGwyXO32ZuZRo4iSMKzzeVfzfzM95xnPrMVlt+n9K29G/s1pMLDXWK6v+"
"zFsnmGIR6FnLd/bkQ2xfA/sujhEjPyFYNS5XeZ87W6wTOoDWv8/s+F2P8DXfXcWwynSCKfpb"
"n5oYOOPL3jrSjG5hG66dUeNdrhFf5c4Z71keQDEwZnWN2zflUN1OSv9YOILJrIfqmHh4kbXj"
"KJdYB9R9vfJharoj1eVca/7u3ddZEe+KfZ7+HVbIGhUzU7+XiokAV8gKAGvAEjkAZAUAZAVA"
"VgBAVgBAVgBkBQBkhfWQC7Vhwe+HgyKAI9GQdWZDMn3tqTKYEr229YrPTVclsHgNiWJfHmFJ"
"g1ftDJ61nXTnENY8fm//uU0oDJdY9vdyrV6nFsoixdWLIVzk8diCrOV2Jq5nVLxLEiTdRfn1"
"ffnfZlgWU3cMYZsuIN4raGNGEcsYvKr9izEX8tWTcvXetyKJ1UOhluzPXdJtF/Vf6/eZWb00"
"q9PT256VHSNClmpSwdWyqlNLhB7Wqcrqh4XXuftGfJJp2j6gtK6S7xLR9CCpek1d7zM8t6xT"
"rKtfiPsOYnVmF7nX6LftpYjjYShw1TgdChHBsqcfWcSrx2mq5689RUKNrKkGnJLCj7zP3ELv"
"1POlJr1aP0v9mNR65TtlR4xZ4ymT67hvdDz1LD4tCkHrOkmm49RvfopNP2c21tqO0fo1qAmn"
"l/kA1VF4fn9dW9Zc/Z/e+5obcGW08gZy6g7h177vRwr8a9/2MzNb6hr36SrGsdHJKMOUNFYO"
"J/pd7q8XYVdMgy9/UX9P8+gtGn9Lqh0ZI79MMn1v+3c0JS1FVHmKSz0PEN5r66SPToMTpzzU"
"w41Dur56rSlkvUDWq8bFW6IItJLWDY4fNyXNpkVMZQ6zZI09X2w8i6zI2jrpYfoeao5gshxD"
"5k6Zkdj3yxFFrafciJyP5fCzU+w5I7PDTDYhKwCUYNUNALICALICICsAICsAICsAsgIAsgIA"
"sgK8JV+tDzijgBkADMqaOQv6g1NOK1/oPFzD8bLN72GFCodAGtwqqleXzVLUsyr+bX1rYZ/v"
"OVb0DGCZNDgRfUyiaqzhy4XosqiXiGpny5JbbA9wfWTNRZjtuOxqiAvXTLqKyPtSVuaCzgKQ"
"tbtxmzTWWMU/fX+kpMloGZkaOWOPidUyBlhaVvvQtkvbMBZ0A9IMjVmJrPDRsraIesJsrCOy"
"wjvIatpIF6n4VxN5iaxwG1nd9vqzzVW/rcqfkc48FwuRFZaXVU4m6XHisLT7zzG6wPRzW+R3"
"1tGI5v/uwmf/JrLCEsPDjiN+fColvlPFP4C3lRUA7jdmBQBkBQBkBUBWAEBWAEBWAGQFAGQF"
"QFYAQFYAsCFbg0mfyv5MCmtaOUwSiKwtMp20JA0AcrJWVGtwkwXWVQTpGQBZR2UU22dVjzCv"
"TQzw7mmwk1E3VWXQIsKKUi0IC7DlJ5h8hbTh/0ZLgsai9aY6BAAia00aHImm4fazSkS4GKXA"
"oa7Sj1jEBSCyNoxhSymsEb8j+7+kUBvA8mmwHn9GousUxIy0i2wDQFYhyKF6X8vE0cg5a5SU"
"CAqMWStTXzdwGwAsMk0mbADeI7ICALICALICICsAICsAICsAsgIAsgIAsgIgKwDM46v1AWol"
"jI9cP/+VQxkBToisiVpLmxA1oI3kAH6Ak9NgL2spPa5FpPQZOQmnACenwU5I6yLF0WS1Brcd"
"qzc0VXNQ61dfUuje+wA+JbJK4f6LsCo1LhVJaxXVqaievC/3OL5S+MTIWiPxnz/2aDZYkdBH"
"0vDofVSRACJrjVEFEQ3T0Fy1CSpRALJGpHj5WUaknl5HtgFRcyl0730Ab0VyQiZWWXDLTCLJ"
"VJhJHoBzI6uLjUtLURRRAU6OrABwrzErACArACArALICALICQJb/CzAAGbpQ96M3zzMAAAAA"
"SUVORK5CYII=")
getToolbarsOffData = ToolbarsOff.GetData
getToolbarsOffImage = ToolbarsOff.GetImage
getToolbarsOffBitmap = ToolbarsOff.GetBitmap
#----------------------------------------------------------------------
PtableOn = PyEmbeddedImage(
"iVBORw0KGgoAAAANSUhEUgAAAbEAAAD/CAYAAAB/9egZAAAAGXRFWHRTb2Z0d2FyZQBBZG9i"
"ZSBJbWFnZVJlYWR5ccllPAAA/i9JREFUeNrsfQd8lFX29jO9ZTLpkEboJYBIr0oTkC4oIqBi"
"WRHRxbKwKFZAsSs2EJUFpYqKCiogICi9915COimE9D4z3z3nnRlCCGQyM37/ZXmf/c0mhuS8"
"9z333nPuOfcUxbBhw+z4m7FixQoFZMiQIUPGTYXhw4f/7fpFTf930jCS/0OhUkOp0kGhVHtM"
"0G4rh81aAru1nP+7SdG38kzKkCFDxk2Kv1u/uKiptCaodGYoNQbvH1JWBGtJHqylBfIMypAh"
"Q8ZNjr9Tv6idGpIeoNZboNQahbbUevwQm7UUNsffk8aUIUOGDBk3L/5u/cJKjEw80pD0AJXW"
"T/y3xvMBW6UHKMXDiK4MGTJkyLh54Qv90jNWjR7N1Ei8kIuPfrwgFI3SpV+UrHiEeUcf0pD0"
"AIX46slnTDcDJg8yoLwwi80+b8xGGTJkyJDxP2CJealfmkTqMP4OE+Yu3w69PQtP9PFDad4F"
"2O22y0rMF3i8pxpDWqtRmpuCvOS9KC/KkWdPhgwZMmR4BT9NOb7bGId9+w8iITkTflorii6e"
"4Xsxgs9Mpc9+y8SZ0xloFFyCkuwkaP0joFIb5BmQIUOGDBkeY/fZYhwoSMfM54aic4vaGP3s"
"57CVF9OlmG8tMaVaD7XOIvk+NXqZ8zJkyJAhw2tY/HRY8lJH5BaWo/uDs5CYng+dJQpKnZ9v"
"LTFSXCo9fS33KvpEhgwZMmTIcKJnMw3MBgXCzWX4eMogHE/Ix4L1aVAoVL5VYjJkyJAhQ4av"
"8dOuXOzZuwv5Sfv4vy8U6GGDRSgxpe+V2MrdhchLOQ6NX5iwxmSXogwZMmTI8A5KtQ5xuaEo"
"tjeDrbQQCo0S6grePp8qMZXOD6awZigvyYXdZoW1OFeeARkyZMiQ4TEozF5niYbWrxZs5UVc"
"saO8JB/lhRerV2IRAcC3Ey2u/07KKMTQaYewclpbRAZfTlgb/PIuZJSFQGMIhMYUwsEdZYVZ"
"sEJWYjJkyJAhw6lTFFj+bM10CiU2K5Qq8THwV/EDKMqK+Wu1Siw5qxztJu7GRw+HYuPmnZi9"
"aB3MUe0w8IUCTLgzCE2jdLh3/Bsw1WqJwEa9uayIDBkyZMiQUbVOKauxTnHefV0L11Vi9Mdq"
"YzD7JMV/cASi1hLJOWAFVrv4kYK1odY/nH+Pft+ZRS1DhgwZMmR4q1Oqw/XvxAQBDT1QYxdm"
"XQD0gfVgCKoPnXigxlAsfl4sflYXhuCG/HsyZMiQIUOGL3RKTEQwpt1tQNNILZIyivDG0rPY"
"l6DiOzL3lVgFTPlHX/5chgWb95yErVyuVC9DhgwZMmqG6nTKpAE6rNl2FgPm/Yh+nWLwwuMD"
"cOezv8BYKxbO+7AaKbGZc1biw0/ncaa0SuePx0d0QtfWdaXyHzJkyJAhQ0YNcD2d4m9UoX1D"
"vfg0wzMjmrn+JsB6Fvm5AdCaw2uuxKgKsS4wBuaINtD4hYoH12Z/JpWbkiFDhgwZMmqC6+kU"
"Z2zFPeNmYOOf26APqssWGgV6BDSwiX+3u+i4XTtRqVJDHyAeGN0elrrdEBpehx/GF3QyZMiQ"
"IUNGDXA9nUJ1Enccy8DER4dBFxCN5u3uwPrl7yGycSeoDQEcFOKWJVYxT6xj074YNaANBr64"
"HT9ObYzIYOnn5ze8jr4TV4iHhksx/TJkyJAhQ0aVOuVynth1dco/f8D0r614+9HGSNn5BRLT"
"8vDcR1uQW1AKvVZZ4UbMocSogSV9qPUzdWZ2mmdJGeVo++RRXDr7BwrSjrGGNEe2xYApf6Ao"
"8xTykvayiWeq3RyBDWpDpTGwmUd0nDRlyJAhQ8bNi4r6JTGjUOiUbW7pFHNkO9w3bTMKLhyG"
"rawYamMQDMENoFBphJ6xuvTLFUrMbqVPKWyXn84Xbuao9jCGNmMTjkw5armiqKWB1j9S/I6d"
"y03R71GpKRcd+l7OGZMhQ4aMm1uJCT3A+kDoBSjL3dYpFLxBrkSqxWstyYdSY4TWFEzFFLkh"
"5pVKjLSatUxSYFb1FRdlRMwY2uSqgWlMwVVqXMkKK3M8wC7PoAwZMmTc3GrMYSiVwWZT10in"
"ECiPzAnSL1QEmPWV3VrZEiuTPuIfvbGfJGVYxlYcrvBcypAhQ4aMmw8K1gesG4QV5bV+ceoq"
"hyWmGDZs2A1vLq1YsULWljJk3IAYPny47K6R4RXYEjtpHMmlQCgGn/yOdHHmnSVWypdz1rJC"
"1M/4FKf9H4LkWlRwLSzKD/CYPrssSyT/qkCTom/lWZQh4wbGScNI6UStUkOp0nktH/jjuPhv"
"UvgtyzeiSZ2A+atM/++lz144Sd43yl2Ac6FPQSX0CgVxUMkob/WLTeiV8uIclBVe5PHzaKWB"
"a6SPeICyUm2qmsBpKirocs6pKam6vUN5SSX1vVRiZUV8sWctLZAlgAwZ/wNQaU1Q6czcxskn"
"QtrhdkIh+IDulG0+UwIy/evQd0QOkjLLBSswSXlpfaJfFFaHrnKMU1JipIHpBQRxpeNhnkLp"
"eBB9tTsS0miBSgzSOE5bXrwEWXmOvyeLTIYMGTc2SCaQAmNPkNbotXxwRlmzkHYcoiXZo/WJ"
"/JHpu0HfEV/BOqGCBeYL/WJXlUv6RKGqoMQc2pdeQFJkNTP3RnfVoUktO47F5+LrDZfEgjRd"
"YTLy6arCCyg9NCcnDzTg458TkVMKqTyJSq4WIkPGjQ7axyQjSIGptH4eyQenDLIJwfnD5hTs"
"PlPqKonnvCLxRv5Qku74O/RIuJCLT35OcChbo0/ot6unwuA2God1VC7kaB4WrM+CWhz+fTV+"
"5zOOxV0StFNdhoWv6PeMVaNHMzWOCvpfO+k7LKXKCsxd+jSnC//IgELMY4eGBtf4/7M2i0MG"
"nfSVFZWY0vGAy6Zf9Z8mkToMbavHnGWbxYtoMSC2AKV5F+j2y8Wkyi9QE/rOz5huBvRsoUeg"
"7SzK8tPA92temL0yZMj4L7HEvJA/zk8vIXs+X74dsxeuxabNu2AtyXUFR3srf/yNWnw41oJl"
"a4/BYM/C+N46lOZecIV4e0t/99kyzF+TgLnf7UC4xYa0hGMoyrhczd1b+pHBWswYacHc73eh"
"Z3MdBjYvETI6rYIl7B39dg10QsGbMFfwP0yfi4EtylFWkOkxfaL31Th/3C9kfl7KAcHzXB7/"
"st/2o20MMKhlOUrzM66wzryCn6Yc3208x0yhU0RGSpyYgFOwlvnuvqptXQVq+0lVQApSD4kF"
"lOwyVWXIkCHDLIyuh/tFo2/7SMpKkoSmUuMT2j2aKpCTV4Sh7Y24mJ6Kb75fzzKIqkj4yp16"
"OkONrm0aICElC19/u5rv/SvWB/QGVIcwJ78UbaPLYTaocPrEIRRdPCNkdJFP6DeuZcORM2nY"
"vXMbEpLT0Sk2CIVCCVPwhSfYfboI81fHsVsy5/xWDG6txPYj6Vj/xyZs3n0CnZoFoyjzNMdF"
"+ESJ7T5bjB+3ZmDCmJ6wmI2wlRagnLOprT5boGO6aPDeoh2cyW0tzRfML76iirEMGTJubvy+"
"LxNzlv4Jfz8t/jWqNQd9Oe98vIVJWwa7sIo+/up7QV+H0YM6XA5c8JElqjGFYkTPuvhixV5o"
"/WpxY0hyrfoC4QFSnpa1tBDxSalo3iAU1uJcn/Hnxx3ZiK0bgE9fHI4BtzVjA6MkO5FltadK"
"PTVHyUqcEptpLlmpC8tXZaD7O6Ww9DL4fXyixIa2N+GRgY0wac4BLFu9H4PuaOeKfvEFSAuH"
"BwBLX+rCE/HSxPvEBOQI+nJQhwwZMiRPTV6hFSdT7Ui+WCasMgVbGp5aApWRnFksLJkiHDmb"
"Lr4vgcXfJAlWH8qgnrEa8YwSHDx6BjpLJJdb8iYUvSLoPuzouUzMXrIBW/aeRavYhlIAho8a"
"GsdGm/D9pvOC/iYcPHYOBw6fZPrw0NAgpa6iYBOhxJRaE5LSchBVy4/LTQVazMLqy3BYqRJ9"
"ry+V/jhcgHmPByLs8VvQvH4wpry9WMrO9pEl9tOOXCxasR95SXtw4IfJeO3dr8TiNLK/mHLO"
"ZMiQcXPjRFIxJj0Whkah/WAxafH8+z8I+WClUDmf0N94rAy3N1LgizcnICYiGBOmLRWHaKvH"
"QrpqRWzH1v3n2cOk9Y/g0ky+k6HZmDc+CJ+//hhuaRotZPQySUb7yJJMzrZh8uAGaFxbAX+j"
"Gv9+cyEMIY1YAXlsnbKSkvKKf9+Thn6d62Phm6OZ/4PGr3DkNBuAEh8osfwSFQa/tAMxxhSc"
"P5+InIIS6IMaCFPY6BMGKdVaGIIbcpHIe6b+hrNZRmFqx3BEjV3uKi1Dxk2P/BIFhry6FzH6"
"JBw4cpIj4/RB9cRp3t8n9Mmt9+KiM0z/3LmzyC2ycTV1X9EnfPpLOlJOH2bZRg0iKXzcDt8o"
"sYJynSSjDUJGx68UMroMBuKPj9yVqZeAwS/vkvh/6Bj0gjfGsGbQUN8vD3Ey1YaR0zazVao1"
"18bUhSmI0SVg/4GDHK3ocrf6QolRDgANOiFHB1tgACwhGmhMYZz34Yze8QYUraL1D+dPfmEk"
"QmIj2KwU/4ByWYnJkHHTgwI4dAF1EJ+jhDnSjy0ASuClA7BP6KuIfgwS8jSwWfQwBwmZJBQN"
"WwI+QqHNCFP4LdK9j87fp/yhVANDaBMk5phgC7DAP9gxfh8pMeIzKZWEHA38YwJYuWuMIXy3"
"5Y3cz7JHCXpmaE2hrLgSc4m+UYpkFUYMVe4geB+jTqX0hWlHWlG67Cxnk1gqP2X16WSQNUb5"
"YXTJV1aULe9eGTJkXCmDyotgIzeZzSrdy/gI5FnSB9Zjq4DdfHYr56T5jL4QyiqLQar07khG"
"/jv4YxOWns/Hr1AK2RwotePyEf+pspPWL0wYRCHStZH46IPqQyeMGaswXsqLcqRgj+spMbos"
"nfXg5RNBUkYhhk47JMy7KLayCBR08e/BZrR7ei9H1xCj7FZFtUEdlWk7kSvM3I9/isPK/Vah"
"fUOuzux21l2U78JkyLgpUBNZQYIP9JUO0DV0xdF9zuSBOjSNlAoo7Dh2EVFhRkz47BQyii2O"
"qhYqDt23gQ7othqN/aMVZ7B4SzH3xooK0eHbiRbX75ErLqMsBBqhCDzt/DFpgAZD2xldvFmw"
"NgGLthazXCZvmVMx1GT8Tmx+xXLNf6v4XvycavhPQSazHrLUjCcOeV9xfq+wBK81OIrVb/3E"
"ZiSkXsLrHy1B+wFPIT/lAIfPO0FBF7c+tg5FmTWLBKpMu3bbBxF9+3M4eDwOL41pDFvqZikZ"
"Tw6jlyHjpsb/D1kREQDMesDEjRdbDn4V0bc9i/0HjwjBahD0t6Aw85RHVkvFsT89vCHCy/ei"
"JCcJSZklGPLaAeTkF6PDoKdxZOdqlOVneBxo8cEYPdrGKDBk4nzmzcw5P2Fsnwj8o3Mh51N5"
"m8/W/rnDWLbmEP7aeQS1Wo9GVLeJiOn5Ahav3IbC9OMcdMfJ5W5g1+kCn/PkmkqM/Jlacy3W"
"fmR+kgWktURC7bDC+I/VWu7EaQhpKBX5dddUrED7UnYu+2z9wlth5/FL/O9BSEDxpfOufjEy"
"ZMi4OfH/Q1aM7qxmGXfPuOnIykyHqVYsPlmVgiW/7IJJVSQJUw+UmHPs5MX6ec0WfDy5H5TZ"
"R8SBPxtpBQYcPZuBxAvZUBuCoDYGehRtTd6w9g10mDn7R+zZtQP6gDpYubeEq2eMu6c9/IsO"
"oSQ32aucNskVaYKzL5gxpDEs9brh9SVnMW/VCShqcPfIesTHPFFe92F+tfjSlGL2KWqGOmw6"
"XYlkKm+ZFopd78ci3N9ao+S/irQ1xiDBlEaIaNwZA3u0YO1+8OhZzsH4UJyOyJSlzz0tMjiB"
"zpd+bhkyZPyXKzE3ZYU34eI9m+sRn5yBi+kpMEe1R2Cjvghs0BPv/lKIg2kBHC3oSfUM59hJ"
"Abz48Wqm8crYlihMO8qBCfRzv/BbYardnIMXPLkmIQuMsO73tUKBxSCgYW8ENrwDcQW1+Od3"
"tKbqGSe8qs7BSoxD2vXQWaLx5IP98fiITvCLuBWBjfsKnrVzOxilJjyJiQzDl/+QdMDSJ7Ro"
"EZDI5awqpx54fLlEpvL4WQf4+6yTa7jUlCenobcm34szv07GhhmNOQN75bodHOky7q5bkZ2T"
"j4aD3kO3UW/hoT6RMBceRGluqs8y5WXIkHHj4FqyQmsO96qOqr9RWHmXsjgKUR9U15WDZAxt"
"ioD63dnycN4reYpiZRD++dYqDOrVGmO66lF88YwkgKnPFhUy9/Ce36yTZCGNn9IKSEHQ2NVC"
"4RMoobn4UrzH1TMqohuVxfrzXTw9vAGXlSJXIikdfqYH/KmOJ5MH6rFm21nUv3Mm3vhsBV4Y"
"EcmuS7LafKLEuGS/I5mttCCDG5TZbTVXLpNnzkdIs4GI6voUVq7dim8/eQ6DerfBHW2C0Kdt"
"KM78Mglblj4Pi9mANnXKJR+vHFovQ8ZNh2vJCqebyxuQ7CLXFbchcVhdvVqa8GCvELbyvE08"
"JmEflxeC9xftwvPj+iNaG8cFG7xNQ0rKlGRhgL+ZIyidFeKdbjiqI0mh6L6ooLRl72kENe6H"
"GbMWozQnSfKMeVH143o8oYNF+4Z6PDOiGc6tmYo5r41BnfBABFjPCkMm5Yr59lyJiZOP2mFC"
"qrzIl1AqtXyCMEd3xOJtkqtwZN9YoW3zMOOjJQhuOgARHcchotPjWPrLLkdHUqu8o2XIuMlw"
"LVmRn7L/qtN5TUAVIVo1bwiLv9FxLSIFiVAVjc17TqI465wrJ8lzKNg6Wrpbjd82H8cnzw+G"
"n7Yc5YVZcJZP8swjJhVa796lNVunzgCUJhGSMlu5dpur1Yr3UPB91vw18ViwPo1LY3lnoV6b"
"J04Zf8+4GQhu0h+RnZ9AePtHkHghRzpUVAjk8UiJUTTMyDbFjgnwDgEB/uzL9Y9qjwfv6cM/"
"o1YKP/6yDg/e3QuNmrZg3+sPX01Hv0HDofOPkEItZciQcVPhWrKiYkVzT7Bw40VhyZiwfPYU"
"aIqTOdJ6dCcVws1W7Nt3UCpx56G7kkL3OzYNQLNoA7v2yPX59opM8Tw/mI1qFGcneHUo33jC"
"jtVbz+CV58aiYUgxSvPTMLiVAk/2D8KcJRuRlJHP8Qw+qc4hLFRyHfrHdBLGRX+YI9t4lJjt"
"Dk+o8tOOYxmY+OgwVpbN292B9cvfQ2TjTpwvXPGO0q08salPDOFPRfz0y17MfnoAf7/jp3fQ"
"45G5KCq6BI0xsNqXqEj7hfGD+UPILSjFW1+uxaffrBbKKhK9e3Zn2oTXvtqJbYeSOfpGzhOT"
"IePmgDuygpSaUu25N+hMlgn3TP0VrzzQHLsWjOGfbT+ShidnrGA3IyXdkjXjzdh/+uhBvPjJ"
"Wvx+Ng12fRSmLziAicPqCwVZ5JVLkbxhLy4+gUkDs7Hy44ddvHl73gbMmrMQxrBYvtvzxlt2"
"OU8shO/EXpm7FWtOlXLVj5p2aZbyxKrnCVnDM5cn4Y3RtZCy8wskpuXhuY+28LvptcorsulY"
"iXHVefGhyD+FVcvm2a6TxWj9+B5kn/sTBWnH2GykUi4K8ZXarRAWr9rO1hg1wTTWikWQPpM7"
"npK/UmpTLZm29NXmMPts16ENsrDEqYQWpV9EK0z49ATykhdzRIpa788Z2xRiyxVBHGOWIUPG"
"jY2q5I8T7sgKc3QHqPRmrnJh40pBpdeVP5WPwEqNDvF5kbj3lfX8DCFFucwRPcevdkvpeXSN"
"YbXWiD6N/dbHduLSmfWcS0tBKAENerAs23zOiFX//B6mWs2hEu/krNDhyfjJUnnnxxN46ZPX"
"OR3ACZLJxB9SNk5Z6Qn99k/vE++wAXkp+1m2U3FfS0wXYd0ZrrLwqqO/4wTxZG/1PNHokV5k"
"xqgZ29hdTLlu5HqkmpXkGpWulcqvVmJ2R7kTeiApCorVN9fpBFPtW65aeNxOXEw0BVlQ+Q+q"
"uqzWB/ACsLloXX4J8n+6GMRlSqqgrQCfqCiklTLN6e8otLO88KJUQ1GciChyyOZo4y0rMRky"
"/neUWEX54/q3a8mhSrKC5csVAvTa8qeqEBC1UFT+dToLoVof5SU53JmehCaH99PB3UXLffo0"
"dhqbpX4PmKM6sMwkGUZ1X1WGQKEIurL8pJJNntB3sUKpgT64IZTCKisrzGQaV/BGPM8r+sIK"
"NUXcykaEU/ZLPFdelQReHX0qbOwuT0i/GIVCo3mgRHSyhrWmYK6da+WelRWVGJ8ynAtA7dLE"
"5HtU17AS8eUXKHU1XavYfI0ZJRSSO7Q55FWcMkCfK+hLWt4XBYZlyJDxf6zEriF/UAM5dNmS"
"cUP+XIMGRcsZgutXQbusZvKt2rHb2V1W8efejp/iBKiuIH2uxRtP6ZNVRPl5VXD9qhqP1dGH"
"qgY8EUqK3KCGoPpX0KdGmRXlfwVLrEz6OEw/jxekVaLhLGQpPbi8AmPs3tN3jlW2xGTI+B+x"
"xG4g+SPT/6+S/4phw4bd8AUKV6xYoZBFgQwZNx6GDx8uF0iV4RXYEjtpHMmXl1Kmunc5BZU1"
"cd3Ud3E+fDKUKjX7bom2t/QpZ4PCYCnBuknht/IsypBxA+NGkz8y/f8u+c9KjHIg+AGOhyhV"
"njeTk0xFyTBympCXX0ArVfrwkr7C6hirUi1LABkybnDcaPJHpv/fJf8lJaZQOTSklh+g8OIh"
"14qeqfgC3tK3q8ql8SrkpGcZMm54JXaDyR+Z/n+X/FdePgmp+SHSQtK49YkK1uL+bgZh3lHe"
"mB29Wxo4mc1eXsoZ1U6zUVqgl1/AXfr33y51anXSnnGvGY/31EhhpI72MDJkyPhfsMRqLn8q"
"ygf6fsYIE0Z1UqC86BKLUl/KH+fPptwVBD91sZTTplL7jL5z/NNH+KF1ZLFUsNfZDNIH9ElW"
"vz7SH4/30kplnezlPuMPyXySzdPv1mP6PUaudlJWdLmcli/G36Ghnp8xupNSom23ueT/FUpM"
"6XiAwvGw633GCOX14YP+aBhUiIILR1m5TB5sRj3zRRRdimPfZUUmVXyB6mi3a6DDV+P8WUHm"
"pRzgZ4y/w8Q9cvT2LDzRx48TrO1yNXsZMv5nlJjSC/kwtK0ec5ZtRq/megxsXiI1ynTS91L+"
"lBdlu2Rer5ZGBFjjUJafdoWS8ZZ+r1gtPhfybfbCtVxKi5tMKnwzfoM9Fx+OtWDZ2mPi+yyM"
"761Dae4FV4i6t/S3HUrC/DUJmPvdDoRbbEhLOIaijJOu4sDe0g8z5GPGSAvmfr8LPZvrMKhl"
"OUrz06+wzjzCjzuysXzDab5cK7hwRHx/kstCUd0rasviTcFMavMyf3Uc5xvknN8Kve0SvtsY"
"h337DyIhORN+WiuKLp7xql6aDBkybkxULR/OseKiw3NGSpxUT9FDGVSZfllBBpeQqu1XymHd"
"JO9Kc5M9rgxfFX2zHni4XzT6to/kyvMs9JUan9Dv0cSGnLwiDG1vxMX0VHzz/Xoev6cdnyvT"
"J8v3dIYaXalVS0oWvv52NRfA8KQHW1X0s8SYc/JL0Ta6HGaDCqePH0JxVpxr/B4rsYJStVTB"
"WJxGKBIlObOUE+5o2Jzw5oWVRKZnao6SmUCJbaTpf9yajpnPDcWogW25sCW3Y5Gr2cuQcfNZ"
"blXKhwxMGNOTK9GT8qpY0cFb+mRRjOmiwXuLdrAbi1x9ViFAPZVxVdH/fV8m5iz9E/5+Wvxr"
"FFWkL7gySdgL+iZNKRfa/fir7wV9HUYP6lCjJsbV0aerHarCMaJnXXyxYi9XOaFyUp4WHa5M"
"PzxQ6eB7IeKTUtGiYZg0v/Zy75QYlQShQZIiYzORGpmJn3GIrJdV5sm1QOWmFOIlqGcZVZhe"
"8lJH5BaWo/uDs5CYng+dJQpKnZ+8o2XIuAndjxXlw4ie9fDIwEaYNOcAlv62D4N7t2PB6rES"
"q0R/+G3hCA8Alr7UhatKvDTxPliLc1gx+II+VXTPK7TiZKodyRfLhFWmYE8ThZH7gj61L8nJ"
"L8KRs+nC2CgRit7ESpI6YvuCPqFnrEY8owQHj54RsjmS6zl6GkpfmX6nZoE4ei4Ts5dswJa9"
"Z7ltDhtK5aXeKTE2FSuYi9SEjRux+SjtWMG0FUyzT7vawoxUINxcho+nDMKT99/BdRrl6EQZ"
"Mm5SRVZBPqzdmYjerSx49/FbMGpAWyxetcPrvoMV6X+34TQGTN7AB2jCtHe/ZAXjTXPeivRJ"
"QA/vGoaPJvdDt9b1MGfZX9J9ko/G//ueC8gtsuOLNydgYPcW+HzpX5Ir1G73CX0C9V7buv88"
"14vU+kdwLV1fze+3608htl4QPn/9Mdw/7HYsWbWDx+60hL0K71v0Vx4Ulw5zPxgq5Pjm96lI"
"PnkOWlOY1+28T6baMHLaZtbqKzanionOQH7SPv63CwV62GBxMVCGDBk3FyrKh0KbCYNf2oEY"
"Ywri4s6zRWAIqgeVB+1TqqKvMQSxjKO6fve8sApnsoyCfozLCvF6/FYjhry6FzH6JBw4cpJr"
"OFLzT5Xe3yf0tebaeHFRKtM/d+6sUGg2rgbvK/rkkfv0l3SknD7Mvcuo8DAZGHZYfUK/WGGR"
"5teQgvPxK5GTVywpSuqYUu6lEqOGaGX+zWA2lXHGPQVD+kW25chKlc7snSZWaZFlj4J/jJkz"
"+ePEwIvtzdhHqtAoofYi10CGDBk3uCVWQT5oTCHsgkrI0cFmMcE/SMvtR5ReNIKsSF9rCpUq"
"2vuHIy8/DMFN6dCu98raqGr88TlKmCP9WDmSPFWqtT4bP7WWScjTCP7oYXbyx4seY5XpF9p0"
"MIXfwi1rPGmU6Q5/EnNMsAVYYA5U8tid7kSvlBhZWzozVU22w+lH1FuiHK1Yythv6fFLKFVc"
"op9fgIJHyEz1q8UN0yjypbwkn1u0yJAh4yZUYpXkAwWYkUVgE5YAuxHt1qvahHhF3wE6UJNC"
"cLac8vX4KS/KRm4ym9Wn8pPo6wPrsVX29/BHAZXF4Co3Zfdi7NXNL8t/Kjvl6J12lRIb3VWH"
"CX0lTTp65j6cy/Hnfj5D2mrw78GSdZWUUYih0w5xcIVkcSkqPh3XuhijPIsn75Q6P/++Jw1T"
"Fyazmc5mocCkARoMbSd9/8NfSXhrRSYzXSG0Ll/BKQ2OoBEFFBxeKdf9lSHjfx0RAcC3Ey34"
"ZGUiFm7KgcZPuq744H4j2jfQ4YfNKXjrh3SWFRSabgPV73Mv8m50ZxXnnRJ2HLuI5KwynEwu"
"xcp9pRjWOQRT7gpGu6f3cvQdKTCSb2QVuBuZ6Bx7ZeQWlGHB2gQs2lrMtDlAjmQbhdZT7cEa"
"uuKu9x6seDlkX1Vj/jSurcDkgTo0jdS5aEeFGTHhs1N4aVRDdGhsuoL/ngT1ffuUCccS8vDC"
"gngxt7Vc+gDOOIsKio3G7+xP5jKmKhNc+EcGBkzZyN+/OTYatrQdKC/Kwk87cjBpzn4kpFxE"
"uzvHIzdxl7CGapan9c2GdPSftI5zFvq2q4WyhLWcr+C8YGxXT9Kp9zw+A09PfQdFF09L+QYy"
"ZMi4adG9qUIcnAvQQ3y9dPYPzk0l/HNugpSbeuk8suP+Ej/PqhFdyv0a0kaD3uMXI6bn89i0"
"ZRfu7lYb+akHkZ9yAN//lYhbH1vHHYg9jRRMzipHu4m7Oehh4Q9/oHab+xF92zNYtWEPJg5v"
"gEjbQZTkJHkVhFLde1BDSU8PD7MeMPHftxz8qhj3s9h/8AiiQgywpW7BQ6/+iG0HEz3mv3Ps"
"ZNHecWsgyhLXXaEP3PYIXmXGUVtuUxh+23yCQ1RfGtMIBRcOs/Y7la7E1gPxrhbh6hree1GH"
"VI05lEM9zyekoHdLEzOAInHoZXYclczD0pwUDtd3BozIkCHj5kW7uiq8Pe8PtGwchQaWHCHo"
"Uljo090R5RSRbCrNTeWrhpqgcS0bjpxJx5mTR1jWfLMpWzxnAyfvlgh6BK1/JAwhDSUrzBO3"
"GHWx5/stsmTsbF0Yw2Kx4aBkADQIKkRh+nGvDuvVvYenbsnRndXM53vGTUdWZjpMtWLxyaoU"
"LPllF0yqIs7bIuvIU/4T6GDy7AeS0XR311qcWlDTqM+rlBiZa3T3VGgzYvzL8zGkT0eM6apn"
"ZaM1BLHy8otoDUNwQ7w+KgSbX7HwZ+5YBQJt58SJJfuaSXRO2hQ1tGrDXnTv0lowOYXbgbeN"
"ASctEuhiUB8QA50lGrMeCrziGVumhWJkmyKU5qV6nDEvQ4aMGwN8uD2WidVbTyMnrxCDet3K"
"sojynCiKT6nSOXJVa369fzyhAP06RuOzV0Zi9OCOQkg3x7LdKqzcV44enVth9wctsev9WIT7"
"Wz1PDhZKi4M0xGGcow4DY2COaovBfTrwP+8/dBRlBZle3SFd7z30AdEeV43v2VyP+OQMXExP"
"EWNuj8BGfRHYoCfe/aUQB9MCoA+qy4aJp/w3C71O1ZcOn07Br5sOYsid3djqJYuOrpZI5r83"
"woZXBpXy910iUiW5X+kuUnntE4QKZzK1ePOL1Xh+XH9Ea+NQUpBBmogno1kdP/RqoUePhz9H"
"i/4vIDJIjRaWBBSmHa9ekyoUvCiH3nkbjMoCnsReLXQ4eCzOocSk0NWh7Qzs8+4+9mN0GfEa"
"P2Pc85/hvY/moCQ70auLTxkyZPz3g07qa7ad5cPv8vWn8MDdvbnkkC+CuvbEWfHB0v3CwovE"
"tMc6YfeHt+Cth+sjNLwu9iXr8fj7u/n3sk6u4VJ63naSHz24E86vn4E9H7VF4zArpry9lHPE"
"OCTdi2jr672HPqi+x6kA/kYVLl3K4qRlUlhSvzcDjKFNEVC/O4whjaHwItWY5nb7kQusa9bv"
"v4RWsfXRJFLNiurN71Lw1apjaBqlw+7tW/j3LaUnkZe4RyqOXAHXVZ8U0EG5YK2aHccnzw/G"
"M+//AXu5hX2Wx+JzMer1HRh3dxuMHjSef78kJ1mYg8XQBdWr1tV4PLGA79fu69cC+xLzsHZX"
"sqveojPHbMeJS8gtsLDCoktDusxjE1b8j3I2lHKYvQwZ/7Ogk3qvFgbc1aHXFT/v0yYUOzOT"
"OLDMmwBrOowv2Z6OOUsWIUSTiQljegsl2QvlRTl4fkGcsDLq8e+VisN7meqiUGJUOd1zob3o"
"py2Y+O8ZLoXAiqJOF5jCYr26Nrnee7zwTSJbgvAwb5ffWViTLGsdxS16tTQJ61SHbzZRtwDP"
"E6Z7xKrRoVFTvHx/U9fP+ndphNlr4rjiB5U2tJiN+GrBQnw87wfmmV9Eq6vuzJTXt4RVvFDe"
"XpHJ308b14lNPTLlm9UxYelLnZCUXsiXiWR20kmF6pZR4UZ3GL962zl0a9eEK0MfPHpWaHyd"
"w1BTur4mpuVjx8/v4q9F/8Jvfx3F6i0nYQhtzL5fbzqEypAh47/fCpv13QlE3/4vRHYaj+hu"
"TyM+8YKQGY1QlHUO5VTp3QtMHmRAp9gQmKM7oDDodryxLA6jn53NtfnyU/ZzGDrLKh/dy5MC"
"pORdc2RbBDbohZDYIQhs2It/5k2pvuu9R17SbpQVpHtElyLIqcQT1aOU3KmS8qDqHJv3nBQW"
"8TmP60dS0EhSej7q9Z2GiI7jENVtIhcmHtKvC4ovxfEdoUpnQULqJRSU6eAf0xWhre5jt2Zl"
"y7JKJdazuQYdmwXApC5h66fMWA8zvjmGW5rGcC8aYkrHxn48iE/m/4wxQ7siJjIUgYFBjhe9"
"tnaOCFQiKtQgTFU11u1Nw23tGqNLqyj8uOp3oWmvtN563+KPHUfTeQGHd3gU/35rMQwhjfg+"
"Tg74kCHjf9sKG9JWi0MnznPuqaV+dwQ27ssem7v6d4femsnXEN6AAspmPhDBqT8aYxAC6vfA"
"3cOGYuuBBPb4eFrl/ZpKTOFQYlFthVDuDFPtllJYupcepereg4wOT7Bw40WuW7t89hRoipM5"
"QpN6hYWbrdi376Cj1YpnaU4UNBKfcpFzvywxXRDUuB/2JahQNzocHWODOVDE2V6TLDBDcH34"
"CX5xzdxK/LpuntiexePQ58llyCsLwaGMEHyxYh/04jRBFZy3H0nD2D6RSNz8IUervP3VOrz8"
"7P04nvg5juVfqjKap2Ke2L5vJ6LhoPeReOE2nE9Ixri72+KliUP43779bDKWrNqJhX8exrev"
"3oZHB3/uovHeop1Y9Fe+xxWYZciQ8d+P36ZI8uP7NwfhxY/XYM3pILz8QCzu6iDlQh3+ZTq2"
"HUzg4rkdm3YSArUU76y6wNUj4GazXIq8ox5k/bs2xL9Gx/DPth9OxRMf/oGe3drhi8md+Gc7"
"fnoHPR6Zi6KiS0JJBNbY4nDmidE46V6s3zOrkFMYCI0h0NWTzBtc7z10/uEeV086k2XCPVN/"
"xSsPNMeuBWMkukLuPzljBbsZv5zcRRg7gcIKDK4R/z8Yo+dYB7RvhlqGPLz90yWMHtSeG46y"
"/P/kuSt+P3nH53j4tV9wTBhPVV1TqSUmlPOHAiW+XpeK2Qt/R/bZjdx4zFS7BYIaRUMXUAdz"
"N1xEbuJRoRXr4WSqFV3H/4yc+O1MiCZ39uL13APHHFVLKLoCV4Fert4hvn79exJmL1qP3Pht"
"fHlnDGuGvhNXoDDzFCulrzekoeRSghQJKU4oHbr1RsKFbPQd9QJPdg+xsN6aNAJzls7jv1XI"
"yc4yZNzwqCh/FFYtu4cowZgCKgrTjkErrJeAerfhjcVqTP3gKLLP/cnXGvqAKD7JU4QzXS1Y"
"6t7Guat0VcFVzh3Ry075o3Sc7Z1q483vkpGXeE5q7URBYg53GVkz+xLVaDn2R+Sc38ZuM2Ot"
"WATpM6GkRFwhq9yhT0jKKEfbJ49yfhv1ISM5RhZFQP1gdlNW7k5PVTQoUtFd+tW9h19EUzYo"
"nNGPNaGv1OgQnxeJe19ZjwIxD1SlhFOwKEJdvMOE2afY7Zobv6NG/H9qzlnB1y1Cl+xmq8q/"
"Tid8v/E8Fv20Gdln/hDyP55jHoiOVGi5hMP7A+oboQis61ovzkCbK5QY3WVRqCQprKAmAzjK"
"kOqDkW+SzEaNORyWerczk1R6M5fLV+kDeMD0QPLrkgnONcXsClc/HFeGtUIhTgYRCGx4h0Rb"
"78+DJRchMZfMbUNQQ/43hVqLUk0wK8KU3f9hOhQIMun1eSgTytUWECO7FGXI+F9QYkIpcOsU"
"R7kiFngaE9/xUCQc7XMqQaTQGKEPbohgITOobh73LxSHZpYz4nuNUSpRJAnQ8iuEKMmfioKU"
"oNKaudYr5W2Ry40P3hQ0ZgxiWiQ8AxrqYSvtxDKNOmc4y025Q9+hoTlliO5yjKHNpOeyTPWX"
"3rlSkMJlBeMm/Wreg6I6ScHYXLRqRp9y3PzrdIY+sD6nQlWkS/LcGNZcfF+7RvwXEwqD4AXl"
"I7v+Tsytzj8SgY37VZkzR4cHCjTk6vXWqpQYtS1waGhSYrRg6FP5tKTgnIegy4SFFlWHmiud"
"JEpdi9GlxBxfyfdL4aTkF3YHGWWluG/GNuQl7OT8M4WjtTUpWUmB2WUJIEPGja/GHEJJqrdK"
"gk6l0cMoDreVodKEs4vsWrie/EElS0PBAjTomrSo/FFl92FN6LvoCKVlDG1SpQXqzfjh5ntU"
"zKf1aPzCQKE7qapAeWigT03oCxle+e/gmHOqlXg9SPQlK8/uCLypYImVSR+H6efxcrRKNJyF"
"IKUHl1dgjN19+uIUQyX3/et2cZR9sXMlD/aLKtRX5QvIkCHjRoSC9zrLDaX6v0f+yPT/O+k7"
"dZXjEKAYNmyYbM7IkCFDhowbEmyJnTSOlGohcka20av8q8qauG7quzgfPlmYkGr2X0suQW/p"
"l7K/mnLS6md8itP+D8HZDkbhqDLtMX3n/aBdKjXTpPBb5g/RpPs5/irTl+nL9D2nz5HF0n5t"
"lLsA50Kf4lJ0Uvki7Q0gf2T6/5f0qSgGt2IpvMjrk1ejtDA1rod4UwnD5nQPoEKUi+sFtHzn"
"5j198QQKLnFq4gotEqTLXh9sYsdEoBCs4F0T4CshIdOX6d+09CvUIswFKzBJNmhvEPkj0/+/"
"pK+wOnSVYx1KSoxOWI6gCaVjMXmKqqJnKr+AL+jTV7ujDApHRqqcSthLJlVxMcn9eHw1CTJ9"
"mb5M33X/znu6ggV2o8gfmf7/HX27qlyS944UrgqWmJofIiky98w9Soym/mOUO9C7pRE9mqlx"
"NO4Svl5/yaVYmL5Kc8ULuEN/8kADTNpyrNiahn3xCnRsGogh7fQ4JugvcNGXmEGRihU3gCf0"
"KSGQChpn5+Rj54kcrs6ssGsc9I1e07+jdRB6Ntch8UIuN/ejkFGlyugz+g/2CkWTcCWOns++"
"iv++oE/8oTUyZUAQPvn5PHIK4Upx8OX4KRSYmuztPlPKQTy+oh9d24In+piQQPz/OcGn/FeJ"
"cd7VKdBlxRyLzxNrNAtqR3kcX4z/yvWf6vP5da5Paf96Rz8iQCFkg5bD4L/ekI60Aj06NvHH"
"4La6K8fvOElXVmCe0Cd6PZtrxf61iv1byqHbnsqfquj3vjUAPWM1jv17gdePL+k/0DMITWor"
"xP4t81p+Xos/5K2aNNhP2r+lNraQfD1+m1Xr2L/Frv3rC/pRYX5i/xp5/360IkG6OnKsH2VF"
"JaZ0POCyaV/1p10DHb4a54/7uxmQl3IArSNLMP4OE+Yu344wfS4Gtii/oiRM5QVaHf3pI8yI"
"T8nEklXb8ebYurCUn8GM+wKx7Lf93LJlYPNSTsT2FX1l7gmM66HC5MFm1DNfRNGlOD4lVlxE"
"3tBvFpDs4o/enoXxvfUozb3gChH1Bf0hbfWYs/Qv9GquF/wpQWlemk/5U16cizFdDVznMsAa"
"h7L8NFe1AV/Q7ykOQJ9/uw2zF67Fps27YKW6eArfrZ9ZD1qwbO1RGJj/Op/yf/funfjixwP4"
"/LsdCLfYkJZwDEUZJx1lebynH6WN5/U/9/udrGh8Pb8dwtN9un/H32FEfFI69h86hk/GRUFV"
"cBbTRwb4bP9Wpl8geD2up9pn+7cy/RhDMv/MV/u3KvpDhIKnqhu+2L9V8cdaVsQVk3yxf6ui"
"z/tX8McX+7eq9TNrLO3fY7x/qYN1ad4FV91Gj2qe7D5dhPmr49gtkHN+KxqGFOPImTTs3rkN"
"Ccnp6BQbhELxYp52Q6WajItXbsfmPWf4Aviu9iZs2XMK6zdswObdJ7jUSWH6CZ/R1xSew5Jf"
"dktdSrMTuO2Cs6K+L+hbkCb+exv27t0n+JPJPXSKMn3HH4n+VlePtYyUOEH/NAe++Io/rWrn"
"oJZfMVsaVHmAOrB62s+tKvp+Ohse6heNvu0jKWtIWvRKjU/o3xFLLSUuYWh7Iy6mp3KhURq/"
"p7XxKtPXFifi0Il4dG1dFwkpWfj629VSwqZC4RP6tJfIQ9AmqgxmgwqnTxzi5oFWDxspVqbf"
"rFYpDh49jV07Nvtk/yZmFOCvHYe5I3B2Th4Gt7Jj675zWP/HJp/s38r085P3CwF3ROry7IP9"
"W5m+Ov8Mlv66B/v2H/TJ/q2S/i97WHH5Yv9WxZ9bwwtQ26/UJ/u3Kvp+Ojse9tH+rUz/9vpF"
"Yv/mVNi/v0tKzNHyyyMlRqZhao6SN6mttBDf/n4MsXUD8OmLwzHgtmbMHGqf4mke16e/ZaBb"
"2wbY+OUj+HbNYWRdzOBMdLoQVhksHIFIJwlf0Y9LSOWNzRap02/vRW3GyvS//3Urlq0+iDf/"
"NQyjBrbF7KWbJAHkYUvyqukf4hYMVHGaFr+1JM/j/kdV8efhvtF475ttfBlPfKf6mZ7yqCr6"
"v24+jtmL/4C/nxb/GtXaMd9lPqFfKjYDWUUffbFc0Ndh9KAOnjc5rIL+eXFqpHuje3s2wBcr"
"9nI1A31gXS6J5Av6YjK5ojrxJD4pFc0bhMIqLGNf8efj/6xEi0bhYv/e45P9+9lvmejapgEG"
"9miJ7NwClBVlS7Tsvtm/lemXF2U59q/KJ/u3Mv2NW3Yxn2Y+N9Qn+7dK+kIJTxjT0yf7tyr+"
"PNg7FO8t2uGT/VsV/dVbTmHO0j99sn8r06dC9FTF6eOvvuf9O2ZQR+lO1VHtxDMlJoQ9lZxS"
"CCVGZfFbNgjD95vOY/aSTTh47BwOHD55RQ2vmuKhPuF4dFBTvDR7A96c+ytSssq5ujGZmoEW"
"M46czZRMYR/R1wfU4RbkdMfD/n8v2iJURb92TCxWzXkcuYVWdH9wFm846lxNZbd8Qf+h+wbj"
"qYcGYNKc/Vj62z4M7t3ucgSYD+iPHdGHfdLLXr2Nef7SxPuEEM0RJ6ESn9DveVsnFJRpcSpN"
"geSLwtrQK9jS8PSkW9X6ySko5QaEyZklQlCYeJPZrCU+Wz8Dbo8VzygRFs0ZrkhD/ZA8DSWu"
"TL9Hlzbs6Zi95A9s2XsWrWIbSoLaR/xv37Ezlq87zkLIF/v3m2frY/3+LDwyYw1uaRLNwr5O"
"eBDvWV/s38r0WzSOkK5DqMuwD/ZvZfpd2zXDj7PuR25BmU/2b2X6U8YPxeP3dsak2ft8sn8r"
"05/8aF9EBWux9KXOPtm/lenfP6QjcvKLcSLF6pP9W5m+3V4uLLJcHDl9wbF//dh4ctaD9DhW"
"VsGuEikvKzGzCK8+2g6Nayu4xcq/31zI9RA97Sg6tB35RNNw922RGNGjHqbNP4BBGYVY+NYY"
"xEQEY9ATK6WcNq3RJ/Tf+PY8bPoA6Z18UFO4Mv3DiWWCLxqE+5fh4ymDcDyxEIs2F7qia7yl"
"P+v7k3h8ZBQiAtVoXj8Y/35rkSPPx+oT+tO/OYLv//yB+/wc+OHfmPbul2KB+lXfwdtN+h/9"
"eBZv3NEYsTH+sJi0eP79HwRtq8cn3SrXjxjqF29NEOsnBBOmLRUbwOqxEK1q/VDgwtb95/l0"
"SFVmqNSQr/j/4fKjGDWgNea+MQ63NK2DKW8vkypceHiSrkx/3pp43Ne/NWLrBflk/5IAevfx"
"FuIUXR9b9p0VFvYG3NqyCRa+KfZvZIjX+7cy/cMnkxHYoDGk+qze79/K9OtFhTJfaptLfbJ/"
"K9P/fPE6rPn6JXFQNIn9G+L1/q1M/605P+L9r/9k/hz88QWv929l+j//vgurF0zl/mUWk87r"
"/XvV+lkk1k+LJtL+jQzFE68uuqK/mcdK7GSqDSOnbeZT54VcNQa/vAsx+iQcOHQM+uAGXGVe"
"YwjwiPaEz07DnrGTXQ4aQxDyivWYPPcQGoWWYf+Bw7y5TLXqQq3z9wn97Bwz/Iwl3BI7+dQ5"
"aE1hru7SvqB/Mg3Yuf8USrLjeSGlFYkFpA332NyuTD8xQ4N+T/+ExrXsiDufIE5FJTAE1eP8"
"G1/Qz83XsWWhD66Pe15YhTNZRkE/xmMhd9X4M3Xo99yv3LL9wJHTHEmlp/Hr/X23fr44jMah"
"VpyLi0NukQ0GsUZ9RZ/Wz6zvTyAjNR76wBip3bwQcHZYfUI/KUONvhN/QqPadsTHrxIWX5k0"
"vx66KyvTP0Xr59lVgj/lwgo74fX+/WZTNlb+fhx6e7ZQMIlMa/Lcw2gaqfXJ/q1MnyxhjSkU"
"b33vm/1bmT7N5fHExSgrzBS7V+n1/q1MX6mphT5PLUezaKNP9m9l+rTWDSGNudi6L/ZvZfoq"
"TRh3I2kWbfDJ/q1y/XxxBM0i9WL/rhYWcanUV4wKzZd5Y4mptMiyR8E/xuxIhlQhIUcj/juA"
"B8+ViVWekU8vMqGotC7KrcI6KlAKwRDAizSxrFDQ94NCLVW1plYBvqCv8w/gtghFCg1Xg6Zi"
"Ap724Kly/EFGnC/Uotxm5At/hVbLwsPTi8/K9A1BFrFAA5FALjKLGf5BWsGfULFI/Xw0/gB2"
"n9Az8gpqI7hpuOC9XupW4JP5lcYfX1wAc6Q/by5aU0q11qfrJ0Hw3mYxwuzkj4ddEKpaP8WK"
"IPiFk9CXqpZ7g2vNbxLNb0Ag/IN9Pb/+XKE9gfdXkNf7l+bukq0RSnNTuC0T3RHS+BOLLvlk"
"/1ZFX+sfiSJhmfpi/1amz7y3K1Bmz2Q3lrf79+rxh3El+oSiLJ/s32vxhwoa5+V7v3+vNf54"
"MX5f7N9rrZ+E4mzev34BCnYb2x2BWZ4rMaG0aPBUdZhciuTj5vYC5UJQkJtDmJI2h8+ypiBX"
"g6lWC5fJyBe2jpwwauXyd9Gn99BbNI5WC2W+pS8+5B6wCf443QTOEF1f8sdWXleib7e62i/4"
"jL5CISW+Uv6HoyWFr8f/d68frX/438QfDa8fZ7kdu4dj/z+dXx/xn6wg6sbM7TqIPhciULEg"
"ogr0fxd9+p5+7u3+rYo+88Zazyf791rj1wh5ahOWvLfze03+OObe2/17vfH/3euH+kySIcBl"
"pxx3etUqsW+fMiEi6PKvjf/oIB7pXx8dGl8+6bSZsIXbo3D5J1IGVLLGDVfK6M4qjvkn0KXp"
"zhNZyCsC3voxk7Wxqipztwb029ZVYMYIP5gNShyLz8XOkzmw+Onx1opM7qpaJX3OnXDPsf7b"
"ZDPTrgofrTjDwQpTR9bhBn9kCUiVD1SuxnR2a/V3GptfudwhOymjEEOnHcKIXg3x/PCwKvlP"
"oa02lLlFm1rATxqoRa8WkkVCPMortGL9AWHO7y9jHl2VXe8o71XVfcyssQHo0Mjoev/FW4p5"
"YTtdOxXX0oxFJ7Bqv41PnFc8w835rciXqnhf+dmuDVID/tAd7+SBOjSNlGjsOHYRUWFGTPjs"
"FDLKLK5yZ5UY5NbacY7/9z1pmLowWWzOcD4pV+YRrdGp90a61hB5DNwZvztzq/Rwf1XsVlwZ"
"dK2QURYi0a/Eexakbs4vPWPSAB3aN9S75rR5vSD8uCNbSr4X1uJVLkO+03Z//04aoOH7Qefc"
"7jqVz9bDos0FfCC/evyGGu9f57o/lpCHFxbEizVZi+eZxlkVf2qyPivKTxp/clYZTiaXYuW+"
"UkkWVOVSvc7+dWd/zV9zHrPX5rKCIWvOk/kd3FqJfw++rD9o7N9sSMfsfzarcg87FbCTP67+"
"lM49XR2j7pp5Gu8t3In45AzUuvU+rP31Zzzy+u9IvJCDNz75DrXbPoi8pD01jkR5vKeaJ+Cl"
"T35HVLeJuO+ZT1Dbrwy68jTkxG3h4o7egDbxjBEmPPPhRtS942Uea++Wftw5Ojd+O3eG9ZY+"
"+WYHT5iDyE7jBX8y8fpHS5gfM2f/jBB1BuYv+QmxoxahKNPzSJ32zx3Gy59twKHj59G+/xPc"
"DfX7TXEYNX0btuw9g/B2DyE3YYdH9D+438D3aEMmfIHo257BN9+vQ9MoPVR5J8Sc7uUurTXB"
"k7NP45W5W5GTV4iezVS4dGaDax5JIfg51nxoi2GYN3+RlKtVXuoxX5atOYS/dh5BrdajeQ3F"
"9HyB8/EK04/zmuSESw9BQnTWAybOVWk5+FXBn2ex/+ARRIUIJZK6hbuRe3pSrjj+vu1qYUTL"
"TM47ojQA2m9HzqZj8sz5+OKLL7H4523cYbima8jXc1sRJq2VlWK30W8hsvMTqNNjCg6dTJQi"
"GzcuFnss3qsQd+L9V4+ZYVQVodVdbyD69n9BV3aBq4ooLx1CQdrRKhsn1gRfPmpE2xgFhvzz"
"P4L+c/h59Z8Ye0cY1EXxzB+rh/u1qoM0WTx33BqIssR1vOY9DSiqTHdIGw16j18s1v3z2LRl"
"F+7uVhv5qQeRn3KA1603cK7PVet3oXab+xHd7Wm8OfcXPHxnXXQKi+MgL0/zzH7akYtbH1sn"
"HSSmz8Xwh1/Aho1/4bWvduPwqWR0GPQ0PvhkHoqz410FA65ruVXretCZXRd0ZB6SBp43tTde"
"nrMJny1cy83N+NJQb6nRIr3/NhPe+c8fmPf1YvYvn88PEwpnE/xNOpTkJnk9CY1rSx1j169b"
"L06vJhxI9cMrn//FETklLDy92wR5xTYMfmUvlxgyhjXlEi7kBqCTwvy18Xjtyx18MUsnbArf"
"rwl/Krt+Np6w45ZmddGycSQ3jqP7iy6tojk5m+aG/N01pU+nIbpop0i0PXt2cV7Tyr0leGf+"
"RlhLCzlxuqbJwOSn1ohx/LLxgBhvPQQrElGWd4Ej6drG2LFm+3n+vdLcVLYqaNye+s3pfSVL"
"WupFZRRr0FKvG15fchbzVp3gzuDeYHRnaT7vGTcdWZnp3B79k1UpWPLLLpiEcC3Lz/B4E1cc"
"/6cLfsGUf/RFtPosSnKSeM2QgqADiprnNlzMTb0araG/Y24r4mRyGUa9vgOpl8BuyWeeGMOh"
"0A//cxqs1JXd4Vr1jvflGDFuBi5mpMIU1gyf/pKKz5dvg0GRL/iU7JZwuz5/NBwFuGf3Tr7v"
"/Vnw56VP18NPWy4E9HmPE40ro0dTBZ79YCN/f3fXWhx67mlU4BXyrZYNR86k48zJIyxjKBji"
"7XkbUF50Sci3VI9deZXXZ05eEVtuFFyxL16a0zBjvlCWhzzO86M9T3tfco+X8Fq5vfMtuLNz"
"XQwc9xFblLTedSwfqr83rdadSBekGqNUXJeIfj1jOH7YnIwdR9MR0KAnvxxHitQgGqh7U8kU"
"PH3iMLe/DmjYm7u4FojT4ROfHIYhuCE6xgbhxfuMiAzSXGFeqrnTavXuguNJYqHYDVg1ZzzW"
"7krC8n1GHMm2Yffy0xytExtjwdSRenYVJWUUYcq8UzibbZZMffduBTliL0jf31HnTMe5cxSV"
"Y6nbDZ1ig/Hp4zEVXCyeJdfSYrKpWvI79OzeFd9szOKABKp68OLHmTBHtIZfeKsaKzE6hRKo"
"yoohJBaBjfqwC3ftmUQUCEtm5jODcW/vRth5/BJyi8rRp00opnx1AhuPlYr3rDpqjfigNhqR"
"mlvIp/KBPW7F0l0pMIQ2Qbt6FnGqSxQ0G0JriUSP29rjy8mxyC0sx4I18Zg4vIFkoX+wF/sS"
"VNVezPMm05dRp3Ox/qLx5IP9OfpqwboU5nN0mB9mPhDJ1gfN7xtLz2J/sr5qF3IV6Nlcj/ik"
"C7iYnoKgJv0RKNYorfF3fzkhrKIAhEaE48sngpl+RfeoxmBxa306x//9n0mIidyJT14YghFT"
"V8Ou78JRe8bQWNzRIQZfTulW4zVU3dxOGN0Lz42K5bl9cs5Z/PxqK0QGa/DxirNY+FcuVORG"
"vt7KF0rKGNwIOnMEYusF4rmRkSxAU3NV6D/4LvznlW5XzStdQ+xPNkgNbd3g/aHjcchMT0Zw"
"kzuFnOnFvJ+78ZSwsguF0K4lxqvFG2MMrKydLqmnPo+T7uirKTDr5M/6dWvhH93RwZ8gbE9N"
"xvr9R1ieEY3K1xHPzz+L9GI/MRb3AoLIW0PVPQ6fTsGvmw5iyJ3dxAF3CUy1b+Go7g/G6NG+"
"gSR/kjOL8OTn53kc7hTIPZ5QgAn9ovHZKyO5TuFvx4xYtjtLKMlyNiw6NBbr/37zFWPPKAni"
"Q7DbSkysT5WwSCla1RzVDmOGNuJ8xYXfrcO0F5/BqP51ayQfLq8fLb8/ywzxnJ49uuLZe1uI"
"9f8bDEENuIv0fXe2wvN3h7lk/9PDG2LB70n49Ne0q/aw28cli1mP3776F/vrH+guTOOCi6wM"
"KKS4puGsdocLKetiptgIUrtxEsy0AIlZ/nU6iVNLGLYdSETd3i9i5pyVGNYpENlxf4nnZrj1"
"jIJSJSZ9foAFyuQHu2L3rNb4+pl6aClOjMSoN8fWwdb9cajX5zUuUdMyKAUF4nRB0Ufu6TAp"
"yIHDe4WAqHwxuT9Jj/GzDkjveXINl8Kxe3GRuvtsCcYM6cJh0QbkwKy343ziBT4EqD0IhTbr"
"JGFI5ZjopC5Fixn4e1LC7/ycja9+PiyEtHj29i3SGig9ibzEPdVayXRy++3Poxh6Z1eOMGoY"
"VICc/CKX9UuLcPvhVA6bpfwbEnRT3lrMLtNBrezITdrttiuwW5sGSPjzXbHIG3CpJHIlEv0X"
"RkQKyy8O9e+ciTc+W8H/zW7vomy36PobqVRVFgtsfVBdR689g1AuTRFQvzueG92aT5G0fsa/"
"PB8v398U5oJ9KHFYnu5CYwzAa/P28Gn0lbEtUXDhsFSZRmvgO9xx7++q8Rqqbm6X7rRj7c4E"
"lIq9lHV6HfpPXsdh3fni2eSapmog159flVh3QQipFS0USZjg8znMmruED58H0wM5nL7yvFI9"
"xtyEnVyJwh3ek7XCF/ziUEjFm7fOqI39c27HyR/G4eWxLdC9YSn8NGWoe8crGPXMZ3xoNOXu"
"4Eoj1fHfyR8qm0dpI6QUv3s2BHs+aovj347F2llDoLdmYPo9JjwyY62Y41fx59Z9GNUBKEw7"
"zony7lph249c4BD99fsvoVVsfTSJVLMl3KMJuJRYw8EfCItwMbvdc+I2uy3f9sRZ8cHS/eyd"
"mfZYJ+z+8Ba89XB9hIbXRVhUQzEvta8ae0H6MbfH7sSoAW0Qt/Zl7Pm4HdrWU7J7scBmxPT5"
"+/HlT4c8kg9XWMW92+LfD90ujAozbm9ULpSamT17K/eVcfEGQn3zRS5XRlc0xKPKe7hG0YkP"
"P/MGgkPD8fui6WITtxEno4tisuvVuL+QK6qHIk/U+st/Lzbyx4/Wwj/nJmDKf85iVPtyrJr9"
"hFA8UZycSRvcFNZUKLuw6nWMOKIfvGDByFf+QF7KPjz/j74Y3KcD5j7bGo/O/INPclSGiIRC"
"78e/QbkwjckapP/2Qb6kVLXZcWIgYVGmuiho28S4PHCzCIW56QTw0qhANInQilOWVQihRGkC"
"KUDFg1Bxu8svb5cqcjvChf2NWkwaES74X4C8EqU4vBjx1YKF+HjeDyzI/SJaVSskKGl87a4E"
"vPDEYLFpdWgdVcoKRW+/LARpzinwhTBxyhtYtGITb8jo8ECuG0dzoXXDatqy9zSGjHoKz054"
"kIuLkhCrHdOSAwLaN2yGZ0ZcviwOKDuFgpxgGN0Mv+b5ogt4R2QmoVdLE8L9deh9ixlvzf2N"
"hc+GgwFISL3EP1u85aQUFOBmtQ46lZbqo/Cvz/bguzf6iZPuBb6PobtChdLkOnW61hDxvpok"
"2+rm9vn5RVw9xmiy8iFDIax5ut+lw5zkinLPVUeBBWRtTP/gG74S8I/pxAFGBeX5V89rRJBQ"
"wifEIaAxdNWEjucWlrEip3VEY0+5ZEW7ibux4J/R+Gn1Rny+bIuwZloi40ITLoBwW7sm/HdU"
"j7EkMJTHcD1Qnp2LPw75Q3eR/+hSzEJ55IS3cc8997Ay/W5mf/F7/fm345PTkTdrJdSmUD54"
"V6vEYtXo0KgpH3Cc6N+lEWaviUN5cWNEBJrQsYlFWDNZ2D19TY1SPmhdLNmejjlLFiFEk8kl"
"5x64u5cQ8Dn442hhlWPP/+hXaIWh4HTluQNynz8t5lFjro0enVthyYcThEwwYPbaHOSXqjyS"
"DxVBFW6mf/A1/jNrKt587i4Me3aJMEDyOcWjsFyyGn/46RdhyR5m642S8GkPKDyxxMg3Sm0I"
"zlw04J35f+LJB/ritnr5Hl3wkflLaNWiEYd6Oi+B6a6MggIK0o7gzQejcGfXhpgqFs2Ud5ax"
"wpNKBbn3rMFtVHiwZzC7O0ObD8OcdfkY8tRXvMHr+0tBHRTcQUwJajoAIc0Gs5nvaQJgVdaI"
"M5lT5WE+UkUU2fzYpTiwe3O0r6/FX7uOsWuGosDgwf3DrpPSabt751ulSCvHwYJOjxRYQPcC"
"JIhJOBeU6YSA6orQVvcJS7m9lGRYDVKyFSyQqShun9ZB+Gv7wSuimZg/DhfoklU72AInNyP9"
"Dlk47t/ZKPgkPX9NPBasT7ui3NM942YguEl/Dj4Ib/8IEtNy3a50QVGDrZo35Fp2FasDtK1r"
"x+Y9J/lnVOmd7vYs9W533O3ZUJyTJKz5mp12SSDFF0Xi/UW78Py4/uyipNM6W/serKHq5rYo"
"65ykIMSYydppTpUW/PTSgdLNtdSjqRL33+6HFz5YgfOJqfCLbCMssUaSS7mqeVW7P6/r9qQz"
"7/3NRkdCsYI9Dpy3RvMgxjj+vm4Yd097rN58HF3vne64s5dq7FUX+r77VL6LP/z7Yi5pL6nF"
"uhZc4fWhVEnepWAhG8Ja3cuBQ52HTXWebty696fyVPX6TkNEx3H891R4eki/Liwz1+yI4/1M"
"9VTP/DoZ37x+N4ePu+vunjzIIKzPEJijO6Aw6Ha8sSwOo5+dzVUzyFqscuwKRY0Dbmg90PyZ"
"I9vicFY4V6WZMOYOIaOPSbnBHsoHJyhgkCIQpy84gNz8Ynw0qQ/ykvfxvJC1TzhyLhOm8FsQ"
"0vwusdduuyoJv0bSj/y1foLY8v0m/PbXccx8ehAsJcdQSmX9a8Cc0+kqvuR/5bmxuLt7FJ8G"
"KTJx2t16LrRJwqFP2zCxCXYiLj4Z9w+7HQEWs7TB3IzssZeV4MkBIZgy1MK9hchFOXLkGOSJ"
"U97Pv29HTm6BUMR9mN7wLiF4qF8dr7L8/25UdClGheixZ/cuvh9Ue1hV4ac9RbwAP3jtSTQI"
"LOAK2hR8MaabDot/2iq5lBwCjYQS+an9xOmX7z+v47MnH3xs3UCeq7U7xdwN7SrmMBHpKec4"
"8KMqhITX5UVKAvtyKR+7u7uMg43ICghu2l9stjYotJmw41gGJj46jJVa83Z3YP3y9xDRuLO0"
"MdyoLr9w40UE+JuwfPYUaIqTOTJwdCcVws1W7Nt3UKz/Y3zyJVDkWVSoCb/8sa8G7lygY2M/"
"9GlXm11sdAe4dLeaXdwUxEOHCE8j8NyZW7LEWjaK4IK/S15oA3+TBraSfLeEHI2d2pGs3noa"
"K1auhSm0KRo3b4P5T4ahnl+my2V4xbxymLTCrXld+GcOr5/ln02GtiSZ6Y3tFcYlmeg+igIZ"
"urSMwLYDCVj4w0Y8OXYA/11QYKAkh6qRERSCTnc77782AQ0d/KE7pHt61mNFSZ6evQlgF+sz"
"48ewV+DOQXdj/sevwFSruVuKhoJT4lMuclUVS0wXBDXux3e9VAO2Y2wwHuwRiDq1LOg+9hPU"
"6T4JkcE6hKjSODDDHVlKB4KZD0RwexWSywH1e+DuYUOxVfBk0/YDbAxUPfaaJThbzCbmN+2r"
"9p27s1X9545DUqshx/qsiXyoymNFub/2oFsx6fODvPb/Oag2Xws4cy0pMI8qmBjF+On6prIc"
"qVaJUY7DUwNroU54IJK3z0HbOnZ89mQjDLi9GRdS/ePLR9CvQQaKsxPdTvCkQby4+ALe/vJ3"
"vDVpBPbN7oZ5j/sL03UPNm7ZzYLmu41xeGNif2xdNhVvz/uDBc+3n/6LS/C749e1idMYtWcw"
"KPLYl779zbq4q6M/nnxjBYoVgXjqrZUY0qcjji9/iO9hKAS5WJxQayo4KNKJciqiQg2Y+sQQ"
"bJw3jk+6rSOL2TXKl84/vYMwQ77bC/R6LkVSLJu27mGXE0UpKj0sTVMMf4yeuRuHT6fi548e"
"xK73Y/HY7Xb8881VuJh5AdMf78aXqTzvOz7nNiClBenXvZOhPLGnBoVzlNFXU3uyoK8TEYz9"
"h45j0dsPsO+ekLp7Poa21bv4c2LDJ3i4bySGd6uFbm0bYsn7/3DM87XvJ4nndPhw3okNaaNj"
"FxxfSAurZebyJAQGBiFl5xeY91JfvPblTj7AcJ6MGw7jM1km3DP1V1aquxaMEesnBrdGiIPP"
"jGXMg49/TuDGqXG/v4IXRkRg6qxfWHFQkqY71vxvUyyIFIeRyQ924fs6Op3T3eqb36ewAKLo"
"MhKsn4yLrvEaqm5uyXL9WSg6Klj8+euPYtGPm9it8/JzD2JknyYoL7h4Xe8KWXQUCNK/ayMx"
"l//B6VXP4qcXm3CQVLTqJD6b0PDqeRXztOidsRyZWt3+TS/2x8jXNiJXjG/nfIn3tzcqxf1T"
"vmHLjDwEa3YmYmTfWCRu+QhHxHtu3nMK333xCgzI5d5311OWdPC7/92jbFX85ODPpP5qjH3p"
"O1zKzmErtaBUg8lz9vNB6PyGNzjw4NWvdroKO1wPFLAxtL0Jz45ohunjb+MI0zFDOmPWcz0l"
"mfrJc0hLPMUWd9zvr4r1+x427z6OM6elvn3uHCTI3Ur9x/q0Ccaej9tjx9sNEBGoxDtCVpZq"
"auPp99ZdNXZuFOqmpe3cXyTnnXdi/xkfJPb0UTw2+UO8/+oTeG5U6xrJh8oyk/Du1IfxzRv3"
"ok0dG5ZPlw6FE+7vg4Pz7nSt/Z0r38PD/WJYJlQVdakYNmyY/YzlETbpaHJJU1f055OVlB23"
"Wcq7EYuPQo2NYbHC+rrguMTL5eizgHq3w1S7OUfpkTKT2pCXISruZSTVm3FVYzQKYaWL6tzE"
"XZJfXvyMnk2BIn4RrXmxZp/7U2zueFdZKzoN0+UxWVUUWn49+rTZySyVckqK+S6KXIl0ijKK"
"8dLpovjiWRRknGDGU4CJX2RrDmeWEhqvP34nKMyUfPE557egULwP0efgFGHmlxdnI+uUpByN"
"gm90GmN/vVik7tK/8vRVzL17ssWz6LKeIubo5HPF7zgSMaunb+cL0vzUw8hP2c+8JZeP2mDh"
"cHXyPxddPMf94ujeh+adAhp0gXV5I1RFn074ecl7Oc+GKg7QyY/8/ESH3IREn3hBzzXQ3YgY"
"O+U/0T0WXeCTcC3MPM0WgV9UG3ZN1EubVeX46W8oDy1PjJ34SW5hOvFSugOtI3ofypehd6P5"
"p4MRzTutVXIbSXy6Nn/IJUWbhtY9uU7I7U3uNlqLfOIUFl5xVhwHodD70N/SO7D7jCovOKpG"
"XIs+9b3KOrlajO8g07TU7SrWdUcWkJTHSErNWKsF/w3vA8caokg9Oo1ygdhr0ldfd27pPoks"
"+zyxlnLi/uJ/5zkVp3u1KQQWsb8MnDairZI+9XGifXvp9DoWujRvRJ++p3cjtxgFKJTkpLjm"
"ldYA3bmZo9tzROB196/Yf7TmLu/fIleVeroDpgAVCgIrFHu3IFWqxUj7jvY8WVGWul14DCTo"
"ryl/aN+mHRfP2MNBatyZQ1jDHGBGHichg+h59J5kFYALO4eLNdSMA32I3rXGbxX7nuQB5XTS"
"z0he0V4ozklE9pk/WKbR/iJ69G7sYhX811kixPrpIFU1qWb9UJpQnqBPtCp2HJDGfiuvd+ob"
"VnHsNO80H5xQXY18cO4v2kPUH4zokouV5LLaEMR0aD5p/borH1zrx1rCMpMC9UgHkN4hdzRd"
"jVCeG0XQUqoJ7QvSOWSJc1BSvdv4eogO9LS+y/LT0TDnP1Jgh7Otut1RLqfiOYA2Lm0eqsxN"
"zKCLYjrtUpFTyq/g3CiNVAuNDLvLArTcdZpzZljbHKafzRF4oReCh0IsKefGZi1mq4KKd9IC"
"pfFY6nUXz77ITKVF6swpAGWcV0dfMJyULSkNOtETw2njq3UWadOR757KmAhhRAuJFjCZtaTs"
"3Bl/RWOW7kXIJ+wX0Ua6xxCTQnXPNGLCAhr2gq20E9cpI8vJWe7FffpXXLQxz4K5GoKWeVf5"
"jtBd/vPIqRBreEvmB90PVuQPR+WJ31aJd6FoUp53sXhpDdhsVdOneSFlwuViHEEnpLxoHuh0"
"SWuFNrNzzZDgo0MD8Z8v2IXQoEMK9WqiHCmlI+CnyvkVa8UkNqs+qL7DujfwPNBvEE+UvG6b"
"82amaClaWzoh2JRag0OBVc8fuofxr9NZjLE+ykty2IIjelquumASClFseLFuyCqmsdPapXG7"
"M79KjTjsCGFOQpHupugimwI2SHDShtaHNOSNTLyquIboPoB7Kdls16d/nblVOu5+SCDQWuVD"
"Ht3pcfuPMlYwCt7LVdOncdI8UQBLZc+Fc17pwFVxXuk9nbSr379apu0X2Y7TJ0g5kSAlt6Qz"
"SpSVjthjOosUxMFdA6x0d1nOe49bmVQjH+hAQ+kEVNiXfkfF9P1Z2BI9Erh0KKHDFssI8Wyt"
"Saopeb3xU96HQbwvB6BROSaqQ0nrzz8SgeIgy3wR78AyTexVUqj0PvR7NL/urB+qVUh1Imlv"
"saAvK7hifTrnoeLYSb6RLHVLPlfaX5f1gVaqpkTrXigXraDvrnxw8cchMy11b4NZzDEZDVIF"
"Fj3PBynyq69T9Kxz+F7PWu7SWa7oROepThKA6it8jLSpDJVe5DpGbgUGlbqqPFes9myr4MMk"
"pw4pP0kBXkmHXoxOJJWjgGpCnxak+jqVlKv695rQd90VioVNn6thvOrOyhP6/4+97wCPslr+"
"/m162fTeCDWE0HsVKVIkFAUVBQTLFSmKiiJdLyrFLr0I0qvSld47hF5CCZCeEAjpvX5n5t1d"
"lmWTbPP/6X32+OTesEnmPe+c6WfKU0kARPyuQU8pLWPgW3DNRuAzHh0tffGvhGXhbnihsa77"
"p3oXivdro8EnsXT7Z2hXX/ywsvKoqSWcU6LgjRom3T/BtbRxfOrexVpxwa3v/is8WxLw/G4O"
"XCaj9/4F3Ipp3jTnCwWOLN2CAbfgCu+JNfegl/ypQMaoHQYrTfUaTF3xQ7VaUONT5ftUhTNd"
"98+9CtXoQpe9m4a/1OSnwvA3Jf1owtOOH8nLUybwqHlixdIXNc40IgGhXBGmUTZClR5coiYY"
"ys3wzfDN8M3wzfDN8A2Dr9RVCk+M78RgXuZlXuZlXub1L1zsid12GMhxTine7GDwWHVtmrh6"
"8veI8RvHl810D8Z91czwzfDN8M3wzfDN8A2AT/kNPIol7zHq5m2UlBhdKvIDFA/RJ8//mZil"
"5ODx/z6JzStfwEbqZGGGb4Zvhm+Gb4Zvhm8AfFmpQlcpEr8kJSZTDPXj9EobnRpQVrS0Zddp"
"voAZvhm+Gb4Zvhm+Gb4h8MstSxSTEizVlBh7Ylb8kMrqlJTL31WGQe1tOLVy5cGHCPJ1xkut"
"XRRupBUiY0ux4sBDWCkyrCQFaVVlHVRF8FNy7dC6rjP6NLdFZHS6gJ2u6BxvbTL4XZu4onOY"
"NW4I+CuNhK9cncOs4OtUilWHH6N1qCv6tXQwyf61waeU4K4NHZCRWYqzt4qkwkYTwn+hqRsP"
"WKTWY3N3PJB68pkQ/rAunqjrb4UbMcV/C/4JP/T3n/WRY+72GGQWlbGFaOr9l5XaYPPxJG6t"
"RmnBpoIf5OOEUT2cEUf4325a/N+Mz+EG25yWbgL+/f9B/0r6NAX/OtkD48IdOBMu4WEeFuxO"
"RZsGPlzAbIr9a4NPqfFdG8lNwr/a4FNnmC5CPpiCf7XBH9Y9EKEm4t+K8EP8RPw7e8tjZAhd"
"oxyWaaGuxCwUD5ApHlbR14gXHBCb8BCXrkZi7vBAHDkRgaXbr2Px72fg51KGlLhIqS2JYuaP"
"ZiGdvvDdymPx1UBXLP7jHDrXt0V4/UJuFaPS9EbCb+DxkD9bvOk0vO2yuOM2tb4yFD59UbPV"
"ES/IUdsjHxaZkfjmDQ9s2HUJzYMh9l+EopyHJoNPBYLvd7bGuD5OqOH0GPmKfpbqRGQM/Go2"
"MRjZzYnxY1eexi2HirIeqFJcTQG/bwt77kDQpb6d0eerDT9UK0YteoiRXUujeRqAsvOCKeB3"
"DrPBIoGfBav34sjxc1IXfpnp6Gf2W+7YsDcS9ox/W5PinwYSLtl6xWT8qwnftSSK6d9U/KsJ"
"v4Fbooo+TcG/nevZcr++heuOYvWWw7ApSRH79zQZ/2rCL8hMZPljKv7VhF/DNRMje7iYjH+1"
"wScDxVT8qw0/lLav5F/SB9zqUCNsqdeKf5SLY2eusWDIyMzmzgDUWLQ9tQBKSsPKjbulIkiZ"
"Yf3gNeEnRZ3jXofNg0qElrZE1K2rPFyu1MDecprwa7qk42rkfZ6/FJf4EG3C3HmsR4kR011p"
"NPzpa4l8+di3hS33xDtw6AiPFKBZYFSxbir4eSk3sOngbZy6msidIKgKvszIoX7q8K3zY7F+"
"90VcvHRF4CeVZyTRJGJT7Z/h77rIhE/M+ygpmjvZGzOYUBM/zauVwVdexGm51MmAJuwaM9RS"
"Ez5NrX67RxC6twzgwlxmWgtrk8B/vm450jOzWFA8fpjMjWR5KrYRgy3V4ZPCuhmbZTL+1YSf"
"fP8St9IyFf9qwqdRP1dvxZiMfx1tinnO1zvhtbm91oDn/HH6apLJ+FcTPuF5y4kUk/GvJnxn"
"Oxk27b9tMv7VDv+WyfhXG35a1LZV8W8e8W/2A1WKvUFKbP6uVCb48E4NkZGVy1YnVXC/2rk6"
"lmy5wBXj1CZE32aTFcGn8B91fKDOG7EJyahfy4tbHKkX0RkDf+XGv7j787zJ/bkhKh0EtV0x"
"dHIpjai4fu8RomPiFNk0+VK/OGH5WNq7cNcR8gRMBZ8OMzG1SBpxAkVBoBHj4TXhH4+IZCaY"
"MbYf3ghvjgXrj0gCqKzUdPAP3MGowZ25azwRP3UDMHT+mjb8DO3qhR/WnOEiUMJ7aXGBwTjS"
"Bp9mai1cfxTOcht8+kZTPm9D6VMTvpMdNaIoxJylfwj4thjUu5Wis75p9s/3Cg7uJuNfTfgU"
"CqUOI6biX0341AS4QS3T8S+Npdl9Igprd5zmYaVWpYJeiiR6NAX/asJ3kOUgQRjWpuJfTfiX"
"hYG+6eAdzPjENPyrHf5djBpkGv7Vhp8hHRzww+rTCv7NlQw4RastK0MesuqTmhg75zSW/HEW"
"Z5cPQYMQf4Q1cUNmTgE3EqVWMeojMYyF/0rPFsLSisX8tftZKzcOq42yv+4yY5sC/ss92mLd"
"nxHcRHRQeAvExCU91Y9M39W5nhUcrV1RVhLGs3eSHjxCNV9Xdn/dXJwEA6ZKoSwTwX+x/Q2c"
"Sirh3mZcImFhaZQXpgn/1Z7N8cl/XsLeM7F4fugv3IOShkNaVtINRR/4Mz8dgPxyJ3y24ALe"
"7OSGPl1b4ODlgwYzgSb86WOKeEL4+iltGedTxryOd77aZTD9aML/eMhjYQzl4FZiMRIfC6Ht"
"bcuehj4jKaqin/SMLG7om5hayDPXpLFEhSajH0c/e+EtmYZ/NeEXl5RJ/Ltmn0n4VxP+e693"
"Yf49FnETg4WCN5Z/iVbm705C+uNC5tkHSTF4vkkb5itT8K8mfNuiROSD2l1VNwn/asL3ssvG"
"4q/6Y+9Z0/CvJvxXn/OBm4cPPl1wHkM7uxvNv5rwB7R14dE266e2k/j3o0HcrFnZDNggJXbg"
"Uhq+f7+BYNyaOHHxHq7dTsRbAx1x8uJ9RhD1WeReZgZqek343y/ehj2rvsDi6cPRKLQaxn+7"
"Qee5ULrAP3ruFjbM/QQNQwJ5JMXnM1dzD0BDZ4u9+eMdZNw/gre7B7GHN2XWr/ht9hQe4Bcc"
"4IXeI3dINXk2DiaBv23XYXiE9QV37jbBRE9N+BZlBTyp19epCHPG98bN+DysOZ6nNjbFOPhf"
"/fgbDmz6CYFeDmylfz5rjdQKzUD60YT/yRdzpPZQQvBc3TYZ077/FSUFcu7vZwr4C5f/gf0b"
"v0eDml48l2vCj5sF7FKDLd2K6OfXWaME/Xhj1LT1wtsoNViIaqOfX2a2Zl4wBf9qwh//9WJx"
"vj9K/Fsv2Gj+1YS/bss+bP71S8G//oJ/bYzmXxpT89vkF3j+HI2GWrH5GNo2DcHqmcS/nkbz"
"ryb8mISHcKleRwrfmoB/NeE3quOj4N8Sk/CvJvyVm49g92/jEegt53E5xvKvJvw5K3Zh/rqj"
"rNCubJ0o+HcxSgqtVEYQd+y45zacu9hTLy4pq6TyFMjCrCS4Ft2EXXmGUGDx3NjWO6gO0h5L"
"jTRphpCNoxdryoC7E5BYe9YzF3v6wOfGkLZOqBfkgJjYeJ7MqpwvE5w4yyTwqcdhaKA9rly7"
"xU0oqVGtnVs1BEZ/oTd8umujoYaFmQmwKYjnkCU1r6wXZI9Ll69LzVkJPo1ej51mNHzygJ2D"
"28LVRc73hzILG27+SjgzBP+a8B8/foRGIQEozk9jwk/Jl6PIxo+t9WrxM4yGT/c91Cw4rJqc"
"Z4/RHCdjzvcZ+MJLoong1KDU0zIZt29cZPjywBYITphpEvjEO/XE/smTIR6is6WvanHfmIh+"
"vBk/96OjkZVfxj0P7T1rmwQ+0Y93UF2kp0mNgo3lX23nS8116wXLERubYDT/VkQ/9YIcceX6"
"baP5l7qju5TcQXF2CuKS07jZLnktdX1lgn+vGs2/mvBp7zSvixRN4p3TRvOvJnxK2qMZf8U5"
"D1gRGMu/mvDJeyQZGhpgg+iYWKP591n8yzm8TXj3tEjE7WsRPGnaXnwWkrfeME+Munukl9Xh"
"ESpOgT4cQy+ldvq2QdK9j62zUZbEs/C9mZDihRAtc3WFs4eN+MyLu1WbAj51VCZExeenC2Xg"
"zgTLnactDUIPW7H2tnW4gz5dPLtTh2xre8QXZAr4TpBZSV3/LaxtTQLfTcCndyK/gjpbk0NG"
"DGDo0oTv6ZOLBGH1FEPgv1BYcDY2PI7e0MQFTfge/kUMK64gA2UuznB2N+58n4GvwA99np3j"
"B49QP+6ub2lrKvhP9u8U4MLMRs+Tpj2bjn7iCrMEfhzgpMSPgRPDtdFPqcCH3KHQJPxb0fkm"
"0Pm6uhnNv8/A9ytkQS3xl4fx/Cu8rLQcAVtmC7l/sDSmiuSDeJZzsKPx/KsFPk1AyC8rMQ3/"
"asAnAz2htARF5e4oKzIB/2ru39GL+SkuN1XQp9x4/q0AP/SM7BwfuId6KspBhKeXZ2A4kbpH"
"0/A/HrlRXq4oPLOANeVlKdqN6DogU2f41LWZ5jS5SeNfiNnKDMwuqwg+zyAqyUcZhTnKSrUO"
"YNP3OTSnTBrQJ41Y51lBfxN8WvReyllEpoTPo1QIpsCPMkxQ1Rh4ffdP+DfF+VaGHwoD0Xgh"
"5UgcU+//76Yf5Zws0+NHWqbg3/9f50thUFPgXykfaHQPh6uoM4SQb9I4E7+/DT7JIlPwrzb4"
"FCamWY2m4N+K9k+Ggynl8zP4UfAvjW+i8TzKMgqtSkw5dVNzLd8TgwV7s/B2z2oY1cMNZ2+m"
"Y/TCe1IMnePPMugT1G1eXYavX5XzSPvI2CycvZ3JdwqztqTygDRNS5MUDQ90A/Xn0i2ervku"
"faaewzvhdbi4U7majTrBVh2PLSC3lzLOUPkB00XjxjHa8UTPeFTsye8gIV/CCcegq4A/qL0t"
"RnWXLOFBMy7ifqYzh8H6NrfG530k6yzhUR7fH9EaMfsKLiXaKwaHWj31PM3VoqYV5rzjJcWd"
"c4vR6fMIvsRXjqOhiavqz+g37SqP8SCrkIwUqZ7QUjV4s7IzoAyykd0qtsSewrkafqo63xY1"
"LPHLW8/ind5nzrZo7LhUqpj5pPCCZBo0qXiPiu5jdIE/6bUgvNRK/gz963K+tD7rZY1+LZ69"
"TzkT+Rgzfk/Ao0I3HnNBe6VUcvrdhEf54jyusAdASlhX+lee6ZDvbuDuY1umpacSBzTxowf/"
"qp8x4efsrTRk5wOztqZKnqjgX383meATaRzR12tuYceFAnHmblU+h2TDL0Odq+Crp/evK/51"
"lT2aYS/Gm47wadGEZ0oVV8rONmGemLgyDtumhj3LuzwxWlYp/6qvaf1t0aWBndafER19sCha"
"TS4rQdvrzL+VvQutzccSGFdkmCjxpKt81oRFeFj0UWPVv2dvuYu1JwrYaSGFpnEI0jmoTajW"
"mmLfcuw1bNhzFcfOXodP00EI7DAGC9YeFMqrOuo53MSSzeex92w8inIfIS1qP8cw9V1OYm9f"
"v+qIj38+jOovTMX0ub+ja0M5CtPjeLItDfIzxaJ3OXk5lu8V6rR7E9fP7eVR9Ut33OCaD99m"
"g5EVd0bvmglHm1Im/g6DZiGg7UhU6zQeV2/H40rkfVw+vFa8R6xBF9erDz1Cr/GH+fuZw4JQ"
"liL2lp+GbWcy8dnCS4hLeowWPUeg139+4t+hqb+5yVd1qhk6dycHTd8/hLjkdM5sa+V+C/mp"
"d1Rp1s2DZcjKKcQ3czehZa/RPNW1pDDbILzLrYux6cBtBHX4COO/XcefeTd6Fe0GTMHVW3GQ"
"Z53lqbT6pomfi8pF05HH+R2+mb0Ovs2HIqjjWMQmPMCHfQNR/uCEVIhqYNKDLvCnLb+EpTsj"
"mf5p+q2+9D/rjxS8N+uYRJ+9PoB/6+EIH/4L35m+38lCmsZcmKP63Z82XOG6oce3dvFdkD5L"
"eabtAx/yxG0u9TDBer+zFSuwKXP3sXx4/eO58JUXw7YkBZnRJzjMRysxrQQtxkTw9zQlW5oQ"
"X3VqekRUPp8D1Veu3nxI8OkQRF48ghIB15j08/8r2UMKns6sVvh3QjZ8Dm/7HL4zTb93CAPG"
"b9ebdzWXn0s5pszbj8B2o7Fm+wmVrH79ozlwsMxDxr3DUkG/idaHi+PwzvQDKpr9eMpPyE+7"
"98xQVF1hLd1+jb9/4bVPsXv7RtR7fRXfzb76/gz88MtCLvgu0zF7VasSI+tY5VkJgqGR5uej"
"JcvD2y5TCL57nMtPLjXdKxnCGCG+YGI8sP8ALK0dcTlZji8WHeOMMRq9TW6vKRa9y7jFV5GZ"
"nYvfl0xhC8TN3R3tGgVgxJRlnJRCF7Saw+OqWrcTi/HGN2cgZB0cfRrg45GD0ahuEN7+cBpK"
"xTsoQ6z6LrKyaSLsruO3OEV1yuA6yH1wjRXNnYcWrJDJOsmXSfstEQzHRYY6hMZ4eqzchy2Z"
"bbuOoE19by5KLCnMYsYm3FCqOLnpZNXauARIHoEBa96uR/hy6Vm2BpWTnulC/kGOHV6ZsBNJ"
"GeWqMKVe+BHvwJOnxTvwhGhh+cl9G2HvuUS4ODnAIus21wgZGirRBX5JXipyCqWzJYWpL/2T"
"lW+lGGhYJv6WvKuYXD9cv5vC9U5ZsWfEGTxS/S5NeCZckQJTKjddFkULqMiY6m3eCG/JdFSi"
"UC7GLII75DlHfPfbISxbuZbvV2JyvIVSOAJnR1vBvwl81pIHYMFhUOX5F2YSb1cdJqP7LJ5C"
"zZZ4OVveHDVQei1GrP8L2UOe3vEIopV0lp+fL7mOExeiOBklIyNLb97VXEN/vIWN+2/C1i2Y"
"J14rZfX5e0UYMG4L0015uemmbNE9L91zKWmW5CadhyH3sgRr3l8pnFS39IdPhewpx2dD2mDK"
"/AM4cemeNKjUye9ZL6wiGV+hErMrpinbvFG5f1OMeK2J0JT5OHziPMrsGvDIcVdXO+xa9hka"
"hQbj7M00jF54n6d16tLg8WYCFavZY+fCEUJAJGDTRQdczyhDxKYoDB3QFdOGN1e5lh/1r40V"
"+xIwf3eacL3deDy6Pkqs1L2pUGTXsOmrrvj87efh5e+FZX/eRpGNP9xCanFmkL4XqaSkHDzq"
"CGT7I6yGG8YODMC3yw4iOcsS7707BF+N6GDQ/kloktDPK8vDiKnLsWfFJERG78bGCzGwca8t"
"/r6Mz0MuFCetfi92xB/9u3A45/Olt3Ap3rLCC1UW0BSOEgd7+koCvp04BNN++4mZqXlTD+47"
"F+LjIsWk3arzVOSX2rioQozkeY6ae08oULcqkxasbF3gHNiKu1fYe0n7sXH2haN/Y1YKFOb6"
"oLcfZ2QR3NHzo1Bg5S2Eim3VSoYVsTXfUZABUrdxW4Q/H8geXnRsHCYM8sPY1z1U4b7tXzbm"
"yv85W+5h9bEszl6TGQHfx609Cw4Lq2Ks++l9PNcihMN9Q767jgILtyoZm35Ol+G0KGvVwb4e"
"WrXrhIYh7jhy6oLw8B5yd46pQ1yQleeI09eKWEjpW7f1fKiMIybJ0fcxclAn9GgdhNPJCRwi"
"blHLRhVOy8orFvRTIhSQFTp9elV7GEcDLq2oW9dYqbjW7spTgHOF1z5y7jXYe9SGq7MD5r9r"
"zxlrm4/nPwnH6WNMiHOwsC6Xsj2FsB4xsB3G9AvG/ouPBN1Ycz9GwvvIeTeRWuSusyFamezp"
"3LENfpvcXOCkBCv2xGJM/1pPhf50NerO3srAZ2+2YYW/42IxorO9MGr+HRQgGO5u1bTy7uVE"
"3ZONyNB1rdVZIS9cBZ5yWFY7Bbbk8x3cwQ4f9gng3913PgWTVicKo8BP1S9U32XJSsxSRbP2"
"9rVg5xrMyRaGwHL0aYgJy29j3eQWWPfzCJy5kYr9Eclwq9UFjr4N+B1+flOuCjsqQ4xWDm66"
"eWLK1YHa0Bz9XgiBhoiJT0avd3/Eg2wrsflqTGQNQwK4LuOV96YhNNAO3Ws+4CJPXdr55BZZ"
"4LNFl5k5xw1tj4hfmmLlxzXQUHgz28/nY+zc0/x7NZ0ec9jP0+oRMqOPscDVH2lyxBUG44fV"
"ZzFq8AvCGorH1p37hVD1g4NXXYM6ExBDkjXt6ROE6YO9uWPDL4vXMQP/eVXGhbvG7J88obup"
"Npi5ZDcmDH8RQTbRKCTrXDyXvWTFGII3BRNM+2EZVv2+F5Ne9UdW3FmU5GdUCX+32C9ZtD3b"
"VucWLp2EYDp5OYbPg0clyGTwd7diBfbR93s5pEYh1+GdrZCbckN4H/lVCGo7xi+NG1c3auiZ"
"1fxc+V5p6oLD6PDGTIQFO0OeE4GCtHt6WaWTRvbF/T2TMf0NT5y4eFfQ53eM/5X7k1k4KcPd"
"L47bz2m/OcITodAxdYswBj55s+QZtG8SzLVJ/xn3MwK97NGj9kPGjT7hoTPbvkPk+sFYPtoH"
"u47dwLhvlqFOSJhQYKGMd0rZ79G6Gl/yl+np8bWobsm1X3cf27GX17tLU8Gf9/gcx/W2x+5T"
"d1Ht+c+wZssRpD1+iNDOo5CdeJ4988pWucKTopIaspjJcpYUs6cQoi3gXK0NPuxXjT2aIeOW"
"c9sm9sR0xHtFa/mu+/jtrzvo1swLof7WGD5xobDiy9DOP5nPVtc2VpXJnkvxNvh0/nk2rkiB"
"jZ+1FldvxnA/RuKtUh3D62uOZmPJ5gsY1KcNNnz5HM7+EIq3e1QT8qYO3yNp491MutbQgXdZ"
"pgllR3KYYakZBySX29T3Qv92nmg5dDmCu0yCn3MxetZ5LPjrvkkSdkzi2Qn5kCYLxn+XnWcn"
"KCX+JopyHnHpiK1zAAa3t+WWgLV7/yBkxCy81S0ATnlXUJSV/MwVRKVKjNxf95AemLNsK3q0"
"8meidPJvBgfveizE6X6m7xujcfTMVRbUYcFOyEuJ1Ol+iSzdKw9cMPCLQxxTn7fiT8htSrD4"
"k6Z8V5JTIFl7m7f9if5vTcCIKUslBjIkHi4EMl1obzgvWbIXL17mPVJiAV2qGtMjjmLfFIr7"
"6qdVHFZxDm7DXkxeqYPR+6c9rzmWjV3Hb2LuhD6wyo6SCvzUwgRUuPvz/OX468hVVPP3gLss"
"kUMiVd01kSex69hNhHdqzP3aHK2LcTUymoWzsvs6dcVPeJiLzVt3sAX6+4E7CO8Yxg1vi/Me"
"GYwzsuSpG/jmbTvZkq7V61tuI0QxcH1CIN/M3cj0eenqDbbKuTFstdbC8wtBdn65KtxNipPC"
"33RHUSiYQNdOFxXBJwuUaIZi+C8N+Rjb/jqE2MSHbKBQzz592hE16/oWvBoOYCNh3IyVKLYL"
"RteuXXi/f2zdjtfHzMaxszekdjt63D9QOKtViCNurHkNkesGoUFtH/R5oRWsC+M5BLr/QqoQ"
"mJncIkhZFEz4oaQLqypS7FWhWsrsFbSinOtEtDPnXR/GN1nQfx68iENHT+KNj+dJ8I0UoBT9"
"yS604BBpn9dHYsv23cgQ35Pgp36DuuK9UtmTFi1kj0SDY8ZPx6/LVrASoyYI+Y9uoTg/XTfe"
"FQbuooP5qNlzOgaO+g479p/BJwMbYlAbK5Uhq8m7HrIEDjfCyDs/alIc4GGLiFVvI/bQDG7i"
"UNffkvm2xEhDwpSLEspef7EJFq47gqkfD0FokJ0kHwX9UFeWbs08cffPz3Bi/QTuzNKsWglf"
"f2g2KagiuCzjuPSWk1LH4N5dmkn1NYr7MipEe5BlAbfaL6hCEHQpqssdQZ9mlhja2YMVolf9"
"l7Fwfw76frCUhZi77MmdBnUzpuJLz/ovwaVGR9VdgiGeE7moqnsGGweO6xozZbRTqAWGdJRj"
"4k9b2FOVBzQTlkQdDk0q92nM/pV7/nZLKn8/bXibZ/B77XYC5P5N4Fy9vSJeTXdaj6uslqf3"
"PnMzDc+1DMGADr4cKiMviLMQFTihuwv6jAiL381T6ipARYi6WowVWfKUISUT/5HlTrjxCA1n"
"K0zfkBOFmf44Gs/WHEUO+L6JJ5QL4WplwzRZv7Y3Z56xwNXjPqUi+MoQyvWoZETGZEphHSt7"
"LvqkOhx9hLWlrSMcBQ+41nhO4KAXPOqFc6hRKmkoEUZRO/FvKfNUnw4L5Fn3+GgbAtt/wF/t"
"XvmSP3+xbU2ORJCSHNS7JRJPLeB+gxN+2Aw791rsKVQVWqcxM7QaN6jDpQpKw0x5B5ebcp3P"
"l5QKyQ+5X2MV3xllvYuzpHrR61EPcCshT+C9ExtcBJcSDHRt6FyZ7HFDrOr81u08w/RJd8P0"
"HDKydPWyl73vBjdXF7jWfB6R+fXw6dyzmDF/K+Mo7+FNrbxLd4Z0H21opwsVf4n9U0IM0ZNf"
"i2F8/uO/28gyu9zIshJTrve72GD/+Qf4YfUZ7Dx4Hgv/+ybcy+OEjEvlfc5YuJ3fgRKf/Nu8"
"j/V/ntPaCcSiKg+G4tLOgYLYHxdyTyyaudWrfiF7BKThmzVtiqZN6qNtAx8cv3BX59Yp5cWF"
"GN3LE+P7ubA7TCGIgQMHIzuvGLEJKaoOyHTxqqz+JoEiXXIbzgSSAFe0/TeiRxl5XzTSYPfJ"
"KGzZsReOXqEIqd8My0d7o4Y8VRV2MGT/netbo3U9VzhaSb3Dih1q4OtVkSxIyYorzn2SDUdx"
"dYp1D3whlCcJxCamVupY0qweuvuoX9MD+84/YBIY8XoHbPtz/5MUfYWg33+BZsW5sPFC6+V2"
"nth19IbRxHsrPp/bBYV3bsxKZeKrAUw//Hw9PDGyqAmnGZa1+d/tm1bH6J7UlSOFvaSGdfxZ"
"QK+b2Iwt6TIhJPTxhCuDT53ASTGSkSH3baiYx2ett1dPBiEJU+dq7eAU1Eookpq4EF3GsPt0"
"bc7td9o28NUzcUGGljVtEB2byHcPbnW6IVvejHsv9uvZAQWP7+Otbv5o0v9bFnKUMRoZky6U"
"TUPVXV1lK+qhJfacjsEXY4dhwPOB7O1SZuK0AXbcJogE8elrSejduQkr/l/HP2c6ySfQS01m"
"KYqiwjvTre5411X2ePpVZwOUPFNJVsigXlNXqXywKxNeqS9PT6AQdHDT3ngpvLMwah+rjNBn"
"eDcp1aiokHKdi8oRtFoDXTp1EEZJPYwdMxyffTQSDp61DbrD+jsWRbD6NrfFqj8O8h3b9A0x"
"cHWW46cxbTmDlRKphvTrgDqhDVjRb176FXr07i9dT2jI7SrqxDz5Tqz7mC3YG5GET14Nw+dv"
"2+HlT9Zj5OAuGPnln9g47xPO2qJRGjv3neZ2KVY2VV9+lgmNumHvdTha5uPSwo5S4kB0OkZP"
"34Khr3THzLHdpAvSHT/gu2WHsOnqAxYYMgMPWb0G6vtJw9C32018sCSWrU5LA3qskaVLyQIB"
"7esgOeK3p34WZHkb00f1Mmj/6nVi59cOR7fRG5Bd7ImrjzyxZMtF2FlYcAd2Wj9vug4vayu+"
"t4l/kIkRXyxnT48ufaXsuqetLvU6sR3z/oM3J67HnlP30KNNMBwscnHrj89Vd0GD+7ZFr88P"
"4ovFZVg8/T3+/NSVOE6/pzg8dQHQZW38wBH+7hI9JUcsx9T5B/HX1QT8uOYBFn39Dn9OqfgH"
"D0WwALdzDao08UW9jku5z/CJx7HnTCw+GBaOHfvPcip2UXYop00v+uZdrNl6hA2uqWOHIqd4"
"LfbceQxrO1eD4bevliaUgFTrs/aHd1GjejDfidHv08igyuDTkurEXFR3YsQ7P+yO5TsO8iqS"
"s63x08arWDzjffZs5q38i599dudP6Dl2l9SCp4LEC2n/Ev3c2TZaoh95fWweXx0B7oLd6/jh"
"0K++WCes2stbxqv+Lv5BBob/dAFppOSrUPTkcU5eewdXrt/BrM9exSxIncd/WBOBwyfoHKtj"
"1eE0zBL7WPP9O1i7/SRPjfj5649h852guahUoRjkVYZDlXVirUPb8N3Sj+su4oNwKdN17ffv"
"crsmJd5Jufx++aGCLmUGy57O7VsKw0GSPbcOzsX3K46hfwd6pg/WfDcMI2dfg41zQJWDHclY"
"2r73FKa82Z77LdL6detlbNhzGbXr1OP7eV/507xL1xFS4pWlTh7T07WqT2T1mUh7/Lg2Fb8v"
"miTx18G7+O+yc1JNl4GZnVJtV8U0qz8siX73zxuA7h9uweaZvYUesWNDfdFH2Xjv28Pid3rw"
"s2j9d+lZHlVDz4PGO3DvxLsu70itVQQBUJJDcfYDrn/JTrrEBE3ZIqTRC9Kj+eKasmAcvELY"
"vaZ6EKqeJlfYVrjdToGtuGeZssNDYPRUJNT4+pnBaPQ32YkXVRfhMiGcyZ0nhSIJeymGW5gR"
"x0zrUuM5thSp5Qu5yzyuoBL4motCGzQDKCP6GMfP6V0pVOMS3PYp61NZCFgVfPK0suLPIT1q"
"P8eZpXRgO/6efk4EQ2nSlFKsz/4Jp5QKTXUedHdBuHev8wJbnoSLrPgItqacApoz3qimiBIY"
"KJxCFil5fHLxN3TPoQmfzpLuGzOjj3N9GCkN6r9Hn9H5kddBVjTd69A5UNYmZefRPQElBNCZ"
"kuCQC+vUTliX9J5V4Z+s9IyYE8gW+yac0X2VS7W2TPh0vvRszoYUz+HQDXVgEM+pCD+0h8L0"
"GKnGJiVS2mdgcxYshDfCkYNPGOOnOOcRMsWz6f6TmJdwa+XoKZ7fBvbeoQzPEPhE/3SxTjih"
"8KEtdyko5nch/LhW71AhfMIPhXypZov2Rkk1RO9Ei04BTfnv+ZzEc+icaA+qMJkwgOh8KfRI"
"xkpF+CkQ+6J6JNoP9YykcD/RZkb0UU5OICG/7Kdx2CGMzp0HIpgX1v08EruP38KOy4Lfvepy"
"4lCl9C+8FeIj4gG+dxSfST3ugjl7lu47aG5bVvxZDoGTUCYapaQY4jl78YyK8EPw6d6D7j8y"
"BA44/CbOj8LNVIicn3Zfoldq6iwWnQPd2VJY11F4Z0RPlfEv478C2aM0EOh8iO7pGcTb+cJ7"
"pTtDp6CWcA5qza2tKsMP8Vf6vSMcduf3oTMU50eeBPEPPY/m0KnzLn3u6NeY96GLfCOc0h6J"
"VimxRSmrXWt05DPOSjjHtW8kL+i9CL61oGPVuBc95CfJMqId+qLvn6FZPeRnaUEGMmNPISvm"
"FNMR4dTRuz6HoTPFZ4R/unsmhZ4naIBkEtETySvqWUlZwyRLqD6zduZvkifG9x7c6kRqNyMT"
"lpajcOHoj5SZMNRShJSUg3cYMwQ1PAULhnw+qDJFfzprwRDKeL6S+aT/l6FMEb8s45CeLcMi"
"4UxzhohAKN5JqdmElPKyIqnNlDhgfp5wOcvJQlchqHL4WuxHVlYu1Z8TiG+hyC70ILPyqfYo"
"5brCF3uhMAH1mdMs+ON7E46hF+i9fyZ0gRP3ur347wn3lrZSVwtrIeDpXo1CbsRElnaAsxCY"
"JKS5J5o4fBu6P7G20wqfYNO5UQyeBA114SYBRmMZyhT9/0jZ08+kZBhX7llGioWUFuFGuu9z"
"Y0LXBf90D0XhMkk5lTNuuBcmecCCGB28Hgkbuozpi76eKDDt+CHjhhJenIQicvRtpNqnZMX6"
"MC7oTozwTR4pCXsWVFQSwP3Wihl3MrFTQ+FbcDKDJRt2BI+zL8W7UXoz05X4/YrgWyhox1YI"
"FTfqFF9SxHvjd5dZqmjRStAqna29OBvlHSZP+6Xwmfj9yvDDdC7oxCkgT0E/zqyUSEDaUlKK"
"WLeTS7Fk1mjVOe08eAErNv7FZRGlrvl8x1cp/1Ko1bMOnyEZC2WlBeyhEb1wmY3Ag704d0uB"
"C0lRWClmoJVWin8lfBLyfA5BrbgOU7oOsGMat/esy3hXJiDRnRvth86czqsq/q1M9tD9I/0t"
"vRfxlPKZyrPm8SWs4CuXD1biPF1rdWEepqsXEtZEJ9RNhvAjvZ/bU7xLbZZI4egs3wSv0NlK"
"99UhKllNeCM+I1lX7KnGX+TlqRSYnvKTzlvIAEk2l2qlWV3lJ8GiM6S/lwxjV8a9nI3mmqra"
"QlJcNsJgpNpGxh05WnQuihl+Sm/VSpltVK7SoFawFIikug9tS5ke+mQ5q4pZ8RSCilRD79SH"
"35WpXcTRJq0qmWmjDtcQ+JrLWkFA2i5CDYFfEbxKQxlVwOciT2p4Kb6e2qMi6cJaIzHEgsKH"
"ap9VBp8IgZjTUYd7D810XuV76ot/sqrsFcbQs+f77HtWBR+WkIheSziTPiNDS+3Cia33vw2+"
"AefL+BH74oJOZ78KaVH2N+BH/RzWnUnB4t/nCq/7jpRlKJQOZV1aU6G3zEqn861oj1zETgMk"
"hSDVPHu95EMF72EK/Fcle0iZGQxfQffazlftau8Z3jWEv4g3qUzIVPxVkfwko5VD/fRlrPwU"
"+NcGSxvOufZP7fck+JKXp0z+U/PEiqUvajxpVGZMsWLardRIVHpwiRpiys3wzfDN8P8/w+eE"
"Et+GPNKCwqwWwjrm+1QODZWb8W+G/8+Fr9RVCk+M78RgXuZlXuZlXub1L1zsid12GMj3WVJ9"
"jYNRtVOamrh68veI8RvH7U4obs09Bc3wzfDN8M3wzfDN8A2AT3eYdJdISYV18zZKSkyqtbBW"
"PcTC0sbgh0iuopTiaqGKpypfwIbvfMzwzfDN8M3wzfDN8A2BLytV6CpFpxhJicksFRrSRpUG"
"aejSlt2i+QJm+Gb4Zvhm+Gb4ZviGwC+3LFFMCbFUU2KKqnd6SEV1AuqLuj6MC3fgTJGEh3lY"
"sDsVw7oHItTfSnxGXauTuDWNMgVWUpBWldYhVAW/WoAnRvVwQdyDLMzd/oDTw5VuqbHwI+7m"
"oX87RaufMuqqXooVBx7CSjlQTk/4I7raws+5TBqhLf6b+XsC2tb3QZeGjohPycbcHcbtXxv8"
"Ac8FcMfwGzHFWHkgXRrSaEL4+ZDG83zWRy7wH4PMojJVR2xT7t8U9KMNvrubO0b2dBf4N55+"
"NOHvuZCGF1t6c8rz30U/9Wt54aVWzlyUu+JvOF8lfd6IyTCaftSfMXdHIlLy7NC6rgv6NLc1"
"yf61wacatc71bZCRWYqzt4q4E4cp4Xdt4sbdiuJJ/hjJv9rgv9nZA3V9ZSbh34rww0NWTcC/"
"le3fFPyrDX6gtxNGdnNg+T97Sxx7e0pPzEJdiVkoHqBqy1TBV+d6ttwTcOG6o1i95TAKMhPR"
"pb4tFm06jQWr9+LI8XMopU7YisJ5zUI6feHblKRg9tue2LA3EvblafyCRVkPVCmWxsI/euYa"
"lu6IxOLfz8DPpQwpcZHIf3RbNZRNX/g0wPLXHTdw+cYd+DkVw6XwJkb2cGb82PH+7Yzavzb4"
"NP134fqj4hzsEF6/kOcUqSwhI+En3DzBBauD29sLQecA19JoaeCeonLeFPA7h9lg0caTJqEf"
"TfhZcefwy9te2Lj3uknoRxP+9u07sOSPc1j0N9EP0q5g+hveTJ+dBZ+Z+nyDrO5jZHeiz1Pw"
"tsviju3K0e+GwB/XxxElBdk4evYG5r4fBMucu/hqoCs27LrEzWnD6xdJg0tNBD/34S2erjCu"
"jxNqOD3mgYpcU6emBIyBX80uESNecMBiE/GvNvjUgmnhhuMm4V9t+KHm0YM7mIZ/tcGnhr2m"
"kv/a6OeXYS4q+U/DWKlJgLKFnEE9SBxtirltyDvhtbn1EhUY0lyit3sEoXvLALbueNMWhl3g"
"acKn0QsZWXk8Y+nxw2Ss+uOAIKJEgyaiaoNPSL7z0JJb48QlpWHlxt1SAbOBLa6SMi0Q9dAK"
"A7s3wOffrYe9LBfrBQNfvHwFcYmp3HcvP/W23tOkK4W/+yILBmLeR0nR3O1A2QPOWPh0gdqy"
"th18naSGwNSJgfCva8NVXeAT/bzVI9gk9KMJX6KfbPRrJTcJ/WjCp3O8mVgojS76G+jncUoC"
"t59qVq1M4MkSUbeu8sij0uJ8k8APDbTB1VuxOH/utKDPh2gT5s5dWwylz4SUXB48WdfPEjFx"
"SejTGDh58T4OHDrC0y5a13Pj7jmmgp+TeEkYKDe4LRF1OqFOImUG0r42+Fa5d7H+r/O4eMk0"
"/FsRfB6QaQL+1YafJv658JWbhn+1wZfblptM/mvC71irAOkZmWryf5+kxBTd7A1SYtQnbfeJ"
"KJ4YO3diXzjIcrD3TCwWrDsCZ7kNPn2jKTe5fKoI0wj47nZF3BlkztLfBXxbDOrdSlH9X2YS"
"+I6WBey+v9q5OpZsucBF1tSmxZA5Y7SoQ/67fUJxMzYLN2Mycf5+MbaeScfMsS/hjfDmWLD+"
"iCSADOxWrR1+BkYN7sLNUYn4qS2LoR2rNeFT6523uwfhhzVnpZEgRTncv9HQMfHa4FM360Ub"
"jpqEfjThu3t6ClyXCfr5wyT0owmfuvtTJ/q/i35qh4RJ3XGK8hCbkMyhRZrNZSr8bD4Sz3PR"
"5k0ewA2TSbjRdGx9RsqoL393C6HMU4UASoSLwHexEPYMi7p12Ltw0T55AqaCX1KQgfiHOVyw"
"repIYcQ4E034R05ECCV5DTPG9jMJ/2qHf13wb2eT8K82/Azr4iX494xJ+FcbfGqETpEgU/Cv"
"JnxHqyI2OJX8O7h3a6lOTNEs3CAlFuBuzQ2Bz9+Tuqy3qy1DWtpjbmWT+LgYTnYythQNtVQ0"
"4acIyyQ9LR3Xo1KQmFooDtqRkaTrXKiq4NsWJaJjnWJh7RbwEELqymDrGmR4KqhgUgqv/nX0"
"Brfv8avREL9/052nxT4/9BckCIaj7giWds4mgf9m/04Y3r85Plt4mRtz0rQBvu8wdOyCBnwi"
"Gn+Bs/VT2nF3hyljXhdCNFOabWYC+M+3bYKcIitBP+UmoR9N+A+yrJGZW8idwk1BP5rw7d1r"
"sbdHgzf/Dvp5rlUYbkQ/FkbiQZy4cA+Nw2pLgtpE+G/eogV+PxLHRuiVyPu4fO22NI7EwPH2"
"XRu7YN2fERyeDA70ZTjV/KQ2dW4uTuIcUqVQlong0zBLGc/Bs5VKhIyYTqENfodWDbD158E8"
"gdkU/KsJf8LIl/D+q23w2YKLJuFfTfjj/tMDAR42gn/bmoR/NeEP6deGIwW3kkwj/zXhU3l0"
"RmYWj+CR+FfOBp2yU4hBs6qz8kp5RARdktPohX3HL2HX0s948J6Loy0m/LhZeE6lBlsqmvCX"
"bz6GNk1DuNcbdYQeNW29eIFSg5lAE35MwkOMDnHkGTyk3W2c/bmdi6Fzfai7NE1FPnrqEndB"
"6Nm2JofL6P5hzvjeuBmfhzXH8/SaD1UZ/CM3i7Gypxt8HBrxiJXPZ63ROnfHUPg0aXvTwYM8"
"IuHy5nE8zK+kQP7McDpD4VNoa8ogX9Tx7iHox8Zo+tGEfzTKEt1aAktmjkKwv4fR9KMJnxrE"
"Nq8hE/QT87fQz/aIXJ6OvOib99AoNAjjv90gJZEYaklrwE/Jl2Nq12DU9bPgicafz1zN3qWF"
"AdMdaK3Yl4jpY3oJpd5Z4OQ+Fqw9iCYN6mD1zMHMv71H7pBqUm0cTAKf5nK51KwJqT8ojF6a"
"8KsHeAi8WHM43RT8qwl/4dr92LNiMgK95YJ/PY3mX0343y7chh+WH2ZFf2XrRKP5VxP+9n0R"
"2L18gsnk/zP0s0bQT/06Qv4L/g3wwsgv1ygiKeWGK7E1x7Kw89AdHo5IgzEtbYPQ45M/Eepv"
"icvXo6Ru0O41DLZUNOHLfRtj/LI7HCO9f/8+svLLuCeeqeATrDnb4vD4UTJ34aZGokSg5TDs"
"EBLTSjB4+nnkltnDwSOYlcCla0eRk3CRf05Co8zGz2B3WxN+HlzRZ8oZBDskITo6hj0CmmFm"
"6Ow1TfjUN5EyjaiP3SsTd+JumoOAH2ywkNOEnw9n9P3yAoLtEgT93DaafjTh2zj5Y/KaeIZ/"
"//49o+lHEz41YZ3350MkRV37W+inwMJDOl/7JMTE7hBeZbF0vgaGKzXhp+Q5os/UcxL+r0bC"
"TuCGmjZb69m3UMVfx3Owc/912CML1+4kcm+/cYuvcfbppcvXmG4cfapXOUFaV/jUUZ0aD8/6"
"IwmJd+7z9xWNqjEEPiW93Yxby8MaqXGxsfyrCd/CxhvdPtiEekEOiI6JM5p/NeETL1GDYFPx"
"ryZ8SxtPHgFTL8jeNPJfG/0suY56AXa4H72br4PozC1onE+xgUqMmsim5VRDscwWcv9g7ppN"
"3Zdjc1PhFODMyKEOIBZWhtUDPAOfuhcLho3LT0OZiz2c3KmjsZfBk2K1wS8Re5Zb+0hxewOZ"
"SxWtERbPo2IPHrZHeKCO7dHZXigoryd1rLax4a7ohl58asKnMRQkeOIybQV+HOGsxI+BQu6Z"
"/dvI+R1snP2QneMNj1A/acK3rangO3JH8dhMC0E/cqPpRzv8YMRlWwv82BlNP5rw6RI7r9iB"
"Byj+HfRDjWppdEl8piPKXF3g7GH686U7vLhMazgHu7LwoQ7jMkuDxAPLg4zyMDzMSoJTkD/f"
"EVL38/j8dAFfzuOIqDGthbWtyeDTqJx8nkDenOdWVjWdWh/4tPeEchmKy1NNwr/P7t+bJ1ZL"
"8s3JaP6tCD90F5qd42s0/1a0/1ixf1PI/4roJ64gQ+DHAXJXGYeNyxWJWQZRKc9/EprQVtHR"
"XjkRmFvrl+SjjMIcwpXUZ0y7LvBJ+VAXfXazy0ufGgFgNHwadcJjBqR2KeUG7l1550DeC4Vq"
"ZIpJyTSDig6DElSUYQJliq4p4FN4hoRRGc+2Mg4/z8J/EqOh59B4FRpLX2bEnVtF+zcF/Wjb"
"PzGwnVsNk9CPVviCqSyFgfV30c/fe74WLCRI+ZqSf3kKBXXIp7RqHlHjxp3d/y749D19XlYm"
"jQExJXzm19IaJuHfivbPo6dMcL4V4sdE/FvZ/v9u+iH+pcxfbjuluNOrVIk5CUPps3AbdGkg"
"WayRsVnIzivFgcsZ2HGpmIW+evU1I4pSK6l3ViWhFPXJnurrTORjTFoVhwJLL2ZYzcpugs+D"
"I0H9uSq+D6DR11RLoFybjyVg1pZURoDK+haM+2zluAy6BNWfnqgKJDzKQ79pV7FjWnOp5ECx"
"KETzqNiTM4NGdnfhxA4K46QUOfGYioruNGi8/LLhFVvzI2ZfwaVEe7Z21Kec6oof3pvapGvC"
"+7k7ORjzUrDq51+vucXx+f7t3FT/3nmpTJy5izQbqlx3/CsX0Q+NIb+fLs0SUxYr6ks/6s8Z"
"0sGe0861nbPmFFt98ENLfbqw5pky7avvXybTmX408a+Jo7k74nEpQQrfGnq+ykWTtSPjsjFx"
"RSwPpLRU3kMR/WvBT1X479vMGp/3c3mKt1YdycT2L+o/ww8U8lH3iPQ5X114YNFHjZ+cSYF0"
"JhK+ZEbh/u0ewWgV4oI5W+/z3RcJZxKsMgt7fgfl4MfKzkAb7dCi5JA526KF/Czl2WKbPnbH"
"lpMPBQ4zpLC9DuerKX/UYa/YG4c1Jwuk6Ji2kCqdexX8q7loEnnnMFt0mXCJaYhH2CgSafSl"
"H/XJ6ZXhhWvKtMDnwa/K+YhKpVfZ5n8aYo8Qn3L0HbUEQc99jFV/7EdooHBDs2/x5NOSwmyD"
"NO2Hi+Pw5a+nOaPFu/FABLYbjUFjl6BNmAdebZLNdQyG1sDQWnU4Hb3GH+bvXxn+NT6a9B3y"
"H0c9M7zS0EV3Ci3GRPBF/jdzNqJV+BjkJF1G+MRjWLLlEo6di4Rvs8GIPH+Ii0dHdnfCsC+2"
"IT09A4GWt5H36JaqEFbb8nMuRWRMBhqET0G7V6aq3sOv5TtcZ+NafAe5yVd5oJ+ha9uZLPzy"
"+00+g5fe/ARzft2EAeN38M9ahn+IpctWYMq8/dhz6j5mLNiGJUt+RUHafZ2sK038077bvz4D"
"Ae5WGPmCPU8D5mJII5ZSUX7722EEdRyLXu/9JGgVWD7alycw0+RfY1dEVD6ajjzOCT+rNx8S"
"ZzoEkReP8JA+Y1K4lfhv8t5+SUh8tRi+zYeK857MWWOz3qrJU5/tyjPw2YvWXEdnCO2SICVr"
"+4UmbiiO38+1QYYmsygXlYoo9/3K+98wb1HdWuP/7OXssW/mrGf6IX4wVD7oygNDJ2/kz9Nu"
"7+HaMF2z+arC/aBPFiIzpwA5NJk67rRBtKqknbjkdHwzex0/g+j0ys1oTBkcgrLk41wX9tL0"
"O1j8x1mpblHHbEF1+aOkS5LPOw+ex5j+tRBQdgWFmQkGJ4ZoOjIhPjI4O1iilcdtro9Try+b"
"1t+WC+N1lUXnonK14iU24QE+7BuI8gcnpEJ4PejUojJrhS5iKVPp/PlzHDPfcaEQ3y0/zBsu"
"yk42uFiUYqbk1pIAJYuGLgGvpnqIf+cjwM2Ks+BK8tMNRjxpcJrqS0s5WZkmCxt6B6LtTsGK"
"Y762bIFTfNnGJYCz0nJLhcWmsMrpDomyBWkd2L8XbQdMxu6Td6ShcZUIwUPXcjHwyyPIK7WH"
"nUcd1XuQBfTON/vx+8F70i8aIUgpXh1xrwguTg5o3yRYmizrLIVXe3duwlYPpYq7uDhi4brD"
"0nRjhaWoL/5p3+myYFy/+xBBPs7SyPrcRwbvnSxRUmDUwWLZ8jVMSzE53vhh7Xk0qOOLF0Oz"
"kcfMVmTcOdOAUicfhUVYrgoL09lrejGG4J/uKRhHNM+LxrbLQ7D3bII4E3sW0r0bFgtFkMlG"
"HXVM0Xd1CpXhk58kY2JAex9OezY0I021b8sn+6Yp5cRbXFIgvK7sgjLV+RM/WBlxL6ULD8gs"
"JFosErREir68rMwkuPewSEJmVi7KinJQmJWks3LRRjvER+kZWYwnmkB99qYk19wRh4L0GI7I"
"cJhb7EfXZJSn5I+CLmlS9cErktFQyz0PeQ9vmsRoJxr640g0F8P3aBUkaPGGKnWevGVqNZWT"
"dEnqAKJTJPsJXkjJEu7lvo2w91wiyyKLrNtco6hPqLbCcGLzYMldizh7CvaeYXCr043DV3vv"
"xiNXIIiysOa9HyTcbickPMpHYmo+Ri+K4UmlVTV4pIt2K6HZecS5azXI/ZvgjXBptPvcFTuE"
"F2aBFrWsMfl1B67pojV7y12sPVEg/s6tynABM5FiKrS1+H07VwcWPupKTD3kRa7s50tv4XKi"
"jpedfP8niMi6nDO4iAhpgq2tUGLW9jSmvYCV/uA+bTBliDSVNPH0Qgz5fCWuPnRjZUd7rEiR"
"EcE7+tTnZA03byfVe9h7BMC1Vmf4u1ti5tBA1AtyVIUDP1gULcHVsTaJzig620O8eyE6d2yD"
"a9vi0K5xEJcdNG1UDyv2J8Hdwwc5hZac2WTvWVsxOlxWZaW/Jv5p3127dELDEG+s3LSHCzlJ"
"MKiHlfU53+dDpZ+fjzjLCsy1ZifOYLqZJwmItg398Pvhk+jQrLagUS9ViGv6+vu4GGepc1YW"
"M5x4DzpnzrgSNP/NqM7o38GXhVFWfhHXh40XtHPkFvSa8k34V06JptAqGXL+IW0R3imAjbsR"
"r3fAsFdCJQXUoS9+XHcRG8/H64QfpQVNnSWuRSXhryNX0LdnByzfuw6OQmC83bMa0z69w+iF"
"97D9y8YcBp+z5R5WH8uCJYVKddg3CVI7VyuumSIjR+IHd+YF+nqzk6uKxyhUFxbsjH3nH2DC"
"b9FMF7CwqoSGKucBEt6OPlIY2VJP47Qq3N+PiWPjtHGDEFx+5yUWrrMFbtaeyNcZ/0raIRlH"
"MtHBs47qGWt3nMKVG/ewbfVoplXqNThr80PJKNUlbV9N/ijp0imwOfp0k6aYX7p6AyGBLTB/"
"rKc4V1uWz5TdfS/D6Uk4WVdvvoYMU+bfgXWBPSa81wOT5+1lT6l/e2983lc6l+urX8GpK/EY"
"syyKeaAy+a+OFyXu6zYWeHk+UCjKOETHxmHCID+Mfd0D+y8+4tKG1qGu/A4j593Eo3z5M9cQ"
"FhUzgSRg09PTWSBL2UT2/L1L9Q7o260NFwfX7vMTPp+1li2hzOjjelnYQb4uiD8xG5eXvIDx"
"/Vy4gwZZ63Tg1JD31OV4VO86GTMW7sDLbdyQEX3MKAtefdFdytQFRxDU4SNcibyHjjVzkZ14"
"gQWsPmv8f7rj7p+f4tyP9XH8Cxd80NuHrV0S0r8ficG05ZclfAY0w9HTl1lJ8oV6JQxMF5kU"
"hycFr5mhRETbvaUfFxRWf+ELvPHxfA7DOmadERZMnF7eGWX4nIlMQ8fWDTicQeG4KfP2oW/3"
"dnC0oDZHxRzSoXMnRjQkbXnj/HG4s200ejcq5bDJzEU7hSCqjbdfrIGMzGzU7v0DOrwxC291"
"C4BT3hWxj+Qq36G8RPKw0lIfseIm44H2qBzFTkKnIC0ao3q64rUp+wSepgrmiGcPXwrlGu6N"
"fLXyGpbujERooC0iTp+Qnld0G1kJ5wzuQPH9pGG4v2cyDn4dwvz26shZGDd9BdZuP4lVv++D"
"uzAgZy/ZiILMeFWrHV0s6NPXH3Cq/4FL6WgcVhN1A6w4grLqUKqwfBPYg0mL2o8Xx+3ntO6c"
"B9eQFXeGu4HosjbM+YjP9vTMYKZ9EjYl3KmhlOvQSIFNnX8QgR3GsPU+f9UevDPma2EER3LH"
"iMoVTeU8QJ6flb2b0XJAG+6JjsjboaLjS1dv4j/jfsZH/WtBnntB0GeS3hGQWeNew92/xvEz"
"KIq1Y/8ZlqPDfzgrtcoSHhnLNgO87UHCUI458DXOz26OEO9SjP92PW7cT8Xc8b2x6/htIT+n"
"YMe+U5g5LAjZ8REoyde9AJkiHhQdy8jI5I5AtN7o2VjImVhsOZmCaSuuIDbxEVxrdODQcl5q"
"lF7tviaN7Mu4n/6GJ05cvIte737HsmHl/mQs+/M2G4ih/tYYPnEh66N2/smKq6YC3ZRYuSom"
"WS51bFakkzo72GDGED8W0v5uMu5Ofe5WOt7+ao/e4br4BxnwrBcOvxbD0H7gN+jVsR72rv6S"
"4ZDlQK1Hdi4YyS8r9fy6hhIDDlrb6vfVNYRVd8H13TPxXMtQZjLu56anEiMF61W/H9/rBXee"
"iBkLtnOYlQQlucpKz45bEQnr1JqtECuj9r76cDqWbr+G1bMGY/0vo/kz2nsh9UPTI+OIPF/q"
"Nt0oNJjPUm5bipOX49gabd+sJkK8SrjnHVlvFtaG1ZQMeGcyarV6DX4u4PZkFEpwElYi3dN0"
"a+YpDIDPcGL9BA7jNKtWwj3jqlIy5DnTcnWRs8WuxKfy/zOzcrh1D3mML7fzZMv5na/34uyt"
"jKcSJQwKpwnazC2yYkW5dMVqvo9YsGZflSHiytan/10At9pdEdj+Awz88GfcTiqBe0gP6XKe"
"syqDhQclvBKXICmzTBclFmaFqUNCcXPTW/j5k0782Yvt6rByJxrJzi/nDDISyiSwqfaGBFCh"
"MCJ07WTyynvTmH+DnvuEaZ/ugssKcxh+YmoBe19FOSnUb1xKJuDMzWI2iCyt7fBPWNpw71Kj"
"I+/32Jlr6DNwOP48dJF5omUNK53oU3ONm7Gc8UTP2LH3JDbOHYveXZuxbOCwmsAJGW+U+ajv"
"WrPtBNOKf5v38eI732L97kto16kPOwgrN/7FZ7H5WBJ3TKnumMIKSNdQHUU8yOO6uXEYzi4b"
"yJ+Fd27KoUq6c+ZO+4J26KqGvGZyPiz0qG37Zu5G3jt5jmQAkQfnXK017L1CkFNkyTjv8/pI"
"bNm+Gxni+5L8DORRSLw4Vzcldu62ZI1RSyDOxFG8OFl41L6HtPuu47cw89OX2cpY9c0Azgqz"
"1LOAjkISjn6NkWXfEJsO3mWB2tg3GzPeDEDPdrUw6ZcdGP/dBr7ok1oFFRtNuBRqWf1ZmBCC"
"TpxwsGbrUQl+cb7eTTGJ2G3ZnW8piL+DVIQnGJSFKysxyeW2cfYVVkZNycozUolRmOY//Rpg"
"9/GbaP/aV1JsXwieMgP6oR2+Jf3+hPd748r1KBY4u0/eZe+sXjVHQWCR7PZbGVi4KBO4KLTx"
"xd7TMRjyckdWVowTsc8ZC7fDI7QX/FsPZyZc/+c5nToVHLohCZHGDeqwQFEqbkpkoHX09BVO"
"ef/v0nNwkdsLS/UrRG0fg45tGj2bVWiAErO0deGL6dxiWzgHt4dX49fhHNTK4OJj8jqouNUp"
"qLVg6u7wDOsnBGsXDtFZWkuFoyQkqJWVLneSZEFTa6Qa3acxbskToqbHfXu0E1Z/NPMR0ajM"
"SsoAq1/bW+DJjhWkPnd9BIM6e1C9GdE+3YFZ2MpVJTHZeSX4dvwgjrbQorZWDkJAUfjdwsBC"
"XlMvbbh3CW7LYb1jEZEcpvao10eR0VfOd2T6Jp1ZWNjwGdIz1p6SoggDu4ch79Ed9pQ589HA"
"mjyZhQWHRp0CmsOtVhex/758PcNXlkLRUFG/c3Abxb+z2UhRRjKqWi2qWyLkpXkIaDeKI1bj"
"Zqzkzis+Dnmcs8BKjOSfkHlEn0QL+sh/+lsy0P44Gs9ynxpoE39J5SROnCh0KyEPrrU6sTyl"
"n9E9n6YOqJBit53PZ0b96b+jUcstlzNpmgeXY3AHW6zddhLv9KrDLWSeHzYX1Z7/jGOvnpYp"
"UkKGjoLUWTAOCRW5XyME1uuI3p0asfaNOH0MPVoFYO32E4iOTWThRwpHZkS/NSVz//quPWo4"
"P+ZeYjPmbxHv4I0+L7SCm5ubIiFDP/g0k4fuBJyCWnKY1cuvmoRwIzoGVElcNa1w8lIsVm8+"
"jNHDekkXxWL/rMD0xE9+mRw3otPQt1trnI+QlEhEVB56d2mKtLQ0PncSzoYKHUuBCwfPEDwq"
"8WDvpU09D+HJ+2LP6WgM7tsedUIbMNNtXvoVevTuz6HBqnrf5ZU64OdN1zHm3QF4tVN1Fix1"
"hNc4LtwO1++mYPWWQyw0yAP5ddtVps8J329C10ZyFGYa3r3+CfcpDDDBbGSYyH0bSgrGwDMn"
"Y4f2S4qQFIKDd6gUKhP0Xs3PFUHejpg5NAjFOQ916mw+qK0VYpMe87m5BLdja5fuAqsH+aF1"
"mAdb/Vm5JWhYx58b/q6b2AzOjtaSF6VPOFqcrb2HQokJ2icesmLBZol6gXZwcrBmBerb/E28"
"+NYM7szi4BVqsEH09yixCnAvFl2ZePnXwBu9CD82nP1HMkimZ28rV1dnlhHOwtAd+ko3/ozG"
"lZBXZ3B/U+X+ZQolFthcKKu2wmNviHsZztwQechLz/Hv0FUMzTGk5AxdFyX2ZWbncjYyK0ih"
"4E/ESAY5yQYObQtlQg156WvdpOZMV/qE1DknQiixDMva/O/2TatjdE931iPkOJG8oCYIxF/K"
"cWF6JXYUCIIbNCMCE172wvbZQ/mzG9Hp+HDmTjxOfSDcvTpcRxS970v+GSmcu1G34F4nEDZV"
"MIJ0oS/VCiitNFqnriTgo0lLkFtqx6NLZnzSD+PffQGjZ2zF/Mn9sXHep3j/pwt82VtZAoOU"
"tOGiupN5Jox54zCu3bHF8XWf4+rteEyes4s7eF+7k4QNEY9gLdxjWRXKUFmn0Tq0OxN5+OTT"
"2DopRChH6fOYg9/gi8UnMXGAlOCQHLGc0+xvCkGkazcBqs/o1+LJe6zbeRY/7I7HvogSTBkU"
"Jqy52cJT3Ynj5+/g9yVfoOvwFRwWpTs33QWRLc7dyUKgMEIOHTsN66BuuJhgw5b5FWoEKzwd"
"Cv3o01RVE/+07/l74hD/IACLZ7yPGQu2YunOW2hZ+xWc2fYd/95/l0r3A3QHUlXIj/a87nQZ"
"inOPYuKI3pjlLFl/G/Zex9gv53LYVh7QDNn5pZg9rrtQBAMRJ4T6+1N+RXGeo/ROOlxwq9f6"
"tA5tw/cPp64moV0j6UwTzyzC2//9E5G5D/miXR8PT71Wie5lPhj2CH2mRrAlq6SPiKhczBxW"
"AzvmD8fQyZuQm+XGdwaV3QX9/KZc4NUeaFkPPvbZ+HZbOgb1bonxL0k0QaGsSbP/wsb9kejS"
"oBkWffMu1mw9goYhgZg6dihyitdiz53HsLbT3nJKvU6M7sTobNefS8HOL6Qaw3rv9cDr4c0R"
"PuEoyl/2RMKJOWr8HYdRc2+yotRVDVTEA63qOGD2O9I5EA11emcx8oUBzQkjJsA9hZ7PnT6F"
"639N539P/HELsvKK4OYbpFPPR3XamTiiD39JofAizPp1L+at2o2ty2dxYgd9lQnv6LudD2Dj"
"6FVpwsuz8keiyx4f70RmnpuqdpeSjWa91Qqjh/bE9XuPMPLLVRzGpWJz8sAr62v4JOnNCYcW"
"D8WL4w4iJKwp/vjMn38+5aNBqFHjFFYfvYHR4d64sXsWJv60DdmJOXD0DhPy07diA1ytToyu"
"iQb3bYvwicex50ysOIdw7Nh/Fu2rpeHDfmGSXvn+Xab3QC97/n1ykNafS1Xdf7MyfPnll8vv"
"urwjtXai8AVZ3awgyjkGmZN8jVMoSThK/fNc2LKmC3W6kJRSOQsU6cf+wiJoJVXlK6rmA6On"
"IqHG108NRistyEBm7GlkiS+CSxkt3K2hrJgFlIN3fS54y0m+wvOBJAFhyb9LTEwWE7XGqQg+"
"VY3TvinRhNNYBWEquxOUFGSxAKM4rlR/kyd1GqHW/uJgyZIhz5BSziuCTx4b3S2k3zuE3JRI"
"3jNZK+RO56fe4Ro6ujOkjD5CNoUN6O7BwSdMWKzPCetDEtQVwVcqaPJqsxMvCTyd4roPCteS"
"xUvue+7DG8hNlvrQEfPR79I78c+rwL+mAUCw06MOcNaRa82OcBT7pFTazNiTfM4UprBREKay"
"0JO7qOuIf/pbCrfSGWYLWqLWPXTHYyUEZX7afa4zIeuclA+FJeguiMOKleyfnp+fehfZ8ed4"
"/8pl7eghzqKFwHU9njmUce8IvxcpGLqDoFRkChFRKKwq/JCyI2s5Q7wH0TnTuKJ9Dz2TaIlw"
"5VrzealhruAPXfBD8MlipXtMutCnGieiUfLmXcX5Ec5p0UV/VsxJTjgieidL3t67HmfjVQSf"
"eCQ7/iyy4iP438QrhFOynDPuHhLnEavyPAhGTuJF/hviDaJZK8F3LuJv7IVHQn+vCZ/+puDx"
"PWnfAv9E3/QMEjQkJ3JTbjAeAkJac+f3Hm9+hfT0x/D0CcSJ9RPR94OlyLQJZQub+K0q+qyI"
"BwjvdN+Wdmc/1y8Sb5HHSXBJ0FVKn6WFVeKe5A7RFkUi6KyIFkjuOYl3pZZQ0jlXQp9K2rl/"
"VCUjuDkBGYPivYmH6RzoHpvmcdHfk2wgj4r4ubL9PyV/HlxnuiRvheiQYBKtE+1kJ0TweVAI"
"jt6RFAzJN+KDqvg3O/EyMmOOsw6QBzQVuHmO7+zS7uwTvH2VZbazwBmFXXkPgl/lfk3g6N+U"
"DYmK4JMBU0iJLAq80LvSO1OJAeU8UHIaZZLTHukdKfRN78RRI0F3/PuCdsmDIzlSO/M3yRMj"
"l5a/FO1ylH4UN+r0a8iX8YQUEixWti6K2hk7vuynRAU6ZEIcKQNKOS9TwZJil8oK6zJl/FK4"
"kZS2TYeqfv9BQo5bS1Hyg6UVp/o6CEVDRMEHK5iMQ4oUn64EfrlALBGjqxC+2i5h2eISz6HD"
"LS3O5XEUFgqlpaz9KlcIIxZm4vdkineSWRbBgqZgC0FCh0ZKVWoL5Cr1uPOsyzghRqLf4Toa"
"wVhMSGzpUffoYj50ZQNRUqSyUmuUW0rwyxX3HoQbuktzEcRJeyECIyFNe6emyKS0pPeR8/kR"
"cZPyVd7tVQVf/Z6HQhFEeMxoNJ5GKFo3sV++2yOYRbkKJVakopOK4EvKxAsuNZ5j4cD75pRg"
"O6m1jjhHqWefA9cTUbIOETk1biVmo59XBl+5f6rDc67enpUgnxFltAn82HCNmozbKDlVay2N"
"nRC4lEo73Pl8eZSDDvhnASe8OlJ8yjg+fZEwIJwrrXeypMsVrXaqwk85C9ISphlSAFQ/pKQh"
"EgpKXBM/kHCmhsJQXKCTC1OqGEOhDT7d29ixt+auaC/lwfxCOHGt3UWqm+RsU0+pXkouZdNy"
"WjS1OhLvRDyO0idtidThk3Grvm/pbKWyGrkQYKTM6bnFAvcJD3MRue8HtYv8TYi6fV0IW0+x"
"P6KzsirpsyIeIDyR4iSjq5QFv1ySEZTQU1ZWKf4pHFgV7ulOlbx5opMSRbEz06cNjfHJr/p8"
"lbQT2IKbKavHohn/ZLjT/Q97RwGqsyKaqux8tcofhQxQ3hlJ3YisJINQ8BmFoOnn7L1YWlYJ"
"n99VGAtUukL0zLjhZzqwMUrvozx3C0tbpkvatw13CbGpFD63aFPHiwL3pPgIHhmGUncUS343"
"gqsM09P70MBN6qNL8wGVCUiSElNYvZIFafXURZkF11QE8pfmkh78tPuujYnVuz2XKWDauQYB"
"rkGVus3kUdCXIfDpwNRdTl2X0oJQClK+ECXCVrRr4cF7CndfabU9hRNBnJXVC0lEmv2UkmFL"
"2MJa0SPs6dgvXXDSlyYMLk52CdIKn+DpCv+JInOQmmoK5ivOl9JplWEruiAuVYNfrvDyKoNP"
"DMVW8TP48XoqA1ZS/k9CV9IwvRKd9y8V2z5Nm6VsnOQr7q2ehs/4L9Qd/2CDKKBKulEWgOqK"
"Hwat5QyJ/srUMnBl6sXF9G4F2VXC1/bOFdGLtQaPKPfP2Z0V7b8CWE/zQzne+/4Mp+wX5z5U"
"JXuQwONojFAMymSxquhTGw9w5xiNsyF6KuFhoVXjXyfcK2qZ6Msg+qyCdrTRP8udslyd4GvK"
"H4Kn5N0n5+sDa7Wfl+lAP9r4V3l3p03m2aiFD3XFjza8kNGp3jybDTEt8o2dD+bhEjUlxoQr"
"PZQFuBEXjeUKN1vZCFUijhI1xVj+L4BfxF/KS3RJQJWzFSVTKDOD4SuFXPmToXcU1uTDlVlW"
"eoFphm+G/2+CT/delHZdQo1hqTuDUByUwShjYZtmxr8ZvkHwyQNTKjDVnRjMy7zMy7zMy7z+"
"hYtV4m2HgYq5RS7SeG9Dx6pr8ZSqJ3+PGL9xnIqucin/4fDZXRVuMXlgdbJWYMuWLTIzqZiX"
"eZmXef1DlZjk4lmrlIAuBZUVrTJVIOFJEdoTBWPDF47/dPiUxCGleZudVPMyL/Myr3++EqNY"
"paW1Ij3UpsoGvpUtC5WiebI0Fcw/HT5nISoGZZqXeZmXeZnXv8ITs2IloK2OSNsa0dUWfs5l"
"mLsjEUF+LniptYsizGeFyNhSrDjwkKv3GT4rSKsK65Sqgp+SZ8c9Gvs0t0VkdLqArWh5ooBj"
"Cvhdm7ihc5g1F3Qv35smjTc0ss+eeZmXeZmXef29y0JdiVkoFIBMWVRXwde4Po4oKcjG0bM3"
"MPf9IBw+fhZLt1/n+U5+LmVIiYtE/qPbqjk8moWA+sJ3LYvBVwNdsfiPc+hc3xbh9Qu5CFHl"
"iRkJv4FHCka84IDFm07zEMs+jcq59si8zMu8zMu8/gVKTN+VkJKLEF+grp8lYuKSuHMEtTZp"
"36wW4pLSsHLjbkXRnWHhOE34yVERPKSueVAJj6KnSbI04M/Q6c+a8Gs6Z+Bq5H2enRaX+JBH"
"m1B1eKkRk2nNy7zMy7zM6x+qxPzdLXhMSkxcIlzkttyxg+o/Xu1cHUu2XJDGjrhVN7irtyZ8"
"fzcLbldCleCxCcmoX8uLZx6pFzkbA3/lpl1oUNsH8yb354ao1FKG2sHoOnLbvMzLvMzLvP5F"
"SqxrYxes+zMCizadQnCgLxrWDULXJi7IzCnAlRt3pXHlrkEGp7prwn/lxZbcgXn+2v04ceEe"
"GofVljprGDA2XBv8l3u2x9o/z2HBusO4Ijyyy9dvK1pZmbMTzcu8zMu8/snLoNLpFfsSMX1M"
"L6G0OuPkpfu4djsBw16T8wBFam1CrUmoR2BVc6F0hf/94u3Ys3IKFk8fjkah1TD+2w3cm9DQ"
"IYSa8I+evYUNcz9Co5BAHklBc3OkuWD2QKGZSMzLvMzLvP6nlNia4znYuf867JGFa3cSWeDP"
"3noXaY9TubswNSyltP1yGKbENOFb2Pih2webUC/IATGxO5GZW8yD7AwNVz4D39pBwP8doYH2"
"uHLtloBdkwddcqNJsxIzL/MyL/P631Ji1MQ1ozwMD7OS4BTkz3dgpfaukNsGcSds9SaOpoHv"
"zQ1A4/PTUObqCmcPGx6HYGGgEtOET/8mhRifnw7nYHdF93lbbnxrXuZlXuZlXv9jSowEvJ3w"
"vmx45Ei5VKdFowSoUb6iHZSyA7zJ4FtYSmM8hIfEYUoaG1FabFL41I2ZZumUlhSgJD/TrMTM"
"y7zMy7z+rUpMmr6sfdz6vvMpmLQ6kccqPD0hVwZdulwc/8JF6+fL98Rgwd4sVi40e0pz3Dsp"
"Gh7MB+qfqPt92MYPHBEZl42JK2J5NAHvWShdbfBBtWQGKkfzMi/zMi/z+r9dFWYnfrg4Dl/+"
"epq/9270KgLajUJw54mY8MPvsC/PQOb9oyjOfWTQQ1uOvYYNe67i2Nnr8Gk6CIEdxmDB2oN4"
"u2d11HO4iYKMWFUbf2MXjQmn4X4vNHFDcfx+FGUlsvdlXuZlXuZlXv/DSoymOlsphsFRWM3O"
"pRpcanTAzktleHvaTh4qZ2gKOsG15JZUMs4ypLHf56OlJBBvu0zkpUSarEarU6gMn/x0mL8f"
"0N6Hi6S1TXs2L/MyL/Myr/8hJSaNcvfg72k8eIvW7bBsUhceKV2/VU/c2ToKET83xisNHnF4"
"cMlbFsh7dJsLn3VSYjz2xY6nq9JY8xGvtUdmTj4OnzjP48Bb1LDAhg8cGDZ90XMKM+Klia46"
"LiehZ+U2pbgWlYS/jlxB354dkJ96F8WK6a19mlpg1zg5w188TAarnLs8cdZcH2Ze5mVe5vUv"
"V2LqKzliOTb+tyOKcx/zuPHE1AJ0Hn+Rf/ZSa2fMX70X/m6WSLv1F4qyknV+eAdqU3X0e2z/"
"siFi4pPR690f8SDbCnau1fBSKyecuhyP6l0nY8bCHXi5jRsyoo/pFcIkL+z09Qec7n/gUjoa"
"h9VE3QArFGUnc/Pfz/s4Ycr8Q+jwxkyEBTtDnhMhPLX7Bte3mZd5mZd5mdc/UIm51e6Kbq+P"
"Fx5SpvBkorhnYT6kNPqtOw9g6lffI7TLB9SJV68C5BMXouAe0gNzlm1Fj1b+KCvJh5N/M/b2"
"Jq5O5NZQOxeMxKSRffmOLPfBNZQovCidlFiYFaYOCcXNTW/h50868WcvtquDgrRoPF+nhDvi"
"b962EwmP8lGr17fc/5GaFhtaRG1e5mVe5mVe/0AlZmXvgrtpjvjPzGOw96zDfRKtHTz5ZwkP"
"s2HnUQueYX3hUS8cts5+ejxeBhsnH2w5mcLf9+7SjEOMFMqcOTQIPdvXxqRfdmD8dxs4GYOm"
"LeuaVu/vSnvLQY3u0+Dfejgnj6z64wD69miHgvRolBRkMCyZ+M8psAU8678Ej9Bw2It34SxF"
"8zIv8zIv8/ofUWJ2LpD7NxFC/kW41ujI9VrKDvUyKxuhuPxh71VXKIDa+hU6CxiUTu8c2BKJ"
"jwvRp2sLnunVq34hujaSY+32k4iOTcSQlzvC1cVJmu+lY2bhoLZWiE16zEXMLsHt2OO7GGeJ"
"6kF+aB3mwT0SG9T2Rnjnxgx34qsBaNvAR1Jg5isx8zIv8zKvf7cSozqxiQN8+Hu6E5v8enWU"
"5GcIr8wVQd6Oqlqv7ye9jVXTX0NhZjx7Sros+tv+7TxVd2JetunYG5GERqHB+PztTtiydSc2"
"7LmGGR/3wckNk/DtskOs8DbO+xRF2Q+qfA7tvV9LR3zyaj18NeI52AjvcHDftvhlbGf++ca5"
"Y+Ftn41vl+7Hoq/fwdXlvTn1/uChwyjMSja4O755mZd5mZd5/d8u2csvv1x+1+Ud9q5IQZHn"
"QoMlKYEiM/Y0smJPsfKi0SrO1doIj6yx8Lac+F4pLWo/cpOv8t85C2/HJbgtLO1cuVsHd5kv"
"LUZg9FQk1Pj6qcGVxUIRpd89iOykS5xi7+jbAA5e9TjMl5tygzMWqQcjZSMW5aTA2uH/sfcd"
"4FFWy9+/ze5ms7vphXRCMPTeQUQFVJSqWBBU8F4VRbx6VaQI2AUseJVmvxZQihKkSJMivXdI"
"KIGQCum9b/nOzLu7JCFls1m8+P3f4dknJNnMnnfOnOkzx489JENpHnt7tA6lm2et+I2luci7"
"vBv5SYf4Z/R+fWA7lApFmxu3TXxOAk/Zp/mLhrICvgCTp3iI792DO0Ol8+W7xCoK0xGV919E"
"R0crZFaRQQYZZLj5gCd2mIxlfImlSQh8ArP4SlE7EuoUSqSiClIOar0fV+7Re2m+oEdoN6F8"
"WvGt0CT46W+oxN5sGTtl9WhMFcVQGNUCL+Epp7lP0AmlQoqEgBSnWu/PMxK1/i1ZoZBiJIVl"
"KMkW+NWcJ+Obol0k59FUXlwrfl67+FuV1pcnc9C66TNd9U3gHTXAtn6VULgUOyQlTcUc9D6e"
"vm+w0MMoT/+VQQYZZLjplRgpHestxi5C+ZBS4l8KIS8J+mtAlYnWG5XpypXKQE3E5nIDKz3y"
"kqxKhjwoUkTSjEIVv2hOIehV2S0UilLDTdASKDVq9vps39NaBW728sqL6sRffe2siIVyJC+v"
"OlTO45ksCozoQXSRQQYZZJDhJldirJy48q8MLkqNTYk5AqzA6GU22kZHVRRnScpFobQpmZsZ"
"P9FBVmAyyCCDDH8TJdaqZPkN/ZBWxX9v/DLIIIMMMtycoDDLw3BlkEEGGWSQldjNDyNHjqSH"
"tbvSMDo6WuYQGWSQQYabGFxkEsgggwwyyCArMRlkkEEGGWSQlZgMMsgggwwyyEpMBhlkkEEG"
"WYnJIIMMMsggg6zEZJBBBhlkkEFWYjLIIIMMMsggKzEZZJBBBhlkJSaDDDLIIIMMshKTQQYZ"
"ZJBBBlmJySCDDDLIICsxGWSQQQYZZJCVmAwyyCCDDDLISkwGGWSQQQYZZCUmgwwyyCCDrMRk"
"kEEGGWSQQVZiMsgggwwyyNBQUMkkqBsst0HLIIMMMsjgAERHRytkJfY/hnPaUfxVoVTBRamB"
"wsVxsplNBullNvLXVsXLcU43inEqFErpq4xfxi/jl/H/TfGbjGUwGw38fauS5bIndrOA0lUP"
"pcYDLmqtc5jIWCG+VgDFgFrnJ3CqhZJUO49JZfwyfhm/jP9/gN9UUQJjWQGM5UVyOPFmAfLA"
"SIGp3Lzg4qoT3pirw7hMxnK2Usz0lZiINkHglZjI1eLtyfhl/DJ+Gf/fE7/J8vfkkclK7CYB"
"CiGSB0YKTOnqLr5X1/l+Dy3w2hAdb2hyejEWbchE7/aBGNFDj5j4HHy/5Qp7dgoLHhe1jv/v"
"wkzk6hD+u7sHYUAHHc4I/D80Ej/BmL4atAo0Y+WedBy9bEav1j4Y3t3NKeuvCT8ZCQPauyE3"
"rxAHzuZBodJAYXYe/ru6+KJ/Ow2SruZj/pokizGicxr+sQMC0CrYBWcu5wr659wQ+pCFPGWw"
"L+avvoy8YjBPOnv9JmGhr9yVikNx5XBRuTkNf3iQFybcrUci0X91olPprxR/c39vH5uXEZNQ"
"IHg0GyqxB38X/rfypzPO73MDNQj2NAlaGGEW/2b/kox2twTg/p6eTll/TfhL4IW7OnkhN78I"
"+2IKLXg0f418llWUHZ6YxcV2sWywwrLZtb36t9Hg9KVMfP7zDiyO3g5/dRbeG+2PL389yIw6"
"pF0ZygvSKnl6VRmoofg7hRRjwiBPfLliH5q45WNIewMqijIdxv/YbVoEuZfh598PY/bYpvAy"
"xOHdR32wbP0xdIuAWH85ygvTnYbfJf8sxt+pxGvDPBDpkYWSnHgOd1gPWWPxt/FOwXN36Zk+"
"buZscQjdUJ5/lfMCzsI/vJsbPl+6EwPauTV6f2uij6E0H4/11bKh4m2MR0VhGjGm0/D3b6PC"
"F8v3YtHiTfhz10EYy/IFYufxz6djvbBs0xlomf4ap9L/0KED+GrVcXzxy34Ee5mQlhiDkoxz"
"MBnKnII/zDWB+f/LXw845fxWx98zON3Gn844v7/tz8PXa87g+JnzCPaoQH7iQbw/ugmWrj/q"
"lPNbHX9y7G4821+N14Z78vktzb7Mnl5jwpKyEvsfg961Aj1u0eCfQ6IQ6qdGXlEZ8gvL0C3c"
"ILwoJS6cPYmSrDgYK0qcgr9NuA6nz1/BoQN7kZiSjt5tfVEsDrGhNM8h/MO7ukKHfIy81R+z"
"P1+NAW3V2HP0IrZs3YZdh86iVxsfFKefdRr+qwlnsHzzGew9kYzS3EQhgM7DVFHsMP2r46/I"
"TcBSITCOHD0m6JMJd1cjSjKdRx/Gv+6QEGxXWflmpMYL/BfE/hY7jT5dwspZ8JGnUXT1tFAC"
"KfxZzsLvLpyuJweF454eoWxds1BzUTsFf7emRuTk5nEkIiv9Cn78dQuv31RR6hT8aUnnhIeR"
"hdu6RCIxNRs/LN/AeRkoFE7BHxdzDHnCw+jqpPNbHX+IvhAnY+NxcP9up5zf1DwXXEhXYdQ9"
"7TH5w6V46I5w7DkWj63b/nTK+a2Ov6I4C79su4S9Jy3nV/C+yUHayErsJoH8onJs2H0BP63Z"
"h/nThiOqCdjqNJYXIyH5Crv2RmFZW2PSjcW/dtsxtI30wYLpD2BwvzYs3Mpyk8TnFTqE30Pr"
"gj/3HMGPKzZj2nNDoXYxsECmZ1BqvYRscGFPwFn4PXUqpGSVczxeYY3bm00O0786/pNnE7H8"
"j1jMfuUBjB7SDYuW/ikJIJPRefi3nMXzjw2El6eOaUWJbVI4zqLPk3cF4eMl+yhzznQ3CgXg"
"KI1qwr9hT5zw7P+Ep7srXh3dhZPyjvJndfwBnmre08++XiHwazBmaE+JNk5av5fQwCqdHx4e"
"0BxfRR+Bq3sg3HyacejfGfjbRPozrZ11fqvjX7PlENpHBYrz+6BTzq/SVYenhrVGbEI+Yi/n"
"ceiQeUW8nHF+q+N3841EermPFLESvzc38vz+n1RiI0eOvKnWE+qrxqZDqTh8kcIZCvRuocGJ"
"mEtYuGQzdh+5iE5toyRBbShzCv5OEa74ee1+LPp5O3/O8VPnGL/gJIfwJ2eIwyoswn0xGRyy"
"ysrORtMgiUl9vDxw+mKmFMpyEn5PcaiJ6aXco078SNko+lfHHxrohVWfPIr84nLcMfZTJKcX"
"ws07Ako3T6fgf3xYd4x/sAdeXXSYQzbDBnaX8gUOKrHq+Mfc14E97qUz+zLNZ7z4qBCieQ7z"
"T3X8/btHIK+gEOeumoQxUQEPNwV7Go5a6tXxZwr+yRWe2Jm4dKRklglFr2cl6Wjivyb+GdhB"
"L56hFCfOxEHjFQqNd7gtHN1Y/P26NhWGymUsWvKHU85vdfw9OjTDT+sO4POlzjm/hHNAOw1+"
"33EGLiotrhao0TTYV0h755zf6vi1vrdA4xHMOVTp/P61pRZyYceN8MSKjfjv9LuQlJaP5RtP"
"Yf4P67Hhv1Px5axn0bF1U0z5YBlbRY5aK9XxHzp5EUs/nYgOLcPgqVdj8uzF0Pq3gIslsd1Q"
"oMTyC2MH44VxCizbcBzfr9yNPl3bYPHsxxAR6o+hE9bYKjWdgT8hJRNekSYp/OOEtsjq+Du1"
"DBbehhpBHgbMmzIUsUnFWLKrmPtinIH/h5U7sOG7qQgPdEe75v6YPGeJpQ/H6BT8875fL7zH"
"XWywnFg1DW9/9LVQMO4wGUqdgv+PXSew/tu7hTcQBC+9BlPnrhS4jQ57qtfzzy7BP63x1ZyJ"
"zD/Pv71UWOtGh4VoTfzzQisPDpmZBU5XzxAoNe5Oo/+CHzaI/Z3mtPNbHf/hU/FY+vQQdGwZ"
"7pTzG+ItXr4q7Nh7THiovthxQYW7e5SI8zsGESF+jT6/1fG7egRK5fkKo1POr6zEbgJYsjMf"
"a7edR0VBGhKvZMNFG4l7XoxG61BXXE5Yi7yiCmG9RDoc7rgOv9oPg15ajVbBSmHFnYWb3y3Q"
"NWkDtdbbIfw7zrlg58GTCNQWCAs0CfqgDpj8zTm0ClLg2PGTfLj0gc2g0ng6BT+FIzRC8Mz5"
"9QpSzl+Cq76JsOocr2yqjp9wxSatQEXhVVYEaSVCAbgGOxwOqo5fqQkT+7uK9zf+cgLyCsuk"
"/VXrnIJf598KWrGnRPeHpq1FXLZO4I9wWMhVx69yC8Ggl9ehdYjgn9MXOPxEe+Kop1oT/0z5"
"9jzz56VLl5BfYuLncRZ+Wuu83xKRlXEFbj4RULsHsIFihtE5+6uNcOr5vZ5/fJx6flOyDXjs"
"/cMoMmmh84sQSiYEry9ORIQmUZzfE40+v9XxKy14ZtP5PXcJan2AOHOutoZnWYn9DUEprJzs"
"wqaoUGjgHhIhbaraDUlFmTB5e8PTzxWu4qC5OHgIrsfvz6G4xOIseEb4snBQ6/w5x+QQU2h9"
"UIG2SMi/Ao/wQFYqZLklMX49FCqtWL9QNGqN0/C7egSjxGSAe2g3YeWCS8odZupq+FVu3kg2"
"mVFu9oWpXHhgrq5CQPg6XLhw/foDWDAk0v56ucPTt3H7Wxt9iIcKCgPh11r6P3kbzlx/gli/"
"R6gn/58aYEkQOZN/EkuyBX208LDSx9Ii4Az8BsHz7upASsjYhKqz+MdKH2ed3+r46aySweOs"
"80s5r4wKP3g27c37yEaJTzMk5asFfl2jz291/Na+shJ48/m1FhwZSnJlJWYvREdH31TrIcvf"
"zSsMGo8gSwhZxXFkYkyTsBQ5zCEOm8nB6rJa8QvGNBtKYKIwh8koxdUdYVKlmgUDCXoKmUgt"
"BkpWnhrP4BuGn8JL9Fwmy0QBZ+InICvdJOhjDTNZS7ydtX5n7W+t9IGlMZX6t2gygoM5t7rW"
"f6P5x1Xw7A2hD/G/1oe9a5OlmddR+F/tr7POL8sCYdhSqI/oQmF6KsZw823ulPNbE342rklZ"
"ivNLhU0VxTlyOPEGQkMC8XVGeFsGKfDaEA1ah0oWzf6YLIQ10eH5heeRUerFAsfayyPtvZKt"
"FpOww8zGuuPpy1/Qc9y5OqzcmYw50ZksDKpbsizoqDSaRsrUEkqhJsvn75Es1TGzjuJSnqew"
"DH0xvJsak4dJ3g8lnke8fRIawZDkEU0arMaI7jrx8xIMf+MMH7aawn0jumkw5QG/634ekyA1"
"GB9LdhOf5W1Rugopjl7VxLPQq+7A+iePuXGLAcF3Gy+jd1t/TPshEWnFekFzTwlHDfgVLlqm"
"EQkfrqCqZQ9qoz3Bu0vOYu0xE1vi3DdTjf727i/lFSYN1qBHlNRQ/Fl0HNpF+mLV/lwcTVCw"
"NW5dv3U9K3emYPavqbxfdRW/jOmjxIS7a/cSiE97t/XDvFWXODdI+0n47OGfEG8FVrzsVePv"
"6Bl+2l1q44/r6V8/farjt/Limre7cXGLFYbNPCi8AX9WXNfOmAL2JmXs3ePKfF7f+qn/a+K9"
"PrV+Ztfnd0Pj3dQiFxQ10qc++nePVOLTJ+unj3WfX/jiopQjpOZmO/AT7Hqj6v7WSGvxVaFw"
"qe6i2XV+ne40/B9UYooGvOoUQp8+oYexrBAdhr2J8H4v49iJ0wjz18J0ZTeKM887bKkR3D/r"
"Aj5efAAJKRkI7Pwowvq+gKkf/4IHbw/Dwx2yJfwOVEct3paBwVO2SzHsceEwpe0Xbn82NzBO"
"+vwYElOz0P3e55CfdBCGsgJ+35xf0/DJshPcu5V9fiP3Q9XoEe/LQqenNvD/J73zJYK6jUX7"
"IdO5km7Ok82Rd3k3DMXZjdo8UsK0jluGfIimd05GE20h2jR1R87FbSjJvuhwRWBNtN91MAZB"
"XR9H2G0vIqL/NPy0Zi9URXEoTD1qo40jQLzzzTMe0ClL0On+9xF++6vQVFzlqQ0uOSdRlHam"
"Sp8NrWfviSRuAs+L3yX2q24r111dgRVbziH8tpcw5YOf+WdNOj6MWx+cwe0AL8+Yi7yCYhRe"
"PYX8xH1SY7Pd+ZAKdH/xEE5fuIr35i1FcPdxYv2vYNFPW/HSyCg81CGLKxtNDlbuWfHvOXZZ"
"4F+OnkNeFPQ+jiHTduKr6GPYyXvyGGIObxO8lOVwccWN2GOm+x+xtdLdPf8ASnMSHG4tIDh4"
"oQjDZhxA4pUc7Nh/Et3ueRoFyYeZPqcvpuO9+St4T9ZtPYLywjRkX/gDFZUam+2BHq+cwrKN"
"J7HzwGkEdhnTaFrLSuwmhTF9VBxWeGj8O8jOTIc+sC3mr03Fz+sOQi+EU0VhhsPNqOwiCw/I"
"mvgmt59CAWQdEgR5GVGQdAiG0obHnCkUpdY3wfpdZ1ngz3isBYqEMKO1nk93wZ7jCWx9Uqxb"
"ZclLkccnFSmYUZ5/hRV3jcyk1AirL1hasxBiZLUa3Vti04FkeHlo4V1xHqV5SY06xN2buWDX"
"oXPiUOVA598Sk786jd1HLqAsL5kVpNnU+INmoz1VLwrLkj7HK/I2vPfzRXy79qzkSZrNjeQd"
"Ax4e/y4XI+ibtMGCdVfwxYq90CoKxbOkVFECtB4uFzcaUCYMiPqqEhesz8Cb3xxgC5x6pgho"
"z64WuuGhqWvFV41QYiXcJ1SWn9oghUPWN/VkFZSaLKFtLdyDOor1X+V9GP9gdyD9IAtQR2hk"
"xc8ekLDsKffn6hXKz1JkFN6dQrIvic/ofdd5A//DPV4gzv+bX+2rle6puWY+Q41RBrSutBIP"
"vPyfP3FH7454/fn7uSKzQ4tgFBQbsPCH9cITDkRhhbT+crG/DR3ES56ikouGFHxWG0trOZx4"
"k0L/dm5ISL6KrPRU+La6Dz5RA/ngfbTuLEoyvaHxCcBnT/qgRwtdlVCLSudjl7tNYTy1Ts3F"
"BxrPULgHd8Lowd34d5cTUxG37lUbXrKAYxML8PhHsZYwV+0JW1IsdMCKTcV4buZ32Pj964iJ"
"34DlRy7D1TdKfKYJ7iFdoPWLwv29vTjEmF+sx75T5bxuRR3DQUnQ0lp5/eIgUNVYSMs+GHJn"
"KFv+fTqG4JO3BvBsu9jEQjzYLxgHYmlW3FXMeaolPHVKvPblSWyPMUhhwRrgQGw2Jj3Rm72Z"
"NUcrEF8QwOHbUkRg1tO98NAdgVi56wraRniwh0YhM5rD+K9hoeI5qKoqFmmlQoDVUVRgpb2L"
"upTzaNOeG4a0Ii2i96SzABo3sAleGBrEa5/4+UWsfrMTh3LmRV/E4p35UGp96txh4h2a0JCZ"
"ngK/VvfC+5YBzDtfbj+P4vRiqWTZRWkL48YkuAgjo4w2z64eOpXGC55hPXnyhjZACiu6egZB"
"H9KJFQ4pL+rp6dy+NY7/8wFhYOgEH10U/FlSP39yblcoGbWZczpa/yh4hPfgfNHh+Bzc1k2P"
"KP8SzJ0aifAm0mc/99kJfPFSJ4lfV57Hj3/mcli5fvzegv6R0HIuJ0R8X2rZk2bMn9TO8M5D"
"Wu6bpFA3VUDGZbnZVTpe3x6//kgoHujjx3ucX2LA3V0DMOWbs4I3ywVv17x2Uooe4d3J6quR"
"7sO6uAi84YgV/B/jIP+TEqO8VnKRij3JSc88gvNXl2Piw6FCsW0XZ7czywo64z4+Rqz/dhI6"
"to7gczPx80ucy1LUM+CXlZhbBT0GNF7hTGvak+rhRtrXiJAATHs4xBYupTTHX90nJntiDgIx"
"XE5ONgtuN99mUt+FEIy6gNbwbn4Hxj/QBbn5hYga+jFuGz0HT94dCo/iE+zJNMQTaRrsjeQ9"
"83H8q4GYcLcOc77ehIU/bkD7wa9LYZFenli4eBNCfJTIPvu7hN8ui1eJuExXzP5qA6aOvw/h"
"rvEoK8pgQUlWWFiAlhXYSx9t4gbSQb2askdor1X30evjcGnjdGx9t6WgUw4enjCHG7I/+HYr"
"K5jNG9di2IRFPAJndB8lujw8F7uPXsQdLYSXmXyIZwXWGA7dkYuvVh7BmGG9sezNfjjwcWv8"
"Y1BTQfcWmP1LKjbuT8Bdnb3w9KRPMEc827i7gqAquoSuo+axt3lreAaPbTLaMfKob+cIXN7y"
"Lv5xbwSK0k5zCJcs+J/2VmDTwWSUC3pRuOa+1/7gsnopPLefpznUxzvkTXGBjlD0NBx3z7tB"
"OPb57Ti3cjxmjmuPIR0M6N9WjbHTl0OvKmOBzVMi7PDu2XsRgo4Ef2WBxV6OUAyU6yRlMWxg"
"Nxw7GYunX/uPMIRugXvREbbc7eZPxbWoO31msUkS3BQKvf3xT6SQ4/wVWB+9BC99/Ac++OYP"
"zP3sS5RmX7KrUXjK0/ewsXZwbjsWnC8MDWS6WT1HUmAb98Sh2cAZWLN5L4fHiXeMJfY3ade2"
"xx+uzsc3a2PQOkyDQ/t283u9ys+hIOlw7ZEIYRhQFWltdF93wgWf/hKLNo3g/2uK3h/LDqux"
"fmcsFs4chR9WbMCF87EcsaESfWps7tAyFJ56Vzz0zNviOdxwT/OrHOptTISIYOzc8/w199IO"
"/PjLZk41EGScjuZJI3I48W8EFLoiBuUSU0uFzoAOeowd4I8B7bW4u1sTcQgnYffSqRxO69rU"
"IM0Va0CTKsW+fVsO4jh3+8HTWWF5hPeES1Bf/v2qtVsw852P0HrACxwaaUioggoEluwswPpd"
"sZg/dRhUBRck4WI2o0eUlsdb/bpqNR598TPsPHCGhZu9M9FefWsRe6eUyxv1r//gXKpBfH8X"
"Sl182StbGb0apy5ctTzDZpTlJCAprYDHHpVkXeQ8Wo1rFhbhF1tL0Pze9zHq+Q+x5o/9eHlU"
"B4zprWIPo6DEyGu9cO4MD0kmL+PbH5ZyyDevsJQFEOE3VdSvjKl5NqDdCMz77yqU5iZIYT5j"
"OSufghIzV3iR0CceIFpRrq5MGBH1TaLIL67gUDSFxsjTTs0xVskzvTLjP4jyK8XuI3E8r3L0"
"vxcIrz8NJlNFowVQZdi5/xSGjRqPdduO8p70iFQ1mD+rKGe9axWPnwyK4Xf1ZHx9OzfFij/O"
"ctGHisrH7egDnPX5GqZ/2K0TOV81a9FqnrdI+FqHSx7Yd0vXcGh25c5UnkoR6ZHJ8/vsrTyt"
"dY+FQVpUrmL++eb7xZw3W7Rks8Dr+LgsalkoFDgbw//X9JiSjZHVR6TzuGXLFuZDMoqsaQDK"
"bw8fPZFzZzQzkYzH4rQYhyexWKGwQiogofA95WcLLOzCIf1G4pbDiX8hbD6chp7tonhWnjQH"
"zsyKrFszM5ZvPofbo5oLgbQO/1n0o8XyVcBFWEeeEX0kAdYAl1ut94M+uBN7eRQGI0FAlhhB"
"cnoBW15+re7jUTsNaZC0HoQPojOxeHIg3h7fG6fj0qW5eTz/zMwNi16R/XgNChcSuvbZPeSh"
"UkOoR3gv7kmhXi0Kk7mKQ5onBL7aIwjuwR1tFixZquzNKg1sadeWp/nvBH9MXJgNCG83Rhyg"
"V+cf4OHHTYN9UJxxXqyvBQqEfnITtKAwlFV4aLTh0i0E4rPYmhfKoP7AnILzC58uP8OhIqKV"
"hIPGYwlaqCSF1i6qCc/vo3yjPXmDPw6nY2DnKHh66CwN1wop56C05GGo8kvsDfEVCSQK19G6"
"lSqtw0Nta1Rih2IET7WCX5thzI+036SEdcJQUTnQp0deC+XaTpy5BHXondh50RWTnmiG23t1"
"4OcqcfGBR2grFrRSlWh5vfkfjU8EPEK6cgOzxiuIPT4XS4sB55yEx0KN054RvW3fl5dcYd6D"
"XePLatljygNrFGxEFlVoxBnoC31Qe0EXd7g42J9H3hmFMRvD/1WVosaWe6NxTyQTKMQrVQga"
"eRDC1XwXNia5YlR8boVQPHS+VW6O99JZm7yVaj0/U4eoQNt6/hcge2IOwuLtWfD21GPFoilQ"
"l6awBTKmtxLBHkYcPXqCvZsnHhyIFq3bc5x65TfvYNDQkVKooUGzARUcj6Y4t1ezvnAP7Sod"
"NLVUmq0gAS1wagNacezankbP/u3U6NXGm8NUhL9CF4l3f4zh2DlZVxVF6dgfmyUEs4ZDTjTi"
"qk/7oAYfWBJWnsJrpKZIXZPW3ORJgoUEPhWKcKmxReFdm5loFdI1J9U9NGbMeyoI3Zqa+Hkj"
"ugzF/UP6C68rSxzOAjYQaF/4Fm7rfVgsPNyvlQDbqwjE+0jxkuFBRsJzo27DZ/8M4JAJhQ87"
"tAjhga0/T+vK44JMwsuzxxNevCOPld2Kha/BtSyFhwWPG9CEQ4ZUKEEhqXOpFbitWwt+fTv1"
"Tg45OhuG390bASGRGD24K3tRa7ce5nUpHCiRfra/iu+TWvDD7ygoFzwr6JZR5oN9p69i9qsj"
"8duGHSyYiQesvFuvcBJKnWZckhL3anYbAoKbSvP5hLCkto2k9EI8fn8/fu8DvX3Ykzl5NqGB"
"mqX2PTabym05Iq1fc7gHdbApOYdBfF5j+L8mRS8pFEm5VzaOaQxd1y5d0KVzO3F+A7FLePaN"
"Ge1GrRtzR6uQlZHC33dsE4Hv3hyMkbdJsuGvuslZ9sScBHHZejz0+u9444l2OPj9Y/yzfafT"
"MPHdaA4zUu6mb5cS7P/tQ/7dW98cwN6TKeJQNq3SO1YbSH0sEpNTTmzm5zuwKS6FCzdC/Vyx"
"/EUvS+7pH0IYxeKFr5IsllzdUygq94kd/mk87p64DAUV/jiZ4Y+voo/CTXhalC9KzVXgk+Un"
"eV4chT9IOL0wbggOrPsMg/69lpPhimoTHSr3iVFO7IVxGRg28xDn2EipUGJ78jDJatuzfAYi"
"wgJt76Vn6NejKX//89yn8ezcw0IQBl8fwhUW/epNezHjib48h4/g61XHsWzjcXwweTQe7h/J"
"P/vzu+fF7wP4/7QHe45eQliADq8/P4JDTcsOZdZqjVamPeVLKgPNusuN34tftrXDwI7u+OK9"
"p7Bk1Z8sMGa+MhaFFT9h4/ksqN1q94jTSz0x6q3tmP5oJA58J/HOmfhsPD7lR7QJc+M9XLUv"
"G3d1zsTPnzzL5dlHj5/E2EcGMc0/WJUmJdrrMYYqP8eVQ99h5sKt2HRJ4qEDZ4txcN9enP79"
"ff79tLnRPCDZJyi8zsKIyn1cvVrfw3krDpEKK5/yq/O+WclGG0+RFwbV1hNZGNHdDdt37edw"
"siS4FXbjJwU7ZPo+rHq9peB7y55sfQ93v/ALXl1wAB8/1wMTx96L0xczMOHNHzlETkYA0amu"
"2Yn17fEr97jg0XvD+fuU/V/gH2+tQ4ww7uzxUGuj+4P9QjDl/sbxf2WQCn+8bDz+4bfbsELI"
"GFK0BcVmTHzvFyxf8DKHRGkw9drN+6AP7gCVa93PcK1PzB+JOz66jjZJMTvx8eISTP/XI3wJ"
"JoXAZ7w4God+XyBkw2phlEX9pbJYYW5EqfDfDUaOHGlGA+wQmgRCfxPn9U8pli9cfuvNziQI"
"qV+KejSK0mI4vMHl6+Q1CYvNTVhubLEn7OUL7khgUtJVH9iOx1DxgFhjBcLiZyI58t3rLqaj"
"XEtu/C7GTxaOLqAlW6Pk0ZDFVZodz0UFRVdO8ro8I26Fl7AmqXKKQoHSNeTX4ydrmErqcy9u"
"54vxKETi2+IubsIsy01EftIhtpQ9w3txOIv6kuj5rLkYM0zQN2kHz2a38rNWxk/vKcm+hHzx"
"zHQnmNISCvMW66ayY8pZFaaeEJ+9TXx2BlvA9DdER3oGqpyiEnIqJXcP6wqPsB6ITPu0yvqp"
"z4b7zUpymU7ciyesS/ZGBX3LhaChSwApZKjW+bKXQ++lqinyxijnQULas2kf8RxtEZH6wXX0"
"NxRlSLRPOcL0oiZPGjtE+UL6PB1V5Im1Ef3y4neyF04eDHsa4hm8hOeppX0SuGrcX6F86A6m"
"gpSjtp4wvnRVeBjkqXD1nfgM4pvcSzvFmpM4HEdCmZ6BqkdJUXABTi38Q8A8JGhF7RhEB63g"
"Ie/I25mHKKxUkHSQL3ekfSF6UZm5h1g7KTmpIfx6/iEDrDwvmfvyiC9o3VITrILfT3xEnvfS"
"Gb240o+mtfurMrDkt53waX6noEsbKbdaC39Wx0808QjtxgNxSzLPi/Mg7Yk+qB1HJ+g5ijPO"
"Mg2J37T+rcT5ayftlz3nq5Y9pvA50ZcueKS9ohYaKtjSiL3hva5l/Tb+qYHupFwo39UY/q+8"
"v5yPEvSg80A4iG8o9O8uFBXJjEIhG6iFgt5HuWCa7u8R1lO8rylHDGpbf4XAlRO3FQWpx3iv"
"uFq0Em20/rfw5Hrqyyy6csqWSiGc+sD2HNolGUX9aVF5/yU5ekO7n2VPzA6wXntutoyzMVUq"
"MiBh6ObTHIayPA7D8FRn90AWNsTw3mIzqVFQwaXt0gw5SYEZrikGo5QXMVniuyZI/Vw6cXBI"
"+BOTUIyelB+9QxJmniwsiGkoDKFiy1xdSYHVjJ8FvhA0vq0Gs+CidSo1knVMlp+XOGz0eRyW"
"FHg9hQLSBrS2hT2oeEESuG7X4Sdw1Qkh3qyfEDzd+bN4Qgflofg9LnyQfVrey59NwkC658hs"
"mRih5rFQ9F5S+i6W0Ejl9dOBopJ0+ns6VDTihmkrBACtWSVoRDkOvhm6FvxUeq5287H0HF1P"
"/+q0r2L1CQufcw88dsePn4+KDdgr5etXKqRpG7RPte6vK6/VXdCISphJyNCaaCCrtcqVhIaL"
"Wg+fFndLSpLWT89jKTrgHFYd/APrcwilQZ5JdR6iHKVHeG8ucLFWwln5U1JgtfCn+FxaOwlY"
"XUCbylFvDoVS7oo+Iym9CK+PaordR8oxdvpmHmKs0jeppMDsxG/hIWobUASqxZ6EWvjTnQ0T"
"jXcE/4z4kgxMtU7sq9qtweer+h5TvodAJ4xOs6GcDR/y8ui9JlN5nfhrozsVszSW/yvvLxVy"
"kYzxoYn9tEYyogX9zeLnNNeR8uik/MmIY8Us+JVy5pICq2P9ah305E1bcso18T/tCdHOygNk"
"bJAxYJMNFpkphxNvFiVm8ZokBaGqkkgka43i5df9jXg/WUxUYADvcNvPrx3gctsU9crT1K2M"
"REyhrYGJuFlSMAcdYkrKV4f68FPxAAkrelVX1Dx/TijhylD9vXXhJ2WiEhasteG5Kj3KLUUq"
"kgKoDepdP+UANcF1JJ113EfjKH5TnbSv/mFqLipoMH7bn7tB6RMB0KuW4hjmH4Q7hL8uHpJm"
"AVJPmA80Xg1bf228VxmmfH0Gz17awRVrPLNPPAcVRTQGP3lHNQqxSmHhxp+vuqGx/OPSSP6v"
"vL9cmMWtFME1Jcuk0Kd4WYs/7N5fwZc6ofzqZ3/tdXKE8NOQbYPwjB2dTSorsRvmiVVILxpM"
"2xhcljCNdVCptPGGSorRLOOX8f/t8VOzO4UmdcKLpDAfea3kbcr0+T+A3yor/yJPTM6J2ZET"
"k9W4DDLIIINjIOfEbgI4pxslzRLkfIXO4WvPa7KEml35CJeDX+NyYoqJ82RrGb+MX8Yv4/+b"
"4qf8JOVxqSCmVfHyGy6fZSVmj7vqYtlgyyY3pk9EctUto3osP7vGQK6cs5Lxy/hl/DL+vyt+"
"hdEiK/+iGYqyErNHiSmUFgvF1VaG6ihUqS6yKcmqDCTjl/HL+GX8f1f8ZqVBkpcKJf4KkJWY"
"3Z6Yije5cp9GXfDaEC3P0PthSxrSitzQq5UnhnXTICY+B99vyZEuqbPgkRSk6ro+kIbgJ3z9"
"27kiN8+IA2fLpYnnTsQ/sLM3D6RNukoXXF7lkmNn4n+ivy9aBSlw5nKF+NmNoQ9VbE0a5o75"
"qy8jr9zEFqiz128yumLlrlQciiu1TQxxBv6wJu48ADqR6L/aufQPD/LE/b28LGEmFWISjIJH"
"06Fy1Ttt/Tea/638eSY+xyH+oSbrO9so8eP2TE4ZPH+PB/RqA0+Yd8b668Pf2PNbH/7Gnt/6"
"8Fc+v99typYuZPyLPDF57FQDlJiLZYMVls2u7fWfsZ58meXaLYfw/mNNoCpJwDujvLFs/TF0"
"iwCGtCvnRlkb/mqNjA3FTw2U4/ur8dowD0R6ZPHlidwnVYlJG4O/me4qJtylw5cr9sHNnI3n"
"BrqhPP+qrYTWGfiHCwHx+bJdGNDOTdCnjJtwnUkfmkJCN+8O6KCDtzEeFXTflWVyijPw92+j"
"xheCPosWb8Kfuw5KF00qnLN+4p9Px3lh2aYYaJn+GqfS/8+9x/DNmjP48pf9CPYyIS0xBiUZ"
"52zz+xqL31eRzPz/5a8HhaDWOH1/OwRk4jkLfzZxy8eQ9gZuFLcXP/EF4YzyLUbR1TN4Vpwl"
"nbIUO/efxPzxYVAWXWrU+a0PP838HN9f5fD5rQ9/hC7VRh9Hzq89+Cuf36EdDFXoIyuxvyG0"
"ClZh+8592LH3OFvQTw/wsE0kp2nSdP1CcfpZhyc+V8ffTJ/GY2X2nkjmCd40LYOSq85af5RP"
"Hn5aewBHjh5DYkom3F2NKMk857T1E/6f1x7ka2To8GakxvM0daODz1ATfToF5iBIX8plv3QV"
"S3l+isMT4WvC764x4sl7wnBPj1AuJWeh4KJ2Cv7RfTTIycnFiB46ZKVfwY+/buH1mypKnYK/"
"uUc2Tp1Lwq1dIpGYmo0flm+QbitwcNhwdfze5hTk5Reha1gFPLRKXDh7kq8EMdp5I0J9+Pve"
"YsbJmIs4uH+34M909G7rKxSD/fy5an8uVmy9wIUIxBs0h3HJb7t4vBnNlBzWGdhz9CK2bPvT"
"ofNbH/4I/RUs/f2Iw+e3PvxdQorx85p9OHLkqEPn1178NAXFen7puh2Tg/srhxNvAvh+UyLe"
"mXCncN2lm5cNJdmCYQzcCKjUenFTMXkCNO7HGfjLC64gPr9M4G3Bxj83NDbi9tjq+A8dPsK3"
"0s56+SHc2jEUY179WgggI0+ocCZ+mn1ItwKQ8qIxOY72mdREn7H978SrC3diwNx7me7kmTlK"
"o5rwr9t+nAfoPjasN14d3QUL12eIvfZ2Cn4NiniM0GdfLuX5iWOG9uTLJeGk9dPAZ5MxFI/0"
"j+R5e9Qcy7MPXd2dgt/PTbo1gEYwJSRfQbtbAnDoQmKVJtvG4F+zYRs+eeMpLJg+Es3CAtlL"
"o5FvNIDaHqArV6SbpEul/iZBVzqfPG1GKHJjaYE01UR4Lo6c3/rx5yM+la7maeXQ+a0P/597"
"j/KlobNefhS3dmr4+bUX/4dTH+fza7Ke37+o2fn/C09s5MiRN9V66O6wmQu34CdhnZCg2bP/"
"CA+jpZCkj5cHTl/MlEJZDvboVcd/7MQZabo3TbK2TcN23vrjExLx+5f/Qn5RBe4Y+ymS0wt5"
"urjSwescquNvHxWI5x8bKJTMQfYohw3szqO1HFVi1fG3jfThSz6Xv30n03zGi4/yfU32XMxo"
"D36ybPMLSnD+igkpWcLbcFOwp+Gop1od/94Dh5GbVyD4Jh0pmWVCUOhZqdV3b1lD+GdQz1C+"
"b40uQKUZezRhw9FS6+r4A7zU7CktXLIZu49cRKe2UZKgdhL9FWaD8Ax2Y9FPW3Ei5hKOnzon"
"XfNi5/nia25oJqoQ1BQ+S0rLQ1igF7y9vATPG5CQmikNm3bw/NaHn+6RoxyVo+e3PvzJ6UVY"
"//XLfI+dI+e3PvydWgvj54lBeHWB5fze1cNyfuWJHX/jJJoS7714H492mTznJ2zYcwEjRxRg"
"yYfjEBHih6ET1kg9Z3Zco24Pfp7X6BFIM5kcvmahLvz333cnPN3dOF8yb8pQxCYVY8muYser"
"j6rh33ngNDY9/RArerqOZPKcJdKoL0cPQTX8lDtZuSOJLcgT0VPx9kdfCwXj7vDlj9Xx0wT1"
"j9/shY5tm8NLr8HUuSsFbsc91er41+++gAeGm/H1hy8K/vHH828vFb8zOmwE1cQ/t3YMw57j"
"CXxLAM3Eo9FPzqL/jv0nMG7UvfhqzkR0bN0UUz5YxsrH4WhBNfypWWX4ZGR/dG7fAp46NSbP"
"XswzA10shSn141NUCZ1+8vMxvPXsYOQLpb50/RFs2H0Ow+/uicWzxzh2fuvB72Id3+To+a0H"
"/9AB3Rp3fuvB//vOM/j9iXuund/ZPzbu/MpK7H8PizZmw7s8luPblGOg6fPTvo9HlF85jh0/"
"wYdLH9iMB746Az9NNadBsnNWXkXKuUtw1Tdp1AV11fHTBP/zaatRlivd1ZRWIhSAa7DD4aDq"
"+DXe7XHvqxvRMlB4ffGX+a4uutSQ7lxyBn7Ppr14xiF5wg9NW4u4bJ3AH2G/kKt3/W0x+LUt"
"aBFgwPHT57jSjEJZjnqqNfPPZcZ/6dJ65JeY+HmchZ/4Z8G6q8i4cpmv2KEhsiTgzDA6Bb+r"
"d0cMemUDWjYx4XLCWuQJj57318Fw5XX094rAfZM2SfQ/GcOXxNIA3oZcEEs3nCtyTvHQ3qPJ"
"aox680+4liXz7cg0x3HKtxcEfqPD57cu/BS6dfUIadT5rQs/jfw6mxwtzm+yw+e3Lvy09ntf"
"+R0tgxTS+c0v5vfRDEZU3Hh5KyuxG0FUN29kGyJRLiwsr0glT9kmwZZUmA7PCJ0wuCTLy0Wt"
"cRp+mihSYiiDe2g3vk9P6cDNvLXh56nkhgqUmXU83FPh6so3yDpauHDd+sUhoEObWJgGk5ce"
"nr6ufB2Ii4NCrib6uNIUcaUaBYVN4Nc6mEM3So27U9efINbvEerOQo6vr1C5OpV/EosyBH3c"
"4GGlj/i9s/CX0+TyYE8p76PxdC7/W+iTRPvr7QVPPyfvrxCYVEiTyOfLm5U7TVpXKO0Xb/TM"
"FZ5t4KGvsEzyL0N+nrcwIAx8CzMN000qynT4/NaHn4YClxgrHD6/deEnTzuxwohys4fD57fO"
"9dOtHWIvJP7Uw8PbhXmTJuvLnpidQDMObyYgAUmXX9IdV+yNU7+EwoUtT5o4baIwinC167ue"
"vcH4xVc3rzCYTNI1C87ET2EmukaCrzKxhAkcTdzWtn66S8skPAHGbzZarm9xHn5JAHrxVRl0"
"/5vJwZxbXes301UaN2p/XaXrR24IfegaISH8reOIzMZyp/P/jd5fHjLsIP1JyWr4Espr41X5"
"4lHLNSlMfyHIHT2/9uAH3Ybu4PmtDz+dX6KZo+fXnvUT/Wl/qSqRx04VZshK7GaF9a95wENb"
"c03MZ9FxeGmkdLPpc5+dwLEULW82X/tOm02l19RUWkeoRroB+XpLjK5kn78mCceS3aTKoOqd"
"9Ry7doG9gfVuzRT4dOw1q3t/TBZe+CIet3Zuinn/vHbFwrCZB5FR4c8XB9IzmCzX0piN1+c0"
"Kt8cPWbWUVzK8+R7mIZ3U9ueKTmjGCPePslKsbLFSbj54k5U1IjbCtLNudez7sqdyZgTncmC"
"nu/cqmnyAO+Dqt58DN2a27+tBgOmHmNL87pboAlPNfz27i9d8z7hbskLoWKZA2ezUVACzFmV"
"KXlw5GHVgt8e+ly7mbcqfLfxMhZtysf00ZG4v6cXV5SNePtEpX1QoKFJGQohvTZEg9ahGhsP"
"hTXR4fmF55FR7oVerX3w7iPSeZn89Rn8GWvki1vr+5za9pjg3SVnsfaYib25yjSqj/7dm6sE"
"XwfUvi+V+FW6v03VoP2lfqqJ9/rw/zcfTsPri1OksJoldzZpiCtGdNddx6sUIbA+76/i57OW"
"J0mh0BoKPLoLz/PTJ71ssuan3aUc7g/z12D5i941nlnmJRYN2nrPb208VBWfwiJuVDXyZ+X7"
"Bf8Sp0FWSQ0DD610Ffuw5z9HaO/nkJCSifc++xlB3cZi1qLVfItt5wfm8Hvp1l+6ebmh/Ty/"
"7c9H52f+kBj/nS8Zd/sh07mibs6TzaWbjYuzG/0shy6UoMuEXUi8ksPPMPIf07gPZN/pNAyb"
"cQB5QrK2uuMZnD64iZtH7UnEL96WgcFTtvP/Z48LhyltP7cY/LY/D5M+P8Yx9O73Pof8pIMw"
"lBU4tO77Z13Ax4sPcCl1YOdHEdb3BUz9+Bc8eHsYHu6QjeLM87ZGXYf2WMjjloEKeOqU6Ol3"
"jntqHO0pqw7UqEwKbMb8zQi77UU8+u/5CHKvgMaQJvhlN/fiNBZ6vHIKyzaexNotBxHU9XGE"
"3/YSZn+5Dv+4txl6N4nHG1/swtyfj3IpdNbZ9Xz7ryMQImTmp0/ouZy6w7A3Ed7vZRw7cVoI"
"VC1MV3bzPrw2VIuvfzuBdduPoZk2FQUpx7jU3t493nUwhp+BaBXRfxp+WrMXqqI4FKYebTD/"
"HDxfiC7PbrPxO52r8NtfQcfhb+Pk2UQg8xCK0mMd5p0ft6bjvkl/8Lm5p3sgKhI3cT+ftQCn"
"e6Qk9B969l289PqHKMm6YOuloufdeyKJb2y33lxe4zNcKLKdWTKWgw1H+M625MwyDH/rOFeY"
"9hz6Ek4f2MCekKPFM1YeoqKrwC5jEHN4G1/u25jWHVmJOQ/MDXhdBwXFJgx744jwigr4mnca"
"XUTuOVkg321KwFtf70eRUcpVGEryeTJBQ0vFKZfCN9gCfKAIt9G9JTYdSObyYu+K8yjlK+sb"
"x1B8QaZHIFtQObn5lu+DOOSWVuKBM5cykF9skG4y1vmyN1kvTrpdVt8E63ed5eee8VgLoRhP"
"sRI4n+7CFXAUmuBbARzM29HfWYsaKORCly6SZU4Q5GXka+ENpbkO0+XO1gr8+me8EGwJGNQz"
"nKcUOFouX0Xo+7jg8ds98eF/t+HbH37ivMTlwib493/+hKdeI5RJMiuERodXxP5RDo2EKXmd"
"VORwNEHauya6Qm4kl/JFZu5xMzpoTIzpI/H+Q+PfQXZmOvSBbTF/bSp+XncQemUJtOZchPq5"
"4vDhw3hm8jzM+eYPFuj2VK3Z9lghhap0/i3hFXkb3vv5Ir5de1YKITawOpP+hrxqDq9Zzqx7"
"UEeY/bri4dc3YH9sNt/OXsvRt4P3BV97BHArxOXEVAzsoEdpzmU+wxT12H9GCq+V56Vy2Trn"
"8ix5TXpe8sjozJQXXK21cpaegc4sRTNWb9yNea8Ngkvuaeb3tCItzlzM4P458iZVdMu1wqVR"
"PMQelZAzdNGtyhJRutng/1Q40Sn32ghXmnpofN3us8xP0/AFgFSNRlVklUuTO3dsjV8mPljF"
"9VfxbbqKepSLK/fqEFhxh7TsgyF3hgrBVIy4C2cx7ZFH8MqjPraQ1ORvzuJ4SsOKFfhA8KFW"
"s5LS+kRypRQxMAsRVzPcgzsJ4dSGFZk9ExxIMBDOYlMxnpv5HTZ+/zpi4jdg+ZHLcPWNEnhM"
"XA23ed5I7t0ixf9gv1Dh9ajw3pJzWH2kRHy+T52fQaEvtU6alK0Ryp7WOHpwN/4dCY+4da/a"
"wrkRIQGY9rCUO+n6/G5LqLHuqsdukQrMWHge6lItpj4zCNMXbOIxOk1D/LDiJe8qYePkzBK8"
"LwTriw80R5twHb7bGI8F66RGUFQ78P3bSMftwtlTLBC8owbyDbpFQolMmH8KLdt0wub5vRzG"
"X0UAuVVAKRQvVep5hHXHYyNa4HRcGhb/IhSJb2eoqKhCocLjD9yBD6cOtIUCJy6KE2vzt2t+"
"Yf92bkhIvoqs9FT4troPPuJ5yED5aN1Z+LmEYf83j/D7fp77DGYtCsBPe8r4FnR7eNS6xy7q"
"Uq6YnPbcMBbS0XvS2RugvNj8Z0LQI0rLYdEUQaeJX1yWjK1aBthK/N6E+cZ6ruZPG47VB4uw"
"/2xTnh85/dFmbKDGJhYKvgzGgdgcng8456mW7Jm/9uVJbI8xXB9ersT7SrUKa7fuxx23dsHa"
"E8eEx5iHbhFa7D2ZjAdvD+XcGuf0vMIxeYQnhxhjhJFhNpZJw8brmDloPbN0NqfP24Dfv3oR"
"b4zrgGk/nIF7aHeWSe7BnaEPaof2tzTBOw/rEeqrZhpN+fY84rLc7GoNsPIQ1X7QOrV+UVIO"
"zOKBL3/RqwqfxiYW4PGPYjnE+1eGEuVwomNajDeYmNC6qdc8KA0zmDXhPF0osB9XbMTi6G14"
"8q5g5FzcJlz8hs0U++j1cbi0cTq2vtsSOTk5eHjCHD6ITw9rg5mLtnOo6ETMRdzevAgFKUcc"
"tqqteR6bouL/u4hn0kpVTA0cQUSHMS7TFbO/2oCp4+9DuGs8yooyOM5PB+2+yVu4lP4fgyK4"
"LH38tEWY8XgrIOOgUBhpdlnDTYO9kbxnPo5/NZCH4875ehMW/rgBg5/6iH+fe2kHfvxlMz5Z"
"doK/zzgdzZMc6g6RKdiDyc3N43E7BKPv7cTtBdQk+viHpyQhW3AOHYe/A1N5CaY9FIwJb3yP"
"D77dipF9A8Xn7qwyu88WArAk6rOzMjlJTkUCZIlTZRopmlzXNhjz/kGH8VeH0YO7In7TTBye"
"110oZhcOLxaZdCy8rYJ+577jOHU+BX0feQcPP/sez/Gzd+QRCfWcnGz2INx8m1nu29NCF9Aa"
"+bpOGDx1B79v+KMTMO+bXzjCQErGOhjZHujbOQKXt7yLf9wbgaK00xyiJAPrnu7ByM0vRtSw"
"T7hXjMKwefG7BF3sKyZ4fcJwPld3dfFFfvIhlOWlYM2RMnz6SyzaRnhg88a1GDZhEY+YGt1H"
"iS4Pz8XuoxdxRwvh6ScfkiZ41GHoUm/oiHv7QedSxHs1oL1GnNN4i4KWWjtGdNeif1tXjJ2+"
"HHpVGfdYGcry7S6qKXXxxb/mrMXQAV3wWF83lGbFSXJIGGkuwrgmBbZxTxyaDZyBNZv3cnif"
"1m4saVxUISXbgP5Tjkph0F6eWLh4E0J8lMg++zuPjpPDif8fASmwf016i6cI0JQFyjfZe8is"
"8Opbi9jCpbzPqH/9B+dSDfCKvB1Dpu1G22beOL1hNvr1aM3hLp7n1hgl5mw3X+vL/SXrd8Vi"
"/tRhUBVckKY0mM0siCi3+OeeoxgycizW/nFA8pYiFNLcNTtyUJQX8G05CMHdx6H94Ol8mDzC"
"e8Ls00kK5xZnw1CSgwJLZIZyB/WFBWlS98i+TRC7fBwOfDuKfzakfxdB21jOUxQZpPBP9OqN"
"LMBpegEN0D13+hA/j5eHTgjaczXmtmz5BKroEoLcZnELY2HeU4H8fZHBzWH81YHCegHtRiCk"
"97OYMnsxezPTJ460lVZ7ebhh+cLXsGbTXuFRpbFy0/o2r9dTrfJMJhOHmPgOKouhM6CDHuMG"
"Btr6wKgqkax5Cp8pGqDACPYci+dnmPffVSgVhgQpGwohU4l3iI8CvVp54eDZHPzjnY0Najl4"
"b/5y5p01m/ez8KcxSvQcheUqjnasjF6NUxeu8ntXrd2MspwEsRcF8HR3lQZK18NHsUlFnP99"
"dFB73OJdgE0HU2zGgbUHrGWwAnuPJ/BM1dH/XsB7IN0kYF/6gYzB+AJ/zF1y0GYoUuiSqg5b"
"h2vZA/tu6RrGt3JnqjD6fBHpkcn9dY0ZCUV0KoGnhTZbMPOdj9B6wAsc+v1f5Mzk6sQbCGuE"
"5asLbAt9k7Y2S7yhQ0/JyqXGUI/wXuyBUY+MX0AQvnshCCfPJqHvo7Mw9em7WTASbkcLECjX"
"xjk2S57BQ1M5heioY6fkyrcPojOxeHIg3h7fG6fj0nlkEoWLpJsB1OzV+giBIgnFCi40oDyO"
"PUJJrfeDPrgTW//Uq0KVWvpAKeSnVOvZ4+gQFVhFeNQFVMHW8v4FKEqPgYsQ9o8Kb4a84UBd"
"MXuSyjBpL4uNbtD6RbCgps+lfSEv3LrPNRXzHDxfxF87tW+Bk9uzbQeewjMkOIvFZ5r1zRzG"
"X5OwcfUK5fDSqewAoRAu4/nH7sJHP74r9uAW8Q5//HvGf/DdvBlCyCahQN8JWv8oLse2xxug"
"Crye7aJ4Xh4LXuIdoci6NTNj+ebzQtBLQlutIyWms/VzNay0XsF5rE+Xn+EcGfET4dh2qhh+"
"LrmY/eoDLJz3nUrF+LmHLXkc+0LpFKZ8Zd5u8X9X8dyBrLyVGiXyhLFAvVvuwR0tfCNVA7On"
"qTSwoqiv+IPWsWHvJdzWvRW8vdNw4sxFTj1Y90XaxwqYzGVs0HmE95DGOzHPK+ymDfWALT2k"
"QpsIyVCkKRpc9GWhMc1lpMZ4z4jetu/LS66wTIGj4+nE+jm9ICA5vYBD1n6t7uM0i9rBeaGy"
"J3aTgVUB+PoFcLc/NQtbwwwNTkZT74hgOE/hYXg27c3FJOSBhfppMGthNCJCm2DYXT3h4+PD"
"wzgdUToU/39s+K3o1daPE8Turga8/aCGY/gknBp6L1D/dmr0auPNIRI6aBW6SLz7Yww6to7g"
"A0YDZ61we+8O+PWbtzGoV1MpvHUwpmECTufHOTGvZn3hHtqVhVyhQQqVdWwTge/eHIyRtwVJ"
"B7i8qE5sI7ppeNo6Wfoeod2EYr0Huy9LxScUsqFiGmsDp7egt6SIlfyiPI9t1qC5ZuV/Pg3Y"
"uC8eb7wyDg/eEcZTv6ky8e0HhUe08ZSlAtTsMP7rDRM9Kw4PQZcefe5Ah5ah2LH/pHTNivAK"
"KGy6+8h54cFuxqx/D+eCgvpoVBkWb8+Ct6ceKxZNgbo0hb3cMb2VCPYw4ujREzCZnNDsKnia"
"Chk8I/qwoHxu1G347J8BGNMLCG/ijjvGzUfTOybxefBXprHnbU/BE3mjpMS8m9/B+Tw9G01u"
"/Hle7m48LYaUltWQvDbTUFGncUfFO5TrpRzvH0fS0K97S9zaKYy9OZWbx3Xnrm/X5ritWwt8"
"O/VOhAd52UUSamvo1dobbcK1HNmgPSZD0dvTHR7ic8nTonvVkij8fX8//huaPE+eJBUrNQao"
"PWTuaBVHNZg2KldOn2iFnKO8WWMb5R1iEbPZLGudOmDkyJHmiz7j2cKneL5UzOF6XS8XlXsP"
"nbEfHiFdsPf9MNvPaUjpY8P7SO9Juop7XloF71sGsFdAwjI0bipSouZUuc9neHe363APm3mI"
"LUMSbHSXzydj1GgX6YuT55Lw1a8HsWD6g0KprcKyQ0roxPus07Brwl898e1amoB3HnLnA2WF"
"FVvO8wxAjbBIPZv24eokmxdg6TOpCf/jt7vb+sQI7p64TFj43bjY5albi+FmysKMBVvQpNMj"
"+G1GWxw9dhy392oHby9PTJnzE5as3s2ChRQSQU3rX/GST5Ueopmf78CmuABb3xAp3ofaZ+Df"
"D7VGrlBKC75fgxkvjuaij0H/Xl0j/cfe6YuJgyXrMjE1E/e9thVtuvTDr5NCbJ+z69A59OvR"
"qlI4M5u9AKvyvb1nW9vvooZ+LD7nTjRNmmVbP1m+ZdmXMaprCaY8cw+/j0KEHy85hJ/X7kdU"
"qzbYOHeww/it9Nn9ds29UMs2HMcbsz7Dm5OexmMj+vLPduw7gTv6dLK956n3t+Bkhj/zGYWc"
"6uIfCq+GKk7jjSfaCYNB8iCpPeNfs6LhKRToti/H2vDO+WoDfjnpw9Y6KYLa+MeKv64+MXqO"
"k+eSMWZIN7RvIfHlT4Jvps5dBd8Wd0EX2I4VWXX8PVroqvQ/Etw7aSNyVS25/2lYV5Xt3FFo"
"LyIssNLex4q9byPtxYFTeFZ4fXpx1psmvmPD//gdXrY+MWmP5mL7N0/j6IlTOCXWS4OnbaHe"
"tQcw+9dUfPFyV877UYn/5cQUDL+nDxav3IY50ekcjQhPeLsKfXpGueHTJ31teKbP34TNFwNZ"
"4d4aepULgHqNmISgrmN58DW15DQN8eX5nlM/WoGTsZcF3/QXuFvxmayN/rX1Gkoh3svo26VZ"
"Fdq88FUS9IHt+e/JEKogY7UwHbfkfOWcgjpZiTVOicV5/ZOVGIUUeJozb1Qh56Cop4OS4aTc"
"KDnvHdmPO+4pyVmYeoJDIRrPIGG5pHK/FFUQeTe/ncMAFE4Ii5+J5Mh3q1xMR1VKhDs3fiff"
"LaS0hBu8m93Gw1lJAFB+jQoXKBFMrj1fkSCYUh/UgZUdlfvWhr965Rk9S+GVkyhIPIAKIZh4"
"WjVVQYl1e4j1UojJxSK4KiuwmvBTmIVK6nMvbueKPn1QexYsGu+mKBMWYn7SIbZ4yatc9Xor"
"fL90DeZ+9jk/A9GEyrQ9wnoIuolnMhpqXL+hKEPQZhcKkg/zgdEFtOTKUPJSpTyMWVijSYI+"
"f6LoyilbmIvCd3TQaqI/lTQTzfMFDehCS/fQLoLe/XjCQfb5zUwf2n/y9MibpNYJqjSlfScP"
"itZH4V56Zvq9Lqg9K+Nbsr6osn5SsNQLRH1y5InRz2nN5BXQ3tE6cuK2ojgt1iH8RJ8K4VER"
"jsLU43y3GRdTKDXMI5SnJM+ePDHiT7r2hgpLqCCIaEnWNM2a5Cn2CmWd/ENKjrw32oeitBie"
"gsItFsI7ltpPhGebsEc8SwzTjdZLCsZqQNTFn0Qb3uOUI8xTpGRonBd5HsSDbFC6eXJuikOr"
"ChfxGSGCd3pKUzUsUy8q4yfFVpojeFCsidZL6yCa05llmgjaE01yL24TdM5gD5Bw0DPS3hOd"
"ysT/IfjSPawr82lk2qc2/LS2IuKhhL3cukBKiELlVIwilamHoEx8PpXdU5Us5W/J4ysU56WM"
"W2bM/GxU+EEhYPeQTmh2ZW5V/qFnyLoo9ncLSjLjuJqYjBm9oCvtYa6QR/SVnomqTKmQoyjt"
"DPejkRzR+reCe1A7iZZ10J8KoIiHClKP8dq5Cd9Cf+IZ8mRJDpDnS7TxjLgVXsJbpkZ2kidk"
"4JASi8r77w1XYnJOzA6gJDIxgckiyM2saAycpyBGpIPAY1doEgGXyCpYWWn9W9qYQieEJwkw"
"jtmL99IMM+sAThIoCqNgCqUQAspy7lUhXCToKVRWGbcU7pEmjRPzGsoKOY5uVVr8la5BqAO/"
"uYYSZK3vLSxMiSk5hCjeQ/kmGkZKeI2WGLskfKSxRDXhF99xeMOnxd0sFFjpi4NKOKisnJ6J"
"4LcZbTgENOPFUVx1+duBPI7d0/BZ+huqyqtt/UQHoi0ZFuByaylnROuyhsPowHqG92ahTJa/"
"lIspt43IqU5/EiCUc/Jq3k8qPCF6U85OrJ2EFQkk6w3fRB/OAfEkBBcWLArLJBDOSxrKpWs1"
"LGHYqutXQUNhLIGXinxIQNNEBwo5kzAgPvMM78VCyTH85bxuUhaS11M1NE3CiGhDgo4MLL7K"
"pNIz0XuUrsILM9BUirJ6+YcNrNBuXLhB+RYyFqiQg56H8FmfxYX7BwOY5sZyY638Y8NfbY+r"
"PweVuJPgNZYVib0sYi+X+JXCrnxXXA34CSf9noxN2k8pd+XO/EN0p3NDPECtD7QvVtpbaWSl"
"P42c4vCuJaRow0/5P8G/pKyZ9zWevKekaHgtAh9dgUIGqfV8Ea1V4ispY8IvKV+DlBuzPHeV"
"88X09WajjVpVuLqVjVgjKxlKO5BSV2q8mNeI9rTnpHjoWWlviD9M9cmHWnjImk+swjPi/2wU"
"miWDmHCzvDSW/SXyWVZidgALR0vVnwsLQpUlHqzhw1tV4Ul5ALK04BF0PS7LxhsqrglpAzOw"
"mg+llUFqw22qNKlDxd6L/3X4iWGlKqfa8dfIDILBmckre2linZWLUazrrws/HSzyvGx/I7i7"
"wjKBwBqKum/yNuRf3ius0JNsZZMlp3YP4jJsY0VRvesnq5helaF6ZSavoxoN66I/9c+4kXC0"
"0MdaJebqGWI/r9hBn5poJHnExfV+nr34a+O/ysqnpiGzVvwkjBrCP6SgbLnfOmhnZOFpsIs/"
"a9rj6wsoqj4DV+eZ6uYf6yCBGvmzhnNXG/2tBSqV8XMurXpeqFJFJnnC1507N2/JaKqO31I8"
"UuP+VnsGG+8LRU3KjGVFSblFsQZCXVk+iPfaQ//6eOg6Y18obnO5gRWY9BkGWYndTGC9hJBC"
"JA0tdKjxEJivXfpI5dLMPJZGx/8L+InRqaGbB/Ly4dcKazSXJ9LJ9JHxy/j/vvhJTv5VCkzO"
"idmZE5OpIIMMMsjgGNzonNj/E2AAz1XfLodM4S4AAAAASUVORK5CYII=")
getPtableOnData = PtableOn.GetData
getPtableOnImage = PtableOn.GetImage
getPtableOnBitmap = PtableOn.GetBitmap
#----------------------------------------------------------------------
PtableOff = PyEmbeddedImage(
"iVBORw0KGgoAAAANSUhEUgAAAbEAAAD/CAYAAAB/9egZAAAAGXRFWHRTb2Z0d2FyZQBBZG9i"
"ZSBJbWFnZVJlYWR5ccllPAAA4bZJREFUeNrsfQegFEXyd82+QE4mMkgWFASJKuYz/AUTIiYE"
"s57p9NQ7A5gjngE9Iyb0RDBgOEAFMT4woJ4kFTCQMSDh5Q0z8/Wvunt2dt++9zbMu/uedHl7"
"7Nud/U1PdXdVV3V1lXXCCSe4VMc0c+ZMiwwZMmTI0A5Fo0aNqnP9ko//e27qVNJ3ssR/+J+L"
"T9zEvy11kYtPLVf+yx/o9772WvK68ePGmZ40ZMiQoR2U6lq/hKrc0U3816X4DV3fRa7vetf3"
"mev95QczZMiQIUM7PNWBfmFLzHHjP+f3DlHc/yf+cCzvA4eVIJChCh3+x381gPkaJ+ljQ4YM"
"GTK0w1Fd65d8aa05pH+n7DSl5FyfGchWnfzCspSKjOtIy7Xi2tG72GgxQ4YMGdqhja8A9Mv3"
"K7+nlatWUcuWLWj4AQdIBad+zO5Ex3FZQ7r413H4ZbtO/HPXJscWf4t/XfG37Yi/8eL3Ll+H"
"679YtIjem/+evK24Aa4zZMiQIUM7sCWWo375+edfqGhBEQ0dMoQi4QgtKCpitedAOWolZgNU"
"gePHrvjXteV7vqEtb+41An/rz2x5zcIFC2jZ8mVkhSzKC+VxA9BIQ4YMGTK041Ku+qWyspL6"
"9u1Lbdq2phbCEsPfVijkWWLSnehIJ6VD0g9puSHpl7TgfwzBkSksPEt5Cl3PGmTr0JFm4rBh"
"w4Sp15I2b94sb6DNSEOGDBkytMNSrvqlQ/sO1KZ1a3rnnbm0du1aOmnMmAT9kq/NvcTYEFu/"
"gR5lH6VuSMqAQ3ZjWlJzstkIrSpNREOGDBkytONSrvolXF5Br776KvXs2ZPOOecc/iwWi5Id"
"s/1KLKZALbX5JvVgYkyIJCvpj3g0vyv9mmwOOsqdaJSYIUOGDO3YSiw3/fLDDz9QOBym4uJi"
"mj1rFu2y667Ub++9Pf0ilZgttaAMKFRvLHkLS0eIaHPP05a+WH5LHkRz9bWIHFE+UEOGDBky"
"tAMrsRz1S69evahNmzZUWFDInzdp2lRFM/rOidlBKBuB2qNnDyosLKRoLCbMvRjZtolONGTI"
"kKEdmXLVL1BWCOjIz8v3/o5Go55+UUrM9lKAuN6Wmiv/X2nOqu5KSytTmRaEN+609WXJKBTX"
"RCcaMmTI0I6txHLXLzE7RhHxH2Iv9HmyBEvMURtk2trTaGvXradDDz3Eg+3UuTN9/PHHdMDw"
"4RwlomnBgiJq1669uJHAAZY+uWbOOhsyZMjQDk1+/bJ+/To65JBDve86d+4kdEoRDU/SKUVF"
"RdS+fTuhThyVM9HSXsYq+kWeE8OhMnUYDTH7tjq83KFje/rpp5/owAMPpJtvvpkWf/01NSgo"
"4JtecskldPDBB9P27dupR4+eEp2jE4UFFpMH1VwTnWjIkCFDO7Yl5tMv7dt3FDpltadTvv56"
"MRWwTvk4QacgEhHqyeVzZHjF+MxYKv2iAjtS7V0pledKH6Q+aR2OCKNOvJo1a6Y+d/nvSCQa"
"D+RwyeT+NWTIkCFDKfSLm6BTIkqnNG3WNEGnRKMRivk8e5b2LybpF2mJiZvEXzH1r8PuQYDJ"
"U9U2hzlWVFZSuDLMG2uyAWE+QR2Jyrh9/q0TxzNkyJAhQzuwJZakX5J1CvRHZbiSYtGY1Cnq"
"sx9//JFOOmk09endm4486ij6/PPP5Xlk10nQLwkh9nE1R0Q+TyS042233cYvPx100EFS0yqN"
"apmcv4YMGTJkKMESq6pfqtMpB0KnWFKnwN04YsQImjdvHs2ePZtuuOEG+vDDD6m8vDzBQFK5"
"E/2a0vE0pqP+Bk2YMIG2bt1Kv/76C23atIkmTpzomXfygLOdhGMsMUOGDBna4S2xFPoFyiyu"
"U371dEpI6ZRt27bRJ598QpMmTaJ27drReeedR2vWrOFr8/LyqlpiOgSyKslQRU4lJV4w/crK"
"ysiOxfi9NgmTFVZ12akMGTJkyNCOp8SSFYKrYi2kTinnNFJapzgqqTxo5syZdOihh/J3MJqg"
"Z7YLBadTHMYtMduu8cXBHeJH2A9D6g9oyd9++81TYsnKzHH8GteQIUOGDO2wSiyFTtEBHBUV"
"FVQidMr2JJ3StGlT2nfffemBBx7g/bHly5ezMlu/fj3HYfj1S3xPLAVt2LCRRo8+kd9/8ukn"
"9MK0aTRnzhwaOXKk+G4Df96xY0eaP38+NW/enLN0MJ6xxwwZMmTIUJJ+gd4YPXo0v//0009p"
"2rQX6C2hU0aMHOHplA5Kp9x000101VVXccop6JnJkydzVHx8Tywh7ZSdkHQRARr4s127tvTV"
"l19Ry1YtqUmTJqwlS0pK6a235lCjho2pafOmFLJC7GLcum0ruVFHZSxWyR0to8QMGTJkaIe2"
"xHz6pS3rlC+FTmnl0yklbBw1biR0ilBSoZDFOqWktIRmTJ9OjcV1obwQRy9CgUWjMl5D6xcv"
"Y4ertJeVcHOHLCssFNQ2vhEoxnkRoxQRQGUVZayuOGwyHKGowEmMUDRKzJAhQ4Z2aEvMr1+E"
"URYWOmWbMHq0TkGuXTsaZd1SXlEu9QyH31eKn1hUUVlBeXn5/FlU6BmkoJL7YX4lhqzzUEeq"
"wCXvgamKZOFKhyorwyrPVdxJKKBlw1zyTDd85+hcWJx23ygxQ4YMGdqhlViSfglXRqhSKCPO"
"n+ha8UxSqNjs6RfX0y+VkUpPv7gqL6Jfv6h6Yo7SRXEt5epT0uS7SYISc1MqsfhNtCI0ZMiQ"
"IUM7rBKrY/1inXDCCfXeXJo5c6ZRl4YM1UMaNWqUcdcYyonYEntu6lRfXIflVdTU6fO9Cs7q"
"ItafVrymM5di8XSqB8SfjR83rs7xDRkyVH+pvssfg/+/xQ9VGVFu4r9y+0ze0PVd5Pqud32f"
"ud5ffrD/Ir4hQ4bqL9V3+WPw/+v4KrAj/nN+7091hT8cy/tAlrxUDkls2FlKLfoawNc48Y/r"
"Gt+QIUP1l+q7/DH4/1v8fGmtOb6IRMuX6t71Hx/zKmp6lTNV4xZ9sYh++/U32m231jR48CAZ"
"/ujGY+1zxXdVNMr89+Zz8bQGDRtKTKPFDBmq/8ZXAPLhy0Vf0q+//cp/9+3Xjzp16KC/DgS/"
"eFsxFS1YQC1btqDhBxwgBWxA+GvWrqHlS5d74my31q1pyKBBnvAPov3r1qyjpcuWUevWu9Hg"
"IUNE8+1A5fP3K7+nlatWBYr/xaJFAmswRzfW1H52J+KAsqOKlumM9CiK6X3u2nzq2nFluhAc"
"XkNqKXy36edfaNnSZTRk6FBatWolLV+2nNuA3/IhtxzxbUemJ/lcKMpVK1epswVuAr4hQ4bq"
"sSUWgHxYKWTPECHchg0dRrt37swCznGdQPArKipp5mszaW+hHJHDb0FRUaD4HTt2okFi8Y/2"
"oyBk48aNhAwNBYa/des2mj1nNg0V+KuEolm2bCnjByWf16xZKxR8EQ0dOoRKikuEPljKiihb"
"/NVrVtO0adPoiy+/JCuUJ3ge4fbvvXc/WrduXZX2qyz2Dr/kDWzOk4iqmdxQzmUlb+41An+r"
"z8IVFdS3b1/OPgzl1ahxQ1XzxVXZO3LDRzVPZC8uFp0LxZuXF6qCb8iQofpLucoHlkNCuSwS"
"K/cVK1coQet4FThyxV+1ciU1aNBAWAJLqVGjRkKY7s1COij5hhRKu+yyC61evVpYei2p/979"
"2UZxA8IvLCykhg0b0tp1a5lPO7XaiduvLclc8X/95RdhIbWmtm3bUAthqcKyhJLRllKm+B3a"
"d6TBgwZLV2FeHivFzmJh0qXL7vzvWqE0rZCVaIkxKAqNufFG6s8c/ZlSGvHP5b8d2negPffc"
"i/NgYcUigWUciatWErng48H+89VXdABMeGV4sluVNbhjJIAhQ/XdnZijfMCre/fubMkgWSxK"
"3Sds/+eIrzOoDxs2lPEXL17shRkE1X5kq1i6dAkNHjyYlRqyH2lLI1d8NgAgOcUzQEn+/PPP"
"cZdgAPiQ/78IRfbmm/+mFStWcBxhKBTKGh/KDVWe46Tdkq66r6uUZMJh58R6z2IdQ/ExYEut"
"7Tgpc/p+++237OI76qij6D//+Q9999131LVrV/ZZ6nT6ueIjcz7MSxCKop1wwgnsk9b4hgwZ"
"qt/uxGzlA2j9uvVsKcGaQSJyuOTyxErdjrmB4CPpLPCx56/xyY1bSrni47MffvhB3KMhWzRQ"
"aHYsGoj8BK1du1a0fTdW8lAArMSUAgoC/+efN9Fee+3Fch8KHoqSKDf+xDPdO9SiRXPeqoLx"
"UikMJTyL62u/UmIxBWqpzTdfEl/y3U/rRN8fuwsT77WZr7EiQ8Gyww8/XGlM19cJ2eP32qMX"
"uysLCwvokUce5WrSFlkJ+IYMGarPSix7+QCLCMrro48+4lIesJr+9Kc/eTUQg8Dv0qUL/fjj"
"D/TGG29wyZCRI4/hS4KQb/oE1IYN66lTx04szKHEkE/QCog/vXv35rpcaD8sJk9GB9R+lE2B"
"caH5f8ThR4j2R71SKdnge20Tyqpbt260cuUKevnll3kBcdppp3EexaqlWCwdUKjeqAqblo5A"
"sayEwBQdWVKQX0Cnjx1L27ZuZQ2MFUssGk0obJYLPkzgCEU5yfCYMWNop512omg0koBvyJCh"
"eqzEcpAPLMQKhAw6/TQhg7ZT6zatWRFEVULZIPBxCRQjAiRatWrFe0yxAPHxIaykZk2by3aL"
"l6tSNQWBn5ef7/EHe1Yso2HtaSWTI34TocTGjj2d+YOyKZDPkRz5s7OQ8yeddBJnrodCB//R"
"/jZt27Dc9/evKsWSmzJwhfZt1rwZv0eRs+RKz7nis49YPFyBGKxI0a8LpxkyZKj+U67ygdT+"
"CmQQ9qz8xXqDwsc+DdyKsGBwDwjQwPAFhfLyqDJc6VlIru9sVRDtDwv+6H2mZBkdFD5crcB2"
"lDWpnyFbfASjgNfsWhT/oX+BD1w//xPqiVkq7aJ2TnoJF103hTvU0sqUrSKYj5a3AUcJV+eK"
"z/5n8d52bcUcIpOtw5ChP4oSy10+ACPqRtlzUyfyR8jLmBtjfBlc5tQJftyp5tYZf+qi/Ywf"
"CZb/DpcCk/tlkP+wylLhy3NiMZsVEeq0cNij+Lfo44+pS9eu1LVLF96wO/jgQ9gsdZXSgnsP"
"VTnhL0bBMnwBP2VMRdWwptfnBJLwiz7+iDH9+Hg/YMAAeumllzhc33HkPWIKByapzRq+Kr4h"
"Q4bqsTsxhfyRfzuJssL3GjCgP82YMUOGuiPIqwb5UBM+vxe/W7x4CR173HEe/vjx43j/ff2G"
"DUrmxfGBkw7+Rx8XefJtypQnyQqFeC9/zerV4rMuLDvx2rhpo6zLqI4FZNP+a6+7zsebAeJ+"
"T7CSkeHtdlbt1/ip+K/b/8SUKRzu7jpuWvwvKvqYfwuMJwRPQpaMOly9ek0C/saNG1hRca2x"
"WuS/PCcGTaqibRCzjwNsw/bblw+dIS7/5ptvpsVLFlNhQQH7MPE9bjxmzCl8hgsFy9hHyhEl"
"4hWTB+FcfU4jCX/YvvslYG/bto1+//136t+/P11zzTUUjkQ4RJPPD7DCdFihVYdvyJChemyJ"
"pZA/fBhWzPVhw/bl81NaVmxnWbHFkxURDn8P1SgfasKHbAH++DPH8+IZUYLA32effTiqD/j5"
"YvHO55syxN93v2Fe2++48w76ftUqyhNyrX2HjhyIghgCRPP17NnL5xbNvP3jxo2jhQsX0rx5"
"82iLkKM33ngTPfroo/SPf9zH56w4MUQO/Pnxxx/pjDPOEIbMwRxYsWXLFpbX48ePpwLBm8LC"
"BjJaMA38YcP2Y4UFntwpeLJq1fcs69t3aM/BIZInS6hXr16snlyt2Gtof752ByYTMgrDPIy7"
"PR2KRCJSM9oOa3nLwmfi3xBCQuM+SkqMqKyCD5MwGpEXoNH4HXyd+w/fnx9k06ZNrOVxPw7P"
"1LVntP3qGm+iIUN/GEss5f62imCDrIhGPFlhs6wo5/RzWlbsLmSFE/YJhVrkjx8fBKsF9Prr"
"r/M9IIuuuuoq2rp1Kx/vYQvKiUc7posP5RoV/3Xq1ImV4nnnnUdz5swRSrGA2rZtS/2QHkt8"
"V1FZyYEK3j5/Bu1HxB4U2FNPPUUDBw7k6EAERGzZ8jvddtttrHx23mVnoYxj1crP2vgTQ7i/"
"z2BAkWT0ye23364qLsdUBqXa5b/uz2SeIECwbTvNk45q3zHKlldt8l9aYmqTz1ZuQlu5BSsF"
"Q/QmKZgD4IiKPFywYAHtscce1KNHd1onVixstsbiZl7CxmESPva1kEpEbwACFyb1m2+8yasK"
"nIjHgDnrrLOoT5/e1Kd3b3rm2WfFSikk25OEb8iQoXpsiaWQP1goy+2JqrJi08ZNHC6uZQXp"
"DB1pyh8/Pt6//fY7tPvuu3Pkc2lZGRVvL+YjQzfeeCMNGjRILLgjWeFHue1Sht496W6+9ppr"
"r2WPlo4OhMKsKC9n71M27YcCAx122GF8LyjdEvHq0aMHfz5nzmy2liDzs+VPRBgzMeW2xD0e"
"uP9+evDBBznIrqSkmMpKS1kvpIMPxRTnyST+/lrBk/zCfO/3FeUVVC54AgvwpJNGs/w/8qij"
"6PPPP1fZmpwEfLknZjteTiudGkS/Z8Wnzlz4rxs2bBhNnTqVv8c5AYSd6sga/6smfNCVV15J"
"7dq1oyGDh3ADjzvuOLFqiNDDDz/Mq6INGzZw45944gnavHmz0Px5VfANGTJUny2x6uUP742r"
"vQ8tK5AU1pMVQvhLj42T8pUOPlxkLVu19IS0Dt+GgoEy09F82eJDLjZu3Jgef+xxsVB/g558"
"6kl2UfoFfLbth9JiK1W0PywsJChDtF2Hn4NPiOrW3rRs2g/+IyADLlAcNJ50zyQO0+ejBuI+"
"4H+m/PF48vhjvCB56smnmCeujyc33XQTjRgxgjZu3Eg3TJxIN9xwA0cssiLz4avciX5N7Hga"
"WZuBnhJz5UYfrvczCoollKQhE0M4U+OD7rvvPt4Tw0Hp448/nk488UR6/Y3X6a233uJX+/bt"
"ZWJMcc1nn3/GHcK50YwlZsjQH8MSq0H+2LbjubJSyorXX5cCNMkCSEf+aHwiFTkHuYJDuup6"
"yB8snmWqpNzwYWV0696N/v73v7Ob7/vvv09ULFnid+jQga/ZtnWbDNjwtT/RO+hm3X7mv9Au"
"Bx54ICt8WKhQOKx0lCzOtP2ct0Poj27duifwBA5D6BH08yeffEKThLWGhQvcjoi/QN9D31Sx"
"xKre3PFe3mrJcbzvHGXmY8Xi7whvVVHjQ9gJ2PgdfKxY8YxTVZqRYgqbfdC88Euj4ThpjpPa"
"MlGkY5SYIUN/SCWWKH9snyKQsqKyiqzA6jzBqklT/mh8pMz7+uuvWdZwZnV1HfLBImdrFasp"
"Q3ztoYLFMnbsWBo5ciRdeOGF/ByhUChBdmaKP3ToUL7m/fffVzyS7V++fDn/feyxxyo3Xizr"
"9uNfbcjgGc4991w6++yzuS/0Xl6m7Xdd8vHkjASe5CmegJBpBAoN8h96oGPHjiq/opOkxGy7"
"2pduvKsyEeOzP190ET3//PMqyWMKJeb4NS7ViI2BU1lZwX5c7HuBEAUzatQoeu6557h0QGlp"
"KedLfPvtt9Xht1gCviFDhv4oe2J2SqEYlxWVUlY884wnK+DagospU/mjX2eOP5MFJSw7uA6B"
"9ayQRXBjIQoSlKAEMsD/5ptv2KJYtmwZu8rQ/uuvu47vB1cgPEtVlFgG+Hj+o48+ml1vyFsL"
"K+VVIfgnT55MF198MQt9PJNf2WTKH81/EJROsYpQhMLRrsRM2p/AE4EbTsETbFHtu+++9MAD"
"DzDPoJQPPfRQWr9+vbhnOAG/mj0xh/ehUB8GP0IUSqfOnWmA6FBofnyHRJXnn38+g8Ddhygh"
"vaqI2TX7RCX2UA8bm6r9Bwygfz70EG/yXXLJJWw+ogOAjXMDWC3hoVLhGzJk6I+0J5YoK4b4"
"5JAnK/75T09WYB9LZ3BIR/4kv7p378orfhAi/PYRr6+++ooeeeQR/ixb/M8//8yzGI855hh6"
"4/XXpRtOCGkoHVdF3CXHEmTSfiinu+66k/bff3+2ZqB0wRscP4AnC8EXeOG6bPkD/r/yyitc"
"HQDbOzNfe82zylLthdWEj/5M4MkbbwiehBRPbpbKUvFkwoQJvHBBKiuE899yyy2cNSVmJ2Zk"
"ScjYoZzDHF6PzoSJ3bJFS2rcpLFsXDTG/so8PtxssXsPkS8FhYUcTbJ16xaVMkUFZ1oupcIf"
"JLCR8R55yLC5pztDX1BcvJ1KS8ro4UcepmZNm7Fmhr8XGYzlpqut8m+ZOHtDhv4I7sRk+aPz"
"pg4aOIhlBYK8mjRpoqIUo17heFgFxcIiCIvVuevoastWjfLHj483YfE7LJhfmvESyzpd1Bey"
"BpF3HNghMOLVh9PDR2Tj4q8Xc9AF6pAh8GKrsDbC4Uoavv9wDlrgyD6OfswcX7e/rKyc/va3"
"v/G+UkFBofhcllGGBwtWK6eCEnI7W3zUaYOshgIBAQ8RnBGVw9bVv0sDf+CggYInQq8o2Q+Z"
"vnXbVooJ3gwXinjEiKPF85Ty8S4cDZj+4oucmxEJNaB/oGeiURWvYfmz2MdsmQTEcr3MwpZ4"
"6ArOQ7aFthdvTzHwZJRJnpXHN4BmREi+reP6mVQW6SR813K4I2GSbt+eiC39pGHBoBgPpnBF"
"WChJGcyByJtoOOJPzWkkgCFD9d0SSyF/5Oy2KCRkBeSKPrPllyyQP9FwlKIxeZ7U1XKzFvnj"
"x9fpjhwhmGFtlQoBmp+fx8IYqfQilVAwMdI1EjPBx4HcikqhAH+3vahqPmsrlGOEYhTbEmP5"
"ye23nazbH4P7TkUJImJQZupwWY7GIjE+tJxN+zU+wuchp2HRkeJ7WCgZNjycOGg6+C7rFfBE"
"Bm9wRCgiKlVEqL3FplDIYvnPwSUxh3NKyvNoNst/GDTSvelXYjhtjQY7JFPlsyJ3xcUVQolU"
"xrNdWfGsXpYqIuC1XJ9J1rmwOO2+eogq+MAOs5Lk62rAj4pOoPIkfErEN2TIUD1WYinlD38j"
"RIXFnheWQ2nIHyct+RPH1/LHZWUQZtdhcPgxqozZXCw4lXyrtO1A2x+1y9lSCZo/tq2MhwD4"
"b1uISoTsD8fluE/+28qy0/hhce9wNFyj/M/X1o9sS7yVWtlYZGWuxPgmmhF1j2/IkKF6rMTq"
"ufwx+P9bfOuEE06o9+bMzJkzjTozZKge0qhRo4w7xVBOxJbYc1On+vb1LK9ip06f71UgdX2+"
"Usv1fKZcSsDTqR4QfzZ+3Lg6xzdkyFD9pfoufwz+/xY/VGVEJcVMSH+rvKHru8j1Xe/6PnO9"
"v/xg/0V8Q4YM1V+q7/LH4P/X8VVgR/zn/N7xBZjgD8fyPuBgFO3UdB3ll0yMaeFrnPjHdY1v"
"yJCh+kv1Xf4Y/P8tfkhaazKVk4wi0Rk6XJXew5W1W/hAnuudxcDfCJFctOgL+Rvx3YoVK2nN"
"mrXkYarGZ4uP8wnywR1aKbBnzZpNRUULVEp+N6GEtyFDhuqp8RWAfFj0+SKaPXs2yyN5gDhY"
"+YPr8f27787nDBN++RNk+2fPnkPr1q0LHB+5FauTn7nir1m7hmbPmu21/4svviBLFbsMqv1r"
"Vq/h9qfqX5mxQwM58ZPjXBTNu4GsrInzBq5KJLlo0ed8chv5rEKhPCpaUETvzZ9Pv/32m3oA"
"ilf2zBAfBTORE+2LL78kS2D/+utvjD90yBDOcL+gqIjVsOOajB2GDNV7SywA+bB02VIhH4Zy"
"mrpl4j0XygxI/kDW4PovhFBdtXIVp1vizwLEX7lqJWcnGjZ0GO3euXOCfMsVH6VsZr42k/bu"
"14+PECTLz1zxO3XqTIMGD5KJ2rdvp8aNGzH/g8Lfvr2YZs+ZzfI/Vf+qBMCOOrys0uRDG9rx"
"lPxcYdlx4o0Qf+/ZZy/q27cva0Wkm8L7Tp078Xuu+6U0azb4Hdp3pMGDBkt/Z14eMx74bdq2"
"phYtW3AuLRSqM4aYIUP1n4KSD0Ls8AIa2TFk6qJg8EFr16yRSR8EPpI7BI2PZ4DlsWLlCmUo"
"xJOk54oPwY/8klD04A3XYONyJsHIZ7R3l1124SrWyKzSf+/+nncuCHwkeMZr7bq1zKedWu2U"
"wH/pTmQTzuES0lpJ6c8c/VmCued4WTSUvUjNmzeXZqLegHPl6exs8PFwTZs19QZ5p46daM89"
"96R33pnL5byHDB2q7mEsMUOG6r07MSD58Omnn8kEChzxpk8c5Y4PGORSPOCA4SR3aKwE+RME"
"fvfu3dmSwQIdOQoTwhdyxIf7E8bGsGFDGR8y1PWVRw6i/ci2sXTpEho8eDAfWI7G4nXgcsUv"
"Vlmd8AxQkj///HNC/+Zrcy8xNsRXJhvvofUcJ34SzXMDOF7ySi/jvU/ROXbcnMwU31/CAOXI"
"X3zxRerZsyedc845/D3yp3GKK0OGDNV7d2Iu8mHJksW8P48k4ciziGzuSBoelPyBcEbKq2nT"
"XuTvPvzwQ66qoS2NXPHXrl3DlhKsGRgDcMnlhSwh34LBb9GiBePvtltrD59cN7D2Q+lIa68h"
"J4bn9FGxaDwBcI74qCOGYpxQ8viMlZjap/QpsZgCtVQ0iEteEkfy3Y9UQIhngLnxgpmOv2yL"
"65mP2eJ7v0VQx8qVXunt2bNm0S677kr9hElsstgbMvRHUGK5yQdYMdOnT+e9KuzRH3744Z4s"
"CgIfVl6fPn2osKCQHnn0ETrooIO8TOtB4O8q5Nl8FU8AOfenP/0p0PZ369ZNyNAVnDEexYVH"
"jjxG5Z4MRj6jnRs2rGeL2OUEzTFhicW83+eKv9dee3H/ov2oK6b7NyGLPa9YVDCGF5VhyVtY"
"OsJEZTSOW3Eu+6GlVSTre6GAnEyVL7MM+1PxZ4q/80470UknncSZi3v37s0djUGEL5HV2CIy"
"0YmGDP0RlFiO8iEvP5/Gjj2dtm7dxu4mWB26/lcQ+DGuqRVjz8+YMWNoJ/FdTNXnCqr9p59+"
"Gm3bup1at2nNiiCqEuIGgQ+FAsUI/iAbPZIExwLEB39gJTVr2ly2W7xclWoqCPxQXp7HH8RE"
"JPevKsWSnUWDBiCQo5Kz3TucqRnvtZbUSiZbfGzmaWw0Pj8v37MAo75BZMiQofpLucoHlgNC"
"+PlLhSRWFs4dnyPt3CiXhUI2d39l4cDa37yZJ+/89bKCwMceGPgD2YnPdH20oPChaJBtPln2"
"B8kfvU+W3L8J9cQslXZROycTstJT8vlrS6b8t2VtLzfhgsSrs8UHMyzlLwV+RPxneVEp5pyY"
"IUN/DCUWjHyICiUjz0BZCUFfQeHjAsg7ZNWvC3zdfi3fgsaPubE65Q/w61L+V9e/8pxYTJag"
"hhvwsccepa5du/DG6Dfffse3BRg2NfEZXoccfDAXxgQQTEk0EiajDgu1HVWKWp+jUPjwJ0uM"
"LnTZZZfJMxKuOjcgfnfdddd595g4cQLXlfHjcz0ZNl9j0px0jCVmyFC9dyf65A+HXavtCK4Q"
"LN5jY7+LkAlPTJkij9awvIjR2LFjudLzBCEr8oQsQYQbFAxwUsmfVPiPKZkEfFQPnjBxIs2Y"
"Pp1FKs4qAZ9D6l3y5Fsm+GtW/+Thd/W9BgzoT0888YTcm1JBcDbvJ9nVys/q+AP5+eijj3nY"
"/BwTrqfp01+UUX9J+Jm0f8nir+m4447z2g/sg4X8xx7YGWdU5X9N8r+69gPvkksvZWuO+cFW"
"lqwnFlVyvqb2y3NiuLkKyDjvvAtowYIF/OXFF18kzLkwvx9z8hjBqEe50YuXLGVTD7V+5A3l"
"oHI5okS80Gjg6XMOCv+C8yU2/NazZs3iYnB8aE01aOHChXw9NvAeeughoSgLWEvXhm/IkKF6"
"bIn55A/ODKGgIx+GdaVsmTNnDnXq1IneEv82FnIHB8LghZk69Tneh8/PL6AGDQpZmNUkf5Lx"
"FywsEoJ+Bn366ae0efNmOuSQQ2jaCy9QYYMGvO9y6qmnsQLN420Mt1b5lqr97dt3oJ9++okO"
"PPBAOvPMMzky8Pfft9Dxxx9Pd955J61auZKTRaQjP6vjT1GReI4Z0/k5ftfPIRRwYWEDKiwo"
"kIknssBfs3a1UFpnsvXzww8/iHb/TvsMGEBr167lApwzZrzMz5Ut/9F+ZBABIdtHJBymPMvi"
"7/msHM6PpaFfpCVmS00pNWiM95uOOeYYbvy1114rmFHADUCABQYNV1TljcGo0rxOlX8lng7s"
"iGti/K5fv37UpUsXMSjf4n00WHRQbvsP31/6OPPzeXURjUbUyqRmfEOGDNVjS8wnfxz9slUW"
"BzHHFy5cQBMnTOTzTd98+y3vw9tqta6DBaBo8LYm+ZOMv2zpMpZFiN6LRqJiAX8eTRSWGCds"
"EC9cFxGfo7I0PEC1ybdU7eczU0KOxSMNHWEYVPBxANA333xD+VrRZIEPvGXL4s+BKsyJz+G3"
"kDLDn/LEFP7+9ddfp1YtW/H+1FVXX03jxo1TVbbVlk6W/Ef733rrLXrsscf4OhyjQpCLVGDy"
"unT0i7TE1CaZ9PdGOcyzadOm9ORTT/EDTJnyJIXyQ6x94cZD9VBsrsEl2KdPb+ojlBuidjZt"
"2uT5QBM2Vj3sGGPjPUzU999/n5UYfJywwobvP9y7HteBaWeddSbjI8QV0SpQpM88+4waZEaJ"
"GTJU7y0xn/yxtatIbR9gcbvffvvT0SOPZg/O62+84WW5wIJY5+WzVTCEbdvVyp9kfMgUeIRw"
"9vTZ555lmTZeWEujTxzNIe8I3e/RozutE5YH48cyw4+pz6AIbZWdIixkKAJDIFdBA4RlE0L2"
"DAjuLPETnmPqVKoor2Crb/To0eLeQt7GYlm1/62332bPG6IxS8tLWXEVl5TQjTfcSIMGDWIZ"
"LTNtZMf/LVu3Miai3I899lh67bXXWKFj1+vGG29kWX/eeefSlX/9Kz/ju/PelXLfdRLwlSXm"
"eDmtHHVQGdqwV69eNGHCBLr11lvp+1Xfs9/TVcxeunQpvfPOO/TJJ5/wOa7169fTl19+yeGb"
"esXhD7H3Y4NGjBjBjS4tLSErZDEWp0NRD41rZ8yYwfgwkxd98QXf4+mnn6Yrr7ySo4QMGTL0"
"R7DEEuWPTkeEF+QCZAUspdNOPY2mPvssz33LsrwoOP/51EQcp0Z8ZP75+9//TouXLKZrr7mW"
"kylgYY7zWsg88dxzz/HvsaCHXIsf7k0PX7/XgQ3Aa9O6Nd8HFti9997LAlxHWidjp4s/ZOgQ"
"fo4li5eI57iGevaKP4c/EjFTfGTKaNWqpVS+sEYjMiwfyh5n8vBvLvyfK/p2//334/ewTL/+"
"+mtaLqxKGDY33XQT/fnPf6bly5dzX4B+/e1X3sZK1i/x6MSklREahXj/s846i8EvuOACeuSR"
"RzgiEZoQWnLmzJn08MMP07/+9S/PDYgBBkvNH/7ux4cGBjYsuM6dO9Pzz/+Lzxj83//9n4o8"
"iTdw33335dPmwJSrLtcbvLAK8ZkhQ4bquSVWJUBLut6Ki0tYib388ssJ3855a47a1oh7YqQ1"
"YKc8dlMdPn6PQIVLLrmED9FiH36qsGTyxGr//vvv985RQahKa8lJ6f2pDj+5VhTccLgHZJdu"
"J5QBy8tYrNpo69rwkREj/hw/i3v8k58DVst9993nWUyZ8l/fQxsu8jqX5r47nzZs2OBlT8qW"
"/3PnzmUjZcKEid43sCgvv/xyDtdv0qQJZ2LBff7yl78wNnjlP94Qdyc6doLJ53gbaw5rcvhX"
"QYgehO8TigSW2KhRo6hjx460ceNGVkhaCbmOk3ROw48tmYm9rqOPPpo++ugjevttaYXpQaM1"
"O64H/sCBA2nYsGE0cuRI/k2Fcmfq6w0ZMlS/lViiy0nufcybN4+uuuoq3qaAkkG6Ibi3IDO0"
"JyYxa5A6X2Xb1cofP/4tt9zKQRFQlrC24MKC9weyTa/4/YtqT4aliW/bjve3biMUSqlQXBDO"
"W7Zs4X+1LMsWP/4cxeI5miU8BxL+xvcQM8PX1tHWrVt9z+/QZ59+qgJq8hP6IBP+r127jjp0"
"6MjeNWRZQd9CEcPNKoNRXOYJAnqgzPBsCL7Bv1G1CEhwJybewPY0JH6AhuGQ8U2CMdhYxaoE"
"L3wPBXPppZeymYwoHnSKTvyrGZyMj8gW1MtB5x1xxJE8IBcsKOJonZjWroohWIXBGsMDYhDf"
"c8893OHQxrzRag47GzJU/5WYbVd5QT68+upMdreFK8Mc1QdhCsEKQQcZEAqFEgIm4gtlu1r5"
"439hzX311VfTs88+w5FxW8U9X3nlFdp///29BXlKJZYmvl9pkE+JwfrC8+Bf7e5LNCIyw48/"
"x7OMv03wKfk5ssFHZCL64cQTT2S5i+MNuMcGYbT079/fU2DZ8B+WYqdOHdmbVry9mPsW+2zI"
"hL9g4UIV8OcqgyfRhSn31Zzq98SgkGDyQtHgLAP8qqi3iVyFcClqlx6UC5Rcu3btWOMjivGW"
"W26RYfIqBDbZJwrsiy++mLFheeEFTYvVFSJUDjv0UL5+9EknsfUHq+ull16iNm3acGJJ3Avu"
"y5gvOaQhQ4bqN1XdM3E4TdK3337DiXanvTiNlRY8QZATEKzY6MeeCfbLsZ2B77RlELNr25OJ"
"fwcMLJYh3wbusw+7ybC/9N5779HZZ5/N12C7A9agDiZLFx8vyDrsWX2i2omF/y9cgzFU7W8y"
"wZfXuN5zQKbuM3Cg9xy8lxWNZoWPwBZsGYHgDQN/kM0f20ogbDXBmMmU/zB8gIs9QcRchMMV"
"9Pzzz/PnIATwoX8nT57MRg/kP8rUaMWWjJ+QsQM09oyxdJFgSIuWLXkzE5E0sLDADJzzata8"
"OX/Wo3sPoTEXUIvmLfh30VhUMPJC1pAwz2Ulz7g5CXwcTrxQXNOyhcTGwJz7zlxq1LiR5zNG"
"JuRGjRqIlVGUPvv8M+70b7/9lr//4IMP6JprruEQUs7ZFYsYCWDI0B/Anejf5rHEe1QHRlRc"
"k8ZNKBwJs+K6/rrr6fbb76CWLeU+OfZNcJAW57og3GDd6G0QWdXerRYff2Lh3axpM7rwwgtZ"
"qWhChPaA/gO4/hbkG1yLkFVbt25RwSSUFj4W++3atuOAN+QshFsMVFZWynkAI24EAQbyp5bK"
"Y6H+SBcfb6655lpOKfXnC//MQXKaIJPhuuSIcIGRKT54iaS+cE2i7ZYqpAmlWFZaxgYF3LC6"
"DFe6/P+nMJKat2ghfyeeH3XasFg59dRTRd+2EvxuwHtwMSfGXkD0TVl5GScvxn4itrv8+DIB"
"MNKo6NbHXCoVSioSjahDeDaHhSLIoxwBFdEIm6+oFxMKWxSpjDDjZH4umHYWMy/GZziUJlb4"
"6K7ysnLGAjbMRLyKS0ukScjnDUpVGKVLeflS88ICA8FqmzRpEmt8YBl3oiFDfwBLzCd/tAhG"
"aDhcTHAhIXw7yoJYLIxLEdRVyUkSdEScFtx8BEgsbuMV391q8UEVypWHTBH5QuboM0p8zCgS"
"5YxBiMiDBQBZg/NiXP7JA6kZ39XKImKxi09WhJYHjyvVcSXLVXJX1SizdFamDPAr1bGlkrwS"
"td0jCwZDDkM+25xFPnN8HTYfiUFplarzbJI/leEI/x5WFlx8mfAf4XglJcXsSo3/TlqL3B++"
"BYXf5Qw9ZMdslboqji+VGELqwRBx75jQmrFoBZVzw1xmsn5u25VKR7McvwkLJmnV7eXC0r9T"
"mlLju6L1FbEKPsegU/L78V0rnnULn0Ir41R+y1Zi5ZVf4J1HKBUrGY7wMe5EQ4bqvxLzyR+d"
"ozDsRFloJcsHzHuxDvbkjyeZ05A/fnz+V9zDjsaqlT/4TWVFuCq+myY+OXxd2A4LZRJOiS/N"
"uji+kwU+Mlfwc6TEp5zwkZUJQXjVtT8aEQqyPDP+I9VUJArFWpbYv0KRcdg+Zda/qp6Yo66N"
"t9JVtqeuYlpdJ1d/E82I7PHxP7guY3aUlRhrcT48GKaYWCE5ZBIAGzJU75XY/6fyx+DXD3zr"
"hBNOMJrAkCFDhgzVS2JL7LmpU337blIduuR66fP135br88Vabtzn6+r3Pn1oyevGjxtn8A2+"
"wTf4Bt/g1wl+1R20xD0zGaWibuj6LnJ917u+z1zvLz+YwTf4Bt/gG3yDHzy+CuxwfZusLvbz"
"fFEqDnYDvQ8cb7/K4lpg0i+ZGDPD1zjxjw2+wTf4Bt/gG/y6wM+X1prji0ixtHpM0IjxMwYy"
"9T7+/WLRIho8ZDBHn3y/8ntauWoVtW69m/hsiLi/7d0lG/z589/l8w39+vWlDh070ro162jJ"
"0qV1hg/OoP04o9Cpc2d1PCA4/FUrV9FK8cIZl+EHHCA7SK9GAsD/YtEXnL5lt93qjj/4+r33"
"5tPw4cOpIZ/NCb79oL79+lGnDh0Cxd++dTsVcS274PmPiblsyTJvUu3WujUNGTTIm7z1Yfzr"
"8RkE/vbiYj7nhc8gH3C2dO3qtbR02bI6ww9y/qbCX7ViFeMHMX5S4Qc5f6vjT1Dzt6b2BzF/"
"U+HXNH9lxg5kH07KQsxFy/Tnrqpd48pMGavXrOaia198+SVXZ0YerKIFRTR06BAqKS6hZWKy"
"ERc3U5U9M8RHgTQk/sXp81mzZlNJSSnNnjNb/N2PT8AvW7ZUFtMMCB+lEtD+9+bP5wwlKgo1"
"MPwNGzZybrOhYnBGwhFaIN6TOjgYFD6ypgwdMpRWiYlWF/zBAPzii0Us7OR5FytQfLQbmRGG"
"DR1GuwshFCR/MH5mvjaTxw8Ed9D8b9umLU828B8HPhs3bsT8Dwp/8+bfefxj/NRF//74409y"
"fAY0f4EFYdOmbVt65ZVXBc8jNPutOYHN32R8YAU5f5Pxf/v1NynfApq/qfCDnL+p+OMooyOI"
"+ZsKf2WA8zfV+OH52y/1/FUZO5y4NtTbaa5876pT4ZaKccRnHdp3pMGDBtN8odVR2+c3oYGR"
"Fqpt2zacJmTN2jW01159lXGYOT5OcqPIG5JXgtDBSDDcpcvurO3XrllLfYHvWIHgI6EkJjTS"
"aHEhOdEpMdf2VtK54uOYAPDbgD/r1nL2AS6zHrMDxRfN5gnMn1uWt1IJgj+//PwzC2hcw+Xa"
"A8bHwUeklkHNqF123UUetHSCGT8oFYSsCxhHwMd3aL9jB9O/OLuE8f/5558zfv+9+8vzlE4w"
"+MiqjvavW7+WJ/FOrXYKlP/oW6T2aSuERlDzt3On3bl0RiPRbpTX2D3g+evHB3/wPEHOXz8+"
"MlTI+ds6sPmbCj/I+ZvMnzWrV3NmjKDmbzJ+OOD568f/4fvv5fxdlnr+siXmqjpftq6XY7ve"
"Z47+jP+VnyPBY9NmTT0vJZJ0IkHvm2/+m1asWMGNlKeulTslQ3zkZURC4SeffJL69e3HD2Ip"
"pjuq1hm0f1D4YAzStnAGAL2BqBIZB4G/1557Mo+Q2wxJlFHHyNVmdoD4n376GWchkBE/VqD8"
"wQA94IDhXoRRkO0HPmrXwRKAMvv4448Tt29zxEcZDYwfVEIAPvrAjfs0Amk/roGSRO0jrubr"
"la7IHT9eosPieyEhdpD9O1SsnuX8fTOw+QtvzYoV31EDNXdJzamg5m8yftDz14+P3K5y/s4N"
"bP6mwg9y/ibzB+65IOdvMj5qpMESC2r++vGxcJPzd2jK+Rt3J6JcAFJHsYlns7lnA9SWaT64"
"kJkrS0LrjMU6CS8m1V577cUPgRUpXqxTHZeywQfDITSRBPSAAw9gzYwUNLhfZUUl+41lRddg"
"8LFq1vXKXMfHYNsJBB/mO5JkNmjQgGvjNBcTzo5FZQqbAPCRlPOzzz7jmmwQSt999x37jINq"
"/3/+8x+2wqZNe5HxPvzwQ3kYMSD+//jjj5wLb+edd+G+xqDNC1mBjh/wHuMG7zndjesGOn7A"
"c9wDY5+zkov+DYr/P/30E7cd8wup11iJBTj+N27cwEI0qPmLXHvdunWjE04YxcoRJPPqUSDz"
"Nxkf/PAKZAYwf5PxofCDnL/J+KjkEeT8TcaHUgly/ibjQz6AN7vsEsz8TTV+5PxtnXL+qowd"
"qi4Xp/LQGtRKigmJb8DhDy9DsWgMVkHzlT8aD3DE4Udw3i6d2zBTfFQ9xYpz2bJlvLo99NBD"
"ufEojofOOO2007zS3EHgH3zwwZwnzV+h1PZnYc4RH64aMB7ujtmzZglze1fOmh0U/n777cdC"
"CbyBu+bwww/3niUI/EMOOYSzSiMZ5yOPPkIHHXSQcke4gbX/3Xff5bZj/EC4Btl+jB8Ihjfe"
"eIOTiI4ceQxfHxT/MX7ghkOyVFflf4siL56Ov8oRHyU1lixZwu3HpNb9G1T7kaEc+MAOYv52"
"69qN3nrrLXYBQelCOULRvPLyK7Rt+7ac528yPpQi2s0uqgDmbzI+FtBcQqW4JJD5m4yPEiTI"
"4h7U/E3GRyAH5hgIGehznb/J+HvssQe3X4+fXOdvdeOnuvkrlZgtYx5dmRpZ5fOSt7B0hJX2"
"XSord+edduKU+Uj42KRpUxo79nTR2dtYYEejEYpEo17RykzxR44YKX23qlwBEk8eeeQR9Pvm"
"LbyvhM+iAeIjoz7afOABB7KbFMmLHV8Bz1zxdxYrlPbt23FBUfwW/LLIV4snR3wsIsaNO4MD"
"ACCcsGrRNYqCwC8Q/EHSTyRDHTNmDGcXj0WjgeE3Fe0/44yx3L+t27RmRRCtg/ED/iCbOPo7"
"FvD42XffYdS4URPZblj1TjwpWs78EeMF/Qv+tGjZIvD+3XnnnQX/Bf7vvwcyf7G/07NXT/49"
"FAz2DI844nDa/NvvgczfZPwo8yLGhRqDmL/J+CBYGexiDWD+JuPjivHjxwkjYHMg87cKf5jX"
"UXbjBTF/q7RfXIMKJJtF+4OYv9WNH/An1fxNCOzIlKApYWEwM8TNYS0hgaPORuwmbaymSyjN"
"gkz1OptxlNPvC2HdvJlMEKmqfjpJG4dZ44Mh4hmw4Ynn0avcINuP0gMhK+TtDUR9gyhXfC5P"
"ICxi8B8kC8fZgeGj/VIwOOz2QyCJv0R4IP2L9reQrgKvQmxQ/avGjy4ZoQsRBjl+kAkdpUGS"
"x06Q/YvxXxf96x8/Qcxf/B6CuHHjxrIMiC33B4Oav6nwMT6Dmr+p8KEc80J5gczfVPjaoxVE"
"/1bHH1ioQczfatsv+jeI+Vvt+FH7nsnzN6GemKXSLuo4koSszVXOX1sMwgEXjjyUhpW65UW9"
"+CdxZvjMdJR6USUWOJhEpympY3zfqYVA8XV2aH/745MsWP5wrI/r1Al/9Hd1hf/fGD91wR95"
"NtOts/Hz3+rfIPgPSsWfqButU/yg5m91+BZZgczfmtofRP/WhB/E/K2t/XXZv6n449UT8zyV"
"lj8liEWHHXYInwPThPNh8KsWcay+pHXr1oqVSUxqXNd3ck2fwq4G//EnptA990zi9zi3AncA"
"VoN33H47rxxs258zyyI37k5NC3/Bwk/osssuZV8zNkz3P2A4+1SDwh84aJAMO09BKLjXXKxM"
"rr32OlqzZjVbMZnyB23r0aO7h4lDnNikfeH55+m6669P4L+TBf+3bS+mG26YSHPmzOG/EboK"
"i3Hk0UfTmJNPFgMJUUOUgj9OSvzxZ55JCxYs4PfXiec/7/wLxACMyUEtXoccdiitW7uWv7/r"
"rrvolFNO5iqt5DoZ8797jx7VruTkvc+Xq7WU7U+PP0uXLRf8mUBLly7jvzE+sck/7YUXqF37"
"9mLM21mPH93+kSNHcnFBBAlgsxv7d34eIWoLz4P78j6SrmdVCz7G5cQbbqjStyNGjKBTxoxR"
"Jd6zG//rhDw4RFVhTyYcSG3ftq203B3Kmj84TzZh4kTfeLqOFi9ZTKeedhrtv+++LBg5mi2H"
"+Qv86dOne32LvSPw+0IxdoLA1zkADz30MA6ceVjITQ6IU7UXc+FPsvxE+zt26sQBdqeKuVtz"
"+52s59dFF11Ef//b39iFmy1/ZkyfQddPmOBhou0o6Hna6aclyM8LLjg/LfnA/gSEPtp6Q9R2"
"OWqED6O5Nr3//gd0vRCYCAPFxMCmIzoe57ZuuukmPjNRUFAoVyYcsWjz+Qk+xKaia1LhT7rn"
"Hu6Af/zjH1w5+rXXXuOBC1O3QcNG7OrAtQ6b1Q5Pukzwt4p2QYE9/vjjHHBy40030pzZs9mN"
"UtigYSD4ULwISMDGL/hz8803s5K88cYbaePGjXTWWedwmXDeC8uQP5r/iNy7R/Cqf//+tGTx"
"YmpYWCgm8uksnLBBC/4XFjbICv/MM8fz5j6eAfshZwolhIOuqCXXgE/0Wxnx57mpz3HRUvj1"
"57z1FjVq3FAeqhS/W7J0CRUrhY/K3+eee64Y0HmyRlwW/P/xpx95HwdBFRiXGEObN2+m8ePH"
"U74Yj9m034+/eu0a5g9CwX/44Qfmz4ABAziAA3WuMI4ghLLF1+2fNWsWh7pzAVgB+OH77wuF"
"szc98MADXMF8nLgG8wLFDjkoPU18LChS9W1FeTlXQsaKNtvxv3XbdhbKqFiMsQ++Y3zi1ad3"
"bwrl5SuLLzv81WvW0vEnnMBRvTj8i/ajhiAOaVeKsYk9zlzwwR/gL1y4kObNm8f4qCz86KOP"
"UrmQPwWFufHHP3+LiqQSRtsjiNrjQ+SuqoCcPX7RwgU0Y8Z0+vTTT5n/CL7C4qqBkA9BtF+P"
"z+OPP96bXzeIRREMmHliTOUy/secfAqfRQRNnjyZj3YccughdPfdd/N+2OLFS+iqq65iuZmO"
"fFCBHakqJEuVF3PjG4zQfPAFnyw0PYTVEUccwdkWUFkUlpj2UfpC+CkVPiblE088QROENkbI"
"KjaSe/boSY899hhdc801XJlU+kZttRkoNa8+b1Ibvj4gDTrssMMYZ8jgIdxmCH9Z+dTNCb9p"
"0yb0wQcfsN9W++F1brALLriQVxxgPPiDVZEdS58/CfwX/yEo4eqrr6avv/5aWGY9uA9wb6xg"
"uGCdEKqZ8B/08ssvsZB79dVXaeDAfcQzhOmkMScxBoSHPidkq03ZdPgTU3sdxx57LD333HO0"
"aeMmdYbKpoULFrLV8YKYaPlCYJeVRbnfY7pSa4b8j0Xj0Xm4OCzaH46G6XZhZWPw22wJ2Bm1"
"309TxPgEvf7665w9oKKikvsAiwZ9qJbPvmSJr9t/+eWX06233sp92bVbV7a2+vbdiw488EBZ"
"VRd187zMCup+teAjijfetwN5fI45aQyPw9KSUtX27Md/nz696d//fpMaNWrM+zcPPfQQj009"
"56TLKqb2jzLHnzIlznssFCsrK+jqq67mNsuxmacyP2TX/mT+hMOVHKSGfa8FQulgfFZW5iYf"
"9PxFlB3k2tFHH00vvvginX322eSGI97YzRZ/2dJlbF0jFB3zCAse7EvxYW8VsJNL+/X41Gcg"
"cTQC5yxBWJhjb40LE2cx/jFvohF5gXQ/OvT+e++LMfVvjnLHZxiz2A9LRz6E9KCLv2LqX4cn"
"lI4y4c1MMaHQ2aeccgqHbGJAbdu2lUtXI5qJXSJqEy5hYzIJ/+233+bP0QHAxsp8e8l2jjx5"
"dupUfgCcnYCSxITB6u6ZZ5/lwAieyLXg41+EhIMQ7jl58oNUXlnOK+mbb7nFOzA3evRoxj/q"
"yCNpxcqV3tGBdPDBHyhvrFIg2BxXbmYCu1TwBc/Yvn17zlIA9xCfYE+TP37+R3jVX0BHjzia"
"OxifITIH7lycK6moKKdysbrOhP/4d+HCT6RLlIVcmE/zI4T42OOOo3POPoeuvPJK6t69u5gc"
"59KVf/0r8/Pdee/KCaKeNRlfR0F16NCBV+UIiYUFgYm08JOF8qS9CiTAswAfBxiffeYZxu8t"
"+hlHBVBuPmHjOUX7Idz15i7S0tz3wH300IMPsSVfIpQMQuqxutb9y7hqHzcd/rz99jtsXSOS"
"q6ysXPJH9OsNwspGSDSs+1GjRnnjc+Zrr2U0PnX7MZew2j3//PNZUOhxgnE0d+5c6tq1C/MJ"
"C790+xcWRrxv5dEOzK/jjzuezhaLRqx+gQlruKAgn47kedaHnnn6mRr7199+KHV4I3CvO++8"
"k66fcD2Pd4x7tBkC7xnuV8mfRZwLLz3+AwMr8laC9xjbkA/FpcX0l7/8hUYL+YNAndWrV3vz"
"F/gQ4jgCwhZOmvzBAlfyR+CXFNPBBx3MCwqklsK1cGVifAIfUX2bNm3y9njSmb9bhJUK3sNq"
"xcIO3iZYkZb6DRSaHp9oPwJH0mm/lm+w4mEETJ36HJULOXDWmWfRiYInsPiw7TB06FDGHyN4"
"Js8WUtryQY9PvIcyKS0vpWeFDMYchrfj73//Ox9wzkQ+aHzgQubo7959dz7dcecdvMDFYe/t"
"wtJ/6qmneIz27r2HJx8euP8BKU94cR3HD+kQSJ3TSmvwhPeiURDU6PT169eLldIUBtPaUkei"
"pHqlwteEQYoqzWFUahYPhsEDIVRWWsYuS/iowfyJEyfSSzNmsNUTX2VUj482N2nShB4UK0TQ"
"HXfcQb169qITTzyRV4xYtWNCYPWLgQkN/6WYZNIF5aaFr8OEsYqLiJWQd0bFlQxG5oapQiFL"
"q60ph4UmY9eGr9/jzA6EAqwb8L1ULBowOeDSRRvwyoT/wMTvuQ9ateSoOigWHJdgJSzw4RL9"
"85//TMuXL+dnASENDCJStVWQCl+v8I855hheScPq/ebbb3hFrVdSuB5nn7CCxyIAFvK9993H"
"ggurY50OqTb+YDGGxQ7CcO+ZdA81KGwgw2/FWMKYwf4P3Lp4D1dIQ5VdIB3+oF0txaKKV6GC"
"PzJ0PsaWB5Q9BDewMH4w4SZcfz27ddA/6favyxvYUbr9jtuZb9dddx27g/TkRuYC9HlNYygV"
"vu5btB/jU88vKEn07Znjz2TeoK2YJ7Dq0T8NGjZg3vt5lAofggj8gCK/4orLGeuKK67gsYN9"
"YiwmdL/ep/p1ZlK/1oSP3+o2wAr7afVPtGefPVmodRQLJPAJbkAsKvj82SuvsMKBW1C6udLj"
"D0jz58gjjmShzOeqDhjOfPqrEM4QrOhjuOuefvpp7oOaxr+/f+e+844Y5/vx+6OOOoplD1Jw"
"ge/I3gMrB1bNvffey59lIt+goKBIlixZzN4ryLfLLr2M+wRnzWDh19b2dMYnzn/h2AU8ZXBd"
"HicWuRgz8HhkIx/8+NraBhYsYyzaME4xx7BAfEjJb2SRwdbJpp83pRyf8ejEKqawLwW++hNC"
"GQMFygyT+LLLLquimFJRtfiudFdhhalPp59/znlCST7Jgx/3gzWGg5hYFWOSlZWXxd2bNeLb"
"NHCffZhJGBxQZLAMzhSrCAgGrGzR0TrhJAYPFLLfAqi1/QnH9eKpbqD00RnapcL7GZZMWJmK"
"V+ng/+mwP9ENE2/gSYAcfbDCgCVdidEs+O967gwIZ519oFisgm6//Q66//77WXBi8YLVHpQ+"
"+IKVcTKP/Ph8Ol+80D6sapcv/4Y++/Qzdqfgt/qAPH6PfgFhsOKcyWIxybHnhMkmffp2reMH"
"bje4ITBewH+4gmA1ffLJJ/yCINWESQZhzQdj0+C/PgvkH5/vzn2bEy7DWoA7HOMG+8RYULz9"
"ztu896THUbrjH8oXPMBqHav2kHJ3+91yGEPaQk0eQzXhR319u614m+jb20TfPsDhyhDUwMV9"
"wBc8i7Sc3Wr714//jBCMsGKwN44xBKUCpdO4SWK/fq37tYHo13Kr1vmlFzx6P6Rd23b07bff"
"8jYGrNZLLrmEBR3Ot8FCwkIGBHy9iEg84pCIr4+iyFB/GSyD/kSADQ6CYyEFlyOUHRZjmiCD"
"Gqo0SP45Vx1/IJQxBidMmOh9A+sJcgfPBxkE2QOvFpSSDIZJT/7gOlhE4AUOGYPXkJcYO5CZ"
"KdveqCEr7GR5UdP4GTt2LGNjHGKxA08cZAKeIRv5kCjfiD02GD+YN3DXY+8Qyh19AmUJgvGB"
"Z0G7/SH8ie5Ex04y+RzfS0a5YGB17NiRVyuIHMGDvffee97Kx/97x04yV5PwBw8ewp8jXYmr"
"cmbhcwz0Fi1acpkArILwQNjsQ2BD3H/q1oqPdiP7MZQhmIpNyUsvvdSL1EJCWH54MWkxGfA9"
"XpjUbNWkge/nj207iUJcCR89WBxfqq50+JMKH5MHigEC+zOxIoIVCXzpl7Yz4j/whg3bl797"
"//33ZU5K1b55897lCCfdr1iZYjBhUsDSwL9R3z2T8bUAQTJZCGQIGLjm9B6PFh5+AY2JAgs8"
"EvHvFbi18kdbvnB9wDUG9wzcFLbCnTlzJk8yTHKsTjF+uX2OUyt/9MoZgQt6fOKF/HbgPcYi"
"eIQ+gOWgnxufWT4XSjrth6KBkPnb3/7Gq1KsbjX/U42h2vo3sW/j8wvWCxL7FuTnJ1h0cK2z"
"S1yvlNMYP3PnzuPVPeZnp06dee5gruFZauvX2vCPPPJIxftt3j6gf2GAfyF/oHRgBSJlk18+"
"1Na/UBggCGXNH33ui5WfLxsK+h8Ld1h8WDymyx9EdHfo0JE9Vxh7+D2UDhbVhQUFPL4wn9Hn"
"GJennnqqpxzTwb/llls5aATzsWnTZuw5Qbom7EtCflbX9kzkT3x+RXiBAosa3jHwXnsFMpUP"
"fnwQFn+Yv7fccgvrGEQ/Qtb5xz7kEcYRngVzLaLPjvndiclCMPnlqg4FKAbrqaecwoMH5iwa"
"LiP9/ILM9gRwKnwEJ6ADEc0HxiMT/gbR2TCLsdoCHlZGp59+Ok9uWE6YZPGJVzO+/nzy5AfY"
"GsDfiIx7cfp0XoVhxQttj84A3ksvvcSBJnogp4OfrDR0hycoK9+kS/w8c3zsgyH9Csz7dYJX"
"2O/A4EqpxNLAh1sAAxBuoJXCXEcm6k+FMIDf+/TTTvMEgjyzodxoYiDLg5ixavExyOAa0C4U"
"tBf7glg1e0rMxw+2kMQkx7jSe6/ye7dW/uj2wSWN/sUeBNqISQBXHCL8sHKDUkDoOgSKFIa1"
"8wcCB2MOq0DsO8KSxn4t3JMDxOoR4x8rXzwHxipW1Vgtpjs+gY1VOhZWwEb/ni6EPoQElIoW"
"EvHUPT4lVgu+v29XqL7Fwgd9e5rqW1hi8HBgUYTVNYSPt0isBR9tx9yBdY19R0Q8rvjuO8bW"
"C8RU/ep3J9WED97j+tGjT2TFiEXBU08+6Y0rCDG4D8ErRNA9+OCDjIOFaDrtB3+wwLr88jh/"
"Fgo8bGFooY19TwhVeCTQBgRooF0QpjFOyVVz/2JsdOrUkWVK8fZiVijAxF7egoUL2QWNYxPY"
"u4JLEWMTiy3pKqt9/OC6q6++ivsU/Ngm8OFWhZv+wIMOqrbtcushPfkDXqCveU9MzCu4EzFm"
"4NproBRlpvIhWUbr/kQf3yfai7GPduutHf174KL9eJ5k/lezJxZ/wTc5+cHJbCXBNwqNfv4F"
"F7CVhAfEA2EiIlpFD9SYXbPPFQ+NMzCw6LAS2avvXnTGuHE8CRAyjSAFuAnwPYQRlBuwMdmw"
"QnXJqsXnKj8/5ZRT+aGhyfcRQh9+eaze4Ff95z//yaGdUKhwM8Lt0UCFHtfWfv8Lm7VDhg7h"
"QYhVNCwOpGlCklWsKkBQPvBNa393JvjyJc+AHXTQwXy9zPUY8oJukq9PBx+CfsaMl3gyjzxm"
"JPUfMIAefeQR5gv2KnGsAi463e8IjNCupurwYe1CoGDSwD0AQY+JCpcB+hZ7UyAUjYSVpPmD"
"DPYIM8ckxKQ+RaxK2aLx7aEltx+raX09AgoQWIEQXnavCp7A1QfBgbZjAmOlB8HNK7yYXSt/"
"sP+CNuoACYyfr778kkOMMbXgPtGW6m233cbudayooTQj0Vit+Ag4wpiBu/OWW2/hDX/sCYPv"
"2p0GoXHhhRdWGUO19a/s2xnct1Cs/Qf0p0cefVT07cMcqIKAJAhy3AcBJVAEWGWDRxDklgow"
"qA4fQTloO+Y9kgXvLhYpI0aOZJcfhPQFQj6k6tdTVb/WNn933XVXduehfRD8+wzch94TVuUL"
"L0zzMkDAWkO0X7t27fg5YR1jwQGlSVaoRnyMEZx3HT58f48/dwmL8vnn/yWj8cSzw9WNvSoE"
"waBfcRQI/JHZL2rmP+YBxg5+j3EYDlfwYg6fgyDHsI8L1yXGD8YvR6d27SoNAl/drZrkG/ak"
"sLfWb+9+PD6hDGFYYAGERUaqtqcrH/T8gpxHG5ErEjISEcboU3jKgJuJfPDLTG0NI5T+9LGn"
"0+fi9ycKXQOCDEIghx772HPjYyh5MmNKMr4lVlLulVddmbANY7n6YJolTN9CztcGAQAQRGqV"
"l5cxo/AZrCicK0Jiz3Jepdjx5I4C6B//uJdS4YfURiYwvA1r0ThEp5SVlaAYBLVo1UKYxrLe"
"DiJSEH0EpbRt23ZeudaEnycmC6wuvVnqqhBNqdXLOaINPuImjZvw5/AVI8oSzwcroLb2a/4g"
"oghpfDDhcC+sEEpLi8Xqq4TyCvK49hOECtq9desW8W9F/JxeGvi67g7vi4h7IW8bQr4RKbpl"
"2xaKVIblt5a/OqqVFj4WHnAFwLet3VdyVSX4Uyn407ghtWzeggUs9iJxBg7tr44/wMNYad5M"
"7jmwfxyu0EYNfQK2kbguj3GwwsOCAosHCH+ECjfkM4J5wjLYLqy6bUI53JWy/TjrBIGMtutU"
"PVjxlrFPPibGini2Zk2oWZOmXPtJP1dpaRm7vGrjD85IoF3Nmjbz9nh0uqGyslLmT4NGDfhZ"
"mXeuwzWVtos2wKVZGz5KTOj2a5ckAkZc3hNqJsZ9I+Y5rNIWQrCCh+Vl0jWOyEA5iGoe/8BG"
"+3EGTfct+F5eXsp59BBS3lKM2zxWLC5bJHDtYH5hLtiCj6nw80X/oNou2g+ZoN2FcgyBR2Eq"
"yC+kwoaFHEyC79HPCPIBf9KZvxhzyfMXixQsUKAUopEYz7umYvzaykLF/XEvLK5x39rkD8Y+"
"+JNfkO/JH7i+sNIvLSkj27W5f3nv1pLpyzB+eA5wqr3U+IX5BXywnNOcOS7v0cKKgBxo2bIV"
"V5/GggUyBzy3vPRfYeYP+re28YPxD3zIRysU3zvH2Ib8xL94viai7fgpgs8gnyHfIKPSwefx"
"KeaPPlrFGWlYhka5jdh/w/xKVz74x08j0S4sGBo3asyBa2yxqzy8TZo0VuWMonytTukGbwsK"
"3Ca338vY4arWJ2YWxl8RKoaZiE15pQRgLkplU+aZvxj8WIGqFAkJG3ip8DFYiktkKDEsF3kI"
"0FH7PGFeTWGjU1p40ofKhegQeh6Lqs3C6vGdqCMUqxw8+F2+GiwcBYloLVaYFSwYMLmgfHGI"
"1cYzpNF+zR9eDVTKQ7U6ewfaVymwQjGLNtubvc1zrIC9jAtp4usD+pZaGZeWlvAkBpvxHK7t"
"aqmrrqO08SvDSrAJBVAIy8fHH6wGwf+IENaYJBxqC/7ocxsp8aMc3s4CBBOKC0OKfisJcfst"
"DhyQbitbuZUQiYrJ4KgienlWCd9PR11W134oPAgrXnmrsygRFeKP8YL+jW0XAq9CCIr8kNxX"
"Uf1bffsT+VNeIcdjiVBaBRzaK10niGgDfiQWYf5ACPIKH20WwikdfPB4q3J/Onx8JcKTFjjb"
"tiGPZynzByMAfMQY4iMX2POzY7XPr4gtxr90w0DIhHgFK49scDJYhFsL4YpI3VCexYIH8xvj"
"B+2IKj6mwo/qcSiw8pQA9ue943YL4YPvdMVePCf6PRqJpjV/7bBNW7baPH/1PmNM7aOyO0y0"
"tzJSyfMXv5PnlSyWPxDYteIjArU4Ln9CPnw9fjiKLubwoh0LK/QD+jdWC/8xaktKimXJEHWk"
"JKYiiIEvrS0Z5YljGQhGcl15HZSb4zq19i/G4FbBHw4aEy/IN//4tBUfwJ9QnpzXmci35Pnl"
"D17Dd/BmoN0VZRUZyIf4+LGE7P19ixjroW0qeCrG8wDKatu2vJT5FCMKP5k/+TpajAWmQ16O"
"KpkyX0xiTFbkRCRS+cPISzLiqgqdemmfkAuL0+67VCO+E2WmQntXxRcDGBvEqfApHXwIYbEK"
"rLTimUqS2h8TSgYr6qzbj4xz4k0sVkGVVJGSP5UV4Zzw+Tqv/UKRRSI8WKrjv5Mhvu7f8hT8"
"YavDLU+b/27E4dUUid/okguJ7U9z/KTRv2ExdpgP1eLjueBvj2Y5fng5whNQW1bJ7c8Fv6b2"
"V4bRv2GPP1hsZdN+2xHCMxKtlv/Zt9+lcjG3hIass/7l9iOSjhcFqfGjUUssriuz718lf9yy"
"8mrbXxETMzucGf8dLP4wD6gskT/RqEyAHAB/bD56E6uR/5VYOGcpf2qfX65QllZG8qGuxk++"
"1nLy2jiKvlk8M1amN9GCwOAbfINv8A2+wa8bfN4TI0OGDBkyZKgeEltiz02d6tt3k+rQ1aUZ"
"fH9bSdmZ9Z4Nl4r2dGp8Aw+fjR83zuAbfINv8A2+wa8T/FAVteYmHdqm+A1d30Wu73rX95nr"
"/ZV4MtvgG3yDb/ANvsEPGl8FdsR/zu8df8Ij5Nu34rVhdBycrAKo/JKJMXV8jRP/2OAbfINv"
"8A2+wa8L/HxprTm+iCzLl1rPTcjipyt2bi8u5sO8+GzwkMGczXrZkmUeKA6zDhk0yGt8rvg4"
"k7J29VpaumwZtW69m/hsiHg+23uKIPBXrVhFK1etCgRfV5ZbtXIl32vQ4EG0bs06WrJ0aZ3h"
"o2fRfpxBQfFM13UCxV+1UvBHvHBGbfgBB8gB5qVYyx3/i0VfcIYHHAKtK/7g6/fem8+ZHhpy"
"RoDg2w/q268fderQIVD84m3F9HFRUZ3wHweWdRmVIObv/2L86/EZBH5YVVkA4fwnEgJD/gTV"
"/lT4GJ+opBHE/E2Fv3LFysDmbyr8RZ8vCmz+VscfjMdU81dm7MAJcXWY0Etv4zrxz13bO++h"
"E+aCGW3atuUchbvv3oUGCWWArAI4K9W4cSMuJqjj+XPFxyHQ2W/NoaECH0Xyli1byvi2V2cp"
"N/z169ZT0YIiGjp0CN8LxQP5TFyW+PgdDtaiyi06FiHss+fMpr337sfpiXJtfzI+zrCg/e+J"
"jkcWaxVFGxj+5t82M8/Af5xjWcBVva2s+zcVPoTo0CFDA+nfVPzBBPpi0SIWdjizxIc4AsRH"
"uzH+hw0dRrsLIRQkfzB+Xp35Ku0tlCMOiAfN/927dOGsCEHN32R81DDD+A9q/ibj8/wtCm7+"
"rli5goUxskog2wzO0s0KcP4m46MvPy76OLD5m4z/6y+/Bjp/U+EHOX9T8QfXVzd/VQJgRx0+"
"VYXUEBJpx1Pmc4VQTpwq/8VJ8c6ddmeARg1lleTW4qZIOYNT2P337s86lk94B4CP093QvGvX"
"reVJjCwYxHneKBD8X8XAQeqUtm3bcMYJVB1FJ+iVRKb4yIYwf/57nK4FBzyR8w2JLrt02Z3/"
"XbtmrTplHww++I/UO506d5JF8VgAycSmQeDjEC/SErVp25r5g0OcfPA8S/5Xhw+WYwJzyY4c"
"+jcVf9auWcOZE8ByHP4MGh88QeodTEApaONJTnPF//777znbw1IhHMAb8IosK7D+Re7G3QKc"
"v8n4OitLUPM3Gf+3gOcvzlYhnRJS7OHAL/IFdhb3Cmr+JuNjvCA1XlDzNxkfYxN1wIKav9Xh"
"BzV/U/EHNRmrm7+sxBgUWTHc+CDRnzn6M8VUfI58hqvXrKYVK77j9Dk6a/fSpUt4RSdThtie"
"pswVX5e1x4DFJOMCb5YV397LER8JXZF88803/80JQREHoysbZ4P/1VdfsosGbbV0hA2pDN6u"
"o1JgBYcPGE5xw1E8agNUlYUJAr9zp848yd55Zy4n6BwiVkiudhMEiI8M8cgEIyOWrED58+WX"
"X9IBcEuoCKkg2w8wVHeAJYMJjTyBCdvPOeKHVeYHFGjUBV1dfzmdHPFdN9j5m4y/PeD5m4wP"
"pR7k/G3QoJD7E7hIkKwT7vJ2TgDzNxkf/Yv0e0HN32R88CrI+VsdflDzNxV/sP1T3fzN1+Ze"
"YmyI7YsgsaXWcxzvJNqrL7/MGayRnBOltzEokc2+QYOG/EBcEVSl0AkCH5YMVloQEuhcWaXU"
"8VaKueIjESdWElhloZMxOci3Es0UHytnpEjRZbabNW/GExmTACmZsOp1c2h/Mj6UMbL96/xy"
"3gCxnUDw4R5ANVwkS0btIBCnDorZgeDPnfsOpxdDZYOvvvqKqzIjGWpQ7Z83by7zf9q0F/ln"
"H374IWdfD4r/CxYUsaWxyy678GIC98pDKp5YcOMHlthuu7X28Ml1Ax0/mLNBzd9kfKycg5y/"
"yfiwgIOcv+Av2qqLeCJ34k8//cRtD2L+JuMjM06+Ko8TxPxNxof7TSc7D2L+JuPDlYh+CGr+"
"psJHlYXq5q9SYioXGKfy0OhWUkxIfAOuW9dunKkcEwsmPToVtcHw3lX5wTglio4/yREf5QVQ"
"juXNN96kn3/5mYsQJmTZzhEfCgDlWDC54O444vAjOHdcvFxAZvijTxzNQu2r/3xFv/z6C5cB"
"QR2hV15+hRMlI6N7LKEcQW74e+yxBxcj9KpLO65nvgeBDxzwBZNh9qxZtMuuu3JW66DwUQkB"
"pSsweLHHofs3XoYkN3xkPEeeOsAhCz3uR75SM7ni6yresAbAJ2SoD7L9evyg2gKSrI4ceQxf"
"HxT/MX4wH4Kav8n46M+pU58NbP4m48OVjqz9Qc1fJD1HFnoEFcDCGDBgAGftR2Z9jNFc528y"
"PhYmUMpBzd9kfM0Xji0IYP4m48NiQpZ+uP6CmL/J+Ngbg1IDpZq/UonZUgu6Knu3zJAtb2Hp"
"CCWVUR3/oNE9e/XkwQ4FhgEPV0ejho1VGfeoXE3oSZAjPq5AOQ0EAMCniwHMq0U9iALBHyfw"
"f6fWbVpzgsuIKnOSDT6vpsRKCpOrj92HE/+i2ira36ZtG6/gW1D4MqlrjMs5IDM5V4j11zPL"
"Eb+hWBGhHhi7aMT1yDStqx4HgQ9c9C/2NrCKzrV/k/HDvgSsKPGD7NyxaDQwfIvbP060fzNb"
"Mm7A/avHD/jTqlUrrvoQC3j87LvvMM6cH8T8rcIf8SH376/BzN8q41MsRrV8CGL+orRJz549"
"uF8xHjF+IJh/3/x7IPM3GT+qElcHNX+T8XHFrrvuwgFIQczfKvjiGpRpgTcuiPmbjI++tDmZ"
"uJty/ubrjbdMyGG/ZQM2s8OqyibujgzEeoWVWB48d3z4otHBIFl4zV85NBh8uG2ArbNNe0XZ"
"MsRncx0sEYzmjNVlZezp1viyLHrMG6Q546sBD7cNzPrkPsgVHyUc4LMPqYzluiRJtvxPxi/T"
"/BH3CKJ/U/FfR0XBbVmm/g4SX7ffXz49sP714bNLS9wj6PGDkRLU/K2uf4Oav6nwISSDmr8s"
"H4RiRIZ43Z9++ZDr/E2Fj/3HoOZvKvymKKUVygtk/qbCD3L+VscfKLFU81cpMdtLAeLG0zEm"
"Zj1OOn+N0iUhVceGV20JFyReHSS+LJRoeZt6dYHvnUfJAZ+vtuSGOe9f/Jfwg+J/Mj6FrCrt"
"j0+yYPkTRP9Wh89FDVEaoo7w/xvjpy75U1fj57/V/qD4n0o+RN1oneLXtfzkILOA5u//Sj6n"
"mr/ynBhqtHDFUlmrp2vXLrwx10W8unaJv0clT9SuQTAErjnjjLGSKaQLysmwYttRJaj1OYEk"
"fEeZyx99XMSRgcA/7rjj6R6Bj0qoIVWjLMZ1jWKMo/HxADE7lhY+agL5249/N27aRBOuv57b"
"j70wvFAPSpY3kPjptH/N6tVV+NNVvTZt3Ci3L8V1MYXjb39N+I899qjH/2++/Y67HasObGpq"
"/EMOPpiv6SLujRL3pFwstfH/o48/Uhhd2M8fysvnDXZH/W7ai/F7HHzwQVxnzVHncmzmu83F"
"9tDOmOqX6vjz2KOPVssfvGQNJSclf2rq36Kij1OOT1Smxr4mhw6rWk2p+I/nzBX/+uuu42vG"
"jTtDFmz0jf90xs91112bcn7BJbYBY8d1vfajujm+O/igg7l4paPqvKU7/l+c9oIcS998q85O"
"OfxdTfxJd/4+8uhjCfy57LLLEuYv8H/y5klX5p8+31MbftHHH1fhD+YuHy2oof3pzl/go83A"
"P/54IXvukbLHP36qkz/p8mfsGWd47YdsQzXt9Rs2eHMQwVKOiljOlP+XXHJJtfML44jnrirX"
"otufyfzV44ffi3bxs/juMXHiBF5EZDp/gQ+94R//qGDub/+TU6aoBUqsCv9TzV95TgyTRm8o"
"2i79+ONPXLL8YCEssZGJarIox45NNRw4u/jiS7hMNXysMoLEkhvncEvgwBoXLnP5LEAqfBRs"
"Q5aPyy67lB5//HH29d940400Z/ZsjtIpbNBQuTlcNWCdjPH5MJ249scff6QDDzyQfas4e9Cr"
"Rw+66+5J4hkupoMOks9XWNhArkwyaf/2beyTR+g2ihvCH4yDeXj17tNHVbmljNt/3nkX0IIF"
"C/jziy++iGtZgcacPIYeFYoBSnfxkqX03nvvyXNujVApuVCev6gFf79996PVq9dwFBcWHzj9"
"npeX75nrOASJzdSbbrqZz8YUFDRQAjVz/iOTwtixY3ns3H///XwdIowQAAQeoc9DofyM+TNs"
"WPwZbr75Zt5M/v3331mh33XXXRQJy4KqfFYri/GTDv6dd93N4yfb8X/bbbfTi9NlpBX4jPGD"
"/kQU1j/uuYcKxHiUVchx7W1C6V3H86EJV0e2Mhr/RUULuE/nzptLhQUFvAdhO27W/NH4k0Q7"
"77lnEi9s0ccoOY+DwHD1NODq3HL+dmjfniP7QHDhI3za0odca8Aftp88BoO5e+aZZ/I87dG9"
"OwssRwVAZNt+yJ5LhcJ9/Akle268kQ9jY842LCzMafzo9j8msNGHCPbB+EFgCPq3ccOG9Pbb"
"73hzF33iOG7G+Dhzp3kPpaVlNfoBAVhyXIZylp/ytzYHLk2fPt0bsw899BDLjmzkw9Spz9HF"
"l1zM33300Ue837tRLN4goxG8dOVVV7HbMF35KS0xW2pK1njKAnKUlgOhUuiwYcP4/QaxkkBn"
"Y2KA4LfkhiasJNRqz9uYTMTHS6e5Oeyww/jvIYOH0KRJk7jjsYqQfmG7Cm66+PIz6Rt/+OGH"
"mUFYCcFkhcIB855++ilVCTXMK5RM8Pv07s1nGDp06MA+4HvvvZe+/vprjtIhdW5OrhYzaz+v"
"PqJROuaYY5gXWIkXFhbwAOgt7onNX9yfS6ajA3E4EhV0Eyyx6vGx6Q0aNWoUn2fCYIEC37Z1"
"G1t04JPmP6oPJ/MlXf5cddWVUuirSsL6nFC7du1ozpw51F4IN1ed2s8UXz+D9u+D/yOOHsEK"
"p7y8nMekPliZzfipDR/Pof3/ep8wE3weFyoogKsdi/7u0b0Hh4kjRByphyzPGxHfWwjxXLPS"
"Hv9rhDLGPIWQgxAqZAFtefsV2fJnjVAuTzzxBFsuCNlG//bs0ZM9NOARxo/c25Dtj6gK3SGu"
"7J0nrY802o8q0PEIN1nZVwds5NJ+T/YcehjjDhky2JM94LFUYHZO8mfhgoUcRScPwlewDMLf"
"eSw7myfOXa0IMsB/4/XX6fTTT5fVjtX4gEcAZ2DnzHlL7nO6Ts7y05tHMZsjPvWY1XJTWqZO"
"xuP/aqGoEGCHsbldGAS33nor9wEWLchQI2MV0pOfobjAtT3BKwWP7YVWl5WVs+bFhIDGJ7Xx"
"iAGL8F+YgOeddx7l5+V7aWESNvaS8PFvH2GtgBCOPHnyg1ReWc4urptvuYWeeeYZ6tatGwvt"
"Z599hhXGA5Mn88Zkuvi2Mp/xLJg4aD+sAKxssdq98MILebUC6wAluGUETNyMTwe/XAg38ABu"
"gTvvvJMndTshnKc8MYVX7tm0HwIBPG/atCk9+dRTHFo9ZcqTFMoPeVGIEKS69DlWXlAMCEHF"
"CXcWfq6TEl+XLkffIf8YwlgxiXBws2hhEfXdq6/yQbvcBtxjurAY0H7010knneRtotfGHyi/"
"UnEtVofamuRK0aLt27dtF880RVqtvfegMcAVn2ufdzr84c17W5aXx7mUN958gycFUijBlYmw"
"8XPPPVco6Xw6Uqz00P5nnn5GCQ0nJ3wdho5rTjzxRB7/Rx51FJeC13sANfEHfMBE1TzBPT79"
"/FNWYOAJ2ohVL8YPUinhnKTe7M9kfL799ts0YsQIfmGczpo1SwppgQNrH6HLffr0pn3FAhXt"
"x0IVC9Ta+he4IMxR8KG4uIS2l2znyMlnhbLE88D6GD16NOPfeMMNniLSVn9t7Yf8qVT9wHJI"
"LKgefPBBPgR75ZV/5b4Ff4466kj6RR2eTnf+JsqeyWKRUsmy5xYhe96dP5+6d+/GvIAcQvsx"
"/hdxrlUr7fbvt99+dPvtt4u2XklffvmVGN9lQhY8S7vuuiuPr4S5O3gwn3XLBD8cjrDsQr/q"
"sYiUUphzSA6BRTX6B+2/SrQBylNaQnZG8lO/j8QivKjgMRuRY1YqsainUNLlP8Z8eXkF8x5e"
"iFGjTuQMKDhnViysyBLxXMA/66yzPP4/I3jHmUxS8CekQyAdx/+yPVMPIehQVHBjvfvuu8x0"
"NB6TCpMOQgqCdvny5fwvVvZ6wvlDRJPxmzRpQg8KxQK64447qFfPXiwQYM3gHAhWLiCcwMcK"
"5udNm6gR53SzErCqw/e/xwqia7eubNVgImAPDIfloBT8kV6pXtXhS0Edpd9++5Uuv+JyFhRX"
"XH4Fny4/YdQJrDSzbb+rsgL06tWLFSNWKd+v+j6uBH2rc0wMuL3gcrlBCAsoZv89UuGD0F7Q"
"rFn/ZqE5d+5cVmx+YQP360033cRuzF9+/ZUXAw888IBc0fvPKaXgj16pQWl6mR9ceZAT7qWJ"
"EyeypQbFCyENt4g+8JkO/0G3CqHTtm1buuKKK9hCfXfeu8x/LKhwmB3txTj74IMPeAHWQFg4"
"6fCnNnyMG7QTlizmAIQd0uJg/Pt5U9v4BO2zzz58Puuk0Sex9X3ffffxYd7rr7+e+Q6lNnv2"
"bG6zpc7GpDv+sV+KPsVxElh5cNVgfgIHYwZbAnB3YTW8k1BAP/zwg3fAtLbxA2q1005srUPB"
"oL8hRLHIKSsto3vEQhH3wT6YdkPlKSsnHfkQnwuu9zr//PN58YkzbZA3Tz/9NAtyuGLhqvS3"
"uyb8Jk0ae/MTsgeKkWXPf77mM3//fOifLNdgGaA/sHiZ+eqrVXhTU/thoV500UV8vvXYY4+l"
"PXrtIRZXj3FGC60Mapu7tc0vKHnwX+dA1BYkxiXOzWFe4YwYvGevC4WZyfxKkHX6b+W+c8mt"
"Vl6mKz/RfpxXu+OO23kO7brLrl40IuTGk08+yV4htB0yApY/PGhxL0scP5S8ctQ+UAhSmHbo"
"zMsvv5xdQGBwWVmpsEDKGQD7BnCpQUjjWuR205M4McSyKj40+EAxgTHxMZGw5wZf7pliQkHJ"
"wBIBYXDhGjxUwmq0FnxbbU7atmQ+Bg72+UADBw708t15IfZJK4h08Z8Wq3scIoSwh7IsKZGr"
"CAjPXNrPYbxCSWI1AmFzwQUXcAg0NjwdN96BmAR//etf+Zo1a9bwoEVH14SvT+zjN2+88SYP"
"bjwDBJ0slyCFB1bcHTt25GeA++vUU0/l1XzDhg290Ox0+K9P1msX8Ttz3+FDjHBpwh2L/YK9"
"9tyTJ0e6/Adh4mN8YhUNaxjXlZaW8PjEAVLpmpa8gBLT7iw92bPFr6iUYdbARCYELIiwyEOI"
"NMZ/OvhaUWICYzWKfsPqGXtG8+bNY2zwHQdsMb+0EkuXP598spCVGDwCXXbvwvsYUGIVwiLA"
"qhcHwKUVbnk4nMdSKGgdfl39+PHSn8v7xfTGu03nnnM2b7zj3hDehxxyCD+D3z2byfzyfqes"
"CMgFCDeMQ4wf3a/YW/JbkDXhQ4Dus8+AKrJn/JnjqUDMBX0UAIoOyghKjPfOsZ+X1AfVtR+L"
"NwS6QAi/KhQgtjLunnQ3PSMUr6Wi7qrM3V8S526688s7JM2LRNH3n37C+5OYY8iUgjGGrERY"
"xCVbRunKT5mg10kIg/fjZCM/o2KsPf/8vzhIBbxgj4NSmu+88w4vVrDtwImphcX52eefeUZS"
"FUus6s1lmn65LxJhtwDeYxJw9ElU+qqxgoRlBpM2qg6T8sSoUYlJfGSPh5sMrjGswi+99FJW"
"lCAMLO0LR0dgdQf3BAYSu3pqZJJmlONjmBy42NvQncgrR+WeS2Z8uviwXrAavPvuScwLuCVh"
"JkeVIMi2/Y638e6wQoTVAsIGPzZT9WoNBMUDfJnZWe07hEJJ56BSDCxb5pCEtY1VG3BSrZL1"
"6h/Pps/IYKL5hV9t/HcSlJgMp9W4aDd4gzGAsZAu/zUe+DlmzMk8UfEsGJ9RtU+gnwPfYYx6"
"K7gc8W1luYNnewrli35NsFJqVGJKMCieaPcwLArwYMuWrd7Y0SmD9JmnTNo/d+48ev/9D1g5"
"/vzzL/TZZ5/xtbNnz2FBDSX/r3/9iz0tWIjC6kD/oi2af9XhDx4ssyfAPa/7FJ/Dcm/RoiUn"
"6/YrRXZB+y2YDOav3xIDH/BCQBVciTKVmz/zh5PW+KlJ9iDjhM4kgcAktB3PoO/h6v28Wtp/"
"6qmniXG9hdu411592XUGrwoWbNpqTDV3Q150ZPryzb9vqMcuPAdYHCFwBWMA/ZsN/xMXXj4e"
"JCmxbOQntpGwmPrb3/7OCx54UDBWQ2rBBn7hGdAn0AnIlCITBTsplFiKhmjGoAOxSseKGatO"
"rBJfEysYHaWC6Dy84GOXQQe+DfWUPtH4zSdPfoBdZfgbftwXp09XGeY7qfMG8reYXOhsnmDR"
"aFr4yUyVIZ52ylVElevTwIdQxEoNbqtRYiVeIdr23YoVzGjUBfLOSGTRfihHrGQh2NBW7DXe"
"dOONLEihQLRJrf3qELTTpk1jhQnLqSZ8tBsTC5vbiAoCwXULa8L2uW+AjywFEEzod/wWK2p2"
"Q3oRSenxX5/p0Mk+IYBwf+Dib6zCUCoiE/7rNoK3cIWB4EaBu3OTmLQYRxifENDYywMv4+64"
"3PH1fgR4DwVf1d1cM753UFa8x14axj/2AzBGBg0cyH2ERSO8BzpaNa7IasbHqhtKq3PnTjzu"
"tglB0ELwA8KfXf7CWoRnAH0AAYFrsU+Ea+V+YM34yMGH/Qv0GxZA+WI8bhDC+ZprrqGTTz6Z"
"BTFSxYH3yHMHd9n/Y+884KSsrv5/ZxsLS4+CBQt2UVATFbCXWGKMsWCNonljSdRYYk3E3mJN"
"NPYKGjUqYnkt0diigIomFlADJCrFTl22z8zz/O/33HufeWaYnbLzbN5N/s/V/bA7O/ub+5x7"
"7mn33HPCFrwTtqXwj5NDfqgSemd0L5V/jOy5ISR7GtWfHnpIeAZj1FWTkDYy+jNWMiJKWF8U"
"0wknHC/p48gGruSwVzF6qix+vr1bKv/npZGdIy1X4FV6csFPZDES3uV7c3TSNfnphdaioBIr"
"AZ9Q6pQpjwl/ExK9QBvqyyRj/RQJq6LcSJKjtQtrgHwiMoRRHyR8FDoT48B38uTJQgjcua++"
"/lJAEaKcY+DGc4hLNhICAk8Nl5iYPkqvvSNZJCZqXj/ssMOFsCzgd/XGJe6MQOVwmDg9gxg1"
"G85lQZoDd68ofvZXSk3RDDPa1t8688wzhXjufCD3/aXgwyBYVVhwQ4YOkQP/fbWA//jjj6Wl"
"BeG/rsyfGDrKkXDAVluZVHQ6wlHrDExTQdvMmUNjfiasiyDC2pJEgfaOLEHp8Iktc5iNAEYZ"
"vfXWDBFGCEwE2Abrry+fy4E04WFCZGx0LCQUD2uOddQm2ZzJkugPr5BMw6BdD8kkY7QHeNZZ"
"Z8kZB7isA+euLmZfiD48A/wJ7d08Bw0eqPbee2+hG6m6nCVSnoZQE5/BWhMS4uCe85mEPVvs"
"Kj6CGQ8cJXDYYYfJ79z7EeqF8PkiCYjzEgahEq6X1BAO8w1/0JSStYXunP3gKcBT8JKEU1Si"
"IH0oAcR8SDghTNXcvELtrted+TJ3nonMNpQanhjnfigdPqMY/V01DOQAZ8xnn3222nzk5uoo"
"/ZkYcCR+kSTF/gWL1/Bo4CWOJaC/ywAsxD9mHbYVJYDHOEwL+Pv13uBM29Ed+ji6c2YiSSlS"
"zcMreqbH32dkz3fVY5ovb775Fu29vhLIHviIvetkIeF04VGVKEm+EUJE0W+p9/HOmi6cT4IB"
"feD/fHtXwrmpdEnyjb2aK6tRvFSpR8Yhl8HnfdDKKZ6uyM+TNQ+e+ItfGJmmeZbjE5PZrMqW"
"n/DzTTfdJHKIfQ/j76+VFHIIw/Nnxx4r+wOlzv6Aj9ljRI7y4Se0hvPPOPOMrAqM9XW91EAt"
"sFwasfMietf3Vn0aTKmm1pZWie3yICwsQhqNumzZcsn2MfWxfG0FXKdy8fXLki2D5UOquLjQ"
"VjibeHK7vL+hb4OEJjgMpZdMs1hF6UzxyAL4vg1nSLxYmRBYQ58Gqd1G079UMi2YWMCSApwI"
"dxctjs9GREgOGjhIP0u1Oez3fPkez6OjPalq6mqEluXMn7/v37efnudAOV+B9oQ8oEl9r3rp"
"Qo2lQ6PBRHVC9WvoK5Y15zF8PlbLCv07SeHOwYfO0HuQxqYeIlYNVbmJlUMfmv8hTKEPjNfY"
"1Kja5ff1JilFmXRw8ClFldbMXYz+FPOE5vASHiXnVY2aFrRjkPXV2NJDSM8F69WU3VGd0ofn"
"7KP5EPpw7ijzXNEo9OdnKrG3tDQLfaD/wP4DTGYWPFBVJVmB8ChrkW/+peB3dGhrMOVpGtYL"
"JkqdZ+VZoM/Spcs6xefBaqtrpAwQZzvQh7NOyZLVc5bCu/q5qWPYf2B/4VnhY8uf0B58Qn6d"
"0aehdx/Zv8wHL2/J0iVCY3iV0kkMznoI4WB4opRQNvvs8wNt3Owr2chyHlWE/+El1tWdA0Ir"
"eB2lyf7q07ePGtCvv/CU67sGHQvR3+EnLK+yx9x1Erxisl57a7rDS5xNuvtWnMNxbkKmJFZ6"
"of3r6M965soew3+e6qv3IOvL/mDOveWOXpUWtI0y/5TIjM7pw/7C6DP3Rb3gKka7JL+Ypo7I"
"UtbfzYF8A+aPjChFvvF3yAT2l8shaJaM4GVSbFe6H2j5iQcLj0FzMoVdSL8c+YmcH6D3EvKn"
"Tu+r9rYOkWlNes8mRdaULj/rampVf72u7jyTfc+8+2pZ1n9Af6EX0b/2ZLvqo3mZz2Z9WQvk"
"GzQM65cad6Pat7PnwzuSHYF1biwbrb31QkrsfkWjCNGOZEoWu6aqRjNptaRpiyWhPyBzAOir"
"fPjyWtJTy+xnwLA1nKXpL6mgrT8fa5a0ezLy5PM6kmKh+LaYZDF8ZQubuHImuMAwfXoJITV7"
"DyrZIZvCs620fUP3kvB5RsI/KBfHoJmQSVouDFI2pdz5q5QvabLMjcu0otRtAdsW0mihDSVw"
"RBn6Qm+qX3BWBrMm9c+ptKsbl43PnLmzsniJFxwgSxHTFXqekppvlP3y5dXyl1KxQCtjFE9z"
"s7m7lNL0IhvNuPLF6a+5SehESEVZD1Lun0kKdZtsYlozyd0QDIEi9IHn+Dtv6VIR/JLyy1mJ"
"/luEHEJD0uQ1XkLLuPZWvT7VtoEksXZfSQIOX0GYs0x8yd7CEFthGhi6VvJS7SFt1qgzfB4t"
"KQKrWYynKkt3OUcN2p/4mvdbVWpxSjU1NsnfieCx+OwPk/GZnz7C54szawxduTkqhlRLs/wd"
"GXl4qW4QSTnqqPFy/UHuF3mF15ffN64wQh8jqtpWAzHeRLvQJ9WYUh1a2EH/cPFX3lOIPkb+"
"GYUIPdw6OOu7qakx6Byc0MJ6efXy4PxekkyKyJ8OwVwu1zowQlDIVVbOMTemibCXsL3tOIyg"
"lTt9HaZYbzH6sM8WLUqbHAEr3zz37Hr9eCe0QxlX15h7nqxTGrkaSPzC+wt6JxLtIkcR7i50"
"R1JJyvJhufurM/lJncoVTStsclmIZ5GffnnyMynGmEmAE5qSl2Dv/zVpRW5kc1LChi1NLZq/"
"TDIH80e+5dKnJshGY8KeKHDxItolDdQXJgmqXSUyVb1MsamEavc7AtUd1MJyf5fwVT580e4J"
"whbaymnrHL/FNhxcCd8vBV9+E8yfL+51SXJCaP65+F7J+Hr+Wri3tbQWpE+580+Rfppslbnm"
"0j/tm4PtMH6yI1U6/fVb29Lt0jnVtUQotr5u/iSslLe+hv5JNhMKJQ++uy9SDn3SCa4YtGsB"
"155n/u0rzR9eLoc/y8XPu75F6CMXeVNaqZMp2Bn9PU0bSfpojWz+7clkgE+oibANnp4oPy1E"
"8a4xWJJSxd4vvr56jgjdDG9kr29Hh1c2/bPlQ6tEAsreX0Xxwe7ALeqc/iInuoqvxMtEEBfa"
"X8lk1/Hd/mpv80Th5pWfnfFPF+Sn7GPbnqdS+UkpK5wg7Tdm00caaubiaz5uKUyfGmfhmLlk"
"qOAW23XRLJ+JHCFi/Bg/xu9p+Cb0v0zCjabOnvGixBvQQiamf4z/n4IvZ2IqHvGIRzziEY//"
"wCGe2H2TJoXO3Yw69JUflM93Pyf8UKw04QcxU2mFEOjUzAEerx09fnyMH+PH+DF+jB/jdwt+"
"1UpqLfvMzJ4n+TZLJfMmP/R+P/SaH/ykVuoAFOPH+DF+jB/jx/hR4te4S6hBZh3fhxNY+MFL"
"BC94Lg/FlyZWNi6ZndMi7/EyL8f4MX6MH+PH+DF+d+DXGG/NC2WkJFSQzhfSiJk7ACbVkcu+"
"DHL9d9hxB/X2jLfloh1j5KhRau1hw5QflFirHH/50uXq9alT1cCB/LyjecCI8NdeZ20184OZ"
"AZm4bLrt1ltnbqiXiT9t+nS5ouDG7t/fXc2fN1/NmTM3kvnnw2f+0J/Lq1xG9O21gajw6+vq"
"hR70IOPSJvdPumP+UfBPPnxS7aPin1x8KuZT6b47+eebr75RH8ycqYYO7Z71dfwZBT456tOm"
"TZXP2FHvXe4Wzf9svpo5a1a34SPZ5sydK21s1l5nneDaQ1T4c2fPFfwo+Ccf/jtvvxPZ/u2M"
"Pvw6iv1baP5R7N98+Mj/qdOm5aW/qdjhmtR5mdIqadvrSV7308F9CfL1Z8+ZLcTmtjhVtpkC"
"C8zt6jGjx6h1NRMpey8pCnwu4T425TG1hSYO97Jo3hgl/jrrrKu23mYbU2hSE66PVJuv6jL+"
"iM1GqG222VqKby6XVi/NUlaJCgTc66p0/vnwqWIwetvRUqZl1qyZwT2aKPAbGvoKA77zzttq"
"rhZ0ptZbIlL8uRHyTy4+d+iEf7aIhn9y8answNyhf3fwD3fzaNpIxZnuWN9FixYH/Mkl01n0"
"20p0fX3pdoEwokrH5MemCM8/89yzQn+qR1Q6/1x87upN1ULvZW2YUuHGZnlHhv/tN98KPvSP"
"Yv/mw49y/+ajD/mBNDSOYv/mw49S/ufjnymPT+lU/osn5pqLJaxuTKjMTW3f3tpO2BxHXuOe"
"0cKFC4RhKGLZ0LevtKigJw5VCFZZdRXTX8bVh6sQf8nSpVJ9gCr54Eu1dWlT7quo5r/qKqtI"
"DUjwt9xiS3Mfy+safr++/eUS5dNPPyOlZ6joQNkjhAa1CEltlourqXSk+Fxq5O3SMiKRCCyV"
"SvEZ1H4T6z1hqkJEjd8WIf/k4s+ZM8fwz8xo+Cff/OkT5eYfNf8wd4rG0s2XTTx40OBI6U9p"
"Knhz9dUNf86bP0+K1prgTvn4/fsPkFqK3A8cNGCAVCdHsA0fvq5Y63h90rvOS0SCz2Vl1pRL"
"0VJEV2+ElJ+p9VcpPlcPZP+uPlTWoNL92xl+VPs3H30WfPqpXHaPYv/mw49S/ufi05qokPwX"
"T8y3PazSrshl2g9ec0VbPVutmtdpF8GNfwhPkU8egKKgaGKEEXW8so7fKsRvsZVDxowZLfjU"
"cPQzPmkk8+c9M2d+IPXppFdYKp3pg1UmPhUdZrw9Q7y9IasOUcPWHCaFP2kvwNypbeY7NztC"
"/DfffEuqHJiMn0SX6ZOLTxWEd955R1x7l2EU5fzBj5J/cvGlWkiE/JOLL5XztSDqLv6hGrrQ"
"Xa8pm/gr2wQyqvlTPxDMp576X+l/x/qaKjRdw6caBqWQmKsryWXCSn7Q5gdPIzJ8jUH5Kyle"
"7VbW97vMn7n4eATQ6PnnX4hk/3aGH9X+zUcfDPSo9m8+fORpVPs3F7/d8lBn+zcTTqTtARWR"
"xcVLi7tH6SR5Tfm21I7p4IlFvsEGG0jBSQaFQ9GUq2hvhnqIfGh1VSKwRCvFp3Ya+EOGDBV8"
"6Wps3dMo8BFAaHvq4g0dOtS0Z5GOpV6X8FkU8FhYNi09qB544AGxpqlZ119vOPDTqXQk+O++"
"+3cpIkqRzFEjR5nzGd+LbP7vvfeuWLkPPviQ4FFEVi4jdpH+ufiffvqJ1N+Lin9y8RFw0D4q"
"/snFp4wQ3l538c+8eZ+JwkFIUGVdlJjvRTZ/ihojRMFn/nypCtaXkBjWMgodr4Vh2qYoqX/H"
"s/gVzD8XH3pk+mmFBGQX6Z+Lj3yLcv/m4tPiBy+GYtxR7N98+NA/qv2bi09LHmgT1f7Nxz+F"
"9q+t2JGyJ3CJoBxRUMQxJzOS16jHRTVykiJgfqoMU2mani88AJXSHVNFgU9TQqpV05qCIp/7"
"7vsjeX+mj1Bl+BCGatkICNd6PmlLrHQFH4HPFxWkqWOIdQtdeO2Zp5+WjqZUpe/q/HPxoT9t"
"Uoh1E66hhUol9M/FJ3EBTw+63XLrLdKkUdm2JlHgDx48WLrzEt6Ngn9y8bF0586dExn/5OLD"
"L4Sn116re/gH+hOSY/7sMbe+Uc0fI5FQq6P/nnvsKbUN00HrovLw6VZNyyYED3sK5Yiimfzo"
"ZLVs+TIpNpwKtUWpFB+l6IqGO0WWDldRrxDftX7hvDCK/ZuLv/XWW0vbET4niv2bi0+LLLoU"
"MG65pfL9m4sPfzL/qOR/Z/zT2f41SswWhQwX6XQ9dRIuw8rFLvU/o7YYpa24DSUujMuHKzh+"
"/FFq0beL1dDVhspGTtqCjlHgk03IwtKemsrQWO2pCPGZK65q7/o+Zt5SO84LCFsuPtWYDx43"
"zhSjTabURhtvLNYtSoA3cQaXsCGPKPCJSR955E+kujnPw+K7Zp9R4Ac9iLTlSYsTlE4qmYwM"
"n0KrP/nJEWrZ0uWR8E8uPjXs2FjQJwr+WYk+mg5sNM6auoN/qkL0IcwS9fr2aWgI+IezMTzL"
"jkr2l/YmNtpwQ1HkKBgK8+655x4iH1ZbfbWgxFVU+FJAVitjhDVdmVO2K3G4FUgl+Ay8DAmx"
"+pXv31x83nH00eO1EbEokv27En2SpmgxYbwo9u9K8xf5P16v76Jo5H8n/AN98u3frMSOUgfM"
"QXsOhE+bPU+SA+P+/YKfsxr/RYDvwkIQjNdStrtudPNXUqHZWbh+6G5DufgM1+rENa1D+FCx"
"2p0NJENMVCm+a9TnWudQ5Di7s2rl+GbXJqUtAhXYsztHRzB/1jci/ilEnyj4Jx8+iqa7+MfN"
"HwHdXesLPhEJsF3PMD8nMaKc/VWnBXHvPqZtU9q2rmd9XXfwSvdvLj6Ki4QF00olew2iwIf2"
"dKSIYv/mw3fyLYr17Yw+eKhR7N9O5x+h/M/LP53sX6vE0kEJED9TjjG76nHO/WsOs2k1Ehzc"
"JVyKfyKT7x9s4mjxJZfF97oFP3RroSJ8ehqBLxtJqmZrj0B1ZNEns8kqxwcj6Scjo08uflCd"
"W9q3pCPHD88/Cv5Zaf50CPBT3Ucfi99d/NPd6yv4Hclu3b9Rrm937998+AkphxTN/v2/km9R"
"7d+eJP9NYkfKtJ8WN5wDNuuOL16yVJ180kly5jJcf+2///5q/NFHq0ceflgQceHFlfdMnn9a"
"LDijNZ32zId/1FFHBpjrDR8efE9HVemL4xts6WeVBz+VThXEv+3WW7Lwzz//fOnN5fk2Vi5W"
"Tn58aXtdZP7zPvs0C3/XXXeVu0h0teV18zVcff75QlmYW2+7Vb9vPbmTtnDh57KQKfu5+fA/"
"eP+9vPRx2JzfOfqn7DzLoQ/r+9CDDwb40P2OO+8MzX099cgjD6vf/OY3arj+Pe975OFHJPzK"
"IW259A/zz0cff2zaylj655t/Mfo7/rzl1tvUVpqmDl/Wma7Bso6d45dCH35+7fWpK9H/iy+/"
"LDj/Uvgnl/5hfGj05htvVLy+nu3gu8vOO0knXfjft1ZxmP/Lpf9DDz0ovB3QfMIEzeefZ/Hn"
"rnofmMr46S7JB+b/wfvvd8r/Zg+8IWedfH3x5RciIEul/0MPPtApf76h9xahMZ7x9ttvN2cv"
"NsnC9BtLBeegheY/9fXX886f8/1HHnlEwmYSAt1pJ3X7Hbebu1zioRZf31z5474H+069j6VH"
"HS2dOpFv5fAP3yMHttTYRK6EHgXkZ7H1nTr19Sz+cfPf0tGFqwuh/VuK/BclRupj2h2Ipn3J"
"GiF75JhjjpYDZS6fLV68WP98jFyEpNdVL7nxnbAPZD5UMk24sJYydzR8m12Tiz9p0n3Sjpv4"
"L1kzdC4m0YLUTNqB19DITTqt+l3CP+74E9S0adPkdxwG0laejsliMadNw0rf97uMv+awtdSn"
"mpFo80778ffee08atzH/k08+WZQZz7XhhhupBfPn62e9RpQC8dw5c2arWssMneHPX7BQjRw1"
"Uv3rX/+SzB/3HBz87rLzznLICf3xprsyf57/kMMOlfbyrAHXDGgd/+c//1neT4tw2plfc801"
"0vn3wgsv1D8fq2qqq+XuULn0Z96k+HIH6Rq97rV1veR8oav0Z/636Y1/zTVXi+KCN0kMgVd/"
"vN9+FfOP4/+x242RzDTWGd5nTTfaYAMlF3pEkfkV0Z/7WIwbbrhBaMR6I4BO1IYj2bh0EUZJ"
"yMVOzyt7/tOmm0uhzzzzjDQyBbtS/j/kkMPUvHnzs/YWQoi15coK++F9zT+VyAfmN3/hgk73"
"wM477yJ74NFHJ8vrvXv3EaWpJIRYHP+QQw/LS3t45qQTT1SPPTbFdN2uqwsqW5Q7/zHbjVWf"
"zftMkmegCZ8Bn2LInnvuuXLOwzWDV195RZ100snGwyhx/mH54/gSbJTwlVdeKRePTUPUyvif"
"bEHOSdlXfAZ6ANnl2QQa3nuKNpCcZ1QK/pgx2+k9NW8lumAs//a3v1UdJOgkqsriT+OJpY2m"
"FI1nvx7+059k8r/73e/U9773XSH6wYccrCboTeVajRtrMWyBZv41eO5gNRs/bS0ZGAUsehuR"
"ocPP3OjnHpeJjaa7jM/htLtb49lQiWhwG681MdsK8OmS6mduoEMfvoL7KrbT7Pvvf2BK++z+"
"ffX3v/9dOuhKBCd0GTAXf6+99pQsKFqOS9aVfQ5o9pBelyOO+Ik9a/O6NH+TpJFSY8eOFSYi"
"5daznWAZTzzxRPBMMPEvTzkluAtlLK3y6M+8hw4ZKmmzXKylNFAl60vK+bXXXCseBinPfN5G"
"2mDAYuQOyeTJjxqrsQL6mNfMAXUmy8qTJCPoEiS7VED/pDSetSEYvcER/D/U/OHSxo3FnpDO"
"yYlEouz5P/fsc+q2226T9zz00EOSyCHeWAX8H15bRxP2L1UVOFMzwictfCsdkLtIn732ZA88"
"Y/dAW/Ye0M/yk5/8xHZkV7LWpsJFefs3oL3vCe33tbT/Unt2ZC7LxWnnwXaBf9z6SvIbneW1"
"8U/JJ8aX2qNn3uwnaCU8lU6XLX/cGnBOxBUbxkcffSRnX12Vz2H+f+655ySbFOX7tJZJ8KJb"
"Y+5FoiPqhD9Lp3+Yf8CCLj/c54emvx3dtlGU9py2lPkbT8wyddq6ifw7ffob8obvfe970jmU"
"296kmO734x+rn/3Pz4TwuN0jRmyq9t5rL7HcOfj0bXw962AyB99lrkjLaY3T3Nyi7rnnHvn5"
"lFNPlb+hDM6empHBH7HppureiRONy+15RfHBbm/vCH7H963trUEmGQTA7d5U44I/dswYuaeR"
"sBZvMXz+5Ta5U4g8Ay3hhRmTpsU830+aNEmdcsovBeM73/mOeunFlyRcynvD2Uf55k9HVhbV"
"lIhRooDBpEwQZWn22WcfuefD/I87VntJmmmNJZUuaf5snvW1V8FmxYvhb17762uS0oqy5T1k"
"g/brZ6qxNDU3q9aW1iCMUh7929ULfzEXRbEWEza993/+53+6tL7OYyQVl89asaJJLV+x3JZA"
"U+IRI5TeeOONAJ8NPmPGDNta3StKHzZLMmVoHjZUzjrrLLXxxhupYzXNf/WrXwn+S9pCrbKt"
"7MuhPxdb3e9JCkGw4W0g9PBwsEwR2OvoNblb749S6cO/GB/wysiRI9V+2jt9/PHHRbAh9u6y"
"vM8z1NbWiMIYMWKEuveee0VwF6IPiqnNzjtl6YN8YH+5hBDKxPEewnGO/mTF8ZlnnHGGREWc"
"ICxEn2Yt0MweaArRiVT3Rnm9LUQ/uSxbIv2ZY1tbewZTf09I0tGeECWDfcBab6j3STn86ebf"
"ZnnHfF5mfZGbeK0oYvBxDMqZf1j+OL4kWQPjk0FYEeVCRq6Tz7PnzJEzpVLnn7bh0+nTp4ty"
"5wseWqHlF9VeHn74YekOjtOBzPjpT38qiWvF5D/84/ZUSmjfJvfinnzqSaHJutoju+3WWyVt"
"n/1FBAj+2Uvv36++/Co4YwvjV7kUSLdRnQbkHglj0KCBssHEUkiaxUAQ80AIQOLh1113nWhP"
"7pvIJghhdYbPw2KVU65n/fXXVxdddJE66qijZNPxGX/SHgdWCxYpISPO4crFD6oEuNdD7yNs"
"iZDgXgbCD1eZEI6zbIrhy+809mWXXabWWGMNtcnGm8ids+uuvVaYnXHYYYepyy+/XL7Hwth5"
"l51NNQeb2dQZPowEvdskMycVXKRwG4LwEO693L2ZPFlCd7jkWNrZ8yw8f+aw/fbbqVdffVUE"
"y0cffqSuuvpq2QysP2dvPFPunMuh/wEHHCCXyic/NlmddNJJsmERcngICAz4B+Vyxx13iNLM"
"WGGd47tBqjBWHfwJXTqs4kTAIbDhS0Kl0AnB1Lu+txHkIZ4oRJ/ws7j7R5fq9f7Fz3+hPvzw"
"Q7mMyYCH8vFOKfiM008/Xa2++uqCN3DQIAmtX3/99SLsCBexFoR7Wd9S+ZPqMNwN4mcUOCFv"
"BBv0xXvFCOL7hoYGWX/2ci/tIVPyyEQvCuMzDjroIFlblBNlpOBDE6FREl7kGa666iq5f8Zn"
"naI9egw7DAwVvqeXB98I6g7xwlJ2D5g18ALlCU+GX/fyfBXcvyHab7vNtmrQQEN75JwLX6IQ"
"7r33XgmDs8dK4c/c9UVxIyNYX2hLqS+e7b777pNrAXgyyLYw3UuVP2BwfQeDFg8Mnmctjj/+"
"eFE88D6fd5p2DnLXthg+azhgQH/VX38RhWP88f77hQ8xSpBt7CunD4z3Vxp/Mi695BKhPWsA"
"HV78y4tiMOMQ/fznPxcvkH2Gg4PhgrEd5h0vyxPzwprYpV46JaBkUdP2wG7pksXqtNNPk99x"
"ARmPaYz2ZLjsbA4GvSzN2xk+73MXCRFeCDLc1d13201+TxiT3+ONXXrppUJ8Npk56yiOnw4x"
"vlNgaXtoyb8vvPCCbGoWn3AazFlnw5jl4COUly5dKoIMS+v88yeohM2qCXtbbDiUswmzpErC"
"d/Hg7OdIidXDIsNIWENyo11vBBRRqfQXi0vPY/ToMeIhLVywUDWuaFQ7aKWGcuGWP5sCQ4L5"
"yr2SLJzS6INC5Fzp84WfC7OzeVc0rRAG5QshKIWXNR+8NeOtQMkUwnepyNA9lbLFQ+2BtQvf"
"wCd8YTFCE/hzzNgxZdEnTH9lD/ip1NDQt0H4FmWAYCOsqWxJpXLo49nfw+soKnho8qOPilLA"
"SEmGvHpKZ6GsnTFRDP+FF56X8zTOHk488UR5n4SD4BE9T0J/0MecnaSD8JkJw/pF8RkILujA"
"JVd4n0u04mXr/xDaGEBO6JtSU4kgzJ6dol6Y/l7OHnDvDxs0uR5GqfwZpv2jk6H9JrIPwON5"
"oBmeLDw1/Y3pJfFn7vqizN1F5v33/7Eof/ZFVpq4nJP7Zc8fQwdewVDggjD3Cd948w1RQBhA"
"zBU5gcNA4XO3HqXgv6ANoYcffkStu866aotRW8h7n3rqqSw56dYTI72ltaVk/mRccMEFMncM"
"BTw+3kd1I3AII0Nz6H/ggQca/qyuChTlSp7YyovvacU0Vt7wyiuviCJzD/4XrS1hTg78f/jD"
"H6qzzz5brbXWWurwww8PrCOv4ENYxrSLx/sJJzLhQw89VAQqoT1cSTwOLDkSDDLxa79E/Iwn"
"FmY6frdMCz+EP0LwTZuNFI7RloLPl8OW2/wrVshmIIzmaCWVG6y1yEIT+5W7OQWVWAY/TKfM"
"c3jqbu1F4slAf8pNZdEmyD4rDX83bTQw8CjxSKEbVjrWOUqe18JCJ+3i2yXSn/ngpYCJ1chm"
"TlmahA0ABCGxdxF4BTdZWu2+++7y+rvvvheUteH1N94wIXCED7TH+OHzEKgYRPAyz1IOfdxG"
"dV9yJqixwcOLaZQq8IvkX7BLpY/7cmsLX8BDzJdEJ6GT5RN+R7gI/hHBVwR//vwFatiwtcTI"
"hLZY42SgIjhrSXpxIThrzbLn+LxMxKL4/F2aPnNqbDS8H2Da92FsnHnmmbaMlRJlyvtRyJ0r"
"sZXpn7sHvHR6pdfDgrlU+uen/VKx+hkkTjBf1sNFFsQbLqjEVl5fd2bFZ4wff7S89uCDD64U"
"FQjuV5Utfzqy5t/cZMKvGCXM3x1JBEZKkf3l8JEtGKDsTXjo2muvFY+eMmXufDJzJNQsiqxU"
"+e9oz98ecoiR+xjOcvZuz5yJyjmDLlyhJnf+ec7EzBcuKBsVV2/O7NkSB31TP9TEiRPVT7Sw"
"IfzDA3L+QEiIDcPDukSKsMbNh8+knLUJ0YmtEvpB45LkgZV+5JFHirvqhF9mwYvju98FFx9x"
"j/VnELIke4f5nnfeeerTTz+VsAGMmrmkVxq+U+7Ug5M4vbWIwpf9woev5eKHn0OFmJ11wEPi"
"WW688Ub5tdto5eKjYDBKoAHnn2DQcoK1IJsSpmeNspRYGfTnX87S6BLAGhJyOvOss6ROHKVq"
"qJOGh0bYkbMucwE3VRCfsAghmhtu+L2EnbFiP9Ze4xVXXCGMP17TBRwyRQmrwJ9kw+J9m5Cc"
"Xx79/UxDv7DwZKM5IeEUTLn0D4ScKING2RPsBza3C7ljVfO8CCHDz4XxCdmxd0kHBw9DgT3F"
"fsXiZU1RMGShss4HH3ywfHbGECo+f5eYI8/PvK3yNWemnhhAYCLwUKSEN1k3hB0h4HLoH3hi"
"K+0jb6W9VS5/uv0rtJe2Rhna43Wwn/HioSOGe7nrCw70hx8bNZ8QmmSQwexCY4EnWeb8fZsl"
"SEZfk8Zm/vAi2aI4FvABuJSk42f2Rqny87HHHhNZDD6YPIOUq7LemCQJWRnOvsYpqK6uzk7Y"
"KiL/XbLLYC1n3Fn273//e/XlV18FxwKsBWuycrjZK3YmZqxnXEkefN8f7St5/Lfecou66aab"
"1KDBg8Xdg1HZLISEiGlCPEmd9gqfORB+wfKHAFjJ9DfCukZoQnAsXKxyUlHJoONfHprNZjKs"
"CsfsUXokEDD4G+b1XS2gD9SC8uOPP5bP5Lm22247dc4554jwY2FuvfVWc67kq4L4KFx6kXFX"
"hZRWzrrI2gEfJiXECtNg+fKcDKxRPEwJ33jFzmTMF9juOcbp5+BsEOuNECsH/u45oD0hChYb"
"+qfSXkn47oyNcB6eMPfdYIytvvtdWRu8sHD4NvibIvi59J9w/gS13fbbC68Q7yYhAwXj6qKx"
"PpzbsNal4DNnDsXd2m22+WbqKO1N77DDjqKoWq3VS8iMz4E/b775ZlH61TZFuBT6zJjxlqwz"
"4RkE2VrDhqlf/OIX6gZtOKBYKNHk1jRsUZdCf0Jx9O9i4K1wX6iurleQhch7OEOBl/BieQ72"
"pFjABfDZW5zrcDYyYcJ5IgTuv/8+E/K06/GENliIeiCkUPLQhUP1Sy65RIyCRFV1dm3GdO68"
"R8vrhKngya+//lIquxN+lv2ghR0hIgY8Sukgzj6I1qRtin+p/Anej/c37W4olcXnkcQE3V2Y"
"FB4inOnOy4vRP/wMhvbmXCqT2OXJEQk8hidAKjjn5yh+lFFHMlV0/hyPsL4Yy+7siDuNyE+u"
"trCe0A+jAt4is9adeRabf1j+8LfD1hqmvtaGgks8IWECrwmZRqFzaEWSDYaoRMtS6aL7F7pj"
"eKBsCaFT/9WdAcMn0AS5w4BG8JDLWSg0f0OX0QFd8HYHDR4o+59kJowejndQZtTzJK8AmeHe"
"j/NUVV2Tdaaa0Bawf8aZZ2RVYEz45kcEJgoFheWSBoz12aK1f1L16t1LNfTuIxfUTMisXe62"
"tLa2meKOGujaa69Tufh1NbWqv95ACBlwnZVvvDhfu6XNkp7a0K9B1feqN2nO+j+yX1okY2m5"
"CUl1gl+jN2GDjany9+5yIu/h3MgdGvN8EB18zrH4D0VAeETi2Z3gV6mElK1C6UIf6ILQxKKj"
"nE///n0l5RQrA9eY8inEkVuaW8SigT6+lHLKjx+mP7SHTlht0ARvr6OjTTNMg5zNuIwm6Mgz"
"Yb0Uo7/DT9h6ZczN1SSDti0tTaqhj/7cgf0lWYI5k36f6b6aKIifS3/uKElIQ79HyvdUV2lv"
"o0Ul08kg2YI1gn7GEu6w9dU6nz88h2Xfv1//IEbPrMgObWpq1LRuVbW9atWgAQOz0oLBJ3xN"
"SLAYfVBOzI+SYWxQhsmsSqtedfXCS7QJWgrN21pt9fTi9AG/yiZVoEh4DuZmQkJEJ9qlWGpN"
"XY0aoJ+vL1XT5femASohl87wua84sP8A6YbLMzfq/djU3CQKkMQFzpUltKV5HJ7vp9epWgxD"
"X6ItZL0xB7zBtJdaCZ9nZs8P0GvLvOFJMpfZX/369lN9GvrIfvji8y/U/gfsL4IQ3lq0eJHa"
"YfsdxOOnX5S0xymBP9nz8Ax7wPBSh96fy4R/WF96q/FsyIWlS5dIVq/vq6L8yZ6EP/voZ4H3"
"oP1y/dztcn/L15/VW/XV+7hXbZ2slQnNGdkDfxZbX/gTnhmo+c/RhNwC6ael39PeZjKme2nD"
"hT3uvBq+Cq1vPvnDgK+Zv8l49VRtTZ3Mv0HLCXMnMy1ylUxPPPRi9IHn4E3kCtjIFbLPjQPT"
"IDKTs0P+Tuag/67Zyk54qDN8zrX6yJ4aaGSnll/gILv4mU4QyDdoUN+7XubisnjhN/iMNcDz"
"dPxZ425U+5b64crCbe1GaXG5uU4/DAsjWWBaKKFt2/SHESqqkZRZc+6D0POCkiC+yofPiQgb"
"ks3keg250J/Dx1rmINvEjU2MVm5zc4CfStrb2vnxU75v4rMaq9oqWJVVcidlyppogtZU1Qgx"
"UJ7gp20xUaPl8+NL43M9x6U2BV7ukSRN9QOqf7e2NgedU/20L0KE+yaiPNs7zMU93+8U3w2u"
"mRB+QTBXhQ7FJU1V/7JZM2XCT8j8E/bGf1LO5NIF6Z+pHG2ELVmQSxYvlud3xULT3gpZX3NX"
"qsP0+jF8qTIgpdFfKhFwXqRpyqEt5WRMinBaNVc3i+CV+Dhnb3r+mablBebPIXCzSS9GSVUn"
"TI8kc1+vXaz9FOua8rTlXmM9mLTgp0qkP/NOaB70lnpBtq7rUwW9nZcqn2cvYJZCH5ck0mJr"
"5LnCsqYihDlX453p9rRa5i2X9ym7TmkrCDvF1zyDUGDj81uMqKQ9R2NvGW/FpGjLHLRCr6o2"
"xiPSlfknpVJCMijtE8b3k55qTeh5L0mbO1TwJEamxRfBpkyZMjxgUvfd+M1556n111tfLV6y"
"2PQV87yi/Am+hCBRLjacKmsMn+r1XZReFCSnCH1oj1KE/kn9uQltdCxe4qllVcuC/duRdHtH"
"86/+fUeqQ+RDTW21LGo5/JnQz9cqdQSXmGaUWbUB07J/+be22tQydOfmKLpi8jNX/ohMI2Oz"
"o8MmfJDmrmX0Mu1waGOuuqZK5Kf8vhj/2P3r5A77N5ky99JS+nsMBfp9iazR9EK+8V74qhT6"
"wFNtsqeWBnsK/JTNGTDOUlrkf/WKKutdpoX+cjbm+bJOrrpIpoo9DIVA81RQo8qUzNcCjEuw"
"muAtppJ+UOMqYUsn0SXZmU5BLSzQpOy+r/Lhk2HXIWmsRggH1bRy8CUpwknOsvBRJnrja4FZ"
"CN+3HUbLxee9bZ5Jge8ufPnXSxqm04JmZXwWvUJ8vb7yPrw5PieE73WYC5i5+J6rddZF+rdZ"
"4ero0+7rz2ipjD5Y33n5h2raHakK6KP5m/tc1rMtZX1LoY/B1/tH06cNzyEv/3isjmpNtYmX"
"V+r8k15KntlPtGTeZw3Hlra2lebf5pe3f9P6tdaWNq1Y27LwE3nwCbuK99erLqjRiEEXFMZW"
"xfnTFyMqlVf+JJOJ/PKnKP21kkq3UWm38/3r2SrpfnsX+QejpFW1t7YVlA9d5f/i8kcrNe5o"
"ao8vSvkp54W5/N9WHv+kU9yrbV+Jf/xEe5fkZ42LLZr3ZqjgFtt1AS1fSDtGjPFj/Bj//0d8"
"qYivlVCd9rTlqAChisejDSSUU0z/GD8KfDkTU/GIRzziEY94/AcO8cTumzQpdK5n1KG4+n72"
"z9Z7M65hwg/OVKSwbqBTMweEvHb0+PH/8fhTpkxJxKwSj3jEIx49b6yc9ZB9JmeqrVuF4Ife"
"5Ife74de84OfwmD/RfjxiEc84hGPnuWJeaEutPK9F0rw4QcvEbwgmTEuqOm7uHZ2TpG8x8u8"
"/J+OH494xCMe8ejBSkxSaYODsoRzX7I8lswdIZOKO23aVEl53HHHHSTVc9YHswKhP2ToULXt"
"1lsHyqVSfO68zP9svpo5a5YaOnSI2mbbbbX+SQdaJgr8ubPnSiWPfPjxiEc84hGPnjlMxQ5u"
"0Nsq3UEJF9/LvO7bIqu+KRdCxXeUAbfQJz82Rf87XG297TamkKtWDH369Lb3llxZmMrwuZj5"
"zHPPSjkkyhTRisT0r0lHgk/x26laqXHDns+i8adKJAL8eMQjHvGIRw/2xFxzsYT1XRLWm/Hl"
"0mLCJkj4QYIEN+4/X7hQ7o8NstWvhw4ZIuVNuAW/5RZbmuKQtghspfjcrqfD6vwF8+WeArf0"
"lVz+VZHgf/Ptt1JCaPXVV5NyQnR93XzzkcoEH+MRj3jEIx492hMz5XI8aSFtqlD7wWuee03+"
"Na9zY5tSPCgsuXCnVNDpk/pa0n/Ktm6JAr9xubnxzl0TXqOiskq4GwWV41PTjOLFTz31v1Ij"
"DCXoOlfHIx7xiEc8ergSk7Ablw+5RS8huLSE4yjd49ub9aYUiGkJTUiPVvMoLNdKndeoe0Wh"
"W6lknUoG1acrxafQMJ4S4UqKxooSk7I1fiT4FC7lZ/CZv2kd4Qf48YhHPOIRj545bMUO1z04"
"YZMjzJ3p7Jw9M3iNKuQ0YKMoLUqFKtXvvvuufO86r1IPK6gTVyE+HWqprPzUk0+pr77+Su2x"
"xx7ZVbYrxOds7JFHHhHlSLhyzz32lNpxQRuUeMQjHvGIRw9WYmmTk+6b0tG2grhRAQmXYejO"
"lvQ/o0aOUhttuKEoKhQY/44ZM1r1ru9jCshSENSWGokCn3fQ1G/Rt4skDIjyCXdNjgZ/vMZf"
"rIauNlQKW0qB0VQq5pB4xCMe8ejpSiztlZfAgAdUpxUJCRd4LqJMtHagOnHQhDJ0dysKfDId"
"acnAaLXVvzOdQ6PB79e/n6n3Zr3J8DPEIx7xiEc8eqwSSwclmvxMOcbsqtAqO81BWplU2Xta"
"nhdUVzYj+91R4pvWLYmgTUR34Af3yeIRj3jEIx49X4nR78WJbZf0d/Qxx0gr+Xxj3333lQ6l"
"0iba84M6xIHsdzeLXZWMHPwNNtgwLy6dWs8+5xzp7WOyCZUK1zkuFV/l1EjcbbfdpQPyzbfc"
"YlpASLKHKhk/HvGIRzzi0TOHZCeSmp62l4XTaV8U06T7Jqmrr75a3kTzsiVLlqhFixap66+/"
"Xhqx0WWTP/ckrOeZRo8oBy4U2waBvs1OzMX/5JNPpZ01ra+5HA32qaeeqm7RSuadt98O2k/z"
"3q7gM3+57KzfO3WqUcTPPPOM6mhvl+aJkrXo+yXjxyMe8YhHPHqwEkOQizAnDd1+0SnUJTYQ"
"YqMNOQ3tDj74YPWnPz1szpE8qwA8b6V/DZ7NHszBp3OwF6qG0d7epsaMGSPff/7556q2tsZW"
"3ugavnylTZWO5557Tt12223yvoceesi0Yret6kvFj0c84hGPePRkT8wmSZgvk/VHN9WkVWJk"
"HL414y11+GGHS6v0jz76UK2xxhpqgw02UBMn3qtGbLqpOuSQQ1RNtVUQXjo78SIHX9pw4+1o"
"JUFiRXNzi/rDH/6gBgwYIN4ZAT5CmXvuuacaMWJTwb934kTbqtorip+23tUS2wKbUOJ+++2n"
"Hn/8cVVTWxtczn744Yclq9LNv7nJtAnPxY9HPOIRj3j0aE/MC2oOOg8onGE4ePBgUQIoqd71"
"9WrYmsOkxBSD+1WnnHKKWrhwoWQPVldXZ2F1hs947bXXJMV9t912k7ta1DREOaLYwN1hhx3k"
"7tb555+vHtEKp0+fPlJJoxR8/n3h+efV9ttvJ9/vvffe6r333lMfzpolc1ywYIG66KKL1FVX"
"XaVmzJghF6oJa9ZYTy2MH494xCMe8ejJnpgX9mS8wKPxrRDHm3n55ZdVVXWVtBonA7BeKzPG"
"AQccoC677DL1z3/+M1N8N53jKeXBJ7twp512kjOx0047TT377LMStmxubtLeXou69tpr5SIy"
"3till14qv+tV30v+LQWf+b/wwgtqwoTz1TrrrCNJI4ynn35ae2M18rvNN99cHXjggWrYsGGi"
"hDfbfLMg1Bh7YvGIRzzi8R+pxJwiMFXgGZyNbbTRRmrixImqpaVVLjPjLTHWWmstuVuFF7N0"
"6VLV1tZmkyU6UzIGHycPhUFocdy4cfL9k08+KWFG8E8//XRJxsBTuuaaawTHpL/7JeHPn79A"
"K6e1RDl988034tFxYfqJJ55QdbW14tE5PBJVFi9eLM/Q0tKyEn484hGPeMSjJyuxdDrvl7uL"
"lUqmVJMW9Jwx4Tm1uQvOSoXOtZrlC6UUJEzkPbNy2EZB8n7an+ANPfXUU1IO6nGtaPj3yCOP"
"lDAjJaeocZgJ8xXHnzRpkvbk1pLzvMbljaJgt956a/XZZ5+padOnS63EmTNnymeCefHFF6up"
"U6dmJ3zESiwe8YhHPHq+Elv5TMlTv/zlLyVMyBgydIi6+JJLJLECpYMiGD16tPzuzDPPFGVT"
"S8KE9myk2kW68JkVfzt58mT1+uuvqzXXXFN99fWXaq+99lLvv/+++u1vfyshvsMPP1yde+65"
"auzYsfIvCozMSDmzUomC+Mx9ypQp6rrrrlMTJkzQSrZV3X///fI6Axw8s1//+tfq+OOPV5tu"
"uqnMn7M58NNefCYWj3jEIx7/CSNxwAEH+GeceUZWhdyE/p4sPrIFB/QfoKprqiVMiMe0oqlJ"
"Cu7W9+qtBg0epPo2NEgWI+dmtDihR1dQfFcDXXvtdSoXv76ulxo4aJDq16+fvIQHRxivd31v"
"1afBlILi8zgDq6utE2+KczgSS3jfsmXLJeTYGX5dTa3qr+fev39/uTu2XM+Lz+Acb+DAQfrf"
"XvIZrW2tgokCo+xUW2ubhBbb2trtZWeDrxVifO05HvGIRzx64AgqdvhWewXSOqVUowj0NnN2"
"pL0SUxTX3PFqS7SrJUuXiPLCS0LRdCRTQTFeM2yrlBz8jmSHhCVRLPJR6bRKaQ8PBdW4olHw"
"waqurlK1WiFJrzCNm6iqkgvIzMH0KsuPjxpdoXGYO0NS+qkCYmsich6W9gxOwk9ohV0tnaJ5"
"X0d7R9CROi49FY94xCMe/wlKjN5ceE+eCmoIprW3hdJq8ROZSkyJTFVEr73NJHf4xuOyjZMz"
"tQqlLYpVMjn4He1J1S4em31fHvyE7dGcF18Vxve4i5bkjltzNr5+HpJQysWPRzziEY949GQl"
"ZtumJEJaxLf1AzOVBctVMhbjvwA/HvGIRzzi0TOHnInFZCg84jOxeMQjHvHooUos7pkVj3jE"
"Ix7xiJXYf8A48MADXWSxVA8s5pB4xCMe8ejBoyomQTziEY94xCNWYvGIRzziEY94xEosHvGI"
"RzziEY9YicUjHvGIRzxiJRaPeMQjHvGIR6zE4hGPeMQjHvGIlVg84hGPeMQjHrESi0c84hGP"
"eMRKLB7xiEc84hGPWInFIx7xiEc84hErsXjEIx7xiEesxOIRj3jEIx7xiJVYPOIRj3jEIx6x"
"EotHPOIRj3jEI1Zi8YhHPOIRj1iJxSMe8YhHPOIRK7F4xCMe8YhHPModNTEJCg/bDToe8YhH"
"POLRhTFlypRErMT+j8d9kyYpp8kS+j/+93nFz/45Yd/k82rCN//KC+77kD5MmPcdPX58jB/j"
"x/gx/n8tfnePOJxY7vCz//VVZsH90Jv80Pv90Gt+8FMYLMaP8WP8GP//A/zYE/u/GZ7vZ3/v"
"KZXxj/UPXiJ4wRMjhJXFFPHkn/C7WVh5j5d5OcaP8WP8GP+/FT9WYj3B+dKL5dbN+snWyPBD"
"brh41fJae0eHeumll+T1AQMGqB123EHN/2y++mDmTDV06BC1zbbb6vVPB6scBf6c2XPUnDlz"
"I8FXiYR655231TfffKNGjRqphq21llowb0Fk88+HD+fPmTtX1df3Umuvs47BjBB/rqYN9Bk4"
"EHrtaDagryLDf+ftd+TnIUO6jz78+uWXX1I77LCDqu/Vq1vmzxg5apRae9iwSPGXL12upk6b"
"1i30R/DO+mBWIDSHDB2qtt1660A4/yfwv+PPKPCnTZ+uli9fHsiv3b+/u/rmq28im38+/Pq6"
"ejV7zpy8+zcOJ/YET8zzZUP4/Ot58pX2vczrflp5af2z/tfXP8+eM1uE2ejRo9WWW26pGpc3"
"qqeffUaN1swzVwvqWbNmaj6uUmlhpMrxF8xfoKZOnap/3lataFyhZmlmZaN0FX/G2zOESUdp"
"Yfb008+oFSua1DN6/ltsMUotWLCg4vnn4nd0JLWAm6pe1or522+/ZeqyYaLC//zzLwx9NP07"
"2jvUNP09G8yTjRYN/kxN89Hbjo5kffPRBwGD4EPYrVixQuYfJT7z3lbTZ8zoMWpdLYSipA/8"
"M+XxKcI/7e3tkdN/9dVW14J5G6E/r/fp01voHxX+okWLhf+j2r+5+J988mmk+3fEZiPUNtts"
"rVZbbTW1vLFRVVfXRLp/c/EbGvqq1wvs31iJ9YCRZlHt4np6YXz9r58238uCp83iOyZoa21X"
"8+fPVzNmzFDLli1TdXV1YjnPXzBfNvHgQYOFSZ0lWin+V19/rS2soWr11VdTA7SlO2/+PGFS"
"ZwmVi//hrA9lngjmnXfeWQvOOWodLdiGD19X/p0/b75KVCUiw+/Tu7ds6LXXWVtVVVWpKhFA"
"vmyiKPCZ5RZbbKFWs/Rpa2vT86/qMv07w4fkbODe+nkqWd989Fmg11usX41fVV0VOT40efvt"
"t8VAQlAJZtqLBJ+519fXy8/QBlox/6jWt3efPmLUffrZp9rTG6i23GJL8SH8iPDB7BXh/s3F"
"Zw+jEFZfffVI9m+/vv3VKt9ZVb3//vtqrz33VB988EGk+zcXnzFq5MhO92+sxHpCOJEF9LFO"
"rKWS9oPXPPeaXTRe79WrTm200UayWf/3f/9XWyeLjEuuGZ8N8dVXXxlp544/K8TfeKON1dda"
"kT311P+q2bNnS54QzNRVfATauuuuK17eX//6V83EaRt2UGLdIuTMJosGn5/79esnuL47IBYL"
"0IsEHwW/+eabq+eff1423rbag/VdGCVC/DfffEu1oiAloysRKX3eeecdteOOOwQZZFHOn5/h"
"JzwBvn/99dezj+crxG9qahbeHzNmtPyONfAzMavK59/aKjw6c+YH2kPYRr5PptKBJ1Ap/jdf"
"fxPp/s3F32TjTez+fSqS/YvywdtDsQ9ZdYh9ry9fUezfXPy0pnVDQ0On+zc+EythHHjggdxF"
"6NZwYnZuTjqUwZM2VplnT0P1a1jMhGbEItdjvrassLR4jcWVTeB7gaVYKf6XX34hCg0rCwHB"
"RlMhS7RcfM7ZwFiLsxhlPAs+k7m3tbYJ8/oVzD8Xn03dR1vTvg1pBBso7UWCz9yffPJJteGG"
"G6qf/exn8loqlZTNFwX+e++9J8/wgx/8QP39739X//jHP9R6660X2fxZU57hwQcfkp8RfAcc"
"cEBk9P/kk0/E0/jOd1ZR/fv3l8+q1pZ6OhUNPuE98IcMGRrgK9+PlH8+//xz/Rn1YlCkUik9"
"96QI3yjwP9MeXpT7Nxd/4cIFEomIav8y/vnPf8p8UVoYiHPmzBEjNIr9m4ufTHYIzTvbv7ES"
"6xFnYim7qAl7+Olbe3jlzFReq6utE6UKs2Khs9j333+/eurJp9RXX3+l9thjD2MVBZusMvw1"
"1lhDPfroo7K5CFPsucee2hJNBh5UufhbbbWV9irelK/NR25uzt0WLJDPQAAdccQRKqWxo8Ln"
"OZi3HC7bjeDCG1Hgf/nll4LPecMzTz+tVll1VTVKK/2o8DEgWF/CQhzWu/X1fT8SfM4+8TAY"
"t9xyi4SgTDgrGvzhw4erP/7xj+INQKfvf//7kc7f8Q+GxHJNo333/ZG8Pyr6wz98v/baa4sA"
"RaAm9Veii/s3Fz/q/ZuLv+aaa6pHHnkksv3b2NgoXyjFVDolXt/cuXMi27+5+NBbwpCWZ3L3"
"b6zEeoISSxsrRPa0O7VMmCVOuAyoRMIlHmkBOUpttNGGcu6CVcXCHn30eLXo28US88YqFWvR"
"MVEE+OPHa/xFi8RixDLqSCblM7qCD3Oura3EpuZmsWw7Ojpk4y5etFjOlWDOZJT4gpVUO+64"
"o+rbr69sDC+dzgiJCvGhz6qrrqKqqqrlbxv69rXZVn4k+F6I/u78pJL1zUd/sXS1cDjkkEPU"
"4MGDVSqZjAwfOo8ff5Tw59DVhooiSHYD/0CfQYMGyRlxKmL+IVTZu76Pmbf+Em+gi/s33/pG"
"uX8L8U8U+7dvQ1918LhxqqamRtMiJVgYJsuWLo9k/+bioxDxTNm/eH25+zdWYj0ksaM8z81T"
"verrVXV1tYQ65FBU/4eAZrTaGL7bBFHhE6oB27PWqBPSXcEnJg8e+MxTwhL9+wk+uMb68iLD"
"5/yChAV+dlZuVPPn5756c1WjxKzySoaUQBTzh/5s4KjWNx99UGK1tbWqWQs/c+Ae8fz1+jp6"
"pUNCKDL+seeevBY1/8Apbe0r806U9Ily/+bDj2r/Muptso5bRzylqPZvPnyUoJNH+dYgVmJF"
"Rneeh5lFTgclWHzrapuiKs5C8cPhYnvmooVyVSJzcGrfkEiYrKDwoWfU+MF9lArwlRwup7Lw"
"k36yW/Ezb0h0C35CyuVk5p8REtHNP6r17QwfocHadxd+d69vd9OnO/nn3zH/qOhPZinyQXhc"
"QnxKvKZuw9dvSPvpvPSPlVj0oxzqipbwbAKA87YdwsxZH6oLLpigZs6cJT/jTs+bN089+MAD"
"ao011zTWVJBLllB+JtxsXXZrmeXB32233dT8BQtWmtBPfvITdcXll0vMX7KFysS/88471NVX"
"XyM/P/PMs2rEiE3EEnv4Tw+r8yacJ6+vs/ba6rXXX9eMmtK/89X5EyaoP/3pT3Lm8PrrU4Nw"
"QS7+nx5+WE3Q780dHFqfe865asx2Y43VZkM9nqe6RJ+jjz5GTZs2TV478cQTJZvulptvUWsM"
"W1PwE75fEf5uu+anPeO3v/2tOuzQQyWE0hX6u/XljGjC+ecHz/GbX/9Gvf/B++rwI45Q248d"
"K4LF4e++265q/vwFsvaXX36F0D84aM+Df8fteo2vuaZTpoZPodmvf/1rdfwJJ5iMNU+VNH+S"
"EHbV9Mk3fv2b36jjjz9evz9ls9nKp38u/jrrGJ7jgjfXStzgXtWaa66haeFFur/cGh+q1xj+"
"93xVMv7td9yhrilAdz6PCIBvPceu0OeNN6ar8eOPLkoft86cdcpzpP2S6bPBBhtm4cCja6y+"
"RpDtWe7+6u7x/2OKfaKML2N1cG/GHVimfRHsn82fp4455mhJVf3Xv/6lFi9eLAe2MBIVNYgX"
"i7yWsIMnjCTMy4XBVNpcInT3cPLgv/LXV0WpcCjLYeySJUvU9ddfrx7QCvKuu++WsFJX8I87"
"7oRAcJ500ona/W+X7w859BB16623yue9/8FMudfja/MK/Msuu0z9RgsoQiANDb1VtVxUXRn/"
"sEMP00rcbKQbbrhBLVu+TGiD9Xei/izuyiV883xyF4n7J2XO/7bb7hC8r7/5Wmi+cOFCuW9T"
"37te1VRXy86qBJ+/eeXVvwrtd9lll4D2nFccffTRqrWlRdXW9ZI5dBX/M02j/Q84QC4tc3mW"
"52hqbtJGxTOSLl6j19ZYuwb/lVdeVTvttJOq1TzVu3cvVeWrgvhcQD3yyCNl3r/73e/kPRzE"
"v/vuu5JkceONf5CzO3d/US6mljj/NddcS3366WeSzHLxxRdLMgvzP/XUU9WVV1yh7rnrLlVd"
"kz3/cujj8Hle8N97733hdZTuySefHKwJVwIQX769z9bV/ZVvjVtaWuXcy/F/qfiNRej+7Tff"
"qJqqqor4c8yY7YQWnKvtuuuu6gO9V1lHXsNYvPiii2RN9t9/fwnvmQzmRFn04fL1UUcdFdCG"
"rF45M5P7Y+my5x97Yj0isWPlm+d3aquL8cQTT0gpndbWNnXWWWcJA8G4VXKZ1l4YtZZJwh6W"
"quyM1rz4qaQXpIDzZ2QtjTt4nPrVr34lVjybzBz4l4ef8M2h7o9+9CM1a9YsscZvvPEGuUC9"
"6aabivVG/Dxpky2Yv69UEP+X5IhEIgvTfe9TMC1pP0fScn2Z57777qs9iMsl+4qD/XRHUgVT"
"DVlupcx/+vRpsnm5UEn8/eabb5aNVlNdYxSLZyoNdBXfhGp9ob2L7be3t6mO9qS67PLLtCKp"
"Dc7TTEZW+fh4w453yKxra2tVZ515lnweig0aBxdPpcCqPR9JJOR3fg5mLv6ZZ54pwsslhLj1"
"IIv12WeflQoOfK5cTLV4rHPp/GnObxx9OGdh/lw1+MNNN6kjtQBEgJL11hX6uFCvqx7Bc/DF"
"mZRv7yvxs0ntTle0v4I11sZce7Jd+BT6pCRFP13W/s2me3IlunPBmBR3cxbld4k/eQ+Xom+7"
"7Ta50nGRVlpnn61p/+57sqanaGMimUzJ+SOyiHVQZa4vLOOFqm0IrfWeTXkp43dl8j5Kmn/s"
"ifWExA57iGu+TFbSn//8vHgtZIo1N7do63e5CKALLrxQbb311rLwP/3pT9WIEZuqEVo53Dtx"
"ornJLp5COvtgOA8+jJi0h7uUBWpuaVb33H2PvJ+UaLKYsJAmTrxX8MlaQ5Cbagud47O5UIh9"
"+/YVjw5Beuedd6mqmqpA6LVobwPB9NBDD8n8KbeDwnMbvjN8/haB7F5DyZDeTmo1lj/WInM/"
"5JCDxcpGaR533LHq7Rkz1JixY+XnF198URI8shIXQvPfbrvtRNCcccYZ6m9/+5vMdaKm7apD"
"VlXnnHOO2mSTTdQll1ysDj74YMGDPvfo5xwxYoS2YsfYi6qqIP1d5pYToBdddLGaeN9E1SLr"
"3CheJp7Ascceq72EGqlaAP6999wrisHzvYL4f/7zn8WTGaR5h/k3Nq5QjU2N4s2M0/NO6s/k"
"vRdqXoL+4w46SASSq5hQjH+YP8kfy7RyZw1EEGmBz2fx2rKlS2UtudO28cYbqQ032KAs/oQm"
"LvkAfD5r+YrlQl/m+dFHH0m4Dvoz/3feflvow8/33ntvwfUN4/MzvMpnkLTBmY6siX0NpbnX"
"XnsK/++1995q9j9mG6FchP7h/RWs8cUXqfsm3ScZgyv0GqOQWGP48wxtODL/F//yYsH1NXRv"
"EqPKRTh4zdB9mbpL7zP4/2BtjHaV/9m/PDs4hG/x+Chddd7556krr7zS8JP+fD53qV5n1oE7"
"i8cdd1xJ8sHRH+PAGHCG1ih4shgJo7OmzJUKL5MnPyr0hz61zgPPwY+VWI/wxLzAKnQWMow6"
"UHsVUgZKbzCT2psS4c99JDwELCMuYVIe6g7tuRGuMBZqBqszfJfdwxnbKqusojZYfwNhWM6c"
"TvnlKXJ5kcH9klNOOUXCaliqpeD79tb+xhtvLHiXXnqp+ufcf0r2njC5ZmA+FyuPECOhEEJd"
"WFoJez+pED7j9NNPF4uR+00DBw2U5JujjjxKnXfeeaIQSbl+4YUXJLR5t1YyH2vBRwjpL3/5"
"i4QyE1KWaGX8n/3sf+Qc7L777lP77befPMOtt92qWrXyvFgrmx/+8IeiJBCWPBt0ZxMiWMF8"
"+eWXxTt0WWKd0Z9nROmSAn377bfL33A/j3X+6TE/Vfvss4/QmkoFr776qqx1r/peYom7uXeG"
"D++496D0KZe02YjN1AZamaw1bJiEbidPniwVRh5++GExjgiZSrkpm11ZCN8ZKnwFFrWvgtRq"
"XgcD44IQOLS65uqrJSxYKn/6vh9UDUFoodAa+jQE3sJbb70l4S0U8V577SV8NOG8CWJ81Npw"
"aTF8wth4MazxyM1HqmuvvVaulWCE8D6w8PIxTPb/8Y/VqaedWhL9w/sra43rekloDhpdcMEF"
"6he/+IX68MMPgzt633z7jfCmm3suPjQwdG8LfufWCswD9j9Ae01nV8T/bv7gEfokooKCOuaY"
"Y9R6w9fTsqg9yBB0l+QxVHkO/oX2xfgn7IU5pWcqeZjfPzb5MfkdBQqYA8YjA+88H//ESqwn"
"eGJe2FLJWEjurhFCnwXmfX9+7ll1x513iCB97rnn5CIjlyW55PnWjLcCJspO0V0ZH4sIF53Y"
"N4yIAqQkDecCnJ84153KDWx2btAHxTvT6aL4kmaLQNbeIoLghBNOEGUMLJbm9OnTRTAfpL0A"
"LklKjUCrxIrhM1C4hFW5/Dv50cliueGtImTwysDlojaDiivQhQoGPCuCRIVCmGH89vYOrbR/"
"qY2Dheqxxx5TP9bC6+qrrhYvyKW5M9f1119f8PEMqNLBZ/I8zL82OHMqRB9z7wVr9rTTThMF"
"Vl1TLfdhuIjKhgWLTcv7XXiOn4utr5uHO8/h0Pzjjz8WoY/w/P0Nv5ef+XwsaRQaXr8zIEpZ"
"33RwV8fPVnySrGP+Djo9/fTTYgxAn+lvTC+ZP+3NdFuKyBf+X7psaUbw6feg6BGcDJTFYYcf"
"FoQGs6845MfHCIH+8BAe/fnnn6+9RcP3KHXC6ghRPo9IBIYXe8QJ0lL2V3iNa+tqtbdSJXwk"
"SlkbKI5/UPC//OUvM9GIIvTJVWLGi0lJBKQS/nf44pFpgxkcxvd3/77s27bWFvG6fSs7KEvH"
"OqMgZ86amYVdjP/Dl5edfIN/GvoaYwU6w/PuaklNbU1e+RCfifUQJZYb4917773lxj0bwPP8"
"YMGon8eNeFqlIJDwSCQjyTIEVrUf2mCd4Rtrzw/uNBGycXd4UD5Je9YB4+P9wfxOOHg2+6kz"
"fC84mDV13BAOCAE8gJEjR2Zi23YwZ3dvxRQCLT5/dx+IvyV048JczBEFwL88k7NqwyE85fuB"
"IMzF58D5rrvukmfYXFvnhPZGjhwlpb3YoPwdm8qFQRy+8UqMkk/Y1/LhZ9PIhIPOOONMmb+5"
"36Q3p73o6vCweBF2gQWas4Fz8fFMsMKXLl1m55GZn5uvS/+HJtAw40X7WXMvxD9SKT5HmMrZ"
"iP0tgg3eWWrDiyIQamqE/sXXNxuT92Pto6C33GILWV/OLsn0w1PlvXgYTU1Nptah55WED10I"
"1zvv0tHXzRdBKtEPqeyvRKjWhLyBUvcXXp0JgbfL+rK/oD0ZuSgzDDI+h9fYf57vF5x/Nt0z"
"9OSzKuH/3LNDqXRjlZIxEJIBfZg7niy8KXLB3k9LhBRkIfqrYJ9k8xtYYUUI/7ufg/X5N8rn"
"2BMr+0zMfGEBwhxYQq3a+sFCnDhpkvriiy/UVltuKVboJP0z2WdsXDwmvDNzQTCVxRj58MPW"
"HEwDBucZbjM5RnICmg3BlzlPSBfER4C+8cYbgsXfEyu/6MILhRkRCnxR6sjVHERxuIzGXMGV"
"D9/Ni2QXKVGjcZr1/NvtWQe4btO594Yvd+Zu/DA2wgqvEQOC+P9nn32mHn98itpss81sZXpf"
"hHK4IoE7rwiwfa8o/Z3CgLaN2oNcumSJuunmm+Wzq7WgR1FSHRxLl/M3njMTai1Mf+c9jBt3"
"kDwDQuVurZgJM7kzH8728F6ok8j7yXrNGBHpkvgnHRL2fo6XzusUnKV1BmnYrAmhKZewUgzf"
"GGUqEFp/+MMfhK/wVvA2oBthcM4wCaHhMTN43SUMFcOHB0x4vlEiGczVPQOePQYce4zXiBbw"
"M0aYX8L6hteY9jys3xLNNzfddJOssSjzINEhFShKc9E5VdL8M2HHtDFs7OdVwv/5vlxyRsqe"
"S7vPhz85N+aL/WuStryS19fNxbdrzNnzSSedpAZJbUdT05NsTGjvDIh8+LEn1kPOxHIH5xec"
"83BA+73vfU9eY8NS247lR/Bwl4VQIuOSSy5RY8eONdZ82ssqupkPf9y4cXKexuBsiZDhD36w"
"j2RkLVi4UH7vMqIQRnxukDWXCXauhI/A4ryOsdVWW8oZ0YD+/aSWIJuXTeoyoLBOibdjXSOc"
"EFScDyCsXNggjI/Cw/J28+L9ZGWlyCLT73nyyaf076+U35MEQPgn/Ayvvfaa/HzY4Yer22+/"
"I/AIc+mDQITu7u9POOF4dbj+G4QlZ4QMd2ePwRpwj4bwE0kh8hmHEdrKv75h2rsirW7wOQhp"
"7hFxCM+9KJQ8AoM15nd46b7fEVyIzcVfddVVZeOzpiQBMVDCDzzwoPr4449E2GH0QGfmSZiR"
"sysnsM8991zUQXZZrjwj/Bw0iuTZmVtSyjSNEbqgDBism8to60imOuVP8BzvYUhceeUVwXkI"
"njzJKRhcztCi3BEhRbwy5xGk0l6n/JmL/+CDD6jnNA/9cN8fBs9CE0kiHYSsydZF8RCa41wL"
"/Fa8qXS6U/rn0mbYWsNWWuOrrrpKEpsYJFFBe9ZIPDHP73T+udhDQ3SfPPmxgF6V8L8bV111"
"tabt4/I9jS7POedczS+HinJkLZEJGFiuXiJGCoZue0cyK0MyFx855QbHIbm0WV17d2Ric5ZO"
"aJRIDt8jBznT84MIwL/HH0v8u0qD9IRx4IEHOu4raaCk+JszzjwjqwJmwt4K5LC/X99+qk9D"
"n8BqcRlKpKzX1ddpBTFA4t3Ew0mvZYNzrmPyVH117bXXqXz4tXV1ko4OPgf6JuuoUTXrf7mL"
"Ud+rtxo0eJDq29AgoQ9TlHO5hBOC4p158DnX6a8xB9h7QjA191qwkOt71at+WhhhSZGcgp8+"
"UM+/j/4M0oPdHUZaa5Dh1pFsz8LHg4MWAwcMlLMvGJl5iWDk7pz2+KhbOGgQNKmT1/BgeVYp"
"JKppx+vMn2dZvnyZ3vS/zZp/7z76uQcOEkvZD6X1SvhQ0xes/lopYxWyFoSW8Jw4J8CarKvr"
"JSFBLPsVTY0iCHLp30vPAfogCByOhGISVUIHPO8VjU1yhjJQK3jwOUeprqoS+i9bZjzPtJfq"
"dH25C4bg53C8ynqQnD0kJTmgVbW2tKmauhqhpSSi2IojLrwIL6TSyU7x+ZG/wwDhOVzYjbm1"
"tjar2po61bd/X3nWKnu2wXPxe/izM/7h+XtrPiGpybXfcF6uXHtoN943wo6zHs5lOM/FYl+2"
"bKnwTnAPtgR86O48oD69+0j5MCpFwLecDZMR52iI4pLX9WfAS6XsL4yO8Bpz7xN8MQj1PmAu"
"rBXZwfAMd8jkCkcn8w/zjyQ6VFWrFqHrMvH4KNdUCf+H1xe5gnzoP6C/7GWuCRCtaW5eoT9X"
"77V+DZKswl5h/Ts62u36txWUP/X6b6C/O+tamf9bZa9xN5M1Cqf/I9+WLFkqGbYOX8vRbr32"
"HHtipXhi3Cex3BNejZZWE8tewWaqNvdtTIaS8bY6Uh0q2Z4UYSehKc6sNCNnmn77neNroUs6"
"N8rLhQtcoVwszLZEu1qydIkIDCdIxIJOeyE1vTK+SvmSRoxQ546QJEuQUksqMKEs/Tp6ASxp"
"yqD/dkXTiuB8pcp2zOV9gSdm8c3Bcqtakk5n7h+lTAFS5p/U82zRwiCl6ZKwxXhN7y0X5vOD"
"g3ueJwiZhuYP/iJbcgsMd/7BpiGcwoZta2tR0qGyE3xzbSFzhyqX/h36vxUrNO3xStXKZ31y"
"9qDnltCyAMFRVW0bPJL4wjlaKilfgSeQZ33T7Wm9fkboMmded+EgjAipRKHlAPzDgbnLBkxY"
"Hkvae0yF+JN1RQG453Dp5EJb/TfwZ40WdjW11YJcEn/qR2pPtItCcudQ7hDF8zP3t9YcNkxd"
"ccUVavvtt9dezEQRbi1a8KVT6YL8mQ8fxZ624WEUgrK0QigTdoCn5G4XPNbeYSqa+H5Z+yt7"
"jT3rLfpqhaYPgtvtE7lbVmT/5vIPnnWSMKqtIVkJ/4fXF3sVRd6eNMrQra/wh9K0WJYM1hfl"
"LDJC08cLSmZ1Mn9oI8qwOQ9t7Brrz0Cxi7GbMOFPCeenTWsWkzwU107sOUqMTB3YzVNBjTPT"
"siAlDMBhsKkzlgkyUIQlKcJVC8oW39Yms7XIQJO2B36n+FjxHclG8z4XvAjhe1pRuvYlzjTL"
"qnXWCX4KAZlslQ0WzMPip/2ULZWlbBW1hH1vS2nz14/amm4TL8K1dMiav/Yg062tdnMb/Lzz"
"L0CfpKYLNM2LnzAXM5tbVJfxwSADqyPZlBc/vL78DZegy8V3/JPWQtgojc7xhX+6iu9pgaYl"
"XX58ozCV3142fntbh/a4OgrS5/LLLlO33nKLJHPAPygxzvo8W2uvS/jScDSbPvzQ1tEW+f7q"
"Lv6Re2MV8H+W/PG0qtLGpt/cknf+qZQ2TPyOsvHh6XaJ6BTmf/x1PNNi+LES6wlKzNb6S4RW"
"0Xe31FVXN4FThDF+jP/fh080grT0mppaCXvisUrWWkyf/+/w4zOxHnAmFqvxeMQjHvHo2ojP"
"xHrAuG/SpNC5p41hKz9oX+B+dt6z2C8JV+HcWDQZmyZzgMprR48fH+PH+DF+jP9fi9/dI74n"
"Vu7IPtO1tS7NgvuhN/mh9/uh1/zgJ5X/4DPGj/Fj/Bj/vxU/9sT+j87EQiFX+T6cAMgPXiLT"
"m8fGiyUg7Ntmd1kRTN+8x8u8HOPH+DF+jP/fih8rsZ7gfNmOgcGCBdm7fvh6RaZjaiKhXnrp"
"RXltm223kbtX8z+br2bOmqWGDh0iFxN9SUFNRIYP58yZO1fV1/dSa6+zjk3vjg5/7uy5gk/b"
"mR123NEwsB8dfd55+x2pkTdkSPfRh1+//PJLcvHZ9dGKev6MkaNGqbWHDYsUf/nS5WrqtGnd"
"Qv+ly5apWR/MCoQOF6O33XrrQLj9J/C/48+u4lNVhuo6XD7ntWnTpqr2trbI5l8Mv9L9Wwy/"
"0v1bDL/Q/o3DiT3BE/PMHQ7XCkNK3/he5nXfFAD2fFOu5bEpj8kl04032UTaJHB59JnnnlVb"
"bDFKqkbMmjVT7m24QqyV4oM1VTPVyy+9JKV5bJZ9ZPjffPOt4NOShXsm06ZOFQZ1902iwKeg"
"6+htR8tG6Q76kH9FS5C5c+ba+0eJSPEREFTAGDN6jFpXC6Eo6QP/THl8itpCK0euVURN/3XX"
"WVdtrYWRFKrWwqpPn96GZhHh02oG/od/umN9FyxYaPhz9LZyb2mW5iWVKH1933lnhiRxIYS5"
"FEylHSrrrLPuulJlo9L9Wwy/0v1bDP/bCvdvKfiF9m+sxHrASEuPpVCbCOlwmmnpIB1Opaad"
"+febr79Rw9cdHlSgf+vNN0WwDR++rrw2f958uUDpLJVK8WF8ShOtvc7aptGhCCA/qGBeKT7M"
"S/+r1VZfTQ0YOEAY2NQpVJHicz+ZDSzdaBOJyPChz0ItfKiiD8mlpUnE+Fil9FeaPWe2bV/h"
"BRX9K8X/+9/+JvetqEIObaCVNCaNaH2Z/2ra+6IOJWWEttxiS7HB/Yjwm7TRgOe7YOF8UcKD"
"Bw2OlP6ffvKJlIaiVBr8OW/+PBGipe6vESM2Dwpfs3+oYbnFqC2kBQzz/VD/XMn+LYa/qML9"
"WwwfxVvJ/i0Vv7P9G4cTe0I40TNBYs/06FYJv8rEhbmpjh3g2fJHvokX43K/8JcXRCCIgx70"
"4bIXC6VcUlXm+LNCfG7rY5ka99/1efKDihGV4tMqhFJOL7zwvJqnN/DBhxwS9JKKFv8F1SoX"
"WhO2dWx09HnnnXek1xgta1weVVTzB58NTdFeiqJSuHfM2O0imz+Xkvk99fZoBMlnbLf99pHh"
"u8LFWNOuCDAVPZwlXSk+lR9MebCEvEb/rzXWHBbZ/KE9bY+oP0h5J15H2Gp3oiR8135G2X0j"
"NKlKBPyR1UevC/u3FPxK9m8xfNr4gN/V/VsqPv3v8u3f2BMrYVCjrdvDiWmsk7SxBqk8Ic0A"
"ffOaMpXL5XXbrp3Cp1hXDIrISmde2pO0tkncWPr1eH4k+Fihxooy1rNvG1+6wp6V4hNHv//+"
"+6XuIL2V+vfrp9JUIk+lI8H/+uuvpIki7dZHjRyl/vGPf8hmimr+X3/9tVjsDz74oPxMZfhE"
"yNOoFB9rlDqFVG2nXh4/V7PJI8KHf/DE4BvwpcWM70fKPzRZ5RkoWCuV0ClrFRH9qdYBLuFK"
"2oNId+0I+R/e53vw+Ry+VBnr6/nZbW4QyMtsnURXf9LsX9Wl/VsMH7xK9m8xfHiGJrJd3b/F"
"8FnPQvs39sR6xJlYyrpkiaDcUVBkNycz1TXKpJozFhYdXDfccEPpLEzlcldROpXVtqQy/HTa"
"lRBSQSHZdLhza4X4MKVpSdKonnn6abXKqqtK1fuo8LHk2GRsDEKLvOb6r0WBj4e02WYj5LdU"
"9qZJoLKWdRT4VKWnzQ6bGTohYKOcv+MfugRQhHbffX9kSo9FRH/4h4rqa6+1tgjQlO2nlYiI"
"/1lfPMinnnxKfaUNFre+Uc0fIR2m/5577Cm1JcvZX55rAKm/6EZBdwcMB8Jo0J89UMn+LYTv"
"WrFUsn8L4Uexf4vRh+4YroFp7v6NlVhPUGK2qK5vq9ebCtBmiRPOzXbhDv3Ptttsq1pHtsoh"
"KFYLljMLu2TxEolLh5vgRYEvBXz1pt1hxx2k8nQq6OrrRYIPzne+M1gqY/MmKtEnQqGFSvHZ"
"sLQzoUwRoSCsO9cXKSr60wOK6AfNPwcPHiwFj6PCB+eoo45UixctUUNXGyqKIMr1dfwDfai8"
"TsXyVMT8gxfT0KfBzJsmrrYUUVTrO378UUIfzmSiXt8w/+BVUoC2o0z6iFfnm47Oq6+2ujrk"
"4INFUYEP1p577iHz7+r+LYZf6f4thI8CWnXVVSrav4Xw3fouWpR//8ZKrIckdpTnuXmykGwy"
"0w04JSGRfv37SSjEt8yQ6TxbOT4uv/s5aJ7o+5Hgw4z9+vWXn11cPLu9fET0sa0fTOPBdKT4"
"ng3/EN/njCa7s3N06+u6b4ebmkZJH9cxO2r+4YyDNiq5vBPl/Pv269st65u2IUc8MrBzm0yW"
"go+w5hzNrR9eHsaCw4d/Ktm/xfA5f6xk/xbD72fbwnR1/xbDL7R/YyVWwiD9s3uVWDoowZJp"
"iOFnV43POcZM2XYh7uBUKlj7ySDBI/zuqPAzb0h0C35CJbLmn9lk0dJHju99r1voY0Kv6W7B"
"/3esb3fTpzv559+xvpXQP5UttjV+KtL1LYZfKf2L4Ve6f0uZf771jRM7ekI4MZW27b9Nryc6"
"Iq+33npquP5ab/jwzPf668677pJ/11tvuJo+fbpJlbWHnGmxEI3V5ayvfPgPPfhAXvz9999f"
"vfHmm7Y3VFpCENJryUsH+NIWvAi+Z8MVr70+NQufbtRYg9wjYf6cZfD1xZdfmIaMZK0lU6aB"
"n/3cXPzbbrtV/hbMjz7+h2wLLLcHH3zI0mU9tesuu+jPqZK55M4f+qTSqYLz32XnnfLShw6z"
"NHj0hQ6pTulTDB/60KV4y622kkaXstHd39tW7Z3hl7K+t916SzDnrbbcUp1yyinqvAkTJO1Z"
"+KUIfrH5O/rn0ufaa68V+px33nnynp122smkWiu/S/xDz60P3n9POm07/oeHdtHr+/nnC2Xd"
"//raa0LH9YavJ9lr7n5eMfxddt457/7ii+7dyEpoVA79X3v9tWBv5qPPxyQkcHWhi+t7i11X"
"8FlT0zPM3rvSfw9PuWc4//wJ8gwpi7PLzrvY18+XKyDyN3noM3Xq68H877jzLlVle5F99tm8"
"AJuvL774XBRJeP6l7F9H/1z6fPHFl/bunVc2f8ZKrCeEE7n3Yw9cly5dJnHgF196UQ4yEfIX"
"X3yxJCVceOGF6ovPP1dz5/5T/o77EnW1tZL9I2cy0jJdf8E04Ll7RCF87sQccuhhcteFccMN"
"Nwj2v/71L7FyTjrxRNWrvl6+l/szwlBeWfhkHZF9NHa7MXI3iLsvPAMpyoTbtt9hR0kTJ77N"
"gf+GG25kzCwJcRTGP+64E9S0adPk9ZNOOlF6rTEOOfQQdeuttwq93v9gphwK+36iS/N/5dW/"
"aqF/nmBx0E5n6uuvv1498MAD6m5tRFTX1FrF0zX6SAWLD2cJ9osvviiK3RgiacGQrC3f7xL+"
"1Vdfo66+5hpRKMz78ccfl3s2hDi5S1UllnHX8fmbTz75VM6IMHocfS644AJJannxL3+RbtYo"
"MsJDfXqbi81d4Z958z/TSusY4UX4kzOp72qFNX/+fNPJu6ZGTdCfc9JJJ4miI8GgV69alXCX"
"awvgv/LXV2WNUYjuGegQjZJ0WXHl8s92Y7cTYe/4fdnyZTJnrl1sqY0J7vrVSZfuRJfof8Lx"
"hvfZN08//bQW8B2WtkagY9QySND5wx/+oPmqVrwc8F955WUxKmpra1Tvul5Bg8lc+owZk3mG"
"K6+8QmQN67jmsDUl65bPfv/9D+TaAeLdd4ZJmev7yaefCA85+m+40YYm0cPzyubPOJwY/Sgn"
"ZcasWyi2SzvzV199VVqiu/i1cak1E//8BOOS20+Qi4vWumahE/awNFPWxR2cZ1ssYkF12PsY"
"CeOas2n33Xdfdfnll0sWFgf8ntdhD2OVcflLxHdvkm6vynSPhfndgTVfXBzlMJdzBpr4YcEF"
"Me4C+AnfYHDfiEuRv/71r9WNN96g2lrb1aabbqp23HFH44HZw+y060RdxvxTKT9ID+ZvyLw6"
"eNzB6le/+pUoBGjF4b5c3OwCfbhzdMThR6hHqh8RYbTPPj+QflgIIre+AVQZ+MztjjvuUBO0"
"10WqMzTYaKONtPd6mzr33HPNmWPCdBHuCn6GPsZTd2va1tYqd8wYn2sjC+XiznMyn+mVzT93"
"3nGnfPfEE0+ogQMGqlb9OWeedZYYAWTCURmFZ/7u976nztKv81xyhmINgkL4qaRnuijb8yHo"
"355sF/6XLs62s3U5/COhsWRH5gn0nuX8BsPt2WeeVVU1VWad05lwczn09xOG99k3PPdzzz4n"
"hgRY06e/oY3D7dX8B+cH9IdHUylz3uYnXXgvoedhuj6ng8SO0P7Sc+DvuKrw3e9+VxuNx6ln"
"n31W1WrDbfU1zJ5de+217FlkUvC7Ih9SyUz2KG823cw7TCp+mfwfe2LRnp0lyvkKPDF7SJm2"
"bjRCE+tkqb37JZuzvU01rWjS1t1ytUJvYMbf/vY3tcYaa6iNtaC6d+JEcxPfC4Vr3MFqDj6u"
"vvNgzMZvl5AeFhyCCff+9ttvF6UwYsSmaqwWUFSLQMCWgp+21hOhAJ7FHYTzPZcVk5ph3YEt"
"7dvb9EZ3rdmdVdkZPhsHHJT9XXffLQLuTsIeWkC41ulgjh07VqzFG274vcx/xIgRaspjU6zS"
"9wrO32WGuVbp4N19z93y3uHDh2sFvJqk/UKTyZMfVSOETiNko7szgEL4WMwYDHzhKTU1NatE"
"dUItmL8goPm9994r3++1157q7Rkz5AIpP//+97/XnmB1wBdhfNLAGeuvv77Mf7nmE4Q9BsnE"
"SROlZA9r21V8N39D57SEj1iL5uYWNVHzHwIOT8a39AWD14drjxb6HHvssSJgCS+Wwj/P6efB"
"Gybbs6mlSZ6lUSuuCy+4UO5qbbbZZvL34w46SP3ud79TzZqOrJXLXCuEj9GUtMkTPM9FF1+k"
"7pt0n2rSHiv7C8+VZ4FWe++1lwhzEhdMtZT862t4PJN4A4/zd6SLr2heIUoZD2fcuIPEU4Pe"
"xx13rNB/jOZXfsYzD8J9efGNEsTzfOWVV2wyVEJ4aoftdwjez/v4/AsuOF/4c9y4ccFdUodd"
"aH/xnquuvlp+j6FYU1cT7M9W7alC53fffVf4B/y99t5bzf7HbKO0iuwv/u3oSAbJK5TdwkBJ"
"8pr+3fx584QWfE2ceK/gk/Vbo42LfPSPlVhPOBNLe0FNMWdBwUgIUz90fwImYsPxO8Yll1yi"
"jjnmGNlsd2oLvKGhwQjpEFY+fFfuhXH66aeLV0Ra8aCBgySJJaU3OKG5q666Su5lEAphcxGi"
"c9lbpeC7713GUrh2Wvhyo8u0y/eVD9+3VQ1QUngdl156qfrn3H9mhIymE6EPwrIoY+Z/zz33"
"SPgImoZp1Nn8wSHUyQVjlAJCks/65SmnqBf/8qL8Hd4ytD/nnHPkZ7xKCQ0WmD+hsAED+svc"
"UBwMLnoj3Ndcc80giYg1nj17tsyVUN1dd94pIbqHH35YPtc9QxjfjcGDBxnL1l6NaO9oF6FM"
"OabHtdLvKn7umv5Rz5uUcxT6m2++KYIVHpQuy/ZvuTNHySAUPgobryTMQ4X4h6KwgwYNtIKu"
"3Qg5LfjwblDMRCwYeLOnnXaaCDdngJSCzxoT1kYhwie96npJRhwYzzzzjBh0eJbXXXedrGuY"
"LoXw3d5kX+F1s2/4+3EHjVNnn322RBC40kAFGcKDd2tj7OOPPpJwH/fT6m04Px++8+CoDmMM"
"oBWS+cl5oJQLs0qD97KWvM6/eK1UTKmyZ7BZ9+g64X+e9/bbbxPj9u677rYGSEYpnXHGGWKI"
"EbnZX6/9qaedKkccbu5F6R9EhqxcsO9jH8AvDM4nOf9buHChZJ/m21+xEusJZ2Je2FLxAosl"
"CCNYJWbOTTIHpiiwm266SZgXK6tXfS9h0rDlUwifgXDGwkVZPaq9ik033URbu42itGB6wlEo"
"BJinrlfdSpZVsfmnQ3Hr8PwzFzktQ+Z4YMXwJQ1ZC5uf/vSnspFOOOEE8VaJOHg25Iii2HXX"
"XSUcst9++wkWwrZWzhG9IvheUDuPsxIE/sknn6yt/RXiqbhQGfR2qb81tTX2LLHz+T///Ata"
"qDwi2FvYihCcFSJA+VsEB4MqMQhRwjqcG6AoUJKsM4LWfU4YPxMuNkkJafFIjHA49mfHyvsa"
"+vTuMn4ufY488kg5t6U2IoIeYwLhnbZCCqyDtJeEcuN58QxaJXScLJk/lTs/sgkP8M9zf35O"
"wqbghD0PZ/iVzP8al/Azz4ASrK2r1da+SUThMwnZUYyWUCmXbU1iglcUn4FhAO/w7NATA4u/"
"J4IA3aHL5ptvHqwFPEnlFP6G97vnyofP3PAQoen99/9RPCCqWbhwm9tTXGCno8Juu+2mJk+e"
"LF6tK29VjD7E6+Cf9dffQIy0yy67zJZUM/sL2QB9jOfti6eE0cc+cYqmFPoHRrrnB+sLnZzB"
"fMABBwSfHRQPTqfjFPueqMTyx3hDXXeCxfOCVxHMuPUIhmzPLp0F1zm+Cu4FYak5AbBk8WJ1"
"+BFHiHJE6F9xxRVZ7y8dP5PKi6Dw7dkdf0+oK19oY+UE4JXxveDg15O5k3HFJiI7yxUSdV6s"
"s+IRqAFT1tRkh8vyzN99BjiEyzj3cWd6zU1NWcqcWoNhC7gQfSifQ7ILFiv4CMczzzxTffHF"
"F+LFOMHM9+4+jPtcPKswV+TOf5tttpGfCfNstdVWNuEnrb2JL0ShIxzdeWpX8LP5xnzxN9AH"
"XkFgklBwjvY2nMVPeBJja++99xbhLbzq+yXxD38D/8E7YaFIwWv40wlt5u7CZ3LeV4R/8q0x"
"XoULrSO8d999dyknhueEcN5+++3Fm+e9pfA/uMzpxhtvlJ/dfTb+HmPB0K052NthD9IJ93z0"
"d94H4dx99tlHvfbaa2rJkqVCf3c5OlzNAhrxOvs7XwSk0Pq6UOuRRx6lPvzwQ/Xzn/9c+Kha"
"ivv6gSHHmprODeacvibkLRWif6biTLZSZf3a7fcodvBR7swlH/1jT6wnKLF0utOvjKXiUpTT"
"gUAm84kFdsIn7K5nLKrO8d3fUK8NbwzFQh26Dz74QNx3wkuffvqphBPI3sqE/krDd1+chyCs"
"CZ2wqTjXI9GA8jJhq9B9FcMnDPPGG2/InJkTsfKLLrxQlAmbii9HO7xIrDnCQwwsb9/WkSs0"
"f7cB2TSEbCjHxHkM9O5tvSU+D2+EckFuAxei/2OPmRYfzItNj3CWElXWG3PKlQG9w+Hk8OVX"
"X/l5z0zwprDIOW8hhAQdWMdzzz1HHXbooZL+7jC6gp/Ll8uWLRVBTRV5lA18w/OQ+MLgWaE3"
"HizWPPMxAvT/sXc2v1FVUQC/M3TAQmgZanBTE0xIXLisCQtMXEgqHwkmNcRikTUtYeGOLwlG"
"jSQsXLGAHQvZIi4QSPgPhBbXmODCJcNY2pl23pv3PL9z731zO/NmLGMwVecmDWVmeua+c8/3"
"110f/VCZ6L058E5FHTm230XhEyIOh8aGVvp64XuBzvUh0FJFzoPIBl79jRs3NPRLuJGQInhE"
"qdlQWW/4fj914Sv2D64xfCKXZ0Ug27xQi2/D5unUTZjPg8+e8ICAOzn5oSox7t6iwCPOCqPs"
"95NTYv/wAB4Tf+sH//baPx4c/EXYU5WxKODzYiBWXUENXiM8jYIBT3wXPMD/MSL/Cn6IJ19o"
"5uUb5zt36pTygseNzbsu6w84a8f/wBPbIDmx9oXiuHz5sv5OxRRK4M6dn7Qo4oP9+/V1ksYI"
"Ud5j7d27V2PqqfHx9DQXfggbLwDrmZCbVggKgbytswDfUSVDsh5PjDJmCJS5bsyH7QW/3RM7"
"f+6sOXf+gjl27Fj2ziciVE+fPt2yroL4dtLmj4XwedarV6/q7/TTkTQfHdmus9oQPirsgnwC"
"3iqMDiNfuXJFQ38wYyi02/dPEhzBxSKv8c3XX5kDBw8pfmA4vBgqFQmf4V3gCfL7xMREV/yH"
"+yZ8R66C0AvCx+dQSNQjdFiTk5Ma6kPwIFD4l+dg7dr1hnny5NfM2/H7Ryhwrgh4PAh+sPqp"
"3HtfvpO/Qcn1C98vimb8AoZf0AYK9HPBjadJQmXgnkUOE28GmkqDhvBu9LNnzx7NEQIT3LKg"
"SUr5EeTklVhHjx7V4oPp6Wk917iZdKWfvDMef3N8zXvQKXmyBw8eZM8Hn1EUA+34EvB2+Nxk"
"AE17nuUHg2tneYdO7b99+0c5n2/1fUKUeHieBzFiPP6n5fuvXbveCg86+CEN4XnR6sD+CBNS"
"gQoN6rMJPmZmZtQIJS0AXsA53rlXOmfOnM2VP+EzUAEM7x86eECetGQuXfpSPOvv3DU9ibZx"
"QFsofkKj5BXh5XpbBWYe/kMaIgcWLjx6aDjEDWfuI0VJbrxmoMQ2TjixoDcUaCwdoTA6MiqW"
"/7AeHtWJy/KBhw9/FsYYM9u2b9NkNwKQfFhJrBcuCNQL6bBSCmkufJKwMCoCeOvwVo1B4xkU"
"jG265dLCm9/fNKPlUfVyIJ6nvz3V6kQ8NTuVujt8Xk5dKINfSpu3aKHIyPYRzRtlFrALqWg1"
"VJoEt+u64aA58I9/dtzMzc6aUdk74TH+HksXGPTRMP6G13yJPMwL4zKwlYIV9k/4i3xat/3/"
"cOuWwkcBIMgJ2WI9g2tbKp6amU9nzNzcnCo0Fr/zvEsaauzEP0Jwln2Ld4KVyefGx8fNo4eP"
"THlnWXMlvvqMXp7NpS3ZkFl/VQUFP0NDJf3RhH6hk35q9Zp6XRg4eERhpdzrY2Nmfn5BiyV0"
"jmEf8MEPl3/uKJezXKA3QqiOxdtAeF784qLSJ7kg3vceMrisVi0umWbei37YE0OD8SrBc8Fd"
"tAg8cPj4l8fKH+QRKV7BW/aNv93ox8OnKILiEPDOGftnoC2ESR3Qiq2I26QeoA0J1vV8COXl"
"wUfRzi/Mm/Ko8JXsF3jQYlX3FSnfoVzKwlel0malf67ZKTGrklyQ7IHX2eQid9OZtfChoZOz"
"J7XdANoHl/fv3Vf5wDpx4oSc+WtmeHiLeJeR5ravi2JhliG0wHmSS2T/L14sdsBnTbw7YR4v"
"LOj5apuPeJPPxeOORTG9t2+fOXz4kDzTknqvu9/abe7dvavP6nPxeGr02RGS7YV/CjeoOgX/"
"IQ2BfwYVpK6kHpkGTS0u2v1a72utfBgosY3giWGVutMtBEUQNZezKP5RtMMxtTS4oX06lecV"
"JVJ/tUGx6PpxKB2Wz9jijzQXfgSxCEM+qySmWqzaiiNyIq73CSW1VBPXPW6Y0qaSwIr1NZjZ"
"FgvEaz2NnP3bsJQltlhgUmmGAED4qKeE0KSCTpjBCjN7B1chDVOBnfBNnGoZNHvlmTWpTxWe"
"7L9GDD9qKLNOTX2sljZJYa56OXLkI2V6Kuf4zBpLum3/sitlcvCvip2cBUUDcZT9XU3wFz+L"
"9aZfvRfJ4YcGzFz8F+29V5Huu2gVlhNihLEWXY7QM68m4E2aDaW1d8Wl+nmf58jCUcH+k4YI"
"KFooUIZaUGCFC7hGGKBIKpWmKuV+4Ct+5Bn4e5/TCXMcvj+PhvDl+rLre7PCyReLaNVkM25Z"
"6l3ox4fPG7HNQw45ZWsrLiM7VSOyz+LzN03XF9WNfjL4PIMK3FpOriZRz4kQF/ga0pYDm/+z"
"9JoPn9cJvVWS5wo7KzrRfQnPFIWnha9impSLm9y4pYIbjptm+PdC3edHPXzOq+YMMGhfvU4E"
"vBgcRZsAk/0uZb2jkcMHhg2GidKu4y+fn2vHD89OuXvzWeKUb5Lxl7YuVOw4rkZkp29U40Th"
"a28ddLbqzzbtiX/4APhLLr/cTkchLXq60u/0fXsB/gdKbCMoMWLCkHNishlhqRx4LMSxIlZN"
"1u9XaDnRMJSShJf8qWnNIuMdvfYg7QJfmKG5wiRN+7kc+IlYtirE+oLv/uUaPAc/EuJrxEsZ"
"fMuSnftP/Cy1LvBRiHFUVwWT7cPtv5nGbhis0f6t8s4xsdRHVOgy4Z/cTeyUb6/9UyHViJY6"
"4If4KYhlXdOetPr68MOkglrsChtMdiUFn6OYoAN+F/ysB/+JXjop3yP0077/2Cm4vwMfKx8l"
"0hM/8h3902eLfpiagefQEBzl4Wd1pdEXfAyzRrTYff/94EeMy5Xmqjbeh+fb6tdtmma97oyj"
"l4efCsrrcq70aeXC77b/xvrx0yxQlbiqIcE8+E1XVOHh89mVxspL4381iVQ59oX/NvkwUGIb"
"QYm5nolCcIpe2fhbgl+eybwg+H/Cx3LD0qMBFk8PC9pOC08H+BnAH8D/D8F/1avwT11c9m9d"
"U1NTAwQN1mAN1mD1ucLpR69i/SnAAIDb/vS6cU0rAAAAAElFTkSuQmCC")
getPtableOffData = PtableOff.GetData
getPtableOffImage = PtableOff.GetImage
getPtableOffBitmap = PtableOff.GetBitmap
#----------------------------------------------------------------------
PtableSel = PyEmbeddedImage(
"iVBORw0KGgoAAAANSUhEUgAAAbEAAAD/CAYAAAB/9egZAAAAGXRFWHRTb2Z0d2FyZQBBZG9i"
"ZSBJbWFnZVJlYWR5ccllPAAAwPdJREFUeNrsnQncVtP2+Hdvk0ZkHi8pNNIgSpMKjTQpQzfS"
"YEoplERCyM+9hkSmFEpzXCpCZUplnm6IDCVkvqaShv/6rs5+/4/TM5znnP3ee7vt9fm89Y7r"
"7LP2XuNeQ7FOnTptMUUMs2fPLmY8ePDgwcMOBZ07dy5y/VKCf46oVavIHvDWO+/4nfTgwYOH"
"HRSKWr8UeBJ78ODBg4ftFbwS8+DBgwcP2y2U8CTw4MGDBw//zXB49eqmWrVq5uuvvzZPzJ1r"
"ypQta0qWKOHeE2t47LHmxDZtzE8//2z++OMPT3kPHjx48JAI9t5nH9OqVSszbepUs2nTJtO0"
"WTPzw/ffmz82bnSrxI5r2dLUrVvX/PTTT2b16tXmt3XrPPU9ePDgwUMiKFmqlFm0cKF58803"
"zRdr1ujXX3/zjVkX6Bhn4cR54uJ9uGKF2WOPPcyPP/5o9t5rL099Dx48ePCQCFZ++KH59bff"
"zKDBg02tWrXMpZdcopG+LZs3u/XESpQoYXbaaSdTomRJ/dyDBw8ePHhICuUrVDBXjhhhfvv1"
"V3Nmz57mG/HCdt11V9U3Tj0xLtlKly5tSnol5sGDBw8eHEH16tVVYVWoWNEMGTrUrPn8c7N0"
"yRJTUFDgVol58ODBgwcPrmHZ0qXm1VdeMWu+/NLQ+un33383ZUSpkeThXIm9Ig/66quvTPny"
"5TWs6MGDBw8ePCQBInskDG7euFEVV6lSpUzZsmVN8eLF3Sux0oJ8rz33NJs3by6MV3rw4MGD"
"Bw9xAWW18y67qHO0ecsWU6xYMf1epHDiLvKHAwcNKvyaC7WRI0aYa0aNMrvttlvh968YPtz8"
"sWGDKVOmjClXrpynugcPHjx4cKJTUFoFfGSI7hWvVq3ayEzp8L/99puZPWuW2Wfffc2MGTPM"
"ZUOHKsKXXnrJbBTX7ueffzbt27XT/ytUqFD4wFRY+/XXpnv37lf77fPgwYOHHQumTZv2J/3i"
"QqeE9UvWFHv+mNhjCXHdQENscueKFU1FQb7xjz/0e/wOD+P3sj3MgwcPHjzs2FAUOqVElAeS"
"Nr+TaMRKlSrpR0V5qP0++fq4gXztwYMHDx48uNAp+4q31rVbN7Pffvtp2PHhyZM1vR7vzN6H"
"5VRiqdC3b1/9SAWyETcG/as8ePDgwYMHVzqlXfv25qXFi8348ePNMcccY84591xz8aBBZv/9"
"9/9T7kVkJTbuzjvN2LFjzc4776xFzaeIhqxTp45XYh48ePDgIW/IplPKirdVpWpV/eD7FjZu"
"2mT+9a9//SnUGFmJFRQvrpkluHblBAEPJp7pu3N48ODBg4d8IZtO2bJli/5OP/HUnnv+ebOr"
"/B41YoQSd5Hf2xKk2iueyA8sKNBY5f7ywIMOOsjsvffe2mrKKzEPHjx48JC3EsuiU8hi/Oc/"
"/2l69+mjSuuoo44y06ZPN4ceeqjOEjMpCR+R68QOr1bNtGvb1lw+bJgZfuWVhTn9CxYuNBf2"
"768PzZUO6cGDBw8edlzIR6c8MGGC6dOvn1n28stm7dq15rZbb9UmwBQ9p2qZYp06ddpyRK1a"
"aR9I543vv//efLRypSJBQ+L67b777ubbb781n3/+ucYv0aBVDjlEs0xSs0aAt955x8yePdtr"
"Ng8ePHjYwaBz585/0i/56BQ8tHXr12srQ0avcA/GqC9+pndigX6JlGL/lwMP1PlgfI23RUup"
"UqRCilYlNsmlnK8T8+DBgwcPrnQKafeVxCmijoymvwzDpJ6M1PxUTRNJiaWrAeMBHjx48ODB"
"Q75KLB+dQqZiNijwZPXgwYMHD9utYuRObHt/CX/n5sHD9gncmXgqeEgCGk7MlNjhArh4K2r8"
"Hjx42H5he5c/Hv9/Fr8PJ3rw4MGDh+0WvBLz4MGDBw/bLThpt9Hw2GPNXnvtZVZ99pl57tln"
"taK6RDA62iW0bdfOzJ0zR2sGSLf0F2EePHhIlUHUIS1ZvNh8tmqV2al0aWf4KdJt0aqV+Xrt"
"WjNv7lyVcSUddSs66OCDTZ26dc3mTZt0cvHnq1eb5597bmtnCkdgn/EZMnrRIucy+vDq1U21"
"atXMZ59+6kwHsKeLFi7UWrIqVapkXH9iT2zvffYx9erVM1MefthUkxc59LDDzI8//KB9rlwf"
"0ho1a5oNosB++PFHPawePHjwAFQXATpt6lTz0IMPmueff978+uuvZpMjGUFd0l979jRPPvmk"
"4mzSrJn54fvvzR+Omp9/+OGH5sknnjDTp03TNPNPRRF88eWXWhvlSgF369bNzJg+XenkWkaj"
"IFuJgof+1HfRiYMmvXHxg693376msch8FDqyvlv37mo8HHjAAVvXLzrA4k+sxPCIFi5YYH75"
"5Re1JL744gud/bJhwwanVgStRniZL2VzkxDIgwcP/3uAojmxdWvtsUe6I1Z68QI3tyWHH364"
"Thpu0KCB+ebrr82smTNVBhERcgGsEw+vjjgDX4r8nC7K5o9gQKQL+G3dOvOLKPUDDzxQ6fTe"
"e++Zb779Vh0CF4AH/NFHH5mXX37ZfL5mjdLra6ET3TbiKvUn5s1Tg+FT8bzobP/uO++YheKV"
"MaoF/HT7sPgT7/JKeeBicd9PP+MMU0GsCJTXerEgXHpKjUQjTxILi0ru3wU/G2y7HHvw4MHD"
"a6+9ptGgcmLsdj/1VJUTrjwxDHVGgNx3772KnzlX4HYlg2jVB94Wxx1HuZAa7LtVqqRejStP"
"jLWitGjrdMghh5j1ogA2O3IEli5Zog18hw8fbpo0aaIOBp7S7zGVGEodI4HCaGQ9OgWvF52i"
"3Trk5xgVv7tSYkcdfbRuKrNh5on2bCluJQ9zdYCIg7IJV151lW7EgAEDdAP8HDMPHjzYSA0N"
"yOmx991332kLI/rwrRMPxAV8+803KjTxNsBbMTDWXcqg6jVqaDSLzu10bd9l111NcUd3VgcL"
"fT5eudJMnjRJlT3PQtG4Wj8e3rOLFpmHp0wx7y1fbt55913FHVfFo9TZQzzRUmJAsK977bmn"
"fp9xLR9//LEqOIs/8c3kO2+9Zc49/3xtI1K5cmVz4403qrJx5YktXbpUrZM14qbOkv9vuukm"
"PZwbHbnCHjx42L6Be5N+7dqZPUXQlS9Xztxyyy1bhagjGbRcFAsjQEaPHm323W8/M+raa7de"
"ZziMBh30l7+YN958U2UnSrK0w6QUZOh5IqOvu/56DcUhQ1VGO1r/Dz/8YDqcdJLmR6AH0AHs"
"RWlRQHFB+/DKB/+/+sorplGjRoX0v0DehX6LpQL8iZUYbvvwyy/XxZM5gkW0x+67Fz4gKRDb"
"pkV/GdHMtOznQpVOxq7we/DgYfsGEiBGXHGFZqzhyWDFI4P43wWUEoVCwgj4P/nkE33eniKD"
"XOEH5jz+uPlQPD3maxFOLHDYTB2D38roVatWqRMAfVwpShLtrhg+XOnzzjvvqLymuW+S7Eru"
"BkdedZUq9AoVKpgHhf6EEt8SRQ/d9913X9UJTpQY6Y/Eb4lh4gajYOg67Cq9FZeazsV8cEFZ"
"vXp1xV3a4QHy4MHD9gt2QjAyiPEdCDvkhStDlzsawns///STyjjuyAhruTSkiVzts/feet9T"
"1mFqvcrokiVVaUEfusTjJbmU0TgaKN9/CX3wKFk/yidJin1xpjuvX2/+IvjKiXeNnvlJ8PM1"
"ypd94L2cKDHsBW2jL4jZCNw/YpdFUcOF5oXwxQI304MHDx5SZRAhRBRBgWP5oGNCxFjfWZRA"
"Ucg4VYwIZWRbEdKnKGS0HaeCY+GK/vw9HikKzMp75lWihMP4MyoxLkvPPOuswq9Jmx85YoRa"
"INYNJenipJNPNgP699eHRXWvw7gtUNvxyOzZ5o3XX1d84YtNr7w8eNixIB9ZoYItpvXPfU77"
"9u3Nfvvvr18vX75co0p3jB1r1q9bp7IN/AV54E9d+6xZs8yLL7yggnn33XYrnG4MEIr7Y8MG"
"VQRxpRuNII5q0KCQNvOffFKfR9ZjYVFwnuu3cNXVV2f8Wep76XNy4I9Fk0DmZ9rfjNmJ5Oqf"
"e845WpfFWOi2bdpsU4DHhWGf3r3Nt999pxmDUSGMu54owyaNG2tmS4+//tV8tXat+fmXX4xP"
"ovfgYceGf4esIBTZ88wz9X6/vSgD8L/55puqxMiMIyMxTrZ16tq7dOmiySCE9JCXV4lD8MvP"
"P+vzli1bpnVccVP2oQPK4UJxJlj7nXfcYY4/4QTTSD5n7UmLsgcNHKiF3qyzzpFHmmMbNTLH"
"NW9uHvvHP7QejKS7qOn0RUGTjEqMOHAFLhjlf1zQgmDCZuplIJqX2CdaNJ9LzlTcP8oLEO/c"
"Ryyh995/X3/Ossl48V05PHjYseHfISvoBsTf9+3bV4U+d0aPP/aYefzxx9XDQ5jGaa5g104U"
"CyVw6ZAhKrDx7H4Vxbvy449VmOuQyBSPIx8gGnZIlSqquCg2RiG/9uqrWjDdtWtXdS64S0pS"
"02anLgPQaffdd9e7r8mTJ2tCSj5F5UVBk4xP59CUDw4PLwFxKqUU4KH5rxk1ytx8yy2m4s47"
"68tFJVQqbtxFiEIKa7NmzVS7k9K6SawHWr3gyvJRs3ZtPcQbfacODx52GIgqK5II6Zo1a5o1"
"n3+u3TgOOOAAU7VqVXNI5cpmjigyOkOQtl8swdpLigIYc9ttKpAJpYGTOzAUA1l21EDZu598"
"gSJj4KmnntLkiiqHHKJ9Bqk5s0qO90rSXQT5zwe9ItEDZ4rXekq3bmZfMSaqyrP233//yIl2"
"+dBkv/32M33Fa0P+ny9eJsk1hErDBkvsYmfcwltuvlk/X7FihbYxiWMNDRFNPHfePDPquuuU"
"0HYzOnXubH4SpdWubVtz2qmnmhPEPSY19OeEVoUHDx62T8gkK0jBLkjQYgqr/3vx5vC6SBxQ"
"gU1G3x57aKEwirNEgma/xQLhfcP115sWLVqYxk2aaFE2wHPIxIt712+VB96opucLLcBZThQ+"
"QL0cKfAu2gDWrVfPPPf886Zzly7qsX4t3hQZmuVT7t1c0qR9hw7mpcWLTesTT9S7Sfon0nEk"
"XMQee+dxC22KKVqf+rA4xXPXiTdX7fDDTaOGDfUycqy4xS1atlQLol79+npop0ydqgeVynAX"
"MV4PHjxsf5BJVpDRl9Sw5e9RJCgyq05qHXGEClgXhcEIZrp+THroIdNPvAtk58aglVISICwH"
"EA3DiykM7dn/Zd0ofBe9ZglT4gXfesstGgLkI0nXj2w0IZRYRTxiPL4n5883I8UbI4y8MbhD"
"S93v2EoMLWqtgJJBvDSWMgxqDHDj6cEInCheFwkkXORSYX50gwb6MWfOHD1M/q7Mg4cdDzLJ"
"CpqOr0/QYoqOEDVq1FBDWa9Fgu9z7/OqCO7v6Vif0JNBQSKYubeiy/6wyy/XlHf1KhIoyA9X"
"rND/6WhBb0SbgLLfvvvq//PFW1XPxkULK3kH7rO4y3rmmWc0Uz2Rh5qFJtZo6Ne3rznssMPM"
"MUcfbY4Sp4ZEGxRYYiVGNgxe0rpff01MF+ouOJjEVU/p2lW/98KLL+qFIdkrh4nmRwOPHz9e"
"Q4skkhQU+FmeHjzsaJBJVhCGSjK2hO7oyJVx48ZphiLJEA1FKeDdvPHGG+odxJU5pO4zmgTF"
"ixeBopw9a5Y+jzAmjXKTeHnvv/eeKvTBgwdr2JPsviPr1DFtRFaSeEF3fEKkLgqz8VAJHTIO"
"BbmMoozTdCIKTX4N+kj27tNHC5uZTjBt+nT1BLUTSL51YvTd4iMV8IoGXnSRfv6Pxx4zvXr1"
"Ug1aQl4yV3z3T7jPO08/AC7t7r3nHvPAxImq5Y8TVx7cAN9/++23TaXddvO1Yh487CAQRVYg"
"DEskiAbhaQ0bOtT0lOdMfOAB/R6jP665+mr1zDQRIYYSSF37bWPGmDHysfKjj/TObeL995tO"
"YqTrRI4EkSWUCBM+uD+6fezYQtqMv+8+VcpkWu4hH0miZal1YtyJ3X3XXeaDDz7QhJd8PbzI"
"NJGfT5861ZwhDtMy8dRI/CAy95u8G/uRqgGKderUacsRtWpt8zDunbh/omMwCHAb0ZL8by8J"
"+Zq7MOKazJRBS5Jun2q1vCWHIYw/E26bzo8CI0OFrCPm07ApvCTZkXx/5xRvDPyzZ8/2Ws2D"
"h+0QOnfunFb+5CMr8Ax2I/kijUBNJ3/CgCeEDCNpgGeA1z6HVlDazDZDi6Zs+Fk7mYEfBt3v"
"8SIZg0JfQTzHTz79VP8neYS2UPnit0AYkeeslvXbrET1XIU2B4jXCm0yTaGOgh/PiHcgbEsY"
"D4+P9k9RmvyG8edDE0KXa+SZPBfFxn6QbLO37AmfFwvwZ/TEbD7/wQcdVBhfTQU0O9YPzSV5"
"AJtcPmKaaEbc8rfgBQ+V5sy7KSufo33R+GTe8DMfTvTgYceAqLIiSZ8+OkEQ0rKZiIQTiwVG"
"Ot8vFbPHIGsnREYa+l8OPHDregUfChLZSRo/Qr1skEkYF0joQKEQZvs1qGlzRRsABwJlaBVt"
"4XvEwJsPTQiB4rSw/yg2vGF6Yu4U6mySUYnZfH4+XENk3EIkPDvDhwcPHnY4KEo5FFZkCM6k"
"CiWftbt8J5RBJfFq+HANKDG8n/8ETeiXWybHvZt3aTx48ODBw3YLeie2vb+EvxPz4GH7BO7E"
"PBU8JAENJ+a62EsCUS4Ok+L34MHD9gvbu/zx+P+z+H040YMHDx48bLfglZgHDx48eNgxlRgd"
"jY9p2NCsW79eK68Pr17d7H/AAZoO6aI1FCMS1gsui5tCuGObNNHRAr5/ogcPOzakygc+79i5"
"szappebLxbSLVPwWGD5JrRS1sluKYP0ndeyotVC/0XopoQxNxY+s7ty1qzbadSU/Lf4DDjxQ"
"ZfPJsvYOJ5+sfW9d7EHq+imS5hl169ffBndBkgf06NlTR3ZTjNa8eXPToUMHHSlAd+MkXZNZ"
"cO++fU1jecbnq1frBrRq1cpMmzpVayCaNmtmfqCfmVdkHjzscJBOPtQT5TXl4YdNNTF2Dz3s"
"MPPjDz/Ebnobxv9rUECMzKtRs6YWF9MZPq6SSYe/erVqKt8eevBB7SOo9V6O8LNOxlrR8xCc"
"TRLKzzD+N994wzz5xBNm+rRpWgP26aefbjNAOQl+Cqq7detmZkyfrnQK729sJbb0pZfMgmee"
"0Y4dVLk/8/TT5u233tLNpbPyhgTzaxjz8sS8eUrwTz/7TCvqFy1cqNNWv1izRoveUJTrEjT9"
"9ODBw/YJ6eTDwgULtFsFDRIwqr9JYEiH8aNQEKzUMKEQGNpIJ/W4SjIdfgp4T2zdWnsE4uFR"
"SFw8ZlOHMH6EPt5LgwYNtFvGrJkzdf1xZ4yF8SOH6dFYRwyJL4X2DOQEdzFH+4usZzApU0yg"
"03vvvaejv6yOia3EOCB2Dg6byXhpCtlYOF8n6QfG5kFkcEMMlOOLL75oBg0erO781ClTEvcc"
"8+DBw/YJ6eQDTXBPP+MMU0E8AWTT+gRXGmH8NABuJF4BPQoJJdIkWOVPzMa96fC/9tpr6knS"
"YaP7qafqMzY5Wj+F0ITf7rv3XsXfrn17xe1q/dAZvC2OO45yJ1X2u6UMUE6Kn9ZUGsKVz2kN"
"RpsquqpsTuqJ0SIEN492UHxoGypRavyftC2UnSaNQqT1CC7qlSNGaPupM8UtxsrixXaK0UHZ"
"gwcP2zeE5QMzvxDM4+6808wTC75lq1YqWOMqgTD+Jk2basjyyquuUmE6YMAAFaJxZ2mF8dPR"
"nYgWY0boyM/P6CsYN9IUxr9W8OKJfRT0K6wYKHpX6weq16ihnjCd5+k6zxTmuONfwvgJIX68"
"cqWZPGmSKnuehaNk1x97GEyx8P/0TLQfDsDi4//69evrS2FlDRk6VEeJL12yxPdQ9OBhB4VU"
"+bB06VIzqkMH7XVYuXJlc+ONN24dZJkgUpOKn2uTZ5991qxZs8bMEk/jpptuUgWzMcGVSSp+"
"mhuf1auX9j+k3+Ett9yiAnqLo/W/8vLLpmHDhmb06NFm3/32M6OuvXZrKDTBCJhU/ACz1954"
"802lO0oyrheWDv/TQv/rrr9eP5gvCf1TB5Vm7GIfBYjlMhb7R3H99hPicIiIZ9IxmZk/JHnE"
"LXbDjcSlfv/99zVbh+afa778UpUmF4b006JZ5wfyPN+xw4OH7RNydbGPIh/o66cDFkX+fPbZ"
"Z+rV0Kx2P5FBdEtPip95hjQC1kbkItuWL1+uMommxCsc4SeERgNfPBkMdtaPUnt/xYrE+PcV"
"/ETJwP/JJ5+o/Nwz6AbvAj+ynh630BrDYX/RBXTQB1zIfzrco67Y31WrVqkBkbq/JZIcQGbZ"
"oHWJh/IAAGVWPGXqc1zgsGwRl52W/zuJVscd3izWCRYELibPczKt1IMHD9sdpMqHcsFoFu5R"
"CGWhYBjXtFMCb+BP+MUYpzEwHdRJfa9evbriTiLjMq0fBbBT8KwkgyzD60eJ/fzTT0ofEuNQ"
"Mi7xo7wYW1NM3sPqgqLYXwZ8otxT9zeREiODhhCfuqWBW8lYAHUDE74EXaW5ICwXjHdBE2t2"
"kDyLr1FgPpzowcOOCWH5wAcjUxCmfG6TzFzht0AECOFZLCWU5nL9hBBRBAUJr2XS4acciunY"
"RUIf+djZkezPd3+3UWLUQpxwwgn6+fXXXaf5+Lih1GGcdPLJ+n0SK0aOGKHaXGOfqQTPQvxU"
"3K++8op58MEHt87rCaaOknl4VIMG+vnzzz1nZs2apbNkSBYBa0GC6aQePHjYPoGkioGDBpl/"
"/OMf5tlFi1S4YUBT+3RIlSpaV0XauJUV+UCqTCJMSGIFd1+vv/qqZiR27NTJDOjfX4WpJhvk"
"qbzs2sPAVcz8J580L77wQuHML1VcMaNL2d6DdRcP8BfkiX/vffYx7du319CdxY2ne8fYseb0"
"Hj10EHIS+gMXDhyoYeCJEybo3lp9EKZ1pvVv48pQjzXkkkv0c8ZIr6Ue67ffNJHizjvu0BqM"
"1ieeqFNE8y1ms7gJDdY/6iizevVqrR6314uVDzlE/+/Xt68ZNmyY+e7bb31BswcPOziQvff1"
"11/rpf7KlSv1bgq46667zNtvv6338tz1/JZnNh+1X/Xq1jXnnnOOad6smSqUJk2amK++/FKL"
"dZ979lnTp3dvLR8iGzEOfP/99+bCCy4wb7zxhhrldevU0SLeBQsWmM5duqjsI0y2OUGSRa73"
"+D1mvRwKuOeZZ+rftxcHo0njxlqrixIjk3LEFVeYt6gNjkl/u3ZS5esIXcL6ILLXFv4GsdNy"
"4h29IITAdesh2pYFk67KQaI6G61O3DPfDBSLm1RPLuhq1a6tBCATh5fhUhP4SZQcv4uXlmms"
"tgcPHnYMOLhyZXP/+PHmsMMO09Rt5ANCv1RQzoMQ1FZEeWYL7rXXXiqLPvjgA73bXyRe3vj7"
"7tPEAfABfJ+khbjlPDbhBE9rS3AVwnMR/kAlwY1c/SNBpmOu99gU0xHAu0MH9BWngtR87qIe"
"f+wx8/jjj6sOwMHgfeLSH6gmBsrNN9+sn9MSC8clXzzbaAi95xKXjgSKK4YPNw88+KD55OOP"
"zavillaqVEk3hJHRuwnxKS6sGWSe0Gpkghw0tLaNGWfCzYUilkijRo1UKf4uVs5BBx1k3hIt"
"37RpU1WO1IERv+119tkaMrDP4Pdmi0WDki3qaa8ePHj4z4I1bml2gKCkoHbOnDmamYycQaZg"
"8Ma5H8eQbt2mjRkxYoQqAZ7z8rJl5nsxrElJv2zYMP095OAf9EoMlFAcJVYyqKvFuyHT+vhW"
"rfTnFGoT0dqUoM9gtvfgyqd4TEegZs2a2vaJLh8YEBQZQ+85osi+Ew+TJAtoH5f+JLCgC1as"
"WKGKt3Xr1hpiJYR5WseOerVEdw6yTbnOuveeezRbkdBuajeTjE8m/oj2vefuu00/cVN5GD2+"
"WCyfkzWCAuvVq5dpIw9HqWEl0X4kVwiQY7BYDiWLRqMTH4ZgLBiwWTO0YEGB9fzrX03Xrl31"
"GcMuu8yMGTNG3fSNPtTowcP/NGCpv7R4sRqstLbr0qWLRm8QbEkB4/zhyZO1LVPffv3Mrbfd"
"Znr17q2p53SG+NtNN+nvIWRpc5S0IW+Hk04yCxYuNGPGjjV7ivdEPRvh0XIJM62zvQeOR9ws"
"RJQvipC1obDwRlHGWl4gxgWGRJLkFsLD7zIPTHQKzgxZnzhIGCv0SXxMlCXp+9QBAugVlOqG"
"0DVWiSwmhL7Ec889pzHpYZdfbv7+978XKg68omuvucZ06dzZtO/QQb/3r59+0vjx7vKSpXJc"
"8GE9cL92AvdrsrBlL79c6FLbEOJ7y5ergiNmbL0u2w9NXXQfavTg4X8WsNQxlBscffSfvk+n"
"erwDW4sUFxDuS5YsMVOmTFHhfEaPHqokuf+acP/9hXLol8B4J4SZpKjn0UcfNUOGDClUCADO"
"AAqtZIKktWzv8cDEiYXhzDiwJSUb3KqrWkccoSUAJNkkKZhGaVU99FBtJG/h2MaNtZkwpQAo"
"K66USPggPArNKOEKt8sqyOUKk49P+I7PSbjg8g5FQjNGWkHRnJHLRDJhiI1qL60IrjGEf+ml"
"l9Tbql27tlkuLnChNRJod55Jc+F/iEae/PDDmrFIWIHYLC9ZwteJefDwPwtY6ljkTZs0MceI"
"IiMhAoO3vigxIjG/x0y2sIDxjSDF2kex0LvwoosuMlWqVFED2yZblHSUFV0QyFOeR2iOdkqH"
"VK6s30uSUp/tPfAobRf+fIEM8ho1aqgiwQu1qoPuHFwvsQdxE1IIq64VQ4Sw6tENGphjGzUy"
"M2fONCeKUwNe9AhKi2bLfI6yR0/wjqVCuRhplVgNIQgHqGSQ90+hH+nwtscXlgmplVxIYrF0"
"7NhRNSR1CGjJbK9FyBFPDesAItFS6ghZHJeF4USRI4480vzz3Xf1AB8lv0fbFFxYPkomKNTz"
"4MHDf78Xxj0IVwx4XISvqopQfvnll02btm1VqP6aMKRIU1yy78jksy2rOnfurBl4tjGvS8Ao"
"J/GCO7G/iBNAuA8FkbRpQ673iNvNf+HChbrecePGaa4Dnl1DUTYVZT/IttwYJHbEAZJG6HiP"
"zEdBHVq1qln12WfmgAMOUIVM8o71uFBmlURvQK90zkvWOjG8n/PPO09jkdrCXzwyLAYW/64o"
"F0KBL4hnNEcUEB2SBw0apJYSKfn0AAtf9qXinj5jhqZtkvlIaBH3d8DAgfqzO++8U7NgnhXP"
"a+TIkRpLtjBp0iSzTFznLVu2eE734OF/FIZedpn+P/rGG/UOfMUHH5iePXsWhhbnzJ2rQhrD"
"mg8E+WOPPqpCN6rnRGExEzGOFblEkhrwzjvvaO9CwlqXDhmi3yMSxN0/2X4lypePXSfGOpFl"
"AwcMUGegjCjqYg56zWZ7D5Rk3D6GeETDhg41Pc86y0x84AH9HndY11x9tRoRQ2SPuLNE6eRD"
"/x5//avmOjAaBho8Mnu2epOdRPECY++440+/v3TZMtUDv4piKxt07/iTcRDuncgIA0KDXDji"
"caH9qoqWZDN+/PFHVVIskrROcvopUgNAjsbnngorYy/5O2LKqb2zwI32/fiTT/TyTsOCgpcE"
"Ets4kktbPiA+B+mcfv3MaaedppvN15dcconpf8EFmqWIGw5+3zvRg4ftEzL1TmQuISnjXCdY"
"Twx+/0q+pmEuSgDZwbUEcghvhl6GB4pVT+TIQrbefdzhI89+CAYsWsMYWYZsArj7R5gj74g+"
"kW6fKkRz9QZE2PP3H4k8xWBHjiFTCSOSdJErqy9K78Fs74HXx7tkSu7Ihp9QIXKakCT7wLsg"
"38FLi6my4qgQdkUH5EN/ZoNBV9bM36m+EPrSg5fsSt6jTJC5aKcF8HM8TI3CpeRCgH/bFHv5"
"BbIA0d7k6/N/ueBikEOjWl1ejr5hpDryQR0CcUq8NF5U+xqm2RxwE3I8TBa3MYh5sti9hMib"
"gnYiZL7wM9JCd5LfowXLy6+8on8PwW64/npVrknqKjx48PDfDbR34u5l7yDpoTwehcgDBLKV"
"OSgAOjhwB4+c4Pv51JUibLnbpwEvBjgfxQLhDy6EJ8/k+8i98qEWVFFDiODT8KG8CwAuvlfM"
"0cSPbO+htbYxr16Q5/y9zUREoaTi5aqJZ2Jc5EN/kv5Q5CSH2L9DF+wqn1c7/PC0sh2FRnlW"
"Wr2yzTdQVsyDSZP5wwJLsvgA2OByeTR7zIY7U6x39A03qKbHlbdzyyBoGT9LzIOH/1lAqCHo"
"0n2f+xEXgCzJFfqqkCLv4oBVYi6a4iZ5j7hQEOREpHpXqVBaHB7DRx6AQto9zd+xtyjEfOG/"
"OkcdrYvLjfJcRyYSHqBYMRysMhmI6sGDBw8edhzQOzFPBg8ePHjwsD2CemJxh2JGgbhD0Tx+"
"j9/j9/g9fo8/F34/kMuDBw8ePGy34JWYBw8ePHjYbiFRYgfFy8wII3WeHmcUvn326ac6h6dM"
"gn5dAAMyyWJZvHixZifSQaRe/fr6+XOLFjnHT0fs6jVrml9+/tms/OgjzfZJMjk6jJ95OdVr"
"1NAuJ0/MnavrTzJmJoy/RYsW2v2ZqveioD/0gR58f+6cOZoGm6RrSqb1U6KxhO+tWpVovHwY"
"P5lurY4/XhtUz3NMf87/Mccco2untoYmpbRIK5MgI+3fff7t+XTBv5TiIBtIg2daBfO/6IJe"
"p149J+tPh593qSbrd8G/6fDTPaha9epO+Dcd/ubHHae1tS74NxN9yJR0wb/Z1u+Cf9Php7Si"
"ZQb+jbXLjEfo3bev9jKDYakVaNWqlZk2dapmD1KZTtPeuOMFunTtqgV2THKlnQqNILufeqqZ"
"J8Q/8IADtFszhdeu8IOrabNmpkOHDlqzQD/IuK1a0uGniLtlQB/WzLN+oD9YzLY26fDTFJWe"
"aTCa0icofHRFHxox03Kmhij6DcIAFKPG7eqdDj9nBvo89OCDOimW521yhJ/zwxRgGouCs4lj"
"+i9bulS72UybNk33gkJOHUaY59DYTPhRkpz/GYKffnuu95dC0pYO+beF4FotQoyZWXRVp4XQ"
"Kd27q/Bxwb9h/BQRN23e3Bn/hvFTA+uSf9Phr1O3rjP+TUcfbRkl8toF/6bD75J/050f5d8n"
"n0zLv7GU2IcffmiemDdPEX4qlgN1W1Ra09fs8zVr1GrEYlkXs0Enf0sb/tdee02/biBWLn0W"
"nxGt/Ir8D34qyF3hp/qf3o06pVQ29xuYIEExdRg/RYGPicB4/fXXzRdCHywgGG1djEmomfAj"
"kHRYoBx8isK/ScDI6eiDl8QkAQ4+TTmTCLl0+BGeNP+kITTpslihxWNa0mH8MC5dAJhPpO3T"
"Zs7U9cctmA/jpxMNc44QRHSkmT59uuIu5uj80NGG9R5w4IHaU5B+gowG2eBo/XipzKBi5IUT"
"/hXeXLZsmSpx1o0Xw9mnF58T/g3hx2CYLwbK2674N4SfHo14L7S5csK/GfDTxMEJ/6ahzz77"
"7eeOf9PgV/5t3doN/4bw06KKfW2QgX9jPYXFgQT3FERPzZ+vbaCGDx+uTSghDpZW3C7TbKgO"
"QbvvPtW+3wUMSzsVmJgqb9qhuMJP+xOYlsI+BI+2bkkwOyiMHwv0CWGyiy++WN15+pxBt7jP"
"SIcfL6PHGWeYCuIJcPgRrJsd4Yc+KJgHHnhA94BmoH8E++EKP9bb5MmTTTlhNLwOnrHJ0fqh"
"Bd0XGKoH/nbt2ytuV+unTRuFmoREZ8+ercJit0qVYvesC+Nn7ayVfcWDogM6lvXmmEIojP/+"
"++/X1nJXXHmlE/7lPKLQm4t3REuo9SLsfw/Oowv+DePHCFL+Fbwu+DeM/wU5m9Bp0ODBTvg3"
"Hf75IkNPd8S/6ejTqmVLM0m8JBf8mw4/00XwJF3wbxg/kQh4gP686fg3lhLjsMC0HBhirVWE"
"AZgt87BsLjPA3nn33a2MF/MQHX/CCdoo846xY83dd92lvcfobkzHDvqo0TsNBeoKPzFYKshL"
"BJXvSe7C0uGnJcyd48bpZp8pbjFWFpOr4448D+M/9bTTzJlnnaWNk+eJh0zoAwaIe4jC+E85"
"5RSdeTTy6qv14AwYMKCwp5kL/E2aNtVWY1jn3333ndIF7yOupbvN+RGcjKOgHyh4KwaCwtX6"
"OT+EmLCk8Wi0K43sb9zu5GH8NHYl0oGSx3vi7gpB7Wr9WLhPPfWUCiEX/DtIjLU3xPO65ppr"
"9C6Me0KGHepoJwf8G8ZPT0N4llZ1Lvg3jB/vgkGThMhc8G8Y/3nnnWe6detm7rzjDif8G8bf"
"p08fs9vuu5srr7rKCf+G8Z988sl69vHwXPBvGD/GAk4TEcB0/Bv7Zlv7fuG5yAeb2ptJovvs"
"o+1VmFjKRVzpmBeHhH2wOBEMx4l1O2HCBH0Go1j2Fbf4gvPPL2wQ6QL/VGHenWxHaQf9zML4"
"uawlVo+VNWToULNGfrZ0yZLYzBbGP3PGDNNdmIDuJjTJhP4c1riWXBg/g/UYjooxMfuRR8xN"
"N92kB3RjzJBNGP/smTM16eIv4s3Tn47u2ypEHa2f84NlC104P6OuvXZrKCWmJZru/BwuzMZ0"
"WtvIunSCpJQwfu7a8ACuv+EGDcVBf91fR+vnaqBt27am8sEHa1PXpPzLmI5zzz1Xw9uEESdP"
"mmRq1aypHen3c8C/YfxMXubc29B6Ugjj318MaNsv0AX/hvEzmePBhx4yewjN8bKT8m8YP6NU"
"JgoPI98eefTRxPwbxo8BRJf7KrJ2ohBJ+TcdfWqmnJ8w/27TxT4q4I7iMnIXQEydUBwZI4wA"
"QGDTPZm5Yf8Uyy5v/HI4vhWl9XPQeh/tWypo/sm9FZoey47Gwcvl+Unxc0m4j+BD8GDxkvXC"
"8DXeI1axXgg/F5+EWwnRcJAIrdD7kbvED8S6SIofBU+IV7ObVq1Sj28Pwb2fvMOH8j4u6I8F"
"zTPwVpfLnuqIcnmnFY7wQ3O8PXCzv6yf/X5fBJQL/No8VvCTdAH995T1c25d4P8h6HL+pewz"
"wmd/YTQ7ddjF+bGhMp6ho45EALncX84PdxjQhxFLSfmXEJC9k0I+2Ia38JQL/g3jRyESqaGh"
"LN3ik/JvGD+0Z8AkfMXnSfk3jB/vEZrwDi74N4xfexUG/WZd8G86/HYPXPBvuvNDj16MiXT8"
"G9sTw3XfIi4pA810xosIZ0YCHBR8jTUaN0V0nbjtxMvRtripTCvlQP4hSpPn8VI6HC1m08sw"
"fjsDBxsOTY+wLp2gwXAYPw1LCWfxNfcYbLp2+ndFH8HPIcLFhi4cUBppxk1xTUf/XYJnIECZ"
"HwTuuDQK4yccB25CHCgAvGIEUlxLPdP5sfThYh4l4wp/xaCLN1m6CLmkzV63OT/iYdv95V0Q"
"Dq73F5qTxemCf/HmNouCRBixn+WDXqecHRf8mw4/68WAcMG/YfysXYf9imeBcE3Kv9usX7wX"
"MhSZw+iCfzPRh+7xvzng32zrd8G/mc4Pd6vp+De2EkNpsfhywXgCPiAKGw1DJxm3jSbXmgMu"
"aINnFQ9qAhDYRYWfd1DCBAkeLvEj3GwdEc+BAeKGI7LRZ3Mw0sZecjulj9k6IgMGsHvuev1F"
"fX5QmEVCH9nPwhB7wnDWf2p/XdG/RHB3jfBB+OtZJ1IjggiFWVT4eZdSwTT6JHuQDj+wSWSP"
"C/7NtH6bPZh0fzPhN474N9v6i/r87JyGf3MqsQsHDlRL0MKtN99s2rRrpxduFs475xwVDnrR"
"mYd1kjrpmUtTUofRtrNnzVJLJ60mzwM/9WzdunfXl6eIE9cUwnAHkzEmnwfxmWyaqZs+dUOE"
"XE899VQzoH//wpk5+cJVV19d+Dlhn5EjRujFb+cuXdLSvyAP+mAxcddSK3D3cdWxlrnbef21"
"1/TdwtZmtsNvJ7ba93/xhRf0YFuLPvUskSn1ujyHO7A/PSPi+lPpko724WcXGl950Ic73vbt"
"22tYB7BhGBIiiApoclNMZrXrp3TkQaEF9y0I4DCNsDq7xzhDUfY2Ln+lTisOwxXDhyttwL8N"
"7aFVRPrzDLLQSBqze8qd3ZKlS5WXEcRh/MXy5F/ow/2g3VuGcIKTbEEM8m3WH9NzZE8p8p44"
"YcJWr4Woj6wzHX0KYspP1k9SBZmyr7/6qp6TdJ50VOWVib/IgiZTk/cIF3tH3V8yD086+eTC"
"r1n7gqefVjql42GrEDPRJ6cpcd2112oBG8Q5onZtM09eYtQ11+g9z+23327qyYKoLVmfZ7rs"
"cS1b6gaA49hGjXRkN4zMhSC1Z8SFE1mzwkQosJv/9jfTskULfU7tI47Qe6lVq1erW50UP4r3"
"vHPPNcccfbTS57Zbb1V6kCVIePLhyZPNqd26mW/lcK2PmU48SDb2jjvuUAXf+sQTldZ0SWFE"
"OJlq9evV0/eJgx+lQ1z5/PPP18L1maLcuUvQaa7ynHyLde+66y5zz913699TlEs2INX2ViFY"
"AVyzRg0zYeJEDRdsjJkmDl1gJupJ6hx5pJ6h45o313o87pDYj7gp3FaIUgjMvW97EXZNGjfW"
"OiGUGGefe7ZNCdK47frrH3WUqSV8xR0VtIDf6Dhx3ahR5p57791akNyjR95nyPXepgKhIxTJ"
"aaJcOfvNmzUzH4iBiDB69tlntaYnbvq2pX0/4Su8w44i7Jo2aaJJCAg/ioDJYk06FLdPv35q"
"5F4oxgF7S3ILDRuoXYsjz7IZ0ni8dEThPpMzv8URXmTNuWLAQn8EPuURX3355dZC+wTF3qnn"
"82lRLnVl7Zyhu8aNM63btNFwNvfAcc8/9Yh9evfWz5Fjvc46yyySc0MK/QoxJOC3sSKv2eso"
"GZQ5PTHi11b4EENHMw6/4gpNB+Ulcfu4NMzHy9CU5KZNzfjx49U6wfKkXczN4uWRDko6ZdJN"
"YIoqrjkF0qyNAsJxolxo3QP+fdIM3MvrXkGU7JVCBywsBFvxIFyIV4G1ssXOPqtYcasLHzP+"
"zN+9L8LhggsuUO8X4YMCPUIU8lsiVHkG8e588SMQuD8YLBY13gBJA6/J//eL4EB4IOzy7UhQ"
"KrigRslaS+vnX35R44S7liUvvaReJFlHZJMluXfhOaUCyxi6cwa5eyQNXe+pEg4zxMoFb9++"
"ffU+E1o9/thj+i7sse04kXT9ZI3xDPaSc0kEAiMOA0X3lonGQZg+6h4Xxd6mAgbCtWLIQgMU"
"JdGGww4/XI1FlAu8kGRqsaV9P2gvRhBJINBevQjBjSLQ7MmY+AvpM3iwNmiAPq+K98J9F63z"
"KIwncUBc38TKBnzINTJLG4uSeVWet3NwB58EWDNJaHiP8NGiRYv0XOJts7+bEuxv6vnkTBK6"
"Q8aRZa13ViSriSERd64jPFMxGH6J4ca+0raNjkDwAne/7E9F7k0jtPaKpMRYKC+CwrpWLEQK"
"U6mHQRDpJTMPy4OZaVECYL1BENJKqdNCcY257Tazm3yOJX/a6aebSsH0z2whonSw+vPP9f9x"
"4h1greNio9mnTZmihahkCxKmIVREmA4rgJ+jICLFc+V3uGTc6dBDNSyDcNAR2yJIwc3l6bnn"
"nfenEMuWIJ6e72EC98vyDs3E4qLrAW487WmgFQy+T4qXE9mSkzUC0AZ6V61SRffiow8/VE9m"
"kAhAFA4eIF6xFsfec4+GZAlrpavGtxfeCBmsctK3aclEptLBssfPiFUHTpgYy45wLLhR+jY8"
"SrgaIanJQlnuHHYKDANogVF0pnhNfP30U08pncm0w5PaP9hfvGJSo+1ZzgWk9NJSjQ4BGA+c"
"Uc7dHBGm35HNKjQ/XwyL/YNQY8bwaI71U7oAww67/HJz+bBhWy/c5QO+aiBezmVCo3zPUK69"
"PeOMM5S32FuMUer/+D3C+C9E4DHej7ojDDRG11OnOP6++3Tfaf004qqrYu+rpT1rY63UgFna"
"LxSDlE4lWkwu68XbhHY2JIWRGiWhwNKHs0INJ5mHTC7+UtZHfZJm4srzwtcR94vRjYyyd0pR"
"ojWshRIAlEzr1q3NfDH8iUrsLArCht85n3jipMJXINwYISGCLEa8ohEjRqgyQx4jI74XGcb6"
"aV1Fq6bYaw/OJ6UpOBmc85M6dtRn4dVfLueRsox85EPq+bETnFkPcg1ZPEzOOvvK89rIu9Ee"
"zcr+LnKOaKpBHV04lBn5ZhKte58QggfQ7JGFowy4qM3XGrXtTojhopE5eFgmmkYph5L+aseK"
"1fLmW2+ZFvIsDmfDhg3NJ598opZZFCDTir8DEHC3iXtKxT0WI4rxzF69VOgcL0IV6xHikSL9"
"R0QPsFiw0QjQcDYa9KAO5xZhXIBDDPPFrfvAGuHwnBQUFaJAeTbhCZ5dJoaXZzOTCP2gePVg"
"yB5YJfzoI4+Yfzz6qB5e3H8A6x3BviFHKAohhXAm/IlVCL3xtG0ICCalFINCW9aPoBstlioM"
"UUs8TA2PRgx30TPyOTGqwEGIj3ZA4Kd4FM+PNXCHhTBiT6IWYLIuBAIMt2tw3wh9NDVZhNvp"
"ogQIdXB+8Mh7iMCgfRBeZj6hNPYOBYBgoWCdUCVeF8/6QOjxt5tuyvsM5dpbapzYU3iJAtJL"
"Lr5YzxXPRjjmCsPakfV4YT169DAvCZ0JJcNDawXH3SKMk+wrfwttOfd41zxn1PXXm7tESM6a"
"PVvpRIcR3olOFBcNHKhGI0r0xwihTEsfkjTAj+IYfMklZoyck+kzZpjbxoxRGXWKnCE8Tp5B"
"o+SjRQbREilqOyhq+t5l3pXwA3eRrBGjE55ADpHNTegMGiFPubf8JaJ8++Tjj9UwQ1nRX5Bi"
"7F7U6gqtkKEoyCRrL7w3FEX1lBiftwttOPeEF6HNhPvvN4/GlA+pgFHb6+yzNWsVg6V0UA5A"
"JAIDC0BH0K6MbFZ0wLrQVVNe2YkcFph4khAPJsYyIi6ab5aOZcQtgYC2fw8j9xF3EobAcqCT"
"AJ4UljACCCZjk6wWz8poInyID4+48kq1AHFTKagdLAzLfQMMh+XAWs6RQ0CYDm9wc4J7jj9Z"
"G/JO1qJCQGh2Ipk2MXChMN8XQUBbGjxHNntZcHCwtOKEJgoLEWVNhA3shSltXWjWer8IVmiC"
"8ULIF0GLIMfyzSmkZR9ZH50I+H3qRxB0qZfL0MMqtaFDh2q7JhhyX7FSsUwJl5SNEKp4TTxs"
"vIrz5VkoHMIfCGoSAvhAEFkgdGFDdlGs0S0pmWj2txHGGF30A7z77rtV+HBXRrcCQryLX3xR"
"jbGo6cXghnHHipC4XgQ13tL6IP29IOYZyrW3E4S3EAR8jUBFsKLQ2A+9p4wYisKwRCEQLoOm"
"GJ8YdTZUGXdfWYvlQ9bO/cuF4vUOuOgivbuaOnWq4kEe0ACBe0UA/Nw/wdvZvOFCQ1joY+UP"
"d5EYzghl7rnpUsM7EQYsDKOKDOLeu0LEYnaUVlXhVQwcC8c2bqweKryFcYSiQ8nTnSIfPuZc"
"LBFjZMqUKfp3Z4gxgbfC2UFxJl27hTmPP677iCFEuO9WwcH55x02xJUPKYAHefPf/65KGNk8"
"SPYYvKTZ25AoypK7VuQ++ieMP7L24bDbC220MK7qwZUrx7rgg1Ft2GBzSg8sGABLFmuOUBDt"
"dm695Rbzf0EFO0wWtWll3bp1TQuxQnjpGjVqqCvaXxgBPLYQVb1JOfCHyUEjdo2bn2S8SNgb"
"sRZf0vi3tRqXBSFFQhB8bkO9ce4fiKVbQZTaaw6mIrGAewHeAeEM3bGUateurUxeKgITYBFj"
"5XOhzR0E1lpqXZBtXQZw34H1qHdk8jsI0cjdBOTdsaS5n33mmWd0b204mDsVDCCSD46qX3+r"
"l0O9TwQm4y6JcwOT6hm1oSihA/cnfA9hSOgECxXvG7woyXytXQQSSmXSQw+Zfueco0Wd8JuW"
"rQS0zucM5dpbOq9Y5cwH4TQNIQZlJpG8DBHQdPxAANFxHEVIiJF3SbqvWOHQnr/T/pB4fkFd"
"ljUsuIfr2rWrXm10E4VjIzwo0FydTFZY+ohQZk3sJXS2BoOmdQfhKmhWu1YtTRzq1KlT4c+j"
"3Puv/fpr9dSPFmOcvycMRw9S6E+UAB6+WDzAuaKYR4lhXT5iKBFo36GDKkn4EWVIy7CLRAGw"
"l4Rhk6z9z+xVTPeB53wvsp9uGihM3o2fxZUPqcoVHkKnYKhdcumlZs0XX+i+2FFGnFlyGHhf"
"eC084igvFwqBCTJagXB4Lho0SC9Df8kzhAKRsSK4WCXBA+sPC6GLHEZixoRl6ovQobM8iRMd"
"ZQMQTspgEZ8DEUih5W8RasS+Ofhky9EmhWf+VVxuoJEoS+LVJUqUMP+twNrYzJNOOkndbQQp"
"oagyMRNGcM85gNyH7CqKnAQM2j41FkuRjDjCPlagIZRsWGeXHPefnBEOGn/LpfnJHTtqTJ7E"
"mlJh+gb4uV8Ct84sC1KAo54mMMD8eAEYI3SaQIhh4fXu00fXS++7adOnqwerDBBBUHP3CPNy"
"T8Fdgo6yEGHAZTOMzLywLsF9D4qalkFEJiLfdQqdDg368mGVI0ShF3cyNrkgbgZelL3FgIMe"
"8B/3GwiS34M7tyhrJ5MPr5Nu+Nzf1RAB079//60NbINwUtx9pQ8rv3vHnXfqmqAPYSfu4FGG"
"GBYITDxgPD2uC6zi0PXneAeUJOH5kSNHaqgb+rAXNHAmgsJ5+uyTT1Sokv0Hv1FqMeb229UD"
"jNKOi+QUJhqwrxoqq1pVEyOISiCMuS+GNj1FBpF9iQEAjxPujrIHRBUw9MlIRMFDm86dOytN"
"iHpgBMVd+5+ukWQ/oTdGCuefM0M4GmfGns985EM6Yx8+4+/JfuTsc6+KjrAOC4qdUDgdXlDY"
"pUIGXc62U+E6MTYeZYCWt0BKOdZNxSBzKxXStX1ByHCReaRY6IT5rItPjyysNxZ6du/eutEo"
"m+uvu04ZjctbLoi56LUWS6a2MozfYANYDwyncWQ5mH//298Uz9FinV84YIBuzscrV6olpFk4"
"oUzLXG1rwjUPhC6HDxummUh9gncDevXqVRh/T7V282mLw6aSDEE4hUQUwle25VcmyISfA4i3"
"1FmsWZjX0of7Iy5nLxELkbvP1H3/NWhTlBo+TsWfWieGJ0OXdEJuhJsQoA2CmhyAsgEyLi3Q"
"3xAa2YSE22+7TZn/PTlX6dYfrmPhfg0PhMQKQlB4H2fIemA6UrIJpXwq70fCxy7WIMpCH1Kt"
"+Y2eZ52ljAUQprlOziKCBsF96ZAhejeDsGM/GMGCAsdby3U+U9ePsUbCyK7CZ+wlSR6EsxBQ"
"ZAJnO0Pp8OfaWwxRvD28PhQNigCPFe+Hvn3wAwID3kmH/0hR2hgn6QA6DxSPINe+ZqMPSguj"
"gTCxrePiDohrBix9vO6uQh+Ll159pMnr/ZAYLgfI71APWiwDfvgIr5wmyHxYw5q7KQxf0r6R"
"b+wtyVkIcZoWcw1BiIu9LxdkLqbDn8oHhOMeEfriOXUSJWPhbyKHOgoNqwS/x/3z38WrPTQw"
"xCyPZTo/NHEmDEm0yibKcc9Moge1thhHnM9sa496PlOBcC48cKl4TKlnIIp8yCQzXxHjjXAh"
"680EZLKTwRtOIgR/TiWGEvlYGIA7KcIkaHMOONYLiQUcOEJ2FCLSBSCs6TMRCQ8ORbYqqJ2A"
"YazGZRMJUUJ8LFJLGA62PkusjvJZDpGGCmUjUSi2poS/x8LhGeBA4ZJYQiIA4QQ2m3guSiw1"
"dJNLyWApwgBcyn4TJBXAaHgGCEIu5L8PeutxQLl3y7XJmYBQCfOMPpFnYS2SdWZDo/kqMWw9"
"DjsWO+47tMUSxJPCegMv9OG9sNpZP3TnZ6mZQan4uZTGcyY5AFrzN9ASPPwPfmihvf9orSPP"
"wKJD4GIoVQj2xIYnUAgr5QykW7+GK8WaxsPjWayLv7GNa3kf3oufg48ztEfQb03vxHLQB0NL"
"a6rk3HOGOCOsn79FCWD18y6rg2QRzi/vwBqiKEmSLlC6rA+c9LFjXhhKDBqSVAL9YFhokOkM"
"pcOfa29ZP1/DH/A2P2e9RC84V+wzxh10zKRk4NsPg/s79g18fA4d+BqjlNBqpn3Nxr/sJ9GY"
"MP/ad0BGIIjhN94RntOQrLwzz8LIRdnzTpnor3wruKkJY60a/heviXPKfiCDeN6qYEyTbezM"
"+eEclc6ihOED+Ab5CD3+IvvK3v0o9PgoCNVz9sHHu+nsuaDDP/Sxa892fkgKAf8PwfBM672x"
"dvbO9mzNtvZs+FP5y+LlXeAD9oB9Zd38PKp8CMtMDCv2EHz7Be292E9ClaWCfdgQeOLsOTpG"
"601TwpXgj5Riz6XsroGrbmPeEIXsxM1BJhWWTz5uJIvEKuYCD0sWBuJ7tpUVeLXpphwIq+Bs"
"xlKpCPcDbBTrZo0oTLIOEUysvUKQhsuz7GaUDt4p335utuYBAmMBFgvao9iOCIS42AjoWD5o"
"0ZUkpAjNygUp0GUT1LEUC8JCJIrAPBzEVPrY+5JywQUr74IHkC11ln3hMPN7GloMRohj7duu"
"3OyJPTPQGoEM/UsESm7voB0S75Ztn7Vhqqwdo8PeGaWeQT23wsysBSbgrhPDRacVRAlzcNcm"
"v4/AhTHXB56Z7WYOPcDJO6IwWHtqG7YoWYl4bNQzcv/C30Er8KDMUMbgh1b5nqFce2vHKLEv"
"2pMUvkJABYKQ72XjZT2Hsj4SNMIhT7uvGwPhnO++2nsYkmMQ/vAn94WsDOG1U5DIxDlUYSrC"
"ze73pqBlU9kIIWPkA2uClzSRRNZWOkgr591LBR1BrFLhXbQnID0Ic4TkeD9wc96oa7OdVnaV"
"z6uJhwcu3oFnwFsI9YLg98KRmowZnLIWrkjYQ84GH6nnE7pDk3zXnom/ChOROKvyDGhFFivK"
"Jap8CMvMQ0TpYezb+3HlIaEB+77N3wS6Id2VTyQlxoEtknseeRmdvZTGm1DLVghkD2ne2YGB"
"AC6XRdCXyPHzqM8hayZTxmT5QKC7ANu7sEyC5qZhfDBzaVEkuwX1eGFGz4f+2i0bPGlwuQYO"
"/d5ZCtbVmEhIK5tKnimbToUqRbGO1x9+ZpzC7Vx7a+8v4xSr5jrzTs5mUEaSrf4R2ZRkDSiS"
"XDIGoVo+TxmRiQ94F1c0KxnMPswGcdYelb/U2BFllnrV9J86PwXGgwcPHjx42E5B78Q8GTx4"
"8ODBw/YIGk6MMxQzKsQaCujxe/wev8fv8Xv8EfD7cKIHDx48eNhuwSsxDx48ePCw3UKsFhXU"
"yFCRTmrlggULNIuFjtukqZKmSxNIOhqUiTmmPYyfNHuKMevUq6c1NM8tWqS4447BSIefXnh0"
"hqe7xHPPPpsIvwVa85BZRgcCGn7S483F+tPhJ123prjtdE+hsweZS3Enz6bDT4ErBeTUdzwx"
"d25h+rwr/BS277PvvtrVoCjob1OmKWadO2fO1jTnhC3G0q2flPglixebz1atij1ePh1+SheO"
"P/FErW2a55j+1BsdfcwxWiDugn//E+ffnk8X/GsHilJ/xRQD+gSC29X60+EHH3PlXPBvOvx0"
"QKoh8sEF/6bDT/G1K/7NRB/Wm45/Y1GpRatW2i/trbfe0g7KHHi6nk+fNk3z/yn008FsMQfv"
"hfFTH0bj0hnTp+uIFirzfwyK/Fzgp9ahZcuWZtrUqZq2SwU8hZpx8duNoFMIbW0oXGVcBcKH"
"ughdfzCPygV+CjabN2+u7VooGaCAe0PCeWyp+IvTLfz445U+rJmeefTMTDKTKoyfOW/0f8OQ"
"SLq/6ehDrRGGC8KIukGKjZM0ew7jZ93QhwGytGSj9miTI/ycHzqH0KkCnE0c03/BM8/oGBZX"
"/BvGDx7Ovyv+DeOnFs6eTxf8a3tMPizncabQxa7fFf+G8bO/dFZxxb9h/NSNoWRc8W86/C75"
"Nx19UFqZ+DeWEsMapIUMm8thYUAaD8VTol8Y7Xe0Cj3mJoTxf7hypXb1oLiPw0u7FcZSbIjZ"
"Wy6Mf2fxzJYLTnrXIZAgIhbLugTTXbEY3nn7bfXysODoN0k/PvragZ9OBK7wg4tZXW+LUmZz"
"qYLfkHDybSp+Cn2Z40NfNjqGYAHBaOsSTMfeBr8ICIre8ebpAvBNQkYO04eiVWr2OPh0BUhq"
"pITxU1dzYuvW2u5HpzNQLJ7AE07Fz3n5l+wrbbuwTGfNnKnrTzLdOBU/vISH4Yp/w/jpMPOz"
"Q/4N46c/5HsO+ZfzTduodvIM6r0wGt6WZ7ni3zB+6Pziiy86498wfmjOCBVX/JsJvyv+TUcf"
"26Q6Hf/G4jIEDv2vsP5RLgghLCBmf9GHTYfWVaqUV8v/bPjxlOj4wMbSBoi2Mjxzc0whFMZP"
"L0KINHz4cO1XB3GwtOKOt8diQKnDvFjOtrUMG6AdI0S40dLIFX7wMr6e8AMbntq53AV+hu2h"
"JJnHhvCYOmWKvk/cZ6TFL94Ao2a0gSwNd8XA2OwIP3hoIMvgSs4RHRJ0/Vu2OMNP01UsUTpA"
"MOCPZ2xytH4UJA1f6c8I/nbt2+v3Xa0foLjaFf+G8dMsYbND/g3jx4t0yb9M8mYGF82Shw0b"
"puvcEJxHF/wbxg8+jJNijvg3jB8FD3+54t90+Bc45N909GFfH8rAv7GCooMuvlinCs+cMcNM"
"fOAB7edGTJp+inQPpwJ+F/koHjMmGsZPh3kalzKqgkr+6jVqmPnz50eeexQFP4066QxPx2f6"
"pYE7bgEdIZOSQZssXG0sB+4NbX80ekLm06k9F35mFH0hwgF6u7gLC+NnyirNjOlefWbPnrp2"
"7U4esxtGGD/jFziQd44da45r2VIVzrvvvhtbCYTxD6SJtVh0V151lT5nwIAB2lQ67vkJ42cs"
"EcYQFig9Arm/oidk2Zh3SmH8zMVDKNOHE7y000JQuFo/54d+iq74N4yf/13ybxg/DcnnzJmj"
"jWQJySXlXzqcPPHEE7qXtK+i/yTyzRX/hvGrxxLMNnPBv2H88Ok1117rjH/D+Gl2zvdoMN3C"
"Af+G8dM9n/M4IgP/xlJijKI499xzdfYXYTKYi5gxn9tmk6UTXGqH8dMJ/UHRwgwNJN590003"
"be3FF9MSDeMnDHH77bdrLJeYNJ28bSPZOECHag464SUsxBtHj9ZpsaMFL40uLzj//MLeii7w"
"41lWDzpZm2LFTFII48eisj3ZhgwdqjOAYIi4zBbGz/TiGTNnanNSrPQbg/lxcS25MH46e+PN"
"s95Hxbrj/BBK2RgzZBPGzywkRr2wdvrH0VVdhaij9Y9OOT80lx4lAklDKTHPf7rzwzMYUeKC"
"f8P46QrP/l4n/FvNAf+G8eM9MjGBcSd4qkn5l16TV1x5pYYMuYckfFtXlJgr/g3jp9Ex/QKL"
"OeLfMH5oBP+yry74Nx19JkycqI3hKzvg3zB+hm4yxRrl+8ijj27Dvzm72KcDrE4bs8XCYkMZ"
"fofm5Fjyue2uHqfYLYxfm2XKgSGmTod07YK+++7a4JROyy7wY5UwnuKfYkGgyOhivbsI1X8u"
"X543ftxdwg3Ebbl343ngZJYQsXWehTXNpi+X5yfFTyyaC2doTsdzsngQdjwzDv3D+NlXvG0O"
"F9Y536MnIY1xP/jww8T48TI4Q9xbsb88J8n+hvHz/56yl5rhJHvNKB4UJp3jVzjCr5ON5XwS"
"WmF/WT+C9H0x8FycH0J8NAYm+47v7Rl05HeBn/PDeaEjunHAv+n2F5pAHzIhk/JvpvNzoJwf"
"F/xLF3qMEOjyRTATjA+a7ZIMlpR/w/i1izud52XddLlPyr9h/CgrBhj/EgxaTcq/Yfy2jyMK"
"nrvVpPwbxm+nm/A/3mqYf2N5YhB7sxAE5uLA0z0corDRxC/LJkzN3QY/E08FNxlmdNNHONA8"
"Mm4Kcxh/uWCiKsxFZ3FrtcRNEbWNV0nl5+J5ExOjZZO5B0BQQycdHhdz4vM2+ANPCeAgFU+Z"
"Ku0CP/RW1517DWEAaGVHM7jATyiLGWB0g4cuOqYlwf5ug1/oz3r5PiN6GEoI7rg0yrZ+zpN2"
"DA863bs8P9zBQB9CaSgZZ/iZKsCYmeC+Jyn/ZqOPC/4N49eZesGoJhf8i5JC4HPeUVY00UX+"
"IJxd8G86/OWCpAUX/BvGj2ymnIi7PTz4pPwbxm8nMJCR64J/M9GHZ6Tj31hKjMMBE6G8dJS3"
"fF04dZkJrgnd4XT46Shus1N4lk1icImfcBkhIBi5wIFbz3O46LR04eDAxEWFH9AxFw72IIwf"
"Om0K6gDtaPuksfvw+qG/i/3NRh8YGgYoFkwadr3+oj4/ZNIWCX0sODo7/4n9RXG5oL+VDxWC"
"6QG61uBuyQX/ZsK/xRH/psMPbtbugn8zrb9sMELLlXwO48/Ev2mVWKapnhSdEaMkEaJ1mzYa"
"Ornzjjv+v9WZ58YedPDBplv37upOEyYhtIdimT1zpn4vPGqAg1OQp/UQfpcrhg/X1E0uCy2c"
"d845atXpRWdE/Pz+wEGD0v6MZzC/jHdQQgd00c9z4Cfz6oQTTtDPubyk3oIwWL169QqnoZK+"
"ukcwAoRJ18TUCyeqZtkD6H3mWWfp51hNl158sQpFazGlTlzlGSNHjNDDVDo4NPkc+tT3SAd/"
"onkKfXLtb+o7pALvwwTdN15/XS1Da2WG7xlyKa8o+Mk+pLg/fP6j7C9AhthRKVOuLRAmoVbr"
"9yDbF3ztgt8N70dUsHv6fzfeqENoOUupAjjJPUzqHkMf6IG3RbZg2SB0u2sKn5Ad+vobb2yd"
"iRZBNoT3YRu+Cq0/Kv2jyp6wp1KQB34gdcIzspOEFu53SFAI824xq7gi7kWXrl21uUE64ByN"
"u/POP0UDwFoQ03MMvwtAbfAsasSYIRbQJKp8DuOCDhcNHlz4NXhffOGFrfPDQvjS8W9aqTRo"
"4EBVVtRS1TnySHOsCPzJkyer4oLgXOQtW7pUDy7TXYlh5u0yykHhEN38t7+Zli1aaGJF7SOO"
"0Pg22UW/JahBCr/Lm8I4hA4bNWyoSRz33nuvpm9S88H78bz1eabLEl7g8J8mAu0YEWjNmzUz"
"HwgjcIAYtU29R5wU6EULF5ohl1yin8PEa6nn+O03vYhFYBIjbn3iiaZP7976O0zm/fKrryIV"
"LrJX54ryIFsSr2q33XfXbDebRXTQQQdpHPr2MWNMGzFUkhS8IgRIy28sgo7EFqC2MF2Xzp1V"
"YJBUE4dGqe9w2623mnoipBlNT+o249KpWeQd4maORcF///33m8fk/HD+ucPI9/zPFP4Zff31"
"WxWa8NTRoqT69umjd6bHHXec7vHvQY0Nv0vqPinFH6xYoXTLy1AM9pQ7FmqokhbBWyCLFAUG"
"3yIfBg4YUJiJ+GlwLwIwkfrCCy7Qz1fL86Hj7xHWYPcBowGhRmIFSVjgjVta8O+UPSh47t3Z"
"32ZNm6rxwJ3gypUrzZAhQ/Lm3TBgfI6VdSPTHn300UJZPeDCCzUcSeIL++4K7rrrLk0osmeW"
"cobvmdYdY+3gYs1At27dzGOPP266n3KKhhDPkT2H7yjGjpq9WpApJmmnr+IecgEIUezPvpMH"
"6DRU+RkXrHEYg4m2/P0zCxaotQDjYj2wcC5sNyYs1k19l7vGjdN13nPPPSq8SSE+onZttezs"
"dNh8002xoK695ho9+MTkyXaktc6F/furwCme4gLn5UozOVWEwQtiiUCfHj166JhxFA0FnCjk"
"VAuRezwtMoyQCcSasJzwqChepvodJYblD2NDG5S9Hde+c4IstXlz5ph7hd4ItvJBWADhxVov"
"GzpU6WbDlPlA6jvwztCCOy9qzXgW+8wY+LiZgVHwcw+jyl3WDq3yPf/E9m1LJwRd+WC6MAoR"
"CxVB+mugGPldtablWexNPkYFni7rReFSW0a2l1UuSQC8TUUwjx8/Xj0LDFsE0M1iUXN3oQkX"
"AU0KJy3zrkESzKYIwsnuA5OEtwQhMLxQ67UkgX+H7MF4eFWMZE1i2WMPc7fIoNdefVXx85Ev"
"74bhb//3f+app576/9GMQFajJC+99FKVIy5nbKEP7IBNzixyE0Uap3UVuOaK4vrggw800xQZ"
"Q5nK2LFjzeuvvaZ8Rpi4RETcJTIJfj5YIETicq27WC4c1MUvvaQXqyWCn40Xq5QK9vfEA7kz"
"5MJmg9VikQHjRCtjRbwuG0zobNqUKaaruMr9RCNb17JLly7mqfnzVfCWDy748lFiTB9FkV07"
"apTpdfbZmgn0uAhZ1lm1alX9Ol9hjXDDk4HYjLCnxGD8ffepoOktVjVKLc76Nc4vv4NCQck+"
"8OCD5hMxIKhh4z1gYs2MEkYE8I7Bj9C7T5QG1jYX9OlCf3yvfCCgybKikPB+EURYnnWF6T4R"
"yxC87C3ZQDzvGLH0bIiRdkTUgvBzDXdloU/pINsT4bt7MOGW9+KSf29RCnXEsu5w0kn6Pni0"
"YyPiTX0HvaOQdeLhNWveXD081nia7MVpp59eGO4befXVWntCmOuFDGGKfPAfKVa7Had+8y23"
"aF86wn14nOwt714sh5daLpj4zXRcBEIj8WbIAH1p8WIVbHT+gLFROmS0muAeIx+gHAXewgCl"
"EJUQKB05UAaUA9hwGmeH5xCGJcRcUX6e7VL+8KCcg8gD+wcu9hjFRf0ltOZ+qk+/fpqoQBsu"
"S9uoYPcBgYe8QdYggzp26qSlADyXdH3ofrs8E0OCPYmi4LLJHpQz6d3QgxBgZ+GttGH7HPC+"
"nD32D0GPYMaYwHNifbsEE43z4d0wcH4OqVxZz4SVKdAIj5v9pXbrJOEvAGVKiRLKoVTMkCKy"
"snywbntmd4mrxATXXiIHkD3QmpIU6hOJjHGWMDJ4h55nnlkYdswWYsxKrbr16pnn5ACOHDlS"
"ew327t3b/CRWxC7B5SZMx8Hv27evEo8F0DkiSjsfrDKsHw2byWJvkw2mohxvhpeBGQCYga/J"
"BELIrothSRL6w9t46KGH1LPBEqK4GaFKKmipGN6GHV2PFwZOOjbgJsPAb4m3dIcIzyTrBz9e"
"0j13360KnY2nkp0Dzuf2oMMEWmc1Y4b2l7QlCLkAYQm7NxQlBYNhiFA/lyosUWIosJvE6iOk"
"Bg2bH3ecWUsIJIf3weHGoOH9U4UvTIwi414JGp0qa/6LKFAYmfBEPlbpeeefb+aLNXq60B/B"
"dnavXho1oAUOwsmGuy8RwYxiwKOFPlE7LWTCDyPxHhTAwgPgx9rGICLcmI8l/4/HHjNTp00z"
"/S+8UO8ZRomhBU4EIHQnZfyYY45RnsrX4yOtmnV/J+cIL4/QGeE9QucUBdMVoakIO+76+B1C"
"4gjSXPSx/E3pBfvLPqtiFuFGdiblHoReiUjgFaAYgPUJejGqdy9GIHzL/TDKcdhll6nRQyo3"
"exu1DVc22UMJAIYaygoFNvqGG9QYqiWGi147RHyH57gzmjlTFQlG1N9FCaK0UPY2YSEu76qR"
"GCh2cKXecSIXatSooSHev8q5pQsLhjZnir1P0mrNJSAf4KH7xPDHKLLRBzrFYEQdK+eSiEq7"
"tm31yobQNbShfVk4epNVieH+8vKEDbDiOCQcHmpUIBxuOA/gvgZBTfopIYso90tcANKJYIRo"
"YghOWILU4cEiELRlTHBYiJ2eddZZ6pUAceLhbDHhGyr6AS6XWSOHoGyES+assW9RAljehFK0"
"VkgYGOt9cxAyib3+IAwDM2DJDrv8cvOLKMBwnJjCP5QBnbzx0DgYKOlcz8FqfV4sG5QS9Ib2"
"MCt/b1OHYVxCmI888ogKC1rXIJDoYBDnHjTVkkeh0zQaRc39G0JWC4Tz2N8xY8bo+aTnXDUR"
"QCjLA0SgYZiQYGDD3bwTDML5xVOOGmvPhJ/uAQCKEQMG4UoBKdY7nsHveSgbGk/XqllTjQSK"
"+dkXGtuyXop4LxTlhkLeErQvixzOOvhgXfvkhx82U0RJUvBKk1zOPetGufE5OG3khM+1VCZH"
"aN0aGluC8Lc1qKAznV0wcHnewgULtKP5RQMH/kn5xQUscFsjRpcODAA+R7hhPEdV8tlkD7Vy"
"VpEMHTpUI03wBQr6mzz6DcK73AmfKML3/PPO09Afhht3ZRZHXN6NEsokSvTQpElmIRMEDjtM"
"8XPPuz5Bv1bXgLfP/RqNfgcNGqSOkA0d07wBY2Wu8NaUqVNVWXOniLwI38MV5BKkeCs0pwRo"
"KcJBsplYhCYgOge2XBC/hpGjMHHdunUVHxYslgPhtv4XXFC4gZZR6JGG5U5tAGG7uOMhCoKY"
"urUCtMBZPKkkTVoZBUFH6Jv//nf1VDkoHB4Evl1nkvXrPYBYUYTB+LyfCAhCf6nMSlyZOxsM"
"CLUy5Wf2vjJXuIYklKPq19e+ZIQ/EDKafhvQRGtLgt6A+wXvxs8RgusS3K1sCupVwIVRVENo"
"gyeIF5tvyInsNxJpDg8OvS1cLxFkl/Fhm4eWCKy/pPhtCIVONZ+KMq4sHg/PQxBC/015XHYT"
"3qFuisJNhM3hQdcY2/HgL0HdU0GeKdGE2rjk5+KfD0L0QCMRovAsRggt1pYsXWqaiGHC3QT0"
"p0A4V33PR+LdAjVF+W5O6eGIUUjiCZ46+4scgO5EK2wYNZESI1QrNMa7ht8qCz/ZVk0o4KhK"
"MpvssaUkwOOiJPEsteZMnoHxE9XLPlcUF8YOa+QOlVAiCgsa0Xw3Ce9G4S+SYOApEpPYf7po"
"cPaT4nYJTBPB+aEnIgby1ddcozrnt4AGXE/xDiQ+8UFrsc1pOoEU5PJgOIRoSMINWI0kAzCX"
"hg2lTRMHgiQJrEmsu2IRaxz4e1KNiXGjYNCyWFe8ABlM1uq01dpUxyNQSiVgBBtLtcItSa2H"
"HQWxWBT8Y3LYEUQI4/79+29tghl4knHWb4V6yaBmhLAlMW0EKUZCatYRXowdtYDCJG6fLU2X"
"dWNVIniJlfO72ntu7tzCej8r6PHEEUDsO3CsCEBCXkmBkA2KhUw8ntVNno9AVCGdhxWKskUo"
"2HAl4b3WbduqMcX9LZ4InuPl4gWjGBCqWxzhJwQN3TGMbLFtnGQezgfClG4TeHmEcMlag++g"
"O3cGtfLseMCdI+1/CE+xtqoYmbLvCH8yWwkrEZ7pJLyHkCNjFM+Yu4hyweV9NsA7X7JkiRk8"
"eLDSF++WM9/llFPM/CefNL/KGaXDPONFUPyXDRvmVPhBd/bF0j3feqeosgcFoz0GZa8LAr6I"
"enowZPFKCZVjHHCP2lbODveT1gjNl3ejwgpRjshlwsPIJXoNXnTRRbqOEgkNCVeAR8pdMndd"
"nLmp4o1hLAwQr509WPbyy6Zjx47mMOFh9oFoIKFFfie838XFYhu5d5AkYIHaKlrcMOSsV69e"
"6gpj8dD1nXsvUiCJ/z8wcaK6xPQwe1o0KW45dwYwpbW61sqBD+MH+B0uWFkQCyfUoX3PRo82"
"jRs3NkMvu0x/jwt6QgYwZOpdkIVM+MNAvcw5QbIFlicWLwqIC8psF+aZ8FOjAU4YoF+/fuZ0"
"WSdeGUQmjf9COThx1s/mQk82lpj5XJQL1fCiuFBeHPGlYj1jvdH5mn2hJx24yZbkWXiEMAdM"
"l4qfENMFomTxGKg/4sKZv2dP2eNJkyer8CSpAAFEzRLuO/3WOomgw+u4PngWghLa5aL/hbK3"
"zBoCuNsjFPnOO+9oej2MhSAhKYj7A02mCHnHYfy8A3VH0Meuk3KJfWU97Tt0UEFANh7eBs89"
"+eSTNSyH9cbnhFQQwvaCPg5+1sfeIBSw5PkcYcHvE51YmwU/gADlTkrPx2mn6e9Ck1KB90i4"
"ib0dKPThZ1OChAMyDDGYdk7J3Eq3fhKL+DuSjQhHk307SvYNY5RkG/iYruMkOpHSzO+fKMqN"
"NaTeV2Q6/3iFXCFQgsE5hy6kqCOQCKFxR0aKNPzBGqAf9EQoKf3XrtWzk4k+qfuAZ4iHyt0V"
"oT7qoyzdkRMYY9Dd8lg48SId/myyh0QC7iXtfRl4OTfIQqIpLzz/vPKWlRmZ1k9tH3tF8kxX"
"Ue4MTSVsSA9Akqd4FxRdNt7NJd9Q5EPFQEiV1RgR8CyGCsYb4W6ueCjTQBlzfZKa9RdVflLb"
"hdGe6czmIz/BxZ6hI9hDZNwY8VQx9tEfvA93lig57irtGcJw4rnabSTYY/Cn7Z3IHQk9r7jz"
"wnLFGuEejOFkEGTnoLUIFg2eAUzHHRbfR7iyEPuQTL2/CIshEMCH5aNV5fKsUkFLHb1zC7p3"
"7xq45QjOcKgjam8xrHCEFxYnsW3bq0/nTGWxPjPh5325jMS6Jc7MweNw8DmbyteEBhCm+ayf"
"i2PoQqosSkstaTEYOLDQAi/G9ikjtIFSsPc90BCrBWGF9xbGTyyZgtePBDcHHaufvYKheB/W"
"CS7owz7wDH4HhtC+mLI/CCNCLKyL38lFf6x0Rmawbp7BuaHZKe/A/vJs6MZzWDfeaqoQCuPX"
"d5C1Y9FydlgDf4fxwOU+NEJIsHYUP89mTxAKnFeUNIIPYVE6zfqj4LcFx98F9zB6BypKkneB"
"wfAyM+EvPPsiRHXOlggu8NEuaV9ZM/sGnVHynFXWYMNbmhQj+4tnVTHIFEu3fhQge8x6UK78"
"PjTGw0PQAyQaPC2GC2EceIEsSzI38aB4ho0YZNpf0qw5S/AAe1w8uGaAFoSeCelqIg11VyIj"
"Ngd3evAFWXX7ZKFP6j5AA/iWd0d5sVbOI2eJM2MTTNgPjDH2PZXHMtI/g+xh/dAKb4Dn8AzW"
"zDP4XeQF1wJWZmRaP/PS4GFkI7Sx4XP2DfoScSAJKBvv5pJv0JQ10i8VWltZzfpQgShqzoAW"
"nct7gV/fL0XpRJWfhJ85O3yw5vCZzUd+gosei2T68u7URxKpgh58D/rjHMCrnAGeZ7PM4aud"
"U7wx8GdMsbcX5NY1RnjtKkgghNYyBfUaLIKNYpPQ8lrbEcG95wBj3ZKNAkOQ7Ua8k2eXDWqW"
"2HDw4wLbO40koUTwwUAkX0AE1hs3PMlaEBCsNXzhzqHRGHowRyyf9fM7MCs05++V9sGobxSZ"
"lgIEdLLhQYQ0wrREkBGYqeZNa28CIcL+wrQIBSwl6I2FTRiUn7G3/Ix181yMGN3joJt9yYh9"
"+7RxqjAWPdVgMmhD3Zi1CrUwOVCOtj4rV4iP3+MOab/gMpx1aksmeQa04P1ZN4ed/xGI0M92"
"TedZmVLso+C3yQwIDPrR2Vom7sL4Ge+XrW8fng73i1qbJ3/D39v+c1ZZ6VkN0o1tCBz6Q79s"
"5SCsn7+tIn/LmeB3rXeC8bFbIPgRejeI53FD8HckYTB5GcEU5d5E7/JkbXYPMRBKBeecd1H6"
"CH/zuQpp6E9LIrM1PTxXX0O7DyooEfrwBnwlNMJIge42NMZ7FQSp5lF4LJvsYb3ghueUp4Jn"
"2r2OKjPgQ8LZeo8mHzyDPSwX0Ace5vOovJvpztwmk6EELL9BN22aLp+H+StuP0l7d1s+aC0V"
"PrP54mIPWQ9rg7+0NpnQenDvDp2t4iLMq6UE1JwGZ+tPMjOTErOXsWHAUk7n1uYLuqE0dszi"
"BcXBm+15CLWdAwv2vw1fqrJF4O8SJKGEhV/JID039U6lYuh72RIVYPTyQY1SPhD3PWGqPQMG"
"S/ezdO8Z9x3SvVWZLFaiC/xxAAFDiK9SkOWY7zmIu/5UAUltFKn1eDkIEv5ut6CpblTBlGuN"
"ZDqWidnINslZdSF7Kibka9v5Ptd9aFTezabEMjVsjnN+sq1V6z2Dms+iwJWO5urx5nhmCePB"
"g4cdDsiSJXSF0sLjR7BrJCXlvseDh+0B9E7Mk8GDBw8ePGyPoJ5YvkPL8oE4Q908fo/f4/f4"
"PX6PPwr+AuPBgwcPHjxsp+CVmAcPHjx42G4hVmIHqcEUbJLyS00K3Z6pOqf2g/TLJYsXm89W"
"rYo/njoNfuoRTjjxRC2UnDd3rl5Ml4yZch/GT98+uohrqx/5+Hz1au1MEbfFFbOWyObTljzy"
"9cwZM7Q4k84LtJx5IuH60+GndRQ0WvXZZ9qvrkyQlu8KP1AqKJKeO2eOpk1HTbPPZ/0uzk86"
"/NTHMMyVbLx5julP0Xj9o44qbFtUFOeHDhwNGjTQ+prnFi1yvr/2fH7m4PykPoPWTXTwoLlA"
"nXr1nKw/HX7S5qvJO9Cphe4XZIAmmTwexn/kkUeaatWr6/lJyr/p8NO9hs7uq4qI/qWDVoFt"
"HfBvtvW74N90+CkhaHn88Wnlf6xdpiUSB4XGjTNnzdIiaKaWTps6Vftg0bCWArVNMft0hfFT"
"2MiASAZ1grNJs2baESDOQLZ0+OlAT0U4HSpI86TgLslAyCWCj8a/77z7rmZ7UQuCkqdbOYqz"
"acL1p8NPdwq6AcBotANjtETchqth/IxJQDig6Gk7Rm0Nxbhx+7Clw8+6GYXh4vyE8SM4z+rV"
"y9n5CeOnQTI1VkV1fij4pEsC+GmM6np/yUbU8yn8S1o47c107ldM/AhKzuTSZct0HAvF0HRp"
"R/hQ06Trl/PjCj/NfJs2b65dUEibx1BMMvwzjB/jrWWrVirfXPBvOvx0N6Grhgv+TUcfvqYb"
"kAv+TYefM+NK/qc7P0x1yMS/sZQYGpz2LFjl5Ptrl3jxbmiXRDsR7W5Nf8KYllAYPwKazgZY"
"onhOtCiCyf6IObwujJ91Ur2PpUjboOkikMAdt4sZa8Nio5UPrWywgJ6YN08HWn6xZo0+/+s8"
"OmJHwY+A0AF7cvDptPJNAkYO46fjQpWqVbXYkINP66AkQi4dfj0/bdo4OT9h/IwU4ntMYnBx"
"fsL4YTg6cNQtovPD55x/ukUQRaCrOh0hNjhaP10umJVGuzRGsWDk8fN1MTue87fUmdIYgUa9"
"eDE0pF24cKE2fAU//OYKPwYD7ZaYNoBw1rOfYLBlGD/nE+/lzTffdMK/mfC74t909CHKQc2d"
"C/5Nhx/jx5X8D+OnAw77mkn+x3oK7XyYRYT3wmBFRi/QSw1Lgip0Rg7Q5imuJg7j3ynoisGk"
"YPDTQ25TSvfspPiLB9NzcYnps8dmU80fd6oxFelYhba1Ci2MsH4Z9YCVMVU8Dt4n7vThdPih"
"/xk9emxtPiy0p33VZkf4KcrlgE4SKwuas7e6/pj0T4efZsSuzk8YP3vJWu+7914n5yeMH0OI"
"gu4WRXR+6PyAoYJgph0SnTxQnJtjCqEwfvor8owrrrhCw7oINx2HFFPJ0NmHtk60KCofRAo2"
"BOcRXkZeoJRd4UeZIPgIH2I4sP4tCbq1h/HTjgsvgD5+Lvg3Hf758+fr4FIX/JuOPjSTdsW/"
"6fAz6cQV/4bx2wkCmfg3lhKjsp9x7YTk6LqMlU4PLywIeozRGYAQSFxLJYwf64ceYNxdgbdi"
"sNEbY7rzYfzgoj8hlhChLa10F8Eat+gTgUNXdoQDsXla59Dok/YpZ4pbjJXFHc1OMbsZhPHT"
"nLdz167aNJPZVoQ+YIC4hyiMnwnMtH+58qqr9ODQFRvBFJf+YfwNGzXSPaAVkovzE8aPwCS8"
"4er8hPFXkvOEF1ZU5wcLFENl8qRJOimC0D2C2tX66TS/iOa0IpxpxkyYUWe7xVQCeF4MryT8"
"qTOi5Hv7BC28aN3Fu+TTET4Xfjw7HSEUjGVJcheWDj/0v/W22/QMueDfMH6Gr57SrZtOIXfB"
"v2H8dNOnzZkr/g3jZwAq1w14eC74d5vzI2vG86JPbTr+jXUzifvLiAhCAlgodHZmeJyd28S4"
"aWWCmJsQxj9T3EfG2Y++8UYNfYy69tqtrnBMSyKMH61PHPqN119XgkGk0gkuJemCgGDjro2W"
"MMSisUCxsugIT+gJzykus4XxvyeCs02bNnofQHNbZgdtSTN3Jy5+QkA0ioVOs8TTYHIBB3Rj"
"zJBNGD8hArxIevHRZibp+QnjZzQFYY7Ro0drWCXp+Qnj116LBx9s3njzzSI5P4T5Lm7aVA0h"
"BDb0t0lILvAzG66VWOo0V+Vrzg+eZemYF/94FXTgR7DBUyhfEkcs/14gQpvwcSlH+JnLRa/L"
"QEObpBDGr015g56hLvg3HX0eEC8JmuNlJ+XfMP67xo3TCSMo+kcefTQx/4bx00h6wsSJzuR/"
"rvMT5t+0XexzAV2IWSSWJ94Xh5EPmIBBi2hiGjmyKe+vWGGS4kcgkOmCNUf4gwtzGtISN3WB"
"H4aiSS1xbg4PDUXtAM04xXocvo1CZEYVQAcdlCn0WSOWCizG+ukpRwf5D8S6SIofOn8nnjCM"
"RogIJc33GdvONIKk+GnWSXhAG3GKtcse040ewbHCEX48bTKO8GSSnp9t8Mve/uvHHxU/XdGT"
"np8wfhQjDAWt+Znr87OH0AELlP21I+xd7i90JpJSJhivgTFE82PGoPxT9jpf/FjNdjAug0Nt"
"E2KUwVtvvaX7i6wg42z5++8nxg//0gmdPoR07ydrjWfxHnHoH8ZfEEyqhq/4PCn/hvHbQa68"
"w6rgjizJ/obxa69CwVcmGBablH/T4bd74EL+pzs/NGRmjFA6+R8vxV4WiZaEcTmMtpsx7jYM"
"jNfBgYpraYXxY53TkRmLkVBNyWBci1P8QWdr4vVlY6ZGp4ZrcHcZJwAuNuHnn34ym0VxYkHw"
"LJ2JkyDcFMbPHQybv0swJof01LgprmH8pYJmpuwpYyyYqwTu0gnCoX/CL/TAO2D9Ls5PWvy7"
"7qp74OL8hPGzj3QpxxAqivMDrREKOtaHiQIiHFzvL+Gxfwl9DgomSes045jnk3uLLcJfZJWx"
"n9xrIORQviSn2MbPcQc0psPPejFAsdRJKIh7NtPhLxOMx8Gz4F4yKf9us375OlW+JeXfTPTh"
"LtQF/2Zbvwv+zXR+1sva0/FvLCXG4QZJhaADc0Ew0ZYGomw0jJxkanIm/CifnYWJ+dxe4rrC"
"b4KRGybiZOpcQgLLgTEtdlIy69bsIGEGjd/nOW4+F34dZSAHScddJKTPNvhTfoY1BwOkToB2"
"uX4X5yfd+mFgLoxdnJ90+JWxgkncRXF+inR/g7OPUHPJvwgfhL+dos4zUMJFhX9LsM9J9yAd"
"fmATc+Mc8G+m9dvsQVfyLYzfFf9mW39Rn590/JtVidmiYDseHVcOa4pUcQo8w1ORdeERrBMm"
"e5LiHgZc0QcmTNg6YE8IHbZ0wF8QAT93UIxft0DhKVNn7Zwdy8jbWFIRCY/XwNRZC1z0jhwx"
"wlwzapQmjVi4YvhwtdC5qKVQmzDBDdddp9acTs/NgJ85THYKdTq49eab9X6qbDDTLV/6ANSl"
"nHTyyYV0516BcfUWyGSiwLaR0NJ+/brsO15rLgs0TH8LnB8yuwgdIpTDQiDq+Ul9TpPGjQuL"
"isP7HGbSfOgDMF2Y+sRUsHtqJxMXHp0872NS6R+mEZOpyUJE4MTdXwtM1ibEzJ2IWswp5z8d"
"fXLRP7xuaL7o2WfNVVddtQ0/2OGhcfY3Cg9cNHhw4Z6sD/YkimDORXuK4rkjJ9OU+/7ywRyu"
"gjw8x3RnByBaxQgc7nqIYA26+GKdME9iTbY5d9nkTypuSg1efOGFjDPb4igvdAD1ZUOHDFFa"
"WCVYIo18zrW/UemCjCkRUf4X5FI2xB3PP/9801gEBgkWxJrJ9qKeJG4x51133WXuuftuxXNE"
"7dqmUcOGZrAcSNzcI+WAfRVMXI0LixYuNEMuuUQ/79e3r6bRf/ftt7GLE8PA/cGFF1xg3hCh"
"PmbMGNOubVutlbhs6FA9+FzE1znySM0kwxBAgY248koV3mwC6cDZMoO0YPaTTxRvl86dC9/j"
"qPr1NcmC+4wvv/oqUS3M0qVLtUCXPfhrjx6avsoh1UPbpo25b/x4c/vtt+vlP1lT98jPee+N"
"EdK6w/Rn3ad2764KnlHwOuU5Znp1WFGOl3WiyPr07q13X/0vvFDPz+8Jil0tkA117jnnKGOh"
"HOvWqaP1ThgjcdOTU+nPmoFrrr7a1JNzD93hqV5nn60ClWcgQHheHH5AYJCGT1LU6mACc9KR"
"FanrPqdfP+Wt9997z/Tu1UvpNea22/Q9khR7R+WB4ZdfXnhvQt1c1ESIXLQfJAqC+/K1TKZe"
"tSrWWbVnh4y92269VZ/BOSX7E7nKGf1ZnkGSAnzI3kTNFkyVP/ZcIp8XLFhgOnfpontM6Hnz"
"luQDSpBfGBQYzPAv07xTsya7dO2qHTWiyqJMdMFoI8sRuuggzzzWWJDNWiG+fMP112sNDzHz"
"1+T/+0VosGCEX1ylUCq4yOSOgjsicH/DpgrOSkGNQNz0THUvmToahAr/CKbt6jTiEm7Gp9lh"
"dFgKxYLnEcMmDrwxKHLld3gm2YLAU089ZTqLp0N9GoIl2wFjRPwIsWQ51LsH07V5D6xaDj2H"
"FUgiSFk7Kees8UhhAiyfCsEAwhYtW6qXoe8kH3Q20am3EVvhhOlvrXGeh1GEQMXyigtYoigw"
"mH/ixImFd5xkMVEqUa1ata3MFrOOyoKdLmwnN9sU8bAHHJf+dgggArl4MJl42bJluifsfS0x"
"8EiFhrF/i8EP0OFm8ViAxk2aqCG3MYHhE1439LVnH7pYnrXfS5KhGYUHrFWO0EPRRxXauWjP"
"2UepcG+Yj3JJd3bA9aMoFGhC8e5777+/lXflA6O2ZBDm1jvIiPIpVf7Yc0lyFEkzAJmnGMp/"
"JNxrgGxYjFIK7I8+5hizVvCuD5Q6yo0PkuPYg3zpohOi5R2gy8sB7dEB0CufzMaMVDsoSFll"
"Y9HAVatUUcJ9JJoUAhHbPlfcfdxuwgcIjXHjxukCc13o2YtRDiECiYSKdh066ItNuP9+JT6p"
"prTaqRSE57A4cJPLRxixXSJFIGscXpQksdSSKeGA1JAXAvW+e+5R77JsKEyU7RBpVpH8Poq3"
"UnAQ7fd55kknnaRWl1p/Qschl16qdCLJINuBLRGM7yZZY69gwjbvATOjFCkO7ikuORfzNhxI"
"jVg+l6kcHowICr+bioCjDdER4j1SdlC7Vi3z1Pz5Zrc99tAiVZ7LWtiLKJfZYfrz9y1atNCC"
"WrpZYPEiGFLDyvnsLy1uACxyFBg0IfHh14CREP50h6D+6ZzzzisMcdGWi/ToMhH22N6V2hBc"
"6SD55AKxgFEIMDWCk2dQhE/HCw2DRLwnsZPB1doNEiugT/PmzZWRT5WzT+0Q0KRpU10771s+"
"4oj5nYIUdrwUQlWEyAg1IXRayzM4+7wDXvZI8Ubg8dmyBy/k2IPUdRPGZd2cZ0Kf0KlMCj80"
"lz23PIZniUx59dVXzYMPPKACq1SW8FwuHiApy04ML5lngkgu2rNWW0t3tnhsrDUKbdKdHf63"
"6+YZzZo105Dl8n/+0zz00EN6VmnTRBcKFdwRcKfKH3suySY9vlUr/TmdS3BAaK7Aczn7RFpo"
"ZcW5yOe+itKRsWPHKs/2Fc/79jFjVGEdK97TyUFIdpKcTRQoz8glg1LpAu9Ce+RNM6E9PATt"
"kfunnX66RrJ4T4wx3uF28fIxLHYKh9kzPcxmrtDugweVD+4Z+JzDSK81Nrx9u3Zm9A03KEOz"
"gF/ysLCxyl8Uz+Re8e46iiv52GOPmZUrVypDHStK5k0hDF0QENANGzbU9OgkFnwq4MLeKXhx"
"w1ECB4vSRMDlGwLp27evmTN3rrlZXOOrRBi0F2WMxYiQxoJBKQMcqiVLluhdn2Y2ZRF2/Iy7"
"Jw5n+EDw9VENGihjUNtz0cCBGobFYqTLQj7eGckIy7Gwjj5a/x4BxyEl/Amj0+cOmrPvZWM2"
"JIXGjwrT1j7iCG00S80K+9umbVu1uAgXnXbqqSrssORRrLnewXpY3373nQoYjAfWaEfZ8z2s"
"XNpYEXJqKcL0MzmbGCmUUSQJK+P5cU4JqxOWsh4CTX83xAyfXT58uJkvnvqo667TdZ8nxuF1"
"o0ZpR5kZQjO8y3tEUVImENUrwIJ+l1lLcpa4w+aMkIkLzy585hm1fOElwjuXiLBDMH2VZ/iM"
"cDN7S/0OZx/jAiGDhY0SY0/vECV5bKNGihPlNXDAADWUcnkJuXgAz08TsRJCOtpjjCAkuct+"
"WzxC6EOYDnr9FOF8hmHIkCFm7rx5+gzem6gMcpR6LW2VJc+Fz+J42zQiWCByZowoGuosqTFD"
"hl42bJgahZx9nkfv0NUi39bn8Qxor56RnDtkF0A9KspwseCeMGGCRs1I1SfU+22erdAo8ob2"
"p/fooQrrbFkjSvfpp5/WYmcMROTmsMsuUw+ckgPOaPjsZJSkhe6cbBgWk3XduTDs0bOn2STM"
"hBsMs6BBr7nmmrwtIhpHVpO/Jy7aXaxOPIKHJk3SsN//Y+9MwK6a1ge+vq95llk0odI80aS6"
"RAoJDTImiltdJBU3RV0UyqyQylXGDJEiM1GZolBuJeW615ChroTQ8H9/b2t9/912znf22WdH"
"sd7n+Z76hvPutdd652lNmjRJJ3Xcfscd+rIwBi+AskwC/jFypCrj2WKd0ggLkxFX35ClIELB"
"1hUBQV7vcLEmENobrRJz46wABCyMreGpHCcKYFnjOdG8yyQB52nAYNk0SGKR4VkjfJywYD4c"
"hNtEzgSmIAfEecSdeH322WfrxINdbFUa+4ACIFwNkcLcDzz4oCoePMuvI+QunSGDIAtOaHD/"
"ulAQe4ExhECCPsnd5BoGZC9QVqyXYgnyEfeKRb3ZTrCPAyOFFulDgobOP+88Dc9gtWvrCoaj"
"7B09VUQTooacUFrw6UOiBAfaAgisZwQm+4LBwL+cNXvCniIcsgmfYcDBvxiE0D654J/svnOO"
"atRa/MgPcikYIM6L2BEg1d7jfUBLGCnIJbx69gkP8OsYuXUMEvaJZ+ANjxPFTsheJ8sTVpM9"
"AX+cUC9yAFppLjx2Vq9eOkP1MDH8cRAetAOL8fQI2VHtp4N/I9IpcgGagYbuEloHDheliCHI"
"ORe3xVPwAl4zCqh4FudKPQFrR5GzPxjOlUU2EFUBv0YkxMCdIUYj/4dmMVzDMyXTSlOq1TTs"
"JhsfnEXmJsDTVU3lzqDBg7daGXJQZSOEEkN+sRI0G4xbT5wb/HuLxdhTGJDKuJtuvNGMsR3s"
"MFmueQ4XahlyySUqBCk4oCqGYwV/tvPoXEgUwUyPDTgRNHxxKC4vgPLa1Xq0uY7FIeyBKw9x"
"ntS9e4F3AnNlm8wl0Qz07dfPLF68WImSvB3xbzwxLNGStiw3bg4FwY8lR/UjBM+ecJ4ofM4b"
"BuRr1qxZuv5Miph1AvXq1t16ZvbvKWQA1OMVOiS8AeM+L3T1hFh2LeWdooYS0yoxm88lMc2z"
"6Xtq0KCBnn/xmHuEUQNt0CxK2J7wyQEiMDVEJ++B1Y6Q0N6qiNVr5C4IL7GveEIUZTHwl6IA"
"hADhOuiTLzdpAZrNRslzrnjVrLua7f9CMLuWGAzOS8SKJtoCEBKlBwpjrvgOosRS7X1VMaZY"
"P0qZ9fIz3mmLNZCyzTWxxxXtM+bZveggXipGM3jZ97g0iSFKaBT6IwXDLQekZwDOmfOpIr8D"
"MNRZ/6aISri60ODx4unBN0SsRo8erSFWjCsUSnF71sg8VWLyrGzkP5/FQHv55ZdVYWLUOv6C"
"jogSMAB4f+HronakWCodkHbniL/DqMTLK8riqKSpKp5La9HMhDnIYTGpoOcZZ6gHxVQKHsTL"
"RbVIYRw3LYMrCFxMmpEuTByfIVYG5cEniPBjo5TBcihmgLkZ7Y8g5XDHiwuOu0rFHETmEq5Z"
"EREHIZ+lKQ/PDguomFVi2wsofSdERCXkmWeeWfBuuu9Z7g9KY9XKlaa97AH5ChTCh8uXaw6L"
"K3YIMyGc43piCEssNMrS2XfOmVwYdw6hiGuJJYYRQ5UhoUVCg5kYGiLm2ofeffqoZQhjMtWC"
"UC7FI+QXOBM8ECxV6HPsmDGmQaNGZt233+Zc3FBgDAmzIQA586gKplAhJ8IGb5RpBK5cHNzk"
"fsiBEqqPEq4h3/u5nXSDkq1Zo4beU4UQ1dCz8BjTV7CC27ZtqyE1BBPWbzbeJJEGzpY1Q/sV"
"rTfP+TFdAZwoULzVXpZOebeSOTQiJ67E0uw9cJTwBLR5jNAl7/LC88//qm8yCuBBq4yQZ3Tv"
"1k1/9urcuTpncHMOg4pdfgyeISeG8oVeCPdx79YJtmWG2aSEcJfaopIoQKTEFd4hI1Hwqz76"
"SH+HbCC0jWeNDGdvoCHoKpuqYAwI5JbLs1Ng1lH2GrriucgLfs87QVPp5EJ6SSvEPOrKK3Ww"
"LG4fQNz26quv1tAVWh33+jk5WACFg+aEMVzFTDoIJvSdlQaQHLz00ks1nMEgTIQQgmr0qFG6"
"Sbjh9IdgYRSm8YNFG1j7YSAHRsKbgafL5GApCx42fLj+jApMNq4wgRTs08CCQPheOnSoGXbZ"
"ZQV9YsSpJ9xxh+lmPaUFb7+tZfYoBS1qiWB5UV5N/su9BxfEES7AwDjttNM0d8Wcsr3k+4mT"
"JplzZK+oHEJxRGU0lC3vjRGCZwczUz0IcTKCiLNAKWeTDA7vP+uePXu2hoOhH/Ik/IzB0YQK"
"AIoj8PooHsnkDRS1nh2lvRQXuUozQjVUtGHpw9RMEBgyZIgKIsJE5Mf4DB5rlGxKsKeFcyb/"
"wBrxvACKdQhHfS/MG/VMg0LC9SpB2zyHfifo2nnvnAu5jPGyh/wOwYFCK8yLcbzVzOZNiTKg"
"3E+0ZerKQzfdpHmSevXra54GY6hWrVra5oKlu1KEFeefqognuG5yYpwjxV/kxDTEKEYidPv3"
"iy/WPNK8+fP/n78XLVLDMRtFmY4Hah5yiDlb6F1lj/zsLNknDOiisu5M9BNl7wk9zxcae0ro"
"Frj+uus05IqXE8WgC9JOv3799MuFwqH1KXffbe6eMkV7cPmiSvIJkaEuv5vJGA/KH+iSXKO7"
"0gglMHHiRG0XIKJFjmyE8AW/A3+RDAZ2kH9prSEniPFD9ApgriHvx+WdnTp1Mk8/84y54frr"
"taYAXits5uY2+9K/v54DrUk4Lr3k5+TDMLwotweuE7ysG4+Yv4dyMOCDfXBpZyfyxyQB8cY+"
"FQGgwlFe3lXasBnE110ppys/ZgFYp46QUs0uw6LEw+ILvGXs2CesEp5B/J+f0WtCUtEJCP6W"
"l0F5kvRNh5+8Fvm2laJ0WaOb3caawMGz0PKu/4bf8Wy+EH5YkS58lgo/f0dYhjltWDisGWuF"
"fSFmTs+DKw1GGLh8FS43Lj8/d+X+hc12I9FLXvBj2Sf6PlgzSVT2mXARZ+PmVsLA/B78mfY/"
"DOBeLgYICpa9ZZ30yPBczvlAwemmm4Qhyv7zWZQjZwgtYYRgXREuY+YjjK1ejSgfig8qBLyx"
"dOuH6SkZ/0QULut3AN3gFZPPw6uHgXkv8EEH+9h7ipw3UNj+oOw4T4w36NxZvew3z4SW2Cv2"
"LHimmfZHQzuyB+AEN/TB2vCUOF+nlF2xFAUpOltP9pDim1IBTyaMH97iMxgiKCGsc9ZIEQ1e"
"KufBPhMqZg9JzPMevBs0C73yPpwDwiiMP7hu9oa/1/FVIhc4W8cPGLM3iIFFpIZnsgaMRiao"
"87fkPXhmJvpMxwPgIzqEoocX+Z5nEtIKGhOp8EfZe3JH7CE05Camc8bkyzQqlOF8He0wsd/t"
"iZNjyA9wcA7IBc6As+L5VRj7FShYySR/MAydx04IGpw8A9qhkMMV0fCOyFXkVHAsWjr+Zc9X"
"2eEWfIa18U7sN3IHPmPPeDZrwDBBwfOzoKwI4w/vC7yEh8q+gwd575rkXeibdwLwXPk5Mo41"
"IaPBn1Yl59ncERUhIHV9GDCT67mCmRA4EAUbx4uVi2AJFbfls+XsmJVgaE6nvZM3kkNF2+rQ"
"WSZ4yMtutD1fmeLp/A1lvzW5hyZF+IXwGO/B4bJJWD5FrQvLJmUKBboSV3Xf5T3c2J6Stsy4"
"og3tKV75gmF/sTPXsinsYI/xTKgU3WQLRdjj0nZE0K42BMqaN9lxNUqgWRYvMC6McAFCDfwI"
"rz2tIcH6S2U5CzC8/7pum8zn55yjM1zwAN0Zk7/COIni0WCF8VntEbNFCeBwNKjWrFXqG2wR"
"Q3E7/zFq7sr1tJDvcXkGDWvIc7TXD5xZnmlw/TAugqeKFQY6+imwNs4Yg8oVxUSZjg/9IdB4"
"zzzLk1rKLP8nea7X0svfOEsWGtJeSt7JekiFTY4Ir7uIFc6a+xS8Oj/SjsminYTqMweUalNI"
"hNeXKVqTiQfYB86CcDQ8zPdlbVVhEnsPLgS33u1lqzUdfeZlQTvgwDAO1gFoJS1FO7bKkjYC"
"d1ZRelnD8sfJgGD/InK0spXdhPKheeR2lFBuUbvnfIY9L5BtQu/kp3ifgnMnLyrrd6HFTHND"
"w/vi9p7PsVbnLHG20DF85mZsYpzm256+oIwudMfYDgRaCXmh4DilYJI7nYVeKKMxVRl8KXAG"
"gWc7QZ2tgNA7newk8aTBEVGqA3OWXBKgd1XJ+6fag5LWgEjkOSgdEZRBgLDiljAXtv9helGr"
"MwMdFPYcCL9CmnN2tBsXXE+LK91POhejTcKFnCEMjzIqnwWPpeOtdPSS7bsVtu7gOaAOmcyD"
"xY23wefgG41ORFQ2mXhAFVeMs4my9zw3lwrKqLQTh/4Lkz/Bgo9MfxOHf1Phy0YOFbYvcbls"
"+1UfePDg4U8LqKjydmINnramCmwvX9kI0RoPHiLTGjkxvw0ePHjw4GFnBPXEsr20LBuIcynd"
"joZ/+vTp3mz04MGDhx0Q8v0WePDgwYMHr8Q8ePDgwYOH3xhiF3YcfsQRWpVC8yG9K0zYcFeM"
"MAyVy/JK5XBNexA/DaoH1aplGjdtqr1lc156SXHHnZCQCn+jRo10mgSDYmniyxW/Bw8ePHjY"
"QT0xuuip52diAWOcEPqPP/aYeWjatK2X2YkiyOVSvDB++oq69+ih90cxG4zrXxitEneOYhg/"
"fV1HiFJjlBFlu3TB01iZxJxGDx48ePCwgykxut33tpMPGNDIpX1MRsBTYmYbd0b9Yi+HTAI/"
"kwboNWEyAE183IP0VZZj/wvDX6FiRb2ShIGfTEdgKC1/82OOtw978ODBg4cdUIlVtLcvc/cQ"
"Xex4XHgw3P3FHDb6QOjijnuzaxg/39Phj9JipJNOYRAFszmmpxTGjwfGJO9hw4aZNm3aqAfG"
"+JOfvBLz4MGDhz+eEiN/xKVlhA+Ze4Xnws+YZbZkyZKt3d7i3RSJmVMK4z+6Y0cdyMm9TVye"
"VqduXVU0G2NebhjG3/Hoo/X7+++/X68meX/xYsXtG+g8ePDgYceGWIUd3CXGJGMuvFv4zjt6"
"99hJPXroBYp4TFFmvGWDf8KECWbK1Kl6nw35Km5E5TmbY17LEsZPGJEbjcm1Mb+M21GZHVgi"
"5vUjHjx48ODht4G0U+wLA4oe3L0xTDVmxh7DGZkyjFrh/26OWpxm5DB+ZpgxE46cGCFAJisz"
"VJfhxB+uWJEI/pJ22OoS8cJQZAyn3H2PPcwS8cx8s7MHDx48/IE8MSZgbxEvhmILFBZ5JSba"
"430xjbl0DqX1KfFzY7Tg5n4oKgnxkiiPj3vbcBh/GXsjNcqRieWsH2/Sl9h78ODBwx9Qibnp"
"4SgvwnpuQrXeKhzj5tMo+JnKXNZe3cKz9Ar0hPEzYX0L+Lluww8o9eDBg4edV4kFb18Ow4K3"
"3jJTp05Vob/N3V4RBb+7BTYMT8+ebZ5++mlVVlwPEvaEUCz5Mbyj8wcM0Cbpu//5z61eHTcf"
"C65U+I33vjx48OBhp4G01YncBXTnhAn6/wb165uWLVqYww87zFxHUYX8jFtRuZE3DgwUpYKy"
"4lrzxo0amUNbtTL33XefVgkSyqO8PXhZZi7AddiU4jdu3FhvaiWE6KsOPXjw4OEPrsSK22IH"
"gCIILk0kX0QF4sgRI7aWz8esDnQ3IAMoKy7K4/I89zsajeM2Moehdu3a5oYbbtD/t27TRq+0"
"35gQbg8ePHjw8PtC2nAihQ6uQIPrpJs1a2bOOOMMvWKc68VHjBypv3v00UdN165dNVw3dsyY"
"reX1GUrTUVR8uRuFK1WqZHr06KEl7/Pmz9fPVxcPqlu3bnpNtnvO3Fdf3Xo1dcSQH9M9eA8q"
"EF966SXTsWNH84x4gMx6rCBKtHGTJqZ9+/Y6J5GZibwb115rgYqnDQ8ePHjYeT2xICx4+23z"
"jyuu0EG5hOS+Fm/m4iFD9Hctmjc390ydqteHL1261Hy3bl3khzdp2tTMeeUVM1IUIuOfevfu"
"bdZ9+60qtuaCd9G77+oUkNtvu820bNky6xAmTdiL339fi0AWLVxo6tSpowrzO1GW5StUMJ2P"
"P96MGz/enCwKtGq1aop7zTffJBbK9ODBgwcPO4ASYyQTgp5RTygw5iK6UOLMWbPMFaLg2rVr"
"p8oimwbktxcsMDVr1jSTJ0/WKfjg3Xfffc2ee+xhpk6ZYj779FNz+x13mH79+6ti+eKLL8wP"
"okijAkrr9J49zUMPP2wGXnSR/uzQ1q3N2rVr9bkoRQYX805MBWFGo07q2OKzZh48ePDwh1Fi"
"9GOtWbPGXHP11Zq/ItxWukwZ/d2Xq1ebXXfdVXNPXJdCODEyUNZetqyZO3euftvuiCM0VEgI"
"8MyzzjKHHnqouenGG82Ya69VxYKSizpZHm9u9ZdfmvZHHmmaN2umxSOPPPKI6dChg74LChlc"
"VCmiOOuKwsNz22233VQZe/DgwYOHP4oSK1lSJ77XEu+lWrVqpqwoMJczosADxcUEDRRANg3I"
"4CDHxfxCCi64DqVuvXqmbv36pkGDBmbGjBmaazvhxBO1r6ugFy0CtBQFyER9FG7VqlVNzRo1"
"zCeCq3LlyuqhffDBB+phHn744Yr3pJNPNvXk2arAvCfmwYMHDzu3EqNPrFv37vp/cmKnnHqq"
"Xk3CZA4mZrher2HDh+tMQ0Y5/WxHOWUCPttKlIzLiaFomF+IN3fW2WdriI8S/AsHDjQPTptm"
"7po8WT9H/op8VqbnsHYKUbqfdJLp27evenvkvy4aNKgAD6OyJk2caK686ipz95Qpmot78YUX"
"tAR/k8+JefDgwcNOAWlnJ67//nv1gvhiHFPFihVN1SpVzD6VKhWEF5d/+KH5/PPPVSHg7fBV"
"1oYZHaSanUgfGDMPPxNPiTAhd3uRB1uzdq1ZvXq1el08j79bv369VkniIREC3EP+bv/99y94"
"Tir8rJ2LOSlCwVNk3XvttZf5nygq8l7kxAg3EgblGhkKOqhK5Hu8QkZbuZAi+P3sRA8ePHjY"
"MSF9iX2xYir4y9lRT0VEyDMYl7J4wm8olurVqplK++yjAp8c2TbTOwoBwpOVRVkQggTwxMDN"
"PV+ELVEopUUx7iPKjUKOIjZPRtEFv8v0HH6PYixfrpyOkAI3z6wo/6990EGaW2PoL8qXwCFK"
"GmXK3/G+PifmwYMHDzu7EhOlsTs9WrZPKwwosbiDflEoKJlUgBcUBLyjbCHd2nluhWwKTzx4"
"8ODBww4N3uXw4MGDBw87tydG3md7ws6O34MHDx487JiQ5xt7PXjw4MHDTu2J/VmgS5cuaOzI"
"lYbTp0/3FOLBgwcPOzD4nJgHDx48ePBKzIMHDx48ePBKzIMHDx48ePBKzIMHDx48eCXmwYMH"
"Dx48eCXmwYMHDx48eCXmwYMHDx48eCXmwYMHDx68EvPgwYMHDx68EvPgwYMHDx68EvPgwYMH"
"D16JefDgwYMHD16JefDgwYMHD16JefDgwYMHD16JefDgwYMHr8Q8ePDgwYMHr8Q8ePDgwYOH"
"rKGo34LCwd4G7cGDBw8eYsD06dPzvBL7naFh/frbDfe777/v8Xv8Hr/H/4fFv73BhxM9ePDg"
"wcNOC16JefDgwYOHnRZ8OHE7QMlSpcwxxx5rNm3aZL768kvz9OzZpm69eubgQw4x//73v82c"
"l14ypUqXNkWLFEkM/8EHH2zq1q9v/v3xx2bOyy/nhB9oeeihZq+99jLz5s1TnAcddJBpKs9I"
"Yv2p8JcsUcLUkT1a/9135qMVK0yxYsVMfn5+YvgbN25s6tSta76U/Zr95JO6/mJFiyaGv127"
"dmbvffYxn7A/22H/2R/2g3N/ctYs88svv5hixYsnvv7Nmzeb1/jZJ5/oM5PCv/fee5sj27c3"
"X65ebZ5KeP/Z5xYtWujaN2/ZYv77n/+YV+bM0WfsLPTv6DMJ/j38iCNMhfLldT9I6D/y8MNm"
"/wMOMM2aNUtk/anwAw0bNjTr169PhH+9J/Y7AwTPQd5///3mkUcfNflCLCefcop5+KGHTJ3a"
"tU3NWrXM/9auVSWUBP69REC0P+ooM+3BB00JETwHyTO+/fbb2PhhsDJlyphZTzxhevbsaX7+"
"6SfT4+STzVMiPKtUrrx1/f/7X2L4wdX2L38xxx13nP78y6++Mj///HNOAiKIv7ww3BFHHqn7"
"w5p51to1a8wvGzcmhr9J06bmATmP2nXq5Hy+qfbn+++/Ny1btVJj6GdRYGvlZwiRpPBDM+zP"
"PVOnmldeeUWftykh/NDPGfIvxhY42yS8/2+8/rp5VPhg2rRpehYfiyL47PPPzU/y3CTwFxVl"
"C/0/LPiT4N8wfpSZo88k+Pe1+fPN448/bt5fvNiUK1dOFdcpIn+eTIh/w/iXLFliDjvsMHNc"
"586J8K9XYjsAYCEfcOCB5lixmnffbTcVCFgoVapUUS/qX//6l/nq669VGCWBv7IQ5vIPPzRv"
"vvmm+e+nn6qSw+P4ccOGWPibikCmnKhV69bmtttuU8H5zttvmxdefNG89dZbin+1WNRJ4YfJ"
"nnn6afPuu++qcP4KJoi5N6nw/08EAgy8cOFC85nsD/sHo/3444+J4Z8l+L8TL3KzCIbPPvts"
"6zvEZORU+1NZaKesCAwU1+cioHMRcqnwlyxZ0nTo2NEccsghal1jpReJaUmH8VepVk2FJp4A"
"kYNHH3lE1/9LzDMO4//Pf/9rVq1caZo0aWI+l71/SIxFcOclRD/w67p160zlqlUT4d8wfs71"
"Xx98YN54441E+Je95fMdOnQw115zjfmLGA3Q/osJ8W8Y/w8//GBeeOGFxPjXK7EdAL4XhUWY"
"YMaMGWbo0KFqaW0R4cPB/lcY7gBx7TcIAW2OKYTC+CHO6tWrm0uHDTNt2rRR4YbQ+CkmkZYS"
"Rp0r+B9++GHTr18/DQuwdgQoTJwn3yOwk8JfunRp88033+hzYG7WvyWmF5AK/7KlS81zzz1n"
"Lho0SMNxDz7wgAq5uM9Ihf95wX/a6aebcuIJoLw2iBewOSH87A+huHumTDFbtmwxPwl+Xf+W"
"LYnhh57uv+8+U6ZsWfU6eMamhNZfoUIFs0m8rokTJyr+Yzt1UtxJrb+s4OQdDm/XjnJu/X63"
"XXdVryYJ/PAWa/1F9iQJ/g3jf+7ZZ82BNWqYYcOHJ8K/xYsV06gGxgleKUbbFrvfSfBvGP+u"
"FSuqt10kIf79UyqxLl267FDr2U28ozfFqiLkZ/LyTA0h0A/Eerv3nnvM2+LREPvmoDfGDKeE"
"8VcTS3fmE0+oEMKiw80Hd9wGNywpPJYlgidP8KNg9tlnH1UyCKSVYvXy86Tww9QwGGGbJGLp"
"Yfx77rmnueHGG1X5n9mzp/6+ojAe3kcS+DsJQ3ft2tWMHzfOPPXUUxoaQoHFVQJh/Ecfc4wK"
"5ctHjtR9uuCCC1SIxqWfMH7yqevEusbD46zZl6/F04jrqYbxrxGceKsrhF7BW94q+qTWD/3U"
"t/kYQlu7CI3uIudbJGbOJ4wfDw/v6957702Ef8P4GzRoYGbOnJkY/4KzXr16Zs6cOcpP68WL"
"3KdSpcT4N4x/V5FHGG9J8W+24As7tgPgXg+/7DJ12Z9++mlz9913m3/K1+jRozXePXbsWBVG"
"m2NaomH8uPE333yzxrqJSV977bUquEvETPxjGfY880xzpnzNFqGMdUsI5BrBu++++5q/9e+v"
"gqN4QvgJv1WrWnVr+Ccv977IMP5asi9Y6gjPiy+5xHwq1vTrr70Wm9l+tT+PPqrni8dNAp39"
"1/ONqcTC+O/+5z8134bweOzxx5V+UDAbY4Zswvjnzp1rJt91lxpbeDE3isJXIZrQ+slXoQgc"
"/Vx15ZVbQ6Ex6T8V/XDGC995R/edcy6RQ1FKGP8U8YCT5N8w/vfff9/c3KePvkMS/LvLLruo"
"Ypk/f77S/fLly80hzZqZa665xlRKgH/D+MsJzWjoGd7Ny/vN5W1eXJd+R/PEELQR/o6XjbzL"
"4OQz2TYDrv/+exUCWIYwGNYJViEM/Mknn6gA2mP33c2+++1nPhTrNAn8fFUSa2uxWHEwwr7y"
"/9332MMsEcsuDn7i3hD6smXL1DLn/3hjKEy+51l7CaN9sHRpzvhZ736yN6XlX6x1qtb2k73h"
"53GaMcP4sRBRLlQ+oghI+JeSd9hdzmDZhx/mjB+BiUDgfAmxYGTker7h/d9VPDGewbt8IGe6"
"h5xtdfHAlyeEn3fgTMHN96wfQbpUBGAS+EtDP4Kf8BP7v6esn4rFJPBDJ5WENslzIs+gJTwO"
"IAn6Yd/hryT5NxX9JMW/GE8bxUhAObJOCr8ITxJKfHfRopz5N4wfxUgOlRD0h8JPYf71Ezt2"
"QoBIEJhYmhALh8nBUuBRUawYhAMlqnFLmH+FX6yhIoIf4YlH47yOuCW0MBe418kzEAjkMXgm"
"+KsKfpiOkE1RYeyk8JezRQsICqy6EjFDfanww7zkZMhh4AEgMNijIkntj5wvODlf9gUFk8v5"
"ptsfaOgHEaB16tRR3HH3qLD1u/0qL8+La6mno58fhX7YH3I0KJlE8aOERZGR7ymdQ2l9pv1J"
"gn/D+DHeUJJJ8S+GGuFaCsnAxdoJn1OckgT/hvEH+SgJ/v1TKrEoXthvGqOVQ4VJETyAFizI"
"wUOsCGr+74oYksRPKIgQEIycn4NbDxEiGOglwbLNt/gQRDDx9sKPm0zSmJBELqZbKvwAaycE"
"xF7BeHHDienWn9T5psOvAlDOAOHJM/JinkFh69/e9FMB+tkO++NyY7nSzu95vknxL+vDsMX7"
"zbP7AV/hzSfBv6nwAyjLJPjXe2KZIZv4aaFnQXNop06dNKwAuDAPCX4S7zBtUNBAOPkRravz"
"BwxQogsDTZzkGIhDFwtZUkqYGfDTo3LUUUfp/0ePGqX9LjATOa/Oxx+vPyfxPPLyy1VRYrVR"
"0UdMPfzzMDRu0qQARxAIIT0xY4ZWdiGEnQAIl3BHzYmdfsYZ2mIA0HtEop28EZZsgYBPgT8/"
"ouWZbu+Be6dONe8sXGjKikALe3LZnC95Bar0qEoDONP9q1c3r73+ekFzs1u/Ww/9W5Snpzr7"
"dGecCqBTvDmMv1cFJ8KTdUehH9Y9YODAlL/jHea++qriS1WiH2V/wvgdzV1x1VVa0ORg+LBh"
"Wi1YygpSE5F2sj3joDeUaf2Z9r3fX/+q76dyIRV9Rtj/akIjZ/bqlXF/3DnfftttBV51FPzA"
"iH/8Y5vvU+11KiMqqZx2tvBnLLHPy+KrUGYjOUscuJMI+TatW5tFixapEvviiy+0CmtTDmWm"
"o668UhtPP/30U9OwQQPTqmVLc93Ysdqo26BhQ8W/MUaJ70svvmguHjxY/w8zrKZfSoQ/hQ63"
"jR+vObaOHTpo741rFn1EBCeFBZR1L1u+XMMgqeB1EcB9evfW/18hjNBUlNoxRx+teM46+2xV"
"Zj/ErHgLCgrK/cH7l7ZtVQET1vjoo4+0Cm5zAqW9bu/pu2vSuLE5tFUrc/hhh6kiJp9BZVnc"
"RlpHO+f27ash4BNE6bdt00aLNDACMCoo2An2ULEecpFr1qwxq1atyriHKDhK/lvLXtHHAzSo"
"X9907dLFLF261Ay79FItsYZOyfFkU2rNGs7/298093HLzTfrGUP79913n1ZoUmn3TUzaDOKn"
"r+mWW24xxx5zjDYu//2SS1TpciaNGzXSKkGMlrg5/e1xxpn2Hb6hjyqXOgT2fZgoFSpJXxOe"
"Pap9e+0tY3+oVr5V9owzoW+LnDl/z/tkAwNFwVMwRt9aEnvtPbEdFBCmCMxzzjlHS7eJBVPm"
"TogPC911xMeNa+PpuBJw8GA1vvPOO/o98XgIl2dh9WZ14CI4yXm8KhYzpfmnn3669h+RdKeB"
"cZEID9ZPrNt5W+RiNH9BHH/durTMzbsSywcQYuBhfTADkwkoRvlW9oVQRNxQGGtmQoMm18Vg"
"mHD77WoxkyjnWYQLi+R4tm7vnbVJAQi9MAhqBAP7vyUB2jkX2hEBQ14T2tHniXXOHmt1WmA9"
"eK98BuWTqSqRySooJ6UPG3LG2GLtCDueCR56e3hWNqXiGhaX83Pl9whuCn5YP9V1Xbt10zYD"
"1qyhwxihqtJ2JFKepVf2G29io21g5m94t9I50NH2OONM+45hghe9xYa044YivxN8N95wgxkj"
"Rm3//v210b5GzZrme1E0VFLCB+SseI6ec5ZN9+xLcevpQ3O57rVXYjso0CfBjDYmEMC8NEDC"
"eIyS+UasSRKneB81AuGiYKglCpPhvrveDgQFEzoAGGXWk08W4MUCpipu7JgxW8uLC0mY82wY"
"CcVImGCKWKNMO1iwYIEqSogVoUpoooV4f4QHscLee+89DRUUVgzB7ypYJUY4jGRyTWEuRtLA"
"TFjpI8VDY63MGGwjnhT9N88/+6zpLQKdZ985YUJBxVmqiRFL5e8ZYYSAZIoIeMfdeqsyGAbF"
"X+RZhMhIYFeRL8rfEYTuPa4eNUo9uVKhUG+qvUdA4zXRkIrgpxQdwXDkkUdqbxhrx3vlndgv"
"nvVqhDOGdvgsRgP742jnRbGemQSh4T1Zmwvjsl8UpuTbXExG2pF3269yZTU6drchJs58n733"
"1hA4yos9qS/n0btPHxVSUdfulAxCjj3ivV1xAnREzxk/Gyre3p577aWfuUkE7oUXXRSJDxx+"
"9h5jC5rkC7p2P4eueAYVp927d9dyb8JqkyZOVE+Wz2XK+WQ645N69DCtxDvjnKAbwu0T77xT"
"Pap0tJlp35mPSCN5LvTP+aPQWes999xjzjn3XPWoTzrpJHPD9dernOCL57JPtE4woYP+s9sC"
"ocVMSowvjFf2hr0OFsu4cCPnWmm//fTZ4XCpDyfuBMChrhGGQXBXtAcHQ2jpc/Xq5sQuXbSB"
"lHDIKUK4xMqxXr8TyzcbtxyCnDd/vpk4aZLOR4SRsLaO7thRf9+ieXMNi2BFwmDgj3TwwuSE"
"JGGac4X4tPpKLDyYhP9TAo3gRzHSlMmAVRRfVKuO6SHPCHNeJUpjrexTv759zROi4CfLe6Bg"
"Zs+ebfrKc2vXrq2eSTdRxCgllP5/xDjYkCbERYMleaHOnTur8rheGKnj0Uer0GDcEGHRRiIs"
"Bg8erO/GnhF+O0mEHetHyHzx+eeRRh41atRIR22B/4vVq3W/EH5Mt6DZHEFCuGbwoEFqbUcN"
"z0E7eD8oEs6NUvOrRo82d8jZPjp9uoZ5UTCM+7p06NCCFgGmgEQZNYXwQVgh+INGhxY/UFwh"
"RhH/P+KII9Q4Yf1dZP95n3XZ0GcgL8Iz3ed4Nzx89obwFr1thMJRMoQgaaiO4v1hlGCs3XDT"
"TSo4MRyYt+g+iwLjLI5o1848K7TW66yzNAy+IYuQdbozniFrhl4pFSdMDvBsDNef00QiMu07"
"IWHmp+ZC/wWKXpTcW2++qXnSyy6/3Dw0bZr2g6HwaYyHjzGQUIbsI++BsfS17H3ccWUOOEtg"
"5apVOvyXVAOweMkSjUD5nNhOBFsClW7O7mNyABPB69evr1Ovn3zqKfPAgw+qtUvuBibJZvAp"
"sW+I0eWXporCYlbi3tbKnTlrlrniiiv0mRpyykIAIUxRCjAClvN6sTidgKDgAKFGHuL888/X"
"kCCVU1Hn3Y0cOdIceOCBmss7/7zzNNfG927kzWOPPaY9YfoOM2cq8SNEqNpij9IJItZM3qGD"
"KKf+Yj0jvLBuNVcmChaFxVqxZsmTse9T7r5bBSeKhlAojBxFGdM8W7dOHXPX5Mlq4SPgN1nl"
"g0HiwnvQAHvF3kQJz/G3LndHocDaUJ7psuHDtUfobfGOyW0MGDBAi2Jci0BSgHDuIVY0Y8t4"
"j/333z9r+gwCAjPolYOfcVnsB8qC0V94YPxd0QgT7ClKYP+hIfJVeBIbrRKDB/DAHnjgAd0T"
"aBiDjzCeDkeOyAfpzhiFhLKCfigaIm/GxB3wxs0N4XlCd7nQf9AIxRhZ8NZb+v3zQifQIUaR"
"SwPAcxjQGHbMTER5km/dEHPclAMXzoYH+NpglToh/Vxx+3DibwgQT926dQv6m1wXNX0eCFZi"
"1Aik226/vSDEBmOT08m2+IAcEgyKl4e3Rw6otBUYXG2B9UVIkxBmmSxyZBA9ayOUxCQLcjQr"
"RPDDaDr/zE6dYM0oj/wsytIJhcBQCBvWS4iHEAdfKBOEGR5IQZ6Ohmr5Yo8KG+nTVxQX4cP9"
"5f8/iDLg/wh/9gfmZ32Ef2BwV30GfkJH4Ob/4I6kDGzZM9PRNccjOCnGQBgVtQ3sfKGcNTwm"
"v4uSNyBRjlDHYtf5e9agAJczjBBS7D3PrSxWNLh5ZpJ5CYoaoCm8AfYNGkaIo4yLx+ghokoX"
"AU2DLs26K8QzOOOMM0xz8eL1vczWPiI8hSghdeiN8BSfgQfYf90H+XJzCxGahLuq2AphvGDX"
"TB2pGjXNGWs4U+jxc+u1E11hIotOuojZH8b58tlc6D+sFF1OvJil8VKB3BXDkFEs0CdygQIP"
"eIM8XdDgyBZcOJJ+P9Zbw1YKFy36+6gT74nFBKxXhNDtoqQgCpiJqzLKCxNQWUVehiR3LVFm"
"CNjJYukRWuQz2fYnlbZKDAWJcIDR3F1MRWwxBZ3zMHOUBkwsT+LkxWxPB/0eeHiM1IHIYbIP"
"lixRBiHkxIir+ll29WuYFSUmwgUPFKHiSnTL2bi8i52j8FhLXqD3ZkshuYw+omyrimLlfRuJ"
"53uM7Cvz4BBeeItu7JArQ3ch0mx7q1zvHevHSMDj6927t84BZI/wkNu2bauhU4TCTzaZngle"
"fuklxT1ePAs+w7qZt4gnhKJif6hKxZMnx4SX7ARekkBlG3TF/rH+F55/fpu+n2yAO6ZQzHi9"
"KBIMF96LqQ6DBg3S8BnFPtBA1CZbzg0aIueGIcUeFLNKjLwSBtwJJ56ofwvv4WUQUs8GCjtj"
"V12sE1Ns2FebhHO4R4y9zYX+Uyl6p0D4CsoWxtAx7ovq5vr16qnxlJdDDxfRjlNOO01zuUBt"
"kSEjRowwrdu00e9/y+tXttnTP8LYqaiQ5NgprjEAUc9evdSS1ZiwMOyoUaPUxcbDGSjMC2MD"
"5LIIgxECQfg6JZRuLE64j4XQCh4HwoHPB3tpiI1PuOMOtRTDSdsw/nAvCyG5MraJs5X8DiUw"
"btw4VXIUZHAPGtY1Cfle8q7E6wdddJE58IADVFEE8Yf7xBDEFI+Q2OZvg78nPLaftZ7dO1DE"
"ABAOvFW8WMIf/1q2bJv19z/vPJ3+fbzgwUIHHpNzYs2X/P3vBe/Gs93vASo7YWiAsBRVmOxX"
"qrE+hfUQMetuwoQJapxQrIASgE4QgHjmzL1bKd4sI31Q5KnOF+GO0XPKqacWvDNFEXfIGbIn"
"lDcjuHlXLhpEMJNr49141swZM/TdEHyFjVUKv8f48eO1DBsaIlc4/7XXzCXigQPXX3edtlJg"
"VVMQk44+0/WJESK97957dW/Zk4NkPzDoUPRcBnuavCseAYaYNiWnoc8wfkrdyQtef+ON2/RB"
"nfe3v6mC69e/vxYiETomf8te1bSGI95sVP4KnzEKpaPNO7vw+PfCBxqRCCiKVPjT7TsGj1O6"
"cek/CK7wxwGGMmOlMHK5foXw7fDhw3U4LxWjzKxkrw4QY8kVaqRaf7hPLLw3GO7dunfXimM8"
"d8KtF8g7Q6MDL7xQecOFNH+LsVNeicVUYptt+SrEiAWIEsASUq9JhDbKinLyj8VihMHd/DuI"
"qELAG0vHZBAHiVPwY+EQ9sEapfQaAUM/DXeIEe5AKEDwfJUNhQnC+IlfI+BherwJrEuSyQgP"
"4vIoKYQjYUDeib4k3s+F37DkEBAIOzyeIH68Cqw0PkO1mIbCBA8z/vhbfk+IY4V9NhYpeNlH"
"3gFlys+hSd6FEM5HItyD66d6j7VjKLjQC2sCP2EqQiYwE+EYzgKFwd/yLNbDvvIvSW4UwbIU"
"s/vc3rNP4HHDUl0YknJsPEzWyt+hkFgDv8eqx6PinKkSTXW+vB/l0OB3PWHQgwt7Ipx5BnSD"
"h0lIyIV2oSMuNkTR4EEXpsR4j1Uff6xnyj64oiNoCI+bn7sSbNbOM/m9Fn6koR/WAO1xhqyd"
"dTsPm72BjqqKV8O1IhRd8I68F5coIjzdbQgmIn4+yzmxNsLF8ANrhW7BxXtAa+wh54rxwN8X"
"JqSjnLEbNcVaeIYOd5b1s47gjdSp8Kfbd7w4crO50H8QyP8yzJpngQO6oWFeK1DhNZENrAX6"
"Zx2cK3h5hyKFyB/kADMhyamxFje6Kkj/8BpV2DzDhcD5lzOpKfLEtdr42Yk7MOTbsBiExqFu"
"sJ6ZTnUmXEA4i/4q+ZfcjfZM0T8ihBqpTNrOgqPyEeLQXJh8XvtnbA4F5VDJCgVyZFHyGAgF"
"LFrwb7SMX8b25SCA1IKS55Wy9w4h7F0RiVMarCXVxA7XJ4awQtC6UUDub/l9RSH+2vJ5GMIR"
"fsHoHfm9y3Wkex+qv7C0XYKfSQKsy83PKyfn4HJN6fDn21xCuhh+eO+3CZPKZxA2nCPnzP8p"
"hODdXDFBmdCkh1QhLPYcYY9hQ7M5n2T9JW3ZN0KDHAn/kuR3o5XcnVDFIuQfeI99bAgsTEOs"
"H/r52YbCAUefeRnCb6Xt2h1duNySy9dyFigWytTxgClUQblECaWH8Tsacr1L7kx4NzwMqlIR"
"3tABvMaZRCnxznTGLqKBUKbQg+8LprXH3HfWlyv9BwEa2E1kj5sNSpjW0TU8gafHvqDE4Ftw"
"RnkH9g8jjRTFr9IElv45E667URqQ94CmCBezplxuEPBK7HdQZFjDpQPhkXACVPtFQuNgogCE"
"gMVcWJ4szqBTVVbct2SnfIeZopht0iwI76T523R5MLxMV8iS7e+j7kthTAJzkb/IBTLtffh5"
"sUIgdpZgoQJX9mv3GLQT5T04i2IxijeckslEe4SYVojywqrfzYbQo9BrYfjLp6GbOEUK2Zxx"
"krjxznOh/234lXmIQuvp6F0NHdlHjNNsAJqMkoPFyIoqG7wS8+DBw04FZWxYFS+SJuDydpKN"
"Bw9Jg8+JFQIuJ+bJxIMHDx7igc+J7QCQ7aVx2UCcS/s8fo/f4/f4dxb82xt8n5gHDx48eNhp"
"wSsxDx48ePDglZiHbYFGxKM6dtSSVHo06PE6sWtX0+Tgg7dep5HjDLwwfnKbB9WpowNu+T7X"
"e7XC+JnmwfoPbdNm62iimPP10uFn4sIJXbqYJk2bbrf9cT/n/3pVxXZYf+cTTtC+oB/sbMWk"
"8NPj06VbN52OkPT+My6Ksz1e1n7c8cdrU3quZ/Bb07+jz7j0QwUftzYwxIDPMoGkg+AvmtD6"
"M+HPlX8z4c+VfzPhT5p/vRL7nYGbh2nKZELHqaeeqg243Xv0ME89+aT2TzEOxt03lgT+L7/6"
"Sq8gOe6447TcmO9zGQETxk8fCmORpj34oK6ZizkZWhtXkKbCzzQNpmHXFkbW/Vm7NtH9ocmb"
"aSVMhucqFh0SG1PJpMKPkGB/uFGAYbQ0Km9KCD/0w/UzTPIAZ5uE95+rUZjaziR0yti5vJSL"
"KONe/BnGzz5D/0xwryP7lPT5MliA8WjsP+XtnAUN4lHxQxeny/7Sw0WDL5Nq6Nvi0sk+556r"
"QjkX/s2En8G/bXPg30z42ZNc+DcK/sYJ8q9XYjsAcMEkgmz+/Pl6pxIExNwyJpIzTZqRTkwj"
"+DHmxOcwfhocnxQG46oHhDONpj9HnDYfBT/Ey6WHNK4yBojBnzDajzFvaU6F/4mZM1VY0OwJ"
"o3yVgyJOtT9MXChrx2sxZSAbIRcFP4yMZXrIIYeoh0c/XpH8/ETwc68V59pMcHN/HVfRsP5f"
"Yp5xGD/joZYtXaqCiIkqXGnzi72AMgn8NMNi/VeuUkUNFu7QYvLKzwmtn3FWjA9jXBOXxcJf"
"TI6Jyl+vCx7mRjKZA77E43j8scfMM888o0qlYePGek0K81Lj8G8m/HxxoWZc/s2Enzu/uLE6"
"Lv9Gwi/yYV1C/Jst+OrE7QDPiMXMTDfulwL0ugLbNV/STsJAYP8UU4mF8UM83F2mt96arTdB"
"b8khlBXGD+MyQuuiiy4yDRo2NEMGD1YhF/cZ6fAzSZ8pDDpFIoeQaKr9aSeW+rhbbtG7qRh/"
"xbSSuO0lqfAj4GB0ZkMyRPa5Z5+N7YmF8aME2JMJd96pFxAe26mTek5JrR9PD5o5vF07M+qq"
"q1QpM1Yo7uSFMH6dKCH48ezwoJgCw2iyzTGNiDD+2fL9ZZddZoYNG6bhOAQ1nhJDp6MAe1vE"
"3kDgbm9g/JO7+VlnXVp6jMO/UfBjWMXl30z458+bp0ploPBvwxj8GxX/0KFDE+HfP6Un1qVL"
"lx1qPYy+GT9unFo/HDj3KjHPzd3SzDw8HTmTEP73xIJzV3XQxZ+fn5/o+v/98cc69JZ5f2f2"
"7KkEy6ifuDe4hvEzh/G0005TJcOgUjxXGCCuEgjjZ54ceaorREDz/QUXXKCjljbGDMeF8TOF"
"Yb0INQQRs/HYF+b8xfVUw/jfEPrB81rx4YeKt7wVFEmtH/pp1ry5vsOSJUu2TmmR843bnBzG"
"D81/IJ4SoVYiEnXq1o183UgU/AhjlPq9996rNxi/v3ix4o7KX/BNCXutCF+rRTnqxPpddtGw"
"8Gd2mHRc/s2En8HexXLg30z48UonTZqk4+/i8G8m/IQQCXffeuutifCv98R2AIDAmerMPLNr"
"rr7azJs7V6euXztmjDLD38SKdANHk8Bfyt7VpVeyJ3DfVBg/V3Uw+w0Gxlti6CgX7cVVlmH8"
"r7/xhl6vwt5wgzGT4N3A2yTwPy8e0ssvv6w4uWV47NixqmA2xgxnhfFzueHlI0aYOsLMeDE3"
"3njjViGa0PrnCv3g4Y2RdbNHTCPXUGhMTywV/WChL1y0SPfIXWWTFP2QO+HyTc6VfBX7r+eb"
"0PoxHLiZmnwn4S2ew9inEhH5Ky/07/3332/+2revehuE6V999VW93POaa64xlWLwbyb8xezM"
"w7j8mwk/+ULlX1E6cfg3E/5X5szRm+f3S4h/s37/P8LEDjwxpmtE+LvEptgXBjoZXAQkIQ2s"
"cywW5oztLozFVQlYQEw5ZyjqB0uXmlzxM0SWgZ0MGHVWHcM/Yeg4zYxh/OCBOPmezSP8oe+z"
"++5mmTwvV/wITQQCeSvuiSL2zvBRquaYpp0rfpSvu7KdsAhegU4Wr1bNLE8IP2eK4MST4f+s"
"n++XppiSH4t+RGiCjzCcu/QRazgJ/O52Bf6P4EEYVbAz8ZKgH86XSAHnyw0DGBBJnq8qXaEf"
"8mPcXwa9cu8et2OnumonFeBRrF27Vu8R06HANoxGfgf8uv+CPy7/FoZf70yTvQBvXP4tDD9z"
"KBkB9u26dbH5tzD8mhOW/Wd6fir+9RM7dkIgbr7RXnHO/UlOSJN74CoErFy9XC/GANZ0+JlQ"
"zc+w1CkoKBEz1JcKv05qF4LdbK9i4F3cTcRJ4C9nhRzhLPYFBcOQ1JIxvYFU+1PGTu+m9B2P"
"Cdxx96iw9aMA+H15e/FhkvSDIGF/SMyjZJLED04mr5PviTNYOur+IABRxkmeL+FFjBM8A75n"
"/ao4s6BPne9o6QRlgpeH0Idfy9nCHcLpcfk3E354DN6Ky7+F4WdAOTmwXPi3MPwoMbzJ72X/"
"k+DfP6USi+KF/ZYAc2E9u6nb7hoNvYpBfo6gyM8h7JcOf74QZ3F7W3NewuvH8oIwN9u7g2CA"
"uOHEdOvH2sUT0HcJ3HKbFH4ACxTmyvaW56jrJ4S4vc4X+iEktD32B5pRoZMj7fye54tgjrv/"
"KDyUrYZo7WcVn9l6WwX4EeRx+TcKfngqLv9mws+/KJi4/Btl/XyfxPl6T+w3gIv//ve0V3Bw"
"A3LXrl31/zfdcINeusfh6sFy+BGsn/ANyQ7o3yGZTYUXwjhsSeVtTRhEfo9q1aubM3v1Kvie"
"MBs3SHMbde8+fQp+zu3MeGLu8sPCIHhz9OhRo7RfpJS8f9OmTQveicTyyMsvV28imHthf/Ij"
"7E+6W3mJzbP/5axlmMrSjKq8aKYlx3LJxRerpRm2Kp0gCELU8w3uEd4VJedUr06XtUMrelV9"
"GvxR9ifdzbxPz56tvWb0VlHI8atziKF4CSF16tRJQ0eOhrDEKbwg3MSt5yedfLLSzp0TJphl"
"y5ap15EX84yBe6dONe8sXKgtE8E9yrT/YXoPQ5BeVTCHhHwm/MFzXfDWW2aqrFPvFrQe27GB"
"m5iDtFpEfu/el9YBWigcDRf2DnyeHj/oc/fQbe9hnmW/87PwHMM0tA0+xwMp9if/d7ipwPeJ"
"xQhlIHj69e1rWoggQEndfNNNpqkoHq5mh/BOPOEE/VtuXP38iy+ybkqlmrFP7976/yuEmMB9"
"zNFHayz7rLPPVmX2Q8zKtyAQf+/7179qXoF3OEuYgz6Qxe+/r+XK5B7+0ratefPNNzWUEiV/"
"+tKLL5qLBw/W/8Nsq+lHkc+SSL5t/HiNoXfs0MH8RxRx3GbaUVdeqZVu7H3DBg1Mq5YtzXVj"
"x2oTJy0AVPDlMjGAM0Y4o1C4B+treYekKq2YdICgo5Lr0FatzIALLlBBR3jsY5tPyBUGikBE"
"WXE9fZPGjU1rEa533H676Sg0RCiP6+Xvv+8+DTFxszUtAnEAb6jnmWdqy0InEdBtWrc2ixYt"
"UiVG+Tvn0KlzZ/PY9OnagsB+cmZRzt2dMbTHO7BXhx92mBpx623FYLb0E6Z3+Io1HydKeOnS"
"pbpeKvniVk062odvDj7kEL3Zmf44xzXklYFzzzlHy9G/kec52cD70ifGTdLkPdPxd/AdMJYJ"
"D1K5+vU335gRYpAQsuUs6Jljn+LWPDgaAk9jMWqpKv0hogzwSmz7w5Ysvn4FCGRuqiWBCbMS"
"v8aFxiLE0p14550FTbSUcROnz7ZKx92QDCCMi9ibiCEoJ/Doq8qVoFi7VjXKvyRs+besjXnz"
"nis/+kgVNpZz6QhemK6dm19ljVR08d6nn366CjSUAAJikVjQvA8CLW4FHJ9z5cHsNRYsjZzG"
"hjxpeN2Qg5KnmRWBhIfUvEULs1rWvSFmT19Y6LcVo2Dy5Ml6aSR7gNC5QTx2cg0Io58SaBB1"
"tyCDmzOFTj8RenUhIKr5NJQk9IOQjWtM4HlwxueIUEYBoCBpip85c6aeMfSJEbBABODFQ4aY"
"iRMn6jOjVG26M3aeM0UI5LvuE+ULfhfijkvvjme5uZmin0tFqeBFqjcak68c7VOtSgFLfTGw"
"KIaAX/GgKPoBMBr4W3jZ3dDN+7p16dimNJWz7h3wolEyQy6+WOkGeicn9dHKlarg9GLRiDxb"
"GA0BrIm1uojSjgZ/qnBiIlUycojElkvWrKkJUhLKHDgVRsxXo0rHKS2IeMJ55/3K9c+UcHY3"
"ICsxkUcT3DXleYx7gcCxxrp3725OOfXUgpDUJFGeCG8IN2qs2ykt/tUbkYWZXf8ITMX7weRU"
"wpWOEAIqiJ0LTpQLIYgpYk2vEsZasGCB4ocRqOy6ddw4Fa4ofjwofn7vPfeoMgqHiVIJuFL2"
"PQmFsUZCNQDCY9aTTxaEc5kmQIMw0E8sWBRJpv6Y6iJwxsn6EO7nnHuuufWWW9QYYd0X2pCN"
"CxsjTPBqKPGuXLmyChbeSZPdRbdlL8rLAaZj8L40/RIGQnHdcvPNGnobJ95qXPxBAcQXDafs"
"OZVuzHREuD7yyCN6xuTXCAed2KWLegXBcHLUopR69eqZ/4q3wRSRWrVq6ftw/rNEkcEXk0VR"
"AyhpvHBaBTjz4hGMF3fGRDY4s379+imdgwPlyLtzNjVq1NA9wlvGw4T20q09SO+OZ3l3vD36"
"y5qLR3/KKaeogYrSbyMGB4bM888+a3qLoubMgiHR8EQWR/s8n+k8TFrBaKMpGtlAZSNGTAnL"
"0+Q3mVdJiJFnUiyRb/NJmXiWfYFm7hTDgIjH3XfdpSFdFI+rnDzgwAOV9hnLxR5Nkr8lXEqk"
"IVNOz9GQyz8Gb+bm+wEhPmD9Y8eMKagU9Z7YDgx59oA5yHAVV1HrMTkv6jxRYIzw4aDbt29v"
"PsKzEWGYDVwqiuAZYaKrRo1Sq44wJgxEfgnBQKgI4VNdBMinOYTo8ly+KJQ70uZLea9stT9M"
"gnUO058rykOr6+TdYUL+P2TQIFUMhLgIX/79kkt0Jh7M9p38PIotjPKaN3++9qi0P+oo9YKn"
"TJlizj77bP39ylWrzCMPP6wz3YDFYglTlp3JW8JQ4O/obwKOljXC/F+uXm2uvfpq/RleTufj"
"jtOQXHcRFJdfdpmZLOs4VM4j3Tk7Dx1PCBpBWbC/ZYSOqGpEANEDFhf/r/J6xxxjnn3uOTUY"
"UMyEF9VzFQHqDKnXZP+Wi1A+SYyiv4pSyGbkEfS/RvYFg6OiNQ54HxQVOdtLxPsCTj75ZPXC"
"iloPPJ3yTQXkZ18Qrxg6YcYgNIUSOFgE/3c2dEavGKEuwuyE0KIAEz/gK/LP5JiptHv7rbd0"
"viMVd7PFUCBsh2GBx9lNBDWjp1CahAkL88zhFXpDOzKgWN4Z5YvCRyECTskyooy8K14gnhnh"
"RgyPKOPQ8qxCu3r0aNOuXTsdDA1dAZoPFnwosHnz5pkj5PfPyrv2OussDeNvyDEVQcjzYnu2"
"pFQI+0JThGS/k3304cQ/EKDABg8erFYeQot8U1QmczBy5EidDUfe53xRiuSUEEgIfUIUjNyB"
"GbD2mEe3IaYSS17bb61WmjNnjiarh156qVkvgsblG7RkWfYCJqPPDwELIEBgxiiMTNgED9Xl"
"DEmk463sKgJVQ7/CrDryy+6Jhl0yhAXxlg5t3do8JMrvLutJMI5JZ83ZCd7ADPE2YGZCpczw"
"oz+J9yHsgiL4PsU5Ow99iw09OYsbY4Fmb77fZPcnDv4wzJo509StU8c0F4F/tQh6vBkMK5d8"
"B9dt4r0gzBHkeAeE1opnUQCwJVDt5gyd+g0banOw87jwqPCYeV7RotkFfxaKZ8473DV5shoS"
"hD/ZI75QnIR+EZ5XXHFFykKIdHCLeNfQDsIdesOgwjOlGAXl+Nhjj6nnChC+xKhBiRL2RZFm"
"UgREBODVozp0MLvInr4h3p6bdemUOHlXPDW8tgEDBugZMIor6kxP3pe1EsFwhiL8BZ0pH4j3"
"9MADDyg+eBCjj6ZnHX6dQyoiLxBynTlrlu49ilTDob9DzsxXJ25HQDDj1u8hX84Sz3ZoKyEL"
"rByIkjAboQAs3fPPP98sFQv65B49TJ8+fVQwai9IzIIGiFtH+LhwAuXiVkjlQuyERam6Y1IA"
"Ce0V4kUgKFwOAOGH91NTLFzdI2FAvSpC3iVKnw9eDMzJnujkA9kjHToLk9tROYy1cjmLTFB9"
"//3N8Z07a/6Oz1KleKkoYLxfFAcek65ThAUhFt4DoYSgxgsvOOcUxQGMjXJhOHJubm95f/Ik"
"PJPnxMWfav8xnggvrRHBu1AE5mmnn67eqsu9DR8+XAU6o614NrmnqOFoKvDq1q2rygnB6SYJ"
"kLtCOTiDgbXzjuWy7N1yxhDvPW3aNN0LlCFexvvvvafrHCRGIufP99ddd13k3jk+ixKkwIP/"
"897QD4oXhcYzaSZ3dIOX6SqCo4zMYh0YHxiYGAcfLFny/yFyG8qDV7dYg45hBW50XNS8k5a1"
"y94SDq0ie66Goqz9RzunFeAMoKMqtnoUY9c1y+fH7FPV51o6JTpByJpwMmmWMpZGvSe2k0NJ"
"W35PvgPmKGsP3Jqu2SkxQjUoMSHCKlWqKPExaWI3wUsZM82RWL38jbPyswXi/4zFogkYCxNG"
"Js79nggGhFO2/WBYzljIxWzPC4yGl4SXQ9hnfSAU1qJFCw0H8i8AQ2YDpa0SQ3AypQEh5wRM"
"bVnDiBEjNNQCZJqqrfdoYenbplOU3ypRugCWJsU0zhNDKJew/WYuROpyJKqcUpwzSooQJYOU"
"yY2grBHsXbt316G2wQrQOPjDAG4UDEqM+57wPKgSxZP4xXocKCLCQQyH1UkYWRSWUHGIkiQX"
"hVJEYPIcpuKjMDcncBVHnlVi0D6CkuHKvXv3VnrBWOl5xhmmrZwv/IASQIBHMbzYS/aYuZq1"
"ZF8oSsFYyLMeKvvtcqf8rbY9BHqf0j2BmZNMCoEu2duDDz5YK2jx5sKFTOSRuIKIv0EBOaWZ"
"CfDg4CUMW+iR9WIo6tADeS5eIxWOKJgTTjxRP8O5EAnCa80FCK2ectppGtVw8onnMqEDZflb"
"NThvQyN/hLFT2xPSjZ0K93JROjxs6FAVGKOvuabg51xR0Fkse4BY+oUDBijTOIJONVYmFW6K"
"JJiowOewRBmYi9dAkQDJ+mFiUY8fP17j+iR4ncUbZWwNwof7kmAoB8wbpGwdBkGAkL9JBWH8"
"wV4ZoH+/fmrhowxbye+oTKNoooF85jJRMAi75s2bq/Iht8F+ET4lrMg7pFp/uIeIYgSKXVxB"
"CM+qJ58hl4SioBKQWXuEeAZeeGHK/Q+umzDQ4EGDtLR4iHiQDpi2j2UdDGeiQJ3ybWZ7gADa"
"LA4SoRsc60OohQKERrLPVPQBeHcMrqWqD2+UKftx8TtI1yc2+6mnzKhRo8yQIUO0oEBzYqLU"
"WrZsWfA39Epx1xTCEOVZGP0QXkWo9+zVS3NHmneUv+cZCDam7jsgN0phAyGuoDeWDn9hfWK8"
"B60BFPPUsB48A4Cvv/56VdQYM87wCuJP1Sc2aOBAVX54i00CvYyE9vaz3ouevey/6/GiSvjW"
"m29WGv3XsmUF+MO0T75u0uTJ+t4Ug0CDDjhv8m8XiSdJ3g/lAn3yeYY3zJwxQw2p8Fir8Dvg"
"RX+0YoUqXKIEXHxJLhVeJu1ASw4yiTwqhRc8hz2Crshbp9v/dDSkIV7h2caNG2+zNxPuuEPH"
"ioU9YfBv77FTXonFVGJYnljWJJPJUXB4ED2WHSExiMXNFYOhsVywErGeEFau+CMVETncWFPg"
"1nCDfA4PjM/hKZAroZyW0IDrlOcLBuY6ipKFKMlU74LAdHPtXL6GZ8EYauWmCQOF8ZN/QunC"
"NHhcWJcIGqxeLEQUOVYtihHr88EHHjA3i0DQkmDnVcl7otTy0qwfxUTRBoIGz4FQIp9xQ1+h"
"aJ610pYbu7wN/4I/1f6zbnqP6O1jDxAg7Ddhu+UiMMHjcjt4k3gtrNeNg3JtEPzffR4l8295"
"3+D6KZpAkX1ie4h0SoPgwJPGSOF55GKwmuPgN/bdmVkH/Tlv1Sl3V4VKuJbf8y9GBnTk9hLh"
"p+E1oYPC6AelzD5wDqwX/NAOz+MsoBl63/gd+3aAGF3cBRa01tPhd2cMLeFZu4G7G+3oJJ6h"
"FZiiSPXuM0LX8gwUC+F3F5IL4mdv8UKhC9bEWqFPeFb3RH7PfWorLO1iwPEs3pHns0/8HDri"
"OewTPOjwQ0N8nnXzGfYAuueZbrAyxVl8gRueJv9ILynywQ3N5b24fJMQYXi2JGukGpSfgxe6"
"oSp0b1EgnCH0y7+sjVD7f+zZsEfIEdIb0I4rSku3/0EaYl2OFtl/cGn+VvYGWmRv2A8dQRWM"
"Ov1GSsznxOJunHWjYQBCfW6sDoTCoSMAEUp4TS6OTnjF/U0U3DA9xBzErTFg+T2KhZwPBItS"
"gCF5Bn+TbfK8uJ2bBwEioLWHhp4X+b5chJaAbdYun3O5nI2WcWCmojb3pe8g+3OpeI783fkX"
"XKA9aoReCL9Sdlw2Qzk/OCqJMtJBpJRbkwujaMCu04WEHHMT0uR3hF4QzKn2n3XjJRBK3WSF"
"pvbKyF5wxs66Z+85RzdexynHPDutwP3OlSj/aq9lrYTBSluBiFAobqeYMymCMB/njvEQB7+G"
"s+Xn0CQhnm1CaJwp/Xnye3IjCEA84yBeaKGcnTOZMRcha2KfndLbYD0zBB7vs8n2YvEuRe07"
"RqXN8BmH36OkzU/9LPSPEcbZOHpNl1NyPVbwJufpnuP6n6ARLmitLWvlXNze8xU8ezUM5Fnh"
"Ahjejc/XQtgL7WseTegIxbHJ0gtGAr9z/FXCjhIjjO/GZ/E8UhKpqjiLWOOSUHdVMQQLaN/m"
"06AdFB0hfOQDdIByh66gbc4ryhUs6WjI5RODNMP3qfbjN5PFXh3FA9fL5fq5fhW3jhjfjoNb"
"y/xpBo146V9Gd9wyc4kE4tmqrLiPyk5BDwJMWcyGJUdfdZVaeljxCBFCiHsRLo2QmGede9pi"
"mTjryPbvcx2Im+0e5TyAVwRQJvpDmaUL12UD+TbnWTrNGLYyMd8lyhlnvVbbY1U2TfFBJr7L"
"5VwznUVS7xD+uYtwbA8a2mEcCq+OPPwe4Cqy8L6wIoOelAcPHjxENsJ9TqxwsHeQefDgwYOH"
"GLC9c2L/J8AAm1EAoAEDbGUAAAAASUVORK5CYII=")
getPtableSelData = PtableSel.GetData
getPtableSelImage = PtableSel.GetImage
getPtableSelBitmap = PtableSel.GetBitmap
| lukauskas/mMass-fork | gui/images_lib_gtk.py | Python | gpl-3.0 | 993,889 | [
"DFTB+"
] | 0fc1c8cc9a5342f4d068ad3439b62073ae8b397e236917d94d85824d4c236aec |
# -*- coding: utf-8 -*-
import sys
import textwrap
import pytest
from _pytest import fixtures
from _pytest.fixtures import FixtureLookupError
from _pytest.fixtures import FixtureRequest
from _pytest.pathlib import Path
from _pytest.pytester import get_public_names
from _pytest.warnings import SHOW_PYTEST_WARNINGS_ARG
def test_getfuncargnames():
def f():
pass
assert not fixtures.getfuncargnames(f)
def g(arg):
pass
assert fixtures.getfuncargnames(g) == ("arg",)
def h(arg1, arg2="hello"):
pass
assert fixtures.getfuncargnames(h) == ("arg1",)
def h(arg1, arg2, arg3="hello"):
pass
assert fixtures.getfuncargnames(h) == ("arg1", "arg2")
class A(object):
def f(self, arg1, arg2="hello"):
pass
@staticmethod
def static(arg1, arg2):
pass
assert fixtures.getfuncargnames(A().f) == ("arg1",)
assert fixtures.getfuncargnames(A.static, cls=A) == ("arg1", "arg2")
@pytest.mark.pytester_example_path("fixtures/fill_fixtures")
class TestFillFixtures(object):
def test_fillfuncargs_exposed(self):
# used by oejskit, kept for compatibility
assert pytest._fillfuncargs == fixtures.fillfixtures
def test_funcarg_lookupfails(self, testdir):
testdir.copy_example()
result = testdir.runpytest() # "--collect-only")
assert result.ret != 0
result.stdout.fnmatch_lines(
"""
*def test_func(some)*
*fixture*some*not found*
*xyzsomething*
"""
)
def test_detect_recursive_dependency_error(self, testdir):
testdir.copy_example()
result = testdir.runpytest()
result.stdout.fnmatch_lines(
["*recursive dependency involving fixture 'fix1' detected*"]
)
def test_funcarg_basic(self, testdir):
testdir.copy_example()
item = testdir.getitem(Path("test_funcarg_basic.py"))
fixtures.fillfixtures(item)
del item.funcargs["request"]
assert len(get_public_names(item.funcargs)) == 2
assert item.funcargs["some"] == "test_func"
assert item.funcargs["other"] == 42
def test_funcarg_lookup_modulelevel(self, testdir):
testdir.copy_example()
reprec = testdir.inline_run()
reprec.assertoutcome(passed=2)
def test_funcarg_lookup_classlevel(self, testdir):
p = testdir.copy_example()
result = testdir.runpytest(p)
result.stdout.fnmatch_lines(["*1 passed*"])
def test_conftest_funcargs_only_available_in_subdir(self, testdir):
testdir.copy_example()
result = testdir.runpytest("-v")
result.assert_outcomes(passed=2)
def test_extend_fixture_module_class(self, testdir):
testfile = testdir.copy_example()
result = testdir.runpytest()
result.stdout.fnmatch_lines(["*1 passed*"])
result = testdir.runpytest(testfile)
result.stdout.fnmatch_lines(["*1 passed*"])
def test_extend_fixture_conftest_module(self, testdir):
p = testdir.copy_example()
result = testdir.runpytest()
result.stdout.fnmatch_lines(["*1 passed*"])
result = testdir.runpytest(next(p.visit("test_*.py")))
result.stdout.fnmatch_lines(["*1 passed*"])
def test_extend_fixture_conftest_conftest(self, testdir):
p = testdir.copy_example()
result = testdir.runpytest()
result.stdout.fnmatch_lines(["*1 passed*"])
result = testdir.runpytest(next(p.visit("test_*.py")))
result.stdout.fnmatch_lines(["*1 passed*"])
def test_extend_fixture_conftest_plugin(self, testdir):
testdir.makepyfile(
testplugin="""
import pytest
@pytest.fixture
def foo():
return 7
"""
)
testdir.syspathinsert()
testdir.makeconftest(
"""
import pytest
pytest_plugins = 'testplugin'
@pytest.fixture
def foo(foo):
return foo + 7
"""
)
testdir.makepyfile(
"""
def test_foo(foo):
assert foo == 14
"""
)
result = testdir.runpytest("-s")
assert result.ret == 0
def test_extend_fixture_plugin_plugin(self, testdir):
# Two plugins should extend each order in loading order
testdir.makepyfile(
testplugin0="""
import pytest
@pytest.fixture
def foo():
return 7
"""
)
testdir.makepyfile(
testplugin1="""
import pytest
@pytest.fixture
def foo(foo):
return foo + 7
"""
)
testdir.syspathinsert()
testdir.makepyfile(
"""
pytest_plugins = ['testplugin0', 'testplugin1']
def test_foo(foo):
assert foo == 14
"""
)
result = testdir.runpytest()
assert result.ret == 0
def test_override_parametrized_fixture_conftest_module(self, testdir):
"""Test override of the parametrized fixture with non-parametrized one on the test module level."""
testdir.makeconftest(
"""
import pytest
@pytest.fixture(params=[1, 2, 3])
def spam(request):
return request.param
"""
)
testfile = testdir.makepyfile(
"""
import pytest
@pytest.fixture
def spam():
return 'spam'
def test_spam(spam):
assert spam == 'spam'
"""
)
result = testdir.runpytest()
result.stdout.fnmatch_lines(["*1 passed*"])
result = testdir.runpytest(testfile)
result.stdout.fnmatch_lines(["*1 passed*"])
def test_override_parametrized_fixture_conftest_conftest(self, testdir):
"""Test override of the parametrized fixture with non-parametrized one on the conftest level."""
testdir.makeconftest(
"""
import pytest
@pytest.fixture(params=[1, 2, 3])
def spam(request):
return request.param
"""
)
subdir = testdir.mkpydir("subdir")
subdir.join("conftest.py").write(
textwrap.dedent(
"""\
import pytest
@pytest.fixture
def spam():
return 'spam'
"""
)
)
testfile = subdir.join("test_spam.py")
testfile.write(
textwrap.dedent(
"""\
def test_spam(spam):
assert spam == "spam"
"""
)
)
result = testdir.runpytest()
result.stdout.fnmatch_lines(["*1 passed*"])
result = testdir.runpytest(testfile)
result.stdout.fnmatch_lines(["*1 passed*"])
def test_override_non_parametrized_fixture_conftest_module(self, testdir):
"""Test override of the non-parametrized fixture with parametrized one on the test module level."""
testdir.makeconftest(
"""
import pytest
@pytest.fixture
def spam():
return 'spam'
"""
)
testfile = testdir.makepyfile(
"""
import pytest
@pytest.fixture(params=[1, 2, 3])
def spam(request):
return request.param
params = {'spam': 1}
def test_spam(spam):
assert spam == params['spam']
params['spam'] += 1
"""
)
result = testdir.runpytest()
result.stdout.fnmatch_lines(["*3 passed*"])
result = testdir.runpytest(testfile)
result.stdout.fnmatch_lines(["*3 passed*"])
def test_override_non_parametrized_fixture_conftest_conftest(self, testdir):
"""Test override of the non-parametrized fixture with parametrized one on the conftest level."""
testdir.makeconftest(
"""
import pytest
@pytest.fixture
def spam():
return 'spam'
"""
)
subdir = testdir.mkpydir("subdir")
subdir.join("conftest.py").write(
textwrap.dedent(
"""\
import pytest
@pytest.fixture(params=[1, 2, 3])
def spam(request):
return request.param
"""
)
)
testfile = subdir.join("test_spam.py")
testfile.write(
textwrap.dedent(
"""\
params = {'spam': 1}
def test_spam(spam):
assert spam == params['spam']
params['spam'] += 1
"""
)
)
result = testdir.runpytest()
result.stdout.fnmatch_lines(["*3 passed*"])
result = testdir.runpytest(testfile)
result.stdout.fnmatch_lines(["*3 passed*"])
def test_override_autouse_fixture_with_parametrized_fixture_conftest_conftest(
self, testdir
):
"""Test override of the autouse fixture with parametrized one on the conftest level.
This test covers the issue explained in issue 1601
"""
testdir.makeconftest(
"""
import pytest
@pytest.fixture(autouse=True)
def spam():
return 'spam'
"""
)
subdir = testdir.mkpydir("subdir")
subdir.join("conftest.py").write(
textwrap.dedent(
"""\
import pytest
@pytest.fixture(params=[1, 2, 3])
def spam(request):
return request.param
"""
)
)
testfile = subdir.join("test_spam.py")
testfile.write(
textwrap.dedent(
"""\
params = {'spam': 1}
def test_spam(spam):
assert spam == params['spam']
params['spam'] += 1
"""
)
)
result = testdir.runpytest()
result.stdout.fnmatch_lines(["*3 passed*"])
result = testdir.runpytest(testfile)
result.stdout.fnmatch_lines(["*3 passed*"])
def test_autouse_fixture_plugin(self, testdir):
# A fixture from a plugin has no baseid set, which screwed up
# the autouse fixture handling.
testdir.makepyfile(
testplugin="""
import pytest
@pytest.fixture(autouse=True)
def foo(request):
request.function.foo = 7
"""
)
testdir.syspathinsert()
testdir.makepyfile(
"""
pytest_plugins = 'testplugin'
def test_foo(request):
assert request.function.foo == 7
"""
)
result = testdir.runpytest()
assert result.ret == 0
def test_funcarg_lookup_error(self, testdir):
testdir.makeconftest(
"""
import pytest
@pytest.fixture
def a_fixture(): pass
@pytest.fixture
def b_fixture(): pass
@pytest.fixture
def c_fixture(): pass
@pytest.fixture
def d_fixture(): pass
"""
)
testdir.makepyfile(
"""
def test_lookup_error(unknown):
pass
"""
)
result = testdir.runpytest()
result.stdout.fnmatch_lines(
[
"*ERROR at setup of test_lookup_error*",
" def test_lookup_error(unknown):*",
"E fixture 'unknown' not found",
"> available fixtures:*a_fixture,*b_fixture,*c_fixture,*d_fixture*monkeypatch,*", # sorted
"> use 'py*test --fixtures *' for help on them.",
"*1 error*",
]
)
assert "INTERNAL" not in result.stdout.str()
def test_fixture_excinfo_leak(self, testdir):
# on python2 sys.excinfo would leak into fixture executions
testdir.makepyfile(
"""
import sys
import traceback
import pytest
@pytest.fixture
def leak():
if sys.exc_info()[0]: # python3 bug :)
traceback.print_exc()
#fails
assert sys.exc_info() == (None, None, None)
def test_leak(leak):
if sys.exc_info()[0]: # python3 bug :)
traceback.print_exc()
assert sys.exc_info() == (None, None, None)
"""
)
result = testdir.runpytest()
assert result.ret == 0
class TestRequestBasic(object):
def test_request_attributes(self, testdir):
item = testdir.getitem(
"""
import pytest
@pytest.fixture
def something(request): pass
def test_func(something): pass
"""
)
req = fixtures.FixtureRequest(item)
assert req.function == item.obj
assert req.keywords == item.keywords
assert hasattr(req.module, "test_func")
assert req.cls is None
assert req.function.__name__ == "test_func"
assert req.config == item.config
assert repr(req).find(req.function.__name__) != -1
def test_request_attributes_method(self, testdir):
item, = testdir.getitems(
"""
import pytest
class TestB(object):
@pytest.fixture
def something(self, request):
return 1
def test_func(self, something):
pass
"""
)
req = item._request
assert req.cls.__name__ == "TestB"
assert req.instance.__class__ == req.cls
def test_request_contains_funcarg_arg2fixturedefs(self, testdir):
modcol = testdir.getmodulecol(
"""
import pytest
@pytest.fixture
def something(request):
pass
class TestClass(object):
def test_method(self, something):
pass
"""
)
item1, = testdir.genitems([modcol])
assert item1.name == "test_method"
arg2fixturedefs = fixtures.FixtureRequest(item1)._arg2fixturedefs
assert len(arg2fixturedefs) == 1
assert arg2fixturedefs["something"][0].argname == "something"
@pytest.mark.skipif(
hasattr(sys, "pypy_version_info"),
reason="this method of test doesn't work on pypy",
)
def test_request_garbage(self, testdir):
try:
import xdist # noqa
except ImportError:
pass
else:
pytest.xfail("this test is flaky when executed with xdist")
testdir.makepyfile(
"""
import sys
import pytest
from _pytest.fixtures import PseudoFixtureDef
import gc
@pytest.fixture(autouse=True)
def something(request):
original = gc.get_debug()
gc.set_debug(gc.DEBUG_SAVEALL)
gc.collect()
yield
try:
gc.collect()
leaked_types = sum(1 for _ in gc.garbage
if isinstance(_, PseudoFixtureDef))
# debug leaked types if the test fails
print(leaked_types)
gc.garbage[:] = []
assert leaked_types == 0
finally:
gc.set_debug(original)
def test_func():
pass
"""
)
result = testdir.runpytest()
result.stdout.fnmatch_lines("* 1 passed in *")
def test_getfixturevalue_recursive(self, testdir):
testdir.makeconftest(
"""
import pytest
@pytest.fixture
def something(request):
return 1
"""
)
testdir.makepyfile(
"""
import pytest
@pytest.fixture
def something(request):
return request.getfixturevalue("something") + 1
def test_func(something):
assert something == 2
"""
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=1)
@pytest.mark.parametrize("getfixmethod", ("getfixturevalue", "getfuncargvalue"))
def test_getfixturevalue(self, testdir, getfixmethod):
item = testdir.getitem(
"""
import pytest
values = [2]
@pytest.fixture
def something(request): return 1
@pytest.fixture
def other(request):
return values.pop()
def test_func(something): pass
"""
)
import contextlib
if getfixmethod == "getfuncargvalue":
warning_expectation = pytest.warns(DeprecationWarning)
else:
# see #1830 for a cleaner way to accomplish this
@contextlib.contextmanager
def expecting_no_warning():
yield
warning_expectation = expecting_no_warning()
req = item._request
with warning_expectation:
fixture_fetcher = getattr(req, getfixmethod)
with pytest.raises(FixtureLookupError):
fixture_fetcher("notexists")
val = fixture_fetcher("something")
assert val == 1
val = fixture_fetcher("something")
assert val == 1
val2 = fixture_fetcher("other")
assert val2 == 2
val2 = fixture_fetcher("other") # see about caching
assert val2 == 2
pytest._fillfuncargs(item)
assert item.funcargs["something"] == 1
assert len(get_public_names(item.funcargs)) == 2
assert "request" in item.funcargs
def test_request_addfinalizer(self, testdir):
item = testdir.getitem(
"""
import pytest
teardownlist = []
@pytest.fixture
def something(request):
request.addfinalizer(lambda: teardownlist.append(1))
def test_func(something): pass
"""
)
item.session._setupstate.prepare(item)
pytest._fillfuncargs(item)
# successively check finalization calls
teardownlist = item.getparent(pytest.Module).obj.teardownlist
ss = item.session._setupstate
assert not teardownlist
ss.teardown_exact(item, None)
print(ss.stack)
assert teardownlist == [1]
def test_mark_as_fixture_with_prefix_and_decorator_fails(self, testdir):
testdir.makeconftest(
"""
import pytest
@pytest.fixture
def pytest_funcarg__marked_with_prefix_and_decorator():
pass
"""
)
result = testdir.runpytest_subprocess()
assert result.ret != 0
result.stdout.fnmatch_lines(
[
"*AssertionError: fixtures cannot have*@pytest.fixture*",
"*pytest_funcarg__marked_with_prefix_and_decorator*",
]
)
def test_request_addfinalizer_failing_setup(self, testdir):
testdir.makepyfile(
"""
import pytest
values = [1]
@pytest.fixture
def myfix(request):
request.addfinalizer(values.pop)
assert 0
def test_fix(myfix):
pass
def test_finalizer_ran():
assert not values
"""
)
reprec = testdir.inline_run("-s")
reprec.assertoutcome(failed=1, passed=1)
def test_request_addfinalizer_failing_setup_module(self, testdir):
testdir.makepyfile(
"""
import pytest
values = [1, 2]
@pytest.fixture(scope="module")
def myfix(request):
request.addfinalizer(values.pop)
request.addfinalizer(values.pop)
assert 0
def test_fix(myfix):
pass
"""
)
reprec = testdir.inline_run("-s")
mod = reprec.getcalls("pytest_runtest_setup")[0].item.module
assert not mod.values
def test_request_addfinalizer_partial_setup_failure(self, testdir):
p = testdir.makepyfile(
"""
import pytest
values = []
@pytest.fixture
def something(request):
request.addfinalizer(lambda: values.append(None))
def test_func(something, missingarg):
pass
def test_second():
assert len(values) == 1
"""
)
result = testdir.runpytest(p)
result.stdout.fnmatch_lines(
["*1 error*"] # XXX the whole module collection fails
)
def test_request_subrequest_addfinalizer_exceptions(self, testdir):
"""
Ensure exceptions raised during teardown by a finalizer are suppressed
until all finalizers are called, re-raising the first exception (#2440)
"""
testdir.makepyfile(
"""
import pytest
values = []
def _excepts(where):
raise Exception('Error in %s fixture' % where)
@pytest.fixture
def subrequest(request):
return request
@pytest.fixture
def something(subrequest):
subrequest.addfinalizer(lambda: values.append(1))
subrequest.addfinalizer(lambda: values.append(2))
subrequest.addfinalizer(lambda: _excepts('something'))
@pytest.fixture
def excepts(subrequest):
subrequest.addfinalizer(lambda: _excepts('excepts'))
subrequest.addfinalizer(lambda: values.append(3))
def test_first(something, excepts):
pass
def test_second():
assert values == [3, 2, 1]
"""
)
result = testdir.runpytest()
result.stdout.fnmatch_lines(
["*Exception: Error in excepts fixture", "* 2 passed, 1 error in *"]
)
def test_request_getmodulepath(self, testdir):
modcol = testdir.getmodulecol("def test_somefunc(): pass")
item, = testdir.genitems([modcol])
req = fixtures.FixtureRequest(item)
assert req.fspath == modcol.fspath
def test_request_fixturenames(self, testdir):
testdir.makepyfile(
"""
import pytest
from _pytest.pytester import get_public_names
@pytest.fixture()
def arg1():
pass
@pytest.fixture()
def farg(arg1):
pass
@pytest.fixture(autouse=True)
def sarg(tmpdir):
pass
def test_function(request, farg):
assert set(get_public_names(request.fixturenames)) == \
set(["tmpdir", "sarg", "arg1", "request", "farg",
"tmpdir_factory"])
"""
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=1)
def test_request_fixturenames_dynamic_fixture(self, testdir):
"""Regression test for #3057"""
testdir.copy_example("fixtures/test_getfixturevalue_dynamic.py")
result = testdir.runpytest()
result.stdout.fnmatch_lines("*1 passed*")
def test_funcargnames_compatattr(self, testdir):
testdir.makepyfile(
"""
import pytest
def pytest_generate_tests(metafunc):
assert metafunc.funcargnames == metafunc.fixturenames
@pytest.fixture
def fn(request):
assert request._pyfuncitem.funcargnames == \
request._pyfuncitem.fixturenames
return request.funcargnames, request.fixturenames
def test_hello(fn):
assert fn[0] == fn[1]
"""
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=1)
def test_setupdecorator_and_xunit(self, testdir):
testdir.makepyfile(
"""
import pytest
values = []
@pytest.fixture(scope='module', autouse=True)
def setup_module():
values.append("module")
@pytest.fixture(autouse=True)
def setup_function():
values.append("function")
def test_func():
pass
class TestClass(object):
@pytest.fixture(scope="class", autouse=True)
def setup_class(self):
values.append("class")
@pytest.fixture(autouse=True)
def setup_method(self):
values.append("method")
def test_method(self):
pass
def test_all():
assert values == ["module", "function", "class",
"function", "method", "function"]
"""
)
reprec = testdir.inline_run("-v")
reprec.assertoutcome(passed=3)
def test_fixtures_sub_subdir_normalize_sep(self, testdir):
# this tests that normalization of nodeids takes place
b = testdir.mkdir("tests").mkdir("unit")
b.join("conftest.py").write(
textwrap.dedent(
"""\
import pytest
@pytest.fixture
def arg1():
pass
"""
)
)
p = b.join("test_module.py")
p.write("def test_func(arg1): pass")
result = testdir.runpytest(p, "--fixtures")
assert result.ret == 0
result.stdout.fnmatch_lines(
"""
*fixtures defined*conftest*
*arg1*
"""
)
def test_show_fixtures_color_yes(self, testdir):
testdir.makepyfile("def test_this(): assert 1")
result = testdir.runpytest("--color=yes", "--fixtures")
assert "\x1b[32mtmpdir" in result.stdout.str()
def test_newstyle_with_request(self, testdir):
testdir.makepyfile(
"""
import pytest
@pytest.fixture()
def arg(request):
pass
def test_1(arg):
pass
"""
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=1)
def test_setupcontext_no_param(self, testdir):
testdir.makepyfile(
"""
import pytest
@pytest.fixture(params=[1,2])
def arg(request):
return request.param
@pytest.fixture(autouse=True)
def mysetup(request, arg):
assert not hasattr(request, "param")
def test_1(arg):
assert arg in (1,2)
"""
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=2)
class TestRequestMarking(object):
def test_applymarker(self, testdir):
item1, item2 = testdir.getitems(
"""
import pytest
@pytest.fixture
def something(request):
pass
class TestClass(object):
def test_func1(self, something):
pass
def test_func2(self, something):
pass
"""
)
req1 = fixtures.FixtureRequest(item1)
assert "xfail" not in item1.keywords
req1.applymarker(pytest.mark.xfail)
assert "xfail" in item1.keywords
assert "skipif" not in item1.keywords
req1.applymarker(pytest.mark.skipif)
assert "skipif" in item1.keywords
pytest.raises(ValueError, "req1.applymarker(42)")
def test_accesskeywords(self, testdir):
testdir.makepyfile(
"""
import pytest
@pytest.fixture()
def keywords(request):
return request.keywords
@pytest.mark.XYZ
def test_function(keywords):
assert keywords["XYZ"]
assert "abc" not in keywords
"""
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=1)
def test_accessmarker_dynamic(self, testdir):
testdir.makeconftest(
"""
import pytest
@pytest.fixture()
def keywords(request):
return request.keywords
@pytest.fixture(scope="class", autouse=True)
def marking(request):
request.applymarker(pytest.mark.XYZ("hello"))
"""
)
testdir.makepyfile(
"""
import pytest
def test_fun1(keywords):
assert keywords["XYZ"] is not None
assert "abc" not in keywords
def test_fun2(keywords):
assert keywords["XYZ"] is not None
assert "abc" not in keywords
"""
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=2)
class TestRequestCachedSetup(object):
def test_request_cachedsetup_defaultmodule(self, testdir):
reprec = testdir.inline_runsource(
"""
mysetup = ["hello",].pop
import pytest
@pytest.fixture
def something(request):
return request.cached_setup(mysetup, scope="module")
def test_func1(something):
assert something == "hello"
class TestClass(object):
def test_func1a(self, something):
assert something == "hello"
""",
SHOW_PYTEST_WARNINGS_ARG,
)
reprec.assertoutcome(passed=2)
def test_request_cachedsetup_class(self, testdir):
reprec = testdir.inline_runsource(
"""
mysetup = ["hello", "hello2", "hello3"].pop
import pytest
@pytest.fixture
def something(request):
return request.cached_setup(mysetup, scope="class")
def test_func1(something):
assert something == "hello3"
def test_func2(something):
assert something == "hello2"
class TestClass(object):
def test_func1a(self, something):
assert something == "hello"
def test_func2b(self, something):
assert something == "hello"
""",
SHOW_PYTEST_WARNINGS_ARG,
)
reprec.assertoutcome(passed=4)
@pytest.mark.filterwarnings("ignore:cached_setup is deprecated")
def test_request_cachedsetup_extrakey(self, testdir):
item1 = testdir.getitem("def test_func(): pass")
req1 = fixtures.FixtureRequest(item1)
values = ["hello", "world"]
def setup():
return values.pop()
ret1 = req1.cached_setup(setup, extrakey=1)
ret2 = req1.cached_setup(setup, extrakey=2)
assert ret2 == "hello"
assert ret1 == "world"
ret1b = req1.cached_setup(setup, extrakey=1)
ret2b = req1.cached_setup(setup, extrakey=2)
assert ret1 == ret1b
assert ret2 == ret2b
@pytest.mark.filterwarnings("ignore:cached_setup is deprecated")
def test_request_cachedsetup_cache_deletion(self, testdir):
item1 = testdir.getitem("def test_func(): pass")
req1 = fixtures.FixtureRequest(item1)
values = []
def setup():
values.append("setup")
def teardown(val):
values.append("teardown")
req1.cached_setup(setup, teardown, scope="function")
assert values == ["setup"]
# artificial call of finalizer
setupstate = req1._pyfuncitem.session._setupstate
setupstate._callfinalizers(item1)
assert values == ["setup", "teardown"]
req1.cached_setup(setup, teardown, scope="function")
assert values == ["setup", "teardown", "setup"]
setupstate._callfinalizers(item1)
assert values == ["setup", "teardown", "setup", "teardown"]
def test_request_cached_setup_two_args(self, testdir):
testdir.makepyfile(
"""
import pytest
@pytest.fixture
def arg1(request):
return request.cached_setup(lambda: 42)
@pytest.fixture
def arg2(request):
return request.cached_setup(lambda: 17)
def test_two_different_setups(arg1, arg2):
assert arg1 != arg2
"""
)
result = testdir.runpytest("-v", SHOW_PYTEST_WARNINGS_ARG)
result.stdout.fnmatch_lines(["*1 passed*"])
def test_request_cached_setup_getfixturevalue(self, testdir):
testdir.makepyfile(
"""
import pytest
@pytest.fixture
def arg1(request):
arg1 = request.getfixturevalue("arg2")
return request.cached_setup(lambda: arg1 + 1)
@pytest.fixture
def arg2(request):
return request.cached_setup(lambda: 10)
def test_two_funcarg(arg1):
assert arg1 == 11
"""
)
result = testdir.runpytest("-v", SHOW_PYTEST_WARNINGS_ARG)
result.stdout.fnmatch_lines(["*1 passed*"])
def test_request_cached_setup_functional(self, testdir):
testdir.makepyfile(
test_0="""
import pytest
values = []
@pytest.fixture
def something(request):
val = request.cached_setup(fsetup, fteardown)
return val
def fsetup(mycache=[1]):
values.append(mycache.pop())
return values
def fteardown(something):
values.remove(something[0])
values.append(2)
def test_list_once(something):
assert something == [1]
def test_list_twice(something):
assert something == [1]
"""
)
testdir.makepyfile(
test_1="""
import test_0 # should have run already
def test_check_test0_has_teardown_correct():
assert test_0.values == [2]
"""
)
result = testdir.runpytest("-v", SHOW_PYTEST_WARNINGS_ARG)
result.stdout.fnmatch_lines(["*3 passed*"])
def test_issue117_sessionscopeteardown(self, testdir):
testdir.makepyfile(
"""
import pytest
@pytest.fixture
def app(request):
app = request.cached_setup(
scope='session',
setup=lambda: 0,
teardown=lambda x: 3/x)
return app
def test_func(app):
pass
"""
)
result = testdir.runpytest(SHOW_PYTEST_WARNINGS_ARG)
assert result.ret != 0
result.stdout.fnmatch_lines(["*3/x*", "*ZeroDivisionError*"])
class TestFixtureUsages(object):
def test_noargfixturedec(self, testdir):
testdir.makepyfile(
"""
import pytest
@pytest.fixture
def arg1():
return 1
def test_func(arg1):
assert arg1 == 1
"""
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=1)
def test_receives_funcargs(self, testdir):
testdir.makepyfile(
"""
import pytest
@pytest.fixture()
def arg1():
return 1
@pytest.fixture()
def arg2(arg1):
return arg1 + 1
def test_add(arg2):
assert arg2 == 2
def test_all(arg1, arg2):
assert arg1 == 1
assert arg2 == 2
"""
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=2)
def test_receives_funcargs_scope_mismatch(self, testdir):
testdir.makepyfile(
"""
import pytest
@pytest.fixture(scope="function")
def arg1():
return 1
@pytest.fixture(scope="module")
def arg2(arg1):
return arg1 + 1
def test_add(arg2):
assert arg2 == 2
"""
)
result = testdir.runpytest()
result.stdout.fnmatch_lines(
[
"*ScopeMismatch*involved factories*",
"* def arg2*",
"* def arg1*",
"*1 error*",
]
)
def test_receives_funcargs_scope_mismatch_issue660(self, testdir):
testdir.makepyfile(
"""
import pytest
@pytest.fixture(scope="function")
def arg1():
return 1
@pytest.fixture(scope="module")
def arg2(arg1):
return arg1 + 1
def test_add(arg1, arg2):
assert arg2 == 2
"""
)
result = testdir.runpytest()
result.stdout.fnmatch_lines(
["*ScopeMismatch*involved factories*", "* def arg2*", "*1 error*"]
)
def test_invalid_scope(self, testdir):
testdir.makepyfile(
"""
import pytest
@pytest.fixture(scope="functions")
def badscope():
pass
def test_nothing(badscope):
pass
"""
)
result = testdir.runpytest_inprocess()
result.stdout.fnmatch_lines(
(
"*Fixture 'badscope' from test_invalid_scope.py got an unexpected scope value 'functions'"
)
)
def test_funcarg_parametrized_and_used_twice(self, testdir):
testdir.makepyfile(
"""
import pytest
values = []
@pytest.fixture(params=[1,2])
def arg1(request):
values.append(1)
return request.param
@pytest.fixture()
def arg2(arg1):
return arg1 + 1
def test_add(arg1, arg2):
assert arg2 == arg1 + 1
assert len(values) == arg1
"""
)
result = testdir.runpytest()
result.stdout.fnmatch_lines(["*2 passed*"])
def test_factory_uses_unknown_funcarg_as_dependency_error(self, testdir):
testdir.makepyfile(
"""
import pytest
@pytest.fixture()
def fail(missing):
return
@pytest.fixture()
def call_fail(fail):
return
def test_missing(call_fail):
pass
"""
)
result = testdir.runpytest()
result.stdout.fnmatch_lines(
"""
*pytest.fixture()*
*def call_fail(fail)*
*pytest.fixture()*
*def fail*
*fixture*'missing'*not found*
"""
)
def test_factory_setup_as_classes_fails(self, testdir):
testdir.makepyfile(
"""
import pytest
class arg1(object):
def __init__(self, request):
self.x = 1
arg1 = pytest.fixture()(arg1)
"""
)
reprec = testdir.inline_run()
values = reprec.getfailedcollections()
assert len(values) == 1
def test_request_can_be_overridden(self, testdir):
testdir.makepyfile(
"""
import pytest
@pytest.fixture()
def request(request):
request.a = 1
return request
def test_request(request):
assert request.a == 1
"""
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=1)
def test_usefixtures_marker(self, testdir):
testdir.makepyfile(
"""
import pytest
values = []
@pytest.fixture(scope="class")
def myfix(request):
request.cls.hello = "world"
values.append(1)
class TestClass(object):
def test_one(self):
assert self.hello == "world"
assert len(values) == 1
def test_two(self):
assert self.hello == "world"
assert len(values) == 1
pytest.mark.usefixtures("myfix")(TestClass)
"""
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=2)
def test_usefixtures_ini(self, testdir):
testdir.makeini(
"""
[pytest]
usefixtures = myfix
"""
)
testdir.makeconftest(
"""
import pytest
@pytest.fixture(scope="class")
def myfix(request):
request.cls.hello = "world"
"""
)
testdir.makepyfile(
"""
class TestClass(object):
def test_one(self):
assert self.hello == "world"
def test_two(self):
assert self.hello == "world"
"""
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=2)
def test_usefixtures_seen_in_showmarkers(self, testdir):
result = testdir.runpytest("--markers")
result.stdout.fnmatch_lines(
"""
*usefixtures(fixturename1*mark tests*fixtures*
"""
)
def test_request_instance_issue203(self, testdir):
testdir.makepyfile(
"""
import pytest
class TestClass(object):
@pytest.fixture
def setup1(self, request):
assert self == request.instance
self.arg1 = 1
def test_hello(self, setup1):
assert self.arg1 == 1
"""
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=1)
def test_fixture_parametrized_with_iterator(self, testdir):
testdir.makepyfile(
"""
import pytest
values = []
def f():
yield 1
yield 2
dec = pytest.fixture(scope="module", params=f())
@dec
def arg(request):
return request.param
@dec
def arg2(request):
return request.param
def test_1(arg):
values.append(arg)
def test_2(arg2):
values.append(arg2*10)
"""
)
reprec = testdir.inline_run("-v")
reprec.assertoutcome(passed=4)
values = reprec.getcalls("pytest_runtest_call")[0].item.module.values
assert values == [1, 2, 10, 20]
class TestFixtureManagerParseFactories(object):
@pytest.fixture
def testdir(self, request):
testdir = request.getfixturevalue("testdir")
testdir.makeconftest(
"""
import pytest
@pytest.fixture
def hello(request):
return "conftest"
@pytest.fixture
def fm(request):
return request._fixturemanager
@pytest.fixture
def item(request):
return request._pyfuncitem
"""
)
return testdir
def test_parsefactories_evil_objects_issue214(self, testdir):
testdir.makepyfile(
"""
class A(object):
def __call__(self):
pass
def __getattr__(self, name):
raise RuntimeError()
a = A()
def test_hello():
pass
"""
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=1, failed=0)
def test_parsefactories_conftest(self, testdir):
testdir.makepyfile(
"""
def test_hello(item, fm):
for name in ("fm", "hello", "item"):
faclist = fm.getfixturedefs(name, item.nodeid)
assert len(faclist) == 1
fac = faclist[0]
assert fac.func.__name__ == name
"""
)
reprec = testdir.inline_run("-s")
reprec.assertoutcome(passed=1)
def test_parsefactories_conftest_and_module_and_class(self, testdir):
testdir.makepyfile(
"""
import pytest
import six
@pytest.fixture
def hello(request):
return "module"
class TestClass(object):
@pytest.fixture
def hello(self, request):
return "class"
def test_hello(self, item, fm):
faclist = fm.getfixturedefs("hello", item.nodeid)
print (faclist)
assert len(faclist) == 3
assert faclist[0].func(item._request) == "conftest"
assert faclist[1].func(item._request) == "module"
assert faclist[2].func(item._request) == "class"
"""
)
reprec = testdir.inline_run("-s")
reprec.assertoutcome(passed=1)
def test_parsefactories_relative_node_ids(self, testdir):
# example mostly taken from:
# https://mail.python.org/pipermail/pytest-dev/2014-September/002617.html
runner = testdir.mkdir("runner")
package = testdir.mkdir("package")
package.join("conftest.py").write(
textwrap.dedent(
"""\
import pytest
@pytest.fixture
def one():
return 1
"""
)
)
package.join("test_x.py").write(
textwrap.dedent(
"""\
def test_x(one):
assert one == 1
"""
)
)
sub = package.mkdir("sub")
sub.join("__init__.py").ensure()
sub.join("conftest.py").write(
textwrap.dedent(
"""\
import pytest
@pytest.fixture
def one():
return 2
"""
)
)
sub.join("test_y.py").write(
textwrap.dedent(
"""\
def test_x(one):
assert one == 2
"""
)
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=2)
with runner.as_cwd():
reprec = testdir.inline_run("..")
reprec.assertoutcome(passed=2)
def test_package_xunit_fixture(self, testdir):
testdir.makepyfile(
__init__="""\
values = []
"""
)
package = testdir.mkdir("package")
package.join("__init__.py").write(
textwrap.dedent(
"""\
from .. import values
def setup_module():
values.append("package")
def teardown_module():
values[:] = []
"""
)
)
package.join("test_x.py").write(
textwrap.dedent(
"""\
from .. import values
def test_x():
assert values == ["package"]
"""
)
)
package = testdir.mkdir("package2")
package.join("__init__.py").write(
textwrap.dedent(
"""\
from .. import values
def setup_module():
values.append("package2")
def teardown_module():
values[:] = []
"""
)
)
package.join("test_x.py").write(
textwrap.dedent(
"""\
from .. import values
def test_x():
assert values == ["package2"]
"""
)
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=2)
def test_package_fixture_complex(self, testdir):
testdir.makepyfile(
__init__="""\
values = []
"""
)
testdir.syspathinsert(testdir.tmpdir.dirname)
package = testdir.mkdir("package")
package.join("__init__.py").write("")
package.join("conftest.py").write(
textwrap.dedent(
"""\
import pytest
from .. import values
@pytest.fixture(scope="package")
def one():
values.append("package")
yield values
values.pop()
@pytest.fixture(scope="package", autouse=True)
def two():
values.append("package-auto")
yield values
values.pop()
"""
)
)
package.join("test_x.py").write(
textwrap.dedent(
"""\
from .. import values
def test_package_autouse():
assert values == ["package-auto"]
def test_package(one):
assert values == ["package-auto", "package"]
"""
)
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=2)
def test_collect_custom_items(self, testdir):
testdir.copy_example("fixtures/custom_item")
result = testdir.runpytest("foo")
result.stdout.fnmatch_lines("*passed*")
class TestAutouseDiscovery(object):
@pytest.fixture
def testdir(self, testdir):
testdir.makeconftest(
"""
import pytest
@pytest.fixture(autouse=True)
def perfunction(request, tmpdir):
pass
@pytest.fixture()
def arg1(tmpdir):
pass
@pytest.fixture(autouse=True)
def perfunction2(arg1):
pass
@pytest.fixture
def fm(request):
return request._fixturemanager
@pytest.fixture
def item(request):
return request._pyfuncitem
"""
)
return testdir
def test_parsefactories_conftest(self, testdir):
testdir.makepyfile(
"""
from _pytest.pytester import get_public_names
def test_check_setup(item, fm):
autousenames = fm._getautousenames(item.nodeid)
assert len(get_public_names(autousenames)) == 2
assert "perfunction2" in autousenames
assert "perfunction" in autousenames
"""
)
reprec = testdir.inline_run("-s")
reprec.assertoutcome(passed=1)
def test_two_classes_separated_autouse(self, testdir):
testdir.makepyfile(
"""
import pytest
class TestA(object):
values = []
@pytest.fixture(autouse=True)
def setup1(self):
self.values.append(1)
def test_setup1(self):
assert self.values == [1]
class TestB(object):
values = []
@pytest.fixture(autouse=True)
def setup2(self):
self.values.append(1)
def test_setup2(self):
assert self.values == [1]
"""
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=2)
def test_setup_at_classlevel(self, testdir):
testdir.makepyfile(
"""
import pytest
class TestClass(object):
@pytest.fixture(autouse=True)
def permethod(self, request):
request.instance.funcname = request.function.__name__
def test_method1(self):
assert self.funcname == "test_method1"
def test_method2(self):
assert self.funcname == "test_method2"
"""
)
reprec = testdir.inline_run("-s")
reprec.assertoutcome(passed=2)
@pytest.mark.xfail(reason="'enabled' feature not implemented")
def test_setup_enabled_functionnode(self, testdir):
testdir.makepyfile(
"""
import pytest
def enabled(parentnode, markers):
return "needsdb" in markers
@pytest.fixture(params=[1,2])
def db(request):
return request.param
@pytest.fixture(enabled=enabled, autouse=True)
def createdb(db):
pass
def test_func1(request):
assert "db" not in request.fixturenames
@pytest.mark.needsdb
def test_func2(request):
assert "db" in request.fixturenames
"""
)
reprec = testdir.inline_run("-s")
reprec.assertoutcome(passed=2)
def test_callables_nocode(self, testdir):
"""
an imported mock.call would break setup/factory discovery
due to it being callable and __code__ not being a code object
"""
testdir.makepyfile(
"""
class _call(tuple):
def __call__(self, *k, **kw):
pass
def __getattr__(self, k):
return self
call = _call()
"""
)
reprec = testdir.inline_run("-s")
reprec.assertoutcome(failed=0, passed=0)
def test_autouse_in_conftests(self, testdir):
a = testdir.mkdir("a")
b = testdir.mkdir("a1")
conftest = testdir.makeconftest(
"""
import pytest
@pytest.fixture(autouse=True)
def hello():
xxx
"""
)
conftest.move(a.join(conftest.basename))
a.join("test_something.py").write("def test_func(): pass")
b.join("test_otherthing.py").write("def test_func(): pass")
result = testdir.runpytest()
result.stdout.fnmatch_lines(
"""
*1 passed*1 error*
"""
)
def test_autouse_in_module_and_two_classes(self, testdir):
testdir.makepyfile(
"""
import pytest
values = []
@pytest.fixture(autouse=True)
def append1():
values.append("module")
def test_x():
assert values == ["module"]
class TestA(object):
@pytest.fixture(autouse=True)
def append2(self):
values.append("A")
def test_hello(self):
assert values == ["module", "module", "A"], values
class TestA2(object):
def test_world(self):
assert values == ["module", "module", "A", "module"], values
"""
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=3)
class TestAutouseManagement(object):
def test_autouse_conftest_mid_directory(self, testdir):
pkgdir = testdir.mkpydir("xyz123")
pkgdir.join("conftest.py").write(
textwrap.dedent(
"""\
import pytest
@pytest.fixture(autouse=True)
def app():
import sys
sys._myapp = "hello"
"""
)
)
t = pkgdir.ensure("tests", "test_app.py")
t.write(
textwrap.dedent(
"""\
import sys
def test_app():
assert sys._myapp == "hello"
"""
)
)
reprec = testdir.inline_run("-s")
reprec.assertoutcome(passed=1)
def test_autouse_honored_for_yield(self, testdir):
testdir.makepyfile(
"""
import pytest
@pytest.fixture(autouse=True)
def tst():
global x
x = 3
def test_gen():
def f(hello):
assert x == abs(hello)
yield f, 3
yield f, -3
"""
)
reprec = testdir.inline_run(SHOW_PYTEST_WARNINGS_ARG)
reprec.assertoutcome(passed=2)
def test_funcarg_and_setup(self, testdir):
testdir.makepyfile(
"""
import pytest
values = []
@pytest.fixture(scope="module")
def arg():
values.append(1)
return 0
@pytest.fixture(scope="module", autouse=True)
def something(arg):
values.append(2)
def test_hello(arg):
assert len(values) == 2
assert values == [1,2]
assert arg == 0
def test_hello2(arg):
assert len(values) == 2
assert values == [1,2]
assert arg == 0
"""
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=2)
def test_uses_parametrized_resource(self, testdir):
testdir.makepyfile(
"""
import pytest
values = []
@pytest.fixture(params=[1,2])
def arg(request):
return request.param
@pytest.fixture(autouse=True)
def something(arg):
values.append(arg)
def test_hello():
if len(values) == 1:
assert values == [1]
elif len(values) == 2:
assert values == [1, 2]
else:
0/0
"""
)
reprec = testdir.inline_run("-s")
reprec.assertoutcome(passed=2)
def test_session_parametrized_function(self, testdir):
testdir.makepyfile(
"""
import pytest
values = []
@pytest.fixture(scope="session", params=[1,2])
def arg(request):
return request.param
@pytest.fixture(scope="function", autouse=True)
def append(request, arg):
if request.function.__name__ == "test_some":
values.append(arg)
def test_some():
pass
def test_result(arg):
assert len(values) == arg
assert values[:arg] == [1,2][:arg]
"""
)
reprec = testdir.inline_run("-v", "-s")
reprec.assertoutcome(passed=4)
def test_class_function_parametrization_finalization(self, testdir):
p = testdir.makeconftest(
"""
import pytest
import pprint
values = []
@pytest.fixture(scope="function", params=[1,2])
def farg(request):
return request.param
@pytest.fixture(scope="class", params=list("ab"))
def carg(request):
return request.param
@pytest.fixture(scope="function", autouse=True)
def append(request, farg, carg):
def fin():
values.append("fin_%s%s" % (carg, farg))
request.addfinalizer(fin)
"""
)
testdir.makepyfile(
"""
import pytest
class TestClass(object):
def test_1(self):
pass
class TestClass2(object):
def test_2(self):
pass
"""
)
confcut = "--confcutdir={}".format(testdir.tmpdir)
reprec = testdir.inline_run("-v", "-s", confcut)
reprec.assertoutcome(passed=8)
config = reprec.getcalls("pytest_unconfigure")[0].config
values = config.pluginmanager._getconftestmodules(p)[0].values
assert values == ["fin_a1", "fin_a2", "fin_b1", "fin_b2"] * 2
def test_scope_ordering(self, testdir):
testdir.makepyfile(
"""
import pytest
values = []
@pytest.fixture(scope="function", autouse=True)
def fappend2():
values.append(2)
@pytest.fixture(scope="class", autouse=True)
def classappend3():
values.append(3)
@pytest.fixture(scope="module", autouse=True)
def mappend():
values.append(1)
class TestHallo(object):
def test_method(self):
assert values == [1,3,2]
"""
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=1)
def test_parametrization_setup_teardown_ordering(self, testdir):
testdir.makepyfile(
"""
import pytest
values = []
def pytest_generate_tests(metafunc):
if metafunc.cls is None:
assert metafunc.function is test_finish
if metafunc.cls is not None:
metafunc.parametrize("item", [1,2], scope="class")
class TestClass(object):
@pytest.fixture(scope="class", autouse=True)
def addteardown(self, item, request):
values.append("setup-%d" % item)
request.addfinalizer(lambda: values.append("teardown-%d" % item))
def test_step1(self, item):
values.append("step1-%d" % item)
def test_step2(self, item):
values.append("step2-%d" % item)
def test_finish():
print (values)
assert values == ["setup-1", "step1-1", "step2-1", "teardown-1",
"setup-2", "step1-2", "step2-2", "teardown-2",]
"""
)
reprec = testdir.inline_run("-s")
reprec.assertoutcome(passed=5)
def test_ordering_autouse_before_explicit(self, testdir):
testdir.makepyfile(
"""
import pytest
values = []
@pytest.fixture(autouse=True)
def fix1():
values.append(1)
@pytest.fixture()
def arg1():
values.append(2)
def test_hello(arg1):
assert values == [1,2]
"""
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=1)
@pytest.mark.issue226
@pytest.mark.parametrize("param1", ["", "params=[1]"], ids=["p00", "p01"])
@pytest.mark.parametrize("param2", ["", "params=[1]"], ids=["p10", "p11"])
def test_ordering_dependencies_torndown_first(self, testdir, param1, param2):
testdir.makepyfile(
"""
import pytest
values = []
@pytest.fixture(%(param1)s)
def arg1(request):
request.addfinalizer(lambda: values.append("fin1"))
values.append("new1")
@pytest.fixture(%(param2)s)
def arg2(request, arg1):
request.addfinalizer(lambda: values.append("fin2"))
values.append("new2")
def test_arg(arg2):
pass
def test_check():
assert values == ["new1", "new2", "fin2", "fin1"]
"""
% locals()
)
reprec = testdir.inline_run("-s")
reprec.assertoutcome(passed=2)
class TestFixtureMarker(object):
def test_parametrize(self, testdir):
testdir.makepyfile(
"""
import pytest
@pytest.fixture(params=["a", "b", "c"])
def arg(request):
return request.param
values = []
def test_param(arg):
values.append(arg)
def test_result():
assert values == list("abc")
"""
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=4)
def test_multiple_parametrization_issue_736(self, testdir):
testdir.makepyfile(
"""
import pytest
@pytest.fixture(params=[1,2,3])
def foo(request):
return request.param
@pytest.mark.parametrize('foobar', [4,5,6])
def test_issue(foo, foobar):
assert foo in [1,2,3]
assert foobar in [4,5,6]
"""
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=9)
@pytest.mark.parametrize(
"param_args",
["'fixt, val'", "'fixt,val'", "['fixt', 'val']", "('fixt', 'val')"],
)
def test_override_parametrized_fixture_issue_979(self, testdir, param_args):
"""Make sure a parametrized argument can override a parametrized fixture.
This was a regression introduced in the fix for #736.
"""
testdir.makepyfile(
"""
import pytest
@pytest.fixture(params=[1, 2])
def fixt(request):
return request.param
@pytest.mark.parametrize(%s, [(3, 'x'), (4, 'x')])
def test_foo(fixt, val):
pass
"""
% param_args
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=2)
def test_scope_session(self, testdir):
testdir.makepyfile(
"""
import pytest
values = []
@pytest.fixture(scope="module")
def arg():
values.append(1)
return 1
def test_1(arg):
assert arg == 1
def test_2(arg):
assert arg == 1
assert len(values) == 1
class TestClass(object):
def test3(self, arg):
assert arg == 1
assert len(values) == 1
"""
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=3)
def test_scope_session_exc(self, testdir):
testdir.makepyfile(
"""
import pytest
values = []
@pytest.fixture(scope="session")
def fix():
values.append(1)
pytest.skip('skipping')
def test_1(fix):
pass
def test_2(fix):
pass
def test_last():
assert values == [1]
"""
)
reprec = testdir.inline_run()
reprec.assertoutcome(skipped=2, passed=1)
def test_scope_session_exc_two_fix(self, testdir):
testdir.makepyfile(
"""
import pytest
values = []
m = []
@pytest.fixture(scope="session")
def a():
values.append(1)
pytest.skip('skipping')
@pytest.fixture(scope="session")
def b(a):
m.append(1)
def test_1(b):
pass
def test_2(b):
pass
def test_last():
assert values == [1]
assert m == []
"""
)
reprec = testdir.inline_run()
reprec.assertoutcome(skipped=2, passed=1)
def test_scope_exc(self, testdir):
testdir.makepyfile(
test_foo="""
def test_foo(fix):
pass
""",
test_bar="""
def test_bar(fix):
pass
""",
conftest="""
import pytest
reqs = []
@pytest.fixture(scope="session")
def fix(request):
reqs.append(1)
pytest.skip()
@pytest.fixture
def req_list():
return reqs
""",
test_real="""
def test_last(req_list):
assert req_list == [1]
""",
)
reprec = testdir.inline_run()
reprec.assertoutcome(skipped=2, passed=1)
def test_scope_module_uses_session(self, testdir):
testdir.makepyfile(
"""
import pytest
values = []
@pytest.fixture(scope="module")
def arg():
values.append(1)
return 1
def test_1(arg):
assert arg == 1
def test_2(arg):
assert arg == 1
assert len(values) == 1
class TestClass(object):
def test3(self, arg):
assert arg == 1
assert len(values) == 1
"""
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=3)
def test_scope_module_and_finalizer(self, testdir):
testdir.makeconftest(
"""
import pytest
finalized_list = []
created_list = []
@pytest.fixture(scope="module")
def arg(request):
created_list.append(1)
assert request.scope == "module"
request.addfinalizer(lambda: finalized_list.append(1))
@pytest.fixture
def created(request):
return len(created_list)
@pytest.fixture
def finalized(request):
return len(finalized_list)
"""
)
testdir.makepyfile(
test_mod1="""
def test_1(arg, created, finalized):
assert created == 1
assert finalized == 0
def test_2(arg, created, finalized):
assert created == 1
assert finalized == 0""",
test_mod2="""
def test_3(arg, created, finalized):
assert created == 2
assert finalized == 1""",
test_mode3="""
def test_4(arg, created, finalized):
assert created == 3
assert finalized == 2
""",
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=4)
@pytest.mark.parametrize(
"method",
[
'request.getfixturevalue("arg")',
'request.cached_setup(lambda: None, scope="function")',
],
ids=["getfixturevalue", "cached_setup"],
)
def test_scope_mismatch_various(self, testdir, method):
testdir.makeconftest(
"""
import pytest
finalized = []
created = []
@pytest.fixture(scope="function")
def arg(request):
pass
"""
)
testdir.makepyfile(
test_mod1="""
import pytest
@pytest.fixture(scope="session")
def arg(request):
%s
def test_1(arg):
pass
"""
% method
)
result = testdir.runpytest(SHOW_PYTEST_WARNINGS_ARG)
assert result.ret != 0
result.stdout.fnmatch_lines(
["*ScopeMismatch*You tried*function*session*request*"]
)
def test_register_only_with_mark(self, testdir):
testdir.makeconftest(
"""
import pytest
@pytest.fixture()
def arg():
return 1
"""
)
testdir.makepyfile(
test_mod1="""
import pytest
@pytest.fixture()
def arg(arg):
return arg + 1
def test_1(arg):
assert arg == 2
"""
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=1)
def test_parametrize_and_scope(self, testdir):
testdir.makepyfile(
"""
import pytest
@pytest.fixture(scope="module", params=["a", "b", "c"])
def arg(request):
return request.param
values = []
def test_param(arg):
values.append(arg)
"""
)
reprec = testdir.inline_run("-v")
reprec.assertoutcome(passed=3)
values = reprec.getcalls("pytest_runtest_call")[0].item.module.values
assert len(values) == 3
assert "a" in values
assert "b" in values
assert "c" in values
def test_scope_mismatch(self, testdir):
testdir.makeconftest(
"""
import pytest
@pytest.fixture(scope="function")
def arg(request):
pass
"""
)
testdir.makepyfile(
"""
import pytest
@pytest.fixture(scope="session")
def arg(arg):
pass
def test_mismatch(arg):
pass
"""
)
result = testdir.runpytest()
result.stdout.fnmatch_lines(["*ScopeMismatch*", "*1 error*"])
def test_parametrize_separated_order(self, testdir):
testdir.makepyfile(
"""
import pytest
@pytest.fixture(scope="module", params=[1, 2])
def arg(request):
return request.param
values = []
def test_1(arg):
values.append(arg)
def test_2(arg):
values.append(arg)
"""
)
reprec = testdir.inline_run("-v")
reprec.assertoutcome(passed=4)
values = reprec.getcalls("pytest_runtest_call")[0].item.module.values
assert values == [1, 1, 2, 2]
def test_module_parametrized_ordering(self, testdir):
testdir.makeini(
"""
[pytest]
console_output_style=classic
"""
)
testdir.makeconftest(
"""
import pytest
@pytest.fixture(scope="session", params="s1 s2".split())
def sarg():
pass
@pytest.fixture(scope="module", params="m1 m2".split())
def marg():
pass
"""
)
testdir.makepyfile(
test_mod1="""
def test_func(sarg):
pass
def test_func1(marg):
pass
""",
test_mod2="""
def test_func2(sarg):
pass
def test_func3(sarg, marg):
pass
def test_func3b(sarg, marg):
pass
def test_func4(marg):
pass
""",
)
result = testdir.runpytest("-v")
result.stdout.fnmatch_lines(
"""
test_mod1.py::test_func[s1] PASSED
test_mod2.py::test_func2[s1] PASSED
test_mod2.py::test_func3[s1-m1] PASSED
test_mod2.py::test_func3b[s1-m1] PASSED
test_mod2.py::test_func3[s1-m2] PASSED
test_mod2.py::test_func3b[s1-m2] PASSED
test_mod1.py::test_func[s2] PASSED
test_mod2.py::test_func2[s2] PASSED
test_mod2.py::test_func3[s2-m1] PASSED
test_mod2.py::test_func3b[s2-m1] PASSED
test_mod2.py::test_func4[m1] PASSED
test_mod2.py::test_func3[s2-m2] PASSED
test_mod2.py::test_func3b[s2-m2] PASSED
test_mod2.py::test_func4[m2] PASSED
test_mod1.py::test_func1[m1] PASSED
test_mod1.py::test_func1[m2] PASSED
"""
)
def test_dynamic_parametrized_ordering(self, testdir):
testdir.makeini(
"""
[pytest]
console_output_style=classic
"""
)
testdir.makeconftest(
"""
import pytest
def pytest_configure(config):
class DynamicFixturePlugin(object):
@pytest.fixture(scope='session', params=['flavor1', 'flavor2'])
def flavor(self, request):
return request.param
config.pluginmanager.register(DynamicFixturePlugin(), 'flavor-fixture')
@pytest.fixture(scope='session', params=['vxlan', 'vlan'])
def encap(request):
return request.param
@pytest.fixture(scope='session', autouse='True')
def reprovision(request, flavor, encap):
pass
"""
)
testdir.makepyfile(
"""
def test(reprovision):
pass
def test2(reprovision):
pass
"""
)
result = testdir.runpytest("-v")
result.stdout.fnmatch_lines(
"""
test_dynamic_parametrized_ordering.py::test[flavor1-vxlan] PASSED
test_dynamic_parametrized_ordering.py::test2[flavor1-vxlan] PASSED
test_dynamic_parametrized_ordering.py::test[flavor2-vxlan] PASSED
test_dynamic_parametrized_ordering.py::test2[flavor2-vxlan] PASSED
test_dynamic_parametrized_ordering.py::test[flavor2-vlan] PASSED
test_dynamic_parametrized_ordering.py::test2[flavor2-vlan] PASSED
test_dynamic_parametrized_ordering.py::test[flavor1-vlan] PASSED
test_dynamic_parametrized_ordering.py::test2[flavor1-vlan] PASSED
"""
)
def test_class_ordering(self, testdir):
testdir.makeini(
"""
[pytest]
console_output_style=classic
"""
)
testdir.makeconftest(
"""
import pytest
values = []
@pytest.fixture(scope="function", params=[1,2])
def farg(request):
return request.param
@pytest.fixture(scope="class", params=list("ab"))
def carg(request):
return request.param
@pytest.fixture(scope="function", autouse=True)
def append(request, farg, carg):
def fin():
values.append("fin_%s%s" % (carg, farg))
request.addfinalizer(fin)
"""
)
testdir.makepyfile(
"""
import pytest
class TestClass2(object):
def test_1(self):
pass
def test_2(self):
pass
class TestClass(object):
def test_3(self):
pass
"""
)
result = testdir.runpytest("-vs")
result.stdout.re_match_lines(
r"""
test_class_ordering.py::TestClass2::test_1\[a-1\] PASSED
test_class_ordering.py::TestClass2::test_1\[a-2\] PASSED
test_class_ordering.py::TestClass2::test_2\[a-1\] PASSED
test_class_ordering.py::TestClass2::test_2\[a-2\] PASSED
test_class_ordering.py::TestClass2::test_1\[b-1\] PASSED
test_class_ordering.py::TestClass2::test_1\[b-2\] PASSED
test_class_ordering.py::TestClass2::test_2\[b-1\] PASSED
test_class_ordering.py::TestClass2::test_2\[b-2\] PASSED
test_class_ordering.py::TestClass::test_3\[a-1\] PASSED
test_class_ordering.py::TestClass::test_3\[a-2\] PASSED
test_class_ordering.py::TestClass::test_3\[b-1\] PASSED
test_class_ordering.py::TestClass::test_3\[b-2\] PASSED
"""
)
def test_parametrize_separated_order_higher_scope_first(self, testdir):
testdir.makepyfile(
"""
import pytest
@pytest.fixture(scope="function", params=[1, 2])
def arg(request):
param = request.param
request.addfinalizer(lambda: values.append("fin:%s" % param))
values.append("create:%s" % param)
return request.param
@pytest.fixture(scope="module", params=["mod1", "mod2"])
def modarg(request):
param = request.param
request.addfinalizer(lambda: values.append("fin:%s" % param))
values.append("create:%s" % param)
return request.param
values = []
def test_1(arg):
values.append("test1")
def test_2(modarg):
values.append("test2")
def test_3(arg, modarg):
values.append("test3")
def test_4(modarg, arg):
values.append("test4")
"""
)
reprec = testdir.inline_run("-v")
reprec.assertoutcome(passed=12)
values = reprec.getcalls("pytest_runtest_call")[0].item.module.values
expected = [
"create:1",
"test1",
"fin:1",
"create:2",
"test1",
"fin:2",
"create:mod1",
"test2",
"create:1",
"test3",
"fin:1",
"create:2",
"test3",
"fin:2",
"create:1",
"test4",
"fin:1",
"create:2",
"test4",
"fin:2",
"fin:mod1",
"create:mod2",
"test2",
"create:1",
"test3",
"fin:1",
"create:2",
"test3",
"fin:2",
"create:1",
"test4",
"fin:1",
"create:2",
"test4",
"fin:2",
"fin:mod2",
]
import pprint
pprint.pprint(list(zip(values, expected)))
assert values == expected
def test_parametrized_fixture_teardown_order(self, testdir):
testdir.makepyfile(
"""
import pytest
@pytest.fixture(params=[1,2], scope="class")
def param1(request):
return request.param
values = []
class TestClass(object):
@classmethod
@pytest.fixture(scope="class", autouse=True)
def setup1(self, request, param1):
values.append(1)
request.addfinalizer(self.teardown1)
@classmethod
def teardown1(self):
assert values.pop() == 1
@pytest.fixture(scope="class", autouse=True)
def setup2(self, request, param1):
values.append(2)
request.addfinalizer(self.teardown2)
@classmethod
def teardown2(self):
assert values.pop() == 2
def test(self):
pass
def test_finish():
assert not values
"""
)
result = testdir.runpytest("-v")
result.stdout.fnmatch_lines(
"""
*3 passed*
"""
)
assert "error" not in result.stdout.str()
def test_fixture_finalizer(self, testdir):
testdir.makeconftest(
"""
import pytest
import sys
@pytest.fixture
def browser(request):
def finalize():
sys.stdout.write('Finalized')
request.addfinalizer(finalize)
return {}
"""
)
b = testdir.mkdir("subdir")
b.join("test_overridden_fixture_finalizer.py").write(
textwrap.dedent(
"""\
import pytest
@pytest.fixture
def browser(browser):
browser['visited'] = True
return browser
def test_browser(browser):
assert browser['visited'] is True
"""
)
)
reprec = testdir.runpytest("-s")
for test in ["test_browser"]:
reprec.stdout.fnmatch_lines("*Finalized*")
def test_class_scope_with_normal_tests(self, testdir):
testpath = testdir.makepyfile(
"""
import pytest
class Box(object):
value = 0
@pytest.fixture(scope='class')
def a(request):
Box.value += 1
return Box.value
def test_a(a):
assert a == 1
class Test1(object):
def test_b(self, a):
assert a == 2
class Test2(object):
def test_c(self, a):
assert a == 3"""
)
reprec = testdir.inline_run(testpath)
for test in ["test_a", "test_b", "test_c"]:
assert reprec.matchreport(test).passed
def test_request_is_clean(self, testdir):
testdir.makepyfile(
"""
import pytest
values = []
@pytest.fixture(params=[1, 2])
def fix(request):
request.addfinalizer(lambda: values.append(request.param))
def test_fix(fix):
pass
"""
)
reprec = testdir.inline_run("-s")
values = reprec.getcalls("pytest_runtest_call")[0].item.module.values
assert values == [1, 2]
def test_parametrize_separated_lifecycle(self, testdir):
testdir.makepyfile(
"""
import pytest
values = []
@pytest.fixture(scope="module", params=[1, 2])
def arg(request):
x = request.param
request.addfinalizer(lambda: values.append("fin%s" % x))
return request.param
def test_1(arg):
values.append(arg)
def test_2(arg):
values.append(arg)
"""
)
reprec = testdir.inline_run("-vs")
reprec.assertoutcome(passed=4)
values = reprec.getcalls("pytest_runtest_call")[0].item.module.values
import pprint
pprint.pprint(values)
# assert len(values) == 6
assert values[0] == values[1] == 1
assert values[2] == "fin1"
assert values[3] == values[4] == 2
assert values[5] == "fin2"
def test_parametrize_function_scoped_finalizers_called(self, testdir):
testdir.makepyfile(
"""
import pytest
@pytest.fixture(scope="function", params=[1, 2])
def arg(request):
x = request.param
request.addfinalizer(lambda: values.append("fin%s" % x))
return request.param
values = []
def test_1(arg):
values.append(arg)
def test_2(arg):
values.append(arg)
def test_3():
assert len(values) == 8
assert values == [1, "fin1", 2, "fin2", 1, "fin1", 2, "fin2"]
"""
)
reprec = testdir.inline_run("-v")
reprec.assertoutcome(passed=5)
@pytest.mark.issue246
@pytest.mark.parametrize("scope", ["session", "function", "module"])
def test_finalizer_order_on_parametrization(self, scope, testdir):
testdir.makepyfile(
"""
import pytest
values = []
@pytest.fixture(scope=%(scope)r, params=["1"])
def fix1(request):
return request.param
@pytest.fixture(scope=%(scope)r)
def fix2(request, base):
def cleanup_fix2():
assert not values, "base should not have been finalized"
request.addfinalizer(cleanup_fix2)
@pytest.fixture(scope=%(scope)r)
def base(request, fix1):
def cleanup_base():
values.append("fin_base")
print ("finalizing base")
request.addfinalizer(cleanup_base)
def test_begin():
pass
def test_baz(base, fix2):
pass
def test_other():
pass
"""
% {"scope": scope}
)
reprec = testdir.inline_run("-lvs")
reprec.assertoutcome(passed=3)
@pytest.mark.issue396
def test_class_scope_parametrization_ordering(self, testdir):
testdir.makepyfile(
"""
import pytest
values = []
@pytest.fixture(params=["John", "Doe"], scope="class")
def human(request):
request.addfinalizer(lambda: values.append("fin %s" % request.param))
return request.param
class TestGreetings(object):
def test_hello(self, human):
values.append("test_hello")
class TestMetrics(object):
def test_name(self, human):
values.append("test_name")
def test_population(self, human):
values.append("test_population")
"""
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=6)
values = reprec.getcalls("pytest_runtest_call")[0].item.module.values
assert values == [
"test_hello",
"fin John",
"test_hello",
"fin Doe",
"test_name",
"test_population",
"fin John",
"test_name",
"test_population",
"fin Doe",
]
def test_parametrize_setup_function(self, testdir):
testdir.makepyfile(
"""
import pytest
@pytest.fixture(scope="module", params=[1, 2])
def arg(request):
return request.param
@pytest.fixture(scope="module", autouse=True)
def mysetup(request, arg):
request.addfinalizer(lambda: values.append("fin%s" % arg))
values.append("setup%s" % arg)
values = []
def test_1(arg):
values.append(arg)
def test_2(arg):
values.append(arg)
def test_3():
import pprint
pprint.pprint(values)
if arg == 1:
assert values == ["setup1", 1, 1, ]
elif arg == 2:
assert values == ["setup1", 1, 1, "fin1",
"setup2", 2, 2, ]
"""
)
reprec = testdir.inline_run("-v")
reprec.assertoutcome(passed=6)
def test_fixture_marked_function_not_collected_as_test(self, testdir):
testdir.makepyfile(
"""
import pytest
@pytest.fixture
def test_app():
return 1
def test_something(test_app):
assert test_app == 1
"""
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=1)
def test_params_and_ids(self, testdir):
testdir.makepyfile(
"""
import pytest
@pytest.fixture(params=[object(), object()],
ids=['alpha', 'beta'])
def fix(request):
return request.param
def test_foo(fix):
assert 1
"""
)
res = testdir.runpytest("-v")
res.stdout.fnmatch_lines(["*test_foo*alpha*", "*test_foo*beta*"])
def test_params_and_ids_yieldfixture(self, testdir):
testdir.makepyfile(
"""
import pytest
@pytest.yield_fixture(params=[object(), object()],
ids=['alpha', 'beta'])
def fix(request):
yield request.param
def test_foo(fix):
assert 1
"""
)
res = testdir.runpytest("-v")
res.stdout.fnmatch_lines(["*test_foo*alpha*", "*test_foo*beta*"])
@pytest.mark.issue920
def test_deterministic_fixture_collection(self, testdir, monkeypatch):
testdir.makepyfile(
"""
import pytest
@pytest.fixture(scope="module",
params=["A",
"B",
"C"])
def A(request):
return request.param
@pytest.fixture(scope="module",
params=["DDDDDDDDD", "EEEEEEEEEEEE", "FFFFFFFFFFF", "banansda"])
def B(request, A):
return request.param
def test_foo(B):
# Something funky is going on here.
# Despite specified seeds, on what is collected,
# sometimes we get unexpected passes. hashing B seems
# to help?
assert hash(B) or True
"""
)
monkeypatch.setenv("PYTHONHASHSEED", "1")
out1 = testdir.runpytest_subprocess("-v")
monkeypatch.setenv("PYTHONHASHSEED", "2")
out2 = testdir.runpytest_subprocess("-v")
out1 = [
line
for line in out1.outlines
if line.startswith("test_deterministic_fixture_collection.py::test_foo")
]
out2 = [
line
for line in out2.outlines
if line.startswith("test_deterministic_fixture_collection.py::test_foo")
]
assert len(out1) == 12
assert out1 == out2
class TestRequestScopeAccess(object):
pytestmark = pytest.mark.parametrize(
("scope", "ok", "error"),
[
["session", "", "fspath class function module"],
["module", "module fspath", "cls function"],
["class", "module fspath cls", "function"],
["function", "module fspath cls function", ""],
],
)
def test_setup(self, testdir, scope, ok, error):
testdir.makepyfile(
"""
import pytest
@pytest.fixture(scope=%r, autouse=True)
def myscoped(request):
for x in %r:
assert hasattr(request, x)
for x in %r:
pytest.raises(AttributeError, lambda:
getattr(request, x))
assert request.session
assert request.config
def test_func():
pass
"""
% (scope, ok.split(), error.split())
)
reprec = testdir.inline_run("-l")
reprec.assertoutcome(passed=1)
def test_funcarg(self, testdir, scope, ok, error):
testdir.makepyfile(
"""
import pytest
@pytest.fixture(scope=%r)
def arg(request):
for x in %r:
assert hasattr(request, x)
for x in %r:
pytest.raises(AttributeError, lambda:
getattr(request, x))
assert request.session
assert request.config
def test_func(arg):
pass
"""
% (scope, ok.split(), error.split())
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=1)
class TestErrors(object):
def test_subfactory_missing_funcarg(self, testdir):
testdir.makepyfile(
"""
import pytest
@pytest.fixture()
def gen(qwe123):
return 1
def test_something(gen):
pass
"""
)
result = testdir.runpytest()
assert result.ret != 0
result.stdout.fnmatch_lines(
["*def gen(qwe123):*", "*fixture*qwe123*not found*", "*1 error*"]
)
def test_issue498_fixture_finalizer_failing(self, testdir):
testdir.makepyfile(
"""
import pytest
@pytest.fixture
def fix1(request):
def f():
raise KeyError
request.addfinalizer(f)
return object()
values = []
def test_1(fix1):
values.append(fix1)
def test_2(fix1):
values.append(fix1)
def test_3():
assert values[0] != values[1]
"""
)
result = testdir.runpytest()
result.stdout.fnmatch_lines(
"""
*ERROR*teardown*test_1*
*KeyError*
*ERROR*teardown*test_2*
*KeyError*
*3 pass*2 error*
"""
)
def test_setupfunc_missing_funcarg(self, testdir):
testdir.makepyfile(
"""
import pytest
@pytest.fixture(autouse=True)
def gen(qwe123):
return 1
def test_something():
pass
"""
)
result = testdir.runpytest()
assert result.ret != 0
result.stdout.fnmatch_lines(
["*def gen(qwe123):*", "*fixture*qwe123*not found*", "*1 error*"]
)
class TestShowFixtures(object):
def test_funcarg_compat(self, testdir):
config = testdir.parseconfigure("--funcargs")
assert config.option.showfixtures
def test_show_fixtures(self, testdir):
result = testdir.runpytest("--fixtures")
result.stdout.fnmatch_lines(["*tmpdir*", "*temporary directory*"])
def test_show_fixtures_verbose(self, testdir):
result = testdir.runpytest("--fixtures", "-v")
result.stdout.fnmatch_lines(["*tmpdir*--*tmpdir.py*", "*temporary directory*"])
def test_show_fixtures_testmodule(self, testdir):
p = testdir.makepyfile(
'''
import pytest
@pytest.fixture
def _arg0():
""" hidden """
@pytest.fixture
def arg1():
""" hello world """
'''
)
result = testdir.runpytest("--fixtures", p)
result.stdout.fnmatch_lines(
"""
*tmpdir
*fixtures defined from*
*arg1*
*hello world*
"""
)
assert "arg0" not in result.stdout.str()
@pytest.mark.parametrize("testmod", [True, False])
def test_show_fixtures_conftest(self, testdir, testmod):
testdir.makeconftest(
'''
import pytest
@pytest.fixture
def arg1():
""" hello world """
'''
)
if testmod:
testdir.makepyfile(
"""
def test_hello():
pass
"""
)
result = testdir.runpytest("--fixtures")
result.stdout.fnmatch_lines(
"""
*tmpdir*
*fixtures defined from*conftest*
*arg1*
*hello world*
"""
)
def test_show_fixtures_trimmed_doc(self, testdir):
p = testdir.makepyfile(
textwrap.dedent(
'''\
import pytest
@pytest.fixture
def arg1():
"""
line1
line2
"""
@pytest.fixture
def arg2():
"""
line1
line2
"""
'''
)
)
result = testdir.runpytest("--fixtures", p)
result.stdout.fnmatch_lines(
textwrap.dedent(
"""\
* fixtures defined from test_show_fixtures_trimmed_doc *
arg2
line1
line2
arg1
line1
line2
"""
)
)
def test_show_fixtures_indented_doc(self, testdir):
p = testdir.makepyfile(
textwrap.dedent(
'''\
import pytest
@pytest.fixture
def fixture1():
"""
line1
indented line
"""
'''
)
)
result = testdir.runpytest("--fixtures", p)
result.stdout.fnmatch_lines(
textwrap.dedent(
"""\
* fixtures defined from test_show_fixtures_indented_doc *
fixture1
line1
indented line
"""
)
)
def test_show_fixtures_indented_doc_first_line_unindented(self, testdir):
p = testdir.makepyfile(
textwrap.dedent(
'''\
import pytest
@pytest.fixture
def fixture1():
"""line1
line2
indented line
"""
'''
)
)
result = testdir.runpytest("--fixtures", p)
result.stdout.fnmatch_lines(
textwrap.dedent(
"""\
* fixtures defined from test_show_fixtures_indented_doc_first_line_unindented *
fixture1
line1
line2
indented line
"""
)
)
def test_show_fixtures_indented_in_class(self, testdir):
p = testdir.makepyfile(
textwrap.dedent(
'''\
import pytest
class TestClass(object):
@pytest.fixture
def fixture1(self):
"""line1
line2
indented line
"""
'''
)
)
result = testdir.runpytest("--fixtures", p)
result.stdout.fnmatch_lines(
textwrap.dedent(
"""\
* fixtures defined from test_show_fixtures_indented_in_class *
fixture1
line1
line2
indented line
"""
)
)
def test_show_fixtures_different_files(self, testdir):
"""
#833: --fixtures only shows fixtures from first file
"""
testdir.makepyfile(
test_a='''
import pytest
@pytest.fixture
def fix_a():
"""Fixture A"""
pass
def test_a(fix_a):
pass
'''
)
testdir.makepyfile(
test_b='''
import pytest
@pytest.fixture
def fix_b():
"""Fixture B"""
pass
def test_b(fix_b):
pass
'''
)
result = testdir.runpytest("--fixtures")
result.stdout.fnmatch_lines(
"""
* fixtures defined from test_a *
fix_a
Fixture A
* fixtures defined from test_b *
fix_b
Fixture B
"""
)
def test_show_fixtures_with_same_name(self, testdir):
testdir.makeconftest(
'''
import pytest
@pytest.fixture
def arg1():
"""Hello World in conftest.py"""
return "Hello World"
'''
)
testdir.makepyfile(
"""
def test_foo(arg1):
assert arg1 == "Hello World"
"""
)
testdir.makepyfile(
'''
import pytest
@pytest.fixture
def arg1():
"""Hi from test module"""
return "Hi"
def test_bar(arg1):
assert arg1 == "Hi"
'''
)
result = testdir.runpytest("--fixtures")
result.stdout.fnmatch_lines(
"""
* fixtures defined from conftest *
arg1
Hello World in conftest.py
* fixtures defined from test_show_fixtures_with_same_name *
arg1
Hi from test module
"""
)
def test_fixture_disallow_twice(self):
"""Test that applying @pytest.fixture twice generates an error (#2334)."""
with pytest.raises(ValueError):
@pytest.fixture
@pytest.fixture
def foo():
pass
class TestContextManagerFixtureFuncs(object):
@pytest.fixture(params=["fixture", "yield_fixture"])
def flavor(self, request, testdir, monkeypatch):
monkeypatch.setenv("PYTEST_FIXTURE_FLAVOR", request.param)
testdir.makepyfile(
test_context="""
import os
import pytest
import warnings
VAR = "PYTEST_FIXTURE_FLAVOR"
if VAR not in os.environ:
warnings.warn("PYTEST_FIXTURE_FLAVOR was not set, assuming fixture")
fixture = pytest.fixture
else:
fixture = getattr(pytest, os.environ[VAR])
"""
)
def test_simple(self, testdir, flavor):
testdir.makepyfile(
"""
from __future__ import print_function
from test_context import fixture
@fixture
def arg1():
print ("setup")
yield 1
print ("teardown")
def test_1(arg1):
print ("test1", arg1)
def test_2(arg1):
print ("test2", arg1)
assert 0
"""
)
result = testdir.runpytest("-s")
result.stdout.fnmatch_lines(
"""
*setup*
*test1 1*
*teardown*
*setup*
*test2 1*
*teardown*
"""
)
def test_scoped(self, testdir, flavor):
testdir.makepyfile(
"""
from __future__ import print_function
from test_context import fixture
@fixture(scope="module")
def arg1():
print ("setup")
yield 1
print ("teardown")
def test_1(arg1):
print ("test1", arg1)
def test_2(arg1):
print ("test2", arg1)
"""
)
result = testdir.runpytest("-s")
result.stdout.fnmatch_lines(
"""
*setup*
*test1 1*
*test2 1*
*teardown*
"""
)
def test_setup_exception(self, testdir, flavor):
testdir.makepyfile(
"""
from test_context import fixture
@fixture(scope="module")
def arg1():
pytest.fail("setup")
yield 1
def test_1(arg1):
pass
"""
)
result = testdir.runpytest("-s")
result.stdout.fnmatch_lines(
"""
*pytest.fail*setup*
*1 error*
"""
)
def test_teardown_exception(self, testdir, flavor):
testdir.makepyfile(
"""
from test_context import fixture
@fixture(scope="module")
def arg1():
yield 1
pytest.fail("teardown")
def test_1(arg1):
pass
"""
)
result = testdir.runpytest("-s")
result.stdout.fnmatch_lines(
"""
*pytest.fail*teardown*
*1 passed*1 error*
"""
)
def test_yields_more_than_one(self, testdir, flavor):
testdir.makepyfile(
"""
from test_context import fixture
@fixture(scope="module")
def arg1():
yield 1
yield 2
def test_1(arg1):
pass
"""
)
result = testdir.runpytest("-s")
result.stdout.fnmatch_lines(
"""
*fixture function*
*test_yields*:2*
"""
)
def test_custom_name(self, testdir, flavor):
testdir.makepyfile(
"""
from test_context import fixture
@fixture(name='meow')
def arg1():
return 'mew'
def test_1(meow):
print(meow)
"""
)
result = testdir.runpytest("-s")
result.stdout.fnmatch_lines("*mew*")
class TestParameterizedSubRequest(object):
def test_call_from_fixture(self, testdir):
testdir.makepyfile(
test_call_from_fixture="""
import pytest
@pytest.fixture(params=[0, 1, 2])
def fix_with_param(request):
return request.param
@pytest.fixture
def get_named_fixture(request):
return request.getfixturevalue('fix_with_param')
def test_foo(request, get_named_fixture):
pass
"""
)
result = testdir.runpytest()
result.stdout.fnmatch_lines(
[
"The requested fixture has no parameter defined for test:",
" test_call_from_fixture.py::test_foo",
"Requested fixture 'fix_with_param' defined in:",
"test_call_from_fixture.py:4",
"Requested here:",
"test_call_from_fixture.py:9",
"*1 error in*",
]
)
def test_call_from_test(self, testdir):
testdir.makepyfile(
test_call_from_test="""
import pytest
@pytest.fixture(params=[0, 1, 2])
def fix_with_param(request):
return request.param
def test_foo(request):
request.getfixturevalue('fix_with_param')
"""
)
result = testdir.runpytest()
result.stdout.fnmatch_lines(
[
"The requested fixture has no parameter defined for test:",
" test_call_from_test.py::test_foo",
"Requested fixture 'fix_with_param' defined in:",
"test_call_from_test.py:4",
"Requested here:",
"test_call_from_test.py:8",
"*1 failed*",
]
)
def test_external_fixture(self, testdir):
testdir.makeconftest(
"""
import pytest
@pytest.fixture(params=[0, 1, 2])
def fix_with_param(request):
return request.param
"""
)
testdir.makepyfile(
test_external_fixture="""
def test_foo(request):
request.getfixturevalue('fix_with_param')
"""
)
result = testdir.runpytest()
result.stdout.fnmatch_lines(
[
"The requested fixture has no parameter defined for test:",
" test_external_fixture.py::test_foo",
"",
"Requested fixture 'fix_with_param' defined in:",
"conftest.py:4",
"Requested here:",
"test_external_fixture.py:2",
"*1 failed*",
]
)
def test_non_relative_path(self, testdir):
tests_dir = testdir.mkdir("tests")
fixdir = testdir.mkdir("fixtures")
fixfile = fixdir.join("fix.py")
fixfile.write(
textwrap.dedent(
"""\
import pytest
@pytest.fixture(params=[0, 1, 2])
def fix_with_param(request):
return request.param
"""
)
)
testfile = tests_dir.join("test_foos.py")
testfile.write(
textwrap.dedent(
"""\
from fix import fix_with_param
def test_foo(request):
request.getfixturevalue('fix_with_param')
"""
)
)
tests_dir.chdir()
testdir.syspathinsert(fixdir)
result = testdir.runpytest()
result.stdout.fnmatch_lines(
[
"The requested fixture has no parameter defined for test:",
" test_foos.py::test_foo",
"",
"Requested fixture 'fix_with_param' defined in:",
"*fix.py:4",
"Requested here:",
"test_foos.py:4",
"*1 failed*",
]
)
def test_pytest_fixture_setup_and_post_finalizer_hook(testdir):
testdir.makeconftest(
"""
from __future__ import print_function
def pytest_fixture_setup(fixturedef, request):
print('ROOT setup hook called for {0} from {1}'.format(fixturedef.argname, request.node.name))
def pytest_fixture_post_finalizer(fixturedef, request):
print('ROOT finalizer hook called for {0} from {1}'.format(fixturedef.argname, request.node.name))
"""
)
testdir.makepyfile(
**{
"tests/conftest.py": """
from __future__ import print_function
def pytest_fixture_setup(fixturedef, request):
print('TESTS setup hook called for {0} from {1}'.format(fixturedef.argname, request.node.name))
def pytest_fixture_post_finalizer(fixturedef, request):
print('TESTS finalizer hook called for {0} from {1}'.format(fixturedef.argname, request.node.name))
""",
"tests/test_hooks.py": """
from __future__ import print_function
import pytest
@pytest.fixture()
def my_fixture():
return 'some'
def test_func(my_fixture):
print('TEST test_func')
assert my_fixture == 'some'
""",
}
)
result = testdir.runpytest("-s")
assert result.ret == 0
result.stdout.fnmatch_lines(
[
"*TESTS setup hook called for my_fixture from test_func*",
"*ROOT setup hook called for my_fixture from test_func*",
"*TEST test_func*",
"*TESTS finalizer hook called for my_fixture from test_func*",
"*ROOT finalizer hook called for my_fixture from test_func*",
]
)
class TestScopeOrdering(object):
"""Class of tests that ensure fixtures are ordered based on their scopes (#2405)"""
@pytest.mark.parametrize("variant", ["mark", "autouse"])
@pytest.mark.issue(github="#2405")
def test_func_closure_module_auto(self, testdir, variant, monkeypatch):
"""Semantically identical to the example posted in #2405 when ``use_mark=True``"""
monkeypatch.setenv("FIXTURE_ACTIVATION_VARIANT", variant)
testdir.makepyfile(
"""
import warnings
import os
import pytest
VAR = 'FIXTURE_ACTIVATION_VARIANT'
VALID_VARS = ('autouse', 'mark')
VARIANT = os.environ.get(VAR)
if VARIANT is None or VARIANT not in VALID_VARS:
warnings.warn("{!r} is not in {}, assuming autouse".format(VARIANT, VALID_VARS) )
variant = 'mark'
@pytest.fixture(scope='module', autouse=VARIANT == 'autouse')
def m1(): pass
if VARIANT=='mark':
pytestmark = pytest.mark.usefixtures('m1')
@pytest.fixture(scope='function', autouse=True)
def f1(): pass
def test_func(m1):
pass
"""
)
items, _ = testdir.inline_genitems()
request = FixtureRequest(items[0])
assert request.fixturenames == "m1 f1".split()
def test_func_closure_with_native_fixtures(self, testdir, monkeypatch):
"""Sanity check that verifies the order returned by the closures and the actual fixture execution order:
The execution order may differ because of fixture inter-dependencies.
"""
monkeypatch.setattr(pytest, "FIXTURE_ORDER", [], raising=False)
testdir.makepyfile(
"""
import pytest
FIXTURE_ORDER = pytest.FIXTURE_ORDER
@pytest.fixture(scope="session")
def s1():
FIXTURE_ORDER.append('s1')
@pytest.fixture(scope="package")
def p1():
FIXTURE_ORDER.append('p1')
@pytest.fixture(scope="module")
def m1():
FIXTURE_ORDER.append('m1')
@pytest.fixture(scope='session')
def my_tmpdir_factory():
FIXTURE_ORDER.append('my_tmpdir_factory')
@pytest.fixture
def my_tmpdir(my_tmpdir_factory):
FIXTURE_ORDER.append('my_tmpdir')
@pytest.fixture
def f1(my_tmpdir):
FIXTURE_ORDER.append('f1')
@pytest.fixture
def f2():
FIXTURE_ORDER.append('f2')
def test_foo(f1, p1, m1, f2, s1): pass
"""
)
items, _ = testdir.inline_genitems()
request = FixtureRequest(items[0])
# order of fixtures based on their scope and position in the parameter list
assert (
request.fixturenames == "s1 my_tmpdir_factory p1 m1 f1 f2 my_tmpdir".split()
)
testdir.runpytest()
# actual fixture execution differs: dependent fixtures must be created first ("my_tmpdir")
assert (
pytest.FIXTURE_ORDER == "s1 my_tmpdir_factory p1 m1 my_tmpdir f1 f2".split()
)
def test_func_closure_module(self, testdir):
testdir.makepyfile(
"""
import pytest
@pytest.fixture(scope='module')
def m1(): pass
@pytest.fixture(scope='function')
def f1(): pass
def test_func(f1, m1):
pass
"""
)
items, _ = testdir.inline_genitems()
request = FixtureRequest(items[0])
assert request.fixturenames == "m1 f1".split()
def test_func_closure_scopes_reordered(self, testdir):
"""Test ensures that fixtures are ordered by scope regardless of the order of the parameters, although
fixtures of same scope keep the declared order
"""
testdir.makepyfile(
"""
import pytest
@pytest.fixture(scope='session')
def s1(): pass
@pytest.fixture(scope='module')
def m1(): pass
@pytest.fixture(scope='function')
def f1(): pass
@pytest.fixture(scope='function')
def f2(): pass
class Test:
@pytest.fixture(scope='class')
def c1(cls): pass
def test_func(self, f2, f1, c1, m1, s1):
pass
"""
)
items, _ = testdir.inline_genitems()
request = FixtureRequest(items[0])
assert request.fixturenames == "s1 m1 c1 f2 f1".split()
def test_func_closure_same_scope_closer_root_first(self, testdir):
"""Auto-use fixtures of same scope are ordered by closer-to-root first"""
testdir.makeconftest(
"""
import pytest
@pytest.fixture(scope='module', autouse=True)
def m_conf(): pass
"""
)
testdir.makepyfile(
**{
"sub/conftest.py": """
import pytest
@pytest.fixture(scope='package', autouse=True)
def p_sub(): pass
@pytest.fixture(scope='module', autouse=True)
def m_sub(): pass
""",
"sub/__init__.py": "",
"sub/test_func.py": """
import pytest
@pytest.fixture(scope='module', autouse=True)
def m_test(): pass
@pytest.fixture(scope='function')
def f1(): pass
def test_func(m_test, f1):
pass
""",
}
)
items, _ = testdir.inline_genitems()
request = FixtureRequest(items[0])
assert request.fixturenames == "p_sub m_conf m_sub m_test f1".split()
def test_func_closure_all_scopes_complex(self, testdir):
"""Complex test involving all scopes and mixing autouse with normal fixtures"""
testdir.makeconftest(
"""
import pytest
@pytest.fixture(scope='session')
def s1(): pass
@pytest.fixture(scope='package', autouse=True)
def p1(): pass
"""
)
testdir.makepyfile(**{"__init__.py": ""})
testdir.makepyfile(
"""
import pytest
@pytest.fixture(scope='module', autouse=True)
def m1(): pass
@pytest.fixture(scope='module')
def m2(s1): pass
@pytest.fixture(scope='function')
def f1(): pass
@pytest.fixture(scope='function')
def f2(): pass
class Test:
@pytest.fixture(scope='class', autouse=True)
def c1(self):
pass
def test_func(self, f2, f1, m2):
pass
"""
)
items, _ = testdir.inline_genitems()
request = FixtureRequest(items[0])
assert request.fixturenames == "s1 p1 m1 m2 c1 f2 f1".split()
def test_multiple_packages(self, testdir):
"""Complex test involving multiple package fixtures. Make sure teardowns
are executed in order.
.
└── root
├── __init__.py
├── sub1
│ ├── __init__.py
│ ├── conftest.py
│ └── test_1.py
└── sub2
├── __init__.py
├── conftest.py
└── test_2.py
"""
root = testdir.mkdir("root")
root.join("__init__.py").write("values = []")
sub1 = root.mkdir("sub1")
sub1.ensure("__init__.py")
sub1.join("conftest.py").write(
textwrap.dedent(
"""\
import pytest
from .. import values
@pytest.fixture(scope="package")
def fix():
values.append("pre-sub1")
yield values
assert values.pop() == "pre-sub1"
"""
)
)
sub1.join("test_1.py").write(
textwrap.dedent(
"""\
from .. import values
def test_1(fix):
assert values == ["pre-sub1"]
"""
)
)
sub2 = root.mkdir("sub2")
sub2.ensure("__init__.py")
sub2.join("conftest.py").write(
textwrap.dedent(
"""\
import pytest
from .. import values
@pytest.fixture(scope="package")
def fix():
values.append("pre-sub2")
yield values
assert values.pop() == "pre-sub2"
"""
)
)
sub2.join("test_2.py").write(
textwrap.dedent(
"""\
from .. import values
def test_2(fix):
assert values == ["pre-sub2"]
"""
)
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=2)
| txomon/pytest | testing/python/fixture.py | Python | mit | 124,651 | [
"VisIt"
] | 0edf0bfcbf02bb34607902c130e574afd2ebdd0f755d48a0616b4b35c5c874e5 |
# Copyright (C) 2010 Parker Phinney
# Copyright (C) 2009, 2010 OpenHatch, Inc.
# Copyright (C) 2010 Jessica McKellar
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import logging
import os
import StringIO
import tempfile
from webtest import Upload
from django.contrib.auth.models import User
from django.contrib.auth import authenticate
from django.core.urlresolvers import reverse
from django.test.client import Client
from django.utils.unittest import skipIf
from django_webtest import WebTest
import mysite.account.forms
import mysite.account.views
import mysite.base.depends
from mysite.profile.models import Person
import mysite.project.views
from mysite.search.models import Project, ProjectInvolvementQuestion
class Login(WebTest):
""" Tests for user logins and logouts """
fixtures = ['user-paulproteus', 'person-paulproteus']
def test_login(self):
""" Test login with username and password """
user = authenticate(username='paulproteus',
password="paulproteus's unbreakable password")
self.assertTrue(user and user.is_active)
def test_logout_web(self):
"""
Test logout of a user. Test by inspecting Django's client sesssion.
"""
# Log in first before you test the log out feature.
self.client = Client()
username = 'paulproteus'
password = "paulproteus's unbreakable password"
self.client.login(username=username, password=password)
# Check that the user is indeed still logged in
self.assertEqual(1, self.client.session.get('_auth_user_id'))
# Log out the user
self.client.logout()
# Test that user is indeed logged out by checking the client session
# object
self.assertNotEqual(1, self.client.session.get('_auth_user_id'))
# Test that the links are expectedly present or expectedly absent by
# using django web-test. Log in first before you test the log out
# feature.
search_page = self.app.get('/search/')
self.assertIn('log in', search_page.content)
login_page = search_page.click('log in')
self.assertNotIn('log out', login_page.content)
login_page_old = login_page.click('Log in with a password')
login_page_form = login_page_old.form
login_page_form['username'] = username
login_page_form['password'] = password
login_page_form.submit()
# Go to ANY page to confirm that 'log out' link is present and
# 'log in' link is absent
search_page = self.app.get('/search/')
self.assertIn('log out', search_page.content)
self.assertNotIn('log in', search_page.content)
# After the log out link is clicked, go to ANY page to confirm that
# the log out link is gone and log in link is present instead
logout_page = search_page.click('log out')
search_page = self.app.get('/search/')
self.assertIn('log in', search_page.content)
self.assertNotIn('log out', search_page.content)
def test_logout_no_open_redirect(self):
""" Tests to ensure logout does not open redirect """
client = Client()
# All test cases should redirect to the OpenHatch root.
# Verify existing logout still behaves as before:
response = client.get('/account/logout/?next=/')
self.assertEqual(response.status_code, 302)
self.assertEqual(response['Location'], 'http://testserver/')
# Verify appended redirect url is ignored:
# Before the fix for issue 952, urlparse() redirected this url to
# /account/logout/.
response = client.get('/account/logout/?next=http://www.example.com')
self.assertEqual(response.status_code, 302)
self.assertEqual(response['Location'], 'http://testserver/')
# Verify appended redirect url is ignored
# Before the fix for issue 952, urlparse() redirected this url to
# example.com.
response = client.get('/account/logout/?next=http:///www.example.com')
self.assertEqual(response.status_code, 302)
self.assertEqual(response['Location'], 'http://testserver/')
class ProfileGetsCreatedWhenUserIsCreated(WebTest):
"""
Test that a user profile is created when a user is created.
django-authopenid only creates User objects, so we need to create Person
objects in all such cases. Test that creating a User will automatically
create a Person in our project.
"""
def test_login_creates_person_profile(self):
""" Test that a person object is created when user is created """
# Create a user object
u = User.objects.create(username='paulproteus')
u.save()
# Even though we didn't add the person-paulproteus fixture,
# check that a Person object is created.
self.assert_(list(Person.objects.filter(user__username='paulproteus')))
class Signup(WebTest):
""" Tests for signup without invite code. """
fixtures = ['user-paulproteus', 'person-paulproteus']
def test_usernames_case_sensitive(self):
username = 'paulproteus'
signup_page = self.app.get('/account/signup/')
signup_form = signup_page.form
self.assertNotIn(
'already got a user in our database with that username',
signup_form.text
)
signup_form['username'] = 'paulproteus'
signup_form['email'] = 'someone@somewhere.com'
signup_form['password1'] = 'blahblahblah'
signup_form['password2'] = 'blahblahblah'
response = signup_form.submit()
self.assertEqual(response.status_code, 200)
self.assertIn('already got a user in our database with that username',
response.content)
def test_usernames_case_insensitive(self):
username = 'paulproteus'
signup_page = self.app.get('/account/signup/')
signup_form = signup_page.form
self.assertNotIn(
'already got a user in our database with that username',
signup_form.text
)
signup_form['username'] = 'PaulProteus'
signup_form['email'] = 'someone@somewhere.com'
signup_form['password1'] = 'blahblahblah'
signup_form['password2'] = 'blahblahblah'
response = signup_form.submit()
self.assertEqual(response.status_code, 200)
self.assertIn('already got a user in our database with that username',
response.content)
def test_reserved_username(self):
username = 'paulproteus'
signup_page = self.app.get('/account/signup/', user=username)
signup_form = signup_page.form
self.assertNotIn('That username is reserved.', signup_form.text)
signup_form['username'] = 'admin'
signup_form['email'] = 'someone@somewhere.com'
signup_form['password1'] = 'blahblahblah'
signup_form['password2'] = 'blahblahblah'
response = signup_form.submit()
self.assertEqual(response.status_code, 200)
self.assertIn('That username is reserved.', response.content)
def test_signup_redirect_to_profile(self):
signup_page = self.app.get('/account/signup/')
signup_form = signup_page.form
self.assertNotIn(
'already got a user in our database with that username',
signup_form.text
)
username = 'test_test'
signup_form['username'] = username
signup_form['email'] = 'someone@somewhere.com'
signup_form['password1'] = 'blahblahblah'
signup_form['password2'] = 'blahblahblah'
response = signup_form.submit()
self.assertEqual(response.status_code, 302)
self.assertIn('/people/{}'.format(username), response.location)
def test_signup_redirect_to_referer_page(self):
next_page = '/missions/tar/unpacking'
signup_page = self.app.get('/account/signup/?next={}'.format(next_page))
signup_form = signup_page.form
self.assertNotIn(
'already got a user in our database with that username',
signup_form.text
)
username = 'test_test'
signup_form['username'] = username
signup_form['email'] = 'someone@somewhere.com'
signup_form['password1'] = 'blahblahblah'
signup_form['password2'] = 'blahblahblah'
response = signup_form.submit()
self.assertEqual(response.status_code, 302)
self.assertIn(next_page, response.location)
class EditPassword(WebTest):
""" Tests for password edits """
fixtures = ['user-paulproteus', 'person-paulproteus']
def change_password(self, old_pass, new_pass,
should_succeed=True):
""" Helper function for changing password tests """
# From a sample user profile page, go into the reset password page
user = 'paulproteus'
paulproteus_page = self.app.get('/people/%s/' % (user,), user=user)
settings_page = paulproteus_page.click(href="/account/settings/location/")
reset_pw_page = settings_page.click("Password", index=0)
# Change password on the password reset form
reset_pw_form = reset_pw_page.form
reset_pw_form['old_password'] = old_pass
reset_pw_form['new_password1'] = new_pass
reset_pw_form['new_password2'] = new_pass
form_response = reset_pw_form.submit()
# Try to log in with the new password now
client = Client()
username = 'paulproteus'
actual_should_succeed = client.login(username=username,
password=new_pass)
self.assertEqual(actual_should_succeed, should_succeed)
def test_change_password(self):
""" Test that change password succeeds """
old_pass = "paulproteus's unbreakable password"
new_pass = 'new'
self.change_password(old_pass=old_pass, new_pass=new_pass)
def test_change_password_should_fail(self):
""" Test that wrong password entered fails """
oldpass = "wrong"
newpass = 'new'
self.change_password(oldpass, newpass,
should_succeed=False)
class EditContactInfo(WebTest):
""" Test contact information changes """
fixtures = ['user-paulproteus', 'person-paulproteus']
def test_edit_email_address(self):
""" Test for successful edits of email address """
# Opt out of the periodic emails. This way, the only "checked"
# checkbox is the one for if the user's email address gets shown.
user = "paulproteus"
paulproteus = Person.objects.get()
paulproteus.email_me_re_projects = False
paulproteus.save()
contact_info_page = self.app.get("/account/settings/contact-info/",
user=user)
current_pw = "paulproteus's unbreakable password"
new_email = 'new@ema.il'
# Let's first ensure that "new@ema.il" doesn't appear on the page.
# We're about to add it.
# Test that the email is initially not visible on user profile page
paulproteus_page = self.app.get('/people/%s/' % (user,), user=user)
assert new_email not in paulproteus_page
# Change email address and make sure it's publicly visible
contact_info_form = contact_info_page.form
contact_info_form['edit_email-email'] = new_email
contact_info_form['show_email-show_email'].checked = True
contact_info_form.submit()
self.assertEqual(paulproteus.user.email, new_email)
# Test that the email is publicly visible on user profile page
paulproteus_page = self.app.get('/people/%s/' % (user,), user=user)
assert new_email in paulproteus_page
# Test that the email is not publicly displayble
contact_info_page = self.app.get('/account/settings/contact-info/',
user=user)
contact_info_form['show_email-show_email'].checked = False
contact_info_form.submit()
# Test that the email is no longer visible on user profile page
paulproteus_page = self.app.get('/people/%s/' % (user,), user=user)
assert new_email not in paulproteus_page
# list of photos
photos = [os.path.join(os.path.dirname(__file__),
'..', '..', 'sample-photo.' + ext)
for ext in ('png', 'jpg')]
def photo(f):
""" Helper function for photo file """
filename = os.path.join(os.path.dirname(__file__), '..', f)
assert os.path.exists(filename)
return filename
class EditPhoto(WebTest):
""" Tests for photo edits """
fixtures = ['user-paulproteus', 'person-paulproteus']
def login_with_client(self, username='paulproteus',
password="paulproteus's unbreakable password"):
""" Helper function to login """
client = Client()
success = client.login(username=username,
password=password)
self.assert_(success)
return client
def test_set_avatar(self):
""" Test if user avatar setting succeeds """
username = 'paulproteus'
for image in [photo('static/sample-photo.png'),
photo('static/sample-photo.jpg')]:
paulproteus_page = self.app.get('/people/%s/' % (username,),
user=username)
settings_page = paulproteus_page.click(href='/account/settings/')
photo_page = settings_page.click(href='/account/edit/photo/')
photo_form = photo_page.form
photo_form['photo'] = Upload(image)
photo_form.submit()
# Now check that the photo == what we uploaded
p = Person.objects.get(user__username=username)
self.assert_(p.photo.read() == open(image).read())
response = self.login_with_client().get(
reverse(mysite.account.views.edit_photo))
self.assertEqual(response.context[0]['photo_url'], p.photo.url,
"Test that once you've uploaded a photo via the "
"photo editor, the template's photo_url "
"variable is correct.")
self.assert_(p.photo_thumbnail)
thumbnail_as_stored = mysite.base.depends.Image.open(
p.photo_thumbnail.file)
w, h = thumbnail_as_stored.size
self.assertEqual(w, 40)
def test_set_avatar_too_wide(self):
""" Test if avatar is too wide for setting """
username = 'paulproteus'
for image in [photo('static/images/too-wide.jpg'),
photo('static/images/too-wide.png')]:
paulproteus_page = self.app.get('/people/%s/' % (username,),
user=username)
settings_page = paulproteus_page.click(href='/account/settings/')
photo_page = settings_page.click(href='/account/edit/photo/')
photo_form = photo_page.form
photo_form['photo'] = Upload(image)
photo_form.submit()
# Now check that the photo is 200px wide
p = Person.objects.get(user__username=username)
image_as_stored = mysite.base.depends.Image.open(p.photo.file)
w, h = image_as_stored.size
self.assertEqual(w, 200)
def test_invalid_photo(self):
"""
If the uploaded image is detected as being invalid, report a helpful
message to the user. The photo is not added to the user's profile.
"""
username = 'paulproteus'
bad_image = tempfile.NamedTemporaryFile(delete=False)
try:
bad_image.write("garbage")
bad_image.close()
paulproteus_page = self.app.get('/people/%s/' % (username,),
user=username)
photo_page = paulproteus_page.click(href='/account/edit/photo/')
photo_form = photo_page.form
photo_form['photo'] = Upload(bad_image.name)
form_response = photo_form.submit()
self.assertEqual(form_response.status_code, 200)
self.assertIn("The file you uploaded was either not an image or "
"a corrupted image", form_response.content)
# Test that user test object has no photo attribute
p = Person.objects.get(user__username=username)
self.assertFalse(p.photo.name)
finally:
os.unlink(bad_image.name)
class EditPhotoWithExistingPerson(WebTest):
""" Test for edit and upload an updated photo for a user """
fixtures = ['user-paulproteus', 'person-paulproteus-with-blank-photo']
def test_set_avatar(self):
""" Test if setting avatar succeeds """
username = 'paulproteus'
for image in (photo('static/sample-photo.png'),
photo('static/sample-photo.jpg')):
paulproteus_page = self.app.get('/people/paulproteus/',
user=username)
settings_page = paulproteus_page.click(href='/account/settings/')
photo_page = settings_page.click(href='/account/edit/photo/')
photo_form = photo_page.form
photo_form['photo'] = Upload(image)
photo_response = photo_form.submit()
# Now check that the photo == what we uploaded
p = Person.objects.get(user__username=username)
self.assert_(p.photo.read() == open(image).read())
class SignupWithNoPassword(WebTest):
""" Test signup without a password """
def test(self):
""" Test user signup with no password """
response = self.client.post(reverse(mysite.account.views.signup_do),
{'username': 'mister_roboto'})
form = response.context['form']
self.assertFalse(form.is_valid())
self.assertEqual(User.objects.count(), 0)
class LoginPageContainsUnsavedAnswer(WebTest):
""" Test for login page where a response is not saved """
def test(self):
""" Test successful handling of a login page with unsaved info"""
# Create an answer whose author isn't specified.
# This replicates the situation where the user isn't logged in.
p = Project.create_dummy(name='Myproject')
q = ProjectInvolvementQuestion.create_dummy(key_string='where_to_start',
is_bug_style=False)
# Do a GET on the project page to prove cookies work.
self.client.get(p.get_url())
POST_data = {
'project__pk': p.pk,
'question__pk': q.pk,
'answer__text': ("Help produce official documentation, share "
"the solution to a problem, or check, proof "
"and test other documents for accuracy."),
}
response = self.client.post(
reverse(mysite.project.views.create_answer_do),
POST_data,
follow=True
)
# The session will now know about the answer, but the answer will
# not be published. Visit the login page, assert that the page
# contains the text of the answer.
response = self.client.get(reverse('oh_login'))
self.assertContains(response, POST_data['answer__text'])
class ClearSessionsOnPasswordChange(WebTest):
""" Test sessions cleared when password changes """
fixtures = ['user-paulproteus']
def user_logged_in(self, session):
return '_auth_user_id' in session
def test(self):
""" Test the session is cleared successfully """
client1 = Client()
client2 = Client()
username = "paulproteus"
password = "paulproteus's unbreakable password"
new_password = "new password"
client1.login(username=username, password=password)
client2.login(username=username, password=password)
self.assertTrue(self.user_logged_in(client1.session))
self.assertTrue(self.user_logged_in(client2.session))
client1.post(reverse(mysite.account.views.change_password_do),
data={'old_password': password,
'new_password1': new_password,
'new_password2': new_password
})
self.assertTrue(self.user_logged_in(client1.session))
self.assertFalse(self.user_logged_in(client2.session))
| ehashman/oh-mainline | mysite/account/tests.py | Python | agpl-3.0 | 21,272 | [
"VisIt"
] | a146da3f8085fd7c4028508b39efd4eec700f2f713e3e2d658f40531d84a6e4b |
"""
Tools for simulating the result of a cgi.FieldStorage()
call; useful for testing CGI scripts outside the Web
"""
class FieldMockup: # mocked-up input object
def __init__(self, str):
self.value = str
def formMockup(**kwargs): # pass field=value args
mockup = {} # multichoice: [value,...]
for (key, value) in kwargs.items():
if type(value) != list: # simple fields have .value
mockup[key] = FieldMockup(str(value))
else: # multichoice have list
mockup[key] = [] # to do: file upload fields
for pick in value:
mockup[key].append(FieldMockup(pick))
return mockup
def selftest():
# use this form if fields can be hardcoded
form = formMockup(name='Bob', job='hacker', food=['Spam', 'eggs', 'ham'])
print(form['name'].value)
print(form['job'].value)
for item in form['food']:
print(item.value, end=' ')
# use real dict if keys are in variables or computed
print()
form = {'name': FieldMockup('Brian'), 'age': FieldMockup(38)} # or dict()
for key in form.keys():
print(form[key].value)
if __name__ == '__main__': selftest()
| simontakite/sysadmin | pythonscripts/programmingpython/Internet/Web/cgi-bin/formMockup.py | Python | gpl-2.0 | 1,388 | [
"Brian"
] | ff6a050c0b21451aa385cb2b7e6bb9f76cb5b79fde3b8c9b36a37b95fdff5c97 |
""" pytest for WorkflowTasks
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
# pylint: disable=protected-access,missing-docstring,invalid-name
import json
import six
import sys
from mock import MagicMock
from pytest import mark
parametrize = mark.parametrize
from hypothesis import given, settings
from hypothesis.strategies import (
composite,
integers,
lists,
text,
dictionaries,
from_regex,
)
from string import ascii_letters, digits
from DIRAC.Core.Utilities.JEncode import encode
from DIRAC.TransformationSystem.Client.BodyPlugin.DummyBody import DummyBody
from DIRAC.TransformationSystem.Client.RequestTasks import RequestTasks
@composite
def taskStrategy(draw):
"""Generate a strategy that returns a task dictionary"""
transformationID = draw(integers(min_value=1))
targetSE = ",".join(draw(lists(text(ascii_letters, min_size=5, max_size=10), min_size=1, max_size=3)))
inputData = draw(lists(from_regex("(/[a-z]+)+", fullmatch=True), min_size=1, max_size=10))
return {"TransformationID": transformationID, "TargetSE": targetSE, "InputData": inputData}
def taskDictStrategy():
return dictionaries(
integers(min_value=1), taskStrategy(), min_size=1, max_size=10 # pylint: disable=no-value-for-parameter
)
mockTransClient = MagicMock()
mockReqClient = MagicMock()
mockReqValidator = MagicMock()
reqTasks = RequestTasks(
transClient=mockTransClient,
requestClient=mockReqClient,
requestValidator=mockReqValidator,
)
@parametrize(
"transBody",
[
"removal;RemoveFile", # Transformation to remove files
"removal;RemoveReplica", # Transformation to remove Replicas
"anything;ReplicateAndRegister", # Transformation to replicate and register, first parameter is useless
"", # if no Body, we expect replicateAndRegister
],
)
@mark.slow
@settings(max_examples=50, deadline=500)
@given(
owner=text(ascii_letters + "-_" + digits, min_size=1),
taskDict=taskDictStrategy(),
)
def test_prepareSingleOperationsBody(transBody, owner, taskDict):
"""Test different bodies that should be routed through the
singleOperationBody method.
"""
# keep the number of tasks for later
originalNbOfTasks = len(taskDict)
# Make up the DN and the group
ownerDN = "DN_" + owner
ownerGroup = "group_" + owner
res = reqTasks.prepareTransformationTasks(transBody, taskDict, owner=owner, ownerGroup=ownerGroup, ownerDN=ownerDN)
assert res["OK"], res
# prepareTransformationTasks can pop tasks if a problem occurs,
# so check that this did not happen
assert len(res["Value"]) == originalNbOfTasks
for _taskID, task in taskDict.items():
req = task.get("TaskObject")
# Checks whether we got a Request assigned
assert req
# Check that the attributes of the request are what
# we expect them to be
assert req.OwnerDN == ownerDN
assert req.OwnerGroup == ownerGroup
# Make sure we only have one operation
assert len(req) == 1
ops = req[0]
# Check the operation type
# The operation type is either given as second parameter of the body
# or if not, it is ReplicateAndRegister
expectedOpsType = transBody.split(";")[-1] if transBody else "ReplicateAndRegister"
assert ops.Type == expectedOpsType
# Check that the targetSE is set correctly
assert ops.TargetSE == task["TargetSE"]
# Make sure we have one file per LFN in the task
assert len(ops) == len(task["InputData"])
# Checks that there is one file per LFN
assert set([f.LFN for f in ops]) == set(task["InputData"])
@parametrize(
"transBody",
[
[
("ReplicateAndRegister", {"TargetSE": "BAR-SRM"}),
],
[
("ReplicateAndRegister", {"TargetSE": "TASK:TargetSE"}),
],
[
("ReplicateAndRegister", {"SourceSE": "FOO-SRM", "TargetSE": "BAR-SRM"}),
("RemoveReplica", {"TargetSE": "FOO-SRM"}),
],
[
("ReplicateAndRegister", {"SourceSE": "FOO-SRM", "TargetSE": "TASK:TargetSE"}),
("RemoveReplica", {"TargetSE": "FOO-SRM"}),
],
],
ids=[
"Single operation, no substitution",
"Single operation, with substitution",
"Multiple operations, no substitution",
"Multiple operations, with substitution",
],
)
@mark.slow
@settings(max_examples=50, deadline=500)
@given(
owner=text(ascii_letters + "-_" + digits, min_size=1),
taskDict=taskDictStrategy(),
)
def test_prepareMultiOperationsBody(transBody, owner, taskDict):
"""Test different bodies that should be routed through the
multiOperationsBody method.
"""
# keep the number of tasks for later
originalNbOfTasks = len(taskDict)
# Make up the DN and the group
ownerDN = "DN_" + owner
ownerGroup = "group_" + owner
res = reqTasks.prepareTransformationTasks(
json.dumps(transBody), taskDict, owner=owner, ownerGroup=ownerGroup, ownerDN=ownerDN
)
assert res["OK"], res
# prepareTransformationTasks can pop tasks if a problem occurs,
# so check that this did not happen
assert len(res["Value"]) == originalNbOfTasks
for _taskID, task in taskDict.items():
req = task.get("TaskObject")
# Checks whether we got a Request assigned
assert req
# Check that the attributes of the request are what
# we expect them to be
assert req.OwnerDN == ownerDN
assert req.OwnerGroup == ownerGroup
# Make sure we have as many operations as tuple in the body
assert len(req) == len(transBody)
# Loop over each operation
# to check their attributes
for opsID, ops in enumerate(req):
expectedOpsType, expectedOpsAttributes = transBody[opsID]
# Compare the operation type with what we want
assert ops.Type == expectedOpsType
# Check the operation attributes one after the other
for opsAttr, opsVal in expectedOpsAttributes.items():
# If the expected value starts with 'TASK:'
# we should make the substitution with whatever is in
# the taskDict.
# So it should be different
if opsVal.startswith("TASK:"):
assert getattr(ops, opsAttr) != opsVal
# Otherwise, make sure it matches
else:
assert getattr(ops, opsAttr) == opsVal
# Make sure we have one file per LFN in the task
assert len(ops) == len(task["InputData"])
# Checks that there is one file per LFN
assert set([f.LFN for f in ops]) == set(task["InputData"])
@parametrize(
"transBody",
[
# We request a key that does not exist in the taskDict
[
("ReplicateAndRegister", {"TargetSE": "TASK:NotInTaskDict"}),
],
],
ids=[
"Non existing substitution",
],
)
@mark.slow
@settings(max_examples=50, deadline=500)
@given(
owner=text(ascii_letters + "-_" + digits, min_size=1),
taskDict=taskDictStrategy(),
)
def test_prepareProblematicMultiOperationsBody(transBody, owner, taskDict):
"""Test different bodies that should be routed through the
multiOperationBody method, but that have a problem
"""
# keep the number of tasks for later
originalNbOfTasks = len(taskDict)
# Make up the DN and the group
ownerDN = "DN_" + owner
ownerGroup = "group_" + owner
res = reqTasks.prepareTransformationTasks(
json.dumps(transBody), taskDict, owner=owner, ownerGroup=ownerGroup, ownerDN=ownerDN
)
assert res["OK"], res
# prepareTransformationTasks pop tasks if a problem occurs,
# so make sure it happened
assert len(res["Value"]) != originalNbOfTasks
# Check that other tasks are fine
# Note: currently, we will never enter this loop as
# the transbody are buggy, so all the tasks should be removed.
# I just prepare the future :-)
for _taskID, task in taskDict.items():
req = task.get("TaskObject")
# Checks whether we got a Request assigned
assert req
# Check that the attributes of the request are what
# we expect them to be
assert req.OwnerDN == ownerDN
assert req.OwnerGroup == ownerGroup
# Make sure we have as many operations as tuple in the body
assert len(req) == len(transBody)
# Loop over each operation
# to check their attributes
for opsID, ops in enumerate(req):
expectedOpsType, expectedOpsAttributes = transBody[opsID]
# Compare the operation type with what we want
assert ops.Type == expectedOpsType
# Check the operation attributes one after the other
for opsAttr, opsVal in expectedOpsAttributes.items():
# If the expected value starts with 'TASK:'
# we should make the substitution with whatever is in
# the taskDict.
# So it should be different
if opsVal.startswith("TASK:"):
assert getattr(ops, opsAttr) != opsVal
# Otherwise, make sure it matches
else:
# Check that the targetSE is set correctly
assert getattr(ops, opsAttr) == opsVal
# Make sure we have one file per LFN in the task
assert len(ops) == len(task["InputData"])
# Checks that there is one file per LFN
assert set([f.LFN for f in ops]) == set(task["InputData"])
@mark.slow
@settings(max_examples=50, deadline=500)
@given(
taskDict=taskDictStrategy(),
pluginFactor=integers(),
)
def test_complexBodyPlugin(taskDict, pluginFactor):
"""This test makes sure that we can load the BodyPlugin objects"""
transBody = DummyBody(factor=pluginFactor)
# keep the number of tasks for later
originalNbOfTasks = len(taskDict)
# Make up the DN and the group
ownerDN = "DN_owner"
ownerGroup = "group_owner"
res = reqTasks.prepareTransformationTasks(
encode(transBody), taskDict, owner="owner", ownerGroup=ownerGroup, ownerDN=ownerDN
)
assert res["OK"], res
# prepareTransformationTasks can pop tasks if a problem occurs,
# so check that this did not happen
assert len(res["Value"]) == originalNbOfTasks
for _taskID, task in taskDict.items():
req = task.get("TaskObject")
# Checks whether we got a Request assigned
assert req
# Check that the attributes of the request are what
# we expect them to be
assert req.OwnerDN == ownerDN
assert req.OwnerGroup == ownerGroup
# DummyBody only creates a single operation.
# It should be a forward diset, and the
# argument should be the number of files in the task
# multiplied by the pluginParam
assert len(req) == 1
ops = req[0]
assert ops.Type == "ForwardDISET"
assert json.loads(ops.Arguments) == pluginFactor * len(task["InputData"])
| ic-hep/DIRAC | src/DIRAC/TransformationSystem/Client/test/Test_Client_RequestTasks.py | Python | gpl-3.0 | 11,381 | [
"DIRAC"
] | 7f86e3587bb85bfe1ae82abcea2838955107bddae53b96c2f6373764d446a391 |
#!/usr/bin/env python
# -*- coding: utf8 -*-
"""
Check that all error messages are formatted the same way.
"""
from __future__ import print_function
import os
import sys
import glob
import re
import codecs
ROOT = os.path.join(os.path.dirname(__file__), "..", "..")
ERRORS = 0
# Path, line of messages that do not follow the current format, but
# are allowed
ALLOWED = [
"found deprecated configuration file at '{}', please rename it to .chemfiles.toml",
"could not find _atom_site.type_symbol in '{}'",
"could not find _atom_site.Cartn_x in '{}'",
]
def error(message):
global ERRORS
ERRORS += 1
print(message)
def extract_messages(lines, i, has_context):
if has_context:
context_start = lines[i].find('"')
if context_start == -1:
# look at the next line
i = i + 1
context_start = lines[i].find('"')
context_stop = lines[i].find('"', context_start + 1)
else:
context_stop = -1
start = lines[i].find('"', context_stop + 1)
if start == -1:
# look in the next line
i = i + 1
start = lines[i].find('"')
if start == -1:
print("warning: could not get the message at {}:{}".format(path, i))
return ""
stop = lines[i].find('"', start + 1)
if stop == -1:
error("could not get the message end at {}:{}".format(path, i))
return lines[i][start + 1 : stop]
def check_message(path, line, message):
if not message:
return
if message in ALLOWED:
return
# check for upper case at the start, allow abbreviations (LAMMPS, HELIX)
if message[0].isupper() and not message[1].isupper():
error(
"message starts in upper case\n"
" => '{}' at {}:{}".format(message, path, line)
)
# check for full stops in sentences
if re.search("[a-zA-Z][\\.!?]", message):
error(
"found punctuation (., ! or ?) in message\n"
" => '{}' at {}:{}".format(message, path, line)
)
def check_file(path):
with codecs.open(path, encoding="utf8") as fd:
lines = list(fd)
for (i, line) in enumerate(lines):
# ignore comments
if line.strip().startswith("//"):
continue
if " warning(" in line:
check_message(path, i, extract_messages(lines, i, has_context=True))
if "throw" in line:
check_message(path, i, extract_messages(lines, i, has_context=False))
if __name__ == "__main__":
for path in glob.glob(os.path.join(ROOT, "src/*.cpp")):
check_file(path)
for path in glob.glob(os.path.join(ROOT, "src/*/*.cpp")):
check_file(path)
for path in glob.glob(os.path.join(ROOT, "include/chemfiles/*.hpp")):
check_file(path)
for path in glob.glob(os.path.join(ROOT, "include/chemfiles/*/*.hpp")):
if "external" in path:
continue
check_file(path)
if ERRORS != 0:
sys.exit(1)
| Luthaf/Chemharp | tests/lints/check-error-messages.py | Python | mpl-2.0 | 3,010 | [
"Chemfiles",
"LAMMPS"
] | e7f96cf3bb68fc240ace8f7d43218d38e89fa35d1f9399e5fc823ec8f34dec4d |
"""
Python module for creating, training and applying hidden
Markov models to discrete or continuous observations.
Author: Michael Hamilton, hamiltom@cs.colostate.edu
Theoretical concepts obtained from Rabiner, 1989.
"""
import numpy
import time, copy
import numpy.random
import numpy.linalg
import matplotlib.pyplot as plt #FC since pylab no longer seem to make sense
#import matplotlib.rc
#rc('text', usetex=True)
class HMM_Classifier:
"""
A binary hmm classifier that utilizes two hmms: one corresponding
to the positive activity and one corresponding to the negative
activity.
"""
def __init__( self, **args ):
"""
:Keywords:
- `neg_hmm` - hmm corresponding to negative activity
- `pos_hmm` - hmm corresponding to positive activity
"""
self.neg_hmm = None
self.pos_hmm = None
if 'neg_hmm' in args:
self.neg_hmm = args[ 'neg_hmm' ]
if 'pos_hmm' in args:
self.pos_hmm = args[ 'pos_hmm' ]
def classify( self, sample ):
"""
Classification is performed by calculating the
log odds for the positive activity. Since the hmms
return a log-likelihood (due to scaling)
of the corresponding activity, the difference of
the two log-likelihoods is the log odds.
"""
# Scream if an hmm is missing
if self.pos_hmm == None or self.neg_hmm == None:
raise "pos/neg hmm(s) missing"
pos_ll = forward( self.pos_hmm, sample, scaling=1 )[ 0 ]
neg_ll = forward( self.neg_hmm, sample, scaling=1 )[ 0 ]
# log odds by difference of log-likelihoods
return pos_ll - neg_ll
def add_pos_hmm( self, pos_hmm ):
"""
Add the hmm corresponding to positive
activity. Replaces current positive hmm, if it exists.
"""
self.pos_hmm = pos_hmm
def add_neg_hmm( self, neg_hmm ):
"""
Add the hmm corresponding to negative
activity. Replaces current negative hmm, if it exists.
"""
self.neg_hmm = neg_hmm
class HMM:
"""
Creates and maintains a hidden Markov model. This version assumes the every state can be
reached DIRECTLY from any other state (ergodic). This, of course, excludes the start state.
Hence the state transition matrix, A, must be N X N . The observable symbol probability
distributions are represented by an N X M matrix where M is the number of observation
symbols.
|a_11 a_12 ... a_1N| |b_11 b_12 ... b_1M|
|a_21 a_22 ... a_2N| |b_21 b_22 ... b_2M|
A = | . . . | B = | . . . |
| . . . | | . . . |
|a_N1 a_N2 ... a_NN| |b_N1 b_N2 ... b_NM|
a_ij = P(q_t = S_j|q_t-1 = S_i) b_ik = P(v_k at t|q_t = S_i)
where q_t is state at time t and v_k is k_th symbol of observation sequence
"""
def __init__( self, n_states=1, **args ):
"""
:Keywords:
- `n_states` - number of hidden states
- `V` - list of all observable symbols
- `A` - transition matrix
- `B` - observable symbol probability distribution
- `D` - dimensionality of continuous observations
- `F` - Fixed emission probabilities for the given state ( dict: i -> numpy.array( [n_states] ),
where i is the state to hold fixed.
"""
self.N = n_states # Number of hidden states
# Initialize observable symbol set parameters
self.V = args[ 'V' ]
self.M = len( self.V )
self.symbol_map = dict( zip ( self.V, range( len( self.V ) )) )
# Initialize transition probability matrix
if 'A' in args:
self.A = args[ 'A' ]
assert numpy.shape( self.A ) == ( self.N, self.N )
else:
# Randomly initialize matrix and normalize so sum over a row = 1
raw_A = numpy.random.uniform( size = self.N * self.N ).reshape( ( self.N, self.N ) )
self.A = ( raw_A.T / raw_A.T.sum( 0 ) ).T
if n_states == 1:
self.A.reshape( (1,1) )
# Initialize observable symbol probability distributions
if 'B' in args:
self.B = args[ 'B' ]
if n_states > 1:
assert numpy.shape( self.B ) == ( self.N, self.M )
else:
self.B = numpy.reshape(self.B, (1,self.M) )
if 'F' in args:
self.F = args[ 'F' ]
for i in self.F.keys():
self.B[ i,: ] = self.F[ i ]
else:
self.F = {}
else:
# initialize distribution
B_raw = numpy.random.uniform( 0, 1, self.N * self.M ).reshape( ( self.N, self.M ) )
self.B = ( B_raw.T / B_raw.T.sum( 0 ) ).T
if 'F' in args:
self.F = args[ 'F' ]
for i in self.F.keys():
self.B[ i,: ] = self.F[ i ]
else:
self.F = {}
# Initialize the intitial state distribution
if 'Pi' in args:
self.Pi = args[ 'Pi' ]
assert len( self.Pi ) == self.N
else:
# initialize to uniform distribution
self.Pi = numpy.array ( 1.0 / self.N ).repeat( self.N )
if 'Labels' in args:
self.Labels = args[ 'Labels' ]
else:
self.Labels = range( self.N )
if 'F' in args:
self.F = args[ 'F' ]
for i in self.F.keys():
self.B[ i,: ] = self.F[ i ]
else:
self.F = {}
def __repr__( self ):
print self.A
retn = ""
retn += "num hiddens: %d\n" % ( self.N ) + \
"symbols: %s\n" % ( self.V ) + \
"\nA:\n %s\n" % ( str( self.A ) ) + \
"Pi:\n %s" % ( str( self.Pi ) )
return retn
def symbol_index( hmm, Obs ):
"""
Converts an obeservation symbol sequence into a sequence
of indices for accessing distribution matrices.
"""
Obs_ind = []
for o in Obs: Obs_ind.append( hmm.symbol_map[ o ] )
return Obs_ind
def forward( hmm, Obs, scaling=True ):
"""
Calculate the probability of an observation sequence, Obs,
given the model, P(Obs|hmm).
Obs: observation sequence
hmm: model
returns: P(Obs|hmm)
"""
T = len( Obs ) # Number of states in observation sequence
# Get index sequence of observation sequence to access
# the observable symbol probabilty distribution matrix
Obs = symbol_index( hmm, Obs )
# create scaling vector
if scaling:
c = numpy.zeros( [ T ], float )
# Base Case:
Alpha = numpy.zeros( [ hmm.N, T ], float )
Alpha[ :,0 ] = hmm.Pi * hmm.B[ :,Obs[ 0 ] ]
if scaling:
if (numpy.sum( Alpha[ :,0 ] ) == 0): #FC added
print 'scaling zero vector in hmm '
c[ 0 ] = 1.0e80
else:
c[ 0 ] = 1.0 / numpy.sum( Alpha[ :,0 ] )
Alpha[ :,0 ] = c[ 0 ] * Alpha[ :,0 ]
# Induction Step:
for t in xrange( 1,T ):
Alpha[ :,t ] = numpy.dot( Alpha[ :,t-1 ], hmm.A) * hmm.B[ :,Obs[ t ] ]
if scaling:
if (numpy.sum( Alpha[ :,t ] ) == 0): #FC added
print 'scaling zero vector in hmm '
c[ t ] = 1.0e80
else:
c[ t ] = 1.0 / numpy.sum( Alpha[ :,t ] )
Alpha[ :,t] = Alpha[ :,t] * c[ t ]
if scaling:
log_Prob_Obs = -( numpy.sum( numpy.log( c ) ) )
return ( log_Prob_Obs, Alpha, c )
else:
prob_Obs = numpy.sum( Alpha[ :,T-1 ] )
return ( prob_Obs, Alpha )
def backward( hmm, Obs, c=None ):
"""
Calculate the probability of a partial observation sequence
from t+1 to T, given some state t.
Obs: observation sequence
hmm: model
c: the scaling coefficients from forward algorithm
returns: B_t(i)
"""
T = len( Obs ) # Number of states in observation sequence
# Get index sequence of observation sequence to access
# the observable symbol probabilty distribution matrix
Obs = symbol_index( hmm, Obs )
# Base Case:
Beta = numpy.zeros( [ hmm.N, T ], float )
Beta[ :, T-1 ] = 1.0
if c is not None:
Beta [ :,T-1 ] = Beta [ :,T-1 ] * c[ T-1 ]
# Inductive Step:
for t in reversed( xrange( T-1 ) ):
Beta[ :,t ] = numpy.dot( hmm.A, ( hmm.B[ :,Obs[ t+1 ] ] * Beta[ :,t+1 ] ) )
if c is not None:
Beta[ :,t ] = Beta[ :,t ] * c[ t ]
return Beta
def viterbi( hmm, Obs, scaling=True ):
"""
Calculate P(Q|Obs, hmm) and yield the state sequence Q* that
maximizes this probability.
Obs: observation sequence
hmm: model
"""
T = len( Obs ) # Number of states in observation sequence
# Get index sequence of observation sequence to access
# the observable symbol probabilty distribution matrix
Obs = symbol_index( hmm, Obs )
# Initialization
# Delta[ i,j ] = max_q1,q2,...,qt P( q1, q2,...,qt = i, O_1, O_2,...,O_t|hmm )
# this is the highest prob along a single path at time t ending in state S_i
Delta = numpy.zeros( [ hmm.N,T ], float)
if scaling:
Delta[ :,0 ] = numpy.log( hmm.Pi ) + numpy.log( hmm.B[ :,Obs[ 0] ] )
else:
Delta[ :,0 ] = hmm.Pi * hmm.B[ :,Obs[ 0] ]
# Track Maximal States
Psi = numpy.zeros( [ hmm.N, T ], int )
# Inductive Step:
if scaling:
for t in xrange( 1,T ):
nus = Delta[ :,t-1 ] + numpy.log( hmm.A )
Delta[ :,t ] = nus.max(1) + numpy.log( hmm.B[ :,Obs[ t ] ] )
Psi[ :,t ] = nus.argmax( 1 )
else:
for t in xrange( 1,T ):
nus = Delta[ :,t-1 ] * hmm.A
Delta[ :,t ] = nus.max( 1 ) * hmm.B[ :,Obs[ t ] ]
Psi[ :,t ] = nus.argmax(1)
# Calculate State Sequence, Q*:
Q_star = [ numpy.argmax( Delta[ :,T-1 ] ) ]
for t in reversed( xrange( T-1 ) ) :
Q_star.insert( 0, Psi[ Q_star[ 0 ],t+1 ] )
return ( Q_star, Delta, Psi )
def baum_welch( hmm, Obs_seqs, **args ):
"""
EM algorithm to update Pi, A, and B for the HMM
:Parameters:
- `hmm` - hmm model to train
- `Obs_seqs` - list of observation sequences to train over
:Return:
a trained hmm
:Keywords:
- `epochs` - number of iterations to perform EM, default is 20
- `val_set` - validation data set, not required but recommended to prevent over-fitting
- `updatePi` - flag to update initial state probabilities
- `updateA` - flag to update transition probabilities, default is True
- `updateB` - flag to update observation emission probabilites for discrete types, default is True
- `scaling` - flag to scale probabilities (log scale), default is True
- `graph` - flag to plot log-likelihoods of the training epochs, default is False
- `normUpdate` - flag to use 1 / -(normed log-likelihood) contribution for each observation
sequence when updating model parameters, default if False
- `fname` - file name to save plot figure, default is ll.eps
- `verbose` - flag to print training times and log likelihoods for each training epoch, default is false
"""
# Setup keywords
if 'epochs' in args: epochs = args[ 'epochs' ]
else: epochs = 20
updatePi=updateA=updateB=scaling=graph = 1
normUpdate=verbose=validating = 0
if 'updatePi' in args: updatePi = args[ 'updatePi' ]
if 'updateA' in args: updateA = args[ 'updateA' ]
if 'updateB' in args: updateB = args[ 'updateB' ]
if 'scaling' in args: scaling = args[ 'scaling' ]
if 'graph' in args: graph = args[ 'graph' ]
if 'normUpdate' in args: normUpdate = args[ 'normUpdate' ]
if 'fname' in args: fname = args[ 'fname' ]
else: fname = 'll.eps'
if 'verbose' in args: verbose = args[ 'verbose' ]
if 'val_set' in args:
validating = 1
val_set = args[ 'val_set' ]
K = len( Obs_seqs ) # number of observation sequences
start = time.time() # start training timer
LLs = [] # keep track of log likelihoods for each epoch
val_LLs = [] # keep track of validation log-likelihoods for each epoch
# store best parameters
best_A = copy.deepcopy( hmm.A )
best_B = copy.deepcopy( hmm.B )
best_Pi = copy.deepcopy( hmm.Pi )
best_epoch = 'N/A'
best_val_LL = None
# Iterate over specified number of EM epochs
for epoch in xrange( epochs ):
start_epoch = time.time() # start epoch timer
LL_epoch = 0 # intialize log-likelihood of all seqs given the model
Expect_si_all = numpy.zeros( [ hmm.N ], float ) # Expectation of being in state i over all seqs
Expect_si_all_TM1 = numpy.zeros( [ hmm.N ], float ) # Expectation of being in state i over all seqs until T-1
Expect_si_sj_all = numpy.zeros( [ hmm.N, hmm.N ], float ) # Expectation of transitioning from state i to state j over all seqs
Expect_si_sj_all_TM1 = numpy.zeros( [ hmm.N, hmm.N ], float )
Expect_si_t0_all = numpy.zeros( [ hmm.N ] ) # Expectation of initially being in state i over all seqs
Expect_si_vk_all = numpy.zeros( [ hmm.N, hmm.M ], float ) # Expectation of being in state i and seeing symbol vk
ow = 0
for Obs in Obs_seqs:
if ow > 0 and ow % 100 == 0:
print "epoch %d: %d seqs processed" % ( epoch+1, ow )
ow += 1
Obs = list( Obs )
log_Prob_Obs, Alpha, c = forward( hmm=hmm, Obs=Obs, scaling=1 ) # Calculate forward probs, log-likelihood, and scaling vals
Beta = backward( hmm=hmm, Obs=Obs, c=c ) # Calculate backward probs
LL_epoch += log_Prob_Obs # Update overall epoch log-likelihood
T = len( Obs ) # Number of states in observation sequence
# Determine update weight of the observation for contribution
# to model parameter maximization
if normUpdate:
w_k = 1.0 / -( log_Prob_Obs + numpy.log( len( Obs ) ) )
else:
w_k = 1.0
# Get index sequence of observation sequence to access
# the observable symbol probabilty distribution matrix
Obs_symbols = Obs[ : ]
Obs = symbol_index( hmm, Obs )
# Calculate gammas
# Gamma[ i,t ] = P( q_t = S_i|Obs, hmm)
Gamma_raw = Alpha * Beta
Gamma = Gamma_raw / Gamma_raw.sum( 0 )
Expect_si_t0_all += w_k * Gamma[ :,0 ]
# Expect_si_all[ i ] = expected number of transitions from state i over all
# training sequences.
Expect_si_all += w_k * Gamma.sum( 1 )
Expect_si_all_TM1 += w_k * Gamma[ :,:T-1 ].sum( 1 )
# Calculate Xis
# Xi is an N X N X T-1 matrix corresponding to
# Xi[ i,j,t ] = P(q_t = S_i, q_t+1 = S_j|Obs, hmm )
Xi = numpy.zeros( [ hmm.N, hmm.N, T-1 ], float )
for t in xrange( T-1 ):
for i in xrange( hmm.N ):
Xi[ i,:,t ] = Alpha[ i,t ] * hmm.A[ i,: ] * hmm.B[ :, Obs[ t+1 ] ] * Beta[ :,t+1 ]
if not scaling:
Xi[ :,:,t ] = Xi[ :,:,t ] / Xi[ :,:,t ].sum()
# Expect_si_sj_all = expected number of transitions from state s_i to state s_j
Expect_si_sj_all += w_k * Xi.sum( 2 ) #which = numpy.array( hmm.V[ k ] == numpy.array( Obs_symbols ) )
Expect_si_sj_all_TM1 += w_k * Xi[ :,:,:T-1].sum( 2 )
if updateB:
B_bar = numpy.zeros( [ hmm.N, hmm.M ], float )
for k in xrange( hmm.M ):
which = numpy.array( [ hmm.V[ k ] == x for x in Obs_symbols ] )
B_bar[ :,k ] = Gamma.T[ which,: ].sum( 0 )
Expect_si_vk_all += w_k * B_bar
############## Reestimate model parameters ###############
# reestimate initial state probabilites
if updatePi:
Expect_si_t0_all = Expect_si_t0_all / numpy.sum( Expect_si_t0_all )
hmm.Pi = Expect_si_t0_all
# reestimate transition probabilites
if updateA:
A_bar = numpy.zeros( [ hmm.N, hmm.N ], float )
for i in xrange( hmm.N ):
A_bar[ i,: ] = Expect_si_sj_all_TM1[ i,: ] / Expect_si_all_TM1[ i ]
hmm.A = A_bar
if updateB:
# reestimate emission probabilites
# ( observable symbol probability distribution )
for i in xrange( hmm.N ):
Expect_si_vk_all[ i,: ] = Expect_si_vk_all [ i,: ] / Expect_si_all[ i ]
hmm.B = Expect_si_vk_all
for i in hmm.F.keys():
hmm.B[ i,: ] = hmm.F[ i ]
LLs.append( LL_epoch )
# Quit if log_likelihoods have plateaued
if epoch > 1:
if LLs[ epoch - 1 ] == LL_epoch:
print "Log-likelihoods have plateaued--terminating training"
break
# if validating, then calculate log-likelihood of validation set
# to determine if training should be terminated.
if validating:
val_LL_epoch = 0
for val_Obs in val_set:
val_Obs = list( val_Obs )
val_LL_epoch += forward( hmm=hmm, Obs=val_Obs, scaling=1 )[ 0 ]
val_LLs.append( val_LL_epoch )
# Terminate training if validation log-likelihood is worse (lower) than
# previous epoch
if epoch > 0:
if val_LL_epoch > best_val_LL:
best_A = copy.deepcopy( hmm.A )
best_B = copy.deepcopy( hmm.B )
best_Pi = copy.deepcopy( hmm.Pi )
best_epoch = epoch
best_val_LL = val_LL_epoch
else:
best_val_LL = val_LL_epoch
best_epoch = 0
if verbose:
print "Finished epoch %d in %d secs" % ( epoch+1, int( time.time() - start_epoch ) ), LL_epoch
if validating:
print "Validation LL: ", val_LLs[ epoch ]
if graph:
if validating:
plt.figure()
plt.subplot( 211 )
plt.title( "Training Reestimation Performance" )
plt.xlabel( "Epochs" )
plt.ylabel( r"$\log( P ( O | \lambda ) )$" )
plt.plot( LLs, label="Training data", color='red' )
plt.subplots_adjust( hspace=0.4 )
plt.subplot( 212 )
plt.title( "Validation Reestimation Performance" )
plt.plot( val_LLs, label="Validation LL", color='blue' )
plt.xlabel( "Epochs" )
plt.ylabel( r"$\log( P ( O | \lambda ) )$" )
plt.axvline( best_epoch, color="black", label="Lowest validation LL", linewidth=2 )
plt.legend( labelsep=0.01, shadow=1 , loc='lower right' )
plt.savefig( fname )
else:
plt.figure()
plt.title( "Training Reestimation Performance" )
plt.xlabel( "Epochs" )
plt.ylabel( r"$\log( P ( O | \lambda ) )$" )
plt.plot( LLs, label="Training data", color='red' )
plt.savefig( fname )
print "Total training time: %d secs" % ( int( time.time() - start ) ), "Best epoch: ", best_epoch
if validating:
hmm.A = best_A
hmm.B = best_B
hmm.Pi = best_Pi
return hmm
###################################################################################
################################ Example ########################################
###################################################################################
#def dishonest_casino_test( graph = True ):
# create transition probability matrix
# A = numpy.array( [ [ 0.95, 0.05],[ 0.05, 0.95 ] ] )
#
# # create observable probability distribution matrix
# B = numpy.array( [ [ 1.0/6, 1.0/6, 1.0/6, 1.0/6, 1.0/6, 1.0/6, ], \
# [ 1.0/10, 1.0/10, 1.0/10, 1.0/10, 1.0/10, 1.0/2 ] ] )
#
# # create set of all observabB = [ (-1,.1), (1,.1) ]
# A = numpy.array( [ [ 0.99, 0.01 ], \
# [ 0.01, 0.99 ] ] )
#
# #le symbols
# V =[1, 2, 3, 4, 5, 6]
#
# # instantiate an hmm, note Pi is uniform probability distribution
# # by default
# hmm = HMM( 2, A=A, B=B, V=V )
#
# # adjust the precision of printing float values
# numpy.set_printoptions( precision=4 )
#
#
# print "\nDishonest Casino Example:\n "
# Obs = [ 1,2,1,6,6 ]
# print hmm
# print
# print '*'*80
# print '*'*80
# print "\nWithout Scaling\n"
# print "\nObservation Sequence: %s\n" % ( Obs )
# prob_Obs, Alpha = forward( hmm, Obs, scaling=0 )
# print '*'*29
# print "* Forward Algorithm Results *"
# print '*'*29 + '\n'
# print "p(Obs|hmm) ~ %.7f" % ( prob_Obs )
#
# print "Alpha's:\n %s\n" % ( Alpha )
# print '*'*80 + '\n'
#
#
# Beta = backward( hmm, Obs )
#
# print '*'*30
# print "* Backward Algorithm Results *"
# print '*'*30 + '\n'
# print "Beta's:\n %s\n" % ( str( Beta ) )
# print '*'*80 + '\n'
#
# Q_star, Delta, Psi = viterbi( hmm, Obs, scaling=0 )
#
# print '*'*29
# print "* Viterbi Algorithm Results *"#Xi[ i,:,t ] = Xi[ i,:,t ] / Xi[ i,:,: ].sum( 1 )
# print '*'*29 + '\n'
# print "Q* = %s\n" % ( Q_star )
# print "Delta's:\n %s\n" % ( Delta )
# print "Psi:\n %s\n" % ( Psi )
# print '*'*80 + '\n'
#
#
# print '*'*80
# print '*'*80
# print "\nWith Scaling\n"
# print "\nObservation Sequence: %s\n" % ( Obs )
# log_prob_Obs, Alpha, c = forward( hmm, Obs, scaling=1 )
# print '*'*29
# print "* Forward Algorithm Results *"
# print '*'*29 + '\n'
# print "p(Obs|hmm) ~ %.7f" % ( numpy.exp( log_prob_Obs ) )
#
# print "Alpha's:\n %s\n" % ( Alpha )
# print '*'*80 + '\n'
#
#
# Beta = backward( hmm, Obs, c )
#
# print '*'*30
# print "* Backward Algorithm Results *"
# print '*'*30 + '\n'
# print "Beta's:\n %s\n" % ( str( Beta ) )
# print '*'*80 + '\n'
#
# Q_star, Delta, Psi = viterbi( hmm, Obs, scaling=1 )
#
# print '*'*29
# print "* Viterbi Algorithm Results *"
# print '*'*29 + '\n'
# print "Q* = %s\n" % ( Q_star )
# print "Delta's:\n %s\n" % ( Delta )
# print "Psi:\n %s\n" % ( Psi )
# print '*'*80 + '\n'
# c = []
# c.append( Obs )
# baum_welch( hmm, c, epochs=15, graph=graph )
###################################################################################
###################################################################################
###################################################################################
#if __name__ == "__main__":
## # run the example, you can turn off graphing by setting it to 0
## X = numpy.random.uniform(0,1,10).reshape( (5,2) )
## print norm_df(X)
# dishonest_casino_test( graph = 1 )
#def runme():
#
#based on Mike's DC example
#transition probabilities
#A = numpy.array( [ [ 0.95, 0.05],[ 0.1, 0.90 ] ] )
#A = numpy.array( [ [.5,.5],[.5,.5]])
#emission probabilities
#B = numpy.array( [ [ 1.0/6, 1.0/6, 1.0/6, 1.0/6, 1.0/6, 1.0/6, ], \
# [ 1.0/10, 1.0/10, 1.0/10, 1.0/10, 1.0/10, 1.0/2 ] ] )
#symbols
#V = [1,2,3,4,5,6]
#model = HMM(2,A=A,B=B,V=V)
#numpy.set_printoptions(precision=5)
| freinque/barbiturythme | barbiturythme/hmm.py | Python | gpl-2.0 | 24,648 | [
"CASINO"
] | 39b4f708d74441a193f2ed387e5de055454ed1f5dcb26f5828e2c416926d5ea8 |
#
# Copyright 2016 The BigDL Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
import itertools
import logging
import pickle
import numpy as np
import ray
from bigdl.dllib.utils.file_utils import enable_multi_fs_load, enable_multi_fs_save
from bigdl.orca.data.ray_xshards import RayXShards
from bigdl.orca.learn.dl_cluster import RayDLCluster
from bigdl.orca.learn.tf2.tf_runner import TFRunner
from bigdl.orca.learn.ray_estimator import Estimator as OrcaRayEstimator
from bigdl.orca.learn.utils import maybe_dataframe_to_xshards, dataframe_to_xshards, \
convert_predict_xshards_to_dataframe, update_predict_xshards, \
process_xshards_of_pandas_dataframe, make_data_creator
from bigdl.orca.data.utils import process_spark_xshards
from bigdl.orca.ray import RayContext
logger = logging.getLogger(__name__)
class TensorFlow2Estimator(OrcaRayEstimator):
def __init__(self,
model_creator,
compile_args_creator=None,
config=None,
verbose=False,
backend="tf2",
workers_per_node=1,
cpu_binding=False):
self.model_creator = model_creator
self.compile_args_creator = compile_args_creator
self.config = {} if config is None else config
self.verbose = verbose
ray_ctx = RayContext.get()
if "batch_size" in self.config:
raise Exception("Please do not specify batch_size in config. Input batch_size in the"
" fit/evaluate function of the estimator instead.")
if "inter_op_parallelism" not in self.config:
self.config["inter_op_parallelism"] = 1
if "intra_op_parallelism" not in self.config:
self.config["intra_op_parallelism"] = ray_ctx.ray_node_cpu_cores // workers_per_node
if backend == "horovod":
assert compile_args_creator is not None, "compile_args_creator should not be None," \
" when backend is set to horovod"
params = {
"model_creator": model_creator,
"compile_args_creator": compile_args_creator,
"config": self.config,
"verbose": self.verbose,
}
if backend == "tf2":
cores_per_node = ray_ctx.ray_node_cpu_cores // workers_per_node
num_nodes = ray_ctx.num_ray_nodes * workers_per_node
self.cluster = RayDLCluster(
num_workers=num_nodes,
worker_cores=cores_per_node,
worker_cls=TFRunner,
worker_param=params,
cpu_binding=cpu_binding
)
self.remote_workers = self.cluster.get_workers()
ips = ray.get(
[worker.get_node_ip.remote() for worker in self.remote_workers])
ports = ray.get(
[worker.find_free_port.remote() for worker in self.remote_workers])
urls = ["{ip}:{port}".format(ip=ips[i], port=ports[i])
for i in range(len(self.remote_workers))]
ray.get([worker.setup.remote() for worker in self.remote_workers])
# Get setup tasks in order to throw errors on failure
ray.get([
worker.setup_distributed.remote(urls, i, len(self.remote_workers))
for i, worker in enumerate(self.remote_workers)])
elif backend == "horovod":
# it is necessary to call self.run first to set horovod environment
from bigdl.orca.learn.horovod.horovod_ray_runner import HorovodRayRunner
horovod_runner = HorovodRayRunner(ray_ctx,
worker_cls=TFRunner,
worker_param=params,
workers_per_node=workers_per_node)
horovod_runner.run(lambda: print("worker initialized"))
self.remote_workers = horovod_runner.remote_workers
ray.get([worker.setup.remote() for worker in self.remote_workers])
ray.get([
worker.setup_horovod.remote()
for i, worker in enumerate(self.remote_workers)])
else:
raise Exception("Only \"tf2\" and \"horovod\" are legal "
"values of backend, but got {}".format(backend))
self.num_workers = len(self.remote_workers)
def fit(self, data, epochs=1, batch_size=32, verbose=1,
callbacks=None, validation_data=None, class_weight=None,
steps_per_epoch=None, validation_steps=None, validation_freq=1,
data_config=None, feature_cols=None,
label_cols=None):
"""
Train this tensorflow model with train data.
:param data: train data. It can be XShards, Spark DataFrame or creator function which
returns Iter or DataLoader.
If data is XShards, each partition can be a Pandas DataFrame or a dictionary of
{'x': feature, 'y': label}, where feature(label) is a numpy array or a tuple of
numpy arrays.
:param epochs: Number of epochs to train the model. Default: 1.
:param batch_size: Batch size used for training. Default: 32.
:param verbose: Prints output of one model if true.
:param callbacks: List of Keras compatible callbacks to apply during training.
:param validation_data: validation data. Validation data type should be the same
as train data.
:param class_weight: Optional dictionary mapping class indices (integers) to a weight
(float) value, used for weighting the loss function. This can be useful to tell
the model to "pay more attention" to samples from an under-represented class.
:param steps_per_epoch: Total number of steps (batches of samples) before declaring one
epoch finished and starting the next epoch. If `steps_pre_epoch` is `None`, the
epoch will run until the input dataset is exhausted. When passing an infinitely
repeating dataset, you must specify the `step_per_epoch` argument.
:param validation_steps: Total number of steps (batches of samples) to draw before stopping
when performing validation at the end of every epoch. Default: None.
:param validation_freq: Only relevant if validation data is provided. Integer of
`collections_abc.Container` instance (e.g. list, tuple, etc.). If an integer,
specifies how many training epochs to run before a new validation run is performed,
e.g. `validation_freq=2` runs validation every 2 epochs. If a Container, specifies
the epochs on which to run validation, e.g. `validation_freq=[1, 2, 10]` runs
validation at the end of the 1st, 2nd, and 10th epochs.
:param data_config: An optional dictionary that can be passed to data creator function.
:param feature_cols: Feature column name(s) of data. Only used when data is a Spark
DataFrame or an XShards of Pandas DataFrame. Default: None.
:param label_cols: Label column name(s) of data. Only used when data is a Spark DataFrame or
an XShards of Pandas DataFrame.
Default: None.
:return:
"""
params = dict(
epochs=epochs,
batch_size=batch_size,
verbose=verbose,
callbacks=callbacks,
class_weight=class_weight,
steps_per_epoch=steps_per_epoch,
validation_steps=validation_steps,
validation_freq=validation_freq,
data_config=data_config
)
from bigdl.orca.data import SparkXShards
data, validation_data = maybe_dataframe_to_xshards(data, validation_data,
feature_cols, label_cols,
mode="fit",
num_workers=self.num_workers,
accept_str_col=True)
if isinstance(data, SparkXShards):
if data._get_class_name() == 'pandas.core.frame.DataFrame':
data, validation_data = process_xshards_of_pandas_dataframe(data, feature_cols,
label_cols,
validation_data, "fit")
ray_xshards = process_spark_xshards(data, self.num_workers)
if validation_data is None:
def transform_func(worker, partition_refs):
params["data_creator"] = make_data_creator(partition_refs)
return worker.step.remote(**params)
worker_stats = ray_xshards.reduce_partitions_for_actors(self.remote_workers,
transform_func)
else:
val_ray_xshards = process_spark_xshards(validation_data, self.num_workers)
def zip_func(worker, this_partition_refs, that_partition_refs):
params["data_creator"] = make_data_creator(this_partition_refs)
params["validation_data_creator"] = \
make_data_creator(that_partition_refs)
return worker.step.remote(**params)
worker_stats = ray_xshards.zip_reduce_shards_with_actors(val_ray_xshards,
self.remote_workers,
zip_func)
else:
params["data_creator"] = data
params["validation_data_creator"] = validation_data
params_list = [params] * self.num_workers
worker_stats = ray.get([self.remote_workers[i].step.remote(**params_list[i])
for i in range(self.num_workers)])
worker_stats = list(itertools.chain.from_iterable(worker_stats))
stats = worker_stats[0].copy()
return stats
def evaluate(self, data, batch_size=32, num_steps=None, verbose=1,
sample_weight=None, callbacks=None, data_config=None,
feature_cols=None, label_cols=None):
"""
Evaluates the model on the validation data set.
:param data: evaluate data. It can be XShards, Spark DataFrame or creator function which
returns Iter or DataLoader.
If data is XShards, each partition can be a Pandas DataFrame or a dictionary of
{'x': feature, 'y': label}, where feature(label) is a numpy array or a tuple of
numpy arrays.
:param batch_size: Batch size used for evaluation. Default: 32.
:param num_steps: Total number of steps (batches of samples) before declaring the evaluation
round finished. Ignored with the default value of `None`.
:param verbose: Prints output of one model if true.
:param sample_weight: Optional Numpy array of weights for the training samples, used for
weighting the loss function. You can either pass a flat (1D) Numpy array with the
same length as the input samples (1:1 mapping between weights and samples), or in
the case of temporal data, you can pass a 2D array with shape (samples,
sequence_length), to apply a different weight to every timestep of every sample.
:param callbacks: List of Keras compatible callbacks to apply during evaluation.
:param data_config: An optional dictionary that can be passed to data creator function.
:param feature_cols: Feature column name(s) of data. Only used when data is a Spark
DataFrame or an XShards of Pandas DataFrame. Default: None.
:param label_cols: Label column name(s) of data. Only used when data is a Spark DataFrame or
an XShards of Pandas DataFrame.
Default: None.
:return: validation result
"""
logger.info("Starting validation step.")
params = dict(
batch_size=batch_size,
verbose=verbose,
sample_weight=sample_weight,
steps=num_steps,
callbacks=callbacks,
data_config=data_config,
)
from bigdl.orca.data import SparkXShards
data, _ = maybe_dataframe_to_xshards(data,
validation_data=None,
feature_cols=feature_cols,
label_cols=label_cols,
mode="evaluate",
num_workers=self.num_workers,
accept_str_col=True)
if isinstance(data, SparkXShards):
if data._get_class_name() == 'pandas.core.frame.DataFrame':
data = process_xshards_of_pandas_dataframe(data, feature_cols, label_cols)
data = data
if data.num_partitions() != self.num_workers:
data = data.repartition(self.num_workers)
ray_xshards = RayXShards.from_spark_xshards(data)
def transform_func(worker, partition_refs):
params["data_creator"] = make_data_creator(partition_refs)
return worker.validate.remote(**params)
worker_stats = ray_xshards.reduce_partitions_for_actors(self.remote_workers,
transform_func)
else: # data_creator functions; should return Iter or DataLoader
params["data_creator"] = data
params_list = [params] * self.num_workers
worker_stats = ray.get([w.validate.remote(**params_list[i])
for i, w in enumerate(self.remote_workers)])
worker_stats = list(itertools.chain.from_iterable(worker_stats))
stats = worker_stats[0].copy()
return stats
def _predict_spark_xshards(self, xshards, params):
ray_xshards = RayXShards.from_spark_xshards(xshards)
def transform_func(worker, shards_ref):
params["data_creator"] = make_data_creator(shards_ref)
return worker.predict.remote(**params)
pred_shards = ray_xshards.transform_shards_with_actors(self.remote_workers,
transform_func)
spark_xshards = pred_shards.to_spark_xshards()
return spark_xshards
def predict(self, data, batch_size=None, verbose=1,
steps=None, callbacks=None, data_config=None,
feature_cols=None):
"""
Predict the input data
:param data: predict input data. It can be XShards or Spark DataFrame.
If data is XShards, each partition can be a Pandas DataFrame or a dictionary of
{'x': feature}, where feature is a numpy array or a tuple of numpy arrays.
:param batch_size: Batch size used for inference. Default: None.
:param verbose: Prints output of one model if true.
:param steps: Total number of steps (batches of samples) before declaring the prediction
round finished. Ignored with the default value of None.
:param callbacks: List of Keras compatible callbacks to apply during prediction.
:param data_config: An optional dictionary that can be passed to data creator function.
:param feature_cols: Feature column name(s) of data. Only used when data is a Spark
DataFrame or an XShards of Pandas DataFrame. Default: None.
:return:
"""
logger.info("Starting predict step.")
params = dict(
verbose=verbose,
batch_size=batch_size,
steps=steps,
callbacks=callbacks,
data_config=data_config,
)
from bigdl.orca.data import SparkXShards
from pyspark.sql import DataFrame
if isinstance(data, DataFrame):
xshards, _ = dataframe_to_xshards(data,
validation_data=None,
feature_cols=feature_cols,
label_cols=None,
mode="predict",
accept_str_col=True)
pred_shards = self._predict_spark_xshards(xshards, params)
result = convert_predict_xshards_to_dataframe(data, pred_shards)
elif isinstance(data, SparkXShards):
if data._get_class_name() == 'pandas.core.frame.DataFrame':
data = process_xshards_of_pandas_dataframe(data, feature_cols)
pred_shards = self._predict_spark_xshards(data, params)
result = update_predict_xshards(data, pred_shards)
else:
raise ValueError("Only xshards or Spark DataFrame is supported for predict")
return result
def get_model(self):
"""
Returns the learned model.
:return: the learned model.
"""
state_refs = [w.get_state.remote() for w in self.remote_workers]
state = ray.get(state_refs[0])
return self._get_model_from_state(state)
@enable_multi_fs_save
def save(self, checkpoint):
"""
Saves the model at the provided checkpoint.
:param checkpoint: (str) Path to the target checkpoint file.
"""
# Some model might need to aggregate variables during checkpointing
# which requires both the chief and workers to participate in the
# allreduce communication protocol.
# So we need to call get_state on every remote workers, otherwise
# it might get stuck
state_refs = [w.get_state.remote() for w in self.remote_workers]
state = ray.get(state_refs[0])
with open(checkpoint, "wb") as f:
pickle.dump(state, f)
return checkpoint
@enable_multi_fs_load
def load(self, checkpoint, **kwargs):
"""
Loads the model from the provided checkpoint.
:param checkpoint: (str) Path to target checkpoint file.
"""
with open(checkpoint, "rb") as f:
state = pickle.load(f)
state_id = ray.put(state)
ray.get([worker.set_state.remote(state_id) for worker in self.remote_workers])
def shutdown(self):
"""
Shuts down workers and releases resources.
"""
for worker in self.remote_workers:
worker.shutdown.remote()
worker.__ray_terminate__.remote()
def _get_model_from_state(self, state):
"""Creates model and load weights from state"""
# keep the same behavior as `set_state` in `load` do
model = self.model_creator(self.config)
model.set_weights(state["weights"])
return model
| intel-analytics/BigDL | python/orca/src/bigdl/orca/learn/tf2/ray_estimator.py | Python | apache-2.0 | 19,777 | [
"ORCA"
] | 70e7070d0f57c88de1805c2abbce365b5f5ecde16a3cc2756445eeebbb8f9abf |
# Standard Library
import os
import shutil
import subprocess
from pathlib import Path
# BioPython
from Bio import SeqIO
from Bio.Align.Applications import ClustalOmegaCommandline
# OrthoEvol
from OrthoEvol.Tools.logit import LogIt
from OrthoEvol.utilities import FullUtilities
from OrthoEvol.Orthologs.GenBank import GenBank
from OrthoEvol.Orthologs.Align.pal2nal import Pal2NalCommandline
from OrthoEvol.Orthologs.Align.guidance2 import Guidance2Commandline
from OrthoEvol.Orthologs.Align.orthoclustal import ClustalO
class MultipleSequenceAlignment(object):
"""The MultipleSequenceAlignment (MSA) class uses the standard configuration
along with function dispatching to give the end-user access to multiple
alignment tools."""
def __init__(self, project=None, project_path=os.getcwd(), genbank=GenBank, **kwargs):
"""Initialize the MultipleSequenceAlignment class.
:param project: The project name.
:param project_path: The path to the project.
:param genbank: The composer parameter which is used to configure the
GenBank class with the MSA class.
:param kwargs: The kwargs are used with the dispatcher as a way to
control the alignment pipeline.
:returns: If the kwargs are utilized with YAML or other
configurations, then this class returns an alignment
dictionary, which can be parsed to run specific alignment algorithms.
"""
self.dispatcher_options = {"Guidance_config": ["GUIDANCE2", self.guidance2],
"Pal2Nal_config": ["PAL2NAL", self.pal2nal],
"ClustalO_config": ["CLUSTALO", self.clustalo]}
# Set up loggers
__log = LogIt()
__logfile = None
self.guidancelog = __log.default('guidance2', __logfile)
self.pal2nallog = __log.default('pal2nal', __logfile)
self.clustalolog = __log.default('clustalo', __logfile)
# Initialize Utilities
self.msa_utils = FullUtilities()
# stop_codons = ['TAG', 'TAA', 'TGA']
self.program = None
self.alignment_dict = {}
self.project = project
self.project_path = project_path
if project_path and project:
self.project_path = Path(project_path) / Path(project)
# Configuration of class attributes
add_self = self.msa_utils.attribute_config(self, composer=genbank, checker=GenBank, project=project, project_path=project_path)
for var, attr in add_self.__dict__.items():
setattr(self, var, attr)
# Determine which alignment to configure
# And then run that alignment with the configuration.
for config in self.dispatcher_options.keys():
if config in kwargs.keys():
program = self.dispatcher_options[config][0]
aligner = self.dispatcher_options[config][1]
aligner_configuration = kwargs[config]
self.alignment_dict[program] = [aligner, aligner_configuration]
def guidance2(self, seqFile, msaProgram, seqType, dataset='MSA', seqFilter=None, columnFilter=None, maskFilter=None, **kwargs):
"""Run the GUIDANCE2 command line wrapper from BioPython.
The Guidance2 algorithm is used to filter sequence alignments in
different ways. Here we employ a few of our own strategies on top of
Guidance2.
:param seqFile: The sequence file required by GUIDANCE2.
:param msaProgram: The msa program to be used by GUIDANCE2.
("CLUSTALW", "PRANK", "MAFFT", or "MUSCLE")
:param seqType: The type of sequences to be aligned in GUIDANCE2.
("aa", "nuc", or "codon")
:param dataset: The name of the dataset, which is used for file
naming convention among other things in GUIDANCE2.
:param seqFilter: The sequence filter parameter is None, "inclusive",
or "exclusive". If inclusive the SeqCutoff
decreases for every iteration. If exclusive the
SeqCutoff increases for every iteration, and so the
algorithm excludes more genes from the alignment.
(An OrthoEvol strategy)
:param columnFilter: The column filter removes columns from the
alignment using GUIDANCE2.
:param maskFilter: The mask filter uses GUIDANCE2 maskLowScoresResidue
script to mask the low scoring residues.
:param kwargs: The kwargs are used to configure GUIDANCE2 with
specific parameters including seqCutoff and colCutoff.
It can also be used to set the number of iterations and
the increment number, which controls how seqCutoff and
colCutoff change for each iteration.
:return: Returns Guidance2 files.
"""
self.guidancelog.info("Guidance2 will be used.")
# Name and Create the output directory
self.program = "GUIDANCE2"
outDir = self.program
gene = Path(seqFile).stem
geneDir = self.raw_data / Path(gene)
self.guidancelog.info(geneDir)
if seqType == 'nuc':
g2_seqFile = str(geneDir / Path(gene + '_G2.ffn')) # Need for all iterations
rem_file = str(geneDir / Path(gene + '_G2_removed.ffn')) # Need for all iterations
g2_alnFile = str(geneDir / Path(gene + '_G2_na.aln'))
g2_seqcolFilter = str(geneDir / Path(gene + 'G2sfcf_na.aln'))
g2_colFilter = str(geneDir / Path(gene + '_G2cf_na.aln'))
g2_maskedFile = str(geneDir / Path(gene + '_G2mf_na.aln'))
elif seqType == 'aa':
g2_seqFile = str(geneDir / Path(gene + '_G2.faa')) # Need for all iterations
rem_file = str(geneDir / Path(gene + '_G2_removed.faa')) # Need for all iterations
g2_alnFile = str(geneDir / Path(gene + '_G2_aa.aln'))
g2_colFilter = str(geneDir / Path(gene + '_G2cf_aa.aln'))
g2_maskedFile = str(geneDir / Path(gene + '_G2mf_aa.aln'))
# Add the Guidance 2 cutoffs to the keyword arguments
if 'seqCutoff' not in kwargs.keys():
kwargs['seqCutoff'] = 0.6
if 'colCutoff' not in kwargs.keys():
kwargs['colCutoff'] = 0.93
# Filter Sequences, and then either remove columns, mask residues or do nothing
if seqFilter is not None:
# Filter "bad" sequences and iterate over the good ones until the cutoff is reached.
iterFlag = True
iteration = 0
while iterFlag is True:
set_iter = kwargs['iterations']
iteration += 1
# Create paths for output files
if columnFilter is not None:
outDir = self.raw_data / Path(gene) / Path(outDir + '_sf_cf')
elif maskFilter is not None:
outDir = self.raw_data / Path(gene) / Path(outDir + '_sf_mf')
else:
outDir = self.raw_data / Path(gene) / Path(outDir + '_sf')
Path.mkdir(outDir, parents=True, exist_ok=True)
iterDir = Path(outDir) / Path('iter_%s' % iteration)
g2_rem_file = str(iterDir / Path('Seqs.Orig.fas.FIXED.Removed_Seq.With_Names')) # Need for all iterations
Path.mkdir(iterDir, parents=True, exist_ok=True)
# Create files for masking
if maskFilter is not None:
g2_aln2mask = str(iterDir / Path('%s.%s.aln.With_Names' % (dataset, msaProgram)))
g2_rprScores = str(iterDir / Path('%s.%s.Guidance2_res_pair_res.scr' % (dataset, msaProgram)))
if iteration == 1:
# seqFile is the given input
G2Cmd = Guidance2Commandline(seqFile=seqFile, msaProgram=msaProgram, seqType=seqType,
outDir=str(iterDir), **kwargs)
self.guidancelog.info(G2Cmd)
subprocess.check_call([str(G2Cmd)], stderr=subprocess.STDOUT, shell=True)
# Copy the Guidance removed seq file and paste it to the home directory
# Creates the rem_file
# Files without any removed don't have the file *.With_Names
if os.path.isfile(g2_rem_file) is False:
g2_rem_file = str(iterDir / Path('Seqs.Orig.fas.FIXED.Removed_Seq'))
SeqIO.write(SeqIO.parse(g2_rem_file, 'fasta'), rem_file, 'fasta') # Need for iter_1
# Filter the input NA fasta file using Guidance output
# Creates the g2_seqFile
self.msa_utils.multi_fasta_manipulator(seqFile, g2_rem_file, g2_seqFile, manipulation='remove') # Do after copying (iter_1) or adding (iter_n)
iterFlag = True
elif set_iter >= iteration > 1:
# Depending on the filter strategy increment the seqCutoff
if seqFilter == "inclusive":
kwargs['seqCutoff'] -= kwargs['increment']
elif seqFilter == "exclusive":
kwargs['seqCutoff'] += kwargs['increment']
# seqFile changes to g2_seqFile and the cutoffs change
G2Cmd = Guidance2Commandline(seqFile=g2_seqFile, msaProgram=msaProgram, seqType=seqType,
outDir=str(iterDir), **kwargs)
self.guidancelog.info(G2Cmd)
subprocess.check_call([str(G2Cmd)], stderr=subprocess.STDOUT, shell=True)
# Get the removed sequence count
rem_count = 0
# Files without any removed don't have the file *.With_Names
if os.path.isfile(g2_rem_file) is False:
g2_rem_file = str(Path(iterDir) / Path('Seqs.Orig.fas.FIXED.Removed_Seq'))
for rec in SeqIO.parse(g2_rem_file, 'fasta'): # Need for all iterations
rem_count += 1
# If sequences are removed, then iterate again on the "good" sequences
if rem_count > 0:
# Add new sequences to the rem_file
self.msa_utils.multi_fasta_manipulator(rem_file, g2_rem_file, rem_file, manipulation='add')
# Filter the input fasta file using the updated rem_file
self.msa_utils.multi_fasta_manipulator(seqFile, rem_file, g2_seqFile, manipulation='remove')
iterFlag = True
# If sequences aren't removed, then stop iterating
if rem_count < 0 or set_iter == iteration:
filtered_alignment = Path(iterDir) / Path('%s.%s.aln.Sorted.With_Names' % (dataset, msaProgram))
renamed_alignment = shutil.copy(str(filtered_alignment), g2_alnFile)
self.msa_utils.multi_fasta_manipulator(str(renamed_alignment), str(seqFile), str(renamed_alignment), manipulation='sort')
iterFlag = False
if columnFilter is not None:
col_filt_align = iterDir / Path('%s.%s.Without_low_SP_Col.With_Names' % (dataset, msaProgram))
shutil.copy(str(col_filt_align), g2_seqcolFilter)
elif maskFilter is not None:
G2Cmd = Guidance2Commandline(align=False, seqFile=seqFile, msaProgram=msaProgram, seqType=seqType,
outDir=str(iterDir), maskCutoff=maskFilter, maskFile=g2_aln2mask,
rprScores=g2_rprScores, output=g2_maskedFile, **kwargs)
self.alignmentlog.info(G2Cmd)
subprocess.check_call([str(G2Cmd)], stderr=subprocess.STDOUT, shell=True)
self.msa_utils.multi_fasta_manipulator(g2_maskedFile, str(seqFile), g2_maskedFile, manipulation='sort')
# Only COLUMN FILTER the bad columns
elif columnFilter is not None:
outDir = self.raw_data / Path(gene) / Path(outDir + '_cf')
Path.mkdir(outDir, parents=True, exist_ok=True)
G2Cmd = Guidance2Commandline(seqFile=seqFile, msaProgram=msaProgram, seqType=seqType,
outDir=str(outDir), **kwargs)
self.guidancelog.info(G2Cmd)
subprocess.check_call([str(G2Cmd)], stderr=subprocess.STDOUT, shell=True)
col_filt_align = outDir / Path('%s.%s.Without_low_SP_Col.With_Names' % (dataset, msaProgram))
shutil.copy(str(col_filt_align), g2_colFilter)
# Only MASK the bad residues
elif maskFilter is not None:
outDir = self.raw_data / Path(gene) / Path(outDir + '_sf')
G2Cmd = Guidance2Commandline(seqFile=seqFile, msaProgram=msaProgram, seqType=seqType,
outDir=str(outDir), maskCutoff=maskFilter, maskFile=kwargs['aln2mask'],
rprScores=kwargs['rprScores'], output=kwargs['maskedFile'], **kwargs)
self.guidancelog.info(G2Cmd)
subprocess.check_call([str(G2Cmd)], stderr=subprocess.STDOUT, shell=True)
self.msa_utils.multi_fasta_manipulator(kwargs['maskedFile'], str(seqFile), kwargs['maskedFile'], manipulation='sort')
def pal2nal(self, aa_alignment, na_fasta, output_type='paml', nogap=True, nomismatch=True, downstream='paml'):
"""This Pal2Nal method works with the Pal2Nal command line wrapper.
It uses a protein alignment to generate a codon alignment from the
corresponding nucleic acid sequences. This is useful for downstream
PAML analysis. This function also catches and removes taxa that are
inconsistent with Pal2Nal's algorithm.
:param aa_alignment: An amino acid alignment that is used as a guide
for a nucleic acid alignment.
:param na_fasta: The FASTA file that contains matching/ordered
sequences corresponding to the aa_alignment.
:param output_type: The format of the resulting alignment.
("clustal", "paml", "fasta", "codon")
:param nogap: Removes the gaps and in-frame stop codons from the
alignment to work better with PAML.
:param nomismatch: Removes mismatched codons between protein and DNA
sequences.
:param downstream: Used as a naming convention for a better and more
obvious pipeline.
:return: A codon alignment.
"""
removed = []
# Create output directory for PAL2NAL
outDir = 'PAL2NAL'
gene = Path(na_fasta).stem
geneDir = self.raw_data / Path(gene)
outDir = geneDir / Path(outDir)
Path.mkdir(outDir, exist_ok=True)
# Name the output file using the gene and the downstream application
output_file = str(geneDir / Path(gene + '_P2N.%s.aln' % downstream))
# Create an alignment
P2Ncmd = Pal2NalCommandline(pepaln=aa_alignment, nucfasta=na_fasta, output_file=output_file, output=output_type,
nogap=nogap, nomismatch=nomismatch)
self.pal2nallog.info(P2Ncmd)
# Use a while loop to catch errors and remove sequences that aren't working with pal2nal
pal2nal_flag = True
while pal2nal_flag is True:
pal2nal = subprocess.Popen([str(P2Ncmd)], stderr=subprocess.PIPE,
stdout=subprocess.PIPE, shell=True,
encoding='utf-8')
error = pal2nal.stderr.readlines()
out = pal2nal.stdout.readlines()
pal2nal.wait()
# Catch errors
if 'ERROR: inconsistency between the following pep and nuc seqs' in error[0]:
self.pal2nallog.warning('Caught the pal2nal error!')
self.pal2nallog.warning(error[0])
for err in error:
if '>' in err:
removed.append(err.strip('>' '\n'))
self.msa_utils.multi_fasta_manipulator(na_fasta, removed, na_fasta)
self.msa_utils.multi_fasta_manipulator(aa_alignment, removed, aa_alignment)
# If no errors then break the while loop
else:
if removed is not None:
# If any sequences were removed then write them to a file.
p2n_remFile = str(geneDir / Path(gene + '_P2N_removed.txt'))
with open(p2n_remFile, 'w') as p2n_rem:
for name in removed:
p2n_rem.write(name)
pal2nal_flag = False
self.pal2nallog.info('Error: ' + str(error))
self.pal2nallog.info('Out: ' + str(out))
def clustalo(self, infile, outfile, outfmt="fasta"):
"""Align protein/amino acid sequences using Clustal Omega.
:param infile: Input a multifasta protein file.
:param outfile: Output an aligned multifasta file.
:param outfmt: (Default value = "fasta")
"""
try:
clustalo = ClustalO(infile=infile, outfile=outfile, outfmt=outfmt)
clustalo.runclustalomega()
except Exception:
pass
| datasnakes/Datasnakes-Scripts | OrthoEvol/Orthologs/Align/msa.py | Python | mit | 17,737 | [
"Biopython"
] | c950a3f13483002e89d82c24deac5a532fb345a196fcaa71b945aa1dd95bd09e |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# Flask React SPA documentation build configuration file, created by
# sphinx-quickstart on Thu Sep 7 06:48:34 2017.
#
# This file is execfile()d with the current directory set to its
# containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.
import os
import sys
import guzzle_sphinx_theme
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
sys.path.insert(0, os.path.abspath('..'))
# -- General configuration ------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
#
# needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = [
'sphinx.ext.autodoc',
'sphinx.ext.intersphinx',
'sphinx.ext.viewcode',
'sphinx.ext.githubpages',
'sphinx_click.ext',
'guzzle_sphinx_theme',
]
autodoc_member_order = 'bysource'
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# The suffix(es) of source filenames.
# You can specify multiple suffix as a list of string:
#
# source_suffix = ['.rst', '.md']
source_suffix = '.rst'
# The master toctree document.
master_doc = 'index'
# General information about the project.
project = 'Flask React SPA'
copyright = '2017 Brian Cappello'
author = 'Brian Cappello'
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
version = '0.1'
# The full version, including alpha/beta/rc tags.
release = '0.1.0'
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#
# This is also used if you do content translation via gettext catalogs.
# Usually you set "language" from the command line for these cases.
language = None
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
# This patterns also effect to html_static_path and html_extra_path
exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'
# If true, `todo` and `todoList` produce output, else they produce nothing.
todo_include_todos = False
# -- Options for HTML output ----------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
html_theme_path = guzzle_sphinx_theme.html_theme_path()
html_theme = 'guzzle_sphinx_theme'
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
#
html_theme_options = {
'project_nav_name': 'Flask React SPA',
'projectlink': 'https://github.com/briancappello/flask-react-spa',
}
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static']
# Custom sidebar templates, must be a dictionary that maps document names
# to template names.
html_sidebars = {
'**': [
'logo-text.html',
'about.html',
'globaltoc.html',
'searchbox.html',
'github.html',
]
}
# -- Options for HTMLHelp output ------------------------------------------
# Output file base name for HTML help builder.
htmlhelp_basename = 'FlaskReactSPAdoc'
# -- Options for LaTeX output ---------------------------------------------
latex_elements = {
# The paper size ('letterpaper' or 'a4paper').
#
# 'papersize': 'letterpaper',
# The font size ('10pt', '11pt' or '12pt').
#
# 'pointsize': '10pt',
# Additional stuff for the LaTeX preamble.
#
# 'preamble': '',
# Latex figure (float) alignment
#
# 'figure_align': 'htbp',
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title,
# author, documentclass [howto, manual, or own class]).
latex_documents = [
(master_doc, 'FlaskReactSPA.tex', 'Flask React SPA Documentation',
'Brian Cappello', 'manual'),
]
# -- Options for manual page output ---------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
(master_doc, 'flaskreactspa', 'Flask React SPA Documentation',
[author], 1)
]
# -- Options for Texinfo output -------------------------------------------
# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
# dir menu entry, description, category)
texinfo_documents = [
(master_doc, 'FlaskReactSPA', 'Flask React SPA Documentation',
author, 'FlaskReactSPA', 'One line description of project.',
'Miscellaneous'),
]
# Example configuration for intersphinx: refer to the Python standard library.
intersphinx_mapping = {'https://docs.python.org/': None}
| briancappello/flask-react-spa | docs/conf.py | Python | mit | 5,584 | [
"Brian"
] | 0bc0e94775cbc3625eb99f15efd6da2bdab967baf66b09081f02d0505e90f41a |
# $Id$
#
# Copyright (C) 2002-2008 greg Landrum and Rational Discovery LLC
#
# @@ All Rights Reserved @@
# This file is part of the RDKit.
# The contents are covered by the terms of the BSD license
# which is included in the file license.txt, found at the root
# of the RDKit source tree.
#
""" command line utility to report on the contributions of descriptors to
tree-based composite models
Usage: AnalyzeComposite [optional args] <models>
<models>: file name(s) of pickled composite model(s)
(this is the name of the db table if using a database)
Optional Arguments:
-n number: the number of levels of each model to consider
-d dbname: the database from which to read the models
-N Note: the note string to search for to pull models from the database
-v: be verbose whilst screening
"""
import sys
import numpy
from rdkit.Dbase.DbConnection import DbConnect
from rdkit.ML import ScreenComposite
from rdkit.ML.Data import Stats
from rdkit.ML.DecTree import TreeUtils, Tree
import pickle
__VERSION_STRING = "2.2.0"
def ProcessIt(composites, nToConsider=3, verbose=0):
composite = composites[0]
nComposites = len(composites)
ns = composite.GetDescriptorNames()
# nDesc = len(ns)-2
if len(ns) > 2:
globalRes = {}
nDone = 1
descNames = {}
for composite in composites:
if verbose > 0:
print('#------------------------------------')
print('Doing: ', nDone)
nModels = len(composite)
nDone += 1
res = {}
for i in range(len(composite)):
model = composite.GetModel(i)
if isinstance(model, Tree.TreeNode):
levels = TreeUtils.CollectLabelLevels(model, {}, 0, nToConsider)
TreeUtils.CollectDescriptorNames(model, descNames, 0, nToConsider)
for descId in levels.keys():
v = res.get(descId, numpy.zeros(nToConsider, numpy.float))
v[levels[descId]] += 1. / nModels
res[descId] = v
for k in res:
v = globalRes.get(k, numpy.zeros(nToConsider, numpy.float))
v += res[k] / nComposites
globalRes[k] = v
if verbose > 0:
for k in res.keys():
name = descNames[k]
strRes = ', '.join(['%4.2f' % x for x in res[k]])
print('%s,%s,%5.4f' % (name, strRes, sum(res[k])))
print()
if verbose >= 0:
print('# Average Descriptor Positions')
retVal = []
for k in globalRes:
name = descNames[k]
if verbose >= 0:
strRes = ', '.join(['%4.2f' % x for x in globalRes[k]])
print('%s,%s,%5.4f' % (name, strRes, sum(globalRes[k])))
tmp = [name]
tmp.extend(globalRes[k])
tmp.append(sum(globalRes[k]))
retVal.append(tmp)
if verbose >= 0:
print()
else:
retVal = []
return retVal
def ErrorStats(conn, where, enrich=1):
fields = ('overall_error,holdout_error,overall_result_matrix,' +
'holdout_result_matrix,overall_correct_conf,overall_incorrect_conf,' +
'holdout_correct_conf,holdout_incorrect_conf')
try:
data = conn.GetData(fields=fields, where=where)
except Exception:
import traceback
traceback.print_exc()
return None
nPts = len(data)
if not nPts:
sys.stderr.write('no runs found\n')
return None
overall = numpy.zeros(nPts, numpy.float)
overallEnrich = numpy.zeros(nPts, numpy.float)
oCorConf = 0.0
oInCorConf = 0.0
holdout = numpy.zeros(nPts, numpy.float)
holdoutEnrich = numpy.zeros(nPts, numpy.float)
hCorConf = 0.0
hInCorConf = 0.0
overallMatrix = None
holdoutMatrix = None
for i in range(nPts):
if data[i][0] is not None:
overall[i] = data[i][0]
oCorConf += data[i][4]
oInCorConf += data[i][5]
if data[i][1] is not None:
holdout[i] = data[i][1]
haveHoldout = 1
else:
haveHoldout = 0
tmpOverall = 1. * eval(data[i][2])
if enrich >= 0:
overallEnrich[i] = ScreenComposite.CalcEnrichment(tmpOverall, tgt=enrich)
if haveHoldout:
tmpHoldout = 1. * eval(data[i][3])
if enrich >= 0:
holdoutEnrich[i] = ScreenComposite.CalcEnrichment(tmpHoldout, tgt=enrich)
if overallMatrix is None:
if data[i][2] is not None:
overallMatrix = tmpOverall
if haveHoldout and data[i][3] is not None:
holdoutMatrix = tmpHoldout
else:
overallMatrix += tmpOverall
if haveHoldout:
holdoutMatrix += tmpHoldout
if haveHoldout:
hCorConf += data[i][6]
hInCorConf += data[i][7]
avgOverall = sum(overall) / nPts
oCorConf /= nPts
oInCorConf /= nPts
overallMatrix /= nPts
oSort = numpy.argsort(overall)
oMin = overall[oSort[0]]
overall -= avgOverall
devOverall = numpy.sqrt(sum(overall**2) / (nPts - 1))
res = {}
res['oAvg'] = 100 * avgOverall
res['oDev'] = 100 * devOverall
res['oCorrectConf'] = 100 * oCorConf
res['oIncorrectConf'] = 100 * oInCorConf
res['oResultMat'] = overallMatrix
res['oBestIdx'] = oSort[0]
res['oBestErr'] = 100 * oMin
if enrich >= 0:
mean, dev = Stats.MeanAndDev(overallEnrich)
res['oAvgEnrich'] = mean
res['oDevEnrich'] = dev
if haveHoldout:
avgHoldout = sum(holdout) / nPts
hCorConf /= nPts
hInCorConf /= nPts
holdoutMatrix /= nPts
hSort = numpy.argsort(holdout)
hMin = holdout[hSort[0]]
holdout -= avgHoldout
devHoldout = numpy.sqrt(sum(holdout**2) / (nPts - 1))
res['hAvg'] = 100 * avgHoldout
res['hDev'] = 100 * devHoldout
res['hCorrectConf'] = 100 * hCorConf
res['hIncorrectConf'] = 100 * hInCorConf
res['hResultMat'] = holdoutMatrix
res['hBestIdx'] = hSort[0]
res['hBestErr'] = 100 * hMin
if enrich >= 0:
mean, dev = Stats.MeanAndDev(holdoutEnrich)
res['hAvgEnrich'] = mean
res['hDevEnrich'] = dev
return res
def ShowStats(statD, enrich=1):
statD = statD.copy()
statD['oBestIdx'] = statD['oBestIdx'] + 1
txt = """
# Error Statistics:
\tOverall: %(oAvg)6.3f%% (%(oDev)6.3f) %(oCorrectConf)4.1f/%(oIncorrectConf)4.1f
\t\tBest: %(oBestIdx)d %(oBestErr)6.3f%%""" % (statD)
if 'hAvg' in statD:
statD['hBestIdx'] = statD['hBestIdx'] + 1
txt += """
\tHoldout: %(hAvg)6.3f%% (%(hDev)6.3f) %(hCorrectConf)4.1f/%(hIncorrectConf)4.1f
\t\tBest: %(hBestIdx)d %(hBestErr)6.3f%%
""" % (statD)
print(txt)
print()
print('# Results matrices:')
print('\tOverall:')
tmp = numpy.transpose(statD['oResultMat'])
colCounts = sum(tmp)
rowCounts = sum(tmp, 1)
for i in range(len(tmp)):
if rowCounts[i] == 0:
rowCounts[i] = 1
row = tmp[i]
print('\t\t', end='')
for j in range(len(row)):
print('% 6.2f' % row[j], end='')
print('\t| % 4.2f' % (100. * tmp[i, i] / rowCounts[i]))
print('\t\t', end='')
for i in range(len(tmp)):
print('------', end='')
print()
print('\t\t', end='')
for i in range(len(tmp)):
if colCounts[i] == 0:
colCounts[i] = 1
print('% 6.2f' % (100. * tmp[i, i] / colCounts[i]), end='')
print()
if enrich > -1 and 'oAvgEnrich' in statD:
print('\t\tEnrich(%d): %.3f (%.3f)' % (enrich, statD['oAvgEnrich'], statD['oDevEnrich']))
if 'hResultMat' in statD:
print('\tHoldout:')
tmp = numpy.transpose(statD['hResultMat'])
colCounts = sum(tmp)
rowCounts = sum(tmp, 1)
for i in range(len(tmp)):
if rowCounts[i] == 0:
rowCounts[i] = 1
row = tmp[i]
print('\t\t', end='')
for j in range(len(row)):
print('% 6.2f' % row[j], end='')
print('\t| % 4.2f' % (100. * tmp[i, i] / rowCounts[i]))
print('\t\t', end='')
for i in range(len(tmp)):
print('------', end='')
print()
print('\t\t', end='')
for i in range(len(tmp)):
if colCounts[i] == 0:
colCounts[i] = 1
print('% 6.2f' % (100. * tmp[i, i] / colCounts[i]), end='')
print()
if enrich > -1 and 'hAvgEnrich' in statD:
print('\t\tEnrich(%d): %.3f (%.3f)' % (enrich, statD['hAvgEnrich'], statD['hDevEnrich']))
return
def Usage():
print(__doc__)
sys.exit(-1)
if __name__ == "__main__":
import getopt
try:
args, extras = getopt.getopt(sys.argv[1:], 'n:d:N:vX', ('skip',
'enrich=', ))
except Exception:
Usage()
count = 3
db = None
note = ''
verbose = 0
skip = 0
enrich = 1
for arg, val in args:
if arg == '-n':
count = int(val) + 1
elif arg == '-d':
db = val
elif arg == '-N':
note = val
elif arg == '-v':
verbose = 1
elif arg == '--skip':
skip = 1
elif arg == '--enrich':
enrich = int(val)
composites = []
if db is None:
for arg in extras:
composite = pickle.load(open(arg, 'rb'))
composites.append(composite)
else:
tbl = extras[0]
conn = DbConnect(db, tbl)
if note:
where = "where note='%s'" % (note)
else:
where = ''
if not skip:
pkls = conn.GetData(fields='model', where=where)
composites = []
for pkl in pkls:
pkl = str(pkl[0])
comp = pickle.loads(pkl)
composites.append(comp)
if len(composites):
ProcessIt(composites, count, verbose=verbose)
elif not skip:
print('ERROR: no composite models found')
sys.exit(-1)
if db:
res = ErrorStats(conn, where, enrich=enrich)
if res:
ShowStats(res)
| ptosco/rdkit | rdkit/ML/AnalyzeComposite.py | Python | bsd-3-clause | 9,361 | [
"RDKit"
] | 626a543933bcb1e2156128512c953943b479bdaa68bffe3ade5078e0b3034056 |
"""
chapter4.py
==========
Models from Chapter 4 of [G&L 2012].
- Model PC = Model with Portfolio Choice
Note that if using the book initial conditions, not all variables are being set at
present. This will affect some stock variable accounting.
[G&L 2012] "Monetary Economics: An Integrated Approach to credit, Money, Income, Production
and Wealth; Second Edition", by Wynne Godley and Marc Lavoie, Palgrave Macmillan, 2012.
ISBN 978-0-230-30184-9
Copyright 2017 Brian Romanchuk
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
from sfc_models.gl_book import GL_book_model
from sfc_models.sector_definitions import *
class PC(GL_book_model):
"""
Implements Model PC from Chapter 4 of G&L. PC = "Portfolio Choice."
"""
def build_model(self):
country = self.Country
tre = Treasury(country, 'TRE', 'Treasury')
cb = CentralBank(country, 'CB', 'Central Bank')
cb.Treasury = tre
hh = Household(country, 'HH', 'Household')
hh.AlphaIncome = 0.6
hh.AlphaFin = 0.4
# A literally non-profit business sector
bus = FixedMarginBusiness(country, 'BUS', 'Business Sector')
# Create the linkages between sectors - tax flow, markets - labour ('LAB'), goods ('GOOD')
tax = TaxFlow(country, 'TF', 'TaxFlow', taxrate=.2, taxes_paid_to='TRE')
labour = Market(country, 'LAB', 'Labour market')
goods = Market(country, 'GOOD', 'Goods market')
mm = MoneyMarket(country, issuer_short_code='CB')
dep = DepositMarket(country, issuer_short_code='TRE')
# Create the demand for deposits. ('MON' is the residual asset.)
hh.AddVariable('L0', 'lambda_0: share of bills in wealth', '0.635')
hh.AddVariable('L1', 'lambda_1: parameter related to interest rate', '5.')
hh.AddVariable('L2', 'lambda_2: parameter related to disposable income', '.01')
# Generate the equation. Need to get the name of the interest rate variable
r = dep.GetVariableName('r')
# The format() call will replace '{0}' with the contents of the 'r' variable.
eqn = 'L0 + L1 * {0} - L2 * (AfterTax/F)'.format(r)
hh.GenerateAssetWeighting({'DEP': eqn}, 'MON')
# Add a decorative equation: Government Fiscal Balance
# = Primary Balance - Interest expense + Central Bank Dividend (= interest
# received by the central bank).
tre.AddVariable('FISCBAL', 'Fiscal Balance', 'PRIM_BAL - INTDEP + CB__INTDEP')
if self.UseBookExogenous:
# Need to set the exogenous variable - Government demand for Goods ("G" in economist symbology)
tre.SetExogenous('DEM_GOOD', '[20.,] * 105')
dep.SetExogenous('r', '[.025,]*10 + [.035,]*105')
# NOTE:
# Initial conditions are only partial; there may be issues with some
# variables.
self.Model.AddInitialCondition('HH', 'AfterTax', 86.486)
self.Model.AddInitialCondition('HH', 'F', 86.486)
self.Model.AddInitialCondition('TRE', 'F', -86.486)
self.Model.AddInitialCondition('HH', 'DEM_DEP', 64.865)
self.Model.AddGlobalEquation('t', 'decorated time axis', '1950. + k')
return self.Model
def expected_output(self):
"""
Expected output for the model (using default input).
Based on EViews output using code from Gennaro Zezza (from sfcmodels.net)
NOTE: A spreadsheet at sfcmodels.net gives different output; income is changing during the
same period as the rate change.
We ignore value at t=0
:return: list
"""
out = [
('t', [None, 1951., 1952., 1953., ]),
('TRE__DEM_GOOD', [None, 20., 20., 20., 20.]), # G
('DEP__r', [0.025, ] * 10 + [.035] * 5),
('HH__WGT_DEP', [None, 0.75, 0.75, 0.75, 0.75, 0.75, 0.75, 0.75, 0.75, 0.75, 0.80, 0.80, 0.80, 0.80, 0.80,
0.80, 0.80]), # Weight of deposits (bills)
('HH__AfterTax', [None, 86.49, 86.49, 86.49, 86.49, 86.49, 86.49, 86.49, 86.49, 86.49, 86.49, 87.72,
88.04, 88.32, 88.56, 88.77, 88.95, 89.11]), # YD
('TRE__T', [None, 21.62, 21.62, 21.62, 21.62, 21.62, 21.62, 21.62, 21.62, 21.62, 21.62, 21.93, 22.01, 22.08,
22.14, 22.19, 22.24, 22.28]), # T
('GOOD__SUP_GOOD', [None, 106.49, 106.49, 106.49, 106.49, 106.49, 106.49, 106.49, 106.49, 106.49, 106.49,
107.22, 107.62, 107.95, 108.25, 108.50, 108.71, 108.90, 109.06, 109.20, 109.33]), # Y
('HH__DEM_MON', [None, 21.62, 21.62, 21.62, 21.62, 21.62, 21.62, 21.62, 21.62, 21.62, 17.30, 17.40, 17.49,
17.56, 17.62, 17.68, 17.72, 17.76, 17.80]), # high-powered money (H)
]
return out
| brianr747/SFC_models | sfc_models/gl_book/chapter4.py | Python | apache-2.0 | 5,346 | [
"Brian"
] | 428c6a58f9ebe0cb6b29f52aeaeb656a61c0a12e2a731fb404c2be842363a093 |
model = """# Generated by PySCeS 0.7.0 (2010-10-07 19:43)
# Keywords
Description: Auto-regulatory network
Modelname: AutoRegulatoryNetwork
Output_In_Conc: True
Species_In_Conc: False
# GlobalUnitDefinitions
UnitVolume: litre, 1.0, 0, 1
UnitLength: metre, 1.0, 0, 1
UnitSubstance: item, 1.0, 0, 1
UnitArea: metre, 1.0, 0, 2
UnitTime: second, 1.0, 0, 1
# Compartments
Compartment: Cell, 1.0, 3
# Reactions
RepressionBinding@Cell:
P2 + Gene > P2Gene
RepressionBinding_k1*Gene*P2
ProteinDegradation@Cell:
P > $pool
ProteinDegradation_k6*P
Dimerisation@Cell:
{2.0}P > P2
Dimerisation_k4*0.5*P*(P-1)
Dissociation@Cell:
P2 > {2.0}P
Dissociation_k4r*P2
Transcription@Cell:
$pool > Rna
Transcription_k2*Gene
RnaDegradation@Cell:
Rna > $pool
RnaDegradation_k5*Rna
Translation@Cell:
$pool > P
Translation_k3*Rna
ReverseRepressionBinding@Cell:
P2Gene > P2 + Gene
ReverseRepressionBinding_k1r*P2Gene
# Fixed species
# Variable species
P2@Cell = 0.0
P@Cell = 0.0
Rna@Cell = 0.0
Gene@Cell = 10.0
P2Gene@Cell = 0.0
# Parameters
RepressionBinding_k1 = 1.0
ProteinDegradation_k6 = 0.01
Dimerisation_k4 = 1.0
Dissociation_k4r = 1.0
Transcription_k2 = 0.01
RnaDegradation_k5 = 0.1
Translation_k3 = 10.0
ReverseRepressionBinding_k1r = 10.0
"""
xml_model = """<?xml version="1.0" encoding="UTF-8"?>
<sbml xmlns="http://www.sbml.org/sbml/level2" level="2" version="1">
<model id="AutoRegulatoryNetwork" name="Auto-regulatory network">
<listOfUnitDefinitions>
<unitDefinition id="substance">
<listOfUnits>
<unit kind="item" multiplier="1" offset="0"/>
</listOfUnits>
</unitDefinition>
</listOfUnitDefinitions>
<listOfCompartments>
<compartment id="Cell"/>
</listOfCompartments>
<listOfSpecies>
<species id="Gene" compartment="Cell" initialAmount="10" hasOnlySubstanceUnits="true"/>
<species id="P2Gene" name="P2.Gene" compartment="Cell" initialAmount="0" hasOnlySubstanceUnits="true"/>
<species id="Rna" compartment="Cell" initialAmount="0" hasOnlySubstanceUnits="true"/>
<species id="P" compartment="Cell" initialAmount="0" hasOnlySubstanceUnits="true"/>
<species id="P2" compartment="Cell" initialAmount="0" hasOnlySubstanceUnits="true"/>
</listOfSpecies>
<listOfReactions>
<reaction id="RepressionBinding" name="Repression binding" reversible="false">
<listOfReactants>
<speciesReference species="Gene"/>
<speciesReference species="P2"/>
</listOfReactants>
<listOfProducts>
<speciesReference species="P2Gene"/>
</listOfProducts>
<kineticLaw>
<math xmlns="http://www.w3.org/1998/Math/MathML">
<apply>
<times/>
<ci> k1 </ci>
<ci> Gene </ci>
<ci> P2 </ci>
</apply>
</math>
<listOfParameters>
<parameter id="k1" value="1"/>
</listOfParameters>
</kineticLaw>
</reaction>
<reaction id="ReverseRepressionBinding" name="Reverse repression binding" reversible="false">
<listOfReactants>
<speciesReference species="P2Gene"/>
</listOfReactants>
<listOfProducts>
<speciesReference species="Gene"/>
<speciesReference species="P2"/>
</listOfProducts>
<kineticLaw>
<math xmlns="http://www.w3.org/1998/Math/MathML">
<apply>
<times/>
<ci> k1r </ci>
<ci> P2Gene </ci>
</apply>
</math>
<listOfParameters>
<parameter id="k1r" value="10"/>
</listOfParameters>
</kineticLaw>
</reaction>
<reaction id="Transcription" reversible="false">
<listOfReactants>
<speciesReference species="Gene"/>
</listOfReactants>
<listOfProducts>
<speciesReference species="Gene"/>
<speciesReference species="Rna"/>
</listOfProducts>
<kineticLaw>
<math xmlns="http://www.w3.org/1998/Math/MathML">
<apply>
<times/>
<ci> k2 </ci>
<ci> Gene </ci>
</apply>
</math>
<listOfParameters>
<parameter id="k2" value="0.01"/>
</listOfParameters>
</kineticLaw>
</reaction>
<reaction id="Translation" reversible="false">
<listOfReactants>
<speciesReference species="Rna"/>
</listOfReactants>
<listOfProducts>
<speciesReference species="Rna"/>
<speciesReference species="P"/>
</listOfProducts>
<kineticLaw>
<math xmlns="http://www.w3.org/1998/Math/MathML">
<apply>
<times/>
<ci> k3 </ci>
<ci> Rna </ci>
</apply>
</math>
<listOfParameters>
<parameter id="k3" value="10"/>
</listOfParameters>
</kineticLaw>
</reaction>
<reaction id="Dimerisation" reversible="false">
<listOfReactants>
<speciesReference species="P" stoichiometry="2"/>
</listOfReactants>
<listOfProducts>
<speciesReference species="P2"/>
</listOfProducts>
<kineticLaw>
<math xmlns="http://www.w3.org/1998/Math/MathML">
<apply>
<times/>
<ci> k4 </ci>
<cn> 0.5 </cn>
<ci> P </ci>
<apply>
<minus/>
<ci> P </ci>
<cn type="integer"> 1 </cn>
</apply>
</apply>
</math>
<listOfParameters>
<parameter id="k4" value="1"/>
</listOfParameters>
</kineticLaw>
</reaction>
<reaction id="Dissociation" reversible="false">
<listOfReactants>
<speciesReference species="P2"/>
</listOfReactants>
<listOfProducts>
<speciesReference species="P" stoichiometry="2"/>
</listOfProducts>
<kineticLaw>
<math xmlns="http://www.w3.org/1998/Math/MathML">
<apply>
<times/>
<ci> k4r </ci>
<ci> P2 </ci>
</apply>
</math>
<listOfParameters>
<parameter id="k4r" value="1"/>
</listOfParameters>
</kineticLaw>
</reaction>
<reaction id="RnaDegradation" name="RNA Degradation" reversible="false">
<listOfReactants>
<speciesReference species="Rna"/>
</listOfReactants>
<kineticLaw>
<math xmlns="http://www.w3.org/1998/Math/MathML">
<apply>
<times/>
<ci> k5 </ci>
<ci> Rna </ci>
</apply>
</math>
<listOfParameters>
<parameter id="k5" value="0.1"/>
</listOfParameters>
</kineticLaw>
</reaction>
<reaction id="ProteinDegradation" name="Protein degradation" reversible="false">
<listOfReactants>
<speciesReference species="P"/>
</listOfReactants>
<kineticLaw>
<math xmlns="http://www.w3.org/1998/Math/MathML">
<apply>
<times/>
<ci> k6 </ci>
<ci> P </ci>
</apply>
</math>
<listOfParameters>
<parameter id="k6" value="0.01"/>
</listOfParameters>
</kineticLaw>
</reaction>
</listOfReactions>
</model>
</sbml>
"""
| SystemsBioinformatics/stochpy | stochpy/pscmodels/Autoreg.py | Python | gpl-3.0 | 7,624 | [
"PySCeS"
] | 8a8acf392c9314c75277679908b502946ec09c7987b5a9d5bd3dd55be3591c6d |
# Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
# Spack Project Developers. See the top-level COPYRIGHT file for details.
#
# SPDX-License-Identifier: (Apache-2.0 OR MIT)
from spack import *
class PyCrispresso(PythonPackage):
"""Software pipeline for the analysis of CRISPR-Cas9 genome editing
outcomes from deep sequencing data."""
homepage = "https://github.com/lucapinello/CRISPResso"
pypi = "CRISPResso/CRISPResso-1.0.8.tar.gz"
version('1.0.8', sha256='b04ac8781ff8ed56d018c357e741f146b72ad7e0d23c9e5bc1e1bcd1a873ebc3', deprecated=True)
depends_on('py-setuptools', type='build')
depends_on('python@2.7.0:2.7', type=('build', 'run'))
depends_on('py-biopython@1.6.5:', type=('build', 'run'))
depends_on('py-matplotlib@1.3.1:', type=('build', 'run'))
depends_on('py-numpy@1.9:', type=('build', 'run'))
depends_on('py-pandas@0.15:', type=('build', 'run'))
depends_on('py-seaborn@0.7.1:', type=('build', 'run'))
depends_on('emboss@6:', type=('build', 'run'))
depends_on('flash', type=('build', 'run'))
depends_on('java', type=('build', 'run'))
| LLNL/spack | var/spack/repos/builtin/packages/py-crispresso/package.py | Python | lgpl-2.1 | 1,135 | [
"Biopython"
] | fa90a7f89a6e1b6841e3fc1d976c0b2e37edc340ac59d9a80e84c4b60879b2f7 |
"""
=================
flask-geckoboard
=================
Geckoboard_ is a hosted, real-time status board serving up indicators
from web analytics, CRM, support, infrastructure, project management,
sales, etc. It can be connected to virtually any source of quantitative
data. This Flask_ plugin provides view decorators to help create
custom widgets.
.. _Geckoboard: http://www.geckoboard.com/
.. _Flask: http://flask.pocoo.org/
Installation
============
To install flask-geckoboard, simply place the ``flask_geckoboard``
package somewhere on the Python path.
Limiting access
===============
If you want to protect the data you send to Geckoboard from access by
others, you can use an API key shared by Geckoboard and your widget
views. Set ``GECKOBOARD_API_KEY`` in the Flask config.
If you do not set an API key, anyone will be able to view the data by
visiting the widget URL.
Encryption
==========
Geckoboard encryption allows encrypting data before it is sent to Geckoboard's
servers. After entering the password used to encrypt the data when the Geckoboard
is loaded, the data will be decrypted in the browser.
To use encryption, first set a ``GECKOBOARD_PASSWORD`` in the Flask config.
Next, enable encryption for each widget using the decorator arguments::
from flask import Flask
from flask_geckoboard import Geckoboard
app = Flask(__name__)
geckoboard = Geckoboard(app)
@app.route('/user-count')
@geckoboard.number(encrypted=True)
def user_count(request):
return User.objects.count()
Creating custom widgets
=======================
The available custom widgets are described in the Geckoboard support
section, under `Geckoboard API`_. From the perspective of a Flask
project, a custom widget is just a view. The flask-geckoboard
application provides view decorators that render the correct response
for the different widgets.
Let's say you want to add a widget to your dashboard that shows the
number of number of comments posted today. First create a view, using a
flask-geckoboard decorator::
from datetime import date, time, datetime
from flask import Flask
from flask_geckoboard import Geckoboard
app = Flask(__name__)
geckoboard = Geckoboard(app)
@app.route('/comment-count')
@geckoboard.number
def comment_count():
midnight = datetime.combine(date.today(), time.min)
return Comment.objects.filter(submit_date__gte=midnight).count()
If your widget has optional settings, you can pass them in the decorator
definition::
@app.route('/gecko/comment/count-absolute')
@geckoboard.number(absolute='true')
def comment_count(request):
midnight = datetime.combine(date.today(), time.min)
return Comment.objects.filter(submit_date__gte=midnight).count()
This is all the Flask code you need to display the comment count on
your dashboard. When you create a custom widget in Geckoboard, enter the
following information:
Encryption
Enable if the field is encrypted (see instructions above).
URL data feed
The view URL. In the example above this would be something like
``http://HOSTNAME/geckoboard/comment_count/``.
API key
The content of the ``GECKOBOARD_API_KEY`` setting, if you have set
it.
Widget type
*Custom*
Feed format
Either *XML* or *JSON*. If you don't specify a format the decorators will
automatically detect and output the correct format or default to XML
if this is not enabled (by default the format isn't appended by
Geckoboard as a parameter any more)
Request type
Either *GET* or *POST*. The view decorators accept both.
The following decorators are available from the
``flask_geckoboard.decorators`` module:
``number``
-----------------
Render a *Number & Secondary Stat* widget.
The decorated view must return a tuple *(current, [previous],
[prefix])* where the *current* parameter is the current value, optional
*previous* parameter is the previous value of the measured quantity and
the optional parameter *prefix* is the prefix used in Geckoboard widget.
If there is only one parameter you do not need to return it in a tuple.
For example, to render a widget that shows the number of users and the
difference from last week::
from datetime import datetime, timedelta
@geckoboard.number
def user_count(request):
last_week = datetime.now() - timedelta(weeks=1)
users = User.objects
last_week_users = users.filter(date_joined__lt=last_week)
return (users.count(), last_week_users.count())
@geckoboard.number
def users_count_with_prefix(request):
last_week = datetime.now() - timedelta(weeks=1)
users = User.objects
last_week_users = users.filter(date_joined__lt=last_week)
return (users.count(), last_week_users.count(), '$')
``rag``
--------------
Render a *RAG Column & Numbers* or *RAG Numbers* widget.
The decorated view must return a tuple with three tuples *(value,
[text])*. The *value* parameters are the numbers shown in red, amber
and green (in that order). The optional *text* parameters will be
displayed next to the respective values in the dashboard.
For example, to render a widget that shows the number of comments that
were approved or deleted by moderators in the last 24 hours::
from datetime import datetime, timedelta
@geckoboard.rag
def comments(request):
start_time = datetime.now() - timedelta(hours=24)
comments = Comment.objects.filter(submit_date__gt=start_time)
total_count = comments.count()
approved_count = comments.filter(
flags__flag=CommentFlag.MODERATOR_APPROVAL).count()
deleted_count = Comment.objects.filter(
flags__flag=CommentFlag.MODERATOR_DELETION).count()
pending_count = total_count - approved_count - deleted_count
return (
(deleted_count, "Deleted comments"),
(pending_count, "Pending comments"),
(approved_count, "Approved comments"),
)
``text``
---------------
Render a *Text* widget.
The decorated view must return a list of tuples *(message, [type])*.
The *message* parameters are strings that will be shown in the widget.
The *type* parameters are optional and tell Geckoboard how to annotate
the messages. Use ``TEXT_INFO`` for informational messages,
``TEXT_WARN`` for for warnings and ``TEXT_NONE`` for plain text (the
default). If there is only one plain message, you can just return it
without enclosing it in a list and tuple.
For example, to render a widget showing the latest Geckoboard twitter
updates, using Mike Verdone's `Twitter library`_::
import twitter
@geckoboard.text
def twitter_status(request):
twitter = twitter.Api()
updates = twitter.GetUserTimeline('geckoboard')
return [(u.text, TEXT_NONE) for u in updates]
.. _`Twitter library`: http://pypi.python.org/pypi/twitter
``pie_chart``
-------------
Render a *Pie chart* widget.
The decorated view must return an iterable over tuples *(value, label,
[color])*. The optional *color* parameter is a string ``'RRGGBB[TT]'``
representing red, green, blue and optionally transparency.
For example, to render a widget showing the number of normal, staff and
superusers::
@geckoboard.pie_chart
def user_types(request):
users = User.objects.filter(is_active=True)
total_count = users.count()
superuser_count = users.filter(is_superuser=True).count()
staff_count = users.filter(is_staff=True,
is_superuser=False).count()
normal_count = total_count = superuser_count - staff_count
return [
(normal_count, "Normal users", "ff8800"),
(staff_count, "Staff", "00ff88"),
(superuser_count, "Superusers", "8800ff"),
]
``line_chart``
--------------
Render a *Line chart* widget.
The decorated view must return a tuple *(values, x_axis, y_axis,
[color])*. The *values* parameter is a list of data points. The
*x-axis* parameter is a label string or a list of strings, that will be
placed on the X-axis. The *y-axis* parameter works similarly for the
Y-axis. If there are more than one axis label, they are placed evenly
along the axis. The optional *color* parameter is a string
``'RRGGBB[TT]'`` representing red, green, blue and optionally
transparency.
For example, to render a widget showing the number of comments per day
over the last four weeks (including today)::
from datetime import date, timedelta
@geckoboard.line_chart
def comment_trend(request):
since = date.today() - timedelta(days=29)
days = dict((since + timedelta(days=d), 0)
for d in range(0, 29))
comments = Comment.objects.filter(submit_date__gte=since)
for comment in comments:
days[comment.submit_date.date()] += 1
return (
days.values(),
[days[i] for i in range(0, 29, 7)],
"Comments",
)
``geck_o_meter``
----------------
Render a *Geck-O-Meter* widget.
The decorated view must return a tuple *(value, min, max)*. The *value*
parameter represents the current value. The *min* and *max* parameters
represent the minimum and maximum value respectively. They are either a
value, or a tuple *(value, text)*. If used, the *text* parameter will
be displayed next to the minimum or maximum value.
For example, to render a widget showing the number of users that have
logged in in the last 24 hours::
from datetime import datetime, timedelta
@geckoboard.geck_o_meter
def login_count(request):
since = datetime.now() - timedelta(hours=24)
users = User.objects.filter(is_active=True)
total_count = users.count()
logged_in_count = users.filter(last_login__gt=since).count()
return (logged_in_count, 0, total_count)
``funnel``
----------
Render a *Funnel* widget.
The decorated view must return a dictionary with at least an *items*
key. To render a funnel showing the breakdown of authenticated users
vs. anonymous users::
@geckoboard.funnel
def user_breakdown(request):
all_users = User.objects
active_users =all_users.filter(is_active=True)
staff_users = all_users.filter(is_staff=True)
super_users = all_users.filter(is_superuser=True)
return {
"items": [
(all_users.count(), 'All users'),
(active_users.count(), 'Active users'),
(staff_users.count(), 'Staff users'),
(super_users.count(), 'Super users'),
],
"type": "standard", # default, 'reverse' changes direction
# of the colors.
"percentage": "show", # default, 'hide' hides the percentage
# values.
"sort": False, # default, `True` orders the values
# descending.
}
``bullet``
----------
Render a *Bullet* widget.
The decorated view must return a dictionary with at least keys *label*,
*axis_points*, *current* and *comparative*. To render Geckoboard's own example
at
http://support.geckoboard.com/entries/274940-custom-chart-widget-type-definitions::
@geckoboard.bullet
def geckoboard_bullet_example(request):
return = {
'label': 'Revenue 2011 YTD',
'axis_points': [0, 200, 400, 600, 800, 1000],
'current': 500,
'comparative': 600,
'sublabel': 'U.S. $ in thousands',
'red': [0, 400],
'amber': [401, 700],
'green': [701, 1000],
'projected': [100, 900],
'auto_scale': False,
}
.. _`Geckoboard API`: http://geckoboard.zendesk.com/forums/207979-geckoboard-api
"""
class Geckoboard(object):
import decorators
app = None
bullet = decorators.bullet
funnel = decorators.funnel
geck_o_meter = decorators.geck_o_meter
line_chart = decorators.line_chart
pie_chart = decorators.pie_chart
text = decorators.text_widget
rag = decorators.rag_widget
number = decorators.number_widget
def __init__(self, app=None):
if app:
self.init_app(app)
def init_app(self, app):
self.api_key = app.config.get('GECKOBOARD_API_KEY')
self.password = app.config.get('GECKOBOARD_PASSWORD')
self.app = app
__author__ = "Rob Eroh"
__email__ = "rob@eroh.me"
__version__ = "0.2.1"
__copyright__ = "Copyright (C) 2011-2014 Rob Eroh and others"
__license__ = "MIT License"
| rossdeane/flask-geckoboard | flask_geckoboard/__init__.py | Python | mit | 12,681 | [
"Amber"
] | 809bf482e60b157d013baaf8acf63e9420f7a7d7bff7d6de0c0145a4bf66ffcf |
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import models, migrations
from django.conf import settings
class Migration(migrations.Migration):
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
]
operations = [
migrations.CreateModel(
name='Assignment',
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('created', models.DateTimeField(auto_now_add=True)),
],
options={
},
bases=(models.Model,),
),
migrations.CreateModel(
name='AssignmentHistory',
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('date', models.DateField()),
],
options={
},
bases=(models.Model,),
),
migrations.CreateModel(
name='Companion',
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('created', models.DateTimeField(auto_now_add=True)),
],
options={
},
bases=(models.Model,),
),
migrations.CreateModel(
name='Companionship',
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('created', models.DateTimeField(auto_now_add=True)),
],
options={
},
bases=(models.Model,),
),
migrations.CreateModel(
name='District',
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('name', models.CharField(max_length=128)),
('created', models.DateTimeField(auto_now_add=True)),
],
options={
},
bases=(models.Model,),
),
migrations.CreateModel(
name='Household',
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('name', models.CharField(max_length=128)),
('address', models.CharField(max_length=256)),
('notes', models.TextField(blank=True)),
('created', models.DateTimeField(auto_now_add=True)),
('moved', models.BooleanField(default=False)),
],
options={
},
bases=(models.Model,),
),
migrations.CreateModel(
name='Member',
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('first_name', models.CharField(max_length=128)),
('last_name', models.CharField(max_length=128)),
('birthday', models.DateField(blank=True)),
('phone', models.CharField(max_length=28, blank=True)),
('email', models.CharField(max_length=128)),
('is_home_teacher', models.BooleanField(default=False)),
('created', models.DateTimeField(auto_now_add=True)),
('household', models.ForeignKey(related_name='members', to='llts.Household')),
],
options={
},
bases=(models.Model,),
),
migrations.CreateModel(
name='Organization',
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('name', models.CharField(max_length=128)),
('created', models.DateTimeField(auto_now_add=True)),
('owner', models.ForeignKey(related_name='organizations', to=settings.AUTH_USER_MODEL)),
],
options={
},
bases=(models.Model,),
),
migrations.CreateModel(
name='Visit',
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('visitor1', models.CharField(max_length=128)),
('visitor2', models.CharField(max_length=128, blank=True)),
('date', models.DateField()),
('notes', models.TextField(blank=True)),
('household', models.ForeignKey(related_name='visits', to='llts.Household')),
],
options={
},
bases=(models.Model,),
),
migrations.AddField(
model_name='household',
name='organization',
field=models.ForeignKey(related_name='households', to='llts.Organization'),
preserve_default=True,
),
migrations.AddField(
model_name='district',
name='leader',
field=models.ForeignKey(related_name='districts', to='llts.Member'),
preserve_default=True,
),
migrations.AddField(
model_name='district',
name='organization',
field=models.ForeignKey(related_name='districts', to='llts.Organization'),
preserve_default=True,
),
migrations.AddField(
model_name='companionship',
name='district',
field=models.ForeignKey(related_name='companionships', to='llts.District'),
preserve_default=True,
),
migrations.AddField(
model_name='companion',
name='companionship',
field=models.ForeignKey(related_name='members', to='llts.Companionship'),
preserve_default=True,
),
migrations.AddField(
model_name='companion',
name='member',
field=models.ForeignKey(related_name='companionships', to='llts.Member'),
preserve_default=True,
),
migrations.AddField(
model_name='assignmenthistory',
name='household',
field=models.ForeignKey(related_name='past_assignments', to='llts.Household'),
preserve_default=True,
),
migrations.AddField(
model_name='assignment',
name='companionship',
field=models.ForeignKey(related_name='assignments', to='llts.Companionship'),
preserve_default=True,
),
migrations.AddField(
model_name='assignment',
name='household',
field=models.ForeignKey(related_name='active_assignment', to='llts.Household'),
preserve_default=True,
),
]
| ryanrborn/lds-leader-tool-suite-backend | llts/migrations/0001_initial.py | Python | mit | 6,883 | [
"VisIt"
] | 98b7aa1db8f997d58ad2f36cfe430b4680709721596fb62add286e6b6694b3f0 |
#!/usr/bin/env python3
"""bvc.py: Manages binary and integer variables for the MSA 2 QUBO problem"""
import math
import numpy as np
from matplotlib import pyplot as plt
try:
import gurobipy
except ImportError:
pass
__author__ = "Dan Mapleson, Luis Yanes, Katie Barr, Sophie Kirkwood and Tim Stitt"
__copyright__ = "Copyright 2016, Quantum MSA"
__credits__ = ["Dan Mapleson", "Luis Yanes", "Katie Barr",
"Sophie Kirkwood", "Tim Stitt"]
__license__ = "GPLv3"
__version__ = "0.0.1"
__maintainer__ = "Dan Mapleson,"
__email__ = "daniel.mapleson@earlham.ac.uk"
__status__ = "Prototype"
class BVC:
"""This class represents the binary variables required for a given number of sequences. Little endian is used where
binary variables are representing integer values.
To use the class initialise, and optionally override default parameters representing the max gap size and weightings,
then add BioPython sequence records that will represent the MSA. Finally call createBVMatrix to create the symettric
matrix containing binary variable coefficients."""
def __init__(self, P=1, d=2.0, l0=0.8, l1=1.0, l2=10.0, reduced=False, weights=None, settings_file=None):
self.data = []
if settings_file == None:
self.__P = P
self.__d = d
self.__l0 = l0
self.__l1 = l1
self.__l2 = l2
self.__N = 0
self.__Lmax = 0
self.__K = 0
self.unused=[]
self.__reduced = reduced
self.__x = []
self.__seqs = []
else:
handle = open(settings_file, "r");
parts = handle.readline().split("\t")
self.__P = int(parts[1])
parts = handle.readline().split("\t")
self.__d = float(parts[1])
parts = handle.readline().split("\t")
self.__l0 = float(parts[1])
parts = handle.readline().split("\t")
self.__l1 = float(parts[1])
parts = handle.readline().split("\t")
self.__l2 = float(parts[1])
parts = handle.readline().split("\t")
self.__N = int(parts[1])
parts = handle.readline().split("\t")
self.__Lmax = int(parts[1])
parts = handle.readline().split("\t")
self.__K = int(parts[1])
self.seqs = []
used = handle.readline()
used = handle.readline().strip()
self.unused= []
for i in range(len(used)):
self.unused.append(True if used[i] == "1" else False)
parts = handle.readline().strip().split("\t")
self.__reduced = True if parts[1] == "True" else False
self.__x = []
for line in handle:
parts = line.split("\t")
self.__x.append([0] * int(parts[1]))
handle.close()
self.__W = np.zeros((0, 0))
self.__bvm = np.zeros((0, 0))
self.__qim = np.zeros((0, 0))
self.__lil = []
self.__bvs = []
self.__weights = weights
self.energy = 0
self.ienergy = 0
self.active = []
self.nb_active = 0
def __str__(self):
return "N=" + str(self.__N) + "\tNumber of sequences\n" \
"Lmax=" + str(
self.__Lmax) + "\tLength of longest sequence (rounded up to nearest ^2)\n" \
"K=" + str(self.__K) + "\tTotal number of characters\n" \
"M=" + str(self.M()) + "\tLength of each row in solution space\n" \
"m=" + str(
self.m()) + "\tNumber of binary variables required to represent each position in solution space\n" \
"P=" + str(self.__P) + "\tMaximum gap size\n" \
"p=" + str(
self.p()) + "\tNumber of binary variables required to represent each gap\n\n" \
"l0=" + str(self.__l0) + "\tPosition weighting\n" \
"l1=" + str(self.__l1) + "\tGap weighting\n" \
"l2=" + str(
self.__l2) + "\tReward weighting\n" \
"d=" + str(self.__d) + "\tScaling factor when substituting products of 3BVs to 2BVs\n\n" \
"Solution space will contain " + str(
self.calc_solutionSpaceSize()) + " cells\n\n" \
"Bounds on total # Binary Variables required: " + str(
self.calc_minBV()) + "-" + str(self.calc_maxBV()) + "\n" \
"# Binary Variables required for positioning: " + str(
self.get_NbPositioningVars()) + "\n" \
"# Binary Variables required for gaps: " + str(self.get_NbGapVars()) + "\n" \
"Max Binary Variables required for rewards: " + str(
self.get_NbRewardVars()) + "\n" \
"Max Binary Variables required for y and z (each): " + str(
self.get_NbYVars()) + "\n\n"
def add_record(self, record):
"""Adds a biopython record and updates the state of this object accordingly"""
l = len(record.seq)
self.__Lmax = max(self.__Lmax, l)
# ensure Lmax is power of 2
self.__Lmax = 1 << (self.__Lmax - 1).bit_length()
self.__x.append([0] * l) # Add a list the size of the this sequence to the 'x' list
self.__seqs.append(record.seq)
self.__K += l
self.__N += 1
def save_settings(self, filename):
handle = open(filename, "w");
print("P\t" + str(self.__P), file=handle)
print("d\t" + str(self.__d), file=handle)
print("l0\t" + str(self.__l0), file=handle)
print("l1\t" + str(self.__l1), file=handle)
print("l2\t" + str(self.__l2), file=handle)
print("N\t" + str(self.__N), file=handle)
print("Lmax\t" + str(self.__Lmax), file=handle)
print("K\t" + str(self.__K), file=handle)
print("Unused:", file=handle)
for i in range(len(self.unused)):
print("1" if self.unused[i] else "0", end="", file=handle)
print("", file=handle)
print("Reduced mode:\t" + str(self.__reduced), file=handle)
for v in self.__x:
print("x\t" + str(len(v)), file=handle)
handle.close()
def load_bvs(self, filename, active):
with open(filename) as f:
f.readline()
s = f.readline().strip()
# index = 0
for c in s.strip():
# while index < len(active) and active[index] == False:
# index += 1
# self.__bvs.append(0)
self.__bvs.append(int(c))
# index += 1
def get_energy_from_file(self, filename):
with open(filename) as f:
f.readline() # Number of bits
f.readline() # Solution
s = f.readline().strip() # Energy
parts = s.split()
return float(parts[0])
def make_msa(self):
msa = []
b_k = 0
for k in range(self.__N):
L_k = len(self.__x[k])
sa = []
for j in range(L_k):
b_kj = b_k + (j * self.m())
# pos = j # Ensures minimal offset to ensure characters don't stack up on each other (handles the -1 in E0).
pos = 0
for a in range(self.m()):
pos += 2 ** a if self.__bvs[b_kj + a] == 1 else 0
sa.append(abs(pos))
msa.append(sa)
b_k += L_k * self.m()
return msa
def make_gap_matrix(self):
gm = []
g_k = self.get_gVarOffset()
for k in range(self.__N):
klen = len(self.__x[k])
gr = []
for j in range(klen):
g_kj = g_k + (j * self.p())
pos = 0
for g_a in range(self.p()):
pos += 2 ** g_a if self.__bvs[g_kj + g_a] == 1 else 0
gr.append(pos)
gm.append(gr)
g_k += klen * self.p()
return gm
def bvm(self):
return self.__bvm
def W(self):
return self.__W
def N(self):
return self.__N
def K(self):
return self.__K
def P(self):
return self.__P
def d(self):
return self.__d
def M(self):
"""Returns the length of each row in solution space"""
min_m = 2 * self.__Lmax + 1
return 1 << (min_m - 1).bit_length()
def Lmax(self):
return self.__Lmax
def m(self):
"""Returns the number of binary variables required to represent each row in solution space"""
return math.ceil(np.log2(self.M()))
def p(self):
"""Returns the number of binary variables required to represent each gap"""
return math.ceil(np.log2(self.__P + 1))
def x(self):
return self.__x
def l0(self):
""" Penalty for placing the characters out of order."""
return self.__l0
def l1(self):
""" Penalty for adding gaps."""
return self.__l1
def l2(self):
""" Affinity of characters across sequences, lower values relaxes the aligner to spread-out positions. """
return self.__l2
def im(self):
return self.__qim
def getSolutionVars(self):
return self.__bvs
def getSolutionShape(self):
pvar = self.get_NbPositioningVars()
gvar = self.get_NbGapVars()
list=['X'] * pvar + ['G'] * gvar
if not self.__reduced:
rsize = 0
for i in range(self.get_rVarOffset(), self.get_rVarOffset() + self.get_NbRewardVars()):
if not self.unused[i]:
rsize += 1
ysize = 0
for i in range(self.get_yVarOffset(), self.get_yVarOffset() + self.get_NbYVars()):
if not self.unused[i]:
ysize += 1
zsize = 0
for i in range(self.get_zVarOffset(), self.get_zVarOffset() + self.get_NbZVars()):
if not self.unused[i]:
zsize += 1
list += ['R'] * rsize + ['Y'] * ysize + ['Z'] * zsize
return "[{0}]".format(", ".join(str(i) for i in list))
def getPosSolution(self):
return self.__bvs[0:self.get_NbPositioningVars()]
def getGapSolution(self):
return self.__bvs[self.get_gVarOffset():self.get_gVarOffset() + self.get_NbGapVars()]
def calc_solutionSpaceSize(self):
"""Size of the solution space"""
return self.__N * self.M()
def calc_minBV(self):
"""Calculate lower bound on number of binary variables required"""
return self.K() * (self.m() + self.p())
def calc_maxBV(self):
"""Calculate upper bound on number of binary variables required"""
return self.calc_minBV() + math.ceil(self.__N * (self.__N - 1) * (self.__Lmax ** 2) * (1 + 2 * self.m()) / 2)
def get_NbIV(self):
return self.get_NbPositioningVars(intmode=True) + self.get_NbGapVars(intmode=True)
def get_NbBV(self):
"""Return the actual number of binary variables required for this problem"""
return self.__bvm.shape[0]
# return self.get_NbPositioningVars() + self.get_NbGapVars() + self.get_NbRewardVars() + self.get_NbYVars() + self.get_NbZVars()
# return self.get_NbPositioningVars() + self.get_NbGapVars()
def get_gVarOffset(self, intmode=False):
"""Gets the offset (in terms of number of binary variables) for the first binary variable representing a gap"""
return self.get_NbPositioningVars(intmode)
def get_rVarOffset(self):
"""Gets the offset (in terms of number of binary variables) for the first binary variable representing a reward"""
return self.get_gVarOffset() + self.get_NbGapVars()
def get_yVarOffset(self):
"""Gets the offset (in terms of number of binary variables) for the first binary variable representing a reward"""
return self.get_rVarOffset() + self.get_NbRewardVars()
def get_zVarOffset(self):
"""Gets the offset (in terms of number of binary variables) for the first binary variable representing a reward"""
return self.get_yVarOffset() + self.get_NbYVars()
def getTotalBVs(self):
return self.get_zVarOffset() + self.get_NbZVars()
def get_NbPositioningVars(self, intmode=False):
return self.K() * self.m() if not intmode else self.K()
def get_NbGapVars(self, intmode=False):
return self.K() * self.p() if not intmode else self.K()
def get_NbRewardVars(self):
count = 0
for k in range(self.__N - 1):
klen = len(self.__x[k])
for q in range(k + 1, self.__N):
qlen = len(self.__x[q])
for i in range(klen):
for j in range(qlen):
count += 1
return count
def get_NbYVars(self):
return self.get_NbRewardVars() * self.m()
def get_NbZVars(self):
return self.get_NbRewardVars() * self.m()
def lenK(self, k):
return len(self.__x[k])
def qim(self, x, y):
return self.__qim[x, y]
def lil(self, x):
return self.__lil[x]
def printqim(self):
for k in range(self.N()):
L_k = len(self.__x[k])
for j in range(L_k):
print("x_", k, ",", j, sep="", end="")
print(" ", end="")
for k in range(self.N()):
L_k = len(self.__x[k])
for j in range(L_k):
print("G_", k, ",", j, sep="", end="")
print(" ", end="")
print()
print(self.__qim)
def printlil(self):
for k in range(self.N()):
L_k = len(self.__x[k])
for j in range(L_k):
print("x_", k, ",", j, sep="", end="")
print(" ", end="")
for k in range(self.N()):
L_k = len(self.__x[k])
for j in range(L_k):
print("G_", k, ",", j, sep="", end="")
print(" ", end="")
print()
print(self.__lil)
def printIntegerCoefficients(self):
np.set_printoptions(threshold=np.inf, linewidth=np.inf, suppress=True, precision=2)
print("Quadratic coefficients:")
self.printqim()
print()
print("Linear coefficients:")
self.printlil()
print()
print("Constant:")
print(self.ienergy)
print()
def plotMatrix(self, outpath):
matDims = self.get_NbBV()
G = np.zeros((matDims, matDims, 3))
B = np.zeros((matDims, matDims, 3))
G = np.copy(self.__bvm)
B = np.copy(self.__bvm)
lt0 = self.__bvm < 0
G[lt0] = 0
gt0 = self.__bvm > 0
B[gt0] = 0
G= G+1
G = np.log2(G)
B= np.abs(B)+1
B = np.log2(B)
F = G-B
#G[self.__bvm != 0] = [0, 0, 0]
#G[self.__bvm == 0] = [1, 1, 1]
plt.figure(figsize=(10, 10))
# plt.annotate(s="G", xy=((m2q.bvc.get_NbPositioningVars())*0.5,-1))
# plt.annotate(s="G", xy=(matDims,(m2q.bvc.get_NbPositioningVars())*0.5))
plt.axvline(self.get_NbPositioningVars() - 0.5)
plt.axhline(self.get_NbPositioningVars() - 0.5)
plt.axvline(self.get_NbPositioningVars() + self.get_NbGapVars() - 0.5)
plt.axhline(self.get_NbPositioningVars() + self.get_NbGapVars() - 0.5)
if not self.__reduced:
rsize = 0
for i in range(self.get_rVarOffset(), self.get_rVarOffset() + self.get_NbRewardVars()):
if not self.unused[i]:
rsize += 1
yoffset = self.get_rVarOffset() + rsize
ysize = 0
for i in range(self.get_yVarOffset(), self.get_yVarOffset() + self.get_NbYVars()):
if not self.unused[i]:
ysize += 1
zoffset = yoffset + ysize
plt.annotate(s="R", xy=((self.get_rVarOffset() + rsize) * 0.5, -1))
plt.annotate(s="R", xy=(matDims, (self.get_rVarOffset() + rsize) * 0.5))
plt.axvline(self.get_rVarOffset() - 0.5)
plt.axhline(self.get_rVarOffset() - 0.5)
plt.annotate(s="Y", xy=((yoffset + ysize) * 0.5, -1))
plt.annotate(s="Y", xy=(matDims, (yoffset + ysize) * 0.5))
plt.axvline(yoffset - 0.5)
plt.axhline(yoffset - 0.5)
plt.annotate(s="Z", xy=((zoffset + matDims) * 0.5, -1))
plt.annotate(s="Z", xy=(matDims + 0.11, (zoffset + matDims) * 0.5))
plt.axvline(zoffset - 0.5)
plt.axhline(zoffset - 0.5)
plt.imshow(F, cmap='RdGy', interpolation='nearest', vmin=-10, vmax=10)
plt.colorbar()
#plt.imshow(B, cmap='Greens', interpolation='nearest', alpha=0.5)
#plt.colorbar()
plt.savefig(outpath)
def __addE0Coefficients(self, intmode=False):
"""Updates the binary variable matrix with coefficients from E0"""
if intmode:
x_k = 0
G_k = self.get_gVarOffset(True)
for k in range(self.__N):
L_k = len(self.__x[k])
for j in range(L_k - 1):
x_kj = x_k + j
x_kj1 = x_kj + 1
G_kj1 = G_k + j + 1
# Nodes
self.__qim[x_kj, x_kj] += 1 # Squared
self.__qim[x_kj1, x_kj1] += 1 # Squared
self.__qim[G_kj1, G_kj1] += 1 # Squared
self.__qim[x_k, x_k] += 1 # Squared
self.__qim[G_k, G_k] += 1 # Squared
# Couplers
self.__qim[x_kj, x_kj1] += -2
self.__qim[x_kj, G_kj1] += 2
self.__qim[x_kj1, G_kj1] += -2
self.__qim[x_k, G_k] += -2
# Linear parts
self.__lil[x_kj] += 2
self.__lil[x_kj1] -= 2
self.__lil[G_kj1] += 2
# Left over energy
self.ienergy += 1
x_k += L_k
G_k += L_k
nbvars = self.get_NbPositioningVars(intmode=True) + self.get_NbGapVars(intmode=True)
for k in range(nbvars):
for j in range(k, nbvars):
self.__qim[k, j] *= self.__l0
self.__lil[k] *= self.__l0
self.ienergy *= self.__l0
else:
nbvars = self.get_NbPositioningVars() + self.get_NbGapVars()
e0bm = np.zeros((nbvars, nbvars))
x_k = 0
G_k = self.get_gVarOffset()
for k in range(self.__N):
L_k = len(self.__x[k])
for j in range(L_k - 1):
x_kj = x_k + (j * self.m())
x_kj1 = x_k + ((j + 1) * self.m())
G_kj1 = G_k + ((j + 1) * self.p())
self.energy += 1
# x nodes and xx couplings. Include quadratic and linear terms
for x_a1 in range(self.m()):
x_kja1 = x_kj + x_a1
x_kj1a1 = x_kj1 + x_a1
x_k1a1 = x_k + x_a1
linear_scale = 2 ** x_a1
quad_scale = 2 ** (2 * x_a1)
# X Nodes - linear parts
e0bm[x_kja1, x_kja1] += 2 * linear_scale
e0bm[x_kj1a1, x_kj1a1] -= 2 * linear_scale
# X Nodes - quadratic parts (on diagonal)
e0bm[x_kja1, x_kja1] += quad_scale
e0bm[x_kj1a1, x_kj1a1] += quad_scale
e0bm[x_k1a1, x_k1a1] += quad_scale
for x_a2 in range(x_a1+1, self.m()):
x_kja2 = x_kj + x_a2
x_kj1a2 = x_kj1 + x_a2
x_k1a2 = x_k + x_a2
off_quad_scale = 2 ** (x_a1 + x_a2 + 1)
# X Nodes - quadratic parts (off diagonal)
e0bm[x_kja1, x_kja2] += off_quad_scale
e0bm[x_kj1a1, x_kj1a2] += off_quad_scale
e0bm[x_k1a1, x_k1a2] += off_quad_scale
# g nodes
for G_a1 in range(self.p()):
g_kj1a1 = G_kj1 + G_a1
g_k1a1 = G_k + G_a1
linear_scale = 2 ** G_a1
quad_scale = 2 ** (2 * G_a1)
# Linear parts
e0bm[g_kj1a1, g_kj1a1] += 2 * linear_scale
# Quadratic parts (on diagonal)
e0bm[g_kj1a1, g_kj1a1] += quad_scale
e0bm[g_k1a1, g_k1a1] += quad_scale
for G_a2 in range(G_a1+1, self.p()):
g_kj1a2 = G_kj1 + G_a2
g_k1a2 = G_k + G_a2
off_quad_scale = 2 ** (G_a1 + G_a2 + 1)
# Quadratic parts
e0bm[g_kj1a1, g_kj1a2] += off_quad_scale
e0bm[g_k1a1, g_k1a2] += off_quad_scale
# xx - coupled
for x_a1 in range(self.m()):
for x_a2 in range(self.m()):
e0bm[x_kj + x_a1, x_kj1 + x_a2] -= 2 * 2 ** (x_a1 + x_a2)
# xG - coupled
for x_a in range(self.m()):
for G_a in range(self.p()):
quad_scale = 2 ** (G_a + x_a)
e0bm[x_kj + x_a, G_kj1 + G_a] += 2 * quad_scale
e0bm[x_kj1 + x_a, G_kj1 + G_a] -= 2 * quad_scale
e0bm[x_k + x_a, G_k + G_a] -= 2 * quad_scale
x_k += L_k * self.m()
G_k += L_k * self.p()
for k in range(nbvars):
for j in range(k, nbvars):
e0bm[k, j] *= self.__l0
self.energy *= self.__l0
return e0bm
def __addE1Coefficients(self, intmode=False):
"""Updates the binary variable matrix with coefficients from E1"""
if intmode:
g_k = self.get_gVarOffset(True)
for k in range(self.__N):
L_k = len(self.__x[k])
for j in range(1, L_k):
g_kj = g_k + j
self.__qim[g_kj, g_kj] += self.__l1
g_k += L_k
else:
nbvars = self.get_NbPositioningVars() + self.get_NbGapVars()
e1bm = np.zeros((nbvars, nbvars))
g_k = self.get_gVarOffset()
for k in range(self.__N):
L_k = len(self.__x[k])
for j in range(1, L_k):
g_kj = g_k + (j * self.p())
for a1 in range(self.p()):
g_kja1 = g_kj + a1
quad_scale = 2 ** (2 * a1)
e1bm[g_kja1, g_kja1] += self.__l1 * quad_scale
for a2 in range(a1+1, self.p()):
g_kja2 = g_kj + a2
off_quad_scale = 2 ** (a1 + a2 + 1)
e1bm[g_kja1, g_kja2] += self.__l1 * off_quad_scale
g_k += L_k * self.p()
return e1bm
def __addE2Coefficients(self, intmode=False):
"""Updates the binary variable matrix with coefficients from E2"""
if intmode:
pass
else:
e2bm = np.zeros((self.getTotalBVs(), self.getTotalBVs()))
pbK = 0
piK = 0
b_k = 0
for k in range(self.__N - 1):
size_iq = 0
size_bq = 0
b_q = b_k + len(self.__x[k]) * self.m()
for q in range(k + 1, self.__N):
size_ii = 0
size_bi = 0
for i in range(len(self.__x[k])):
b_ki = b_k + (i * self.m())
size_ij = 0
size_bj = 0
for j in range(len(self.__x[q])):
term1 = np.zeros((self.getTotalBVs(), self.getTotalBVs()))
term2 = np.zeros((self.getTotalBVs(), self.getTotalBVs()))
term3 = np.zeros((self.getTotalBVs(), self.getTotalBVs()))
pen1 = np.zeros((self.getTotalBVs(), self.getTotalBVs()))
pen2 = np.zeros((self.getTotalBVs(), self.getTotalBVs()))
pen3 = np.zeros((self.getTotalBVs(), self.getTotalBVs()))
Wijkq = self.w(i=i, j=j, k=k, q=q)
w_l2 = Wijkq * self.l2()
d1 = self.__d
d2 = self.__d * 2
d3 = self.__d * 3
b_qj = b_q + (j * self.m())
i_idx = piK + size_iq + size_ii + size_ij
b_idx = pbK + size_bq + size_bi + size_bj
r_kqij = self.get_rVarOffset() + i_idx
for a in range(self.m()):
b_kia = b_ki + a
b_qja = b_qj + a
y_kqija = self.get_yVarOffset() + b_idx + a
z_kqija = self.get_zVarOffset() + b_idx + a
ls = 2 ** a
# X and Y or Z blocks
for b in range(self.m()):
b_kib = b_ki + b
b_qjb = b_qj + b
quad_scale = 2 ** (a + b)
# Wijkq*Rijkq
e2bm[r_kqij][r_kqij] += Wijkq # OK
# z * x_3
term1[b_kib, y_kqija] += quad_scale
term2[b_qjb, z_kqija] += quad_scale
term3[b_qjb, y_kqija] += quad_scale
# delta * x_1 * x_2
pen1[b_kia, r_kqij] += d1 * ls
pen2[b_qja, r_kqij] += d1 * ls
pen3[b_kia, r_kqij] += d1 * ls
# -2 * delta * x_1 * z
pen1[r_kqij, y_kqija] -= d2 * ls
pen2[r_kqij, z_kqija] -= d2 * ls
pen3[r_kqij, y_kqija] -= d2 * ls
# -2 * delta * x_2 * z
pen1[b_kia, y_kqija] -= d2 * ls
pen2[b_qja, z_kqija] -= d2 * ls
pen3[b_kia, y_kqija] -= d2 * ls
# 3 * delta * z
pen1[y_kqija, y_kqija] += d3 * ls
pen2[z_kqija, z_kqija] += d3 * ls
pen3[y_kqija, y_kqija] += d3 * ls
for s in range(self.getTotalBVs()):
for t in range(s, self.getTotalBVs()):
e2bm[s, t] += -w_l2 * term1[s,t] - w_l2 * term2[s,t] + 2 * w_l2 * term3[s,t] - w_l2 * pen1[s,t] - w_l2 * pen2[s,t] - 2 * w_l2 * pen3[s,t]
size_ij += 1
size_bj += self.m()
size_ii += size_ij
size_bi += size_bj
size_iq += size_ii
size_bq += size_bi
b_q += len(self.__x[q]) * self.m()
pbK += size_bq
piK += size_iq
b_k += len(self.__x[k]) * self.m()
for k in range(self.getTotalBVs()):
for j in range(k, self.getTotalBVs()):
e2bm[k, j] = -e2bm[k,j]
return e2bm
def __calcNbNodes(self):
count = 0
for i in range(self.get_NbBV()):
if self.__bvm[i, i] != 0.0:
count += 1
return count
def __calcNbCouplers(self):
nbv = self.get_NbBV()
count = 0
for i in range(nbv - 1):
for j in range(i + 1, nbv):
if self.__bvm[i, j] != 0.0:
count += 1
return count
def calcActiveBVs(self):
nbv = self.get_NbBV()
self.active = [False] * nbv
for i in range(nbv):
for j in range(i, nbv):
if self.__bvm[i, j] != 0.0:
self.active[i] = True
break
self.nb_active = sum(self.active)
return self.nb_active
def createW(self):
N = self.__N
self.__W = []
for k in range(N - 1):
karray = []
for q in range(k + 1, N):
qarray = []
for i in range(len(self.__x[k])):
iarray = []
for j in range(len(self.__x[q])):
if self.__weights == None:
iarray.append(1. if self.__seqs[k][i] == self.__seqs[q][j] else 0.)
else:
iarray.append(float(self.__weights[self.__seqs[k][i]][self.__seqs[q][j]]))
qarray.append(iarray)
karray.append(qarray)
self.__W.append(karray)
def w(self, i, j, k, q):
return self.__W[k][q-k-1][i][j]
def sophiesMethod(self):
print("Optimal solution")
bvec=np.array([0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
0, 0, 0, 0, 0, 0, 0, 1,
1, 0, 0, 1, 0, 1, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
bvec=np.array([0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
1, 0, 0, 1, 0, 1, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
'''
bvec=np.array([0,0,0, 1,0,0, 0,0,0, 1,0,0,
0,0,0,0,
1,0,
0,0,0, 0,0,0,
0,0,0, 0,0,0])
#1,1,1, 1,1,1,
#0,0,0, 0,0,0])
'''
print(np.dot(bvec, np.dot(self.__bvm, bvec.transpose())))
def createBVMatrix(self, intmode=False, verbose=False):
"""Creates the symmetric binary variable matrix of coefficients from the energy function"""
if not intmode:
size = self.get_NbBV()
self.__bvm = np.zeros((size, size))
self.energy = 0
np.set_printoptions(threshold=np.inf, linewidth=np.inf, suppress=True, precision=2)
e0bm = self.__addE0Coefficients()
if verbose:
print("\n\nE0:\n", e0bm)
e1bm = self.__addE1Coefficients()
if verbose:
print("\n\nE1:\n", e1bm)
e2bm = self.__addE2Coefficients()
if verbose:
print("\n\nE2:\n", e2bm)
if self.__reduced:
print("REDUCED MODE!")
self.__bvm = e0bm + e1bm
else:
# Get unused BVs
self.__bvm = e2bm # For the final matrix just start with the E2 matrix
for i in range(self.get_rVarOffset()):
for j in range(self.get_rVarOffset()):
self.__bvm[i, j] += e0bm[i, j] + e1bm[i, j]
# Remove parts (columns and rows of BVM that are not required)
j = 0
size = len(self.__bvm)
for i in range(size):
if ~self.__bvm[:,j].any():
self.__bvm = np.delete(self.__bvm, j, 0)
self.__bvm = np.delete(self.__bvm, j, 1)
self.unused.append(True)
j -= 1
else:
self.unused.append(False)
j += 1
if verbose:
print("\n\nBVM:\n", self.__bvm)
print("\n\nW:\n", self.__W)
#self.sophiesMethod()
else:
isize = self.get_NbIV()
self.__qim = np.zeros((isize, isize))
self.__lil = [0] * isize
self.ienergy = 0
self.__addE0Coefficients(intmode=True)
self.__addE1Coefficients(intmode=True)
# return self.__bvm + self.__bvm.T - numpy.diag(self.__bvm.diagonal())
def writeQUBO(self, outfilepath, infilepath):
"""Outputs QUBO format representation"""
o = open(outfilepath, 'w')
print("c ---------\nc", file=o)
print("c QUBO format representation of ", infilepath, file=o)
print("c\np qubo 0 ", self.get_NbBV(), self.__calcNbNodes(), self.__calcNbCouplers(), file=o)
print("c\nc nodes\nc", file=o)
for i in range(self.get_NbBV()):
v = self.__bvm[i, i]
if v != 0:
print(i, i, v, file=o)
# Output elements
print("c\nc couplers\nc", file=o)
for i in range(self.get_NbBV() - 1):
for j in range(i + 1, self.get_NbBV()):
v = self.__bvm[i, j]
if v != 0:
print(i, j, v, file=o)
o.close()
| maplesond/msa2qubo | bvc.py | Python | gpl-3.0 | 26,542 | [
"Biopython"
] | db14ff0182df5cae3b0f89985e59707cb44d6b4ba1b0b7a9a7b512f2209b3846 |
#
# co_co_only_spike_buffer_data_types.py
#
# This file is part of NEST.
#
# Copyright (C) 2004 The NEST Initiative
#
# NEST is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# NEST is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with NEST. If not, see <http://www.gnu.org/licenses/>.
from pynestml.cocos.co_co import CoCo
from pynestml.utils.logger import LoggingLevel, Logger
from pynestml.utils.messages import Messages
from pynestml.visitors.ast_visitor import ASTVisitor
from pynestml.meta_model.ast_neuron import ASTNeuron
from pynestml.meta_model.ast_input_line import ASTInputLine
class CoCoOnlySpikeBufferDataTypes(CoCo):
"""
This coco ensures that all spike buffers have a data type and all current buffers no data type stated.
Allowed:
input:
spikeIn integer <- inhibitory spike
end
Not allowed:
input:
current integer <- current
end
"""
name = 'only spike buffers specified with data type'
description = 'TODO'
def check_co_co(self, node):
"""
Ensures the coco for the handed over neuron.
:param node: a single neuron instance.
:type node: ASTNeuron
"""
node.accept(BufferDatatypeVisitor())
class BufferDatatypeVisitor(ASTVisitor):
"""
This visitor checks if each buffer has a datatype selected according to the coco.
"""
def visit_input_line(self, node):
"""
Checks the coco on the current node.
:param node: a single input line node.
:type node: ASTInputLine
"""
if node.is_spike() and not node.has_datatype():
code, message = Messages.get_data_type_not_specified(node.get_name())
Logger.log_message(error_position=node.get_source_position(), log_level=LoggingLevel.ERROR,
code=code, message=message)
if node.is_current() and node.has_datatype():
code, message = Messages.get_not_type_allowed(node.get_name())
Logger.log_message(error_position=str(node.get_source_position()),
code=code, message=message,
log_level=LoggingLevel.ERROR)
return
| kperun/nestml | pynestml/cocos/co_co_only_spike_buffer_data_types.py | Python | gpl-2.0 | 2,673 | [
"NEURON"
] | e0be948f2e3783e33677a5c55320ed8be16def42b25433ce9f6825e12807c7da |
import logging
import httplib2
import json
import os
import hashlib
# This module performs authentication based on the tokens
# issued by Globus Online's Nexus service, see this URL for
# details:
# http://globusonline.github.com/nexus-docs/api.html
#
# Import the Globus Online client libraries, originally
# sourced from:
# https://github.com/globusonline/python-nexus-client
from nexus import Client
from django.contrib.auth.models import AnonymousUser,User
from django.contrib.auth import login,authenticate
from django.contrib.auth.middleware import AuthenticationMiddleware
from django.conf import settings
from django.http import HttpResponse
from pprint import pformat
"""
This is the 2-legged OAuth authentication code from tastypie
heavily modified into a django authentication middleware.
We base this on RemoteUserMiddleware so that we can get access to the
request object to have access to the request headers, and then we
simply re-use the existing remote user backend code
https://docs.djangoproject.com/en/1.4/howto/auth-remote-user/
You configure it the same way using the normal instructions, except
that you use this module oauth.TwoLeggedOAuthMiddleware instead of
django.contrib.auth.middleware.RemoteUserMiddleware
The django.contrib.auth.backends.RemoteUserBackend module is also
used with this module, add it into the AUTHENTICATION_BACKENDS
declaration in settings.py
To set the authentiction service to be used, set AUTHSVC in your
settings.py file. Here is an example:
AUTHSVC = 'https://graph.api.go.sandbox.globuscs.info/'
Django modules can check the request.META['KBASEsessid'] for the
session ID that will be used within the KBase session management
infrastructure
To test this, bind the sample handler into urls.py like this:
...
from oauth import AuthStatus
...
urlpatterns = patterns( ...
...
url(r'^authstatus/?$', AuthStatus),
...
)
Then visit the authstatus URL to see the auth state.
If you have the perl Bio::KBase::AuthToken libraries installed,
you can test it like this:
token=`perl -MBio::KBase::AuthToken -e 'print Bio::KBase::AuthToken->new( user_id => "papa", password => "papa")->token,"\n";'`
curl -H "Authorization: Bearer $token" http://127.0.0.1:8000/authstatus/
Steve Chan
sychan@lbl.gov
9/6/2012
Previous documentation follows:
This is a simple 2-legged OAuth authentication model for tastypie.
Copied nearly verbatim from gregbayer's piston example
- https://github.com/gregbayer/django-piston-two-legged-oauth
Dependencies:
- python-oauth2: https://github.com/simplegeo/python-oauth2
Adapted from example:
- http://philipsoutham.com/post/2172924723/two-legged-oauth-in-python
"""
class OAuth2Middleware(AuthenticationMiddleware):
"""
Two Legged OAuth authenticator.
This Authentication method checks for a provided HTTP_AUTHORIZATION
and looks up to see if this is a valid OAuth Consumer
"""
# Authentication server
# Create a Python Globus client
client = Client(config_file=os.path.join(os.path.dirname(__file__), 'nexus/nexus.yml'))
try:
authsvc = "https://%s/" % client.config['server']
except:
authsvc = 'https://nexus.api.globusonline.org/'
# Set the salt used for computing a session hash from the signature hash
salt = "(African || European)?"
def __init__(self, realm='API'):
self.realm = realm
self.user = None
self.http = httplib2.Http(disable_ssl_certificate_validation=True)
# The shortcut option will bypass token validation if we already have a django session
self.shortcut = False
def process_request(self, request):
"""
Verify 2-legged oauth request. Parameters accepted as
values in "Authorization" header, or as a GET request
or in a POST body.
"""
# AuthenticationMiddleware is required so that request.user exists.
if not hasattr(request, 'user'):
raise ImproperlyConfigured(
"The Django remote user auth middleware requires the"
" authentication middleware to be installed. Edit your"
" MIDDLEWARE_CLASSES setting to insert"
" 'django.contrib.auth.middleware.AuthenticationMiddleware'"
" before the RemoteUserMiddleware class.")
try:
if 'HTTP_AUTHORIZATION' in request.META:
auth_header = request.META.get('HTTP_AUTHORIZATION')
else:
logging.debug("No authorization header found.")
return None
# Extract the token based on whether it is an OAuth or Bearer
# token
if auth_header[:6] == 'OAuth ':
token = auth_header[6:]
elif auth_header[:7] == 'Bearer ':
token = auth_header[7:]
else:
logging.info("Authorization header did not contain OAuth or Bearer type token")
return None
# Push the token into the META for future reference
request.META['KBASEtoken'] = token
if (request.user.is_authenticated() and self.shortcut):
return
user_id = OAuth2Middleware.client.authenticate_user( token)
if not user_id:
logging.error("Authentication token failed validation")
return None
else:
logging.info("Validated as user " + user_id)
token_map = {}
for entry in token.split('|'):
key, value = entry.split('=')
token_map[key] = value
profile = self.get_profile(token)
if (profile == None):
logging.error("Token validated, but could not retrieve user profile")
return None
# For now, compute a sessionid based on hashing the
# the signature with the salt
request.META['KBASEsessid'] = hashlib.sha256(token_map['sig']+OAuth2Middleware.salt).hexdigest()
# Add in some useful details that came in from the token validation
request.META['KBASEprofile'] = profile
# See if the username is already associated with any currently logged
# in user, if so just pass over the rest
# Raises exception if it doesn't pass
user = authenticate(remote_user=profile['username'])
if user:
request.user = user
# For now, compute a sessionid based on hashing the
# the signature with the salt
request.META['KBASEsessid'] = hashlib.sha256(token_map['sig']+OAuth2Middleware.salt).hexdigest()
print pformat( request.META['KBASEsessid'])
# Add in some useful details that came in from the token validation
request.META['KBASEprofile'] = profile
login(request,user)
else:
logging.error( "Failed to return user from call to authenticate() with username " + profile['username'])
except KeyError, e:
logging.exception("KeyError in TwoLeggedOAuthMiddleware: %s" % e)
request.user = AnonymousUser()
except Exception, e:
logging.exception("Error in TwoLeggedOAuthMiddleware: %s" % e)
def get_profile(self,token):
try:
token_map = {}
for entry in token.split('|'):
key, value = entry.split('=')
token_map[key] = value
keyurl = self.__class__.authsvc + "/users/" + token_map['un'] + "?custom_fields=*"
res,body = self.http.request(keyurl,"GET",
headers={ 'Authorization': 'Globus-Goauthtoken ' + token })
if (200 <= int(res.status)) and ( int(res.status) < 300):
profile = json.loads( body)
return profile
logging.error( body)
raise Exception("HTTP", res)
except Exception, e:
logging.exception("Error in get_profile.")
return None
def AuthStatus(request):
res = "request.user.is_authenticated = %s \n" % request.user.is_authenticated()
if request.user.is_authenticated():
res = res + "request.user.username = %s\n" % request.user.username
if 'KBASEsessid' in request.META:
res = res + "Your KBase SessionID is %s\n" % request.META['KBASEsessid']
if 'KBASEprofile' in request.META:
res = res + "Your profile record is:\n%s\n" % pformat( request.META['KBASEprofile'])
if 'KBASEtoken' in request.META:
res = res + "Your OAuth token is:\n%s\n" % pformat( request.META['KBASEtoken'])
return HttpResponse(res)
| kbase/auth_service | python-libs/oauth.py | Python | mit | 8,778 | [
"VisIt"
] | 89a721fbba3a6c15c97afd75c9546cd897a3354b3a6c6ee57f12796494b480f1 |
#!/usr/bin/env python
from sys import argv, stderr, exit
import subprocess
import numpy as np
from argparse import ArgumentParser
try:
from exactP import exactP_list
except:
stderr.write("Please build the exactP module by running 'make exactP'.\n")
exit(1)
try:
from PISMNC import PISMDataset
except:
subprocess.call("ln -sf ../../util/PISMNC.py", shell=True)
from PISMNC import PISMDataset
def parse_options():
stderr.write("reading options ...\n")
parser = ArgumentParser()
parser.description = "Test P (verification of '-hydrology distributed')."
parser.add_argument("--pism_path", dest="PISM_PATH", default=".")
parser.add_argument("--mpiexec", dest="MPIEXEC", default="")
parser.add_argument("--Mx",dest="Mx", help="Horizontal grid size. Default corresponds to a 1km grid.", type=int, default=51)
parser.add_argument("--keep", dest="keep", action="store_true", help="Keep the generated PISM input file.")
return parser.parse_args()
def generate_config():
"""Generates the config file with custom ice softness and hydraulic conductivity."""
stderr.write("generating testPconfig.nc ...\n")
nc = PISMDataset("testPconfig.nc", 'w')
pism_overrides = nc.createVariable("pism_overrides", 'b')
pism_overrides.ice_softness = 3.1689e-24
pism_overrides.ice_softness_doc = "Pa-3 s-1; ice softness; NOT DEFAULT"
pism_overrides.hydrology_hydraulic_conductivity = 1.0e-2 / (1000.0 * 9.81)
pism_overrides.hydrology_hydraulic_conductivity_doc = "= k; NOT DEFAULT"
pism_overrides.hydrology_regularizing_porosity = 0.01;
pism_overrides.hydrology_regularizing_porosity_doc = "[pure]; phi_0 in notes";
pism_overrides.hydrology_tillwat_max = 0.0;
pism_overrides.hydrology_tillwat_max_doc = "m; turn off till water mechanism";
pism_overrides.hydrology_thickness_power_in_flux = 1.0;
pism_overrides.hydrology_thickness_power_in_flux_doc = "; = alpha in notes";
pism_overrides.hydrology_gradient_power_in_flux = 2.0;
pism_overrides.hydrology_gradient_power_in_flux_doc = "; = beta in notes";
pism_overrides.hydrology_roughness_scale = 1.0;
pism_overrides.hydrology_roughness_scale_doc = "m; W_r in notes; roughness scale";
pism_overrides.yield_stress_model = "constant";
pism_overrides.yield_stress_model_doc = "only the constant yield stress model works without till";
pism_overrides.default_tauc = 1e6;
pism_overrides.default_tauc_doc = "set default to 'high tauc'";
nc.close()
def report_drift(file1, file2):
"Report on the difference between two files."
nc1 = PISMDataset(file1)
nc2 = PISMDataset(file2)
for name in ("bwat", "bwp"):
var1 = nc1.variables[name]
var2 = nc2.variables[name]
diff = np.abs(np.squeeze(var1[:]) - np.squeeze(var2[:]))
stderr.write("Drift in %s: average = %f, max = %f [%s]" % (name, np.average(diff), np.max(diff), var1.units) + "\n")
def create_grid(Mx):
Lx = 25.0e3 # outside L = 22.5 km
x = np.linspace(-Lx, Lx, Mx)
xx, yy = np.meshgrid(x, x)
return x, x, xx, yy
def radially_outward(mag, x, y):
"""return components of a vector field V(x,y) which is radially-outward from
the origin and has magnitude mag"""
r = np.sqrt(x*x + y*y)
if r == 0.0:
return (0.0, 0.0)
vx = mag * x / r
vy = mag * y / r
return (vx, vy)
def compute_sorted_radii(xx, yy):
stderr.write("sorting radial variable ...\n")
Mx = xx.shape[0]
# create 1D array of tuples (r,j,k), sorted by r-value
dtype = [('r', float), ('j', int), ('k', int)]
rr = np.empty((Mx,Mx), dtype=dtype)
for j in range(Mx):
for k in range(Mx):
rr[j,k] = (np.sqrt(xx[j,k]**2 + yy[j,k]**2), j, k)
r = np.sort(rr.flatten(), order='r')
return np.flipud(r)
def generate_pism_input(x, y, xx, yy):
stderr.write("calling exactP_list() ...\n")
EPS_ABS = 1.0e-12
EPS_REL = 1.0e-15
# Wrapping r[:]['r'] in np.array() forces NumPy to make a C-contiguous copy.
h_r, magvb_r, _, W_r, P_r = exactP_list(np.array(r[:]['r']), EPS_ABS, EPS_REL, 1)
stderr.write("creating gridded variables ...\n")
# put on grid
h = np.zeros_like(xx)
W = np.zeros_like(xx)
P = np.zeros_like(xx)
magvb = np.zeros_like(xx)
ussa = np.zeros_like(xx)
vssa = np.zeros_like(xx)
for n,pt in enumerate(r):
j = pt['j']
k = pt['k']
h[j,k] = h_r[n] # ice thickness in m
magvb[j,k] = magvb_r[n] # sliding speed in m s-1
ussa[j,k], vssa[j,k] = radially_outward(magvb[j,k], xx[j,k], yy[j,k])
W[j,k] = W_r[n] # water thickness in m
P[j,k] = P_r[n] # water pressure in Pa
stderr.write("creating inputforP.nc ...\n")
nc = PISMDataset("inputforP.nc", 'w')
nc.create_dimensions(x, y, time_dependent = True, use_time_bounds = True)
nc.define_2d_field("thk", time_dependent = False,
attrs = {"long_name" : "ice thickness",
"units" : "m",
"valid_min" : 0.0,
"standard_name" : "land_ice_thickness"})
nc.define_2d_field("topg", time_dependent = False,
attrs = {"long_name" : "bedrock topography",
"units" : "m",
"standard_name" : "bedrock_altitude"})
nc.define_2d_field("climatic_mass_balance", time_dependent = False,
attrs = {"long_name" : "climatic mass balance for -surface given",
"units" : "kg m-2 year-1",
"standard_name" : "land_ice_surface_specific_mass_balance"})
nc.define_2d_field("ice_surface_temp", time_dependent = False,
attrs = {"long_name" : "ice surface temp (K) for -surface given",
"units" : "Kelvin",
"valid_min" : 0.0})
nc.define_2d_field("bmelt", time_dependent = False,
attrs = {"long_name" : "basal melt rate",
"units" : "m year-1",
"standard_name" : "land_ice_basal_melt_rate"})
nc.define_2d_field("bwat", time_dependent = False,
attrs = {"long_name" : "thickness of basal water layer",
"units" : "m",
"valid_min" : 0.0})
nc.define_2d_field("bwp", time_dependent = False,
attrs = {"long_name" : "water pressure in basal water layer",
"units" : "Pa",
"valid_min" : 0.0})
nc.define_2d_field("bcflag", time_dependent = False,
attrs = {"long_name" : "if =1, apply u_ssa_bc and v_ssa_bc as sliding velocity"})
nc.define_2d_field("u_ssa_bc", time_dependent = False,
attrs = {"long_name" : "x-component of prescribed sliding velocity",
"units" : "m s-1"})
nc.define_2d_field("v_ssa_bc", time_dependent = False,
attrs = {"long_name" : "y-component of prescribed sliding velocity",
"units" : "m s-1"})
Phi0 = 0.20 # 20 cm/year basal melt rate
T_surface = 260 # ice surface temperature, K
variables = {"topg" : np.zeros_like(xx),
"climatic_mass_balance" : np.zeros_like(xx),
"ice_surface_temp" : np.ones_like(xx) + T_surface,
"bmelt" : np.zeros_like(xx) + Phi0,
"thk" : h,
"bwat" : W,
"bwp" : P,
"bcflag" : np.ones_like(xx),
"u_ssa_bc" : ussa,
"v_ssa_bc" : vssa}
for name in variables.keys():
nc.write(name, variables[name])
nc.history = subprocess.list2cmdline(argv)
nc.close()
stderr.write("NetCDF file %s written\n" % "inputforP.nc")
def run_pism(opts):
stderr.write("Testing: Test P verification of '-hydrology distributed'.\n")
cmd = "%s %s/pismr -config_override testPconfig.nc -boot_file inputforP.nc -Mx %d -My %d -Mz 11 -Lz 4000 -hydrology distributed -report_mass_accounting -y 0.08333333333333 -max_dt 0.01 -no_mass -energy none -stress_balance ssa+sia -ssa_dirichlet_bc -o end.nc" % (opts.MPIEXEC, opts.PISM_PATH, opts.Mx, opts.Mx)
stderr.write(cmd + "\n")
subprocess.call(cmd, shell=True)
# high-res and parallel example:
# ./runTestP.py --pism_path=../../build --mpiexec="mpiexec -n 4" --Mx=201
# example which should suffice for regression:
# ./runTestP.py --pism_path=../../build --Mx=21
if __name__ == "__main__":
opts = parse_options()
x,y,xx,yy = create_grid(opts.Mx)
r = compute_sorted_radii(xx, yy)
generate_config()
generate_pism_input(x, y, xx, yy)
run_pism(opts)
report_drift("inputforP.nc", "end.nc")
#cleanup:
if opts.keep == False:
subprocess.call("rm testPconfig.nc inputforP.nc end.nc", shell=True)
| talbrecht/pism_pik06 | test/test_hydrology/runTestP.py | Python | gpl-3.0 | 8,902 | [
"NetCDF"
] | 0dc94603b177687e9836435b795c88bb402373b1b8e411aea56b1fef92422212 |
# Copyright (C) 2012,2013
# Max Planck Institute for Polymer Research
# Copyright (C) 2008,2009,2010,2011
# Max-Planck-Institute for Polymer Research & Fraunhofer SCAI
#
# This file is part of ESPResSo++.
#
# ESPResSo++ is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# ESPResSo++ is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import unittest
import espressopp
import espressopp.esutil
import espressopp.storage
import espressopp.integrator
import espressopp.interaction
import espressopp.analysis
import espressopp.bc
import mpi4py.MPI as MPI
import math
import logging
from espressopp import Real3D
# Input values for system
N = 10
cutoff = 2.5
skin = 0.3
def calcNumberCells(size, nodes, cutoff):
ncells = 1
while size / (ncells * nodes) >= cutoff:
ncells = ncells + 1
return ncells - 1
class TestVerletList(unittest.TestCase) :
def test0Build(self) :
system = espressopp.System()
rng = espressopp.esutil.RNG()
SIZE = float(N)
box = Real3D(SIZE)
bc = espressopp.bc.OrthorhombicBC(None, box)
system.bc = bc
system.rng = rng
system.skin = skin
comm = espressopp.MPI.COMM_WORLD
nodeGrid = [1, 1, comm.size]
cellGrid = [1, 1, 1]
for i in range(3):
cellGrid[i] = calcNumberCells(SIZE, nodeGrid[i], cutoff)
print('NodeGrid = %s'%(nodeGrid,))
print('CellGrid = %s'%cellGrid)
dd = espressopp.storage.DomainDecomposition(system, nodeGrid, cellGrid)
system.storage = dd
id = 0
for i in range(N):
for j in range(N):
for k in range(N):
m = (i + 2*j + 3*k) % 11
r = 0.45 + m * 0.01
x = (i + r) / N * SIZE
y = (j + r) / N * SIZE
z = (k + r) / N * SIZE
dd.addParticle(id, Real3D(x, y, z))
# not yet: dd.setVelocity(id, (1.0, 0.0, 0.0))
id = id + 1
dd.decompose()
integrator = espressopp.integrator.VelocityVerlet(system)
print('integrator.dt = %g, will be set to 0.005'%integrator.dt)
integrator.dt = 0.005
print('integrator.dt = %g, is now '%integrator.dt)
# now build Verlet List
# ATTENTION: you have to add the skin explicitly here
vl = espressopp.VerletList(system, cutoff = cutoff + system.skin)
potLJ = espressopp.interaction.LennardJones(1.0, 1.0, cutoff = cutoff)
# ATTENTION: auto shift was enabled
print("potLJ, shift = %g"%potLJ.shift)
interLJ = espressopp.interaction.VerletListLennardJones(vl)
interLJ.setPotential(type1 = 0, type2 = 0, potential = potLJ)
# Todo
system.addInteraction(interLJ)
temp = espressopp.analysis.Temperature(system)
temperature = temp.compute()
kineticEnergy = 0.5 * temperature * (3 * N * N * N)
potentialEnergy = interLJ.computeEnergy()
print('Start: tot energy = %10.6f pot = %10.6f kin = %10.f temp = %10.6f'%(kineticEnergy + potentialEnergy,
potentialEnergy, kineticEnergy, temperature))
nsteps = 10
# logging.getLogger("MDIntegrator").setLevel(logging.DEBUG)
for i in range(20):
integrator.run(nsteps)
temperature = temp.compute()
kineticEnergy = 0.5 * temperature * (3 * N * N * N)
potentialEnergy = interLJ.computeEnergy()
print('Step %6d: tot energy = %10.6f pot = %10.6f kin = %10.6f temp = %f'%(nsteps*(i+1),
kineticEnergy + potentialEnergy, potentialEnergy, kineticEnergy, temperature))
if __name__ == "__main__":
unittest.main()
| espressopp/espressopp | testsuite/integrator/testVelocityVerlet.py | Python | gpl-3.0 | 4,313 | [
"ESPResSo"
] | d4e5b75a39478a6b97d7d748a9341037c35d92cf3299df4bbea5b73797e86352 |
import math
import numpy as np
from scipy import ndimage as ndi
from scipy.ndimage import filters as ndif
from collections import OrderedDict
from ..exposure import histogram
from .._shared.utils import assert_nD, warn
__all__ = ['try_all_threshold',
'threshold_adaptive',
'threshold_otsu',
'threshold_yen',
'threshold_isodata',
'threshold_li',
'threshold_minimum',
'threshold_mean',
'threshold_triangle']
def _try_all(image, methods=None, figsize=None, num_cols=2, verbose=True):
"""Returns a figure comparing the outputs of different methods.
Parameters
----------
image : (N, M) ndarray
Input image.
methods : dict, optional
Names and associated functions.
Functions must take and return an image.
figsize : tuple, optional
Figure size (in inches).
num_cols : int, optional
Number of columns.
verbose : bool, optional
Print function name for each method.
Returns
-------
fig, ax : tuple
Matplotlib figure and axes.
"""
from matplotlib import pyplot as plt
num_rows = math.ceil((len(methods) + 1.) / num_cols)
num_rows = int(num_rows) # Python 2.7 support
fig, ax = plt.subplots(num_rows, num_cols, figsize=figsize,
sharex=True, sharey=True,
subplot_kw={'adjustable': 'box-forced'})
ax = ax.ravel()
ax[0].imshow(image, cmap=plt.cm.gray)
ax[0].set_title('Original')
i = 1
for name, func in methods.items():
ax[i].imshow(func(image), cmap=plt.cm.gray)
ax[i].set_title(name)
i += 1
if verbose:
print(func.__orifunc__)
for a in ax:
a.axis('off')
fig.tight_layout()
return fig, ax
def try_all_threshold(image, figsize=(8, 5), verbose=True):
"""Returns a figure comparing the outputs of different thresholding methods.
Parameters
----------
image : (N, M) ndarray
Input image.
figsize : tuple, optional
Figure size (in inches).
verbose : bool, optional
Print function name for each method.
Returns
-------
fig, ax : tuple
Matplotlib figure and axes.
Notes
-----
The following algorithms are used:
* isodata
* li
* mean
* minimum
* otsu
* triangle
* yen
Examples
--------
>>> from skimage.data import text
>>> fig, ax = try_all_threshold(text(), figsize=(10, 6), verbose=False)
"""
def thresh(func):
"""
A wrapper function to return a thresholded image.
"""
def wrapper(im):
return im > func(im)
try:
wrapper.__orifunc__ = func.__orifunc__
except AttributeError:
wrapper.__orifunc__ = func.__module__ + '.' + func.__name__
return wrapper
# Global algorithms.
methods = OrderedDict({'Isodata': thresh(threshold_isodata),
'Li': thresh(threshold_li),
'Mean': thresh(threshold_mean),
'Minimum': thresh(threshold_minimum),
'Otsu': thresh(threshold_otsu),
'Triangle': thresh(threshold_triangle),
'Yen': thresh(threshold_yen)})
return _try_all(image, figsize=figsize,
methods=methods, verbose=verbose)
def threshold_adaptive(image, block_size, method='gaussian', offset=0,
mode='reflect', param=None):
"""Applies an adaptive threshold to an array.
Also known as local or dynamic thresholding where the threshold value is
the weighted mean for the local neighborhood of a pixel subtracted by a
constant. Alternatively the threshold can be determined dynamically by a a
given function using the 'generic' method.
Parameters
----------
image : (N, M) ndarray
Input image.
block_size : int
Odd size of pixel neighborhood which is used to calculate the
threshold value (e.g. 3, 5, 7, ..., 21, ...).
method : {'generic', 'gaussian', 'mean', 'median'}, optional
Method used to determine adaptive threshold for local neighbourhood in
weighted mean image.
* 'generic': use custom function (see `param` parameter)
* 'gaussian': apply gaussian filter (see `param` parameter for custom\
sigma value)
* 'mean': apply arithmetic mean filter
* 'median': apply median rank filter
By default the 'gaussian' method is used.
offset : float, optional
Constant subtracted from weighted mean of neighborhood to calculate
the local threshold value. Default offset is 0.
mode : {'reflect', 'constant', 'nearest', 'mirror', 'wrap'}, optional
The mode parameter determines how the array borders are handled, where
cval is the value when mode is equal to 'constant'.
Default is 'reflect'.
param : {int, function}, optional
Either specify sigma for 'gaussian' method or function object for
'generic' method. This functions takes the flat array of local
neighbourhood as a single argument and returns the calculated
threshold for the centre pixel.
Returns
-------
threshold : (N, M) ndarray
Thresholded binary image
References
----------
.. [1] http://docs.opencv.org/modules/imgproc/doc/miscellaneous_transformations.html?highlight=threshold#adaptivethreshold
Examples
--------
>>> from skimage.data import camera
>>> image = camera()[:50, :50]
>>> binary_image1 = threshold_adaptive(image, 15, 'mean')
>>> func = lambda arr: arr.mean()
>>> binary_image2 = threshold_adaptive(image, 15, 'generic', param=func)
"""
if block_size % 2 == 0:
raise ValueError("The kwarg ``block_size`` must be odd! Given "
"``block_size`` {0} is even.".format(block_size))
assert_nD(image, 2)
thresh_image = np.zeros(image.shape, 'double')
if method == 'generic':
ndi.generic_filter(image, param, block_size,
output=thresh_image, mode=mode)
elif method == 'gaussian':
if param is None:
# automatically determine sigma which covers > 99% of distribution
sigma = (block_size - 1) / 6.0
else:
sigma = param
ndi.gaussian_filter(image, sigma, output=thresh_image, mode=mode)
elif method == 'mean':
mask = 1. / block_size * np.ones((block_size,))
# separation of filters to speedup convolution
ndi.convolve1d(image, mask, axis=0, output=thresh_image, mode=mode)
ndi.convolve1d(thresh_image, mask, axis=1,
output=thresh_image, mode=mode)
elif method == 'median':
ndi.median_filter(image, block_size, output=thresh_image, mode=mode)
return image > (thresh_image - offset)
def threshold_otsu(image, nbins=256):
"""Return threshold value based on Otsu's method.
Parameters
----------
image : (N, M) ndarray
Grayscale input image.
nbins : int, optional
Number of bins used to calculate histogram. This value is ignored for
integer arrays.
Returns
-------
threshold : float
Upper threshold value. All pixels with an intensity higher than
this value are assumed to be foreground.
Raises
------
ValueError
If `image` only contains a single grayscale value.
References
----------
.. [1] Wikipedia, http://en.wikipedia.org/wiki/Otsu's_Method
Examples
--------
>>> from skimage.data import camera
>>> image = camera()
>>> thresh = threshold_otsu(image)
>>> binary = image <= thresh
Notes
-----
The input image must be grayscale.
"""
if image.shape[-1] in (3, 4):
msg = "threshold_otsu is expected to work correctly only for " \
"grayscale images; image shape {0} looks like an RGB image"
warn(msg.format(image.shape))
# Check if the image is multi-colored or not
if image.min() == image.max():
raise ValueError("threshold_otsu is expected to work with images "
"having more than one color. The input image seems "
"to have just one color {0}.".format(image.min()))
hist, bin_centers = histogram(image.ravel(), nbins)
hist = hist.astype(float)
# class probabilities for all possible thresholds
weight1 = np.cumsum(hist)
weight2 = np.cumsum(hist[::-1])[::-1]
# class means for all possible thresholds
mean1 = np.cumsum(hist * bin_centers) / weight1
mean2 = (np.cumsum((hist * bin_centers)[::-1]) / weight2[::-1])[::-1]
# Clip ends to align class 1 and class 2 variables:
# The last value of `weight1`/`mean1` should pair with zero values in
# `weight2`/`mean2`, which do not exist.
variance12 = weight1[:-1] * weight2[1:] * (mean1[:-1] - mean2[1:]) ** 2
idx = np.argmax(variance12)
threshold = bin_centers[:-1][idx]
return threshold
def threshold_yen(image, nbins=256):
"""Return threshold value based on Yen's method.
Parameters
----------
image : (N, M) ndarray
Input image.
nbins : int, optional
Number of bins used to calculate histogram. This value is ignored for
integer arrays.
Returns
-------
threshold : float
Upper threshold value. All pixels with an intensity higher than
this value are assumed to be foreground.
References
----------
.. [1] Yen J.C., Chang F.J., and Chang S. (1995) "A New Criterion
for Automatic Multilevel Thresholding" IEEE Trans. on Image
Processing, 4(3): 370-378. DOI:10.1109/83.366472
.. [2] Sezgin M. and Sankur B. (2004) "Survey over Image Thresholding
Techniques and Quantitative Performance Evaluation" Journal of
Electronic Imaging, 13(1): 146-165, DOI:10.1117/1.1631315
http://www.busim.ee.boun.edu.tr/~sankur/SankurFolder/Threshold_survey.pdf
.. [3] ImageJ AutoThresholder code, http://fiji.sc/wiki/index.php/Auto_Threshold
Examples
--------
>>> from skimage.data import camera
>>> image = camera()
>>> thresh = threshold_yen(image)
>>> binary = image <= thresh
"""
hist, bin_centers = histogram(image.ravel(), nbins)
# On blank images (e.g. filled with 0) with int dtype, `histogram()`
# returns `bin_centers` containing only one value. Speed up with it.
if bin_centers.size == 1:
return bin_centers[0]
# Calculate probability mass function
pmf = hist.astype(np.float32) / hist.sum()
P1 = np.cumsum(pmf) # Cumulative normalized histogram
P1_sq = np.cumsum(pmf ** 2)
# Get cumsum calculated from end of squared array:
P2_sq = np.cumsum(pmf[::-1] ** 2)[::-1]
# P2_sq indexes is shifted +1. I assume, with P1[:-1] it's help avoid '-inf'
# in crit. ImageJ Yen implementation replaces those values by zero.
crit = np.log(((P1_sq[:-1] * P2_sq[1:]) ** -1) *
(P1[:-1] * (1.0 - P1[:-1])) ** 2)
return bin_centers[crit.argmax()]
def threshold_isodata(image, nbins=256, return_all=False):
"""Return threshold value(s) based on ISODATA method.
Histogram-based threshold, known as Ridler-Calvard method or inter-means.
Threshold values returned satisfy the following equality:
`threshold = (image[image <= threshold].mean() +`
`image[image > threshold].mean()) / 2.0`
That is, returned thresholds are intensities that separate the image into
two groups of pixels, where the threshold intensity is midway between the
mean intensities of these groups.
For integer images, the above equality holds to within one; for floating-
point images, the equality holds to within the histogram bin-width.
Parameters
----------
image : (N, M) ndarray
Input image.
nbins : int, optional
Number of bins used to calculate histogram. This value is ignored for
integer arrays.
return_all: bool, optional
If False (default), return only the lowest threshold that satisfies
the above equality. If True, return all valid thresholds.
Returns
-------
threshold : float or int or array
Threshold value(s).
References
----------
.. [1] Ridler, TW & Calvard, S (1978), "Picture thresholding using an
iterative selection method"
IEEE Transactions on Systems, Man and Cybernetics 8: 630-632,
DOI:10.1109/TSMC.1978.4310039
.. [2] Sezgin M. and Sankur B. (2004) "Survey over Image Thresholding
Techniques and Quantitative Performance Evaluation" Journal of
Electronic Imaging, 13(1): 146-165,
http://www.busim.ee.boun.edu.tr/~sankur/SankurFolder/Threshold_survey.pdf
DOI:10.1117/1.1631315
.. [3] ImageJ AutoThresholder code,
http://fiji.sc/wiki/index.php/Auto_Threshold
Examples
--------
>>> from skimage.data import coins
>>> image = coins()
>>> thresh = threshold_isodata(image)
>>> binary = image > thresh
"""
hist, bin_centers = histogram(image.ravel(), nbins)
# image only contains one unique value
if len(bin_centers) == 1:
if return_all:
return bin_centers
else:
return bin_centers[0]
hist = hist.astype(np.float32)
# csuml and csumh contain the count of pixels in that bin or lower, and
# in all bins strictly higher than that bin, respectively
csuml = np.cumsum(hist)
csumh = np.cumsum(hist[::-1])[::-1] - hist
# intensity_sum contains the total pixel intensity from each bin
intensity_sum = hist * bin_centers
# l and h contain average value of all pixels in that bin or lower, and
# in all bins strictly higher than that bin, respectively.
# Note that since exp.histogram does not include empty bins at the low or
# high end of the range, csuml and csumh are strictly > 0, except in the
# last bin of csumh, which is zero by construction.
# So no worries about division by zero in the following lines, except
# for the last bin, but we can ignore that because no valid threshold
# can be in the top bin. So we just patch up csumh[-1] to not cause 0/0
# errors.
csumh[-1] = 1
l = np.cumsum(intensity_sum) / csuml
h = (np.cumsum(intensity_sum[::-1])[::-1] - intensity_sum) / csumh
# isodata finds threshold values that meet the criterion t = (l + m)/2
# where l is the mean of all pixels <= t and h is the mean of all pixels
# > t, as calculated above. So we are looking for places where
# (l + m) / 2 equals the intensity value for which those l and m figures
# were calculated -- which is, of course, the histogram bin centers.
# We only require this equality to be within the precision of the bin
# width, of course.
all_mean = (l + h) / 2.0
bin_width = bin_centers[1] - bin_centers[0]
# Look only at thresholds that are below the actual all_mean value,
# for consistency with the threshold being included in the lower pixel
# group. Otherwise can get thresholds that are not actually fixed-points
# of the isodata algorithm. For float images, this matters less, since
# there really can't be any guarantees anymore anyway.
distances = all_mean - bin_centers
thresholds = bin_centers[(distances >= 0) & (distances < bin_width)]
if return_all:
return thresholds
else:
return thresholds[0]
def threshold_li(image):
"""Return threshold value based on adaptation of Li's Minimum Cross Entropy method.
Parameters
----------
image : (N, M) ndarray
Input image.
Returns
-------
threshold : float
Upper threshold value. All pixels with an intensity higher than
this value are assumed to be foreground.
References
----------
.. [1] Li C.H. and Lee C.K. (1993) "Minimum Cross Entropy Thresholding"
Pattern Recognition, 26(4): 617-625
DOI:10.1016/0031-3203(93)90115-D
.. [2] Li C.H. and Tam P.K.S. (1998) "An Iterative Algorithm for Minimum
Cross Entropy Thresholding" Pattern Recognition Letters, 18(8): 771-776
DOI:10.1016/S0167-8655(98)00057-9
.. [3] Sezgin M. and Sankur B. (2004) "Survey over Image Thresholding
Techniques and Quantitative Performance Evaluation" Journal of
Electronic Imaging, 13(1): 146-165
DOI:10.1117/1.1631315
.. [4] ImageJ AutoThresholder code, http://fiji.sc/wiki/index.php/Auto_Threshold
Examples
--------
>>> from skimage.data import camera
>>> image = camera()
>>> thresh = threshold_li(image)
>>> binary = image > thresh
"""
# Copy to ensure input image is not modified
image = image.copy()
# Requires positive image (because of log(mean))
immin = np.min(image)
image -= immin
imrange = np.max(image)
tolerance = 0.5 * imrange / 256
# Calculate the mean gray-level
mean = np.mean(image)
# Initial estimate
new_thresh = mean
old_thresh = new_thresh + 2 * tolerance
# Stop the iterations when the difference between the
# new and old threshold values is less than the tolerance
while abs(new_thresh - old_thresh) > tolerance:
old_thresh = new_thresh
threshold = old_thresh + tolerance # range
# Calculate the means of background and object pixels
mean_back = image[image <= threshold].mean()
mean_obj = image[image > threshold].mean()
temp = (mean_back - mean_obj) / (np.log(mean_back) - np.log(mean_obj))
if temp < 0:
new_thresh = temp - tolerance
else:
new_thresh = temp + tolerance
return threshold + immin
def threshold_minimum(image, nbins=256, bias='min', max_iter=10000):
"""Return threshold value based on minimum method.
The histogram of the input `image` is computed and smoothed until there are
only two maxima. Then the minimum in between is the threshold value.
Parameters
----------
image : (M, N) ndarray
Input image.
nbins : int, optional
Number of bins used to calculate histogram. This value is ignored for
integer arrays.
bias : {'min', 'mid', 'max'}, optional
'min', 'mid', 'max' return lowest, middle, or highest pixel value
with minimum histogram value.
max_iter: int, optional
Maximum number of iterations to smooth the histogram.
Returns
-------
threshold : float
Upper threshold value. All pixels with an intensity higher than
this value are assumed to be foreground.
Raises
------
RuntimeError
If unable to find two local maxima in the histogram or if the
smoothing takes more than 1e4 iterations.
References
----------
.. [1] Prewitt, JMS & Mendelsohn, ML (1966), "The analysis of cell images",
Annals of the New York Academy of Sciences 128: 1035-1053
DOI:10.1111/j.1749-6632.1965.tb11715.x
Examples
--------
>>> from skimage.data import camera
>>> image = camera()
>>> thresh = threshold_minimum(image)
>>> binary = image > thresh
"""
def find_local_maxima(hist):
# We can't use scipy.signal.argrelmax
# as it fails on plateaus
maximums = list()
direction = 1
for i in range(hist.shape[0] - 1):
if direction > 0:
if hist[i + 1] < hist[i]:
direction = -1
maximums.append(i)
else:
if hist[i + 1] > hist[i]:
direction = 1
return maximums
if bias not in ('min', 'mid', 'max'):
raise ValueError("Unknown bias: {0}".format(bias))
hist, bin_centers = histogram(image.ravel(), nbins)
smooth_hist = np.copy(hist)
for counter in range(max_iter):
smooth_hist = ndif.uniform_filter1d(smooth_hist, 3)
maximums = find_local_maxima(smooth_hist)
if len(maximums) < 3:
break
if len(maximums) != 2:
raise RuntimeError('Unable to find two maxima in histogram')
elif counter == max_iter - 1:
raise RuntimeError('Maximum iteration reached for histogram'
'smoothing')
# Find lowest point between the maxima, biased to the low end (min)
minimum = smooth_hist[maximums[0]]
threshold = maximums[0]
for i in range(maximums[0], maximums[1]+1):
if smooth_hist[i] < minimum:
minimum = smooth_hist[i]
threshold = i
if bias == 'min':
return bin_centers[threshold]
else:
upper_bound = threshold
while smooth_hist[upper_bound] == smooth_hist[threshold]:
upper_bound += 1
upper_bound -= 1
if bias == 'max':
return bin_centers[upper_bound]
elif bias == 'mid':
return bin_centers[(threshold + upper_bound) // 2]
def threshold_mean(image):
"""Return threshold value based on the mean of grayscale values.
Parameters
----------
image : (N, M[, ..., P]) ndarray
Grayscale input image.
Returns
-------
threshold : float
Upper threshold value. All pixels with an intensity higher than
this value are assumed to be foreground.
References
----------
.. [1] C. A. Glasbey, "An analysis of histogram-based thresholding
algorithms," CVGIP: Graphical Models and Image Processing,
vol. 55, pp. 532-537, 1993.
DOI:10.1006/cgip.1993.1040
Examples
--------
>>> from skimage.data import camera
>>> image = camera()
>>> thresh = threshold_mean(image)
>>> binary = image > thresh
"""
return np.mean(image)
def threshold_triangle(image, nbins=256):
"""Return threshold value based on the triangle algorithm.
Parameters
----------
image : (N, M[, ..., P]) ndarray
Grayscale input image.
nbins : int, optional
Number of bins used to calculate histogram. This value is ignored for
integer arrays.
Returns
-------
threshold : float
Upper threshold value. All pixels with an intensity higher than
this value are assumed to be foreground.
References
----------
.. [1] Zack, G. W., Rogers, W. E. and Latt, S. A., 1977,
Automatic Measurement of Sister Chromatid Exchange Frequency,
Journal of Histochemistry and Cytochemistry 25 (7), pp. 741-753
DOI:10.1177/25.7.70454
.. [2] ImageJ AutoThresholder code,
http://fiji.sc/wiki/index.php/Auto_Threshold
Examples
--------
>>> from skimage.data import camera
>>> image = camera()
>>> thresh = threshold_triangle(image)
>>> binary = image > thresh
"""
# nbins is ignored for integer arrays
# so, we recalculate the effective nbins.
hist, bin_centers = histogram(image.ravel(), nbins)
nbins = len(hist)
# Find peak, lowest and highest gray levels.
arg_peak_height = np.argmax(hist)
peak_height = hist[arg_peak_height]
arg_low_level, arg_high_level = np.where(hist>0)[0][[0, -1]]
# Flip is True if left tail is shorter.
flip = arg_peak_height - arg_low_level < arg_high_level - arg_peak_height
if flip:
hist = hist[::-1]
arg_low_level = nbins - arg_high_level - 1
arg_peak_height = nbins - arg_peak_height - 1
# If flip == True, arg_high_level becomes incorrect
# but we don't need it anymore.
del(arg_high_level)
# Set up the coordinate system.
width = arg_peak_height - arg_low_level
x1 = np.arange(width)
y1 = hist[x1 + arg_low_level]
# Normalize.
norm = np.sqrt(peak_height**2 + width**2)
peak_height /= norm
width /= norm
# Maximize the length.
# The ImageJ implementation includes an additional constant when calculating
# the length, but here we omit it as it does not affect the location of the
# minimum.
length = peak_height * x1 - width * y1
arg_level = np.argmax(length) + arg_low_level
if flip:
arg_level = nbins - arg_level - 1
return bin_centers[arg_level]
| ofgulban/scikit-image | skimage/filters/thresholding.py | Python | bsd-3-clause | 24,466 | [
"Gaussian"
] | 6633e17ab913a9dc4dad23a2c2b533dd1c69964eeb47cc0b256ff8cb806737d9 |
# -*- coding: utf-8 -*-
import re
import creoleparser
import creoleparser.elements
import genshi
import genshi.core
import pygments
import pygments.lexers
import pygments.formatters
from werkzeug import url_quote
from tipfy import local, escape, url_for
from tipfy.ext.i18n import _
from tipfy.ext.db import _slugify
from moe.wiki import WikiPath
formatter = pygments.formatters.HtmlFormatter()
default_lexer = pygments.lexers.get_lexer_by_name('text')
class Heading(creoleparser.elements.Heading):
def _build(self, mo, element_store, environ):
heading_tag = self.tags[len(mo.group(1))-1]
heading_text = mo.group(2)
slug = _slugify(heading_text, default='heading')
if environ is not None:
headings = environ.setdefault('headings', [])
i = 1
original_slug = slug
while True:
if slug not in headings:
headings.append(slug)
break
slug = '%s_%d' % (original_slug, i)
i += 1
toc = environ.setdefault('toc', [])
toc.append((heading_tag, escape(heading_text), slug))
# The heading itself.
text = creoleparser.core.fragmentize(heading_text,
self.child_elements, element_store, environ)
# The anchor and link to the anchor.
anchor = genshi.builder.tag.span(id=slug)
anchor_link = genshi.builder.tag.a(genshi.core.Markup('¶'),
class_='headerlink', href='#' + slug,
title=escape(_('Permalink to this headline')))
heading = genshi.builder.tag.__getattr__(heading_tag)
return heading([text, anchor, anchor_link], class_='heading')
def parse_macro(name, arg_string, body, isblock, environ):
macro = MACROS.get(name, None)
if not macro:
return
args, kwargs = creoleparser.parse_args(arg_string)
return macro(name, arg_string, body, isblock, environ, *args, **kwargs)
def macro_code(name, arg_string, body, isblock, environ, *args, **kwargs):
"""A macro to allow syntax highlighting in wiki pages.
<<code python>>
def hello(who):
print 'Hello, %s!' % who
hello('World')
<</code>>
"""
if body is None:
body = ''
if len(args) > 0:
language = args[0].strip()
if language == 'pycon':
lines = []
for line in body.splitlines():
if not line.startswith('>>>'):
line = '>>> ' + line.strip()
lines.append(line)
body = u'\n'.join(lines)
try:
lexer = pygments.lexers.get_lexer_by_name(language)
except pygments.lexers.ClassNotFound:
lexer = default_lexer
else:
lexer = default_lexer
return genshi.core.Markup(pygments.highlight(body, lexer,
formatter))
def macro_note(name, arg_string, body, isblock, environ, *args, **kwargs):
"""A macro to create notes and warnings.
<<note>>
I am a note.
<</code>>
<<warning>>
I am a warning!
<</warning>>
"""
body = wiki_parser.parse(body)
return genshi.Markup("""<div class="macro-note %s">
<p class="title">%s:</p>
%s
</div>""" % (name, name.capitalize(), body))
def create_wiki_link(path):
"""Creates a wiki link given a path."""
anchor = None
parts = path.split('#', 1)
if len(parts) > 1:
path = parts[0]
anchor = parts[1]
page_path = WikiPath(path).normalized_path
url = url_for('wiki/index', page_path=page_path, area_name=local.area.name)
if anchor:
url += '#' + url_quote(anchor)
return url
def get_wiki_link_func(area):
def create_wiki_link(path):
"""Creates a wiki link given a path."""
anchor = None
parts = path.split('#', 1)
if len(parts) > 1:
path = parts[0]
anchor = parts[1]
page_path = WikiPath(path).normalized_path
url = url_for('wiki/index', page_path=page_path, area_name=area.name)
if anchor:
url += '#' + url_quote(anchor)
return url
return create_wiki_link
def get_page_sections(body, index=None):
"""Returns a section of the page."""
sections = []
section = ''
for line in body.splitlines():
res = heading_re.match(line)
if res:
#if index is not None and len(sections) == index:
# return section.strip()
sections.append(section.strip())
section = line + '\n'
else:
section += line + '\n'
sections.append(section.strip())
return sections
def heading_re_string():
token = '='
tags = ['h1','h2','h3','h4','h5','h6']
whitespace = r'[ \t]*'
tokens = '(' + re.escape(token) + '{1,' + str(len(tags)) +'})'
content = '(.*?)'
trailing_markup = '(' + re.escape(token) + r'+[ \t]*)?(\n|\Z)'
return '^' + whitespace + tokens + \
whitespace + content + whitespace + trailing_markup
def get_toc(data):
"""A very rudimentar TOC creator. No nested lists. Simple."""
if len(data) <= 1:
return ''
res = u'<ul class="toc">'
for level, title, anchor in data:
res += u'<li class="toc-%s"><a href="#%s">%s</a></li>' % (level,
anchor, escape(title))
return res + u'</ul>'
def parse_page(body_raw, environ, area):
# Factory link creation function to use current area.
wiki_parser.dialect.link.path_func = get_wiki_link_func(area)
# Parse wiki markup.
body = wiki_parser(body_raw, environ=environ)
toc = get_toc(environ.get('toc'))
return (body, toc)
heading_re = re.compile(heading_re_string(), re.MULTILINE)
dialect = creoleparser.create_dialect(
creoleparser.dialects.creole11_base,
#wiki_links_path_func=create_wiki_link,
macro_func=parse_macro,
)
dialect.headings = Heading(['h1','h2','h3','h4','h5','h6'], '=')
wiki_parser = creoleparser.Parser(dialect=dialect, encoding=None)
MACROS = {
'code': macro_code,
'note': macro_note,
'warning': macro_note,
'seealso': macro_note,
}
| ac001/moe | project/app/moe/wiki/parser.py | Python | bsd-3-clause | 6,205 | [
"MOE"
] | 434d7bd3cbd554f2f7c53b076c56e864fcf75ea33488a9e8d08db4eb32c48e25 |
from __future__ import division
import os, sys, warnings
def fn_name(): return sys._getframe(1).f_code.co_name
try:
import gobject
import gtk; gdk = gtk.gdk
import pango
except ImportError:
raise ImportError("Gtk* backend requires pygtk to be installed.")
pygtk_version_required = (2,4,0)
if gtk.pygtk_version < pygtk_version_required:
raise ImportError ("PyGTK %d.%d.%d is installed\n"
"PyGTK %d.%d.%d or later is required"
% (gtk.pygtk_version + pygtk_version_required))
del pygtk_version_required
_new_tooltip_api = (gtk.pygtk_version[1] >= 12)
import matplotlib
from matplotlib._pylab_helpers import Gcf
from matplotlib.backend_bases import RendererBase, GraphicsContextBase, \
FigureManagerBase, FigureCanvasBase, NavigationToolbar2, cursors, TimerBase
from matplotlib.backend_bases import ShowBase
from matplotlib.backends.backend_gdk import RendererGDK, FigureCanvasGDK
from matplotlib.cbook import is_string_like, is_writable_file_like
from matplotlib.colors import colorConverter
from matplotlib.figure import Figure
from matplotlib.widgets import SubplotTool
from matplotlib import lines
from matplotlib import markers
from matplotlib import cbook
from matplotlib import verbose
backend_version = "%d.%d.%d" % gtk.pygtk_version
_debug = False
#_debug = True
# the true dots per inch on the screen; should be display dependent
# see http://groups.google.com/groups?q=screen+dpi+x11&hl=en&lr=&ie=UTF-8&oe=UTF-8&safe=off&selm=7077.26e81ad5%40swift.cs.tcd.ie&rnum=5 for some info about screen dpi
PIXELS_PER_INCH = 96
# Hide the benign warning that it can't stat a file that doesn't
warnings.filterwarnings('ignore', '.*Unable to retrieve the file info for.*', gtk.Warning)
cursord = {
cursors.MOVE : gdk.Cursor(gdk.FLEUR),
cursors.HAND : gdk.Cursor(gdk.HAND2),
cursors.POINTER : gdk.Cursor(gdk.LEFT_PTR),
cursors.SELECT_REGION : gdk.Cursor(gdk.TCROSS),
}
# ref gtk+/gtk/gtkwidget.h
def GTK_WIDGET_DRAWABLE(w):
flags = w.flags();
return flags & gtk.VISIBLE != 0 and flags & gtk.MAPPED != 0
def draw_if_interactive():
"""
Is called after every pylab drawing command
"""
if matplotlib.is_interactive():
figManager = Gcf.get_active()
if figManager is not None:
figManager.canvas.draw_idle()
class Show(ShowBase):
def mainloop(self):
if gtk.main_level() == 0:
gtk.main()
show = Show()
def new_figure_manager(num, *args, **kwargs):
"""
Create a new figure manager instance
"""
FigureClass = kwargs.pop('FigureClass', Figure)
thisFig = FigureClass(*args, **kwargs)
canvas = FigureCanvasGTK(thisFig)
manager = FigureManagerGTK(canvas, num)
# equals:
#manager = FigureManagerGTK(FigureCanvasGTK(Figure(*args, **kwargs), num)
return manager
class TimerGTK(TimerBase):
'''
Subclass of :class:`backend_bases.TimerBase` that uses GTK for timer events.
Attributes:
* interval: The time between timer events in milliseconds. Default
is 1000 ms.
* single_shot: Boolean flag indicating whether this timer should
operate as single shot (run once and then stop). Defaults to False.
* callbacks: Stores list of (func, args) tuples that will be called
upon timer events. This list can be manipulated directly, or the
functions add_callback and remove_callback can be used.
'''
def _timer_start(self):
# Need to stop it, otherwise we potentially leak a timer id that will
# never be stopped.
self._timer_stop()
self._timer = gobject.timeout_add(self._interval, self._on_timer)
def _timer_stop(self):
if self._timer is not None:
gobject.source_remove(self._timer)
self._timer = None
def _timer_set_interval(self):
# Only stop and restart it if the timer has already been started
if self._timer is not None:
self._timer_stop()
self._timer_start()
def _on_timer(self):
TimerBase._on_timer(self)
# Gtk timeout_add() requires that the callback returns True if it
# is to be called again.
if len(self.callbacks) > 0 and not self._single:
return True
else:
self._timer = None
return False
class FigureCanvasGTK (gtk.DrawingArea, FigureCanvasBase):
keyvald = {65507 : 'control',
65505 : 'shift',
65513 : 'alt',
65508 : 'control',
65506 : 'shift',
65514 : 'alt',
65361 : 'left',
65362 : 'up',
65363 : 'right',
65364 : 'down',
65307 : 'escape',
65470 : 'f1',
65471 : 'f2',
65472 : 'f3',
65473 : 'f4',
65474 : 'f5',
65475 : 'f6',
65476 : 'f7',
65477 : 'f8',
65478 : 'f9',
65479 : 'f10',
65480 : 'f11',
65481 : 'f12',
65300 : 'scroll_lock',
65299 : 'break',
65288 : 'backspace',
65293 : 'enter',
65379 : 'insert',
65535 : 'delete',
65360 : 'home',
65367 : 'end',
65365 : 'pageup',
65366 : 'pagedown',
65438 : '0',
65436 : '1',
65433 : '2',
65435 : '3',
65430 : '4',
65437 : '5',
65432 : '6',
65429 : '7',
65431 : '8',
65434 : '9',
65451 : '+',
65453 : '-',
65450 : '*',
65455 : '/',
65439 : 'dec',
65421 : 'enter',
}
# Setting this as a static constant prevents
# this resulting expression from leaking
event_mask = (gdk.BUTTON_PRESS_MASK |
gdk.BUTTON_RELEASE_MASK |
gdk.EXPOSURE_MASK |
gdk.KEY_PRESS_MASK |
gdk.KEY_RELEASE_MASK |
gdk.ENTER_NOTIFY_MASK |
gdk.LEAVE_NOTIFY_MASK |
gdk.POINTER_MOTION_MASK |
gdk.POINTER_MOTION_HINT_MASK)
def __init__(self, figure):
if _debug: print 'FigureCanvasGTK.%s' % fn_name()
FigureCanvasBase.__init__(self, figure)
gtk.DrawingArea.__init__(self)
self._idle_draw_id = 0
self._need_redraw = True
self._pixmap_width = -1
self._pixmap_height = -1
self._lastCursor = None
self.connect('scroll_event', self.scroll_event)
self.connect('button_press_event', self.button_press_event)
self.connect('button_release_event', self.button_release_event)
self.connect('configure_event', self.configure_event)
self.connect('expose_event', self.expose_event)
self.connect('key_press_event', self.key_press_event)
self.connect('key_release_event', self.key_release_event)
self.connect('motion_notify_event', self.motion_notify_event)
self.connect('leave_notify_event', self.leave_notify_event)
self.connect('enter_notify_event', self.enter_notify_event)
self.set_events(self.__class__.event_mask)
self.set_double_buffered(False)
self.set_flags(gtk.CAN_FOCUS)
self._renderer_init()
self._idle_event_id = gobject.idle_add(self.idle_event)
def destroy(self):
#gtk.DrawingArea.destroy(self)
self.close_event()
gobject.source_remove(self._idle_event_id)
if self._idle_draw_id != 0:
gobject.source_remove(self._idle_draw_id)
def scroll_event(self, widget, event):
if _debug: print 'FigureCanvasGTK.%s' % fn_name()
x = event.x
# flipy so y=0 is bottom of canvas
y = self.allocation.height - event.y
if event.direction==gdk.SCROLL_UP:
step = 1
else:
step = -1
FigureCanvasBase.scroll_event(self, x, y, step, guiEvent=event)
return False # finish event propagation?
def button_press_event(self, widget, event):
if _debug: print 'FigureCanvasGTK.%s' % fn_name()
x = event.x
# flipy so y=0 is bottom of canvas
y = self.allocation.height - event.y
FigureCanvasBase.button_press_event(self, x, y, event.button, guiEvent=event)
return False # finish event propagation?
def button_release_event(self, widget, event):
if _debug: print 'FigureCanvasGTK.%s' % fn_name()
x = event.x
# flipy so y=0 is bottom of canvas
y = self.allocation.height - event.y
FigureCanvasBase.button_release_event(self, x, y, event.button, guiEvent=event)
return False # finish event propagation?
def key_press_event(self, widget, event):
if _debug: print 'FigureCanvasGTK.%s' % fn_name()
key = self._get_key(event)
if _debug: print "hit", key
FigureCanvasBase.key_press_event(self, key, guiEvent=event)
return False # finish event propagation?
def key_release_event(self, widget, event):
if _debug: print 'FigureCanvasGTK.%s' % fn_name()
key = self._get_key(event)
if _debug: print "release", key
FigureCanvasBase.key_release_event(self, key, guiEvent=event)
return False # finish event propagation?
def motion_notify_event(self, widget, event):
if _debug: print 'FigureCanvasGTK.%s' % fn_name()
if event.is_hint:
x, y, state = event.window.get_pointer()
else:
x, y, state = event.x, event.y, event.state
# flipy so y=0 is bottom of canvas
y = self.allocation.height - y
FigureCanvasBase.motion_notify_event(self, x, y, guiEvent=event)
return False # finish event propagation?
def leave_notify_event(self, widget, event):
FigureCanvasBase.leave_notify_event(self, event)
def enter_notify_event(self, widget, event):
FigureCanvasBase.enter_notify_event(self, event)
def _get_key(self, event):
if event.keyval in self.keyvald:
key = self.keyvald[event.keyval]
elif event.keyval <256:
key = chr(event.keyval)
else:
key = None
ctrl = event.state & gdk.CONTROL_MASK
shift = event.state & gdk.SHIFT_MASK
return key
def configure_event(self, widget, event):
if _debug: print 'FigureCanvasGTK.%s' % fn_name()
if widget.window is None:
return
w, h = event.width, event.height
if w < 3 or h < 3:
return # empty fig
# resize the figure (in inches)
dpi = self.figure.dpi
self.figure.set_size_inches (w/dpi, h/dpi)
self._need_redraw = True
return False # finish event propagation?
def draw(self):
# Note: FigureCanvasBase.draw() is inconveniently named as it clashes
# with the deprecated gtk.Widget.draw()
self._need_redraw = True
if GTK_WIDGET_DRAWABLE(self):
self.queue_draw()
# do a synchronous draw (its less efficient than an async draw,
# but is required if/when animation is used)
self.window.process_updates (False)
def draw_idle(self):
def idle_draw(*args):
self.draw()
self._idle_draw_id = 0
return False
if self._idle_draw_id == 0:
self._idle_draw_id = gobject.idle_add(idle_draw)
def _renderer_init(self):
"""Override by GTK backends to select a different renderer
Renderer should provide the methods:
set_pixmap ()
set_width_height ()
that are used by
_render_figure() / _pixmap_prepare()
"""
self._renderer = RendererGDK (self, self.figure.dpi)
def _pixmap_prepare(self, width, height):
"""
Make sure _._pixmap is at least width, height,
create new pixmap if necessary
"""
if _debug: print 'FigureCanvasGTK.%s' % fn_name()
create_pixmap = False
if width > self._pixmap_width:
# increase the pixmap in 10%+ (rather than 1 pixel) steps
self._pixmap_width = max (int (self._pixmap_width * 1.1),
width)
create_pixmap = True
if height > self._pixmap_height:
self._pixmap_height = max (int (self._pixmap_height * 1.1),
height)
create_pixmap = True
if create_pixmap:
self._pixmap = gdk.Pixmap (self.window, self._pixmap_width,
self._pixmap_height)
self._renderer.set_pixmap (self._pixmap)
def _render_figure(self, pixmap, width, height):
"""used by GTK and GTKcairo. GTKAgg overrides
"""
self._renderer.set_width_height (width, height)
self.figure.draw (self._renderer)
def expose_event(self, widget, event):
"""Expose_event for all GTK backends. Should not be overridden.
"""
if _debug: print 'FigureCanvasGTK.%s' % fn_name()
if GTK_WIDGET_DRAWABLE(self):
if self._need_redraw:
x, y, w, h = self.allocation
self._pixmap_prepare (w, h)
self._render_figure(self._pixmap, w, h)
self._need_redraw = False
x, y, w, h = event.area
self.window.draw_drawable (self.style.fg_gc[self.state],
self._pixmap, x, y, x, y, w, h)
return False # finish event propagation?
filetypes = FigureCanvasBase.filetypes.copy()
filetypes['jpg'] = 'JPEG'
filetypes['jpeg'] = 'JPEG'
filetypes['png'] = 'Portable Network Graphics'
def print_jpeg(self, filename, *args, **kwargs):
return self._print_image(filename, 'jpeg')
print_jpg = print_jpeg
def print_png(self, filename, *args, **kwargs):
return self._print_image(filename, 'png')
def _print_image(self, filename, format):
if self.flags() & gtk.REALIZED == 0:
# for self.window(for pixmap) and has a side effect of altering
# figure width,height (via configure-event?)
gtk.DrawingArea.realize(self)
width, height = self.get_width_height()
pixmap = gdk.Pixmap (self.window, width, height)
self._renderer.set_pixmap (pixmap)
self._render_figure(pixmap, width, height)
# jpg colors don't match the display very well, png colors match
# better
pixbuf = gdk.Pixbuf(gdk.COLORSPACE_RGB, 0, 8, width, height)
pixbuf.get_from_drawable(pixmap, pixmap.get_colormap(),
0, 0, 0, 0, width, height)
if is_string_like(filename):
try:
pixbuf.save(filename, format)
except gobject.GError, exc:
error_msg_gtk('Save figure failure:\n%s' % (exc,), parent=self)
elif is_writable_file_like(filename):
if hasattr(pixbuf, 'save_to_callback'):
def save_callback(buf, data=None):
data.write(buf)
try:
pixbuf.save_to_callback(save_callback, format, user_data=filename)
except gobject.GError, exc:
error_msg_gtk('Save figure failure:\n%s' % (exc,), parent=self)
else:
raise ValueError("Saving to a Python file-like object is only supported by PyGTK >= 2.8")
else:
raise ValueError("filename must be a path or a file-like object")
def get_default_filetype(self):
return 'png'
def new_timer(self, *args, **kwargs):
"""
Creates a new backend-specific subclass of :class:`backend_bases.Timer`.
This is useful for getting periodic events through the backend's native
event loop. Implemented only for backends with GUIs.
optional arguments:
*interval*
Timer interval in milliseconds
*callbacks*
Sequence of (func, args, kwargs) where func(*args, **kwargs) will
be executed by the timer every *interval*.
"""
return TimerGTK(*args, **kwargs)
def flush_events(self):
gtk.gdk.threads_enter()
while gtk.events_pending():
gtk.main_iteration(True)
gtk.gdk.flush()
gtk.gdk.threads_leave()
def start_event_loop(self,timeout):
FigureCanvasBase.start_event_loop_default(self,timeout)
start_event_loop.__doc__=FigureCanvasBase.start_event_loop_default.__doc__
def stop_event_loop(self):
FigureCanvasBase.stop_event_loop_default(self)
stop_event_loop.__doc__=FigureCanvasBase.stop_event_loop_default.__doc__
class FigureManagerGTK(FigureManagerBase):
"""
Public attributes
canvas : The FigureCanvas instance
num : The Figure number
toolbar : The gtk.Toolbar (gtk only)
vbox : The gtk.VBox containing the canvas and toolbar (gtk only)
window : The gtk.Window (gtk only)
"""
def __init__(self, canvas, num):
if _debug: print 'FigureManagerGTK.%s' % fn_name()
FigureManagerBase.__init__(self, canvas, num)
self.window = gtk.Window()
self.window.set_title("Figure %d" % num)
if (window_icon):
try:
self.window.set_icon_from_file(window_icon)
except:
# some versions of gtk throw a glib.GError but not
# all, so I am not sure how to catch it. I am unhappy
# diong a blanket catch here, but an not sure what a
# better way is - JDH
verbose.report('Could not load matplotlib icon: %s' % sys.exc_info()[1])
self.vbox = gtk.VBox()
self.window.add(self.vbox)
self.vbox.show()
self.canvas.show()
# attach a show method to the figure for pylab ease of use
self.canvas.figure.show = lambda *args: self.window.show()
self.vbox.pack_start(self.canvas, True, True)
self.toolbar = self._get_toolbar(canvas)
# calculate size for window
w = int (self.canvas.figure.bbox.width)
h = int (self.canvas.figure.bbox.height)
if self.toolbar is not None:
self.toolbar.show()
self.vbox.pack_end(self.toolbar, False, False)
tb_w, tb_h = self.toolbar.size_request()
h += tb_h
self.window.set_default_size (w, h)
def destroy(*args):
Gcf.destroy(num)
self.window.connect("destroy", destroy)
self.window.connect("delete_event", destroy)
if matplotlib.is_interactive():
self.window.show()
def notify_axes_change(fig):
'this will be called whenever the current axes is changed'
if self.toolbar is not None: self.toolbar.update()
self.canvas.figure.add_axobserver(notify_axes_change)
self.canvas.grab_focus()
def destroy(self, *args):
if _debug: print 'FigureManagerGTK.%s' % fn_name()
if hasattr(self, 'toolbar') and self.toolbar is not None:
self.toolbar.destroy()
if hasattr(self, 'vbox'):
self.vbox.destroy()
if hasattr(self, 'window'):
self.window.destroy()
if hasattr(self, 'canvas'):
self.canvas.destroy()
self.__dict__.clear() #Is this needed? Other backends don't have it.
if Gcf.get_num_fig_managers()==0 and \
not matplotlib.is_interactive() and \
gtk.main_level() >= 1:
gtk.main_quit()
def show(self):
# show the figure window
self.window.show()
def full_screen_toggle (self):
self._full_screen_flag = not self._full_screen_flag
if self._full_screen_flag:
self.window.fullscreen()
else:
self.window.unfullscreen()
_full_screen_flag = False
def _get_toolbar(self, canvas):
# must be inited after the window, drawingArea and figure
# attrs are set
if matplotlib.rcParams['toolbar'] == 'classic':
toolbar = NavigationToolbar (canvas, self.window)
elif matplotlib.rcParams['toolbar'] == 'toolbar2':
toolbar = NavigationToolbar2GTK (canvas, self.window)
else:
toolbar = None
return toolbar
def set_window_title(self, title):
self.window.set_title(title)
def resize(self, width, height):
'set the canvas size in pixels'
#_, _, cw, ch = self.canvas.allocation
#_, _, ww, wh = self.window.allocation
#self.window.resize (width-cw+ww, height-ch+wh)
self.window.resize(width, height)
class NavigationToolbar2GTK(NavigationToolbar2, gtk.Toolbar):
# list of toolitems to add to the toolbar, format is:
# text, tooltip_text, image_file, callback(str)
toolitems = (
('Home', 'Reset original view', 'home.png', 'home'),
('Back', 'Back to previous view','back.png', 'back'),
('Forward', 'Forward to next view','forward.png', 'forward'),
('Pan', 'Pan axes with left mouse, zoom with right', 'move.png','pan'),
('Zoom', 'Zoom to rectangle','zoom_to_rect.png', 'zoom'),
(None, None, None, None),
('Subplots', 'Configure subplots','subplots.png', 'configure_subplots'),
('Save', 'Save the figure','filesave.png', 'save_figure'),
)
def __init__(self, canvas, window):
self.win = window
gtk.Toolbar.__init__(self)
NavigationToolbar2.__init__(self, canvas)
def set_message(self, s):
self.message.set_label(s)
def set_cursor(self, cursor):
self.canvas.window.set_cursor(cursord[cursor])
def release(self, event):
try: del self._pixmapBack
except AttributeError: pass
def dynamic_update(self):
# legacy method; new method is canvas.draw_idle
self.canvas.draw_idle()
def draw_rubberband(self, event, x0, y0, x1, y1):
'adapted from http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/189744'
drawable = self.canvas.window
if drawable is None:
return
gc = drawable.new_gc()
height = self.canvas.figure.bbox.height
y1 = height - y1
y0 = height - y0
w = abs(x1 - x0)
h = abs(y1 - y0)
rect = [int(val)for val in min(x0,x1), min(y0, y1), w, h]
try:
lastrect, pixmapBack = self._pixmapBack
except AttributeError:
#snap image back
if event.inaxes is None:
return
ax = event.inaxes
l,b,w,h = [int(val) for val in ax.bbox.bounds]
b = int(height)-(b+h)
axrect = l,b,w,h
self._pixmapBack = axrect, gtk.gdk.Pixmap(drawable, w, h)
self._pixmapBack[1].draw_drawable(gc, drawable, l, b, 0, 0, w, h)
else:
drawable.draw_drawable(gc, pixmapBack, 0, 0, *lastrect)
drawable.draw_rectangle(gc, False, *rect)
def _init_toolbar(self):
self.set_style(gtk.TOOLBAR_ICONS)
self._init_toolbar2_4()
def _init_toolbar2_4(self):
basedir = os.path.join(matplotlib.rcParams['datapath'],'images')
if not _new_tooltip_api:
self.tooltips = gtk.Tooltips()
for text, tooltip_text, image_file, callback in self.toolitems:
if text is None:
self.insert( gtk.SeparatorToolItem(), -1 )
continue
fname = os.path.join(basedir, image_file)
image = gtk.Image()
image.set_from_file(fname)
tbutton = gtk.ToolButton(image, text)
self.insert(tbutton, -1)
tbutton.connect('clicked', getattr(self, callback))
if _new_tooltip_api:
tbutton.set_tooltip_text(tooltip_text)
else:
tbutton.set_tooltip(self.tooltips, tooltip_text, 'Private')
toolitem = gtk.SeparatorToolItem()
self.insert(toolitem, -1)
# set_draw() not making separator invisible,
# bug #143692 fixed Jun 06 2004, will be in GTK+ 2.6
toolitem.set_draw(False)
toolitem.set_expand(True)
toolitem = gtk.ToolItem()
self.insert(toolitem, -1)
self.message = gtk.Label()
toolitem.add(self.message)
self.show_all()
def get_filechooser(self):
return FileChooserDialog(
title='Save the figure',
parent=self.win,
filetypes=self.canvas.get_supported_filetypes(),
default_filetype=self.canvas.get_default_filetype())
def save_figure(self, *args):
fname, format = self.get_filechooser().get_filename_from_user()
if fname:
try:
self.canvas.print_figure(fname, format=format)
except Exception, e:
error_msg_gtk(str(e), parent=self)
def configure_subplots(self, button):
toolfig = Figure(figsize=(6,3))
canvas = self._get_canvas(toolfig)
toolfig.subplots_adjust(top=0.9)
tool = SubplotTool(self.canvas.figure, toolfig)
w = int (toolfig.bbox.width)
h = int (toolfig.bbox.height)
window = gtk.Window()
if (window_icon):
try: window.set_icon_from_file(window_icon)
except:
# we presumably already logged a message on the
# failure of the main plot, don't keep reporting
pass
window.set_title("Subplot Configuration Tool")
window.set_default_size(w, h)
vbox = gtk.VBox()
window.add(vbox)
vbox.show()
canvas.show()
vbox.pack_start(canvas, True, True)
window.show()
def _get_canvas(self, fig):
return FigureCanvasGTK(fig)
class NavigationToolbar(gtk.Toolbar):
"""
Public attributes
canvas - the FigureCanvas (gtk.DrawingArea)
win - the gtk.Window
"""
# list of toolitems to add to the toolbar, format is:
# text, tooltip_text, image, callback(str), callback_arg, scroll(bool)
toolitems = (
('Left', 'Pan left with click or wheel mouse (bidirectional)',
gtk.STOCK_GO_BACK, 'panx', -1, True),
('Right', 'Pan right with click or wheel mouse (bidirectional)',
gtk.STOCK_GO_FORWARD, 'panx', 1, True),
('Zoom In X',
'Zoom In X (shrink the x axis limits) with click or wheel'
' mouse (bidirectional)',
gtk.STOCK_ZOOM_IN, 'zoomx', 1, True),
('Zoom Out X',
'Zoom Out X (expand the x axis limits) with click or wheel'
' mouse (bidirectional)',
gtk.STOCK_ZOOM_OUT, 'zoomx', -1, True),
(None, None, None, None, None, None,),
('Up', 'Pan up with click or wheel mouse (bidirectional)',
gtk.STOCK_GO_UP, 'pany', 1, True),
('Down', 'Pan down with click or wheel mouse (bidirectional)',
gtk.STOCK_GO_DOWN, 'pany', -1, True),
('Zoom In Y',
'Zoom in Y (shrink the y axis limits) with click or wheel'
' mouse (bidirectional)',
gtk.STOCK_ZOOM_IN, 'zoomy', 1, True),
('Zoom Out Y',
'Zoom Out Y (expand the y axis limits) with click or wheel'
' mouse (bidirectional)',
gtk.STOCK_ZOOM_OUT, 'zoomy', -1, True),
(None, None, None, None, None, None,),
('Save', 'Save the figure',
gtk.STOCK_SAVE, 'save_figure', None, False),
)
def __init__(self, canvas, window):
"""
figManager is the FigureManagerGTK instance that contains the
toolbar, with attributes figure, window and drawingArea
"""
gtk.Toolbar.__init__(self)
self.canvas = canvas
# Note: gtk.Toolbar already has a 'window' attribute
self.win = window
self.set_style(gtk.TOOLBAR_ICONS)
self._create_toolitems_2_4()
self.update = self._update_2_4
self.fileselect = FileChooserDialog(
title='Save the figure',
parent=self.win,
filetypes=self.canvas.get_supported_filetypes(),
default_filetype=self.canvas.get_default_filetype())
self.show_all()
self.update()
def _create_toolitems_2_4(self):
# use the GTK+ 2.4 GtkToolbar API
iconSize = gtk.ICON_SIZE_SMALL_TOOLBAR
if not _new_tooltip_api:
self.tooltips = gtk.Tooltips()
for text, tooltip_text, image_num, callback, callback_arg, scroll \
in self.toolitems:
if text is None:
self.insert( gtk.SeparatorToolItem(), -1 )
continue
image = gtk.Image()
image.set_from_stock(image_num, iconSize)
tbutton = gtk.ToolButton(image, text)
self.insert(tbutton, -1)
if callback_arg:
tbutton.connect('clicked', getattr(self, callback),
callback_arg)
else:
tbutton.connect('clicked', getattr(self, callback))
if scroll:
tbutton.connect('scroll_event', getattr(self, callback))
if _new_tooltip_api:
tbutton.set_tooltip_text(tooltip_text)
else:
tbutton.set_tooltip(self.tooltips, tooltip_text, 'Private')
# Axes toolitem, is empty at start, update() adds a menu if >=2 axes
self.axes_toolitem = gtk.ToolItem()
self.insert(self.axes_toolitem, 0)
if _new_tooltip_api:
self.axes_toolitem.set_tooltip_text(
'Select axes that controls affect')
else:
self.axes_toolitem.set_tooltip (
self.tooltips,
tip_text='Select axes that controls affect',
tip_private = 'Private')
align = gtk.Alignment (xalign=0.5, yalign=0.5, xscale=0.0, yscale=0.0)
self.axes_toolitem.add(align)
self.menubutton = gtk.Button ("Axes")
align.add (self.menubutton)
def position_menu (menu):
"""Function for positioning a popup menu.
Place menu below the menu button, but ensure it does not go off
the bottom of the screen.
The default is to popup menu at current mouse position
"""
x0, y0 = self.window.get_origin()
x1, y1, m = self.window.get_pointer()
x2, y2 = self.menubutton.get_pointer()
sc_h = self.get_screen().get_height() # requires GTK+ 2.2 +
w, h = menu.size_request()
x = x0 + x1 - x2
y = y0 + y1 - y2 + self.menubutton.allocation.height
y = min(y, sc_h - h)
return x, y, True
def button_clicked (button, data=None):
self.axismenu.popup (None, None, position_menu, 0,
gtk.get_current_event_time())
self.menubutton.connect ("clicked", button_clicked)
def _update_2_4(self):
# for GTK+ 2.4+
# called by __init__() and FigureManagerGTK
self._axes = self.canvas.figure.axes
if len(self._axes) >= 2:
self.axismenu = self._make_axis_menu()
self.menubutton.show_all()
else:
self.menubutton.hide()
self.set_active(range(len(self._axes)))
def _make_axis_menu(self):
# called by self._update*()
def toggled(item, data=None):
if item == self.itemAll:
for item in items: item.set_active(True)
elif item == self.itemInvert:
for item in items:
item.set_active(not item.get_active())
ind = [i for i,item in enumerate(items) if item.get_active()]
self.set_active(ind)
menu = gtk.Menu()
self.itemAll = gtk.MenuItem("All")
menu.append(self.itemAll)
self.itemAll.connect("activate", toggled)
self.itemInvert = gtk.MenuItem("Invert")
menu.append(self.itemInvert)
self.itemInvert.connect("activate", toggled)
items = []
for i in range(len(self._axes)):
item = gtk.CheckMenuItem("Axis %d" % (i+1))
menu.append(item)
item.connect("toggled", toggled)
item.set_active(True)
items.append(item)
menu.show_all()
return menu
def set_active(self, ind):
self._ind = ind
self._active = [ self._axes[i] for i in self._ind ]
def panx(self, button, direction):
'panx in direction'
for a in self._active:
a.xaxis.pan(direction)
self.canvas.draw()
return True
def pany(self, button, direction):
'pany in direction'
for a in self._active:
a.yaxis.pan(direction)
self.canvas.draw()
return True
def zoomx(self, button, direction):
'zoomx in direction'
for a in self._active:
a.xaxis.zoom(direction)
self.canvas.draw()
return True
def zoomy(self, button, direction):
'zoomy in direction'
for a in self._active:
a.yaxis.zoom(direction)
self.canvas.draw()
return True
def get_filechooser(self):
return FileChooserDialog(
title='Save the figure',
parent=self.win,
filetypes=self.canvas.get_supported_filetypes(),
default_filetype=self.canvas.get_default_filetype())
def save_figure(self, *args):
fname, format = self.get_filechooser().get_filename_from_user()
if fname:
try:
self.canvas.print_figure(fname, format=format)
except Exception, e:
error_msg_gtk(str(e), parent=self)
class FileChooserDialog(gtk.FileChooserDialog):
"""GTK+ 2.4 file selector which remembers the last file/directory
selected and presents the user with a menu of supported image formats
"""
def __init__ (self,
title = 'Save file',
parent = None,
action = gtk.FILE_CHOOSER_ACTION_SAVE,
buttons = (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
gtk.STOCK_SAVE, gtk.RESPONSE_OK),
path = None,
filetypes = [],
default_filetype = None
):
super(FileChooserDialog, self).__init__ (title, parent, action,
buttons)
super(FileChooserDialog, self).set_do_overwrite_confirmation(True)
self.set_default_response (gtk.RESPONSE_OK)
if not path: path = os.getcwd() + os.sep
# create an extra widget to list supported image formats
self.set_current_folder (path)
self.set_current_name ('image.' + default_filetype)
hbox = gtk.HBox (spacing=10)
hbox.pack_start (gtk.Label ("File Format:"), expand=False)
liststore = gtk.ListStore(gobject.TYPE_STRING)
cbox = gtk.ComboBox(liststore)
cell = gtk.CellRendererText()
cbox.pack_start(cell, True)
cbox.add_attribute(cell, 'text', 0)
hbox.pack_start (cbox)
self.filetypes = filetypes
self.sorted_filetypes = filetypes.items()
self.sorted_filetypes.sort()
default = 0
for i, (ext, name) in enumerate(self.sorted_filetypes):
cbox.append_text ("%s (*.%s)" % (name, ext))
if ext == default_filetype:
default = i
cbox.set_active(default)
self.ext = default_filetype
def cb_cbox_changed (cbox, data=None):
"""File extension changed"""
head, filename = os.path.split(self.get_filename())
root, ext = os.path.splitext(filename)
ext = ext[1:]
new_ext = self.sorted_filetypes[cbox.get_active()][0]
self.ext = new_ext
if ext in self.filetypes:
filename = root + '.' + new_ext
elif ext == '':
filename = filename.rstrip('.') + '.' + new_ext
self.set_current_name (filename)
cbox.connect ("changed", cb_cbox_changed)
hbox.show_all()
self.set_extra_widget(hbox)
def get_filename_from_user (self):
while True:
filename = None
if self.run() != int(gtk.RESPONSE_OK):
break
filename = self.get_filename()
break
self.hide()
return filename, self.ext
class DialogLineprops:
"""
A GUI dialog for controlling lineprops
"""
signals = (
'on_combobox_lineprops_changed',
'on_combobox_linestyle_changed',
'on_combobox_marker_changed',
'on_colorbutton_linestyle_color_set',
'on_colorbutton_markerface_color_set',
'on_dialog_lineprops_okbutton_clicked',
'on_dialog_lineprops_cancelbutton_clicked',
)
linestyles = [ls for ls in lines.Line2D.lineStyles if ls.strip()]
linestyled = dict([ (s,i) for i,s in enumerate(linestyles)])
markers = [m for m in markers.MarkerStyle.markers if cbook.is_string_like(m)]
markerd = dict([(s,i) for i,s in enumerate(markers)])
def __init__(self, lines):
import gtk.glade
datadir = matplotlib.get_data_path()
gladefile = os.path.join(datadir, 'lineprops.glade')
if not os.path.exists(gladefile):
raise IOError('Could not find gladefile lineprops.glade in %s'%datadir)
self._inited = False
self._updateson = True # suppress updates when setting widgets manually
self.wtree = gtk.glade.XML(gladefile, 'dialog_lineprops')
self.wtree.signal_autoconnect(dict([(s, getattr(self, s)) for s in self.signals]))
self.dlg = self.wtree.get_widget('dialog_lineprops')
self.lines = lines
cbox = self.wtree.get_widget('combobox_lineprops')
cbox.set_active(0)
self.cbox_lineprops = cbox
cbox = self.wtree.get_widget('combobox_linestyles')
for ls in self.linestyles:
cbox.append_text(ls)
cbox.set_active(0)
self.cbox_linestyles = cbox
cbox = self.wtree.get_widget('combobox_markers')
for m in self.markers:
cbox.append_text(m)
cbox.set_active(0)
self.cbox_markers = cbox
self._lastcnt = 0
self._inited = True
def show(self):
'populate the combo box'
self._updateson = False
# flush the old
cbox = self.cbox_lineprops
for i in range(self._lastcnt-1,-1,-1):
cbox.remove_text(i)
# add the new
for line in self.lines:
cbox.append_text(line.get_label())
cbox.set_active(0)
self._updateson = True
self._lastcnt = len(self.lines)
self.dlg.show()
def get_active_line(self):
'get the active line'
ind = self.cbox_lineprops.get_active()
line = self.lines[ind]
return line
def get_active_linestyle(self):
'get the active lineinestyle'
ind = self.cbox_linestyles.get_active()
ls = self.linestyles[ind]
return ls
def get_active_marker(self):
'get the active lineinestyle'
ind = self.cbox_markers.get_active()
m = self.markers[ind]
return m
def _update(self):
'update the active line props from the widgets'
if not self._inited or not self._updateson: return
line = self.get_active_line()
ls = self.get_active_linestyle()
marker = self.get_active_marker()
line.set_linestyle(ls)
line.set_marker(marker)
button = self.wtree.get_widget('colorbutton_linestyle')
color = button.get_color()
r, g, b = [val/65535. for val in color.red, color.green, color.blue]
line.set_color((r,g,b))
button = self.wtree.get_widget('colorbutton_markerface')
color = button.get_color()
r, g, b = [val/65535. for val in color.red, color.green, color.blue]
line.set_markerfacecolor((r,g,b))
line.figure.canvas.draw()
def on_combobox_lineprops_changed(self, item):
'update the widgets from the active line'
if not self._inited: return
self._updateson = False
line = self.get_active_line()
ls = line.get_linestyle()
if ls is None: ls = 'None'
self.cbox_linestyles.set_active(self.linestyled[ls])
marker = line.get_marker()
if marker is None: marker = 'None'
self.cbox_markers.set_active(self.markerd[marker])
r,g,b = colorConverter.to_rgb(line.get_color())
color = gtk.gdk.Color(*[int(val*65535) for val in r,g,b])
button = self.wtree.get_widget('colorbutton_linestyle')
button.set_color(color)
r,g,b = colorConverter.to_rgb(line.get_markerfacecolor())
color = gtk.gdk.Color(*[int(val*65535) for val in r,g,b])
button = self.wtree.get_widget('colorbutton_markerface')
button.set_color(color)
self._updateson = True
def on_combobox_linestyle_changed(self, item):
self._update()
def on_combobox_marker_changed(self, item):
self._update()
def on_colorbutton_linestyle_color_set(self, button):
self._update()
def on_colorbutton_markerface_color_set(self, button):
'called colorbutton marker clicked'
self._update()
def on_dialog_lineprops_okbutton_clicked(self, button):
self._update()
self.dlg.hide()
def on_dialog_lineprops_cancelbutton_clicked(self, button):
self.dlg.hide()
# set icon used when windows are minimized
# Unfortunately, the SVG renderer (rsvg) leaks memory under earlier
# versions of pygtk, so we have to use a PNG file instead.
try:
if gtk.pygtk_version < (2, 8, 0) or sys.platform == 'win32':
icon_filename = 'matplotlib.png'
else:
icon_filename = 'matplotlib.svg'
window_icon = os.path.join(matplotlib.rcParams['datapath'], 'images', icon_filename)
except:
window_icon = None
verbose.report('Could not load matplotlib icon: %s' % sys.exc_info()[1])
def error_msg_gtk(msg, parent=None):
if parent is not None: # find the toplevel gtk.Window
parent = parent.get_toplevel()
if parent.flags() & gtk.TOPLEVEL == 0:
parent = None
if not is_string_like(msg):
msg = ','.join(map(str,msg))
dialog = gtk.MessageDialog(
parent = parent,
type = gtk.MESSAGE_ERROR,
buttons = gtk.BUTTONS_OK,
message_format = msg)
dialog.run()
dialog.destroy()
FigureManager = FigureManagerGTK
| SpaceKatt/CSPLN | apps/scaffolding/mac/web2py/web2py.app/Contents/Resources/lib/python2.7/matplotlib/backends/backend_gtk.py | Python | gpl-3.0 | 43,329 | [
"FLEUR"
] | 4aeb004e80adbe2345355c0de322735e6d0a2a4fa0179b6b02c850c3f7f3af3a |
# (c) 2012, Michael DeHaan <michael.dehaan@gmail.com>
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible. If not, see <http://www.gnu.org/licenses/>.
import sys
import re
import os
import shlex
import yaml
import copy
import optparse
import operator
from ansible import errors
from ansible import __version__
from ansible.utils.plugins import *
from ansible.utils import template
from ansible.callbacks import display
import ansible.constants as C
import ast
import time
import StringIO
import stat
import termios
import tty
import pipes
import random
import difflib
import warnings
import traceback
import getpass
import sys
import textwrap
#import vault
from vault import VaultLib
VERBOSITY=0
# list of all deprecation messages to prevent duplicate display
deprecations = {}
warns = {}
MAX_FILE_SIZE_FOR_DIFF=1*1024*1024
try:
import json
except ImportError:
import simplejson as json
try:
from hashlib import md5 as _md5
except ImportError:
from md5 import md5 as _md5
PASSLIB_AVAILABLE = False
try:
import passlib.hash
PASSLIB_AVAILABLE = True
except:
pass
KEYCZAR_AVAILABLE=False
try:
import keyczar.errors as key_errors
from keyczar.keys import AesKey
KEYCZAR_AVAILABLE=True
except ImportError:
pass
###############################################################
# Abstractions around keyczar
###############################################################
def key_for_hostname(hostname):
# fireball mode is an implementation of ansible firing up zeromq via SSH
# to use no persistent daemons or key management
if not KEYCZAR_AVAILABLE:
raise errors.AnsibleError("python-keyczar must be installed on the control machine to use accelerated modes")
key_path = os.path.expanduser(C.ACCELERATE_KEYS_DIR)
if not os.path.exists(key_path):
os.makedirs(key_path, mode=0700)
os.chmod(key_path, int(C.ACCELERATE_KEYS_DIR_PERMS, 8))
elif not os.path.isdir(key_path):
raise errors.AnsibleError('ACCELERATE_KEYS_DIR is not a directory.')
if stat.S_IMODE(os.stat(key_path).st_mode) != int(C.ACCELERATE_KEYS_DIR_PERMS, 8):
raise errors.AnsibleError('Incorrect permissions on ACCELERATE_KEYS_DIR (%s)' % (C.ACCELERATE_KEYS_DIR,))
key_path = os.path.join(key_path, hostname)
# use new AES keys every 2 hours, which means fireball must not allow running for longer either
if not os.path.exists(key_path) or (time.time() - os.path.getmtime(key_path) > 60*60*2):
key = AesKey.Generate()
fd = os.open(key_path, os.O_WRONLY | os.O_CREAT, int(C.ACCELERATE_KEYS_FILE_PERMS, 8))
fh = os.fdopen(fd, 'w')
fh.write(str(key))
fh.close()
return key
else:
if stat.S_IMODE(os.stat(key_path).st_mode) != int(C.ACCELERATE_KEYS_FILE_PERMS, 8):
raise errors.AnsibleError('Incorrect permissions on ACCELERATE_KEYS_FILE (%s)' % (key_path,))
fh = open(key_path)
key = AesKey.Read(fh.read())
fh.close()
return key
def encrypt(key, msg):
return key.Encrypt(msg)
def decrypt(key, msg):
try:
return key.Decrypt(msg)
except key_errors.InvalidSignatureError:
raise errors.AnsibleError("decryption failed")
###############################################################
# UTILITY FUNCTIONS FOR COMMAND LINE TOOLS
###############################################################
def err(msg):
''' print an error message to stderr '''
print >> sys.stderr, msg
def exit(msg, rc=1):
''' quit with an error to stdout and a failure code '''
err(msg)
sys.exit(rc)
def jsonify(result, format=False):
''' format JSON output (uncompressed or uncompressed) '''
if result is None:
return "{}"
result2 = result.copy()
for key, value in result2.items():
if type(value) is str:
result2[key] = value.decode('utf-8', 'ignore')
if format:
return json.dumps(result2, sort_keys=True, indent=4)
else:
return json.dumps(result2, sort_keys=True)
def write_tree_file(tree, hostname, buf):
''' write something into treedir/hostname '''
# TODO: might be nice to append playbook runs per host in a similar way
# in which case, we'd want append mode.
path = os.path.join(tree, hostname)
fd = open(path, "w+")
fd.write(buf)
fd.close()
def is_failed(result):
''' is a given JSON result a failed result? '''
return ((result.get('rc', 0) != 0) or (result.get('failed', False) in [ True, 'True', 'true']))
def is_changed(result):
''' is a given JSON result a changed result? '''
return (result.get('changed', False) in [ True, 'True', 'true'])
def check_conditional(conditional, basedir, inject, fail_on_undefined=False):
if conditional is None or conditional == '':
return True
if isinstance(conditional, list):
for x in conditional:
if not check_conditional(x, basedir, inject, fail_on_undefined=fail_on_undefined):
return False
return True
if not isinstance(conditional, basestring):
return conditional
conditional = conditional.replace("jinja2_compare ","")
# allow variable names
if conditional in inject and str(inject[conditional]).find('-') == -1:
conditional = inject[conditional]
conditional = template.template(basedir, conditional, inject, fail_on_undefined=fail_on_undefined)
original = str(conditional).replace("jinja2_compare ","")
# a Jinja2 evaluation that results in something Python can eval!
presented = "{%% if %s %%} True {%% else %%} False {%% endif %%}" % conditional
conditional = template.template(basedir, presented, inject)
val = conditional.strip()
if val == presented:
# the templating failed, meaning most likely a
# variable was undefined. If we happened to be
# looking for an undefined variable, return True,
# otherwise fail
if conditional.find("is undefined") != -1:
return True
elif conditional.find("is defined") != -1:
return False
else:
raise errors.AnsibleError("error while evaluating conditional: %s" % original)
elif val == "True":
return True
elif val == "False":
return False
else:
raise errors.AnsibleError("unable to evaluate conditional: %s" % original)
def is_executable(path):
'''is the given path executable?'''
return (stat.S_IXUSR & os.stat(path)[stat.ST_MODE]
or stat.S_IXGRP & os.stat(path)[stat.ST_MODE]
or stat.S_IXOTH & os.stat(path)[stat.ST_MODE])
def unfrackpath(path):
'''
returns a path that is free of symlinks, environment
variables, relative path traversals and symbols (~)
example:
'$HOME/../../var/mail' becomes '/var/spool/mail'
'''
return os.path.normpath(os.path.realpath(os.path.expandvars(os.path.expanduser(path))))
def prepare_writeable_dir(tree,mode=0777):
''' make sure a directory exists and is writeable '''
# modify the mode to ensure the owner at least
# has read/write access to this directory
mode |= 0700
# make sure the tree path is always expanded
# and normalized and free of symlinks
tree = unfrackpath(tree)
if not os.path.exists(tree):
try:
os.makedirs(tree, mode)
except (IOError, OSError), e:
raise errors.AnsibleError("Could not make dir %s: %s" % (tree, e))
if not os.access(tree, os.W_OK):
raise errors.AnsibleError("Cannot write to path %s" % tree)
return tree
def path_dwim(basedir, given):
'''
make relative paths work like folks expect.
'''
if given.startswith("/"):
return os.path.abspath(given)
elif given.startswith("~"):
return os.path.abspath(os.path.expanduser(given))
else:
if basedir is None:
basedir = "."
return os.path.abspath(os.path.join(basedir, given))
def path_dwim_relative(original, dirname, source, playbook_base, check=True):
''' find one file in a directory one level up in a dir named dirname relative to current '''
# (used by roles code)
basedir = os.path.dirname(original)
if os.path.islink(basedir):
basedir = unfrackpath(basedir)
template2 = os.path.join(basedir, dirname, source)
else:
template2 = os.path.join(basedir, '..', dirname, source)
source2 = path_dwim(basedir, template2)
if os.path.exists(source2):
return source2
obvious_local_path = path_dwim(playbook_base, source)
if os.path.exists(obvious_local_path):
return obvious_local_path
if check:
raise errors.AnsibleError("input file not found at %s or %s" % (source2, obvious_local_path))
return source2 # which does not exist
def json_loads(data):
''' parse a JSON string and return a data structure '''
return json.loads(data)
def parse_json(raw_data):
''' this version for module return data only '''
orig_data = raw_data
# ignore stuff like tcgetattr spewage or other warnings
data = filter_leading_non_json_lines(raw_data)
try:
return json.loads(data)
except:
# not JSON, but try "Baby JSON" which allows many of our modules to not
# require JSON and makes writing modules in bash much simpler
results = {}
try:
tokens = shlex.split(data)
except:
print "failed to parse json: "+ data
raise
for t in tokens:
if t.find("=") == -1:
raise errors.AnsibleError("failed to parse: %s" % orig_data)
(key,value) = t.split("=", 1)
if key == 'changed' or 'failed':
if value.lower() in [ 'true', '1' ]:
value = True
elif value.lower() in [ 'false', '0' ]:
value = False
if key == 'rc':
value = int(value)
results[key] = value
if len(results.keys()) == 0:
return { "failed" : True, "parsed" : False, "msg" : orig_data }
return results
def smush_braces(data):
''' smush Jinaj2 braces so unresolved templates like {{ foo }} don't get parsed weird by key=value code '''
while data.find('{{ ') != -1:
data = data.replace('{{ ', '{{')
while data.find(' }}') != -1:
data = data.replace(' }}', '}}')
return data
def smush_ds(data):
# things like key={{ foo }} are not handled by shlex.split well, so preprocess any YAML we load
# so we do not have to call smush elsewhere
if type(data) == list:
return [ smush_ds(x) for x in data ]
elif type(data) == dict:
for (k,v) in data.items():
data[k] = smush_ds(v)
return data
elif isinstance(data, basestring):
return smush_braces(data)
else:
return data
def parse_yaml(data):
''' convert a yaml string to a data structure '''
return smush_ds(yaml.safe_load(data))
def process_common_errors(msg, probline, column):
replaced = probline.replace(" ","")
if replaced.find(":{{") != -1 and replaced.find("}}") != -1:
msg = msg + """
This one looks easy to fix. YAML thought it was looking for the start of a
hash/dictionary and was confused to see a second "{". Most likely this was
meant to be an ansible template evaluation instead, so we have to give the
parser a small hint that we wanted a string instead. The solution here is to
just quote the entire value.
For instance, if the original line was:
app_path: {{ base_path }}/foo
It should be written as:
app_path: "{{ base_path }}/foo"
"""
return msg
elif len(probline) and len(probline) > 1 and len(probline) > column and probline[column] == ":" and probline.count(':') > 1:
msg = msg + """
This one looks easy to fix. There seems to be an extra unquoted colon in the line
and this is confusing the parser. It was only expecting to find one free
colon. The solution is just add some quotes around the colon, or quote the
entire line after the first colon.
For instance, if the original line was:
copy: src=file.txt dest=/path/filename:with_colon.txt
It can be written as:
copy: src=file.txt dest='/path/filename:with_colon.txt'
Or:
copy: 'src=file.txt dest=/path/filename:with_colon.txt'
"""
return msg
else:
parts = probline.split(":")
if len(parts) > 1:
middle = parts[1].strip()
match = False
unbalanced = False
if middle.startswith("'") and not middle.endswith("'"):
match = True
elif middle.startswith('"') and not middle.endswith('"'):
match = True
if len(middle) > 0 and middle[0] in [ '"', "'" ] and middle[-1] in [ '"', "'" ] and probline.count("'") > 2 or probline.count("'") > 2:
unbalanced = True
if match:
msg = msg + """
This one looks easy to fix. It seems that there is a value started
with a quote, and the YAML parser is expecting to see the line ended
with the same kind of quote. For instance:
when: "ok" in result.stdout
Could be written as:
when: '"ok" in result.stdout'
or equivalently:
when: "'ok' in result.stdout"
"""
return msg
if unbalanced:
msg = msg + """
We could be wrong, but this one looks like it might be an issue with
unbalanced quotes. If starting a value with a quote, make sure the
line ends with the same set of quotes. For instance this arbitrary
example:
foo: "bad" "wolf"
Could be written as:
foo: '"bad" "wolf"'
"""
return msg
return msg
def process_yaml_error(exc, data, path=None):
if hasattr(exc, 'problem_mark'):
mark = exc.problem_mark
if mark.line -1 >= 0:
before_probline = data.split("\n")[mark.line-1]
else:
before_probline = ''
probline = data.split("\n")[mark.line]
arrow = " " * mark.column + "^"
msg = """Syntax Error while loading YAML script, %s
Note: The error may actually appear before this position: line %s, column %s
%s
%s
%s""" % (path, mark.line + 1, mark.column + 1, before_probline, probline, arrow)
unquoted_var = None
if '{{' in probline and '}}' in probline:
if '"{{' not in probline or "'{{" not in probline:
unquoted_var = True
msg = process_common_errors(msg, probline, mark.column)
if not unquoted_var:
msg = process_common_errors(msg, probline, mark.column)
else:
msg = msg + """
We could be wrong, but this one looks like it might be an issue with
missing quotes. Always quote template expression brackets when they
start a value. For instance:
with_items:
- {{ foo }}
Should be written as:
with_items:
- "{{ foo }}"
"""
msg = process_common_errors(msg, probline, mark.column)
else:
# No problem markers means we have to throw a generic
# "stuff messed up" type message. Sry bud.
if path:
msg = "Could not parse YAML. Check over %s again." % path
else:
msg = "Could not parse YAML."
raise errors.AnsibleYAMLValidationFailed(msg)
def parse_yaml_from_file(path, vault_password=None):
''' convert a yaml file to a data structure '''
data = None
try:
data = open(path).read()
except IOError:
raise errors.AnsibleError("file could not read: %s" % path)
vault = VaultLib(password=vault_password)
if vault.is_encrypted(data):
data = vault.decrypt(data)
try:
return parse_yaml(data)
except yaml.YAMLError, exc:
process_yaml_error(exc, data, path)
def parse_kv(args):
''' convert a string of key/value items to a dict '''
options = {}
if args is not None:
# attempting to split a unicode here does bad things
args = args.encode('utf-8')
vargs = [x.decode('utf-8') for x in shlex.split(args, posix=True)]
#vargs = shlex.split(str(args), posix=True)
for x in vargs:
if x.find("=") != -1:
k, v = x.split("=",1)
options[k]=v
return options
def merge_hash(a, b):
''' recursively merges hash b into a
keys from b take precedence over keys from a '''
result = copy.deepcopy(a)
# next, iterate over b keys and values
for k, v in b.iteritems():
# if there's already such key in a
# and that key contains dict
if k in result and isinstance(result[k], dict):
# merge those dicts recursively
result[k] = merge_hash(a[k], v)
else:
# otherwise, just copy a value from b to a
result[k] = v
return result
def md5s(data):
''' Return MD5 hex digest of data. '''
digest = _md5()
try:
digest.update(data)
except UnicodeEncodeError:
digest.update(data.encode('utf-8'))
return digest.hexdigest()
def md5(filename):
''' Return MD5 hex digest of local file, or None if file is not present. '''
if not os.path.exists(filename):
return None
digest = _md5()
blocksize = 64 * 1024
infile = open(filename, 'rb')
block = infile.read(blocksize)
while block:
digest.update(block)
block = infile.read(blocksize)
infile.close()
return digest.hexdigest()
def default(value, function):
''' syntactic sugar around lazy evaluation of defaults '''
if value is None:
return function()
return value
def _gitinfo():
''' returns a string containing git branch, commit id and commit date '''
result = None
repo_path = os.path.join(os.path.dirname(__file__), '..', '..', '..', '.git')
if os.path.exists(repo_path):
# Check if the .git is a file. If it is a file, it means that we are in a submodule structure.
if os.path.isfile(repo_path):
try:
gitdir = yaml.safe_load(open(repo_path)).get('gitdir')
# There is a posibility the .git file to have an absolute path.
if os.path.isabs(gitdir):
repo_path = gitdir
else:
repo_path = os.path.join(repo_path.split('.git')[0], gitdir)
except (IOError, AttributeError):
return ''
f = open(os.path.join(repo_path, "HEAD"))
branch = f.readline().split('/')[-1].rstrip("\n")
f.close()
branch_path = os.path.join(repo_path, "refs", "heads", branch)
if os.path.exists(branch_path):
f = open(branch_path)
commit = f.readline()[:10]
f.close()
date = time.localtime(os.stat(branch_path).st_mtime)
if time.daylight == 0:
offset = time.timezone
else:
offset = time.altzone
result = "({0} {1}) last updated {2} (GMT {3:+04d})".format(branch, commit,
time.strftime("%Y/%m/%d %H:%M:%S", date), offset / -36)
else:
result = ''
return result
def version(prog):
result = "{0} {1}".format(prog, __version__)
gitinfo = _gitinfo()
if gitinfo:
result = result + " {0}".format(gitinfo)
return result
def getch():
''' read in a single character '''
fd = sys.stdin.fileno()
old_settings = termios.tcgetattr(fd)
try:
tty.setraw(sys.stdin.fileno())
ch = sys.stdin.read(1)
finally:
termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
return ch
def sanitize_output(str):
''' strips private info out of a string '''
private_keys = ['password', 'login_password']
filter_re = [
# filter out things like user:pass@foo/whatever
# and http://username:pass@wherever/foo
re.compile('^(?P<before>.*:)(?P<password>.*)(?P<after>\@.*)$'),
]
parts = str.split()
output = ''
for part in parts:
try:
(k,v) = part.split('=', 1)
if k in private_keys:
output += " %s=VALUE_HIDDEN" % k
else:
found = False
for filter in filter_re:
m = filter.match(v)
if m:
d = m.groupdict()
output += " %s=%s" % (k, d['before'] + "********" + d['after'])
found = True
break
if not found:
output += " %s" % part
except:
output += " %s" % part
return output.strip()
####################################################################
# option handling code for /usr/bin/ansible and ansible-playbook
# below this line
class SortedOptParser(optparse.OptionParser):
'''Optparser which sorts the options by opt before outputting --help'''
def format_help(self, formatter=None):
self.option_list.sort(key=operator.methodcaller('get_opt_string'))
return optparse.OptionParser.format_help(self, formatter=None)
def increment_debug(option, opt, value, parser):
global VERBOSITY
VERBOSITY += 1
def base_parser(constants=C, usage="", output_opts=False, runas_opts=False,
async_opts=False, connect_opts=False, subset_opts=False, check_opts=False, diff_opts=False):
''' create an options parser for any ansible script '''
parser = SortedOptParser(usage, version=version("%prog"))
parser.add_option('-v','--verbose', default=False, action="callback",
callback=increment_debug, help="verbose mode (-vvv for more, -vvvv to enable connection debugging)")
parser.add_option('-f','--forks', dest='forks', default=constants.DEFAULT_FORKS, type='int',
help="specify number of parallel processes to use (default=%s)" % constants.DEFAULT_FORKS)
parser.add_option('-i', '--inventory-file', dest='inventory',
help="specify inventory host file (default=%s)" % constants.DEFAULT_HOST_LIST,
default=constants.DEFAULT_HOST_LIST)
parser.add_option('-k', '--ask-pass', default=False, dest='ask_pass', action='store_true',
help='ask for SSH password')
parser.add_option('--private-key', default=C.DEFAULT_PRIVATE_KEY_FILE, dest='private_key_file',
help='use this file to authenticate the connection')
parser.add_option('-K', '--ask-sudo-pass', default=False, dest='ask_sudo_pass', action='store_true',
help='ask for sudo password')
parser.add_option('--ask-su-pass', default=False, dest='ask_su_pass', action='store_true',
help='ask for su password')
parser.add_option('--ask-vault-pass', default=False, dest='ask_vault_pass', action='store_true',
help='ask for vault password')
parser.add_option('--vault-password-file', default=None, dest='vault_password_file',
help="vault password file")
parser.add_option('--list-hosts', dest='listhosts', action='store_true',
help='outputs a list of matching hosts; does not execute anything else')
parser.add_option('-M', '--module-path', dest='module_path',
help="specify path(s) to module library (default=%s)" % constants.DEFAULT_MODULE_PATH,
default=None)
if subset_opts:
parser.add_option('-l', '--limit', default=constants.DEFAULT_SUBSET, dest='subset',
help='further limit selected hosts to an additional pattern')
parser.add_option('-T', '--timeout', default=constants.DEFAULT_TIMEOUT, type='int',
dest='timeout',
help="override the SSH timeout in seconds (default=%s)" % constants.DEFAULT_TIMEOUT)
if output_opts:
parser.add_option('-o', '--one-line', dest='one_line', action='store_true',
help='condense output')
parser.add_option('-t', '--tree', dest='tree', default=None,
help='log output to this directory')
if runas_opts:
parser.add_option("-s", "--sudo", default=constants.DEFAULT_SUDO, action="store_true",
dest='sudo', help="run operations with sudo (nopasswd)")
parser.add_option('-U', '--sudo-user', dest='sudo_user', default=None,
help='desired sudo user (default=root)') # Can't default to root because we need to detect when this option was given
parser.add_option('-u', '--user', default=constants.DEFAULT_REMOTE_USER,
dest='remote_user', help='connect as this user (default=%s)' % constants.DEFAULT_REMOTE_USER)
parser.add_option('-S', '--su', default=constants.DEFAULT_SU,
action='store_true', help='run operations with su')
parser.add_option('-R', '--su-user', help='run operations with su as this '
'user (default=%s)' % constants.DEFAULT_SU_USER)
if connect_opts:
parser.add_option('-c', '--connection', dest='connection',
default=C.DEFAULT_TRANSPORT,
help="connection type to use (default=%s)" % C.DEFAULT_TRANSPORT)
if async_opts:
parser.add_option('-P', '--poll', default=constants.DEFAULT_POLL_INTERVAL, type='int',
dest='poll_interval',
help="set the poll interval if using -B (default=%s)" % constants.DEFAULT_POLL_INTERVAL)
parser.add_option('-B', '--background', dest='seconds', type='int', default=0,
help='run asynchronously, failing after X seconds (default=N/A)')
if check_opts:
parser.add_option("-C", "--check", default=False, dest='check', action='store_true',
help="don't make any changes; instead, try to predict some of the changes that may occur"
)
if diff_opts:
parser.add_option("-D", "--diff", default=False, dest='diff', action='store_true',
help="when changing (small) files and templates, show the differences in those files; works great with --check"
)
return parser
def ask_vault_passwords(ask_vault_pass=False, ask_new_vault_pass=False, confirm_vault=False, confirm_new=False):
vault_pass = None
new_vault_pass = None
if ask_vault_pass:
vault_pass = getpass.getpass(prompt="Vault password: ")
if ask_vault_pass and confirm_vault:
vault_pass2 = getpass.getpass(prompt="Confirm Vault password: ")
if vault_pass != vault_pass2:
raise errors.AnsibleError("Passwords do not match")
if ask_new_vault_pass:
new_vault_pass = getpass.getpass(prompt="New Vault password: ")
if ask_new_vault_pass and confirm_new:
new_vault_pass2 = getpass.getpass(prompt="Confirm New Vault password: ")
if new_vault_pass != new_vault_pass2:
raise errors.AnsibleError("Passwords do not match")
return vault_pass, new_vault_pass
def ask_passwords(ask_pass=False, ask_sudo_pass=False, ask_su_pass=False, ask_vault_pass=False):
sshpass = None
sudopass = None
su_pass = None
vault_pass = None
sudo_prompt = "sudo password: "
su_prompt = "su password: "
if ask_pass:
sshpass = getpass.getpass(prompt="SSH password: ")
sudo_prompt = "sudo password [defaults to SSH password]: "
if ask_sudo_pass:
sudopass = getpass.getpass(prompt=sudo_prompt)
if ask_pass and sudopass == '':
sudopass = sshpass
if ask_su_pass:
su_pass = getpass.getpass(prompt=su_prompt)
if ask_vault_pass:
vault_pass = getpass.getpass(prompt="Vault password: ")
return (sshpass, sudopass, su_pass, vault_pass)
def do_encrypt(result, encrypt, salt_size=None, salt=None):
if PASSLIB_AVAILABLE:
try:
crypt = getattr(passlib.hash, encrypt)
except:
raise errors.AnsibleError("passlib does not support '%s' algorithm" % encrypt)
if salt_size:
result = crypt.encrypt(result, salt_size=salt_size)
elif salt:
result = crypt.encrypt(result, salt=salt)
else:
result = crypt.encrypt(result)
else:
raise errors.AnsibleError("passlib must be installed to encrypt vars_prompt values")
return result
def last_non_blank_line(buf):
all_lines = buf.splitlines()
all_lines.reverse()
for line in all_lines:
if (len(line) > 0):
return line
# shouldn't occur unless there's no output
return ""
def filter_leading_non_json_lines(buf):
'''
used to avoid random output from SSH at the top of JSON output, like messages from
tcagetattr, or where dropbear spews MOTD on every single command (which is nuts).
need to filter anything which starts not with '{', '[', ', '=' or is an empty line.
filter only leading lines since multiline JSON is valid.
'''
filtered_lines = StringIO.StringIO()
stop_filtering = False
for line in buf.splitlines():
if stop_filtering or "=" in line or line.startswith('{') or line.startswith('['):
stop_filtering = True
filtered_lines.write(line + '\n')
return filtered_lines.getvalue()
def boolean(value):
val = str(value)
if val.lower() in [ "true", "t", "y", "1", "yes" ]:
return True
else:
return False
def make_sudo_cmd(sudo_user, executable, cmd):
"""
helper function for connection plugins to create sudo commands
"""
# Rather than detect if sudo wants a password this time, -k makes
# sudo always ask for a password if one is required.
# Passing a quoted compound command to sudo (or sudo -s)
# directly doesn't work, so we shellquote it with pipes.quote()
# and pass the quoted string to the user's shell. We loop reading
# output until we see the randomly-generated sudo prompt set with
# the -p option.
randbits = ''.join(chr(random.randint(ord('a'), ord('z'))) for x in xrange(32))
prompt = '[sudo via ansible, key=%s] password: ' % randbits
success_key = 'SUDO-SUCCESS-%s' % randbits
sudocmd = '%s -k && %s %s -S -p "%s" -u %s %s -c %s' % (
C.DEFAULT_SUDO_EXE, C.DEFAULT_SUDO_EXE, C.DEFAULT_SUDO_FLAGS,
prompt, sudo_user, executable or '$SHELL', pipes.quote('echo %s; %s' % (success_key, cmd)))
return ('/bin/sh -c ' + pipes.quote(sudocmd), prompt, success_key)
def make_su_cmd(su_user, executable, cmd):
"""
Helper function for connection plugins to create direct su commands
"""
# TODO: work on this function
randbits = ''.join(chr(random.randint(ord('a'), ord('z'))) for x in xrange(32))
prompt = 'assword: '
success_key = 'SUDO-SUCCESS-%s' % randbits
sudocmd = '%s %s %s %s -c %s' % (
C.DEFAULT_SU_EXE, C.DEFAULT_SU_FLAGS, su_user, executable or '$SHELL',
pipes.quote('echo %s; %s' % (success_key, cmd))
)
return ('/bin/sh -c ' + pipes.quote(sudocmd), prompt, success_key)
_TO_UNICODE_TYPES = (unicode, type(None))
def to_unicode(value):
if isinstance(value, _TO_UNICODE_TYPES):
return value
return value.decode("utf-8")
def get_diff(diff):
# called by --diff usage in playbook and runner via callbacks
# include names in diffs 'before' and 'after' and do diff -U 10
try:
with warnings.catch_warnings():
warnings.simplefilter('ignore')
ret = []
if 'dst_binary' in diff:
ret.append("diff skipped: destination file appears to be binary\n")
if 'src_binary' in diff:
ret.append("diff skipped: source file appears to be binary\n")
if 'dst_larger' in diff:
ret.append("diff skipped: destination file size is greater than %d\n" % diff['dst_larger'])
if 'src_larger' in diff:
ret.append("diff skipped: source file size is greater than %d\n" % diff['src_larger'])
if 'before' in diff and 'after' in diff:
if 'before_header' in diff:
before_header = "before: %s" % diff['before_header']
else:
before_header = 'before'
if 'after_header' in diff:
after_header = "after: %s" % diff['after_header']
else:
after_header = 'after'
differ = difflib.unified_diff(to_unicode(diff['before']).splitlines(True), to_unicode(diff['after']).splitlines(True), before_header, after_header, '', '', 10)
for line in list(differ):
ret.append(line)
return u"".join(ret)
except UnicodeDecodeError:
return ">> the files are different, but the diff library cannot compare unicode strings"
def is_list_of_strings(items):
for x in items:
if not isinstance(x, basestring):
return False
return True
def safe_eval(expr, locals={}, include_exceptions=False):
'''
this is intended for allowing things like:
with_items: a_list_variable
where Jinja2 would return a string
but we do not want to allow it to call functions (outside of Jinja2, where
the env is constrained)
Based on:
http://stackoverflow.com/questions/12523516/using-ast-and-whitelists-to-make-pythons-eval-safe
'''
# this is the whitelist of AST nodes we are going to
# allow in the evaluation. Any node type other than
# those listed here will raise an exception in our custom
# visitor class defined below.
SAFE_NODES = set(
(
ast.Expression,
ast.Compare,
ast.Str,
ast.List,
ast.Tuple,
ast.Dict,
ast.Call,
ast.Load,
ast.BinOp,
ast.UnaryOp,
ast.Num,
ast.Name,
ast.Add,
ast.Sub,
ast.Mult,
ast.Div,
)
)
# AST node types were expanded after 2.6
if not sys.version.startswith('2.6'):
SAFE_NODES.union(
set(
(ast.Set,)
)
)
# builtin functions that are not safe to call
INVALID_CALLS = (
'classmethod', 'compile', 'delattr', 'eval', 'execfile', 'file',
'filter', 'help', 'input', 'object', 'open', 'raw_input', 'reduce',
'reload', 'repr', 'setattr', 'staticmethod', 'super', 'type',
)
class CleansingNodeVisitor(ast.NodeVisitor):
def generic_visit(self, node):
if type(node) not in SAFE_NODES:
#raise Exception("invalid expression (%s) type=%s" % (expr, type(node)))
raise Exception("invalid expression (%s)" % expr)
super(CleansingNodeVisitor, self).generic_visit(node)
def visit_Call(self, call):
if call.func.id in INVALID_CALLS:
raise Exception("invalid function: %s" % call.func.id)
if not isinstance(expr, basestring):
# already templated to a datastructure, perhaps?
if include_exceptions:
return (expr, None)
return expr
try:
parsed_tree = ast.parse(expr, mode='eval')
cnv = CleansingNodeVisitor()
cnv.visit(parsed_tree)
compiled = compile(parsed_tree, expr, 'eval')
result = eval(compiled, {}, locals)
if include_exceptions:
return (result, None)
else:
return result
except SyntaxError, e:
# special handling for syntax errors, we just return
# the expression string back as-is
if include_exceptions:
return (expr, None)
return expr
except Exception, e:
if include_exceptions:
return (expr, e)
return expr
def listify_lookup_plugin_terms(terms, basedir, inject):
if isinstance(terms, basestring):
# someone did:
# with_items: alist
# OR
# with_items: {{ alist }}
stripped = terms.strip()
if not (stripped.startswith('{') or stripped.startswith('[')) and not stripped.startswith("/") and not stripped.startswith('set(['):
# if not already a list, get ready to evaluate with Jinja2
# not sure why the "/" is in above code :)
try:
new_terms = template.template(basedir, "{{ %s }}" % terms, inject)
if isinstance(new_terms, basestring) and new_terms.find("{{") != -1:
pass
else:
terms = new_terms
except:
pass
if '{' in terms or '[' in terms:
# Jinja2 already evaluated a variable to a list.
# Jinja2-ified list needs to be converted back to a real type
# TODO: something a bit less heavy than eval
return safe_eval(terms)
if isinstance(terms, basestring):
terms = [ terms ]
return terms
def deprecated(msg, version, removed=False):
''' used to print out a deprecation message.'''
if not removed and not C.DEPRECATION_WARNINGS:
return
if not removed:
if version:
new_msg = "\n[DEPRECATION WARNING]: %s. This feature will be removed in version %s." % (msg, version)
else:
new_msg = "\n[DEPRECATION WARNING]: %s. This feature will be removed in a future release." % (msg)
new_msg = new_msg + " Deprecation warnings can be disabled by setting deprecation_warnings=False in ansible.cfg.\n\n"
else:
raise errors.AnsibleError("[DEPRECATED]: %s. Please update your playbooks." % msg)
wrapped = textwrap.wrap(new_msg, 79)
new_msg = "\n".join(wrapped) + "\n"
if new_msg not in deprecations:
display(new_msg, color='purple', stderr=True)
deprecations[new_msg] = 1
def warning(msg):
new_msg = "\n[WARNING]: %s" % msg
wrapped = textwrap.wrap(new_msg, 79)
new_msg = "\n".join(wrapped) + "\n"
if new_msg not in warns:
display(new_msg, color='bright purple', stderr=True)
warns[new_msg] = 1
def combine_vars(a, b):
if C.DEFAULT_HASH_BEHAVIOUR == "merge":
return merge_hash(a, b)
else:
return dict(a.items() + b.items())
def random_password(length=20, chars=C.DEFAULT_PASSWORD_CHARS):
'''Return a random password string of length containing only chars.'''
password = []
while len(password) < length:
new_char = os.urandom(1)
if new_char in chars:
password.append(new_char)
return ''.join(password)
| mitodl/ansible | lib/ansible/utils/__init__.py | Python | gpl-3.0 | 39,074 | [
"VisIt"
] | 150be469b101d23e18095c83a88af0a1bfff44db5deddd76b77b880a483529d9 |
# coding=utf-8
# Copyright 2022 The Google Research Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Self-normalized Importance Sampling distribution."""
from __future__ import absolute_import
import functools
import tensorflow.compat.v1 as tf
import tensorflow_probability as tfp
from eim.models import base
tfk = tf.keras
tfkl = tf.keras.layers
tfpl = tfp.layers
tfd = tfp.distributions
deconv = functools.partial(tf.keras.layers.Conv2DTranspose, padding="SAME")
conv = functools.partial(tf.keras.layers.Conv2D, padding="SAME")
class AbstractNIS(base.ProbabilisticModel):
"""Self-normalized Importance Sampling distribution."""
def __init__(self, # pylint: disable=invalid-name
K,
data_dim,
energy_fn,
proposal=None,
data_mean=None,
reparameterize_proposal_samples=True,
dtype=tf.float32):
"""Creates a NIS model.
Args:
K: The number of proposal samples to take.
data_dim: The dimension of the data.
energy_fn: Energy function.
proposal: A distribution over the data space of this model. Must support
sample() and log_prob() although log_prob only needs to return a lower
bound on the true log probability. If not supplied, then defaults to
Gaussian.
data_mean: Mean of the data used to center the input.
reparameterize_proposal_samples: Whether to allow gradients to pass
through the proposal samples.
dtype: Type of the tensors.
"""
self.K = K # pylint: disable=invalid-name
self.data_dim = data_dim # self.data_dim is always a list
self.reparameterize_proposal_samples = reparameterize_proposal_samples
if data_mean is not None:
self.data_mean = data_mean
else:
self.data_mean = tf.zeros((), dtype=dtype)
self.energy_fn = energy_fn
if proposal is None:
self.proposal = base.get_independent_normal(self.data_dim)
else:
self.proposal = proposal
def _log_prob(self, data, num_samples=1):
"""Compute a lower bound on the log likelihood."""
# Due to memory issues, we need to use num_samples=1 here
num_samples, proposal_num_samples = 1, num_samples
batch_size = tf.shape(data)[0]
# Sample from the proposal and compute the weighs of the "unseen" samples.
# We share these across the batch dimension.
# [num_samples, K, data_size]
proposal_samples = self.proposal.sample(num_samples * (self.K - 1))
if not self.reparameterize_proposal_samples:
proposal_samples = tf.stop_gradient(proposal_samples)
# [num_samples, K]
log_energy_proposal = tf.reshape(
self.energy_fn(tf.reshape(proposal_samples, [-1] + self.data_dim)),
[num_samples, self.K - 1])
tf.summary.histogram("log_energy_proposal", log_energy_proposal)
tf.summary.scalar("min_log_energy_proposal",
tf.reduce_min(log_energy_proposal))
tf.summary.scalar("max_log_energy_proposal",
tf.reduce_max(log_energy_proposal))
# [num_samples]
proposal_lse = tf.reduce_logsumexp(log_energy_proposal, axis=1)
# [batch_size, num_samples]
tiled_proposal_lse = tf.tile(proposal_lse[tf.newaxis, :], [batch_size, 1])
# Compute the weights of the observed data.
# [batch_size, 1]
log_energy_data = tf.reshape(self.energy_fn(data), [batch_size])
tf.summary.histogram("log_energy_data", log_energy_data)
tf.summary.scalar("min_log_energy_data", tf.reduce_min(log_energy_data))
tf.summary.scalar("max_log_energy_data", tf.reduce_max(log_energy_data))
# [batch_size, num_samples]
tiled_log_energy_data = tf.tile(log_energy_data[:, tf.newaxis],
[1, num_samples])
# Add the weights of the proposal samples with the true data weights.
# [batch_size, num_samples]
# pylint: disable=invalid-name
Z_hat = tf.reduce_logsumexp(
tf.stack([tiled_log_energy_data, tiled_proposal_lse], axis=-1), axis=-1)
Z_hat -= tf.log(tf.to_float(self.K))
# Perform the log-sum-exp reduction for IWAE
# [batch_size]
Z_hat = tf.reduce_logsumexp(
Z_hat, axis=1) - tf.log(tf.to_float(num_samples))
# pylint: enable=invalid-name
try:
# Try giving the proposal lower bound num_samples if it can use it.
proposal_lp = self.proposal.log_prob(data,
num_samples=proposal_num_samples)
except TypeError:
proposal_lp = self.proposal.log_prob(data)
lower_bound = proposal_lp + log_energy_data - Z_hat
return lower_bound
def sample(self, num_samples=1):
"""Sample from the model."""
flat_proposal_samples = self.proposal.sample(num_samples * self.K)
proposal_samples = tf.reshape(flat_proposal_samples,
[num_samples, self.K] + self.data_dim)
log_energy = tf.reshape(
tf.squeeze(self.energy_fn(flat_proposal_samples), axis=-1),
[num_samples, self.K])
indexes = tfd.Categorical(logits=log_energy).sample() # [num_samples]
samples = tf.batch_gather(proposal_samples,
tf.expand_dims(indexes, axis=-1))
return tf.squeeze(samples, axis=1) # Squeeze the selected dim
class NIS(AbstractNIS):
"""Self-normalized Importance Sampling distribution."""
def __init__(self,
K,
data_dim,
energy_hidden_sizes,
proposal=None,
data_mean=None,
reparameterize_proposal_samples=True,
dtype=tf.float32,
name="nis"):
"""Creates a NIS model.
Args:
K: The number of proposal samples to take.
data_dim: The dimension of the data.
energy_hidden_sizes: The sizes of the hidden layers for the MLP that
parameterizes the energy function.
proposal: A distribution over the data space of this model. Must support
sample() and log_prob() although log_prob only needs to return a lower
bound on the true log probability. If not supplied, then defaults to
Gaussian.
data_mean: Mean of the data used to center the input.
reparameterize_proposal_samples: Whether to allow gradients to pass
through the proposal samples.
dtype: Type of the tensors.
name: Name to use for ops.
"""
if data_mean is None:
data_mean = tf.zeros((), dtype=dtype)
energy_fn_helper = functools.partial(
base.mlp,
layer_sizes=energy_hidden_sizes + [1],
final_activation=None,
name="%s/energy_fn_mlp" % name)
def energy_fn(x):
# import ipdb
# ipdb.set_trace()
return energy_fn_helper(x - data_mean)
super(NIS, self).__init__(K, data_dim, energy_fn, proposal, data_mean,
reparameterize_proposal_samples, dtype)
class ConvNIS(AbstractNIS):
"""Self-normalized Importance Sampling distribution with convs."""
def __init__(self,
K,
data_dim,
proposal=None,
data_mean=None,
reparameterize_proposal_samples=True,
dtype=tf.float32,
name="nis"):
"""Creates a NIS model.
Args:
K: The number of proposal samples to take.
data_dim: The dimension of the data.
proposal: A distribution over the data space of this model. Must support
sample() and log_prob() although log_prob only needs to return a lower
bound on the true log probability. If not supplied, then defaults to
Gaussian.
data_mean: Mean of the data used to center the input.
reparameterize_proposal_samples: Whether to allow gradients to pass
through the proposal samples.
dtype: Type of the tensors.
name: Name to use for ops.
"""
if data_mean is None:
data_mean = tf.zeros((), dtype=dtype)
energy_fn = tf.keras.Sequential([
tfkl.Lambda(lambda t: t - data_mean),
conv(32, 4, 2, activation="relu"),
conv(32, 4, 2, activation="relu"),
conv(32, 4, 2, activation="relu"),
tfkl.Flatten(),
tfkl.Dense(1, activation=None),
])
super(ConvNIS, self).__init__(K, data_dim, energy_fn, proposal, data_mean,
reparameterize_proposal_samples, dtype)
| google-research/google-research | eim/models/nis.py | Python | apache-2.0 | 8,872 | [
"Gaussian"
] | b3496574784d55c7a97975c2358ba605c1878a048e4472f6e69505e5219c6a79 |
#!/usr/bin/env python
########################################################################
# $HeadURL$
# File : dirac-admin-list-users
# Author : Adrian Casajus
########################################################################
"""
Lists the users in the Configuration. If no group is specified return all users.
"""
__RCSID__ = "$Id$"
import DIRAC
from DIRAC.Core.Base import Script
Script.registerSwitch( "e", "extended", "Show extended info" )
Script.setUsageMessage( '\n'.join( [ __doc__.split( '\n' )[1],
'Usage:',
' %s [option|cfgfile] ... [Group] ...' % Script.scriptName,
'Arguments:',
' Group: Only users from this group (default: all)' ] ) )
Script.parseCommandLine( ignoreErrors = True )
args = Script.getPositionalArgs()
if len( args ) == 0:
args = ['all']
from DIRAC.Interfaces.API.DiracAdmin import DiracAdmin
diracAdmin = DiracAdmin()
exitCode = 0
errorList = []
extendedInfo = False
for unprocSw in Script.getUnprocessedSwitches():
if unprocSw[0] in ( 'e', 'extended' ):
extendedInfo = True
def printUsersInGroup( group = False ):
result = diracAdmin.csListUsers( group )
if result[ 'OK' ]:
if group:
print "Users in group %s:" % group
else:
print "All users registered:"
for username in result[ 'Value' ]:
print " %s" % username
def describeUsersInGroup( group = False ):
result = diracAdmin.csListUsers( group )
if result[ 'OK' ]:
if group:
print "Users in group %s:" % group
else:
print "All users registered:"
result = diracAdmin.csDescribeUsers( result[ 'Value' ] )
print diracAdmin.pPrint.pformat( result[ 'Value' ] )
for group in args:
if 'all' in args:
group = False
if not extendedInfo:
printUsersInGroup( group )
else:
describeUsersInGroup( group )
for error in errorList:
print "ERROR %s: %s" % error
DIRAC.exit( exitCode )
| avedaee/DIRAC | Interfaces/scripts/dirac-admin-list-users.py | Python | gpl-3.0 | 2,047 | [
"DIRAC"
] | be78da5da5e96e0c839d41d45696dcb035c420f3d539939b9da57c2dd390daa5 |
""" This file contains different utility functions that are not connected
in anyway to the networks presented in the tutorials, but rather help in
processing the outputs into a more understandable way.
For example ``tile_raster_images`` helps in generating a easy to grasp
image from a set of samples or weights.
Noises functions are based on
https://github.com/vitruvianscience/OpenDeep
"""
import numpy
import gzip
import os
import cPickle
import math
import theano
import theano.tensor as T
import theano.sandbox.rng_mrg as RNG_MRG
theano_random = RNG_MRG.MRG_RandomStreams(seed=23455)
def dropout(input, noise_level=0.5, mrg=None, rescale=True):
"""
This is the dropout function.
Parameters
----------
input : tensor
Tensor to apply dropout to.
corruption_level : float
Probability level for dropping an element (used in binomial distribution).
mrg : random
Random number generator with a .binomial method.
rescale : bool
Whether to rescale the output after dropout.
Returns
-------
tensor
Tensor with dropout applied.
"""
if mrg is None:
mrg = theano_random
keep_probability = 1 - noise_level
mask = mrg.binomial(p=keep_probability, n=1, size=input.shape, dtype=theano.config.floatX)
output = (input * mask)
if rescale:
output /= keep_probability
return output
def add_gaussian(input, noise_level=1, mrg=None):
"""
This takes an input tensor and adds Gaussian noise to its elements with mean zero and provided standard deviation.
Parameters
----------
input : tensor
Tensor to add Gaussian noise to.
noise_level : float
Standard deviation to use.
mrg : random
Random number generator with a .normal method.
Returns
-------
tensor
Tensor with Gaussian noise added.
"""
if mrg is None:
mrg = theano_random
noise = mrg.normal(avg=0, std=noise_level, size=input.shape, dtype=theano.config.floatX)
output = input + noise
return output
def add_uniform(input, noise_level, mrg=None):
"""
This takes an intput tensor and adds noise drawn from a Uniform distribution from +- interval.
Parameters
----------
input : tensor
Tensor to add uniform noise to.
noise_level : float
Range for noise to be drawn from (+- interval).
mrg : random
Random number generator with a .uniform method.
Returns
-------
tensor
Tensor with uniform noise added.
"""
if mrg is None:
mrg = theano_random
noise = mrg.uniform(low=-noise_level, high=noise_level, size=input.shape, dtype=theano.config.floatX)
output = input + noise
return output
def salt_and_pepper(input, noise_level=0.2, mrg=None):
"""
This applies salt and pepper noise to the input tensor - randomly setting bits to 1 or 0.
Parameters
----------
input : tensor
The tensor to apply salt and pepper noise to.
noise_level : float
The amount of salt and pepper noise to add.
mrg : random
Random number generator with .binomial method.
Returns
-------
tensor
Tensor with salt and pepper noise applied.
"""
if mrg is None:
mrg = theano_random
a = mrg.binomial(size=input.shape, n=1, p=(1 - noise_level), dtype=theano.config.floatX)
b = mrg.binomial(size=input.shape, n=1, p=0.5, dtype=theano.config.floatX)
c = T.eq(a, 0) * b
return input * a + c
def scale_to_unit_interval(ndar, eps=1e-8):
""" Scales all values in the ndarray ndar to be between 0 and 1
:param eps:
:param ndar:
"""
ndar = ndar.copy()
ndar -= ndar.min()
ndar *= 1.0 / (ndar.max() + eps)
return ndar
def zero_mean_unit_variance(Data):
""" Scales all values in the ndarray ndar to be between 0 and 1 """
Mean = numpy.mean(Data, axis=0)
Data -= Mean
Std = numpy.std(Data, axis=0)
index = (numpy.abs(Std < 10 ** -5))
Std[index] = 1
Data /= Std
return [Data, Mean, Std]
def normalize(Data, Mean, Std):
Data -= Mean
Data /= Std
return Data
def max_divisor(a):
b = int(round(math.sqrt(a)))
for i in range(b, 0, -1):
res = a % i
if res == 0:
return i
return 1
def tile_raster_images(X, n_visible, tile_shape, tile_spacing=(0, 0),
scale_rows_to_unit_interval=True,
output_pixel_vals=True):
"""
Transform an array with one flattened image per row, into an array in
which images are reshaped and layed out like tiles on a floor.
This function is useful for visualizing d whose rows are images,
and also columns of matrices for transforming those rows
(such as the first layer of a neural net).
:param tile_spacing:
:type X: a 2-D ndarray or a tuple of 4 channels, elements of which can
be 2-D ndarrays or None;
:param X: a 2-D array in which every row is a flattened image.
:type n_visible: Int;
:param n_visible: Number of visibles units
:type tile_shape: tuple; (rows, cols)
:param tile_shape: the number of images to tile (rows, cols)
:param output_pixel_vals: if output should be pixel values (i.e. int8
values) or floats
:param scale_rows_to_unit_interval: if the values need to be scaled before
being plotted to [0,1] or not
:returns: array suitable for viewing as an image.
(See:`Image.fromarray`.)
:rtype: a 2-d array with same dtype as X.
"""
comun_divisor = max_divisor(n_visible)
img_shape = (comun_divisor, n_visible / comun_divisor)
assert len(img_shape) == 2
assert len(tile_shape) == 2
assert len(tile_spacing) == 2
# The expression below can be re-written in a more C style as
# follows :
#
# out_shape = [0,0]
# out_shape[0] = (img_shape[0]+tile_spacing[0])*tile_shape[0] -
# tile_spacing[0]
# out_shape[1] = (img_shape[1]+tile_spacing[1])*tile_shape[1] -
# tile_spacing[1]
out_shape = [
(ishp + tsp) * tshp - tsp
for ishp, tshp, tsp in zip(img_shape, tile_shape, tile_spacing)
]
if isinstance(X, tuple):
assert len(X) == 4
# Create an output numpy ndarray to store the image
if output_pixel_vals:
out_array = numpy.zeros((out_shape[0], out_shape[1], 4),
dtype='uint8')
else:
out_array = numpy.zeros((out_shape[0], out_shape[1], 4),
dtype=X.dtype)
# colors default to 0, alpha defaults to 1 (opaque)
if output_pixel_vals:
channel_defaults = [0, 0, 0, 255]
else:
channel_defaults = [0., 0., 0., 1.]
for i in xrange(4):
if X[i] is None:
# if channel is None, fill it with zeros of the correct
# dtype
dt = out_array.dtype
if output_pixel_vals:
dt = 'uint8'
out_array[:, :, i] = numpy.zeros(
out_shape,
dtype=dt
) + channel_defaults[i]
else:
# use a recurrent call to compute the channel and store it
# in the output
out_array[:, :, i] = tile_raster_images(
X[i], img_shape, tile_shape, tile_spacing,
scale_rows_to_unit_interval, output_pixel_vals)
return out_array
else:
# if we are dealing with only one channel
H, W = img_shape
Hs, Ws = tile_spacing
# generate a matrix to store the output
dt = X.dtype
if output_pixel_vals:
dt = 'uint8'
out_array = numpy.zeros(out_shape, dtype=dt)
for tile_row in xrange(tile_shape[0]):
for tile_col in xrange(tile_shape[1]):
if tile_row * tile_shape[1] + tile_col < X.shape[0]:
this_x = X[tile_row * tile_shape[1] + tile_col]
if scale_rows_to_unit_interval:
# if we should scale values to be between 0 and 1
# do this by calling the `scale_to_unit_interval`
# function
this_img = scale_to_unit_interval(
this_x.reshape(img_shape))
else:
this_img = this_x.reshape(img_shape)
# add the slice to the corresponding position in the
# output array
c = 1
if output_pixel_vals:
c = 255
out_array[
tile_row * (H + Hs): tile_row * (H + Hs) + H,
tile_col * (W + Ws): tile_col * (W + Ws) + W
] = this_img * c
return out_array
def load_data(dataset):
""" Loads the dataset
:type dataset: string
:param dataset: the path to the dataset (here MNIST)
"""
#############
# LOAD DATA #
#############
# Download the MNIST dataset if it is not present
data_dir, data_file = os.path.split(dataset)
if data_dir == "" and not os.path.isfile(dataset):
# Check if dataset is in the data directory.
new_path = os.path.join(
os.path.split(__file__)[0],
"..",
"datasets",
"dataset",
dataset
)
if os.path.isfile(new_path) or data_file == 'mnist.pkl.gz':
dataset = new_path
if (not os.path.isfile(dataset)) and data_file == 'mnist.pkl.gz':
import urllib
origin = (
'http://www.iro.umontreal.ca/~lisa/deep/data/mnist/mnist.pkl.gz'
)
print 'Downloading data from %s' % origin
urllib.urlretrieve(origin, dataset)
print '... loading data'
# Load the dataset
f = gzip.open(dataset, 'rb')
train_set, valid_set, test_set = cPickle.load(f)
f.close()
# train_set, valid_set, test_set format: tuple(input, target)
# input is an numpy.ndarray of 2 dimensions (a matrix)
# witch row's correspond to an example. target is a
# numpy.ndarray of 1 dimensions (vector)) that have the same length as
# the number of rows in the input. It should give the target
# target to the example with the same index in the input.
def shared_dataset(data_xy, borrow=True):
""" Function that loads the dataset into shared variables
The reason we store our dataset in shared variables is to allow
Theano to copy it into the GPU memory (when code is run on GPU).
Since copying data into the GPU is slow, copying a minibatch everytime
is needed (the default behaviour if the data is not in a shared
variable) would lead to a large decrease in performance.
:param data_xy:
:param borrow:
"""
data_x, data_y = data_xy
shared_x = theano.shared(
numpy.asarray(
data_x,
dtype=theano.config.floatX
),
borrow=borrow
)
shared_y = theano.shared(
numpy.asarray(
data_y.reshape((len(data_y), 1)),
dtype=theano.config.floatX
),
borrow=borrow
)
# When storing data on the GPU it has to be stored as floats
# therefore we will store the labels as ``floatX`` as well
# (``shared_y`` does exactly that). But during our computations
# we need them as ints (we use labels as index, and if they are
# floats it doesn't make sense) therefore instead of returning
# ``shared_y`` we will have to cast it to int. This little hack
# lets ous get around this issue
return shared_x, shared_y # T.cast(shared_y, 'int32')
test_set_x, test_set_y = shared_dataset(test_set)
valid_set_x, valid_set_y = shared_dataset(valid_set)
train_set_x, train_set_y = shared_dataset(train_set)
rval = [(train_set_x, train_set_y), (valid_set_x, valid_set_y),
(test_set_x, test_set_y)]
return rval
| gdl-civestav-localization/cinvestav_location_fingerprinting | models/regression/deep_models/utils.py | Python | gpl-3.0 | 12,258 | [
"Gaussian"
] | 1a5aee97321f8b96e84fa156d5a53f6a4b06c316128dfa825938255020704e9d |
import numpy as np
from openpathsampling.netcdfplus import StorableObject
# The decorator @restores_ allows us to restore the object from a JSON
# string completely and can thus be stored automatically
class PES(StorableObject):
"""Abstract base class for toy potential energy surfaces.
"""
# For now, we only support additive combinations; maybe someday that can
# include multiplication, too
def __init__(self):
super(PES, self).__init__()
def __add__(self, other):
return PES_Add(self, other)
def __sub__(self, other):
return PES_Sub(self, other)
def kinetic_energy(self, sys):
"""Default kinetic energy implementation.
Parameters
----------
sys : :class:`.ToyEngine`
engine contains its state, including velocities and masses
"""
v = sys.velocities
m = sys.mass
return 0.5*np.dot(m, np.multiply(v, v))
class PES_Combination(PES):
"""Mathematical combination of two potential energy surfaces.
Abstract base class.
Parameters
----------
pes1 : :class:`.PES`
first potential energy surface of the combination
pes2 : :class:`.PES`
second potential energy surface of the combination
fcn : function of two variables
function to combine the PES energies
dfdx_fcn : function of two variables
function to combine the PES (first) derivatives
"""
def __init__(self, pes1, pes2, fcn, dfdx_fcn):
super(PES_Combination, self).__init__()
self.pes1 = pes1
self.pes2 = pes2
self._fcn = fcn
self._dfdx_fcn = dfdx_fcn
def V(self, sys):
"""Potential energy
Parameters
----------
sys : :class:`.ToyEngine`
engine contains its state, including velocities and masses
Returns
-------
float
the potential energy
"""
return self._fcn(self.pes1.V(sys), self.pes2.V(sys))
def dVdx(self, sys):
"""Derivative of potential energy (-force)
Parameters
----------
sys : :class:`.ToyEngine`
engine contains its state, including velocities and masses
Returns
-------
np.array
the derivatives of the potential at this point
"""
return self._dfdx_fcn(self.pes1.dVdx(sys), self.pes2.dVdx(sys))
class PES_Sub(PES_Combination):
"""Difference of two potential energy surfaces; pes1 - pes2
Parameters
----------
pes1 : :class:`.PES`
first potential energy surface of the combination
pes2 : :class:`.PES`
second potential energy surface of the combination
"""
def __init__(self, pes1, pes2):
super(PES_Sub, self).__init__(
pes1,
pes2,
lambda a, b: a - b,
lambda a, b: a - b
)
class PES_Add(PES_Combination):
"""Sum of two potential energy surfaces; pes1 + pes 2
Parameters
----------
pes1 : :class:`.PES`
first potential energy surface of the combination
pes2 : :class:`.PES`
second potential energy surface of the combination
"""
def __init__(self, pes1, pes2):
super(PES_Add, self).__init__(
pes1,
pes2,
lambda a, b: a + b,
lambda a, b: a + b
)
class HarmonicOscillator(PES):
r"""Simple harmonic oscillator. Independent in each degree of freedom.
:math:`V(x) = \sum_i A_i * mass_i * omega_i^2 * (x_i - x0_i)^2`
Parameters
----------
A : list of float
omega : list of float
x0 : list of float
"""
def __init__(self, A, omega, x0):
super(HarmonicOscillator, self).__init__()
self.A = np.array(A)
self.omega = np.array(omega)
self.x0 = np.array(x0)
def __repr__(self): # pragma: no cover
repr_str = "HarmonicOscillator({obj.A}, {obj.omega}, {obj.x0})"
return repr_str.format(obj=self)
def to_dict(self):
dct = super(HarmonicOscillator, self).to_dict()
dct['A'] = dct['A'].tolist()
dct['omega'] = dct['omega'].tolist()
dct['x0'] = dct['x0'].tolist()
return dct
def V(self, sys):
"""Potential energy
Parameters
----------
sys : :class:`.ToyEngine`
engine contains its state, including velocities and masses
Returns
-------
float
the potential energy
"""
dx = sys.positions - self.x0
k = self.omega*self.omega*sys.mass
return 0.5*np.dot(self.A * k, dx * dx)
def dVdx(self, sys):
"""Derivative of potential energy (-force)
Parameters
----------
sys : :class:`.ToyEngine`
engine contains its state, including velocities and masses
Returns
-------
np.array
the derivatives of the potential at this point
"""
dx = sys.positions - self.x0
k = self.omega*self.omega*sys.mass
return self.A*k*dx
class Gaussian(PES):
r"""Gaussian given by: :math:`A*exp(-\sum_i alpha[i]*(x[i]-x0[i])^2)`
Parameters
----------
A : float
amplitude of the Gaussian
alpha : list of float
Gaussian width parameter
x0 : list of float
center of the Gaussian
"""
def __init__(self, A, alpha, x0):
super(Gaussian, self).__init__()
self.A = A
self.alpha = np.array(alpha)
self.x0 = np.array(x0)
self._local_dVdx = np.zeros(self.x0.size)
def to_dict(self):
dct = super(Gaussian, self).to_dict()
dct['alpha'] = dct['alpha'].tolist()
dct['x0'] = dct['x0'].tolist()
return dct
def __repr__(self): # pragma: no cover
return "Gaussian({o.A}, {o.alpha}, {o.x0})".format(o=self)
def V(self, sys):
"""Potential energy
Parameters
----------
sys : :class:`.ToyEngine`
engine contains its state, including velocities and masses
Returns
-------
float
the potential energy
"""
dx = sys.positions - self.x0
return self.A*np.exp(-np.dot(self.alpha, np.multiply(dx, dx)))
def dVdx(self, sys):
"""Derivative of potential energy (-force)
Parameters
----------
sys : :class:`.ToyEngine`
engine contains its state, including velocities and masses
Returns
-------
np.array
the derivatives of the potential at this point
"""
dx = sys.positions - self.x0
exp_part = self.A*np.exp(-np.dot(self.alpha, np.multiply(dx, dx)))
for i in range(len(dx)):
self._local_dVdx[i] = -2*self.alpha[i]*dx[i]*exp_part
return self._local_dVdx
class OuterWalls(PES):
r"""Creates an x**6 barrier around the system.
:math:`V(x) = \sum_i sigma_i * (x_i - x0_i)^6`
Parameters
----------
sigma : list of float
linear scaling of the potential wall
x0 : list of float
center of the potential
"""
def __init__(self, sigma, x0):
super(OuterWalls, self).__init__()
self.sigma = np.array(sigma)
self.x0 = np.array(x0)
self._local_dVdx = np.zeros(self.x0.size)
def to_dict(self):
dct = super(OuterWalls, self).to_dict()
dct['x0'] = dct['x0'].tolist()
dct['sigma'] = dct['sigma'].tolist()
return dct
def __repr__(self): # pragma: no cover
return "OuterWalls({o.sigma}, {o.x0})".format(o=self)
def V(self, sys):
"""Potential energy
Parameters
----------
sys : :class:`.ToyEngine`
engine contains its state, including velocities and masses
Returns
-------
float
the potential energy
"""
dx = sys.positions - self.x0
myV = 0.0
for i in range(len(dx)):
myV += self.sigma[i]*dx[i]**6
return myV
def dVdx(self, sys):
"""Derivative of potential energy (-force)
Parameters
----------
sys : :class:`.ToyEngine`
engine contains its state, including velocities and masses
Returns
-------
np.array
the derivatives of the potential at this point
"""
dx = sys.positions - self.x0
for i in range(len(dx)):
self._local_dVdx[i] = 6.0*self.sigma[i]*dx[i]**5
return self._local_dVdx
class LinearSlope(PES):
r"""Linear potential energy surface. :math:`V(x) = \sum_i m_i * x_i + c`
Parameters
----------
m : list of float
slope
c : float
energy offset
"""
def __init__(self, m, c):
super(LinearSlope, self).__init__()
self.m = m
self.c = c
self._local_dVdx = self.m
self.dim = len(self.m)
def __repr__(self): # pragma: no cover
return "LinearSlope({o.m}, {o.c})".format(o=self)
def V(self, sys):
"""Potential energy
Parameters
----------
sys : :class:`.ToyEngine`
engine contains its state, including velocities and masses
Returns
-------
float
the potential energy
"""
return np.dot(self.m, sys.positions) + self.c
def dVdx(self, sys):
"""Derivative of potential energy (-force)
Parameters
----------
sys : :class:`.ToyEngine`
engine contains its state, including velocities and masses
Returns
-------
np.array
the derivatives of the potential at this point
"""
# this is independent of the position
return self._local_dVdx
| choderalab/openpathsampling | openpathsampling/engines/toy/pes.py | Python | lgpl-2.1 | 9,856 | [
"Gaussian"
] | 8613b261b7a14f3801ee10550b3fc54370356a520d7b825984cec73004a5e15b |
########################################################################
# This program is copyright (c) Upinder S. Bhalla, NCBS, 2015.
# It is licenced under the GPL 2.1 or higher.
# There is no warranty of any kind. You are welcome to make copies under
# the provisions of the GPL.
# This program builds a multiscale model with a few spines inserted into
# a simplified cellular morphology. Each spine has a signaling model in it
# too. The program doesn't run the model, it just displays it in 3D.
########################################################################
try:
import moogli
except Exception as e:
print( "[INFO ] Could not import moogli. Quitting ..." )
quit()
from PyQt4 import Qt, QtCore, QtGui
import numpy
import time
import pylab
import moose
from moose import neuroml
import matplotlib.pyplot as plt
import sys
import os
from moose.neuroml.ChannelML import ChannelML
sys.path.append('/home/bhalla/moose/trunk/Demos/util')
import rdesigneur as rd
PI = 3.14159265359
useGssa = True
combineSegments = False
baselineTime = 1
tetTime = 1
interTetTime = 0.1
postTetTime = 0.1
ltdTime = 0.1
postLtdTime = 0.1
do3D = True
dt = 0.01
plotdt = 0.1
psdTetCa = 8e-3
basalCa = 0.08e-3
ltdCa = 0.25e-3
def buildRdesigneur():
##################################################################
# Here we define which prototypes are to be loaded in to the system.
# Each specification has the format
# source [localName]
# source can be any of
# filename.extension, # Identify type of file by extension, load it.
# function(), # func( name ) builds object of specified name
# file.py:function() , # load Python file, run function(name) in it.
# moose.Classname # Make obj moose.Classname, assign to name.
# path # Already loaded into library or on path.
# After loading the prototypes, there should be an object called 'name'
# in the library.
##################################################################
cellProto = [ ['ca1_minimal.p', 'elec'] ]
spineProto = [ ['makeSpineProto()', 'spine' ]]
chemProto = [ ['CaMKII_merged77.g', 'chem'] ]
##################################################################
# Here we define what goes where, and any parameters. Each distribution
# has the format
# protoName, path, field, expr, [field, expr]...
# where
# protoName identifies the prototype to be placed on the cell
# path is a MOOSE wildcard path specifying where to put things
# field is the field to assign.
# expr is a math expression to define field value. This uses the
# muParser. Built-in variables are p, g, L, len, dia.
# The muParser provides most math functions, and the Heaviside
# function H(x) = 1 for x > 0 is also provided.
##################################################################
chemRange = "H(1.1e-6 - dia) * H(p - 1300e-6)"
spineDistrib = [ \
["spine", '#apical#', \
"spineSpacing", chemRange + " * 5e-6", \
"spineSpacingDistrib", "1e-6", \
"angle", "0", \
"angleDistrib", "6.28", \
"size", "6", \
"sizeDistrib", "0" ] \
]
chemDistrib = [ \
[ "chem", "#apical#", "install", chemRange ]
]
######################################################################
# Here we define the mappings across scales. Format:
# sourceObj sourceField destObj destField couplingExpr [wildcard][spatialExpn]
# where the coupling expression is anything a muParser can evaluate,
# using the input variable x. For example: 8e-5 + 300*x
# For now, let's use existing adaptors which take an offset and scale.
######################################################################
adaptorList = [
[ 'Ca_conc', 'Ca', 'psd/Ca_input', 'concInit', 8e-5, 1 ],
[ 'Ca_conc', 'Ca', 'dend/DEND/Ca_input', 'concInit', 8e-5, 1 ],
[ 'psd/tot_PSD_R', 'n', 'glu', 'Gbar', 0, 0.01 ],
]
######################################################################
# Having defined everything, now to create the rdesigneur and proceed
# with creating the model.
######################################################################
rdes = rd.rdesigneur(
useGssa = useGssa, \
combineSegments = combineSegments, \
stealCellFromLibrary = True, \
spineDistrib = spineDistrib, \
chemDistrib = chemDistrib, \
cellProto = cellProto, \
spineProto = spineProto, \
chemProto = chemProto
)
return rdes
def createVmViewer(rdes):
network = moogli.extensions.moose.read(rdes.elecid.path)
normalizer = moogli.utilities.normalizer(-0.08,
0.02,
clipleft=True,
clipright=True)
colormap = moogli.colors.UniformColorMap([moogli.colors.Color(0.0,
0.5,
1.0,
1.0),
moogli.colors.Color(1.0,
0.0,
0.0,
0.9)])
mapper = moogli.utilities.mapper(colormap, normalizer)
def prelude(view):
vms = [moose.element(x).Vm for x in list(network.shapes.keys())]
network.set("color", vms, mapper)
view.pitch(PI/2.0)
view.down(450)
view.left(100)
view.h = 2.0
view.zoom(5.0)
def interlude(view):
if view.h > 0.10:
view.h /= 1.005
view.zoom(0.005)
view.yaw(0.01)
viewer = moogli.Viewer("vm-viewer")
viewer.attach_shapes(list(network.shapes.values()))
view = moogli.View("vm-view",
prelude=prelude,
interlude=interlude)
viewer.attach_view(view)
return viewer
def main():
numpy.random.seed( 1234 )
rdes = buildRdesigneur()
rdes.buildModel( '/model' )
assert( moose.exists( '/model' ) )
moose.element( '/model/elec/hsolve' ).tick = -1
for i in range( 10, 18 ):
moose.setClock( i, dt )
moose.setClock( 18, plotdt )
moose.reinit()
if do3D:
app = QtGui.QApplication(sys.argv)
compts = moose.wildcardFind( "/model/elec/#[ISA=CompartmentBase]" )
print(("LEN = ", len( compts )))
for i in compts:
n = i.name[:4]
if ( n == 'head' or n == 'shaf' ):
i.diameter *= 1.0
i.Vm = 0.02
else:
i.diameter *= 4.0
i.Vm = -0.05
vm_viewer = createVmViewer(rdes)
vm_viewer.showMaximized()
vm_viewer.start()
app.exec_()
if __name__ == '__main__':
main()
| BhallaLab/moose-examples | paper-2015/Fig4_ReacDiff/Fig4B.py | Python | gpl-2.0 | 7,167 | [
"MOOSE"
] | a2b886a2ddddc4643ae62488c5dc2971063d5030cccd017c5300877908cc2a86 |
#!/usr/bin/env python
#
# This code is part of the binding affinity prediction tools distribution
# and governed by its license. Please see the LICENSE file that should
# have been included as part of this package.
#
"""
Functions to read PDB/mmCIF files
"""
from __future__ import print_function, division
import os
import sys
import logging
try:
from Bio.PDB import PDBParser, MMCIFParser
from Bio.PDB.Polypeptide import PPBuilder, is_aa
except ImportError as e:
print('[!] The binding affinity prediction tools require Biopython', file=sys.stderr)
raise ImportError(e)
def validate_structure(s, selection=None, clean=True):
# setup logging
logger = logging.getLogger('Prodigy')
# Keep first model only
if len(s) > 1:
logger.warning('[!] Structure contains more than one model. Only the first one will be kept')
model_one = s[0].id
for m in s.child_list[:]:
if m.id != model_one:
s.detach_child(m.id)
# process selected chains
chains = list(s.get_chains())
chain_ids = set([c.id for c in chains])
if selection:
sel_chains = []
# Match selected chain with structure
for sel in selection:
for c in sel.split(','):
sel_chains.append(c)
if c not in chain_ids:
raise ValueError('Selected chain not present in provided structure: {0}'.format(c))
# Remove unselected chains
_ignore = lambda x: x.id not in sel_chains
for c in chains:
if _ignore(c):
c.parent.detach_child(c.id)
# Double occupancy check
for atom in list(s.get_atoms()):
if atom.is_disordered():
residue = atom.parent
sel_at = atom.selected_child
sel_at.altloc = ' '
sel_at.disordered_flag = 0
residue.detach_child(atom.id)
residue.add(sel_at)
if clean:
# Remove HETATMs and solvent
res_list = list(s.get_residues())
_ignore = lambda r: r.id[0][0] == 'W' or r.id[0][0] == 'H'
for res in res_list:
if _ignore(res):
chain = res.parent
chain.detach_child(res.id)
elif not is_aa(res, standard=True):
raise ValueError('Unsupported non-standard amino acid found: {0}'.format(res.resname))
# Remove Hydrogens
atom_list = list(s.get_atoms())
_ignore = lambda x: x.element == 'H'
for atom in atom_list:
if _ignore(atom):
residue = atom.parent
residue.detach_child(atom.name)
# Detect gaps and compare with no. of chains
pep_builder = PPBuilder()
peptides = pep_builder.build_peptides(s)
n_peptides = len(peptides)
if n_peptides != len(chain_ids):
message = '[!] Structure contains gaps:\n'
for i_pp, pp in enumerate(peptides):
message += '\t{1.parent.id} {1.resname}{1.id[1]} < Fragment {0} > ' \
'{2.parent.id} {2.resname}{2.id[1]}\n'.format(i_pp, pp[0], pp[-1])
logger.warning(message)
# raise Exception(message)
return s
def parse_structure(path):
"""
Parses a structure using Biopython's PDB/mmCIF Parser
Verifies the integrity of the structure (gaps) and its
suitability for the calculation (is it a complex?).
"""
# setup logging
logger = logging.getLogger('Prodigy')
logger.info('[+] Reading structure file: {0}'.format(path))
fname = os.path.basename(path)
sname = '.'.join(fname.split('.')[:-1])
s_ext = fname.split('.')[-1]
_ext = {'pdb', 'ent', 'cif'}
if s_ext not in _ext:
raise IOError('[!] Structure format \'{0}\' is not supported. Use \'.pdb\' or \'.cif\'.'.format(s_ext))
sparser = PDBParser(QUIET=1) if s_ext in {'pdb', 'ent'} else MMCIFParser()
try:
s = sparser.get_structure(sname, path)
except Exception as exeption:
logger.error('[!] Structure \'{0}\' could not be parsed'.format(sname), file=sys.stderr)
raise Exception(exeption)
return (validate_structure(s),
len(set([c.id for c in s.get_chains()])),
len(list(s.get_residues())))
| haddocking/binding_affinity | lib/parsers.py | Python | apache-2.0 | 4,255 | [
"Biopython"
] | b22f90cc88a07c53e5db8c182a39702fd392dcc3d52335a21595ddedc24dc05e |
#
# Copyright (C) 2013-2019 The ESPResSo project
#
# This file is part of ESPResSo.
#
# ESPResSo is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# ESPResSo is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
"""
Set up a linear polymer.
"""
import espressomd
espressomd.assert_features(["WCA"])
from espressomd import interactions
from espressomd import polymer
from espressomd.io.writer import vtf # pylint: disable=import-error
import numpy as np
# System parameters
#############################################################
system = espressomd.System(box_l=[100, 100, 100])
np.random.seed(seed=42)
system.time_step = 0.01
system.cell_system.skin = 0.4
system.cell_system.set_n_square(use_verlet_lists=False)
outfile = open('polymer.vtf', 'w')
system.non_bonded_inter[0, 0].wca.set_params(epsilon=1, sigma=1)
fene = interactions.FeneBond(k=10, d_r_max=2)
system.bonded_inter.add(fene)
positions = polymer.linear_polymer_positions(n_polymers=1,
beads_per_chain=50,
bond_length=1.0,
seed=3210)
previous_part = None
for pos in positions[0]:
part = system.part.add(pos=pos)
if previous_part:
part.add_bond((fene, previous_part))
previous_part = part
vtf.writevsf(system, outfile)
#############################################################
# Warmup #
#############################################################
# minimize energy using min_dist as the convergence criterion
system.integrator.set_steepest_descent(f_max=0, gamma=1e-3,
max_displacement=0.01)
while system.analysis.min_dist() < 0.95:
print("minimization: {:+.2e}".format(system.analysis.energy()["total"]))
system.integrator.run(20)
print("minimization: {:+.2e}".format(system.analysis.energy()["total"]))
print()
system.integrator.set_vv()
# activate thermostat
system.thermostat.set_langevin(kT=1.0, gamma=1.0, seed=42)
#############################################################
# Integration #
#############################################################
print("simulating...")
t_steps = 1000
for t in range(t_steps):
print("step {} of {}".format(t, t_steps), end='\r', flush=True)
system.integrator.run(10)
vtf.writevcf(system, outfile)
outfile.close()
print()
| fweik/espresso | samples/minimal-polymer.py | Python | gpl-3.0 | 2,972 | [
"ESPResSo"
] | fbb5c3d107a4bba612b8f3eb54c37a65fa18fb9bb1d4e87129294292dacfe276 |
import numpy as np
import pandas as pd
# from matplotlib.pyplot import plot,show,draw
import scipy.io
import sys
sys.path.append("../")
from functions import *
from pylab import *
from sklearn.decomposition import PCA
import _pickle as cPickle
import matplotlib.cm as cm
import os
###############################################################################################################
# TO LOAD
###############################################################################################################
count_nucl = pd.DataFrame(columns = ['12', '17','20', '32'])
for m in ['12', '17','20', '32']:
subspace = pd.read_hdf("../../figures/figures_articles/figure1/subspace_Mouse"+m+".hdf5")
nucleus = np.unique(subspace['nucleus'])
total = [np.sum(subspace['nucleus'] == n) for n in nucleus]
count_nucl[m] = pd.Series(index = nucleus, data = total)
nucleus = list(count_nucl.dropna().index.values)
nucleus.remove('sm')
mappings = pd.read_hdf("/mnt/DataGuillaume/MergedData/MAPPING_NUCLEUS.h5")
lambdaa = pd.read_hdf("/mnt/DataGuillaume/MergedData/LAMBDA_AUTOCORR.h5")
# nucleus = np.unique(mappings['nucleus'])
lambdaa_nucleus = pd.DataFrame( index = nucleus,
columns = pd.MultiIndex.from_product([['wak', 'rem', 'sws'], ['mean', 'sem']],
names = ['episode', 'mean-sem']))
for n in nucleus:
tmp = lambdaa.loc[mappings.index[mappings['nucleus'] == n]].dropna()
tmp = tmp.xs(('b'), 1, 1)
tmp = tmp[((tmp>0.0).all(1) & (tmp<3.0).all(1))]
for e in ['wak', 'rem', 'sws']:
lambdaa_nucleus.loc[n,(e,'mean')] = tmp[e].mean(skipna=True)
lambdaa_nucleus.loc[n,(e,'sem')] = tmp[e].sem(skipna=True)
data_directory = '/mnt/DataGuillaume/MergedData/'
datasets = np.loadtxt(data_directory+'datasets_ThalHpc.list', delimiter = '\n', dtype = str, comments = '#')
theta_mod, theta_ses = loadThetaMod('/mnt/DataGuillaume/MergedData/THETA_THAL_mod.pickle', datasets, return_index=True)
theta = pd.DataFrame( index = theta_ses['rem'],
columns = ['phase', 'pvalue', 'kappa'],
data = theta_mod['rem'])
###############################################################################################################
# PLOT
###############################################################################################################
def figsize(scale):
fig_width_pt = 483.69687 # Get this from LaTeX using \the\textwidth
inches_per_pt = 1.0/72.27 # Convert pt to inch
golden_mean = (np.sqrt(5.0)-1.0)/2.0 # Aesthetic ratio (you could change this)
fig_width = fig_width_pt*inches_per_pt*scale # width in inches
fig_height = fig_width*golden_mean*0.5 # height in inches
fig_size = [fig_width,fig_height]
return fig_size
def simpleaxis(ax):
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.get_xaxis().tick_bottom()
ax.get_yaxis().tick_left()
# ax.xaxis.set_tick_params(size=6)
# ax.yaxis.set_tick_params(size=6)
def noaxis(ax):
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.spines['left'].set_visible(False)
ax.spines['bottom'].set_visible(False)
ax.get_xaxis().tick_bottom()
ax.get_yaxis().tick_left()
ax.set_xticks([])
ax.set_yticks([])
# ax.xaxis.set_tick_params(size=6)
# ax.yaxis.set_tick_params(size=6)
import matplotlib as mpl
from mpl_toolkits.axes_grid1 import make_axes_locatable
# mpl.use("pdf")
pdf_with_latex = { # setup matplotlib to use latex for output
"pgf.texsystem": "pdflatex", # change this if using xetex or lautex
# "text.usetex": True, # use LaTeX to write all text
# "font.family": "serif",
"font.serif": [], # blank entries should cause plots to inherit fonts from the document
"font.sans-serif": [],
"font.monospace": [],
"axes.labelsize": 8, # LaTeX default is 10pt font.
"font.size": 7,
"legend.fontsize": 7, # Make the legend/label fonts a little smaller
"xtick.labelsize": 7,
"ytick.labelsize": 7,
"pgf.preamble": [
r"\usepackage[utf8x]{inputenc}", # use utf8 fonts becasue your computer can handle it :)
r"\usepackage[T1]{fontenc}", # plots will be generated using this preamble
],
"lines.markeredgewidth" : 0.2,
"axes.linewidth" : 0.8,
"ytick.major.size" : 1.5,
"xtick.major.size" : 1.5
}
mpl.rcParams.update(pdf_with_latex)
import matplotlib.gridspec as gridspec
from matplotlib.pyplot import *
from mpl_toolkits.axes_grid.inset_locator import inset_axes
fig = figure(figsize = figsize(1))
ax1 = subplot(211)
# outer = gridspec.GridSpec(3,3, wspace = 0.4, hspace = 0.5)#, height_ratios = [1,3])#, width_ratios = [1.6,0.7])
# gs = gridspec.GridSpec(2,3, wspace = 0.35, hspace = 0.35)#, wspace = 0.4, hspace = 0.4)
# gs = gridspec.GridSpecFromSubplotSpec(1,1, subplot_spec = outer[0])
# gs = gridspec.GridSpecFromSubplotSpec(3, 4, subplot_spec = ax1)
colors = ['firebrick', 'navy', 'darkgreen']
###################################################################################################
# A. AUTOCORRELOGRAM EXEMPLE
###################################################################################################
autocorr = pd.HDFStore("/mnt/DataGuillaume/MergedData/AUTOCORR_LONG.h5")
axA = subplot(1,3,1)
simpleaxis(axA)
def func(x, a, b, c):
return a*np.exp(-(1./b)*x) + c
labels = ['AD (HD)', 'AM', 'IAD']
# colors = ['green', 'blue', 'red']
hd = 'Mouse12-120807_28'
iad = 'Mouse12-120817_52'
nhd = 'Mouse12-120819_3'
###########
index = mappings[np.logical_and(mappings['hd'] == 1, mappings['nucleus'] == 'AD')].index.values
best = (lambdaa.loc[index,('wak','b')] - lambdaa_nucleus.loc['AD', ('wak', 'mean')]).dropna().abs().sort_values().index.values
hd = best[0]
index = mappings[np.logical_and(mappings['hd'] == 0, mappings['nucleus'] == 'AVd')].index.values
best = (lambdaa.loc[index,('wak','b')] - lambdaa_nucleus.loc['AVd', ('wak', 'mean')]).dropna().abs().sort_values().index.values
nhd = best[0]
index = mappings[np.logical_and(mappings['hd'] == 0, mappings['nucleus'] == 'IAD')].index.values
best = (lambdaa.loc[index,('wak','b')] - lambdaa_nucleus.loc['IAD', ('wak', 'mean')]).dropna().abs().sort_values().index.values
iad = best[0]
for i, n in enumerate([hd, nhd, iad]):
tmp = autocorr['wak'][n].copy()
tmp.loc[0] = 0.0
tmp = tmp.loc[tmp.loc[0.1:25.0].argmax():]
tmp2 = tmp.rolling(window = 100, win_type='gaussian', center=True, min_periods=1).mean(std=5.0)
tmp3 = tmp2 - tmp2.min()
tmp3 = tmp3 / tmp3.max()
tmp3 = tmp3.loc[:2500]
plot(tmp3.index.values*1e-3, tmp3.values, label = labels[i], color = colors[i])
x = tmp3.index.values*1e-3
y = func(x, *lambdaa.loc[n, 'wak'].values)
if i == 2:
plot(x, y, '--', color = 'grey', label = "Exp. fit \n " r"$y = a \ exp(-t/\tau)$")
else:
plot(x, y, '--', color = 'grey')
# show()
legend(edgecolor = None, facecolor = None, frameon = False, bbox_to_anchor=(0.3, 1.1), bbox_transform=axA.transAxes)
xlabel("Time lag (s)")
ylabel("Autocorrelation (a.u)")
locator_params(nbins = 4)
axA.text(-0.1, 1.05, "A", transform = axA.transAxes, fontsize = 9)
###################################################################################################
# B. LAMBDA AUTOCORRELOGRAM / NUCLEUS
###################################################################################################
axB = subplot(1,3,2)
simpleaxis(axB)
order = lambdaa_nucleus[('wak', 'mean')].sort_values().index
labels = ['Wake', 'REM']
for i, ep in enumerate(['wak', 'rem']):
m = lambdaa_nucleus.loc[order,(ep,'mean')].values.astype('float32')
s = lambdaa_nucleus.loc[order,(ep,'sem')].values.astype('float32')
plot(m, np.arange(len(order)), 'o-', color = colors[i], label = labels[i], markersize = 3, linewidth = 1)
fill_betweenx(np.arange(len(order)), m+s, m-s, color = colors[i], alpha = 0.3)
legend(edgecolor = None, facecolor = None, frameon = False)
yticks(np.arange(len(order)), order)
ylabel("Nuclei")
xlabel(r"Decay time $\tau$ (s)")
locator_params(axis = 'x', nbins = 4)
axB.text(-0.1, 1.05, "B", transform = axB.transAxes, fontsize = 9)
###################################################################################################
# C. BURSTINESS VS LAMBDA
###################################################################################################
axC = subplot(1, 3,3)
simpleaxis(axC)
# firing_rate = pd.read_hdf("/mnt/DataGuillaume/MergedData/FIRING_RATE_ALL.h5")
# fr_index = firing_rate.index.values[((firing_rate[['wake', 'rem']] > 1.0).sum(1) == 2).values]
from scipy.stats import pearsonr
burst = pd.HDFStore("/mnt/DataGuillaume/MergedData/BURSTINESS.h5")['w']
idx = lambdaa['rem']['b'].index
# correlation during wake
df = pd.concat([burst['sws'].loc[idx], lambdaa['wak']['b'].loc[idx]], axis = 1).rename(columns={'sws':'burst','b':'lambda'})
df = df[np.logical_and(df['burst']<25,df['lambda']<3)]
a, b = pearsonr(df['burst'].values, df['lambda'].values)
print('wake', a, b)
# correlation during rem
df2 = pd.concat([burst['sws'].loc[idx], lambdaa['rem']['b'].loc[idx]], axis = 1).rename(columns={'sws':'burst','b':'lambda'})
df2 = df2[np.logical_and(df2['burst']<25,df2['lambda']<3)]
df2 = df2[df2['lambda'] > 0.0]
c, d = pearsonr(df2['burst'].values, df2['lambda'].values)
print('rem', c, d)
scatter(df2['burst'].values, df2['lambda'].values, 4, color = 'black', alpha = 1.0, edgecolors = 'none')
xlabel("NREM burst index")
ylabel(r"REM decay time $\tau$ (s)")
yticks([0,1,2,3],['0','1','2','3'])
axC.text(0.5, 1.0, "r="+str(np.round(c, 3))+" (p<0.001)", transform = axC.transAxes, fontsize = 6)
axC.text(-0.1, 1.05, "C", transform = axC.transAxes, fontsize = 9)
###################################################################################################
# C. BURSTINESS VS LAMBDA
###################################################################################################
df = pd.concat([theta['kappa'].loc[idx], lambdaa['rem']['b'].loc[idx]], axis = 1).rename(columns={'b':'lambda'})
df = df[np.logical_and(df['kappa']<1,df['lambda']<3)]
df = df[df['lambda'] > 0]
####################################################################################
# ANOVAS
####################################################################################
import scipy.stats as stats
neurons = [n for n in lambdaa.index.values if mappings.loc[n,'nucleus'] in nucleus]
# 1 tau vs nucleus
# group1 = mappings.loc[neurons].groupby('nucleus').groups
# F1 = stats.f_oneway(*[lambdaa.loc[group1[n]].xs(('b'),1,1)[['wak', 'rem']].values.flatten() for n in nucleus])
# # 2 tau vs brain-states
# group2 = { 'wak':lambdaa.loc[neurons,('wak','b')].values,
# 'rem':lambdaa.loc[neurons,('rem','b')].values}
# F2 = stats.f_oneway(*[group2[k] for k in group2.keys()])
# # 3 tau vs animal
# group3 = {m:np.hstack([lambdaa.loc[n,[('wak','b'), ('rem','b')]].values for n in neurons if m in n]) for m in ['Mouse12', 'Mouse17','Mouse20','Mouse32']}
# F3 = stats.f_oneway(*[group3[k] for k in group3.keys()])
anova = pd.DataFrame(columns = ['episode', 'nucleus', 'tau'])
tmp1 = pd.DataFrame(columns = ['episode', 'nucleus', 'tau'])
tmp1['nucleus'] = mappings.loc[idx,'nucleus']
tmp1['episode'] = 'wake'
tmp1['tau'] = lambdaa.loc[idx,('wak', 'b')]
tmp2 = pd.DataFrame(columns = ['episode', 'nucleus', 'tau'])
tmp2['nucleus'] = mappings.loc[idx,'nucleus']
tmp2['episode'] = 'rem'
tmp2['tau'] = lambdaa.loc[idx,('rem', 'b')]
anova = pd.concat([tmp1,tmp2], axis = 0)
# tmp = pd.concat([lambdaa_nucleus[('wak', 'mean')], lambdaa_nucleus[('rem', 'mean')]])
# anova['nucleus'] = tmp.index.values
# anova['tau'] = tmp.values
# anova['episode'] = ['wak']*len(lambdaa_nucleus) + ['rem']*len(lambdaa_nucleus)
fig.subplots_adjust(wspace= 0.4, hspace = 0.6)
savefig("../../figures/figures_articles/figart_2.pdf", dpi = 900, bbox_inches = 'tight', facecolor = 'white')
os.system("evince ../../figures/figures_articles/figart_2.pdf &")
| gviejo/ThalamusPhysio | python/figure_article/main_article_fig_2.py | Python | gpl-3.0 | 11,952 | [
"Gaussian"
] | 2c306c2bd1a32f7cf087c17d864859885fd4da97967c0d078549aea35db41a26 |
"""
[2016-01-06] Challenge #248 [Intermediate] A Measure of Edginess
https://www.reddit.com/r/dailyprogrammer/comments/3zqiiq/20160106_challenge_248_intermediate_a_measure_of/
Want to write a program that actually understands images it sees?
One of the mainstays of the computer vision toolkit is *[edge
detection](https://en.wikipedia.org/wiki/Edge_detection)* -- a series
of different approaches to find places where color/brightness in an
image changes abruptly. It is a process that takes a regular image as
input, and returns an image that highlights locations at which "edges"
exist.
On Monday we [took a
look](https://www.reddit.com/r/dailyprogrammer/comments/3zfajl/20160104_challenge_248_easy_draw_me_like_one_of/)
at how the Netpbm image format works, and built a very simple drawing
program using PPM images. Let's use the same format (as it is very
simple to read/write without any special libraries) to handle this
challenge.
# Formal Input
The input to your program is an image in PPM format. Because edge
detection requires images that are larger than can be comfortably
typed or copy/pasted, you may want to input this from a file.
**Sample input:** [PNG
version](https://github.com/fsufitch/dailyprogrammer/raw/master/ideas/edgedetect/valve_original.png),
[PPM (P3, RGB color)
version](https://github.com/fsufitch/dailyprogrammer/raw/master/ideas/edgedetect/valve_original.ppm)
(3.1 MB). Image courtesy of
[Wikipedia](https://en.wikipedia.org/wiki/Sobel_operator#/media/File:Valve_original_\(1\).PNG).
# Formal Output
The output must be a ~~black and white~~ *grayscale* (edited for clarification) image of the same size as the
input. Edges from the input image must be highlighted in white.
This is not a strict "right or wrong answer" challenge. There are many
ways to do edge detection, and they each may yield a different
result. As such, expect outputs to vary. In general though, try to aim
for crisp (thin) edges, with little noise from non-edges.
**Sample output:**
[Converted to PNG](https://raw.githubusercontent.com/fsufitch/dailyprogrammer/master/ideas/edgedetect/valve_sobel.png).
This
is the sample output that Wikipedia gives for the application of a
Sobel filter -- one of the most basic forms of edge detection.
# Challenge Inputs
- Taters:
[JPG](https://github.com/fsufitch/dailyprogrammer/raw/master/ideas/edgedetect/potatoes.jpg),
[PPM](https://github.com/fsufitch/dailyprogrammer/raw/master/ideas/edgedetect/potatoes.ppm)
- Utah teapot:
[JPG](https://github.com/fsufitch/dailyprogrammer/raw/master/ideas/edgedetect/utah_teapot.jpg),
[PPM](https://github.com/fsufitch/dailyprogrammer/raw/master/ideas/edgedetect/utah_teapot.ppm)
- Advice dog:
[JPG](https://github.com/fsufitch/dailyprogrammer/raw/master/ideas/edgedetect/advice_dog.jpg),
[PPM](https://github.com/fsufitch/dailyprogrammer/raw/master/ideas/edgedetect/advice_dog.ppm)
# Hints / guidance
*If you prefer to figure it out / research it yourself, do not read
this section*.
While the Wikipedia article on edge detection has plenty of details
about how to approach it, it is a bit overwhelming for the purpose of
a daily challenge. As such, here's a quick overview of how one of the
simpler edge detection approaches, the **Sobel operator**:
The Sobel operator focuses on finding edges based on the
"brightness" of the image, requiring each pixel in the image to have a
"brightness" value. In other words, it requires a grayscale, not color
image. The first step, then, is to convert the input (RGB color) image to
grayscale -- perhaps by averaging the red, green, and blue values.
Next, we can actually apply the Sobel transformation. That involves
iterating through each pixel and figuring out how "edgy" it is. This
is done by looking at the pixels around it. Suppose our current pixel
is `X` in the table below, while its surrounding pixels are `a` to `h`.
a b c
d X e
f g h
Since at this point each of these values are integers, we can just do
some simple arithmetic to figure out how much this selection of 9
pixels is changing horizontally. We'll just subtract the rightmost
three pixels from the leftmost ones (and give the central ones, `d`
and `e` a bit more weight since they're closer and more relevant to
how edgy `X` is).
Edge_horizontal = E_h = (c + 2*e + h) - (a + 2*d + f)
Similarly, we can calculate the edginess in a vertical direction.
Edge_vertical = E_v = (f + 2*g + h) - (a + 2*b + c)
If we imagine these horizontal and vertical edges as the sides of a
right triangle, we can calculate the overall edginess (and thus, the
value of `X`) by using the Pythagorean theorem.
X = sqrt((E_h * E_h) + (E_v * E_v))
That's it. When we apply this calculation for every pixel in the
image, the outcome will be something like the problem's sample
output. We can then print out the PPM image using the same value for
red, green, and blue, giving us the grayscale output we want.
# Finally...
**Have any cool ideas for challenges?** Come post them over in
/r/dailyprogrammer_ideas!
**Got feedback?** We (the mods) would like to know how we're doing!
Are the problems too easy? Too hard? Just right? Boring/exciting?
Varied/same? Anything you would like to see us do that we're not
doing? Anything we're doing that we should just stop? Come by this
[feedback thread](https://redd.it/3zgexx) and let us know!
"""
def main():
pass
if __name__ == "__main__":
main()
| DayGitH/Python-Challenges | DailyProgrammer/DP20160106B.py | Python | mit | 5,425 | [
"exciting"
] | 3fad427ba8ab38b9ca02f7ff6300165077d0b3e582b9f7057f1038673bfb4a75 |
import ase
from ase.calculators.lj import LennardJones
from ase.constraints import FixBondLength
from ase.optimize import FIRE
for wrap in [False, True]:
a = ase.Atoms('CCC',
positions=[[1, 0, 5],
[0, 1, 5],
[-1, 0.5, 5]],
cell=[10, 10, 10],
pbc=True)
if wrap:
a.set_scaled_positions(a.get_scaled_positions() % 1.0)
a.set_calculator(LennardJones())
a.set_constraint(FixBondLength(0, 2))
d1 = a.get_distance(0, 2, mic=True)
FIRE(a, logfile=None).run(fmax=0.01)
e = a.get_potential_energy()
d2 = a.get_distance(0, 2, mic=True)
assert abs(e - -2.034988) < 1e-6
assert abs(d1 - d2) < 1e-6
| suttond/MODOI | ase/test/fix_bond_length_mic.py | Python | lgpl-3.0 | 753 | [
"ASE"
] | 10950dbaeef55b1cf662d9afa5405879f2305757e0d5ded7f4f2851db89b62f0 |
"""
Calculate spectroscopy limited maximum efficiency (SLME) given dielectric function data
Forked and adjusted from :
https://github.com/usnistgov/jarvis
References: 1) https://doi.org/10.1021/acs.chemmater.9b02166 &
2) http://dx.doi.org/10.1103/PhysRevLett.108.068701
"""
import os
from math import pi
import matplotlib.pyplot as plt
import numpy as np
import scipy.constants as constants
from scipy.constants import physical_constants, speed_of_light
from scipy.integrate import simps
from scipy.interpolate import interp1d
from pymatgen.io.vasp.outputs import Vasprun
eV_to_recip_cm = 1.0 / (physical_constants["Planck constant in eV s"][0] * speed_of_light * 1e2)
def get_dir_indir_gap(run=""):
"""
Get direct and indirect bandgaps for a vasprun.xml
"""
v = Vasprun(run)
bandstructure = v.get_band_structure()
dir_gap = bandstructure.get_direct_band_gap()
indir_gap = bandstructure.get_band_gap()["energy"]
return dir_gap, indir_gap
def matrix_eigvals(matrix):
"""
Calculate the eigenvalues of a matrix.
Args:
matrix (np.array): The matrix to diagonalise.
Returns:
(np.array): Array of the matrix eigenvalues.
"""
eigvals, eigvecs = np.linalg.eig(matrix)
return eigvals
def to_matrix(xx, yy, zz, xy, yz, xz):
"""
Convert a list of matrix components to a symmetric 3x3 matrix.
Inputs should be in the order xx, yy, zz, xy, yz, xz.
Args:
xx (float): xx component of the matrix.
yy (float): yy component of the matrix.
zz (float): zz component of the matrix.
xy (float): xy component of the matrix.
yz (float): yz component of the matrix.
xz (float): xz component of the matrix.
Returns:
(np.array): The matrix, as a 3x3 numpy array.
"""
matrix = np.array([[xx, xy, xz], [xy, yy, yz], [xz, yz, zz]])
return matrix
def parse_dielectric_data(data):
"""
Convert a set of 2D vasprun formatted dielectric data to
the eigenvalues of each corresponding 3x3 symmetric numpy matrices.
Args:
data (list): length N list of dielectric data. Each entry should be
a list of ``[xx, yy, zz, xy, xz, yz ]`` dielectric
tensor elements.
Returns:
(np.array): a Nx3 numpy array. Each row contains the eigenvalues
for the corresponding row in `data`.
"""
return np.array([matrix_eigvals(to_matrix(*e)) for e in data])
def absorption_coefficient(dielectric):
"""
Calculate the optical absorption coefficient from an input set of
pymatgen vasprun dielectric constant data.
Args:
dielectric (list): A list containing the dielectric response function
in the pymatgen vasprun format.
| element 0: list of energies
| element 1: real dielectric tensors, in ``[xx, yy, zz, xy, xz, yz]`` format.
| element 2: imaginary dielectric tensors, in ``[xx, yy, zz, xy, xz, yz]`` format.
Returns:
(np.array): absorption coefficient using eV as frequency units (cm^-1).
"""
energies_in_eV = np.array(dielectric[0])
real_dielectric = parse_dielectric_data(dielectric[1])
imag_dielectric = parse_dielectric_data(dielectric[2])
epsilon_1 = np.mean(real_dielectric, axis=1)
epsilon_2 = np.mean(imag_dielectric, axis=1)
return (
energies_in_eV,
(
2.0
* np.sqrt(2.0)
* pi
* eV_to_recip_cm
* energies_in_eV
* np.sqrt(-epsilon_1 + np.sqrt(epsilon_1 ** 2 + epsilon_2 ** 2))
),
)
def optics(path=""):
"""
Helper function to calculate optical absorption coefficient
"""
dirgap, indirgap = get_dir_indir_gap(path)
run = Vasprun(path, occu_tol=1e-2)
new_en, new_abs = absorption_coefficient(run.dielectric)
return (
np.array(new_en, dtype=np.float64),
np.array(new_abs, dtype=np.float64),
dirgap,
indirgap,
)
def slme(
material_energy_for_absorbance_data,
material_absorbance_data,
material_direct_allowed_gap,
material_indirect_gap,
thickness=50e-6,
temperature=293.15,
absorbance_in_inverse_centimeters=False,
cut_off_absorbance_below_direct_allowed_gap=True,
plot_current_voltage=False,
):
"""
Calculate the SLME
Args:
material_energy_for_absorbance_data: energy grid for absorbance data
material_absorbance_data: absorption coefficient in m^-1
material_direct_allowed_gap: direct bandgap in eV
material_indirect_gap: indirect bandgap in eV
thickness: thickness of the material in m
temperature: working temperature in K
absorbance_in_inverse_centimeters: whether the absorbance data is in the unit of cm^-1
cut_off_absorbance_below_direct_allowed_gap: whether to discard all absorption below bandgap
plot_current_voltage: whether to plot the current-voltage curve
Returns:
The calculated maximum efficiency.
"""
# Defining constants for tidy equations
c = constants.c # speed of light, m/s
h = constants.h # Planck's constant J*s (W)
h_e = constants.h / constants.e # Planck's constant eV*s
k = constants.k # Boltzmann's constant J/K
k_e = constants.k / constants.e # Boltzmann's constant eV/K
e = constants.e # Coulomb
# Make sure the absorption coefficient has the right units (m^{-1})
if absorbance_in_inverse_centimeters:
material_absorbance_data = material_absorbance_data * 100
# Load the Air Mass 1.5 Global tilt solar spectrum
solar_spectrum_data_file = str(os.path.join(os.path.dirname(__file__), "am1.5G.dat"))
solar_spectra_wavelength, solar_spectra_irradiance = np.loadtxt(
solar_spectrum_data_file, usecols=[0, 1], unpack=True, skiprows=2
)
solar_spectra_wavelength_meters = solar_spectra_wavelength * 1e-9
delta = material_direct_allowed_gap - material_indirect_gap
fr = np.exp(-delta / (k_e * temperature))
# need to convert solar irradiance from Power/m**2(nm) into
# photon#/s*m**2(nm) power is Watt, which is Joule / s
# E = hc/wavelength
# at each wavelength, Power * (wavelength(m)/(h(Js)*c(m/s))) = ph#/s
solar_spectra_photon_flux = solar_spectra_irradiance * (solar_spectra_wavelength_meters / (h * c))
# Calculation of total solar power incoming
power_in = simps(solar_spectra_irradiance, solar_spectra_wavelength)
# calculation of blackbody irradiance spectra
# units of W/(m**3), different than solar_spectra_irradiance!!! (This
# is intentional, it is for convenience)
blackbody_irradiance = (2.0 * h * c ** 2 / (solar_spectra_wavelength_meters ** 5)) * (
1.0 / ((np.exp(h * c / (solar_spectra_wavelength_meters * k * temperature))) - 1.0)
)
# now to convert the irradiance from Power/m**2(m) into photon#/s*m**2(m)
blackbody_photon_flux = blackbody_irradiance * (solar_spectra_wavelength_meters / (h * c))
# units of nm
material_wavelength_for_absorbance_data = ((c * h_e) / (material_energy_for_absorbance_data + 0.00000001)) * 10 ** 9
# absorbance interpolation onto each solar spectrum wavelength
# creates cubic spline interpolating function, set up to use end values
# as the guesses if leaving the region where data exists
material_absorbance_data_function = interp1d(
material_wavelength_for_absorbance_data,
material_absorbance_data,
kind="cubic",
fill_value=(material_absorbance_data[0], material_absorbance_data[-1]),
bounds_error=False,
)
material_interpolated_absorbance = np.zeros(len(solar_spectra_wavelength_meters))
for i in range(0, len(solar_spectra_wavelength_meters)):
# Cutting off absorption data below the gap. This is done to deal
# with VASPs broadening of the calculated absorption data
if (
solar_spectra_wavelength[i] < 1e9 * ((c * h_e) / material_direct_allowed_gap)
or cut_off_absorbance_below_direct_allowed_gap is False
):
material_interpolated_absorbance[i] = material_absorbance_data_function(solar_spectra_wavelength[i])
absorbed_by_wavelength = 1.0 - np.exp(-2.0 * material_interpolated_absorbance * thickness)
# Numerically integrating irradiance over wavelength array
# Note: elementary charge, not math e! # units of A/m**2 W/(V*m**2)
J_0_r = (
e
* np.pi
* simps(
blackbody_photon_flux * absorbed_by_wavelength,
solar_spectra_wavelength_meters,
)
)
J_0 = J_0_r / fr
J_sc = e * simps(solar_spectra_photon_flux * absorbed_by_wavelength, solar_spectra_wavelength)
def J(V):
J = J_sc - J_0 * (np.exp(e * V / (k * temperature)) - 1.0)
return J
def power(V):
p = J(V) * V
return p
test_voltage = 0
voltage_step = 0.001
while power(test_voltage + voltage_step) > power(test_voltage):
test_voltage += voltage_step
max_power = power(test_voltage)
# Calculate the maximized efficience
efficiency = max_power / power_in
if plot_current_voltage:
V = np.linspace(0, 2, 200)
plt.plot(V, J(V))
plt.plot(V, power(V), linestyle="--")
plt.savefig("pp.png")
plt.close()
# print(power(V_Pmax))
return 100.0 * efficiency
| davidwaroquiers/pymatgen | pymatgen/analysis/solar/slme.py | Python | mit | 9,539 | [
"VASP",
"pymatgen"
] | ff8d4e05d76d4d4e904bb115e70d5d6aa250f39d6aa2cfb97b2effd3b7ad2db4 |
import ast
from src.ast_pprint import parseprint
from types import *
import _ast
class PyUnitAssertionError(AssertionError):
pass
def assert_equal(a, b):
if a != b:
raise PyUnitAssertionError("{0} is not equal to {1}".format(a, b))
def assert_not_equal(a, b):
if a == b:
raise PyUnitAssertionError("{0} is actually equal to {1}".format(a, b))
test_namespace = {'assert_equal': assert_equal, 'assert_not_equal': assert_not_equal}
class AssertPyUnitTransformer(ast.NodeTransformer):
"""Transform 'assert a==b' into 'assert_equal(a, b)'
"""
def generate_assert_equal(self, node):
call = ast.Call(func=ast.Name(id='assert_equal', ctx=ast.Load()),
args=[node.test.left, node.test.comparators[0]],
keywords=[])
return call
def generate_assert_not_equal(self, node):
call = ast.Call(func=ast.Name(id='assert_not_equal', ctx=ast.Load()),
args=[node.test.left, node.test.comparators[0]],
keywords=[])
return call
def visit_Assert(self, node):
dispatch = {ast.Eq: self.generate_assert_equal, ast.NotEq: self.generate_assert_not_equal}
if isinstance(node.test, ast.Compare) and \
len(node.test.ops) == 1:
for key, value in dispatch.items():
if isinstance(node.test.ops[0], key):
call = value(node)
# Wrap the call in an Expr node, because the return value isn't used.
newnode = ast.Expr(value=call)
ast.fix_missing_locations(newnode)
return newnode
# Return the original node if we don't want to change it.
return node
class Runner(object):
def __init__(self):
self.reset_tests_results()
def report(self):
for result in self.results:
result.report()
def reset_tests_results(self):
self.methods_to_run = []
self.results = []
def run_tests(self, file):
self.parse_code(file)
self.inspect_clases()
def parse_code(self, filename):
with open(filename) as f:
code = f.read()
self.ast_tree = ast.parse(code)
self.code_lines = [None] + code.splitlines()
def modify_tree(self):
self.ast_tree = AssertPyUnitTransformer().visit(self.ast_tree)
def inspect_clases(self):
for node in self.ast_tree.body:
if isinstance(node, ast.ClassDef):
new_node = AssertPyUnitTransformer().visit(node)
self.search_def_methods(new_node)
if isinstance(node, ast.Import):
self.import_node(node)
self.execute_tests()
def import_node(self, node):
wrapper = ast.Module(body=[node])
co = compile(wrapper, '<string>', 'exec')
exec (co, globals(), test_namespace)
def search_def_methods(self, class_node):
for node in class_node.body:
if isinstance(node, ast.FunctionDef):
if self.is_test_method(node.name):
newnode = ast.arguments(args=[], vararg=None, kwarg=None, defaults=[])
ast.copy_location(newnode, node.args)
node.args = newnode
self.methods_to_run.append(node)
def is_test_method(self, method_name):
return method_name.startswith('test_')
def execute_test(self, test_node):
print(test_node)
test_name = test_node.name
wrapper = ast.Module(body=[test_node])
try:
co = compile(wrapper, '<string>', 'exec')
exec (co, test_namespace)
test_namespace[test_name]()
self.results.append(SuccessFulResult(test_name))
except PyUnitAssertionError as e:
self.results.append(FailedResult(test_name, e, test_node.lineno, self.code_lines[test_node.lineno]))
except Exception as e:
self.results.append(ErrorResult(test_name, e, test_node.lineno, self.code_lines[test_node.lineno]))
def execute_tests(self):
for test in self.methods_to_run:
self.execute_test(test)
class Result(object):
def report(self):
pass
class SuccessFulResult(Result):
def __init__(self, test_name):
self.test_name = test_name
def report(self):
print('Test {0} run successfully'.format(self.test_name))
class FailedResult(Result):
def __init__(self, test_name, exception, lineno, message):
self.test_name = test_name
self.exception = exception
self.lineno = lineno
self.message = message
def report(self):
print("{0} Failed:{1} on line {2}".format(self.test_name, self.message, self.lineno))
print("Cause: {0}".format(self.exception))
class ErrorResult(Result):
def __init__(self, test_name, exception, lineno, message):
self.test_name = test_name
self.exception = exception
self.lineno = lineno
self.message = message
def report(self):
print("{0} Errored:{1} on line {2}".format(self.test_name, self.message, self.lineno))
print("Cause: {0}".format(self.exception)) | tcdl-utn/astmanipulation | src/testing_framework/astPyTest.py | Python | bsd-3-clause | 5,255 | [
"VisIt"
] | 69ed377d05ff10359a73227ff2f9bcc7318f1b186cfea169f0f1caa0a5bc5736 |
# Authors: Alexandre Gramfort <alexandre.gramfort@telecom-paristech.fr>
# Matti Hamalainen <msh@nmr.mgh.harvard.edu>
# Denis A. Engemann <denis.engemann@gmail.com>
#
# License: BSD (3-clause)
import copy as cp
from distutils.version import LooseVersion
import itertools as itt
from math import log
import os
import numpy as np
from scipy import linalg
from .io.write import start_file, end_file
from .io.proj import (make_projector, _proj_equal, activate_proj,
_needs_eeg_average_ref_proj)
from .io import fiff_open
from .io.pick import (pick_types, pick_channels_cov, pick_channels, pick_info,
_picks_by_type, _pick_data_channels)
from .io.constants import FIFF
from .io.meas_info import read_bad_channels
from .io.proj import _read_proj, _write_proj
from .io.tag import find_tag
from .io.tree import dir_tree_find
from .io.write import (start_block, end_block, write_int, write_name_list,
write_double, write_float_matrix, write_string)
from .defaults import _handle_default
from .epochs import Epochs
from .event import make_fixed_length_events
from .utils import (check_fname, logger, verbose, estimate_rank,
_compute_row_norms, check_version, _time_mask, warn,
copy_function_doc_to_method_doc)
from . import viz
from .externals.six.moves import zip
from .externals.six import string_types
def _check_covs_algebra(cov1, cov2):
if cov1.ch_names != cov2.ch_names:
raise ValueError('Both Covariance do not have the same list of '
'channels.')
projs1 = [str(c) for c in cov1['projs']]
projs2 = [str(c) for c in cov1['projs']]
if projs1 != projs2:
raise ValueError('Both Covariance do not have the same list of '
'SSP projections.')
def _get_tslice(epochs, tmin, tmax):
"""get the slice."""
mask = _time_mask(epochs.times, tmin, tmax, sfreq=epochs.info['sfreq'])
tstart = np.where(mask)[0][0] if tmin is not None else None
tend = np.where(mask)[0][-1] + 1 if tmax is not None else None
tslice = slice(tstart, tend, None)
return tslice
class Covariance(dict):
"""Noise covariance matrix.
.. warning:: This class should not be instantiated directly, but
instead should be created using a covariance reading or
computation function.
Parameters
----------
data : array-like
The data.
names : list of str
Channel names.
bads : list of str
Bad channels.
projs : list
Projection vectors.
nfree : int
Degrees of freedom.
eig : array-like | None
Eigenvalues.
eigvec : array-like | None
Eigenvectors.
method : str | None
The method used to compute the covariance.
loglik : float
The log likelihood.
Attributes
----------
data : array of shape (n_channels, n_channels)
The covariance.
ch_names : list of string
List of channels' names.
nfree : int
Number of degrees of freedom i.e. number of time points used.
See Also
--------
compute_covariance
compute_raw_covariance
make_ad_hoc_cov
read_cov
"""
def __init__(self, data, names, bads, projs, nfree, eig=None, eigvec=None,
method=None, loglik=None):
"""Init of covariance."""
diag = True if data.ndim == 1 else False
self.update(data=data, dim=len(data), names=names, bads=bads,
nfree=nfree, eig=eig, eigvec=eigvec, diag=diag,
projs=projs, kind=FIFF.FIFFV_MNE_NOISE_COV)
if method is not None:
self['method'] = method
if loglik is not None:
self['loglik'] = loglik
@property
def data(self):
"""Numpy array of Noise covariance matrix."""
return self['data']
@property
def ch_names(self):
"""Channel names."""
return self['names']
@property
def nfree(self):
"""Number of degrees of freedom."""
return self['nfree']
def save(self, fname):
"""Save covariance matrix in a FIF file.
Parameters
----------
fname : str
Output filename.
"""
check_fname(fname, 'covariance', ('-cov.fif', '-cov.fif.gz'))
fid = start_file(fname)
try:
_write_cov(fid, self)
except Exception as inst:
fid.close()
os.remove(fname)
raise inst
end_file(fid)
def copy(self):
"""Copy the Covariance object
Returns
-------
cov : instance of Covariance
The copied object.
"""
return cp.deepcopy(self)
def as_diag(self):
"""Set covariance to be processed as being diagonal.
Returns
-------
cov : dict
The covariance.
Notes
-----
This function allows creation of inverse operators
equivalent to using the old "--diagnoise" mne option.
"""
if self['diag']:
return self
self['diag'] = True
self['data'] = np.diag(self['data'])
self['eig'] = None
self['eigvec'] = None
return self
def __repr__(self):
if self.data.ndim == 2:
s = 'size : %s x %s' % self.data.shape
else: # ndim == 1
s = 'diagonal : %s' % self.data.size
s += ", n_samples : %s" % self.nfree
s += ", data : %s" % self.data
return "<Covariance | %s>" % s
def __add__(self, cov):
"""Add Covariance taking into account number of degrees of freedom."""
_check_covs_algebra(self, cov)
this_cov = cp.deepcopy(cov)
this_cov['data'] = (((this_cov['data'] * this_cov['nfree']) +
(self['data'] * self['nfree'])) /
(self['nfree'] + this_cov['nfree']))
this_cov['nfree'] += self['nfree']
this_cov['bads'] = list(set(this_cov['bads']).union(self['bads']))
return this_cov
def __iadd__(self, cov):
"""Add Covariance taking into account number of degrees of freedom."""
_check_covs_algebra(self, cov)
self['data'][:] = (((self['data'] * self['nfree']) +
(cov['data'] * cov['nfree'])) /
(self['nfree'] + cov['nfree']))
self['nfree'] += cov['nfree']
self['bads'] = list(set(self['bads']).union(cov['bads']))
return self
@verbose
@copy_function_doc_to_method_doc(viz.misc.plot_cov)
def plot(self, info, exclude=[], colorbar=True, proj=False, show_svd=True,
show=True, verbose=None):
return viz.misc.plot_cov(self, info, exclude, colorbar, proj, show_svd,
show, verbose)
###############################################################################
# IO
@verbose
def read_cov(fname, verbose=None):
"""Read a noise covariance from a FIF file.
Parameters
----------
fname : string
The name of file containing the covariance matrix. It should end with
-cov.fif or -cov.fif.gz.
verbose : bool, str, int, or None (default None)
If not None, override default verbose level (see mne.verbose).
Returns
-------
cov : Covariance
The noise covariance matrix.
See Also
--------
write_cov, compute_covariance, compute_raw_covariance
"""
check_fname(fname, 'covariance', ('-cov.fif', '-cov.fif.gz'))
f, tree = fiff_open(fname)[:2]
with f as fid:
return Covariance(**_read_cov(fid, tree, FIFF.FIFFV_MNE_NOISE_COV,
limited=True))
###############################################################################
# Estimate from data
@verbose
def make_ad_hoc_cov(info, verbose=None):
"""Create an ad hoc noise covariance.
Parameters
----------
info : instance of Info
Measurement info.
verbose : bool, str, int, or None (default None)
If not None, override default verbose level (see mne.verbose).
Returns
-------
cov : instance of Covariance
The ad hoc diagonal noise covariance for the M/EEG data channels.
Notes
-----
.. versionadded:: 0.9.0
"""
info = pick_info(info, pick_types(info, meg=True, eeg=True, exclude=[]))
info._check_consistency()
# Standard deviations to be used
grad_std = 5e-13
mag_std = 20e-15
eeg_std = 0.2e-6
logger.info('Using standard noise values '
'(MEG grad : %6.1f fT/cm MEG mag : %6.1f fT EEG : %6.1f uV)'
% (1e13 * grad_std, 1e15 * mag_std, 1e6 * eeg_std))
data = np.zeros(len(info['ch_names']))
for meg, eeg, val in zip(('grad', 'mag', False), (False, False, True),
(grad_std, mag_std, eeg_std)):
data[pick_types(info, meg=meg, eeg=eeg)] = val * val
return Covariance(data, info['ch_names'], info['bads'], info['projs'],
nfree=0)
def _check_n_samples(n_samples, n_chan):
"""Check to see if there are enough samples for reliable cov calc."""
n_samples_min = 10 * (n_chan + 1) // 2
if n_samples <= 0:
raise ValueError('No samples found to compute the covariance matrix')
if n_samples < n_samples_min:
warn('Too few samples (required : %d got : %d), covariance '
'estimate may be unreliable' % (n_samples_min, n_samples))
@verbose
def compute_raw_covariance(raw, tmin=0, tmax=None, tstep=0.2, reject=None,
flat=None, picks=None, method='empirical',
method_params=None, cv=3, scalings=None, n_jobs=1,
return_estimators=False, verbose=None):
"""Estimate noise covariance matrix from a continuous segment of raw data.
It is typically useful to estimate a noise covariance from empty room
data or time intervals before starting the stimulation.
.. note:: This function will:
1. Partition the data into evenly spaced, equal-length
epochs.
2. Load them into memory.
3. Subtract the mean across all time points and epochs
for each channel.
4. Process the :class:`Epochs` by
:func:`compute_covariance`.
This will produce a slightly different result compared to
using :func:`make_fixed_length_events`, :class:`Epochs`, and
:func:`compute_covariance` directly, since that would (with
the recommended baseline correction) subtract the mean across
time *for each epoch* (instead of across epochs) for each
channel.
Parameters
----------
raw : instance of Raw
Raw data
tmin : float
Beginning of time interval in seconds. Defaults to 0.
tmax : float | None (default None)
End of time interval in seconds. If None (default), use the end of the
recording.
tstep : float (default 0.2)
Length of data chunks for artefact rejection in seconds.
Can also be None to use a single epoch of (tmax - tmin)
duration. This can use a lot of memory for large ``Raw``
instances.
reject : dict | None (default None)
Rejection parameters based on peak-to-peak amplitude.
Valid keys are 'grad' | 'mag' | 'eeg' | 'eog' | 'ecg'.
If reject is None then no rejection is done. Example::
reject = dict(grad=4000e-13, # T / m (gradiometers)
mag=4e-12, # T (magnetometers)
eeg=40e-6, # V (EEG channels)
eog=250e-6 # V (EOG channels)
)
flat : dict | None (default None)
Rejection parameters based on flatness of signal.
Valid keys are 'grad' | 'mag' | 'eeg' | 'eog' | 'ecg', and values
are floats that set the minimum acceptable peak-to-peak amplitude.
If flat is None then no rejection is done.
picks : array-like of int | None (default None)
Indices of channels to include (if None, data channels are used).
method : str | list | None (default 'empirical')
The method used for covariance estimation.
See :func:`mne.compute_covariance`.
.. versionadded:: 0.12
method_params : dict | None (default None)
Additional parameters to the estimation procedure.
See :func:`mne.compute_covariance`.
.. versionadded:: 0.12
cv : int | sklearn cross_validation object (default 3)
The cross validation method. Defaults to 3, which will
internally trigger a default 3-fold shuffle split.
.. versionadded:: 0.12
scalings : dict | None (default None)
Defaults to ``dict(mag=1e15, grad=1e13, eeg=1e6)``.
These defaults will scale magnetometers and gradiometers
at the same unit.
.. versionadded:: 0.12
n_jobs : int (default 1)
Number of jobs to run in parallel.
.. versionadded:: 0.12
return_estimators : bool (default False)
Whether to return all estimators or the best. Only considered if
method equals 'auto' or is a list of str. Defaults to False
.. versionadded:: 0.12
verbose : bool | str | int | None (default None)
If not None, override default verbose level (see mne.verbose).
Returns
-------
cov : instance of Covariance | list
The computed covariance. If method equals 'auto' or is a list of str
and return_estimators equals True, a list of covariance estimators is
returned (sorted by log-likelihood, from high to low, i.e. from best
to worst).
See Also
--------
compute_covariance : Estimate noise covariance matrix from epochs
"""
tmin = 0. if tmin is None else float(tmin)
tmax = raw.times[-1] if tmax is None else float(tmax)
tstep = tmax - tmin if tstep is None else float(tstep)
tstep_m1 = tstep - 1. / raw.info['sfreq'] # inclusive!
events = make_fixed_length_events(raw, 1, tmin, tmax, tstep)
pl = 's' if len(events) != 1 else ''
logger.info('Using up to %s segment%s' % (len(events), pl))
# don't exclude any bad channels, inverses expect all channels present
if picks is None:
# Need to include all channels e.g. if eog rejection is to be used
picks = np.arange(raw.info['nchan'])
pick_mask = np.in1d(
picks, _pick_data_channels(raw.info, with_ref_meg=False))
else:
pick_mask = slice(None)
epochs = Epochs(raw, events, 1, 0, tstep_m1, baseline=None,
picks=picks, reject=reject, flat=flat, verbose=False,
preload=False, proj=False, add_eeg_ref=False)
if method is None:
method = 'empirical'
if isinstance(method, string_types) and method == 'empirical':
# potentially *much* more memory efficient to do it the iterative way
picks = picks[pick_mask]
data = 0
n_samples = 0
mu = 0
# Read data in chunks
for raw_segment in epochs:
raw_segment = raw_segment[pick_mask]
mu += raw_segment.sum(axis=1)
data += np.dot(raw_segment, raw_segment.T)
n_samples += raw_segment.shape[1]
_check_n_samples(n_samples, len(picks))
data -= mu[:, None] * (mu[None, :] / n_samples)
data /= (n_samples - 1.0)
logger.info("Number of samples used : %d" % n_samples)
logger.info('[done]')
ch_names = [raw.info['ch_names'][k] for k in picks]
bads = [b for b in raw.info['bads'] if b in ch_names]
projs = cp.deepcopy(raw.info['projs'])
return Covariance(data, ch_names, bads, projs, nfree=n_samples)
del picks, pick_mask
# This makes it equivalent to what we used to do (and do above for
# empirical mode), treating all epochs as if they were a single long one
epochs.load_data()
ch_means = epochs._data.mean(axis=0).mean(axis=1)
epochs._data -= ch_means[np.newaxis, :, np.newaxis]
# fake this value so there are no complaints from compute_covariance
epochs.baseline = (None, None)
return compute_covariance(epochs, keep_sample_mean=True, method=method,
method_params=method_params, cv=cv,
scalings=scalings, n_jobs=n_jobs,
return_estimators=return_estimators)
@verbose
def compute_covariance(epochs, keep_sample_mean=True, tmin=None, tmax=None,
projs=None, method='empirical', method_params=None,
cv=3, scalings=None, n_jobs=1, return_estimators=False,
on_mismatch='raise', verbose=None):
"""Estimate noise covariance matrix from epochs.
The noise covariance is typically estimated on pre-stim periods
when the stim onset is defined from events.
If the covariance is computed for multiple event types (events
with different IDs), the following two options can be used and combined:
1. either an Epochs object for each event type is created and
a list of Epochs is passed to this function.
2. an Epochs object is created for multiple events and passed
to this function.
.. note:: Baseline correction should be used when creating the Epochs.
Otherwise the computed covariance matrix will be inaccurate.
.. note:: For multiple event types, it is also possible to create a
single Epochs object with events obtained using
merge_events(). However, the resulting covariance matrix
will only be correct if keep_sample_mean is True.
.. note:: The covariance can be unstable if the number of samples is
not sufficient. In that case it is common to regularize a
covariance estimate. The ``method`` parameter of this
function allows to regularize the covariance in an
automated way. It also allows to select between different
alternative estimation algorithms which themselves achieve
regularization. Details are described in [1]_.
Parameters
----------
epochs : instance of Epochs, or a list of Epochs objects
The epochs.
keep_sample_mean : bool (default True)
If False, the average response over epochs is computed for
each event type and subtracted during the covariance
computation. This is useful if the evoked response from a
previous stimulus extends into the baseline period of the next.
Note. This option is only implemented for method='empirical'.
tmin : float | None (default None)
Start time for baseline. If None start at first sample.
tmax : float | None (default None)
End time for baseline. If None end at last sample.
projs : list of Projection | None (default None)
List of projectors to use in covariance calculation, or None
to indicate that the projectors from the epochs should be
inherited. If None, then projectors from all epochs must match.
method : str | list | None (default 'empirical')
The method used for covariance estimation. If 'empirical' (default),
the sample covariance will be computed. A list can be passed to run a
set of the different methods.
If 'auto' or a list of methods, the best estimator will be determined
based on log-likelihood and cross-validation on unseen data as
described in [1]_. Valid methods are:
* ``'empirical'``: the empirical or sample covariance
* ``'diagonal_fixed'``: a diagonal regularization as in
mne.cov.regularize (see MNE manual)
* ``'ledoit_wolf'``: the Ledoit-Wolf estimator [2]_
* ``'shrunk'``: like 'ledoit_wolf' with cross-validation for
optimal alpha (see scikit-learn documentation on covariance
estimation)
* ``'pca'``: probabilistic PCA with low rank [3]_
* ``'factor_analysis'``: Factor Analysis with low rank [4]_
If ``'auto'``, this expands to::
['shrunk', 'diagonal_fixed', 'empirical', 'factor_analysis']
.. note:: ``'ledoit_wolf'`` and ``'pca'`` are similar to
``'shrunk'`` and ``'factor_analysis'``, respectively. They are not
included to avoid redundancy. In most cases ``'shrunk'`` and
``'factor_analysis'`` represent more appropriate default
choices.
The ``'auto'`` mode is not recommended if there are many
segments of data, since computation can take a long time.
.. versionadded:: 0.9.0
method_params : dict | None (default None)
Additional parameters to the estimation procedure. Only considered if
method is not None. Keys must correspond to the value(s) of `method`.
If None (default), expands to::
'empirical': {'store_precision': False, 'assume_centered': True},
'diagonal_fixed': {'grad': 0.01, 'mag': 0.01, 'eeg': 0.0,
'store_precision': False,
'assume_centered': True},
'ledoit_wolf': {'store_precision': False, 'assume_centered': True},
'shrunk': {'shrinkage': np.logspace(-4, 0, 30),
'store_precision': False, 'assume_centered': True},
'pca': {'iter_n_components': None},
'factor_analysis': {'iter_n_components': None}
cv : int | sklearn cross_validation object (default 3)
The cross validation method. Defaults to 3, which will
internally trigger a default 3-fold shuffle split.
scalings : dict | None (default None)
Defaults to ``dict(mag=1e15, grad=1e13, eeg=1e6)``.
These defaults will scale magnetometers and gradiometers
at the same unit.
n_jobs : int (default 1)
Number of jobs to run in parallel.
return_estimators : bool (default False)
Whether to return all estimators or the best. Only considered if
method equals 'auto' or is a list of str. Defaults to False
on_mismatch : str
What to do when the MEG<->Head transformations do not match between
epochs. If "raise" (default) an error is raised, if "warn" then a
warning is emitted, if "ignore" then nothing is printed. Having
mismatched transforms can in some cases lead to unexpected or
unstable results in covariance calculation, e.g. when data
have been processed with Maxwell filtering but not transformed
to the same head position.
verbose : bool | str | int | or None (default None)
If not None, override default verbose level (see mne.verbose).
Returns
-------
cov : instance of Covariance | list
The computed covariance. If method equals 'auto' or is a list of str
and return_estimators equals True, a list of covariance estimators is
returned (sorted by log-likelihood, from high to low, i.e. from best
to worst).
See Also
--------
compute_raw_covariance : Estimate noise covariance from raw data
References
----------
.. [1] Engemann D. and Gramfort A. (2015) Automated model selection in
covariance estimation and spatial whitening of MEG and EEG
signals, vol. 108, 328-342, NeuroImage.
.. [2] Ledoit, O., Wolf, M., (2004). A well-conditioned estimator for
large-dimensional covariance matrices. Journal of Multivariate
Analysis 88 (2), 365 - 411.
.. [3] Tipping, M. E., Bishop, C. M., (1999). Probabilistic principal
component analysis. Journal of the Royal Statistical Society:
Series B (Statistical Methodology) 61 (3), 611 - 622.
.. [4] Barber, D., (2012). Bayesian reasoning and machine learning.
Cambridge University Press., Algorithm 21.1
"""
accepted_methods = ('auto', 'empirical', 'diagonal_fixed', 'ledoit_wolf',
'shrunk', 'pca', 'factor_analysis',)
msg = ('Invalid method ({method}). Accepted values (individually or '
'in a list) are "%s" or None.' % '" or "'.join(accepted_methods))
# scale to natural unit for best stability with MEG/EEG
if isinstance(scalings, dict):
for k, v in scalings.items():
if k not in ('mag', 'grad', 'eeg'):
raise ValueError('The keys in `scalings` must be "mag" or'
'"grad" or "eeg". You gave me: %s' % k)
scalings = _handle_default('scalings', scalings)
_method_params = {
'empirical': {'store_precision': False, 'assume_centered': True},
'diagonal_fixed': {'grad': 0.01, 'mag': 0.01, 'eeg': 0.0,
'store_precision': False, 'assume_centered': True},
'ledoit_wolf': {'store_precision': False, 'assume_centered': True},
'shrunk': {'shrinkage': np.logspace(-4, 0, 30),
'store_precision': False, 'assume_centered': True},
'pca': {'iter_n_components': None},
'factor_analysis': {'iter_n_components': None}
}
if isinstance(method_params, dict):
for key, values in method_params.items():
if key not in _method_params:
raise ValueError('key (%s) must be "%s"' %
(key, '" or "'.join(_method_params)))
_method_params[key].update(method_params[key])
# for multi condition support epochs is required to refer to a list of
# epochs objects
def _unpack_epochs(epochs):
if len(epochs.event_id) > 1:
epochs = [epochs[k] for k in epochs.event_id]
else:
epochs = [epochs]
return epochs
if not isinstance(epochs, list):
epochs = _unpack_epochs(epochs)
else:
epochs = sum([_unpack_epochs(epoch) for epoch in epochs], [])
# check for baseline correction
if any(epochs_t.baseline is None and epochs_t.info['highpass'] < 0.5 and
keep_sample_mean for epochs_t in epochs):
warn('Epochs are not baseline corrected, covariance '
'matrix may be inaccurate')
orig = epochs[0].info['dev_head_t']
if not isinstance(on_mismatch, string_types) or \
on_mismatch not in ['raise', 'warn', 'ignore']:
raise ValueError('on_mismatch must be "raise", "warn", or "ignore", '
'got %s' % on_mismatch)
for ei, epoch in enumerate(epochs):
epoch.info._check_consistency()
if (orig is None) != (epoch.info['dev_head_t'] is None) or \
(orig is not None and not
np.allclose(orig['trans'],
epoch.info['dev_head_t']['trans'])):
msg = ('MEG<->Head transform mismatch between epochs[0]:\n%s\n\n'
'and epochs[%s]:\n%s'
% (orig, ei, epoch.info['dev_head_t']))
if on_mismatch == 'raise':
raise ValueError(msg)
elif on_mismatch == 'warn':
warn(msg)
bads = epochs[0].info['bads']
if projs is None:
projs = cp.deepcopy(epochs[0].info['projs'])
# make sure Epochs are compatible
for epochs_t in epochs[1:]:
if epochs_t.proj != epochs[0].proj:
raise ValueError('Epochs must agree on the use of projections')
for proj_a, proj_b in zip(epochs_t.info['projs'], projs):
if not _proj_equal(proj_a, proj_b):
raise ValueError('Epochs must have same projectors')
else:
projs = cp.deepcopy(projs)
ch_names = epochs[0].ch_names
# make sure Epochs are compatible
for epochs_t in epochs[1:]:
if epochs_t.info['bads'] != bads:
raise ValueError('Epochs must have same bad channels')
if epochs_t.ch_names != ch_names:
raise ValueError('Epochs must have same channel names')
picks_list = _picks_by_type(epochs[0].info)
picks_meeg = np.concatenate([b for _, b in picks_list])
picks_meeg = np.sort(picks_meeg)
ch_names = [epochs[0].ch_names[k] for k in picks_meeg]
info = epochs[0].info # we will overwrite 'epochs'
if method is None:
method = ['empirical']
elif method == 'auto':
method = ['shrunk', 'diagonal_fixed', 'empirical', 'factor_analysis']
if not isinstance(method, (list, tuple)):
method = [method]
ok_sklearn = check_version('sklearn', '0.15') is True
if not ok_sklearn and (len(method) != 1 or method[0] != 'empirical'):
raise ValueError('scikit-learn is not installed, `method` must be '
'`empirical`')
if keep_sample_mean is False:
if len(method) != 1 or 'empirical' not in method:
raise ValueError('`keep_sample_mean=False` is only supported'
'with `method="empirical"`')
for p, v in _method_params.items():
if v.get('assume_centered', None) is False:
raise ValueError('`assume_centered` must be True'
' if `keep_sample_mean` is False')
# prepare mean covs
n_epoch_types = len(epochs)
data_mean = [0] * n_epoch_types
n_samples = np.zeros(n_epoch_types, dtype=np.int)
n_epochs = np.zeros(n_epoch_types, dtype=np.int)
for ii, epochs_t in enumerate(epochs):
tslice = _get_tslice(epochs_t, tmin, tmax)
for e in epochs_t:
e = e[picks_meeg, tslice]
if not keep_sample_mean:
data_mean[ii] += e
n_samples[ii] += e.shape[1]
n_epochs[ii] += 1
n_samples_epoch = n_samples // n_epochs
norm_const = np.sum(n_samples_epoch * (n_epochs - 1))
data_mean = [1.0 / n_epoch * np.dot(mean, mean.T) for n_epoch, mean
in zip(n_epochs, data_mean)]
if not all(k in accepted_methods for k in method):
raise ValueError(msg.format(method=method))
info = pick_info(info, picks_meeg)
tslice = _get_tslice(epochs[0], tmin, tmax)
epochs = [ee.get_data()[:, picks_meeg, tslice] for ee in epochs]
picks_meeg = np.arange(len(picks_meeg))
picks_list = _picks_by_type(info)
if len(epochs) > 1:
epochs = np.concatenate(epochs, 0)
else:
epochs = epochs[0]
epochs = np.hstack(epochs)
n_samples_tot = epochs.shape[-1]
_check_n_samples(n_samples_tot, len(picks_meeg))
epochs = epochs.T # sklearn | C-order
if ok_sklearn:
cov_data = _compute_covariance_auto(epochs, method=method,
method_params=_method_params,
info=info,
verbose=verbose,
cv=cv,
n_jobs=n_jobs,
# XXX expose later
stop_early=True, # if needed.
picks_list=picks_list,
scalings=scalings)
else:
if _method_params['empirical']['assume_centered'] is True:
cov = epochs.T.dot(epochs) / n_samples_tot
else:
cov = np.cov(epochs.T, bias=1)
cov_data = {'empirical': {'data': cov}}
if keep_sample_mean is False:
cov = cov_data['empirical']['data']
# undo scaling
cov *= n_samples_tot
# ... apply pre-computed class-wise normalization
for mean_cov in data_mean:
cov -= mean_cov
cov /= norm_const
covs = list()
for this_method, data in cov_data.items():
cov = Covariance(data.pop('data'), ch_names, info['bads'], projs,
nfree=n_samples_tot)
logger.info('Number of samples used : %d' % n_samples_tot)
logger.info('[done]')
# add extra info
cov.update(method=this_method, **data)
covs.append(cov)
if ok_sklearn:
msg = ['log-likelihood on unseen data (descending order):']
logliks = [(c['method'], c['loglik']) for c in covs]
logliks.sort(reverse=True, key=lambda c: c[1])
for k, v in logliks:
msg.append('%s: %0.3f' % (k, v))
logger.info('\n '.join(msg))
if ok_sklearn and not return_estimators:
keys, scores = zip(*[(c['method'], c['loglik']) for c in covs])
out = covs[np.argmax(scores)]
logger.info('selecting best estimator: {0}'.format(out['method']))
elif ok_sklearn:
out = covs
out.sort(key=lambda c: c['loglik'], reverse=True)
else:
out = covs[0]
return out
def _compute_covariance_auto(data, method, info, method_params, cv,
scalings, n_jobs, stop_early, picks_list,
verbose):
"""docstring for _compute_covariance_auto."""
try:
from sklearn.model_selection import GridSearchCV
except Exception: # XXX support sklearn < 0.18
from sklearn.grid_search import GridSearchCV
from sklearn.covariance import (LedoitWolf, ShrunkCovariance,
EmpiricalCovariance)
# rescale to improve numerical stability
_apply_scaling_array(data.T, picks_list=picks_list, scalings=scalings)
estimator_cov_info = list()
msg = 'Estimating covariance using %s'
_RegCovariance, _ShrunkCovariance = _get_covariance_classes()
for this_method in method:
data_ = data.copy()
name = this_method.__name__ if callable(this_method) else this_method
logger.info(msg % name.upper())
if this_method == 'empirical':
est = EmpiricalCovariance(**method_params[this_method])
est.fit(data_)
_info = None
estimator_cov_info.append((est, est.covariance_, _info))
elif this_method == 'diagonal_fixed':
est = _RegCovariance(info=info, **method_params[this_method])
est.fit(data_)
_info = None
estimator_cov_info.append((est, est.covariance_, _info))
elif this_method == 'ledoit_wolf':
shrinkages = []
lw = LedoitWolf(**method_params[this_method])
for ch_type, picks in picks_list:
lw.fit(data_[:, picks])
shrinkages.append((
ch_type,
lw.shrinkage_,
picks
))
sc = _ShrunkCovariance(shrinkage=shrinkages,
**method_params[this_method])
sc.fit(data_)
_info = None
estimator_cov_info.append((sc, sc.covariance_, _info))
elif this_method == 'shrunk':
shrinkage = method_params[this_method].pop('shrinkage')
tuned_parameters = [{'shrinkage': shrinkage}]
shrinkages = []
gs = GridSearchCV(ShrunkCovariance(**method_params[this_method]),
tuned_parameters, cv=cv)
for ch_type, picks in picks_list:
gs.fit(data_[:, picks])
shrinkages.append((
ch_type,
gs.best_estimator_.shrinkage,
picks
))
shrinkages = [c[0] for c in zip(shrinkages)]
sc = _ShrunkCovariance(shrinkage=shrinkages,
**method_params[this_method])
sc.fit(data_)
_info = None
estimator_cov_info.append((sc, sc.covariance_, _info))
elif this_method == 'pca':
mp = method_params[this_method]
pca, _info = _auto_low_rank_model(data_, this_method,
n_jobs=n_jobs,
method_params=mp, cv=cv,
stop_early=stop_early)
pca.fit(data_)
estimator_cov_info.append((pca, pca.get_covariance(), _info))
elif this_method == 'factor_analysis':
mp = method_params[this_method]
fa, _info = _auto_low_rank_model(data_, this_method, n_jobs=n_jobs,
method_params=mp, cv=cv,
stop_early=stop_early)
fa.fit(data_)
estimator_cov_info.append((fa, fa.get_covariance(), _info))
else:
raise ValueError('Oh no! Your estimator does not have'
' a .fit method')
logger.info('Done.')
logger.info('Using cross-validation to select the best estimator.')
estimators, _, _ = zip(*estimator_cov_info)
logliks = np.array([_cross_val(data, e, cv, n_jobs) for e in estimators])
# undo scaling
for c in estimator_cov_info:
_undo_scaling_cov(c[1], picks_list, scalings)
out = dict()
estimators, covs, runtime_infos = zip(*estimator_cov_info)
cov_methods = [c.__name__ if callable(c) else c for c in method]
runtime_infos, covs = list(runtime_infos), list(covs)
my_zip = zip(cov_methods, runtime_infos, logliks, covs, estimators)
for this_method, runtime_info, loglik, data, est in my_zip:
out[this_method] = {'loglik': loglik, 'data': data, 'estimator': est}
if runtime_info is not None:
out[this_method].update(runtime_info)
return out
def _logdet(A):
"""Compute the log det of a symmetric matrix."""
vals = linalg.eigh(A)[0]
# avoid negative (numerical errors) or zero (semi-definite matrix) values
tol = vals.max() * vals.size * np.finfo(np.float64).eps
vals = np.where(vals > tol, vals, tol)
return np.sum(np.log(vals))
def _gaussian_loglik_scorer(est, X, y=None):
"""Compute the Gaussian log likelihood of X under the model in est."""
# compute empirical covariance of the test set
precision = est.get_precision()
n_samples, n_features = X.shape
log_like = np.zeros(n_samples)
log_like = -.5 * (X * (np.dot(X, precision))).sum(axis=1)
log_like -= .5 * (n_features * log(2. * np.pi) - _logdet(precision))
out = np.mean(log_like)
return out
def _cross_val(data, est, cv, n_jobs):
"""Helper to compute cross validation."""
try:
from sklearn.model_selection import cross_val_score
except ImportError:
# XXX support sklearn < 0.18
from sklearn.cross_validation import cross_val_score
return np.mean(cross_val_score(est, data, cv=cv, n_jobs=n_jobs,
scoring=_gaussian_loglik_scorer))
def _auto_low_rank_model(data, mode, n_jobs, method_params, cv,
stop_early=True, verbose=None):
"""compute latent variable models."""
method_params = cp.deepcopy(method_params)
iter_n_components = method_params.pop('iter_n_components')
if iter_n_components is None:
iter_n_components = np.arange(5, data.shape[1], 5)
from sklearn.decomposition import PCA, FactorAnalysis
if mode == 'factor_analysis':
est = FactorAnalysis
elif mode == 'pca':
est = PCA
else:
raise ValueError('Come on, this is not a low rank estimator: %s' %
mode)
est = est(**method_params)
est.n_components = 1
scores = np.empty_like(iter_n_components, dtype=np.float64)
scores.fill(np.nan)
# make sure we don't empty the thing if it's a generator
max_n = max(list(cp.deepcopy(iter_n_components)))
if max_n > data.shape[1]:
warn('You are trying to estimate %i components on matrix '
'with %i features.' % (max_n, data.shape[1]))
for ii, n in enumerate(iter_n_components):
est.n_components = n
try: # this may fail depending on rank and split
score = _cross_val(data=data, est=est, cv=cv, n_jobs=n_jobs)
except ValueError:
score = np.inf
if np.isinf(score) or score > 0:
logger.info('... infinite values encountered. stopping estimation')
break
logger.info('... rank: %i - loglik: %0.3f' % (n, score))
if score != -np.inf:
scores[ii] = score
if (ii >= 3 and np.all(np.diff(scores[ii - 3:ii]) < 0.) and
stop_early is True):
# early stop search when loglik has been going down 3 times
logger.info('early stopping parameter search.')
break
# happens if rank is too low right form the beginning
if np.isnan(scores).all():
raise RuntimeError('Oh no! Could not estimate covariance because all '
'scores were NaN. Please contact the MNE-Python '
'developers.')
i_score = np.nanargmax(scores)
best = est.n_components = iter_n_components[i_score]
logger.info('... best model at rank = %i' % best)
runtime_info = {'ranks': np.array(iter_n_components),
'scores': scores,
'best': best,
'cv': cv}
return est, runtime_info
def _get_covariance_classes():
"""Prepare special cov estimators."""
from sklearn.covariance import (EmpiricalCovariance, shrunk_covariance,
ShrunkCovariance)
class _RegCovariance(EmpiricalCovariance):
"""Aux class."""
def __init__(self, info, grad=0.01, mag=0.01, eeg=0.0,
store_precision=False, assume_centered=False):
self.info = info
self.grad = grad
self.mag = mag
self.eeg = eeg
self.store_precision = store_precision
self.assume_centered = assume_centered
def fit(self, X):
EmpiricalCovariance.fit(self, X)
self.covariance_ = 0.5 * (self.covariance_ + self.covariance_.T)
cov_ = Covariance(
data=self.covariance_, names=self.info['ch_names'],
bads=self.info['bads'], projs=self.info['projs'],
nfree=len(self.covariance_))
cov_ = regularize(cov_, self.info, grad=self.grad, mag=self.mag,
eeg=self.eeg, proj=False,
exclude='bads') # ~proj == important!!
self.covariance_ = cov_.data
return self
class _ShrunkCovariance(ShrunkCovariance):
"""Aux class."""
def __init__(self, store_precision, assume_centered, shrinkage=0.1):
self.store_precision = store_precision
self.assume_centered = assume_centered
self.shrinkage = shrinkage
def fit(self, X):
EmpiricalCovariance.fit(self, X)
cov = self.covariance_
if not isinstance(self.shrinkage, (list, tuple)):
shrinkage = [('all', self.shrinkage, np.arange(len(cov)))]
else:
shrinkage = self.shrinkage
zero_cross_cov = np.zeros_like(cov, dtype=bool)
for a, b in itt.combinations(shrinkage, 2):
picks_i, picks_j = a[2], b[2]
ch_ = a[0], b[0]
if 'eeg' in ch_:
zero_cross_cov[np.ix_(picks_i, picks_j)] = True
zero_cross_cov[np.ix_(picks_j, picks_i)] = True
self.zero_cross_cov_ = zero_cross_cov
# Apply shrinkage to blocks
for ch_type, c, picks in shrinkage:
sub_cov = cov[np.ix_(picks, picks)]
cov[np.ix_(picks, picks)] = shrunk_covariance(sub_cov,
shrinkage=c)
# Apply shrinkage to cross-cov
for a, b in itt.combinations(shrinkage, 2):
shrinkage_i, shrinkage_j = a[1], b[1]
picks_i, picks_j = a[2], b[2]
c_ij = np.sqrt((1. - shrinkage_i) * (1. - shrinkage_j))
cov[np.ix_(picks_i, picks_j)] *= c_ij
cov[np.ix_(picks_j, picks_i)] *= c_ij
# Set to zero the necessary cross-cov
if np.any(zero_cross_cov):
cov[zero_cross_cov] = 0.0
self.covariance_ = cov
return self
def score(self, X_test, y=None):
"""Compute the log-likelihood of a Gaussian data set with
`self.covariance_` as an estimator of its covariance matrix.
Parameters
----------
X_test : array-like, shape = [n_samples, n_features]
Test data of which we compute the likelihood, where n_samples
is the number of samples and n_features is the number of
features. X_test is assumed to be drawn from the same
distribution as the data used in fit (including centering).
y : not used, present for API consistence purpose.
Returns
-------
res : float
The likelihood of the data set with `self.covariance_` as an
estimator of its covariance matrix.
"""
from sklearn.covariance import empirical_covariance, log_likelihood
# compute empirical covariance of the test set
test_cov = empirical_covariance(X_test - self.location_,
assume_centered=True)
if np.any(self.zero_cross_cov_):
test_cov[self.zero_cross_cov_] = 0.
res = log_likelihood(test_cov, self.get_precision())
return res
return _RegCovariance, _ShrunkCovariance
###############################################################################
# Writing
def write_cov(fname, cov):
"""Write a noise covariance matrix.
Parameters
----------
fname : string
The name of the file. It should end with -cov.fif or -cov.fif.gz.
cov : Covariance
The noise covariance matrix
See Also
--------
read_cov
"""
cov.save(fname)
###############################################################################
# Prepare for inverse modeling
def _unpack_epochs(epochs):
"""Aux Function."""
if len(epochs.event_id) > 1:
epochs = [epochs[k] for k in epochs.event_id]
else:
epochs = [epochs]
return epochs
def _get_ch_whitener(A, pca, ch_type, rank):
""""Get whitener params for a set of channels."""
# whitening operator
eig, eigvec = linalg.eigh(A, overwrite_a=True)
eigvec = eigvec.T
eig[:-rank] = 0.0
logger.info('Setting small %s eigenvalues to zero.' % ch_type)
if not pca: # No PCA case.
logger.info('Not doing PCA for %s.' % ch_type)
else:
logger.info('Doing PCA for %s.' % ch_type)
# This line will reduce the actual number of variables in data
# and leadfield to the true rank.
eigvec = eigvec[:-rank].copy()
return eig, eigvec
@verbose
def prepare_noise_cov(noise_cov, info, ch_names, rank=None,
scalings=None, verbose=None):
"""Prepare noise covariance matrix.
Parameters
----------
noise_cov : instance of Covariance
The noise covariance to process.
info : dict
The measurement info (used to get channel types and bad channels).
ch_names : list
The channel names to be considered.
rank : None | int | dict
Specified rank of the noise covariance matrix. If None, the rank is
detected automatically. If int, the rank is specified for the MEG
channels. A dictionary with entries 'eeg' and/or 'meg' can be used
to specify the rank for each modality.
scalings : dict | None
Data will be rescaled before rank estimation to improve accuracy.
If dict, it will override the following dict (default if None)::
dict(mag=1e12, grad=1e11, eeg=1e5)
verbose : bool, str, int, or None
If not None, override default verbose level (see mne.verbose).
Returns
-------
cov : instance of Covariance
A copy of the covariance with the good channels subselected
and parameters updated.
"""
noise_cov_idx = [noise_cov.ch_names.index(c) for c in ch_names]
n_chan = len(ch_names)
if not noise_cov['diag']:
C = noise_cov.data[np.ix_(noise_cov_idx, noise_cov_idx)]
else:
C = np.diag(noise_cov.data[noise_cov_idx])
scalings = _handle_default('scalings_cov_rank', scalings)
# Create the projection operator
proj, ncomp, _ = make_projector(info['projs'], ch_names)
if ncomp > 0:
logger.info(' Created an SSP operator (subspace dimension = %d)'
% ncomp)
C = np.dot(proj, np.dot(C, proj.T))
info_pick_meg = pick_types(info, meg=True, eeg=False, ref_meg=False,
exclude='bads')
info_pick_eeg = pick_types(info, meg=False, eeg=True, ref_meg=False,
exclude='bads')
info_meg_names = [info['chs'][k]['ch_name'] for k in info_pick_meg]
out_meg_idx = [k for k in range(len(C)) if ch_names[k] in info_meg_names]
info_eeg_names = [info['chs'][k]['ch_name'] for k in info_pick_eeg]
out_eeg_idx = [k for k in range(len(C)) if ch_names[k] in info_eeg_names]
# re-index based on ch_names order
del info_pick_meg, info_pick_eeg
meg_names = [ch_names[k] for k in out_meg_idx]
eeg_names = [ch_names[k] for k in out_eeg_idx]
if len(meg_names) > 0:
info_pick_meg = pick_channels(info['ch_names'], meg_names)
else:
info_pick_meg = []
if len(eeg_names) > 0:
info_pick_eeg = pick_channels(info['ch_names'], eeg_names)
else:
info_pick_eeg = []
assert len(info_pick_meg) == len(meg_names) == len(out_meg_idx)
assert len(info_pick_eeg) == len(eeg_names) == len(out_eeg_idx)
assert(len(out_meg_idx) + len(out_eeg_idx) == n_chan)
eigvec = np.zeros((n_chan, n_chan))
eig = np.zeros(n_chan)
has_meg = len(out_meg_idx) > 0
has_eeg = len(out_eeg_idx) > 0
# Get the specified noise covariance rank
if rank is not None:
if isinstance(rank, dict):
rank_meg = rank.get('meg', None)
rank_eeg = rank.get('eeg', None)
else:
rank_meg = int(rank)
rank_eeg = None
else:
rank_meg, rank_eeg = None, None
if has_meg:
C_meg = C[np.ix_(out_meg_idx, out_meg_idx)]
this_info = pick_info(info, info_pick_meg)
if rank_meg is None:
rank_meg = _estimate_rank_meeg_cov(C_meg, this_info, scalings)
eig[out_meg_idx], eigvec[np.ix_(out_meg_idx, out_meg_idx)] = \
_get_ch_whitener(C_meg, False, 'MEG', rank_meg)
if has_eeg:
C_eeg = C[np.ix_(out_eeg_idx, out_eeg_idx)]
this_info = pick_info(info, info_pick_eeg)
if rank_eeg is None:
rank_eeg = _estimate_rank_meeg_cov(C_eeg, this_info, scalings)
eig[out_eeg_idx], eigvec[np.ix_(out_eeg_idx, out_eeg_idx)], = \
_get_ch_whitener(C_eeg, False, 'EEG', rank_eeg)
if _needs_eeg_average_ref_proj(info):
warn('No average EEG reference present in info["projs"], covariance '
'may be adversely affected. Consider recomputing covariance using'
' a raw file with an average eeg reference projector added.')
noise_cov = cp.deepcopy(noise_cov)
noise_cov.update(data=C, eig=eig, eigvec=eigvec, dim=len(ch_names),
diag=False, names=ch_names)
return noise_cov
def regularize(cov, info, mag=0.1, grad=0.1, eeg=0.1, exclude='bads',
proj=True, verbose=None):
"""Regularize noise covariance matrix.
This method works by adding a constant to the diagonal for each
channel type separately. Special care is taken to keep the
rank of the data constant.
**Note:** This function is kept for reasons of backward-compatibility.
Please consider explicitly using the ``method`` parameter in
`compute_covariance` to directly combine estimation with regularization
in a data-driven fashion see the
`faq <http://martinos.org/mne/dev/faq.html#how-should-i-regularize-the-covariance-matrix>`_
for more information.
Parameters
----------
cov : Covariance
The noise covariance matrix.
info : dict
The measurement info (used to get channel types and bad channels).
mag : float (default 0.1)
Regularization factor for MEG magnetometers.
grad : float (default 0.1)
Regularization factor for MEG gradiometers.
eeg : float (default 0.1)
Regularization factor for EEG.
exclude : list | 'bads' (default 'bads')
List of channels to mark as bad. If 'bads', bads channels
are extracted from both info['bads'] and cov['bads'].
proj : bool (default true)
Apply or not projections to keep rank of data.
verbose : bool | str | int | None (default None)
If not None, override default verbose level (see mne.verbose).
Returns
-------
reg_cov : Covariance
The regularized covariance matrix.
See Also
--------
compute_covariance
""" # noqa
cov = cp.deepcopy(cov)
info._check_consistency()
if exclude is None:
raise ValueError('exclude must be a list of strings or "bads"')
if exclude == 'bads':
exclude = info['bads'] + cov['bads']
sel_eeg = pick_types(info, meg=False, eeg=True, ref_meg=False,
exclude=exclude)
sel_mag = pick_types(info, meg='mag', eeg=False, ref_meg=False,
exclude=exclude)
sel_grad = pick_types(info, meg='grad', eeg=False, ref_meg=False,
exclude=exclude)
info_ch_names = info['ch_names']
ch_names_eeg = [info_ch_names[i] for i in sel_eeg]
ch_names_mag = [info_ch_names[i] for i in sel_mag]
ch_names_grad = [info_ch_names[i] for i in sel_grad]
# This actually removes bad channels from the cov, which is not backward
# compatible, so let's leave all channels in
cov_good = pick_channels_cov(cov, include=info_ch_names, exclude=exclude)
ch_names = cov_good.ch_names
idx_eeg, idx_mag, idx_grad = [], [], []
for i, ch in enumerate(ch_names):
if ch in ch_names_eeg:
idx_eeg.append(i)
elif ch in ch_names_mag:
idx_mag.append(i)
elif ch in ch_names_grad:
idx_grad.append(i)
else:
raise Exception('channel is unknown type')
C = cov_good['data']
assert len(C) == (len(idx_eeg) + len(idx_mag) + len(idx_grad))
if proj:
projs = info['projs'] + cov_good['projs']
projs = activate_proj(projs)
for desc, idx, reg in [('EEG', idx_eeg, eeg), ('MAG', idx_mag, mag),
('GRAD', idx_grad, grad)]:
if len(idx) == 0 or reg == 0.0:
logger.info(" %s regularization : None" % desc)
continue
logger.info(" %s regularization : %s" % (desc, reg))
this_C = C[np.ix_(idx, idx)]
if proj:
this_ch_names = [ch_names[k] for k in idx]
P, ncomp, _ = make_projector(projs, this_ch_names)
U = linalg.svd(P)[0][:, :-ncomp]
if ncomp > 0:
logger.info(' Created an SSP operator for %s '
'(dimension = %d)' % (desc, ncomp))
this_C = np.dot(U.T, np.dot(this_C, U))
sigma = np.mean(np.diag(this_C))
this_C.flat[::len(this_C) + 1] += reg * sigma # modify diag inplace
if proj and ncomp > 0:
this_C = np.dot(U, np.dot(this_C, U.T))
C[np.ix_(idx, idx)] = this_C
# Put data back in correct locations
idx = pick_channels(cov.ch_names, info_ch_names, exclude=exclude)
cov['data'][np.ix_(idx, idx)] = C
return cov
def _regularized_covariance(data, reg=None):
"""Compute a regularized covariance from data using sklearn.
Parameters
----------
data : ndarray, shape (n_channels, n_times)
Data for covariance estimation.
reg : float | str | None (default None)
If not None, allow regularization for covariance estimation
if float, shrinkage covariance is used (0 <= shrinkage <= 1).
if str, optimal shrinkage using Ledoit-Wolf Shrinkage ('ledoit_wolf')
or Oracle Approximating Shrinkage ('oas').
Returns
-------
cov : ndarray, shape (n_channels, n_channels)
The covariance matrix.
"""
if reg is None:
# compute empirical covariance
cov = np.cov(data)
else:
no_sklearn_err = ('the scikit-learn package is missing and '
'required for covariance regularization.')
# use sklearn covariance estimators
if isinstance(reg, float):
if (reg < 0) or (reg > 1):
raise ValueError('0 <= shrinkage <= 1 for '
'covariance regularization.')
try:
import sklearn
sklearn_version = LooseVersion(sklearn.__version__)
from sklearn.covariance import ShrunkCovariance
except ImportError:
raise Exception(no_sklearn_err)
if sklearn_version < '0.12':
skl_cov = ShrunkCovariance(shrinkage=reg,
store_precision=False)
else:
# init sklearn.covariance.ShrunkCovariance estimator
skl_cov = ShrunkCovariance(shrinkage=reg,
store_precision=False,
assume_centered=True)
elif isinstance(reg, string_types):
if reg == 'ledoit_wolf':
try:
from sklearn.covariance import LedoitWolf
except ImportError:
raise Exception(no_sklearn_err)
# init sklearn.covariance.LedoitWolf estimator
skl_cov = LedoitWolf(store_precision=False,
assume_centered=True)
elif reg == 'oas':
try:
from sklearn.covariance import OAS
except ImportError:
raise Exception(no_sklearn_err)
# init sklearn.covariance.OAS estimator
skl_cov = OAS(store_precision=False,
assume_centered=True)
else:
raise ValueError("regularization parameter should be "
"'ledoit_wolf' or 'oas'")
else:
raise ValueError("regularization parameter should be "
"of type str or int (got %s)." % type(reg))
# compute regularized covariance using sklearn
cov = skl_cov.fit(data.T).covariance_
return cov
@verbose
def compute_whitener(noise_cov, info, picks=None, rank=None,
scalings=None, verbose=None):
"""Compute whitening matrix.
Parameters
----------
noise_cov : Covariance
The noise covariance.
info : dict
The measurement info.
picks : array-like of int | None
The channels indices to include. If None the data
channels in info, except bad channels, are used.
rank : None | int | dict
Specified rank of the noise covariance matrix. If None, the rank is
detected automatically. If int, the rank is specified for the MEG
channels. A dictionary with entries 'eeg' and/or 'meg' can be used
to specify the rank for each modality.
scalings : dict | None
The rescaling method to be applied. See documentation of
``prepare_noise_cov`` for details.
verbose : bool, str, int, or None
If not None, override default verbose level (see mne.verbose).
Returns
-------
W : 2d array
The whitening matrix.
ch_names : list
The channel names.
"""
if picks is None:
picks = pick_types(info, meg=True, eeg=True, ref_meg=False,
exclude='bads')
ch_names = [info['chs'][k]['ch_name'] for k in picks]
noise_cov = cp.deepcopy(noise_cov)
noise_cov = prepare_noise_cov(noise_cov, info, ch_names,
rank=rank, scalings=scalings)
n_chan = len(ch_names)
W = np.zeros((n_chan, n_chan), dtype=np.float)
#
# Omit the zeroes due to projection
#
eig = noise_cov['eig']
nzero = (eig > 0)
W[nzero, nzero] = 1.0 / np.sqrt(eig[nzero])
#
# Rows of eigvec are the eigenvectors
#
W = np.dot(W, noise_cov['eigvec'])
W = np.dot(noise_cov['eigvec'].T, W)
return W, ch_names
@verbose
def whiten_evoked(evoked, noise_cov, picks=None, diag=False, rank=None,
scalings=None, verbose=None):
"""Whiten evoked data using given noise covariance.
Parameters
----------
evoked : instance of Evoked
The evoked data
noise_cov : instance of Covariance
The noise covariance
picks : array-like of int | None
The channel indices to whiten. Can be None to whiten MEG and EEG
data.
diag : bool (default False)
If True, whiten using only the diagonal of the covariance.
rank : None | int | dict (default None)
Specified rank of the noise covariance matrix. If None, the rank is
detected automatically. If int, the rank is specified for the MEG
channels. A dictionary with entries 'eeg' and/or 'meg' can be used
to specify the rank for each modality.
scalings : dict | None (default None)
To achieve reliable rank estimation on multiple sensors,
sensors have to be rescaled. This parameter controls the
rescaling. If dict, it will override the
following default dict (default if None):
dict(mag=1e12, grad=1e11, eeg=1e5)
verbose : bool, str, int, or None
If not None, override default verbose level (see mne.verbose).
Returns
-------
evoked_white : instance of Evoked
The whitened evoked data.
"""
evoked = cp.deepcopy(evoked)
if picks is None:
picks = pick_types(evoked.info, meg=True, eeg=True)
W = _get_whitener_data(evoked.info, noise_cov, picks,
diag=diag, rank=rank, scalings=scalings)
evoked.data[picks] = np.sqrt(evoked.nave) * np.dot(W, evoked.data[picks])
return evoked
@verbose
def _get_whitener_data(info, noise_cov, picks, diag=False, rank=None,
scalings=None, verbose=None):
"""Get whitening matrix for a set of data."""
ch_names = [info['ch_names'][k] for k in picks]
noise_cov = pick_channels_cov(noise_cov, include=ch_names, exclude=[])
if len(noise_cov['data']) != len(ch_names):
missing = list(set(ch_names) - set(noise_cov['names']))
raise RuntimeError('Not all channels present in noise covariance:\n%s'
% missing)
if diag:
noise_cov = cp.deepcopy(noise_cov)
noise_cov['data'] = np.diag(np.diag(noise_cov['data']))
scalings = _handle_default('scalings_cov_rank', scalings)
W = compute_whitener(noise_cov, info, picks=picks, rank=rank,
scalings=scalings)[0]
return W
@verbose
def _read_cov(fid, node, cov_kind, limited=False, verbose=None):
"""Read a noise covariance matrix."""
# Find all covariance matrices
covs = dir_tree_find(node, FIFF.FIFFB_MNE_COV)
if len(covs) == 0:
raise ValueError('No covariance matrices found')
# Is any of the covariance matrices a noise covariance
for p in range(len(covs)):
tag = find_tag(fid, covs[p], FIFF.FIFF_MNE_COV_KIND)
if tag is not None and int(tag.data) == cov_kind:
this = covs[p]
# Find all the necessary data
tag = find_tag(fid, this, FIFF.FIFF_MNE_COV_DIM)
if tag is None:
raise ValueError('Covariance matrix dimension not found')
dim = int(tag.data)
tag = find_tag(fid, this, FIFF.FIFF_MNE_COV_NFREE)
if tag is None:
nfree = -1
else:
nfree = int(tag.data)
tag = find_tag(fid, this, FIFF.FIFF_MNE_COV_METHOD)
if tag is None:
method = None
else:
method = tag.data
tag = find_tag(fid, this, FIFF.FIFF_MNE_COV_SCORE)
if tag is None:
score = None
else:
score = tag.data[0]
tag = find_tag(fid, this, FIFF.FIFF_MNE_ROW_NAMES)
if tag is None:
names = []
else:
names = tag.data.split(':')
if len(names) != dim:
raise ValueError('Number of names does not match '
'covariance matrix dimension')
tag = find_tag(fid, this, FIFF.FIFF_MNE_COV)
if tag is None:
tag = find_tag(fid, this, FIFF.FIFF_MNE_COV_DIAG)
if tag is None:
raise ValueError('No covariance matrix data found')
else:
# Diagonal is stored
data = tag.data
diag = True
logger.info(' %d x %d diagonal covariance (kind = '
'%d) found.' % (dim, dim, cov_kind))
else:
from scipy import sparse
if not sparse.issparse(tag.data):
# Lower diagonal is stored
vals = tag.data
data = np.zeros((dim, dim))
data[np.tril(np.ones((dim, dim))) > 0] = vals
data = data + data.T
data.flat[::dim + 1] /= 2.0
diag = False
logger.info(' %d x %d full covariance (kind = %d) '
'found.' % (dim, dim, cov_kind))
else:
diag = False
data = tag.data
logger.info(' %d x %d sparse covariance (kind = %d)'
' found.' % (dim, dim, cov_kind))
# Read the possibly precomputed decomposition
tag1 = find_tag(fid, this, FIFF.FIFF_MNE_COV_EIGENVALUES)
tag2 = find_tag(fid, this, FIFF.FIFF_MNE_COV_EIGENVECTORS)
if tag1 is not None and tag2 is not None:
eig = tag1.data
eigvec = tag2.data
else:
eig = None
eigvec = None
# Read the projection operator
projs = _read_proj(fid, this)
# Read the bad channel list
bads = read_bad_channels(fid, this)
# Put it together
assert dim == len(data)
assert data.ndim == (1 if diag else 2)
cov = dict(kind=cov_kind, diag=diag, dim=dim, names=names,
data=data, projs=projs, bads=bads, nfree=nfree, eig=eig,
eigvec=eigvec)
if score is not None:
cov['loglik'] = score
if method is not None:
cov['method'] = method
if limited:
del cov['kind'], cov['dim'], cov['diag']
return cov
logger.info(' Did not find the desired covariance matrix (kind = %d)'
% cov_kind)
return None
def _write_cov(fid, cov):
"""Write a noise covariance matrix."""
start_block(fid, FIFF.FIFFB_MNE_COV)
# Dimensions etc.
write_int(fid, FIFF.FIFF_MNE_COV_KIND, cov['kind'])
write_int(fid, FIFF.FIFF_MNE_COV_DIM, cov['dim'])
if cov['nfree'] > 0:
write_int(fid, FIFF.FIFF_MNE_COV_NFREE, cov['nfree'])
# Channel names
if cov['names'] is not None and len(cov['names']) > 0:
write_name_list(fid, FIFF.FIFF_MNE_ROW_NAMES, cov['names'])
# Data
if cov['diag']:
write_double(fid, FIFF.FIFF_MNE_COV_DIAG, cov['data'])
else:
# Store only lower part of covariance matrix
dim = cov['dim']
mask = np.tril(np.ones((dim, dim), dtype=np.bool)) > 0
vals = cov['data'][mask].ravel()
write_double(fid, FIFF.FIFF_MNE_COV, vals)
# Eigenvalues and vectors if present
if cov['eig'] is not None and cov['eigvec'] is not None:
write_float_matrix(fid, FIFF.FIFF_MNE_COV_EIGENVECTORS, cov['eigvec'])
write_double(fid, FIFF.FIFF_MNE_COV_EIGENVALUES, cov['eig'])
# Projection operator
if cov['projs'] is not None and len(cov['projs']) > 0:
_write_proj(fid, cov['projs'])
# Bad channels
if cov['bads'] is not None and len(cov['bads']) > 0:
start_block(fid, FIFF.FIFFB_MNE_BAD_CHANNELS)
write_name_list(fid, FIFF.FIFF_MNE_CH_NAME_LIST, cov['bads'])
end_block(fid, FIFF.FIFFB_MNE_BAD_CHANNELS)
# estimator method
if 'method' in cov:
write_string(fid, FIFF.FIFF_MNE_COV_METHOD, cov['method'])
# negative log-likelihood score
if 'loglik' in cov:
write_double(
fid, FIFF.FIFF_MNE_COV_SCORE, np.array(cov['loglik']))
# Done!
end_block(fid, FIFF.FIFFB_MNE_COV)
def _apply_scaling_array(data, picks_list, scalings):
"""Scale data type-dependently for estimation."""
scalings = _check_scaling_inputs(data, picks_list, scalings)
if isinstance(scalings, dict):
picks_dict = dict(picks_list)
scalings = [(picks_dict[k], v) for k, v in scalings.items()
if k in picks_dict]
for idx, scaling in scalings:
data[idx, :] *= scaling # F - order
else:
data *= scalings[:, np.newaxis] # F - order
def _undo_scaling_array(data, picks_list, scalings):
scalings = _check_scaling_inputs(data, picks_list, scalings)
if isinstance(scalings, dict):
scalings = dict((k, 1. / v) for k, v in scalings.items())
elif isinstance(scalings, np.ndarray):
scalings = 1. / scalings
return _apply_scaling_array(data, picks_list, scalings)
def _apply_scaling_cov(data, picks_list, scalings):
"""Scale resulting data after estimation."""
scalings = _check_scaling_inputs(data, picks_list, scalings)
scales = None
if isinstance(scalings, dict):
n_channels = len(data)
covinds = list(zip(*picks_list))[1]
assert len(data) == sum(len(k) for k in covinds)
assert list(sorted(np.concatenate(covinds))) == list(range(len(data)))
scales = np.zeros(n_channels)
for ch_t, idx in picks_list:
scales[idx] = scalings[ch_t]
elif isinstance(scalings, np.ndarray):
if len(scalings) != len(data):
raise ValueError('Scaling factors and data are of incompatible '
'shape')
scales = scalings
elif scalings is None:
pass
else:
raise RuntimeError('Arff...')
if scales is not None:
assert np.sum(scales == 0.) == 0
data *= (scales[None, :] * scales[:, None])
def _undo_scaling_cov(data, picks_list, scalings):
scalings = _check_scaling_inputs(data, picks_list, scalings)
if isinstance(scalings, dict):
scalings = dict((k, 1. / v) for k, v in scalings.items())
elif isinstance(scalings, np.ndarray):
scalings = 1. / scalings
return _apply_scaling_cov(data, picks_list, scalings)
def _check_scaling_inputs(data, picks_list, scalings):
"""Aux function."""
rescale_dict_ = dict(mag=1e15, grad=1e13, eeg=1e6)
scalings_ = None
if isinstance(scalings, string_types) and scalings == 'norm':
scalings_ = 1. / _compute_row_norms(data)
elif isinstance(scalings, dict):
rescale_dict_.update(scalings)
scalings_ = rescale_dict_
elif isinstance(scalings, np.ndarray):
scalings_ = scalings
elif scalings is None:
pass
else:
raise NotImplementedError("No way! That's not a rescaling "
'option: %s' % scalings)
return scalings_
def _estimate_rank_meeg_signals(data, info, scalings, tol='auto',
return_singular=False):
"""Estimate rank for M/EEG data.
Parameters
----------
data : np.ndarray of float, shape(n_channels, n_samples)
The M/EEG signals.
info : Info
The measurment info.
scalings : dict | 'norm' | np.ndarray | None
The rescaling method to be applied. If dict, it will override the
following default dict:
dict(mag=1e15, grad=1e13, eeg=1e6)
If 'norm' data will be scaled by channel-wise norms. If array,
pre-specified norms will be used. If None, no scaling will be applied.
tol : float | str
Tolerance. See ``estimate_rank``.
return_singular : bool
If True, also return the singular values that were used
to determine the rank.
Returns
-------
rank : int
Estimated rank of the data.
s : array
If return_singular is True, the singular values that were
thresholded to determine the rank are also returned.
"""
picks_list = _picks_by_type(info)
_apply_scaling_array(data, picks_list, scalings)
if data.shape[1] < data.shape[0]:
ValueError("You've got fewer samples than channels, your "
"rank estimate might be inaccurate.")
out = estimate_rank(data, tol=tol, norm=False,
return_singular=return_singular)
rank = out[0] if isinstance(out, tuple) else out
ch_type = ' + '.join(list(zip(*picks_list))[0])
logger.info('estimated rank (%s): %d' % (ch_type, rank))
_undo_scaling_array(data, picks_list, scalings)
return out
def _estimate_rank_meeg_cov(data, info, scalings, tol='auto',
return_singular=False):
"""Estimate rank of M/EEG covariance data, given the covariance
Parameters
----------
data : np.ndarray of float, shape (n_channels, n_channels)
The M/EEG covariance.
info : Info
The measurment info.
scalings : dict | 'norm' | np.ndarray | None
The rescaling method to be applied. If dict, it will override the
following default dict:
dict(mag=1e12, grad=1e11, eeg=1e5)
If 'norm' data will be scaled by channel-wise norms. If array,
pre-specified norms will be used. If None, no scaling will be applied.
tol : float | str
Tolerance. See ``estimate_rank``.
return_singular : bool
If True, also return the singular values that were used
to determine the rank.
Returns
-------
rank : int
Estimated rank of the data.
s : array
If return_singular is True, the singular values that were
thresholded to determine the rank are also returned.
"""
picks_list = _picks_by_type(info)
scalings = _handle_default('scalings_cov_rank', scalings)
_apply_scaling_cov(data, picks_list, scalings)
if data.shape[1] < data.shape[0]:
ValueError("You've got fewer samples than channels, your "
"rank estimate might be inaccurate.")
out = estimate_rank(data, tol=tol, norm=False,
return_singular=return_singular)
rank = out[0] if isinstance(out, tuple) else out
ch_type = ' + '.join(list(zip(*picks_list))[0])
logger.info('estimated rank (%s): %d' % (ch_type, rank))
_undo_scaling_cov(data, picks_list, scalings)
return out
| jniediek/mne-python | mne/cov.py | Python | bsd-3-clause | 76,115 | [
"Gaussian"
] | 8bdbba1339e341ca5c37cb64badfd99415aecd6b4d6d3c787aafc8e9e0e153af |
"""Module for calculating the electron-phonon coupling in an LCAO basis.
Electron-phonon coupling::
__
\ l + +
H = ) g c c ( a + a ),
el-ph /_ ij i j l l
l,ij
where the electron phonon coupling matrix is given by::
______
l / hbar ___
g = /------- < i | \ / V * e | j > .
ij \/ 2 M w 'u eff l
l
Here, l denotes the vibrational normal mode, w_l and e_l is the frequency and
mass-scaled polarization vector, respectively, M is the effective mass and i, j
atomic orbitals. The coupling can be calculated for both finite and periodic
systems.
In PAW the matrix elements of the derivative of the potential is given by the
sum of the following contributions::
d d ~
< i | -- v | j > = < i | -- v | j>
dP dP
_
\ ~a d . ~a
+ ) < i | p > -- /_\H < p | j >
/_ i dP ij j
a,ij
_
\ d ~a . ~a
+ ) < i | -- p > /_\H < p | j >
/_ dP i ij j
a,ij
_
\ ~a . d ~a
+ ) < i | p > /_\H < -- p | j >
/_ i ij dP j
a,ij
"""
import sys
import cPickle as pickle
from math import pi
from os.path import isfile
import numpy as np
import ase.units as units
from ase.phonons import Displacement
from ase.parallel import rank, barrier
from gpaw.utilities import unpack2
from gpaw.utilities.tools import tri2full
from gpaw.utilities.timing import StepTimer, nulltimer, Timer
from gpaw.lcao.overlap import ManySiteDictionaryWrapper, \
TwoCenterIntegralCalculator
from gpaw.lcao.tightbinding import TightBinding
from gpaw.kpt_descriptor import KPointDescriptor
class ElectronPhononCoupling: # (Displacement):
"""Class for calculating the electron-phonon coupling in an LCAO basis.
The derivative of the effective potential wrt atomic displacements is
obtained from a finite difference approximation to the derivative by doing
a self-consistent calculation for atomic displacements in the +/-
directions. These calculations are carried out in the ``run`` member
function.
The subsequent calculation of the coupling matrix in the basis of atomic
orbitals (or Bloch-sums hereof for periodic systems) is handled by the
``calculate_matrix`` member function.
"""
def __init__(self, atoms, calc=None, supercell=(1, 1, 1), name='elph',
delta=0.01):
"""Init with an instance of class ``Atoms`` and a calculator.
Parameters
----------
atoms: Atoms object
The atoms to work on.
calc: Calculator
Calculator for the supercell calculation.
supercell: tuple
Size of supercell given by the number of repetitions (l, m, n) of
the small unit cell in each direction.
name: str
Name to use for files.
delta: float
Magnitude of displacements.
"""
# Store atoms and calculator
self.atoms = atoms
self.calc = calc
# Displace all atoms in the unit cell by default
self.indices = range(len(atoms))
self.name = name
self.delta = delta
self.N_c = supercell
# Center cell offset
N_c = self.N_c
self.offset = N_c[0] // 2 * (N_c[1] * N_c[2]) + N_c[1] // 2 * N_c[2] \
+ N_c[2] // 2
# Log
self.set_log()
# LCAO calculator
self.calc_lcao = None
# Supercell matrix
self.g_xNNMM = None
def __call__(self, atoms_N):
"""Extract effective potential and projector coefficients."""
# Do calculation
atoms_N.get_potential_energy()
# Get calculator
calc = atoms_N.get_calculator()
# Effective potential (in Hartree) and projector coefficients
Vt_G = calc.hamiltonian.vt_sG[0]
Vt_G = calc.wfs.gd.collect(Vt_G, broadcast=True)
dH_asp = calc.hamiltonian.dH_asp
setups = calc.wfs.setups
nspins = calc.wfs.nspins
gd_comm = calc.wfs.gd.comm
dH_all_asp = {}
for a, setup in enumerate(setups):
ni = setup.ni
nii = ni * (ni + 1) // 2
dH_tmp_sp = np.zeros((nspins, nii))
if a in dH_asp:
dH_tmp_sp[:] = dH_asp[a]
gd_comm.sum(dH_tmp_sp)
dH_all_asp[a] = dH_tmp_sp
return Vt_G, dH_all_asp
def run(self):
"""Run the calculations for the required displacements.
This will do a calculation for 6 displacements per atom, +-x, +-y, and
+-z. Only those calculations that are not already done will be
started. Be aware that an interrupted calculation may produce an empty
file (ending with .pckl), which must be deleted before restarting the
job. Otherwise the calculation for that displacement will not be done.
"""
# Atoms in the supercell -- repeated in the lattice vector directions
# beginning with the last
atoms_N = self.atoms * self.N_c
# Set calculator if provided
assert self.calc is not None, "Provide calculator in __init__ method"
atoms_N.set_calculator(self.calc)
# Do calculation on equilibrium structure
filename = self.name + '.eq.pckl'
if not isfile(filename):
# Wait for all ranks to enter
barrier()
# Create file
if rank == 0:
fd = open(filename, 'w')
fd.close()
# Call __call__
output = self.__call__(atoms_N)
# Write output to file
if rank == 0:
fd = open(filename, 'w')
pickle.dump(output, fd)
sys.stdout.write('Writing %s\n' % filename)
fd.close()
sys.stdout.flush()
# Positions of atoms to be displaced in the center unit cell
N_atoms = len(self.atoms)
offset = N_atoms * self.offset
pos = atoms_N.positions[offset: offset + N_atoms].copy()
# Loop over all displacements
for a in self.indices:
for i in range(3):
for sign in [-1, 1]:
# Filename for atomic displacement
filename = '%s.%d%s%s.pckl' % \
(self.name, a, 'xyz'[i], ' +-'[sign])
# Wait for ranks before checking for file
# barrier()
if isfile(filename):
# Skip if already done
continue
# Wait for ranks
barrier()
if rank == 0:
fd = open(filename, 'w')
fd.close()
# Update atomic positions
atoms_N.positions[offset + a, i] = \
pos[a, i] + sign * self.delta
# Call __call__
output = self.__call__(atoms_N)
# Write output to file
if rank == 0:
fd = open(filename, 'w')
pickle.dump(output, fd)
sys.stdout.write('Writing %s\n' % filename)
fd.close()
sys.stdout.flush()
# Return to initial positions
atoms_N.positions[offset + a, i] = pos[a, i]
def set_lcao_calculator(self, calc):
"""Set LCAO calculator to be used in the matrix element evaluation."""
# Add parameter checks here
# - check that gamma
# - check that no symmetries are used
# - ...
parameters = calc.input_parameters
assert parameters['mode'] == 'lcao', "LCAO mode required."
assert parameters['usesymm'] != True, "Symmetries not supported."
self.calc_lcao = calc
def set_log(self, log=None):
"""Set output log."""
if log is None:
self.timer = nulltimer
elif log == '-':
self.timer = StepTimer(name='EPCM')
else:
self.timer = StepTimer(name='EPCM', out=open(log, 'w'))
def lattice_vectors(self):
"""Return lattice vectors for cell in the supercell."""
# Lattice vectors
R_cN = np.indices(self.N_c).reshape(3, -1)
N_c = np.array(self.N_c)[:, np.newaxis]
# R_cN += N_c // 2
# R_cN %= N_c
R_cN -= N_c // 2
return R_cN
def calculate_supercell_matrix(self, dump=0, name=None, cutoff=None, atoms=None):
"""Calculate matrix elements of the el-ph coupling in the LCAO basis.
This function calculates the matrix elements between LCAOs and local
atomic gradients of the effective potential. The matrix elements are
calculated for the supercell used to obtain finite-difference
approximations to the derivatives of the effective potential wrt to
atomic displacements.
Parameters
----------
dump: int
Dump supercell matrix to pickle file (default: 0).
0: Supercell matrix not saved
1: Supercell matrix saved in a single pickle file.
2: Dump matrix for different gradients in separate files. Useful
for large systems where the total array gets too large.
name: string
User specified name of the generated pickle file(s). If not
provided, the string in the ``name`` attribute is used.
cutoff: float
Apply specified cutoff (default: None).
atoms: Atoms object
Calculate supercell for atoms different from the ones provided in
the ```__init__`` method.
"""
assert self.calc_lcao is not None, "Set LCAO calculator"
# Supercell atoms
if atoms is None:
atoms_N = self.atoms * self.N_c
else:
atoms_N = atoms
# Initialize calculator if required and extract useful quantities
calc = self.calc_lcao
if not hasattr(calc.wfs, 'S_qMM'):
calc.initialize(atoms_N)
calc.initialize_positions(atoms_N)
# Extract useful objects from the calculator
wfs = calc.wfs
gd = calc.wfs.gd
kd = calc.wfs.kd
kpt_u = wfs.kpt_u
setups = wfs.setups
nao = setups.nao
bfs = wfs.basis_functions
dtype = wfs.dtype
spin = 0 # XXX
# Basis info for atoms in reference cell
basis = self.calc_lcao.input_parameters['basis']
niAO_a = [setups[a].niAO for a in range(len(self.atoms))]
M_a = [bfs.M_a[a] for a in range(len(self.atoms))]
# If gamma calculation, overlap with neighboring cell cannot be removed
if kd.gamma:
print "WARNING: Gamma-point calculation."
else:
# Bloch to real-space converter
tb = TightBinding(atoms_N, calc)
self.timer.write_now("Calculating supercell matrix")
self.timer.write_now("Calculating real-space gradients")
# Calculate finite-difference gradients (in Hartree / Bohr)
V1t_xG, dH1_xasp = self.calculate_gradient()
self.timer.write_now("Finished real-space gradients")
# For the contribution from the derivative of the projectors
dP_aqvMi = self.calculate_dP_aqvMi(wfs)
# Equilibrium atomic Hamiltonian matrix (projector coefficients)
dH_asp = pickle.load(open(self.name + '.eq.pckl'))[1]
# Check that the grid is the same as in the calculator
assert np.all(V1t_xG.shape[-3:] == (gd.N_c + gd.pbc_c - 1)), \
"Mismatch in grids."
# Calculate < i k | grad H | j k >, i.e. matrix elements in Bloch basis
# List for supercell matrices;
g_xNNMM = []
self.timer.write_now("Calculating gradient of PAW Hamiltonian")
# Do each cartesian component separately
for x, V1t_G in enumerate(V1t_xG):
# Corresponding atomic and cartesian indices
a = x // 3
v = x % 3
self.timer.write_now("%s-gradient of atom %u" %
(['x','y','z'][v], a))
# Array for different k-point components
g_qMM = np.zeros((len(kpt_u), nao, nao), dtype)
# 1) Gradient of effective potential
self.timer.write_now("Starting gradient of pseudo part")
for kpt in kpt_u:
# Matrix elements
geff_MM = np.zeros((nao, nao), dtype)
bfs.calculate_potential_matrix(V1t_G, geff_MM, q=kpt.q)
tri2full(geff_MM, 'L')
# Insert in array
g_qMM[kpt.q] += geff_MM
self.timer.write_now("Finished gradient of pseudo part")
# 2) Gradient of non-local part (projectors)
self.timer.write_now("Starting gradient of dH^a part")
P_aqMi = calc.wfs.P_aqMi
# 2a) dH^a part has contributions from all other atoms
for kpt in kpt_u:
# Matrix elements
gp_MM = np.zeros((nao, nao), dtype)
dH1_asp = dH1_xasp[x]
for a_, dH1_sp in dH1_asp.items():
dH1_ii = unpack2(dH1_sp[spin])
gp_MM += np.dot(P_aqMi[a_][kpt.q], np.dot(dH1_ii,
P_aqMi[a_][kpt.q].T.conjugate()))
g_qMM[kpt.q] += gp_MM
self.timer.write_now("Finished gradient of dH^a part")
self.timer.write_now("Starting gradient of projectors part")
# 2b) dP^a part has only contributions from the same atoms
dP_qvMi = dP_aqvMi[a]
dH_ii = unpack2(dH_asp[a][spin])
for kpt in kpt_u:
#XXX Sort out the sign here; conclusion -> sign = +1 !
P1HP_MM = +1 * np.dot(dP_qvMi[kpt.q][v], np.dot(dH_ii,
P_aqMi[a][kpt.q].T.conjugate()))
# Matrix elements
gp_MM = P1HP_MM + P1HP_MM.T.conjugate()
g_qMM[kpt.q] += gp_MM
self.timer.write_now("Finished gradient of projectors part")
# Extract R_c=(0, 0, 0) block by Fourier transforming
if kd.gamma or kd.N_c is None:
g_MM = g_qMM[0]
else:
# Convert to array
g_MM = tb.bloch_to_real_space(g_qMM, R_c=(0, 0, 0))[0]
# Reshape to global unit cell indices
N = np.prod(self.N_c)
# Number of basis function in the primitive cell
assert (nao % N) == 0, "Alarm ...!"
nao_cell = nao / N
g_NMNM = g_MM.reshape((N, nao_cell, N, nao_cell))
g_NNMM = g_NMNM.swapaxes(1, 2).copy()
self.timer.write_now("Finished supercell matrix")
if dump != 2:
g_xNNMM.append(g_NNMM)
else:
if name is not None:
fname = '%s.supercell_matrix_x_%2.2u.%s.pckl' % (name, x, basis)
else:
fname = self.name + \
'.supercell_matrix_x_%2.2u.%s.pckl' % (x, basis)
if kd.comm.rank == 0:
fd = open(fname, 'w')
pickle.dump((g_NNMM, M_a, niAO_a), fd, 2)
fd.close()
self.timer.write_now("Finished gradient of PAW Hamiltonian")
if dump != 2:
# Collect gradients in one array
self.g_xNNMM = np.array(g_xNNMM)
# Apply cutoff
if cutoff is not None:
cutoff = float(cutoff)
self.apply_cutoff(self.g_xNNMM, M_a, niAO_a, cutoff)
# Dump to pickle file using binary mode together with basis info
if dump and kd.comm.rank == 0:
if name is not None:
fname = '%s.pckl' % name
else:
fname = self.name + '.supercell_matrix.%s.pckl' % basis
fd = open(fname, 'w')
pickle.dump((self.g_xNNMM, M_a, niAO_a), fd, 2)
fd.close()
def load_supercell_matrix(self, basis=None, name=None, multiple=False,
cutoff=None):
"""Load supercell matrix from pickle file.
Parameters
----------
basis: string
String specifying the LCAO basis used to calculate the supercell
matrix, e.g. dz(dzp).
name: string
User specified name of the pickle file.
multiple: bool
Load each derivative from individual files.
cutoff: float
Zero matrix elements from basis functions located further away from
the atomic gradient than the cutoff.
"""
assert (basis is not None) or (name is not None), \
"Provide basis or name."
if not multiple:
# File name
if name is not None:
fname = name
else:
fname = self.name + '.supercell_matrix.%s.pckl' % basis
fd = open(fname)
self.g_xNNMM, M_a, niAO_a = pickle.load(fd)
fd.close()
else:
g_xNNMM = []
for x in range(len(self.indices)*3):
if name is not None:
fname = name
else:
fname = self.name + \
'.supercell_matrix_x_%2.2u.%s.pckl' % (x, basis)
fd = open(fname, 'r')
g_NNMM, M_a, niAO_a = pickle.load(fd)
fd.close()
g_xNNMM.append(g_NNMM)
self.g_xNNMM = np.array(g_xNNMM)
if cutoff is not None:
cutoff = float(cutoff)
self.apply_cutoff(self.g_xNNMM, M_a, niAO_a, cutoff)
def apply_cutoff(self, g_xNNMM, M_a, niAO_a, r_c):
"""Zero matrix element with basis functions beyond the cutoff."""
# Number of atoms and primitive cells
N_atoms = len(self.indices)
N = np.prod(self.N_c)
nao = g_xNNMM.shape[-1]
# Reshape array
g_avNNMM = g_xNNMM.reshape(N_atoms, 3, N, N, nao, nao)
# Make slices for orbitals on atoms
slice_a = []
for a in range(len(self.atoms)):
start = M_a[a] ;
stop = start + niAO_a[a]
s = slice(start, stop)
slice_a.append(s)
# Lattice vectors
R_cN = self.lattice_vectors()
# Unit cell vectors
cell_vc = self.atoms.cell.transpose()
# Atomic positions in reference cell
pos_av = self.atoms.get_positions()
# Zero elements with a distance to atoms in the reference cell
# larger than the cutoff
for n in range(N):
# Lattice vector to cell
R_v = np.dot(cell_vc, R_cN[:, n])
# Atomic positions in cell
posn_av = pos_av + R_v
for i, a in enumerate(self.indices):
dist_a = np.sqrt(np.sum((pos_av[a] - posn_av)**2, axis=-1))
# Atoms indices where the distance is larger than the cufoff
j_a = np.where(dist_a > r_c)[0]
# Zero elements
for j in j_a:
g_avNNMM[a, :, n, :, slice_a[j], :] = 0.0
g_avNNMM[a, :, :, n, :, slice_a[j]] = 0.0
def coupling(self, kpts, qpts, c_kn, u_ql, omega_ql=None, kpts_from=None):
"""Calculate el-ph couplings in Bloch basis for the electrons.
This function calculates the electron-phonon coupling between the
specified Bloch states, i.e.::
______
mnl / hbar ^
g = /------- < m k + q | e . grad V | n k >
kq \/ 2 M w ql q
ql
In case the ``omega_ql`` keyword argument is not given, the bare matrix
element (in units of eV / Ang) without the sqrt prefactor is returned.
Parameters
----------
kpts: ndarray or tuple.
k-vectors of the Bloch states. When a tuple of integers is given, a
Monkhorst-Pack grid with the specified number of k-points along the
directions of the reciprocal lattice vectors is generated.
qpts: ndarray or tuple.
q-vectors of the phonons.
c_kn: ndarray
Expansion coefficients for the Bloch states. The ordering must be
the same as in the ``kpts`` argument.
u_ql: ndarray
Mass-scaled polarization vectors (in units of 1 / sqrt(amu)) of the
phonons. Again, the ordering must be the same as in the
corresponding ``qpts`` argument.
omega_ql: ndarray
Vibrational frequencies in eV.
kpts_from: list of ints or int
Calculate only the matrix element for the k-vectors specified by
their index in the ``kpts`` argument (default: all).
In short, phonon frequencies and mode vectors must be given in ase units.
"""
assert self.g_xNNMM is not None, "Load supercell matrix."
assert len(c_kn.shape) == 3
assert len(u_ql.shape) == 4
if omega_ql is not None:
assert np.all(u_ql.shape[:2] == omega_ql.shape[:2])
# Use the KPointDescriptor to keep track of the k and q-vectors
kd_kpts = KPointDescriptor(kpts)
kd_qpts = KPointDescriptor(qpts)
# Check that number of k- and q-points agree with the number of Bloch
# functions and polarization vectors
assert kd_kpts.nbzkpts == len(c_kn)
assert kd_qpts.nbzkpts == len(u_ql)
# Include all k-point per default
if kpts_from is None:
kpts_kc = kd_kpts.bzk_kc
kpts_k = range(kd_kpts.nbzkpts)
else:
kpts_kc = kd_kpts.bzk_kc[kpts_from]
if isinstance(kpts_from, int):
kpts_k = list([kpts_from])
else:
kpts_k = list(kpts_from)
# Supercell matrix (real matrix in Hartree / Bohr)
g_xNNMM = self.g_xNNMM
# Number of phonon modes and electronic bands
L = len(u_ql[0])
M = len(c_kn[0])
# Lattice vectors
R_cN = self.lattice_vectors()
# Number of unit cell in supercell
N = np.prod(self.N_c)
# Allocate array for couplings
g_qklnn = np.zeros((kd_qpts.nbzkpts, len(kpts_kc), L, M, M),
dtype=complex)
self.timer.write_now("Calculating coupling matrix elements")
for q, q_c in enumerate(kd_qpts.bzk_kc):
# Find indices of k+q for the k-points
kplusq_k = kd_kpts.find_k_plus_q(q_c, kpts_k=kpts_k)
# Here, ``i`` is counting from 0 and ``k`` is the global index of
# the k-point
for i, (k, k_c) in enumerate(zip(kpts_k, kpts_kc)):
assert np.allclose(k_c + q_c, kd_kpts.bzk_kc[kplusq_k[i]] ), \
(i, k, k_c, q_c, kd_kpts.bzk_kc[kplusq_k[i]])
# assert np.all(k_c + q_c == kd_kpts.bzk_kc[kplusq_k[i]] )
# LCAO coefficient for Bloch states
ck_nM = c_kn[k]
ckplusq_nM = c_kn[kplusq_k[i]]
g_nnNNx = np.dot(ckplusq_nM.conj(),
np.dot(g_xNNMM, ck_nM.T)).swapaxes(1, 4) # .copy()
# Mass scaled polarization vector
u_lx = u_ql[q].reshape(L, 3 * len(self.atoms))
g_lnnNN = np.dot(g_nnNNx, u_lx.T).transpose(4, 0, 1, 2, 3)
# Generate phase factors
phase_NN = np.zeros((N, N), dtype=complex)
for m in range(N):
for n in range(N):
Rm_c = R_cN[:, m]
Rn_c = R_cN[:, n]
phase_NN[m, n] = np.exp(2.j * pi * (
np.dot(k_c, Rm_c - Rn_c) + np.dot(q_c, Rm_c)))
# Multiply phases and sum over unit cells
g_lnn = np.sum(np.sum(g_lnnNN * phase_NN, axis=-1), axis=-1)
g_qklnn[q, i] = g_lnn
# XXX Temp
if np.all(q_c == 0.0):
# These should be real
print g_qklnn[q].imag.min(), g_qklnn[q].imag.max()
self.timer.write_now("Finished calculation of coupling matrix elements")
# Return the bare matrix element if frequencies are not given
if omega_ql is None:
# Convert to eV / Ang
g_qklnn *= units.Hartree / units.Bohr
else:
# Multiply prefactor sqrt(hbar / 2 * M * omega) in units of Bohr
amu = units._amu # atomic mass unit
me = units._me # electron mass
g_qklnn /= np.sqrt(2 * amu / me / units.Hartree * \
omega_ql[:, np.newaxis, :, np.newaxis, np.newaxis])
# Convert to eV
g_qklnn *= units.Hartree
# Return couplings in eV (or eV / Ang)
return g_qklnn
def calculate_gradient(self):
"""Calculate gradient of effective potential and projector coefs.
This function loads the generated pickle files and calculates
finite-difference derivatives.
"""
# Array and dict for finite difference derivatives
V1t_xG = []
dH1_xasp = []
x = 0
for a in self.indices:
for v in range(3):
name = '%s.%d%s' % (self.name, a, 'xyz'[v])
# Potential and atomic density matrix for atomic displacement
try:
Vtm_G, dHm_asp = pickle.load(open(name + '-.pckl'))
Vtp_G, dHp_asp = pickle.load(open(name + '+.pckl'))
except (IOError, EOFError):
raise IOError, "%s(-/+).pckl" % name
# FD derivatives in Hartree / Bohr
V1t_G = (Vtp_G - Vtm_G) / (2 * self.delta / units.Bohr)
V1t_xG.append(V1t_G)
dH1_asp = {}
for atom in dHm_asp.keys():
dH1_asp[atom] = (dHp_asp[atom] - dHm_asp[atom]) / \
(2 * self.delta / units.Bohr)
dH1_xasp.append(dH1_asp)
x += 1
return np.array(V1t_xG), dH1_xasp
def calculate_dP_aqvMi(self, wfs):
"""Overlap between LCAO basis functions and gradient of projectors.
Only the gradient wrt the atomic positions in the reference cell is
computed.
"""
nao = wfs.setups.nao
nq = len(wfs.ibzk_qc)
# Derivatives in reference cell
dP_aqvMi = {}
for atom, setup in zip(self.atoms, wfs.setups):
a = atom.index
dP_aqvMi[a] = np.zeros((nq, 3, nao, setup.ni), wfs.dtype)
# Calculate overlap between basis function and gradient of projectors
# NOTE: the derivative is calculated wrt the atomic position and not
# the real-space coordinate
calc = TwoCenterIntegralCalculator(wfs.ibzk_qc, derivative=True)
expansions = ManySiteDictionaryWrapper(wfs.tci.P_expansions, dP_aqvMi)
calc.calculate(wfs.tci.atompairs, [expansions], [dP_aqvMi])
# Extract derivatives in the reference unit cell
# dP_aqvMi = {}
# for atom in self.atoms:
# dP_aqvMi[atom.index] = dPall_aqvMi[atom.index]
return dP_aqvMi
| ajylee/gpaw-rtxs | gpaw/lcao/electronphonon.py | Python | gpl-3.0 | 29,004 | [
"ASE",
"GPAW"
] | b328655d5ecc96dd619867ad69e2ea24d893f9149d9641e1cf6d596538b628d0 |
#!/usr/bin/env python
# Copyright 2014-2018 The PySCF Developers. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import ctypes
import _ctypes
import numpy
from pyscf import lib
from pyscf.gto.moleintor import make_cintopt, make_loc, ascint3
from pyscf.scf import _vhf
libao2mo = lib.load_library('libao2mo')
def _fpointer(name):
return ctypes.c_void_p(_ctypes.dlsym(libao2mo._handle, name))
class AO2MOpt(object):
def __init__(self, mol, intor, prescreen='CVHFnoscreen', qcondname=None):
intor = ascint3(intor)
self._this = ctypes.POINTER(_vhf._CVHFOpt)()
#print self._this.contents, expect ValueError: NULL pointer access
self._intor = intor
c_atm = numpy.asarray(mol._atm, dtype=numpy.int32, order='C')
c_bas = numpy.asarray(mol._bas, dtype=numpy.int32, order='C')
c_env = numpy.asarray(mol._env, dtype=numpy.double, order='C')
natm = ctypes.c_int(c_atm.shape[0])
nbas = ctypes.c_int(c_bas.shape[0])
self._cintopt = make_cintopt(c_atm, c_bas, c_env, intor)
libao2mo.CVHFinit_optimizer(ctypes.byref(self._this),
c_atm.ctypes.data_as(ctypes.c_void_p), natm,
c_bas.ctypes.data_as(ctypes.c_void_p), nbas,
c_env.ctypes.data_as(ctypes.c_void_p))
self._this.contents.fprescreen = _fpointer(prescreen)
if prescreen != 'CVHFnoscreen' and intor in ('int2e_sph', 'int2e_cart'):
# for int2e_sph, qcondname is 'CVHFsetnr_direct_scf'
ao_loc = make_loc(c_bas, intor)
fsetqcond = getattr(libao2mo, qcondname)
fsetqcond(self._this,
getattr(libao2mo, intor), self._cintopt,
ao_loc.ctypes.data_as(ctypes.c_void_p),
c_atm.ctypes.data_as(ctypes.c_void_p), natm,
c_bas.ctypes.data_as(ctypes.c_void_p), nbas,
c_env.ctypes.data_as(ctypes.c_void_p))
def __del__(self):
libao2mo.CVHFdel_optimizer(ctypes.byref(self._this))
# if out is not None, transform AO to MO in-place
def nr_e1fill(intor, sh_range, atm, bas, env,
aosym='s1', comp=1, ao2mopt=None, out=None):
assert(aosym in ('s4', 's2ij', 's2kl', 's1'))
intor = ascint3(intor)
c_atm = numpy.asarray(atm, dtype=numpy.int32, order='C')
c_bas = numpy.asarray(bas, dtype=numpy.int32, order='C')
c_env = numpy.asarray(env, order='C')
natm = ctypes.c_int(c_atm.shape[0])
nbas = ctypes.c_int(c_bas.shape[0])
ao_loc = make_loc(bas, intor)
nao = ao_loc[-1]
klsh0, klsh1, nkl = sh_range
if aosym in ('s4', 's2ij'):
nao_pair = nao * (nao+1) // 2
else:
nao_pair = nao * nao
out = numpy.ndarray((comp,nkl,nao_pair), buffer=out)
if out.size == 0:
return out
if ao2mopt is not None:
cao2mopt = ao2mopt._this
cintopt = ao2mopt._cintopt
intor = ao2mopt._intor
else:
cao2mopt = lib.c_null_ptr()
cintopt = make_cintopt(c_atm, c_bas, c_env, intor)
cintor = _fpointer(intor)
fdrv = getattr(libao2mo, 'AO2MOnr_e1fill_drv')
fill = _fpointer('AO2MOfill_nr_' + aosym)
fdrv(cintor, fill, out.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(klsh0), ctypes.c_int(klsh1-klsh0),
ctypes.c_int(nkl), ctypes.c_int(comp),
ao_loc.ctypes.data_as(ctypes.c_void_p), cintopt, cao2mopt,
c_atm.ctypes.data_as(ctypes.c_void_p), natm,
c_bas.ctypes.data_as(ctypes.c_void_p), nbas,
c_env.ctypes.data_as(ctypes.c_void_p))
return out
def nr_e1(eri, mo_coeff, orbs_slice, aosym='s1', mosym='s1', out=None):
assert(eri.flags.c_contiguous)
assert(aosym in ('s4', 's2ij', 's2kl', 's1'))
assert(mosym in ('s2', 's1'))
mo_coeff = numpy.asfortranarray(mo_coeff)
assert(mo_coeff.dtype == numpy.double)
nao = mo_coeff.shape[0]
i0, i1, j0, j1 = orbs_slice
icount = i1 - i0
jcount = j1 - j0
ij_count = icount * jcount
if aosym in ('s4', 's2ij'):
if mosym == 's2':
fmmm = _fpointer('AO2MOmmm_nr_s2_s2')
assert(icount == jcount)
ij_count = icount * (icount+1) // 2
elif icount <= jcount:
fmmm = _fpointer('AO2MOmmm_nr_s2_iltj')
else:
fmmm = _fpointer('AO2MOmmm_nr_s2_igtj')
else:
if icount <= jcount:
fmmm = _fpointer('AO2MOmmm_nr_s1_iltj')
else:
fmmm = _fpointer('AO2MOmmm_nr_s1_igtj')
nrow = eri.shape[0]
out = numpy.ndarray((nrow,ij_count), buffer=out)
if out.size == 0:
return out
fdrv = getattr(libao2mo, 'AO2MOnr_e2_drv')
pao_loc = ctypes.POINTER(ctypes.c_void_p)()
c_nbas = ctypes.c_int(0)
ftrans = _fpointer('AO2MOtranse1_nr_' + aosym)
fdrv(ftrans, fmmm,
out.ctypes.data_as(ctypes.c_void_p),
eri.ctypes.data_as(ctypes.c_void_p),
mo_coeff.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(nrow), ctypes.c_int(nao),
(ctypes.c_int*4)(*orbs_slice), pao_loc, c_nbas)
return out
# if out is not None, transform AO to MO in-place
# ao_loc has nbas+1 elements, last element in ao_loc == nao
def nr_e2(eri, mo_coeff, orbs_slice, aosym='s1', mosym='s1', out=None,
ao_loc=None):
assert(eri.flags.c_contiguous)
assert(aosym in ('s4', 's2ij', 's2kl', 's2', 's1'))
assert(mosym in ('s2', 's1'))
mo_coeff = numpy.asfortranarray(mo_coeff)
assert(mo_coeff.dtype == numpy.double)
nao = mo_coeff.shape[0]
k0, k1, l0, l1 = orbs_slice
kc = k1 - k0
lc = l1 - l0
kl_count = kc * lc
if aosym in ('s4', 's2', 's2kl'):
if mosym == 's2':
fmmm = _fpointer('AO2MOmmm_nr_s2_s2')
assert(kc == lc)
kl_count = kc * (kc+1) // 2
elif kc <= lc:
fmmm = _fpointer('AO2MOmmm_nr_s2_iltj')
else:
fmmm = _fpointer('AO2MOmmm_nr_s2_igtj')
else:
if kc <= lc:
fmmm = _fpointer('AO2MOmmm_nr_s1_iltj')
else:
fmmm = _fpointer('AO2MOmmm_nr_s1_igtj')
nrow = eri.shape[0]
out = numpy.ndarray((nrow,kl_count), buffer=out)
if out.size == 0:
return out
if ao_loc is None:
pao_loc = ctypes.POINTER(ctypes.c_void_p)()
c_nbas = ctypes.c_int(0)
ftrans = _fpointer('AO2MOtranse2_nr_' + aosym)
else:
ao_loc = numpy.asarray(ao_loc, dtype=numpy.int32)
c_nbas = ctypes.c_int(ao_loc.shape[0]-1)
pao_loc = ao_loc.ctypes.data_as(ctypes.c_void_p)
ftrans = _fpointer('AO2MOsortranse2_nr_' + aosym)
fdrv = getattr(libao2mo, 'AO2MOnr_e2_drv')
fdrv(ftrans, fmmm,
out.ctypes.data_as(ctypes.c_void_p),
eri.ctypes.data_as(ctypes.c_void_p),
mo_coeff.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(nrow), ctypes.c_int(nao),
(ctypes.c_int*4)(*orbs_slice), pao_loc, c_nbas)
return out
# if out is not None, transform AO to MO in-place
def r_e1(intor, mo_coeff, orbs_slice, sh_range, atm, bas, env,
tao, aosym='s1', comp=1, ao2mopt=None, out=None):
assert(aosym in ('s4', 's2ij', 's2kl', 's1', 'a2ij', 'a2kl', 'a4ij',
'a4kl', 'a4'))
intor = ascint3(intor)
mo_coeff = numpy.asfortranarray(mo_coeff)
i0, i1, j0, j1 = orbs_slice
icount = i1 - i0
jcount = j1 - j0
ij_count = icount * jcount
c_atm = numpy.asarray(atm, dtype=numpy.int32)
c_bas = numpy.asarray(bas, dtype=numpy.int32)
c_env = numpy.asarray(env)
natm = ctypes.c_int(c_atm.shape[0])
nbas = ctypes.c_int(c_bas.shape[0])
klsh0, klsh1, nkl = sh_range
if icount <= jcount:
fmmm = _fpointer('AO2MOmmm_r_iltj')
else:
fmmm = _fpointer('AO2MOmmm_r_igtj')
out = numpy.ndarray((comp,nkl,ij_count), dtype=numpy.complex, buffer=out)
if out.size == 0:
return out
if ao2mopt is not None:
cao2mopt = ao2mopt._this
cintopt = ao2mopt._cintopt
intor = ao2mopt._intor
else:
cao2mopt = lib.c_null_ptr()
cintopt = make_cintopt(c_atm, c_bas, c_env, intor)
cintor = _fpointer(intor)
tao = numpy.asarray(tao, dtype=numpy.int32)
ao_loc = make_loc(bas, 'spinor')
fdrv = getattr(libao2mo, 'AO2MOr_e1_drv')
fill = _fpointer('AO2MOfill_r_' + aosym)
ftrans = _fpointer('AO2MOtranse1_r_' + aosym)
fdrv(cintor, fill, ftrans, fmmm,
out.ctypes.data_as(ctypes.c_void_p),
mo_coeff.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(klsh0), ctypes.c_int(klsh1-klsh0),
ctypes.c_int(nkl), ctypes.c_int(comp),
(ctypes.c_int*4)(*orbs_slice), tao.ctypes.data_as(ctypes.c_void_p),
ao_loc.ctypes.data_as(ctypes.c_void_p), cintopt, cao2mopt,
c_atm.ctypes.data_as(ctypes.c_void_p), natm,
c_bas.ctypes.data_as(ctypes.c_void_p), nbas,
c_env.ctypes.data_as(ctypes.c_void_p))
return out
# if out is not None, transform AO to MO in-place
# ao_loc has nbas+1 elements, last element in ao_loc == nao
def r_e2(eri, mo_coeff, orbs_slice, tao, ao_loc, aosym='s1', out=None):
assert(eri.flags.c_contiguous)
assert(aosym in ('s4', 's2ij', 's2kl', 's1', 'a2ij', 'a2kl', 'a4ij',
'a4kl', 'a4'))
mo_coeff = numpy.asarray(mo_coeff, dtype=numpy.complex128, order='F')
nao = mo_coeff.shape[0]
k0, k1, l0, l1 = orbs_slice
kc = k1 - k0
lc = l1 - l0
kl_count = kc * lc
if kc <= lc:
fmmm = _fpointer('AO2MOmmm_r_iltj')
else:
fmmm = _fpointer('AO2MOmmm_r_igtj')
nrow = eri.shape[0]
out = numpy.ndarray((nrow,kl_count), dtype=numpy.complex128, buffer=out)
if out.size == 0:
return out
tao = numpy.asarray(tao, dtype=numpy.int32)
if ao_loc is None:
c_ao_loc = ctypes.POINTER(ctypes.c_void_p)()
c_nbas = ctypes.c_int(0)
ftrans = _fpointer('AO2MOtranse2_r_' + aosym)
else:
ao_loc = numpy.asarray(ao_loc, dtype=numpy.int32)
c_ao_loc = ao_loc.ctypes.data_as(ctypes.c_void_p)
c_nbas = ctypes.c_int(ao_loc.shape[0]-1)
ftrans = _fpointer('AO2MOsortranse2_r_' + aosym)
fdrv = getattr(libao2mo, 'AO2MOr_e2_drv')
fdrv(ftrans, fmmm,
out.ctypes.data_as(ctypes.c_void_p),
eri.ctypes.data_as(ctypes.c_void_p),
mo_coeff.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(nrow), ctypes.c_int(nao),
(ctypes.c_int*4)(*orbs_slice),
tao.ctypes.data_as(ctypes.c_void_p), c_ao_loc, c_nbas)
return out
| gkc1000/pyscf | pyscf/ao2mo/_ao2mo.py | Python | apache-2.0 | 11,111 | [
"PySCF"
] | e30cdafc399e9a791f961e9866b6491788a22f0cfa874042f525d2dbaaedf3f3 |
'''
Script to extract auxiliary predictors and other raster-based variables for each station.
'''
from twx.db import StationSerialDataDb, CLIMDIV, MASK, TDI
from twx.infill import add_stn_raster_values
from twx.raster import RasterDataset
from twx.utils import TwxConfig
import numpy as np
import os
if __name__ == '__main__':
twx_cfg = TwxConfig(os.getenv('TOPOWX_INI'))
# Extract auxiliary predictors and other raster-based variables
# for each station and add to final serially complete station observation
# netCDF files
# Load new serially complete dbs
stnda_tmin = StationSerialDataDb(twx_cfg.fpath_stndata_nc_serial_tmin,
'tmin', mode='r+')
stnda_tmax = StationSerialDataDb(twx_cfg.fpath_stndata_nc_serial_tmax,
'tmax', mode='r+')
# Monthly Land Skin Temperature Predictors
# Require each station to have a LST value by setting revert_nn=True, force_data_value=True
# This accounts for coastal stations that might not fall within a grid cell that
# has a LST value. MODIS coverage along the coasts is very jagged and incomplete.
path_lst_rasters = os.path.join(twx_cfg.path_rasters, 'lst')
long_name = 'land skin temperature'
units = "C"
# Nighttime LST
print "Adding Nighttime LST values to Tmin stations..."
for mth in np.arange(1, 13):
var_name = 'lst%02d' % mth
print var_name
a_rast = RasterDataset(os.path.join(path_lst_rasters, 'LST_Night.%.2d.tif' % mth))
add_stn_raster_values(stnda_tmin, var_name, long_name, units, a_rast,
revert_nn=True, force_data_value=True)
# Daytime LST
print "Adding Daytime LST values to Tmax stations..."
for mth in np.arange(1, 13):
var_name = 'lst%02d' % mth
print var_name
a_rast = RasterDataset(os.path.join(path_lst_rasters, 'LST_Day.%.2d.tif' % mth))
add_stn_raster_values(stnda_tmax, var_name, long_name, units, a_rast,
revert_nn=True, force_data_value=True)
# Topographic Dissection Index (TDI)
# Unlike LST, TDI coverage is complete along the coasts, so do not set
# force_data_value=True.
var_name = TDI
long_name = 'topographic dissection index'
units = "[3,6,9,12,15] km radius"
a_rast = RasterDataset(os.path.join(twx_cfg.path_rasters, 'tdi.tif'))
# Tmin TDI
print "Adding TDI values to Tmin stations..."
add_stn_raster_values(stnda_tmin, var_name, long_name, units, a_rast, revert_nn=True)
# Tmax TDI
print "Adding TDI values to Tmax stations..."
add_stn_raster_values(stnda_tmax, var_name, long_name, units, a_rast, revert_nn=True)
# Interpolation Mask
var_name = MASK
long_name = 'Interpolation Mask'
units = "0 or 1"
a_rast = RasterDataset(os.path.join(twx_cfg.path_rasters, 'mask.tif'))
a_rast.ndata = 0
# Tmin interpolation mask
print "Adding interpolation mask values to Tmin stations..."
add_stn_raster_values(stnda_tmin, var_name, long_name, units, a_rast, extract_method=0)
# Tmax interpolation mask
print "Adding interpolation mask values to Tmax stations..."
add_stn_raster_values(stnda_tmax, var_name, long_name, units, a_rast, extract_method=0)
# U.S. Climate Divisions
var_name = CLIMDIV
long_name = "U.S. Climate Division"
units = ""
a_rast = RasterDataset(os.path.join(twx_cfg.path_rasters, 'climdiv.tif'))
# Tmin U.S. Climate Divisions
print "Adding U.S. climate division values to Tmin stations..."
add_stn_raster_values(stnda_tmin, var_name, long_name, units, a_rast, extract_method=0)
# Tmax U.S. Climate Divisions
print "Adding U.S. climate division values to Tmax stations..."
add_stn_raster_values(stnda_tmax, var_name, long_name, units, a_rast, extract_method=0)
| jaredwo/topowx | scripts/step19_add_raster_predictors.py | Python | gpl-3.0 | 3,951 | [
"NetCDF"
] | 9b6081b0b9f9a00de9d801a1472609ab70e23091d246503b5023e72bdee56aa7 |
import logging
import urllib
from functools import partial
from django.conf import settings
from django.core.context_processors import csrf
from django.core.exceptions import PermissionDenied
from django.core.urlresolvers import reverse
from django.contrib.auth.models import User
from django.contrib.auth.decorators import login_required
from django.http import Http404, HttpResponse, HttpResponseRedirect
from django.shortcuts import redirect
from mitxmako.shortcuts import render_to_response, render_to_string
from django_future.csrf import ensure_csrf_cookie
from django.views.decorators.cache import cache_control
from courseware import grades
from courseware.access import has_access
from courseware.courses import (get_courses, get_course_with_access,
get_courses_by_university, sort_by_announcement)
import courseware.tabs as tabs
from courseware.masquerade import setup_masquerade
from courseware.model_data import ModelDataCache
from .module_render import toc_for_course, get_module_for_descriptor, get_module
from courseware.models import StudentModule, StudentModuleHistory
from django_comment_client.utils import get_discussion_title
from student.models import UserTestGroup, CourseEnrollment
from util.cache import cache, cache_if_anonymous
from xmodule.modulestore import Location
from xmodule.modulestore.django import modulestore
from xmodule.modulestore.exceptions import InvalidLocationError, ItemNotFoundError, NoPathToItem
from xmodule.modulestore.search import path_to_location
import comment_client
log = logging.getLogger("mitx.courseware")
template_imports = {'urllib': urllib}
def user_groups(user):
"""
TODO (vshnayder): This is not used. When we have a new plan for groups, adjust appropriately.
"""
if not user.is_authenticated():
return []
# TODO: Rewrite in Django
key = 'user_group_names_{user.id}'.format(user=user)
cache_expiration = 60 * 60 # one hour
# Kill caching on dev machines -- we switch groups a lot
group_names = cache.get(key)
if settings.DEBUG:
group_names = None
if group_names is None:
group_names = [u.name for u in UserTestGroup.objects.filter(users=user)]
cache.set(key, group_names, cache_expiration)
return group_names
@ensure_csrf_cookie
@cache_if_anonymous
def courses(request):
"""
Render "find courses" page. The course selection work is done in courseware.courses.
"""
courses = get_courses(request.user, request.META.get('HTTP_HOST'))
courses = sort_by_announcement(courses)
return render_to_response("courseware/courses.html", {'courses': courses})
def render_accordion(request, course, chapter, section, model_data_cache):
"""
Draws navigation bar. Takes current position in accordion as
parameter.
If chapter and section are '' or None, renders a default accordion.
course, chapter, and section are the url_names.
Returns the html string
"""
# grab the table of contents
user = User.objects.prefetch_related("groups").get(id=request.user.id)
request.user = user # keep just one instance of User
toc = toc_for_course(user, request, course, chapter, section, model_data_cache)
context = dict([('toc', toc),
('course_id', course.id),
('csrf', csrf(request)['csrf_token']),
('show_timezone', course.show_timezone)] + template_imports.items())
return render_to_string('courseware/accordion.html', context)
def get_current_child(xmodule):
"""
Get the xmodule.position's display item of an xmodule that has a position and
children. If xmodule has no position or is out of bounds, return the first child.
Returns None only if there are no children at all.
"""
if not hasattr(xmodule, 'position'):
return None
if xmodule.position is None:
pos = 0
else:
# position is 1-indexed.
pos = xmodule.position - 1
children = xmodule.get_display_items()
if 0 <= pos < len(children):
child = children[pos]
elif len(children) > 0:
# Something is wrong. Default to first child
child = children[0]
else:
child = None
return child
def redirect_to_course_position(course_module):
"""
Return a redirect to the user's current place in the course.
If this is the user's first time, redirects to COURSE/CHAPTER/SECTION.
If this isn't the users's first time, redirects to COURSE/CHAPTER,
and the view will find the current section and display a message
about reusing the stored position.
If there is no current position in the course or chapter, then selects
the first child.
"""
urlargs = {'course_id': course_module.descriptor.id}
chapter = get_current_child(course_module)
if chapter is None:
# oops. Something bad has happened.
raise Http404("No chapter found when loading current position in course")
urlargs['chapter'] = chapter.url_name
if course_module.position is not None:
return redirect(reverse('courseware_chapter', kwargs=urlargs))
# Relying on default of returning first child
section = get_current_child(chapter)
if section is None:
raise Http404("No section found when loading current position in course")
urlargs['section'] = section.url_name
return redirect(reverse('courseware_section', kwargs=urlargs))
def save_child_position(seq_module, child_name):
"""
child_name: url_name of the child
"""
for position, c in enumerate(seq_module.get_display_items(), start=1):
if c.url_name == child_name:
# Only save if position changed
if position != seq_module.position:
seq_module.position = position
def check_for_active_timelimit_module(request, course_id, course):
"""
Looks for a timing module for the given user and course that is currently active.
If found, returns a context dict with timer-related values to enable display of time remaining.
"""
context = {}
# TODO (cpennington): Once we can query the course structure, replace this with such a query
timelimit_student_modules = StudentModule.objects.filter(student=request.user, course_id=course_id, module_type='timelimit')
if timelimit_student_modules:
for timelimit_student_module in timelimit_student_modules:
# get the corresponding section_descriptor for the given StudentModel entry:
module_state_key = timelimit_student_module.module_state_key
timelimit_descriptor = modulestore().get_instance(course_id, Location(module_state_key))
timelimit_module_cache = ModelDataCache.cache_for_descriptor_descendents(course.id, request.user,
timelimit_descriptor, depth=None)
timelimit_module = get_module_for_descriptor(request.user, request, timelimit_descriptor,
timelimit_module_cache, course.id, position=None)
if timelimit_module is not None and timelimit_module.category == 'timelimit' and \
timelimit_module.has_begun and not timelimit_module.has_ended:
location = timelimit_module.location
# determine where to go when the timer expires:
if timelimit_descriptor.time_expired_redirect_url is None:
raise Http404("no time_expired_redirect_url specified at this location: {} ".format(timelimit_module.location))
context['time_expired_redirect_url'] = timelimit_descriptor.time_expired_redirect_url
# Fetch the remaining time relative to the end time as stored in the module when it was started.
# This value should be in milliseconds.
remaining_time = timelimit_module.get_remaining_time_in_ms()
context['timer_expiration_duration'] = remaining_time
context['suppress_toplevel_navigation'] = timelimit_descriptor.suppress_toplevel_navigation
return_url = reverse('jump_to', kwargs={'course_id': course_id, 'location': location})
context['timer_navigation_return_url'] = return_url
return context
def update_timelimit_module(user, course_id, model_data_cache, timelimit_descriptor, timelimit_module):
"""
Updates the state of the provided timing module, starting it if it hasn't begun.
Returns dict with timer-related values to enable display of time remaining.
Returns 'timer_expiration_duration' in dict if timer is still active, and not if timer has expired.
"""
context = {}
# determine where to go when the exam ends:
if timelimit_descriptor.time_expired_redirect_url is None:
raise Http404("No time_expired_redirect_url specified at this location: {} ".format(timelimit_module.location))
context['time_expired_redirect_url'] = timelimit_descriptor.time_expired_redirect_url
if not timelimit_module.has_ended:
if not timelimit_module.has_begun:
# user has not started the exam, so start it now.
if timelimit_descriptor.duration is None:
raise Http404("No duration specified at this location: {} ".format(timelimit_module.location))
# The user may have an accommodation that has been granted to them.
# This accommodation information should already be stored in the module's state.
timelimit_module.begin(timelimit_descriptor.duration)
# the exam has been started, either because the student is returning to the
# exam page, or because they have just visited it. Fetch the remaining time relative to the
# end time as stored in the module when it was started.
context['timer_expiration_duration'] = timelimit_module.get_remaining_time_in_ms()
# also use the timed module to determine whether top-level navigation is visible:
context['suppress_toplevel_navigation'] = timelimit_descriptor.suppress_toplevel_navigation
return context
@login_required
@ensure_csrf_cookie
@cache_control(no_cache=True, no_store=True, must_revalidate=True)
def index(request, course_id, chapter=None, section=None,
position=None):
"""
Displays courseware accordion and associated content. If course, chapter,
and section are all specified, renders the page, or returns an error if they
are invalid.
If section is not specified, displays the accordion opened to the right chapter.
If neither chapter or section are specified, redirects to user's most recent
chapter, or the first chapter if this is the user's first visit.
Arguments:
- request : HTTP request
- course_id : course id (str: ORG/course/URL_NAME)
- chapter : chapter url_name (str)
- section : section url_name (str)
- position : position in module, eg of <sequential> module (str)
Returns:
- HTTPresponse
"""
user = User.objects.prefetch_related("groups").get(id=request.user.id)
request.user = user # keep just one instance of User
course = get_course_with_access(user, course_id, 'load', depth=2)
staff_access = has_access(user, course, 'staff')
registered = registered_for_course(course, user)
if not registered:
# TODO (vshnayder): do course instructors need to be registered to see course?
log.debug('User %s tried to view course %s but is not enrolled' % (user, course.location.url()))
return redirect(reverse('about_course', args=[course.id]))
masq = setup_masquerade(request, staff_access)
try:
model_data_cache = ModelDataCache.cache_for_descriptor_descendents(
course.id, user, course, depth=2)
course_module = get_module_for_descriptor(user, request, course, model_data_cache, course.id)
if course_module is None:
log.warning('If you see this, something went wrong: if we got this'
' far, should have gotten a course module for this user')
return redirect(reverse('about_course', args=[course.id]))
if chapter is None:
return redirect_to_course_position(course_module)
context = {
'csrf': csrf(request)['csrf_token'],
'accordion': render_accordion(request, course, chapter, section, model_data_cache),
'COURSE_TITLE': course.display_name_with_default,
'course': course,
'init': '',
'content': '',
'staff_access': staff_access,
'masquerade': masq,
'xqa_server': settings.MITX_FEATURES.get('USE_XQA_SERVER', 'http://xqa:server@content-qa.mitx.mit.edu/xqa')
}
chapter_descriptor = course.get_child_by(lambda m: m.url_name == chapter)
if chapter_descriptor is not None:
save_child_position(course_module, chapter)
else:
raise Http404('No chapter descriptor found with name {}'.format(chapter))
chapter_module = course_module.get_child_by(lambda m: m.url_name == chapter)
if chapter_module is None:
# User may be trying to access a chapter that isn't live yet
if masq=='student': # if staff is masquerading as student be kinder, don't 404
log.debug('staff masq as student: no chapter %s' % chapter)
return redirect(reverse('courseware', args=[course.id]))
raise Http404
if section is not None:
section_descriptor = chapter_descriptor.get_child_by(lambda m: m.url_name == section)
if section_descriptor is None:
# Specifically asked-for section doesn't exist
if masq=='student': # if staff is masquerading as student be kinder, don't 404
log.debug('staff masq as student: no section %s' % section)
return redirect(reverse('courseware', args=[course.id]))
raise Http404
# cdodge: this looks silly, but let's refetch the section_descriptor with depth=None
# which will prefetch the children more efficiently than doing a recursive load
section_descriptor = modulestore().get_instance(course.id, section_descriptor.location, depth=None)
# Load all descendants of the section, because we're going to display its
# html, which in general will need all of its children
section_model_data_cache = ModelDataCache.cache_for_descriptor_descendents(
course_id, user, section_descriptor, depth=None)
section_module = get_module(request.user, request,
section_descriptor.location,
section_model_data_cache, course_id, position, depth=None)
if section_module is None:
# User may be trying to be clever and access something
# they don't have access to.
raise Http404
# Save where we are in the chapter
save_child_position(chapter_module, section)
# check here if this section *is* a timed module.
if section_module.category == 'timelimit':
timer_context = update_timelimit_module(user, course_id, student_module_cache,
section_descriptor, section_module)
if 'timer_expiration_duration' in timer_context:
context.update(timer_context)
else:
# if there is no expiration defined, then we know the timer has expired:
return HttpResponseRedirect(timer_context['time_expired_redirect_url'])
else:
# check here if this page is within a course that has an active timed module running. If so, then
# add in the appropriate timer information to the rendering context:
context.update(check_for_active_timelimit_module(request, course_id, course))
context['content'] = section_module.get_html()
else:
# section is none, so display a message
prev_section = get_current_child(chapter_module)
if prev_section is None:
# Something went wrong -- perhaps this chapter has no sections visible to the user
raise Http404
prev_section_url = reverse('courseware_section', kwargs={'course_id': course_id,
'chapter': chapter_descriptor.url_name,
'section': prev_section.url_name})
context['content'] = render_to_string('courseware/welcome-back.html',
{'course': course,
'chapter_module': chapter_module,
'prev_section': prev_section,
'prev_section_url': prev_section_url})
result = render_to_response('courseware/courseware.html', context)
except Exception as e:
if isinstance(e, Http404):
# let it propagate
raise
# In production, don't want to let a 500 out for any reason
if settings.DEBUG:
raise
else:
log.exception("Error in index view: user={user}, course={course},"
" chapter={chapter} section={section}"
"position={position}".format(
user=user,
course=course,
chapter=chapter,
section=section,
position=position
))
try:
result = render_to_response('courseware/courseware-error.html',
{'staff_access': staff_access,
'course': course})
except:
# Let the exception propagate, relying on global config to at
# at least return a nice error message
log.exception("Error while rendering courseware-error page")
raise
return result
@ensure_csrf_cookie
def jump_to(request, course_id, location):
"""
Show the page that contains a specific location.
If the location is invalid or not in any class, return a 404.
Otherwise, delegates to the index view to figure out whether this user
has access, and what they should see.
"""
# Complain if the location isn't valid
try:
location = Location(location)
except InvalidLocationError:
raise Http404("Invalid location")
# Complain if there's not data for this location
try:
(course_id, chapter, section, position) = path_to_location(modulestore(), course_id, location)
except ItemNotFoundError:
raise Http404("No data at this location: {0}".format(location))
except NoPathToItem:
raise Http404("This location is not in any class: {0}".format(location))
# choose the appropriate view (and provide the necessary args) based on the
# args provided by the redirect.
# Rely on index to do all error handling and access control.
if chapter is None:
return redirect('courseware', course_id=course_id)
elif section is None:
return redirect('courseware_chapter', course_id=course_id, chapter=chapter)
elif position is None:
return redirect('courseware_section', course_id=course_id, chapter=chapter, section=section)
else:
return redirect('courseware_position', course_id=course_id, chapter=chapter, section=section, position=position)
@ensure_csrf_cookie
def course_info(request, course_id):
"""
Display the course's info.html, or 404 if there is no such course.
Assumes the course_id is in a valid format.
"""
course = get_course_with_access(request.user, course_id, 'load')
staff_access = has_access(request.user, course, 'staff')
masq = setup_masquerade(request, staff_access) # allow staff to toggle masquerade on info page
return render_to_response('courseware/info.html', {'request': request, 'course_id': course_id, 'cache': None,
'course': course, 'staff_access': staff_access, 'masquerade': masq})
@ensure_csrf_cookie
def static_tab(request, course_id, tab_slug):
"""
Display the courses tab with the given name.
Assumes the course_id is in a valid format.
"""
course = get_course_with_access(request.user, course_id, 'load')
tab = tabs.get_static_tab_by_slug(course, tab_slug)
if tab is None:
raise Http404
contents = tabs.get_static_tab_contents(
request,
course,
tab
)
if contents is None:
raise Http404
staff_access = has_access(request.user, course, 'staff')
return render_to_response('courseware/static_tab.html',
{'course': course,
'tab': tab,
'tab_contents': contents,
'staff_access': staff_access, })
# TODO arjun: remove when custom tabs in place, see courseware/syllabus.py
@ensure_csrf_cookie
def syllabus(request, course_id):
"""
Display the course's syllabus.html, or 404 if there is no such course.
Assumes the course_id is in a valid format.
"""
course = get_course_with_access(request.user, course_id, 'load')
staff_access = has_access(request.user, course, 'staff')
return render_to_response('courseware/syllabus.html', {'course': course,
'staff_access': staff_access, })
def registered_for_course(course, user):
"""
Return CourseEnrollment if user is registered for course, else False
"""
if user is None:
return False
if user.is_authenticated():
return CourseEnrollment.objects.filter(user=user, course_id=course.id).exists()
else:
return False
@ensure_csrf_cookie
@cache_if_anonymous
def course_about(request, course_id):
if settings.MITX_FEATURES.get('ENABLE_MKTG_SITE', False):
raise Http404
course = get_course_with_access(request.user, course_id, 'see_exists')
registered = registered_for_course(course, request.user)
if has_access(request.user, course, 'load'):
course_target = reverse('info', args=[course.id])
else:
course_target = reverse('about_course', args=[course.id])
show_courseware_link = (has_access(request.user, course, 'load') or
settings.MITX_FEATURES.get('ENABLE_LMS_MIGRATION'))
return render_to_response('courseware/course_about.html',
{'course': course,
'registered': registered,
'course_target': course_target,
'show_courseware_link': show_courseware_link})
@ensure_csrf_cookie
@cache_if_anonymous
def mktg_course_about(request, course_id):
try:
course = get_course_with_access(request.user, course_id, 'see_exists')
except (ValueError, Http404) as e:
# if a course does not exist yet, display a coming
# soon button
return render_to_response('courseware/mktg_coming_soon.html',
{'course_id': course_id})
registered = registered_for_course(course, request.user)
if has_access(request.user, course, 'load'):
course_target = reverse('info', args=[course.id])
else:
course_target = reverse('about_course', args=[course.id])
allow_registration = has_access(request.user, course, 'enroll')
show_courseware_link = (has_access(request.user, course, 'load') or
settings.MITX_FEATURES.get('ENABLE_LMS_MIGRATION'))
return render_to_response('courseware/mktg_course_about.html',
{'course': course,
'registered': registered,
'allow_registration': allow_registration,
'course_target': course_target,
'show_courseware_link': show_courseware_link})
@ensure_csrf_cookie
@cache_if_anonymous
def static_university_profile(request, org_id):
"""
Return the profile for the particular org_id that does not have any courses.
"""
# Redirect to the properly capitalized org_id
last_path = request.path.split('/')[-1]
if last_path != org_id:
return redirect('static_university_profile', org_id=org_id)
# Render template
template_file = "university_profile/{0}.html".format(org_id).lower()
context = dict(courses=[], org_id=org_id)
return render_to_response(template_file, context)
@ensure_csrf_cookie
@cache_if_anonymous
def university_profile(request, org_id):
"""
Return the profile for the particular org_id. 404 if it's not valid.
"""
virtual_orgs_ids = settings.VIRTUAL_UNIVERSITIES
meta_orgs = getattr(settings, 'META_UNIVERSITIES', {})
# Get all the ids associated with this organization
all_courses = modulestore().get_courses()
valid_orgs_ids = set(c.org for c in all_courses)
valid_orgs_ids.update(virtual_orgs_ids + meta_orgs.keys())
if org_id not in valid_orgs_ids:
raise Http404("University Profile not found for {0}".format(org_id))
# Grab all courses for this organization(s)
org_ids = set([org_id] + meta_orgs.get(org_id, []))
org_courses = []
domain = request.META.get('HTTP_HOST')
for key in org_ids:
cs = get_courses_by_university(request.user, domain=domain)[key]
org_courses.extend(cs)
org_courses = sort_by_announcement(org_courses)
context = dict(courses=org_courses, org_id=org_id)
template_file = "university_profile/{0}.html".format(org_id).lower()
return render_to_response(template_file, context)
def render_notifications(request, course, notifications):
context = {
'notifications': notifications,
'get_discussion_title': partial(get_discussion_title, request=request, course=course),
'course': course,
}
return render_to_string('courseware/notifications.html', context)
@login_required
def news(request, course_id):
course = get_course_with_access(request.user, course_id, 'load')
notifications = comment_client.get_notifications(request.user.id)
context = {
'course': course,
'content': render_notifications(request, course, notifications),
}
return render_to_response('courseware/news.html', context)
@login_required
@cache_control(no_cache=True, no_store=True, must_revalidate=True)
def progress(request, course_id, student_id=None):
""" User progress. We show the grade bar and every problem score.
Course staff are allowed to see the progress of students in their class.
"""
course = get_course_with_access(request.user, course_id, 'load', depth=None)
staff_access = has_access(request.user, course, 'staff')
if student_id is None or student_id == request.user.id:
# always allowed to see your own profile
student = request.user
else:
# Requesting access to a different student's profile
if not staff_access:
raise Http404
student = User.objects.get(id=int(student_id))
# NOTE: To make sure impersonation by instructor works, use
# student instead of request.user in the rest of the function.
# The pre-fetching of groups is done to make auth checks not require an
# additional DB lookup (this kills the Progress page in particular).
student = User.objects.prefetch_related("groups").get(id=student.id)
model_data_cache = ModelDataCache.cache_for_descriptor_descendents(
course_id, student, course, depth=None)
courseware_summary = grades.progress_summary(student, request, course,
model_data_cache)
grade_summary = grades.grade(student, request, course, model_data_cache)
if courseware_summary is None:
#This means the student didn't have access to the course (which the instructor requested)
raise Http404
context = {'course': course,
'courseware_summary': courseware_summary,
'grade_summary': grade_summary,
'staff_access': staff_access,
'student': student,
}
context.update()
return render_to_response('courseware/progress.html', context)
@login_required
def submission_history(request, course_id, student_username, location):
"""Render an HTML fragment (meant for inclusion elsewhere) that renders a
history of all state changes made by this user for this problem location.
Right now this only works for problems because that's all
StudentModuleHistory records.
"""
course = get_course_with_access(request.user, course_id, 'load')
staff_access = has_access(request.user, course, 'staff')
# Permission Denied if they don't have staff access and are trying to see
# somebody else's submission history.
if (student_username != request.user.username) and (not staff_access):
raise PermissionDenied
try:
student = User.objects.get(username=student_username)
student_module = StudentModule.objects.get(course_id=course_id,
module_state_key=location,
student_id=student.id)
except User.DoesNotExist:
return HttpResponse("User {0} does not exist.".format(student_username))
except StudentModule.DoesNotExist:
return HttpResponse("{0} has never accessed problem {1}"
.format(student_username, location))
history_entries = StudentModuleHistory.objects \
.filter(student_module=student_module).order_by('-id')
# If no history records exist, let's force a save to get history started.
if not history_entries:
student_module.save()
history_entries = StudentModuleHistory.objects \
.filter(student_module=student_module).order_by('-id')
context = {
'history_entries': history_entries,
'username': student.username,
'location': location,
'course_id': course_id
}
return render_to_response('courseware/submission_history.html', context)
| elimence/edx-platform | lms/djangoapps/courseware/views.py | Python | agpl-3.0 | 30,853 | [
"VisIt"
] | 8e53f2743e4865b0b706e41caf78c4bfe36414f07e9eaf60dd47e6c65ed69e28 |
# -*- coding: utf-8 -*-
"""
/***************************************************************************
QAD Quantum Aided Design plugin
comando ROTATE per ruotare oggetti
-------------------
begin : 2013-09-27
copyright : iiiii
email : hhhhh
developers : bbbbb aaaaa ggggg
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
"""
# Import the PyQt and QGIS libraries
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from qgis.core import *
from qad_rotate_maptool import *
from qad_generic_cmd import QadCommandClass
from qad_msg import QadMsg
from qad_getpoint import *
from qad_textwindow import *
from qad_ssget_cmd import QadSSGetClass
from qad_entity import *
import qad_utils
import qad_layer
import qad_label
from qad_dim import *
# Classe che gestisce il comando RUOTA
class QadROTATECommandClass(QadCommandClass):
def instantiateNewCmd(self):
""" istanzia un nuovo comando dello stesso tipo """
return QadROTATECommandClass(self.plugIn)
def getName(self):
return QadMsg.translate("Command_list", "ROTATE")
def getEnglishName(self):
return "ROTATE"
def connectQAction(self, action):
QObject.connect(action, SIGNAL("triggered()"), self.plugIn.runROTATECommand)
def getIcon(self):
return QIcon(":/plugins/qad/icons/rotate.png")
def getNote(self):
# impostare le note esplicative del comando
return QadMsg.translate("Command_ROTATE", "Rotates objects around a base point.")
def __init__(self, plugIn):
QadCommandClass.__init__(self, plugIn)
self.SSGetClass = QadSSGetClass(plugIn)
self.SSGetClass.onlyEditableLayers = True
self.entitySet = QadEntitySet()
self.basePt = None
self.copyFeatures = False
self.Pt1ReferenceAng = None
self.ReferenceAng = 0
self.Pt1NewAng = None
def __del__(self):
QadCommandClass.__del__(self)
del self.SSGetClass
def getPointMapTool(self, drawMode = QadGetPointDrawModeEnum.NONE):
if self.step == 0: # quando si é in fase di selezione entità
return self.SSGetClass.getPointMapTool()
else:
if (self.plugIn is not None):
if self.PointMapTool is None:
self.PointMapTool = Qad_rotate_maptool(self.plugIn)
return self.PointMapTool
else:
return None
def getCurrentContextualMenu(self):
if self.step == 0: # quando si é in fase di selezione entità
return self.SSGetClass.getCurrentContextualMenu()
else:
return self.contextualMenu
#============================================================================
# rotate
#============================================================================
def rotate(self, f, basePt, angle, rotFldName, layerEntitySet, entitySet):
# verifico se l'entità appartiene ad uno stile di quotatura
dimEntity = QadDimStyles.getDimEntity(layerEntitySet.layer, f.id())
if dimEntity is None:
# ruoto la feature e la rimuovo da entitySet (é la prima)
f.setGeometry(qad_utils.rotateQgsGeometry(f.geometry(), basePt, angle))
if len(rotFldName) > 0:
rotValue = f.attribute(rotFldName)
# a volte vale None e a volte null (vai a capire...)
rotValue = 0 if rotValue is None or isinstance(rotValue, QPyNullVariant) else qad_utils.toRadians(rotValue) # la rotazione é in gradi nel campo della feature
rotValue = rotValue + angle
f.setAttribute(rotFldName, qad_utils.toDegrees(qad_utils.normalizeAngle(rotValue)))
if self.copyFeatures == False:
# plugIn, layer, feature, refresh, check_validity
if qad_layer.updateFeatureToLayer(self.plugIn, layerEntitySet.layer, f, False, False) == False:
self.plugIn.destroyEditCommand()
return False
else:
# plugIn, layer, features, coordTransform, refresh, check_validity
if qad_layer.addFeatureToLayer(self.plugIn, layerEntitySet.layer, f, None, False, False) == False:
self.plugIn.destroyEditCommand()
return False
del layerEntitySet.featureIds[0]
else:
# ruoto la quota e la rimuovo da entitySet
dimEntitySet = dimEntity.getEntitySet()
if self.copyFeatures == False:
if dimEntity.deleteToLayers(self.plugIn) == False:
return False
newDimEntity = QadDimEntity(dimEntity) # la copio
newDimEntity.rotate(basePt, angle)
if newDimEntity.addToLayers(self.plugIn) == False:
return False
entitySet.subtract(dimEntitySet)
return True
def RotateGeoms(self, angle):
# copio entitySet
entitySet = QadEntitySet(self.entitySet)
self.plugIn.beginEditCommand("Feature rotated", entitySet.getLayerList())
for layerEntitySet in entitySet.layerEntitySetList:
layer = layerEntitySet.layer
transformedBasePt = self.mapToLayerCoordinates(layer, self.basePt)
rotFldName = ""
if qad_layer.isTextLayer(layer):
# se la rotazione dipende da un solo campo
rotFldNames = qad_label.get_labelRotationFieldNames(layer)
if len(rotFldNames) == 1 and len(rotFldNames[0]) > 0:
rotFldName = rotFldNames[0]
elif qad_layer.isSymbolLayer(layer):
rotFldName = qad_layer.get_symbolRotationFieldName(layer)
while len(layerEntitySet.featureIds) > 0:
featureId = layerEntitySet.featureIds[0]
f = layerEntitySet.getFeature(featureId)
if self.rotate(f, transformedBasePt, angle, rotFldName, layerEntitySet, entitySet) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
def waitForRotation(self):
# imposto il map tool
self.getPointMapTool().setMode(Qad_rotate_maptool_ModeEnum.BASE_PT_KNOWN_ASK_FOR_ROTATION_PT)
keyWords = QadMsg.translate("Command_ROTATE", "Copy") + "/" + \
QadMsg.translate("Command_ROTATE", "Reference")
prompt = QadMsg.translate("Command_ROTATE", "Specify rotation angle or [{0}] <{1}>: ").format(keyWords, \
str(qad_utils.toDegrees(self.plugIn.lastRot)))
englishKeyWords = "Copy" + "/" + "Reference"
keyWords += "_" + englishKeyWords
# si appresta ad attendere un punto, un numero reale o enter o una parola chiave
# msg, inputType, default, keyWords, nessun controllo
self.waitFor(prompt, QadInputTypeEnum.POINT2D | QadInputTypeEnum.FLOAT | QadInputTypeEnum.KEYWORDS, \
self.plugIn.lastRot, \
keyWords, QadInputModeEnum.NONE)
self.step = 3
def waitForReferenceRot(self):
# imposto il map tool
self.getPointMapTool().setMode(Qad_rotate_maptool_ModeEnum.ASK_FOR_FIRST_PT_REFERENCE_ANG)
msg = QadMsg.translate("Command_ROTATE", "Specify reference angle <{0}>: ")
# si appresta ad attendere un punto o enter o una parola chiave
# msg, inputType, default, keyWords, nessun controllo
self.waitFor(msg.format(str(qad_utils.toDegrees(self.plugIn.lastReferenceRot))), \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.FLOAT, \
self.plugIn.lastReferenceRot, \
"")
self.step = 4
def waitForNewReferenceRot(self):
# imposto il map tool
self.getPointMapTool().setMode(Qad_rotate_maptool_ModeEnum.BASE_PT_KNOWN_ASK_FOR_NEW_ROTATION_PT)
keyWords = QadMsg.translate("Command_ROTATE", "Points")
if self.plugIn.lastNewReferenceRot == 0:
angle = self.plugIn.lastRot
else:
angle = self.plugIn.lastNewReferenceRot
prompt = QadMsg.translate("Command_ROTATE", "Specify new angle or [{0}] <{1}>: ").format(keyWords, str(qad_utils.toDegrees(angle)))
englishKeyWords = "Points"
keyWords += "_" + englishKeyWords
# si appresta ad attendere un punto o enter o una parola chiave
# msg, inputType, default, keyWords, nessun controllo
self.waitFor(prompt, \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.FLOAT | QadInputTypeEnum.KEYWORDS, \
angle, \
keyWords)
self.step = 6
def run(self, msgMapTool = False, msg = None):
if self.plugIn.canvas.mapSettings().destinationCrs().geographicFlag():
self.showMsg(QadMsg.translate("QAD", "\nThe coordinate reference system of the project must be a projected coordinate system.\n"))
return True # fine comando
#=========================================================================
# RICHIESTA SELEZIONE OGGETTI
if self.step == 0: # inizio del comando
if self.SSGetClass.run(msgMapTool, msg) == True:
# selezione terminata
self.step = 1
self.getPointMapTool().refreshSnapType() # aggiorno lo snapType che può essere variato dal maptool di selezione entità
return self.run(msgMapTool, msg)
#=========================================================================
# RUOTA OGGETTI
elif self.step == 1:
self.entitySet.set(self.SSGetClass.entitySet)
if self.entitySet.count() == 0:
return True # fine comando
# imposto il map tool
self.getPointMapTool().setMode(Qad_rotate_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_BASE_PT)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_ROTATE", "Specify base point: "))
self.step = 2
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PUNTO BASE (da step = 1)
elif self.step == 2: # dopo aver atteso un punto o un numero reale si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
self.basePt = QgsPoint(value)
self.getPointMapTool().basePt = self.basePt
self.getPointMapTool().entitySet.set(self.entitySet)
# si appresta ad attendere l'angolo di rotazione
self.waitForRotation()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA SECONDO PUNTO PER ANGOLO ROTAZIONE (da step = 2)
elif self.step == 3: # dopo aver atteso un punto o un numero reale si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
if type(value) == unicode:
if value == QadMsg.translate("Command_ROTATE", "Copy") or value == "Copy":
self.copyFeatures = True
self.showMsg(QadMsg.translate("Command_ROTATE", "\nRotation of a copy of the selected objects."))
# si appresta ad attendere l'angolo di rotazione
self.waitForRotation()
elif value == QadMsg.translate("Command_ROTATE", "Reference") or value == "Reference":
# si appresta ad attendere l'angolo di riferimento
self.waitForReferenceRot()
elif type(value) == QgsPoint or type(value) == float: # se é stato inserito l'angolo di rotazione
if type(value) == QgsPoint: # se é stato inserito l'angolo di rotazione con un punto
angle = qad_utils.getAngleBy2Pts(self.basePt, value)
else:
angle = qad_utils.toRadians(value)
self.plugIn.setLastRot(angle)
self.RotateGeoms(angle)
return True # fine comando
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PRIMO PUNTO PER ANGOLO ROTAZIONE DI RIFERIMENTO (da step = 3)
elif self.step == 4: # dopo aver atteso un punto o un numero reale si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
if type(value) == float: # se é stato inserito l'angolo di rotazione
self.ReferenceAng = qad_utils.toRadians(value)
self.getPointMapTool().ReferenceAng = self.ReferenceAng
# si appresta ad attendere il nuovo angolo
self.waitForNewReferenceRot()
elif type(value) == QgsPoint: # se é stato inserito l'angolo di rotazione con un punto
self.Pt1ReferenceAng = QgsPoint(value)
self.getPointMapTool().Pt1ReferenceAng = self.Pt1ReferenceAng
# imposto il map tool
self.getPointMapTool().setMode(Qad_rotate_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT_REFERENCE_ANG)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_ROTATE", "Specify second point: "))
self.step = 5
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA SECONDO PUNTO PER ANGOLO ROTAZIONE DI RIFERIMENTO (da step = 4)
elif self.step == 5: # dopo aver atteso un punto o un numero reale si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
angle = qad_utils.getAngleBy2Pts(self.Pt1ReferenceAng, value)
self.ReferenceAng = angle
self.getPointMapTool().ReferenceAng = self.ReferenceAng
# si appresta ad attendere il nuovo angolo
self.waitForNewReferenceRot()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA SECONDO PUNTO PER NUOVO ANGOLO ROTAZIONE (da step = 4 e 5)
elif self.step == 6: # dopo aver atteso un punto o un numero reale si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
if type(value) == unicode:
if value == QadMsg.translate("Command_ROTATE", "Points") or value == "Points":
# imposto il map tool
self.getPointMapTool().setMode(Qad_rotate_maptool_ModeEnum.ASK_FOR_FIRST_NEW_ROTATION_PT)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_ROTATE", "Specify first point: "))
self.step = 7
elif type(value) == QgsPoint or type(value) == float: # se é stato inserito l'angolo di rotazione
if type(value) == QgsPoint: # se é stato inserito l'angolo di rotazione con un punto
angle = qad_utils.getAngleBy2Pts(self.basePt, value)
else:
angle = qad_utils.toRadians(value)
angle = angle - self.ReferenceAng
self.plugIn.setLastRot(angle)
self.RotateGeoms(angle)
return True # fine comando
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PRIMO PUNTO PER NUOVO ANGOLO ROTAZIONE (da step = 6)
elif self.step == 7: # dopo aver atteso un punto o un numero reale si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
self.Pt1NewAng = value
# imposto il map tool
self.getPointMapTool().Pt1NewAng = self.Pt1NewAng
self.getPointMapTool().setMode(Qad_rotate_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_NEW_ROTATION_PT)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_ROTATE", "Specify second point: "))
self.step = 8
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA SECONDO PUNTO PER NUOVO ANGOLO ROTAZIONE (da step = 7)
elif self.step == 8: # dopo aver atteso un punto o un numero reale si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
angle = qad_utils.getAngleBy2Pts(self.Pt1NewAng, value)
angle = angle - self.ReferenceAng
self.plugIn.setLastRot(angle)
self.RotateGeoms(angle)
return True # fine comando
# Classe che gestisce il comando ROTATE per i grip
class QadGRIPROTATECommandClass(QadCommandClass):
def instantiateNewCmd(self):
""" istanzia un nuovo comando dello stesso tipo """
return QadGRIPROTATECommandClass(self.plugIn)
def __init__(self, plugIn):
QadCommandClass.__init__(self, plugIn)
self.entitySet = QadEntitySet()
self.basePt = QgsPoint()
self.skipToNextGripCommand = False
self.copyEntities = False
self.nOperationsToUndo = 0
self.Pt1ReferenceAng = None
self.ReferenceAng = 0
def __del__(self):
QadCommandClass.__del__(self)
def getPointMapTool(self, drawMode = QadGetPointDrawModeEnum.NONE):
if (self.plugIn is not None):
if self.PointMapTool is None:
self.PointMapTool = Qad_rotate_maptool(self.plugIn)
return self.PointMapTool
else:
return None
#============================================================================
# setSelectedEntityGripPoints
#============================================================================
def setSelectedEntityGripPoints(self, entitySetGripPoints):
# lista delle entityGripPoint con dei grip point selezionati
self.entitySet.clear()
for entityGripPoints in entitySetGripPoints.entityGripPoints:
self.entitySet.addEntity(entityGripPoints.entity)
self.getPointMapTool().entitySet.set(self.entitySet)
#============================================================================
# rotate
#============================================================================
def rotate(self, entity, basePt, angle, rotFldName):
# entity = entità da ruotare
# basePt = punto base
# angle = angolo di rotazione in gradi
# rotFldName = campo della tabella che memorizza la rotazione
# verifico se l'entità appartiene ad uno stile di quotatura
if entity.whatIs() == "ENTITY":
f = entity.getFeature()
# ruoto l'entità
f.setGeometry(qad_utils.rotateQgsGeometry(entity.getGeometry(), basePt, angle))
if len(rotFldName) > 0:
rotValue = f.attribute(rotFldName)
# a volte vale None e a volte null (vai a capire...)
rotValue = 0 if rotValue is None or isinstance(rotValue, QPyNullVariant) else qad_utils.toRadians(rotValue) # la rotazione é in gradi nel campo della feature
rotValue = rotValue + angle
f.setAttribute(rotFldName, qad_utils.toDegrees(qad_utils.normalizeAngle(rotValue)))
if self.copyEntities == False:
# plugIn, layer, feature, refresh, check_validity
if qad_layer.updateFeatureToLayer(self.plugIn, entity.layer, f, False, False) == False:
return False
else:
# plugIn, layer, features, coordTransform, refresh, check_validity
if qad_layer.addFeatureToLayer(self.plugIn, entity.layer, f, None, False, False) == False:
return False
elif entity.whatIs() == "DIMENTITY":
# stiro la quota
if self.copyEntities == False:
if entity.deleteToLayers(self.plugIn) == False:
return False
newDimEntity = QadDimEntity(entity) # la copio
newDimEntity.rotate(basePt, angle)
if newDimEntity.addToLayers(self.plugIn) == False:
return False
return True
#============================================================================
# rotateFeatures
#============================================================================
def rotateFeatures(self, angle):
entity = QadEntity()
self.plugIn.beginEditCommand("Feature rotated", self.entitySet.getLayerList())
dimElaboratedList = [] # lista delle quotature già elaborate
for layerEntitySet in self.entitySet.layerEntitySetList:
layer = layerEntitySet.layer
transformedBasePt = self.mapToLayerCoordinates(layer, self.basePt)
rotFldName = ""
if qad_layer.isTextLayer(layer):
# se la rotazione dipende da un solo campo
rotFldNames = qad_label.get_labelRotationFieldNames(layer)
if len(rotFldNames) == 1 and len(rotFldNames[0]) > 0:
rotFldName = rotFldNames[0]
elif qad_layer.isSymbolLayer(layer):
# se la rotazione dipende da un campo
rotFldName = qad_layer.get_symbolRotationFieldName(layer)
for featureId in layerEntitySet.featureIds:
entity.set(layer, featureId)
# verifico se l'entità appartiene ad uno stile di quotatura
dimEntity = QadDimStyles.getDimEntity(entity)
if dimEntity is None:
if self.rotate(entity, transformedBasePt, angle, rotFldName) == False:
self.plugIn.destroyEditCommand()
return
else:
found = False
for dimElaborated in dimElaboratedList:
if dimElaborated == dimEntity:
found = True
if found == False: # quota non ancora elaborata
dimElaboratedList.append(dimEntity)
# basePt va espresso in map cooridnate
if self.rotate(dimEntity, self.basePt, angle, rotFldName) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
self.nOperationsToUndo = self.nOperationsToUndo + 1
#============================================================================
# waitForRotatePoint
#============================================================================
def waitForRotatePoint(self):
self.step = 1
self.plugIn.setLastPoint(self.basePt)
# imposto il map tool
self.getPointMapTool().basePt = self.basePt
self.getPointMapTool().setMode(Qad_rotate_maptool_ModeEnum.BASE_PT_KNOWN_ASK_FOR_NEW_ROTATION_PT)
keyWords = QadMsg.translate("Command_GRIPROTATE", "Base point") + "/" + \
QadMsg.translate("Command_GRIPROTATE", "Copy") + "/" + \
QadMsg.translate("Command_GRIPROTATE", "Undo") + "/" + \
QadMsg.translate("Command_GRIPROTATE", "Reference") + "/" + \
QadMsg.translate("Command_GRIPROTATE", "eXit")
prompt = QadMsg.translate("Command_GRIPROTATE", "Specify rotation angle or [{0}]: ").format(keyWords)
englishKeyWords = "Base point" + "/" + "Copy" + "/" + "Undo" + "/" + "Reference" + "/" + "eXit"
keyWords += "_" + englishKeyWords
# si appresta ad attendere un punto, un numero reale o enter o una parola chiave
# msg, inputType, default, keyWords, nessun controllo
self.waitFor(prompt, QadInputTypeEnum.POINT2D | QadInputTypeEnum.FLOAT | QadInputTypeEnum.KEYWORDS, \
None, \
keyWords, QadInputModeEnum.NONE)
#============================================================================
# waitForBasePt
#============================================================================
def waitForBasePt(self):
self.step = 2
# imposto il map tool
self.getPointMapTool().setMode(Qad_rotate_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_BASE_PT)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_GRIPROTATE", "Specify base point: "))
def waitForReferenceRot(self):
# imposto il map tool
self.getPointMapTool().setMode(Qad_rotate_maptool_ModeEnum.ASK_FOR_FIRST_PT_REFERENCE_ANG)
msg = QadMsg.translate("Command_GRIPROTATE", "Specify reference angle <{0}>: ")
# si appresta ad attendere un punto o enter o una parola chiave
# msg, inputType, default, keyWords, nessun controllo
self.waitFor(msg.format(str(qad_utils.toDegrees(self.plugIn.lastReferenceRot))), \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.FLOAT, \
self.plugIn.lastReferenceRot, \
"")
self.step = 3
#============================================================================
# run
#============================================================================
def run(self, msgMapTool = False, msg = None):
if self.plugIn.canvas.mapSettings().destinationCrs().geographicFlag():
self.showMsg(QadMsg.translate("QAD", "\nThe coordinate reference system of the project must be a projected coordinate system.\n"))
return True # fine comando
#=========================================================================
# RICHIESTA SELEZIONE OGGETTI
if self.step == 0: # inizio del comando
if self.entitySet.isEmpty(): # non ci sono oggetti da ruotare
return True
self.showMsg(QadMsg.translate("Command_GRIPROTATE", "\n** ROTATE **\n"))
# si appresta ad attendere un punto di rotazione
self.waitForRotatePoint()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DI UN PUNTO DI ROTAZIONE
elif self.step == 1:
ctrlKey = False
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
value = None
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
else:
value = self.getPointMapTool().point
ctrlKey = self.getPointMapTool().ctrlKey
else: # il punto arriva come parametro della funzione
value = msg
if type(value) == unicode:
if value == QadMsg.translate("Command_GRIPROTATE", "Base point") or value == "Base point":
# si appresta ad attendere il punto base
self.waitForBasePt()
elif value == QadMsg.translate("Command_GRIPROTATE", "Copy") or value == "Copy":
# Copia entità lasciando inalterate le originali
self.copyEntities = True
# si appresta ad attendere un punto di rotazione
self.waitForRotatePoint()
elif value == QadMsg.translate("Command_GRIPROTATE", "Undo") or value == "Undo":
if self.nOperationsToUndo > 0:
self.nOperationsToUndo = self.nOperationsToUndo - 1
self.plugIn.undoEditCommand()
else:
self.showMsg(QadMsg.translate("QAD", "\nThe command has been canceled."))
# si appresta ad attendere un punto di rotazione
self.waitForRotatePoint()
elif value == QadMsg.translate("Command_GRIPROTATE", "Reference") or value == "Reference":
# si appresta ad attendere l'angolo di riferimento
self.waitForReferenceRot()
elif value == QadMsg.translate("Command_GRIPROTATE", "eXit") or value == "eXit":
return True # fine comando
elif type(value) == QgsPoint or type(value) == float: # se é stato inserito l'angolo di rotazione
if type(value) == QgsPoint: # se é stato inserito l'angolo di rotazione con un punto
angle = qad_utils.getAngleBy2Pts(self.basePt, value)
else:
angle = qad_utils.toRadians(value)
angle = angle - self.ReferenceAng
self.plugIn.setLastRot(angle)
if ctrlKey:
self.copyEntities = True
self.rotateFeatures(angle)
if self.copyEntities == False:
return True
# si appresta ad attendere un punto di rotazione
self.waitForRotatePoint()
else:
if self.copyEntities == False:
self.skipToNextGripCommand = True
return True # fine comando
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PUNTO BASE (da step = 1)
elif self.step == 2: # dopo aver atteso un punto
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
pass # opzione di default "spostamento"
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
if type(value) == QgsPoint: # se é stato inserito il punto base
self.basePt.set(value.x(), value.y())
# imposto il map tool
self.getPointMapTool().basePt = self.basePt
# si appresta ad attendere un punto di rotazione
self.waitForRotatePoint()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PRIMO PUNTO PER ANGOLO ROTAZIONE DI RIFERIMENTO (da step = 1)
elif self.step == 3: # dopo aver atteso un punto o un numero reale si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
if type(value) == float: # se é stato inserito l'angolo di rotazione
self.ReferenceAng = qad_utils.toRadians(value)
self.getPointMapTool().ReferenceAng = self.ReferenceAng
# si appresta ad attendere un punto di rotazione
self.waitForRotatePoint()
elif type(value) == QgsPoint: # se é stato inserito l'angolo di rotazione con un punto
self.Pt1ReferenceAng = QgsPoint(value)
self.getPointMapTool().Pt1ReferenceAng = self.Pt1ReferenceAng
# imposto il map tool
self.getPointMapTool().setMode(Qad_rotate_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT_REFERENCE_ANG)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_GRIPROTATE", "Specify second point: "))
self.step = 4
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA SECONDO PUNTO PER NUOVO ANGOLO ROTAZIONE (da step = 3)
elif self.step == 4: # dopo aver atteso un punto o un numero reale si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
if type(value) == QgsPoint or type(value) == float: # se é stato inserito l'angolo di rotazione
if type(value) == QgsPoint: # se é stato inserito l'angolo di rotazione con un punto
self.ReferenceAng = qad_utils.getAngleBy2Pts(self.Pt1ReferenceAng, value)
else:
self.ReferenceAng = qad_utils.toRadians(value)
self.getPointMapTool().ReferenceAng = self.ReferenceAng
# si appresta ad attendere un punto di rotazione
self.waitForRotatePoint()
return False
| geosim/QAD | qad_rotate_cmd.py | Python | gpl-3.0 | 41,108 | [
"ESPResSo"
] | 7c4503973152d23a7a1cafeede5970fbacb9dd5da2db7e9ba939770710ac629b |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
'''
Copyright (C) 2016 Sovrasov V. - All Rights Reserved
* You may use, distribute and modify this code under the
* terms of the MIT license.
* You should have received a copy of the MIT license with
* this file. If not visit https://opensource.org/licenses/MIT
'''
import multiprocessing as mp
import numpy as np
from miscFunctions import *
from clustering import getKohonenClusters
from tsk0Model import TSK0
from pso import PSO
def buildAndTestModel(args, xTrain, yTrain, xTest, yTest, conn):
clusterCenters = getKohonenClusters(xTrain, args.nClusters, args.seed)
model = TSK0()
model.initFromClusters(clusterCenters, xTrain, yTrain)
initialParams = model.code()
newParams = PSO(lambda x: getTSK0Score(model, x, xTrain, yTrain),
model.code(), model.getParametersBounds(), args.nParticles, False, args.seed)
model.decode(newParams)
conn.send(model.score(xTest, yTest))
def getTSK0KFoldCVScore(modelEvaluator, x, y, k = 5, seed = 0):
rndInstance = random.Random(seed)
data = zip(x, y)
rndInstance.shuffle(data)
scores = []
threads = []
for i in xrange(k):
training = [x for j, x in enumerate(data) if j % k != i]
validation = [x for j, x in enumerate(data) if j % k == i]
xTrain, yTrain = zip(*training)
xTest, yTest = zip(*validation)
parentPipe, childPipe = mp.Pipe()
thread = mp.Process(target=modelEvaluator, args=\
(xTrain, yTrain, xTest, yTest, childPipe))
thread.start()
threads.append([thread, parentPipe])
for i in xrange(len(threads)):
currentScore = threads[i][1].recv()
threads[i][0].join()
scores.append(currentScore)
printIf('Score on split {}: \t{}'.format(i + 1, scores[-1]))
return np.sum(scores) / k, np.std(scores)
| sovrasov/fuzzy-ml | src/crossValidation.py | Python | mit | 1,864 | [
"VisIt"
] | 48fdb579bd3864ce6f8341c0a26a73b611477dafd12e612b97b6169a8a374ebf |
# encoding: utf-8
import datetime
from south.db import db
from south.v2 import SchemaMigration
from django.db import models
class Migration(SchemaMigration):
def forwards(self, orm):
# Adding model 'LegendOption'
db.create_table(u'profiles_legendoption', (
(u'id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
('indicator', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['profiles.Indicator'])),
('bin_type', self.gf('django.db.models.fields.CharField')(max_length=255)),
('bin_options', self.gf('django.db.models.fields.TextField')(default='')),
))
db.send_create_signal(u'profiles', ['LegendOption'])
def backwards(self, orm):
# Deleting model 'LegendOption'
db.delete_table(u'profiles_legendoption')
models = {
u'auth.group': {
'Meta': {'object_name': 'Group'},
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}),
'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': u"orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'})
},
u'auth.permission': {
'Meta': {'ordering': "(u'content_type__app_label', u'content_type__model', u'codename')", 'unique_together': "((u'content_type', u'codename'),)", 'object_name': 'Permission'},
'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['contenttypes.ContentType']"}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
},
u'auth.user': {
'Meta': {'object_name': 'User'},
'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime(2013, 11, 4, 13, 42, 53, 389661)'}),
'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': u"orm['auth.Group']", 'symmetrical': 'False', 'blank': 'True'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime(2013, 11, 4, 13, 42, 53, 389253)'}),
'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': u"orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'}),
'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'})
},
u'contenttypes.contenttype': {
'Meta': {'ordering': "('name',)", 'unique_together': "(('app_label', 'model'),)", 'object_name': 'ContentType', 'db_table': "'django_content_type'"},
'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
u'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'})
},
u'maps.shapefile': {
'Meta': {'object_name': 'ShapeFile'},
'color': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
'geo_key_column': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'geo_meta_key_column': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True', 'blank': 'True'}),
'geom_type': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'label_column': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
'shape_file': ('django.db.models.fields.files.FileField', [], {'max_length': '100', 'null': 'True', 'blank': 'True'}),
'zoom_threshold': ('django.db.models.fields.IntegerField', [], {'default': '5'})
},
u'profiles.customvalue': {
'Meta': {'object_name': 'CustomValue'},
'data_type': ('django.db.models.fields.CharField', [], {'default': "'COUNT'", 'max_length': '30'}),
'display_value': ('django.db.models.fields.CharField', [], {'max_length': "'255'"}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'indicator': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['profiles.Indicator']"}),
'supress': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'value_operator': ('django.db.models.fields.CharField', [], {'max_length': "'255'"})
},
u'profiles.datadomain': {
'Meta': {'ordering': "['weight']", 'object_name': 'DataDomain'},
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'indicators': ('django.db.models.fields.related.ManyToManyField', [], {'to': u"orm['profiles.Indicator']", 'through': u"orm['profiles.IndicatorDomain']", 'symmetrical': 'False'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'}),
'slug': ('django.db.models.fields.SlugField', [], {'unique': 'True', 'max_length': '100', 'db_index': 'True'}),
'subdomain_only': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'subdomains': ('django.db.models.fields.related.ManyToManyField', [], {'to': u"orm['profiles.DataDomain']", 'symmetrical': 'False', 'blank': 'True'}),
'weight': ('django.db.models.fields.PositiveIntegerField', [], {'default': '1'})
},
u'profiles.datapoint': {
'Meta': {'unique_together': "(('indicator', 'record', 'time'),)", 'object_name': 'DataPoint'},
'change_from_time': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'datapoint_as_change_from'", 'null': 'True', 'to': u"orm['profiles.Time']"}),
'change_to_time': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'datapoint_as_change_to'", 'null': 'True', 'to': u"orm['profiles.Time']"}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'image': ('sorl.thumbnail.fields.ImageField', [], {'max_length': '100', 'null': 'True', 'blank': 'True'}),
'indicator': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['profiles.Indicator']"}),
'record': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['profiles.GeoRecord']"}),
'time': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['profiles.Time']", 'null': 'True'})
},
u'profiles.datasource': {
'Meta': {'object_name': 'DataSource'},
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'implementation': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'})
},
u'profiles.denominator': {
'Meta': {'object_name': 'Denominator'},
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'indicator': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['profiles.Indicator']"}),
'label': ('django.db.models.fields.CharField', [], {'max_length': '50'}),
'multiplier': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'sort': ('django.db.models.fields.PositiveIntegerField', [], {'default': '1'})
},
u'profiles.denominatorpart': {
'Meta': {'object_name': 'DenominatorPart'},
'data': ('django.db.models.fields.files.FileField', [], {'max_length': '100', 'null': 'True', 'blank': 'True'}),
'data_source': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['profiles.DataSource']"}),
'denominator': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['profiles.Denominator']"}),
'formula': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'indicator': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['profiles.Indicator']"}),
'part': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['profiles.IndicatorPart']"})
},
u'profiles.flatvalue': {
'Meta': {'object_name': 'FlatValue'},
'display_title': ('django.db.models.fields.CharField', [], {'max_length': "'255'", 'db_index': 'True'}),
'f_moe': ('django.db.models.fields.CharField', [], {'max_length': "'255'", 'null': 'True', 'blank': 'True'}),
'f_number': ('django.db.models.fields.CharField', [], {'max_length': "'255'", 'null': 'True', 'blank': 'True'}),
'f_percent': ('django.db.models.fields.CharField', [], {'max_length': "'255'", 'null': 'True', 'blank': 'True'}),
'geography': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['profiles.GeoRecord']"}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'indicator': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['profiles.Indicator']"}),
'moe': ('django.db.models.fields.DecimalField', [], {'null': 'True', 'max_digits': '10', 'decimal_places': '2', 'blank': 'True'}),
'number': ('django.db.models.fields.DecimalField', [], {'null': 'True', 'max_digits': '10', 'decimal_places': '2', 'blank': 'True'}),
'percent': ('django.db.models.fields.DecimalField', [], {'null': 'True', 'max_digits': '10', 'decimal_places': '2', 'blank': 'True'}),
'time_key': ('django.db.models.fields.CharField', [], {'max_length': "'255'"}),
'value_type': ('django.db.models.fields.CharField', [], {'max_length': "'100'"})
},
u'profiles.geolevel': {
'Meta': {'object_name': 'GeoLevel'},
'data_sources': ('django.db.models.fields.related.ManyToManyField', [], {'to': u"orm['profiles.DataSource']", 'symmetrical': 'False', 'blank': 'True'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '200'}),
'parent': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['profiles.GeoLevel']", 'null': 'True', 'blank': 'True'}),
'slug': ('django.db.models.fields.SlugField', [], {'unique': 'True', 'max_length': '200', 'db_index': 'True'})
},
u'profiles.georecord': {
'Meta': {'unique_together': "(('slug', 'level'), ('level', 'geo_id', 'custom_name', 'owner'))", 'object_name': 'GeoRecord'},
'components': ('django.db.models.fields.related.ManyToManyField', [], {'related_name': "'components_rel_+'", 'blank': 'True', 'to': u"orm['profiles.GeoRecord']"}),
'custom_name': ('django.db.models.fields.CharField', [], {'max_length': '100', 'null': 'True', 'blank': 'True'}),
'geo_id': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'geo_searchable': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'level': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['profiles.GeoLevel']"}),
'mappings': ('django.db.models.fields.related.ManyToManyField', [], {'related_name': "'mappings_rel_+'", 'blank': 'True', 'to': u"orm['profiles.GeoRecord']"}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'notes': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'owner': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['auth.User']", 'null': 'True', 'blank': 'True'}),
'parent': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['profiles.GeoRecord']", 'null': 'True', 'blank': 'True'}),
'shapefile': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['maps.ShapeFile']", 'null': 'True', 'blank': 'True'}),
'slug': ('django.db.models.fields.SlugField', [], {'db_index': 'True', 'max_length': '100', 'blank': 'True'})
},
u'profiles.indicator': {
'Meta': {'object_name': 'Indicator'},
'data_domains': ('django.db.models.fields.related.ManyToManyField', [], {'to': u"orm['profiles.DataDomain']", 'through': u"orm['profiles.IndicatorDomain']", 'symmetrical': 'False'}),
'data_type': ('django.db.models.fields.CharField', [], {'default': "'COUNT'", 'max_length': '30'}),
'display_change': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
'display_distribution': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
'display_name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'display_percent': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'last_generated_at': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'levels': ('django.db.models.fields.related.ManyToManyField', [], {'to': u"orm['profiles.GeoLevel']", 'symmetrical': 'False'}),
'limitations': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'long_definition': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'}),
'notes': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'published': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
'purpose': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'routine_use': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'short_definition': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'slug': ('django.db.models.fields.SlugField', [], {'unique': 'True', 'max_length': '100', 'db_index': 'True'}),
'source': ('django.db.models.fields.CharField', [], {'default': "'U.S. Census Bureau'", 'max_length': '300', 'blank': 'True'}),
'universe': ('django.db.models.fields.CharField', [], {'max_length': '300', 'blank': 'True'})
},
u'profiles.indicatordomain': {
'Meta': {'object_name': 'IndicatorDomain'},
'default': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'domain': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['profiles.DataDomain']"}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'indicator': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['profiles.Indicator']"})
},
u'profiles.indicatorpart': {
'Meta': {'object_name': 'IndicatorPart'},
'data': ('django.db.models.fields.files.FileField', [], {'max_length': '100', 'null': 'True', 'blank': 'True'}),
'data_source': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['profiles.DataSource']"}),
'formula': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'indicator': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['profiles.Indicator']"}),
'time': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['profiles.Time']"})
},
u'profiles.legendoption': {
'Meta': {'object_name': 'LegendOption'},
'bin_options': ('django.db.models.fields.TextField', [], {'default': "''"}),
'bin_type': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'indicator': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['profiles.Indicator']"})
},
u'profiles.precalculatedvalue': {
'Meta': {'object_name': 'PrecalculatedValue'},
'data_source': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['profiles.DataSource']"}),
'geo_record': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['profiles.GeoRecord']"}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'notes': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'table': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'value': ('django.db.models.fields.TextField', [], {'blank': 'True'})
},
u'profiles.taskstatus': {
'Meta': {'object_name': 'TaskStatus'},
'error': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'last_updated': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'null': 'True', 'blank': 'True'}),
'status': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True', 'blank': 'True'}),
't_id': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True', 'blank': 'True'}),
'task': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True', 'blank': 'True'}),
'traceback': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'})
},
u'profiles.time': {
'Meta': {'object_name': 'Time'},
'description': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '20'}),
'sort': ('django.db.models.fields.DecimalField', [], {'max_digits': '5', 'decimal_places': '1'})
},
u'profiles.value': {
'Meta': {'object_name': 'Value'},
'datapoint': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['profiles.DataPoint']"}),
'denominator': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['profiles.Denominator']", 'null': 'True', 'blank': 'True'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'moe': ('django.db.models.fields.DecimalField', [], {'null': 'True', 'max_digits': '10', 'decimal_places': '2', 'blank': 'True'}),
'number': ('django.db.models.fields.DecimalField', [], {'null': 'True', 'max_digits': '10', 'decimal_places': '2', 'blank': 'True'}),
'percent': ('django.db.models.fields.DecimalField', [], {'null': 'True', 'max_digits': '10', 'decimal_places': '2', 'blank': 'True'})
}
}
complete_apps = ['profiles']
| ProvidencePlan/Profiles | communityprofiles/profiles/oldmigrations/0056_auto__add_legendoption.py | Python | mit | 20,590 | [
"MOE"
] | 7e8be4624e082c70301f7a0b616bac04274279e835570c2ebd8d2da2c4e2f769 |
#
# Copyright (C) 2019 Greg Landrum
# All Rights Reserved
#
# This file is part of the RDKit.
# The contents are covered by the terms of the BSD license
# which is included in the file license.txt, found at the root
# of the RDKit source tree.
#
from rdkit import Chem
from rdkit import Geometry
from rdkit.Chem import RDConfig
import os
import sys
import unittest
class TestCase(unittest.TestCase):
def setUp(self):
mb = """
ACCLDraw04231812452D
13 13 0 0 0 0 0 0 0 0999 V2000
5.0960 -4.3327 0.0000 C 0 0 0 0 0 0 0 0 0 0 0 0
7.4016 -4.3321 0.0000 C 0 0 0 0 0 0 0 0 0 0 0 0
5.0960 -5.6718 0.0000 C 0 0 0 0 0 0 0 0 0 0 0 0
6.2539 -6.3314 0.0000 C 0 0 0 0 0 0 0 0 0 0 0 0
6.2510 -2.3329 0.0000 C 0 0 0 0 0 0 0 0 0 0 0 0
7.4056 -1.6662 0.0000 C 0 0 0 0 0 0 0 0 0 0 0 0
5.0963 -1.6662 0.0000 C 0 0 0 0 0 0 0 0 0 0 0 0
6.2510 -3.6663 0.0000 C 0 0 0 0 0 0 0 0 0 0 0 0
8.5505 -6.3291 0.0000 C 0 0 0 0 0 0 0 0 0 0 0 0
8.5505 -7.6624 0.0000 O 0 0 0 0 0 0 0 0 0 0 0 0
9.7052 -5.6625 0.0000 O 0 0 0 0 0 0 0 0 0 0 0 0
7.4016 -5.6658 0.0000 C 0 0 0 0 0 0 0 0 0 0 0 0
3.9416 -2.3329 0.0000 C 0 0 0 0 0 0 0 0 0 0 0 0
3 4 2 0 0 0 0
1 3 1 0 0 0 0
5 8 1 0 0 0 0
5 7 2 0 0 0 0
5 6 1 0 0 0 0
1 8 2 0 0 0 0
2 8 1 0 0 0 0
9 12 1 0 0 0 0
9 11 2 0 0 0 0
9 10 1 0 0 0 0
4 12 1 0 0 0 0
2 12 2 0 0 0 0
7 13 1 0 0 0 0
M STY 2 1 DAT 2 DAT
M SLB 2 1 1 2 2
M SAL 1 1 10
M SDT 1 pH
M SDD 1 0.0000 0.0000 DR ALL 1 6
M SED 1 4.6
M SAL 2 2 5 7
M SBL 2 1 4
M SDT 2 Stereo
M SDD 2 0.0000 0.0000 DR ALL 1 6
M SED 2 E/Z unknown
M END"""
self.m1 = Chem.MolFromMolBlock(mb)
mb3000 = '''
Mrv2102 09042105562D
0 0 0 0 0 999 V3000
M V30 BEGIN CTAB
M V30 COUNTS 13 13 2 0 0
M V30 BEGIN ATOM
M V30 1 C 5.8858 -5.0042 0 0
M V30 2 C 8.5487 -5.0035 0 0
M V30 3 C 5.8858 -6.5508 0 0
M V30 4 C 7.2232 -7.3127 0 0
M V30 5 C 7.2198 -2.6945 0 0
M V30 6 C 8.5534 -1.9244 0 0
M V30 7 C 5.8862 -1.9244 0 0
M V30 8 C 7.2198 -4.2345 0 0
M V30 9 C 9.8757 -7.31 0 0
M V30 10 O 9.8757 -8.85 0 0
M V30 11 O 11.2094 -6.5401 0 0
M V30 12 C 8.5487 -6.5439 0 0
M V30 13 C 4.5525 -2.6945 0 0
M V30 END ATOM
M V30 BEGIN BOND
M V30 1 2 3 4
M V30 2 1 1 3
M V30 3 1 5 8
M V30 4 2 5 7
M V30 5 1 5 6
M V30 6 2 1 8
M V30 7 1 2 8
M V30 8 1 9 12
M V30 9 2 9 11
M V30 10 1 9 10
M V30 11 1 4 12
M V30 12 2 2 12
M V30 13 1 7 13
M V30 END BOND
M V30 BEGIN SGROUP
M V30 1 DAT 0 ATOMS=(1 10) FIELDNAME=pH -
M V30 FIELDDISP=" 0.0000 0.0000 DR ALL 1 6" FIELDDATA=4.6
M V30 2 DAT 0 ATOMS=(2 5 7) FIELDNAME=Stereo -
M V30 FIELDDISP=" 0.0000 0.0000 DR ALL 1 6" -
M V30 FIELDDATA="E/Z unknown"
M V30 END SGROUP
M V30 END CTAB
M END
'''
self.m2 = Chem.MolFromMolBlock(mb3000)
def testBasics(self):
self.assertTrue(self.m1 is not None)
sgs = Chem.GetMolSubstanceGroups(self.m1)
self.assertEqual(len(sgs), 2)
self.assertTrue(sgs[0].HasProp("TYPE"))
self.assertTrue(sgs[1].HasProp("TYPE"))
self.assertEqual(sgs[0].GetProp("TYPE"), "DAT")
self.assertEqual(sgs[1].GetProp("TYPE"), "DAT")
self.assertTrue(sgs[0].HasProp("FIELDNAME"))
self.assertEqual(sgs[0].GetProp("FIELDNAME"), "pH")
self.assertEqual(sorted(sgs[0].GetPropNames()), [
'DATAFIELDS', 'FIELDDISP', 'FIELDNAME', 'ID',
'TYPE', 'index'
])
dd = sgs[0].GetPropsAsDict()
self.assertTrue("TYPE" in dd)
self.assertEqual(dd["TYPE"], "DAT")
self.assertTrue("FIELDNAME" in dd)
self.assertEqual(dd["FIELDNAME"], "pH")
sgs[0].ClearProp("FIELDNAME")
self.assertFalse(sgs[0].HasProp("FIELDNAME"))
# The property doesn't exist anymore, but this should not fail
sgs[0].ClearProp("FIELDNAME")
self.assertFalse(sgs[0].HasProp("FIELDNAME"))
Chem.ClearMolSubstanceGroups(self.m1)
self.assertEqual(len(Chem.GetMolSubstanceGroups(self.m1)), 0)
def testBasics3000(self):
self.assertTrue(self.m2 is not None)
sgs = Chem.GetMolSubstanceGroups(self.m2)
self.assertEqual(len(sgs), 2)
self.assertTrue(sgs[0].HasProp("TYPE"))
self.assertTrue(sgs[1].HasProp("TYPE"))
self.assertEqual(sgs[0].GetProp("TYPE"), "DAT")
self.assertEqual(sgs[1].GetProp("TYPE"), "DAT")
self.assertTrue(sgs[0].HasProp("FIELDNAME"))
self.assertEqual(sgs[0].GetProp("FIELDNAME"), "pH")
self.assertEqual(sorted(sgs[0].GetPropNames()), [
'DATAFIELDS', 'FIELDDISP', 'FIELDNAME',
'TYPE', 'index'
])
dd = sgs[0].GetPropsAsDict()
self.assertTrue("TYPE" in dd)
self.assertEqual(dd["TYPE"], "DAT")
self.assertTrue("FIELDNAME" in dd)
self.assertEqual(dd["FIELDNAME"], "pH")
Chem.ClearMolSubstanceGroups(self.m2)
self.assertEqual(len(Chem.GetMolSubstanceGroups(self.m2)), 0)
def testLifetime(self):
self.assertTrue(self.m1 is not None)
mcpy = Chem.Mol(self.m1)
smi = Chem.MolToSmiles(mcpy)
sgs = Chem.GetMolSubstanceGroups(mcpy)
self.assertEqual(len(sgs), 2)
mcpy = None
parent = sgs[0].GetOwningMol()
self.assertEqual(smi, Chem.MolToSmiles(parent))
sgl = list(sgs)
sgs = None
parent = sgl[0].GetOwningMol()
self.assertEqual(smi, Chem.MolToSmiles(parent))
def testSetProp(self):
self.assertTrue(self.m1 is not None)
mcpy = Chem.Mol(self.m1)
sg = Chem.GetMolSubstanceGroupWithIdx(mcpy, 0)
sg.SetProp("foo", "bar")
sgs2 = Chem.GetMolSubstanceGroups(mcpy)
pd = sgs2[0].GetPropsAsDict()
self.assertTrue('foo' in pd)
self.assertEqual(pd['foo'], 'bar')
def testCreateSGroup(self):
mol = Chem.MolFromMolBlock('''
Mrv1810 10061910532D
0 0 0 0 0 999 V3000
M V30 BEGIN CTAB
M V30 COUNTS 4 3 0 0 0
M V30 BEGIN ATOM
M V30 1 O -14.8632 3.7053 0 0
M V30 2 C -13.3232 3.7053 0 0
M V30 3 O -11.7832 3.7053 0 0
M V30 4 * -10.2453 3.6247 0 0
M V30 END ATOM
M V30 BEGIN BOND
M V30 1 1 1 2
M V30 2 1 2 3
M V30 3 1 3 4
M V30 END BOND
M V30 END CTAB
M END''')
self.assertTrue(mol is not None)
mcpy = Chem.Mol(mol)
sg = Chem.CreateMolSubstanceGroup(mcpy, "SRU")
self.assertEqual(sg.GetProp("TYPE"), "SRU")
sg = Chem.GetMolSubstanceGroupWithIdx(mcpy, 0)
sg.AddBracket((Geometry.Point3D(-11.1, 4.6, 0), Geometry.Point3D(-11.1, 2.7, 0)))
sg.AddBracket((Geometry.Point3D(-13.9, 2.7, 0), Geometry.Point3D(-13.9, 4.6, 0)))
sg.AddAtomWithIdx(1)
sg.AddAtomWithIdx(2)
sg.AddBondWithIdx(0)
sg.AddBondWithIdx(2)
sg.SetProp("CONNECT", "HT")
sg.SetProp("LABEL", "n")
mb = Chem.MolToMolBlock(mcpy, forceV3000=True)
self.assertNotEqual(mb.find('V30 1 SRU'), -1)
self.assertNotEqual(mb.find('BRKXYZ'), -1)
self.assertNotEqual(mb.find('CONNECT=HT'), -1)
def testXBONDS(self):
mol = Chem.MolFromMolBlock('''
Mrv1824 06192020192D
0 0 0 0 0 999 V3000
M V30 BEGIN CTAB
M V30 COUNTS 6 6 1 0 0
M V30 BEGIN ATOM
M V30 1 C -1.25 0.7484 0 0
M V30 2 C -2.5837 -0.0216 0 0
M V30 3 C -2.5837 -1.5617 0 0
M V30 4 C -1.25 -2.3317 0 0
M V30 5 C 0.0837 -1.5617 0 0
M V30 6 C 0.0837 -0.0216 0 0
M V30 END ATOM
M V30 BEGIN BOND
M V30 1 1 1 2
M V30 2 1 2 3
M V30 3 1 3 4
M V30 4 1 4 5
M V30 5 1 5 6
M V30 6 1 1 6
M V30 END BOND
M V30 BEGIN SGROUP
M V30 1 SRU 0 ATOMS=(1 1) XBONDS=(2 1 6) XBHEAD=(2 6 1) XBCORR=(4 6 6 1 1) -
M V30 BRKXYZ=(9 -2.02 -0.0216 0 -2.02 1.5184 0 0 0 0) BRKXYZ=(9 -0.48 1.5184 -
M V30 0 -0.48 -0.0216 0 0 0 0) CONNECT=HT LABEL="1-3"
M V30 END SGROUP
M V30 END CTAB
M END
''')
self.assertIsNotNone(mol)
sgs = Chem.GetMolSubstanceGroups(mol)
self.assertEqual(len(sgs), 1)
sg = sgs[0]
self.assertEqual(sg.GetProp('TYPE'), 'SRU')
v = sg.GetUnsignedVectProp('XBHEAD')
self.assertEqual(len(v), 2)
self.assertEqual(list(v), [5, 0])
v = sg.GetUnsignedVectProp('XBCORR')
self.assertEqual(len(v), 4)
self.assertEqual(list(v), [5, 5, 0, 0])
def testDataFields(self):
mol = Chem.MolFromMolBlock('''
Mrv2007 06242013252D
0 0 0 0 0 999 V3000
M V30 BEGIN CTAB
M V30 COUNTS 7 6 1 0 0
M V30 BEGIN ATOM
M V30 1 C -5.1782 0.0827 0 0
M V30 2 C -6.5119 -0.6873 0 0
M V30 3 C -3.8446 -0.6873 0 0
M V30 4 O -2.5109 0.0826 0 0
M V30 5 C -1.0732 -0.4692 0 0
M V30 6 C -5.1782 1.6227 0 0
M V30 7 C -6.5119 2.3927 0 0
M V30 END ATOM
M V30 BEGIN BOND
M V30 1 1 1 2
M V30 2 2 1 3
M V30 3 1 3 4
M V30 4 1 4 5
M V30 5 1 1 6
M V30 6 1 7 6
M V30 END BOND
M V30 BEGIN SGROUP
M V30 1 DAT 0 ATOMS=(2 1 6) FIELDNAME=property -
M V30 FIELDDISP=" -5.1782 0.0827 DA ALL 0 0" -
M V30 FIELDDATA=val2 FIELDDATA=val1
M V30 END SGROUP
M V30 END CTAB
M END
''')
self.assertIsNotNone(mol)
sgs = Chem.GetMolSubstanceGroups(mol)
self.assertEqual(len(sgs), 1)
sg = sgs[0]
self.assertEqual(sg.GetProp('TYPE'), 'DAT')
pv = sg.GetStringVectProp('DATAFIELDS')
self.assertEqual(list(pv), ['val2', 'val1'])
def testCopying(self):
mol = Chem.MolFromMolBlock('''
Mrv2014 07312005252D
0 0 0 0 0 999 V3000
M V30 BEGIN CTAB
M V30 COUNTS 7 6 3 0 0
M V30 BEGIN ATOM
M V30 1 * -12.75 11.5 0 0
M V30 2 O -11.4163 12.27 0 0
M V30 3 C -10.0826 11.5 0 0
M V30 4 C -8.749 12.27 0 0
M V30 5 O -10.0826 9.96 0 0
M V30 6 N -7.4153 11.5 0 0
M V30 7 C -6.0816 12.27 0 0
M V30 END ATOM
M V30 BEGIN BOND
M V30 1 1 1 2
M V30 2 1 2 3
M V30 3 1 3 4
M V30 4 2 3 5
M V30 5 1 4 6
M V30 6 1 6 7
M V30 END BOND
M V30 BEGIN SGROUP
M V30 1 SRU 0 ATOMS=(3 2 3 5) XBONDS=(2 1 3) BRKXYZ=(9 -9.9955 12.6173 0 -
M V30 -9.0715 11.0169 0 0 0 0) BRKXYZ=(9 -11.5035 11.1527 0 -12.4275 12.7531 -
M V30 0 0 0 0) CONNECT=HT LABEL=n
M V30 2 DAT 0 ATOMS=(1 6) FIELDNAME=foo_data -
M V30 FIELDDISP=" -7.4153 11.5000 DAU ALL 0 0" -
M V30 MRV_FIELDDISP=0 FIELDDATA=bar
M V30 3 DAT 0 ATOMS=(1 7) FIELDNAME=bar_data -
M V30 FIELDDISP=" -6.0816 12.2700 DAU ALL 0 0" -
M V30 MRV_FIELDDISP=0 FIELDDATA=baz
M V30 END SGROUP
M V30 END CTAB
M END''')
self.assertEqual(len(Chem.GetMolSubstanceGroups(mol)), 3)
mol2 = Chem.Mol(mol)
Chem.ClearMolSubstanceGroups(mol2)
self.assertEqual(len(Chem.GetMolSubstanceGroups(mol2)), 0)
sgs = Chem.GetMolSubstanceGroups(mol)
Chem.AddMolSubstanceGroup(mol2, sgs[0])
Chem.AddMolSubstanceGroup(mol2, sgs[2])
self.assertEqual(len(Chem.GetMolSubstanceGroups(mol2)), 2)
molb = Chem.MolToV3KMolBlock(mol2)
self.assertEqual(molb.find("foo_data"), -1)
self.assertGreater(molb.find("M V30 2 DAT 0 ATOMS=(1 7) FIELDNAME=bar_data"), 0)
# we can also use this to copy SGroups:
sgs2 = Chem.GetMolSubstanceGroups(mol2)
newsg = Chem.AddMolSubstanceGroup(mol2, sgs[1])
newsg.SetProp("FIELDNAME", "blah_data")
molb = Chem.MolToV3KMolBlock(mol2)
self.assertGreater(molb.find("M V30 3 DAT 0 ATOMS=(1 6) FIELDNAME=blah_data"), 0)
def testCStates(self):
mol = Chem.MolFromMolBlock('''
ACCLDraw08282007542D
0 0 0 0 0 999 V3000
M V30 BEGIN CTAB
M V30 COUNTS 9 9 1 0 0
M V30 BEGIN ATOM
M V30 1 C 8.759 -6.2839 0 0
M V30 2 C 10.8013 -6.2833 0 0
M V30 3 C 9.7821 -5.6936 0 0
M V30 4 C 10.8013 -7.4648 0 0
M V30 5 C 8.759 -7.4701 0 0
M V30 6 C 9.7847 -8.0543 0 0
M V30 7 C 11.8245 -5.6926 0 0
M V30 8 O 12.8482 -6.2834 0 0
M V30 9 O 11.8245 -4.5104 0 0
M V30 END ATOM
M V30 BEGIN BOND
M V30 1 1 6 4
M V30 2 2 5 6
M V30 3 1 2 3
M V30 4 1 1 5
M V30 5 2 4 2
M V30 6 2 3 1
M V30 7 2 7 9
M V30 8 1 7 8
M V30 9 1 2 7
M V30 END BOND
M V30 BEGIN SGROUP
M V30 1 SUP 1 ATOMS=(3 7 8 9) XBONDS=(1 9) CSTATE=(4 9 -1.02 -0.59 0) LABEL=-
M V30 CO2H
M V30 END SGROUP
M V30 END CTAB
M END
''')
sgs = Chem.GetMolSubstanceGroups(mol)
self.assertEqual(len(sgs), 1)
sg0 = sgs[0]
pd = sg0.GetPropsAsDict()
self.assertTrue('TYPE' in pd)
self.assertEqual(pd['TYPE'], 'SUP')
cstates = sg0.GetCStates()
self.assertEqual(len(cstates), 1)
cs0 = cstates[0]
self.assertEqual(cs0.bondIdx, 8)
self.assertAlmostEqual(cs0.vector.x, -1.02, 2)
self.assertAlmostEqual(cs0.vector.y, -0.59, 2)
def testBrackets(self):
mol = Chem.MolFromMolBlock('''
Mrv2014 08282011142D
0 0 0 0 0 999 V3000
M V30 BEGIN CTAB
M V30 COUNTS 6 5 1 0 0
M V30 BEGIN ATOM
M V30 1 C -15.7083 2 0 0
M V30 2 C -14.3747 2.77 0 0
M V30 3 O -13.041 2 0 0
M V30 4 C -11.7073 2.77 0 0
M V30 5 C -10.3736 2 0 0
M V30 6 C -9.0399 2.77 0 0
M V30 END ATOM
M V30 BEGIN BOND
M V30 1 1 1 2
M V30 2 1 2 3
M V30 3 1 3 4
M V30 4 1 4 5
M V30 5 1 5 6
M V30 END BOND
M V30 BEGIN SGROUP
M V30 1 MON 0 ATOMS=(2 3 4) BRKXYZ=(9 -13.811 1.23 0 -13.811 3.54 0 0 0 0) -
M V30 BRKXYZ=(9 -10.9373 3.54 0 -10.9373 1.23 0 0 0 0)
M V30 END SGROUP
M V30 END CTAB
M END''')
sgs = Chem.GetMolSubstanceGroups(mol)
self.assertEqual(len(sgs), 1)
sg0 = sgs[0]
pd = sg0.GetPropsAsDict()
self.assertTrue('TYPE' in pd)
self.assertEqual(pd['TYPE'], 'MON')
brackets = sg0.GetBrackets()
self.assertEqual(len(brackets), 2)
b = brackets[0]
self.assertEqual(len(b), 3)
self.assertAlmostEqual(b[0].x, -13.811, 3)
self.assertAlmostEqual(b[0].y, 1.230, 3)
self.assertAlmostEqual(b[1].x, -13.811, 3)
self.assertAlmostEqual(b[1].y, 3.540, 3)
self.assertAlmostEqual(b[2].x, 0, 3)
self.assertAlmostEqual(b[2].y, 0, 3)
b = brackets[1]
self.assertEqual(len(b), 3)
self.assertAlmostEqual(b[0].x, -10.937, 3)
self.assertAlmostEqual(b[0].y, 3.54, 3)
self.assertAlmostEqual(b[1].x, -10.937, 3)
self.assertAlmostEqual(b[1].y, 1.23, 3)
self.assertAlmostEqual(b[2].x, 0, 3)
self.assertAlmostEqual(b[2].y, 0, 3)
def testAttachPoints(self):
mol = Chem.MolFromMolBlock('''
Mrv2014 09012006262D
0 0 0 0 0 999 V3000
M V30 BEGIN CTAB
M V30 COUNTS 4 3 1 0 0
M V30 BEGIN ATOM
M V30 1 C -5.0833 0.0833 0 0
M V30 2 C -3.7497 0.8533 0 0
M V30 3 O -2.416 0.0833 0 0
M V30 4 O -3.7497 2.3933 0 0
M V30 END ATOM
M V30 BEGIN BOND
M V30 1 1 1 2
M V30 2 1 2 3
M V30 3 2 2 4
M V30 END BOND
M V30 BEGIN SGROUP
M V30 1 SUP 0 ATOMS=(3 2 3 4) SAP=(3 2 1 1) XBONDS=(1 1) LABEL=CO2H ESTATE=E
M V30 END SGROUP
M V30 END CTAB
M END''')
sgs = Chem.GetMolSubstanceGroups(mol)
self.assertEqual(len(sgs), 1)
sg0 = sgs[0]
pd = sg0.GetPropsAsDict()
self.assertTrue('TYPE' in pd)
self.assertEqual(pd['TYPE'], 'SUP')
aps = sg0.GetAttachPoints()
self.assertEqual(len(aps), 1)
self.assertEqual(aps[0].aIdx, 1)
self.assertEqual(aps[0].lvIdx, 0)
self.assertEqual(aps[0].id, '1')
mol = Chem.MolFromMolBlock('''
Mrv2014 09012006262D
0 0 0 0 0 999 V3000
M V30 BEGIN CTAB
M V30 COUNTS 4 3 0 0 0
M V30 BEGIN ATOM
M V30 1 C -5.0833 0.0833 0 0
M V30 2 C -3.7497 0.8533 0 0
M V30 3 O -2.416 0.0833 0 0
M V30 4 O -3.7497 2.3933 0 0
M V30 END ATOM
M V30 BEGIN BOND
M V30 1 1 1 2
M V30 2 1 2 3
M V30 3 2 2 4
M V30 END BOND
M V30 END CTAB
M END''')
sgs = Chem.GetMolSubstanceGroups(mol)
self.assertEqual(len(sgs), 0)
sg = Chem.CreateMolSubstanceGroup(mol, "SUP")
sg.AddAtomWithIdx(1)
sg.AddAtomWithIdx(2)
sg.AddAtomWithIdx(3)
sg.AddBondWithIdx(0)
sg.SetProp('LABEL', 'CO2H')
sg.AddAttachPoint(1, 0, '1')
molb = Chem.MolToV3KMolBlock(mol)
self.assertGreater(
molb.find('M V30 1 SUP 0 ATOMS=(3 2 3 4) XBONDS=(1 1) LABEL=CO2H SAP=(3 2 1 1)'), 0)
def testClearValues(self):
mol = Chem.MolFromMolBlock('''example
-ISIS- 10171405052D
0 0 0 0 0 999 V3000
M V30 BEGIN CTAB
M V30 COUNTS 14 15 1 0 0
M V30 BEGIN ATOM
M V30 1 C 6.4292 -1.1916 0 0 CFG=3
M V30 2 C 7.0125 -0.6042 0 0
M V30 3 N 6.4292 -0.0250999 0 0
M V30 4 C 5.8416 -0.6042 0 0
M V30 5 C 5.8416 -1.7708 0 0
M V30 6 N 6.4292 -2.3584 0 0 CFG=3
M V30 7 C 7.0125 -1.7708 0 0
M V30 8 O 5.7166 -3.5875 0 0
M V30 9 C 5.7166 -4.4125 0 0 CFG=3
M V30 10 C 4.8875 -4.4125 0 0
M V30 11 C 6.5376 -4.4166 0 0
M V30 12 C 5.7166 -5.2376 0 0
M V30 13 C 6.4292 -3.175 0 0
M V30 14 O 7.1375 -3.5875 0 0
M V30 END ATOM
M V30 BEGIN BOND
M V30 1 1 1 2
M V30 2 1 2 3
M V30 3 1 3 4
M V30 4 1 4 1
M V30 5 1 1 5
M V30 6 1 5 6
M V30 7 1 6 7
M V30 8 1 7 1
M V30 9 1 6 13
M V30 10 1 8 9
M V30 11 1 9 10
M V30 12 1 9 11
M V30 13 1 9 12
M V30 14 2 13 14
M V30 15 1 8 13
M V30 END BOND
M V30 BEGIN SGROUP
M V30 1 SUP 0 ATOMS=(7 8 9 10 11 12 13 14) XBONDS=(1 9) BRKXYZ=(9 6.24 -2.9 0 -
M V30 6.24 -2.9 0 0 0 0) CSTATE=(4 9 0 0.82 0) LABEL=Boc SAP=(3 13 6 1)
M V30 END SGROUP
M V30 END CTAB
M END''')
sgs = Chem.GetMolSubstanceGroups(mol)
self.assertEqual(len(sgs), 1)
self.assertEqual(len(sgs[0].GetBrackets()), 1)
sgs[0].ClearBrackets()
self.assertEqual(len(sgs[0].GetBrackets()), 0)
self.assertEqual(len(sgs[0].GetCStates()), 1)
sgs[0].ClearCStates()
self.assertEqual(len(sgs[0].GetCStates()), 0)
self.assertEqual(len(sgs[0].GetAttachPoints()), 1)
sgs[0].ClearAttachPoints()
self.assertEqual(len(sgs[0].GetAttachPoints()), 0)
if __name__ == '__main__':
print("Testing SubstanceGroups wrapper")
unittest.main()
| bp-kelley/rdkit | Code/GraphMol/Wrap/testSGroups.py | Python | bsd-3-clause | 17,783 | [
"RDKit"
] | ac3c4161d7634d2441e09b65e779ff61a740df650c2dc76a90d937384ddbc3b4 |
# ---
# jupyter:
# jupytext:
# formats: ipynb,.pct.py:percent
# text_representation:
# extension: .py
# format_name: percent
# format_version: '1.3'
# jupytext_version: 1.3.3
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# %% [markdown]
# ## Sanity checking when model behaviours should overlap
#
# Many of the model classes in GPflow have overlapping behaviour in special cases. In this notebook, we fit some approximations to a model with a Gaussian likelihood, and make sure they're all the same.
#
# The models are:
# - `GPR`: Full Gaussian process regression.
#
# - `VGP`: A Gaussian approximation with Variational Bayes.
# Approximating a Gaussian posterior with a Gaussian should be exact.
#
# - `SVGP`: a sparse GP, with a Gaussian approximation. The inducing points are set to be at the data points, so again, should be exact.
#
# - `SVGP` (with whitened representation): As above, but with a rotation applied to whiten the representation of the process.
#
# - `SGPR`: A sparse GP with a *collapsed* posterior (Titsias 2009). Again, the inducing points are fixed to the data points.
#
# - `GPRFITC`: The FITC approximation. Again, the inducing points are fixed to the data points.
#
# In all cases the parameters are estimated by the method of maximum likelihood (or approximate maximum likelihood, as appropriate). The parameter estimates should all be the same.
# %%
import gpflow
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
from gpflow import set_trainable
from gpflow.models import maximum_log_likelihood_objective, training_loss_closure
from gpflow.config import default_float
from gpflow.ci_utils import ci_niter
# %matplotlib inline
plt.rcParams["figure.figsize"] = (12, 6)
# %%
np.random.seed(0)
X = np.random.rand(20, 1) * 10
Y = np.sin(X) + 0.9 * np.cos(X * 1.6) + np.random.randn(*X.shape) * 0.4
Xtest = np.random.rand(10, 1) * 10
_ = plt.plot(X, Y, "kx", mew=2)
# %%
data = (
tf.convert_to_tensor(X, dtype=default_float()),
tf.convert_to_tensor(Y, dtype=default_float()),
)
inducing_variable = tf.convert_to_tensor(X, dtype=default_float())
m1 = gpflow.models.GPR(data, kernel=gpflow.kernels.SquaredExponential())
m2 = gpflow.models.VGP(
data, kernel=gpflow.kernels.SquaredExponential(), likelihood=gpflow.likelihoods.Gaussian()
)
m3 = gpflow.models.SVGP(
gpflow.kernels.SquaredExponential(),
gpflow.likelihoods.Gaussian(),
inducing_variable,
q_diag=False,
)
set_trainable(m3.inducing_variable, False)
m4 = gpflow.models.SVGP(
gpflow.kernels.SquaredExponential(),
gpflow.likelihoods.Gaussian(),
inducing_variable,
q_diag=False,
whiten=True,
)
set_trainable(m4.inducing_variable, False)
m5 = gpflow.models.SGPR(
data, kernel=gpflow.kernels.SquaredExponential(), inducing_variable=inducing_variable
)
set_trainable(m5.inducing_variable, False)
m6 = gpflow.models.GPRFITC(
data, kernel=gpflow.kernels.SquaredExponential(), inducing_variable=inducing_variable
)
set_trainable(m6.inducing_variable, False)
models = [m1, m2, m3, m4, m5, m6]
# %% [markdown]
# Now, we optimize the models. For `GPR`, `SVGP`, and `GPRFITC`, this simply optimizes the hyperparameters (since the inducing points are fixed). For the variational models, this jointly maximises the lower bound to the marginal likelihood (Evidence Lower Bound, ELBO) with respect to the variational parameters and the kernel and likelihood hyperparameters.
# %%
for m in models:
opt = gpflow.optimizers.Scipy()
loss_closure = training_loss_closure(m, data)
opt.minimize(
loss_closure,
variables=m.trainable_variables,
options=dict(maxiter=ci_niter(1000)),
compile=True,
)
# %% [markdown]
# If everything worked as planned, the models should have the same:
#
# - prediction functions
# - log (marginal) likelihood
# - kernel parameters
#
# For the variational models, where we use a ELBO in place of the likelihood, the ELBO should be tight to the likelihood in the cases studied here.
# %%
def plot(m, color, ax):
xx = np.linspace(-1, 11, 100)[:, None]
mu, var = m.predict_y(xx)
ax.plot(xx, mu, color, lw=2)
ax.fill_between(
xx[:, 0],
mu[:, 0] - 2 * np.sqrt(var[:, 0]),
mu[:, 0] + 2 * np.sqrt(var[:, 0]),
color=color,
alpha=0.2,
)
ax.plot(X, Y, "kx", mew=2)
ax.set_xlim(-1, 11)
f, ax = plt.subplots(3, 2, sharex=True, sharey=True, figsize=(12, 9))
plot(m1, "C0", ax[0, 0])
plot(m2, "C1", ax[1, 0])
plot(m3, "C2", ax[0, 1])
plot(m4, "C3", ax[1, 1])
plot(m5, "C4", ax[2, 0])
plot(m6, "C5", ax[2, 1])
# %% [markdown]
# Here are the kernels and likelihoods, which show the fitted kernel parameters and noise variance:
# %%
for m in models:
print(m.__class__.__name__)
print(f" kernel lengthscale = {m.kernel.lengthscales.numpy():.5g}")
print(f" kernel variance = {m.kernel.variance.numpy():.5}")
print(f" likelihood variance = {m.likelihood.variance.numpy():.5}")
# %% [markdown]
# Here are the likelihoods (or ELBOs):
# %%
for m in models:
print(f"{m.__class__.__name__:30} {maximum_log_likelihood_objective(m, data)}")
| GPflow/GPflow | doc/source/notebooks/theory/Sanity_check.pct.py | Python | apache-2.0 | 5,239 | [
"Gaussian"
] | bfc30811e8a7d676e6700ce9f5b7f041715b7ab00941b190e66c5b3219346db8 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.