code
stringlengths 501
5.19M
| package
stringlengths 2
81
| path
stringlengths 9
304
| filename
stringlengths 4
145
|
|---|---|---|---|
import json
import logging
import logging.handlers
import os
import sys
import timeit
from typing import Callable, List, Optional, Tuple
try:
import tqdm
TQDM = True
class TqdmHandler(logging.StreamHandler):
def __init__(self, level=logging.NOTSET):
super(self.__class__, self).__init__(level)
def emit(self, record):
try:
msg = self.format(record)
tqdm.tqdm.write(msg)
self.flush()
except (KeyboardInterrupt, SystemExit):
raise
except: # noqa
self.handleError(record)
except ImportError:
TQDM = False
# Credit to: http://stackoverflow.com/a/15707426/2214380
def time_execution(func: Callable) -> Callable:
"""Function decorator to time the execution of a function and log to debug.
:param func: The function to time execution of
:return: The decorated function"""
def wrapper(*args, **kwargs):
start_time = timeit.default_timer()
ret = func(*args, **kwargs)
end_time = timeit.default_timer()
logging.debug("Elapsed time for %s: %f seconds", func.__name__,
float(end_time - start_time))
return ret
return wrapper
# From: list_dc_datastore_info in pyvmomi-community-samples
# http://stackoverflow.com/questions/1094841/
def sizeof_fmt(num: float) -> str:
"""Generates the human-readable version of a file size.
>>> sizeof_fmt(512)
512bytes
>>> sizeof_fmt(2048)
2KB
:param num: Robot-readable file size in bytes
:return: Human-readable file size"""
for item in ['bytes', 'KB', 'MB', 'GB']:
if num < 1024.0:
return "%3.1f%s" % (num, item)
num /= 1024.0
return "%3.1f%s" % (num, 'TB')
def pad(value: int, length: int = 2) -> str:
"""
Adds leading and trailing zeros to value ("pads" the value).
>>> pad(5)
05
>>> pad(9, 3)
009
:param value: integer value to pad
:param length: Length to pad to
:return: string of padded value"""
return "{0:0>{width}}".format(value, width=length)
def read_json(filename: str) -> Optional[dict]:
"""Reads input from a JSON file and returns the contents.
:param filename: Path to JSON file to read
:return: Contents of the JSON file"""
try:
with open(filename) as json_file:
return json.load(fp=json_file)
except ValueError as message:
logging.error("Syntax Error in JSON file '%s': %s",
filename, str(message))
except FileNotFoundError:
logging.error("Could not find file %s", filename)
except Exception as message:
logging.error("Could not open JSON file '%s': %s",
filename, str(message))
return None
def split_path(path: str) -> Tuple[List[str], str]:
"""Splits a filepath.
>>> split_path('/path/To/A/f1le')
(['path', 'To', 'A'], 'file')
:param path: Path to split
:return: Path, basename"""
folder_path, name = os.path.split(path.lower()) # Separate basename
folder_path = folder_path.split('/') # Transform path into list
if folder_path[0] == '':
del folder_path[0]
return folder_path, name
def handle_keyboard_interrupt(func: Callable) -> Callable:
"""Function decorator to handle keyboard interrupts in a consistent manner."""
# Based on: http://code.activestate.com/recipes/577058/
def wrapper(*args, **kwargs):
try:
ret = func(*args, **kwargs)
except KeyboardInterrupt:
# Output a blank line for readability
print() # noqa: T001
logging.info("Exiting...")
sys.exit(0)
return ret
return wrapper
def setup_logging(filename: str, colors: bool = True,
console_verbose: bool = False,
server: Tuple[str, int] = None,
show_progress: bool = True):
"""Configures the logging interface used by everything for output.
:param filename: Name of file that logs should be saved to
:param colors: Color the terminal output
:param console_verbose: Print DEBUG logs to terminal
:param server: SysLog server to forward logs to
:param show_progress: Show live status as operations progress"""
# Prepend spaces to separate logs from previous runs
with open(filename, 'a', encoding='utf-8') as logfile:
logfile.write(2 * '\n')
# Format log output so it's human readable yet verbose
base_format = "%(asctime)s %(levelname)-8s %(name)-7s %(message)s"
time_format = "%H:%M:%S" # %Y-%m-%d
formatter = logging.Formatter(fmt=base_format, datefmt=time_format)
# Configures the base logger to append to a file
logging.basicConfig(level=logging.DEBUG, format=base_format,
datefmt=time_format, filename=filename, filemode='a')
# Get the global root logger
# Handlers added to this will propagate to all loggers
logger = logging.root
# Configure logging to a SysLog server
# This prevents students from simply deleting the log files
if server is not None:
syslog = logging.handlers.SysLogHandler(address=server)
syslog.setLevel(logging.DEBUG)
syslog.setFormatter(formatter)
logger.addHandler(syslog)
logging.debug("Configured logging to SysLog server %s:%d",
server[0], server[1])
# Record system information to aid in auditing and debugging
# We do this before configuring console output to reduce verbosity
from getpass import getuser
from platform import python_version, system, release, node
from datetime import date
from adles import __version__ as adles_version
logging.debug("Initialized logging, saving logs to %s", filename)
logging.debug("Date %s", str(date.today()))
logging.debug("OS %s", str(system() + " " + release()))
logging.debug("Hostname %s", str(node()))
logging.debug("Username %s", str(getuser()))
logging.debug("Directory %s", str(os.getcwd()))
logging.debug("Python version %s", str(python_version()))
logging.debug("Adles version %s", str(adles_version))
# If any of the libraries we're using have warnings, capture and log them
logging.captureWarnings(capture=True)
# Configure console output
if TQDM and show_progress:
console = TqdmHandler()
else:
console = logging.StreamHandler(stream=sys.stdout)
if colors and "NO_COLOR" not in os.environ:
try:
from colorlog import ColoredFormatter
formatter = ColoredFormatter(fmt="%(log_color)s" + base_format,
datefmt=time_format, reset=True)
logging.debug("Configured COLORED console logging output")
except ImportError:
logging.error("Colorlog is not installed. "
"Using STANDARD console output...")
console.setFormatter(formatter)
console.setLevel((logging.DEBUG if console_verbose else logging.INFO))
logger.addHandler(console)
# Warn if using old Python version
if python_version() < '3.6':
logger.error("Python version %s is unsupported. "
"Please use Python 3.6+ instead. "
"Proceed at your own risk!")
def get_vlan() -> int:
"""Generates a globally unique VLAN tags.
:return: VLAN tag"""
for i in range(2000, 4096):
yield i
@handle_keyboard_interrupt
def user_input(prompt: str, obj_name: str, func: Callable) -> Tuple[object, str]:
"""Continually prompts a user for input until the specified object is found.
:param prompt: Prompt to bother user with
:param obj_name: Name of the type of the object that we seek
:param func: The function that shalt be called to discover the object
:return: The discovered object (vimtype) and it's human name"""
while True:
item_name = input(prompt)
item = func(item_name)
if item:
logging.info("Found %s: %s", obj_name, item.name)
return item, item_name
else:
print("Couldn't find a %s with name %s. Perhaps try another? " # noqa: T001
% (obj_name, item_name))
@handle_keyboard_interrupt
def default_prompt(prompt: str, default: str = None) -> Optional[str]:
"""Prompt the user for input. If they press enter, return the default.
:param prompt: Prompt to display to user (do not include default value)
:param default: Default return value
:return: Value entered or default"""
def_prompt = " [default: %s]: " % ('' if default is None else default)
value = input(prompt + def_prompt)
return default if value == '' else value | ADLES | /ADLES-1.4.0.tar.gz/ADLES-1.4.0/adles/utils.py | utils.py |
import logging
class Group:
""" Manages a group of users that has been loaded from a specification """
def __init__(self, name, group, instance=None):
"""
:param str name: Name of the group
:param dict group: Dict specification of the group
:param int instance: Instance number of a template group
"""
self._log = logging.getLogger('Group')
self._log.debug("Initializing Group '%s'", name)
if instance:
self.is_template = True
self.instance = instance
else:
self.is_template = False
# !!! NOTE: ad-groups must be handled externally by caller !!!
if "ad-group" in group:
group_type = "ad"
self.ad_group = group["ad-group"]
users = []
if instance: # Template groups
# This is the " X" in the spec
self.ad_group += " " + str(instance)
elif "filename" in group:
from adles.utils import read_json
group_type = "standard"
if instance: # Template group
users = [(user, pw)
for user, pw in read_json(group["filename"])
[str(instance)].items()]
else: # Standard group
users = [(user, pw)
for user, pw in read_json(group["filename"]).items()]
elif "user-list" in group:
group_type = "standard"
users = group["user-list"]
else:
self._log.error("Invalid group dict for group '%s': %s",
name, str(group))
raise Exception()
self.group_type = group_type
self.users = users
self.size = int(len(self.users))
self.name = str(name)
self._log.debug("Finished initializing Group '%s' with %d users",
self.name, self.size)
def __str__(self):
return self.name
def __eq__(self, other):
return self.name == other.name and self.users == other.users and \
self.group_type == other.group_type
def __ne__(self, other):
return not self.__eq__(other)
def get_ad_groups(groups):
"""
Extracts Active Directory-type groups from a dict of groups.
:param dict groups: Dict of groups and lists of groups
:return: List of AD groups extracted
:rtype: list(:class:`Group`)
"""
ad_groups = []
for _, group in groups.items(): # Ignore the group name, nab the group
if isinstance(group, list):
for i in group:
if isinstance(i, Group):
if i.group_type == "ad":
ad_groups.append(i)
elif isinstance(group, Group):
if group.group_type == "ad":
ad_groups.append(group)
else:
logging.error("Invalid type '%s' for a group in get_ad_groups: %s",
type(group).__name__, str(group))
return ad_groups | ADLES | /ADLES-1.4.0.tar.gz/ADLES-1.4.0/adles/group.py | group.py |
import ipaddress
import logging
import os
import sys
from io import TextIOWrapper
from typing import Optional, Tuple
from yaml import YAMLError, load
try: # Attempt to use C-based YAML parser if it's available
from yaml import CLoader as Loader
except ImportError: # Fallback to using pure Python YAML parser
from yaml import Loader # noqa: T484
from adles import utils
# PyYAML Reference: http://pyyaml.org/wiki/PyYAMLDocumentation
def parse_yaml_file(file: TextIOWrapper) -> Optional[dict]:
"""Parses a YAML file and returns a nested dictionary containing its contents.
:param file: Handle of file to parse
:return: Parsed file contents"""
try:
# Parses the YAML file into a dict
return load(file, Loader=Loader)
except YAMLError as exc:
logging.critical("Could not parse YAML file %s", file.name)
if hasattr(exc, 'problem_mark'):
# Tell user exactly where the syntax error is
mark = exc.problem_mark
logging.error("Error position: (%s:%s)",
mark.line + 1, mark.column + 1)
else:
logging.error("Error: %s", exc)
return None
# PyYAML Reference: http://pyyaml.org/wiki/PyYAMLDocumentation
def parse_yaml(filename: str) -> Optional[dict]:
"""Parses a YAML file and returns a nested dictionary containing its contents.
:param filename: Name of YAML file to parse
:return: Parsed file contents"""
try:
# Enables use of stdin if '-' is specified
with sys.stdin if filename == '-' else open(filename) as f:
try:
# Parses the YAML file into a dict
return load(f, Loader=Loader)
except YAMLError as exc:
logging.critical("Could not parse YAML file %s", filename)
if hasattr(exc, 'problem_mark'):
# Tell user exactly where the syntax error is
mark = exc.problem_mark
logging.error("Error position: (%s:%s)",
mark.line + 1, mark.column + 1)
else:
logging.error("Error: %s", exc)
return None
except FileNotFoundError:
logging.critical("Could not find YAML file for parsing: %s", filename)
return None
def _checker(value_list: list, source: str, data: dict, flag: str) -> int:
"""Checks if values in the list are in data (Syntax warnings or errors).
:param value_list: List of values to check
:param source: Name of source that's being checked
:param data: Data being checked
:param flag: What to do if value not found ("warnings" | "errors")
:return: Number of hits (warnings/errors)"""
num_hits = 0
for value in value_list:
if value not in data:
if flag == "warnings":
logging.warning("Missing %s in %s", value, source)
elif flag == "errors":
logging.error("Missing %s in %s", value, source)
else:
logging.error("Invalid flag for _checker: %s", flag)
num_hits += 1
if num_hits > 0:
logging.info("Total number of %s in %s: %d", flag, source, num_hits)
return num_hits
def _verify_exercise_metadata_syntax(metadata: dict) -> Tuple[int, int]:
"""Verifies that the syntax for exercise metadata matches the specification.
:param metadata: metadata
:return: Number of errors, Number of warnings"""
warnings = ["description", "version", "folder-name"]
errors = ["name", "prefix", "infra-file"]
num_warnings = _checker(warnings, "metadata", metadata, "warnings")
num_errors = _checker(errors, "metadata", metadata, "errors")
if "infra-file" in metadata:
infra_file = metadata["infra-file"]
if not os.path.exists(infra_file):
logging.error("Could not open infra-file '%s'", infra_file)
num_errors += 1
else:
err, warn = verify_infra_syntax(parse_yaml(infra_file))
num_errors += err
num_warnings += warn
return num_errors, num_warnings
def _verify_groups_syntax(groups: dict) -> Tuple[int, int]:
"""Verifies that the syntax for groups matches the specification.
:param groups: groups
:return: Number of errors, Number of warnings"""
num_warnings = 0
num_errors = 0
for key, value in groups.items():
if "instances" in value: # Template groups
if not isinstance(value["instances"], int):
logging.error("Instances must be an Integer for group %s", key)
num_errors += 1
if "ad-group" in value:
if not isinstance(value["ad-group"], str):
logging.error("AD group must be a string")
num_errors += 1
elif "filename" in value:
e, w = _check_group_file(value["filename"])
num_errors += e
num_warnings += w
else:
logging.error("Invalid user specification method for "
"template group %s", key)
num_errors += 1
else: # Regular groups (not templates)
if "ad-group" in value:
if not isinstance(value["ad-group"], str):
logging.error("AD group must be a string")
num_errors += 1
elif "filename" in value:
e, w = _check_group_file(value["filename"])
num_errors += e
num_warnings += w
elif "user-list" in value:
if not isinstance(value["user-list"], list):
logging.error("Username specification must be a "
"list for group %s", key)
num_errors += 1
else:
logging.error("Invalid user specification method "
"for group %s", key)
num_errors += 1
return num_errors, num_warnings
def _check_group_file(filename: str) -> Tuple[int, int]:
"""Verifies user info file for a group.
:param filename: Name of user info JSON file
:return: Number of errors, Number of warnings"""
num_warnings = 0
num_errors = 0
if utils.read_json(filename) is None:
logging.error("Invalid user info file %s", filename)
num_errors += 1
return num_errors, num_warnings
def _verify_services_syntax(services: dict) -> Tuple[int, int]:
"""Verifies that the syntax for services matches the specification.
:param dict services: services
:return: Number of errors, Number of warnings"""
num_warnings = 0
num_errors = 0
for key, value in services.items():
if "network-interfaces" in value and \
not isinstance(value["network-interfaces"], list):
logging.error("Network interfaces must be a list for "
"service %s", key)
num_errors += 1
if "provisioner" in value:
num_errors += _checker(["name", "file"],
"provisioner for service %s" % key,
value["provisioner"], "errors")
if "note" in value and not isinstance(value["note"], str):
logging.error("Note must be a string for service %s", key)
num_errors += 1
if "template" in value:
pass
elif "image" in value or "dockerfile" in value:
pass
elif "compose-file" in value:
pass
else:
logging.error("Invalid service definition: %s", key)
num_errors += 1
return num_errors, num_warnings
def _verify_resources_syntax(resources: dict) -> Tuple[int, int]:
"""Verifies that the syntax for resources matches the specification.
:param dict resources: resources
:return: Number of errors, Number of warnings"""
warnings = []
errors = ["lab", "resource"]
num_warnings = _checker(warnings, "resources", resources, "warnings")
num_errors = _checker(errors, "resources", resources, "errors")
return num_errors, num_warnings
def _verify_networks_syntax(networks: dict) -> Tuple[int, int]:
"""Verifies that the syntax for networks matches the specification.
:param networks: networks
:return: Number of errors, Number of warnings"""
num_warnings = 0
num_errors = 0
net_types = ["unique-networks", "generic-networks"]
if not any(net in networks for net in net_types):
logging.error("Network specification exists but is empty!")
num_errors += 1
else:
for name, network in networks.items():
err, warn = _verify_network(name, network)
num_errors += err
num_warnings += warn
return num_errors, num_warnings
def _verify_network(name: str, network: dict) -> Tuple[int, int]:
"""Verifies syntax of a specific network.
:param name: Name of network
:param network: the network
:return: Number of errors, Number of warnings"""
num_warnings = 0
num_errors = 0
for key, value in network.items():
# Subnet verification
if "subnet" not in value:
logging.warning("No subnet specified for %s %s", name, key)
num_warnings += 1
else:
try:
subnet = ipaddress.ip_network(value["subnet"])
except ValueError as err:
logging.error("Invalid format for subnet '%s': %s",
str(value["subnet"]), str(err))
num_errors += 1
else:
if subnet.is_reserved \
or subnet.is_link_local \
or subnet.is_multicast \
or subnet.is_loopback:
logging.error("%s %s is in a invalid IP address space",
name, key)
num_errors += 1
elif not subnet.is_private:
logging.warning("Non-private subnet used for %s %s",
name, key)
num_warnings += 1
# VLAN verification
if "vlan" in value:
if name == "unique-networks" and int(value["vlan"]) >= 2000:
logging.error("VLAN must be less than 2000 for network %s", key)
num_errors += 1
elif name == "generic-networks":
logging.error("VLAN specification is not allowed "
"for network %s", key)
num_errors += 1
# Increment verification
if "increment" in value:
if name == "unique-networks":
logging.error("Increment cannot be used for network %s", key)
num_errors += 1
elif not isinstance(value["increment"], bool):
logging.error("Increment must be a boolean for network %s", key)
num_errors += 1
return num_errors, num_warnings
def _verify_folders_syntax(folders: dict) -> Tuple[int, int]:
"""Verifies that the syntax for folders matches the specification.
:param folders: folders
:return: Number of errors, Number of warnings"""
num_warnings = 0
num_errors = 0
keywords = ["group", "master-group", "instances", "description", "enabled"]
for key, value in folders.items():
if key in keywords:
continue
if not isinstance(value, dict):
logging.error("Invalid configuration %s", str(key))
num_errors += 1
continue
# Check instances syntax, regardless of parent or base
if "instances" in value:
if not isinstance(value["instances"], int):
pass
elif "number" in value["instances"]:
if not isinstance(value["instances"]["number"], int):
logging.error("Number of instances for folder '%s' "
"must be an Integer", key)
num_errors += 1
elif "size-of" in value["instances"]:
pass
else:
logging.error("Must specify number of instances "
"for folder '%s'", key)
num_errors += 1
# Check if parent or base
if "services" in value: # It's a base folder
if "group" not in value:
logging.error("No group specified for folder '%s'", key)
num_errors += 1
for skey, svalue in value["services"].items():
if "service" not in svalue:
logging.error("Service %s is unnamed in folder '%s'",
skey, key)
num_errors += 1
if "networks" in svalue and \
not isinstance(svalue["networks"], list):
logging.error("Network specifications must be a list "
"for service '%s' "
"in folder '%s'", skey, key)
num_errors += 1
if "scoring" in svalue:
err, warn = _verify_scoring_syntax(skey, svalue["scoring"])
num_errors += err
num_warnings += warn
else: # It's a parent folder
if not isinstance(value, dict):
logging.error("Could not verify syntax of folder '%s': "
"'%s' is not a folder!",
str(key), str(value))
num_errors += 1
else:
err, warn = _verify_folders_syntax(value)
num_errors += err
num_warnings += warn
return num_errors, num_warnings
def _verify_scoring_syntax(service_name: str, scoring: dict) -> Tuple[int, int]:
"""Verifies syntax for the scoring definition of a service.
:param service_name: Name of the service for which the
scoring specification applies
:param scoring: scoring parameters
:return: Number of errors, Number of warnings"""
warnings = ["ports", "protocols"]
errors = ["criteria"]
num_warnings = _checker(warnings, "service %s" %
service_name, scoring, "warnings")
num_errors = _checker(errors, "service %s"
% service_name, scoring, "errors")
return num_errors, num_warnings
def verify_infra_syntax(infra: dict) -> Tuple[int, int]:
"""Verifies the syntax of an infrastructure specification.
:param infra: infrastructure
:return: Number of errors, Number of warnings"""
num_warnings = 0
num_errors = 0
warnings = []
errors = []
for platform, config in infra.items():
if platform == "vmware-vsphere": # VMware vSphere configurations
warnings = ["port", "login-file", "datacenter",
"datastore", "server-root", "vswitch"]
errors = ["hostname", "template-folder"]
if "login-file" in config and \
utils.read_json(config["login-file"]) is None:
logging.error("Invalid vSphere infrastructure login-file: %s",
config["login-file"])
num_errors += 1
if "host-list" in config and \
not isinstance(config["host-list"], list):
logging.error("Invalid type for vSphere host-list: %s",
type(config["host-list"]))
num_errors += 1
if "thresholds" in config:
num_errors += _checker(["folder", "service"], "infrastructure",
config["thresholds"], "errors")
elif platform == "docker": # Docker configurations
warnings = ["url"]
errors = []
if "registry" in config:
num_errors += _checker(["url", "login-file"], "infrastructure",
config["registry"], "errors")
elif platform in ["cloud"]:
logging.info("Platform %s is not yet implemented", platform)
else:
logging.error("Unknown infrastructure platform: %s", str(platform))
num_warnings += 1
continue # Skip the syntax verification of unknown platforms
num_warnings += _checker(warnings, "infrastructure", config, "warnings")
num_errors += _checker(errors, "infrastructure", config, "errors")
return num_errors, num_warnings
def verify_exercise_syntax(spec: dict) -> Tuple[int, int]:
"""Verifies the syntax of an environment specification.
:param spec: Dictionary of environment specification
:return: Number of errors, Number of warnings"""
num_warnings = 0
num_errors = 0
funcs = {"metadata": _verify_exercise_metadata_syntax,
"groups": _verify_groups_syntax,
"services": _verify_services_syntax,
"resources": _verify_resources_syntax,
"networks": _verify_networks_syntax,
"folders": _verify_folders_syntax}
required = ["metadata", "groups", "services", "networks", "folders"]
optional = ["resources"]
for key, func in funcs.items():
if key not in spec:
if key in required:
logging.error("Required definition %s was not found", key)
num_errors += 1
elif key in optional:
logging.info('Optional definition "%s" was not found', key)
else:
logging.warning("Unknown definition found: %s", key)
num_warnings += 1
else:
err, warn = func(spec[key])
num_errors += err
num_warnings += warn
return num_errors, num_warnings
def verify_package_syntax(package: dict) -> Tuple[int, int]:
"""Verifies the syntax of an package specification.
:param package: Dictionary representation of the package specification
:return: Number of errors, Number of warnings"""
num_warnings = 0
num_errors = 0
# Check syntax of metadata section
if "metadata" not in package:
logging.error("Metadata section not specified for package!")
num_errors += 1
else:
metadata_warnings = ["name", "description", "version"]
metadata_errors = ["timestamp", "tag"]
num_warnings += _checker(metadata_warnings, "metadata",
package["metadata"], "warnings")
num_errors += _checker(metadata_errors, "metadata",
package["metadata"], "errors")
# Check syntax of contents section
if "contents" not in package:
logging.error("Contents section not specified for package!")
num_errors += 1
else:
content_warnings = ["infrastructure", "scoring", "results",
"templates", "materials"]
content_errors = ["environment"]
num_warnings += _checker(content_warnings, "contents",
package["contents"], "warnings")
num_errors += _checker(content_errors, "contents",
package["contents"], "errors")
return num_errors, num_warnings
def check_syntax(specfile_path: str,
spec_type: str = "exercise") -> Optional[dict]:
"""Checks the syntax of a specification file.
:param specfile_path: Path to the YAML specification file
:param spec_type: Type of specification file
(exercise | package | infra)
:return: The specification """
spec = parse_yaml(specfile_path)
if spec is None:
logging.critical("Failed to ingest specification file %s",
os.path.basename(specfile_path))
return None
logging.info("Successfully ingested specification file '%s'",
os.path.basename(specfile_path))
if spec_type == "exercise":
logging.info("Checking exercise syntax...")
errors, warnings = verify_exercise_syntax(spec)
elif spec_type == "package":
logging.info("Checking package syntax...")
errors, warnings = verify_package_syntax(spec)
elif spec_type == "infra":
logging.info("Checking infrastructure syntax...")
errors, warnings = verify_infra_syntax(spec)
else:
logging.error("Unknown specification type in for check_syntax: %s",
str(spec_type))
return None
if errors == 0 and warnings == 0:
logging.info("Syntax check successful!")
return spec
elif errors == 0:
logging.warning("Syntax check successful, but there were %d warnings",
warnings)
return spec
else:
logging.error("Syntax check failed! Errors: %d\tWarnings: %d",
errors, warnings)
return None | ADLES | /ADLES-1.4.0.tar.gz/ADLES-1.4.0/adles/parser.py | parser.py |
import logging
from adles.interfaces import Interface
class PlatformInterface(Interface):
"""Generic interface used to uniformly interact with
platform-specific interfaces."""
def __init__(self, infra, spec):
"""
:param dict infra: Full infrastructure configuration
:param dict spec: Full exercise specification
"""
super(PlatformInterface, self).__init__(infra=infra, spec=spec)
self._log = logging.getLogger(str(self.__class__))
self._log.debug("Initializing %s", self.__class__)
self.interfaces = [] # List of instantiated platform interfaces
# Select the Interface to use based on
# the specified infrastructure platform
for platform, config in infra.items():
if platform == "vmware-vsphere":
from adles.interfaces.vsphere_interface import VsphereInterface
self.interfaces.append(VsphereInterface(config, spec))
elif platform == "docker":
from adles.interfaces.docker_interface import DockerInterface
self.interfaces.append(DockerInterface(config, spec))
elif platform == "cloud":
from adles.interfaces.cloud_interface import CloudInterface
self.interfaces.append(CloudInterface(config, spec))
else:
self._log.error("Invalid platform: %s", str(platform))
raise ValueError
# @time_execution
def create_masters(self):
"""Master creation phase."""
self._log.info("Creating Master instances for %s", self.metadata["name"])
for i in self.interfaces:
i.create_masters()
# @time_execution
def deploy_environment(self):
"""Environment deployment phase."""
self._log.info("Deploying environment for %s", self.metadata["name"])
for i in self.interfaces:
i.deploy_environment()
# @time_execution
def cleanup_masters(self, network_cleanup=False):
"""
Cleans up master instances.
:param bool network_cleanup: If networks should be cleaned up
"""
self._log.info("Cleaning up Master instances for %s", self.metadata["name"])
for i in self.interfaces:
i.cleanup_masters(network_cleanup=network_cleanup)
# @time_execution
def cleanup_environment(self, network_cleanup=False):
"""
Cleans up a deployed environment.
:param bool network_cleanup: If networks should be cleaned up
"""
self._log.info("Cleaning up environment for %s", self.metadata["name"])
for i in self.interfaces:
i.cleanup_masters(network_cleanup=network_cleanup) | ADLES | /ADLES-1.4.0.tar.gz/ADLES-1.4.0/adles/interfaces/platform_interface.py | platform_interface.py |
import logging
try:
import docker # NOTE(cgoes): has not been tested with Python 3.6 yet
except ImportError:
logging.error("Could not import docker module. "
"Install it using 'pip install docker'")
from adles import utils
from adles.interfaces import Interface
class DockerInterface(Interface):
"""Generic interface for the Docker platform."""
def __init__(self, infra, spec):
"""
:param dict infra: Dict of infrastructure information
:param dict spec: Dict of a parsed specification
"""
super(DockerInterface, self).__init__(infra=infra, spec=spec)
self._log = logging.getLogger(str(self.__class__))
self._log.debug("Initializing %s", self.__class__)
# If needed, a wrapper class that simplifies
# the creation of containers will be made
# Reference:
# https://docker-py.readthedocs.io/en/stable/client.html#client-reference
# Initialize the Docker client
self.client = docker.DockerClient(base_url=infra.get("url",
"unix:///var/run/"
"docker.sock"),
tls=bool(infra.get("tls", True)))
# Verify the connection to the client
self.client.ping()
self._log.debug("System info : %s", str(self.client.info()))
self._log.debug("System version : %s", str(self.client.version()))
# Authenticate to registry, if configured
if "registry" in self.infra:
reg = self.infra["registry"]
reg_logins = utils.read_json(reg["login-file"])
self.client.login(username=reg_logins["user"],
password=reg_logins["pass"],
registry=reg["url"])
# List images currently on the server
self._log.debug("Images: %s", str(self.client.images.list()))
def create_masters(self):
pass
def deploy_environment(self):
pass
def cleanup_masters(self, network_cleanup=False):
pass
def cleanup_environment(self, network_cleanup=False):
pass
def __str__(self):
return str(self.client.info() + "\nVersion:\t" + self.client.version())
def __eq__(self, other):
return super(self.__class__, self).__eq__(other) \
and self.client == other.client | ADLES | /ADLES-1.4.0.tar.gz/ADLES-1.4.0/adles/interfaces/docker_interface.py | docker_interface.py |
import logging
import os
from adles.interfaces import Interface
from adles.utils import get_vlan, pad, read_json
from adles.vsphere import Vsphere
from adles.vsphere.folder_utils import format_structure
from adles.vsphere.network_utils import create_portgroup
from adles.vsphere.vm import VM
from adles.vsphere.vsphere_utils import VsphereException, is_folder, is_vm
class VsphereInterface(Interface):
"""Generic interface for the VMware vSphere platform."""
def __init__(self, infra, spec):
"""
.. warning:: The infrastructure and spec are assumed to be valid,
therefore checks on key existence and types are NOT performed
for REQUIRED elements.
:param dict infra: Infrastructure information
:param dict spec: The parsed exercise specification
"""
super(VsphereInterface, self).__init__(infra=infra, spec=spec)
self._log = logging.getLogger(str(self.__class__))
self._log.debug("Initializing %s", self.__class__)
self.master_folder = None
self.template_folder = None
# Used to do lookups of Generic networks during deployment
self.net_table = {}
# Cache containing Master instances (TODO: potential naming conflicts)
self.masters = {}
if "thresholds" in infra:
self.thresholds = infra["thresholds"]
else:
self.thresholds = {
"folder": {
"warn": 25,
"error": 50},
"service": {
"warn": 50,
"error": 70}
}
# Read infrastructure login information
if "login-file" in infra:
logins = read_json(infra["login-file"])
else:
self._log.warning("No login-file specified, "
"defaulting to user prompts...")
logins = {}
# Instantiate the vSphere vCenter server instance class
self.server = Vsphere(username=logins.get("user"),
password=logins.get("pass"),
hostname=infra.get("hostname"),
port=int(infra.get("port")),
datastore=infra.get("datastore"),
datacenter=infra.get("datacenter"))
# Acquire ESXi hosts
if "hosts" in infra:
hosts = infra["hosts"]
self.host = self.server.get_host(hosts[0])
# Gather all the ESXi hosts
self.hosts = [self.server.get_host(h) for h in hosts]
else:
self.host = self.server.get_host() # First host found in Datacenter
# Instantiate and initialize Groups
self.groups = self._init_groups()
# Set the server root folder
if "server-root" in infra:
self.server_root = self.server.get_folder(infra["server-root"])
if not self.server_root:
self._log.error("Could not find server-root folder '%s'",
infra["server-root"])
raise VsphereException("Could not find server root folder")
else: # Default to Datacenter VM folder
self.server_root = self.server.datacenter.vmFolder
self._log.info("Server root folder: %s", self.server_root.name)
# Set environment root folder (TODO: this can be consolidated)
if "folder-name" not in self.metadata:
self.root_path, self.root_name = ("", self.metadata["name"])
self.root_folder = self.server_root.traverse_path(self.root_name,
generate=True)
else:
self.root_path, self.root_name = os.path.split(
self.metadata["folder-name"])
self.root_folder = self.server_root.traverse_path(
self.metadata["folder-name"], generate=True)
self._log.debug("Environment root folder name: %s", self.root_name)
if not self.root_folder: # Create if it's not found
parent = self.server_root.traverse_path(self.root_path)
self.root_folder = self.server.create_folder(self.root_name, parent)
if not self.root_folder:
self._log.error("Could not create root folder '%s'",
self.root_name)
raise VsphereException("Could not create root folder")
self._log.info("Environment root folder: %s", self.root_folder.name)
# Set default vSwitch name
if "vswitch" in infra:
self.vswitch_name = infra["vswitch"]
else:
from pyVmomi import vim
self.vswitch_name = self.server.get_item(vim.Network).name
self._log.debug("Finished initializing VsphereInterface")
def _init_groups(self):
"""
Instantiate and initialize Groups.
:return: Initialized Groups
:rtype: dict(:class:`Group`)
"""
from adles.group import Group, get_ad_groups
groups = {}
# Instantiate Groups
for name, config in self.spec["groups"].items():
if "instances" in config: # Template groups
groups[name] = [Group(name, config, i)
for i in range(1, config["instances"] + 1)]
else: # Standard groups
groups[name] = Group(name=name, group=config)
# Initialize Active Directory-type Group user names
ad_groups = get_ad_groups(groups)
for group in ad_groups:
# res = self.server.get_users(belong_to_group=g.ad_group,
# find_users=True)
res = None
if res is not None:
for result in res:
# Reference: pyvmomi/docs/vim/UserSearchResult.rst
if result.group is True:
self._log.error("Result '%s' is not a user",
str(result))
else:
group.users.append(result.principal)
# Set the size, default to 1
group.size = (len(group.users) if len(group.users) > 1 else 1)
else:
self._log.error("Could not initialize AD-group %s",
str(group.ad_group))
if hasattr(self.server.user_dir, "domainList"):
self._log.debug("Domains on server: %s",
str(self.server.user_dir.domainList))
return groups
def create_masters(self):
""" Exercise Environment Master creation phase. """
# Get folder containing templates
self.template_folder = self.server_root.traverse_path(
self.infra["template-folder"])
if not self.template_folder:
self._log.error("Could not find template folder in path '%s'",
self.infra["template-folder"])
return
else:
self._log.debug("Found template folder: '%s'",
self.template_folder.name)
# Create master folder to hold base service instances
self.master_folder = self.root_folder.traverse_path(
self.master_root_name)
if not self.master_folder:
self.master_folder = self.server.create_folder(
self.master_root_name, self.root_folder)
self._log.info("Created Master folder '%s' in '%s'",
self.master_root_name, self.root_name)
# Create networks for master instances
for net in self.networks:
# Iterate through the base network types (unique and generic)
self._create_master_networks(net_type=net, default_create=True)
# Create Master instances
self._master_parent_folder_gen(self.folders, self.master_folder)
# Output fully deployed master folder tree to debugging
self._log.debug(format_structure(self.root_folder.enumerate()))
def _master_parent_folder_gen(self, folder, parent):
"""
Generates parent-type Master folders.
:param dict folder: Dict with the folder tree structure as in spec
:param parent: Parent folder
:type parent: vim.Folder
"""
skip_keys = ["instances", "description", "enabled"]
if not self._is_enabled(folder): # Check if disabled
self._log.warning("Skipping disabled parent-type folder %s",
parent.name)
return
# We have to check every item, as they could be keywords or sub-folders
for sub_name, sub_value in folder.items():
if sub_name in skip_keys:
# Skip configurations that are not relevant
continue
elif sub_name == "group":
pass # group = self._get_group(sub_value)
elif sub_name == "master-group":
pass # master_group = self._get_group(sub_value)
else:
folder_name = self.master_prefix + sub_name
new_folder = self.server.create_folder(folder_name,
create_in=parent)
if "services" in sub_value: # It's a base folder
if self._is_enabled(sub_value):
self._log.info("Generating Master base-type folder %s",
sub_name)
self._master_base_folder_gen(sub_name, sub_value,
new_folder)
else:
self._log.warning("Skipping disabled "
"base-type folder %s", sub_name)
else: # It's a parent folder, recurse
if self._is_enabled(sub_value):
self._master_parent_folder_gen(sub_value,
parent=new_folder)
self._log.info("Generating Master "
"parent-type folder %s", sub_name)
else:
self._log.warning("Skipping disabled "
"parent-type folder %s", sub_name)
def _master_base_folder_gen(self, folder_name, folder_dict, parent):
"""
Generates base-type Master folders.
:param str folder_name: Name of the base folder
:param dict folder_dict: Dict with the base folder tree as in spec
:param parent: Parent folder
:type parent: vim.Folder
"""
# Set the group to apply permissions for
# if "master-group" in folder_dict:
# master_group = self._get_group(folder_dict["master-group"])
# else:
# master_group = self._get_group(folder_dict["group"])
# Create Master instances
for sname, sconfig in folder_dict["services"].items():
if not self._is_vsphere(sconfig["service"]):
self._log.debug("Skipping non-vsphere service '%s'", sname)
continue
self._log.info("Creating Master instance '%s' from service '%s'",
sname, sconfig["service"])
vm = self._create_service(parent, sconfig["service"],
sconfig["networks"])
if vm is None:
self._log.error("Failed to create Master instance '%s' "
"in folder '%s'", sname, folder_name)
continue # Skip to the next service
def _create_service(self, folder, service_name, networks):
"""
Retrieves and clones a service into a master folder.
:param folder: Folder to create service in
:type folder: vim.Folder
:param str service_name: Name of the service to clone
:param list networks: Networks to configure the service with
:return: The service VM instance
:rtype: :class:`VM`
"""
if not self._is_vsphere(service_name):
self._log.debug("Skipping non-vsphere service '%s'", service_name)
return None
config = self.services[service_name]
vm_name = self.master_prefix + service_name
test = folder.traverse_path(vm_name) # Check service already exists
if test is None:
# Find the template that matches the service definition
template = self.template_folder.traverse_path(config["template"])
if not template:
self._log.error("Could not find template '%s' for service '%s'",
config["template"], service_name)
return None
self._log.info("Creating service '%s'", service_name)
vm = VM(name=vm_name, folder=folder,
resource_pool=self.server.get_pool(),
datastore=self.server.datastore, host=self.host)
if not vm.create(template=template):
return None
else:
self._log.warning("Service %s already exists", service_name)
vm = VM(vm=test)
if vm.is_template(): # Check if it's been converted already
self._log.warning("Service %s is a Template, "
"skipping configuration", service_name)
return vm
# Resource configurations (minus storage currently)
if "resource-config" in config:
vm.edit_resources(**config["resource-config"])
if "note" in config: # Set VM note if specified
vm.set_note(config["note"])
# NOTE: management interfaces matter here!
# (If implemented with Monitoring extensions)
self._configure_nics(vm, networks=networks) # Configure VM NICs
# Post-creation snapshot
vm.create_snapshot("Start of Mastering",
"Beginning of Mastering phase for exercise %s",
self.metadata["name"])
return vm
def _create_master_networks(self, net_type, default_create):
"""
Creates a network as part of the Master creation phase.
:param str net_type: Top-level type of the network
(unique | generic | base)
:param bool default_create: Whether to create networks
if they don't already exist
"""
# Pick up any recent changes to the host's network status
self.host.configManager.networkSystem.RefreshNetworkSystem()
self._log.info("Creating %s", net_type)
for name, config in self.networks[net_type].items():
exists = self.server.get_network(name)
if exists:
self._log.info("PortGroup '%s' already exists on host '%s'",
name, self.host.name)
else: # NOTE: if monitoring, we want promiscuous=True
self._log.warning("PortGroup '%s' does not exist on host '%s'",
name, self.host.name)
if default_create:
self._log.info("Creating portgroup '%s' on host '%s'",
name, self.host.name)
create_portgroup(name=name, host=self.host,
promiscuous=False,
vlan=int(config.get("vlan",
next(get_vlan()))),
vswitch_name=config.get("vswitch",
self.vswitch_name))
def _configure_nics(self, vm, networks, instance=None):
"""
Configures Virtual Network Interfaces Cards (vNICs)
for a service instance.
:param vm: Virtual Machine to configure vNICs on
:type vm: vim.VirtualMachine
:param list networks: List of networks to configure
:param int instance: Current instance of a folder
for Deployment purposes
"""
self._log.info("Editing NICs for VM '%s'", vm.name)
num_nics = len(list(vm.network))
num_nets = len(networks)
nets = networks # Copy the passed variable so we can edit it later
# Ensure number of NICs on VM
# matches number of networks configured for the service
#
# Note that monitoring interfaces will be
# counted and included in the networks list
if num_nics > num_nets: # Remove excess interfaces
diff = int(num_nics - num_nets)
self._log.debug("VM '%s' has %d extra NICs, removing...",
vm.name, diff)
for _, nic in enumerate(reversed(range(num_nics)), start=1):
vm.remove_nic(nic)
elif num_nics < num_nets: # Create missing interfaces
diff = int(num_nets - num_nics)
self._log.debug("VM '%s' is deficient %d NICs, adding...",
vm.name, diff)
# Add NICs to VM and pop them from the list of networks
for _ in range(diff):
# Select NIC hardware
nic_model = ("vmxnet3" if vm.has_tools() else "e1000")
net_name = nets.pop()
vm.add_nic(network=self.server.get_network(net_name),
model=nic_model, summary=net_name)
# Edit the interfaces
# (NOTE: any NICs added earlier shouldn't be affected by this)
for i, net_name in enumerate(networks, start=1):
# Setting the summary to network name
# allows viewing of name without requiring
# read permissions to the network itself
if instance is not None:
# Resolve generic networks for deployment phase
net_name = self._get_net(net_name, instance)
network = self.server.get_network(net_name)
if vm.get_nic_by_id(i).backing.network == network:
continue # Skip NICs that are already configured
else:
vm.edit_nic(nic_id=i, network=network, summary=net_name)
def deploy_environment(self):
""" Exercise Environment deployment phase """
self.master_folder = self.root_folder.traverse_path(
self.master_root_name)
if self.master_folder is None: # Check if Master folder was found
self._log.error("Could not find Master folder '%s'. "
"Please ensure the Master Creation phase "
"has been run and the folder exists "
"before attempting Deployment",
self.master_root_name)
raise VsphereException("Could not find Master folder")
self._log.debug("Master folder name: %s\tPrefix: %s",
self.master_folder.name, self.master_prefix)
# Verify and convert Master instances to templates
self._log.info("Validating and converting Masters to Templates")
self._convert_and_verify(folder=self.master_folder)
self._log.info("Finished validating "
"and converting Masters to Templates")
self._log.info("Deploying environment...")
self._deploy_parent_folder_gen(spec=self.folders,
parent=self.root_folder,
path="")
self._log.info("Finished deploying environment")
# Output fully deployed environment tree to debugging
self._log.debug(format_structure(self.root_folder.enumerate()))
def _convert_and_verify(self, folder):
"""
Converts Masters to Templates before deployment.
This also ensures they are powered off before being cloned.
:param folder: Folder containing Master instances to convert and verify
:type folder: vim.Folder
"""
self._log.debug("Converting Masters in folder '%s' to templates",
folder.name)
for item in folder.childEntity:
if is_vm(item):
vm = VM(vm=item)
self.masters[vm.name] = vm
if vm.is_template():
# Skip if they already exist from a previous run
self._log.debug("Master '%s' is already a template",
vm.name)
continue
# Cleanly power off VM before converting to template
if vm.powered_on():
vm.change_state("off", attempt_guest=True)
# Take a snapshot to allow reverts to the start of the exercise
vm.create_snapshot("Start of exercise",
"Beginning of deployment phase, "
"post-master configuration")
# Convert Master instance to Template
vm.convert_template()
if not vm.is_template():
self._log.error("Master '%s' did not convert to Template",
vm.name)
else:
self._log.debug("Converted Master '%s' to Template",
vm.name)
elif is_folder(item): # Recurse into sub-folders
self._convert_and_verify(item)
else:
self._log.debug("Unknown item found while "
"templatizing Masters: %s", str(item))
def _deploy_parent_folder_gen(self, spec, parent, path):
"""
Generates parent-type folder trees.
:param dict spec: Dict with folder specification
:param parent: Parent folder
:type parent: vim.Folder
:param str path: Folders path at the current level
"""
skip_keys = ["instances", "description", "master-group", "enabled"]
if not self._is_enabled(spec): # Check if disabled
self._log.warning("Skipping disabled parent-type folder %s",
parent.name)
return
for sub_name, sub_value in spec.items():
if sub_name in skip_keys:
# Skip configurations that are not relevant
continue
elif sub_name == "group": # Configure group
pass # group = self._get_group(sub_value)
else: # Create instances of the parent folder
self._log.debug("Deploying parent-type folder '%s'", sub_name)
num_instances, prefix = self._instances_handler(spec,
sub_name,
"folder")
for i in range(num_instances):
# If prefix is undefined or there's a single instance,
# use the folder's name
instance_name = (sub_name
if prefix == "" or num_instances == 1
else prefix)
# If multiple instances, append padded instance number
instance_name += (pad(i) if num_instances > 1 else "")
# Create a folder for the instance
new_folder = self.server.create_folder(instance_name,
create_in=parent)
if "services" in sub_value: # It's a base folder
if self._is_enabled(sub_value):
self._deploy_base_folder_gen(folder_name=sub_name,
folder_items=sub_value,
parent=new_folder,
path=self._path(
path, sub_name))
else:
self._log.warning("Skipping disabled "
"base-type folder %s", sub_name)
else: # It's a parent folder
if self._is_enabled(sub_value):
self._deploy_parent_folder_gen(parent=new_folder,
spec=sub_value,
path=self._path(
path, sub_name))
else:
self._log.warning("Skipping disabled "
"parent-type folder %s", sub_name)
def _deploy_base_folder_gen(self, folder_name, folder_items, parent, path):
"""
Generates folder tree for deployment stage.
:param str folder_name: Name of the folder
:param dict folder_items: Dict of items in the folder
:param parent: Parent folder
:type parent: vim.Folder
:param str path: Folders path at the current level
"""
# Set the group to apply permissions for
# group = self._get_group(folder_items["group"])
# Check if number of instances for the folder exceeds configured limits
num_instances, prefix = self._instances_handler(folder_items,
folder_name, "folder")
# Create instances
self._log.info("Deploying base-type folder '%s'", folder_name)
for i in range(num_instances):
# If no prefix is defined or there's only a single instance,
# use the folder's name
instance_name = (folder_name
if prefix == "" or num_instances == 1
else prefix)
# If multiple instances, append padded instance number
instance_name += (pad(i) if num_instances > 1 else "")
if num_instances > 1: # Create a folder for the instance
new_folder = self.server.create_folder(instance_name,
create_in=parent)
else: # Don't duplicate folder name for single instances
new_folder = parent
# Use the folder's name for the path,
# as that's what matches the Master version
self._log.info("Generating services for "
"base-type folder instance '%s'", instance_name)
self._deploy_gen_services(services=folder_items["services"],
parent=new_folder,
path=path, instance=i)
def _deploy_gen_services(self, services, parent, path, instance):
"""
Generates the services in a folder.
:param dict services: The "services" dict in a folder
:param parent: Parent folder
:type parent: vim.Folder
:param str path: Folders path at the current level
:param int instance: What instance of a base folder this is
"""
# Iterate through the services
for service_name, value in services.items():
if not self._is_vsphere(value["service"]):
# Ignore non-vsphere services
self._log.debug("Skipping non-vsphere service '%s'",
service_name)
continue
self._log.info("Generating service '%s' in folder '%s'",
service_name, parent.name)
# Check if number of instances for service exceeds configured limits
num_instances, prefix = self._instances_handler(value,
service_name,
"service")
# Get the Master template instance to clone from
master = self.masters.get(self.master_prefix + value["service"],
None)
if master is None: # Check if the lookup was successful
self._log.error("Couldn't find Master for service '%s' "
"in this path:\n%s", value["service"], path)
continue # Skip to the next service
# Clone the instances of the service from the master
for i in range(num_instances):
instance_name = prefix + service_name + (" " + pad(i)
if num_instances > 1
else "")
vm = VM(name=instance_name, folder=parent,
resource_pool=self.server.get_pool(),
datastore=self.server.datastore, host=self.host)
if not vm.create(template=master.get_vim_vm()):
self._log.error("Failed to create instance %s",
instance_name)
else:
self._configure_nics(vm, value["networks"],
instance=instance)
def _is_vsphere(self, service_name):
"""
Checks if a service instance is defined as a vSphere service.
:param str service_name: Name of the service to lookup in
list of defined services
:return: If a service is a vSphere-type service
:rtype: bool
"""
if service_name not in self.services:
self._log.error("Could not find service %s in list of services",
service_name)
elif "template" in self.services[service_name]:
return True
return False
def _get_net(self, name, instance=-1):
"""
Resolves network names. This is mainly to handle generic-type networks.
If a generic network does not exist, it is created and added to
the interface lookup table.
:param str name: Name of the network
:param int instance: Instance number
.. note:: Only applies to generic-type networks
:return: Resolved network name
:rtype: str
"""
net_type = self._determine_net_type(name)
if net_type == "unique-networks":
return name
elif net_type == "generic-networks":
if instance == -1:
self._log.error("Invalid instance for _get_net: %d", instance)
raise ValueError
# Generate full name for the generic network
net_name = name + "-GENERIC-" + pad(instance)
if net_name not in self.net_table:
exists = self.server.get_network(net_name)
if exists is not None:
self._log.debug("PortGroup '%s' already exists "
"on host '%s'", net_name,
self.host.name)
else: # Create the generic network if it does not exist
# WARNING: lookup of name is case-sensitive!
# This can (and has0 lead to bugs
self._log.debug("Creating portgroup '%s' on host '%s'",
net_name,
self.host.name)
vsw = self.networks["generic-networks"][name].get(
"vswitch", self.vswitch_name)
create_portgroup(name=net_name,
host=self.host,
promiscuous=False,
vlan=next(get_vlan()),
vswitch_name=vsw)
# Register the existence of the generic network
self.net_table[net_name] = True
return net_name
else:
self._log.error("Invalid network type %s for network %s",
net_type, name)
raise TypeError
def cleanup_masters(self, network_cleanup=False):
"""
Cleans up any master instances.
:param bool network_cleanup: If networks should be cleaned up
"""
# Get the folder to cleanup in
master_folder = self.root_folder.find_in(self.master_root_name)
self._log.info("Found master folder '%s' under folder '%s', "
"proceeding with cleanup...",
master_folder.name, self.root_folder.name)
# Recursively descend from master folder,
# destroying anything with the prefix
master_folder.cleanup(vm_prefix=self.master_prefix,
recursive=True,
destroy_folders=True,
destroy_self=True)
# Cleanup networks
if network_cleanup:
pass
def cleanup_environment(self, network_cleanup=False):
"""
Cleans up a deployed environment.
:param bool network_cleanup: If networks should be cleaned up
"""
# Get the root environment folder to cleanup in
# enviro_folder = self.root_folder
# Cleanup networks
if network_cleanup:
pass
def __str__(self):
return str(self.server) + str(self.groups) + str(self.hosts)
def __eq__(self, other):
return super(self.__class__, self).__eq__(other) and \
self.server == other.server and \
self.groups == other.groups and \
self.hosts == other.hosts | ADLES | /ADLES-1.4.0.tar.gz/ADLES-1.4.0/adles/interfaces/vsphere_interface.py | vsphere_interface.py |
import logging
from abc import ABC, abstractmethod
class Interface(ABC):
"""Base class for all Interfaces."""
# Names/prefixes
master_prefix = "(MASTER) "
master_root_name = "MASTER-FOLDERS"
def __init__(self, infra, spec):
"""
:param dict infra: Full infrastructure configuration
:param dict spec: Full exercise specification
"""
self._log = logging.getLogger(self.__class__.__name__)
self.infra = infra # Save the infrastructure configuration
self.spec = spec # Save the exercise specification
self.metadata = spec["metadata"] # Save the exercise spec metadata
self.services = spec["services"]
self.networks = spec["networks"] # Networks for platforms
self.folders = spec["folders"]
self.thresholds = {} # Thresholds for platforms
self.groups = {} # Groups for platforms
@abstractmethod
def create_masters(self):
"""Master creation phase."""
pass
@abstractmethod
def deploy_environment(self):
"""Environment deployment phase."""
pass
@abstractmethod
def cleanup_masters(self, network_cleanup=False):
"""
Cleans up master instances.
:param bool network_cleanup: If networks should be cleaned up
"""
pass
@abstractmethod
def cleanup_environment(self, network_cleanup=False):
"""
Cleans up a deployed environment.
:param bool network_cleanup: If networks should be cleaned up
"""
pass
def _instances_handler(self, spec, obj_name, obj_type):
"""
Determines number of instances and optional prefix using specification.
:param dict spec: Dict of folder
:param str obj_name: Name of the thing being handled
:param str obj_type: Type of the thing being handled (folder | service)
:return: Number of instances, Prefix
:rtype: tuple(int, str)
"""
num = 1
prefix = ""
if "instances" in spec:
if isinstance(spec["instances"], int):
num = int(spec["instances"])
else:
if "prefix" in spec["instances"]:
prefix = str(spec["instances"]["prefix"])
if "number" in spec["instances"]:
num = int(spec["instances"]["number"])
elif "size-of" in spec["instances"]:
# size_of = spec["instances"]["size-of"])
# num = int(self._get_group(size_of).size
# if num < 1:
num = 1 # WORKAROUND FOR AD-GROUPS
else:
self._log.error("Unknown instances specification: %s",
str(spec["instances"]))
num = 0
# Check if the number of instances exceeds
# the configured thresholds for the interface
thr = self.thresholds[obj_type]
if num > thr["error"]:
self._log.error("%d instances of %s '%s' is beyond the "
"configured %s threshold of %d",
num, obj_type, obj_name,
self.__name__, thr["error"])
raise Exception("Threshold exceeded")
elif num > thr["warn"]:
self._log.warning("%d instances of %s '%s' is beyond the "
"configured %s threshold of %d",
num, obj_type, obj_name,
self.__name__, thr["warn"])
return num, prefix
def _path(self, path, name):
"""
Generates next step of the path for deployment of Masters.
:param str path: Current path
:param str name: Name to add to the path
:return: The updated path
:rtype: str
"""
return str(path + '/' + self.master_prefix + name)
@staticmethod
def _is_enabled(spec):
"""
Determines if a spec is enabled.
:param dict spec: Specification to check
:return: If the spec is enabled
:rtype: bool
"""
if "enabled" in spec:
return bool(spec["enabled"])
else:
return True
def _determine_net_type(self, network_label):
"""
Determines the type of a network.
:param str network_label: Name of network to determine type of
:return: Type of the network ("generic-networks" | "unique-networks")
:rtype: str
"""
for net_name, net_value in self.networks.items():
vals = {k for k in net_value}
if network_label in vals:
return net_name
self._log.error("Could not find type for network '%s'", network_label)
return ""
def _get_group(self, group_name):
"""
Provides a uniform way to get information about normal groups
and template groups.
:param str group_name: Name of the group
:return: Group object
:rtype: :class:`Group`
"""
from adles.group import Group
if group_name in self.groups:
group = self.groups[group_name]
if isinstance(group, Group): # Normal groups
return group
elif isinstance(group, list): # Template groups
return group[0]
else:
self._log.error("Unknown type for group '%s': %s",
str(group_name), str(type(group)))
else:
self._log.error("Could not get group '%s' from groups", group_name)
def __repr__(self):
return "%s(%s, %s)" % (str(self.__class__),
str(self.spec),
str(self.infra))
def __str__(self):
return str([x for x in self.infra.keys()])
def __hash__(self):
return hash(str(self))
def __eq__(self, other):
return isinstance(other, self.__class__) and \
self.infra == other.infra and \
self.spec == other.spec | ADLES | /ADLES-1.4.0.tar.gz/ADLES-1.4.0/adles/interfaces/interface.py | interface.py |
import logging
from time import sleep, time
from pyVmomi import vim
from adles.utils import read_json, user_input
SLEEP_INTERVAL = 0.05
LONG_SLEEP = 1.0
class VsphereException(Exception):
pass
def wait_for_task(task, timeout=60.0, pause_timeout=True):
"""
Waits for a single vim.Task to finish and returns its result.
:param task: The task to wait for
:type task: vim.Task
:param float timeout: Number of seconds to wait before terminating task
:param bool pause_timeout: Pause timeout counter while task
is queued on server
:return: Task result information (task.info.result)
:rtype: str or None
"""
if not task: # Check if there's actually a task
logging.error("No task was specified to wait for")
return None
name = str(task.info.descriptionId)
obj = str(task.info.entityName)
wait_time = 0.0
end_time = time() + float(timeout) # Set end time
try:
while True:
if task.info.state == 'success': # It succeeded!
# Return the task result if it was successful
return task.info.result
elif task.info.state == 'error': # It failed...
logging.error("Error during task %s on object '%s': %s",
name, obj, str(task.info.error.msg))
return None
elif time() > end_time: # Check if it has exceeded the timeout
logging.error("Task %s timed out after %s seconds",
name, str(wait_time))
task.CancelTask() # Cancel the task since we've timed out
return None
elif task.info.state == 'queued':
sleep(LONG_SLEEP) # Sleep longer if it's queued up on system
# Don't count queue time against the timeout
if pause_timeout is True:
end_time += LONG_SLEEP
wait_time += LONG_SLEEP
else:
# Wait a bit so we don't waste resources checking state
sleep(SLEEP_INTERVAL)
wait_time += SLEEP_INTERVAL
except vim.fault.NoPermission as e:
logging.error("Permission denied for task %s on %s: need privilege %s",
name, obj, e.privilegeId)
except vim.fault.TaskInProgress as e:
logging.error("Cannot complete task %s: "
"task %s is already in progress on %s",
name, e.task.info.name, obj)
except vim.fault.InvalidPowerState as e:
logging.error("Cannot complete task %s: "
"%s is in invalid power state %s",
name, obj, e.existingState)
except vim.fault.InvalidState as e:
logging.error("Cannot complete task %s: "
"invalid state for %s\n%s", name, obj, str(e))
except vim.fault.CustomizationFault:
logging.error("Cannot complete task %s: "
"invalid customization for %s", name, obj)
except vim.fault.VmConfigFault:
logging.error("Cannot complete task %s: "
"invalid configuration for VM %s", name, obj)
except vim.fault.InvalidName as e:
logging.error("Cannot complete task %s for object %s: "
"name '%s' is not valid", name, obj, e.name)
except vim.fault.DuplicateName as e:
logging.error("Cannot complete task %s for %s: "
"there is a duplicate named %s", name, obj, e.name)
except vim.fault.InvalidDatastore as e:
logging.error("Cannot complete task %s for %s: "
"invalid Datastore '%s'", name, obj, e.datastore)
except vim.fault.AlreadyExists:
logging.error("Cannot complete task %s: "
"%s already exists", name, obj)
except vim.fault.NotFound:
logging.error("Cannot complete task %s: "
"%s does not exist", name, obj)
except vim.fault.ResourceInUse:
logging.error("Cannot complete task %s: "
"resource %s is in use", name, obj)
return None
# This line allows calling "<task>.wait(<params>)"
# instead of "wait_for_task(task, params)"
#
# This works because the implicit first argument
# to a class method call in Python is the instance
vim.Task.wait = wait_for_task # Inject into vim.Task class
# From: list_dc_datastore_info in pyvmomi-community-samples
def get_datastore_info(ds_obj):
"""
Gets a human-readable summary of a Datastore.
:param ds_obj: The datastore to get information on
:type ds_obj: vim.Datastore
:return: The datastore's information
:rtype: str
"""
if not ds_obj:
logging.error("No Datastore was given to get_datastore_info")
return ""
from adles.utils import sizeof_fmt
info_string = "\n"
summary = ds_obj.summary
ds_capacity = summary.capacity
ds_freespace = summary.freeSpace
ds_uncommitted = summary.uncommitted if summary.uncommitted else 0
ds_provisioned = ds_capacity - ds_freespace + ds_uncommitted
ds_overp = ds_provisioned - ds_capacity
ds_overp_pct = (ds_overp * 100) / ds_capacity if ds_capacity else 0
info_string += "Name : %s\n" % summary.name
info_string += "URL : %s\n" % summary.url
info_string += "Capacity : %s\n" % sizeof_fmt(ds_capacity)
info_string += "Free Space : %s\n" % sizeof_fmt(ds_freespace)
info_string += "Uncommitted : %s\n" % sizeof_fmt(ds_uncommitted)
info_string += "Provisioned : %s\n" % sizeof_fmt(ds_provisioned)
if ds_overp > 0:
info_string += "Over-provisioned : %s / %s %%\n" \
% (sizeof_fmt(ds_overp), ds_overp_pct)
info_string += "Hosts : %d\n" % len(ds_obj.host)
info_string += "Virtual Machines : %d" % len(ds_obj.vm)
return info_string
vim.Datastore.get_info = get_datastore_info
def make_vsphere(filename=None):
"""
Creates a vSphere object using either a JSON file or by prompting the user.
:param str filename: Name of JSON file with connection info
:return: vSphere object
:rtype: :class:`Vsphere`
"""
from adles.vsphere.vsphere_class import Vsphere
if filename is not None:
info = read_json(filename)
if info is None:
raise VsphereException("Failed to create vSphere object")
return Vsphere(username=info.get("user"),
password=info.get("pass"),
hostname=info.get("host"),
port=info.get("port", 443),
datacenter=info.get("datacenter"),
datastore=info.get("datastore"))
else:
logging.info("Enter information to connect to the vSphere environment")
datacenter = input("Datacenter : ")
datastore = input("Datastore : ")
return Vsphere(datacenter=datacenter, datastore=datastore)
def resolve_path(server, thing, prompt=""):
"""
This is a hacked together script utility to get folders or VMs.
:param server: Vsphere instance
:type server: :class:`Vsphere`
:param str thing: String name of thing to get (folder | vm)
:param str prompt: Message to display
:return: (thing, thing name)
:rtype: tuple(vimtype, str)
"""
# TODO: use pathlib
from adles.vsphere.vm import VM
if thing.lower() == "vm":
get = server.get_vm
elif thing.lower() == "folder":
get = server.get_folder
else:
logging.error("Invalid thing passed to resolve_path: %s", thing)
raise ValueError
res = user_input("Name of or path to %s %s: " % (thing, prompt), thing,
lambda x: server.find_by_inv_path("vm/" + x)
if '/' in x else get(x))
if thing.lower() == "vm":
return VM(vm=res[0]), res[1]
else:
return res
def is_folder(obj):
"""
Checks if object is a vim.Folder.
:param obj: The object to check
:return: If the object is a folder
:rtype: bool
"""
return hasattr(obj, "childEntity")
def is_vm(obj):
"""
Checks if object is a vim.VirtualMachine.
:param obj: The object to check
:return: If the object is a VM
:rtype: bool
"""
return hasattr(obj, "summary") | ADLES | /ADLES-1.4.0.tar.gz/ADLES-1.4.0/adles/vsphere/vsphere_utils.py | vsphere_utils.py |
import logging
from pyVmomi import vim
class Host:
""" Represents an ESXi host in a VMware vSphere environment. """
def __init__(self, host):
"""
:param host: The host to use
:type host: vim.HostSystem
"""
self._log = logging.getLogger('Host')
self.host = host
self.name = str(host.name)
self.config = host.config
def reboot(self, force=False):
"""
Reboots the host.
:param bool force: Force a reboot even if the host
is not in maintenance mode
"""
self._log.warning("Rebooting host %s", self.name)
self.host.RebootHost_Task(force=bool(force)).wait()
def shutdown(self, force=False):
"""
Shuts down the host.
:param bool force: Force a reboot even if the host
is not in maintenance mode
"""
self._log.warning("Shutting down host %s", self.name)
self.host.ShutdownHost_Task(force=bool(force)).wait()
def enter_maintenance_mode(self, timeout=0, spec=None):
"""
Enter maintenance mode.
:param int timeout: Seconds to wait
:param spec: Actions to be taken upon entering maintenance mode
:type spec: vim.HostMaintenanceSpec
"""
self._log.warning("%s is entering maintenance mode", self.name)
self.host.EnterMaintenanceMode_Task(timeout=int(timeout),
maintenanceSpec=spec).wait()
def exit_maintenance_mode(self, timeout=0):
"""
Exit maintenance mode.
:param int timeout: Seconds to wait
"""
self._log.info("%s is exiting maintenance mode", self.name)
self.host.ExitMaintenanceMode_Task(timeout=int(timeout)).wait()
def create_vswitch(self, name, num_ports=512):
"""
Creates a vSwitch.
:param str name: Name of the vSwitch to create
:param int num_ports: Number of ports the vSwitch should have
"""
self._log.info("Creating vSwitch %s with %d ports on host %s",
name, num_ports, self.name)
vswitch_spec = vim.host.VirtualSwitch.Specification()
vswitch_spec.numPorts = int(num_ports)
try:
self.host.configManager.networkSystem.AddVirtualSwitch(name,
vswitch_spec)
except vim.fault.AlreadyExists:
self._log.error("vSwitch %s already exists on host %s",
name, self.name)
def create_portgroup(self, name, vswitch_name, vlan=0, promiscuous=False):
"""
Creates a portgroup.
:param str name: Name of portgroup to create
:param str vswitch_name: Name of vSwitch to create the port group on
:param int vlan: VLAN ID of the port group
:param bool promiscuous: Put portgroup in promiscuous mode
"""
self._log.debug("Creating PortGroup %s on vSwitch %s on host %s;"
" VLAN: %d; Promiscuous: %s",
name, vswitch_name, self.name, vlan, promiscuous)
policy = vim.host.NetworkPolicy()
policy.security = vim.host.NetworkPolicy.SecurityPolicy()
policy.security.allowPromiscuous = bool(promiscuous)
policy.security.macChanges = False
policy.security.forgedTransmits = False
spec = vim.host.PortGroup.Specification(name=name, vlanId=int(vlan),
vswitchName=vswitch_name,
policy=policy)
try:
self.host.configManager.networkSystem.AddPortGroup(spec)
except vim.fault.AlreadyExists:
self._log.error("PortGroup %s already exists on host %s",
name, self.name)
except vim.fault.NotFound:
self._log.error("vSwitch %s does not exist on host %s",
vswitch_name, self.name)
def delete_network(self, name, network_type):
"""
Deletes the named network from the host.
:param str name: Name of the vSwitch to delete
:param str network_type: Type of the network to remove
("vswitch" | "portgroup")
"""
self._log.info("Deleting %s '%s' from host '%s'",
network_type, name, self.name)
try:
if network_type.lower() == "vswitch":
self.host.configManager.networkSystem.RemoveVirtualSwitch(name)
elif network_type.lower() == "portgroup":
self.host.configManager.networkSystem.RemovePortGroup(name)
except vim.fault.NotFound:
self._log.error("Tried to remove %s '%s' that does not exist "
"from host '%s'",
network_type, name, self.name)
except vim.fault.ResourceInUse:
self._log.error("%s '%s' can't be removed because there are "
"vNICs associated with it",
network_type, name)
def get_info(self):
"""
Get information about the host.
:return: Formatted host information
:rtype: str
"""
return str(self.config)
def get_net_item(self, object_type, name):
"""
Retrieves a network object of the specified type and name from a host.
:param str object_type: Type of object to get:
(portgroup | vswitch | proxyswitch | vnic | pnic)
:param str name: Name of network object [default: first object found]
:return: The network object
:rtype: vim.Network or vim.VirtualSwitch
or vim.VirtualEthernetCard or None
.. todo:: determine what possible return types there are
"""
if name:
return self.get_net_obj(object_type, name)
else:
return self.get_net_objs(object_type)[0]
def get_net_obj(self, object_type, name, refresh=False):
"""
Retrieves a network object of the specified type and name from a host.
:param str object_type: Type of object to get:
(portgroup | vswitch | proxyswitch | vnic | pnic)
:param name: Name of network object
:param bool refresh: Refresh the host's network system information
:return: The network object
:rtype: vim.Network or vim.VirtualSwitch
or vim.VirtualEthernetCard or None
.. todo:: determine what possible return types there are
"""
objs = self.get_net_objs(object_type=object_type, refresh=refresh)
obj_name = name.lower()
if objs is not None:
for obj in objs:
if object_type == "portgroup" or object_type == "proxyswitch":
if obj.spec.name.lower() == obj_name:
return obj
elif object_type == "pnic" or object_type == "vnic":
if obj.device.lower() == obj_name:
return obj
elif obj.name.lower() == obj_name:
return obj
return None
def get_net_objs(self, object_type, refresh=False):
"""
Retrieves all network objects of the specified type from the host.
:param str object_type: Type of object to get:
(portgroup | vswitch | proxyswitch | vnic | pnic)
:param bool refresh: Refresh the host's network system information
:return: list of the network objects
:rtype: list(vimtype) or None
"""
if refresh: # Pick up recent changes
self.host.configManager.networkSystem.RefreshNetworkSystem()
net_type = object_type.lower()
if net_type == "portgroup":
objects = self.host.configManager.networkSystem.networkInfo.portgroup
elif net_type == "vswitch":
objects = self.host.configManager.networkSystem.networkInfo.vswitch
elif net_type == "proxyswitch":
objects = self.host.configManager.networkSystem.networkInfo.proxySwitch
elif net_type == "vnic ":
objects = self.host.configManager.networkSystem.networkInfo.vnic
elif net_type == "pnic ":
objects = self.host.configManager.networkSystem.networkInfo.pnic
else:
self._log.error("Invalid type %s for get_net_objs", object_type)
return None
return list(objects)
def __str__(self):
return str(self.name)
def __hash__(self):
return hash(self.host)
def __eq__(self, other):
return self.name == other.name
def __ne__(self, other):
return not self.__eq__(other) | ADLES | /ADLES-1.4.0.tar.gz/ADLES-1.4.0/adles/vsphere/host.py | host.py |
import logging
from pyVim.connect import Disconnect, SmartConnect, SmartConnectNoSSL
from pyVmomi import vim, vmodl
from adles.vsphere.vsphere_utils import VsphereException
# TODO: separate connection logic from init, put in a ".connect()" method
# TODO: context manager, enter connects, exit disconnects (instead of atexit)
class Vsphere(object):
""" Maintains connection, logging, and constants for a vSphere instance """
def __init__(self, username=None, password=None, hostname=None,
datacenter=None, datastore=None,
port=443, use_ssl=False):
"""
Connects to a vCenter server and initializes a class instance.
:param str username: Username of account to login with
[default: prompt user]
:param str password: Password of account to login with
[default: prompt user]
:param str hostname: DNS hostname or IP address of vCenter instance
[default: prompt user]
:param str datastore: Name of datastore to use
[default: first datastore found on server]
:param str datacenter: Name of datacenter to use
[default: First datacenter found on server]
:param int port: Port used to connect to vCenter instance
:param bool use_ssl: If SSL should be used to connect
:raises LookupError: if a datacenter or datastore cannot be found
"""
self._log = logging.getLogger('Vsphere')
self._log.debug("Initializing Vsphere\nDatacenter: %s"
"\tDatastore: %s\tSSL: %s",
datacenter, datastore, use_ssl)
if username is None:
username = input("Enter username for vSphere: ")
if password is None:
from getpass import getpass
password = getpass("Enter password for %s: " % username)
if hostname is None:
hostname = input("Enter hostname for vSphere: ")
try:
self._log.info("Connecting to vSphere: %s@%s:%d",
username, hostname, port)
if use_ssl: # Connect to server using SSL certificate verification
self._server = SmartConnect(host=hostname, user=username,
pwd=password, port=port)
else:
self._server = SmartConnectNoSSL(host=hostname, user=username,
pwd=password, port=port)
except vim.fault.InvalidLogin:
self._log.error("Invalid vSphere login credentials "
"for user %s", username)
raise VsphereException("Invalid login credentials") from None
except TimeoutError:
raise VsphereException("Timed out connecting to vSphere") from None
# Ensure connection to server is closed on program exit
from atexit import register
register(Disconnect, self._server)
self._log.info("Connected to vSphere host %s:%d", hostname, port)
self._log.debug("Current server time: %s",
str(self._server.CurrentTime()))
self.username = username
self.hostname = hostname
self.port = port
self.content = self._server.RetrieveContent()
self.auth = self.content.authorizationManager
self.user_dir = self.content.userDirectory
self.search_index = self.content.searchIndex
self.datacenter = self.get_item(vim.Datacenter, name=datacenter)
if not self.datacenter:
raise LookupError("Could not find a Datacenter to initialize with!")
self.datastore = self.get_datastore(datastore)
if not self.datastore:
raise LookupError("Could not find a Datastore to initialize with!")
self._log.debug("Finished initializing vSphere")
# From: create_folder_in_datacenter.py in pyvmomi-community-samples
def create_folder(self, folder_name, create_in=None):
"""
Creates a VM folder in the specified folder.
:param str folder_name: Name of folder to create
:param create_in: Folder to create the new folder in
[default: root folder of datacenter]
:type create_in: str or vim.Folder
:return: The created folder
:rtype: vim.Folder
"""
if create_in:
if isinstance(create_in, str): # Lookup create_in on the server
self._log.debug("Retrieving parent folder '%s' from server",
create_in)
parent = self.get_folder(folder_name=create_in)
else:
parent = create_in # Already vim.Folder, so we just assign it
else:
parent = self.content.rootFolder # Default to server root folder
return parent.create(folder_name)
def set_motd(self, message):
"""
Sets vCenter server Message of the Day (MOTD).
:param str message: Message to set
"""
self._log.info("Setting vCenter MOTD to %s", message)
self.content.sessionManager.UpdateServiceMessage(message=str(message))
def map_items(self, vimtypes, func, name=None,
container=None, recursive=True):
"""
Apply a function to item(s) in a container.
:param list vimtypes: List of vimtype objects to look for
:param func: Function to apply
:param str name: Name of item to apply to
:param container: Container to search in [default: content.rootFolder]
:param bool recursive: Whether to recursively descend
:return: List of values returned from the function call(s)
:rtype: list
"""
contain = (self.content.rootFolder if not container else container)
con_view = self.content.viewManager.CreateContainerView(
contain, vimtypes, recursive)
returns = []
for item in con_view.view:
if name:
if hasattr(item, 'name') and item.name.lower() == name.lower():
returns.append(func(item))
else:
returns.append(func(item))
con_view.Destroy()
return returns
def set_entity_permissions(self, entity, permission):
"""
Defines or updates rule(s) for the given user or group on the entity.
:param entity: The entity on which to set permissions
:type entity: vim.ManagedEntity
:param permission: The permission to set
:type permission: vim.AuthorizationManager.Permission
"""
try:
self.auth.SetEntityPermissions(entity=entity, permission=permission)
except vim.fault.UserNotFound as e:
self._log.error("Could not find user '%s' to set permission "
"'%s' on entity '%s'",
e.principal, str(permission), entity.name)
except vim.fault.NotFound:
self._log.error("Invalid role ID for permission '%s'",
str(permission))
except vmodl.fault.ManagedObjectNotFound as e:
self._log.error("Entity '%s' does not exist to set permission on",
str(e.obj))
except vim.fault.NoPermission as e:
self._log.error("Could not set permissions for entity '%s': "
"the current session does not have privilege '%s' "
"to set permissions for the entity '%s'",
entity.name, e.privilegeId, e.object)
except vmodl.fault.InvalidArgument as e:
self._log.error("Invalid argument to set permission '%s' "
"on entity '%s': %s",
entity.name, str(permission), str(e))
except Exception as e:
self._log.exception("Unknown error while setting permissions "
"for entity '%s': %s",
entity.name, str(e))
def get_entity_permissions(self, entity, inherited=True):
"""
Gets permissions defined on or effective on a managed entity.
:param entity: The entity to get permissions for
:type entity: vim.ManagedEntity
:param bool inherited: Include propagating permissions
defined in parent
:return: The permissions for the entity
:rtype: vim.AuthorizationManager.Permission or None
"""
try:
return self.auth.RetrieveEntityPermissions(entity=entity,
inherited=inherited)
except vmodl.fault.ManagedObjectNotFound as e:
self._log.error("Couldn't find entity '%s' to get permissions from",
str(e.obj))
return None
def get_role_permissions(self, role_id):
"""
Gets all permissions that use a particular role.
:param int role_id: ID of the role
:return: The role permissions
:rtype: vim.AuthorizationManager.Permission or None
"""
try:
return self.auth.RetrieveRolePermissions(roleId=int(role_id))
except vim.fault.NotFound:
self._log.error("Role ID %s does not exist", str(role_id))
return None
def get_users(self, search='', domain='', exact=False,
belong_to_group=None, have_user=None,
find_users=True, find_groups=False):
"""
Returns a list of the users and groups defined for the server
.. note:: You must hold the Authorization.ModifyPermissions
privilege to invoke this method.
:param str search: Case insensitive substring used to filter results
[default: all users]
:param str domain: Domain to be searched [default: local machine]
:param bool exact: Search should match user/group name exactly
:param str belong_to_group: Only find users/groups that directly belong
to this group
:param str have_user: Only find groups that directly contain this user
:param bool find_users: Include users in results
:param bool find_groups: Include groups in results
:return: The users and groups defined for the server
:rtype: list(vim.UserSearchResult) or None
"""
# See for reference: pyvmomi/docs/vim/UserDirectory.rst
kwargs = {"searchStr": search, "exactMatch": exact,
"findUsers": find_users, "findGroups": find_groups}
if domain != '':
kwargs["domain"] = domain
if belong_to_group is not None:
kwargs["belongsToGroup"] = belong_to_group
if have_user is not None:
kwargs["belongsToUser"] = have_user
try:
return self.user_dir.RetrieveUserGroups(**kwargs)
except vim.fault.NotFound:
self._log.warning("Could not find domain, group or user "
"in call to get_users"
"\nkwargs: %s", str(kwargs))
return None
except vmodl.fault.NotSupported:
self._log.error("System doesn't support domains or "
"by-membership queries for get_users")
return None
def get_info(self):
"""
Retrieves and formats basic information about the vSphere instance.
:return: formatted server information
:rtype: str
"""
about = self.content.about
info_string = "\n"
info_string += "Host address: %s:%d\n" % (self.hostname, self.port)
info_string += "Datacenter : %s\n" % self.datacenter.name
info_string += "Datastore : %s\n" % self.datastore.name
info_string += "Full name : %s\n" % about.fullName
info_string += "Vendor : %s\n" % about.vendor
info_string += "Version : %s\n" % about.version
info_string += "API type : %s\n" % about.apiType
info_string += "API version : %s\n" % about.apiVersion
info_string += "OS type : %s" % about.osType
return info_string
def get_folder(self, folder_name=None):
"""
Finds and returns the named Folder.
:param str folder_name: Name of folder [default: Datacenter vmFolder]
:return: The folder found
:rtype: vim.Folder
"""
if folder_name: # Try to find the named folder in the datacenter
return self.get_obj(self.datacenter, [vim.Folder], folder_name)
else: # Default to the VM folder in the datacenter
# Reference: pyvmomi/docs/vim/Datacenter.rst
self._log.warning("Could not find folder '%s' in Datacenter '%s', "
"defaulting to vmFolder",
folder_name, self.datacenter.name)
return self.datacenter.vmFolder
def get_vm(self, vm_name):
"""
Finds and returns the named VM.
:param str vm_name: Name of the VM
:return: The VM found
:rtype: vim.VirtualMachine or None
"""
return self.get_item(vim.VirtualMachine, vm_name)
def get_network(self, network_name, distributed=False):
"""
Finds and returns the named Network.
:param str network_name: Name or path of the Network
:param bool distributed: If the Network is a Distributed PortGroup
:return: The network found
:rtype: vim.Network or vim.dvs.DistributedVirtualPortgroup or None
"""
if not distributed:
return self.get_obj(container=self.datacenter.networkFolder,
vimtypes=[vim.Network],
name=str(network_name), recursive=True)
else:
return self.get_item(vim.dvs.DistributedVirtualPortgroup,
network_name)
def get_host(self, host_name=None):
"""
Finds and returns the named Host System.
:param str host_name: Name of the host
[default: first host found in datacenter]
:return: The host found
:rtype: vim.HostSystem or None
"""
return self.get_item(vim.HostSystem, host_name)
def get_cluster(self, cluster_name=None):
"""
Finds and returns the named Cluster.
:param str cluster_name: Name of the cluster
[default: first cluster found in datacenter]
:return: The cluster found
:rtype: vim.ClusterComputeResource or None
"""
return self.get_item(cluster_name, vim.ClusterComputeResource)
def get_clusters(self):
"""
Get all the clusters associated with the vCenter server.
:return: All clusters associated with the vCenter server
:rtype: list(vim.ClusterComputeResource)
"""
return self.get_objs(self.content.rootFolder,
[vim.ClusterComputeResource])
def get_datastore(self, datastore_name=None):
"""
Finds and returns the named Datastore.
:param str datastore_name: Name of the datastore
[default: first datastore in datacenter]
:return: The datastore found
:rtype: vim.Datastore or None
"""
return self.datacenter.datastoreFolder.get(datastore_name)
def get_pool(self, pool_name=None):
"""
Finds and returns the named vim.ResourcePool.
:param str pool_name: Name of the resource pool
[default: first pool found in datacenter]
:return: The resource pool found
:rtype: vim.ResourcePool or None
"""
return self.get_item(vim.ResourcePool, pool_name)
def get_all_vms(self):
"""
Finds and returns all VMs registered in the Datacenter.
:return: All VMs in the Datacenter defined for the class
:rtype: list(vim.VirtualMachine)
"""
return self.get_objs(self.datacenter.vmFolder, [vim.VirtualMachine])
def get_obj(self, container, vimtypes, name, recursive=True):
"""
Finds and returns named vim object of specified type.
:param container: Container to search in
:param list vimtypes: vimtype objects to look for
:param str name: Name of the object
:param bool recursive: Recursively search for the item
:return: Object found with the specified name
:rtype: vimtype or None
"""
con_view = self.content.viewManager.CreateContainerView(container,
vimtypes,
recursive)
obj = None
for item in con_view.view:
if item.name.lower() == name.lower():
obj = item
break
con_view.Destroy()
return obj
# From: https://github.com/sijis/pyvmomi-examples/vmutils.py
def get_objs(self, container, vimtypes, recursive=True):
"""
Get all the vim objects associated with a given type.
:param container: Container to search in
:param list vimtypes: Objects to search for
:param bool recursive: Recursively search for the item
:return: All vimtype objects found
:rtype: list(vimtype) or None
"""
objs = []
con_view = self.content.viewManager.CreateContainerView(container,
vimtypes,
recursive)
for item in con_view.view:
objs.append(item)
con_view.Destroy()
return objs
def get_item(self, vimtype, name=None, container=None, recursive=True):
"""
Get a item of specified name and type.
Intended to be simple version of :meth: get_obj
:param vimtype: Type of item
:type vimtype: vimtype
:param str name: Name of item
:param container: Container to search in
[default: vCenter server content root folder]
:param bool recursive: Recursively search for the item
:return: The item found
:rtype: vimtype or None
"""
contain = (self.content.rootFolder if not container else container)
if not name:
return self.get_objs(contain, [vimtype], recursive)[0]
else:
return self.get_obj(contain, [vimtype], name, recursive)
def find_by_uuid(self, uuid, instance_uuid=True):
"""
Find a VM in the datacenter with the given Instance or BIOS UUID.
:param str uuid: UUID to search for (Instance or BIOS for VMs)
:param bool instance_uuid: If True, search by VM Instance UUID,
otherwise search by BIOS UUID
:return: The VM found
:rtype: vim.VirtualMachine or None
"""
return self.search_index.FindByUuid(datacenter=self.datacenter,
uuid=str(uuid), vmSearch=True,
instanceUuid=instance_uuid)
def find_by_ds_path(self, path):
"""
Finds a VM by it's location on a Datastore.
:param str path: Path to the VM's .vmx file on the Datastore
:return: The VM found
:rtype: vim.VirtualMachine or None
"""
try:
return self.search_index.FindByDatastorePath(
datacenter=self.datacenter, path=str(path))
except vim.fault.InvalidDatastore:
self._log.error("Invalid datastore in path: %s", str(path))
return None
def find_by_ip(self, ip, vm_search=True):
"""
Find a VM or Host using a IP address.
:param str ip: IP address string as returned by VMware Tools ipAddress
:param vm_search: Search for VMs if True, Hosts if False
:return: The VM or host found
:rtype: vim.VirtualMachine or vim.HostSystem or None
"""
return self.search_index.FindByIp(datacenter=self.datacenter,
ip=str(ip), vmSearch=vm_search)
def find_by_hostname(self, hostname, vm_search=True):
"""
Find a VM or Host using a Fully-Qualified Domain Name (FQDN).
:param str hostname: FQDN of the VM to find
:param vm_search: Search for VMs if True, Hosts if False
:return: The VM or host found
:rtype: vim.VirtualMachine or vim.HostSystem or None
"""
return self.search_index.FindByDnsName(datacenter=self.datacenter,
dnsName=hostname,
vmSearch=vm_search)
def find_by_inv_path(self, path, datacenter=None):
"""
Finds a vim.ManagedEntity (VM, host, folder, etc) in a inventory.
:param str path: Path to the entity. This must include the hidden
Vsphere folder for the type: vm | network | datastore | host
Example: "vm/some-things/more-things/vm-name"
:param str datacenter: Name of datacenter to search in
[default: instance's datacenter]
:return: The entity found
:rtype: vim.ManagedEntity or None
"""
if datacenter is None:
datacenter = self.datacenter.name
full_path = datacenter + "/" + str(path)
return self.search_index.FindByInventoryPath(inventoryPath=full_path)
def __repr__(self):
return "vSphere(%s, %s, %s:%s)" % (self.datacenter.name,
self.datastore.name,
self.hostname, self.port)
def __str__(self):
return str(self.get_info())
def __hash__(self):
return hash((self.hostname, self.port, self.username))
def __eq__(self, other):
return isinstance(other, self.__class__) \
and self.hostname == other.hostname \
and self.port == other.port \
and self.username == other.username
def __ne__(self, other):
return not self.__eq__(other) | ADLES | /ADLES-1.4.0.tar.gz/ADLES-1.4.0/adles/vsphere/vsphere_class.py | vsphere_class.py |
import logging
from pyVmomi import vim
from adles.utils import split_path
from adles.vsphere.vsphere_utils import is_folder, is_vm
def create_folder(folder, folder_name):
"""
Creates a VM folder in the specified folder.
:param folder: Folder to create the folder in
:type folder: vim.Folder
:param str folder_name: Name of folder to create
:return: The created folder
:rtype: vim.Folder or None
"""
# Check if the folder already exists
exists = find_in_folder(folder, folder_name)
if exists:
logging.warning("Folder '%s' already exists in folder '%s'",
folder_name, folder.name)
return exists # Return the folder that already existed
else:
logging.debug("Creating folder '%s' in folder '%s'",
folder_name, folder.name)
try:
# Create the folder and return it
return folder.CreateFolder(folder_name)
except vim.fault.DuplicateName as dupe:
logging.error("Could not create folder '%s' in '%s': "
"folder already exists as '%s'",
folder_name, folder.name, dupe.name)
except vim.fault.InvalidName as invalid:
logging.error("Could not create folder '%s' in '%s': "
"Invalid folder name '%s'",
folder_name, folder.name, invalid.name)
return None
def cleanup(folder, vm_prefix='', folder_prefix='', recursive=False,
destroy_folders=False, destroy_self=False):
"""
Cleans a folder by selectively destroying any VMs and folders it contains.
:param folder: Folder to cleanup
:type folder: vim.Folder
:param str vm_prefix: Only destroy VMs with names starting with the prefix
:param str folder_prefix: Only destroy or search in folders with names
starting with the prefix
:param bool recursive: Recursively descend into any sub-folders
:param bool destroy_folders: Destroy folders in addition to VMs
:param bool destroy_self: Destroy the folder specified
"""
logging.debug("Cleaning folder '%s'", folder.name)
from adles.vsphere.vm import VM
# TODO: progress bar
# pbar = tqdm.tqdm(folder.childEntity, desc="Cleaning folder",
# unit="Items", clear=True)
for item in folder.childEntity:
# Handle VMs
if is_vm(item) and str(item.name).startswith(vm_prefix):
VM(vm=item).destroy() # Delete the VM from the Datastore
# Handle folders
elif is_folder(item) and str(item.name).startswith(folder_prefix):
if destroy_folders: # Destroys folder and ALL of it's sub-objects
cleanup(item, destroy_folders=True, destroy_self=True)
elif recursive: # Simply recurses to find more items
cleanup(item, vm_prefix=vm_prefix,
folder_prefix=folder_prefix, recursive=True)
# Note: UnregisterAndDestroy does NOT delete VM files off the datastore
# Only use if folder is already empty!
if destroy_self:
logging.debug("Destroying folder: '%s'", folder.name)
folder.UnregisterAndDestroy_Task().wait()
def get_in_folder(folder, name, recursive=False, vimtype=None):
"""
Retrieves an item from a datacenter folder.
:param folder: Folder to search in
:type folder: vim.Folder
:param str name: Name of object to find
:param bool recursive: Recurse into sub-folders
:param vimtype: Type of object to search for
:return: The object found
:rtype: vimtype or None
"""
item = None
if name is not None:
item = find_in_folder(folder, name, recursive=recursive,
vimtype=vimtype)
# Get first found of type if can't find in folder or name isn't specified
if item is None:
if len(folder.childEntity) > 0 and vimtype is None:
return folder.childEntity[0]
elif len(folder.childEntity) > 0:
for i in folder.childEntity:
if isinstance(i, vimtype):
return i
logging.error("Could not find item of type '%s' in folder '%s'",
vimtype.__name__, folder.name)
else:
logging.error("There are no items in folder %s", folder.name)
return item
def find_in_folder(folder, name, recursive=False, vimtype=None):
"""
Finds and returns an specific object in a folder.
:param folder: Folder to search in
:type folder: vim.Folder
:param str name: Name of the object to find
:param bool recursive: Recurse into sub-folders
:param vimtype: Type of object to search for
:return: The object found
:rtype: vimtype or None
"""
# NOTE: Convert to lowercase for case-insensitive comparisons
item_name = name.lower()
found = None
for item in folder.childEntity:
# Check if the name matches
if hasattr(item, 'name') and item.name.lower() == item_name:
if vimtype is not None and not isinstance(item, vimtype):
continue
found = item
elif recursive and is_folder(item): # Recurse into sub-folders
found = find_in_folder(item, name=item_name,
recursive=recursive, vimtype=vimtype)
if found is not None:
return found
return None
def traverse_path(folder, path, lookup_root=None, generate=False):
"""
Traverses a folder path to find a object with a specific name.
:param folder: Folder to search in
:type folder: vim.Folder
:param str path: Path in POSIX format
(Templates/Windows/ to get the 'Windows' folder)
:param lookup_root: If root of path is not found in folder,
lookup using this Vsphere object
:type lookup_root: :class:`Vsphere` or None
:param bool generate: Parts of the path that do not exist are created.
:return: Object at the end of the path
:rtype: vimtype or None
"""
logging.debug("Traversing path '%s' from folder '%s'", path, folder.name)
folder_path, name = split_path(path)
# Check if root of the path is in the folder
# This is to allow relative paths to be used if lookup_root is defined
folder_items = [x.name.lower() for x in folder.childEntity
if hasattr(x, 'name')]
if len(folder_path) > 0 and folder_path[0] not in folder_items:
if lookup_root is not None:
logging.debug("Root %s not in folder %s, looking up...",
folder_path[0], folder.name)
# Lookup the path root on server
folder = lookup_root.get_folder(folder_path.pop(0))
else:
logging.error("Could not find root '%s' "
"of path '%s' in folder '%s'",
folder_path[0], path, folder.name)
return None
current = folder # Start with the defined folder
for f in folder_path: # Try each folder name in the path
found = None
# Iterate through items in the current folder
for item in current.childEntity:
# If Folder is part of path
if is_folder(item) and item.name.lower() == f:
found = item # This is the next folder in the path
# Break to outer loop to check this folder
# for the next part of the path
break
if generate and found is None: # Can't find the folder, so create it
logging.warning("Generating folder %s in path", f)
create_folder(folder, f) # Generate the folder
elif found is not None:
current = found
# Since the split had a basename, look for an item with matching name
if name != '':
return find_in_folder(current, name)
else: # No basename, so just return whatever was at the end of the path
return current
def enumerate_folder(folder, recursive=True, power_status=False):
"""
Enumerates a folder structure and returns the result.
as a python object with the same structure
:param folder: Folder to enumerate
:type folder: vim.Folder
:param bool recursive: Whether to recurse into any sub-folders
:param bool power_status: Display the power state of the VMs in the folder
:return: The nested python object with the enumerated folder structure
:rtype: list(list, str)
"""
children = []
for item in folder.childEntity:
if is_folder(item):
if recursive: # Recurse into sub-folders and append the sub-tree
children.append(enumerate_folder(item, recursive))
else: # Don't recurse, just append the folder
children.append('- ' + item.name)
elif is_vm(item):
if power_status:
if item.runtime.powerState == \
vim.VirtualMachine.PowerState.poweredOn:
children.append('* ON ' + item.name)
elif item.runtime.powerState == \
vim.VirtualMachine.PowerState.poweredOff:
children.append('* OFF ' + item.name)
elif item.runtime.powerState == \
vim.VirtualMachine.PowerState.suspended:
children.append('* SUS ' + item.name)
else:
logging.error("Invalid power state for VM: %s", item.name)
else:
children.append('* ' + item.name)
else:
children.append("UNKNOWN ITEM: %s" % str(item))
return '+ ' + folder.name, children # Return tuple of parent and children
# Similar to: https://docs.python.org/3/library/pprint.html
def format_structure(structure, indent=4, _depth=0):
"""
Converts a nested structure of folders into a formatted string.
:param structure: structure to format
:type structure: tuple(list(str), str)
:param int indent: Number of spaces to indent each level of nesting
:param int _depth: Current depth (USED INTERNALLY BY FUNCTION)
:return: Formatted string of the folder structure
:rtype: str
"""
fmat = ""
newline = '\n' + str(_depth * str(indent * ' '))
if isinstance(structure, tuple):
fmat += newline + str(structure[0])
fmat += format_structure(structure[1], indent, _depth + 1)
elif isinstance(structure, list):
for item in structure:
fmat += format_structure(item, indent, _depth)
elif isinstance(structure, str):
fmat += newline + structure
else:
logging.error("Unexpected type in folder structure for item '%s': %s",
str(structure), type(structure))
return fmat
def retrieve_items(folder, vm_prefix='', folder_prefix='', recursive=False):
"""
Retrieves VMs and folders from a folder structure.
:param folder: Folder to begin search in
(Note: it is NOT returned in list of folders)
:type folder: vim.Folder
:param str vm_prefix: VM prefix to search for
:param str folder_prefix: Folder prefix to search for
:param bool recursive: Recursively descend into sub-folders
.. warning:: This will recurse regardless of folder prefix!
:return: The VMs and folders found in the folder
:rtype: tuple(list(vim.VirtualMachine), list(vim.Folder))
"""
vms = []
folders = []
for item in folder.childEntity: # Iterate through all items in the folder
if is_vm(item) and str(item.name).startswith(vm_prefix):
vms.append(item) # Add matching vm to the list
elif is_folder(item):
if str(item.name).startswith(folder_prefix):
folders.append(item) # Add matching folder to the list
if recursive: # Recurse into sub-folders
v, f = retrieve_items(item, vm_prefix, folder_prefix, recursive)
vms.extend(v)
folders.extend(f)
return vms, folders
def move_into(folder, entity_list):
"""
Moves a list of managed entities into the named folder.
:param folder: Folder to move entities into
:type folder: vim.Folder
:param entity_list: Entities to move into the folder
:type entity_list: list(vim.ManagedEntity)
"""
logging.debug("Moving a list of %d entities into folder %s",
len(entity_list), folder.name)
folder.MoveIntoFolder_Task(entity_list).wait()
def rename(folder, name):
"""
Renames a folder.
:param folder: Folder to rename
:type folder: vim.Folder
:param str name: New name for the folder
"""
logging.debug("Renaming %s to %s", folder.name, name)
folder.Rename_Task(newName=str(name)).wait()
# Injection of methods into vim.Folder pyVmomi class
#
# These enable "<folder>.create('name')" instead of
# "folder_utils.create_folder(<folder>, 'name')"
#
# This works because the implicit first argument
# to a class method call in Python is the instance
#
vim.Folder.create = create_folder
vim.Folder.cleanup = cleanup
vim.Folder.get = get_in_folder
vim.Folder.find_in = find_in_folder
vim.Folder.traverse_path = traverse_path
vim.Folder.enumerate = enumerate_folder
vim.Folder.retrieve_items = retrieve_items
vim.Folder.move_into = move_into
vim.Folder.rename = rename | ADLES | /ADLES-1.4.0.tar.gz/ADLES-1.4.0/adles/vsphere/folder_utils.py | folder_utils.py |
import logging
import os
from pyVmomi import vim
from adles import utils
from adles.vsphere.folder_utils import find_in_folder
# Docs: https://goo.gl/CRhYEX
class VM:
""" Represents a VMware vSphere Virtual Machine instance.
.. warning:: You must call :meth:`create` if a vim.VirtualMachine object
is not used to initialize the instance.
"""
def __init__(self, vm=None, name=None, folder=None, resource_pool=None,
datastore=None, host=None):
"""
:param vm: VM instance to use instead of calling :meth:`create`
:type vm: vim.VirtualMachine
:param str name: Name of the VM
:param folder: Folder in inventory to create the VM in
:type folder: vim.Folder
:param resource_pool: Resource pool to use for the VM
:type resource_pool: vim.ResourcePool
:param datastore: Datastore the VM is stored on
:type datastore: vim.Datastore
:param host: Host the VM runs on
:type host: vim.HostSystem
"""
self._log = logging.getLogger('VM')
if vm is not None:
self._vm = vm
self.name = vm.name
self.folder = vm.parent
self.resource_pool = vm.resourcePool
self.datastore = vm.datastore[0]
self.host = vm.summary.runtime.host
self.network = vm.network
self.runtime = vm.runtime
self.summary = vm.summary
else:
self._vm = None
self.name = name
self.folder = folder # vim.Folder that will contain the VM
self.resource_pool = resource_pool # vim.ResourcePool to use VM
self.datastore = datastore # vim.Datastore object to store VM on
self.host = host # vim.HostSystem
def create(self, template=None, cpus=None, cores=None, memory=None,
max_consoles=None, version=None, firmware='efi',
datastore_path=None):
"""Creates a Virtual Machine.
:param vim.VirtualMachine template: Template VM to clone
:param int cpus: Number of processors
:param int cores: Number of processor cores
:param int memory: Amount of RAM in MB
:param int max_consoles: Maximum number of active console connections
:param int version: Hardware version of the VM
[default: highest host supports]
:param str firmware: Firmware to emulate for the VM (efi | bios)
:param str datastore_path: Path to existing VM files on datastore
:return: If the creation was successful
:rtype: bool
"""
if template is not None: # Use a template to create the VM
self._log.debug("Creating VM '%s' by cloning %s",
self.name, template.name)
clonespec = vim.vm.CloneSpec()
clonespec.location = vim.vm.RelocateSpec(pool=self.resource_pool,
datastore=self.datastore)
if not template.CloneVM_Task(folder=self.folder, name=self.name,
spec=clonespec).wait(120):
self._log.error("Error cloning VM %s", self.name)
return False
else: # Generate the specification for and create the new VM
self._log.debug("Creating VM '%s' from scratch", self.name)
spec = vim.vm.ConfigSpec()
spec.name = self.name
spec.numCPUs = int(cpus) if cpus is not None else 1
spec.numCoresPerSocket = int(cores) if cores is not None else 1
spec.cpuHotAddEnabled = True
spec.memoryMB = int(memory) if memory is not None else 512
spec.memoryHotAddEnabled = True
spec.firmware = str(firmware).lower()
if version is not None:
spec.version = "vmx-" + str(version)
if max_consoles is not None:
spec.maxMksConnections = int(max_consoles)
vm_path = '[' + self.datastore.name + '] '
if datastore_path:
vm_path += str(datastore_path)
vm_path += self.name + '/' + self.name + '.vmx'
spec.files = vim.vm.FileInfo(vmPathName=vm_path)
self._log.debug("Creating VM '%s' in folder '%s'",
self.name, self.folder.name)
if not self.folder.CreateVM_Task(spec, self.resource_pool,
self.host).wait():
self._log.error("Error creating VM %s", self.name)
return False
self._vm = find_in_folder(self.folder, self.name,
vimtype=vim.VirtualMachine)
if not self._vm:
self._log.error("Failed to make VM %s", self.name)
return False
self.network = self._vm.network
self.runtime = self._vm.runtime
self.summary = self._vm.summary
if template is not None: # Edit resources for a clone if specified
self.edit_resources(cpus=cpus, cores=cores, memory=memory,
max_consoles=max_consoles)
self._log.debug("Created VM %s", self.name)
return True
def destroy(self):
"""Destroys the VM."""
self._log.debug("Destroying VM %s", self.name)
if self.powered_on():
self.change_state("off")
self._vm.Destroy_Task().wait()
def change_state(self, state, attempt_guest=True):
"""Generic power state change that uses guest OS operations if available.
:param str state: State to change to (on | off | reset | suspend)
:param bool attempt_guest: Attempt to use guest operations
:return: If state change succeeded
:rtype: bool
"""
state = state.lower() # Convert to lowercase for comparisons
if self.is_template():
self._log.error("VM '%s' is a Template, so state "
"cannot be changed to '%s'",
self.name, state)
# Can't power on using guest ops
elif attempt_guest and self.has_tools() and state != "on":
if self._vm.summary.guest.toolsStatus == "toolsNotInstalled":
self._log.error("Cannot change a VM's guest power state "
"without VMware Tools!")
return False
elif state == "shutdown" or state == "off":
task = self._vm.ShutdownGuest()
elif state == "reboot" or state == "reset":
task = self._vm.RebootGuest()
elif state == "standby" or state == "suspend":
task = self._vm.StandbyGuest()
else:
self._log.error("Invalid guest_state argument: %s", state)
return False
self._log.debug("Changing guest power state of VM %s to: '%s'",
self.name, state)
try:
task.wait()
except vim.fault.ToolsUnavailable:
self._log.error("Can't change guest state of '%s': "
"Tools aren't running", self.name)
else:
if state == "on":
task = self._vm.PowerOnVM_Task()
elif state == "off":
task = self._vm.PowerOffVM_Task()
elif state == "reset":
task = self._vm.ResetVM_Task()
elif state == "suspend":
task = self._vm.SuspendVM_Task()
else:
self._log.error("Invalid state arg %s for VM %s",
state, self.name)
return False
self._log.debug("Changing power state of VM %s to: '%s'",
self.name, state)
return bool(task.wait())
def edit_resources(self, cpus=None, cores=None,
memory=None, max_consoles=None):
"""Edits the resource limits for the VM.
:param int cpus: Number of CPUs
:param int cores: Number of CPU cores
:param int memory: Amount of RAM in MB
:param int max_consoles: Maximum number of simultaneous
Mouse-Keyboard-Screen (MKS) console connections
"""
spec = vim.vm.ConfigSpec()
if cpus is not None:
spec.numCPUs = int(cpus)
if cores is not None:
spec.numCoresPerSocket = int(cores)
if memory is not None:
spec.memoryMB = int(memory)
if max_consoles is not None:
spec.maxMksConnections = int(max_consoles)
self._edit(spec)
def rename(self, name):
"""Renames the VM.
:param str name: New name for the VM
"""
self._log.debug("Renaming VM %s to %s", self.name, name)
if not self._vm.Rename_Task(newName=str(name)).wait():
self._log.error("Failed to rename VM %s to %s", self.name, name)
else:
self.name = str(name)
def upgrade(self, version):
"""Upgrades the hardware version of the VM.
:param int version: Version of hardware to upgrade VM to
[defaults to the latest version the VM's host supports]
"""
try:
self._vm.UpgradeVM_Task("vmx-" + str(version)).wait()
except vim.fault.AlreadyUpgraded:
self._log.warning("Hardware version is already up-to-date for %s",
self.name)
def convert_template(self):
"""Converts a Virtual Machine to a Template."""
if self.is_template():
self._log.warning("%s is already a Template", self.name)
else:
self._log.debug("Converting '%s' to Template", self.name)
self._vm.MarkAsTemplate()
def convert_vm(self):
"""Converts a Template to a Virtual Machine."""
self._log.debug("Converting '%s' to VM", self.name)
self._vm.MarkAsVirtualMachine(self.resource_pool, self.host)
def set_note(self, note):
"""Sets the note on the VM.
:param str note: String to set the note to
"""
self._edit(vim.vm.ConfigSpec(annotation=str(note)))
# From: execute_program_in_vm.py in pyvmomi_community_samples
def execute_program(self, process_manager, program_path,
username=None, password=None, program_args=""):
"""Executes a commandline program in the VM.
This requires VMware Tools to be installed on the VM.
:param vim.vm.guest.ProcessManager process_manager: vSphere process manager object
:param str program_path: Path to the program inside the VM
:param str username: User on VM to execute program using
[default: current ADLES user]
:param str password: Plaintext password for the User
[default: prompt user]
:param str program_args: Commandline arguments for the program
:return: Program Process ID (PID) if it was executed successfully,
-1 if not
:rtype: int
"""
from os.path import basename
prog_name = basename(program_path)
if not self.has_tools():
self._log.error("Cannot execute program %s in VM %s: "
"VMware Tools is not running",
prog_name, self.name)
return -1
if username is None:
from getpass import getuser
username = getuser()
if password is None:
from getpass import getpass
password = getpass("Enter password of user %s to "
"execute program %s on VM %s"
% (username, prog_name, self.name))
creds = vim.vm.guest.NamePasswordAuthentication(username=username,
password=password)
try:
prog_spec = vim.vm.guest.ProcessManager.ProgramSpec(
programPath=program_path, arguments=program_args)
pid = process_manager.StartProgramInGuest(self._vm,
creds, prog_spec)
self._log.debug("Successfully started program %s in VM %s. PID: %s",
prog_name, self.name, pid)
return pid
except IOError as e:
self._log.error("Could not execute program %s in VM %s: %s",
prog_name, self.name, str(e))
return -1
def snapshot_disk_usage(self):
"""Determines the total disk usage of a VM's snapshots.
:return: Human-readable disk usage of the snapshots
:rtype: str
"""
from re import search
disk_list = self._vm.layoutEx.file
size = 0
for disk in disk_list:
if disk.type == 'snapshotData':
size += disk.size
ss_disk = search(r'0000\d\d', disk.name)
if ss_disk:
size += disk.size
return utils.sizeof_fmt(size)
def create_snapshot(self, name, description='', memory=False, quiesce=True):
"""Creates a snapshot of the VM.
:param str name: Name of the snapshot
:param str description: Text description of the snapshot
:param bool memory: Memory dump of the VM is included in the snapshot
:param bool quiesce: Quiesce VM disks (Requires VMware Tools)
"""
self._log.info("Creating snapshot '%s' of VM '%s'", name, self.name)
if not self._vm.CreateSnapshot_Task(name=name, description=description,
memory=bool(memory),
quiesce=quiesce).wait():
self._log.error("Failed to take snapshot of VM %s", self.name)
def revert_to_snapshot(self, snapshot):
"""Reverts VM to the named snapshot.
:param str snapshot: Name of the snapshot to revert to
"""
self._log.info("Reverting '%s' to the snapshot '%s'",
self.name, snapshot)
self.get_snapshot(snapshot).RevertToSnapshot_Task().wait()
def revert_to_current_snapshot(self):
"""Reverts the VM to the most recent snapshot."""
self._log.info("Reverting '%s' to the current snapshot", self.name)
self._vm.RevertToCurrentSnapshot_Task().wait()
def remove_snapshot(self, snapshot, remove_children=True,
consolidate_disks=True):
"""Removes the named snapshot from the VM.
:param str snapshot: Name of the snapshot to remove
:param bool remove_children: Removal of the entire snapshot subtree
:param bool consolidate_disks: Virtual disks of deleted snapshot
will be merged with other disks if possible
"""
self._log.info("Removing snapshot '%s' from '%s'", snapshot, self.name)
self.get_snapshot(snapshot).RemoveSnapshot_Task(
remove_children, consolidate_disks).wait()
def remove_all_snapshots(self, consolidate_disks=True):
"""Removes all snapshots associated with the VM.
:param bool consolidate_disks: Virtual disks of the deleted snapshot
will be merged with other disks if possible
"""
self._log.info("Removing ALL snapshots for %s", self.name)
self._vm.RemoveAllSnapshots_Task(consolidate_disks).wait()
# Based on: add_nic_to_vm in pyvmomi-community-samples
def add_nic(self, network, summary="default-summary", model="e1000"):
"""Add a NIC in the portgroup to the VM.
:param vim.Network network: Network to attach NIC to
:param str summary: Human-readable device info
[default: default-summary]
:param str model: Model of virtual network adapter.
Options: (e1000 | e1000e | vmxnet | vmxnet2
| vmxnet3 | pcnet32 | sriov)
e1000 will work on Windows Server 2003+,
and e1000e is supported on Windows Server 2012+.
VMXNET adapters require VMware Tools to be installed,
and provide enhanced performance.
`Read this for more details:
<http://rickardnobel.se/vmxnet3-vs-e1000e-and-e1000-part-1/>`_
"""
if not isinstance(network, vim.Network):
self._log.error("Invalid network type when adding vNIC "
"to VM '%s': %s", self.name, type(network).__name__)
self._log.debug("Adding NIC to VM '%s'\nNetwork: '%s'"
"\tSummary: '%s'\tNIC Model: '%s'",
self.name, network.name, summary, model)
# Create base object to add configurations to
spec = vim.vm.device.VirtualDeviceSpec()
spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
# Set the type of network adapter
if model == "e1000":
spec.device = vim.vm.device.VirtualE1000()
elif model == "e1000e":
spec.device = vim.vm.device.VirtualE1000e()
elif model == "vmxnet":
spec.device = vim.vm.device.VirtualVmxnet()
elif model == "vmxnet2":
spec.device = vim.vm.device.VirtualVmxnet2()
elif model == "vmxnet3":
spec.device = vim.vm.device.VirtualVmxnet3()
elif model == "pcnet32":
spec.device = vim.vm.device.VirtualPCNet32()
elif model == "sriov":
spec.device = vim.vm.device.VirtualSriovEthernetCard()
else:
self._log.error("Invalid NIC model: '%s'\n"
"Defaulting to e1000...", model)
spec.device = vim.vm.device.VirtualE1000()
# Sets how MAC address is assigned
spec.device.addressType = 'generated'
# Disables Wake-on-lan capabilities
spec.device.wakeOnLanEnabled = False
spec.device.deviceInfo = vim.Description()
spec.device.deviceInfo.summary = summary
spec.device.backing = \
vim.vm.device.VirtualEthernetCard.NetworkBackingInfo()
spec.device.backing.useAutoDetect = False
# Sets port group to assign adapter to
spec.device.backing.network = network
# Sets name of device on host system
spec.device.backing.deviceName = network.name
spec.device.connectable = vim.vm.device.VirtualDevice.ConnectInfo()
# Ensures adapter is connected at boot
spec.device.connectable.startConnected = True
# Allows guest OS to control device
spec.device.connectable.allowGuestControl = True
spec.device.connectable.connected = True
spec.device.connectable.status = 'untried'
self._edit(vim.vm.ConfigSpec(deviceChange=[spec])) # Apply change to VM
def edit_nic(self, nic_id, network=None, summary=None):
"""Edits a vNIC based on it's number.
:param int nic_id: Number of network adapter on VM
:param network: Network to assign the vNIC to
:type network: vim.Network
:param str summary: Human-readable device description
:return: If the edit operation was successful
:rtype: bool
"""
nic_label = 'Network adapter ' + str(nic_id)
self._log.debug("Changing '%s' on VM '%s'", nic_label, self.name)
virtual_nic_device = self.get_nic_by_name(nic_label)
if not virtual_nic_device:
self._log.error('Virtual %s could not be found!', nic_label)
return False
nic_spec = vim.vm.device.VirtualDeviceSpec()
nic_spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.edit
nic_spec.device = virtual_nic_device
if summary:
nic_spec.device.deviceInfo.summary = str(summary)
if network:
self._log.debug("Changing PortGroup to: '%s'", network.name)
nic_spec.device.backing.network = network
nic_spec.device.backing.deviceName = network.name
# Apply change to VM
self._edit(vim.vm.ConfigSpec(deviceChange=[nic_spec]))
return True
# Based on: delete_nic_from_vm in pyvmomi-community-samples
def remove_nic(self, nic_number):
"""Deletes a vNIC based on it's number.
:param int nic_number: Number of the vNIC to delete
:return: If removal succeeded
:rtype: bool
"""
nic_label = "Network adapter " + str(nic_number)
self._log.debug("Removing Virtual %s from '%s'", nic_label, self.name)
virtual_nic_device = self.get_nic_by_name(nic_label)
if virtual_nic_device is not None:
virtual_nic_spec = vim.vm.device.VirtualDeviceSpec()
virtual_nic_spec.operation = \
vim.vm.device.VirtualDeviceSpec.Operation.remove
virtual_nic_spec.device = virtual_nic_device
# Apply change to VM
self._edit(vim.vm.ConfigSpec(deviceChange=[virtual_nic_spec]))
return True
else:
self._log.error("Virtual %s could not be found for '%s'",
nic_label, self.name)
return False
def remove_device(self, device_spec):
"""Removes a device from the VM.
:param device_spec: The specification of the device to remove
:type device_spec: vim.vm.device.VirtualDeviceSpec
"""
self._log.debug("Removing device '%s' from '%s'",
device_spec.name, self.name)
device_spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.remove
self._edit(vim.vm.ConfigSpec(deviceChange=[device_spec]))
# Based on: delete_disk_from_vm.py in pyvmomi_community_samples
def remove_hdd(self, disk_number):
"""Removes a numbered Virtual Hard Disk from the VM.
:param int disk_number: Number of the HDD to remove
:return: If the HDD was successfully removed
:rtype: bool
"""
hdd_label = "Hard disk " + str(disk_number)
self._log.debug("Removing Virtual HDD %s from %s", hdd_label, self.name)
dev = self.get_hdd_by_name(hdd_label)
if not dev:
self._log.error("Could not find Virtual %s to remove", hdd_label)
return False
else:
spec = vim.vm.device.VirtualDeviceSpec(device=dev)
self.remove_device(device_spec=spec)
return True
# Based on: resize_disk.py from pyvmomi-community-samples
def resize_hdd(self, size, disk_number=1, disk_prefix="Hard disk "):
"""Resize a virtual HDD on the VM.
:param int size: New disk size in KB
:param int disk_number: Disk number
:param disk_prefix: Disk label prefix
:return: If the resize was successful
:rtype: bool
"""
# TODO: !!UNTESTED!!
self._log.warning("Usage of untested method resize_hdd")
hdd_label = disk_prefix + str(disk_number)
self._log.debug("Resizing %s on VM %s to %d",
hdd_label, self.name, size)
# Find the disk device
dev = self.get_hdd_by_name(hdd_label)
if not dev:
self._log.error("Could not find Virtual %s to resize", hdd_label)
return False
else:
virtual_disk_spec = vim.vm.device.VirtualDeviceSpec()
virtual_disk_spec.operation = \
vim.vm.device.VirtualDeviceSpec.operation.edit
virtual_disk_spec.device = dev
virtual_disk_spec.device.capacityInKB = int(size)
self._edit(vim.vm.ConfigSpec(deviceChange=[virtual_disk_spec]))
return True
# Based on: change_disk_mode.py in pyvmomi-community-samples
def change_hdd_mode(self, mode, disk_number=1, disk_prefix="Hard disk "):
"""Change the mode on a virtual HDD.
:param str mode: New disk mode
:param int disk_number: Disk number
:param str disk_prefix: Disk label prefix
:return: If the disk mode change operation was successful
:rtype: bool
"""
# TODO: !!UNTESTED!!
self._log.warning("Usage of untested method change_hdd_mode")
hdd_label = disk_prefix + str(disk_number)
self._log.debug("Changing mode of %s on VM %s to %s",
hdd_label, self.name, mode)
# Find the disk device
dev = self.get_hdd_by_name(hdd_label)
if not dev:
self._log.error("Could not find Virtual %s to resize", hdd_label)
return False
else:
virtual_disk_spec = vim.vm.device.VirtualDeviceSpec()
virtual_disk_spec.operation = \
vim.vm.device.VirtualDeviceSpec.operation.edit
virtual_disk_spec.device = dev
virtual_disk_spec.device.backing.diskMode = str(mode)
self._edit(vim.vm.ConfigSpec(deviceChange=[virtual_disk_spec]))
return True
def attach_iso(self, iso_path, datastore=None, boot=True):
"""
Attaches an ISO image to a VM.
:param str iso_path: Path in the Datastore of the ISO image to attach
:param vim.Datastore datastore: Datastore where the ISO resides
[defaults to the VM's datastore]
:param bool boot: Set VM to boot from the attached ISO
"""
self._log.debug("Adding ISO '%s' to '%s'", iso_path, self.name)
if datastore is None:
datastore = self.datastore
spec = vim.vm.device.VirtualDeviceSpec()
spec.device = vim.vm.device.VirtualCdrom()
spec.device.key = -1
spec.device.unitNumber = 0
# Find a disk controller to attach to
controller = self._find_free_ide_controller()
if controller:
spec.device.controllerKey = controller.key
else:
self._log.error("Could not find a free IDE controller "
"on '%s' to attach ISO '%s'",
self.name, iso_path)
return
spec.device.backing = vim.vm.device.VirtualCdrom.IsoBackingInfo()
# Attach ISO
spec.device.backing.fileName = "[%s] %s" % (datastore.name, iso_path)
# Set datastore containing the ISO file
spec.device.backing.datastore = datastore
spec.device.connectable = vim.vm.device.VirtualDevice.ConnectInfo()
# Allows guest OS to control device
spec.device.connectable.allowGuestControl = True
# Ensures ISO is connected at boot
spec.device.connectable.startConnected = True
spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
vm_spec = vim.vm.ConfigSpec(deviceChange=[spec])
if boot: # Set the VM to boot from the ISO upon power on
self._log.debug("Setting '%s' to boot from ISO '%s'",
self.name, iso_path)
order = [vim.vm.BootOptions.BootableCdromDevice()]
order.extend(list(self._vm.config.bootOptions.bootOrder))
vm_spec.bootOptions = vim.vm.BootOptions(bootOrder=order)
self._edit(vm_spec) # Apply change to VM
def _find_free_ide_controller(self):
"""
Finds a free IDE controller to use.
:return: The free IDE controller
:rtype: vim.vm.device.VirtualIDEController or None
"""
for dev in self._vm.config.hardware.device:
if isinstance(dev, vim.vm.device.VirtualIDEController) \
and len(dev.device) < 2:
# If there are less than 2 devices attached, we can use it
return dev
return None
def relocate(self, host=None, datastore=None):
"""Relocates the VM to a new host and/or datastore
:param vim.Host host:
:param vim.Datastore datastore:
"""
# TODO: !!UNTESTED!!
self._log.warning("Usage of untested method relocate")
if host is None:
host = self.host
if datastore is None:
datastore = self.datastore
self._log.debug("Relocating VM %s to host %s and datastore %s",
self.name, host.name, datastore.name)
self._vm.Relocate(
spec=vim.vm.RelocateSpec(host=host, datastore=datastore)).wait()
def mount_tools(self):
"""Mount the installer for VMware Tools."""
self._log.debug("Mounting tools installer on %s", self.name)
self._vm.MountToolsInstaller().wait()
def get_datastore_folder(self):
"""Gets the name of the VM's folder on the datastore.
:return: The name of the datastore folder with the VM's files
:rtype: str
"""
return os.path.split(self._vm.summary.config.vmPathName)[0]
def get_hdd_by_name(self, name):
"""Gets a Virtual HDD from the VM.
:param name: Name of the virtual HDD
:return: The HDD device
:rtype: vim.vm.device.VirtualDisk or None
"""
for dev in self._vm.config.hardware.device:
if isinstance(dev, vim.vm.device.VirtualDisk) and \
dev.deviceInfo.label.lower() == name.lower():
return dev
return None
def get_vim_vm(self):
"""Get the vim.VirtualMachine instance of the VM.
:return: The vim instance of the VM
:rtype: vim.VirtualMachine
"""
return self._vm
def get_nics(self):
"""Returns a list of all Virtual Network Interface Cards (vNICs) on the VM.
:return: All vNICs on the VM
:rtype: list(vim.vm.device.VirtualEthernetCard) or list
"""
return [dev for dev in self._vm.config.hardware.device if is_vnic(dev)]
def get_nic_by_name(self, name):
"""Gets a Virtual Network Interface Card (vNIC) from a VM.
:param str name: Name of the vNIC
:return: The vNIC found
:rtype: vim.vm.device.VirtualEthernetCard or None
"""
for dev in self._vm.config.hardware.device:
if is_vnic(dev) and dev.deviceInfo.label.lower() == name.lower():
return dev
self._log.debug("Could not find vNIC '%s' on '%s'", name, self.name)
return None
def get_nic_by_id(self, nic_id):
"""Get a vNIC by integer ID.
:param int nic_id: ID of the vNIC
:return: The vNIC found
:rtype: vim.vm.device.VirtualEthernetCard or None
"""
return self.get_nic_by_name("Network Adapter " + str(nic_id))
def get_nic_by_network(self, network):
"""Finds a vNIC by it's network backing.
:param vim.Network network: Network of the vNIC to match
:return: Name of the vNIC
:rtype: str or None
"""
for dev in self._vm.config.hardware.device:
if is_vnic(dev) and dev.backing.network == network:
return dev
self._log.debug("Could not find vNIC with network '%s' on '%s'",
network.name, self.name)
return None
def get_snapshot(self, snapshot=None):
"""Retrieves the named snapshot from the VM.
:param str snapshot: Name of the snapshot [default: current snapshot]
:return: The snapshot found
:rtype: vim.Snapshot or None
"""
if snapshot is None:
return self._vm.snapshot.currentSnapshot
else:
for snap in self.get_all_snapshots():
if snap.name == snapshot:
return snap.snapshot
return None
def get_all_snapshots(self):
"""Retrieves a list of all snapshots of the VM.
:return: Nested List of vim.Snapshot objects
:rtype: list(vim.Snapshot) or None
"""
return self._get_snapshots_recursive(self._vm.snapshot.rootSnapshotList)
# From: https://github.com/imsweb/ezmomi
def _get_snapshots_recursive(self, snap_tree):
"""Recursively finds all snapshots in the tree.
:param snap_tree: Tree of snapshots
:return: Nested List of vim.Snapshot objects
:rtype: list(vim.Snapshot) or None
"""
local_snap = []
for snap in snap_tree:
local_snap.append(snap)
for snap in snap_tree:
recurse_snap = self._get_snapshots_recursive(snap.childSnapshotList)
if recurse_snap:
local_snap.extend(recurse_snap)
return local_snap
def get_snapshot_info(self, name=None):
"""Human-readable info on a snapshot.
:param str name: Name of the snapshot to get
[defaults to the current snapshot]
:return: Info on the snapshot found
:rtype: str
"""
snap = self.get_snapshot(name)
return "\nName: %s; Description: %s; CreateTime: %s; State: %s" % \
(snap.name, snap.description, snap.createTime, snap.state)
def get_all_snapshots_info(self):
"""Enumerates the full snapshot tree of the VM and makes it human-readable.
:return: The human-readable snapshot tree info
:rtype: str
"""
# Check for ideas: snapshot_operations.py in pyvmomi_community_samples
raise NotImplementedError # TODO: implement
def get_info(self, detailed=False, uuids=False,
snapshot=False, vnics=False):
"""Get human-readable information for a VM.
:param bool detailed: Add detailed information, e.g maximum memory used
:param bool uuids: Whether to get UUID information
:param bool snapshot: Shows the current snapshot, if any
:param bool vnics: Add information about vNICs on the VM
:return: The VM's information
:rtype: str
"""
info_string = "\n"
summary = self._vm.summary # https://goo.gl/KJRrqS
config = self._vm.config # https://goo.gl/xFdCby
info_string += "Name : %s\n" % self.name
info_string += "Status : %s\n" % str(summary.overallStatus)
info_string += "Power State : %s\n" % summary.runtime.powerState
if self._vm.guest:
info_string += "Guest State : %s\n" % self._vm.guest.guestState
info_string += "Last modified : %s\n" \
% str(self._vm.config.modified) # datetime object
if hasattr(summary.runtime, 'cleanPowerOff'):
info_string += "Clean poweroff: %s\n" % \
summary.runtime.cleanPowerOff
if detailed:
info_string += "Num consoles : %d\n" % \
summary.runtime.numMksConnections
info_string += "Host : %s\n" % self.host.name
info_string += "Datastore : %s\n" % self.datastore
info_string += "HW Version : %s\n" % config.version
info_string += "Guest OS : %s\n" % summary.config.guestFullName
info_string += "Num CPUs : %s\n" % summary.config.numCpu
info_string += "Memory (MB) : %s\n" % summary.config.memorySizeMB
if detailed:
info_string += "Num vNICs : %s\n" % \
summary.config.numEthernetCards
info_string += "Num Disks : %s\n" % \
summary.config.numVirtualDisks
info_string += "IsTemplate : %s\n" % summary.config.template # bool
if detailed:
info_string += "Config Path : %s\n" % summary.config.vmPathName
info_string += "Folder: : %s\n" % self._vm.parent.name
if self._vm.guest:
info_string += "IP : %s\n" % self._vm.guest.ipAddress
info_string += "Hostname: : %s\n" % self._vm.guest.hostName
info_string += "Tools status : %s\n" % \
self._vm.guest.toolsRunningStatus
info_string += "Tools version : %s\n" % \
self._vm.guest.toolsVersionStatus2
if vnics:
vm_nics = self.get_nics()
for num, vnic in zip(range(1, len(vm_nics) + 1), vm_nics):
info_string += "vNIC %d label : %s\n" % \
(num, vnic.deviceInfo.label)
info_string += "vNIC %d summary : %s\n" % \
(num, vnic.deviceInfo.summary)
info_string += "vNIC %d network : %s\n" % \
(num, vnic.backing.network.name)
if uuids:
info_string += "Instance UUID : %s\n" % summary.config.instanceUuid
info_string += "Bios UUID : %s\n" % summary.config.uuid
if summary.runtime.question:
info_string += "Question : %s\n" % \
summary.runtime.question.text
if summary.config.annotation:
info_string += "Annotation : %s\n" % summary.config.annotation
if snapshot and self._vm.snapshot and hasattr(self._vm.snapshot,
'currentSnapshot'):
info_string += "Current Snapshot: %s\n" % \
self._vm.snapshot.currentSnapshot.config.name
info_string += "Disk usage of all snapshots: %s\n" % \
self.snapshot_disk_usage()
if detailed and summary.runtime:
info_string += "Last Poweron : %s\n" % \
str(summary.runtime.bootTime) # datetime object
info_string += "Max CPU usage : %s\n" % summary.runtime.maxCpuUsage
info_string += "Max Mem usage : %s\n" % \
summary.runtime.maxMemoryUsage
info_string += "Last suspended: %s\n" % summary.runtime.suspendTime
return info_string
def screenshot(self):
"""Takes a screenshot of a VM.
:return: Path to datastore location of the screenshot
:rtype: str
"""
self._log.debug("Taking screenshot of %s", self.name)
return self._vm.CreateScreenshot_Task().wait()
def has_tools(self):
"""Checks if VMware Tools is installed and working.
:return: If tools are installed and working
:rtype: bool
"""
tools = self._vm.summary.guest.toolsStatus
return True if tools == "toolsOK" or tools == "toolsOld" else False
def powered_on(self):
"""Determines if a VM is powered on.
:return: If VM is powered on
:rtype: bool
"""
return self._vm.runtime.powerState == \
vim.VirtualMachine.PowerState.poweredOn
def is_template(self):
"""Checks if VM is a template.
:return: If the VM is a template
:rtype: bool
"""
return bool(self._vm.summary.config.template)
def is_windows(self):
"""Checks if a VM's guest OS is Windows.
:return: If guest OS is Windows
:rtype: bool
"""
return bool(str(self._vm.config.guestId).lower().startswith("win"))
def _edit(self, config):
"""Reconfigures VM with the given configuration specification.
:param vim.vm.ConfigSpec config: The configuration specification to apply
:return: If the edit was successful
"""
if not self._vm.ReconfigVM_Task(config).wait():
self._log.error("Failed to edit VM %s", self.name)
return False
else:
return True
def _customize(self, customization):
"""Customizes the VM using the given customization specification.
:param vim.vm.customization.Specification customization:
The customization specification to apply
:return: If the customization was successful
:rtype: bool
"""
if not self._vm.CheckCustomizationSpec(spec=customization).wait():
self._log.error("Customization check failed for VM %s", self.name)
return False
elif not self._vm.CustomizeVM_Task(spec=customization).wait():
self._log.error("Failed to customize VM %s", self.name)
return False
else:
return True
def __str__(self):
return str(self.name)
def __hash__(self):
return hash(self._vm.summary.config.instanceUuid)
def __eq__(self, other):
return isinstance(other, self.__class__) and self.name == other.name \
and hash(self) == hash(other)
def __ne__(self, other):
return not self.__eq__(other)
def is_vnic(device):
"""Checks if the device is a VirtualEthernetCard.
:param device: The device to check
:return: If the device is a vNIC
:rtype: bool
"""
return isinstance(device, vim.vm.device.VirtualEthernetCard) | ADLES | /ADLES-1.4.0.tar.gz/ADLES-1.4.0/adles/vsphere/vm.py | vm.py |
import sys
import tqdm
from humanfriendly.prompts import prompt_for_choice, prompt_for_confirmation
from adles.scripts.script_base import Script
from adles.utils import default_prompt, pad
from adles.vsphere.folder_utils import format_structure
from adles.vsphere.vm import VM
from adles.vsphere.vsphere_utils import is_vm, make_vsphere, resolve_path
class VsphereScript(Script):
"""Base class for all vSphere CLI scripts."""
def __init__(self, server_filename=None):
super(VsphereScript, self).__init__()
self.server = make_vsphere(filename=server_filename)
class CleanupVms(VsphereScript):
"""Cleanup and Destroy Virtual Machines (VMs)
and VM Folders in a vSphere environment."""
__version__ = '0.5.12'
name = 'cleanup'
def run(self):
if prompt_for_confirmation("Multiple VMs? "):
folder, folder_name = resolve_path(self.server, "folder",
"that has the VMs/folders "
"you want to destroy")
# Display folder structure
if prompt_for_confirmation("Display the folder structure? "):
self._log.info("Folder structure: \n%s", format_structure(
folder.enumerate(recursive=True, power_status=True)))
# Prompt user to configure destruction options
print("Answer the following questions to configure the cleanup") # noqa: T001
if prompt_for_confirmation("Destroy everything in and "
"including the folder? "):
vm_prefix = ''
folder_prefix = ''
recursive = True
destroy_folders = True
destroy_self = True
else:
vm_prefix = default_prompt("Prefix of VMs you wish to destroy"
" (CASE SENSITIVE!)", default='')
recursive = prompt_for_confirmation("Recursively descend "
"into folders? ")
destroy_folders = prompt_for_confirmation("Destroy folders in "
"addition to VMs? ")
if destroy_folders:
folder_prefix = default_prompt("Prefix of folders "
"you wish to destroy"
" (CASE SENSITIVE!)",
default='')
destroy_self = prompt_for_confirmation("Destroy the "
"folder itself? ")
else:
folder_prefix = ''
destroy_self = False
# Show user what options they selected
self._log.info("Options selected\nVM Prefix: %s\n"
"Folder Prefix: %s\nRecursive: %s\n"
"Folder-destruction: %s\nSelf-destruction: %s",
str(vm_prefix), str(folder_prefix), recursive,
destroy_folders, destroy_self)
# Show how many items matched the options
v, f = folder.retrieve_items(vm_prefix, folder_prefix,
recursive=True)
num_vms = len(v)
if destroy_folders:
num_folders = len(f)
if destroy_self:
num_folders += 1
else:
num_folders = 0
self._log.info("%d VMs and %d folders match the options",
num_vms, num_folders)
# Confirm and destroy
if prompt_for_confirmation("Continue with destruction? "):
self._log.info("Destroying folder '%s'...", folder_name)
folder.cleanup(vm_prefix=vm_prefix,
folder_prefix=folder_prefix,
recursive=recursive,
destroy_folders=destroy_folders,
destroy_self=destroy_self)
else:
self._log.info("Destruction cancelled")
else:
vm = resolve_path(self.server, "vm", "to destroy")[0]
if prompt_for_confirmation("Display VM info? "):
self._log.info(vm.get_info(detailed=True, uuids=True,
snapshot=True, vnics=True))
if vm.is_template(): # Warn if template
if not prompt_for_confirmation("VM '%s' is a Template. "
"Continue? " % vm.name):
sys.exit(0)
if prompt_for_confirmation("Continue with destruction? "):
self._log.info("Destroying VM '%s'", vm.name)
vm.destroy()
else:
self._log.info("Destruction cancelled")
class CloneVms(VsphereScript):
"""Clone multiple Virtual Machines in vSphere."""
__version__ = '0.5.12'
name = 'clone'
def run(self):
vms = []
vm_names = []
# Single-vm source
if prompt_for_confirmation("Do you want to clone from a single VM?"):
v = resolve_path(self.server, "VM", "or template you wish to clone")[0]
vms.append(v)
vm_names.append(input("Base name for instances to be created: "))
# Multi-VM source
else:
folder_from, from_name = resolve_path(self.server, "folder",
"you want to clone all VMs in")
# Get VMs in the folder
v = [VM(vm=x) for x in folder_from.childEntity if is_vm(x)]
vms.extend(v)
self._log.info("%d VMs found in source folder %s", len(v), from_name)
if not prompt_for_confirmation("Keep the same names? "):
names = []
for i in range(len(v)):
names.append(input("Enter base name for VM %d: " % i))
else:
names = list(map(lambda x: x.name, v)) # Same names as sources
vm_names.extend(names)
create_in, create_in_name = resolve_path(self.server, "folder",
"in which to create VMs")
instance_folder_base = None
if prompt_for_confirmation("Do you want to create a "
"folder for each instance? "):
instance_folder_base = input("Enter instance folder base name: ")
num_instances = int(input("Number of instances to be created: "))
# Determine what will be the default
pool_name = self.server.get_pool().name
pool_name = default_prompt(prompt="Resource pool to assign VMs to",
default=pool_name)
pool = self.server.get_pool(pool_name)
datastore_name = default_prompt(prompt="Datastore to put clones on")
datastore = self.server.get_datastore(datastore_name)
self._log.info("Creating %d instances under folder %s",
num_instances, create_in_name)
for instance in tqdm.trange(num_instances, desc="Creating instances",
unit="instances"):
with tqdm.tqdm(total=len(vm_names), leave=False,
desc="Creating VMs", unit="VMs") as pbar:
for vm, name in zip(vms, vm_names):
pbar.set_postfix_str(name)
if instance_folder_base:
# Create instance folders for a nested clone
f = self.server.create_folder(
instance_folder_base + pad(instance),
create_in=create_in)
vm_name = name
else:
f = create_in
vm_name = name + pad(instance) # Append instance number
new_vm = VM(name=vm_name, folder=f,
resource_pool=pool, datastore=datastore)
new_vm.create(template=vm.get_vim_vm())
pbar.update()
class VmPower(VsphereScript):
"""Power operations for Virtual Machines in vSphere."""
__version__ = '0.4.0'
name = 'power'
def run(self):
print("Enter the power operation you wish to perform") # noqa: T001
operation = prompt_for_choice(['on', 'off', 'reset',
'suspend'], padding=False)
attempt_guest = prompt_for_confirmation("Attempt to use guest OS "
"operations, if available? ")
if prompt_for_confirmation("Multiple VMs? ", default=True):
folder, folder_name = resolve_path(self.server, "folder", "with VMs")
vms = [VM(vm=x) for x in folder.childEntity if is_vm(x)]
self._log.info("Found %d VMs in folder '%s'",
len(vms), folder_name)
if prompt_for_confirmation("Show the status of the "
"VMs in the folder? "):
self._log.info("Folder structure: \n%s", format_structure(
folder.enumerate(recursive=True, power_status=True)))
if prompt_for_confirmation("Continue? ", default=True):
pbar = tqdm.tqdm(vms, unit="VMs",
desc="Performing power operation " + operation)
for vm in pbar:
pbar.set_postfix_str(vm.name)
vm.change_state(operation, attempt_guest)
pbar.close()
else:
vm = resolve_path(self.server, "VM")[0]
self._log.info("Changing power state of '%s' "
"to '%s'", vm.name, operation)
vm.change_state(operation, attempt_guest)
class VsphereInfo(VsphereScript):
"""Query information about a vSphere environment and objects within it."""
__version__ = '0.6.5'
name = 'info'
def run(self):
print("What type of thing do you want to get information on?") # noqa: T001
thing_type = prompt_for_choice(['vm', 'datastore', 'vsphere',
'folder'], padding=False)
# Single Virtual Machine
if thing_type == "vm":
vm = resolve_path(self.server, "vm",
"you want to get information on")[0]
self._log.info(vm.get_info(detailed=True, uuids=True,
snapshot=True, vnics=True))
# Datastore
elif thing_type == "datastore":
ds = self.server.get_datastore(input(
"Enter name of the Datastore [leave "
"blank for first datastore found]: ")
)
self._log.info(ds.get_info())
# vCenter server
elif thing_type == "vsphere":
self._log.info(str(self.server))
# Folder
elif thing_type == "folder":
folder, folder_name = resolve_path(self.server, "folder")
if "VirtualMachine" in folder.childType \
and prompt_for_confirmation("Want to see power state "
"of VMs in the folder?"):
contents = folder.enumerate(recursive=True, power_status=True)
else:
contents = folder.enumerate(recursive=True, power_status=False)
self._log.info("Information for Folder %s\n"
"Types of items folder can contain: %s\n%s",
folder_name, str(folder.childType),
format_structure(contents))
# That's not a thing!
else:
self._log.info("Invalid selection: %s", thing_type)
class VmSnapshot(VsphereScript):
"""Perform Snapshot operations on Virtual
Machines in a vSphere environment."""
__version__ = '0.3.0'
name = 'snapshot'
def run(self):
print("Enter Snapshot operation to perform") # noqa: T001
op = prompt_for_choice(['create', 'revert', 'revert-current', 'remove',
'remove-all', 'get', 'get-current', 'get-all',
'disk-usage'], padding=False)
if op in ['create', 'revert', 'remove', 'get']:
name = input("Name of snapshot to %s: " % op)
if op == "create":
desc = input("Description of snapshot to create: ")
memory = prompt_for_confirmation("Include memory?")
quiesce = prompt_for_confirmation("Quiesce disks? (Requires VMware "
"Tools to be running on the VM)")
elif op == "remove":
children = prompt_for_confirmation("Remove any children of the "
"snapshot?", default=True)
if prompt_for_confirmation("Multiple VMs? ", default=True):
f, f_name = resolve_path(self.server, "folder", "with VMs")
vms = [VM(vm=x) for x in f.childEntity if is_vm(x)]
self._log.info("Found %d VMs in folder '%s'", len(vms), f_name)
if prompt_for_confirmation("Show the status of the "
"VMs in the folder? "):
self._log.info("Folder structure: \n%s", format_structure(
f.enumerate(recursive=True, power_status=True)))
if not prompt_for_confirmation("Continue? ", default=True):
self._log.info("User cancelled operation, exiting...")
sys.exit(0)
else:
vms = [resolve_path(self.server, "vm",
"to perform snapshot operations on")[0]]
# Perform the operations
pbar = tqdm.tqdm(vms, total=len(vms), unit="VMs",
desc="Taking snapshots")
for vm in pbar:
self._log.info("Performing operation '%s' on VM '%s'", op, vm.name)
pbar.set_postfix_str(vm.name)
if op == "create":
vm.create_snapshot(name=name, description=desc,
memory=memory, quiesce=quiesce)
elif op == "revert":
vm.revert_to_snapshot(snapshot=name)
elif op == "revert-current":
vm.revert_to_current_snapshot()
elif op == "remove":
vm.remove_snapshot(snapshot=name, remove_children=children)
elif op == "remove-all":
vm.remove_all_snapshots()
elif op == "get":
self._log.info(vm.get_snapshot_info(name))
elif op == "get-current":
self._log.info(vm.get_snapshot_info())
elif op == "get-all":
self._log.info(vm.get_all_snapshots_info())
elif op == "disk-usage":
self._log.info(vm.snapshot_disk_usage())
else:
self._log.error("Unknown operation: %s", op)
pbar.update()
pbar.close()
VSPHERE_SCRIPTS = [CleanupVms, CloneVms, VmPower, VsphereInfo, VmSnapshot] | ADLES | /ADLES-1.4.0.tar.gz/ADLES-1.4.0/adles/vsphere/vsphere_scripts.py | vsphere_scripts.py |
---
layout: default
---
# What is ADLES?
ADLES is a tool that automates the creation of system environments for educational purposes.
The goal of the system is to enable educators to easily build environments for their courses,
without the need for a specific platform or advanced IT knowledge.
Complete documentation can be found at ReadTheDocs: [adles.readthedocs.io](https://adles.readthedocs.io)
Publication describing the system: [doi.org](https://doi.org/10.1016/j.cose.2017.12.007)
## Getting started
```bash
pip3 install adles
adles -h
adles --print-spec exercise
adles --print-spec infra
adles --list-examples
adles --print-example competition
```
## Usage
Creating an environment using ADLES:
* Read the exercise and infrastructure specifications and examples of them.
* Write an infrastructure specification for your platform. (Currently, VMware vSphere is the only platform supported)
* Write an exercise specification with the environment you want created.
* Check its syntax, run the mastering phase, make your changes, and then run the deployment phase.
```bash
adles -c my-competition.yaml
adles -m -s my-competition.yaml
adles -d -s my-competition.yaml
```
## Requirements
Python: 3.5+
ADLES will run on any platform supported by Python. It has been tested on:
* Windows 10 (Anniversary and Creators)
* Ubuntu 14.04 and 16.04 (Including Bash on Ubuntu on Windows)
* CentOS 7
### VM requirements
**VMware vSphere**
* vCenter Server: 6.0+
* ESXi: 6.0+
# License
This project is licensed under the Apache License, Version 2.0. See
LICENSE for the full license text, and NOTICES for attributions to
external projects that this project uses code from.
# Project History
The system began as a proof of concept implementation of my Master's thesis research at the
University of Idaho in Fall of 2016. It was originally designed to run on the RADICL lab.
| ADLES | /ADLES-1.4.0.tar.gz/ADLES-1.4.0/docs/index.md | index.md |
*********
Platforms
*********
Wrappers for the various platforms ADLES supports.
vSphere
=======
The vSphere platform serves as a wrapper around the pyVmomi library.
.. automodule:: adles.vsphere
Vsphere
-------
Holds the state and provides methods to interact with the vCenter server
or ESXi host.
.. autoclass:: adles.vsphere.vsphere_class.Vsphere
:members:
VM
--
Represents a Virtual Machine.
.. automodule:: adles.vsphere.vm
:members:
Host
----
Represents an ESXi host.
.. automodule:: adles.vsphere.host
:members:
Utility functions
-----------------
.. automodule:: adles.vsphere.vsphere_utils
:members:
.. automodule:: adles.vsphere.folder_utils
:members:
.. automodule:: adles.vsphere.network_utils
:members:
| ADLES | /ADLES-1.4.0.tar.gz/ADLES-1.4.0/docs/source/platforms.rst | platforms.rst |
*******************************************************
Automated Deployment of Lab Environments System (ADLES)
*******************************************************
ADLES automates the deterministic creation of virtualized environments for use in Cybersecurity and Information Technology (IT) education.
Installation
============
.. code:: bash
pip install adles
Getting started
===============
.. code:: bash
adles -h
adles --print-spec exercise
adles --print-spec infra
adles --list-examples
adles --print-example competition
Usage
=====
Creating an environment using ADLES:
* Read the exercise and infrastructure specifications and examples of them.
* Write an infrastructure specification for your platform. (Currently, VMware vSphere is the only platform supported)
* Write an exercise specification with the environment you want created.
* Check its syntax, run the mastering phase, make your changes, and then run the deployment phase.
.. code:: bash
# Validate spec
adles validate my-competition.yaml
# Create Master images
adles masters my-competition.yaml
# Deploy the exercise
adles deploy my-competition.yaml
# Cleanup the environment
adles cleanup my-competition.yaml
API Documentation
=================
.. toctree::
:maxdepth: 2
:caption: Contents:
interfaces
platforms
scripts
utils
Indices and tables
==================
* :ref:`genindex`
* :ref:`modindex`
* :ref:`search`
| ADLES | /ADLES-1.4.0.tar.gz/ADLES-1.4.0/docs/source/index.rst | index.rst |
**********
Interfaces
**********
Interfaces for the various platforms ADLES supports.
Generic Interface
=================
.. autoclass:: adles.interfaces.interface.Interface
:members:
vSphere Interface
=================
.. autoclass:: adles.interfaces.vsphere_interface.VsphereInterface
:members:
Docker Interface
================
.. autoclass:: adles.interfaces.docker_interface.DockerInterface
:members:
Cloud Interface
===============
.. autoclass:: adles.interfaces.cloud_interface.CloudInterface
:members:
| ADLES | /ADLES-1.4.0.tar.gz/ADLES-1.4.0/docs/source/interfaces.rst | interfaces.rst |
*******************************************************
Automated Deployment of Lab Environments System (ADLES)
*******************************************************
SYNOPSIS
========
adles [options] [-]
adles [options] [-t TYPE] -c SPEC [-]
adles [options] (-m | -d) [-p] -s SPEC [-]
adles [options] (--cleanup-masters | --cleanup-enviro) [--nets] -s SPEC [-]
DESCRIPTION
===========
Automated Deployment of Lab Environments System (ADLES)
| ADLES automates the deterministic creation of virtualized environments for use in
Cybersecurity and Information Technology (IT) education.
| The system enables educators to easily build deterministic and
portable environments for their courses, saving significant amounts of
time and effort, and alieviates the requirement of possessing advanced IT knowledge.
Complete documentation can be found at ReadTheDocs: https://adles.readthedocs.io
Project source code and examples can be found on GitHub: https://github.com/GhostofGoes/ADLES
COMMAND LINE OPTIONS
====================
-n, --no-color Do not color terminal output
-v, --verbose Emit debugging logs to terminal
-c, --validate SPEC Validates syntax of an exercise specification
-t, --type TYPE Type of specification to validate: exercise, package, infra
-s, --spec SPEC Name of a YAML specification file
-i, --infra FILE Override infra spec with the one in FILE
-p, --package Build environment from package specification
-m, --masters Master creation phase of specification
-d, --deploy Environment deployment phase of specification
--cleanup-masters Cleanup masters created by a specification
--cleanup-enviro Cleanup environment created by a specification
--nets Cleanup networks created during either phase
--print-spec NAME Prints the named specification: exercise, package, infrastructure
--list-examples Prints the list of examples available
--print-example NAME Prints the named example
-h, --help Shows this help
--version Prints current version
USAGE
=====
Creating an environment using ADLES:
* Read the exercise and infrastructure specifications and examples of them.
* Write an infrastructure specification for your platform. (Currently, VMware vSphere is the only platform supported)
* Write an exercise specification with the environment you want created.
* Check its syntax, run the mastering phase, make your changes, and then run the deployment phase.
.. code:: bash
adles -c my-competition.yaml
adles -m -s my-competition.yaml
adles -d -s my-competition.yaml
EXAMPLES
========
adles --list-examples
adles -c examples/tutorial.yaml
adles --verbose --masters --spec examples/experiment.yaml
adles -vds examples/competition.yaml
adles --cleanup-masters --nets -s examples/competition.yaml
adles --print-example competition | adles -v -c -
LICENSING
=========
This project is licensed under the Apache License, Version 2.0. See
LICENSE for the full license text, and NOTICES for attributions to
external projects that this project uses code from.
PROJECT HISTORY
===============
The system began as a proof of concept implementation of my Master's thesis research at the
University of Idaho in Fall of 2016. It was originally designed to run on the RADICL lab.
| ADLES | /ADLES-1.4.0.tar.gz/ADLES-1.4.0/docs/source/manpage.rst | manpage.rst |
MIT License
Copyright (c) 2019 Minerva Research Group from the Division of Computer Science of the University of Sevilla (Spain)
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
| ADLStream | /ADLStream-0.1.5-py3-none-any.whl/ADLStream-0.1.5.dist-info/LICENSE.md | LICENSE.md |
from flask import request, abort
import jwt, requests
from cryptography.x509 import load_pem_x509_certificate
from cryptography.hazmat.backends import default_backend
class ADLoginValidation(object):
def __init__(self, app_id, authority_url='https://login.microsoftonline.com/common/.well-known/openid-configuration'):
self.authority_url = authority_url
self.app_id = app_id
def _get_access_token(self, request):
if 'Authorization' not in request.headers:
return None
if len(request.headers['Authorization']) < 7:
return None
return request.headers['Authorization'][7:]
def _validate_request(self, request):
access_token = self._get_access_token(request)
if access_token is None:
return False
try:
token_header = jwt.get_unverified_header(access_token)
res = requests.get(self.authority_url)
jwk_uri = res.json()['jwks_uri']
res = requests.get(jwk_uri)
jwk_keys = res.json()
# Iterate JWK keys and extract matching x5c chain
x5c = None
for key in jwk_keys['keys']:
if key['kid'] == token_header['kid']:
x5c = key['x5c']
cert = ''.join(['-----BEGIN CERTIFICATE-----\n', x5c[0], '\n-----END CERTIFICATE-----\n',])
public_key = load_pem_x509_certificate(cert.encode(), default_backend()).public_key()
except Exception as ex:
print(ex)
return False
try:
jwt.decode(access_token, public_key, algorithms=token_header['alg'], audience=self.app_id,)
return True
except jwt.exceptions.InvalidTokenError as ex:
print(ex)
return False
def validate_token_decorator(self, func):
def func_wrapper(*args, **kws):
if not self._validate_request(request):
abort(403)
else:
return func(*args, **kws)
return func_wrapper | ADLoginValidation | /ADLoginValidation-0.2.tar.gz/ADLoginValidation-0.2/adloginvalidation/adloginvalidation.py | adloginvalidation.py |
# AdaptiveDecisionMaking_2018 (ADM)
Repository for code and lab resources for "Neural and Cognitive Models of Adaptive Decision Making" course (2018)
### Jupyter notebooks [](https://mybinder.org/v2/gh/CoAxLab/AdaptiveDecisionMaking_2018/master)
Click on binder badge above to run jupyter notebooks for labs and homework. Or download the ipynb files [**here**](https://nbviewer.jupyter.org/github/CoAxLab/AdaptiveDecisionMaking_2018/tree/master/notebooks/) to run locally.
## Instructions for getting started
#### Install **Anaconda** with **Python 3.6**:
- [**OSX**](https://www.anaconda.com/download/#macos)
- [**Linux**](https://www.anaconda.com/download/#linux)
- [**Windows**](https://www.anaconda.com/download/#windows)
#### Confirm installs
```bash
# check that your system is now using Anaconda's python
which python
```
```bash
# and that you installed Python 3.6
python -V
```
## Install ADMCode package
[**ADMCode**](https://pypi.org/project/ADMCode/) is a python package with custom code that can be used to complete the labs and homeworks (which will both be in the form of jupyter notebooks)
```bash
pip install --upgrade ADMCode
```
## Working with `git`
Git is full of weird nonsense terminology. [**This tutorial**](http://rogerdudler.github.io/git-guide/) is a super useful resource for understanding how to use it.
- If you don't already have a github account, create one [**here**](https://github.com)
- Install git command-line tools (see *setup* section [**here**](http://rogerdudler.github.io/git-guide/))
#### Clone ADMCode
* Open a terminal and `cd` to a directory where you want to download the ADMCode repo (example: `cd ~/Dropbox/Git/`)
* Next, use `git` to `clone` the *remote* ADMCode repository to create a *local* repo on your machine
```bash
# make sure you've done steps 1 and 2
# before executing this in your terminal
git clone https://github.com/CoAxLab/AdaptiveDecisionMaking_2018.git
```
#### Pull updates
* Use `git pull` to update your local repo with any changes to the *remote* ADMCode repo
* In the command below, `origin` is the default name pointing to the remote repo on Github
* `master` is the `branch` of the remote that you want to sync with
```bash
# first cd into your local ADMCode repo
# (same directory as step 1 in "Clone ADMCode" ^^^)
git pull origin master
```
## Useful resources
- [**Anaconda distribution**](https://www.anaconda.com/): package management for scientific python (& R)
- [**Jupyter**](http://jupyter.org/): interactive python interpreter in your browser ([tutorial](https://medium.com/codingthesmartway-com-blog/getting-started-with-jupyter-notebook-for-python-4e7082bd5d46))
- [**pandas**](http://pandas.pydata.org/pandas-docs/stable/): tabular dataframe manager ([tutorial](https://medium.com/init27-labs/intro-to-pandas-and-numpy-532a2d5293c8))
- [**numpy**](http://www.numpy.org/): numerical computing library ([tutorial](https://www.machinelearningplus.com/python/101-numpy-exercises-python/))
- [**scikit-learn**](http://scikit-learn.org/stable/): data science and machine learning library ([tutorial](http://ogrisel.github.io/scikit-learn.org/sklearn-tutorial/tutorial/text_analytics/general_concepts.html))
- [**matplotlib**](https://matplotlib.org/index.html): plotting and visualization library ([tutorial](https://www.datacamp.com/community/tutorials/matplotlib-tutorial-python))
- [**seaborn**](https://seaborn.pydata.org/): wrapper for making matplotlib pretty, plays nice w/ pandas ([tutorial](https://elitedatascience.com/python-seaborn-tutorial))
- [**and more...** ](https://docs.anaconda.com/anaconda/packages/pkg-docs/)
| ADMCode | /ADMCode-0.5.2.tar.gz/ADMCode-0.5.2/README.md | README.md |
from __future__ import absolute_import, division
from __future__ import print_function, unicode_literals
# -*- coding: utf-8 -*-
# Resource object code
#
# Created by: The Resource Compiler for PyQt4 (Qt v4.8.7)
#
# WARNING! All changes made in this file will be lost!
from PyQt5 import QtCore
qt_resource_data = b"\
\x00\x03\x09\x4f\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x03\xc2\x00\x00\x02\xc2\x08\x06\x00\x00\x00\x15\x9c\x6a\x19\
\x00\x00\x00\x04\x67\x41\x4d\x41\x00\x00\xb1\x8f\x0b\xfc\x61\x05\
\x00\x00\x00\x20\x63\x48\x52\x4d\x00\x00\x7a\x26\x00\x00\x80\x84\
\x00\x00\xfa\x00\x00\x00\x80\xe8\x00\x00\x75\x30\x00\x00\xea\x60\
\x00\x00\x3a\x98\x00\x00\x17\x70\x9c\xba\x51\x3c\x00\x00\x00\x06\
\x62\x4b\x47\x44\x00\xff\x00\xff\x00\xff\xa0\xbd\xa7\x93\x00\x00\
\x00\x09\x70\x48\x59\x73\x00\x00\x17\x11\x00\x00\x17\x11\x01\xca\
\x26\xf3\x3f\x00\x00\x00\x07\x74\x49\x4d\x45\x07\xe2\x08\x1c\x08\
\x36\x12\xc9\x51\x02\x4a\x00\x00\x80\x00\x49\x44\x41\x54\x78\xda\
\xec\xbd\x77\x98\x5c\xc7\x75\xe6\xfd\xeb\x9e\x8c\x9c\x33\x40\x04\
\x02\x24\x02\x09\x80\x00\x98\x73\x10\x29\x46\x91\xa2\x98\x94\x25\
\x52\xc9\xb2\xb9\x5e\xd9\x96\xd7\xf2\x3a\x7e\xde\xb5\xe4\xbc\x0e\
\x4a\xb6\x65\x2b\x27\x66\x31\x48\xa2\x18\xc5\x9c\x00\x12\x0c\x20\
\x88\x4c\xe4\x34\x08\x93\xa7\xfb\x7e\x7f\xbc\xa7\x54\xd5\x77\x6e\
\xcf\x0c\xe2\x0c\x66\xea\x7d\x9e\x79\xa6\xfb\x76\xdd\xca\x75\x42\
\x9d\x53\xa7\x72\x40\x0d\x11\x11\x47\x17\x39\x20\xe9\xe9\x4a\x44\
\x44\x74\x13\x71\xbe\x46\x44\xf4\x2e\xc4\x35\x19\x11\x71\xe8\x88\
\xeb\x28\xa2\xbf\x22\x07\x14\x81\xb6\x1c\x70\x0f\xb0\x0b\x28\xf4\
\x74\xad\x22\xfa\x05\x72\xc0\x08\x60\x3f\xd0\xd2\xd3\x95\x89\x88\
\xe8\x02\x09\x30\x1c\x68\x43\x73\x36\xd7\xd3\x15\x8a\x88\xe8\xe7\
\xc8\x01\x23\x81\xbd\x40\x6b\x4f\x57\x26\x22\xe2\x18\x45\x05\x5a\
\x47\x3b\x89\xf2\x7f\x44\xff\x43\x25\xd0\x0c\xfc\x79\x25\x30\x1e\
\xf8\x37\xb4\x18\x22\x22\x8e\x34\xaa\x81\xdf\x07\x1e\x05\x96\x11\
\x15\x8b\x88\xde\x8d\x04\xf8\x34\xb0\x09\xb8\x8f\x38\x5f\x23\x22\
\x7a\x1a\xd5\xc0\xff\x02\x1e\x06\x5e\x27\xae\xc9\x88\x88\x83\xc1\
\x70\xe0\x0f\x91\xfc\xbf\xa3\xa7\x2b\x13\x11\x71\x94\x31\x0a\xf8\
\x0c\x50\x5b\x09\xd4\x03\x2f\x03\xdb\x7b\xba\x56\x11\xfd\x02\x55\
\xc0\x16\x60\x39\xf0\x52\x4f\x57\x26\x22\xa2\x1b\x58\x0f\xac\x25\
\xce\xd7\x88\x88\xde\x80\x90\x87\xbc\xdc\xd3\x95\x89\x88\x38\x46\
\x31\x02\x29\xc0\x2f\x03\xdb\x7a\xba\x32\x11\x11\x47\x19\xa3\x91\
\x57\x51\x31\x6f\x0f\xf2\x87\x90\x59\x44\xc4\x81\x20\x8f\x76\xf0\
\x2b\x7a\xba\x22\x11\x11\xdd\x44\x9e\x48\x23\x23\x22\x7a\x0b\x2a\
\x10\x0f\x89\x6b\x32\x22\xe2\xe0\xe1\xd6\x51\x94\xc5\x22\xfa\x23\
\xdc\xfc\x8f\x8c\x24\x22\x22\x22\x22\x22\x22\x22\x22\x22\x22\x22\
\x22\xa2\x7f\x21\x2a\xc2\x11\x11\x11\x11\x11\x11\x11\x11\x11\x11\
\x11\x11\x11\xfd\x0a\x51\x11\x8e\x88\x88\x88\x88\x88\x88\x88\x88\
\x88\x88\x88\x88\xe8\x57\xa8\xec\xe9\x0a\x1c\x05\x0c\x03\xce\x03\
\x4e\x45\x51\xc2\xb6\x00\x8f\x01\xcf\xa0\xd0\xd9\x00\x4b\x80\x4f\
\xa0\xe0\x1b\xdf\xa4\xf3\x2b\x19\x72\xc0\x07\x81\xb3\xed\xfb\xeb\
\xc0\xd7\xd0\xf5\x2a\x21\x46\x02\x17\x59\xb9\x43\x50\x30\x82\x67\
\x80\x27\x80\x7d\x65\xd2\x0d\x46\x41\xcb\x9e\x01\x1e\x47\xd7\xb5\
\x44\xf4\x0c\xce\x02\x3e\x84\xc6\x7b\x17\xf0\x8f\xf8\x80\x12\x13\
\x80\xff\x81\xc6\xb5\x1d\xf8\x4f\xe0\x15\xe0\x63\xc0\x69\xf6\x4e\
\x3a\x92\x69\x3b\xf0\x1f\xf8\x80\x4b\x15\xc0\xc9\x68\x6e\xce\x42\
\xf3\xe7\x65\x14\x09\x75\xa3\xa5\x19\x04\xfc\x36\x8a\xec\xfe\x2f\
\xc0\xdb\x41\x7e\xe7\xa0\x79\xf8\x0a\xf0\x0d\xfc\x5d\x80\x39\xe0\
\x26\xcb\x17\xe0\x2d\xe0\xab\x94\x5e\x55\x35\x0b\xf8\x2d\x74\x65\
\xc2\xbf\x02\xab\x82\x77\x3f\x0d\x2c\x00\xbe\x0b\xfc\x1a\xb8\xd9\
\xf2\x7a\x04\xf8\xb1\xa5\x1b\x62\xcf\xce\x44\xf3\x77\x17\xf0\xa2\
\xa5\xd9\x65\x69\xce\xb7\x7a\x80\xe6\xf4\x3f\xe2\x23\xd3\x4f\x06\
\x6e\xb7\xf6\xb5\x01\xff\x8e\x22\x88\x47\x1c\x5d\x54\x02\x9f\x05\
\xe6\xda\xf7\xa7\xd0\xb8\x67\xdd\x2b\x39\x00\xcd\xc5\x69\xf6\xfd\
\x21\xe0\xee\xe0\xf7\x3c\xf0\x11\xe0\x74\xfc\xfc\x4f\x10\x0d\x7b\
\x0d\xf8\x25\x7e\x5e\x1f\x0c\xe6\x03\xb7\xa2\x40\x49\x59\xeb\xeb\
\x25\xe0\xfb\xc0\x6d\x68\x7e\x2f\x45\xf3\xaa\xdd\x7e\xbf\x1e\xb8\
\x18\xd8\x8c\xd6\x92\x9b\x8b\x35\x68\xce\xcf\xb1\xef\x4f\x00\x3f\
\x48\xf5\xc1\x4d\x68\x3e\x03\xac\x40\xeb\xc9\xf1\x8e\x05\xc0\x27\
\xad\x5e\xfb\xd0\x3c\xdf\x8d\xe8\xc3\x94\x54\x5f\xec\x46\x6b\xfc\
\x41\x4b\x3b\x08\xad\x83\x09\xf6\xde\xca\x8c\x76\xd7\xa0\xc8\x96\
\xb3\xcb\xb4\xbb\x11\x45\x7d\x7d\xdb\xc6\x60\x3e\x70\x21\x70\x3c\
\x5a\xdf\x2b\x80\x5f\x01\x6f\x12\xef\x0b\xed\xad\x38\x11\x8d\xd9\
\x6c\x34\x86\xcb\x81\x5f\xe0\xe9\x72\x25\x9a\xa3\xf3\x80\x6f\x01\
\xcf\x67\xe4\x51\x05\x7c\x0a\x38\x09\xd1\xe9\x47\x80\x33\xd0\x9a\
\xdc\x01\xfc\x3f\x7c\x40\xd4\x5a\xe0\x7f\xa2\x79\xf7\xaf\x68\xee\
\x7c\xd6\xf2\x77\xef\x3a\x4c\x42\xf2\xc9\x7c\x44\x03\x56\xa2\xf9\
\xb4\x8c\x8e\xf3\x69\x02\xf0\x3b\x48\xe6\x2a\x5a\x5d\x5f\x48\xd5\
\xd1\xcd\xe5\xff\x44\x3c\xa3\x2b\x54\xdb\x3b\x73\x90\x6c\x16\x06\
\x2c\x3c\x1e\xd1\xa4\xad\xc0\x3f\xa3\x35\x55\x01\x2c\x02\x2e\x00\
\xa6\x23\xbe\xf7\x26\xa2\x3f\xef\xd8\x7b\x75\xc0\xef\x01\x13\x29\
\xbf\xa6\xfe\x06\xd1\xab\x4a\xcb\xef\xfc\x4e\xf2\x8b\xe8\x1e\xe6\
\xa0\x79\x5c\x03\x34\x21\x3a\xbc\x2a\xf8\x7d\x0c\xa2\x9b\x23\xf0\
\xe3\x52\x44\x32\xfb\xb3\x88\x36\x37\x02\x27\xa0\xf9\x9a\xa0\x71\
\x5f\x1d\xe4\x91\x47\x72\xd8\xa9\x48\x7e\x79\x12\xf8\x5d\x34\xe7\
\xb3\xc6\x7a\x2d\x1a\xeb\xf1\x68\x4d\xa4\xd3\x35\x22\x19\xea\x17\
\xa9\x72\x86\xa2\x39\x76\x06\x8a\xbe\xbd\x13\xad\xcb\x47\x51\x00\
\x62\xd0\x7a\xfa\x14\x9a\xc3\x59\x65\x2f\x45\xb2\x5b\x7b\xea\xf9\
\x74\x24\x9f\x0d\x2c\xf3\xde\x0a\xeb\xbb\x89\x9d\xa4\x2b\x00\xff\
\x84\x6e\xbb\xf8\x5d\x6b\x5f\x56\x5e\x3f\x44\xba\xc6\x67\x10\xed\
\xc8\x4a\xd3\x8c\x78\xde\x9b\xf6\xdd\xad\x89\x73\xad\xae\x4d\x68\
\x2d\x3f\x8c\x97\x91\xdf\x0b\x5c\x6b\x9f\x13\x4a\xe5\xd3\x1c\xa2\
\x45\xff\x60\xfd\xe6\x78\xd6\x4c\xab\xf7\xdb\x88\x06\xbd\xce\x51\
\xe4\x59\xbf\x00\xc6\x1e\xad\xc2\x8e\x32\x8e\x07\xee\x40\x93\xb9\
\x1e\x2d\xa8\x26\x60\x0f\x9a\xfc\x83\x2d\xdd\x07\x51\x87\x3f\x84\
\x88\x7d\x67\x18\x8b\x26\xb0\x1b\xdc\x77\xd1\xc2\x0c\x31\x01\xb8\
\x13\x4d\xa0\x7a\x34\x19\xf7\x01\x0d\xc0\xd7\xd1\x22\x02\x4d\xe4\
\xbb\x2c\xdd\x6e\x24\xa4\x65\xa5\xeb\x4b\xa8\x41\x1b\x07\x67\xf4\
\x74\x45\xba\xc0\xa7\xf0\x63\xdc\x0c\x5c\x1a\xfc\x76\x2d\x22\x5e\
\x09\x22\xd4\x37\xa0\xc5\xed\x04\xe8\x7d\x68\xcc\xc3\xbf\xb5\xc0\
\x95\x41\x1f\xfc\x2e\x62\xb4\x4d\x88\x91\xef\x46\x4a\xe1\x53\x68\
\x63\x06\x14\xd5\xee\x15\xb4\x31\x73\x61\xaa\x7e\x8e\x11\xdc\x4d\
\x29\xe1\x1a\x85\x84\x0f\x57\xf7\xcd\x88\x20\x87\xb8\x10\x31\xf4\
\x04\x11\xd4\x6a\x7b\x9e\x03\xee\xb5\xe7\x9f\xb1\x67\x5f\x0f\xd2\
\x81\x84\x9c\x6f\xa2\x39\xba\xd7\xda\xb6\xc7\xfa\xe8\xa7\x68\xee\
\x83\x04\x14\x57\x87\x46\xc4\x34\x1c\x6e\xb4\x7e\x4b\xac\x1f\xdf\
\x77\x54\x47\xf6\xc0\xf1\x27\x48\xa0\xec\x6b\x98\x05\x6c\xc0\x8f\
\xd3\x32\x60\x5c\x99\xb4\xa7\xa1\x4d\x0e\x97\xf6\x11\xb4\x21\xe2\
\x50\x01\x7c\x8f\xd2\xf9\xbf\x19\x29\xc2\x05\x24\xc4\x9c\x7c\x08\
\x75\xbd\xd6\xf2\x69\x47\x74\x3c\xbd\xbe\xbe\x89\x04\xed\xdb\xd0\
\x7a\xd9\x05\x5c\x6e\xef\xce\x47\x02\x57\x82\xc6\xb2\x2a\xc8\x77\
\x2e\x5a\x87\xae\x5d\x2f\xa2\x75\x17\xe2\xab\xc1\xef\xeb\x11\x5f\
\x71\xf8\xe3\xe0\xb7\x5d\x56\xd6\x70\xe0\xd5\xe0\xd9\x26\x24\x20\
\xb4\xa3\xf5\xfe\x4f\x48\x18\x1f\x15\xa4\x3b\x8f\x6c\x0c\xb6\xbe\
\x4e\xf0\xbc\x24\xfc\x5b\x81\x68\xa9\xdb\x00\x5b\x8f\xd6\xe2\x56\
\x2b\xb3\x0d\x29\x2f\x57\xd1\x77\xae\x19\xaa\x45\x9b\x1c\x8b\x7b\
\xba\x22\x87\x88\x3c\x92\x3d\xde\x46\xf4\x78\x1b\x12\x0c\xdb\xd1\
\xe6\xd1\x7b\x83\xf6\x3e\x84\xe6\xc0\x87\xcb\xe4\x55\x17\xa4\xf9\
\x9f\xf6\xec\xe3\x78\x1e\xf5\xfb\x78\x0f\xc0\xc1\x68\xde\x15\x11\
\x5f\xab\x42\x72\x60\x82\xf8\x92\xc3\x05\x48\xb8\x6f\x45\xca\xf4\
\x36\xfb\xbc\x1e\x6d\x4a\xa5\x0d\x29\x1f\xc5\xd3\x75\xc7\x33\x42\
\xaf\xc3\x3a\x24\x2c\x27\xf8\x4d\xd2\xae\x30\x00\x29\xde\x09\xe2\
\x1b\x21\xce\xb3\x7e\x7b\x15\x29\x51\x79\xab\xd7\x66\xb4\xce\xb6\
\x20\x81\xbb\x0d\x6d\x2e\x9c\x6f\xef\x0d\x03\xde\xa0\x74\x7d\x86\
\x7f\x6f\xa1\xcd\x89\x3c\x92\x03\xb6\x64\xe4\xf7\x1a\xe5\xd7\xec\
\xb1\x82\xd1\x68\xe3\x63\xfc\x51\x2a\xef\xcf\xf0\x73\x23\x9c\xa7\
\x0e\xb3\x50\xff\x27\xa8\x9f\x1d\xdd\x6c\x45\x7c\xe4\xef\xd1\xdc\
\x9d\x8c\xd6\x4c\x02\x7c\x3e\x95\xc7\x78\x34\x36\x09\x9a\x0b\x0b\
\x11\x3d\x4c\x10\x4d\x4c\x8f\xf5\x83\x68\x7d\x2d\x2e\x93\x6e\x2f\
\x9a\xd3\x4f\x23\x45\x0d\xb4\xf9\xff\xdf\x48\xae\xd9\x13\xa4\x6b\
\x42\x9b\xb1\x63\x2c\xdd\x95\x68\xae\x14\xc8\xe6\x59\xdf\x42\xb2\
\x60\x1a\x67\x5a\x7e\xe5\xea\x7c\x07\x52\x7e\xcf\x44\xbc\x36\x2b\
\xdd\x7a\x64\xac\x1b\x8f\xe8\x7f\x82\xd6\x70\x3a\xaf\x4f\x22\xf9\
\xcf\xd1\x8e\x3d\x19\x69\x56\x22\xa5\x17\x2b\xf7\x4f\x6c\x5c\x1a\
\xad\x5d\xf5\x36\x46\xbf\xc4\x6f\xaa\xff\x4e\xf0\x7e\x3d\x5e\xd6\
\x73\xfd\xf0\x0c\xda\x28\xbe\x0e\xc9\xc6\x21\xcf\x6a\x45\xfc\xfa\
\x7d\x1c\x59\x9e\x35\x0e\xf8\x0e\x70\x1c\xf4\x5d\x45\x78\x28\x12\
\xcc\x9d\xb2\x70\x16\xb2\x66\xdc\x84\x3a\xbe\x1d\x09\x4d\x20\xab\
\x57\x11\xb8\x9f\xae\x15\xe1\x2b\xd1\xa0\x2d\x43\xbb\xfb\x05\xbc\
\xd2\xe0\xf0\x79\x7b\xfe\x08\x52\x6a\x26\x23\xa1\xcc\x09\x63\x1f\
\xb4\x74\xbf\x6d\xe9\x7e\x15\xa4\xbb\x22\x23\x5d\x5f\xc2\xb1\xa2\
\x08\xdf\x8a\xc6\xa0\x60\xff\xff\xdc\x9e\xe7\x80\xaf\xa0\xc5\xda\
\x8a\x18\xf1\x07\xec\xb9\xb3\xa6\x7d\x09\xed\xa4\xa7\xff\xea\x2c\
\x8f\x5b\x10\x01\x7b\x17\x79\x22\xcc\x40\x3b\x6c\x3f\xb2\xf7\x7f\
\x81\x98\xf5\x48\xa4\xd4\x36\xe0\x99\xb8\xc3\xa7\x2d\xed\x1d\x94\
\x12\x8b\xf7\x58\xfa\xe5\xf6\x6e\x01\x11\xa5\x10\x17\x20\xc6\xe2\
\x04\x01\x27\x70\xe5\xd0\xc6\x4c\x82\x04\x00\x90\xb5\x29\x41\xc2\
\x3b\xc0\xfb\xad\xcd\x4b\x11\x71\x9c\x64\xff\x5f\xb4\x74\xbf\x6f\
\xe9\x7e\x2b\xd5\x7f\xff\xcb\x9e\xe7\x2d\xaf\x56\xc4\x24\x9a\x80\
\x6b\x7a\x68\x8c\xbb\x8b\xbe\xaa\x08\xdf\x86\xc6\xe7\x69\xa4\x50\
\x35\x03\x57\x97\x49\xfb\xc7\x88\x46\x3e\x82\x94\xe7\xdd\x88\xa6\
\x3a\x54\x20\xe1\x20\x41\x02\xcf\x24\xc4\x60\x2e\x04\x1e\xb0\xe7\
\xf7\x50\xaa\x3c\xe7\x10\x3d\xa8\xa1\xeb\x63\x3a\xd7\xe0\x37\x8a\
\x66\xd3\x71\x6d\x8d\xb4\x74\x03\xf1\xeb\xf0\xd7\xc8\x0a\xf1\x7d\
\xfb\xfe\x2b\x3a\x2a\xb9\xce\x33\xe2\xd7\x88\xee\xee\xc7\xaf\x07\
\x87\x7f\xc1\x33\xf2\x16\xb4\xf1\x05\x12\xa0\x1e\xc0\xd3\x82\x6d\
\x48\xd9\x1f\x8e\x78\x43\x3b\xb2\x44\x4f\x42\x42\xd4\x97\xf0\xc2\
\xd3\x99\x41\xba\x36\xbc\xa0\x91\xc6\x20\x24\x60\xb4\xa3\x35\x99\
\x6e\xf7\x44\xeb\xbf\x51\x68\x0d\x36\x21\x65\x66\x06\xda\xa0\xfd\
\x7b\xab\xfb\xb3\x41\x1f\x1d\xeb\xe8\x2b\x8a\xf0\x85\x48\x30\xdc\
\x8d\x2c\x94\x27\xa0\x4d\xcb\x7f\x46\x6b\xed\x55\xb4\x86\xaa\x81\
\x9f\xd9\xb3\x72\x32\x41\x2d\x92\x5f\x12\x64\x55\x03\x59\xc6\x9c\
\x62\xba\x06\x79\x2f\x80\x94\x89\x97\xd1\x5c\xbe\x04\x29\xc2\x6e\
\x8d\xde\x6e\x69\x4e\x44\x0a\x45\x2b\xf0\x77\x68\x5e\xcf\x42\x74\
\xbc\x01\x09\xad\x21\x0f\xaf\x46\xd6\xa5\x82\xd5\xb5\x01\x59\x74\
\x26\x05\x69\x9c\xb2\x5e\xa0\xa3\x52\x5b\x0e\x03\x80\x9f\x5b\xdd\
\x6e\x48\xfd\x76\x0e\x5a\xaf\x2f\xa3\xf9\x3f\x19\x59\xad\xf6\xa2\
\xb5\x32\x15\xad\x7f\xe7\x31\xf5\x10\xa2\x0f\x43\xad\x6f\x9b\x2d\
\xcf\xf4\x9a\x9a\x60\x7d\x72\x1c\x52\x8a\xf7\x22\x79\xc0\xe5\xf7\
\x4d\xcb\xef\x41\xcb\xef\x58\xc5\xd1\x54\x84\x87\x23\x3e\xd3\x80\
\xe6\x47\x01\xd1\xb5\xc1\x41\x9a\x99\x88\xb7\xec\xc2\xcb\x16\xb3\
\x90\x8c\xb4\x0e\xcd\xd7\xcf\x22\x5e\xf1\xcf\x78\x9e\x52\x17\xe4\
\xe1\xe4\xf3\x77\xd0\x78\x2d\xb4\x32\xdf\x41\xf4\x22\x3d\xd6\x63\
\x11\x1f\x5a\x8c\x68\xf3\x4a\x24\x8b\xb9\xdf\x2f\xc2\x2b\xdd\x5f\
\xb4\x32\x3e\x88\x68\xf6\xf3\x88\x07\x4e\x42\x32\x95\xdb\xd4\xfc\
\x6d\x4b\x77\x85\xd5\xf9\x39\x34\x6f\xd2\x65\x8f\x22\x5b\xd1\x3b\
\x03\xd1\x84\x15\xc0\x29\x19\xef\x8d\xb6\xf7\xce\x44\x4a\xe6\x5b\
\x65\xd2\xd5\xd8\xff\x37\x2d\xdd\xe5\x19\x69\x06\xa1\x35\x76\x3f\
\xa2\x15\xbf\x45\x36\x8f\xa9\xb5\x7e\xff\x1c\xe2\x31\xef\x20\x5d\
\x6a\xba\xd5\xd7\xd1\x9e\x9f\xa0\x35\x31\x24\x78\xff\x56\xc4\xbf\
\x7e\x8d\xe8\xca\x24\xa4\x84\x8e\x46\x7c\xa9\x19\xd1\xbf\x19\x36\
\xde\x5f\xa1\xfc\xa6\xf4\xe1\xc4\x6f\x14\xe1\xbe\xec\x1a\x7d\x0e\
\x9a\x88\xeb\x80\x3f\x42\x3b\x80\x20\x86\x30\x12\x11\xc0\x01\x1c\
\xd8\x8e\x43\x05\x9a\x4c\x35\x68\x31\xef\x47\x0b\xed\x72\xe0\xdb\
\x68\x21\x81\x08\x4b\x1e\x11\xd0\x8d\x68\x07\x64\x03\x5a\xf4\xe7\
\xe2\x5d\x9e\x5d\x3a\xa7\x14\x6d\xb6\x74\x83\x2c\xdd\xbe\xae\x2a\
\x14\x71\xc4\xb1\x01\x11\x81\x33\xd1\x7c\xa9\x44\x3b\x6d\x6b\xec\
\x7b\x96\x05\x6d\x27\x1a\xcf\x2c\x0c\x43\x4c\x7a\x20\xf0\x7f\x90\
\x8b\x98\xc3\xff\x46\x04\x64\x17\x62\xd6\xa1\x6b\x7c\x31\x95\x4f\
\x31\x23\xef\x1c\x12\xe2\x07\x20\xa6\xbf\x19\x11\xf5\xcb\x91\x5b\
\x76\x43\xc6\x3b\xc3\x11\x11\x7a\x91\xee\xdd\x25\x3e\x16\x09\x3d\
\x8d\xd6\x46\xf7\xf7\x25\xa4\x44\xa5\xef\x23\x5c\x6f\x6d\x3d\xdb\
\xfa\x71\x80\xf5\xe5\x3b\xd6\xc6\xbe\x22\x9c\x1f\x6b\xa8\xc3\x5b\
\x4c\x7f\x80\x84\x90\xdf\x46\x34\xf3\x7e\x24\xa8\x38\x0c\x43\x96\
\xa3\x02\x9a\xaf\x57\x20\x26\x78\x19\x12\x6e\xd2\xee\x4b\xbb\xf1\
\xf3\x7f\x1d\x62\xc2\x0b\x91\x50\xb1\x18\xb9\x8f\x9d\x81\xac\x5b\
\x73\xd1\xbc\x5d\x61\xf5\x78\x94\xec\xb9\xed\xd0\x6c\x79\x36\x96\
\xf9\xbd\x01\xf8\x32\xb2\x60\x9f\x81\x94\xf3\xb9\x48\x70\xff\x2b\
\x4a\xe7\xf8\x00\xeb\x03\xb7\x89\x35\x1f\x6d\x6a\x5e\x8e\x84\xef\
\x74\x3d\x56\x22\x21\xf9\x4c\x24\x40\x1e\x87\xdc\xc9\x5e\x47\x42\
\x78\x1a\x6e\xa7\xde\xf5\xc5\xbf\xa3\x4d\xd7\xb9\xd6\xdf\x6f\x72\
\x60\xd8\x46\x79\xba\x32\x16\xd1\x22\x67\x7d\x78\x17\x09\x61\x5f\
\x46\x42\x5b\x42\xa9\x25\x3c\xa2\x67\x51\x8d\xac\x31\x63\x91\xc7\
\xc1\x3f\xe0\xd7\xdc\x5f\xa2\xb1\xac\x41\xf4\x79\xd3\x61\x28\x6f\
\x2a\xda\x20\xf9\x0c\xdd\x73\x37\xbc\x11\x29\xe5\xbf\x40\x9b\xc0\
\x7b\xed\xf9\xdf\xa3\x35\x70\xa2\xd5\xcd\x61\x06\xa2\xf1\xdb\xd1\
\xc6\xd1\x04\x7b\xff\x2c\xb4\xc1\x7b\x34\x30\xc4\xea\xd4\x8e\xb7\
\x46\xb5\xa2\x75\xbf\xcf\xda\x50\x8d\xd6\xb5\x3b\xae\xe0\xd6\x4a\
\x16\x86\x5a\x7e\x6d\x19\xf9\xed\x0d\xf2\x6b\x20\xa2\x2b\x9c\x82\
\x36\x53\x56\x21\x25\x76\x21\xe2\x05\x27\x21\x1e\x12\xa2\x88\x64\
\x17\x37\x2e\x6f\x23\x85\xe8\xff\x22\x23\xc2\x77\xd0\x26\xc4\xad\
\xc8\x80\x74\x3c\xda\xb4\xa9\x40\x7c\xaa\x06\xf1\x91\xf5\x78\xf9\
\xa2\x0d\xc9\x72\x5b\xbb\xa8\x67\x3b\x92\xd9\xb7\xd8\xf7\x77\x91\
\xc2\x3b\x13\xcd\x71\xd0\xda\xac\x44\xe3\x1e\xca\x40\x7f\x84\xe4\
\xaf\x9d\xa9\x3c\x9b\xad\x2e\x07\x72\xd4\x31\x87\xe6\xda\x06\xba\
\x96\xcb\x5a\x11\x4f\xdc\x59\x26\x1f\xd7\xa7\x1b\xc9\x9e\xeb\xa1\
\xf1\x6f\x3b\xe5\xd7\xc3\x38\xbc\x27\xc8\xdf\xa2\x8d\x2f\x90\xcb\
\xf8\x1f\x23\x99\x62\x0f\xd2\x73\xb6\xe0\x69\xc6\x76\xbc\x67\xe5\
\xbb\x41\x3f\x4c\x44\x3a\x50\xc1\xc6\x65\xa3\xa5\xf9\x1b\xfc\x1a\
\x3d\x2a\x3a\x6a\x5f\x56\x84\x4f\x45\x82\xf7\x32\x3a\x9e\xbd\xfa\
\x0f\x24\xf8\x34\x70\x60\x3e\xe8\x13\x90\x65\xae\x01\xb9\xf8\xec\
\x47\x16\xb0\xd3\x90\x95\xc2\x9d\x5f\x59\x86\x76\x4d\xae\x44\xc2\
\xd2\xd3\xf6\xf7\x2c\xa5\x4c\x61\x19\x1a\x78\x97\xee\x29\xe4\x32\
\x90\x4e\x17\xd1\x73\x78\x17\x29\xa6\xa7\x22\x57\x8e\x5a\xb4\x6b\
\xf5\x2b\x34\xe6\x59\xbb\xa9\x1f\x42\x84\x3f\xc4\x7a\x24\xec\x4c\
\x46\x3b\xff\x8d\xe8\xac\x7a\x08\xb7\xcb\xd6\x8a\xe6\xcf\x28\x7b\
\x5e\x61\xf9\x85\x9b\x36\x27\x66\x94\x3b\x1e\x29\x1b\x4d\x68\xb7\
\x75\x0b\x22\x8e\x4b\x10\xc3\x79\x36\x48\x9b\xb3\xdf\xf6\xa1\x4d\
\x97\x8f\xe0\xad\x47\x9d\xe1\x75\xa4\xe8\x9c\x8e\x14\xa6\xa7\xd0\
\xdc\x7e\x06\x29\x52\x69\xe5\xc1\x29\x2d\xf3\x11\xe1\x1b\x81\x18\
\xd7\x03\x88\x19\x8e\x22\xa2\x27\x30\x0b\x29\x8a\xdb\x91\x95\x77\
\x2d\xb2\x10\x5f\x80\xe6\xe8\xda\x20\xed\x02\xfb\x5b\x83\xe6\x6c\
\x0d\xda\x48\xbc\x14\x59\xf7\x77\xa4\xf2\x4e\x6f\x2e\xbe\x8d\x04\
\xa0\xb3\x90\x12\xb8\x09\xf8\x2f\x34\x5f\x5f\x47\x0a\xda\x87\xd1\
\xdc\xbd\x9e\xd2\x73\x80\x21\x8a\x68\xde\xff\x1b\xa5\x71\x1c\x8a\
\x48\xc9\x74\x67\x0e\x97\x23\x66\xfa\x8f\x48\xd8\x2a\x20\xab\xd0\
\x13\xa9\xfc\x66\xa3\x75\xbd\x19\x09\x4e\xdb\x90\x72\x72\x11\x9a\
\xab\x1b\x52\xe9\x97\x21\xe5\xf2\x4c\xc4\xec\x17\x20\x01\xed\x01\
\xa4\xd0\x64\x29\x9a\xe1\x7a\x18\x67\xef\x15\xf0\x1e\x19\xdd\x41\
\x82\x36\x4c\x7f\x0b\xbf\x79\xe1\xe0\x62\x54\xec\x46\x5e\x1a\x57\
\x20\x45\xe4\x16\xfc\xba\xfc\x3f\x48\x40\x89\xe8\x3d\x18\x85\xe8\
\x5f\x3b\x5a\x7f\xe1\xc6\x93\x9b\x87\xce\x95\xbe\xfa\x80\x73\xf7\
\xc8\x21\x1e\x56\x89\xdc\x10\xef\x43\xf3\xb5\x1c\xdc\x86\xc9\x69\
\xf6\xfd\x49\xbc\x40\x0b\x9a\xff\xff\xcb\xf2\x0d\x15\xc0\xf3\xd1\
\x7a\xfe\x39\xe2\x09\x4f\x58\xfb\xae\x40\xc7\xc4\xda\x38\xb2\xc8\
\xa1\x75\xfc\x36\x32\x82\xfc\x07\x9a\xff\x4e\xa6\xfa\x93\xa0\xbe\
\xc3\x82\x76\xfe\x01\xe2\xd7\x21\x5e\x41\x9b\x13\xce\x2d\xf4\x2c\
\xe4\xc6\x5a\x2e\xbf\x88\xce\x91\x47\x9b\xa6\x03\x91\x55\xf0\x29\
\x44\xab\xaf\x46\x3c\xe4\x19\x3a\xd2\xc2\x34\x0f\x71\x31\x7d\xa6\
\x23\xfe\xf4\x02\xda\x48\x5c\x80\xe4\x97\xd7\x90\x7c\x7e\x11\x9a\
\xa3\xce\xc2\x89\xe5\x3d\x0e\xc9\x37\xe9\x31\xbb\x03\xcd\xd9\xb0\
\xdc\x3a\xfc\x59\xe1\x69\x78\x59\xcb\xc5\x68\x79\x0d\xad\x89\xf3\
\xd0\x5a\xfa\xb5\xd5\xef\x19\xbc\x65\xd4\xa1\x88\x78\xed\xbf\x50\
\xca\xb3\x12\xb4\xa9\xfc\x5c\x99\x3e\x2b\x22\x1e\xf4\x0f\x74\xdc\
\xf4\xfd\x11\x92\x3f\x5d\x3e\xce\x70\xb6\x2b\x48\xb3\x1e\xf1\x6b\
\x57\x97\x4a\xb4\xa6\x87\x05\x69\x76\xe0\x0d\x84\xae\xed\x9f\x46\
\xb1\x34\x42\xac\x40\x9b\x17\x33\xec\x6f\x37\xa2\x0b\x21\x96\x21\
\xfa\xd2\x8c\x8f\x9f\x91\x1e\xcb\xf4\xf9\xe3\x3d\x68\xad\x5d\x83\
\xe4\x88\x1b\xf1\x7a\xd2\x5f\xe3\xcf\x5a\x1f\x71\xf4\x65\x45\xd8\
\x9d\x55\xdc\x4b\x29\x93\x81\xec\xc1\xea\x0e\xce\x42\x42\xfc\x52\
\x34\xf0\xad\x68\x20\x2f\x40\x2e\xa9\x4e\x80\xbb\x1f\xed\xc4\xdf\
\x86\x17\x22\x3f\x8b\x84\xcb\x1f\x22\x57\xa3\x9d\xc8\xaa\x9c\x4e\
\xf7\xb9\x20\xdd\xdf\x52\x3a\xb9\x23\x8e\x3e\x9a\xd1\x8e\xe0\x7b\
\x91\x50\x5d\x8d\x76\x89\x5f\xc0\x9f\x19\x49\x63\x1e\x22\xd8\x21\
\x5e\x45\xc4\x70\x18\x62\x08\xed\x74\xdc\x21\x2c\x52\x2a\xb0\x3a\
\xa2\x51\x83\xe6\x42\x92\xf1\x5b\x88\xd3\x91\x92\xfd\x06\x9a\x97\
\xfb\xd0\x9c\xbc\x14\x31\xa2\x50\x11\xce\xa3\x1d\xb8\x6f\xa1\x9d\
\xd6\xdf\x42\xc4\xb5\x33\x6b\x1c\x88\x50\xfd\x29\x72\xbf\x3b\xd1\
\xfe\x3e\x89\x84\x86\xbb\x2d\xaf\x70\x47\xb1\xd1\xfa\xea\x62\xa4\
\xcc\x8f\x42\xca\xc0\x0b\x1c\xda\x99\xd1\x88\x43\xc3\x45\xe8\x2c\
\xd3\xcf\xd0\x06\xcc\x6e\xfb\x7f\x22\x62\xf0\x6b\x2d\x5d\x0e\xcd\
\x9d\x41\x88\xf9\x6d\x44\x8c\x7f\x23\x9a\xe7\x4b\xd0\xee\x7c\x67\
\x68\x41\x02\x3d\x68\x87\xfe\x64\xb4\x76\x9e\x42\xae\x98\x5b\xd1\
\xfc\xa8\xa2\xf3\x1d\xfb\x04\xcd\x9f\x4b\x29\x5d\x0b\x05\x4a\x85\
\xfb\x04\x09\xfc\x9f\x43\x1b\x30\x5b\xd1\x31\x99\x74\x50\x92\x4b\
\x2c\xbf\x3b\xd1\xae\x76\x03\x52\xd8\x8f\x47\xd6\xad\x1f\xa4\xd2\
\xef\x44\x6e\x98\xd7\x21\x57\xb7\x33\xf1\xc7\x64\xae\xca\xa8\x6f\
\x1e\x29\xf6\x0b\xd0\x9c\xbf\x0a\x6d\xa6\x2d\x43\xf3\xff\x40\x6e\
\x6d\xc8\x21\xef\x8e\xb9\xa9\xe7\x83\x90\xab\xe6\x3e\xb4\x2e\x6b\
\xac\xee\x57\xda\x5f\x83\x95\xf5\x65\xbc\x8b\x69\x44\xcf\x63\x20\
\x5a\x0b\x59\x7c\x00\x4a\x95\xcf\x43\xc5\xab\x88\x0f\x7c\x09\x79\
\xff\x2c\xa7\x73\x3a\x5f\x85\xf7\x74\xca\xaa\x47\xba\xbe\x75\x48\
\xe1\xcd\xa1\x0d\xd8\x7d\xf6\xff\x53\xf8\x80\x3a\x2b\x8e\x5c\x57\
\x02\x3e\xa8\xe5\x97\xd0\xc6\xcf\xa9\xe8\x8c\xe1\xfb\xac\x0d\x4f\
\x23\xe1\xfa\xf1\xe0\x9d\x3c\xe2\x99\xe9\xe0\xa8\x15\x96\xdf\x0e\
\xcb\xef\xaf\x10\x9d\x0b\xf3\x7b\xca\xf2\x7b\x82\x88\xae\x30\x1a\
\xd1\xda\x16\xe4\x61\xb0\xdf\xfe\x5f\x89\x78\xcb\x3f\xd3\x71\x33\
\x35\x0d\x17\x6b\x62\x20\x92\xa1\x5c\xc0\xb2\x85\x48\xf6\xfe\x26\
\x1a\xf3\x19\x68\x7e\x3f\x13\xbc\xeb\x94\xc5\x8b\xe8\x38\xef\x5f\
\x09\x3e\x17\x11\x7d\xfe\x09\x3e\xb8\xe8\x58\xa4\x78\xff\xc2\x9e\
\x83\xe6\xd0\x5f\xa0\x23\x90\x73\xec\xef\x53\x48\xee\xb9\x13\xc9\
\x40\x5b\x82\xb2\x47\xd0\x91\x67\x15\x29\x55\xc0\xd3\x48\x90\x87\
\xc3\xc5\x19\x75\x7e\x2e\x95\x6e\x2a\x3e\x90\xa9\xc3\xff\x45\x9b\
\x35\x2e\xcd\x60\xfc\x31\x37\x87\xbb\xf1\x47\x2d\xdc\xf3\x53\xd0\
\x06\x71\x88\xe1\xf6\xee\x48\xb4\x41\xb0\x9f\x8e\x1b\x0a\x45\x0e\
\x5c\x71\xdd\x8f\xbc\x4d\xea\x10\x9d\xb8\xc2\xfe\x1a\x10\xbd\xfa\
\x0a\x92\x2d\xba\x92\x49\x0f\x19\x7d\x59\x11\x76\xca\x6f\x96\xb0\
\xe1\xdc\x62\x0e\x04\x55\x68\x37\xbe\x0a\x09\x84\x4d\x96\xc7\x13\
\xe8\xac\xcf\x65\x68\xb2\xec\x41\x03\xf9\xe7\xe8\xfc\x82\x8b\xae\
\xbb\x00\x09\x58\x7f\x60\xbf\xff\x5f\xfb\xff\x67\x68\x42\x66\xa5\
\xdb\x8f\x88\xed\x11\x9f\x08\x11\x9d\x62\x29\x3e\x60\x95\x73\xff\
\x58\x4a\xf9\x73\x4e\x7f\x83\x5c\x32\x43\xb4\xe2\x03\x20\x84\x11\
\xf4\xd2\xc8\x9a\x9b\xad\x74\x8c\x1a\x7d\x2e\xb2\xfa\x38\x54\xa2\
\xf9\x59\x8d\x98\xb4\xb3\x38\x3d\x8e\x88\xf0\x7b\x50\xe4\xd0\x5d\
\xa9\xb2\x7e\x8a\x36\x78\xae\x47\xae\x73\x83\xba\xe8\x8b\x36\xc4\
\xb8\x7e\x89\xac\x00\x67\x22\xe2\x79\x02\x52\x3c\x8a\x94\x06\x5c\
\x01\x29\x0f\x45\x44\xd4\x47\x21\xa5\xcb\x05\x6b\x89\x38\xfa\x18\
\x8c\xe8\x55\x0e\xcd\x8f\x1c\x9a\xd3\xcf\x20\xe5\xf6\x72\xb4\x11\
\xd7\x82\x17\x62\xda\x2c\x6d\x0d\xb2\xbc\xbc\x84\x84\xc2\xcb\x91\
\x90\xd0\x19\x72\x78\x3a\x5c\x40\x42\xcc\x6a\x64\x91\xbe\x0b\x59\
\x35\x5f\x44\xca\xec\xe6\x4e\xf2\xa9\x40\x9b\x52\x9f\xa4\xa3\x30\
\x9e\x76\x0b\xbb\x0c\x1f\xd4\x6a\x0c\x3a\xdb\xfe\x06\x5e\x19\x1e\
\x86\xd6\x45\xd1\xda\x55\x81\xe6\xe5\xb3\x68\x33\xe0\x72\x64\x2d\
\x08\x85\xe4\x36\xcb\xe3\xa3\xf6\xfb\xe9\xc8\x6a\x9c\x25\xe4\x3b\
\x2b\xee\xe7\xf1\x6b\x7e\x0f\xda\x6c\xfa\x2b\xb4\x63\xdf\x5d\x6f\
\x88\x9c\xf5\xdb\x1f\xd2\xd1\x9a\xd7\x8c\xdf\x64\x78\x09\xc5\x2b\
\x38\x17\x59\xc5\x4e\xb5\xf1\x3c\x1f\x59\xeb\xde\x87\xce\x93\x45\
\xf4\x3c\x8a\x78\xf7\xbf\xc3\x25\xa3\x74\x56\xd6\x37\xd1\x3a\x3e\
\x0d\x09\xed\x9d\xc9\x7e\x2e\xb6\x03\xdd\xac\xdb\x1c\x34\xd7\x76\
\x22\x1a\x52\x8b\xd6\xf4\x2a\x24\x54\x9f\xc7\xe1\x51\x84\xbb\xd3\
\x1f\x4f\xa2\xc0\x7a\xe7\xa1\x0d\xa1\xd3\xac\x7e\x97\x21\xa5\xe6\
\x1a\xfc\x66\x73\x2b\xe2\x59\x69\xd7\xdc\xa6\xa0\xac\xc7\xd1\xba\
\x39\x0f\xbf\xa6\xe6\xa0\x8d\xf1\x31\x56\xd6\x06\x22\x3a\xc3\x69\
\x48\x3e\x58\x83\xac\xa9\xb5\x88\x8e\x6f\x47\x1b\x7b\x8b\xd1\x51\
\xae\xce\x90\xc7\xd3\x41\x37\x37\x7f\x81\xc6\x6f\x09\x9a\x67\x17\
\xe3\x03\x3f\x6d\x4b\xbd\xbb\x0e\xc9\x6b\xe9\x8d\xd6\x2c\x4f\x99\
\x22\xa2\xcd\xb3\xd0\x5c\xf8\x3b\x24\x7f\xb9\x23\x0a\x2d\xf6\xec\
\x41\x4a\x65\xa0\x59\x28\x1e\x4b\x2b\x3a\x4f\x9c\x20\xbe\xb2\x14\
\x05\xae\x4b\x6f\x2a\x75\x66\xe4\xca\x23\x1e\x79\x33\x1d\x8f\x9b\
\xd5\x07\x9f\x9d\x27\xc4\x3f\xa6\xf2\x7f\x39\x95\xa6\x11\x59\x5d\
\xd7\x05\xcf\xd7\x20\x7e\x58\x89\x5f\xd3\x7f\x8c\xf4\x96\x10\x2d\
\xf8\x40\x62\x09\xd9\x91\xa5\xe1\xe0\x68\xd6\x2b\xc8\xbb\x2c\xcd\
\xb3\xce\x45\xc6\xcc\xb5\x88\x96\x1c\x51\xf4\x65\x45\xd8\x85\x65\
\x9f\x8c\x7c\xe0\x43\xc1\xe9\x02\x34\x81\x7f\x46\x69\x78\xff\xce\
\x30\x0d\x0d\x14\xc8\x22\x70\xa6\x7d\x76\xc2\xcc\x02\x64\x7d\x78\
\x0a\x09\x52\x33\x10\x53\xf8\x27\x74\x45\xc1\x44\xb4\x48\xfe\x07\
\xda\x99\x72\xcf\x66\x20\x42\x1c\xa6\xbb\xdd\xfe\x2e\xc6\x5f\x0b\
\x10\xd1\x73\x78\x1b\x11\x10\xa7\x3c\xac\x41\x8c\xbd\x9c\xbb\xe1\
\x2e\xca\x9f\xb3\xd8\x8a\x08\x99\xdb\x69\x7c\x35\xf8\x6d\x38\x1a\
\xf7\x95\x68\x6e\x3a\xa2\xd2\x8e\x36\x4b\x42\x77\x94\x02\x5e\x11\
\x4e\xd0\x4e\xa6\x8b\x62\x79\x15\xb2\x1e\x81\x76\x23\x41\xc4\x65\
\x11\x52\x60\x1d\x9c\x02\xf4\x37\x68\x3e\x5f\x4f\xe9\x35\x4b\x69\
\xe4\x90\x72\x71\x22\xb2\x6a\x7d\x0d\x09\x58\x63\x91\x72\xf0\xa7\
\x68\x6d\x8d\xa0\xd4\x2d\x69\x05\x12\x16\xae\x44\x34\xe7\x1d\x6b\
\xe3\x1e\xfa\x4e\x24\xdb\x63\x09\x6e\x2e\x80\x84\xe2\xeb\xed\xb3\
\xf3\xa2\x39\x13\xd1\xa5\x37\x90\x10\x73\x22\x1a\xb7\x3f\x40\x9e\
\x2d\x60\x91\x16\xd1\xe6\xd0\x78\x3a\x3f\xc7\xe8\xce\xee\x25\x68\
\x1e\xbc\x86\x5c\xa1\x3f\x64\x65\x9d\x81\xd6\xd6\xa7\xd0\x51\x93\
\x6f\x77\x92\x57\xfa\x9c\x51\x16\xe6\x22\x41\xa4\x0e\xad\x2f\x77\
\xdd\xc6\xe3\xf8\xab\x61\xe6\x23\x6b\x82\x0b\x00\x72\xb3\x3d\x77\
\xc1\x7d\xce\x41\x3b\xed\xe1\xe6\x53\x11\x09\x35\x7b\xd1\x4e\xfa\
\x38\xa4\xc8\xaf\x47\x82\x46\x18\xe5\xdf\x09\x6d\xbf\x8b\xbf\x65\
\x60\xaf\xb5\xbf\xfe\x20\xc7\xad\xb3\xf3\x5b\xce\xd2\xde\x86\x22\
\xbf\xdf\x6b\xfd\xbe\x18\x6d\x80\xcd\x41\x02\x63\x54\x84\x7b\x07\
\x5c\xfc\x10\xc7\x07\x42\xd4\x20\x3e\x50\x8f\x84\xd2\xfa\x43\x2c\
\x2b\x8f\xe6\x9d\xdb\xa0\xfd\x38\x5a\xcf\xe5\xe2\x4c\xb4\x22\x1e\
\xb7\x18\xad\xf3\xb4\x80\xfb\x71\x44\xe3\xef\x46\xb4\xfc\x12\xb4\
\x61\xd6\x82\x64\x98\x56\x2b\x73\x0a\x52\x04\xae\xa0\xf3\x35\xdd\
\x19\xda\xf1\x9b\x51\xe9\xa3\x07\xb5\xf8\x78\x15\x6e\xd3\xee\x64\
\x64\x60\xb8\xc3\xfe\x86\xa1\x8d\xde\x7f\x41\x74\xe1\x64\xfc\xe6\
\x5f\xfa\x0c\x7f\x1a\x63\xd0\x91\xa2\x74\x7e\x67\x5b\x7e\xf3\xec\
\xf7\xa8\x08\x97\x87\x1b\xff\x5a\x24\xdb\x7e\x1f\xcd\xbb\x2a\x44\
\x9f\xea\xd0\xa6\xc2\xcf\xbb\xc8\x67\x9c\xbd\xb3\x05\xaf\x18\xbe\
\x8c\xe8\xfb\xe9\x88\x1e\x9f\x8b\x64\x8a\x07\xe9\xa8\x90\xb9\x73\
\xde\x9d\x6d\xb4\xe6\x11\x2d\xbf\xc1\xde\xff\x3f\xe8\xa8\xda\xd9\
\xe8\x5c\xf2\x26\x4b\x33\x13\x29\xbd\x2f\x23\xe3\xd7\xd7\x11\x0f\
\xbc\x15\x9d\x13\xbe\x10\xf1\x02\x57\x07\xc7\xb3\x0e\xc4\xcb\x23\
\x67\x75\xde\x48\xe7\x5e\x52\xce\x13\xe2\x3f\xe9\xfc\x8c\x70\x0b\
\x72\xa9\xee\xea\x9a\xca\xce\xe2\xdb\xb8\xdb\x6f\x06\xa2\xb1\x5c\
\x93\x1a\x9f\xdf\x46\x8a\xed\x83\x74\xef\xd8\xc0\x08\xb4\x1e\x8b\
\xc8\x83\xeb\x3e\xb4\x49\xbf\x08\xf1\xac\x79\x48\xfe\x38\xe2\x8a\
\xf0\x81\xb8\x66\x1d\x6b\x78\x04\x2d\x9a\x05\x68\xa1\xb9\x09\x31\
\x1c\x09\x3e\xff\x1b\x4d\xdc\xb0\x0f\x8a\x94\x3f\xcb\x72\x1e\x62\
\x58\x3b\x10\xe1\x6b\xb7\xbf\xcd\x68\xb2\x0e\x41\x56\x82\x01\xf8\
\x83\xe4\x9f\x40\x0c\xa7\x1d\x29\x52\xee\x5e\xac\x36\x44\x00\x5c\
\xba\x4f\x22\x82\x91\x95\x2e\x5a\xcd\x7a\x16\x8d\xf8\x31\x19\x8f\
\x16\xfc\x4b\xc8\x7a\x54\x28\xf3\x4e\x67\xbb\x62\xeb\xf1\x96\xb5\
\x0f\x52\x7a\x66\xe3\x32\xa4\x6c\x7c\x05\xcd\xb5\x70\xec\x2b\x52\
\xf9\xa4\xbf\x9f\x8d\x04\xf7\x5d\x56\x86\x9b\x9f\x8e\xd1\x0f\xc6\
\x07\x06\x4a\x52\xf9\xbc\x88\xce\x50\xd6\x52\x1a\x00\x25\x8d\x4a\
\xe4\x2a\xf6\x63\x74\xf5\x41\x8d\xf5\xc1\x26\x44\x60\x5d\x99\x61\
\xbf\x34\xa0\x5d\xbd\x37\x90\xa2\x35\xc6\xca\xab\xef\xa4\xff\x22\
\x8e\x1c\x72\xc8\x3b\x60\x38\x9a\x17\x5b\xf1\xe3\xe6\x02\x6e\xb8\
\xb3\x56\x61\xf0\xb5\xb5\x68\x6e\xb9\xb4\x6b\x90\xd0\xe1\x82\xe4\
\x84\x73\x35\x3d\xae\xe7\x20\xe1\xe1\x5d\xe4\xd6\x35\x17\xed\xa0\
\x3f\x61\x75\xb9\x08\x09\xca\x63\x90\xd0\xd4\xd5\x06\x6d\x67\xf3\
\x66\x10\x52\x82\x4f\x40\x56\x87\x8f\x21\x21\x6b\x34\x3a\xdb\xe8\
\x36\x2e\x2f\x45\xc2\xca\xbb\xf8\xab\x8d\xc2\x3e\x98\x48\xc7\x2b\
\xcb\xf6\xe2\x37\xc5\x66\x58\xbf\x3c\x8f\xb7\x20\xa5\x37\x75\x12\
\xa4\x04\xbb\x73\x71\xaf\x51\x5e\xa9\x69\xa7\x6b\x74\xc6\x0b\xce\
\x41\x82\xfa\xd7\xf0\xae\x6d\x7b\x91\x60\xb2\x03\xcf\x4f\x22\x7a\
\x07\x76\xa1\x79\xe9\xae\xbd\x9a\x10\xfc\x76\x26\xda\x10\xfa\x3b\
\xa4\x68\x85\xf3\xfd\x60\x69\x66\x1e\x79\x13\xfc\x04\xf1\x9c\x41\
\x94\xe7\x53\xee\xa8\x41\x2b\x5a\x8f\xe1\x11\x96\x13\x11\xed\xff\
\x32\x5a\x1f\x83\xf0\x6e\x9f\xef\x20\x7e\xe9\x94\xd7\x15\x48\x00\
\x3f\x1d\xcd\xc9\xb0\xee\xdd\x99\xef\xe0\xaf\x6b\x02\x09\xc5\xa1\
\x32\x3c\xc7\xbe\xef\x44\x7c\xe6\x32\xe4\x9a\xfa\x4f\x48\x09\x07\
\xad\xb7\x97\xf0\x9b\xd6\xe9\x35\xd0\xd9\x9a\x7a\x2f\xda\xe8\xfa\
\x47\xfc\x66\x45\x3a\xbf\xee\xb6\xa3\xbf\x62\x12\x32\x3a\xb9\x6b\
\xdc\x5a\xf1\x67\xdf\xdf\x46\x73\xe2\x62\x24\x5b\x85\x63\x11\xf6\
\x6b\x1d\xda\x44\xaf\x46\x1e\x3b\x4e\x99\xad\x47\xb1\x7a\x72\x48\
\x86\x3e\x01\xc9\x16\xe5\x94\xbd\xee\xac\x9d\x04\x1f\x7c\xea\x4b\
\x96\xdf\x39\xc8\x8b\x67\x28\x9a\x6f\x7f\x8e\x64\xa0\xdf\xb6\x3a\
\x15\x10\x1f\x59\x86\xbf\xe2\xcf\xb5\x25\x77\x00\x65\x67\xd5\xa5\
\xbb\xef\x75\x27\x10\x62\x77\x0c\x9f\x9d\xad\x87\xb7\x91\x71\x6f\
\x08\x92\x5d\x5d\xc4\xf4\x3c\xf2\x8c\xf8\xa2\xf5\xd3\x18\xba\x87\
\x33\x91\x47\xe2\xd7\xf0\x57\x7c\xee\x43\x3c\xcb\x6d\x76\x1c\x15\
\x9e\xd5\x97\x2d\xc2\xaf\xa0\x1d\xd0\x3f\x47\x84\xd1\xb9\xb1\x5d\
\x88\x14\x82\xf5\x68\x97\xc7\x4d\xb4\x04\x59\x7d\x3f\x4f\xa9\x3b\
\x5c\x01\x29\x2e\xef\x45\x4a\xc3\xb7\x90\x12\x1d\xba\xb7\xfe\x0e\
\x62\x0c\x97\x22\xa2\xf9\x90\x95\xf3\x87\x68\x47\xf5\x4d\x44\x10\
\x6e\xb2\xfc\xee\x45\x03\xfd\x4b\x4b\xf7\xc5\x8c\x74\xed\x96\xae\
\x5c\x74\xd4\x88\xa3\x83\x04\x31\xf3\x97\x90\xe5\xac\x88\xbf\xdb\
\xb7\x9c\x8b\xc8\x05\x74\x54\x54\x41\xde\x07\xcf\x23\x01\x67\x1e\
\x72\x63\x1c\x84\x02\x10\x8d\x47\xc4\xa5\x0a\xdd\xc7\xfa\x36\x22\
\x38\xb9\x32\xe5\x84\xdf\x6b\xf1\x0a\xc4\x77\xd1\x7c\x0a\x09\xda\
\x67\x51\xa0\x88\x4b\x90\x05\x22\x2d\x00\x39\xd7\xb9\x4b\xe9\xfc\
\x5a\xab\x36\x24\xbc\xbd\x1f\x59\xef\x86\x59\x5f\x8c\xb4\xb6\xd4\
\x21\x4b\xf6\x6e\xfc\x06\x93\x8b\x16\xf8\x32\x0a\x8e\x51\xb0\x77\
\xda\x88\xd6\xe0\x9e\x40\x78\x5e\xe9\xef\xd0\x8e\xb6\x43\x0e\xd1\
\xb1\xdb\x11\xbd\xfb\x15\x9a\xcb\xed\xc8\x65\xea\xa7\x41\xda\x6a\
\xb4\x13\x7e\x0b\x12\x52\xee\x0e\x7e\x3b\x0f\xef\xf6\x39\x05\xcd\
\x8d\x6a\xb4\xd9\xb2\xc2\xbe\x7f\x05\x31\xbd\x7f\x47\x96\xce\x19\
\x56\xa7\xb7\xe8\x7c\x83\x69\x32\xda\xc8\x4c\xc7\x78\xd8\x81\x76\
\x94\x6f\x40\xeb\x74\x0f\x3a\x56\xf2\x0a\x3a\x86\xb2\xc8\xda\xf2\
\x69\xbc\x9b\x68\x62\xbf\xfd\x7b\x90\x4f\x05\xda\xa0\xfc\x1c\xf2\
\xac\xf8\xaf\x54\xf9\xbb\xd1\xa6\xd8\x7c\x44\x9b\x3b\xdb\x61\x2f\
\xe7\xf6\x9a\x95\xe6\x03\xc8\x42\x1d\x62\x25\xfe\x5c\x7f\xde\xfa\
\x79\x52\x46\x1e\x8f\x21\x81\xed\x6d\xa4\x2c\x7c\x0b\xcf\x3b\x2e\
\x40\x16\xb1\x57\x28\x8d\x11\x10\xd1\xb3\x28\xa0\xf5\x73\x2a\x92\
\x01\xbe\x8f\x94\xcf\x41\xc8\x3b\x61\x14\xe2\x03\xcf\xe3\x79\x89\
\x3b\xaf\x9f\x8e\xb4\xbf\x19\x7f\x3f\x6f\x39\xe4\xd0\x9a\xf9\x07\
\x64\x39\x9b\x41\xe7\xb8\x1b\x29\x00\x1f\x43\x72\xd2\x4f\x11\xcf\
\x7b\x3f\xda\xc8\x7a\x12\xc5\x42\x59\x80\x36\xb5\xb6\xa3\x8d\xff\
\xa5\x41\x1e\xa3\xd0\x3c\x3c\x05\xd1\x1c\x17\x98\x27\x87\xf8\x55\
\xfa\xc6\x85\x4d\x88\x7f\xa4\x85\xdf\xfb\x90\x4c\xf4\x09\x24\x7c\
\xbf\x8a\xd6\xc1\x87\xac\x4d\xf7\x21\x1a\xf5\x1c\x92\xf1\x4e\x45\
\x96\x6f\x77\x55\xd3\xc5\x68\x43\xe1\x49\xab\x5f\xde\xfa\xaa\x12\
\xd1\x8a\x74\xac\x0a\x77\xb5\xcf\x33\x96\xdf\x69\x68\xa3\xce\xe5\
\x77\x09\xe2\xdf\x4f\xa4\xda\x1b\xd1\x11\xe7\xa0\x33\xe2\x6f\xa3\
\xb9\x13\x7a\x0e\x9d\x80\xe6\xd0\x4c\xb4\x99\xea\xbc\x33\x6b\xd1\
\xbc\xdb\x8a\xf8\xc6\x62\xfc\x7d\xb3\x5f\xc5\x7b\xad\x25\x48\x1e\
\xf9\x6d\xc4\xd7\x0a\x68\x2e\x64\x79\x50\x8e\x40\xb1\x78\xea\x53\
\xcf\xf7\xa3\xb9\x9e\xb5\x76\xd6\x02\xff\x1f\x9a\x4b\x57\xa2\xf9\
\xf6\x6f\x56\xe6\x55\x28\xae\xca\x68\xc4\x03\xc6\x20\xde\x53\x65\
\x75\xd8\x8b\xe6\x99\x0b\x7a\xf5\x59\xfc\x11\x16\x87\x5d\xc8\xe3\
\x23\x4b\xc6\x4f\xd0\x3a\xbf\x8d\x8e\x96\xe4\x46\xfc\xd5\xb0\xd0\
\xb5\x1c\x95\xeb\x46\x1a\x97\xee\xbd\x64\x5f\x59\xf4\x24\x5a\x77\
\x5f\xc6\x5f\x69\x35\x12\x79\xb3\x4e\x47\x72\x40\xbb\xf5\xd5\xfa\
\x32\x79\xa7\xf1\x0a\xe2\xf7\x67\x21\x8b\xf6\x3d\x68\x43\xeb\x3c\
\xfb\x5b\x86\x36\x90\x8f\x0a\xfa\xea\x3d\xc2\xe0\x17\xd4\xd3\x68\
\x01\xb8\x4b\xeb\x1f\x42\x84\xd9\x0d\xce\x0d\x68\xb2\x35\xe3\xef\
\x84\x74\x7f\x7b\x90\x95\x6e\x25\x9a\xb8\x97\x66\x94\x73\x0a\x3e\
\xba\xf0\xe5\x88\x99\xfd\x1e\x1a\xe8\x3d\x41\x3e\x4b\x2d\x2f\x77\
\x77\xda\xe0\x4e\xd2\xfd\x3e\x5d\x9f\xd7\x3c\x16\x71\xac\xdc\x23\
\xfc\x71\x44\xb8\x5c\x80\x84\x4b\x90\x10\xbc\x15\x6d\xaa\xb8\xbb\
\x1d\xf7\x23\x22\x9d\x43\x02\x68\x13\x9a\x67\xad\x19\x7f\x7f\x1a\
\xe4\xbf\x00\x31\xd7\x0d\x68\xde\xed\x47\x02\xf6\xff\xc6\x5b\x65\
\x47\x21\x42\xe0\xee\xd5\x0b\x71\xab\x95\xf5\x3d\xb4\x4b\xbf\x12\
\xcd\xf1\x2b\x33\xda\x72\x12\x22\xea\xf5\x88\x80\x9f\x65\x6d\x79\
\x91\x52\x77\xce\x6b\x91\x40\xd3\x84\x08\x1d\x68\x13\xc9\x9d\x93\
\x01\x8d\xdf\xad\x48\x48\xd8\x65\xed\xda\x87\x84\x9c\xbf\xc2\x5b\
\xdc\x3e\x63\xef\x7d\xd7\xbe\x5f\x69\xe5\x6f\x42\xeb\xa5\x0e\xd1\
\x9e\xbd\x65\xea\xdc\x9b\xd0\x97\xee\x11\x3e\x1f\xef\x62\xbb\x30\
\xe3\xf7\xcb\xd0\xb8\xae\x45\x4a\xe2\x1e\xb4\x41\x37\x2d\x23\xed\
\x87\xd0\xbc\x7d\x0b\xcd\xc1\x6f\xd0\x71\xfe\xef\x45\x0c\xed\x0f\
\xf0\x77\x08\x0f\x00\xbe\x80\x82\x9a\x34\xe0\xaf\x97\xf8\x57\xb2\
\xaf\x23\x03\xcd\xdb\x7a\xb2\x69\x74\x2b\x52\x18\xce\x41\x1b\x2e\
\x4d\x68\xde\xd6\xd8\xbb\x79\x64\x0d\xde\x87\xac\x56\xff\x1b\x29\
\xce\x6b\xf1\x3b\xd1\xe9\xb2\xf6\x58\x9d\x4e\x42\x73\xbf\x09\x59\
\x08\x40\x1b\x9f\x4d\x88\x4e\x8f\x47\xca\xf9\x72\xeb\xd3\x93\xd0\
\x06\xd1\x33\x56\xde\xd9\x9d\x8c\xc5\x48\xa4\x9c\x96\xa3\x19\xdf\
\xb5\xbc\x7e\x46\xe7\x74\xe5\x36\xcb\xcf\xdd\x45\xbe\x1e\x1f\x10\
\x72\x23\x12\xf4\x7a\x3b\xbd\x3d\x10\xf4\x95\x7b\x84\x41\x42\xe4\
\x3f\xa3\xf3\x80\x4d\x48\xc8\x7d\x07\x7f\x4d\x11\x68\x1e\xdf\x49\
\xf9\x39\xf0\x28\x12\xc4\x5d\x9a\xcf\xdb\x7b\x1f\xb6\xef\x77\x51\
\xaa\x4c\xdf\x8e\xe6\xe6\x6e\xe4\x8d\x51\x85\xe6\x48\xf8\x2e\x88\
\x96\xff\x09\xe2\x4b\xe1\x3a\xfd\x36\xb2\xc6\x62\xbf\x37\x21\x85\
\x26\x2d\xaf\xe4\x10\x0d\x69\x42\x32\xd7\x58\x24\xec\x96\x6b\xc7\
\xc3\x64\xcb\x3c\x55\x88\xfe\x3e\x87\x68\x40\x2b\xa2\x3b\xaf\x21\
\xf9\x29\x7c\xe7\x6c\x6b\x8b\xbb\x8a\xc5\x5d\xb7\xf6\x23\x3c\xbd\
\x1b\x8a\x94\xae\x72\xf5\xd8\x87\x78\x3a\x88\xa6\xdc\x93\x91\xdf\
\x0f\xf1\xf7\x32\x1f\xab\x38\xd2\xf7\x08\x57\x21\x05\xa7\x09\x29\
\xb0\x69\xe3\x40\x0d\xda\x00\x6a\x42\x9b\x42\x27\x20\x85\x39\x1c\
\x97\x16\x24\x73\xfd\x9c\x52\x99\xdd\x61\x88\xfd\xd6\x84\x8e\x43\
\xa6\x83\x09\xba\x4d\x9a\x72\x63\xed\x82\x23\x2e\x40\x7c\x6f\x69\
\xaa\x3f\xaa\xd1\xc6\x68\x03\xa2\xf1\xf3\x10\xfd\xf9\x2c\xe2\x39\
\xbb\xf1\x7c\x6e\x39\x8a\xf9\xe3\xe4\x37\xc7\x4b\xcb\xf1\xac\x57\
\xc8\xe6\x77\xa7\x21\x39\xa9\x5c\x9d\xd7\xa3\x0d\xe6\x53\xad\x6f\
\x5e\xa2\xbc\x0e\x37\x09\xf1\xdf\xcd\x74\xbc\xc9\xc4\x61\x00\xa2\
\x11\x9d\xf1\x98\x90\x2e\x9c\x81\xe6\xcd\x26\x4b\xbf\xd7\xfa\xed\
\x7f\x92\xbd\x7e\xaf\x46\x6b\xea\x41\x4a\xef\x8d\xc6\xfa\xfd\x07\
\xd6\xa6\x26\x3c\xcf\xba\x17\xc9\xa9\x47\x12\xbf\xb9\x47\x38\x87\
\x84\xd1\x0f\xd3\xf5\xfd\x5a\xc7\x32\x46\x22\x8b\xab\x0b\x74\xb4\
\x8e\xd2\x5d\xa3\xd1\x68\x57\x2a\x6b\xf7\xbe\x80\x94\xe7\x31\xf6\
\xd9\x31\x85\x10\xd5\x48\x00\xaa\x43\x2e\x83\x1b\xed\xf9\x58\x34\
\x11\xeb\xd0\x20\x3b\x57\xc4\x34\xba\x9b\xae\x2f\xa0\x06\x09\xa9\
\xff\x4d\x69\x64\xbf\xde\x86\xb1\x68\x4e\xec\x44\x8a\xc0\x40\x44\
\x04\x13\xb4\x33\xd6\x8a\xdc\xbd\x86\x21\x2b\xd7\x0e\xb4\x53\xd6\
\x99\x5b\xc8\x7a\x4a\x77\xcb\x6a\xd0\xbc\x1c\x45\xe9\x5d\x85\x6e\
\xa7\xaf\x0a\x11\xf6\x3a\xa4\x68\x86\x67\x92\xc7\x21\x02\xbe\x03\
\x1d\x01\x98\x83\x9f\x9f\xe9\xf3\x93\x55\x56\xf7\x81\x68\x7e\xee\
\xb3\xef\x4d\x48\x98\x68\x0f\xea\x33\xcf\xca\x7b\xc7\xf2\x9d\x81\
\x3f\x03\xba\x3a\xc8\x73\x24\x52\x00\x06\x21\x62\xe8\xce\xdf\x38\
\x4b\xf4\x78\x7b\x77\x07\x52\x94\x06\x59\xde\x05\xeb\xbf\x36\x6b\
\xdb\x60\xfb\xbd\x37\x47\x47\xff\x13\xa4\x34\x1d\xec\x39\xb7\xde\
\x04\x37\x6f\xdc\xd8\xa7\x23\xa6\x0e\x40\xe3\x54\x69\x69\x06\xe2\
\x85\xce\xb4\xa5\x76\x08\x5e\x91\x7c\x03\xd1\xd1\x34\x43\x76\x8c\
\x2d\xeb\x6c\xd6\x44\x44\xf7\x2a\xd0\x3c\x59\x43\x79\x57\xa8\x11\
\x48\xd9\x2e\x67\x61\xdd\x8f\x04\x9e\xa9\xf6\xfd\x2d\x4a\xcf\x4c\
\x0d\x46\xf3\xad\xd2\xea\x54\x83\x94\x8e\xd7\x33\xfa\xc0\xad\xf5\
\x4a\xb4\xf6\x87\x21\xa5\xc4\xad\xdf\x51\x48\x68\xdb\x87\x84\x9f\
\xaa\x20\xfd\x72\xb4\x1e\xdc\x7a\x5b\x4e\xf9\x58\x02\x6e\x7d\x97\
\xdb\xf0\xdc\x8e\x04\xb5\x13\xe8\xfc\xc8\x82\x5b\xab\x50\x4a\x53\
\xb0\x3e\x70\x42\x46\x5f\x41\x2d\x3a\xa3\xf9\x35\xfc\x95\x59\xc7\
\x32\x2a\xd0\x98\x39\x6f\x9d\x2d\x68\x83\x34\x0c\x58\x75\x22\x3e\
\xde\x43\x1a\x7b\xd1\x3c\x9d\x69\x69\x56\x23\x7a\x3c\x06\xf1\xa4\
\x5d\xf6\xbb\xe3\x2b\x8e\x16\xe7\xf1\x7c\x65\x0e\x9a\x63\xee\x5d\
\x87\x1c\x9a\xfb\x6e\x9d\x6e\x47\xf3\xa9\xc5\x7e\x9b\x85\xd6\xfd\
\x56\x34\x0f\xd3\x96\x35\xc7\x07\x9a\xd1\x5a\x9b\x4e\xf9\xb9\xbc\
\xc7\xea\x53\xce\x23\x64\x34\x3e\xe6\x8b\xe3\x39\x1b\x33\xd2\xd5\
\x59\x7f\xba\xfe\x72\xf7\x6f\x3b\x2f\x92\x4a\x24\xaf\x0d\x2c\x53\
\x4e\x11\x29\x64\x3b\x32\xf2\x4b\xac\x0f\x36\xd0\x79\x3c\x8d\x63\
\x01\xa3\xd1\xe6\xe3\xed\x74\x7e\x76\xf6\x60\x51\x81\xe8\xdb\x10\
\x3a\xca\x3e\x0e\xd3\x10\x1f\xd8\x8b\x68\xdd\x1c\xfc\x06\x26\xf8\
\x20\x83\x69\x99\x3d\xc4\x4c\xb4\x76\xf6\xa1\x39\x16\xba\x55\x0f\
\x42\x63\x5d\x51\xe6\xdd\x16\x44\xa3\x2b\x2c\x9d\xfb\x1e\xf2\x84\
\xe1\x48\xd6\xcb\x23\x83\x83\x93\xcd\x47\xa1\xf9\x38\x10\xcd\x2d\
\x27\x03\x25\x19\xef\x65\xa1\x81\x6c\xfe\x33\x18\xef\xf6\x9f\x85\
\x56\xa4\xdc\x56\x5b\xff\xb6\x94\xc9\x07\xeb\xcb\xb9\x96\x76\x39\
\xd9\xb1\x35\xba\xa2\x2f\xd0\x91\x2e\xd4\x21\x5e\x3b\xc2\xca\x7f\
\x17\xcf\x83\xd2\x18\x69\xf9\xbb\x4d\xf5\xf4\xfa\xae\x41\x8a\xfd\
\x28\xfc\x99\xe7\x75\x1c\x79\x9e\x35\x0e\x79\x0d\xff\x31\xf4\x6d\
\x8b\x70\x44\xef\xc3\xb1\x62\x11\x8e\x88\x70\xe8\x4b\x16\xe1\x88\
\x88\x63\x1d\x7d\xc9\x22\x1c\x11\xd1\x53\x38\xd2\x16\xe1\x88\x88\
\xde\x8c\xdf\x58\x84\xfb\x72\xb0\xac\x88\x88\x88\x88\x88\x88\x88\
\x88\x88\x88\x88\x88\x88\x88\x0e\x88\x8a\x70\x44\x44\x44\x44\x44\
\x44\x44\x44\x44\x44\x44\x44\x44\xbf\x42\x54\x84\x23\x7a\x0a\x07\
\x7a\xf1\x76\x44\x44\x44\x44\x44\x44\xe4\x1d\x11\x11\x87\x8e\x24\
\xf8\x8b\x88\xe8\x8f\x48\x40\x41\x03\x2a\x50\xf0\x81\x01\x3d\x5d\
\xa3\x88\x7e\x81\x1a\x34\xef\xea\x88\x73\x2e\xa2\xf7\x23\x41\x41\
\x2b\xaa\x89\xf3\x35\x22\xa2\x37\xa0\x16\xf1\x90\x5a\xe2\x9a\x8c\
\x88\x38\x58\x0c\x40\xeb\x28\xca\xff\x11\xfd\x11\x75\x48\xff\xcd\
\xb9\x08\x5d\xab\x38\x4a\x17\x17\x47\xf4\x7b\xe4\x51\xb4\xb9\x9d\
\x28\xca\x5f\xbc\x4b\x36\xa2\x37\x23\x41\x11\x53\x5b\x50\xb4\xd0\
\x38\x5f\x23\x22\x7a\x16\x39\xc4\x43\xb6\xa1\x28\xa8\x71\x4d\x46\
\x44\x1c\x18\xdc\x06\xef\x54\x14\xa1\xb7\x95\xb8\x8e\x22\xfa\x0f\
\x12\x64\xdc\xa8\x00\x6e\xac\x1c\x54\x9d\x1f\x74\xfc\xc8\xda\xc5\
\x55\x15\xb9\xe8\x1f\x11\x71\x44\x91\x03\x8a\x49\xc2\xea\x5d\xad\
\xc5\xdd\x4d\xed\x8d\x68\x32\x46\xe2\x1b\xd1\x9b\xe1\x08\x26\xe8\
\x2a\x86\x38\x5f\x23\x22\x7a\x16\x39\x24\xc4\xd7\x05\xdf\x23\x22\
\x22\x0e\x0c\x15\xc8\x22\x3c\x90\xd2\x2b\x8b\x22\x22\xfa\x03\x2a\
\xd1\x06\x50\x52\x79\xc2\xe8\xda\xa6\x6f\x5c\x3b\xb5\x6a\xf4\xc0\
\x2a\x92\xa8\x0a\x47\x1c\x61\xb4\xb6\x27\x7c\xe1\x81\x0d\xfb\xee\
\x7d\xb3\xfe\xaf\xd1\xdd\x67\xf1\x9c\x7a\x44\x6f\x46\x11\xf8\x04\
\xba\x1f\xf0\x41\xe2\x7c\x8d\x88\xe8\x69\x54\x03\xbf\x0b\xdc\x83\
\xee\x9d\x8d\x6b\x32\x22\xe2\xc0\x90\xa0\x7b\x6e\x7f\x17\xf8\x7f\
\xe8\xce\xe4\xb8\xa1\x14\xd1\x5f\x90\xa0\x7b\x8b\x3f\x02\x34\x57\
\xe6\x73\xb9\x64\x60\x75\x05\x83\x6b\xf2\x24\x51\x0f\x8e\x38\x92\
\xc8\x41\x4b\x45\x42\x55\x3e\x97\xa0\xcb\xb2\x1b\x88\x42\x4c\x44\
\xef\x46\x01\xed\x1a\xb6\x12\xe7\x6b\x44\x44\x6f\x40\xbb\xfd\x45\
\x1e\x12\x11\x71\xf0\xa8\x41\xfc\xad\x11\xad\xa3\xa8\x08\x47\xf4\
\x17\x24\xe8\x5c\x7c\x11\x64\x1a\x8e\xa1\xe3\x22\x8e\x0e\x12\x48\
\x92\xdf\xcc\xb3\x5c\xf0\x17\x11\xd1\x5b\x91\x9e\xa3\x71\xbe\x46\
\x44\xf4\x0e\x44\x1e\x12\x11\x71\x70\x08\x8f\xa5\xc5\x75\x14\xd1\
\x1f\xf1\x9b\xf9\x1e\x77\x52\x23\x7a\x1b\x8a\x68\x97\x32\x44\x81\
\xae\xf7\x69\x8a\xdd\xcc\x3f\x39\x80\xb4\x87\x03\x59\x75\x2f\x66\
\x3c\x3b\x98\x7a\x15\xbb\xf1\x4e\xb8\xcf\x55\xec\x46\xba\xa3\x09\
\xd7\x0f\x59\xfd\xd1\xd3\x75\x3b\x98\xb6\x14\x32\x9e\x1d\x4a\xbd\
\xbb\xdb\x3f\x11\x11\x11\x07\x87\x72\xf4\xf9\x60\x68\x71\x1a\x47\
\x8a\xa6\x1f\x0e\x1c\x48\x39\x21\xfd\x3d\x98\xba\x1d\x6d\x9e\x1b\
\x71\xf4\x71\xb0\x72\x5b\x44\x44\x8f\x23\x2a\xc2\x11\xbd\x09\x09\
\x30\x17\x38\x0b\xbf\x5b\x53\x01\x9c\x89\xfc\xf9\x93\x32\xef\x54\
\x01\x73\xe8\x9e\xb2\x3c\x19\x38\xb9\x1b\x69\x0f\x17\xce\x00\xc6\
\xa7\xca\x9b\x9f\x7a\x96\x00\xe3\x80\x53\xe9\xfe\x9a\x4c\x80\x59\
\xc0\xcc\x4e\xda\x92\x00\x63\x81\xe3\x51\x74\xc8\x93\x29\x2f\xb0\
\x0d\xb7\x3a\x1c\xad\x7e\xa9\x00\x16\x01\xc3\xac\x3f\xa6\x50\x5e\
\x58\x1a\x6f\xe9\x7a\x2b\x53\x4d\x80\x13\x81\xcb\x90\x97\x4d\x62\
\xed\x5b\x82\xfa\xf5\x60\xea\x5d\x01\x9c\x8e\xe6\xfd\x6c\x60\x7a\
\x2f\x6e\x7f\x44\xc4\xb1\x88\x6a\xe0\x42\x4a\x79\x4b\x82\xe8\xd1\
\x6c\xba\xbf\xde\xaa\x10\xfd\xaa\x0c\x9e\x25\x88\x66\x9d\x9a\x7a\
\xde\x19\x8a\x88\x8f\x75\x87\x97\x1d\x0a\x12\xc4\x13\x4e\xe8\x66\
\x39\x93\x80\xc1\xc8\x95\xf0\x34\x6b\xef\x81\x94\x35\x0e\x38\x85\
\x68\x71\xec\xab\x48\xd0\x7a\x39\x07\x2f\xbf\xe4\x90\x1c\x37\x86\
\xc8\xb7\x22\x7a\x39\xa2\x22\x1c\xd1\x9b\x90\x20\x46\xfb\x25\xa4\
\x58\x14\x10\xd3\xbd\x02\x98\x80\xdf\x75\x6c\xb7\xff\x45\x14\xc9\
\x77\x09\x70\x1d\x70\x12\xba\x5b\x32\x44\x31\x48\x5f\x40\xcc\xff\
\x1c\x74\x5d\x58\xb8\x63\x99\xa4\xf2\x0e\x9f\xb9\xe7\xc5\x20\xcf\
\x42\xf0\x97\x55\x96\x73\x3d\xba\x02\x98\x16\xbc\x9b\x03\xce\x43\
\x82\x53\x6b\xd0\x8e\xe3\x90\x22\x55\x91\x6a\x67\xb1\x4c\xfe\x05\
\x60\x21\xb0\x20\x48\x9f\x66\x38\x95\x56\xfe\x00\x60\xa4\x95\x99\
\xd5\xa6\x04\x78\x0f\x12\xda\x0a\x94\xf6\x85\x2b\x3f\x7c\xaf\x98\
\x51\xc7\x62\x46\x7d\xd3\xfd\x19\xb6\x21\x07\x5c\x04\x8c\xb6\x7a\
\x8d\xc4\x5b\x0e\xc2\xf1\xad\x00\x6e\xb4\xfe\x29\x66\xd4\xa3\x37\
\xa0\x12\xcd\xbf\x8f\x21\x85\xd5\xd5\x7b\x06\xfe\x1c\x4a\x38\x67\
\xc2\xcf\x59\x63\x5b\x44\xf3\xfe\x72\x34\xef\xc7\x23\x81\x22\x3d\
\xef\xb2\xe6\x6e\x6f\xe9\x93\x88\x88\x9e\x44\x77\x84\xef\x22\xe2\
\x05\x67\xe3\x69\xcb\x00\xe0\x06\xb4\x81\x15\xd2\xaf\xd0\x22\x1a\
\x3e\x2f\x20\xfa\x7e\x23\x92\xa7\x42\xda\x5a\x87\xe8\x41\x9e\x8e\
\x6b\xd4\x7d\x27\x95\xef\xe9\x88\x07\x66\xd1\xd8\x30\x5d\xda\xfa\
\x96\xe6\x5f\x09\x1d\x69\xa5\xfb\xdc\x86\x78\xe5\xc2\x8c\xf4\x69\
\xfa\x5d\x89\x02\xca\x8c\x47\xbc\xf6\x32\x44\x9b\xd2\x75\x2a\x47\
\xdf\x8a\xc0\x50\xeb\xa3\x74\xff\x15\x33\xea\x1e\xe9\x57\xef\x41\
\x77\x3d\xb1\x8a\x68\x53\xfb\x4b\xc0\x3c\xfb\x9e\x07\xae\xc2\x6f\
\x70\xa7\x65\x23\xe8\x38\xff\xc3\x39\xdb\x99\xec\xd3\x99\xcc\x16\
\x11\x71\xc0\xe8\xee\x4e\x65\x44\xc4\xd1\x42\x3b\xba\x5f\xf8\x46\
\x60\xbd\x7d\x77\x04\xb2\x1a\xed\xd6\x1f\x07\x34\x03\x2f\xa0\x40\
\x0f\x21\xf3\x4d\x13\xee\x13\x90\x95\x79\x1f\xf0\x8c\xa5\x19\x0c\
\x5c\x62\xff\x5f\x00\xb6\xa0\xdd\xfb\x85\x48\x21\xdb\x02\xbc\x08\
\x0c\x41\x3b\xe7\x55\xf6\xfb\xcb\xc0\x46\xb4\xbb\x5d\x85\x76\xba\
\x77\x59\x1e\x2d\xc8\xea\xba\xc0\x3e\xbf\x88\xee\x4a\xce\x62\x26\
\x45\x24\x20\x8d\x06\x76\x03\xcf\x05\xe9\x12\x7b\xbe\x18\x29\xf5\
\xaf\x03\xef\x20\xc6\x72\x92\xd5\x67\xa7\xbd\xe3\x18\x4c\x25\xda\
\x7d\xdd\x84\xee\x04\xcf\xd9\xf3\xb9\x56\xef\x37\x81\x89\x48\xf1\
\x1e\x89\x36\x19\x2a\xed\xf3\x32\xcb\x6f\x11\x12\x90\x9e\xb7\xbe\
\x3a\x0d\x09\x30\x6f\xd9\xfb\x53\x90\x30\x33\x00\x78\xd7\xda\x5f\
\x63\x7d\xf0\xba\x7d\x9e\x65\x69\xdf\xb4\xb1\x5a\x68\xe5\xae\xb3\
\x72\xda\x6c\xec\x16\xda\xb8\xb9\x4d\x8b\xf5\x40\xbd\xe5\x79\x92\
\x95\xd3\x6a\x7d\x58\x87\x2c\xd9\x6d\xd6\x0f\x03\xad\x6f\x2a\x80\
\xa5\xc0\x06\x7a\xd6\xd2\xe0\xc6\x72\xb0\x8d\xc9\xb9\xc0\x0a\x34\
\xcf\x56\xa3\x20\x24\x73\xad\xdf\x26\x5a\x5f\x6f\xb0\x36\x35\xa0\
\x39\xd9\x86\x04\x88\x19\xf6\xde\xcb\xc1\xdc\xc9\xd9\xb8\xb6\x5a\
\xbf\x8c\xb7\xb2\xaa\xad\xbc\xed\xf8\xcd\xa0\x11\xc0\xdb\xd6\xff\
\x51\xa0\x8c\xe8\xaf\xa8\x46\xb4\xbb\x1e\xf1\x8f\x72\x68\x01\x7e\
\x0d\x9c\x0f\x3c\x80\x78\xca\xf1\x88\xd6\x2e\x47\xde\x36\x27\x23\
\x5a\xf5\x02\xb0\x17\xd1\x1e\xd0\x5a\xde\x82\xd6\xea\x7c\xb4\x7e\
\x17\xa2\x7b\x8d\x87\xa3\x35\xb9\x12\xd1\xe3\x02\xa2\xc3\x4b\x10\
\xfd\x7a\x1d\xad\xe9\x05\x88\x86\x35\x58\x39\xdb\xf0\x0a\x41\x1e\
\xf1\xae\x13\xad\xbc\x57\x11\xdd\x58\x82\xe8\x66\x0d\xf0\xb4\xbd\
\x8b\xe5\xbb\x10\x79\x00\xed\x46\x74\xbc\xc2\xea\x35\x00\xd1\x74\
\xec\xbd\xbc\xe5\x31\x1c\x29\xb6\x8e\x96\x0c\x40\xf4\xfc\x25\xab\
\x83\xab\xef\x6c\xc4\x5f\x9e\xa4\xd4\xd3\x65\x05\xa2\x35\x27\x58\
\x7b\x27\x58\x39\xab\xf0\x34\xfb\xd7\x36\x0e\x6b\xad\xfc\xe3\x10\
\x8d\xaf\x09\xde\x1f\x6a\x79\x0e\x46\xfc\xe6\x2d\xa2\x15\xb1\xa7\
\x91\xa0\xb1\xaf\x43\x32\x4e\x57\xe3\x51\x40\xe3\x7c\x23\xe2\xf7\
\xfb\xf0\xf2\x4c\x15\x9a\x0f\x53\xf1\x7c\x7d\x2f\x92\xa3\x96\xa2\
\x35\x33\xdf\xca\xd9\x89\xe6\xc2\x68\x60\x0d\xf0\x1a\x5a\xc3\xb3\
\xed\x6f\x4f\xf0\xfe\x58\xb4\x86\x06\xe1\x65\x8c\xce\xd6\x7b\x44\
\x44\x26\xa2\x45\x38\xa2\xb7\x21\x07\x3c\x8c\x98\xe8\x55\xc1\xf3\
\x22\x52\xce\x2e\x45\xc4\x70\x16\xf0\x61\x24\xbc\xbc\x04\xdc\x81\
\xae\xd2\x68\x09\xd2\xcf\x01\x3e\x8a\x88\xf4\x2c\xe0\x1a\xbc\x42\
\x39\x14\xb9\x7c\x7d\x1c\x11\xfb\xeb\x90\xe0\x53\x6f\xe5\x9e\x8d\
\x84\x9d\xcf\x22\xa2\x3c\x12\xb8\x0d\x09\x58\x57\x23\x4b\x6b\xab\
\xa5\x3d\x13\x31\xf8\x4f\x58\xd9\x23\xed\xf3\x10\xb2\xcf\x02\xd7\
\x22\x62\x5f\x44\x96\xd8\xcb\xf1\x4c\x63\x28\xf0\x19\xab\x5b\x0e\
\xb8\x15\x31\x80\x25\xc8\x52\xd1\x82\x94\xd6\xf7\x58\xfa\x4a\x6b\
\xd7\x59\x78\x61\xc7\x61\x09\x12\x9e\x1a\x90\x40\x75\x1a\x72\x03\
\xfc\x0c\x72\x11\x1f\x04\x7c\xca\xca\x6c\x42\x02\x5f\x1e\x59\x00\
\x66\xda\xb3\x1b\x10\x13\x3b\x01\xf8\xb4\x95\x57\x63\xfd\x76\xb2\
\xb5\xe5\x8b\xc8\x9a\x5c\x6d\xcf\x47\x01\x57\x22\x6b\xcb\x5e\x64\
\xf9\xbd\x08\x31\xae\x4f\x21\x81\x6b\x92\x95\x51\xb0\xfe\x9b\x81\
\x98\xe1\x15\xd6\x8e\x69\xc8\xc2\x8a\xb5\xd9\x09\x98\x6e\x0c\x2a\
\xad\xac\x89\xf4\xbc\xd0\x74\x1a\x62\xc4\x0f\x21\xa5\x77\xb4\xd5\
\xef\x02\xa4\x9c\x5e\x60\xfd\x58\x04\xae\x07\x3e\x69\x75\xbe\xdc\
\xde\x3d\x11\xb8\xd6\xc6\x69\xbc\xf5\x51\x2d\xde\x42\xb3\xc8\xd2\
\xcc\xb5\xf9\x50\x63\x7d\xf7\x21\x34\x77\x6f\xb6\xdf\x1a\x2c\x9f\
\x53\x89\x8a\x70\x44\xff\x44\x1e\xf1\x85\xaf\x21\x5a\x92\x74\x91\
\x76\x19\x5a\x43\x53\xed\xd9\x12\x24\x9c\x8f\x43\xf4\xa7\xdd\x3e\
\x7f\x1c\xd1\x9d\xeb\x81\x8b\x11\x4d\x7a\x3f\x52\x8c\x1b\x11\x2f\
\x68\x42\xae\xd6\x1f\xb0\xef\x6e\xed\x0f\xb6\xbc\x66\x58\x19\x37\
\xa3\xf5\x7c\x95\xfd\x06\xa2\xdf\xc7\xe3\x15\x61\x67\x65\x6e\xc1\
\xf3\x84\xe1\xf6\xec\x6c\x7b\xee\xda\x96\x03\xde\x8b\x14\x8b\xdd\
\xc8\xe3\xe8\x0a\x2b\xff\x33\x88\x46\x16\x11\x0d\x3a\x07\xf1\xcc\
\x9c\xa5\xaf\x43\xbc\xf1\x16\xab\xcb\x07\xac\x9d\xc3\x80\xf7\x59\
\xfe\xad\xd6\xc6\x76\xb4\x21\x3a\xcb\xfa\xee\x56\x44\xc7\x4f\x43\
\xb4\xc8\xd1\xb4\xcf\x5a\xfe\x17\x58\x5d\x26\x5a\xb9\x23\x2d\x5d\
\xb5\xa5\xfd\x14\xe2\x43\xd7\x5b\xdb\xdb\xac\x8e\xce\xfb\x2b\xa2\
\x67\xe0\x3c\x23\xfe\x27\xf0\x6f\x78\x59\xa5\x33\xe4\x80\xc7\x10\
\xef\xbe\xc6\xbe\x3b\xfe\x75\x0a\x9a\x17\x7b\xd1\xbc\xfe\x28\x9a\
\x9b\x57\xa3\xb9\x5d\x40\x1b\xc8\x33\x90\x5c\x73\x1a\xe2\xf7\x57\
\x23\x3e\x37\x1f\xcd\xcf\x66\xb4\xe9\xfc\x41\x34\x3f\x6f\x41\x73\
\xaa\x09\xad\xf9\x79\x44\xcb\x70\xc4\x41\x20\x5a\x84\x23\x7a\x23\
\x1a\x80\xef\x23\x42\xfc\x36\x22\xa6\x39\xfb\xbc\x1b\x11\xd8\x89\
\x68\x37\xb0\xd6\xd2\xaf\xa0\xe3\xc6\xce\x39\x68\x47\xf1\x0e\xc4\
\xe4\x87\x20\xe5\x6d\x39\x70\x17\x62\xe2\xb7\xdb\x6f\x8f\x22\x06\
\x5d\x8b\x08\xee\x71\x56\xd6\x6a\xe0\x4e\x4b\xf3\xe7\x88\x80\x37\
\x03\x4f\x20\xc2\x3f\x0c\x11\xeb\xd1\x88\xa8\x3b\x0b\xf5\x45\x78\
\xc1\x26\x44\xce\x7e\x7f\x00\xb8\x1f\x59\x15\xae\x06\x1e\xc1\xbb\
\x6e\xd7\x02\xdf\x45\x4c\xa5\x0e\x59\x2c\x06\x01\x8f\xdb\x7b\xc3\
\xed\xf9\xb9\x68\x63\x00\xab\xdb\x16\xb4\x63\x0f\xda\x85\x1d\x6f\
\xf5\x04\xaf\x68\xe7\x90\xd2\x76\x97\x7d\x5e\x60\xed\x5e\x83\x36\
\x18\x2a\x91\x22\xf5\x00\x12\x4c\xf2\xd6\x8f\xef\x20\x0b\xc7\x7d\
\x88\xf9\xec\xb3\xcf\xfb\x90\x60\xf6\x08\xba\x6b\x77\x11\x12\x96\
\xce\x43\x56\x8c\x82\x8d\xcf\x79\x96\xd7\x5e\xe0\x07\x88\xd1\x4e\
\xc1\x33\xcc\x9c\xd5\xe1\x2e\xbc\x55\x7c\xae\xa5\xdf\x88\x84\xd3\
\xa9\xf6\xf7\xb2\xe5\x3b\xce\xea\xbf\x21\x68\xf7\xd1\x44\x62\xf3\
\x62\xb1\x8d\x4d\x9b\xf5\xe5\x22\xeb\x0f\xd7\xe7\x79\x64\xbd\xb9\
\xd3\xea\xbf\x0b\xcd\xc9\x91\x48\x10\x5c\x0a\xfc\x94\x52\x57\xff\
\xc1\xa9\x72\x1c\x5e\x06\xee\x46\x82\xf4\xa7\xad\x0f\xcf\x04\x7e\
\x89\x77\x27\x3b\x1b\xef\x65\x10\x11\xd1\x9f\x50\x81\xd6\xd8\x14\
\x3c\x7d\x29\x87\x1c\x5a\x8b\x6f\x21\x61\x7d\x2b\x12\xd4\xbf\x89\
\xe8\x77\x1d\xa2\xf5\x7b\x10\xfd\x9a\x8a\x68\xd9\x83\x68\x7d\x8d\
\xb6\x67\xcb\x10\x8d\x7a\x13\xd1\xea\xe7\x11\xfd\x74\x67\x7d\xa7\
\xa0\xa3\x0d\x7f\x8d\x36\x5a\x9f\x45\xf4\x0f\x4a\xdd\x3c\x43\xc5\
\x76\x3b\xa2\x09\x4e\xb0\x3f\x1f\xd1\xfd\x16\xc4\xab\x9e\x40\xb4\
\xc6\xb5\xef\x79\xcb\xb3\x0a\xd1\xe4\xe9\x88\x56\xec\x46\xf7\x2d\
\xef\x47\x0a\xe7\xc3\x88\x6f\xdd\x84\x36\x90\xef\x42\x1b\xad\x1f\
\x43\xf4\x7b\xb7\xd5\x3b\x87\xee\x96\x7d\x11\x29\xd9\xcb\x90\xc2\
\xb1\x13\xd1\xb1\xed\x88\x97\xba\x8d\xc8\x17\x10\x4d\x1b\x8f\xe8\
\xdd\x5d\xd6\x7f\xd3\xac\x5f\x13\xeb\xbb\x3b\x11\x8d\x1a\x83\x2c\
\x8e\x63\x11\xcf\x19\x8b\xf8\xcb\xfd\xd6\x47\xf1\x3c\x71\xcf\xa2\
\x06\xcd\xa1\xa9\x88\xcf\x76\x85\x1c\x9a\x1f\xdf\x03\x7e\x1f\xc9\
\x58\xce\x45\x7a\x35\x9e\xaf\x8f\x41\x72\x51\x1d\xa5\x41\x20\xdd\
\xfc\xaf\x40\xeb\x2a\x8f\xd6\xd9\x16\xb4\x31\x9f\xa0\x0d\x99\x3d\
\x68\x3e\x3e\x84\xe4\x8f\x3c\x92\xbb\x72\x48\x9e\x7b\xa9\xa7\x3b\
\x2e\xe2\xd8\x43\x54\x84\x23\x7a\x23\xf2\x88\x29\xfe\x0a\xed\x9e\
\x3b\x05\xf7\x24\xb4\xcb\xbc\x16\x29\x8b\x61\xc8\xff\xb4\x12\x9c\
\x43\xc4\x76\xa3\x7d\x2f\x22\xc1\x21\x8f\x88\xa9\x53\xae\x8b\x88\
\xe8\x5f\x84\x98\xf8\x6a\x44\x8c\x5d\xbe\xa1\x5b\x90\x23\xec\x2d\
\x48\x41\xab\x40\x82\x8a\x73\x35\x6b\xc2\x07\x4b\xba\x17\xb9\xbf\
\x65\x79\x5d\x38\xe5\xd0\x31\x8f\x5c\x90\xae\xd6\xf2\x6f\xb3\xe7\
\xfb\x90\xb0\x51\x17\xbc\x53\xb0\xb6\x54\x22\x77\xba\x76\xa4\x10\
\xae\x4f\xb5\x3f\x47\x47\x57\xa1\x1c\x12\x34\xdc\xf9\x6b\xa7\xa8\
\xb9\xf2\xab\xf1\xe7\xbb\x6a\x90\x30\xb5\xd6\xfa\xc6\x59\x9c\xf3\
\x48\xb0\x6a\xb6\x3e\x70\xf7\xec\xe6\xf1\xae\xda\x39\x7b\x56\x6b\
\xf5\x5a\x86\xdf\xbd\x75\xe7\x7d\x5c\xdb\x1d\xe6\x20\x57\xbd\xf5\
\xc1\x18\xe4\x83\xb6\xb8\xbe\x71\xf5\x7d\x18\x09\xb1\x3d\xe5\xd9\
\x52\x44\x0a\xe9\x24\x74\xb6\x6f\x91\xf5\xd9\xb9\xc8\xe5\xd9\x21\
\xb1\x3e\x77\xf3\x65\x3f\xfe\x2c\x78\x11\x6d\xa4\x5c\x83\x5c\xce\
\xdb\x28\xbd\xda\x82\x54\x3e\xbb\xf0\x9b\x07\x6e\xbc\xb0\xf7\x6a\
\x90\x00\xb2\xb9\x87\xfa\x23\x22\xa2\xa7\xd1\x0a\x7c\x03\x6d\x4c\
\x2d\xa5\xfc\x5a\x72\x48\x90\x62\x7a\x3d\x52\x02\x77\xa3\x75\x38\
\x00\xd1\x27\x77\x1e\xf6\x1e\x44\x6b\x5b\xd1\xfa\xad\x44\x6b\x39\
\xa4\xdd\x6e\x5d\xee\x0d\x9e\x25\x68\x5d\xb6\xd9\xbb\xee\x99\xa3\
\xbd\xa1\xfb\x68\x58\xa7\x29\x48\x59\xdd\x8a\x77\x33\x75\xbc\xa7\
\x81\x52\xd9\x2d\x8f\x36\xbf\x66\xa2\xcd\xc4\xea\xa0\x3e\xfb\xac\
\xfe\x8e\xde\x38\xda\x83\xb5\x35\xbc\x42\xa7\x05\x29\x12\xa7\x59\
\x79\x2f\xe1\xe3\x39\xb8\x74\x7b\xf0\x34\xd8\xf1\xc3\x82\xe5\xe5\
\xce\x42\x37\x04\x9f\x43\x45\x67\x24\xb2\xa2\x37\x22\x05\xc7\x29\
\x3e\x3f\x41\x9b\x79\x0b\xac\xdd\xff\x8d\x14\xf0\xa8\x0c\xf7\x0c\
\x9c\x8c\xf0\x15\x64\x9d\x7f\x9e\xee\x8d\x45\x1e\xcd\xbf\x87\xd0\
\xdc\x75\xca\xee\x1c\xb4\x61\xbf\x16\x3f\x6f\x5d\x7e\x6e\x7e\x54\
\xd9\xfb\xbf\x40\x73\x74\x36\xb2\x10\xff\x0c\xcd\xe7\x46\xfb\xdf\
\x84\x94\xea\x02\xf2\x7e\xaa\xc4\x1f\x8f\x8a\x1e\xae\x11\x07\x85\
\x38\x71\x22\x7a\x1b\x42\xa5\xec\x21\xfc\x19\xcb\x1c\xb2\xbc\xad\
\x46\xbb\xc6\x4d\x74\x0c\x8c\x15\xa2\x88\x5c\xa5\x17\xa0\x9d\xcd\
\x8b\x90\xb0\xe3\x94\xb4\xb0\xbc\x21\x96\xee\x61\xe0\x29\xbc\x92\
\x99\x26\xae\xf9\xe0\x7f\xfa\x0e\xbe\x77\x10\x51\x7f\x0b\x9d\x91\
\x9a\x8c\x17\x5e\xc2\xf2\x12\xc4\x20\xce\x42\xbb\xad\x67\x22\x65\
\xbd\xc5\xca\x5c\x83\xac\xcc\x8b\xd1\xce\xe9\xa9\x48\xa0\x7b\x03\
\x29\x5b\x53\x90\x05\xf9\x72\xcb\xef\x79\xe0\x3b\xd6\xbe\x30\x0a\
\x68\x1b\x12\x82\x46\x05\xf5\x0c\xeb\x9f\x6e\x53\x01\x09\x2a\x7b\
\xd1\x6e\xbf\x3b\x8b\x33\x0c\xed\xdc\x27\x65\xde\x4b\xf7\x51\x05\
\x62\x64\xee\x7c\xf7\xf3\xf6\x7c\x14\xb2\xda\x4f\x41\x1b\x1a\x0b\
\x82\xfa\xba\x31\x5f\x82\x84\x50\x67\x69\xae\xc5\x5b\xd4\x47\x59\
\x3f\x35\x5b\xde\xaf\x21\xe5\xbc\x82\x9e\xb3\x7c\x56\x22\xa5\xf7\
\x21\xe0\x4f\x80\xbf\x04\xfe\x02\xed\x68\x9f\x18\xd4\x3d\xbd\x61\
\x93\x9e\x47\x8b\xf0\x96\x9b\xdd\x48\x70\x4e\x6f\x02\xe4\xe8\x28\
\x74\x57\x20\x0b\xcd\x66\xb4\x4e\x5e\x40\x16\xe5\x21\x44\xd7\xc2\
\x88\xfe\x09\xe7\xf1\xf2\x10\xa2\x63\x5d\x09\xf0\xce\x62\xd5\x8a\
\x8e\xc7\x3c\x87\x68\xf1\x0a\x7b\xf7\x75\x44\x6f\x5c\xa0\xc1\x34\
\x0d\x74\x8a\x60\x1d\xb2\x4c\x85\xeb\xdb\xad\xd1\x4d\x88\xa7\x2c\
\x41\x34\xfd\xb3\xc8\xb3\x08\xa4\x24\x9c\x88\x04\x7f\xf7\x4e\x82\
\x68\x64\x01\x59\x50\xb7\xe0\x79\x5d\x9a\x9f\x80\xe8\xc5\x69\x48\
\xa1\x7f\x24\x28\xd7\xfd\x27\xe3\xdd\x34\x2d\x71\xf5\x5e\x8a\xf8\
\xd2\x24\x44\x63\x1d\x46\x22\x7a\x17\xe6\x91\xa6\x4f\x61\x9f\x84\
\x9f\xdd\x6f\xd3\x90\x45\xf0\x2e\xb4\xd1\x5d\x87\x14\xa0\x4b\xd0\
\x06\xdf\xf7\x10\xdf\x99\x40\xf4\x66\xe9\x0d\x78\x03\x79\x1a\xed\
\xa3\xeb\x75\x14\xf2\xab\x87\x11\x1f\x9b\x6b\xbf\x2d\x46\xca\xea\
\xcf\x90\x6c\x50\x87\x3f\x86\x35\x07\xcd\x7d\x77\x16\xde\x79\x8e\
\xfd\x00\xc9\x42\x93\x91\x27\x60\x25\xda\x4c\xdf\x82\x2c\xd4\xa3\
\x90\x8b\xfe\x7d\x68\xce\x3a\xc3\x48\x44\xc4\x01\x23\x5a\x84\x23\
\x7a\x13\x5c\x60\x20\x67\x65\x6d\x44\x4a\x9e\xdb\x65\x7f\x08\x29\
\x80\x37\x22\x21\x67\x39\xe5\x37\x73\x2a\x90\x55\x60\x20\x3a\x4b\
\xd2\x84\x5c\x4a\x87\xe3\x95\xdc\x16\xa4\xc0\x6e\x01\x7e\x8e\xac\
\xcd\x3b\x11\x03\xa8\x47\x0c\xc0\x59\x59\xdb\x11\x41\x6e\x42\x82\
\xd6\x7e\xcb\x63\x2b\x52\xce\x9e\x43\x4a\xe3\x07\xac\xbe\x2e\x08\
\xd5\x2a\xc4\xdc\x43\x22\xfd\x0e\x12\x34\x6e\xb6\x76\xfd\x14\x29\
\x4f\x6b\x11\xc3\xf8\x11\x72\x47\xae\x00\x5e\x41\x41\x4a\xaa\x90\
\xd5\xf0\xc3\xf6\xce\x9d\x78\x45\x72\x05\x72\x97\x3b\x09\x09\x18\
\xee\x6c\xce\x32\xe4\xbe\x56\x65\x75\x71\x7d\xba\x0e\x1f\x5c\xec\
\x6d\x7b\xf6\xa2\xe5\x3f\x12\xf8\x2f\x64\x99\x5d\x84\xdc\xe3\xde\
\x42\xbb\xb3\xeb\xac\xfe\x6d\x48\x78\x74\xae\xb8\x2b\xac\x2f\x8b\
\x96\x5f\x3d\x72\xed\xbe\x06\x9d\x95\x6e\x44\xae\x82\x6b\xd1\x26\
\x86\x3b\x5f\xfd\x9a\xfd\xf6\xae\xd5\xef\x41\x7b\xe7\x66\x7c\x20\
\x9a\x22\x72\x2b\x5e\x88\x77\x69\xbf\xd4\xda\xb2\xca\xde\xed\x09\
\x06\x98\x20\xa5\xb3\xcd\xfa\xde\x59\xc4\x37\x20\xd7\xc3\x71\x78\
\x01\x71\x03\xde\xfa\xb2\xc1\xda\x9a\x43\x0a\x6c\x11\x31\xfc\xeb\
\xd0\x3c\xdd\x82\x14\xda\xa2\xb5\x6f\xbf\x3d\xdb\x6f\xe5\xba\xf3\
\x7d\x8d\x36\xd6\xbb\x6d\xbc\xde\x6b\xe3\x5f\x6f\xfd\x14\x11\xd1\
\x5f\x11\x2a\x63\xdd\x41\x13\x52\x22\xf3\x88\x26\x55\x22\xd7\xe3\
\x01\x88\xd7\x80\xe8\xe3\x2e\x44\xc3\x9c\x27\xcb\x66\xfc\x9a\x7e\
\x17\x6d\x6a\x6e\x40\xbc\x29\xa4\xb5\xdb\x90\x60\x7f\x91\xa5\x79\
\xce\xf2\xab\x44\x74\x7e\xbb\x7d\xaf\xc7\x7b\x73\xbc\x8e\x36\xfa\
\x3e\x68\xcf\x9e\x45\xf4\xda\xd1\x84\x10\xcd\x88\xb7\x9d\x81\xe8\
\xf4\x06\x4b\xdb\x8c\x68\x84\x0b\x26\xb9\xd2\xde\xcd\x5b\x9d\x9c\
\x6b\xb5\xa3\x25\x45\xc4\xcf\xde\xc5\x5b\xc7\xf3\xd6\x17\x8b\xac\
\x9e\xab\xf0\x5e\x46\xab\xac\xce\x35\x41\xbe\x1b\x11\x2d\x0c\x79\
\xe3\x5e\xcb\xf3\x35\xc4\xb3\x6e\x44\x34\xed\x19\xc4\x63\xdf\x44\
\xca\xf0\x99\x88\x7f\x3c\x79\x80\xe3\x17\x71\x64\xd0\xdd\x31\xc8\
\xa1\xf1\x74\x1b\x25\xcd\xe8\x68\x5b\x0d\x1a\xfb\x9f\xa3\xf3\xf0\
\x37\xa1\x79\xb7\x0c\xcd\xb9\x7b\x90\xcc\x75\x3c\x9a\xff\xdb\x91\
\xbc\x75\x35\x92\x5b\xea\x91\xbc\xb0\xd7\xf2\xfa\x10\x9a\xcb\x4f\
\x21\x99\xe4\x49\x74\x8e\x7d\xab\xbd\x9f\x96\xb3\x22\x22\xba\x85\
\xdc\x92\x49\x03\xeb\xbf\x7d\xc3\xf4\xa1\x63\x07\x55\x92\xc4\x3d\
\xb8\x88\x23\x8c\x96\xf6\x84\xcf\xdf\xbb\xae\xfe\xce\xd7\x77\xdf\
\x8e\x18\x63\x9a\xd8\xba\xef\xa1\x45\x2b\x74\x23\xad\xc2\xbb\xdd\
\x56\x52\x7a\xce\x24\x0d\xe7\x16\x57\x85\x77\xf7\x75\xbb\x96\xce\
\x35\xda\xed\xe8\xbb\xa8\xd4\xce\x6d\xb7\x92\x52\xf7\xe9\xb0\x1e\
\x6e\xd7\x3e\xb4\x10\xb8\xb3\x5c\x2e\x10\x88\x73\x6d\x76\xef\x84\
\x75\x74\x6e\x63\x95\x78\x65\x32\xb4\x2e\xb8\x76\xe6\xf1\xee\x74\
\x58\x7e\xd5\xf8\xeb\x02\xdc\x6e\x7f\x31\x28\xcb\x09\x29\x09\xb2\
\x0c\xde\x8a\xce\x6e\xad\x0f\xca\xcd\x6a\x93\x2b\xd3\xd5\xbd\xd2\
\xfe\x5a\xf1\x2e\x6c\xa4\xde\x2b\xa4\xf2\x48\x52\xf9\xe5\x2d\xcf\
\xb6\x54\xbf\xa5\xdd\x02\xc3\xc0\x1a\x8e\x99\xb6\xe2\xad\xbd\xee\
\x9d\x76\x3a\xce\x01\xd7\x2f\x47\x0a\x05\x14\x70\x66\x13\x72\x77\
\x0f\x2d\x2c\xe9\x3e\x0f\xc7\x77\x0a\x3a\xc3\xfb\x75\xfc\x06\x42\
\x38\x5f\x8a\x94\xce\x9d\x4a\xbc\x9b\x79\x3e\x48\xeb\xfa\x2d\x44\
\xd6\xdc\xad\x48\x8d\x57\x14\x08\x22\xfa\x2a\xaa\x51\x80\xbe\x3b\
\xe8\x7c\x33\xf4\x40\x10\xae\x27\x28\x3d\x7a\x50\x8e\x9e\x87\xeb\
\xb7\x82\x52\x9a\x98\xb5\x46\x43\xda\x96\xa6\x85\xa1\xf7\x48\x98\
\xa7\x5b\xd3\xa1\xf5\x36\x8b\xe7\x39\xfe\x15\xd2\xef\xd0\x75\x99\
\x32\x75\x0f\xeb\x99\x43\x74\xeb\x66\xb4\x39\xfb\x66\x90\xce\xf1\
\xd0\x5c\x46\x7e\xb9\x20\xaf\x2c\xfa\x96\x04\xef\x85\x3c\x81\xe0\
\x79\x48\xff\x22\xfd\x3a\xf2\x48\x90\x57\xc2\x17\x81\xbf\xa5\x7b\
\xde\x13\x9d\x21\x2d\xb7\xb9\xf9\x1e\xde\x6c\xe1\xe6\x7e\xf8\x3c\
\x3d\xff\xdd\xd5\x83\x95\x78\xb9\xc1\x21\x94\xcf\xa0\x54\x1e\x72\
\xef\xc5\x60\x59\x11\xdd\x81\x8b\x43\x73\x1b\xf0\x85\x68\x11\x8e\
\xe8\x6d\xc8\x72\xe9\x74\xc4\x2d\x3c\xf3\x1a\x32\xe4\x72\x70\x84\
\x3d\x64\xba\xe9\x73\x4b\x61\xde\x6d\x19\x79\x87\x02\x47\xd6\xb3\
\x62\x27\x65\x85\xef\x64\xb5\x31\x5d\x2f\x97\x36\xbc\x8f\x32\xcd\
\x9c\x42\xe5\x2f\xec\xab\x84\x52\x85\x2c\x87\x76\x48\x1f\x43\xae\
\x66\xeb\x28\x65\x52\x9d\xf5\xad\x53\xc0\xca\x95\x95\x6e\x57\xa1\
\x4c\x7e\x09\x1d\x95\xd5\xac\x73\xcb\x61\x90\x98\xb0\xdd\x61\x99\
\x6d\x19\xef\xf7\xb4\xb0\x94\xee\x73\x87\x0a\x74\x66\xcf\x79\x1b\
\xa4\x85\x45\x52\x9f\xc3\x76\x87\xcf\xb3\xe6\x5b\x58\x76\xd8\xd7\
\xe9\xf1\x8a\x88\x88\xe8\x3e\xd2\xf7\xfa\x76\x87\x9e\x87\xeb\xb7\
\x48\x47\x1a\x99\x5e\xa3\x69\x9a\xde\x15\x2d\x0c\xd7\x74\x77\xa2\
\xf6\x66\xf1\xaf\x72\x74\x3a\x8b\x77\x0c\x45\xd1\xfe\xdf\xc0\x5f\
\xd9\xe7\xd0\x46\x47\x74\xc6\x0f\xb3\xca\x48\xf3\x84\xf0\x79\x48\
\xff\x22\xfd\x3a\xf6\x50\x2e\x28\x68\xf8\xb9\x90\xf1\x3c\x2b\x86\
\x49\x39\x5e\xd6\x96\xf1\x2c\x9c\x4b\x51\x09\x8e\x38\x28\x44\x45\
\x38\x22\xa2\xef\x22\x8f\x5c\xab\xc3\xe0\x5f\x11\x47\x1e\x6d\xc8\
\xbd\xdd\xdd\x81\x1d\xfb\x3e\x22\x22\xa2\x37\x23\x87\x5c\x50\xff\
\x8d\x78\x17\x6b\x44\x44\x44\x3f\x42\x54\x84\x23\x7a\x1b\x9c\xf5\
\x2c\xd7\xc5\xb3\xae\x90\xde\x59\x3f\x90\xf7\xd3\x6e\xcf\xe5\xea\
\x09\xa5\xee\x5f\xce\x1d\x2c\x47\xa9\x6b\xd8\xa1\x96\x75\xa8\x48\
\x5b\x02\xba\xd3\xbf\xae\x3d\x07\x72\x2d\xd1\xd1\x68\x4b\x6f\x85\
\xb3\x08\x39\x37\x43\x17\xfd\x39\xb4\x84\x1c\x8d\x7e\x09\xc7\xed\
\x60\xd6\x4d\x44\x44\x7f\x42\x96\x25\x38\x2b\x20\xd5\x91\x2c\xdf\
\xe1\x40\xe9\x6d\x77\x11\xba\x32\x77\x85\x63\x45\x09\xee\x8c\x3f\
\xa5\xa3\x79\xbb\x67\x61\x5f\x1f\xed\x71\xee\xeb\x48\x7b\x44\x84\
\xfd\x7b\xb0\x72\x41\x7f\x96\x27\x22\x8e\x22\xa2\x22\x1c\xd1\xdb\
\x30\x1f\x05\x68\xda\x84\x67\x52\x0b\xd1\x19\x96\x8d\x74\x9f\x71\
\x0d\x40\x81\x9f\x36\x59\x9e\xdd\x7d\xdf\x5d\x5d\x51\x85\x82\x81\
\x94\xbb\xc6\x66\x16\x0a\x8e\xf5\x22\xfe\x5e\xc4\x53\x51\xa0\xa3\
\xed\x28\x1a\xe2\x2a\xfc\x79\xb0\x72\x65\x8d\x40\x51\x3a\xdd\x9d\
\xbb\x47\x1a\x2e\x00\xd6\x7a\x3c\x93\x3a\x19\xb9\x51\xaf\xc3\x9f\
\x4f\x1d\x69\x6d\x7c\x91\xee\x09\x47\x09\xba\x7b\x79\x00\x3a\x5b\
\xd6\x5f\x04\x0c\x77\x36\x6f\x1e\x1a\xc7\x16\x64\x85\xdf\x88\x22\
\x5e\x8e\x44\x01\x76\x66\xd9\xf3\x23\x39\xc6\x09\x9a\x93\x27\xa1\
\x71\x9b\x87\x82\xe0\xd4\xd3\x7f\xc6\x23\x22\xa2\xbb\x48\xd0\xb1\
\x91\xb3\xf1\xd7\x17\xd5\xa3\x6b\x83\xb6\x70\x74\xd6\xcc\x78\x14\
\x38\x08\xb4\x5e\x9f\xe5\xf0\x46\x7c\xaf\x41\x41\xa8\x2a\x51\xf0\
\xc8\xd6\x43\xcb\xae\x57\x20\x41\xc1\x08\xa7\xd1\xf1\xbe\xf4\x0a\
\x14\x80\x69\x07\xe2\xa9\x2e\x46\xc8\x7b\x11\x6d\x74\x63\xba\x1f\
\x45\xd8\xee\x4e\x44\xe4\x88\xce\x91\xa0\xa8\xcf\x8b\xf0\x46\x80\
\x77\x51\xb0\xcb\x7d\x28\x18\xd6\x00\xb2\x63\xc2\x74\x96\xe7\x50\
\x14\x5c\xed\x65\xa2\xdb\x73\xc4\x11\x44\xdc\x69\x89\xe8\x4d\x48\
\x50\x14\xcd\x69\xf8\xa8\xc6\x09\x52\x28\x86\xe3\xcf\x99\x14\x28\
\xdd\xe1\x75\xbb\xfa\x2e\x68\x42\x3b\x52\xee\xae\xb5\xef\x93\x11\
\x13\x4c\x82\xdf\xdd\xfb\xe9\x77\x5d\x9e\x97\x23\x42\x9c\xd0\x71\
\x37\xb9\x88\x94\xf3\x4b\xf0\x97\xc4\xff\x8e\xd5\xbb\x80\x14\xef\
\xeb\xd0\xb5\x01\x83\x52\xef\xba\xfc\x5c\x50\xac\xb1\xc0\x85\xf6\
\x9b\xab\x43\xba\x4d\xe9\xba\x16\x52\x69\x8b\x74\xde\x2f\x85\x20\
\xed\x05\x88\xb9\x84\xef\x9e\x8d\x14\xb5\xb6\x20\xed\x38\x74\x5e\
\xac\x8a\x8e\x7d\x14\xf6\x43\x7b\x50\xc6\x89\xe8\x8a\x90\x24\xc8\
\x27\x6d\x71\xe9\x4b\x48\xd0\xb5\x0d\x1f\x03\xce\x47\xc2\xd5\x30\
\x34\x17\x8e\x47\xf3\x67\x12\x52\x86\x2f\x41\xf4\xb6\xb3\x3e\x74\
\xe3\x56\x6e\x8c\xdb\x83\xbf\x62\xc6\xfb\x45\x74\xad\xc4\xb5\xe8\
\x8a\x8a\x69\x48\x00\xe9\xce\xfc\x88\xa1\x12\x23\xfa\x12\xba\x33\
\x9f\x8b\xe8\x6a\xbd\x0b\xd1\x06\x56\x13\x5a\xb7\xb7\xd3\x91\xdf\
\xb8\xf4\x69\x7a\x9c\x5e\xcb\x59\x3c\x05\x4a\xd7\x5a\x18\x3c\xeb\
\x66\x74\x4f\x7c\x8d\x95\x9d\x3b\x80\xf7\xb3\xda\x1c\xd2\xfb\x02\
\xfe\x6e\xf6\xfa\x54\x5d\xb3\x68\x0c\x74\xe4\x39\x64\x94\x5b\x8e\
\x2f\x85\x75\x28\x66\xe4\x9b\xc5\x7f\xb3\xea\x52\xa4\x73\x5e\x58\
\x44\x9b\xd5\x57\xd2\xd1\xb3\x69\x02\xf0\x51\x74\x7b\x43\x1d\x9e\
\x46\x7f\x00\x6d\x3a\x37\xa2\xa8\xc6\x2d\xdd\x9c\x23\xfd\x19\x61\
\x3c\x95\xce\x50\x44\x4a\xf0\x29\xa8\x7f\x0b\xc0\x7b\x50\xa0\xce\
\x1a\x14\x94\x68\x12\x7e\xfc\xd3\xf3\x2e\x9c\x5f\xe1\xef\x23\x2c\
\x9f\xee\xf2\xcd\xac\xbc\x23\x22\xba\x44\xb4\x08\x47\xf4\x36\x38\
\x62\x39\x00\xdd\xb5\xeb\xee\x71\xdc\x85\x04\x85\xb1\x48\xc1\xa8\
\x44\xbb\xc1\xdb\x91\xd0\x72\x2a\xba\x2a\xe9\x75\x74\x1d\xcd\x02\
\xa4\x0c\xcf\x45\xd7\x49\xd4\x23\x82\x3a\x17\x29\x82\xbb\xf0\x17\
\xc5\x2f\x41\x44\x77\x35\xda\xb5\x5c\x8f\x76\x32\xcf\x40\x77\xe2\
\x9d\x8f\xee\xaa\xdb\x41\xe9\x45\xf0\x05\x2b\xfb\x56\x64\x79\xfe\
\x2f\x4a\x09\xb4\x3b\x23\x1a\xb6\x6d\x12\x62\x18\x45\x64\x3d\x4e\
\x10\xb3\x38\x07\x29\x51\xaf\xa1\x40\x25\x83\x91\xb2\x3d\xc6\xea\
\xfa\x1c\xb2\x3c\x9e\x84\xb7\x40\x2f\x45\x56\xe7\x93\xac\xed\xa3\
\x90\x32\xfb\x0c\x3a\xef\x35\xd6\xda\x56\x81\xae\x2c\x58\x4f\x36\
\x63\x2b\x5a\xbd\xae\x45\xf7\xd1\x3e\x1b\x8c\x83\xdb\x99\x3d\xd5\
\xea\xf4\x96\xfd\x81\xbf\x03\x70\x6f\xea\x9d\x3c\xba\xf3\x78\x97\
\xf5\xd9\x42\x74\xd5\x41\x5f\xb0\x46\xa4\xfb\x6d\x11\xba\xb2\xe4\
\xaf\xf0\xd7\x8d\xdc\x84\xac\x3b\x2f\xe0\x5d\xf7\xaa\xd1\x9d\xc3\
\x83\xd0\xb8\xad\xb5\xdf\x4e\x06\x66\xa2\x6b\x25\x5e\xb4\x3e\x5c\
\x62\x7d\x35\x11\x5d\x4d\xf5\x26\x5a\x0b\x63\xf1\x16\xe8\xa5\x68\
\x9e\x9c\x82\x14\xde\x6d\xf8\xf9\xe4\xe6\xe6\x5a\x34\x9e\x0b\xd1\
\x1c\x1b\x8b\x04\x95\x67\xed\xf9\x78\xb4\x59\x03\xb2\x56\xf7\xd4\
\x55\x54\x11\x11\x87\x13\xd5\x88\x66\xed\xa6\x6b\x6f\x96\x1c\xe2\
\x17\x3f\xc1\xd3\xf3\xff\x8b\x14\xe4\xe3\xd1\x7a\xcd\xa1\x2b\xdc\
\xa6\x21\x9a\x57\x8f\xe8\xf1\x48\x44\x87\x5f\xb4\x34\xa7\x21\x1a\
\xdb\x68\x9f\x07\x23\x7e\xb4\xc2\xde\x1d\x8b\x22\xf9\x57\x23\x1a\
\x3d\x14\xad\xff\x7d\xe8\x7a\x39\x77\x85\xd1\x08\x44\x03\x06\x06\
\xef\x4f\xb7\xb2\x86\xa0\xcd\xc9\xe7\xe8\xc8\x8f\xc6\xa2\xf5\x5c\
\x89\xac\xa1\xdb\x11\xcd\xa9\x42\xf4\xc4\xf5\x45\x15\xda\xfc\x6c\
\x47\x8a\xe3\x0a\x2b\xa7\x0a\xd1\xb3\x29\x48\x51\x7c\x01\x79\x0a\
\x9d\x82\x94\xc9\xc4\x9e\xcd\x46\xde\x2f\xee\xda\x9a\x91\xd6\x57\
\x4f\x59\xff\xcd\x41\xb4\x1f\xab\x47\xa5\xf5\xc7\x6a\xa4\x14\x9d\
\x80\x36\x0d\x9f\xb3\x3e\x9f\x8b\x68\xe1\x38\x4b\x3f\xc4\xfa\x6b\
\xb9\xd5\x2d\xcd\x0b\x43\x5e\x93\xc6\xa9\x96\xc7\x48\xab\xa7\x1b\
\x9b\x46\x74\xfd\xe2\x6b\x56\x96\x8b\x5e\x1d\xe9\x5d\x36\x12\x34\
\xff\x06\xa0\x3e\xef\x8e\x62\xb9\x0c\xf8\x31\xea\xdb\x47\x80\x3f\
\x46\xf3\x7b\x2b\xea\xff\x0a\xc4\xeb\x66\xe3\xaf\x2a\x5b\x8d\x78\
\x5b\x15\x9a\x63\xdb\xad\xdc\x21\x48\xae\xa8\x44\x1e\x0d\x23\xd0\
\x1c\x7d\xdb\xde\x9d\x8f\xf8\xee\x76\xe4\xc1\xd1\x80\x0c\x1e\xf3\
\x2d\x9f\x77\xd0\xfc\x89\x0a\x71\x44\x97\x88\x16\xe1\x88\xde\x06\
\x47\x80\x3f\x88\xac\x94\x0d\x88\x50\x1e\x87\x14\xbe\x8f\x23\x82\
\x3a\x0b\xed\xa6\x0f\x41\x77\xd5\x4e\x42\x3b\xfa\x37\x23\x42\xdb\
\x88\xdf\xe5\x3f\x13\x31\xf7\xc5\xc0\x0d\xf6\x6c\x3e\xba\x8f\xf6\
\x0a\xa4\x34\xef\x47\x8a\xe0\x0c\x24\x20\xac\xb0\x34\x03\x90\x52\
\x93\x65\xd9\x1d\x8e\xac\x7f\x03\x81\xff\xb4\x7c\x5b\x50\xd4\xcd\
\x3b\x90\x72\xd1\x80\xdf\xe5\x1f\x0f\x7c\x0a\xed\x54\x0f\xb7\xba\
\xd6\x5a\x5b\x26\xda\xe7\xdb\x90\x42\x7b\x05\x62\x22\xbb\x90\x15\
\xf7\x3d\x88\xb9\x7f\xd6\xda\x5a\x8b\xae\xe7\x19\x86\x84\x9a\x5b\
\xac\xde\x4b\xd0\xdd\x7a\x23\xac\xac\x21\x56\xdf\x8f\x23\x46\x91\
\xc5\x18\xf2\xf6\x5e\xd1\xfa\xea\x3a\xbc\x80\x30\xc0\xf2\x39\x1e\
\x09\x53\x1f\x41\xc2\xd2\x3c\x74\xaf\x5f\x2b\xb2\x04\x5f\x85\x3f\
\x17\xf4\x1e\x74\x67\xe6\x3e\x24\xc4\xcc\x43\x0c\xad\xaf\xed\xc0\
\xe7\xac\x6d\xab\x91\x70\xec\xae\x88\xb8\x0b\x09\x5d\x33\xac\x3f\
\x0b\x48\xb0\x9b\x82\x14\xd2\x4f\xa1\xb9\x70\x36\xba\x33\x71\x0f\
\x1a\xeb\xf7\x5b\x7f\xdd\x6a\xf9\x16\xd0\xdc\x3e\x0e\x09\x05\xbb\
\xd0\x3c\xbc\xd6\xfe\x5f\x82\xee\x5d\x6e\x40\x82\xe6\x2d\xf8\x2b\
\xa7\xaa\xd0\xbc\x19\x8e\x2c\x5e\x37\xa0\xb9\x79\x0e\x72\x13\x1c\
\x6d\xf5\xa8\xb5\xb4\x9f\x40\x82\x68\x5f\x1b\xa3\x88\xfe\x85\x3c\
\xa2\x51\x5f\x43\x16\xc3\xae\xe6\xb3\x5b\x2b\x83\xed\x6f\x06\x5a\
\x43\x6d\xe8\xce\xf6\x53\xd0\xfa\x3a\x05\xdd\x7f\xdb\x80\x94\xd2\
\x0f\x22\x45\xd6\xad\xd9\x11\x88\xee\x0e\x41\x16\xc9\xe3\x10\x0f\
\xba\x09\x29\x7a\x73\xd1\x1a\xab\xb2\x32\x3e\x64\x65\xb7\x20\x3a\
\x39\x14\xf1\xa3\x21\x68\x5d\x1e\x87\xe8\xf9\x27\xf0\x1b\xba\xee\
\xfd\xe3\xed\xfd\xca\xa0\x0d\xa3\x80\xcf\xd9\xff\x0a\xc4\x1b\xa6\
\x23\xbe\xd6\x84\xbf\x7f\xdc\x6d\xa4\x7d\x0c\x29\x8d\x6d\xd6\x5f\
\x73\x11\x7f\xbc\x04\xd1\xb2\x99\xf6\x7c\xa0\xfd\x9f\x6f\xf9\x5c\
\x8a\x68\x7d\x03\xa2\x6d\x37\x21\x1e\xe0\x68\xfe\x4d\x88\x97\xd5\
\x21\x9a\x53\x8b\xe8\xca\x15\x88\x06\xde\x64\xef\xce\x46\x74\x68\
\x30\xf0\x49\x6b\xd3\x60\xe0\x0f\x11\x9f\x1f\x60\x75\x1c\x8a\xbc\
\xb3\xe6\xa3\xfb\xd7\xcf\x47\x16\xee\xac\xeb\xa3\x06\x22\x85\xf9\
\x51\xa4\x64\x9d\x83\xa7\x87\xd5\xd6\xbe\x0b\x2d\x8f\xc9\xdd\x98\
\x1b\xfd\x15\x09\xea\xff\x2f\xa0\xe0\x69\x4e\x36\xe8\x0a\x79\xfc\
\xb5\x8b\x3b\xd0\x46\xec\xf1\x48\x3e\x58\x8c\xe4\x16\x37\x5f\x06\
\x20\x59\x67\x04\xb2\xd6\x9f\x87\xe6\xea\x12\xfc\x7d\xc1\xed\x68\
\xce\x4c\xb5\x3c\x6f\x43\x9b\x21\x67\x21\xbe\xb7\x17\xad\x8d\xeb\
\x2d\x9f\x0f\xa1\x79\xd7\x86\xe4\x1d\xe7\x59\x18\x11\xd1\x29\xa2\
\x45\x38\xa2\xb7\xa1\x02\x09\xf4\x7b\x81\x3f\x41\x42\x42\xe8\xa2\
\xf3\x32\xba\x88\x7d\x1e\x12\x54\x4e\xb4\xcf\x3f\x43\xc4\xb3\x0e\
\x29\x6a\xef\x20\x65\x63\x35\xfe\x9e\xd5\xd3\xd0\xce\xfe\xbd\x48\
\x41\x18\x88\x18\xff\x18\x64\xe5\x7c\x00\xed\x5e\xe6\xd1\x4e\xe3\
\x08\x2b\xf3\x9f\xe9\x18\xb4\xa1\x88\x98\xf3\x2f\x10\xa1\x3e\x09\
\xed\x96\xbb\x33\xb6\x6e\xe7\x32\xbc\x36\x67\x01\xb2\x52\xfc\x10\
\xad\xbd\x31\x48\x70\x59\x07\xdc\x69\x69\x4e\x41\x0a\xef\x53\x48\
\xd9\xa9\x42\x82\xc3\x71\x48\xc1\xde\x00\xdc\x6d\xf9\x9e\x84\x14\
\x1a\x77\xc9\xfc\x3d\xd6\x6f\xe7\x5b\x59\xd3\x90\xe5\xb0\xcd\xda\
\xb2\x80\xf2\x2e\x75\xbf\xb2\x7c\x57\x21\x86\xf3\x0e\x5e\x81\x1b\
\x8d\x04\xcb\x9d\x56\xee\xb9\x48\xb0\x7a\x09\x29\x7d\x43\xec\x6f\
\xbe\xfd\x56\x8d\x2c\xa4\xef\x5a\x3b\xff\x85\xec\xab\xa0\x8e\x75\
\xb8\xf3\x67\x4d\xa9\x7e\x6d\xa5\xd4\x6d\x30\x8f\x2c\x45\x3f\x41\
\x4a\xef\x54\x24\x18\x9c\x62\xef\x16\xed\xf9\xd9\xc8\x4b\x61\x07\
\x9a\xa3\x5b\x91\x80\x3a\x11\xed\xb0\x3b\xcf\x87\x1f\xa0\xdd\xf1\
\x3f\x42\xf3\xfe\x49\xb4\x1b\xff\x05\xb4\x81\x13\xba\x8a\x61\x75\
\x79\xdc\xf2\x6c\x47\xf3\xe0\x14\xcb\xd7\x59\x91\xc7\xa2\xf9\xb4\
\x89\x23\x13\xb0\x27\x22\xe2\x68\xa0\x02\x6d\x38\x4d\xb6\xbf\xee\
\xc4\x84\x38\x09\xad\x25\xc7\x27\x7e\x8e\xd6\x6b\xbb\x7d\x5e\x8a\
\xee\x5b\xc5\x9e\xd5\x23\x25\xee\x61\xfb\x7c\x02\x12\xec\xb7\xd8\
\xfb\x8b\x80\xfb\x2c\x6d\x35\xf2\x8e\xd9\x86\x36\x46\xef\x41\x3c\
\xeb\x93\x88\x56\x6f\x42\x4a\x5b\x03\x5a\xaf\xc7\xa3\x75\xfe\x4f\
\xf6\xbb\xb3\xde\x6e\xc4\xf3\xbe\xd9\x48\x29\xae\x43\xfc\xb1\x88\
\xdf\x38\xfb\x2e\xa2\x3f\x23\xad\x5d\x6f\xda\xf3\x37\xf0\xeb\x3a\
\x67\xf5\xbe\x1b\x59\xa1\xeb\xac\x8c\x9f\x22\xfe\x94\x43\x4a\xcb\
\x62\xa4\xc8\x36\xa3\x8d\xbd\x77\x90\x02\x72\x27\xe2\xa3\xaf\x01\
\xbf\x67\x6d\xfd\x01\xf0\x07\x96\xdf\x7f\x58\x39\x57\x22\xa5\x7f\
\x2a\xe2\xc3\x3b\x10\x9f\x18\x8b\x78\x87\x8b\x03\xb2\x0b\xd1\xb1\
\x2a\x44\xdf\x1e\x42\x74\x71\x2e\xda\xe8\x7d\x1a\xcf\x0b\xf7\x5b\
\x7e\x1b\x32\xc6\x71\x96\xb5\xbb\x19\xd1\xce\x4b\x90\x12\xbe\xdf\
\xde\x9d\x6b\x65\xe7\xac\xbf\xc3\x38\x24\x11\xa5\xa8\x41\xfd\x7c\
\x1c\xea\xb3\x83\x41\x01\x7f\xb7\x35\x68\xfc\xef\xc0\xf3\xc6\x31\
\x68\xa3\xa3\x05\xf1\xa7\x47\xd1\xe6\xcd\x72\x34\x1f\x66\xa2\x71\
\xbc\x03\xef\xd9\x34\x11\x6d\x66\x84\x7c\xf3\x0c\xe0\x97\x48\x16\
\x01\xc9\x54\x03\xd0\xd8\xbf\xdd\xd3\x1d\x19\xd1\xfb\x11\x15\xe1\
\x88\xde\x86\x0a\xa4\x8c\x0d\x45\x2e\x56\xcf\x04\xbf\x25\x78\x17\
\x67\xe7\xb6\x5b\x8b\x3f\xdb\x5a\x85\xdc\xa6\x56\x22\x22\x1b\x46\
\xcc\xcd\x23\xa2\xdc\x10\xbc\x5f\x83\x04\x9d\x1d\x48\x38\x39\x1e\
\x09\x03\x8f\x20\x21\xc6\x5d\x3b\xd4\x4a\xc7\x2b\x88\xf2\x48\x40\
\xfa\x57\xe0\x62\xb4\x6b\xfe\x2e\xb0\xd9\x7e\xcb\xf2\xb6\xa8\x43\
\x56\x02\xa7\x20\xb9\x8b\xe3\xeb\xad\x3c\x67\x35\xad\x42\x0a\xe5\
\x0c\xe4\xb6\xe7\x5c\xdb\x40\x4c\xbd\xd5\xf2\x2a\xe0\x15\xef\x72\
\xfd\xe2\xca\x79\x04\x09\x43\x33\x32\xea\x95\xe0\x2d\xd7\xce\x72\
\xe0\xea\x5f\x83\x18\x55\xab\x3d\xdb\x6b\x79\xe7\xac\x2e\x2e\x38\
\x46\x95\xd5\x7f\x8f\xfd\x2d\x42\x4c\xc8\xb9\x8a\xf7\x45\xe5\xaa\
\x88\x77\xc3\xaf\xc2\x9f\x71\x9a\x87\x98\x70\x78\x5f\x62\x33\x1a\
\x8f\xa2\xf5\x67\xad\xf5\x57\xa3\xbd\xbb\x0b\x09\x98\xcd\xf6\xe7\
\x5c\xc9\x9c\x3b\xa3\xb3\x90\xec\x40\x82\x67\x8d\xbd\xbf\x1f\x8d\
\x4b\x13\x5e\xf0\xc8\xaa\x67\x3d\xa5\xf3\xa3\xce\xea\xe1\xea\xf7\
\x4b\xb4\x6e\xa2\x97\x50\xc4\xb1\x8c\x56\xe0\x9b\x48\xb0\x5e\x46\
\xd7\xd7\x97\xe5\xd0\x26\xe8\xd7\xd1\xda\x68\x46\xf4\x6b\x30\x5a\
\x53\x4d\x68\x7d\x56\xa3\x35\xe9\xd6\xec\x9d\x48\x48\x5f\x8a\x36\
\x58\xab\x11\xef\x71\x6b\xcc\x29\xc1\xcf\x23\x05\x72\x3a\x3e\x68\
\x5d\xb8\x41\x96\x8e\xea\x5e\x8b\xa7\xb7\x39\xa4\xe8\x4e\xb1\xdf\
\xd2\xef\xa7\xdf\x73\xe7\x33\x13\x7b\x6f\x10\xde\x0d\x38\x4d\x7f\
\x5b\xf1\x34\xbf\x01\xb9\x48\xcf\x47\x9b\xa8\x6b\x11\x7d\x71\x75\
\x0c\xfb\xc1\x29\xa3\x79\x2b\x2f\x17\xf4\x8d\xa3\x1d\x45\xcb\xf3\
\x55\x64\x95\x1d\x8a\x36\x99\xd7\x02\xdf\x42\x9b\x70\x57\x21\x5e\
\x79\xaf\xe5\xe7\x68\x62\x2b\x9e\xdf\xba\x73\xd4\xa7\x23\xde\xbc\
\xda\xca\x0a\xef\x65\x0f\xc7\xf1\x2c\x44\x27\x6f\xb2\xba\x0c\xb1\
\xb1\x79\xd8\xea\xf7\x3d\xa4\x64\x39\x5e\x1e\x69\x5d\x36\xdc\x46\
\xc9\xdf\x20\x63\xc2\x0b\x74\x6f\xc3\x20\x74\x57\xaf\x46\x0a\xf4\
\xab\xf8\xb3\xda\x93\x91\x97\xc0\x36\x24\x47\x80\x3f\xff\xbb\x1f\
\x3f\xe6\x7b\xf0\x6b\x63\x8f\xfd\xee\xd6\x55\x05\x9a\x9b\x3b\xf1\
\x7c\xf3\x6e\x34\x77\xae\x43\xf3\xc8\x05\xba\x73\xb2\x51\x44\x44\
\xa7\x88\x84\x20\xa2\xb7\xa1\x80\xac\x93\xf7\x20\xb7\xb3\x71\x78\
\x61\x21\xb4\xb0\xe6\x10\x51\xdc\x84\x88\xe5\x2e\xb4\x63\x3e\x12\
\x11\xca\x76\x64\xf1\x1d\x8c\x27\xb6\xef\x20\xc6\x38\x05\x31\xe2\
\xab\x90\x3b\x57\x11\xdd\xfb\xfa\x2e\x3e\xa8\xc3\x30\xcb\x37\xc1\
\xbb\x25\x87\x44\x35\x8f\x84\x8d\x36\xa4\x44\xac\x47\xee\x38\x03\
\xc8\x26\xbe\x39\xa4\x68\x4c\x47\x0a\xfe\x62\x64\x15\x18\x40\xe9\
\x3a\xcc\x59\xbd\x17\x21\x2b\xef\xe3\xd6\x4e\x77\x9e\x29\x9f\xaa\
\x83\xfb\x9f\xee\x97\x75\xf8\x5d\xef\xe5\x48\xd0\xa9\xa4\xa3\xe0\
\x85\x3d\x3f\xc3\xea\x76\xa6\xf5\x43\x93\x3d\xdf\x60\xfd\x79\x06\
\xb2\x0e\x9f\x83\x14\xea\xe5\xc8\x8d\x69\x2a\x72\x97\x7b\x3f\xfe\
\xde\xe2\xff\xb4\x7e\x9e\x8f\x2c\xd1\x97\x90\xad\xa0\x1d\xeb\xc8\
\x23\x41\x77\x20\xb2\x94\x4c\x40\x4a\xf0\x47\x90\x10\xe6\xce\x4b\
\xbb\xa0\x3c\x0b\x91\x95\x66\x9c\xf5\xe1\x3b\x41\x9f\xed\xb7\xf7\
\xdd\xe6\x46\x58\x46\x25\x12\xee\x8e\x43\xbb\xe6\x23\xd1\x7c\x58\
\x87\x5c\xca\x26\x23\x37\xe8\x06\xe4\xc9\x50\x11\xbc\xeb\xfe\x87\
\xf3\xa3\x12\x09\x95\x2d\x68\xde\xbe\x89\x76\xda\xa3\xe0\x10\x71\
\xac\x23\x87\xd6\xc5\xcf\xd1\x5a\xe8\x4a\x80\xcf\xe3\x85\xe7\x2d\
\x48\x01\x70\x4a\xa6\x53\x98\xda\xd1\xa6\x5e\x05\xfe\xec\xad\xe3\
\x13\x2f\x23\x0b\xed\x24\xe4\xa5\xb1\x15\x6d\x56\xd5\xdb\x6f\xa3\
\x10\x7d\x70\x65\xb9\x3a\x86\x6b\x6d\x24\x5a\x93\x15\x48\x59\x1c\
\x80\x94\xbf\x19\x48\xb9\x7b\x8b\x8e\x1e\x49\x69\x9e\xf1\x0e\xa2\
\x1f\x0b\xd1\xa6\xee\x02\x44\x63\xdc\xef\xe9\x63\x3d\x23\x10\xad\
\x9f\x89\x14\xd3\xd7\x10\x3d\x5f\x83\x94\xd6\x66\x44\xb3\x5d\x5d\
\x9d\x42\xbc\x06\xd1\x9a\xc9\x88\x77\xee\x44\x3c\xf0\x66\x64\xb9\
\x6b\x46\x6e\xd0\x39\xa4\x40\x9d\x82\x14\xa1\xb7\x91\xc5\x76\xb1\
\x8d\xcd\x2f\xf0\xc7\x81\x72\x94\xf2\xf8\xb0\x5d\x03\x2c\x8f\xa7\
\x80\xc7\xf0\xbc\x30\xec\x03\xe7\xd1\x32\x1b\xf8\x5b\xe0\x2f\x80\
\x3f\x43\x4a\xf7\x79\x88\x16\xbb\xcd\x00\xb7\x31\x10\x2d\xc1\x5d\
\xe3\x0d\xb4\x89\xd0\x9d\xc8\xda\x39\x34\x8f\xa7\xa2\x79\x7b\x13\
\x9a\x3f\xaf\xe0\xf9\xd1\x3c\xfb\x7f\x17\xda\x04\x09\xd7\x45\x7a\
\x6d\xb8\xcf\x61\xb9\x15\x88\x3f\xbe\x89\xd6\xcb\x2b\x56\xb7\x71\
\x68\x2e\x4d\x40\x4a\xf1\x5b\x68\xde\xc4\x31\x8e\xe8\x16\xa2\x45\
\x38\xa2\xb7\xc1\x05\xaa\x7a\x0b\x31\xce\xd9\xf6\x6c\x8f\xfd\x5e\
\x83\x0f\x7e\xf1\x0e\x52\xf4\xbe\x87\x98\xf3\x19\x88\xc0\xbe\x83\
\x98\xef\xa9\x48\xa1\xdc\x60\xef\x2f\x45\x67\x32\x3f\x8c\x76\x24\
\xef\x46\x8a\xf2\xe5\x48\x70\xd8\x8e\x18\x74\xce\xca\x5e\x8d\x76\
\xa7\xcf\x45\x42\x92\x0b\x4e\x92\x43\x02\x4f\x68\x31\xfe\x0e\xb2\
\xd8\xcd\x40\x42\x45\x9a\x08\xe7\x11\x63\xf9\x05\x52\xc0\x8b\x68\
\x37\x7c\x27\x22\xe0\x6e\x37\x75\xa5\x95\x75\x3f\x52\x26\x5d\x3d\
\xda\x91\x90\xb1\xca\xf2\x2b\x58\xda\x46\xa4\xb8\xee\xb4\x32\xf6\
\x20\x61\x6a\x25\x12\x4c\x2e\xb4\xe7\x6b\xac\x1f\xd7\xe3\x5d\x9c\
\xc1\x0b\x8e\x95\xe8\xac\x4e\x33\x72\x73\xab\xb1\xb2\xb6\x5a\xdb\
\x2e\xb6\xfa\xac\xb4\x36\x14\xad\xef\x6e\xb1\x3a\xdc\x85\x5c\xa8\
\x9b\xad\x8c\xfb\x91\x2b\xda\x7e\x24\x30\xbd\x88\x04\xce\xbe\xc4\
\x9c\x72\x68\xce\x7c\xd3\xfa\xe7\xc3\xd6\x2f\x4f\xa0\xcd\x9c\x59\
\x68\xee\x35\x23\x01\x7a\x81\xf5\xd9\x83\x88\x99\xbf\x8b\xe6\xe3\
\x47\xd1\x1c\x7a\xc4\xfa\x6b\x25\xde\x9a\xec\xe6\xe0\x44\xa4\xe8\
\xbe\xcf\xca\x7d\x1d\xb9\x5a\xbb\xf7\xf7\x01\xdf\xb6\xb2\x56\x20\
\xe1\x74\x6d\x30\x1e\x2e\x90\xd7\x2e\x34\xde\x6f\x22\xcb\xf2\x65\
\xf8\x4d\x9a\x4d\xc4\xcd\xd1\x88\x63\x1f\xe5\x3c\x72\xd2\xc8\xa1\
\x75\xb1\x26\xf8\x0e\xa2\xc5\x4e\xf9\x75\x96\xce\x87\x10\xbd\x77\
\xe7\x17\x9f\x42\x8a\x61\x23\xf2\x5a\x72\x96\x64\xd0\x3a\xbc\x18\
\xf1\x9f\xed\x68\x3d\xe6\xf1\x16\xd8\x46\xb4\xde\x9a\x2c\x9f\x85\
\x68\x5d\xbe\x83\x68\xbf\xe3\x67\x67\x21\xba\xf1\xa8\xa5\x71\x0a\
\x49\x13\xa5\x34\x22\x8f\xe8\xc4\x4f\x11\xad\xcd\xa1\xe3\x12\xcf\
\xa3\x4d\xd7\xf4\xb5\x81\xce\x43\x65\x0a\x52\x9a\x5f\xb3\xf4\x5b\
\x11\x2f\xbc\xc1\xea\xbd\x14\xcf\x67\xdc\xf1\x8f\x9f\x22\x97\xe7\
\x8f\x20\x5a\xf5\xdf\x68\x13\x60\x0b\x72\x67\x9d\x68\xbf\x8f\x44\
\xb4\x6f\xab\xb5\xa1\x09\xd1\xbb\x66\x7c\x6c\x89\x1f\x22\xeb\xe0\
\x1a\x2b\xa7\xc5\xfa\xca\x79\xc1\xac\xb4\x7a\xdc\x8f\x36\x06\x66\
\x5a\x3b\x8b\x56\xf6\x3b\x78\xeb\xf8\x18\x6b\xc7\x0a\xbc\x55\xfc\
\x59\x6b\xdf\x30\x44\x2f\xf7\x1f\xd6\x59\xd6\xf7\xd1\x5d\x5e\x90\
\x43\x72\xd7\x42\x74\xbe\xbd\x88\xc6\xfd\x6b\x68\x7d\xed\x44\x63\
\xba\x14\xcd\x95\x5b\x10\xaf\x79\x0a\x2f\xf3\xec\x0d\xf2\x71\x1b\
\x15\x4d\xf8\xf1\x76\xc7\xcd\x9c\xdc\xf6\x3e\x34\x07\xdb\x11\xaf\
\x5d\x83\xe6\xc7\x07\xd0\x5c\x7c\xda\xde\x8f\xfc\x2c\xa2\x4b\xe4\
\x96\x4c\x1a\x58\xff\xed\x1b\xa6\x0f\x1d\x3b\xa8\x92\x24\xda\x02\
\x22\x8e\x30\x5a\xda\x13\x3e\x7f\xef\xba\xfa\x3b\x5f\xdf\x7d\x3b\
\xd9\xf7\xca\xb9\x9d\x72\xb7\x2b\x1f\x7e\x07\xef\x8a\xeb\x7e\x73\
\xee\xa8\x6e\x47\xbd\x2d\x48\x5b\x19\xa4\x4f\x82\xf7\xaa\x28\x0d\
\xb1\xef\x5c\x94\x9d\x8b\xf5\x70\x74\x4e\xf6\xc7\x88\x79\xbf\x0f\
\x45\xb8\x0c\xa3\xea\x86\x6e\x60\xe0\xdd\xb8\xa0\xf3\xeb\x82\x9c\
\xeb\xb3\x13\xb6\x1c\xd1\x0f\xeb\xe2\xae\x90\x08\xd3\x55\x06\xf5\
\x4f\xa7\x4d\xbb\xcb\x85\x6d\x76\x01\x9c\x5a\x83\x77\xd2\xd7\x22\
\xb8\x3e\x76\x3b\xae\xce\x92\x99\xd5\xbf\x61\xe4\x67\xd7\x97\xee\
\xea\x83\xac\xb6\x0c\x41\x16\xe1\xfb\x10\x63\x3a\xd6\x50\x00\x3e\
\x83\x18\xf7\xbd\x64\xbb\x78\xbb\xfe\x72\x6e\x7b\xce\xad\xd1\xf5\
\x47\xe8\xc6\x98\x47\xf3\x2c\x7c\x1e\xf6\xa1\xb3\x44\x85\x42\x2e\
\x41\x5e\xe1\x99\xf3\x36\x4a\xe7\x73\x01\x6f\xf1\x08\xdd\xe6\x3b\
\x9b\x1f\xce\xba\xd2\x46\xdf\xda\xa4\x88\xe8\xbb\xa8\x46\x67\x76\
\xef\x40\x9e\x29\x87\x22\xec\x86\xeb\x21\x0d\x47\x5f\x43\x7a\xe9\
\xd6\x78\x1b\xa5\x96\x2b\x82\x34\x8e\x96\x86\xfc\xc8\xd1\x8d\x34\
\xef\x02\xbf\xfe\xdd\xef\x8e\xf6\xa7\xe9\x76\xb9\xf7\x09\x7e\x73\
\x9e\x43\x6d\xf6\x2c\x4d\x93\x13\x44\x93\xff\x08\xf8\x3b\x64\xb9\
\x6e\x0b\xf2\x08\xf9\x85\xe3\x15\xe1\x91\x8a\x90\x66\x39\x9a\xe3\
\xf8\x54\x48\xf7\xab\x90\x17\xcc\xfb\xd1\x99\x61\xc7\x3b\xdd\xbb\
\xce\x7d\x3c\x17\xe4\xef\xde\x2d\xa4\x3e\xa7\x79\xa6\xe3\x85\x61\
\x1f\xa4\xf9\x71\x38\x86\xae\xce\xe1\xf5\x88\xfd\x1d\xce\x2b\xe0\
\x8b\xc8\x8a\xde\x1d\xef\x89\xce\x90\x76\xbf\x77\xc7\x80\x42\xbe\
\xe5\xf8\x93\x5b\x17\xa1\x27\x80\x1b\x9b\x70\x1c\xd3\x6b\x33\x94\
\x8d\xd2\x7c\xd3\xd5\xa1\x12\x7f\x5b\x47\x38\xaf\x22\x22\x42\x24\
\xc8\x70\x73\x1b\xf0\x85\x68\x11\x8e\xe8\x6d\x08\x09\x57\xd6\x1d\
\xb4\x49\xc6\x6f\x8e\xe0\xb9\x77\x1d\x41\x4f\xbf\xeb\x9e\xb7\xa5\
\xbe\x3b\xe5\xc5\x61\x02\x0a\xe6\xb1\x0e\x11\xdb\x17\xf1\xe7\x4e\
\xb2\xea\xe9\xf2\xea\xce\x7d\xb9\xce\xd5\xce\x7d\x4e\x2b\xa5\x85\
\x32\xe9\xc2\x7b\x1a\xd3\x69\xd3\x6e\x6f\x49\xea\xbd\x30\x50\x55\
\x16\x63\x70\xcf\xd2\xf5\xca\xea\xdf\x34\xb3\x6c\x4b\xbd\x13\xd6\
\xa5\xdd\xfa\xf5\x09\x8e\x4d\x25\xb8\xbb\x70\xcc\xbb\x35\xf5\x3d\
\xec\x8f\x30\x80\x55\x68\x8d\x87\x8e\xf3\x31\x9c\x47\xc5\xd4\xff\
\x10\xe9\xf7\x9d\xe2\x5b\x48\xbd\xd3\xd9\xfc\x68\x4f\xe5\x15\x11\
\xd1\x9f\xd0\xd9\x5d\xa9\xe1\x3a\xcc\x5a\x6b\x61\x1e\xa4\xd2\xa6\
\xf9\x51\x67\x7c\xad\x2d\xf5\xbe\x53\xf0\xca\xd1\xed\x2c\xbe\x18\
\xbe\x17\xd6\x37\xdd\x3e\xb7\xe6\x57\x22\x7a\x95\xde\x00\x0b\xcb\
\x0d\x83\xed\x75\xd6\x0f\xe9\xba\xb8\x3b\x60\xaf\x44\xd6\xf2\xb4\
\xa7\x49\x16\xff\xcd\xea\xf3\xae\x78\x61\x16\x9d\x4c\xa3\xaf\xde\
\x61\xdf\xdb\x90\xbe\x37\x1a\x3a\xf2\xc1\xf4\xba\xc8\x5a\x7b\xe9\
\x79\x5e\x4e\x36\x82\x8e\xf3\x28\xa1\x74\x2d\x45\x25\x38\xa2\x5b\
\x88\x8a\x70\x44\x44\x29\xf2\xc8\xbd\xea\x2d\x3c\x03\x5e\x4b\x74\
\xb1\x39\x18\xb8\x80\x5a\x2e\xa8\x56\x44\x44\x44\x44\x44\xcf\xa2\
\x09\xb9\x34\x1f\xa9\x48\xfe\x39\x74\x8c\xe8\xef\xe9\xfa\x1e\xe7\
\x88\x88\x88\x88\x1e\x45\x54\x84\x23\xfa\x3a\x42\x97\xdd\xae\x90\
\x76\x3d\x76\xc8\x77\xf1\x4e\xe8\xbe\xdd\x13\x0a\xf3\x81\xb4\xf1\
\x50\x71\xa0\xed\xec\xeb\x0a\x70\xda\x3a\x93\x76\x89\xee\xa9\x39\
\xd1\x5d\x64\xcd\x9d\x63\xa1\xde\x11\x11\x87\x13\xe1\x1a\xee\xe9\
\x60\x4a\x47\x6a\xfd\x85\xc7\x83\xba\x93\x96\x8c\xb4\xa1\xcb\x6a\
\x16\xc2\x60\x7f\xed\x41\x5e\x21\x4f\xed\xec\x06\x81\x90\x9f\x66\
\x95\x7f\x24\x91\xd5\xb6\xb0\xee\xee\xb7\x84\xce\xfb\x20\xcc\x2b\
\x3c\x9a\x02\xe5\xc7\x34\x7d\xf4\xeb\x58\xa3\xbd\xae\x8f\xc2\x7a\
\x1f\x4e\xb9\xa4\xab\xe8\xef\x07\x52\xcf\xae\xc6\x2e\xa2\x9f\x21\
\x2a\xc2\x11\x7d\x19\x95\x28\xe0\xc8\x9b\x94\x06\x88\xca\x42\x1e\
\x05\xd6\x5a\x8b\x0f\x8a\xd5\x15\x72\x28\x92\xaf\xbb\x1f\x71\x02\
\x0a\x08\x71\x34\xcf\x21\xd5\xa0\x20\x56\x2f\xd3\xbd\xe8\x8e\x87\
\x82\xc4\xda\x38\x1a\x05\x40\xe9\xef\x70\xfd\x71\x0e\xfe\x0c\xdb\
\x76\xe4\x4a\xbf\x13\x45\x56\x1d\x85\xae\x71\xe9\x8d\xc8\xa3\xf5\
\xf1\x1a\x0a\xf4\xe3\x04\xb6\xe9\xd6\x9e\x15\x44\x81\x21\xa2\x6f\
\x23\x41\x34\x74\x1e\x8a\x78\xdb\x82\x68\x69\x4f\xdd\x31\x9b\xa0\
\x80\x8b\x35\x28\xb8\xe2\xe1\xaa\x83\x0b\x28\x75\x26\x3a\xf2\xb3\
\xb4\x8b\xb4\xc3\x51\x44\xe7\x2d\xc1\xf3\x22\x70\x32\x3e\x50\x65\
\x5a\x59\x73\x77\x26\x2f\xa5\x94\x9e\x8c\x41\x81\x2c\xf7\x22\x77\
\xec\x17\xe8\xe8\x0e\x8e\xb5\x79\x0c\x0a\xee\x35\x00\xf1\xd4\x4d\
\x47\xb2\xb3\x53\x58\x88\x82\x3c\x6d\x0e\xea\x3e\x18\xdd\xb1\xec\
\xae\xb4\x7a\x15\xd1\x47\x17\x65\x3c\x6b\x7c\xdc\x5d\xd2\xeb\xd0\
\x4d\x0b\xeb\xac\x5d\xad\x64\xd3\xd4\x04\x45\x3e\x6e\x47\x01\xd5\
\xe6\x23\x9e\xd1\x7c\x14\xdb\x7e\x28\x48\x50\x50\xb6\x3a\x14\xc9\
\x19\x6b\xe3\x39\x68\x9e\x6c\xe5\xd0\xe6\x71\x2d\x92\x39\x36\x72\
\x68\xee\xce\x09\x0a\xe0\xd9\x82\x02\x81\x46\xde\x16\x01\x1c\x7b\
\xbb\x4e\x11\x7d\x1f\x45\xfc\x39\x25\xb7\x1b\xdb\x1e\x7c\x0f\xd3\
\x84\x01\xaf\x48\xa5\x75\x01\x9e\xae\x46\x4c\x26\x7c\xc7\xe5\x95\
\xa4\xca\x9a\x82\xee\x5e\x2c\x04\x7f\x61\x19\x85\x54\xfe\x03\x51\
\xa4\xe0\xa1\x88\x61\x4e\xc9\x68\x43\x31\xe3\x59\xd8\x16\x87\x24\
\xf5\x7b\xd6\x7b\xe9\xfe\x28\xe2\xef\xcf\x1b\x16\xe4\xe1\x7e\x4f\
\xe7\x9b\xee\xaf\xac\xf2\x92\x8c\x67\x2e\x6d\xab\xb5\xf1\x1c\x22\
\x13\x01\xf5\xcf\x0c\x74\xf7\x66\x13\x12\x5c\x16\x00\xbf\x8b\xce\
\xc8\x0d\xc5\x5f\xb3\xd2\xd9\x3c\xee\x6a\x9e\xa4\x2d\x2a\x2e\xb0\
\x48\xf8\x6e\x7a\xec\xd3\xf3\xbb\x40\xe9\x1a\x70\x3b\xec\x33\xf0\
\xf7\x3c\x16\x90\x80\x3a\x07\x09\x85\x59\x6b\x24\x22\xa2\xb7\xa3\
\xb3\x73\xbf\xe9\x74\xb5\xe8\xda\xbb\xf3\x90\xa2\x36\x04\xb8\x1d\
\x45\x7c\x77\xe7\x19\xd3\xf3\x3f\xbd\x46\xa1\xe3\xd9\xc7\x42\x46\
\xda\xa4\xcc\xb3\x90\x36\xbb\x20\x2e\xe3\xf0\xeb\xbe\xab\xf2\xb3\
\xda\x9a\xa6\x37\x45\x14\x21\x7e\x06\x3e\xba\x35\xa9\xfc\xda\x83\
\xcf\x17\x23\x05\xb0\x3d\x55\xd6\x04\xb4\xb9\x97\xae\x5b\x11\x29\
\xb2\xd7\x22\x25\x3a\xac\xeb\x7b\x91\x42\x58\x83\xce\x0d\x57\x67\
\xb4\xa7\xdd\xea\xf6\x01\x7b\x7e\x06\xfe\x6a\x43\xe8\x9c\xaf\xa5\
\x95\xa3\x2c\xf9\xa0\x5c\x9f\x85\xf9\x9c\x8b\x36\xb6\xc3\x32\x4f\
\x47\x1b\xcd\x7b\xd1\x46\x49\xad\xa5\x9b\x82\x0f\xae\x99\xce\x27\
\xb1\x7c\x86\xa0\xab\x17\x27\x5b\x7b\x16\x66\xcc\x29\x57\xd6\x75\
\x48\x49\xcb\x5b\x5f\x55\x91\xdd\x8e\xce\xf8\xf9\xe1\x46\x77\xd7\
\x51\x11\x29\xfe\x17\x04\xe9\xf3\xe8\x1a\xad\xc9\x78\x7e\xe3\xf2\
\x4c\xf3\xaf\xac\xf1\x08\xe7\xe2\x1c\x14\xb0\x34\xfd\x7b\x57\x32\
\x4e\xd6\xda\x1a\x87\xd6\x57\x77\x78\x72\x3c\x5f\xde\x4f\x10\x2d\
\xc2\x11\xbd\x0d\xa7\x23\x66\x33\x10\x85\xd7\x1f\x83\x76\xa1\xf7\
\xa3\xeb\x20\xf6\x21\xc6\x94\x43\x57\x35\xac\x46\xbb\xa7\x6e\xb7\
\x6f\xb6\xa5\x7d\x01\xed\x5c\x3b\x62\x5e\x87\x88\xf5\x04\xfb\xfd\
\x39\x7b\x7e\x0a\x5a\x07\x7b\xf1\x57\xdd\x9c\x87\x17\x44\xaa\x91\
\x85\x60\x5d\xf0\xfe\x5e\x74\x35\xc3\xf1\x88\x48\x9f\x8b\x82\x82\
\xac\xb7\x77\x26\x5a\xda\x3c\xda\x41\x5e\x63\xe9\x86\xa2\x6b\x25\
\x0a\x96\x3e\xdc\x35\x1f\x61\x75\xaf\xb1\x74\x2f\x5b\x7e\x67\xd8\
\xb3\x01\xe8\x4a\x80\x49\x96\x6e\xaf\xf5\x47\xc8\x58\x6a\xd1\x95\
\x1d\x63\xad\x2d\xaf\xd8\xbb\xf3\xad\x6f\xc7\xa1\x6b\x24\xde\xb2\
\x76\x2d\x41\x4c\xe1\x5d\xb4\x8b\xfd\xac\xbd\xbb\xc4\xbe\x2f\xb5\
\x76\xbb\x7c\x87\x23\x85\x3f\x2a\x44\xa5\x58\x83\x22\xd8\xba\xbb\
\xab\xff\x10\xcd\xa1\xe7\x91\x40\x53\x81\xee\x0f\x9e\x89\xae\x49\
\x71\xf3\x78\x0a\x12\x8e\x40\x7d\xbd\x1e\x5d\xf7\x31\xd2\xfe\x9a\
\xd1\x98\x8f\x43\x42\xd5\x2b\x68\xae\x9e\x86\xbc\x10\x26\xa0\xb1\
\xa9\x47\xc1\x6f\x16\x22\x21\x75\x1b\x9a\xdf\x03\xac\xcc\x81\x68\
\x83\x67\xa9\x95\x39\xda\xea\xb0\x09\xed\x8c\x37\xa2\x71\x75\x73\
\x6d\x22\xba\xf6\x22\x9c\xcb\x39\x34\x27\xc3\xc8\xe9\x11\x11\xbd\
\x11\xb5\x68\xbd\xec\xa6\xf3\x33\xaa\x4e\x80\x9f\x06\xfc\x15\xfe\
\x8a\xb1\x76\xc4\x4b\x56\x20\xe5\x6c\x3e\xda\x04\x7c\x09\x59\x01\
\x4f\x45\x6b\x60\x82\xbd\xe3\xae\x29\xda\x85\xf8\xd1\x60\xb4\x16\
\x5f\x44\x6b\xed\x14\xa4\x34\xbd\x88\xd6\xed\xa9\x88\x1f\x55\xa3\
\x35\x39\xc7\xd2\xad\x42\xbc\x6c\x3b\xfe\x9a\xc0\xe9\x19\xe5\xcf\
\xb7\xf7\xc7\xa2\xb5\xfb\x2c\xa5\x71\x18\x72\x96\xe7\x1c\x3c\xdf\
\x1c\x82\xee\xf0\x7d\x17\x59\xc4\xc2\x9b\x01\x66\x03\x27\xd8\xbb\
\x4b\xad\x8e\x0b\x11\xdd\x7a\xd9\xea\x36\xc0\xde\xd9\x61\x6d\xae\
\x44\x34\xed\x78\x6b\xdb\x4b\x88\x27\xa5\x83\x1d\xcd\xb0\x72\xd7\
\xa2\xcd\xc2\x76\x6b\xf7\xf9\x56\xd6\x5e\xab\xa7\xdb\x44\x9c\x87\
\x14\xf0\x45\xd6\xbe\xa7\x10\x5d\x3c\x0d\x29\x55\x1b\xac\xac\xe1\
\x78\x2b\xe4\xbb\x28\x7a\xb8\xc3\x34\xab\x5b\x8d\x8d\xe1\x72\xfb\
\x3e\x08\xd1\xc7\x36\x3c\xff\x1d\x6f\x79\x37\xe1\xef\x7e\x77\x75\
\x1f\x8b\x36\x7d\x2b\xac\x7e\xef\xd8\x7f\xe7\x35\x33\x1e\x79\xfe\
\x3c\x6f\xf5\x99\x6d\xf5\xd9\x84\xf8\x66\x03\x5e\xfe\x70\x7c\x3a\
\x6f\x6d\x9c\x89\xbf\x87\xba\xd9\xea\x37\xc4\xe6\xc0\x6a\xab\xe3\
\x10\xc4\x8b\x47\xd8\xf3\x57\x91\x6c\x70\x12\x7e\xc3\xe4\x15\xfc\
\xf5\x5f\x87\x13\x89\xf5\x57\x1d\x9a\xd7\x5d\x29\xdc\xa1\x1c\x12\
\x7e\xcf\x5b\x1f\xae\x41\x96\xf6\x51\x68\x93\x69\x9b\xf5\xef\x50\
\x34\x5f\x9f\xb5\xbe\x1c\x81\xd6\xc7\x20\xe4\x11\xf1\x0e\x9a\x8b\
\x27\x5b\xbb\x97\xa3\xf5\x74\x1c\xb2\x10\xbf\x84\xd6\xfb\xc9\x56\
\xee\x18\x4b\xb3\x02\x19\x07\x96\x58\x19\x6f\xdb\xf3\x2d\x68\xfe\
\x57\xd8\x38\xcc\x42\xf3\xd9\xc9\x8b\x8b\xed\xb7\xf1\xc8\x92\xfd\
\x22\xd9\xde\x0b\x11\x7d\x08\xd1\x22\x1c\xd1\xdb\x70\x0d\xba\x6e\
\x67\x1f\x62\x2c\x1f\x42\x04\x6a\x1c\xba\xa7\x77\x08\xda\x35\x3e\
\x1f\x31\xaf\x0f\x20\xc2\xb9\x00\x7f\x1f\xeb\x34\x74\x9f\xdd\x40\
\x3c\x13\x72\xf7\x0c\x3b\x26\x7f\x1d\x52\x36\x3e\x87\x18\x8a\xbb\
\x2f\x78\x2c\x62\x90\xdb\x11\x31\xbe\x1a\x31\x83\x0b\x90\x92\xbe\
\x1d\x31\xe9\xf7\x23\x06\xd6\x62\xe9\x27\x21\x37\xd3\xb1\xe8\xba\
\x9d\xa1\x48\x58\xf8\xac\xd5\xe7\x74\x74\x7f\x5e\x9b\xbd\xff\xbe\
\xa0\xcd\x8e\xa9\x7d\xda\xf2\xa9\xb3\x3c\xc6\xa2\x1d\xf6\x0b\x91\
\xc0\xb0\x08\xf8\xa0\xb5\x7b\x86\xb5\x71\x00\xfe\x3c\xd9\x07\x90\
\x10\xb1\x0f\xed\xc2\x5f\x61\xf5\xb8\x0d\x09\x2c\x89\x7d\x1e\x8f\
\xac\x03\xe7\x5b\x1b\xde\x6f\xf5\x19\x05\xdc\x6a\xed\x4e\xac\xbf\
\x27\xa3\xbb\x25\xcf\xb3\xb6\x9e\x82\x18\x4f\x54\x86\x3d\x72\x68\
\xac\xab\xd0\xd8\x2c\x47\x82\xce\x74\x34\xee\x27\xa0\xb1\xa9\x47\
\x42\xec\x85\x48\x88\xfe\x0c\x1a\xbf\x3a\x34\x0f\x27\x22\xc6\xfd\
\x51\xb4\x59\xb2\x10\xb8\x19\x09\x59\xd7\x5b\xda\x31\x68\x5c\x47\
\xa1\xf1\x1f\x8f\xc6\xe5\x5a\x2b\x73\x3b\x70\x29\x7e\x33\xe7\xb3\
\x48\x20\x98\x82\xae\x4c\x19\x6b\xcf\x3f\x88\xc6\xf1\x52\x34\xf7\
\x6e\x46\x82\x01\xf8\x4d\x9c\xb1\x68\x3e\xd4\x20\xe1\xe0\x13\xf8\
\x0d\xa2\x88\x88\xde\x88\x3c\xba\x5f\xf4\x6b\xe8\xbe\xf6\xce\xe6\
\x6a\x0e\xcd\xf9\x55\x88\x86\xbb\xab\x83\xee\x46\x77\x7d\xcf\x42\
\x34\x39\x87\x04\xf4\xcf\x21\x9e\x71\x05\xb2\x6c\x36\xa2\xf5\xe3\
\x2c\x89\x97\x5b\x79\xf3\x10\x2f\x98\x04\x7c\xd2\x9e\x0d\x44\xeb\
\x67\x34\x5a\xcb\x8e\x4e\x5f\x86\xd6\xdb\x1e\xc4\x6b\x8e\x47\x9b\
\x61\x0b\xec\xb3\x2b\xdf\xf1\xaa\x11\x88\x6e\x3b\xfe\x73\x36\xa2\
\xf5\xa1\x45\x6b\x21\xa2\xdd\xad\xc8\x8a\xf9\x69\x6b\x5b\xa3\x95\
\xe9\x22\x45\x17\x11\x8d\xba\x1e\x29\x6d\x83\x2c\xed\x00\x4b\xdb\
\x10\xf4\xe7\xc9\xf6\xee\x12\x44\xcf\xe6\x5a\xff\xd6\x23\x1a\xf4\
\x09\x44\x4f\xd2\x68\x49\x95\x8b\xa5\xbb\xd6\xda\x52\x44\xca\xc7\
\x09\x56\x5e\xb3\xa5\x75\x77\x34\x37\x5b\x5f\x9f\x8b\x14\xb2\x73\
\xac\xcf\x27\x5b\x5d\x07\xe1\xa3\xf5\x27\xd6\x4f\x1f\x44\xf4\xaa\
\xdd\xfa\x7f\x22\xe2\xfd\xb7\x58\xda\x45\x56\xfe\x30\x44\x43\x87\
\x23\x3e\x39\x27\x55\xf7\x36\xab\x53\x83\xd5\xf3\x62\x7b\xa7\xda\
\xf2\x68\x45\x56\xeb\xcb\x10\x7d\x75\x32\x47\x3b\xa2\xbf\x63\xe9\
\xb8\x31\x30\x0b\xc9\x1e\xfb\xad\xdc\x4f\x5b\x7e\xcd\xf6\xac\xda\
\xf2\x1c\x6a\xfd\x3e\xdf\xca\xbf\xde\xfa\x60\x14\xe2\x1b\xe3\x10\
\x5d\x76\xf5\x3f\x9c\x34\xd9\xcd\xd7\xff\x09\x7c\xd5\xc6\xbc\x3b\
\x8a\xf0\x12\xb4\x09\xfc\x45\xe0\x0f\xf0\x9b\x24\x27\xa3\x39\x5b\
\x40\xae\xf9\x27\xd9\x78\xdf\x66\xed\x9d\x8e\xbc\x32\x46\x5a\x7f\
\x4c\xb5\x79\xf3\x51\x34\x97\xdd\xbc\x68\xb0\xbe\xbe\xc8\xe6\xc2\
\x69\x36\x37\x46\x58\x5e\x53\x6d\xdc\x6f\xb3\xfe\xb9\xc6\xfa\xdb\
\xf5\xdf\x44\xb4\xae\x4e\x44\x7c\xf9\x26\x9b\x63\xb3\x11\x9f\x1b\
\x68\x63\x73\xa1\x3d\xbf\xce\xda\x14\x2d\xc3\x7d\x1c\xd1\x22\x1c\
\xd1\xdb\xe0\x76\x6b\x7f\x05\xfc\x0e\x22\xf6\x05\xc4\x1c\xcf\x45\
\x0c\x70\x2f\xba\xd3\xf5\x65\xfb\xed\x2c\xfb\xff\x1c\x70\x27\x62\
\x22\x7f\x86\x08\xb1\x0b\x8e\xb0\x14\xed\x2c\x57\x58\x5e\xd3\x81\
\x27\xd1\xae\xdf\xfd\xf6\xec\x3c\xcb\xe7\x15\xc4\x70\xce\x06\xbe\
\x8b\x76\xe9\xb7\xa1\x5d\xde\x0a\x2b\x7f\x06\x12\x98\xb6\xd8\xef\
\x13\xed\xdd\x93\x11\x83\xfc\x3e\x62\x88\xa3\x10\x13\x2e\x00\xbf\
\x46\xf7\xe9\xee\x45\x42\x93\xbb\x17\x0f\xab\xe3\x1a\xe0\xa7\x88\
\x08\x7f\x11\x31\x8c\x16\x74\xfd\xd0\xe3\xf6\xec\x59\xe0\x2e\x44\
\xfc\xbf\x64\xed\x28\x20\x06\x7d\x0a\xf0\x2f\xc8\xe2\xbb\x09\x09\
\x04\x6f\x5a\x1b\xef\x46\xc2\xd6\x42\xc4\x1c\x16\x03\x3f\xb0\xb6\
\x36\x20\xe2\x3f\x07\x29\xed\xcb\xac\xee\xa3\x11\xe3\x9a\x83\x2c\
\x9e\xee\x6c\xd7\x3c\x4a\x03\x80\x44\x94\xc2\x59\x3d\xc0\xf7\xd1\
\x10\xbc\x25\x76\x2d\xea\xff\x7a\xe0\x87\x96\x66\x3c\x9e\xe9\x3e\
\x89\xc6\x6b\x19\x72\xd3\xfc\x25\xea\xf7\x99\x96\x6e\x2d\x9a\x8f\
\xf5\x68\x3e\xed\x44\x73\xaa\x16\xad\x97\x26\x24\x98\x6f\x42\xd6\
\x92\xbb\xd0\x5c\x9a\x62\xe9\x27\x22\x61\xa1\xce\xca\x1b\x89\xe6\
\xf3\x3f\x5b\xde\x83\xd1\xbc\x9c\x6f\x69\x5f\xc4\x5b\x87\x4f\xb2\
\x7c\x3b\x0b\x78\x13\x11\xd1\x53\xa8\x40\x3c\x62\x32\x9a\xaf\x5d\
\x79\x2f\x54\x21\x7a\x1b\xa2\x15\xad\x8b\xd3\x90\x75\xee\x27\x96\
\xee\x4b\x88\xbe\xb7\x20\x4f\x8d\x9f\x23\xa5\x71\x3a\x5a\x57\x9f\
\x43\xca\xcf\x62\xb4\x66\xe6\x21\x3a\xdd\x62\xf9\x1d\x8f\x68\x6f\
\x3b\xe2\x6f\x8f\xa3\x35\x39\xc6\xf2\x7f\x08\x59\xcd\x9c\xb5\xf0\
\x34\x64\x11\xfb\x31\x5a\xd7\x5f\x42\xeb\xaf\xcd\xde\xbd\xd7\xf2\
\x72\x56\x2c\x77\xdc\xe1\x6c\x44\xab\xef\x44\x74\xe7\xcf\x90\xc2\
\xb8\x1a\xc5\x03\xd8\x8c\x97\xfd\xb6\x22\x9e\xe3\xee\xea\x1d\x6b\
\x79\x6d\xb0\x72\x9c\x05\xed\x21\xc4\x43\xe7\x5b\x19\xeb\x10\x5d\
\x71\xde\x4c\x8b\xf0\x47\x2c\x1c\x72\xc8\x6a\xb7\x0e\xf1\x99\x30\
\x4e\x47\xda\x7a\xe8\x6e\x67\xd8\x68\xe5\x4c\x45\x3c\x79\x37\x52\
\xa2\xde\xb4\x77\x1b\x10\x9f\xbe\xd7\xd2\xde\x8b\x94\xa4\x7c\xf0\
\xfb\x5d\x96\xff\x18\xab\xd3\x18\xfb\xfe\xb4\xa5\xdf\x83\x94\xa9\
\x13\xad\xad\x3f\xb0\x31\x3f\x9e\x52\xab\xfa\x2e\xe4\x69\x93\xa0\
\xcd\x12\x57\xdf\x76\xb4\x51\xf2\xa0\xf5\xcf\xf5\x36\x17\x5c\x7d\
\x12\xa4\xac\xa7\x03\x3c\xe5\xac\xef\x5d\x7f\xd7\xd9\x58\x15\xec\
\xdd\x37\xf0\xd6\xd7\x71\x36\xaf\xbe\x8c\x68\xf8\x3e\xa4\x88\xdf\
\x81\xe4\x98\x7b\xac\xee\x27\x23\x19\xa3\xab\x18\x28\x07\x8a\x6a\
\x1b\x83\xc9\xd6\x7f\x5d\xc1\xcd\x89\x5f\xd8\xf7\x3c\xda\xec\x4d\
\xac\xdf\x3f\x80\xf8\xdf\x5c\xe0\x01\xc4\xc7\x5e\xc0\xcb\x32\x5f\
\x44\xf2\xdd\x50\xc4\x87\xea\xd1\x1c\x3d\x1d\x59\x7d\x27\x21\xbe\
\xf3\x69\x2b\xc7\x8d\xf5\xb9\x48\xde\xd9\x8c\x78\x66\x23\x92\x83\
\xc6\x59\x9a\xf1\x36\x76\xf7\x5b\xdf\x62\xf9\x9e\x83\xd6\xd0\x7d\
\xd6\xbe\x3f\x42\x6b\xb1\xc1\xd2\x3e\x8f\xe8\xc7\x0c\x24\x7f\x45\
\xf4\x61\xf4\x7b\x45\xb8\xbd\x98\xd0\x56\xf0\xb4\x3b\x9f\x83\xea\
\xca\x7c\xf4\xfd\xeb\x39\x14\xd0\xce\x68\x25\x62\x14\x8d\x88\xa0\
\x35\x21\xc6\xbe\x03\x31\x22\xf7\xbc\x01\x09\x09\xe0\x83\x45\xb9\
\xc0\x16\x6e\x87\x3a\x87\x84\x8a\x53\x90\x30\xe0\xdc\xce\x72\x96\
\x4f\x1b\xa5\x77\xde\x0d\x42\x3b\xdc\x1b\x11\xb3\x03\x11\xe4\xf9\
\xc1\xfb\xce\xad\x2c\x1d\x81\xb0\x0e\x31\x66\x77\xee\xa4\xc1\x9e\
\x35\x21\xa6\xee\x94\xdf\xf4\x14\x73\x57\x0d\xb9\xf3\x2c\x8d\x56\
\xff\x76\x7b\x5e\x65\xe5\x3a\x17\xb8\xd6\x54\x1b\xab\xac\x3e\x8d\
\xf6\xbf\xc1\xfa\xb0\x02\x31\x7e\x67\x05\x28\x20\x26\x57\x69\x75\
\xca\x5b\xbf\x15\x2c\x2f\x57\xf7\x1c\x52\xc0\xd6\xa2\x5d\xd4\xa6\
\x60\x1c\xc2\xb3\x6d\x3d\x1d\x61\xb5\xb7\x20\x3c\x23\x38\x19\x09\
\x2b\xce\x35\xec\x1d\xe0\xbf\x50\x3f\x5e\x83\x18\xf3\x3e\x34\x56\
\x4e\x20\x74\xf3\xa4\x80\x9f\xdb\xcd\xf8\xf9\xbc\x14\x6d\xf8\x0c\
\x42\x42\x57\x62\xcf\x5b\xd0\xb8\x5d\x84\x98\xff\x1a\x34\xe6\x6e\
\x3e\xbb\x39\x95\xb7\xcf\x59\x91\xd1\x1d\x1f\x68\xb1\xff\x6e\x4d\
\xd5\x58\x1d\xdc\x3b\x0f\x22\xc1\x30\x7a\x12\x45\xf4\x56\xb4\x02\
\xdf\x00\x1e\x43\xae\xa4\x9d\x45\x9b\x4d\xd0\x7a\x59\x88\xd6\x80\
\xa3\xbd\xf3\x90\x10\x5f\x87\xd6\xa9\xa3\x75\x8d\xf8\x35\xba\x07\
\xad\x33\x47\x2b\x37\xa1\xcd\xa9\x0b\xf1\x01\xf2\x2e\x41\xf4\xd2\
\xbd\x7f\x2f\x52\x30\x8b\x78\xfa\xfc\x0b\xa4\xc4\xcc\x41\xca\x93\
\x53\xe2\x40\xeb\x7a\x9f\x7d\x76\x3c\xaf\x36\xa3\xfc\x34\x6a\xe9\
\xc8\x27\xea\x28\x8d\x68\xef\xda\x3f\x15\x29\x29\x9b\xf0\xf4\x21\
\xcd\xdb\x5c\xfc\x83\x8a\xe0\xbd\x13\x91\x45\xd8\x1d\x07\xa2\x4c\
\x3f\xe7\x82\x72\xd3\x74\xc3\xb9\xcf\xd6\x50\x5a\xb7\xb0\x7c\x67\
\xa5\x6f\xb2\xcf\xeb\x90\xc7\x4d\x01\xef\x6a\x1d\xf2\xee\x51\xc8\
\x5a\xbe\xcf\xc6\xc3\x79\x4b\x25\x48\xb9\x0a\x6f\x78\xa8\xc5\x9f\
\xf3\x75\x3c\x37\x5d\xf7\x7c\x90\x87\x43\xc1\xc6\xcf\xf5\x8d\xa3\
\xb7\x8d\x56\x9f\xaa\x4e\xe6\xdb\x0c\xab\xdf\xc6\x60\x6e\xb8\xf7\
\x43\x59\xc2\x9d\x11\x6e\xc1\xf3\xe8\x6a\x4b\xbb\xdf\xc6\xd4\x59\
\x9f\x0f\x37\x3d\xce\x59\x5f\x7d\x05\xaf\xb0\x76\x87\xc7\x6f\x43\
\x1b\x40\x39\xab\xe7\xb5\xf6\xff\x4d\xeb\xe7\x8b\xad\xae\x6f\xa3\
\xf5\xe5\xd6\x96\xbb\xcf\x7a\xb0\xb5\xd7\xc9\x2a\xae\xcd\x95\xc1\
\x5c\xa8\xb0\x7e\xae\xb4\x3e\x7c\xc7\xd2\x87\x32\x8e\xe3\x57\xf7\
\x22\xb9\x6f\x36\xda\x54\xf8\x36\x7e\x7e\x57\xe3\xd7\x48\x28\x2f\
\x36\xe1\xe5\xcf\x23\x75\xbd\x58\x44\x2f\x43\xbf\x16\x68\xf2\x39\
\xf8\xe9\xf2\xdd\x5c\xf3\x9d\x77\x7e\xf3\xf7\x85\x07\x36\xb0\xbf\
\xa5\x10\x67\x7f\xcf\xc1\x31\x84\x22\x22\xa0\x8e\x90\x6e\x41\xd6\
\x4a\x67\xfd\x3c\x13\x31\x95\x33\x10\x63\x5c\x6a\x9f\x67\xa0\x5d\
\xd6\x1a\xa4\xc4\x55\x20\xa2\x77\x9a\xa5\x79\xd8\xf2\x76\x16\xbb\
\x0a\x3c\xb1\xcb\x23\x06\xf4\x41\xb4\x33\xfe\x38\xda\xc5\x1c\x65\
\xef\xbf\x62\xef\xbb\xdd\xf3\xa2\xbd\x3f\xca\xde\xad\x40\x67\x53\
\xc6\x23\xa5\x7b\x0e\x52\x9e\x97\x53\xaa\x9c\xe4\xe8\xb8\xf6\x8a\
\xc8\x5d\x68\x81\xfd\x4d\x46\x0c\xc3\x09\x02\x6d\xd6\x0f\xae\x8d\
\x67\x21\x6b\xc4\x3a\xab\x4b\x3d\xda\x15\xbd\xc0\xde\xbd\x18\x09\
\x29\x0d\x94\x5a\xef\x9c\x45\x7c\x3d\xde\xa5\xef\x3c\x24\x28\xad\
\x45\x02\xcf\x66\xb4\x3b\x3d\x19\x31\x88\x75\x96\x66\x9a\xf5\x6d\
\x9d\x95\x79\x91\xb5\xb5\x3f\x5b\x86\x73\xc8\xea\x32\x15\x31\xdb\
\xab\xd1\x38\x3e\x89\x9f\x57\xb3\x91\x70\xfd\x00\x9a\x53\xc7\xa1\
\xb1\x9d\x8a\x76\xf4\x4f\x46\x82\xe5\xeb\xa8\x5f\x4f\xc7\x07\xe1\
\xda\x65\x7f\x2f\xa1\x79\x31\xc0\xde\x0d\x05\xcb\x41\xf6\xdb\x63\
\x68\xf7\xbd\x06\x2f\x3c\x84\x16\x8e\x8a\xe0\x73\x3e\x78\xb6\x0b\
\x59\x94\xcf\x41\x56\x91\x33\xad\x1e\xee\xac\xda\xbb\x68\x5e\x4f\
\xa6\xf4\x6a\x93\x88\x88\xde\x86\x1c\xa2\x6d\xbf\x44\xc7\x04\xba\
\xba\x29\xe0\x39\xa4\x50\x5c\x83\xf7\x78\xf8\xa8\x3d\x5b\x8e\xd6\
\xe6\x6c\x64\xf1\x9c\x84\xd6\x5e\x45\x2a\x0f\x77\xae\xf8\x79\x74\
\xc4\x64\x33\x52\x0a\x56\x21\xba\xbe\xda\xfe\x8e\x0b\xde\x71\x6b\
\xf3\x3c\xcb\xef\xc7\x48\x49\x9e\x1c\xfc\xf6\x06\xde\x95\x73\xb1\
\xd5\x6f\x25\x1d\x79\x56\xc8\x4b\x12\xab\xb7\xa3\x21\x67\x21\x7a\
\xbd\x26\xf5\x1e\x56\xb7\x93\x10\x8d\xbf\x07\x6d\x32\xd7\xd9\x6f\
\xed\xc8\x3a\x57\x47\xa9\xf2\xec\x68\xc7\x29\xd6\xbf\x3f\x43\xb4\
\xa3\x2e\xa8\x4f\x56\x3f\xbb\xf7\x2b\xac\xbc\x26\x2b\xfb\x44\xeb\
\xe3\x9c\x95\x39\xc0\xca\x75\xe5\x83\x3f\x03\xfb\xb2\xe5\xe5\x2c\
\xbc\x59\x3c\x74\x2a\x72\x15\xbe\xdb\xfa\x7f\x50\xd0\x9f\x61\x1b\
\x2a\x11\xbf\x73\xe7\x70\xe7\xe1\xcf\x99\xa6\xe7\x53\xd8\xd7\xe0\
\x2d\xb9\x8e\x1f\xae\xc2\x9f\x3b\x4d\xb7\x39\xdc\x08\x00\xef\xea\
\x7c\x0f\xa2\xbb\xee\x98\x91\xf3\xcc\x71\xc7\x50\xb6\x59\x1f\x39\
\x1e\x7d\x11\xb2\x7c\xb6\x50\xda\xee\x23\xe9\x99\xf3\x26\xf2\x5c\
\x08\xcf\x9f\x97\x83\x93\x7f\xd2\x7f\xce\x58\xf1\x2a\x5a\x1b\x6f\
\x5a\x7e\x79\x34\xa7\x67\xa1\x39\x0a\xf2\x76\x1b\x88\xe6\xee\x74\
\x7b\xfe\x16\x92\x49\x06\xd9\x98\xad\xb2\x77\x9d\x37\xe0\x18\xfc\
\x46\x45\x38\x4e\x95\x68\x63\xa9\x09\xf8\x11\x9a\xab\xe3\xf1\xb2\
\xd4\x5b\x96\xff\x34\xeb\xe3\x2a\xc4\xe7\x2a\x29\xbf\xb6\x22\xfa\
\x28\xfa\xb5\x45\x38\x47\x8e\x4d\x7b\x5b\x79\x69\x63\xc3\x6f\x9e\
\xb5\x15\x8a\xb4\x17\x93\xe8\xf8\xd9\x73\x58\x85\xb7\x9c\x3e\x86\
\x18\xc5\x8d\x68\x34\x9e\xc3\x9f\x1f\x1a\x83\xce\x78\xac\x43\x42\
\x0f\x88\x41\xdd\x88\x18\xed\x77\x91\xf2\xbc\x12\x31\x9c\xbb\x10\
\x33\x99\x68\xcf\xdd\x55\x0e\x6f\xe1\x2d\x9c\x6b\xf0\x6e\xaa\x4d\
\x88\x70\xe7\xd1\xee\xfe\xdd\x48\x68\x99\x14\xbc\xdf\x84\x84\x9f\
\x33\xd0\x4e\xe8\x7a\xb4\x43\xe9\xca\x02\x78\x04\x11\xed\xc1\xd6\
\xae\x1c\xda\xbd\x74\x2e\x57\x0e\x6e\x17\xd6\x05\x52\xb9\xd7\xf2\
\x5a\x85\xdf\xc9\xfe\x05\x22\xd8\x37\x23\xe6\xf0\x6d\xab\xcb\x0a\
\xcb\xf3\x7b\x68\x97\xfe\xc3\xd6\xe6\x1f\x21\xe1\x60\x15\xde\x72\
\xe0\xfa\xe3\x1e\x24\xfc\xdd\x68\x7d\xdc\x6a\xe5\xdd\x61\x75\xcf\
\x23\xe1\x6d\x2d\xb2\x58\x5c\x63\xe5\xb6\xe0\x5d\xc4\x67\x23\x4b\
\x42\x4f\x5d\x35\xd2\xd3\xc8\x59\xdf\x54\xa2\x33\x4e\x09\x1a\xe3\
\xff\x40\x73\x69\x10\x12\x6e\xd7\x22\x01\xe8\x23\x68\xdc\x7e\x80\
\x94\xde\x41\xf8\xf3\x7d\x0f\x22\x01\x76\x2e\x1a\xab\xf7\xa1\xb1\
\xfb\x3e\xea\xf3\x8d\x48\xc0\x7e\x1d\x09\x12\x4d\xf8\xb9\x5b\x8f\
\xdc\xb9\xce\x41\x63\xfb\x06\xfe\x8c\xdf\x6a\xab\xe7\x5e\x34\xbe\
\x89\xfd\xb6\x12\x3f\xe6\xbb\xf1\x73\xc7\x5d\x0d\xb2\xd1\xf2\xbf\
\x17\x09\x14\x6e\x27\x7f\x13\x51\x38\x88\xe8\xdd\x38\x90\x3b\xce\
\x77\x00\x5f\x47\xd6\xdb\x0f\xa2\x35\xf7\x18\xf0\x28\x5a\x2b\xc3\
\x90\x65\xab\x80\x5c\x5a\x57\xa3\xb5\xbd\xcf\xca\x09\xad\x8e\xcb\
\xd1\x66\xe9\x33\xf6\xec\x25\xa4\x68\x5d\x63\x65\xbd\x8a\x5c\x91\
\x57\xe2\xad\x61\xcb\xd1\x99\xe3\xf9\x88\x96\x3c\x88\xd6\x60\x13\
\xb2\xc4\x0d\x47\x67\x15\xdb\x91\x8b\xf6\x1a\x24\xb0\xbb\xc0\x5e\
\x2e\x40\x57\xd8\xa6\xc7\xf0\xbc\xb0\x0d\xad\xed\xad\x88\x16\xd5\
\x53\xaa\x94\x3e\x8e\x36\x72\x6f\x46\xf4\xe5\x29\xfb\xfd\x39\x6b\
\xf7\x74\xc4\x5f\x9c\xf7\xd0\x46\x2b\xf3\x4d\xfb\xfd\x26\x7b\xcf\
\x05\x6e\x74\x8a\x4b\xa8\x74\xae\x47\xfc\xa9\x11\xd1\x10\xa7\x08\
\x5e\x8c\xf8\xe9\x4b\x48\x51\x59\x8b\xe8\xcb\x19\x88\xe7\x9e\x80\
\x14\xe5\xef\x20\x7a\xf8\x31\x7b\xf7\x01\xc4\x07\xd3\x3c\xd4\x8d\
\xc1\x89\xc0\x0d\x56\xaf\x67\x10\x9d\xdb\x68\xfd\x9b\xb7\xba\xac\
\xb6\xb2\x7e\x8c\x36\x1c\xdb\x10\xdd\xac\x4f\xd5\x7d\x2b\xde\x72\
\xbd\x0a\x1f\x34\x6b\xbc\xb5\x7d\x37\xf2\x54\x1b\x67\xf5\xc1\xd2\
\xae\xb5\x31\x5e\x8d\x0f\xc4\xb9\xdf\xc6\xef\xfa\xa0\xbf\x9f\xb1\
\xf4\x4f\xa0\x4d\xec\x15\x56\xce\x2e\x6b\xf7\x65\x88\xcf\x6e\x46\
\xb4\x78\xa8\x95\x8f\xcd\x49\xd7\x9f\x47\x02\x07\xb2\x8e\x36\x51\
\x6a\x51\x4f\xac\x6e\x7b\xed\xfb\xab\xe8\x38\xd8\xcb\x41\x1f\x35\
\xe2\x8f\x88\x7d\xcf\xfa\xef\xbb\xc8\xab\xe2\x74\x1b\x8f\x47\xf0\
\x01\xbb\x4e\x41\x32\xcd\x55\x36\x17\x9a\xd0\x7a\xd9\x6f\xfd\x5c\
\x0c\xca\xdd\x6d\x65\x5e\x8a\x36\x3a\xd6\xa2\xb9\xbe\xc8\xfa\x6b\
\x39\xda\xb4\x76\x31\x57\xfe\xdb\xe6\xc7\x1a\xbc\x47\xd6\xc6\xa0\
\x7d\x11\x7d\x18\xb9\x25\x93\x06\xd6\x7f\xfb\x86\xe9\x43\xc7\x0e\
\xaa\x24\xe9\x67\x8a\x5f\x3e\x97\xe3\xef\x7f\xbd\x85\xbf\x7c\xc4\
\x5f\x55\xb7\x70\xc2\x00\x7e\x72\xcb\x0c\x46\x0c\xe8\x7f\xfd\x71\
\x34\xd0\xd2\x9e\xf0\xf9\x7b\xd7\xd5\xdf\xf9\xfa\xee\xdb\xd1\x79\
\xa5\x34\xb1\x0d\x5d\x97\xdc\x08\xb8\x3b\x5a\xdb\xd0\x8e\xf1\x17\
\x10\xe1\xdc\x40\xc7\xa8\xa0\xee\x6a\x06\xe7\x32\xe4\xf2\x73\xd7\
\x29\xe5\x2c\x9f\xf0\x4c\x55\x31\x55\x76\xe8\x9a\x45\x90\x5f\xfa\
\x7d\xf7\x5e\x65\xf0\xd9\xb9\xc8\x56\x05\x69\x43\x17\x2b\x57\x66\
\x2e\xf5\xce\x1c\x24\x10\xfd\xab\xbd\xd3\x96\xaa\x7f\xd8\x1f\xe9\
\x36\x56\x04\xe5\xba\xdd\xd0\x36\x4a\x77\x4a\xd3\x6d\xbc\x1e\x09\
\x04\x6f\x58\xb9\xfb\x10\x13\x72\xbb\xe5\x61\xdd\x5d\x9d\xab\xac\
\x4c\x97\x9f\x2b\xb7\x2f\xaf\x94\x02\x0a\x4e\xb2\x09\x09\x22\xe9\
\x1d\x78\x67\x55\x75\x73\xc5\x5d\xc7\x10\x5a\x04\x9c\x8b\x55\x15\
\xfe\x5a\x06\xd7\xaf\xce\x8d\xce\x05\x7c\xf9\x10\x1a\x8b\x9f\x05\
\xe5\xd7\xa0\x73\x83\xef\x47\x2e\xd6\xeb\x82\x32\xc3\x28\xa7\x6e\
\x9d\xb8\xb9\x1a\xba\x41\xe7\xca\x7c\x0e\xd7\x87\x9b\x4b\xe1\xb5\
\x14\x09\x1d\xe7\x43\x44\x44\x4f\xa2\x1a\x9d\x29\xbc\x03\x09\xb4\
\x87\xba\x31\xe3\xe6\xbe\xf3\xf2\x71\xf3\x3c\x5c\xa3\x8e\xff\xa4\
\x69\x72\x9a\x96\xe7\x29\x3d\x76\x10\xae\xf1\x2c\x5e\xe0\x5c\x63\
\x5d\x70\x27\x57\x17\x47\x37\x38\xc0\xf2\x5d\x99\xae\x9f\xb2\x78\
\x61\x92\x4a\xeb\xca\x0f\xd7\xb7\xe3\x97\x50\x5a\xd7\x90\x5e\xb8\
\xf7\x5a\x29\xe5\xa7\xe9\x32\x42\x2f\x12\x57\xd7\x24\xc8\xbf\x40\
\x29\x4f\x71\x56\x3b\xf7\xbb\xe3\x39\x8e\xff\x84\x7d\x94\x0e\xe2\
\xe4\xea\xe8\x5c\xdd\x5d\x99\x61\x3b\xc2\x3e\x73\xbc\x1a\x4a\x69\
\x29\x19\xef\xe6\x29\x95\x19\x5c\x19\x9d\xf1\xd9\x90\x7f\xba\xb6\
\x96\xeb\xef\x2a\x3a\xca\x11\x15\x74\x8f\x9f\x1f\x28\x0f\x76\x67\
\xbb\xbf\x08\xfc\x2d\x5d\x7b\x4f\x74\x05\xb7\x06\x8b\xa9\x67\x09\
\x32\x02\x9c\x87\xbc\x1d\xbe\x8e\xe6\xcb\x95\x68\x93\xe7\x87\xc1\
\x18\xbb\xb5\xe3\x5c\xa0\x5b\x83\xbc\xc2\x79\xd1\xd5\x5c\xc8\x9a\
\xa3\xae\xff\x2a\x82\xdf\xa0\xf3\x35\x92\xd5\xa6\x88\xbe\x01\x17\
\xa0\xf6\x36\xe0\x0b\xfd\xda\x22\x1c\xd1\x2b\x11\x12\x9d\x50\xb9\
\x00\x4f\x28\x57\xe3\xcf\x07\xa5\x89\x77\x5b\x90\x36\xcc\x2f\x14\
\x2c\xd2\x0a\x44\xba\xec\xac\x3b\xe4\xca\xbd\x1f\xd6\xcf\x21\x9f\
\x4a\x9b\x6e\x57\x16\xe3\x6a\x40\xbb\x96\xa1\x22\x55\xae\x3f\xd2\
\x6d\x0c\xcb\x4a\x82\xdf\xb3\x84\x12\x27\x84\xbc\x8a\xac\x91\x27\
\xa3\x5d\xef\x07\x29\x55\xdc\xc2\xf2\xd2\xe5\x26\xa9\x72\xfb\x33\
\x9c\xe2\x19\x22\x3c\xb3\x16\x0a\x41\xe1\xb8\xb8\xff\xe1\xdc\x4e\
\x90\xc2\xdd\x6c\xcf\x9d\xb2\x3b\x04\x59\x06\x9e\x43\xd6\xa0\x2c\
\xe1\x27\xcc\x2b\x1c\xc3\x24\x55\x97\xf4\xe7\x70\x7d\x64\xb5\x25\
\x6b\x3e\x44\x44\xf4\x25\xb8\xf5\x9a\xa6\xab\xd0\x71\x8d\x42\xe7\
\xb4\x3c\x2d\x34\xa7\xd7\x65\x3a\x4d\xa8\x90\xb9\xef\x69\xba\x71\
\x20\xe5\x87\xe5\xb4\x75\xf2\x5e\xb9\xf2\x43\x85\x35\x8b\xbe\x17\
\x33\xde\x2b\xc7\x4f\xb3\xfa\xa4\x5c\xfe\x49\x46\x9e\x69\xba\xd3\
\x19\x5f\x23\xf5\x5b\x5b\x2a\x6f\x52\xdf\xdd\xb3\x90\x57\x67\x21\
\x6b\x6c\xc3\xa0\x59\xe5\xea\x93\x4e\x9b\xde\x08\xc8\xea\xef\x2c\
\x3e\xd2\x1d\x7e\xde\x1b\x50\x2c\xf3\xcc\x6d\xf2\xcf\x41\xd6\x77\
\xa7\xc8\x6e\xa7\x34\x1e\x89\x9b\xa3\x79\x4a\xe7\x40\x3a\xaf\xee\
\xcc\x85\xac\x39\x1a\x7e\x87\xee\xad\x91\xde\xd2\xb7\x11\x47\x18\
\x51\x11\x8e\x38\xd6\xd0\x8a\xdc\x63\x3a\x0b\x82\x72\xac\x21\x8f\
\x14\x9c\x8d\x1c\x1d\xe2\x9b\x43\x2e\x6c\xee\xbc\x99\xdb\x2d\xed\
\x2b\xfd\x79\xac\x22\x87\x5c\xe4\xdc\xce\xb5\x7b\xb6\x0b\xf8\x27\
\xe2\xc6\x43\x44\x44\x44\x44\xc4\xb1\x83\x3c\x72\x9b\x7f\x9e\xd2\
\x0d\xfe\x97\xe8\x18\x68\x34\x22\xa2\x47\x10\x15\xe1\x88\x63\x11\
\x7d\x71\xa7\xee\x60\xdc\x9b\x0e\x05\x59\xbb\xa5\x11\x07\x0e\x17\
\xe8\xc4\x21\x1d\x99\xf5\x40\x91\x35\xb7\x43\xab\xc0\xe1\x3e\x9f\
\x1b\xba\x4a\x87\xe5\xa5\x23\xa5\x46\x44\xf4\x55\x1c\xc9\xf9\x1e\
\xba\x61\x42\xd7\xb4\xa1\xab\xba\x74\xb5\x5e\x9d\xeb\xed\xe1\x80\
\x8b\x9d\x11\xd6\xfd\x70\xf7\xd1\x91\xea\xfb\xd0\x4d\x36\xdd\xa6\
\x72\xfd\x13\xe9\xde\xc1\x23\x94\x25\xa0\x94\x0f\x66\xc9\x18\x47\
\x5b\xde\x39\xd0\xb6\x64\xb9\x48\x77\xf5\x0e\x74\xbe\x6e\x0f\x34\
\xcf\x43\x9d\x8f\x69\x2f\x84\x03\xa1\x29\x74\x91\x36\x39\x80\x77\
\x0e\x04\x5d\xf5\xe3\x11\x41\x54\x84\x23\x22\x22\x22\x0e\x0e\x09\
\xba\x06\xe2\x3c\x3c\x2d\xad\x47\xbb\xdd\x87\x33\x80\x58\x11\x45\
\xd7\xac\x21\xfb\x5c\xfd\xc1\x22\x8f\xa2\x9e\xbe\x8a\xce\x8b\x3b\
\x06\x37\xc3\xda\xb3\xe2\x30\xb6\x21\x22\xa2\x37\x22\x41\x91\x6a\
\x8f\x47\xf1\x12\xda\x0f\x2d\xbb\x0e\x79\x0f\x41\x91\x9f\xc7\xa2\
\x35\xb6\x14\x05\xd8\xca\x95\x49\x3f\x19\x9d\xdd\x7c\xb5\x4c\x9e\
\x0b\x51\x50\x9f\x0d\xf8\xf5\x3a\x1c\xad\xd9\x37\xf0\x77\x18\x37\
\x72\x68\x6b\xb7\x1a\x05\x91\x72\x77\xc8\xba\xc0\x92\xcb\x39\x7c\
\x1b\xd1\xee\xfc\xe8\x49\x56\xe7\xb6\x43\xcb\xae\x24\xdf\x13\xed\
\x73\x48\xc3\x6a\x82\xfe\x69\xc9\x78\x67\x14\x0a\x82\xb5\xfc\x30\
\xd5\xa3\xbf\x20\x41\x01\xbd\x16\xe3\xe7\xe4\x36\x14\xec\xcd\x05\
\x08\x3d\x56\x50\x89\x78\xfa\x26\x74\xaf\x70\x2d\x5d\xc7\x21\x48\
\x50\x90\xcb\x04\x7f\xdf\x75\x3a\x4f\x77\xa5\xe2\x54\x74\xbe\x39\
\x2b\x5d\x3a\xcf\xe1\x56\x87\xd7\x38\xb8\x33\xe0\xa3\xf1\xc1\x59\
\x17\xa1\x00\x74\x59\x57\x84\xb9\x60\x62\x3b\xba\xa8\x53\x0e\xdd\
\x28\xb1\x16\xd1\xa8\x46\x14\x5c\xec\x70\x8d\x6f\x82\x02\xe4\xe5\
\x38\xca\xb2\x47\xdc\xf9\x3a\x0c\xc8\xe5\xa0\x22\x97\xa3\x32\xdf\
\xf1\xaf\x22\x9f\x23\x9f\x3b\xb6\x28\x41\x44\x44\x44\xb7\x50\x44\
\x02\xe8\xb9\xe8\x8c\xf7\x5e\x74\x1d\xc3\xed\x88\x89\xb9\xf3\xde\
\xce\xb2\x52\x0c\x9e\x85\x67\xc7\x5c\x9a\x62\xea\x59\x98\x76\x14\
\x8a\x4c\x5a\x0c\xd2\x77\xf5\x4e\x92\x91\xd6\xa5\x71\x3b\xba\xd3\
\x50\x54\x4e\x97\xb6\x0d\x09\x35\x0b\x33\xf2\xe8\x8b\x9e\x18\x11\
\xfd\x1b\x09\x8a\xb6\x3e\x15\xbf\x2e\x3a\x9b\xef\x59\x6b\xaa\x5c\
\xbe\xa3\x81\xdf\x46\xeb\x69\x27\x52\x2a\x7f\x07\x29\x69\x6e\x2d\
\x86\x67\xf5\xdd\xd5\x80\xe3\x53\xe5\xb4\x07\xe5\x4c\xb4\x34\xe1\
\x5a\x1e\x81\x22\xed\xd6\x20\x7a\x54\x45\x47\x3a\x41\xaa\x9c\xb4\
\xb5\x37\x5d\xf7\x3a\x14\x44\xb1\x06\xd1\xb5\x3c\x0a\x2c\x73\x2a\
\x1d\xe9\x5a\xb9\x3e\x0b\xe9\x5d\x56\xdf\x25\x96\xff\x54\x7c\x90\
\xbe\xee\xd6\xb9\x98\x2a\x33\xfd\x7d\x34\xfe\x6a\x1d\x57\x8f\x2a\
\x14\xa4\x69\x00\xa5\xf4\xd2\xd5\xb9\x15\x29\xff\x53\x88\xb4\x0e\
\xba\x6f\xb5\x2d\x22\x45\x6b\x3e\x9a\x2b\xfb\xd1\x75\x93\xb7\xa1\
\xf1\x0d\xe7\x6a\x18\x0c\x2c\xcd\x1b\xd3\x69\xb2\xe6\x55\x9a\x77\
\x16\xc9\x1e\xff\x70\x0e\x65\xcd\xbb\xf0\x79\x7b\xf0\xde\x58\x14\
\x49\xba\x12\x29\xb7\x8b\xf1\x77\x4d\x97\xe3\xd9\x45\xa4\x4c\x2e\
\xa2\xe3\x1a\x68\x47\x7c\xfb\x63\x68\x8e\x8f\xa4\x74\x5e\x96\x5b\
\x8b\x45\xfc\xb5\x8a\xe9\x33\xf6\xdd\xe1\xf3\xe0\xa3\xd1\x3b\x3e\
\x5f\x45\xc7\x79\x9f\x47\xb4\x63\x6c\x46\x3b\xd3\x7d\x9a\x47\xb1\
\x4a\x8e\xb3\xf4\x23\xe9\x48\x67\xba\x23\xd7\xb8\x67\x59\xf5\x1e\
\x85\xd6\x6e\x57\xfd\x73\x58\x11\x2d\xc2\x07\x89\x1c\x8a\x3a\x5d\
\x48\x12\x76\x35\x16\x58\x5f\xdf\xc2\xa6\x7d\x6d\xec\x6f\x29\xd0\
\xd0\xaa\x71\x1f\x58\x9d\x67\xdc\xe0\x2a\xa6\x0c\xab\x61\xdc\xa0\
\x2a\x06\x54\xe5\x29\x26\x49\xaf\xf5\x07\x89\x88\x88\x38\x28\xac\
\x41\x57\x68\xb4\x21\x05\xf8\xff\x43\x16\xa6\x13\xf1\xf7\x70\x3e\
\x8d\x22\x3f\xcf\x42\x56\xe3\xe7\xed\xff\x08\x24\x34\x0c\x44\x57\
\x23\xb9\x7b\xa8\x17\xa2\xeb\x95\xd6\x22\x0b\xf3\x0e\x24\x64\x8c\
\xb5\x7c\xab\xec\xdd\x97\xad\xfc\x61\x88\x11\x8f\x44\x81\x48\x9e\
\x43\x02\xdf\x4c\xfb\x3f\x18\x59\xa3\xa6\x20\x46\xf3\x1c\xda\xf5\
\x5e\x83\x02\xcf\x0d\x41\xd7\x96\xd4\xa0\x1d\xf1\xdd\x88\xf9\x4c\
\xc4\xef\xf4\xbf\x84\xce\xb2\xc7\x7d\xbd\x88\xbe\x80\x04\xad\x97\
\x53\x80\x6f\x21\xc1\x6b\x02\x12\x6a\x73\x68\x6d\x39\xcb\xab\x4b\
\x3f\x1c\x5d\xed\x92\x47\xca\xed\x1e\xca\x5b\x77\x2e\x47\x6b\xf6\
\xdf\x91\x92\x95\x03\x3e\x80\xae\xf6\xf9\x7b\x64\x29\x5e\x8e\x62\
\x00\x9c\x84\xd6\xe1\x2e\x4b\x37\x14\xd1\x80\x02\x12\xa4\x97\xa1\
\x98\x0e\x1b\x11\xdd\xa8\x42\xeb\x7d\x32\xa5\x4a\x82\xbb\x2a\x6f\
\x31\x5a\xcb\xe3\xd0\x5a\x7e\x16\x05\x27\x9a\x66\xf9\xb6\x21\x8b\
\xdd\xd6\x32\x75\xcf\x21\x85\xe6\xe7\xf8\xeb\x99\x06\x59\x5f\xed\
\xb0\x7e\x1a\x82\xac\xab\x09\x52\x90\x2b\xac\x9e\xab\xad\x7e\xf3\
\xf1\xd7\xb1\xbd\x60\x79\x9c\x62\xef\xee\xb7\x3a\xb5\x20\x1a\xe7\
\xac\x4d\x39\xfb\x7d\x23\xa2\x37\x89\xf5\xd3\x0c\xab\xf3\x4b\xe8\
\x2a\xa1\xf9\xc8\x6a\x3d\x05\x45\xd1\xdf\x6d\xcf\xb6\xa2\x2b\x89\
\xb6\x07\xed\x70\xc1\x9a\xf6\xe1\x6f\x3a\xa8\xb3\x3a\x8f\xb1\x3e\
\x7b\xd5\xfa\xf5\x6d\x74\x7d\xe0\xb7\x0e\xf3\x5c\x3b\xd6\x90\xa0\
\xf1\x1e\x80\xe6\x79\x57\x1b\x03\x2e\x00\xe7\x4f\xed\xfb\x52\xe0\
\xf7\xd0\x7a\xa9\x40\xe3\x5e\x8b\xae\x7e\x5a\x86\x78\xd8\x38\x34\
\xcf\x97\x22\x5d\xe4\x24\x34\x6f\xde\x40\x6b\x6a\x14\x5a\x8b\xee\
\x4e\xef\x77\xed\xfb\x0b\x68\x2c\x67\xd8\xfb\x2d\x96\x66\x92\xd5\
\x75\x1d\x9a\x33\x0d\xc0\xaf\xad\x1d\x27\x5a\xf9\x83\xed\xfd\x0d\
\x56\xb7\x53\xac\x9c\xed\x88\x27\xcf\x43\x0a\xf0\x69\x68\xee\x8c\
\x40\x0a\x65\x1d\x9a\xaf\x5b\x2d\xfd\xa9\xd6\x37\x6f\x22\xbe\xed\
\x14\xbb\xc5\x56\xb7\x95\x56\xa7\xc5\x68\x8e\xcd\x42\xfc\x75\x13\
\x3e\x08\xe6\x34\xab\x67\x9b\x95\x1d\x7a\x8a\x54\xd8\xef\xcb\xf0\
\xd1\xaf\x13\xc4\xe7\x17\x5b\xbd\xb6\x21\x3e\x3e\xd8\xf2\xaf\xb6\
\xdf\x5f\x42\xeb\xeb\x14\xa4\xb4\xbe\x85\xd6\x64\x2b\xa5\xf3\x7e\
\xb5\xf5\x6b\x82\xe4\x84\x99\x68\x1d\x3d\x8f\x68\xc5\x2c\x1b\x93\
\x16\xb4\xce\x77\x04\xf3\x60\x33\xa2\x57\x53\xac\x9e\xb5\xd6\xde\
\xe7\xec\xb7\x74\x39\x4b\x91\x2c\x31\xcd\xea\xbb\x12\xad\xb7\xd3\
\xac\xac\x46\x64\x31\xdf\x16\xf4\xcf\x0c\xb4\xa6\x5b\xac\x4e\x87\
\x1a\xd9\xbc\x2c\xa2\x45\xf8\x20\x90\xcf\x41\x4b\x21\xe1\xb1\x35\
\x7b\xf9\xd2\x2f\xde\xe5\xa6\x1f\xae\xe2\x03\xdf\x5f\xc5\xad\x77\
\xac\xe5\xf3\xf7\xae\xe7\x0b\x0f\x6c\xe0\x0b\x0f\x6c\xe0\xf3\xf7\
\xae\xe7\x43\x3f\x5a\xc3\xfb\xbe\xb3\x92\xcf\xdc\xbd\x96\x3b\x5f\
\xdf\xcd\xbe\xd6\x22\xf9\x28\x46\x46\x44\xf4\x25\x54\x21\xa1\x70\
\x18\x62\x26\xd5\x88\xb8\x7f\x18\xed\xea\xee\x45\x42\xde\x4d\x88\
\x41\x9d\x00\x7c\xc2\xd2\x7f\x0c\x31\x93\x56\x24\x20\xcf\xb4\x74\
\x43\x90\x90\x7d\x33\xb2\x28\x9d\x88\x18\xdb\x58\xb4\xd3\x3e\x0a\
\x31\xe2\xdb\x10\x43\xbf\x06\x31\x8e\x6d\xc0\x7b\x90\xbb\xf6\x58\
\x74\xf5\xd3\x50\x24\x30\xff\x11\x62\x4c\x63\xd0\x35\x4d\xb5\x96\
\x76\x94\x95\x39\x17\xbf\xbb\x9f\x0f\xca\x72\x57\x81\x7d\x02\x6f\
\xad\x8a\x88\x38\xd6\x51\x44\xeb\xaa\x80\x04\xdc\x31\x78\x2b\x16\
\x68\xbe\x4f\xa4\xf4\x3a\xa2\x8f\x20\x61\x2e\xb4\x90\x66\x29\x09\
\xb5\x48\xf9\x7a\x1e\x7f\x15\x50\x0e\x09\xe1\xa3\x90\xd0\x7e\x39\
\x52\xc4\x0b\x48\xc0\x9f\x83\xac\xa3\x4b\xd0\x9a\xfe\xb4\xa5\xc3\
\xca\x1a\x83\x94\xf0\xe3\x10\x3d\xb9\x1a\x09\x90\x27\x23\x5a\x52\
\x8d\x6e\x02\x18\x64\x79\xbf\x17\x09\xe5\x97\x22\xaf\x95\x29\xd6\
\xa6\x76\x44\x3b\x3e\x61\xe5\x94\x5b\xcf\x79\xcb\x6b\x88\xf5\xc3\
\x64\xeb\xa7\x33\xd0\x1d\xc5\xcd\x48\x20\xff\x9c\xa5\xc1\xea\x3c\
\x03\xd1\x9f\x2b\x11\x0d\x3b\x1d\x59\xdd\xcf\x47\x82\xef\x36\xa4\
\x00\xbc\xdf\xde\xbb\x08\x09\xd1\x37\xa0\xa3\x1a\x0d\x68\xc3\x60\
\x01\x52\x4c\xae\x40\x1b\x04\xe3\xd0\x7d\xed\x75\xe8\x2e\xd9\x4b\
\x90\x30\xfe\x09\x74\xcf\x70\xb3\xe5\x79\x22\xa2\x65\xf3\xec\xf3\
\x47\x90\x30\x3d\x13\x6d\x02\xe6\xad\xac\xf9\x96\xef\x65\xd6\x3f\
\xa0\x8d\xc8\xe9\x88\x66\xf6\x57\x3a\xe7\x8e\x0b\x7c\x01\xf8\x2a\
\xe5\xe7\x78\x1a\xb5\xa8\xdf\x86\xa3\x7e\x6f\x45\x73\xf2\x83\x88\
\x87\x34\x21\x7e\x37\x0d\xf1\x98\x5b\xf0\x73\xe8\x66\xbc\x95\xf2\
\x53\x68\x33\xe4\x66\xfb\xdf\x82\xe6\xc3\x48\x34\xaf\x4e\xb2\x3a\
\x5e\x66\xbf\x9f\x83\xc6\xbd\x09\xcd\x83\x8f\x5b\xd9\x97\xa0\xb9\
\x37\x16\xcd\xcb\xd1\xd6\xae\xcf\xa0\xb5\x74\x35\x9a\x13\xdb\x2c\
\xed\x05\x68\xee\x35\xe3\xef\xf9\x9e\x6f\x75\x9f\x82\x78\xe6\x70\
\xab\xdf\x24\x4b\xf7\x31\xbc\xf7\x54\xd1\x9e\x5f\x65\xfd\x31\xc7\
\xea\xb6\xcf\xea\xb3\x07\xf1\xf2\x93\x2d\xbf\x5b\x2d\xdd\x28\xb4\
\x9e\x1c\xdd\x71\x47\x06\x86\x22\xe5\xd0\xe9\x69\x15\xe8\xee\xee\
\x69\x48\x29\xbc\x0c\xad\xa9\x71\x88\x3e\x8c\x40\xeb\xf5\x36\xb4\
\x46\x9c\x97\x5a\x85\xb5\x6f\x08\xba\x36\x73\x89\x3d\xbf\x1c\xad\
\x93\x5a\x24\x5b\x34\x22\x5a\x71\x16\x52\x82\x6f\xc3\x5b\x69\x3f\
\x6b\xf9\x3b\x0b\xf4\x62\xeb\xbb\x19\xd6\x8e\x5a\xab\xc7\x27\xac\
\xec\x1b\xf0\xc7\x38\x2e\xb3\x7e\x38\xde\xd2\xe6\xac\xad\xb7\x5a\
\x7f\x0e\x42\x34\x64\x96\xf5\xd9\x3c\x44\x07\x3f\x89\xb7\xd2\x7f\
\x00\x7f\xcd\xd9\x61\x47\xb4\x08\x1f\x20\xf2\x39\x58\x57\xdf\xca\
\xbf\x3c\xb3\x8d\x9f\xbc\xb6\x8b\x3d\xcd\xe5\x03\xb9\xb6\x17\x13\
\xf6\xb7\x16\xd8\xdf\x5a\x60\x7d\x7d\x2b\xbf\x7c\x67\x2f\x57\x9d\
\x38\x8c\x3f\xbd\x68\x02\xe3\x87\x54\xc5\x7b\x8a\x23\x22\x8e\x7d\
\x14\x11\xb3\xfc\x5f\x78\x77\xe3\x9f\xa3\x1d\xe7\x26\xe0\x61\xb4\
\xab\xfb\xc7\xc0\x63\xc0\x7d\x88\x21\xff\x6f\x24\xf4\x8d\x05\xfe\
\x0a\x31\x49\xb7\x13\x7b\x3f\x62\x5e\x43\x11\x13\x9c\x88\xdf\x71\
\xce\x21\x0b\xc6\xdd\x88\xf9\x2c\xb4\x74\x8f\x21\x26\x5f\x63\x79\
\x4c\x41\x56\x95\x77\x2d\xed\x49\xf6\xec\x5e\xc4\xac\x1d\xb3\x2c\
\x20\x01\x63\x06\xf0\xff\xd0\x6e\xfa\xe0\xa0\x5d\x13\xf1\x56\x9f\
\x89\x88\x49\x6d\xe4\xf0\x05\xe4\x89\x88\xe8\x29\xb8\x33\xb9\xbb\
\x90\xb2\xea\x04\xd4\x97\xd1\xba\x18\x8b\xd6\x8d\xb3\x0a\x4f\x42\
\xc2\xde\x97\x91\x75\x64\x14\xd9\xca\x92\x8b\xfa\x5e\x85\xbf\x0b\
\xd5\x09\x90\xee\xbb\xbb\xe7\x3b\x7d\xa5\x59\x78\x75\xd2\x46\xb4\
\x5e\xdb\xd0\x5a\x1c\x6b\xf5\xaa\x44\x8a\xc4\x63\x88\x56\xbc\x8b\
\x17\xbe\x5d\x7e\x2d\xf6\xfb\xc3\x88\x3e\xcc\x40\xeb\x7a\x18\xfe\
\x2c\xee\x4c\x24\x9c\x3e\x47\xc7\xf5\x9c\xd8\x7b\x9f\x41\x9b\x77\
\x79\x24\x7c\xff\x0a\x6d\xba\x2d\x43\x77\x9d\x5f\x66\x6d\xfa\xbe\
\xe5\x3b\x0a\x29\x2b\xe3\x11\x1d\x7c\x02\x79\xc3\xd4\x20\xa5\x68\
\x9d\xd5\x7f\x1f\x7e\x43\xc1\xb5\xb7\xd1\xda\xf3\x0a\x52\xf6\x67\
\xa0\x6b\xfd\xee\xb2\x3a\x8d\xb6\x76\xd7\x5a\x59\x8f\x21\x8b\xdf\
\xe9\x36\x66\xbf\x40\x82\xf4\x04\x7c\x84\xe2\xd3\x90\x85\xf1\x4e\
\x1b\xbf\xe3\xac\x8e\x67\x03\x4f\x59\x9a\x76\xfb\xfe\x38\xde\xda\
\x3e\x9c\x63\xef\x7c\xeb\xe1\x44\x35\xea\xab\x49\xa8\xdf\xbb\x42\
\x82\x14\xc9\xa9\xf8\x73\xc2\x77\x22\x6f\x80\x7b\xed\xd9\x48\xc4\
\x73\xdc\x11\x9f\xd7\x80\x07\xd0\xbc\x74\x67\xb6\xc7\x23\x85\xcd\
\x9d\x6f\x9d\x88\x94\xc1\x07\x2d\xaf\x17\xd1\x1c\x58\x6d\xf9\xdc\
\x61\x69\x9e\x46\x7c\x6e\x16\x5a\x9b\x77\x23\x65\x77\x0a\x9a\xb7\
\x6f\xe3\xbd\xb6\xfe\x08\x29\xa4\x8f\x21\x25\xcc\xf1\xcc\xc9\xc8\
\x42\xba\x05\xcd\x99\x09\x68\x5e\xdd\x83\xdf\xbc\x3e\x09\xad\xa1\
\x7f\x44\xca\x64\x0d\x52\xf2\xdc\x5c\x79\x01\x29\x92\x13\x11\x6f\
\x7e\x11\x6d\xae\x6c\x43\x96\x63\xc7\xcb\x17\x23\xba\xf2\x53\xcb\
\x63\x0c\xa5\xae\xdc\x53\x90\x22\x1b\xce\xc1\x04\x78\xd4\xfa\xb0\
\xce\xfa\xec\x38\x64\x81\x7d\xc7\xda\x3c\x10\xf8\x33\x7b\x67\x3d\
\xf2\xf8\xda\x89\xb7\x26\xcf\x47\x7c\x7e\x35\x9e\xaf\xb7\xa3\x75\
\xfd\xa8\xf5\xc7\x54\x1b\xf7\x37\xad\x7e\xb5\x48\x5e\x99\x47\xf6\
\x75\x60\xcb\xad\xec\x49\xc0\x1f\x58\x3f\x9e\x6d\x63\xe2\xee\x83\
\x3e\xdb\xfa\x66\x95\xcd\x87\x45\xd6\x6e\x47\x37\x66\x06\xf3\xa6\
\x88\x36\x5f\x56\xdb\xf8\xd6\xe2\xdd\xa5\x8f\x08\xa2\x22\x7c\x00\
\xc8\xe7\xe0\xdd\x3d\x6d\xdc\x7e\xdf\x7a\x1e\x5f\xb3\xaf\xe4\xb7\
\x01\x55\x79\x46\x0f\xac\x64\x48\x6d\x85\x7c\x8a\x5a\x8b\x6c\x6f\
\x68\x67\x5f\x8b\x57\x94\x9b\xda\x8a\xfc\xf8\xb5\x5d\x0c\xac\xce\
\xf3\x7f\x2e\x9d\x44\x4d\x45\xae\xdf\x6e\x39\x46\x44\xf4\x11\xe4\
\x11\xd3\xfc\x3a\x62\x64\x2d\x48\xa9\x1d\x62\x9f\x9b\x10\x9d\xad\
\xc1\x0b\x94\xee\x9e\xe0\x41\xf8\x73\xb9\x20\xa6\x31\x1a\x09\x9a\
\x20\x46\x99\x15\x35\xb2\x9e\xd2\xe8\x8d\x35\x88\xd1\x8c\x47\xcc\
\x23\x8c\xee\xba\xdf\xca\xca\xdb\xe7\xf0\xbe\x4e\x07\xc7\x07\x9c\
\x90\xde\x84\x04\xa1\x1a\x4a\xef\xeb\x7e\x00\x09\x14\xd1\x93\x28\
\xa2\xaf\xa0\x12\x7f\x06\xad\x16\xad\x59\x77\xd7\xe9\x43\x48\x88\
\xc5\xd2\xb8\xf3\x8e\x6e\xbd\xee\x45\x96\x55\xf7\xbb\x8b\x92\xeb\
\x94\xba\x8d\x48\x80\x7e\x11\xd1\x83\x01\x48\xf9\x6b\x46\xca\xb7\
\x53\x02\x41\xeb\x2d\x44\x0e\x09\xc2\x2d\x41\x1d\xc3\xfb\xc7\x9d\
\x85\x2d\x87\xa7\x27\xa1\xd2\xd6\x62\xf5\x73\x0a\x77\xde\xea\xdf\
\x18\xb4\xe1\x6e\xa4\x44\x13\xa4\x09\xcb\xdf\x8b\xee\x7e\x5d\x6f\
\xbf\xef\xb5\x7c\x13\xfc\xb9\xe1\x3a\xab\x87\xeb\xc3\x06\x64\x39\
\xaa\xa2\x34\x60\xd7\x00\x64\x89\x3a\x19\x09\xc3\xd5\x74\x8c\xa0\
\xdd\x68\x7f\xee\xbc\xb0\x73\x6b\xbe\x1c\x29\xd0\x0e\x8e\x86\xee\
\x0b\xfa\xa6\x29\xd5\x9f\xae\x0d\xb5\x48\x99\x70\x7d\x12\x5a\xe7\
\x1b\xf1\xf4\x7b\x07\x5e\x08\xcf\xd1\xbf\x37\xfa\x72\x88\xc7\x7c\
\x19\x29\x9b\xee\xaa\xa3\xae\xde\x79\x0a\xcd\x17\xd7\xb7\xfb\x10\
\x4f\x7a\xbf\x7d\xdf\x6c\x69\xdd\x38\xed\xb5\xb4\xe3\x90\x45\x74\
\x17\x52\x18\xdd\x18\xfc\x00\x6d\x72\x9c\x8c\x14\xbe\x6f\xa0\xb5\
\x74\x1a\xf2\x22\xd8\x64\xe9\x0b\x88\xe7\xba\x31\x73\x73\x28\x9c\
\x0b\x8e\x0f\x16\xd1\x5c\x19\x6c\x79\x4c\xa4\x94\x67\xe6\x82\x3f\
\x2c\x5f\xd7\x3e\x77\x76\xbe\x0d\x4f\x23\xf6\xdb\xb3\x7a\xfb\xbe\
\x05\xad\xa9\x0b\xad\xed\xf7\x22\x3e\x0f\xa5\x7d\x58\x8b\x0f\x5c\
\xe5\x78\xb8\x9b\xcb\x20\x85\x7e\x8d\xd5\xd9\xb5\xab\x1a\x79\x70\
\x8d\xb6\xdf\xc2\x3a\xd7\x53\xaa\xa4\x86\xbf\xb9\x67\x15\xf8\xb5\
\xe3\xda\xe8\x36\x95\xc2\x63\x03\x39\x6b\xd3\x4e\x7b\xb7\xcd\xde\
\xa9\xcd\x18\xf7\x24\x68\xbb\xdb\xc4\x4b\xaf\xaf\x37\x6d\x9c\x86\
\x06\x63\x3e\xd0\xda\xe6\xce\x3a\xef\x4f\xe5\x9b\xd5\x3f\x8e\x2e\
\x1c\x76\x44\x81\xe6\x00\xd0\x56\x48\xf8\xea\x73\xdb\x4a\x94\xe0\
\xc1\x35\x15\x7c\x7c\xd1\x28\xbe\x7b\xe3\x74\xee\xfc\xd0\xf1\xfc\
\xe4\x16\xfd\xdd\xf1\xc1\xe3\xf9\xf1\xcd\x33\xf8\x83\x73\xc7\x31\
\x69\x68\x29\x8f\xbb\xe7\x8d\x7a\x5e\xd9\xd4\x48\x3e\xfa\x48\x47\
\x44\x1c\xeb\xc8\x21\x01\x6b\x1b\x72\x1b\xdc\x13\xfc\xe6\x18\x51\
\x01\x31\x83\x73\x90\x20\x7c\x3e\x22\xee\xee\xdc\xdc\xe9\x48\x60\
\xbe\x0d\xb9\x03\x1e\x87\x2c\x23\xcb\x11\x13\x4d\x33\xe8\x7c\x50\
\x76\x0e\x31\xf5\xf9\xc8\xa2\xf1\x0c\x9e\xa9\x86\x0c\x3d\x14\xee\
\xdc\x67\xf7\x7f\x17\x62\x50\xe7\x22\x0b\xd1\x99\x48\x90\x5d\x8d\
\x98\xe0\x46\x74\xa6\xe7\x38\x3a\x0a\x18\x11\x11\xc7\x2a\x72\x78\
\x01\xad\x02\xcd\xf7\x66\x24\xb0\xbf\x8d\x2c\x23\x79\x64\xad\x38\
\x0f\x09\xde\x05\xe4\x1a\x3c\x0b\x59\x7e\xf2\x48\xc9\xbb\x8c\x52\
\x37\xe3\x22\xb2\x62\x2d\x46\x96\xb2\x05\xc8\xaa\xf2\x59\xe4\xf9\
\xb1\xd3\xf2\x3a\x09\xad\x7d\xe7\xee\x19\xae\xd9\x50\x3e\x73\x34\
\xc0\x59\x30\x57\xa2\x75\x3a\x03\xd1\x15\xe7\xb6\x18\xa6\xcb\xa5\
\xde\x5d\x69\xdf\xd7\x20\xc5\x72\x1a\x3e\x52\xeb\x99\x64\x2b\x3b\
\x3b\x11\x5d\xdb\x89\x57\xb6\xc3\xfc\xdf\x46\xca\xc4\x22\xa4\xb4\
\xce\x47\x56\xb4\xd5\x68\x73\x6e\x0a\x72\x6b\x7c\x0f\x52\x84\x97\
\x02\x8f\x58\xde\xd5\xa9\xfa\xb9\xf6\x86\x82\xfc\x29\x36\x46\xf7\
\xe3\x95\x8e\xf0\x1d\xf0\xb4\x2c\x7c\xee\xfe\x96\x5b\xdf\x9e\x68\
\x6d\x74\x67\xa6\xd7\x5b\xff\x2f\x45\xf4\xd3\xb9\xa8\x0f\xb2\x76\
\xee\xa1\x6b\xe5\xaf\xaf\xe3\x2d\x64\x25\xdc\xdf\x8d\xbe\x70\x1b\
\x37\x5b\xd1\x78\xb9\x4d\xd7\xc9\x78\x85\xf0\x6d\xa4\x00\x85\x73\
\xc8\x05\x9c\x1c\x8c\x2c\xaf\x1b\xd0\x7a\xaa\x41\xae\xfd\xdb\x91\
\x72\xdd\x84\x3c\x22\x36\x5b\x19\xef\xa5\xf4\x6e\xe2\x90\xcf\xb9\
\x79\xe4\xe6\x50\x82\x9f\x9b\x8b\x90\xf5\x75\x33\x5a\x93\x4f\xe0\
\x79\x66\x95\xe5\x57\x8d\xd6\x53\x7a\xa3\xa6\x12\x9d\x67\xaf\x46\
\x73\xe9\x78\x34\xc7\x5f\x0b\xca\x6b\xb7\x7a\x5d\x6a\x75\xdf\x62\
\x6d\xac\x41\x73\xcc\xd5\xe9\x2d\xfc\x91\xa7\xb3\xd1\x31\xaa\x6a\
\xbc\xb2\x3d\x09\x6d\x18\x85\x8a\xec\x40\x64\x65\x7e\x0c\x9d\x57\
\xae\xa1\xe3\xda\x71\x9f\x5d\x20\xaa\x91\x48\xa9\xac\x40\x3c\x7e\
\x1b\xe2\xf3\x53\x91\x85\x7b\x6e\x6a\x1c\x5d\xfd\x96\x5b\xff\x9c\
\x88\x36\x1e\x46\x23\xfa\x51\x41\xe9\xfa\xcf\x92\x31\xf6\x59\x3f\
\x15\xd1\xfa\x1a\x68\xfd\x49\xf0\xde\x3b\x36\xce\x8b\x91\xa5\x79\
\x61\xaa\xfc\xb7\xac\x6e\xb3\xac\xbe\xce\xbd\xfe\x88\xc8\x1e\xd1\
\x22\xdc\x4d\x54\xe4\x72\xbc\xba\xad\x89\x3b\x5f\xdf\xfd\x9b\x67\
\x75\x55\x79\xbe\x74\xc1\x78\x3e\xbe\x68\x14\x35\x95\x79\x92\x20\
\x10\x56\x0e\x98\x36\xa2\x86\xd3\xa6\x0c\xe4\xcc\xe3\x06\xf1\x3b\
\xf7\xad\x67\x7d\xbd\x0c\x2e\xbb\x9a\xda\x79\x72\xed\x3e\xce\x98\
\x32\xb0\xa7\x9b\x15\x11\x11\x71\xf0\xc8\x21\xa1\xca\x05\x93\x09\
\x05\xb9\x76\x64\x4d\x72\x56\x91\x07\x91\x65\xe3\x66\x24\x6c\x7f\
\x1b\x31\xba\xef\xa3\xf3\x3b\xa7\x22\x57\xa2\x67\x11\x43\xbc\x0a\
\x31\xad\x67\x11\x63\x71\xd6\x65\xc7\x64\xb0\x32\xde\x42\x02\xfa\
\xfd\x88\xa1\xee\x42\x2e\x58\x8d\x48\x30\x59\x8d\xb7\xee\xac\xb4\
\xba\x35\x5a\xdd\x5a\xed\xd9\x2e\xe0\xbb\x56\xe6\xfb\x2d\xbf\x8d\
\x96\xf7\x3d\x88\xa9\xe7\xed\x9d\x4d\xc4\x0d\xd4\x88\xbe\x81\x1c\
\x9a\xe3\x67\x21\x25\xf6\x2d\xe4\x86\x7b\x31\x12\xe8\x56\x22\xc1\
\x7c\x11\x12\xd6\x9f\x45\xae\x7a\x17\x22\xe5\xb1\x15\x7f\x0e\x72\
\x36\x12\x1e\x9d\x80\xe0\x2c\x21\xff\x89\x14\xd5\x21\x48\x01\x6d\
\x45\x42\xe8\x20\xe4\x76\xf8\x5e\xa4\x28\xbc\x84\x84\xe6\x16\x64\
\x51\x6a\xc2\xaf\xd7\xa2\x7d\xde\x6b\xf5\xd9\x8d\x94\xcd\xab\x11\
\x3d\x69\x42\xc2\x78\x1b\x5a\xa3\x2e\x00\xd5\x3e\xbc\x95\xaa\xdd\
\xca\x70\xf1\x04\x40\xee\xcd\xdb\x90\xb0\xbb\x08\x09\xf0\x4e\x84\
\x71\x79\x35\xd3\x51\xd1\xd8\x88\xb7\x54\xad\xb6\x76\x5c\x68\xbf\
\x3f\x8a\x36\xf8\xde\xb4\xfa\x7d\x08\x29\xd1\x77\x59\x1f\x5e\x88\
\x14\xe7\xcd\xc8\x92\xd4\x8e\x84\xe2\x16\x44\x0f\x9d\x65\xd7\x1d\
\x2d\x79\x16\x9d\xfb\xbc\x09\xd1\x9e\xe7\xac\x0e\x6b\xf0\x56\xa4\
\xb7\xf1\x56\xa9\x35\xc8\xba\xeb\x84\xff\xe7\xad\xcd\xd7\x5b\x7f\
\x2c\xb3\x7e\xfc\x2f\x74\xf6\xf8\x23\xf6\xfd\x09\xeb\xe7\x69\xf6\
\x7e\x7f\x76\x8b\x76\xe8\x2e\x9d\xcf\xa1\xb1\xa9\xa4\xe3\x06\xcc\
\x5b\x68\x3e\x5c\x8f\xc6\xfc\xd7\x88\xff\x6c\x41\x8a\x4d\x25\x9a\
\xcb\x33\xd0\xb9\xd2\x4d\xc0\x93\x68\xac\x96\xa3\x4d\x24\x17\xb8\
\xee\x39\xa4\xdc\xbd\x66\xe9\x9d\x77\xd2\x06\xbc\x87\xc5\x3a\x7c\
\x50\xa5\x8d\xf8\xcd\xa5\x3d\x68\x03\xab\x0e\xad\xe1\x65\x88\x27\
\x9f\x65\xef\xbe\x81\xe6\xe0\x0e\xfb\x7c\x96\xd5\xc5\x59\x35\x1b\
\xad\xbc\x8d\xc0\xf7\xd0\x3c\x3e\xcd\xf2\x79\x14\xf1\x5e\xe7\x55\
\xb1\xc2\xca\x73\xae\xc7\x5b\x50\x20\xb1\xb3\xf1\xc1\xb2\x96\xe1\
\xbd\xbf\xda\xad\x4e\x7b\xad\xdf\xea\x10\x0d\xd8\x4c\xa9\x82\x5b\
\x8f\xf8\xf1\xb9\x68\x4d\x2d\xc7\x47\xe9\x5e\x8b\x97\x3b\xde\xc4\
\xaf\x9d\x4b\x91\x8b\xb7\xa3\x1f\xdf\x43\x67\xf7\x6f\x41\xeb\xed\
\x69\x44\x9b\xdc\x66\xc7\x56\xeb\x87\xe7\xd0\x06\xe1\xb5\xd6\xe7\
\x3f\xb2\x32\x56\x59\x3d\x36\xa2\x35\xd2\x8e\x3f\x3a\xd2\x62\x65\
\xef\x41\xf2\x8d\x5b\x5f\x7b\xd0\x26\xfd\x38\xfc\x75\x4b\xdb\xd0\
\xe6\xc8\x79\x78\x4f\x93\xa2\x95\x5f\x89\x68\xd5\x48\xe0\x3a\x44\
\x33\xef\xa0\x7b\x1b\x32\x07\x85\xdc\x92\x49\x03\xeb\xbf\x7d\xc3\
\xf4\xa1\x63\x07\x55\xf6\xbb\x33\xab\xf9\x5c\x8e\xbf\xff\xf5\x16\
\xfe\xf2\x91\x4d\xbf\x79\xb6\x70\xc2\x00\x7e\x72\xcb\x0c\x46\x0c\
\x28\xed\x8f\x5c\x0e\xbe\xf2\xf8\x16\xfe\xfa\xf1\xcd\xbf\x79\x76\
\xf9\x09\x43\xf9\xfa\xfb\xa6\x32\xb0\x26\xdf\x69\xdf\xe5\x72\xf0\
\xe7\x0f\x6f\xe2\x9f\x9e\xde\xfa\x9b\x67\xd7\xcc\x19\xc6\xbf\x5f\
\x37\x95\x7c\xae\x7f\xd1\xda\x96\xf6\x84\xcf\xdf\xbb\xae\xfe\xce\
\xd7\x77\xdf\xce\xe1\xbd\x13\x35\x22\xe2\x48\xa0\x80\xce\xc9\x6d\
\x42\x84\x3b\xed\x32\xe7\x76\x44\xb3\x82\x89\xb8\x9d\xd9\xf0\x1a\
\x0a\x77\xb5\x49\x7b\xf0\xbb\x73\x59\x6a\x0b\xf2\x0c\x5d\x36\xb3\
\x5c\xfe\xc2\x8b\xe7\xdd\x59\xc3\xf0\xda\x14\x67\xb9\x75\x69\x73\
\x65\x3e\xbb\xbc\xdd\xe7\xd0\xfd\x28\xed\xea\xe4\xdc\xc1\x22\x22\
\x7a\x12\xd5\xc0\x17\x91\x70\xd4\xd5\x1d\x9f\x5d\x21\x87\x94\xb5\
\xb5\x48\x58\x73\x6b\xcf\xcd\x77\x82\xfc\x07\x20\x01\xf2\x25\x24\
\xdc\x7d\x10\x9d\x4b\x7d\xda\xde\xc9\xba\x6e\xc6\x45\x7c\xad\xc4\
\xdf\x51\x3c\x0a\x09\x93\x2d\xf8\x00\x30\x69\xd7\xe7\xf4\x11\x86\
\xf0\x2c\x6d\x12\x3c\x77\x56\x2c\xf0\xb4\x22\x5c\xd7\xa1\x95\xd9\
\xd1\x09\x67\x00\x71\xd7\x45\x9d\x60\x7f\x3f\x4b\xd5\x3d\xcc\xa3\
\xb3\xe7\x45\x7c\x40\x3d\x47\x23\x5c\xb9\x55\xf6\xcc\xa5\x0d\xcb\
\x4e\xd3\x28\x57\xf7\xb0\x0c\xd7\x7f\x8e\x3e\x86\xef\xb8\x3a\xe4\
\x33\x3e\x87\xfd\x1f\xf6\x53\xd8\x0f\x79\xab\x4f\x1b\xde\x6a\x77\
\x2b\x52\x02\x5e\xa4\x6f\xcb\x26\x09\xb2\xd2\x7d\x11\xf8\x5b\x0e\
\x3d\x22\x6f\x39\x3e\x18\xce\x03\x37\xdf\xc2\x31\x0a\xc7\xcd\x8d\
\x05\xf6\xdd\x9d\x87\xcf\xe3\xa3\xae\x3b\xe5\x71\x27\x5a\xff\xa1\
\xd5\x37\x3d\x17\x5c\x7d\x16\x20\x2f\xac\xaf\xe2\x8f\x22\xb9\x74\
\xce\xca\xd8\x4e\xe9\x11\x04\xe7\x26\x9c\xb5\x86\x8a\x41\xbd\xc2\
\x63\x4d\xce\x9a\x7b\x0a\x52\x7a\xff\x19\xaf\xbc\x65\xe5\x99\xe6\
\xd9\xe1\xfa\x2f\x27\x53\x74\xc5\xe7\x5d\xdf\x85\x6b\x3d\x5c\xa7\
\xae\x8f\x2a\x32\xea\x1e\xb6\xd3\xd1\x14\xd7\x3f\xae\xcf\xd2\xeb\
\x8b\x4e\xca\x0e\xc7\x34\xf4\x56\x29\x20\xab\xfc\xb5\x68\x63\x04\
\x44\x4b\xbf\x8d\x36\x4e\xc2\x31\xcc\xea\x9f\xc3\x81\xc4\xe6\xd2\
\x6d\xc0\x17\xa2\x45\xb8\x9b\x68\x2d\x24\x6c\x6f\x68\x63\xfc\xe0\
\x2a\xf6\x34\x17\x48\x80\xf7\xcd\x19\xce\xe0\xda\x0a\x0a\xc5\xce\
\x77\x10\x2a\x72\x39\x16\x4d\x1a\x40\x45\x3e\xf7\x9b\xb4\xfb\x5b\
\x8a\x14\x13\x62\x04\xe9\x88\x88\x63\x1b\x59\x82\xa2\x43\xc8\xc8\
\xdc\x4a\x77\xc2\x70\xb8\xd3\xeb\x98\x6b\x48\x0d\xda\xcb\xe4\xe3\
\xca\x4c\xff\x96\x0b\xde\x09\x19\x53\x5a\xe0\x48\x7f\x0e\xdf\x4f\
\x28\x2d\xd7\x3d\x2f\x04\x9f\x23\x22\xfa\x12\x8a\x28\xa0\xd4\x02\
\xa4\x60\x87\xf7\xde\x86\x6e\x89\x20\xab\xd0\x1b\xc8\x1a\x94\x20\
\x2b\xd5\xcb\x94\x2a\x70\x69\x38\xa1\xae\x2d\x78\xe6\xae\x49\xc9\
\x53\x7a\xe6\x2d\x29\xf3\x1f\x3a\xae\xe7\x34\x3d\x49\xa7\x4b\xdf\
\x3d\x1a\xbe\x97\x6e\xdf\x6e\x74\xbe\x33\xa1\x74\x8d\x97\x6b\x53\
\xfa\x79\x3e\x23\x4f\xf7\xbf\x2d\xf5\x3d\x4c\x97\x6e\x53\x31\xa3\
\x8c\x34\x7d\x4c\xbf\x53\xee\x3d\x82\xf7\xc3\x7e\x0a\xfb\x21\x1c\
\x97\x1c\xda\xa0\x58\x8f\xac\x77\x7d\x59\x09\x3e\x12\x28\xc7\x07\
\xd3\xf3\x00\xb2\xc7\x28\xc9\x48\xe3\xe6\xaa\x53\x82\x72\xc8\xaa\
\x5b\x8b\xdc\x83\x73\x19\xf9\x65\xcd\xfb\xbd\xc8\x52\x1c\xde\x9d\
\xeb\xca\x0d\x79\x66\xb8\xa1\x94\x5e\x57\x61\xfb\xdc\x7a\x0f\x79\
\xb6\xfb\x3e\x11\x29\xc1\x3f\xa7\xd4\x82\x59\x8e\xb7\x86\xe5\x77\
\xd5\x97\x59\xef\x74\xb6\x1e\xc2\x36\xa5\xfb\x3a\x8c\x29\x90\xd5\
\x67\xe5\xe4\x95\x72\xca\x79\x56\xd9\xe9\xf5\x15\xe6\xed\x8e\x27\
\x5c\x61\x75\xfc\x05\xb2\x5a\xe7\x28\x5d\xa3\x59\xfd\x73\xd8\x11\
\x15\xe1\x6e\xa2\x32\x9f\xe3\x0f\xcf\x1f\xcf\x6d\x4b\x46\x53\xdf\
\x5c\x60\x47\x43\x3b\x4b\x26\x0d\xa4\xd8\x0d\x33\x7a\x2e\x07\x23\
\xea\x2a\xa9\x0a\x14\xe1\xd6\x42\x42\xa1\x08\x95\x91\xdc\x46\x44\
\x44\x44\x44\x44\xf4\x04\x9c\x5b\xe7\x56\xba\x77\x57\xea\xaf\x91\
\xcb\xe1\xa1\x78\x48\xf4\xa6\x0d\xa5\x1c\xa5\x77\xee\xf6\x57\x38\
\x17\xf2\x07\x88\x31\x10\x7a\x2b\x12\xe4\xb5\x10\x06\x35\xeb\x0a\
\x79\xe4\xed\xb1\x8e\xee\x5d\x01\x75\x28\xc8\x23\x37\xff\xbf\xa1\
\x63\xf0\xba\x88\x52\xb4\x23\xd7\xf4\x87\xe9\xa8\x98\x1f\x75\x44\
\x45\xb8\x9b\xc8\x01\x23\x07\x54\x32\x6a\x40\x25\x39\x73\x67\x2e\
\x16\x93\xdf\xb8\x44\xe7\x90\xc2\x0b\x90\xcb\xe5\xb4\x55\x93\x24\
\xb4\xb4\x27\x6c\xdd\xdf\xc6\xcb\x9b\x1a\x69\x0f\x2c\xc7\x85\x24\
\xa1\x90\xa4\x37\x60\x23\x22\x22\x8e\x51\x84\x3b\xaf\x61\xf0\x8a\
\x2c\x84\x6e\x5c\x07\xf3\x7b\x44\x44\xc4\xe1\x81\x0b\x2a\x03\xa5\
\xcc\xd8\x59\xa1\xd2\x6b\xd0\x59\x59\xba\x12\xc4\x93\x8c\x3c\x7b\
\x2b\x42\xab\x6b\x3a\x40\x50\x1a\xe1\xd1\x8a\x23\x81\x03\xa1\x7d\
\x61\x1f\x1f\x8e\x7a\x25\x65\x9e\xa5\xf3\x3e\x16\xc6\xb4\x27\x70\
\xa4\xf8\x96\x9b\x9b\x0e\x61\xe0\xc7\xee\x8c\x7b\x67\x16\xd6\x23\
\xd1\x07\xa1\x1b\x6f\xb9\x3e\xe9\xaa\xde\x45\xfa\x3e\xff\x3f\x6a\
\x16\xdf\xae\x10\x15\xe1\x03\x40\x92\xd8\x6a\x4a\x12\x71\x48\xd3\
\x7c\xdb\x8b\x09\x8d\x6d\x45\xf6\xb7\x15\xd9\xdb\x5c\x60\xdb\xfe\
\x36\x36\xec\x69\x65\xf5\xae\x16\x56\xec\x68\xe6\xed\xed\xcd\xac\
\xab\x6f\x2d\x51\x84\x43\x05\x3a\x6e\x3f\x46\x44\x1c\xb3\x70\xa1\
\xfd\x4f\x46\x41\x70\x5a\xd0\xd9\xf7\xb5\x9d\xa4\x1f\x8e\x02\xd4\
\xbc\x48\xb6\x0b\xd6\xf1\xc8\x4d\xf3\x0d\xa2\xd0\x15\x11\x71\xa4\
\xe0\x22\xd6\x9e\x86\x82\x25\x6d\xc4\x9f\x67\xbc\x1c\x59\x08\x5f\
\x2e\xf3\xee\x42\x14\x64\x67\x1d\xd9\x02\xeb\x04\x14\xb0\xe6\x58\
\x09\xba\x34\x0f\x05\xfc\x7a\x16\x05\xea\xc9\xaa\xb3\xbb\x5b\xbc\
\x11\xb9\x31\x1e\x6e\x41\xdd\xd1\x46\x57\x8f\xa4\x8b\xb4\x23\x90\
\x9b\xec\x76\x14\xec\xeb\x0d\xfc\xf5\x2c\x87\xab\x3e\x43\x50\xb0\
\xb3\x7d\x28\x30\x58\x23\x1a\xf7\x63\x61\x4c\x8f\x26\x12\xe4\x5a\
\x3e\x06\x05\x4c\x3a\x9c\x38\x13\x45\x6e\x07\x79\x61\xac\x44\xee\
\xeb\x2d\x28\xea\xf0\x76\xca\xaf\xc3\x9e\xee\x93\xb1\xc0\x74\x34\
\x9f\x1d\x72\x28\x82\xfa\x7a\xfc\x31\x89\x10\xb5\x68\x0d\xbc\x8e\
\xbf\xd2\x30\xe2\x08\x22\x2a\xc2\x07\x81\x8a\x5c\x8e\x86\xb6\x02\
\x2b\xb6\x37\xf3\xcc\xfa\x06\x96\x6f\x6d\x64\xcb\xbe\x36\xb6\x35\
\xb4\xb3\xa3\xa1\x9d\xc6\xb6\x22\x8d\x6d\xc5\x2e\xcf\x0e\x47\x44\
\x44\x1c\xd3\x70\xc1\x31\x3e\x86\xae\x08\x78\x05\x5d\x03\x71\x1b\
\x3a\xf3\xf2\x18\xa5\x01\x28\x9c\x75\xa1\x16\x5d\x2b\xf2\x12\x1d\
\x2d\xc9\x20\x01\x6f\x00\x62\x84\xe9\x9d\xf0\x30\x88\x8c\x43\x7f\
\xbe\xf3\x32\x22\x22\x8d\xee\x5a\xa6\x12\x24\x70\xde\x8e\x94\xdf\
\xff\xb6\x67\x53\x80\xcf\xa1\x35\xfc\x52\x90\x5f\x78\xad\xcf\x78\
\xb4\x06\xd7\x50\xaa\xb0\xe5\x2d\xaf\x9b\xd1\x39\xc1\x9d\x94\x9e\
\x21\x0e\xaf\x8d\x49\xbf\x17\x06\x72\x0a\xcb\x2a\x97\x36\xc9\xc8\
\x37\xeb\x59\xba\xcd\xc5\x54\x5e\xb5\x28\x58\xcd\xcb\x48\x79\xcf\
\x4a\xeb\xca\x1b\x87\xbf\xc7\x3c\xab\x4e\xe1\x75\x36\xe9\x33\x94\
\x0e\x69\x7a\x55\x0c\xca\x1a\x85\x22\xdd\x3e\x83\x0f\x28\xe8\xf2\
\x0a\xad\x80\x45\x74\x0f\x6c\x3b\x72\x67\xbe\x04\x6d\x64\xb8\xe8\
\xc1\x15\x74\x6c\x6b\x68\x77\xc8\xb2\x7c\xa7\xfb\xbe\x88\xae\xb6\
\x5b\x02\xfc\x04\x05\x4a\x7b\x04\x45\x16\xee\x6a\x4c\xbb\xb2\xac\
\xf7\x35\x54\xa0\x08\xe8\xef\xd0\xf1\xdc\x6a\x56\x5f\x64\xcd\xc3\
\xac\xfe\xca\xa1\xc8\xd1\x05\xb4\xd1\x31\x00\x45\x10\x3f\x1e\xf8\
\x21\xda\x70\x6a\x43\x1b\xcf\xa1\x67\x47\x78\xa6\x35\x5d\x8f\x2c\
\xef\xad\xd0\x42\x9b\x8e\xa7\xe1\xde\xcd\xa2\x03\x59\x67\xf7\xc3\
\x75\x31\x08\xd1\x13\xb7\xb1\xe3\x02\x80\x9d\x07\xfc\x0a\x6d\xb6\
\x85\x6b\xc5\x05\xe0\x9a\x83\xd6\xe5\x53\xf4\x3e\x05\xbf\xcf\x21\
\x2a\xc2\x07\x00\xb9\x3b\xc3\x13\xeb\xf6\xf1\x9f\x2f\xee\xe0\xa9\
\x75\xfb\xd8\xde\xd0\xde\xe5\x7b\x83\xaa\xf3\x0c\xaa\xa9\x60\xeb\
\xfe\xb6\x7e\x17\x99\x3b\x22\xa2\x0f\xc3\x09\x4a\x13\x81\xbf\xc6\
\xdf\x21\xbc\x11\x09\x96\xaf\x23\x2b\xf1\x16\xb4\x63\x3d\x05\x5d\
\x09\xb0\x0e\xed\x06\x57\x21\x21\x0b\xc4\xd0\xd7\x22\x61\x74\x27\
\xb2\x40\x8c\x46\x77\x60\x62\xef\xbd\x84\x04\xef\x3a\x74\xdd\xd2\
\x58\xfb\xbe\x8c\xd2\x40\x23\x11\x11\xfd\x19\xb5\xc0\x30\xfc\xdd\
\xb7\x5d\x61\x15\x5a\xa7\x03\x51\x80\x9b\xb9\xc8\x2a\xda\x82\xd8\
\xfe\xf1\xc8\x62\x5a\x8d\xa2\x54\xbf\x85\xae\x36\xd9\x6d\xbf\x4d\
\x40\x96\xc3\x6a\xfc\x75\x24\x27\xa3\xeb\xcb\xd6\xa2\xcd\xb1\x53\
\xf1\xd7\xc0\xac\xb3\xfc\x86\xe1\xef\x1e\x7e\x0a\x29\x98\x53\x91\
\xd5\xb5\x16\x5d\xd7\xf2\x2a\x52\xd6\x47\x06\x69\x9f\x46\x0a\xdf\
\x58\x64\xcd\xae\x42\xf7\x75\xae\x46\x16\xb9\x53\xad\x2e\xcb\xf0\
\x57\xbb\x61\xef\xd6\x22\x9a\x33\x1e\xd1\xa9\x97\x2c\x8f\xe3\xd0\
\x46\x5e\x73\x90\x76\xb8\xfd\x36\xc4\xda\xfc\x1a\xa2\x65\xfb\x11\
\x2d\x9b\x86\x14\x93\x81\x28\xd2\xf2\x0e\x14\x9d\xf7\x65\x44\x0b\
\xe7\x22\x0b\xea\x56\xab\xd3\x38\x44\xf7\x5e\xa2\x94\x5e\x9d\x82\
\xae\x6a\x19\x68\x63\x56\x85\xae\x88\x19\x63\xed\xda\x62\x75\x7e\
\xd6\xfa\x74\xa6\xd5\x7f\x11\xfe\xae\xe0\xc4\xfa\xf4\x54\x1b\x9b\
\xe7\xad\xbc\x49\xd6\x8e\x0a\xeb\xcb\x13\xad\xce\x4f\x51\x1a\x29\
\x39\x67\xbf\xcd\x41\x72\xf1\x32\x1b\xdf\x73\xec\xdd\xf1\xf6\x7b\
\xb3\x8d\x4b\x9d\xf5\x4d\x85\xd5\x71\xad\xd5\x67\x88\x8d\xf7\xd3\
\xd6\x96\xfe\xa0\x0c\x17\xd1\x3a\x18\x8f\x22\x39\xbb\x35\xb3\x00\
\x8d\xff\xf3\x68\x6e\x84\xee\xc2\x13\xd1\x98\xba\x6b\xfe\xd6\xe3\
\xaf\xe1\x49\xa3\x0d\x8d\xfd\xaf\xf0\x57\x0f\xfd\x36\xf2\xe2\x78\
\x17\xad\x9b\x41\x88\x17\x8f\x46\x3c\xf1\x15\xbc\x07\xc3\x2c\x4b\
\xf3\x1c\xda\xe8\x39\x13\x29\x97\xe3\x90\x75\xf9\x0d\x34\x6f\x56\
\xa2\xb9\x36\x06\xcd\xb1\x3d\xf6\x79\x10\x1a\xe3\x6a\xc4\x8f\xab\
\xec\x9d\x37\xd0\x7c\x19\x84\x68\x40\x83\xe5\x71\x92\x95\xfd\x04\
\xe2\xe3\xeb\xad\xcd\x93\xac\x9c\x46\x34\xd7\xdd\xe6\xce\x29\xc8\
\x33\x65\x9b\xf5\xd5\x7e\x74\xe5\xd4\xfb\xac\x5c\x77\x05\x63\xc4\
\x11\x42\xdc\x69\x38\x00\xb4\x27\x09\xdf\x5d\xba\x93\x5b\xef\x5c\
\xcb\xdd\x6f\xec\xce\x54\x82\xab\x2b\x72\x8c\x1c\x50\xc9\xdc\xb1\
\x75\x5c\x36\x6b\x28\x5f\x3c\x6f\x3c\xdf\xbd\x71\x3a\x7f\x7e\xf1\
\x44\x2a\xfa\xd9\x55\x49\x11\x11\x7d\x1c\x79\x24\x7c\xbd\x8e\x98\
\x66\xa5\xfd\x2d\xc7\xdf\x49\x79\x3e\x62\x72\x05\xfb\x7e\x06\xb2\
\xf8\x5e\x80\x98\xe1\x2d\x48\x80\xda\x6f\x9f\x67\xa3\xab\x4c\x4e\
\x46\x82\xee\xa7\x90\x20\x57\x83\x2c\xcd\xc3\xd1\xdd\x7a\xa7\x20\
\x41\xee\x62\x7c\x14\xdb\x88\x88\xfe\x8e\x3c\xf0\x51\xe0\x6b\xe8\
\x1e\xdb\xae\xd6\x85\xbb\x7b\xb4\x88\x94\xc1\x3a\xa4\xe4\x2d\xb3\
\xdf\xc7\x21\xeb\x6e\x2b\x12\xc8\x6f\xb3\x67\xa7\x22\xa5\x75\x36\
\xf2\x08\x01\x98\x8c\xae\x62\x2a\x20\x81\xbb\x1e\xad\xf5\x4f\xe1\
\xaf\x01\xf9\xb8\xbd\xbf\x18\xad\xf7\x16\xa4\x30\x7e\xc0\xd2\xde\
\x82\x84\xde\x46\xe0\x13\x56\xa7\x30\xed\x3c\x74\xd7\xf7\x30\xab\
\xcb\x30\x6b\xe3\x8d\xc8\x05\xf3\x56\xa4\x8c\x35\xa3\x3b\x3c\xa7\
\x53\x6a\xb9\x7c\x3f\x52\xee\x76\x21\xba\xf1\x3e\x24\xac\x37\xe3\
\x2d\xbd\x0e\x37\x58\x1b\xf7\xa2\xab\x4e\xc6\x5b\x5d\x4e\xb0\x7c\
\x3f\x89\x94\x83\xd1\xd6\xae\xa1\xd6\xe7\xc3\x2d\x9f\x45\x48\x09\
\x39\x17\x29\x1f\xdb\x80\xf7\xe0\x15\x05\xac\xee\x17\xa3\xe8\xb1\
\xfb\xad\x8f\xa7\x21\xc5\x02\x6b\xe3\x48\xab\xeb\x89\xd6\x86\x2b\
\xad\xdd\xfb\xac\x6e\x4d\x56\xe6\x49\x96\xc7\x75\x48\x01\x3a\xde\
\xde\xcf\xdb\x6f\xbf\x8f\xe8\xe8\x4c\x4b\x13\x5a\xab\x27\x59\x1f\
\x36\xda\xb3\x4f\x21\x85\x76\xaf\x95\x53\x6f\x7d\xb4\xc7\xda\x79\
\x9b\xcd\x95\x56\x1b\xff\x29\xd6\x8e\xf7\x5a\xfa\x74\xb4\xde\xbe\
\x8c\x04\x1d\x15\xd8\x6a\x6d\x3f\x11\xcd\xbd\x06\x34\x4e\x1f\x47\
\x7d\xe9\xac\xa9\xc3\xad\xff\x06\xa1\xbe\xfc\x2d\xc4\x23\xcb\x05\
\xb3\x72\x67\x82\x2b\xed\xff\x3a\xcb\x7b\x22\xe2\xa7\x53\x81\xcb\
\x10\x4f\xdc\x81\xc6\x60\xa6\xfd\x76\x23\x1a\xc3\x99\x68\xbe\x0e\
\x45\x6b\xc9\x29\xe1\x1f\x44\x73\xe3\x24\x64\xa5\x2d\xa0\x3b\x84\
\xe7\xa0\xf9\xeb\xee\xe9\x1e\x89\xa7\x03\x05\xcb\x6b\x34\x5a\x0f\
\x37\xa3\xb9\x71\x11\xf0\x59\xb4\xf9\x76\x26\xe2\xf1\xe3\x90\x0c\
\x30\xd2\xda\x5c\x63\xed\x9f\x65\xf9\x9c\x6f\xf5\xdd\x81\xa7\x03\
\x95\x48\x79\x76\xd6\xe4\xc8\xdb\x8f\x30\xa2\x45\xb8\x9b\xc8\xe7\
\xe0\xe1\x77\xf6\xf1\x17\xbf\xda\xc4\xae\x26\xaf\x00\xd7\x55\xe5\
\x99\x3b\xb6\x8e\x79\x63\xea\x38\x7e\x54\x0d\xd3\x87\xd7\x30\x69\
\x68\x35\xa3\x06\x56\x32\xa2\xae\x92\x9a\xca\x1c\x55\x15\x39\x7e\
\xb9\x72\x2f\x51\x0f\x8e\x88\xe8\x53\xc8\x21\x41\x30\x8c\x1e\xeb\
\xee\x08\x2e\xd8\x6f\xe5\xae\x2d\x72\xff\xf7\x01\xf7\x01\x2b\x90\
\x00\x31\x15\x7f\xdf\x62\x0e\x59\x74\xee\x45\x42\xd7\x49\xf6\xfb\
\x39\xe8\x7c\x71\x15\x12\x8e\xcf\x42\xbb\xe5\xdd\xb1\x7e\x45\x44\
\xf4\x65\x54\x20\x01\x79\x02\x52\xdc\xba\xc3\x75\x1b\x90\x55\xd8\
\x29\x68\xed\xc8\xaa\x38\x01\x29\x3e\x77\x58\xba\xf1\x48\x38\x1d\
\x49\xa9\xcb\xe5\xcb\x68\x0d\x9f\x80\x14\xd1\xfd\x28\x12\xf5\x6b\
\x48\x19\x9b\x88\x77\xb1\x1e\x8f\x94\xd9\x02\xb2\x72\xfd\x0c\x09\
\xc1\xd7\x58\xb9\x77\x22\xc5\x6d\x34\x5a\xf3\xe3\x2c\xed\x53\x96\
\x76\x17\x52\x5e\xe7\xa2\xf5\xff\x03\x7b\x6f\x34\xa2\x1f\xb3\x90\
\xa5\xca\x9d\x6f\x3d\x05\x59\xa9\x12\xa4\x04\x2c\x46\xf7\xa9\x2e\
\x47\x16\xb8\x5b\xd1\xfd\xc9\x9b\x11\x4d\x69\xa4\xf4\xae\xd0\x89\
\x48\xf1\x78\x10\x59\x48\x43\x1a\xf6\x9a\xb5\x7b\x22\x52\x32\x07\
\xd0\xf1\x2a\x1b\x47\xc7\x46\x5b\xf9\xbf\xb4\xfc\xd2\x81\xc9\x9e\
\x47\xae\xe8\x73\xad\x5e\x77\xe3\xef\x80\xad\xb5\xfe\x5b\x8c\x2c\
\x76\x23\x90\x1b\xfb\x70\xa4\xa4\x6c\xb3\x7a\xdf\x87\x36\x30\x26\
\xa1\x0d\x84\xdd\x88\xae\xde\x83\x14\x95\xb3\xec\xf3\x16\xa4\x7c\
\xb8\x3b\x8e\x73\xc8\x7a\xfb\x53\xab\xcf\x64\xa4\xc0\xe5\xf0\x57\
\xba\x3c\x87\x14\xf0\xe5\x96\xff\x74\x64\x61\x76\x8a\xdd\x02\x1b\
\x87\xe7\xac\x8d\xee\x5e\xe5\xfe\x80\x0a\xd4\xdf\xaf\x59\x7f\x9c\
\x81\x36\x79\x13\x34\x3e\x73\x52\xbf\xcf\x41\xfd\xfe\x03\x7c\x4c\
\x8c\x03\x81\x9b\x57\x55\x94\xba\xb3\x8f\x45\x73\xf0\xe7\x48\x29\
\xbf\x06\x1d\x4f\xba\x0f\xb9\xdc\xff\x29\x52\x2c\x77\x03\x77\xa1\
\xb9\xe1\x3c\x24\x9e\x46\x9b\x23\xa3\xad\x7e\xf7\xa0\xb5\xb3\x0c\
\x78\x08\x29\xf2\xee\xbc\xee\x04\xfb\x3e\xca\xca\x7f\xd1\xca\x18\
\x8f\xd6\xec\x3d\x88\xf7\xbb\xb5\x53\x40\x1b\x66\x45\xe4\xce\x5d\
\x89\xe6\x4f\x1d\x52\x84\x1b\xec\x59\x03\x52\xa0\xef\xb3\x3a\xee\
\xb3\xb2\xde\xe8\xe9\x01\xee\xeb\x88\x8a\x70\x37\x90\xcb\xc1\xee\
\xa6\x02\xff\xf2\xcc\xb6\x12\x25\x78\xc6\xc8\x1a\xbe\x78\xee\x78\
\x2e\x9c\x31\x98\x61\xb5\x95\x54\x56\x18\xdd\x4b\xa0\x88\x22\x4a\
\x17\x13\x28\x14\xa1\xb9\x5d\xf7\x06\x47\x44\x44\xf4\x19\x14\x91\
\x4b\xdc\x4c\x24\x0c\x54\x23\x57\xaa\x2a\xfb\xfc\xae\xa5\x73\x8c\
\xba\x9a\x52\xe1\x28\x87\x98\x5f\xb3\xbd\x5f\xc8\xf8\x7d\x3f\xfe\
\xac\x9c\x3b\x5f\x94\xb7\xf7\x40\x2e\x8b\x7b\x38\xf2\x57\x43\x44\
\x44\x1c\x0b\x68\x05\xbe\x01\x3c\x8a\x17\xbc\xbb\x52\x48\x72\x48\
\xe0\xbd\x16\x09\xf0\x2b\xf1\x9b\x58\xe3\x91\x55\x69\x07\xf2\xc0\
\xc8\x8a\xe6\xba\x87\x8e\xf7\x64\xba\xf3\x88\x35\x48\x49\x73\xae\
\xc0\x0f\x22\x01\x7c\x42\xea\x3d\x77\x3e\xf6\x03\x78\x45\xda\x95\
\x55\x44\x42\x71\x05\x7e\x9d\x57\xe3\xad\x53\x20\x9a\x33\x18\x6d\
\x8c\xb5\x58\xba\x47\x11\x7d\x70\xf5\x75\xb4\xa3\x31\xf8\x5f\x81\
\x57\xda\x2a\x28\x75\x15\xbe\x03\x29\x09\x27\x20\x8b\xdd\xb7\x28\
\xb5\x4e\xd5\x97\xe9\xcf\x30\x16\x42\x05\xf0\x24\x52\x88\xe6\x22\
\xcb\xee\xc3\x68\x73\xcf\xa1\x10\xb4\xcf\xd1\xc4\x56\xeb\x3b\xd7\
\x07\x2f\x22\x8b\xda\x45\x88\xe6\xee\x0a\xd2\xe7\xac\xcd\x8d\xd6\
\xc6\x70\x8c\xf6\x06\x63\xb2\x3f\x68\x5b\xfa\xee\xd4\xc9\xe8\xec\
\xe9\x16\xa4\x84\x38\xb7\x55\x37\x8e\x15\x41\x9e\x35\x56\x5e\xab\
\xbd\xfb\x30\x52\x56\xa6\xa5\xda\xd1\x9f\x90\xc7\x6f\xc4\x56\xa3\
\xbe\x2e\xa0\x31\xb9\x03\x29\xa6\x6e\x5e\xd4\xa1\xf5\xe0\xce\x7a\
\xbb\x71\x71\x67\x68\xb3\x62\x5e\xb8\x77\xdd\x86\xce\x00\x34\x56\
\x0b\x2c\xfd\x2f\xd1\x7a\x9a\x8d\xce\x8b\x3f\x88\xe6\x75\x83\xd5\
\xad\xc5\xf2\x76\x63\xd7\x8c\x9f\x6b\x53\xd0\x9a\x2f\x20\xab\x7e\
\x11\x9d\x75\x5e\x6c\x75\x73\xae\xdc\x8e\x0e\xec\xa0\x74\x6d\xee\
\xc5\xcf\x8d\x06\xb2\xc7\xbe\x06\xcd\x17\xd7\xe6\x16\x7b\xa7\x12\
\xcd\x99\xc4\xfa\xe8\xa7\xf8\x73\xfa\xed\x44\x1d\xed\xa8\x20\xba\
\x46\x77\x03\xf9\x5c\x8e\x97\x37\x35\xf2\xd2\xc6\x86\xdf\x3c\x1b\
\x52\x5b\xc1\x9f\x5d\x34\x91\x1b\x4e\x1e\xc1\x88\x01\x95\xe4\x72\
\x50\x28\x26\xfa\x4b\x92\x92\xb3\xc0\x09\xb0\x65\x5f\x7b\xb7\xee\
\x1c\x8e\x88\x88\x38\x66\x90\x43\x42\xde\x20\x24\x44\x9f\x80\x02\
\xef\xfc\x29\xda\x09\xde\x88\x98\xf3\x3c\x24\x48\xba\xb3\x7b\xe0\
\x69\x6f\x48\x83\x9d\xd0\x15\xfe\x85\xbf\x57\x20\x46\xbb\x1a\x2f\
\xbc\x0f\xc4\x5b\xa8\x22\x22\xfa\x3b\x72\xc8\xa2\xf8\x2b\x4a\xcf\
\x25\x76\x96\xde\xb9\x5b\x3a\xeb\xd0\x6b\x78\x61\x7c\x06\x12\xdc\
\xef\x45\xeb\x79\x10\x1d\xd7\x68\xa8\x3c\xba\xf5\x9a\x20\xeb\xd2\
\x7a\x24\xd0\x6e\x41\xc2\xf5\x14\x4a\x15\x2c\x82\xff\x93\x91\x55\
\xeb\x3e\x74\xce\x71\x60\x99\x32\x2a\x90\x32\x38\x0c\x09\xeb\x27\
\x01\x9f\xc6\xbb\x0a\xef\x42\x91\x7b\x27\xe1\x15\xfa\x1c\xa2\x45\
\x1b\x90\x32\x79\x1c\x72\x53\x7e\x17\xaf\xbc\x85\xa8\x44\xee\xa6\
\x8d\x28\x50\xd4\x6e\x64\x9d\xce\x6a\x37\xf8\x20\x3f\x8d\xe8\x58\
\xc7\x6c\xfb\x0f\x70\x36\xb2\xe2\x3a\x2b\xdc\xc4\x54\x59\x2e\xf0\
\x50\xba\x0f\xc3\xdf\xde\xb5\xfa\x5f\x88\xce\x4f\x16\x91\xe2\x32\
\xd2\xc6\x27\x5d\x97\x70\x33\x22\x9d\x6f\xba\x8c\x04\x59\xd2\x2b\
\xac\xef\xb7\xda\x38\xbb\xb4\x6e\xb3\xa2\x80\x36\x3a\x37\x59\x3b\
\x77\x58\x7b\xa6\xe0\x37\x19\xfa\x9b\x02\x8c\xf5\xcb\x76\xb4\x91\
\x03\x3a\x43\x5d\x81\xbc\x2c\xb6\xe0\xdd\xf3\x97\x20\x2b\xeb\x5b\
\x68\xdc\x4e\x41\x73\x64\x21\xea\xdf\x31\x78\x4b\x7d\x88\x0a\x34\
\xf7\xa6\xa3\xb9\xfe\x51\x34\xff\xd7\xe2\xd7\xd2\x05\x68\x1e\xdc\
\x81\xd6\xf2\x38\xb4\x39\x71\x8e\xbd\xe7\x02\x6e\x6d\xb0\x72\xce\
\x42\x63\x7e\x1a\xb2\xf2\xef\x45\x16\xfe\xeb\xd0\xfa\x77\x0a\xb4\
\xf3\x8e\x98\x81\xe8\xc3\x3d\x88\x0e\x0c\xb6\xba\x85\x63\x9e\x9e\
\xc7\xee\xaf\x02\xad\xfd\x11\x68\xbd\xce\x47\x56\x67\x77\xde\xdc\
\xc5\x1e\x68\x45\x34\xa0\x60\x7d\x30\x84\xec\xa8\xd2\x11\x87\x19\
\x71\xb7\xa1\x3b\x48\xe0\xed\x1d\xcd\x34\xb6\x79\x59\xf3\x84\x51\
\xb5\x9c\x33\x75\x90\xee\x12\xee\xe2\xf5\xf6\x62\xc2\xd2\xcd\x8d\
\xa5\xca\x71\x42\x0c\x9c\x15\x11\x71\x6c\x23\x87\x18\xd5\x57\x91\
\x80\x76\x09\x12\xa2\x56\x21\x46\x3f\x15\xb9\x55\xbd\x1f\x29\xca\
\x6b\xf0\x67\xda\xde\x41\x8c\x6f\x25\x3e\x28\xcf\x5a\xcb\xaf\x1d\
\x31\xe2\x7d\x96\x0e\x7b\xb6\x02\x09\xb9\xdf\x06\xae\x02\x3e\x6c\
\x69\xee\xa7\x7b\x96\xaf\x88\x88\xfe\x80\xee\x6e\xf0\xbb\xf5\xfb\
\x0e\x5a\x93\x4f\x23\x4b\xed\x36\xfb\x4b\x90\x4b\xee\x34\x74\x5e\
\x76\x23\x0a\x80\xd3\x8a\x04\xea\x5d\x48\x98\x75\xc1\x6c\x1a\xd1\
\x1a\x6d\x04\x7e\x8d\x04\xde\xef\x23\x05\xf0\x22\xab\xd7\x0a\xa4\
\x48\x6d\x44\xd6\xa6\x3c\xa2\x09\xab\x90\x30\x3c\x0d\xd1\x8b\xcd\
\x56\x56\xa3\x7d\x6e\xb2\x32\xf6\x22\x9a\xb1\x01\xf8\x11\x3a\xd7\
\x98\x47\x16\xb1\xa7\x2d\x9d\x0b\xf0\xb4\x16\xd1\x1c\x47\x17\xda\
\xad\x3e\x57\xa0\x73\x92\xbb\x91\x7b\x6a\xb3\xd5\x2b\x0c\x60\xd5\
\x86\x36\xda\x2e\x46\x0a\xcc\x0a\xb4\xe9\x77\x46\xd0\x6e\x77\xcd\
\x52\x0b\x52\x3a\xf6\x59\x5b\x2f\xb1\x7e\x7c\x01\xd1\xc3\xed\xe8\
\xec\xf0\x47\xac\xcc\xfb\x53\x63\xb0\x06\x2f\xf0\xbb\x80\x43\x4e\
\xf1\x5c\x61\xf9\xb6\x22\x05\xc5\x05\x38\xca\x5b\xfe\x57\x23\x25\
\xe5\xed\xa0\x8f\x36\x58\xbf\xed\x43\xca\x4b\x1e\x29\xad\xae\x2f\
\xea\x6d\xcc\xc3\x88\xc0\xcf\xe1\xcf\x09\xbb\x71\x2e\xe0\xa3\xfa\
\x26\xc8\xc2\xbe\xd8\xfa\xe5\x47\x41\x3f\xaf\x46\xca\xd7\x1a\xba\
\xb7\xf9\xd2\xd7\xe0\x36\x65\x2f\x42\xca\xe8\x53\xf6\xff\x3a\xeb\
\xb7\x17\xf1\x81\xc7\xdc\xf5\x82\x0f\x20\x9e\xb9\x17\x8d\x79\x3b\
\xda\x7c\x98\x85\xfa\xde\xcd\xc5\x04\xf5\xed\x02\xa4\x3c\xb6\xa3\
\xfe\x7e\xc8\x3e\xaf\x43\xf3\x6b\x35\xe2\x89\x73\x90\x9b\xfb\xfd\
\x78\x8f\x87\x9b\xd0\xdc\xf8\x6f\x34\xf6\xfb\xd1\xfc\x9c\x8a\x94\
\xdf\x27\xad\x0d\xaf\xa1\x6b\xd3\x96\xe1\x37\x5f\xb0\x3c\x42\x3a\
\xb0\x09\xad\xef\x76\x34\x57\xdc\xfa\xdf\x80\x8f\x28\xbd\xd5\x7e\
\x77\xd7\x6e\xad\x47\xd6\xde\xf3\xd1\x5c\x5e\x66\x6d\xbf\x13\xcd\
\xe1\x0f\x59\xdf\x3c\x62\xff\x8f\xb3\x3c\xd3\xc7\x08\x22\x8e\x00\
\x72\x4b\x26\x0d\xac\xff\xf6\x0d\xd3\x87\x8e\x1d\x54\xd9\xef\x14\
\xb3\x7c\x2e\xc7\xdf\xff\x7a\x0b\x7f\xf9\xc8\xa6\xdf\x3c\x5b\x38\
\x61\x00\x3f\xb9\x65\x06\x23\x06\xf8\xfe\xc8\xe7\xe0\xaf\x1f\xdf\
\xc2\x97\x1f\xdf\xfc\x9b\x74\x17\x4c\x1f\xc2\x0f\x6f\x9e\x4e\x65\
\xbe\xf3\x39\x5a\x91\xcf\xf1\xda\x96\x46\x3e\xfc\xe3\x35\xac\xdd\
\xdd\xf2\x9b\xe7\x4b\x26\x0d\xe4\xc7\xb7\xcc\x60\x68\x4d\x45\xbf\
\x3a\x09\xdf\xd2\x9e\xf0\xf9\x7b\xd7\xd5\xdf\xf9\xfa\xee\xdb\x11\
\xe1\x89\x5e\x09\x11\xbd\x19\x05\xe0\x33\x88\xf9\xdd\x4b\xb6\xdb\
\x96\xbb\xfa\xc0\x9d\x59\x72\x96\x8a\x66\xc4\x74\xdd\xae\xb5\x73\
\x7d\x0e\xaf\xe7\x08\xaf\x60\x08\xcf\xe6\x39\xe4\x32\x7e\x77\xe5\
\x55\x52\x7a\x9e\x38\x22\xa2\x3f\xa0\x1a\xf8\x22\xb2\xfe\x2c\xe7\
\xd0\x78\x88\xb3\xda\x84\x57\xfd\x84\x57\x9e\xb9\x35\xeb\xd6\x1a\
\x64\xaf\xd3\x50\xa9\x72\xeb\xb5\xd2\xde\x77\x16\x9e\x1c\x5e\xc0\
\xcf\x1f\x44\x59\x61\x5a\xe7\x26\xea\x8c\x19\xed\xc1\x73\x67\x9d\
\x74\x65\x85\xb4\x21\x21\x9b\x76\x84\xf5\x0e\xd3\x3a\xda\xe5\xd2\
\x66\x5d\xc7\x14\xb6\xdb\xd5\x29\xa4\x53\x8e\xce\xb9\x32\x8b\x74\
\xb4\xe0\x86\x6e\xe5\x69\x9a\x07\xb2\xae\x5f\x8b\x94\x8d\xfb\x82\
\x77\x2a\x83\x3a\x84\x41\xc1\xd2\x75\x4c\x8f\x73\x96\x7b\xb4\xbb\
\x76\xa9\xbd\x4c\x1e\xe9\x31\x4d\xf7\xb3\xbb\xb2\xe9\x58\x10\xe9\
\xdc\x3d\xcc\x5f\x04\xfe\x96\xd2\x08\xda\x07\x83\x5a\x74\xde\xfc\
\x97\xc8\x1b\xc1\xcd\x31\xac\x7f\xc2\xeb\x86\xc6\x23\xe5\xef\x31\
\xe4\x32\x7c\x33\x3a\xce\xb0\x9a\x52\xf7\x7f\x87\xd0\xd2\x9a\xe0\
\xd7\x86\x9b\xb7\x6e\xae\xb9\x39\xd6\x46\xe9\x18\x54\xe1\xc7\x6c\
\x18\xf0\x3f\x80\x6f\x22\x65\xd5\x1d\x2d\x18\x86\x0f\x6e\xf5\x0d\
\x3a\xd2\x83\xee\xcc\x8f\x5c\xc6\x67\x57\x4f\xe7\x12\x5d\x45\xe9\
\x1c\x71\x6d\x0d\xeb\x98\x43\x73\x1d\xb4\xb1\x14\x79\xfb\xe1\x87\
\xf3\xd8\xb9\x0d\xf8\x42\xb4\x08\x77\x03\x39\x72\x0c\xaf\x2b\x95\
\x7f\x37\xed\x6b\x65\xeb\xfe\x76\x26\x0f\xad\x2a\x7b\xf6\xb7\x22\
\x9f\x63\x67\x63\x3b\xff\xf0\xeb\xad\x25\x4a\x30\x40\x21\x49\xe2\
\x99\xe1\x88\x88\xbe\x01\xc7\xa4\x43\x06\xbd\x33\xf8\xcd\x59\x37\
\xa0\x23\x03\x4c\x07\x97\x49\x23\xc9\xf8\x3d\xb4\xf0\x84\xdf\x23\
\x22\x22\x0e\x0c\x59\x01\xec\xc2\xe7\xe9\xb5\x06\x9d\x1f\x43\x08\
\x7f\x0b\x95\xd9\xf0\x8e\xd3\x43\x29\x2b\xac\x6f\x2e\x23\x5f\xa7\
\x6c\xa4\x95\x4d\x52\xe9\xd2\xb4\xa3\x58\x26\x6d\x91\x52\xba\x53\
\x4e\x6a\x09\xd3\x84\x11\x93\x93\xe0\xbd\x2c\xc5\x3c\x5d\x76\x5a\
\x91\x74\x0a\xce\x59\xf6\xfc\x89\xe0\xfd\x74\x59\x61\x1e\x59\xcf\
\x92\x32\x65\x84\x6d\x6b\xef\x24\x8f\xb0\xdf\xb2\xfa\xb9\x3f\x1f\
\x4f\x69\x44\x67\xa5\xc7\x20\x2b\x3e\xf8\xb1\x09\xef\xf4\x05\x59\
\xcd\x37\x20\x65\xb8\x1d\x59\x6f\x9d\xe5\x33\xab\x0f\x8b\xa9\xe7\
\xb9\xd4\x6f\xee\x59\xb9\x39\x16\x8e\x59\x3b\xf2\x28\x68\xc6\x2b\
\x9d\x45\x64\x49\x3e\x1e\xf8\x31\xa5\x1b\xd6\xa4\xf2\xef\x6c\x7e\
\x24\x5d\x7c\x0e\xe9\x40\xba\x2d\xe1\x7a\x1c\x68\xe9\x9e\x38\x4c\
\x63\x13\xd1\x05\xa2\x22\xdc\x1d\xe4\xe0\xe4\x71\x03\x18\x52\x5b\
\xc1\xde\x66\xcd\xe3\x77\x76\xb6\xf0\xd5\x67\xb7\xf1\x47\x17\x8c\
\x67\x48\x4d\x85\x5c\x9d\x49\xc8\x91\x23\x97\x83\xb6\x62\xc2\xb2\
\xcd\x8d\xfc\xe3\x53\x5b\xb9\xef\xcd\xfa\x0e\x59\xb6\xb4\x27\xb4\
\xb6\x17\x21\x57\x71\x6c\xec\x1f\x46\x44\x44\x1c\x08\xa2\x72\x1a\
\x11\x11\x11\x71\xe8\x28\xa2\x28\xd2\xa1\x95\x39\xa2\x77\x21\x8f\
\xce\xfe\xbe\xdd\x8d\xb4\x6d\x48\xf9\xfd\x05\x5e\xb9\x3c\x44\x8f\
\x88\xd1\x00\x00\x80\x00\x49\x44\x41\x54\x5a\x63\xda\x88\xdc\xda\
\xc3\x79\x94\x47\x11\xdc\x9f\xa3\x63\xc0\xca\xa3\x8d\x1c\x72\xe3\
\xbe\xbf\x17\xd4\xa5\xdf\x20\x2a\xc2\xdd\x40\xb1\x98\x30\x6f\x6c\
\x1d\xe7\x4c\x1d\xcc\xfd\x6f\xd5\x03\x0a\x8c\xf5\xad\x97\x76\xb0\
\x79\x5f\x1b\xef\x9b\x33\x8c\xa9\xc3\x6b\xa8\xa9\xcc\xd1\xdc\x5e\
\x64\x43\x7d\x2b\x4f\xad\xdb\xcf\x83\x6f\xef\x61\x7d\xbd\x22\xae\
\x0f\xaf\xab\xa4\xb5\x50\xa4\xa1\x55\x1b\x58\x7b\x9a\x0b\xec\x6f\
\x2d\x32\x8e\xa8\x07\x47\x44\xf4\x01\x84\x3b\xbd\xe9\x60\x2c\x69\
\x84\xae\x56\x07\xf2\x7b\xe8\x4a\x9d\x0e\x56\x13\x11\x11\x71\x6c\
\x23\xae\xeb\xf2\x28\xe7\xf6\x1c\xd1\x7b\xe0\xae\x1e\x83\x52\x77\
\xe6\x72\x68\xe5\xe8\x05\x18\x0b\x23\x89\x97\xf3\xbc\xea\x2d\x47\
\x8c\x3a\xab\x4b\x68\x65\xef\x6e\x5d\xb3\x22\xdd\x77\xf7\xbd\x34\
\x3d\xea\x8a\x46\xb9\xa8\xdf\x59\xe9\xba\x92\x7b\x7a\x0c\x51\x11\
\xee\x06\x12\x60\x70\x4d\x9e\xdb\xcf\x1c\xcb\xca\x1d\xcd\xbc\xbd\
\xa3\x19\xd0\x95\x48\x77\xbf\xb1\x9b\xfb\xdf\xaa\x67\x68\x5d\x05\
\x35\x15\x79\x9a\xdb\x8b\xec\x6d\x2e\xd0\x66\x7e\xcf\xb9\x9c\xce\
\x03\xff\x8f\xb3\xc6\xf2\x8d\xe7\xb7\xf3\xd8\xea\x7d\x00\xec\x68\
\x68\x67\xcd\xee\x16\x66\x8e\xaa\x8d\x51\xb3\x22\x22\x8e\x5d\x24\
\xe8\x7c\xd4\xc9\x28\xf8\x46\x33\x3a\xb7\xb8\xa6\x93\xf4\xc3\x51\
\x54\xd5\x17\xe8\x78\xf7\xaf\xbb\x57\xb1\x1a\x05\xa0\x71\x8c\xa4\
\x06\x45\xd9\x7c\xcd\xde\x5d\x87\xce\x38\xf5\x06\xc6\x1d\x11\x11\
\x71\x68\x48\x50\x74\xf9\x16\x14\xc8\x29\xae\xeb\x88\x63\x09\x39\
\xe4\x5e\x7c\x32\x52\x74\xde\x44\x7c\xb0\x9c\xeb\xba\x8b\xc2\xfc\
\x3a\x47\x7e\xae\x57\xa2\xe0\x53\xeb\xe8\xc8\x6f\x8f\x25\x54\x00\
\xa7\xa3\x33\xd6\x8f\xa2\x00\x64\x5d\xf5\x5d\x0d\x0a\xf0\xf6\x0a\
\xe5\xaf\x76\xca\x42\x82\xae\x85\x2c\xa0\xb3\xdb\xee\x88\xd7\x12\
\x14\xbc\x6f\x23\x1d\x95\xdc\x41\xe8\x66\x8c\xe7\xd1\x55\x69\xab\
\xf1\x67\xcf\xdd\x55\x74\x13\xac\x2e\xbd\x4a\xe9\xe9\x75\x9a\xf9\
\xd1\x44\x0e\x9d\xd5\x0d\xd1\x5e\xe6\xe0\x6e\x31\x81\xc5\x93\x06\
\xf0\x8f\x57\x4e\xe1\xec\xa9\x83\x4a\x82\x64\xb5\x15\x13\x76\x34\
\xb4\xb3\x71\x6f\x2b\x3b\x1b\xdb\x69\x2b\x26\xe4\x72\x30\x75\x78\
\x0d\x7f\x70\xee\x38\xfe\xe3\xba\x69\x5c\x7e\xc2\x30\x4e\x9b\x3c\
\xf0\x37\xef\x34\xb7\x17\xb9\xff\xad\x3d\xb4\xb4\xf7\xe7\x63\x25\
\x11\x11\xc7\x34\x12\x14\x1d\xf3\x13\x28\x22\xa6\x8b\x18\x7a\x2b\
\x8a\x0e\x19\xde\x7d\x48\xf0\xbd\x16\x5d\x93\xe0\xce\xb8\xb9\x3f\
\x97\x76\x04\x0a\xe4\x00\x7e\x97\xbd\x0a\x45\x63\x1d\x8c\x98\xc9\
\xa0\xd4\xbb\x85\x54\x39\x61\x9e\x11\x11\x11\xe5\xe1\x02\xdc\x85\
\x6b\xa8\xab\x67\x85\xe0\x59\x7a\x7d\x97\x7b\x3f\xbd\xce\xd3\xdf\
\x47\xa3\x4d\xb2\xe4\x00\xca\x8f\x88\x38\x52\x08\xe7\x73\x67\x28\
\xa2\xa8\xce\x1f\xb7\xef\x6d\x28\x0a\xf2\x7b\x28\x3f\xd7\x87\xa3\
\xf3\xc4\xe1\x9c\x6e\xc7\xcf\xf7\x74\xec\x8c\xac\x35\x91\xb5\x46\
\xb2\xea\x36\x16\x5d\xb9\x54\x95\xf1\x4e\x16\xaf\x4c\xaf\xb3\xf0\
\x3b\x19\x69\xd2\xeb\xbb\xb3\xb5\x79\xb0\xb4\xa6\x68\xfd\xf5\x01\
\x14\xf9\xba\x99\xae\xe9\x8e\x0b\x9c\x37\x05\x1f\xa4\x2b\xdd\xd6\
\x24\xa3\x1c\x90\x6e\x78\x3e\xba\xc2\xc9\xe5\xd9\x0e\x9c\x8b\x36\
\xfc\x8b\x19\xf5\x1e\x0c\x5c\x83\x64\x93\x89\xf8\xb3\xce\xee\xdd\
\x41\x48\x76\x71\x7d\x95\x1e\xdf\xac\xba\x74\x35\xbe\x87\x05\xfd\
\xda\x22\x5c\x24\xe1\xd4\x49\x03\xf9\xfc\x19\x63\x7e\xf3\x6c\xe2\
\x90\x6a\x6a\x2b\xf3\x99\xdd\x9e\x24\x70\xc6\x94\x81\xfc\xc7\x75\
\xd3\xf8\xf9\xca\x3d\x3c\xb2\x6a\x2f\x2b\x77\xb6\xb0\xb7\xb9\x40\
\x21\x49\xa8\xca\xe7\x19\x5a\x5b\xc1\xac\x51\x35\x9c\x3a\x79\x10\
\xe7\x4e\x1b\xcc\xcc\x91\x35\xe4\x73\x90\x24\x09\xd7\xcd\x1d\x4e\
\x5b\x01\x5a\x0b\x9a\x6b\xa3\x07\x56\xd1\xdc\x5e\x64\x70\x75\xff\
\x8a\x1c\x1d\x11\xd1\x47\x50\x44\xd7\x89\x4c\x00\xfe\x1a\xdd\x73\
\x09\xda\x2d\xfd\x10\xfe\x3a\x94\xcd\x68\x37\x7a\x0a\xba\x6b\x71\
\x2d\xba\x4e\xa1\x0a\xed\xa0\x62\x79\xac\x45\xd7\x34\xec\xc2\xdf\
\x37\x3c\x17\x59\x8a\xf6\xe3\x99\xd9\x46\x74\x2d\xc3\x3c\xa4\x34\
\x8f\xb0\xe7\x4f\xa3\x20\x5d\x63\xd0\xce\x71\x35\xba\xa6\x61\x55\
\x4f\x77\x54\x44\x44\x2f\x45\x0e\x59\xb1\xe6\x20\x0b\xcb\xb3\xc8\
\x72\xb2\x00\x59\x44\xf6\xa0\xb3\x83\x4d\xc8\xb2\x92\x43\x96\x8d\
\xf5\xe8\xea\x95\x53\x91\xe7\xc6\x36\x7b\x3e\x0d\x5d\x17\x73\x22\
\xf2\xdc\xa8\xb7\xf7\xdb\xf0\xf7\x88\xbb\xeb\x86\x16\x01\x43\xd1\
\xd9\xca\xd7\x2c\x8f\x16\x64\xf9\x71\xe5\xef\x46\x16\x96\xfd\x68\
\x4d\xe7\x11\xad\xd8\x84\x3c\x4a\xda\x88\x88\x38\xfc\x70\x8a\xcd\
\x00\xb4\xc1\x5b\xec\x22\xed\x42\x14\x00\xeb\x87\x68\x4e\x2e\x47\
\xca\x50\x0e\x6d\xf0\x9c\x86\x36\x80\x97\xa1\x60\x55\xbb\xd1\x79\
\xdd\x13\xf1\xf7\x08\x57\x22\x2f\xa7\x77\x50\xf4\xe6\x17\x10\xcf\
\x5b\x64\xf9\x9d\x8c\xd6\x4f\x2d\xba\xf2\xe8\x38\xb4\x6e\xeb\xd1\
\x1a\xdb\x43\x47\x8b\x67\x0e\xdd\x3d\x3c\x0b\xf1\xea\xad\x88\x07\
\x0f\x43\xeb\xb4\x88\xd6\x65\x0e\x78\x19\xad\xeb\x93\xac\xdd\x93\
\xad\xed\xeb\xd1\x7a\x6c\xb0\x72\x9b\x2c\xbf\xf9\xc8\xbd\xdb\x5d\
\x13\x76\xbe\xb5\xa1\x06\x05\xba\xca\xb2\xc0\xce\xb6\xfc\x1b\x10\
\xad\xd9\x6d\xdf\xe7\xa0\x35\xfe\xbc\xb5\xe7\x34\x44\x07\xc6\xa3\
\x2b\xbc\x5e\x46\x57\xa5\x0d\xb3\xbe\x5a\x80\xbf\xfa\x6d\x9c\xf5\
\xf5\x32\xab\xd7\xc9\x88\x8e\x3c\x8b\xae\x68\x5a\x6f\xf5\x1c\x6e\
\xf9\x0e\x45\x67\xb9\x5f\x45\xb2\xc2\x5c\xab\xdb\x48\x6b\xcb\x5a\
\x2b\x67\xa0\x7d\x9e\x68\x7d\xd7\x68\xef\x3a\xb7\xe7\x05\x36\x7e\
\x3b\xad\x2c\xa7\x90\x17\xd1\xd5\x53\xfb\xad\x6f\x87\x20\x25\x78\
\x8d\x3d\x1f\x81\x64\x97\xa7\x90\x92\x7b\x1a\x92\x51\x86\x5a\x7d\
\xc6\x58\x7d\xdf\xb4\x74\x15\xd6\x9f\xf5\x1c\x21\xef\x81\x7e\xad\
\x08\x27\x09\x9c\x37\x6d\x30\xe7\x4f\x1f\x12\x3c\x94\x95\xb8\xec\
\xf6\x52\x02\xa3\x07\x55\xf2\x91\x85\xa3\xf8\xc0\x49\x23\xd8\xdf\
\x52\xa0\xa1\xb5\x48\x4b\x21\x61\x40\x55\x9e\xba\xaa\x3c\x83\x6a\
\xf2\xd4\x56\xe6\x49\x2c\x32\xb4\x33\x32\xcf\x1c\x55\xcb\x9f\x5c\
\x34\xa1\xdb\x65\x45\x44\x44\xf4\x6a\xe4\x11\x13\x79\x1d\x31\x61\
\x47\x4f\x5f\x47\xcc\x60\x1a\x62\x5e\x2f\x20\x37\xa1\x69\x96\x7e\
\x2f\xba\xaa\x61\x15\xba\x3a\x62\x05\x62\x4c\x37\x23\x66\x33\x05\
\x31\x8f\x36\xb4\x93\xfd\x6b\x7b\xe6\x88\x87\xbb\x8f\xf1\x64\xc4\
\x44\xee\x41\xc2\xc4\x78\xe0\x27\xe8\x4a\x80\x35\x88\xc9\x7e\x08\
\xf8\x2e\xfe\xee\xcd\x88\x88\x08\xc1\x09\xc1\x57\xa3\x35\x36\x13\
\x09\x80\x5b\x81\x4b\x81\xc7\xd1\x31\x85\x79\xc0\x77\xd0\x1d\xb3\
\xab\x90\xe2\x7a\x23\x7e\x0d\x0e\x43\x57\x39\x9d\x87\x3c\x44\xda\
\xd1\x9d\xa6\x8f\x23\xeb\xc9\xf1\xe8\xea\xb5\x8f\x59\x39\x2f\x23\
\xcb\x49\x35\x12\x64\xaf\x43\x9b\x5f\xf3\x11\x1d\x99\x00\xbc\xd7\
\xde\x9f\x65\xe5\xff\x07\xba\x5f\x78\xbb\xbd\xef\xae\x57\x79\x92\
\xec\x2b\xdd\x22\x22\x0e\x16\x09\x52\x82\x7e\x0f\x29\x69\x7f\x8b\
\x94\x96\x72\xfc\x23\x87\x14\xb8\x5b\x81\x3f\x41\xfc\xec\x35\xe4\
\xbe\x3b\x04\xf8\x24\x52\x92\x77\x22\x7e\xf4\x1d\xb4\x26\x46\x5a\
\x9a\x4d\x68\xdd\xdc\x88\xbf\x43\xf8\x2c\xb4\x29\x5c\x83\x3c\xa1\
\x36\xa0\xf9\xbf\x03\x45\xa7\x5e\x88\xee\x2d\x7e\x12\xf1\xc6\x13\
\xd0\xb5\x47\xad\x19\xf5\x6b\x40\x6b\x75\x17\xda\xcc\x3a\x1d\xdd\
\xe9\x3b\x02\xad\xa3\xe5\xf6\xde\xc7\x2d\x8f\x73\x91\x12\xfc\x28\
\x5a\xa7\x7b\x81\x67\xac\xbc\x36\xab\xcb\x27\xed\xd9\x60\xe0\xb7\
\x80\x7f\xb1\xfa\x6d\xb5\xf7\xd2\x62\x7d\xd1\xfa\xf2\x66\xeb\xcb\
\x89\x88\xee\xbc\x81\xd6\xff\x13\x68\xdd\x7f\x06\xf8\xba\xd5\x6b\
\x97\xf5\xc1\xfb\xac\x8f\x77\x5b\x5b\xea\xad\x4f\xde\xb4\xbe\x9e\
\x04\x9c\x69\x65\x7f\xd4\xfa\x64\xbc\xd5\xfd\x2e\x74\x5f\xf3\x7a\
\x64\x4d\x6e\x42\x34\xec\x46\x1b\xe3\xfd\x48\x5e\xf8\x91\xf5\xf5\
\x6d\xc0\xff\xb1\xf6\xef\xb5\x76\xdc\x86\x36\xf2\xb1\x7e\xbe\xdf\
\xfa\xf0\xbd\x56\xd6\x74\xe4\xea\xfe\x00\xfe\xca\xb5\xf3\x2c\xef\
\x8b\x90\x45\xfe\x2e\xab\xd3\x4c\x1b\x8b\xab\xd0\xe6\x45\x82\x64\
\xa1\xbd\x48\xa9\xbe\x14\x05\xc6\x3b\xcb\xda\xf8\x30\x3a\x12\x36\
\x08\xdd\x81\x7e\x44\xd0\xef\x05\xa3\x62\xa2\xc0\x57\xbf\xf9\xeb\
\xc6\x79\xdd\xc4\x14\xd8\x9a\x8a\x1c\x23\x07\x56\x72\xdc\xf0\x6a\
\x66\x8d\xaa\x61\xd2\xd0\x2a\x46\x0c\xa8\xa0\x2a\x9f\xa3\x50\xec\
\x78\x3d\x52\x72\x10\x65\x45\x44\x44\xf4\x5a\xe4\x90\x30\xdb\x46\
\xe9\x15\x1a\xce\xc5\xab\x9a\xf2\xd7\x76\xb8\xff\xfb\xd0\xbd\x98\
\xf7\x22\x66\x35\x15\xbf\xab\xba\x08\x29\xc8\x77\x21\x05\x77\x0b\
\xa5\xf7\x75\x26\x88\x19\xdf\x0f\xfc\x0a\x31\x9a\x79\x48\xc8\x68\
\xb6\xb4\xc3\x2c\x9f\xe8\x22\x1d\x11\x51\x8a\x3c\x12\x20\x9f\x47\
\x6b\xf0\x3f\x90\xf2\x79\x0e\xba\xe3\xf4\x3e\xb4\x89\x34\x0e\x09\
\xdb\xbb\xed\xd9\xfd\x68\xad\x4e\x44\x8a\xed\x3c\x64\xf5\x3a\x11\
\x09\x77\xe7\x59\xfe\x55\x48\xf0\x9c\x6f\x79\xd4\x03\x3f\x47\x1b\
\x63\x45\x7b\xbf\x12\x09\x90\xbb\xf0\x81\x64\xce\x01\x1e\x09\xca\
\x9f\x80\x04\xd3\x06\x2b\xfb\x3e\x24\x04\x4f\xef\xe9\x0e\x8c\xe8\
\xb3\xa8\x42\x0a\xd6\x04\xa4\xb0\x76\x86\x3c\x52\x7c\xff\x1a\x29\
\x6e\x93\x81\xdf\x41\x8a\xd7\x2c\xb4\x2e\x9a\x10\x8f\x1c\x4c\x29\
\x3f\xda\x80\x94\xa9\x11\x48\x21\x75\x11\x9d\xb3\xae\x0d\x6c\x46\
\xeb\xf3\x29\xbc\x15\xb7\x92\xd2\x35\x96\x75\xdd\xd8\x06\x64\x3d\
\x7d\x03\xf1\xe5\x57\xd1\x3a\x1a\x6d\x75\x6d\xc5\x1f\x4d\x38\x09\
\xf1\xf3\xa7\xf0\x3c\xf9\x2d\xfb\xfc\xa6\xa5\x77\x16\xcc\x3b\x90\
\x05\xbc\x09\x6d\x88\x35\x21\xba\xe1\xac\xc6\xe9\xbb\x84\x4f\x43\
\x9b\xe4\xf7\x00\xff\x8d\xd6\xfd\xd9\x88\x1e\xdc\x03\x7c\x0f\x59\
\xa2\x67\x22\xb9\xe0\x01\xfb\x73\xe5\xbe\x89\xbc\xc1\x96\x51\xea\
\x09\x12\x1e\xc1\xaa\x45\x96\xf2\x35\x48\xb9\x76\xee\xc5\x93\xad\
\x7f\xbe\x8f\xe8\xc7\x23\x48\xe1\xaf\x42\x9b\x71\xf7\xd9\x5f\x95\
\x8d\xc5\x4c\x24\x7b\x1c\x87\x36\x29\x7e\x04\xdc\x69\x7d\x57\x85\
\xac\xdf\xee\x5e\xe4\x46\xa4\xac\x8e\xa6\xd4\xb5\x1b\x2b\xfb\x59\
\x24\x9f\xec\xc6\xcb\x2d\x59\xae\xef\x15\xc0\x52\xab\xc7\x32\x64\
\x3d\xbe\x07\xc9\x38\xe3\x39\x82\xfa\x6a\xbf\x57\x84\x0f\x05\x09\
\x52\x6e\x8b\xc1\x5f\xd4\x6d\x23\x22\xfa\x0d\x8a\xc8\x75\xe8\x78\
\x44\xc4\x6b\x10\xe3\x98\x82\x94\xe0\x77\x2d\x9d\x23\xfc\xd5\x74\
\x64\x8e\x0d\x88\xc1\x57\xd0\xf1\xba\x84\x1a\xfb\x0d\xa4\x5c\xb7\
\x66\x94\xbf\x07\x1f\xa5\x31\xb1\x77\x9a\xec\xbd\x76\xc4\x80\x96\
\x12\x69\x7d\x44\x44\x1a\x39\xbc\x20\xe7\xd6\xdd\x60\x24\xf8\x35\
\xa0\x35\xd3\x8a\xdf\xd4\x6a\x44\x6b\xcb\xad\xb7\x0a\x24\x24\xe7\
\x81\x8b\x91\xa5\x63\xb5\xbd\xbf\x17\xad\xbf\x9d\x48\x80\xdc\x63\
\xef\xba\x48\xb9\xf7\x21\xa1\x7e\x26\xb2\x92\xcd\xc5\x2b\xc2\xae\
\xac\xac\xf2\x1b\x29\x1f\x95\x35\x22\xe2\x70\x20\x87\xe6\xeb\x97\
\x81\xdf\x47\x4a\x53\x67\xf3\xac\x02\x59\x2d\x07\x21\x6b\xde\x57\
\x80\x6f\x22\xeb\xeb\x48\x34\x87\x1b\xd1\x3c\x7e\x14\x79\x34\xb8\
\xe0\x4b\x39\x64\x59\x9c\x0d\x7c\x1b\x29\x80\x0e\x2e\xda\xb1\xf3\
\xb4\x2a\x58\x3e\xce\xfd\x78\x1f\x5a\x63\xbb\x90\x85\x37\x54\xb4\
\xd2\xed\x71\x7f\x09\x5a\x9b\x79\xa4\x34\x36\xa1\x75\xdb\x0a\x3c\
\x84\x2c\xac\x21\x5f\x4d\xf0\x6b\xde\xe5\x5b\x63\xf5\x70\x75\x6a\
\xb2\x67\xed\x88\x6e\x84\xfc\x38\x44\xb5\xa5\x75\x18\x84\x14\x5f\
\x47\x7f\xda\xec\xcf\xf1\xf0\x30\x2f\x77\x13\x45\x2e\xa8\x8b\x3b\
\x53\x5b\x65\x7f\x3b\x90\x35\x79\x0f\xb2\xb2\xde\x64\x65\x24\xf6\
\x7b\x01\x4f\x7f\xf6\x5b\x39\xf9\xa0\x1f\xdd\x3d\xcb\x03\x91\xe2\
\xb9\xc6\xfa\x28\x3c\xbb\xdd\x82\x37\x00\xb8\xf7\x76\x58\xff\xef\
\xcd\x98\x27\x45\x2b\x2b\xcb\x6b\xc5\x29\xc3\xb5\xf6\xdf\x8d\x8d\
\xc3\xfe\xa0\xcd\x47\x74\x23\x3f\x0a\x47\x11\x11\x11\x11\x07\x87\
\x1c\xda\x75\x1d\x88\xdc\x9b\x4e\x00\x6e\x07\xfe\x14\xb9\x12\x6d\
\x44\x4c\xe9\x24\x24\xf0\xba\x33\x82\xe0\x69\x6f\x48\x83\x1d\xd1\
\x77\x4c\xef\x0d\x64\x6d\x9a\x8b\xce\xe8\x4c\xc6\x0b\xcb\x21\x63\
\x74\x75\xa9\x44\x3b\xd8\x4d\x48\x28\x58\x81\x57\xca\x23\x22\x22\
\x4a\x51\x40\x6b\xe4\x54\xe4\xda\x77\x25\x72\xcd\x5b\x8e\xac\xb2\
\x33\x90\x40\xe9\xce\xe5\x87\xc2\x9c\xbb\x1e\x66\x2f\x52\x86\x6f\
\x40\xd6\x92\x06\x64\xf5\xa9\x45\x16\x95\x7d\x78\x2f\x8f\x0a\xfc\
\x3a\x7d\x0f\x12\x22\xef\x40\x82\xe4\x58\xfb\xad\xdd\xde\x3f\x07\
\x59\x7c\x2f\xb0\x77\x37\xd9\x7b\xe1\x7a\x8f\xf2\x5b\xc4\x91\xc4\
\x0a\xb4\x59\xd3\x55\xb4\xe1\x02\x72\x81\xfe\x38\xe2\x53\xee\xdc\
\xef\x36\xb4\x06\xf6\xe2\xd7\x89\xb3\x30\x82\xb7\x92\x5e\x87\x5c\
\x60\xab\x90\x02\x56\x8f\xce\x89\x9e\x80\xa2\x14\x8f\xa7\x94\xef\
\xb5\x23\xde\x58\x13\xe4\x3f\xc3\xd2\x9c\x83\xac\xd0\x49\xaa\x7e\
\x35\xe8\x6c\x70\x3e\xf8\x5b\x8d\x14\xc3\x6d\xc8\xc2\x3b\x0d\xbf\
\x46\x43\xfe\x9c\xe6\xd5\xcb\x11\x4f\x9f\x6b\xf5\x9b\x6c\xf5\x70\
\xef\xe6\xac\x1e\x33\x29\xf5\x00\x5b\x81\xce\xd5\xce\x42\x6e\xbf\
\xef\x43\x6b\xfd\x54\x7b\x76\x0e\xfe\x5c\x6e\x78\x6c\x35\xab\x0e\
\xdb\xd1\xe6\xc1\xf1\xd6\xe7\xb5\xc8\xc3\xe4\x02\xe4\x95\xf2\x80\
\xb5\xb7\xce\xea\xb5\xc9\xfa\xe1\x3c\x3c\x5d\x5b\x8e\x14\xef\x34\
\x5d\x1b\x6f\x6d\xd8\x8e\xe4\x89\x1a\xe4\x0a\x7d\x32\xde\x62\xee\
\xfa\xff\x2d\xa4\xc8\x4f\xc7\xd3\x38\xe8\xd8\x7f\x6e\xd3\xa3\xc2\
\xc6\xd7\xdd\xb4\xb1\xd0\xfa\x3d\x1c\x5f\x82\xb4\xee\xf3\x11\xa5\
\x75\xfd\xfa\x8c\x70\x44\x44\x44\xc4\x21\xc0\x31\x8b\xaf\xa2\x73\
\x38\x17\x23\xf7\xe5\x95\x68\x27\x7c\x2a\xda\x65\xbe\x0e\x31\xbd\
\xd5\x88\x69\x37\x5a\x9a\x16\xc4\x40\xdd\x2e\xeb\x1a\x74\xce\xc7\
\xed\x7c\xbf\x62\xf9\x5c\x8d\x84\x91\x97\x2c\xed\x1a\x24\x60\x6f\
\xc4\xef\x26\xef\xb5\x3c\xd7\x02\x3f\x40\x4c\xb5\xd2\xd2\xae\x26\
\x5a\x8e\x22\x22\xd2\xc8\xe1\x05\xf0\x9b\xd0\x1a\xba\x1b\x6d\x5e\
\x5d\x81\x94\xdb\x26\x64\xa9\xda\x81\x84\xe5\x16\x7b\x77\x0d\x12\
\xa0\x73\x48\xf0\x9c\x86\x2c\x5d\x15\x68\xcd\xe7\xed\xfd\x76\xe4\
\x2a\xb9\x1b\xb9\x36\xb6\xd8\xb3\x65\x88\x5e\x2c\x42\xae\x89\x8f\
\x23\xa1\xb0\xd1\x3e\x5f\x85\xce\xf1\x35\x21\x37\xca\x5d\x96\xce\
\x59\x8a\x37\x10\x8f\x3b\x44\x1c\x59\x74\x57\xf9\x48\xd0\x86\xce\
\x7b\x90\x75\xb7\x02\xcd\xcf\xef\xa2\x40\x91\xdf\x45\x0a\xd8\x99\
\xf6\xfc\x1d\xb4\xe6\x5a\x90\x62\xbc\x03\x59\x8f\x97\xa0\x79\x7e\
\x1f\x72\x4d\xbe\x1a\x29\x62\xbf\xb6\xb4\x2b\xf0\x96\xda\x87\xd0\
\xda\xbb\x01\xf1\xcb\x5f\x23\x1e\x39\xcf\xca\x7c\x0b\xaf\x98\x6e\
\x45\x6b\xf3\x2c\xb4\x66\x9d\x55\x74\x05\xf2\xd6\xb8\xd0\xd2\xbd\
\x8d\xbc\xb8\xdc\x79\x66\xa7\x2c\xbb\x75\xfe\xae\xb5\xf5\x25\x14\
\x78\xea\x6a\xb4\x96\x7f\x64\xe9\x56\xe0\x2d\x9a\x27\xa1\xe0\x4f\
\x2b\xac\x1e\x79\xab\xe3\x00\xe0\x7a\xb4\xae\xef\xb2\xba\x26\xe8\
\x7c\x71\x0b\x3a\x3f\xbd\xc9\xf2\x73\xee\xd5\x1b\x90\xf2\xd9\x64\
\x7d\x97\x20\x4f\xaf\xeb\xed\xbd\x2d\x48\x1e\xd8\x62\xef\x5e\x6f\
\xe9\x7f\x68\xf9\xaf\xb2\x36\x7c\x07\x29\xe0\xf3\x2c\x9f\x07\x91\
\xd2\xeb\xae\x6b\x6b\x43\x34\x2a\x87\x64\x8f\x36\x7b\xef\x07\x48\
\x71\x6e\x43\x2e\xf0\xf5\x68\xd3\xef\x4a\x44\x37\xdb\x11\xcd\xaa\
\x47\x8a\xbd\xf3\x8c\xd9\x1f\xf4\x5f\xde\xc6\x6e\x1d\x92\x99\xee\
\x43\xe7\x87\x37\x23\x2f\x81\x06\xfb\x5c\x65\x69\x37\xe3\x37\x60\
\xb6\x5b\x3e\x47\x0c\xb9\x25\x93\x06\xd6\x7f\xfb\x86\xe9\x43\xc7\
\x0e\xaa\x8c\x6e\xbd\x11\x47\x1c\x2d\xed\x09\x9f\xbf\x77\x5d\xfd\
\x9d\xaf\xef\xbe\x1d\x2d\xaa\xb8\xab\x1d\xd1\x9b\x51\x40\x01\x2c\
\x36\xa1\x73\x42\x59\x2e\x3e\x8e\x72\x86\xd7\x33\x8c\x40\x0c\xc1\
\xb9\x05\x39\xb7\x23\xb7\x3b\xea\xce\xfa\xba\xff\xd0\x51\x59\x75\
\xee\x4f\x95\x94\x5e\x77\x90\x95\xce\xed\x44\xbb\xf3\xc5\x95\x96\
\x77\x5b\x99\xbc\x23\x22\x8e\x55\x54\x03\x5f\x44\xc2\xf7\x72\x0e\
\x8d\x87\x84\x6b\x37\x7d\xdd\x98\x7b\x56\xc0\x5b\x36\xd2\x6b\x35\
\x09\xbe\x27\x19\x79\xba\x98\x01\xe9\xf7\xdd\x99\xb8\x70\x8d\xba\
\x76\x14\x0f\xa2\xfc\x88\x88\x03\x81\xbb\xa6\xef\x8b\x28\x18\x96\
\xbb\xef\xf5\x50\xf2\x73\xbc\xca\x59\x6d\xc1\xf3\xa4\x34\x3f\xca\
\x07\xbf\x87\x16\xbf\xc4\xde\x75\xee\xbc\xed\xf8\xb5\x95\x0f\xca\
\x71\xf3\xbe\x32\x78\x27\x87\x94\xda\x7a\xa4\xac\xa6\xe9\x82\x73\
\x33\x86\xd2\xb3\xac\x61\x9d\xc3\xe3\x06\x49\x27\x9f\x93\x54\xd9\
\xa1\xe5\xb3\x88\x94\xbc\x5d\x78\x37\xf0\xb0\x9f\xb2\x68\x4d\x3a\
\xaf\x90\x9e\x84\xe5\x86\x31\x42\x5c\x99\x85\x20\xbd\xcb\x3f\xb1\
\xbe\x0e\xe9\x86\xb3\xd8\x56\xa4\xc6\x21\x74\x3d\x0e\xc7\x21\xdd\
\x47\xe9\x7e\x83\xf2\x34\xae\x9c\x8c\x92\xee\xbf\x22\x1d\x65\x9a\
\xce\xfa\xfd\x70\xc1\x9d\x09\xbf\x0d\xf8\x42\xb4\x08\x47\x44\x44\
\x44\x1c\x1a\x1c\xa1\x0e\x99\xff\x2e\xfb\xec\x98\x63\xc8\xac\xa0\
\xf4\xde\x3f\x87\xa4\x4c\xde\xe9\x7b\x09\xb3\xd2\x85\x8c\x2b\x64\
\x7c\x51\x01\x8e\x88\x28\x8f\xac\xb5\x4b\xea\x59\x5a\x41\x85\x8e\
\x6b\x30\xe9\x24\xcf\xac\xf7\xc3\x4d\xab\x2c\xa5\xfa\x40\xcb\x8f\
\x88\xe8\x49\x84\x1b\xb1\xee\xbb\x43\x16\x3f\x4a\x6f\x1a\x15\x32\
\xf2\x6b\x4f\xa5\x49\xaf\x9f\xf0\x3d\xa7\xd0\xad\x40\xbc\x37\x6b\
\x73\x2c\xeb\x7e\xdf\xae\x36\x97\xca\x7d\x0e\xf9\x72\x7a\x7d\xe6\
\x91\x45\x7a\x27\x1d\xeb\x91\xde\x24\x48\xd7\x2d\x54\x44\xb3\xca\
\x0d\xeb\x9a\x04\xef\x25\x19\xf9\x67\xd5\x2b\xdc\x34\x70\xef\x65\
\xe5\x5f\xae\x8f\xd2\xfd\x5f\xae\xac\x72\x32\x4a\x56\xff\x65\xa5\
\x4f\x3a\xf9\xed\xb0\x23\x2a\xc2\x11\x11\x11\x11\x87\x1f\x51\x01\
\x8d\x88\x88\x88\x88\x88\x38\x3a\x70\x67\xf9\x7b\x9a\xf7\xf6\x96\
\x7a\x44\x74\x13\xd1\x2d\x35\x22\x22\x22\x22\x22\x22\xa2\x3f\xc2\
\x45\x43\x0d\xbf\x17\x3b\xf9\x3d\x44\x18\x19\xb6\x10\xbc\x9b\xce\
\xc3\xa5\x6d\x0f\xfe\x3a\xcb\x37\x8d\x24\x23\xbf\xac\x67\x47\x0a\
\xce\x9a\x17\x7e\x2f\x64\xfc\x9e\x15\x29\x17\x4a\xbd\x5f\x7a\xc2\
\x92\xdd\x13\x67\xa9\xfb\xeb\xf9\xed\xf4\xdc\x70\xcf\x0e\x74\xdc\
\x0f\x76\xae\xf4\x16\xe5\xb3\xb7\xd4\x23\xa2\x1b\x88\x16\xe1\x88\
\x88\x88\x88\x88\x88\x88\xfe\x86\x2a\x74\xa6\xf0\x55\x14\xd0\x65\
\x10\x0a\xf8\xf3\x3a\x72\xb1\xac\x42\x41\xe7\xde\x41\x31\x02\xd2\
\xc2\xed\x59\x28\x80\xce\x26\x74\x27\xe7\x10\x14\x4d\x75\x01\x0a\
\xf2\xf3\xa2\xa5\x2b\xa2\xe0\x39\x8b\x83\x77\xb7\xa0\x20\x5b\xbb\
\xe9\x5c\x68\x4e\x50\x60\x9e\x59\xe8\xbc\x61\x7b\xf0\xec\x24\x14\
\x54\xe8\x48\x2a\x5d\x09\xba\xa3\xb5\x02\x05\xd0\x01\x45\xa9\x1d\
\x88\xee\x4c\x6d\x47\x51\x82\x87\x20\x05\x68\x2b\xde\x1a\x96\xd8\
\xf3\x93\xd1\x5d\xa9\xee\x2e\xe5\x3d\x1c\x3d\x45\xa1\x16\x8d\xc7\
\x32\x4a\xaf\xc9\x3a\x92\xa8\xb0\x3e\x5b\x85\x82\x18\xf5\x27\xa5\
\xe8\x6c\xa4\x57\x3c\x61\xdf\x73\x28\xa2\xf0\x8e\x03\xe8\x8b\x04\
\x05\xce\xda\x8e\x82\x3f\x46\x83\x5d\xc4\x11\x45\x9c\x60\x11\x11\
\x11\x11\x11\x11\x11\x7d\x05\xdd\xb5\x96\x26\x48\x99\x9d\x8f\x14\
\xba\xe9\xc0\xc7\x50\xa0\x1b\x80\x61\x28\xda\x7b\x0d\xde\xd2\xe5\
\xac\xbd\x09\x8a\xfa\x3c\x15\x5d\x9f\x72\x25\x12\xdc\x2f\x44\x11\
\xa4\x77\x04\xe5\x14\x91\x12\x3c\xdb\xd2\xec\x40\x82\xfe\xad\x94\
\x06\xd8\x0b\x2d\xc9\xee\x59\x3b\x8a\x1c\x7f\x3e\x3e\xb8\x4c\x01\
\x29\x78\x53\x52\x69\xc3\xf7\x93\x8c\x67\xe9\xb4\x49\x27\xef\x87\
\xe9\x27\x02\x97\x23\x05\xaf\x0e\x45\xc1\xff\x90\xf5\x0f\xd6\x0f\
\xd3\xd0\x15\x2b\x53\x50\x20\x1e\x97\x7f\x35\x30\xc9\xea\xfb\x11\
\xa4\x0c\x17\x3b\xa9\x5f\x38\x36\xe9\xfe\x2e\x67\x85\x2e\x04\x7f\
\xe1\xef\xed\x56\xee\x85\x48\x71\x0f\xd3\x25\x74\xaf\x2f\xb2\x2c\
\xfc\x85\x8c\xf7\xc2\x72\x67\xdb\xf8\xb6\xa6\xd2\x97\x9b\x93\x85\
\x6e\xa4\xe9\x09\x1c\x88\xd7\x41\x82\xa2\x24\xdf\x88\x22\x09\x8f\
\xb6\x77\x6b\xd0\x9a\x1a\x49\xc7\xf1\x72\x79\x87\xfd\xe8\x9e\x8f\
\xb3\xfc\xc2\x79\x70\x20\x5e\x14\x11\x11\xdd\x46\xb4\x08\x47\x44\
\x44\x44\x44\x44\x44\xf4\x15\xd4\x21\x25\x6d\x27\x3e\x3a\x6a\x16\
\xdc\x95\x2c\xd3\x90\x51\xe0\x04\x74\xd5\xd1\x58\x64\x1d\x9e\x84\
\xae\x43\xd9\x8c\x14\x5e\x67\xd1\x7d\x19\x59\xaa\x0a\x56\xd6\x05\
\xc8\xf2\x79\x1c\xb2\x7e\x6e\xc2\x5b\x6e\xc3\xa0\x34\xcb\xd1\x95\
\x29\x20\xab\xf3\xef\x23\xcb\x6e\x1d\xba\x3a\xc9\xdd\x3d\xbc\x0c\
\x29\xe7\x23\xd1\x75\x2b\x3b\xf0\x0a\xc2\x3c\x6b\xdb\x0a\x74\x15\
\x49\x0d\xb2\xd0\xe6\xd0\x55\x28\xeb\x90\x25\x7a\x00\x52\x4c\x47\
\x21\x8b\xb6\xb3\xe6\x9e\x82\xee\x37\xdd\x8d\x2c\xd2\x4d\x48\x69\
\x73\xef\xaf\xb5\xf6\x39\xa5\x32\x87\x02\xff\x5c\x60\x7d\x32\x0a\
\x45\xc2\xdf\x8f\xee\x23\xdd\x8f\x94\x96\xc7\x90\x55\x7c\xaa\xf5\
\x5f\x13\xf0\xb4\xf5\xf1\x7a\xa4\x20\xcf\xb6\x34\xef\x5a\x5e\xa7\
\x23\x19\x74\x19\xb2\x9e\x86\x98\x6c\xfd\x5d\x81\x22\x00\xef\xb5\
\x3e\x71\x57\xe9\xcc\xb7\x3a\x0e\x40\xca\xf6\x78\x1b\xef\x67\xec\
\xf7\x93\x81\x39\xe8\x0a\x96\x4a\xfb\x3b\xd7\xd2\x57\xd8\x38\xcf\
\xb0\x3a\xed\x03\x9e\xb5\xff\x6e\x8c\x8f\xb3\x3e\x6e\x43\xf7\xc5\
\xae\xb5\x7e\xcd\xa3\x7b\x5f\xa7\x21\xab\xfe\xf3\x94\x5a\x9a\xab\
\xd0\xa6\xc5\x33\xf6\x7c\x84\xb5\x73\x18\xba\x9a\x66\x39\xa5\x81\
\xa2\xea\xec\xf7\x91\xc1\xbc\x79\x89\x9e\x57\x88\x13\x60\x30\xda\
\x40\xd8\xde\x8d\xfa\x14\xad\xcf\xb7\xd9\xe7\x53\x81\x7b\xd0\x3d\
\xb7\x27\xa0\xeb\x93\xb6\x01\x13\x2c\x5d\x15\xf2\x9e\x78\x1b\x59\
\x91\x57\xa1\x79\x72\x01\xba\x2e\x68\x13\xf2\x1c\xa8\xc1\xdf\x35\
\xdb\x6a\xfd\x1d\xcf\xdf\x46\x1c\x56\x44\x8b\x70\x44\x44\x44\x44\
\x44\x44\x44\x5f\x40\x1e\x59\xa0\xbe\x8e\xee\xf9\xec\xcc\x82\x94\
\x43\xca\xc9\x78\x64\x7d\x9a\x8e\xee\xc3\x6c\x47\x8a\xd8\x54\x74\
\x5f\xf0\x08\x74\x85\x9a\xbb\x97\xf4\xb3\x48\xb1\x73\xd6\xaa\x7a\
\xa4\x10\x6e\x41\x0a\xdb\x6e\xa4\x04\xb9\xf3\xc0\xae\x0e\x75\x48\
\xf1\x1d\x85\x94\xab\x46\xa4\xfc\xde\x82\x94\x87\x3d\xc8\x6a\x3a\
\x0d\x29\x6d\x57\x59\xde\x2e\x8f\x85\xc8\xe2\xb6\xcf\xea\x7b\x89\
\xe5\x79\x13\x72\xff\xdd\x63\x9f\x67\x03\x97\x21\xd7\xe9\xad\xe8\
\x6e\xd7\x19\x48\xe1\xb8\x0e\x29\x8c\x33\x81\x8f\x23\x05\xed\x26\
\xa4\x58\xee\x01\x6e\xb6\xf7\xdb\xac\xdc\xa2\xb5\xab\x11\x29\xbc\
\x33\xad\x4f\x5e\x47\x0a\xce\x58\x6b\xdb\x06\x6b\xcb\x42\xab\xdf\
\x69\xc0\xa5\x48\x99\xba\xc8\xf2\x69\xb4\xb2\x87\xa0\x6b\x4b\x6a\
\xed\xd9\x87\xad\xcd\x4e\xd9\xaa\xb5\xba\xb9\x2b\x65\xae\x47\x0a\
\xd9\x65\x48\x41\xad\xb6\xbe\x19\x62\x6d\xbb\x18\x45\x0a\xbe\x14\
\x59\xf8\x67\x03\x1f\xb4\x31\x99\x6a\xe3\x5b\x01\x7c\x00\x6d\x04\
\x38\x8b\xfc\x4d\xd6\xbf\x13\x81\x4f\x5b\x9f\x5e\x8f\xee\x76\x6e\
\x00\x3e\x87\x94\xda\x06\xeb\x97\x29\xd6\x96\x8b\xd1\xe6\xc8\x49\
\xd6\x9f\x61\xc4\xdc\x71\xf6\xb7\x1a\x29\xdd\x1f\xb5\xb9\xb4\x1d\
\x79\x17\x2c\xa6\x54\xa9\xbc\xdc\xea\x5c\x0f\x5c\x83\x3c\x0b\x7a\
\x5a\x2e\x4f\xac\xbf\x7f\x1f\xf8\xaa\x8d\x65\x57\x8a\x70\x15\x52\
\xe8\x5f\x44\x9b\x0c\x67\x58\xfb\x1b\x81\x66\xeb\xf3\x91\xf8\xbb\
\xb1\x9b\x91\x47\xc4\x28\x1b\xc7\x0f\x21\x25\xf8\x32\x1b\xb7\x33\
\x6d\xec\x16\x20\x8b\xfe\x66\x1b\xc7\x8f\x58\x59\x11\x11\x87\x0d\
\xd1\x22\x1c\x11\x11\x11\x11\x11\x11\xd1\x17\x90\x47\x8a\xc8\x58\
\xfb\xdf\x99\xe5\x28\x87\xac\x93\x39\xa4\x3c\xd5\x22\xeb\xe7\x1c\
\x64\x79\x9d\x84\x2c\x90\x0b\x91\xa2\xf5\x63\xa4\x24\x4c\x40\x0a\
\x4d\x82\xb7\x2a\x4f\x41\xe7\x22\x67\x22\xe5\x7a\x30\x52\x6a\x72\
\xc8\x5a\x5a\x44\x82\xfe\x71\xf8\xbb\x3f\x7f\x82\x94\xcc\xbb\x90\
\xa2\x36\xda\xea\x30\xc6\xf2\x7e\x0e\x78\xd8\xea\x76\x3c\x52\xde\
\xbe\x8d\x2c\x86\x27\xe0\xaf\xa3\xa9\x07\xee\x43\x96\xdf\xb9\x56\
\x17\xa7\x94\x0d\x02\x7e\x89\x14\xb1\x1b\x81\x5f\x01\x0f\x21\x85\
\xe5\x4b\xd6\xc6\x5d\xf6\xfe\x2a\x6b\xf7\x54\xa4\xa0\x1c\x87\x14\
\xfb\xfb\xad\x9f\x66\x59\xde\x2f\x59\x99\xef\xb7\xbe\xda\x6c\xe9\
\x0a\x96\xff\xfd\xd6\xbf\xf3\x91\xa5\x35\x41\x0a\xf9\x76\xe0\x35\
\xa4\x18\x1e\x8f\x94\xe9\x3c\x52\xc6\x17\x58\xfd\xc1\xdf\x91\x3a\
\x0d\x59\xb2\x7f\x81\x2c\x84\x6f\x22\x25\xd5\x8d\xf3\x9b\xc8\xd2\
\xf8\xa8\xf5\xfd\x68\xa4\xf0\x8f\xb7\xbc\xef\xb2\xfa\x8e\xb6\x7e\
\x6a\xb3\xbe\x78\x01\xf8\x03\xab\xdb\x7d\x68\x73\xe2\x4b\xf6\xee\
\x3e\x4b\xb3\x1a\x29\xc1\x4f\xa2\x33\xe4\x0b\xac\xde\xe7\x22\x65\
\xbe\x0e\x29\x73\x67\x21\xcb\xe7\x3e\xab\xb7\xdb\x18\xd8\x63\xfd\
\xb7\xd0\xea\x5f\x83\xe4\xed\x33\x91\x55\xd3\x29\x9b\xa7\x00\xdf\
\xb3\x76\x36\x5b\x7b\x7a\x83\xb5\xb3\x0a\xcd\xf3\xf1\x48\x81\xed\
\x0c\x45\xeb\x9b\x99\xe8\xcc\x7a\x0b\x9a\x57\x27\x00\x2b\x6d\xdc\
\xdf\x40\x16\xe1\x3b\xac\x1f\xc6\x21\x05\x78\x14\xf0\x33\x34\xb7\
\x3e\x89\xee\x34\xde\x84\xf7\xa6\x58\x89\x94\xe9\x0a\xb4\x21\x31\
\xcf\xfa\xb2\xad\x97\xf4\x53\x44\x1f\x40\x54\x84\x23\x22\x22\x22\
\x22\x22\x22\xfa\x02\xda\x80\x6f\x00\x8f\xe0\xdd\x50\xcb\x09\xcc\
\x4e\x89\xdc\x89\x14\x90\x2d\x48\x81\x79\x0b\xb8\x02\x59\x44\xd7\
\x22\x85\xa6\x19\x6f\x15\x6b\x44\xc2\xb8\x43\xde\xfe\x2a\x82\xff\
\x2d\xc8\x0a\x96\xb7\xcf\x39\xa4\x54\xfd\xd0\x9e\x35\x22\xc1\x7e\
\x32\x70\x83\x95\xbb\x19\x29\x93\xce\x22\xb8\x1f\x7f\x3f\x6a\x1b\
\x72\x35\x3e\x05\x29\x7e\x21\x1a\x90\x95\xad\xc2\xea\x98\x47\xca\
\xd7\x2e\xa4\x44\x5f\x0c\x3c\x88\xe4\xbd\x46\xfb\xbd\xd5\xd2\x56\
\xdb\xfb\xcd\xc1\xfb\x39\xa4\xd8\xee\xb4\x3a\x14\xac\x4f\xce\x41\
\x8a\xfa\x6a\x2b\xcf\xb9\x09\x3f\x8d\x3f\xfb\xb9\xcf\xf2\x49\xf7\
\x7b\x2e\xf8\xab\xb1\xf2\x1a\xed\xbd\x5f\x5a\xfe\xae\xdd\xad\xc0\
\x7f\x22\xa5\xf7\x14\xa4\x5c\xfe\x3d\x52\x5c\x6f\x40\xca\xfd\x5b\
\x56\xb7\x16\xfb\x1f\xb6\xbd\xda\x9e\xb9\x7e\x73\x4a\x53\xc1\xca\
\xac\xb4\x34\x8d\xa9\x34\x35\x96\x9f\x4b\x53\xb0\x7a\xba\xfb\x57\
\xdd\x38\xef\xb1\xf4\xeb\x91\x75\xdc\x8d\xaf\x9b\x0b\xee\x2c\x6c\
\x95\xcd\xa1\xfd\x96\xfe\x59\xa4\xe4\x61\x79\x57\x58\x3d\x5c\x19\
\xce\x8b\xc0\xfd\x9e\xa7\x67\x94\xbd\x9c\xb5\xf1\xcb\xd6\xf7\xaf\
\x74\xa3\x1e\x4b\x90\x62\xff\x1e\xeb\xab\x0a\xb4\xa6\xd6\xe0\x03\
\xa7\x8d\x47\x96\xf5\xed\x48\x29\x76\x6d\x74\xe7\xb9\xb3\x2c\xe1\
\x0b\x90\x15\x7e\x95\xf5\x67\x54\x7e\x23\x0e\x3b\x7a\xda\x05\x23\
\x22\x22\x22\x22\x22\x22\x22\xe2\x70\x20\x87\xce\x10\x3e\x8a\x14\
\xb9\xae\x04\xe7\x76\x24\x64\xbb\xe8\xd0\x09\x52\xf4\x26\x20\x01\
\x7d\x27\x52\xba\xa6\x22\xa5\x6c\x01\xb2\xba\xbe\x81\x77\x95\xce\
\x51\xaa\x08\xe5\x91\xab\xf0\xbd\xc0\xdd\xf6\xb9\x02\x29\x3a\x2e\
\x58\x56\xa3\x95\x35\x09\x59\xdc\xee\x47\x4a\xf7\xd0\x20\xbf\x7c\
\x90\xe7\xbb\xc8\x1a\x9c\xc3\x5b\x9a\xf3\xa9\xff\x2e\x6d\x05\xb2\
\x3e\xd7\x59\xf9\xef\x22\xcb\xdb\x6b\x48\x39\x99\x81\xdc\x4d\xdb\
\x90\x62\x16\x1a\x44\x9c\x62\xf2\x8c\xbd\xfb\x2b\x4b\xb7\x1a\x29\
\xd5\x4d\x48\xc1\xde\x87\x36\x11\x66\xa1\x73\x9e\xe9\x7a\xa4\xeb\
\xef\xdc\xc3\xc7\xd9\xf8\xec\xb7\xf7\xdf\x41\x96\xdf\x6a\x4b\xe3\
\x22\x4d\x5f\x61\x65\xde\x6d\xf5\x1b\x6e\xe3\x94\x20\x17\xdc\xe7\
\x83\xbc\x73\xa9\xcf\x6f\x22\x6b\xf4\x1c\x64\xb1\x9d\x84\x57\xce\
\x9c\xe2\xfb\x3a\x72\xdf\x9d\x85\x3f\x3b\xbc\xce\xca\xca\x95\xc9\
\xbb\x05\x59\x28\xeb\xac\x8c\x9c\xcd\x13\xd7\xb6\x9c\xcd\x97\x2a\
\xe4\x11\xe0\xac\xe0\x6d\x36\x5f\xc6\x5b\xdb\x46\xda\x18\xb6\x59\
\x9b\xce\x47\x6e\xf9\xe7\x23\x25\xbf\x12\xb9\x79\x87\x79\xf7\x04\
\xde\x46\x96\xf6\x06\xca\xaf\xa3\x04\x7f\xde\xfb\xdf\x81\x3f\x07\
\xfe\x02\xf8\x3b\x74\x16\x78\x9c\xa5\x19\x8d\x2c\xc6\x83\x90\x05\
\x78\x33\x52\x9c\x41\x1b\x35\xb5\xc0\xb7\x90\x6b\xfa\x58\xfc\xfc\
\x39\x05\xad\x9f\x5f\x5a\x7f\xd5\xf6\x60\x7f\x44\xf4\x51\x44\x8b\
\x70\x44\x44\x44\x44\x44\x44\x44\x5f\x41\x0e\x29\x3d\xdd\x4d\xfb\
\x26\x72\x43\x76\x56\xc9\xdd\xc8\x7a\xb7\x06\x29\x85\x6f\x21\xa5\
\xf6\x62\x24\xd4\xdf\x8b\xac\xcd\xb3\x91\x52\xb8\x1f\x29\x6d\x09\
\x52\xa6\x76\xe2\xad\xc3\x20\xcb\xd7\x06\xfb\x9c\x56\xae\xde\x40\
\xc1\xa9\xae\x45\xca\xc1\xe3\x48\xd9\x5c\x83\xac\x66\x79\xa4\x88\
\xac\xb2\xff\x3f\x44\x67\x83\xab\xac\x5e\xad\x48\x39\x73\x56\xc9\
\xd5\x48\xb9\xdd\x8e\x94\xad\x39\x96\xcf\x83\xc8\xf2\x78\x05\xb2\
\xaa\x36\x02\xff\x6d\x75\x4d\xbf\xbf\x0d\xc9\x86\x61\x1f\xee\x40\
\xca\xf1\x4a\x7c\x00\x32\xe7\xe2\xbb\xcd\xde\x5d\x63\xfd\x91\xb7\
\xf4\xab\xac\xcc\xb7\xad\xee\x8f\x20\x05\xf5\x0d\xe0\x07\x68\xf3\
\xa1\xc2\xca\x5c\x1b\xf4\xd7\x3e\xa4\xa8\x5e\x62\xfd\xff\x10\x72\
\x3f\x6f\xb4\xff\x09\xde\xa5\x7d\x35\xfe\x5a\x9e\x4d\xf6\xf9\x05\
\x7c\xc4\xef\x06\xe4\x06\xde\x6c\xe5\x3a\xeb\xf1\xc3\xd6\xc6\xeb\
\xed\xb7\xff\x42\x8a\xeb\x4a\xeb\xff\x62\x90\x1e\x7b\xbe\x0b\xf8\
\x29\x3a\x9f\x7c\x8b\xa5\x73\x0a\x9a\x53\xdc\x9c\x9b\xf8\x64\xb4\
\xf1\xf0\x2d\x64\x25\x9d\x67\xf9\xbf\x86\x94\xc1\xe3\x6d\xac\xef\
\xb3\x71\xba\xd6\xc6\xd4\x59\xda\xa7\x21\x8b\x73\x67\x1e\x0d\x47\
\x1a\xdd\x35\x94\x0d\xb7\xb1\x77\x41\xbe\xdc\x9a\x7a\xc9\xda\xfa\
\x28\x3a\x4a\xf0\x90\xf5\xe9\xf5\x68\x33\xe4\x11\x6b\xf3\x64\xe4\
\x32\xfd\x36\x3a\x8f\x7f\xa2\xe5\xb7\xdd\xfa\xe7\x2a\xe4\x86\xbf\
\x09\xad\xd3\xee\xae\xed\x88\x88\x6e\x21\xb7\x64\xd2\xc0\xfa\x6f\
\xdf\x30\x7d\xe8\xd8\x41\x95\x24\x31\x30\x79\xc4\x11\x46\x4b\x7b\
\xc2\xe7\xef\x5d\x57\x7f\xe7\xeb\xbb\x6f\x47\x4c\x21\x7a\x25\x44\
\xf4\x66\x14\x50\xa0\x9c\x4d\x48\x00\x8e\x4c\x38\x22\xa2\x67\x51\
\x0d\x7c\x11\x09\xcf\xcb\x39\x3c\x3c\xc4\xb9\x6f\x86\xdf\xa1\xf4\
\x5a\x1d\x67\x38\x70\x6e\x9c\x61\x9a\x1c\x1d\xa3\x44\xd3\x49\x7e\
\xa4\xde\xad\xc4\xbb\xc5\xe6\x52\xbf\x87\xf5\x73\x96\xcd\x24\xf5\
\x7e\x92\x7a\xd7\xb9\x09\x57\x50\x1a\xb0\x0b\x4a\xaf\x61\xca\x97\
\x79\x3f\x4b\x1a\xcc\x91\xdd\xae\xac\x77\xb3\xfa\x26\x49\x95\xed\
\xac\xaf\xe5\xda\x5d\x11\xfc\x5e\x81\x82\x5a\xdd\x80\x94\xa1\xc7\
\x83\xdf\xb3\xca\x0f\xcb\x72\xcf\xf2\xa9\xef\x5d\xf5\x45\x98\x3e\
\xec\x57\x90\x02\xe7\x22\x79\x87\xf5\x76\x67\xc1\x27\x01\xdf\xc7\
\xbb\x40\x57\xe0\x37\x10\x42\x2f\x82\xeb\x90\xb2\xfd\x3a\x3e\x38\
\xda\xf7\xf0\x73\xfa\x48\x49\xe5\x09\x52\x3a\xbf\x88\xce\xe5\x6e\
\xe7\xe0\x15\x6e\xd7\x96\x62\xc6\x73\x57\x56\x05\x3e\x12\x79\x38\
\xd7\xc3\xcd\xa2\x70\x83\x28\x5c\x77\xe1\x3c\x38\xd2\xfd\x12\xd1\
\x3f\xe0\xbc\x14\x6e\x03\xbe\x10\x2d\xc2\x11\x11\x11\x11\x11\x11\
\x11\xfd\x19\x49\x17\xdf\x43\xa5\x28\x4b\x18\x4f\xca\xbc\x47\x17\
\xcf\x9d\xf0\xdf\xde\x45\xda\x50\xd9\x2b\x96\xf9\x2d\x9d\x2e\x21\
\x5b\xc9\x74\x0a\x49\x67\xed\xe8\x6e\x1b\x92\x03\xf8\xec\xce\xe9\
\xa6\xfb\x33\x4b\x01\xcb\xa5\x7e\x77\x67\x4e\xb7\xe3\xaf\x31\xea\
\xac\xcc\xb0\x2c\x87\x62\xea\xf7\xae\xfa\x22\x4c\x9f\x56\xb6\xb3\
\xfa\xd5\x7d\x7f\x1e\xb9\xfd\x0e\x41\x8a\xad\x1b\x87\xb4\xa2\x5f\
\x04\x96\xa2\x48\xc9\x73\x91\x35\xf9\x81\x6e\x8c\x43\x6f\x83\xdb\
\x78\xc8\x7a\xee\x10\x8e\x45\x38\xd7\xb3\xe6\x40\x7a\x9c\xc2\x34\
\xc7\x52\xbf\x44\x1c\x23\x88\x8a\x70\x44\x44\x44\x44\x44\x44\x44\
\x44\x44\x6f\x45\x1b\xb2\xb0\x76\xa6\x3c\xf7\x06\xe4\x90\x7b\xf3\
\x83\xdd\xa8\xa7\x8b\x8a\xbc\x8a\x8e\x16\xe3\x88\x88\x88\xa3\x84\
\xa8\x08\x47\x44\x44\x44\x44\x44\x44\xf4\x67\x14\xf1\x2e\x9c\xe1\
\xb3\x30\x10\xd6\xc1\xe4\x19\xba\x4c\x1f\x0e\x05\xc7\x45\x24\x76\
\x48\x07\xa9\x3a\x9c\xfd\x71\xb8\xea\xec\xe0\x2c\x87\x69\x57\xf6\
\xae\xca\x72\xbf\x77\x75\x97\x6d\x6f\x42\x77\x2d\x97\xa1\xe5\xfe\
\x58\x56\x80\xd3\xde\x12\xee\xd9\xe1\x9a\x43\x69\x8b\xfc\x81\xfe\
\x5e\xee\x9d\xac\xf9\x18\xd6\x3f\x74\xd3\x3e\x96\xc7\x27\xa2\x13\
\xc4\xf3\x99\x11\x11\x11\x11\x11\x11\x11\xfd\x15\x45\xe0\x24\xe0\
\x1a\x7c\xf4\xe2\x0a\xe0\x6c\x74\x8e\xf2\x60\xdc\x31\x5d\xe4\xe6\
\xd1\xc8\xed\x75\xe6\x41\xe6\x93\xc6\xa9\xc0\xad\xf6\xf7\x49\x14\
\x88\x69\xd0\x61\xca\x3b\xc4\x12\xfc\x7d\xc4\x87\x03\x09\x8a\x96\
\x7c\x26\x1d\xe3\x2c\x2c\x46\xe7\x7f\xb3\xda\x50\x65\xbf\x0f\x38\
\x02\x6d\x8c\x38\x3c\x48\x50\x30\xb0\xd3\x82\x67\x39\x14\x05\x7b\
\x3c\x87\x67\xdc\x26\xa3\xa0\x5c\xe5\x5c\xb0\x87\xa0\xc8\xee\x07\
\x52\xe7\x71\x56\xe7\x7c\xc6\x6f\x03\x51\x30\xb7\x1a\x4b\x37\xfa\
\x30\xb5\x23\xa2\x17\x22\x2a\xc2\x11\x11\x11\x11\x11\x11\x11\xfd\
\x15\x35\xc0\xd5\x28\x12\xf0\x74\xbc\x25\x68\x02\xba\xae\xc5\x59\
\x61\x0b\xf8\x00\x49\xee\x73\x18\xd4\x27\xfc\xbd\x12\x9d\xfd\x1c\
\x8f\x94\xe9\x61\xa9\x34\xe1\xbb\x49\xea\xdd\x72\x48\x90\x70\x3e\
\x09\xdd\x79\xbc\x13\x29\x1b\x1f\xb2\xfa\x86\x79\x24\xa9\xb2\x1c\
\xba\x53\x77\x80\x31\x48\xc1\xee\x4e\x9d\x0b\x65\x9e\xa5\xcb\xaa\
\xb3\xfe\xc8\xa7\x7e\x3b\x03\xdd\xd5\x5c\xcc\x78\xa7\x0d\x45\x50\
\x3e\x8b\xa8\x88\x1c\x6d\xb8\x73\xcc\x5d\xa1\x88\xae\x39\x3a\x87\
\xd2\x40\x63\x97\xa1\x0d\x8e\xac\x71\x85\xec\x79\x07\x1d\xe7\x50\
\x25\x0a\x92\x36\x99\xec\xb5\x58\x44\x9b\x25\xef\xa1\xfc\xdc\x0f\
\xdb\xe2\xde\xaf\x43\x4a\x2e\x74\x5c\x83\x55\x68\xae\x56\xa2\x80\
\x66\x33\x91\xd5\x3e\xac\xa7\x2b\x2b\xe2\x18\x47\x74\x8d\x8e\x88\
\x88\x88\x88\x88\x88\xe8\x8f\x28\x22\x25\x6c\x10\xf0\x6b\x14\x90\
\xe9\x4d\x7b\xbe\x11\x9d\xf7\x5c\x88\x14\xe2\x29\xe8\x5a\xa0\xf5\
\xe8\x1a\xa0\x46\x74\xcf\x6a\x0b\xb2\xfa\xce\x46\x0a\xc0\x52\x74\
\x8d\x92\x13\x94\x77\x20\x85\xee\x78\x24\xcc\x0f\x42\xca\xf7\x53\
\x48\xa1\x1d\x82\x2c\xa5\xc3\xd1\x15\x32\xaf\xd2\x31\xd0\x53\x58\
\xdf\x97\x80\xbb\xf0\xf7\x0b\x7f\x0c\x09\xed\x73\x91\x4c\xb7\x1b\
\x45\xd3\x3e\x0d\x29\xb4\xab\xd1\x15\x4d\xad\x48\xa0\x5f\x68\x9f\
\x9f\x43\x57\x1f\xcd\x07\x4e\x40\x56\xbc\x57\xd0\xdd\xbe\x5b\x81\
\x3d\xf6\xdb\x70\xa4\xcc\x17\x81\x27\x51\x00\xa8\xc9\x48\xf9\x19\
\x88\xce\xb8\xbe\x64\xfd\x38\xc6\xfe\xda\x51\x24\xe4\x79\x56\xa7\
\xc7\xac\xbf\x36\x59\xdb\x26\x22\x05\xb8\xd9\xf2\x77\x9b\x0f\x0b\
\xad\x2e\xbb\xac\x7e\xbb\xed\xff\xc7\xd0\xb5\x48\xf5\x44\x17\xd5\
\xa3\x01\x67\x65\x1d\x80\x02\x94\x75\xa5\x10\x67\x29\x85\xee\x59\
\x1e\x79\x5c\xcc\x45\x73\xea\x59\x74\xad\xd5\xe9\x68\x2c\xc7\xa3\
\x39\xf7\x0a\xf2\x16\x38\x15\x6d\x7e\xb4\xa2\x2b\xbb\x06\xa0\x3b\
\x89\x5b\xd1\x5c\x1e\x81\x3c\x16\x40\xf3\x7a\xa3\x7d\x9f\x8a\xd6\
\xe0\x7a\x34\xb7\xc6\xa2\x6b\x98\x5e\x44\xf3\x7e\x24\x9a\xbf\xb3\
\xac\xcc\x55\x68\xfd\x25\x96\xf6\x74\xe4\x11\xf2\x8a\x3d\xdf\x88\
\xe6\xf2\x02\xab\x43\x11\xcd\xeb\x97\xac\x4d\xe7\xa0\xeb\xbc\xb6\
\x12\xe7\xe4\x31\x8d\x68\x11\x8e\x88\x88\x88\x88\x88\x88\xe8\xaf\
\x38\x0d\x09\xcc\x3f\x47\x82\xf4\x18\x24\x90\x9f\x8f\x84\xee\xb3\
\x91\xc5\x78\x37\xba\xf3\xf5\x23\xe8\xae\xd8\x0b\x90\xf0\x3c\x05\
\x59\x8d\x76\x59\x7e\x9f\x44\x16\x60\x77\x06\x71\x3e\x12\xbe\x67\
\xdb\xbb\x6d\x48\x10\xff\x08\xb2\x4a\x7d\x18\x09\xfe\x9b\xd1\x3d\
\xbf\xa7\xd3\xb9\xe2\x31\xd0\xea\x35\x1a\x29\x9a\xbb\xed\xd9\x6d\
\xc0\x50\xa4\x64\x7c\x08\x29\x1f\x5b\x80\xf7\x22\x6b\xd9\x34\xe0\
\xe3\x48\xf9\x1c\x6c\x75\x9e\x6d\x6d\xdb\x61\x6d\xfe\x14\x52\x80\
\x4e\xb5\x76\x2d\x41\xd6\xb8\x7d\xe8\x7e\xd7\xeb\xed\xdd\x9b\x2c\
\xfd\x36\xe0\x66\xfb\x6d\xae\xb5\xa5\xc9\xde\xfb\x1d\x6b\xeb\x5c\
\x6b\xd7\x28\xa4\x3c\x8c\x44\xae\xdd\x03\x90\xe5\xed\x44\x6b\xef\
\x19\xc8\x3d\x7d\x8b\x95\xfd\x41\xb4\x61\xb0\xd5\x7e\x9f\xc1\xb1\
\x75\x4e\xf8\x58\x85\x73\x0d\xfe\x3d\xe0\x6b\x74\x3d\x1f\xdd\x3b\
\xa7\x02\x7f\x64\x7f\x7f\x88\x36\x7e\xda\x81\x45\xc0\x07\xd0\x5c\
\x19\x83\xe6\xc8\x10\xe0\x46\xfb\x6d\xb7\x7d\x5e\x68\x7f\x17\x20\
\x25\x74\x2c\xf0\x51\xcb\xa3\x01\xcd\xd1\xb1\xc0\x67\xf1\x67\xc6\
\x3f\x8d\x3c\x24\xea\xd1\x9a\x6c\x44\x73\x7f\x01\x9a\x47\x97\x02\
\x97\xdb\xf3\xf7\xe1\x3d\x28\x2a\xd0\x7c\x3c\x03\x6d\xc4\xdc\x86\
\x36\xa8\x5a\xd0\x7c\x9f\x8a\x36\xc5\x72\xe8\x7a\xab\x5d\xf6\xce\
\x75\x68\xde\x8e\x43\x16\xef\x68\x11\xee\x03\x88\x16\xe1\x88\x88\
\x88\x88\x88\x88\x88\xfe\x06\x67\xf5\x5a\x82\xee\xa5\xad\x44\x16\
\xa1\x25\xc0\x2f\xf0\x42\x6e\x01\x78\x1a\x5d\x6d\x33\x07\x59\xc8\
\xee\x47\x42\xf9\x24\x64\xe1\xba\x03\x19\x16\x06\x22\xc1\x7a\x68\
\xaa\x1c\x97\xd7\xcb\xf6\xee\x09\xc0\xe7\x90\x15\xf5\x54\xe0\x11\
\x24\x60\x83\x84\xf3\xa7\x3a\xa9\xf7\x95\x48\xd0\xcf\x21\x2b\xd9\
\x8f\xec\xff\x36\x14\xad\xb8\x1a\x29\xde\x5f\x41\x96\xe9\xbd\xe8\
\x8e\xda\x11\xc8\x5a\x76\x17\x52\x30\x47\xda\x7b\x77\x22\x21\x7f\
\x08\x52\x0e\x86\xe2\xad\x79\x45\x64\x95\x7b\xc0\xf2\xb9\xc2\x9e\
\xdd\x63\xe5\x0c\xb3\x7e\x1b\x67\xf5\x79\x15\xb8\xcf\xfa\x61\x2a\
\xf0\x33\xa4\x0c\x9f\x8a\x2c\x69\xed\xc8\xfd\xbc\x12\xf8\x31\x52\
\x3c\x66\xe1\x37\x1e\x9c\x0b\x75\x8b\xbd\x33\x1a\x59\xbd\xf7\x5b\
\x5f\xbf\x70\xb4\x27\x49\x3f\x45\x15\x3a\x1a\x30\x16\xcd\xe7\xae\
\x90\x43\x16\xd6\x7b\xed\x7b\x05\x7e\x43\xe9\x6c\xb4\x36\x6a\xd1\
\x7c\x5b\x08\xfc\x0a\x29\x97\x77\x03\x6f\xa1\x31\x3f\x1d\x45\x06\
\x6f\xb0\xf7\x1a\xd1\x66\xce\x5e\xb4\x49\xb4\x1c\xad\x9b\x1d\xc0\
\x4f\xd0\x5c\x99\x8c\xac\xc5\x6b\xad\x8c\x26\x4b\xf3\x0f\xc8\x7a\
\xbc\x1b\x29\xb6\x3f\x47\xf3\xf2\x76\xe0\x21\xe0\x51\xb4\x41\x55\
\xc0\xcf\xbf\x9f\xa0\x79\xe7\xac\xd0\x58\x1d\x37\x23\xcb\xef\x0b\
\xc0\x25\x78\x8b\xf2\x6a\xb4\xe6\xa2\x35\xf8\x18\x47\x54\x84\x23\
\x22\x22\x22\x22\x22\x22\xfa\x1b\x8a\x48\xb1\x1d\x87\x84\xf3\x93\
\x90\x50\x7b\x2e\x72\x93\x0e\x15\xe1\x7d\xf8\x20\x4f\x8d\x78\x6f\
\xba\x22\x52\xec\x6e\x02\x36\x58\xba\x74\xb4\xd9\xb0\xbc\x7a\x7c\
\xa4\xe0\x04\x29\x1c\x05\x24\xec\xb7\x22\x37\xce\x6d\x41\xb9\xe9\
\xc0\x52\x20\x41\xfe\x41\xfb\xad\xc1\xea\x73\x3c\x52\x02\xda\x91\
\xc5\x36\x41\x42\x7d\xde\x7e\xaf\x40\x8a\x48\xb3\xe5\x91\x43\xca\
\xea\x74\xa4\x58\xaf\xb7\xba\x17\xe8\xe8\x29\xb8\x27\x68\x4f\x11\
\x29\x46\xd7\x5b\x5e\xeb\x83\x77\x0a\xd6\x3e\x17\xc5\xba\x01\xaf\
\x24\x84\x7d\x51\x85\x3f\x6f\x99\x58\x3e\x39\xa4\x58\xef\xb1\x7a\
\x6f\x01\x7e\x6a\xfd\xe2\xac\x7f\x51\x5e\x3d\x3a\xc8\xa1\x71\xf8\
\x6b\xa4\x08\x2f\xa5\x7b\xca\xde\x0e\xb4\x11\x02\x9a\x6f\x7b\xd1\
\x5c\xa8\xb2\xfc\x9a\xd1\xa6\xc8\x8f\x91\x82\xda\x86\x1f\xfb\x46\
\x34\xfe\xa7\x20\x4b\xec\x2a\xfc\x78\xbb\xf9\xe4\xe6\x48\x33\x7e\
\xfd\x34\xa1\x4d\x9d\x16\xfb\xbd\x8a\x8e\x73\x3f\x8f\xbf\x9e\x2a\
\x2b\x82\x7b\x95\xfd\xe6\x8e\x23\x0c\x40\x6b\x85\x20\x6d\x1e\xcd\
\xe7\xa5\x48\xb1\x1f\x88\xd6\x60\x42\x54\x84\x8f\x79\x44\xd7\xe8\
\x88\x88\x88\x88\x88\x88\x88\xfe\x86\x4a\xa4\xf4\xde\x0f\xfc\x29\
\xf0\xff\x01\x7f\x89\x2c\xa7\x73\x29\xbd\x12\x26\x17\x7c\xce\xa7\
\x9e\x9f\x80\x14\xbb\x07\x90\x22\x38\xd8\x7e\xaf\xa0\x54\x90\xce\
\x05\xef\xe6\xec\xf7\x5d\xc8\xe2\x09\xb2\x8c\x8d\x45\x56\xd6\x21\
\xc8\xfa\x9a\x8e\x96\xec\x04\xf2\x1d\x28\x58\x56\x73\x50\x86\x2b\
\x6f\x3b\x52\x34\x2e\x46\x8a\xee\x7b\x90\xeb\xf7\xcb\xc8\x0d\x79\
\x9e\xb5\xfb\x26\xfc\xd9\xcb\x07\x91\x22\x3c\x20\x28\x27\x47\xa9\
\xd2\xe0\x3e\x8f\x45\xd6\xc2\x87\xd0\xd9\xce\x21\x65\xda\x97\xfe\
\xec\xea\xb8\x0e\x29\x12\x67\x20\xab\xdc\x02\xeb\xeb\xe5\x56\xfe\
\x3b\x56\x27\x17\xb8\xac\xd2\xd2\x6f\x39\xca\xf3\xa3\xbf\x63\x25\
\x3a\x53\x1b\x6e\x68\x94\x83\x53\x36\xdd\x7f\xf7\x57\x44\x67\xee\
\xeb\x90\x05\xb5\x01\xb9\xe8\x17\xf1\xae\xf2\x27\xa2\xb9\xf0\x1a\
\x9a\x0f\xef\x02\x0f\xe3\x03\x5a\xb9\xf9\x3f\x16\xcd\x8d\xe9\x48\
\x61\x5e\x68\xef\xbe\x81\xd6\xdf\x08\x34\x6f\x76\x03\x17\xe1\xe7\
\xfe\x6a\xb4\x79\x73\x15\xf0\xff\xd0\xdc\x3d\xd7\xf2\xac\x40\xd6\
\xe4\xa1\xc8\x03\x61\x3e\x72\x93\x1e\x8e\xdf\xb0\x2a\x22\xcf\x84\
\x5a\xb4\x51\x35\x17\xcd\xc7\xb7\xbb\xd1\x2f\x11\xc7\x00\xe2\x0e\
\x5b\x44\x44\x44\x44\x44\x44\x44\x7f\x42\x82\xce\x04\xee\x43\x6e\
\xd1\xce\xaa\xb9\x19\xf8\x25\x12\xaa\x9d\x90\xbb\x16\x29\x9d\x39\
\xbc\x3b\x64\x1e\x59\x80\x73\x48\x10\x1f\x87\xce\x41\xbe\x8b\x02\
\x68\xb5\xd9\xf3\xbd\x28\x40\x54\xa3\xa5\x6d\xc2\x5b\xaa\x5e\x47\
\x42\xfb\x7f\xa1\xf3\x86\x37\x21\x05\x77\x29\x12\xba\xcf\x42\xca\
\x6b\x83\xd5\xc3\xb9\x9f\x6e\xa1\xe3\xdd\xc1\x0d\x48\x91\x2c\x58\
\x19\xff\x8d\xce\x06\xdf\x68\xe5\x3b\xd7\x66\xa7\x60\xb7\x21\x97\
\xe8\xbd\xe8\xdc\xe3\xf5\xe8\x5c\xe6\x63\x48\xf0\x5f\x63\x75\xdb\
\x80\xb7\xec\xd5\x23\xe1\x7f\x25\xb2\x98\x5f\x69\xfd\xf5\xb8\xa5\
\x69\xc7\x5b\x8f\x37\x5b\x9d\xf2\xd6\xa6\x95\xd6\xd7\xab\xed\xb7\
\xef\xa3\xb3\xa0\xed\xd6\xde\x5d\xc0\x32\x6b\xd3\x07\xac\x7e\x8f\
\x5b\x3f\x8d\x45\x0a\xf2\x2a\xa2\xf1\xe6\x68\xa2\xbb\x7d\x9d\xc3\
\x7b\x43\x38\x24\x48\x01\xde\x8b\xd6\x41\x15\xf0\x7e\x34\xde\xbf\
\x46\xe3\xba\x1f\xb9\x4f\x5f\x83\xe6\xc0\x13\x68\x93\xe4\x4a\x34\
\x27\x37\xa1\x63\x07\x05\xfb\x6d\x01\x52\x96\xef\x04\x2e\xb4\x72\
\xee\x43\xeb\x68\x27\xf2\xe8\x98\x85\xe6\xfe\xe5\x68\xee\x6f\x46\
\x73\x7f\x21\x0a\xba\xf6\x18\x9a\xc7\xf3\x91\xab\xf3\x1a\x34\xef\
\x7f\x88\x94\xe3\x0a\x4b\xbf\x12\xb9\x5d\xb7\x58\xd9\xe7\x20\x77\
\xe8\x77\xf1\x6e\xda\xce\x85\x3b\xe2\x18\x47\x6e\xc9\xa4\x81\xf5\
\xdf\xbe\x61\xfa\xd0\xb1\x83\x2a\x49\xe2\xb1\xef\x88\x23\x8c\x96\
\xf6\x84\xcf\xdf\xbb\xae\xfe\xce\xd7\x77\xdf\x8e\x88\x5a\x64\x6c\
\x11\xbd\x19\x05\xe0\x33\x88\x29\xdf\x4b\x64\x7c\x11\x11\x3d\x8d\
\x6a\xe0\x8b\xe8\x5c\xee\x72\x0e\x9e\x87\x38\x0b\x67\x31\xe3\xf9\
\x34\x64\x19\xfa\x1a\xfe\xfc\x61\xe8\x06\x19\x7e\x2e\xe2\xad\x9d\
\xed\xa9\xfa\x64\xb9\x4e\x26\x41\x39\x49\x90\xc6\xbd\x9f\x20\xab\
\xf2\x15\x48\x28\xdf\x47\xa9\x55\x36\xcc\x23\x5d\xef\x24\x55\xae\
\xcb\x33\xfc\xbd\x12\x7f\xed\x0c\xa9\x74\x69\xb7\xd1\xce\xea\x5c\
\x89\xbf\x0e\xa7\x5c\x9b\xb3\x3e\x3b\x2b\x9b\xb3\x60\x17\x29\x1d\
\x07\x57\x3f\xe7\xaa\x7a\x39\xb2\x92\xff\xf0\x20\xc7\x39\xa2\x23\
\x12\xb4\xd9\xf3\x45\xe0\x6f\x91\x17\xc1\xa1\x58\x37\xb3\xe6\x65\
\xb8\x3e\xa0\x74\x5c\x87\x02\xff\x03\xf8\x77\xb4\xb1\x13\xae\x41\
\xe7\x75\x11\xae\xa5\x62\xea\x7d\x67\xc4\x73\x69\xdc\x1c\xcc\xd9\
\xef\xe9\xb9\x5f\x11\x94\xe1\xee\x09\x0f\xd7\x8a\x7b\x46\xf0\x7e\
\x2e\xf5\x5b\x35\x8a\x3e\x7d\x2d\xf0\x1f\x48\xf9\x8f\xf2\xeb\xb1\
\x89\x04\x59\xf9\x6f\x03\xbe\x10\x2d\xc2\x11\x11\x11\x11\x11\x11\
\x11\xfd\x0d\x61\x10\xab\x10\x15\x28\x92\xf4\xeb\x48\x48\x4f\x2b\
\x98\xa4\x3e\x3b\x81\xbf\x90\x4a\x4b\xc6\x3b\x74\xe3\x7d\x90\xd0\
\xfe\x04\xb2\x9a\xe5\xba\x91\x57\xfa\xb7\xac\x3c\xdd\xf3\x42\x2a\
\x4d\x3a\x5d\x77\xca\x48\xe7\xd3\x59\x9b\xb3\x3e\x3b\xe5\x25\xad\
\xb8\x13\xe4\x9b\x47\xca\x47\x1e\xb9\xca\xc6\xf3\x98\xbd\x17\x49\
\x27\xcf\xb2\xc6\xb5\x1d\x79\x17\xb4\xe0\x37\x42\xc2\xf7\xd2\x6b\
\x29\x97\x7a\x3f\x3c\xb6\x00\x1d\x37\x95\xa0\xe3\x7a\x22\x48\x9b\
\xb5\xf9\x15\x6e\x0c\xa5\xeb\x5f\x40\xee\xd0\x17\xa1\x40\x76\x9b\
\x88\x4a\x70\x9f\x41\x54\x84\x23\x22\x22\x22\x22\x22\x22\x22\x84\
\x76\x14\xd0\xa7\x70\xa8\x19\x1d\x24\x9c\x0b\xb5\x73\xa7\xee\xcf\
\x70\xe7\x97\xd3\xca\x52\xc4\xb1\x8d\x26\xb4\xc6\x8e\x95\xcd\x8d\
\x1c\x72\xbf\xfe\x7f\x74\xdc\x5c\x8a\x38\xc6\x51\x99\xcb\x41\x65\
\x1e\x2a\xf3\xb9\xe8\x1a\x1d\x71\x44\x91\xcb\x41\x31\x49\xc8\x8b\
\x84\x14\xe8\xe8\x46\x16\x11\xd1\xdb\x50\xc0\xbb\x11\x3a\xb7\xc5\
\x88\x88\x88\x9e\x83\x73\x6b\x3c\x92\x3c\xa4\xfd\xd0\xb3\x88\x88\
\xe8\xb5\x48\x38\xbc\xfc\xcc\x45\x00\x0f\xcf\xae\x3b\x17\xf8\xf4\
\x79\xf6\xb0\x0e\x59\x28\x74\xf2\x4e\x4f\xa3\x3b\x1b\x32\x2e\x4d\
\x6f\xac\x7f\x44\x06\x2a\x37\xee\x69\xab\xfe\xb7\x67\xb7\x31\xa8\
\x3a\x1e\x7d\x8b\x38\xf2\x68\x2f\x26\xbc\xb1\xad\xb9\x16\x05\x48\
\x38\x9d\x48\x2c\x22\x7a\x37\x8a\xc0\x22\x74\x36\x68\x0c\x71\xe3\
\x26\x22\xa2\xa7\x51\x81\x22\x35\xbf\x0f\x45\x9b\x8d\x3c\x24\x22\
\xe2\xc0\x90\xa0\x00\x64\x23\x39\xf4\xf5\x93\xa0\xbb\xb7\x4f\x40\
\x11\xd8\xeb\xed\xf9\x30\x14\x04\xee\x15\x74\x0f\x6f\x77\xca\xa9\
\x46\xd7\x13\xbd\x8c\x82\xb5\x1d\x8b\x6b\x7b\x11\x0a\x10\xb7\xfe\
\x18\xad\x7f\xbf\x43\x65\x55\x45\x2e\x19\x51\x57\xc9\x90\x9a\x8a\
\x68\xea\x88\x38\xe2\x68\x2f\x26\xd4\x54\xe6\xdc\xf9\x90\xd5\x44\
\x42\x11\xd1\xbb\x91\x00\x53\x90\x5b\xd4\x52\xe2\x7c\x8d\x88\xe8\
\x69\x54\xa1\x2b\x80\x56\xa0\xa8\xaf\x71\x4d\x46\x44\x1c\x38\x06\
\x23\xe5\xb5\x1c\xdc\x99\xdb\xae\x36\x7f\x8b\xc0\x99\xc0\xcd\xe8\
\xec\xec\xaf\xec\xf9\xc9\xc0\x67\x81\x7f\x44\xe7\xed\x2b\x29\x3d\
\xcb\xeb\xce\xfa\x86\x67\x71\xab\x51\x90\xb8\xb5\x88\xe7\x86\x70\
\x56\xe2\xf0\x1d\x57\xb7\xb0\x9e\xc5\x54\x39\x9d\xbd\xef\xae\xf6\
\x4a\xe7\x99\xa4\xbe\x87\x41\xde\xc2\xf7\xb2\x9e\x8d\x46\x67\x9f\
\xc3\xdf\xba\x2a\x3f\xa2\x07\x51\x39\x66\x50\x65\xdb\x4d\x27\x8f\
\x60\xec\xe0\xaa\xe8\x1a\x1d\x71\xc4\xd1\xd2\x5e\xe4\xb9\x0d\x0d\
\x4d\xaf\x6c\x6a\xbc\x13\xed\xfa\x45\x44\xf4\x76\x4c\x40\x02\xf7\
\xf7\x7a\xba\x22\x11\x11\x11\x54\xa2\x7b\x44\xef\x44\xd6\xa6\x88\
\x88\x88\x03\xc7\x30\x74\x85\x55\xb9\x40\x57\x43\x50\x80\xa8\x6d\
\x74\x0c\x2e\x95\x46\x3b\xba\xe3\x77\x0e\xba\xf6\x0a\x60\xb6\x3d\
\x03\x59\x79\xb7\x22\xe3\xc7\x30\x64\x35\x7d\x1a\x38\x0e\x5d\x8b\
\xd4\x04\x3c\x63\xff\x9d\xa2\x58\x8b\x3c\x3e\x26\xa1\x2b\x8e\x9e\
\x43\x67\xc6\x17\xa1\x6b\x92\x76\xa3\xc0\x55\xb5\xe8\x3e\xe1\xa7\
\xed\xbd\x73\x80\x57\xd1\x75\x47\x63\xf1\xf7\x0b\x3f\x81\xdc\xae\
\x17\x23\x1a\x32\x06\x45\x9d\x7f\x0d\x59\xb4\x87\xa1\xcd\x81\xa7\
\xac\xdd\x4b\xd0\x35\x5e\xcf\x59\xf9\xe3\x90\x17\x63\x9d\xbd\xf7\
\xba\xe5\x7f\x3a\xb2\xae\xbf\x8a\xae\x8c\xda\x86\xae\x8d\xaa\xb6\
\x3c\xa6\xda\x33\x57\xff\xd3\xad\x9e\x13\x91\x5c\xf1\x22\x3d\x17\
\x8f\x20\x02\xa8\x4c\x12\x68\x4f\x64\xa9\x8b\x8a\x70\xc4\x91\x46\
\x7b\x11\x92\x24\x71\xa1\xed\x23\x22\x8e\x05\xe4\x89\xf3\x35\x22\
\xa2\xb7\xa0\x92\xb8\x26\x23\x22\x0e\x15\xce\x42\x9b\x46\x82\x14\
\xc1\xdf\x47\x56\xdd\xaf\xa0\xbb\x7f\x3b\xb3\x5c\xe6\x91\x62\x38\
\x0a\x29\x9e\x15\x48\x41\x5d\x89\xf7\xaa\x5a\x00\xfc\x2b\xba\xd3\
\x77\x3e\x72\x1f\xbe\x1e\x78\xd2\xde\xf9\x38\xf0\x1d\xbc\x62\x7e\
\x2d\x30\x03\x29\xc8\xa7\xa3\x7b\x7d\x97\xa2\x3b\x86\x7f\x6e\x75\
\xab\x46\xca\xe4\x25\xc0\xf3\x48\x21\xbf\x04\x5d\x6d\x74\x0a\xba\
\x1b\xf8\x27\x96\x76\x32\x70\x0f\xf0\x61\x74\x87\xf0\xbb\xc0\x47\
\x81\x6f\x20\x45\x7d\x2a\xf0\x53\xa4\x78\xbf\xcf\xca\xad\x05\x3e\
\x01\x7c\x1d\xb8\x05\xdd\x77\xbd\xcd\x7e\xdf\x65\xf5\xdf\x8b\xa2\
\xcb\xbf\x1f\x5d\xb7\xb6\x18\x29\xc4\xf3\xed\xf3\xe3\x56\x97\xe3\
\x51\x80\xb0\x9b\x90\x22\xbd\x12\xdd\x75\xdc\x88\xee\xd0\x8e\x96\
\xe1\x1e\x42\xec\xf8\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x08\
\xd0\xf1\x83\x71\xc8\x6a\x3a\xbc\x1b\xe9\x73\x48\xb1\xdd\x8e\xac\
\xb3\xb3\x81\xcd\x48\x49\xcc\x01\xcf\x22\xeb\xef\x38\xa4\x10\x3f\
\x87\x94\xc3\x41\x40\x0d\xb2\x88\xce\xb6\x34\x45\x64\x8d\x5e\x84\
\xbc\x3e\x7e\x8e\x14\xc8\x79\xf6\x7c\x10\xba\xe7\xfb\x35\xbc\x57\
\x61\x68\xb1\x76\x16\x65\x77\x05\xd9\x03\xc0\x0f\x90\xa2\x3b\x0a\
\xb9\x6f\xdf\x05\xdc\x8d\x94\xf7\x45\x56\xfe\x0b\xc8\xad\x7b\x06\
\x3a\x3b\xed\x6e\xd5\x99\x8a\x94\xd8\x76\x2b\x37\x07\x3c\x64\x6d\
\x4b\xec\xf7\x3c\xfe\xce\xef\xc4\xda\x74\x06\xf0\x33\xab\xff\xf7\
\x91\x15\x7b\x34\x3a\x43\xfd\x33\xfb\x7b\xd7\xda\x1c\xcd\x90\x3d\
\x88\xa8\x08\x47\x44\x44\x44\x44\x44\x44\x44\x44\x44\x44\xe4\x80\
\x3d\xc0\x5f\x03\x5f\x00\x1e\xa5\x7b\xe7\xf0\xdb\x91\x72\xba\x18\
\x38\x09\x29\x99\xee\x7a\xa4\x0d\x48\x51\x7e\x0f\x72\x3f\x7e\x03\
\x29\x8b\x7b\x80\x06\xa4\x1c\xfe\x18\x7f\x6f\x77\x85\xfd\x6f\x41\
\x7a\x4a\x8b\x7d\x5f\x07\xfc\xbb\x95\x75\x19\xb2\x1a\x57\x59\xf9\
\x2e\x42\xb5\xfb\x9e\xe0\xaf\x20\x6b\xb5\x67\x95\x40\x73\xf0\xbd\
\x29\x48\xbf\xdf\xde\xaf\xb1\xcf\xfb\x91\xb2\x7b\x27\x3a\xb3\xfc\
\x23\xa4\xd0\xcf\x42\x96\xe4\xe9\xf6\xec\x19\x7b\xf6\x11\xa4\x30\
\x17\xad\xfe\x95\x96\xbf\xab\x3f\x56\x56\x83\xd5\xa1\x82\x78\x15\
\x53\xaf\x40\x54\x84\x23\x7a\x1b\xce\x44\x6e\x27\x8e\x38\x54\x01\
\x57\xa1\x73\x9a\xe5\x50\x8b\x5c\x67\xba\x83\x13\x90\xbb\xcc\xd1\
\x40\x0e\xb8\x12\x11\xcc\xf0\xd9\xf9\x68\x67\x31\xc4\x54\xe0\x72\
\x0e\xcc\xdd\xef\x14\xe4\x66\xd4\x19\xa6\x5a\xba\x4a\xe0\x6a\xe0\
\xd3\x74\x6f\x87\xd7\xd5\x75\x36\x3a\x3b\x13\x62\x36\x70\x5a\xea\
\xd9\x3c\x74\x36\xe7\x40\x50\x85\xce\x14\xd5\x1c\xc4\xfb\x23\x2d\
\x7d\x4f\xbb\x47\x9e\x84\xc6\x38\xa4\xa5\xb5\x68\xce\x0e\xcd\xe8\
\xa3\x25\x87\xa1\xcc\xc9\x68\xae\x44\x44\x44\x1c\x3c\xea\x90\x9b\
\xe2\xa4\xd4\xf3\xf3\x81\x53\x0f\x20\x9f\x5a\x44\xc7\xaa\x52\xcf\
\x47\x23\x61\xbd\xea\x00\xf2\x3a\x83\xee\xf3\xb2\x10\x63\x90\x25\
\xeb\x40\x30\x05\xb8\x90\xa3\x27\x88\x9f\x8f\xac\x5f\x27\xa0\xb3\
\xa9\x9d\xe1\x44\xe4\xce\x3a\x05\xf8\x2d\x24\x13\x5c\x89\x94\xa8\
\xf7\x22\x57\xda\x72\x18\x6e\x69\x87\x22\xd7\xd5\x51\x68\x1c\xa6\
\x95\x49\x9f\x43\x0a\xcc\x70\x74\xe6\xf3\xea\x43\xec\x93\x1c\x92\
\x63\xc6\x1c\x8d\x4e\x3d\x82\x78\x07\xb9\x44\x37\x74\xa3\x3f\xf2\
\x48\xc6\x78\x03\x29\x85\x63\xed\x7d\x77\x8c\xa1\x15\x9d\x85\xbd\
\x02\xb9\x32\xef\x44\xc1\xee\xaa\x91\x55\x74\x17\x3e\x70\x57\x05\
\x52\x40\xd7\x03\x17\x23\xf9\xe9\x52\x74\xc6\x78\x1c\x5a\x9b\x8f\
\xa3\xb3\xbc\xe3\x2d\xed\x70\x60\xae\xfd\x36\x11\x1f\x3c\xeb\x4c\
\x34\x97\x2e\xb6\x32\xb7\xa3\x39\x75\x16\x9a\x5f\x27\x23\x85\xdd\
\x05\xad\xca\xe1\x23\x5c\x6f\xb3\xbf\x13\x11\xad\xb8\x0a\x59\x7c\
\xef\x46\x0a\xee\x78\x6b\xcf\x7e\xe0\x5e\xa4\x74\x8f\xb0\x7c\x9a\
\x80\xb7\x80\x8b\xd0\xba\xbc\x14\x9d\x69\xde\x81\x57\xf2\xa1\xf7\
\x5e\x13\xd5\xaf\x10\x15\xe1\x88\xde\x86\xf3\x80\x7f\xc1\x0b\x03\
\x55\xe8\x1c\xc5\xff\xcf\xde\x79\x87\x59\x75\x9d\xe7\xfe\xb7\xcf\
\x39\xd3\x07\x86\x3e\x74\x09\x84\x04\x08\x90\x84\x24\x8a\x10\x02\
\x15\xd4\x9b\x25\x59\xb2\x65\x5b\xee\x35\x71\x49\xe2\xb8\xc4\x8e\
\x73\x73\x93\x9b\xdc\x24\xd7\xb9\x71\x7c\x93\xb8\x3b\xb6\xdc\x9b\
\x6c\x59\x56\xb1\x7a\xef\x80\x0a\xbd\xf7\xde\x61\x80\x29\xe7\xec\
\xfb\xc7\xfb\x2d\xed\x35\x7b\xce\x34\x66\x80\x01\xd6\xfb\x3c\xe7\
\x99\x33\xfb\xec\xbd\xda\x5e\xeb\xeb\xeb\x5b\x23\x5b\xb9\xbf\x2f\
\xb2\x32\x7e\x04\x29\x46\x55\xed\x94\x3f\x09\xed\x21\x39\x56\xb8\
\x03\x1d\xbd\xe3\xe3\x6a\x5a\x0a\x2d\x63\xd0\xde\x97\x5c\x47\x0a\
\x35\x4c\xa7\xa5\x42\xea\xa3\x0c\xed\x87\xc9\x21\x85\xf8\xfd\xc8\
\x32\x7b\xb8\x83\xe5\x97\x03\x9f\x47\x8c\xc5\xc7\xb9\xb4\x34\x26\
\xf4\x43\x8c\xa1\x33\x18\x0a\xfc\xb9\xd5\xd3\x0f\x31\xb9\x8e\xe2\
\x30\x7a\x8f\xe7\x76\xb2\xce\xee\xc6\x05\xc0\xed\x34\x67\x66\x39\
\x24\xf0\x95\xa6\xee\x3d\x17\x31\xe0\xae\xa2\x8a\xd6\xd7\x43\x40\
\x40\x40\xc7\xd0\x84\x94\xb3\xeb\xbd\x6b\xbd\x80\x8f\xda\xdf\x8e\
\x62\x3c\xf0\x27\xb4\x34\xca\x95\xa3\x75\xda\x19\x39\xeb\x52\xc4\
\x03\x3b\x8b\xdb\x91\x82\xd8\x19\x8c\x42\x06\xb5\x63\x15\x96\x79\
\x15\xe2\x85\x7d\x68\xdb\xb0\x1d\x59\x5f\x6a\x81\x77\x93\x64\xed\
\x1f\x89\x14\x92\x5b\x68\x5b\x11\x2e\x41\xf4\xb7\x17\xf2\xdc\xd5\
\x22\x45\xfa\xcc\x56\xee\x2f\x43\x7c\x68\x04\x7a\x67\xa7\xd1\x35\
\xe5\xe4\x6c\x1b\xd7\x8e\xf2\xd9\x9e\x0a\xb7\x0f\xbf\xbd\xb1\x88\
\x80\x95\xc8\x5b\xbb\x13\x25\xad\x7a\x0e\x29\x86\xab\x50\x28\x72\
\x06\x29\xc9\xfb\x90\x42\x1c\xd9\x3d\x4f\x23\x05\x73\x16\x0a\x4d\
\xde\x8e\x14\xd3\x7d\x28\x9c\xb9\x11\xc9\x7f\x31\x4a\x56\xb9\x04\
\x29\xe6\xef\x40\xef\xe9\xc7\x56\xc7\x03\x68\x7e\x8d\x44\xe1\xcd\
\x07\x91\xb7\xf5\x20\x32\x82\xf4\xb1\xe7\xeb\x91\xf7\x79\x24\x7a\
\x47\x8f\xa3\x84\x7b\xab\x51\x28\x77\xd6\xfe\x77\xe5\xcd\x41\xfb\
\x77\xd7\xa1\x30\xec\x29\x48\x4e\x7b\x11\x19\x09\x5e\xb3\x6b\xb7\
\xa0\x70\xef\x57\xec\xde\x9d\xc8\x93\xbc\x0b\xad\xcd\x5e\xc0\x0f\
\xad\x5f\x4b\x49\x3c\xdc\x2b\xad\xde\xa0\x0c\x1f\x47\x74\x46\xe8\
\x0e\x08\x38\x16\x68\x40\x84\xf3\x93\x88\x60\x1c\x42\x04\xcd\x65\
\x11\xbc\x14\x59\x0e\x0f\xa1\xbd\x17\x3b\x69\x1e\x5e\xe3\x67\xdf\
\x8b\x10\x91\x9a\x6e\xbf\xdd\x8f\x84\x9f\x81\x28\xf1\x41\x1f\xb4\
\xd7\x63\x15\x62\x96\x73\x90\x15\x77\x3d\xf0\x20\x62\xb6\x53\x10\
\x63\x1d\x04\x3c\x6a\x6d\xba\x9c\x44\xc8\xd9\x86\x88\xe6\x41\xa4\
\x64\xcf\x42\x0c\xf0\x11\x44\x10\xfd\x54\xf9\x0e\x05\xb4\x4f\xe6\
\x2c\x14\x0a\xf4\x80\x5d\x73\x9f\x11\x88\x08\x57\x22\x82\xfb\x2a\
\x62\x24\xb3\x90\x05\x73\x8b\xb5\xaf\x60\xfd\x2d\x41\xe7\x32\x2f\
\x45\xa1\x49\x0e\x17\xa0\x3d\x35\x8b\xd1\x31\x06\xfd\xad\xdd\x15\
\x88\x39\x9c\x86\xac\x94\x0f\x20\x4b\xe5\x34\xeb\xef\x41\xbb\x36\
\x1c\x79\x93\x6f\xb6\xbe\xec\xf7\xda\xef\xc2\x7f\xae\x47\x19\x15\
\x77\x5a\x5b\x6a\x91\x57\xa3\x04\x29\xc6\x4f\x23\x66\x51\x89\x14\
\xd7\x51\xd6\xce\x27\xec\xbd\x5c\x68\x65\x2c\xf2\xde\xdd\xd9\xf6\
\x9e\x9b\xec\x1d\x6f\xb6\x31\x1f\x67\x73\xc3\xed\xcf\x79\x01\x59\
\xfc\xdf\x40\xc6\x85\x2d\xc0\xdc\xee\x9e\x90\xed\x20\x7d\x44\x02\
\xd6\xee\x35\x88\xd9\xf5\x41\xde\x89\x2a\x64\x50\xd8\x81\xe6\xa5\
\x53\x8a\x1b\x10\xe3\x5e\x85\xf6\x3e\x5d\x6d\xe3\xbe\xd8\xc6\xa8\
\x0f\xb2\x2a\x0f\xb1\xbe\xbb\x7d\x48\x6b\xec\xdd\x5e\x66\xe5\x8d\
\xb4\x71\x76\x49\x4d\xdc\x5c\xd9\x00\x3c\x6c\xe3\x15\x10\x70\x2a\
\xa0\x0a\xd1\xf8\xcd\x24\x21\x89\xc5\xd0\x88\xf6\xe9\xbd\x03\xb8\
\x1b\xf1\x94\x73\xd1\x9a\x7e\x19\xd1\xbe\x8b\xd1\x7a\xfb\x23\xa2\
\xf5\x57\xa3\xf5\x36\x0a\xf1\x89\x47\x91\x01\x76\x2a\xa2\x51\xfb\
\xd1\x5a\xed\x85\x68\xd1\x1a\x12\xba\x78\x0d\xf2\x52\xbe\x80\x8e\
\x0f\xbc\xdc\x9e\xdf\x6f\x65\x6c\x44\xb4\x03\x44\x5b\xa7\x20\x1a\
\x9e\x41\x74\x74\x11\xe2\x0b\x55\x88\x8e\xff\x0e\xad\xeb\x7e\x28\
\xd9\x4f\x05\x5a\xeb\x75\x88\x66\xf4\x47\x74\xe5\x61\xeb\xdb\x39\
\x56\xcf\x61\xeb\x4f\x1e\xd1\x90\x77\x20\xfe\xf6\x38\x52\x44\x66\
\xd9\xb8\x1c\x46\xb4\xbc\x11\xd1\xa3\x6b\x11\x6d\x7a\x13\x79\xe4\
\xfa\x21\x9e\x59\x8b\xe8\xcc\x03\xd6\xf7\xf3\x10\xdd\x9a\x87\xf8\
\xc2\x75\xd6\xa6\x81\x36\xb6\xbb\xed\xfe\x2c\xe2\x39\x93\x6d\x4c\
\x9f\x46\xb4\xbc\xda\xca\x5c\x84\xe8\xdb\x12\xc4\x93\x56\x93\x84\
\x92\x5e\x66\xed\x71\x74\x72\x22\x52\x74\xfb\x22\x45\x6a\x95\xdd\
\xeb\x64\x07\x3f\x13\xf1\x65\x88\xf7\x1e\x44\xbc\x64\xa0\xb5\x63\
\x33\x0a\x75\x5d\x45\x4b\x3e\xfc\x82\xbd\xcf\xf3\x6c\x0c\x06\x20\
\xf9\xf9\x7e\x44\x97\x1d\x32\x48\x29\x7a\xd5\xde\x4d\x6f\x9b\x33\
\xc3\xac\x6f\xcf\xd8\x78\x3a\x94\x91\x78\x0d\xdd\x71\x92\x0f\x93\
\x84\xee\x9e\x08\x70\xfb\x63\xb1\xf6\xbb\xd3\x15\x72\x48\x4e\x89\
\xed\xbd\x5c\x80\x12\x44\xad\x46\xef\xbe\xc9\xc6\xff\x51\xbb\xbf\
\xc9\xca\xfa\x01\xc9\xf1\x45\x3f\xb0\x72\xdc\x7b\x04\x29\xc8\x39\
\x12\xf9\x27\x63\xe5\x3c\x42\xc2\x8b\x9d\x7c\x32\x0f\x25\xc8\x8a\
\xec\xde\x61\x68\xbd\xfd\x1c\xc9\x8d\xee\xf9\xfb\xbd\xbe\xe4\xd1\
\x9c\x7a\x26\xd5\xae\xf9\x24\x49\xad\xdc\x3a\x2d\x76\xed\x51\xaf\
\x0d\x3f\x4e\xb5\x3f\x42\x21\xe0\xb1\xb5\xef\x3e\xaf\xde\x80\xe3\
\x84\x30\xf8\x01\x3d\x0d\x11\xb2\xa4\xed\x06\x3e\x44\x62\x29\x2b\
\x20\xc1\xe1\x3a\x44\x4c\x47\xa2\xfd\x2b\x87\x91\x05\xf2\xbf\x10\
\x83\xf6\xad\xb0\x17\x01\x9f\x41\x21\x35\x23\xd0\x1e\x8e\x2c\x52\
\xbe\x62\x24\x94\xfc\x15\x12\x5a\x3e\x8c\x88\xe4\x32\x94\xfd\xef\
\x46\xa4\x28\x7e\x09\x09\x18\x59\xe0\x2b\x48\xb8\x78\x37\xb2\x30\
\x6f\x42\x8a\xd8\xf5\x28\x2c\xe7\xf3\x88\xf1\xe7\xac\x5c\xc7\xf8\
\xd3\xa8\xb4\xb6\x6d\xb5\xfe\xbc\xd7\xae\xc7\x48\x20\xf9\x3b\xc4\
\x38\x76\x5a\x99\xd3\x10\x33\xfd\x00\x12\x20\xce\xb3\x7a\x5d\x52\
\x86\x8f\x21\x41\x68\x7b\xaa\x9e\xcb\x6c\xac\x0e\x5b\x5d\xbb\x10\
\xb3\xbf\x0d\x09\x6e\xcb\x90\xb0\xf5\x11\x24\xd8\x7d\xda\x7e\x1f\
\x8c\xbc\xc7\x07\x10\xd3\xd8\x44\x42\xe4\x1d\xb2\xc0\x7b\x90\x30\
\xb2\x05\x09\x90\x97\xda\xb3\x7f\x85\x84\xa4\x46\xe0\xcb\x48\xa8\
\x71\x1e\xfb\x15\xd6\x97\x77\x5a\x7b\xf6\x5b\x9f\xce\x41\x9e\x90\
\x51\x36\xe6\x07\xad\x6f\x1f\xf5\xee\x5f\x81\x42\x9d\x5c\x58\xf0\
\x02\xe4\xe9\xae\xb5\xbf\x03\xbb\x3a\xf9\xba\x09\xce\x6b\x31\x00\
\xf8\x33\x64\x20\xd9\x6d\x6d\xcf\x58\x5f\xff\xda\xfa\x5e\x0e\xfc\
\x3d\x12\xae\x3e\x8e\x04\xef\xf5\xc8\xea\x3c\xd3\xde\xc3\x68\x64\
\x3c\xb8\x09\xcd\xbb\x11\xc8\x38\xd1\x1b\xad\x81\xf1\x48\xc1\xfe\
\x4b\x64\x24\x7a\x1b\x12\x6e\x57\x59\xdd\x9f\x24\x18\x3d\x03\x4e\
\x0d\x38\xda\xfb\x04\xcd\xf9\x47\x6b\x78\x01\xd1\x99\x71\xf6\xff\
\x15\x48\xc9\x3b\x13\x79\x09\x37\x23\xc5\xec\x4b\x68\x3d\x7f\x00\
\xd1\xa3\x8d\x88\xfe\x5d\x8a\xe8\xee\x3e\x44\x63\x6f\x40\x51\x38\
\x9b\x11\x0d\xbf\xd1\xfe\x7e\x09\x79\x41\xb7\x23\x5a\x38\x19\x9d\
\xbb\xda\xc7\xea\xbd\x12\xad\x5d\x67\x64\x1c\x8b\xb2\xd5\x6e\xb0\
\xff\xff\x06\xf1\x06\x47\x47\x37\x93\xd0\xe4\x7a\x44\x5f\xb6\xd9\
\xf7\x8f\x5b\xb9\x2b\x11\xfd\xb8\xdc\xca\xfb\x22\x89\x72\xf6\x31\
\xeb\xf7\xb9\x24\xde\xef\x2f\xd9\x73\x77\x20\x9a\x52\x82\x3c\xaa\
\xfd\x90\xc7\x7b\x1a\x32\x88\xbe\x1d\xd1\xb2\x0f\x22\x5a\xb4\x0c\
\xd1\xab\x9b\x91\x11\xf3\xf3\x24\x7b\x2f\xff\x86\x84\x7f\x9e\x6f\
\x7d\x39\xdb\xc6\x79\x3c\x09\x4f\x8b\x10\xaf\xa8\x41\x7c\xf7\x20\
\xe2\x5d\x3b\x11\xff\x29\xb1\x3a\x4a\x11\x9d\x3f\xc7\xc6\xfb\xa3\
\xd6\xbf\x69\x88\x7f\xed\xb4\x7e\xdd\x62\x7f\x7d\x14\x6c\x9c\xaf\
\xb1\xb2\x47\x23\xfa\x7c\xc8\xc6\x65\x23\xe2\xef\xb7\xda\x58\xff\
\x4f\x1b\x8f\x1d\x36\x76\xd3\xbc\x7a\xf6\xa1\x28\xae\xcf\xd0\x9c\
\xb6\x0e\xb0\x7e\xbd\x61\xd7\x3f\x63\x63\xbc\x12\x79\x06\x6f\x4e\
\xb5\xe9\x56\xbb\xbe\xd9\xda\xfc\x09\x3a\x17\x4a\xdf\x53\x90\x3e\
\xb3\xd7\xbf\x5e\x40\xf2\xda\x24\x64\x60\xf1\x8d\x53\xee\x0c\x5f\
\xb7\xbf\x17\x9a\x9f\xb1\xeb\x14\x58\xff\x7f\x77\xcd\x3f\x3b\xd8\
\x9d\xcf\x8b\xf7\xff\x06\x24\x9b\xf8\xe7\x01\x1f\x46\xf3\xb5\xb1\
\x48\x9d\xe9\x33\x87\xd3\xed\x72\x67\x09\xe7\x53\x6d\x49\x5f\x73\
\x65\x15\x6b\x3f\xa9\x7a\x5a\x1b\xb7\x80\x63\x88\x20\x1c\x05\xf4\
\x34\x44\xc8\x7a\xfc\xef\xc0\xd7\x91\x97\xcb\x11\x99\x79\x88\x29\
\x95\x23\xe6\x35\x09\x31\xd9\xfd\xc8\x6a\x9c\xc6\xb5\x28\xfc\xe6\
\x17\x88\x81\x3a\xcb\xf9\x0b\xc8\xaa\x78\x1a\xf0\x7f\x90\x20\xf0\
\x6b\xc4\x84\xfb\x20\xe2\x77\x06\x62\x4e\xaf\x23\xab\x64\x1f\xc4\
\x70\x07\x20\x05\xf1\x77\xc8\x93\x37\x0c\x31\xf6\xc1\x56\x7e\x39\
\x22\x6c\xe7\xd8\xf5\x62\xe7\xef\x35\x22\x4b\xe1\x6f\xad\x8e\x8f\
\x92\x08\x36\xe7\x21\xa1\xe1\xff\x21\x86\xd1\x0f\x29\x40\x35\x56\
\xe7\x3d\xc8\xca\xda\x0b\x29\x3c\xef\xb1\x3a\xde\x83\x88\xbe\x43\
\x0e\x09\x29\xf3\xac\xbe\x37\x6c\xbc\x5e\x41\x82\x45\x2d\xf2\x2c\
\xd4\x23\x81\x20\x8b\x14\xf4\x73\x91\x95\x73\x05\x52\xc8\x36\xdb\
\x33\x87\xbc\xb2\x0b\x56\x77\x29\x12\x86\x36\x7a\xd7\x23\x64\xc9\
\xff\xa1\x95\x39\x07\x09\x99\xd7\x58\x39\xfd\xad\x9f\xd7\x22\x05\
\x70\x83\xd5\x37\xcc\xde\xf3\x6c\x2b\xef\x07\x88\x01\xd5\xda\x38\
\x0e\xb4\x72\x1e\x43\x0a\x30\x48\x91\x76\xd9\x2d\xff\xab\xab\x13\
\xaf\x9b\x91\x47\xc2\xd4\xd9\xc0\x17\x90\x15\xbc\x9f\xb5\x77\x8e\
\xf5\xf9\x6e\xeb\xe3\x44\x64\x4c\x99\x86\x84\xc1\x65\xc0\x93\x56\
\xce\x06\x7b\xae\xb7\xbd\xc7\x31\x48\x88\x73\x6b\x62\xbd\x8d\x95\
\xf3\x9a\x8f\x45\xc2\x78\x1d\x12\xc0\xeb\x91\xf0\xf7\x5d\x24\x28\
\x07\x04\x9c\xcc\xc8\x20\x5a\x32\x94\xb6\xc3\x6f\x1d\x76\x22\xba\
\x74\x29\x5a\x4b\x67\x21\xda\x7c\x27\x52\x80\xab\x48\x22\x78\xce\
\x44\x91\x45\x3f\x45\x91\x3a\x67\xa0\xf5\xf8\x3c\x0a\x0b\x7d\x13\
\x29\x91\x8f\x22\x0f\xd9\xd9\x88\xd6\xb9\x6c\xb1\x5f\x41\x0a\xd4\
\x13\x88\x9e\xfb\xd1\x42\x79\x12\x5e\xe1\xd6\xf5\xb7\x48\xf8\xd6\
\x10\x44\x3b\xeb\x90\x87\xeb\x51\xaf\x0f\x75\xc8\xf3\xdc\x84\x14\
\xd5\x9f\x22\xfe\xd0\x9f\xc4\x7b\x3d\x12\xd1\x95\x1f\x21\xba\x5c\
\x6b\xed\x72\xfc\xad\x17\x32\xc2\x15\xac\x6f\x97\x22\x7a\x93\xb5\
\xb2\xff\x04\x19\x06\x56\x23\xda\x14\x23\x7e\xd3\xc7\x3e\x79\xc4\
\x47\x16\x20\xfa\xff\x13\xa4\x2c\x97\x20\xda\x7c\xd8\xc6\xd0\x29\
\x0a\x58\x5b\xbf\x4d\x12\x71\x55\x8b\x68\xd6\x44\xa4\x38\xae\x42\
\xb4\xee\x65\x12\x83\x40\x84\x94\xfe\xef\x20\x9e\x56\x81\x0c\xbe\
\xeb\xec\x3d\xde\x83\x8c\xa2\xad\xcd\x8d\x57\x10\x1d\x2c\x43\x3c\
\x6d\xac\xcd\x81\xf5\xc8\xe3\x5b\xb0\x71\x9c\x6c\xf7\x7c\xdd\xc6\
\xa1\x3f\xf2\x0e\x6f\x43\x3c\xe8\x37\x36\x2e\x6e\x6b\xcf\x01\xab\
\x63\x90\xf5\x67\x87\xf5\xe7\x6a\xe4\x6d\xec\x67\xfd\xbe\x1a\xf1\
\xf1\x26\x2b\xff\x32\x9b\x6f\x8f\x59\x1b\x3e\xcd\xc9\x17\x26\xeb\
\xc2\xa2\x17\x91\xbc\xc3\xa3\x8d\x08\x45\x47\xb9\xfa\xdd\xb5\x3d\
\xe8\xdd\x39\x45\x35\x20\x20\x28\xc2\x01\x3d\x12\x59\xc4\x00\x7f\
\x8a\x18\x83\xc3\x65\xc8\x1b\xf8\x26\xc9\x7e\xac\xb6\x88\x99\x53\
\x98\x41\xc4\x70\x80\x3d\xb7\xdb\x7b\xb6\x80\x14\xc0\xbb\x10\xb3\
\x5b\x80\x18\x5f\x06\x11\xcb\x9d\xa9\x7b\x9d\x55\xd1\x85\x9a\x3a\
\xc2\x5e\x8a\x14\x33\x77\xfd\xbf\x10\x33\x2f\xd6\x3e\xb7\x77\x05\
\x12\xeb\xa8\xbb\xaf\x0c\x85\x45\x39\x6b\x7f\x1d\x62\xf6\x8e\x71\
\xbb\xf1\x19\x80\x18\xee\x52\x6b\xef\x55\x48\x70\x8a\x53\xe5\x39\
\x6b\xa4\x4b\xca\x50\x8a\xac\xd2\x93\x91\x10\xe4\xac\xaa\x1b\x91\
\x27\xfa\x22\xa4\xe4\x1e\xb6\xff\xdd\xb3\xe9\xf7\xb3\x01\x31\xfb\
\x6b\xec\x7d\xf8\xf5\xee\x22\x09\xd9\x2e\x20\x3a\x13\x23\x6f\xc8\
\x7e\x24\xd8\xb8\x30\xa6\x88\x96\x89\xa6\x7c\xaf\xfe\x00\x24\xf0\
\xfc\x33\x0a\xa5\xfe\x00\x52\x22\xff\x91\x44\x90\x2c\xe1\xf8\x5a\
\x55\x9d\x45\xd8\xff\x3f\xf6\xfa\xed\x67\xa8\xcc\x59\x1f\xdd\xfb\
\x2f\x58\x7f\xab\x49\xe6\x96\x1b\x87\x7e\x48\xb0\x1e\x84\xe6\xa5\
\x0b\xd1\xf2\xb1\x97\x24\xb3\xa6\x0b\x07\xcb\x20\x81\x6d\x3f\x12\
\x7e\x97\x90\x08\x6a\x01\x01\x27\x33\x1a\x80\xff\x81\xce\x0e\x7d\
\x85\x8e\xd1\x85\x47\x80\x4f\x21\xde\xb2\x09\x29\x38\x15\x88\xf6\
\xef\x47\x6b\xe7\xbf\x90\xa2\xd2\x40\xb2\x45\xc4\x85\x55\x3a\xda\
\xea\x94\x3c\xc7\x03\x1c\x0d\x2e\x45\x6b\xd7\x85\xc4\x56\xdb\x07\
\xaf\x7d\x15\x34\x8f\x7e\x9a\x48\xb2\x3d\x68\xb7\x3d\x9f\x45\x6b\
\xbd\xae\x48\x1f\x1c\x5d\x70\x7b\x9c\xb3\x48\xf1\x68\xb4\x72\x7d\
\x5e\x08\xe2\x75\x65\x48\x31\x70\x7c\xcd\x29\x07\x8f\x22\x05\xaf\
\x0a\x19\x52\xf7\x5b\x79\x8e\x36\x55\x20\x85\xf5\x9d\x88\x3e\xbf\
\x49\xc2\x33\xb1\x32\xdd\x7d\x4d\x24\xb4\xd1\xa7\xeb\x05\x64\x2c\
\xfe\x04\xa2\x4f\xfb\xed\xbe\x72\x64\xf0\xbc\xc7\xeb\x57\x96\xe6\
\x74\xaf\xc9\x2b\xeb\x90\xfd\xee\x42\xae\xdd\x33\xad\xbd\xf7\x2b\
\x90\x32\xfa\xa6\x57\xa6\xff\xfe\x7c\x3e\x5c\x4f\xc2\x87\x0f\x90\
\xe4\xc0\xd8\x95\x7a\x77\xc5\xde\x43\x31\xbe\xf7\x34\xf2\x62\xfb\
\x3c\xb9\xcc\xeb\x4b\x1d\xcd\xc3\xa6\x4f\x24\x38\x23\x4e\x6b\x51\
\xa6\x69\xb9\xa4\xbb\xe0\x78\xad\xe3\x7f\xee\x6f\xd4\xce\x33\x47\
\x7b\x2c\xfc\xb9\x74\x2c\xe0\xea\x4c\x6f\xd5\xf2\x93\x80\x1d\x8f\
\xfe\x1d\x8d\xb1\xf0\xdf\x79\xb7\x20\x84\x46\x07\xf4\x34\x38\xc1\
\x02\x64\xb9\xdb\x8c\xc2\x77\x23\xa4\x08\x2d\x26\xd9\xf3\x51\xdd\
\x4e\x59\x2f\xa0\xfd\x4e\x93\xd0\x9e\xe0\xf7\x92\x64\x31\x84\x84\
\x48\xf4\x41\xfb\x57\xee\x43\x56\xc4\x3e\x24\x87\xcd\xfb\x6b\x24\
\x4b\x4b\xc2\xe2\xda\x3b\x1f\x29\x64\x6b\x90\xa5\xfc\x7c\x9a\x1f\
\x03\xe0\x10\x5b\xbb\xdf\x86\xc2\xa9\x6f\x22\xd9\x0b\x5d\x8a\xf6\
\x37\xf5\x45\x42\xd9\x64\xe4\xcd\x7b\x0a\x59\xe9\xaf\xb5\x67\x3e\
\x6a\xcf\xc7\x68\x1f\xcb\xbf\x22\x2f\xe0\x85\x5e\x3d\x4d\x88\x61\
\x3b\xe6\xed\xda\x52\x8a\x2c\xf5\xcf\xa3\x7d\x62\x15\x76\xed\x2c\
\x14\xa6\xf5\x14\x12\x22\x07\x91\x24\x7b\x1a\x49\x73\xa3\x99\x3b\
\x17\xf0\x9f\x50\x98\xde\x4c\x6f\x2c\xfc\xbf\xd8\x98\xec\x41\x42\
\x59\x05\x52\xbe\x07\x20\xab\x7d\x3d\x12\x7c\x86\x5a\xf9\x59\xb4\
\xb7\x6a\x3c\x0a\xdd\xbe\x01\x09\xa8\x57\xda\xbb\xff\x2d\xf2\xa6\
\x8c\xb0\x3a\x7a\x23\x42\xeb\x42\xcc\xdb\xcb\xa0\x7d\x34\x10\x21\
\x6f\xcf\x79\x68\x9e\x9d\x8d\x04\xc8\x1c\x49\xd6\xc9\x5b\x91\xd0\
\x77\x03\x12\x7c\x5e\xb0\x77\x30\xc5\xfa\x76\x1a\xf2\x08\xac\xb1\
\x7b\x27\xa0\x50\xbc\x4b\xad\x4f\x0f\xd8\x7b\xee\x63\xef\xc4\x9f\
\x57\x7e\x82\x1e\x27\x28\xcf\xb7\xb1\x71\x06\xa3\xb3\x69\xae\xa8\
\x07\x04\x9c\xcc\x58\x87\xd6\xcc\xf6\x0e\xde\xbf\x18\x19\xa6\x3e\
\x82\x94\xe2\x3c\xa2\x43\x15\x28\x32\x66\x27\xe2\x0f\xd0\x32\xe3\
\x6b\x06\x29\x2f\xbd\x50\x64\x8a\xaf\xb4\x45\x88\x0e\xac\x22\xc9\
\xa7\x70\x3e\x52\xd4\xfb\x20\xda\x75\x31\x49\xae\x04\x27\xdc\x45\
\x68\xdd\x37\x90\xec\x65\xec\x45\x71\x7e\xe2\xd0\x80\xe8\xd0\x69\
\x28\xaa\xe7\x37\xd6\x87\x3e\xd6\x86\x57\x10\x8d\xba\x00\xf1\x8e\
\x3f\x45\xb4\xc4\x6f\x6b\xd6\x3e\x4b\xac\xbc\xab\xd1\xbe\xe1\x9d\
\x88\x36\xdd\x46\x42\x9b\x66\x59\x1b\x8b\xf1\x4c\x47\x93\x96\x20\
\x5e\x77\x1d\xa2\x77\x33\x49\x84\xe2\x8c\xb5\xa7\x0e\x45\x6c\xed\
\x45\x5e\xf2\xe1\x88\x7e\xae\xf2\xc6\xd8\xf5\xd7\x95\x3b\xd8\xfa\
\x70\x0e\x52\x6c\xe7\xa5\x7e\xf7\xbf\xfb\x3c\xbb\x04\x19\x7a\x17\
\xa2\x2c\xbf\x19\x12\x8f\x7f\x64\x75\x97\x5a\x3f\x16\x58\x7b\xae\
\xb7\x76\x5e\x8d\x92\x21\xa5\xc3\x71\xd3\xef\x63\x97\x95\xd7\xc7\
\xe6\x9f\xcb\x8c\xfc\x3a\xe2\x5b\xc3\xec\xb7\xbb\x10\x2f\x98\x8f\
\xc2\xe7\xcf\xb6\xf1\x1d\x60\x75\x5c\x47\xf7\x9c\x30\x70\x2c\x50\
\x40\xfc\x7a\x32\xc7\xd6\x20\x1d\x23\xd9\xc4\x25\x49\x9d\x85\x9c\
\x1a\xb3\x91\x0c\x75\x3c\x8c\xe3\x11\x9a\x63\xb5\xc7\xb0\xfe\x18\
\xad\xcb\x21\x68\x4d\x7c\xd4\x3e\x1f\x46\xd1\x67\xd5\xdd\xd8\x96\
\x0c\x5a\xc7\x83\x3a\x50\x66\xc6\xc6\xa2\x23\xf7\x76\xa6\xaf\x03\
\x10\xdd\xec\x36\xfd\x35\x3b\xac\x77\xe9\x17\x6f\x99\xd0\xb7\xbc\
\xba\x34\xe8\xc4\x01\x47\x1f\xf9\x02\x3c\xb8\x6c\xef\xc1\x45\xdb\
\x0e\xff\x84\xe6\x49\x26\x1c\x06\x91\xa4\xd6\x6f\x44\x1e\xad\x6a\
\xa4\x00\x2d\x46\x42\xc3\x44\xe4\x91\xdc\x8e\x18\x7c\x6b\xd9\x19\
\x57\x21\x61\xe6\x7a\xfb\xfb\x5d\xc4\xe0\xf3\x48\x49\x70\xfb\x8d\
\x9e\x42\xca\x9a\x4b\x4a\xb4\x04\x29\xe0\xab\x10\x53\x7c\xcd\xfe\
\x0e\xb3\xfa\xaa\xac\x5d\xbb\xd0\xa2\xac\x43\xe1\x4f\x79\xab\x6b\
\xbc\x95\x39\x1f\x31\xbf\x45\x24\x61\xcb\x4e\x71\xca\x21\x46\xb7\
\xdb\xda\xe5\xac\xc3\x8f\xa2\x30\xbb\xab\x10\x63\x79\x0a\x09\x1b\
\x8b\x90\xc2\x78\x15\x52\x76\xbe\x67\xed\xdf\x87\x94\x52\xac\xae\
\xd7\x48\x88\x4e\x99\xd5\xf1\x84\xf5\xbf\x1c\x09\x47\x3b\x10\xd3\
\x18\x83\xbc\xd6\xdb\xac\x9e\xc1\x48\xd9\x1e\x86\xc2\xb5\x5e\x47\
\x8c\x7e\x32\xf2\xca\x3a\x2f\x66\x1f\x6b\xc3\x4b\x76\xed\x2c\x24\
\x28\x1d\xb4\xbf\x95\xf6\xac\x13\x2e\x5e\x42\xc2\xd2\x64\x92\xe3\
\x3a\x7e\x87\xbc\xd0\x03\x51\xe8\x9e\x7b\xfe\x71\xfb\x7b\x83\xb5\
\xe3\x07\xd6\xa7\xf3\xec\xfd\x64\xad\xef\x5b\xad\x6f\xa7\x21\xef\
\xc1\x2d\xf6\x5e\x5e\x3b\xe2\xc9\xd9\x3a\x66\xdb\xfc\x78\xbd\xc8\
\x6f\x35\xd6\xaf\xc9\x88\xe8\x9f\x67\xf3\x27\x67\x63\x3d\x17\xcd\
\xd9\x29\x36\x07\x5e\xb7\x3e\xe6\x6d\xac\x47\xa1\x30\xc2\x17\xd1\
\xfc\x9e\x82\x18\xfb\x9b\x28\x22\x62\xbf\x8d\xd9\x70\xb4\x26\xb6\
\xa2\x68\x89\x32\x7b\x27\xfd\xad\xcf\x0d\xf6\xfe\x17\xdb\x1c\x3a\
\x0d\x09\x6f\x7d\x91\xd0\xb7\x91\x80\x80\x93\x03\x39\xa4\x28\xbc\
\x4a\x71\x1e\xd2\x59\xb8\xfd\x86\x15\x24\x99\x65\x57\x23\x9a\x7c\
\x1d\x0a\x89\x7e\x0c\x29\x50\x83\x91\x92\xb4\x17\xd1\xae\x3d\x88\
\x27\x8c\x46\x11\x1c\xdb\x91\x22\xbe\x1a\xd1\xdb\x5e\x88\xf6\xad\
\x40\xf4\xeb\x02\x64\x80\x7c\x18\xd1\xfe\x39\x68\x0d\x2f\x24\x09\
\x1d\xdd\x8d\x68\xc4\x99\x88\x76\x1c\x40\x3c\x61\x01\x5a\xf7\x0b\
\x11\x0d\xf7\xb1\x1f\xd1\x8e\xb5\x88\x6f\x5d\x89\x78\xd3\x12\xc4\
\x2b\x9d\x82\x7f\x03\x12\xd2\xbf\x4b\xb2\xb5\xe4\x35\x44\x57\x87\
\x20\x7a\xb5\x07\xd1\xde\x32\x14\x4a\xdd\x68\x6d\x9b\x8e\x84\xe0\
\xd7\x91\x82\x7e\xc0\xfa\x34\x14\xd1\x9d\xcd\x24\x09\x22\xe7\x23\
\xde\xb4\x9e\xe4\x94\x84\xb5\x88\xce\xd5\x5b\x5b\x1e\x41\x0a\xe0\
\x54\xbb\xd7\xf1\xf4\x4d\x88\xb6\x45\xd6\xa6\xd5\xd6\x56\x47\xeb\
\xfa\x90\x1c\x99\xf8\x1a\x32\xdc\xf6\xb1\xf6\x2c\x24\x09\x27\x7f\
\x1d\xc9\x13\xaf\x20\xc3\xe0\x22\x2b\xf7\x22\xa4\x38\xb8\xb3\x6d\
\x5f\xb0\x3e\x5e\x88\x68\x6b\xc6\xda\xb6\x1e\xf1\xdb\xf3\x49\xf8\
\x70\x5f\x7b\x3f\x2b\x11\x9f\xeb\x85\x22\x9c\x9c\xe7\xf8\xa0\xd7\
\x9f\x25\xf6\xce\xa6\x91\x24\xd1\xfc\x1d\x89\x51\x64\xae\xb5\xe9\
\x4c\x1b\xd7\x12\xfb\xdc\x87\x78\x4e\x93\xb5\xe7\x68\xa1\x12\x45\
\x87\xbd\x42\x72\xde\xae\x0f\x7f\xaf\x6b\x5b\x28\xa0\x7d\xce\x83\
\xac\x4f\x51\x2b\xcf\x17\xbc\xeb\x85\x22\xbf\x17\xbb\x17\x9a\x6f\
\x21\x88\x52\xd7\x9d\x4c\xf1\x2a\x32\x44\xaf\x45\x39\x5c\x96\x21\
\x39\xd2\x19\x2e\xe2\x36\xca\xa1\x95\xdf\xfd\xad\x0a\xb1\xf7\x49\
\xb7\xdd\xdd\xeb\xee\x7f\x27\x9a\xc7\x1b\x53\xf7\xb5\x56\x87\x5f\
\x9e\xdf\x5f\x3f\xba\xa0\x90\xaa\xcf\x6f\xb7\x3b\xf2\x6b\x3e\x8a\
\x9a\x3c\x03\xad\x83\x06\x34\xd7\xcf\x46\xeb\xa4\x31\x55\x7f\x7b\
\xe3\x5d\x6c\xac\x22\xb4\x1e\x76\xa0\x75\xe0\x8f\x8b\x3f\x16\x2e\
\x5a\xe6\x9d\x48\xee\x71\x99\xc3\xd3\x7b\xa8\x8b\x8d\x49\x6b\xef\
\xca\x25\xbf\x3b\x0d\xc9\x4e\x2f\x52\x7c\xeb\x61\x47\x51\x85\xe8\
\xf1\xc3\xd1\x94\xe1\x55\x7b\xee\xbe\x63\x74\x4d\x6d\x75\x8e\x38\
\x6c\xd9\x0e\x38\xca\xa8\x6f\x8a\xf9\xf4\x7d\x6b\x77\xfc\x7a\xc1\
\xee\xeb\x10\x01\x4e\xa3\x58\x42\x01\x7f\x5f\x91\xb3\xee\xe6\x5b\
\xb9\xb7\x18\xdc\xc1\xe5\xc5\xca\xf7\xcb\xce\xd2\x9c\x08\xc5\xad\
\xdc\x9b\x6e\x8f\x7f\x8f\x4f\xbc\xda\xeb\x4f\x7b\xed\xca\xd0\xd2\
\x93\xd7\xd6\x33\x2e\x2c\xc8\xa1\x37\xda\x97\xf6\x7d\x24\xa8\x44\
\x14\x6f\xa7\xff\x9c\x0b\x33\x2b\xa4\xea\x2c\x46\x98\xfc\xb2\xd2\
\xc4\xb5\xd8\xf8\x82\x84\xd8\x62\x89\xb7\x0a\xad\x94\x99\x7e\xd6\
\x09\xad\xa5\x68\xef\xed\xcb\x48\xb0\xbc\x11\x11\xe6\x67\xe9\x7e\
\xfc\x0d\x52\xd4\xef\x2e\xf2\x5b\x3a\xa4\xce\x8d\xa9\xdf\x17\xd7\
\x47\x37\x67\x5b\x9b\x2b\xe9\x7b\x8b\x8d\x7f\x7b\x63\xed\xd7\x9b\
\x7e\x6f\x01\x01\x27\x03\xca\xd1\x11\x7b\xdf\x44\x02\x70\x77\x21\
\x4d\xab\xa0\x25\x3d\xec\xc8\x7a\x83\xe2\xf4\xaf\x18\x4d\xf7\xe9\
\x5c\x5a\xc0\x75\x65\xb6\x95\x6c\x87\x54\x59\x90\x6c\x91\xf0\x69\
\x86\x4f\xdf\x8b\x09\x9e\x7e\xfb\xc6\xa0\x84\x5b\x8f\xa1\xe4\x46\
\xe9\xf1\xe8\x28\x6d\xf2\xc7\xd5\x09\xc8\xed\xf5\x31\xcd\xc3\xd2\
\x4a\x92\xff\xb7\x23\x7c\xbd\x35\x9e\xed\xcb\x10\xed\xbd\xbf\x4c\
\x07\xea\xf1\x31\x0b\x29\x24\xff\x44\xb2\xf5\x29\x3d\x6e\xae\x9c\
\xf7\x21\x5e\xf6\x34\xf2\x72\x97\xa1\xdc\x19\xc5\xc6\xb1\xbb\x31\
\x00\xc9\x06\xff\x89\x14\xb7\xf4\xbb\xe9\x8d\x9c\x10\x5b\x69\x5b\
\xe1\xc8\xa3\xa4\x60\x07\x49\x8c\xfa\x2e\xf1\xe7\x78\x14\x7d\x96\
\x47\xca\xfe\x9b\xc8\x60\xdb\x17\x29\x70\xfb\xac\xef\x55\x48\x91\
\x7d\xda\xca\x9c\x82\x0c\xbf\x31\x8a\x26\xe8\x8b\x64\x98\xd7\xbc\
\xb6\xe4\x49\x8e\x1b\xfb\x37\x64\x84\x7e\x0d\xf8\x1c\x32\xa0\xd7\
\x21\xe3\xc6\xb3\x56\xce\xc5\xc8\x98\xb2\x04\x19\x49\xdc\xfb\x88\
\x91\xe1\xe4\x22\x64\x50\x59\x6c\xf7\x5c\x8c\x14\xfb\x9d\x48\xf9\
\x1a\x8e\x0c\x4e\xfd\x48\xf6\x7c\x3f\x83\x94\xc2\x51\xc8\xe0\x51\
\x67\x6d\xff\x8d\x8d\xe7\x20\x12\x63\x58\x25\x32\x92\xc4\x88\x6e\
\xad\xb6\x36\x57\x59\xd9\xdb\x91\xf1\xe5\x3c\x64\xd4\x79\x0a\x45\
\x0a\x9e\x8d\x3c\xbd\x07\x90\xf2\xe7\xbf\xab\x02\x8a\x24\x88\x50\
\x64\xc5\x87\xed\x99\x1f\x93\xe4\x58\xf9\x8a\x8d\x47\xbd\xd5\x53\
\x69\xf5\x54\x93\x9c\x32\x31\x85\x64\x2b\xc5\x4c\x7b\xf7\x5b\x90\
\xf1\x66\x2e\xcd\x65\x96\x69\xc8\x40\x53\x6b\xe3\xd9\xcf\xda\xf1\
\x34\x32\x58\x8d\xb6\x7b\x0e\x58\xb9\xbf\xb0\xba\x76\x21\x03\xc5\
\x70\x64\x3c\x9b\x6b\x7f\xa7\x21\xd9\x6e\x1e\x32\x18\x0e\x45\x46\
\x2e\xff\x5a\x89\x5d\x1b\x6e\x75\x8d\x06\xbe\x4a\x4b\x59\xb2\xa3\
\x88\x91\x21\xf3\x23\xc0\x67\x83\x1b\x38\xa0\xa7\xa1\x58\x16\xbd\
\x74\x96\xbd\x7c\x1b\xf7\x16\x43\xb1\xfd\x9b\xc5\xca\xf6\x53\xf4\
\x17\xda\xb8\xb7\xad\xac\x7f\xbe\x65\xb0\xbd\xfe\xb4\xd7\xae\x62\
\xe1\xac\x6d\x3d\x93\x66\x56\xfb\x10\x41\x1e\xe6\xdd\x5f\xac\x9d\
\x85\x54\xf9\xe9\x72\xf2\xb4\xdf\x67\xff\x5a\x6b\xe3\x0b\xc5\x09\
\x57\xbe\x8d\x32\xd3\xcf\xba\x6b\xfd\x90\xe7\xe3\x29\xc4\x04\x5e\
\xe3\xd8\x1f\x9d\xe4\xfa\xe7\x2c\xa0\xfe\x71\x1d\xe9\xb6\xfb\x73\
\xd6\xef\x63\x31\x01\x23\x5f\xe4\xff\xd6\xe6\x65\x5b\xef\x25\xfd\
\xde\x02\x02\x02\x5a\x47\xb1\xb5\x92\xa6\x87\x1d\x59\x6f\x71\x1b\
\xf7\xa7\xd7\x76\xda\x43\x53\xac\xcc\xd6\xea\xa3\x48\x59\xbe\x92\
\xe0\xd3\x0c\x8a\x5c\x2f\xd6\xbe\x2c\xf2\xb6\x6c\x44\x91\x44\xc5\
\xc6\x83\x56\xca\x2b\xc6\x33\x5d\xb9\xbe\x82\xd9\x56\x1f\x0b\x45\
\x9e\x4d\xd3\xba\x8e\xf2\xcf\x62\x7f\xd3\xef\xa1\x23\xef\xaf\xa3\
\xf2\x83\xc3\x8b\x48\xe0\x1f\xd0\xc6\xb8\xb9\x72\x9e\x46\x82\xff\
\xc7\xac\xef\xdf\x6e\x63\x1c\x8f\x15\x62\xa4\xb8\x7c\x1e\xf8\x06\
\x52\x10\x3b\xeb\x79\x8b\x51\xf4\xc4\x95\x24\xdb\xd1\xe6\x20\xbe\
\x3d\x03\x45\x70\xed\x40\x4a\xdf\x6d\x76\xef\x35\x76\x6f\x0e\x19\
\x13\xfa\x23\xe3\xc0\x69\xc8\xa3\x78\x3d\x0a\x85\x6e\x24\xd9\x7b\
\xee\xc6\xa9\x1a\x29\xc4\x15\xd6\xd6\x5a\x94\x4f\xa4\xc4\xee\x7f\
\x8f\x95\xb3\xce\xea\x71\x89\xe1\x40\xf2\xc3\x6d\x56\xf6\x66\x14\
\x35\xe1\x8e\x01\x9b\x6a\xf7\x5d\xe1\x5d\x7b\x3b\x8a\x9a\x38\xc3\
\x9e\xab\x45\x0a\x68\x01\x19\xe9\xc6\x58\x9b\x66\xa1\xb5\xb4\xcd\
\xfa\xf7\x71\xaf\xed\x1f\x47\x72\xd9\x2c\xeb\xd7\x0e\x64\xcc\x7f\
\x37\x52\x18\x2f\xb5\xba\x27\xa0\xc4\x7d\xdb\xac\x8f\x1f\xa0\x79\
\xa8\x73\x85\xb5\x69\xa9\x37\xf6\x19\x6f\x1c\x77\xa2\x48\x8b\xd1\
\xc8\x28\x70\x8b\x5d\xeb\x8f\x22\x35\xb2\x36\x46\xb3\xed\xdd\xdc\
\x82\x94\xee\x9d\xf6\x7d\x8e\xd5\xd5\x44\x22\xbb\x5d\x82\x14\xfc\
\x29\x36\x16\xbb\x51\xd2\x39\xf7\x1e\x3f\x64\xfd\xac\xb4\x7a\x0b\
\xf6\xcc\x58\x92\x23\xac\xa6\xa3\xf5\xf1\x11\xab\xbf\xde\xca\x1a\
\x43\x92\xed\x7f\x2f\xda\x42\x70\xba\x8d\xc7\x15\xc8\x28\x33\x96\
\xf6\xb7\x45\x76\x0a\x21\x59\x16\xc5\x63\x24\xba\xe3\xde\x80\x80\
\x1e\x80\x17\x39\x39\x73\x01\x6c\x25\x39\xaf\x10\x64\xe1\x0c\x08\
\x08\x08\x08\x38\x72\x34\xa0\x4c\xc9\x5d\x09\x39\x3c\xd5\xd1\x80\
\x4e\xa5\xe8\x48\x82\xa0\x55\xc0\xdf\x52\x3c\x52\xea\x78\x22\x87\
\x14\xbc\x41\x24\x47\x7c\x75\x16\x69\x03\x88\xfb\xde\x88\xb6\xef\
\x3c\x88\x42\x99\x3f\x48\x72\xee\xb3\x83\xfb\xde\x84\x3c\xc8\x1b\
\x51\xe4\xd7\x5e\xa4\x1c\xd7\x22\xa5\xd5\x3f\x6f\xd9\x19\x10\x2a\
\x50\xa2\x39\xb7\x17\xdc\x79\x1d\x9f\x40\x9e\xce\x0c\x52\xc4\x9e\
\x21\x11\xe1\x9b\x90\xd2\xb6\xc9\xea\xd9\x8c\x64\xa7\x8b\x91\xf7\
\xf6\x34\xb4\x25\x6b\x16\xf2\x70\x3f\x84\x94\xe1\x1b\x90\x27\xfb\
\x20\x49\x82\xb7\x71\x24\x91\x0d\x2f\x5b\x5f\xdf\x81\x3c\xac\xbf\
\xb1\x7b\x4e\x23\xc9\x3b\xf0\xac\x95\x77\xb6\xdd\x73\x3f\xf2\x7c\
\x0e\x46\x4a\x5f\x99\xf5\x29\x46\xdb\xd0\x86\x23\xaf\x35\xd6\x9f\
\x72\xa4\xb8\xb6\x36\xdf\x62\x92\xfd\xfb\xf3\xad\x3d\xd3\x69\x69\
\x04\xea\x8d\x14\xef\x6f\x21\x43\x4e\x16\x6d\x43\x1c\x87\x8c\x17\
\x05\x74\x0a\x8b\x73\x48\x14\xbc\xb6\x1f\x40\x8a\xfc\xb9\xc8\x23\
\xfd\x1b\x92\xdc\x33\x2e\x1a\xc4\x8f\xcc\x68\xb2\x72\x1b\xd1\x89\
\x2d\x79\x2b\xeb\x1c\x7b\x0f\x0b\xad\xdf\xfd\x90\x02\x3f\x16\x45\
\xa8\x3c\x6a\x7d\xbd\xa1\xb3\x93\xb1\x2d\x9c\xf2\x8a\x70\x43\x3e\
\xe6\x70\x53\x42\xf3\xb3\x51\x44\x65\x49\x86\xa8\xc8\x94\x6a\x2a\
\xc4\x1c\x6a\x2c\xbc\x35\x7b\x72\x99\x88\x8a\x92\x4c\xc8\xc1\x1e\
\xd0\xd3\x71\x32\x0a\x35\xc1\x06\x15\x10\x10\x10\xd0\xfd\x38\x19\
\xf9\xc5\xf1\x40\x67\x78\x54\x4f\x52\x82\x9d\x37\xee\x9f\x90\x22\
\xec\xf2\x7d\x74\xa4\xbf\x7e\x94\x99\x53\x7c\x5c\xa8\x7e\xa9\xf7\
\x9b\xdb\x93\xdc\x40\x12\x7e\xee\x9e\xcf\x20\xe5\x0e\x14\x9a\xbf\
\x11\x29\x4d\x73\x90\xb2\xb9\x0d\x29\x4e\x3b\x69\xdd\x33\xf8\x02\
\x0a\x57\x3e\x13\x29\x66\x79\xe4\xb9\x3c\x88\x94\xd3\x74\x22\xbd\
\xfb\x90\x12\x36\xde\xea\xf9\x19\xda\x4f\x7e\x25\xda\x27\xbe\x1b\
\x79\x56\x41\x91\x76\x6e\xcb\x04\xc8\xa3\xe9\x22\x47\x5c\x9f\xb0\
\x6b\x75\x76\xaf\xcb\x0e\xee\x9e\x39\x6c\xe3\x51\x40\xe1\xd6\x4e\
\x71\x76\x59\xd0\xdd\x78\x96\x22\x85\xfb\x80\xfd\xf6\x6b\xeb\xbf\
\x7b\x1f\xc5\x32\x45\xfb\x7b\x6c\xab\xec\x1d\x3e\x6b\x63\x58\x47\
\xf3\xf0\x7e\xd7\xe6\x32\xab\x37\xe7\xbd\x93\x43\xde\xbb\xda\x64\
\xf7\x1f\xf2\x9e\x6f\x6a\x65\x2c\xdc\x5e\xe4\x02\x49\xd6\x7a\x57\
\x5f\xde\xfa\x94\x4d\xdd\x0b\x0a\x21\xef\x6d\x75\xec\xb5\xfb\x1f\
\x40\x46\x92\x89\xc8\x6b\xec\xc6\xd7\xdf\x1a\xd9\x65\x9c\x8c\x9e\
\xa2\x8e\x77\x3e\x82\x5f\xbe\xb9\x8b\x1b\x7f\xb8\xfc\xad\xcf\x9f\
\xdf\xbf\x8e\xfd\x0d\xf9\x16\x23\x9c\x8d\x22\xe6\x6d\x3a\xc8\xdb\
\x7f\xba\xf2\xad\x7b\xff\xfa\xe1\x8d\x1c\x6a\x2c\x04\x45\xb8\xe7\
\xa2\x04\x65\xe1\x1d\xd2\x81\x7b\xb3\x88\xe0\x0d\xeb\xc0\xbd\x0e\
\x19\x44\x38\xab\x51\xf8\xc6\x1c\xba\x37\x4d\x7c\x2d\xb2\x7c\x1d\
\x49\x99\x67\xd8\xf3\xdd\x8d\x21\xd6\xcf\x6c\x57\x0b\x3a\x49\x30\
\x11\xf8\x2b\x34\xde\x0e\xe5\x28\xbc\x67\x4e\x27\xcb\x9a\x83\x18\
\xf7\x14\x64\xc1\x6e\x0d\xc3\x90\x45\xb9\x9c\xe4\x8c\xe9\x80\x80\
\x80\xce\xc3\x65\x73\xf7\x69\x6c\x19\x0a\xf3\xeb\x9d\xba\x77\x12\
\x6d\xaf\xcb\x8e\x62\x24\xe2\x35\x9d\x91\xbf\x4a\xd1\xbe\xd3\xde\
\x9d\x78\x26\x20\xa0\x2b\x58\x81\x3c\x80\xc5\x12\x69\xa5\x91\x41\
\x0a\xd7\x58\xfb\x8c\x46\x4a\x57\x0d\xe2\x91\x53\x11\xdf\x2a\xa0\
\xb9\x3c\x8b\x44\xb9\xdd\x84\x42\x96\xab\xd0\x7a\x9c\x8a\xe4\xa9\
\x0c\x0a\xdf\xcd\x21\x45\x75\x07\xf2\x4e\x3f\x87\x14\x64\xe7\x9d\
\x74\xeb\xc8\x65\xf0\x6e\x40\x5e\xd5\x67\x50\xa8\x71\x23\x8a\x18\
\xcb\xa1\xbd\xad\xc3\xd0\xfe\x50\xa7\x80\xe5\x48\xc2\x84\xef\x43\
\x0a\xb6\x4b\xda\xba\x02\x85\x2e\xcf\xb3\x72\xfd\x53\x4d\x5c\x56\
\xf8\x15\x28\xd4\xd8\x65\x7f\x9f\x40\xb2\x67\xde\xed\x8f\x77\x49\
\xd1\x2e\xb4\xcf\x59\x76\xad\xd8\x09\x24\xfe\xf7\x05\xc8\x1b\xbc\
\x11\x29\xcc\x63\x69\xbe\x3f\xfd\x00\x49\x96\x72\x67\x78\x70\x67\
\x84\x4f\x44\x7b\xd0\xeb\xd1\xde\xec\x9c\x57\xdf\x1e\xa4\x78\x3a\
\x9a\x36\xd2\xae\xad\x43\x21\xc8\x67\x21\x7a\x53\x65\xd7\xfe\x60\
\x63\xba\x89\xe2\xa7\xa7\xb8\x0c\xea\xcb\x6d\x6c\x5d\x82\xd0\xf1\
\x24\x27\x7b\x4c\xb4\xf6\xcf\x40\x61\xd3\x2b\x51\x78\xf4\x54\xe4\
\x1d\xff\xb0\xbd\xe3\x3a\xfb\xac\x23\xf1\xae\x2f\x42\xe1\xdb\x63\
\x51\x98\x74\x0d\xdd\xe8\x0c\x39\xa5\x3d\xc2\x11\x11\xdb\x0e\x34\
\xb2\x60\x6b\x72\xbc\x5e\x26\x13\x91\x2f\xc4\x2d\x53\x20\x44\xb0\
\xbf\x3e\xcf\x82\x2d\x87\xde\xf2\x20\xf7\xa9\xc8\x52\x08\x19\xc6\
\x7a\x32\x4a\xd0\xb1\x49\xeb\x51\xa8\x4b\x5b\x28\x20\x02\xb9\xba\
\x13\xe5\xd7\x00\x9f\x45\xc9\x2d\xaa\x51\x08\x4e\x77\x62\x28\x52\
\xe4\xff\x70\x04\xcf\xfe\x19\x0a\x4f\xd9\x7a\x14\xda\x74\x3d\xda\
\xdb\x14\x8e\xe4\x51\xd6\xca\xff\x85\xe6\xcf\x3f\xdb\xb5\x33\x49\
\xce\x32\x7d\xb4\x13\x65\x0d\x41\x96\xe7\x4b\x10\xf1\x7f\xa9\x95\
\xfb\x3e\x80\xe6\xe9\x3d\x28\x6c\xac\xe4\x78\x0f\x42\x40\xc0\x09\
\x8a\x0b\x90\x50\xfe\x00\xcd\x13\xc2\x9c\x4e\xcb\x75\x75\x2e\x0a\
\x57\x7c\xa9\xa3\x85\xb7\x82\x2a\x3a\x67\x70\x85\x24\x74\x73\x08\
\xca\x26\x1f\x10\x70\xb4\xd1\x51\x43\x4d\x84\x94\xc1\x8b\x91\xe2\
\x09\x52\x22\x7f\x8a\x14\xcb\x2b\x90\x37\xf5\x51\xa4\x54\x37\x22\
\xe5\xec\x06\xa4\xc8\xfd\x1c\xf1\xbd\x07\x91\xf2\xb5\x09\x85\xc1\
\xee\x43\x79\x3f\xae\x46\x0a\xdb\x32\x14\xde\x5c\x42\xe2\x69\xde\
\x89\x12\x5b\xd5\x7b\x7f\x17\x23\xaf\xe2\x23\x48\x29\xec\x87\xc2\
\x9a\xaf\x05\xee\xb0\x67\xe6\x79\xed\x6f\x44\xe1\xcf\x57\x21\x45\
\x7c\x09\xc9\xfe\xf8\x37\x90\xa2\xb6\x00\x29\x7a\xeb\xad\xcd\xce\
\x6b\xbe\x04\x29\x6c\xbf\x44\x7c\xbb\x1e\x79\x9c\xf7\x22\x4f\xe6\
\x2e\x1b\xc7\xc5\xe8\xf8\xc7\xcb\xac\xdd\xf7\xd8\xb5\x33\x90\xf2\
\x97\xb1\xfb\xb7\xd9\xf7\xb5\x68\xcd\xbf\x80\x14\xe1\x1b\xec\xb9\
\x97\xac\x6c\xa7\x80\xd6\xa1\xfd\xc1\x67\xa1\x70\x62\xa7\xc8\xbe\
\x07\xc9\x67\x1b\xd1\x3e\xef\xfd\x56\x66\xa3\xf5\x63\x03\xca\x5c\
\x3f\xc7\xee\x79\xcc\xee\xf9\xbd\x8d\xd3\x75\x24\x1e\x6a\xa7\xf0\
\x3b\x2c\xb3\x7b\xd7\xd9\x58\x64\xec\xfd\x2d\x46\x72\xc9\x2f\x51\
\xc2\x2d\x37\x16\x07\xec\xdd\xbf\x1d\x85\x4f\xaf\xb5\xe7\xd7\xa3\
\x44\x5a\x33\xad\x8c\x7b\xed\x3d\x1c\xb2\x6b\x39\xa4\x2c\xaf\xb6\
\x7b\xaf\x43\xf2\xf0\x01\x9a\x9f\x8e\xd2\x65\x9c\xd2\x8a\x70\x0c\
\x64\x52\x31\xd0\xd9\x36\xec\x5e\x11\x90\xcd\xf8\xff\x47\x21\x40\
\xb3\xfb\x71\x3d\x12\x14\x7a\xa1\xa3\x06\x46\x21\x02\xbb\x17\xed\
\x45\xd8\x81\x92\x1d\x64\xed\xb7\x45\xe8\xa8\x89\x98\xc4\x22\xb7\
\x17\xed\xf3\xd8\x43\x12\xb2\x52\x8d\x16\xfd\x28\xfb\xdd\x1d\x77\
\xe4\x2c\x81\x3b\x10\x41\xa8\x47\x7b\x50\x4e\x27\xd9\x6f\xf2\x28\
\x22\x78\x57\xda\xf5\x3d\xf6\xfc\x44\xab\xef\x56\x44\xc4\x37\xd8\
\x33\x63\x48\xbc\xa6\xcf\xa2\xd0\xa2\x69\x88\x28\xd7\x5a\xbd\xbf\
\xa7\xf9\x11\x18\xa5\xc8\xd2\x35\x01\xed\x13\x79\xc0\xee\xab\x42\
\x04\x64\x38\x52\x3e\xe7\x59\x5f\xae\x46\x56\xbc\x15\x24\x04\x7f\
\x1a\x49\xa8\xd0\x54\x12\x4b\x60\x09\x22\x22\x55\x88\xb0\xce\x45\
\x09\x16\x4e\x43\x4c\xc2\x59\x5c\x37\x23\x45\xf7\x1a\x2b\xe7\x39\
\xab\xaf\x14\x31\x89\x51\xc7\x7b\x72\xf4\x40\xc4\xe8\xfd\x8e\x43\
\x63\x76\x00\xbd\x07\x77\xfc\x17\x88\xd9\x5d\x89\x48\xc8\x93\x88\
\xb8\xdf\x82\x88\xf9\x72\xfb\xbe\x08\xcd\x1f\x17\x12\xe4\xac\xd5\
\x13\x10\xf3\xac\x47\xef\xf9\x10\xb2\xa8\x9e\x85\xde\xcd\x1a\xab\
\xe7\x4a\xe4\xc9\x3a\x0d\xcd\xab\xfb\xad\x2d\x13\xd1\xbc\xaa\x47\
\xf3\xb8\x33\x86\x9e\x80\x80\x93\x1d\x2e\xd1\x9d\x8f\x3c\x5a\x27\
\xf5\xc8\xd3\x72\x13\xa2\x9d\xce\x50\x15\x21\xa5\xd8\x09\xbe\x8f\
\x22\x21\xb6\x1a\xd1\x4e\x77\x64\xde\xe3\xf6\xfc\x95\x48\x81\xde\
\x44\xb2\x2e\xd7\x23\x1e\x77\x85\xb5\xe1\x74\xb4\x9e\x9f\x45\x7c\
\x63\x36\x12\xfe\x37\x20\x5e\xb6\xcf\xea\xf9\x8a\xfd\xdd\x76\xbc\
\x07\x2e\x20\xc0\x90\x41\xf2\xcf\x43\xa9\xeb\x05\xc4\xb3\x1e\xa7\
\x79\xe8\x6e\x06\xc9\x21\x4f\xd2\x3c\xab\xf7\x43\x76\x7f\x3a\xcc\
\x77\xa5\x3d\xe3\xc2\xc7\x7d\x0f\xea\x22\xa4\x80\xc5\x48\xb9\x8c\
\x91\x72\xe5\x24\xf3\xef\x7a\x6d\xf9\x0e\x5a\x5b\xe9\x72\x22\xc4\
\xaf\x97\xa7\xea\x19\x8a\xd6\xf9\x0b\x68\xdd\x67\x49\xb2\x5a\xe7\
\x10\x8d\x58\x63\x75\xbd\x42\xa2\x5c\xbb\xba\x5d\xde\x12\x97\x8d\
\xfc\x19\x2b\x0b\x12\x4f\xf6\xfd\x24\xde\xe3\x07\xbd\xb2\x9f\xf4\
\xca\xba\x1f\xd1\x00\x17\x5a\xec\x1b\x28\x5c\xe6\xea\x1b\x10\xad\
\x79\xdc\x7b\x16\x12\xda\x96\x45\xca\xae\xfb\xde\x64\xe5\x3e\x44\
\x73\xcf\xf8\x55\x36\xde\x2b\x50\x54\xcc\xea\x54\x9d\x05\xa4\xb0\
\xc6\x24\xf2\xae\x3b\x2b\x7d\xb5\xfd\xff\x32\x49\xe2\x52\x3f\x59\
\xdd\x37\x48\x32\xb0\xbb\x50\xf8\x57\xd1\xbe\xe5\xc8\x1b\x93\xb9\
\x48\x36\x8a\x48\x42\xa0\x0f\x23\x05\xdb\xcf\xec\xde\x6d\x38\xa5\
\x43\xa3\xbb\x8a\x38\x8e\xf5\x96\x43\x6c\x74\x77\xe2\x3d\x48\x19\
\x5e\x87\x42\x2b\x3e\x85\x08\x4a\x6f\x14\x82\xda\x1f\x85\x50\x5c\
\x81\x14\xd7\xf7\x23\xa5\xf0\x52\x94\xc2\x7f\x0b\x12\x58\xfe\x27\
\x49\x92\x87\x18\x09\x33\x17\x21\xa2\x79\x2e\xca\xda\x37\x08\xf8\
\x32\x12\x72\x76\x92\x9c\xa1\xbb\xce\xee\xcb\xa2\xf3\xf1\xb2\x48\
\x39\x9e\x6e\xd7\x27\xdb\xf3\x7b\x90\x80\xb2\x96\x24\xdc\xed\x34\
\xe0\xef\xd0\xda\xda\x8f\x8e\xde\x99\x88\xce\xba\xfb\x28\xda\x9b\
\x72\x3e\xca\x12\xe9\xe3\x22\x14\xc6\xb2\x1c\x79\x29\xae\x43\x44\
\x60\x2c\x0a\x1f\x39\x60\x6d\x1d\x86\x12\x41\xcc\x42\x84\xe7\x26\
\xe4\x21\x1c\x03\x7c\x11\x11\x93\xb5\xd6\xb6\x8d\x48\x39\xfa\x1b\
\x24\x74\x6d\xb0\x67\xcf\xb7\xbe\x7c\x9a\x24\xfb\xe1\x9f\xd9\xd8\
\xfe\x35\x12\xe8\x36\xda\xd8\x9f\x8f\x08\xe2\x2d\x76\xed\x7c\x92\
\x30\x9c\x00\xbd\x67\xa7\xf4\x8e\x43\x86\x93\x33\x10\xc3\x8b\x91\
\x01\xe3\x2b\x48\x60\xde\x8b\x8e\x7c\x1a\x81\xc6\xf8\xb3\xc8\x42\
\x7d\x1b\x7a\x0f\x57\xa3\xf7\xed\xf6\xd7\x8c\x45\x73\x7e\x27\x9a\
\x0b\x5f\x42\xeb\x60\x17\x9a\xe7\x8d\xc8\x08\xd3\xc7\xca\xb9\x15\
\xbd\xe3\x1b\xd1\xbc\x18\x8b\xe6\xc4\x4e\x2b\xef\x4b\x1c\x9d\x70\
\xf9\x80\x80\x93\x09\x65\x28\xb9\x4d\x7f\xc4\x53\xce\x46\xc6\xa5\
\x69\x88\xdb\x9f\x83\x68\xf1\x1e\x64\x64\xfc\x7b\xb4\xa6\x3f\x81\
\xe8\xf8\x1a\x44\x2f\x67\x22\x9a\x7e\x1a\xe2\x1b\x37\xa0\x35\x3a\
\x1c\xf1\x9a\x3e\x88\x06\x8c\x45\x8a\xed\xe7\xec\xfb\xcd\x88\xef\
\x2c\x47\xbc\xe3\x53\x48\xd8\xdc\x84\xe8\xc8\xb9\xc7\x7b\x80\x02\
\x02\x52\x70\xc6\x5b\xff\x03\xcd\xcf\xe3\x75\x58\x83\xd6\x93\x1f\
\xe2\xdb\xda\xbd\x4e\x51\x76\x0a\x51\x31\x69\xbb\xbd\x0c\xe1\xb1\
\xf7\x5c\x6b\xe5\xa4\xeb\x01\x19\xa2\x7a\x23\xcf\x69\xba\xbc\x74\
\xdd\x99\x56\x7e\xf3\xff\x77\xfb\x80\xdd\x3e\x68\xda\xb8\x3f\x4e\
\x95\x9d\x3e\x5b\xd8\x2f\x73\x35\xf2\x5c\x0f\xa4\xe5\x3b\xf0\xfb\
\x9a\x6e\x4f\x7a\xbc\x1b\x91\x12\x3a\x0e\xd1\xa9\x35\xc8\xe8\xd6\
\x5a\x8e\xe0\xd6\x4e\x43\xc9\xb4\x52\x17\x5e\x9b\xd2\xf7\xfa\x63\
\xe2\x5f\xf3\xe7\x46\xb1\xf9\xd1\x2d\x38\xa5\x3d\xc2\x5d\x45\xc8\
\x28\x71\x54\x50\x8f\xbc\xa1\x8f\x20\x01\xa3\x0a\x11\xa3\x02\x52\
\xc2\xce\x40\x82\xfd\x0f\x90\x05\x2e\x42\x0a\x44\x1e\x59\xb7\x7e\
\x81\x94\x91\x1f\x22\x42\xe6\x08\xdb\xd3\xc8\xd2\x55\x85\xf6\x7a\
\x9c\x85\xe6\xff\x5a\x7b\x66\x0f\x12\x3e\xf2\x56\xee\x20\xfb\xff\
\x9f\x91\x85\x6b\x13\x12\x4c\xdc\xf3\xe3\xd0\x39\x96\x1b\x10\xf1\
\x38\x1d\x29\xa1\x33\x90\x72\xfc\x0d\xb4\x98\x4f\x43\x1e\x81\x46\
\xe4\x75\xfd\x1d\x52\x6a\xef\xa2\xf9\x99\x89\x8d\x48\xf0\x9a\x80\
\x2c\x7c\x6f\x58\xbf\x97\x5a\x5f\x23\xa4\xec\x4f\x42\x4a\xec\x17\
\xec\xb7\x0d\x48\x80\xda\x6a\xff\xff\xc2\xc6\xf0\x2e\x6b\xd7\x70\
\xa4\xb8\x2f\x44\x82\x57\x0d\xf2\x30\x3a\x0f\xc3\x3d\x88\xe0\x7d\
\x01\x29\xe0\xe7\xa3\x30\xa0\xde\x76\xaf\x53\xee\x7f\x81\xac\x92\
\xdb\x6d\x5c\x82\xf9\x47\x88\x50\x78\xd2\x6b\xe8\xbd\xe4\xd1\xf8\
\xaf\x47\x73\x75\xba\xfd\x7d\x16\xcd\xcb\xa1\xc8\xc0\xf3\x63\xf4\
\x5e\xbe\x00\xfc\x09\xf2\xc6\xa7\x93\x8d\x5c\x8a\x98\x5b\x05\x9a\
\xab\x67\xdb\xf3\x6b\x50\x78\x92\x7f\xbe\xe3\x21\xb4\x6e\x1e\x42\
\xf3\xe8\x2c\xf4\xfe\x06\xa4\x9e\x9f\x40\xf7\x87\xcb\x07\x04\x9c\
\x6c\x68\x42\x6b\xef\x3c\x64\x24\x5c\x8b\xa2\x67\x2a\x91\x51\xf3\
\x75\xe0\x47\x68\xfd\x4f\x44\x4a\xee\x64\x94\x01\x78\x19\x3a\xd6\
\xcd\x79\x4d\xfa\x21\xda\x5b\x40\xeb\x72\x29\x89\x90\xb7\x09\xd1\
\xf7\xad\xc8\xb8\x3b\x0e\x29\xc2\xfb\xd0\xda\x6d\x44\x74\xe0\x3b\
\x48\x59\xde\x83\xe8\xc9\x23\xc7\x7b\x80\x02\x02\x8e\x10\x2e\x82\
\xaf\x27\x3b\xe2\x22\x14\x1e\xed\xda\xda\x93\xe5\x9d\x98\xc4\xbb\
\xde\x95\x31\x8d\x90\xc1\x6e\x29\xc5\x3d\xf0\x27\x2d\x82\x22\xdc\
\x05\xc4\x71\x70\x8b\x1d\x05\xe4\x91\x27\x15\x94\x0c\x68\x07\xf2\
\xa4\xed\x03\xfe\x03\x79\x25\x9b\xd0\x5e\x13\xec\x6f\x89\x7d\xea\
\xec\x5a\xa3\x7d\x5c\x96\xc2\x0c\xf2\x92\x4d\x45\x0a\xa6\x6f\x29\
\x73\x7b\x56\x5c\xf2\xa7\x02\xf2\x9e\x7e\x19\x85\x15\xff\xda\xee\
\x7b\x1b\x52\x12\xfd\xe7\x5d\x42\x83\x74\xa2\x95\x7a\x92\xa9\x71\
\x10\x29\x22\x07\x51\x78\x0d\x14\x27\xac\xf3\xd1\x5e\xd3\x8b\x90\
\x57\x7c\x31\x0a\x41\xd9\x6f\xe5\x55\x59\xbd\x25\x56\xe7\x21\xaf\
\xfc\xac\x5d\xdb\xeb\x95\xed\xda\x55\x86\x14\xef\x1d\x48\x81\xff\
\x15\x0a\x27\x9a\x82\x0c\x0a\xae\x3d\x31\x49\x66\xc3\xed\x36\xc6\
\xbf\x42\x21\x2f\x1f\xb1\x36\x60\xbf\xf7\xa4\x0c\x97\x3d\x05\x2f\
\x20\x2f\x7f\x6f\x34\x47\x2a\xed\x7a\x19\x9a\xbb\xbb\xd0\x18\xff\
\x10\x19\x28\x7c\xeb\x66\x6b\x7b\x7c\xcb\xd0\x3b\x72\xf3\xe6\x9b\
\x28\x64\xe9\x5a\x5a\x5a\xb5\x1b\xac\x1e\xbc\x72\xd3\xcf\x7f\x03\
\x09\xe9\x01\x01\x01\x09\xd2\x59\x57\x1d\x9c\x7c\xe4\xb2\xc0\x1e\
\x46\xb4\xbc\x8c\x84\xd7\xc4\x76\xbd\xca\xfe\x77\x74\xb2\x1c\xe8\
\x0b\xbc\x13\x29\xb4\x0b\x68\x9e\xd8\x07\x92\xa4\x35\x7e\x96\x59\
\x97\x4d\x75\x2b\xa2\xe7\xfb\xed\xd9\x03\xde\x3d\x41\x6e\x0b\xe8\
\x69\x48\x7b\x1f\xdb\xc2\xf1\x12\x9b\x9d\xd7\xd1\xc9\x3b\xed\x29\
\x8d\x69\x8f\x75\x67\xd0\x95\x67\x8f\xb4\xfc\xee\x18\xd7\x62\x9e\
\xf1\x93\x1e\x3d\xd9\x22\xd3\xe3\x11\x94\xe0\xa3\x02\xa7\xd4\x81\
\x3c\xb1\x55\x48\xf8\xdf\x87\xf6\xe3\x16\x90\x60\x71\x33\xf2\x8e\
\x5e\x8f\xce\x75\x7b\x0a\x85\x13\x9f\x8b\xc2\x3a\x4a\x91\x32\x59\
\x82\x04\x97\x8b\x51\xa2\x81\x3f\x22\x21\xa5\x9c\x24\xd3\x9d\xbf\
\xe7\xa4\x1c\x85\xab\x0d\x46\xd6\xc0\x51\xc8\x0b\x37\x13\x29\x3b\
\x7f\x44\xc2\x50\x39\x89\x50\xe2\x12\x16\xe5\x90\x92\x33\x02\x59\
\xf7\xa7\x59\xbd\xcf\xa7\xea\x71\xf5\xfa\x98\x81\x2c\xff\xbf\x43\
\x9e\xda\x11\x56\x9e\x7f\x5f\x0e\x29\xb4\x2b\x91\x80\x35\x1e\x25\
\xa7\x58\x84\x04\x26\x5f\x40\x6a\x42\xe1\xda\x1b\x90\xb0\xe5\x92\
\x48\x4c\x44\x61\xb9\xbe\xf5\xd0\xcf\x7e\xb8\x1d\x09\x66\x4b\x50\
\x08\x60\x29\xf2\x76\xde\x6c\xcf\xde\x8a\x3c\x8e\x19\xb4\x77\xf9\
\xec\x63\x3e\x43\x7a\x16\x22\xf4\xee\x97\xa3\x39\x71\x39\x9a\x27\
\x4e\xa0\x5d\x80\xc6\x7e\x37\x0a\x61\x9a\x8c\xe6\xe3\x1d\x68\xcc\
\xff\x11\x85\x54\x0e\xa6\xb9\x71\x25\x4b\xb2\x3f\x7b\x23\xf2\x18\
\x4f\xb6\x7b\x1a\xd1\x9c\xac\x26\x99\x57\xe9\x79\xec\x3f\xbf\xc1\
\x7b\x3e\xd0\xfc\x80\x80\x04\x11\x89\xe7\xf7\x1c\x14\x31\x51\x85\
\xd6\xcf\x36\xb4\x76\x6e\xb7\xdf\xae\x47\x6b\xf6\x65\x44\xaf\xa7\
\xa0\x68\x9f\xd1\xc8\x43\xbb\x19\xd1\xc7\x89\x68\x1b\xc2\xa5\x88\
\x67\x3d\x80\xf2\x2d\xd4\x90\x9c\xe7\x99\xce\x74\xeb\xbe\xbb\x04\
\x33\x7d\x50\x14\x4f\x29\x49\x64\x53\xc6\xca\x58\x7b\xbc\x07\x2d\
\x20\xc0\x43\x84\xf6\xcb\x9f\x4e\xcf\x0d\x94\xcc\xa1\xed\x63\x25\
\x28\x2a\xe3\xbc\xa3\xd8\xd6\x18\xad\xd3\xa3\x95\x53\x25\x46\x74\
\x6a\xf8\x51\xec\xc3\x29\x85\x60\x59\xec\x02\xe2\x38\xc6\x4f\x1a\
\x9d\x89\x20\x8a\xa2\x16\x26\x9a\x42\xea\xbe\x80\x36\xf1\x2a\xda\
\xff\x08\x4a\x28\x55\x82\xf6\x59\x15\x90\x12\xba\x0b\x29\x7d\x35\
\x68\x7f\xf0\xab\x24\x87\x94\x97\xdb\xbd\x87\xd0\x19\x78\xeb\x91\
\x50\xb1\x19\x79\xc3\xde\x8e\x14\x08\x97\x5d\xef\x20\x52\x5a\xdc\
\x59\x66\x6f\xd8\xf7\x7e\x56\x8f\x0b\x5f\x7e\x1e\xf8\x2f\xe4\x15\
\x1e\x8e\x3c\xc5\x6b\x91\x57\xe0\x0f\x68\xbf\xee\x93\x56\xee\x22\
\xe0\x3f\x51\xd2\x14\x50\x08\xac\x13\x82\x5c\x72\xac\x6d\x28\xb9\
\x82\x3f\x2b\x5e\x43\x4a\xfc\x9f\x58\xff\xbe\x6a\xe5\xbb\xa4\x03\
\x4d\xf6\xcc\x56\xe0\x5f\x81\xf7\x22\x4f\xed\x26\x14\xa2\x37\xc8\
\xee\x75\x7b\x49\x7e\x85\x04\xb1\x27\x6d\x2c\x6e\xb5\x76\x2e\x45\
\x61\x7d\x95\x24\x02\xd8\x1e\x1b\xa7\x55\x28\x14\xfc\x16\xbb\x77\
\x39\xf2\x54\xbf\x6e\x63\xf1\x41\x64\x90\x78\xd6\x9e\x1b\x4d\xfb\
\xd9\xb8\x4f\x76\xac\x45\x73\xf0\x00\x9a\x0b\xa7\xa1\xf9\xbb\xce\
\x7e\x7f\x83\x64\x3e\x64\xd1\x3b\xda\x86\x0c\x1d\xdf\x40\xf3\xa5\
\x16\x09\xda\x6f\xda\xb3\x4e\x50\x7e\x01\xcd\xc5\xdb\xad\xac\xa7\
\xd1\x78\xdf\x87\xf6\x30\x9e\x8e\xe6\xc4\x41\xab\xc7\x79\xf8\xd7\
\x20\x2f\xd5\x73\xc8\x2b\x75\x87\x5d\x7f\x0a\xcd\x97\x80\x80\x00\
\x61\x35\x5a\x3f\x9f\x46\x74\xb3\x0e\xf8\x36\xf0\x22\x32\x5e\x7d\
\x15\xd1\x5a\x17\xa5\xb3\x0c\xd1\xbf\xbe\xc0\x9d\xc8\x68\xf8\x35\
\xb4\xfe\xbe\x66\xf7\x7e\x08\xd1\xf3\x5f\x22\x23\xd6\x1c\x64\x60\
\x7c\x9c\xe4\x8c\xcc\x37\x48\xe8\xbb\xf3\x08\xcf\x43\xeb\xfb\x29\
\x44\x6f\x3f\x66\xf7\xff\x06\x29\xc8\x43\x90\x82\xfc\xc6\xf1\x1e\
\xb4\x80\x80\x14\x66\xa3\x35\xb3\xc2\xfe\x4f\x7b\x5e\x9d\x5c\x02\
\x09\x7f\x2b\x74\xe0\xde\x74\xc4\x1d\x34\x8f\xe0\x88\x8a\x3c\xe3\
\x5f\x07\xc9\x4e\xc3\xd0\x09\x22\xff\x8a\xb6\x1f\xf4\x43\xbc\xd3\
\x3f\x52\xa8\x58\xb9\x31\xcd\xf7\xbb\xa6\xf7\xb7\x46\xb4\xec\x5b\
\x4c\x72\x04\xd4\xb7\x52\x7d\x85\xc4\xb9\xe1\x27\xe9\xf3\xf7\x0c\
\xfb\x89\xa9\xfc\xfd\xb2\xae\x7c\x57\xc6\x75\x28\xc2\xac\x81\x80\
\x2e\x21\x9a\x32\xbc\x6a\xcf\xdd\x77\x8c\xae\xa9\xad\xce\x9d\x72\
\xca\x5a\x26\x8a\xf8\xbf\xcf\x6e\xe1\xef\x1f\x4f\x64\xc3\xc9\x43\
\x2b\xf9\xd5\xbb\xce\xa0\x5f\x65\xf3\xf1\xc8\x66\x22\x1e\x59\xbe\
\x97\xf7\xff\x7a\x35\x75\x0d\x9a\x93\x53\x47\x54\xf1\xf3\x77\x9e\
\x41\xbf\x8a\x1c\x4d\x85\x98\x0d\xfb\x1a\x58\xb4\xed\x10\x5b\xf7\
\x37\xd1\x90\x2f\x50\x53\x9e\x65\x44\x4d\x29\xe3\x06\x56\xd0\xb7\
\x52\x73\xff\x54\x1b\xe3\x34\xea\x9b\x62\x3e\x7d\xdf\xda\x1d\xbf\
\x5e\xb0\xfb\x3a\x44\x88\xd2\x48\x1f\x5c\x05\xcd\x09\x52\x15\x12\
\x38\xbe\x8a\x88\x6e\x3a\xe3\xa7\xcb\x2a\xd7\x1a\xe1\x82\xe6\x9b\
\xf0\xa1\x65\x98\x49\x44\xf3\x30\x9f\x74\x82\x83\xf4\x86\x7f\x3f\
\x93\x5d\x9c\x2a\x23\x4d\xc0\x8a\xb5\xab\xa3\xed\x4f\x3f\x93\x4d\
\xf5\x3f\xfd\xbb\x3f\x6e\x8e\xb0\xe7\xbd\x7b\x69\xa3\x9e\x0c\xc5\
\xc7\x36\x5d\x9f\x5f\xc6\xc9\x8a\xbf\x41\xca\xe5\xdd\x45\x7e\x6b\
\x6d\x0c\x8a\x8d\xaf\x3f\x1f\xd2\xcc\x31\xfd\xae\xfc\x67\xfd\x79\
\x47\xea\x9a\xff\x4c\x7a\x1e\xb7\xf5\x7c\x40\xc0\x89\x8a\x72\xb4\
\x4d\xe6\x9b\xc8\x08\xd5\x15\xa4\x69\x3d\xb4\xa4\xe5\x90\xac\xd7\
\x62\x89\x5e\xd2\x6b\x3f\x4d\x27\x8b\xad\x6d\x68\x7f\xdd\xa6\xcb\
\x79\x07\x52\x86\xbf\x4e\x58\xcb\x01\x5d\xc7\x00\xe0\xfb\xc8\x50\
\xbb\x9d\x23\x0f\x85\x8d\x50\xae\x8b\x17\x90\xa1\xde\x45\x91\xf5\
\x45\xd1\x11\xf3\x51\xf4\x44\x84\x14\xd2\xa5\xc8\x00\x34\x11\xad\
\x8d\x79\x24\xf9\x51\x5e\x46\x9e\xdb\x73\x48\x8e\x0f\xda\x48\xf3\
\xb5\x31\x02\x45\xdb\x65\xd0\xfa\x5f\x89\x14\xcf\xbe\x68\x5b\x5b\
\x3d\x92\x0d\x17\xa3\xa8\xa9\xe9\x56\xfe\x2d\xd6\xdf\x4a\x74\xc4\
\xe1\x62\xfb\xfe\x2c\x32\x10\x0f\x40\x11\x7c\x55\xc8\x40\xfd\x06\
\x32\xf6\x0f\x46\x8e\x06\xe7\x2c\x99\x88\x68\xd0\xe3\xc8\xf8\x7c\
\x06\x8a\xb6\x2a\xb7\xbe\x2d\x42\x49\xf6\x46\x00\xff\x8e\x1c\x32\
\x33\x51\xe4\xc9\x6a\x24\xf7\x46\x24\xe7\xf7\x6e\x45\x46\xeb\x81\
\x36\x3e\x2f\xda\x18\x4e\xb5\x71\xea\x85\xb6\xcc\x55\x20\x63\xf9\
\x42\x44\x1b\x3e\x85\x8c\x66\xaf\xd0\x32\xc2\x30\xa0\x6d\xc4\x68\
\xbc\x3f\x02\x7c\x36\x78\x84\xbb\x88\x4c\x04\x6b\xf7\xd4\xf3\xbd\
\x57\x77\xf0\xe0\xb2\xbd\xac\xdf\xd3\x40\x43\xbe\x40\x21\x86\x5c\
\x26\xa2\xaa\x34\xc3\xd8\x01\xe5\xdc\x38\xbe\x0f\xb7\x4f\xea\x47\
\x6d\x75\x8e\xc2\xc9\xae\x36\x74\x0d\xc5\x46\xc7\x67\xfa\x4d\x88\
\x70\x1e\xa0\xf8\x39\xb6\xf9\x36\xca\x2b\xb4\x72\x3d\x7d\xad\xb5\
\x37\xd4\xda\xf3\xf9\x56\xca\x8a\x5b\xb9\xbf\xad\x3a\xda\x6a\x7f\
\xdc\x89\x7b\x8b\xb5\x37\xdf\xc6\xbd\x71\x1b\xf7\x76\xb4\xbe\x53\
\x11\x71\x07\xaf\xa7\xe7\x43\x5a\x90\x6d\x6b\x6e\x16\x13\x7a\xd3\
\xd7\xe2\x4e\x3e\x1f\x10\x10\x50\x5c\x91\x2d\x86\x62\xca\x71\x6b\
\xeb\x2a\xdf\xca\xb3\xe9\xe7\xd3\xff\xb7\x45\xdf\x4b\x91\xb0\xfb\
\x4b\xc2\x7a\x0e\xe8\x99\x28\xa0\xa8\xb6\x72\x24\xa3\xf5\x45\x51\
\x69\x4b\x51\x34\xde\x0a\xa4\xc4\xdd\x66\xf7\x8f\xb5\x7b\x5f\xb1\
\x7b\x67\x23\xa5\xf1\x5d\x28\x61\xe8\x40\xb4\x25\xeb\x3b\x48\xee\
\x8b\x91\x52\xfa\x21\xa4\x5c\xd7\xa3\x08\xc0\x6f\x21\x05\x76\x14\
\x3a\x93\x78\x34\x4a\x5e\xb7\x04\x6d\x1f\x9b\x8e\x94\xcb\x03\x28\
\x1a\x6b\x24\x52\x66\x5f\x43\x11\x7e\x77\x21\xa3\xda\x07\x91\x52\
\xba\x16\x45\xd0\x61\xbf\x5f\x8f\x92\x8a\x4e\x45\x5b\x9f\xfe\x80\
\x94\xf6\x6a\x74\x36\xf0\xed\x48\x41\xde\x87\x22\x47\xbe\x89\x14\
\x64\x77\x9c\xe2\xfb\xd0\xfa\x9d\x8f\xb6\x52\xf4\x47\xd1\x81\x97\
\xa3\x2d\x15\x33\x50\x24\xa2\x3b\x02\xf4\x25\x1b\x97\xcb\x6c\xcc\
\xee\xb4\x76\x6f\x47\xa7\x41\x6c\x45\x91\x23\x6b\x91\x02\xee\xa2\
\x06\x03\x8e\x10\x41\x11\xee\x02\x22\xe0\xd9\xb5\x07\xf8\xb7\x67\
\xb7\x32\x77\x63\x5d\x8b\xdf\x9b\x0a\x31\x7b\x0f\xe7\x79\x79\x43\
\x1d\x73\x37\x1d\xe4\x8f\xcb\xf7\xf2\xb7\x57\x0c\xe3\xc2\x61\x55\
\xe4\x4f\x75\xd7\xf0\x91\xa3\x1e\x11\x9a\x30\x80\x01\x01\x01\x01\
\x01\xa7\x02\x1a\x80\x9f\x11\xf8\x5e\x40\xcf\x86\x1f\xcd\xe6\x1f\
\x81\xb3\x1b\x6d\x75\x73\x5e\xd8\x69\x68\x4b\x56\x21\x75\xaf\xcb\
\xbb\x32\x1e\x29\xcd\xf3\x48\x0c\x42\x05\x92\xbd\xb1\xaf\xa3\x5c\
\x1b\xb5\x68\x0f\x7d\x13\xf2\x26\x3f\x85\x3c\xc4\x9f\xb5\xfb\xce\
\x47\x8a\xf6\x72\xa4\x4c\x2e\x47\x8a\xf0\x5c\x74\x6e\xef\x59\xe8\
\x38\xce\xb1\x56\xce\x46\x94\xf0\xd2\x79\x64\x37\x59\x5d\xf7\x23\
\x8f\x6c\xde\x9e\x6b\x40\xfb\xa2\x0f\x22\x65\xb8\x1c\x29\xee\xd5\
\xf6\xbc\xdb\x1a\xd5\x88\x3c\xc6\xff\x8a\xa2\xca\xf6\x23\x25\xfb\
\x51\xa4\xfc\x8f\xb6\x76\x2f\x46\xf9\x56\x7c\x23\x97\x1b\xcb\x26\
\xe4\x25\xdf\x8d\xb6\x07\xba\x64\xb2\x5b\xad\xdd\x39\x8a\x3b\x2e\
\x02\x3a\x88\x90\x38\xa5\x0b\x58\xb3\xbb\x81\x2f\x3c\xb8\xe1\x2d\
\x25\xb8\x24\x1b\x51\x53\x9e\xa5\x77\x79\x96\x9a\xf2\x2c\xd5\xa5\
\xc9\xf0\xe6\x0b\x31\xcf\xae\x39\xc0\xa7\xef\x5b\xc7\x4b\x1b\x0e\
\x90\x39\x65\xf2\xb1\x1d\x15\x04\x61\x20\x20\x20\x20\x20\xe0\x54\
\x42\xe0\x7b\x01\x27\x0a\xdc\x09\x17\x2e\x64\xb7\x11\x39\x31\x22\
\xfb\xeb\x92\xc6\xb9\x7b\x73\x48\xb1\xdd\x03\x7c\x17\x29\x92\xd3\
\x91\x87\xb5\x0f\xc9\xdc\x2f\x41\x5e\xd6\x3d\xc8\x03\xfb\x7b\xa4\
\x30\x83\xf6\xdc\xe7\x90\xe7\x74\x0d\xda\x9b\x5f\x8b\x3c\xbf\x2e\
\x29\x9d\xab\xd3\x9d\xb0\xe0\xb6\x2b\x95\x20\xe5\xd6\xe5\xa0\x79\
\x0a\x85\x4c\xc7\x68\x4f\xbf\x4b\x62\x79\x88\xe6\x61\xda\x83\x90\
\xc7\xf6\x12\x94\x07\xa6\x89\xe6\xa7\x89\xe4\xec\xbe\x06\xfb\xff\
\xb0\xb5\x65\x11\xda\x6a\x15\x21\x2f\xef\x35\x5e\xb9\x2e\x31\x5e\
\x89\xb5\xed\x67\x28\x4f\xcd\x68\xe4\x5d\x1e\x43\xf3\xb3\x77\x83\
\x36\xd1\x45\x04\x8f\x70\x17\xb0\xf5\x40\xe3\x5b\xdf\xcf\x1e\x54\
\xc1\xc7\xa7\x0d\xe4\xbc\x21\x95\x44\x36\x2d\xeb\x1a\x0a\xdc\xbf\
\x64\x2f\x3f\x79\x7d\x27\xbb\x0e\xea\xc4\x99\x45\xdb\x0e\xf1\x37\
\x8f\x6c\xe4\x7b\xb7\x8d\x62\x58\xef\x92\x10\x26\x1d\x10\x70\x62\
\xe3\x0c\x14\x1a\xe5\x8e\x40\xda\x81\xc2\x9d\xd6\xa0\xcc\xe1\xf3\
\x91\x25\xba\xbb\x50\x8a\x2c\xc7\x8b\x28\x9e\x24\xa3\x02\x9d\xfd\
\xfc\x04\x09\xb3\x0f\x08\x08\x68\x1b\xd3\x91\xb7\xe9\xc7\x24\x47\
\x20\x9d\x8e\x04\xf8\x8d\xa9\x7b\x2f\x43\x9e\xa2\xa5\x45\xca\xe9\
\x8d\xc2\x1f\x1f\xa1\xf9\xfa\x3b\x0b\x1d\x7b\xb6\x06\x09\xae\x8f\
\xa2\x84\x84\xcf\xd2\xfa\x3a\x1d\x84\xce\x76\x7f\x19\x09\xf5\x7f\
\xb4\x67\xe6\xa1\x6c\xd6\x69\x64\x90\x87\x68\x23\x52\x1e\xc6\x03\
\x0f\x13\x14\xe8\x80\xa3\x0f\x77\xda\xc7\x36\x34\xff\xc7\xa1\x90\
\xdf\xde\x48\x61\xeb\x8f\xe6\xae\xf3\x06\x3f\x83\xd6\xc1\x1c\xc4\
\xcf\x66\xa2\xbd\xb9\x83\x51\x28\xf2\x1f\xd1\x3c\x7e\x17\xf2\xb6\
\x62\xf7\xaf\x42\xca\xe6\x01\xb4\x6e\xae\x47\x21\xd0\x4e\xf9\xc4\
\xea\x7b\x11\xf8\x4b\xa4\xd0\x6e\x43\x49\x2c\xcb\x90\xd7\xd6\xbf\
\xd7\x29\xab\x5b\x48\xf8\xf4\x6a\x94\x88\x6a\x17\x2d\x4f\xd7\x70\
\x8a\xbd\x53\x40\x87\x59\xdf\x7e\x82\xf6\x18\xd7\x90\x9c\xec\xd0\
\x1f\xd1\x92\x3d\x36\x26\x2f\x20\xde\xbc\xc2\xc6\x67\x14\xc9\x39\
\xc5\x83\x91\xe7\x79\x08\xa2\x43\xa7\x23\x25\xbe\xcc\x9e\x59\x82\
\x42\xb2\x3f\x41\x62\x18\xe8\x6f\x6d\x6c\x24\x28\xc3\x5d\x42\xf0\
\x08\x77\x03\x66\x8f\xea\xc5\xf7\x6f\x3b\x9d\xf7\x4e\x1e\xc0\x39\
\x43\x2a\x99\x54\xab\xcf\xf4\x91\xd5\xfc\x8f\x2b\x86\xf2\xcf\xd7\
\x0c\xa7\xb6\x3a\x39\x2a\xf4\x95\x0d\x07\xf9\xd1\xfc\x9d\x41\x09\
\x0e\x08\x38\xf1\x31\x0e\xed\x83\x5a\x85\x18\x5c\x2d\xf0\x2f\x28\
\x51\xc6\xf5\x88\x39\x76\x27\x46\x02\x9f\xa3\xf5\xb3\x87\x73\x28\
\x24\xac\xa4\xc3\x25\x06\x04\x9c\xda\x28\x43\x27\x10\x7c\x12\x85\
\x47\x3a\xfc\x29\x3a\x66\x25\x8d\x5a\x94\xc0\xa6\x18\x6a\x90\x87\
\xa8\xc6\xbb\x16\x59\xf9\xbd\xd1\xde\xc1\xe1\x48\xe8\xbf\xb9\x8d\
\x72\x5c\xbb\x86\xa2\x10\xca\xbb\x50\xa6\xdb\xdb\x10\x0d\x28\x86\
\x0a\xe0\xaf\x90\x02\x5d\x89\x84\xea\x80\x80\x63\x81\x25\xc8\x08\
\xfc\x2a\xca\xac\x7e\x13\x52\x54\x5f\x42\x4a\xdb\x01\xa4\xc0\xdd\
\x68\xf7\x3c\x8b\x42\x96\x97\xd8\xbd\x07\x50\xc2\xa8\x2d\xf6\xfc\
\xf5\xc8\x38\xf5\x73\x9a\x9f\xa4\xb0\x1c\xf8\x05\x4a\x1e\x75\x1d\
\x0a\x29\x5e\x8f\xc2\xa1\x37\x91\x78\x7d\x57\xa0\xb5\x36\x0f\x29\
\xc6\x5b\x49\x92\x76\x39\x8f\x71\x06\x79\x91\x17\x5a\x1d\x3f\x40\
\x5e\xd7\xdb\x90\x82\xb9\xc8\xae\xaf\xb7\x7b\x37\x59\xfd\x19\x2b\
\x63\xa9\x3d\xfb\xa2\xf5\xe1\x74\x64\x78\x72\xa7\x38\xd4\x21\xef\
\xed\x7f\xa3\xf5\xfe\x76\x6b\xc7\x6f\x48\xbc\xd8\xef\x40\xeb\xf6\
\x97\xd6\x97\x67\x91\xc1\xac\x02\x9d\xf8\xb1\xcf\xc6\xeb\x02\x44\
\x2f\x9e\xb5\xff\xcb\x90\x11\x7e\x01\x21\x67\x40\x97\x11\x3c\xc2\
\x5d\xc4\xe9\x7d\xcb\xf8\x9f\x73\x86\x31\x7e\x50\x05\x4d\x85\xb8\
\x45\xea\x8b\x4c\x04\xb7\x4d\xe8\xcb\x96\xfd\x8d\xfc\xdd\xe3\x9b\
\x68\xcc\xc7\x14\xe2\x98\xdf\x2d\xdc\xcd\xbb\xcf\xeb\xc7\x88\x9a\
\xd2\xa0\x10\x07\x04\x9c\xd8\x58\x86\x2c\xc2\x20\xc1\xf6\x27\x88\
\x49\xc5\x28\x89\xc7\x1c\xe4\xc1\x79\x10\x85\x46\x9d\x8f\x2c\xe0\
\x07\x80\x87\x90\xe5\xfb\x2a\xc4\xdc\x4e\x43\x02\xc5\x1f\x90\x20\
\xb0\x0b\x31\xf3\x5e\x28\x7c\xaa\x16\x25\x24\xb9\x1e\xb8\xd7\xca\
\x3f\x0f\x31\xe6\x87\x50\x58\xd7\x3a\x14\x5e\x75\x25\x62\xa8\xa7\
\x21\x6b\xf7\x1f\x10\x73\x0e\x08\x38\x99\x51\x8d\x94\xc1\x8d\x24\
\xde\xdd\xb6\x30\x16\x29\xa9\xf7\x21\x81\x76\x2e\x5a\x33\xd3\x91\
\x42\xb9\x0e\x79\x74\x7b\x93\x78\x8e\xf6\x92\x24\xb4\x19\x6b\xf5\
\x3c\x84\xa2\x34\xd2\xfb\xf5\x2e\x44\x82\xfb\xab\x48\x48\x5e\x47\
\x12\xd6\x78\x0d\x5a\xdb\xaf\xa1\xe3\xd1\xa6\x59\xdd\xbd\x91\x90\
\xbb\x9e\x64\xef\xa4\x0b\x87\x74\xa7\x27\xb8\x33\x8c\xf7\xa1\xb5\
\x7d\x06\xa2\x2d\x37\x21\x5a\xb3\xd1\xee\x1d\x8d\xe8\x4b\x09\x12\
\xa4\xe7\x23\x6f\xdd\x20\x92\x6c\xb8\xf7\x22\x1a\x12\x10\xd0\x59\
\xc4\x28\x99\x94\x4b\x3c\xf7\x43\x92\x8c\xe7\x11\x9a\xdf\x0d\x68\
\x8e\x6d\x21\xd9\x37\xdc\x50\xe4\x5e\xd0\xdc\x75\x91\x0c\x2e\x4c\
\xd8\xc7\xcb\x68\x8d\x46\x24\xa1\xc8\x0f\x92\x64\x61\xaf\x46\x6b\
\x6e\x13\x89\xb7\xb8\x1e\xf1\x65\x97\xc1\x1d\xa4\xff\x6c\x05\x7e\
\x6a\xd7\x96\x91\x28\xba\x6e\x0d\xcf\xf3\xee\x75\xd9\x9e\x33\x24\
\x47\x65\x16\xac\x5c\x3f\xc3\xbb\xcb\x30\xff\x75\xbb\x3f\x0f\x7c\
\x8f\x96\x27\x71\xfc\x90\x64\x7f\xaf\x6b\xfb\x3d\x45\xc6\x63\x3e\
\x52\xac\x23\xef\xde\x31\x56\xde\x7c\x82\x43\xb3\xcb\x08\x03\xd8\
\x05\x64\x22\xb8\x6b\x72\x7f\xce\x19\x62\x4a\x70\x11\xc4\x00\x11\
\xbc\xe3\x9c\x7e\x9c\x3b\xb8\xf2\xad\xeb\x2b\x77\xd5\xf3\xec\x9a\
\x03\x44\x51\x88\x68\x08\x08\x38\xc1\x51\x81\x04\xca\xfe\x48\x90\
\xad\x40\xc2\xf2\x40\x94\xd5\x71\x2d\xf0\x4e\xa4\x10\x5f\x80\x8e\
\x56\x58\x8f\x04\xe9\xbf\x42\x1e\x9f\xdb\xd1\xf1\x0e\xeb\x90\x92\
\x7b\x33\x52\x7a\xdf\x8b\xe8\xf4\x14\x94\x65\x72\x13\x12\x7c\xd7\
\x21\xeb\xfa\x07\x91\x75\xfb\x0c\xe0\x2b\xc8\x03\xfd\x36\x64\x7d\
\x7f\x87\x95\xb9\xd6\xee\xbd\x8d\x80\x80\x93\x1b\x39\xe0\x4b\x68\
\x6b\xc0\x47\xe8\x58\xc8\xe0\x55\x48\xa8\xfd\x19\x52\x24\x87\x22\
\x23\xd5\x6e\x64\xc0\xaa\x00\xbe\x88\x94\xd3\xad\x68\x1d\x9e\x85\
\xf6\x05\x5e\x8b\x3c\x39\xb5\xc0\xe7\x29\x1e\x89\xb1\x13\x29\x99\
\x6b\xad\xac\xdb\x48\xc2\x2a\xc7\xa2\x35\xfd\xa7\x48\x39\xbd\x04\
\x9d\x1f\xbc\x11\x09\xf4\xd7\x17\x29\xb3\x80\xd6\xf3\x45\x48\x20\
\x1f\x8f\xbc\xd9\x7b\x48\x68\xc3\x50\xa4\x64\x8f\x00\xfe\x17\xa2\
\x21\xbb\x80\x2f\xa3\xa3\x69\x66\x59\x3d\x5b\x51\x28\xe6\x9f\x12\
\xe4\xc1\x80\x23\x47\xb1\x63\x02\xdd\xd1\x60\x4d\x68\x8d\x1c\xa6\
\xf9\xd1\x95\xe9\x7b\xf1\xae\x3b\x83\x4f\xb1\x39\xe9\x9f\xad\x9b\
\x49\xd5\xef\xc2\x8c\x2f\x40\x09\xae\x0e\xd0\xf2\x68\xb4\xd6\x4e\
\xf4\xf0\xf7\x2c\xa7\x8f\x54\x4b\xdf\xeb\xbe\xa7\xfb\x10\x79\xd7\
\xfd\x64\x61\xe9\x72\xdd\x27\x7d\x9c\x65\xb1\xf1\xc8\xa4\xca\x8a\
\x10\x9f\x77\xdb\x2f\x82\x12\xd1\x45\x04\x8f\x70\x17\x30\xa4\x57\
\x09\xd7\x9e\x55\x43\x44\x44\xdc\xc6\x36\x9c\x38\x86\x81\x55\x39\
\xae\x3c\xb3\x37\x73\x37\xd6\x89\x32\x14\x62\x5e\xde\x50\xc7\x1d\
\x93\xfa\x11\x74\xe1\x80\x80\x13\x16\x05\x24\x90\x7e\x9d\xc4\x82\
\xfd\xdf\x28\x54\xab\x0e\x25\xc4\x78\x11\x09\xbc\x63\x91\xd0\xd9\
\x1b\x29\xaa\x20\xc1\xfb\x4c\xbb\xf7\x8f\xc8\xb2\xdd\x1f\x85\x5c\
\x7f\x83\x24\xe4\xea\x12\xb4\x9f\x68\x01\x3a\x3a\x61\x31\xf0\x01\
\x64\x41\xbe\x07\x85\x51\x7d\xd3\xca\x72\x47\x4d\xd4\x23\x2f\xd7\
\x43\x48\x50\x1f\x7f\xbc\x07\x2b\x20\xe0\x28\x23\x83\x04\xe1\x5a\
\xfb\xb4\x87\x3e\x48\xb1\xbd\x17\x79\x59\x2b\x90\xc1\xea\x87\x24\
\x19\x63\x77\x93\x78\x8e\xdc\x11\x26\x20\x2f\xee\x5e\xe4\x35\xae\
\x47\xeb\xb4\x8a\x96\x7b\x72\xd7\x20\x7a\xf0\x12\x52\x56\x9d\x80\
\xbf\x15\xf8\x36\x0a\xe3\x1c\x84\x94\xd3\x26\xb4\x7f\xf2\x7e\x44\
\x2b\x8a\x09\x16\x19\xbb\x67\xb5\xd5\xd7\x88\xf6\x1b\x6e\x43\x1e\
\xb7\xf9\xd6\xf7\x26\x94\xf9\x76\x3f\xa2\x25\x31\x0a\xab\x9e\x83\
\xe8\xd6\x43\xd6\xef\xdd\x28\x74\xbb\x14\x29\x2b\x01\x01\xdd\x85\
\x08\x25\x98\xfa\x35\x2d\xcf\xd1\x3e\x1a\xc8\xa0\xb5\xf6\x7f\x69\
\xa9\x50\x9e\x2c\x88\x90\x77\xda\x37\x04\x04\x74\x01\x41\x11\xee\
\x02\xce\x1a\x50\xce\x88\x9a\x52\xe2\x0e\x1c\x85\x94\x89\x22\xce\
\x19\x5c\x49\x79\x49\x86\x43\x8d\x0a\xe9\x5f\xbc\xed\x10\xfb\xeb\
\xf3\xd4\x54\x64\x09\xa7\x29\x05\x04\x9c\x90\xc8\x20\x45\xf7\xaf\
\x91\x12\x7c\x18\x09\x9e\x95\x28\x0c\xf2\x80\xdd\xe7\x84\xdf\x52\
\x24\x4c\xef\x44\x0c\xed\xeb\xc8\x83\xd3\x44\x92\x34\xc7\x31\xb8\
\xcd\x28\x5c\xeb\x76\x24\xc0\x7e\x87\x24\x19\x87\xcb\x2a\x79\xd0\
\x9e\x69\xb0\x32\x4a\x49\x04\x8e\x43\x5e\x99\x7e\xa8\x55\x40\xc0\
\xc9\x8a\x06\xe0\x7f\xa0\x7d\x84\x73\x69\x3f\x51\xd4\x14\xe4\x99\
\xbd\x08\x29\x8d\x79\xe4\x6d\xfd\x15\xcd\x3d\x37\xfb\xd1\xfa\x72\
\x88\x91\x02\x7d\x03\x0a\x5b\x74\xd7\x5a\xf3\x60\x65\x48\x32\xd7\
\xba\x36\x35\x92\x24\xbc\xab\xf7\x9e\xf5\x33\xda\xd2\x4a\x79\x37\
\x20\x0f\xf2\x7c\x9a\x87\x64\xa6\x3d\x59\x65\x88\x26\xb9\x3a\x0f\
\x22\x65\xbf\x80\x14\x60\xd7\xee\x20\x81\x04\x74\x05\x05\x92\xbd\
\xaa\x6e\x0e\x3a\x4f\x66\x6b\xeb\xa2\xa3\x68\xaf\x8c\x62\xbf\x1f\
\x0b\xa5\xdb\xef\xfb\xb1\x56\x48\x8f\x65\xff\x4e\x7a\x04\x6b\x42\
\x17\x70\x7a\xdf\x32\x2a\x4b\x33\x1d\xe2\x20\x85\x18\x46\xf6\x29\
\xa5\xca\x3b\x52\x69\xf3\xfe\x46\xf6\x37\xe4\xc3\x6c\x0e\x08\x38\
\x71\x91\x41\xc2\xec\x76\xfb\xec\xf7\x7e\x73\x82\xaf\xbb\x0f\xb4\
\x4f\xb0\x12\x85\x49\xee\x43\x82\x78\xb1\x7b\x9d\x10\xf1\x08\x52\
\x84\x37\x20\xc5\x38\x6f\xcf\x0f\x44\x56\xe1\x9b\x51\x82\x9f\xdb\
\xed\xd9\x95\x48\x41\x76\x82\x48\xba\xcc\x80\x80\x93\x1d\xeb\x51\
\x74\xc5\x8e\x76\xee\xcb\x21\xef\xee\x0f\x81\x0f\xa1\x50\xea\x0f\
\xa3\xb5\x35\x05\x29\xa7\x23\xd0\x7a\xf3\xd7\xa7\xcb\x90\x3b\x1d\
\xad\xb7\xfb\xec\x5a\xb9\xf7\x7b\x1a\xe9\xe7\x63\xb4\x17\xf8\x66\
\xb4\x7d\xc2\x29\xb5\xfe\xf3\x91\xf7\x9c\xfb\xeb\x0c\x60\xd3\x11\
\x2d\xf9\xa3\xb5\xaf\x9c\x44\x11\x19\x69\xf7\xe4\x90\xd7\xfa\x34\
\x14\xfe\x3d\x15\x45\x96\xbc\x44\x73\x85\x39\x43\xf1\x36\x07\x04\
\x74\x04\x05\xb4\x25\xe8\xe3\xf6\xf9\x30\xca\x5d\x91\x43\x11\x17\
\x73\x48\xd6\xc6\x91\x94\x7d\x16\x5a\x23\xc5\x92\x42\xc5\x68\x6b\
\xd1\x2c\x8e\xbd\x63\x2f\x46\xdb\x17\x2e\xed\x42\xff\x02\x7a\x00\
\x82\x47\xb8\x0b\xe8\x5b\x91\x23\x9b\x89\xc8\x77\x28\xdb\x55\x4c\
\x75\x69\x86\x8a\x92\x44\x16\xad\x6f\x8a\xd9\x5f\x1f\x12\xbe\x05\
\x04\x9c\xc0\xd8\x44\x22\xc0\xfa\xc8\xdb\xf5\xbd\xf6\xff\x52\x24\
\x78\x3e\x82\x98\xe7\x7b\xec\x9e\x87\x90\x02\xfd\x06\x89\xe0\xbe\
\x86\xc4\x53\xf4\x06\x0a\xa1\x7c\x0c\x31\xde\xf5\xe8\xe8\x95\x39\
\xc8\xeb\xd5\x84\xf6\x09\xef\x05\xfe\x01\x29\xcb\x73\x51\xa8\xf5\
\xeb\xc8\xf3\x0c\x0a\xa3\xec\x48\xe2\xa0\x80\x80\x53\x05\x55\x68\
\xed\xfd\x9e\xc4\xab\xba\x1e\x85\x40\x0f\x40\xd9\x5d\xaf\x43\x09\
\x77\x9e\x27\x59\x93\x0b\xd1\x3a\xfb\x2e\x0a\x29\x7e\x2f\xca\x1a\
\xff\x10\xf2\xbe\xbe\x80\xa2\x31\x1c\x62\xb4\x8e\x77\xa2\x08\x91\
\x57\xd0\x5a\x7c\x18\x25\x12\x7a\x0f\x52\x68\x1f\x26\x89\xe8\x00\
\xad\xe9\xf9\xc8\xb8\xf6\x1c\x5a\xd3\xaf\x20\x9a\xf3\x6d\x64\xfc\
\xba\xd3\xda\xb3\xde\xea\xfc\x0d\x52\xaa\x1f\xb7\x3a\x97\xa0\x30\
\xd1\xeb\x91\xb2\xfb\x53\x14\x56\xdd\x17\xed\x19\xc6\xc6\xc0\x85\
\x5a\x06\x04\x38\x74\xd4\x9b\x1b\x23\xc3\xcc\x30\xc4\xa7\xca\x51\
\x86\xe4\x32\xb4\x2e\xae\x42\x49\xa7\x0e\xd2\x7c\x3f\xae\x7f\xdc\
\x51\xfa\xba\xdb\x13\xdb\x84\x14\xe1\x41\x88\xaf\xf9\x6d\x71\x49\
\xe4\x6a\x80\xd9\x24\xeb\x2a\xeb\xfd\xee\x22\x30\x5c\xf9\x19\x9a\
\xef\xdf\xf5\xeb\x74\xed\xf0\xf7\xfd\x92\x7a\x2e\xdd\xd6\x1c\xa2\
\x15\x99\xd4\x6f\x90\x18\xbc\x0a\xa9\x6b\x01\x3d\x0c\x41\x11\xee\
\x02\x7c\xa5\xb6\x23\xc8\x66\x22\xca\x73\xc9\x33\x4d\x85\x98\xc3\
\x4d\x05\xa2\x66\xd1\x52\x01\x01\x01\x27\x10\xe6\x22\x26\x9f\x5e\
\xc0\xf5\xc0\xf7\xbd\xeb\xf7\xda\xdf\x18\x1d\x95\xe0\xf6\x4c\xb9\
\xdf\x7f\xe0\x7d\x7f\x02\x31\xd9\x1a\x14\x7e\xb9\x86\x44\xd9\x3e\
\x04\x7c\x95\x84\xf1\x7e\xc7\xfb\xee\xe0\xf6\x03\xde\xed\x95\xf9\
\x18\x21\x94\x2a\x20\xc0\xc7\x3e\xe0\xef\x69\x99\x00\xe7\x5b\x24\
\xc2\xf2\x33\xf6\xf7\x29\xef\xbe\x5f\x78\xdf\x3f\x4f\x73\xa1\x39\
\x02\xfe\x2d\x55\x66\x1e\xf8\x91\x77\xed\x3f\xec\xfb\xbf\xda\xff\
\xfe\xfa\xfd\x9d\xf7\xdc\x3a\x94\x6f\x20\x06\xfe\xc9\xfe\xfe\xa7\
\x57\xce\x8b\x34\x4f\xae\x13\xa3\x73\x90\x9d\x22\xf1\x82\xfd\x7d\
\x9a\xe4\xdc\x56\x57\xcf\x6f\xbd\x72\x16\xa1\x9c\x03\x41\x08\x09\
\x70\x88\x11\xff\xa9\x46\x86\xd8\x7c\x07\xee\x5f\x84\xf8\x5c\x84\
\xf2\x60\x8c\x45\x8a\xb0\x53\x10\xfb\x22\x4f\x71\x5f\xb4\x2f\x7e\
\x2e\x52\x74\xc7\x23\x8f\x6f\x23\xca\x08\xbd\x16\x79\x92\x67\x21\
\x65\x7a\x08\xcd\x23\xad\x40\x0a\xe5\x0c\xb4\x2f\xbf\x81\x24\xc2\
\xa2\x16\x19\x8d\x0a\xe8\x64\x86\x8d\x28\x62\xe2\x5c\xab\xeb\x05\
\x64\x34\x1a\x60\xbf\x57\x23\x83\xd1\x1a\x14\x31\x51\x81\x78\xec\
\xab\xd6\xa6\x11\xc8\x00\xf5\x1c\x32\x18\x5d\x60\xed\x3d\x88\xd6\
\xd4\x61\xb4\x37\x3f\x6f\xed\x9c\x6a\x6d\xdf\x80\x8c\x67\x59\xb4\
\xed\x62\x88\x5d\x7b\x91\xb0\x0f\xbf\xc7\x21\x84\xca\x75\x01\x1d\
\xf3\x04\x27\x88\xe3\xe6\xcf\xe4\x4c\x31\x8e\x03\xff\x09\x08\x38\
\x91\x11\x77\xe0\x7a\x7a\x1f\x5e\xa1\xc8\xef\xe9\x67\x47\x20\x61\
\xe0\x47\xb4\x14\x04\x0a\xad\x7c\xf7\xcb\x8a\x5b\xb9\x1e\x10\x10\
\xd0\xf6\xde\x58\x77\xbd\xad\x2c\xb3\xee\x7b\xa1\x03\x65\xb6\xb5\
\xd6\xdb\x7a\x3e\x6e\xe5\x6f\xba\xee\x62\xb4\xa5\xbd\x76\xd2\xc6\
\xff\x01\xa7\x2e\x5c\xc8\xef\x17\x50\x02\xc6\x8b\x68\x3f\x5a\x20\
\x46\x09\x1e\x6f\x44\xde\xe0\x73\x90\x32\xe9\xe6\x61\x19\x8a\x5c\
\x1a\x89\x14\xc2\x1b\x50\x48\xf1\x99\x68\x5b\xc2\x5e\xa4\x40\x7f\
\x1c\x79\x96\xdf\x89\x94\xdc\x9d\xc0\xd9\xb4\xcc\xfc\x7c\x09\x70\
\x35\x8a\x8e\x18\x4d\x92\x3b\xe3\x26\x74\xde\x76\x1f\x94\xd1\x7d\
\x10\x8a\x9a\xd8\x69\x6d\xb8\xd1\xee\xfd\x20\x52\xc8\xb7\xda\x33\
\x63\x81\x77\x21\x45\x7a\x0b\x52\x92\xcf\x43\x39\x3a\x4e\xb3\x3e\
\x8d\xb2\xbf\x1b\x91\x22\xed\x8e\x3e\x9b\x65\x7f\x6f\x45\x8a\xf4\
\x4a\xab\xdb\x6d\x45\xb8\x10\x19\x04\x2e\xb2\x71\x69\xcf\xa8\x10\
\x70\x8c\x11\x3c\xc2\x5d\xc0\xc1\xc6\x42\xa7\xd8\x47\x43\xbe\xf0\
\x56\xa2\x2c\x80\xd2\x6c\xd4\x6c\xcf\x70\x40\x40\x40\x80\x87\x05\
\xc0\x9f\x13\x84\xd4\x80\x80\x80\x80\x80\x63\x07\x17\xf2\xdb\x1f\
\x79\x77\x3b\x82\xbe\x48\x29\x75\xfb\xd3\x87\x21\x05\xb4\x80\x8e\
\xf3\x1a\x0a\xfc\x23\x52\x34\x9b\x80\x2b\x80\xe1\x48\xd9\xbc\xcf\
\x9e\x19\x83\xc2\x9c\xc7\x00\x5f\x43\x0a\xe4\x00\xa4\x98\x3b\x64\
\xd1\x9e\xe4\xa7\xd1\x76\x84\xcd\xc0\x1d\xc8\xd3\xbb\x05\x98\x48\
\x92\xb7\x63\x8d\xb5\x67\x02\xda\x42\xf0\x8a\xb5\xab\x3f\xf0\x5f\
\xc8\xc0\x3c\xd7\xfa\x78\x00\x6d\x4f\x58\x83\xb6\x29\xad\x47\x5b\
\x15\x9a\xac\xed\x11\x52\x74\xc7\xa3\xf3\x86\x57\x59\x7b\x5c\x88\
\xf6\x83\x48\x21\xee\x6d\xf7\x0e\x45\xde\xe2\xc1\x48\x99\x7e\xc6\
\x9e\x09\x42\x7f\x0f\x43\x50\x84\xbb\x80\x5d\x07\x9b\x68\x2a\xc4\
\x1d\x3a\xfe\x28\x8a\x22\x36\xef\x6f\xe4\x40\x43\xa2\x08\xf7\xad\
\xc8\x51\xdd\xc1\x64\x5b\x01\x01\x01\xa7\x24\x02\x79\x08\x08\x08\
\x08\x08\x38\x56\x88\x90\x87\xf6\x7f\x23\x8f\xea\x9b\xb4\xaf\xbc\
\x45\x28\xec\xd7\x6d\x2b\x98\x4e\xb2\x77\x1e\xa4\x6b\xb8\x33\x85\
\x23\x14\x1e\x9c\x43\x5e\xda\x3a\xbb\xa7\x80\xc2\xa3\xcb\xed\x1e\
\x77\x6f\x43\xaa\x2e\x97\xdc\xad\xd1\x7e\x6f\xf4\x9e\x7d\x19\x79\
\x5e\x1b\x90\xd2\xbb\x1d\xf8\x1e\x4a\x28\xe9\x3c\xb4\x0f\x5b\xd9\
\xee\x24\x85\x5e\x48\xd1\x3e\x68\x65\xe4\x90\x97\x77\x22\xda\x63\
\xef\xb2\x42\x6f\x41\x7b\xf3\x27\x22\x65\x7d\x0a\xda\xe6\x14\xa3\
\x7c\x03\xb7\xda\x7d\x2b\xac\x9c\x2c\x4a\x4c\x77\x10\x29\xcf\xb7\
\xa1\x70\xe9\x5f\x1e\xef\x17\x1c\xd0\x1c\xc1\x32\xd1\x05\xac\xdb\
\xdb\xc0\xc1\xc6\x42\x87\x37\xde\x2d\xde\x76\x98\xba\x86\x24\x2a\
\x62\xec\xc0\x72\x7a\x95\x85\xa3\x93\x02\x02\x4e\x60\x8c\x01\x3e\
\x07\xfc\x85\xf7\x99\x83\xac\xd0\x5d\x45\x06\x31\xcf\x11\x9d\x78\
\xa6\x37\xb2\x8e\x97\x1d\xef\x81\x09\x08\x08\x08\x08\x38\x61\xb1\
\x0a\xed\xa9\x3d\xd8\x81\x7b\x33\x68\x1f\xec\x24\x14\xfe\x3b\x0d\
\x79\x83\x1b\x90\x62\xb9\xc5\xca\x99\x83\x42\xa8\xaf\x44\x11\x4f\
\xaf\xda\x33\x2e\x73\xfa\x50\xab\x73\xb3\xdd\x3b\x01\x85\x29\xfb\
\xba\x4a\xa3\x3d\x3b\x13\x85\x4d\x5f\x86\xbc\xd1\x11\x52\xda\x6b\
\x11\xcf\x7c\x13\x79\x7f\xaf\x47\xfb\x97\x1f\x45\x0a\xef\x0e\xa4\
\xbc\x3a\x65\xf7\xc3\x48\xe1\x77\xa2\x7c\x8e\x44\x09\x7e\x01\xf1\
\xd2\x52\xe4\xed\xbe\x1c\xe5\xeb\x78\x0a\x85\x5f\xbb\x13\x1a\x6a\
\xec\xf7\xa7\x90\x87\xbb\xc6\xda\x3c\x0b\x85\x54\x3f\x82\x12\x66\
\x0e\x20\xe4\xea\xe8\x71\x08\x1e\xe1\x2e\x60\xe9\xf6\xc3\xac\xd9\
\x5d\xcf\x39\x83\x2b\xc9\xb7\xa1\xcd\x46\x40\x5d\x43\x9e\xc7\x57\
\xed\xc3\x6d\x11\x8e\x22\x38\x77\x48\x05\x65\xb9\x4c\xa7\xf7\x1a\
\x07\x04\x04\xf4\x18\x8c\x45\x0c\xf9\x1b\xc8\xc2\x3c\x00\xf8\x4b\
\x64\x0d\xfe\x63\x17\xcb\xce\x02\xef\x40\xfb\x98\xd6\x77\xf0\x19\
\x17\x92\x16\x8c\x9c\x01\x01\x01\x01\x01\x47\x8a\x8e\xf2\x90\x08\
\x85\x0a\x5f\x8c\xf6\xf6\x82\x14\xdf\xff\x46\x49\x23\x17\xa0\x0c\
\xe5\x3f\x40\x19\xa4\x6f\xb6\xfb\x5d\x96\xf5\x5e\x28\x4c\x3a\x0f\
\xfc\x0c\x29\x8c\xfb\x50\xc6\xf6\x6b\x91\x42\xbe\x8a\x44\x81\x74\
\xa7\x2f\x64\xd0\xfe\xde\xfd\x24\xfb\x91\x77\xa2\xd0\xe6\x3a\x60\
\x0f\x4a\x7c\xb5\xd4\xca\x6a\x42\x89\xee\x96\xa0\x23\xd3\xae\x42\
\x0a\xef\x63\xd6\xc6\xe1\xd6\xde\x06\xe0\x1e\x6b\xd3\xb5\xe8\xc4\
\x85\x1d\x68\x6f\xf3\x46\x6b\x7f\x3d\xf0\x13\xc4\x9b\x97\x22\xfe\
\x7c\x3f\xf2\x14\x6f\x43\x61\xdb\x3b\x91\x32\x7e\x23\x32\x4e\xef\
\xb6\x3e\x87\x33\x80\x7b\x18\x82\x22\xdc\x05\x6c\xaf\x6b\xe4\x97\
\x6f\xee\xe2\xec\x41\x15\x6d\x86\x47\x67\x32\x11\xcf\xad\x3d\xc0\
\x0b\x6b\x0f\xbc\x75\x6d\x70\x75\x09\xb3\x47\xf5\x22\x0e\xee\xe0\
\x80\x80\x13\x1d\x6b\x10\x83\x73\xb8\x18\x31\xd8\xc7\x51\x28\xd6\
\x39\x28\xbc\xea\x31\x64\x99\xbe\x12\xed\x35\x1a\x89\x18\xec\x7d\
\x68\x7f\xd2\xf9\xc8\x82\x7c\x18\x31\xfa\xb5\x48\x38\x28\xa0\xd0\
\xab\xab\x90\x75\xf9\x00\xf0\x07\x64\xa5\xbe\x19\x29\xcc\x59\xc4\
\xfc\x7f\x6b\xcf\x65\x91\x25\xbc\x04\xed\x4f\x5a\x0f\x3c\x80\x18\
\xf8\x85\x48\x79\xdf\x87\xf6\x35\x6d\x3a\xde\x03\x18\x10\x10\x10\
\x10\x70\x42\x22\x83\xf8\xc8\x43\x24\x0a\x9e\x0b\x7d\x8c\xd0\x91\
\x5d\x31\x52\x28\xbf\x6d\xf7\xfb\xbf\x3f\x8e\x3c\xa9\xee\xb9\x0c\
\xe2\x49\xdf\xf3\xee\x75\x67\x69\xbb\x67\x0e\x22\x5e\x97\x25\x49\
\xe4\x55\x82\xf8\x6e\x0d\x89\x11\xba\x11\xf1\xbd\x87\xad\x0d\xae\
\xfc\x15\x28\xa9\x55\x06\x29\xc8\x19\xa4\xd8\xba\xe3\xa2\x5e\x47\
\x4a\xac\x6b\x93\x3b\x0a\xe9\x77\xde\x77\x57\xd6\xef\xec\xff\x07\
\xac\xde\x82\x7d\x5c\xdb\xbe\xe3\x7d\x0f\x4a\x70\x0f\x44\xf0\x1a\
\x74\x01\x85\x18\x7e\xf6\xfa\x2e\x1e\x5f\xb5\x8f\x6c\x26\x2a\x3a\
\xbb\x73\x99\x88\xe5\x3b\x0e\xf3\xcf\x4f\x6d\x61\xcf\xe1\x24\x2c\
\x7a\xce\x98\xde\x8c\x1d\x50\x4e\x70\x06\x07\x04\x9c\xd0\x88\x51\
\x48\xd4\x6d\x28\xa3\xe4\xc7\x51\x98\xd5\x63\x48\xb1\xbd\x1d\x59\
\xa0\x73\xc0\x5f\x23\xeb\xf7\xed\xc0\x2d\x48\x81\xbe\x0e\xed\x2d\
\x3a\x0f\xf8\x22\xb2\x26\x47\xc0\xff\x42\x16\x6a\xc7\x3c\xaf\x47\
\xfb\xae\x16\xa0\x73\x15\x3f\x8d\x14\xe2\x05\xe8\xe8\x93\x8b\x51\
\x98\x58\x05\xb2\x3e\x57\xa1\x33\x4e\x2f\x43\x02\xc8\xbb\x50\x58\
\xd7\x54\xe0\x53\x76\xad\x1c\xf8\x2b\x24\x38\x04\x04\x04\x04\x04\
\x04\x1c\x29\x5c\x66\x72\x77\x9c\x57\xe4\x5d\xc7\xfb\x3f\xfd\xbb\
\x3b\xee\xcb\x3f\xb3\x38\x7d\x6f\x1a\xe9\xb3\x7e\x63\x64\x18\xbe\
\x14\x1d\x67\xb8\xc2\x2b\xcb\x3f\xe3\xb7\x58\xf9\x19\xaf\x0c\xbf\
\x7c\xbf\x4d\x7e\x1f\xd2\x65\xa5\x7f\xf3\xfb\x94\x6e\x67\x50\x82\
\x7b\x20\x82\x47\xb8\x8b\xd8\x79\xb0\x89\x2f\xff\x71\x23\x75\x0d\
\x05\xae\x3e\xb3\x86\xca\xd2\xcc\x5b\x33\xbd\xb1\x10\xf3\xea\xc6\
\x3a\xfe\xe1\x89\xcd\xcc\xdd\x58\xf7\xd6\x33\xa3\xfb\x95\xf1\xe1\
\x29\x03\x29\xc9\x46\x41\x11\x0e\x08\x38\xf1\x51\x81\x94\xdf\x33\
\x51\x68\xd4\xe7\x81\xd7\xd0\xbe\xa5\xef\xdb\xef\x4d\x28\x64\xb9\
\x06\x79\x7c\xef\x41\x56\xf4\x81\x28\x91\x46\x2d\xb2\x42\xff\x14\
\x31\xcb\x49\x48\xf1\x75\x8c\xfa\x59\xe4\xe9\xed\x85\xac\xdc\x63\
\x90\x47\xf7\x31\xa4\xf8\xee\x44\x67\xa2\xfa\x16\xf4\xbd\xc8\xca\
\xfd\x32\xda\x6b\x35\xce\xda\x52\x8d\xb2\x66\x66\xd0\xb9\x88\x67\
\x20\xe1\x21\x20\x20\x20\x20\x20\xe0\x44\x43\x84\x22\xa2\xbe\x49\
\xeb\xca\x73\x40\x40\x51\x04\x45\xb8\x0b\xa8\x2c\xc9\x50\xdf\x14\
\xb3\x7c\xe7\x61\x3e\xf3\x87\x75\x5c\x72\x7a\x2f\x66\x8c\xac\x66\
\x64\x9f\x52\x0e\x35\x16\x78\x65\x43\x1d\x0f\x2e\xdb\xcb\x86\xbd\
\x49\xd2\xbb\x9a\xf2\x2c\x7f\x31\x73\x30\x93\x06\x57\x04\x25\x38\
\x20\xe0\xc4\x47\x84\x3c\xb2\xdf\x40\xf4\xf4\x2b\xe8\xdc\xc2\xe7\
\x51\xf6\xca\x77\xa3\x10\xab\xc3\x24\xa1\x54\x87\x48\xce\x05\x76\
\x4c\xbb\xd4\xee\x01\x59\x92\x0f\xd3\x3c\xe1\xd5\x4d\x48\x31\x9e\
\x8f\x94\x6a\x87\xcb\x91\x77\xf9\x6f\xd1\x7e\xa5\xa1\xde\x6f\x07\
\x91\xd7\xd8\xaf\xa7\x04\x79\x9d\xb7\xdb\xff\xff\x4e\xc7\xf7\x1f\
\x07\x04\x04\x04\x04\x04\xa4\xe1\xbc\xa4\x3e\x32\x1c\x3d\x85\xd4\
\xf7\xe4\xfa\x48\x87\x1e\xfb\x5e\xdd\xb4\x27\xba\x33\x75\x1d\xc9\
\x73\x47\xbb\xaf\x01\xdd\x84\xa0\x08\x77\x01\xd7\x8d\xad\x21\x8a\
\x22\x7e\xbd\x60\x17\xfb\x0e\xe7\xb9\x7f\xc9\x1e\xee\x5f\xb2\x87\
\x6c\x14\x51\x20\x6e\x91\x0d\x7a\x40\x65\x8e\x2f\x5d\x36\x84\x3b\
\x26\xf5\x0d\x87\xa2\x04\x04\x9c\x1c\xc8\x20\x3a\x9a\x43\x0a\xea\
\x37\x81\xbb\x51\xa8\xf4\x28\xb4\x07\xf8\x77\x68\x5f\x70\x15\xc9\
\x5e\x27\x3f\x2c\xcc\x1d\x3d\xf1\x31\x94\x6d\xb3\x2f\xf2\xd2\xfe\
\x37\x4a\xd6\x91\x43\x4a\xf5\x3c\xb4\x77\xf8\xc3\x76\xed\x3c\x14\
\x6e\xfd\x13\xa4\x64\x8f\x4e\x95\xef\xd7\x93\xb5\x7b\x5e\x45\x09\
\x4d\xd6\xa1\xc4\x5e\xb3\xd0\x1e\xad\x80\x80\x80\x80\x80\x80\xce\
\x22\x46\x79\x30\x2e\xf2\xae\x6d\x43\x51\x4c\x3b\xe8\x7e\x05\xb2\
\x0c\xf1\xc9\x79\xc8\xa0\xdc\x5a\xf9\x31\x8a\x7e\x1a\x8a\x92\x73\
\x5d\x80\x92\x76\xad\xe9\x44\x9b\x22\x94\xe7\x63\x25\xca\x64\x7d\
\xac\x95\x61\x97\xe3\x63\x1d\x2d\x8f\x91\x0a\xe8\x26\x9c\xd2\x8a\
\x70\x04\x14\x52\xda\x6a\x5b\x19\x9c\x63\xa0\xc9\xfb\x7d\x60\x55\
\x09\x7f\x71\x49\x2d\x7d\x2a\xb2\xfc\xf2\x8d\x5d\xec\xb5\x3d\xc0\
\xe9\x0c\xd2\xa5\xd9\x88\x69\x23\xaa\xf9\xe4\x45\x83\xb8\xfc\x8c\
\xde\x64\xa3\xa0\x07\x07\x04\x9c\x24\xd8\x04\xcc\x25\x59\xd2\x9b\
\x81\x7f\x45\xfb\x83\x7f\x87\xb2\x3e\xbf\x1f\xed\x59\xfa\x2d\x52\
\x46\x5f\x43\x02\x02\x68\xaf\x6e\x23\xca\x32\xe9\xf6\x0f\x37\x5a\
\x19\x8b\xd1\x39\x84\x5b\x80\xff\xb4\xb2\xde\x89\x12\x6e\xad\x45\
\x0c\x72\x13\xca\x5c\x3d\x16\x85\x86\xfd\x0e\x79\xa3\x0f\x21\x41\
\x61\x9f\xd5\xb3\xd8\xea\xfe\x23\x50\x89\x3c\xd5\x79\x94\xe0\x63\
\xe7\xf1\x1e\xc4\x80\x80\x80\x80\x80\x1e\x85\xf4\xbe\xdd\xd6\x50\
\x40\x8a\xf0\xe9\xc0\x13\x48\xb4\x9e\x8c\xb6\xe3\x7c\x15\xf1\x22\
\x68\xb9\x5f\x16\x12\x43\xb0\xef\x51\x8e\x68\xbe\xaf\xd7\x5d\x73\
\xed\xa9\x46\x7b\x81\x97\xa0\xcc\xd0\x19\x5a\x7a\x7c\xdd\x99\xc5\
\x13\xec\xde\x7f\x42\x8a\xf0\x52\xa4\x14\x67\x69\xbe\xc7\x37\xbd\
\x8f\xd9\x79\x96\xb3\x40\x3f\x94\x2d\x3a\x4e\xdd\x9b\xf6\x78\xbb\
\x3d\xd2\xe9\x3e\xf8\x6d\xf2\xbd\xd3\xe9\x72\xd2\x5e\xf5\x08\x1d\
\x49\xf5\x4e\xe0\x6b\x28\x4a\x2c\x3d\x46\x01\xdd\x80\x53\x5a\x11\
\x2e\x10\x33\x63\x64\x35\x5f\x98\x3d\xe4\xad\x6b\x83\xab\x4b\xa8\
\x28\xc9\xb4\xf0\xe6\xc6\x71\xcc\xe8\x7e\x65\x7c\xee\x92\x21\x34\
\x9a\x32\x3c\x65\x78\x15\x03\xab\x4a\xf8\x9f\x57\x0c\xe3\xea\x31\
\xbd\x79\x60\xd9\x5e\x5e\xdf\x7c\x88\xdd\x87\x9a\x88\x63\xa8\x2e\
\xcb\x30\x6e\x60\x05\x73\xc6\xf4\xe2\xb2\xd1\xbd\x19\x54\x55\x42\
\x3e\x8e\x83\x12\x1c\x10\x70\xf2\x60\x2e\x52\x38\xfd\x65\xfd\x10\
\xca\x52\x59\x40\x61\xd1\x8e\xf1\x81\x18\xd8\x8f\xbc\x7b\x9d\xe0\
\xe0\x32\x52\xfe\x9e\xe6\xcc\xf6\x6b\xde\xf7\x57\x48\x18\xa6\x63\
\xc0\xbf\xa6\x39\x43\x2c\x00\x6f\xd8\x33\xdf\xf7\x9e\xfd\xad\x77\
\xcf\x2f\xed\x39\xbf\x9e\x80\x80\x80\x80\x80\x00\x10\x5f\xe8\x83\
\x94\xce\x2d\x24\x59\x9e\xdb\xba\x7f\x31\x32\xac\xc6\x48\x49\xfd\
\x1c\x8a\x8a\x1a\x89\x72\x53\xec\x41\xfc\x72\x2a\x4a\x04\xb9\x89\
\xe4\x9c\xe2\xb3\x91\x32\x5d\x8a\x12\x40\xbe\x81\xb6\x02\xd5\x20\
\xc3\xed\x4a\xe4\xd9\xad\x40\x5b\x80\x22\x2b\xa7\x06\x19\x85\x5f\
\x45\x09\x23\x17\xa3\xad\x3e\x43\xac\xbc\x71\x48\x19\xbe\x80\x24\
\xb1\xe5\x20\x64\x6c\x7e\x12\xf1\xce\x73\xad\xde\x41\xd6\xbe\x41\
\xc8\xc8\xfc\x8a\xf5\x63\x07\x52\xe6\x4b\x90\x27\x7a\x34\xf2\x78\
\x3f\x4f\xe2\x91\x8e\x51\xc4\xd7\x0c\xab\x7b\x95\x3d\x7f\xa1\xdd\
\xeb\xce\x16\x9e\x86\x3c\xe5\xc3\x81\x29\xc8\xcb\xfb\x22\x52\xb4\
\x67\x5a\x1d\x43\xd0\x51\x4b\xcf\x58\xdb\xce\xb6\x72\x5f\x41\x5e\
\xf7\xfe\x36\x1e\x2f\xd3\x7c\x9b\x54\xc0\x11\xe2\x94\x56\x84\xe3\
\x18\x66\x9c\x56\xcd\xcc\xd3\x7b\x25\xd7\x28\xee\x15\x2e\xc4\x4a\
\x72\xf5\xb9\x59\x83\xbd\x6b\x31\xf9\x42\x4c\x79\x2e\x62\xce\x99\
\x35\xcc\x1e\xdd\x9b\xba\x86\x3c\xfb\xeb\x0b\xc4\xc4\x54\x95\x66\
\xa9\x2e\xcd\x50\x96\xcb\xe8\xde\x70\x54\x52\x40\xc0\xc9\x88\x62\
\x0b\xbb\xd0\xca\xf7\xb8\x9d\xe7\x0b\x6d\xfc\xe6\x2b\xae\xfe\xf5\
\xd6\x84\x94\xb6\x08\x4e\x81\x80\x80\x80\x80\x80\x80\xe6\x70\x5e\
\xd7\xcf\x23\x65\xf2\x5f\xd0\xf1\x46\xed\x79\x20\xab\xd0\x76\x9b\
\x0c\xf2\x08\x1f\x46\x3a\xc6\xfb\xd0\x11\x81\xcb\x51\x3e\x8b\xe1\
\x48\x19\xbc\xc8\xbe\x3f\x6c\xd7\x5f\x42\x61\xcf\x1f\x00\xfe\x0f\
\x3a\xc7\xb7\x0c\x19\x87\x87\x00\xef\x01\x7e\x8c\x14\xea\xfe\xc8\
\x03\xfd\x26\x3a\x42\xf0\x20\x52\xba\x07\xa1\xad\x49\x17\x5b\x5b\
\xb6\xa1\xa4\x91\x3b\xac\xac\xf1\xc8\xe0\x7c\x09\x8a\xc0\x7a\x16\
\x78\x2f\x3a\x8e\x30\xb6\x3e\x3f\x80\x14\xd4\xf7\x58\xdf\x67\xa0\
\x68\xab\x49\xf6\xfd\x71\xeb\x5f\x89\xf5\xcb\x79\x8e\xdd\x69\x0d\
\x73\xad\xfc\xde\x48\xc1\x76\x9e\xe8\xf3\xec\xb3\x1e\x45\x64\x3d\
\x8d\x94\xfc\x0f\x00\xdf\xb2\xfe\xc6\xc8\x38\x7e\x8d\x8d\xe3\x4e\
\xa4\x6c\x6f\x01\xae\x46\x49\x35\x5f\xb1\x7b\x77\xa1\xe8\xb0\xe0\
\x19\xee\x22\x4e\x69\x45\x18\xa4\xe0\x16\x3a\xa8\xa0\xc6\x31\x34\
\x15\xb9\xd7\x29\xcf\x99\x08\x7a\x97\x65\xa9\x29\xcf\xbe\x75\x3d\
\x8e\xdb\x0e\xb7\x0e\x08\x08\x08\x08\x08\x08\x08\x08\x08\xe8\x21\
\xc8\x21\x65\xb3\x2f\x52\x18\xdb\x43\x8c\x4e\x4c\x18\x89\x14\xc3\
\x7a\xe0\xe7\x48\x89\xdb\x8e\x72\x5b\x1c\x42\x4a\xdf\xf7\x90\xc7\
\x77\x3d\xf0\x19\xa4\x08\xff\x06\x29\x85\x83\x91\x02\xd9\x1f\x79\
\x6d\xe7\x21\xcf\xe8\x1c\xe4\xf9\x75\x5b\x7b\xf6\x22\xe5\x75\x39\
\xf2\x98\x0e\x01\x9e\x43\x61\xc4\x83\x91\xc2\x7b\x0f\x0a\x6b\xde\
\x6a\xcf\xe6\x91\x12\xfb\x88\xb5\x71\x26\xc9\x99\xc5\x0f\xa1\x13\
\x1c\xa6\x59\x1d\x65\x48\xd9\xad\x22\x39\x47\x78\xba\x3d\xfb\x14\
\xf2\x40\x97\x93\x1c\x93\xd4\x87\x24\x99\xe5\x40\x1b\x93\x19\xc0\
\x77\x91\xe7\x77\x88\x95\xf7\x32\x52\xa8\xfb\x23\x63\x43\x0e\x79\
\x9f\xcf\xb0\xf1\x79\x16\x79\xaa\x07\x00\x23\x90\x87\x7b\x1b\xda\
\x5a\x75\x86\x5d\xdb\x88\x4e\x8b\xd8\x44\xc8\x8e\xdd\x2d\x38\xe5\
\x15\xe1\xee\x86\x53\x7e\x03\x02\x02\x02\x02\x02\x02\x02\x02\x02\
\x4e\x20\xb8\xa3\xf7\xfe\x09\x29\x75\x0b\x68\xdf\xeb\x18\x21\x05\
\xee\xe7\xf6\xfd\x30\xf2\xd2\x8e\xb6\xbf\x79\xe4\x41\xcd\x20\x6f\
\xab\xfb\x0b\x52\x04\xaf\x43\x0a\xde\x56\xa4\x00\x67\x50\xd8\xef\
\x41\x92\xa4\x8f\x87\x48\x32\x28\xd7\x5b\x1d\x59\xbb\x96\x45\xca\
\x62\x03\xf2\x9c\xe6\x51\xf8\xf0\x40\xaf\x7d\x4d\x48\x31\xcf\x7a\
\xd7\xdc\xb1\x4b\x4e\xd9\x6d\xb4\xfb\x2a\x68\xb9\x5f\x37\xe7\xb5\
\xb9\x04\x29\xab\x7b\xed\x3e\x97\x8c\x72\x1b\xf2\x58\xbb\x44\x5e\
\x1b\x90\x37\xf7\x4a\xa4\x2c\xbf\x09\x5c\x6f\xf7\xec\xb0\xbe\xfc\
\x0a\x25\xf0\xba\xc8\xda\x92\xa5\xe5\xfe\xe1\x0c\x52\xe2\xb7\x22\
\x25\x7f\x16\x32\x04\x3c\x44\x50\x86\xbb\x8c\xa0\x08\x07\x04\x04\
\x04\x1c\x19\xca\x80\x77\x91\x58\xc1\x41\x0c\x6c\x33\xf0\x03\x8e\
\x3c\xcb\xe3\x79\x88\x11\xbf\x50\xe4\xb7\x0c\x62\xf4\x2e\x61\x96\
\xc3\x48\x94\x30\xeb\x31\x42\xd8\x73\x40\x40\x40\x40\x40\xd7\xb0\
\x0a\x29\x93\x1d\x39\x06\xc9\x79\x81\x77\x7b\xf7\xbb\x8f\x53\x64\
\xf7\xa1\xe4\x90\x57\xdb\x33\x97\x23\x1e\xd6\x1b\x79\x79\x1f\x41\
\x7c\xac\x17\x89\xf2\x17\x79\xe5\x67\x53\xdf\xfd\x93\x17\x32\x48\
\x89\x7c\x1d\x85\x1d\xff\x08\x29\xd1\x8d\x24\x1e\xe6\xa8\xc8\x33\
\x78\x7f\xfd\x72\xa3\xd4\xef\x4d\x88\xe7\xce\x42\x21\xc9\x57\x20\
\xfe\xbe\x9c\xc4\x70\xb0\x06\x79\x79\x5f\x41\xde\xf1\x5e\x88\x87\
\xbf\x02\xfc\x05\xf2\x7c\xef\x40\x5e\xde\x49\x48\x19\xce\xa1\xbd\
\xce\x0b\x5b\xe9\x6f\x13\xf2\x3c\x0f\x42\x21\xd6\x0d\x56\x4e\x7f\
\xfb\x04\x74\x03\x42\x6c\x79\x40\x40\x40\xc0\x91\xa1\x80\x18\xf9\
\x62\xe0\x4c\xa4\x88\x2e\x46\x02\x44\x63\x17\xca\xad\x41\x21\x69\
\xad\x61\x10\x52\x94\x7d\x0c\x07\xae\x22\xd0\xf4\x80\x80\x80\x80\
\x80\xae\x23\x43\x73\x85\xb3\x35\x44\xe8\x78\x9f\x35\xb4\x54\xe6\
\xea\x50\x18\x74\x23\xf2\x98\xba\x70\xe9\xb7\xd9\xb5\x9f\xa2\x64\
\x51\x6f\x00\x37\x21\x2f\xeb\x43\xc8\xfb\xbb\x14\x85\x55\x67\x90\
\x02\xb9\xd0\xca\x6d\xb4\xef\x87\xac\x8e\x95\xc8\x9b\x1c\xd9\xf5\
\x5d\xe8\x64\x86\x8c\x95\xb1\x06\x19\x97\x57\x7b\xe5\x6d\x43\x8a\
\x6d\x1d\xe2\xd9\x05\xe0\x80\x3d\xd7\x84\xbc\xcd\x6f\xd8\xdf\x65\
\x24\xa1\xd8\xeb\xd1\x7e\xe6\x43\x68\xef\xb2\x43\x3d\xf0\x43\x2b\
\xfb\x76\xa4\xe0\xbe\xe8\xb5\xe9\x69\x14\xf6\x1c\xa1\xf0\xe9\x3f\
\x20\x43\xc0\x2c\xb4\x37\x7a\xab\x57\x4f\xc6\xfa\xb3\x12\x79\x93\
\xe7\xa3\x53\x28\xe6\xa1\x3d\xc2\x6f\xb7\x76\x3c\xd8\x81\x77\x13\
\xd0\x01\x04\x8f\x70\x40\x40\x40\xc0\x91\xa1\x91\xe4\x0c\xde\xe1\
\x48\x68\xf8\x25\x62\x4e\x97\xa3\x3d\x41\x3b\x10\xc3\xda\x8a\xf6\
\x2e\x5d\x8f\x42\xa4\x5e\x40\x8c\xf2\x0c\xe0\x32\xa4\xfc\x2e\x41\
\xfb\x93\x76\x23\x46\x3b\x0c\x59\x96\x0b\xf6\xfd\x51\xc4\x9c\xb7\
\x20\x06\x5e\x0e\xdc\x80\xf6\x0d\xb9\x70\xaa\x02\x62\x96\xae\x9e\
\x17\xed\x13\xbc\xc4\x01\x01\x01\x01\x01\xdd\x8d\x0c\x52\xf2\xa0\
\xb9\x62\x16\x21\xc5\xf3\xa7\xde\x7d\x3b\x50\xc2\x2b\x17\x4a\xec\
\xf0\xc3\xd4\xb5\x0c\x52\x50\x41\x7a\xca\x62\xfb\xb8\x10\xe9\x5f\
\x7b\x75\x3c\x6c\xdf\x6b\xd1\x7e\xdc\xd7\x51\x54\x56\x16\x29\xc5\
\xdf\x20\xc9\xec\x9c\x2e\x0f\x92\x13\x15\xb6\x59\x3b\x40\x9e\xd7\
\x9f\xd8\xf7\x3f\xd8\xdf\x18\x85\x31\xfb\xed\xf4\x95\xfe\xad\x28\
\x12\x2c\xdd\x8f\x03\xe8\xf8\x43\xf7\x7f\x01\xed\x33\x76\x63\x96\
\xb7\xeb\xf7\xd9\xff\x59\xb4\x07\xd9\xe1\x27\xf6\xbb\x0b\xf7\xce\
\x14\xa9\x3f\xa0\x0b\x08\xde\x83\x80\x80\x80\x80\xae\xc3\x59\xcf\
\x41\x16\xe3\x0f\xa0\xb0\xa9\x11\xc0\xdf\x20\x25\xf8\x4b\x28\x79\
\xc7\x6a\x94\x49\xf3\x5c\xe0\xa3\x48\xa1\x5e\x0c\x7c\x0c\x85\x49\
\x4d\xb2\xbf\x43\x51\x16\xcb\x12\xc4\x4c\xbf\x8c\x98\xfd\xd5\x56\
\xee\xbb\xd1\xde\xa3\x55\xc8\xe2\xdd\x0b\x85\x81\x7d\xd9\xfe\x2e\
\x03\x3e\x8c\x32\x58\x06\x04\x04\x04\x04\x04\x1c\x4f\xf8\x67\x09\
\x47\xa9\x4f\xfa\xcc\xdd\xce\x20\x06\xc6\xa0\xa4\x54\xf7\xd3\xfc\
\xb8\x42\x8e\xa0\xbc\x8e\xb6\xbd\x33\xbf\xfb\x70\x49\xb6\x3a\x72\
\x4e\x33\x34\x3f\x32\xb1\x23\xe5\x07\x74\x02\xc1\x23\x1c\x10\x10\
\x10\xd0\x3d\x88\x11\x73\xba\x1a\x1d\xd1\x70\x2f\xb2\xfc\x7e\x03\
\x25\x03\x19\x80\x94\xe1\x03\x28\x54\xaa\x01\x59\x90\x6b\x90\x82\
\x5b\x86\x12\x87\x14\x48\x98\xdd\x02\x64\x51\xaf\x46\x5e\xe6\x81\
\x28\x74\xab\x12\x25\xd7\xb8\xdb\xca\xaa\x43\xa1\xd1\x67\x21\x25\
\x7a\x15\x52\xbe\xdd\x73\x4f\x1d\xef\xc1\x09\x08\x08\x08\x08\x08\
\x38\x0a\x88\x50\x46\xe6\x97\x49\xf8\x70\x40\x40\x87\x10\x14\xe1\
\x80\x80\x80\x80\xee\x45\x0e\x85\x6f\x41\xf3\x2c\x94\x79\x92\x90\
\xa6\xbe\x48\x49\xfd\x38\xda\x17\xb4\x04\xed\x47\x72\xa1\x53\x90\
\x24\x18\x71\xa1\x53\x79\x5a\x26\xd3\x70\x7b\x91\x1b\xec\xb9\x12\
\x94\x24\x64\xa3\x95\xf7\x6b\xa4\x14\x07\x04\x04\x04\x04\x04\x1c\
\x2d\xb8\xad\x39\x0e\x6e\xbf\x70\xfa\xba\x83\x9f\x90\x0a\x9a\x87\
\x4a\x17\xfb\xbd\x2d\xa4\x3d\xcc\x47\x03\x2e\x63\x75\x67\x3c\xb9\
\x6d\x8d\x95\x5f\x46\x81\xc4\x6b\x1d\xb5\x72\xdd\x87\x2f\x27\xa4\
\xc7\xab\xad\xf6\xa5\x7f\x6b\xed\xdd\x74\x24\x41\x5a\x77\xf4\xfb\
\x68\x3f\xd7\x21\x04\x45\x38\x20\x20\x20\xa0\xeb\x70\xa1\xd1\x31\
\xda\x93\x7b\x13\x3a\x3a\xe1\x7c\xbb\xfe\x08\x3a\x67\xf0\x66\xa4\
\x98\xfe\x09\x3a\x1f\x71\x34\x0a\x9d\x2e\x21\xc9\x6c\xe9\x32\x5a\
\xa6\x33\x65\xe6\xbc\x6b\x87\xd0\x51\x0c\xb7\x22\xc5\xf7\x36\xb4\
\x67\x78\x35\xda\xab\x94\x43\xfb\x89\xde\x83\x14\xed\x80\x80\x80\
\x80\x80\x80\xa3\x81\x18\x19\x77\xa7\xa0\x48\xa4\x7d\xc0\x5c\x94\
\x44\x6b\x24\x8a\x56\x72\xfc\xcb\x29\x76\x2f\xa1\xe4\x54\x11\x50\
\x0a\x5c\x8b\x22\xa3\x40\xc6\xe3\xc5\x28\xe3\x72\x53\x07\xea\xbe\
\x08\xf1\x39\xb7\x8f\xb8\xbb\x51\x82\xa2\xb5\xd6\xa2\xbc\x1e\x15\
\xd6\xbf\x23\x51\xcc\x62\xb4\x75\xe9\x2c\xeb\x7f\x0c\x4c\x04\x26\
\xd8\x18\x2d\xb7\xeb\x0d\x28\x9a\xeb\x2c\x7b\xce\x8d\xdd\x41\x74\
\x3a\xc4\x4c\x92\xa4\x9a\xf5\x68\x6f\xf4\x6b\xc0\xe9\x28\x62\x6c\
\x51\x6a\x2c\x62\x14\x7d\x36\x1e\xed\x41\x6e\x04\x46\xa1\xed\x55\
\xbe\xd1\x02\xe0\x79\x94\x8f\xa4\x3b\x15\xcf\x18\x45\xb4\x8d\x43\
\x39\x52\xf2\x9d\x78\x6e\xb4\xf5\x75\x2e\x47\xe1\xfd\x86\x3d\xc2\
\x01\x01\x01\x01\x5d\xc7\x12\xc4\x78\x00\x7e\x86\x98\xfc\xfb\xd0\
\x5e\xde\x7f\x40\xfb\x75\xff\x09\x38\x1b\x78\x07\xf0\x1b\xe0\x17\
\x28\x8b\xe6\x1d\xe8\x68\x84\x5f\xa2\x44\x58\x6b\x11\x33\xdc\x49\
\x92\x34\xa3\x01\x31\xa7\x3d\x88\xd9\x6d\x03\xbe\x6f\xf7\xde\x85\
\x92\x90\x3c\x8f\x92\x84\xfc\x03\x62\x36\x1f\xb4\xdf\x5f\x3a\xde\
\x83\x13\x10\x10\x10\x10\x70\x42\xa1\x35\x6f\x61\xb1\xfb\x6a\x81\
\x4f\xa1\xa4\x8e\xcb\x90\x6e\xf1\xa7\x28\x61\x64\x1d\x32\xd0\x6e\
\x42\xc6\xe0\x43\xc8\x48\xbb\xc7\x7b\xbe\x14\x98\x63\xf7\xae\x40\
\xfc\xed\x4e\x94\x2c\xb2\x89\x24\x9a\xca\x79\x06\xdd\xff\x6e\x1b\
\xd1\x34\xa4\xe0\xb9\xff\xfd\xfb\x49\x5d\xf3\x15\xb0\x42\xaa\x2c\
\x52\xe5\xbb\xeb\x83\x81\x77\x22\x85\xb8\x0a\x29\xb2\x71\x07\xeb\
\x2a\xe6\xd1\xbd\x8c\x64\x9b\xd3\xcd\x28\x13\xf4\x36\x64\x38\x98\
\x0d\xbc\x1f\x6d\x95\xda\x66\xe3\x51\x89\xf2\x80\xac\x42\x59\xb0\
\xcb\x81\x4b\x91\x8c\xb0\x12\x19\x1e\x3e\x82\xf2\x8e\x1c\x42\xca\
\xed\x80\x54\xdd\x05\xa4\x54\x8f\x23\x89\x2e\x3b\x68\x65\x6e\x45\
\xb9\x44\xf6\x79\xef\xc6\xf5\xa3\xd8\xb8\x74\xb4\xef\x0e\x79\xeb\
\x6b\x5f\xa4\xc0\x67\x29\x3e\xf6\xe9\x79\x95\x47\x0a\xfb\xe9\xc8\
\xa9\x50\xec\xfd\x77\x19\xc1\x23\x1c\x10\x10\x10\xd0\x75\xf8\x47\
\x29\x1c\x40\x4a\x6a\x3a\x7c\x69\x21\xf2\xfe\xfa\x96\xd7\xef\xd1\
\x32\x1c\xda\x67\x5e\xcb\xbd\x32\xbf\x66\xdf\x7f\xe4\xfd\xfe\x1f\
\x45\xea\x59\x60\x9f\x62\xe1\x53\x01\x01\x01\x01\x01\x01\x6d\x21\
\x46\xa7\x0e\xf4\x42\xc6\xd5\xf6\xbc\x77\xd7\x23\x63\xec\x0f\x48\
\x14\xa3\xc3\x48\xc1\xfb\x7b\x94\xd9\xb9\x37\x52\x58\x9f\x45\xc7\
\x1a\xe5\x48\x42\x79\xb1\xfb\x9f\x21\xe1\x79\x7d\x90\xa7\x74\x33\
\xf2\xc6\x56\x21\xa3\x6e\x1e\xb8\x18\x29\xa5\xaf\x21\x5e\xe7\x14\
\xe0\x0c\x52\xbe\x27\x22\xa5\xfa\x05\x94\xb9\x7a\xa6\xdd\x3f\x04\
\x29\x7d\xcf\x22\x05\x6b\x0a\x3a\xf6\x70\x33\xe2\xbd\x2f\x58\x9f\
\xa7\x59\xfd\x1b\xed\xde\x73\x91\xc7\x76\x26\x8a\xf4\x6a\xb2\xfb\
\x27\x20\x05\xad\x01\x45\x82\xad\xb7\x7b\x4a\xad\xae\x3d\x28\x3f\
\x47\x1d\x09\x6f\x1f\x64\xed\xfb\x26\xf2\x96\x5f\x02\xfc\x3f\xaf\
\xdf\x6f\x02\x5f\x41\x8a\xef\xb3\xe8\xf8\x24\x77\x9e\xf0\x83\x76\
\xcf\x08\xe4\x01\x7f\xdc\xfa\x13\x21\xef\xee\x44\xe4\x45\xdf\x09\
\xcc\x40\x79\x4a\xfc\xed\x54\x63\x6c\xec\xf3\x48\x19\xdd\x66\xef\
\xa6\x8f\xb5\xe3\x69\x64\xb4\x18\x8c\xa2\xcc\x7a\x23\x23\xff\xab\
\x48\x81\x1e\x8d\x94\xf2\xd7\x90\x57\xfc\x1c\xe4\x8d\x7e\x0e\x19\
\x3a\x46\x23\xa3\x7e\x15\x52\xb0\xdd\x11\x52\xb3\xd1\xc9\x1a\x4e\
\x1e\x71\xa7\x5b\xcc\xb4\x72\x16\x58\xbf\xdd\x5c\x88\xed\x3d\xcc\
\x46\x5b\xc8\x6a\x6c\x0c\x62\xeb\xfb\x0c\x9b\x3f\x73\x91\xe1\xa5\
\x4b\x08\x1e\xe1\x80\x80\x80\x80\xa3\x83\xd6\x94\xd0\xb8\x8d\xfb\
\x8e\x24\xbb\x65\xa1\x93\xd7\x03\x02\x02\x02\x02\x02\x8a\x21\x46\
\xca\xc7\x17\x50\xa2\xc7\x19\xb4\xcd\xcb\xca\x91\x82\x35\x9f\x44\
\xc1\xca\xda\xff\xfd\x90\xe2\xe7\xae\xb9\xad\x3d\x4e\x09\xf6\x11\
\x21\x8f\xe1\x40\xa4\xd4\x9d\x85\x14\xd1\x73\xd1\xb9\xc3\x9b\x91\
\x82\xf5\x71\xbb\x7f\x3b\xf2\x9c\x4e\x20\x51\x84\x2f\x40\x11\x57\
\x9b\x90\xc2\xf6\x71\xb4\xe5\xe8\x7a\xe0\x42\x14\x21\x75\x25\x4a\
\x28\x79\x1e\x3a\xe1\x61\x83\xd5\xf5\x1e\xa4\x10\xbe\x0d\x29\xb2\
\x4b\xec\xde\xe9\x48\xc9\xdf\x67\xe5\x9e\x85\x14\xc0\x71\x28\xea\
\x6b\xbb\xd5\xfd\x09\xa4\xdc\x5d\x81\x94\xca\xb5\x28\x64\xfb\x32\
\x9a\x7b\x4c\xc7\x23\xa5\x7f\x27\x70\x26\x3a\x57\x79\xad\x8d\x49\
\x0e\x1d\xf9\xb4\xdc\xee\xf3\xc7\x2a\xe3\xdd\x83\xfd\xed\x6f\xe3\
\x75\x16\x52\x34\x37\xdb\x6f\x4b\x6c\xdc\xca\x52\xef\x74\x00\x52\
\x74\xdd\xd8\xbb\xf7\xe1\xde\x4d\x06\x29\xbf\x1f\xb5\xb2\xd7\xda\
\x78\xcc\xb4\xf6\xdc\x81\x14\xef\x5e\xde\x38\x97\x93\x1c\xd7\xf8\
\x76\xa4\x18\xaf\x46\x8a\xf4\x78\xe4\xb9\xbe\x0c\x79\xbb\x47\x5b\
\x3b\x7a\x01\x1f\xb2\x71\x5e\x8f\xb6\x78\x4d\xf2\xe6\x59\xc6\xca\
\x1f\x63\x7d\x72\x63\x31\x00\x9d\x84\x51\x6f\xed\x78\x37\x0a\x55\
\xef\x92\xac\x13\x3c\xc2\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\
\x01\x20\xdd\xa0\x1f\x49\x52\xc7\xb6\xe0\x14\x28\x3f\x84\xb6\x40\
\xb2\xb7\x37\x4b\xfb\x88\x91\xe2\xfa\x41\x14\xfd\x04\x52\xb2\x1e\
\x06\x6e\x44\xfb\x5f\x1f\x47\xe1\xd3\x79\x94\x04\xb2\x01\x29\xd9\
\xd3\x48\x92\x64\xcd\x40\xde\xcb\x87\xac\xdd\x5f\x41\x4a\xe2\x3e\
\xe4\x4d\x7d\x15\x29\x57\xa3\x90\x02\xf7\x02\xf0\x47\xb4\xb7\xd8\
\x9d\xd8\xf0\x20\x89\x37\x3c\x8b\xbc\xa3\xcf\x23\x85\x77\x85\x3d\
\x5b\x40\xca\xf4\x52\x74\x5c\x53\x29\x52\x6a\x27\xa1\x70\xe3\xe7\
\x81\x27\x90\xe2\x36\x92\xe6\xfb\x5a\x47\x20\x4f\x71\xa3\x8d\xb3\
\x9f\x10\xcb\x29\xf4\xee\xb7\xb6\xc6\x6b\x00\x52\xbe\x0f\xdb\xff\
\x6f\x20\x0f\x6c\x16\x29\xd9\x55\xf6\xd9\x6d\xbf\x0f\xb1\x77\xb2\
\x93\xd6\xf7\xd9\xc6\xd6\xde\x81\xe8\xec\xe3\x9d\xd6\x8e\x69\x48\
\x29\x5e\x60\xfd\x1a\x82\x3c\xec\xe7\xa2\x48\xb7\xb5\xc8\xeb\x7d\
\xaf\xd5\xd9\xd7\xc6\x64\x18\x32\x1a\x3c\x6a\x9f\xdd\xc0\x0d\x28\
\xd4\xf9\x6c\x7b\xae\x9f\xbd\xfb\xf3\x49\xf6\x4c\xf7\x41\xca\xef\
\xd7\x91\x51\xa0\x1a\x19\x19\xc6\xdb\xb3\x8b\x6c\xce\xf5\x43\x5e\
\xf0\x2e\x79\x85\x73\x51\x04\xb9\x08\x72\x99\x88\xb8\x3b\x4e\xda\
\x0a\x08\x68\x03\xf9\x4c\x4c\x14\x45\x2e\xc6\x3f\x20\xe0\x44\x80\
\xdb\xcb\x12\x10\x10\x70\xfc\xd1\x44\x58\x93\x01\x01\x5d\x85\x0b\
\x35\x4d\x23\x42\x61\xb7\xff\x1b\x29\x44\x6e\x9b\x0d\xad\xdc\x7b\
\x18\x79\x6e\xc7\x23\x05\xb0\x8f\x7d\x86\x23\x6f\xe7\x0e\xda\x4f\
\x70\xe4\xf6\xab\xde\x8d\xbc\x89\x20\xc5\xaa\xd1\xfb\x0d\xa4\x7c\
\x35\x92\x28\xdd\xf5\x28\xb4\xd6\x95\x91\xb3\x6b\x90\xec\x4b\x2d\
\xb1\x36\x1e\x22\x51\x3c\x33\x5e\x59\x91\xfd\x6d\x44\x4a\xdc\xcd\
\x76\x6d\x39\xc9\x49\x0e\xbe\x07\xd5\xaf\xab\xc1\xfe\x2f\xd8\xf7\
\x12\xab\xb3\x8e\x24\x79\x66\xb1\xbe\xba\x2c\xd7\x6b\xd0\xd1\x8a\
\x03\x91\x87\x73\x0c\x32\x04\x9c\x8e\x14\xff\xd6\xb4\xb2\xc8\xc6\
\xf5\x9b\xf6\xb7\x60\x75\x16\xbc\xf2\xfd\xf6\xc6\x48\x51\xdf\x60\
\xe3\xd3\x9a\x71\x22\xb6\x7e\xb9\xb1\x8b\xbc\xfb\x23\xab\x23\x83\
\x14\xda\xef\x22\x6f\xfc\x34\xe4\x31\xfe\x09\xf2\x18\xef\x45\xde\
\x5f\xf7\x5c\xce\x2b\xcb\xed\xf7\xce\xd9\xd8\x6e\xb3\x71\x7b\xc4\
\x9e\x71\xed\x75\xe3\xed\x68\x7c\xa3\xb5\xad\xc4\xda\xb0\xd5\xfe\
\xbf\x8f\x64\x4f\xfa\x11\x23\xb7\x61\x6f\x43\xe9\xd7\x9e\xdf\x4a\
\x55\x49\x88\x92\x0e\x38\xfa\x68\x2a\xc0\x9b\x5b\x0e\x56\x21\x4b\
\xd6\xc6\xe3\xdd\x9e\x80\x80\x0e\x60\x36\xb2\xe0\x9e\x79\xbc\x1b\
\x12\x10\x10\x40\x0e\x85\x39\x7e\x02\x79\x8d\x02\x02\x02\x3a\x8f\
\x2a\xe4\xd9\x6b\x4d\x49\x5d\x8d\xf6\x79\xb6\x77\x94\x4e\x01\x78\
\x00\x85\xd3\xde\x80\x14\x9c\x3b\x51\x88\xed\x6f\x91\xe2\xe2\x90\
\x6d\xa3\xac\x0c\x52\x02\xf7\xa4\xea\xcc\x78\x9f\x65\x28\xbb\xf4\
\x2c\xa4\x8c\x4d\x01\xee\xb1\xbf\xa0\x70\xec\x39\xc8\x73\x3b\x1c\
\x79\x12\x57\x22\x7a\xe1\x97\xe7\x3c\xa8\x97\x59\x1f\xcf\x01\x86\
\x22\x2f\xf0\xe9\xc0\x8f\xad\x2d\x57\x59\x9b\xdd\x1e\xdd\x5a\xaf\
\x6d\x6f\x20\xc5\xef\x7c\xeb\xeb\x30\xeb\xef\x78\x9a\x2b\xcc\x69\
\xe5\x6a\x2b\xf2\x62\x96\x5a\xdb\x16\xa0\x10\xeb\x87\xac\x6f\x93\
\x90\x27\xd6\xcf\xf3\x91\x49\x95\xe3\xf6\x1b\xef\xb7\xf1\xf2\x8f\
\x8e\x2a\x20\x8f\xec\x61\x6f\xec\x4b\x51\x58\xf2\x63\xad\x8c\xbf\
\x0b\x91\xce\xa0\x50\xe5\x06\x14\x16\xbe\x18\x65\xae\x7e\x0d\x29\
\xa1\x4e\xb9\x1f\x86\xc2\xa1\x1f\x44\x8a\xf8\xcd\x76\x6d\x90\x8d\
\x41\x05\xf2\xd6\xe6\x91\xc7\x78\xb6\xdd\x77\x85\xb5\x6d\xa3\xf5\
\x31\x6b\xdf\xaf\x27\xf1\x5c\x67\x90\x32\xbd\xde\xc6\xff\x19\x7b\
\x7e\xbd\x8d\xd7\x21\x2b\x77\x3b\x8a\x16\x58\x4f\x17\xcf\x8e\xce\
\x95\xe5\x32\x85\x91\x35\x65\xd4\x94\x67\x8e\x68\x73\x5a\x40\x40\
\x67\xd0\x94\x8f\xa9\x2a\xcd\x42\x12\x3a\x13\x2c\x30\x01\x3d\x19\
\x05\xef\x13\xe6\x6b\x40\xc0\xf1\x87\x0b\x25\x0c\x6b\x32\x20\xe0\
\xc8\xe0\xd6\x8f\xcb\xc2\x5b\x0c\x1d\x5d\x57\x19\xa4\xa0\x7c\x13\
\xed\x8d\xed\x87\x42\x99\x0f\x23\x65\x74\x10\x3a\x0d\xa1\x09\x29\
\x8f\xfb\x69\xae\xb4\x38\x4f\xe1\x7c\x12\x8f\xa3\xaf\x48\xae\x21\
\x51\x04\x37\xa0\x64\x91\x97\x20\x83\xd8\x43\x28\x39\x54\x5f\xa4\
\x58\xcd\x47\x0a\xeb\x35\x56\xff\x7f\xa3\x3d\xa6\x4b\xbd\x7a\xd7\
\x58\xd9\x73\x51\x78\xf1\x35\x48\xb9\xda\x6b\xf7\xde\x87\x92\x71\
\x6d\x47\x61\xc0\x7b\x90\xe7\x72\x2e\xda\x83\xbc\x11\x29\x6d\xf3\
\x91\xe2\x7c\xb9\xb5\xff\x47\x28\xd4\x77\x19\x89\x32\xbf\xd1\xda\
\xe1\xf7\x75\x11\xda\x3b\x5c\x83\xf6\x03\xff\xc4\xea\x9b\x85\xbc\
\xa8\x8f\x20\x85\xfb\x3c\x14\x1a\x1e\x21\xe5\x79\xa1\x57\xce\x21\
\x1b\xe3\x7a\x5a\x9e\x9d\x1c\xa1\xfd\xcb\x4b\x48\x3c\xda\x65\xd6\
\xef\xf5\x14\x57\x18\x1b\x80\x79\x56\xee\x3e\x94\xec\xf3\x4a\xb4\
\xff\xf6\x35\x6b\xc7\xb9\xde\xfb\xd9\x64\x63\x7a\x2d\xf2\xd6\xfe\
\xcc\xfa\xd5\x17\x29\xaf\x9b\xed\x99\x3d\xd6\xce\x2c\x32\x92\xec\
\xb7\x71\xdc\x6a\xef\xe6\x72\x64\x38\x58\x47\xf3\xe3\x9e\x9a\x6c\
\x5c\xae\xb3\xcf\x6a\xfb\xac\xb3\x71\x76\xc9\xcf\x16\x93\x18\x6b\
\x8e\x18\xd1\xd4\x11\x55\x7b\x7e\x72\xc7\xe8\x9a\xda\x5e\x25\x21\
\x34\x3a\xe0\xa8\xa3\xbe\xa9\xc0\x9f\xdc\xbb\x76\xcf\xaf\x17\xec\
\xfe\x24\x22\x8a\x1d\xd9\x3f\x12\x10\x70\xbc\x90\x27\xf1\x3c\xdd\
\x4b\x98\xaf\x01\x01\xc7\x13\x31\x12\xea\xfe\x0a\xf8\x15\xca\x34\
\x1a\xd6\x64\x40\x40\xe7\x10\x23\x85\xf5\xaf\x80\x7f\x45\x4a\x5f\
\x57\xcf\x67\x75\x61\xb9\x59\x92\x90\xd6\xbe\xc8\xb3\xda\xde\x59\
\xc0\x9d\xad\xc7\x29\xcb\x79\x5a\x2a\x41\x05\x12\xcf\x65\x81\xe2\
\x4a\x52\x01\x29\xd3\x63\x91\xb2\x7b\x1e\x0a\x4b\xfe\x77\xa4\x3c\
\xfa\xcf\xbb\xef\xce\x5b\x19\x77\xb2\xae\x34\x22\xe0\x5d\x48\xa9\
\x7f\x82\xc4\xbb\xeb\xe8\x58\x1e\xed\x99\x2d\x41\x8a\x63\x67\xe0\
\xde\xeb\x07\xd1\xd1\x8c\x1b\x38\xb2\xf7\xea\x3c\xac\x6e\x8c\xa3\
\x22\xe5\xb8\xbe\xe3\xdd\x03\xcd\xf7\x8b\x17\xfb\x1e\x79\xcf\x67\
\xda\xa8\x23\xee\xe0\x73\x47\x7a\x96\xf3\x40\x74\xe4\xd4\x67\x73\
\x71\x0c\x4d\x31\x34\x15\xe2\xa0\x08\x07\x1c\x75\x34\x15\xa0\xa0\
\x79\xd6\x5a\xe6\xc0\x80\x80\x9e\x06\x67\x8d\x76\xd9\x15\x03\x02\
\x02\x8e\x1f\xda\xcb\x3e\x1b\x10\x10\xd0\x36\x9c\xe2\xd5\x55\xe5\
\xd7\x87\x5b\x87\xbe\xd2\xb2\xbb\x9b\xeb\xf0\xeb\x89\x29\xbe\xf6\
\x7d\x65\xb5\xad\xbd\xcd\x0b\x51\x82\xac\x9b\x91\x17\xf4\x67\xc8\
\xc3\x9a\x7e\x3e\xf6\x9e\x89\x8f\xa0\xae\x34\x0a\x28\x71\x94\x0b\
\x8f\x6e\x4a\x95\x9d\x41\x9e\xd9\x43\x47\x30\x76\x4e\xc1\x7b\x81\
\x23\x57\x82\xa1\xf9\xde\xe2\xd6\xfa\xd5\x5a\xdf\xe3\xd4\xf3\xc5\
\xbe\xfb\xcf\xb4\x56\xc7\x91\x3e\xd7\x69\x84\xac\xd1\x01\x01\x01\
\x01\x01\x01\x01\x01\x01\x01\x01\xdd\x89\xee\x56\x82\xbb\xb3\x5d\
\xbb\x51\xf8\xad\xef\xc1\x3e\x16\xed\x8d\x50\xa8\xf8\xd6\x76\xee\
\x39\x12\x64\x50\x92\xaf\xa5\xc7\xa8\x2f\x27\x05\x82\x22\x1c\xd0\
\xd3\xe0\x87\x51\xf8\xd7\x8a\x85\x66\xa4\x9f\xeb\x88\x75\xc8\x0f\
\x71\x39\x56\xfd\x49\xb7\xbd\xd8\xb5\x23\x69\x97\x6f\xa9\x3c\x92\
\x7b\xba\x6b\x2c\x3a\xda\xc7\x8e\xf4\xc7\xb5\xa7\xb3\xcf\x1f\xeb\
\xf7\xea\xd7\x9b\x3e\xc3\xce\xb5\xbb\x3b\xda\xd3\x5e\xbf\x5a\xfb\
\xbd\xa3\xeb\x21\x20\xe0\x54\x46\x6b\xeb\xf7\x58\xad\x9d\x38\xf5\
\xbd\xbb\xeb\x75\xfd\x3b\x96\x7d\x3a\x16\x68\x8b\x2e\xba\x30\xcb\
\x4c\xea\x5a\x1a\x21\xba\xa7\xfb\x50\x6c\x1d\xb5\x95\x64\xab\x3d\
\xd9\xa5\x23\xb2\x4d\x47\xda\xe4\xfe\x16\x8b\x77\x75\xed\x2b\xa4\
\xfe\xb6\xd5\x97\x23\x91\x6b\x8a\xe1\x68\x2a\xa9\x5d\x4a\x1c\x75\
\x2a\x22\x28\xc2\x01\x3d\x09\x31\xca\xee\xd7\x1f\x65\xb7\x2b\xa0\
\x39\x3a\x0b\x85\xb1\x6c\xa1\xe5\x02\x77\x07\xba\x8f\x47\x9b\xfa\
\xdb\x42\x01\xed\x03\xe9\x0f\xbc\xc4\xd1\x17\x0c\x22\x94\x25\x6f\
\x05\xcd\x53\xc3\x4f\x47\x7b\x4e\xd7\x91\x84\x97\x0c\xb7\xb6\x3d\
\x4b\xc7\x8e\x05\x29\xa0\xec\x82\xb1\x8d\x4d\x6b\x8a\xee\x08\x94\
\xd1\x30\x7d\x4f\x01\x65\x4a\x2c\x45\xc9\x0b\xba\x12\x42\x33\x03\
\x25\x61\xf0\x43\x71\x66\xa2\xc4\x11\x9d\x09\xcf\xa9\xb6\x71\x58\
\x8a\xb2\x40\xee\xb6\xb1\x6b\xef\x3d\xb9\xb3\xef\x6a\xd0\x9e\xc1\
\x63\xc5\x04\x0a\x28\xb4\xea\x6a\x9a\x0b\x55\x8b\x51\x72\x8d\xbe\
\x28\x44\xe9\x48\x11\xa3\xb9\x7a\x0e\x9a\x17\xe9\x7d\x56\x05\x74\
\x7c\x41\x39\x7a\x87\x6e\x9c\xca\x50\x32\x8e\x57\x69\x99\x98\x24\
\x20\x20\x40\x70\x74\xe3\x2a\x12\x59\x68\x2f\x5a\xb3\x6b\x38\x36\
\xeb\xe6\x74\x14\x96\x09\x4a\xc4\xf3\x38\x2d\x85\xf0\xae\xf4\xaf\
\x0a\x65\xd1\x05\x9d\x97\x5a\x7f\xe4\xc5\xf5\x18\x38\x7e\x39\x8e\
\x96\x47\xcc\xe4\x50\x26\xd9\xad\x88\xc7\x47\x88\xc7\xbd\x0d\xd1\
\x63\x87\xfd\x28\x29\xd2\x3e\x02\x7d\xec\x2a\x0a\x28\x91\xd2\xc5\
\x24\xef\x62\x1b\xca\xf6\x5b\x6c\xef\x71\x8c\xf6\xe6\x56\xa2\x84\
\x53\xc5\x7e\x1f\x8c\xde\x65\x57\xf6\xb8\x0e\x41\x89\xba\xfa\x59\
\x7d\x90\x28\xba\x07\xd0\xf9\xbf\x2e\x74\x3b\x83\x12\x37\xcd\x43\
\x34\x61\x86\xd7\x97\xad\xd6\x97\xbd\x68\x8d\x2e\x24\xf0\xd5\x93\
\x0a\x27\x93\x85\x30\xe0\xc4\x47\x8c\x84\xfe\xcf\x22\xc2\xea\xce\
\x1b\xbb\x0c\x11\x34\x77\x76\xa4\xfb\x14\x90\xf2\x73\x31\xda\xe7\
\x71\x01\x4a\xdb\x9e\x4e\x66\xe0\x3f\x33\x0a\x29\xdb\xee\x3c\x33\
\xdf\x6a\xe8\xdf\x17\x17\xb9\x56\x68\xa5\xcc\xb8\xc8\x75\x77\xed\
\x32\xc4\xb4\xfd\x73\xdd\xa6\xa2\x54\xf3\x4d\xde\xfd\xc3\x90\xc2\
\x9f\x49\x95\xe3\x0b\x45\xe9\xeb\x67\x23\x03\x80\xcb\x6a\x9c\xb6\
\x7a\x96\xa2\x8c\x7b\x11\xc5\xc7\x6e\x02\x30\x99\xc4\x02\xea\xff\
\xe6\x5b\x45\xfd\x73\x9f\xd3\xd6\xd2\x08\x9d\x23\x37\x34\xd5\xde\
\x3e\x48\x21\x6b\x6d\xac\xe2\x54\x7d\x79\x24\xd8\xdc\x6a\xbf\xf5\
\x22\x39\x1f\x30\x3d\xae\xe9\x67\x41\xfb\x69\x2e\x47\xd9\x16\xfd\
\x8c\x98\x47\x13\x31\x52\x84\x67\x20\xa5\x7f\x85\x7d\x36\x03\x67\
\x21\x83\x47\xb1\xb1\x75\xf0\xc7\x25\x3d\x26\xae\xaf\x25\x24\x02\
\x5c\xb1\x77\x54\x65\x63\xe5\x67\xd1\x2d\x41\x73\xa9\xaa\x95\xb1\
\x0a\x08\x38\x99\x51\xcc\xa3\x53\x0c\xce\x90\x75\x2e\xca\x7a\xbb\
\x1c\xad\x99\x4f\xa3\x6c\xb2\x6d\xd1\xfd\xb8\x48\x3d\x7e\x16\xde\
\xf4\xb3\xc5\x78\x49\x09\xf0\x0e\x44\x3b\x33\x48\x60\x8f\x3a\xf8\
\x7c\x31\xda\x96\x7e\xce\xf1\x88\xe9\xd6\x3f\xdf\x90\xd6\x11\x9a\
\x94\xe6\x6b\x05\x5a\xe7\x93\x7e\x3b\xd3\xfc\x83\xd4\xb5\xb6\xf8\
\x66\x21\x55\x5f\x6b\x63\x37\x0c\xd1\xfb\xb4\x71\x77\x04\xe2\x21\
\x6f\x23\xa1\x7f\x7e\x16\xe1\xe5\x88\x46\xaf\xa1\x7b\x13\x38\x9d\
\xca\x88\x91\x51\x7e\x38\xc9\xf8\x8e\x01\x3e\x86\xc6\xbe\x18\xdf\
\xaa\x44\x86\xef\x62\xef\x36\x8f\x8e\xd3\x99\x4c\xcb\x39\x57\x6c\
\x4e\x14\x5b\xeb\x39\x94\xd1\xb8\x04\xf1\xe3\x65\x48\x1e\x9a\x88\
\xb2\x0c\xaf\x41\x99\x92\x5d\x39\x31\x70\x29\x92\x27\xcf\x25\x31\
\xc8\xaf\x40\xbc\xfc\xa3\x68\xae\x0d\x42\x47\xf9\x04\x9c\x44\x08\
\x1e\xe1\x80\x9e\x86\x26\x44\xb8\x6e\x47\x04\xeb\x30\x09\x73\xac\
\x40\x4c\xfd\x34\x44\xc4\x9e\x43\x16\xc7\x9d\xc8\x42\xb7\x8b\xe6\
\xd9\xeb\x22\x44\x4c\xcf\xb1\xdf\x9f\xb4\xdf\xfb\x01\xb7\x20\xa2\
\xf7\x1c\x4a\xcb\x5e\x8b\xbc\x68\xfd\x90\x05\xf0\x29\xfb\xfd\x1c\
\xe4\xed\xeb\x07\xbc\x68\x6d\x9a\x81\x08\xfc\x60\xab\xf3\x29\x74\
\xe0\xfb\xd9\x48\x19\xaf\x47\x5e\x85\x8d\x14\x57\xc8\x0a\x48\x81\
\x1d\x85\x2c\x92\x4f\xd2\x5c\x80\x18\xee\xd5\xf1\x26\xca\xae\x9d\
\xb1\xbe\x9f\x65\xfd\x7d\xca\x1b\x97\x32\x64\xf5\x5f\x45\xb2\x37\
\xc4\x29\xba\x15\x28\x8d\x7e\x1f\xe4\xa5\x1d\x84\x94\xb6\x67\xbc\
\xe7\x23\x6b\xcf\xf9\x36\x3e\x2f\xa2\x94\xf8\xa7\x03\xcf\x23\xa6\
\x36\x11\x9d\x19\xd7\xdb\xee\x7d\x9e\x44\x81\x73\xe5\xf4\x45\xcc\
\xe4\x25\x1b\x97\x43\xf6\xdc\x30\x1b\xcb\x8c\xf5\x75\x2b\xb2\xd6\
\xce\xb4\x3e\xbe\x66\xed\xbe\xc0\xc6\x70\x0a\xb2\xbe\x1e\xb4\xb1\
\x3f\xdf\xae\xef\x03\x9e\xb6\x39\xe2\xfa\xb2\xda\xda\xbb\xd5\xe6\
\xcd\x25\x28\xbb\xf3\x35\xc8\xba\xbb\x91\xa3\x6f\xb9\xdd\x62\x63\
\xe3\x8e\x32\x00\x59\xa0\x1d\x83\x1e\x65\x73\x0b\xe4\xa5\x5d\x6e\
\xfd\x9e\x81\xac\xcf\xeb\xd1\x3c\x2c\xb3\x6b\xb5\xe8\xd8\x81\xa7\
\xd0\x3c\xdf\x69\xbf\xcd\x26\x39\xc3\x6f\x8d\x3d\xe3\x32\x72\x66\
\x50\xe6\xcb\x73\x6d\x9c\x4a\x49\x14\xe5\x4b\x6c\xbc\x57\xd9\xbb\
\x69\x38\xca\xe3\x11\x10\x70\xbc\xe0\xe6\xfc\x00\x44\x13\x3a\xe2\
\x01\x5d\x8f\xbc\xa5\x79\x44\xa7\xfe\x09\xad\xd9\x89\xc8\xc8\x54\
\x40\x74\x6b\x9c\x5d\xdb\x83\xe8\x50\x7f\xb4\x16\x9f\x46\xeb\xfe\
\x32\x24\x38\x1f\x42\x86\xa8\x5e\x88\x7e\xbf\x86\xe8\xc1\x48\x24\
\xfc\x97\xa3\xb5\x5d\x8d\x14\x88\x3a\xe4\x9d\xdc\x6e\x75\x0d\x46\
\xf4\xad\xd2\x7b\x7e\x1c\x52\xf2\x7a\xa1\xb5\xfd\x0c\xcd\x69\x9b\
\xf3\x6e\xcf\x40\x72\x9d\xa3\x7d\x97\xd9\x33\x55\x24\xf4\xa8\x14\
\x29\x91\x8d\xd6\xfe\xc5\x88\x2e\x95\x21\x23\xad\xe3\xaf\xcf\xa2\
\xb3\x3f\x67\x22\x3e\xd2\x84\xe8\xfe\x64\xc4\x1b\xb6\xda\x3d\xfd\
\xac\x1f\x0f\xa3\x44\x3d\xe7\x22\x8f\x60\x0e\xd1\x66\x67\x98\x5b\
\x6c\xf5\x8d\xb7\x3e\x3f\x6d\xef\xe7\x42\x44\xe7\x87\x5a\xbb\x6b\
\x10\xcf\x79\xcd\x3e\xfd\x10\xef\x1b\x44\xc2\x2f\x9d\xc2\x94\xc6\
\x34\x14\x1d\x53\x6b\xef\xca\x45\xe4\x1c\xb4\xb6\xbe\x49\x92\xf8\
\xb0\x84\xe0\xd5\xeb\x2e\xc4\x48\xce\x78\xd0\xfe\x5f\x0a\x7c\x01\
\xbd\xcb\xfe\x24\xc7\xdd\xbc\x8e\xde\x41\x1d\x7a\x7f\xb5\x88\xdf\
\xe7\xd1\xfb\x7d\x19\xcd\x1d\x77\x54\xcf\x5c\x34\x47\x66\xa1\xf5\
\xb2\x08\x79\x91\x7b\x5b\x99\x03\x49\x64\x00\xc7\xd7\x9c\x7c\xd5\
\xdf\xea\x3a\x84\x64\xa8\x7a\x34\xc7\x1f\xb6\xfa\xb2\x24\xf2\xc6\
\x6e\xb4\xde\xe2\x54\x5f\x32\x68\x4d\x7f\xc1\xea\x7c\x09\x29\xf8\
\x2f\xa2\xb5\x11\xe6\xcf\x49\x80\xe0\x11\x0e\xe8\x69\x88\x10\xa3\
\xdb\x89\x2c\xbb\x3e\xa3\x9f\x8a\x98\xe6\x62\x44\x60\xdf\x8d\x98\
\xf3\x02\x74\x94\xc6\x2a\x9a\x13\xc3\xf3\x90\x42\xbd\x0e\x11\xb1\
\xeb\xd1\x9c\x1f\x4b\x72\xbe\xda\xfb\x10\x81\xbd\xc9\xfe\x2e\x40\
\x1e\xe6\xd9\x88\x48\xbf\xc7\xca\xaa\x07\x3e\x64\xf5\x5e\x89\x14\
\x9b\xd5\x88\x18\x5f\x02\x9c\x69\xed\xd9\x64\x6d\x78\x3f\x62\xe0\
\x69\x25\x38\x46\x42\xc5\x38\x24\x80\x5d\x60\x75\xbb\xdf\xfa\x03\
\x1f\x47\x42\xc4\x26\x94\x66\xdf\x85\x1d\x5d\x83\x2c\xfb\x23\x50\
\xc8\xb5\x3b\x4a\xe4\x0e\x2b\x6f\x5b\xaa\xae\x0b\xad\xef\x87\xed\
\xfe\x09\x88\xc0\xcf\xa0\xb9\x27\xf9\x4c\x94\x6e\x7f\x97\xdd\xfb\
\x31\x24\x94\x5c\x66\x63\x72\xb1\xf5\x7d\x90\xb5\xe5\x2c\x9a\x5b\
\xd3\x63\xa4\x04\xbf\xdf\xee\xdf\x8b\x04\x97\x21\x48\x18\xb9\x15\
\x09\x4d\xb5\xc0\x9d\x36\x2e\x1f\xb6\x67\xd7\xdb\x3b\x1a\x87\x04\
\xc1\xbd\x76\xef\x64\x24\xd8\x5d\x80\xac\xfb\x6b\x91\x70\x7b\x35\
\xf2\x72\x8f\x43\xcc\xf6\x62\x12\xa5\x73\xa4\x62\xe6\x8c\x00\x00\
\x80\x00\x49\x44\x41\x54\x89\xd5\x57\x85\x18\x64\x39\xc7\xc6\x2b\
\x5c\x8b\xc2\xf1\x6e\x46\x56\xe8\xde\x24\x0c\x75\x88\x8d\xdd\x3e\
\xc4\x38\xef\xb2\x7e\x5d\x8f\x18\xf0\x72\x1b\xd3\x69\xc8\x98\x31\
\x02\x31\xef\xf1\x36\x2f\xfa\x90\x08\xa2\xb7\xd8\xbb\x5a\x63\x75\
\x9d\x6d\xff\x4f\xb2\xf1\x78\x27\x12\x7e\xfb\x5a\x9b\x22\xe4\x71\
\x1a\x83\xd6\xcc\x34\x14\x06\x1a\xce\x07\x08\x38\x59\x91\x43\xeb\
\xed\x9b\x68\xbd\xb4\x37\xd7\x1d\x3d\x1e\x64\x9f\xc9\x56\xc6\x41\
\xe0\xed\x48\x29\x5c\x87\xd6\xea\x0d\x48\x28\xee\x05\xbc\x17\xd1\
\x97\xeb\xd0\x1a\x1d\x88\xd6\x56\x05\xa2\xa5\x15\x88\x1f\xdd\x84\
\xf8\xd0\x59\x56\xde\x6e\x7b\xfe\xdd\x88\xd6\xee\x41\xe1\x9f\x95\
\xc8\x88\xd8\x97\xc4\x93\xb6\x1e\xad\xe9\x0b\xbd\xe7\x77\x22\xfa\
\xf2\x6e\xa4\x58\xb8\x3e\x0c\x46\xc7\xbc\x35\x22\x3e\xf0\x7e\x60\
\x34\xe2\x21\xdb\xed\x9a\xa3\x49\x25\x88\xe6\x9e\x69\x7d\xbb\xcd\
\xfa\x7d\x01\xcd\xf9\xeb\x5d\x88\x96\xde\x8e\x8c\xb3\x1b\xac\xbf\
\x97\x20\xba\x35\xd6\xee\x39\xe0\x8d\xcf\x9d\xd6\x97\x02\xa2\x51\
\x95\x48\xf9\xbd\x14\xd1\xbd\xb7\xd9\xb8\xf4\x43\xf4\xae\x1a\xf1\
\x38\x77\xcc\xce\x5f\x22\x1a\xb8\xd7\xae\xf7\xb3\x71\x1d\x8a\x78\
\xf3\x39\x88\xc6\x16\xe3\xab\xbd\x11\x2d\x7d\x12\x29\x4b\xee\xac\
\x59\xe7\x15\x9e\x6d\xf5\xdf\x8c\xce\x47\x0d\x74\xb0\x7b\x51\x85\
\xd6\xd0\x10\x34\x8f\x0e\xa1\xf7\xff\x71\x34\xd6\x5b\xd0\xba\x99\
\x88\xe6\xe6\x44\x24\xef\xdc\x85\xde\xd3\x7e\x92\xb5\xb3\xdb\xee\
\x2f\xd8\xb5\x2a\x34\x6f\x6e\x44\x73\xf5\x1a\xb4\x26\x96\x21\x19\
\xe0\x2c\x9a\x7b\x8b\x27\xa3\xb9\xef\x8e\x42\xca\xd9\xdf\x0c\x49\
\xa6\xf9\xd3\x90\xfc\xb7\xdd\xea\x1c\xe6\x95\x51\xed\xf5\xe5\x02\
\x34\x37\x0f\x21\x1e\xde\x90\xaa\x2f\xe0\x04\x47\xf0\x08\x07\xf4\
\x44\xd4\xa3\x54\xf6\x5f\x44\xca\x8e\xf3\x5a\x2e\x40\x0c\xb2\xdc\
\xee\xab\xb5\xef\x07\x90\xa2\xe4\x1b\x76\x22\xa4\xac\xce\x47\x07\
\x94\x57\x22\x62\x37\x15\x59\x07\xff\x88\x98\xfb\x9f\xd9\x6f\x0f\
\x23\xa6\x5b\x6d\xe5\x0c\x41\x0a\xd9\x52\x74\x68\x7b\x2f\x2b\xaf\
\x0f\x12\x92\x9e\x40\x16\xe6\xe1\x88\xa0\xf6\x43\xc2\x43\x1f\x24\
\x68\x9c\x81\xbc\x0a\xc5\x12\xb1\x34\x22\x6b\xe3\x63\x48\x41\xba\
\xcd\xea\xca\x23\x02\x1b\x03\xbf\x41\x16\xd1\xfe\x88\xa1\x57\x21\
\x06\xff\x04\x3a\x40\xbe\x0c\x29\xe4\xd7\xd9\x73\x5f\x46\x8a\xac\
\x1b\x83\x52\x24\x9c\x2d\xb2\xff\x0f\x23\x42\x3f\x1a\x59\xe2\xd7\
\x21\x65\xcb\xed\xcb\x5e\x09\xfc\xc1\x9e\x3f\xcb\xfa\xbf\xc3\xee\
\x19\x60\xbf\x8f\xb5\xdf\xe6\xd2\xfc\xfc\xbc\x12\x24\x78\x6d\x04\
\xbe\x43\xe2\xc5\x77\x82\xd7\x4b\xe8\xb8\x80\x9d\x88\xe9\x8d\xb7\
\x72\x56\xda\xb8\xf5\x26\x09\x59\xda\x6a\xef\xd2\xbd\xf3\xa9\xde\
\xf3\x2f\xd8\x3b\x9c\x8d\x84\xa5\xcd\xd6\x97\xf5\xd6\x96\x5d\xf6\
\x7b\x09\x3a\x10\xfe\x58\x25\x88\x29\x27\x09\x0d\x3f\x4c\x42\x57\
\xf3\x24\x1e\x71\x37\xff\x06\x20\xc6\x7a\x01\xf0\x63\x64\x21\x9f\
\x6f\xcf\x38\x41\xa2\xd2\x9e\x1f\x62\xfd\x72\x63\xb1\xdb\xe6\xcd\
\x4a\x24\x10\xba\x90\xfb\x02\xf2\x9a\x2f\xb3\xdf\x6b\x91\xc7\xa6\
\x1f\x52\x7e\x5f\xb7\xb2\x5c\x54\xc1\x43\x84\xb0\xc0\x80\x93\x13\
\x11\xa2\xc3\xee\xd3\x9e\xc7\x26\x46\x06\xc2\xcf\x92\x84\x49\xfe\
\x16\x29\x7d\x87\xd1\x1e\xd4\x37\x11\x2f\x72\x34\x35\x83\x14\x2e\
\xe7\xc5\x1d\x8f\xd6\xec\x06\xb4\x8e\xcf\x41\xb4\x69\xa0\x5d\x3f\
\x1f\x29\xa2\x73\x11\x1d\x5b\x8f\x0c\x81\x07\xed\xf9\xe5\xf6\x3d\
\x8f\x8c\x56\xe5\xc0\x2f\x11\xfd\xef\x8d\xd6\xf0\x7a\xe4\xb5\x7d\
\x14\xd1\xd9\x0f\x21\x7a\xb2\x8f\x24\x04\xfa\x00\x70\x0f\x89\xa7\
\x77\x22\x32\xd6\x96\x20\xda\xea\x68\x61\x84\x68\xf1\xef\xed\x77\
\xe7\x71\xfd\x29\xe2\xaf\x6e\x7b\xd1\x10\x6b\x4b\x9d\xd5\xbb\x06\
\x29\xa7\xbf\x40\x9e\xbb\x95\xe8\x1c\xda\x2c\xca\xbe\xfb\xb7\x68\
\xff\xe4\x1f\xac\x8e\x7a\xa4\x6c\x8f\x42\xb4\x69\xb3\x8d\xc7\x79\
\x24\x61\xa7\x20\x9a\xff\x30\xe2\x69\x97\x5a\x5d\xf5\xd6\xef\x5e\
\x88\xc6\xfb\x74\x71\x98\xf5\xc7\x47\x01\x19\x03\xfb\xdb\x7b\x3a\
\x84\x0c\x84\x43\x91\xb1\x21\x63\x65\x38\xac\x23\x24\x15\xea\x4e\
\xc4\x88\x2f\x8f\x44\x63\x7a\x18\xcd\xa7\xe1\x68\x5e\xff\x1a\x29\
\x90\x83\x10\x4f\x77\xd1\x72\x11\x9a\x47\x0f\xa1\xf7\x3f\x0d\xcd\
\xd7\xad\x24\x06\xa2\x73\x91\x52\x3c\xc8\xee\xb9\xc0\xfe\x1f\x49\
\x22\x03\xf8\x7b\x89\xb3\x48\x3e\x78\x95\xd6\x8d\x1d\x2e\xc7\xca\
\x56\xb4\x57\xb8\x02\x29\xcf\x6e\x6b\xda\x2c\x6b\xbb\x9b\xc7\x3f\
\x45\xeb\x00\xc4\x87\x87\x11\x0c\x29\x27\x0d\x82\x22\x1c\xd0\x13\
\x11\x21\x65\xe8\x7e\xe4\xd1\x72\x98\x81\x18\xf6\x22\x24\xc8\xfb\
\x84\xa8\x98\xc2\x93\x43\x42\x01\x88\x38\x0e\xb6\xbf\x07\x68\x9e\
\x9d\xb8\x12\x59\x8a\xcb\x11\x83\x3e\xec\x95\xe7\x12\x99\xf8\x59\
\x80\x1b\x48\xc2\x76\x1d\x33\xcd\x21\x02\xb9\xd5\xae\xff\x8c\x24\
\x19\x56\x1a\x05\xaf\x5d\x69\x85\x24\x67\xd7\x9c\x02\x5d\x6f\xd7\
\xfc\xbe\x94\x22\x65\x27\x87\x84\xa8\x3c\x52\x96\x7f\xde\x4a\x5d\
\x11\x0a\x69\xdb\x85\x84\xb6\xdb\x91\xc2\x1e\x7b\x75\x3a\x4f\x7a\
\xec\x8d\xed\x62\x1b\xef\x12\xc4\x6c\xa6\x59\x79\xcb\x53\xfd\xca\
\x20\xc1\x68\x08\x62\x26\xcf\x79\xbf\xe5\x6d\x0c\xfd\xb3\xdf\x4a\
\x90\xa0\xb2\xc5\xea\x72\xca\x9d\xf3\x62\xfa\xc2\x49\xd6\x6b\x5b\
\xce\xea\x78\x0e\x09\x96\xe3\xac\x2f\xfd\x91\xf0\xea\x67\x9a\x74\
\xa1\x4f\x47\x5b\xd0\x89\xd0\x7b\xfe\x1e\x49\x68\xb4\x2f\x60\x39\
\x4b\xf7\x56\xbb\xfe\x3b\xbb\x7f\x86\xbd\xcf\x88\x44\x41\xbe\x18\
\x31\xd8\x45\x24\x61\x5c\x7e\xfb\xeb\xed\xe3\x2b\xc7\xfe\x38\xb9\
\xb9\xe4\xc2\x06\xdd\xb1\x10\x5b\x90\x51\x63\x1f\x9a\xfb\xc1\x92\
\x1d\x70\xb2\xa2\x11\xf8\x16\x32\x74\x2e\xa5\x7d\x65\x27\x42\x8a\
\xee\x7f\xa0\x75\xe1\x68\x7b\x0d\xc9\x7a\x73\xde\xa4\xed\xf6\x71\
\xc7\xae\x6c\x41\x46\xac\xe9\x76\xcf\x93\x24\x82\xf3\x16\xfb\xfb\
\x28\xe2\x65\x63\x69\x9e\x60\xc7\xb5\xab\x18\xbd\x73\xfb\x1e\x23\
\xaf\x7e\xec\x79\x9f\x8e\xfa\x28\xb1\xbe\xbb\xeb\xf5\x88\x9f\x65\
\xbc\x8f\x8f\x3c\x09\xfd\x69\xb4\x3a\x2e\x46\x34\x7e\x91\x57\x96\
\x53\x6a\x1a\xbc\x71\xf0\x9f\x73\x6d\x76\xf4\xa7\xd4\xda\xb2\x17\
\x85\x35\xcf\x46\xc6\xe5\xdf\x22\x0f\xdd\xb7\x91\xe1\xe1\x12\x64\
\x80\xfd\x15\xe2\x05\x8d\x88\x0f\x37\xd9\xc7\x37\xb2\x5e\x89\x78\
\xc3\x12\x6b\x4b\xb1\xf7\x99\xb5\xf6\x83\xbc\x85\x19\x6b\xcb\xc5\
\xc0\x03\x56\xc7\x3d\xc8\x98\xde\xda\x98\x04\x1c\x39\x5c\x24\xdf\
\x4f\xd1\xb8\x1e\x46\xeb\xe8\x4a\x9a\xcb\x6a\x0d\x68\x3e\xf8\xcf\
\x1d\xb4\x7b\x2a\xd0\xbc\xf4\xb3\x4d\xe7\xac\xac\x2d\xe8\x1d\x3e\
\x86\x94\xdf\x0d\x68\x2d\x8e\x43\x11\x71\x8f\x20\xc3\x8e\xbf\xa6\
\xda\xe3\x73\x39\x9a\x6f\xef\x72\xdf\xdd\x16\x2e\x77\xb4\xd2\x61\
\x9a\xf3\x76\xe7\x04\x08\x38\x49\x10\x08\x41\x40\x4f\x83\x63\x50\
\x11\xf2\x7e\x6e\x46\xca\x9b\xdb\xc7\xba\x0e\xed\xcf\x28\x23\xb1\
\x10\x17\x43\x8c\x3c\x61\x17\x20\xcb\xdf\x0d\x24\x0c\x32\xad\xc4\
\x55\x21\x0f\xee\x8b\x48\x78\xea\x4b\xa2\x44\xf9\xf7\x66\xbd\x67\
\x22\xef\x7b\x06\x09\x0f\xa5\x48\xd9\x38\x88\xac\x98\x19\x5a\x1e\
\x21\xe0\x12\x45\x5c\x8e\x2c\xf6\x97\x21\xeb\x76\x3d\x62\xfa\x2e\
\xf4\x6e\x36\x52\x2a\xa7\x23\xcb\xe6\xeb\x28\x44\xf6\x6c\x14\x22\
\x77\x89\x95\xf7\x26\xf2\x2c\x5e\x64\x75\x3a\xe2\xdf\x88\x84\x91\
\x81\xf6\xff\x65\xc8\x4b\xf8\x04\x49\x68\x9a\xdb\x2b\xf5\x06\xc9\
\x5e\x99\x99\xc8\x12\xba\x08\x09\x1e\xe7\x21\x4b\xe8\x3c\x1b\xc7\
\xbd\x48\xa1\xf6\xf7\x61\x37\x21\xef\xf8\xbd\xc8\xbb\x3d\x94\x84\
\x19\xa5\xc7\x3b\x67\xef\x70\x8f\x5d\xdf\x42\xb2\x17\xaf\x01\x79\
\x40\x06\x90\x64\xd3\x5e\x68\x63\x30\x01\x85\xb4\x5d\x6d\x63\x37\
\x02\x79\x6b\xd6\x91\x84\xa0\x3b\xe1\xb5\xc1\xee\x3d\x16\x56\x5b\
\x67\x04\x71\x1f\x7f\x8e\xe4\xec\x7d\x36\xda\x67\x17\xf2\x16\x35\
\xa1\x79\x36\x07\x31\xf2\xf7\x20\xa1\x70\xac\xbd\xe7\xd7\x6d\x1c\
\x4a\xbc\xb2\xd2\x73\xd1\x5d\x73\x9f\x37\x49\xf6\xa8\x3b\xcb\xfc\
\x6e\xe4\xf1\xe9\x8d\x3c\x4a\xc3\x69\x9e\xb8\x2d\x20\xe0\x64\x43\
\x84\x8c\x64\x2f\x22\x5a\xd5\x9e\x21\x2c\x83\x04\xe0\xbd\xf6\x39\
\x44\xb2\xa6\x1c\x0f\x68\x42\x74\xa8\xc6\xca\xce\x20\x7a\x14\x21\
\x65\x6f\x0c\x52\xd4\x16\x23\x7e\xb5\x0d\xf1\x82\x4d\x88\x67\xf5\
\xf5\xea\x72\x6d\x74\xf4\x2d\x46\xf4\xb2\xd4\xea\x73\x1e\xdc\xcb\
\x11\xbd\xbd\x04\xad\xed\xb8\xc8\xf3\x7e\x9f\x97\x58\x1b\x66\x22\
\x1a\x30\x19\xd1\x75\xbc\xba\x1c\xdc\x16\x9c\xcb\x10\x7d\xbf\x10\
\x29\xf4\x67\x23\x7a\xfa\x02\x52\xa2\x4b\x69\x4e\xc3\x0f\x21\xba\
\x75\x95\xf5\xeb\x06\xeb\x6f\x8c\x42\xb8\x7f\x8a\x68\xdc\xdb\xac\
\x2f\xaf\x5a\x1f\x1c\x1d\x3c\xd3\x9e\x7d\x0d\x19\x66\x7b\x93\x84\
\xa9\xfa\x63\xee\xbf\x9b\x72\x44\x23\xe7\xd9\x38\xf4\x21\xd9\xdb\
\xeb\xee\x75\xde\xeb\x33\x81\xaf\x02\xff\x00\xfc\x1d\x32\x4e\xce\
\xb4\x67\x1c\x3d\xce\x79\x75\x06\x74\x1f\x9c\xd1\xc6\xad\xa3\x06\
\x34\xc6\xcb\xd0\xba\x99\x85\xe6\xa4\x8b\xc8\x73\xf3\xca\x9f\xcb\
\xfe\x3b\x6d\x44\x8e\x0b\x67\x44\x2e\x47\xeb\x69\x1c\x7a\x9f\x97\
\x23\xfe\xfe\x18\x89\x0c\xe0\xd0\x64\xcf\x0c\x2a\xd2\x46\x57\x57\
\x06\xad\xd7\xe1\x48\xbe\xb8\x04\x45\xcb\xf9\xce\x8e\x3d\x5e\x5f\
\x7c\x6f\x73\x8d\xb5\x25\x44\x13\x9c\x24\xc8\x0e\xeb\x5d\xfa\xc5\
\x5b\x26\xf4\x2d\xaf\x2e\x0d\x74\x21\xe0\xe8\x23\x5f\x80\x07\x96\
\xee\x3d\xbc\x78\xfb\xe1\x87\x90\xc0\x90\x26\x26\x35\x48\x80\x5f\
\x8f\x08\xda\x5a\xc4\xf8\xe6\x22\xaf\xe1\x78\x44\xb0\x36\xa2\xf0\
\xae\xc5\x34\x27\x54\x0e\x91\xdd\x93\x45\xde\xb7\x0c\xb2\x4a\x37\
\x21\x22\xbb\x12\x31\xfa\x5e\x88\xc9\xee\x41\x02\x44\x3f\x44\xbc\
\x77\xd8\xf3\x90\x1c\xe1\xd3\xd7\xea\x2b\x41\xc4\x77\x9f\xb5\xb7\
\x0e\x79\x29\x1b\x90\x42\x3a\x1c\x85\xf3\x2e\x47\x02\xc7\x2a\x6b\
\xab\x6b\xa3\x4b\xc0\x32\x1e\x09\x0e\xf7\x92\x10\xe9\x57\xad\xde\
\x0b\x10\x63\x7f\x19\x29\x99\x6b\x10\x03\x98\x66\xf5\xdd\x6b\x7d\
\xdb\x8f\x04\x84\x02\x52\x20\x5d\xb8\x59\x81\x24\x4b\xe2\xab\xd6\
\xd6\xb3\x91\xe0\xb3\x03\x79\xdb\x4b\x90\x87\xf0\x15\xa4\xbc\x4f\
\x47\xcc\xe7\x41\xeb\xe7\x61\x92\x7d\xd3\xcb\xac\xfe\x17\x68\x79\
\x8c\x55\x1f\x6b\xf3\x42\x12\xa1\xaf\xce\xde\xa1\xf3\x08\x6f\x40\
\x16\xdf\x72\x24\xa4\xae\x45\x02\xd8\x38\x24\xfc\xbd\x8c\x98\xce\
\x10\x64\xe4\xd8\x6d\xf3\x63\x9e\x3d\x33\xdd\xfa\xf4\x5b\xab\x6b\
\x92\xf5\xc5\x85\x36\xd5\x21\x05\x70\x3f\x12\xb4\x6e\xb6\xdf\x36\
\xd2\x35\xa1\xc7\x85\x8e\xef\x47\x42\x60\xba\xac\x2a\x92\xb0\x7d\
\x7f\x8f\x52\x2f\x24\x18\xbc\x6c\xef\x7e\x2a\x12\x98\x17\x20\x45\
\x77\x05\x52\xe6\x2f\xb4\xb1\xb9\x1f\x59\xb8\x27\xdb\x18\xac\xb4\
\xe7\x9c\x60\xbc\xc2\xde\xc5\x72\x2b\xb7\xaf\xbd\x87\xfd\x48\x40\
\x7d\x19\xcd\xeb\x19\x76\xff\x1a\x1b\x87\x05\x56\xef\x05\x76\xdf\
\x13\xf6\xce\x03\x13\x0f\x38\x51\x91\x45\x0a\x8e\x3b\xa6\xac\x18\
\xed\x6f\xeb\x0c\x53\x1f\x2e\xb3\xf0\x52\xef\x59\x57\x47\x1f\x44\
\xf7\xea\x10\xbd\x72\xc7\x92\xf5\x43\xc9\xae\x36\xa2\x35\x55\x8a\
\xd6\xe5\x42\x44\x33\xd7\x20\xda\x34\xd1\xee\x79\xde\x9e\xad\x43\
\x7c\xa3\x0c\xd1\xc2\x05\x76\xbf\xcb\x17\x11\x23\x5a\xbd\x0e\x85\
\x53\x8f\x45\x7c\xef\x49\x6b\xe7\x81\xd4\xf3\x8b\xd1\x9a\xcf\x90\
\xe4\x56\x98\x4a\xb2\xfd\xe5\x25\x64\x74\x6d\xb4\x36\x39\x94\x21\
\x4f\xe9\x5e\x12\x25\xf3\x69\x44\x4f\xc6\x23\xa3\xf0\x46\x1b\xdb\
\x15\x56\xd7\x52\xab\xdf\x25\x96\xbc\xd0\xda\xfe\x6b\xfb\x3f\x83\
\x42\xc5\xd7\x59\x99\x6b\x10\x3d\x3b\xdf\xfa\xb0\x08\xf1\x98\x01\
\x24\x21\xcf\xbf\xb7\x36\x57\x91\x24\x79\xec\x65\xe3\x92\xb7\xf1\
\x7f\xc3\xda\x75\xbe\xd5\xb3\x12\xf1\xcc\xb5\x76\xff\x42\x44\x77\
\x47\xda\x33\xcf\x92\x28\xfd\x3b\xed\x19\x27\x07\x2c\x22\x1c\x7b\
\xe3\xa3\x02\xad\xa3\xe7\xd1\xbb\xe9\xca\xb8\xd4\xa0\xf9\xe4\x1f\
\x13\x19\xa1\xf1\xde\x82\xe6\xe5\x19\x56\xd7\xf3\xe8\x9d\x1f\x44\
\x73\xac\x04\x19\x72\x9c\x8c\xb5\x0c\xcd\x8b\xf1\xe8\x3d\xcf\x45\
\x46\xfe\x89\x48\x01\x7d\x0e\xcd\x81\x49\x24\x61\xd3\x0f\x92\x18\
\xb1\x5c\xdd\xe7\xa3\xf5\xe4\xf8\xb2\xdb\xbb\xbe\xcc\xfe\xdf\x65\
\x6d\xbe\x08\xf1\xd6\x0d\x88\x37\xbb\x88\x86\x35\x34\xe7\xf7\x31\
\x9a\xbf\x97\xa0\x50\xfe\xba\x2e\x8e\x59\xc0\xf1\x45\x15\x92\x8b\
\x1e\x8e\xa6\x0c\xaf\xda\x73\xf7\x1d\xa3\x6b\x6a\xab\x73\xc4\xa7\
\x70\xc4\x7b\x21\xd5\xf7\x4c\x98\xde\x47\x05\xf5\x4d\x31\x9f\xfc\
\xfd\xda\x3d\xf7\x2c\xdc\xfd\x19\x92\x0c\x8e\x6d\xc1\x0f\x6d\xf3\
\xc3\xc9\xf2\x1d\x78\x16\x92\x30\x16\xff\xf8\xa2\xd6\xea\x71\x96\
\x73\x7f\xff\x6b\x67\xe0\x3f\x57\x68\xa7\x7d\x7e\x68\x76\xba\x5d\
\xee\x59\xbf\x9f\xae\x2d\xad\x3d\x13\xa7\xee\x73\xd9\x53\x3f\x8c\
\x94\xac\x65\x24\x96\xfd\xd6\xea\xec\x68\xdb\xdb\x83\x0b\x21\x6a\
\x6f\xac\x8a\xf5\x31\x2a\xf2\x7c\xfa\x1d\x3a\xb8\xbe\xb8\x64\x5d\
\x1f\x42\x7b\xab\xd7\xa1\x24\x35\xf3\x68\xb9\x77\xbc\xb3\xc8\xa3\
\x64\x1f\x9b\x90\xe0\x76\x24\x21\x51\x1d\x7d\x9f\x6e\xec\xfc\x67\
\x3a\x5b\x8f\x7b\x87\x6e\x2c\xdb\x9b\x37\x01\x01\x27\x1a\x4a\x51\
\x16\xd7\xdf\x90\x84\xba\x1e\x0b\xb4\x46\x23\xfd\x2d\x19\xfe\xff\
\xce\xdb\x9c\x0e\x7f\xf6\x91\xa6\xdb\xd0\x92\x5e\xb4\xf5\x3c\x6d\
\x3c\x57\x6c\x5c\x5c\x52\xa9\x2f\x01\xff\x07\x29\x03\xee\xb9\x8e\
\xf0\xd7\x62\xf4\x24\xcd\x77\xdc\x76\x8f\x89\x28\xb1\xd5\xb7\x90\
\xb2\xe2\x7e\xef\x2c\x9f\x49\xf3\xe6\x62\xcf\xb4\xc5\x73\x3a\xc2\
\x8f\x4e\x35\xc4\xc8\xa0\xf3\x05\xe4\x45\x2f\x76\xde\x6f\x77\xa1\
\x23\xf3\xb2\x58\xfb\xd2\x21\xce\xfe\x7a\xc2\xbb\x56\x8c\xaf\x95\
\x21\x79\xe0\x09\x64\x2c\x69\xad\xce\xf4\x3a\x6e\x6b\x0c\x0a\x68\
\x3e\xf7\xa5\xf8\x36\xb4\x80\x13\x07\x31\x8a\x96\xfc\x08\xf0\xd9\
\x53\x7e\x8f\x70\x26\x82\x37\xb6\x1c\xe2\x6b\xcf\x6d\xe5\x70\xa3\
\xd6\x53\x75\x59\x96\xcf\xcd\x1a\xcc\x99\xfd\xcb\x5a\x28\xc8\x01\
\xc7\x1c\x51\x91\xef\x7e\x98\x58\x7b\xf0\x19\x7c\x7b\xf5\xc4\xa9\
\x67\x3a\x8b\xb4\x82\xd3\x91\xfa\xa2\x56\xca\x49\xf7\x33\x6d\x0c\
\x68\xab\xfd\xee\xff\x03\x68\xef\x4c\x5f\x12\x46\xd4\x56\x9d\x1d\
\x6d\x7b\x7b\xe8\xc8\xd8\xb5\xd7\xc7\x62\x6d\x4b\xb7\xdb\x57\xf6\
\xfa\x23\xaf\xe8\x5a\x24\x68\xbd\x88\x98\x7b\x4f\x08\x75\x39\x92\
\xf7\x79\x24\xed\xf6\xdf\x61\x94\xfa\x1b\x12\xc3\x04\x04\x74\x0d\
\xad\xd1\xc8\x62\x1e\x69\xe8\x18\x9f\x2a\xa6\xa4\x65\x3a\xf1\x7c\
\x67\x9f\x73\x7b\x7b\x5f\x27\xd9\x07\x5c\x8c\x26\xb5\xf5\xbc\xbb\
\xa7\x18\xbd\x76\xfd\xa9\x42\x9e\xb6\x47\x91\x77\x2f\x4a\xfd\x0e\
\x1d\xef\x5b\x47\x9e\x69\x8b\xe7\x04\x29\xee\xf8\xe2\x48\xe6\x73\
\x6b\xf3\x2c\xfd\x7c\x6b\x7c\xed\x10\x92\x7d\xfa\xb7\x53\x67\x5b\
\xeb\x38\x8d\x32\xab\xef\x51\x02\x3f\x3d\xa9\x70\xca\x2b\xc2\x51\
\x14\xb1\xbd\xae\x89\x07\x96\xee\xa5\xbe\x49\x8a\x70\xef\xb2\x2c\
\x1f\x9e\x32\x80\x28\x2a\xe7\x94\x76\x93\x07\x9c\xe8\x70\x7b\x97\
\x3b\x1a\x26\x78\xa2\x22\x83\x42\xf6\x56\x92\x58\x9d\xd3\xe1\xdb\
\x01\x01\x01\x01\x01\x0a\x69\x76\x1e\xad\xa3\x41\x23\x23\xb4\xfd\
\xe6\xeb\x04\x85\x21\xe0\xf8\xc0\xed\x4f\xee\x4e\x43\x78\x23\x0a\
\x89\x0e\x73\xfa\x24\x43\x4f\xf0\x96\x1c\x77\x44\x40\x89\x37\x12\
\xb9\x4c\xa4\x59\x1e\x74\xe0\x93\x01\xee\x78\x19\x77\x34\x46\x67\
\x12\x05\xc5\x9d\xbc\xff\x78\xf4\xad\x3d\xf8\x99\x0e\x8f\xb4\x7c\
\x17\x6a\xdb\x93\x91\x66\x4e\xc7\x8a\x51\xb9\x79\xe5\x7f\xdc\xb8\
\xb9\x79\xe7\xfe\xb6\xf6\xfc\x91\x84\xe0\xc7\xed\xfc\xde\x1d\xf5\
\x04\x04\x9c\xec\x68\x6b\xfd\xf6\x14\xb4\xb6\x76\xdb\xa3\x03\x74\
\xd3\x33\x5d\x29\xbb\x18\x1d\xf6\xf9\xd1\x91\xb6\xe7\x68\xf4\xa3\
\x33\x32\xc2\xd1\x1c\xc7\xe3\x3d\x0e\x47\xda\x8e\x8e\xae\x1b\x7f\
\x3e\x77\xa6\xfd\x9d\xed\x6b\x47\x42\xe2\x5b\x5b\x5b\x6d\xf1\xcb\
\xd6\x64\x8b\x63\x45\x37\x3a\x53\x4f\x57\x65\xb8\x9e\x32\xbf\x8e\
\x2a\x82\x22\x1c\x70\x32\x23\x87\x32\xf3\xbe\x13\x9d\x65\xf8\x0e\
\xb4\xc7\xa3\xa3\xfb\x3c\xab\x50\x82\xa9\x9e\xb6\x4e\xdc\x3e\xaf\
\xeb\x49\xce\x54\x6e\xeb\xde\x4a\xe0\x0a\xfb\xdb\x51\xa2\x56\x86\
\x92\x55\x64\xd1\x99\xbf\x17\x74\xe2\xd9\x53\x05\x05\x74\x86\xf4\
\xc7\x81\x3f\xb5\xcf\x7b\x50\xb2\x9a\x1c\x3a\x13\x73\xa0\xfd\x2d\
\x76\xa6\xb4\x3b\xff\xf3\x42\x3a\xce\xdc\x32\x28\x03\xe7\x50\x5a\
\xbe\x0f\x17\x92\x78\x2d\xda\x47\xe9\x5f\x3f\x17\x25\xb1\xe9\x69\
\x42\x7e\x40\xc0\xf1\x42\x8c\xd6\xef\x87\x81\x0f\xd8\xe7\x83\x28\
\x91\x54\x4f\x89\x96\x73\x7b\x39\xcf\xa4\xe5\x7a\x3f\x93\x24\x63\
\x7e\x47\x50\x20\x49\x50\xd8\xdd\x74\xa0\x04\x65\xa1\xee\xdb\x81\
\xf6\x54\xa2\x44\x60\x19\x74\x52\xc1\xd8\x23\x68\xcf\xc5\xe8\xdd\
\x75\x57\x3f\xdc\x38\xdf\x89\x4e\x26\x68\x4b\x46\x28\xa0\xe4\x4f\
\x67\x76\x63\xfd\x47\x82\x52\x94\x85\x7b\x20\xc7\x97\x37\x17\x50\
\x92\xc6\x29\x1d\x68\x47\x8c\xb2\x39\x8f\x42\x63\x3c\x0b\x25\xa0\
\x6a\xef\xb9\x0c\x7a\x2f\x43\x3b\x70\x6f\x47\xe1\xb2\x8d\x0f\x4f\
\x95\x19\xa3\x44\x5b\xe3\x3b\x51\x57\x19\x92\xc7\xfa\x74\x63\xfb\
\x8a\x21\x8b\x8e\xa4\xea\x48\x3d\x15\x68\xad\x67\x50\x12\xce\xb3\
\x3a\xd9\xb6\x18\xbd\x9f\xd3\x39\xc9\xe5\x86\x9e\x26\xe0\x07\x04\
\x38\xcb\xa2\xb3\xce\xfb\x96\xc3\xb6\x2c\xf6\x71\xea\xf7\x02\xca\
\x80\x7c\x23\x0a\x99\x3d\x07\x1d\x79\xb1\xb2\x8d\xb2\xfc\xeb\x79\
\x94\x6d\xf7\x76\x8a\x2b\x1c\xe9\xe7\x63\xda\x6f\x63\xc1\xfb\x2d\
\x7d\x7f\x7b\xfd\x4c\xdf\xdb\x1b\x31\x86\xb2\x22\xed\x76\xd6\x3f\
\x57\x46\x06\x65\x75\xcc\xb4\x73\xaf\xff\x19\x61\x7d\xcf\x22\x65\
\xbb\xaa\x95\x76\xd0\x4a\x99\xa7\x02\x62\x94\xad\x74\x12\xca\xae\
\xba\x14\x09\x79\x9f\x42\xc2\x89\x3b\x02\xe9\x12\x12\xa1\xcd\x7f\
\xb7\xce\x48\xe1\x32\xd7\x76\x74\x3e\xd4\x20\x21\xa8\xd8\x5a\xc9\
\x22\x61\xd4\x59\xc3\xf3\x28\x53\xfa\x44\xc4\x08\x5b\x5b\x5f\x01\
\x01\x27\x0b\x3a\x1a\x01\xe3\xb2\x0d\x4f\x44\x19\x98\x17\xa2\xcc\
\xb1\xef\x42\x8a\x4e\x6b\x6b\xa5\x18\xfd\x2f\xa4\x7e\x8f\x29\xce\
\x93\xd2\xcf\xb4\xb7\xde\x0b\x28\xcb\xf2\x1c\x92\x73\x4e\x41\x74\
\xe5\xdd\x48\x90\x2f\xd0\x31\xbe\x51\x40\xd9\xac\xc7\xa0\x30\x4f\
\x9f\xfe\xa7\x9f\x69\x8d\x9f\x15\x68\xd9\x1f\x77\x66\xf9\x4c\x44\
\xf3\x9a\xbc\xb6\xa6\xc7\xa5\x11\x65\x0f\xbe\xc5\xfe\x9f\x8c\x0c\
\x87\x7e\x7b\x5a\x1b\x07\xbf\x1d\xbd\x48\xf6\x6c\x16\xe3\x3d\xed\
\xd1\xb8\xd6\xc6\x79\x1c\x3a\xe5\xa1\xd0\xce\xbd\x17\x20\x65\xae\
\x58\xbb\xd3\x6d\x6d\xef\x5d\x17\x28\xfe\x0e\xdd\xf7\xd6\xda\xe1\
\x8e\xd9\xea\xcf\xd1\xa1\xe3\x1d\x5d\x47\x31\x5a\x2f\x93\x69\x5f\
\x56\x2a\xa0\xd3\x1d\xdc\xf1\x8f\x33\x90\x52\xe7\xcf\x99\x62\x7d\
\x8d\xac\xaf\x6e\xbe\xfb\xf7\xf9\xdf\x8b\xad\xbb\x74\x3b\xfc\xb6\
\xdc\x80\xd6\x44\x7a\xcc\xab\x90\x22\x59\x8c\x2f\xfb\xde\x55\x57\
\x6e\x19\x32\x4a\xf4\x49\xdd\x9f\x6f\xa3\x4d\xad\xf5\xd5\xbf\x96\
\x5e\x8b\x11\x32\x38\xf5\xa2\xed\x75\xd6\x84\xd6\xd5\xad\x76\xed\
\x5c\xfb\xbf\x89\xb6\xe7\x6b\xba\xde\xde\x74\x6d\x9d\x9d\x10\xe8\
\x29\x56\xcf\x80\x00\x87\xe9\x28\x95\xfd\x20\x92\xe3\x5e\xdc\x31\
\x0f\x17\xa2\xc5\xf6\x0a\xc9\x31\x41\x90\x64\x0d\x9e\x85\x08\xd1\
\x12\x74\xec\xc2\x1c\x64\x6d\x1c\x4f\x72\x9e\x61\x19\x52\x24\x2e\
\x41\x16\xe0\xc5\x28\x3d\xbf\x63\x6e\x93\x50\xca\xff\xe7\x49\xac\
\x82\xd3\xd1\xb1\x41\xae\xae\x3e\xf6\xbc\x3b\xae\xe8\x25\x44\x30\
\x2e\x40\x02\xc1\x40\x74\x2e\xe3\x9b\x5e\x1b\xcb\xac\x3d\x6e\x0f\
\xeb\xd3\x56\xfe\x19\xe8\x2c\xc6\x67\x91\xa2\xea\x8e\x7a\x1a\x64\
\xed\x5a\x80\x18\x9e\xb3\x40\xef\xb4\x67\x7d\x26\x35\x18\x25\x26\
\xe9\x8b\x12\x93\x3c\x89\x18\xc6\x04\xa4\xc4\xae\xb6\xe7\x2a\x91\
\x35\xb1\x17\xc9\xf9\xb7\x0f\x20\xe2\x78\xb1\xf5\x6b\x2b\x3a\x1a\
\xe4\x02\xe4\xad\x9c\x89\xb2\x30\x67\xad\x5d\xe7\xd8\xe7\x90\x8d\
\xc9\x46\x7b\xb6\x12\x1d\x55\xb1\xcf\xea\x3f\x95\x8e\xa9\x58\x87\
\x12\x73\x34\xa2\xb9\xf5\x0f\xc8\x72\xbd\x93\x24\x21\x4d\xc1\x7e\
\xbb\x14\xcd\x8f\x55\x68\x8e\xd5\x91\x30\xfa\xf1\x68\x8e\x37\xa2\
\x23\x22\x36\x93\xcc\x41\x77\x2e\xe7\x12\x74\xb4\xd4\x61\xc4\xc0\
\x07\x91\x9c\xa1\xf8\x04\x3a\x92\x62\xa7\x95\x39\xc8\xea\xc3\xda\
\xb3\xc8\xea\x39\x97\xe4\x7c\xe8\xe7\x08\xfb\xa9\x03\x4e\x1e\xc4\
\x88\x7f\x0c\x40\xf3\xba\xbe\x03\xcf\x6c\x41\xb4\xcc\x65\xb4\x75\
\x4a\xce\x33\x68\xed\x4d\x41\x34\xf2\x05\x74\xa4\x4a\x2f\x44\xff\
\x6b\x11\x6d\x7d\x05\xd1\xdf\x45\x88\x1e\x9e\x8d\x0c\x55\x7b\x90\
\x72\x50\x82\xd6\xb2\x53\xde\x0e\x59\xd9\x17\x20\xa5\x74\x1b\xa2\
\xff\x05\x44\x6f\x0b\x24\xeb\x75\x21\xa2\x01\xa7\x91\x28\xec\x31\
\x12\x6a\xc7\x21\xa1\x78\x03\x32\x5c\x9e\x8b\x68\xfa\x02\xc4\x7f\
\x72\x88\x77\x9d\x61\x7d\x7c\xd2\xfa\x38\x12\x29\xfb\x11\x3a\x8b\
\xbd\x16\xd1\xfe\xe7\xad\xad\x97\x22\xde\xd5\xdb\xea\xae\x40\x74\
\xe7\x15\xc4\x87\x06\x22\xbe\xb2\x1e\xd1\x98\x72\x94\xa4\x10\x44\
\xbf\x66\x59\x7f\x9f\x47\xca\xe5\x1a\x64\x80\x1e\x64\x7d\x3e\xdd\
\xfa\x32\xcd\xda\x73\x5a\xaa\x3d\x0d\x56\x4e\x99\xb5\xed\x75\x1b\
\xbb\x31\xe8\x24\x80\x37\x90\x4c\x70\xd8\xda\x78\x31\xe2\x77\x07\
\x10\x6f\x74\xc7\x36\x4d\xb2\xf7\xff\x0c\x2d\xcf\x7d\x75\xb4\x36\
\x8f\xf8\xf7\x01\x6b\x77\x29\x89\x71\xd9\x65\x2d\x76\xc7\x0e\x96\
\xd9\xf8\xbf\x64\xcf\x9d\x01\xdc\x65\xef\xf3\x49\x6b\xf7\xe5\x56\
\xe7\x08\xb4\x47\xf5\x25\x44\xbb\xa7\xd9\xfd\x3b\xbd\x77\x7d\xb1\
\xd5\x77\x00\xf1\xcb\x0a\x7b\x6e\xab\xbd\xd3\xf3\x6d\x0e\x3d\x86\
\x78\xc2\x54\x64\xcc\x04\x25\x86\xdc\xc8\xd1\x53\x40\x9c\x4c\xd5\
\xcb\xc6\x2e\xdf\xce\xfd\xc5\x42\xa3\x63\x7b\xd7\x17\xd9\x38\xbe\
\x6a\xf3\x62\xb2\x95\xfb\x2a\x89\x31\x64\xba\xbd\xb7\xa7\x6d\x1c\
\x27\x93\x44\xe3\xcd\x47\xf3\xcf\xf5\xd5\x19\x79\x07\xda\x7c\x7a\
\xc2\xc6\xdc\xf1\xce\x15\x68\x7d\x0e\x45\xeb\xf3\x79\xeb\xcb\x14\
\x6b\xe3\x40\x7b\x2f\xdb\xd1\x9a\x19\x65\xef\xea\x74\x24\xc7\x1c\
\xb0\x71\xaf\xb3\x77\x77\xa1\xb5\x65\x37\x92\x8d\x46\x79\xfd\x19\
\x88\xe4\x2c\x77\xe4\x57\x01\xad\xa5\x99\x68\xee\xee\xb1\x67\x4a\
\x6d\x0e\xe4\xec\xdd\xbe\xec\x8d\xd3\x38\x7b\xd7\x65\xde\x9c\x99\
\x8e\xf8\x7a\x25\x3a\x9a\x6d\x08\xa2\x6b\xee\x48\xcf\xf3\x91\x41\
\x61\x8b\xcd\xa7\x8b\x48\xf2\xa4\x0c\xb4\x36\x9f\x6e\x6d\x9b\x4e\
\xb2\xce\xee\xb4\xe7\x9f\xb4\x7e\x5e\x64\xff\x8f\xb4\x3e\x64\xad\
\xaf\x4b\x50\xc2\xd1\x3d\x68\x7e\x57\xda\xbd\x23\x6d\xac\x9f\xb3\
\xb6\x9c\x67\x63\xd8\xda\x3a\x3b\x21\x10\x3c\xc2\x01\x3d\x09\x31\
\x62\x0e\x57\x20\xe6\x39\x01\x85\x79\x8e\x42\xe1\x6b\x7b\x10\xc3\
\xf8\x08\x5a\x90\x8e\xf0\x96\x01\xef\x47\x84\x63\x29\xb2\xcc\x4d\
\x45\x8c\x7a\x0f\x5a\xd4\x1b\x11\x11\x3e\x00\xbc\x0f\x11\xc6\x25\
\x48\x31\x9c\x8e\x16\xf3\xdb\x11\x43\xef\x65\xf5\xee\xb2\xe7\x37\
\x7b\x6d\x2c\xb5\xba\x46\x58\x5d\x57\x00\xd7\x58\xdd\xef\xb6\xb6\
\xec\xb2\x3a\x06\x91\x58\x03\x4b\x51\x68\xf6\x60\xab\xe3\x2a\x44\
\x58\x16\x22\x82\x75\x3b\x52\x94\xee\xb4\xb2\x36\x03\xef\x45\xcc\
\x73\x8e\xb5\x73\x19\x22\xee\x1f\x24\xb1\xd2\xe5\x90\xd7\xbb\xc2\
\xca\x9a\x69\x9f\xd3\xad\xac\x6d\x88\xb1\x5c\x62\xf7\x2e\x47\x04\
\xaf\x1f\x22\x62\x31\x3a\x73\xb7\xdc\x9e\xbf\xc4\x3e\x5b\x91\xb0\
\xb1\x11\x09\x5d\x13\x6d\x8c\xee\x44\x84\x3c\x8b\x42\x82\xfb\x23\
\x01\x62\x36\x52\xee\xce\xb7\xf1\x38\x61\xad\x83\x47\x80\x0a\xf4\
\xae\x6b\x11\x03\x2f\x43\x06\x81\x8b\x49\x42\x17\x0b\x28\x74\x6a\
\x0c\x9a\x77\x17\xa3\x77\x3b\x06\x09\x6c\xa3\xd0\xfb\xde\x86\x98\
\xd6\x4d\x48\x58\xbb\x1a\x8d\xeb\x5e\xf4\xde\xfb\xa1\xf9\x3a\x08\
\xbd\x8f\x1b\xd1\x3b\x1a\x82\xe6\x6f\x35\x12\xc6\x7a\xa3\x50\xcf\
\x4a\x24\x7c\x8d\xb5\x76\x9c\x87\xe6\xda\x6a\xc4\xb0\xde\x8f\xe6\
\xfb\xa9\xf4\xbe\x02\x4e\x5e\xe4\xd0\xb1\x29\xdf\x44\xde\x90\x8e\
\x84\x6a\x0e\x43\xf4\xfe\x46\x44\xc3\xfb\x22\xa5\x6f\x0c\x52\x74\
\x36\x23\xbe\xf3\x7e\x44\xbf\xef\x40\x0a\xc9\x72\x44\xc3\x27\x23\
\x9a\x39\x18\xad\xf3\x33\x11\xbd\x1c\x6e\xe5\x39\xc3\xd5\x9d\x88\
\xc6\xaf\x47\x7c\x63\x36\x52\xac\x86\xa2\xed\x3b\x35\x88\x47\xd4\
\x92\x78\xa6\x47\x20\x81\x7d\xa7\x7d\x40\xeb\x76\x9f\x7d\xd6\x21\
\x1a\x7c\x93\x3d\xb3\xcd\xda\x5c\x6b\x75\xcc\x42\x7c\xea\x0c\x12\
\x2f\xdc\xd9\xd6\xa7\x61\x88\x16\x94\x5a\xdf\xab\xac\x2d\xb3\x10\
\x4d\xb8\xd5\xea\x5c\x4b\xb2\xbd\x68\x06\x52\x94\x57\x59\x7f\xdf\
\x8d\xf8\xdd\x2e\x1b\xb7\xd3\x11\x6d\xb9\x0a\xf1\x82\xa1\x88\x7f\
\x39\xaf\xe1\x99\x56\xf7\x1e\x24\xc4\x67\x10\x9f\xdf\x6c\xe3\x75\
\x1b\xa2\x5d\xef\x46\x0a\xc5\x01\xe0\x2f\xac\x9c\x5d\xd6\xb7\xbe\
\x48\xd0\x1f\x66\x63\x78\x06\x52\x8e\x47\x5a\x9b\x87\xd9\x3b\x5a\
\x87\x14\xfb\xeb\x49\x42\x9d\x0b\xf6\x5e\x3f\x68\x7d\xab\x03\x3e\
\x86\xe8\xea\x26\x6b\xc7\x4e\x12\x65\x6b\x00\xf2\x5e\x6f\xf3\xde\
\xc9\x48\x12\xc3\xe5\x46\xab\xff\x1d\x88\x0f\xdc\x61\xbf\xaf\xb1\
\xb1\x3d\xcb\xfa\x3f\xc7\xe6\xcb\x70\x44\x97\x07\x58\x59\xe5\x56\
\xef\xa5\xd6\x97\x35\xf6\x2e\x6e\xb1\x71\x9f\x4d\x62\x30\xb9\x9c\
\xe4\x1c\xf9\x0f\x21\x5a\x7f\x34\xe0\x8c\x49\x5f\x44\xeb\xe8\x62\
\x3a\x1f\x1a\xeb\xc2\x8e\x3f\x84\xe6\xe9\x56\xb4\x6d\x68\x08\x9a\
\xcf\xdb\xec\x7d\xf6\xb1\xf1\x5b\x65\x63\x70\x11\x9a\xf3\xd7\xd8\
\x58\xec\x25\x91\xed\xd2\x6b\xb9\x91\x64\xdb\x91\x7b\xcf\x65\x36\
\xee\x63\x90\x3c\x73\x21\xe2\xa1\x03\xd0\x9c\xc2\xda\xf3\x41\x1b\
\xfb\x5d\xf6\xce\x0b\x68\x8e\xf7\x41\xeb\x73\x82\x95\x31\x0d\x79\
\x8d\x9d\x82\x79\x25\x5a\xef\xe7\x20\x3e\xdd\x17\xc9\x5b\xce\xa9\
\x18\xd9\x3d\xc3\xd0\x9c\x1c\x6f\xed\x1a\x88\xe6\xee\x61\xeb\xbb\
\x1b\xa3\x7e\xf6\xae\x77\xa0\xf9\xfa\x0e\xb4\x86\x66\xd8\xfb\x5e\
\x8d\xe8\xc2\x7b\xec\xd9\xed\xf6\x6e\xdc\x98\xcd\x41\xf3\x63\xb0\
\xd5\x1b\x23\x85\xff\x4c\x34\xaf\xf6\x58\xff\x9c\x82\xeb\xd6\xfd\
\xad\xd6\xff\xb7\xa3\xf9\xba\x0d\xf8\x24\xc9\x5a\xbc\xc3\xde\xd5\
\x54\xbb\xff\x42\xeb\xf7\x42\x12\x39\x75\x38\x9a\xc3\xeb\xac\xff\
\xd7\x71\x82\x3a\x57\x4f\xc8\x46\xf7\x54\x44\x11\x64\x88\x88\x3c\
\x7b\x48\x0c\x14\xe2\x38\x24\x9f\xee\x38\x1a\x91\xb5\xea\x09\xc4\
\x58\xce\x45\x8b\x70\x1d\x70\x9f\xdd\x33\x06\x31\xd9\xd5\x88\x80\
\x39\x05\xe4\x49\xb4\x78\x4b\xec\xff\xfb\x10\xe1\x78\xc9\xae\x97\
\x22\xcb\xfe\x79\xc8\x4a\xe7\xae\x4d\x43\x0c\x71\x2e\xf2\xec\x55\
\xda\xe7\x2c\x7b\x7e\x8d\xd5\xeb\xea\x3a\x0d\xf8\x47\xc4\x04\x1b\
\x11\xa1\x5b\x8b\x88\xe5\x83\x76\xef\x25\x88\x48\x3a\x6f\x5b\x84\
\x88\xd2\x13\xd6\xee\x0f\x58\xd9\xc3\x48\xf6\x70\xbc\xe2\xf5\x73\
\x27\x22\xf0\xd3\xed\xef\xc3\xf6\xec\x22\xe0\xcb\x24\x7b\x65\xf2\
\xf6\x5b\x7f\x24\xbc\xe4\x10\x81\x5a\x8b\x14\xae\x27\x49\x42\xa7\
\x0e\x23\x8b\xfa\xb9\x88\x31\xfc\x07\x22\x7a\x0f\x23\x82\xec\x9e\
\x1f\x8a\xac\x7b\xdb\x10\xb1\x1d\x61\xcf\x5f\x84\xac\xb3\x7f\xb4\
\xf1\x19\x8f\xac\x99\xf5\xc8\x7a\xf8\xb8\xf5\xb9\x27\xee\xab\x3e\
\x5a\x28\x20\xa1\xf7\x2f\x48\x42\xff\x7e\x8b\x84\x26\x68\xce\xbc\
\xeb\xd0\xdc\xd9\x8a\x2c\xdf\x1b\x10\xc3\xca\x23\x66\xb6\x1e\x79\
\xe8\x4b\x11\xb3\xc9\x03\xf7\xa2\x75\x90\xb3\x6b\xbd\x49\x2c\xe3\
\x05\x64\xed\x7e\x1c\x79\x82\x6f\x42\x73\xbf\x09\xcd\xed\x81\xc0\
\x7f\xa1\x79\x77\x1a\x9a\x83\xd3\xd0\xbb\x1b\x88\x84\x86\x71\x68\
\xbe\x38\x6f\x71\x40\xc0\x89\x8c\x08\xad\x91\xde\x24\x91\x2f\xed\
\xa1\x04\x29\x81\xa7\x21\x5e\xf3\x75\xb4\x1e\xde\x89\x68\x67\x1f\
\x24\x48\x8e\xb4\xdf\xc7\xa0\xb3\x71\x57\x22\x6f\x65\x29\x89\x10\
\x0a\x89\x77\x2c\x42\x8a\xcb\x13\x56\xce\x6e\xb4\x56\x37\x22\xa1\
\xfc\x30\xa2\xb5\x59\xc4\xcf\x9e\x41\xb4\xe1\x01\xc4\x1b\x9c\x21\
\x6d\x93\xd5\xb1\x99\x44\x66\x73\x8a\xf1\x4a\x44\x37\x7e\x87\xd6\
\x75\x0d\xa2\xc1\x83\xd0\x5a\x7f\x00\x79\x6f\xe6\x59\x3d\xef\x40\
\x1e\xa4\xc7\x91\xa7\xe7\x06\xc4\x8f\x0e\x23\x7e\x37\x12\x79\xd4\
\xd6\x58\x99\x55\x56\x56\x25\xc9\x5e\xce\x17\x11\xdd\xb9\xd6\xeb\
\x5f\x29\xa2\x41\xf7\x03\xaf\x21\xba\x32\x02\x79\xd1\x3f\x8c\xe8\
\xd1\x44\xc4\x6b\xb0\x7e\xae\xb5\xf2\x9e\x41\x5e\xcf\x7a\xa4\x00\
\x95\x22\xc5\xe0\x01\x44\xfb\x2e\xb6\x3a\xea\x90\xe2\xe3\x68\x20\
\x88\xb7\x6f\xb0\xf6\x45\x56\x0f\xd6\xd7\xc9\xc8\xd0\xb0\x9a\xe6\
\x74\xf8\x7c\xab\xfb\x0f\x88\x4f\x9d\x81\x8c\xbd\x6b\x10\x4d\xdc\
\x60\x73\x22\x42\x8a\xd8\x6f\x49\x22\x9e\xaa\xec\x5d\x16\xac\xcd\
\x8f\xd9\xfb\xf9\x53\x9b\x6f\x3b\x90\x0c\xb0\x91\xc4\x2b\x37\x0d\
\xf1\xcc\x27\xad\x3d\x5f\xb2\x76\x6e\xb3\xf7\xb0\xc5\xc6\xf2\x69\
\xfb\x7f\x9a\xdd\xf7\x88\x8d\xd9\x50\x7b\x7f\xf7\xd9\x78\x64\xec\
\x5d\x54\x73\xf4\x0c\x98\x59\x12\x7e\x53\x79\x04\xcf\xe7\x91\x1c\
\x30\x9c\x24\xcc\xb8\xbf\x8d\xf3\x66\xa4\x84\x6d\x47\x73\xe6\x01\
\x24\xfb\x9c\x81\xd6\xe0\x73\x34\xe7\x7b\xc5\xfa\x1a\xa1\xf5\xb4\
\xc0\xde\xb3\xbb\xb6\x19\x29\xdf\x6f\x92\xc8\x56\xd3\xec\x1d\xad\
\xb0\xf7\x50\x41\xe2\x9d\xdd\x8a\x64\xae\xdd\x48\x41\x7e\x14\xc9\
\x3c\x17\x5a\x79\x33\x48\x78\xec\x4b\xd6\xee\xb4\x81\x2d\x6d\x24\
\x78\x0e\x29\xa6\x55\x56\xc6\x08\x44\x27\xd6\x91\xf0\x6a\x77\x92\
\xc7\x7e\x34\xbf\xaa\x49\xb6\x53\x0d\x40\x72\xc4\xcb\x56\xd6\x74\
\x34\x9f\x1e\xb6\x71\x3d\x88\xe6\xd8\x7c\x24\x3f\x0c\x43\xeb\xec\
\xa3\x68\x5e\x4d\x42\xf3\xb2\x09\xcd\xb1\x35\x48\x1e\x75\xeb\xec\
\x10\x92\x59\x4b\xac\xdf\x8f\xa0\x79\x7e\x35\x9a\xa3\x1b\x48\x42\
\xd6\xdd\x3a\x7b\xd3\xda\x5a\x6e\x6d\x1f\x6e\xd7\x33\x48\x9e\x5e\
\x4a\xb2\xed\xf0\x84\x43\x50\x84\xbb\x01\xd9\x28\xa2\xa9\x10\xb3\
\xe3\x60\x13\x1b\xf6\x36\xb0\xa3\xae\x89\x86\x7c\x4c\x59\x36\xa2\
\x4f\x45\x96\x91\x7d\xca\xe8\x5f\x99\xa3\x24\x13\x91\x0f\x1a\x71\
\x7b\xc8\x23\x2b\x70\x96\x84\xd8\x94\x20\xc2\x00\x89\xb2\x51\xe2\
\x3d\x93\xb5\x6b\x9b\xd0\x62\x7d\x0a\x11\x38\x47\x6c\xb2\xf6\x37\
\x83\xe6\x7c\xbd\xdd\x7b\xc0\xee\xdd\x86\x2c\xaf\x0d\x56\x5e\x0e\
\x11\x32\xc7\x0c\xfd\xec\x83\xae\x5d\x4d\x76\xbd\xc1\xca\xcd\x58\
\x79\xb1\x77\x4f\x5a\x08\x6b\xb4\xba\x73\x76\xff\x16\x6b\xe7\x2e\
\x44\x28\x0f\xd1\x7c\xcf\x91\xeb\x67\xc6\xea\x71\x61\xd5\x05\xaf\
\x8e\x4a\x64\xd5\xcb\x22\xa1\xe4\xb0\x57\xef\x41\xfb\xeb\x9f\xc3\
\xe7\xc2\xb9\x7e\x8f\x98\x48\x8d\x3d\x9f\xf1\x9e\x77\xfd\x49\xb7\
\x3f\x67\x6d\x72\x87\xdc\x37\x79\xe3\xe9\xc2\x88\x4e\x48\x42\xd8\
\x05\x64\x90\xe5\xf7\x3f\xd1\xbb\x69\x44\xef\xb1\x22\x75\x5f\x16\
\x31\x19\xe7\x9d\xbd\x83\xe6\x9e\xd8\x1c\x1a\x4f\x57\x66\x2d\x62\
\x88\xd7\xa1\x48\x80\xfd\xf6\xbb\x6f\x60\x28\xd0\x72\xad\x44\x5e\
\x7d\x7e\xf8\xbc\x9b\xaf\x59\x24\xac\x6d\xb1\xef\x3f\x26\x84\x46\
\x07\x9c\x3c\x68\x44\x4a\xea\x43\x68\xdd\x14\xa3\xc3\x3e\x22\xa4\
\x14\xdd\x83\xd6\xc3\x47\xd0\x9a\x7b\xdd\xfe\xdf\x4d\xe2\xb9\xfc\
\x39\xe2\x1b\x97\x90\xac\xd5\x5e\x34\xf7\xcc\x15\x90\xb0\xe8\xea\
\x3c\x64\x7f\xb3\x88\xb6\x36\xa2\xb5\x1e\xd1\x9c\xfe\x2f\x41\xf4\
\xba\x8e\x64\x9d\xbb\xfc\x0e\xc5\x68\xb1\xcf\x97\x46\x21\x8f\xd1\
\x2a\x92\xed\x18\x19\x12\xbe\x88\xb5\xc9\x19\x44\x0f\xa4\xca\x3b\
\x88\x94\xd7\x59\x48\x78\xff\x2d\x12\xa8\xdf\x6d\xfd\xdd\x84\x68\
\xbc\xab\xef\x20\x2d\x79\x4c\xc6\xfa\x7a\x98\x84\xf6\x64\x6c\x6c\
\xf7\x20\x21\x3b\x87\x04\xe6\x09\xa9\xfa\xf7\xd3\xd2\x70\x7a\x80\
\x64\xef\x71\x3d\xcd\x79\x5e\xec\xd5\x79\x25\xa2\xa7\x0b\xac\xee\
\x1a\x1b\xcf\xef\x90\x84\xb5\x5f\x0c\x7c\x15\x09\xfb\x90\xf0\x31\
\x68\x29\x4f\x44\x5e\x5b\x0a\x24\x5e\xfd\xf5\xf6\xae\x1c\xbf\x77\
\xcf\x45\xde\x5c\x70\xf2\x80\x1b\x03\x17\x6a\x9f\xa5\x39\xff\x76\
\x32\xc2\x21\x7b\xd6\xfd\xee\xf3\xd0\x7a\x12\x2f\x76\x1e\x79\x20\
\x6f\xb2\x79\x72\x98\x96\xbc\xa0\x3b\xe1\x22\x0e\xfe\x11\x29\x67\
\xee\x08\xc6\xf6\xe0\x0c\xf3\x6e\xec\x72\xf6\x6e\xb7\xd8\xff\xf7\
\x5a\x59\x97\x92\xcc\xdf\x7a\x1b\x87\x9c\x57\xc6\x58\x64\x84\x5a\
\x6e\xed\xc8\xb7\x51\xff\x2b\xc8\xb8\xd3\x07\xcd\x81\x83\x76\xff\
\x26\x24\xd7\xed\xb1\x36\xe4\xad\x1e\x57\x96\xbf\xb6\x5c\x9f\xdd\
\xb8\x66\xbd\x6b\xfe\x5c\x29\x41\xeb\xc2\x3f\x89\x23\x47\x92\x98\
\xd2\x45\xe8\x5d\x87\x8c\x17\x8b\xad\x4c\x47\x0f\x0e\x79\xf5\xba\
\x31\x1a\x82\xd6\xae\x5b\x67\x0d\x34\x5f\x67\x4e\x76\xad\xb3\x67\
\x32\xd6\xc6\x3a\xab\xcb\x5f\x67\xbb\x48\x0c\x49\x4b\x90\x31\x0a\
\xaf\x3c\x27\x2b\xf8\xef\xf9\xb0\xd5\xe9\xe6\x6b\x23\x2d\xc7\x3a\
\x42\x34\x6f\xaa\xbd\x3f\xd7\xc6\xdd\x88\xd6\x4e\x40\x86\xfc\x99\
\xc0\xbf\xa0\x75\x76\x42\xc9\x13\x41\x11\xee\x02\x32\x11\x34\xe6\
\x63\x5e\xdd\x54\xc7\xbd\x8b\xf7\xf0\xec\x9a\x03\x6c\xda\xd7\xc0\
\x81\x86\x02\x4d\x85\x98\x5c\x26\xa2\xb2\x34\xc3\xe0\xea\x12\xa6\
\x8f\xac\xe2\xd6\x09\x7d\x99\x3a\xbc\x8a\x5c\x36\x0a\x1e\xe2\xd6\
\x91\x26\x4e\x39\x64\x8d\x7a\x1f\xb2\xe2\x65\x91\x55\xf1\x31\x12\
\x62\xba\x03\x31\xaa\x6a\x24\xfc\x5c\x85\x16\xf5\x06\xaf\x2c\xc7\
\x90\xb6\x21\xab\x61\x95\xdd\x7b\x0d\x22\x48\x6e\x4f\xf1\x0a\x64\
\x51\x1b\x8a\xac\x71\x6e\xbf\xf2\x56\xab\xcb\x09\x2e\xd7\xa0\x3d\
\x22\xd7\x58\x39\x87\x68\x4e\x40\xd2\x59\x27\x7d\x85\xfc\xb0\xf5\
\xa9\x3f\xb2\x02\x9f\x87\xac\xf8\x1b\x90\x45\xd4\x85\x26\x9f\x89\
\x14\x95\x83\x28\xcc\x6d\x0f\xb2\x7e\xd6\x91\x78\x07\xaa\x91\x87\
\xe2\xa7\xf6\xfb\x15\x56\x4e\x44\x73\x82\x1e\x21\xef\xc2\x47\x10\
\xc1\xdd\x82\x94\xe2\x52\xfb\xfb\x13\x44\xc0\xe6\xd8\xf3\x4d\x36\
\x46\xb5\x5e\xbf\xe6\x23\xcb\xf5\x32\x92\x7d\x65\xcb\x11\x93\x76\
\x84\xcf\x7f\x7f\xa7\x02\x9c\x70\xe3\x18\xb6\xcf\x00\x9c\x00\xeb\
\xc6\xe4\x4a\xf4\x4e\x9e\x40\x02\x46\x5f\x12\x21\x70\x01\x32\x50\
\x5c\x88\xc6\xf6\x02\xf4\x8e\x1b\xd0\x1c\x39\x07\x59\x8b\xd3\xe5\
\x46\x5e\x3b\xdc\xb8\x67\x49\xb6\x01\x5c\x85\xe6\xf4\x74\x64\x79\
\x5f\x88\xe6\xec\x1e\xab\xff\x5c\xe4\x6d\x08\x08\x38\x19\x10\x21\
\x1a\xef\x94\xd7\xf6\x04\x32\x47\x27\x9d\x21\xea\xd7\xc0\xdf\x21\
\xc5\x6d\x09\xf2\x1e\x3a\xc5\xef\x22\x44\xfb\x36\xa3\xb5\xfc\x3c\
\x32\x22\xbe\x82\x78\xc2\x85\x88\xb6\x5f\x88\xd6\x99\x4f\x83\x21\
\xa1\xff\x0d\x48\xa0\x1c\x6e\xed\x3c\x1b\x19\x5e\x57\xd3\x9c\x76\
\xba\xef\x0d\x88\x57\x38\x7a\x01\x49\x32\x9b\xa1\x88\x86\xe7\x90\
\xa1\x6d\x34\xa2\xcb\x0d\x88\xa6\x5c\x86\xe8\x80\xe3\x1f\x8e\x17\
\xf8\x7d\x8f\x50\x34\xd4\x0d\x88\x8f\xae\xb0\x3e\xf4\x42\xb4\xca\
\xe5\x21\xc8\xd0\x9c\xbe\x3b\x9e\x9a\xee\x1f\xde\x7d\xf5\x88\x4f\
\x7e\x1c\x19\x12\xf6\x23\x61\xdb\x79\xc0\xd2\xfc\xde\x37\x5e\x43\
\xeb\x63\x98\xb1\x7e\x8f\x27\xd9\x13\x7d\x07\x52\x56\x5c\x68\xed\
\x23\x88\x2e\xdf\x48\x73\xc3\xf9\x9b\x88\xd6\x4e\x25\xe1\x7f\x0f\
\x22\x1a\xeb\x8f\xbf\x1b\xdf\x2a\x1b\xdb\xa1\x24\x89\x08\x73\xc8\
\x78\xbe\x12\x79\xcf\x56\x93\x28\xb2\xbe\x31\xb2\x81\x44\xb6\xd8\
\x67\xf3\x69\x3f\xe2\xef\x39\x9a\x8f\x97\xff\x5c\xfa\xfa\x99\xf6\
\x1e\x9f\x41\xca\x7d\x65\x91\x7b\xbb\x1b\x6b\x91\x37\xb1\x23\xa7\
\x6c\x64\x48\xbc\x91\x19\xb4\x0e\xd6\x5a\xff\xf3\x68\xee\x4d\xb7\
\xf1\xaa\xb7\xb1\xac\xa1\xb9\x41\xc7\xf5\xd5\x25\x75\x7a\x0a\x79\
\xc4\x7b\xa5\xfa\xea\x1b\x42\x9c\xb7\x7f\x1a\xf0\xb7\x36\xc6\xab\
\xec\x3d\xcd\x47\xc6\x9d\xfd\x76\xcd\x9f\x67\xae\x4f\x0d\x24\x9e\
\xfe\xf4\xda\x2b\x20\x03\xd1\x0c\x24\x13\xb9\x71\x5f\x6f\xe5\x9e\
\x43\x62\x3c\x72\xed\x2b\x43\xeb\xf9\x49\x44\x2b\xce\x25\x89\x0e\
\x49\x8f\xa3\x0b\x1f\xaf\x41\xf2\xd7\x40\xb4\x76\x7d\x99\x81\x22\
\xcf\xba\x71\x8a\xbd\xfb\x1a\xd0\x1a\xfe\x28\xa2\x61\xce\x70\xde\
\x9b\xd6\xd7\x19\xb4\xbd\x7e\xdd\x7d\x2e\xac\x7a\x2d\xf2\x8a\x5f\
\x67\xfd\x1c\x86\xe8\xe4\x23\x48\x29\xbe\x8d\xe6\xeb\xec\x84\x41\
\x76\x58\xef\xd2\x2f\xde\x32\xa1\x6f\x79\x75\xe9\xa9\x24\xbb\x26\
\xc8\x44\x11\xab\x77\xd5\xf3\xbb\x45\xbb\x69\xc8\x6b\x7d\x55\x94\
\x64\x78\xfb\xa4\xbe\x0c\xeb\x5d\xda\x6a\xdc\x49\x26\x82\x0d\x7b\
\x1b\xf9\xd7\x67\xb6\xf0\xf7\x4f\x6c\xe2\xa9\xd5\xfb\xd9\x7a\xa0\
\x91\x83\x8d\x52\x82\x0b\x31\x34\x15\x62\x0e\x35\x16\xd8\x5e\xd7\
\xc4\xfc\x4d\x07\x79\x78\xc5\x3e\xf6\x1d\xce\x73\xde\xd0\x4a\x2a\
\x4a\x32\xa7\xe4\xa6\xbc\x7c\x01\x1e\x58\xba\xf7\xf0\xe2\xed\x87\
\x1f\x42\x02\x4b\xfa\xec\xd7\x3e\x48\x51\xdb\x81\x98\x65\x1e\x09\
\x1c\xfb\x10\xb1\x1b\x82\xc2\x5b\xde\xa4\xb9\x55\x71\x15\x5a\xac\
\x93\xec\xd9\x67\x11\xa1\x70\x09\x2e\xaa\x11\x71\x58\x61\xf7\x4e\
\x44\x84\x6c\x1b\x52\x78\x57\xa1\x05\x3f\xdd\xca\xbc\x17\x85\xa3\
\xd4\x22\xe2\xb7\xda\xda\xd8\x88\x88\xf9\x38\x7b\x7e\x15\x0a\x07\
\x03\x11\x01\x97\xc4\xcb\xed\x57\xde\x47\x42\x50\xfa\x22\x01\xe8\
\x20\xc9\x9e\x93\x29\xf6\x9c\x0b\x65\x71\x89\x07\xc6\x20\x21\x64\
\x3e\x62\x46\xbd\xad\xff\x31\xf0\x1b\xc4\x58\x7a\x21\x21\x6c\x0f\
\x12\x5c\xfa\x20\xe2\xbb\x9d\xc4\x7a\xbd\xdc\xfa\x55\x85\x18\xa9\
\xcb\xd0\x39\x06\x59\x5e\x37\x59\xdf\xd2\xcf\x2f\xb4\xf6\xf6\xb3\
\x71\x38\x84\x42\xe2\x1c\xd3\xe9\x63\x63\xb4\xda\xbe\x6f\x40\xc4\
\xb0\x97\xb5\x7f\xf9\x71\x98\x5e\x47\x03\xb1\x8d\xcd\x7e\xf4\x3e\
\xd3\x84\xd2\x1d\x49\xb5\xcc\xbb\xe6\xe6\x65\x8d\x8d\x4f\x29\x49\
\xe8\xbc\x4b\x36\xb6\x19\x29\xa6\x25\x36\xb6\xaf\xd8\xdf\x8b\xd0\
\xbb\xbe\x17\x09\x78\x43\x91\xc5\x75\x2f\x62\xc0\x6e\x1e\xae\xb7\
\x7a\x77\x5b\x59\x2e\x8c\x6c\x39\x7a\xd7\xaf\xa1\xb9\x78\x0e\x7a\
\xe7\x1b\xac\xfd\x2e\x41\xc9\x74\x34\xb7\x9f\x25\x09\xfd\x0f\x08\
\x38\x11\xe0\x32\x14\x2f\xa6\x25\x0f\x81\x96\x46\xa2\xb6\x50\x89\
\x04\xd5\xa5\x24\x9e\x97\x5d\xc8\x20\xf9\x14\x5a\x5f\xd3\x51\xc8\
\xf0\xab\x88\x2e\xae\x40\xf4\xf3\x1c\xa4\x2c\x3f\x8e\xd6\xe0\x78\
\xa4\xdc\x2e\x45\xeb\x6d\x27\x5a\x6b\x8b\xd1\xda\xec\x45\xe2\x25\
\x72\x74\x73\x1a\xf2\x18\x3d\x8e\xe8\x78\xb5\x3d\xdf\x88\x94\xdf\
\xb5\x76\xef\x28\x44\xcf\x9d\x91\xd3\x79\x6f\xc6\xa2\x10\xca\x32\
\xc4\x3b\x0e\x7b\xcf\xcc\x25\xe1\x31\x3b\x10\x9f\x2a\xb7\xef\x8e\
\x66\x64\xac\xbe\xbd\xc8\xf8\x36\xcf\xfa\xb8\xd7\xc6\xe6\x3c\x1b\
\x9f\x35\x88\xe6\xd4\xdb\xb3\x9b\x49\xf8\xb3\x1b\xbb\x1a\x44\xe3\
\xea\x10\xef\x70\xfb\x8b\x1b\xac\x0d\x8e\x6f\x1d\x22\x51\x3e\x76\
\x20\x7e\xb3\xc5\xea\xcb\xd8\xf8\x96\x23\x9a\x1a\xd9\x7d\x8b\x11\
\x7f\x74\x3c\xb4\xc4\xda\xb3\xcc\xde\xc3\x08\x12\x8f\xf8\x3c\x2b\
\x6b\x9a\x8d\xe1\xfd\x24\x39\x11\x9c\xe1\x7c\xbf\xbd\xd7\x21\x48\
\x09\x5e\x88\xe8\xee\x3e\x6f\x8c\x9d\xd7\xab\xda\xc6\xa1\xc9\xfa\
\xb3\xd6\xc6\xa1\x09\x85\x93\xd7\xa3\x88\x82\x43\xf6\x4e\x17\xd9\
\xbb\xe9\x8b\x78\xe7\x4b\x24\xfb\x9a\x0b\x36\x0e\x7b\xbd\x7e\x35\
\xd8\x73\x1b\x49\xf6\x5a\x6f\x44\x3c\xbc\xaf\xb5\x77\xae\xcd\xc1\
\xb3\xed\x9e\x8d\x24\x32\xcb\x72\x5a\x7a\xf9\x3b\x82\x0a\xb4\x8e\
\x9e\xa7\xb9\x97\xdf\xc1\x57\x98\xda\x43\x1f\x14\x06\x3e\x16\xad\
\x83\xa1\x28\x5c\xd7\x29\x90\x67\x20\x7e\xf6\xba\xf5\x7d\x8c\xb5\
\xf9\x90\xcd\xad\x03\x36\x7f\xf6\xa2\xf9\x3c\x18\xc9\x68\xee\x7d\
\xac\xb4\xbe\xae\x24\x31\xe8\x60\xef\xa0\xd1\xee\x7b\xde\xfe\x5f\
\x81\xd6\xcb\xf9\x24\x09\x57\x9d\xa7\x77\x09\x49\xd8\xf7\x32\x1b\
\xe3\x71\x36\xa6\xf5\x24\x1e\xf7\x1a\x7b\xf7\x2f\xd9\x5c\x9a\x6e\
\xbf\xdf\x47\xa2\x68\x4f\x22\x91\x9f\x56\xdb\xfc\x79\xdd\xda\x3b\
\xd9\xe6\xd6\x0a\x92\xfd\xbf\x59\x9b\x1b\x2e\x4a\xcb\xcd\xaf\x0a\
\x6b\x6b\xc1\xca\x5e\x67\x73\x62\x8b\x95\x5f\xe1\xb5\xdd\xed\x2b\
\x5e\x66\xef\xac\x8f\xb5\x7d\x9d\xb5\x6f\x9a\xcd\xaf\xdd\xd6\xf7\
\x41\x68\xfe\x6e\x27\x89\x04\x73\xeb\x7e\x19\x89\xf3\xc8\xad\xad\
\x85\x56\x4e\x5f\x6b\x7b\xd6\xca\x5e\x64\x73\x6f\x34\x5a\x77\xdb\
\xd1\x3a\x2b\x45\x32\xcb\x00\xb4\xd5\xc0\xc9\x27\x27\x02\xaa\x10\
\xcd\x7b\x38\x9a\x32\xbc\x6a\xcf\xdd\x77\x8c\xae\xa9\xad\xce\x9d\
\x92\x5e\xca\x6c\x26\xe2\xb1\x15\xfb\x78\xdf\xaf\x56\x71\xa0\x41\
\xf3\xb3\x5f\x45\x8e\x9f\xdf\x39\x9a\xa9\xc3\xab\x8b\x86\x32\x67\
\x22\x58\xbd\xbb\x81\xcf\x3d\xb0\x9e\xc7\x56\xee\x6b\x51\x5e\xbf\
\x8a\x2c\x15\x25\x19\x1a\xf3\x0a\x97\x6e\xcc\xc7\xcd\x7e\x7f\xdf\
\xf9\xfd\xf9\x9b\xcb\x87\xd2\xbb\x3c\x7b\xca\x8d\x79\x7d\x53\xcc\
\x27\x7f\xbf\x76\xcf\x3d\x0b\x77\x7f\x06\x29\xb3\x1d\x25\xb4\xe9\
\x90\x92\xf4\x73\xbe\x95\xd0\x79\xe6\x5a\x63\x0c\xad\xdd\xeb\xc2\
\xaf\x7c\x42\xe5\xac\x6e\xf1\x11\xd6\xd5\x1a\x5c\x88\x97\xab\xaf\
\x80\x18\xc9\xfb\x80\xff\x8b\x88\x9c\xeb\x67\xfa\x5e\xd7\x36\x7f\
\x6c\xfc\x50\xd8\xf6\xc6\xd4\x7f\x36\x6e\xe3\xf9\x62\x7d\xef\x6c\
\x5d\x27\x3a\xf2\xc8\x9b\xb1\x09\x85\x93\x77\xf4\x0c\xea\x62\xf0\
\xe7\x4d\x6b\xef\x31\x93\xba\xd7\xdd\x7f\x24\xf3\xcc\x0f\x97\xf6\
\x43\x44\x4f\xb5\x77\x18\x70\x72\xa1\x14\xf8\x02\x12\xf8\x16\xd0\
\xfd\xf3\xd7\xa7\x7b\xc5\xf8\x4e\x9a\xfe\xbb\x6b\xfe\x16\x94\xf6\
\xd6\x69\x7b\x34\x3d\x7d\x6f\x7a\x8b\x4e\xba\x9d\xee\x7b\x9a\x77\
\x41\xeb\xf4\xc6\x95\x51\x81\x84\xfa\x6b\x80\x6f\x23\x61\x99\x0e\
\x3c\xdb\x91\x71\xec\x87\xbc\xd2\x43\x50\xe2\x25\x3f\xcb\x71\x9a\
\xb7\x1c\x09\xd2\x74\xcd\x7f\x57\x6d\xd1\xb8\xf6\xe4\x09\xbf\xfc\
\xd6\xc6\xc1\xcf\x60\xdc\xd6\xf8\x74\xe6\x5d\xb7\xd5\x4f\xd7\x8e\
\x23\x95\x39\xd2\xe5\xf5\x43\xeb\xe8\xab\x48\xb1\xe9\x0e\xcf\x72\
\x31\xd9\xc2\x19\xa5\xd2\x6b\x25\x3d\x9f\x8f\xb4\xaf\xe9\xf1\xef\
\xc8\xbc\xf7\x9f\x6d\xab\x2d\xd0\x52\x2e\x74\x70\xe5\x47\xad\x94\
\xe9\x9e\x6d\x8b\x3e\x75\xa6\xad\x6d\x95\xd1\x0f\x85\x9c\x0f\x43\
\xeb\xac\x89\xa3\xb3\xce\xfc\xf7\xe8\x8f\xcd\x89\x26\x4b\xc4\xc8\
\x48\xf8\x11\xe0\xb3\x21\x34\xba\x93\x88\x22\xd8\x7d\x28\xcf\xdf\
\x3e\xba\xb1\x99\x12\x9c\xcb\x44\xcc\x1e\xd5\x8b\xdb\x26\xf6\xe5\
\xec\xda\x0a\xaa\x4b\x33\xd4\x37\xc5\x2c\xd9\x7e\x88\x9f\xbf\xbe\
\x8b\x27\x57\xed\xa7\xb1\x10\x93\x2f\xc4\xfc\x68\xfe\x4e\x4e\xeb\
\x53\xc6\x27\x2f\x1a\x74\xbc\xbb\x73\x22\x21\xd3\xca\x77\x07\x9f\
\x08\x76\x54\x11\x4c\xdf\x9b\x16\x68\xdc\xbd\x71\x07\x9f\xef\x0c\
\x7c\xe2\xeb\x2c\xaf\x75\xc8\x22\xe7\xf6\xd9\x64\x5a\xb9\xb7\xd8\
\xd8\xc4\xa9\x67\xda\x42\xdc\xc1\xe7\xa3\x4e\xdc\x1b\xd0\x3e\xda\
\x13\x94\x33\x45\xee\x75\xf7\x1f\xc9\x58\x47\xad\x7c\x0f\xef\x30\
\x20\xa0\x75\xa4\x95\x48\x52\xdf\x8b\xd1\xff\xd6\xd6\x5a\x5b\x75\
\xb4\x45\xd3\xd3\xf7\xba\xfa\x5a\x6b\x67\xb1\xb2\x3a\xaa\x98\x57\
\xa1\x30\xe1\xc7\x48\xb6\x00\xd1\xc1\x67\xdb\x42\x8c\xbc\x98\xc3\
\x51\xe2\x2d\x97\xa7\xa0\xb5\xfe\x1c\x09\xd2\x74\xcd\xff\xde\x16\
\x8d\x6b\x4f\x9e\xe8\xc8\x18\x46\xa9\xbf\x6d\x95\xd1\xd1\x77\xdd\
\x91\x76\xf4\x64\x9a\x5d\x4c\x5e\x48\xb7\xbb\xbd\xf7\xdf\xd9\xbe\
\x46\x6d\x3c\x7f\xa4\x6b\x2b\xdd\x87\x62\x65\xb5\x56\x7e\x6b\x73\
\xb2\xbd\xfa\xbb\xb2\xce\x86\xa3\xa8\x88\x7b\x49\xf6\xae\x1f\x8d\
\x75\xd6\x9a\xcc\xdc\x91\xbe\xf6\x58\x04\x45\xf8\x08\xf0\xcb\x37\
\x77\xf1\xe0\xb2\xbd\x6f\xfd\x5f\x5d\x9a\xe1\x4f\x2f\xaa\xe5\x63\
\x53\x07\xd2\xbf\x52\x9e\xf5\xd8\xe6\xf5\xc4\xda\x0a\x2e\x1b\xdd\
\x9b\x7f\x7a\x6a\x33\xdf\x7b\x75\x07\xf9\x42\x4c\x63\x3e\xe6\x87\
\xf3\x76\x70\xed\xd8\x1a\xce\xec\x5f\x46\xe1\x14\xf3\x0a\x07\x14\
\x45\x84\x42\x5c\x7e\x7b\xbc\x1b\x12\x10\x10\x10\x10\x70\x4a\x20\
\x42\xe1\xc4\xff\x49\xd7\x84\xf1\x62\xc8\xa0\x50\xd1\xd7\x8f\x42\
\xd9\x01\x01\x01\x42\x06\x45\x57\xbe\x49\x58\x67\x47\x84\x13\x56\
\x83\x3f\x1e\x88\x22\xd8\xbc\xbf\x91\x9f\xbc\xb6\xf3\xad\x70\xe7\
\x4c\x14\x71\xd7\xf9\x03\xf8\x8b\x99\xb5\xf4\xad\xc8\xd2\x54\x88\
\xc9\xc7\xda\x23\x5c\x88\x63\x9a\x0a\x31\x7d\x2b\xb2\xfc\xc5\xcc\
\xc1\x4c\x19\x5e\xf5\x56\x59\x6b\x76\xd7\xf3\xd0\xb2\xbd\x44\x61\
\xce\x06\x04\x9c\xc8\x70\x99\x32\xfd\xcf\xd1\xca\x9c\xed\xea\x0a\
\xa6\xb3\x80\x80\x9e\x07\x3f\x4b\xfb\x91\x3c\xe3\x67\x44\x3e\x1e\
\x6d\x3f\x9a\x08\x82\xce\xc9\x8f\x34\x2f\x3c\xd2\x39\xe5\xd6\xc4\
\x91\xac\xa7\x74\x39\x9d\x6d\x43\x7b\x75\xf6\x84\xb5\xda\x16\xc2\
\x3a\x3b\x02\x04\x45\xb8\x13\xc8\x44\x11\x73\x37\xd4\xb1\x6c\xfb\
\xe1\xb7\xae\x9d\x39\xa0\x8c\x8f\x4e\x19\x48\x69\x36\x6a\xd5\xb3\
\x5b\x88\x61\x70\xaf\x12\xee\x3c\xb7\x1f\x19\x9b\xa6\x71\x0c\xcf\
\xaf\x3d\xc0\x81\x86\x7c\x98\xb9\x01\x01\x27\x26\x0a\x28\xa9\xce\
\x27\xd0\x61\xf4\x9f\x44\xd9\x48\xcf\xa0\xfb\x99\xa4\x3b\xfa\xea\
\x83\x28\xb1\x46\x4f\x64\xc2\x01\x01\xa7\x2a\x62\x94\x98\x69\x36\
\x1d\x8f\xb4\x8b\x51\x02\x2d\x77\xcc\xc9\x64\x94\x68\xe8\x58\xaf\
\xed\x18\x25\xc7\x39\xe3\x18\xd7\x1b\x70\xf2\xc0\xed\x53\xbd\x1e\
\x9d\xe3\x7b\x3b\x4a\x78\xd5\xd9\xb9\xec\x72\xa5\xb8\x44\x67\x73\
\x38\xb2\xc8\xd5\x18\x25\x92\x1a\x43\xc7\x95\x43\x97\x25\xfc\x8a\
\x56\x7e\xab\x42\x19\x93\x4b\xac\x8d\xb5\x47\xd0\xbf\x80\x1e\x88\
\x10\x1a\xdd\x09\xe4\x0b\x31\xcf\xae\x3d\x40\xbd\x97\xfc\xea\xb2\
\xd1\xbd\x19\xd9\xa7\xb4\xdd\xf0\xe6\x38\x8e\x99\x75\x7a\x2f\xee\
\x9a\x3c\x80\x3e\x15\x59\xce\xea\x5f\xce\x69\x7d\x4b\xc9\x65\xa2\
\xb0\x92\x02\x02\x4e\x4c\xb8\x3d\x70\x13\x50\x22\xad\x3c\xca\xaa\
\xf8\x29\xe0\x1f\x50\x46\x5b\x68\xbe\x47\xcc\xdf\x4f\xe3\x12\xb4\
\xf9\xfb\xfc\xfc\x24\x14\xe9\xeb\x37\xa2\x6c\xa7\x1b\x69\x6e\xb9\
\x76\xbf\xc7\x9d\xa8\x23\x6d\xf9\xf6\x8f\x64\x28\x14\x69\x4f\x40\
\xc0\xc9\x0a\x7f\x7d\x14\x5b\x33\x1d\x59\xab\x79\x94\x69\x76\x06\
\xca\x00\xef\x9f\x03\xeb\x12\xea\xa4\xcb\x88\x11\xed\x98\x81\x32\
\x2f\x57\x7a\xd7\x5b\x5b\xc7\x78\xd7\x8b\x1d\xc7\x92\x5e\xbb\x7e\
\xdd\xae\xcc\x28\x75\x5f\x01\x65\xc5\x1d\x8a\x32\xc5\x46\xb4\x4f\
\x5b\xd2\x7b\x06\x83\x3d\xff\xe4\x83\x9f\x84\xad\xbd\xfb\x06\x03\
\x1f\x43\x59\x9d\x17\xa2\xe3\x9e\x3e\x8d\x42\xee\x37\x78\xf7\x41\
\xcb\xf5\xe4\xaf\x8d\x3c\xda\xef\x3a\x89\xe4\xb4\x8c\xf4\xba\x81\
\xe6\x6b\x2b\x5d\x2e\x56\xce\x54\x6b\xc7\x7f\x7a\xf7\xfa\xcf\xa7\
\x93\xcc\xc5\x48\xc9\x75\xc7\x14\xc6\x45\x9e\xa9\xb1\xbf\x6f\x47\
\x59\xb1\x37\xda\xff\x3e\x2d\xe8\x6a\x22\xb3\x80\x63\x8c\xa0\x08\
\x77\x10\x51\x04\x7b\x0f\xe7\x59\xb8\xf5\xd0\x5b\xd7\x72\x99\x88\
\x0b\x87\x55\x92\xcb\x44\x34\xb5\xa3\x09\x17\x62\x18\xd9\xa7\x94\
\x7f\xbd\x7e\x04\xd9\x08\xa2\x48\xeb\x24\x1f\x36\x08\x07\x04\x9c\
\xe8\x58\x0f\x3c\x8a\x92\x54\xd4\x20\x25\x78\x34\x3a\x72\xc3\x1d\
\xaf\xf4\x24\x3a\x0e\x62\x1c\x3a\xfe\xe1\x59\x74\xe4\xc3\x6c\x92\
\x33\x18\x97\xa2\xe3\x1a\x4a\x91\x45\xfc\x74\x74\x8c\xc2\xb3\x56\
\xee\x24\x74\xdc\x46\x84\x8e\x87\x98\x61\xdf\x5f\x46\x47\x20\x4c\
\x46\x99\x10\xfb\x59\xbb\x9e\x40\xc9\x6f\x46\xa1\x23\x0e\x4a\xd0\
\x71\x5c\x0b\xd0\x51\x2b\xb5\xc8\x13\x14\xdb\xbd\xdb\x50\xc2\x8d\
\x8b\xad\x0d\xf3\xd0\xb1\x09\x01\x01\x27\x2b\x32\xe8\x78\x97\x09\
\x68\x5d\x3e\x85\xd6\xe5\x45\xe8\x68\x9c\xbd\x24\x6b\xf5\x12\xb4\
\xde\x86\xa2\x23\x74\x9e\xb3\xff\x67\xa0\xc8\x90\x46\x2b\xb3\x1a\
\xb8\xdc\xca\x3a\x80\x94\xcc\xad\xe8\x18\x92\x8b\x48\x68\xc0\xf3\
\x56\xf7\x39\x24\x47\xb4\xd5\xa3\x75\x3a\x0d\x09\xf1\xae\xfe\xdd\
\x28\xfb\x72\x06\x65\x86\xdd\x84\xce\x94\xad\xb7\x3a\x63\x74\x54\
\xca\x4c\x44\x2b\x16\xa3\x75\x3e\x1b\xd1\x94\x6d\xc8\x3b\x36\x0c\
\xd1\x8a\x8b\xed\xbe\x45\xf6\xb9\xd0\xfa\xf5\xbc\xb5\x73\x36\xa2\
\x0f\xab\x90\xc0\xdf\x1f\x79\xab\x7b\x5b\xff\xe6\x92\x78\xc5\x9e\
\xb6\xfb\x82\xf0\x7f\x72\xa1\x1f\x8a\x58\xd8\x48\x92\xc0\xb3\x18\
\x62\x74\x5e\xfd\x1e\x74\x1e\x6e\x1e\x1d\x35\x76\x17\x9a\x53\xdb\
\xd1\xbc\x1f\x85\xd6\xc8\xb3\xe8\x28\x9f\x99\x88\x3f\xd6\x21\xe3\
\x91\x9b\x93\xd5\x56\x66\x13\x9a\xf7\xb1\x3d\x3b\xc5\xda\xb3\xd6\
\xca\x68\x42\xca\xee\x78\xb4\x4e\x9e\x46\xfb\xdd\x41\xde\xdb\xf3\
\xd1\x9c\x9f\x40\x72\xf6\xef\x40\xa4\x60\xbf\x80\xd6\xd7\x60\xc4\
\xbb\x27\xda\xf7\xa5\xd6\x0f\x97\x80\xea\x62\x74\x34\xd9\xab\x68\
\x5d\xec\x44\x6b\x68\x02\x5a\xa7\x2e\xb3\xf5\xf3\xf6\xff\x6c\x64\
\x08\xd8\x4c\x58\x0f\x27\x0c\x82\xb5\xbf\x83\x88\x80\x03\xf5\x05\
\x36\xef\x6f\x7c\xeb\x5a\xef\xb2\x2c\x23\xfb\x94\x75\xca\xa3\x1b\
\x21\xa5\x38\x6f\x19\xa4\x03\x02\x02\x4e\x78\x54\x20\x21\x74\x30\
\x62\xbe\x65\x48\x00\xbe\x0d\x31\xcd\xd5\x48\x88\xbe\x1e\x9d\xf9\
\xd8\x0f\xf8\x30\x0a\xdd\xba\x05\x85\x24\xae\x02\xde\x86\xce\xb5\
\x9b\x6c\x7f\xdf\x44\x82\xc2\x5d\x48\x10\xdf\x8e\x98\x78\x1f\x14\
\x22\xbd\x0b\x09\xd8\x77\x21\xa6\x7d\x0e\x70\x03\x62\xfa\x83\xad\
\xfe\xa1\xc8\x52\x5f\x8f\x84\xe7\xf7\x22\xc1\xe1\x5c\xe4\x61\x5e\
\x6f\xf7\xdc\x8e\xce\x02\xfc\x10\x3a\x47\x71\x1d\xf0\x0e\x74\x2e\
\xe4\xd1\xda\xf3\x1c\x10\x70\x3c\x51\x40\x02\xfa\x0d\x24\xeb\xf2\
\x4a\xa4\x70\x5e\x87\xbc\xa3\x6e\xad\xf6\x05\x6e\x46\x82\xf5\x4a\
\xe0\x26\x24\x3c\x5f\x62\xf7\xaf\x44\x46\xa4\x1a\xb4\x66\xaf\x22\
\x31\x82\x5d\x80\xd6\xe7\x74\x44\x03\x56\xa0\xb5\x76\x05\x5a\xd3\
\xbb\xd0\x91\x45\x13\x11\x2d\x98\x8d\x8e\x32\x5a\x8e\x14\xd0\x0f\
\x21\x05\xe0\x7a\xb4\xc6\x97\x5b\x3b\xa7\xd3\x5c\x41\xb9\xdd\xda\
\xbb\xdc\xca\xae\x45\x67\x7f\x4e\xb1\x76\x5c\x61\xf5\xde\x6a\xf7\
\xad\xb0\x6b\x83\x90\xa2\xbc\x0d\x29\x01\xef\x42\x8a\xfd\x02\xa4\
\x68\xcc\x41\xf4\xe4\x3d\x88\x36\x54\x00\x9f\xf3\xea\x7d\x37\x52\
\x02\x02\x4e\x0e\xc4\x48\x19\xfd\x02\x3a\x8a\xe7\x62\xda\xe6\x01\
\xa5\xc8\x68\xb4\x88\xe4\xbc\xde\x18\x29\xc5\x73\x91\x91\x65\x0a\
\xe2\x67\xa5\x88\x07\xf5\x41\xfc\xa5\x0f\xf2\x18\xdf\x82\x0c\x44\
\xab\xd1\x1a\x2b\xb5\xdf\x66\x22\xe3\xcb\x2d\x68\xee\x2d\x46\xeb\
\x60\x12\x9a\x9b\x37\xa2\xb5\xd7\x0f\xb8\x9a\xc4\x1b\xdb\x48\x72\
\x46\xf5\x1e\xc4\x23\x47\xa1\xb3\x78\x2f\x41\x6b\x7e\x0f\x5a\xa7\
\x57\x01\x77\x5a\xf9\xfd\xac\xbf\x7d\xd1\xba\x6f\x42\x4a\xed\x0d\
\x28\xfa\xeb\x32\xc4\x4b\xf7\x90\x9c\xab\x7d\x93\x8d\xd7\x10\xfb\
\x3d\x51\x12\x02\x4e\x08\x04\x8f\x70\x27\x70\xa0\x21\xcf\xfe\xfa\
\x84\xef\x94\x97\x44\xf4\xab\xcc\x12\x9f\x6a\x87\x01\x07\x04\x04\
\x38\x14\x90\x00\xfb\xe7\xf6\x7f\x23\x70\x0f\xb2\xa2\xd7\x21\xaf\
\xd0\x02\x24\x44\x3f\x61\x9f\xd7\x80\xbf\x45\x8c\x75\x3b\x70\x1f\
\x12\x4a\xfb\x20\xe6\xfe\x63\x7b\xb6\x02\x09\x15\xc3\x90\x25\x7a\
\x0b\x12\x04\x86\xd9\xa7\x37\x49\x58\xda\xd9\x24\x96\xe9\x27\x80\
\x43\x88\x79\x9f\x87\x94\xf2\xdf\x21\xef\xf2\x30\x24\x40\x37\x20\
\x8f\xd6\xe3\xe8\xcc\xea\xdb\x90\x95\x7b\x34\xf2\x18\xe5\x90\x30\
\xe0\xbc\xd0\x01\x01\x27\x1b\xb2\x48\x40\x7f\x11\xad\x99\x97\x90\
\xc2\xf9\x49\xfb\xff\x71\x94\xf1\xf8\x2b\x68\xad\xee\x04\x1e\x44\
\x6b\xf5\x02\xe4\x11\x1d\x85\xd6\xf8\x63\x48\xf0\xbe\xc5\xca\xf6\
\x43\x36\x9d\x12\x31\x1d\xad\xb9\x27\x50\x14\x47\x39\x32\x48\x6d\
\x46\x42\xb5\x3b\x6b\xf6\x22\xab\xfb\x09\xa4\x3c\x7c\x05\x29\xd9\
\xfb\x81\x87\x50\xa4\xc6\x38\xbb\xe6\xe3\x00\x5a\xc3\x7b\xed\xf9\
\x4d\xc8\xf3\x35\xd3\x9e\x19\x0e\x3c\x80\x14\x5b\x77\xdf\x13\x88\
\x56\x6d\xb1\x76\x36\xd8\x98\xbc\x66\xe5\xe7\xac\xdd\xf7\x21\x23\
\xdc\x83\xc8\xd8\x37\x0a\x79\xd2\x46\x00\x7f\x6a\x7d\xd9\x4f\xf0\
\x82\x9d\x2c\xc8\x90\x78\xff\x2b\x3b\x70\x7f\xb1\xa3\x16\xdd\x71\
\x59\x8b\xd1\xdc\x74\xfc\x6c\x80\x7d\xdf\x8b\xe6\xd0\x0e\xa4\xa8\
\xfe\x00\x78\xc3\x7e\x3b\x8b\x24\x34\xb9\x1e\xcd\xbf\x1a\xc4\x23\
\x4b\x91\xf1\xf6\x34\xc4\xef\x1e\x47\x6b\xb7\xca\x6b\x47\x03\x9a\
\xd3\x15\x88\x27\x9f\x05\xfc\x13\xf2\x26\x1f\x44\xc6\x9e\xfb\x10\
\x5f\xfc\x4b\xfb\xfe\x2c\x5a\x8f\x4d\x76\x7f\x86\xe4\xd8\xaf\x97\
\x6d\x2c\x40\x4a\xf0\x0e\xa4\xb4\xcf\x43\x46\xab\x71\x48\x11\x5e\
\x6e\xbf\x85\x75\x70\x02\x21\x28\xc2\x1d\x44\x44\xc4\xe1\xa6\x02\
\x79\xcf\x2e\x56\x96\xcd\x50\x59\x12\x9c\xea\x01\x01\xa7\x30\x32\
\x88\x79\xff\x27\x52\x44\x1b\x11\xa3\xad\x41\xcc\xd8\xed\x15\xcc\
\x91\x9c\xef\xe7\x32\x6a\xe6\x10\x93\x75\x16\xe4\x46\xbb\xf7\x62\
\x24\x7c\x2e\xb4\xe7\xfd\x7d\x78\x19\xe4\x7d\xd9\x8b\x04\x58\x80\
\x5f\xdb\xbd\x83\x90\xc0\xe1\xf6\x4f\x39\xc1\xda\xcf\xe0\xd9\x88\
\x3c\xd6\x87\x52\xf7\x62\xe5\xd6\x21\x0b\x7d\x01\xed\x7b\x5e\x49\
\x60\xea\x01\x27\x2f\x32\x24\xeb\xaf\x14\x09\xb3\xa5\x68\xed\xfa\
\x6b\x35\x8b\xd6\x8c\x5b\xcf\xfe\xf9\xef\x79\xef\x5e\xdf\x73\xe6\
\x04\xf9\x4a\xfb\xdd\xad\x77\xd0\x5a\x1b\x6a\x7f\xfd\x3d\x85\x91\
\x95\xdf\xd8\x4a\xfd\x87\x53\xf5\xfb\xcf\xdd\x8f\x22\x4b\xc6\x02\
\x97\xda\x7d\x6f\x20\xef\xf1\x35\xc8\xe8\xb6\xa5\xc8\x7d\xc5\xc6\
\x63\xa3\xdd\xbf\x1b\x45\xa3\xe0\xfd\xcd\x58\x3b\x5c\xbd\x3d\x35\
\x83\x6e\xc0\x91\x21\x42\xef\xfa\x7f\x23\xa5\x75\x31\x6d\x47\x8f\
\x36\xa0\xf9\x34\x9a\xe6\xfb\x79\xaf\x46\xbc\xb0\x37\x32\xc6\xbc\
\x49\xc2\xcf\x22\x34\x87\x1c\xcf\xf3\xd7\x51\x13\xcd\xf7\xd1\xf7\
\x45\x1e\xdb\xbd\xc8\x18\x73\xc8\xee\x77\xeb\x04\xb4\x8e\x06\x23\
\x63\x8c\xf3\x56\xb9\xf5\xe1\x78\x9c\x53\xcc\x1b\x48\xf8\xa9\x5b\
\xeb\x95\x34\xe7\x85\x39\xeb\x87\xdb\xf3\x5b\xeb\xb5\x27\xf2\x3e\
\x07\xd1\x76\xa3\x99\x48\xe9\xbe\xcf\xbb\x27\xe0\x04\x41\xd0\xe2\
\x3a\x81\x28\x8a\xc2\xf4\x0e\x08\x08\xf0\xe1\x84\xd5\xfd\x48\x78\
\x38\x4c\x42\x25\x1c\xb3\x6d\x42\x9e\xa5\x4b\x91\xf7\xf8\x5a\x92\
\xf0\xe3\x41\x28\x3c\x71\x32\xf2\x04\xbd\x8e\xac\xcb\x1b\x49\xbc\
\x46\x15\x5e\x79\x19\xe4\xb1\x75\x42\xf7\x3e\x7b\xb6\x8c\x96\x82\
\x71\x09\xda\xf3\x34\x00\xed\x8f\x9a\x62\xf7\xce\x2f\x72\x6f\x0e\
\x59\xb8\x0f\xd8\xf7\x5d\xc8\x9b\x5c\x45\x10\x72\x03\x4e\x4e\xe4\
\x91\x01\x69\x3a\x8a\x7c\xb8\x05\xad\x93\xf9\x68\xad\x4e\x42\x0a\
\x64\x23\x32\x0e\xf9\x8e\x03\x27\xb8\x2f\x42\xa1\x96\xe7\x20\x85\
\xb3\x3f\xa2\x05\x8d\x68\x3d\xbb\x3d\x8c\x31\xf2\xb2\x5e\x64\xe5\
\xde\x6a\x75\xd4\x23\x2f\x57\x7f\x12\x5a\xf1\x9a\x57\xff\xb5\x76\
\xcf\x46\xab\xdf\xa7\x2d\xbe\xfc\x96\x43\x11\x20\xbd\x91\x87\x6c\
\x27\x32\xc6\xed\x46\x1e\xec\x6b\xd1\x3e\xc7\xd8\xee\xeb\x65\xf7\
\xed\xb2\x67\xea\x11\x9d\x00\x29\x1b\x7d\x91\xa7\xfa\x74\x64\x1c\
\x80\x44\x51\xf0\x13\x85\xb9\xef\x41\x32\x3a\xf9\xb0\x16\xcd\x99\
\xc3\x1d\xb8\xf7\x31\x14\xd2\xec\xb6\x0f\x5c\x89\xe6\x59\x1d\xf2\
\xae\x6e\x42\x5e\x5b\xc7\xcf\xdc\xbc\xc9\xd8\x3d\xab\x90\xe2\x3c\
\x09\xf1\x43\xff\x9e\x7e\x48\xc9\x7d\x06\xcd\x49\x37\x4f\x17\xa0\
\xfd\xf9\x6e\x3d\xa5\xb3\x3d\x37\xda\xb3\x79\xab\xff\x3a\x14\x39\
\x75\x3d\x52\xee\x87\xa0\xf5\xfd\xef\x56\xe6\xe5\x24\x8a\xf3\x4a\
\x6b\xeb\x6c\xb4\x86\xef\x42\x6b\xc6\x25\x8e\x6b\x42\xd1\x55\x95\
\x36\x46\x6e\xcf\xb0\x4b\x36\x17\x70\x02\x21\x78\x84\x3b\x88\x98\
\x98\xea\x92\x0c\x25\x99\x64\x8e\x37\x16\x62\xea\x9b\x3a\x27\x23\
\xfa\xa9\x16\x03\x02\x02\x4e\x68\x44\x68\x5f\xdd\x42\x5a\x5a\x81\
\x9d\x40\x7b\x00\x31\xcf\x87\x11\x43\xbe\xc6\xae\x7d\x0f\x29\xb1\
\x7b\x11\x33\xbd\x1c\x31\xfa\xe7\x90\x82\x7c\x2d\x12\x0c\xd6\x23\
\xab\x73\x06\x31\xef\xbd\x48\x61\xfd\x19\x12\xe0\x73\x88\x11\xaf\
\x47\x02\x6c\x9d\xdd\xbb\x0b\x59\xe0\xd7\x00\x3f\x42\x5e\xe6\x1c\
\xb2\x58\xcf\x43\x96\xf0\x43\xde\xbd\xaf\x59\xbd\x3f\x40\xca\xc0\
\x24\xeb\xd7\x72\x82\xc1\x34\xe0\xe4\x44\x06\x85\x06\x47\x68\x5d\
\xee\x01\x7e\x83\xd6\x65\x03\xcd\xd7\xea\x4e\x24\x78\x3b\x43\xd7\
\x12\xe4\x31\x7d\x13\x09\xce\xd7\xa0\xb5\xf9\xa2\x3d\xf3\x53\xa4\
\xcc\xf6\x41\xe1\xc4\xdb\xd0\x5a\x2c\xb1\x7b\x77\xa1\x48\x8e\x3c\
\x12\xa2\xcf\xb1\xdf\x0f\x5a\xd9\xb1\xdd\xb7\xdf\xea\xdf\x6d\xf5\
\x3b\x7a\xb2\x82\xe6\xde\x67\x97\x84\x68\x0e\x52\x44\xe6\xa3\x90\
\xed\x18\xad\xe3\xf3\x11\xfd\xc8\x23\x1a\x73\x05\x4a\x16\x34\xcf\
\x9e\xeb\x85\xf6\x27\x9f\x8e\x68\xc0\x35\x48\xa9\xd9\x8e\xc2\xab\
\x7b\x91\x24\xea\xdb\x85\x3c\xcd\xb1\xb5\x6f\x2e\x89\x07\x3b\xe0\
\xe4\x41\x47\xe9\x7e\x06\xcd\xdd\x6f\x21\xde\x71\x23\x9a\xc7\xdf\
\x45\xeb\x63\x1f\xe2\x67\xd7\x22\x1e\xf3\x34\x5a\x47\xf3\x11\x0f\
\x2a\x00\xbf\x42\x73\xee\x2a\x2b\x6b\x1d\x9a\xeb\x0b\x91\x52\xfa\
\x10\x5a\x4f\x5b\xec\xfb\x0e\x64\x28\x2e\x45\x7c\x72\x2f\xf0\x4b\
\x12\xaf\x6f\xd6\xca\x1f\x8d\xc2\xf8\x7f\x60\xe5\x5f\x87\x14\xfc\
\x87\xd1\x9a\x78\x0a\xad\x87\x3d\xc8\x48\xbc\xde\xea\xdc\x02\xdc\
\x4d\x72\x1c\xda\x3d\x48\x59\x7f\x1d\xd1\x86\x87\x91\x12\x5e\x8b\
\x8c\x54\xeb\xed\xb7\x83\xb4\xcc\xe6\x1e\xd0\xc3\x11\x4d\x19\x5e\
\xb5\xe7\xee\x3b\x46\xd7\xd4\x56\xe7\x38\x15\xb7\xba\x66\x33\x11\
\x8f\xad\xd8\xc7\xfb\x7e\xb5\x8a\x03\x0d\xe2\x2b\xfd\x2a\x72\xfc\
\xfc\xce\xd1\x4c\x1d\x5e\x4d\xde\x06\x25\x13\xc1\x86\x7d\x8d\xbc\
\xed\xee\xe5\xac\xdc\xa5\x44\x8d\xfd\x2b\x73\xfc\xf2\x5d\x67\x70\
\xc1\xd0\xaa\xb7\xee\x6b\x0f\xfb\xeb\xf3\x64\x33\x11\xe5\xb9\x0c\
\xd9\xe8\xd4\x53\x88\xeb\x9b\x62\x3e\xf9\xfb\xb5\x7b\xee\x59\xb8\
\xfb\x33\x88\x48\x06\x21\x3b\xa0\x27\x23\x0f\x7c\x1c\x59\x94\x7f\
\xcf\x91\x33\x39\x17\x3e\x98\x25\x09\x1d\xeb\x03\xfc\x19\x12\x20\
\xb6\x90\x84\x40\xfb\x4a\x75\x81\xe2\x6b\xc4\xbf\xde\xda\x3d\x47\
\xfb\xde\x80\x80\xe3\x81\x52\x94\xc8\xe7\x37\x48\x39\xec\xea\x1c\
\x2d\x90\xac\x4b\x87\xf4\x5a\x6d\xad\x8e\xf4\xba\x2e\xb6\x6e\xd3\
\xeb\x39\x5d\x17\x24\xeb\xbe\x58\x99\xd0\x31\x25\xd3\x3f\x46\x26\
\x4f\x92\x8d\xde\x25\x06\xfa\x25\xcd\xf7\x72\xfa\xe1\xa8\xae\x0e\
\xff\xe8\xa4\x0c\x9d\xab\x3f\xe0\xc4\x81\x3b\xf7\xf7\x0b\xc0\x57\
\x91\xc1\xa3\xab\xef\xd8\xcd\x7f\xff\x38\x22\x7f\x5e\xfb\xf3\xb2\
\x58\x7b\x20\x99\x9f\x51\x91\xb2\x8b\xad\xc7\xf4\x7a\x8a\x52\x65\
\x16\x9b\xd3\x6e\xce\xfb\xc7\x8b\xb5\x56\x67\x6b\xbc\xd0\xdd\x5f\
\x8e\x8c\x58\xd7\x00\xdf\x26\x64\x8b\x3e\x51\x10\xa3\x0c\xe2\x1f\
\x01\x3e\x1b\x3c\xc2\x1d\x44\x1c\x2b\x4b\xf4\xb0\x9a\xd2\xb7\x14\
\xe1\x7d\xf5\x79\xd6\xed\x69\xe0\xc2\x61\x55\xed\x6a\xb4\x11\x70\
\xa8\xa9\xc0\xff\x7a\x62\x33\x4b\xb7\x1f\xa2\x5f\x65\x8e\xd1\xfd\
\xca\x78\xcf\x79\xfd\x19\xdd\xaf\xac\xdd\x73\x88\x03\x02\x02\x4e\
\x68\xf8\x67\x79\xfa\x99\x2d\xdf\x24\x09\x3d\xf3\xc3\x0d\x49\x5d\
\x4b\x23\xd3\x81\x7b\x8e\xf6\xbd\x01\x01\x27\x03\xd2\xc6\x27\x68\
\xb9\x56\x5b\x43\x7a\x5d\xfb\x65\xfa\xf7\xb4\x55\x17\x34\x97\x20\
\x5a\x2b\xb3\x3d\xa4\xcf\xf6\x05\x85\x65\x47\x28\x29\x51\x5b\xf7\
\xf9\xed\x88\x8a\x7c\x0f\x08\x68\x0f\x69\xc3\x8f\x6f\x60\x71\xd7\
\x5b\xe3\x29\x51\x2b\xdf\xfd\xb2\x8b\xad\xc7\xd6\xd6\x53\xba\xde\
\x62\x6d\xf0\xaf\xb7\x56\x67\xb1\xef\xee\xfe\x18\x45\x73\x5d\x88\
\x42\xc3\xb7\x10\xd6\xcb\x09\x89\xa0\x08\x77\x10\x31\xd0\xab\x34\
\xc3\xb8\x81\xe5\x3c\xbd\x7a\x3f\x00\x8d\xf9\x98\x57\x36\xd4\x71\
\xf3\xf8\x3e\xed\x3e\x1f\x45\xb0\xeb\x60\x9e\xa7\x56\xed\x67\xf9\
\x4e\xc9\xbd\x03\xab\x72\xdc\x36\xa1\x5f\xbb\xcf\x06\x04\x04\x9c\
\x94\x38\x04\xfc\xd6\xbe\x07\x06\x1a\x10\x10\xd0\xdd\x78\x1c\x09\
\xe9\x10\x68\x4c\x40\x40\x77\xc2\x6d\x13\xf8\x2f\x82\xd1\xe8\x84\
\x46\xb0\xf8\x77\x02\x99\x4c\xc4\x8c\x91\xd5\x94\xe7\x92\x61\x7b\
\x6c\xe5\x3e\xd6\xed\x6d\x20\xd3\xce\x12\x88\xa2\x88\x57\x36\xd4\
\xb1\x7e\x6f\xc3\x5b\xd7\xc6\x0f\xaa\x60\x44\x9f\xd2\x53\x32\x24\
\x3d\x20\x20\x20\x20\x20\xe0\x28\xc1\xcf\x64\x1c\xa3\x70\x48\xf7\
\x39\xd2\x73\xb1\x3b\xf3\x5c\x67\x32\x29\xc7\xde\xa7\xb3\x6d\xeb\
\x48\x3d\xbe\x17\xad\x58\xf9\xc7\xf2\x9c\x70\xbf\x8f\xed\xd5\xdb\
\xd5\xdf\xbb\x0b\xfe\x51\x58\xe9\xeb\xf9\xd4\x35\x37\xd7\xd2\xef\
\xf3\x64\xcf\xac\x5d\x6c\xee\xb6\x36\x6e\x9d\x41\xa1\x8d\xeb\x85\
\x0e\x3c\x77\xac\xe6\x48\x50\x82\x4f\x60\x04\x45\xb8\x13\x28\xc4\
\x31\x33\x4f\xaf\xe6\xdc\x21\x15\x6f\x5d\x5b\xbe\xe3\x30\xdf\x7e\
\x79\x3b\x87\x9b\xe2\x56\x95\xe1\x6c\x14\xb1\x65\x7f\x23\xdf\x9f\
\xbb\x9d\xc3\x4d\x5a\x97\x99\x08\xae\x3d\xab\x86\xde\x65\x99\x93\
\x9a\x3a\x06\x04\x04\x04\x04\x04\x1c\x43\x14\x50\xd2\xa7\x09\xf6\
\xbd\x0a\x25\xa3\xfb\x20\xf0\x1e\x94\xc5\xb6\xb3\xc8\xa2\x6c\xee\
\x1d\xc9\xa2\x5e\x40\xe1\x92\x13\x69\x5f\x10\x8f\x51\xf8\xf2\xb9\
\xe8\x38\xa5\xd9\x74\x5c\xa8\x76\x47\xcb\x8c\xe9\xe0\xfd\x65\x28\
\x61\x51\x25\x89\x62\x56\x81\x12\x6c\x55\x77\xa0\x5f\x5d\x45\x8c\
\xce\x32\x9e\x89\x32\x5a\x5f\x65\x6d\x2a\x86\x52\x94\xe1\xb7\xb4\
\x95\x72\x7a\xa7\xfa\x72\xb4\x10\xa1\xf7\xde\xa7\x48\x3d\x37\xa0\
\x6c\xc2\xe5\xf6\x7f\x01\x9d\x6d\xfb\x51\x94\x51\x78\xb8\xdd\x53\
\x82\x32\xf0\x8f\xe0\xd8\x1a\x1d\x8e\x15\x0a\x28\xd1\xd4\xac\xd4\
\xb8\x5d\x63\x63\x70\xa4\xef\x27\x8b\xd6\x46\x7a\xcd\x95\xa2\xa4\
\x57\x77\xa2\x24\x6e\xfe\x6f\x6e\xef\xf3\x1c\x34\x47\x6e\xe4\xd8\
\xcc\xed\x80\x13\x18\x41\x11\xee\x04\xe2\x58\x09\xb2\xde\x7f\xfe\
\x00\x2a\xec\xfc\xe0\x42\x0c\x3f\x98\xbb\x83\xaf\x3e\xb3\x85\x5d\
\x07\x95\x08\x2b\x9b\x89\xc8\x46\xc9\xdf\xf5\x7b\x1b\xf8\xc7\x27\
\x36\xf1\xc2\xda\xba\xb7\xca\x9a\x58\x5b\xc9\x75\xe3\x6a\x8e\x77\
\x97\x02\x02\x02\x02\x02\x02\x4e\x26\x54\x22\x41\xb9\xc9\xbe\x7f\
\x0c\x29\x55\x8b\x50\x06\xdb\x8f\xa3\x04\x37\xce\xab\x94\xf6\x14\
\x17\xbb\xde\x07\x09\xde\x55\xde\x6f\xce\xe3\x95\xbe\xd7\xed\x1d\
\x2c\xf7\x7e\x2f\xa4\xea\x70\x9e\xc3\x26\x94\xad\x79\x22\x12\xfc\
\xab\x49\x92\xfb\x14\x6b\x97\x7f\x2d\x0f\x4c\x43\xd9\x74\x63\x9a\
\x7b\xbe\x7d\x85\xcb\xdd\x9b\xb5\x7b\x2b\xbd\xdf\x32\x34\x3f\x16\
\xc6\x6f\x67\xb1\x36\xa7\xdb\xe0\xfe\x2f\xe6\x7d\x2f\xd6\xd7\x5a\
\x74\x1c\x4d\x6b\x7d\x75\x9f\x21\xc0\xbb\xd1\xf6\xbd\x62\xf5\xf6\
\x42\xc6\x8d\x8a\x22\x7d\x4d\x2b\x3d\xc5\xc6\x32\x7d\x3d\x6e\xe5\
\xde\x52\x6b\xc7\xa0\xd4\xb3\x91\xd5\xff\x01\x94\x99\xd8\x79\x86\
\x2f\x41\xc6\x96\x5a\x64\xd8\x98\x43\x22\x67\x5f\x43\xeb\x8a\x7f\
\x4f\x44\x47\x23\x14\x62\x34\x7f\xa7\x79\xe3\x98\x41\x73\x6d\x30\
\x2d\xd7\x53\x6b\x63\xed\xca\x72\xd7\xaa\x81\xf7\xd9\x5f\xbc\x67\
\x4e\x43\x63\xbf\x1c\xe5\xd7\x48\x97\x9d\xb3\x67\xaa\x90\xb1\xa5\
\x9a\xe6\xf3\xc2\x8f\xc0\xf0\x9f\x6b\x6d\xfd\x04\x9c\xe4\x08\x7b\
\x84\x3b\x89\x38\x86\x9b\xce\xee\xc3\xbc\x4d\x07\xf9\xde\xab\xdb\
\x29\xc4\x70\xb0\xb1\xc0\xbf\x3f\xb7\x95\x97\xd7\x1f\xe0\x86\x71\
\x7d\x38\x67\x48\x25\xbd\x4a\x33\xec\xab\x2f\x30\x7f\x53\x1d\xbf\
\x59\xb0\x9b\xd7\x36\x1f\x7c\x2b\x21\x56\x4d\x79\x96\x4f\xcd\x18\
\xc4\xc8\x9a\xd2\x90\x24\x2b\x20\x20\x20\x20\x20\xa0\x7b\x50\x40\
\x4a\x6e\x16\x9d\xa1\x7d\x29\x3a\xa3\xf7\x1f\xd0\x51\x3f\x2e\xc9\
\xcd\x48\x74\x04\xd0\x04\xe0\x02\x94\xb8\xee\x05\x74\x44\xca\x74\
\xe4\x4d\x1a\x88\xce\xd7\x7d\xcc\xee\x3b\x1b\x79\x6c\x17\x21\xe5\
\xa7\x12\x1d\x3b\xe6\x3c\xc0\x15\x56\xe7\x0b\xe8\xe8\x97\x43\x24\
\x9e\xe9\x32\x2b\xf3\x39\x74\xf4\x51\x3f\x24\xcc\x97\xa1\x33\x4c\
\xb7\x5b\x1b\xf6\x91\x08\xfb\x17\x23\x6f\xe2\x3c\xab\x73\x3c\x3a\
\xf2\xa5\xdc\xea\x79\xc3\xea\x1d\x0e\x3c\x8f\x8e\x85\xb9\x14\x29\
\x61\xab\xac\x1d\x8d\x76\xcf\x39\x28\x73\x74\x29\xcd\x15\xc5\x02\
\x3a\x7a\xa6\x80\x3c\xb5\x65\x36\x36\xeb\xd1\x11\x35\xe7\x59\xdb\
\x1e\x45\x8a\xdd\x99\xc8\x9b\x5b\x82\x8e\xa7\x19\x47\x72\x76\xf1\
\x7a\xaf\xdd\x39\xfb\x7d\xa1\x8d\xd3\x6c\x1b\x4f\xa7\xd8\xe6\xbd\
\x7a\x47\x7a\x63\xbe\x01\x1d\x23\x37\x19\x18\x6b\x65\x3d\x69\xef\
\x68\x1c\x3a\x46\xea\x29\x7b\xae\xc9\xca\x9c\x6a\xf5\x1f\xb2\xef\
\xf5\x36\x36\x58\xdd\x33\x6d\x3e\x0c\x46\x47\x40\xbd\x62\xff\x4f\
\x43\xd1\x01\x3b\xad\xce\xdd\x24\x9e\xfc\x7a\xab\xa7\xbf\xd5\x7b\
\x05\x3a\x39\xe0\x00\x89\xc7\xfe\x20\x3a\xea\x67\x02\x4a\x7a\xd8\
\x1b\x79\x82\x57\x7a\xf3\xcc\x65\x1b\x5e\x88\xce\xd6\x1d\x6f\x73\
\xe6\x44\x70\x42\xf5\xb3\x3e\x6d\xb4\xb1\x6e\x0b\x4e\xd1\xcc\x92\
\x1c\x5f\xe4\x67\x3f\x77\xe3\xba\xd7\xc6\x7a\x3b\x3a\xd6\x68\x2a\
\x32\x6a\xac\xb1\xeb\xe3\x91\xe7\xbc\x17\x9a\x2b\x67\xa1\x39\xfd\
\x5b\x7b\x27\xee\xa8\xc1\xbe\xf6\xe9\x65\xe3\x5a\x8b\xd6\xce\x13\
\x68\xce\xbb\xb9\xe5\x0c\x40\x57\xa2\x77\xbf\x1e\x1d\x0d\x58\x86\
\xde\xfb\xb9\x48\x61\x5e\x62\xfd\x9c\x6d\xff\x2f\x44\xf3\x37\x28\
\xc4\xa7\x00\x4e\x84\xc5\xd8\xa3\x10\x03\x95\x25\x19\xbe\x30\x7b\
\x30\xef\x9d\x3c\x80\x92\xac\x68\x62\x53\x21\xe6\x99\x35\x07\xf8\
\xe2\x1f\x37\xf0\xf6\x9f\xac\xe0\xa6\x1f\xad\xe0\xf6\x9f\xae\xe0\
\xaf\x1f\xd9\xc8\xbc\x4d\xcd\x95\xe0\x2f\x5f\x36\x84\x9b\xc7\xf7\
\x09\x4a\x70\x40\x40\x40\x40\x40\x40\xf7\x21\x42\xca\xe2\x6a\x24\
\xbc\x8f\x27\x39\x5f\x3b\x87\x84\xe2\x87\x80\x07\x90\x62\xfb\x3e\
\x24\x00\xd7\x21\xcf\xf1\x60\x24\x9c\x5f\x81\x14\x9a\x31\x28\xbc\
\x72\x07\x52\x24\xd7\x20\x0f\xee\xad\x48\x31\x8a\x80\x5b\xd0\x39\
\xc1\xcb\x81\xdb\x91\x80\x3f\xd1\x9e\x1d\x0e\xdc\x81\x94\xf0\x26\
\xe0\xfd\x48\x91\x7c\x0f\x52\xe2\xd6\x23\x61\x3f\x22\xf1\x96\x0e\
\x00\x3e\x84\x04\xff\xcd\xc0\xf5\x56\xd6\xcd\x56\xcf\x4a\x2b\x73\
\x04\xb0\xd5\x3e\xbb\x81\x77\x21\x45\xd4\x29\xc8\x57\x22\x25\xed\
\x76\x1b\x8f\x1a\x2b\xdb\x17\xee\xcb\x91\xb2\x59\x65\xf7\x4f\x45\
\x4a\xf4\xdb\xd1\xf9\xac\x2b\x6d\x2c\x26\x5a\x7d\x77\xda\x58\xd4\
\xa2\xa3\xdf\xf6\x23\x8f\xdb\xad\x76\xed\x43\x36\x96\x6b\x81\x77\
\x20\xc5\xf9\x06\xa4\x88\xaf\xb0\xb1\x29\xb3\x67\x66\x22\x45\xe6\
\x66\x92\x0c\xfa\x57\x5a\xdb\xb7\x20\x65\x66\x3d\xf2\xb2\x5e\x85\
\x8c\x01\xbd\x6d\xec\x9c\x67\xb5\x11\x85\xe4\xba\x72\xaf\x25\x51\
\xb6\x5d\xff\x6e\x43\xca\xf6\x2a\xfb\x7e\x2e\xf2\xd4\xce\xb1\x32\
\x07\x21\xcf\xee\x28\xeb\xf7\x6a\x9b\x27\xd7\x21\xe5\x6a\x8f\xf5\
\xc7\xf7\x3e\xba\xf2\x5f\xb3\xf9\x50\x81\x8c\x1e\xfb\x28\x7e\x84\
\x4e\x3d\x3a\x1b\xf7\xfc\x23\x9f\xda\xc7\x0c\xb1\xbd\x9f\x2f\x02\
\xdf\x40\xf3\xa3\x23\x21\xfe\xd3\x81\xaf\xd8\xe7\xcb\xe8\xdd\x37\
\x21\x83\xc3\x8d\x48\xd9\x2c\x05\xde\x8b\x0c\x0c\x6f\x43\xc6\x84\
\x45\xf6\xfb\x39\x68\x9e\x5d\x8f\xd6\xd9\x6a\x34\x07\xd6\x91\x28\
\xe2\x8d\xc8\x58\xb2\x1d\xcd\x8d\x2b\x50\xf4\xc0\x3c\x7b\x0f\x37\
\xa1\xe8\x0d\x67\x8c\x71\x1e\xe2\x4b\xd0\xda\xce\x5b\xbb\x26\xa1\
\xb5\xf9\x4e\x2b\xeb\x30\x9a\xbb\x25\xc8\xc8\x74\x03\x32\xbe\x04\
\x45\xf8\x14\x40\xf0\x08\xa3\x95\xd2\xe8\x4d\xf7\xc6\x42\x2c\x2a\
\xe7\x9f\xb8\xe7\xa1\x60\x21\xd2\xff\x73\xce\x50\x4e\xeb\x5b\xca\
\x0f\xe7\xed\x64\xcd\x6e\x1d\xa9\x14\xc7\x50\xd7\x50\xa0\xae\xa1\
\xf9\xfa\xc9\x46\x11\x93\x06\x57\xf0\xe9\x19\xb5\xdc\x30\xbe\x86\
\x5c\x14\x85\x4d\x0b\x01\x01\x01\x01\x01\x01\xdd\x87\x12\xe4\xb9\
\x7c\xd5\xfe\x2f\xc6\xc5\x9d\x22\x73\x01\xf2\x12\x3d\x84\x64\xa1\
\xb3\x91\x80\xdc\x80\xbc\x81\x4f\x23\xe5\x6a\x3a\xf2\x1e\xed\x44\
\xca\x54\x2d\x12\xea\x9f\xb4\xdf\xef\x45\x8a\xc3\x40\xa4\x10\x0d\
\xa4\xb9\xb2\xf4\x26\xf2\xa8\x0e\x46\x4a\xde\x08\xa4\x34\xfd\x0b\
\x12\xe6\x07\x91\x78\x6a\x9b\x90\xa0\x1e\xa3\x73\xcb\x1b\x91\x07\
\xb3\xd1\xab\x67\x10\xf2\x8c\xf5\x22\x51\xc6\xeb\x81\x29\xc0\xeb\
\x48\x19\x2e\x41\x4a\xed\x20\xeb\xe3\x23\xf6\x7d\x02\x2d\xcf\x43\
\x2d\x78\x75\x3f\x01\xbc\x88\x14\x87\x57\x91\xa7\xf5\x7c\xeb\xd3\
\x61\xeb\xb7\x3b\x8a\xa9\x97\x95\xbb\x1b\x29\x8d\x13\x90\x32\xb9\
\xd4\xc6\xa5\xc6\xda\x34\x1e\xf8\x85\xf7\x4e\xa6\xda\xdf\x82\xf5\
\xeb\x0f\xc8\xfb\xd8\xc7\x9e\x1b\x6c\x7d\xde\x85\x14\xd0\xb7\xdb\
\xfb\x19\x6e\xe3\x34\xc1\xda\x88\xd5\xbd\xc0\xde\xa5\x2b\x73\x09\
\xcd\x8f\xc5\xd9\x0a\xdc\x87\x94\xab\x5a\x7b\x9f\x03\x80\x87\xed\
\x3d\x2f\x46\x8a\xdb\x20\x1b\x9b\x0b\xad\x8c\x15\x48\xe9\xdf\x8d\
\x8c\x1c\xe7\x00\x17\x59\x9b\x1f\xb4\xb2\xd7\xd9\xbc\x71\xc6\x8f\
\xa5\x56\x4e\x1a\x31\x52\xb8\xa6\x59\x5f\x7a\xba\x82\x95\x41\x73\
\xad\x1a\xcd\xe9\xf6\x10\x21\x85\xf6\x6e\x12\x8f\xf0\x27\xac\xaf\
\x17\xa1\xf7\x36\x14\x19\x26\x26\x22\x83\xc6\xbd\xe8\xbd\xf7\x25\
\x79\xef\x05\x64\xc8\x79\xc6\xc6\x71\x0f\x32\xc6\xb8\xb3\x7f\x1b\
\xd0\x9c\x18\x8d\xde\xcf\x5e\xa4\x08\x57\x93\x78\xfd\xfd\xf3\xaf\
\xdd\xd8\xfb\xa1\xd1\x7e\xa2\xad\x15\x68\x8e\x9f\x69\xed\xda\x8c\
\xbc\xfa\x15\x28\x2a\xe1\xa5\xe3\xfd\x22\x02\x8e\x3e\x4e\x79\x45\
\x38\x8e\x63\x06\x57\x97\xf0\xf6\x89\x7d\xa9\xb7\x44\x56\x55\xa5\
\x59\xfa\x57\xe6\x88\xdb\x48\xe7\x5c\x88\xa1\x57\x79\x96\x4f\xcf\
\xa8\xe5\xca\x31\xbd\xf9\xfd\xe2\x3d\xbc\xb4\xbe\x8e\x55\xbb\xea\
\xa9\x6b\x28\xd0\x54\x88\xc9\x64\xa0\x57\x69\x96\xb1\x03\xcb\xb9\
\x72\x4c\x6f\xae\x1b\xdb\x87\xe1\x35\x25\x14\xe2\xb0\x73\x3f\x20\
\x20\x20\x20\x20\xe0\x28\xc1\x85\x65\x2e\x47\xde\xa1\x52\xa4\x2c\
\xc6\x48\x39\x1b\x8a\x94\xc5\x46\xef\xfe\x26\x24\x13\xe5\x91\x57\
\xd3\xed\x9b\x85\x96\xe7\x97\x1e\xb2\xdf\x86\xa2\x3d\xa4\x1b\xed\
\x53\x9f\xba\x2f\x46\x5e\xc2\x62\x67\x0c\x17\xec\x7a\x13\xcd\x93\
\x42\x65\x69\x2e\xb8\xd7\x22\xc5\xf7\x56\xaf\x9e\xc3\x56\x4e\xc6\
\x7b\xc6\x79\xcb\xb6\x21\xa5\x7d\x3f\x12\xe6\x1b\xbc\xfa\xda\xcb\
\xb4\x5b\x67\x65\xe5\xad\x2f\x59\xaf\x1f\xa0\xd0\x60\x77\x54\xcc\
\x21\x6f\x5c\x0a\x76\xef\x7e\xa4\xdc\xe7\x91\x22\xbf\x89\x24\x69\
\x98\xeb\xab\xbf\x57\xb3\x17\xf2\x64\x1f\x44\x4a\xc9\x41\xaf\x4c\
\xf7\xc9\x22\x05\x65\x23\x52\x6a\x97\x21\x05\xc9\x19\x39\x5e\xb6\
\x77\xd0\x1b\x29\xc5\x07\x48\x42\x73\xb1\x71\x69\x22\x39\xbb\x3d\
\x67\xe3\xd6\x68\xd7\xdc\xfe\xde\x3d\xc0\xb7\x49\x42\xd0\x2f\x42\
\x47\xe3\xb8\xf7\xbf\x1d\x85\xcc\xba\x71\x8a\xac\xbd\x4b\x51\x48\
\x6d\x6f\x64\x1c\x99\xdd\xc6\xf8\xba\xb2\x7a\x32\x22\x34\x67\xff\
\x37\x32\x18\x2c\xa6\x63\xd1\xa3\x7b\xd0\x3b\x74\xef\xcc\x8d\x51\
\x06\x79\xf8\x37\xa2\xb1\x5f\x87\xde\xcd\x5d\xf6\xcc\x6a\x34\x97\
\xdc\x7a\x3b\x40\x32\xb7\xd3\xeb\xce\x9f\x17\xa5\xc8\x7b\x3c\x14\
\xbd\xf7\x3a\x14\xd9\xd0\xda\xf8\xfa\x09\xe2\xdc\x3d\x2e\x71\x4f\
\xce\xda\xb0\xde\xfe\xfe\x91\xe2\x9e\xfd\x80\x93\x10\xa7\xbc\x22\
\x5c\x88\x61\xfc\xa0\x72\xbe\x7e\xe3\xc8\xa2\xbf\xb5\x05\xa7\x27\
\x4f\xa8\xad\x60\x42\x6d\x05\xfb\xea\x0b\xec\x3a\xd8\xc4\x81\x86\
\x3c\x75\x0d\x05\xca\x72\x11\x35\xe5\x39\x06\x55\xe5\xa8\x2a\xcd\
\x74\xa8\xcc\x80\x80\x80\x80\x80\x80\x80\x23\x42\x23\x52\x58\x9c\
\x77\xef\x15\xa4\x08\xbf\x0b\xed\x99\xed\x8b\x42\x85\x1f\x46\x7b\
\x00\xef\x44\x1e\xca\x6a\xe4\x59\xfa\x05\xf2\xa8\x3a\xc1\xdf\x09\
\xf5\x79\x24\x2f\x0d\x23\x09\xb1\x8e\x91\x92\x5a\x03\xfc\x1c\x85\
\x7b\xf6\xa7\xa5\x10\xef\x97\x95\x43\x4a\xea\x66\x94\x3c\x69\x2e\
\x52\x9c\xe6\x79\xbf\xaf\x42\x1e\xd6\x59\x48\x28\xbf\xde\xda\xda\
\x0b\x79\xa9\x07\x7a\xf5\x34\xd8\xff\x20\x85\xa2\x3f\xf2\x40\xcf\
\x46\xde\xcc\xf9\xc8\xa3\x3a\x15\x79\xa1\x87\xd2\xdc\x0e\x1f\x79\
\x6d\x75\x7f\xb1\xfe\xb9\x76\x67\x52\xf7\xb8\x6b\x59\xaf\x8c\x12\
\xab\xff\xa0\xd7\xc7\x19\xd6\xcf\x45\x28\xe4\xb9\x09\x85\x23\xfb\
\x09\x95\x7a\xa3\xb0\xe5\xef\xdb\xbb\xeb\x67\xd7\xf3\xc8\x4b\x38\
\x08\x79\xb9\x27\x21\x0f\xf1\x68\xe4\x7d\xdd\xec\xb5\x71\x8d\x3d\
\x7b\x3e\x52\xbe\xd3\x86\x88\x21\x68\x5f\xe9\x22\xe4\xed\xbd\x0f\
\x79\xe5\xaf\x40\x1e\xc5\xf3\x48\x94\xe7\x1b\x91\x97\xbb\xce\xc6\
\xdd\x29\x67\x23\x90\xb7\x7c\x8d\x37\x27\x5c\xfd\xaf\x03\x7f\x87\
\xbc\xd4\xdb\x48\xf6\xc9\xfa\xe3\x05\x52\x2a\x77\x58\x5b\x4f\x84\
\x6d\x89\xeb\x90\xf7\x35\xdb\x81\x7b\xdd\x7c\xf0\xe7\x89\x33\xe8\
\xbc\x89\xc2\xe0\xf7\xa0\xf5\x73\x36\x7a\x97\xc3\x80\xfb\xed\xbe\
\xbe\xa9\xe7\x40\x73\x20\x83\xe6\xec\x36\x9a\x1b\xa5\x32\x68\xce\
\x9d\x65\xe3\xbe\x10\x85\xbc\xc7\x34\x1f\x77\x67\x20\xda\x4f\xb2\
\x7f\x7c\x0a\xf2\x3a\x47\x5e\x9b\x37\x5b\x1d\xd5\x48\x19\xbe\x0e\
\x19\x9b\xc2\xf9\xc0\xa7\x00\xb2\xc3\x7a\x97\x7e\xf1\x96\x09\x7d\
\xcb\xab\x4b\x4f\x84\x75\xd9\x33\xe1\xcc\x4c\x65\xd9\x88\xbe\x15\
\x59\x6a\xab\x4b\x19\xde\xa7\x94\x21\xd5\xa5\xf4\xa9\xc8\x52\x92\
\x89\x4e\xfa\x43\xe4\x3a\x8a\x7c\x01\x1e\x58\xba\xf7\xf0\xe2\xed\
\x87\x1f\x42\x84\x27\x10\x99\x80\x9e\x8c\x18\x09\x4f\xfb\x91\xe5\
\x3f\x10\xca\x80\x80\xe3\x8b\x2c\x12\xac\x17\xd3\x92\x87\xc4\x48\
\x81\x3a\x1b\x29\x99\x87\xec\xbe\x11\x48\xe1\xa9\x45\x0a\xcd\xb3\
\xc8\x4b\x55\x87\xc2\x55\xfb\xa3\x10\xdd\x65\x28\x44\x77\x0b\x52\
\xa8\xab\x90\x40\xbe\x00\x09\xde\x23\x90\x67\x6b\x1f\x0a\xd9\xdc\
\x6b\xf5\x9d\x67\xf7\xad\x44\x5e\xd9\x3a\xa4\x0c\xee\x41\x0a\xe0\
\x1a\x92\x6c\xb6\x6f\x58\x9b\xce\x44\x09\xa1\x36\x22\xcf\xb5\xeb\
\xcb\x6b\xc8\x93\xea\x12\x61\xfd\x11\x79\x3d\x2b\x90\xb0\xef\xea\
\x71\xcf\x8d\xb2\x7e\x3e\x61\xdf\xcf\x43\xf4\xea\x29\xa4\x9c\xd6\
\xa3\x70\x60\x90\x62\xf3\x26\x89\x97\x38\x6b\x7d\x5c\x81\xbc\xce\
\xab\xed\xd9\x3e\x48\x11\xda\x61\xdf\x37\x5b\x9f\x1b\xad\xee\x2a\
\xfb\xbe\xdc\xfa\x1f\x21\xa3\xc3\x7a\xa4\x90\x8e\xb1\x3e\xce\xb5\
\xb2\x6b\xad\x5d\x3b\xec\xf9\x35\xd6\x9f\xf9\x48\x09\xbd\x80\x24\
\xd9\xd8\x56\xfb\x5b\x6d\xef\xe5\x51\xe4\xfd\x9b\x6a\xf5\x3e\x69\
\xe5\x54\x5a\x1d\xfb\x48\x14\xfc\x3f\xa6\xe6\x43\xa5\xd5\x7b\xd0\
\xc6\xfb\x45\x64\x10\x59\x6d\xe5\x4f\xb5\xf1\xfc\x8d\x8d\x4d\x2f\
\xbb\xd6\x17\x29\x69\x2b\x48\xc2\xd5\x57\xd9\x58\x3a\x65\xaf\xaf\
\xf5\x63\x25\x32\x86\xbc\x68\xe3\xd4\xcf\xee\x3d\x68\xe3\xbb\xd0\
\x9e\xb9\xd6\xee\xd9\x48\xcf\x90\x7b\x2a\xd0\x3a\x7a\x9e\xc4\x13\
\xef\x23\xad\xc8\xb7\x85\x5e\x68\xde\x2c\x27\x31\x02\xf4\xb5\xb1\
\x79\x03\xcd\xfd\x69\x68\x2e\x3d\x85\xde\x6f\x13\x7a\xef\x25\x68\
\xdd\x6d\x46\xeb\x69\x0f\x9a\x47\x4d\x36\x7e\x23\xad\x5c\x17\xbd\
\xe1\xe6\xdb\x12\xb4\xc6\x26\x21\x63\xc7\x72\xfb\xdf\xed\xf1\x5e\
\x89\xde\xf1\x02\x7b\x1f\x63\x91\xf2\xbd\xc4\xde\xdb\x2e\xa4\xa8\
\x2f\x27\x49\x7c\x36\x11\xd1\x8e\x75\x24\xc9\xe6\x7a\xc2\xbb\x0a\
\xe8\x7e\x54\xa1\xf9\xf7\x70\x34\x65\x78\xd5\x9e\xbb\xef\x18\x5d\
\x53\x5b\x9d\x23\x0e\x9a\x5a\xc0\x51\x46\x7d\x53\xcc\x27\x7f\xbf\
\x76\xcf\x3d\x0b\x77\x7f\x06\x31\xe4\xa0\x58\x04\xf4\x64\xe4\xd1\
\x71\x2b\x9b\x90\xb7\xa1\x23\xd6\xf1\x80\x80\x80\xa3\x87\x52\xe0\
\x0b\x48\x79\x59\x40\xcb\x3d\xaf\xbd\xd0\x99\xc1\xbf\x47\x02\xb0\
\x0b\xa1\x75\x5e\xdc\x02\xcd\xc3\x93\x8b\x7d\x2f\x86\x98\xe6\xe1\
\xd2\xd0\xdc\x4b\xe5\x7f\x6f\x0f\xe9\xe7\xd2\xcf\xa4\xdb\x15\xa5\
\xee\x4f\x3f\xeb\xc2\x93\xa1\xf9\x1e\xc9\xc8\x2b\xab\x33\xed\x3b\
\x52\xb8\xb6\xa6\xeb\xf5\xc7\xae\xb5\xbe\xfa\xf7\xa5\xc7\xbb\xb5\
\x3e\x64\x91\x97\xf8\x56\xa4\x20\x3f\x4f\xf3\x70\xee\x01\x88\x7e\
\x7f\x13\x29\xcf\x71\x2b\x6d\x4a\x8f\x55\xba\x5d\xed\x8d\x59\x5b\
\x63\x5b\x40\x0a\xd6\x15\xc0\x77\x48\x42\xca\x8f\x27\xdc\x79\xbb\
\x5f\x00\xbe\x8a\x8c\x3e\x47\x7b\x5e\xa4\xc7\xbd\xb5\xf7\x9e\x6e\
\x67\x7a\xcd\x15\x2b\x37\xfd\xbd\x58\x39\xd0\xf2\x1d\xb7\x75\x4f\
\x3a\x2c\x3b\xe0\xe4\x41\x8c\x22\x69\x3e\x02\x7c\xf6\x94\x0f\x8d\
\x0e\x08\x08\x08\x08\x08\x08\x38\x29\xe0\xf6\x37\x3e\x4a\x12\x6e\
\xe9\x3e\x7e\x48\x2e\xed\x7c\x6f\xad\xec\xb8\xc8\xb5\x62\xdf\x3b\
\xd2\xce\xb6\x9e\x6b\xab\x5d\xc5\x9e\x8d\x5b\xf9\xee\x3f\x7f\x2c\
\x84\xfa\x62\xed\xf6\x15\x8a\xb6\xfa\x5a\x6c\x3f\x68\x5c\xe4\x9e\
\xf4\xb3\xe7\x23\xef\xdf\x7c\x5a\x1a\x2a\xeb\x69\xee\x01\x6f\xaf\
\x4d\xad\xb5\xbf\x3d\x44\xed\xfc\xd6\x0b\x25\x65\x3b\xc8\xa9\x69\
\xfc\x2f\x36\xee\xad\xbd\x77\x1f\xad\xa4\xac\x6d\x51\x6e\xfa\x7b\
\xb1\x72\xda\xbb\xaf\x23\xf7\x04\x9c\x84\x08\x8a\x70\x40\x40\x40\
\x40\x40\x40\xc0\xc9\x02\x77\x6e\x6b\xf0\xe8\x9c\xfc\x68\x44\xfb\
\xba\x8b\x79\x6d\x23\x14\x76\xfd\x7b\xef\xff\xe3\x81\x08\x65\x1f\
\x6e\xcd\xeb\x19\x10\x10\x70\x1c\x11\x16\x65\x40\x40\x40\x40\x40\
\x40\xc0\xc9\x84\xa0\x00\x9f\x5a\x38\x11\xde\xf7\x89\xd0\xc6\x80\
\x80\x53\x0e\x41\x11\x0e\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\
\x08\x08\x38\xa5\x10\x14\xe1\x80\x80\x80\x80\x80\x80\x80\x80\x80\
\x80\x80\x80\x80\x53\x0a\x41\x11\x0e\x08\x08\x08\x08\x08\x08\x08\
\x08\x08\x08\x08\x08\x38\xa5\x10\x14\xe1\x80\x80\x80\x80\x80\x80\
\x80\x80\x80\x80\x80\x80\x80\x53\x0a\x41\x11\x0e\x08\x08\x08\x08\
\x08\x08\x08\x08\x08\x08\x08\x08\x38\xa5\x90\x8b\x80\x6c\x04\xd9\
\x28\x22\x0e\x39\xed\x02\x8e\x22\x22\x20\x9f\x89\xc9\x68\x9e\xe5\
\xed\x13\x77\xa5\xcc\x80\x80\xa3\x8c\x3c\x50\xb0\x4f\xfe\x78\x37\
\x26\x20\x20\xe0\x2d\xbe\x11\x78\x48\x40\xc0\x91\xc1\xad\x1f\x7f\
\x1d\x05\x0d\x20\xe0\x54\x81\x3f\xff\xc9\xad\xdf\xdb\x50\xf6\xd5\
\x67\xb6\x50\x55\x92\x09\xdc\x24\xe0\xa8\x23\x5f\x88\x79\x63\xcb\
\xa1\x72\xe0\x1d\xc0\xe5\x04\xe2\x1b\xd0\xb3\x51\x00\xce\x47\xe7\
\x51\x9e\x4e\x88\xa2\x09\x08\x38\xde\xc8\x02\x67\x03\xef\x04\xb6\
\x13\x78\x48\x40\x40\x67\x11\x03\x15\xc0\x99\xc0\x87\x80\x83\x84\
\x75\x14\x70\xea\x20\x06\xaa\x80\x61\x40\x69\xae\xb2\x24\x93\x1f\
\x3f\xa8\x82\x9a\xb2\xec\xf1\x6e\x58\xc0\x29\x80\xc6\x42\xcc\x4b\
\xeb\xeb\x1a\x80\xe7\x81\x15\x04\xe2\x1b\xd0\xb3\x11\x03\xbd\x80\
\x6d\xc0\x53\x84\xf9\x1a\x10\x70\xbc\x51\x02\x0c\x07\x9e\x03\x56\
\x12\xd6\x64\x40\x40\x67\x11\x03\x35\xc8\xb8\xfb\x38\xb0\x9b\xb0\
\x8e\x02\x4e\x1d\xc4\x40\x5f\xe0\x16\xa0\x90\xeb\x5f\x95\x6b\xba\
\x61\x6c\x0d\xb5\xbd\x4a\x88\x83\x4b\x38\xe0\x28\xa3\xbe\xa9\xc0\
\xa3\x2b\xf6\xd5\xbf\xbc\xa1\xee\x61\x60\xde\xf1\x6e\x4f\x40\x40\
\x07\x30\x0e\x58\x0d\xfc\xfa\x78\x37\x24\x20\x20\x80\x1c\x70\x19\
\xf0\x30\x30\xff\x78\x37\x26\x20\xe0\x04\x45\x5f\xe0\x4a\xe0\x77\
\x28\xb2\x22\x20\xe0\x54\xc2\x00\xe0\x12\xa0\x29\x17\xc7\xd0\x14\
\x43\x53\x21\x0e\x8a\x70\xc0\x51\x47\x53\x01\xe2\x38\x8e\x50\x78\
\x5b\x40\xc0\x89\x80\x0c\x61\xbe\x06\x04\xf4\x14\xe4\x90\xf7\x2a\
\xac\xc9\x80\x80\x23\x47\x0e\xf1\xb6\xdc\xf1\x6e\x48\x40\xc0\x71\
\x80\xe3\x23\x61\xbf\x5b\x40\x40\x40\x40\x40\x40\x40\x40\x40\x40\
\x40\x40\xc0\xa9\x85\x60\x09\x0a\x08\x08\x08\x38\x52\xfc\xd9\x93\
\xcd\xff\x8f\x49\x76\x5a\x7d\xed\xd2\x63\x53\x6f\x67\xea\xf9\xcc\
\x93\xde\x4e\xb0\x26\x9a\xb1\x80\xa3\xd9\xde\x80\x80\x80\x80\x80\
\x80\x80\x80\x1e\x86\xa0\x08\x07\xf4\x34\x94\xa1\x7d\x2b\xe7\x00\
\x1b\xd0\xfe\x95\x7d\xa9\x7b\xae\x06\xd6\x02\x4b\xbc\x6b\x43\xd0\
\xbe\xb1\x7b\x80\xc3\x1d\xac\x6b\x22\x30\x10\x78\xa2\x93\x6d\xbc\
\x02\xd8\x45\xd8\x9f\x16\xa0\xec\xb5\x77\x01\x8f\x12\xc7\x8f\x41\
\x34\x14\xf8\x30\xf0\x18\xf0\x5c\x73\xc5\x13\x29\x9b\x69\xe5\xb9\
\xcd\xdf\x2a\xe0\x6b\xd3\x52\xd7\x63\xd0\x3a\xf9\x00\xb0\x17\xf8\
\x19\x7f\xf6\x04\x6f\x55\x14\x01\xff\x76\x29\x7c\xf1\xc9\xe6\x2b\
\x21\x2e\x40\x4c\x44\xc4\xd9\x2a\xb8\xe4\x55\x88\xdf\x86\x32\x27\
\x7e\x9b\x3f\x7b\xb2\x11\x62\xa8\x6f\x82\xb2\x12\x92\xc2\x0a\xfa\
\x1b\xc7\xfa\x7c\xfd\xf2\xe3\x3d\xe6\x01\x01\xdd\x85\xb1\xe8\x04\
\x83\x26\xb4\xb0\x32\xc0\xeb\x68\xff\x71\x43\x07\x9e\xbf\x00\x65\
\xdf\x7d\xb6\x1b\xdb\x74\x01\x70\x2b\x70\x37\xb0\xd4\xae\x55\x01\
\x1f\x05\x96\x03\x0f\x00\xef\x02\xe6\x02\x8b\xbb\x79\x3c\xca\x80\
\x49\xc0\x02\x8a\xf3\xd1\xbe\xc0\x75\xc0\x7d\x88\x0f\xbf\x08\xd4\
\x23\xfe\xfb\x7a\x37\xb7\x25\xe0\xc4\xc1\xb5\xc0\x6c\xb4\x86\x1a\
\x91\x6c\xf4\x00\x9a\x1b\x9d\x41\x06\x78\x3b\x4a\x4c\xb9\xf5\x28\
\xb5\xf5\x42\xa0\x12\x58\x03\x9c\x0b\xdc\x8f\x98\x5c\xc0\x29\x8a\
\x10\x1a\x1d\xd0\xd3\x70\x33\x70\x03\xf0\x32\x22\x52\xef\x2e\x72\
\xcf\x2c\x94\xed\xd0\xc7\x20\x7b\xb6\xac\x13\x75\x9d\x05\x5c\x74\
\x04\x6d\x9c\x81\x14\xa0\x80\x80\x33\x81\x2f\x02\xff\x8b\x28\x1a\
\x8c\xe6\xe1\x67\x80\x29\xfc\xd9\x93\x90\x27\x02\xfa\xa1\xc4\x0c\
\x39\x29\xac\x64\x81\xfe\x40\x15\x71\xdc\x0f\xe8\x4b\x86\xc8\x94\
\xdd\x52\xa0\xd6\xca\x29\x23\x3e\xe8\x94\xe0\x32\x64\xb4\xe9\x6d\
\x5b\x23\x4b\x80\xf7\x00\x37\xf3\x67\x4f\x42\x1c\x67\xac\xcc\x7e\
\x40\x86\xcf\x3c\x29\x31\x36\xa6\xc2\xca\xaa\xa1\xe9\x70\x44\x86\
\xe1\xc0\x7f\x03\xb7\x43\x5c\x89\x92\xa4\x6c\x40\x82\x41\x7f\x20\
\x4b\x65\x19\xc4\x71\x0d\xd0\xd7\x94\xee\xd2\xb7\xea\xce\xe5\xe0\
\x93\x8f\x1e\xef\x31\x0f\x08\xe8\x2e\x8c\x01\xce\x43\x8a\xec\x33\
\x48\x01\xfc\x24\x32\xc6\x76\x04\x13\x81\x29\xdd\xdc\xa6\x49\xc0\
\xe7\x80\xb7\x79\xd7\xc6\x03\x7f\x89\x94\x8d\x2c\xca\x76\x3a\xe6\
\x28\x8c\xc7\x48\xe0\xcf\xd1\x9a\x2f\x86\x1a\xab\xbb\x17\x50\x6d\
\x6d\xb9\x0a\x29\xee\x01\xa7\x2e\x2e\x05\x46\xa0\xd3\x40\x16\x00\
\xef\x45\xf3\xa4\xb3\x88\x91\xfc\x37\xe0\x28\xb6\x75\x22\x30\x1d\
\x39\x02\xab\x08\xd9\xb2\x4f\x79\x04\x8f\x70\x40\x4f\xc3\x64\x74\
\x2c\xc6\x53\xc0\x19\x40\xef\x22\xf7\xe4\x81\xa9\x48\x60\xd8\x0e\
\xfc\x06\x59\xf4\x9c\x55\xff\x0c\xe0\x7a\x44\xe4\x5e\x04\x9e\xb6\
\xe7\x66\x21\x02\xb8\x0f\x79\x9a\x0b\x56\x56\x0e\xb8\x0d\xd8\x08\
\xbc\x8a\x84\xa0\x09\xf6\xfb\x83\xc0\x9b\x48\xf1\xbe\x05\x59\x3b\
\x47\x21\xcb\x7c\xc6\xca\x9c\x01\xec\x41\x56\xf2\xf5\xc7\x7b\x00\
\x03\x8e\x29\x0a\xc8\xea\x3d\x15\x31\xff\x87\xd1\x1c\xc9\x03\x65\
\xe4\xf8\x04\x52\x58\xcb\x80\x3f\x02\xff\x88\x3c\x48\xdf\x07\xea\
\x89\xa2\x21\x40\x81\x02\x5f\x41\x73\xef\x7f\x20\x61\xb4\x37\xb0\
\x96\x28\xfa\x22\x12\x36\xff\x0e\xb8\x18\xd8\x0a\x85\x7f\x44\x02\
\x47\x1e\xcd\xf9\x52\xa2\xcc\x27\xad\x1e\x88\xf9\x09\xf0\xff\x80\
\x11\x44\xfc\x03\x12\xf4\x77\x51\x52\xf1\x75\x34\xaf\x27\xa3\x39\
\xbc\x18\x09\x2f\x13\xac\x4d\x9f\x82\xe8\x23\xe4\x0b\xeb\x88\xa2\
\xef\x03\x6f\x40\xfc\x5d\x88\xfe\x07\x30\x93\x28\xda\x4a\xa1\xf0\
\xbf\x21\x7a\x04\xc2\xb1\xf3\x01\x3d\x16\x35\xe8\x78\xa5\xd5\xe8\
\x7c\xd4\xf6\xb0\x81\x84\x47\x80\xe8\xff\x58\xe4\x29\xba\x00\x45\
\x00\x35\x22\x5e\xb0\x04\x19\x96\xde\x0e\x94\x03\x43\x51\x74\xd2\
\x38\xfb\xdc\x8b\x94\xc8\xdb\x10\x3f\xc8\x20\x03\xed\x48\xa4\x20\
\x3c\x88\x68\xc1\xdb\xd0\xda\x5b\x6c\xd7\x0e\xa5\xda\x34\xdf\xda\
\x50\x8d\xce\x30\x9f\x66\xcf\x3b\x0f\x5b\x9e\x96\x5e\xac\xf3\x90\
\x72\x3c\xd4\x7e\x7b\xde\x9e\xab\x04\x7e\x8e\xf8\xdb\xf9\xc0\x1c\
\xfb\xfd\x51\xe0\x35\xe4\xd9\x1d\x82\xbc\xbd\x35\x88\x3e\x5c\x8f\
\x3c\x7a\x73\x90\xc1\xb8\x01\xf8\xbd\xd5\x9f\x47\xeb\x7f\x8f\x95\
\x7d\x29\xe2\xb9\x37\xda\xf3\xbf\xb1\xfe\x5c\x66\xcf\x3d\x77\x6c\
\x5e\x7b\x40\x37\xa3\x16\xcd\x89\x95\x68\xfe\xb7\x85\x02\x8a\x08\
\xb8\xcf\xfe\x1f\x8e\x8c\x37\x03\x90\x62\x5b\x81\x3c\xbc\xcf\xa1\
\xf9\x36\x12\x1d\xd9\x74\x0f\xb0\x19\x19\x93\xe6\x20\x79\xae\x17\
\xe2\x7f\xef\x05\xfe\x80\xa2\xef\x2e\xb0\xb2\x9e\x41\xf3\xec\x4c\
\x60\x15\x9a\x93\xe5\x68\xbe\x0e\xf7\xca\xcc\xd9\xb5\x2c\x3a\xa6\
\x73\x3e\x5a\xb3\x15\x28\x02\x6a\x93\xf5\xc9\x45\x1b\x9e\x8f\x8c\
\x4c\xd5\xe8\x34\x13\xc7\xc7\x03\x4e\x01\x04\x8f\x70\x40\x4f\x44\
\x2f\xe0\xcb\x48\x80\x78\xaa\xc8\xef\x95\xc8\xaa\xf7\x06\x22\x90\
\x1f\x41\x56\xbd\x18\x09\x29\x7f\x8b\x98\xf5\x9b\xc0\x27\x10\x81\
\xbb\xd8\xee\x7b\x03\x09\x22\xef\x42\x44\xb2\x04\xf8\x20\x30\x13\
\x11\xd6\x69\x88\x20\x3f\x8f\x98\xfe\xe7\x81\xc1\xc0\x5f\x21\x62\
\xbf\x0e\x29\x0e\x79\x7b\xe6\x83\x48\x81\xc9\xdb\x3d\x35\xc7\x7b\
\xf0\x02\x8e\x29\x22\xa0\x0e\x09\x01\x1f\x46\x42\xa4\x33\xb0\x5c\
\x0d\xfc\x35\x9a\xc3\xff\x0d\xdc\x05\xd1\x47\x10\x93\x3e\x0b\x09\
\x03\x3f\x42\x0c\xfc\xed\xc8\x48\x73\x17\x12\x24\xff\x1d\x58\x09\
\x71\x16\xf8\x10\x0a\x3d\xfb\x3a\x62\xdc\x7f\x8f\x84\x94\x82\x7d\
\x66\x02\x5f\x40\x02\xf5\x43\xc0\x5f\x12\x31\x13\x79\x95\x2e\x00\
\xfe\x0d\xd8\x0a\xd1\x95\xc8\xf3\xb5\x03\x29\xe5\x4f\x59\xdd\x63\
\x90\x80\x3f\x18\x09\xb5\x93\x90\x71\xe7\x0d\x88\x3e\x08\x5c\x03\
\xfc\x5f\x24\x90\xff\x2d\xb9\x4c\xdf\xe3\x3d\xe8\x01\x01\xad\x20\
\x07\xfc\x0d\xda\x9a\xf0\x09\xda\xf7\xf6\x14\xd0\xfc\x7f\x37\x12\
\xbc\xff\x1c\x09\xdc\x8f\x20\x1e\xf3\x17\x28\x3c\x79\x33\x5a\x63\
\xa3\xec\x9e\x5a\xa4\xc4\x4e\x42\x7c\xe4\x0c\xb4\xde\x23\xc4\x5f\
\x6e\x06\xfa\x00\x9f\x42\x0a\xed\x4b\x68\x6d\x5d\x0c\x7c\x1a\x09\
\xf2\xcf\xa1\xe3\x3b\xd2\x51\x4f\x19\x60\x19\x12\xc4\xc7\x21\xe1\
\xfc\x74\x2b\xa3\x2d\x99\x6d\x32\x0a\x9f\x5e\x81\x22\x96\xfe\x1e\
\x19\x66\x87\x01\xef\xb7\x6b\x7f\x85\x14\xf7\x8d\xc0\x57\xac\x6d\
\x57\xa1\x70\xe7\xd7\xac\x4f\xdb\xad\xcf\xb3\x11\x3f\x7c\x16\x29\
\x10\x9f\x45\xfc\x12\xeb\xe7\xb5\xd6\xc7\x75\xf6\x59\x81\x94\x94\
\x89\x34\xe7\xb1\x01\x27\x1e\x6a\x80\xff\x42\x67\x0c\x5f\xdf\x81\
\xfb\x63\x34\x57\x3e\x00\xfc\x09\x9a\xd7\x8f\x58\x39\x9f\x46\xeb\
\x6c\x39\x72\x26\x8c\x40\xbc\xe7\x2c\x24\x3f\x9d\x85\x78\x95\x3b\
\x13\x7c\x14\x32\x60\xcd\xb4\x4f\x84\xb6\x2f\xd4\x00\xef\x43\x6b\
\xe8\x25\x34\xdf\xaf\xb4\x32\x87\x23\x63\xd6\x78\x34\xd7\x07\xa3\
\xc8\xac\x3d\x68\xae\x7f\x16\xad\xd9\x45\x68\xcd\x46\x24\xdb\xe9\
\x6a\xad\xdd\x6b\xd0\x76\x83\x3f\xb1\x7b\x02\x4e\x11\x04\x8f\x70\
\x40\x4f\xc4\x01\x64\xe9\xdb\x88\x94\x00\x90\x55\xb1\x04\x59\x1c\
\x0f\x03\x3f\x43\xc2\xfc\x4e\x44\xf0\x5e\x42\xca\xc7\x39\x88\x28\
\x7f\x07\x59\xa3\x07\x23\x86\x5d\x07\x3c\x89\xac\xfc\x7f\x44\x16\
\xc7\x59\x48\x60\x29\x41\x84\x70\x93\x95\xdd\x80\x88\x6e\x25\x52\
\xac\x27\xa2\x90\xd3\xef\x03\xfb\x91\xf7\xcf\x85\x84\x55\x23\xa1\
\xa6\x0a\x11\xcf\xd3\x90\xb2\x1d\x70\xea\xa0\x09\xf8\x26\xf0\x19\
\x22\x3e\x8e\x3c\x42\x31\x9a\x27\x3b\x81\xaf\x12\x17\xb6\x13\x65\
\xe6\x00\x97\xa3\x39\x1c\xa3\x39\xfe\x2d\x14\x56\x58\x89\xe6\xfb\
\x26\xe4\x35\x9e\xaf\xdf\xa3\x3c\x0a\xdf\x2f\x20\x61\x38\x46\x0a\
\xf4\x48\xfb\x1e\x23\x81\xa0\x0a\x59\xef\x41\x42\xe8\x2c\x64\xe5\
\x7e\x44\x75\xc4\x3f\x85\x28\x42\xd6\xf3\x83\x48\xf1\x5d\x6d\xf7\
\xc7\xc8\x08\xf4\x34\x52\x7a\x4f\x07\xb6\x40\xfc\xb2\x29\xc2\x79\
\x24\x9c\xa0\xdf\xa2\x11\xc8\x4a\x1f\x10\xd0\xd3\x10\xa1\xb5\x50\
\x85\xd6\x54\x47\xe0\x0c\xa2\x67\x21\x9a\xfe\x79\x64\x44\xfd\x13\
\xc4\x3f\x46\x90\x28\xbb\x97\xa2\xb5\xf0\x79\xa4\xfc\x9d\x46\xb2\
\xde\xf3\x5e\x99\x4d\x68\xab\xc1\x85\x48\x71\x5e\x0d\xbc\x80\x84\
\xee\xbf\x46\xfc\x6a\x02\x5a\xab\x57\x20\x43\x99\xff\xbc\x33\xae\
\x5d\x64\x75\x1f\x40\xca\xf8\x28\x5a\x47\x84\x94\xeb\x07\xac\x9e\
\x3a\xe4\x51\xcb\xa0\x75\x3d\x1b\x29\x1b\xbf\xb0\xfb\x27\x21\x85\
\xa5\x01\x29\x3c\x4f\x20\xc5\x7b\x07\x52\xc4\xd7\xdb\xf7\x3e\xd6\
\xce\x11\x48\x21\x76\xd1\x20\x05\xe4\xf9\xdd\x60\xe3\xb7\x18\x45\
\x60\xcd\x26\x89\xce\x9a\x7b\x54\xdf\x76\xc0\xd1\x42\x16\xc9\x36\
\x55\xe8\x9d\x77\x04\x55\xc8\x88\x54\x82\xde\xff\x24\x34\x7f\xd6\
\xa3\x08\xbc\xad\x48\x31\x3d\x1d\xf1\xaa\x52\x64\xa4\x99\x61\xf7\
\xfc\xd2\xae\x5d\x86\xe4\xb0\x47\x10\x1f\x5b\x80\xe4\xb0\x79\xc8\
\xc8\xf5\xff\x80\x57\xd0\x5c\xcf\x21\x59\x6d\x94\x95\x59\x86\xd6\
\xe9\xe3\x48\xf1\xfe\x9d\xf5\x63\x3c\xda\xf2\xb0\xde\xee\xad\x44\
\xf3\xb3\x60\x6d\xfa\xae\xb5\x7d\x88\xdd\x3f\xf8\x78\xbf\x80\x80\
\x63\x87\xa0\x08\x07\xf4\x34\xb8\x33\x5b\x37\xa0\x30\xb3\x6b\xd0\
\x3c\x7d\xc1\xfe\x6e\xb6\xfb\x9a\xec\xaf\x0b\xd3\xf2\x9f\x2f\x78\
\xd7\x1a\xad\xbc\x1c\x49\xa8\x4b\x29\x22\x96\x65\x88\xe1\x6f\x40\
\xa1\x6c\x0b\x90\x37\xf8\x16\xab\xef\x00\xcd\x53\xeb\x16\xbc\x3a\
\x23\xbb\xbe\xde\xca\xc8\x78\x65\x05\x9c\x5a\xc8\x20\x21\xf0\x1b\
\xc0\xbf\xa2\x79\x11\x23\x21\xb1\x02\xe8\x03\xd1\x41\x64\x7c\xd9\
\x4a\x22\xf0\x1e\xf0\xca\x88\x88\xe3\x85\x44\xd1\x87\x90\x20\x39\
\x1b\x79\x61\x9d\xe2\xba\x0f\x29\xc7\x73\x91\x41\x66\x25\x89\x77\
\xc8\x19\x6f\x96\x21\xe1\xfc\x49\xa4\xd8\x5e\x05\xf4\x27\xa6\x8c\
\x28\x1a\x81\x04\x86\x4d\xb8\x33\x58\xcb\x70\x81\x96\x91\x7d\xfb\
\x3d\xf0\x9f\x28\xc4\xf2\x17\xd6\xd6\x06\x64\xfc\x79\x0d\x09\xe6\
\xdf\x25\xcc\xf1\x80\x9e\x8b\x46\xb4\xbd\xe0\xc7\x88\x9e\xb7\x17\
\xc2\x9f\x41\x02\xf3\x0f\xec\xfb\x41\xe4\x51\x72\xde\xd7\x2d\x68\
\x5d\x01\x7c\x0d\xad\x9f\xeb\x48\x78\x41\x13\x12\xfc\x2d\xa3\x1c\
\x05\xfb\xbf\xcc\x9e\x8f\x48\xd6\xfb\x40\xa4\x38\xd7\x93\xf0\x8a\
\x75\x88\x0e\xa4\xc3\x9c\x23\x14\x95\xf4\x27\x48\x40\x7f\x85\xf6\
\xf7\x4d\xe6\x91\x50\xef\xfa\x75\xd0\x2b\x2b\x46\x7c\xb0\xc9\xbb\
\xdf\xf1\xb6\x3c\x5a\xe3\xd0\xdc\x83\x7b\x33\x52\x44\x5e\x42\xf4\
\xc7\xf5\x31\xdd\xce\x8c\x77\xfd\x31\xe4\x45\xaf\x41\x79\x3e\xea\
\xba\xf4\x36\x03\x8e\x17\x76\x01\x1f\x47\x0a\x61\x47\x92\x82\x46\
\xc8\x90\xf2\x7f\xec\xff\x8b\x51\xf4\xc1\x7c\x34\x07\xdc\x3a\x79\
\x1f\x32\xe2\xbe\x82\x12\x3d\xf6\x46\x73\xd0\xcd\x7f\x67\x50\xca\
\x90\x84\x41\xbf\x13\xad\x97\xad\x34\x9f\xc3\x7d\x90\xe2\x7a\x3d\
\xda\x0e\x30\xd7\xca\xec\x63\xed\x39\x48\xb2\xf5\x2d\xa2\xf9\x9a\
\x75\x28\x20\xc5\xf8\x73\x28\xa2\x61\x85\xb5\x37\x44\xcb\x9e\x42\
\x08\x2f\x3b\xa0\xa7\x21\x87\x88\xdf\x45\xc0\x4d\x88\x01\xbf\x89\
\xc2\x3e\xef\x43\x96\xf5\x2a\x14\x4a\x3a\x15\xb8\x1d\x09\x3c\x75\
\x48\xc1\x5d\x88\x94\x8f\x3b\x10\x31\xbe\x16\x11\xe8\x67\x91\x37\
\xee\x22\xe4\x65\xbe\x1d\x11\xc7\x37\x90\xc2\x71\xb6\xdd\x7b\x36\
\x52\xb6\x9f\x44\x96\xc1\x1a\x14\x32\xb3\x0f\xb8\x13\x09\x06\x6e\
\x8f\xd5\x73\x48\x38\xd9\x47\xb2\x57\x2a\xe0\xd4\x42\x84\x18\x7c\
\x44\xcc\xcf\x90\x01\x45\xc6\x9c\x98\x47\x10\x23\xfe\x26\x51\xf4\
\x43\x64\x7c\xf9\x09\x52\x5c\x4b\x48\xe8\x6f\x16\xc8\x10\x45\xe7\
\xa3\x2d\x01\x7b\x90\x11\xa8\x0e\xed\x79\xba\x1f\x09\xd1\xb7\xa0\
\xc8\x85\x59\x48\xe0\xcf\xd9\xe7\x69\x14\xce\xe8\x84\x86\x3b\x89\
\xe3\x7d\x48\xb1\xbd\x9c\x88\xbb\x81\x5f\xa1\x2d\x03\x15\x48\xe8\
\xbd\x95\x7a\xee\x20\x31\x12\x65\x90\xe0\xbd\xd3\xea\x7a\x10\xa2\
\x26\x14\x6a\x3d\xc8\xab\xfb\x62\xe2\x16\xfb\x19\x03\x02\x7a\x12\
\xb6\x22\x7a\xbf\xa7\x03\xf7\x3a\x83\x66\x16\xd1\xf4\x6f\xa1\xf9\
\xff\x4e\x24\x58\x97\xa1\xb5\xd6\x44\x72\x5a\xc0\x5a\xb4\x1f\x7f\
\x3a\x49\x82\xc6\x4d\x48\xa0\x76\x51\x46\x43\xd0\x9a\x5c\x82\x42\
\x84\xa7\xa2\xd0\xea\x01\x88\x5f\x0d\xb3\x76\x4e\x44\x74\x21\x6d\
\xcc\x2d\x41\x0a\x7a\x05\xf2\x98\xbd\xec\xb5\x13\x92\x35\x4b\xea\
\xb9\x8c\xf7\xdd\xdd\x1b\xd9\xf7\x17\x91\x67\xec\x2a\x64\x60\x3e\
\x97\xc4\xc0\xec\xee\x6d\xb4\x3a\x47\xa1\x48\x93\x55\x36\x96\x7d\
\x91\x51\xce\x2f\xd7\x29\xc0\x87\x90\x22\x32\xc0\xfa\x5b\x6f\xe3\
\xd0\xd9\xd3\x18\x02\x7a\x16\x5c\x14\x43\x47\x4e\xe1\xc8\xa0\x2d\
\x06\x33\x50\x94\xc1\x4d\xc8\xc8\x73\x90\xc4\x91\x50\x82\xbc\xc4\
\xaf\xa2\xb5\x55\x8b\xe6\xda\x2b\xc8\x40\x74\x2d\xda\x3b\xef\xc2\
\x92\xb7\xa2\xf9\x77\x2b\x32\xb0\x1c\x40\xb2\xe0\x3b\x50\xa4\xc5\
\x5f\x5a\x5d\x93\xac\x8c\xf9\xb8\x24\x93\xc9\xba\xce\x20\xaf\xf4\
\x0a\x92\x35\x7b\x13\x9a\xc3\xce\x88\x33\x0c\xcd\xef\x07\x90\x22\
\x5d\x4b\xd0\x8d\x4e\x29\x64\x87\xf5\x2e\xfd\xe2\x2d\x13\xfa\x96\
\x57\x97\x86\xf7\x1e\x70\xf4\x91\x2f\xc0\x83\xcb\xf6\x1e\x5c\xb4\
\xed\xf0\x4f\x90\xf0\x90\xc6\x65\x48\x50\x1f\x82\xac\x85\xdf\x41\
\x21\xa3\x3e\x7a\x21\xe2\x7c\x8e\x95\xe1\xc2\xca\xca\x91\x02\xbb\
\x08\x29\xbc\x13\x50\xd2\x83\x07\x11\x41\x2d\x20\x65\x38\x8f\x3c\
\x5b\x87\xed\x33\x1f\xd8\x86\x04\x92\xfb\x10\x41\x9f\x68\xcf\xac\
\x45\x16\xf1\x57\x11\x11\x1d\x85\xac\x93\xf3\x90\x02\x92\xb7\x36\
\x0f\x44\xca\xcb\x8a\xe3\x3d\xc6\x01\xdd\x8e\xd9\x48\xa8\x6e\x79\
\x3c\xc8\xf4\xf7\x57\x22\x06\xff\x38\xb9\xec\x7a\xe2\x78\x2d\x12\
\x6a\x9f\xa0\x29\xff\x1c\x99\xcc\x6b\x44\x0c\x44\x82\xf4\xbf\x11\
\x17\xfe\x40\x14\x65\x50\xa8\xfd\x4b\x68\xbe\x0c\x44\x02\xe4\x93\
\x68\x0e\x9f\x87\x98\xf1\x4f\x89\xf9\x35\x11\x0b\xd0\xfc\x1c\x6e\
\x7f\xef\x45\x73\xb3\x3f\xda\xcb\xf7\x20\x12\xae\x87\x58\xdd\x7f\
\x24\xe2\x45\x88\x5e\xb1\x76\x0f\x45\x06\x9f\xaf\xa3\xb5\xb1\x1b\
\x19\x93\x96\x23\x8f\xd7\x56\xe0\x69\xa2\xc2\x3e\x53\x7e\x97\x00\
\xbf\xe0\x6b\x97\x36\x30\xed\xbd\x4b\x88\xd8\x6e\xe1\xd0\x5b\x81\
\xdf\x12\x17\x56\xf1\xd2\x0f\x43\xb2\xac\x80\xe3\x85\x1c\xf2\xca\
\xbe\x4a\x71\x1e\xd2\x19\x54\x20\xe5\xef\x0d\xb4\x76\x0e\x5a\x99\
\x63\x50\x58\xf1\x66\xc4\x33\x46\x23\x5e\xf2\x2a\x5a\x6b\x13\x90\
\x00\xbe\x02\xd1\x85\x57\xac\x9c\xd9\x48\xf0\x7e\x13\xf1\x88\x97\
\x91\xf2\x39\x15\xad\xf7\xdf\xa2\xe8\x8a\x33\x91\xd2\xb0\x1b\x85\
\x6f\xfa\xd1\x21\x2e\x41\xd6\xcb\x88\xbf\xac\x47\xbc\xa6\x17\x32\
\xba\x2e\x22\x51\xa8\xb7\xa4\x9e\xdb\x8b\xa2\x45\x7a\xd9\xf7\xc5\
\xc8\x48\xdb\x88\xb6\x04\x6d\xb1\xfe\x8c\x40\x46\xb9\x57\x90\x12\
\xb0\xc6\xea\xa9\xb3\x72\x6a\x11\x2f\x9c\x80\xf6\x11\x2f\x45\xbc\
\x70\x11\x52\x22\xe6\x23\x1a\xb2\x18\xd1\xa2\xb1\xf6\xec\x4a\x44\
\x6f\xb2\x28\x41\x57\x38\x96\xa6\xe7\xa2\x0a\x79\x53\x1f\xa2\xf9\
\xfc\x3b\x12\xf4\x45\x6b\xc6\xad\x8b\x8d\x68\xbb\x90\x73\x12\xcc\
\x43\xf3\x63\x0b\xda\x4b\x3c\x1c\xcd\xa1\x2d\x28\x69\xdb\x46\x34\
\x2f\x2b\xd1\x5c\x7b\x11\xc9\x81\x95\x48\x49\x76\x5b\xdd\x16\xa2\
\xb9\x3b\xc3\xee\xfb\x11\x52\xd8\x2f\x42\x0a\xed\x7c\xb4\x7e\x97\
\x21\x45\x77\xae\x3d\xb7\x00\x39\x39\xce\x41\x73\xf4\x75\x34\xdf\
\x23\xc4\x77\x4b\x91\xe3\xa4\xd1\x7e\x5b\x45\x48\x7c\x7a\xb2\xa3\
\x1a\x19\x05\x1f\x8f\xa6\x0c\xaf\xda\x73\xf7\x1d\xa3\x6b\x6a\xab\
\x73\xc4\x41\xb4\x09\x38\xca\xa8\x6f\x8a\xf9\xf4\x7d\x6b\x77\xfc\
\x7a\xc1\xee\xeb\x10\x13\x4e\xe3\x5f\x90\x50\xf2\xe3\xe3\xdd\xd6\
\x80\x00\xc3\xdf\x20\x41\xf1\xee\x16\xbf\xf8\xe7\xfb\x36\x36\x42\
\x89\x8b\xc2\x42\x56\x9f\x6c\x26\x09\x4c\x04\x9d\xc3\x1b\xb5\x93\
\xbf\x27\x8a\xec\xfe\x58\x7f\xa3\xf4\x6f\xad\x10\xea\x08\x88\xfd\
\xca\x5a\xfc\xd8\xbc\x9c\x42\x9c\x0a\x74\x2c\x90\x18\xc2\x63\xf8\
\xda\x65\x24\xe7\x13\xbb\xe7\x63\xc8\xc7\xf0\xff\xc2\x59\xc2\x01\
\xc7\x0d\xe5\xc0\x7f\x20\x41\xfb\xd5\xe3\xdd\x98\x80\xb7\x90\x45\
\x4a\xd0\x47\x90\xb1\xee\xe1\xe3\xdd\xa0\x80\x36\x31\x10\x6d\x85\
\xf9\x0c\xc9\x96\xb3\x9e\x84\xb1\x28\x99\xd6\x02\xa4\xf0\x06\x04\
\x74\x27\x06\xa3\x50\xfe\xbf\x0e\x7b\x84\x03\x7a\x1a\x5e\x25\xec\
\x41\x0c\x38\x51\xf0\xb5\x4b\x8f\x77\x0b\x8e\x72\xff\x2e\x3b\xde\
\x2d\x08\x08\x08\x38\x31\x90\x41\x5e\xb5\x37\x28\x7e\xda\x43\x40\
\x40\x67\x70\x01\x8a\xae\xb8\xf7\x78\x37\x24\xe0\xe4\x46\x50\x84\
\x03\x7a\x1a\x7e\x79\xbc\x1b\x10\x10\x10\x10\x10\x10\x10\xd0\x29\
\x34\x22\x0f\x63\x40\x40\x77\xe0\xa7\xc7\xbb\x01\x01\xa7\x06\xc2\
\xc6\xe0\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x53\
\x0a\xc1\x23\x1c\xd0\xd3\x70\x29\xc9\xf1\x14\x31\xc9\x19\x74\x5d\
\x4d\x8a\xd2\x5d\x28\x45\x47\x2d\x3d\x4b\xf1\x64\x0a\xc3\x50\xc2\
\x94\xdf\xe0\x0e\xa7\x69\x1d\x6f\x43\x7b\x4f\x5f\xeb\xa6\xb6\xf5\
\x42\x9b\xff\x1f\x26\x39\x0e\xe3\x58\x61\x00\xca\x5a\xfc\x73\xe8\
\xb6\xac\xc2\x63\x51\x82\xb2\x9f\xa1\x84\x17\x3d\x11\x63\x81\xf7\
\x92\x64\x52\xdd\x49\x92\xbc\xaa\xa7\xe0\x06\x94\xe8\xaa\xd8\x9e\
\xfc\x4a\x94\x95\xf3\x61\x94\x88\x2b\x20\xe0\x54\xc2\x58\xe0\x2e\
\x12\x59\xe8\x58\xae\xdf\x08\x25\xf0\xd9\x81\x78\xdd\x95\x88\x7e\
\xe6\xbb\x52\x68\x0a\xbd\x81\x77\x23\x7e\x7a\x37\xdd\x47\x9b\x7b\
\x3a\x26\xa3\x44\x50\x4f\xa0\xd3\x1d\x02\x8e\x2e\x66\xa1\x13\x36\
\xee\xb3\xff\x33\x28\xf3\xfa\x4b\x28\x39\x55\x57\x50\x83\x92\xd5\
\xbd\x41\xd7\xd7\xc6\xa5\x28\x69\xd7\x2b\x5d\x2c\x27\xe0\x24\x42\
\xf0\x08\x07\xf4\x34\x4c\x43\x19\x75\x9f\x45\xc7\xb9\x8c\x45\xc9\
\x8a\xca\x8e\x77\xc3\x0c\x25\x48\xe1\x1b\xd2\xca\xef\x83\x50\x7a\
\xfe\x8e\xb4\x77\x0e\xca\x28\xda\x5d\xa8\x06\xae\x46\xc9\x64\x8e\
\x35\xfa\x21\x03\x41\xc5\xff\x67\xef\xbc\xc3\xec\x28\xae\xbc\xfd\
\xf6\x9d\xa0\x9c\x73\x42\x39\x22\x81\x10\x88\x0c\x12\x39\x47\x03\
\x06\x47\x9c\xbd\x4e\x60\xef\xae\xe3\xda\xdf\xe6\x5d\x6f\xb0\xbd\
\xbb\xf6\xae\xd3\xae\x6d\x6c\xaf\xd7\xc6\xc6\xe4\x20\x40\x88\x24\
\x04\x28\xa1\x80\x90\x50\xce\x39\xe7\x99\xb9\xfd\xfd\xf1\x3b\x45\
\xf7\xb4\xee\x9d\xb9\x9a\x91\xd0\x68\xe6\xbc\xcf\x73\x9f\xb9\xd3\
\xb7\xbb\xba\xba\xba\xaa\xce\x39\x75\x4e\x55\x1d\xc3\x34\x87\x20\
\x23\xad\x29\x0f\xd8\x0d\x47\xdb\x90\x4c\x47\x75\x36\x02\xfe\x11\
\xad\x9c\xda\x54\xb8\x84\x64\x4b\x8a\x2c\x6d\x50\x7d\xad\x6f\x8f\
\x52\xc7\x69\x8e\x0c\x43\xab\xb4\xbf\x4c\xd2\x7e\xff\x81\x77\xa7\
\xfd\x56\x02\x9f\x05\x06\x21\x5d\xac\xdd\x71\xb8\xc7\xd9\xc0\x85\
\x68\x05\xea\xaa\x77\xe1\x99\x9a\x02\x65\x68\x70\x72\x3f\x5a\x51\
\xd8\x39\xfe\x4c\x44\xdb\x8b\x05\x22\x24\x57\x06\x1c\x83\xb4\xcf\
\x42\xef\xf3\x58\xd0\x8a\xa6\xa3\x4b\x3a\x4d\x84\xa6\xac\x60\x3a\
\x2d\x93\x3c\xf2\x90\x3e\x6a\xff\x2f\x45\xdb\xbe\x8c\x04\x26\x20\
\x63\x6f\x15\x52\x5a\xae\x47\x4a\xc4\x32\xb4\x67\x6a\x3b\xd4\xf9\
\x56\x23\x45\x66\x0a\x5a\xb6\xff\x3a\xb4\x42\x62\x6b\x3b\x6f\x3c\
\xda\x1e\x29\x8f\x46\xff\xe7\xa1\x7d\x85\x73\x96\xde\x66\xe0\xf7\
\x68\xe4\xf0\x42\xb4\x00\xc8\x01\xb4\xcd\xc0\x6a\x34\x2a\x99\xb7\
\xfb\x5d\x0f\x8c\x40\x0b\x7c\x3d\x68\xc7\x6b\x38\x72\x5f\xc8\x89\
\x96\x56\x5b\xb4\xa4\xff\xd3\xa9\x74\x3a\xa1\x7d\x5a\x07\xa0\x2d\
\x6d\x1e\x46\x4a\xcb\x65\x68\xc1\x88\x5d\x68\xa4\x75\x55\x2a\xcd\
\x32\xe4\x79\x3e\x07\x6d\x01\xf5\x10\xda\x02\xa1\xd2\xd2\xea\x81\
\xbc\x1a\x8f\xdb\xb9\x57\x23\x63\x68\xa3\x9d\x3b\xca\x9e\xe9\x75\
\x64\x6c\xc6\x68\x6b\x8f\xf3\xec\xfc\x3d\xc8\xbb\x5c\x66\x79\x9d\
\x9d\x79\xa6\x21\x68\x40\xa0\x2d\xda\x7e\x60\x5b\xea\x79\x06\x21\
\xaf\x7e\x37\xe4\x35\x7f\xc0\xae\xbd\x01\x29\x9e\x2b\xec\x5e\x11\
\xda\x73\x73\x90\x95\xeb\x83\x68\xbb\x85\x40\xcc\xb1\xf5\x8e\x1c\
\x0f\x62\xb4\xd5\xc2\xc3\xf6\xff\x73\xa8\xbe\x8c\xb6\xf7\xd3\xde\
\xca\xe4\x0f\x76\xfc\x0c\x2b\xab\x87\xed\xef\xad\x56\xc6\x03\x51\
\xbd\x7f\xd2\xde\xc1\x70\xa0\xb3\xfd\xdf\xd9\xae\x6d\x85\xf6\x75\
\x9c\x66\xe7\x0c\xb2\x32\x8e\x50\x7d\x5d\x4b\xb2\x1f\x76\x05\xda\
\x72\x65\x46\xea\xbd\x94\xa3\x11\xf1\xb3\xd1\xfb\x7d\x0c\x6d\xdf\
\x92\xad\xaf\x8e\x73\x32\xd3\x19\x6d\xcf\xb2\x1c\x19\x43\xf5\xb1\
\x82\xc4\x93\xf5\x1c\x6a\xb7\xa3\xd0\x1e\xa5\x9d\x90\x3c\xb9\x1f\
\xf5\xb5\xe7\xa0\x76\xfb\x20\x1a\xf4\x1c\x8e\xfa\xb7\x08\x0d\x04\
\xce\xb1\x7b\xde\x62\xd7\xce\x40\x0b\x47\x8d\x47\x7d\x42\x27\xd4\
\x67\x3e\x80\x22\x78\xce\x45\xfd\xf6\xcf\xd0\x56\x67\x79\xb4\x45\
\xdf\x8d\x48\xbe\xbc\x9a\xba\x7e\x94\x5d\xdf\xc6\xee\x9f\xdd\xaa\
\x2f\xdd\xf6\x9f\xb7\xdf\x6f\xb5\x7c\xf6\x22\x89\x3c\xea\x6c\xf9\
\x6b\x45\xb2\x4f\xf9\xe5\x48\x3e\xac\x41\x7d\xd3\x76\x24\xd7\xae\
\x47\x32\xe5\x59\xb4\xc5\xcd\x25\xa8\x2f\x3b\x08\xdc\x66\xf9\x1b\
\x83\xe4\x6d\x07\xb4\xa5\x4d\x1f\xb4\x9d\xce\x2b\xf6\x0e\x6e\x46\
\xf2\x68\x36\x92\x25\xa3\x90\x3c\xac\x40\x03\xa8\x0f\xa3\x6d\x99\
\xfa\xd8\xb9\x5d\xec\xdc\x67\x50\xff\x76\x33\x1a\xa8\x9b\x65\xf9\
\x48\x1b\xf4\xed\x91\x7c\x4f\xcb\xe0\xb1\xa8\x8f\x03\xd7\x71\x1b\
\x43\x2f\x54\xfe\x6f\x53\xff\x20\x4a\xd8\x26\xab\xd2\xfe\x86\x7d\
\xb9\x73\xc0\x5d\x68\x11\xd4\xb7\x81\x53\x90\xec\x5a\x8e\xea\x41\
\x17\x3b\xf7\x8f\x28\x3a\x6e\x10\xd2\x13\x3a\xa2\xc1\x9b\x97\xd1\
\xb6\x4a\xe7\xa3\xba\x37\x1d\xd5\xc9\x91\xa8\xdd\x3e\x8c\xea\xf1\
\x75\x76\xbf\x53\x90\x6e\xf8\x3c\x8a\xce\xbb\xc1\x9e\x61\x2e\xda\
\x3e\x6c\x3f\xd2\x7b\x2a\x90\xd3\x60\x3c\x8a\xc8\x78\x04\x45\x4d\
\xdd\x64\xcf\x30\x10\xd5\xa7\x07\x28\xad\x0f\x71\x4e\x62\xdc\x23\
\xec\x34\x45\xba\xa1\x4e\xec\x14\x64\xc0\x6d\x46\xc2\xff\xf3\xa8\
\x13\x5b\x8e\x96\xfc\x0f\x9e\xb8\x73\x80\xcf\x20\x61\xf9\x79\xa4\
\x94\x2c\x03\xbe\x82\x3a\xcc\x5b\xed\x9c\xd9\x68\x1f\xb9\xcb\x50\
\x67\xb9\xdf\xce\x69\x67\xe7\x5c\x8c\x3a\xec\x4b\x90\x22\x72\xae\
\xa5\xb7\x10\x29\x2b\x7f\x89\x14\xac\xbc\xdd\xe3\x63\x48\x69\x7a\
\x05\x09\xe2\x2f\xa1\x0e\x36\x6b\x54\xf4\x46\x23\x9a\x4b\x50\x87\
\xfc\x19\xcb\x57\x30\x9a\x6f\x47\x1d\xf2\x8b\x48\x48\x9c\x61\xcf\
\xfd\x61\xcb\x73\x05\xf0\xff\x90\x02\x13\x18\x02\x7c\x0a\xed\x79\
\x57\x83\x36\x99\xcf\x21\x63\xba\xbb\x5d\xf7\x51\x4b\xeb\x4e\x7b\
\x9e\x19\x96\x97\xaf\xd9\xdf\xeb\xec\xd9\x3f\x01\x7c\xc4\xbe\xdf\
\x84\x14\x92\x2f\xa0\x2d\x15\x56\xa1\xd0\xc1\xf6\xa9\x7b\x77\x07\
\xfe\xc2\xde\xc5\x42\x24\xe8\x42\xb9\xb4\xb2\x67\xad\x41\xc2\xe8\
\x4a\x64\x14\x5f\x8d\x8c\xb0\x17\xec\x59\xcf\xb7\xe3\x17\xd8\x73\
\x8f\x47\x03\x05\x27\x23\xed\x51\x5d\xed\x87\xea\x56\x1b\xa4\x60\
\x7e\xdc\x8e\xbd\x61\xe5\x7f\x27\x1a\x78\xe8\x00\x7c\xd3\xca\xf1\
\x23\x48\x99\x9e\x8d\xde\xf7\x25\xa8\xae\xbe\xd7\xae\xeb\x00\xbc\
\x0f\xed\x4b\xba\x08\xf8\x33\xf4\x8e\xcf\xb5\xe3\x6f\x22\x85\xe5\
\xb3\x48\x78\x7f\x0b\x29\xb1\xe1\xdc\xb3\x48\xea\xd9\xa5\x96\xa7\
\xb9\x96\xef\xbf\x44\x0a\xaa\x1b\xc1\x4e\x73\xa1\x1c\xb5\x81\x67\
\x81\x3f\x21\xb3\x41\x58\x01\x62\xd4\x7e\x07\xa0\xb6\x7a\x39\xea\
\x6f\x77\xa1\xfe\x33\xb4\xdf\x2b\x50\x3f\x37\xc3\xee\xf1\x65\xd4\
\xd7\xdd\x89\xda\x71\x3f\x24\x43\xda\x00\xdf\xb0\x74\x5f\x03\x3e\
\x80\xe4\xca\x58\x4b\x6f\x19\x52\xfc\xbf\x84\x06\xa3\x36\xa2\x3e\
\xb4\x15\x52\xf0\x7b\xa1\x76\x59\x8d\x8c\xea\x4f\xa1\x3e\x61\x2c\
\xea\x2b\x96\x59\xfe\xbe\x48\x6d\xcf\xd6\x40\xbb\x6e\x1b\x6a\xfb\
\x7f\x8a\x0c\xd4\xb7\x90\xc1\x90\x36\x9a\x3b\x58\xd9\xb4\x41\xfd\
\xc7\x9d\xf6\x7c\x2f\x22\x83\xf6\x0b\xa8\x3f\xfb\x06\xea\x4b\x96\
\xd8\x73\x8c\xb5\x3c\x86\xfb\x5e\x8d\xe4\xc8\x55\xf6\x7d\x8e\x5d\
\xff\x69\x24\xa3\x77\x02\x5f\xb5\xf2\x9d\x8e\x0c\xda\xab\x81\xa1\
\x76\xce\x3a\x24\x83\xbf\x8c\xfa\xa1\xaf\x58\xde\x66\xa1\xfe\xf2\
\x4c\xfb\xad\x2d\x92\xb1\xb7\x22\x99\x11\xc8\x21\xd9\x95\x96\xc1\
\x7f\x66\x65\xba\x06\x0d\x70\xef\x3a\xd6\x15\xac\x85\xd0\x19\xf8\
\x2f\x34\x18\x71\x7d\x09\xe7\xe7\x51\x1d\xfa\x89\x7d\x7e\x84\xf4\
\xb3\x43\xa8\x6e\xde\x6c\xe7\x5d\x83\x06\x7a\x46\xa0\xba\xbd\x12\
\xb5\x87\xaf\x93\xd4\x61\x50\x1d\xf8\x18\x92\xa7\x2b\x50\x5d\x59\
\x61\xc7\xce\x45\x7a\x44\x48\xa3\x3b\x92\x7f\x95\xa8\xbe\xff\xa9\
\xdd\xe3\xa3\xf6\xdb\xab\xc8\x20\x1e\x8c\xea\xd4\x18\xcb\xcf\x1d\
\xa8\x8d\x76\x44\xfa\x55\x17\x24\x77\xcf\x42\x72\xfa\x06\x54\x5f\
\x9d\x66\x8e\x8f\x96\x39\x4d\x91\x1b\x91\xa1\x08\x12\x64\xdf\x41\
\x1d\xea\x5a\x34\x1a\x1d\xf6\x2b\xfc\x06\xea\xf8\x36\xa2\x0e\xf4\
\x55\xe4\x05\xfd\xb5\x9d\x3f\x11\x75\x9a\x07\xd1\x68\xe0\x2b\xa8\
\xb3\xdb\x81\x46\xd6\x3b\x20\xc5\xa3\x03\xf2\xfe\xfe\x1e\x79\x04\
\x86\xa3\x91\xc9\xe1\x48\x80\x3f\x8c\x84\xee\x39\xa8\x93\xac\x41\
\xc2\xfd\x7c\xcb\xdb\x6b\x48\x59\xf8\x0f\xfb\x9e\x35\x2c\xb6\x01\
\xff\x8d\x46\xbf\xfb\xdb\xbd\x7b\x92\x8c\xa2\x6e\x47\x9e\xd2\x73\
\xed\xfe\x6f\x23\x43\xf3\x11\xe4\xb1\x7e\x0e\xed\xa3\x37\xc6\xf2\
\x03\x32\x42\x73\x48\x09\x99\x8d\xbc\x84\x20\x81\xf1\x4b\xa4\x08\
\x5c\x83\x84\xc5\x05\x68\x9e\xed\xd3\x48\x59\xf9\xb1\xa5\xdd\x19\
\x19\xa0\x3b\x51\x5f\x70\xa6\x1d\x9b\x85\x94\xaf\x4b\xad\xcc\xee\
\xa7\xf6\xdc\xb2\x31\xc8\xbb\xfe\x3f\x48\x61\x7b\x01\x29\x82\x11\
\x1a\x39\xfe\x8d\x3d\x67\x2f\xa4\xc4\x0c\xb2\x34\xfb\x21\x63\x77\
\x3a\x32\xec\x4e\x47\x0a\xd7\x24\x34\xf2\xfb\xc6\x71\xaf\x59\xc7\
\x9e\x3c\xaa\x67\xdf\x46\xef\xfd\x20\xf0\x9f\x48\x68\xef\x44\x75\
\x67\x36\xf0\x49\x34\xba\xfc\x94\x3d\xff\x2f\xec\xdd\xac\x47\x73\
\xf7\x96\x5a\x79\x4d\x42\xf5\xf3\x65\xa4\xcc\xb7\xb2\x32\xed\x86\
\xea\x6e\x17\xa4\x34\x56\x23\x6f\xf1\xd3\x68\x90\xe6\xb3\xe8\x3d\
\xef\x46\xde\x25\x90\xc2\x19\xf6\x3f\xca\x21\x45\x65\x0a\x8a\x12\
\x68\x85\xea\x73\x88\x8c\x70\x9c\xe6\x40\x84\xfa\x9c\xf0\xa9\x8f\
\x3c\xea\xd3\xff\x89\xa4\xfd\xfe\x00\xb5\xdf\x7d\x28\x7a\x26\x0c\
\x52\xb5\x43\x5e\xdd\x8e\xc8\xe3\xf8\x13\xd4\xcf\x9e\x85\x64\xc8\
\x12\xa4\x8c\x9f\x8d\x22\x5c\x46\xd9\xf1\xf3\x91\xec\x7a\x8e\x24\
\xaa\xe8\x9b\x96\xfe\x06\x64\x8c\xee\x47\xed\x7c\xac\xa5\xf1\x13\
\xb4\x2e\x42\x4f\xd4\x0f\xbf\x0d\x4c\xb5\xeb\xd7\x20\xf9\xd0\x86\
\x64\x1d\x8a\xb3\x90\x9c\xf9\xb9\xfd\x3f\xc2\xf2\xb1\xd0\xf2\x9d\
\x36\x84\x23\x3b\xf7\xf7\xa8\xff\xf9\x26\xea\xab\xc6\x5a\x99\x4d\
\x40\x86\xec\x21\xd4\x4f\xc5\x96\xf7\x21\xd4\xee\x2b\x42\x24\xc9\
\x61\xd4\x57\xbd\x88\x0c\x8f\x85\x56\x6e\x23\xec\xd9\x1f\x05\x4e\
\xb5\xb4\x83\xd1\x3a\x1d\x79\xa2\x07\xda\x39\x63\xd0\x60\xc4\x5f\
\x23\x79\x38\xc3\xee\x77\x81\x5d\x3f\x26\x75\xfd\xc3\x76\xdf\xb6\
\x68\xe0\xf8\x5f\x48\x64\xf0\x0f\x50\xdf\xb8\x1a\xc9\x13\x37\x84\
\x1b\x46\x08\xd5\x6f\x4b\x69\xa1\xc4\x11\x7a\x07\xdf\x4e\x5d\xff\
\xf7\x76\xfc\x09\xe0\xcf\x91\x4e\x30\x01\x19\xd8\xa3\x90\x2c\x7c\
\x18\xe9\x43\xff\x89\x06\xe6\xcb\x81\x9f\x22\x7d\xa3\x3b\x7a\xdf\
\x53\x51\xfb\xd9\x82\x64\xd8\x2a\xa4\xff\xb5\xb1\xf4\xa6\xa1\xf6\
\xf1\x7f\xa8\x4d\xbd\x07\x0d\xe6\x6f\x43\x86\xf4\x1e\x54\x1f\x37\
\xa0\x7a\x53\x81\xea\xdc\x03\x48\x1e\xbe\x8a\x0c\xf7\x91\xa8\xee\
\xfd\x1f\x32\x84\xcf\x42\x32\xd4\x69\xe6\xb8\x21\xec\x34\x45\x7e\
\x87\x3a\x46\x90\x62\x52\x85\x3c\xb9\x7b\x91\xf0\x0d\x1d\x73\x4d\
\xe6\x6f\x0e\x09\xc1\xf4\xf1\x32\x24\xa8\x43\x78\xcb\x15\x28\x2c\
\x6c\x3a\x32\x1a\xaa\x51\x67\x5d\x4d\xb2\xc0\x54\x10\xf6\x65\x76\
\x1c\x92\x30\xdd\x32\xfb\x1e\xd9\x27\xdc\xab\x3a\x95\x87\x2c\x61\
\xa4\xfa\x4d\xd4\x89\xef\x4b\x9d\x57\x8e\x94\x9b\xad\xc8\x7b\xfb\
\x51\x24\x30\x72\xa9\x34\xf3\x24\x61\x46\x81\x2d\xc0\x5f\x21\x63\
\xf2\x22\xe4\xc9\xf8\x07\x2b\xa3\xf4\xc2\x52\xb9\xd4\xf3\x85\x32\
\x89\x91\x97\x7d\x1d\x1a\x65\x9f\x8f\x0c\xdb\xdb\x91\x92\xb5\x1a\
\x19\xf8\xe3\x90\xb1\x74\x13\x1a\x65\x5d\x9c\x2a\x97\x38\x55\x4e\
\x83\x49\x42\x80\x3b\x21\x8f\xc2\x21\x92\x11\xf9\x72\x24\x6c\xfe\
\x0e\x09\xae\xf7\xa3\x41\x86\x1f\x5a\x99\x9f\x81\x3c\x0e\xc3\xd0\
\x06\xe7\x27\x93\x61\x96\x43\x75\xe9\xab\x56\xc6\x87\xed\xd9\x3b\
\xdb\xdf\x43\x56\xfe\xe9\xf7\x19\xde\x41\xa8\x5f\x21\xec\xac\x3a\
\x55\xb6\xa1\x2e\x8e\x43\x75\xe7\x0d\xa4\x0c\x1c\x48\xa5\x95\x5e\
\x10\x2d\xa4\x97\x0e\x25\xaf\x26\x99\x2f\x1e\x51\xbb\x3e\x87\x3a\
\x15\xee\xe7\x38\xcd\x81\x2a\xe4\xdd\xf9\x25\x1a\x14\xad\xaf\x6e\
\xe7\x90\x61\xf6\x65\xd4\x76\x42\xfb\xed\x82\xda\xda\xa1\xd4\x79\
\x2b\xd0\xc0\x6b\x0e\x19\x7b\x6b\x51\xd4\xcb\x55\x48\xb9\xfe\x9d\
\xdd\x6f\x1f\xea\xeb\x0f\xa0\xfe\x74\x25\x1a\x70\x0c\x46\x59\x44\
\x22\x43\x42\xff\x1c\x08\x21\xa5\xa1\x0f\x4c\xf7\x09\xbb\x33\xd7\
\x93\xb9\x2e\xdb\xf6\x5b\x59\xfa\x85\x64\x52\x95\x3d\x5b\x99\xa5\
\xf7\xb6\x3d\xdb\x52\x14\x2d\xd5\x8e\x64\xc1\x4a\x50\x1f\xdf\xd1\
\xce\x0d\xfd\x46\x58\x0f\xa2\x06\xc9\x9d\x40\xe8\x97\xca\x91\xdc\
\x5d\x64\xcf\xbe\x1a\x19\x23\xa7\xa4\xce\x49\xa7\x47\xea\xb9\xfb\
\xa3\x81\xd3\xbd\x99\xeb\x37\xa6\xf2\x14\xca\x2f\x2b\x83\xcb\x52\
\xbf\x39\x0d\x63\x3b\xf2\xda\xa7\x43\xea\xeb\x22\x0c\xae\xbc\x95\
\xfa\x7f\x2f\x7a\x07\x8b\x50\xdd\x7d\x3f\xaa\x77\x8b\xd0\xc0\x46\
\x68\x5b\xa1\xbe\x97\x93\x4c\xe3\x01\xbd\xcf\x1c\x49\xdd\x08\xef\
\x7a\x89\xdd\x67\x19\xf2\x58\x1f\x42\xf5\x23\xad\x9f\xe5\xd0\x40\
\xcf\x12\xa4\x5f\xdc\x63\xc7\x42\x34\x5f\x56\xbf\x0a\xd7\x1c\x20\
\xd1\x15\x43\x1b\x75\x9a\x39\xde\x51\x38\x4d\x8d\x1c\xea\x2c\xf7\
\xd8\x27\x18\x09\x11\xea\x28\x73\xa8\xc3\x7d\x1b\x85\xec\x9e\x85\
\x46\xeb\x17\x21\xe3\xee\x54\x14\xf6\x72\x1d\x1a\x6d\x7e\x15\x29\
\x29\xa1\xae\x9f\x8a\x84\xe9\x0b\x68\xb4\x3e\x08\xf7\x20\x3c\xb1\
\xef\x39\x34\xd2\x78\x11\x1a\x95\xbc\x1d\x8d\xce\xcf\x41\x0a\xc6\
\x5e\xe4\x29\x78\x3f\xf2\x08\x7e\x0c\x75\xcc\x1b\x2d\x9f\xe9\x0e\
\xb4\x3f\x32\x14\x9f\x44\x9d\x6c\x6f\x92\x0e\x3e\x2c\x2a\x31\x11\
\x8d\xba\x2f\xb6\x7c\xbd\x88\x42\x73\xce\xb7\xe7\xac\x21\x11\x32\
\xa0\x91\xca\x10\x6a\xf7\x34\x32\x78\x2a\x0a\x3c\xc7\x41\x14\xee\
\x7d\x07\xf2\x10\x7c\x18\x79\x1c\x97\x22\x65\xee\x5a\x64\xb0\xce\
\xb5\xfb\xbd\x6a\x65\xf2\x69\xcb\xeb\x13\x76\xef\xf4\x02\x5c\x8b\
\xec\xef\xed\xc8\x00\xff\x22\x32\xfc\x72\x76\xed\x48\x2b\xbb\xe5\
\x28\x54\xae\xcc\xce\x9b\x6c\xe5\x3e\x1f\x19\xcc\x57\x23\x8f\xe5\
\x0b\xc8\xd0\xeb\x94\xa9\x0b\xe1\xbd\x34\x65\x82\x70\xdd\x8d\xea\
\x6b\x10\xee\xa1\xbe\x06\xa5\xf5\x65\x34\x00\x73\x2e\x70\x37\xaa\
\x3f\x4b\x90\xb2\x77\x07\xf2\x94\x5f\x85\x14\xeb\xf4\x73\x0f\x42\
\xf5\xed\x29\x7b\x0f\x61\x4e\x70\x5a\xc1\x8d\xd0\xbb\x9f\x8d\xbc\
\xc5\xb7\x5a\x59\x4f\x46\x4a\x6d\x50\x0e\xa6\xd9\x3d\x2e\x40\x61\
\xd5\xad\x51\x1d\xa8\xc4\x05\xbe\xd3\x7c\xd8\x84\xda\x5b\x29\xde\
\xc0\x52\xda\x2f\xc8\x58\xee\x63\x69\x76\x41\x72\x01\x34\x08\x16\
\xe6\xc8\xce\x41\xc6\xda\x5a\xd4\x0e\xb7\x23\xd9\xd1\xd3\xce\x2d\
\x4b\xa5\x1d\xda\x64\x0d\x1a\x00\x0c\xfd\xf7\x42\x92\x79\x95\xe7\
\xa3\x3e\xf9\x65\x92\x81\xae\x42\x79\x03\xb5\xfd\xbe\xa8\x8f\x99\
\x8c\xfa\x93\xb0\x5a\x72\x56\xcf\x4b\xcb\xbb\x2a\x3b\x6f\x20\x92\
\xab\x03\x91\x9c\x98\x47\x32\x97\xf8\x1a\xd4\xc7\x1f\x44\x72\xec\
\x72\x24\x37\xc2\xf4\x9e\xb2\xd4\x3d\xd2\x86\x4b\x08\x67\xed\x8d\
\x06\x7a\xcf\x43\xfd\x5d\xf6\x59\x2a\x48\x3c\x7e\x77\x5a\xde\xbf\
\x62\x65\xb3\x3c\x73\x7d\x7a\xf1\xa5\x7d\x94\x2e\x83\x9d\xa3\x67\
\x05\xf2\xcc\x1f\x2c\xe1\xdc\x1c\xb5\x1d\x6b\xe1\xff\x1c\x1a\x5c\
\x7a\x11\x0d\x76\xcf\x20\x19\x1c\xbe\x0a\x4d\x1b\x78\x1f\x32\x40\
\x1f\x47\xb2\xe8\x2e\xf4\xae\x43\xdd\xdf\x83\xda\x53\x27\xa4\xcb\
\x0c\x44\xf5\x61\x18\x8a\x62\x08\xf5\x29\xad\xf7\x94\x23\x5d\xe7\
\x14\x24\x3b\xd7\x23\xbd\xaa\x8c\xa4\xce\xdf\x82\x06\xfa\x3f\x80\
\x8c\xe2\xa5\xa8\x2e\x46\xa9\x67\x70\x1b\xa9\x05\x50\xd6\xaf\x63\
\xe5\x57\x6f\x39\xb5\x4b\xeb\xf6\x95\xfe\xbe\x9d\xe3\x4f\x4d\x1e\
\x9e\x58\xb2\x6b\xff\x9b\x9b\x0f\xfe\x9a\xc2\x5b\x22\x75\x44\x8a\
\x4c\x76\xc9\xfd\x4a\x12\x65\xff\x30\x32\x9c\x06\xa3\x0e\x73\x15\
\x0a\x3d\x0e\xe1\xca\x61\xa1\x8f\x5f\x21\xe5\xa4\x0b\x32\x3a\x36\
\x23\x45\x65\x04\x32\x88\x97\xa1\xce\x7e\xbe\xa5\xbf\x08\x85\x88\
\xb5\x47\x0a\x4f\x08\x3b\xbd\x04\x29\x05\xff\x8d\x8c\xd1\x2e\x48\
\x51\x78\x19\x8d\x98\x5e\x80\x94\x88\x1f\x23\xe3\x31\xe4\x33\x8c\
\x38\x6e\x22\x09\xe3\xda\x8f\x3c\x15\x4b\x51\xe7\xbf\xcc\xce\x3d\
\x1d\x75\xca\x6b\x2c\xdf\x6f\xa0\x0e\x79\x92\xa5\xf7\x23\xcb\x7b\
\x60\xb7\xa5\x79\x09\x32\x8e\x7e\x6e\x69\xb5\xb3\xf4\x0f\xa1\x50\
\xec\xa5\x28\x6c\xad\x83\xa5\x75\x10\x79\x62\xb7\x5a\x1a\xad\x91\
\x00\xda\x8c\x04\xca\xa3\x56\x7e\xd5\x96\xf6\x50\x14\x8e\xfe\x2a\
\xc9\x48\x6d\x30\xe2\x2e\x42\xc2\xe8\xb7\x76\xcf\x76\x28\x8c\x69\
\x33\xc9\x42\x33\xaf\x23\x25\xe7\x05\xa4\x38\x9d\x6f\x65\xf5\x33\
\xcb\xdb\x28\x2b\x97\x10\xd6\x97\x5e\x2c\xab\x8d\xdd\xf3\x75\x4e\
\xec\xa2\x59\x93\xac\x5e\x14\x0a\xdd\x6e\x83\xea\xe3\x3c\x8e\x5c\
\x20\xad\xa3\x5d\xb3\x87\x24\x6c\xf2\x62\xfb\xfd\x87\x56\xce\x97\
\xda\xdf\x31\x24\xa1\x8f\xed\x49\xda\xc0\x7a\x4b\xe7\x5c\x54\x27\
\x17\x58\x5a\x07\x48\xea\x73\xf0\xfc\x3c\x63\x65\x1a\xde\xcb\x1f\
\x91\xf1\xdb\x19\xb5\x91\xe7\xad\x1c\x27\x5b\xbe\x7f\x8c\xea\x7f\
\xe7\x54\x3e\x1d\xa7\xa9\x53\x8e\x0c\xb1\x99\x34\x7e\x5b\xbd\x36\
\x48\x31\x2e\xa5\xfd\xe6\x50\x9f\xd8\x09\x85\x55\xae\x46\xc6\x58\
\x84\xe4\x4c\x58\x28\x6b\x01\x32\xcc\xce\x40\x9e\xe1\x29\xa8\xed\
\xef\x40\x86\x5d\x85\xfd\xff\x1a\xea\xef\x4e\x43\xed\x36\x18\x0c\
\x8b\x50\x9f\x78\x2a\xc9\x54\x86\x36\x05\xae\x9f\x4d\x32\x50\x1c\
\x7e\xbb\x18\xb5\xfd\x07\x51\x7b\x6f\x6b\x79\x5a\x92\x29\xbf\xf6\
\xa8\x5f\x3d\x64\xf9\xed\x6c\xd7\x96\x91\x78\xd2\x96\xa1\xbe\x6f\
\x10\xf0\xbf\x48\x06\x6c\xb6\x63\x79\x2b\xff\x05\xf6\xfc\xab\x50\
\x3f\xdf\x16\xc9\x98\x05\xf6\x77\x1e\xf2\x86\x4f\xb4\xfc\x3d\x66\
\xf7\x08\x9e\xe2\x72\x24\x37\xa6\xdb\xf3\x9c\x85\xa2\x60\x9e\x40\
\x06\x4c\xfa\xfa\x65\x56\x16\xc1\x30\x8b\xed\x3e\x59\x19\xbc\xcb\
\xde\xd1\xdb\xa8\xdf\x76\x0a\xd3\x0e\x39\x0c\x9e\xa4\xb6\x47\xbf\
\x21\x74\x44\x72\x2c\x6c\x3b\x16\x21\xfd\x63\x21\xd2\x35\x0e\xa3\
\x77\xf4\x9f\xe8\xfd\x8c\x45\x7a\x54\x47\x54\xb7\x7f\x88\xde\xef\
\x9b\x48\x0f\x1a\x87\xf4\x96\xa0\x8f\xf4\x47\xf5\xfe\x7e\xf4\xbe\
\x2f\x42\x75\xff\x7e\xd4\x3e\x2b\x49\xb6\x57\xea\x86\xda\xed\x62\
\x24\x37\x27\xa0\xba\xf5\x47\xa4\xef\x6c\x24\x99\x76\x34\x19\xd5\
\xa3\xff\x42\x7d\x49\x67\x54\x2f\xf7\x90\xe8\xa2\x6f\x9f\xe8\x17\
\xe5\x1c\x17\xda\xa3\x35\x6c\xa6\x46\x13\xfb\xb7\xdb\x79\xdf\x1d\
\x43\x3a\xf5\x6a\x5f\x4e\xec\x01\x72\xce\x71\xe6\x50\x75\xcc\x17\
\x1e\x59\xb5\xf5\xf7\x0b\x76\x5c\xcb\xb1\xdf\xcb\x2d\x84\x91\x7e\
\x84\x93\x2b\xbc\xd6\x69\xda\x7c\x0b\x85\x37\xde\x77\x8c\xd3\xed\
\x8a\xe6\xb7\x7d\x0b\x29\x91\x8e\xe3\xd4\x4f\x6b\xe0\xfb\x48\x79\
\x9e\x79\xa2\x33\xe3\x38\x27\x29\x3d\xd0\x9c\xea\x7b\x50\xc8\xfa\
\xf1\xa2\x3f\x8a\x7a\x6a\x87\xe6\x0d\xd7\x20\x2f\x6c\x0f\xe0\xbb\
\x27\xba\x10\x9c\x16\x4b\x6f\x34\x15\xef\x2f\x7c\x8e\xb0\xd3\x9c\
\xd8\x81\x3c\x8f\x8e\x73\x32\x70\x08\x79\x80\x0e\x34\x36\x21\xc7\
\x71\x1c\xc7\x69\x82\x0c\x43\xde\xdf\x9f\x90\x44\x76\x2d\x45\xd1\
\x05\x8e\x73\xc2\x71\x43\xd8\x69\x4e\xac\x45\xe1\xcb\x8e\x73\x32\
\xb0\x8f\x64\x85\x67\xc7\x71\x1c\xc7\x69\x6e\x4c\x23\xd9\xd5\x22\
\x30\xe3\x44\x67\xca\x71\x02\x3e\x31\xd8\x71\x1c\xc7\x71\x1c\xc7\
\x71\x1c\xc7\x69\x51\xb8\x21\xec\x9c\x0c\x44\x68\xa5\xca\xbf\x40\
\x2b\x5a\x7e\x1a\xf8\x38\xa5\xed\x13\x09\x5a\x64\xe1\x4c\xb4\x60\
\x94\xe3\x1c\x4b\x46\xa3\x39\x56\x1d\x53\xc7\xae\x43\x0b\x7e\x94\
\xc2\x44\x92\xbd\x7e\xb3\x94\xa1\x15\xc3\x07\x17\xf9\xbd\x37\x9a\
\x6b\x55\x6a\x3b\x70\x1c\xa7\x36\x9d\x91\x6c\x38\x1a\x5d\xa8\x37\
\x5a\x71\xb6\xf2\x38\xe4\x67\x22\xc9\x8a\xd4\x75\x11\xa1\xc5\xb8\
\x7a\xa0\xc5\x83\x6e\x41\x72\xee\x68\x18\x86\x76\x58\x70\x3d\xd0\
\x69\x2c\x17\xa1\xf9\x96\xdf\x4e\x7d\x26\x15\x39\x37\x87\x16\x07\
\xed\x86\x56\x54\x7f\x2f\xc7\xa7\x2d\x39\x4e\x49\x78\x07\xe8\x9c\
\x0c\x74\x44\x0b\x60\xbd\x85\x96\xce\x9f\x4c\xb2\xe2\x65\x29\xf4\
\x42\x7b\xdb\xb6\x3b\xd1\x0f\xe2\x34\x3b\x06\x03\x7f\x09\x7c\x88\
\x64\xdb\x85\x49\x68\x25\xd8\x52\x38\x95\xe2\x46\x73\x0e\x6d\x21\
\xd1\xaf\xc8\xef\xdd\xed\xf7\xd6\x38\x8e\xd3\x10\xce\x42\x83\x4d\
\x47\x43\x37\xe0\x32\x8e\x8f\xfe\x34\x0e\x19\xb8\xf5\x51\x81\x06\
\xe0\x06\x58\x7e\x2e\x6d\x40\x7e\xca\xd0\xca\xb9\x8e\xd3\x58\x26\
\xa2\xdd\x38\x9e\x4f\x7d\xd6\x14\x39\xb7\x1d\xd2\xc7\x7a\xa1\x3a\
\xdb\x1a\xdf\xea\xca\x39\x81\xf8\x1c\x61\xa7\xa9\xd1\x1e\x29\xf7\
\xc3\xd1\x82\x0a\x8f\xa1\x7d\x0c\x47\x20\x05\x61\x20\xea\x40\x7b\
\xa1\xed\x2b\x6e\x46\xca\xc0\x02\xb4\xe5\xc2\x01\xb4\xdd\xc2\x55\
\x68\xe5\xe8\x27\xd1\x16\x3d\x67\xa2\xfd\x55\x7f\x8a\x96\xf2\x77\
\x9c\x63\x41\x8c\xb6\x6d\xb8\x09\xcd\x7b\x9a\x89\xea\x5d\x1e\x29\
\x99\x57\x20\xe5\x16\xb4\x15\xca\x2c\x34\x0a\x7e\x3b\xda\x36\xa2\
\x1f\xda\x6f\x33\x42\x5b\x4b\x4d\x42\x03\x3c\x4f\xa2\xed\x1f\x6a\
\xec\x1e\x6d\x50\xbb\x18\x89\x56\xf8\x7c\xd0\x7e\x3b\x91\xdb\x4a\
\x39\xce\xc9\x4c\x05\x8a\x34\x3a\x1f\x19\xb6\x73\x50\x1b\xeb\x8f\
\xb6\xdd\x79\x00\xb5\xcd\xd3\xd0\x9e\xe7\x11\xda\xd2\xe7\x30\x8a\
\x2e\xfa\x00\xf2\x0e\x4f\xb7\x6b\x6f\x41\xed\x72\x3b\x32\x0c\xba\
\xda\xf1\xeb\x2c\xcd\x1d\x68\x6b\xa2\xd0\x2f\xb4\x45\xdb\x97\xb5\
\x25\xd9\xcf\xbe\x35\xda\xae\xe8\xb3\xc8\x60\x78\xc0\xce\x1f\x8b\
\xb6\x8a\x89\xed\x3e\x6d\x90\x9c\xbb\x03\xc9\xc8\x0e\xc8\xa0\xef\
\x8d\xb6\xf5\x7b\x1e\x6d\xc1\xd4\xd7\xd2\xdb\x8d\xfa\x9e\x8b\x2c\
\x8d\xfb\xec\x39\xf6\x59\x59\x4c\x44\xdb\x27\xb5\x43\x5b\xcd\x3c\
\x65\x69\xdd\x84\x16\x3a\x9a\x85\xb6\x13\x0c\xdb\x35\x39\xcd\x9f\
\xde\x68\x90\x65\x09\xf5\xbf\xf7\x18\x39\x2a\x1e\xcf\x1c\xef\x8c\
\xb6\x3a\x1b\x82\xb6\xcc\x7a\x10\xc9\xbc\x89\xc0\x6d\x68\x5b\xae\
\x3d\x48\x5e\x8e\x45\x6d\x65\xa7\xdd\xef\x15\xbb\x7f\x39\x9a\x63\
\x1c\xb6\x4d\x7a\xd0\xbe\xdf\x6c\xe9\xbf\x6a\xbf\x57\xe3\x38\x0d\
\xc0\x3d\xc2\x4e\x53\x22\x07\x7c\x12\x09\xf8\x69\xc8\x5b\xf6\x31\
\xb4\xbf\xdc\x5a\xa4\x70\xcc\x47\x7b\x16\xae\x00\xbe\x88\x8c\xe0\
\x69\x48\x88\xbf\x17\x85\x7b\x7d\x05\xed\x59\xb8\x1e\x29\x2b\x7b\
\xd0\x7e\x70\x0b\x71\xc3\xc1\x39\xb6\xe4\xd0\x9e\x85\x0f\xa2\x51\
\xee\xf6\x48\x29\xc8\xa3\x7a\x7c\x05\xf0\x12\x12\xee\x5f\x45\xca\
\xf1\x9f\x22\x01\x3f\x0f\xed\x1f\x0c\x1a\xa8\xf9\x22\xaa\xa3\x5b\
\x90\x97\x79\x90\xa5\x13\x03\x1f\x46\xca\xfa\x74\x34\x18\xf4\x65\
\xdc\x13\xec\x38\x8d\xa1\x06\xc9\x91\x75\x68\xd0\xf5\x36\xa4\xfc\
\x3f\x8b\xe4\xc8\x87\x50\xc4\xc7\xd7\xd0\xa0\xeb\x2a\x3b\xd6\x09\
\x0d\xd4\xe6\xd0\x9e\xa3\xf7\x00\x7d\x90\x41\x7d\xbe\x1d\x7f\x2f\
\xea\x0b\x6e\x42\x03\x5f\xcf\xa2\x41\xac\x8f\xd8\xb9\x9f\x43\x32\
\x69\x15\x70\x17\xea\x07\xc2\xbe\xc0\xa7\x5b\xbe\x22\xe0\xde\x54\
\x7a\xbd\xed\xf3\x1e\xe4\x6d\xdb\x8c\xe4\xe1\x5e\x34\xd8\x0b\x32\
\x46\xee\x45\x86\xf7\x79\xc0\x9d\xa8\x7f\xba\x00\xf5\x19\x0b\x91\
\x5c\xbd\x1d\x19\x24\x93\x2d\x3f\x1f\x44\x06\xcf\x4c\x64\x84\x8f\
\x06\xfe\x04\x19\xd8\x33\x80\xeb\x29\x3e\x45\xc3\x69\x7e\x74\x46\
\x7b\xeb\x3e\x83\xde\x7d\x7d\xc4\x48\xde\x7d\xcc\x3e\x37\xa3\x81\
\xa6\xab\x50\xdd\x9e\x6a\x69\x7e\x16\xc9\xb7\x4d\xc8\x79\xd1\x16\
\xed\xe5\x3a\x08\xb5\xb3\xf5\x68\x9f\xe1\x2f\xa1\xfa\x36\x01\x4d\
\x87\x03\xc9\xcc\x2b\x51\x24\xd4\x37\xec\x9e\xaf\xa0\xf6\x73\xd9\
\x89\x2e\x30\xe7\xe4\xc5\x3d\xc2\x4e\x53\xa2\x03\x32\x1c\xde\x42\
\xca\x40\x1b\x64\xe0\xfe\x1e\x75\x90\xaf\x22\xa5\xa0\x2d\x1a\x75\
\xbf\x14\x8d\x7c\x87\x73\x2f\x40\xe1\x5e\xeb\xd1\xe8\x39\x68\x84\
\xb2\x0b\x52\x1a\xde\xc2\x0d\x61\xe7\xd8\x13\x01\xbf\xa2\x76\x98\
\x65\x84\x94\xe4\xdf\xa0\xfa\xd7\x01\x8d\x62\x0f\x41\xd1\x0d\x9f\
\x47\x83\x3b\x43\x90\xc2\x3c\x09\x29\xa1\x0f\xd9\xf5\x13\x51\xc8\
\x74\x1e\xd5\xf7\x49\x68\xcf\xc7\x97\x2c\xdd\x1f\x20\x6f\x8f\xef\
\x97\xed\x38\x0d\x23\x8f\x0c\xdc\x75\x68\x9f\xf0\xc7\x51\x7b\xec\
\x89\xe4\xc9\x00\xd4\x06\x37\x00\xff\x67\xd7\x3c\x65\xc7\x97\xa0\
\xb6\x7d\x10\x19\xd0\xed\xec\xb7\x49\xa8\x7d\xf6\x40\x6d\xb5\x12\
\x29\xf4\xbd\xd0\xc0\xd5\x40\x64\x20\x2c\x01\x1e\x41\x5e\xac\xc3\
\xc0\xc3\xa8\xfd\x8f\x43\x46\xc3\xe3\x96\xa7\xbf\x40\xf2\x6c\x05\
\x32\x6c\x83\xf1\xfe\x3a\xb0\xcd\xee\x75\x80\xa4\xaf\xa9\xb2\xfc\
\xf4\xb4\xef\xcf\xa0\x48\x94\x09\x48\x36\x4e\x01\x4e\x41\x86\xc7\
\x7c\x2b\x83\xed\xc0\xff\x58\x9e\xfb\x22\x43\xbf\x17\x32\x58\x2e\
\xb4\xf4\x1f\xe6\xf8\xee\x35\xeb\x34\x2d\x22\xd4\x06\xda\x50\x7a\
\xf8\x7c\x2b\x54\x77\x40\x75\x3a\x42\xfa\xd9\x06\x64\xc4\xb6\x45\
\x6d\x67\x07\x32\x84\x17\xa1\xfa\x5c\x8d\xea\xe7\x2e\xe0\x97\x76\
\xfd\x64\xbb\x3e\x44\x57\x61\x7f\xab\x80\xa1\x68\xe0\x78\x0d\x1a\
\xd4\xe9\x88\xea\xe9\x53\x27\xba\xd0\x9c\x93\x13\x37\x84\x9d\xa6\
\x44\x0e\x75\x8a\x8b\x81\xb7\xd1\x28\x7d\x95\x1d\xcb\x21\x41\x9e\
\x43\x1d\x64\xb9\xfd\xf6\x26\xb0\x11\x79\x80\x77\xa1\x51\xf7\x38\
\x95\xde\x48\x92\x7d\x5a\x7d\x1e\x8a\x73\x3c\x88\x50\xe8\xe1\x77\
\x81\xbf\x47\x0a\xc1\x22\xb4\x08\xd6\x9d\x68\xd4\x7a\x17\xaa\xaf\
\x65\xd4\xae\x87\x41\xc8\xe7\xa8\x3d\x48\x53\x43\x12\xb1\x13\x65\
\x7e\xaf\x49\x5d\xe3\x38\x4e\xc3\x09\x6d\xa8\x92\xc4\x5b\xfb\x3a\
\x32\x0e\x3b\xa2\xf6\x1a\xda\x68\x84\x3c\xc1\x15\xa8\x3d\xa7\xdb\
\x68\x19\xda\x13\xfc\x46\xe4\xa1\x5a\x84\x0c\xd5\x6f\x22\xa3\x34\
\xa4\xd9\xc9\xd2\xd9\x8b\xe4\x54\x68\xd7\xfb\x2d\x9d\x18\x45\x30\
\x85\xfb\x81\x8c\x8a\x67\x91\x67\xae\x1a\x0d\x96\xd5\xd8\xef\xe1\
\xb3\xdb\xf2\x59\x96\x7a\xb6\x1a\xcb\x67\x48\xeb\x60\xea\x7b\x90\
\x91\x79\x64\x58\x7c\x05\x79\x8b\x97\xa3\x70\xe9\x72\x14\xb6\xba\
\x10\x79\xfa\xbe\x68\xcf\xfd\xc8\x89\x7e\x61\xce\xbb\xc2\x0e\xb4\
\x28\x69\x2f\x14\x51\x50\x1f\x11\xaa\xe3\xdf\x49\x1d\x0b\x91\x0c\
\xa7\x23\x27\xc6\x0e\x64\x08\x07\x1d\x2e\x4d\xd6\x16\x09\x61\xce\
\x71\xea\xdc\xd6\xa8\x0e\xe6\x50\x1b\x59\x80\xda\xcd\x2a\x34\xa8\
\xec\x38\x0d\xc2\x15\x29\xa7\x29\xb1\x07\xcd\x45\x1a\x84\x94\x88\
\xd1\x68\x84\xbc\x86\x44\xc0\xe7\x50\xa7\xb9\x1d\x75\xd0\xe1\xdc\
\xb3\x90\xa7\x6d\x06\x1a\xf1\xbe\x0a\x85\x90\x7d\x02\x75\xa4\xad\
\x90\xc0\xf7\x3a\xef\x1c\x4b\xc2\x00\x4d\x19\x0a\x75\xfe\x23\xf2\
\xdc\x80\xea\xef\x76\xe0\x05\xe4\x11\xee\x00\x6c\x45\x83\x3c\x1f\
\x40\x61\x94\x37\x59\x1a\x2f\xa3\x10\xb0\x4b\xd1\x5c\xf6\x41\xc8\
\x43\x54\x81\x84\xfd\x74\xa4\x60\x9f\x8d\x42\xcf\xd6\xa2\x91\xf6\
\xa3\x5d\x29\xd6\x71\x9c\x84\x83\xc8\x13\x3a\x14\x85\x70\xce\x42\
\x9e\xd2\xbe\xc8\x83\x35\x1b\xc9\x93\xeb\xd0\xdc\xdc\xcf\x22\x85\
\x3c\xc8\xa3\x88\x64\x80\x76\x13\x9a\xc6\x73\x2b\xf2\xc4\x96\xa1\
\xf9\xc5\xb3\x90\xd2\xde\x17\xc9\xae\x88\xda\x06\x6b\xb8\x1e\xfb\
\x9b\x1e\x00\x2b\xb7\xdf\x5f\x45\xe1\xce\xfd\x51\xbf\x10\x23\xb9\
\x38\x12\x79\xed\xb2\xe9\x45\x99\xb4\xb2\xdf\xc3\x39\x11\x89\x17\
\x78\x0a\x1a\x34\xee\x81\xfa\x95\xbb\x51\xf8\xf4\xd3\x28\xa2\xaa\
\xfd\x89\x7e\x59\xce\xbb\xca\x4a\x54\xef\x0e\x96\x70\x6e\x8e\x23\
\x65\x51\x19\x9a\xf7\xbb\x18\x19\xc9\x3d\x51\xe4\x44\x18\xc8\x1d\
\x8e\x06\xa0\xca\x51\x3b\xeb\x8c\x42\xaa\xaf\x46\x1e\xde\x18\x19\
\xb9\x67\x21\x99\x7a\x23\x9a\x5a\x14\xa6\x33\xf4\x42\x53\x8e\x26\
\xa1\x29\x03\x8e\xd3\x20\xca\xfa\x75\xac\xfc\xea\x2d\xa7\x76\x69\
\xdd\xbe\xd2\xed\x03\xe7\xf8\x53\x93\x87\x27\x96\xec\xda\xff\xe6\
\xe6\x83\xbf\x46\x21\x5f\x69\xf2\xc8\xb8\xed\x87\xc2\x9c\xf7\x03\
\x7f\x40\xa3\xdd\xed\x90\x32\x91\x43\xc2\x7a\x21\x30\x17\x75\xa6\
\xe7\x20\x41\xfd\x20\xea\x24\xd7\x23\x6f\x5c\x77\x14\xf2\xf5\x26\
\xea\xa4\x87\xd8\x35\xbe\xa8\x82\x73\x34\x4c\x42\x02\xb7\xd0\xc8\
\x78\x1b\xb4\xb8\xd5\x3c\x24\xb8\xdf\x46\x1e\x9c\x39\xc8\x00\x1e\
\x82\x06\x73\x56\xa0\x08\x87\xb9\xc8\x43\x3c\x1a\x29\x09\x4b\x90\
\xe2\xfd\xbc\xdd\xe3\x12\x14\x46\xf6\x3f\xa8\xbe\x77\xb3\xdf\x5f\
\xb2\xef\x17\xd8\x79\x3f\x46\xed\xa2\xd2\xee\xe5\x8b\xd8\x38\x2d\
\x85\x72\xb4\x00\xcf\x4c\x8e\x94\x21\x47\xcb\x2e\x24\x6f\x62\xe0\
\x39\x34\xd0\xd4\x07\x29\xe6\x1b\x91\x27\x76\x35\xea\x03\x7a\x01\
\x3f\x43\xca\x79\x39\x6a\x9f\x79\xa4\xc0\xcf\x47\x83\x5e\xed\xed\
\xfa\x9f\x22\x03\x62\x0d\x92\x4f\x7d\x90\x41\xbc\x16\xf5\x11\x35\
\xa8\x2f\x88\xd1\xd4\x89\xf9\xc8\x63\xd6\xce\xd2\x59\x8e\x64\x56\
\x05\x6a\xdf\xbb\xd1\x62\x91\x6f\xa2\x35\x31\xf2\xc8\x73\x3b\x16\
\xf5\x2b\xfb\x91\x4c\x0c\xf9\x99\x87\xe4\xdc\x26\xbb\x67\x47\x7b\
\x9e\xa5\x96\xc7\x1d\x76\x8f\xd8\xd2\x2b\x47\x03\x73\x07\xed\x7e\
\x4b\x50\x7f\x77\x2e\xf2\x08\xbf\x86\x3c\xd1\xbe\xd0\x64\xf3\xa1\
\x1d\x1a\xe0\x79\x12\x45\x28\x34\x86\x0e\xc8\x21\xb1\x20\x75\x2c\
\x8f\xea\xff\x78\x24\x07\xe7\xa1\xf6\xfa\x3a\xaa\xbb\xa7\xa2\xe9\
\x6a\xd5\xc8\x81\xb1\x05\x19\xbc\x1d\x51\x9b\x78\x15\xc9\xd0\x4e\
\x28\x14\xfa\x2d\xd4\x76\x5e\x45\x75\xf3\x4c\x92\x36\x11\x16\xb1\
\x73\x9c\x52\x69\x8f\xe6\x9c\x4f\x8d\x26\xf6\x6f\xb7\xf3\xbe\x3b\
\x86\x74\xea\xd5\xbe\x9c\x38\x6e\x6c\xba\x8e\x53\x37\x87\xaa\x63\
\xbe\xf0\xc8\xaa\xad\xbf\x5f\xb0\xe3\x5a\xd4\x21\x3a\x4e\x53\xe7\
\x5b\x68\x74\xfc\xbe\x13\x9d\x11\xc7\x71\x68\x0d\x7c\x1f\xf8\x21\
\x32\x86\x9b\x02\x11\x1a\xdc\xfa\x28\x32\x78\x7f\x73\x8c\x9f\xf7\
\x5c\xb4\x50\xd7\x3f\xa3\xb0\x6b\xc7\x69\x2c\x3d\xd0\x5a\x13\xf7\
\x70\xe2\xe7\x7f\x0f\x44\x8b\xbc\x3d\x88\x06\x97\x3f\x88\xe4\xee\
\xb2\x13\x9c\x2f\xa7\xf9\xd2\x1b\xf5\xa7\x7f\xe1\x73\x84\x1d\xc7\
\x71\x1c\xc7\x71\x1a\xc7\x04\x64\x50\x3c\x7a\x8c\xd3\x6d\x85\xbc\
\xb5\x8f\xa0\x30\x53\xc7\x69\x6e\xac\x43\x8b\xc4\x5d\x89\x3c\xbb\
\xdf\x47\x11\x0b\x8e\x73\xdc\x71\x43\xd8\x71\x1c\xc7\x71\x1c\xa7\
\xe1\xc4\x68\xe5\xf8\xe3\xc1\x2e\xb4\x08\x9f\xe3\x34\x57\xaa\xd1\
\x40\x8f\x2f\xc6\xe6\xbc\xeb\xb8\x21\xec\x38\x8e\xd3\x50\xbe\x34\
\xad\xf0\x06\x46\xdf\x9b\x0c\x5f\x78\x16\x72\x65\xb5\x8f\x35\x94\
\x7b\xa7\x35\x2c\x9d\x7b\xa6\x15\x5e\x2b\xbd\x31\x79\x71\x1c\xc7\
\x71\x1c\xc7\x69\x06\xb8\x21\xec\x38\x8e\xd3\x50\x72\x31\xe4\x39\
\x15\xa2\xdb\xd1\x2a\xb3\x4f\x03\xcf\xf1\x85\xa9\xd5\xe4\x72\xa0\
\x85\x42\x6e\x44\x8b\x5f\xd5\xde\xe2\x21\x6d\xdc\x06\xbe\x37\x19\
\xee\x7d\x8e\x5a\xd6\xab\x8c\xd6\x71\x68\x2b\x8a\xff\x01\x96\xbf\
\x73\x4e\x1c\x43\x4d\x0d\x7c\xff\x72\xb8\x67\x2a\x44\x51\xed\x6b\
\x63\xda\xa1\x05\x48\xe6\xd9\x91\x4f\x00\x53\xb8\x77\xda\xeb\xc9\
\xfd\x52\xf9\x88\x63\x4b\x43\x17\xf3\xbd\x4b\x4e\x74\x09\x3b\xce\
\xf1\x64\x14\xf0\x3e\x92\x85\x76\x72\xa8\xad\x3c\x81\x16\xc1\x2b\
\xc4\x60\xa4\x3b\xbd\xfd\x2e\xe4\xaf\x27\x5a\x68\x2b\x2c\xc6\x57\
\x17\x5d\xd0\x4e\x09\xbf\x25\xd9\x82\xc9\x71\xde\x0d\x2e\x46\x72\
\x2e\xec\xfb\xbb\x0c\x2d\xae\xb6\xf9\x04\xe6\x69\x32\x5a\xfc\x6d\
\xc6\x89\x2e\x1c\xa7\x69\xe3\x4b\x45\x3b\x8e\xe3\x34\x94\x6a\xfa\
\x43\xf4\x53\xb4\x65\xca\x64\xb4\x5a\xec\x59\xc4\x71\x04\xf1\x48\
\xe0\x9f\xd0\x22\x20\x3d\x6b\x5d\xf7\x85\x69\xd8\xea\x84\x9d\xd1\
\x96\x28\xdd\x81\x1c\xf7\x3c\x07\x07\xd6\x80\xb6\x89\xe8\x45\x44\
\xa5\x19\xaa\xc3\x81\xcf\x01\xfd\xec\xff\xf6\x68\xb1\x87\xf6\x54\
\x54\xc0\xbd\x53\x21\xce\xe7\x2c\x9d\x5e\xc4\xb4\x06\x72\x44\xbc\
\x07\xad\x30\x7d\x2a\x89\x82\xb2\xd7\xf2\xd3\x9e\xcf\x4f\x03\xcd\
\x41\xec\x0d\xb4\xa6\x4b\x17\x88\x63\xdd\x9b\xb8\xa2\xa0\xb1\xee\
\x38\xcd\x87\xa1\xa8\x6d\x3c\x87\x56\x88\x9e\x05\x7c\x0a\xcd\x55\
\x2c\xc6\xfb\xd0\xe2\x55\xef\x06\x97\xa3\x2d\xd6\x4a\x59\xca\xb4\
\x03\xda\xe2\xa9\xdd\xbb\x94\x37\xc7\x09\x9c\x89\x76\x35\x78\x0e\
\xed\x8a\x30\x16\x85\xf3\x77\x3a\x81\x79\x2a\xc7\xb7\x17\x74\x4a\
\xc0\x3d\xc2\x8e\xe3\x38\x0d\x26\x3a\x15\xed\xe5\xf9\x31\x64\x9c\
\xfe\x13\xd0\x86\xb2\xb2\x51\xc0\x4f\xd0\x7e\xc0\x87\x29\xa4\xc8\
\x46\xd1\x25\xc0\x17\xd1\xd6\x47\xbd\x81\x5f\x02\x3f\xa5\xcd\x29\
\xef\x01\xbe\x04\x74\x20\xe6\x19\xe0\x2f\xd1\x76\x2b\x55\xfa\x1b\
\x8f\x83\xe8\xef\x81\x11\x44\xd1\x12\xe2\xf8\x9b\x10\x2d\x20\x57\
\xf6\x49\x88\x3e\x01\xb4\x21\x62\x3a\x32\x80\x3f\x8b\xf6\x41\xfd\
\x47\xe0\xeb\xc0\x67\x80\x9f\x03\x57\x00\x2b\x39\x9c\xff\x1a\x6d\
\x72\x37\x23\x63\xfd\x93\xec\xdc\x79\x2a\x51\xf4\x45\xa0\x03\xe4\
\x9e\x24\x8e\xff\x16\x6d\xe7\xe2\x38\x27\x0b\x5d\x80\x01\x68\xd0\
\x67\x5f\x09\xe7\xaf\x43\xfb\x78\x07\xae\x01\x86\x21\x25\x7a\x32\
\xda\xc7\xb4\x1c\x6d\x33\xb4\x1c\x79\xbf\x76\xa1\xbd\xbd\x0f\x22\
\x2f\x6c\x47\xb4\xad\xcb\x73\xd4\xde\x9e\xaf\x3d\x32\x64\x87\xa2\
\x2d\xd4\x1e\x44\x21\x1b\x37\x23\xcf\x72\x38\xd6\x0a\x0d\xa6\x1d\
\xb0\xe3\xcf\xa3\x2d\x9c\x2e\x41\x83\x60\x53\xd1\x36\x4f\x9d\xed\
\xfa\x07\xd0\xb6\x4c\x13\xd0\xb6\x33\x0f\xa2\x81\xae\x1a\x1c\xe7\
\xd8\xd0\x07\x19\xb7\x8b\xa9\x7f\x7b\xbe\x3c\xda\x3a\xe9\x09\xfb\
\xff\x39\xb4\xd5\xd8\xf9\x28\x4a\xea\x32\xb4\x35\xd9\x76\xe4\x29\
\xde\x02\xdc\x8e\xf6\x1a\x1e\x88\xb6\x43\x7a\x1c\x0d\x30\x8d\x44\
\xf5\xfc\x31\xe4\xac\xbb\x0e\xd5\xf9\xa9\x68\xa7\x91\x01\xc8\xfb\
\xdc\x0d\x6d\x41\xf6\x04\x1a\xd8\xbd\x19\x0d\x04\xcf\x42\xdb\x29\
\x1d\x44\x51\x1d\x95\x68\x6f\xe2\xf1\xa9\xfb\xaf\x05\xde\x8f\xda\
\xea\x50\xb4\xcd\xd3\xef\xd1\x36\x64\x4e\x0b\xc3\x3d\xc2\x8e\xe3\
\x38\x0d\xa7\x15\x32\x74\x47\x02\x7f\x8e\x04\x73\xd8\x5f\xf4\xc7\
\xc0\x77\x08\xb1\xca\xf7\x4c\x53\x18\xf2\xbd\xd3\x20\x26\x87\xb6\
\x5a\xe9\x03\xfc\x03\x70\x3f\xb0\x9d\x28\x1a\x0a\xfc\x35\xda\x22\
\xe5\x07\xc0\x1d\xc8\xcb\x93\x47\xc6\x74\x1b\x88\xbe\x6a\xd7\xfd\
\x35\xd0\x17\xf8\x53\x88\xce\x85\xe8\x1b\xc0\x8b\xc0\x8f\x80\xd1\
\x10\x77\x47\xca\xc5\x1e\xe0\x3f\x91\xf2\x3e\xc2\xf2\xb3\x08\xb8\
\x8e\xd6\x51\x50\x2a\x76\x12\xc7\x39\x4b\xf3\x4d\xe0\x3f\x80\xbb\
\x88\xa2\xdb\x4e\x74\x01\x3b\xce\x51\x50\x81\xb6\x5d\x79\x16\x0d\
\xfa\x44\xf5\x9c\x9f\x47\x6d\xe2\xc3\xa8\x3d\xfe\x39\x8a\xc6\x98\
\x62\xc7\x6f\x46\xa1\x95\xcb\x81\x3f\x45\x5b\x19\xad\x46\xed\xe7\
\x10\xf0\x4d\x64\x24\xbc\x0c\xdc\x09\x5c\x9a\x4a\x3b\x07\x7c\x1c\
\x19\xd2\x2f\x22\x2f\xd9\xe5\xc0\xe7\x81\xd3\x91\xb1\x7b\xba\xfd\
\xdf\x0d\xf8\x13\xcb\xef\x7c\x34\x10\xd6\x13\x19\xca\xcb\x91\xb1\
\x7e\x17\xea\x67\x5e\x47\xc6\xf5\x7b\xec\xbe\xed\xec\x99\x3b\x50\
\x9a\xe7\xd8\x71\xea\xa3\x33\xf0\x5f\xc0\x33\xc0\x0d\x25\x5e\x93\
\x5a\x10\x83\xdd\x68\xcf\xea\x51\xa8\xce\xdf\x85\xea\x6a\x0d\xf0\
\x65\x64\xb0\x7e\x08\x0d\x38\xbd\x8a\xa2\x2c\x2e\x43\x6d\xe5\xbd\
\x68\x10\xa8\x13\xf0\x35\xd4\x06\x16\xa2\x6d\x9e\xc6\x00\x1f\x41\
\x83\x5d\x2f\x93\x0c\x5a\x7d\x02\xb5\xdb\x97\xec\xd8\x10\xb4\xc7\
\xf0\x58\xd4\x56\x6e\x47\x9e\xea\xd6\xa8\xcd\x76\x42\xb2\x75\x82\
\x1d\xbf\xd6\xae\x73\x5a\x20\x6e\x08\x3b\x8e\xe3\x34\x8e\x32\x34\
\x87\xef\xaf\x90\x50\xbe\x13\x8d\xa2\xdf\x87\xe6\x48\x45\x48\x41\
\x6d\x07\x7c\x15\xf8\x01\x65\x7c\x1e\x19\x9c\xa7\x20\x0f\xed\xa9\
\xc0\x7a\x34\x3a\xdd\xcf\xce\x1d\x8c\x94\xed\x33\xd1\xa8\x76\x8c\
\x3c\x4f\xa7\xdb\x7d\xc7\x22\x25\x7c\x24\xf2\x0e\x95\x03\xff\x4d\
\x2e\xf7\x5d\xe0\x5a\x22\x9e\x40\x4a\xc4\x21\xe0\x35\xe4\x1d\x0b\
\x5e\xa3\xc7\x80\x8e\x66\xe8\x9e\x09\x3c\x4c\x14\xf5\xb3\x7b\x77\
\xb2\x7c\x54\xa1\xb9\xc9\x8e\x73\x32\xd1\x0a\xb5\x97\xca\x12\xcf\
\x8f\x51\x9b\x18\x8c\x94\xe3\x9f\x22\xc5\x7b\x15\x8a\xd2\x68\x8d\
\x14\xf7\xee\xa8\xad\xaf\x03\x96\x20\xc5\xfb\x0c\xa4\x94\x8f\x43\
\xed\xe6\xc2\x54\xba\x6d\x90\x47\xec\x97\xc8\x43\xf6\x97\x68\xa0\
\xec\x0c\x34\xd7\x7f\x1a\x8a\x1a\x39\x03\x19\xbd\x8b\xd1\x80\xd8\
\x23\xc0\x4e\x4b\x77\x0d\x32\xbc\xd7\xa3\x01\xb7\x87\x91\xc7\x6b\
\x22\xf0\x07\x64\xa8\xfc\x08\x19\xd2\xc3\x28\xbc\x74\x9f\xe3\x1c\
\x2d\x11\x6a\x47\xad\x68\x5c\x78\x71\x39\x32\x84\xdb\x22\x79\xd5\
\x0d\xc9\x9b\x3e\xa8\x4e\xdf\x87\xbc\xb7\x8f\x02\x93\x50\x5b\x7c\
\x19\x79\x7f\xfb\x23\x39\xd4\x1f\xd5\xed\x5e\xc8\xab\xbb\xd9\xd2\
\x18\x6f\xd7\xad\x07\xb6\xa1\x76\x34\x1e\xc9\xb6\xb0\x2f\x72\x0e\
\x45\x55\xfc\x01\x79\xa6\x7f\x88\xda\xf1\x48\xd4\xc6\x7e\x67\xf7\
\x9a\x89\x3c\xd3\x4e\x0b\xc4\x43\xa3\x1d\xc7\x71\x1a\x8e\x79\x69\
\xe9\x09\xf1\xef\x20\xfa\x33\xe0\x22\xe0\x87\x7c\x6f\x72\x15\xf7\
\x4e\x0b\x46\x30\x48\xb9\x68\x87\x3c\x37\x6d\x88\xf9\x05\x11\x6f\
\xa2\x70\xb0\xeb\x91\x31\xfb\x6f\xc8\x70\x5d\x8e\x46\xb7\x5f\x45\
\x8b\xf2\x0c\xb6\xeb\x6b\x50\xc8\xd7\x66\x14\x9a\x39\x1b\x29\x01\
\xa7\x20\x85\xa5\x3b\x35\x35\x1d\x89\xa2\x89\xc4\xd1\x9b\x48\x11\
\x88\x50\x5f\x1f\xc2\x26\xcb\x88\xe3\x85\x44\xd1\x42\xe0\x0b\x40\
\x15\xc4\xcf\x12\x47\x7d\x88\xa8\xb2\xfb\x85\x7b\x2f\x39\xd1\x05\
\xec\x38\x47\x41\x15\x32\x38\xef\x43\x03\x4d\xf5\x79\x48\x73\x28\
\x84\xfa\x57\xf6\xfd\x00\xf2\x0c\xbf\x86\x42\x39\x3f\x85\xda\xc1\
\x4e\xd4\x2e\x73\x24\x0e\x84\x32\xe4\xf9\x9a\x8f\xe6\xdd\xaf\x44\
\x86\x6b\x20\xb2\x73\x83\x71\xda\x0d\x85\x39\x43\xd2\x16\x6b\x52\
\xf9\xd8\x8f\x8c\xdd\x0a\xbb\x26\xa2\xb6\xb3\x22\x6f\xe7\x94\xd9\
\x6f\x21\xdd\xd8\x3e\xee\xd8\x70\x8e\x15\x3b\x80\x4f\x23\xe3\x73\
\x5e\x89\xd7\xa4\x07\x61\xc2\x40\xee\xf3\xc8\xe8\x5d\x8e\xda\x49\
\x19\x8a\x98\xda\x84\xea\x6c\x75\xea\xda\x20\x2b\xf7\xda\xb1\x72\
\x14\x42\x3d\x1f\xb5\x93\x95\x24\x6d\xed\x6d\x64\xf8\x7e\x01\x19\
\xeb\xbf\x43\x83\x57\x13\xec\x58\x25\xb5\xdb\x56\x3e\x93\xc7\x9c\
\xdd\x3b\x4c\x9d\xf0\x48\x8a\x16\x8c\x1b\xc2\x8e\xe3\x38\x8d\x23\
\x87\xc2\x93\x6f\x42\x9e\xdd\x87\xc8\xbf\x23\xe0\x73\x48\xb1\xcd\
\x21\x01\xfe\x4d\x00\xe2\xb8\x8c\x28\xfa\x12\xf2\xec\xfc\x0a\xcd\
\x7b\x1a\x09\xf1\x6c\x88\x66\xa3\x39\x4d\xa7\xa0\x45\xab\xfe\x12\
\xa2\xbc\xa5\xb3\x1b\x78\x12\xb8\x1b\x79\x9e\xfb\xa1\xf9\x82\x8f\
\x23\xef\xef\xb7\x89\xa2\x0d\xc8\xa8\xfe\x1c\x0a\x87\xee\x00\x7c\
\x03\xad\x26\x5b\x66\x79\x39\x88\xe6\x56\x5d\x6b\xc7\x57\x10\xb1\
\x13\x79\xac\xae\x42\xa3\xf0\x7d\x90\x97\xdb\x71\x4e\x26\x36\x53\
\xfa\x6a\xb5\x61\x90\xa8\x0c\x29\xce\x3f\x46\x46\xf4\x5d\xf6\xfb\
\x21\xe4\xcd\x3d\x07\x79\x92\x22\xd4\x76\x86\xa1\x70\xe7\x0d\x68\
\x7e\xff\x1c\x34\x98\x35\x25\x95\xf6\x7e\xe4\x69\xba\x13\x79\x95\
\xef\x44\x8a\xfc\x42\x14\x16\xfa\x20\x0a\xbd\x7e\x0b\xd8\x4a\x6d\
\x7d\x2c\x18\xbb\x07\x50\x1b\xef\x4d\x62\x84\xd7\xa0\x70\xed\x5b\
\xd1\x9c\xc7\x33\x91\x42\xbf\x0c\x5f\x1c\xc8\x39\x76\xac\xb2\x4f\
\x29\xe4\xd0\x20\xcf\x45\xc8\x08\xbd\x0a\xd5\xc9\x97\x90\x51\x7c\
\x23\xaa\xcb\x83\x50\x7d\x9d\x85\xea\xf4\x9d\x24\x21\xce\xbf\x46\
\x9e\xda\x10\x62\xfd\x06\x0a\x69\x6e\x8f\x06\x7b\xaf\x40\x32\xee\
\x3d\x68\x60\xea\x59\x14\x2a\xdd\x09\xcd\xf7\xdd\x6d\xc7\xc6\xda\
\x35\xc1\x00\x7e\x11\x4d\x2f\xda\x8a\x8c\xe7\x3d\xc8\x90\xae\x20\
\x99\x3a\x91\xc3\x8d\xe1\x16\x8b\x1b\xc2\x8e\xe3\x38\x0d\x27\x42\
\x02\xff\xb7\x68\xbe\xee\xb7\x81\xff\x26\x7a\x47\xa8\x2e\x41\x8a\
\xf5\x56\xfe\x6d\x72\x72\xd5\xbd\xd3\xf2\x28\x84\xab\x3d\x32\x7a\
\xd7\x02\xff\xc1\xbe\x43\x73\x68\xd7\xfa\x0b\xc8\xd0\xed\x05\x3c\
\x04\xd1\x42\x64\x28\xdf\x07\xac\x25\xce\xff\x2b\x51\xb4\x1d\xa2\
\xd3\x81\x97\x21\x7e\x9a\xf8\xf0\x52\xa2\xca\x8f\x43\xf4\x41\x34\
\xbf\xeb\xab\xc4\xf1\xe3\x44\x51\x5b\xb4\x80\x57\x17\xa4\x4c\xfc\
\x12\x78\x8b\x7f\xbb\x04\xee\x99\xf6\x18\x11\x23\x74\x0f\xaa\xa8\
\xac\xdc\xcc\xe1\xc3\x9f\x07\x3e\x08\xf4\x40\x8a\xfa\xfc\x13\x5d\
\xc0\x8e\x73\x1c\x59\x8d\x94\xf5\xd0\x5e\xb7\xa2\x36\x7c\x26\x1a\
\x60\xea\x88\x0c\xce\xb7\x50\x38\xf3\x41\xd4\x2e\xee\x44\x6d\xf7\
\xaf\x90\x62\x7e\x0b\x1a\x44\x4a\x2f\xba\x95\x47\xa1\x98\x77\xa0\
\x79\x8a\x73\x90\xe7\xaa\x0d\xc9\xdc\xff\x55\x76\xac\x12\x85\x4a\
\x07\x2f\xd9\x73\xc8\x1b\xb6\x0a\x19\x07\xa3\x51\x68\x67\x30\xf0\
\x7f\x83\xfa\x9d\x1b\x51\xbb\xfe\x6b\x64\x1c\x3c\x85\x0c\x0e\xc7\
\x79\x37\x99\x8f\xe6\xd4\xdf\x81\x06\x6a\xde\x06\xbe\x87\x8c\xd3\
\x87\xed\xd8\xf5\xa8\xfd\xfc\x1a\x19\xa3\x5b\xed\xda\x2b\x48\xc2\
\xfc\xab\x49\x0c\xe1\x45\xa8\x2d\x5e\x8d\x8c\xd6\x27\x51\x94\xc7\
\x01\xe0\x36\xfb\x3c\x6f\xd7\xf6\xb6\x7b\xdf\x8e\xda\xce\x83\x68\
\xf0\xea\x20\x8a\x9a\x0a\xf7\xdf\x81\xda\xca\x76\xd4\xde\x76\xd8\
\xbd\x4a\xd9\x9e\xcc\x69\xa6\x44\x13\xfb\xb7\xdb\x79\xdf\x1d\x43\
\x3a\xf5\x6a\x5f\x6e\xbb\x79\x38\xce\xf1\xe3\x50\x75\xcc\x17\x1e\
\x59\xb5\xf5\xf7\x0b\x76\x5c\x8b\x16\xfd\x70\x9c\xa6\xce\xb7\x50\
\x58\xd6\x7d\x47\xfc\x72\xef\xb4\x9b\x80\x5f\xa0\x05\x45\x5e\x7c\
\xe7\xb8\xf6\xfe\xad\xbd\x47\x6f\x38\x96\x3d\x9e\xa6\xd6\x3e\xbe\
\xc5\x88\xa9\xbd\x06\x50\xba\xe3\x8e\x4a\x4b\xab\xd0\x7e\xc5\xc5\
\x48\xe7\xdb\x71\x4e\x3c\xad\x81\xef\x23\x23\x73\xe6\x89\xce\x8c\
\xe3\x9c\xa4\xf4\x40\x0b\x32\xde\x43\x32\xa7\xf6\xdd\xa2\x33\xf0\
\xaf\x68\x20\x69\xf5\x89\x2e\x08\xa7\x45\xd2\x1b\xf8\x67\xe0\x2f\
\xdc\x23\xec\x38\x8e\xd3\x70\x56\x21\x43\x78\x53\x41\x83\xb1\x98\
\x11\xd9\x14\x8c\xcb\xef\x5d\x72\xa2\x73\xe0\x38\x8e\xe3\xb4\x3c\
\x0e\x03\x2f\x50\xda\xf6\x66\x8e\x73\x5c\x71\x43\xb8\x0e\x72\x19\
\x67\x49\xbe\x1e\x8f\x79\x14\x1d\xe9\xa7\x71\x2f\xbb\xe3\x34\x6b\
\xe6\xa2\x11\x75\xc7\x71\x1c\xc7\x71\xea\x67\x3f\x1a\x40\x76\x9c\
\x13\x8e\x1b\xc2\x45\x38\x5c\x13\xb3\xe3\x40\xf5\x3b\x86\x6c\x14\
\x41\xd7\x36\xe5\x54\x94\x15\x0e\x25\x8c\x81\x1d\xfb\x6b\x38\x54\
\x9d\x2c\x9c\xd7\xb6\x32\x47\xc7\x56\x65\x25\xdc\xcd\x71\x9c\x93\
\x92\xa6\xe0\xd9\x75\x1c\xc7\x71\x1c\xc7\x71\x8e\x1a\x37\x84\x0b\
\x50\x96\x8b\x98\xb3\x66\x1f\x9f\x7b\x78\x15\xd5\xe6\x06\x6e\x53\
\x9e\xe3\x47\xb7\x0c\x62\x7c\x9f\xb6\xd4\x14\x70\xf3\x56\xd7\xc4\
\xfc\xd5\xb3\xeb\x78\x7e\xc5\x9e\x77\x8e\xdd\x3e\xae\x2b\x5f\x9f\
\xdc\xe7\x44\x3f\x8e\xe3\x38\xc7\x8f\xd1\x68\x61\xab\xf4\xd6\x25\
\x5b\xd0\xde\x9e\xbb\x8e\xd1\x3d\x3a\xa3\xd5\x65\x1f\x44\x0b\xe2\
\x64\x19\x8b\x56\xab\xfe\xed\x89\x2e\x0c\xc7\x71\x1c\xc7\x71\x9c\
\x93\x05\x37\x84\x0b\x10\x01\x07\xab\xf3\xac\xda\x71\xf8\x1d\xa3\
\xb7\x75\x79\xc4\xa1\x9a\x7c\xb2\xd3\x59\x86\x18\xd8\xb4\xb7\x8a\
\xd5\x3b\x0f\xbf\x73\x6c\xdb\xbe\xea\x92\xee\xe7\x38\xce\x49\xcb\
\x50\x64\x0c\xff\x88\x64\xdf\xc2\xbd\x68\xb5\xca\x63\x45\x07\xb4\
\xe2\xe5\xb3\x14\x36\x84\x87\xa1\x95\x37\xdd\x10\x76\x1c\xc7\x71\
\x1c\xc7\x29\x11\x37\x84\xeb\x20\x17\x41\x4d\x1c\xbe\x47\xf5\xae\
\xaf\x9a\xcb\xac\xd0\x5a\xef\xe2\xaf\x8e\xe3\x9c\xec\xc4\x68\x6f\
\xc3\xc7\x32\xc7\x23\xe0\x6c\xe0\x52\xe4\x2d\x7e\x0a\xcd\x27\xbe\
\x05\x6d\x95\x32\x1c\x58\x80\xbc\xc6\xe7\xa3\x3d\x40\xef\xb7\xeb\
\xae\x06\xc6\xa3\x6d\x51\x1e\x44\xdb\xb0\xd4\xd8\xdf\xee\x68\x3b\
\x97\xbe\x68\x4b\x97\x87\x53\xbf\x3b\x8e\xe3\x38\x8e\xe3\x38\x25\
\xe2\x86\xb0\xe3\x38\x4e\xc3\x89\x81\x31\xc0\xa7\x91\x41\x0a\xb0\
\x18\x19\xb9\x7f\x86\x8c\xdb\x0a\xb4\xc7\xe1\x32\xe0\x2e\xfb\xfd\
\x45\xe0\x6b\x68\x0f\xd3\x69\xc0\xe7\xd0\x9e\xc3\x43\x81\x6b\xd1\
\x42\x22\x67\x00\xdf\x44\xfb\x31\xc6\x40\x2b\xe0\x8b\xc8\xe3\x3c\
\x0d\x78\x2f\xd0\x0d\xdf\x7e\xc2\x71\x1c\xc7\x71\x1c\xe7\xa8\xc9\
\x35\x3e\x09\xc7\x71\x9c\x16\x4d\x39\xd0\x36\xf5\xa9\x04\xaa\x90\
\xb7\xf7\x1a\xa0\x23\xf2\xec\x1e\x04\x0e\x00\x0f\x00\x53\xd0\xde\
\xc4\x4f\xdb\xf7\xd5\x40\x3f\x60\x32\xf0\x07\x14\x06\xfd\x43\xe4\
\x01\x1e\x0e\x54\x23\x2f\xf0\x60\xe0\xa7\xc8\x10\xfe\x05\x70\x9e\
\xa5\xef\x38\x8e\xe3\x38\x8e\xe3\x1c\x05\xee\x11\x76\x1c\xc7\x69\
\x38\x11\x30\x0f\xf8\x4e\xe6\x78\x39\xf0\x6d\xb4\x90\xd5\xd9\xc0\
\x8d\xc0\x97\xd0\xfe\x89\x7b\xed\xf7\x6a\xfb\x1f\x92\x95\x07\x22\
\x12\xcf\x72\x38\x96\x4b\xfd\x16\xa7\x8e\xd7\xd8\x31\x9f\x84\xe1\
\x38\x8e\xe3\x38\x8e\x73\x94\xb8\x21\xec\x38\x8e\xd3\x70\x22\xe0\
\x14\x34\x17\x38\xcc\xd3\x3d\x88\x56\x8e\xfe\x1c\xf0\x04\xf0\x0c\
\x70\x1a\xf2\x14\x97\x91\x18\xae\xd9\xef\xd5\x28\x64\xfa\x56\x60\
\x3b\x30\x01\x79\x95\x97\xa2\xb0\xe8\xf5\xc0\x5a\xe0\xc3\xc0\x54\
\xe0\xfd\xc0\x2c\x60\x8f\x5d\xef\x38\x8e\xe3\x38\x8e\xe3\x94\x88\
\x1b\xc2\x8e\xe3\x38\x0d\x67\x25\xb0\x06\x2d\x82\x15\x3c\xb5\x3b\
\x81\xff\x42\xe1\xd0\x97\x21\x0f\xef\x77\x81\x45\x28\xa4\x79\x27\
\x32\x9a\x9f\x03\x36\xda\x35\x2f\xa1\xf0\xe8\x67\x51\x58\xf5\xb5\
\xc0\x0e\xe0\x6f\xec\xef\x33\x68\xf1\xac\x7f\x44\xf3\x8d\x6f\x04\
\x66\xa2\x30\xeb\x21\xc0\xf3\x27\xba\x20\x1c\xc7\x71\x1c\xc7\x71\
\x4e\x26\xdc\x10\x76\x1c\xc7\x69\x38\x0b\x80\x2f\x14\xf9\x6d\x03\
\x32\x7c\xd3\xfc\x2c\xf5\xfd\xe7\xa9\xef\xff\x9b\xfa\xfe\x5b\x8e\
\xdc\x0a\xe9\x47\xa9\xef\xff\x9e\xf9\xed\x0d\xfb\x38\x8e\xe3\x38\
\x8e\xe3\x38\x25\xe2\x8b\x65\x39\x8e\xe3\x38\x8e\xe3\x38\x8e\xe3\
\x38\x2d\x0a\x37\x84\x1d\xc7\x71\x1c\xc7\x71\x1c\xc7\x71\x9c\x16\
\x85\x1b\xc2\x8e\xe3\x38\x8e\xe3\x38\x8e\xe3\x38\x4e\x8b\xc2\x0d\
\x61\xc7\x71\x9c\x86\x73\x16\x5a\x08\xeb\xd4\xd4\xb1\xb6\xc0\x97\
\xd1\x02\x5a\xc5\x18\x88\x56\x92\x3e\xd6\x74\x02\x3e\x09\x74\x2e\
\xf2\xfb\x38\xe0\x3d\x78\xdf\xef\x38\x8e\xe3\x38\x4e\x0b\xc7\x95\
\x21\xc7\x71\x9c\x86\x33\x1a\x6d\x93\x74\x6b\xea\xd8\x28\xe0\xf3\
\xc0\x85\x75\x5c\x77\x33\x70\xe5\x71\xc8\x4f\x3b\xe0\x26\xa0\x7d\
\x91\xdf\x87\x02\x97\xe0\x7b\x0f\x3b\x8e\xe3\x38\x8e\xd3\xc2\xf1\
\x55\xa3\x1d\xc7\x71\x1a\x4e\x0c\xcc\x46\x06\x66\x27\xb4\xef\xef\
\x39\xc0\x7c\xb4\x0d\x12\xc0\xe9\xc0\x35\xc8\xf8\x7c\x06\x58\x8e\
\x8c\xe4\x4e\xc0\x53\x68\x5b\xa4\xdb\x80\xae\x68\xf5\xe7\xc7\x2d\
\xbd\xf3\x90\x41\xdb\x0e\x6d\x93\xb4\x18\xed\x21\xdc\x0a\xf5\xdd\
\xf7\x03\xe7\x03\xe3\x2d\x8d\x3f\xa2\x6d\x99\x6a\xd0\x96\x4d\x3d\
\x91\x81\xde\x0b\x58\x02\x3c\x6c\xc7\x6b\x70\x1c\xc7\x71\x1c\xc7\
\x69\xe1\xb8\x47\xd8\x71\x1c\xa7\xe1\xe4\x80\xa5\xc0\x01\x60\x0c\
\x32\x5a\x07\x01\x33\x90\x91\x3c\x04\xf8\x0a\x32\x44\xdf\x40\x5b\
\x2d\xf5\x07\x56\x20\xc3\x76\x07\xf0\x2d\xa0\x12\xed\x05\x7c\x33\
\x32\x8a\x07\x03\x9f\x40\xfb\x14\x6f\x01\xfe\x02\x19\xb4\x77\x00\
\xc3\x81\x57\xd0\x5e\xc2\x37\xd9\x75\x95\x96\x4e\x07\xbb\x6f\x6b\
\x14\x9e\xdd\x0b\x6d\xe1\x34\x19\x19\xd1\x8e\xe3\x38\x8e\xe3\x38\
\x0e\xee\x11\x76\x1c\xc7\x69\x0c\x11\xb0\x1f\x79\x85\xcf\x45\x46\
\xe8\x5e\x60\x1d\x30\x0c\xcd\x21\x1e\x6c\x9f\x18\xe8\x0d\x8c\x04\
\xd6\x23\x23\xba\x3d\x32\x56\xbf\x82\xbc\xc9\xad\x91\x71\xfb\x34\
\x32\x70\x1f\x02\x2a\x90\x21\x3b\xda\xce\x79\xc2\xee\xf7\x19\xe4\
\x29\x7e\xce\xfe\xff\x21\x32\x92\xab\x81\x3e\x76\x9f\x4f\xd9\xbd\
\x0e\x21\x23\xfc\xe1\x13\x5d\x60\x8e\xe3\x38\x8e\xe3\x38\x4d\x01\
\x37\x84\x1d\xc7\x71\x1a\x47\x84\x3c\xb4\xf7\x00\x5d\x80\xd7\x48\
\x16\xab\x2a\x03\x36\x21\x43\x35\x0f\x2c\x43\x9e\xe1\xdb\x90\x61\
\x1c\xd9\xdf\xd8\xce\xcf\x93\xcc\xdf\xad\xb6\xbf\x71\xea\xdc\x1a\
\xe4\x7d\x2e\x4b\x5d\x4b\xea\x6f\x94\xf9\x5b\xec\x77\xc7\x71\x1c\
\xc7\x71\x9c\x16\x8d\x87\x46\x3b\x8e\xe3\x34\x9c\x08\x79\x6c\x97\
\xa3\xfe\xf4\x42\x14\x16\x5d\x66\xc7\xe7\x20\xe3\xb5\xb3\x9d\x7b\
\x35\xd0\x06\x79\x91\x07\x23\xef\xf1\x36\xe0\x23\xc0\x05\xc0\x9d\
\xc8\xa8\xde\x0f\x4c\xb2\xf3\x3f\x68\x69\xbc\x69\x69\xe6\xec\xff\
\x17\xd0\x1c\xe0\x0b\x80\xbb\x81\x83\x28\x4c\xbb\x15\xb0\xc1\xbe\
\x7f\x14\xcd\x35\xbe\x1b\x78\x95\xc4\x88\x76\x1c\xc7\x71\x1c\xc7\
\x69\xd1\xb8\x47\xd8\x71\x1c\xa7\xe1\x2c\xb6\xbf\xfb\xd1\xe2\x55\
\xfd\x80\xad\x68\x4e\xf0\x3e\xe0\x2d\xe0\x1f\x81\xab\x90\x11\xfb\
\x08\xf0\x36\x32\x5a\x7b\xa0\x50\xe9\xbf\x01\x6e\x47\x0b\x6a\x3d\
\x61\xe7\x5c\x8a\x0c\xd9\x71\xa8\x9f\xfe\x3b\x60\x33\x5a\x6c\x6b\
\xa3\xdd\xf3\x77\xc8\xb0\xbd\x16\x19\xd3\x7f\x05\x6c\xb7\x34\xb6\
\x02\xdf\x46\x73\x8a\xaf\x43\xc6\xf9\x03\x68\xce\xf2\x4b\x24\x1e\
\x62\xc7\x71\x1c\xc7\x71\x9c\x16\x89\x1b\xc2\x8e\xe3\x38\x0d\xe7\
\x15\xfb\x00\x3c\x99\x39\x1e\x78\xdd\x3e\x69\x56\x20\xc3\x35\xf0\
\xaf\x99\xdf\xcb\xd1\x42\x59\xff\x9c\x39\xfe\x93\xd4\xf7\x03\xc8\
\x18\xfe\x5d\xe6\x9c\x1f\xd8\xdf\x5d\xc0\xbf\x67\x7e\x7b\xc3\x3e\
\x8e\xe3\x38\x8e\xe3\x38\x2d\x1a\x37\x84\x1d\xc7\x71\x9a\x1e\x2b\
\xd0\x7c\x61\xc7\x71\x1c\xc7\x71\x1c\xe7\x38\xe0\x86\xb0\xe3\x38\
\x4e\xd3\x63\x9e\x7d\x1c\xc7\x71\x1c\xc7\x71\x9c\xe3\x80\x2f\x96\
\xe5\x38\x8e\xe3\x38\x8e\xe3\x38\x8e\xe3\xb4\x28\xdc\x10\x76\x1c\
\xc7\x69\x3c\x97\x03\x5f\x46\x2b\x42\x07\x4e\x03\x06\x1d\xc3\xf4\
\x2f\x2f\xf2\x5b\x19\x5a\x75\x7a\xc8\x89\x2e\x04\xc7\x71\x1c\xc7\
\x71\x9c\x93\x05\x37\x84\x1d\xc7\x71\x1a\x47\x6b\xe0\x7d\x68\xe5\
\xe7\x09\x76\x2c\x02\x3e\x01\x8c\x3d\x46\xf7\x98\x08\x9c\x55\xe4\
\xb7\x1c\x5a\x39\xba\xef\x89\x2e\x08\xc7\x71\x1c\xc7\x71\x9c\x93\
\x05\x9f\x23\xec\x38\x8e\xd3\x38\xc6\xa2\xad\x91\xfe\x08\xdc\x88\
\x56\x8c\x1e\x8a\x8c\xd7\x76\xc0\x6c\xa0\x3d\x70\x13\x32\x9a\x9f\
\x47\x5b\x18\x4d\x40\x5e\xe3\x0e\xf6\xfb\x03\xc0\x22\x60\x18\x70\
\xb3\x5d\xfb\x1a\xf0\x34\xda\x37\x38\x46\x06\xf6\xc5\x68\x8f\xe1\
\x43\x68\xab\xa4\x37\x81\x6a\x7c\x4b\x24\xc7\x71\x1c\xc7\x71\x9c\
\x92\x71\x8f\xb0\xe3\x38\x4e\xc3\x89\x80\xab\xd1\x96\x44\xff\x87\
\x8c\xe2\x81\x68\xcf\xdf\x75\xc0\x5c\xa0\x12\xf8\x06\xb0\x1e\x98\
\x0e\x7c\x1c\x38\x13\x18\x0d\x7c\x00\x58\x88\x8c\xda\x7b\xd1\x3e\
\xc4\x7f\x05\xec\x46\xc6\xf2\x87\xd1\x1e\xc4\x35\x68\x15\xe9\x89\
\xc0\xe7\x80\x99\xc0\x1a\xe0\x5b\xc0\x60\xdc\x08\x76\x1c\xc7\x71\
\x1c\xc7\x39\x2a\xdc\x10\x76\x1c\xc7\x69\x38\x5d\x91\x77\xb6\x06\
\x79\x81\xdb\x03\x57\xa0\x3d\x7c\xb7\x00\x4b\x90\x61\x7c\x2a\xd0\
\x1f\x38\x1d\xe8\x8e\x0c\xe1\x3c\x30\x15\x78\x06\x78\x0c\xe8\x86\
\xbc\xc4\x79\xe0\x17\xc0\xb3\x76\xfc\x12\x92\xe8\x9d\x49\x68\x4f\
\xe2\xc7\x81\xff\x05\x36\x00\x67\xdb\xfd\x1d\xc7\x71\x1c\xc7\x71\
\x9c\x12\xf1\xd0\x68\xc7\x71\x9c\x86\x73\x3e\xd0\x09\x79\x65\x07\
\x22\xe3\xf7\x3a\xe0\xb7\xc8\x5b\x0c\x1a\x70\xdc\x8e\xbc\xb8\x55\
\xc0\x52\x60\x31\x9a\xf3\xbb\xdb\xce\x89\x32\x7f\x03\x85\x3c\xbd\
\x71\xe6\x7b\x84\xe3\x38\x8e\xe3\x38\x8e\x73\x54\xb8\x47\xd8\x71\
\x1c\xa7\x61\x54\x00\xd7\x03\x3f\x07\xbe\x80\x42\x9b\x3f\x8b\xbc\
\xc2\xe7\x02\xfb\x81\x31\x28\x84\x79\x3b\xd0\x07\x79\x7b\xaf\x05\
\x3a\x23\x03\x36\xf4\xc1\x91\xa5\xb7\x10\xad\x02\xfd\x01\x60\x32\
\x32\xaa\x5f\xb0\xeb\x72\xc0\x8b\xc8\x03\x7c\x25\xf0\x5e\x60\x00\
\xf2\x10\x57\xe2\x06\xb1\xe3\x38\x8e\xe3\x38\x4e\xc9\xb8\x47\xb8\
\x0e\x6a\xe2\xb8\xd6\xf7\xfa\x26\xe1\xe5\xe3\x38\xf3\xff\x89\x7e\
\x02\xc7\x71\x8e\x23\x6d\xd0\x42\x55\x8f\xa4\x8e\x6d\x06\x7e\x82\
\x8c\xd9\x5f\x23\xa3\xb7\x1a\xcd\xfb\xbd\x11\x18\x0e\x4c\x41\x73\
\x87\x41\xf3\x86\x41\x86\xf2\x93\xc0\x5a\xe0\x2f\x81\x5b\x90\x87\
\xf9\xd7\xc0\x53\xc0\x41\x3b\xef\x35\xe0\xbf\x48\x16\xcb\xfa\x6b\
\xe4\x61\x7e\x1a\x85\x49\x3b\x8e\xe3\x38\x8e\xe3\x38\x25\xe0\x86\
\x70\x01\xf2\x71\xcc\xf0\x6e\xad\xf9\xa7\x6b\x06\xbc\x63\xcc\x96\
\xe7\x60\x60\xe7\x56\x47\x18\xbb\x81\xf2\x1c\x7c\xf4\xac\x1e\x5c\
\x3e\xac\xd3\x3b\xc7\x46\xf7\x68\x7d\xa2\x1f\xc5\x71\x9c\xe3\xc7\
\x6e\xe0\xdf\x32\xc7\x62\xb4\x68\x56\x60\x66\xea\xfb\xa2\xcc\xb9\
\xaf\xa6\xbe\x6f\x40\x06\x2e\x68\x5e\xf1\xb7\x33\xe7\x4e\x49\x7d\
\x9f\x6a\x9f\x34\x3f\x3d\xd1\x85\xe1\x38\x8e\xe3\x38\x8e\x73\x32\
\xe1\x86\x70\x01\xf2\x31\xf4\xeb\x54\xc1\x27\x27\xf6\x78\xe7\x58\
\x8c\x79\x85\x8b\x78\x79\x73\x51\xc4\xd5\x23\x3a\xd5\x8a\x35\xcf\
\xc7\xb5\xbd\xca\x8e\xe3\x38\x8e\xe3\x38\x8e\xe3\x38\xce\x89\xc7\
\x0d\xe1\x22\xc4\x31\x54\x1d\xa5\x11\x5b\x93\x8f\x7d\xe9\x56\xc7\
\x71\x1c\xc7\x71\x1c\xc7\x71\x9c\x26\x8e\x2f\x96\xe5\x38\x8e\xe3\
\x38\x8e\xe3\x38\x8e\xe3\xb4\x28\xdc\x23\xec\x38\x8e\xd3\x70\x26\
\x02\x1f\x42\xdb\x22\xc5\xc0\xdb\xc0\xfd\x68\xfe\xf0\x7b\xd0\x2a\
\xcf\xeb\x8e\x73\x1e\xca\x80\x0f\x03\xd3\x80\xe5\x05\x7e\xef\x03\
\x5c\x8d\xb6\x74\xda\x7f\xa2\x0b\xcc\x71\x1c\xc7\x71\x1c\xa7\x29\
\xe0\x1e\x61\xc7\x71\x9c\x86\x33\x06\x18\x85\x56\x7c\x9e\x02\x4c\
\x40\x5b\x28\xbd\x9b\x7d\x6b\x0e\xb8\x06\xe8\x5b\xe4\xf7\x6e\xc8\
\x10\xf6\xd5\xfb\x1c\xc7\x71\x1c\xc7\x71\x0c\xf7\x08\x3b\x8e\xe3\
\x34\x8e\x95\x24\xab\x3a\x57\x20\x4f\x70\x39\xda\x36\xa9\x06\x18\
\x01\xdc\x84\xf6\x17\x7e\x05\x6d\x75\xd4\xc1\xce\x1b\x64\xd7\x3f\
\x80\xf6\x02\xbe\x09\x19\xb6\x7d\xed\xbc\x17\xed\x58\x3f\xa0\x1d\
\xf0\x7b\xe0\x14\xb4\xc7\xf0\x21\xe0\x09\xb4\x85\x53\x35\xda\x6b\
\xb8\x1d\xda\x7a\x69\x04\xb0\x11\xf8\x83\x1d\xaf\x81\x7a\x77\x80\
\x73\x1c\xc7\x71\x1c\xc7\x69\x31\xb8\x47\xd8\x71\x1c\xa7\xe1\xe4\
\x81\xb1\xc0\xe7\x80\x2f\x00\x1f\x41\x06\x6c\x0d\x32\x56\xfb\x02\
\x9f\x46\xfb\x00\xbf\x00\xdc\x80\x8c\xda\xcf\x21\x4f\xf2\x53\xc0\
\x48\xe0\x1e\xa0\x3b\xf0\x71\xe0\x30\x30\x0b\xb8\x17\x18\x0d\x5c\
\x0c\x5c\x6a\xd7\x8f\xb1\x6b\x5f\x05\x56\x01\xdf\x04\x06\x5b\x3e\
\x62\xbb\xff\xf9\x96\x87\x1e\xc0\x97\x91\x27\xd8\x8d\x60\xc7\x71\
\x1c\xc7\x71\x9c\x14\x6e\x08\x3b\x8e\xe3\x34\x9e\x08\x19\x9b\xdb\
\x80\x33\x90\xc7\xb7\x06\x79\x6a\xb7\x00\x93\x80\xf1\xc0\x43\x76\
\xde\x04\xe0\x67\xc0\x4b\x68\x0f\xe0\x31\x40\x2f\x60\x3e\x9a\xcb\
\xfb\x10\xda\x4f\xf8\x6c\x64\x18\x3f\x87\x8c\xdf\xd3\x80\xd7\x51\
\x28\xf6\x6f\x80\xf5\x68\x9e\x72\xf0\x06\x5f\x08\xfc\x0a\x79\x92\
\x7f\x0c\x0c\x41\xc6\xb8\x1b\xc2\x8e\xe3\x38\x8e\xe3\x38\x29\x3c\
\x34\xda\x71\x1c\xa7\xe1\xe4\x80\x05\xc0\x7f\xd8\xff\x7d\x81\x5f\
\x02\x03\x48\xbc\xb4\xbf\x44\x46\xec\x99\xc0\x9f\x02\xff\x6d\xbf\
\x15\xa2\x50\x08\x73\x4c\xb2\xc8\x55\x54\x42\x9e\xdc\xe8\x75\x1c\
\xc7\x71\x1c\xc7\xa9\x07\x37\x84\x1d\xc7\x71\x1a\xc7\x20\xe0\x0a\
\x64\xdc\x4e\x04\x76\x20\x2f\x70\x39\x0a\x4b\xfe\x04\xb0\x0c\x79\
\x7f\xcf\x04\xf6\x02\x73\x80\xbb\x91\xe7\xf7\x46\xe0\x2d\x60\x13\
\x30\x0e\xb8\x0d\xd8\x89\xbc\xb9\x3f\x03\x4e\x25\x89\xde\x79\x01\
\x85\x51\x5f\x05\x74\x01\xfa\x03\x3f\xb0\x34\x0e\x00\x2f\x03\x1f\
\x40\x2b\x49\x5f\x86\xe6\x1f\x6f\x40\x73\x97\x4b\x31\xa2\x1d\xc7\
\x71\x1c\xc7\x71\x5a\x04\x6e\x08\x3b\x8e\xe3\x34\x9c\x45\xc0\x62\
\xe0\x3a\xfb\x7f\x03\xf0\x17\x68\xa1\xaa\xb0\x75\xd2\xef\xd0\x82\
\x57\xc3\x50\xd8\xf3\x33\xc0\x74\xb4\x58\xd6\x35\x68\xcb\xa5\x3f\
\x00\xbd\xd1\xbc\xdf\xae\xc8\xb8\xfe\x0e\x0a\x8f\x7e\x05\x19\xc9\
\xd8\xf7\x0a\x14\x6a\x7d\x08\xf8\x6b\x60\x29\x5a\xac\x6b\x03\x32\
\x9c\x6f\x01\xae\xb4\x6b\x7e\x88\x0c\xe0\xa7\xd0\x3c\x65\xc7\x71\
\x1c\xc7\x71\x1c\x07\x37\x84\x1d\xc7\x71\x1a\xc3\x6b\xf6\x29\xc4\
\xef\xec\xef\x7a\x60\x61\xe6\xb7\xc3\x28\x44\x3a\x4d\x3f\xe4\x09\
\xfe\x2f\x64\xe4\x06\xfe\x98\xfa\x5e\x83\xe6\x0b\x3f\x97\xb9\x36\
\x9d\xd6\x2f\x0b\xe4\xe5\x7f\x4e\x74\x41\x39\x8e\xe3\x38\x8e\xe3\
\x34\x25\x7c\xb1\x2c\xc7\x71\x9c\xa6\xc1\x36\xe0\x79\x7c\x8e\xaf\
\xe3\x38\x8e\xe3\x38\xce\x71\xc7\x3d\xc2\x8e\xe3\x38\x4d\x83\x0d\
\x68\x25\x68\xc7\x71\x1c\xc7\x71\x1c\xe7\x38\xe3\x86\xb0\xe3\x38\
\x4e\x43\xb9\x77\x5a\xed\xff\x63\x92\x25\xa9\xbe\x37\xf9\xdd\xb9\
\xef\xd1\xdc\xe7\x9e\x69\xa9\x25\xb3\xaa\xa9\x25\x02\x1a\x92\xdf\
\xec\xf3\x87\x42\xf8\xde\x42\xd6\xfb\x35\x00\x00\x80\x00\x49\x44\
\x41\x54\x25\xc9\x6f\x11\xf0\xdd\xc9\xa5\xa7\x93\xce\x47\x43\x9f\
\xb3\x31\xd7\x36\xe6\x9e\x8e\xe3\x38\x8e\xe3\x9c\x34\xb8\x21\xec\
\x38\x8e\xd3\x70\x4e\x43\xab\x42\x3f\x41\x1c\x3f\x0e\xd1\x00\xe0\
\x73\x68\x9f\xdf\xe7\x6a\x1b\x9e\xc8\xb0\x2a\x68\x3c\x16\xfb\xad\
\x0d\x7c\xef\x9c\xcc\xf1\x18\xa0\x15\xf0\x59\xb4\x42\xf5\xcf\xb8\
\xf7\x39\xde\xb9\x51\x30\x3c\xbf\x3a\xad\xf6\xf2\x58\x71\x1e\x62\
\x22\x22\x26\x00\x95\x50\xf1\x0a\xc4\xb7\xa3\x95\xa7\xbf\xcf\xbd\
\xd3\xaa\x20\x86\x43\xd5\xd0\xaa\x82\x24\xb1\xbc\xfe\xc6\xb1\x3e\
\xff\x7e\x69\x36\x2f\x7d\x21\x7a\x3f\x30\x14\x98\x85\xe6\x46\xef\
\x02\xba\x01\x1f\x23\xe6\xb7\xdc\x3b\x6d\xd5\x91\x0f\x6c\x06\xb3\
\x98\x00\x7c\x18\xf8\x4f\xee\x9d\xb6\x38\x75\x52\x7b\xe0\x5e\xb4\
\x28\xd9\x1f\x8e\x28\x87\x70\x7d\xfa\x78\x0c\xfc\xdb\x64\xd0\x4a\
\xda\x67\x00\xdf\xe3\xde\x69\xbb\x92\x1f\x33\x8b\x67\x1f\x59\xee\
\xfd\x81\xcf\x03\x0f\x00\xaf\xd6\xfa\xad\x14\xa3\xde\x71\x1c\xc7\
\x71\x9c\x93\x02\x9f\x23\xec\x38\x8e\xd3\x70\x06\x23\xc3\xf7\xaf\
\x89\xa2\x7e\x68\xc5\xe7\x8f\x03\xa7\x73\xef\x34\x88\x29\x43\xab\
\x41\xf7\x03\x2a\x65\xb0\x52\x0e\xf4\x01\x3a\xdb\x6f\x3d\x89\xc8\
\x99\xc1\xd5\x06\x38\x05\xed\x43\xdc\x96\x78\x7f\x30\xd2\xda\x22\
\x03\xad\x1b\x51\x2b\xd0\xca\xd1\xb7\x02\x57\xd9\x7d\x42\x9a\x7d\
\x80\x72\xee\x99\x26\x23\x38\xa6\x83\xa5\xd5\x83\xb8\x26\x47\x8e\
\xc1\x68\x61\xad\xdb\x21\xee\x00\xac\x45\xab\x56\x77\x40\x7b\x20\
\x97\xd3\xae\x35\x40\x77\xa0\xa7\x19\xba\x6d\xde\xb9\x77\xeb\xd6\
\xf0\xf9\x67\x53\x8f\x1f\xb5\x86\xe8\x6f\xad\x0c\x4e\x01\xfe\x19\
\xa2\x0f\xd8\x8f\x43\xd1\x0a\xd6\xd5\x10\x57\x58\xfa\xdd\x2d\xbd\
\x3e\x68\x8b\xa7\xc0\x30\xe0\xd3\xc0\x08\x2b\xab\xce\xc4\xef\xdc\
\xfb\x7d\xc0\x85\x56\x0e\x39\xa0\x17\xd0\x8f\x98\xd6\xdc\x3b\x8d\
\xd4\xf1\x9e\x96\xcf\xf6\x76\xec\x5c\xe0\x83\x96\x46\xd8\x6a\xaa\
\x1c\xa8\xb4\xef\x2a\xe3\x7b\xa7\x61\xf7\xea\x64\xf7\x1e\x68\xef\
\x70\x94\xfd\xd6\xda\xce\xef\x41\x39\x11\xf7\x4c\x3b\xd1\x75\xce\
\x71\x1c\xc7\x71\x9c\x63\x80\x7b\x84\x1d\xc7\x71\x1a\x4e\x1e\xad\
\xf0\x7c\x06\xf0\x11\xe0\x31\xa0\x0a\xad\xee\xdc\x86\x1c\x5f\x04\
\xee\x42\xc6\xd7\xb3\xc0\x5f\xda\xf7\x5f\xd9\x79\x3d\x01\x88\xf9\
\x0b\x60\x06\xf0\xf7\xc8\x58\xec\x0c\x6c\x20\x8a\xbe\x84\x8c\xde\
\x7f\x04\xce\x06\xb6\x11\x1f\xfe\x3b\xb4\x6a\x74\x0d\x8a\x6f\x6e\
\x4d\x14\xfd\x99\xdd\x07\x62\x7e\x03\xfc\x0b\x30\x98\x88\x6f\xa3\
\x7d\x88\x77\x91\x2b\xff\x0f\x64\x70\x9e\x8a\x8c\xc0\x05\xc8\xe8\
\x3b\x0d\xe8\x08\x7c\x09\xa2\x8f\x50\x5d\xb3\x0a\xf8\x05\x30\x13\
\xe2\xff\x81\xe8\xef\x80\x73\x88\xa2\xad\x1c\x3e\xfc\x0f\xc0\x23\
\x24\x0b\x7a\x75\x02\x2e\x44\x5e\xe0\xf0\x69\xcf\x17\x9f\x83\x98\
\x33\x81\x35\x10\xef\x81\xe8\x6b\x68\x7f\xe3\xad\x68\xbb\xa9\x8e\
\xc0\xc7\xd0\x2a\xd9\xa1\x1c\xf3\xc0\x57\xd1\x60\xc2\x5a\xa2\xe8\
\xcb\x68\x3b\xa9\x6a\x7b\xd6\x56\xc8\xe0\xfe\x10\xd0\x86\x28\x9a\
\x0e\x7c\x0b\x6d\x51\xf5\x71\xe0\x4f\x80\xf6\x44\x2c\x00\xfe\xdc\
\xae\x3b\x8c\x0c\xf2\x6f\xa2\x6d\xa6\xfe\x1e\xf8\x33\x60\xb4\xa5\
\xb7\x1c\xf8\x73\xa2\xa8\x3f\xf0\xcf\x68\x60\x63\x2d\x32\xd2\xab\
\x81\x9e\x44\xd1\xdf\x03\x17\x03\xbb\xa9\xe2\x5f\xd1\x16\x58\xf9\
\x13\x5d\xf1\x1c\xc7\x71\x1c\xc7\x69\x1c\xee\x11\x76\x1c\xc7\x69\
\x38\x11\xb0\x0f\x78\x1d\x19\xc2\x13\x91\x91\x54\x03\x5c\x8b\x8c\
\xae\x07\xd1\x9e\xc0\xb7\x40\xf4\x49\x34\x00\x39\x10\x19\xbb\xff\
\x8e\xbc\x95\x37\x01\xe7\x00\xb7\xa1\x90\xdc\x7f\x52\x9a\x71\x8c\
\x8c\xbc\x8b\x81\xbf\x01\xd6\x20\x63\xba\x4f\xea\x3e\x17\x03\x5f\
\x40\x0b\x6d\xfd\x16\xf8\x3c\x11\x93\xec\xde\xc3\x91\xb1\xb8\x08\
\xa2\x73\xd0\x1e\xc6\x9b\x81\x87\xd0\xde\xc3\xbd\x91\xb7\x73\x3e\
\x32\x4e\x2f\x41\x86\xf1\x04\x60\x26\x44\x1f\x43\x86\xee\xff\x43\
\xdb\x40\x7d\x93\xb2\x5c\xb7\xd4\xf3\xe7\x90\xd1\xd8\xd5\xee\x53\
\x05\xbc\x40\x44\x0e\x38\x5d\xe9\x46\xa7\x03\xf7\xa0\x70\xf1\x87\
\x81\xf7\x02\xdb\x88\xa2\xdd\x99\xb2\x2c\x43\x86\xe9\xdf\x23\x83\
\xfd\x1e\x34\x08\x80\x3d\xeb\x25\xc0\xd7\x2c\xdf\xff\x00\x5c\x86\
\x42\x98\xc7\x02\xdf\x40\xdb\x58\xfd\xa3\xe5\x65\xac\x5d\xd3\x39\
\x39\x16\xff\x3b\x44\x39\xbd\xaf\xf8\xef\xac\x2c\x6e\x05\xc6\x20\
\x23\x7a\x9c\x9d\xbb\x1c\x79\xe0\x63\x64\xbc\x5f\x6b\xf7\x7b\x13\
\x19\xd4\xfd\x4e\x60\x7d\x73\x1c\xc7\x71\x1c\xe7\x18\xe1\x1e\x61\
\xc7\x71\x9c\xc6\x51\x0d\xfc\x18\xb8\x87\x88\x4f\x23\x4f\x63\x8c\
\x8c\xc9\xcd\xc0\xf7\x89\xf3\x5b\x89\x72\x37\x20\xa3\xf5\x8f\xf6\
\xfb\x63\x68\xcf\xdf\x0f\x02\xad\x81\x15\xc8\x08\xfb\x36\x32\xba\
\x1e\x32\xc3\x6d\xa2\xdd\x67\x82\x9d\xd7\x13\x19\x63\xc1\x2b\x7b\
\x1a\xd0\x0e\x79\x33\x63\x64\x9c\x9e\x6b\xc7\xa7\x02\xbf\x86\xf8\
\x01\x9b\x1b\xdb\x01\x05\x4d\x2f\x47\x9e\xcf\xc0\x4a\x60\x1a\x70\
\xb5\xa5\xb3\x0e\xe2\x59\x10\x7d\xca\x7e\x3f\x0b\x85\x18\xf7\x86\
\xa8\x3f\xf2\xec\x06\x22\x9d\xcf\x7f\x00\xdf\x05\x3e\x4f\x3e\x5a\
\x89\x8c\xd9\x87\x90\x81\x59\x0d\xfc\x27\xb0\x09\x78\x3f\x32\xe8\
\xf3\x99\x34\xf6\x02\x3f\x22\x8a\x5e\x22\x8e\xaf\x00\x46\x22\xef\
\x39\xf6\x5c\x67\x02\xbb\x81\x7f\xa3\x86\xb5\x94\x31\x19\x38\x1f\
\x58\x86\x0c\xd7\x5f\x03\xcf\x13\xf3\x5b\x22\x0e\x00\xe3\x95\x5f\
\xfa\x00\xff\x47\x1c\xad\x24\xa2\x42\xcf\x1e\x7d\xdc\xd2\xc7\xca\
\x74\x24\xf0\x32\x51\xf4\x33\xe2\x78\x3e\x0a\xe9\xae\xb4\x7b\x86\
\x32\x6e\x0f\x74\x25\x62\xa8\xe5\xdf\x71\x1c\xc7\x71\x9c\x93\x18\
\x37\x84\x1d\xc7\x71\x1a\x47\x0e\x58\x02\xfc\x00\x79\x78\x2b\x91\
\xe1\xb6\x17\x19\xa8\xbd\x20\xaa\x46\x8b\x47\xad\x41\x5e\x53\x80\
\xfd\x24\x2b\x37\x45\xc4\xf1\x12\xa2\xe8\xd3\x28\x04\x7a\x32\xf2\
\x8c\x46\xc0\x1e\xb4\xf8\xd4\x34\x14\x12\x7d\x08\xcd\xeb\x0d\x11\
\x3d\xfb\xec\xd8\x6c\x64\xd0\x3e\x8a\x8c\xea\x2b\x80\xde\xc4\xb4\
\x25\x8a\x46\x21\xef\xe8\x72\x4b\xb3\x82\x1c\x39\x33\x45\x23\x14\
\x42\xfc\x08\x32\xe8\xc7\xa3\xd0\xe8\x4d\xc8\x68\x0e\xf7\x7e\xc1\
\xfe\xcf\x2e\x7c\x95\x03\x06\x12\xb3\xd8\xc2\x92\xaf\x44\x06\x64\
\x1b\x92\x30\xe8\x72\xa0\x3f\xc4\x87\x21\x6a\x07\x94\x65\x76\x4b\
\x8e\xd1\x00\xc2\x40\xf2\xf9\xd9\x44\x51\x37\x7b\xae\xb4\xb1\xbc\
\x07\x19\xbc\x7d\x28\x63\x37\x32\x72\x77\x01\xdb\x91\x37\xb9\x27\
\xd0\x8e\x88\x8b\x20\x7e\xdb\x8a\x76\x3b\xf2\xc8\x5f\x49\xc4\x85\
\x96\xa7\x7f\x42\xde\xeb\x05\x28\x14\x3b\x6f\xef\xa2\x2b\xf9\x7c\
\x7b\xa2\xa8\x8f\xbd\xc3\xbc\xbd\xc3\x7d\xc0\xcb\x56\x06\xff\x6d\
\xd7\x39\x8e\xe3\x38\x8e\x73\x92\xe3\xa1\xd1\x8e\xe3\x38\x0d\x47\
\x46\x25\xe4\x88\xe3\xdf\x01\x2f\xda\xb1\x72\x62\x9e\x02\x0e\x00\
\x3f\x21\x8a\x7e\x83\xe6\xe5\xde\x87\x8c\x56\x5d\x23\xca\x80\x1c\
\x51\x34\x01\x85\x3f\x97\x23\xa3\x73\x17\xda\x5b\xf8\x21\x34\x6f\
\xf8\xa3\xc0\x17\x81\x6b\x50\x48\x74\xb9\x7d\xa6\xa1\xb0\xe5\xf7\
\x03\x9f\x01\x3e\x41\x1c\x1f\x04\xfe\x00\x5c\x44\xc4\xef\x50\xc8\
\xf4\x9f\x23\x03\x6f\x27\x70\x07\x79\xde\x67\xf7\x2e\xb7\xbc\xcc\
\x40\xc6\x6f\x67\xe0\x09\x88\x6a\x90\x71\xdc\x13\x85\x67\x7f\x11\
\xb8\x92\x98\x43\x99\x32\xa8\x01\xae\x20\xe2\xb7\x28\xb4\x7b\x36\
\xf2\x58\xef\x22\x62\x1d\xf0\x0a\x32\xc0\xbf\x0b\xd1\x4f\xd0\x80\
\xc0\x08\xe2\xb8\x32\x95\x46\x0e\x19\xc2\x7f\x41\x14\xfd\x0e\x38\
\x0f\x19\xf4\x07\x93\xe7\x8c\x9f\x46\x9e\xe8\x1f\x01\xff\x87\xbc\
\xb4\xf2\x02\xc3\x3c\x14\x32\xfe\x5b\x95\x71\x74\xb1\xa5\xb9\x03\
\x19\xbe\x0b\x50\x18\x75\x57\x3b\xde\x05\x79\xda\xdb\xd9\x7d\x1f\
\x06\xce\x22\x8a\xee\xb7\x77\xd0\xce\x9e\xeb\x51\x64\x7c\x7f\x0c\
\x85\x6a\xdf\x48\x1c\x57\x9f\xe8\x4a\xe7\x38\x8e\xe3\x38\x4e\xe3\
\x71\x8f\xb0\xe3\x38\x4e\xc3\x59\x81\xbc\xa8\xeb\x29\x2b\xdb\x49\
\x3e\xff\x97\xc0\x5b\xc0\x7c\x0e\x55\xcd\xa1\x55\xc5\x87\x88\xb8\
\x19\x79\x22\xbf\x43\x9c\x7f\x9a\x28\xd7\x19\xf8\x19\xda\x6a\xa8\
\x06\x19\xac\x3b\x81\x85\xc8\xb0\x3b\x03\x79\x23\xff\x9c\x98\x47\
\x88\x88\x91\xc7\xf4\x42\xe4\xa1\x7c\x10\x19\xc9\x7f\x00\x76\x50\
\x5e\xb6\x88\xea\x9a\x4f\x00\xef\x41\x61\xbe\x2f\x10\x45\xab\x81\
\x1f\x22\x43\xf0\x1c\x64\x9c\xde\x8f\xc2\x88\xff\x1a\xb8\x1c\x79\
\x58\xa7\x22\xef\x72\x0d\x51\xcd\x16\xe2\xb2\x7f\x45\xab\x3f\xcf\
\xe6\x7b\x93\xe1\x9e\xa9\xbf\x25\x8a\x0e\x43\x74\x11\x0a\xd7\x7e\
\x80\x7c\xfe\xe0\x91\xc5\xc0\xe3\x28\xd4\x7a\x21\x71\xfc\x73\xa2\
\x68\x28\xf0\x6b\x6a\x38\xcc\x0d\xac\xe6\x31\x3e\x03\xdc\x89\x42\
\x9b\x7f\x02\xf4\x87\xa8\x12\x79\xa2\x41\x0b\x59\xfd\x13\x0a\xb1\
\x1e\x05\x3c\x06\xf1\xaf\x20\xca\x5b\x99\x2c\xe2\x70\x87\x45\x54\
\xee\xfd\x90\x3d\x67\x47\x2b\xf7\xc7\x2d\x8d\x4f\xa1\xd5\xa5\x7b\
\xa0\xd0\xf3\xdf\x22\xaf\x7a\x15\x1a\x24\xf8\x5b\xe0\x06\x2b\x87\
\x6f\xa2\xb0\xed\x17\xed\xfd\xed\x21\xe2\x7f\xcd\x43\x7d\xba\xa5\
\xd9\xdb\xca\x65\x36\x5a\xa0\xeb\x32\x34\xa8\xf1\x28\x11\x7b\x4e\
\x74\xa5\x73\x1c\xc7\x71\x1c\xa7\xf1\xb8\x21\xec\x38\x8e\xd3\x70\
\xe6\x01\x5f\x06\xe0\xd0\x21\xa8\xa8\x78\x19\x85\xd1\x42\x79\x0e\
\x22\x66\x20\x4f\xab\x11\x01\x6c\x43\xa1\xb9\x81\xef\xa5\xbe\xff\
\xd2\x3e\x59\x7e\x63\x9f\x34\xdf\x05\xa0\xba\x06\xe4\x75\x7d\xa5\
\xc0\x75\x3f\xb7\x4f\x9a\x07\xed\x53\x9b\x38\x0a\xf7\x27\x99\x7e\
\xcc\x41\x88\x52\xf7\x8e\xd3\xbf\x05\x2a\x81\xd5\xc8\xc0\x0e\xa7\
\x2d\x26\x42\xfe\xe6\x47\x81\x88\xd7\xd1\x82\x62\x09\xb5\xe3\x91\
\x66\xdb\x27\xc5\x3b\xfb\xfd\xfe\x9d\xee\xb2\x07\x88\x0a\x9c\x07\
\x68\xf0\xe1\x5b\x99\x63\x8f\xda\x07\x60\xba\x7d\x40\x03\x0e\x99\
\x67\x07\x64\xa0\x17\xe2\x8f\xf6\xb1\x6c\x45\x38\x8e\xe3\x38\x8e\
\x73\xf2\xe3\x86\xb0\xe3\x38\x4e\x43\xf9\xde\xe4\x13\x9d\x83\xe3\
\xcb\xbf\x5d\x5a\xdf\x19\xfb\x90\x77\xfb\xf5\x46\x95\x45\x73\x2f\
\x47\xc7\x71\x1c\xc7\x71\x9a\x1c\x6e\x08\x3b\x8e\xe3\x38\x0d\x65\
\x37\x47\x7a\x62\x1d\xc7\x71\x1c\xc7\x71\x9a\x3c\x6e\x08\x3b\x8e\
\xe3\x38\x0d\xc3\x3d\xb9\x8e\xe3\x38\x8e\xe3\x9c\xa4\xb8\x21\xec\
\x38\x8e\xd3\x38\xba\xa1\x95\x9c\x87\xa3\x85\x9b\x9e\x46\xf3\x61\
\xe3\xc6\x24\x5a\x0f\xd7\xa1\x85\x9e\x3a\xa3\x15\x8e\xd7\x03\x63\
\xd1\x82\x58\xf9\x02\xe7\xdf\x84\xf6\x34\x7e\xa5\xc4\xf4\x1d\xc7\
\x71\x1c\xc7\x71\x9a\x35\xbe\x7d\x92\xe3\x38\x4e\xc3\xe9\x8a\x16\
\x89\x1a\x80\x56\x1b\x5e\x04\x7c\x1d\x98\x74\x9c\xef\x7b\x26\x30\
\x08\x19\xbd\x79\x60\x30\x70\x31\xa9\x15\xa6\x32\x9c\x8b\x56\x63\
\x76\x1c\xc7\x71\x1c\xc7\x71\x70\x8f\xb0\xe3\x38\x4e\x63\xb8\x0c\
\xe8\x00\x7c\x07\xde\xd9\x5f\x37\x02\x7a\xa1\xfd\x67\xaf\x45\x9e\
\xda\x08\x78\x12\x6d\x99\x74\x3b\x32\xa0\x5b\xdb\xf1\xdf\xa3\x7d\
\x76\x47\x01\x67\xd9\xff\x57\xd9\xf7\x6d\xc0\x03\x68\x55\xe6\x71\
\xc0\xcd\x68\x6f\xdd\x41\xc0\xab\x24\xcb\x38\xc7\x68\x2b\x26\xd0\
\xf6\x4b\xd7\xa2\xbd\x8a\x5f\x44\xfb\x0c\xd7\x50\xd8\x53\xec\x38\
\x8e\xe3\x38\x8e\xd3\x22\x71\x8f\xb0\xe3\x38\x4e\xc3\x39\x1d\x58\
\x42\x62\x04\x83\x0c\xd7\xfb\x81\xf1\xc8\x13\xfb\x18\xb0\x0a\xf8\
\x33\x14\xca\xfc\x1e\xb4\x57\xef\xb3\xc8\x20\xbe\x16\x19\xc4\x37\
\xd9\xef\xd7\xa0\x3d\x6f\x9f\x00\xf6\xa3\xed\x99\x86\x00\x5f\xb1\
\x74\xde\x04\x46\x22\xc3\x76\xb4\xdd\x27\x78\x86\x87\x00\xdf\x40\
\xfb\x05\x4f\x07\x3e\x03\x9c\x4f\x62\x24\x3b\x8e\xe3\x38\x8e\xe3\
\x38\xb8\x47\xd8\x71\x1c\xa7\x31\xe4\x29\x1c\x8e\x1c\xa1\xfd\x6a\
\x73\x28\x6c\xba\x2f\xf2\x12\x77\x00\xf6\x22\x23\x77\x36\xf2\xda\
\x7e\x12\xe8\x0f\x8c\x01\xfe\x19\xf8\x13\xa0\x23\x32\x60\x3b\x20\
\x4f\xf1\xc5\x40\x15\xf0\x5b\x64\x74\x9f\x67\x69\x07\x03\x38\xe4\
\x65\x02\x9a\x0b\xfc\x5b\xe4\x25\x1e\x0b\x5c\x4a\xf1\x90\x69\xc7\
\x71\x1c\xc7\x71\x9c\x16\x89\x1b\xc2\x8e\xe3\x38\x0d\x67\x0e\x70\
\x0b\x0a\x73\x3e\x68\xc7\xae\x04\x06\x02\x7b\x90\x67\xf7\x79\xb4\
\x98\xd5\x21\x64\xbc\x1e\x26\xf1\x20\xcf\xb7\xff\x3f\x84\xc2\xa0\
\xdf\xb6\x73\xde\x42\x1e\xdd\x72\x60\x06\x32\x6a\xd3\xfd\x75\x5d\
\x86\x6d\x94\xf9\x7e\x3c\x17\xed\x72\x1c\xc7\x71\x1c\xc7\x39\x29\
\xf1\xd0\x68\xc7\x71\x9c\x86\xf3\x1c\xb0\x0f\x85\x2d\x5f\x00\xdc\
\x0a\x7c\x1a\xd8\x88\xc2\x9f\x77\x01\x73\x81\xde\xc8\xbb\x1b\x21\
\x83\x36\xf4\xbd\xfb\xd1\x5c\xdf\xbb\xd1\x7c\xde\x43\x96\xe6\x60\
\xe4\x2d\x1e\x06\x5c\x01\x2c\x46\xe1\xcd\x1f\x02\x6e\x44\x73\x93\
\xb1\x74\x72\x96\x6e\x05\x30\x13\xe8\x0e\xbc\x1f\x85\x5c\x9f\x6f\
\xe9\xe5\xf0\xfe\xde\x71\x1c\xc7\x71\x1c\xe7\x1d\xdc\x23\xec\x38\
\x8e\xd3\x70\x76\x02\xdf\x42\x46\xe7\x95\xc8\x2b\xfc\x2f\x68\x9b\
\xa2\xd7\x81\xbb\x90\x21\xbb\x08\xf8\x09\x70\x00\x98\x02\xac\x4b\
\xa5\xf1\x34\xd0\x03\x78\xc9\xfe\xff\xa3\x9d\x37\xc9\xfe\xfe\x37\
\xda\x2a\xe9\x6f\x91\xf7\xb9\x0b\x70\x1f\xb0\x12\xd8\x81\xb6\x4f\
\xda\x04\xbc\x60\xe7\xfd\x8d\xe5\x67\x30\xf0\x1f\xc8\xb3\xdc\x09\
\xd8\x72\xa2\x0b\xcb\x71\x1c\xc7\x71\x1c\xa7\xa9\xe0\x86\xb0\xe3\
\x38\x4e\xe3\xd8\x02\xfc\xa2\xc0\xf1\x0d\x68\x35\xe9\x2c\xff\x9b\
\xf9\x7f\x1d\x9a\x1b\x1c\xa8\x02\x1e\xb1\x4f\x9a\xa5\x99\xf3\xb2\
\xbc\x69\x7f\xe7\xd9\x27\xcd\xa3\x27\xba\x90\x1c\xc7\x71\x1c\xc7\
\x71\x9a\x12\x1e\x2a\xe7\x38\x8e\xe3\x38\x8e\xe3\x38\x8e\xe3\xb4\
\x28\xdc\x10\x76\x1c\xc7\x71\x1c\xc7\x71\x1c\xc7\x71\x5a\x14\x6e\
\x08\x3b\x8e\xe3\x38\x8e\xe3\x38\x8e\xe3\x38\x2d\x0a\x37\x84\x1d\
\xc7\x71\x1a\xce\x79\x68\xc5\xe7\x52\xfa\xd2\x73\xd0\x9e\xbe\xa5\
\xd0\x0d\x38\x17\x28\x2b\xf2\x7b\x5f\xe0\x33\x68\xdb\xa6\x42\x84\
\x15\xac\x1d\xc7\x71\x1c\xc7\x71\x9c\x02\xb8\x21\xec\x38\x8e\xd3\
\x70\x46\x22\xe3\x36\x2a\xf1\xdc\x71\x25\xa6\x3b\x11\xb8\xb3\x8e\
\xdf\xbb\x02\x57\xa3\x2d\x93\x0a\x31\x1a\x19\xe9\x8e\xe3\x38\x8e\
\xe3\x38\x4e\x01\x7c\xd5\x68\xc7\x71\x9c\x86\x13\xa3\xfd\x7d\xd3\
\x44\xc0\x19\x68\x3b\xa5\x8e\xc0\x12\xe0\x77\x40\x35\x32\x86\xbf\
\x6a\xe7\xfc\x1e\x78\x1b\x18\x82\xbc\xb7\x9d\x80\x19\xc0\xf3\xc8\
\xb8\xbe\x00\xed\x17\x3c\x1b\xb8\x19\x18\x84\xb6\x53\xba\x1f\xc8\
\xdb\x7d\x63\x60\x20\x70\x3b\xd0\x19\xad\x16\xfd\xb0\xfd\x96\xcd\
\x97\xe3\x38\x8e\xe3\x38\x8e\x63\xb8\x47\xd8\x71\x1c\xe7\xd8\xd2\
\x01\xb8\x03\xed\x1d\xfc\x08\xda\xfb\xf7\x3c\x64\xb4\x8e\x42\xfb\
\x0b\xef\x01\xbe\x82\x8c\xd8\xaf\x03\xdb\x81\x27\xec\xdc\x8b\xed\
\xda\xe5\xc0\x42\x64\x50\xf7\x02\xfe\x80\x06\x2f\x3f\x89\x42\xa6\
\x63\x64\x68\x7f\x13\x38\x6c\xd7\x5f\x03\xdc\x66\xbf\x39\x8e\xe3\
\x38\x8e\xe3\x38\x45\x70\x8f\xb0\xe3\x38\xce\xb1\x65\x1f\xf0\x2b\
\xe4\xc1\x1d\x83\x3c\xbd\x7d\x90\x87\xf6\x49\xe0\x59\x60\x0e\x70\
\x91\x7d\xc6\x01\x6b\xd0\xbc\xe0\x2e\xc0\x04\xe4\x05\xde\x08\xac\
\x07\xa6\x02\x63\x81\x11\x40\x0f\x14\x16\x5d\x81\xbc\xc2\x43\xed\
\x9a\x9f\x03\xbb\x91\x61\x7c\x23\x30\xf7\x44\x17\x82\xe3\x38\x8e\
\xe3\x38\x4e\x53\xc6\x0d\x61\xc7\x71\x9c\xc6\x11\xc2\x94\x03\x7d\
\x90\x97\xf7\x4d\xe4\xd1\xdd\x86\xa2\x6f\x0a\x85\x2a\xc7\xc0\x4e\
\x60\x3a\xb0\x17\x98\x0f\xac\x43\x46\x34\xc8\xf3\x7b\x37\x0a\x9f\
\x7e\x09\x58\x8b\x0c\xdf\xf4\xf5\x11\xc9\x1c\xe5\x08\xf7\x06\x3b\
\x8e\xe3\x38\x8e\xe3\xd4\x8b\x1b\xc2\x8e\xe3\x38\x8d\x63\x20\x0a\
\x49\xae\x41\xf3\x80\x0f\x21\xcf\xed\xeb\x40\x2b\x60\x00\x32\x84\
\x73\xc0\xf5\xc0\x1b\xc8\x53\xbc\x11\x78\x11\xcd\x03\x1e\x69\xc7\
\xaf\x47\x73\x7c\xf7\xa2\x70\xe8\x61\xc8\x08\x5e\x0e\x2c\x03\xce\
\x07\xda\x59\x5a\x15\x76\x6c\x0b\xf0\x71\xe4\x45\xbe\x13\x79\x9d\
\x5b\x53\x7c\xc5\x69\xc7\x71\x1c\xc7\x71\x9c\x16\x8f\xcf\x11\x76\
\x1c\xc7\x69\x38\x0b\x81\x05\xc8\x98\xbd\x12\x2d\x72\xb5\x09\xf8\
\x3e\x32\x5a\xbb\x03\xdf\x43\x86\xec\x22\x14\x32\x3d\x0e\x79\x91\
\xff\x11\x58\x0d\xfc\x15\x32\x5a\x2f\x45\x0b\x65\xbd\x88\x8c\xda\
\x57\x50\xe8\xf3\xbf\xd9\xef\xe7\xa1\x79\xc0\x0f\xa1\x39\xc5\x8f\
\x20\x6f\xf3\xdf\x00\x55\xc0\x24\xe0\x01\x34\x97\xf8\x4d\x4b\xc7\
\x71\x1c\xc7\x71\x1c\xc7\x29\x80\x7b\x84\x1d\xc7\x71\x1a\xce\x4c\
\xfb\x64\x59\x8a\x0c\xd6\x2c\xb3\x0b\x1c\x5b\x85\x8c\xdd\x34\x07\
\x32\xc7\x16\x16\xb8\x6e\xb9\xfd\x5d\x0b\xfc\x7b\xe6\xb7\x19\x27\
\xba\x60\x1c\xc7\x71\x1c\xc7\x71\x9a\x32\xee\x11\x76\x1c\xc7\x71\
\x1c\xc7\x71\x1c\xc7\x71\x5a\x14\x6e\x08\x3b\x8e\xe3\x38\x8e\xe3\
\x38\x8e\xe3\x38\x2d\x8a\xf2\x88\xb0\x8a\x4b\x44\x3e\xf2\xc5\x46\
\x9d\xe3\x47\x04\x44\xd1\x3b\xff\x7a\x65\x73\x4e\x16\x62\xbc\xbe\
\x3a\x4e\x53\x21\x8f\xb7\x49\xc7\x69\x2c\xa1\x1d\xe5\x4f\x74\x46\
\x1c\xe7\x04\xf0\x8e\x0c\x89\x7a\xb6\xaf\x38\x70\xc5\xb0\x8e\xad\
\xdb\x56\xe4\x5c\xaa\x38\xc7\x95\x08\xa8\xc9\xc7\x4c\x5b\xb1\xe7\
\xe0\xf2\xed\x87\x1e\x45\x8b\x0a\x39\x4e\x53\x67\x22\xb0\x07\x78\
\xeb\x44\x67\xc4\x71\x1c\xca\x81\x8b\xd1\x22\x75\x9b\x4f\x74\x66\
\x1c\xe7\x24\xa5\x0d\x6a\x47\x2f\x01\xfb\x4e\x74\x66\x1c\xe7\x5d\
\xa6\x1d\x30\x02\xb8\xbb\xbc\x73\xeb\xb2\xea\x4b\x86\x74\xa0\x4b\
\x9b\x72\x37\x84\x9d\xe3\x4e\x55\x4d\xcc\xe2\xad\x07\xab\x97\x6f\
\x3f\xb4\x12\x58\x81\x87\xe7\x3b\x4d\x9b\x3c\x30\x18\xad\xce\xfc\
\x26\x5e\x5f\x1d\xe7\x44\x53\x01\x9c\x06\xac\xb4\x8f\xb7\x49\xc7\
\x39\x3a\x62\xa0\x03\x70\x06\xf0\x36\xb0\x8b\x64\x2f\x7a\xc7\x69\
\xee\xc4\x40\x67\xa0\x1f\x50\x5d\xde\xb9\x75\x59\xcd\xc5\x83\x3b\
\xd0\xab\x7d\x85\x1b\xc2\xce\x71\x25\x02\x0e\x55\xe7\xf9\xc3\x82\
\xed\xd5\xc0\x5c\x60\x3e\xae\xc4\x38\x4d\x9b\x1a\x60\x2c\xb0\x1e\
\x6d\x47\xe4\x7b\xf3\x3a\xce\x89\xa5\x15\xf2\x64\xcd\x45\x5e\x61\
\x97\x21\x8e\x73\x74\xc4\x40\x57\xb4\x65\xdf\x6b\x68\x2f\x7a\x37\
\x84\x9d\x96\x42\x0c\xf4\x00\xc6\x03\xf9\xf2\x18\xa8\x89\xa1\x26\
\x8e\x89\xdd\x12\x76\x8e\x33\xd5\x79\xc8\xab\x9e\x95\xd9\xc7\x95\
\x18\xa7\xa9\x93\xb3\x4f\xa8\xb3\x8e\xe3\x9c\x38\x72\x48\x69\x77\
\x19\xe2\x38\x0d\x23\x46\x6d\x27\xdd\x8e\xdc\x10\x76\x5a\x0a\xe9\
\xfa\xef\x02\xc4\x71\x1c\xc7\x71\x1c\xc7\x71\x1c\xc7\x69\x59\xb8\
\x21\xec\x34\x35\xb2\xab\x81\xe6\x0b\xfc\x7e\x34\x69\xbd\x9b\xf9\
\x2e\xf5\xfe\x47\x9b\x2f\x8f\xd5\x68\xfa\x34\x64\x15\xdb\xc6\xae\
\x7c\x9b\xbe\x3e\xfb\xf7\x58\xde\xc7\x71\x9a\x2b\x71\x81\xff\xe3\
\x3a\x7e\x2f\x76\x6d\xbe\xc8\xf5\xd9\x74\xc3\x27\x4f\xe3\x65\xd9\
\x89\x92\x6f\xc5\xca\xa8\x3e\x79\x77\xa2\x56\x27\xf6\xbe\xef\xf8\
\x53\xa8\xde\x37\xd7\x72\x4f\xd7\xf7\xfa\xea\xfe\xf1\xb8\x57\x43\
\xd3\x70\x8a\xe0\x86\xb0\xd3\x94\x88\x81\x2b\x81\xf3\x48\x14\x85\
\xf3\x80\x0f\x01\xed\xd1\x2a\x6f\xe7\x97\x90\x4e\x1e\x18\x05\x5c\
\xc2\xbb\x23\x7c\x2b\x80\xdb\x80\xde\x24\x9d\x4e\x99\x3d\x4b\x5f\
\x6a\x2b\x02\xa3\x81\x6b\x8e\x22\xed\x3c\x30\x09\x38\xf5\x5d\x7a\
\x16\xe7\xe8\xc9\x03\x17\x00\x9f\x00\x5a\x53\x9a\xe0\xc9\xa3\x05\
\x7f\xce\x29\xf1\xfc\x42\xd7\x8f\x07\xce\x06\x86\x03\xd7\x01\x9d\
\x80\x1b\xd0\x6a\xa0\xe9\x3a\x77\x9e\xdd\xcb\xeb\x8f\xe3\x24\x54\
\x02\xef\x05\xfa\xa3\xb6\xd1\x11\xf8\x1c\x70\xa6\xfd\x5f\x0e\xdc\
\x0a\x0c\xa4\x70\xdb\xb9\x1e\xad\x3a\xda\xca\xd2\xf9\x00\x5a\x7c\
\xe8\xb3\xa8\xcf\x0e\xe4\x91\xdc\xfa\x3a\xf0\x65\xfb\x7c\x14\x18\
\x40\xfd\x6d\x3f\x06\x7a\x02\x57\x23\x39\x13\x8e\xf5\xb0\xbc\x1d\
\x6f\x1d\x2e\xc8\xe0\xb4\x2c\xbd\x1e\x78\x9f\x95\x4f\x1e\xad\xaa\
\x7f\x99\x9d\x33\x94\xda\x83\x02\x5d\x80\x9b\x50\xbf\x38\x1e\xe8\
\x56\xc2\x33\x1f\xcb\xbc\xb7\x43\x7d\x63\xfb\x77\xf1\xbe\x2d\x8d\
\x3c\x70\x2e\x70\x17\x49\x1d\xcd\x51\x77\xdb\x39\x59\x69\x83\xea\
\x73\x47\x60\x10\x30\x04\xd5\xed\x9b\xed\xd8\xb1\xac\x63\x39\xe0\
\x2a\xa4\x43\x9e\x0f\x9c\xce\xd1\x95\x65\xe8\x3b\xae\x45\x6d\xd5\
\x29\x82\x1b\xc2\x4e\x53\x63\x1c\x52\xec\x6b\x90\x71\xf1\x21\x60\
\x19\x52\x36\x2e\x45\x46\xe4\x79\xd4\x56\xf6\xa1\xf6\xde\x92\x35\
\x68\x35\xb8\x31\xf6\x3d\xbd\x57\x5e\xfa\xbc\xf4\xa8\x7c\xf6\x38\
\x99\x73\xea\x3a\xb7\x1c\x09\x82\x2e\xa9\x73\x72\xc8\xf8\xe8\x64\
\xe7\x84\x4f\x7f\xa4\x10\x44\x25\xde\x33\x18\xcf\xfd\x53\xcf\xe2\
\x34\x2d\xda\xa0\x41\x8f\x8b\x50\x9d\xab\xeb\x5d\xa6\x8f\x9d\x82\
\x04\x69\xfa\x37\x28\x5c\x47\xb3\x69\x01\x54\x03\x55\x48\x50\x4e\
\xb0\xe3\x87\x53\xe7\x87\x73\x87\xd9\xbd\xb2\xe9\x79\x5d\x72\x9a\
\x23\x41\x06\xd4\x57\xbf\xab\x51\xfb\x1b\x67\xdf\x87\x23\x63\xee\
\x42\xd4\x3f\x77\x43\x6d\xba\x9a\xc2\xde\xdc\x09\x68\xf0\x73\x90\
\x7d\x7f\x1d\xc9\xa6\x6a\x60\x61\xea\x3e\x79\x60\x24\x92\x09\x4f\
\x03\xcf\x00\x6d\x81\x4f\x22\x25\xba\x2e\x39\x10\x0c\xf4\xf1\x68\
\x70\x35\xfd\xfb\xa1\xcc\xb9\x75\xc9\x91\x74\x5e\xb2\xf2\xac\xd8\
\xb9\xe1\xfc\xd6\x68\x71\xb2\x0a\x64\x50\x4e\x06\xae\x40\x8b\x2d\
\x61\x65\xd4\x0e\xc9\xa9\x1e\x1c\xd9\xd7\x1d\x42\x83\x0e\x77\x20\
\xc5\x3c\xfd\x7b\xb1\x7d\x6c\x8b\x95\x09\x99\xef\xf5\xc9\xe8\x4a\
\x34\x38\xd1\x9a\xba\xcb\xa2\x94\x3e\xbb\xae\xfb\x35\x47\x42\x3b\
\x2a\xe5\xbc\xa1\xa8\x3e\x5f\x68\xe5\x12\xa1\x01\x92\xee\x14\x96\
\x63\xe1\x3a\x32\xdf\x8f\xa6\xde\x16\xd3\xe5\x8a\xe5\xb1\xbe\x7b\
\x95\x2a\x7f\x83\x8c\xbd\x02\x39\x28\x6a\x50\x1d\x8f\x4b\x48\x33\
\x5d\xd7\x8a\x91\xbe\x6e\x1c\xea\x87\x0e\xa3\x7e\xa5\x50\xfe\x48\
\xfd\x1f\x67\xee\xd3\x09\x19\xd0\x11\xa5\xd5\xe3\xfa\xda\x65\xb3\
\xc4\x47\x09\x9c\xa6\x46\x1e\x35\xf8\xf1\x68\x94\xed\x97\xc0\x74\
\x24\xc8\x96\x22\xa5\x7f\x39\xea\x18\xc2\xe2\x0e\x65\x48\x18\x8f\
\x43\xfb\xe1\x4d\xb1\x34\x7a\x03\x1f\x44\x06\xea\x34\xb4\xfd\xcd\
\x48\x34\xba\xd6\x01\xd8\x00\x3c\x81\x8c\xcc\xd3\x91\xa0\xef\x64\
\xe7\x2e\x46\x1d\x5d\x5b\x24\xdc\x77\x03\x8f\xdb\xdf\xb3\x81\xb3\
\x2c\x0f\x2f\x00\x6b\x29\xae\x78\x5d\x88\xbc\x03\x1b\xed\x5e\xe9\
\x8e\x70\x1c\x32\xf6\x23\x60\x0e\x52\xa4\xda\xa2\xd1\xf5\x81\x76\
\xcd\x93\x96\x76\x0d\x52\x3c\x6e\xb0\xf2\x58\x81\x2f\x6e\xd1\x14\
\xc8\x23\x05\x3a\x07\x3c\x8b\x14\xc6\x39\xa8\x6f\xbd\x04\xd5\xdb\
\x01\xa8\xce\xee\x42\x4a\xd9\x5a\xe0\x51\xf4\x4e\x07\x03\x1f\xb3\
\xeb\x9f\x01\x56\xa1\x55\xaa\xcf\x41\xca\xe5\x1a\xe0\x29\x54\x5f\
\x2f\x47\x75\x60\x15\x52\xa8\x23\xbb\x2e\x08\xad\xf0\x3f\x48\x39\
\xbf\x12\xb5\x83\x53\xd0\xca\xa0\x65\xa8\xbe\x9d\x06\xec\x47\x75\
\x77\x39\x5e\x8f\x9c\xe6\x43\x58\x0d\xb7\x3f\xaa\xdb\x7b\x29\x5e\
\xbf\xab\x80\x45\xa8\xad\x94\x21\xd9\xf0\x34\xd0\x07\x19\x9f\xfd\
\xd1\xb6\x69\x5b\x90\xa1\x7b\xae\xa5\xff\x3a\x6a\xe3\x35\xa8\xbf\
\xbe\xc2\xae\xb9\x04\xb5\xef\xcd\x48\x8e\xa4\x57\xe2\xcd\xa3\x76\
\xfb\xaa\xfd\xbf\x05\xf8\x2a\xda\xc2\x63\x34\x92\x27\xad\xd1\x56\
\x36\x53\x91\x41\xdd\x1f\xf5\x23\x2b\x2c\xaf\x20\x23\xb4\x35\xf0\
\x06\x6a\xeb\x6d\xec\xfe\x11\x92\x77\x6b\x90\xfc\xeb\x84\xfa\x8b\
\x6e\x56\x0e\xcf\xda\xf5\xc1\x6b\xbb\xcb\xee\xb3\x03\x79\x9d\x22\
\x7b\x86\xd0\xb7\x1c\xb6\xf3\x73\xc0\x12\x34\x00\xdd\x11\x19\xb2\
\xdb\x2d\xff\x23\xd0\xfe\xea\x5d\x51\x7f\xd6\x17\xc9\xd1\x53\x2d\
\xbf\x8f\xdb\xdf\xc8\xce\x1d\x69\xf7\x5a\x6b\x79\x9d\x64\xe5\x3e\
\x1b\x98\x49\x6d\xf9\x79\x9a\x95\x77\x85\x95\xd9\x7a\xd4\xb7\x3e\
\x82\x64\xfc\x24\xe0\xa0\x95\x5f\x7b\x12\x19\xfd\x18\xea\xdb\x26\
\x5b\x3e\xf6\xa2\x41\xf4\x0a\xe0\x16\xd4\xa7\x56\x5b\x19\x9d\x81\
\x06\x2e\xf7\x22\x99\xbf\xde\xf2\x87\xd5\x89\x25\x76\x8f\x71\x56\
\x2e\x4f\x5a\x3a\x41\x3e\x6f\x46\x7d\xf6\x76\x9a\x67\x1f\xda\x17\
\xe9\x4e\x4b\x49\xea\x43\x31\x6a\x50\x5b\xba\x01\xe9\x4e\x1b\x48\
\x8c\xaa\xf6\xc8\x89\x71\x8a\x1d\x9b\x06\xac\x43\x65\x1d\xca\xef\
\x72\x3b\xb6\x15\xc9\xad\x6e\xc0\x6a\xfb\xbd\x0a\xe9\x51\x63\x50\
\x7d\x9b\x8a\xea\xd0\xa9\xa8\x8e\x04\x39\x39\x05\xbd\xfb\xf4\xbb\
\x88\x51\x5d\x0b\x75\x67\x3f\xaa\x3b\xfb\xd0\xd6\x6b\x57\x22\x63\
\x7d\x15\x6a\x23\x9d\x50\xdb\xab\xb4\x67\x9f\x89\xe4\x77\x5f\xcb\
\xf7\xdb\x96\x7e\x4f\x14\x39\xb2\x0f\x78\x8b\x44\xf6\x5e\x6d\xf9\
\xe9\x61\x79\x0d\x3a\xe3\xc5\xa8\x6d\x6c\x40\xed\xf7\x29\x7b\xd6\
\x42\xf5\xe6\x74\x7b\xde\xbd\x56\x0e\x79\x92\x05\x02\xdb\xa0\xba\
\x3d\xd8\xfe\x7f\xc9\xde\xcf\xb5\xa8\x9e\x1f\xb6\xfb\x75\xb5\x67\
\x58\x61\xe5\x7f\x8b\xe5\x69\x2e\xd2\x1f\xdb\xa3\x7e\xa3\xaf\x95\
\xfb\x54\x7b\x96\xf3\x91\xfe\x51\x01\xcc\xb3\x73\x4b\x19\x0c\x39\
\xa9\x71\x8f\xb0\xd3\xd4\x88\x91\xe0\xf9\x12\x6a\xc4\xd3\x51\x3d\
\x3d\x84\x3a\xa1\x3f\x00\x9b\x48\x1a\x67\x1e\x19\xa6\x57\x00\x2f\
\x23\x01\x7f\x09\x52\x20\x06\x20\x6f\xf2\x7a\x14\xca\xd5\x15\x09\
\xb1\xb5\xa8\xd3\x3b\xdb\x3e\x7d\x50\x87\xb8\x04\x19\x9f\xef\x43\
\x9d\xd9\x79\xc8\x63\xf0\x22\x12\xe4\x21\x44\xf9\x16\xa4\x0c\xad\
\x40\x86\x76\x4f\x0a\xcf\x8f\x69\x8f\x04\xf5\x4b\x48\xd9\xb9\x96\
\xc4\x68\x19\x08\x7c\xd8\x9e\xe9\x0d\x34\x5a\x7e\x2a\x0a\xe3\x1a\
\x8e\x3a\xa6\x4e\x96\xbf\xa0\xdc\xdd\x6d\x69\xaf\xa7\x79\x0a\xde\
\x93\x91\x08\xd5\x93\xc5\x48\x81\x1c\x8c\xa2\x11\x40\xf5\xb0\x2f\
\xaa\xc3\xb7\x22\xe5\x6e\x3a\xaa\x47\xa3\xec\x9c\x53\xd0\x16\x30\
\x7b\xd0\xfb\xed\x89\x94\x82\x65\x48\xf0\x5e\x68\xd7\x05\x0f\xcc\
\x73\xa8\x2e\x0e\xb6\x6b\x87\x91\x8c\xe0\xb6\x45\x0a\x7b\x57\x54\
\xb7\x76\xa0\x2d\xca\x42\x7e\x26\x22\x41\x3d\x1d\xb5\xa1\x0f\x51\
\x3b\x8a\xc1\x71\x4e\x76\x2a\x80\x4f\x01\xdf\x47\xe1\xca\x75\xf5\
\x93\x11\x52\x62\x7b\x21\x85\x73\x20\xea\xab\x0f\x21\x43\x68\x30\
\xea\x9f\xfb\xa3\xb0\xe7\x37\x91\xa7\xf7\xfd\xa8\x0d\xc6\xc8\x50\
\x5a\x84\x94\xf6\x69\xc8\xe8\x5c\x80\xe4\x08\xd4\x6e\x5b\x5d\x91\
\x3c\x19\x81\xe4\xd0\x4e\x24\xa7\x2e\x45\xed\x74\x3a\x32\x38\x87\
\xa1\x81\xe0\x71\xc0\x0c\x24\xd3\x72\x76\xde\x64\xcb\x73\x5b\x24\
\x1b\x5a\xa1\xbe\xa1\x3d\x92\x7f\x93\xec\xba\xab\x51\xdb\x0e\xfd\
\xc5\x20\x24\xe3\x26\x02\xcf\x23\xf9\xf9\x31\x3b\xe7\x0a\x24\xef\
\x5e\x46\x7d\xd6\x69\x24\x5e\x70\x90\xd1\xbb\x0b\xf5\x23\x23\x51\
\xdf\xb4\xc0\xbe\xf7\xb1\xb4\xd6\x22\x05\xbf\x8f\xe5\xb9\x9b\x3d\
\x4b\x5b\xbb\xe7\x76\xd4\xe7\xcc\x43\x06\xf5\xdd\x56\x56\xaf\x03\
\x37\x92\x44\xd2\x84\x7e\xec\xfd\xc8\x38\x59\x80\x06\xef\x72\x56\
\x26\x43\x91\x31\x70\x29\x32\x90\xce\xe7\x48\x19\x3d\xde\x9e\x75\
\xba\x9d\xd3\x3d\x55\x7e\x9d\x90\x61\x7d\xbe\x3d\xeb\x8b\xc8\x70\
\xf8\x84\xe5\xf9\x52\xfb\xfb\x9a\xd5\x9f\x61\x76\xfe\xa5\x76\xef\
\x1b\x90\x7c\x7e\xc6\xf2\x71\x17\xcd\xcf\xa1\x14\xa3\x81\xd7\xaf\
\x01\x3f\xb0\x32\xad\xcf\x3b\x18\x59\x99\x2d\xb2\x72\xab\x24\xd1\
\x75\x4e\x43\x6d\xeb\x19\x24\x93\xde\x87\xf4\xa2\xb3\xd1\xbb\xce\
\x23\xdd\xa7\x37\xaa\xb7\x3d\x50\xbd\x1d\x62\x9f\x0b\x91\x21\xf9\
\x02\xaa\x87\x1f\x42\x72\xf2\x32\x12\x39\x79\x31\xb6\x15\x4e\x81\
\xbc\xed\xa7\x76\xdd\xb9\xcc\x8e\xdf\x6d\xf7\x9f\x8a\xe4\xf1\xcd\
\xa8\x8d\xde\x84\xea\xf3\x0e\x34\x55\x62\x1b\x32\x16\x6f\x43\xf5\
\x67\x22\x6a\x1f\xab\xed\x79\xf7\xd8\xb1\x76\xc8\x30\x1f\x8e\xfa\
\x91\x21\x76\xaf\x71\x48\xf7\x9b\x61\xe5\x74\xb3\x9d\x9b\x95\xbb\
\x79\xd4\xc6\xde\x8f\xfa\x9a\x75\xa8\x3d\x85\x88\x92\x01\xf6\x77\
\x84\xe5\x79\x3d\xea\x97\x3a\x59\xb9\x95\x01\xb3\x90\x21\x3d\x16\
\xd5\xdb\x9d\x48\x07\xd9\x85\x8c\xe0\x5b\xed\x1e\xb7\x59\xda\xcf\
\x58\x59\xde\x62\xc7\xcf\xb5\x7c\x06\x9d\xb4\x77\x09\xef\xfe\xa4\
\xa7\xb9\x35\x60\xe7\xe4\x27\x87\x84\xf6\xfd\x48\x50\x8d\x47\x0d\
\x38\x87\x3a\x9f\xec\x7e\x77\x11\x1a\x99\x9b\x8d\x84\xea\x3c\x54\
\xaf\x2f\xb2\xef\xaf\x20\x45\xe6\x5c\x3b\xfe\x04\x89\x01\xd1\x01\
\x75\xba\x9b\xd0\x08\xff\x0c\xd4\xf9\x5c\x84\x84\xfa\x5e\xd4\xe1\
\xcc\x41\x1d\x75\x1f\xbb\xa6\x8b\xfd\x5f\x8e\x3a\x8f\xfe\x1c\xd9\
\xa9\x45\x76\xfd\x14\x34\xaa\xd8\x01\x09\x94\xb9\x24\x1d\xff\x16\
\x64\x90\x87\x8e\xee\x02\x4b\xeb\x77\xa8\x23\x5a\x62\x69\x0d\x01\
\x6e\xb7\xf3\xbf\x8e\x94\x2f\x1f\xc4\x3a\xf1\x84\x39\x70\x67\x22\
\xa5\x6b\x28\x89\x30\x7c\x08\x09\xc8\xe7\x91\x50\xdb\x82\xea\xe7\
\x4c\x24\x14\x3b\xdb\xf5\xaf\xd8\x67\x09\xf2\x0a\x75\x40\xde\x95\
\xfe\x24\x75\xb4\x3b\xaa\xa3\x67\x23\xa5\x73\x1e\x12\xd4\x21\xac\
\x3a\x4d\x88\x84\x68\x83\x46\x9d\xb7\x23\x45\x04\x4b\xbf\x23\x12\
\x94\xad\x50\xdd\xed\x4d\xf3\xf5\x68\x38\x2d\x8f\x18\x19\x3f\x55\
\x24\xa1\x84\xc5\x88\x90\x87\xa6\x1a\x29\xab\x65\x48\xb1\x5e\x8e\
\xda\x4c\x6f\xd4\x7f\x8f\x43\x1e\xa7\x69\x96\xfe\xa9\x48\x2e\xc5\
\x24\x32\x69\x3b\x1a\x0c\xdb\x8a\x14\xe4\xfe\xc8\x68\xca\xa1\xbe\
\xa0\x06\xb5\xdf\x6e\x76\xdf\x1d\xc0\x2f\x90\xc1\xfc\xb8\xdd\x6b\
\x00\x89\x7c\xc9\xa3\xbe\x62\x3e\x52\xd2\x47\xa3\x01\xb7\x9f\x20\
\x0f\xd0\x28\x4b\x33\xb2\xfb\x4f\x45\x86\xe3\xa5\xc8\xb0\xdf\x88\
\x06\xc5\x6a\x2c\x8d\x2d\xc8\x00\x99\x82\x64\xe5\x4a\xe0\x9b\x96\
\xcf\x4d\x76\xfd\x6a\x92\xc1\xbb\xdb\x90\xc2\xbd\x1d\x45\x65\xad\
\x46\x32\xaa\x3f\xea\xd3\x76\x5b\xfa\xa7\x59\xd9\xec\xb3\xb2\x78\
\x1e\x29\xe3\x3d\xec\xf7\x9c\x3d\xcb\x6e\xfb\xac\x46\xf2\x77\x20\
\x92\xf3\x35\x48\x91\x1f\x81\xfa\xb5\x9c\xbd\xbb\xcd\x96\x97\x85\
\xa8\x7f\xdc\x88\x64\xe7\x99\xf6\xcc\x61\x60\x7c\x3f\xb5\x65\x74\
\x5f\x64\xcc\xcc\x45\x86\xc0\x6a\xd4\x4f\xe6\x90\xdc\x7c\xc9\xde\
\xef\x7b\xed\xfb\x4c\x7b\x6f\x67\xd8\x79\x3b\x90\x71\xbc\x06\x19\
\x40\x33\x50\xff\x7d\xa5\xbd\xa3\x09\xf6\xac\xe1\x5d\x0e\x41\xc6\
\xd4\x6e\x9a\x57\x1f\x9a\x6e\x47\xa5\x78\x04\xc3\x54\xaf\xdf\x03\
\xdf\x40\x86\x69\x8c\xca\x7d\x21\xc9\xe0\x7f\x2f\x24\xfb\x5a\x53\
\x3b\x8a\x2e\x0c\x82\x6c\x40\x65\x5b\x65\xd7\xad\x43\xf2\xb2\x3d\
\x7a\x47\xed\x90\x9c\x6d\x8b\xbc\xff\x03\xec\xff\x20\x27\x0b\xe5\
\x6b\x17\xd2\xa7\xce\xb0\xfc\x1c\x46\xef\xb9\x0f\xf0\x2b\x24\x4b\
\x41\xed\x63\xb9\x7d\x5e\x44\x75\x7b\x1c\x1a\x20\xea\x8f\xe4\x67\
\x2b\xcb\xf7\x01\xd4\x36\x36\x20\x3d\x2f\xe4\xff\x00\xea\x27\x66\
\x21\x83\xb8\x3f\x92\xb9\x6f\xa0\x7a\xfc\x16\xd2\x0f\x0a\xd5\x95\
\xd8\xae\xd9\x85\x06\x02\x2a\xec\x9e\xa1\x0d\x81\xea\x7c\x70\xf2\
\xf4\x46\x75\xbd\xad\x3d\xcf\x2b\xf6\xfb\x21\xbb\xff\x1b\xc8\x20\
\x5e\x49\xd2\x77\x5d\x61\x79\x3a\x03\x19\xd2\x67\xdb\xfb\xe8\x09\
\xfc\x11\xe9\x0c\x3d\x2d\xed\x4e\x96\xf7\x66\x8f\x1b\xc2\x4e\x53\
\xe4\x19\x64\x08\xc7\x68\x51\x91\xbf\x25\x31\x80\x8b\x09\x9b\x10\
\x22\xda\x16\x09\xec\x0a\xd4\x29\xc5\xa9\xdf\xba\xa0\xd1\xb6\x75\
\xc8\xf0\x48\x1b\x00\xfb\x49\xc2\x4f\xb0\xbf\x55\xa8\x53\x29\x4b\
\x1d\x03\x75\x20\xb3\xec\xf8\x12\xa4\x80\x14\xca\x57\x94\x49\x2f\
\x3b\x17\x23\x7d\xbf\x74\x67\x17\xf2\xdb\x8d\x64\x34\xfb\x79\x92\
\x70\x96\xdf\x9d\xe8\x17\xe4\x00\xc9\x82\x55\xad\x91\x40\xea\x8c\
\x94\xca\x0b\x90\x20\x3b\x84\x84\x6e\x19\xc9\x7c\xab\xec\x3e\xc4\
\xe9\xfa\x11\x16\xb7\xb8\x0e\x45\x1b\x2c\x47\x23\xba\x65\x48\x61\
\xdb\x88\x8c\xe3\xeb\x90\x42\x50\x2c\x5c\x2d\xa6\x76\x98\x74\x94\
\x3a\xbe\x9a\xa4\xee\x2e\xc2\xa3\x0b\x9c\xe6\x45\x35\x32\x16\x1f\
\x46\x0a\x6e\x68\x0b\x85\x88\x90\x01\xb3\x09\x19\x5d\xab\x90\x91\
\xb3\x18\x19\x4a\x07\xec\xd8\x10\x6a\xb7\xd3\x74\x5f\x1d\x8e\x85\
\xe3\x61\x5f\xd6\x8d\x48\x8e\x05\x63\x3b\x4c\x9d\xb8\x8f\x64\x50\
\xb7\x1a\xc9\xaa\xbb\x91\xe7\x73\x3d\x1a\x3c\x0b\xf7\x3a\x94\x4a\
\x7b\x2b\x32\x62\x2f\x42\xc6\x59\xfa\xfe\x07\x91\xac\x0a\x72\x23\
\x87\x8c\xc0\x0d\xc8\x48\xb8\x1e\xc9\xbe\x1a\x6a\xf7\x09\xa1\xcf\
\x39\x68\x79\x09\xbf\xe5\x91\x12\xbd\x8a\xa4\x0f\x0b\x61\xaf\xb1\
\x1d\x3f\x68\xdf\x27\xa2\xc1\xe5\xe0\xfd\x0b\x83\xb4\xc5\xe4\x61\
\x60\x1b\x32\x5e\xab\x90\x61\xbf\x3a\x73\xff\xdf\x91\xac\xf3\xf1\
\x51\xa4\xe8\xbf\x66\xdf\x3b\x23\xa3\xf9\x00\xc5\x65\x74\x39\x47\
\xf6\x83\x61\x0d\x85\x74\x39\xa5\xf3\x16\x8c\xbf\x74\x9f\x9d\x2e\
\x97\xf0\xff\x62\x7b\x5f\xad\xd1\x00\xe8\x01\x9a\x57\x1f\x1a\x06\
\xf1\xff\x01\x19\x43\xab\x28\x6d\xe0\x3d\x0c\xca\xdc\x8f\x3c\x95\
\x6d\x50\x99\x5f\x8e\x06\x10\x66\xa0\x3a\x39\x84\xe4\xdd\x84\xbf\
\x6d\x49\xe4\xdc\x16\x3b\xe7\x5a\x24\x57\x6b\x90\x3c\x9c\x45\x12\
\xb2\x9b\x43\x11\x0d\xcb\xd1\xe0\xd5\x4e\x6a\xbf\xa7\xec\xfb\x78\
\x1d\x79\x92\xbb\xa3\xba\xbd\x8f\xda\x6d\x20\xfd\x7c\x07\x49\xf4\
\xb3\xc3\x99\xf3\x82\xfe\x96\xd6\xed\xd2\xc7\x42\x7d\xcc\x51\xdb\
\x39\x92\x95\xfb\xa4\xae\xcd\x86\x72\x67\xf5\xd0\x40\x1e\x0d\x30\
\x5c\x44\xd2\xbe\xc3\xd4\x83\xc3\x24\x7d\x40\x98\xb3\x1c\xf6\xc9\
\x3d\x44\x6d\x3d\x38\x9c\xbf\x08\xb5\xbd\xb0\xde\xce\x08\xe4\x70\
\x99\x85\x06\xa2\x0e\x94\xf8\xde\x4f\x7a\x5a\xc4\x43\x3a\x27\x15\
\xa1\x91\x82\x46\xca\x37\x22\x45\xa1\xd8\x6a\xbc\x31\x12\x90\x13\
\x50\x27\x71\x1b\x1a\xe5\x82\xda\xf5\x3b\x87\x3a\xdb\x6e\x48\x90\
\x55\xa1\x11\xc1\xb4\x12\x43\xe6\xba\x6c\x87\x94\x43\x23\xcd\xed\
\x91\x62\xd1\xc3\xee\x59\xce\x91\x1b\xd2\xc7\x68\x34\xed\x3a\x14\
\xda\x33\x19\x75\xc0\x35\xa8\x33\x5f\x60\x69\x5c\x83\xc2\x67\xc6\
\xa2\x91\xc7\x39\x68\xee\xcc\xb9\x48\x98\x04\xa1\xf1\x16\xf0\x1b\
\x4b\x6b\x2c\x2d\x20\x5c\xe5\x24\xa0\x15\x7a\x1f\x0f\x03\xff\x02\
\x7c\xc7\xfe\xb6\x22\x59\x10\x2d\x3d\x8f\x3d\x3d\xe8\x11\x7e\x0b\
\x73\xc8\x6f\x40\xc2\x67\x1f\x52\xf4\xde\xb2\x73\xfb\xd8\xf9\x97\
\x23\xa5\x73\x19\x52\xdc\x43\x1a\x69\xe5\x1b\x54\x17\xd7\x23\xc5\
\xe0\x26\x54\xef\x42\x68\xe1\x4c\x54\x67\x3b\x20\x25\xf3\x7c\x5c\
\x06\x38\xcd\x8b\xe0\x01\x5a\xcc\x91\xf3\x05\x0b\x51\x83\xda\xd4\
\xd9\x48\x29\x8c\x91\x07\xa5\x07\x52\x88\x77\x21\xc5\xbb\x1f\xea\
\x97\xaf\x40\x83\x51\x73\x49\xda\x74\x5a\x7e\xe4\xec\xb3\x0d\x29\
\x94\x33\xed\x7b\x30\xac\x82\xc2\x1a\x14\xd2\x4e\x48\x11\x5d\x84\
\xe4\x42\xcf\x54\x1a\xe9\x34\xb7\xa2\x39\x8e\x9b\x91\x8c\xab\xa0\
\x76\xdb\x4f\xf7\x33\xa1\xbf\x38\xd3\x9e\x6d\x0b\x92\x17\xaf\x22\
\x59\x73\x3e\x0a\x91\xdc\x85\x06\x85\xd3\x0e\x91\xd0\x8f\xbc\x6d\
\x79\x5f\x60\x65\xb4\x0a\x85\x8a\xef\xb5\xeb\xf6\x59\x9e\x06\x59\
\xb9\xa5\xfb\x22\x38\xb2\x4c\xf2\x96\xce\x28\x34\x40\xb1\x0f\x79\
\xa6\xda\xa2\x3e\x2a\xac\xea\x1c\xa3\x41\xbe\xbb\x90\xfc\x5c\x84\
\x14\xf2\x32\x64\x2c\xef\x43\x5e\xba\xd9\x05\x9e\x3d\xdc\x7f\xb6\
\x9d\x73\x29\x1a\x04\xe8\x67\xe9\x86\x73\xab\x91\x61\x74\xa1\x7d\
\x6e\xb6\xdf\x57\x58\x59\x14\xeb\xb3\x0f\xd9\x7b\x1f\x6a\xe5\x7f\
\xaa\x7d\x9a\xeb\xd4\x92\x2d\xa8\x1e\xd4\x17\x59\x01\xc9\xfb\xce\
\xa1\xb2\x9d\x8f\xda\x09\x48\x86\x6d\x47\xef\xaf\x0f\x7a\xe7\xfb\
\x50\x3b\xb8\x04\xbd\xff\x51\x24\x46\xf3\xd9\x24\x72\x0e\xd4\x8e\
\xfa\xd9\x75\x83\x90\x1c\x0c\x3a\x58\x90\x93\xbd\xd0\x7b\xe8\x8f\
\xa6\xab\xa5\x17\x53\xcd\xd9\xbd\x0f\x23\xb9\x3c\x07\xb5\xc9\xb5\
\x28\x24\xf8\x3c\x24\x7f\xe7\xa3\x3e\x23\xb4\x87\xb4\x5c\x4d\xd7\
\xb5\xd0\x96\x0f\xa1\x36\xd1\x99\x23\xdb\x7f\xfa\xfb\x4c\x34\xa0\
\x33\x19\x19\xf7\xa7\x58\x99\x4e\x40\xd3\x02\xd2\x75\xec\x2d\x54\
\xff\xaf\x45\x7d\xcd\x58\x6a\x1b\xc7\x7d\xd0\x60\xd9\x0a\x7b\xe6\
\xb6\x14\x6e\x07\x69\x43\x3c\x3d\xf8\x55\x6e\x65\xbf\x00\x79\x9f\
\xcb\xad\x4c\x86\xa3\x41\x87\x08\xf5\x9d\x9d\xec\xd3\x9c\x06\x78\
\x8a\x52\xd6\xaf\x63\xe5\x57\x6f\x39\xb5\x4b\xeb\xf6\x95\xae\x0f\
\x39\xc7\x9f\x9a\x3c\x3c\xbe\x78\xd7\xc1\x45\x5b\x0e\x3e\x89\x84\
\x7a\xb6\xa1\xb5\x42\x8a\x7c\x08\x59\x5b\x86\x1a\xff\x3a\x0a\x2f\
\x7c\x12\x46\xdc\xf7\x22\xe1\xb7\x17\x19\x26\x87\xec\xfb\x6a\x92\
\x4e\x62\x2e\x32\xac\xc7\xd8\xb5\x73\xec\xff\xcd\xa8\x73\x59\x97\
\x3a\x77\xb1\xfd\x5d\x63\xe9\x54\xa2\x51\xe9\x59\x48\x01\x18\x8b\
\x04\x75\x08\x49\xab\x40\x42\x23\x3d\xd2\x08\xf2\x38\x0c\x41\x1d\
\xcf\x54\x4b\x7f\x2f\x32\x8a\x57\x23\x01\xd0\x15\x2d\xc4\xb1\x00\
\x8d\x70\xb6\xb6\x3c\x2e\x45\x5e\x85\x32\x24\x14\x96\xd8\x73\xb5\
\xb2\x7c\x39\xc7\x9f\x18\x85\x27\xed\x41\x75\x22\x3d\xea\xdc\x16\
\x09\xe3\x17\x48\x94\xb5\x83\xf6\xbd\x1a\xd5\xcb\xd5\x48\xb8\xb6\
\x42\x75\x79\x8f\x7d\x5f\x65\xdf\x77\x20\xe5\xb7\x1a\x85\x26\x85\
\x30\xc3\xd1\x48\x70\xcf\x25\x09\x0b\x1c\x80\x04\xd6\xdb\xa8\x5e\
\x80\x0c\xde\xad\x76\x4d\x58\x40\x6d\x09\x52\x20\x07\x22\x85\x7e\
\x91\xe5\x7d\x1e\x52\x62\xc7\x22\x45\xe1\x19\x54\xe7\x5b\x84\xb0\
\x73\x9a\x0d\x65\xc8\x80\x59\x44\x61\x19\x12\x51\xbb\x0f\xae\x8b\
\x08\xb5\xd7\x43\xc8\xbb\x17\xbc\xab\x61\x0a\xc2\x3a\xd4\x66\xd6\
\xa2\x3e\xb9\x13\x9a\xba\xb0\x18\xf5\xd3\xab\x50\x1f\x7f\x88\x44\
\x0e\x6c\x40\xed\x3a\x18\xa5\x11\x92\x1f\x5b\xa8\x1d\x81\x11\x21\
\x03\xa1\x1a\xc9\x81\x3d\x24\x9e\xe1\x5d\xf6\x77\x0b\xc9\x36\x45\
\xcb\x90\x91\xde\x07\xf5\x13\xfb\x49\x16\xbb\x5b\x89\xfa\x8b\x56\
\x96\xd7\x05\x48\xe1\x1e\x6e\x79\x9d\x8a\xe4\x49\x98\x96\xb3\x07\
\x78\x80\x24\xe2\x64\x85\x5d\x5f\x49\xb2\x68\x51\xda\xd0\x0f\x5e\
\xa5\x37\x48\x42\x49\x0f\xd8\x79\x73\x2d\xdd\x56\x76\xed\x4e\x4b\
\x27\xc8\x5f\x48\x22\xb0\x06\x58\xde\xde\xb4\xbc\xf5\x25\x31\x9c\
\xe2\xd4\xbd\x76\x5a\x79\xf7\x44\x9e\xf4\x85\x76\xbc\xaf\xe5\xf3\
\x19\x2b\xdb\x72\x12\x19\xdd\x8a\x44\x46\xef\x44\xfa\xc0\x1e\xbb\
\x36\x0c\x72\x2c\xb5\x72\x5b\x67\xf9\x1f\x67\xe9\xfd\xc1\x9e\xa5\
\xc2\xca\xe2\xa0\x7d\x5f\x8a\xfa\xd6\x56\x56\xc6\xb3\xec\xd9\xc2\
\x42\x5c\xcf\x70\xf2\x86\x45\xb7\x41\xed\x68\x3a\x85\x07\x8d\x4a\
\x6d\x43\x58\x99\x6c\x45\x75\x36\x0c\x26\xed\x43\xef\x75\x11\xaa\
\xb3\xfd\x90\xa1\xb7\x06\xd5\x87\xa5\xc8\x0b\x19\x16\x4c\x5b\x81\
\xea\x6a\x7f\x54\x37\x96\xa1\xf2\x5d\x8e\xde\xd5\x58\x3b\xf7\x69\
\xfb\x6d\x37\xaa\x23\x55\xa8\x0e\x6e\x20\x59\x48\x6d\x36\x7a\x87\
\x21\xff\x35\xe8\x7d\x6d\xb0\xdf\x6a\xec\x5e\x3d\xec\x5e\x8b\x50\
\x58\x70\x18\xac\x5a\x6e\xf7\x3a\x6c\xf7\x8a\x48\x06\xcd\xf2\x96\
\xd7\x4d\x96\xd7\xad\xa8\xbd\xae\xb0\xeb\xd7\xa0\x7a\x57\x69\xc7\
\x17\x59\x3a\xc3\x2d\xaf\xdd\x90\xce\xd0\xd9\x9e\x69\x16\x49\xdd\
\xdf\x8b\xfa\x91\xd1\x76\xfd\x42\xcb\xe7\x61\xd4\x17\xcc\xb1\x3c\
\x9f\x42\x32\x8d\x63\x55\x2a\x9f\x07\xec\xba\x74\xdf\x51\x9d\xca\
\x5b\xb9\x9d\x37\x1b\x19\xdc\x63\x50\xbb\x9c\x6a\x69\x55\x58\x3e\
\x37\x59\xbe\xd7\xa0\xb6\x74\x32\xd6\xef\xfa\x68\x87\x06\x0b\xa7\
\x44\x13\xfb\xb7\xdb\x79\xdf\x1d\x43\x3a\xf5\x6a\x5f\x4e\xdc\x5c\
\xc7\xb5\x9c\x26\xc3\xa1\xea\x98\xcf\x3d\xbc\x6a\xe7\x03\x0b\x77\
\xdc\x83\x3a\xc9\xec\x08\x4c\x3a\xcc\x24\xfc\x1f\x53\xbf\xe7\x2a\
\x1b\xaa\x96\xfd\x1e\x42\x5d\xb2\x9e\xd4\xba\xce\x4d\xe7\x25\xfd\
\x3d\x9b\x46\x2e\x75\x4d\xb1\x3c\x51\x20\xcd\x42\xbf\x67\xaf\x2b\
\x74\xcd\xd1\x08\x28\xa7\x71\xd4\x00\x9f\x46\x82\xe5\x61\x8e\x0c\
\x71\x2a\xf4\x3e\xf2\xd4\x56\x76\xb3\xe7\xa5\x7f\x4f\xf7\xba\xe9\
\xdf\xc9\x1c\x2f\x74\x2e\x05\xce\x4b\x87\x9c\x95\x92\xb6\x8f\x80\
\x3a\x27\x1b\x95\xc0\x57\x90\xf1\xb2\x80\xc6\xd7\xe1\xd0\x56\xd2\
\xed\x38\x5f\xe0\xff\x34\x39\x6a\xb7\x63\x38\x52\x4e\x64\xef\x51\
\xe8\x78\xa1\xb4\x0b\xc9\xa4\x6c\xbb\x4e\xcb\x9c\x98\xc2\x7d\x44\
\x7d\xed\x3f\x1d\xf2\x59\x28\xcc\xb3\x50\x3e\xb3\x21\xa1\x69\xd9\
\x5c\x97\xbc\x2c\x34\xf5\x27\x9d\xbf\xfa\x64\x67\x05\x32\x1a\x6e\
\x40\x91\x62\x33\x69\xbc\x8c\x2e\x54\x16\xe9\x73\xb2\xdf\xeb\x2a\
\xc3\x93\x8d\xb0\x00\xe7\x57\x50\x14\x53\x76\xed\x95\x86\xa4\x07\
\x47\xd6\x8d\x42\xf5\x12\x0a\xd7\x81\x52\x65\x62\x31\x59\x06\x32\
\x12\x2f\x44\xe1\xfa\xd9\xa9\x43\x85\xea\x6b\x31\x99\x1a\x15\x38\
\x3f\x5d\x8f\xd3\xf9\x4f\x87\x57\x67\xeb\x63\x0d\xf2\x60\x5f\x8a\
\x06\x74\x86\x21\xc7\xc8\xbf\xa1\x41\xa1\x81\x24\x2b\xba\x93\xba\
\x4f\xa1\xb2\xca\x96\x75\xfa\xf7\x74\x5d\x2d\xf4\x2e\xb2\xfd\x5a\
\xa1\x72\x2e\x96\x76\x73\x24\x46\x75\xe5\x13\xc0\x9f\xfa\x1c\x61\
\xa7\xa9\xd1\xd0\x51\xc9\xfa\x1a\x6c\xae\xc4\xf3\xd2\xe7\x14\x52\
\x48\x8a\xa5\x51\xea\xb1\xfa\xd2\x29\x74\xbc\x94\x6b\x9c\x13\x43\
\x43\xea\x42\x76\x6e\x5a\x29\xd7\x17\x3b\xb7\xd8\x39\xc5\xda\x8d\
\xd7\x1f\xc7\xa9\x4d\xa1\xb6\x92\xab\xe7\xff\x62\xc7\xea\x9a\x8f\
\x5c\x8c\x52\xe7\x5f\x66\xf3\x5a\x9f\x9c\x2a\xb5\xfd\xd7\x77\x4d\
\xb1\x6b\x23\x4a\xbb\x77\x21\xd9\x5b\x9f\x5c\x2f\x74\xaf\x41\xc8\
\x00\x9e\xc7\xb1\x91\xd1\x47\xd3\x4f\xe7\xea\xb9\xae\xa5\x53\x9f\
\xde\x56\x6c\xe0\xb6\xbe\xb9\xe4\x81\x52\xdb\x5f\x58\xe0\xb4\xd0\
\xfa\x19\x85\xf2\x54\x57\x1d\xcc\xfe\x9e\xad\xc7\xe9\xdf\x0b\xcd\
\xe9\x0d\xa1\xc8\x6f\xa2\xb9\xc9\x13\x91\x17\xfb\x3e\xe4\xb9\xdd\
\x88\x22\x13\x62\xea\xaf\xbb\x47\xd3\xae\xa3\x3a\xae\xad\x4f\xf7\
\x38\x19\x07\x75\x1a\x8d\x1b\xc2\x8e\xe3\x38\x8e\xe3\x38\x4e\x53\
\x25\x4c\x1d\x01\x37\x44\x9d\xe2\x1c\xa2\x76\x48\x74\x53\xe0\x10\
\x0a\xbb\x0e\x84\xf9\xd4\x7b\x52\xff\x3b\x27\x10\x37\x84\x9d\xa6\
\x48\x36\x7c\xa3\xae\x91\xbb\xba\x42\xb9\xc8\xa4\x51\xea\xf5\xa5\
\xa4\x59\x17\x71\x23\xae\x2d\x35\xfd\xf4\xf7\x5c\x91\x73\x8e\x26\
\x3c\xef\x44\x3d\x4b\x73\xa1\xa1\x75\xe6\x68\xca\xd7\xdf\x85\xe3\
\x1c\x5b\x8a\xf5\xff\xe9\x50\xdb\x34\x85\x42\x95\x0b\xf5\xb3\xf5\
\x5d\x5f\xe8\xfc\x63\xcd\xd1\xc8\xd1\x70\x7e\x5d\x46\x66\x7d\xf9\
\x2c\xe5\xf7\xec\xb9\xa5\x3e\x77\x7d\x53\x82\xea\x7a\x1f\xce\xf1\
\x27\x2e\xf0\x7f\x43\xc3\xc6\x1b\xfb\x0e\x4b\xb9\xf6\xdd\xae\x2f\
\x47\x13\x3d\xe2\xbc\xcb\xb8\x21\xec\x34\x35\x2a\xd1\x2a\xb7\xa7\
\xdb\xff\x0b\xd1\xc2\x02\x87\x0a\x9c\x1b\xe6\xb9\x9c\x82\xe6\x1b\
\x67\xe7\x56\xe4\xd1\xaa\x7e\xa7\xa1\x39\x23\xd5\x05\xae\xbf\x10\
\x2d\x60\x30\x83\x64\xae\xc5\xd9\x24\x5b\x50\x1c\xad\xd1\xd8\x05\
\x6d\x6e\xfe\x30\xc9\xc2\x59\xc7\x92\x18\xcd\x2b\x99\x8c\x56\x4e\
\x9c\x63\xf9\xcc\xa7\x7e\xef\x86\x56\x06\x9d\x42\x12\x22\x94\x47\
\xf3\x54\xf6\xd9\xf9\xa5\x86\xe3\xdd\x68\xe7\x6f\x3c\x0e\xcf\xd2\
\x5c\xc8\xa3\x2d\x0d\xc6\xa0\x3d\x37\x4b\xd9\x4e\x23\x8f\xf6\xf2\
\x6b\x83\xf6\xff\xab\x4f\x41\x9d\x80\x16\xe7\x7a\x09\xf7\x88\x38\
\xce\xb1\xa0\x35\x5a\x35\x76\x3a\x5a\x4c\x26\xb4\xab\xcb\x51\x1f\
\xda\xc7\xce\x29\x47\x73\xfd\xf2\x68\x3f\xce\xe9\xa8\xad\x9f\x89\
\x64\xc7\x43\x24\x2b\x41\x77\x46\x3b\x01\x4c\xb7\xbf\x5d\x48\xfa\
\xe6\xad\x68\x5b\xa0\xb0\x45\x52\x8c\xda\xff\x79\x68\xc1\xa8\xf4\
\xd6\x49\x8d\x25\x42\x8b\xfc\x9d\x6b\xf7\x58\x81\x42\x46\x77\x14\
\xb9\x47\x58\xa0\x31\x2c\x4a\x95\x26\x3c\xd7\xe5\x48\xa6\x64\x17\
\x87\x0a\x72\x76\x82\x95\x45\x21\x39\x3c\xda\xca\x3a\xfc\xb6\x1e\
\x79\xc9\x0a\x2d\x76\x56\x88\x31\x76\xdf\xec\xe2\x7e\xb1\xbd\xa7\
\xf3\xd0\xc2\x4a\x97\xa0\xdd\x17\xb6\x1e\xc3\xb2\x74\xea\x26\xac\
\xf6\x7c\x2e\xd2\xb1\xc2\x42\x54\xcf\x52\xda\xca\xed\x69\x72\x68\
\x1e\xf8\x74\x4a\xaf\x1b\x47\x9b\xd7\x33\x90\x2c\x5d\x8d\x16\x3d\
\x7b\x06\xdf\x85\xa3\x45\xe3\x0a\x95\xd3\x94\xc8\xa3\x15\xff\x2e\
\x47\xc6\xd7\x0c\x64\xf0\x5d\x67\xbf\x85\x7d\x78\xc3\x9e\x85\x35\
\x68\xd5\xc7\xab\xec\xfa\x70\x9c\xd4\xf9\x3d\x90\x80\xce\x15\xb8\
\x3e\xec\x9d\x36\x94\xda\x23\x9a\x61\x2f\xc1\x6c\x7a\x85\x46\x3d\
\xf3\x99\xef\xed\x90\x50\xae\x2c\x70\x3f\x1a\x90\x66\x76\x14\xbd\
\x3d\xf0\x11\xb4\xb8\xc5\xab\x68\xeb\x87\x81\x99\x6b\xda\xa1\x25\
\xf1\xcb\x52\xe9\x05\x65\x64\x08\xb5\x9f\xbf\xae\xbc\x45\x56\x76\
\x9d\x32\x79\x2d\xf6\x0c\x85\x9e\xa7\x25\xd0\x06\x6d\x75\x70\x21\
\x52\xd8\xb2\xe5\x99\x7e\x07\xe9\xb2\x0b\xf5\x0c\xea\x7e\x1f\x35\
\x24\x2b\xc0\xe6\xa9\xff\xdd\x65\xef\x1b\xd7\x73\x3c\x9d\x5e\x4b\
\x7c\x7f\x4e\xf3\x22\x2c\x52\x53\x5f\x5d\x3e\x84\x8c\xa8\x0b\x53\
\xd7\x75\x44\x6d\x79\x1d\x52\xe4\x5f\x42\x8b\xda\xcc\x47\x86\xdb\
\x4a\xd4\xaf\x06\x23\xf8\x22\xb4\x1a\x6e\x68\x97\xa7\x21\x99\x12\
\x56\x9b\x9f\x67\xd7\x4d\x41\xca\x7d\xd8\x1b\x38\xdc\xef\x6c\xa0\
\x37\x1a\xa0\x0c\xc7\xd2\x6d\x39\xfb\x5c\x85\xda\x6f\x96\xd0\xd7\
\xdf\x85\x0c\x92\x69\xa8\xdf\xff\x10\xb5\x65\x42\x38\xb7\xc6\xf2\
\x70\x07\x5a\x94\xaa\x50\x5f\xd2\xd6\xf2\xda\x9a\xc2\xfd\x7f\x0f\
\x34\x07\xb2\x98\xc7\xbb\x3f\x32\x96\x9f\xb1\x4f\x77\xb4\xcd\x4d\
\x36\x3f\xe9\x34\xc3\xf1\x32\x64\x1c\x0d\xe4\xc8\xe7\xce\x23\xf9\
\x34\x91\x64\xd5\xfe\x62\x72\x35\x5d\xbe\x59\x19\xe8\xfd\xde\x91\
\x84\xba\x51\x1f\x31\xc9\x8a\xce\x4f\xa2\x36\x73\x21\xd2\xe3\xb2\
\xe5\x5b\x8a\xee\x30\x01\xb5\xc3\x7c\xe6\x1e\xc5\xae\x2f\x25\xcd\
\xac\x2c\x1d\x81\x8c\xf6\x43\x75\xa4\xe5\xb4\x10\xdc\x23\xec\x34\
\x35\x06\xa2\xa5\xdb\x67\x23\xe5\x60\x15\x12\x9a\x39\x34\x7a\x17\
\xf6\x44\x9d\x6b\x9f\x33\x91\xf7\xf8\x4c\x34\xc2\x77\x09\x1a\xcd\
\xdf\x8b\x56\x97\x4c\x77\xe6\x23\x90\xa1\xdd\x0a\x8d\x7c\xbf\x48\
\x61\xa1\x19\xb6\xbc\x08\x4a\x51\x5f\xb4\xef\xdc\x93\x24\x23\xea\
\x31\x12\xc0\x97\x20\x45\xa8\x86\x64\x04\x34\xdc\xef\x74\x64\x14\
\x97\xa3\xbd\x8e\x67\x21\xc5\xeb\x72\x34\xc2\xbe\x12\x8d\xd2\xef\
\xcb\xa4\x79\xa9\xdd\xb3\xda\x7e\x7f\x9b\x44\xc1\xe8\x6c\xe7\xbc\
\x6a\xcf\x51\x68\xc4\x35\x18\xc3\xef\xb1\x73\x67\x21\x25\x2c\x28\
\x6b\x95\x96\xef\xb0\x65\xc7\x34\x92\x7d\xe9\xae\x40\x5e\xf6\xb7\
\x91\x27\xbe\xc6\x3e\x83\x91\xd2\xf7\x18\x12\x78\x57\x5a\x39\x2f\
\xb5\x3c\x0e\x43\x8a\x5f\x39\x5a\xd0\xe4\x0d\x5a\xc6\x88\x7c\x1e\
\x19\xa8\x39\xf4\xfe\x2f\x46\x5e\xfa\x72\xf4\x1e\x5b\x23\x25\x70\
\x05\xda\x4a\x61\x3c\x52\xb2\x1f\xb3\x6b\xca\xec\xdc\x8b\x50\xfd\
\xde\x8f\xea\xe5\x12\x54\x57\xae\xb6\xdf\x7b\xa2\xad\x0c\x2a\xed\
\x1e\xa3\xec\xda\xb0\x57\xe9\x4d\xf6\x5b\x84\x94\xee\x33\x2d\x5f\
\xbb\xd0\xfb\xd9\x64\x69\x55\x5a\x5a\x5b\x51\x94\xc4\x01\x92\x08\
\x8c\x03\xc0\x73\x24\xdb\x30\x39\xce\xc9\x46\x88\x12\x1a\x80\xb6\
\x03\xa9\xcb\xcb\x5a\x8d\xfa\xb8\xf7\xa0\x01\xc6\x3d\x68\x20\xeb\
\x00\xf2\xd0\xee\x47\xfd\xe7\x35\x48\x5e\xbc\x8d\xda\x5c\x7b\x64\
\xf8\xfd\x1f\x6a\xdb\x13\xd0\x96\x24\x15\xc8\x58\x7c\xcd\xae\x3d\
\x88\xfa\xc1\xa5\xd4\x6e\xeb\x21\x9f\xed\x50\xe4\xce\x1f\x2c\x2f\
\x83\xd0\x3e\xbf\x6d\xd1\x6a\xd8\xd3\x49\xa2\x98\x62\xb4\xff\xf7\
\x55\xa8\xfd\xae\xb7\xf4\x1e\xe4\x48\xc5\x3d\x78\x49\xab\x50\xff\
\xb0\x0d\xf5\x27\xa3\xac\x2c\x7a\x21\x19\xd4\x15\xc9\xd7\xa9\xf6\
\x0c\x23\xd0\xc0\xf3\x4b\xa8\x8f\xe9\x8f\xfa\xfe\xa9\x56\x36\x41\
\x56\xf6\x46\x72\xa2\x8b\x5d\xff\x34\xf5\x1b\x4d\x31\xea\x73\x5e\
\xb5\x67\xca\xa1\xfd\x90\xdb\xd9\x33\xb7\xb3\xeb\x9f\x40\x83\xdb\
\xa7\x23\x19\xfe\x2c\xea\xb3\x4e\x47\x7d\x69\x3b\xbb\xd7\xb3\x48\
\xfe\x5d\x83\xb6\x77\xa9\x26\x59\x9c\xa8\x1c\xed\x1f\xfc\x96\x3d\
\xf7\x69\x48\x87\x78\x0b\xc9\xe3\x36\xf6\xec\xb3\xac\x2c\x06\xd9\
\x33\xcf\x6e\x5c\xd5\x6b\x76\xf4\x23\xd1\x05\x0e\xd7\x73\x6e\x1e\
\xe9\x5f\x21\x8a\x6e\x38\xaa\x27\xdd\x90\xdc\xa9\x40\x32\xe8\x0d\
\xa4\x83\xf5\x40\x7a\xcf\x53\xa8\x2e\x9f\x0d\x9c\x83\xf4\xab\x4e\
\xe8\x3d\xbf\x17\xd5\xbd\x2d\xa8\x7e\x76\x41\xed\xf2\x4a\xcb\xdb\
\x06\x54\xf7\x5a\x21\x59\xdb\x1d\xb5\xbb\x27\x2d\x0f\x57\xa2\x7a\
\xb7\x1c\xd5\x83\x20\x4b\x7b\xa0\x2d\xc0\x22\x92\x2d\xc2\xce\xb4\
\x4f\x1b\x3b\xf7\xb9\x12\x9e\xd9\x69\x26\xb8\x47\xd8\x69\x4a\x44\
\x48\xc0\xf5\x02\xfe\x0e\xf8\x33\x24\x9c\xdf\x42\x42\xf9\xc3\x48\
\xa9\x98\x85\x94\x97\x51\x48\x69\x5f\x83\x8c\xca\x8b\x91\x30\x7d\
\x12\x75\x8a\xd7\x93\x8c\xf2\xf5\x00\x3e\x86\x3a\xcf\xe9\x48\xa1\
\x38\x8f\xc2\x4a\xc4\x10\x64\xf8\x9d\x83\x14\xa3\xa9\xa8\x73\x3e\
\x9d\xda\x23\x8c\x13\x90\x52\xf2\x14\xea\xd4\x6f\x27\x19\x51\x6f\
\x07\xbc\xcf\xf2\x37\x1f\x29\x3c\xdd\x81\xbb\xed\x39\xa7\x22\x81\
\x7f\x43\xe6\xde\x13\xec\xbc\xa7\x90\x22\x75\x17\xc9\x96\x3d\x61\
\x3e\x4b\x1e\x8d\xc0\x7e\x09\x29\x0b\x9b\xa8\x3d\x27\x2d\xb6\x7c\
\xed\x46\x82\xe3\x56\x92\x0d\xeb\xf3\xc8\x08\xbe\x08\x78\xde\xce\
\xf9\xb8\x9d\xff\x01\xd4\x27\x3c\x07\x8c\x24\xf1\x40\x0e\x45\xde\
\x84\xf5\x48\x49\xfc\xb0\x9d\xf7\x0c\x32\xde\xae\xb0\xf7\x73\x39\
\x1a\x9c\x58\x77\x42\x6a\xcf\x89\x21\x42\xf5\xe8\x2d\x24\x94\x07\
\x5b\x59\x80\x94\xca\xde\x28\x54\xef\x16\xf4\xce\xa6\xa3\xb2\x1f\
\x61\xe7\x0d\x41\x75\xe3\x0a\x3b\x6f\x0b\xaa\xa7\x7d\xd1\xfb\xc8\
\x23\xc5\xba\x97\xa5\x39\x10\x85\x76\xbd\x80\xf6\xf9\x7b\x2f\x52\
\x36\x26\xd9\xdf\xe9\x76\xdf\xb3\xd1\x7b\x3c\x84\xde\x6f\x27\xbb\
\x6f\x2f\xbb\x76\x3c\xaa\xdf\x67\x22\x85\xe1\x25\xf4\xde\x3e\x8c\
\x14\x0e\xf7\x90\x38\x27\x23\x15\xc0\xa7\x80\xff\x40\x6d\xa3\xbe\
\x95\x89\x17\x21\x99\x31\xdc\xce\x9d\x88\xfa\xcc\xb0\x2f\x78\x50\
\x94\x83\x21\x0b\x52\xc2\x0f\xa0\xd0\xcd\xe9\xc8\xd0\x6a\x83\xda\
\x7a\x77\x34\x30\x15\x21\x19\x70\x2b\x6a\xcf\x1f\x25\xe9\x4f\x41\
\xed\x6b\x00\x32\x7a\xd7\xa1\x01\xce\x8f\x20\x63\xf1\x05\xd4\x86\
\xcf\xa5\xb6\x7c\xba\xc9\xae\x79\x01\xf5\xe7\x17\x17\x79\xbe\x1c\
\x32\xea\x76\x02\x7f\x09\x7c\xdd\xce\x0d\xfb\xa0\xdf\x8d\x8c\xcb\
\xa9\x48\xbe\xdd\x88\xe4\xe7\x66\x64\xf0\x9f\x66\xcf\xf2\x14\x32\
\x80\xef\x42\x06\x44\x8c\x8c\xd1\xbb\xed\xff\x70\xfd\x4d\x25\xbc\
\x97\x3c\xf2\xc4\x7d\x04\xf8\x24\x70\xa7\x95\xdd\x61\x24\x8f\x3a\
\xa2\x29\x22\x13\x90\x1c\x79\xc1\xf2\xf3\x11\x64\xd0\xaf\x41\xde\
\xf5\xad\xa8\xbf\x6a\x8f\xfa\xc2\xf1\x24\xde\xf4\x72\x12\x6f\xe2\
\x78\xd4\xd7\xd5\xd8\xfb\x1a\x85\x06\x12\x6e\x40\xd3\x7c\xd6\x02\
\x9f\x43\xf2\x73\x19\x92\xdd\x6d\xf1\x7e\x0f\x92\xc8\x88\xaf\x03\
\xdf\x47\x75\xb1\x3e\x2f\x69\xd0\x5d\x3e\x0a\x7c\x06\xb5\xa3\x57\
\x50\x1b\xb8\x1e\xc9\xb5\x85\x48\xd6\xe5\x90\x93\xa2\x3d\x7a\x1f\
\x43\x51\xf9\xcf\x46\xef\x37\x18\xb4\x43\x91\xac\x2b\x43\x86\x6e\
\x84\x22\xe0\x06\x20\x3d\xb1\x1b\x92\x5f\x17\xd8\x6f\x4f\x5a\xbe\
\xaf\x47\xed\xe9\x3a\xa4\x7f\xad\xa4\xb6\x2c\xed\x6d\xe7\x77\x43\
\x3a\x58\x37\x7b\xc6\x37\xd0\x20\xf4\xb5\xd4\x6e\xab\x4e\x33\xc7\
\x3d\xc2\x4e\x53\x22\x42\x02\xef\x1f\x91\x81\x30\x1a\x75\x7c\x43\
\x90\xf0\xda\x8e\x3a\xc0\x6a\x64\xa8\x8d\x47\x42\x6c\x07\xea\x68\
\x5f\x40\x9d\xe7\x08\xa4\xcc\x07\x45\x26\x18\x73\x87\x90\xb7\x6c\
\x3f\xea\x4c\x27\xda\xb5\x59\xe1\x17\xc2\x82\xb7\xa0\x4e\xf9\x6a\
\x34\x4a\xf8\x16\xb5\x97\xc9\x7f\x03\x29\x44\x43\x91\x21\xd9\x0d\
\x29\x62\x20\xe1\xbd\x19\x75\xe0\x6f\x22\x23\xa7\xa3\xa5\xf7\x23\
\x64\xbc\x56\x22\x65\xed\x41\x92\x90\xb9\xb9\x24\x42\xa0\x87\xa5\
\x19\x3c\xbf\xe9\x72\x5a\x84\x46\x6a\x3f\x8c\x8c\xa8\x3c\x12\xf6\
\xdb\x91\x00\x5a\x65\x65\xb5\xd3\x9e\x73\x8c\x3d\x67\x05\x12\x2e\
\x2f\xa2\x01\x85\x25\xf6\xff\x59\x48\x61\xf8\x85\xe5\x3b\x78\xa1\
\xdf\x8b\xf6\x5a\x9b\x87\x3c\xc7\xbd\xd1\x80\xc0\x2c\x64\x6c\x75\
\xb0\xf7\xf4\xa6\xe5\x69\x36\x2d\x67\xc1\x92\xe0\x7d\x3a\x13\x95\
\xf9\x30\x24\xf8\xcf\x41\x73\xe5\xf6\xa0\x3a\xf9\x26\xaa\x4b\x33\
\xed\x73\x2d\x12\xd4\x41\xd0\x9e\x85\xa6\x01\xbc\x86\x3c\x41\x67\
\xa1\x77\xd6\x0b\x6d\xb5\xb0\x16\x09\xe6\x76\xa8\x7d\x3c\x87\x3c\
\x3e\x03\x50\xfd\x68\x8b\x14\xba\x19\x48\xe8\x7f\x08\x29\xa9\x73\
\xec\xff\xf1\x48\x09\xdd\x69\xc7\xe7\xa1\x77\xd7\x17\x29\xf0\x9d\
\xed\x9c\x56\x76\x5e\x6f\x54\x8f\x5a\xc2\x3b\x74\x9a\x17\x31\x32\
\xae\xc2\xa7\xae\xbe\x28\x42\x6d\xf4\x0d\xd4\x86\x37\xa0\x36\x77\
\x3f\xc5\x9d\x04\x31\x6a\xe7\x6b\x90\x1c\x7a\x13\x29\xde\x83\xec\
\xf8\x4a\xd4\x7f\xf6\x42\xed\xfb\x00\x49\xc4\x4f\x75\x26\x9d\x1e\
\x96\xc7\x03\xa8\x0f\x1d\x81\xe4\x5c\x57\xd4\xaf\x8e\x44\xfd\x74\
\x8c\xda\xf8\x68\xe0\xd7\x48\x46\xe4\x50\xdf\x5c\xec\xb9\x76\xa3\
\xc1\x80\x53\x2c\x9d\x73\x51\x1b\xbf\x1f\xc9\xaa\xff\x41\x03\x9b\
\x39\xe0\xfd\x96\xe6\x6e\x24\x97\xb6\x53\x5b\xae\x75\x27\x09\x89\
\xee\x61\xc7\xfe\xdb\xca\xab\x0c\x19\xca\x6b\xeb\x79\x2f\x11\x32\
\x4a\xf7\x59\x3a\x1b\x90\x4c\x9a\x81\x06\x7c\x5f\x46\x83\xdc\x37\
\xa3\x41\xbb\x33\xec\x9e\x03\x50\xbf\xb7\xc3\xca\x66\xbe\x95\x77\
\x98\xe6\xb3\x10\xf5\x6b\x61\x20\xb8\xd8\xd4\x8f\x20\xd3\x57\xa2\
\x41\xbf\x53\xd0\xe0\xe1\x2b\xa8\xff\xbb\x0c\xc9\xe3\x7d\x38\xa0\
\xf2\x3a\x84\xea\x67\x55\x89\xd7\x54\x21\x3d\xe5\x30\x7a\x27\xe3\
\xd1\x7b\xdd\x80\x3c\xc5\x5b\xec\xb7\x61\xa8\xae\x77\xb5\x7b\x8c\
\x45\x75\xf1\x25\x24\x83\x2e\x22\x59\xb7\xe5\x2c\x54\x2f\x3a\x22\
\x5d\xe5\x52\xd4\x06\xe6\x93\x44\x68\x74\xca\xa4\xd9\x01\xbd\xeb\
\x55\x76\xdf\xf6\x48\xd6\x05\x59\x1a\xe4\x74\x70\x92\xec\x42\x91\
\x08\x7d\x90\x3c\x6d\x8f\xea\x84\x0f\x8a\xb4\x10\xdc\x10\x76\x9a\
\x12\xe5\x68\xf4\x7c\x3a\x32\x0a\x5e\x25\xf1\x7a\x85\x90\xe4\xf4\
\x1e\x8a\xe9\x55\x31\x2b\x90\x07\x36\x18\x93\x1b\x91\xf2\x10\xc8\
\xae\x3a\x19\x0c\xe4\x62\x9d\x5d\x0e\x85\xd4\xfc\x10\x29\x39\x17\
\xa3\x11\xe8\x1f\x92\xac\xae\x79\x0d\xea\x54\x5f\x43\x9d\x7d\xef\
\x54\xfa\x35\x68\x61\x94\xfe\x48\x68\x7f\x14\x78\x80\xda\xab\x3c\
\x17\xda\x54\xfe\x7a\xe4\x55\x7c\x1d\x09\x87\x7e\x1c\xa9\xc8\x95\
\x5b\x1e\x96\x23\x45\x6c\x98\xa5\xbd\x1a\x29\x15\x55\x99\x6b\x72\
\x24\x61\x6b\x71\x2a\x0f\xe1\x6f\xf0\x32\x47\xa9\xe3\x03\xed\xfc\
\x6a\xe0\xf7\x48\xa8\x4d\x44\xc2\x25\x84\xfc\x6d\x41\x83\x03\xbb\
\xad\x8c\xc2\x7c\x9b\x96\x62\x40\xe5\xd1\xa0\x40\x2b\x12\x63\x72\
\x23\x1a\xa1\x0e\xde\xd8\xc3\x24\xf3\xe0\x6a\x48\xbc\x4a\xd9\x74\
\xc2\xf1\x50\x47\x6b\x48\xde\x07\x24\xef\xe5\x2c\xa4\x2c\xbe\x8a\
\xea\x5c\x18\x40\xc9\xdb\xbd\x82\x42\x18\xce\x8f\x32\xbf\x1f\x2e\
\x90\x87\x55\xa8\xbe\x95\xa3\xf6\xb6\x9e\x96\xf3\x0e\x9d\xe6\x45\
\x35\xf0\x13\xb4\x58\x61\xa9\x91\x29\xaf\x21\x2f\xe7\xa5\x48\x51\
\x0e\x0b\x03\x16\x92\x0d\x95\xa8\xaf\x7b\x1a\xb5\xb1\xdd\xc8\x18\
\xbb\x10\x19\x88\x4f\x92\xf4\xa5\x07\xd0\xc0\x6b\x3a\x34\x3a\x6d\
\x60\x67\xe5\xcf\x5e\x34\x90\x78\x00\x29\xf9\x5b\x32\xf7\x0e\xa1\
\x9c\xd9\x9d\x02\xb2\xc6\x7e\x8c\xbc\xb4\xfb\xad\x1c\xde\x40\x46\
\xc5\x57\x90\xa1\x90\x5e\x31\x37\x97\xb9\x3e\x46\x72\x6d\x24\xea\
\x63\xd6\x93\xc8\x82\xf0\x3b\xd4\x96\x1f\x85\xd6\xb2\x28\xb4\x97\
\xe9\x3a\x24\x13\x6b\xd0\x40\xc1\x3f\x20\xe3\xa3\x1a\xf5\x4b\xe1\
\x99\x42\x7f\x54\x61\x65\xbb\x29\xf5\xdb\x01\x2b\xa3\xc9\xc8\x50\
\xfe\x15\xc9\xe0\x73\x36\x8f\xa1\x8c\xdb\xa7\xf2\x13\x06\x94\xcb\
\x48\x06\x26\x72\x05\xae\x6d\xc9\xfd\x5f\x84\xea\xe2\x3f\x20\x23\
\x73\x35\xf5\x47\x8f\x46\x68\x80\xf5\xff\xec\xff\xb3\x51\x24\xd2\
\x1b\x48\x5f\xa8\x41\x72\xf2\x76\x64\x84\xce\x42\xed\x2c\x44\x1f\
\x85\xc8\x8b\xf0\xc9\x59\x7a\x97\xa2\x81\xe3\xe5\x68\x80\x06\x92\
\x3a\xd7\x13\xd5\xa3\x8b\x50\xbb\x9c\x6b\x69\x76\xb3\x34\xd2\x03\
\x61\xa1\xed\x84\xeb\x03\x79\xd4\x9e\xef\x46\x83\xd0\x6b\xd0\xe0\
\x98\x47\xcb\xb6\x20\xfc\x65\x3b\x4d\x89\x2a\x14\x1a\xf3\x11\x14\
\x52\x76\x15\x12\xca\x6f\x23\xc1\xd8\x11\x85\xbb\x5c\x8e\x0c\x90\
\x99\xc8\x10\xe8\x8a\x84\x75\x1f\x24\x44\x77\xa2\x91\xe4\xd0\xb9\
\x56\x20\x65\xa4\x0c\x85\x81\x4d\x46\x23\xe4\x61\x3e\x4b\xb6\x1d\
\x84\xff\x27\x22\x6f\xf0\x7a\x24\x0c\xb2\x9b\x9a\xf7\x41\xca\xca\
\x7a\x34\xe2\xd8\x36\x95\x5e\x7b\x34\x52\xde\x11\x85\xa4\x1d\x42\
\x02\x7d\x83\x3d\xdb\xf9\xc8\xe8\x0d\xcf\x10\xd2\xec\x9b\x4a\xb3\
\x1f\xea\xe0\xd3\xe4\x51\x47\x7f\x3d\x12\x00\x13\x90\xc0\x08\x21\
\xe3\x0b\x90\xe0\x19\x62\x65\x77\x25\x32\xd0\xe7\x93\x18\xff\xaf\
\xdb\xb5\x17\x23\xa3\x2a\x1c\x5b\x89\x14\xa8\x0b\x90\x97\xa0\x0b\
\x12\x60\x33\x81\x47\x49\x16\x53\x59\x84\x14\xa5\x0a\x3b\x37\x28\
\x4a\x85\x8c\xbc\xe6\x4c\x2b\xa4\x00\x3f\x0c\xfc\x0b\xf0\x5d\xfb\
\xdb\x0a\x19\xc5\xd9\x81\x97\xf4\x20\x4e\xfa\xb7\x57\x91\xe2\x30\
\x09\xbd\x8f\x72\xf4\x3e\x56\xd8\xff\x17\xa3\xf0\xc1\x08\x79\x64\
\xaa\x50\x24\x44\x57\xa4\xa8\xe4\x52\x9f\x2a\xbb\xf6\x52\xcb\xdb\
\xad\xc8\xcb\xb1\xc6\xd2\x4d\xe7\x01\xa4\x54\xf6\x40\x86\x7c\x7f\
\xbb\xc6\xe5\x82\x73\xb2\x12\xbc\xa1\x4b\x28\x6d\xc5\xda\x1c\x32\
\x7e\x77\x21\xd9\x32\x83\x23\x43\x22\x43\x7b\x0d\xca\x77\x6b\x64\
\xd4\x85\x76\xf2\x2a\x92\x27\xed\xd0\xc0\x60\x38\x1e\xe6\x04\x87\
\x4f\x56\x7e\x6c\x26\x99\xf7\xba\x06\xf5\xf9\xc3\x50\xff\x71\x09\
\xf2\xc4\x76\x43\xf2\xb0\x1c\xb5\xd5\xab\x51\x9f\x7b\xad\x5d\x57\
\x8e\xe4\xcc\x08\x6a\x87\x5d\xaf\xb3\xe7\xf9\x00\x8a\x18\x7a\x0f\
\x92\xad\x8b\xec\xb7\x20\x83\x6e\xb4\x74\x77\x5b\x5e\x86\x20\xb9\
\xb3\xd5\xce\xeb\x67\xf9\x09\x86\xfc\x96\xd4\xf5\x17\xa0\xd0\xd6\
\x59\x48\x86\x95\x21\x99\x70\x97\x3d\x47\xb6\x1c\x7b\xd9\x73\x5d\
\x8a\xfa\xb5\x7d\x76\x9f\x72\x92\x81\xed\xd7\xad\x8c\x3b\x21\xaf\
\x6d\x58\xc8\xac\x9a\xc4\x93\x37\x0b\xc9\x9f\x6a\x24\xef\x43\xde\
\x82\xec\xad\xb6\xb2\xbd\x10\xc9\xb9\xf3\x52\x65\x9e\x4b\x7d\x4f\
\xcb\xab\xf0\xfd\x3a\x14\xd1\xe3\x61\xb1\x7a\x37\x4b\x39\x72\xb7\
\x8d\x42\xe4\x50\xd4\xd2\xa5\xa8\xbe\x5d\x83\xde\xcd\x01\x92\xba\
\x5f\x86\x74\xa6\x35\x68\xde\xfa\x00\x54\xb7\x16\x90\x44\xde\x05\
\xe7\x42\xb8\xff\x6a\xf4\x1e\x5f\x47\xf5\xe5\x4d\x3b\xe7\x3c\x14\
\xf9\x34\x14\xd5\xab\xd5\xc8\x50\xee\x4f\xb2\x56\x46\xa8\x13\x3b\
\x90\xbc\xbc\x99\x44\x96\xa6\x65\x70\x47\x14\x19\xb5\x18\xb5\x81\
\x1e\xb8\x0c\x6c\x51\x94\xf5\xeb\x58\xf9\xd5\x5b\x4e\xed\xd2\xba\
\x7d\xa5\xbf\x77\xe7\xf8\x53\x93\x87\xc7\x17\xef\x3a\xb8\x68\xcb\
\xc1\x27\x39\x72\x79\xfc\x08\x75\xbc\x3b\x49\x16\x5b\x58\x80\xc2\
\x56\xb6\xa1\x8e\x35\x84\xbf\x4c\x41\xc6\xdd\x6e\x14\x0a\x13\x42\
\x69\x86\xdb\xff\x73\x90\xd1\xb9\x16\x29\x44\x0b\x91\x72\x34\xc4\
\xd2\x7d\x9e\x64\xd4\x79\xb3\x9d\x9b\xf6\x2e\x6f\xb7\x7b\x77\x46\
\x21\xc7\x5b\x91\x31\x18\xc2\xdc\xf2\x96\x76\x3f\xd4\x11\x2f\x44\
\x8a\xcc\x0a\x34\x12\x39\x1f\x29\x0d\x63\x50\xc7\xfa\x0c\x32\x58\
\x97\x20\x41\x3f\x18\x8d\x96\x86\x50\xef\xa0\x68\xad\x46\x9d\x79\
\x48\x73\xad\xa5\x19\xc2\x93\x3a\x21\xaf\xe0\x02\x24\x04\xde\x40\
\xe1\xb7\x90\x74\xee\x39\x24\x80\xb0\x67\x7d\xdc\xee\xdb\x0a\x8d\
\x98\xbe\x8e\x14\x97\x53\x91\xd1\xfc\x00\x32\xd2\xdf\x46\x82\x6a\
\x30\xf2\xca\xcf\x44\x42\x65\x95\xfd\xd6\xda\xca\xfb\x25\x7b\x86\
\xe1\xc8\x78\x7e\xc1\xca\x63\xb7\xfd\xdf\x9c\x08\x5e\xd8\x3d\x24\
\x73\xec\xc2\xf1\xb6\xa8\x7e\xbc\x48\x32\xa7\xf0\x20\xaa\x6f\xd5\
\xa8\x4e\xad\xb6\xff\x2b\x49\x16\xef\x09\x65\xba\xc7\xca\x6c\xb6\
\x7d\x3f\x15\x0d\x3c\x3c\x80\x94\xcd\xa5\x56\xce\xfd\xec\xde\x4b\
\x90\x12\xd8\x1e\xd5\xe3\xb5\x76\x6c\x35\x7a\x9f\x21\xfd\xd5\x76\
\xff\xb1\xf6\xff\x03\xa8\x4d\x95\xdb\x6f\x07\x50\x1d\x0f\xe1\xda\
\xbb\xec\xdc\xd6\xc8\xd3\xe5\x1e\x61\xa7\x29\x53\x86\x94\xe3\x45\
\x14\xde\x62\x25\xed\x59\x2a\x85\x10\xb2\x1b\xfa\xb6\x9a\x4c\x3a\
\x65\x48\x91\x0e\x8b\x67\xed\x42\xed\x37\x9c\xb3\x97\x64\xe1\xba\
\x95\x24\x7d\x70\x84\x0c\xe3\x42\xdb\xa9\x45\x96\xde\x78\xd4\x0e\
\x57\xa2\x3e\x76\xa0\x7d\x16\x20\x03\xbb\x12\x19\x84\x4b\x50\x1f\
\xdd\x16\x19\x10\x87\xec\xb7\x17\x91\x47\x2b\x84\x34\x87\x3c\x87\
\xc1\xdb\x41\x76\xfd\x7a\xd4\x0f\x6c\xb3\xfb\xf4\x40\x7d\xc8\x02\
\x24\x9b\x76\x93\x2c\xd6\x38\x0d\xc9\x81\xde\xc8\xf0\x58\x6d\xcf\
\x5b\x65\xcf\x33\x3f\x73\xfd\xd3\xf6\x4c\x07\xad\x9c\x2e\xb4\x32\
\x4a\x7b\x12\xcb\x90\xc1\xd1\xd7\x3e\xfb\xd1\x22\x61\x1b\xec\x39\
\x96\xda\x3b\x58\x6f\x79\x19\x63\xc7\x9f\x46\x7d\xe1\x2e\x7b\xee\
\xb5\xf6\xce\xc7\x5b\xf9\x2c\x41\xfd\x5a\xb5\xa5\x11\xc2\x9f\x17\
\x5b\x1e\x7b\x90\x4c\x11\xd9\x64\xe7\x85\x77\x54\x63\xd7\x07\x8f\
\xf6\x62\x34\x67\xb4\xbd\x3d\x77\x73\x57\x8a\xdb\xa0\x77\x35\x9d\
\xc2\x83\x46\x47\xd3\x86\x2a\xd1\xc0\x79\x5f\x54\x77\x56\xa0\x29\
\x5f\xfb\x91\x6e\xb0\x14\xb5\x83\xf5\xa8\xde\x74\x42\xef\x65\x13\
\xf2\xe4\xae\x26\xd9\x71\xe1\x2d\xd4\xb6\xf7\xa0\x77\xd1\x1d\x4d\
\x35\xaa\x41\xf5\xab\x2d\x1a\x08\x59\x84\xf4\xc0\x55\xc8\x78\xee\
\x68\x69\x05\xb9\x7b\x08\xd5\xf5\x6a\x92\x3a\xdf\x9f\x44\x96\x6e\
\x46\x75\x7a\xae\x9d\x3b\x0a\xd5\xbd\x79\x96\xc6\x96\xa3\x78\x7e\
\xe7\xe4\xa3\x1d\x9a\x12\x33\x25\x9a\xd8\xbf\xdd\xce\xfb\xee\x18\
\xd2\xa9\x57\xfb\x72\x62\x8f\x88\x77\x8e\x33\x87\xaa\x63\x3e\xf7\
\xf0\xaa\x9d\x0f\x2c\xdc\x71\x0f\x12\xa8\x85\x84\x4d\x3a\x64\x2c\
\xad\xd4\x14\x1a\xa9\x0f\x42\xac\x50\x28\x5b\x3a\xdc\xab\x50\x08\
\x57\x8e\xc2\xa1\x50\x71\x91\xef\x51\x81\xf3\x0a\xad\x38\x9d\x4f\
\xfd\x2d\x96\xdf\xf4\x31\x4a\x48\x33\x94\xcb\x29\x68\x11\xb1\x6f\
\x92\xcc\x8d\x2a\x56\x86\x85\xee\x1d\x9e\x23\xfd\x7b\x78\xae\x42\
\x79\xcb\x53\xfb\xfe\xe9\x32\xcd\x96\x73\xf6\x7b\x73\xa0\x06\xf8\
\x34\x12\xe0\x0f\x73\xa4\xd7\x3b\x1b\x72\x9f\x3e\x96\x2e\x8f\xf4\
\x79\x79\x8e\x2c\xb3\xfa\xde\x47\x3a\x1c\xb2\x58\x9d\x8b\x32\xf7\
\xcb\xa6\x97\x2f\x90\x46\xb1\x76\xe5\x38\x4d\x95\x4a\x14\xe6\xfb\
\x07\x64\x88\x1d\x8b\xfa\x9a\x9e\x32\x92\x25\x4f\xdd\xa1\xc8\xe1\
\x1c\x38\x32\xec\xb2\xae\xbc\xe5\x91\x21\x32\x14\xcd\x7b\xcc\x6e\
\xf9\x94\xed\x77\xdf\x8b\x8c\x97\x39\x68\x4e\xeb\x6a\x34\x6d\x25\
\x1d\xfe\x99\x4d\x3f\x9b\x5e\xb1\x7e\x3e\x7d\x1f\xa8\x5b\xae\x15\
\x93\xa3\x31\x32\x4a\xaf\xb2\xf7\xb2\x8a\xda\xfd\x4d\xb6\x9f\x89\
\xa8\xbf\xef\x4a\xa7\x9f\x47\xc6\xce\x05\x28\x82\xe6\x07\x24\xc6\
\x7f\x5a\xe6\x16\xca\x63\xba\x4f\x4d\xdf\x27\xfb\xec\x17\x21\x63\
\x68\x2e\xcd\xbb\x1f\x0c\xeb\x5b\x7c\x05\x45\x31\x35\xd6\xe8\x2b\
\xf4\x7e\xd3\xd3\xae\xd2\xe5\x4c\x81\xf3\x0a\x5d\x3b\x02\x45\x2c\
\xcc\x45\x06\x6f\xb1\xba\x57\x28\xcd\x74\xe8\x3f\x14\xae\x0f\xe9\
\xef\x85\xea\x66\x73\xd3\x65\x9c\x84\xb0\xde\xc1\x27\x80\x3f\xf5\
\x39\xc2\x4e\x53\x24\x77\x14\xc7\xd3\x1d\x56\x5d\x8b\xa2\x64\xcf\
\xa5\x8e\x6b\x4a\x35\xec\x8a\x75\x96\xb9\xcc\xdf\x52\xae\x29\xe5\
\xf7\xb0\xb8\xcb\x73\x68\x24\xb3\xae\x50\xe4\x62\xf7\xae\xef\xf7\
\xa8\x8e\x74\x72\x45\xd2\x6a\xc9\xe4\x1a\x70\xac\xd4\x6b\x8a\xd5\
\x85\xa8\x84\xeb\xeb\xbb\x47\x7d\x75\xc1\x71\x5a\x12\x75\xf5\xbb\
\xb9\x02\xe7\xd6\x77\x4e\xb1\x63\xd9\xdf\x67\x59\x7a\x6d\x90\x67\
\xb9\x58\x3a\x31\x5a\xe8\xee\x12\x64\x04\xbe\x49\xed\x48\xa0\x52\
\xf2\x5d\xdf\xb3\xd6\xd7\xbf\xe7\xea\xb8\x3e\x7d\xec\x15\x64\x4c\
\x66\xd3\x2b\x26\xaf\x4a\xe9\xbb\x82\xd1\xdc\x0a\x45\xc8\x3c\x44\
\xed\x05\xfd\xb2\x32\xb7\x94\xbe\xb3\x50\x9f\x3c\x1f\x79\xa6\xbd\
\x4f\x3c\x3a\x4a\x7d\xbf\x47\x53\x57\xfb\xa3\x28\xa7\x97\xa8\x5b\
\x87\xab\xab\x9e\x53\xc7\x75\xa5\xa4\xe1\xb4\x00\xdc\x10\x76\x9c\
\x93\x87\x08\x85\x88\xfd\x11\xef\xb8\x1d\xc7\x71\x4e\x76\x0e\x91\
\x28\xfa\xf5\x0d\x90\x6e\x01\x7e\x9b\x39\xd6\xd4\x06\x24\xf3\x24\
\x0b\x5b\x1e\x6b\x22\x64\xfc\xfe\xb7\xfd\x7f\x3c\x64\xe0\xce\xe3\
\x94\x77\xe7\xe8\x79\xc6\xfe\x06\xcf\xb2\xe3\x1c\x17\x5c\x99\x76\
\x9a\x2a\x85\x42\x84\x4b\xb9\xe6\x78\x9c\xdb\x54\x48\xaf\xd8\x79\
\x22\x9f\xe9\x44\x95\x5d\x53\x7d\x67\x71\xea\x53\xd7\x4a\xe4\xc7\
\xea\xf9\xb3\x7f\x1d\xc7\x69\x1c\x0d\x91\x37\xc7\x8a\x52\x95\xfc\
\xe0\x15\x0d\x9f\xfa\xae\x6b\xea\xcf\xd3\x50\xc2\xf3\x9f\x8c\x79\
\x6f\xce\xc4\xf5\xfc\x7f\xb4\x84\xf7\x7c\x22\xdb\xa6\xd3\x02\x70\
\x43\xd8\x69\x8a\x44\x68\x85\xe2\x5b\x39\x3a\xc1\x74\x39\xa5\x6f\
\x84\x7e\x19\x9a\x9b\x75\xb2\xac\x0e\x59\x89\xe6\xcb\x84\xed\x2f\
\xb2\xe4\xd1\x6a\xd8\xa7\x1e\xc7\x67\x8a\xd1\x62\x18\x57\xf1\xee\
\xaf\x10\x1d\xa1\x15\xb0\x07\x1d\xc7\xe7\x3b\x5a\xf2\xc0\x69\x68\
\xbe\xf6\x57\xd1\x7c\xab\xf7\xa3\x95\x5e\x1b\x2a\xb8\xf3\x68\x21\
\x98\x73\xa9\x6d\xf0\xb6\x41\x2b\x7a\x77\x46\xab\x66\x0e\x40\xf5\
\x7d\x7c\x13\x2a\x0f\xc7\x39\x19\x09\x73\x75\x3f\x85\xda\x59\x29\
\x6d\x37\xb4\xd3\x0b\xa8\xbf\xfd\x85\x73\xcf\x29\x31\xed\xc6\x92\
\x43\x2b\xd0\xf7\x79\x97\xee\xe7\xb4\x6c\xf2\x48\x5e\x5d\x45\xed\
\xc1\xfa\xf7\xa0\x85\xdf\x1a\x23\x9f\x62\xb4\x08\xd7\x78\x1a\xaf\
\x73\xe4\xd1\x4a\xe9\xe3\x1b\x99\x27\xa7\x99\xe1\x86\xb0\xd3\xd4\
\xc8\x23\x01\x3e\x09\x19\xab\xbd\xa8\x6d\x10\xa4\x3d\x6f\x79\x6a\
\x2f\xd2\x70\x90\x64\xa9\xff\x7c\xe6\x1a\x52\xe7\xc7\x68\x6f\xdf\
\x9e\x99\xeb\xe3\x02\xf7\x22\x73\x4e\xbe\xc8\x39\xf9\x7a\xce\xcd\
\x3e\x63\xf6\xdc\x62\xd7\x85\xef\x65\xa8\x03\x6f\x97\x49\x33\x5d\
\x1e\x23\xd1\xfc\xa9\x7c\x91\x34\xb2\x0b\x5a\xa4\x8f\x97\xf2\x4c\
\x79\xb4\xda\xe3\x38\x92\x45\x2a\xb2\xe7\x52\xc7\x3d\xb2\xe9\xc5\
\x14\x7f\x3f\x85\x16\xaf\x38\x95\x64\x20\xa0\xd0\xbd\xb3\xf7\x20\
\xf3\xbd\x94\x77\x73\x34\x84\xc5\xcb\x7a\xa1\xc5\x3c\x9e\xb6\xff\
\xdf\x4b\xed\x05\x5e\x8a\xbd\xd3\x62\x75\x2f\xec\xf7\x9b\x7e\xb6\
\x72\xf4\xfe\xdb\xa0\xd5\x37\xab\xd0\x4a\xcf\x03\x8f\xc1\x73\x38\
\x4e\x4b\xa6\x2d\x1a\x54\xba\x00\xc9\x85\x62\xfd\x45\xfa\x3b\xa8\
\x8d\x1e\x4a\x1d\x2b\xd6\xa6\xf3\x68\xe0\x6a\x28\xc5\xfb\xfc\x62\
\xf2\xa6\x14\x39\x94\xbd\x77\xb5\x7d\xae\xc4\x75\x3c\xa7\xe1\xe4\
\x49\x56\x50\xaf\x8b\x18\xad\xda\x3c\x2e\x73\xfc\x2c\xb4\xe2\x73\
\xb6\x0e\xa7\xd3\x2f\xa6\x03\x84\xef\x79\xd4\x26\xaf\x24\x59\x00\
\xab\x2e\x5d\xac\x58\xdb\x09\xc7\x0e\x91\xec\xc0\x71\x34\x6d\xcc\
\x69\xc6\xf8\x1c\x61\xa7\xa9\x11\xa3\x25\xcd\xc3\xbe\xbf\xe7\xa2\
\xd5\x41\xbb\x22\x8f\x67\x25\xda\xd6\x61\x1e\x32\x0a\x46\xa2\xed\
\x67\x5e\x42\x5b\xc2\xe4\xec\xf8\xa5\xa8\x73\xde\x89\x16\x19\x59\
\x83\x0c\xa9\xc9\x68\x49\xff\x7e\x24\x7b\x13\x5f\x81\x3c\x9d\x79\
\xb4\x9d\xd1\x66\xb4\x4f\x63\x39\x9a\xef\xf4\xb2\x5d\xd7\x1f\x6d\
\xa3\x34\x05\x29\x1a\xd7\xd8\xdf\x3e\x68\xab\xa3\x69\x68\x31\x8f\
\xcb\x91\xe7\x72\x33\x32\x8e\xb6\x91\x78\xb6\x5b\xa1\x95\x29\x87\
\xdb\xf3\xbd\x66\x9f\x2b\x2c\x2f\xdd\x91\x41\xff\x18\x9a\x0f\x75\
\x11\x70\x06\x5a\x7c\xa4\x3d\x47\x1a\x78\x43\xed\xda\x83\x76\xcf\
\xa5\x48\x00\x8d\x41\x0a\xde\x8b\x24\xde\xe2\x0a\xb4\x9a\xe7\x4b\
\xc8\xa8\x1a\x6e\x65\xd5\x0a\x78\x0a\x2d\x4c\x31\x0c\x2d\xc8\xd2\
\x0a\x6d\xcd\xf4\x8a\x9d\x73\x35\x32\xf8\xd2\x2b\x7c\x4e\xb0\x7b\
\xb5\x45\xdb\x1a\x4c\x41\x1e\xd2\x31\x76\xaf\x97\x2c\x9d\x0b\x2c\
\xbf\xb3\xec\x59\x2f\x41\x5e\xd3\x2e\x96\xde\xe3\x68\xbb\x82\xb1\
\xc8\x33\x13\xa1\x6d\x7d\x66\x17\x78\xde\x89\x56\x3f\x42\x19\xed\
\x26\x51\x60\xc3\x5e\x9b\xcb\xd1\x7e\x81\x8f\xa2\x05\x68\x26\xd9\
\x3b\x5f\x8a\x46\xad\x7b\x5a\x7d\x78\x16\x2d\x3e\xd6\xd8\x70\xb8\
\x4d\x56\x97\xaa\xd0\xd6\x5d\x93\xad\x1e\xf6\x40\x02\xbc\x33\xda\
\xbe\x61\xaa\xbd\xa3\x33\xad\x5c\xda\x5a\x1e\xde\x06\x6e\x23\xd9\
\x33\x7a\x15\xc9\xbe\x9c\x17\x21\x05\x63\x8f\x9d\x1f\x93\xd4\x73\
\x17\xd4\x8e\xd3\x38\xf2\xa8\xcf\x2b\x47\x73\x12\x27\xa1\x55\x99\
\xcb\xd0\x40\x6c\x1b\xd4\xef\xaf\x42\xb2\x60\x3c\xda\xce\xe7\x51\
\x3b\x27\x7c\xce\x41\xed\xfa\x30\xda\x8e\x66\x01\x92\x0b\xd7\xd8\
\xef\xdd\xd1\xb6\x3d\x15\xa8\x6f\x1a\x69\xf7\x0c\xfd\xdc\x35\x68\
\x90\x33\x42\xfd\xe8\x99\x96\xaf\xdd\xa8\xdf\xd8\x88\xf6\xb8\x2d\
\x43\xf2\x6f\x33\xda\x56\xf0\x00\xea\x33\x4f\x47\x7d\xdc\x73\xa8\
\xff\x7b\x03\xf5\xb3\x83\x50\xdf\xec\x06\xb1\x73\xb4\xf4\x47\x7a\
\xd7\x12\x92\x81\xd9\x62\x84\x95\xa1\xdb\x52\x7b\x0f\xdf\x1c\x8a\
\xec\x5b\x60\xe9\x0c\x42\xfa\xcc\x6a\xb4\x2a\x74\x3b\xd4\x26\x9e\
\x46\xf5\x74\x28\xaa\xb7\x6d\xd0\xf6\x48\x33\x90\xcc\x3f\x1d\xb5\
\xb1\xb9\x48\xdf\x19\x80\x74\x86\xa7\x51\x3b\xba\x12\xe9\x62\xbd\
\x51\xdd\x7f\xd1\xf2\x7f\x19\x92\xc9\x4b\x51\xfb\x2e\xb7\xbc\xb5\
\xb2\xdf\x86\xa3\x36\xf6\x2c\x6a\x63\x57\x23\x39\xdc\x0b\xe9\x7a\
\x4f\x70\x6c\x74\x04\xa7\x09\xe3\x9d\xa3\xd3\xd4\x68\x8b\x8c\xab\
\xe9\xc8\x90\x3a\x07\x75\x96\x6d\x80\x1b\x48\xf6\x04\xfe\x04\xea\
\x40\x67\xa3\x8e\xb6\x3b\x32\x86\x7a\xa1\xce\x6c\x02\xea\xdc\x0e\
\x03\x1f\x45\x1d\xf0\x07\x51\x87\xb8\x04\x29\x29\xa0\x4e\xb9\x3b\
\xf0\x24\xea\xf0\xee\x44\x1d\xe7\xb5\x68\x61\xaa\x37\x80\x5b\xd0\
\xde\xba\x4f\x5b\x5e\x3e\x84\x3c\xa3\x57\x23\x83\xec\x15\x14\xb6\
\x3c\xc4\xf2\x38\x0c\x19\x96\x95\xc0\xfb\x48\x06\x9c\xf2\x76\xce\
\x58\xa4\xb0\x2c\x46\x21\xe0\x9d\x2d\x1f\x63\xd0\xfe\xc6\x3d\x91\
\xc1\x36\xda\xd2\x9d\x81\x94\xb0\xe0\xc1\x86\x64\xcf\xc7\xbb\x91\
\x62\xb6\x00\x09\x81\xa0\xd8\x5d\x68\xd7\x01\x7c\x0c\x09\x9e\x57\
\xec\xb9\x26\x5a\x3e\x2e\x44\x8a\xd8\x01\xe4\xc5\xec\x65\xe9\xad\
\x41\x82\xe4\x0a\x2b\xc7\x6b\xec\xfc\x69\xc8\x18\x6f\x87\x8c\xf6\
\xc9\x68\x95\xcd\xe7\xec\xdc\x51\x48\x90\x9d\x87\xf6\x78\x0c\x65\
\xb5\x10\x29\x97\xef\xb5\x67\x1a\x83\x14\xbd\x97\xec\xbd\xde\x88\
\x04\xdb\x07\x91\xf0\x9b\x69\x65\x3e\x82\xda\xa3\xb6\x6d\xed\x5d\
\xbd\x68\xef\xef\x4a\x24\xec\x26\xd8\xb1\xf9\xc0\xed\x96\xe6\x38\
\x2b\x87\x30\x28\x92\x07\xee\xb2\x77\x3b\xc5\xee\x77\x23\x8d\x17\
\x70\x79\xcb\xe7\x47\x50\x68\xe5\x2d\x56\xee\x65\x56\x96\x55\x56\
\x6f\x4e\x43\x82\xb7\xa7\xe5\x7b\x31\x52\x8c\xef\xb6\x67\xba\x08\
\x0d\x0e\xbc\x6c\xe7\x0c\xb5\x6b\xae\xb6\x63\x7b\xed\x3c\xec\x78\
\x63\xc2\xaf\x1d\xc7\x11\x11\xea\xaf\x16\x21\x45\x79\x10\x1a\x24\
\x8d\x50\xbf\xd1\x0b\xb5\xbf\x1b\xd1\x40\xea\x8b\xa8\xad\x8e\x44\
\x7d\xcf\x30\xd4\x1e\x6f\x45\x7d\xde\x52\xd4\xa6\x87\xa2\x69\x12\
\xd5\x76\xbc\x17\xd2\xb7\x06\x22\xa5\xfe\x79\xd4\x2f\xde\x85\xda\
\xf2\x24\x24\x07\x5e\xb6\xef\x13\x51\xbf\x7a\x10\xf5\xdf\x9d\xec\
\xbe\x3d\xed\xf8\x19\x68\x90\xf8\x2c\xd4\x9f\xbc\x80\xe4\xc0\x87\
\x91\xf1\xb2\x1b\x0d\xc0\xa6\x3d\xdc\x8e\x53\x0a\x31\x92\xef\x5f\
\x03\xbe\x8f\xe4\x7c\x7d\xa1\xc4\x31\xd2\xd5\xbe\x61\x9f\xaf\xa1\
\xb6\x71\x08\xe9\x0c\x93\xec\x9c\xf3\x91\x0c\xee\x8d\x1c\x06\xf3\
\x90\xc1\xf9\x61\xd4\x36\x3e\x8e\x16\x85\x7b\x01\x19\xc4\xe7\x21\
\x03\x79\x0d\x6a\x5b\xef\x41\xb2\xfb\x29\xcb\xe3\xed\xa8\x6d\x5c\
\x83\xea\xfc\xeb\xa9\x73\x6e\x40\xed\x78\x1a\x6a\xbb\x7d\x51\xbb\
\x1c\x80\xf4\x95\x89\x68\x90\x69\x9f\xdd\xb7\x13\xd2\x89\x7a\xdb\
\x35\xa7\x59\x7e\x3d\x8c\xba\x99\xe3\x86\xb0\xd3\x94\xc8\xa3\x8e\
\x6a\x08\x52\xfa\xbb\x23\xc5\x64\x14\xea\x44\x37\xa1\x0e\x72\x01\
\x1a\x0d\x9c\x81\x8c\xa6\x3c\x32\xba\x6a\x90\x71\x3c\x16\x75\x70\
\x73\xd1\xc8\x7d\x5b\xd4\xc1\x85\x11\xf3\x97\x49\xf6\x09\x7c\x03\
\x75\xc6\xc3\x91\xb2\xd2\x0d\x68\x6d\xf7\x9a\x81\x46\xde\x47\xa2\
\x91\xc1\x79\x68\xdb\x86\x01\xc8\xdb\xb7\x06\x29\x34\xaf\x21\xcf\
\x73\x3f\xa4\x98\x74\x40\x1d\x78\x77\x7b\x9e\x0e\x24\xfb\x17\xae\
\xb2\x67\xe8\x8f\xc2\x68\x3b\x5b\xde\x0f\xd8\xf1\x37\x2c\x6f\xdd\
\xed\x39\x96\x58\x3e\x9e\xb5\x6b\xd3\xfb\x3c\xf6\x45\xc6\xf6\x33\
\xa9\xb2\x08\x9e\xc2\xf9\x68\x90\xa0\xbb\x3d\xf7\xd3\x48\x21\x7b\
\x15\x09\x00\xec\xfb\x4c\xfb\xdb\x19\x19\x74\x43\x90\x40\x9a\x80\
\x04\xc3\x58\x7b\xfe\xe7\x2c\xbd\xa7\x90\x51\xb6\xd7\xca\xa4\xad\
\x5d\xd7\x1e\x79\x78\xb1\xf7\x33\xdb\xca\x63\xad\x95\xd1\xcb\x48\
\xd9\x3c\x1d\x29\x87\x2f\x23\xe3\x78\xb6\xdd\xe7\x54\x3b\x7f\x38\
\x12\x40\x9d\x49\x42\x09\xb1\xe7\x3e\x6c\xf9\x98\x63\xcf\xd7\xc7\
\xea\xc1\x54\xfb\x3e\xc8\x9e\xb7\xc6\xd2\x3d\xc3\xd2\xab\xb6\xf3\
\xce\xb2\x3c\x9e\x67\xf7\x1c\x45\xe2\x85\x6d\x28\x11\x32\x76\xf7\
\x20\x41\x1c\x3c\xdb\x83\xec\x99\x7a\x20\x85\xb5\xa3\xdd\xaf\xdc\
\xf2\xff\x0a\x49\x64\xc1\x60\x2b\xcf\x19\xf6\xbe\x0f\xd9\x3b\x1c\
\x6b\x65\xf9\x9a\xbd\xe3\x75\xf6\x7e\xb3\xfb\x8d\x3a\x8e\x73\xf4\
\x84\xbd\x54\xcf\x42\xfd\xc0\x70\xd4\x17\x9f\x67\xbf\xed\x43\x7d\
\xd7\x5c\xb4\x8f\xf8\x4c\xfb\x6c\x23\x89\x66\xc9\xa3\x3e\x6d\x1e\
\x6a\xd3\x53\x91\xec\xb8\x10\xc9\x92\x27\xed\x9a\x17\x2c\xcd\xb5\
\xa8\x0f\xeb\x87\xfa\xd9\xce\x48\x3e\xec\x45\xfd\xf0\x72\x12\xf9\
\x35\x07\x45\xbd\xb4\x45\xf2\x62\x57\xea\xf8\xdb\xa8\xcf\x3b\x13\
\xf5\x65\x13\x48\x8c\xf8\x5e\xa8\x8f\xd8\x8e\x64\x84\xe3\x1c\x2d\
\x79\x24\x87\xd2\xa1\xc4\x75\x11\x21\x99\xfb\x6f\xf6\xf9\x77\x60\
\x05\x92\x57\xaf\x20\xbd\xe2\x14\xd4\xc6\x66\x58\xfa\xaf\xa0\x3a\
\xff\xa4\x9d\x77\x01\x92\x87\x4f\xa1\xe8\xb1\x17\x91\x2e\xb0\x0b\
\xd5\xe5\x7d\xa8\x9e\x77\x40\x32\xb5\x2b\x1a\x54\x6f\x8d\x06\x95\
\x9f\xb7\xf4\xf6\xa2\xf6\xb9\x8e\xc4\x98\x9d\x8d\x74\xb9\xb0\xd7\
\xf5\x78\x64\xec\xce\x41\x11\x69\x15\x96\xbf\x9d\x24\xba\xe3\xdb\
\xc8\x28\x76\x59\xdb\xcc\xf1\xd0\x68\xa7\x29\x11\xa1\x4e\x6b\x37\
\xea\x38\x41\xa3\x85\x97\xa0\x6d\x23\x0e\x90\x84\xe0\x54\x93\xcc\
\x9d\x85\x23\x43\x68\xcb\x48\x36\x54\x8f\xec\xfc\x10\xae\x43\xea\
\xba\xeb\x90\x21\xf7\x2a\xea\x38\xfb\x93\x18\x5d\x35\x24\xf3\x52\
\xd2\xe9\x85\x7b\xa4\xf3\x13\xee\x5f\x83\x0c\xbe\xf9\xa8\x83\xae\
\x44\x86\x68\xd8\xb4\xfd\x1c\x34\x82\x3f\x03\x29\x57\x87\x53\xbf\
\x1d\xa4\xf6\x82\x10\x79\x92\x36\x5a\x68\xab\x8c\x90\x9f\xec\x1e\
\x8a\xb1\xa5\x95\xde\x54\x3e\xfd\xdc\x61\xee\xcf\xfe\xcc\x35\x20\
\xa1\x33\x13\x09\xc0\x25\x48\xe9\xbb\x23\x95\x8f\xf0\xac\x03\x90\
\xe7\xe3\x4d\x64\xa0\xef\x4a\xdd\xe3\x50\x2a\xcd\xf4\xf3\x84\x7b\
\x63\x65\x97\x1d\x88\xdb\x82\x46\x74\x6b\xec\xde\x2b\x32\xe7\x54\
\x59\xda\xe1\x58\x1e\x09\xc6\x9b\xec\xfd\xad\xb7\xe7\xce\xd9\x33\
\x7c\x14\x29\x9a\xf3\x90\x10\x3d\x64\xdf\xd7\x20\x03\xb3\x86\x64\
\x4e\x79\x43\x89\x2c\x9f\xf7\x5b\x5a\x03\x80\xbf\x46\xca\xe8\x7e\
\x24\x68\xb7\x5b\x9d\xd8\x45\xe2\xd5\x0f\x03\x23\x61\xe0\x22\x6f\
\x75\x21\xfd\xbc\x79\x24\xa0\x8b\xbd\x7f\xc7\x71\x1a\x4e\x30\x62\
\x2b\xd1\x40\xd5\x69\x68\x20\xeb\x02\xa4\x0c\x07\x23\x20\xf4\x5b\
\xd5\x1c\xd9\x5f\x86\x74\xd2\xfd\x5c\x90\x4f\xe9\xbd\x55\x43\x3b\
\x3f\x8b\x24\xca\x27\xdd\x5f\x55\xdb\xbd\x42\xff\x1a\xae\x0b\xed\
\x3e\x4e\xe5\x27\xdb\x6f\xae\x42\xfd\x5f\x05\xf2\x32\x6f\x20\xe9\
\xf3\xdd\x9b\xe5\x1c\x2d\x11\x32\x26\xff\x01\x0d\xb2\xac\xa6\x34\
\xa7\xd9\x7e\x34\x08\x14\xe4\x5a\x90\xd5\x2b\x91\xec\xbb\x01\xc9\
\xfd\x95\xc8\x20\x86\xda\xfa\x49\x0d\x47\xea\x2a\x31\xb5\xe5\xde\
\x61\xa4\x73\xbc\x85\xa2\xbd\x72\x76\xec\x00\xb5\xf5\xb3\x1c\x1a\
\x6c\x5f\x81\x3c\xd3\xb7\x52\x7b\x3a\x51\x56\xa7\x0b\xed\x2e\xac\
\xcf\xf1\x6e\x2f\x06\xea\x9c\x40\xdc\x23\xec\x34\x15\x62\x34\x82\
\x3e\x0e\xf8\x21\xf0\x5d\xfb\xfc\x27\x1a\xf5\x3b\x85\xda\x9b\xaa\
\xa7\xeb\x6e\x30\x70\xcb\x50\x27\x36\x1b\x85\xdd\x5c\x88\xe6\x5e\
\xee\x42\x23\xf2\x11\x52\x42\x42\xc8\x2f\x68\x54\x7d\x1b\x52\x1e\
\xfa\x23\xa5\x28\x3d\xc7\xe5\x00\x32\x9e\xae\x47\x0a\xd2\xed\x28\
\x54\x67\x1b\x32\x0e\xd3\x9d\xf6\x61\x64\xc8\x85\xb9\xb7\xa7\xdb\
\x27\xad\x8c\xf4\x40\xca\xcf\x0a\x64\x14\x75\x4a\x3d\x4f\x50\x78\
\xc2\xfd\xe7\xa2\x01\x81\x2b\x91\xc1\x3e\x84\xda\x1e\xd2\xb5\x68\
\x04\xf3\x66\x14\x76\x1b\x56\x25\x4d\x6f\xb1\xb1\x04\x29\x48\x37\
\xa1\x50\xbf\x89\x48\x09\x4b\x97\x61\x64\xcf\xb2\x12\x0d\x3c\x0c\
\x45\x9e\x91\xcb\xec\xef\x1c\x2b\xcf\x8b\xad\x1c\x3a\x90\x84\x48\
\xbf\x8d\xe6\xdb\xf4\x4a\x3d\x43\x99\x7d\x9f\x8f\x46\x54\xaf\xb5\
\x67\x18\x61\x69\xa5\x85\x5d\xb8\xf7\x62\xa4\xe4\x05\x2f\xf9\xa5\
\x1c\xb9\x30\x58\xfa\xba\xf0\x7c\xdd\x90\x00\x5d\x8e\x46\x88\x3b\
\xdb\xf1\xb5\x48\x30\x9f\x69\xf5\x61\xaf\xbd\xc7\xd1\x96\xdf\x73\
\x38\x76\xab\x86\x87\xb9\x48\x57\xa0\xd0\xe8\x5d\x48\x50\x2f\xb5\
\xfb\xb5\xb6\xb2\x1b\x60\x79\x9d\x60\xe7\xdf\x8c\x94\x85\xe5\x56\
\x06\xe9\xf7\x91\xb3\x7c\x8f\xb1\xb2\xbf\xde\xae\x0f\x02\x3c\x5d\
\x67\x1c\xc7\x39\x7a\xc2\x7a\x0d\x0f\x01\xff\x0a\x7c\x0f\xf8\x17\
\x24\x03\xc6\xdb\x39\xd9\xfe\x26\x7c\x4f\x6f\x65\x34\x1b\x45\x7f\
\x5c\x8e\x94\xfd\x6e\x48\xde\xac\x41\xfd\xc1\x24\xd4\x9f\x85\xb9\
\xc2\xd5\xa8\xff\xef\x8e\xfa\xd2\x74\x5b\xae\x42\x46\xed\x65\xd4\
\x96\x5f\x6b\xa9\x2d\x6f\x42\x5e\x5e\x47\x32\xa5\x2b\xea\x3b\x2f\
\x4e\xe5\xab\xbb\x5d\xe7\x38\x0d\x61\x2b\x92\x61\xa5\x0c\x16\xe7\
\x48\xe4\x52\x94\xf9\xff\x10\x89\x4e\x36\x0f\xe9\x54\x20\xa7\xc7\
\x25\xa8\x8d\xec\x46\x6d\xa6\x06\xc9\xc5\x49\xa8\x6d\xce\x44\xb2\
\xbb\x9b\x7d\xde\x40\x11\x6a\xad\x51\xc4\x57\x08\xfd\xcf\xea\x06\
\x65\xa8\x2d\x8e\x43\xf2\x75\x5b\xea\xbc\x1a\xd4\x6e\x2e\xb1\x7b\
\xdc\x8a\x06\xca\x57\x73\x64\x1b\x73\x1b\xa9\x05\x50\xd6\xaf\x63\
\xe5\x57\x6f\x39\xb5\x4b\xeb\xf6\x95\xfe\xbe\x9d\xe3\x4f\x4d\x1e\
\x1e\x5f\xbc\xeb\xe0\xa2\x2d\x07\x9f\x44\xa1\x2a\x69\x45\xbe\x2b\
\xc9\x9c\xaa\xa0\xf0\xef\xb6\xdf\xb6\xa3\x8e\x79\x05\xc9\xa8\xde\
\x52\x92\x11\xfb\x25\x24\x21\xb0\x73\xed\xfb\xa9\x48\x89\x78\x00\
\x2d\x84\xb0\x1c\x19\x3f\x6d\x91\x47\xf0\x2d\xd4\x31\x87\x70\xb2\
\x37\x51\x67\x18\x16\x2b\x5a\x8a\x8c\xdb\x65\x48\x39\x1a\x89\x46\
\xf1\x1f\x46\xc6\x6c\xde\xd2\x0c\x21\xd9\x2b\x51\x48\x4f\x39\x0a\
\x83\xdd\x8b\x42\x92\x77\xa7\x9e\x73\x03\x52\x7e\x06\xd9\xb3\x2c\
\xb3\xeb\x0e\x59\xda\xbb\xec\xfa\x3d\xc8\x68\xdc\x88\x8c\xa1\x43\
\x68\xb4\x3f\x84\xce\x06\xaf\xf5\x52\x92\x10\xbb\x85\xc8\xa0\xdc\
\x6d\xe5\xb5\x1e\x19\x83\xcb\x90\x11\xdd\x93\x24\xb4\xae\xdc\xce\
\xd9\x64\xdf\xab\x90\x90\x59\x8c\x42\x75\xfb\x23\xe1\x15\x16\x9f\
\xc2\x9e\x69\x95\x9d\x33\xd7\xd2\x1e\x89\x84\xc8\x5c\xcb\xeb\x76\
\x24\x74\xd6\x59\x3e\x56\xda\x75\x9d\x50\x08\xd2\x5b\x56\x96\xeb\
\xed\xdc\x72\x4b\x67\x2e\xc9\xe8\x6d\x2f\x34\x47\xfc\xcd\x4c\xf5\
\xa9\x40\x8a\xdd\x6e\xfb\xbe\x1b\x19\xf5\xad\xec\xbd\xae\xb5\xbc\
\xad\x46\x03\x04\x7b\x2c\x1f\x73\x49\xbc\xcc\x1d\x90\x41\xbe\x81\
\x64\x0e\x5e\x5d\xc6\x64\x8c\xbc\x38\x7b\x2c\xed\x6c\x47\x59\x66\
\xcf\xd6\x0b\x0d\xaa\xec\x04\x7e\x6f\xcf\xb7\xc4\xca\x7c\x88\xbd\
\xa7\x17\xac\xae\x75\xb1\xfb\x56\x00\x7f\x44\x9e\xf0\x4a\x7b\x4f\
\x7b\xec\xf8\x4e\xab\xa3\x5b\xad\x1e\xef\xb5\xf7\xfb\xb6\x3d\xcb\
\x1a\x4b\x63\x3d\x47\xb6\x23\xc7\x69\xce\x94\x21\x23\x71\x11\x0d\
\xaf\xfb\x61\xcd\x81\x8e\x68\xad\x82\x03\x96\xee\x21\xd4\x9f\x05\
\x59\xb2\xca\x7e\xab\x40\xfd\xd3\x1e\xd4\xdf\xac\x42\xfd\xcf\x2e\
\x24\x43\x36\xa1\x76\x5a\x01\x3c\x68\xe7\x2e\x45\x46\x6a\x3f\xcb\
\xeb\xdb\xa8\x3f\x6d\x8b\xfa\x84\xd5\xa8\x4f\x59\x43\xe2\x29\xdb\
\x6b\xc7\xab\x90\x92\xbf\x07\xf5\x11\x3b\x48\x06\x2b\x0f\xa0\xfe\
\x62\x0b\x92\x37\x3b\x91\x8c\x68\x85\xe4\xcd\x3a\x92\xc5\x25\xa7\
\xe0\x8b\xfd\x38\x85\x69\x83\xda\xd1\x74\x92\xa8\xb5\x34\x47\x13\
\x85\x54\x81\x64\x55\x7a\xfa\x56\x25\xd2\x1d\x76\xa2\xf6\x36\x06\
\x2d\x7c\xba\x17\x39\x0b\x42\xb4\x53\x15\xaa\xe3\x9b\x48\x16\xd4\
\xea\x8b\x42\xa3\x5f\x43\x6d\xac\x1d\x6a\x9f\x53\xed\xba\xd1\x96\
\xee\xd3\xa8\x3d\xd4\xa0\x36\x17\x16\x93\x5c\x8a\xda\xdb\x40\x4b\
\xef\x0d\xd4\xce\x73\x24\xed\xa6\x0a\xb5\xd9\x3d\x48\x47\x0c\x6d\
\x6c\x35\x49\x9b\xdf\x8c\x64\xac\xb7\x9f\xe6\x47\x3b\xe4\x28\x99\
\x12\x4d\xec\xdf\x6e\xe7\x7d\x77\x0c\xe9\xd4\xab\x7d\x39\xb1\x47\
\xc2\x3b\xc7\x99\x43\xd5\x31\x9f\x7b\x78\xd5\xce\x07\x16\xee\xb8\
\x07\x79\x0c\xb3\x86\x45\xbe\xc8\xb1\x74\x98\x6f\xf6\xbc\x6c\x78\
\x72\x36\x24\x2c\x1d\x5e\x16\x67\x8e\xc3\x91\x73\x40\x72\x99\xf4\
\x0b\x5d\x17\x71\x64\x1e\xd2\xc7\xc3\x75\x59\xaf\x5d\x5c\xe4\x7e\
\xe9\xbc\xc7\xa9\x6b\xf3\x05\xce\xa5\x48\x7a\x71\xe6\xf7\xa8\xc0\
\x39\xf5\xdd\xaf\xd0\xb9\xe1\xf9\x42\x5a\xe9\x90\x5e\x0a\xdc\x2f\
\xfd\xbd\x50\xfe\x1b\xf3\xac\xe9\xeb\xb2\xc7\xb3\xd7\xa5\xd3\x2e\
\x54\x0e\xa5\x08\xfa\x1a\xe0\xd3\x24\x03\x20\xd9\x90\xa9\x42\x5b\
\x3d\xa5\xbd\xfb\x79\x6a\x97\xc5\xa5\x48\x88\xff\x17\xb5\xeb\x47\
\xba\xfe\x14\xab\xc7\xd9\xf2\x2b\x54\xee\x8e\xd3\xdc\xa9\x44\x7b\
\x76\xff\x01\x0d\x16\x35\x66\x14\x3f\xdd\xee\xb2\xc7\xb2\xf2\x26\
\xdd\xbf\x67\xfb\xba\x62\xed\xb4\x50\xdf\x5c\xa8\xfd\xc6\xd4\xce\
\x47\x21\x19\x92\x2f\x90\x46\xb1\xf0\xe7\x2b\xd0\x20\xdc\x6f\x8e\
\x6d\xd1\x3b\xcd\x84\x30\x3f\xfe\x2b\x28\x0a\x62\x0b\x8d\x93\x23\
\x59\x59\x0b\x49\x3b\xe9\x8f\xa2\xc2\x0e\x03\xbf\x40\x32\xf5\x7a\
\x34\x20\x7c\x1f\x49\xfd\x2e\x24\x33\xd3\xed\xa8\x90\xbe\x56\x97\
\x2e\x46\x91\xb4\xa0\xb8\x8e\x58\xac\x8d\x39\xcd\x8b\x18\x0d\x52\
\x7e\x02\xf8\x53\x9f\x23\xec\x34\x35\x72\x75\x1c\x8b\x8a\x9c\x57\
\xdf\xef\xa4\x7e\x8f\x8a\x1c\xaf\x2b\x1f\x51\x09\xe7\x14\xfb\xde\
\x90\x3c\xa4\xcf\xa9\x4f\xc9\x2b\xc5\x98\x2b\x74\x4e\xb1\xfb\x95\
\xf2\xac\xa5\x3c\x67\x5d\xe7\x34\xe6\x59\xeb\xfb\x5e\xd7\x73\x1f\
\x8f\x79\xb6\xe9\x79\x80\xa5\xfc\xb6\x96\x23\xe7\x02\x67\x9f\xbd\
\x94\x7a\xec\x38\x4e\xe3\x69\x8c\xbc\xa9\x2f\x9d\xa3\x91\x37\xd9\
\x63\xf5\xdd\xa3\xae\x3e\x22\x87\x3c\x7c\x53\x38\x72\x8e\xa5\xe3\
\x1c\x0f\x0a\xd5\xf5\x60\x78\x76\x43\xd1\x4b\x8f\x93\xd4\xc7\xe5\
\x28\x32\xa2\x8c\x23\x65\x74\x59\x3d\x69\x1f\x8d\x2e\x56\x28\xad\
\x42\xe7\x15\x3a\xe6\xed\xa6\x85\xe0\x86\xb0\xe3\x38\xce\xbb\x43\
\x0e\x85\x3f\x2f\xc3\x85\xac\xe3\x38\xc7\x87\x3c\x0a\x77\x05\xef\
\x67\x9c\x13\x4b\x84\xc2\x92\xd3\x6b\x83\x44\x68\x8a\x54\xf8\xdd\
\x71\x4e\x28\x3e\x31\xd8\x39\x19\x38\x1e\x41\xfb\x47\x93\xe6\xb1\
\xbe\x7f\x5c\xcf\xb1\xb8\x9e\x73\x8f\x86\x52\x17\x83\x8a\x8f\xf2\
\x7c\x27\x21\x1d\xfe\x98\xa7\xee\x77\x56\x28\x0c\xb3\xd4\xb4\x1d\
\xc7\x39\xf6\xa4\xa7\x37\x14\x9a\xea\x70\x32\x52\x6c\x97\x81\x52\
\xfb\x91\xa3\x39\x37\x7b\x5d\x5d\x69\xc5\xf5\x5c\x1b\x17\xf8\x7e\
\x22\x29\x35\xef\xc5\xca\xa1\x21\xe5\xdd\x14\x9e\xbb\x21\x64\x57\
\x52\x4f\x87\x16\x17\xf2\xfc\x36\x36\x14\xbb\xd4\xf3\x1a\x5b\x9e\
\x27\xfa\x7d\x34\x87\xfe\xa8\x49\xe3\x86\xb0\xd3\xd4\xc9\xa1\xf9\
\x24\xc3\x39\x36\x1d\x42\x58\x24\xe5\x43\x68\x71\xa3\x7c\x91\x73\
\x26\xa1\x95\x3b\x41\x1b\xb4\x8f\x3b\x46\xf7\x6f\x83\x56\x9e\x6e\
\x4b\x6d\x41\x71\x1b\xda\x3f\xb2\x1c\xb8\x0b\x2d\x58\xd5\xc9\xf2\
\xd9\x85\x86\x75\xc6\x95\x68\xa1\xa7\xd6\x96\xff\x4b\x0a\x3c\x43\
\x1e\x2d\x4c\x11\xb6\x17\x38\x0b\xcd\x1d\x3a\xd1\x9d\xff\xc9\x40\
\x1e\x6d\xb9\xf2\x2d\xe0\xab\xf6\xf9\x00\x0a\x05\x2b\xb5\xfc\x4e\
\x43\x0b\x6d\xc5\x05\xd2\xee\x8f\xea\x4a\x07\xb4\xb2\x66\xa7\xa3\
\x48\xd7\x71\x9c\xfa\x09\xa1\x9b\x37\x03\x9f\x41\xeb\x01\x4c\xe0\
\xc4\x79\xaa\xf2\x68\x35\xdc\xf3\x39\xb6\x0a\x70\x8c\x64\xe8\x17\
\xd0\xca\xd2\xf5\x9d\x7b\x0a\x5a\xe4\x30\x6b\xdc\x4c\x42\x2b\x6a\
\xd7\x14\xb8\xae\x35\xf0\x3e\xb4\x5a\x75\xda\xa8\x1b\x01\x7c\x0e\
\xc9\xb8\xdb\xd0\xa2\x5e\x85\xee\xd9\x11\x95\x7d\x19\xda\x6d\x60\
\xec\xb1\x2f\xde\x3a\xb9\x1c\x2d\x62\x96\x1e\x14\xe9\x0d\x7c\x0a\
\xe9\x00\xb7\xa1\xba\x72\x59\xe6\xbc\x2c\xe5\x68\x97\x87\x01\x68\
\xe5\xe2\x41\x56\x6e\x67\x53\x5c\xdf\x18\x8d\x16\x76\x6a\x87\x76\
\x78\x68\xcf\xc9\xd3\xd7\x87\x6d\x21\xbf\x89\x64\xe0\x57\x80\x4f\
\xda\x73\x1f\x0f\x27\x42\x6b\x2b\xa3\xfa\xe4\x61\x7a\x9f\x70\x50\
\xbd\x1f\xc9\xd1\xb5\xab\x08\xbd\xcb\x53\x8e\xf2\xba\x63\x45\x6b\
\x12\x1d\xee\x64\xa9\x0f\x27\x1d\x6e\x08\x3b\x4d\x8d\xf4\x88\x7c\
\x58\xe8\xe0\x74\x64\x2c\xe4\x29\x3c\x72\x9f\x3e\x16\xd7\x71\x2c\
\x50\x89\x14\x8d\xce\x14\x1f\xc1\x1e\x89\x84\x13\x68\x65\xb9\xfe\
\x14\x36\x22\xb3\x79\xc9\xe6\x2b\xce\x7c\xaf\x40\x1d\x5b\x56\x19\
\x38\x13\xad\x2e\x9a\x43\x02\xb3\x07\x32\x9a\xcf\xe7\xc8\x6d\x84\
\xe2\x02\xe9\xa6\xbf\xc7\x48\x51\xe9\x81\x0c\xdc\xd6\x68\x35\xd4\
\x83\xa9\xeb\xd3\xd4\xa0\x95\x1c\x5b\x23\xc3\xab\x3b\x4d\x67\x44\
\xbe\x29\x93\x47\x02\xb2\x27\xf0\x24\xf0\x14\x52\x7e\xde\x4b\xe1\
\x85\xc7\xb2\x75\xb2\x0c\xed\xd1\xdc\xa7\xc0\xb9\x69\x21\x9e\x43\
\x2b\xd9\xd6\x25\x88\xe3\xd4\x27\x9f\xf9\xdf\x71\x5a\x12\xa1\xff\
\xab\xaf\xee\xc7\x48\x06\x7c\x06\x29\xd5\xcf\xa0\x95\xd9\x3f\x84\
\xb6\x99\x2b\x26\x6f\xb2\xdf\xeb\xf2\xe4\xa5\xdb\x62\xb1\x6b\xb2\
\x32\xeb\x10\xc9\x5e\xec\x47\x73\xff\xec\x7d\xb3\xe7\x5e\x86\xfa\
\xf9\x05\xf5\x9c\x5b\x83\x06\x4d\xcf\xe2\xc8\x7e\xe4\x20\x5a\xe3\
\xa0\xd0\x75\x15\xc8\x20\xca\x1a\x71\x97\xa1\x95\x79\xd7\x22\x39\
\x57\x51\x20\xcf\x79\xb4\x63\xc0\xb5\xf6\xff\x39\xc0\x79\x05\xca\
\x2e\x2d\xef\xea\x7a\xf6\x42\x11\x4e\xc5\xf4\x84\xf0\xff\x68\x24\
\x33\xd3\xbf\x9d\x83\x0c\xf4\xd7\xed\x19\x6a\xd0\xea\xc7\x61\xb0\
\xb3\x50\x7e\x62\x34\x47\x3b\x46\x83\x06\xdd\x90\x3e\x31\xb8\xc8\
\x7b\x0c\xc6\xd6\x70\xb4\x5a\xf9\xfe\x4c\xbe\xea\x7a\xee\xe3\x69\
\x9c\x85\xba\x50\x1f\x31\xda\xb5\xa1\x06\x78\x0c\x78\x02\xc9\xac\
\x4f\xa2\x01\xff\x6c\xde\x8b\xe9\x47\x75\xbd\x27\x52\xdf\xc3\xf6\
\x66\xad\x0b\x5c\x9b\xbd\xcf\x18\xe0\x6a\x3b\x36\x12\xc9\xea\x6c\
\x9d\xae\x4b\x9f\xc2\xde\x47\x75\xe6\x58\xa1\xba\x57\x57\x3d\x2d\
\x54\xb6\x85\xfa\x85\xf4\xf5\x35\x48\x37\xb8\xd9\x9e\xf9\xdd\x7a\
\xef\x2d\x0e\x9f\x23\xec\x34\x25\x62\xa4\x90\x5c\x89\x3a\x80\xf5\
\x68\xb9\xfc\x1a\xd4\xf0\x3b\xa1\xd5\x30\xfb\xd9\xff\xcf\xa1\xe5\
\xf6\x2f\x42\x1e\xcf\x1a\x3b\x7f\x59\xea\x58\x35\x30\x0d\x6d\x53\
\x91\x1e\xe5\x0f\x8a\x52\xb1\x91\xff\xb4\x12\x54\xc3\x91\x1d\x4f\
\xd8\x83\x72\x38\x6a\x47\xaf\xd9\xe7\x66\x4b\xb3\x37\x5a\xde\xff\
\x31\x64\xc4\x5c\x4a\xb2\x9d\x53\x2b\x0a\x2b\x02\x71\xea\x7e\xe9\
\xef\xd9\x32\xea\x8f\xb6\xc6\xe8\x8a\x84\xf3\x13\x68\xeb\xa2\xb3\
\x90\xe0\xce\xa3\xad\x07\x06\xa3\x51\xfd\xcb\xd1\x56\x02\xe5\x96\
\x8f\x7d\x68\xdb\xa1\x30\xba\x3d\x1f\x29\x27\xa3\xd0\xe8\xfd\x55\
\xf6\x5c\xdb\xd1\x96\x03\x9d\x91\x30\x99\x62\xcf\xe4\xf3\x7a\x6a\
\xb3\x09\xed\x77\x58\x85\x94\xa6\xc9\x48\x19\xbc\x1a\xbd\xeb\x2a\
\xf4\x8e\x26\x22\xc1\xbc\x1b\x29\xdd\xed\x91\x70\xbe\x1c\xd5\xf7\
\xfd\xa8\x4e\xb7\x03\xae\x41\xdb\x39\x04\x01\xdc\x0a\xbd\xbf\xdb\
\x51\x3d\x5b\x81\xbc\x27\x95\x68\xbb\x94\x0b\xec\x7b\x67\xcb\xcb\
\x29\x96\xe6\x34\x34\x47\xcb\xdf\x99\xd3\x12\x08\x1e\xde\x53\xd0\
\x16\x2a\x75\x6d\x1d\x14\x0c\x9d\x32\xe0\xff\x90\x91\xb7\x08\x29\
\xf1\x1d\x51\x7b\x3b\x07\xb5\xb3\x2a\x34\xef\x76\x3e\xf2\xf2\x55\
\x22\xa5\x7a\x2f\xea\xe3\xcf\x42\xdb\xc7\xcc\x44\xc6\xd4\x65\xa8\
\xcd\x8f\xb4\x34\xaa\x51\x9f\xfc\x36\x8a\x70\x6a\x8f\xfa\xf6\xd7\
\xec\xf7\xee\x68\x6b\xa4\xa7\xec\xbe\xe5\x96\xaf\xf3\x90\x87\xb8\
\x0a\x78\x19\x19\xb1\x97\xa1\x28\xa1\xb0\xdd\xe0\x63\xa8\x0f\x0a\
\xcf\x59\x81\xbc\x5f\xa3\xd1\x36\x30\xcf\xd9\xb1\x89\x76\x5e\x17\
\xcb\x6b\xce\x9e\xe3\x22\xd4\xef\x07\x39\xb6\x04\x19\x1a\x95\xf6\
\xbc\xc3\x50\x9f\xb4\x0f\xc9\xaf\xfd\xc8\xc0\xb9\x0c\xc9\x18\x90\
\x9c\x08\x5b\x09\xa6\x95\xf5\x53\xed\xbe\xeb\xec\xde\xd5\xc8\x80\
\xb9\x1e\x6d\x7d\xb3\x05\xf5\x5d\x61\xcf\xf7\xb1\xc8\x18\x9e\x88\
\x64\xe8\x0c\x2b\x97\xab\x50\xe4\xd2\x3a\x24\x87\xc2\xf6\x50\xe5\
\x68\xbe\xe9\xcb\x24\xbb\x19\x9c\x4d\x62\x28\x2d\x46\x7d\xed\x05\
\x68\x30\xbd\xa3\x9d\xf7\x38\x32\xcc\xc7\x21\x6f\xed\x3e\x4b\x3f\
\x6d\x88\xf4\xb7\xdf\xca\x91\xce\x11\xf6\x7a\x8f\x2d\x7f\x67\x92\
\xc8\xf8\x6e\x56\xe6\xe5\x56\x7e\x15\x24\x7b\xd6\x06\x03\x27\x6f\
\x79\xba\x04\x19\x8e\x65\xc0\x2b\x24\x5b\x6f\x75\x45\x5b\xf7\x84\
\x6d\x85\xfa\x23\xd9\xd0\x09\xf5\xf7\xcf\xa0\xfe\xfd\x4a\x7b\xaf\
\x7d\xec\x7d\x85\xed\x26\x8f\x35\xfd\xed\xb9\xc2\x96\x8d\x75\x11\
\xa3\x6d\xc0\x66\xda\xff\xdb\x80\x2f\x23\xcf\xf9\xe9\xf6\x4c\x9b\
\x2c\xbf\x97\xd9\xbb\xdd\x6c\x75\x60\x27\x1a\xf0\x1f\x87\xe4\xdc\
\x42\xe0\x79\x7b\xf6\x6e\x56\xa6\x8b\x49\xb6\x5c\x5a\x69\xc7\x2e\
\xb7\xf2\x58\x67\x65\x73\x25\x92\x75\x4b\x50\xbd\x3c\x07\xf5\x03\
\x63\x51\x3b\xca\x5b\x5e\x46\x58\x1e\x1f\xb5\xf7\x33\xc9\xde\x55\
\x6f\xb4\xad\x52\x77\xcb\xf7\x0c\x2b\xdb\x4a\xfb\xbd\x2d\xd2\x3f\
\x07\xd9\xf3\x4d\x21\x59\x6d\x3b\xf4\x3b\x61\xb5\xf6\x55\xc0\xb3\
\x68\x7b\xaa\x4d\x96\x6e\xe8\x17\x1e\x47\x7a\xc0\x44\xd4\xae\x5f\
\xb4\xe7\xbb\xd6\xea\x47\xe8\x57\x1e\x45\x7d\xcf\x68\xab\x33\xaf\
\x23\xfd\xad\x8b\xa5\x3f\xc5\xea\x81\xcb\xf6\x46\xe2\x1e\x61\xa7\
\x29\x91\x43\x8a\x7e\x0f\xd4\xc8\xbb\xa1\x8e\x2b\x08\x92\xf1\xf6\
\xdb\x13\xa8\xf3\x7c\x0f\xea\x94\xae\x47\x1d\xec\x1a\x24\xf0\x06\
\xa0\x50\xd2\x57\x91\xb0\x3b\x8f\x44\xb8\x1c\x0b\xf2\xa8\xa3\x1c\
\x8b\x0c\xef\x45\x96\xef\x2e\x48\x08\x0f\xb4\xe3\xc3\x90\x70\x9c\
\x80\x3a\xc0\x69\x48\xd9\x6a\x4c\x88\x6b\x0e\x29\x2e\xfb\x91\x00\
\xee\x81\x0c\xae\x61\x96\x87\xd9\x48\x31\x98\x84\x94\x9d\x0d\x48\
\x38\xf4\x41\x4a\x59\x8d\xe5\xa5\x1c\x09\x9e\xc1\x48\xf8\x9c\x89\
\x06\x1e\x36\x5a\x1a\x7b\x51\xa7\x5e\x89\x3a\xed\xa1\x14\xde\x6b\
\xb0\xa5\x93\x47\x82\xf5\xa3\x28\xac\xf2\x16\xa4\xdc\xd4\x20\x41\
\x9d\x43\x0a\xf4\xf9\xf6\x79\x06\x0d\x30\x7c\x18\x95\x71\x78\x3f\
\xdb\xed\xfc\x36\x48\xe0\x8f\x42\xca\x19\xe8\x1d\x4c\x20\xd9\xf7\
\xae\xab\xdd\x77\x00\x7a\x7f\x5d\x90\x47\x61\x39\x12\xcc\x9f\xb1\
\x74\x57\xa3\x36\xe2\x61\x55\x4e\x4b\xa1\x02\x85\xb2\xfe\x3b\x70\
\x27\x75\xf7\x57\x11\xea\x37\xd7\x20\x45\xbf\xcc\x3e\x2f\x20\x05\
\x7d\x3c\x6a\xcf\x33\x90\x72\xfd\x61\xd4\xe6\xce\x44\xfd\xe1\x54\
\xfb\xff\x52\x4b\xef\x32\xd4\xde\xcf\x40\x46\xd5\x10\x14\x91\xf3\
\x2a\xda\x13\xfd\xfd\xc8\xb8\xb8\x10\x29\xf0\xd3\xed\x9a\xce\x76\
\xbf\x41\xf6\x19\x60\xd7\x8e\x47\x03\xab\xaf\x20\x03\xfa\x6e\x64\
\x90\x8d\xb5\xcf\x0b\xc8\xb0\xbb\x3e\xf5\x4c\x79\x24\x1f\x2e\x41\
\xc6\xc4\x26\xe0\xe3\x48\xee\x2c\x43\x8b\x16\x6d\x20\xd9\x2a\x66\
\x10\x89\x1c\x5b\x88\x42\x9b\xcb\x91\xa2\xbd\x04\xf5\x27\x57\xa1\
\xfe\xe3\x55\x7b\xee\xfe\x24\x1e\xce\xa7\xac\xfc\xee\xa4\xf6\x74\
\x9f\x50\xbe\x6b\x51\xbf\x34\x1b\xc9\x96\x88\x23\x3d\xc7\x61\xef\
\xf8\x65\x76\xfe\x6c\x92\x7d\x98\x43\xda\xdd\x50\xd4\x4d\x77\xd4\
\xa7\xf5\xb4\x7c\x2d\xb6\xf3\xd2\xc6\xc8\x85\xc8\x20\x7b\x09\x0d\
\x28\x0e\xb4\xfc\x9e\x85\x0c\xe6\x32\x7b\xaf\x7d\xd0\x54\x96\xc5\
\xf6\xac\xbd\x33\x79\xdf\x66\xbf\xbd\x69\xe5\x11\xfa\xe0\x56\x76\
\x9f\xe7\x2d\x1f\xb7\xda\xdf\x2b\x91\x2e\xb0\x02\x4d\x79\xe9\xcc\
\x91\x1e\xcd\xa1\xa8\x6f\x7f\xd6\xee\xf9\x7e\x34\x38\xb0\x16\x0d\
\x72\xec\xb3\xfa\xd3\x15\xf8\x88\xfd\xf6\x8c\xa5\x77\x9d\xbd\xef\
\xab\xec\xbd\xce\x46\xd1\x47\x3d\x39\xb6\xfd\x7b\x08\x53\xff\x3a\
\xf0\x7d\x34\xe0\x50\x8a\x07\xb2\x1b\x89\xec\xba\x82\xc4\x83\x7e\
\xad\xe5\x77\x21\x8a\x80\xea\x8d\xf4\xbb\x2e\x56\xdf\xfa\x5a\x7d\
\x78\x05\xb5\xb5\x5b\x50\x1b\x38\xcb\xde\xdd\x0b\x56\xee\x57\x5a\
\x19\x2d\xb7\xb2\x2d\x47\x3a\xd5\x39\xa8\x0e\xb7\x45\xfa\x56\x8c\
\xf4\xc0\x56\xf6\xfe\xd6\xda\xdf\xd6\x76\xef\x97\xed\xdc\x1b\x2c\
\xdd\x6b\x91\xae\xb4\x14\xf8\x13\xd4\x56\x16\x92\x4c\x47\x1a\x67\
\xef\xe3\x6a\x7b\xb6\xa7\xed\xde\xe7\xa6\x9e\xbd\xc2\xde\x65\x6b\
\x54\x4f\x07\xda\xfb\x8a\x48\xfa\x85\x33\x51\x9d\x1b\x8a\xda\xf5\
\x0c\xa4\xab\x7d\xc0\xca\xe0\x2c\xd4\xa6\xa6\x22\x03\xfe\x12\x7b\
\xd6\x0d\x68\x40\xea\x0a\x34\x4d\xea\x69\xd4\x3f\x84\x08\x03\xa7\
\x91\xb4\x78\x8f\x70\x14\x1d\x29\x29\xf3\xf5\x54\xad\x5c\xe6\x82\
\x38\xae\x67\x75\x9c\x06\xdc\xa3\x05\x12\xa3\x46\x3e\x14\xf8\x6f\
\xd4\x41\x2c\x43\x46\xc0\x39\xa8\x23\x99\x87\x3a\xd6\xe1\xa8\x43\
\xe9\x8e\xc2\xb4\x0e\xa0\x4e\x67\x09\xea\x5c\x76\xa3\x4e\xf8\x7a\
\xd4\x01\xbe\x46\x69\x21\x3e\xa5\x92\x43\x82\xf1\x05\xd4\x61\x0d\
\x44\x1d\x73\x3b\x64\x2c\x4e\x43\xc6\xcd\x58\x64\xa8\xf6\xb1\xff\
\x67\xa1\x4e\xb9\x31\x73\xd0\x62\x24\x80\x87\x22\x03\xb5\xab\x3d\
\xdb\xe9\x96\x76\x10\xf4\xaf\x20\xe5\x62\x37\x52\x40\x06\xd9\xf5\
\x73\x91\x40\x19\x8c\x14\xad\xd7\x50\xc7\x1f\x5b\x99\xed\xb5\xf3\
\x37\xa1\x8e\x77\x98\x9d\xf7\xba\x9d\x57\x86\x93\x26\x42\x75\x70\
\x17\x2a\xc3\xf5\x48\x69\x99\x87\x06\x6b\x5e\x45\x8a\xd1\xfb\x50\
\xfd\x3e\x1b\xd5\x93\xc1\xa8\xff\xdd\x83\xca\x3a\x8c\x08\x8f\x40\
\x8a\xd0\x1c\xa4\x14\xa5\xf7\x43\xcc\x86\x7c\x06\x2f\x43\x64\xf7\
\x98\x6e\xf7\x3e\x0d\xb5\x83\xfe\x68\xd4\xb9\x15\x49\x58\xbc\xe3\
\x34\x67\x62\x54\xd7\xc3\xa7\xae\xa8\x1f\x50\x7b\xca\x3a\x04\x82\
\x67\xf1\x74\xa4\x80\xce\x40\xfd\xde\x44\xe4\xb9\x3b\x88\xfa\xfe\
\x79\xa8\xbd\xf6\x47\x7d\xfe\x24\x24\x0b\xc6\xa3\x7e\x78\x24\xea\
\xff\x4f\xb3\xf4\x7a\x21\x05\xff\x20\x6a\xab\x6f\xdb\xf5\x21\x1c\
\xf8\x2d\xe4\xdd\x1a\x66\xf9\x3e\x1d\xc9\x8d\x57\x51\x5f\x11\x22\
\x4a\x0e\x21\x23\xef\x0d\x4b\x33\xc8\xc7\xf0\xac\x67\x58\xfa\xb3\
\x91\x11\x77\xae\xe5\x63\xab\xa5\xbf\x87\x64\xf1\xa2\x35\x48\x9e\
\x9c\x62\x79\xeb\x8c\x94\xfa\x9d\xa8\x5f\xdb\x83\x64\xc8\x2b\x48\
\x1e\x57\x59\x5e\x97\xa0\x7e\x65\x88\x3d\x7f\x0f\x24\xab\xb3\xe5\
\xb8\x1b\x0d\xf2\x85\xfb\x06\xb2\x21\xa8\x35\x28\x02\x66\x27\xea\
\x43\x77\xa4\xde\xcf\x19\x68\x50\xef\x7c\x64\x3c\x75\x46\x06\xc2\
\x6a\x2b\x9b\x2a\x92\xc5\x97\x76\x22\xe3\xbc\xb7\xe5\xa9\xa3\x9d\
\x5f\x6d\x65\x32\x17\x19\xe0\x57\x20\x3d\x62\x9f\xbd\xbb\x2a\x2b\
\xa7\xf4\x36\x82\xfb\xad\xcc\xf2\xc8\x28\x4e\x87\xae\x87\xb4\x22\
\x64\xc8\xac\x44\x3a\xc1\xab\xf6\x2e\xc2\xf3\x65\x17\x88\x5a\x81\
\x3c\x80\x03\xad\xcc\xbb\xd8\xf9\x41\x4e\xef\xb3\x67\xee\x65\xf9\
\x7e\x0c\x0d\x46\xb4\x41\x86\xd9\xdb\xf6\x1e\x5e\xb6\xf2\xbe\x06\
\x19\x6b\x1b\x38\xb6\x83\xd4\x79\xa4\x57\x1d\xa0\x7e\x6f\x30\xf6\
\xac\x67\xd9\xf3\x44\xf6\xce\x7f\x8e\xea\xd0\x46\x2b\x97\xc3\x48\
\x6f\xf9\x21\x1a\x30\xd8\x03\xfc\xb9\x3d\xef\x53\xc8\x18\xec\x69\
\xef\xac\x13\x6a\x27\x6f\xd8\xb9\xfd\xac\xec\x5e\xb3\xf7\xb7\x03\
\x0d\x26\xac\x40\x03\x1f\xdd\xed\x9d\x7c\xd4\xca\x75\x18\xf0\x2b\
\xa4\x7b\xed\xb4\xf7\x58\x85\xea\xfa\x5c\x3b\xff\x62\x2b\xfb\xd5\
\x24\xfa\xd2\x56\x2b\xdb\x36\x68\x80\xab\x8d\xe5\xaf\x1c\xb5\xc7\
\xc7\x50\x9f\x10\xbc\xfe\x61\x00\xa6\x33\x6a\xe7\x8b\x50\x3d\xed\
\x84\x06\x06\x7e\x6c\xf9\x3b\xc5\x7e\x7f\x09\xb5\xe1\xee\x96\x5e\
\x19\xaa\xa7\xfd\xed\xdd\x3f\x8f\xfa\x95\x51\xa8\x0e\xcf\x45\xba\
\xc5\x46\xd4\x2e\x82\x71\xbd\x10\xb5\x29\x77\x4c\x1c\x03\x5a\xbc\
\x21\xbc\xe3\x40\x0d\x3b\xf6\x57\xbf\xf3\x7f\x65\x79\x44\x9f\x0e\
\x15\xe4\xa2\xc2\xf5\xab\x3a\x1f\xb3\x71\x4f\x15\x55\x35\x89\x25\
\xdb\xad\x5d\x39\x1d\x5b\x15\xb6\x0f\x22\x60\xe7\x81\x1a\xb6\x67\
\xee\xd1\xbb\x43\x05\x65\x91\xd7\xe1\x0c\x41\x70\x94\xd9\xf7\x3e\
\xc8\xd0\xc3\x8e\x5f\x83\x3a\x88\xe0\xe9\xed\x87\x84\xd5\xcf\x50\
\x27\x7a\x26\x1a\xfd\xfe\x57\xe0\x7f\xec\xf7\x33\xd0\xa6\xd9\x7f\
\x8b\x84\x59\xa1\x7b\xd6\xa7\x2c\x65\x09\x21\x75\x57\xa2\x0e\x34\
\xec\x0d\x1b\x46\xd9\x0f\x52\x5b\xb9\x0a\x1d\x29\x24\x5b\x08\x34\
\x94\x56\x48\xf0\x1e\x46\x42\x62\x83\xa5\x9d\x27\x31\x52\x2b\x90\
\x32\x16\x14\x8f\xf4\xb0\xcb\x76\x34\xf2\x79\xb5\x95\xed\x3c\x24\
\x00\x42\x19\x87\xbc\xed\x44\x9d\xfa\x55\x48\x30\x3d\xd0\xc8\x7c\
\x37\x57\x22\xa4\x04\xfd\x1e\x29\x5b\x03\x80\xbf\x41\x02\xfd\x30\
\x12\xbe\x65\xa8\x0e\x2c\x43\x4a\x75\x25\x89\x17\x38\xd4\x93\xbd\
\x76\xec\x0a\x24\xe8\x9f\x42\xc2\x32\x4b\xa8\xab\x35\xc8\xb0\x0e\
\x1c\x22\xa9\x03\x41\x59\x0d\xca\xb1\xe3\xb4\x14\xaa\x81\x9f\x00\
\x0f\x53\xbf\xa2\x18\xa3\x3e\xee\x0a\xe4\x21\xda\x67\xc7\x2e\x21\
\x59\x93\x22\xf4\xa9\x41\x2e\x85\x69\x32\x07\xa8\xbd\xdf\xf0\x56\
\xd4\x0f\x5c\x87\x06\xba\x16\x22\xe5\x77\x1d\x6a\xf3\x39\x64\xe8\
\xae\xb0\xf3\xab\x50\xbf\x3d\xcb\xce\x19\x82\xfa\xe4\x76\x24\x83\
\x56\x35\x05\xee\x1f\x06\xbf\xb2\x32\x26\x4d\xde\xd2\x8e\xed\x9c\
\x60\x98\x65\x57\xea\xad\x41\x03\x73\x57\x5b\x1e\xd7\x5a\xba\xd9\
\xf3\x0e\x5b\xb9\x86\xfb\x85\x32\x3a\x9f\x44\xfe\x9d\x56\x47\x59\
\x47\x99\x34\xb3\x73\x1d\x3b\x50\x3b\xb4\x9b\xcc\xb9\x87\x91\xf1\
\xb1\xcc\xca\x27\x84\x18\x57\xa5\x9e\x2b\xa4\x35\x14\xcd\xf1\x9e\
\x83\x8c\x87\xbd\xa9\xdf\xd3\xcf\x16\xa2\xcc\xca\x48\x64\x72\xa1\
\x01\x91\x88\xc2\x32\x3b\xf4\xad\xe9\xb5\x20\xaa\x52\xc7\x8a\xbd\
\x97\xf3\x51\x7d\xcb\xea\x0d\x51\x81\x73\x21\xd1\x85\xc2\x5f\x50\
\x5f\x1f\x06\x70\x8e\xc7\x5c\xd1\xc8\xca\xed\x1f\x90\x41\xb7\x86\
\xfa\xa3\x47\x23\x64\x98\xde\x47\x12\x12\x5e\x8d\xea\x75\x90\x4d\
\xe1\x19\xd3\xcf\x94\x47\x03\x46\xd7\x20\x2f\xfe\x7a\xd4\x0e\xc3\
\xb3\x1d\x4e\xdd\xfb\x30\x89\xfc\xab\xb2\xf4\x43\xfb\xc8\xa1\xf6\
\xb7\x1b\xb8\xd1\xd2\x58\x85\x0c\xcc\x40\x0d\x49\xbb\x49\x0f\x78\
\x84\xfc\x85\x7c\xe7\x39\xf2\x79\xd3\xeb\x7a\xe4\x91\x6c\x3e\x05\
\xb5\xdf\xf0\x5b\x30\xdc\xd7\x21\xcf\x75\x35\xd2\xcf\x56\xa1\x7e\
\xa1\x2d\xea\x17\x86\xd8\x73\xbe\x62\xe9\x2d\x42\x03\x3b\xe7\x93\
\x44\xa6\xa4\xcb\x35\xd4\xc1\x74\x5f\x71\x2d\xd2\x13\xfe\x80\xeb\
\x65\x8d\xa6\x45\x1b\xc2\xb9\x08\x7e\x37\x6f\x3b\xdf\x79\x69\xe3\
\x3b\xc7\xc6\xf5\x6e\xc3\x4f\x6f\x1d\x4c\xe7\xd6\x65\x47\x68\x90\
\x51\x04\x5b\xf7\x57\xf3\xc9\x3f\xae\x64\xf9\xf6\x43\x96\x46\xc4\
\xff\xbb\xac\x2f\xef\x3b\xbd\x1b\x35\xf1\x91\x3a\x67\x59\x2e\xe2\
\x81\x85\x3b\xf8\xf6\xf3\x1b\xde\x39\x36\xaa\x47\x1b\x7e\x76\xdb\
\x60\xba\xb6\x2d\x23\x76\x35\x35\x10\x3a\xdf\x85\xa8\xd3\x08\xf3\
\x81\xe7\x90\x74\x04\xbd\x90\xf1\xb0\x11\x79\x5b\xdb\xa0\x51\xb3\
\x1b\xd1\x28\xeb\x32\x64\x3c\xf7\x42\x1d\xeb\x34\x3b\x76\x0a\x47\
\x1a\x04\xa1\xb3\xe9\x83\x3a\x95\xdf\x51\xdb\x03\x17\x14\x88\xec\
\xf7\x40\x37\xd4\x69\xad\x42\x46\x67\x27\x8e\x14\x9a\xe1\xba\xd7\
\x51\x78\x57\x58\x95\xb2\x77\x81\xfc\xa4\xaf\x2b\xcb\x7c\x0f\x84\
\x8e\xb8\x17\x1a\xfd\xdc\x67\xcf\xb6\x19\x19\xb4\x67\x93\x18\xae\
\xa3\x80\xfb\x91\xe1\x1c\xe6\x31\x07\xa1\xfd\x2a\xf0\xd7\xc8\xd8\
\xda\x66\x65\x90\x43\x1d\x77\x8d\x5d\xbb\xd2\xce\xfb\x2b\x14\xaa\
\xb3\x15\x85\xf3\x6c\x42\x1d\xb8\x4f\xab\x48\x08\x73\xb9\xf2\x68\
\x3e\xcf\x0e\x54\x4f\xcb\x49\x8c\xd6\x59\x24\x73\x9a\xfa\x21\x8f\
\xc0\x1b\xa8\x0e\x0d\x47\x9e\x9b\xd7\xd1\x6a\x98\x33\x91\x00\xed\
\x49\xed\x3a\x58\x83\x04\xe8\x24\xa4\x08\x9e\x6d\xd7\x64\x95\xb8\
\xb4\x82\xee\x1e\x7c\xa7\x25\x11\x91\x78\x31\xeb\xdb\xa2\x25\x28\
\x97\xe7\x01\x1f\x23\x59\x37\xe1\x2a\x34\xf0\xb7\x03\x85\x23\x5f\
\x89\x0c\xb0\x2e\x48\x3e\x4d\xe4\xc8\x3e\x3e\x8f\xbc\x55\xff\x0f\
\x78\x10\x0d\x24\xce\x43\x83\xb3\xbd\xed\x9c\xf3\x90\xf1\x93\xee\
\xeb\x2f\x43\x86\xe0\x4c\xd4\xc7\x86\x67\x88\x2c\x6f\x77\x93\x84\
\x44\x76\xb2\xfb\x8f\xa4\xb0\x9c\x02\xf5\xef\xaf\xa1\x68\xa8\x6d\
\x68\x60\xae\x1a\x0d\x7e\xa6\x3d\x9e\x81\xee\xf6\xfb\x4a\x64\xcc\
\x76\x20\xf1\x86\x0e\xb2\xdf\x0b\xc9\xb4\x1e\x56\xce\xeb\x2c\xdd\
\xf6\x14\xde\x26\x27\x9b\xc7\x32\xd4\xe7\x85\xa9\x20\x03\xed\xbe\
\xcb\x90\x21\xd1\xd9\x8e\x1d\x40\xde\xf7\x76\xa8\x9f\x1c\x8d\xfa\
\xc4\x89\xc8\x43\xb6\x9c\x23\xfb\xb6\xb0\xc6\x48\xa5\x3d\x6f\x6f\
\x92\x3e\x34\x6b\xfc\x54\xd8\x39\x57\x21\xfd\x61\x37\x1a\x34\x7f\
\xb1\x40\xde\xd3\x46\x29\x48\xef\xb8\x1a\x19\x63\x17\x23\xcf\x7b\
\xd6\x80\x49\x1b\xd7\xe9\xbf\x3d\xec\xdc\xd5\x76\xbf\x76\x76\xfe\
\x01\xe4\xc5\x5c\x66\xe9\x6c\xb2\xcf\xad\x56\x8f\xae\xb5\xf7\x7a\
\x38\x73\x9f\x42\xe5\x7d\xac\xd8\x46\x32\x97\xbc\x3e\x42\x1e\xd2\
\x03\x26\xa1\x1e\x87\x3c\x06\xfd\xee\x26\xa4\xa3\x5c\x84\xe4\x5e\
\x58\x44\x74\x39\xaa\xaf\xc1\xab\x9c\x7d\x67\xd9\x41\xa1\x6c\x9d\
\x3c\x68\xef\xe2\x53\xc8\xeb\x7c\xc8\xca\x35\xac\x19\x50\xa8\x1e\
\x53\x24\xdd\xb4\x4c\x0d\xb2\x77\x26\xaa\xb3\x21\xf4\x7a\x1d\x89\
\xfc\xdd\x69\xcf\x32\x1a\xd5\xed\xf3\xed\xf7\xd9\xf6\xde\xbe\x05\
\xfc\xd1\xce\x9b\x8b\x74\xc6\x3e\x24\xeb\x00\xac\x28\xf2\xbc\x87\
\x51\x7d\x1b\x82\x3c\xc9\x6d\x2c\xcd\x2d\xf8\x20\xf7\x31\xa3\xac\
\x5f\xc7\xca\xaf\xde\x72\x6a\x97\xd6\xed\x2b\x5b\x9e\x5e\x1b\x45\
\x11\xcf\xaf\xd8\xcd\x93\x4b\x76\xb3\xbf\x2a\xcf\xfe\xaa\x3c\x9d\
\x5a\x97\x73\xfb\xb8\x2e\xb4\x29\x50\x1e\xb9\x08\x76\x1d\xcc\xf3\
\xb3\x59\x5b\x59\xbb\xab\x8a\xfd\x55\x79\xf6\x1d\xce\x73\xc9\xd0\
\x8e\x4c\xe8\xd7\xae\xa0\x51\x9b\x8b\x22\x5e\x5a\xb5\x97\xc7\xde\
\xda\xf5\xce\x3d\xda\x57\x96\x71\xe7\x69\x5d\x69\xdb\x02\xcb\xbc\
\x26\x0f\x8f\x2f\xde\x75\x70\xd1\x96\x83\x4f\x22\x03\x2e\xdd\x89\
\xc7\x48\x38\xb5\x43\x21\x63\xf3\x50\x08\x5a\x18\xed\x9b\x8f\x3c\
\xbf\xbd\xd0\x88\xdb\x3a\x3b\x67\x0f\xea\x24\x5a\xa1\x05\x06\xde\
\x42\x9d\xe0\xa9\x76\xec\x61\x64\x40\xa4\x3b\xc1\x08\x85\xa3\x82\
\x46\xb7\xe7\x50\x7b\xe1\x81\x72\x24\x88\xd6\xa0\x4e\x7a\x05\x12\
\x0c\xe1\xf7\x0d\x48\xf8\x0f\xb4\xdf\x96\x21\xa3\x38\x18\xc7\xfb\
\x2c\x8d\xed\x96\xf6\x76\xcb\xe3\x4e\xcb\xdf\x62\x92\x70\xed\x28\
\x73\x8f\x72\x92\x85\x5e\x62\x3b\xf7\x10\xc9\x48\xe8\x5a\x24\x34\
\xdb\x20\x65\x69\x13\xea\x5c\xd7\xda\x3d\x72\xc0\x43\x96\xf7\x6a\
\x24\x08\x56\x5a\x1e\xd6\x5b\xba\x87\x91\xe2\xb7\x9d\xa4\xc3\x5d\
\x82\x94\x8c\xbe\x96\x97\x1d\x48\x91\x9b\x62\xd7\x9d\x42\x12\xc2\
\xd5\x52\x46\x21\x43\xc8\xd7\x1e\xf4\x1e\xb2\x8d\xb6\x0c\x09\xf5\
\x9e\x48\xf1\xda\x81\xbc\xc3\x5b\xec\xdc\xe5\x48\x40\xaf\x41\x8a\
\xc0\x18\xbb\xee\x29\x54\xff\x77\x22\xc3\x78\xb5\x5d\x73\x16\x1a\
\xc0\x59\x89\xea\x41\x98\xdb\x17\x93\xcc\x9b\xeb\x6d\xf7\x9c\x89\
\xea\xda\x56\x3b\x6f\x85\xe5\xe7\xa0\xdd\x37\xd4\x97\xa5\x1c\xdb\
\xa9\x01\x8e\x73\x22\x29\x43\xe1\x86\x8b\x38\x52\x86\xc0\x91\x1e\
\xc8\x62\x84\x69\x0d\xf3\x51\x5f\x3e\x02\x0d\x30\x3d\x81\x94\xcd\
\xad\xa8\xaf\x1b\x8d\xfa\xe7\x07\x49\x16\x33\x5a\x85\xda\x73\x05\
\x6a\xf3\x6b\x51\xdf\x78\x18\x0d\x52\xee\x42\x7d\xf9\x7a\xbb\xbe\
\x23\x1a\x50\x5c\x81\xda\xf5\x72\xd4\xa7\x6c\x26\x99\x37\xb8\x18\
\x79\xd5\x62\xbb\x7e\x3e\xea\xdb\x47\xdb\x35\x0f\x92\xc8\xa3\xf5\
\xa8\xef\x28\xb7\x7c\xac\x4a\x3d\xd3\x7a\xbb\x7e\x34\x6a\xff\x0f\
\xa0\xbe\xa5\x22\xf5\x5b\x28\x9f\x75\xc8\x53\x35\x18\xf5\x39\x8b\
\xed\x1e\xab\x50\x9f\xb6\xdb\xca\x21\xf4\x63\x15\x56\x26\x73\x90\
\x5c\xe9\x6f\xd7\x2c\x27\x91\x7f\x6f\x53\xdb\xfb\x5a\x4e\x12\x1a\
\x5d\x6d\xe7\xaf\x44\xf2\xa4\x02\x19\x13\xab\xed\xfa\x56\xf6\x0e\
\xe6\xa0\x88\xa5\xfd\x28\x5c\xb4\x2d\x1a\x00\xd8\x64\x65\x14\x8c\
\x9c\x65\xa9\xf7\x99\xb3\xbc\x86\xe9\x53\xdb\xad\x0c\xd7\xd9\x73\
\x6c\xb2\xdf\xcb\x2d\xdd\x37\x51\xdf\x38\x04\xc9\xd2\x10\xf2\x1a\
\x06\x51\xb0\x73\xb7\xda\x7b\x2a\xb3\x7c\x1f\xb2\x63\x03\xed\xfa\
\x29\x24\x2b\x45\x2f\x4f\xd5\xd1\x35\x56\x0e\xab\x2c\xaf\x61\xd1\
\xa4\x0e\x76\xed\x72\x2b\xab\x55\xf6\xfc\x7d\xed\x3e\xbb\x2c\xdd\
\x05\xf6\x0e\x06\x5a\x7d\x9c\x66\x69\x1f\x26\xe9\xdf\x83\x8c\x69\
\xc8\xfa\x1d\x6d\x50\x3b\x9a\x5e\xe4\xfa\x52\xda\x50\xa0\xdc\xea\
\x58\x36\x44\x3b\x18\x91\x21\xac\x7e\xa9\xbd\xdf\xe1\x56\x96\x8f\
\x5b\x39\xc5\x76\x6c\xb3\x3d\xf7\x5a\xab\x2f\x6b\x50\xfb\x0a\xf5\
\x7c\x45\x2a\x6f\x2b\xac\x2c\xca\xed\xbe\x9b\xec\xb7\xd1\x48\x06\
\x1f\xb0\x77\xd9\xc6\xf2\xb1\xc1\x3e\x3b\x49\xa6\x25\xad\x44\x75\
\x32\xa4\x5b\x6d\x75\x20\x0c\x7e\x2c\xb5\xef\x6b\xad\x7e\xe4\x90\
\xa3\x60\x39\x92\xe1\xd5\x24\x91\x80\x8b\xd1\x40\xcc\x70\xcb\xf7\
\x34\xcb\x5f\xe8\x17\x5e\xb6\xef\xdb\x2c\x1f\xa3\xac\x2e\x4c\x25\
\x91\xf7\x6b\x2c\x5f\xe5\x96\xcf\xa0\xa3\x76\xb2\xf7\xd4\x0b\xf5\
\x15\x8b\xec\xba\x70\x7f\xe7\xe8\x09\x6b\xae\x4c\x89\x26\xf6\x6f\
\xb7\xf3\xbe\x3b\x86\x74\xea\xd5\xbe\xbc\xc5\x79\x27\x73\x51\xc4\
\x77\x5e\xda\xc8\xdf\x4c\x5d\xff\xce\xb1\x33\xfa\xb6\xe5\xfe\xf7\
\x0d\xa5\x6b\xdb\x23\xcb\x23\x17\xc1\xda\x5d\x55\xdc\xfa\xab\xa5\
\xbc\xbd\xed\xe0\x3b\xc7\xfe\xf9\x9a\x01\x7c\x6c\x62\x0f\x6a\x0a\
\x4c\xfc\x2d\xcf\x45\xfc\xfb\xf4\x4d\x7c\xf3\xe9\x75\xef\x1c\x1b\
\xdb\xab\x0d\x7f\xfc\xc0\x30\xba\xb5\x6b\x79\x65\x7e\xa8\x3a\xe6\
\x73\x0f\xaf\xda\xf9\xc0\xc2\x1d\xf7\x90\x74\x2c\x69\xb2\xcb\xd2\
\xa7\xc3\xba\xc8\x7c\x4f\xff\x4e\x09\xc7\xd2\x84\x74\xba\xa0\x91\
\xc9\xa7\xa9\x3d\x8f\x32\xe4\x21\xa2\x70\x58\x59\x7a\xeb\x83\x42\
\x79\x8d\x0a\xa4\x51\x4a\x7e\xa2\x02\xdf\x0b\x9d\x4b\x81\xf4\xd2\
\xcb\xf0\xe7\xa8\x7d\xdf\x28\xf3\x37\x9b\xcf\x38\x95\x46\x58\x74\
\x24\xac\x0a\xfa\x03\x92\xed\x20\x8e\x46\x38\x36\x07\x6a\xd0\x22\
\x58\xeb\xd1\x80\x4a\x21\x2f\x44\xa1\x77\x5b\xe8\xdd\x15\x7b\x3f\
\x31\xaa\x87\x93\xd0\xe0\xcd\x0f\x90\xc0\x4c\x9f\x1b\xd2\xca\xd6\
\xbb\x28\x73\x5e\xfa\x5d\x42\xe1\xfa\xe3\x38\x27\x33\x95\x68\xaf\
\xd2\x3f\x20\xa5\xb9\xb1\xf5\x3b\xdd\xa6\x42\x1f\x97\x6e\x3f\x64\
\x8e\x17\xeb\xe3\xe1\x48\x59\x51\x4c\x36\x65\x43\x74\xb3\xed\x39\
\x7c\x2f\x74\xff\xf4\x3d\xb3\xed\x9d\xcc\x7d\xd3\x7d\x4d\x5c\xe0\
\x1e\xc5\xe4\x58\x7a\xca\x50\x3a\xfd\x38\x73\x8f\x42\xf2\xaf\x90\
\x4c\x4f\x3f\x4f\xb1\x7e\x2c\xca\x1c\x8b\x33\xdf\xd3\xcf\x93\xfd\
\x5e\xe8\xd9\xd3\xe5\x98\xfe\x9e\x2e\xb3\x62\xf9\xa8\x2b\xef\xd9\
\xf9\xbf\xc5\xfa\xdd\x28\x73\x5e\x5d\xe5\x56\xa8\xbc\xb3\x79\xab\
\xeb\x3e\x47\x2b\x93\x63\x34\xd0\xf0\x15\xe0\x5f\x48\x56\x3f\x6e\
\x28\x85\xea\x56\xfa\x79\xd3\xef\x2c\xfb\x2e\x0b\xe9\x47\xe9\xb2\
\x2b\x54\xcf\x0b\xa5\x79\x0a\x8a\x26\xdc\x0f\xfc\x32\xf3\x5b\x5d\
\x75\x20\x5f\x24\xdd\xf4\xfb\x4e\xd7\xcf\x74\x3a\xc5\xda\x52\xfa\
\xd9\x0a\xbd\xa7\x52\xfa\x05\x32\xf7\xcc\xb6\x8f\x96\xa6\x8b\x1d\
\x4b\x62\x14\x9d\xf1\x09\xe0\x4f\x5b\x74\x68\xb4\xd3\x24\x29\xd4\
\xb8\xd3\xc2\xae\x50\xa8\x67\xae\xc4\x63\x85\x7e\x0f\x5b\xd6\x64\
\x17\x13\x8a\xea\x49\xab\x58\xd8\x69\xee\x28\xd2\x28\x76\x5d\xae\
\x9e\xeb\x72\x25\xa4\x71\x34\xe7\xa6\xcb\x3c\x74\xc8\xed\x48\xe6\
\xa0\xec\xc7\x3b\xdd\x62\xd4\x15\x7e\x9c\xab\xe7\xff\x70\x2c\x46\
\xa3\xe4\x5d\x91\xf7\x26\xed\x91\x88\x32\xd7\x16\xbb\x5f\x31\xe1\
\xe8\x46\xb0\xe3\xd4\xcd\xd1\xb4\xe1\xec\xb1\xa8\x9e\xf3\x4b\xb9\
\xbe\xae\xe9\x0b\xc5\x64\x4f\xfa\x7b\xd4\x80\xeb\xea\xbb\x7f\x3a\
\xdd\xa8\x48\x1a\xa5\xca\xe2\x42\xfd\xd1\xd1\xca\xcf\x62\x79\x2f\
\xb5\xcc\xea\x7a\xb6\xb2\x7a\xce\xcd\xa6\x9b\xab\x27\xcd\xec\x73\
\x66\x29\xb5\xbc\x0b\xe5\xad\xa9\xf6\xef\xf5\x4d\x41\x28\x96\xff\
\xba\x9e\xa3\xae\x7a\x5e\xa8\x9e\x74\x43\x5e\xe3\x27\xa8\x6d\x44\
\x17\xab\x3b\x51\x81\xb4\x0a\x7d\xaf\x4f\x1f\x4b\xa7\xd9\x58\x5d\
\xa0\xd0\xb3\xd7\xa7\xff\x3a\x8d\xc4\x0d\x61\xa7\xa5\x73\x98\x24\
\xec\xd8\x11\x39\x14\x0a\xf4\x3f\x34\x7e\x71\x2f\xa7\x7e\x22\x14\
\xd6\xe5\xe5\xed\x38\x8e\xe3\x38\x47\x47\x84\xa6\x87\xcd\xc6\x65\
\xa8\x73\x94\x34\x95\xd1\x24\xc7\x39\x91\x78\xa7\x79\x24\xc5\x16\
\x3e\x71\x8e\x24\xbb\x57\x64\x7d\x2b\x79\x66\xc3\xff\xa1\x76\x79\
\x17\xfa\xdd\x71\x9c\xe3\x43\x53\x6b\x6b\xe9\xad\x85\x8e\xf7\x73\
\xe7\x0b\x7c\xaf\xeb\xfc\x77\xb3\xac\x4a\x29\x87\x52\x7e\x6f\x6a\
\xef\xb7\xb9\x12\x56\x34\x87\xe2\xf5\xa9\xbe\x77\x91\x7d\xe7\xf1\
\x51\x5c\x5f\x4c\x67\x29\xa5\x6e\x3b\x2d\x18\xf7\x08\x3b\x8e\xe3\
\x34\x8c\xb0\xf5\xc3\x6d\xf6\x7f\x8c\x16\x68\x79\x0e\x2d\xb8\x51\
\x68\x10\x21\x46\x0b\xcc\xdc\x84\x16\xe8\x78\x8a\xda\x42\x3a\xcc\
\xcf\x1e\x82\x16\xc3\xba\x04\x2d\xf6\x12\xb6\x52\x5a\x8d\x56\x4c\
\x9f\x42\xed\xb9\x43\x57\xa1\x15\x39\x57\xe1\x03\x9c\x8e\x53\x2a\
\x31\x6a\x5b\xe3\xd0\x1e\x9f\xd5\x8d\x4b\xee\x1d\xf2\x68\x21\x96\
\x53\x50\xa8\xe6\x55\x68\x15\xfe\xec\x36\x41\x85\xf2\x73\x2a\xc9\
\xca\xd7\x97\xa1\xfe\xe4\x1a\xe0\x19\xcb\xe7\x7a\xb4\xd0\x53\x98\
\x56\xd1\xdb\xee\xf5\x34\xc9\xd6\x69\xa5\x3c\x77\x5b\xb4\x57\xea\
\x68\x7b\xee\x37\xac\x0c\xaa\x8a\x9c\xdf\x17\xcd\xab\x7b\xa3\xc0\
\x33\xe4\x2d\xdf\xc3\xd0\x82\x95\x85\x0c\x96\x2b\xd1\x42\x5b\x73\
\x29\x3c\x8f\xf8\x5a\x7b\x8e\x6a\x4b\x6f\xb9\x3d\xf3\x8e\x3a\xca\
\xec\x7c\xb4\x92\xf4\xd3\xa8\xff\xcb\xae\xa0\x3d\x08\x2d\xc0\xb5\
\xd2\xd2\x7f\x09\x2d\x10\x35\xdf\xca\x6d\xb7\x3d\x4f\x28\xcb\x6e\
\xf6\xfb\x53\x94\xb6\x7f\xae\x23\xc2\x1c\xdd\x8b\x50\x19\xee\x47\
\xab\x25\xcf\x47\xb2\xec\x56\x34\xb7\xbf\x92\x64\xdb\xab\x67\xd1\
\x22\x72\xe7\x91\xb4\xbb\x8d\xa8\xec\xd7\x23\xfb\x64\x32\x5a\x4c\
\xb2\x2f\x32\x72\xc3\xf6\x80\xbb\x81\xff\x43\x8b\x96\x85\x30\xe7\
\xab\xd0\x9a\x01\x5d\xd0\x9e\xcb\x87\x2d\xcd\x9d\x68\x61\xa9\xc5\
\xf8\xc0\xbe\x53\x00\x57\x98\x1c\xc7\x71\x1a\x46\x50\x42\xbb\x20\
\x65\xf7\x09\xa4\xc0\x7e\x16\xad\xf4\x59\x68\x84\x3c\x8f\xb6\x5e\
\x08\x7b\x88\xd6\x50\x7b\x4f\xcd\x3c\x5a\x59\xfa\x2a\x3b\xb6\x9f\
\x64\x8b\xa5\xe1\x48\xb8\xef\x4b\x9d\x1f\xae\x3d\x15\xcd\x31\xce\
\x7a\x79\xdc\x1b\xe2\x38\xc5\x89\x90\xb1\x19\x56\xce\x4f\xb7\xa9\
\x62\x1e\xad\xba\x7e\x4f\x9f\x77\x0a\xda\x26\xa5\x0c\x6d\x11\xd4\
\x8e\xa4\x7d\x16\x6b\x97\x11\x1a\x24\x1b\x8c\xfa\x86\xbd\x76\xfd\
\xd9\x68\x85\xd9\x7d\x24\x0a\x7e\x48\xa7\x3d\x1a\x1c\x2b\xa3\xfe\
\xfc\xa7\xf3\x77\x1d\xda\xc2\x67\x2a\x32\xd2\xaf\x41\x86\x47\x4d\
\xe6\xda\xd0\x2f\x9d\x8d\x0c\x9d\x70\x8f\xf4\x7d\x6a\xd0\xea\xd7\
\xa7\x65\xf2\x96\xfe\x3e\x06\x19\x35\xc5\x9e\x7d\x14\x5a\x35\xf8\
\x11\x64\xfc\x0f\x43\xdb\x5a\xb5\xa2\x76\xbf\x16\xf2\xd3\x1a\xf5\
\x93\x6f\xa1\x01\xc2\xf4\xb3\x85\x73\x2e\xb3\x67\x0c\x65\x99\xb7\
\xff\x7b\x90\xf4\xad\xe9\x3c\xb6\x01\x4e\x47\xfd\x73\xa1\x67\x68\
\x49\x84\xf7\x5a\xca\x79\x83\x81\xcf\xa0\xfa\xf9\x24\x5a\x0d\xfb\
\x03\x68\x7b\xa9\xcd\x76\x6c\x2a\x92\x97\x73\xd1\x60\xc9\x32\x54\
\x27\x76\xa3\x77\xfe\x18\xda\x3e\xeb\x6e\x54\xfe\x9d\x51\x7d\x7a\
\xdd\x7e\x5f\x8d\x0c\xe7\x27\x90\x11\xbd\x97\xda\xf5\x70\x0c\x92\
\xc5\x03\x50\xdd\x78\xcc\xee\xb3\x07\x2d\x78\xd9\x99\x96\xf7\x0e\
\x9d\x12\x70\x8f\xb0\xe3\x38\x4e\xc3\x89\xd1\x8a\x9b\x73\x91\xd2\
\x30\x17\x09\xfb\x8b\x91\x27\x37\xac\x04\x7d\x00\x6d\xa7\x70\x10\
\x79\x1c\xaa\xd1\x56\x08\xad\xd0\x3e\xa1\x6d\xd0\x96\x08\x33\xd0\
\x16\x4a\x63\xd1\x48\x79\x05\x89\x52\x06\x52\x76\x5b\xd9\xf7\x09\
\x96\xd6\x1e\xb4\xcd\x46\x0d\xf2\xf2\x5c\x89\x3c\x21\xdb\x90\x47\
\xa5\x3e\x2f\x94\xe3\xb4\x44\x82\x97\x73\x04\xf0\x7d\xd4\x46\x4e\
\x43\x03\x55\x11\x32\x0e\xe7\x50\x7b\x95\xdb\xc1\xa8\xbd\xc6\x48\
\x81\x5f\x83\xb6\x45\xc9\x15\x49\x3f\x1d\xb5\x71\x29\x32\x3e\x57\
\x23\xc3\x60\x2c\xf2\x46\x3f\x81\x06\xb1\x26\xa1\x48\x92\x31\x48\
\x91\xdf\x80\xda\x7a\x44\x32\x60\xd6\x0a\xf5\x01\x6d\x91\xe1\xda\
\x0f\x79\xc8\x82\x11\x3c\x18\xed\x75\xda\x06\x79\x48\x5f\xa4\xb0\
\x97\x3b\x42\x7d\xc4\x3a\x3b\x6f\x9f\x7d\x0f\xe9\x9f\x05\x9c\x63\
\x69\xce\xb0\x7c\x9d\x89\xa2\x59\x4e\x47\x7d\xce\x64\xb4\xad\xcb\
\x0e\x64\xa8\xa4\x0d\xa7\xd3\xad\x1c\x73\xa8\x4f\x9c\x41\xed\x41\
\xbf\x42\xd4\x20\xcf\xed\x1c\xbb\x6e\x05\xda\x7f\x75\x08\x5a\xb3\
\xe2\x2a\x7b\xde\x6d\xc8\x6b\x38\xd6\xde\xdd\x2e\x34\x37\x74\xac\
\xe5\xfb\x30\xda\x76\x71\xb3\xe5\x23\x87\xbc\xbe\xad\xa8\xbd\xea\
\x73\x25\x32\x84\x5b\x59\xda\x83\xec\xff\xd0\xdf\xf6\xb4\xe3\x5d\
\x2d\x2f\x53\xad\x9c\x5a\x4a\x5f\x3a\x00\x79\x77\xc3\xf6\x8d\xc5\
\xc8\xa1\xba\xb8\x18\xed\x95\x1b\x21\x59\x16\xa1\xfd\xac\x67\xa1\
\xf2\xef\x88\xde\x5d\xd8\x3e\x32\xac\x82\xbc\xc6\xce\x09\xdb\x99\
\x7d\x06\xd5\xdf\x81\x48\xb6\x2e\x44\x75\xb8\x13\x92\xad\x6f\xd8\
\xff\x65\x68\x50\xe3\x22\x64\x14\xf7\x24\x69\x6f\x1b\x50\x9d\x88\
\x51\xdd\x39\x0f\xbd\xc7\xba\xa2\x0b\x9c\x16\x8a\x7b\x84\x1d\xc7\
\x71\x1a\x47\x98\x9b\x14\x94\xd1\x65\x48\x61\xbc\x10\x29\xbf\xd3\
\x90\x92\xf9\x71\x3b\x7f\x31\x0a\x19\xdb\x01\x7c\x14\x19\xaa\x53\
\x91\xe2\x78\x26\xda\xbb\x70\x8d\x9d\x37\x12\x09\xff\x30\xf2\xdd\
\x0d\x29\xca\x03\x80\xbb\x90\x52\xb0\xdc\xce\x01\x29\xda\x23\x91\
\xa2\x1d\x03\xef\x43\x0a\x9f\xe3\x38\xb5\xc9\x23\x2f\xe4\x3e\xd4\
\x16\x07\xa1\xf6\xf2\x06\x0a\xeb\x7c\x0f\x8a\xc2\x08\x86\x53\x3b\
\xe0\x83\x48\x39\x9f\x89\x0c\xc1\x11\x94\x36\x4f\xb5\x03\x6a\x87\
\xcf\x22\x63\xfb\x72\xd4\x47\x8c\x21\xf1\x44\x8e\x47\x61\x9c\xeb\
\x81\x79\xc8\xf8\x98\x80\x06\xc3\xc2\x3d\x46\xa3\x01\xb4\x2b\x50\
\x3b\x7f\xd6\x7e\x6f\x8f\x3c\x5e\x1f\x41\x46\xc0\xb3\xa8\xff\x39\
\x8f\xe2\x9e\xe1\xc7\xed\xf9\xff\x16\xf8\x33\xe4\xc1\x5e\x6e\xc7\
\xde\x6b\xcf\x38\x17\x78\xbf\xe5\x75\x99\x7d\xd6\xda\xb3\x6f\x41\
\x1e\xb7\x81\x68\x0a\x47\x28\xa7\x81\x56\x4e\x8b\xd0\x60\xc2\x2d\
\xc8\x20\x2d\x65\x9e\x66\xe8\x4b\xc3\x3e\xaa\x3b\xed\xde\xb7\x5a\
\xfe\x9e\x44\x86\xeb\x87\x91\xd1\xbc\x06\xed\xaf\x3a\x18\xb8\x11\
\x85\x3e\x2f\x41\xde\xc8\x36\x68\xaa\xc8\x5b\x96\xd7\x33\x48\xbc\
\xf2\x61\xdf\xda\xbe\x68\xd0\xf2\x4c\xd4\x07\xe7\x91\xc1\x55\x09\
\x7c\xc8\xf2\xf4\xa4\x9d\x7b\x4d\xe9\x55\xeb\xa4\x26\x46\x46\xeb\
\xd7\x81\xff\x40\xef\x3a\x5f\xc7\xb9\xad\xd1\xbb\x79\xd3\x8e\xe5\
\xd0\xfb\x5b\x84\xea\x65\x77\x3b\x96\x5e\x85\x39\x3d\x97\xb7\x17\
\x6a\x47\xa7\xa2\x7a\xbd\x11\x0d\x1c\x0f\x45\xf5\x31\xb6\xf3\x73\
\xa9\x4f\x84\x06\x45\xde\x87\xda\xca\x52\x12\x19\x18\xb6\x23\x1c\
\x8e\xda\xc8\x95\xc8\xc0\xde\x8e\x1b\xc1\x4e\x01\xdc\x23\xec\x38\
\x8e\x73\x6c\x09\x5b\x1c\x9c\x89\x14\xc1\x59\x48\x49\x38\x17\x85\
\x0f\x6e\x41\x5e\x8c\x36\x48\x50\x6f\x46\xa3\xd9\x1d\x50\x38\xe0\
\xdb\xf6\xfb\x56\x0a\x2f\x1e\x52\x6d\xe7\x6d\x43\x1e\x9f\x88\xc4\
\x7b\x7c\x36\x12\xfa\x17\x20\xc5\x78\xb0\xa5\xbb\x0d\x57\x02\x1c\
\x27\x4d\x98\xda\xb0\x0b\xb5\xa9\x51\xc8\x30\x0a\xc6\x69\x17\x64\
\x1c\x2f\xb2\xf3\xfb\x21\x03\x69\x8a\x5d\x33\x82\xd2\x06\x99\x22\
\xe4\x3d\x7e\x1a\xcd\x61\xec\x8d\xda\xe9\x62\x6a\x87\x9e\xe6\x91\
\x51\xbe\x1b\x0d\x8e\x1d\xe4\x48\x03\xa4\x06\xe9\x6d\xa3\x50\xdb\
\x9f\x6b\xc7\x6e\x44\x83\x63\x43\xec\xda\x5e\xc8\xa0\x1b\x89\x06\
\xe2\xb2\xe4\x50\x3f\xf3\x77\x76\xcd\x68\xe0\x0e\x64\x74\x86\xf9\
\xb9\x2f\x5b\xde\x4f\xb7\xdf\x77\x20\x43\x72\x2b\x32\xb4\x87\x22\
\x2f\x6c\x37\xd4\x7f\x6d\xb3\x6b\x47\xdb\xf7\x69\x56\xae\xa3\x91\
\x41\xdf\x90\xb0\xd4\x08\x19\x5a\xa3\xd0\xde\xb0\x0b\x90\x41\xf3\
\x0d\xfb\x6d\x07\xf2\xb0\x5f\x81\x3c\x7e\x61\xe0\xa0\xa7\xe5\x6b\
\x87\x95\x69\x08\x8b\x4e\x13\xfe\x1f\x8b\x8c\xe9\x39\xc8\xd3\xdd\
\xd7\xae\x3d\xd5\xf2\x7c\x81\x95\xe5\x18\x6a\xef\xe3\xdc\x9c\x09\
\x75\x31\x1d\x3e\x5e\x8c\x10\xf9\x50\x9e\xfa\xbf\x86\x23\xf7\x80\
\x2e\x44\x90\x5d\x7d\xed\xff\x2d\xe8\x3d\x97\xa3\x76\xf2\x22\x89\
\x17\x3f\x9b\xbf\xa1\xa8\x2e\xbc\x68\xf7\x38\x8f\x64\xb1\xc9\xb1\
\x28\xc4\x1a\xd4\x9e\xfe\x07\x0d\xaa\xb8\x0c\x74\x8e\xc0\x0d\x61\
\xc7\x71\x9c\xc6\x11\x04\x7f\x35\x52\x8c\x47\x20\x25\xb3\x1f\x49\
\x1f\x1b\x46\xb2\xf3\x48\x18\x87\xd1\xf1\x5d\x68\x0e\xd4\x5e\x64\
\x2c\x6f\x46\x0a\x6d\x7d\xca\x56\x50\x88\x83\x60\x0f\xc6\x77\x15\
\x52\xdc\x67\x21\x05\xb2\xb5\xa5\xed\x0a\x80\xe3\x1c\x49\x56\xc1\
\xde\x02\xbc\x82\xda\xdf\x62\x64\x10\x06\xe3\x27\x46\x6d\x2e\xb4\
\xb5\xa3\x59\x55\x3f\xdd\xe6\xcb\x50\xfb\xad\xb1\x63\x35\xa8\xdf\
\x68\x6b\xbf\xa7\xef\x57\x88\xf0\x5b\xf0\x14\xa7\xbd\x6d\x3b\x91\
\x37\x7b\x1f\xea\x4f\xb6\x51\x78\x61\xaa\x36\x28\x42\xe5\x09\x34\
\x58\x37\x03\x79\x7a\x2f\x41\x1e\xd5\xf4\x7e\xa5\xe5\xa9\xbc\x86\
\x39\xc9\x77\x5b\xda\x0b\x91\xe1\x9d\xa6\x26\x55\x36\x51\xea\xfa\
\x52\xdf\x47\x08\xa1\xee\x8b\x0c\xd0\x95\x68\x51\xac\xb2\xd4\x3b\
\x08\xcf\x11\xee\x11\x23\xef\xf0\x2b\x96\xcf\xb0\x70\xe0\x39\xa9\
\x73\xeb\xba\x67\x45\x81\x77\xba\x1f\x85\xd7\x6e\x44\x06\xf8\x21\
\x5a\x86\x11\x1c\x21\x99\xf1\x8f\xc8\x33\xbc\x96\xe2\xd1\xa3\x11\
\x1a\xb0\x59\x8e\x22\x1a\x5e\x46\x83\x10\xfd\xd0\xa0\xef\x36\xd4\
\xa6\x8a\xb5\x93\x18\xcd\xe5\x7d\x00\x95\x7d\x35\x7a\xff\xc3\xed\
\xef\xd6\x22\xd7\x86\xe9\x02\x85\x64\x60\x84\xea\xc1\xbf\xa7\xce\
\x0b\xf5\xd7\x71\x8e\xc0\x2b\x86\xe3\x38\x4e\xe3\xe8\x87\xc2\xc7\
\x2e\x03\x3e\x85\x3c\x49\xd3\x90\x72\x79\x36\x0a\x8f\xbe\x15\x09\
\xe5\xb7\x49\x94\xe9\x75\x28\x0c\x72\x14\xf2\xda\x5e\x8a\x16\x71\
\xd9\x87\xc2\xc9\x06\x92\x84\x81\xa5\x3f\xe5\x28\xdc\xaf\x2d\xf2\
\x04\x5d\x8b\x46\xc0\xab\x90\x12\x3c\x02\x29\x30\xa7\xa3\x70\xc0\
\x96\xa0\xbc\x39\xce\xd1\x12\xa1\x36\xd8\x0d\x19\x42\x61\x2e\xe2\
\x20\xd4\x0e\xaf\x40\x03\x49\x13\xd0\xca\xf0\xeb\x90\x62\x7f\x33\
\x32\x18\x27\x5b\x3a\x9d\xd0\x14\x87\x9e\xd4\x6e\x6b\xc1\xf8\x8d\
\xed\x9c\xeb\xed\x9a\x0b\x50\x3b\x5d\x85\xbc\xb1\x97\xa2\xf0\xcd\
\x10\xb6\x7b\x00\x19\x02\x1d\xa8\xad\xe4\x87\xb0\xe1\x1a\x34\xd0\
\x35\xd9\x3e\x37\x22\x6f\xe8\x2a\x64\x38\x8c\xb4\x6b\x2f\x43\x7d\
\xd1\x40\x14\x2a\xdc\x9a\xc4\x78\x3c\x88\x8c\xe6\x4f\xa0\xd0\xe5\
\x1b\xec\xfc\x05\x96\xb7\x01\xa8\x5f\xb9\xce\xca\x63\xae\xe5\xab\
\xaf\xa5\xd7\x0d\x79\x62\xab\x90\x17\x39\x18\x24\xe5\x96\x46\x07\
\x4b\xf3\x4a\xb4\xd2\xf5\x6b\x24\x06\x6c\x6f\x14\xc2\x1d\x9e\x37\
\x50\x8e\xfa\xb1\x4b\xed\xde\x9f\xb6\xb4\x16\xa1\xf0\xd7\x1b\xd0\
\x7c\xd0\xdb\x51\x28\xec\x36\xbb\x26\x87\x0c\xd6\xce\x96\xf6\x00\
\x34\xdf\xba\x0c\x19\xb3\xa7\x90\x84\xe7\x86\xb2\x0c\x83\x07\x31\
\x1a\x88\xbc\xc0\xee\x7b\xa3\x9d\xbb\x15\x0d\x08\x9c\x6a\xf9\xbc\
\xd0\xd2\xed\x8c\x06\x01\xba\xd2\xfc\xfb\xd5\x6d\xc8\xc0\x2d\x65\
\x25\xf5\xc7\x51\x14\xc2\x07\x50\xe4\xd3\x17\x81\x4f\xa2\x36\x75\
\x38\x75\x5e\x76\xf0\x28\xbc\x83\xea\xcc\x7d\x46\xa1\xfa\x95\xbe\
\x36\x3d\x98\x94\x43\x03\x55\x6d\xd0\x3b\xbb\x1a\xd5\xb3\x38\x75\
\x4e\x48\x33\x7d\xcc\x71\x8e\xc0\x3d\xc2\x8e\xe3\x38\x0d\x23\x22\
\x99\xcb\x1b\xc2\xe8\x36\xa2\x05\x43\xb6\xa2\xb0\xbc\x3c\x52\xee\
\xf6\x03\x3f\x44\xca\xe7\x42\xe4\x5d\xd8\x03\xfc\x18\x29\x77\x21\
\x3c\x6f\x2e\x52\xca\xa7\x23\xc5\xeb\x0d\xe4\x71\xd9\x6f\xf7\xdc\
\x82\x94\xe0\x4d\xc0\x4f\x91\x82\x76\x18\xb8\xdf\x7e\x7b\x0b\x85\
\x82\x8d\xb3\xf4\xa7\xd8\xef\xee\x11\x76\x9c\xda\xe4\x50\x7b\x99\
\x8c\x8c\xd8\xd5\xc0\x4f\x90\x17\xb1\x07\x5a\x00\x6a\x25\x0a\x89\
\xdd\x8b\x8c\xbe\xc7\xd0\x00\x53\x6f\x64\x78\x1e\x40\x86\xe9\x2e\
\x6a\x7b\x3d\xc3\xa0\xd7\x5e\x3b\xfe\x14\xf2\xfa\x8e\x42\x21\xd2\
\x33\x90\x51\xf0\x20\x1a\xb8\x5a\x66\xe7\x1f\x06\x1e\xb6\x3c\x94\
\xa3\x39\xaf\x7b\x51\x28\xf2\x4e\x14\xbe\xbb\x19\xf5\x3b\x55\x28\
\xec\x78\x31\x6a\xeb\x3b\x80\x1f\x91\xf4\x27\x2f\xd9\xf9\x7d\x91\
\x77\xae\xc2\xf2\x0b\xea\x97\x7e\x8b\x16\x81\x1a\x63\xc7\x9e\x41\
\x06\xeb\x21\xe0\x67\x68\x10\x2f\x8f\xfa\xa8\xd5\x24\x03\x74\xad\
\xed\xf7\xb3\xec\x99\x7e\x67\xe7\x6d\xb4\xe7\x5a\x6f\xe5\x78\x1e\
\x32\xc4\x7f\x8e\x8c\xd9\x2e\x96\x77\x2c\x4f\xd9\xb0\xf2\x99\x68\
\xfe\xf4\xe9\xf6\x6c\x61\x35\xeb\x6a\xe0\x21\x64\xac\x8e\xb5\x3c\
\xbf\x60\xcf\xf2\xb2\x95\xcf\x5a\x14\x52\x7b\x86\xe5\xe5\x01\x92\
\xad\xec\xc2\x80\xc0\x4b\xa8\x6f\x7c\x11\x0d\x6a\x84\x3e\x78\xb9\
\xdd\x7f\xb4\xbd\xd3\xc5\xa8\xbf\xbd\xcf\xca\x72\xbc\xd5\x93\x17\
\x48\xc2\xae\xdb\x90\x0c\x2a\x34\x57\xc2\xc0\x6b\x29\xe7\xad\x47\
\xf3\x89\xcf\x25\x69\x3b\xfb\xd1\xd4\x9c\xee\xa8\x6e\x54\xa1\x01\
\xe2\xf4\x5c\xdd\x59\xe8\x9d\xa4\xef\x53\x86\xea\xc9\xfa\xd4\xf1\
\x20\x6b\x43\xb4\x46\x84\xe4\xdd\x4f\x51\xbd\xa8\x44\x32\x70\x2b\
\x49\x7b\x6c\xce\xef\xc6\x39\x86\xb8\x21\xec\x38\x8e\xd3\x30\x72\
\x48\x51\xfe\x7e\x81\xe3\x61\x45\xcc\xd7\x90\x32\x17\x8e\xe7\x90\
\x72\x0a\x12\xf8\x1b\x91\x42\x1a\xa5\xce\x39\x64\xc7\xd2\xa3\xd8\
\x2b\x53\xdf\x37\xd8\x6f\xcb\x91\x02\x0d\xb5\x3d\xc6\xcf\xd9\x27\
\x4e\xe5\xc5\x71\x9c\xda\x04\x65\x7a\x3e\x9a\xcf\xff\x38\x32\x46\
\xd3\x7b\x80\xe7\x90\x57\x72\x3e\x0a\x09\xbe\x1a\x19\x45\x3b\x91\
\xc1\xb6\x18\x19\x88\xf7\x53\xbb\xad\x85\xf0\xdc\x05\xf6\x7d\x0a\
\x89\x07\x31\x78\xb6\xc2\x5e\xaa\x69\x72\x76\xff\xb0\xaa\xee\x62\
\x3b\xf6\x88\xfd\x7d\x35\x95\xc6\x0b\xf6\x89\x53\x69\x66\xfb\x93\
\x08\x19\x8c\x0b\x91\x17\x38\x7d\x3c\xac\xae\xfc\x7c\x26\x5f\x11\
\x0a\xab\x5e\x98\x39\xbe\x0d\x19\x9b\xc1\x8b\x37\x27\x93\x1e\x96\
\xf7\x1c\xf2\xd8\xbe\x9d\xb9\xfe\x45\xfb\xbf\x2b\xf2\xf0\x1e\xc8\
\x5c\x3f\x0d\xf5\x5b\xd9\xf2\x88\x90\x51\x35\xc5\x8e\xa5\xfb\xb5\
\x67\x48\xfa\xc9\x37\xd0\x40\x62\xfa\x9e\xeb\x91\x41\x1b\xa5\xae\
\x9b\x62\xff\xaf\x4e\x9d\x3b\x1d\x19\xd5\xe9\x6b\x77\x22\x03\x3c\
\x7d\x6d\x7b\x2b\x1b\x37\xb4\x6a\x13\x21\x23\xf4\x61\x92\xf2\x8a\
\xd0\x80\x41\x15\x89\x5c\x7b\x82\xda\xb2\xea\x25\x6a\x7b\x7a\x03\
\xaf\xa7\xd2\x85\x64\x15\xf1\xe5\xa9\x73\x23\x6a\xcb\xc0\x70\xde\
\x46\xdc\x0b\xec\x1c\x05\x6e\x08\x3b\x8e\xe3\x34\x9c\x10\xae\x58\
\x8c\x5c\x91\x6b\xea\xba\xbe\xbe\x34\xd3\xca\x41\xa9\xf7\x74\x1c\
\xa7\x30\xcf\x21\xaf\x68\x05\xc5\xb7\x1a\x0a\xc6\xd8\x23\xc8\xd3\
\xd9\x13\x45\x7e\x04\x43\x97\x3a\xae\x83\xa3\x6b\xab\xe9\xeb\xb2\
\xd7\x47\x25\x5c\x9b\xed\x3b\x76\x23\x23\xb3\xaa\xc4\xfb\x97\x92\
\x76\x31\x23\xb0\xae\xe7\x0d\xc7\xf6\x23\x6f\xef\xc1\x12\xf3\x92\
\x2d\x93\x62\xd7\x1c\x6d\x59\x1e\xcd\xf3\x06\x0e\x5b\x59\xfa\xba\
\x0b\x47\x52\xa8\xbc\xb2\x0b\x6d\xe5\xea\xf9\x3f\x9d\x56\xa1\x63\
\x51\x23\xae\x77\x9c\x82\xb8\x21\xec\x38\x8e\xe3\x38\x4e\x4b\x24\
\x42\xde\xbd\x57\x28\x4d\x79\x4e\x7b\x6b\xe1\xe4\x18\x74\x0a\x8b\
\x3c\x35\x15\xe3\xe0\xb0\xe5\xa9\xa9\xe4\xe7\x68\xa8\xc2\xa7\x9a\
\x38\x4e\xb3\xe2\x64\xe8\xc4\x1d\xc7\x71\x4e\x16\xc2\x56\x12\x8e\
\xe3\x9c\x1c\x94\xb2\xcd\x4b\x20\xec\x81\x9a\x5e\xa9\xb9\xa9\x92\
\x5d\xb8\xab\x29\xd1\xd4\xf2\xd3\x52\xf2\x7e\xb2\x51\xd7\xfe\xc5\
\xfe\x1e\x9c\x63\x42\x53\xef\xc8\x1d\xc7\x71\x9a\x2a\x79\xb4\xba\
\xeb\xd7\x81\xaf\xd9\xe7\x53\x68\xd5\xd6\xe3\xb9\xa2\x68\x8c\x42\
\x33\x6f\xc0\xa3\x7a\x1c\xa7\xb1\xe4\x81\x8b\x81\xcf\x90\x2c\x82\
\x54\xca\x35\x67\xa0\xc5\xea\xea\x1b\xf8\x0a\xe7\x9e\x57\x62\xda\
\x8d\x25\x87\x16\x00\xeb\xfb\x2e\xdd\xcf\x69\xd9\xe4\xd1\xf6\x56\
\x57\x93\xd4\xb7\x1c\x5a\xdd\x7b\x10\x0d\x1f\x18\x2e\x47\x0b\xb6\
\x75\x48\xa5\x1b\xb6\xfe\x7a\x1f\x5a\xa9\xbd\x23\xb5\xeb\x78\x90\
\x8d\x37\xa1\x05\xd2\xde\x8f\x56\x6c\xf7\x76\xe0\x14\xc5\x0d\x61\
\xc7\x71\x9c\x86\x11\xa3\xd5\x63\x3b\xa3\x85\x76\x1e\x43\xf3\xf1\
\x3e\x47\xa2\x00\xa4\x05\x70\xfa\xff\x7c\x26\x9d\xf0\xb7\xd0\xf7\
\x7c\xea\x58\x48\xa3\x3d\x5a\x61\xb5\x2c\x75\x2c\xca\xdc\xe3\x58\
\xde\xdb\x71\x9a\x23\x31\xda\x86\xec\x52\xb4\xe2\xed\x18\x8e\x6c\
\x6f\xd8\xdf\xf4\x71\xd0\x1c\xd7\xfd\xa9\xdf\xb3\xd7\xc4\xa9\x4f\
\x7f\xb4\x82\x6e\x36\x62\x24\x7b\x6e\xb1\x34\xea\xfa\x9e\xbd\x77\
\x35\x0a\xdf\xbd\x92\xba\xd7\x1a\x70\x9c\xba\x08\x7b\x3a\xd7\x47\
\x8c\xb6\x01\x0b\x3b\x27\x84\x7a\x79\x06\xda\x66\xab\x58\x7d\xce\
\x17\xf9\x1e\xce\xe9\x08\xdc\x89\x64\x5d\xfa\x5e\x83\x90\xec\x7b\
\x01\x2d\x54\x17\x64\x5f\xb8\xae\x1a\xad\x06\xde\x0a\x19\xd2\x75\
\x0d\x6e\x65\x8d\x68\x97\x7b\x2d\x10\xf7\x26\x38\x8e\xe3\x34\x9c\
\x18\xad\x3c\x3b\x0f\x09\xe0\x37\x90\x71\x7c\x21\x1a\xc9\x9e\x80\
\xb6\x1b\x99\x8e\x94\xe6\xcb\xec\xff\x45\x68\x91\x9e\x71\x48\x81\
\x28\x47\x02\xff\x69\xb4\x2a\xed\x10\x3b\xb7\x8d\x9d\xfb\xbc\x9d\
\x73\x0d\x52\xaa\x0f\x93\xac\xde\x3a\x0a\x6d\xf3\xd1\x1e\x6d\x3b\
\xf1\x28\x30\x14\x29\x22\x65\x68\xfe\x23\xc8\xeb\x55\x86\x56\x56\
\x7d\x19\x79\xa8\x06\xd8\x75\xe5\x68\x45\xcf\x95\xa9\x7b\xb7\x45\
\x8b\x01\xbd\x48\x69\x7b\x49\x3a\xce\xc9\x46\x8c\xa2\x3a\xca\xd0\
\x6a\xc2\x93\xd0\x9e\xb4\xe5\x68\x1f\xe1\x36\x68\x9f\xf0\xd5\x68\
\xdb\x97\xf1\x68\x25\xe2\x87\xd0\xe2\x5a\xad\xec\xda\xf3\x51\x5b\
\xaf\x42\x6d\x6b\x9e\x5d\x77\x2d\x6a\xa7\xdd\xd1\x0a\xb7\x95\xc8\
\x5b\x3b\xc2\xee\x31\xd3\x3e\xd7\x93\xec\xab\x3b\x05\x98\x88\xda\
\xf0\x1e\xb4\xb2\xf4\x7a\x92\x08\x90\x5e\xa8\xcf\x79\x14\x19\xe3\
\x93\x90\x61\xb0\x1f\xf5\x29\x4b\x51\x3f\x74\x29\xda\xf3\x77\x19\
\xee\xf4\x70\x8e\x9e\x53\x90\x21\xfb\x16\x47\x2e\x7a\x95\x25\x8f\
\xda\x41\xd8\xfb\x3a\xec\x17\x1c\xa3\x3a\x7f\x09\x1a\x64\x0a\xf5\
\x79\x15\xaa\xb3\xe7\xa2\x7a\xbf\x0e\x0d\x24\x9f\x86\xda\x46\x6b\
\x4b\x77\x28\x6a\x87\xbf\x45\x75\xbd\x9d\xfd\xdf\x17\x45\x5e\xed\
\x47\xf5\xbf\xbb\x7d\x7f\x1c\xc9\xc6\x36\x76\x7d\x0d\x6a\x33\xb7\
\xa2\x55\xce\x97\xa1\xb6\xd5\x16\x6d\x41\x18\xb6\x5e\x9a\x8b\x64\
\xe7\xe5\x24\x32\xf7\x05\x0a\x2f\x30\xe7\x34\x33\xbc\x73\x74\x1c\
\xc7\x69\x1c\x61\xfb\x87\xe0\x9d\x5d\x8e\x0c\xcc\x41\xc8\x20\x7e\
\x05\x09\xe9\x4f\xa0\xfd\x2e\xa7\x22\xe1\x7d\x11\x52\x96\x2f\x22\
\xd9\x1b\xf8\x4e\x14\xda\x75\x37\xda\x26\xe9\x19\xa4\x64\x9f\x8b\
\x14\x80\x91\xc8\x58\xce\x21\xa5\xa0\xd2\xd2\x5a\x81\x14\x89\x53\
\xd1\x1e\xa4\xfd\x2d\xdd\x57\xec\xdc\x0f\xa3\x6d\x3f\x5e\x06\x6e\
\x44\x0a\xfd\x30\xb4\x6d\xcc\x4b\x48\xe0\xdf\x82\x14\x9f\x8f\x20\
\xc5\xe4\x19\xcb\xff\x79\xf8\x08\xb9\xd3\x3c\x89\x50\xfd\x5e\x84\
\x14\xf4\x81\xa8\xed\x80\xda\x55\x57\xb4\x4a\xf0\x75\x68\xc0\x69\
\x2a\x6a\x8f\xa3\x50\xdb\x1d\x82\xda\xd2\x4d\xa8\x1d\xbd\x09\x7c\
\x08\xb5\xad\xf7\xa1\x76\xff\x12\x52\xd4\xcb\x90\x71\x31\x06\xb5\
\xad\x37\x50\x7b\xef\x8e\xda\x59\x7b\xa4\x7c\x4f\x42\x83\x58\x53\
\x90\xe1\xf0\x51\x14\xde\x79\x01\x0a\xf7\x7c\x1a\x0d\xa0\x9d\x87\
\xf6\xf2\xbd\xd4\xf2\xb5\x0a\xb5\xf3\x6e\x76\xdd\x36\xbb\x97\x87\
\x85\x3a\x47\x43\xf0\xc6\x7e\x0d\xed\x0d\x3c\x99\xfa\xfb\xff\x18\
\x79\x5f\xc3\x34\xa1\xaf\xa0\x36\x50\x8d\x06\x60\xcf\x47\xf5\x79\
\x13\xf0\x41\x34\x98\x73\x11\x6a\x77\x4f\x22\xf9\x36\x1e\x19\xbe\
\x13\xd1\xe0\xeb\x6b\x76\xfe\x5c\x92\x05\xca\x0e\xa2\xc1\xd9\xe5\
\xc8\xb0\x3d\x17\xc9\xae\x87\x90\xf1\x7c\x03\x32\xc6\x4f\x47\xed\
\x2d\xb6\xbf\xa7\xa3\xb6\x5c\x83\x64\xf3\x10\xb4\xdf\xf1\x65\x68\
\xe0\x6b\x1b\x92\x7b\x69\x99\xeb\x72\xaf\x85\xe0\x86\xb0\xe3\x38\
\xce\xb1\x25\x1d\xae\xfc\x16\x12\xb4\x5d\x90\xc0\x7e\x06\x09\xf0\
\x97\x90\xe0\x2f\xb3\xdf\x67\x23\xcf\x50\x05\x52\x06\x86\x23\xa5\
\xfc\x3c\x24\xd8\xc7\x20\xe5\xf7\x25\xa4\x40\x3f\x8d\xc2\xb0\xab\
\xec\x3b\xf6\x7b\x57\xa4\x58\xc7\x68\x1f\xd0\xb9\xc8\xb0\xde\x8e\
\x14\xfa\xd7\xec\x5e\xe3\x91\x52\xf0\x0a\xf2\x5e\xcd\xb6\xfb\x0c\
\x46\x4a\xc2\x20\xa4\x64\x74\x42\x23\xf4\xbe\x30\x89\xd3\xdc\x88\
\x91\xd1\x78\x16\xf2\x02\x8d\x46\xc6\x68\x98\xcb\xbb\x0f\x29\xe4\
\x0b\x90\x47\x76\x26\x6a\xbb\x5b\xd1\x74\x88\x10\x2e\x7d\x1a\x6a\
\x43\xaf\xa1\x36\xb6\x11\x19\xad\x5d\x51\xdb\x9c\x83\x0c\xdc\x3c\
\x1a\x08\x7b\x11\xb5\xb3\xa1\xa8\x7d\xb5\x47\x86\xeb\x6b\x28\x22\
\x63\x2c\xf2\xec\xce\x43\x1e\xae\x36\xc8\x38\xdf\x65\xe9\xbf\x81\
\xbc\xbe\xbd\x91\x17\xba\x0b\x32\x42\x86\xd9\xb1\x9e\xa8\x6d\x6f\
\x07\xfa\x9c\xe8\x42\x76\x4e\x4a\xf2\x68\x8b\xa8\x7d\x1c\xb9\xcd\
\x55\x21\x22\x34\x98\xfb\x1d\xe0\xbb\xc0\xf7\x90\xb1\x5a\x8e\xea\
\x68\x47\xd4\xae\x06\x23\xd9\xd2\x06\x78\x0a\x45\x54\x8c\x45\xed\
\xa0\xab\xdd\x77\x1e\xda\xb7\x7b\x35\x1a\x48\xda\x44\x62\x90\x56\
\x23\xcf\xed\x76\x64\xb4\xbe\x88\xda\xdb\x38\x54\xef\xbb\x92\xc8\
\xdf\x40\x7a\x4a\x51\xfa\x7f\xd0\x5e\xd7\xb3\x90\xdc\x1d\x61\x79\
\x0b\x32\xd7\xe5\x5e\x0b\xc1\x43\xa3\x1d\xc7\x71\x1a\x47\x8c\x14\
\xcf\x6a\xe4\xa1\x1d\x89\x0c\xe0\x1a\xa4\x44\x84\xb9\xbb\x61\xb5\
\x59\x90\xe0\x0d\xf3\xaf\x82\xa2\x11\x42\xc9\x40\x4a\xef\x6b\x48\
\x19\x59\x08\xec\x04\xde\x63\xd7\x85\x51\xee\x08\x09\xfe\x8f\x22\
\x6f\xd0\x62\x14\x32\x19\xd2\x39\x9c\xb9\x77\x94\xb9\x77\x6c\xf7\
\x4e\x0f\x88\xc6\x76\xef\x57\x91\x12\xf2\x26\x52\xfc\x1d\xa7\xb9\
\x91\x47\x9e\xa2\x72\xa4\x98\x8f\x02\xd6\x20\x23\xf6\x59\x14\x0e\
\x5a\x85\xda\x47\x98\x2f\x99\xa3\x76\x3b\x85\x24\xfc\x12\xfb\xad\
\xdc\xae\x8b\x52\xc7\xcb\x49\xbc\x66\xd7\xa3\xc8\x8c\xd5\x24\xed\
\xaf\x26\x75\xaf\x9a\xd4\xf9\xa1\xdd\xe6\x33\xf9\x81\x64\x4e\xe3\
\x0a\x4b\xaf\x1c\x19\x11\x1b\x52\xf9\x74\x8f\x96\x73\xb4\x44\x48\
\xee\xfc\x23\x32\x60\xd7\x51\x9a\xd3\xec\x00\x89\xfc\x29\x43\xf2\
\x07\x54\x9f\x97\xa2\x41\xdc\x4a\x34\xe8\x5a\x86\x22\xa4\xde\xb2\
\xdf\xb6\x91\x4c\xf5\x09\x6d\x22\x5b\xcf\xa3\xcc\xa7\x15\x70\x17\
\xc9\x14\x83\xb5\x68\x60\xab\x2e\xc2\xfa\x1a\x41\x16\xa6\x65\x6f\
\x90\x7b\x7b\x91\xdc\xdb\x76\xa2\x5f\x84\xf3\xee\xe0\x1e\x61\xc7\
\x71\x9c\xc6\xd1\x1f\xcd\x81\xba\x02\xf8\x34\xf2\x16\xbd\x88\x84\
\x7d\x30\x7e\x97\x21\x25\xf6\x56\x14\xca\x78\x01\x32\x74\xf3\x24\
\xfd\x70\x84\x8c\xd4\xb5\x48\xf9\x18\x83\x46\xca\x2f\xb7\x34\x5f\
\x41\x61\x6a\x97\xa0\x10\xb0\x4e\x48\xb1\xe8\x82\x0c\xe1\x1c\x0a\
\xd7\x4c\x6f\xef\x92\x43\x42\xbd\x1d\x0a\xdf\xbc\x0a\x29\xff\x33\
\x49\x14\x8a\x70\xef\x72\x64\x08\x6c\x44\xde\xb1\x70\xef\x1e\x78\
\x78\xa5\xd3\xfc\x68\x85\xc2\x33\x1f\x42\x1e\xac\xff\x40\xde\xac\
\xe0\xc5\x82\xda\xfb\x05\xe7\x52\xdf\xa3\xd4\xb1\x59\xa8\xad\x5e\
\x05\xdc\x8c\xda\xe3\x0b\xa8\x4d\x86\xf6\x7e\xa9\x9d\xdb\x05\x0d\
\x98\xad\x45\xde\xdb\x0e\xa9\xb4\x22\xd4\x47\xcc\x40\x21\x9b\x93\
\xd1\xca\xbb\x3b\xed\xfc\x72\x6a\xb7\xd7\x08\xf5\x21\x3d\x51\xa8\
\xe9\x30\x14\x56\x1d\xf2\xd5\x03\xb5\x67\xc7\x69\x08\xdb\xd1\x20\
\x4b\x29\xeb\x43\x84\xa9\x41\x69\x43\x35\x84\x26\xbf\x8e\xa6\x04\
\xf4\x40\x83\x4d\xe7\xa0\x81\xa7\x0e\x28\x02\xa2\x35\x8a\x5c\x48\
\x4f\x31\x22\x75\xdf\x91\x48\x2e\x06\xd2\xe7\x75\x47\x03\x3f\xfb\
\x90\x37\xb7\x22\xf5\x3b\x24\x06\xf9\x56\x24\x37\x27\xa3\xd0\xeb\
\x38\x95\xc7\x1c\x47\xca\xdc\xcb\x48\x22\xab\x9c\x66\x8e\x7b\x84\
\x1d\xc7\x71\x1a\x46\x84\x14\xcd\x45\xc8\x70\x8c\x91\x50\xfe\x03\
\x0a\xdf\x5a\x86\x94\x89\x30\xda\xfc\x43\xa4\x78\x0f\xb3\x73\x66\
\xda\x75\xeb\x91\x40\xde\x89\x42\x1f\xb7\x02\x3f\xb1\x73\xc7\xa0\
\x91\xf4\xb9\x24\x5e\xa3\x91\xc8\xfb\x3b\xc7\xae\xfd\x05\x0a\x0d\
\xdb\x0a\xfc\x12\x79\x72\xf7\xda\xbd\x73\xc8\xb0\xfd\x31\x9a\xf7\
\xd4\x09\xf8\x39\xf2\x32\xb7\xb2\x73\x73\x28\xfc\xec\x45\xbb\xe6\
\xc7\xa9\x7b\xbf\x80\x46\xf0\x7d\xd0\xd4\x69\x4e\x84\x45\x7c\xe6\
\x91\x78\x53\x43\x3b\xfd\x2d\x1a\xa0\x9a\x01\xec\xb0\xef\x21\x04\
\x33\x42\xed\x71\x8d\x5d\xbf\x01\x0d\x34\xdd\x87\xe6\xdb\x1f\x46\
\xed\x7c\x0d\xf0\x1b\x64\x98\x0e\x46\xf3\x20\x57\xa2\x70\xd1\x1c\
\x0a\xa7\x5e\x81\xda\xeb\x1e\x4b\x7f\x33\xea\x07\x9e\x43\x8a\xfd\
\x28\xbb\xff\xc3\x68\x1a\xc4\x74\xd4\x47\x94\x59\xbe\xf3\xa8\x0f\
\x88\x51\xfb\xaf\x02\x7e\x67\xd7\x74\x45\x46\xf7\x9b\x78\xdb\x75\
\x1a\x46\x7a\xa0\xb4\xbe\xf3\x16\xa0\xfa\x1d\xce\xcf\x23\x59\xb6\
\x19\xc9\xa8\xc3\x48\x9e\x1c\x04\x1e\x40\x86\xe7\xff\xa2\x3a\xbe\
\x11\xc9\xa4\xed\x76\x6d\x30\x4e\xf7\xd8\xb9\x3d\x50\x5b\xdb\x6f\
\xe9\x6f\x46\xc6\xf5\x7e\xd4\xee\xce\x47\x6d\xec\x51\x64\x60\xef\
\x44\x6d\x65\x0f\x9a\x8a\xb4\x07\xb8\x1f\x19\xb7\xa7\xf0\xff\xd9\
\x3b\xef\xf0\xb8\xaa\x33\xff\x7f\xee\x8c\x24\xcb\x96\x7b\xef\xbd\
\x62\x8a\x29\xa6\x83\x4d\x31\xbd\x84\x4e\x20\x85\x24\xa4\x27\x60\
\x36\x8d\x6c\xea\xfe\xb2\x9b\x64\x37\xc9\x06\xb2\xe9\x15\x08\x10\
\x48\xe8\x1d\x03\xb6\x31\xd8\x14\x1b\xdb\xb8\xe2\xde\x71\x2f\x92\
\x9b\xda\xcc\xfd\xfd\xf1\x7d\x8f\xef\xd5\xd5\x8c\x24\x5b\x2e\xb2\
\x7d\xbe\xcf\x33\x8f\x46\x77\xce\x3d\xbd\xbc\xed\xbc\x2f\x3c\x69\
\x65\xed\x20\x72\x24\xb9\x9d\x9a\xe7\xde\x9b\xf8\x73\xef\xa8\x81\
\x67\x84\x3d\x3c\x3c\x3c\xf6\x0d\x29\x74\xf8\xff\x26\xc7\xf3\x34\
\x62\x90\x43\xa2\xc3\x74\x2d\xf0\x88\x7d\x77\x52\xeb\x79\xf6\x7f\
\x1a\x1d\xce\x2f\x12\x31\xa6\xff\x4c\xa4\x05\x11\xcc\x93\x12\xcf\
\xdf\x45\x26\x5d\xee\x99\x23\x46\x5c\xd9\x01\x22\xc0\x97\x24\xde\
\x9b\x1e\x2b\x7b\x0d\x22\x4e\xea\x2a\xdb\xc3\xe3\x48\x41\x80\x08\
\xe9\x27\xa8\x4d\xf0\x4f\x24\x32\x7f\x76\xbf\x8d\x23\x5a\x0b\xaf\
\x25\xd2\x07\x88\x31\x7d\x3f\xf6\x7f\x0a\x11\xe4\x4f\xc6\xd2\xb9\
\x75\xf4\x44\x8e\xf7\x57\xc6\xde\xab\xa2\xe6\x3a\x77\x6b\x78\x3c\
\xd1\xde\x32\x2d\xf6\xee\x7b\x89\xff\x41\x4c\xf9\x42\xb4\xae\xfd\
\x3d\x47\x8f\x03\x89\x14\x91\x40\x26\x6e\xce\xfc\x12\xd1\xfa\x79\
\x07\x09\x96\x5c\x7a\x27\x50\x7a\xc3\x9e\x25\xd7\xa0\x33\xeb\x4f\
\xae\x01\xd0\x39\xfa\xa1\x3d\x5b\x80\xcc\xab\x93\xef\xae\xb7\xdf\
\x9f\xb1\xbf\x3b\x10\xe3\x1d\xb7\xa8\x00\x09\xa3\x52\xb1\x77\xfc\
\xb9\x77\x14\xc2\x33\xc2\x1e\x1e\x1e\x1e\xfb\x0e\x67\x5e\x95\xef\
\xb7\xa0\x9e\xb4\x49\x22\x35\x55\x4f\xbe\xa9\x06\x3e\x4b\xe6\x9d\
\xaa\xe7\xf7\xa4\x99\xb4\x8f\x3f\xea\x71\x34\xa0\xae\xf5\x94\x6f\
\xfd\x34\x74\x0d\xe6\x5b\x47\xe9\x3c\x69\x1b\x5a\xaf\xba\xea\xe6\
\xfe\xdf\x8e\x04\x5d\x21\x9e\x11\xf6\x38\xf0\xc8\xa5\x3d\xde\x97\
\x35\xd3\x90\x34\xf1\xb2\xea\x3b\xfb\xea\x3b\x4f\xeb\x3b\x9f\x3d\
\x8e\x02\x78\x46\xd8\xc3\xc3\xc3\xc3\xc3\xc3\xc3\xe3\xc8\x80\x33\
\xeb\x06\xcf\x04\x7b\x78\x78\x78\xd4\x09\xaf\xfa\xf7\xf0\xf0\xf0\
\x38\xf8\x70\x9e\x30\x3d\x3c\x3c\x9a\x1e\x1a\xbb\x36\x0f\xb5\xb7\
\xe6\x86\xde\xef\xdc\x5f\xed\x3d\x14\x38\x18\x7b\x68\xdc\x63\xf1\
\xa1\x1e\x53\x8f\xa6\x8b\x7d\x99\x1b\xfb\x7b\xee\x1e\xca\x35\x9c\
\xab\xfd\xf1\xb5\xd3\xa4\xe1\x19\x61\x0f\x0f\x0f\x8f\x7d\x43\x16\
\xe8\x05\xdc\x86\xbc\x55\x8e\x41\xce\xaf\xea\x3b\x14\x43\xe4\xe1\
\xf2\x58\x64\x95\x73\x25\xf2\x20\x7b\x15\x8a\x5d\x78\x02\x72\x00\
\x12\x8f\x7b\xd8\x1c\xb8\x06\x39\xbb\x3a\x1c\x89\x56\x0f\x8f\xa6\
\x86\x2c\x8a\xa7\xfd\x03\xa2\x75\x1b\x02\x2d\x80\xaf\x02\x97\xd4\
\xf1\xee\x05\xe4\x5f\xeb\x01\x5a\xc3\x5d\x39\x3c\xd6\x6a\x60\xed\
\xb9\x03\xc5\x10\xcf\x57\xe7\x2c\xf2\xbc\x7b\x22\x51\xe8\xb7\xfd\
\x89\x10\xf5\xd9\xb5\xd4\x4f\x9b\xba\x3d\x74\x18\xda\x7b\xaf\x46\
\xa1\x73\xf6\x67\x7f\x87\xc8\x9b\xf1\x97\x50\xc8\xab\x93\x90\x57\
\xfe\xc3\x61\x4c\x0f\x26\xdc\x3a\xba\xfe\x50\x57\xa4\x0e\x84\xc8\
\xbb\xfa\x55\xd4\xf4\x40\xbd\x3f\x10\xa0\x35\xd1\x85\xdc\x73\x23\
\x8b\xf6\x92\x11\xf6\x39\x03\x39\xaa\x1c\x89\x3c\x66\xef\xeb\x7c\
\xca\x22\x5f\x00\xa7\x5b\x3e\x23\x91\x53\xb1\x53\x50\x54\x8a\x5c\
\x6b\x34\x44\x34\xc4\x8d\x96\x76\x7f\xa0\xc8\xea\x50\x42\x4d\x9a\
\xa5\x3d\x70\xbb\x95\x95\x6c\x67\x16\xed\x35\x63\x80\xee\x28\x0c\
\xd6\xfe\x1e\x97\x06\xe3\xa8\x67\x84\xc3\x7a\xfe\xdf\xdb\xf7\x0f\
\x44\x19\x1e\x1e\x1e\x4d\x16\xed\x50\x6c\xd0\x34\xf2\xe6\xec\x42\
\x0d\xd5\xa5\xad\x08\x91\x77\xca\x53\xd0\x61\x55\x66\x7f\x8f\x47\
\x87\xe9\x2e\xfb\x40\x44\x68\x17\x22\xcf\xb0\xc5\xd4\xd6\x52\xf8\
\x2d\xc5\xc3\x23\x82\x8b\xeb\x5d\xdf\xba\x08\x11\x63\x33\x06\x79\
\x77\x76\xeb\xa9\x3f\x22\x5c\x07\x59\x9a\x38\xb3\xeb\xd6\xdb\x0e\
\x14\xd7\x17\x6a\x13\x78\x85\x28\x8c\x52\xd7\x3c\xef\x93\x78\x2f\
\xbe\x57\x34\x36\x6d\xbe\xf7\x49\xbc\xef\xda\x9a\x45\x8c\xff\xa5\
\xe8\x4e\xf1\x5a\x6a\x3a\xdb\x4b\x96\xb5\x03\xc5\x8b\x4d\xc6\x52\
\xae\x4b\xf8\x17\x2f\x33\xdf\xbe\xe8\x9e\xb7\x42\xfb\x60\x43\xf2\
\x1d\x85\x04\x0e\xce\x0b\x77\x8b\x1c\xf5\xce\x57\xc7\x7c\x0c\x4b\
\xfc\x7b\x16\x85\xfa\x69\x81\xbc\x14\x5f\x8d\x04\x9f\x0d\x19\xd3\
\x23\x01\x2e\x76\x76\x7d\x08\x51\x08\xc1\x11\x39\xfa\x21\xd7\x1c\
\xaa\x6b\x7c\x72\xa5\xcd\x52\xd3\x1b\x75\xfc\x6f\xbe\x7c\x93\xef\
\x83\x18\xb5\xe3\xa8\x7d\x0f\x38\xf9\x5e\xb2\x6e\xf9\xce\x5b\xf7\
\xbc\x19\x62\xb0\xbb\x12\xcd\x9b\x64\x9b\x86\xa1\xb9\xe3\x22\x3a\
\x74\x43\xf3\xa9\xd9\x5e\x8e\x49\x72\x7e\xed\x46\x1e\xe6\x5d\x7e\
\x05\x56\x4e\xdf\x3c\x7d\x0c\x12\xaa\x8f\x20\xe2\xff\x72\xf5\x75\
\x43\xf7\xa4\x10\xd1\x40\x37\x5a\xbe\xf1\x74\xc7\xa1\xfd\x75\x32\
\xd1\x5e\x19\xdf\x37\x2a\x91\x2f\x83\xd6\x88\x16\x4a\x93\x7f\xfd\
\xd4\x37\x4f\x1a\x85\xa3\xfa\x8e\x70\x18\x86\x5c\x36\xb8\x0d\xbd\
\xdb\x44\x82\x91\x76\xcd\xd3\x94\x14\xa5\x09\xc3\x5c\xe9\xf5\xfb\
\xff\x1b\xd3\x83\xed\x15\xd1\xfe\x70\x62\xf7\x16\x64\xc3\xdc\xe3\
\x97\x0d\x43\x2e\x1a\xd8\x9a\xae\x2d\x23\x61\x47\x9b\xe2\x34\x2d\
\x9b\xe5\x2e\xc3\xc3\xc3\xe3\xb0\x82\x23\xba\x21\x92\xd0\x0e\x43\
\x07\xd4\x73\xe8\xf0\x3d\x15\xc5\x2a\xcd\x22\x02\x79\x16\x22\xe0\
\x5a\x21\x6f\xaf\xcd\xd1\x21\xe0\x0e\xd1\x22\x74\x40\xa6\x91\x06\
\xe6\x58\x74\x60\x94\xd8\xef\x1d\x11\xe1\xda\x01\x85\x69\x79\x15\
\x31\xd3\x4d\xde\x04\xc9\xc3\xe3\x00\x23\x44\xc2\xa8\x3e\xc0\x22\
\x14\x0e\x29\xa8\x27\xfd\x7c\x44\xc4\xb6\x41\x9e\x9e\x87\x23\x6f\
\xb4\x95\x88\x46\x3a\x13\xad\xc1\x66\x28\x4c\xcc\x04\xa2\x35\x3b\
\xc2\x7e\x2b\x02\x5a\x22\xef\xd2\x05\x96\x47\x05\xf2\x4a\xdb\x07\
\x38\xdb\xca\x7b\x17\x31\x55\xe7\x20\x82\xb5\xc4\xd2\xbf\x80\xd6\
\xf2\xe9\x48\xbb\xd4\x1c\x58\x0c\xbc\x8c\xf6\x94\x7e\x88\x21\x2b\
\xb2\xb4\xcb\x50\x98\x97\xd1\xf6\xfe\x7b\xe8\x5e\xb0\x7b\x96\x46\
\x21\xd7\xde\xa2\x26\xa1\xdb\x11\xc5\x3b\xee\x84\xbc\xe4\x8e\x43\
\x1a\xaa\x7e\xf6\xee\x2c\x22\x21\x5c\x3f\x14\xff\xb8\x15\xf2\x40\
\xfd\x0a\x12\xc4\x95\xa3\xb0\x37\x23\xad\x9c\xb6\xd6\x27\x8b\x90\
\x56\xf0\x25\x14\xe2\xe6\x1c\xb4\x2f\xad\x41\xfb\x95\x8b\xf9\xfa\
\x22\x35\xf7\xab\x8b\x90\x00\xb0\xd0\xf2\x68\x85\x08\xeb\xae\x88\
\x39\x9f\x03\x5c\x06\x3c\x8b\x3c\xeb\x9f\x81\x08\xec\x93\xad\xed\
\x73\x2d\x2f\x57\xd7\x8d\x96\xb6\x97\x8d\x4f\x89\x8d\xdd\x74\x24\
\xac\x6c\x6b\x7d\xb8\x28\x56\x87\x42\x1b\xa3\x61\xd6\xc7\x33\x90\
\x97\xfd\x51\x56\xc6\x28\x64\xad\x93\xb1\xf7\xba\x10\xc5\x6c\x7e\
\xcf\xc6\x75\x0c\xd2\x3a\x16\x01\xcf\x53\x53\xa8\x70\x38\xa2\xb7\
\x8d\xd9\x7c\x22\x46\x26\x1f\x1c\xd3\x9c\x02\xae\xb3\xff\xbb\xa1\
\xf1\x7a\x16\x31\x6b\xa3\x90\xc0\xa2\x1c\x79\x5e\x6f\x89\xe6\x50\
\x0a\xcd\xdd\x72\x34\x86\x85\x68\xee\x4e\x41\x63\x77\x21\x62\xb4\
\x43\xe0\x75\x34\xde\x67\xa3\xb1\x75\x61\x9a\xe6\x20\x01\xd6\x85\
\x68\xed\xcc\xb7\xb4\x69\x34\xf7\x7a\x59\x1b\xe2\xcc\x96\xd3\x12\
\x9f\x67\x75\xe8\x82\xe6\x48\x07\xcb\xeb\x6d\xc4\xc4\x75\x45\x6b\
\xa6\x1d\x8a\xac\xf0\x12\xd2\x62\x9e\x13\x6b\xfb\x70\xe4\xed\x7d\
\x95\x7d\x77\xfb\xc5\x5c\x74\x3e\xbb\xb3\xbd\x19\x5a\xc7\x83\xd1\
\x5c\xbb\xc8\xea\xf4\x2e\x5a\x63\x83\xac\x5d\xcf\xa0\x38\xca\x9d\
\xac\x9c\xe7\xad\x3f\xaf\x44\x61\xd9\xaa\xd1\x3a\xdf\x68\xdf\x87\
\x58\x7e\xe7\x5b\x9d\xfa\x03\x9f\x41\xeb\x61\x1c\xda\xcf\xe2\xc2\
\x84\xe6\x44\xc2\xba\x0f\xac\x8e\x45\x56\x9f\xde\xc0\x66\xb4\xde\
\x37\xa2\xfd\x6f\x04\x5a\xfb\x8b\xd0\x9e\x34\xc6\xea\x56\x68\xe5\
\x0f\xb0\x67\x8f\x59\x3f\x77\x44\x56\x26\xdd\xec\xb7\x42\xab\x6f\
\x6b\x14\xde\xed\x59\xb4\xae\x5c\xb8\xab\x6a\x1b\xeb\xab\xad\x2e\
\x1b\x6d\xbe\x6c\xb1\x72\x4f\xb0\x7e\x7a\x03\xed\xcb\x17\x5a\x7d\
\xe7\xda\xb3\x86\xc4\xba\xce\x8b\xa3\x5a\x23\x1c\x02\xc3\x3a\x17\
\x73\xf3\xf1\xed\xf7\x7c\x2e\x1a\xd4\x86\xa2\x74\x90\x37\x7d\x8b\
\xc2\x14\x97\x0d\x69\x53\xe3\x9d\x81\x1d\x9a\xe5\x65\x6a\xb3\x21\
\x0c\xe9\x54\xb3\x8c\x4b\x06\xe7\x2f\xc3\xc3\xc3\xe3\xb0\x45\x01\
\x32\x07\x9a\x80\x36\xef\x1b\xd1\x81\xe0\x36\xf1\x00\x1d\x28\x01\
\x22\x64\x3f\x40\x61\x20\x8e\x47\x07\x96\x93\xb0\x3a\x89\xee\x08\
\xb4\xe1\x8f\x47\x07\x42\x07\x2b\xe3\x63\x96\xdf\xf3\x88\x20\xbc\
\x82\xc3\x9b\xe0\xf2\xf0\xd8\x5f\x28\x04\x3e\x0f\xdc\x0b\xdc\x4c\
\xfd\xeb\x22\x85\xd6\xe0\x4e\x44\xb0\xb5\x44\x04\xf1\x1c\xfb\xbd\
\x0b\x62\xb8\x26\xa1\x70\x2f\x57\x21\xa2\x7c\x90\xfd\xd6\x13\x11\
\x8a\x53\x11\xe3\x73\x13\x5a\xab\xab\x10\x83\xd4\x09\xb8\x85\x88\
\x51\xbd\xc6\xca\xe9\x1f\xcb\xb7\x1c\x31\x0f\x1d\x11\x23\xfc\x2e\
\x5a\xf3\x17\x59\xda\x81\xc8\x2c\xf7\x4d\x44\x64\x5e\x8b\x08\xf1\
\x4f\x20\x82\x7f\x0a\x12\xb6\x0d\x07\x3e\x6e\xcf\x26\x21\xad\xf6\
\xf1\x44\x8c\x70\xda\xea\xd2\x0a\xed\x1d\xed\xad\x8f\xe6\x23\x66\
\xf5\x2d\xa2\x58\xad\x58\x9d\x2a\x11\x61\x3a\x18\x31\x0d\x03\xd1\
\x9e\xe3\x18\xc1\x59\x88\x61\xfc\x28\x12\x24\x9c\x6c\x7d\x18\x22\
\x46\xba\x1b\x70\x2e\x22\xb8\x5f\xb0\x36\x0e\xa6\x26\x33\x72\x82\
\xb5\x73\x02\x22\x92\x3b\xa3\xd8\xb2\x53\x10\xb1\xde\x06\x09\x13\
\x8e\xb7\xf1\x3d\x1f\x31\xda\x8b\x6d\x9c\xd6\x58\x9a\x02\x44\xbc\
\x1f\x8b\x34\x4c\xdd\x2c\xed\x34\xc4\xa4\x7d\xca\xea\xbb\xcd\xc6\
\xd1\x69\x06\xb3\xd6\x9f\x27\x58\xbf\xbf\x6d\x7d\x5c\x80\xc2\xdb\
\xcd\x41\xc4\xf6\x5a\xc4\x20\xb7\xb2\x7e\x9e\x6d\x63\x72\x05\x62\
\x42\x46\xa0\x7d\x7b\x22\x12\xc0\x1c\xae\x08\x11\xc3\xf2\xef\xc0\
\xaf\x10\xa3\xd8\x50\xcd\x5b\x80\xe6\x70\x67\xc4\x30\x0e\x46\x66\
\xba\x27\x21\x46\x69\x02\x5a\x1b\x67\xa3\xf9\x71\x36\x1a\xe7\x0a\
\xe0\x93\x88\x19\x9c\x88\xe6\xfe\x09\x48\x38\xd3\x01\x31\x4e\x6b\
\x91\xa0\xa5\x17\x9a\x17\xef\x58\xfa\xd3\xd0\x3a\xbb\x0d\xad\x65\
\x27\xdc\x39\xdd\xca\x1c\x82\x98\x37\xa8\x6d\xbe\xdb\x12\x31\xb9\
\x6b\xd1\x79\xfc\x39\xa4\xb1\x9d\x89\x98\xb2\xce\x96\x6f\x88\xd6\
\x4c\x1f\x34\x37\xba\x22\xc6\x6e\x26\x62\x96\x57\xa3\x3d\xa0\x84\
\x68\x5d\x4f\x46\x73\xa3\x07\x91\x16\xd3\x9d\xed\x4b\xd0\xbc\x75\
\x82\x70\xc7\x54\x9f\x8d\x98\xe5\x2a\xa2\x10\x6f\x43\xd1\x5c\x3e\
\x06\x31\xc2\xfd\xd1\xfe\xd3\xcb\xea\xd7\x27\x96\xdf\x2c\x22\x93\
\xfe\x69\x48\xd8\x95\x34\x83\x76\x66\xcb\x3b\xa8\xb9\xcf\x5c\x61\
\x63\xf2\xbc\xa5\xb9\xd9\xda\x79\x1a\x5a\x13\x6e\x5c\xfa\xa1\x35\
\x36\xd0\xc6\x73\xa6\x95\x33\x13\x31\xa4\x29\x24\xe8\x9a\x4b\x14\
\xde\xea\x5c\x1b\x9b\x67\xac\xfd\xa3\xad\x0e\xc3\x88\xf6\x9b\x22\
\x9b\x27\x6e\x8c\x06\x58\x3b\xfa\xd8\x58\xba\xfd\xef\x53\x88\x7e\
\x7a\x0d\xed\x41\x23\xf7\x62\x7e\xe6\xc4\x51\xad\x11\x06\x31\xaa\
\xd9\xbd\x50\xcd\x86\x40\x75\x76\xef\x54\xb9\x7b\x5b\x86\x87\x87\
\xc7\x61\x89\x0c\x3a\x2c\x66\xd9\xf7\xcf\xa3\xd8\xa2\x71\xf3\xb2\
\x2c\xda\xcc\x4b\x89\x0e\x8c\xe4\x26\xee\xa4\xc7\xc3\x11\xb1\x35\
\x1d\x58\x81\x08\x83\x36\xf6\x77\x3e\x3a\x04\xda\xa1\x03\xa5\x10\
\x1d\x9e\x1e\x1e\x47\x33\x9c\xd9\xb2\xfb\x34\xc4\x59\x4b\x05\x5a\
\x4f\xc7\xd9\xff\x3b\x80\x4d\x88\xc9\xdd\x88\x88\xc5\x9e\x88\xe8\
\x6c\x85\x98\x04\x47\xd8\x86\x88\xc9\x9d\x89\x98\xe9\x93\x10\x31\
\xb8\x1d\x11\xd7\xfd\x11\xd3\xe8\xf2\xee\x80\x08\xbb\x0c\x22\xe4\
\x67\x21\xa1\xd9\x35\x88\xe8\x7d\xc5\xca\xea\x80\xd6\x7a\x3b\xb4\
\xae\xa7\x58\xda\xe6\x88\x10\x1f\x6c\xf5\x7c\xdd\xea\xf2\x3e\x22\
\xfe\xfb\x22\xc2\x3f\x63\xf5\xec\x6f\xf5\x73\x77\x03\x07\x00\xbf\
\x40\x84\x73\x25\x70\xa7\xb5\x7f\x3b\x22\xe6\x1d\x01\x0e\x8a\x91\
\x7e\xb6\xb5\x79\x36\xd2\x12\xc5\xaf\x7d\xcc\xb4\xbc\xd7\x21\xed\
\x4f\x33\x6a\x9a\xa4\xbb\x3e\xfa\x10\x11\xbe\x57\x20\xc6\x65\x79\
\x62\x4c\xaa\xd0\x1e\xf7\x01\xda\xf3\x56\x20\xa2\x37\x65\xef\x14\
\x59\x5f\x9d\x64\x7d\xea\x34\xb6\x03\x88\x4c\x43\xcb\x10\x51\xfe\
\x81\xb5\xad\x93\xd5\x77\x1e\x62\x08\x3a\x22\x4d\xf0\x34\x22\x2d\
\xa1\xb3\xc2\x49\x59\x1b\x26\xda\xd8\x74\xb3\xbe\x4b\xdb\x3c\x08\
\x10\xf3\xb6\xc3\xca\xef\x65\x1f\x77\x47\xbc\x8d\xf5\x73\xb9\xf5\
\xd3\x07\x68\x3f\x3e\x9c\x85\x93\x59\x34\x27\x9c\x29\xfc\xde\xc0\
\xcd\xcb\x39\x88\x11\xea\x80\xe6\xf4\x2c\x34\x6e\x73\x50\xdf\x5e\
\x82\xd6\x9d\x9b\xbb\xfd\xd0\xbc\xee\x67\x7d\x3a\x10\x59\x0f\x04\
\x88\x09\xec\x8d\xd6\x60\x25\x12\x66\x5c\x89\x34\x94\xef\xd8\xf3\
\xc1\x48\x40\xd2\x15\xcd\xd9\x63\xd0\xd9\xf8\xa6\x95\x5d\x4d\x6d\
\xe1\x98\x8b\xe1\xfd\xb6\xbd\xb7\x09\x09\x84\x9a\x23\x21\x74\x2f\
\xab\xff\x5f\x11\xa3\x59\x08\xdc\x6a\xe9\x96\xa0\x79\x5b\x84\xe6\
\xdf\x06\x34\xd7\x27\x58\x7b\xbb\x58\x3b\x9c\x90\xdb\xf5\x6b\xc6\
\xea\xbf\x1d\x31\x90\x93\x91\x60\xa5\x8f\xb5\xfd\xef\x89\xbe\x5c\
\x84\x18\xcf\x1e\x88\xd9\x1e\x4c\x64\x09\xe1\x2c\x53\xb6\xc5\xea\
\x00\x5a\x97\xd3\xd1\x9c\x3c\x01\xed\x31\x95\xf6\x9b\x9b\xef\xaf\
\x5b\x1d\x36\x5a\x5d\x4f\xb1\xb1\x3e\x17\xed\x3b\xbd\xac\xcf\xdc\
\x9e\xd4\xd1\xfa\xb3\x0d\x5a\xb3\xef\xa1\xb9\xde\x13\xad\xc1\xf5\
\x44\xa6\xd5\x15\x96\x6f\x0b\xb4\x66\xc6\xa3\xf5\x7a\x82\xe5\xd1\
\x11\xad\xf3\x24\xed\x93\x6b\xff\x08\x6d\xce\xcc\x42\x42\x86\x01\
\x36\x16\xbd\xac\x6f\x07\x5a\x1f\xee\x33\x8e\x7a\x46\xd8\xc3\xc3\
\xc3\x63\x3f\x22\x1d\xfb\x9b\xb1\x8f\x23\xb8\x0a\x89\xee\xd1\x34\
\x84\x48\xaa\x26\xba\x43\x94\x8a\xe5\xbd\x1b\x1d\x72\xab\x90\x44\
\x3b\x43\x23\x4d\x83\x3c\x3c\x8e\x10\x54\x03\x7f\x46\x57\x11\x1a\
\x6a\x9a\x1a\x20\x06\xe6\x93\x88\x59\x9a\x6a\x7f\x9d\x30\xea\x16\
\x44\x28\xaf\x40\x04\x5f\x32\xcf\x72\x7b\x96\x2b\xce\x6f\x16\x11\
\x9d\x93\xed\xfb\x3c\xc4\x0c\xf6\x8c\xbd\x17\xa0\x35\xdc\x0f\x69\
\x79\xdf\x43\x6b\xdb\x99\x75\x67\x2d\x6d\x2a\x96\x6f\x06\xd1\x6f\
\xae\x4c\x47\x60\x6e\x44\x84\x7c\x85\x95\xb5\x9a\x9a\x77\x01\x43\
\x7b\x2f\x44\xfb\x51\x36\x56\xdf\x64\xdc\xd7\x37\x10\xa1\xdb\x1f\
\x31\xdf\xc9\xfb\x8f\x4e\x7b\x1c\xef\x8f\x38\x11\xdb\x1a\x31\xa3\
\x0b\x80\xdf\x22\x42\xff\x42\x44\x04\xdf\x17\x7b\xc7\x09\x07\x5d\
\xf9\x95\x44\xfb\xa5\xab\xcb\x0c\x44\xa0\x5f\x66\x75\x2a\x8b\xa5\
\x0f\x11\x61\x5e\x4d\xed\xfb\x9f\xe5\xb1\xf6\x39\x26\x3f\x45\xed\
\x3b\x87\x23\x90\x06\x7c\x32\x62\xd4\x4f\x8d\xf5\x77\x40\xcd\xbe\
\x0f\x11\xc3\x31\xc5\xca\x9c\x87\x98\xa9\xfe\x56\xf7\xc3\xdd\xd2\
\x32\x40\x0c\xd8\x4f\x11\xa3\xb1\x66\x2f\xdb\xe4\xc6\x33\x9d\x78\
\xe6\xe6\x5d\x73\x34\x5f\x9b\x59\x7f\xb9\x7e\xdd\x4a\xa4\x1d\x9e\
\x87\x98\xca\xcb\x91\x46\x74\x0a\x5a\x7f\x03\xec\xf7\x07\x10\xf3\
\x76\x22\xf0\x59\xe0\x09\xc4\x0c\xbe\x83\x98\xbb\x39\xf6\xff\xb5\
\x88\x51\x0d\x89\xac\xb2\x92\xa8\xb0\xdf\x53\x68\x5d\x39\xe1\x08\
\x44\x42\x6c\x67\x52\x5d\x48\xc4\x9c\x55\xc5\xde\x73\x6b\x78\x38\
\x62\x94\xdf\x42\x73\x62\x47\x9e\x32\x83\xd8\xdf\x65\x96\xee\x6a\
\x34\xaf\x57\x26\xfa\x7b\x8e\xfd\x56\x84\xb4\xa0\x17\x58\x9d\x5f\
\x42\xcc\xab\xcb\x27\x7e\xff\x76\x37\xb5\xd7\x66\x1c\x6e\xbd\xc4\
\xd7\x42\x15\x62\xae\xa7\xdb\x18\x15\x21\xa1\xd0\xc7\xd0\x9e\xb8\
\x8a\xe8\x4a\x43\x48\x34\xd7\x53\x39\xca\x09\x62\x9f\x56\x48\x8b\
\xbb\xde\xf2\xcf\xb7\x2f\x87\x89\xef\x2d\x13\x63\x14\x9f\x27\x6f\
\xa3\xfd\x67\x2e\x5a\x8b\x8d\x12\x3a\x1d\xee\x0b\xd6\xc3\xc3\xc3\
\xe3\x50\x22\x20\x3a\xf0\x0b\x90\xe9\xd0\x79\xe8\x00\x9f\x85\x0e\
\xb5\xd6\xc8\x44\xeb\x12\x74\x78\x67\xd1\x26\xde\xc7\xfe\x77\xfb\
\xb0\x3b\x50\xdc\xe1\xf2\x1e\xd2\x3a\x5c\x42\xe4\xa8\xa5\xd4\xf2\
\x3d\x1e\x49\x66\xcf\x45\xc4\x81\x37\x39\xf1\xf0\x88\x88\xf8\xa5\
\xd4\x7f\xaf\xd1\xa5\x2f\x40\x44\x77\x16\xad\xb7\xb9\x68\x4d\xa7\
\xd0\xda\x4d\x21\x22\xb0\x13\xd2\x0e\xc5\x19\xa4\x5c\x0c\x64\x16\
\x11\x95\xc3\x10\x91\x0b\x91\x99\x9f\xbb\xc3\x18\x27\x52\x5d\x1e\
\x2d\x91\xe6\x66\x25\xd2\xc8\x74\xa2\x36\x13\x86\xd5\x77\x91\x3d\
\xbf\x0a\x69\x37\xaf\xb6\x36\x6f\x27\x72\xda\x37\xc6\xea\xef\xb4\
\xe2\x65\x88\xe1\xbf\x16\xed\x1b\xd7\x23\x86\x63\x3b\xb5\x19\xc8\
\x14\xd2\xb8\x8d\xb0\xbe\xd9\x4a\x74\x07\xd4\xd5\x3d\x9d\x48\x5f\
\x8e\x18\xdf\x31\xd6\xce\xe3\xad\xec\xb3\xed\xd9\x66\x44\xb4\x56\
\xe7\x28\xcb\xf5\x61\xae\x7c\x53\x88\xc1\xff\x10\x11\xfe\x53\xed\
\xb7\xdd\x48\x78\xd0\x31\xc7\x18\x04\x75\xe4\x9b\x1c\x33\xa7\x2d\
\x0f\x91\xe0\xa0\x2b\x12\x84\xc4\xc7\x37\xb4\xf2\x86\x5a\x9a\xdd\
\xc8\x3c\xb5\xb3\xb5\xad\x24\x51\xde\x91\x80\x2d\x48\x28\xd0\x10\
\x87\x59\xf1\xfe\x8d\xcf\x57\xd7\x27\xef\x22\xad\xe6\x18\x64\xaa\
\x7b\x32\x11\x13\x99\x42\xda\xd5\x2d\xa8\x7f\xdd\x3d\xf6\x76\x68\
\xbd\x95\xa2\xb9\xd3\x1b\xad\x1d\x77\xdd\xa0\x05\x5a\x2b\x95\x68\
\x7d\xae\x46\x8c\x68\x3b\x34\xff\xda\x21\x86\x74\x14\x62\x1e\xaf\
\x42\xe3\x1a\x26\xea\x9d\x9c\x23\xf1\xf9\xbd\x09\x31\xe0\xd7\x59\
\x3e\x57\x21\x4b\x88\xdd\xb1\xf6\x3a\x81\xf7\x30\x74\x9e\x07\x56\
\x97\x8e\x44\x73\x33\xf9\xa9\xb0\xb6\x0c\xb6\xef\xd3\x11\xdd\x30\
\x83\x48\x73\xeb\xea\xb4\x02\xcd\x33\x77\xef\xbf\x13\x91\x80\x2d\
\x99\xdf\x20\x6a\xcf\xfb\xe4\x9c\x4c\xae\xb1\x34\x5a\x93\xef\x58\
\xff\xb7\xb7\xf1\x19\x81\xe6\x75\x91\xf5\x73\x5b\xab\x47\x2a\x51\
\x46\x95\x7d\x1f\x4c\xed\xb5\x1b\x20\xe1\x41\x07\x24\x50\x09\x6d\
\x1c\xe3\x6b\xd4\xd5\x61\x17\xda\x8b\xdc\xfe\x31\x3c\xc7\xb8\xac\
\x40\x7b\x88\x33\x99\x1f\x63\xf5\x6d\x14\xfd\x93\xee\xd1\xba\xe8\
\xee\x6b\x86\xb7\x2b\x6e\x59\x74\x24\xad\x5f\x8f\xa6\x8a\x4c\x16\
\x5e\x58\x50\x5a\x3e\x7f\x63\xb9\x73\xa8\x71\x38\x9b\x0f\x79\x1c\
\xf9\x08\x11\xf1\xb5\x1d\x69\x36\x92\x1b\x65\x0a\x1d\x8a\x0b\x2c\
\xed\x3a\x74\xdf\x6c\x05\x92\xd8\x6e\x43\x12\xd0\x81\xe8\x50\x9d\
\x89\x88\x8b\x35\x68\x03\x2f\x43\x44\xde\x2a\x74\x98\xad\xb4\x67\
\xdb\x10\x91\xba\x1e\x1d\x30\x8e\x88\x5d\x68\x7f\x5b\x22\x0d\xc4\
\x0a\x64\xe2\x14\x97\x98\x7a\x78\x1c\xc9\x48\x23\xe6\x6a\x3e\xb9\
\xcf\x90\xbd\x89\xa1\x9b\x46\x4c\xde\x62\xc4\x40\x2f\x47\xeb\xce\
\x3d\x9f\x41\xe4\x49\x7a\x2d\x5a\x7b\x6b\xd0\x7a\x5c\x6b\x7f\xb7\
\xa2\x75\x9a\x42\x44\xec\x22\xb4\xa6\xbb\x5b\xfa\xb9\x88\x11\x6e\
\x87\xee\x0e\x2e\xb4\xb4\x1b\xd0\x9e\x90\x46\x7b\xc8\x34\xab\xc3\
\x40\xc4\x14\xcc\xb0\x32\xb6\x5a\x3a\x97\x76\x97\xe5\xbb\xd8\xea\
\xd5\x12\xdd\xeb\x9b\x8f\x18\x0a\x67\x42\xfa\xb6\xa5\x73\x08\xad\
\x6e\xc5\x88\x81\x5c\x88\x4c\x4f\x2b\xed\xb7\xa5\x44\x5a\xd3\xac\
\x95\xdd\xd3\x3e\xd3\x10\x53\x11\xa0\x3d\x6e\x4b\xac\x0f\x9c\x36\
\xcc\x99\x25\xf7\x20\x72\x00\xb4\xd2\xfa\xb3\xad\xd5\x75\x29\x32\
\xb5\x74\x9a\x40\x47\x0c\xaf\x41\xcc\x8e\x23\xea\x97\xc5\xea\xbd\
\xcc\xfa\xa0\x3d\x62\x7e\x9e\xb7\xe7\x9b\x11\xa3\xb1\xcd\xfa\x66\
\x25\x62\x1e\xdb\x95\xcd\x00\x00\x80\x00\x49\x44\x41\x54\xc6\xd3\
\x36\x1e\x1b\x11\x13\xb5\xc6\x9e\x95\xa2\x7d\x36\x85\x34\xfb\xcb\
\x89\x84\x04\x6e\xfc\xfa\x5a\x9a\xb9\xf6\x9e\x33\x93\xdf\x60\xe5\
\x75\xb3\x7e\x9e\x65\x69\x3b\x20\x6d\xe5\x3c\x7b\x7f\xb5\xf5\xcd\
\xe1\xb0\x17\x37\x27\xba\xa3\x1b\xbf\x1b\xee\xd0\xd0\x75\xe4\xc6\
\x70\x2b\x1a\xab\x94\xf5\xed\x2e\xeb\xf7\x8d\xd6\x5f\x9b\x11\xa3\
\xb5\x1d\x59\x6c\xec\xb2\x77\x56\xd9\xf7\x45\x48\xd8\xdb\x05\xcd\
\x9d\x99\x96\x4f\x47\xa2\x7b\xfb\xcb\xed\xaf\xcb\xab\x19\x72\x4a\
\xb9\x04\x9d\xc1\xdd\xd0\xfc\x9b\x85\xe6\xec\x0a\xb4\xb6\x06\x5b\
\x39\xf3\x2d\x8f\xb8\x25\x44\x85\xa5\x83\x68\xfd\x3a\x13\xe6\x85\
\x96\x57\x1b\x34\xde\xb3\x90\x56\xd6\x99\x8e\x2f\x27\x32\x75\xee\
\x86\x84\x34\xbb\xd0\x5c\xff\x10\xcd\xa3\xd5\x96\x76\x0d\x9a\x1b\
\x5b\x63\xef\xb5\xb6\xba\x87\x56\xc7\xc7\x89\x2c\x45\x5c\xfd\xaa\
\x62\xfd\xb3\xc8\xea\x38\xd3\xf2\x77\xfb\xd4\xb2\x58\x7e\x2b\xd0\
\x9c\x75\x8c\x72\x05\x5a\x77\x99\x58\x9e\x19\x7b\xe6\xb4\xdf\x2b\
\x10\x33\x9e\x41\xcc\x74\x19\x5a\xa7\x4e\xa0\x38\xc0\xfa\x7c\x86\
\x95\x5b\x6a\xed\xda\x6c\xf5\xd9\x85\xd6\xe7\xf2\x58\x39\x29\x4b\
\xb7\xcc\xde\x19\x40\x24\x14\x59\x6b\xcf\x76\x58\xbf\x54\xa0\xfd\
\x63\xb9\x8d\x5f\xca\xfa\x72\x25\x91\x20\x64\x8d\xf5\xcd\x02\x4b\
\xd3\x0d\x29\x0b\x66\xb0\x6f\x8c\xb0\xbb\xcf\x3d\x2e\x18\xd9\xb3\
\x64\xdb\x03\x37\xf6\x6f\xd3\xa5\x65\x81\xf7\x62\xec\x71\xc0\x51\
\x51\x1d\xf2\x95\x67\x56\x6c\x7b\x62\xee\xd6\x3b\xd1\x21\xed\x25\
\x30\x1e\x4d\x19\x19\xe0\x0b\x44\x8e\x1e\xf2\x85\x5e\x70\x9a\xa0\
\xf8\x2e\xea\xa4\x9e\xee\x79\x5c\x4a\xee\x42\x15\xa4\x62\xbf\x25\
\xef\x33\x26\xc3\x35\x04\x89\x77\x93\xe5\x78\x78\x1c\x0d\x28\x02\
\xbe\x85\x88\xc6\x39\x34\xee\x0c\x49\xae\x5f\x88\xd6\x58\xdc\x5c\
\xd2\x21\x6e\x82\x98\x5c\xab\xf9\xf2\xca\xb7\x86\xf3\xbd\x17\x26\
\xca\xca\x57\x46\x7c\x1f\x08\xea\x78\x96\x6c\x6f\xae\xbd\x23\x5b\
\x4f\xda\x5c\x26\xc5\xee\x39\xd4\xdc\xcb\xe2\xef\x24\xc3\xde\xc4\
\xcb\x24\xf6\x5b\xbc\x5f\x5d\xfb\xdc\x6f\x69\xa4\x1d\xba\x12\x99\
\x6b\x4f\x22\xf7\x1e\x1a\x37\x95\x8e\xb7\x21\x39\x9e\xc9\x32\x72\
\xf5\x4b\xae\xbe\x4f\xce\x8f\x64\xdf\x64\xd9\x3b\x21\xcc\xa1\x84\
\x73\x98\xf4\x2d\xe0\xe7\x88\x59\x6d\x4c\xbd\x93\x73\x38\x69\xaa\
\x9b\x3c\xcb\xe2\x63\x15\xff\x5e\xdf\x7c\x86\xba\xd7\x54\xae\xb9\
\x9f\x2b\x6d\xae\x7a\xe7\x9a\x7b\x75\xad\xb3\x64\xda\x78\x3b\x89\
\xfd\x5f\xd7\xd9\x0e\x12\x4a\x5d\x81\x98\xe4\x87\xf3\x8c\x43\x72\
\x3f\x71\xdf\xc3\x1c\xf9\xc5\x99\xe8\x5c\x73\x3d\xde\x36\xf7\x3d\
\x20\xf7\x18\xe5\xa2\x41\xe2\xed\x49\xae\xef\x64\xdf\x92\x27\x0f\
\x12\xf9\xe4\xdb\xd3\xe2\xd7\x11\xea\x9a\x27\x7b\x0b\x17\x5d\xe0\
\xb3\xc0\xd7\xfc\x1d\x61\x0f\x0f\x0f\x8f\x7d\x47\x7c\xb3\xce\xb7\
\x21\xa7\xf2\xbc\x17\x37\xd5\x8b\xff\xdd\x9b\x77\x3d\x3c\x3c\xf6\
\x1d\xf9\xd6\x6f\xfc\x79\x3a\xcf\x7b\x0d\xcd\x2b\x55\xcf\xfb\x0d\
\xd9\x43\x72\xa5\xcd\xb5\x0f\xd4\xb7\x37\xe4\xfb\xbd\xa1\xfb\x4c\
\x3e\x66\x29\x55\xc7\x3b\xf9\xfa\x30\x57\xd9\x49\x46\xd2\xfd\xd6\
\x05\x39\x55\x7a\x37\x4f\x59\xc9\xfe\x4c\x7e\x0f\xf2\x7c\x6f\x68\
\xbf\xe5\xaa\x67\xba\x8e\xdf\x8f\x36\xd4\xb5\x8e\xc8\xf1\x3c\xd7\
\xef\x7b\x33\x9f\xf7\xe6\x5c\xac\x6b\x5c\xea\x9a\x17\x75\xcd\xe9\
\x7c\x69\xa1\xe1\xfb\x85\x63\xfc\xda\x22\x8d\xe7\x4b\x75\xd4\x33\
\xdf\x7e\xd2\x90\xfe\xad\x8f\xae\xa8\x6f\xaf\xaa\x6f\xdc\x1a\x92\
\x26\xdf\x18\x04\x39\xfe\xd6\xd7\x7f\xfb\x9d\xfe\xf1\x8c\xb0\x87\
\x87\x87\x87\x87\x87\x87\x87\x47\x53\x44\x88\xcc\x34\x9d\xc3\x23\
\x0f\x8f\x23\x05\x01\x32\x73\x9e\x8e\xb7\xec\x3a\x64\x38\x9a\x25\
\x58\x1e\x1e\x1e\x1e\xfb\x03\xce\xfc\xa8\xbe\x34\x87\x8b\xd9\x9c\
\x87\x87\xc7\x91\x83\xbd\xd9\x7b\xf6\xe7\x05\xb9\x86\x96\x1b\xdf\
\x3f\xf3\xed\xa5\x71\xaf\xf9\x07\x03\x49\x33\xce\x03\x85\x46\xc5\
\x3f\x6d\x82\x88\x9b\xb2\xfa\xcb\x96\x0d\x43\xdc\x19\xd4\xe1\x86\
\x23\x62\x9c\x3d\x23\xec\xe1\xe1\xe1\xb1\x6f\xc8\x22\x0f\xad\x5f\
\x46\x8e\x70\xdc\xdd\x95\x8b\x51\xcc\xcb\xc1\xc8\x8b\x34\xc0\xf9\
\xc0\x58\xe4\x08\x27\x5b\x4f\x9e\x27\x01\x67\x51\x93\x38\x6c\x8e\
\x62\x8d\xb6\x43\x1e\xa9\x7b\x5b\xde\x27\x73\xe4\x11\x53\x1e\x1e\
\x47\x1b\x42\xb4\xe6\x4f\x64\xff\xae\xe7\x10\x38\x13\xb8\x0b\xdd\
\xb3\xad\x2f\xef\x63\x91\xc3\xa2\x78\xba\x34\xd1\x9e\x93\xcd\x91\
\x7f\x57\xe4\x09\xb8\x38\xf1\xdb\xd9\x28\x4e\xf1\x0d\xe8\x7e\x6f\
\xbe\x90\x29\x3d\xad\xdd\x2e\x84\xd4\x31\x1c\x3c\xe2\xba\x19\xf0\
\x11\xe4\xf4\x2a\xbe\xdf\x0e\x47\xfb\xf5\xd5\xc8\xcb\x76\xeb\x1c\
\xe9\x92\xed\x28\x01\x3e\x8a\xf6\xe8\x1b\xac\x1f\xaf\x46\x4e\x82\
\x72\xf5\x7b\x0a\xed\xf5\x1d\x2d\xdf\x6b\x89\xc2\xe5\x1d\x4e\xc8\
\xa2\x39\xf6\x03\xe0\xdb\xc0\xbf\x03\x5f\x24\x7f\x34\x83\x2c\x9a\
\xeb\xe7\x70\x04\x30\x51\x8d\x40\x21\xf2\x46\x9d\x6b\x5d\xe5\x43\
\x88\xfa\xed\xa4\xbd\x78\x27\x85\xd6\x6f\xaf\xbd\x78\xa7\xa1\x75\
\xe9\x8b\xbc\x65\xa7\x51\x8c\xe6\x7c\xeb\xa3\x49\xc3\x33\xc2\x1e\
\x1e\x1e\x1e\xfb\x86\x10\x11\x31\x37\x22\x22\xc6\xdd\xf9\x19\x8a\
\x0e\x9d\xdd\xc8\xfb\x62\x09\x62\x5a\xa7\x23\x4f\x8b\x71\x64\x13\
\xf9\x05\xc8\x03\xe3\x8e\xd8\xef\x2e\x04\xc1\x71\x88\xd8\x2c\x45\
\x5e\x16\x87\x21\x22\xf2\xb0\x3b\x78\x3c\x3c\x9a\x10\xdc\x1a\x0b\
\x63\x9f\xf8\xb3\x5c\x6b\x34\x1f\x33\x94\x2f\xcf\xf8\xef\xf1\xe7\
\x71\x27\x37\x3b\xd1\x9e\x91\xef\xfd\x64\xf9\xc9\x3a\xe4\xaa\x77\
\x31\x12\xcc\xcd\x43\xde\x5b\x83\x1c\x69\x5d\x79\x69\x14\xa7\xb7\
\x4f\x8e\xfc\x4b\x89\xc2\xba\x84\x89\x32\x5a\x21\x46\xb6\x20\xf6\
\x4e\x33\x2b\x77\xb6\xb5\xe9\xb8\x3a\xfa\xfe\x54\xc4\x48\x65\x50\
\x08\x99\x13\x13\x63\x91\x74\xb6\x13\xd6\x91\x57\x2e\xe7\x5c\xb9\
\xfa\x2c\xee\xdc\xe7\x58\xb4\x47\xc7\xc7\xe7\x02\xe4\x79\x77\x06\
\xf2\x08\xec\xd2\x35\x8f\xbd\x1f\x26\xf2\xcf\x22\x0f\xbe\x29\x14\
\x7a\xa6\x9d\xbd\xd3\x91\x28\x06\x73\xbc\x7e\xc5\x48\xb8\xd9\x11\
\x79\x06\xde\x16\x4b\x07\x35\xe7\x46\xb2\xdd\x07\x63\xcf\x77\x9e\
\x93\xeb\x83\x63\x88\xca\x81\x27\x81\xa7\xac\x3d\x9f\x4d\xf4\x6b\
\x32\x7d\x7f\x6a\xcf\xb3\x5c\xe3\x1c\x77\x36\x59\x5f\x7f\x24\xfb\
\x2e\xdf\xda\x6b\x08\x72\xad\xd1\xf8\xb3\xbd\xb1\x04\x8b\xd7\xcd\
\x7d\x4f\xa3\x78\xca\x6d\xa9\xbd\x76\xc3\x1c\xef\xb8\x67\x3b\x10\
\x8d\x00\x35\xe7\x54\xbe\xba\xa4\x10\xad\xd0\x26\xd1\x86\x5c\x75\
\x4a\xd6\xbb\xae\xb4\x21\x0a\x29\x75\x02\xd1\xdc\xcf\xec\x43\x1f\
\x1d\x72\xf8\x3b\xc2\x1e\x1e\x1e\x1e\x8d\xc3\x6c\x24\xa1\x7d\x1f\
\x85\x2c\x71\x87\x44\x11\x22\x04\xce\x25\xd2\x74\xcc\x01\x46\x22\
\x42\xa9\x1c\x98\x80\xc2\xa0\xdc\x64\xe9\xb3\x28\x94\x41\x25\x3a\
\x28\xcf\x47\xda\x89\x1d\x44\x44\x45\x09\xda\xbb\x93\x5e\xaa\x3d\
\x3c\x3c\xf6\x0e\x45\x88\xf9\x72\x61\x5d\xc6\x21\x06\xe8\x42\xa4\
\xd1\xda\x81\xc2\xa5\xac\x43\x5a\xcd\x14\x72\xdc\xb4\x06\xdd\x5b\
\xbd\x04\x39\x70\x5a\x8c\x88\xcd\x61\xf6\x7c\x14\xb2\x16\xd9\x0e\
\xbc\x8a\x98\x9c\xab\xd1\xba\xdd\x8a\xf6\x81\x51\x28\xf4\xd1\x62\
\x2b\xb7\x18\xad\xe9\xe6\x48\x70\xd6\x3f\x56\xfe\x6a\x7b\x3f\x6d\
\xe5\x6f\x44\x61\x63\xb6\x13\x11\x9c\xad\x11\xf3\xd9\x13\x79\xa0\
\x1d\x87\xac\x52\x5c\xf8\xb5\xf7\x2c\xbf\x10\x31\x69\x17\xa0\x30\
\x24\x59\x2b\xa3\x1c\x11\xb5\x2d\x91\xf3\x9e\xb3\x10\x61\xbb\x8e\
\xe8\x7e\x6e\x27\xab\x5b\x27\xc4\xec\xbc\x68\xbf\x25\x19\xa6\x33\
\x51\x18\x96\x8d\xf6\x7e\x15\x0a\x77\x72\x36\xf2\xbe\x5f\x8e\x34\
\xac\xf3\x11\xe3\xdb\x93\x28\xf6\x70\x11\xda\x47\x2b\xac\x3d\x2d\
\x51\xd8\x98\x57\xad\x7e\xc7\x22\x46\xfb\x0d\x22\xaf\xe1\xc5\xc0\
\x68\x1b\xb3\x02\x1b\x93\x77\x2c\xcf\xf6\xd6\xde\x4a\x2b\x7b\x93\
\xf5\xfd\xc9\xd6\x2f\xad\x89\x88\xfc\xac\xd5\xe1\x24\x14\xba\x65\
\x3e\x0a\xd9\xe4\xcc\x57\x2f\x25\x8a\xf5\xfc\xa2\xd5\xe7\x18\xab\
\xcf\x34\xb4\x37\xbb\xf0\x34\x8e\xb9\xc9\x22\x4d\xd9\x45\xd6\x07\
\x19\x9b\x23\x25\xf6\xee\xc5\x88\x79\x74\xef\x1e\x6b\xf5\x2b\x44\
\x67\xcb\xeb\x96\xee\x04\x7b\xd6\xda\xc6\x6b\x0e\x07\xd6\x9c\xb6\
\x0f\x62\xd2\xe7\xdb\x78\xd5\x85\x10\xad\x89\x99\xf6\xff\x36\xe4\
\x91\xba\xbf\xd5\xfd\x39\x24\x10\x71\x42\x99\x8c\xd5\xbd\x3b\x5a\
\x7f\x05\x36\x46\xd3\xed\x59\x4f\x6b\xf7\x54\xb4\x8e\xce\xb7\x3e\
\x5e\x68\x6d\x1f\x86\x84\x2b\x45\x36\x3f\x5e\x8d\xcd\xa5\xd3\xac\
\x2f\xd7\x58\xb9\xc7\x5b\x1d\x02\x24\xd0\xd9\x05\xbc\x60\xef\x5e\
\x65\x73\x6d\x25\x35\xbd\x12\x77\xb1\xba\x56\x21\x8b\x87\x59\xe8\
\xac\x76\x6b\xac\x3b\x0a\xb9\xf5\x92\x3d\x1b\x89\x42\x42\x85\x48\
\xb8\x31\xc9\x9e\x75\xb0\xb6\x3d\x8f\xd6\xe1\x89\x96\xe7\x9b\x68\
\x4e\xbb\x79\xd2\x1a\xed\x25\xbd\x88\xd6\xee\x5a\xcb\xe3\x4c\x34\
\x4f\x33\x56\xd7\x66\x36\xa7\x0a\xd0\x9c\x3f\xd6\xfa\xf6\x35\x14\
\x8a\x29\x9f\x23\xbf\xb3\x10\x2d\xb2\x13\xad\x83\x6d\x68\x3d\x9e\
\x6c\x75\x9a\x64\x63\x73\x01\x0a\xbf\xd6\x1e\xed\x17\xcf\x59\xbf\
\x9d\x6d\xfd\x58\x84\xe6\xe5\x2c\xb4\x4e\x0a\x10\xed\xe3\xe6\x6f\
\x3b\xb4\x4e\xba\xda\x18\xbc\x6c\xef\x37\x59\xd3\x6f\xaf\x11\xf6\
\xf0\xf0\xf0\xd8\x77\x04\x88\x71\x7d\x01\x69\x86\x5d\x70\x77\x77\
\x98\x0e\x41\xb1\x04\x57\xa0\x78\x8d\xc7\x20\xe2\xec\x55\x74\x10\
\x7e\x1c\x11\x95\x67\xa0\x03\x7d\x02\x22\x3e\xfa\x22\x66\xf9\x02\
\x74\xc0\x6d\x42\x87\x2a\x88\x31\x6e\x74\x10\x79\x0f\x8f\xa3\x1c\
\x59\x44\x48\x8e\x44\x04\xed\x16\xb4\x0e\x2f\x45\x6b\xef\x45\x7b\
\xf6\x69\xb4\xf6\xce\x41\x44\xdf\x38\xa4\xc5\x1c\x8e\x98\xa4\x33\
\xd1\x3e\x70\x0e\x62\x54\xce\x46\xb1\xc7\x5f\x44\xf1\x67\x3f\x66\
\xef\x5f\x80\x18\xcc\xa9\x48\xf3\x5a\x85\x88\xc4\x41\x88\x68\xec\
\x8b\x18\xd3\x8b\x11\xf1\xfe\x22\x62\x9a\x3f\x85\xb4\x39\x67\xd8\
\xdf\x97\xac\xec\xb3\xa8\xa9\x01\xbb\x0e\x11\xd2\xcf\xa1\xbd\xe1\
\x93\x68\xdf\x59\x8e\x62\x00\x6f\x23\x62\x9a\x8f\xb7\xbc\x9e\xb6\
\x3a\xde\x80\x88\xd5\xe5\x88\x61\xae\x46\x8c\xdb\x72\x44\xf0\x1e\
\x83\x08\xdc\x53\xac\xbc\x27\x11\x63\x79\x0d\xb9\xe9\xc8\x05\xb1\
\x72\x4b\xed\x59\x2b\xeb\x57\xa7\x80\x39\xce\xfa\x6b\x09\xda\x0b\
\x67\x5a\x7d\xe7\xda\x3b\x9f\xb2\xfe\x77\x0c\xe7\x68\x64\x46\x7a\
\x2a\x62\x82\xd7\x10\x69\xeb\xfa\xa2\x6b\x27\x2f\x59\x7d\x6f\xb2\
\xf6\x9d\x80\x98\xe3\x71\x88\xd9\xb8\xcc\xda\x72\x39\x30\x11\x31\
\x1b\xf1\xbd\x34\x40\x4c\xd1\x22\x1b\xa7\x32\xab\x73\xda\xf2\xcb\
\x5a\x5e\x27\x21\xa6\xa2\xaf\xd5\x67\x12\xda\xa3\x4f\x41\x8c\x82\
\x83\x3b\x0b\x46\xd8\x5c\x79\xca\xc6\xe1\x3a\xc4\x48\xad\x46\x0c\
\x74\x60\x63\xd2\xcb\xc6\xed\x03\x60\xbc\x8d\xc1\x69\x36\x3f\xce\
\xb1\xb1\x59\x81\xcc\x50\x9b\x73\x60\xe0\x18\xb3\x6f\x03\xbf\xb2\
\x7e\x6f\x88\x49\x6d\x27\xc4\xa0\x1e\x8b\xd6\x50\x29\x62\xde\x4e\
\x8c\xf5\xc9\x30\x6a\x9e\x91\x6d\xd1\x7c\x5f\x88\xe2\xfc\x7e\xce\
\xc6\xf5\x03\x24\x28\xe9\x65\xf3\x60\x25\x12\x1e\x38\x66\xae\x87\
\x7d\x7f\xd7\xd2\xdf\x84\xe6\xe7\xd9\x88\x49\x7b\xde\xc6\xe2\x78\
\x1b\xff\x11\x36\x46\x4b\x90\x90\xa1\x2d\x62\xb6\x8f\x27\x12\x26\
\xc5\xdb\x5f\x82\x98\xef\x0d\x88\x69\xbd\x02\xcd\xbd\xeb\xd0\xf9\
\xfc\xac\xf5\xff\x0d\xf6\xff\xf1\x44\xce\xae\x9c\x30\xe9\x14\x44\
\x03\xbc\x8a\x98\xe0\x2b\x10\x73\x3f\x17\xf8\x84\xb5\xcd\x69\x4e\
\x9d\x89\xb4\x5b\xbb\x9f\xb0\x7a\xdf\x60\x63\xbe\xd8\xfa\xa9\x13\
\x12\xaa\x77\x47\xf3\x6e\x94\xf5\xcb\x1a\x6b\x7b\x2e\xe5\xa6\x6b\
\x4f\x09\x9a\xbb\xdd\xad\x6d\xc7\xa2\x75\xf0\xba\xf5\xd9\xad\x48\
\x50\x73\x1c\xa2\x5b\x5e\x41\x73\xf6\x7a\x7b\x67\x04\xa2\x4f\xa6\
\x20\xa1\x60\x89\xf5\xe7\x1c\xb4\x8e\x4e\x42\x6b\xfc\x46\x9b\x3f\
\xcf\xa1\x35\x73\x1c\x4d\x9c\x56\xf1\x1a\x61\x0f\x0f\x0f\x8f\xc6\
\x21\x85\x88\x96\x63\x89\x4c\xa4\x21\x32\x2d\xdb\x82\x08\xaa\x0f\
\x11\x51\xd3\x0e\x11\xb5\x85\xe8\xe0\xe9\x82\x24\xaf\xef\xa2\x00\
\xf6\x27\xa0\xbd\x79\x38\x3a\xa0\x66\x20\x42\xe0\x44\xa2\xb8\xa6\
\x4d\xfa\x60\xf1\xf0\x38\x0c\x90\x46\x6b\xf6\x6d\xb4\xce\x16\x20\
\xe2\xf6\x5b\x88\x78\x9d\x83\x88\xf3\xd3\x10\xd1\xba\x01\x11\x8d\
\xcb\x11\x03\xd3\x01\x98\x0c\xdc\x62\xbf\xf7\x01\xfe\x82\x08\xca\
\x36\x88\x30\x2d\x41\x44\x7b\x7b\x7b\x7f\xaa\xe5\xb9\x02\x31\x18\
\xad\xac\x9c\x4d\x68\x4d\x17\x20\x82\xd3\x95\xbf\xda\xca\xef\x89\
\x18\x28\x47\xb4\x2e\x41\x5a\x1b\x88\x08\xdd\xa1\xc0\xdf\x91\x56\
\x67\x2b\xf0\x4d\xcb\x6f\x1b\xda\x7b\x2a\x88\x88\xf5\x59\x88\xd9\
\x3d\x16\x11\xe0\xed\xed\xff\x32\xc4\xa0\x55\x20\xe2\x7a\x1a\xd2\
\x20\x39\x8d\xef\x54\xb4\x2f\x8d\x40\xc4\x71\x21\xb5\xe9\xc8\x90\
\x9a\x7b\x9e\xd3\x14\x41\x4d\x2b\x96\x2c\x12\x06\x94\x5a\xbf\x6f\
\x40\x4c\xc9\x76\x44\x80\x0f\xb3\xdf\xda\x23\xc2\x7a\x90\xd5\x6d\
\xae\xf5\x81\x6b\x8b\x13\x46\xbe\x85\x18\x8e\x5e\x88\xd1\x29\x41\
\x9a\xcc\x77\xac\x2f\xfb\xa2\x3d\xf4\x58\xb4\xcf\x4e\xb5\x71\x3a\
\x85\x9a\xa1\x72\xca\xac\xcf\xd6\xa1\x7d\xd9\x99\x9f\x6e\x45\xcc\
\xc1\x22\xc4\x8c\x0c\xb5\xfa\xcc\xb1\x4f\x07\x6a\x33\x8c\xae\x7e\
\x33\xad\x7f\x8f\xb3\xb1\xec\x60\x75\xdb\x6e\x79\x54\x59\x1f\x0f\
\xb4\x32\x27\x22\x41\xc3\x40\x74\x1e\x2c\x46\x0c\xd1\x74\xab\xc7\
\x28\xc4\x5c\xee\xe6\xc0\x68\xda\x32\xd6\x0f\x65\x44\x66\xb8\x75\
\x21\xb4\xbe\x6d\x65\xf5\xd9\x04\xfc\x8d\x9a\xa6\xb2\x50\xfb\xec\
\x0a\xd0\x7a\x7a\x07\xcd\xab\x55\xe8\x1c\xec\x86\xce\xc8\x21\x96\
\xfe\x55\xab\x47\x4f\xc4\x70\xcd\xb1\xf1\x9b\x89\xe6\xa7\x33\xad\
\x1f\x67\xe3\xdc\xd3\xc6\xd6\x31\xdd\xb3\xd1\xba\x28\x46\xc2\x85\
\x63\xd1\xfa\x99\x4f\x64\xce\x9e\x1c\xb7\x65\x88\xe9\xcb\x20\x01\
\x4a\x0f\xc4\xf0\x6e\x42\x6b\xb7\x93\x8d\xe3\x6c\x72\x9b\x0d\x97\
\xdb\x98\x2d\x44\x4c\xec\xfb\x68\x3d\xa5\xad\x6d\xc7\x58\xda\x16\
\x68\x6e\x3f\x42\xb4\x76\xbf\x61\x63\xbc\x16\xed\x31\x01\xda\x07\
\x5c\x5f\x83\xe6\xd2\x0c\xcb\x77\x3e\x91\xa6\x38\x17\x76\xa3\x39\
\x35\xdb\xde\xeb\x82\xd6\x5c\x47\x24\x08\x4c\xdb\xf7\xee\xd6\xcf\
\xd3\x2d\x6d\x35\xf0\x19\x7b\x36\x01\xed\x71\x5d\xd1\xfa\x2a\x42\
\xeb\xa4\x9c\x68\x9d\xb4\x44\x6b\xf0\x37\x68\xce\x2e\xb3\xbe\x6d\
\xd2\x4a\x57\xcf\x08\x7b\x78\x78\x78\x34\x1e\x15\xc0\xc3\xc0\xd7\
\x10\xd1\xb6\x38\xf6\x9b\x23\x86\x52\xe8\xb0\x58\x86\x08\xda\x02\
\x44\x90\xae\x41\x87\x5b\x15\x35\x0f\x8c\x6a\x22\x07\x34\x69\x7c\
\xe8\x10\x0f\x8f\xfd\x8d\x2c\x62\xe6\x9c\x76\xca\x99\x50\x16\x11\
\x99\x03\x3b\x53\xd7\x4a\xb4\x26\xdd\x1a\x4d\x21\x86\x6a\x37\x32\
\x5b\xde\x82\x18\xd7\x2c\x22\x7e\x27\x59\x3e\xef\xda\x6f\xd5\x96\
\x4f\x01\x62\xbe\x17\x22\xad\xcf\x55\xb1\xba\x38\x33\xe3\x64\xf9\
\x59\x2b\x3f\xb9\x47\x24\xef\xfc\xba\xb6\x14\x10\x69\x7f\x83\x1c\
\xef\x5c\x8e\xcc\x56\xa7\x20\x46\xa4\x1b\xb5\x3d\x3c\x57\x53\xf3\
\x0e\x62\x1a\x69\x87\xda\x59\xfd\x57\x58\xfd\xf3\x99\x62\x92\x28\
\x37\x4b\xe4\x47\xa1\x00\x31\x00\x61\xe2\xfd\x78\x7b\xb6\x23\x06\
\x69\x2b\xda\x27\xb7\x21\x46\x24\xce\xd0\x63\xfd\x75\x16\xd2\xb8\
\xbf\x61\x63\x72\xb2\xfd\x5e\x65\xfd\x16\x37\x7b\xad\xb6\x7e\x72\
\xf5\xcb\x17\x23\x36\x57\xac\xd4\x74\xac\xfe\x8e\xa9\x2b\x27\x7f\
\xe8\x9b\xd0\x7e\xbb\x0a\x09\x1c\xde\xb2\x7e\xeb\x90\xa7\x0c\x37\
\x3f\xdc\xf3\x22\x22\x21\xc4\xee\x58\x39\x07\x52\x10\x1a\x20\xe6\
\xf2\xa7\xe8\x2c\x5b\x43\xfd\x8c\x4c\x80\x2c\x97\x1e\x20\x12\xd6\
\x3a\xe7\x67\xae\x1f\x02\xc4\x28\x25\xdf\xab\x24\x9a\x1b\x55\xd4\
\x9c\xaf\xd5\xd6\xe7\x6e\xde\x14\xd9\xb3\x90\x48\x08\xe0\xfa\xa3\
\x2b\x70\x1b\x62\x0a\x97\x22\xeb\x0b\xd7\x8f\x95\xb1\xb2\xa6\x12\
\x69\x4f\x1f\xad\xa3\x4d\x95\xb1\xf1\x73\xa8\x40\x8c\xe7\x07\x68\
\xfe\xba\xf9\x90\x26\x5a\x7f\xf1\x7b\xe4\x6e\xee\x25\xe7\x5c\x81\
\xb5\xd5\xf5\x4d\x48\xcd\xb5\xeb\xfa\xa2\x28\xd6\xc6\xc2\x44\xfd\
\xe2\xeb\xbd\x25\x5a\x1b\xef\x59\x1d\x93\x7d\x9c\x5c\x07\xae\xdc\
\x55\x68\x9f\x4a\x21\xe1\xc2\x32\xc4\x18\xa7\x62\x75\xca\x22\xe6\
\xf9\x12\xa2\xfd\x62\x27\xb9\xe7\xaf\xdb\xc3\xdc\xd5\xad\xde\x36\
\x87\x66\xe2\x4d\xa3\x3d\x3c\x3c\x3c\x8e\x48\xb8\x43\x3b\x85\xb4\
\xb6\x2f\x20\x29\x7e\x9c\xf9\x85\xe8\x60\x99\x86\x24\xc9\x3d\x91\
\xe4\x74\x34\x11\x81\x95\x4a\xe4\xf9\x1e\x92\x88\x5f\x8a\x08\x6d\
\xe7\x18\x2b\x15\x4b\xd3\x64\x0f\x17\x0f\x8f\x26\x8e\x0c\x22\x8a\
\xcf\x40\xa6\x82\xb7\xa0\x35\xf9\x26\xba\xb7\x78\x3e\x32\xb9\x2c\
\x45\x04\x63\x5c\x71\xe0\xd6\xfc\x2e\xc4\xa4\x5d\x82\xb4\x28\x15\
\x88\x49\xec\x87\xb4\x2e\xc7\x01\xa7\xdb\x3b\x8e\xa9\x75\x8c\xe8\
\x29\x48\x1b\xb8\x95\x88\xc1\xce\x20\x66\xe9\x82\x58\xf9\x5b\x11\
\x83\x1d\x67\x90\xe2\x7b\x8b\x73\xb0\xf7\x9e\xe5\x3b\x1a\x99\x27\
\xae\x42\x5a\xd6\xa4\xc2\x23\x40\x8c\x58\x29\x62\x2e\xfb\x12\x31\
\xa5\x15\x48\xd3\xd9\x8a\x9a\x1a\x57\xb7\x47\x75\x40\x1a\xb1\x9d\
\xd6\xc6\x22\x6a\x33\xda\x0e\xe9\x58\x79\x69\xc4\x98\x14\x21\x8d\
\xdc\xc5\x48\xc3\x16\x5a\x5e\x3d\x91\x36\x6a\x87\xd5\x27\x8b\x84\
\x89\x27\x20\xc6\xfb\x42\xc4\xac\x93\xa7\xac\x76\x88\xd8\x5f\x8f\
\x34\xc2\x2d\xa9\xbd\x47\xba\x36\xcc\xb0\xf2\xae\x40\x26\x9e\xfd\
\xa8\xcd\x58\x26\xdb\x1e\x22\xed\xe2\xd5\xc0\x18\xa4\x9d\x9b\x96\
\x68\x67\xbc\x6e\xf1\x3d\x3a\x65\xfd\xb6\xd5\xfa\xbc\x2f\x62\x96\
\x9c\xc5\xd0\x50\x24\xf0\x4c\x23\x06\xcb\x99\xca\x5e\x84\x98\x92\
\x77\x13\x79\x07\x1c\x1c\xa1\xe8\x56\xc4\xf4\x34\xc4\x61\x96\xeb\
\xab\x4c\x2c\x7d\xca\xf2\x08\xd0\x78\xbb\x7b\xef\x21\x35\x99\xa8\
\xf8\x78\xc6\xdb\x55\x80\x18\xb3\x9d\xc8\x44\xf8\x42\x64\x16\xfd\
\x56\x8e\xf7\x52\xd6\xa7\x2d\xd1\xbc\x6f\x81\xe6\x97\x3b\x57\xe3\
\xe3\xf2\x3e\xd1\x1c\x5b\x86\xd6\xcc\xa8\x44\x3b\x93\x73\x3a\x8d\
\xd6\xd8\x0c\xa4\x4d\x76\x56\x5d\xc7\xa0\x35\xd6\xda\xda\x77\x09\
\xd2\x34\xc7\xcf\xe9\x80\xc8\x92\xe2\x52\x64\x35\x56\x82\x2c\x1b\
\x0a\x62\xf9\x5e\x81\xd6\xee\x0d\x88\x96\x78\x0d\xad\xc3\xab\xec\
\xbd\xe3\xa9\x29\x38\x9a\x8a\xd6\xc7\x18\xb4\x4f\x9c\x80\x68\x8b\
\x4f\xd9\x7b\xf1\x39\x9d\x5c\x07\x8e\xbe\x68\x85\xb4\xbc\xfd\xad\
\x7f\x0b\xd0\x1a\xbd\x04\xed\x3f\x57\xa3\xfd\xcd\xbd\xff\x21\xda\
\xd7\x3a\x10\xed\x7f\x7d\x91\x36\x39\x65\x63\x35\xc3\xea\x3c\x0a\
\x59\xc7\xb4\x43\xeb\xe5\x1a\x9a\xa8\x25\x5b\xba\x47\xeb\xa2\xbb\
\xaf\x19\xde\xae\xb8\x65\x91\xe7\x89\x3d\x0e\x3c\x32\x59\x78\x61\
\x41\x69\xf9\xfc\x8d\xe5\x2f\xa1\x0d\xc4\x13\xf2\x1e\x4d\x19\x21\
\x22\x58\xb7\x23\xd3\xc9\xe4\x46\x99\xb2\xdf\x56\x12\x39\x0c\xd9\
\x84\xb4\x3d\x9b\xed\xb7\x0f\xed\xb7\x15\x96\x6e\x23\x32\x85\x4a\
\xa3\x3b\x82\x6b\xd1\x3a\x58\x6a\xe9\xd3\x48\x83\x34\x1f\x99\xe7\
\x0d\x42\x04\xd4\x2c\x44\x1c\x56\x21\xc2\x78\x97\x95\x17\x97\x7c\
\x7b\x78\x1c\xe9\x48\x23\x8d\xce\x7c\x1a\x77\x86\x04\x68\xfd\x6c\
\x47\x02\xa7\x75\x48\x90\xb5\x08\x11\x74\x83\xd1\x3a\x7c\x0a\xad\
\xbf\x10\xad\x5f\xa7\x59\x71\x6b\xbd\xd4\x3e\x53\x88\xd6\x66\x19\
\x5a\xb7\xee\x1e\xf0\x66\xc4\xec\x2e\x45\xcc\xe6\x5a\xc4\xd8\xf5\
\x44\x04\xe9\x14\xab\xd3\x46\x44\x48\xee\xb2\xf7\xb7\xa0\xfb\xb8\
\xce\xd9\xcc\x0a\xa4\x81\x4c\x5b\x7d\xd7\xc5\xda\xbf\xd4\xea\x38\
\xd0\xea\xf0\x2c\x91\x59\xab\x7b\x2f\x88\xb5\xa3\x13\x22\x60\x67\
\x21\xe6\x61\xa9\xe5\xd7\x05\xed\x59\x9b\x91\x09\xb6\x73\x6c\xb4\
\xdc\xfa\xbc\x07\x32\x3b\x7d\xcf\xfa\x60\x85\xf5\xd7\x52\x22\x0d\
\xb2\x2b\xc7\x39\xfe\x2b\x45\xfb\xe7\x6a\x44\x74\x97\x22\xc1\xc1\
\x72\x7b\xd6\xca\xea\xe7\x4c\x8c\x37\x22\x93\xd0\x0e\xd6\x47\x73\
\x89\x1c\x11\x6e\xb2\xfa\xc5\x85\x02\xab\x91\x69\x68\x4f\xb4\x47\
\x7e\x60\x6d\xda\x65\x69\x4b\xad\xcf\x4a\x11\x23\xb4\xda\xfa\xd7\
\x09\x32\x16\xdb\xb8\xc4\xb5\xc1\x6b\x6c\x1c\xab\x63\x6d\xdc\x86\
\x18\xf6\xc9\x88\x11\x49\x59\x5d\xdd\x1e\x9e\xb5\x7e\x70\x63\xbd\
\x1b\x31\x5b\x73\x90\xc6\xb2\x3d\xd2\x8e\xad\xb6\x32\x37\xda\xf3\
\x15\x36\x0f\xe7\x5b\xdd\x9d\xb9\xfa\x38\x22\x46\x64\x6b\x6c\xbc\
\xab\x88\x9c\x2d\xed\x2b\x9a\xa3\x75\x34\xc5\xfa\x21\xb9\x8e\x72\
\x69\xfc\xf2\x21\x85\xd6\x62\x7c\x3e\x3a\x0d\xec\x6a\xc4\x2c\xed\
\xb4\x39\xb3\xd2\xbe\x6f\xb4\x77\x76\x59\xfb\x9d\x40\x67\x99\xcd\
\x9d\x4a\x64\x2a\x3c\xd7\xfa\xbc\x13\x91\x03\xad\x14\x5a\x1b\xeb\
\xed\x7b\xa5\xe5\xbd\x09\xcd\xff\x5d\x48\x50\xb1\xce\xca\xd8\x10\
\x1b\x23\xe7\xc5\x7c\xba\xf5\xf7\xb1\x68\x3e\x3b\xc7\x6b\xae\xee\
\x15\x56\x2f\xc7\xbc\x2d\xb3\xb1\x4b\x5b\x19\xeb\x11\xb3\xea\xc6\
\x7f\xa0\x7d\x9f\x69\xef\x55\x58\x5b\x4b\xad\x5e\x2e\x0d\x68\x4f\
\xf9\xd0\xbe\x2f\x47\x73\x32\xb9\x76\xb7\xdb\x7c\x73\x0e\xd6\xda\
\xda\x5c\x58\x6b\xe5\xcc\xb5\x39\x31\xc4\xfe\x3e\x4b\x14\x9a\x6a\
\x76\x8e\x31\x5d\x65\xfd\x9e\x42\x6b\x7b\x26\x9a\xe3\x03\x6d\x2e\
\xbc\x62\x69\x46\x58\x7d\x9d\x23\xbf\x57\xac\x4e\x01\x62\x9a\x57\
\x5b\xd9\xab\xd1\xfe\xd0\xd1\xea\xb9\xc9\xfa\x68\x2e\x12\xec\xf4\
\xb3\x3e\x7e\x13\xed\x19\x83\x6c\xec\x9a\x0a\xad\x52\x82\x2c\x47\
\xc6\x05\x23\x7b\x96\x6c\x7b\xe0\xc6\xfe\x6d\xba\xb4\x2c\x20\x6c\
\x92\xbc\xba\xc7\x91\x84\x8a\xea\x90\xaf\x3c\xb3\x62\xdb\x13\x73\
\xb7\xde\x49\x74\xcf\xc7\xc3\xa3\xa9\x22\x03\x7c\x01\x1d\x5a\xcf\
\x50\x5b\x12\xef\xcc\x9a\x52\x89\x77\xe2\xa6\x78\xce\x24\x3a\x7e\
\x77\x38\xee\x9c\xc5\xfd\x1e\x27\x20\xdd\x6f\x75\xa5\x4d\x4a\xd6\
\x3d\x3c\x8e\x06\x14\xa1\x7b\xbc\x8f\x53\x93\x78\xdd\x57\xc4\xd7\
\x98\xd3\x7c\xe4\x7b\x16\x5f\xc3\xf1\xf5\x9a\xa5\xa6\xd6\xa5\xbe\
\xf7\xdd\x3b\x50\x53\xeb\x48\x3d\xe5\x07\x39\xbe\xc7\x11\x67\x8c\
\x52\x75\xa4\x4d\x96\xef\xd2\xc7\xdb\x12\xdf\xd7\x72\x85\x26\x8a\
\x33\x3c\xc9\x3d\x90\x44\x3e\xf1\x7d\x30\x4c\xbc\x1b\x4f\x9b\xeb\
\x7b\xb2\x8f\x72\x95\x95\xab\x3d\xc9\x3d\x32\x57\x3d\xe2\x79\x27\
\xeb\x1e\xef\xeb\x7c\xef\x24\xeb\x13\x4f\x1b\x2f\x3f\x57\xbf\xa5\
\x12\xcf\x42\x6a\x8e\x41\xbe\xb9\x91\xec\xa3\x7d\x81\xd3\x70\x7f\
\x0b\xf8\x39\x62\xac\x1a\x73\x8e\x24\xeb\x97\xec\xcb\x5c\x63\x1e\
\x7f\xb7\xae\xbe\xac\xaf\x3f\xea\x1a\xd7\x64\x59\x25\x48\x53\x79\
\x0a\xf0\x5b\x6b\xf7\xe9\x88\x69\x9d\x41\xcd\xf5\x99\x6b\xfe\x3b\
\xad\xb7\x43\x72\xbf\x48\x8e\x6d\xbc\x0e\x0d\x59\xd3\xf1\xba\xf7\
\x42\xce\x34\xa7\x58\xbd\xcf\x00\xfe\x0f\x31\xf7\xa9\x3c\xef\x38\
\x87\x61\xaf\x51\xf3\xfe\x78\x72\xbf\xaa\x6b\x1d\x7c\x01\x31\xc9\
\x93\x88\xae\x64\xc5\xc7\x20\xd9\xb7\xb9\xf6\x8b\x4c\x2c\x1d\x48\
\x73\xde\xc9\xf2\x6c\x0a\xf4\x4a\x68\xf5\xf9\x2c\xf0\x35\x7f\x47\
\xd8\xc3\xc3\xc3\x63\xdf\x91\xeb\xb0\x4d\x27\x7e\x87\xda\x66\x5c\
\x49\xe4\xba\xf7\x57\x5f\xda\xa6\x70\xa0\x78\x78\x1c\xee\xa8\x6f\
\x3d\xe6\x7a\x96\x5c\xaf\xe9\xbd\x7c\x3f\xd7\x3b\x0d\x5d\xf7\xf9\
\x7e\x87\xdc\x26\xb3\xb9\xd2\xe6\x33\xaf\x8d\x3f\xcf\x57\x9f\x7c\
\xef\xe5\x2b\x37\x9f\x19\x6c\xbe\x7a\xe7\xfb\x9e\xcc\xab\xa1\xed\
\xc9\xf5\x6e\x7d\x4c\x64\xae\xbe\xce\xd7\x8f\x41\x1d\x69\xe3\xbf\
\xd5\x37\x36\x71\x46\xb1\xae\xb9\xd1\x90\xfa\x1f\x6c\xd4\x75\x16\
\x35\xe4\x7e\xb1\xfb\x9b\xab\x2f\xeb\xeb\x8f\x86\x8e\xab\xbb\xf3\
\xda\x06\x59\x59\x6c\xb2\xf4\xf3\x88\xee\x79\xe7\xca\x33\x99\x6f\
\x43\xd7\x58\x6a\x2f\xd3\x24\x7f\xff\x10\x79\x41\x3f\x1e\x69\xbc\
\xff\x8a\x34\xdb\xe9\x3a\xde\xd9\x85\x9c\x62\x39\xeb\x8f\x5c\xe9\
\xea\xeb\xaf\xf7\x90\xb6\xbb\x90\xba\xe7\x64\xb2\x3f\xea\x9a\xeb\
\x2b\x91\x85\x44\x93\xa4\x59\x3c\x23\xec\xe1\xe1\xe1\xe1\xe1\xe1\
\xe1\xe1\xe1\xe1\x71\xa4\x22\x40\x66\xca\x0f\x51\xd3\x0a\x20\x19\
\x3e\xa9\xa9\x20\x44\xa6\xc5\xef\xc5\xea\x5f\x9f\x50\xc1\x39\xc5\
\x6a\x4c\x7b\xde\x61\xff\x5b\x9a\x39\xe7\x5a\x4d\x12\x9e\x11\xf6\
\xf0\xf0\xf0\x68\x1c\xe2\x66\x91\xee\x3e\x5d\xbe\x4d\xbf\x2e\x13\
\x32\x0f\x0f\x8f\x83\x8f\xa4\xe7\xe2\xfd\x89\x7c\xe6\xd4\xf9\xea\
\xc1\x01\xac\x8b\x43\x3e\x53\xdd\x7c\x75\x8a\x9b\x8b\x1e\xaa\x3a\
\x7b\x78\xc4\xd1\x98\x79\x57\x9f\xb6\xbd\x29\xd5\x7f\x5f\x34\xff\
\x8d\x69\x4f\x63\x4d\xee\x0f\x44\x9d\x0e\x38\x9a\x9a\x79\x85\x87\
\x87\x87\xc7\xe1\x84\x14\xba\x63\x74\x27\x70\x37\xf0\x31\x74\xf7\
\x24\x1f\xd1\xd8\xda\xd2\x17\xe6\xf9\xbd\x15\xf0\x09\x64\xbe\x95\
\xcc\x23\x8b\x62\x6b\x5e\x89\xdf\xbb\x3d\x3c\xf6\x07\xdc\x5d\xb1\
\x0b\xd8\xff\x8a\x81\x66\xc8\xfb\xea\x37\xec\x73\x35\xba\xeb\x97\
\x6f\x6f\xe8\x40\x14\xba\x24\x89\x2c\x72\x38\x74\x1d\xf9\xf7\x8e\
\x73\xd0\xfd\xc0\x6c\x1d\xbf\xff\x10\xf8\x77\xe0\xdb\xc0\x27\x91\
\x23\x9e\x7c\xde\x61\x42\x14\xb3\xf5\xdf\xac\x5e\xd9\x1c\xbf\x77\
\x47\xde\x6a\x9d\xa7\xe3\x9e\xc8\x7b\xee\xf1\xc8\x11\xcd\x59\xb1\
\xf7\x5c\xbc\xe3\x8f\xa0\x7d\x70\x6f\xbc\xd2\x64\xad\xac\x6f\x20\
\xe7\x40\xd9\x06\xbc\xe3\xfa\xf4\x3a\xa2\x30\x74\x75\xa5\x6d\x8f\
\x3c\xdb\x36\xdb\x8b\x7a\x79\xd4\x44\x16\x8d\xcf\x98\x03\x58\x46\
\x88\x1c\x34\x9d\x4e\xfe\x3b\xc9\xbd\x80\x9b\xc9\xbd\x56\xf2\xa1\
\x08\xad\xd1\x2e\xec\x3f\xef\xc6\x69\xe4\x05\x3a\x4e\x13\xc4\xe9\
\x80\x02\xb4\x46\x4e\xa4\xfe\x39\x9d\x45\x5e\xb3\xcf\xac\xa7\x7e\
\x6e\x9d\x5d\x4f\x6e\x3a\xa2\xae\xf6\x9f\x81\x3c\x6e\x1f\x83\xbc\
\x46\x37\xb6\x1f\x5c\x68\xa7\x1b\xa8\xe9\xc9\x3a\x83\x3c\x49\xbb\
\xf8\xcf\x87\x14\x9e\x98\xf2\xf0\xf0\xf0\xd8\x37\x64\x51\xe8\x8b\
\x1b\x90\x09\xd3\x33\x88\xf0\xfa\x24\x51\xfc\x3d\xa7\x6d\xca\x12\
\x11\xb3\x97\x52\xd3\x01\x45\x5c\x43\xd3\x0c\x11\x90\xc5\x44\x4e\
\x2d\xe2\xef\x77\x26\x8a\x75\xea\xe1\xe1\xd1\x38\x04\x88\x09\x76\
\x31\x3f\xe3\xc4\x68\x3e\x86\x32\xd7\xf7\x24\x1c\xd1\x7a\x2e\x30\
\x1e\x78\x15\xad\xeb\xab\xa8\xed\xfc\xc7\x85\xd1\x39\x06\x31\x91\
\x49\xe7\x3b\x2e\x7d\x3b\xc4\x60\xa6\x72\xbc\x1f\x22\x2f\xad\x7d\
\xc9\xcf\x68\xf7\x47\x66\xa0\x8f\x01\xcf\x23\x02\xf5\x4b\x88\x28\
\x77\xfb\x4b\xbc\xbc\x02\xeb\x9b\xe5\xc8\xbb\x6e\xb2\x7d\x59\xe0\
\x54\x44\xd0\x87\xc8\x73\x6d\x25\xda\x13\x5d\x28\xa4\x1d\xb1\xf4\
\x01\x22\xb6\x8f\x41\xfb\x5c\x7c\x7f\x73\xdf\xeb\xc2\x69\xd6\xfe\
\xd1\xd4\x8e\x87\x9a\x6b\xcc\x5c\xcc\xe0\xad\xb1\xfa\xc6\xfb\xcc\
\xa5\x71\xef\x37\x47\x1e\x84\x0b\xa8\xed\xc4\x2a\xce\xc4\x04\x39\
\xca\x4a\x96\x9b\xfc\x9e\xab\xec\x23\x09\xf1\x3e\xea\x80\x3c\x04\
\x27\xfb\x25\xd9\x47\x41\xec\x7b\x3c\x4d\x98\x78\x9e\x1c\x0b\x77\
\xee\x5e\x94\x28\x3b\xfe\x7b\x5b\xc4\x5c\xe6\x5a\x2b\xb9\xde\x71\
\xef\x6d\x23\x8a\x53\x5c\xd7\xdc\x4c\x9e\xcd\xc9\x3a\xbb\x7a\xa7\
\xd0\x9c\x6d\x11\xfb\x3d\x8b\xd6\xea\x95\xf6\x7e\x5f\xb4\x5e\xea\
\x6a\xb7\x2b\xa3\x3f\xd1\x1a\xaf\x6b\xde\x67\xd0\xbc\xcf\xd0\xb0\
\x75\xe6\xe2\xa8\xdf\x80\xd6\x41\x67\x14\x23\x3c\xcc\x91\x7f\x1c\
\xf1\x31\x8c\xf7\x7f\xbc\xac\x0c\xf2\xf0\x9d\xec\xa7\x5e\xe4\xdf\
\xaf\x0e\x2a\xbc\x69\xb4\x87\x87\x87\xc7\xbe\xc1\x69\x93\x40\xa1\
\x41\x36\x20\x87\x10\x83\x89\x98\xde\x8b\x10\xc1\xb9\x14\x11\xc3\
\xa7\x22\x42\x70\x34\xf2\x06\x39\x86\x28\x9e\xe6\x04\x14\x1a\xc1\
\x1d\x5e\xdd\x10\xd3\xdc\x06\x39\xce\x78\x81\x9a\x04\x9d\x87\x87\
\xc7\xbe\x23\x24\x0a\xeb\xf1\x32\x22\xde\x4e\x44\x1a\x9a\x00\xdd\
\x95\x9b\x46\x4d\xe2\x6d\x00\x5a\xd3\x59\xc4\xe4\xad\x00\xde\x20\
\xb7\x52\xa1\x3b\x22\x46\x17\xa0\x30\x3c\xab\xd0\x7e\x91\x42\x5a\
\xd4\xb3\xed\xfb\x2c\x14\x2b\xf6\x14\x14\xd6\xe5\x54\xcb\xf7\x02\
\xa4\xa5\x2c\x27\x0a\x8d\xe2\xb4\x27\xc3\x50\xac\xe3\x66\x88\x49\
\x1d\x4f\xfd\x7b\x43\x16\xed\x23\xce\xd3\xf6\x22\xa4\x21\x3e\x0e\
\xdd\x43\xbc\xd8\xda\x57\x86\xc2\xf6\x74\xb6\xdf\x8a\xad\x2f\x06\
\x5a\xdf\x84\x28\x94\xd1\x02\xab\x73\x77\xfb\xbd\x84\x48\x00\x98\
\x45\x04\x75\xb1\x3d\xbb\x00\xed\x7b\x3b\x2d\x9d\x63\xec\x2f\x41\
\xfb\xdc\x5a\x1b\x03\x17\x77\x36\x39\x4e\x2d\x51\x58\x97\x7f\x21\
\xe1\x42\x77\xe4\x80\xe7\x0c\x14\xd2\xa5\xbd\xa5\x9d\x85\xe2\xb5\
\xb6\x40\x0e\x91\x76\x20\x4d\x54\x60\xcf\x47\x5b\x7d\xe6\xa2\x50\
\x3c\x69\xab\x43\x3f\xe4\x65\xb7\xd0\xca\x3b\x0e\x69\xab\x5a\x22\
\xc7\x41\xcf\x20\xe6\xeb\x04\x7b\xe7\x0d\xeb\xfb\xb3\x2d\xef\xe9\
\x28\xa4\xd2\xa9\x36\x9f\x8a\xad\xfd\x2f\xa1\x50\x7a\x43\x90\x86\
\xad\x19\x8a\x96\xf1\x06\x62\xb8\x8e\x04\x38\x0d\xed\x95\xd6\xef\
\x2d\xd0\x38\x83\xd6\xd3\xd9\xf6\x7d\x1a\x0a\x9f\x73\xa9\xa5\x4f\
\x5b\xbf\x0d\xb5\x7e\x6f\x6f\xff\x77\x47\x96\x05\x13\xed\x9d\x13\
\x91\x10\xa4\x04\x85\xfb\x19\x87\xe6\xdd\x70\x34\x46\xf3\x2c\xcf\
\x2e\xe8\x0c\x76\xe7\xa4\x3b\x47\x87\x5a\xdf\x17\xd9\x58\x8c\xb7\
\xb2\x2f\x45\xcc\xd8\x5a\x1b\x97\x27\xd1\x78\xa7\x10\x53\x78\x29\
\x9a\x9b\xeb\x81\x17\x89\xe6\x66\x88\xce\xf6\x31\x96\x7e\x89\xd5\
\xa9\xaf\xd5\xb3\xd0\xfa\xe0\x55\x2b\x2f\x65\xe5\xb7\x44\x61\x8b\
\x5e\x40\x42\xb1\xa1\x68\x2e\x63\x6d\xe9\x6a\xf5\x78\x01\x85\x21\
\x3a\x19\xcd\xa7\x16\x44\x21\x95\x5c\xbb\x7a\x21\xef\xd7\x05\x56\
\xd7\xe9\xf6\xac\x9b\xb5\x6f\x01\xd1\xbc\xef\x62\x6d\x69\x8f\xf6\
\x95\x97\xc9\x7d\x67\xf7\x44\xb4\xc6\xc7\x20\x47\x62\xbd\x80\xdb\
\xd0\x3a\x9d\x60\xfd\x70\x11\xf2\xd6\xbf\x03\xad\xe9\x4a\x14\xea\
\xab\xc8\xea\x35\x0e\xad\xc9\x7e\x68\x1f\x79\xc5\xda\xec\xea\xd2\
\x07\xb8\x8c\xc8\x9a\x24\x29\x60\x3b\x24\xf0\x1a\x61\x0f\x0f\x0f\
\x8f\x7d\x43\x0a\x85\x5c\x58\x05\x7c\x17\xf8\x1e\x70\x39\x3a\xb4\
\x9a\x03\x9f\x46\x87\xc0\x73\x48\xd3\x70\x09\x3a\xa0\x56\xa1\xf0\
\x04\x2e\x7e\xe1\x53\x88\x40\xbd\x81\x48\x53\xd2\x0c\x69\x96\xab\
\xed\xfd\x5e\xc0\xb5\x78\x4d\xb0\x87\xc7\xfe\x82\xd3\x2c\xed\x40\
\x44\x6e\x7f\x64\x4e\x39\x0d\xc5\xbe\xfc\x08\x91\x50\xcb\x31\x63\
\x1f\x47\xc4\xf8\x14\xc4\x14\x0e\x24\xb7\x46\x23\x40\x21\x4c\x5a\
\x02\x3f\x42\xe6\xc8\xa7\x20\x02\xb7\x27\xba\x42\x31\x0b\x31\x63\
\x97\xa1\xbd\x60\x21\x22\x54\x17\x22\x2d\xeb\x0e\xe0\x09\xb4\x17\
\x5c\x41\xa4\x61\xe9\x04\x7c\x0a\x09\xd7\xc6\x21\x62\xfa\x1c\x1a\
\x26\x20\x73\x0e\x77\xd2\xc8\xc3\xec\x3a\xb4\xb7\xb8\x3a\x3c\x87\
\xb4\x37\xb7\x23\xa6\x62\xb1\xb5\xb5\x0d\x70\x13\x62\x78\xdf\x42\
\x7b\x51\x37\xab\xeb\x02\xab\xcb\x09\x88\x28\x77\xf5\xec\x85\x88\
\xe4\x93\x10\xd1\x3e\xce\xf2\x6e\x6f\x75\xb8\x09\x69\xa3\x9f\x26\
\x32\x9f\xcc\x67\x16\xee\x98\xa5\x57\x51\xc8\x9b\xd3\xec\x79\x1f\
\xeb\xab\xd7\x11\xa3\x74\x93\xd5\x2f\x83\x18\xfb\x12\xc4\xd4\xf6\
\x40\x44\xfd\x02\xcb\xe3\x02\x7b\x6f\xb4\xfd\xfe\x02\x0a\xa1\xd3\
\x12\x31\xb1\xe7\x20\x22\xfd\x19\xeb\x97\x93\xad\xac\x93\xad\xac\
\x66\x36\x86\xef\x21\xa6\xf6\x23\x96\x4f\x6f\x4b\xf3\x26\xda\xfb\
\xaf\xb3\x7e\xba\xcd\xfa\xd2\x8d\x57\x2e\x53\xf3\xc3\x15\x69\xe0\
\x46\xc4\x0c\x8d\x43\x8c\x5b\x91\xf5\xd7\x47\xad\x8f\x26\x23\x6b\
\x88\x21\x88\xe1\xea\x66\xe3\x10\xa0\x73\xd1\xcd\xfd\xcf\xa2\xf3\
\x71\xbe\xf5\x69\x27\xc4\xec\xce\x42\x73\xf3\x54\x1b\x8f\x05\x96\
\xfe\x03\xe0\x16\xa2\x79\xd4\xc2\xc6\xa5\x80\x88\x41\xff\x14\x5a\
\x77\xe3\xd0\x9a\x3d\x07\xb8\x10\x09\x2c\x5e\xb0\x77\x47\x5b\x9d\
\x87\xa3\xb9\x7e\x1d\x9a\xa7\xcf\xa2\xb3\x7c\x04\xd1\xbc\x6e\x85\
\xce\xf6\x4d\xc8\xb2\xe2\x78\x6b\x43\x67\x34\xcf\x67\x5a\xfd\x3f\
\x81\xb4\xe3\x4e\x18\xf4\x82\xb5\x7f\xa4\xb5\x77\x35\x12\x8a\x14\
\xd8\xbb\x6f\x20\x06\xf5\x7a\xab\xd3\x19\x88\xbe\x78\xde\xbe\x1f\
\x4f\xc4\xdc\xb7\x43\x0c\xeb\x3c\xc4\xc8\xdf\x6e\x6d\x5c\x44\x74\
\xf5\xe0\x78\xab\xeb\xad\xf6\xde\x73\x88\xd9\x1e\x42\xee\x3d\xcb\
\xc5\x11\x9f\x6e\xe9\xbb\xa3\xf8\xc6\x0b\x6d\x1c\x9d\xd9\xfb\x60\
\xeb\xe7\x73\xd1\x1e\x75\x96\xf5\xdd\x04\xeb\xd7\x61\x56\x56\x99\
\xf5\x53\x7b\xab\x4b\x5b\x1b\x9b\x4d\x28\x8c\x52\x3b\x9a\x08\x3d\
\xe3\x35\xc2\x1e\x1e\x1e\x1e\xfb\x86\x00\x69\x11\xfe\x88\x0e\xf6\
\x41\xe8\x90\x3b\x81\xe8\x50\x1e\x87\x88\xec\x57\x91\x34\x75\x05\
\x3a\x20\x36\x23\x42\x14\x74\x48\xf4\x45\x87\x7e\xfc\x00\xef\x06\
\xfc\x05\x1d\x74\x45\x88\x08\xdf\x70\xa8\x1b\xed\xe1\x71\x84\x20\
\x44\x84\x61\x19\x12\x38\x0d\x46\xc4\xdf\xf1\xf6\x7b\x3b\xc4\xd8\
\xcc\xb3\xff\x7b\xa0\xf5\xf9\x1a\xf2\x3e\x3b\x91\xfc\xf7\x49\x03\
\xb4\x56\x7f\x66\x79\x0c\x41\xcc\x57\x5f\x64\x6a\xbc\x05\x11\x83\
\xd5\x88\x70\x3c\xc1\xca\x29\xb3\xdf\x26\x23\xe6\xef\x24\xa4\xd1\
\xd9\x41\x64\xb2\xdb\x0f\x31\x6d\xe3\xd1\x1e\xe2\x18\xb4\xf5\xec\
\xfd\x7d\x3b\x17\x27\xf4\x18\xcb\x6f\x2e\x62\xf4\x4f\x43\xc4\xf4\
\x56\x24\xa4\xeb\x87\x88\xf5\x11\xf6\x9e\xdb\x9f\xb6\x22\x42\xbf\
\x8c\x9a\x66\x97\x71\x73\xce\x61\x88\x91\x99\x89\xf6\xb2\xa1\x44\
\x84\xfa\x1a\xa4\x2d\xeb\x84\x08\xe5\x62\xb4\xa7\x26\xeb\x78\xb6\
\xb5\x7f\xa4\xe5\x3d\x0a\x31\x08\x59\xc4\x2c\xcc\x42\x0c\x52\x95\
\xfd\xdf\xc5\xea\x1a\x58\x1f\x0f\xb4\xbe\x9a\x80\xb4\x58\x03\xac\
\x6f\x8b\x10\x73\x3f\xdb\xca\xed\x65\xbf\xbf\x82\x04\x23\x27\xda\
\x3c\x70\x1a\xe7\x79\x56\xd6\x35\x88\x91\x99\x6c\x7d\x7e\x82\xb5\
\x67\x37\xd2\x7a\xce\xb6\xf4\x43\xd0\xb9\xd0\xcb\xe6\x57\x3f\x6b\
\xe7\x00\xc4\x2c\x1f\xee\x70\xf7\x51\x7b\x03\x7f\xb6\xfe\x99\x80\
\xc6\x7c\x30\x5a\x33\xc7\x5b\xba\x36\x68\xfe\xef\xb6\x3e\x5c\x88\
\xe6\xed\x72\x1b\x83\xe1\x88\x09\x9e\x8a\xe6\xd6\xd9\x44\x5a\xc6\
\xfe\x56\x46\x5b\xcb\x67\x0b\xd1\xba\xed\x07\xfc\xda\xf2\xab\x00\
\xbe\x82\xc6\x2c\x63\xbf\x65\x89\xe2\xea\x4e\x22\x32\xe5\x1f\x8f\
\xac\x23\xca\xad\xae\xce\xd9\x65\x0b\x7b\xef\xef\x88\xe1\x5e\x8e\
\x04\x34\xce\xcc\xba\x07\x62\x8e\xc7\x21\x53\x6a\x27\x58\x79\x07\
\x31\xfd\x53\x11\xe3\x7b\xae\xb5\x77\x07\xda\x2b\xe6\x21\x61\x48\
\x7b\xb4\x0e\x76\x20\x3a\x20\x83\x84\x37\xb3\xd0\xfc\xbf\x09\xcd\
\xe3\x57\x88\xae\x3b\xb4\xb1\x36\x39\xa4\x10\xe3\xfa\xae\xa5\x3d\
\xce\xca\xed\x83\xd6\x6e\x91\xf5\x4d\x3b\xb4\xc7\x3d\x8c\xd6\xf1\
\xf2\xd8\xfb\x49\x94\xa2\x35\xb2\x81\x88\x09\x9e\x66\xed\x1d\x63\
\xf9\x4d\xb7\x31\xcb\x5a\xbf\x2d\xb6\x77\xde\xb5\xfc\x87\xa0\x75\
\x39\x0f\x31\xd5\x27\xd9\xfb\x55\xd6\xee\x0e\x36\x16\xeb\x91\x80\
\xcd\x33\xc2\x1e\x1e\x1e\x1e\x87\x31\x42\xa4\x49\x09\x90\xc9\xde\
\x7c\x74\x70\x7c\x07\x1d\x5c\x2e\xf6\x5e\x48\x64\x3a\x14\xc7\x15\
\x88\x20\x9a\x82\xa4\xb9\x7d\x63\xbf\xb9\xb4\x85\xb1\xf7\xe3\x77\
\x6c\x3c\x3c\x3c\x1a\x8f\xb8\x79\x6a\x88\x08\xb4\x49\x68\xad\xcd\
\x41\xeb\x32\x45\x74\xd7\xad\x80\xc8\xeb\x6c\x11\xf9\x09\xb9\x34\
\xf0\x19\x44\x9c\x4e\x46\x4c\xe0\x62\xa4\x11\x59\x63\xf9\xa4\x62\
\xf9\x54\xc5\xf2\x2a\x40\x42\xaf\x2a\x44\x58\xaf\x24\x62\xc4\x5c\
\x9d\x1d\x03\x0b\x62\xc6\xdd\xbd\xc6\xfa\x90\x8d\xa5\xed\x84\x18\
\x8e\x09\x88\x80\x2e\xb2\xe7\xae\x8d\x71\x0f\xf8\x21\x22\xde\x27\
\xd9\xf7\xb9\x88\x49\x38\x87\xfa\xef\xf7\x66\x88\x04\x06\xae\xde\
\x21\x62\x5a\x66\x20\x2d\x56\x89\x95\x5b\x99\x78\x37\x24\xf2\x8b\
\xb0\x18\x31\xd1\xdb\x11\xd3\x7b\x8c\xe5\xed\x62\xc0\x3a\xa6\xd7\
\x69\xbd\xe3\x75\x72\x7d\xe6\x9e\x3b\x46\x21\x45\x64\x85\x93\xb6\
\x77\x3b\x21\x4d\xd6\x42\xab\xdb\xc6\xd8\x58\xb9\xd0\x34\x19\xa2\
\x38\xab\xee\xee\x73\xb9\xa5\x29\x8f\x3d\x77\x7d\xee\x84\x1b\xbb\
\x10\x93\xbc\x81\x23\xc7\x22\xd3\x9d\x4b\xf1\xf9\xe3\xfa\x79\x1d\
\x9a\x33\x19\xb4\x9e\x56\xa0\x71\xab\x24\x9a\xbf\xee\x6e\x7e\x8a\
\x68\x1d\x38\xa6\xb3\x0b\xd2\xa6\xcf\x41\x26\xc8\x9b\x12\x7d\xeb\
\x34\xa4\x85\xb1\xbf\xae\x4e\x50\x73\xad\x38\x4b\xab\x2a\xfb\x3f\
\x59\x5f\x07\x37\x6f\x0a\x2d\xff\x9e\x68\xfd\xcd\x88\x95\x99\x4a\
\xe4\xe9\xfa\x20\x1e\x47\xda\xad\xa1\x2c\x9a\xeb\xb9\x62\x46\xbb\
\xfc\xe2\x73\xd8\x39\x86\xbb\x1d\x31\xa3\xcb\xd0\xfc\x49\xee\x35\
\x15\xb1\x32\xab\x63\xe5\x26\xef\x2f\x07\x44\x42\xb4\x01\x44\xb1\
\x93\x93\xf9\xc5\xef\xfb\x86\x48\x70\x90\x8a\x3d\x0f\x10\x7d\x73\
\x3b\x12\x48\xbc\x6f\xf5\x76\x7b\x8a\x2b\x2f\xd9\xaf\x8e\x96\x71\
\x75\x71\x63\x54\x40\x13\x70\x94\xe5\x2a\xe2\xe1\xe1\xe1\xe1\xb1\
\xf7\x08\xd1\xc1\xfe\x69\xa4\xe1\x58\x8b\x24\xa2\x1b\xd1\xa1\x79\
\x22\x32\x19\x9b\x8f\x4c\xa7\x26\x21\xa9\x6b\x5b\xa4\x25\x68\x8f\
\x88\xba\x52\xa4\x51\x68\x8e\x0e\x8e\x02\x24\x29\x5e\x88\xcc\x05\
\xa7\x21\x89\xec\x7b\x44\x07\xa6\x87\x87\x47\xe3\x10\x20\xa6\xd4\
\x99\xf6\xcd\x45\x26\x92\x43\x90\xb6\x66\x14\xf0\x37\x64\xd2\xdc\
\x1f\x99\x49\x6e\x44\x66\x93\xcb\xec\xf7\x37\x90\xd0\xeb\x16\x64\
\x05\xb2\x8e\x88\x21\x5b\x89\x18\xdf\x3e\x96\xdf\x29\x88\x79\x9c\
\x8a\xb4\x36\xd7\x12\xad\xfd\xbf\x20\x4d\x54\x7b\x2b\xab\x3d\x22\
\xfe\xab\x89\x9c\x5c\x39\x82\x76\x09\x22\xe6\xaf\xb7\xfa\x9f\x81\
\x4c\xa8\x9d\x56\xab\x2d\xd2\x2a\x3d\x8d\x18\x2e\x47\xc8\xa6\x90\
\xa6\xee\x62\x44\xbc\x8f\xb4\x3a\xbe\x6f\xe5\x5d\x80\x08\xd3\xa1\
\x88\xe1\x58\x4d\x44\xcc\xce\xb6\xbe\x19\x84\x08\xe4\xb3\xed\xdd\
\x9d\x48\xf3\xda\x3d\x51\x8e\x63\x66\x52\x68\xdf\xba\x0d\xdd\x53\
\xec\x87\xb4\xa3\x65\x48\xbb\x74\x3c\x22\xf2\x47\x22\xed\xf2\x42\
\xab\xfb\x4b\x48\x3b\x18\xda\x6f\x1b\x81\x5f\x22\xe2\xdf\xf5\xef\
\x85\x68\xff\x25\x56\xae\xdb\x1b\xe3\x31\x57\x0b\x2c\xdf\x73\xad\
\xcf\x36\x58\xff\x3f\x82\x88\xf2\x2b\xad\x3e\x27\x5a\x3f\x14\x21\
\x13\xe9\x35\x68\x4f\xee\x69\x63\x11\x0f\x93\xe7\xfa\xe3\x23\x44\
\x1a\xc5\xdf\x13\x69\xa1\x5d\x1d\x0a\x6c\xae\x6c\x45\xcc\xfb\x0a\
\xa4\x01\x7f\x06\x69\xa9\xcf\x04\x1e\xa5\xb6\x00\xe0\x70\x41\x80\
\xe6\xc0\x2c\x64\xfa\xdc\x1e\x09\x87\xd7\x20\x66\xeb\x7c\x34\x9f\
\x4a\xad\xff\xe3\x31\x7c\x43\x6a\x8e\x13\xd4\x0c\x6d\x94\x42\x1a\
\x52\x77\x37\xb8\x25\x9a\x67\x29\x24\x50\xe8\x68\x1f\xa7\xa1\xef\
\x88\xd6\xf2\x42\xa4\xa9\x2d\x42\x5a\xd3\x9d\xe8\x1c\x5d\x65\x75\
\x78\xc2\x7e\x1b\x8d\xe6\xfb\x29\x44\x26\xfd\xee\xca\xc0\x2c\x24\
\xa8\x6e\x6b\x6d\x98\x4a\xc4\xc8\xad\x46\x02\xb3\x1b\xd1\x7a\xbe\
\x08\x09\x93\x2a\x90\xb6\xf4\x12\xab\xcb\x4e\x2b\xbf\x80\x9a\x6b\
\x23\x85\xe6\x4c\x2b\xc4\x98\xa6\xa9\x39\x67\x92\xed\x6e\x8d\xb4\
\xba\xee\x5d\x27\x08\x48\x27\xde\x71\x79\xa4\x63\xbf\x6f\x45\xc2\
\x9c\x6b\xd0\x3a\xbf\x08\xcd\x3d\xe7\x5f\xe0\xa5\xd8\x7b\x55\x96\
\xcf\x50\x6a\x0b\x07\x9c\x10\x69\x35\xda\xcb\x86\x02\x0f\x26\xca\
\xae\x44\x5a\xf1\x31\xd6\x97\xc3\x11\x1d\xb3\x1a\xad\xb3\x4d\x68\
\xef\xba\xde\xe6\xc6\x68\xa4\x95\x3f\xe4\x48\xf7\x68\x5d\x74\xf7\
\x35\xc3\xdb\x15\xb7\x2c\xf2\xb4\x95\xc7\x81\x47\x26\x0b\x2f\x2c\
\x28\x2d\x9f\xbf\xb1\xfc\x25\x6a\x1e\xd2\x1e\x1e\x4d\x11\x21\x3a\
\x28\xb7\xa3\x43\x2f\x29\xd5\x5d\x87\x34\x15\x5d\xed\xb3\x12\xdd\
\xf9\xdd\x6c\xe9\x3b\xa0\xc3\xfb\x2d\xa4\x11\x28\xb3\x77\x8b\xd0\
\x5d\xb3\x0e\x44\x87\xf9\x32\x44\x28\xed\xb6\x77\x67\xa3\xc3\xb2\
\x17\x3a\xc4\xc6\xa3\x83\xbb\xd4\xca\xf1\xf0\x38\x1a\xe1\x4c\x65\
\xe7\xd3\xb8\x33\x24\x40\x44\xef\xe9\x68\xbd\xad\x41\x84\x6b\x1f\
\xc4\xdc\xbe\x6e\xcf\xdb\x12\x31\x34\x5b\x88\x4c\x78\x0b\x10\x41\
\xbc\x00\x69\x56\x97\xa1\xb5\xeb\x08\xd5\xa5\xf6\x7b\x2f\x22\x8d\
\x92\xbb\x2a\xb1\xc4\xca\x69\x8d\x88\xd1\x79\x68\x5d\x17\x22\x26\
\x6f\x32\x32\x05\x2d\x46\x44\xf8\x1a\x44\xc8\xef\x40\xf7\x22\xe7\
\xa3\x7d\xa5\x23\x22\xc2\xa7\x5b\x99\xeb\xd1\xde\x73\x2e\x22\x80\
\xe3\xce\xa7\x1c\x93\xdc\x11\xed\x2b\xb3\x10\x73\xbf\x9b\x88\xa9\
\x1d\x84\x08\xd6\xa7\x88\xf6\xaa\x35\xf6\x71\x56\x2b\xad\x91\xa9\
\xe7\x62\xeb\x8f\x56\x88\xb0\x5f\x8f\xf6\xaf\x5d\x96\x7e\xab\xfd\
\x3e\xd7\x7e\x1b\x6c\xff\xcf\xb2\xf6\xcf\xb3\xb1\x1c\x60\xe9\x5f\
\x43\xc4\xf4\x39\x96\xcf\x26\xfb\xbd\x33\xda\xff\xd6\x10\x11\xff\
\x1b\xad\xff\x57\xa0\x3d\xd8\x69\x58\x37\x59\xba\x14\x62\x86\x56\
\x59\x9e\xae\xcf\x7a\x21\x73\xd1\x57\x2c\xcf\x0f\xad\xdf\x07\x11\
\x31\x6f\xb3\xac\xbe\x03\xac\x5d\x53\xad\x8c\x75\x96\xff\x87\xe8\
\x3c\x58\x82\x18\xfb\x12\x74\xff\xd3\x39\x46\xda\x68\xe9\x52\xd6\
\xb7\xf3\xac\xec\x6e\x48\xc3\xf9\xae\xcd\x85\x36\x88\x71\x9a\x4e\
\xa4\x69\x3e\x98\x68\x8e\xd6\xd1\x14\x1b\xb3\x7d\x2d\x3f\x24\x62\
\xf8\x7a\x59\x5f\x2f\xb0\x36\x2f\x25\x32\x69\x7e\xc3\x7e\x0b\x6c\
\x5c\xb6\x11\x31\xb5\x2b\x88\x98\xea\x65\x44\x16\x03\x33\x63\x63\
\xb1\x33\x36\x16\x0b\x89\x14\x79\x13\xd1\xbc\xe8\x87\xe6\xfc\x8b\
\x88\xa9\xdb\x15\xeb\xfb\xee\xe8\xac\x9d\x88\x04\x33\x3b\x88\xee\
\xc1\xee\x24\x9a\xd3\x55\x68\x2d\xcc\x45\x6b\xb1\x1f\x9a\x27\x6f\
\x10\x31\xee\x55\xd6\x0e\x67\x51\x31\x05\x99\xb9\xf7\x41\xcc\x7a\
\x19\x62\x9a\x9f\x44\xf3\x1d\x6b\x93\xd3\x0a\x6f\x40\x73\xc7\x69\
\xd1\x57\x59\x9b\x36\xc7\xfa\x63\x06\x9a\x43\x03\xd0\x5c\x9b\x8a\
\x04\xed\x1b\xad\x3f\x36\x5a\xbd\xe3\xfd\xb6\xdc\xf2\x2c\xb7\xf2\
\x2a\xad\xff\xe7\x58\xfb\x7a\x59\x5d\xa7\x22\xe1\x5a\x57\x34\xd7\
\xdd\x7e\x55\x61\xfd\xd2\x8e\x68\xfd\x7d\x48\xa4\xa9\x5f\x6c\xbf\
\x77\xb3\xb4\xaf\xc5\xe6\xcc\x92\x58\x7d\xca\xd1\x7a\xda\x88\xf6\
\x11\xd7\xd7\x4b\xac\x5f\x9d\x89\xb4\x33\x8f\x3f\x54\x7c\x40\x09\
\x5a\x7f\xe3\x82\x91\x3d\x4b\xb6\x3d\x70\x63\xff\x36\x5d\x5a\x16\
\x10\x7a\xa3\x3b\x8f\x03\x8c\x8a\xea\x90\xaf\x3c\xb3\x62\xdb\x13\
\x73\xb7\xde\x89\x08\x7d\x2f\x81\xf1\x68\xca\xc8\x00\x5f\x40\x07\
\xc2\x33\xd4\x94\x58\x3b\x24\x4d\x96\x9d\x84\x34\x19\x26\x25\x15\
\xcb\xd3\x1d\x3e\xf1\xdf\x89\xbd\x97\x4a\xbc\x0f\x91\x29\x56\xdc\
\x04\xcb\xc3\xe3\x68\x43\x11\xf0\x2d\xe4\xbd\xd4\x79\x40\xde\x57\
\x84\x48\x93\x95\x45\x0e\x5e\x92\xf7\x5c\xe3\xeb\xb0\x15\xf0\x79\
\x44\x6c\x6f\x43\x9a\xd5\x47\x88\xee\x83\xc6\x4d\x36\x1d\xf6\x66\
\x6f\x70\xcf\x52\x39\xea\x01\xf9\xf7\x86\x20\xf1\x4e\x09\x91\x96\
\xaa\x34\xf6\x7e\x72\x3f\x89\xd7\x27\x59\xd7\xb8\x99\x66\x7c\xaf\
\xca\xd7\x37\x71\x0d\x5f\x3c\x34\x0e\x75\xbc\x0b\x35\x4d\x23\x9d\
\x99\xf2\x85\x48\xb3\xb4\x89\x9a\x7b\x64\xd2\x7c\x35\x5e\x4e\x3c\
\x5c\x4b\x2a\xf1\x3d\x5e\xbf\x5c\xfb\x71\xae\xba\x25\x9f\xc5\xfb\
\xb0\xae\xf7\xc2\x3a\xea\x93\xdc\xeb\xdd\xfd\xd9\x57\x39\xf8\x26\
\xa2\x21\x62\x48\xbe\x05\xfc\x1c\x31\x2d\x8d\x61\x46\x92\x73\x2b\
\x5f\x3f\xba\x67\x71\x93\xfb\x5c\x63\x96\x1c\xbf\xe4\x58\x38\xf3\
\xf4\xe4\x39\x0a\xd1\xf8\xd4\xd5\xf7\x97\x21\x66\xed\x2d\xe4\x80\
\x6b\x07\xba\x13\x9c\x49\xe4\x1f\xaf\x77\xbe\xf6\xba\xf2\x2f\x40\
\xd6\x24\xbf\x8b\xd5\x23\xd7\x1a\xca\x55\x7f\x97\x4f\x7d\xed\x4e\
\xd6\xa1\xbe\x7e\xcb\xd7\xfe\x13\xd1\x3e\xfa\x6e\x22\xdf\x64\xa8\
\xaa\xf8\x3a\x2d\xb2\xf7\x2e\x43\xd6\x26\x33\x72\x8c\xa7\xcb\x23\
\xd7\x3e\x92\x8b\xa6\x49\xd1\xb8\x79\xb7\xaf\x70\x57\x43\x3e\x0b\
\x7c\xcd\x9b\x46\x7b\x78\x78\x78\x34\x0e\xf9\x08\xf1\xb8\xf9\x52\
\x1c\xe9\x3c\xdf\xe3\xef\xe5\x7b\x3f\xd7\x81\xe8\xe1\xe1\xb1\xef\
\x98\x88\x4c\x86\x9d\x36\x36\x09\xb7\x0e\x77\x21\x0d\xc7\xe9\x48\
\xc3\xf5\x2f\xa4\x71\xaa\x8b\x11\xdf\x9b\xbd\x21\x69\xee\x98\xef\
\xbd\xba\xde\x77\x26\x8a\xaf\x21\xe2\x3e\xc8\x93\x7f\x43\xeb\x9a\
\xaa\xe7\xf7\x5c\x75\x0e\xea\xc9\x27\x8e\x64\x7d\x32\xe8\x0a\x49\
\xbc\xee\xf9\xca\x0d\xea\x78\x16\xe4\x78\x3f\x5f\xfb\xeb\x6b\x77\
\xb2\x8c\xfa\xfa\x23\x5f\x7d\x92\x65\x6f\x41\x56\x07\x4d\xe2\x9e\
\x64\x23\xb1\xaf\x7d\x9b\x6f\xcc\x72\x8d\x5f\x12\xfb\x7a\x8e\x86\
\x48\x83\x1b\x20\xf3\xdd\x25\xf6\xbf\x63\xd6\xea\xca\xb3\xae\xf6\
\xae\x40\x5a\xd1\xe4\xf3\x7c\x6b\x28\x5f\x9d\xeb\x6b\x77\xae\xf6\
\xed\xed\xbc\x5f\x4c\x74\xcd\x20\x5f\x5d\xe3\xbf\xc5\xef\xcf\xbf\
\x41\x4d\x01\x64\xaa\x8e\x3c\x92\xcf\xea\xdb\x83\x0e\x09\x3c\x23\
\xec\xe1\xe1\xe1\xe1\xe1\xe1\x71\x34\x22\x40\xa6\x8c\x6f\xd3\x30\
\xcd\xf2\x12\x44\x44\xba\x77\x9b\xa2\x65\x46\x86\xe8\x4e\xf1\xe1\
\x86\xc3\xb9\xee\x7b\x0b\xe7\xec\xe8\x68\x68\x6b\x53\x42\x80\xe6\
\xd8\x73\xb1\x67\x8d\xd5\x4c\xa6\x90\x39\xf2\x52\x9a\xe6\x9e\x90\
\x44\x52\x48\xd6\x10\x54\x23\x8f\xd0\xae\xbd\x47\x0c\x3c\x23\xec\
\xe1\xe1\xe1\xb1\xff\xe1\x4c\x8b\x0e\x17\x24\xcd\x30\x3d\x3c\x8e\
\x16\xc4\x89\xba\xa4\xf7\xd7\xba\xd2\x36\x65\xe4\xd2\x96\x66\x39\
\x3c\xd6\xf7\xe1\x50\x47\xdf\xd6\x9a\x38\x90\xe7\x47\x52\x53\xbb\
\x3f\x70\x20\x34\x93\x4d\xc9\x5a\xab\x3e\x01\xcb\xbe\xd6\xf3\x70\
\xd9\xff\x7c\xa3\x3c\x3c\x3c\x3c\x0e\x02\x8a\x91\x37\xd4\xfe\xd4\
\xbc\xf7\x72\x39\xf2\x4a\x9a\xdd\x87\x3c\x73\xc1\x79\xb6\x3c\x97\
\xba\xcd\xe8\x42\xe4\x14\xe3\x93\xc8\x11\x4b\x43\x19\xf1\x10\xdd\
\x6d\x1a\xbc\x1f\xeb\xec\xe1\xd1\xd4\x91\x45\x73\xfe\xbb\x28\xe4\
\xd9\x77\x80\x2f\xa3\xf0\x2e\x07\x52\x88\xe5\x42\x02\xdd\xc8\xc1\
\x31\x13\xcc\x22\x0f\xc5\x67\x1d\xe0\x76\x79\x1c\x9d\x08\x91\x43\
\xac\xe3\xf6\xe2\x9d\x2c\xf2\x3c\x7c\x71\x9e\xfc\x3a\x23\xef\xec\
\x45\x28\x16\x6d\x57\x64\x96\x7b\x1d\x51\xf8\x9d\x83\x81\x2c\x72\
\x82\x75\x29\x07\x97\x5f\x6a\x81\x42\xa8\x75\x44\x77\xe6\x87\xd2\
\xf0\xb3\x39\x40\x7d\xd6\x19\xf5\xdb\x35\x78\xa5\x67\x9d\xf0\x8c\
\xb0\x87\x87\x87\xc7\xbe\xa1\x1c\x31\x9e\x67\xdb\xff\x21\x62\x40\
\x47\x11\x79\x8e\x8c\x3b\x90\x88\x23\xee\x7c\x25\xfe\x3d\x9e\xd6\
\x69\x71\xb2\xc8\xb1\x4a\x3f\x6a\x3b\xb3\x08\x13\x65\x34\x43\x87\
\x60\x32\xb6\x61\xdc\xf9\x4e\x98\xc8\x3f\x40\x8e\x3e\x86\xe2\x09\
\x65\x8f\xa3\x07\x8e\xe0\x6e\x89\x42\xaa\x3c\x81\x9c\x06\x7d\x11\
\xad\xb5\xf8\xfa\x4a\x3a\xb6\x8b\x3b\x84\x09\x13\x79\x92\x23\x2d\
\xd4\x5c\x83\x2d\x10\xe3\x90\x74\x06\x95\x5c\xa7\x41\x1d\xf9\x25\
\xd3\xd4\xb5\xbe\x37\x22\xa7\x40\x3d\xf1\x6b\xdc\x63\xff\x22\x8b\
\xc2\x40\x9d\x4c\x34\x7f\xe3\x71\x6c\xe3\x4e\xd4\x20\x3a\x93\xca\
\x91\xd3\x39\x97\x07\xb1\x77\xaa\x88\xbc\x28\x5f\x8b\xbc\x3b\x57\
\xa2\x7b\xd5\xb9\x1c\x55\x91\x28\x37\x57\x6c\xeb\x5c\x4e\xa5\x92\
\xef\xe5\xca\xab\x0d\x51\x68\xb2\x64\xbb\x73\x9d\xdd\xb9\xce\xfc\
\x78\xbd\xb2\xd4\xae\x63\x72\xad\x17\xa2\x73\xbc\xc4\xfa\x68\x77\
\x8e\x7c\xe2\x9f\xb8\x03\xb7\x62\xe4\x00\xb0\x0b\x32\xbf\xaf\xab\
\xcf\xe2\x75\xcf\xd7\x8e\x23\x7e\xbf\xf0\x52\x02\x0f\x0f\x0f\x8f\
\x7d\x43\x06\x39\x8e\xb8\x09\x79\x94\x2d\x43\xb1\x22\xcb\x50\x28\
\x83\x0b\x51\x8c\xd0\x72\xe4\xc1\x75\x25\x92\x68\x37\x43\x77\x74\
\xb6\x20\x42\xbc\x04\x49\xbe\x5f\xb0\xf7\xce\x44\x87\x60\x31\xba\
\x93\xf8\x1c\x3a\x98\x32\x56\xce\xf5\x28\xf4\xc0\x72\xe4\x1d\xb6\
\xbb\xd5\x67\x3c\x0a\xc3\x90\x41\x87\xd7\x40\x14\x2f\xb0\xb5\xd5\
\xe9\x19\x44\x80\x8f\xb6\xdf\x3b\xa2\xbb\x91\xcb\xac\xbc\xc1\xc8\
\x13\xe4\x4a\xbc\x90\xd4\xe3\xe8\xc1\x66\xe4\xf4\x2a\x83\xc2\x7b\
\x74\x47\xc2\xad\x02\xb4\x86\x33\x28\x84\xca\x56\x24\x30\x2a\x46\
\xe1\x53\x5e\x45\xcc\xec\xb1\x88\x70\x6d\x69\xcf\xe6\xa0\xb0\x27\
\x63\x50\x88\x9a\xf9\x68\xfd\x17\x22\x8f\xab\x3d\x88\x42\xa9\xb8\
\x78\x9b\x67\xdb\xfb\x9b\x90\x47\xd6\x01\x44\x9e\x5d\x27\x23\xa2\
\xf4\x5c\x7b\x67\x16\x72\x28\x75\x3a\xb2\x46\x69\x6e\xe9\x9e\x47\
\x77\x14\x07\x59\x3d\x9b\x5b\x7b\x5e\xb7\x36\xae\x44\x42\x3a\x17\
\xff\xd3\xc3\xa3\xb1\x08\x51\xb8\x9d\x93\x11\xc3\xf8\x0e\x72\x18\
\x75\x31\x9a\xcf\x2b\x80\x97\xd1\xf9\xd2\x09\x39\x9b\xbb\x00\xad\
\x85\x65\x96\x06\x64\xf1\x74\xa6\x7d\x7f\xc7\xde\x6b\x85\xe6\xf2\
\x10\xb4\x96\x76\xd8\x33\xd0\xbc\x1f\x83\xce\xb3\xf9\xe8\xec\xeb\
\x88\x62\xf8\xb6\x43\xb1\x6b\x5f\x20\xba\x0b\x1b\xa2\x75\x77\x21\
\xf2\x96\x5d\x8e\xd6\x4b\x39\x5a\x93\x55\x88\x71\x9c\x6d\x79\xb5\
\x42\x71\x84\xdb\x93\xfb\xfe\x70\x0a\x59\x58\x9c\x8c\xee\xce\x4e\
\xb2\x7a\x8c\x42\xb1\xa4\xab\xd0\xba\x9d\x8d\xb4\xc9\xcd\x50\xf8\
\x22\x17\x86\xeb\x04\xe4\xd1\xfd\x9f\xc8\x02\xe5\x38\xeb\x13\x47\
\x07\x6c\x22\x3a\xc7\x5b\x5a\xda\x96\x96\x57\x2f\x44\x3b\xbc\x68\
\x75\x19\x63\x7d\x5b\x6d\xcf\x4a\xd0\x9e\xb2\x1b\x85\x70\x6a\x45\
\xe4\x18\x6c\xb4\x95\xb3\x00\x39\xd4\x3b\xde\x9e\x17\xd9\x7b\x2f\
\x23\x1f\x08\xe7\x59\x9d\x32\xd6\x1f\xf3\x38\x82\xf7\x0c\x4f\xec\
\x78\x78\x78\x78\xec\x1b\x52\x88\x20\xae\x42\x87\x75\x80\x0e\xf4\
\x77\xd0\x21\x72\x3e\x8a\x1b\xfa\x01\xf0\x31\x64\xa6\x74\x36\x92\
\x6c\xbf\x8e\x0e\xb4\x13\x90\xd7\xda\xed\xc8\x84\xa9\x23\xd2\xdc\
\xbc\x89\xe2\x8b\x9e\x87\x88\x01\x17\xbe\xe5\x13\xe8\x50\x5d\x60\
\x65\xb4\x42\xc4\xc5\x87\xc0\x0d\xe8\x40\x03\x11\xf1\x67\xa2\xd8\
\x98\x4f\x58\xd9\x17\x20\x62\x65\x34\x8a\xdf\x37\x15\x31\xd5\x29\
\x74\xf8\xcd\x40\x31\x0a\x8f\xd8\x03\xcf\xc3\x23\x07\x9c\xd3\xab\
\x34\x5a\x67\xcb\x90\xe6\xb4\x2b\x8a\x69\xfb\x2e\x62\x82\x3f\x8d\
\x18\xcd\x17\x11\x11\x7c\x2e\x62\x9a\x4f\x45\x61\x58\x56\x21\x41\
\x57\x57\xe0\x53\x88\xf1\x7c\xc1\x7e\x3f\x13\x11\xac\x03\x88\xc2\
\x34\x15\xa3\xb5\x7c\x16\x5a\xcf\x4f\xa1\x7d\xe4\x74\x44\xb4\x9f\
\x86\xf6\x06\xd0\xfe\x31\x13\x31\xd4\x97\x21\xc6\xa2\x3f\x22\x64\
\x27\x20\xe6\xe3\x5a\x14\x9f\xf3\x93\x48\x48\xf6\x22\x70\x86\x95\
\x9d\x45\x6b\x7c\x20\x62\x90\x8f\x78\x2d\x8f\xc7\x41\x41\x80\x98\
\x4d\x17\x23\x76\x33\x5a\x27\x5b\xd1\x3c\x1f\x8a\xae\x0a\x2d\x46\
\xf3\xf9\x66\x74\x0e\x2d\x44\x67\xdd\x20\x14\x9b\xfa\x46\xb4\xce\
\xde\x41\xeb\xa5\x3b\x3a\xdf\xd6\xa3\x33\xec\x3d\x34\x87\x8f\x45\
\x73\xfc\x36\xb4\xde\x5e\x00\x46\xa2\x75\x7a\x01\x62\xe6\x9e\x45\
\x02\xe6\xbe\xd4\xb4\x8e\x38\x0d\x9d\xb3\x8f\xa3\xf3\xf1\x32\xc4\
\x48\x8f\x42\x31\x7a\x5f\xb7\x67\xbd\x80\xab\x11\x13\xfc\x02\x62\
\x1c\x5b\x50\x53\x5b\x3a\x1c\x31\xca\x13\xad\xdd\x67\xa0\x75\x7c\
\x09\x62\x1c\x67\x21\xd3\xe6\xde\x68\xad\x76\x47\xe7\xf9\x59\x48\
\xc0\xf5\x12\x12\x3c\x8f\xb0\xdf\xce\x40\x8c\xf3\x6a\x74\xc6\x3b\
\x01\x01\xd6\x47\x9d\xad\x1f\x7b\x23\x81\x76\x35\x62\xc2\x4f\xb2\
\x7a\x3d\x8e\xbc\xda\x7f\x04\x31\xda\x2b\xad\x2f\x53\x56\xd7\xae\
\x68\x5f\x58\x84\x62\x68\x9f\x6b\x75\xe9\x69\xfd\x37\xd9\xfa\xe0\
\x06\x64\x0a\x7e\x05\x12\xf2\x2f\xb4\xdf\x0f\xa6\x39\xfa\x41\x87\
\xd7\x08\x7b\x78\x78\x78\xec\x1b\x1c\x11\x30\x03\x1d\x48\x6b\x91\
\x64\x76\x06\x22\x4a\xdb\xa3\xc3\xa6\x10\x1d\x44\x9d\x2d\xfd\xdb\
\xe8\xa0\xaa\x44\x87\xd5\x1c\x44\x9c\x5e\x8b\x08\xda\x57\xd1\x61\
\xd4\x0e\x69\x73\xdb\xa0\xc3\xd7\x49\xc5\xbf\x8f\x0e\xbd\x39\x56\
\x8f\x13\xd0\xa1\xdf\x89\x68\x4f\xcf\xa0\x43\x7a\x08\x62\xce\x3b\
\x22\x13\xab\x14\x92\x5c\x4f\x45\x87\xfb\x47\xec\x9d\x52\x24\x85\
\xde\x8d\x3f\x17\x3c\x8e\x6e\xa4\x89\xee\xe2\x2f\x46\xda\xe0\x93\
\x89\xb4\x23\xbb\x91\x06\xe8\x78\xc4\x00\xbc\x87\x08\xdf\xdd\x44\
\x0c\x6a\x5f\x60\x03\x22\x34\xdb\xa0\x75\xd8\x11\x11\xdb\xf3\x2c\
\xef\xee\x48\x88\xf6\x1a\x62\x90\x4f\x46\x7b\x46\x07\x44\xb0\xcf\
\x43\x1a\xa5\xcb\x10\x63\xf1\x06\x22\x80\x87\x23\x62\xba\x0c\x31\
\xe0\x73\x11\xe1\x7c\x2d\x22\x94\x07\x20\x62\xb8\xb7\x95\xdd\x0f\
\xad\xfb\x6d\x48\x70\xd6\x1c\x69\xc2\x3c\x3c\xf6\x07\xaa\xd0\xf9\
\x91\x46\xf3\xb0\x25\x12\x00\x6f\xb6\xbf\xd7\x22\x46\xed\x39\xe0\
\xdf\x81\xdf\x22\xe1\x70\x37\x34\x9f\x87\x20\xd3\xfd\x77\x10\x53\
\x37\x03\xcd\xdd\x10\x9d\x87\x3b\xd1\x5a\xaa\x44\x6b\xb0\x3b\x9a\
\xe3\x9b\x88\xd6\xd7\x00\xc4\xe4\x8d\x44\xc2\xe0\x85\x88\x81\x8e\
\x9b\xf7\x4e\x41\xda\xd7\x93\xad\xec\x72\xb4\x2e\x96\xa3\x33\xb9\
\x1a\xad\x91\xae\x68\xfd\x3e\x89\xd6\x60\x6b\xc4\x38\xc6\xf3\x1a\
\x8e\x84\x57\xd3\xad\xdd\x53\x10\x73\x3e\xc7\x9e\x15\x20\xc6\x7b\
\x18\x3a\xb3\xdf\x42\xe7\xee\x06\x6b\xdf\x1c\xc4\xf4\x3a\x5f\x1e\
\x6f\x23\x41\xd7\x0a\x44\x33\x74\x25\x32\x5f\xce\x5a\x19\xc7\x22\
\x61\xd9\x02\x24\xac\x2b\xb0\xf7\x87\xa3\x7d\xa7\x27\x12\xae\x95\
\xa3\xfd\x63\x83\x8d\x4d\x06\xed\x49\x95\x48\x68\x56\x8e\x18\xdf\
\x93\xd0\xfe\x36\x15\xed\x5f\xd5\xd6\x7f\xbb\xad\x1f\xae\xb5\x3e\
\x7d\x8f\x23\x23\xc4\x57\x5e\x78\x82\xc7\xc3\xc3\xc3\x63\xdf\x11\
\xa0\x83\xe4\x33\xc8\xec\x6a\x05\x3a\x80\x42\xa4\x3d\x1a\x8f\x18\
\xe1\x99\xe8\x60\x06\x1d\x38\xce\x2c\xd2\x99\x48\x82\x0e\xbc\x01\
\x48\x92\x3c\x15\x1d\x76\xa5\x44\xa6\x59\xef\xa0\xc3\xff\x2a\xe0\
\x37\x48\x6a\xdb\x1f\x1d\x6a\x4b\x11\xf1\x80\xe5\x5b\x82\xb4\x48\
\x1b\x10\x31\xbd\x26\x56\x67\x77\xdf\x28\x5f\xcc\x40\x0f\x8f\xa3\
\x09\x21\x5a\x93\xee\x8e\xfd\x50\x22\x53\xe9\x2a\x4b\x93\x41\xc4\
\xa8\x5b\xb7\xc5\xf6\x8e\x5b\xc3\xf1\x50\x4a\x21\x22\x24\x27\x23\
\x66\xd5\x99\x55\x5f\x6f\xf9\x87\x88\xf6\x0a\x90\xb0\xeb\x76\x44\
\x70\x7e\x40\x64\x91\x11\xcf\xb7\xda\xd2\xbb\xfc\x8b\xac\x5e\x21\
\x5a\xcb\x71\xd3\xcd\xd0\xca\x7c\x13\x31\x10\xef\x23\x33\x4a\x57\
\xbf\xf8\xdd\x66\x0f\x8f\xfd\x05\x37\xff\xaa\xed\x7b\x01\x9a\x67\
\xcd\x88\xce\x3b\x67\x1a\xdc\x07\xad\x1f\x62\xef\xb8\xf5\x90\x42\
\x0c\xe4\x6e\xf2\x7b\xa2\x0e\xd1\xb9\xf8\x26\x62\xf8\xdc\xfa\xda\
\x86\x84\xd1\xbd\x91\x66\xb6\x25\xf0\x0f\x7b\xbf\x08\x9d\x87\xd5\
\x88\xb1\x5b\x89\x04\xc7\x20\x06\x31\xee\x99\xda\xdd\xbb\x75\x6b\
\xb5\x90\xda\xd6\xb3\x19\x22\x2d\x69\x31\x12\x36\xbb\x75\x89\xa5\
\x2f\xb4\xff\xb3\x56\x86\xcb\xc3\xf5\x47\x32\x4e\xaf\xfb\x1b\x58\
\xfe\x41\x9e\x32\xb3\x88\x51\xee\x8f\x84\xe0\x25\x88\x36\x58\x4e\
\x64\x99\x96\x8c\x5a\x11\xdf\x43\x5c\xdb\xf2\xed\x21\xe5\xc0\x03\
\x48\x70\x77\x32\xf0\x59\xe0\x47\x88\xf6\x38\x22\xe9\x04\x6f\x1a\
\xed\xe1\xe1\xe1\xb1\xef\x48\x21\x26\x73\x2b\xba\x17\xf5\x36\x3a\
\xa8\xa6\xa2\x83\xb6\x2f\x92\x0a\x8f\x26\x22\xa4\xe3\x01\xef\xdd\
\x77\x77\x78\xb5\x40\x07\xea\x5a\x74\x10\x75\xb6\x74\x29\x64\xfe\
\xfc\x4f\x24\xf9\x1d\x8d\x88\xe8\xed\xf6\xe9\x67\xef\xba\xb4\x05\
\x40\x5b\xc4\x08\xa7\xad\x1e\xae\xbc\xf8\xbe\xef\x0e\xe0\xdd\xc8\
\x54\xab\x1d\x9e\x50\xf6\x38\xba\xd0\x13\xad\xdd\x4b\x81\x2f\x21\
\x02\x7a\x12\xd1\x7a\x4d\x21\xcd\xef\x2e\x64\xc2\x79\x11\xba\xe2\
\xf0\x2e\xb5\x43\x2d\x15\x20\x93\xcd\x75\x48\x63\xdc\xc5\xf2\x6e\
\x87\xb4\x46\xa3\xed\xfd\xab\x91\x76\xb6\x10\x69\x9c\xd6\x21\x4d\
\x6d\x2f\xa2\x35\xea\x3e\x73\x11\xe1\x7a\x2d\x32\x8f\x3c\x9e\xc8\
\xec\xd1\x95\xed\x98\x8f\x95\x48\xd3\x34\x02\x11\xcb\x97\xa2\x7d\
\x24\x43\x64\x15\xb2\x8b\x23\x94\xa0\xf5\x38\x64\xd8\x49\x64\x8a\
\xbc\x16\xad\x93\x0b\xd1\xfc\x9b\x82\xe6\xe3\x71\xc0\x7f\x21\xab\
\x87\x0b\x89\xe6\xac\xb3\x68\xb8\x12\x59\x28\x9d\x47\x4d\xa7\x56\
\xe5\xe8\x0c\x2d\x41\x6b\x72\x15\xd1\x1c\x77\xeb\xab\x33\x32\x71\
\x3e\x1f\x31\xc9\x9b\x91\x20\xc9\x21\x8d\xd6\xa0\xbb\x7b\xdb\x0f\
\x9d\xb3\xf1\x35\xe4\xd2\x55\x20\xad\xee\x25\x56\xcf\x2b\xad\xec\
\x38\x63\x3e\xdd\xf2\xb8\x14\x09\xb8\xce\x44\x67\xbf\x33\x05\xbf\
\x16\x69\x6b\xe7\x12\x31\xf9\x90\xfb\xfc\x0f\xed\xfd\x8b\x91\xbf\
\x91\xd5\xd6\x87\x8e\x29\x4e\x21\x46\xf6\x1d\xb4\x77\x5c\x80\x98\
\xfa\x1e\x56\xc6\x56\xab\x73\x7f\xc4\x94\x67\x88\x2c\x47\x9a\x5b\
\x3e\x8b\x2d\xcd\x0d\x56\xce\x99\x48\x4b\xed\xea\x41\xac\xac\xce\
\xc0\xad\x68\x7f\x5a\x87\x68\x83\x23\x5a\x23\x9c\xee\xd1\xba\xe8\
\xee\x6b\x86\xb7\x2b\x6e\x59\xe4\x79\x62\x8f\x03\x8f\x4c\x16\x5e\
\x58\x50\x5a\x3e\x7f\x63\xf9\x4b\x88\x48\xf7\x07\xb2\x47\x53\x46\
\x88\xa4\xbd\xdb\x91\x49\x52\xae\x8d\x32\x43\x64\x5a\xec\x18\xe1\
\xf5\xf6\x19\x80\xe6\xf8\x38\x74\xb8\xb9\xbb\x7a\x4e\xdb\xb3\x9e\
\xc8\x3b\xe6\x2e\x24\xad\x76\x8c\xed\x26\xfb\x7f\x1d\xd2\xea\x6c\
\x45\x9a\xdf\x0d\xe8\x80\x9b\x84\x0e\xf7\x0e\x48\x2a\xbe\x14\x11\
\xc2\xbb\xd0\x01\xbc\x04\x11\x27\x4e\x9b\xbc\x16\x31\xd3\xdb\xa9\
\xa9\x9d\x5e\x8c\x0e\xdf\x8e\xc8\x44\xad\x14\xbf\x2e\x3d\x9a\x2e\
\xd2\x88\x11\x75\xa6\x86\xfb\x3a\x57\xdd\x7b\x2d\xd1\x1a\x6a\x8b\
\xd6\xc1\x63\x96\x6f\x0a\xad\x85\x15\x88\x18\x77\xe6\x9c\x1d\x90\
\x89\xe1\x74\x7b\x7f\x73\xac\x1e\xe5\x56\xaf\x39\x88\xa0\xec\x66\
\xe9\xa6\x13\xad\xcd\xfe\x48\x7b\xf3\x81\xa5\xfb\xd0\x9e\x55\xa1\
\xfd\x63\x2d\x5a\xf3\x9b\xed\xfb\x0e\xb4\x46\x7b\x5b\x5d\x5f\xb4\
\x32\x02\x2b\xd7\xed\x1f\x3b\xec\xf9\x07\x56\x76\x17\xb4\x7f\xb8\
\xfb\x95\x63\x10\x13\x31\xb7\x11\x7d\xe6\x71\xe4\xa0\x39\x5a\x47\
\x53\x68\x9c\x70\x24\x40\x73\xd0\x31\x65\x6f\x20\x66\xb7\x2b\x3a\
\x77\x26\xa3\x73\x68\x3a\xb2\x4e\x5a\x8b\xce\xad\x55\x96\xde\x99\
\xfa\xf6\x47\x6b\xfb\x69\x74\x0e\x95\xa3\x75\xb2\x01\x09\x95\x57\
\x5b\xfa\x45\xc8\x62\xa3\x13\x5a\x5f\x33\x90\xe0\x79\xb5\xe5\xdb\
\xdb\x7e\x9f\x40\xa4\xa1\xae\x42\xeb\xb8\x17\x62\x16\xdf\x45\x67\
\xe0\x2a\x6b\xfb\x4a\x22\xcf\xca\x2b\xac\x9e\x2e\x74\xd2\x42\xb4\
\xae\x56\xc7\xda\xbb\xd5\xde\x1f\x68\xf5\x7c\xc6\xea\xb5\x16\x9d\
\xf9\x59\x64\x5a\xed\xcc\xb3\x57\x21\x61\x01\x96\x7f\x69\xec\xb9\
\x13\x76\xef\x44\x67\xf3\x33\x68\x2d\x67\xd0\xba\x2f\xb7\x7c\x67\
\x11\x99\x39\x2f\x40\x34\xc5\x52\xeb\x83\x96\x68\x9d\xaf\x21\xa2\
\x11\x3a\x5b\xfe\x5b\xac\x0d\x1f\x20\xb3\xf2\x76\xe8\x3a\xc6\xcc\
\xd8\xd8\x6d\xb4\xef\xbb\xed\xf9\x36\x74\x37\x39\x40\x77\xae\xd7\
\x35\x62\x7e\x34\x55\x94\x20\x8d\xf7\xb8\x60\x64\xcf\x92\x6d\x0f\
\xdc\xd8\xbf\x4d\x97\x96\x05\x84\x5e\x0f\xe0\x71\x80\x51\x51\x1d\
\xf2\x95\x67\x56\x6c\x7b\x62\xee\xd6\x3b\xd1\x66\xe3\x25\x30\x1e\
\x4d\x19\x19\xe0\x0b\x88\x58\x7d\x86\xfc\x71\x3f\xdd\x21\x1a\xff\
\x3d\x6e\x86\x18\x37\x4d\x4c\x9a\x2e\xc5\xc3\x21\xa4\xa8\x29\x7d\
\x75\x69\x89\xfd\x9e\x2b\x0c\x42\x90\xc8\x2b\x95\xa3\xfc\xe4\xef\
\xae\x8e\x4e\xf2\xee\xbe\x1f\x69\x07\x9e\xc7\x91\x85\x22\xe0\x5b\
\xe8\xde\xe1\x1c\x1a\x77\x86\xc4\xc3\x8a\x38\xc4\x35\x35\xf1\xb5\
\x92\x0c\x41\xe2\xd6\x0d\x39\xd2\xe7\x4a\x0b\xf9\xf7\x84\xfa\xd6\
\x69\x63\xca\x06\x69\x8f\x6e\x46\x26\x8f\x47\xac\x89\xa3\x47\x83\
\x11\x22\x66\xf5\x5b\xc0\xcf\x89\x18\xa1\xc6\xe4\x17\x37\x2f\x4e\
\xce\xd5\x5c\x21\xc2\xf2\x9d\x55\xf1\x39\x1f\xff\x2d\x45\xdd\xeb\
\x2b\xb9\x96\x93\x67\x59\x43\xcf\x43\x77\xe6\x26\xcf\xe1\xe4\x3e\
\x93\xac\x73\x50\xc7\xb3\x20\xcf\xf7\x0c\xd2\x9e\x97\x00\x7f\x21\
\x32\x5f\x8e\xa7\x4d\x86\x70\x73\xf9\xa7\xc9\xbd\xd6\xf7\xb6\xcf\
\xe2\xfd\x90\x8f\x76\x38\xd2\xe8\xf4\x10\x09\x52\x3e\x0b\x7c\xcd\
\xdf\x11\xf6\xf0\xf0\xf0\x68\x3c\x02\x6a\x33\xc9\xb9\x0e\x8f\x7c\
\xf7\x72\xe3\x0c\x6f\x3e\x66\x3b\xc8\x91\x47\xba\x81\xe9\x72\xfd\
\x1e\x4f\x13\x90\xbf\x5c\x0f\x8f\x23\x15\x75\xcd\xfb\xf8\x9a\xcc\
\x97\x36\xdf\x1a\xce\x97\x6f\x7d\x7b\x42\x5d\x79\xef\x6b\xd9\x21\
\x12\x1e\xbc\x8c\x67\x82\x3d\x0e\x0c\x92\x73\xae\xae\xb3\x30\x39\
\x57\x93\xbf\x53\xc7\x6f\x75\xad\xaf\xfa\xce\xb0\xbd\x39\x0f\xa1\
\xfe\xf3\xb0\xa1\x6b\x39\x55\xcf\xf7\xf9\xe8\xea\x43\x61\x9e\xdf\
\xf3\xd5\xaf\xae\x36\xef\x4d\x9f\xc5\xbf\xd7\x47\x3b\x1c\x91\xf0\
\x8c\xb0\x87\x87\x87\x87\x87\x87\x87\xc7\x91\x89\x00\x99\x98\x26\
\xef\x33\x7b\x78\x78\x1c\x5a\xb8\x28\x0e\x7e\x6d\x1e\x42\x14\x00\
\x84\x61\x48\x18\xe2\x4d\xa3\x3d\x0e\x38\xc2\xc8\x0f\x4f\x40\x6d\
\x89\xbb\x87\x47\x53\x43\xd2\x99\x95\x9f\xaf\x1e\x1e\x87\x16\xce\
\x74\xd0\xaf\xc9\x86\xc3\xf7\x91\x47\x12\xfe\x6c\x6b\x1a\xf0\xfd\
\x7e\x68\xb0\xa7\xdf\x83\x8e\x25\x05\xe5\xa3\xfa\xb5\x6a\xd6\xbc\
\x30\xe5\x7d\x85\x7a\x1c\x70\x64\xc2\x90\x29\x2b\x76\x54\xae\xd8\
\x56\x39\x99\x28\xac\x83\x87\x47\x53\x45\x88\x62\x0f\xee\x44\x4e\
\x2e\xfc\x7c\xf5\xf0\x38\xb4\x48\xa3\xb0\x21\xcb\xf0\x67\x88\x87\
\xc7\xbe\xa2\x19\xf2\xbc\xfc\x3e\x3e\xae\xb4\xc7\xd1\x87\xe6\xc8\
\x41\xe8\xc7\x0a\x3a\x95\x14\x56\x5d\x7f\x6c\xfb\x66\xed\x9b\xa7\
\x3d\x1f\xec\x71\xc0\x51\x95\x09\x59\xbb\xbd\x6a\xd7\x8a\x6d\x95\
\x0f\xe2\xbd\x57\x7a\x34\x7d\x84\x28\x46\xf0\x5a\xe0\x05\xfc\x7c\
\xf5\xf0\x38\xd4\x28\x02\xbe\x8e\xbc\xb2\xce\x3f\xd4\x95\xf1\xf0\
\x38\x4c\xd1\x0e\xf8\x1a\xf0\x5b\xe4\x39\xd8\xc3\xe3\x68\x42\x07\
\x14\xc3\xbd\xaa\xa0\x55\x51\x2a\x73\x72\x8f\x16\x74\x69\x59\xe8\
\x19\x61\x8f\x03\x8e\x8a\xea\x2c\x9d\x4a\x0a\xab\x91\x14\xf2\xbd\
\x43\x5d\x1f\x0f\x8f\x06\x60\x0c\xba\x63\xf7\xce\xa1\xae\x88\x87\
\x87\x07\x85\x28\xec\xd8\xfb\x44\x21\x8c\x3c\x3c\x3c\xf6\x0e\xed\
\x11\x03\x3c\x15\x85\xdb\xf1\xf0\x38\x9a\xd0\x09\xc5\x6d\xce\x16\
\x84\x40\x26\x94\xc9\xaa\xbf\x23\xec\x71\xa0\x91\xc9\xea\x4e\x3a\
\xde\x31\x80\xc7\xe1\x83\x14\x7e\xbe\x7a\x78\x34\x15\xa4\x39\x32\
\x43\x7a\x78\x78\x1c\x4c\xb8\x75\xe4\xa3\x05\x78\x1c\x8d\x70\xf3\
\xdf\x1f\x24\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\x1e\
\x47\x17\x7c\xf8\x24\x8f\xa6\x8c\x78\x20\xf6\x7c\x68\x09\x8c\x02\
\x5a\x01\xef\x02\x4b\x0f\x75\xa5\xeb\x80\x0b\x5a\xee\x71\xa4\x60\
\xec\x44\xa8\x79\x6f\x38\x8c\xfe\xec\x11\x36\x86\xb1\x07\x21\xf7\
\x8c\xde\xd7\x32\xf6\xfe\xdd\x7d\x6f\x53\xca\xca\x8b\xe6\xeb\x9d\
\x13\x21\xb0\x7a\xa8\x35\xb5\xd3\xec\x75\x59\xaf\x43\x58\x0e\x14\
\x05\xdc\x7b\x5e\xc3\xf3\xd9\xd7\x3e\xd1\x7b\x10\x06\x10\xec\xb1\
\x4c\x69\x5c\x1b\x0e\x06\x5c\x7b\x43\x42\x1b\x03\x62\xdf\xf3\xf7\
\xc1\x9e\xf6\x02\xf7\xee\x45\x3f\x25\x71\xe7\x84\x00\x02\xd5\xe0\
\x60\xcc\xc1\x83\x0b\xbf\x2f\x7b\x78\xec\x7f\xf8\x75\xe5\x71\x58\
\xc0\x33\xc2\x1e\x4d\x11\xc7\x02\x97\x23\x1b\xfe\xed\xc0\x53\xe8\
\x3e\x58\x2e\xf4\x44\x9b\xed\x42\xe0\x46\xe0\xe7\x40\x6f\xa0\x3f\
\xf0\x6a\x3d\xe5\x5c\x88\xcc\x23\x5e\x3e\x08\x6d\x6a\x09\x7c\x19\
\xb8\x1f\x58\x67\xcf\x8a\x81\x4f\x02\xcf\x20\x67\x4c\x0e\x17\x5b\
\xfa\xc7\xf7\x22\xff\x8f\x59\x1f\xcd\x3e\x08\x6d\xf1\x88\x70\x0a\
\x72\x38\x52\x8c\x0e\xfe\x0d\xc0\x63\xc0\x2b\x68\x1e\xde\x09\xfc\
\x1d\x31\x5c\x5f\x01\xfe\x9b\xb1\x13\x3f\xd0\xab\x7b\x98\x65\xb8\
\x67\x34\xdc\x39\x01\x02\xfb\x3f\x9b\xd5\x77\xfd\x7f\x31\x70\x03\
\xf0\x5d\xc6\x4e\x5c\x17\x15\x1d\x1a\xa9\x11\x44\xff\x67\x43\xf8\
\xd5\xf9\x11\x03\x94\x0f\xf7\x8c\xce\x9d\x46\xd7\x16\x3a\x5a\x9b\
\xc6\x03\xaf\xc4\x98\xa9\x36\xc0\x0f\x81\x39\xc0\x6b\xd6\x9e\x67\
\x18\x3b\x71\x52\xb2\x39\x04\x01\xfc\x72\x14\x8c\x9d\x10\x3d\x0c\
\x43\xb8\xf7\xbc\xa8\xac\xb1\x13\x81\xb0\x03\x41\xb3\xbb\x80\x47\
\xb9\x73\xe2\xec\x9a\x22\x85\x2c\xdc\x7b\xbe\xe5\x81\xf2\x89\xf2\
\xb8\x10\xb8\x19\xf8\x0f\xbe\xfa\xda\x2a\x52\x29\xeb\xab\x10\xee\
\x39\x2f\x96\x7f\xd4\x35\x96\x77\x37\x60\x0c\x84\xcf\x20\x67\x19\
\x5f\x06\xee\x63\xec\xc4\x59\x7b\xde\x8d\xbf\x57\x83\x94\x8b\xe5\
\x0d\x35\xc7\x2b\xde\x9f\xa1\x8d\x4b\xbc\x31\xf9\xfa\xfb\x9e\xd1\
\x4e\xc0\x50\xf3\x59\xb2\xfe\x70\x1b\x70\x12\xf0\x13\xe0\x7a\xab\
\xd5\xe3\xc0\xbf\xa3\x3b\x7e\x0f\xe4\x19\xf3\x1e\xc0\x05\x36\x4e\
\xdb\x6a\x8c\x51\xad\x7a\xc7\xda\x1b\xc4\x12\xea\xff\x8e\xc0\x5d\
\xc0\x83\x8c\x9d\x38\xef\x08\x62\x86\x4f\x06\xce\x07\xfe\x17\xc8\
\xd8\xb3\x8f\xa2\x3d\x7a\xc2\xbe\x66\x9a\x03\x29\x60\x34\xb0\x18\
\x58\xd9\xc8\xbc\x3a\xa1\xb3\xee\x7e\x60\xc7\x41\xec\x2b\x0f\x8f\
\x7c\xb8\x02\xed\xa7\xf7\xdb\xff\x29\xe0\xab\xe8\x1c\x9c\xb7\x8f\
\x79\xf6\x40\x74\xe0\xfd\x40\x45\x03\xdf\x39\x17\x29\x45\x9e\x3f\
\xd4\x1d\xe2\x71\xf8\xc0\x9b\x46\x7b\x34\x35\x9c\x80\x88\xed\x25\
\xc0\x9f\x11\x83\xfb\x23\x60\x48\x2c\x4d\x7c\xde\x2e\x40\xde\x7c\
\x5b\x00\x55\xc0\x40\x44\x24\xdc\x84\x34\xc5\x49\x61\x4f\xfc\xdd\
\x01\xf6\xc9\x15\x43\x2f\xdf\x1d\xb4\x7c\x5e\x83\x53\xf5\x3c\x2b\
\x02\xce\x41\x9b\xb4\x43\x21\x62\xa4\x4a\x12\x69\x07\x02\xc3\x13\
\x65\x06\xf5\xe4\x7f\x3c\xd0\xa5\x9e\xf4\x1e\xfb\x1f\x3d\x80\xab\
\x11\x41\xba\x10\x38\x11\xf8\x0b\x04\x67\x21\x21\xce\xdb\xc8\x21\
\x49\x4f\xe0\x23\x68\xbe\x0d\x05\xba\x12\x52\x08\x0c\x06\x3a\x73\
\xc7\x04\x10\x33\x3d\x14\x68\x4b\x98\x4d\x11\xd0\x17\x18\x04\x1c\
\x67\x65\xb4\xb2\x7c\xfa\xdb\xf3\x9e\xec\x2e\x02\xe8\x8c\xe6\x4b\
\x4f\xb2\xd9\xc0\x18\x9b\xee\x96\xae\x0f\x30\x0c\xcd\xb1\x62\xfb\
\xde\xda\x98\xcb\xb6\x56\x5e\x3b\xcb\xaf\x37\x01\x43\xd1\x5c\x7d\
\x17\x58\x63\x79\xb5\xb1\xf7\xfa\x02\x97\xa2\x39\xbb\x03\x39\x0f\
\x5b\x8b\xc2\x10\x0c\x01\xba\x5a\xba\x1e\x2c\x6a\x2b\x6d\xaf\xd6\
\xe5\x50\x6b\x77\x01\x77\xc6\x78\x8b\x74\x00\x70\x15\x62\xf4\x37\
\x13\x92\x06\xfa\xa1\x3d\xa0\x2f\x84\x05\xc6\x2c\x17\xa2\x35\x31\
\x04\x68\x6e\x79\x0c\xb0\x3e\x69\xc3\x19\xe7\x63\xfd\x32\x1c\x68\
\xcf\x5d\xaf\x3b\xe6\xce\xd5\x6b\xa8\xf5\x5d\x33\xe0\x1b\xc0\x7f\
\x10\x70\x1c\xb0\xdb\xc6\x67\x97\xa5\x6b\xcb\x9d\xaf\x61\xfd\x31\
\xd4\xfa\xab\xa8\x46\xd9\x35\x99\xcd\x16\x7b\xf2\x56\x7f\x76\xb2\
\xf1\x2c\x00\x5a\x23\x81\xde\x31\x10\xb6\xb2\xf7\x0a\xad\x9f\x4f\
\x00\x7a\x01\x29\xc6\x4e\x24\xd6\xee\x63\x80\xb6\xdc\x35\xd1\xd5\
\xbf\xc0\xca\xee\x0f\x8c\x04\x2e\xb3\x36\xcc\x45\xc4\x65\x31\x22\
\x14\x47\x58\x3f\xb5\xb3\xb9\x32\xc4\xea\x56\x0c\xdc\x0d\x7c\x9f\
\x80\xe1\x68\xbf\x28\xb6\x3a\xaa\x3d\x77\x4d\x74\xed\x1d\x8c\x04\
\x37\x83\x21\x2c\xb6\xfe\x3c\xc1\xca\x2f\x86\xa0\xcc\xfa\xfc\x73\
\x1c\x59\x02\xf4\xee\xc0\xd9\xd4\xdc\x2f\x8f\xb5\xf1\xc8\x75\x26\
\x04\x89\xff\x93\xc8\x77\x66\x14\x23\x0f\xa5\xbd\xea\xc8\xaf\xa1\
\xf9\x56\xa1\x75\x97\xc9\xf3\x7b\x7d\xf9\x7b\x78\xec\x6f\x0c\x41\
\xa1\x98\xe2\x38\x1d\x9d\x4d\x0e\xf9\xf8\x8d\x7c\xb4\x53\x2b\x74\
\xd6\xa4\x1b\x90\xd6\xa1\x0f\xda\xb3\x1a\x42\x33\x79\x78\x00\x47\
\xd6\x81\xe6\x71\xf8\x23\x40\xd2\xf8\x77\x90\x56\x0d\xe0\x03\x44\
\xfc\xb5\x26\xf2\xf2\xd6\xc7\x7e\x7b\x1c\x11\xb2\xa7\x21\x69\xfb\
\x03\xc0\x46\x44\xc4\xef\x44\x1a\x52\x47\x2c\x94\xd8\xbb\xc3\x81\
\x6d\xc0\x83\x40\x35\xd2\xb2\x7c\x17\x6d\xba\x8f\x02\x33\x2c\xaf\
\xf3\x91\x56\x76\x11\x92\x48\x8e\xb4\x72\x0a\x2d\xed\x43\xc8\x0c\
\xfb\x76\xa4\x33\xe9\x89\xa4\xfd\xf7\x5b\x3b\x6e\x44\xcc\xe9\x66\
\xe0\x11\xfb\x9b\xa1\xa6\xa9\x50\x68\xf9\x7d\x02\x11\xae\x8b\xad\
\x0d\x19\xfb\x14\x00\x97\x20\x86\x3e\x83\xa4\xab\xe3\x11\xc3\xfb\
\x31\xa4\xdd\x5a\x61\x75\xc9\x58\x7b\xfa\x03\xb7\x58\xfb\x96\x1f\
\xea\x01\x3d\x0a\x10\xa2\xb9\xf6\x3b\x02\xa6\x10\x72\x2c\xf0\x22\
\x70\x2d\x62\x84\xff\x13\xf8\x37\x34\x36\x29\x34\xd7\xba\x02\x6b\
\x08\xf8\x3a\xd2\xe8\xad\x25\xcb\x17\x28\x08\x2e\x00\x7e\x01\xdc\
\x4e\xba\xa0\x0f\xf0\x03\x74\x35\xa0\x1c\x11\xbf\x01\xf0\x3d\xe0\
\x3c\x7b\xfe\x08\xc5\x55\x6f\x21\xc1\x51\x77\x08\xca\x28\x28\xf8\
\x05\xd2\x40\xdf\x05\x5c\x67\x75\x68\x0f\xbc\x04\xfc\x1e\xf8\x13\
\xf0\x37\x08\xff\x0f\x82\xcf\x5a\x9a\x1f\x00\x3f\x53\x5b\x82\x2a\
\x08\xff\x17\x82\x7f\x43\x82\xa8\xad\xc0\xaf\x81\x53\x09\x58\x83\
\xd6\x60\x25\x22\xe8\xff\x1f\xf0\x63\xa4\x21\x7e\x9c\x80\xb5\x48\
\x30\xb0\x85\x81\x5b\x3f\x0b\xe1\x32\x08\x7e\x86\xd6\x52\x35\x41\
\x70\x1f\x61\xf8\x73\x9c\x74\x3f\x93\x6d\x0e\xc1\x0d\xc0\x6c\x02\
\xd6\x93\xe2\xd3\xc0\xad\x48\xab\x3e\x98\x20\x75\x2f\xf0\x08\xa4\
\xbe\x09\x7c\x1c\x48\x11\x04\xe3\x20\xfc\x16\xd1\x7c\x0f\x79\xf7\
\xf5\x6b\x08\x82\x1f\x00\xed\x20\x58\x48\x18\xfe\x1b\xb0\x0a\xf8\
\x2f\xc4\x3c\xa6\x08\x98\x0c\xfc\x05\x09\x23\x7a\x5a\x3f\xfe\xca\
\xda\xf0\x13\xe0\xd3\x10\xbc\x42\x18\xfe\x17\x01\x5f\x45\xcc\xf9\
\xc7\x09\xf9\x14\xda\x93\x52\x10\xbc\x08\x7c\x07\xed\x1f\x10\x04\
\xdd\x55\x3f\x7e\x03\xfc\xd5\xf2\x1c\x40\x10\x7c\xcd\xf2\x6d\x6e\
\x75\x5a\x80\x18\xf0\xdb\x2d\xdf\x32\xc4\x74\xfe\x00\x78\x95\x14\
\x77\xa0\x10\x5d\xc5\xc0\x7c\xc2\xf0\x1b\x10\xcc\xb7\x31\xfc\xb2\
\xa5\x2f\xb2\x7e\x2b\x44\xcc\x68\xd6\xde\xaf\xb2\x7e\x18\x04\xc1\
\x2f\xad\x5f\xba\x01\x13\x81\x7f\x21\x61\x41\x57\xab\xdb\x57\x09\
\x18\x8b\x84\x19\x01\x30\x91\x30\xfc\x16\x04\x63\x80\x9f\x10\xb0\
\x11\x58\x4b\x10\x3c\x81\xf6\x97\x8d\x1a\x07\x9e\xb0\x3e\x9a\x84\
\xb4\x3c\xbf\x44\xfb\x4e\x53\x45\x4f\x24\x90\x99\x4e\xfd\x61\x61\
\xb2\x1a\x5b\x3a\x5a\x5f\x82\xce\x9b\x0c\xd2\xbc\xef\x44\x82\xd6\
\x4e\x68\x5f\x7d\x1b\x69\xd8\x43\x7b\xf6\x3c\xda\x93\xbb\xa1\xb9\
\xdb\x0d\xed\xe3\x0f\x23\x66\xfa\x5a\xcb\x37\x83\x04\x0b\xb7\x20\
\x81\xd9\x30\x34\x37\x41\x96\x4b\xaf\xd9\xb8\x0c\x47\x67\x41\x73\
\x74\x16\x2c\xb1\x7a\x9c\x88\xf6\x81\x7f\x20\x26\xb8\xa3\x8d\xe1\
\x30\x74\xae\xb5\x42\xc2\x91\x47\x90\x70\xe6\x52\x2b\xb7\x0b\x0a\
\x33\xf5\xc6\xa1\x1e\x14\x8f\xc3\x0a\x01\x12\x8e\xf5\x40\xf4\xd8\
\xce\x7a\xd2\x67\xd1\xba\xe9\x60\xff\xa7\xed\x93\x45\xfb\xda\x75\
\x88\xd6\x2a\x45\xb4\xdd\x7c\x24\x80\x1a\x83\xe6\xee\x0a\xe0\x6f\
\x68\x9d\x7c\x1c\x09\x0c\x77\xa1\xfd\x0e\xa4\x44\x48\xa6\xad\x40\
\x74\xd6\x09\x68\x8f\x7c\x08\xed\x85\xc7\xa1\x73\xb5\x1d\xda\x03\
\xdf\x41\x74\xd1\x47\xd1\x59\x38\xc7\xea\xb0\xfd\x50\x77\xb2\x47\
\xd3\x80\x97\x8e\x78\x34\x25\x34\x43\xd2\xbc\xa4\x29\xcd\x7d\xc8\
\xfc\xef\x74\xc4\xd0\xfe\x09\x58\x86\x08\xcb\x93\x10\xb1\x38\x0d\
\x6d\xde\x15\xc0\x14\xc4\x08\x6e\x23\x62\x3c\x6f\x40\xcc\xec\xfd\
\x28\xf4\xc6\x05\x68\xa3\xee\x81\x08\x9d\xa5\x88\xc0\xec\x8c\xcc\
\x2e\xc7\x21\xe2\x76\x0c\x92\x4a\x0e\x44\x0c\xe9\x73\x68\x23\xfe\
\x2a\xda\x94\x2f\x47\x04\xca\x43\xc0\x45\xc0\xa9\x68\x73\x3e\xc5\
\xea\xfd\x21\x22\x82\x5b\x51\xfb\xbe\x4c\x88\x36\xe6\xdd\x56\xdf\
\xd3\x90\x86\x2c\x6b\x9f\x91\xc0\xa7\x81\xa7\x11\xb1\xf4\x15\x24\
\x75\xfd\x32\x22\x8c\xff\x86\x04\x04\x23\xd1\x01\x32\x04\x69\x80\
\x96\x00\x6b\x0e\xf5\x60\x1e\x65\x28\x30\x91\xcb\x72\xfb\x0c\x43\
\x9a\xd4\x0e\x68\xac\x42\xfb\x3b\x05\x31\x8f\xc7\x43\x30\x04\x98\
\x0c\x8c\xa6\x20\xe8\x8d\xe6\xda\x26\x44\xbc\x7f\xc3\xf2\xf9\x2a\
\x22\x7c\x9d\xd0\xb2\x25\x22\xc0\x7f\x48\xc8\x3f\x80\xef\xa3\x39\
\xff\x29\x14\x8e\xec\xfb\x38\x6d\x9f\xe6\xd6\x2f\x11\xa3\x76\x23\
\x22\x6c\xe6\x03\x97\x41\xaa\x23\x9a\xaf\xb3\x91\x19\x68\x77\x2b\
\xe7\x33\x10\xcc\xb4\x32\x9a\x03\xd7\xa0\xf5\xf0\x23\x34\x9f\x5d\
\x5b\x0a\x10\x31\x5e\x6c\xdf\xbb\x22\x02\xe3\x07\x48\x73\x78\x1e\
\x04\x57\x03\x57\x5a\x9d\xfe\x01\x7c\x99\x20\x38\x26\xea\xb2\xa0\
\xbb\xf5\xd3\x4c\xd3\x8e\xdf\x0a\x54\x41\xf8\xdf\xc0\xbd\x10\x7c\
\x80\xd6\xd3\x97\x10\x13\xfb\x63\xe0\x3a\x08\xce\x43\xf3\x3d\x6b\
\xfd\xfb\x2d\xb4\x1f\x7c\x0e\x31\x22\x9f\x47\x8c\xc0\xcd\x48\xb0\
\xf0\x23\x6b\xcb\x2e\x24\x4c\x5a\x0b\xfc\x07\x22\x84\x3a\x23\x66\
\x7f\x06\x70\x09\xa9\x74\x5f\xc4\xac\x4e\x47\x1a\xf0\x2f\x58\xbb\
\x7f\x6a\x7d\x78\x51\x54\xfd\x70\x25\x12\x94\x5d\x0e\x41\x1f\xb4\
\xa7\xbc\xad\x36\xf0\x0e\x21\xdf\xb5\xf1\xbd\x04\x69\x7b\x6f\x45\
\x7b\xcf\x8f\x91\x50\x62\x25\x70\xa6\x8d\xf5\x93\x56\xef\x9e\x10\
\x7c\x0b\x11\x73\x77\x02\xaf\xa3\x98\xb9\xbb\xd0\x79\x1d\xd8\xbc\
\x6a\x43\xa4\xf1\x08\x09\x29\x46\xcc\xd4\x77\x91\x95\xcc\x65\x48\
\xa0\xf0\x1a\xda\x0b\x7e\x18\xeb\x93\xff\x41\x8c\xf1\xa5\x10\xdc\
\x66\x63\xda\xdd\xd2\xde\x61\x75\xea\x82\xe2\x8b\xfe\x02\x09\x16\
\xb3\x36\xbe\xed\xa9\x69\xad\xd2\xd4\x50\x64\x63\xfb\x8c\xf5\x5f\
\x7d\x1a\xd1\x2c\x9a\x83\xf7\x22\x81\xcf\xaf\xd1\x18\x67\x10\xf1\
\x7f\x1d\x22\xc6\xcf\x40\xc2\x9f\x22\x24\x4c\x99\x8e\xae\xd4\x7c\
\x19\x8d\xed\x5d\x96\xd7\x5f\xac\x2f\x6f\xb3\xbf\x97\xa3\x39\xf7\
\x24\x3a\x63\xc6\xa1\x39\xfa\x15\x7b\xff\x39\x24\x04\x39\xce\xea\
\x71\x1a\xba\x0a\xb4\x05\xf8\xac\xf5\xf5\xf5\x48\x48\xbb\x10\x9d\
\x41\xad\x2d\x5d\x57\x24\x98\x59\x81\xce\xb5\x53\xd1\xf8\x76\x43\
\x63\x3d\x11\x31\x01\x5f\x45\xf3\xc5\xc3\xa3\xa1\x68\x0f\xfc\x0e\
\x78\x16\x9d\x01\xf5\x21\x8b\x04\xb4\x6e\x0d\xfd\x0a\x59\x56\x54\
\xa1\x33\xe0\x3c\x24\xa0\x5d\x84\xae\xdd\xf4\x42\xe7\xca\x24\x44\
\x67\x9d\x0b\x9c\x85\xe6\xfa\xb1\x68\x3e\x97\x23\xba\xa9\x25\x5a\
\x93\x93\xd0\xfa\x3a\x0b\xed\x51\x57\x22\x06\xf9\xef\x48\xf0\x79\
\x11\x5a\xab\xbd\xd1\x3a\x9b\x8f\xce\x8e\x8e\xc0\x37\x91\x60\xef\
\x3e\xc4\x38\xdf\x74\xa8\x3b\xd8\xa3\xe9\xc0\x33\xc2\x1e\x4d\x09\
\x59\xb4\x71\x16\x26\x9e\x17\xda\xe7\x6d\x64\x16\x78\x0e\x22\x3e\
\xba\x20\xed\xd4\x23\x68\xd3\xec\x80\x08\x9f\x72\x44\xdc\xc6\x71\
\x06\x62\x78\x67\x21\x46\xfa\xef\xf6\x7c\x3c\x62\x20\x26\xa3\x0d\
\xb7\x02\x49\x0b\x7b\x21\x4d\x56\x07\xb4\x91\x66\x2c\xed\x0c\x44\
\x9c\xb6\x45\xc4\xf5\x4a\x44\xcc\xcc\x40\x04\x49\x6f\x2b\xab\x0b\
\xd2\x06\x1c\x83\x18\x83\x0e\xd4\x66\x84\xdd\x9d\xd2\xc7\x81\x99\
\x88\x30\x3a\x91\x48\x92\x7a\x86\xd5\xed\x4d\xc4\x08\x2f\x44\xcc\
\xd2\x50\xab\xe3\x1c\xa4\xa9\x79\x0d\x69\x11\xee\x44\x84\xfd\xb3\
\x44\xda\x0d\x8f\x83\x85\x68\x37\x4d\x13\x69\x81\xdc\x98\x07\x88\
\x99\x79\x12\xdd\x3d\xdc\x8e\xe6\xf4\x4b\x88\xb8\xbe\x14\x1d\xf0\
\x2f\xd8\x3b\x9d\x2d\xed\x2b\xf6\x2c\x1b\xcb\x67\x25\x61\xf8\x8c\
\xdd\x4f\xed\x07\xfc\x13\xcd\xcd\xbf\x21\x29\xb8\xbb\x46\xb0\x14\
\x31\xa0\x8f\x22\x89\x79\x17\xc4\x20\x0c\x42\x77\xba\xfa\x23\xa2\
\xbb\xd2\xd2\x4f\x40\x56\x14\xe5\xb1\x76\x1c\x83\x98\xcc\x87\x08\
\x79\x02\x58\x1d\x6b\x69\x7c\x3e\x97\x5b\x5b\x9e\x43\x44\x7c\x21\
\xec\x31\xb3\xbe\x10\x11\xf9\xa1\xd5\xd7\xc1\x99\x6b\x97\x59\x1d\
\x5e\x50\xba\xe0\x5f\xd6\x1f\xcd\x2d\x7d\x6b\x24\x58\x3a\xc7\xfa\
\x70\x90\xd5\x2d\x44\xeb\xb4\x0f\x22\xfe\xaf\xb1\x7e\xef\x69\xe9\
\xb7\x01\x4f\x43\xf8\x67\x42\x6e\x84\xcc\x5b\xf6\xac\x82\x90\x25\
\x44\x6b\xa4\x1a\xad\x99\x1e\x10\xdc\x6a\xef\x3f\x6d\xfd\xd8\x0a\
\x09\xdb\xce\x44\x8c\x51\xac\xfe\x05\x95\x96\xce\x31\xb9\x25\xc0\
\x8b\x10\x6e\x05\x5a\x10\xf0\x5d\xc4\x1c\x67\x91\x29\xf9\xcb\x68\
\x4f\x79\xc8\xf2\x6b\x66\x6d\xc9\x20\xc2\xef\x25\x1b\x83\x13\xac\
\xcc\x16\x48\x40\x36\x0e\x69\xf4\x72\x38\x65\xb3\x39\x11\x50\x86\
\x84\x17\x3f\xb0\xb6\x67\xad\xaf\xb6\x00\xe5\x84\x2c\xb5\x31\x58\
\x06\x3c\x4c\x18\x3a\xad\xcc\x69\x44\x42\x82\xf1\x36\x67\x26\xd8\
\xb3\x07\x81\x8f\x42\xd8\x8e\x30\x9b\x42\x02\x3b\xa8\x79\xbd\xa3\
\xa9\x21\x8b\xf6\xd4\x8d\xf6\xa9\x0f\x29\x64\x75\x74\x27\x62\x18\
\xdd\xbd\xc6\x34\x12\x5a\x35\x47\xcc\xe8\x59\x68\x0f\xae\x40\x42\
\xd9\x71\x68\x3c\x57\x22\x0b\xa2\x53\x91\xe0\xe4\x06\x34\x17\x9d\
\x69\xfd\x2c\xc4\x8c\x2e\x46\x6b\x7e\x35\x9a\x2f\x7d\xed\xbd\x0b\
\xd1\xf9\x32\x10\xad\x81\x97\xd1\x1a\x9c\x8c\xf6\x80\x2d\x68\xee\
\x7c\x05\xad\xdf\xc9\x44\xe7\x64\x7f\x24\x84\x7a\xcc\xca\x79\xdc\
\xea\xd1\x1c\x9d\x95\xef\x58\x7a\xd0\xd9\xe6\xe1\xd1\x50\x54\x21\
\xa1\xdd\x06\x9c\x05\x4c\xdd\x48\xa1\x7d\xc3\xad\xa1\x3b\x11\x7d\
\x52\x84\xd6\x4e\x27\x24\x40\x1a\x81\xe8\xa1\x62\x34\x5f\x3b\x21\
\x26\xb9\x13\x52\x4a\x9c\x82\xf6\xc1\xf7\x81\x27\xd0\xfc\xdf\x65\
\x69\x3b\xa3\xfd\xb3\x13\x5a\x63\x23\xd1\x7a\x99\x89\x98\xe9\xbf\
\xa0\x7d\x71\x02\x5a\xa3\x8e\xa6\xeb\x83\x7c\x01\x0c\x46\x82\xad\
\x4e\x68\x2f\xf4\xfc\x8f\x07\xe0\x4d\xa3\x3d\x9a\x16\x2a\x11\x43\
\x79\x2a\x22\xd8\xb3\x88\xf8\xbb\x03\x11\x12\xee\xae\xde\xcb\x68\
\x93\xed\x85\xb4\x66\x73\x1a\x90\x77\x35\xda\x7c\x41\x92\x74\xc7\
\x70\x3a\xe2\xce\x79\xa8\x1e\x88\x34\x4c\xaf\x23\xa6\xdb\xdd\x1f\
\x73\x84\x25\xc4\x5c\xca\x20\x06\x20\x93\x78\x5e\x85\x36\xe2\xe7\
\xad\xcc\x71\x48\xd3\x97\x4b\x3b\x51\x40\xc4\xf8\x17\x5b\x1f\x38\
\x22\xb7\x02\x31\x36\xc4\x7e\x2f\x27\x32\x43\x02\x77\xaf\x50\xcf\
\xfe\x80\x34\x0b\xd7\x23\xc9\xa7\xc7\xc1\x45\x0a\x99\xc3\xf7\x43\
\xc2\x89\xdd\x89\xdf\x9d\xa6\x3f\x1d\x4b\x3f\x1f\xcd\xdf\xbb\xec\
\xf9\x4b\x68\x9e\x55\x00\x03\x09\xc3\x56\x04\x41\x3f\xa2\x43\x3b\
\x00\x32\x04\x41\x88\xe6\xc2\x2e\x44\x74\x97\x20\x49\x7a\x86\xc8\
\x1c\xb4\x03\x22\x96\x9d\x76\x77\x3b\x12\xaa\xec\x42\xe6\xda\x9b\
\x10\xc1\xdc\xd5\xd2\x57\x99\xf3\xa4\x20\x56\xdf\x4d\x48\x3b\xd0\
\x8f\x80\x22\xa4\x59\xca\xe5\x09\xd4\x79\xc6\x8e\x13\x17\xa5\x56\
\xd6\x73\x48\x30\xf5\x17\xa4\x49\x4b\xbe\x13\x10\x04\x59\xc2\xf0\
\x1f\xd6\x17\xc3\x90\x86\xfb\x27\x88\xc0\xd9\x8d\xb4\x5b\xb3\x11\
\xd3\x3f\x07\x49\xff\x03\x2b\x63\x27\x62\x66\x1e\x44\x6b\x6e\x15\
\x62\x40\x5b\x21\xe6\x36\x4d\xc0\x79\x90\x1a\xbf\xa7\x8e\x01\xcd\
\x63\x75\x4d\x21\x8b\x92\x55\x48\x83\xb0\x1c\xad\xdf\x8e\xd6\xc7\
\x13\xac\xec\x7f\x11\x77\x46\x17\x96\x03\x85\x6f\x58\xfd\x3e\x8f\
\x08\xb2\x59\x10\x7c\x1e\x69\x0a\x3f\x89\x88\xb5\x2f\xa2\x75\xfd\
\x07\xc4\x5c\x1d\x63\xe9\xdb\x21\x02\xaf\x08\x18\x4c\xc8\x87\x04\
\xf4\xb3\x3e\x5f\x63\xfd\x3f\x14\xc2\x77\x20\x88\xdf\x2d\x4d\x22\
\xb0\x32\x6e\x46\xa6\xb7\x1f\x47\x42\x03\xf7\x5b\xda\xda\xbb\xcd\
\xda\xd4\x07\x82\x9d\x36\xee\x73\x89\x0b\xcd\x64\x28\x3c\x0e\x31\
\x91\xfd\x94\x5f\xf0\x3f\x04\xc1\x34\x22\xc1\x4e\x7d\x9e\xfc\x0f\
\x25\xaa\x91\x49\xfc\x5f\x10\xd3\x59\x9f\xd7\xda\xc0\xc6\x66\x93\
\xbd\x0b\x9a\xb3\x81\xf5\xd7\x74\xeb\xcf\xd6\x88\xb1\x1c\x82\xf6\
\x6c\x77\x07\xb1\x88\x68\x1d\xbe\x8a\xce\xa9\xb6\xd6\x57\x9d\x89\
\x84\x4c\x4e\x9b\x1f\xda\x6f\x2b\x11\xa1\x9f\x01\xde\x42\x56\x50\
\x3d\x88\xf6\x0c\x97\x7f\x29\xb2\x20\xe8\x8e\x98\xe6\xef\x21\x8d\
\x37\x68\xdc\xe2\xe7\x47\x0b\x22\x4b\x89\xf2\x58\xb9\xde\x73\xaf\
\xc7\xde\xa2\x0c\xed\x61\x6d\x69\xf8\x35\x88\xdd\x68\x1d\x81\xe6\
\x9d\x9b\xfb\x55\x88\xae\x7b\x0c\xcd\xd5\xf1\x68\xdd\x7c\x0f\x31\
\xab\x73\x91\xe5\x1c\x68\x0d\xb6\xb0\xef\x45\x68\x0d\xf4\x41\xa6\
\xce\x53\xd0\x3a\x59\x8b\x3b\x07\x23\x9a\xae\x33\x62\xa2\x0b\x88\
\xcc\xb8\xdd\x1a\xca\xa2\xb3\xef\x25\x7b\xb7\x83\xa5\xf1\xeb\xc2\
\x03\xf0\x8c\xb0\x47\xd3\xc3\x3f\xd1\xbd\xca\x6f\x20\x29\xf7\x31\
\xc8\x24\xfa\x05\xfb\x5b\x8a\x36\xb5\xd1\x48\xda\xd7\xd0\x60\xf0\
\x2f\x23\x06\xb1\x0a\x49\x28\x57\x23\x62\xc1\xad\x01\xe7\x1c\xab\
\x85\x7d\x56\x23\x09\x7c\x1f\xa2\xc0\xdb\x71\x66\xc4\x95\x1b\x2f\
\x3f\x8d\x36\xf2\x71\x48\x33\xf0\x01\xce\x19\x92\x18\x9e\x3d\x01\
\xbc\x0d\xee\x9e\xd9\xed\x88\x41\xb9\x10\x11\x70\x8e\xd8\x9a\x88\
\x88\x9e\x4f\x20\xc6\xb7\x1b\x32\x39\x4a\x21\x93\xe9\x89\xe8\x0e\
\xe0\xd3\xd6\xae\x99\xc8\x7c\xe8\x47\x88\x80\x9b\x75\x08\xc7\xf1\
\x68\x41\x80\x18\xae\x9f\x20\xe9\xf5\x10\xe0\x43\x08\x1f\x86\xa0\
\x05\x1a\x47\x47\x04\x3b\x02\x9a\x3d\xcf\x9b\x53\xc9\x6e\x5e\x40\
\x26\x94\xcf\x11\x86\x1f\x10\x04\x55\x48\x10\x74\x1b\x41\x70\x32\
\x35\x1d\xba\xa5\xd0\x3c\x4a\x11\x86\x6b\x08\x82\x7f\x20\x13\xca\
\x13\x10\xe3\xf2\x34\x1a\xfb\x9b\xd0\xfc\xfd\x13\x3a\xf8\xd7\xa2\
\x39\xb6\x16\x69\x17\xbf\x04\xfc\x94\xaa\xaa\xcd\x14\x16\x76\xb7\
\xfa\x24\xe7\x32\xf2\xae\x1c\x7c\x12\xdd\x79\xdc\x45\x74\x37\x31\
\xde\x9e\x64\xdb\xec\x7e\x58\xf8\x3c\x04\x1f\x47\x66\x69\x59\xe0\
\x43\x42\xbe\x1c\x2b\x63\x2b\x22\xb8\x3a\x13\x66\x0b\x21\xb8\x0b\
\x69\x48\x9f\x42\xcc\xfc\x87\x68\x8e\xcf\x42\x8c\xde\x16\x64\x06\
\xfc\x25\x82\x3d\xf7\xeb\x3f\xb4\xbe\xba\x11\x09\xc6\x3a\x21\xcf\
\xf1\x2f\xa2\x7b\xae\x7f\x44\x6b\xb2\x03\x32\x19\x5e\x8a\xd6\xd1\
\x4f\x91\xa6\xdc\xf5\x67\x29\xd2\x04\x9e\x03\xfc\x99\x82\xa0\x94\
\xea\xec\x64\x08\xe6\x58\xd9\x9b\xad\x7d\x5f\xc1\x79\xfd\xbd\x67\
\x0c\x8c\x9d\xb0\x1a\x82\x37\x10\xd1\xf8\x13\x44\xfc\xed\xb6\xb4\
\xa7\x23\x6d\x47\x31\x62\x72\x6e\x41\x7b\xcb\xcb\xd6\x96\xa5\x84\
\x4c\x22\x60\x06\xf0\x0b\x02\xd6\xa3\xfd\xe6\x5b\x10\x4e\x86\x60\
\x22\xf0\xef\x10\x5c\x8b\xb4\x92\xce\xca\xc5\xed\x23\xae\xdf\x53\
\x88\x69\x2b\x44\x1a\x93\x53\x11\xe3\x56\x6c\xed\xed\x01\xfc\x94\
\x90\x07\x08\xb8\x0a\x78\x90\xc0\x31\x7d\xe1\xfd\x10\x1c\x1f\x1b\
\xbf\x14\x32\xeb\xbd\x1c\x09\x16\xd6\xa3\xa0\x49\x65\xc6\xa4\x67\
\x89\xbc\xde\x37\x55\xec\x40\x0c\x69\x43\xe0\xf6\xf2\xf8\xbe\x9c\
\x26\xda\xeb\x5f\x45\x42\xc5\x87\x62\xfd\x7f\x0a\x12\xd4\x34\x43\
\x02\xa8\x97\xd1\x9c\x1a\x8d\xc6\xff\x62\x24\x30\xd9\x40\xb4\xa6\
\x32\xe8\xbc\x39\x03\xcd\xe9\x2a\x24\x24\x29\x43\xd6\x19\xff\x45\
\xed\x33\x26\x20\x72\x50\xf6\x2c\x12\x8e\x74\x45\x63\x50\x68\x6d\
\x5c\x8b\xe6\xe4\x2c\x74\xe6\x3c\x66\x65\xa5\x63\xf9\x34\xf4\x8c\
\xf4\xf0\x88\x63\x8b\x7d\x1a\x02\xb7\x8f\x3a\xb8\x79\x17\xa2\x7d\
\xf5\xd3\x48\xc9\xd0\x1b\xed\x71\x8f\xa0\x73\x73\x0d\x3a\x53\xdc\
\xde\xf2\x32\xb2\xae\xa9\x24\xb2\xc8\x2b\x46\xb4\xde\x6a\x22\xe1\
\x6e\x80\x84\xcd\xb7\xa1\xf5\x7e\xba\xd5\x75\x1d\x35\xd7\x50\x81\
\x95\x31\x0d\xad\xcf\x29\xe8\xfa\xd9\x44\x64\x6d\xe7\xe1\x41\xba\
\x47\xeb\xa2\xbb\xaf\x19\xde\xae\xb8\x65\x91\xb7\x12\xf0\x38\xf0\
\xc8\x64\xe1\xc5\x85\xa5\xbb\xe6\x6d\x28\x7f\x88\x48\x0a\x18\xc7\
\x36\xa4\xa5\xea\x8c\x36\xbc\xcd\xe8\x3e\xdd\x12\x64\x1a\xdc\x19\
\x6d\x86\x6f\x20\xc2\x76\x21\x91\xe4\xb1\x2e\x2c\x41\xc4\xee\x30\
\xc4\xa0\x3e\x6c\xef\xad\x8d\xd5\x63\x87\xe5\xbb\x0e\x69\xd9\x36\
\xa1\xcd\x76\xa5\xa5\x59\x47\x74\xf7\x76\x07\x92\x64\xee\x42\xf7\
\x5e\x9c\x26\x77\x31\xda\x6c\xb7\x22\x26\xbe\xd4\xca\xda\x84\x88\
\x9f\x39\xd4\x94\xfa\xef\xb0\x3a\xf4\x40\xda\xac\x49\x96\xcf\x5a\
\xb4\x51\x2f\xb0\xba\xa4\x90\x76\x6c\x11\x22\xb2\x8a\xad\x7f\x5e\
\x43\x8c\x77\x88\x34\x59\xf3\xad\x4e\x55\x48\xc3\xe5\xd1\x78\x8c\
\x42\xf3\xb2\x76\x08\xaf\xd3\x6f\x0b\xd1\x1c\x5d\x85\x98\x86\x89\
\xc0\xcf\x08\x83\xf9\x16\xe3\xb5\x14\x31\xa0\x1b\xd1\x1c\x98\x4c\
\xa4\xc5\x9c\x42\x35\xeb\x10\x41\xf0\x11\xe0\x77\x14\x54\xbd\x45\
\x98\xce\x42\x38\x0d\x02\x37\x37\xff\x89\x84\x1c\x6f\xd9\x7b\x73\
\xd1\xdc\xa8\x22\x08\xa6\xa2\x35\xb0\x1b\x78\x9a\x30\xfc\x0d\x41\
\xb0\x0d\x1d\xf6\x25\xe8\x9e\xd7\x32\xe0\x1e\x82\x70\x16\x61\x2a\
\x20\x60\x08\x70\x2a\x84\xff\x45\x2a\xb5\xc2\x4c\xac\xa5\x2d\x7e\
\xfb\xbe\xd5\x9c\x7e\x1b\x68\x0e\xbd\x6d\x9a\xc0\xe9\xf6\xff\x38\
\x24\xcd\x9f\x06\x2c\x26\xa0\xd4\xda\xf3\xa1\xb5\x69\xb2\xf5\x45\
\x05\xf0\x0e\x15\xbb\xdf\xa5\xa0\x60\x1a\x04\x95\x68\x1e\x3f\x08\
\xd9\x45\xbc\x73\xbf\x34\x8a\xa7\x7f\x72\x17\x04\xa7\x02\xdd\x09\
\x79\x9c\x20\x58\x8c\xd6\x44\x57\xe0\x6d\x08\x7f\x0b\xc1\x52\x08\
\xdf\x32\x0d\xe6\x1a\xe0\x11\x08\xa7\x11\x04\x19\xfb\x7f\x92\xf5\
\xf9\x3a\xb4\x96\x5e\x04\x9e\xa7\x2c\x58\x41\x33\xa6\x20\xe6\x63\
\x11\xba\x73\x3c\x25\x36\x4e\xcb\xad\x1d\xeb\x63\xf5\x5e\x03\xac\
\x85\xf0\x5f\x54\xb1\x89\x54\x50\x66\x7d\xbe\x03\x11\x61\x8f\x02\
\x53\x79\xfb\x3e\xa7\x39\xb4\xf1\x0f\xd6\x5a\x1f\x3f\x41\x48\x29\
\x64\x97\x10\x04\x1f\x22\x2d\xfc\x6b\x88\x49\x99\xae\x36\x51\x84\
\xf6\xb0\x71\x84\xfc\x99\x80\xb5\xc6\x0c\x6f\x51\xd9\xfc\x9a\x30\
\x7c\x1e\x82\xdd\x04\xbc\x83\x88\xbb\x85\x6a\x37\xb3\x81\xa9\x04\
\x7b\x1c\x01\xce\xb6\xef\x6f\x23\x46\x69\x33\x22\xfc\x9e\xb5\xfe\
\x9e\x8b\xf6\x9b\x0d\x48\xab\xf3\x0c\x30\x81\x80\x5d\x68\x0f\xfc\
\x1f\x76\xef\x7a\x8f\xc2\xa2\xc0\xda\xfe\x06\x21\x9b\x09\x58\x61\
\xfd\xd6\x03\xed\x67\xf7\xd8\xb3\xeb\x90\xb0\xe1\x5e\xde\xbe\x6f\
\x17\x87\x0e\x05\xe8\x0e\xf4\x34\x72\x9f\x21\x7b\x8b\x4d\xd6\x57\
\x4e\x43\x14\x22\x01\xc2\x3a\x34\xef\xcf\x46\x57\x69\xd6\x5a\xfb\
\x7b\xdb\x78\x17\x21\xc1\xe5\x0a\xa4\xf1\x72\x3e\x2e\xe6\x22\x61\
\x4e\x85\xe5\xbd\x10\x31\xa7\x6b\xac\x4f\xdf\x45\xda\xe5\x81\x48\
\xe3\xf6\x94\x8d\x6d\x88\xe6\xd9\x7a\xab\x47\x29\x3a\x8f\x4a\x61\
\x8f\x97\xf3\xbf\x5a\xbd\x2a\xec\x9d\xb7\x91\xc0\xab\x07\x9a\xfb\
\xe3\x88\x2c\x39\x96\x59\x3e\xbb\x91\x26\xad\x21\xe7\xa4\xc7\xd1\
\x83\x12\x24\xf0\x7a\x89\xc6\x87\xe1\x0a\x11\x9d\xb4\xc4\xfe\x77\
\x9a\xd8\xf9\xe8\xec\x5a\x87\x84\x79\xce\xe1\xdb\x07\x68\xed\x0e\
\x43\xb4\xd2\x2b\xf6\xfe\x24\xfb\x7f\x18\xda\xc3\xa6\xa2\x3d\x78\
\x0d\xa2\x83\xb6\xa1\x3d\x75\x15\x5a\x1b\x9b\x11\x9d\xb5\x04\x09\
\xab\xca\xd1\xfa\x71\x74\xda\x4e\xb4\x36\xdf\x41\x16\x38\xfd\xd0\
\xfa\x7b\x11\x7f\x7d\xec\x68\x87\xbb\x7b\x3e\x3e\x18\xd9\xb3\x64\
\xdb\x03\x37\xf6\x6f\xd3\xa5\x65\x81\x85\x90\xf4\xf0\x38\x70\xa8\
\xa8\x0e\xb9\xe3\xd9\x15\x9b\x1e\x9b\xb3\xf5\x32\xb4\xc9\x79\x78\
\x34\x75\x7c\x1f\x31\x4e\x0f\xd4\xfa\xa5\xbe\x78\xbd\xf5\xe3\x36\
\xe4\x3c\x24\x0b\x5c\x03\x99\xa5\xdc\x73\x41\xcd\xf8\xbb\xf9\x90\
\x33\x36\xed\x9e\xf8\xaf\x7f\x42\x1a\xa7\xd3\xd9\x63\x26\x19\xa6\
\x20\xf8\x0e\xb2\x40\x98\x41\xc8\xc7\xb9\x77\xf4\xf6\x1a\x79\xe4\
\x8b\x77\x4b\xbe\x62\xea\x40\xa6\x1a\xd2\x09\x65\x5b\x36\xab\x38\
\xc7\x00\x63\x27\x01\xd9\xab\x91\x83\xa7\x1b\x20\x5c\x5e\xcb\x60\
\xe2\x9e\xf3\x6a\xf7\x45\x98\x85\xa0\x1e\xc1\x6d\x01\x91\xa1\x6b\
\x43\x50\xa3\xdd\x39\xe2\x09\x27\xd3\xc6\x91\xec\xbf\x78\x7c\xe1\
\xfa\xfa\xf0\xde\xd1\xb5\xe3\x08\xbb\x58\xc9\x39\xe3\x3c\xc7\xba\
\xa2\x21\x63\x90\x7c\x97\xc4\x3b\x99\x8c\x8d\x51\xae\x7e\xa8\x01\
\x77\x5f\x79\x3a\xf0\x63\xee\x19\x7d\x28\xcd\xa3\x8b\x91\x43\x9e\
\xdf\x23\x66\xf8\x40\xa1\x3b\xd2\xe2\x77\x41\x66\x9c\xe5\xc8\x9a\
\xe8\x06\x60\xec\x21\x6c\xbf\x87\xc7\xfe\x40\x27\xe4\x48\xf1\x4e\
\x24\xe4\xf1\xf0\x38\x9a\xd0\x15\x45\xcb\xf8\xae\x37\x8d\xf6\xf0\
\xf0\xf0\xd8\x57\x24\x99\xa2\xbd\x81\x18\x8e\xe5\xe8\xee\xe9\x78\
\x02\x96\xf1\xcb\x0b\x2c\xdf\xf3\xf6\xbd\x7c\xe5\xfb\x34\x12\x34\
\x65\xf6\xa4\x19\x3b\x21\x44\x92\xf8\xdf\x22\x47\x5c\xdb\x73\xe6\
\xd1\x98\x36\xed\x15\x76\x00\x2d\x5e\x45\x92\xfa\x74\xde\x36\x37\
\xb4\x2f\x1a\x8b\x7d\xed\x87\x64\xba\x7b\xf7\xb2\xbe\xf7\xe6\x29\
\xe7\xa0\x8d\x43\x03\xca\xbd\x73\x42\x9a\x20\x78\x96\x48\xe3\x78\
\x34\xa0\x18\x89\x53\x7e\x47\x74\xe7\x76\x25\xd2\x26\xb9\xfb\xbe\
\x1e\x1e\x1e\x1e\x1e\x87\x31\x3c\x23\xec\xe1\xe1\xe1\x71\x28\x20\
\xed\xdb\x44\x64\xda\xbb\xbf\xf1\x5c\xed\x47\x61\x68\x1e\x99\x85\
\x7b\x47\x1f\xe2\xf6\x5f\x06\x63\x27\xee\xc4\x3b\x76\x6b\xfa\x08\
\x82\xed\xc8\x2b\xf9\xa1\x63\xd0\x0f\x3e\x96\x02\xf7\x24\x9e\xad\
\xc2\x5f\x39\xf1\xf0\xf0\xf0\x38\x62\xe0\x19\x61\x0f\x0f\x0f\x8f\
\xfd\x8b\xb8\xb6\x28\xfe\xdd\x79\x70\x8d\x34\x49\xf5\x33\x15\x7b\
\xaf\x79\xca\x97\xe7\x3d\xe7\xef\x6d\x39\x07\x4a\xeb\x15\x79\x5d\
\xbf\x67\x74\xd8\x80\x74\x07\x02\xf9\xc6\xe8\x50\x94\x71\x20\xca\
\xdf\x97\x3c\xf3\xbf\x53\x7b\x4e\xc5\x3d\xe7\x1f\xaa\x31\xdc\x5f\
\x70\x8e\xa9\xe0\xd0\x6a\xbb\x0f\x64\x5f\xa5\x89\xa2\x1b\x1c\x6e\
\x88\x8f\x4f\xcd\xfd\xb3\xe6\xef\xf1\x10\x73\x61\x3d\xf9\x24\x71\
\xb4\x58\x39\x1c\x48\x38\xa7\x90\xa0\xfe\xdc\x97\xb9\x7c\x38\xec\
\x17\x1e\x47\x18\x3c\x23\xec\xe1\xe1\xe1\xb1\xef\x38\x09\xf8\x28\
\xba\x6b\xb2\xc1\x9e\xdd\x8a\x9c\x75\x6c\x43\x8e\x3c\x1e\x46\xf7\
\x0a\xcf\x42\xce\x6e\xde\xaf\x27\xcf\x51\xc8\xd1\xd2\x52\x14\x06\
\xe8\x77\x79\xd2\x5d\x8d\xbc\xce\x4e\xd8\x0f\xed\xf8\x24\xf2\x34\
\xfc\x1b\x44\x30\xb7\x42\xde\xa8\xff\x81\xbc\x10\x6f\x43\x21\xc5\
\x1a\x8b\x3e\xc8\x41\xc5\x13\xd6\x6f\x0f\x93\xdb\x33\xe9\xb1\x28\
\xc4\xd9\x43\x34\x9e\x48\x1d\x06\x7c\x01\xf8\x1f\x22\x27\x2a\xd7\
\x23\xdb\xec\x15\x68\x0c\xff\x89\x3c\x46\x3b\x6f\xbf\xfb\x03\xd7\
\x58\x79\x01\x72\xb2\xf4\xaf\x3c\xe9\xae\x47\x8e\x63\x26\x37\x30\
\xdf\xfa\x70\x2e\xf2\x1a\xfe\x23\x1a\xee\xe1\xf9\x1c\x14\xdb\xf6\
\xef\x0d\x48\x3b\x02\x85\x09\x7b\x05\x39\x65\x7b\x80\xda\xa1\xc2\
\x5c\x3d\x3a\xa2\xb1\x6e\xaa\x38\x11\x85\xe7\x73\x84\x7b\x19\x72\
\x2a\xf6\x3a\x07\x9e\x20\x4f\xa1\x3d\x61\x05\x5a\x73\x37\x00\xff\
\xc7\xfe\x65\x58\x3b\x23\xaf\xd2\x65\xe8\x4a\xc4\xa1\x74\x72\x56\
\x1f\xce\x42\x4e\x05\x17\xc6\x9e\xf5\x24\x0a\x17\x15\xa2\x79\x36\
\x1e\x39\x84\x4b\xa3\x3d\xf0\x1c\x44\xcb\xce\x46\xfb\xd5\x10\x14\
\xa7\xfb\xff\x88\x1c\x22\x75\x07\x3e\x63\xff\x0f\x44\x8e\xce\x0a\
\xac\x3f\x36\x21\x4f\xf3\x9b\xf0\xd8\x57\x5c\x8e\xc6\x62\x1b\x91\
\xb7\xe6\x29\xc8\x11\x5c\x43\x9d\x52\x95\xa0\x73\xe8\x5f\x34\x2c\
\x06\xb8\x87\xc7\x7e\x81\x77\x15\xed\xe1\xe1\xe1\xb1\xef\xe8\x82\
\x18\xc6\x2f\x10\x85\x8f\x38\x1e\x79\xf4\xde\x81\x18\x91\xd6\xc8\
\xe3\xee\x2b\x44\x5e\x35\xe3\xd2\xf3\x38\x52\xc8\x2b\xed\x60\x44\
\xf4\xad\xc9\xf1\xbb\xc3\x26\xa2\x90\x2e\x90\x5f\xe3\xd1\x90\x7d\
\xfe\x58\xe0\x3b\x88\x09\x07\x11\x8a\xa7\xa3\xb8\xc1\x9b\x10\x81\
\x53\x57\x7e\x75\xb5\x27\xfe\xbd\x0d\x62\x3c\x43\x6b\x5b\x75\x9e\
\xb4\x3b\x89\xbc\xe7\xd6\x55\x6e\x43\x42\xc3\x74\x40\x0e\xc2\xbe\
\x4a\x14\x73\xf5\x18\xeb\xe3\x9d\x68\x8c\xda\x5a\x9a\xf6\xb1\x76\
\x24\xfb\x33\x57\xf9\xb9\xfa\xdc\x3d\x1b\x8a\xc6\xb2\x8c\xda\xcc\
\x75\x3c\xaf\x0d\xc8\x33\x70\x5d\x79\xe6\x2b\x3f\x89\x42\xc4\x80\
\x9f\x8c\x84\x28\x75\xe5\x11\xff\xde\x1b\x85\xe0\x8a\xff\x96\xaf\
\x0e\x9d\x11\x33\x5c\x89\x18\xf8\x6c\x9e\x3c\xb7\x51\x9b\xa0\xdd\
\xd7\x31\x3c\x50\xe8\x8e\x08\xf0\xdf\x20\x07\x5c\x33\xd0\x3a\xe8\
\xd3\x80\x3e\xcb\xd5\x3f\x7b\x33\x5f\x9a\xa1\x30\x4c\xbd\x91\x17\
\xe8\x55\xd4\x64\xbe\x1b\x3a\xdf\x92\xbf\xc7\xdf\x3b\x15\x31\x93\
\x8f\x13\xdd\x73\x8e\x23\x9e\x36\xdd\x80\xfc\x82\x3c\xdf\x5d\x5e\
\xfb\xba\x76\x5c\x48\xc0\x81\x89\xf7\xda\xa1\xb1\xf8\x2b\x1a\x9f\
\x97\xd0\x3a\x1e\x81\xc2\x0d\x5e\x8b\x18\xa7\x07\x90\x67\xed\xcf\
\x23\x4f\xc2\x17\x21\xc1\x8e\xc3\x68\x34\xd6\x8f\x59\x3e\x73\xec\
\xf9\xaf\xed\xdd\x32\x3c\x1a\x83\xc1\x68\x0f\xfb\xa3\x7d\x9e\x43\
\x61\xe7\x4e\x8a\xa5\x49\x86\x29\x83\x9a\x73\xa6\x08\xed\x5b\xf1\
\x18\xef\x1e\x1e\x07\x1c\x5e\x23\xec\xe1\xe1\xe1\xd1\x38\x4c\x41\
\x1a\x88\xd1\x28\xb4\x43\xd6\x3e\x2d\x90\x67\xce\x2b\x11\xe3\x75\
\x26\xf2\xba\x7b\x11\xd2\x7e\xec\x42\x4e\xab\xa6\xa3\xf8\xb9\x1f\
\x47\x7b\x72\x27\x14\x72\xa2\x99\x7d\xef\x80\x88\xc4\x00\xc5\x2b\
\x9d\x8a\x88\xbf\xb6\x56\xfe\x08\x24\x91\xcf\x22\x26\xe5\x29\xa4\
\xd1\x1a\x88\xb4\xae\xed\x90\xb6\xe4\x5f\xe4\x0f\x93\xb1\x1b\x85\
\x62\xf9\x02\x0a\xff\x52\x89\x34\x53\x59\x2b\x27\x40\x84\xca\x75\
\x28\x8e\xea\x2e\xcb\x6f\x05\xd2\x3e\x0e\x42\x84\xce\x0b\x28\x54\
\xc5\x17\xad\xfe\x5b\x11\xf1\x79\x03\x0a\x5d\x51\x41\x14\xfb\xb6\
\xb3\xe5\xf9\x19\xc4\x80\x76\x46\x4c\xe1\x9f\x91\xa3\xa2\xf6\xd6\
\xf6\x2f\x22\x22\xab\x9f\xf5\xd5\x23\xd6\xb7\xb7\x58\x1b\x37\x20\
\xcd\xf2\xca\x3c\x6d\x0b\x50\xc8\x8c\x11\x28\xc6\xeb\x73\xd6\xae\
\x0c\x22\xba\x3a\x20\xa6\xff\x24\x6b\xcb\x1b\x48\x9b\x99\x42\x71\
\x64\xd7\x5a\x59\xad\x91\x36\xff\x31\x24\xec\x18\x6d\x6d\x6e\x6f\
\xe3\x38\x39\x96\xc7\x6e\xa4\x99\x9a\x8f\x18\xad\xb6\x88\xa0\xbf\
\x15\x31\x3b\x9d\x51\xcc\xcc\x97\xed\xfd\xdd\x28\x6e\xe6\x48\xeb\
\xb7\x56\x48\x1b\x3e\x13\x31\xd4\x37\xdb\xb3\x99\x88\xa9\xc9\xa7\
\xd9\xeb\x6f\x73\xe4\x8f\xc0\x25\x56\xaf\xdd\x56\xa7\x8e\x56\x87\
\xf5\x48\xeb\x76\x96\xcd\x07\xa7\x85\xcc\x20\x46\xfa\x52\x6b\x7f\
\x35\x12\xde\x8c\x47\x1e\x36\x3f\x85\x04\x19\xcd\x6d\x7e\x14\xda\
\xfc\x2c\x46\x5e\x94\x2b\x11\x53\x37\x1f\x69\x96\x5b\x5a\xfa\xfe\
\x56\xff\x2a\xc4\x8c\xbc\x8e\x9c\xb9\x75\x45\xb1\x9e\xbb\xa1\x50\
\x3f\xff\x60\xff\x68\xe5\x7a\x21\x2b\x80\xe9\x0d\xcc\x6f\xbd\xa5\
\xc5\xfa\xe5\x26\x34\xaf\xae\xb2\xfa\x97\xd9\x58\x5c\x62\xe3\x5b\
\x6a\x75\x6d\x83\xd6\xc2\x1f\x6c\xae\x7c\x9e\xc8\x3a\xe3\x66\x1b\
\xf7\x69\x48\x23\x7e\xba\x7d\x8a\xec\xbd\x47\xec\x9d\x53\x6d\x2c\
\xff\x6c\x73\x02\xc4\x0c\x5c\x67\xf3\x60\xba\x8d\xf7\xe9\xc0\x69\
\xb1\xf7\x15\xca\x2b\x42\x80\x34\xa3\x97\xa3\x39\xf9\x26\x9a\xf3\
\xd7\x59\x5b\x4e\x44\x8e\xf9\xb0\x79\xf0\x79\x4b\xb7\xc6\xc6\xe2\
\x7a\xc4\xcc\xc4\xd7\xd2\x19\xd6\x07\x85\x36\x07\x3e\x40\x5a\xbf\
\x3f\x58\x9d\x3f\x8f\xd6\xc7\x48\x1b\xe3\xb4\xa5\x19\x64\x73\xe4\
\x55\x14\x0e\xea\x16\x34\xff\x67\x59\xbd\x8f\x43\xeb\xb0\xda\xe6\
\xcf\x63\xd6\xa7\x27\x59\x1e\xef\x53\x53\x00\xb8\x15\x85\x8b\x2b\
\x47\xf3\xff\x7a\x2b\xaf\x9d\xd5\xe3\x03\x22\x4d\x72\x6f\xa2\x30\
\x82\xa3\x50\xe8\xb4\x66\xf6\xfd\x79\xa2\xf8\xd2\xfd\xad\xbf\x67\
\x36\x72\xae\x1d\xa9\x08\xd0\xfe\xd5\x03\x9d\x0b\x3b\xeb\x49\xef\
\xe2\x8b\xbb\xfe\x5d\x8b\xc6\xa6\x2d\xda\xdf\x3e\x8a\x04\x13\x29\
\xb4\x27\xbd\x8d\xce\xc5\x33\x2c\xfd\x53\xe8\xdc\x69\x86\xf6\x84\
\x0e\xe8\x6c\xb9\x0f\x2f\xa4\xf0\x38\xc0\xf0\x52\x17\x0f\x0f\x0f\
\x8f\x7d\x47\x0a\x11\x5b\x0f\x00\x5f\x42\x44\xa6\x33\xb3\xec\x86\
\x34\xad\x6f\x23\xc2\xec\x69\x44\x34\x7e\x04\x11\xd6\x53\x81\x7f\
\x43\x0c\xde\x5d\x88\x90\xf8\x17\x22\xf0\x0a\x2c\xaf\x53\x10\x51\
\x79\x15\x22\xf6\x1e\x46\x1a\xbf\xb3\x10\xe1\xda\x17\x31\x17\x97\
\x20\x22\xfc\x2d\xa4\x31\xe9\x09\x7c\x13\x11\x24\x7f\x43\x4c\xe0\
\x4d\xf5\xb4\xe3\x19\x44\x7c\xc4\xb5\xdb\x21\x62\xc4\x7a\x21\x0d\
\xe3\x25\x28\x8c\xce\x5c\xa4\x91\x39\xc9\xda\xf9\x67\x6b\xcf\xe7\
\xac\xde\x97\x21\x8d\xe0\xb3\x56\xee\x00\x44\xd4\x54\x22\x06\xa1\
\x19\x22\xec\x5b\x20\xa6\xab\xab\xf5\x61\x77\x14\x52\xaa\x0b\xd2\
\x50\xb6\x40\x04\xd3\x3a\xeb\xb3\xeb\xad\x4f\x6f\xb3\xb6\xff\x05\
\x11\x5c\x63\x11\x43\x96\xaf\x6d\x2b\x10\x73\xf8\x39\x44\xdc\xb9\
\x31\xea\x64\xe5\x7c\x80\x88\xb8\x71\x88\x08\xbb\x08\x31\xcc\xab\
\x81\x6f\x23\xe2\xfa\x3e\xab\xf3\xd5\x96\xc7\x85\x96\x7e\xba\xf5\
\x59\x5f\x1b\xcf\xf7\x90\x40\xa0\x33\x91\x59\xf4\x31\x88\x81\xb9\
\x1a\x09\x25\x9e\xb1\xba\x0c\xb5\x4f\x4f\xc4\x40\x9c\x6d\xbf\xad\
\x44\x02\x80\x4e\xc0\xb7\x90\x25\xc1\xfd\x88\x70\xfc\x48\x1d\xe3\
\x78\xa1\xa5\x7d\x1c\x31\xce\x27\x5b\x3b\xcf\xb2\x31\x78\xd0\xca\
\xb8\xd0\xe6\xd2\x20\xc4\x80\x3b\x46\xf8\x4c\x24\x90\x79\x1c\x31\
\x32\x5f\x45\x8c\x8b\x9b\x13\x0f\x5a\x3f\x17\x58\xfe\xa7\xd8\xff\
\x17\xd9\xef\xae\x8e\x57\x12\x31\xa4\x6d\x81\x2b\x10\xd3\xf1\xbc\
\x8d\x5d\x3f\x1b\xb3\x94\xcd\x9d\x8e\xc8\xb2\xa2\xb1\x34\x49\x11\
\x32\xa5\x7d\x06\x99\x3c\xd7\x17\x60\x2a\x24\x5a\x67\x27\x01\x9f\
\xb0\x77\xd6\x59\x1b\xb6\xa3\x75\x7b\x39\x62\x34\xef\x43\xeb\xfd\
\x9b\xd6\x5f\xe7\xa3\xf9\xdf\xd7\xfa\x38\x05\xdc\x8d\xd6\xc7\x03\
\xf6\xfb\xc5\xf6\xfb\x28\x9b\x53\x1f\xd8\xd8\xae\x45\xb1\x52\x5f\
\xb1\xbc\x4e\xb7\x3e\xbb\xdb\xe6\xd0\x83\x48\x28\x71\x79\xe2\xfd\
\x05\x36\x1e\xcd\x63\xed\x18\x8c\xe6\xde\x78\x64\xe6\x7f\xab\x8d\
\xdb\xeb\x68\x5d\xbe\x49\xa4\x6d\x6e\x8e\xe6\xe1\x72\x34\x7f\x3f\
\x69\x73\xe3\x2f\xd6\xde\xb1\x68\x4e\x8e\xb5\xf7\x1f\xb7\x39\x33\
\x08\x31\xee\xce\xaa\xe2\x14\xb4\x57\x8d\x44\xcc\xf6\xa3\xd6\xff\
\x97\x59\x3d\x57\xa0\xb5\xb3\x0a\xed\x41\x27\x23\x0d\x6e\x37\x9b\
\x2f\xaf\x22\x66\xfd\x0e\x74\x3d\x62\x11\xda\xc3\xe2\xc2\x8b\x10\
\x09\xa0\xdc\xf8\xdc\x60\x7d\xb4\x10\xed\x2d\x15\x36\x26\x7f\x8c\
\xb5\xa9\x0a\x69\x8e\xcf\xb4\xfa\x0c\x44\x73\x35\x7e\xf5\x20\xb5\
\x1f\xe6\xda\x91\x8c\xf6\xe8\x4a\xce\xb3\x68\xcc\x1a\x82\xf3\x80\
\xaf\x03\x3f\x00\x7e\x8a\x62\x57\xbf\x83\xc6\xae\x35\x1a\xa3\xb9\
\x68\xee\x0e\x42\x0c\xef\x0b\x48\x90\x3c\x1a\xcd\xab\xf6\x68\x3f\
\xbf\x1f\xad\x87\x73\x0e\x75\x47\x78\x1c\xf9\xf0\x1a\x61\x0f\x0f\
\x0f\x8f\xc6\xc1\x49\xb9\x4f\x45\xcc\x8d\xdb\x57\x43\x44\xe0\x6e\
\x44\x4c\xe1\x6a\x44\xd8\x76\x21\xd2\xb4\xf4\x40\x4c\x6a\x3b\x24\
\x15\xff\x10\x11\x91\x25\xf6\x7e\x16\x11\xe6\x0b\x10\x51\xb2\x09\
\x11\xb5\x27\x23\x8d\x8a\x33\x4b\x7d\xdb\x3e\xcb\x91\x06\x66\x30\
\xd2\x02\x95\x21\xc2\xb1\x13\x22\x6e\x53\xe4\xbf\x73\x5b\x01\xfc\
\x0a\x11\x40\x17\xc4\xd2\x39\x0d\xf7\x59\xc0\x24\x64\x3e\x3a\x03\
\x31\xb3\xcd\xed\xef\x59\x96\x7f\x47\xc4\xbc\x96\x22\x42\x77\x25\
\xd2\x9e\x3e\x8a\x34\x42\x01\xd2\x24\x41\x74\x17\xb2\x14\x69\xcd\
\x9c\xd6\xfa\xb3\x88\x88\xca\x58\xfa\xe5\x88\xb0\x2d\xb5\xfe\xe9\
\x81\x98\xe7\x9d\xc0\x8d\x44\xe6\x93\x2d\xc9\x6d\xfe\x09\x62\xd2\
\x5e\x44\x44\xfb\x97\x88\x4c\xb2\xdd\x18\x6d\xb3\xbe\x5a\x8b\x98\
\xf1\x39\x88\x48\x1f\x6e\xe3\xb3\x09\x31\x6f\x1d\xad\x9d\x73\x11\
\x61\x3d\xd5\x7e\xbb\x1c\x31\xbb\x59\x1b\xbf\x9d\x44\xda\x41\xd7\
\x7f\x29\xc4\x34\x8f\x43\x02\x81\x2b\x2c\xef\x8c\xd5\xa3\xda\xfa\
\x6c\xa6\xa5\x3d\xdb\xca\x3c\xc1\xe6\xd0\x80\x58\xf9\xb9\x50\x82\
\x98\xae\x65\x36\xcf\x8a\x6d\x9e\x4d\xb1\xfa\xbc\x8e\xb4\x6d\xab\
\xed\xd9\xfb\xd6\xb7\x1d\x88\x4c\xec\x9d\xd5\xc2\x5b\xf6\xff\xc5\
\x88\xc0\x1d\x8a\xee\x1c\xcf\xb1\x79\x7a\x5e\xac\xef\x02\xa4\x49\
\x7c\x02\xdd\x6b\x7f\xd1\xf2\x79\x3b\xf6\xfb\xfb\xd6\x1f\xcd\x11\
\x23\xdc\x1f\x11\xc8\x0b\x90\xa0\xa4\x87\xd5\x37\x4d\xe3\xee\x84\
\x3b\xcd\xd4\x7a\x1a\x76\xd7\xdb\x09\x7a\xbe\x60\xdf\xb7\x02\xff\
\x69\x7d\xb4\x0d\x31\x96\xcb\x11\xe3\xdb\x05\x31\x05\xcd\x89\xae\
\x3e\x2c\x42\x04\x7b\x2b\x34\xbf\x8b\x11\x03\xba\x06\x09\x01\x3a\
\x58\xfe\xeb\xad\xff\x67\xa0\x39\x7a\x81\x8d\x77\xa9\xcd\xb9\x0a\
\xfb\x7f\x98\xfd\xfe\x94\xf5\xdd\x73\x96\xff\x7c\xe4\x5d\x7e\x86\
\xa5\x3d\x1f\xad\x3b\x77\x37\x7b\x04\x5a\x6b\x2f\xdb\xff\x6e\x8f\
\x78\xdf\xe6\x4e\xbc\x2f\x02\x7b\xf6\xaa\xfd\x3d\xcb\xe6\xc7\x0d\
\x68\x2d\xf5\x46\xc2\x8c\xcd\x68\xdd\x81\x18\x73\x37\xbf\x1d\xdc\
\xbc\xad\x40\xfb\xc2\x02\x4b\x33\xdb\xc6\x7e\x18\x5a\xfb\x5b\xd0\
\xfa\xec\x84\xd6\xd3\x7b\xf6\xfb\x54\xeb\x17\xc7\x68\xb9\xf5\x57\
\x91\x18\x9f\x1e\x68\x4f\xa8\xb4\x7a\xfe\xaf\x95\x51\x84\x18\xaf\
\xfe\x56\xce\x65\x68\xcf\xfb\x06\x62\xc0\x3e\x8e\xb4\x9a\xe7\x58\
\xbf\xe5\xf2\x45\xe0\x91\x1b\x55\x68\x2c\xd6\xd1\xf0\x7e\xfb\x10\
\xed\x5d\x67\xa1\x71\xfe\x12\x5a\x43\xd3\xd0\x59\x37\x0a\x09\x31\
\x3b\xa0\x31\x5e\x8b\x04\x42\xef\xa3\xb5\x91\x45\xf3\xf4\x59\x24\
\xcc\x5b\x88\x04\xa4\x1e\x1e\x07\x14\x9e\x11\xf6\xf0\xf0\xf0\x68\
\x1c\x02\x74\xb0\xdf\x6b\x9f\x4e\x88\x50\x8b\xff\xee\x3e\xd5\x88\
\x89\xfa\x17\x22\xfa\x27\x21\xa2\xb9\x10\x11\xb6\x20\x62\x3a\xa9\
\xc9\x72\xe6\xc4\x20\x42\x7c\x67\xec\xff\x90\xc8\x74\xcd\x3d\xcb\
\x22\xc2\xf2\x05\x44\xcc\x74\x44\x84\x7b\x5d\x9e\x7e\x53\x48\x7b\
\xf3\x57\xa4\xa5\xa9\x4e\xa4\xab\x24\xd2\x42\xb5\x45\x52\xfc\x5e\
\x88\xb9\x7c\x0e\x11\x34\xc7\x59\xfe\x19\x44\x4c\xb9\x36\xb7\xb0\
\xf7\x9a\x51\xfb\x2e\xa2\x73\xae\xe2\xda\x16\x67\xf0\x5d\xb9\xd5\
\xf6\x9e\xf3\x1a\x5b\x8e\x18\xd1\x49\x96\x77\x2b\xa4\xcd\xaa\xcb\
\xeb\x68\x15\xba\x0b\xfa\x7f\x48\x5b\x1b\x77\x0c\x95\x4a\xbc\x5b\
\x19\xeb\xdb\x6d\xd6\xbe\x4d\x36\xb6\x5b\x11\x81\xed\x98\x90\x20\
\x96\x7f\x21\x91\xc6\xac\x19\xb5\x51\x40\xcd\x3b\xa2\x95\xb1\xdf\
\x42\x22\x93\xe7\xb8\xf7\xd5\x6d\x88\x38\xdc\x6c\xf5\xde\x1a\x4b\
\x13\x6f\xeb\x49\x36\xce\x33\x90\xc6\x65\x1e\x62\x68\xfa\x58\x39\
\x71\x21\x41\x26\x51\xae\xfb\x5b\x41\x64\x72\x0f\x9a\x8b\xbb\x88\
\xcc\xc8\x5d\xbd\x83\xc4\xfb\xa9\xc4\x18\x56\x10\xcd\xb5\x20\x56\
\x76\xdc\x73\xfa\x0e\x74\x95\x60\x3e\xd2\x96\xa7\x6c\x9c\x1b\xe3\
\x39\xb6\x1a\xf8\x31\xd2\x6e\xae\x6e\x40\x3e\x29\xc4\xf4\x3b\x87\
\x59\x6e\xde\xb5\x23\xba\x1e\x00\x1a\xdb\xf7\x10\xb3\x5f\x64\xf5\
\x5e\x83\x98\xfb\x1b\x2c\x9f\x3f\x5a\xf9\x9b\x91\x46\xba\x14\x11\
\xf8\xeb\xd1\x1a\xd9\x1d\x2b\x33\xde\x37\x71\x4f\xc8\xce\xe4\xbc\
\xc0\xca\x2e\xb1\x67\x61\x8e\xf7\xe3\xa8\x24\xda\x37\x42\xb4\x26\
\x2a\xa9\x7d\xc7\x37\x3e\xfe\xd5\xb1\x77\xa7\x58\x5d\xdd\x5a\x6a\
\x65\xe3\xec\x04\x67\xe7\xc7\xc6\x39\x6b\x75\x6c\x6d\xef\x67\xa9\
\xc9\xbc\xba\xb1\x76\x82\x85\xe7\x11\x83\xd3\x11\xed\x49\xfd\xf3\
\xf4\x45\xae\x76\xa5\x10\x83\x7d\x07\x5a\xdf\xf1\x7d\xe1\xeb\x48\
\xf8\xf0\x34\xda\x6f\x67\x22\xa7\x85\x25\x36\x06\x53\x91\xf5\x44\
\x1f\x74\x17\xd8\x7b\x23\x6e\x38\xca\x90\x93\xb5\x36\xe4\xbf\x72\
\x92\xc4\x42\x24\x5c\x79\x1d\x09\x25\xef\x40\x96\x4e\x1f\x47\x82\
\x1a\x77\x46\x0c\x44\x73\xee\xd7\x68\x4e\x9c\x83\xee\xe5\xdf\x8d\
\xe6\x91\x73\xae\x55\x9f\x35\x87\x87\xc7\x7e\x81\x37\x0d\xf1\xf0\
\xf0\xf0\xd8\x77\x38\x02\x2e\x85\x34\x71\xf7\x21\x4d\x48\x40\x4d\
\x22\xd4\x31\x7f\xe3\x91\x86\x63\x38\x62\x52\xae\x45\x0c\xd6\x2c\
\x24\x1d\xbf\x0e\x11\xd6\x05\xb1\xf7\xb3\x88\x78\xfc\x2c\xd2\xf6\
\x8e\xb0\x7c\x5c\xb9\x01\x35\x99\xcb\x02\xc4\x04\xbc\x87\x08\xd8\
\x7e\xc8\x54\xb2\xbf\x95\xfd\x43\x64\x82\x16\x47\xdc\x54\xf0\x39\
\xab\xcf\x20\x22\xe2\x37\x8d\x34\x99\x67\x59\xfd\xc6\x22\xc6\xab\
\x25\x22\x6a\x4b\xad\x4d\x6d\x63\xe9\x5d\x48\x93\x97\xac\x9d\xd7\
\xa2\xbb\xce\xed\x12\x7d\x52\x82\xee\x9f\x5e\x83\xcc\xe5\x5e\x41\
\x04\x51\xae\xb6\xa5\x89\x4c\x1f\x4f\xb7\x36\x5d\x8e\xb4\xa7\x29\
\x64\x8a\x79\x62\x8e\x31\x4a\xdb\xef\xab\x11\xc3\x32\x2c\x56\xc7\
\x34\x11\xb3\x71\x2a\x35\x9d\xb5\xac\xb0\xbe\x38\xdf\xca\xfa\x18\
\xd2\x98\x85\xb1\x34\x01\x62\x0c\x16\x23\x82\xff\xcb\xe8\x4e\xdc\
\xc5\x89\x79\x90\x41\xda\xdd\x4f\xdb\x58\xb6\x41\x4c\x58\x7c\xac\
\xe3\x79\x16\xd8\x9c\x9a\x9d\x28\xbf\x97\x8d\xe9\xf7\x89\x98\x91\
\x34\xd2\x30\x3f\x87\x4c\x13\x7f\x84\x4c\xaa\x57\x21\x4d\x59\xdc\
\x29\x4d\x9a\x9a\xf3\xd2\x95\x5b\x80\x18\xbc\xa1\x88\x78\xfd\x3c\
\xd2\xc8\x8c\x43\x02\x87\xf8\x18\x15\xc5\xde\x0f\x91\x96\xe7\x33\
\x36\x37\x2e\x42\x02\x18\xc8\x3f\x3f\xb7\x20\xe6\x6b\x14\x32\xfb\
\x75\x26\xef\x6d\xad\x5d\x71\x67\x55\x7b\x8b\x1d\x48\xa3\x54\xd1\
\x80\xb4\x71\x06\x2c\xa9\x89\x8e\x0b\x2d\xc6\xd9\x9c\x19\x8c\x04\
\x40\x97\x11\xdd\x3d\xef\x65\x63\x39\x1b\x69\xc4\x17\x21\x8d\xf9\
\x00\x64\x6a\xdd\x2d\xd6\x17\x0e\x2e\x9c\x51\x39\x9a\x73\xad\xad\
\xbc\x39\x56\xff\x3b\xac\x2f\x2f\x45\xcc\x45\x98\xe3\xfd\x38\xde\
\x45\x6b\xf1\x8b\x68\x8f\x38\xc5\xc6\x32\x17\x23\xec\xc6\x23\x40\
\x6b\xe9\x45\x64\xf2\xef\xd6\xd2\x68\x24\x4c\x71\xd6\x1b\x9f\x46\
\x77\x9e\xd7\xa1\x79\xfe\x71\xfb\xf4\xb3\x3e\x8b\xcf\xa7\xf8\x58\
\xaf\xb4\xf6\x9c\x47\xb4\x07\xe5\x5a\x3b\xae\xff\xb7\x5b\xbd\xdb\
\xe4\xa8\x6b\xae\xf1\x99\x83\x34\xf9\x63\xad\x3e\x5f\xb6\x7e\x70\
\x77\x4a\x5f\xb1\xfe\xcb\x22\xa1\x50\x1c\xde\x34\xba\x7e\x6c\x41\
\xfb\x4f\x43\xbc\x98\xc7\x05\x61\x4e\xe0\x38\x14\xed\x49\x6d\xd1\
\xd8\x6e\x47\x82\xd2\xe6\x68\x5f\xf9\x3a\xb2\xbe\xf9\x10\x09\xfb\
\xaa\xa8\xe9\x50\xcb\x8f\x91\xc7\x41\x41\xba\x47\xeb\xa2\xbb\xaf\
\x19\xde\xae\xb8\x65\x91\x9f\x6f\x1e\x07\x1e\x99\x2c\xbc\xb8\xb0\
\x74\xd7\xbc\x0d\xe5\x0f\xa1\x0d\xd0\xc3\xa3\xa9\x63\x14\x3a\xa8\
\x73\x85\x3d\x0a\x11\x23\xbb\xd8\xbe\x2f\x45\xcc\xc7\xfb\x88\x70\
\xdc\x8c\x4c\x2b\x2b\x11\x81\xbc\xc4\xfe\x1f\x66\xe9\x1f\x46\xcc\
\xd6\x4c\xa4\x85\xe9\x82\x9c\x35\xcd\x24\x0a\xc1\xb4\x11\x31\x77\
\x73\x11\x13\xf9\x30\x62\xce\xb0\xb2\xd6\x5b\x1d\x56\xd8\xb3\x72\
\x64\xde\x3a\x85\xc8\xd4\xf1\x6d\xc4\x3c\x3a\x67\x48\x6f\x23\xc2\
\x24\xde\x8e\x25\x96\x57\x06\x11\x99\x1f\x5a\x3e\xbb\x10\x03\x39\
\xc3\xea\x74\x8c\xfd\x76\x5f\xac\xde\x5d\x11\x11\x3a\x1b\x69\x06\
\xb6\x5a\x7d\x77\x5b\xbe\xa5\x88\x89\x98\x8b\x34\x35\x0b\xad\x9e\
\x8b\x91\x40\x60\x81\xe5\xf3\x06\x62\xa2\xb2\x96\xc7\x32\xa4\xed\
\x9e\x4f\xe4\xe0\x6a\x21\xd2\x06\xef\x42\x9a\xd9\x0f\xd1\xbd\xc8\
\x32\xc4\x30\x6e\xb4\xf7\xe2\x6d\xdb\x82\xee\x66\x86\xd6\xff\x2b\
\xad\x0f\xd7\x58\x39\x0b\xac\x0f\xbb\x5a\x59\x2b\xad\x6e\x55\xc8\
\xb4\xaf\x03\x62\x78\x26\x23\xc6\xa4\x1a\x31\xbd\xab\xac\x8c\x9d\
\xd6\x17\xef\x20\xc6\xa7\x84\xc8\x14\x79\x93\xd5\xa9\x1a\x09\x17\
\x16\x21\x62\xf0\xaf\x36\x66\xa1\xfd\xdd\x80\xcc\x05\xd7\x12\x85\
\xf2\x99\x61\xfd\xe5\xca\x7f\xd3\xca\x6f\x86\xee\x6b\xbf\x69\xfd\
\x50\x68\x63\xfd\x32\x91\xc6\x38\x6b\x7d\x93\xb1\xf6\x2d\xb5\xf9\
\x94\xb5\x3e\xdc\x68\xdf\x97\x5a\x99\x1b\x6d\x5e\x2c\x44\x44\x6c\
\x16\x69\x56\x97\xda\xb8\x05\x88\x41\x9d\x6a\xf5\x5a\x6a\xed\x5e\
\x89\xee\x1c\xbf\x6b\xf5\x7c\xc6\xfa\x29\xb4\xf9\xb4\xd2\xda\xb2\
\xc4\x9e\x55\x12\x99\x96\x17\x10\x69\xaf\x9f\xb2\xba\x5e\x6c\xff\
\xe7\x0b\xa1\x52\x80\x18\xd1\x69\x34\xfe\x0c\x71\xeb\x77\x51\x8e\
\xdf\x2a\xad\x1e\xbb\xac\xad\xeb\xd1\xba\xdd\x89\xd6\xe0\x06\xc4\
\x6c\x6f\x42\x02\x8d\xc5\xf6\xff\x7b\x68\x1d\xf7\x40\x1a\xe3\x89\
\xd6\xae\x75\x44\x4e\xa0\xb6\xa3\xb5\xb2\x0a\x31\x03\x8b\x2d\xff\
\x19\xf6\x7e\x4f\xa4\x2d\xfb\x57\xac\x2f\xd7\x26\xde\x9f\x4f\xa4\
\xd5\xdd\x6e\xef\x0e\x40\xeb\xe8\x41\x9b\x8f\xa1\xf5\x63\x52\xab\
\xb7\x0b\xad\xf1\x2a\x6b\xe3\x4e\x1b\xf3\xb5\xc8\x91\xd7\x87\x44\
\xda\xbb\x66\x68\xad\xcf\xb3\xb9\x31\xd0\xf2\x1c\x6f\xf3\xaa\xcc\
\xfa\x67\x83\x95\xb7\xc1\xc6\xda\xad\x9d\xf6\x36\x6f\xa6\x20\xe6\
\xd4\xad\x9d\xe5\xb1\xba\xcc\xb5\x77\xba\x59\x5e\x6e\x6f\x72\xeb\
\xc0\x5d\x95\x88\x63\x91\x95\xef\xae\x7e\xbc\x65\xe3\xe2\xb4\xcd\
\xdb\xd0\x1e\xe3\xae\x68\x24\xc7\x7d\x3d\x91\x17\xff\xa3\x11\x25\
\x48\xf0\xf1\x12\xf9\x9d\x28\x36\x14\x21\x9a\xcb\x6e\x3f\xdc\x66\
\xdf\x0b\x91\x70\xae\x2d\xb2\x66\x79\x13\x8d\xe5\x34\xb4\xe7\x1d\
\x83\xd6\xf3\xfd\x68\xcf\xae\x42\x63\xea\x2c\x4a\x96\xd1\xf0\x10\
\x70\x1e\x1e\x7b\x83\x96\x48\x68\x3b\x3e\x18\xd9\xb3\x64\xdb\x03\
\x37\xf6\x6f\xd3\xa5\x65\x01\xa1\x37\x1c\xf1\x38\xc0\xa8\xa8\x0e\
\xb9\xe3\xd9\x15\x9b\x1e\x9b\xb3\xf5\x32\x6a\x7a\xbd\xf4\xf0\x68\
\xaa\xf8\x3e\x22\xda\x1e\x38\x44\xe5\xf7\x46\xa6\x63\xdf\xa2\x66\
\x18\xa3\x7d\x41\x7b\xe4\x54\xe6\x51\x9a\x46\x4c\xd1\x02\xe0\x17\
\x88\x70\x6f\xec\x7e\x90\x46\x77\x86\xdf\xa6\x26\x23\xdc\x54\x70\
\x32\xd2\xaa\xde\x49\xe3\x63\xc5\x76\x46\xcc\xe0\x3f\x68\x98\xe6\
\xf3\x40\xa2\x04\x31\xcc\x5f\xa3\x76\xb8\xaf\xbd\x45\x0b\x64\x39\
\xf0\x22\x12\x22\xe5\x42\x31\x32\xab\xfc\x3d\x22\xa8\x3d\x3c\x3c\
\xf6\x1e\x9d\x90\xe6\xf6\x4e\x24\x00\xf1\xf0\x38\x9a\xd0\x15\x5d\
\xa5\xf8\xae\xbf\x23\xec\xe1\xe1\xe1\xd1\xb4\x51\x8a\xee\xc1\xed\
\x0f\x86\x67\x07\x0a\x57\xd2\x14\x98\x60\x90\xd6\xf1\x79\xf6\x8f\
\x75\x48\x16\x69\x93\x9b\x6a\xb8\x0d\xe7\x08\x6d\x7f\x60\x1b\x1a\
\xc7\x43\xcd\x04\x83\x34\xa7\x8f\xd2\x78\xad\x92\xcb\xeb\x69\x6a\
\x5a\x2b\x78\x78\x78\x78\x78\x78\x1c\x10\x78\x46\xd8\xc3\xc3\xc3\
\xa3\x69\xa3\x94\xe8\xce\x65\x63\x51\x49\x4d\x07\x4d\x87\x1a\x59\
\x74\xff\x72\x7f\x20\x44\x7d\xd5\x54\xe1\xcc\x9e\xf7\x07\x9a\xd2\
\x38\x56\x21\xaf\xe9\xfb\x03\xd5\x78\x26\xd8\xc3\xc3\xc3\xc3\xe3\
\x20\xc1\x33\xc2\x1e\x1e\x1e\x1e\x8d\x43\x63\xbc\xdc\xe6\xca\x0b\
\xea\xf6\xee\x9c\x4c\xe7\xe1\xe1\xb1\xef\x88\x3b\xe5\x89\x7b\x8e\
\x6e\x08\x0e\xb7\x75\xb8\xb7\x7b\x55\x53\x69\xdf\xfe\xd8\x63\xe3\
\xde\xfb\x5d\x9b\x1a\x13\xaa\xcb\x23\x42\xb2\x6f\xa1\x66\xdf\xee\
\xed\x9c\x0b\xf7\xe2\xb9\x87\x47\xa3\xe0\x19\x61\x0f\x0f\x0f\x8f\
\x7d\xc7\x10\x14\x07\xf5\x67\x44\x4e\x5a\x1a\x83\xcb\x91\x46\x6c\
\x07\x72\x2e\xf5\x8f\x3c\xe9\xae\x44\x0e\x6e\x5e\x3b\xd4\x1d\xe0\
\xe1\x71\x18\xe3\x44\xe4\x69\xb9\x14\x11\xd9\x45\xc8\x59\xcf\x83\
\x34\x4c\x33\x3d\x1a\xdd\x91\xde\x5f\x26\xef\xfb\x03\xed\x91\xf7\
\xe5\xd7\xa9\x69\x3a\x3f\x1c\x79\xa8\xbe\x9f\x86\x33\x80\xb7\x21\
\xe7\x55\xaf\x1f\x80\x7a\x9e\x84\x2c\x00\x66\xd5\x93\x2e\x40\x9e\
\xca\xe7\x22\xe7\x7d\xf5\xa1\x00\xf8\x37\xb4\x1f\xff\xc6\xda\xda\
\x1a\xf9\x59\xe8\x42\x74\x3f\x7f\x23\xf0\x73\xe4\xec\xcc\xa3\x71\
\xb8\x1c\x79\x05\x8f\x5f\xb9\x79\x14\x39\x7c\xdb\x44\xc3\xad\x7e\
\xd2\x28\xfe\xf0\x53\x44\x8e\xb7\x40\xe7\xec\x85\x68\x3c\x3d\x3c\
\xf6\x2b\x3c\x23\xec\xe1\xe1\xe1\xb1\xef\xe8\x00\x9c\x0b\xdc\x83\
\x08\x2f\x27\x15\x77\x84\xa6\x93\x62\xa7\x62\xcf\xd2\xf6\x3d\x2e\
\xdd\x76\xef\x0d\x40\x44\xf9\x64\x6a\x7b\xcb\x8c\xe7\xb1\x11\x79\
\x44\x75\xf9\xe7\xd3\xdc\xb8\x30\x2d\x1e\x1e\x1e\xb5\xd1\x03\x31\
\xb2\x3f\x47\xeb\xa4\x2d\x0a\x3f\xb5\x15\x79\x4f\x86\x9a\xb1\x8f\
\xe3\x48\x21\x47\x76\x2e\x14\x59\x5c\x63\x95\xd4\x5e\xe5\x5a\x87\
\xf9\xd6\x66\xf2\xdd\xe4\xde\x91\xeb\x9d\xf8\xf3\x63\x50\xb8\xa3\
\xc9\x44\x61\xc1\x52\x48\x70\xf6\x61\xa2\x8e\xb9\xf6\xaa\xf8\xf7\
\xe3\x13\xe5\xe5\xda\xbb\x92\x75\xcc\xf7\x3c\xfe\x6e\x80\x1c\xdb\
\xcd\x41\xde\xb3\xe3\x71\x95\x93\xf9\x38\x8f\xd9\x65\xd4\xdc\x4f\
\x73\x8d\x09\x28\x0c\xd4\x18\x6b\xfb\x33\xc8\x3b\x71\x33\x14\x22\
\xea\x77\xc8\x7b\x3c\xf6\x7b\x53\xf5\x27\x70\xb8\x61\x30\x1a\xb7\
\x5f\xc5\x9e\x7d\x88\x1c\xe8\x2d\xa7\xf6\xf9\x14\x9f\x6b\x71\x6b\
\x8c\x00\xc5\xdc\x7e\x8d\x9a\x73\x7a\x27\x35\x19\x63\xf7\x5e\xb6\
\x01\xcf\x92\xa8\xeb\xcc\x8c\x87\xba\x83\x86\xd7\x3b\x8e\x7c\x6b\
\x3d\xd7\xba\xf1\x68\x02\xf0\x8c\xb0\x87\x87\x87\xc7\xbe\x23\x44\
\x5a\x8d\x10\x79\x05\xbe\x06\x11\xd6\xd3\x90\x33\xa3\x8f\xa1\x90\
\x20\x29\x14\x0a\xe5\x2c\x44\x34\x14\xa2\xb0\x15\xe3\x50\xfc\xd4\
\x5b\xd1\xe1\xd9\xcb\x9e\xb5\x44\x04\x76\x4f\xa4\x95\xa9\xb6\x7c\
\x26\x00\xcf\xa2\x50\x39\x65\x88\x09\x3f\x07\x1d\xd0\x6d\x11\xf1\
\x3e\x15\x85\x38\xb9\xc5\x9e\xcd\x43\xd2\x79\x7f\xf7\xd2\xe3\x68\
\x40\x2f\xa4\xfd\x9c\x46\xfd\xda\x3e\x17\x5a\x6b\xa1\xfd\x9f\x42\
\x4c\x57\x27\xfb\x7e\x09\x0a\xc9\x55\x85\xee\xe9\xbf\x81\xc2\x3d\
\x7d\xd2\x7e\xef\x8a\xc2\x16\x9d\x84\xb4\xb0\x7f\x42\x5e\xad\xbf\
\x88\xc2\x63\x95\xa0\x58\xc2\x9d\x51\x88\xa4\xbf\xa3\xf0\x46\x1f\
\xb7\x67\x4b\x51\xc8\x9f\x2d\x56\x7e\x31\xd2\x88\xbd\x88\xc2\x23\
\xb9\x7c\x1f\x46\x31\xc6\x47\x20\x47\x69\x8f\xa2\xd0\x3f\x5f\xb4\
\x7a\xf4\x40\x21\x89\xee\xb3\xfa\x9e\x0a\x5c\x85\xf6\x85\x41\x88\
\x08\x9f\x8e\xf6\x83\x00\x85\x2c\xbb\x0a\xd1\x80\xaf\x23\x66\xf4\
\x26\xe0\xff\x90\x16\xf9\x63\x28\x1c\x51\xb5\xbd\xdb\x06\x31\xd7\
\x83\x10\x51\xff\xbc\xf5\xc5\x17\xd1\x5e\x55\x05\xfc\xc1\xea\x96\
\x46\xde\xd1\xbb\xd9\xbb\x8f\x21\xcd\xf9\x40\x2b\xef\x19\xc4\x1c\
\xb9\xbd\xf0\x2d\xeb\xa7\x1b\xad\xfd\xd3\x90\x46\xb0\xdc\xfa\x24\
\x40\x9a\xc5\xf5\x28\x26\xf1\x48\x4b\xd7\x0a\x59\xcc\xbc\x97\x18\
\xd3\x0b\x50\x28\xaf\x16\x28\x14\xd7\x1f\xed\x79\x05\x62\xbc\xe7\
\xee\xaf\x89\x76\x04\x23\x40\xe1\xb4\x7a\xa2\xb0\x57\x3b\xeb\x49\
\x1f\x22\x8f\xf1\xc9\x10\x83\x59\x34\x37\xce\x42\xb1\xa4\xff\x8e\
\xe6\xe0\xa7\xd1\xb8\x9c\x85\xe6\x6b\x01\x3a\xf7\xc6\xa3\xf9\x7c\
\x3d\x1a\xdf\xcd\x96\xae\x18\xad\x97\x1e\xe8\x3c\x2c\x47\xeb\xfc\
\x5d\xb4\x16\xda\xd9\xf3\xae\x88\x01\x77\xf3\x31\x97\x1f\x85\x51\
\x28\xee\x3c\xf6\xde\xa3\xe8\xcc\x1c\x85\xb4\xce\x2d\x91\xf0\xe4\
\x2f\x68\xde\x82\xe6\x6c\x2f\xe4\xa9\xff\x7e\x34\x0f\x47\x5b\xbd\
\x5f\x42\x21\xba\x06\x50\xf3\xcc\x7d\xc4\xda\x72\x33\x9a\xfb\x85\
\x68\x5d\xbf\x82\x67\x88\x9b\x14\x7c\xf0\x60\x0f\x0f\x0f\x8f\xc6\
\xa3\x08\xf8\x0c\x92\x5a\x3f\x88\x34\x29\x5d\xd0\x41\xdf\x19\x11\
\x6c\xdd\x50\xcc\xd0\x3f\x23\xe2\xe2\x4b\x48\xa3\xf4\x75\x44\x88\
\x3e\x89\x34\xcc\x58\xda\x63\x11\x31\x70\x15\x32\xd7\xfc\x27\x22\
\xaa\x8f\x47\x04\x69\x5f\x14\x9f\xf3\x5c\xc4\x1c\xcf\xb3\x3c\x3b\
\xa1\x50\x4b\x1f\xa2\xc3\xfc\x38\x44\x64\x7a\x78\x1c\xe9\x28\x02\
\xfe\x03\x31\x52\x77\x52\xf3\xce\x62\x2e\x64\xd1\xfa\xf8\x26\x0a\
\x93\xf6\x73\x7b\xe7\x59\xa4\x41\xfc\x04\x62\xe4\x5e\x01\xbe\x8c\
\xd6\x9e\x0b\x37\xf3\x28\x62\x10\x0b\xd0\x7a\x3d\xd1\xde\x2d\xb4\
\x77\xdb\x02\x77\x21\xa2\xfd\x4f\x48\xb0\x75\x9a\x3d\xab\x44\xfb\
\x40\x57\xb4\x6f\xb8\x7a\x56\x20\xa2\xff\x12\x7b\x76\x85\xd5\xf1\
\x23\xc0\xe9\x88\xb9\x5e\x0c\x7c\xc3\xf2\x1b\x8d\x62\x52\xff\x0d\
\x31\xff\xe7\x23\x46\xf2\x03\xc4\xa8\x9e\x82\x08\xf4\x47\x10\xf1\
\x3d\x02\x31\x24\x77\xa2\xf8\xc6\x8f\x23\xa6\x78\xa0\xfd\x2d\xb4\
\x72\x8f\xb7\xfc\xdd\x3d\xda\xe1\x68\x1f\xfb\x23\x62\x1a\xbe\x60\
\xed\x1b\x63\x69\x1e\x23\x62\x96\x02\xc4\x54\xb4\xb5\x72\xfb\xc4\
\xde\x7d\xd7\xfa\x71\x07\x62\x4a\x27\x5a\x5f\xdc\x8d\x04\x0a\x7f\
\xb7\x3c\x2f\x4a\x8c\x93\xdb\x4f\x07\xa0\x3d\xf5\x29\xeb\x87\xcf\
\x23\x6d\xaf\x43\x4b\xb4\x1f\x3e\x6f\x9f\x0b\x11\x93\x1d\x5a\x3f\
\xdd\x61\xf3\xe3\x3f\x10\x43\xed\x91\x1b\xed\x91\xf6\xfc\x69\x14\
\xce\xac\x3e\x64\x11\x73\xe9\xfa\xf6\x0b\x68\x2e\x39\xad\x7d\x2f\
\xb4\xce\x40\xf3\xfb\x34\x34\x27\xbe\x80\x04\x31\x2f\xa1\xf9\x5d\
\x82\x04\x18\x29\x24\xd4\x19\x88\xe2\xde\xb7\x43\x73\xb9\x15\x62\
\x46\x17\xa3\xf3\xf0\x66\x24\x4c\xb9\x0d\x9d\x9d\xf7\xa3\xb5\x38\
\x86\xfc\xfc\x4d\x5f\x34\x3f\x9f\x43\x42\x91\x2f\x59\x5d\xce\x43\
\x0c\xed\x9f\xd1\x1c\x72\xeb\x62\xb0\xbd\xd7\x1a\xad\xf1\x4e\x56\
\xef\x09\x88\x79\x3f\x1d\xcd\xcd\xe4\x99\x7b\x03\x5a\x37\x5d\xd1\
\xfa\x7f\x1b\xcd\xfd\x56\x87\x70\x5c\x3d\x72\xe0\xa8\xd5\x08\xa7\
\x82\x20\x71\xab\x3f\xac\x11\x47\x39\x08\x20\x95\x38\x43\xb3\x61\
\xb8\x5f\xc5\x38\x07\xa3\x0c\x0f\x0f\x8f\x83\x82\x6a\xc4\x88\x5e\
\x8e\x08\xcd\x77\x91\x96\x67\x37\x30\x09\x58\x84\x34\x1a\x85\x48\
\x83\x3b\x08\x11\x1b\x43\xd1\xc1\xff\x34\x22\x0e\xdd\x9d\x5f\x47\
\x80\x06\x88\x49\x7e\xc9\xf2\xba\x08\x69\x9e\xab\x63\xbf\xbf\x01\
\xcc\x44\x44\xf4\x79\x88\x58\x3c\x0e\x69\x80\x7b\xa1\x43\x7e\xf8\
\xa1\xee\x20\x0f\x8f\x83\x80\x2c\x62\x52\xd7\x51\xfb\x6a\x41\x2e\
\x04\x68\x9d\xbe\x87\x08\xde\x4b\x88\xe2\x86\x5f\x85\x34\x50\x97\
\x22\xa2\xba\x33\x5a\x7b\x1d\x91\xd0\xea\x43\xc4\x6c\x39\x46\x2b\
\x43\xa4\xe9\xa9\x46\x84\xf9\x20\x74\x6d\x62\x35\x12\x66\x75\x07\
\xbe\x47\xa4\x81\xed\x8e\xb4\x6e\xa9\xd8\xfb\x2f\x01\x5f\x45\xeb\
\x78\x10\x62\x26\xc7\x22\x62\xfb\x7a\xc4\xd0\xf5\x41\x04\xf9\x26\
\xab\xc3\x3c\xcb\xb3\x0b\xd2\x66\x6d\x43\xd7\x27\xb2\x44\xfb\x4f\
\x57\xab\xd7\x70\x74\xfd\xe2\x65\x2b\xef\x3d\x74\x07\x33\x6e\xba\
\x19\xff\x9e\xb2\xbc\xdb\x20\x06\x61\x28\x62\x36\x8a\x91\x09\xf9\
\x44\xa4\x9d\x8e\xf7\xe9\xee\xd8\xf3\x4d\x88\xd6\x1c\x65\xef\xb6\
\xb7\x3c\xb7\xd9\x58\x75\xb7\xbe\x1f\x89\x18\xde\x8e\xc0\x30\xa4\
\x85\x23\x51\x9f\x2c\x62\x40\x9c\xe6\xf1\x1c\xc4\x08\xbb\xbb\xd0\
\x23\xac\x8c\xe3\x91\x66\xfa\x58\x1b\xb3\xd9\xd6\xbf\x8b\x89\x62\
\x8c\x6f\xc1\x23\x1f\xaa\x90\x86\x77\x2d\xf9\xe3\x79\xc7\x11\xa0\
\x71\x9e\x6d\xff\x6f\xa3\xb6\xb3\xac\xf8\xff\x19\x74\x9f\x78\x21\
\xd2\x0e\xcf\x01\xde\x44\x42\xa3\x1d\x68\xec\xe7\xda\xf3\xce\x96\
\x2e\x63\xe5\x2c\x40\x0c\x6b\x15\x9a\xe3\x7d\xd0\x75\x80\xdf\x5a\
\xf9\x8f\x20\x86\xb3\x2e\x21\xd8\x9b\xe8\xcc\x2c\x47\x4c\x73\x06\
\xad\xe9\x63\x11\xb3\xdb\x19\xad\xaf\xa4\x39\x73\x16\x09\x7c\x16\
\x02\xb7\x5b\x79\x93\xd0\x9c\x3e\x9e\x9a\x67\xee\x71\x48\xd0\xd4\
\x1a\xad\x9b\xc1\x68\x6e\x97\xe0\x4d\xf2\x9b\x14\x8e\x4a\x46\xb8\
\x2a\x13\xb2\x7c\x6b\x39\x95\x99\x68\x7e\x77\x6f\x5d\x44\xfb\xe6\
\xe9\x3d\x33\x7e\xd3\xce\x6a\xd6\x6d\xaf\xda\xf3\x7b\x2a\x80\x5e\
\x6d\x9b\xd1\xaa\x28\xb5\x5f\x18\xd5\x00\x28\x2d\xcf\xb0\xba\xb4\
\x72\x0f\x03\x9e\x4e\x05\xf4\x69\x5b\x44\x8b\xc2\xfd\x53\x86\x87\
\x87\xc7\x41\x43\x80\x4c\x27\x27\xa3\x03\xf0\xf3\x88\x38\xab\x24\
\x22\xd2\xae\x47\x1a\x9b\xa7\x91\xf6\xc3\x31\xb4\x05\x88\x98\xdb\
\x81\x88\xcb\x24\x0a\x89\xa4\xdb\xc5\x96\x5f\x5c\x0b\xe2\x9c\x74\
\xc5\xef\x2c\x6d\x25\x8a\xcf\xdb\x91\xc8\x89\x89\xf7\xbc\xe9\x71\
\x24\xa3\x1a\xf8\x31\xd2\xca\xac\xa1\xfe\xb9\x1e\xa0\x35\xf2\x9a\
\x7d\x42\xa4\x35\x9c\x8e\xd6\xee\x42\xa4\x79\x0a\x10\xf1\xbc\x01\
\x09\xbb\xdc\x3a\x2d\xb6\xdf\x32\x68\x1d\x87\x48\xb0\xd5\x82\xe8\
\xca\x84\x4b\x7b\x02\xb2\x00\x29\x45\x9a\xa4\x85\x48\xd3\x05\x35\
\x99\x84\x79\x88\xd8\xfe\x8c\xd5\x6d\xb9\xe5\xff\x1e\xf0\x04\x5a\
\xfb\xaf\x22\xc1\x5a\x06\x31\x04\xae\x2d\x10\xed\x03\x4e\x1b\x57\
\x91\xf8\xbd\x0a\xed\x29\x69\xab\xe3\x45\x96\x26\xce\xf8\xb6\x8f\
\xd5\x27\x44\xda\xad\x51\x48\x53\xee\x4c\xc1\x5d\x7f\x57\x51\x1b\
\xf1\xe7\x37\x23\x2d\xee\x33\xd6\xaf\xc7\x12\xdd\xc5\x74\x02\x84\
\x0d\x48\xcb\x5b\x8a\x34\x84\xf9\x84\x18\x21\xd1\x7e\x97\x64\x74\
\x52\x48\x5b\xb8\x0c\xed\x79\x20\xc6\xf7\x1a\xa4\x21\xaf\x44\x42\
\x86\xd9\x78\xd4\x87\x32\xe0\x2b\x48\xf8\xb1\xaa\x01\xe9\x1d\x83\
\xfa\x58\x8e\xe7\x10\xad\x0f\x90\xd6\xbe\x39\x9a\xf3\x7f\x46\x02\
\xa3\x53\x80\x6f\x23\x27\x67\x55\xd4\x9e\xb3\x71\x54\xd8\xbb\xf1\
\xf3\xce\xad\x3b\xd0\x7a\x4b\xc7\xde\xcf\xb5\x07\xc4\xcf\xcc\x0c\
\xd2\x12\x7f\x1b\x09\x6f\x66\x01\x67\x12\xad\x6b\xb7\x7e\x5b\xd9\
\xf7\x0c\xd2\xf0\x76\x40\xc2\x9b\x7f\x47\x77\xa3\x37\x53\xf3\xcc\
\xdd\x89\x2c\xb1\x46\xa1\xb9\x3f\xc3\xda\x59\x9f\x95\x8a\xc7\x41\
\xc6\x51\xc7\x08\xa7\x02\xd8\xb4\xab\x9a\xcf\x3c\xb1\x9c\x55\xdb\
\xa2\xeb\x03\xff\x7d\x69\x4f\x6e\x39\xa1\x03\xd5\xd9\x90\x74\x2a\
\x60\xe6\xda\x5d\x7c\xf9\xe9\x15\x54\x54\x6b\x0d\xa5\x53\xf0\xdd\
\xf3\xbb\xf3\x99\x93\x3b\x91\x09\x1b\x4f\x47\x06\x01\x3c\x38\x63\
\x33\xbf\x78\x63\x1d\x59\xcb\x6e\x50\xc7\x62\x1e\xb8\xa1\x1f\x2d\
\x8a\x52\x9e\x54\xf5\xf0\x38\x3c\x10\xa0\x43\xb7\x10\x11\xae\x9b\
\x11\x81\xbb\x19\x31\x9f\x69\xa2\x03\xbb\x2d\x3a\xc4\xcb\x90\x26\
\xa3\x35\xb0\x12\x69\x6b\xbe\x8a\xee\x04\x5e\x86\xee\x36\x39\x42\
\x31\x8b\xb4\x23\xb7\x23\x46\xb9\x17\x92\x7c\x7f\x84\x28\xec\x4b\
\x2a\x56\x97\x02\x44\xb8\xcc\x46\x4c\xf7\x5b\xc8\xbc\xf2\x65\x44\
\x38\x7f\x0e\xb8\x97\x86\x49\xf9\x3d\x3c\x0e\x47\xec\x44\x77\x6f\
\x1b\x02\xb7\x66\x9c\x83\x9b\x87\xd0\xba\xb9\x1d\xdd\xe7\x3b\x0f\
\x11\xaf\x20\x33\xe4\xff\x87\x34\x49\x5f\x42\xa6\x8e\xd7\x23\xe2\
\x77\x39\x5a\x9b\xb7\x22\x0d\x67\x07\xa4\xad\x7a\x0b\x09\xc5\xde\
\x42\x1a\xe6\x47\xec\xfb\x79\x88\x59\x1c\x83\xb4\x5e\x53\x62\x75\
\x2a\xb7\xff\x7f\x84\x34\x5b\x95\x68\xfd\xde\x82\x98\xe4\xfe\x48\
\x53\x3d\x03\xad\x7d\x47\x58\xbb\x3d\x63\x07\x22\xc4\x4f\xa0\xe6\
\xfe\xe3\xcc\xb6\x67\x20\xc6\xf6\xf3\x56\xd6\x39\xc0\xff\x5a\xfb\
\x3f\x89\x98\x84\x41\x44\x4e\xa9\x9c\xff\x01\xa7\xad\x3b\x19\xed\
\x5d\xa9\x44\xfe\x71\xa4\x63\xf5\x6a\x6b\x79\x6e\xb7\x76\x3b\xd3\
\xd0\x32\xeb\xdb\xe9\x68\xcf\x1a\x85\x18\xd6\xab\x81\x07\xac\xad\
\x0e\xae\x1e\xc9\xfd\x2e\x5e\x76\x77\xab\xdb\xb7\x6c\x8c\x40\xda\
\xbd\x7b\x90\x36\x2e\xc5\x51\x48\xf3\x36\x02\x5b\xed\xd3\x10\xe4\
\xeb\x5b\x37\x47\x96\x20\xf3\xe5\x1b\xd1\x79\x56\x82\xe6\xd0\xbf\
\xa1\x75\xb4\x01\x69\x91\x2b\xa8\x39\x77\xe2\x63\xed\x9e\xbb\xb9\
\x10\xda\xb3\x5d\xe8\x6e\xf1\xad\x68\xdd\x5d\x6e\x79\x17\x22\xa1\
\xd6\x78\x64\xce\x4f\x2c\xaf\xf8\xbc\x49\x23\x06\xb7\x05\x3a\x23\
\xbb\x21\xc6\x38\x85\xe6\xe3\x97\xd0\xfd\xfc\x33\x2c\x4d\x5b\xab\
\xf7\x14\x4b\x5f\x8a\x04\x2e\xc9\x33\xf7\x25\xab\x87\x3b\xf3\x47\
\x21\x21\x80\xbf\x92\xda\xc4\x90\xee\xd1\xba\xe8\xee\x6b\x86\xb7\
\x2b\x6e\x59\x74\x74\x8c\x4d\x10\x48\x13\x7b\xdf\x7b\x9b\xd8\xb0\
\xb3\x9a\x8a\x4c\x48\x45\x26\xe4\xa2\x41\x6d\x38\xb1\x5b\x8b\x3d\
\x4c\x69\xab\xa2\x34\x2f\x2e\x2c\x65\x65\x69\x25\x15\x99\x90\xf2\
\x6a\x99\x4e\x5f\x36\xa4\x0d\x45\xe9\xc6\x09\x74\x9c\x36\xf8\xa7\
\xaf\xaf\x63\xf1\xe6\x8a\x3d\x75\xb8\xea\x98\xb6\x5c\x75\x4c\xbb\
\x46\xe5\xdd\xd4\x91\xc9\xc2\x8b\x0b\x4b\x77\xcd\xdb\x50\xfe\x10\
\x92\x9c\x79\x78\x34\x75\x8c\x42\x87\xf4\xfb\x39\x7e\x0b\x11\xb1\
\x30\x03\x31\xc0\xbd\x91\x09\xe2\x73\xc8\x64\xb9\x1a\x31\xba\x9b\
\x91\xc4\xbc\x39\x22\xd8\xa6\x22\x02\xf0\x03\xa4\x69\xea\x84\xa4\
\xef\xaf\x23\x89\xf4\x3a\x64\x6a\x56\x8e\xcc\xbe\xe6\xa1\x43\xf8\
\x7e\x74\xe8\x86\x88\x78\x74\x26\xa0\xab\xed\xd9\x76\x7b\xff\x5d\
\x74\x08\xf7\x41\x84\xc6\xcb\x88\x50\x69\x8f\x4c\xce\x72\x39\x11\
\xf1\xf0\x38\x1c\x50\x80\x04\x46\xd3\x68\xfc\x19\x92\x45\x0c\xeb\
\x22\xfb\xbf\x12\xad\xd3\x96\x68\xfd\xce\x41\x4c\x61\x33\x74\x27\
\x78\x01\xda\x07\x4a\xd0\x9a\x75\x26\x96\x73\xd0\x7a\x1c\x8c\xd6\
\xf4\x64\x4b\x3b\x15\xad\xdb\x3e\xc8\x62\x64\x02\xda\x2b\x0a\x11\
\x43\x3b\x1b\x69\x8b\x92\xeb\x71\x1d\x32\x4b\x7d\x15\xed\x01\x4b\
\x10\xd1\x3d\x14\x11\xd5\x0f\x5b\xbd\xab\xd1\xbe\xb3\xcb\xda\xb2\
\xca\xea\x92\x41\xf7\xa5\x3f\x40\xfb\xc5\x7a\xa2\xbd\x6a\x96\xb5\
\xa1\xbf\xa5\xb9\x0f\x09\xe1\x16\xa1\x6b\x1d\x1b\xad\xdc\xc5\x68\
\xdf\x5b\x62\x7d\xd1\x0a\x99\x5e\xbf\x6d\x6d\x5e\x8c\x98\x80\x0f\
\xa8\xed\x88\xcf\xd5\x6b\xab\xfd\x6d\x69\xef\xbe\x65\x65\x2f\xb2\
\x4f\x17\xfb\xfb\x0a\x62\x40\xba\xd9\xf7\x37\xa9\x6d\x4a\xbb\x0c\
\x99\x33\x7f\x68\x7d\x13\xc6\xca\xcf\x20\xed\xfa\x26\xab\xab\xf3\
\xda\xbb\xc5\xfa\x66\x2d\x91\x80\x70\x47\x23\xe7\xcc\x91\x82\x12\
\xc4\x34\xbe\x44\xe3\xfb\x24\x8b\x84\xba\x49\x01\x54\xc6\x9e\xcd\
\x46\xcc\xee\x00\x34\x77\xde\x41\xf3\x60\x29\x32\xcb\x2f\x41\x42\
\xa8\xf9\xf6\xce\x07\x44\x73\x7a\x25\x3a\xdf\xb6\xa1\xb9\xb2\xc3\
\xfe\x3a\x47\x5c\x0b\xec\xf7\x0c\x5a\x93\x65\x88\xb1\x7d\x1e\xdd\
\x5b\xde\x4a\x4d\xd3\xfd\x10\xcd\x21\x77\x66\xee\x40\x4c\xed\x72\
\xab\xcb\x66\x64\xb1\xb1\x12\x9d\xa3\x3b\x91\x90\x6b\x0a\x5a\x3b\
\xb3\xd0\xf5\x83\x21\x68\x6d\xff\x1d\xad\xb9\xe9\xd4\x3c\x73\xc7\
\xa1\xb3\xb6\x05\x9a\xd7\xef\xa0\xb5\xbf\x98\x9a\x61\xa6\x3c\x0e\
\x0d\x5a\x22\x6b\x98\xf1\xc1\xc8\x9e\x25\xdb\x1e\xb8\xb1\x7f\x9b\
\x2e\x2d\x0b\xd8\x0f\x8a\xce\x26\x8f\x54\x00\xab\x4a\x2b\xb9\xf2\
\xfe\x45\xac\x88\x69\x84\x7f\x75\x65\x6f\x6e\x3b\xa9\x23\x55\xc6\
\x09\xa7\x02\xf8\xc9\xc4\xb5\xfc\x6c\xd2\xba\x3d\xca\xd9\x8e\x2d\
\x0a\x78\xf4\x96\x01\x9c\xdc\xbd\xa4\x51\x5a\xe1\x74\x2a\x60\xc2\
\x92\x32\x3e\xfe\xcf\x65\xec\xa8\xd4\x7e\xdd\xa6\x38\xcd\x43\x37\
\xf5\xe7\xec\xbe\xad\xc8\x64\x8f\xdc\x81\xa8\xa8\x0e\xb9\xe3\xd9\
\x15\x9b\x1e\x9b\xb3\xf5\x32\x6a\x4a\xe9\x3c\x3c\x9a\x2a\xdc\x9d\
\xc1\x07\x0e\x41\xd9\xc3\x91\x54\xfb\xab\x78\xe6\xd5\xc3\x03\x44\
\xe4\xfe\x1a\xf8\x3d\x62\x86\x3d\x3c\x3c\xf6\x1e\x9d\x50\x5c\x5e\
\xe7\xfc\xed\x70\xc6\x17\x90\x80\x79\x0a\x12\x92\xcd\x42\xd7\x23\
\xae\x23\x12\xda\x78\x78\xc4\xd1\x15\xf8\x19\xf0\xdd\xa3\x43\x0d\
\xbc\x0f\x08\x08\xb8\x78\x70\x1b\x3a\xb4\x88\xac\x3d\x36\xef\xae\
\x66\xe2\xd2\xed\x34\xd6\x9d\x55\x26\x1b\xf2\xf2\xa2\xb2\x3d\x4c\
\x30\xc0\x89\xdd\x5b\x70\x7c\xd7\x16\x64\x8f\x60\x26\xd8\xc3\xc3\
\x63\xaf\xe1\xee\xce\xd5\x17\x1b\xd1\xc3\xc3\xc3\xc3\xc3\xe3\x68\
\xc4\x3f\x91\xe5\xc1\x31\xc8\xa2\xe0\x21\x7b\x3e\x8e\x9a\xda\x60\
\x0f\x8f\x5a\xf0\xf7\x25\xf2\x20\x1b\x86\x0c\xeb\xd4\x9c\xd3\x7a\
\x95\xf0\xfc\x82\x52\x00\xc2\x10\x5e\x5b\x5c\xc6\xa7\x4f\xe9\x48\
\x9b\x66\xe9\x7d\x62\x87\x53\x01\xac\x2e\xad\x62\xe2\xd2\xc8\x69\
\x5c\x3a\x15\x70\xd5\xb0\xb6\xb4\x2e\x4e\x1f\xd1\xda\x60\x0f\x8f\
\x23\x0e\x63\x27\xe6\xf9\xa1\x19\xdc\x73\xc6\xfe\x28\x61\x23\xba\
\xab\x58\x1b\x77\x4e\xac\xed\x76\xe3\x9e\xd1\xb9\x7f\xaf\x02\x7e\
\x33\x9a\x06\x23\xde\xae\x7b\xf6\xe2\xbd\xbc\xf9\x84\xec\xa9\x4c\
\x63\xf2\x3b\x94\xc8\x3b\xd6\xd4\xdd\xae\x5c\x7d\xb0\xbf\xfb\x21\
\x59\xb7\x10\xb8\xd7\xf2\xbf\x63\x62\xcd\x5b\x69\xfb\xb3\xdc\xf8\
\x1c\x8b\x97\x99\xab\x4e\x64\xd8\xe3\xc3\x26\x9b\x85\x5f\x9d\x0f\
\x63\x27\x1c\xb8\x3e\xf1\xf0\xf0\x38\x5a\xb0\x05\x85\x2d\x4c\xc2\
\x7b\x67\xf6\xa8\x17\x5e\x23\x9c\x07\x21\xd0\xa2\x28\xc5\x15\xc3\
\xda\x52\x90\x8a\x0e\xea\x39\xeb\x77\x33\x67\xdd\x6e\x52\xa9\x7d\
\xbb\x27\x1c\x04\x01\x6f\xad\xdc\xc1\xd2\x2d\x15\x7b\x9e\xf5\x6a\
\x53\xc4\xa8\x7e\xad\x08\x8f\x06\xdb\x74\x0f\x8f\x23\x0b\x71\x07\
\x2e\x29\x08\x6d\x63\x28\x3f\xb0\xa5\x8e\x9d\xa8\x92\xfb\xee\x79\
\x12\x77\x9a\x13\x47\xdc\xb9\xcc\xde\xb6\x2b\xee\xb4\x64\xdf\x10\
\x86\x10\x04\xae\x6e\x41\xa3\xf3\x3b\xb4\x88\xd7\x3f\xe9\xb4\xa7\
\x01\xed\xaa\x76\x69\x1b\xdf\xaf\x71\xdc\x39\xd1\xbe\xec\x06\xc2\
\x14\xa9\x22\xe5\xee\x18\xd1\x54\x16\x32\x81\xe6\x69\x71\x73\xb8\
\x6b\xe2\x3e\x14\xd2\xe0\x7e\x89\x21\x74\xbf\xa5\x38\x7f\xcf\x33\
\xad\x91\x74\x41\xec\x55\x4b\x13\x1c\xb2\xa9\xe1\x1c\xfa\xec\xdf\
\x71\xd9\x7b\x1c\xc8\xb2\xd3\x8d\xcf\xe2\x90\x21\x3e\x3e\xa9\x3c\
\xbf\xc7\x9f\xe7\x5b\x8f\x41\x2c\x9f\x74\x22\x5f\x8f\xc6\xc1\x9d\
\x83\xf9\xc6\x68\x6f\xf3\x3a\xd0\x75\x8d\x3b\x98\xf3\x38\xca\xe1\
\x35\xc2\x75\x20\x0c\x43\xce\xee\xd3\x8a\xfe\xed\x9b\xb1\x70\x93\
\x08\xdb\xb2\x8a\x0c\xaf\x2e\x29\xe3\xac\x3e\x2d\xf7\x29\xcf\xf2\
\xaa\x2c\x2f\x2d\x2c\xad\x11\xba\xe9\xc2\x01\xad\xe9\xd3\xb6\x19\
\x5e\x19\xec\xe1\x71\xd8\xe1\x14\xe4\xa5\xd4\xc2\xa8\x04\x95\xc8\
\x51\xce\x9f\xb9\x6b\xe2\x36\xb2\xa1\x3c\xf4\x39\xfb\x91\x7b\xce\
\x8b\x18\x94\x84\x82\x30\x27\xc2\x2c\x04\x31\xba\x22\xda\x23\x5a\
\x01\x57\xb3\x9c\xc9\xc8\x51\xcd\x4f\x80\x17\x18\x3b\xf1\xc9\x58\
\x5a\xe7\x95\x73\x11\xf0\x30\x63\x27\x84\x0d\x3a\xf7\xe5\xab\xfa\
\x4c\xe0\x5a\xe0\x97\x8c\x9d\xb8\xba\x56\x7d\x33\x40\xab\xad\xb0\
\x2b\xe6\xdc\x2f\x00\x7e\x39\x3a\xfa\x5f\xda\xc2\x53\x08\xc3\x6b\
\x20\xf8\x35\xba\xeb\xbc\x0e\xb8\x97\xbb\x26\xc6\xda\x62\x19\x27\
\xfb\x23\xd9\xf6\x38\x9c\xe6\x30\xae\x6d\x8d\xf7\x6d\xce\x0e\xce\
\xd3\xe1\xf7\x8c\x86\x3b\x27\x50\x8b\x11\xbb\x67\x74\x52\xeb\xfe\
\x05\xe4\xec\xe5\x47\xc0\xc7\xac\xa7\x1e\x02\xfe\x03\x98\xc6\xd8\
\x09\xf7\xe7\xe9\xdf\x01\xc0\x59\x50\xf0\x4f\x60\x20\xf2\x48\xfc\
\x5b\xee\x9a\xb8\x50\x8e\x39\x12\x1a\xd1\x5a\x9a\x54\xeb\xa8\x30\
\x88\x92\xd6\xd4\x9c\xa6\x80\xf3\xa1\xf9\x2d\x40\x67\xb2\x95\x2b\
\x81\xfb\x08\x98\x0a\x84\x84\x41\x31\xe9\xf0\x3b\xc0\xf1\x94\xef\
\x7e\x84\x02\xfe\x51\x23\xfb\xb1\x2f\x53\x33\x1a\x57\x8e\xe2\xf7\
\x90\x8d\x36\x97\xc3\x3d\xbf\x15\x01\xdf\x41\x36\x07\xff\x43\x8d\
\x7b\xec\x41\x1b\xeb\x9b\x7e\x8c\xe7\xf7\x10\xbe\x04\xc1\x37\x81\
\xee\x64\xb3\xdf\x03\x4a\x21\x6c\x07\xc1\xff\x03\x56\x90\xcd\xde\
\x83\x49\x0b\x0e\x22\x4e\x42\x31\x7a\x5d\xb9\x65\xc8\x79\xd5\x04\
\x0e\x7c\xec\x86\x14\xf2\xd8\xbc\xdc\xca\xbf\x09\x79\x74\xcf\x34\
\x22\xcf\x24\x3a\xa3\x75\x57\x8a\xee\x83\x36\x65\x27\x3d\xe7\x20\
\xa7\x5e\x0b\x63\xcf\x7a\x21\x4f\xdd\x10\x85\x4e\x9a\x80\xae\x8b\
\x14\x20\xef\xf9\xe7\x20\x06\x6c\x2e\x5a\x8f\x43\x50\xb8\xa6\x7b\
\x89\x42\x38\xf5\x40\xeb\xae\x12\x39\x3f\x2b\xb2\xf7\x77\x21\xab\
\x9b\x9f\x21\x47\x5b\x1e\xfb\x86\x8f\xa1\xbb\xb9\xbb\xd1\xfc\x9d\
\x8d\x1c\x3b\x96\xee\x65\x3e\x69\xe4\x29\xfd\x29\xe4\xac\xea\x40\
\xc0\x79\x2e\x9f\x8f\xe6\xc9\x03\xec\xdf\x35\xe7\x71\x98\xc1\x33\
\xc2\x75\x20\x1b\x42\xf7\xd6\x85\x5c\x38\xb0\xf5\x1e\x46\x18\x60\
\xe2\xd2\xed\x7c\xe9\xb4\x6a\x3a\xed\xa5\x83\xb1\x54\x00\x4b\xb6\
\x54\xf0\xd6\xca\xc8\x41\x5f\x49\x51\x8a\xcb\x86\xb6\xa1\x20\x1d\
\x78\xb3\x68\x0f\x8f\xc3\x0f\xdd\x11\x01\xf0\x28\x22\x68\x07\x00\
\xdf\x83\x60\x33\xd9\xf0\x6f\xc8\x8b\x64\x6f\xa0\x1c\xc2\x65\x8c\
\x9d\x98\xb1\x77\x4a\x10\x51\xd6\x9a\x90\x95\x04\x6c\x47\x4c\x52\
\x0b\x22\x02\x7c\x35\x41\x6a\x33\x0a\xd7\xd0\x4b\x79\xb0\x1c\xdd\
\x17\xbe\x1e\xf8\x29\xf0\x75\xe4\x89\xf2\x12\x44\x38\xcc\x05\x42\
\x02\x96\x11\x52\x89\x62\x8f\x6e\xa0\x28\x08\x09\xc3\x76\xc8\xa3\
\x65\x35\xf2\x7a\xb9\x1d\xe8\x89\x3c\x59\x67\xac\xec\x15\x54\x67\
\xb7\x93\x4a\xad\x43\x1e\x5e\x77\x58\x7d\x5b\x20\xa2\xb2\x35\x21\
\x2b\x28\xa0\x8c\x9d\xed\x21\x08\x3b\x23\xa7\x13\x5b\x29\x60\x35\
\x77\x4c\x0c\xf9\xd5\x68\xd7\x37\x85\x28\x16\x65\x95\xd5\x7d\x34\
\xb0\xd8\x34\x98\xcd\x90\x3e\x3b\x6d\x6d\xda\x85\xce\xa3\xbe\xc8\
\x7b\xf6\x36\x6b\x4f\x15\xf2\x06\xdb\xc7\xda\xbd\x1a\x99\xc1\x39\
\xb4\xb1\x36\x2c\xe3\xce\x09\xbb\x10\xc1\xdb\x12\x39\x47\x69\x63\
\x7d\x5f\xa5\xf6\x06\x3b\x10\x01\xdc\xcf\xd2\x6c\x26\x08\x56\x31\
\x76\x62\x86\x30\x2c\xb0\x32\x4a\x80\x35\x10\x6e\xb6\x7a\x16\x5b\
\xfa\x0a\x24\xf4\x38\x11\x09\x1d\xe6\x22\xf6\xb0\x08\x85\xc0\x29\
\x37\x46\xb5\xa3\xd5\xa7\x0a\x79\xb9\x4d\x6b\x3e\x70\x32\x04\xb3\
\x11\xd1\x3d\x05\x28\xb5\x51\x6e\x63\x63\x5b\x09\x2c\x67\xec\x84\
\x4a\xe4\xd9\xbb\xb3\xf5\x41\x27\x60\x13\x61\x7a\x2d\x64\x0b\x6d\
\x8e\x94\x52\xd3\x5b\xf2\x40\x14\x52\x6b\xb5\xe5\x7d\x39\x70\x22\
\x21\xd7\x30\x76\xe2\x3a\x08\x87\x01\x9f\xb6\xb9\xd8\x82\x6a\x9e\
\x23\xee\xe5\x37\x6c\x06\x29\x8a\x09\xe9\x67\xed\x5d\x8b\x04\x16\
\x2d\x89\xe2\xde\xb6\x03\xb6\x92\xce\xac\xa1\x3a\x85\xfd\xe6\xc6\
\x64\x94\x8d\x5f\x24\xb5\xb8\x63\x3c\xc0\xa9\xc0\x27\x6c\x1e\xec\
\x20\x2c\x78\x85\x80\x10\xb8\x8d\x80\x27\x18\x3b\x61\x22\x04\x23\
\x2c\xcd\x77\xa8\xaa\x3a\xd8\x4c\x30\xc8\x9b\x6b\x33\x14\x3e\x28\
\x8b\x62\xdc\xfe\xbb\x8d\xdd\x32\x4b\xe3\x42\x2b\x25\xbf\xc7\x8d\
\xc2\x93\xff\x3b\x0d\x59\x3c\xad\x0b\x47\xe4\xe2\xfb\x36\x43\x21\
\x65\xfe\x82\xbc\xe4\x2e\x4f\xe4\x55\xdf\xfb\xb9\x10\x8f\xad\xea\
\xc6\xa0\x3b\x8a\xd7\x9a\x34\x53\x71\x9a\x31\x97\x36\xde\xb6\x7c\
\x69\xe2\x71\x59\xdd\xf7\x78\x28\x1b\x17\xd3\x35\x59\x8f\x64\xbf\
\x85\x89\xbc\x53\xd6\x17\x4f\x20\xc1\x9d\x2b\xa3\x2d\x5a\x4f\xdf\
\x47\xde\x7b\xbb\x03\xdf\x44\xfb\x57\x17\xc4\x08\xff\x1a\xad\x9f\
\xdb\x50\x48\xa8\x7f\x01\x17\x22\x81\x86\x63\xaa\x47\xa3\x7d\xea\
\xe7\x68\x8d\x5f\x44\x14\x5a\xa9\x12\x6f\x42\xdb\x58\x1c\x8b\xf6\
\xe5\x3f\xa0\x3d\xe4\x4e\xb4\x67\xfe\xc1\x7e\x4f\xce\xa3\x02\x6a\
\x0b\xbd\x9c\x66\xff\x64\x14\xf2\x28\x19\x03\x38\x45\xdd\x73\x35\
\x5f\x9e\xc4\xde\x4b\xa1\x3d\xad\x33\x72\xb4\x17\x8f\x35\xee\x2c\
\x97\x3c\x53\x7c\x94\xc1\x33\xc2\xf5\x20\x9d\x0a\xb8\x74\x70\x1b\
\x1e\x9c\xb9\x99\xb2\x72\xad\x8f\x85\x9b\xca\x79\xef\xc3\x9d\x5c\
\x36\xa4\xed\x5e\x7a\x8f\x0e\x98\xb8\xb4\x8c\x75\x3b\xa2\xf8\xf3\
\x27\x76\x6f\xc1\x49\xdd\xbd\x93\x2c\x0f\x8f\xc3\x14\x21\x62\x02\
\xfe\x89\x34\xc1\x23\x81\x0b\x80\x66\x04\x41\x0f\xa4\x95\x18\x29\
\x4d\x71\xf0\x1b\x42\xfe\x8f\x80\x2f\x02\xb7\x12\xb0\x05\xe8\x41\
\xc0\x4b\x88\x59\xfa\x6f\xe0\x78\x44\xa8\x15\x03\x5f\x81\x70\x3a\
\x04\x3f\x47\xde\xa3\xab\x08\xf8\x3b\x21\x7f\x05\x3e\x8e\x62\x85\
\x7e\x07\x69\x28\x77\x23\xe6\xf8\x66\xa0\x84\x90\x6f\xa1\x10\x28\
\xdf\x02\xa6\x10\x86\x1b\x21\xb8\xc7\xea\xdb\x05\x79\xd2\xfc\x1a\
\x70\x17\xf2\xac\x59\x86\x62\x30\xbe\x42\x10\x8c\x05\x4e\x43\xc4\
\xe7\x6c\x2b\xeb\xa3\x04\x6c\x03\xba\x13\xf0\x02\x21\x77\x10\x84\
\xc7\x20\x06\xa2\x0f\xb0\x85\x2a\x7e\x48\xc8\x53\x7b\x7a\x26\x60\
\x20\x70\x2e\xf0\x5d\x44\x14\x65\xec\xd3\x9c\x90\xef\x21\x0d\x58\
\x1a\x82\x57\x80\x6f\x13\x70\x3d\xf0\x51\xc4\x84\x0d\x25\x48\xdd\
\x8b\x08\xa2\x5f\x20\x02\xa5\x03\x0a\x85\xf1\x55\x14\x0a\x05\x14\
\x02\xe6\x61\x08\x7e\x00\xe1\x13\x88\xd0\x05\xf8\x4f\x08\xfe\x1b\
\x11\x46\xdd\x50\x18\x8c\x7f\x47\xda\xb1\xf3\x2c\x9f\xc1\x84\xe1\
\x0f\xd4\xff\xc1\xd7\x50\x0c\xd5\x66\xc0\x12\x08\xbe\x0e\xcc\x27\
\xe0\x3f\xac\x4e\x1b\x11\x23\xb9\x11\x11\x4c\xb7\xab\xee\x7c\xdd\
\xca\xa8\x26\x60\x10\x22\xca\x77\x22\xe2\xfd\x0d\xe4\xb8\xe5\x52\
\xc4\xf0\x7e\x13\x69\xac\x7e\x82\x34\x28\x6d\x20\xf8\x05\x70\x9c\
\xf5\xcb\xe3\x48\xfb\x75\x29\x12\x72\x2c\x53\xfb\x82\xe5\x04\xd9\
\x4f\x10\xb2\xd3\xf2\x7f\x0d\xf8\x71\xac\x9f\xdb\x21\x22\xff\x5d\
\xcb\xe3\x5f\xf6\x7f\xb9\xd1\x8b\x17\xe8\x3b\x0f\xdb\x58\x1e\xcf\
\xd8\xf1\x93\xb9\xc7\xd9\x2b\x87\xc5\x84\xc1\x7f\xd8\xdc\x2d\x47\
\xda\x92\xcf\xda\xfc\x7a\x98\x80\x35\x48\xc0\xb0\x81\xea\xd4\xa7\
\x11\x13\xf2\x0b\xe0\x12\x82\x3d\x71\x37\x93\x11\x00\x02\xe0\x62\
\x1b\xa7\x37\x80\x2b\x09\xc2\x01\xc0\xf3\x10\xdc\x85\x04\x37\x6f\
\x20\x86\x64\x2b\xf0\x32\xbb\x77\x37\x76\x2d\x3a\xf4\xb6\xf5\x32\
\xcd\xc6\xab\x3e\x6c\x20\x8a\x3b\xbb\x18\xc5\xeb\x1d\x88\xe2\xd9\
\xb6\x41\x82\x80\x87\x6c\x5c\x4e\x44\x6b\xe5\x1f\x36\x1f\x46\x22\
\xef\xd5\x01\xf0\x45\x1b\x9b\x14\x5a\x87\x2d\x90\x20\xea\x71\xe0\
\x74\x14\x87\xb4\x10\x31\x77\xff\xb0\x77\x46\xda\x7c\xf9\xb3\xf5\
\xa3\x7b\x76\xad\xcd\xc5\x99\x36\x9e\xa7\xdb\xa7\xd0\xea\xf4\x4f\
\x14\x8e\x25\xde\xdf\xa3\x90\x10\x24\x85\xf6\xa2\x77\xd0\xda\x1e\
\x88\x98\x8b\x15\x96\xb6\xa3\xd5\x35\x8d\x84\x27\x4f\xa3\xf8\xae\
\x83\xac\x2f\x1e\xb2\xb4\x67\x5a\x1f\x14\x20\x2d\xec\x7c\xfb\xff\
\xf7\x68\xcf\xfb\x22\x72\x46\x74\x1a\x5a\x87\x2e\xee\xea\x10\xab\
\xfb\x2b\x88\xd1\xb8\xc5\xda\x3c\xc7\xda\x7d\x9c\xf5\x65\x25\x62\
\x48\x1e\xb3\x39\x70\xb2\xd5\x69\xa6\xbd\xe7\xb0\x0d\x09\xfb\xca\
\x91\x37\xe0\x9b\x91\x70\xaa\x1d\xda\xf7\x5c\x78\xa8\xc5\x48\xa8\
\xb4\x02\x85\x9b\x1b\x85\x18\xe1\x66\xf6\xfd\x59\x22\xc7\x49\x03\
\xd1\x1a\x99\xb5\x3f\x26\xdc\x11\x88\x00\xc5\xfb\xed\x89\x84\x6b\
\xf5\x85\x57\x72\x61\x8e\x5c\x7f\xce\x44\xf3\xac\x1b\x8a\x5d\x1f\
\xa0\xfd\xec\x2d\x34\x27\x3b\xa3\xf1\x7c\x00\x85\x3f\xba\x02\xc5\
\xe0\xdd\x84\xce\xa7\xd6\x68\xbf\x7c\x10\xcd\x85\x0b\xd1\xfe\xff\
\x1a\xda\xa7\x7b\x21\x61\xe0\xfd\xe8\xbc\xbc\xd9\xca\xab\x40\xe1\
\xc0\x32\x68\x8f\x2e\x47\x61\x9a\xe6\xd8\x7b\x29\xab\xd3\x1c\x24\
\x00\xee\x82\xe6\xf7\x18\x14\x6a\xa9\x04\xcd\x9d\xbf\xa3\x75\xe9\
\x71\x14\xc0\xdf\x11\xae\x07\xd9\x6c\xc8\x09\xdd\xc4\xac\x3a\xec\
\xae\xca\xf2\xea\xa2\x32\xaa\x33\x0d\x67\x5e\x15\x3b\xb8\x9a\x97\
\x17\x95\xed\xd1\x22\xa7\x02\xb8\x6c\x48\x5b\xda\x16\x17\x1c\x70\
\x1b\x2c\x0f\x0f\x8f\x03\x82\x10\x11\xbc\xbf\x45\x04\xc3\x83\xc0\
\x16\xc2\x70\x3c\x22\x2e\xcf\x42\x0c\xe7\x93\xc0\x5d\x04\x0c\x40\
\x5a\xc4\x0e\x88\x49\x7e\x02\x11\xaf\x9d\x10\x53\xfa\x15\x44\x78\
\x6f\x06\x3e\x30\x06\x6d\x20\xd2\x74\xdc\x07\x7c\x95\x80\x13\xac\
\x9c\x52\xe0\x07\x88\x48\x2c\xb0\x77\xee\x46\xda\xc8\x8b\x11\x51\
\xd9\x16\x28\x21\x0c\x8b\x10\x63\xfc\x3d\x44\xac\x5c\x88\x08\xc9\
\xe6\x88\xe8\xf8\x1f\xa4\x1d\xb9\x86\x20\x18\x6d\xf9\xb5\xb3\xbf\
\xcd\xad\xbe\xff\x8b\xb4\x2c\x97\xa1\x78\xa9\x77\x20\xcd\xe0\xed\
\x88\xa0\xfe\x1a\xa9\xb0\x75\xac\x6f\x46\x20\xc2\x62\x21\x71\xa3\
\xea\x80\x53\x10\xa3\x75\x1f\x32\x9d\xbd\x1a\x11\x47\x37\xa8\xee\
\xe1\xcf\xac\xac\x39\x88\x38\x3e\x1f\x39\x0c\xfb\x4f\xe0\x5f\x84\
\x61\x9c\x40\x59\x88\x08\xb0\x4b\x21\x18\x8a\x98\x85\xd7\x09\xc3\
\x0c\x22\xd2\xbf\x87\x08\x9b\x0b\x11\xf1\x7c\x33\x22\xf6\xff\x47\
\xfd\x1f\x2e\x26\xe4\x0c\xeb\xfb\xc7\x80\xcf\x58\x5b\xbf\x45\xc0\
\x69\x48\x93\xfa\x4f\xc4\x44\xc7\x35\x5a\xad\xec\x13\x47\x33\xe0\
\x79\x08\xbf\x87\xb4\x5a\x57\x22\xc2\xfb\x35\xab\xe7\x8f\x6c\xbe\
\xb8\x7e\xff\x0a\x62\x0a\xbe\x8a\xcc\x56\x6f\x87\xc0\x8d\x5b\x17\
\x60\x22\x32\xd9\x3c\xd1\xda\xb5\xd9\xe6\xc1\x5f\x12\xe5\xce\x43\
\x04\xe1\xe5\xd6\xe6\xff\xd4\xb8\x65\xb7\x43\xb5\xd3\x7e\x4d\x45\
\xda\x99\xed\x96\x2e\xb2\xc7\x0e\x82\x22\x44\xa4\xfe\x27\x62\x54\
\x46\xd8\x27\x45\x14\xfb\xf5\x07\x36\xe6\x67\x23\xed\xda\x8d\x56\
\xe7\x1f\xd7\xc8\x6b\x4f\x9e\xa9\x8e\x48\xe0\x30\x01\xc2\xbf\x00\
\x85\x10\x5c\x44\x96\x85\x56\x97\xf3\x21\x18\x84\x08\xd0\x49\x04\
\xe1\x32\xfe\x76\x35\xfb\x01\x45\x36\xa7\x9e\x42\x5a\xa9\x7a\x2f\
\x1f\xa0\xb5\x77\x2a\xd2\xf8\xdf\x66\xcf\x3f\xb4\x7e\xda\x86\xd6\
\xee\xe5\x88\x31\xfc\x2b\x62\xf6\xbe\x81\x04\x20\xa3\x11\x61\xdd\
\xcf\xc6\x28\x85\x84\x4f\xb3\xd0\xfc\x1e\x8d\x98\xfe\x3e\xc8\x84\
\xf7\x19\x34\xaf\xbf\x88\x34\xef\x1f\xd8\x98\x55\x5b\x1d\x7a\x21\
\x06\xe0\x5d\x1b\xd3\x31\x56\x76\x1f\xeb\xfb\xa7\x6d\xbc\x3f\x6f\
\x73\xc8\x61\x08\x32\xf1\x1e\x67\x63\x78\xb3\xcd\xad\x89\x96\xd7\
\x24\x22\xcd\x57\x73\x34\x37\x17\xa3\x75\xf5\x49\xcb\xff\x8f\xd6\
\xde\xbb\x10\x13\x74\x27\x9a\xbb\xff\x44\x4c\xfc\x40\xc4\xa4\x17\
\x5a\x3e\x27\xa1\xb9\x7c\x32\xb2\xe4\x78\xd8\x7e\xbb\xc8\xea\xb9\
\x02\xf8\x36\xd2\x74\xff\xd9\xe6\xd4\xb5\x88\x01\x3d\x1f\xc5\x36\
\x7f\x0b\xad\x83\x2d\x68\x8d\x8c\xa7\xa6\x89\x72\x88\x18\xff\xd3\
\x6c\x7c\x6e\x42\xcc\xd9\x02\xeb\xcb\x5d\xc0\xdf\x2c\xff\xeb\x90\
\xe0\xa5\x0a\xc5\xc6\x3d\xd3\xe6\xc3\x40\xb4\x0f\x4d\x89\xe5\xbb\
\xaf\xbe\x13\x8e\x16\xb4\x47\x67\xda\xd3\x68\xcc\xea\x43\x88\xce\
\x9c\xff\x87\xf6\xac\x8b\xd1\x18\xb4\x00\xae\x42\xcc\xe8\x2b\x48\
\x30\xba\x1e\x09\xf4\xaa\x90\x40\xf0\x04\x64\x15\xf2\x28\x62\xa0\
\x3b\x20\x61\x53\x77\x4b\x9f\xb6\x3c\x76\x22\xa6\xba\x35\xda\xcb\
\xb2\x68\x5e\x8e\x42\xc2\xd3\xdf\xa0\x75\xf4\x31\x74\xee\x5d\x8e\
\xe6\xfd\x7b\xe8\x8a\xd0\x1a\xb4\x36\x5a\xa1\x7d\xa1\x3d\x12\x3c\
\x77\x42\xe7\xf4\x93\x68\x2e\x5d\x61\xcf\x3d\x8e\x12\xf8\x8d\xa0\
\x1e\x84\x40\xeb\xe2\x34\x97\x0f\x69\x4b\xdc\x3f\xd6\x1b\x2b\x76\
\xb0\xa6\xac\x92\x86\xfa\xcc\x4a\xa5\x02\xe6\xac\xdf\xcd\xfb\x6b\
\xa3\x2b\x3a\x3d\xdb\x14\x71\xc1\x80\xd6\x8d\x0e\xc7\xe4\xe1\xe1\
\x71\xc8\x10\x20\x29\xf4\x9f\x11\xd3\x75\x2f\xd0\x96\x20\xf8\x18\
\x62\x60\x0a\x11\xd1\x39\x98\x88\xe8\x06\x11\x6c\xcf\x22\x42\x30\
\x04\xb2\x10\xae\x47\xc4\x5c\x27\xe0\x6e\x42\x96\x20\x62\xf3\x4d\
\x08\x5e\x42\x9a\x9a\xdd\xc8\xfc\x7a\x1d\x62\xcc\x96\x23\xe6\x26\
\x85\x18\xdd\x97\xd1\x81\xef\x88\x55\x6d\x2e\x41\xb0\x0b\x31\x35\
\x3f\x40\xc4\x43\x9c\xa9\x5b\x86\x88\xdd\xc7\x10\x01\xd2\x8b\xc8\
\xfc\xd2\x99\x30\xae\x8c\xd5\x17\x44\x8c\x0c\x46\x84\xce\xf5\x88\
\xd0\x6c\x45\x10\x74\x8e\xf5\x4d\x27\x44\x98\x6c\xa2\x26\x43\x72\
\x0c\x22\x46\x4e\x41\x8c\xc2\x76\x4b\xfb\x1c\x30\x04\x82\xc7\x10\
\x73\xdc\x0e\x99\x20\xcf\x04\xfe\x0b\x69\x49\x07\x13\x04\x85\x7b\
\x72\x6a\xc6\x4e\xab\xd7\x48\x02\x6e\x45\xc4\xd5\xab\x04\x81\x33\
\xa3\xfc\x21\x62\x30\xb2\x48\x70\xf0\x0c\x62\xd0\x1e\x01\xc6\x40\
\x50\x82\x18\x86\x2a\xc4\xb8\xb8\x3e\x3c\x06\x11\xf8\x20\xa6\xea\
\x25\xa4\x65\x73\x8e\x75\x72\x99\xa7\x96\x01\x3d\x21\xf8\x91\x8d\
\x7d\x96\x90\x1d\x88\xb9\xd8\x8d\x18\x03\x67\x3a\xda\x12\x31\x06\
\x6f\x90\x09\x9f\x45\x82\x8d\x4d\x88\x00\x0b\xac\x4f\x5e\xb0\xfe\
\xde\x8d\x98\xec\x6a\x22\xed\x57\x1c\xd5\x48\xcb\x7c\x2d\x22\x5e\
\x3b\x00\x7f\x82\xd4\xe9\x26\x1c\x38\xd1\xe6\xc7\x69\x88\x98\xbc\
\x04\x52\x1d\x63\xef\x57\x5a\x1e\x5f\x20\xd2\x9a\xb8\xf1\xda\x65\
\x6d\x7f\xd9\xda\x57\x68\xe3\x2e\x2d\x69\xc8\x73\x48\x53\x18\xd1\
\x12\x63\xc7\x43\x10\x8e\x8c\xe6\x47\x30\x02\x69\x66\xae\x20\x20\
\x85\x88\xeb\xfe\xc0\xa7\xd4\x5f\x3c\x0d\xe9\xfd\x65\x16\x9d\x45\
\xf3\x7f\x2d\x0d\x8b\x8d\x1a\x5a\x3d\x3f\x8b\x88\xec\xde\x48\x60\
\xb1\xc6\xc6\x6d\x82\x8d\xdb\xa9\x88\x81\xbb\xc1\xfa\xb3\x2f\xd2\
\x92\x2d\x44\x0c\xf0\xd9\x88\xf9\x2d\x46\x66\xa2\x27\xa1\x75\xd1\
\xc1\xf2\x07\x78\x1d\xcd\xe5\xb7\x10\x33\x5a\x6d\x7d\xba\x2e\x36\
\x06\xc3\xac\xaf\x9e\x41\xcc\xc3\xf3\x36\x6e\x29\x7b\xff\xfd\xd8\
\xfb\xf1\x8b\xdd\x23\xac\x9e\xaf\x20\x4d\xf8\x9b\x56\x87\x4d\xf6\
\x89\x6b\xc6\x03\xfb\x7f\x3c\x12\x0a\x9d\x89\xd6\xca\xcd\xc0\x50\
\xeb\x83\xd3\xed\xbd\x71\x48\xb3\xfc\x43\x34\xef\xe2\x61\xdc\x32\
\xd6\x7f\x15\x56\xde\x22\x34\xbf\xe6\x20\xe6\xbb\x18\xad\xad\xe3\
\x10\x03\xdb\xc9\xda\x57\x00\xbc\x8d\x18\x94\xb7\x88\xe6\x5a\x99\
\x95\x51\x11\x2b\x23\x44\x82\x86\xdb\x6c\x7c\x4e\x43\x56\x1f\x73\
\xd0\x1c\xfc\x26\x12\x34\x3a\x26\xeb\x47\x56\xee\xbb\x56\xce\x50\
\xb4\xc7\xcc\xa0\xe6\x95\x0a\x8f\xba\x51\x85\x84\x9b\x6b\x68\xf8\
\xdd\xe9\x75\x68\x7e\x4e\x43\x73\xe1\x72\x34\x16\xcb\xd1\xfc\xf8\
\x10\xed\x23\xdb\x11\xa3\x3c\x10\x31\xa3\xa7\xa0\x7d\xed\x2d\xb4\
\xd7\xcc\xb7\xf2\x5f\x44\x0c\xea\x31\xe8\x7c\x99\x6d\xdf\x9f\xb0\
\x34\xff\x8b\xd6\xc7\x6b\xb1\x3c\x07\xa1\xf9\x92\x42\x6b\x73\x0a\
\x5a\x57\xdd\xd1\x3e\x3e\xdb\xf2\x75\xfb\x77\x16\xcd\x8b\xa7\x2d\
\x6f\xa7\x79\x6e\x7f\xa8\x07\xc0\xe3\xe0\xc1\x9b\x46\x37\x00\x61\
\x18\x72\x5e\xff\x56\xf4\x6a\x53\xc4\x8a\x6d\xf2\x05\xb2\x7c\x6b\
\x05\xef\xac\xda\x49\x9f\x76\xcd\x68\xc8\x45\xe1\x4c\x36\x64\xdc\
\xa2\x32\x4a\xcb\xa3\xeb\x07\xa3\xfa\xb5\xa2\x5f\xfb\x22\xef\x24\
\xcb\xc3\xe3\xf0\x46\x35\x22\x52\xdf\x44\x87\xf0\x2d\x88\x08\x5d\
\x8e\x88\xe5\xc7\x11\x43\x11\xa0\x83\xf8\x1a\x74\x00\xc7\x99\xc3\
\x22\x08\xc6\x22\x4d\xdb\x4f\xd1\xc1\x5c\x80\x08\xd6\xbe\x84\x61\
\x47\x02\x86\x20\xc6\x73\x13\x91\x46\xa3\x04\x31\x27\x21\x22\xa6\
\x1d\x13\x93\xdc\x55\x3e\x8d\x88\xc9\x9b\x11\x93\xe9\xd4\x6f\x21\
\x32\x29\x1b\x84\xcc\xd5\x9a\x93\xfb\xbe\x5c\x86\x9a\xde\x36\x2b\
\x11\x21\x5a\x81\x18\xf4\x16\xf6\xde\xea\x1c\xef\x24\xcf\x99\x4d\
\x88\xd8\x1f\x8f\x08\xd4\x7f\x22\xc2\x36\x44\x04\xce\x60\xa4\x65\
\xfe\x09\xba\x03\x78\x37\x62\x9c\x46\x23\x4d\xdc\x0a\xa4\x99\x73\
\xae\x99\x5e\x43\x5a\xd5\xcf\x00\x2f\x11\xb0\x9c\x90\x1f\x02\xb7\
\x22\x02\xfc\x26\xa4\xa5\xaa\xb2\xf7\xa6\x20\xd3\xd9\xcf\x21\x02\
\xff\x09\xc4\x54\x1c\x6b\x75\x1b\x62\x7f\x57\x59\x7f\xf6\x87\xf0\
\x03\x08\xfa\x92\xff\x6e\x66\x68\x7d\x7c\x13\x32\x3f\xbe\x05\x69\
\xbd\xdc\x5d\x4f\xa7\x59\x77\xfd\x57\x61\x63\x3b\x80\x74\xd0\xcd\
\xfa\xbf\x0d\x22\x26\x45\xa0\x85\x64\x8d\x71\x84\x9a\xf7\xd8\x92\
\x4c\xf8\xe5\x88\x21\xb8\x1b\x31\x02\xef\x21\xc6\xba\x3f\x12\x7e\
\x94\x20\x06\x64\x90\xd5\xa1\x1b\x70\x2a\x63\x27\x3c\xcf\x3d\xe7\
\x61\xed\xfe\x31\x32\x77\x5e\x68\x73\x37\xde\xae\xf8\x9d\xcf\xd0\
\xfa\xa6\x04\x18\x42\xb0\x47\x7b\x1d\x8f\xd5\x99\x82\xe0\x12\x4b\
\x7b\x2a\xd2\x22\x02\x9c\x48\x10\x0c\x47\x5a\xca\xed\xd6\xff\xcb\
\x80\xc9\x84\xf5\x59\x5e\x36\x18\x4e\x28\xf0\x17\x44\x78\xd7\x77\
\xba\xa6\x10\x01\x7e\x27\x11\x63\x07\x12\xc2\x54\x12\x09\x8c\xdc\
\x7d\xfb\x7f\xa1\xb9\xf2\x2a\x62\x12\x26\xa0\x35\x9b\x46\x26\xc3\
\xd5\x48\x73\xff\x24\x5a\x1f\x5d\x11\xb3\x39\x12\x09\x34\xe2\x63\
\xe8\xd6\x53\x7c\x3c\x2b\x90\x16\xb3\xd0\xca\x6e\x69\x65\x87\x39\
\xde\x8f\xa3\x82\x68\x7e\x39\x41\x4b\x05\xd1\xfc\x4b\x22\x43\x74\
\x9f\xb2\x12\xed\x5d\x13\x6d\x5c\x5b\xdb\xfb\xcd\x63\x65\x8d\x21\
\x8a\x7f\x95\xb5\xfa\x39\xeb\x8f\x2c\x35\x99\xd7\xf2\xd8\xf3\xad\
\x48\x50\xb5\x1e\xed\x2f\x65\x68\x5e\xba\x34\x71\xcf\xeb\xf1\x3b\
\xa0\xf1\xf1\x59\x68\xe3\xb3\x3d\xd1\xee\xaf\x23\xe1\xc3\x53\x48\
\x4b\x3e\x1b\x69\x23\x5b\x20\xe6\x66\x2a\xda\x3f\x7a\x23\x0d\xa4\
\xa7\xb4\x1a\x8e\x32\xb4\xa7\xb6\xa6\xe6\x9e\x9e\x0f\x01\x12\xf2\
\x3c\x6e\xff\xaf\x40\x57\x6b\xc6\xa1\xb9\x91\x45\xeb\xe6\x6b\x68\
\x1f\x1e\x8f\xd6\x58\x4f\xa2\xb9\x0b\xda\x27\x8b\xd0\xb8\xbf\x8b\
\xce\xab\x4f\xa2\x71\x76\xc2\x1c\x97\x76\x08\xb2\xc4\xb8\x14\x09\
\x60\x26\xa1\xb3\xac\xb7\xd5\xc7\xad\x1b\x37\xa7\x8a\x13\xef\x63\
\xbf\x1d\x87\xac\x38\x5e\x04\xa6\x23\xcb\x0d\xef\x4d\xfa\x28\x82\
\xd7\x08\x37\x00\xd9\x10\xfa\xb4\x6b\xc6\xe8\xfe\x91\xd5\x5f\x55\
\x26\xe4\x95\xc5\xa5\x94\x57\x67\xeb\x7d\x3f\x08\x60\xfd\x8e\x2a\
\xc6\x2f\x89\xe8\xcb\x16\x85\x29\xae\x18\xda\x96\xa2\xb4\x1f\x02\
\x0f\x8f\xc3\x18\xce\x4c\xf6\xe7\x48\x3a\xfd\x24\xd2\xa8\x3e\x8f\
\x18\xbc\x6a\xa4\x29\xfe\x1f\xe0\xd3\x10\xc6\xc3\x76\x40\xc4\xb8\
\x0e\x46\xe6\x92\xcd\x10\xd1\xf9\x24\x01\x9f\x80\xf0\xef\xc0\x60\
\x02\x9e\x07\xfe\x0f\x49\xdb\x5f\x43\xda\xaa\x10\x11\xfd\x67\x51\
\x93\xe0\x8d\x87\x04\x71\xe5\x6d\xb3\xbf\x63\x2c\x7d\x2b\x44\xec\
\x66\x11\x81\xfa\x27\x44\xc8\xaf\x46\x4c\x7d\x81\x7d\x82\x44\x7e\
\x8e\xb1\xdd\x81\xcc\xcc\x06\x22\x26\xea\x67\xc0\x65\x64\xb3\xf1\
\x0d\x71\x99\x95\xd9\x83\xc8\x99\x4e\x01\x84\x53\x10\x03\xfc\x25\
\xc4\xf4\x7f\xc7\xd2\xdc\x61\x9f\x0a\xab\xef\x3c\x24\xa5\xff\x5f\
\xc4\xc8\xad\x47\xcc\x4d\xe4\x4d\xf4\x97\xa3\x21\x0c\x17\x5b\xbf\
\x74\x02\x5e\x20\xa4\xda\xde\x2f\x40\x5a\x82\x33\xac\xbd\xdd\xad\
\xac\x4f\x22\xa2\x7a\x2b\x22\xb2\x5f\xb6\xf7\xdd\x18\x9e\x8c\x34\
\xfc\xaf\xd9\xf3\xff\x84\xe0\x09\xc4\x20\x3a\x62\x3a\x1e\x6e\xa7\
\xc0\xda\xe9\x34\xa6\xa3\x11\x03\xd8\x82\xc0\x39\xdf\x62\x30\xba\
\x03\xde\x81\xc8\x5b\xed\x03\x36\x57\x9e\xb6\xfe\x5f\x00\xe1\xb3\
\x51\x3f\xed\x61\x94\x5c\x39\xed\x81\xdf\x21\x4d\x6a\x1c\xd3\x11\
\x93\xf2\x17\x44\xcc\xfd\xcc\xda\xb5\x18\x59\x23\xbc\x89\xee\xad\
\x8f\x46\x16\x07\x5b\x90\x30\xc6\x69\xd6\xcb\xad\x3e\xc3\x2c\x7d\
\x4b\xab\xa7\x63\xe0\xdd\xbc\x2a\x50\x5d\xc2\xd7\x80\xa5\x56\x97\
\x07\x91\x76\x34\x46\x38\x06\x5d\x6d\x9e\x3d\x6d\x65\x8e\x46\xa6\
\x8f\x29\xe0\x1a\xc2\xcc\x72\x24\x8c\x68\x0b\xbc\x4a\xc8\x06\xee\
\xb9\x8c\xfd\x88\x9d\x36\xf7\x2a\x1a\x90\xd6\xad\x9b\x5c\x1a\xfe\
\x78\x38\xa5\x97\xad\x7f\x86\x23\xad\xd1\x65\xf6\xdb\x54\x1b\xc3\
\x56\x48\x98\xb3\x54\xe3\xc8\x18\xa4\x8d\xbc\x0d\x31\xc3\x50\x93\
\xde\x72\xce\x7e\xca\x91\xf6\xb5\xb5\xf5\xef\x6c\xc4\x40\xdf\x89\
\x84\x2a\x97\x20\x6d\x67\x98\xe3\xfd\x38\xde\x45\x4c\xec\x97\x91\
\x20\xe6\x24\x34\x7f\x5d\x1b\x93\x6d\x76\x6d\xab\x42\x73\xfe\x74\
\xc4\x58\x5c\x85\x4c\x4d\x67\x58\x99\x5f\x44\x02\xa6\x1b\x91\x86\
\x3d\x8d\xd6\xcf\x27\x10\x13\xe2\x1c\x5d\xa5\x12\x79\x83\x04\x49\
\xee\x1a\xc6\x60\x64\xb2\xea\xac\x4d\x92\x0c\x70\x88\xd6\xcf\xa9\
\x48\x20\x44\x8e\xfc\x92\xe3\x33\x0b\x99\x88\xff\x9b\xd5\xe9\x2b\
\x48\xd3\xec\x1c\xc1\xbd\x62\xfd\x97\x45\x7b\x49\x1c\xde\x34\xba\
\x7e\x6c\x45\x0c\x6d\x43\x9c\x47\x05\x68\xec\x6e\x45\x73\xe3\xb3\
\x68\x0e\x6d\xa7\xe6\xd9\xd1\x16\xed\x3f\x05\xc8\xfa\xa5\x18\x09\
\xa2\x3a\x20\xc1\xd8\xe7\x90\x60\x0e\x4b\x37\x0f\xed\x5d\xe3\xd1\
\x1e\x35\x09\x8d\xf5\xb5\x88\xa9\xee\x82\xd6\x9e\xcb\xf3\x38\x22\
\x46\xda\x9d\x7d\x9b\xd0\x3a\xfd\x32\xb2\xe8\xb8\x8e\xe8\xdc\x4d\
\x11\x59\x57\x6c\x44\x42\x9a\x9e\xf8\x90\x5a\x47\x15\xd2\x3d\x5a\
\x17\xdd\x7d\xcd\xf0\x76\xc5\x2d\x8b\x8e\x8e\x3d\x21\x08\x14\x02\
\xe9\x1f\xef\x6f\xa9\xa1\x9d\xbd\x74\x48\x1b\x46\x74\x6b\x91\x57\
\x3b\x5b\x90\x0e\x48\x05\xf0\xc2\x82\x52\xaa\x2c\xd1\xf6\x8a\x2c\
\x17\x0f\x6a\x4d\xc7\x92\xba\xef\xf8\xa6\x53\x01\xaf\x2d\x29\xe3\
\xfe\xe9\x9b\xc8\x18\x99\x78\x52\x8f\x16\xdc\x71\x66\x17\x9a\xa5\
\x8f\x2e\xc1\x53\x26\x0b\x2f\x2e\x2c\xdd\x35\x6f\x43\xf9\x43\xd4\
\xf4\x7c\xea\xe1\xd1\x54\x31\x0a\x31\x56\xef\xd7\xfa\xe5\xf4\xdb\
\xb2\x48\xe3\xb3\x14\xcd\xe7\x05\x48\xeb\xf8\x2f\x52\x2c\x23\x64\
\x1a\x22\xcc\x67\x02\x0f\x42\xb0\x1c\x11\x16\x0b\x90\x86\xa9\x02\
\x31\x9f\xef\x22\x42\xf3\x2d\xc4\xe8\xad\x41\xda\xd1\x67\x21\x78\
\xd7\xf2\x98\x88\xb4\x76\xce\x5c\x6d\x99\xbd\x3b\x15\x69\x9f\xdf\
\xb6\xff\x2b\x2c\xef\x05\x04\xec\xb2\xbc\x9f\xb3\xfc\x53\xca\x93\
\x39\x96\xbf\x73\x10\xf2\x2b\x64\xce\x76\x0f\x6b\x5b\xcc\xa7\x55\
\x55\x88\x08\xd9\xb7\x10\x81\xba\x00\x31\x5c\x55\xb1\xe7\xef\xa2\
\x3b\x8e\x3b\x10\xf3\xfc\x4f\xb2\xd9\xcd\xbc\xfb\x80\xeb\x9b\xdd\
\x48\x23\xb3\xd4\xea\x53\xae\x3c\x82\xf7\x10\x23\xe4\x08\xad\x47\
\x2c\xbf\x0f\x90\xe0\xa0\xa3\x7e\x0f\x7f\x07\xc1\x7c\x2b\xaf\x83\
\xb5\xeb\xf7\x84\xbc\xce\x3b\xf7\x45\x5b\xee\xe9\xb7\x65\x09\x82\
\x55\xc0\x3c\x08\x9f\xe6\x9e\xf3\x76\x71\xfa\x6d\xf3\x91\x76\x35\
\x40\x66\xa6\xf3\xac\xfe\x53\x89\xee\x4e\xbf\x82\x98\xc7\xb5\x10\
\xbe\x0e\xc1\x7a\x2b\xeb\x37\xc8\x2c\x79\x87\xf5\xe9\x26\x1b\xbf\
\x27\x2c\x8f\x99\x48\x3b\xe7\x9c\xb0\xec\xb0\xbe\x18\x87\x98\xf5\
\x00\x31\x17\xb3\xed\x33\xd3\xea\xb2\xc8\xbe\xaf\x54\x7b\xc3\xf7\
\x62\x63\xfb\x26\xf0\x73\xc2\x60\x85\x79\x56\x5e\x09\x4c\x21\xa0\
\xcc\xca\x7f\x13\xd8\x42\xc0\xa5\x40\xc0\xdb\xf7\x4d\x8c\xda\xff\
\xa9\xad\x36\x37\xd6\x22\x82\x70\x22\x84\x3f\x87\x60\x25\x62\x76\
\x9f\xb2\x7a\x54\x10\xb0\xd5\xea\xf2\x21\x61\x30\x97\x77\xee\xab\
\xe6\x8c\xdb\xb6\x20\x13\xf4\x42\x44\xbc\x4e\xb4\xb1\x58\x6a\x73\
\x7b\xb2\x8d\xd5\x0e\xe0\x2d\xb2\xcc\x23\x08\xde\x46\x0c\xdb\x9b\
\xd6\xbf\xd3\x81\xb9\xbc\x73\x5f\x96\xd3\x6f\x6b\x09\x41\x15\x12\
\x04\x2d\xd5\xb8\x85\x1b\x21\xd8\x00\xac\x22\x60\x9e\xd5\x6d\x19\
\xba\x17\xb8\x81\x77\xee\xdb\x9b\xf5\x58\x80\x18\xd1\x69\x34\xfe\
\x0c\xc9\x22\x02\x78\x71\x8e\xdf\xca\xd1\x1a\xd9\x65\xed\x58\x8b\
\x98\xc5\x32\x74\x1f\x76\xa3\xcd\xc9\x0d\x36\x4f\x16\xdb\xff\xd3\
\x88\x1c\x05\xbd\x86\x88\xf7\x6a\xab\xab\xab\x6f\xa9\xcd\x9d\x95\
\x88\x98\x5f\x4c\x64\x5a\xfa\x1e\x12\xda\xb4\xb7\x3e\x7c\x0b\xed\
\x19\x6b\x89\xb4\xdc\xa5\x44\xeb\x05\xc4\x70\xcc\x40\x42\x89\x16\
\xc8\x4a\x63\xa6\xa5\xdd\x48\xe4\x5c\xce\x61\x87\x8d\x79\x95\xb5\
\x71\x3b\xb2\x18\x58\x63\x63\xb2\xd6\xde\xef\x6f\xf3\xe2\x3e\x4b\
\xb7\xc0\x9e\xad\x27\xba\xfb\x5e\x1a\x9b\x2b\x59\x6b\xc7\x52\xcb\
\x7b\x1a\x91\x67\xf4\x37\x91\x26\xbd\xca\xd2\xae\x88\xd5\x65\x1e\
\xb2\x2a\xe8\x6c\xf3\xc2\x31\xb3\x21\x91\x50\x2c\xc9\x90\x2d\xb2\
\x3a\xf5\xb0\xbe\x9a\x82\x84\x73\x4e\xdb\x5c\x6a\x63\xf7\x2a\xb5\
\x43\xf1\xc4\xeb\x79\xb4\xa2\x04\x59\x93\xbc\x44\xfd\xce\xb0\xea\
\x43\x35\x91\x23\xb8\xd6\x68\x3f\x7c\x00\xed\x6d\xdb\xd1\x5c\x75\
\xeb\xa9\x27\x62\x56\xc7\xa1\xfe\x9f\x8a\xf6\x27\xe7\x11\xff\x0d\
\x24\xe4\xd8\x65\x79\xb5\x27\x0a\x71\x34\x17\x8d\x5d\x3f\xb4\xae\
\x9e\x46\xeb\xa8\xb7\x95\xff\x32\x9a\x47\x8b\xd1\xbe\xe9\xd6\xc8\
\x4c\xb4\x2e\x3a\x5a\xfe\x33\xd1\x59\x59\x4a\xb4\xc7\x0f\x44\xf3\
\x64\x3c\x9a\x9b\xc9\x2b\x28\x1e\x47\x16\x5a\x22\x4b\xb1\xf1\xc1\
\xc8\x9e\x25\xdb\x1e\xb8\xb1\x7f\x9b\x2e\x7b\x19\x0a\xe8\x70\x45\
\x2a\x80\x55\xa5\x95\x5c\x79\xff\xa2\x3d\x66\xce\x00\xbf\xba\xb2\
\x37\xb7\x9d\xd4\x71\x0f\x93\x9b\x44\x10\xc0\xd6\x5d\x19\x6e\x79\
\x74\x09\xef\xac\x92\xaf\x96\x74\x2a\xe0\xbf\x2f\xe9\xc9\xed\x23\
\x3b\xd5\x19\xfa\xa8\x3a\x1b\x72\xe7\xb3\x2b\x79\x64\xd6\x96\x3d\
\x79\xfd\xe0\xfc\xee\xdc\x79\x56\x57\xb2\x47\x43\xa7\xc7\x50\x51\
\x1d\x72\xc7\xb3\x2b\x36\x3d\x36\x67\xeb\x65\xd4\xf6\x34\x32\xa4\
\x0a\xcf\x00\x00\x80\x00\x49\x44\x41\x54\xea\xe1\xd1\x14\xf1\x7d\
\xc4\x68\x3e\x50\xeb\x97\x5a\x31\x5f\x63\xc8\x65\xa0\xbc\xd7\xc8\
\x11\xfb\x36\x67\xac\xd9\x86\xbd\x5a\xf3\xf7\x10\x82\xe0\xcf\x48\
\x03\x7a\x3a\x4e\x83\x96\xcb\x40\xb1\xa1\x88\xc7\xb7\xbd\x6b\x42\
\x8a\x30\xf8\x31\xd0\x9b\x30\xbc\x8d\x20\xa8\xac\xbb\xfe\x0d\x8c\
\xfb\x1b\x02\xf7\x8e\xae\xf9\xac\xce\x78\xc2\x0d\xa8\x73\xae\xf4\
\x0d\xed\xe7\x7d\x46\x3d\x63\x5b\xab\x3b\xc2\x96\x04\xc1\x57\x80\
\x37\xb8\x67\xf4\xe4\xda\x6d\xdf\xcb\x76\x86\x21\xdc\x7b\x1e\x35\
\x63\x3a\x37\xb2\x39\xf7\x8e\x86\xb1\x13\xa2\x8a\xbb\xf9\x10\x7f\
\x16\x66\x20\x88\x29\x5c\x6a\xc6\x44\x6e\x08\x8a\x91\xa9\xeb\xef\
\x11\xa3\xe5\xe1\xe1\xb1\xf7\xe8\x84\x84\x7e\x77\xd2\xb0\xfb\xf4\
\x07\x1b\x67\x23\xed\xf2\x73\x48\xd8\xe6\xe1\xb1\x3f\xd1\x15\x59\
\x4f\x7d\xd7\xdf\x11\x6e\x20\xc2\x10\xda\xb7\x48\x73\xc9\xe0\x36\
\xbc\xbb\x6a\x27\x21\xba\xf7\xfb\xca\xe2\x32\x3e\x7a\x42\x7b\x9a\
\x17\xa4\x72\xd2\x12\xa9\x00\x96\x6f\xad\x64\x4a\x2c\x76\x70\xb7\
\x56\x85\x8c\x19\xd4\xa6\xc1\x65\x7b\x78\x78\x34\x51\xec\x3d\x11\
\xdf\x74\xca\x15\x53\xf4\x04\xd2\xa4\x64\xf7\x7b\x5b\x42\xb2\x88\
\x59\x39\x17\x82\x22\xee\x19\x1d\x49\x1e\xf7\x77\x59\xc9\xfc\xf6\
\x36\xff\x7c\xe9\x0f\xc5\xf8\xe6\x2b\xf3\xce\x89\x15\x84\xe1\x5f\
\x09\x12\xce\x6b\xf6\xa6\x8e\xb9\xd2\xfe\x72\x3f\xb7\x51\xf7\x8e\
\xeb\x7f\xe6\xe1\xe1\xe1\x91\x1f\xad\x90\x76\xf6\xe5\x43\x5d\x11\
\x8f\x23\x1b\x9e\x11\xde\x2b\x04\x8c\x19\xd8\x9a\x3f\xbc\xbb\x91\
\x75\xdb\x15\x0b\x78\xfa\x9a\x9d\x2c\xdc\x58\xce\x89\xdd\x4b\x72\
\xc6\x14\x0e\x08\x98\xb4\x6c\x3b\x6b\xca\xa2\xd8\xc1\x67\xf7\x69\
\xc5\xc0\x0e\xcd\x8e\x3a\x6d\xb0\x87\x87\x47\x0c\x49\x4d\x5e\x2e\
\x26\x25\x9e\x66\x8f\x76\x2d\xf6\xac\x0a\xf8\xcd\xe8\x86\xe7\x57\
\x1b\x2f\xd4\x2a\xcb\xbd\x77\xe7\xc4\x48\x23\xb9\x2f\x0c\xa1\x34\
\xb3\xcb\x91\x36\xdd\xa3\xf1\x70\x26\xa5\x1e\x1e\x1e\x1e\x47\x3a\
\x5e\x3c\xd4\x15\xf0\x38\x3a\xe0\x19\xe1\xbd\x40\x36\x0c\x19\xd8\
\xb1\x98\xb3\xfb\xb4\xe4\xb1\x39\x5b\x01\xd8\xb4\xab\x9a\x89\xcb\
\xb6\x33\x22\x16\x67\xd8\x21\x00\x76\x54\x66\x78\x79\x51\xe9\x1e\
\xd3\xe9\xe2\x82\x14\x57\x0e\x6b\x4b\xb3\x82\x54\x9d\xe6\xd4\x1e\
\x1e\x1e\x47\x05\xf2\x39\xea\x71\x70\x0e\x93\xb2\x0d\x7c\x2f\x5f\
\xfa\xda\x88\x33\xb7\x63\x27\xe6\xf2\x60\x1b\x40\x10\x10\x66\xb2\
\x8c\x9d\xb8\x8f\xcc\xf0\x3e\xbc\xe3\x91\x1b\xf7\x8e\x3e\xd4\x35\
\x38\x12\xe1\x1c\xe6\x38\x91\x4f\x48\xc3\x9c\x03\xc5\xdf\x77\xef\
\x35\x75\xec\x4b\x5d\x9b\x4a\xfb\xf6\xb6\x1e\xb9\x2e\xa6\xc4\xc7\
\xd9\x61\x6f\xc6\xda\x23\x3f\x72\x8d\x4f\x53\x99\x3b\xf5\xd5\xd3\
\xe3\x28\x87\x67\x84\xf7\x12\xcd\x0b\x52\x5c\x3e\xb4\x2d\xcf\x7d\
\x20\x8f\xd1\x61\x08\xaf\x2d\x2e\xe3\xb6\x93\x3b\xd2\xa6\x38\x5d\
\xe3\x9e\x75\x2a\x08\x98\xbb\x61\x37\xef\xad\x89\x62\x07\x0f\xeb\
\x5c\xcc\x69\xbd\x4a\xbc\x36\xd8\xc3\xe3\x48\x40\xae\xfb\x99\xd5\
\xd5\xd0\xa2\x08\x2a\x32\x72\x08\x90\xc4\x9e\xbb\x9f\xa9\x00\xb2\
\x3f\x44\x8e\x97\x7e\xc6\xd8\x89\xb9\x62\xa9\x9e\x87\xbc\x04\x7f\
\x1f\x39\x91\x01\x39\xd7\xf9\x2f\xe0\x3d\x8a\xc3\xdf\x31\x76\x62\
\xfc\x58\xff\x22\x72\x7a\xf3\x6d\xbe\x3a\xbe\x9c\x74\x3c\xe2\x11\
\x39\xee\x89\xee\xf9\x76\x3c\x0a\x21\xf1\x33\xc6\x4e\x9c\x61\xbf\
\x15\x43\x78\x37\x41\x6a\x02\x84\x39\x1a\xea\xe1\x71\xd8\xe3\x44\
\xe4\xbd\x7c\x1b\x5a\x0d\x45\xc8\x01\xd4\x03\x44\x0e\x9b\xea\xc2\
\x79\xc8\xe9\x4a\x53\xba\xc3\xd8\x01\x85\x6b\x9a\x40\x4d\xcf\xd9\
\xc3\x51\x1c\xde\xbf\xd1\x70\x2f\x00\x9f\x42\xfb\xce\x84\x03\x50\
\xcf\x53\x90\x95\xc3\xfb\xf5\xa4\x0b\x90\x27\xec\xb9\xc8\x91\x58\
\x7d\x28\x40\x61\xd6\x76\x21\x4f\xfb\x59\xe4\x74\xe9\x7b\x68\xef\
\x74\xfb\xec\x46\x74\x47\xb0\xa1\x71\x72\x3d\xf2\xe3\x2a\x34\xef\
\xfe\x6a\xff\xa7\x80\xbb\x90\x59\xf3\x9c\x46\xe6\xdd\x15\x79\x83\
\x9e\x40\x34\x76\xfb\x8a\xab\xd1\xba\x7e\xad\x91\xf9\x78\x1c\x41\
\x38\x3a\x5c\x45\xef\x47\x64\xc2\x90\xd3\x7b\x97\x30\xb8\x63\xf1\
\x9e\x67\xb3\xd7\xef\x66\xce\xba\xdd\xa4\x12\x44\x6f\x96\x90\x57\
\x17\x97\xb1\x75\xb7\xd6\x6e\x10\xc0\x25\x83\xdb\xd0\xa9\xe4\xe8\
\x70\x4c\xe6\xe1\x71\x14\xa0\x0d\x0a\xf1\xd3\x03\x31\x93\x3d\x29\
\xdb\x01\x95\x59\x90\x53\x9f\xa1\xe8\x10\x6f\x0d\xa1\x63\x3c\x5b\
\xeb\x59\xb6\x2f\x72\x08\x72\x9a\xe5\xd5\xd2\xd2\x9e\x88\xbc\x5b\
\x82\xbc\x61\x5e\x86\xbc\x71\x3a\x94\xa0\xb0\x40\xa7\x92\x09\x86\
\x21\x4f\xb6\x85\xfc\x1a\xec\xdd\xf3\x80\x34\x9b\x36\x81\xbc\xb5\
\x8e\x00\x7a\x52\xd4\x02\xee\x9c\xa0\xfb\x1a\xd0\x07\x18\x41\x40\
\x6f\x32\x41\x80\x1c\xa7\x5c\x61\x7f\xdb\xda\x3b\x2e\xac\xc4\x58\
\x42\x6a\x9b\xbc\x78\x78\x1c\xfe\xe8\x8e\xd6\xe9\xef\x81\xdf\x22\
\xef\xc8\x17\xa3\xb5\xe0\xe0\xc2\xb0\xc4\xe1\xc2\xfa\xf4\x02\x06\
\x50\x33\xc6\x36\xd4\xd6\x3c\xe6\x52\x3a\xe4\x53\x44\xa4\xea\xf8\
\x3f\x1e\xd2\x29\x5e\x4e\x3c\xdc\xcb\x31\x28\xf4\x52\x41\xe2\xf7\
\x1d\xc8\x7b\x74\x3c\x26\x75\x3a\x47\x5e\xf1\xef\xc7\x59\x1b\xe3\
\x75\x4e\x25\xd2\x05\xd4\x0e\x37\x93\xab\x5e\xf1\x77\x03\x14\xca\
\xe6\xf8\x58\xda\x5c\xf9\x60\xf5\x5d\x83\x3c\xfc\xba\xb4\x75\x85\
\x3f\x1a\x80\xf6\xc0\x8b\xd0\xfe\x09\xda\xc7\x46\x22\xc7\x4b\xbf\
\xb4\xcf\x5f\xc9\x1d\x33\xdd\x63\xef\x31\x10\xcd\x95\x38\x4e\x41\
\xe7\x58\xae\xf9\x1c\xe4\xf8\xee\x90\x9c\x07\x27\xa3\x70\x6f\xc9\
\xb9\x94\x0b\xe9\x7a\xf2\x5a\x4f\x4d\xc1\x47\x43\xd6\x93\xc7\x11\
\x0e\xaf\x11\xde\x4b\x84\x21\x74\x69\x59\xc8\x45\x83\x5a\x33\x6b\
\x9d\x34\xbd\xa5\xe5\x19\x5e\x5b\x52\xc6\x59\x7d\x5a\xee\x49\x17\
\x04\xb0\x69\x67\x35\xaf\x2d\x8e\xf6\xd9\x4e\x2d\x0a\xb8\x78\x50\
\x1b\xa3\x43\x3d\x27\xec\xe1\x71\x04\xe0\x4c\x44\x44\xaf\x43\x44\
\xf5\x3a\xda\xb5\xf9\x34\x01\xab\x20\xf8\x11\x0a\x4f\x91\x06\xde\
\x83\xe0\x6b\xc0\x76\x02\x7e\x09\x9c\x8f\x88\xd2\x3e\xc0\x24\x08\
\xdb\x41\xf0\x53\xcb\xa3\x08\x85\x9a\xb8\x1d\x99\xee\x55\x53\x73\
\xc3\x08\x81\x4a\x14\x5f\xf1\x34\x14\xaf\xf6\xff\xf8\x32\xbf\x8a\
\xa5\x0f\xe8\xd2\xf9\x66\xe0\xdb\x88\xb1\xdd\x46\xe5\xae\x1f\x01\
\x4f\x12\x72\x03\xf0\x5d\xc4\xc4\x97\x51\x10\xfe\x3b\x92\x92\x57\
\x59\xda\x9f\x03\x43\x20\xbc\x0d\x82\x89\xc0\x2d\x04\xc1\x71\xc0\
\x3b\x87\xba\xb3\x3d\x3c\x1a\x80\x3e\x48\xfb\x39\x15\x69\xfd\xea\
\x42\x88\x42\x43\xb9\xf0\x49\x69\xe4\x41\xd7\xc5\x51\xbe\x0c\x31\
\x55\xd5\xe8\x3e\xfd\x24\x64\x71\x71\x1b\x22\x9a\xbb\xa2\xd0\x51\
\x27\x21\xc2\xff\x8f\x48\x80\xf4\x25\x14\x9a\xab\x25\xf2\x7c\xdb\
\x09\x85\x75\x79\x00\x39\x01\x72\xcf\x96\xa1\x50\x47\x9b\xad\xfc\
\x62\x14\xef\xf4\x45\x14\x32\xe8\x64\xc4\xc0\x3d\x04\x5c\x0f\x9c\
\x80\x18\xc2\x47\xac\xce\x5f\xb2\x3a\xf7\xb0\xb6\xfe\xd5\xea\x7b\
\x2a\xd2\xd2\xa5\x50\x0c\xdf\x8c\xd5\xb3\xad\xd5\xfb\x2c\xfb\x3d\
\x6d\x6d\x9a\x05\xdc\x0c\xdc\x8b\xb4\xc8\x9f\x40\x4e\xf4\xaa\x91\
\x46\xb5\x0d\x70\x0b\x62\x78\xd2\xd6\x17\xaf\x5b\x5d\x5b\xa2\xfd\
\xe8\xf7\x44\xf1\xbb\x3f\x8d\xc2\x47\x65\x80\xc7\xac\x4e\x03\x50\
\x88\x9b\x67\x50\xd8\x9c\x33\xad\x6e\x6f\x21\xe1\xde\x4d\xd6\xfe\
\x69\xc8\x89\x9f\x0b\x83\x14\x20\x4d\xee\x06\xb4\x6f\x9e\x86\xf6\
\xc8\x56\xd6\x0f\xc9\xe8\x13\x17\xa0\xf0\x3d\x2d\x90\x50\xe3\x0f\
\xf6\xbc\x02\x69\x95\xe7\xee\xd7\xd9\x76\x64\x22\x40\x02\x95\x9e\
\x28\x7c\x5a\x7d\xe1\x95\xb2\x68\xec\xba\xd8\xff\x2e\x16\x7a\x0a\
\xc5\x77\x9e\x8c\xb4\xf9\xc7\xa0\x31\x9c\x87\xc6\xbf\x19\x5a\x2f\
\xff\xb0\xdf\x4f\x41\x71\x7e\x8b\x91\xa5\xc0\xd3\x68\xee\x9c\x89\
\x04\x1b\x6f\xa1\xb9\xd9\x1b\x85\x12\x7b\xd0\xca\xbb\x1d\x59\x56\
\xf5\x42\xe7\xd4\xa3\x48\x40\x7c\x13\x12\x3c\x7f\x80\xd6\x5e\x07\
\x34\x77\x5a\xa2\xb8\xd6\xc3\x90\x30\xe4\x9f\x28\x34\xd8\x67\xd1\
\xbc\xe9\x8c\x42\xd1\xfd\x91\x68\x6d\x7a\x1c\xa1\xf0\x1a\xe1\x7d\
\x40\x8a\x80\x8b\x07\xb7\xa1\x7d\x8b\x48\x8e\x30\x71\xe9\x76\x36\
\xee\xaa\xde\x63\x09\x99\x0a\x02\xa6\xad\xd9\xc9\x07\x1b\xcb\xf7\
\xa4\x39\xb3\x4f\x2b\x86\x74\x2a\xf6\x66\xd1\x1e\x1e\x47\x0e\x0a\
\xd0\xe1\xff\x3a\x32\x5f\x1e\x4a\x10\x9c\x42\xc8\x15\xe8\xa0\xfd\
\x5f\xe0\x0e\x74\xc0\x7f\x81\x80\x0b\x90\x79\xd6\x2f\xec\x37\x93\
\x3c\x07\xcd\x80\x19\x10\xfe\x10\xc5\x75\x3c\x1b\x11\x9d\xf9\x4c\
\x18\x03\xa4\x25\xf9\x22\x8a\x8b\xf8\x55\x02\x7a\x5b\xfa\x10\x11\
\x0a\xdf\x47\xc4\xf2\xad\xf6\xf7\x07\x04\xc1\x08\x64\x36\xb8\x10\
\xc2\x4f\x20\x22\xb2\x27\x91\x64\xfc\x0e\xe0\x42\xe0\x47\xa4\x0a\
\x97\x20\xe2\x3d\x40\x84\xb5\x87\x47\x53\x47\x11\xf0\x43\xe0\x49\
\x14\x16\x26\xa8\x27\x7d\x16\x69\x25\xef\xb6\xf7\x7e\x61\xcf\x9f\
\x45\x21\xc5\x3e\x86\x88\xe4\x97\xd0\x5a\x3b\xde\xf2\x5d\x85\x62\
\x09\xb7\x44\x7b\x40\x57\x64\x45\x11\xd8\xff\x23\x11\xf3\x38\x16\
\x31\x11\xbf\x47\x04\xf9\xa9\xc0\xbf\x21\xa2\xfd\x0f\x88\x19\xbe\
\x3d\x56\xcf\x0a\x6b\xc3\x25\xf6\xec\x0a\x24\xa0\xfa\x88\xbd\xfb\
\x67\x44\xb0\x7f\x03\xc5\x57\x3d\xd7\xd2\xff\x09\x11\xfe\xe7\xa1\
\x35\x3d\x0f\x31\xb8\x27\x23\xc1\xc0\xc3\x88\x29\x3d\x01\xc5\x01\
\xbe\x03\xc5\xd7\xfd\xa7\xe5\xdb\x1f\x31\x98\x85\x56\xee\xb1\x40\
\x3b\xb4\x97\x64\x91\x60\xa1\x3d\xf0\x3b\x14\x77\xf5\xf3\x88\xa9\
\xbe\xc0\xea\xf7\x28\x8a\x19\xeb\x70\x0e\x62\x54\x1f\x46\xcc\x89\
\x7b\xf7\x2d\xeb\xc7\x1d\xc8\x64\x76\x3c\x62\xa2\xef\x46\x0c\xf0\
\xdf\x2c\xcf\x8b\x13\xe3\x74\x2c\xda\x67\x5d\x3d\x1f\x47\x26\xec\
\x9f\x43\xcc\x94\x43\x2b\x2b\xfb\x79\xfb\x5c\x68\x63\x14\x22\x86\
\x6b\x2c\xf0\x23\xfb\xf8\x3d\x2d\x3f\xda\x23\x0b\x89\xa7\x80\x6b\
\x1b\x90\x3e\x0b\x8c\x06\xee\xb1\xcf\xff\xa2\x39\x53\x6e\xbf\x5d\
\x89\xe6\xd5\x25\x96\xbe\x2b\x30\xca\xf2\x9f\x8e\xd6\xc4\x70\x74\
\x3d\x67\x1a\x12\xe8\x8c\x22\x8a\x17\x3e\x1b\x09\x37\xbe\x84\xd6\
\xd5\xef\xd1\x7c\xfe\x8a\xd5\xf5\x32\xc4\xec\x3e\x8c\x04\x36\x83\
\xd1\xda\xdd\x8e\x04\x52\xbd\x90\xb0\x68\x20\x5a\x0f\x1f\x45\x6b\
\xf9\x0f\x68\x1e\x7d\x1b\xad\xc5\x51\x68\x3e\xfd\x15\x09\xbc\x2e\
\x3b\xd4\x03\xe1\x71\xe0\xe1\x35\xc2\xfb\x80\x6c\x18\x72\x8c\xdd\
\xf5\x7d\x71\x41\x29\x00\x0b\x36\x95\x33\x7d\xcd\x2e\x2e\x1d\xd2\
\x86\x4c\x18\x52\x95\x09\x79\x79\x61\x19\xbb\xaa\x44\xc7\x16\xa5\
\x03\xae\x18\xd6\x86\xe6\x85\xde\x49\x96\x87\xc7\x11\x84\x00\x11\
\x80\xcf\x20\x4d\x52\x19\x22\x4c\x8f\x43\x12\xeb\x87\x20\xd8\x6a\
\x4c\xe7\x89\xe8\xf0\xde\x06\x3c\x45\x10\x2c\x27\x0c\xbf\x88\x98\
\xd0\x72\xa0\x19\x04\xdf\x44\x04\x5f\x7d\x51\x80\x53\x88\x38\x7f\
\x1d\x69\x91\x2f\x47\x07\xbc\x23\x5c\xfb\x21\x62\xe3\x3b\xc0\x9b\
\x48\x3b\xf3\x6b\x44\x44\x76\x03\xfe\x0a\xc1\x04\x42\x26\x11\x06\
\x59\x52\xe1\xf9\xe8\x3c\x38\x1d\x58\x4d\x18\xae\x15\x7d\x1b\x38\
\x4d\x71\xbb\x43\xdd\xd1\x1e\x1e\x0d\x40\x16\x58\x8d\xd6\xde\x87\
\x0d\x48\x1f\x20\x53\xc9\x77\x10\xe1\x7b\x11\xf0\x03\x60\x05\x12\
\x58\xf5\x40\xcc\xa8\xbb\x3e\x70\x12\xd2\x2a\x3d\x6d\xf9\xbf\x88\
\xb4\x99\xce\xc9\x96\x3b\xdc\xab\x2d\xdd\x40\x64\x86\xbb\x1a\xf8\
\x89\xe5\xf7\x3d\xa4\xf1\x6a\x8f\x84\x50\xa0\xf5\xec\xde\x7f\x09\
\x31\xaa\x03\xed\xf3\x0f\x74\xdf\xb2\x2b\x91\xd6\xb4\x17\x32\x3b\
\xdd\x8c\xb4\xb3\x1f\x20\xc6\xb2\x8b\xd5\xbd\xd4\xda\x95\x41\xeb\
\x7f\x31\x5a\xf7\xd5\x48\x2b\xb7\x0d\x78\xc5\xca\x9b\x8e\x98\xe8\
\x6c\xac\xfe\xf1\xef\x29\xc4\x88\xb4\x43\xda\xbc\x21\x56\x97\x62\
\xa4\x4d\x9f\x44\xe4\xbf\xc0\xf5\xe9\x6e\xb4\x37\x2d\x45\x9a\xb5\
\x22\xc4\xe0\x0e\xb1\x76\xa7\xac\x0e\xeb\xac\x5e\x83\xd1\xde\xe4\
\xae\x85\x0c\xc9\x31\xae\x6e\x6f\x9b\x68\xf5\x49\x21\x41\x40\x33\
\xa2\xbb\xd0\x23\xd0\x75\x94\x13\xd1\xbe\x3a\x1c\x09\x03\x66\x59\
\x5f\xcc\x8f\xd5\xd5\xdf\x0d\xce\x8f\x2a\x60\x25\x3a\x5b\xea\xb3\
\xaa\x00\x8d\xc5\x6b\x68\x6e\x83\xfa\xfe\xb7\xf6\xfc\x65\xe0\x3f\
\xd0\x18\x0f\x07\xfe\x1b\xad\xa3\x57\x90\x16\x78\x01\x12\x7c\x5c\
\x8c\x04\x24\xcf\x22\xe1\xc8\xf3\x48\x20\xfc\x2a\x9a\x67\x95\x68\
\x8e\x6c\x40\xc2\xdd\x8e\x48\x73\xdb\xdc\xf2\x78\x0d\x9d\xa3\xa5\
\x68\x8e\xbd\x6f\xe9\xba\x5b\x39\x1b\xd0\x1c\x2a\x44\x82\xaa\x27\
\x91\xc0\x68\x05\x62\xd0\x07\x59\x9a\xe7\xd0\x3c\x99\x8f\xe6\xa6\
\xc7\x11\x0e\xcf\x08\xef\x03\x42\xa0\xa4\x28\xcd\xe5\x43\xda\xf2\
\xea\xe2\x32\xaa\x32\x21\xbb\xab\xb2\xbc\xba\xb8\x8c\x31\x03\x5b\
\x93\x4e\xc1\x8a\x6d\x95\xbc\xb1\x3c\xf2\xb5\x31\xb8\x63\x31\x67\
\xf5\x6e\xe9\xb5\xc1\x1e\x1e\x47\x1e\x1c\x91\x96\x8e\xfd\xef\xcc\
\x2b\x87\x40\xb8\x1a\xe8\x8b\x08\xd5\x35\xc8\xf4\xaa\x2f\x61\x18\
\xa0\x83\x76\x1d\x22\xe8\xbe\x83\x34\x16\xcd\x11\xd1\x5c\x17\x42\
\xe0\x58\xc2\xb0\x3d\x41\xd0\x1f\x11\x09\x8e\xb0\x0b\x10\xf1\x59\
\x8e\x34\x40\xaf\x22\xe9\x77\x39\x3a\xf4\x77\x23\x33\xc5\xd6\x04\
\x5c\x4a\x10\x6e\x8d\xd5\xfb\x77\xc0\x59\x04\xc1\xe7\x09\xc3\x3b\
\x63\xac\xb8\xf7\xae\xea\x71\x38\xa0\x1a\xf8\x29\xd2\x02\xad\xa5\
\xfe\x3b\x48\x81\xa5\x9b\x60\x1f\x67\x15\x31\x1d\xad\xa9\x85\x48\
\xcb\x14\x20\xcb\x8b\x0d\x48\xe8\xe4\x9c\x84\x34\xb7\xdf\x32\x88\
\xc0\x0e\xd1\xfa\x2e\x21\xba\xd2\xd0\xdc\xd2\x9e\x84\x18\xd8\x52\
\xc4\xec\x2e\x40\xcc\x65\xd2\xcb\xfb\x7c\x24\x5c\xbb\x1d\xed\x17\
\xcb\x11\x63\x32\x15\x69\x42\x9b\x01\xe3\xac\x2e\x19\xfb\xcd\xb5\
\x05\x22\x4b\x3f\xd7\xf6\xca\xc4\xef\x95\x88\x31\x4d\x5b\x1d\x2f\
\x45\x7b\x82\x4b\x9f\x46\x7b\x17\xb1\x7c\x6e\x44\x9a\xd6\x67\x10\
\xb3\x72\x62\xac\xbf\xab\xa8\x8d\xf8\xf3\x9b\x91\x69\xeb\x93\x48\
\x43\x37\x9c\xc8\x5b\x77\x68\x69\xd7\x59\xdb\x4a\x11\xe3\xb2\x3e\
\xcf\x78\x85\x56\xd7\x78\x7b\x1c\x9c\x29\xfb\x12\xa4\x35\xc4\xc6\
\xef\x1a\xeb\xd3\x4a\xc4\x7c\xcd\xc6\xa3\x3e\x94\x01\x5f\x45\x56\
\x0c\x6b\x1a\xf8\x4e\x05\x62\x58\x41\x73\xa8\xd2\xfe\x2e\x43\xe3\
\x7b\x3b\x12\x7e\x2c\x45\x16\x52\x4e\x93\x5f\x68\x9f\xed\xf6\xac\
\xd0\xde\x6d\x45\x34\x77\x41\x73\x7d\x17\xb2\x22\x78\xd7\x7e\x2f\
\x41\xe7\xda\x2e\x34\x37\xdc\xdc\x4f\x21\xeb\x83\xf9\x88\x01\xff\
\x14\x5a\x63\xee\x53\x85\x2c\x05\x40\x6b\xc1\x95\x59\x45\xed\xf5\
\xe4\x71\x84\xc3\x33\xc2\xfb\x88\x30\x0c\x39\xa7\x6f\x4b\xfa\xb7\
\x6b\xc6\x82\x4d\x32\x7f\x9e\xbc\x62\x3b\x6b\xb7\x57\xd1\xa7\x5d\
\x11\x6f\xad\xdc\xc1\xca\x6d\xd1\x1a\xbe\x78\x70\x1b\xba\xb4\x2a\
\xf4\x4e\xb2\x3c\x3c\x8e\x2c\x38\x53\xc8\x20\xf1\xfd\x69\x44\x00\
\xfe\x0d\x1d\xd2\xad\xed\xfb\x2a\x44\x10\xfc\x01\x69\x73\x7a\x03\
\x33\x2d\x4d\x05\xd2\x5e\xf4\x46\xc4\x73\xbb\x58\x9e\xc9\x32\x01\
\x46\x11\x04\xcf\x21\x73\xc1\x97\x91\xd6\xc7\x11\x15\x0b\xd0\xdd\
\xbc\xcf\x01\x63\x10\x23\x7e\xbf\xbc\x3f\x07\x8f\x21\x2f\xac\xa7\
\x21\xcd\xcb\x1f\x91\xf6\xc6\xd5\x7b\x16\xf0\x7d\x82\xe0\x61\x22\
\x0d\xf7\x92\x43\xdd\xd1\x1e\x1e\x0d\xc4\x4e\x6a\x9a\xe9\xd6\x05\
\xe7\x4c\x27\x8d\x08\xed\x87\x91\xd6\xf3\xb3\x48\x33\x34\x1a\x59\
\x49\x04\x88\x11\xfc\x7f\xc0\x0c\x64\x92\xf9\x36\xba\xb7\xfb\x1c\
\x22\xf6\x7b\xa2\x75\xd5\x0d\x69\xa4\x36\xa2\xbb\x91\x5f\xb0\xb4\
\x57\xa0\xbb\xbe\x93\x91\x76\x14\xfb\x3b\x0b\x11\xed\x0e\xe5\x96\
\xe6\x3f\x91\x29\x68\x25\x5a\xdf\xb7\x22\xc6\xae\x9f\x95\x31\x93\
\x9a\xce\x86\x1c\x73\xb9\x1d\x69\xcb\x46\x50\xd3\x19\x50\x80\xf6\
\x86\x99\xc8\x51\xd5\x17\xd1\x9e\x73\x06\x32\x65\xad\x46\x0c\x83\
\x13\x94\x85\xb1\xfc\x5b\x5b\x3d\x2a\x90\x49\x71\xeb\x58\xbf\xe5\
\xba\x62\x17\xaf\x57\x6b\x6b\x53\xb9\xf5\xa5\x63\x40\x4a\x91\x66\
\x6e\x3a\xda\x17\x2f\x44\x9a\xed\x2b\x91\xd3\xb2\x5c\xf9\xc5\x9d\
\x64\x05\x89\xb2\x7b\x20\x61\xc3\x37\x89\x3c\x51\x8f\x40\xf7\x9e\
\x07\x5b\x5a\x4f\xf3\x36\x1c\xdb\xec\xd3\x10\xe4\x72\x5e\xe6\xe6\
\x5e\x35\x12\x32\xfd\x0f\x32\x41\x76\x9e\x9f\x2f\x41\xe7\xca\x60\
\x64\x31\xf1\x1c\x62\x90\xef\xb4\xe7\x97\xa2\x73\x72\x37\x1a\xdb\
\xbe\x48\xeb\x3b\x0a\x9d\x4b\xa7\x23\xe1\xef\xcb\xd4\x9c\xe7\xae\
\x2e\x1f\x45\x67\xd7\x7b\x96\x6e\x3b\xb2\xea\xa8\x46\x96\x1c\x1f\
\xb5\xf4\xc7\x22\xc1\xcb\x42\xa2\xab\x01\x2e\x1f\x8f\xa3\x00\xe9\
\x1e\xad\x8b\xee\xbe\x66\x78\xbb\xe2\x96\x45\x47\xc7\x98\x07\x01\
\x94\x55\x64\xf8\xc7\xfb\x5b\x28\x2d\x8f\x94\x1c\x97\x0e\x69\xc3\
\x88\x6e\x2d\x68\xa8\xd5\x72\x08\xb4\x2e\x4e\xb3\x7c\x5b\x25\x53\
\x57\xeb\xcc\xdd\x5e\x99\xe1\x94\x9e\x25\xf4\x6f\xdf\x8c\x7b\x26\
\x6f\x60\xde\x06\x09\x2e\x3b\xb4\x28\xe0\x5b\xa3\xba\xd1\xb3\x4d\
\xd1\x51\xcf\x08\x67\xb2\xf0\xe2\xc2\xd2\x5d\xf3\x36\x94\x3f\x44\
\xc3\x4c\xd7\x3c\x3c\x0e\x35\x46\x21\x82\xa0\x76\x98\x8f\xd3\x6f\
\xcb\xa2\x79\x3c\x05\x11\x76\xdb\x80\xb7\xc9\x36\x9b\x4b\x90\x99\
\x84\x34\xb3\x1f\x00\xff\x4b\xc0\x5b\x48\x62\xfe\x0e\x91\x49\xe1\
\x73\xc0\x74\x02\xc6\x23\xe6\xb5\x10\x99\x32\x4e\x41\xd2\xec\xd5\
\x88\x48\x7c\x9b\xb7\xef\xdb\x69\x65\x86\x56\xce\xbf\x90\x86\x77\
\x3c\x32\x43\xdb\x82\xa4\xd9\xf3\x80\xa9\x10\xbe\x09\xc1\x12\xc4\
\x70\x3f\x04\xdc\x07\xc1\x0e\x24\x4d\x5f\x66\xcf\x1f\x41\x0c\xfa\
\x0e\x44\x0c\x4c\x21\x0c\xa7\x13\x04\x65\xd6\xae\xbe\x48\x5b\xfd\
\x4b\xde\xbe\xcf\x3b\x0d\xf1\x68\x0a\x28\x20\xba\x3b\xd8\xd8\x33\
\x24\x83\x34\xab\xce\x59\x56\x25\x5a\xaf\x2d\xd0\x3a\x9c\x85\x98\
\xc2\x34\xba\x07\xbb\x10\xed\x03\xc5\x48\x6b\x3a\x09\x31\x96\x73\
\xd1\x5a\x1c\x80\xd6\xed\x9b\x96\x76\x2a\xd2\x72\xf5\x40\xa6\x9e\
\xaf\x23\x46\x3a\x8d\xd6\xd6\x4c\x22\x53\xd0\x38\xd6\x23\x4d\xdc\
\x6b\x88\xf9\x5c\x82\x34\xd7\x83\xd1\xda\x7f\x18\x31\xda\x95\xc0\
\x22\x24\x48\xcb\x20\x73\xd6\xb9\x44\x5a\xdf\xf9\xd6\xb6\x0d\x48\
\x13\xb6\x05\x69\x44\xdf\x47\x02\xb7\x02\xb4\xfe\x3f\xb0\xfa\xf6\
\xb1\xb2\x5f\xb5\x32\x9d\x23\xb1\x37\xac\x4f\x3a\xa1\xbd\x69\x86\
\x3d\xdf\x6a\xef\x26\x43\x4d\x39\x6d\xfa\x56\xb4\xaf\x35\x47\x66\
\xac\x53\xac\xec\xc5\x56\xef\x4e\xf6\xfd\x15\xfb\xbd\x33\xd2\x76\
\x4f\xa6\xa6\x96\xbc\x9a\x68\xcf\xfa\x90\x48\xdb\xef\xca\xcf\x20\
\xc1\xe1\x06\x7b\xd7\x11\x77\x5b\xd0\xde\xb6\xd6\xfa\x66\x36\x0d\
\x17\x92\x1c\xe9\x28\x41\xd6\x0d\x2f\x51\xbf\x33\xac\xfa\x90\x41\
\xf3\xdf\x99\x9d\x07\x68\x0e\xcc\x47\xe7\x22\xc8\x3a\xe9\x8f\x56\
\xd6\xb1\x68\x7c\xb7\x22\x26\xf5\x3e\x34\x76\xd3\xd0\x1c\x68\x8f\
\x2c\x04\x26\x13\x59\x3a\x85\xc8\x22\xa1\x1c\xad\xb3\xc5\x48\xd8\
\xbb\x13\x31\xc6\x8b\x2d\xcf\x4a\xb4\x06\x5c\x5e\xdd\xd1\x19\xf9\
\x2a\x3a\x1f\x57\x21\xc1\xd3\x46\x64\x0e\xbd\x12\xdd\x09\xde\x46\
\xb4\xd6\x76\xa1\x39\xb7\x1c\x9d\xc1\x1e\x47\x1e\x5a\xa2\xab\x30\
\xe3\x83\x91\x3d\x4b\xb6\x3d\x70\x63\xff\x36\x5d\x5a\x1e\x1d\x21\
\x7d\x52\x01\xac\x2a\xad\xe4\xca\xfb\x17\xb1\x22\xa6\xb1\xfd\xd5\
\x95\xbd\xb9\xed\xa4\x8e\x54\xed\xc5\xfd\xdd\x74\x2a\x60\xd2\xb2\
\xed\x7c\xec\xd1\xa5\x94\x55\x68\xdf\xfd\xe4\x49\x1d\xf9\xfc\x69\
\x9d\xb8\xfe\xa1\xc5\x7c\x58\x26\x0b\x8b\xcb\x86\xb4\xe1\x4f\xd7\
\xf6\xa5\x79\x41\xea\xa8\xf7\x15\x5d\x51\x1d\x72\xc7\xb3\x2b\x36\
\x3d\x36\x67\xeb\x65\xd4\xf6\xf6\xe8\xe1\xd1\x14\xf1\x7d\x74\x20\
\x3e\x50\xeb\x97\x5c\x71\x84\x01\xd1\x05\x7b\x11\x81\xa1\x21\x8e\
\xe4\xef\x19\x9d\x28\x33\x71\x8d\x38\x19\x23\x38\xd7\x35\xe3\x5a\
\x69\x72\x20\x0c\x25\x31\x0c\x32\x01\x61\xfa\xff\x80\x34\x61\xf8\
\x55\xee\x3d\xaf\xb1\x31\x1c\x3d\x3c\xf6\x07\x8a\xd1\x7d\xf7\xdf\
\x23\x62\xd7\xc3\xc3\x63\xef\xd1\x09\xf8\x0d\xd2\xc0\xae\x3d\x80\
\xe5\x1c\x83\x2c\x0d\x56\x03\xbf\x42\x07\xd3\xad\x56\xfe\x3d\x87\
\xba\x13\x3c\x8e\x5a\x74\x45\x71\xc4\xbf\xeb\xcd\x44\x1a\x81\x6c\
\x36\x64\x44\xb7\x16\x9c\xd4\xa3\x05\x13\x97\x4a\x20\xfa\xf6\xaa\
\x1d\x74\x2a\x29\x60\xc3\x0e\xd1\x8c\x05\xa9\x80\xcb\x87\xb6\xa5\
\xa4\x28\xed\x9d\x64\x79\x78\x1c\x69\x70\xcc\x69\x53\x29\xb3\x21\
\xf5\x69\x68\x9d\xc7\x4e\x34\xed\x74\x38\x83\xc8\x9c\xcd\xc3\xc3\
\xc3\xc3\xc3\xa3\xa1\x70\xce\xac\x9e\x20\x12\xf7\xce\x04\x1f\x9b\
\xde\xa3\x69\xc0\x33\xc2\x8d\x80\x33\x8f\xbe\x6c\x48\x1b\xde\x58\
\xbe\x83\x4c\x36\x64\xe9\x96\x0a\x1e\x9a\xb9\x99\x6a\x63\x7a\x07\
\x74\x68\xc6\x39\x7d\x5b\x11\x1e\x0d\xea\x76\x0f\x0f\x8f\x23\x09\
\x95\xc8\x74\x1a\xee\x3d\xef\x50\xd7\xc5\xc3\xc3\xc3\xc3\xe3\xf0\
\xc3\x7b\xf6\x89\xc3\xc7\x72\xf6\x68\x32\xf0\x8c\x70\x23\x11\x86\
\x21\xe7\xf5\x6f\x4d\xaf\x36\x1b\x59\xbe\xb5\x82\xaa\x4c\xc8\xda\
\xed\x91\x13\xc5\x0b\x07\xb4\xa6\x47\xeb\xc2\x06\xdf\x3d\xf6\xf0\
\xf0\x38\xac\xe0\x1c\xb6\x38\x1b\xe4\xea\xc4\x6f\xf1\xef\xd9\x1c\
\xef\x36\xdd\x9d\xe1\x50\x68\xbb\x3d\x3c\x3c\x3c\x3c\x0e\x57\xb8\
\x33\xaf\x21\xde\xda\x93\xe9\x1a\xfa\xee\xde\xd4\xa5\xe9\x9e\xaf\
\x1e\x4d\x06\x47\x87\x87\xac\x03\x88\x6c\x08\x7d\xdb\x35\x63\x54\
\xbf\x56\xb5\x7e\x6b\x5b\x9c\xe6\xd2\x21\x6d\x48\xa7\xbc\x17\x76\
\x0f\x8f\x23\x14\x27\xa1\xbb\xc3\x7f\xb2\xcf\xcf\x91\x17\x56\x90\
\x07\xcc\x5b\x90\x43\x8e\xaf\x23\xa7\x39\xe7\x23\x27\x39\x3d\x91\
\xe7\xd9\x66\x7b\x57\x9c\x87\x87\x87\x87\x87\x47\x93\x43\x0a\xc5\
\xbb\xfe\x36\xf5\x2b\xd9\xce\x05\xae\x4a\x3c\xfb\x08\xf2\xc2\xbe\
\x3f\xd0\x0b\x79\x45\xf7\xe7\xab\x47\xbd\x38\x6a\x19\xe1\x54\x10\
\x90\x0a\xd8\xf3\x69\x0c\xab\x5a\x98\x0e\xb8\x7c\x48\x1b\x5a\x35\
\x4b\xd7\xc8\x73\x64\xcf\x12\x8e\xef\xda\x82\xac\x57\x07\x7b\x78\
\xfc\xff\xf6\xde\x3b\xce\x8e\xe2\xca\xdb\x7f\xfa\xde\xc9\x33\x1a\
\x8d\x32\x4a\x20\x09\x90\x84\x44\x0e\x22\x27\x01\x26\x63\xc0\x06\
\x6c\x1c\x70\xde\x5d\xaf\x03\xb6\x77\x1d\x76\xf7\x5d\xef\xfb\xae\
\x77\x7f\x5e\x6f\x70\xce\xf6\x3a\x1b\x1b\x6c\xa2\xc9\x41\x22\x67\
\x10\x02\xe5\x80\x72\x8e\x93\xd3\xbd\xfd\xfb\xe3\x7b\x4a\xdd\x73\
\x75\x47\x1a\x8d\xd2\x48\x3a\xcf\xe7\x73\xa5\x3b\x7d\xab\xab\xab\
\xbb\xab\xea\xd4\xa9\x73\xea\xd4\xc1\xca\x70\xd4\x8f\x7e\x0b\xf8\
\x26\x8a\xd8\xfc\x55\xb4\x57\xe6\x16\x14\x20\x64\x20\x52\x8a\x2b\
\x80\x8f\xa2\xc8\xac\xad\x28\xc2\x66\x88\x6e\x5a\xb8\xb5\x47\x96\
\x64\x2b\xa4\xc2\x2d\x4a\xc2\x16\x4d\x81\x28\x75\x9c\x22\xdf\x1d\
\xc7\x71\x1c\x67\x6f\x32\x1a\x6d\x81\x75\x01\x9a\xfc\x0d\x14\x93\
\x4f\xa3\x50\xe4\xe7\xf0\x7b\x16\x38\x0a\x45\x45\x0f\x74\xb7\x35\
\x57\x3a\xdf\x62\x72\xae\x04\xed\x31\x7c\x02\x49\xc4\xca\xc2\xb4\
\xa1\x4c\xe9\x6b\x74\xb7\x05\x94\xcb\xd2\x83\x9c\x43\xee\x05\xc7\
\xb1\xb6\x33\xfa\xe6\x55\xa3\x69\xe9\x48\x3c\x15\x27\x0f\xab\xa4\
\xb3\x97\xeb\x78\xf3\xf9\x98\x33\x8f\xa8\xe1\xd7\x37\x8c\xa5\xb5\
\x33\xc9\xf3\x88\xba\x72\x6a\xca\x3c\x52\xb4\xe3\x1c\xc4\xc4\x68\
\x7b\x87\x99\xf6\x7d\x26\x12\xe6\x57\xa2\xed\x1a\x0e\x43\x11\xa7\
\x3b\x81\xe3\xd1\xbe\x96\x37\x01\x3f\x43\xdb\x3a\x64\xd1\xf6\x4c\
\x17\xa3\xed\x2c\x96\xdb\x6f\x97\xa0\x7d\x7e\x63\x34\x68\xb8\x17\
\xb8\x1b\xed\x7d\x78\x1c\xda\x2e\xe2\x8f\x68\x0b\x92\x0f\xa3\xc0\
\x23\x63\xd0\x16\x12\xeb\x91\x55\x7a\x39\xf0\x43\x7c\xbb\x10\xc7\
\x71\x1c\xa7\xe7\x44\x68\x32\x77\x34\xda\x3a\xab\x27\xdb\x2b\x5d\
\x08\xbc\x85\x62\x4b\x5c\x81\xb6\x4e\x1a\x08\xfc\x15\x9a\xf0\x1d\
\x81\x82\x66\xfd\x02\x2d\x13\xea\x04\xfa\x23\xcb\xed\x33\x96\x26\
\x8f\x94\xd1\x2b\x2d\xbf\x4e\xe0\x01\xb4\xed\x58\x7a\x28\x7d\x3c\
\x70\x23\x92\x99\x33\x90\x2c\x2c\x07\x3e\x82\xb6\x05\xeb\x44\xdb\
\x87\xe5\x91\x42\x7c\x13\x9a\x88\x9e\x69\x69\x4f\xb3\xcf\x00\x34\
\xd9\xfc\x2c\x92\xcd\x83\xd1\x16\x4f\x73\xec\x1e\xce\x21\x09\xf6\
\xf5\x4b\x5c\x96\x1e\x94\x1c\x72\x16\xe1\x18\xa8\x28\xc9\x70\xe1\
\xb8\x5a\xae\x98\x50\xb7\xed\x33\x7a\x37\xf6\xf8\x8d\x81\xea\xd2\
\x0c\x53\x8f\xec\x9a\xe7\x31\x43\x2b\x5c\x09\x76\x9c\x83\x9f\x30\
\xa3\x1d\x98\x07\x8c\x45\xd6\xe2\x49\x24\xfb\x18\x2d\x40\x8a\xea\
\xc3\x68\x3f\xc3\x53\x90\x20\x3e\x0f\x78\x10\xed\x05\x3c\x05\x38\
\x0b\xed\x7b\xf8\x5d\xb4\xe7\xf0\x50\xcb\xf3\x5d\x48\x78\xff\x14\
\x09\xea\xbf\x43\x7b\x99\x4e\x45\x93\x9a\x3f\x47\xae\x65\x63\xec\
\xfb\xd9\xc0\x49\xfb\xfb\xe1\x38\x8e\xe3\x38\x07\x14\x03\xd1\xd6\
\x4a\x77\x21\xb9\xb3\x33\x2a\x90\xe2\xfa\x08\xda\x17\xfb\x5c\x24\
\xdb\xca\xd0\x5e\xad\xab\xd1\x5e\xbd\x97\x22\x85\xb3\xd3\xae\xf1\
\x45\x24\x1b\x5f\xb7\x7c\x72\xc8\x7b\xea\xfd\x28\x50\xe3\xfd\x48\
\x51\x4e\x5b\x8a\x87\x00\x5f\x42\xfb\x51\xff\x1c\xc9\xcb\xab\x81\
\x1b\x80\x71\x48\x3e\x6e\x46\xfb\xc4\x0e\xb1\x6b\xcc\xb0\xeb\x9f\
\x05\x5c\x86\x94\xe5\xf3\x81\xdb\xd1\xde\xc1\x9f\x44\x93\xcd\xab\
\x80\x0f\x58\xd9\x4e\x47\xfb\x14\xff\x02\xb8\x1c\x29\xdf\xce\x41\
\xc8\x21\x67\x11\x0e\x74\xee\x61\x77\xe5\x78\x2f\xe4\xe9\x38\xce\
\x01\x49\x19\x52\x74\xf3\x74\x0d\x90\xd5\x84\x66\xd6\xd7\xa1\x59\
\xf3\xbc\xfd\x7d\x2f\xb2\xf2\x9e\x06\x0c\x43\xb3\xd2\x1b\x90\x20\
\xbf\x06\xad\x3b\x7e\x15\xcd\xac\x0f\x05\xde\x83\x66\xa9\x87\x5b\
\xda\x8d\x68\x00\x32\x13\x0d\x38\x9e\xb1\xef\x1b\xd0\x8c\xbb\xe3\
\x38\x8e\xe3\xf4\x94\x76\x60\x29\x92\x31\xeb\x7a\x90\x7e\x32\x52\
\x14\x8f\xb5\x73\x8f\x46\x5e\x49\xaf\xa2\x25\x40\x8f\x00\x6b\x91\
\x7c\x1a\x8c\x86\xcc\x37\x20\x25\xf4\x03\x48\x36\x06\x77\xe5\x53\
\x80\x91\x48\xb9\xcd\xa0\xc9\xde\xd1\x68\x32\x18\xb4\xb4\x68\x22\
\x92\x97\xc7\x5b\x7e\x93\x90\xec\xbc\x1f\x2d\x4f\x02\x79\x52\x1d\
\x61\x65\x5a\x85\x64\xec\x20\xa4\x54\xaf\x40\x56\xe0\x99\x48\x31\
\x0f\x96\xe5\x51\xc0\x3b\x91\x22\x7d\xbf\x9d\x33\xc4\x9e\x43\xdd\
\xfe\x7e\x29\xce\xde\xe1\x90\x55\x84\x1d\xc7\x71\xf6\x10\xc1\xcd\
\x0b\x34\x33\x7e\x2a\x12\xb2\xf9\x22\x69\x43\xf4\xe8\xd8\xfe\x1f\
\x07\xfc\x03\xf0\x38\xf0\x9a\x9d\x0b\x9a\x91\xfe\x0a\x30\x0d\xb9\
\x86\x81\x94\xeb\x97\x81\x3b\xec\x3a\xc3\xd0\xe0\xa2\xc3\x3e\xd9\
\x54\xbe\x8e\xe3\x38\x8e\xd3\x1b\x1a\x80\xcf\xa0\xb5\xb6\xab\x76\
\x92\x36\x42\x16\xd3\x65\x48\x2e\x55\x00\x6f\x02\xd7\xa1\x6d\x92\
\x5a\x91\xa5\x37\x1d\xd7\x22\x83\x3c\xa3\xd6\x00\x9f\x00\xfe\x1e\
\xc9\xae\x18\xc9\xd2\x05\xc0\xef\xed\xef\xa7\x90\xcb\x75\x20\x87\
\x26\x79\xff\x8c\x14\xd6\xe1\xf6\xff\x47\xad\xbc\x58\x19\x4a\x91\
\x2c\x5c\x6b\x69\x37\x59\xda\x0d\x48\xf9\x6d\x49\x95\x25\xc4\xea\
\x88\xec\xfb\xf1\xc8\xea\x7c\x0f\xf0\x0a\x5a\xf7\x7c\xc8\x79\xd0\
\x1e\x2a\xb8\x22\xec\x38\x8e\xb3\x7b\x4c\x04\x3e\x64\xdf\x8f\x47\
\x42\xf8\x7e\x34\x63\x1d\xb6\x56\xca\x92\x58\x80\xcf\x44\x8a\x72\
\x84\xac\xc7\x15\x48\x90\x1f\x8e\x02\x88\x54\x22\x77\xae\x23\x81\
\x87\xd0\x7a\xa9\xb5\x48\x21\x7e\x3f\x30\x1f\x29\xd0\x87\x21\xf7\
\xb0\x2c\x5d\x83\x7f\x84\xef\xe9\x6d\x9d\x1c\xc7\x71\x1c\xa7\xa7\
\x6c\xb1\xcf\xce\x18\x82\x64\xda\xd7\x80\xe7\xed\xd8\x78\xe4\xa2\
\x7c\x1c\x92\x41\x85\xf2\x29\x42\x16\xe7\x5f\xa1\x38\x16\xd7\x93\
\xc8\xc9\x27\x51\xcc\x8c\xb3\xec\x9c\xf3\x80\xb9\xa9\xeb\x2d\x42\
\xd6\xe1\xcb\x90\xc2\x7d\x35\x52\x9a\x1f\x00\x6e\xb1\x34\x17\x22\
\x4b\xf1\xc2\x82\xb4\x57\x01\xbf\xb1\x34\x41\xb1\x8d\x8a\x7c\x2f\
\x47\x8a\xf4\x56\x14\xc4\x6b\x34\xae\x08\x1f\xb4\x64\x47\xd6\x96\
\x7d\xf9\xba\xc9\x03\x2a\x6a\xca\xfc\x1d\x3b\x7b\x9f\x5c\x1e\x1e\
\x9c\xbf\xb5\x79\xf6\xba\xd6\xdf\xb1\xf3\x99\x46\xc7\xe9\x0b\x9c\
\x8f\x06\x04\x6f\x14\xf9\x2d\x87\x04\x66\x7f\x14\xb0\x6a\x36\xf0\
\x63\x14\xb0\x2a\xcc\x46\x2f\x41\xb3\xd1\xb3\x91\xf0\x1f\x82\x84\
\xf9\x2a\x64\xe1\x5d\x86\x14\xdb\x75\x68\x96\x7c\x35\x72\x19\x5b\
\x89\x5c\xb6\x06\x21\x8b\xef\x23\xc8\xa5\xeb\x28\xa4\x38\xff\xde\
\xae\xd3\x86\x04\x7e\x33\x72\x4b\x9b\x8d\x66\xf4\x3b\xd0\x20\x60\
\xf3\xfe\x7e\x80\x8e\xb3\x07\x29\x41\x81\x6c\x5e\xc1\x65\x88\xe3\
\xf4\x96\x6a\x34\xc9\xfa\x10\x3d\x0b\x86\xd5\x1d\xfd\x91\x7c\x7c\
\x92\xc4\x33\x6a\x8b\x7d\xd6\x02\x8b\x91\xbc\xeb\x40\xf2\x69\x3e\
\x92\x5b\xeb\xec\xb7\xc5\x56\x96\xb9\x48\x56\xbe\x81\x2c\xc9\x63\
\x90\x62\xfc\x07\x24\xdf\x02\x6d\x48\x6e\x0e\x44\x5e\x51\x8f\x21\
\xab\xf1\x22\xcb\x73\x2c\x52\x7a\x5f\xb0\xff\x5f\x42\xeb\x95\x87\
\x20\xcf\xab\xa7\xac\x9c\xab\x51\xff\x91\x43\xb2\x76\x89\x7d\x5f\
\x8b\x26\xaa\xd7\x21\xb9\xbc\xd4\xae\xb1\x84\x9e\xb9\x89\x3b\x07\
\x06\x35\x68\xfd\xfa\x13\xd1\x69\xa3\xaa\xb7\xfc\xfa\xc6\x71\xfd\
\x87\xd5\x94\xf4\x3a\x58\x94\xe3\xf4\x94\xb6\xce\x98\xcf\xdc\xb7\
\x74\xc3\x9f\xde\xda\x7c\x05\xea\xcc\x1c\xa7\xaf\xf3\xcf\x48\x08\
\xfe\x7a\x7f\x17\xc4\x71\x1c\x2a\x80\xef\x01\x3f\x42\xca\xb0\xe3\
\x38\xbb\xce\x10\x14\x10\xeb\xb3\x48\x29\x74\x9c\x43\x89\xc3\x80\
\xff\x04\xfe\xc9\xcd\xc0\x8e\xe3\x38\x8e\xe3\x38\x8e\xe3\x38\xce\
\x21\x85\xaf\x11\x76\x1c\xc7\xe9\x2d\xb7\x4e\x2f\x7e\x3c\x47\xb2\
\xa1\x52\x0c\x7c\xfb\x82\xbd\x77\xdd\x6f\x5d\xb0\xe3\xdf\xd3\x14\
\x4b\xbb\x2b\xf9\xee\x89\xb2\xf5\x94\x4f\x4f\xb7\x67\x18\xc3\xb7\
\x2e\x84\xcf\x4e\xdf\x7e\xc5\x73\xc8\x3f\x7d\xcd\x38\x86\x6f\x5f\
\xd8\xfb\xeb\xee\xca\xfd\xdc\x3a\x8d\x2e\x85\x8a\x63\x88\xa2\xa4\
\xcc\xd0\xb5\xdc\xbb\xf3\x3c\x7a\x5a\xa6\x1d\xfd\xbe\xab\xc7\x7b\
\x5b\x8e\x3d\x55\x07\x1c\xc7\x71\x1c\x67\x2f\xe2\x16\x61\xc7\x71\
\x9c\xde\x13\x02\x7c\xe8\x13\xe7\xd5\xa7\x6a\x8a\x31\xc3\xde\xeb\
\x63\xc3\x75\x77\x14\x0c\x2b\x04\xcb\xea\x49\xda\x5d\xc9\xb7\x27\
\x79\x94\xec\xf6\xbd\x67\x63\xc8\x5b\xf0\x92\x5b\xa7\x2b\xb7\x38\
\xce\x90\xde\xb3\xf9\x96\xe9\xfa\x7f\xe3\xb6\xfb\xcd\x50\x52\xba\
\x5b\x97\xdd\xa5\x67\x12\xe7\xb1\xdf\x32\x9a\xf1\x08\x69\xf3\x91\
\x94\x64\xa0\x2c\x97\x4a\xb3\x0f\xca\x94\x50\x2c\x58\x5a\xd7\xe7\
\xb7\x6b\xf9\xed\xe8\x3a\x5d\xef\x4d\xef\xc9\x03\xb5\x39\xce\xa1\
\x47\x29\x7b\xaf\xed\xa7\x03\x6f\xed\x8f\xf3\x9d\x83\x10\xb7\x08\
\x3b\x8e\xe3\xf4\x9e\x29\x68\x9b\xa3\x0a\x00\xa2\xcc\x66\xe0\x0f\
\xe4\x79\x90\x88\xbf\x43\x81\x44\xbe\xca\xad\xd3\x5b\xa5\x28\x95\
\x42\xdc\x06\x91\xe9\x09\x71\x0c\xb9\x1c\x94\x58\x57\x1c\xd3\x8d\
\x98\xce\x53\xa0\x6b\x9c\x81\xb6\xb7\xf8\x57\x3e\x37\x7d\x36\xdb\
\xc7\x77\x18\x80\xf6\x1f\x7e\x14\x05\x02\xf9\x5b\xe0\xff\xe3\xd6\
\xe9\x05\x01\xbf\xb6\xbb\xe0\x09\x76\x3f\xff\xc1\xad\xd3\x5e\xdb\
\xf9\x98\x21\x5c\xb8\x4b\xba\x21\xc0\xdf\x01\x8f\x71\xeb\xf4\x47\
\xb6\x3b\x25\xc4\xe5\xec\x0c\xd6\x53\xcb\xa7\xa3\x03\xbe\xff\x0e\
\xfd\x79\xeb\x74\x88\xe3\x1a\x32\x7c\x19\xa2\x07\x81\x57\x89\xf9\
\x00\x51\x74\x39\x8a\xe8\x39\x13\xf8\x31\xc3\x58\x62\xd6\xc7\xe3\
\x80\xaf\x02\x39\x72\x9d\x5f\xe5\xd6\xc7\xe7\xf2\xad\x8b\x92\x6b\
\x76\xb1\x18\x87\x72\x14\x7b\xd8\x45\xef\x67\x2c\xf0\xaf\xc0\xcf\
\x81\x27\xb6\x1d\xfd\xcc\x13\x10\x45\xe7\xa0\x08\xdf\x1b\x21\xfa\
\x07\x88\xdb\x81\xff\x80\xec\x5b\x10\x7f\x87\x5b\xa7\xe7\x69\xe7\
\x38\x22\xfe\x19\x45\x48\xfd\xcb\x76\xe5\xd9\x76\x69\xb3\x64\x17\
\x2b\xeb\xb7\x2f\x28\x3c\xe7\x7c\xe0\xe3\xc0\x57\xf9\xcc\x13\x0b\
\xc9\xa4\xc6\x77\x0a\xf6\x31\x00\xf8\xff\x80\xe7\xe8\xba\xb6\xfd\
\xa3\xc0\x39\xc0\x57\xb8\x75\x7a\x3a\xd0\xd4\x24\xe0\x9f\x80\x9f\
\xf1\x99\xc7\x1f\x27\x93\xed\x5a\x86\x4c\xa4\x7a\x9a\xd9\x6e\x1c\
\xd9\x0f\x45\x8b\x9d\xcb\xad\xd3\x7e\x98\xfa\xed\x52\x14\x35\xfd\
\x1b\x68\xfb\x14\xc7\x71\x0e\x6e\x8e\x43\xfb\xde\x0f\x46\x6d\xfe\
\x1e\xe0\x45\x60\x77\xa3\x0f\x0d\x47\xbb\x31\x3c\x82\xa2\x42\xcf\
\x23\x89\x4e\xdd\x13\x46\x58\xd9\x1e\x01\xae\x45\x81\x24\x1f\xdb\
\xdf\x0f\xcb\xe9\x3b\xb8\x45\xd8\x71\x1c\xa7\xf7\x1c\x86\x22\x0f\
\xae\x40\xd1\x29\x27\x03\xff\x43\xc4\x04\xe0\x64\xb4\xf5\xc3\xd1\
\x48\xc1\xec\x07\x9d\x90\x29\x03\x18\x69\xbf\x8f\xa2\xac\x02\x34\
\x29\x39\x99\x88\x23\x2c\x8f\x89\xc4\x94\x20\x25\x6c\xbc\x69\x8c\
\x59\xb4\x55\xd3\x18\x34\x38\xb8\x0c\x18\x48\x44\x06\x45\x92\x9e\
\x62\xff\x67\xd1\xb6\x4c\x17\xeb\x5c\x46\xa0\x7d\x1e\x07\x01\x43\
\xed\xba\x13\x80\x63\x81\x72\x1b\xa6\x8c\xb1\xb4\xc3\x2c\xed\x10\
\xe2\x0c\xc0\x28\xcb\x77\x12\x52\xf6\x4b\xac\x7c\x63\xec\xfc\xa3\
\x88\x29\xb7\x72\x4d\x24\xa2\x04\xed\xcf\xf8\x02\xb0\x5c\xf7\xcc\
\xb1\x10\x8f\xb2\x67\x30\x86\x88\x0c\x9d\x31\x28\xca\xf6\x71\x96\
\x4f\x05\xa5\xe5\xc9\x53\x95\x8b\xf1\xc5\xc0\x3b\x89\x59\x8d\xa2\
\x9b\xfe\x7f\x40\x3d\x8a\x04\xfa\x7e\xe0\x2b\xb4\x51\x62\x5b\x40\
\x5e\x6d\xe5\xbe\x12\xb8\x92\x8e\xe5\x5d\xdf\x92\xee\x71\x00\x70\
\x32\x11\x27\x02\x03\xc8\x47\xe1\xfe\x26\xa2\xad\xab\x4e\x02\x06\
\x11\x67\xe1\x5b\xf7\x87\xdf\x4e\x40\xdb\x58\x5d\x6a\x7f\x27\x44\
\x51\x06\xa2\x9b\x80\x8b\x80\x77\x01\x17\x42\xd4\x80\x06\x82\x1f\
\xb7\x67\x09\x11\x57\x01\x53\xe9\x1a\x71\xb4\x04\x38\x06\x38\xc2\
\x9e\xed\x31\xc4\x94\xf1\xd9\x27\xc2\xe4\xc0\x28\x7b\x4f\x63\xc8\
\x13\xf1\xd9\x69\xd8\x7b\x3d\xca\x9e\xd7\x44\x2b\x53\x7f\xf2\x71\
\x04\xd1\x38\x7b\x4f\x47\x43\x5c\x82\x26\x0b\xa6\xda\x35\xd2\x1c\
\x6b\xe7\x4d\x40\x7b\x69\x0e\xb2\xe3\x83\xec\xf9\x8d\x36\x25\xb8\
\x1f\x1a\x7c\x1e\x0b\x54\x12\xc7\x90\xcd\x00\xd4\xd9\x79\xc7\xa2\
\x48\xaf\xa5\x48\x29\x3f\xde\xbe\x1f\x87\x22\xad\xae\x01\x6e\x02\
\xce\xe2\x73\xd3\x77\xde\x8a\x1c\xc7\x39\x90\x39\x0e\x05\x95\x9c\
\x0d\x7c\x17\x29\xaa\xff\x88\xfa\xcf\x40\x09\x5d\x67\xd1\xa2\xd4\
\x71\x0a\x8e\xa7\xdd\x7a\x4e\x46\x0a\x6c\x09\xda\x61\x61\x13\x5d\
\xb7\x63\x2a\xd4\x63\x32\x45\xce\x7f\xa7\x9d\xbf\x0a\x45\xac\xde\
\xd5\x32\x39\x07\x31\xfe\xb2\x1d\xc7\x71\x7a\x4f\x0c\x34\x01\x3f\
\x85\xe8\x45\x88\xb7\x02\xff\x17\x29\x9c\xed\xc0\x38\x22\x7e\x09\
\x8c\x84\xe8\x76\xe0\x0b\xc4\xb9\x73\x21\xfa\x06\x30\x94\x28\x5a\
\x4f\xbe\xf3\xcb\xc0\xeb\x68\x7f\xc3\x08\x85\xf5\x2f\x27\xe2\x2b\
\x68\xff\xc2\x1b\x90\xa2\x17\xb6\x92\xf8\x15\xda\x72\xa2\x13\x88\
\xc9\x73\x33\xb2\xf8\xae\x40\x0a\xd2\xbf\x90\x6c\x11\x91\xb7\x32\
\x76\x10\x33\x8c\x88\x4f\x21\x25\xf9\x11\xe0\xd3\x10\xbd\x0f\x59\
\x57\xbf\x8f\x14\xd7\xbb\xec\xbc\x1c\x51\x7c\x26\xb2\xe8\xad\x41\
\x8a\xd3\x6f\x91\x75\xf1\xf7\x56\x96\x0a\x88\x3a\x89\x78\x06\xed\
\x23\xd9\x8f\x98\x2f\xa2\x41\xd0\xff\x43\x03\xa2\xd9\xba\xaf\x68\
\x2d\x9a\x34\x68\x20\xcf\xc7\x88\x98\x6d\xcf\xe0\x32\x95\x2f\xba\
\x8b\x38\xfe\x2a\x9a\xad\x87\x88\x32\xe0\x46\x60\x01\x11\xcb\xd1\
\x40\xa8\x1a\x58\x0a\xf1\x6d\x10\xdd\x6d\xe9\xf2\x90\xed\x87\x94\
\xbb\x07\x90\x72\x7d\x15\xa5\x63\x7e\xb2\x2d\x2f\xa5\x1b\x0d\x7c\
\xc7\xca\x3d\x88\x88\xa5\x10\xff\x35\x44\x1f\x47\x7b\x40\xaf\x06\
\xc6\x40\xf4\x2c\x51\xfe\x63\xdc\x7a\xe5\x64\x4b\x3f\x10\x0d\x9c\
\xca\xed\x59\x26\x44\xd1\x30\xe0\x02\xe0\x36\xa4\xcc\x5e\x43\x14\
\xff\x01\xa2\x3b\xf5\x3c\xa3\x29\xc8\xf2\x70\xa9\x9e\x49\xfc\x56\
\xea\xec\x81\xc0\xff\x5a\x79\x2b\x80\x6a\x32\xfc\x3f\xf2\xfc\x8c\
\x38\x7f\x0d\x44\x5f\xb5\x72\x36\x90\xe5\xeb\xc4\xdc\x06\xdc\x4c\
\xb0\x7a\x6b\xb2\x21\x07\xe4\x28\xc9\x5e\x8f\x2c\xf0\xcb\x81\x63\
\x88\x32\x5f\x47\x9e\x00\xb9\xed\xca\xac\x63\xb5\xc0\xb7\xd1\xc4\
\xc0\x9b\xc0\xdf\xd8\xf1\x4e\xa0\x93\x38\x3e\x9c\x28\xfa\x2f\xe0\
\x74\x20\x26\xe2\x21\xe0\x2b\xc4\x71\x35\x44\xdf\x01\x4e\xb5\xbc\
\x1e\x04\xbe\x8e\xb6\x45\x89\x21\xba\x05\xf8\x12\xf0\x8f\x10\xdf\
\x6f\xef\xfc\x7a\xb4\xad\x4a\x6e\x8f\xb5\x38\xc7\x71\xf6\x36\x11\
\x9a\xec\x1a\x0d\x3c\x4d\xba\x2f\x2d\x9e\xf6\x26\x24\xc3\xee\xb2\
\x63\x8b\x51\xbf\x56\x86\xbc\xa2\x6e\x46\xb2\xa9\x09\xb8\x1d\x6d\
\xa1\xf4\x69\x24\x9b\x46\xa0\xbe\xeb\x27\xc8\x9b\xe8\xfd\x68\x62\
\x6e\x19\x92\x35\x17\xa2\x3d\x85\x2f\xb5\xbc\xea\x81\xb3\xd1\x04\
\x64\x99\x5d\xe7\x36\xe0\x35\x4b\x7b\x31\x92\xa1\xcb\x91\x4c\x9d\
\x6a\xe7\xbf\x03\x29\xc9\x0d\x68\xa2\xef\x03\x56\xa6\x06\x2b\xd3\
\x1c\xe0\xaf\x50\x9f\x3c\x04\x6d\xff\xf4\x23\x60\xc3\xfe\x7e\x19\
\xce\xde\xc5\x2d\xc2\x8e\xe3\x38\xbd\x27\x46\x4a\xd2\xe7\x20\xfe\
\x2e\x12\xa4\x0b\x20\x5e\x8a\xfa\xd7\x3c\x72\x1d\x7d\x02\x59\x2b\
\x8f\x04\x3e\x8f\x06\x04\x1f\x44\x42\xf8\xb3\x40\x25\x12\xf2\x1b\
\x80\x4f\x21\x45\xe7\x0a\xa4\x54\x8e\x80\xe8\x54\xe0\x14\x34\x40\
\x98\x46\xa2\xe0\x64\xd1\xc0\xe0\x9b\xc4\x7c\x13\x09\xf8\x0b\xe9\
\xba\x0e\x34\x06\x4a\x88\xf8\x02\xb2\xe6\xfe\x0b\xc4\x77\x59\x1e\
\x17\x12\x31\x1e\xcd\xe8\x3f\x8e\xf6\x68\x4c\xf3\x2b\xa4\xd4\x6e\
\x46\x03\x8a\x72\x2b\xe7\x12\xa4\x7c\x05\xcb\xe1\x17\xd1\x3e\xc6\
\x17\xdb\xb5\x6b\x2d\x6d\x16\x59\x48\x5f\x83\x6d\x8a\xfd\xc9\x10\
\x9d\x87\x14\xfc\xaf\x23\x17\xee\x0f\x10\x71\x76\xea\xba\xb5\x56\
\xa6\xb9\xc4\x74\x40\x7c\x8f\xdd\xf7\x17\x20\x7a\x14\xf8\x04\xd0\
\x41\x8e\xbc\xdd\xd3\x78\x34\x98\xf9\x03\x52\x4a\x8f\xe7\x33\x4f\
\xa4\xef\xa3\x04\x29\xa5\x5f\x45\x96\xfb\xf3\x89\xa2\x3a\x34\x90\
\x1a\x04\xfc\x14\x0d\x9a\x2e\x44\x56\xd4\x8f\x59\x19\x3e\x61\xe7\
\x95\x75\x79\x2a\x5a\xff\x7b\x1a\x9a\xf0\xf8\x35\xf0\x67\xe0\x2c\
\x88\x8e\x46\x8a\xdf\x7a\xe0\x12\xdd\x2b\x93\x81\x7b\x21\xd3\x9c\
\xca\x21\xb2\xe7\xd8\x60\xef\x7b\x23\x44\x97\x93\xc9\x8c\x30\x25\
\x78\x05\xf0\x5e\x7b\x6e\xff\x87\x28\x3a\x19\x4d\x76\xbc\x6d\x65\
\x9b\x8f\xac\x1e\x59\xab\x2b\xdf\x05\xfe\xdd\xee\x73\x2a\x3b\x9e\
\xe4\xce\xa3\x89\x8f\x2f\x22\x17\xfb\x1b\x53\xce\x8b\x11\x51\x14\
\xdc\xa7\x3f\x67\x75\xf7\xdd\x7a\x57\xd1\x7b\x2d\xfd\x67\xed\x9d\
\x95\xdb\x33\xca\x01\xe7\x02\xff\x07\xb8\x0d\xe2\xbb\x89\xa2\x26\
\xb4\x2f\xe8\xa9\xc4\xf4\xc3\x71\x9c\x03\x89\x41\xa8\x8f\xb8\x13\
\x4d\x66\xed\x88\x52\xe4\xa9\x32\xa7\xe0\xf8\xed\xa8\xaf\x7d\x0f\
\xf2\x22\xf9\x31\x9a\x78\xfb\x12\x9a\x14\x9d\x8a\xe4\xe0\x8f\x91\
\x37\xcb\xb9\x48\x26\x54\xd8\xb1\x4a\xe4\x19\xf3\x32\x9a\xac\x7d\
\x16\x29\xe7\xc3\x91\x1c\x39\x1b\xf8\x13\xda\x42\xed\xf3\x76\xec\
\x5c\x34\x41\xf7\x3d\x34\x61\x77\x32\x72\xcf\x9e\x89\x96\x89\x1c\
\x8d\xbc\x7f\x6e\x46\xfd\xf2\x0f\xd0\x64\xed\x97\x51\x5f\x7e\x2e\
\xea\x53\x7f\x8a\xbc\xb1\xae\xd8\xdf\x2f\xc2\xd9\xfb\xb8\x45\xd8\
\x71\x1c\x67\xf7\xc8\x20\x21\x1a\x21\x21\xfc\x47\xf2\xd1\x32\x32\
\x94\x00\x8b\x88\x79\x84\x88\xe3\x90\xd5\xb4\x0e\xb9\x8e\xe6\xd1\
\xcc\x77\x29\x52\x88\x06\xd8\xb1\x17\x80\x87\x81\xa5\x48\xd1\x78\
\x13\x09\xea\x2b\x2c\xed\x4c\x22\xe6\x10\x33\xc6\xae\x1d\xa3\xf5\
\x58\x37\x11\x51\x8b\x14\x13\xd8\x7e\xf1\x6b\x15\x72\x53\x9b\x0f\
\x6c\x84\x78\x15\x44\xd3\x91\x45\xb3\x1c\xd8\x4c\xcc\xd3\x44\x4c\
\x4a\x9d\xdf\x8c\x94\xbd\x2b\xd0\xa0\xe0\x2d\x3b\x9e\x07\x9e\xb7\
\xf4\x9b\xd1\x40\x24\x28\x7f\xe9\x58\xd9\x81\x0e\xe0\x6e\x34\x50\
\xda\x6a\xf7\x21\x77\x68\xcd\xea\x77\x02\x8d\x68\x70\x14\x2e\x5f\
\x86\x66\xf5\x1b\x75\x27\xd1\x06\x88\x3f\x05\xd1\x64\xe4\x8a\x7b\
\x35\x70\x1c\x59\xde\x89\x2c\x05\xd5\x24\x6e\xe1\x55\xc0\x95\xc4\
\xf1\x73\x49\x39\xe2\x56\x88\x86\x23\xf7\xbd\xc3\x49\x26\x12\x22\
\x60\x2d\x31\x0f\x12\xd1\x6a\xc7\x2b\x91\xcb\xf2\xcb\xc8\x72\xbe\
\x1e\x29\x9f\x69\x4a\xec\xb9\x64\xec\xb9\x0e\x43\x56\x84\x77\x90\
\xcf\x7d\x8f\x4c\xf6\x49\xa4\x54\x57\x00\xf5\x10\x3f\xd1\x4d\xf4\
\xe4\xe7\xc8\x44\x8f\x92\x8f\x97\x59\x59\x8e\x40\x83\xbf\x1f\xa0\
\x81\xdf\x20\xbb\xce\x51\x56\xc7\xfe\x8c\xac\xfd\x47\xd8\x73\x88\
\x21\x6e\x34\x25\xf5\xdd\x68\xd2\x61\x47\x6b\xf2\x22\x64\xfd\xbe\
\x0f\xb9\x18\x7e\x01\x98\x40\xb4\x6d\x2d\x5f\x15\x1a\x3c\xbe\x49\
\x1c\xdf\x47\x14\x55\x23\x45\x7d\xb2\x3d\x97\xa5\xc0\xa3\xe4\xf3\
\x8d\x64\xa3\x0c\x71\x54\x67\xf9\x4e\xb6\xf7\xbc\x96\xe6\x96\x76\
\xaa\xaa\xb0\xfa\x53\x8d\x8f\x33\x1c\xe7\x40\xa3\x0d\x4d\xba\x0d\
\x03\xd6\xee\x24\x6d\x6c\xe9\xcb\x0b\x8e\x97\xa1\xb6\x3f\x05\x59\
\x8a\x67\x03\x8b\x80\xeb\xd0\xc4\xe5\x2a\x24\x2f\x17\xdb\xf1\xe1\
\xc8\xaa\xfc\x69\x34\xe9\x37\x03\xf5\x37\x83\x90\xdc\xd8\x8c\xfa\
\xe7\xf0\x79\xd4\xd2\x2f\x00\xae\x42\x7d\xdf\xbd\xa8\x3f\x9e\x82\
\xe4\xc9\x00\xd4\x7f\xa7\xcf\x2f\x45\x93\xca\x77\xa1\xc9\xba\xe5\
\x24\x7d\xec\x3a\xe4\x59\x34\xcf\x7e\x3b\x0c\xe7\xa0\xc7\x05\x94\
\xe3\x38\x4e\xef\x89\x90\x45\xee\xab\xc8\x85\x2c\x10\x2c\x88\x79\
\x62\x22\x5b\xc7\x0b\x52\x16\xb6\x22\x25\xe4\x7f\x91\x62\xbc\x81\
\x64\xdd\x53\x9e\x24\xb2\x65\x44\xc4\x56\x62\x1e\x44\x56\xb8\x0c\
\xf0\x35\xf2\xb4\x99\x9a\x1b\xdb\xf9\xff\x84\x2c\xb4\xff\x02\xfc\
\xce\xce\x2d\x54\x86\xda\x80\x9f\xa1\x75\xa0\x1f\x22\x93\xfd\x2a\
\xf9\xf8\x7e\xa4\x70\x8d\x07\xee\x23\x62\x2d\x52\x68\x62\xa4\xc0\
\x7d\x05\x29\xed\x1f\x41\x2e\xd2\x99\x82\x7c\x83\xd2\x9b\x63\xc7\
\xde\x45\xb1\xdd\x77\x48\x93\x47\x83\xab\x36\x34\xe8\x58\x84\xac\
\xaa\xaf\x15\x9c\x93\x8e\x10\xf6\x65\x88\x4e\x06\xfe\x86\x38\xff\
\x28\x51\xa6\x05\x59\xdf\x27\x20\x65\xba\x11\xad\xd3\x05\x59\x59\
\x2f\x21\x9b\xfd\x16\xdb\xd6\xe5\x46\x37\x28\x7d\xfc\x01\x88\x4e\
\x47\x6b\x78\x49\x95\x87\x6d\xd7\x8a\xc9\x99\x82\x7f\x38\xc4\xc3\
\x4c\xf9\xae\xdc\x96\xfa\xd6\xff\x07\x44\x87\xa1\xf5\xdf\x2d\xc8\
\xb5\x3a\xb6\xeb\x5e\x49\x26\xf3\x53\xe0\x7e\xa4\x98\x1e\x0e\xdc\
\x41\x1c\x2d\xe9\xe6\xb9\xe4\xc8\xc7\xe1\x1e\x23\xab\x07\x4d\x68\
\xcd\x70\x7f\x9b\x40\x69\x43\x83\xb9\x26\xe0\x68\xe2\x78\x00\x51\
\x34\xc9\xca\x5b\x07\xd1\xbf\xa0\xb8\xd9\xff\x60\xef\x7f\x67\xef\
\x62\x20\x31\x47\x13\xb1\x11\x29\xef\x6b\x53\xf5\xae\x0d\x29\xca\
\x67\x43\x74\x38\x72\xe1\x1e\x8c\xdc\xe3\xfb\x03\x43\x89\x19\x4d\
\x26\x53\x49\xcc\x69\xa8\xce\x47\xc0\x74\xe4\xca\xf8\x71\xaa\xaa\
\xee\xb3\xef\xa1\x6e\xec\x6e\xb0\x1c\xc7\x71\xf6\x2d\x0d\x28\x18\
\x63\x2d\x52\x58\x77\x44\x07\xb2\xfc\x9e\x8e\x2c\xb4\x9d\xa8\x4f\
\xf8\xb4\x9d\xdb\x0c\xdb\xbc\x42\x2a\x90\x22\xda\x66\x9f\xf4\x92\
\x89\x2c\x30\x0b\xf5\x63\x63\x90\xeb\x72\x0d\x52\x48\x0b\xfb\x90\
\x88\x10\xa0\x32\xf1\x3c\x1a\x69\xe7\x3c\x81\x26\x67\x4f\x21\x89\
\x9c\x9f\x3e\x3f\x6f\x65\xae\x49\x9d\x5f\x66\xe5\xe9\xb0\x4f\xb8\
\x86\x73\x08\xe0\x8a\xb0\xe3\x38\x4e\xef\x49\xb6\x0a\x4a\x5b\xfc\
\x3e\x33\x1d\xc2\x56\x35\x12\xa7\x19\xa0\x84\x98\xad\x44\xf1\x6d\
\x10\x7d\x09\xb9\x97\x0e\x40\x0a\xf1\x6f\xe8\x1a\xf8\x43\x5b\xd2\
\xc4\x51\x0c\xf1\x23\xc8\x0d\xb9\x1d\x78\xc2\x22\x08\x67\xec\xba\
\x39\xa4\x3c\x8d\x44\x8a\xd7\x70\xa4\xbc\x04\xb7\xd9\x10\xa3\x39\
\x87\x66\xcb\xd7\x00\x9f\x20\x9f\xbf\x1d\xa2\xe7\xec\xef\x49\x48\
\x71\x8b\xb7\x95\x53\xdf\xd7\x21\xeb\xe0\x8d\xc8\x5d\x78\x1d\x52\
\x08\xd3\xe5\x2c\x49\x5d\x27\x1c\x0f\xcf\xa4\xd8\xd6\x4d\x61\xab\
\xa9\xe9\x68\x26\xff\xef\x90\x32\xb9\x15\xe2\xbf\x21\xb1\x3e\x34\
\xdb\xf7\xc1\xf6\xf7\x74\xe4\x62\x77\x2f\x51\x66\x03\x52\xde\xef\
\x47\x03\xb5\xe3\xd1\x64\xc0\x2f\x2d\xed\xfb\x80\xff\x46\xeb\xc2\
\xee\xb6\x63\x9b\x74\x4f\xd1\x45\xc8\x65\xae\xc6\x9e\x55\xba\x7c\
\xe1\x7b\x07\x72\xb1\xfe\x3e\x44\x0f\x90\x04\x85\x4a\x0f\x8c\xce\
\x42\xae\x78\x1f\x06\x1e\xb2\x63\x9f\x03\x3e\x0f\xd1\x89\x10\x3f\
\x03\xd1\x72\xe4\x8a\xf7\x17\x22\x3a\x8b\xd4\x9d\xf4\x73\xd4\xf7\
\x38\x5e\x42\x14\xdd\x06\xdc\x42\xb4\xed\x1a\xbf\x47\x6e\x7d\x77\
\x02\x9f\x22\x8a\x8e\xb5\xf7\x8d\xbd\xd7\x8d\x76\x2f\xef\x47\x03\
\xc8\x25\x24\xdb\x57\x15\x0b\x24\x53\x43\xc4\xb7\xd0\xe0\xaf\xd3\
\x9e\x51\xb0\xde\xe4\x20\xfe\x3d\x44\x17\x12\x71\xa7\x1d\x5f\x81\
\x06\xb8\x03\x81\x6b\x89\xf8\xa3\xd5\x83\x46\xe4\xb1\x50\x82\xac\
\x3d\xdf\x43\x51\xb1\x3f\x8c\xdc\xb4\x87\x20\xa5\xba\x05\xc7\x71\
\x0e\x34\xb6\xda\xa7\x27\xdc\x89\x22\xeb\xff\x23\xf0\x06\xea\x9f\
\x4f\x45\xcb\x25\xb6\xa2\x65\x40\x20\x39\xb2\x1c\x79\x26\xa5\x03\
\x55\x85\x7e\xea\x0a\xd4\x67\x3e\x8d\x2c\xb8\x9b\xed\xfc\x91\xc8\
\x8b\x28\xad\xd8\x5e\x86\xac\xd6\xe3\xed\xff\xe5\xc8\xa3\xa5\x1e\
\xf5\x83\xe3\xec\x1a\xf5\xc8\xcb\xe6\x58\x3b\xb7\x13\xc9\x8e\xf7\
\xa1\x7e\x77\x32\xea\xa7\x16\x74\x53\x26\xe7\x20\xc7\x15\x61\xc7\
\x71\x9c\xde\x33\x0b\xb9\xdb\x2e\x2e\x38\x9e\x43\x56\xce\x2a\xa4\
\xc0\x3e\x8c\x66\xc7\x37\x10\xc7\x3f\x21\x62\x19\x44\xc7\x00\xab\
\x21\x7e\x08\xa2\x7a\x14\x15\x79\xb6\x9d\xff\x63\x9d\x17\x47\x68\
\x30\xb0\x11\x98\x41\x1c\xbf\x6d\xbf\xbf\x89\xac\xd0\x6f\x20\x65\
\xf2\x1d\x96\xee\x93\x68\x90\xd0\x88\x94\x91\x37\xed\xf8\x3f\x03\
\x0b\xad\xbc\x4d\x10\x95\x42\xdc\x04\xd1\x4a\x34\x43\xfe\x1a\xdf\
\xba\x00\x6e\x9d\x3e\x1f\x0d\x5e\xde\x04\x5e\x45\xb3\xf1\x79\xa4\
\xe4\x0d\xb5\x7c\xff\xcd\x7e\x6f\x44\x96\xe2\x65\xc8\x3d\xfb\x7b\
\xa9\xb2\xfe\x2b\x72\x2d\x5e\x6f\xf9\x2d\x44\xc1\x47\xfe\x15\x78\
\x85\x1c\x6f\x93\xe5\xc3\x68\x4d\x71\x19\xf0\x02\x44\xc9\x33\xcc\
\xe7\x1b\xc8\x64\x9e\x47\xeb\x84\xab\x91\x8b\xf2\x8d\xc8\xbd\xbc\
\x1a\xf8\x89\x3d\xb7\xd1\xc0\xbf\x10\x73\x17\x11\x8d\x00\xc4\xdc\
\x43\x44\x05\x5d\xa3\x34\xdf\x6d\xef\xe4\x30\x14\x28\x6a\xa4\x95\
\xe7\x7e\x2b\xdb\x56\xbb\xdf\x7f\x26\x62\x09\x11\x2f\x13\xd3\x84\
\x26\x09\x16\x21\x17\xc1\xb4\xc5\x7a\x35\xf0\x65\x88\xa7\x41\xd4\
\x68\xc7\x7e\xa3\x67\x4b\x23\xe4\xd7\x42\xf6\x9f\x80\xc3\x88\xe3\
\x27\x92\x6d\xa2\xb6\xd1\x08\xfc\xa7\x5d\x3b\x46\x5b\x33\x41\x14\
\xb5\x42\xfc\x6f\x10\xbd\x80\x06\x8d\x8b\x91\xfb\x60\x13\xc4\xff\
\x03\xd1\x7c\xa4\x60\xbe\x6d\xf7\x32\x17\xe2\x2f\x43\x74\x99\xe5\
\xf9\xb7\x48\xae\x37\xdb\xbb\x59\x50\x70\xdd\xfb\xac\xce\xd4\x23\
\x77\xf7\xe7\x88\xa2\x57\x88\xe3\x91\xf6\x9e\x5e\x33\xd7\xfb\x1b\
\x91\xdb\x7c\x87\x3d\xfb\x05\xe4\xda\x23\xb2\xa5\x37\x43\x74\x21\
\x1a\x4c\x3e\x0e\xf1\x22\x0b\xa0\xb5\x8a\x8e\x8e\x79\x94\x96\x7e\
\xc1\xde\xcf\x40\x34\xa0\xbd\xdf\xca\xe2\x38\xce\xc1\x8b\xf5\x87\
\x5c\x80\xbc\x60\x56\xa1\x65\x17\xcb\x51\xff\xb9\x15\x45\xe5\x9f\
\x83\x5c\x9a\xeb\xd1\xe4\xda\x66\x3b\xff\x01\xd4\x1f\x2f\x41\x5e\
\x4b\x63\xd0\xc4\x6d\x08\xf4\x70\x07\xea\xf7\x1e\xb0\xbc\x4f\x43\
\x93\x83\x25\x48\x46\x3d\x68\xd7\xf8\x0f\xe4\x1a\xbd\x1c\x4d\x8e\
\x6e\x45\xb2\xea\x0e\x34\xa9\xfa\x14\x92\x55\x73\xad\x0c\x27\x21\
\x99\xf8\xa8\xa5\xbd\x07\x4d\x0e\x83\x62\x52\x38\x87\x00\xae\x08\
\x3b\x8e\xe3\xf4\x9e\x85\x28\x50\x51\x21\x39\x12\x6b\x24\x68\xbd\
\xe7\xb3\xc9\x9f\xd1\xdd\x05\xbf\x83\xa2\x66\x06\x6e\xb7\xff\x4f\
\x05\xbe\x89\xd6\x49\xdd\x46\x3e\xdb\x6e\xc7\x17\x90\x28\x39\x2b\
\x91\x30\x67\x07\xf9\xcd\x4d\x7d\xff\x1e\x31\xa3\x88\xa2\xdf\xa1\
\xa0\x48\xff\x06\x9d\x9b\xec\xb7\xa5\x28\x5a\x72\xe0\x07\x3b\xc9\
\xf7\x7f\x53\xdf\x7f\x9f\xfa\xfe\xa3\xd4\xf7\xef\x6c\x77\xbc\x06\
\x68\x61\x36\x89\xe2\xdf\x95\x28\xca\x43\x7c\x87\x29\x5d\x47\x21\
\xe5\xed\x65\xfb\x24\xc4\x6c\x22\x42\x7b\x23\x07\x8b\xfc\x67\xa7\
\xaf\x41\xca\x6e\x9a\x46\x14\x59\xb4\x90\x79\x68\x70\x84\x3d\xc3\
\x59\xa9\xad\x95\xef\xb7\x4f\x31\x9e\x26\xb8\xc2\x87\xeb\xde\x3a\
\x7d\x09\xf0\x3f\x76\x03\x20\x2b\x89\xbe\x6f\xbf\x3e\xb8\x89\xa0\
\xfc\x8a\x3f\x27\xe7\xc5\x8d\x68\x40\x76\xcf\xb6\x5f\x35\x49\xb1\
\x05\x45\xee\x2e\x64\xad\xdd\x47\x21\x3f\x2f\x72\xec\xf1\xed\x8e\
\x68\xdf\xe1\x15\x74\xad\xc7\xaf\xdb\xc7\x8a\x95\x81\xa8\x24\x46\
\x93\x01\xaf\x15\xe4\xf0\x2b\x00\x32\x19\x52\x65\x3e\x07\x4d\x70\
\xdc\x8b\xe3\x38\x87\x02\x1b\x90\x72\x5b\x48\x27\xdb\xc9\x3f\x20\
\xf1\xa4\x81\xa4\x0f\x06\xf8\x63\x91\x3c\x0a\xfb\xee\x33\x51\x9f\
\xf5\xcb\x82\xe3\x4f\x15\xe4\xd5\xdd\xf9\x00\xcf\xd8\x27\x4d\x7a\
\x7f\xe1\x17\xf7\xd1\x73\x73\xf6\x33\xae\x08\x3b\x8e\xe3\xf4\x96\
\xe2\x01\x90\xe0\x3b\x17\xec\x4a\x2e\xdd\x73\xeb\xf4\x75\x28\xa8\
\xc7\x22\xf2\xf9\x47\xc9\xe6\x76\x7c\xdd\x9e\xf2\xd9\x69\x5b\x20\
\x7a\x04\xb8\x5b\x11\x99\x33\xf1\x1e\xc9\x77\x4f\xf1\xed\x0b\xe1\
\xd6\x69\xaf\x22\xeb\x73\xc7\x2e\x95\xeb\xdb\x45\xd2\xee\xc9\xfb\
\xfa\xd6\x3f\x77\x73\x7c\x17\xae\xd1\x9b\xf2\xec\x89\x7b\xd8\x57\
\xef\xf7\xd6\xe9\xf5\x28\xda\xf8\xec\x3e\x53\xa7\x1c\xc7\x39\x58\
\x78\x8d\x74\xdc\x06\xc7\xd9\x0d\x5c\x11\x76\x1c\xc7\xe9\xbb\x2c\
\x63\x9b\x95\x11\xf8\xd6\x45\x7b\x2a\xdf\x46\xd2\x56\xdb\x6f\x4d\
\xdd\xdf\xf7\x59\x8c\x0e\xb6\x59\x4a\x9d\x03\x8c\x99\xf6\x71\x1c\
\xc7\xd9\xd3\xcc\xde\xfd\x2c\x1c\x47\xb8\x22\xec\x38\x8e\xd3\x3b\
\xd2\x81\xa8\x0a\x8f\x87\x08\xd0\xbb\xc7\xee\x5b\xd3\x0a\x23\x3d\
\xeb\xfb\xb7\x2f\xdc\x37\x4f\x68\xb7\xee\xfd\x00\x28\xa3\x53\x1c\
\xb7\x02\x3b\xce\xa1\x44\x3a\xe8\x60\x0c\x45\x83\x03\xee\xe9\xeb\
\x81\x47\xa4\x77\xf6\x00\xae\x08\x3b\x8e\xe3\xf4\x8e\x4a\xe0\x8b\
\xc8\x75\xf9\x0d\x3b\x16\xa1\x3d\x67\x57\xa2\xc0\x1e\xfb\x9b\xf7\
\xa2\xf5\xa3\x47\xd8\xdf\x6e\x61\x75\x1c\xc7\x71\xf6\x24\xd7\xa0\
\x28\xcc\xcd\x48\x39\x5d\x89\xe2\x19\xcc\xdd\x9d\x4c\x77\xc0\x85\
\x68\x3b\xb7\xbb\xf6\xf7\x8d\x3b\x07\x3e\x1e\x1e\xdc\x71\x1c\xa7\
\x77\xb4\xa2\x80\x40\x57\x90\xcc\x50\x0f\x46\x51\x2f\x57\xdb\xdf\
\x61\x1b\x9b\x40\xb0\x16\xa7\x27\x21\x4b\x7b\x90\x26\x9d\x36\x5b\
\x90\x96\x82\xb4\xe9\xef\xcb\x50\x64\xce\xa3\x81\x23\xf7\xf7\x03\
\x73\x1c\xc7\x71\x0e\x3a\xc6\xa1\xe0\x55\xff\x01\x7c\x0b\x45\x64\
\xfe\x1a\x8a\xb6\x9f\x96\x67\xe9\x6d\xf4\x82\x9c\x0a\x9e\x55\x81\
\xf4\xf7\x6c\x2a\x4d\x69\xea\xf8\x7a\xa4\x6c\x47\xa9\xf3\xbb\x93\
\x97\xc5\x8e\x45\x3d\x38\xe6\x1c\x22\xb8\x45\xd8\x71\x1c\xa7\x77\
\xe4\xd1\x76\x34\x5f\x40\xb3\xd3\x5b\x50\x34\xcb\xf5\x28\x9a\xf4\
\x7b\x81\xd3\x91\xc2\x7c\x17\xf0\x16\xf0\x59\x64\x49\xde\x88\xb6\
\xa5\xb9\x06\x6d\x83\x13\xa3\xa8\xcb\x0b\x80\xbf\x07\x1a\xd0\xde\
\x87\x2f\xa3\x88\x97\x03\xd0\x3e\xb1\xa3\xd0\xe0\xe0\xcf\x68\xbb\
\x9f\x8f\x02\xe5\x68\xcb\x8a\xd9\x68\xcf\xd6\x53\x51\x04\xe4\x9f\
\x03\x23\x50\x84\xe2\x1c\xee\x46\xe6\x38\x8e\xe3\xec\x9c\x08\x6d\
\x5d\x37\x1a\x45\x61\x6e\xd8\x49\xfa\x3c\xda\xd6\x68\x8e\xfd\x3d\
\x07\xf8\x05\x70\x36\x92\x49\xe7\x59\x9a\x3b\xd1\x36\x7c\xef\x40\
\xf2\xe8\x49\x24\xb7\x2e\x03\x7e\x88\xb6\x33\xfa\x30\xda\xca\xad\
\x0a\xb8\x16\x6d\xa1\xf4\x6e\xb4\x73\xc2\x32\xe0\xa7\x48\x1e\xf6\
\x43\x3b\x0a\x7c\x14\x4d\xf6\x1e\x8e\xa2\xe2\xdf\x65\xe5\xbe\x25\
\x75\xce\xaf\xed\x7a\xb7\x20\xef\xa8\xad\x48\x3e\x36\x00\x1f\x41\
\x72\xb5\x1e\xed\x82\xb0\x64\x7f\x3f\x7c\x67\xdf\xe2\x16\x61\xc7\
\x71\x9c\xde\x33\x13\x29\x9a\x27\xa1\xfe\xf4\x02\xb4\x67\xf0\xb9\
\xc8\x32\xfc\xbf\x48\xd8\xdf\x8a\x04\xf0\x54\xb4\xbf\xed\x1d\xc0\
\x89\x48\x79\xfe\x16\x12\xd6\xb7\xa0\x3d\x58\x2f\xb1\xbf\x7f\x82\
\x06\x08\xe7\xa1\xbd\x11\xf3\x68\x5b\xa0\xd7\x81\x8f\xa3\x81\xc0\
\xe5\x68\xdb\x8a\x5f\xdb\xf9\x65\xc0\xcf\x80\x2b\x81\xf1\xf6\x19\
\x86\x2b\xc1\x8e\xe3\x38\x4e\xcf\x18\x04\x7c\x1f\x29\xae\xd7\xf7\
\xf0\x9c\xb4\x3e\xd1\x8e\x64\xd8\x38\xa4\xac\x1e\x87\xb6\x59\xab\
\x05\x3e\x81\xb6\x07\xfc\x03\xf0\x41\x60\x02\xda\x33\x7d\x14\x52\
\x9c\xaf\x44\x1e\x4c\x53\x2c\xfd\x95\x48\xae\xfd\x10\x29\xc7\x47\
\x5a\xda\x23\xd1\x04\xf4\x54\xb4\xa7\xf0\x1d\xc0\x87\xec\x9a\x9f\
\x43\x4a\xee\x0f\x2d\xcd\x87\x2d\xdd\x09\xc0\x8f\x91\x0c\x3e\x1e\
\x38\x1f\x98\x8c\x64\xed\x7a\x24\x93\x9d\x43\x0c\xb7\x08\x3b\x8e\
\xe3\xf4\x9e\x26\xa4\xe8\x5e\x80\x04\xff\x30\xb4\x5f\xe2\x27\x81\
\xe1\xc0\x4d\xc8\x82\x3b\xd4\xfe\xae\x07\xa6\x21\xb7\xae\xe9\x68\
\xbf\xd5\xab\x90\x50\xae\x42\x02\xff\x6d\xb4\xbe\x78\x0b\xf0\x02\
\x70\x06\x12\xe8\x35\xc8\x0d\xfb\x58\x34\x23\x5e\x89\x04\xfa\x63\
\x68\x46\x7c\x09\xda\x17\x71\x96\x5d\xa7\x16\xb7\x04\x3b\x8e\xe3\
\x38\xbb\x46\x1b\xb0\x08\x18\x02\xac\xe9\x65\x1e\xa5\x96\x4f\x84\
\x3c\x9b\xe6\x23\xc5\x73\x36\xf0\xbc\xa5\x79\x0d\x29\xb4\x73\x81\
\xb3\x90\x07\xd3\x34\xe0\x34\x24\x33\xa7\x21\x3d\xe5\xd3\xf6\x99\
\x01\x2c\x07\x26\xa2\x89\xe1\x08\x79\x5a\x3d\x83\x26\x86\x1b\x90\
\x65\x78\x0a\x50\x61\xe5\x1f\x8e\x14\xf3\x69\x68\xa2\xf9\xef\x81\
\x37\xed\x9a\x15\x76\x5e\x38\xf6\xd6\xfe\x7e\xf0\xce\xbe\xc7\x15\
\x61\xc7\x71\x9c\xdd\x63\x3a\xf0\xcf\x48\xe9\x9d\x85\x94\xd3\x4e\
\x64\x2d\xfe\x25\xea\x67\x9f\x00\x16\x5b\xfa\x4e\xa4\x1c\x7f\x0a\
\x29\xb3\x0f\xa3\xd9\xf4\x33\xed\xf7\x12\x92\xb5\x4d\x35\xc8\xb5\
\xec\x43\x68\xe6\xfc\x1e\x14\x90\x64\x24\x1a\x04\xb4\xa2\x01\x41\
\xd6\xfe\x0f\xdf\xc1\x15\x60\xc7\x71\x1c\x67\xd7\x69\x40\xcb\x78\
\xfa\x21\x97\xe7\x9e\x90\xde\x3d\x61\x08\xb2\xea\xde\x0d\x9c\x82\
\x14\x51\x90\xbc\xaa\x49\xa5\xeb\x87\xe4\xe5\xeb\xc8\x52\x0c\x72\
\x6d\x7e\x8f\x95\xe1\x4d\xa4\xac\x7e\x19\x18\x8b\xbc\x9e\xc2\x04\
\x70\xa0\x0d\xc9\xba\x60\x91\x8e\x91\xeb\xf3\x03\xc8\x45\x7b\x20\
\x92\x89\xcb\x81\xaf\xa2\xa5\x48\xd7\x01\x9f\x07\xfe\x15\xc9\xee\
\xc3\x80\x1b\x90\xe7\xd6\xe7\xd0\xd6\x7d\xce\x21\x82\xbb\x46\x3b\
\x8e\xe3\xec\x1e\x4b\xd0\xac\xf9\xbb\x81\x47\x91\x20\x7e\x04\xb9\
\x6f\x9d\x89\x5c\x9d\xaf\x47\xc2\x38\x43\x12\x94\xa3\x1a\x29\xb9\
\x15\xc0\xc9\x48\xc0\xc7\x68\x7d\xd3\x5f\xa3\xb5\x4b\x93\x91\xa2\
\x5c\x83\x04\x7e\x16\xad\x01\xae\xb2\xbc\x0a\x83\x8c\xa4\x83\x91\
\x44\xa9\x63\x85\x69\x1d\xc7\x71\x1c\xa7\x3b\xb6\xa2\x00\x58\x3d\
\xd9\x06\x30\x42\x9e\x4b\x1f\x42\x0a\xed\x37\xd0\x6e\x05\x2f\xa3\
\x89\xdd\x30\x39\xfb\x0c\xb2\xf4\xfe\xad\xa5\x1b\x87\x3c\xaa\xc2\
\xce\x06\xcd\xc8\x5a\x3c\x0e\x2d\xf9\xd9\x80\x3c\xa6\x6e\x41\xf2\
\x6b\x33\xb0\x89\x24\x48\x56\x44\xd7\xe0\x91\x59\x4b\xf3\x04\x5a\
\x56\x74\x3c\xf0\x01\xe4\x7a\x7d\x0a\xf0\x19\x24\x4b\xb7\x02\x6b\
\x91\xdc\xfd\x0c\xf2\x9e\xda\x6c\xd7\xdb\xfd\x6d\x0f\x9d\x03\x0a\
\xb7\x08\x3b\x8e\xe3\xec\x1e\x79\xe0\x37\x68\xf6\x7a\xa6\x1d\x7b\
\x09\xf8\x77\x34\x38\x68\x44\x03\x83\x95\xc8\x42\xbc\x16\xcd\x9e\
\xff\x37\x0a\x1a\x32\x00\x05\x00\x19\x84\x04\xfb\x0a\xe4\x46\x36\
\xc0\xf2\x78\x0b\xad\x5f\xba\x1c\x0d\x22\x6e\xb3\xb4\x5b\xd0\x5a\
\xab\xad\x68\xc6\xfd\x37\x96\x77\x1e\xad\x19\x5e\x82\xdc\xa6\xd7\
\x22\x01\xef\x38\x8e\xe3\x38\x7b\x9a\xa7\x90\x17\xd3\x10\xe4\xf1\
\x74\x87\x1d\x6b\x43\x8a\x6e\xd0\x35\xde\x06\xfe\x09\x6d\x7f\x14\
\xa1\xa0\x58\xf3\xed\xb7\xff\x21\x51\x46\xff\x1d\xb9\x66\xc7\x48\
\xde\xbd\x03\x29\xca\x77\xa3\x80\x58\xe3\xd0\x04\xf2\x6a\xbb\x16\
\x68\x52\xf9\xb7\x48\x7e\x7e\x1f\xb8\x18\xb9\x49\x3f\x6a\xe7\x74\
\x5a\x7e\x47\xa2\xed\x0e\x1f\x45\x8a\x77\x0e\xad\x63\x9e\x61\xc7\
\xd2\x96\x6d\xe7\x10\xc0\x15\x61\xc7\x71\x9c\xdd\x67\x96\x7d\x02\
\x31\x12\xb6\x6f\x14\xa4\xbb\x3b\xf5\x7d\x19\x0a\x6c\x95\x66\x04\
\x52\x6a\xff\x82\xd6\x1f\x07\xd6\x22\x25\xba\x90\x47\x52\xdf\xff\
\x52\xe4\xfb\x4a\xfb\xff\xed\xfd\xfd\x80\x1c\xc7\x71\x9c\x83\x92\
\xd7\xec\x53\x8c\x57\x0a\xfe\x5e\x64\x9f\x42\x1e\x4e\x7d\xbf\x27\
\xf5\x7d\x0b\x9a\xf0\x4d\x33\x27\xf5\x3d\xac\x61\x6e\xa3\xab\x0c\
\xbc\xaf\xc8\x35\x1e\xec\xe1\x31\xe7\x10\xc2\x5d\xe5\x1c\xc7\x71\
\xfa\x0e\xf5\x68\x56\xdb\xd7\x28\x39\x8e\xe3\x38\x8e\xe3\xec\x45\
\x4a\xc0\x77\x91\x76\xf6\x0d\x5e\xcf\x1c\x67\xa7\x34\xd2\x75\x56\
\xdb\x71\x1c\xc7\x71\xf6\x16\x1e\x54\xd1\x39\xa4\x29\x89\x63\xa2\
\x8e\x5c\x4c\x47\x2e\xf6\xd6\xe0\xec\x55\x22\xa0\x33\x1f\x93\x57\
\x45\x4b\x47\xc6\x75\x9c\xbe\x4c\x06\x05\xe1\xf0\xfa\xea\x38\xfb\
\x9f\x12\xd4\x26\x5d\x86\x38\x4e\xef\x29\x41\xc3\xb2\x52\xbc\x1d\
\x39\x87\x1e\xa1\xfe\x47\xd1\xa0\xaa\x92\xd6\xb3\x8f\xa8\x29\xaf\
\x28\xcd\xf8\xbc\x90\xb3\xd7\xc9\xc7\x31\x2f\x2e\x6f\x6a\x5b\xbe\
\xb5\xfd\x49\x60\x23\x6e\x28\x76\xfa\x36\x31\xda\xb7\xb7\x09\xad\
\xb3\xf5\xfa\xea\x38\xfb\x8f\x98\x24\x72\xfa\x42\x5c\x86\x38\x4e\
\x6f\x88\x51\xb0\xa9\x53\xd0\xda\xde\x16\xbc\x1d\x39\x87\x0e\x31\
\xda\x79\x63\x38\xf0\x81\x92\xc3\xfa\x95\xb6\x7f\xf8\xd4\xc1\xe5\
\x83\x2a\x4b\x5c\x0f\x76\xf6\x3a\x1d\xb9\x98\x4d\x2d\xab\xdb\x97\
\x6f\x6d\x7f\x1a\x0d\x64\x7c\x9d\xba\xd3\x97\xc9\xa1\xd9\xf2\xf5\
\x28\xfa\x65\x76\xf7\xb2\x73\x1c\x67\x37\x88\x81\x32\x14\x3d\xfd\
\x29\x14\x74\xc7\x65\x88\xe3\xec\x1a\x31\xda\x32\x68\x04\x8a\x94\
\xbc\x19\x57\x84\x9d\x43\x87\x18\xed\xca\x71\x25\xd0\x51\x52\x5d\
\x9a\xc9\x4f\x1e\x5a\xc9\xb0\x9a\xd2\xe0\xb2\xea\x38\x7b\x85\x28\
\x82\xb6\xce\x3c\x03\x2a\xb3\x39\xb4\xb5\xcb\x6c\x5c\xb1\x70\xfa\
\x36\x39\xa4\x04\xaf\x46\x91\x2a\xbd\xbe\x3a\xce\xfe\xa5\x0c\x45\
\x92\x5d\x82\xda\xa4\x2b\xc2\x8e\xb3\x6b\xc4\xc0\x40\x14\x9c\x71\
\x01\x92\x71\xae\x08\x3b\x87\x0a\x31\xda\xea\xab\x05\xc8\x97\xc4\
\x40\x2e\x86\x5c\x1c\x13\xbb\x22\xec\xec\x4d\x62\xc8\xe5\x09\xf5\
\x2c\xac\xbb\xf4\x41\x8c\xd3\x97\x89\x51\x1d\x8d\xec\x7f\xaf\xaf\
\x8e\xb3\x7f\x29\x6c\x8f\xde\x26\x1d\x67\xd7\x28\x26\xd7\x5c\x11\
\x76\x0e\x15\x42\xfd\x07\x5c\x80\x38\x8e\xe3\x38\x8e\xe3\x38\x8e\
\xe3\x38\x87\x18\xae\x08\x3b\x7d\x95\x9d\xcd\x50\xee\xed\x19\xcc\
\x03\xa1\x6d\xec\x0b\x1f\x8e\x70\x8d\x30\x73\xdc\xdb\xf2\x1d\xec\
\x33\xce\x3b\x7b\x3e\xd1\x5e\xbe\xff\x83\xfd\xf9\x3a\xce\xde\x22\
\x4f\x12\x85\x1a\xfa\x6e\xd8\xd0\xee\xca\xb5\xab\x6d\xbf\x37\x7d\
\x79\x6f\xe9\xe9\x75\xe2\xd4\xfd\xf5\xb6\x2f\xf3\x3e\x70\xff\x51\
\x4c\xbe\x1d\xac\xef\x23\xd4\xe9\xb8\xc8\x31\xe7\x00\xc4\x5f\x9e\
\xd3\x17\xc9\x02\x1f\x06\x6e\xa1\xfb\x3a\x7a\x23\x70\x38\x1a\xc4\
\xec\x49\x62\xa0\x1f\x70\x13\xd0\x9f\xbe\x3b\x28\xca\x00\x67\x02\
\x87\xed\xc5\x32\x66\x80\xf3\x81\xc1\xc0\x28\xe0\x3a\x92\xc1\xe2\
\xce\x88\x81\x91\x56\xc6\x08\x78\x27\x70\x34\x7b\xfe\x7d\xf5\x05\
\xf2\xc0\x3b\x80\xbf\x07\x6a\xd8\xfe\x7d\xe4\x81\xf3\x80\xd3\xf7\
\xd2\xfd\x67\x80\xeb\x81\xb1\x7b\x29\x7f\xc7\x39\x58\xc9\x02\x53\
\x51\xdb\xfd\x47\xe0\x63\xa8\xdf\xea\x6b\xfd\x7e\x8c\x22\x65\x8f\
\x2b\x52\xb6\x9b\x80\x31\xf4\xac\xed\xc7\x28\x52\xea\x07\x81\xca\
\xbd\x78\x9f\x21\x2a\xeb\x07\x91\x3c\x8d\x77\x92\x76\x38\x70\x36\
\x92\x15\x57\x02\x13\x7a\x78\x3f\x81\x08\x78\x2f\x30\x7a\x17\xcf\
\x73\x76\x9f\x3c\x70\x01\xf0\x49\x14\x89\x3a\xb8\x9d\x7e\x00\x38\
\x92\x83\xe7\x7d\x84\x3a\xfd\x5e\xa0\x0e\x98\x0c\x1c\x83\xda\xd1\
\xcd\x28\xf8\x52\x5f\xeb\x37\x9c\x1e\xe0\x8a\xb0\xd3\xd7\xc8\x23\
\xa5\xeb\x04\x14\xda\x7f\x24\x49\x47\x1a\xb6\xce\xc8\x00\x47\x91\
\x28\x1d\x31\xc9\x9e\x60\x69\x0b\x66\x44\xd7\x59\xfe\xc2\xb4\xe9\
\x7c\xc3\xde\x94\x31\xd0\x01\x2c\xb5\xff\x43\x1b\x29\xcc\x3f\x9c\
\x93\xa5\x78\x47\x1f\x66\xdd\xb3\xa9\x73\x8a\xe5\x91\x2d\x48\x93\
\xb7\xbf\x4b\x0a\xee\x25\x7d\x7e\x1e\x75\xbe\x57\x21\x25\x35\x4e\
\x9d\x97\x2e\x4f\xfa\x19\xa4\x67\x66\x63\x92\xfd\x03\x33\x05\xe5\
\x09\x96\x91\x70\x8d\xab\xed\x1a\xcd\xc0\xf2\x82\xf2\x40\x32\xeb\
\x5b\x58\xee\x3c\x70\x3c\x70\x86\xfd\xbe\x02\x68\x48\x9d\x57\xf8\
\x0e\x8a\xbd\xaf\x03\x81\x18\xd5\xc3\x73\x50\x9d\x3c\x8e\xae\xf5\
\x2a\xd4\x81\xe1\xc0\x30\xfb\x2d\x5d\xdf\x42\xda\x5d\xa9\x67\xa1\
\xde\x84\x67\x1d\xa3\x77\xd3\x98\xca\x27\xb4\x93\x74\xbd\xca\xd0\
\xb5\x5e\x39\xce\xc1\x48\x1e\x05\xb9\xdb\x59\x3d\xcf\xa3\xc1\xec\
\x95\xc0\x63\xc0\xaf\xed\xf8\x07\x48\xfa\xc6\xd0\xd7\x45\x05\x9f\
\xc2\xbe\xbd\xb0\xff\x82\xae\xfd\x6b\xa1\x75\x2c\xa4\x2f\x6c\x97\
\x71\x2a\x5d\x5a\x36\x64\x80\x2b\x80\x23\x52\xe7\x87\x32\x2c\x43\
\x6d\x3f\x90\xee\x43\x8a\xdd\x43\x15\x52\x34\x4b\x52\x69\xc2\x3e\
\xb2\x71\x2a\x5d\xb1\x18\x1e\xa1\x3f\x4a\xf7\x23\xe1\x1a\x25\x05\
\xdf\x4b\xed\x3a\xa5\x05\xcf\xa5\x30\xcf\xc8\xde\xc3\xd9\xf6\xdb\
\x11\x48\xd1\xc8\xa6\xee\xa3\xf0\xb9\xe7\x53\xd7\x09\xcf\x6d\x29\
\x92\x53\x69\xf9\x16\xa5\x7e\x87\xae\x72\xde\xd9\x31\x3d\x6d\x47\
\x61\x22\xe3\x06\xe0\x12\x92\xe7\x3f\x81\xae\xc6\x84\x52\xba\xb6\
\x99\x74\x3d\x08\xf5\x26\xfd\xee\x42\xde\xe9\x71\x5b\x31\x99\x96\
\x4e\x5b\x8c\x42\x0f\x88\xf0\x77\xbe\xc8\xb5\x42\x5b\x29\xac\x67\
\x21\x48\x66\x0e\xd5\xb3\x4e\xa4\xfc\x4f\xb0\xef\x4b\x80\x76\x76\
\x2e\xc7\xd3\x7d\x88\xd3\x47\xe8\xa9\x75\xc7\x71\xf6\x25\x53\x80\
\xb9\xa8\xf3\x39\x0b\x75\x3c\x11\x70\x2e\xb2\x30\x6e\x41\x1d\x6f\
\x0e\xa8\x46\x0a\xe1\x18\xb4\xd7\xeb\x23\xc0\x1a\x64\x31\x8e\x91\
\x12\xb7\x06\xf8\x33\xaa\xef\x57\xa1\x59\xe3\x90\xf6\x6d\xe0\x52\
\xd4\xa1\x01\x3c\x8e\xb6\x75\x1a\x09\xcc\x22\xb1\x82\x0e\x44\x11\
\xe6\xfe\x84\xb6\x1a\x98\x8a\x94\xf5\x0e\xe0\x19\xe0\x55\x3b\x3f\
\x6d\x51\x2e\x07\x36\x01\xd3\x80\x8b\xd1\x56\x05\x9b\x81\x07\x91\
\x62\x78\x3a\x89\xf0\x7f\x1d\x6d\xcf\x73\xaa\xdd\x67\x04\xcc\x00\
\x9e\xb0\xf2\x1d\x8e\x14\xd3\x3c\x70\x17\x8a\x78\x37\xd1\x7e\x5b\
\x09\x9c\x0c\x9c\x64\xbf\xbf\x04\xbc\x68\x65\x1f\x64\x65\xfc\xb3\
\x95\x05\xcb\xeb\x52\x34\xd8\xc8\x01\xf7\xdb\xf3\x3e\x09\x75\xee\
\xa5\xc0\x9b\xc0\x56\xa4\xdc\x5d\x0e\x3c\x8c\xb6\x2c\x39\xcd\xee\
\xe3\xcf\x76\x7f\x37\x59\xb9\x47\xa3\x89\x8b\x72\x2b\xcf\x83\xf6\
\x1e\xc7\xdb\x39\x43\xec\xfa\x75\xc0\x35\xf6\xfe\x9a\x80\x87\x50\
\xc4\xca\x1b\xad\x2c\x43\x90\x52\x77\x37\x07\xc6\xde\x86\x31\x9a\
\x15\xee\xb4\x67\x74\x9e\x3d\xff\x4e\x3b\x7e\xb9\x7d\x1f\x06\xbc\
\x80\x22\xde\x5e\x8a\x06\x7e\xed\xa8\x6e\xbc\x89\x2c\xba\x35\x68\
\xe0\xd0\x89\xea\xd9\x46\x54\x6f\x8e\xb5\x67\xf3\xbc\xbd\xd7\xd3\
\xd1\x04\x43\x19\xaa\x23\xd3\xec\x79\xae\x41\x16\xfc\x30\xc8\xad\
\x04\xee\xb3\x77\x7b\x8a\xfd\x96\x05\x66\xda\x39\x9d\xfb\xfb\xe1\
\x39\xce\x1e\x26\x46\x7d\xd1\x78\x54\xcf\x37\xd0\x7d\x1f\x12\xa3\
\xf6\x16\xa1\x3e\x68\x15\xf0\x1b\xa4\x88\x55\x02\xef\x42\x6d\x7a\
\x39\x6a\xb3\x8d\x96\xe6\x1a\xd4\xa7\x0e\x00\x9e\x43\x6d\xf2\x26\
\x24\x8b\xda\x81\xe9\x48\x6e\x0d\x45\xed\xf0\x31\x4b\x3f\x19\xb8\
\x1d\xf5\xf7\x37\xa2\xfe\xa0\x14\x79\x93\x94\xa1\xe8\xbd\x0f\x91\
\x4c\x02\x87\x2d\x6e\x1e\x42\x93\x88\x13\x2d\xdd\x26\x24\x07\xb3\
\x48\x7e\xf5\xb3\x32\xd6\x22\xcf\x9b\x11\xa8\xef\xbe\x0f\xf5\x15\
\xab\x80\x67\x51\x7f\x34\x09\x45\xda\xce\xd9\x33\x38\x05\xc9\xa0\
\x2a\x24\x57\xef\x40\x9e\x3b\x67\x20\x59\x32\xdd\x9e\x63\xc6\xae\
\x7d\x31\xea\x5f\xca\x50\xbf\xf2\x80\xdd\x4b\x3f\xbb\xc7\xb5\x48\
\xbe\x64\xd0\xfe\xb4\x65\x48\x0e\x0d\xb4\x72\xfc\x05\xb8\xd6\x9e\
\xdb\x1c\xd4\xb7\x9d\x66\xcf\x7c\x12\x89\xd7\xcc\xd9\x76\x3c\x02\
\xee\xb4\xbc\xaf\x26\x91\xe9\x33\x2d\xcf\x23\x50\xbf\x38\x1d\xc9\
\xec\x25\x56\xfe\x4b\x52\x65\xba\x1b\xf5\x8d\x57\x22\x8b\x7a\x07\
\x92\x4f\xf3\xe8\xfb\xf2\x65\x7f\x32\x11\x79\x9c\xbd\x8a\xea\xfe\
\x8e\x9e\x55\x0e\xc9\xbd\x8b\xd1\x6e\x20\x8b\xd1\x7b\xcc\xa3\xf7\
\x74\x35\x49\x7b\x98\x06\xcc\x47\xed\xeb\x6e\xd4\xf6\xae\x46\xef\
\x6e\x23\x1a\xa3\xf5\x47\x75\xe9\x6e\xd4\xa6\x2e\x47\x63\x91\x66\
\xb4\xdd\xd3\x7c\xd4\xc6\x4e\x43\x6d\x75\x3d\x1a\x93\x6c\x65\xfb\
\x49\xff\xe1\xe8\xdd\xdf\x86\xda\xd1\x55\x68\x1c\xb6\xdc\xbe\xf7\
\xb3\x6b\xdd\x6b\xdf\x2f\xb5\x73\x07\x02\x6f\x20\xd9\x3d\xca\xca\
\x3d\x03\xb5\xaf\x0d\xc0\x89\xa8\x2d\xcc\xb5\x63\xb3\x81\xcb\xac\
\xec\xb5\x56\xee\x3f\xa1\xf6\x7a\x19\xaa\xdf\xeb\xec\xb7\x3f\xd8\
\x35\xbd\xfe\xf5\x01\xdc\x22\xec\xf4\x25\x82\x75\xed\x44\x24\xb8\
\x9f\x46\x8a\x61\x0d\x52\x74\xaf\x46\x83\x82\x57\x48\xac\xc1\x97\
\x22\xf7\x9b\xdb\xd1\xa0\xe0\x66\xa4\x6c\x9d\x82\x3a\xbb\x3b\x90\
\xb0\x3d\x1e\x75\x86\x23\x80\xdf\x59\xda\x0f\xa2\x8e\xec\x02\xd4\
\xb9\xbe\x82\x06\x2b\x55\x68\x20\x55\x86\x3a\xaf\x0a\xd4\x71\xd5\
\x22\x45\x27\x28\x8c\xf7\x22\x81\xfe\x6e\xba\x5a\xae\x4b\xd1\x40\
\x62\x25\x1a\x04\x5d\x65\x65\xfa\x3d\x1a\x6c\xbc\x07\x75\xea\xd7\
\x23\x01\xfe\x20\x12\xde\xc7\x5b\x5e\x4f\x21\xe5\xf4\x22\x3b\x76\
\x38\x12\xf8\x77\xa2\x0e\xff\x66\x34\xa8\x78\xdb\x9e\xd1\x91\x68\
\x30\xf5\x17\xa4\xc8\x5f\x6b\xf7\x75\xbc\x95\xe7\x3e\x24\x00\xc2\
\x4c\xe4\xf1\x68\x60\xf0\x2b\x24\x38\xae\x40\xc2\xe2\x3d\xc0\xcb\
\xc0\x3d\x68\xc0\xd0\x80\x26\x21\x9e\xb2\xf3\x8e\x46\x82\xea\x34\
\x34\x08\x1c\x63\xd7\xce\xd9\x73\x7a\x14\x09\xa3\x53\xec\xb7\x99\
\x48\x38\xcc\xb2\xfb\xad\xb3\xb2\x0d\xb2\x67\xb1\x0a\x59\x5f\x06\
\xd8\x7b\x5e\x9b\x3a\xff\x18\x0e\x0c\x97\xaa\xe0\xa2\xfe\x16\x12\
\x94\x23\xec\x5d\xd5\x00\xef\x43\x4a\xee\x03\xa8\x4e\xc5\x48\x78\
\x9f\x81\x26\x33\x5e\x41\x6e\x56\xc3\xd0\xa0\xa3\x06\xd5\xe3\x32\
\x54\xbf\x4e\x45\xca\xeb\x3d\xf6\x0e\xde\x4d\x62\xc1\x7a\x0b\xd5\
\x9b\x71\x76\xde\x91\xa8\x7e\x1e\x8e\x5c\xa4\xef\x45\xf5\xef\x5a\
\x2b\xcf\x7b\xd0\x80\xf1\x5e\x54\x87\x4f\x3e\x40\x9e\xaf\xe3\xec\
\x0a\x65\xc0\x27\x80\xaf\xa3\xb6\xb5\xb3\x38\x13\xaf\x22\x85\xe8\
\xef\x80\xff\x6b\xe7\x04\xcf\x95\x09\xa8\xdd\xe6\x51\xff\x3e\x14\
\x0d\x94\x4f\x43\x6d\xf7\x51\xa4\x78\x8e\x41\xca\x6b\x3b\x6a\x5f\
\x23\x51\x9f\xf8\x5b\x34\x48\x7e\x17\x52\x24\x4e\x44\x13\x7d\x23\
\x51\xff\x16\x21\x19\x34\x0b\xf5\x7b\xc7\x21\xcf\x92\x61\xa8\x3f\
\x7d\x04\xf5\x9f\x37\xa2\x7e\xf7\x6d\xd4\x86\x9b\x51\x3f\x32\xc3\
\xfe\x3e\x1a\xb5\xfd\x6b\x50\x5f\xfa\x3b\x24\x27\x8e\x43\x7d\xc1\
\x50\xbb\x87\x5a\xfb\x3b\x3c\x93\x72\x2b\xd3\x8b\x56\xd6\x91\x76\
\x6f\x87\xa1\xfe\xe8\x01\xbb\x66\xb0\x9e\x0d\x45\x93\x0c\x77\x21\
\x39\x7c\x11\x92\x1b\x93\xec\xb9\xdf\x83\xfa\xa2\x49\x48\x16\x2d\
\xb2\xbf\x37\x00\x7f\x44\x72\x78\x82\x3d\x9b\x73\x2c\xdf\xb3\xd1\
\x16\x3e\xaf\xdb\xb3\x9a\x69\xe5\xca\x22\x79\xd7\x86\x94\xda\x6a\
\x4b\x3b\xc3\x9e\xfd\xcd\x68\xc2\xfa\x29\xa4\x64\xf4\x43\x32\xbb\
\xd6\xde\xc5\x62\x64\xe1\xcf\x5b\x39\x8f\xb6\x67\x76\x8f\xbd\xef\
\x63\xf0\xf1\x6f\x77\xc4\x48\x56\x7f\x11\xf8\x06\x9a\xf4\xdf\x99\
\x55\x38\x83\x64\xd2\x0b\xa8\x0d\x55\xa5\xce\x19\x6f\xdf\x7f\x6b\
\x69\xae\x45\xca\xe2\x04\xf4\xae\xf3\x48\x46\x0d\x40\xef\xba\x14\
\xc9\xc1\x2c\xaa\x93\x53\x51\x9d\xba\x1d\xd5\x91\xf7\xa1\x7a\x37\
\x19\xbd\xff\x3f\xa0\xf7\x79\x22\xc5\x65\xda\x16\x92\xc9\xb1\x1a\
\x24\x7f\x9b\xd0\xd2\xbb\x0d\xa8\xbd\xd4\x20\xf9\xda\x1f\xd5\x93\
\x17\x51\xbb\xbc\x19\xc9\xf0\x17\x91\xdc\xad\xb5\x72\x37\x5a\x59\
\x5e\x44\xca\xed\x44\xbb\x97\x30\x7e\xbc\x1d\x29\xe8\x53\xd1\x78\
\x66\x0a\x52\x8a\x57\x5a\xfe\xc1\x85\xdc\xe9\x03\xb8\x45\xd8\xe9\
\x4b\xc4\xa8\xb3\x3a\x12\x75\x28\xa0\x41\xc6\x64\x24\xe8\xd6\xa3\
\x19\xba\x08\xcd\x9e\x67\x91\xd0\xab\x45\x9d\x54\x15\x52\xb2\xfa\
\x23\x45\xef\x05\xa4\x6c\xad\x45\xc2\xfd\x28\x34\xc3\xbf\x04\x29\
\xc9\xe7\xd9\x39\xeb\x50\xe7\x1a\x06\x1a\x61\x26\x13\x64\x95\x7c\
\xde\x7e\x5b\x68\x79\x1f\x8b\x06\x34\x17\x5b\x19\x6a\xed\xef\x65\
\x24\x83\x8c\xcd\x48\xb8\x6f\x45\x9d\x74\x0b\x1a\xa8\xd4\x5a\x19\
\x27\xa7\xd2\xe4\xd1\x80\x67\x2a\xc9\xba\xda\x30\x70\x19\x81\x06\
\x0e\xcf\xd8\xf5\xdb\x91\x80\x2a\x47\x03\xa2\x4d\xa8\x63\x9f\x83\
\x84\x4c\x84\x94\xa7\x49\xf6\xfb\x0c\x64\x7d\x0e\xee\x3f\xa0\x81\
\xc4\x49\x76\xbd\x71\x68\xb0\x31\x16\x09\x87\x97\xec\x1a\x8b\x50\
\x47\xde\x66\xe5\x2c\xb5\xf7\xb3\xcc\x9e\xd7\x64\x24\x5c\x66\x59\
\xfe\xcf\x23\x01\x51\x67\xcf\xa2\x06\x0d\x28\x1b\xed\x93\xb7\x32\
\x4f\x44\x83\xa2\x25\x68\x00\x74\x36\x1a\xf8\xad\xb4\x6b\xaf\x47\
\xc2\xa9\x8e\xbe\x2f\x28\x62\x34\x38\x3c\x19\x59\x3f\xce\xb1\x72\
\x9f\x69\xcf\xa3\x1c\x4d\x94\xd4\xa3\x09\x86\xc8\xde\xcb\x60\x34\
\x71\x51\x8a\x84\xff\x20\x7b\xf6\xcf\xdb\x73\x99\x6f\xcf\xb6\x1f\
\x1a\x18\x86\xbd\x52\xa7\xda\x7b\x9a\x8f\xea\xfb\x52\xd4\x1e\x5a\
\x49\x5c\xae\x3b\xed\x5a\x0b\x2d\xef\xc9\xa8\xde\x8f\x42\x83\xdc\
\x50\xaf\x86\xef\xef\x87\xe7\x38\x7b\x81\x1c\xea\x4b\x56\xd9\x27\
\xed\xee\x58\x48\x70\x5d\xfc\x0d\x6a\xb7\xe3\x50\xdb\xfd\x0c\xf0\
\x43\xd4\x96\xd2\xae\x8d\xe1\xfb\x6c\xd4\x6f\xc7\xc0\x85\xa8\x7d\
\xd5\xa3\xbe\x76\x35\xb2\x38\x96\xa2\xc9\xac\x71\xa8\x1d\x6e\x40\
\x16\xa8\xe3\x91\x52\x37\x1f\xf5\x0f\x47\xd8\xb1\x89\x56\x86\xd1\
\xa8\x0f\x0c\x8a\x61\xde\xae\x11\x23\x19\xb2\xc5\xf2\x5f\x83\xfa\
\x86\xad\x76\xcf\x65\x48\xce\xdc\x81\xfa\xe8\x55\xa8\xcf\x98\x54\
\x70\x0f\x69\x45\xa1\x1d\xc9\x95\x49\xa8\xef\x1e\x66\x65\x68\x45\
\xca\xe2\x02\xba\x6e\xb1\xb3\xce\xca\x75\x0a\xea\xc3\x06\xdb\xbd\
\xb4\xd8\xbd\xaf\x44\xf2\x62\x0e\x92\x1f\x75\x56\xde\xe7\x53\xef\
\xa3\x0e\xf5\x89\x1f\xb6\x67\x33\x0a\x4d\xfa\x06\xe5\xa2\xc1\xee\
\xef\x15\xa4\xcc\xce\x47\x32\x3e\x8b\xe4\xcc\xeb\x76\xde\x72\xbb\
\xff\xfe\x24\xb2\x25\xc8\xed\x17\x48\xe4\xdb\xe1\x48\xfe\xaf\xb3\
\xfc\x3f\x64\xf9\x3e\x43\xdf\x97\x2f\xfb\x93\x76\xf4\x8c\xeb\x50\
\x7d\xec\x09\x31\x9a\x68\xf8\x47\x24\xdf\x40\x75\x67\x2e\x92\x65\
\xe7\xa3\x77\xd7\x0f\xd5\xd7\xb4\xdb\x75\xa8\x97\x73\x90\x22\x7d\
\x33\x7a\xf7\xeb\xd0\xb8\x69\x10\x9a\xb0\xaf\x20\xb1\x2c\x3f\x83\
\xda\xcd\x09\xa8\x2e\xd6\x15\x29\x53\x84\xde\xfb\x6b\x48\x4e\x67\
\xed\xef\x7a\x54\x77\xa6\xa1\xb6\xf4\x18\x52\x8c\x67\xa3\xb1\xde\
\x1b\x76\xfe\x32\xa4\x08\x8f\x42\xed\xb0\xcc\xca\xda\x81\x64\xf6\
\x56\x54\xe7\x43\xf9\x9b\x51\x7d\x5f\x84\xda\xcf\xe1\xa8\x8d\xcc\
\xb4\xe7\xb0\x1a\x4d\xcc\xb8\x25\xb8\x0f\xe1\x8a\xb0\xd3\x97\xc8\
\xd0\xd5\x15\x1a\xd4\x99\x5c\x88\x66\xde\x2a\x48\xd6\x0d\x95\xdb\
\xef\xad\x96\xfe\x51\xa4\xb8\x0d\x44\x8a\x5b\x27\xc9\x1a\x12\x48\
\x3a\xaf\x6a\x12\xc1\x59\x82\x3a\xae\xdb\x91\x42\x3c\x05\xf8\x08\
\xf0\x03\x92\x8e\x2d\x9c\x97\x9e\x3d\xee\x40\xc2\xf4\x5e\x2b\xcf\
\xcb\x48\x81\x49\xa7\xe9\x4c\xe5\xd1\x8a\x04\xfb\x4b\x48\x08\x54\
\x23\x65\xa4\x9c\x64\xa0\x71\x21\x1a\x30\xad\x46\x03\x83\x30\x18\
\x58\x8a\x06\x47\xe5\x48\x68\x54\x58\xbe\x9d\x24\x03\xb9\x16\xa4\
\xe8\x87\x01\x4b\xa5\x5d\x33\x67\xe9\xd2\xe5\x2a\x05\xde\x8f\x04\
\xdd\x73\x24\x83\xb1\x0e\xd4\xc9\x97\xd8\x6f\xe7\x22\x01\x01\x5d\
\xd7\xf1\xb6\x5b\xb9\xce\xb7\xbc\x7e\x85\x26\x2e\x3e\x84\x84\xca\
\x1b\x48\x30\x45\xa9\xf2\x85\xf3\x73\x76\x7e\x78\x07\x95\x96\xa6\
\xd3\xae\x1f\xde\xd7\x81\x22\x24\xf2\x48\xb8\xb6\xa1\x01\x5f\x0d\
\x12\x78\xa7\x93\xb8\x13\x86\xf7\x56\x89\x06\x79\xed\xa8\x4e\xdf\
\x63\xcf\xfb\x25\x34\x80\x0c\x4a\x6c\x7a\xad\x54\xab\x3d\x2b\x50\
\x3d\xab\xb0\x63\x33\x50\x7b\x18\x8f\x2c\xbd\x5b\xe8\x5a\x5f\xdb\
\x0a\xf2\xc9\xa1\xc1\xcc\x83\xf6\x5b\x70\xa3\x3e\x50\x9e\xb3\xe3\
\xf4\x94\x3c\xea\x93\xee\x46\x93\x84\xd1\x4e\xd2\x5e\x85\xda\xd6\
\xef\x50\x1f\x3e\x0f\xf8\x0a\xea\x9f\xd3\x6b\x0b\xfb\x23\xb9\x02\
\x49\xbf\x1d\xdb\xf7\x30\x11\x95\xb3\x73\xae\x47\x6d\xec\x09\x24\
\x5f\xc2\x64\xe6\x4b\xc8\x7a\x99\x41\x56\xac\x18\x59\x7a\x1f\x41\
\x03\xea\x61\x56\xe6\x49\x96\x67\x7a\x8f\xe4\x74\x7f\x1a\xe2\x58\
\x84\xe3\xe1\x5e\x82\x7c\xcb\x21\x85\x23\x04\x93\x2c\xb1\x63\xb5\
\xa8\x0f\xc1\xf2\x18\x02\x7c\x14\x29\x97\xb3\xe8\x6a\x2d\xee\x2c\
\x92\xff\x29\x76\x6f\x0f\x23\xa5\xf4\xe4\x54\x5e\x9d\xa9\xb4\xed\
\x05\xf9\xa4\xfb\xb5\x88\x64\x12\xf4\x7a\xd4\x2f\xad\xb6\x7b\x0e\
\x79\x85\xfb\x2b\x94\x05\x69\x19\x11\x5c\xbb\x33\x05\xe7\x55\x21\
\x57\xec\x8d\x48\x4e\xd5\xa1\x7e\xb9\xc5\xea\x45\x0d\x9a\x7c\xfd\
\x18\xf0\x55\xa4\xcc\x78\x3f\xd8\x95\x08\x3d\x97\xff\x42\xcf\x73\
\x23\x3d\xb3\x9e\x47\xe8\xbd\xde\x06\xfc\x0d\xaa\x6f\x79\xe4\xc9\
\x37\x0e\x29\x9b\x4d\x68\xac\x92\x96\xf5\x19\xd4\xbe\x32\x68\x5c\
\xf5\x3d\xa4\xec\x5e\x83\xea\x73\x2b\xaa\x9f\x0f\xa2\xfa\x3b\xd8\
\xfe\xff\x38\x1a\xc3\xcc\x24\xf1\xb0\x48\xaf\xff\x4d\x97\xeb\x55\
\x4b\x3f\x14\xd5\x8b\x10\x4f\x23\x8c\xa7\x42\xbb\x09\x63\x91\xb0\
\x76\xbe\x93\xae\x6b\x7a\xe3\x82\x7c\xd3\x13\x64\x91\x9d\x9b\x1e\
\x2f\xc6\x24\x63\x1e\xd0\x98\xa9\x1c\xa7\x4f\xe1\x8a\xb0\xd3\x57\
\x88\xd1\x40\xe0\x18\xe0\xbb\xc8\xba\x09\x9a\xf1\xfb\x0a\x72\x21\
\x06\xcd\x16\x76\x92\xb8\x58\x3d\x8d\x3a\xcc\xd5\x48\x61\xac\x42\
\x2e\x28\x85\x81\x18\x3a\xd0\x4c\xdd\x3b\x50\x47\x34\x1e\xcd\xf6\
\xb5\xa2\x99\xc0\x57\x90\xb0\xdc\x44\x12\xf4\x20\x62\xfb\x60\x23\
\x59\xa4\x84\x1c\x87\x06\x06\x65\x56\x96\x05\xa9\xeb\xa5\xcf\x6b\
\x45\x9d\xf5\xe9\xa8\xf3\x3d\x06\x09\x83\xfb\x90\x45\xfa\x26\xd4\
\x11\x1f\x8d\x06\x47\x21\x68\x48\x58\x07\xf6\x0b\x7b\x36\x17\x5b\
\xf9\x8e\x47\xb3\x9b\x1b\xed\x9e\x4e\x46\x82\xe0\x54\xe4\x42\x57\
\x86\x94\xed\xd7\xad\x8c\x85\x42\x3e\x42\x9d\x7f\xa3\xa5\x9b\x68\
\xcf\x71\xb1\x95\xeb\x26\x24\xcc\x4e\x02\x7e\x86\x14\xa7\x53\xec\
\xf7\x70\x5f\x33\x91\x05\x7d\x05\x52\xd4\xc7\x93\x28\xd0\x63\x91\
\xa0\xcb\x20\xc5\x6f\x34\x52\x94\x83\x90\x78\x1a\x0d\x06\x6b\x90\
\x65\x7d\x31\x52\xca\xb2\x05\x65\x3c\x10\x06\x27\x95\x68\xe2\xe6\
\x5e\xa4\xd8\x46\x68\xe0\xf5\xef\x68\xf0\xbb\x08\xcd\x6c\x2f\x41\
\xd6\xe2\x3b\x91\xb5\xe2\x16\x7b\x6f\xfd\xec\x79\xcd\xa3\x78\x3d\
\x7b\x01\x0d\xd8\xde\x6d\xcf\xab\x14\xcd\x92\xbf\x07\xcd\xd6\x6f\
\xb6\x4f\x33\x5d\x07\x9a\xe9\xc1\x73\x89\xe5\xbf\xd1\xca\xb0\x0e\
\xd5\xaf\xdf\xb3\x63\x6b\x99\xe3\x1c\xa8\xb4\xa2\xbe\xb2\x27\x83\
\xf7\x59\xc8\x95\xba\x0e\x59\x0e\x8f\x24\x59\x76\xb2\x01\x29\xca\
\x47\xa1\x7e\x79\x11\x6a\x33\x13\x90\xbb\x73\x19\x6a\xa7\xb3\x50\
\x5f\x9e\x76\x39\xee\xb4\xdf\x27\x93\x4c\x30\xce\x42\x93\x90\x4d\
\x96\x7f\x16\x4d\x82\x9d\x6b\x79\x9f\x83\xfa\x12\xd8\x3e\xb8\x4f\
\x8c\xfa\xd3\xe3\xd8\x3e\x76\x42\x90\x6f\x4f\x23\xf9\x56\x83\xe4\
\xc1\x0c\xd4\x5f\x5c\x40\xe2\x4e\xdd\x94\x3a\x27\xac\xfb\x6d\x23\
\x59\xd2\xb1\x98\xe2\x93\x91\x31\x49\xf0\xa9\x1c\xea\xf3\x07\xa6\
\xf2\x49\xf7\x5d\x99\x22\xdf\xd3\x7f\xb7\x22\xf9\xf4\x57\xc0\x7f\
\xda\xb3\x6a\xb4\x32\x1c\x5d\x70\xcf\x69\x59\xba\xa3\x7c\xd3\xe9\
\xca\xed\x9e\x06\x58\x39\xd7\x21\x8b\xde\x0d\x48\x16\x07\x39\x1f\
\x26\x2e\x9c\xed\x09\x96\xd4\x9d\xad\x0d\x4e\xa7\x0f\xef\xe0\x4d\
\x64\xad\xfd\x18\xc9\xe4\x7d\xba\x3d\x84\xf1\x47\x3d\x5a\x5a\xb0\
\x02\xb5\xbb\x67\x50\x1b\x18\x83\xc6\x38\x8d\xe8\x3d\xcd\x46\xed\
\xed\x78\x34\xb6\xa8\x43\xae\xf9\xa5\xe8\x3d\x1f\x8e\xea\x4e\x8c\
\xea\xf0\x35\x68\xdc\xd4\x94\x2a\xd3\x4a\xd4\x7e\x26\xa3\x71\xcd\
\x46\x64\xa1\x7d\x0f\x1a\xcf\x9c\x8d\xc6\x75\x85\xfd\x46\x61\x9d\
\x0b\xff\xc7\x56\xbe\xc9\x56\xbe\x74\x90\xad\xc2\xb6\xf0\x1c\x32\
\x14\xbc\x8b\x64\x69\x84\x2f\x4b\xea\x43\x64\x47\xd6\x96\x7d\xf9\
\xba\xc9\x03\x2a\x6a\xca\x7c\xb9\x84\xb3\xf7\xc9\xe5\xe1\x81\x79\
\x5b\x5b\xe7\xac\x6f\x7d\x08\x09\xa8\x74\x27\x5b\x83\x3a\xa8\x37\
\xed\xef\x2c\xea\xbc\xea\xd1\xc0\xff\x25\xd4\x91\x34\x21\x2b\x6c\
\x70\x3f\x59\x87\x3a\xc2\xf4\xec\x7a\x33\xea\x60\x3b\x48\xdc\x7c\
\x66\xa2\x8e\x75\x04\x52\xe0\xee\x47\x4a\x58\x38\xbf\x0d\xad\x6d\
\x5a\x9f\x3a\xbf\x11\x29\xcc\x2d\x48\x70\xae\x45\xee\x3b\x6f\xa3\
\x4e\x39\x04\x49\x0a\x16\xb6\x20\xc0\x1b\xed\x1a\xed\x48\x11\xda\
\x8a\xac\x04\x2b\xd0\xcc\xe8\x46\x2b\xfb\x10\xcb\xf7\x3e\x12\x8b\
\xc4\x40\x24\x2c\xa6\xd9\xdf\xa7\x58\xfe\x2d\x68\xa0\xf2\x38\x1a\
\x4c\xac\x45\xb3\xae\x6f\xa1\x41\xd6\x30\xbb\x87\x7b\xd1\xc4\x40\
\x9b\x95\x3d\x3d\xeb\xdd\x69\x79\x84\x19\xd8\x67\x2d\xcd\x62\xd4\
\xa1\x0f\x40\x83\xb6\xfb\xad\xfc\x6b\xed\xbd\x2c\xb7\xef\xab\xad\
\x1c\x1b\xd0\x60\x66\x2d\xb2\x48\xae\xb3\xe7\xb1\x0a\x4d\x38\xac\
\xb1\xf7\x93\x4f\x3d\xff\x95\xf6\xec\xb6\x5a\xda\xc5\x68\x1d\x5a\
\x8b\x95\x71\xa5\x95\xaf\xdd\xae\x5d\xcf\xfe\x1f\xa8\x84\x6d\x4b\
\x1a\x48\x14\xd6\x70\x3c\xac\xf3\x09\xee\xe4\x59\xfb\x7f\xbd\x95\
\x7d\x3a\x9a\x98\x29\x43\x42\x76\x91\xe5\xb1\xdc\xea\x42\x0b\x12\
\xe8\xeb\xec\xbc\x15\xa8\xde\x15\xab\x67\xcd\x48\xd9\x5e\x61\xef\
\x6b\x08\x1a\xf0\x3d\x4a\xe2\x32\xbf\xc2\x9e\xed\x1a\xa4\x20\xc7\
\xf6\xff\x3c\x7b\xb7\xfd\x91\xf2\xfe\xa4\xe5\xed\x38\x07\x22\x59\
\x34\x60\x9e\xc3\xf6\x32\x04\x7a\x3e\x91\x16\x82\x64\xcd\x42\x7d\
\x5c\x0d\x6a\x2b\x21\xa6\xc2\x22\x64\xc9\xe9\x44\xfd\xe4\xdb\xa8\
\xfd\x0c\x45\x6d\xae\x13\xf5\xb5\xeb\x49\x3c\x93\x9a\x51\xbf\x56\
\x61\xe7\xbe\x8c\x94\xd1\x95\xa8\x8f\x5b\x8f\xe4\xd0\x4a\x24\x9b\
\x66\xa3\x3e\xa2\x0e\xf5\x9b\x6f\xd8\xf1\x75\x48\x46\x80\xfa\xd7\
\x25\xa8\xdf\xe8\x87\xfa\xd8\x95\xf6\x77\xf0\x00\x59\x81\x06\xf6\
\x8d\xa8\x6f\x99\x89\x14\xe3\x30\xd9\x5b\x8b\xfa\xa9\xf9\xa8\x7f\
\xd8\x62\xd7\x5e\x8a\xe4\xc6\x56\xbb\xc7\xd5\x96\xf7\x1a\xba\x06\
\xf3\xc9\xd8\x6f\x8d\xa8\xef\x59\x88\xac\x6c\xab\x91\x2c\x58\x6a\
\xcf\x2c\x47\x22\x53\xb1\xe7\x11\xa2\xec\x06\x39\xb0\x09\x29\x31\
\xe3\xd0\x7a\xe3\x0e\xd4\x4f\xe5\xec\xfb\xb2\xd4\xf3\xca\x5b\x5e\
\x2b\xad\xcc\x2b\xec\xd8\x16\x4b\x97\x43\x7d\xed\x52\x4b\xbf\xc8\
\xee\x6b\x90\xfd\xf6\xac\x3d\xaf\x37\xed\xba\xa3\xec\x5a\x7f\x61\
\xfb\xc0\x4a\x87\x1a\x95\xa8\x1d\x3d\x87\xde\xd3\xee\xb4\xa3\x4e\
\x54\x17\x82\x1b\xf5\x12\xf4\xce\xe6\xa1\xf6\x55\x8e\xda\xd7\x2b\
\x68\xdc\xb3\x14\xbd\xa7\x3a\xf4\xde\x9e\x4d\x1d\x2b\x43\x75\x6c\
\x26\x52\x8e\x57\xa0\x77\x18\x82\xc0\x3d\x84\xea\xd1\x2a\x24\x1b\
\x37\x92\xd4\xdd\x46\x34\x5e\x9a\x81\xda\x45\xda\xa3\x61\x9d\x5d\
\x7b\x9e\xfd\x3d\xd7\x7e\x1f\x84\xda\xe9\xd3\x76\x1f\x9b\x2d\xef\
\x3c\xaa\x33\xcb\x51\x5d\xda\x4a\x32\x2e\x59\x6e\xe5\xaa\x42\xf5\
\x7f\x15\xc9\xce\x0d\x2b\x49\xe4\xf8\x1a\x2b\xd7\x56\xd4\x76\xb7\
\xd8\xbd\x3d\x43\x12\xb7\xc5\xd9\x3f\x54\xa3\xba\xf2\x48\x74\xda\
\xa8\xea\x2d\xbf\xbe\x71\x5c\xff\x61\x35\x25\xc4\xbe\x62\xc2\xd9\
\xcb\xb4\x75\xc6\x7c\xea\xde\xa5\x5b\xee\x9c\xb5\xf9\xb3\x48\x38\
\xa5\x67\x60\xd2\xdb\x00\xa5\xc9\xd1\xd5\xc5\x39\x90\xde\xba\x27\
\x2e\x72\x2c\x7d\x4e\x94\x3a\x1e\xfe\xee\xc9\xf9\x85\xe7\x92\x3a\
\x9e\x76\x89\x29\x9c\x49\xca\xd1\x75\x76\xb0\xd8\x35\xe2\x82\x3c\
\x0b\x8f\x85\x6b\x7e\x12\x0d\xc2\xfe\x42\xd7\x2d\x2a\x42\x9e\x61\
\x86\xb2\xd8\x3d\x14\x13\x66\x85\xd7\x20\x95\x47\xfa\x78\xa6\xc8\
\x35\xc2\x7d\xe6\xe8\x7a\xdf\xe9\xe7\x0a\xdb\x3f\xfb\x90\xe7\xae\
\xbe\xaf\xfd\x4d\x0e\xf8\x6b\x24\xe8\x82\x2b\x7c\xe1\xef\x85\x16\
\x94\xc2\xf7\x17\xd8\x59\x7d\x2b\x74\x7f\xcc\xb0\xf3\x7a\x93\x7e\
\x4f\x69\x2b\x4a\x3a\x5d\xb6\x9b\x73\x1c\xe7\x40\xa4\x0c\xf8\x12\
\x0a\x30\xf5\x16\xbb\x5f\x97\x43\x1b\x2b\xb4\x40\x16\xeb\x8b\x4f\
\x41\xde\x39\xff\x45\x57\xf7\xce\xc2\xf6\x9b\x3e\x2f\x6c\x77\x06\
\x5d\xfb\x7b\x28\xde\x2e\xd3\xed\xbf\x58\x1b\x2e\x96\x67\x31\xf9\
\x96\xde\xf2\x25\xe4\x9f\xbe\x97\x6c\x41\xfa\xc2\xfe\xb6\xd8\x73\
\xcd\x15\x49\x93\xee\x73\x0a\xef\x2f\x57\xe4\xde\x27\x22\x4b\xe0\
\x02\xa4\x08\xa7\x9f\x59\xa1\xac\x48\xbf\x97\x62\xcf\x24\x7d\x8d\
\x7c\xc1\x39\xe9\x7b\x0e\x7d\x64\xa1\xec\x3f\x54\x89\xd1\x84\xfb\
\x97\x50\x5d\x5e\xbf\x9b\xcf\xa3\xbb\x7a\x5d\x38\x6e\x4b\xd7\xdd\
\xc2\xba\x1f\x15\xa4\x85\xae\x75\xa7\x98\xcc\x4c\xd7\x19\xd0\xa4\
\xce\xa9\xc8\xd8\x50\xb8\x2b\x42\x9e\xae\xed\x26\x4e\x1d\x0b\xed\
\xa5\xb0\xed\x15\xd6\xb9\xcc\x4e\x8e\x15\xb6\xc5\x9c\x95\xe7\x6a\
\xa4\xac\x8f\x45\x0a\xd8\x8f\xd1\xc4\x90\xb3\x7f\x08\x4b\x43\x3e\
\x0e\x7c\xe1\x90\x77\x8d\x8e\x8a\x34\xfd\x3d\x3d\x21\x10\x6d\xfb\
\x67\xef\x5d\xe3\x20\x21\x2d\xbc\xd3\x64\xbb\xf9\x1e\xc8\xec\xe4\
\x58\xe1\xf7\xcc\x2e\x9c\x9f\xe9\x41\x9e\xc5\x28\x2c\x67\xb1\xf4\
\xc5\xee\xb7\xd8\xb1\xe7\xd1\x2c\x64\x29\xdd\x97\xa1\x98\x10\xeb\
\xae\x8c\xdd\x3d\xe7\x62\xc7\xbb\xbb\x46\xb1\x74\xc5\xae\xb7\xbb\
\xef\xab\xaf\xb3\xb3\xfb\xeb\xcd\xfd\xa7\x07\x05\x3d\xad\x37\x69\
\x17\xae\x62\xe9\xba\x7b\xe7\x8e\x73\xa8\xd3\xd3\x7e\x32\x42\x13\
\x62\xd3\xd9\x5e\x91\xca\xec\xe0\xbc\x1d\x5d\xab\x3b\x19\x10\x15\
\xf9\xbd\xbb\x7c\x77\x26\xdf\x76\x24\x53\xbb\xeb\xb7\xbb\xa3\x3b\
\xb9\xd1\xdd\xfd\x65\x0b\x7e\x0b\xfb\xa9\xce\x42\x9e\x29\x3b\x7b\
\x66\x85\xcf\xa2\x58\xda\xf4\xbd\x14\x96\xa7\xf0\x39\x1d\x48\xb2\
\xe5\x40\x62\x67\xf5\xba\xa7\xe3\x8d\xee\xd2\x76\x27\x33\x0b\x8f\
\x6f\xa5\xfb\xad\x01\x7b\xd3\xf6\xba\x6b\x87\xdd\x1d\x2b\xd6\x16\
\x67\xa1\xb1\xdb\x58\x12\xcf\xc6\xb4\xb5\xda\xd9\xcf\x1c\xd2\x8a\
\x70\x0c\x6c\x69\xc9\xd1\xde\x99\x4c\x40\x95\x64\x22\xea\x2a\x4b\
\xc8\xec\xc1\x2a\xda\xd0\x9e\xa7\xb9\x3d\x99\x48\xdd\x1b\xd7\x70\
\x0e\x5a\x32\x24\x91\xb2\x5d\x88\x3b\x8e\xe3\xec\x1f\x22\xe4\x5e\
\xb9\x16\xef\x8b\x7b\x4b\x84\xac\xf8\xc1\x1b\xcc\x47\x41\xce\x9e\
\x24\x04\xba\xea\x4b\xf5\xaa\x13\x2d\x8d\x7a\x01\xf7\x46\xe8\x93\
\x1c\xd2\x8a\x70\x04\xfc\xe4\xa5\xf5\xfc\x71\xe6\xa6\x6d\xc7\x06\
\x55\x95\xf0\xbd\x6b\x0e\x67\xe2\x90\x0a\xf2\x7b\xc0\x6a\xdb\x91\
\x8b\xf9\xbf\x8f\xaf\xe4\x89\x45\x0d\xdb\x8e\x5d\x7c\x54\x2d\x5f\
\xbb\x64\x24\x99\xac\xb7\x05\xa7\x47\xf8\xa0\xcb\x71\x1c\x67\xff\
\xd3\x57\x96\x6c\x1c\xc8\xb8\x3c\x3b\xb8\x08\xca\x5d\x31\xb7\xf9\
\xc0\x9e\x08\x0e\x55\x18\x0d\xba\xd8\xef\xc5\xdc\xf4\xd3\x14\xba\
\xcc\xf7\xe4\x9a\x69\x57\xfb\xde\xe2\xde\x58\x7d\x98\x43\xba\x43\
\xca\x66\x22\x4e\x1e\x51\xc5\x9a\x86\x0e\x96\x6c\x6e\x63\xc9\xe6\
\x36\x5e\x5d\xd9\xc4\xf4\xc5\x0d\x44\x7b\x40\xd6\x65\x22\x58\xb4\
\xa9\x8d\x07\xe6\x6d\xdd\x96\xff\xf2\x2d\xed\x9c\x30\xbc\x92\x8a\
\xd2\x43\xfa\xd1\x3b\x8e\xe3\x38\x8e\xe3\x38\x07\x2e\x31\xda\xce\
\xe8\x93\xf6\x7f\x50\x18\xcb\xd0\xee\x08\xe7\x90\xec\x66\xb1\x3b\
\xd7\xa8\x43\x91\x97\x07\xd0\xbd\x52\xfa\x0e\xb4\x2b\xc7\x69\x68\
\x1d\x7f\xae\x48\x3e\xd5\x68\xeb\xc7\x2a\x76\xae\xdc\xe6\x51\xc4\
\xf5\xd3\xf0\x28\xcf\x07\x35\x87\xb4\x36\x96\x8f\x63\x4e\x1d\x59\
\xcd\xb1\x87\x55\x76\x39\xfe\xd8\xc2\x7a\x1a\xda\x73\xbb\xad\x0a\
\x47\x44\x4c\x5b\x5c\xcf\xba\xc6\x8e\x6d\xc7\x8e\x1c\x54\xce\x05\
\x63\x6b\x89\x7d\x91\xb0\xe3\x38\x8e\xe3\x38\x8e\xd3\xf7\x08\xc1\
\x9e\x76\x36\x58\xad\x47\x81\x87\x4e\x24\x09\x60\x75\x04\x52\x4a\
\xc3\x16\x8b\x21\x28\x55\x09\x49\x50\x2a\xd8\x7e\x4d\x6d\x94\xfa\
\xad\x94\x24\x08\x5a\xd8\xa6\xb2\xbc\xa0\x3c\x21\xf8\x55\x16\x6d\
\x4b\x34\x88\x64\x6f\x6a\x52\xf9\x04\x0b\xf1\x70\xe0\x72\x14\xd5\
\xbd\x70\x9f\xee\xc2\x2d\x08\xb3\x28\x52\xf5\x10\xfb\x9e\x49\x5d\
\x3b\x5c\xb7\x94\xae\x01\xdd\x20\x09\x68\x5a\x98\xb6\x24\x75\x2c\
\x5f\xe4\x58\x08\xb8\x55\x9a\xfa\xdb\xd9\x07\x1c\xd2\xae\xd1\x71\
\x0c\x03\xab\xb2\x5c\x39\xa1\x3f\xaf\xad\x6c\xda\xe6\x0a\xfd\xfa\
\xea\x66\xe6\xae\x6b\xe5\xb4\xd1\xd5\xe4\x7a\xe9\x1f\x1d\x01\x5b\
\x5a\x3b\x79\x64\x41\x7d\x17\x17\xeb\x4b\x8e\xaa\x65\x44\x6d\xe9\
\x1e\x71\xbb\x76\x1c\xc7\x71\x1c\xc7\x71\x9c\x3d\xcc\x44\xa4\x38\
\xbe\x42\xf7\xfb\x09\x47\x68\xab\xa0\xe7\x50\x74\xe4\x69\x68\x9d\
\xee\x14\xb4\xbd\x59\xa3\x1d\x7f\x03\xb8\x08\xed\xbb\x9b\x41\x81\
\xd2\xe6\x02\xef\x03\x6e\x47\x5b\x20\x5d\x42\xb2\x0d\xd1\xd5\x68\
\x9b\xb2\xac\xe5\xb9\x84\xed\x77\xba\xc0\xf2\xbe\x10\x6d\x11\x36\
\xca\xae\x39\x10\x6d\x15\x38\x00\x45\x27\x3f\x0c\x6d\xd1\x74\x0f\
\x70\x12\x52\xa8\x2f\x42\x0a\x7c\x1e\x78\x10\x18\x8d\xf6\x02\x9f\
\x06\x5c\x8b\x94\xd1\x55\x76\xfd\x93\xd1\x3e\xc7\x31\xda\x5a\x6d\
\x19\xb2\x14\x1f\x8f\x14\xea\x25\x28\xfa\xf9\x99\x96\x77\x89\x1d\
\xbf\x0f\x6d\xd5\x74\xaa\xe5\x9d\x45\xdb\x3a\x4d\xb3\x3c\xcf\xb7\
\x67\xf1\x16\x8a\x72\x3d\x0a\xb8\x02\x6d\x33\xb5\xd6\xf2\xec\x0b\
\x5b\x48\x1e\xf4\x1c\xd2\x16\x61\x90\xd5\xf6\xa2\xa3\x6a\x19\x52\
\x5d\xba\xed\xd8\xe6\xe6\x4e\xa6\x2d\xae\xdf\x2d\xab\x6d\x26\x13\
\xf1\xd6\xda\x16\xde\x58\xdd\xbc\xed\x58\xff\x8a\x2c\x57\x4c\xe8\
\x4f\xd6\xa3\x64\x39\x8e\xe3\x38\x8e\xe3\x38\x7d\x8b\xe0\x8a\xfc\
\x25\xe0\x3f\x80\xa9\xec\xd8\x3a\x99\x01\x5e\x43\x0a\xe8\x08\xa4\
\xc8\x4d\x40\xdb\x05\x55\x00\x47\x21\x85\xfa\x62\xa4\x04\x3e\x8b\
\x94\xec\x2a\xfb\x3f\x58\x79\x47\x21\xe5\xf5\x68\x64\x89\xfe\x0d\
\x52\x12\xaf\x45\x7b\x1e\x17\x5a\x82\x87\x20\xb7\xeb\x67\x81\xc7\
\xd1\x5e\xd9\x31\xda\x42\x69\x24\x52\x36\x8f\x46\x8a\xf6\x3a\xb4\
\x6f\xf5\x6c\xa4\xb8\x3e\x87\x14\xe4\x91\x48\x19\xae\xb2\xdf\x2b\
\x80\x33\xd0\x3e\xd9\x4f\x58\x7e\x15\xc0\xdd\xc8\xba\xfd\x3e\x3b\
\xef\x68\xe0\x01\xe0\x0e\x4b\x7f\x34\x52\xa6\xc7\x20\x85\x7b\x25\
\x70\x1d\x70\x38\x70\x03\xda\xa3\xf8\x3e\x14\x39\xfa\x38\xe0\x26\
\x2b\xc3\x3d\xc0\xd9\x68\x5b\xb6\x0b\xed\x7a\x7f\x44\x16\xf0\x11\
\xb8\x55\x78\x9f\x70\xc8\x2b\xc2\xb9\x38\x66\xfc\xa0\x0a\xce\x19\
\x53\xb3\xed\x58\x0c\x3c\xbe\xa8\x9e\xcd\x2d\xbd\x77\x8f\xce\xe5\
\x63\x1e\x59\x50\xcf\xd6\xd6\x64\x99\xc2\x69\xa3\xaa\x39\x7e\x78\
\x15\x79\x37\x07\x3b\x8e\xe3\x38\x8e\xe3\x38\x7d\x8f\x76\xe4\xd2\
\xbc\x1c\xb9\x1a\xef\x88\x08\x59\x30\x17\x03\x27\x20\x25\xb8\xd5\
\xfe\x0e\x01\xae\xb6\x20\x0b\xeb\xcd\xc8\x2a\x3b\x1b\x29\xbb\xe9\
\xfd\x81\xc3\xff\x73\x2d\xbf\x0b\x90\xd5\xb5\x1f\xdb\xaf\x31\xce\
\x23\xc5\xb9\x19\x59\xac\x67\x01\xaf\xd3\xd5\xb5\xfa\x6d\x3b\xef\
\x23\x48\x91\x7e\xdb\xd2\x37\x5b\x79\x0a\xaf\x1d\x2c\xce\x1b\x91\
\x05\x7b\xbd\x95\xf1\x79\xa4\x18\x3f\x43\xb2\x0e\xfa\x05\xa4\xd0\
\x9e\x8f\x26\x0d\xfa\xa1\xe8\xd0\x2f\x5b\xda\x59\x68\x42\x60\x3c\
\xb2\x46\xbf\x8c\xac\xd5\x3f\xb1\xb4\x23\x80\xd3\x81\x4b\x91\xf5\
\x7a\xb8\xdd\xf7\x04\xa4\x6c\x6f\x42\xca\xbb\x5b\xcd\xf6\x01\x87\
\xbc\x22\x0c\x50\x51\x9a\xe1\xaa\x89\x75\x94\xa5\xa2\x38\xcf\x5a\
\xd7\xca\xcc\x35\xcd\x64\x7a\x61\xbd\x8d\x22\x58\xd7\xd8\xc1\x13\
\x8b\xea\xb7\x1d\xcb\x66\x22\xae\x9c\x50\x47\xbf\xf2\xac\x4f\xf1\
\x38\x8e\xe3\x38\x8e\xe3\x38\x7d\x8d\x08\x29\x6f\xff\x8d\x82\x60\
\xbd\xc4\xce\x75\x85\x18\x6d\x11\x74\x3c\x72\x03\x7e\x15\x68\x49\
\xe5\x97\x47\x56\xd5\x9f\x23\x25\xef\xc3\xc8\xf5\x39\x4f\xa2\xec\
\x0d\xb0\xef\xd7\x20\x2b\xeb\x52\x60\x26\xc5\xf7\x04\x8e\xd0\x5e\
\xbc\x15\x24\x6b\x6a\xd3\xc1\x7e\x32\xc0\x66\xa4\x78\xde\x8d\xac\
\xb8\xef\xa7\xeb\xfa\xdb\x1c\x72\x63\xce\xa1\x20\x5a\x55\xf6\x5b\
\xd8\x82\x29\xac\x19\x0e\xd6\xe8\x72\x4b\x7b\x24\xf0\x01\xbb\xbf\
\xd7\xed\x3a\x91\xfd\xd6\x46\xd7\xb5\xce\x6d\x48\x19\x0f\xeb\x86\
\x2f\x40\xeb\x98\xd7\x00\xf7\x5b\xd9\x7e\x8b\x2c\xea\x4b\x80\xef\
\x20\xb7\xf1\x33\x80\xcb\x70\x8b\xf0\x3e\xc1\x15\x61\x14\x34\xeb\
\x8c\xc3\xab\x19\x3f\xb8\x62\xdb\xb1\xc6\xb6\x1c\x8f\x2d\xac\xef\
\xd5\x1a\xe1\x4c\x14\xf1\xe2\xf2\x26\xe6\x6f\x68\xdd\x76\x6c\x4c\
\x5d\x19\x17\x8e\xeb\xe7\x41\xb2\x1c\xc7\x71\x1c\xc7\x71\x9c\xbe\
\x4a\x84\xd6\xf7\xae\xa3\x67\x11\x93\x23\xb4\x1e\xb6\x1a\xb9\x3b\
\xbf\x4e\x57\xfd\xa2\x0e\xf8\x20\x72\x21\x6e\x47\xca\xf0\x66\x64\
\x7d\xbd\xd6\x3e\x47\x21\xc5\xaf\x0c\x29\x95\x15\xc0\xb1\x6c\x1f\
\xd8\x2a\x04\xa6\x5a\x62\xf9\xbc\x0f\x78\x37\x8a\xee\x1c\xca\x12\
\xa3\x60\x5d\x37\x23\x8b\x6b\x8b\xa5\x6d\xb2\xfc\x8e\x47\x16\xe2\
\x63\x91\x0b\xf3\xa5\x24\x5b\x1c\xa5\xcb\x1d\x21\xd7\xf0\x6b\x91\
\x1b\xf6\x6b\x40\x03\x52\x6c\x3b\xed\x7e\x86\x90\x28\xbf\xe9\xe0\
\x5b\x25\xf6\x4c\x5a\x80\xf7\x22\x17\xe9\xf3\x90\xbb\x77\x3d\x70\
\xae\x95\xe3\x6a\x7b\x6e\xe7\xa0\x49\x80\x32\xbb\xc6\xe6\x7d\xf9\
\xc2\x0f\x65\x0e\xe9\x60\x59\x81\x38\x86\x61\x35\xa5\x5c\x3a\xbe\
\x3f\xb3\xd6\xb6\x6c\x9b\x82\x79\xf2\xed\x06\xd6\x35\x75\x32\xac\
\xa6\x84\x5d\xd1\x5f\xdb\x3a\xf3\x3c\x34\x7f\x2b\xed\xb9\xe4\xa4\
\xa9\x47\xd6\x32\xaa\xae\xcc\x83\x64\x39\x8e\xe3\x38\x8e\xe3\x38\
\x7d\x99\x5d\x71\x87\x0c\x56\xe4\x3b\x90\x52\xb7\x1e\x29\x85\x9b\
\x50\x20\xa8\xe5\xc0\x6d\x48\xf1\xec\x40\x96\xda\x55\xc0\x2f\x51\
\x60\xad\x46\x3b\xb6\x16\x59\x81\xcf\x42\xca\xf3\x83\x48\x91\xdd\
\x84\xd6\xd8\x36\x90\x44\x76\x6e\x02\x7e\x86\x5c\x8c\xb3\xc0\x4f\
\x91\x72\x5b\x8e\xac\xb8\x0b\x2c\x5d\x08\xa2\xf5\x92\x9d\xf3\x27\
\xa4\x0c\xbf\x80\x14\xe6\xe1\x68\x3d\x70\x70\xe1\x0e\xd7\xc9\xd8\
\x39\x8b\xd1\xfa\xe7\x57\xed\x9c\x4e\xe0\xf7\x68\xfd\xef\x32\x64\
\xc5\x5d\x8f\x26\x0d\x3a\xac\x2c\x2b\x91\xc5\x77\xa3\x95\x6b\x0a\
\xd2\xb7\x7e\x8e\xd6\x1a\xff\x08\xad\x0b\xae\x02\xfe\x80\x14\xe6\
\x95\x96\x6e\x08\xf0\x08\x52\xba\xdd\x58\xb9\x0f\x70\x45\xd8\xc8\
\x44\x11\x97\x1e\x5d\xcb\x2f\x5e\xd9\xc0\xa6\x16\x79\x62\x2c\xd8\
\xd0\xc6\x2b\x2b\x9a\xb8\xfa\x98\x3a\x72\x3d\xd4\x84\x33\x11\x2c\
\xd9\xdc\xc6\xb3\x4b\x1b\xb7\x1d\xeb\x57\x9e\xe5\xaa\x89\xfd\x29\
\xc9\x44\xbd\x8e\x42\xed\x38\x8e\xe3\x38\x8e\xe3\x38\x7d\x90\x08\
\x29\x6f\x61\xbb\xa0\x08\xd8\x8a\x5c\xa6\x33\x68\x0d\xec\x9c\x54\
\xda\x0c\x52\x86\xef\x4c\x1d\x0b\xca\xf7\x7d\xa9\x63\xc1\x4d\x79\
\x6d\x2a\xdf\xf0\xdb\x26\xa4\x70\x06\xd2\x56\xe3\x0c\x0a\xa4\x15\
\xd3\x75\x7b\xa4\x67\x2d\x4d\x36\xf5\x3d\x9d\xe7\x53\x24\xdb\x25\
\xcd\xa1\xab\x7b\x72\xc8\xe3\x79\x14\xec\x2a\x4a\x1d\x0f\xd7\xc9\
\x22\xc5\x38\x94\x77\x1d\x70\x6f\x2a\x5d\xc6\x8e\xdd\x9f\xba\x66\
\x06\x59\x89\x1f\x29\xc8\xc7\xd9\x07\xf8\x6c\x83\x91\xcf\xc7\x4c\
\x1a\x5a\xc9\x94\xd1\xd5\xdb\x8e\xb5\x76\xe6\x79\x6c\xe1\x56\x3a\
\x72\x3d\x57\x5e\xa3\x28\xe2\xc9\xb7\x1b\x58\xd5\x90\xec\x1d\x7c\
\xd2\x88\x2a\x4e\xf0\x20\x59\x8e\xe3\x38\x8e\xe3\x38\xce\xc1\x49\
\xd8\x7f\x37\x90\x76\x17\x0e\xbf\x65\xe9\xea\x42\x9c\x3e\x16\x15\
\x39\x96\xa5\x7b\xc5\x30\x9d\x36\x4b\xd7\x7d\x80\x21\xd9\xab\x37\
\xad\x40\x67\x53\x79\xa5\xaf\x93\x29\x72\x9d\x4c\x91\xfc\x0b\xf3\
\xcd\xd2\x55\xd1\xa6\x20\x9f\xa8\xc8\xf9\x85\xf7\x98\x3e\x56\x82\
\x2b\xc1\xfb\x14\x57\x84\x8d\x18\xa8\x29\xcf\x72\xe5\xc4\xae\xdb\
\x1b\x3d\xb3\xb4\x91\x15\x5b\xdb\xe9\x49\xcc\xac\x08\x68\x68\xcb\
\xf1\xf0\xfc\x64\x6d\x71\x26\x82\x2b\x27\xf6\xa7\xae\xb2\xc4\x57\
\xbd\x77\x25\x6c\x42\xee\x38\x7d\x1d\xaf\xa7\x8e\xe3\x38\x8e\xe3\
\x38\x07\x19\xee\x1a\x9d\x22\x8e\x63\xce\x1b\xd3\x8f\xb1\x03\xca\
\x58\xb8\xb1\x0d\x80\x65\x9b\xdb\x79\x61\x79\x23\x63\x07\x0e\x62\
\x67\x0b\x85\x33\x51\xc4\xec\xb5\x2d\xbc\xb6\x2a\xd9\x3b\x78\x54\
\xff\x32\xa6\x8e\xab\xf5\x20\x59\xdb\x53\x8a\x82\x02\xf8\x64\x8c\
\xd3\x97\x49\xcf\x08\x97\xe2\x33\xb5\x8e\xb3\xbf\x29\x45\xed\xb2\
\x24\xf5\xdd\x71\x9c\x9e\x13\xa3\xb6\xb3\xa7\xb6\xe7\x29\xb4\x04\
\x87\xc8\xcb\xbd\xc9\x3f\xb8\x19\xef\xad\x41\x73\xb0\x1a\x87\xf2\
\xf5\x24\x18\x98\x73\x10\xe3\x8a\x70\x8a\x7c\x2c\xc5\xf5\xe2\xa3\
\x6a\x59\xb8\x51\x5b\xa7\x75\xe4\x63\x1e\x5d\x50\xcf\xb5\x93\x06\
\x50\x9e\x8d\x76\xd8\x32\xf3\xc4\x3c\xba\xb0\x9e\xcd\x2d\x49\xb4\
\xf7\x0b\xc7\xd5\x32\x66\x40\xb9\x07\xc9\xc2\x7a\x9c\x38\x66\x6b\
\x6b\xae\x0a\xf8\x10\x49\xd8\x79\xc7\xe9\xab\xe4\x51\x14\xcc\x66\
\xb4\x47\xa2\x0f\xba\x1d\x67\xff\x11\xd6\x1f\x1e\x87\x82\xe8\x6c\
\xc1\x65\x88\xe3\xec\x2a\x31\x0a\x18\x35\x94\xdd\x6f\x3f\x79\xe0\
\x9d\x28\xea\x71\xb3\xe5\xfd\x36\xda\x1a\x68\xcb\x2e\xe6\x9f\x41\
\xdb\x1c\x3d\x8a\x82\x47\xed\x69\x79\x9b\x03\xce\x46\x01\xbd\x16\
\x01\x27\x03\xf7\xd8\x71\xe7\x10\xc5\x15\xe1\x02\xb2\x99\x88\xcb\
\xc6\xf7\xe7\x77\x33\x36\xd1\xd0\xa6\xb6\xf1\xe2\xf2\x26\x96\x6c\
\x6e\x63\xe2\x90\x8a\x6e\x8d\xc2\x51\x04\xeb\x1b\x3b\x79\x3c\xb5\
\x77\x70\x75\x59\x86\x2b\x26\xf4\xa7\x34\xeb\x41\xb2\xc0\xa2\x17\
\x44\xd0\xaf\x3c\xd3\x04\xfc\x00\x78\x13\x1f\xc4\x38\x7d\x9b\x18\
\xf8\x1b\x14\xd4\xe3\x1e\xbc\xbe\x3a\xce\xfe\xa6\x0c\xf8\x47\xe0\
\x76\xb4\x15\x89\xb7\x49\xc7\xd9\x75\x06\x00\xff\x87\xee\x2d\xaf\
\x79\xba\xee\xa7\xdb\x1d\x31\x8a\xa0\xbc\x06\xf8\x23\x8a\xda\xfc\
\x01\xb4\x25\xd1\x1f\xe9\xba\xf6\xb7\xc3\xfe\x2e\x45\xd1\x97\x73\
\x24\xd6\xd9\x60\xa1\x3e\x12\x05\xa2\xca\xa6\xca\x16\xd6\xe0\x76\
\xda\xf7\x70\x7e\xb0\xe6\x16\xe6\x99\xbe\x26\x76\x3c\x58\xac\x87\
\xa0\x28\xd0\xaf\xa3\xa8\xcf\x79\xfb\x94\xa5\xca\xd8\x5b\x6b\xb6\
\x73\x00\xe2\x8a\x70\x01\xf9\x7c\xcc\x89\xc3\xab\x38\x69\x44\x15\
\x4f\xbd\xdd\x00\xc0\xea\x86\x0e\x9e\x7a\xbb\x81\x63\x86\x56\x76\
\xeb\x1e\x9d\x89\x22\x5e\x59\xd9\xc4\xdc\xf5\xc9\xde\xc1\xc7\x1f\
\x56\xc5\x69\xa3\xaa\xc9\xbb\x5b\x74\x8a\x88\x92\x4c\x94\x43\xa1\
\xed\x67\xed\xef\xd2\x38\x4e\x0f\x58\x8b\x04\xa6\xd7\x57\xc7\xd9\
\xff\x94\xa2\x68\xb1\x2e\x43\x1c\xa7\xf7\x0c\x44\x7b\xdc\x76\xc7\
\x31\x68\x6b\xa1\x97\xd1\xf6\x46\x3b\x53\x86\x37\xa2\xad\x86\x32\
\xc8\x22\x5c\x85\x2c\xce\xef\x41\x8a\xe6\x72\xd4\x5e\x2f\x06\xfa\
\xd9\xb1\xfb\x80\x85\x76\xec\x14\x64\x41\x1e\x82\x2c\xb6\x1f\xb5\
\xdf\x57\xa1\xfd\x77\xfb\x59\x59\xde\x09\x0c\x46\x1e\x85\x77\xdb\
\x75\x2e\x4b\xe5\x79\x0f\x52\x66\x6f\x44\x16\xea\xb9\x68\xcf\xe1\
\xab\xad\x9c\x43\xed\x58\x35\x30\x02\x6d\xd7\x74\x21\xda\xd3\xb7\
\x02\xc9\xfa\xbb\xec\x5c\x57\x86\x0f\x01\xdc\xcd\xaf\x80\x18\xa8\
\xab\x2c\xe1\xf2\x09\xfd\xb7\x05\xc8\xca\xc7\x72\x79\x6e\x6c\xcb\
\x75\xdb\x2a\x3a\x72\x31\x0f\xcf\xdf\x4a\x4b\x87\x26\xa8\x32\x11\
\x5c\x3e\xa1\x3f\x03\x2a\xb3\xbb\xb4\x07\xf1\x21\x84\xd7\x3d\xe7\
\x40\x21\x1d\x85\xd2\x71\x9c\xfd\x4b\x3a\x4a\xab\xe3\x38\xbd\xa3\
\x3b\x4b\x6f\x8c\xf6\xf0\xfd\x22\xf0\x75\x60\x2a\x3b\x5f\xaf\x1b\
\x23\xd7\xe8\x2f\x00\xff\x00\x9c\x89\xf6\xdc\x2d\x47\x7b\xe3\xce\
\x00\x9e\x06\x26\x01\x4b\xd1\xfe\xc1\xf5\xc8\x6a\x7c\x0c\x70\x09\
\x52\x6a\x67\x20\xc5\xb6\x01\x29\xb6\xa7\xa0\x89\xaf\xb3\x2d\xfd\
\xf5\x76\xbd\xdf\xd8\xdf\x93\xd0\xde\xc4\x4b\x81\x5f\x21\x85\xfd\
\x32\xa0\xc6\xce\x7d\x16\x79\x8d\xbc\x17\x29\xe7\x77\xa6\xee\xbb\
\x16\x18\x6b\xf7\x7a\x14\xda\xce\xe8\x76\xe0\x34\x60\x7c\x0f\xee\
\xd9\x39\x48\x70\x41\x52\x84\x38\x8e\x99\x3a\xae\x96\x91\xb5\x65\
\xdb\x8e\xbd\xbe\xaa\x99\xb9\xeb\x5b\xc9\x44\xdb\xf7\x1b\x99\x08\
\x96\x6d\x69\xe3\xe9\x25\xc9\xde\xc1\xc3\xfb\x95\x71\xc9\x51\xb5\
\xfb\xfb\x56\x1c\xc7\x71\x1c\xc7\x71\x1c\xa7\xa7\xb4\x23\x2b\xea\
\x32\xb4\xe7\xed\xce\x88\x80\x15\xc8\x62\xfb\x3c\xf2\xd6\xb8\x10\
\x29\xc2\xab\x80\xd9\xc0\x06\xe0\x15\x34\x91\x75\x09\x72\x81\xee\
\x87\x62\x70\x2c\xb7\x34\xaf\x20\xa5\x36\x8f\xdc\xa3\x8f\x07\x8e\
\xb6\x7c\x16\x03\x47\x20\x85\x7a\x39\x72\xbb\x7e\x1a\xed\x5d\x9c\
\xce\x73\x20\xd2\x6d\x96\x91\xec\x03\x3c\x08\x29\xc5\x8b\x90\x82\
\x1e\xa7\x3e\x5b\x81\x97\x50\x0c\x90\x0b\x91\xcb\x78\x3f\x5c\x11\
\x3e\x64\x70\x45\xb8\x08\xf9\x18\xc6\x0e\x2c\xe3\xbc\xb1\xfd\xb6\
\x1d\xdb\xd4\xd2\xc9\xf4\xc5\x0d\xc4\x45\xda\x46\x14\x45\x3c\xb3\
\xa4\x91\x65\x5b\xdb\xb7\x1d\x3b\x77\x6c\x0d\x47\x0e\xf4\x20\x59\
\xbd\x20\xec\xe7\x96\x26\xbd\xff\xda\x8e\xce\x2b\x3c\x27\xbd\x5f\
\x5c\xa0\x84\x64\x49\xc0\xce\xd6\xbe\xec\x0b\x76\xb6\x71\x7a\xb1\
\xe7\x11\xce\x49\xff\xbf\xb3\x73\x8a\x1d\x73\x76\x9f\xb0\x5e\xa9\
\xdc\x3e\x99\x82\xdf\xf6\x44\x94\xe9\x3d\x95\x8f\xe3\x38\x5d\x29\
\xd6\xb6\xd2\x7b\x7b\xee\x0d\x0a\xfb\x89\xc2\x6b\x77\xd7\xaf\xef\
\x49\x0a\x97\xc5\x15\xf6\x63\xe5\xf8\xd2\xb9\x43\x95\x08\x68\x02\
\xfe\x1b\xf8\x24\x52\x6e\x7b\xd2\x1e\x16\x03\xd3\x80\x47\xec\x33\
\x11\x59\x77\x3b\x90\x62\x5b\x01\x7c\x10\x29\xb3\x73\x81\x79\x76\
\x5e\xab\xa5\x0b\x91\xe0\xcb\xad\x0c\xb3\xed\xfb\xd5\x96\x76\xb3\
\xe5\x53\x85\xd6\x01\x1f\x8d\x5c\xa6\x3f\x0c\x8c\x46\x4a\xef\xfc\
\x54\x79\x72\xa9\xff\x63\x3b\x8f\xd4\xff\x58\x7e\xe3\xd1\x9a\xe6\
\x66\xe0\x55\xb4\xec\x62\x7f\x8f\x0b\x9d\x7d\x88\x0f\x8c\xbb\xa1\
\x2c\x9b\xe1\xca\x89\xfd\xa9\x2a\xd5\x23\x8a\x63\x78\x7c\x51\x3d\
\x9b\x5b\x72\xa4\x8d\xc2\x11\xd0\xd4\x9e\xe3\xa1\x05\x5b\xb7\x05\
\xc4\xaa\x2c\xcd\x70\xd5\xc4\x3a\xca\x4a\xfc\xf1\xf6\x82\x9b\x80\
\x7f\x45\x9d\x26\xa8\x23\xfc\x3b\xd4\xa9\x76\xc7\x00\xb4\x0e\x25\
\x08\xee\x7e\x28\x2a\xf5\x15\xc0\x57\x48\xea\xf9\xa9\xc0\xb7\x80\
\x09\xe8\xd5\x5d\x0b\x8c\xda\xcf\xf7\x7b\x12\xf0\x11\xba\xef\x78\
\xdf\x8d\x5c\x8e\xd2\x8c\x00\x3e\x8b\x66\x39\x3f\x8d\xd6\xf1\xa4\
\x39\x17\xb8\x01\x75\xf8\xef\x44\x6e\x42\xe7\xa1\x68\x8c\xce\x9e\
\xe5\x54\xe0\xf7\xc0\xcf\x80\x9f\xa2\xfa\x75\x3e\x7a\x9f\x53\x90\
\xe0\xdf\x5d\x86\x00\x9f\x41\xae\x5c\x8e\xe3\xec\x39\x4e\x47\x01\
\x83\xd2\x4a\xdf\x07\x91\x75\xa9\xb7\x64\x80\x77\x20\xeb\x54\x9a\
\x52\xd4\x5f\xff\x27\x30\xae\xc8\x79\xd5\x48\x5e\x1d\x06\x7c\x1e\
\xb9\x8c\xee\x0d\x4e\x40\x6e\xa4\xc7\xa7\x8e\x9d\x01\xfc\x81\xa4\
\x1f\xfb\x29\x7b\xa6\xef\x72\x0e\x4c\x82\x32\xbc\x9e\x9e\x6d\x2f\
\x14\xa1\x7a\xf5\x5e\x34\xce\xb8\x01\xb9\x24\x37\x91\x4c\x34\x45\
\x28\x20\x55\x27\xb2\xda\x1e\x63\x7f\xbf\x81\xea\xfe\x7b\xd1\xf8\
\x6f\x2c\x52\x5c\x37\x23\x0b\xee\x49\x48\x19\x6f\xb6\xff\xaf\x06\
\xae\x01\x6e\x06\x2a\x2d\xff\x4e\x34\x1e\x9a\x80\xda\x72\x58\x3a\
\x11\x59\x3e\x33\x2d\xef\xeb\x90\xab\x77\x94\xfa\x04\x83\x49\x0e\
\x29\xc5\x43\x71\xdd\xe8\x90\xc2\x67\xfc\xba\x21\x1f\xc7\x4c\x19\
\x55\xcd\xe4\x61\x95\xbc\xbc\xa2\x09\x80\x59\x6b\x5b\x98\xb9\xa6\
\x99\x0b\xc6\xd5\x92\xb3\x85\xbf\x99\x28\x62\xde\xfa\x56\x5e\xb1\
\x34\x00\x93\x87\x56\x72\xfa\x68\x0f\x92\xd5\x4b\x0e\x47\xb3\x90\
\xb3\x90\x82\x11\xb6\xca\x78\x32\x95\xa6\x1c\x75\x5a\x9d\xc0\x30\
\xd4\x31\xbe\x03\xcd\x2c\x3e\x06\x8c\x41\x0a\x6e\x13\x70\x22\xea\
\xc8\x4f\x06\xfe\x2f\x70\x07\x72\xbd\xb9\x0c\x75\x8a\x47\xa0\xb5\
\x29\x6f\xa7\xf2\x0f\xd1\x0a\x4b\x90\x8b\x10\x24\x1d\x63\x9e\xa4\
\x93\x0d\xdf\x43\xc4\xc3\x90\xb6\xac\xe0\xbc\xf0\x7b\x3a\xca\x61\
\x60\x23\x72\x23\x4a\x47\x38\x4c\x5f\x77\x4c\xea\xfc\xbc\xdd\x77\
\x33\x9a\x2d\x05\x98\x8c\x84\x48\xfa\x9a\x6b\x51\x10\x8c\x91\xc0\
\xfb\x90\xf0\x58\x8b\x66\x66\x03\xa5\xf6\x7f\x38\xb6\xb3\x72\x3a\
\xc5\x19\x86\x9e\xfb\xbf\xa1\xe7\x77\x2a\x5a\x23\xb5\x19\xb9\x82\
\x2d\x4c\xa5\x0d\xef\x30\xed\x96\x05\xaa\xcf\x61\xd6\x3c\x0c\x1a\
\x72\xa9\x73\xda\xd0\xfb\xee\xb0\xdf\xf3\x76\xbc\x03\x77\xdf\x72\
\x9c\xdd\x61\x08\x92\x11\xe9\x76\x74\x14\x5d\x27\x26\x4b\xed\xf7\
\xce\xd4\xb1\x10\xa5\x36\xb4\xdb\x20\x1f\xb2\x68\x70\xfe\x3e\xb4\
\x0e\x72\x71\x2a\xef\x11\x68\x10\xfe\x0d\xe4\xb6\x09\x5d\x65\x59\
\x27\x1a\xb0\x77\x22\x99\x97\x8e\x9c\x5b\x4c\xee\x84\x6b\x76\xa6\
\xca\xd3\xb6\x93\xfb\x8d\xd0\x04\xf1\x18\xe0\x2a\xb4\x73\x43\x8c\
\x26\x53\xab\x51\x34\xee\xd0\xf7\x6c\xdd\xdf\x2f\xc7\xd9\xaf\xf4\
\xd4\x2a\x9a\x01\x9e\x42\x63\x99\x2a\x54\x9f\x1e\x45\xd6\xd5\x2c\
\x0a\x78\xd5\x8a\xea\xe6\xff\x22\x19\x59\x8a\xd6\xf9\xd6\xa0\x68\
\xd3\x3f\xb6\xe3\xeb\x81\x1f\x21\xab\x6c\x1e\x8d\xcb\x66\x23\x57\
\xe8\x0c\xf0\x10\x72\xd5\x1e\x05\xfc\x05\x45\x7e\x7e\x03\xad\xeb\
\x2d\x01\x7e\x8d\xea\xf1\x5a\xe0\x5e\x92\xb1\x4c\x58\xfb\x5b\x07\
\xfc\xd6\x7e\x5f\x8f\x5c\xab\x67\x01\xbf\x43\x63\xcf\xa5\xc0\xb7\
\xed\x5e\x5c\x19\x3e\x44\x70\x45\xb8\x1b\xe2\x18\x06\x55\x95\x70\
\xd9\xf8\xfe\xbc\xb2\xa2\x89\x18\xa8\x6f\xcb\xf1\xf8\xc2\x7a\xce\
\x1d\x93\xb8\x4c\xc7\xc4\x3c\xb6\xb0\x9e\x0d\xcd\x92\x91\x51\x04\
\x97\x8d\xef\xcf\xe0\xaa\x12\x77\x8b\xee\x1d\x9d\xc0\xe3\xc8\xc2\
\xfb\x2a\x5a\xa7\x92\x43\x9d\xd9\x70\xe0\x16\x34\x63\x5e\x0a\xfc\
\x19\x75\xc0\x8f\x23\xab\xf0\x74\x14\x2c\xe1\x78\xe4\x26\xd3\x86\
\x06\x2a\x93\x51\x10\x87\x5f\x23\x45\x38\x06\x9e\x41\x03\x9e\xa7\
\xd0\xda\x96\x40\x0d\x52\x64\x9a\x90\x22\x39\x0b\xf8\x05\x9a\x81\
\x6c\x45\x4a\xf3\x58\xa4\x44\xff\x02\x45\x36\x2c\x41\xae\x39\x6f\
\xd9\xf5\x4e\x41\x03\x8c\x9f\x22\x8b\xec\x71\x24\x02\xe2\xe7\xc8\
\x2d\x28\x30\x00\x0d\x4a\xe6\x03\x7f\x6b\xd7\x1d\x85\x3a\xf7\x5f\
\xda\x39\x17\x23\x45\xbe\x0a\xcd\xd8\xaf\x47\x6e\x41\xaf\xa1\x81\
\xd4\x27\xec\xff\x65\x48\xa0\x0c\xb6\x67\x34\x19\xcd\xa6\xde\x60\
\xf7\x31\x04\x78\x11\x59\x99\xcf\xb6\xe7\xfa\x38\xf0\x00\xf0\x31\
\xfb\xbd\xbf\x5d\xf3\x47\x68\x10\xe7\xec\x98\x18\x09\xed\xf9\xa8\
\x8e\xce\x43\x01\x3c\xae\x20\x99\x94\x79\x9e\xc4\xb2\xbf\x01\xbd\
\xab\x5f\x23\x61\x1b\xdc\xba\xb6\xa2\x81\x41\x84\xbc\x19\xfe\x0b\
\x59\x8d\xde\x81\x26\x84\x8e\x42\xeb\x98\x3e\x8f\xde\xdb\x61\x48\
\xd9\xfe\x01\xaa\x0f\x8e\xe3\x88\xa3\x90\x72\xfb\x2c\xb0\x7a\x27\
\x69\xc3\xb6\x29\x47\x90\x4c\x0a\xd6\x90\x4c\x4a\x5d\x87\x3c\x6c\
\x72\x68\x10\xfe\x28\xea\x8b\xdf\x85\x3c\x8f\x9a\x81\x1f\xa2\x3e\
\xf7\x06\xd4\x1f\x34\x23\x19\xd0\x8a\x64\xc2\x7a\x24\x23\xae\x47\
\xfd\xf6\x54\xd4\x67\xbc\x13\x29\xc7\xa5\x28\x4a\xed\x73\xc8\x4a\
\xf6\x2a\x89\xcc\xfb\x30\xea\xd7\x1f\x41\x41\x81\xce\x40\x7d\xf6\
\xc7\xd0\x40\xfd\x2d\xd4\xa7\xbf\x1f\x59\xd9\x96\x21\x6b\x6f\x77\
\xeb\x3a\x87\x21\x99\xf0\x6d\x64\x81\x1b\x81\xf6\x6b\x0d\x6b\x25\
\xe7\xe2\x38\xbb\x46\x84\x14\xd2\x57\x0b\x8e\x05\x45\xf2\x69\x12\
\x57\xff\x15\x48\xd9\x4c\x4f\xfc\x67\x50\x1d\x5c\x9e\x3a\x3f\x0b\
\x9c\x05\x5c\x84\xea\x7b\xbb\xa5\xeb\x40\xed\x24\x6c\xeb\x14\xce\
\x5d\x56\x90\x67\x84\xda\x7e\xb8\x6e\x33\x72\xdb\x4e\x97\x2f\x42\
\xf2\x38\x83\xd6\x0d\x3f\x5f\x50\x26\x77\x8f\x3e\x44\xf0\x19\x8f\
\x1d\x12\x71\xc9\x51\xb5\x0c\xad\x29\xdd\x76\x64\xfa\xdb\x0d\xac\
\x6b\xea\x24\x8a\xa4\xf4\x6e\x6a\xce\xf1\xd8\xc2\xfa\x6d\x91\xa1\
\x87\x56\x97\xf2\x8e\xa3\x6b\xf1\x36\xd4\x6b\x32\x48\x49\x7d\x12\
\xb9\xff\x56\x93\x58\xcf\x4e\x44\x8a\xee\x7f\x23\x25\xf0\x16\x34\
\xc0\x58\x06\xfc\x04\x0d\x2e\xb2\x68\x20\xf4\x96\x9d\x33\x16\x45\
\x3e\x1c\x82\x06\x31\xc1\x22\xd7\x80\x06\x0c\xc1\xd2\x16\x28\x41\
\x6e\xc4\xab\x80\xef\xa0\x59\xc4\xcb\xd0\x6c\xe1\x11\x96\xa6\x1f\
\x1a\x94\x94\x21\x25\x75\x29\x9a\xe9\xfc\x30\xea\xb0\x7f\x02\x5c\
\x6e\xe9\x8f\x46\x0a\xcd\x4f\xd0\xec\xe6\xad\x48\x11\x0a\x0c\x46\
\xee\x3c\x95\x28\x50\xc3\x9b\x68\x60\x75\x35\x1a\x14\x95\x22\x37\
\xf1\xff\xb5\xeb\x7c\x08\x0d\xd4\x8e\xb7\x7b\xed\x8f\x04\xc8\xf7\
\xec\x5a\xd7\xa1\xc1\xce\x58\x24\x98\xe6\xa0\x99\xd3\x21\xf6\x5c\
\xce\x44\x83\xb8\x9f\x21\x57\xb8\x8f\x22\x97\xa6\x63\xd1\x6c\xe9\
\x0f\xd1\x64\xc4\x4d\xfb\xbb\x22\x1c\x40\x14\x46\xb0\x5d\x80\x14\
\xe0\x61\xe8\x99\x9f\x84\xde\xcb\xcf\x91\x10\xbf\x04\x0d\x5a\x3f\
\x81\xdc\x9d\xff\x1b\xd5\x8d\x2f\xa1\xd9\xf1\x0e\xe4\x22\xf9\xb7\
\x28\x8a\x66\x3b\x7a\xdf\x65\xc8\x95\xb3\x13\xd5\xcd\xd1\xa8\x9e\
\x39\x8e\x23\xca\x80\xaf\xa2\xbe\xed\xb3\xec\x5c\x10\xe7\x51\xbf\
\xf9\x6f\xc0\x7f\xd8\xe7\x02\xd4\xc6\xce\x40\xca\xed\xaf\x50\xb4\
\xd9\x8f\xa3\xc9\xc5\x33\xd1\xa0\xf9\x3f\x51\x5f\x7e\x1d\x72\xa7\
\x3c\x07\x05\xf0\xf9\x0d\x9a\x78\xfc\x0b\x9a\xac\x02\x29\xb6\x8f\
\xa1\xfe\xfd\x8f\xc8\x6d\xba\x15\xb5\xfd\x97\x91\x2c\xab\x45\x7d\
\x45\x39\x89\x15\x79\x3c\x9a\x90\x05\xf5\xcf\xe3\x51\xff\x7f\x09\
\xf0\x04\x1a\xdc\x7f\x0e\x29\xdb\xdf\xb6\xdf\x3e\xb6\x83\xfb\x3e\
\xc7\xca\x74\x0f\x9a\x88\x9b\x9a\x2a\xdf\x64\x2b\xcf\x7f\x22\xcb\
\xf0\xe0\xfd\xfa\x26\x9d\x03\x89\xb0\xbe\x37\x7c\x82\x02\x5a\xb8\
\x06\x3f\x4a\xfd\x9e\x8e\x5b\x92\x76\x51\x4e\xbb\x52\x3f\x89\x26\
\x80\xd3\xf2\x35\x6b\x79\x64\x76\x90\x67\xb1\xeb\xa6\xf3\x0f\x69\
\x32\x05\x79\x86\xdf\x7d\x00\x7f\x08\xe1\x8a\xf0\x0e\xc8\xc7\x31\
\xe3\x07\x57\x70\xd6\x11\x35\xdb\x8e\x2d\xd8\xd0\xc6\xab\x2b\x9b\
\xc8\x44\x11\x99\x28\xe2\xf5\xd5\xcd\xcc\x5a\x97\x6c\xc5\x76\xd6\
\x11\x35\x8c\x1f\x5c\xe1\x6e\xd1\xbb\x47\x1e\x29\x7e\x83\x90\x25\
\x2d\x6c\x6e\xfe\x0a\x12\xf8\xd7\x23\x85\x60\x30\x1a\xf8\xe4\x48\
\xdc\xb8\x86\x21\xcb\xe9\xdb\x76\xce\x60\xe4\x0a\xb3\x08\xad\xb3\
\x2c\x4d\x5d\xa7\x9e\xae\x4a\x30\x76\xce\x4a\x64\x25\x9d\x8b\x3a\
\xe2\x29\xf6\x5b\x70\x19\x8b\x49\x36\x82\x5f\x61\x69\xe6\xa3\x19\
\xc8\xe7\xd0\x20\xa8\x19\x29\xf1\xad\x96\xd7\x7c\xe4\xaa\x33\x00\
\x29\xa5\xa4\xf2\x0a\xae\x6e\x0b\x2d\xaf\x37\xd1\x4c\xe5\x60\x64\
\xd5\x7e\x04\x29\x57\x33\x48\x22\x22\x86\x73\xd6\xa5\xf2\x9f\x86\
\x06\x33\x91\xfd\xde\x80\x2c\xcc\x9b\x48\x2c\x0c\xa7\xa2\x49\x84\
\x37\xd0\x2c\xe8\x2c\x64\xbd\x68\x44\x13\x05\x8b\xed\x3a\x83\xf6\
\x77\x25\x38\x80\xa9\x40\xef\x2d\xb8\xb2\x9f\x8c\x5c\x1e\x5f\x47\
\x83\xd7\x17\xd1\x64\xca\x04\x34\x20\x7d\x1b\x59\x84\xfa\xa3\x77\
\xfe\x7d\x34\xc1\xd2\x84\xde\x2d\x24\xef\x7b\x0b\xaa\x0f\x8b\xd1\
\x24\x87\x0f\x56\x1d\x27\x21\x87\xfa\xc2\x85\x74\x5d\x96\xd0\x1d\
\x19\x34\x19\xfa\x37\x68\x62\xea\x13\xc8\xf2\x1b\xa1\x89\xd7\x91\
\x48\x19\xbe\x0a\xf5\xdd\x43\x51\xfb\x1b\x82\xf6\x29\x3d\x8a\xa4\
\x4f\x9e\x85\xfa\xce\x55\xa8\xff\xdf\x48\xe2\x4e\x1d\xd6\x3c\x36\
\xa2\xbe\xfd\x65\x34\xe9\x75\x1d\x52\xb8\x07\x91\xc8\xb2\x34\x79\
\x92\x65\x2a\x69\x59\xb1\x14\xf5\x23\x39\xe4\x71\x74\x2c\x9a\xd4\
\x3c\x02\x4d\x82\x16\x1b\xdb\x95\xa2\x09\xd6\x01\x68\xfd\x6f\x2d\
\x8a\x93\x51\x46\x62\x1d\x7b\xdc\x3e\xcf\xd8\x3d\x38\xce\xfe\xe2\
\x45\x24\x2f\x3b\x76\x37\x23\xc7\xd9\x11\xee\x1a\xbd\x13\x2a\x4a\
\x33\x5c\x39\xa1\x3f\x0f\xcc\xdb\x42\x5b\x67\x4c\x6b\x67\x9e\x27\
\x16\xd5\x73\xe9\xd1\xda\x67\xf8\xb1\x85\x5b\x69\x6a\x97\x9c\x2a\
\x2f\xc9\x70\xf5\xc4\x3a\x2a\x4a\x33\xdb\x02\x67\x39\xbd\x22\x83\
\x06\x0d\xdf\x05\xbe\x46\x52\x4f\x3f\x8e\x06\x26\xf7\x20\x25\xef\
\x9d\x45\xce\x9d\x84\x06\x18\x2d\x68\x66\x6f\x06\x5a\x1f\xf2\x1a\
\x89\xa5\xf5\xce\x9d\x5c\x3f\x58\x61\x41\x83\x85\x46\x34\xe0\x08\
\xfb\x69\x0d\x4a\x7d\x6f\xb7\xdf\xc2\x1a\xdb\xe0\xb2\x93\x76\xb1\
\xa9\xb6\xef\x35\x76\xbc\xbd\x9b\xeb\xb6\x92\x28\xfd\x90\x0c\x7c\
\xda\x52\x79\x15\x52\x86\xac\xc9\x20\xe5\xaa\x25\xf5\x5b\x98\x91\
\x4d\xaf\xf7\x6d\x42\x83\xb9\xf0\x7b\xb8\xbf\x7c\xaa\x5c\x61\xdd\
\xb3\xd3\x33\xf2\x24\x03\xde\x2a\x34\x71\x32\x8d\xe4\xb9\x37\x23\
\x6b\x0e\xe8\x7d\xd5\x92\xac\x09\x0c\x01\xb0\x6a\x50\x7d\x6d\x41\
\x03\xf0\x55\x48\xc9\x3d\x9c\xae\xf5\xa5\xf0\x3d\xf9\x5a\x6e\xc7\
\x49\xc8\x21\x8b\xe6\xcf\xd1\xa4\x69\x4f\xfa\xb1\x1c\xea\x17\xc3\
\x80\xbb\x3d\xf5\xff\x5c\xe4\x3d\x03\x1a\x94\xaf\x44\xd6\xd2\x39\
\xc8\xf5\x7a\x18\x49\x7f\xd9\x4e\xd7\x20\x3c\x85\x6d\x33\x2d\x13\
\x3e\x86\xda\xf6\xdd\x68\x42\x76\x44\x91\x72\x85\x75\xc9\x61\xf2\
\x76\x20\xc9\x12\x9b\x50\xc6\x3c\x9a\x04\xbe\xc7\xca\x34\x04\xc9\
\xcb\xbc\xfd\x1f\x22\xe6\x82\x94\xf6\x71\xc0\x83\x48\x26\xbd\x86\
\x26\x95\x4f\xb4\x34\x6b\x49\x26\xde\x1c\x67\x57\x48\xc7\x50\x09\
\x84\x78\x16\xbd\x1d\x4b\x84\x3c\xd3\x63\xa2\xbd\x51\x4e\xe7\x10\
\xc7\x15\xe1\x9d\x10\xc7\xf1\x36\x2b\xef\x9b\x6b\xa4\x63\x3c\xbb\
\xb4\x91\xb5\x8d\x1d\x44\x11\x3c\xf9\x76\xc3\xb6\xb4\x13\x06\x97\
\x73\xe6\xe1\x1e\x24\x6b\x37\x49\xaf\xf3\x78\x0e\x09\xe6\xcf\xd9\
\xdf\x61\xc6\xbc\x1f\x52\x36\xaa\xd9\x7e\xbb\x9a\x13\x48\xd6\xaa\
\x04\xe5\x34\x83\x2c\xaa\xdf\x45\xee\x72\xf3\x91\xeb\x74\x31\x62\
\xa4\x28\xfe\x0d\xb2\x28\x9c\x8e\x82\x9b\x0c\x07\xfe\x0a\x59\x60\
\xcf\xa4\xf8\x5a\x92\x74\x59\x32\xa9\xff\x6f\x40\x4a\xee\x19\x68\
\xf0\xb4\xa1\xa0\xcc\x99\x82\xff\x29\x38\x96\x29\x48\x1b\xbe\x87\
\xfd\xf1\xfe\x1a\x59\x18\x2e\x40\x2e\xd2\x23\x2c\x5d\x8b\x3d\xb3\
\x73\xd1\x60\x2a\x83\x66\xfb\xbf\x86\x02\x92\x95\xdb\xf9\xcf\xa0\
\xc1\x50\x54\xe4\x3a\xce\xce\x99\x8c\xde\x01\xc8\x32\x13\x01\xf7\
\xa3\xf7\x5d\x82\xd6\xae\x5f\x8c\x5c\x9d\x2b\x50\x1d\x6d\x04\x1e\
\x46\xdb\x36\x1c\x86\x5c\xf0\x5f\x45\x75\xfa\xa3\x28\xb0\xdb\x89\
\xa8\xbe\xfe\x88\xe2\xf5\x2d\xdd\x56\x1c\xc7\x11\xad\x68\x22\xa9\
\x27\x14\xeb\xeb\x32\x68\x10\x3f\x0d\x2d\x57\xb9\xd4\x8e\x9f\x06\
\x7c\x13\xf5\xa9\x1d\x68\x69\xc2\x71\x68\xb2\x35\xdd\x4f\x07\xc5\
\xfa\x3c\x64\x25\x6e\x28\xc8\x1b\x12\x59\x56\x43\x57\x59\x96\x96\
\x1b\x31\xf2\x24\xb9\x11\xf5\xe5\x17\x5b\x5e\x69\x59\xb1\x11\xc5\
\xb9\xb8\x0a\x4d\xaa\x5d\x80\x3c\x7d\x16\x00\x7f\x8f\xe4\xc1\x72\
\x4b\x7b\x39\xea\x63\xfe\x3d\x55\x9e\x01\x48\x19\x7e\x89\xae\xd1\
\x73\x1d\xa7\xa7\xe4\xd1\x5a\xde\x3a\xe0\x4f\x24\xf5\xf3\x83\x68\
\x6c\x31\x8f\xde\x8f\x27\x62\x34\xd9\x34\x1e\x2d\x47\xd8\x9d\xba\
\x19\xca\xd9\x84\xc6\x96\x3e\xc6\x71\x00\xc8\x8e\xac\x2d\xfb\xf2\
\x75\x93\x07\x54\xd4\x94\x79\x9d\x28\x46\x0c\xf4\x2b\xcf\xb2\x62\
\x6b\x3b\x2f\x2c\x53\x64\xe8\xc6\xf6\x1c\xa7\x8d\xaa\x61\x5d\x63\
\x07\xbf\x7a\x6d\x23\x9d\xf9\x98\x08\xf8\xe0\xc9\x83\xb9\x6c\x7c\
\x7f\x37\xa5\xed\x80\x5c\x1e\x1e\x9c\xbf\xb5\x79\xf6\xba\xd6\xdf\
\x51\x7c\xb0\xd2\x8a\xdc\x3e\xd7\xa0\xc7\x3f\x1b\x29\xa4\xaf\x23\
\x61\x5d\x89\x94\x89\xb0\xde\x6a\x11\x5d\x23\x1f\x83\x06\x0f\xad\
\x68\xd6\x7c\x19\x1a\x14\x60\x69\xb7\xa0\x8e\xb0\xbb\x20\x2a\x95\
\x68\xdd\xd4\x63\x68\xb0\x72\x3b\x72\x23\x5e\x86\x06\x1d\x03\xd0\
\x00\xe9\x55\xe4\x9e\xb6\xd9\xca\xdb\x6e\xdf\xe7\xda\xb5\xeb\xed\
\xfb\x71\x68\x20\xd2\x68\xf9\xdc\x41\x57\x57\x9f\x0e\xbb\xd7\xa5\
\x96\xff\x62\xd4\xd9\x37\x22\x01\xb2\xd6\xae\xbd\xc9\xd2\xae\xb2\
\xfb\x09\x69\x57\xd9\x7d\xd5\x22\xeb\xc2\xcb\x56\x96\x70\x7c\x2d\
\xb2\x22\xcc\xb6\x7c\xde\xb2\xe7\x36\xc2\xae\xf1\x73\x2b\x5f\x8b\
\xe5\x57\x6f\xe7\x2f\x27\x89\x6c\x7a\xa8\x73\x3e\xaa\x37\x6f\x14\
\xf9\x2d\x78\x04\x84\xbd\x41\x5f\x47\x16\xa4\xf0\xbe\x56\xa3\x77\
\xb1\x11\xd5\xdb\x8d\x48\xb0\x4f\xb7\xcf\x06\xe4\xe5\x30\x03\x05\
\xc5\xaa\x43\xef\xed\x49\xf4\xfe\xb3\xc8\xfd\x7e\x05\x7a\x3f\x9b\
\xd1\x44\x4e\xab\x7d\xde\x46\xf5\xc7\x71\x0e\x15\x4a\x50\x30\xba\
\x57\xe8\xb9\xc2\xdb\x1d\x1d\xa8\xaf\x9b\x4f\x62\xb9\x0a\x7d\xe1\
\x3c\x24\x4b\x86\x5b\xba\xdb\x90\xd5\x75\x36\x6a\xc3\x4d\x68\xb9\
\xcb\x62\xd4\x66\x57\x90\x04\x77\x5c\x8a\xfa\xe4\xc5\x24\x5e\x3a\
\x21\xb0\xde\x22\xcb\xb7\x1c\xc9\x9b\xc7\xec\xef\x45\x68\xa2\x75\
\x01\x49\x00\xbe\x37\x90\xf2\xdb\x0f\x2d\x5d\x99\x61\xe5\x0d\xe9\
\x3a\x50\x9f\xd3\x6e\x65\x7a\x11\x4d\xc2\xc5\x68\x02\xf4\x4d\xcb\
\x2b\x78\x26\x4d\xa7\x6b\x70\xbd\x25\x56\xbe\x79\xa8\x2f\x59\x80\
\x73\xa8\x10\xb6\x57\x0c\x5b\x13\x15\x4e\xaa\x06\xb7\xfc\x9d\x4d\
\xb8\xe6\xd1\xda\xf3\x91\x48\xc1\xc4\xd2\xbf\x9b\xe2\xf2\x29\xbd\
\x06\x37\x6c\x75\x94\x4f\xfd\x1f\xd6\x19\x87\xe5\x5c\xa7\xa1\xba\
\xfc\x22\xf2\x90\x08\xdb\x30\x05\x6b\x73\x7a\x5d\x70\x38\x2f\x18\
\x0a\x42\x5e\x21\x6d\x15\x1a\xe3\x84\xbd\x82\x83\xb7\x45\x38\x27\
\x8c\x21\x43\xa4\xf8\x3d\x69\x8d\x76\xfa\x16\xd5\x68\x59\xe0\x23\
\xd1\x69\xa3\xaa\xb7\xfc\xfa\xc6\x71\xfd\x87\xd5\x94\xe0\x86\xcc\
\xe2\x64\xa3\x88\x97\x56\x34\xf2\x9e\xdb\x16\xb3\xa9\x45\x1e\x90\
\xef\x3b\x71\x10\xa5\x99\x88\x5f\xbe\x26\xe3\xde\xa0\xaa\x12\xfe\
\xf8\xde\x23\x39\x75\x64\xf5\xb6\xad\x95\x9c\xed\x69\xeb\x8c\xf9\
\xcc\x7d\x4b\x37\xfc\xe9\xad\xcd\x57\xa0\x0e\xb8\xaf\x31\x10\xb9\
\x50\x7f\x12\x29\x2d\xbb\xcb\xdf\xa3\xc1\xc6\x1d\xfb\xfb\xc6\x9c\
\x5e\xf3\xcf\xe8\x1d\xfe\xba\x97\xe7\x4f\x42\x7b\x61\x3f\x86\xac\
\xbf\x47\xa2\xc8\xe4\xbe\x3d\x89\xe3\xec\x3a\x15\xc8\xd2\xf9\x23\
\xa4\x0c\x3b\xdb\x53\x83\x96\x01\x3d\x80\xf7\x33\x4e\x71\x06\xa3\
\x58\x2c\xdf\x47\x93\x23\x85\x0a\xdf\x44\x34\x09\xf4\x32\x89\x27\
\x42\x31\x72\xc8\xb3\x69\x2c\x9a\x04\x0e\x0a\xe5\xe7\x90\x21\x61\
\x3c\x49\x8c\x8c\x63\x90\x62\xbb\x18\xc5\xce\xc8\xa2\xf6\xfc\x30\
\x9a\xf4\x39\x11\x19\x22\x4a\x2d\xcd\xa3\xc0\x47\x90\x67\xde\x0f\
\xd1\x44\xfe\x35\x68\x09\xc0\x26\x14\x90\x2e\x8f\xbc\x26\x9a\xd1\
\x64\xd0\x6c\x3b\x7e\x14\x0a\x2a\x57\x85\x26\xa9\xee\x44\x5e\x5a\
\x4d\x96\xe6\x9d\xc8\xab\xa3\xc5\xae\xb3\xd0\xf2\xa9\x40\xf1\x3a\
\x9a\xd0\xb8\x6d\x23\xae\x0c\x1f\x6c\xc4\xa8\x0e\x7d\x1c\xf8\x82\
\x9b\x81\x7b\x40\x3e\x8e\x99\x3c\xac\x92\xd3\x46\x57\x6f\x3b\x36\
\x7d\x71\x03\x0f\x2f\x48\xe4\xcb\x19\x87\xd7\x30\x69\x68\x85\x2b\
\xc1\x07\x3e\xcd\x68\x5b\xa4\x3d\x15\x28\xe4\x71\x34\x8b\xef\x1c\
\xba\xcc\x45\x83\xf6\x1a\x64\x21\xfe\x1a\x3e\x38\x75\x1c\x67\xef\
\xd1\x82\x3c\x84\xbc\x9f\x71\x76\x95\x18\x79\x26\x7d\x11\xed\xb8\
\x31\x95\x9d\xaf\xf3\x8d\x51\xc4\xf3\x4f\x03\x9f\x42\xcb\x80\xc6\
\xa0\xf8\x26\xad\xc8\x62\x9c\x41\xcb\xca\xda\x2c\xff\x63\xd0\x44\
\xcd\xab\x68\xbb\xcc\xf1\x68\xff\xed\x97\x91\x77\xd4\x44\x12\xaf\
\x86\xb9\x48\x51\xbe\x11\x29\xcf\xbf\x45\x8a\xea\x4d\xc8\x5b\xe2\
\x14\xa4\xdc\xde\x69\xe5\x1d\x83\xb6\x1e\xdc\x82\x94\xf1\x6a\xa4\
\xf8\x0f\x47\x4b\xdf\xae\x40\x16\xec\xdf\xd8\x79\x1f\x44\x46\x90\
\x63\x91\x97\xc5\xef\x91\xa2\x74\x36\xbe\x9e\xf8\xa0\xc7\xd7\x08\
\xf7\x80\x18\xa8\x2e\xcb\x72\xe5\x84\xfe\x3c\xbe\xb0\x9e\xce\x7c\
\xcc\xca\xfa\x24\x7e\x4d\x69\x36\xe2\xaa\x89\xfd\xa9\x2a\xcb\x7a\
\x90\xac\x03\x9f\x56\x14\x35\x74\x4f\xf1\xda\xfe\xbe\x21\x67\xbf\
\x93\x47\x6e\xfd\x2f\xed\xef\x82\x38\x8e\x73\x48\x90\xa3\x6b\xe0\
\x44\xc7\xd9\x15\xda\x90\x45\xb6\x1a\x2d\xaf\xda\x19\x11\x72\x5d\
\xfe\x2e\xc9\x56\x45\xff\x60\xff\xbf\x80\x3c\xec\x8e\x42\x0a\xea\
\x2f\x90\x12\xfc\x12\x72\xc9\x5f\x85\xd6\xd3\x9f\x8e\x96\x6b\xbd\
\x88\x0c\x11\xcf\x21\xab\xf1\x8b\x48\xe9\xcd\x23\xe5\x78\x0b\x8a\
\xb6\xde\x1f\x29\xc1\xe5\xc8\x63\x6b\x86\x95\xbb\xd1\x8e\x07\xeb\
\xf1\x28\xb4\xa4\x21\x6c\x65\x56\x8a\x76\x6c\x78\x1c\x2d\x61\xd8\
\x84\x96\x3f\x8d\xb6\x34\x2f\xa0\x65\x61\xcb\x90\x72\xec\x83\xfa\
\x83\x1c\x57\x84\x7b\x48\x1c\xc7\x9c\x37\xb6\x1f\x63\x07\x94\xb3\
\x60\x63\x6b\x97\xdf\x8e\x1a\x58\xce\x39\x47\xf4\x23\x76\x6b\xb0\
\xe3\x38\x8e\xe3\x38\x8e\x73\x60\x12\x21\x45\xf4\x7f\xd0\x1a\xf6\
\xb0\xc6\x7c\x67\x74\xa2\xc9\x97\xe0\x1a\x1d\xd6\xfd\xae\x24\xd9\
\xf6\x72\x0b\x5a\xe3\x3e\x99\x64\xb7\x8b\x32\xfb\xd4\x23\xb7\xe4\
\xb0\x3e\xb7\x16\x29\xb6\x61\x60\x9d\xb3\x72\x3d\x8f\xdc\xac\xfb\
\x23\x45\xbd\x9d\x24\x8a\x7a\x3a\xd8\xdc\x3c\xe0\x3b\x28\x1e\xca\
\xbb\x91\xa5\x37\xac\x7b\x6e\x47\xca\x72\xde\xae\x59\x66\xd7\x0a\
\xbb\x39\xa4\x23\x56\x3b\x07\x39\xae\x08\xf7\x90\x7c\x0c\xa3\xfa\
\x97\x31\xf5\xc8\x7e\xdb\x29\xc2\x17\x1f\xdd\x9f\x11\xb5\xa5\xb8\
\x31\xd8\x71\x1c\xc7\x71\x1c\xc7\x39\x80\x89\x90\x15\xb6\x89\x9e\
\xad\x8f\x2d\x0c\xa8\x95\xde\x46\xac\x03\xb9\x3b\x7f\x0e\xf8\x36\
\x89\xd2\x7a\x06\xb2\x36\x8f\x46\x6b\x78\x9f\x42\x16\xdf\x0f\x20\
\xe5\xf9\x0c\xe0\x8f\x48\x31\x1d\x86\xb6\x1b\x7b\x1e\x59\x8e\x73\
\xc8\x8d\x79\x2d\xb2\x18\x67\x8a\x5c\xfb\x12\xb4\x1c\x69\x0e\x5a\
\xe3\xbc\x19\x29\xcf\x9d\x76\xad\xab\x91\x0e\x74\x24\x0a\xe8\xb5\
\x8c\xae\x81\xbc\x7c\x5d\xf0\x21\x82\x2b\xc2\xbb\x40\x36\x82\x8f\
\x9c\x3a\x98\xb1\x03\xcb\xb7\x05\x16\xcb\x44\x30\xf5\xc8\x5a\x32\
\x11\xae\x08\x3b\x8e\xe3\x38\x8e\xe3\x38\x07\x3a\x3d\x55\x04\x33\
\x28\x68\x5d\x65\xea\x9c\x3c\x0a\x58\x15\xb6\xee\x5a\x81\x82\x51\
\xbd\x45\xb2\x35\xd8\xeb\x68\x29\xda\x1c\xa4\xcc\xd6\x03\x3f\x41\
\xc1\xb4\xaa\x91\x0b\xf5\x3c\xe4\xfa\x7c\xbf\xe5\xff\x00\x52\x92\
\x8f\x40\xcb\xce\x5e\xb1\xfc\x1e\x26\xb1\xf8\xde\x87\x5c\x9e\x17\
\xa2\xad\xc9\xea\x80\xbb\xd0\x1a\xe3\x8d\x48\x11\x5f\x82\x5c\xa8\
\xc7\x5b\x99\x5e\x41\xd6\xe6\xc7\xd1\x4e\x0e\x19\x2b\x53\xb8\x3f\
\xe7\x20\xc6\x15\xe1\x5d\x20\x1f\xc3\xf8\xc1\x15\x1c\x33\xa4\xb2\
\xcb\xf1\x5c\x1c\xbb\x12\xec\x38\x8e\xe3\x38\x8e\xe3\x1c\x4a\x44\
\x48\x99\x85\xae\x2e\xc5\xcf\xd8\x6f\xc7\xa0\x08\xcd\xaf\x92\x6c\
\x5b\x94\x41\x4a\xe9\x5f\x48\xb6\x3f\xca\x20\xab\xed\x43\x74\xdd\
\x16\xa9\x0d\xed\xb8\x10\xce\x7b\x09\x29\xa9\xe9\xed\x8e\x5e\x4a\
\x7d\x7f\x26\xf5\xbd\x30\xaf\xb9\x24\x16\xe3\x99\x68\x5d\x71\x7a\
\x5f\xee\x57\x52\x7f\xcf\x2e\xb8\x27\xe7\x20\xc5\x15\xe1\x5d\x24\
\x1f\x2b\x8a\xb4\xe3\x38\x8e\xe3\x38\x8e\xe3\x1c\xe2\x14\x53\x16\
\xb3\x24\x6b\x6c\x67\x01\x4f\xa7\xd2\xce\x46\x96\xde\xb0\x8f\x70\
\x20\x04\xda\x2a\x96\x57\xb1\xef\xe9\xf3\x7a\x92\x36\x53\xf0\x3d\
\xb3\x93\xdf\x9d\x43\x00\x57\x84\x1d\xc7\x71\x1c\xc7\x71\x1c\xc7\
\xd9\x93\x44\xc8\xbd\x79\x2e\x89\xd5\x15\xe4\x9a\x1c\x2c\xb5\x8e\
\xb3\x5f\x71\x45\xd8\xd9\x5f\xf8\xde\x6c\xce\x81\x42\x88\x34\xe9\
\x38\xce\xfe\x27\x87\x06\xd1\xde\x26\x1d\xa7\xf7\x84\x76\xb4\xa7\
\xc8\x23\xc5\xb6\xcc\xf2\x2d\x8c\xe4\x9c\xa6\x30\xb8\xd6\x9e\x20\
\x5c\x67\x6f\xf4\x0b\xc1\x5d\x3a\xb7\x17\xf2\x76\xf6\x33\xae\x08\
\x3b\xfb\x94\x98\x98\xa6\xf6\x7c\x25\x8a\x0c\x78\x3e\x1e\x99\xcf\
\xe9\xdb\xc4\xc0\x39\x68\xbb\x87\xa1\x78\x7d\x75\x9c\xfd\x4d\x09\
\x70\x3c\xf0\x41\xe0\x02\xbc\x4d\x3a\x4e\x6f\xa8\x61\xcf\xc9\xb4\
\x18\x38\x1a\xb8\x10\x45\x66\x8e\x50\xb0\xaa\x47\xe8\x79\xe4\xe9\
\xdd\x21\x8f\xa2\x44\x67\x50\x40\xad\xec\xee\x65\xb7\x5d\xde\x47\
\xa1\x68\xd5\xb7\xed\xe5\xfb\x70\xf6\x03\xae\x08\x3b\xfb\x9c\x58\
\x9d\x55\x1d\x8a\xd2\xe7\x83\x18\xa7\x2f\x13\x03\x55\x28\x22\xe5\
\x60\xbc\xbe\x3a\xce\xfe\xa6\x04\xed\xfd\x59\x87\xcb\x10\xc7\xe9\
\x2d\xd5\x74\x5d\xc7\x5b\x48\x9e\xc4\x7d\x79\x47\x6d\x2c\x8f\xa2\
\x38\xff\x35\xf0\x04\x8a\xda\x5c\x01\xbc\x07\xc9\xce\xdf\x5b\x9a\
\x12\xfb\xb4\xd3\xd5\x2d\x3a\xac\xd5\x6d\xb7\xeb\x74\x97\x36\x58\
\x65\x63\x24\x8f\xcb\x52\xe7\xc5\xc0\xf0\x82\xfb\x09\xeb\x8d\x3b\
\xed\xef\x6c\xea\x9e\xc2\xf7\x3c\x5d\x2d\xd8\x99\xd4\xef\xa5\x76\
\x9d\x4e\xb4\xe7\xf0\xd8\x54\x59\x4a\xec\x78\x94\x2a\x57\x28\x7f\
\x48\x13\xce\xcf\xa7\xca\x53\x66\xe7\xe5\xba\x39\xe6\x7d\xd9\x7e\
\xc0\x15\x61\x67\x9f\x12\x11\x51\x5d\x9a\x69\x43\x33\x85\x6f\xe2\
\x6b\x44\x9c\xbe\x4d\x0e\x0d\xb8\x57\x02\xf7\xb0\x67\x67\x9a\x1d\
\xc7\xd9\x75\xca\x91\x85\xc6\x65\x88\xe3\xf4\x8e\x18\x18\x88\xf6\
\xed\xed\x8e\xc9\x48\xb9\x7c\x09\xed\xc3\xbb\x23\x25\x6d\x2a\xf0\
\x36\xb2\xc6\xc6\x48\xb1\xfb\x35\x6a\xa7\x11\xda\xab\xf7\x0a\xa4\
\x7c\x2f\x07\xee\x45\xca\xf3\x54\xa4\x40\x0e\x02\x9e\x05\x9e\xb4\
\x73\xae\x40\xdb\x25\xad\xb4\xb4\xa3\x81\xcb\x91\x62\xf9\x9a\x5d\
\x63\x0a\xea\x0b\x36\x01\x7f\x20\x71\xcd\x0e\xf7\xd7\x0f\x78\x17\
\xda\x3a\xa9\x12\x29\xea\xbf\x01\x56\xdb\xf1\x87\x80\x13\x80\x93\
\x90\x9c\x7f\x0e\x78\x01\xed\x4f\x7c\x21\x52\xe2\xdb\x81\xdb\x2d\
\xef\x9c\x5d\xef\xdd\x68\xff\xe2\xb7\xad\x9c\x6d\x68\x92\xfc\x55\
\xe0\x51\x60\x08\x70\x8d\xdd\xd3\x26\x34\x31\xd0\x88\x22\x67\x8f\
\xb2\x3c\xef\x05\xd6\xd9\xb1\xe1\x96\xf7\xbd\xc8\x8a\xee\xca\xf0\
\x3e\xc6\x15\x61\x67\x9f\x63\xd3\x75\x61\xc6\xcf\x07\x31\x4e\x5f\
\x26\xcc\xf6\x66\x51\x7d\x75\x45\xd8\x71\xf6\x2f\x59\x12\x6b\x8f\
\xcb\x10\xc7\xd9\x75\x62\xb6\x8f\xd8\x9c\xfe\x6d\x00\xf0\xf7\x48\
\x19\xfe\x37\xe0\x6e\xba\x57\xd0\xca\x80\x71\x68\xdb\xa2\x1c\x50\
\x8b\xdc\xa4\x33\x48\x61\xac\x45\x4b\xe1\x5e\x47\x4a\xec\xbb\x91\
\x02\xb9\xd2\xf2\xff\x26\x52\x1a\xaf\x45\x8a\xe0\xfb\x0b\xd2\x5e\
\x6e\x69\x8f\x03\xbe\x0e\x6c\x01\xae\x42\x5b\x2a\x6d\x06\x3e\x85\
\x14\xda\xf4\xda\xe0\x08\xb9\x64\xf7\x43\x4a\x78\x39\xda\x9f\xf8\
\x55\x2b\xef\x50\xa4\x70\x4f\x05\x7e\x85\x14\xe5\xf7\x02\xeb\x81\
\x49\x68\xcf\xe1\xb9\x68\xf9\xc5\xf9\x68\xab\xa5\x4a\xe0\x66\xcb\
\xf3\x5e\xbb\xe7\x13\x80\xef\xd8\xb3\xfc\xa0\xa5\x7b\x17\xd0\x82\
\x94\xee\xa9\xc0\x8d\x76\xdd\xe3\x81\x1f\xa3\xed\xa4\xc6\x21\x85\
\x79\x12\xf0\x33\xfb\xff\x68\xbb\x7f\x67\x1f\xe3\x8a\xb0\x73\xa0\
\x93\x76\x83\x89\xf1\xd9\x34\xc7\x71\x1c\xc7\x71\x9c\xde\xd2\x06\
\x2c\x42\x16\xdc\x35\x3b\x49\x9b\xb3\xf4\xe5\x68\x0c\x56\x0b\x9c\
\x8d\x94\xcd\xd1\xc0\x0f\x90\xd2\xd9\x02\x1c\x8e\x14\xc0\x4e\xcb\
\x77\x16\x52\x38\x87\xda\xb1\x91\xc8\x05\xb9\x15\x59\x8c\x87\xd8\
\x35\x56\x03\x4b\x51\x04\xea\x08\x59\x6e\x8f\x41\x4a\xe9\x10\xb4\
\x2e\xb9\x90\x0e\xa4\x98\x1e\x83\x74\x9d\xe7\xed\xfa\x55\xc0\x7c\
\xcb\x7f\x18\xc9\xda\xe2\x6a\x34\x01\xf0\x22\x70\x32\x70\x99\xa5\
\x6f\xb6\xfb\x3a\xce\xf2\xfa\x1e\xb2\xf4\x1e\x69\x65\x9f\x65\x79\
\x76\x22\x85\x7e\x12\xb2\xf6\x5e\x8f\xbc\xc9\x4a\x91\x82\xdd\x06\
\x7c\x0c\x59\x92\xa7\xd9\xf3\xe8\x04\x3e\x0e\x2c\x46\xd6\x70\x67\
\x3f\xe0\x8a\xb0\xd3\x17\x09\x6b\x44\xd2\x6b\x34\x8a\xcd\xfa\x87\
\x4e\xf7\x74\xb4\x26\x65\x36\xea\xbc\xc3\x7a\x92\x9d\x45\x0f\xdc\
\x9b\x51\x06\x8b\x91\x5e\xa3\xb2\xa3\x63\xbd\x29\x57\xb1\x7c\xf6\
\x04\xbb\x52\x96\x30\x11\xb1\x37\x23\x2c\x86\xf5\x3b\x61\xfd\x50\
\xe8\xc3\x3a\x77\xe1\xfc\x3d\x39\x59\x12\xd6\x37\x15\x46\xe0\x0c\
\x96\xe3\x7d\x19\x65\x72\x4f\x3f\xf7\x3c\x6a\x83\x61\x9d\x55\x77\
\xed\xb0\xf0\xda\x31\xc9\xba\xab\x62\xef\xc5\x27\xac\x9c\xbe\x42\
\x29\xdb\xd7\xc5\xb0\x06\x71\x6f\xd0\xdb\x7e\x3a\x4b\xcf\xda\x75\
\x44\x57\x4b\x5f\xde\xee\x25\xda\x41\xfa\x1d\xf5\x19\x7b\xa2\xad\
\x06\xeb\x63\xb8\x8f\xc2\x7c\x3b\xe9\x2a\x5f\x32\x05\xe7\x15\xbb\
\x97\x9e\x3e\x0f\x67\xd7\x89\x90\xf2\xf7\x4d\x64\x05\xdd\xc4\x8e\
\xbd\x2e\x72\xc0\x0c\x64\x71\x7d\x02\x58\x01\x7c\x0b\x29\x8e\x9f\
\x47\xef\xad\x01\x59\x70\x57\x21\xa5\xb7\x0d\x29\xb0\xe1\x7d\x46\
\xa9\xbc\xb6\x5a\xda\x95\x96\xb6\x9d\x44\x79\xce\x03\x63\x80\x0f\
\x03\x4f\x21\x4b\xeb\x91\x14\xaf\xa3\x19\x60\x0e\x70\x26\x52\x54\
\x1f\x04\xae\x04\x0e\x43\x56\xd8\x53\xd1\x36\x4e\x7f\xb6\xb4\xa3\
\x80\x0d\x48\x59\x5d\x68\xf7\x34\x90\xa4\x8d\xcc\x05\xa6\x5b\x1e\
\x6f\xd2\x35\x32\x76\xb8\x87\xbc\x3d\xbb\xe7\x90\x55\x79\x80\x5d\
\x7b\x13\xf0\x4b\xfb\x7e\x01\xf0\x11\x64\x49\x0e\xd6\xe8\x0b\x90\
\x45\xf9\xdf\x90\x82\xec\xf2\x71\x1f\xe2\x8a\xb0\xd3\x17\x39\x01\
\xcd\x28\xd6\xa0\x8e\x72\x3a\xea\x54\x0a\x09\x2e\x3c\x9b\x51\x47\
\x73\x21\xb0\x0c\x75\x68\xa3\x49\x36\x70\x2f\x46\x1e\x45\x03\xce\
\xa2\xd9\xb9\xbd\xe9\x5e\x17\xdb\xbd\xdc\x02\xfc\x09\xb9\x0b\x45\
\x48\x79\x7f\x17\x5a\x57\x12\x8e\xe5\x91\x2b\x4e\x35\x70\x3f\x3d\
\xef\x10\xaf\x41\x9d\xfe\xec\x3d\x78\x2f\x31\x9a\x2d\x5d\x87\x04\
\xce\x8e\xf2\xcd\x22\x81\x33\x1f\xcd\x0c\x9f\x0f\xfc\x8e\x3d\xab\
\x98\xc7\x68\xc6\xf5\xfd\x48\x58\xce\x05\x2e\x02\x5e\x46\x82\x73\
\x67\xd7\x0a\x41\x3d\x0e\x47\x82\x6a\x77\xcb\x96\x43\x93\x30\xb7\
\x00\x3f\xb5\x67\x14\xa1\xc9\x99\xcf\xa1\x77\xf1\xa7\x3d\x78\xff\
\x3b\x7b\x36\x03\x91\x1b\xd9\xdd\x68\x4d\xd2\xee\x0a\xd3\x29\xa8\
\x4d\xd5\x20\x77\xb4\x47\x80\xb7\x8a\xe4\x9b\x47\xed\xed\x6a\xe0\
\xe7\xc8\xdd\xed\x2a\xb4\xe6\x6b\x5a\x91\x72\x8e\x45\x83\x91\xe7\
\xf7\x40\x19\x1d\xa7\xb7\x94\xa2\x01\xe9\x48\x34\x40\x0d\xee\x94\
\x2b\xd0\xfa\xc6\x3d\x3d\x20\xcd\xa0\x35\x81\x6f\x00\x0b\xe8\x59\
\x3f\x1d\x82\xf5\xdd\x8c\xfa\x92\x2d\x3b\x28\x53\x88\x6e\xfb\x57\
\x24\x01\x84\xda\x91\xf5\x6c\x1a\xdb\x2b\x8e\x79\x24\x2b\xdf\x61\
\xf7\x5b\x38\xd9\x19\x03\x23\x90\xcb\xe6\xd3\xf4\xae\xbf\x8c\x91\
\x32\x73\x1a\x92\xd1\x57\x20\x59\xd1\x0f\xa8\xb7\x6b\xde\x8e\x2c\
\x77\x21\x50\xd1\x54\x4b\xbb\x05\xf8\x04\x1a\x03\xc4\x48\x79\x7a\
\x01\x29\x5b\x67\xd8\xbb\x7a\xad\x87\xcf\xd1\xd9\x35\x42\x5b\xe8\
\x49\xc4\xe7\x08\x8d\xd1\x42\xc0\xac\x39\x68\x0c\x70\x22\x7a\x5f\
\xf3\x90\x52\x39\x15\x29\x90\x67\xa2\xfa\xd4\x4a\xd7\x77\x97\x45\
\x63\x8d\x59\x48\xee\xbc\x89\xde\xf3\x53\xa8\x0e\x64\x52\xd7\x0b\
\x13\x24\x47\xa2\x3a\x1c\x96\x4b\x44\x05\xe5\x5a\x8f\xea\x58\x7f\
\x24\xbb\xae\x42\xed\x7e\xa5\xa5\x39\x19\x8d\x03\x33\xc8\xda\xfb\
\x5b\x92\x80\x5b\x23\x51\x7b\x0a\x6d\xb5\x01\x78\xdc\xd2\xdd\x40\
\x22\xef\xc3\xb5\x32\x48\x09\x7e\xda\xee\x31\x42\x63\xd9\x95\x96\
\xdf\x35\xf6\x3c\x82\x35\x7c\xb4\x95\xe7\x39\xbb\xbf\x75\x24\x01\
\xb8\x9c\x7d\x48\x9f\x57\x84\xa3\xc8\xb4\x83\x18\x4a\x32\xaa\x1f\
\x9d\xf9\xae\xfd\x71\x36\x8a\x88\x22\x1d\xcf\x44\x10\x45\x11\xb9\
\xfc\x9e\x1b\x7f\x67\x33\x11\x71\x1c\x13\xc7\xfa\x9e\xcb\xc7\x7b\
\xdc\xec\xb6\x27\x9f\x57\x86\x88\x5c\xdc\x57\x4b\xb8\x43\xf2\x24\
\xdb\x62\xfc\x19\xcd\xca\x4d\x44\x83\x95\xef\xa2\x0e\x35\x8b\xac\
\x4d\x61\x76\x78\x19\x72\x2b\x39\x1b\x75\x42\xa3\x90\x72\x34\x12\
\x0d\x64\x66\xa0\xce\x25\xcc\x40\x87\x08\x7d\x1d\x48\x40\xa7\xd7\
\x99\x85\xd9\xc9\x18\x75\x96\xe9\x88\x84\xd9\xd4\xff\xa4\xd2\x86\
\xce\x39\x1d\xe1\x90\x82\x6b\x75\xda\xef\xe3\x49\xdc\x87\xb0\x73\
\xc7\xa2\x19\xc1\x52\x92\x19\xcf\xa1\xa8\xe3\x0e\xe9\x82\x75\x2d\
\x5d\xbe\xc2\xa8\x84\xa3\x51\x87\x9b\x8e\x82\x98\x1e\xf8\x84\xe3\
\x99\xd4\x39\xdd\xdd\x53\xb8\xff\x18\x29\x2c\x9d\x74\x1d\x04\x15\
\x3e\xcb\x10\x55\xf1\x0a\x60\xa3\xa5\x19\xc3\xf6\xd1\x20\x8b\x95\
\x3b\x1d\x0d\x12\xba\x5a\x10\xd3\x65\x6e\xb3\xf3\x27\x21\x85\xef\
\x76\xb4\x7e\x68\x15\x52\xa8\x82\xf5\x32\xa4\x8d\xba\x29\xe7\x89\
\xc0\x04\x12\x81\x54\x66\xd7\x0a\x65\xdc\x15\x82\x62\x7e\x1c\x12\
\xa6\xaf\x91\x0c\x46\x4f\x45\x03\xbd\xf4\x3b\x8c\x48\x66\x90\xd3\
\x96\xed\x20\xe4\xf3\xa9\x32\x94\x14\xa4\xed\x2e\xba\x64\x99\xfd\
\xdd\x41\xe2\xce\x16\xea\x5b\x3a\xea\x27\xa9\xb2\x84\xf7\xdd\x4e\
\xd7\x7a\x9e\xb6\xbc\x8c\x46\x6b\xa6\xee\x42\xb3\xe6\x27\xa1\x09\
\x88\xaf\xa3\x01\x41\x48\x17\xac\x33\x55\x68\xc0\x5c\x8a\x06\x31\
\x8b\x51\x90\x95\x60\x1d\x0e\xf7\x1e\xa3\xc1\xc7\x70\xe4\x82\x16\
\xea\x61\xba\xfd\xf8\x40\xc0\xd9\x1d\x42\x34\xd8\x30\x38\xee\x8e\
\x4e\x54\xbf\xb3\xa8\x2f\xc9\xa2\x7e\xa5\x03\xd5\xc5\x72\x92\xb6\
\x95\x1e\x68\x87\xf6\x12\x62\x06\xa4\xfb\xfd\xb0\x8f\x6a\xe8\x6f\
\x42\x3f\x14\xfa\xb1\x51\xa8\x8d\xe6\x0b\xd2\x16\x46\x8c\x4d\xb7\
\xf9\x52\xd4\xa7\x84\x3e\xb9\xb0\x0f\x8d\x52\xe7\xf4\xb7\x73\x7e\
\x60\xf9\x8e\x46\xd6\xb3\x65\x48\x41\x49\x7b\x5a\x81\x64\xe6\x82\
\x54\xd9\xe3\xd4\xef\x39\xd4\xdf\x9e\x86\xfa\xd8\x76\x8a\x47\xc3\
\x0d\xc7\x8a\xdd\x47\x84\x14\xa0\xf5\x68\x02\x60\x39\x92\x29\x9f\
\x40\x5b\xd1\x6c\x41\x4a\x2f\x56\xb6\x20\x73\xc2\xfd\xc4\xc0\xff\
\xda\xb5\x8f\x40\x63\x83\xb7\xed\x7e\xae\x47\xfd\xcc\x56\xbc\xcf\
\xd8\x1b\xf4\xf4\x99\x06\xa5\xf9\xe7\x48\x49\x1c\x83\xea\xc1\x1f\
\x50\xdd\xea\x44\x0a\xe6\x29\x28\xa8\xd4\x03\x68\x0d\xf0\x10\x24\
\x23\x23\x34\x71\x7b\x0f\x1a\x3f\x84\xb4\x43\x2c\xed\x0c\xfb\x1e\
\xea\xdf\x72\x64\xd1\x3d\x1a\x19\x10\xbe\x83\xea\x71\x68\x53\x69\
\xe5\x3a\x8f\x26\x86\x6b\x91\xdc\xba\xdd\x8e\x77\x20\xb9\xf6\x23\
\x34\xe6\x04\xd5\xb3\xa5\x96\xf7\xf1\x48\x9e\xfe\x18\xb5\xa7\x55\
\xc8\x60\xd1\x69\xf7\x15\xdc\x9f\xa7\xa3\x3a\xda\x8a\xc6\xac\x9b\
\xac\xcc\xab\x50\x5b\x7f\x01\x8d\x0b\x5a\xec\x1a\xe3\xd0\xb8\xf6\
\x55\x2b\x4f\xce\x9e\xd7\x22\xe0\x15\x76\xec\xbd\xe1\xec\x25\xfa\
\xb4\x22\x1c\x45\xb0\xa1\xa9\x93\xa5\x5b\xda\x99\x38\xa4\x82\x47\
\x17\xd6\x53\x51\x12\x71\xf1\x91\xb5\x64\x33\x49\x5d\x79\x6e\x59\
\x23\xab\xea\xdb\xb9\x74\x7c\x7f\xd6\x34\x74\xb0\xa2\xbe\x9d\x73\
\x8e\xe8\x47\x66\x0f\x54\xa7\x7c\x0c\xd3\x16\xd6\x33\xba\x7f\x19\
\x03\x2b\xb3\xbc\xb4\xa2\x89\x73\xc7\xf4\xa3\xa6\x2c\xd3\xe7\x94\
\xe1\x28\x82\x55\xf5\x1d\xac\x6e\xe8\xe0\xe4\x11\x55\xfb\xbb\x38\
\xbd\x21\x83\x2c\x90\xaf\xa2\xc0\x0b\x19\xe4\xaa\x12\x06\xd2\x87\
\x21\xab\xd3\x40\x54\x77\x9f\x40\x1d\xcd\x99\xa8\x03\xbe\x07\x09\
\xc5\x97\xed\xbc\x37\x49\x5c\x35\xfb\xa1\x19\xb9\x51\xa8\x53\xba\
\xcf\x7e\x3b\x01\x75\xb2\xfd\x50\x47\xf7\x3a\xb2\x66\x9e\x84\x2c\
\xb6\x6b\x51\xe7\x79\x02\x1a\xc0\xe7\x51\xa7\xfa\x00\x12\xc2\xef\
\xb5\x63\x83\x2c\xed\x1d\x56\xd6\xab\x49\xd6\x97\x3c\x64\xbf\x15\
\x73\x2f\x2e\x03\xae\x43\x03\x89\x75\x24\x11\x0a\x83\x62\x77\x09\
\xea\x94\xf3\xf6\x5c\xa6\x23\x25\xe2\x1a\x34\xe8\xd9\x68\xf7\x1d\
\xa2\x1a\x8e\x47\x56\xc1\xbb\x90\x62\x1c\x5a\xc1\x59\x24\x2e\xe4\
\x5b\x80\x3f\x22\x25\xfc\x6c\xd4\xb9\x0f\x48\x3d\xcf\x53\x80\x8b\
\x51\xe7\x3e\x12\x0d\x3a\x02\xc1\xf2\x78\x8d\xbd\x8f\x66\x7b\x16\
\x03\x90\x82\x79\xa9\xbd\xbb\x61\xc0\x87\xec\xff\x19\xf6\x0c\x86\
\xd9\x79\xb5\xa9\x72\x57\xdb\xfd\xc7\x68\xa0\x96\xb6\xec\x9e\x82\
\x94\xaa\xe0\xe2\xf4\x92\xfd\x3d\x06\x6d\xcd\x70\xa2\xbd\xe7\x17\
\xd1\xa0\x75\x2a\x1a\x98\xce\x46\xd6\xcb\x0a\x64\x81\x19\x89\x84\
\xce\x13\x24\x8a\xf0\xc9\x24\x56\xec\x32\x34\x5b\xfc\x10\xbd\x73\
\xb7\x9b\x85\x04\xfc\x40\x24\x08\x27\xdb\xb1\xa0\x68\x5f\x4a\x32\
\x09\xb2\xc0\xee\x7b\x88\xdd\x77\x05\x1a\x0c\x34\x59\xf9\x6e\xb0\
\x67\x3a\x04\x4d\xfc\xdc\x8b\x2c\xb2\x57\x23\xeb\x4c\x83\x3d\xef\
\x35\x76\x6c\x8c\x95\xe1\x41\x7b\xdf\x47\x20\xa1\x1a\xa2\x65\xae\
\xb2\x77\xb9\x15\x0d\x36\xce\xb1\x32\xd5\xa0\x81\xe9\x68\x7b\x2f\
\xf7\x23\x81\x1d\xea\x4b\x05\x52\x6e\x1b\xed\x5d\xdd\x6f\xf7\xd4\
\x62\xe5\x5e\x85\x66\xbe\x8f\x41\x83\x82\x39\x76\xbf\x93\xec\xd9\
\xae\xb4\xf7\x3e\xc2\xea\x6f\x19\x1a\xc0\x3c\x84\x26\x09\x46\x22\
\x8b\xf1\x7a\xbb\x8f\x5a\xbb\xa7\xfb\xec\x19\xfa\x60\xc0\xe9\x0d\
\x31\x6a\x13\x13\x51\x5f\xbe\x8e\xee\xeb\x52\x8c\xfa\xe5\x0e\xe4\
\x55\x94\x45\x03\xe1\x01\xa8\x5f\x1f\x89\x06\xc3\x8f\x21\x2b\xf1\
\x07\xec\x9c\xf5\xa8\xbe\x5f\x80\xda\xc8\x72\xe0\x4e\xd4\xfe\xaf\
\x44\xfd\x72\x16\xd5\xf5\x37\x2c\xdd\x99\xa8\x8d\x1f\x8e\xfa\x98\
\x01\x28\x38\xd0\x70\xd4\xa6\x1f\x44\x0a\x5e\x28\x6b\xb9\xe5\x35\
\xc1\x7e\xaf\x45\x7d\xfc\x30\xd4\xa7\x0d\xb4\x32\xff\x05\xb5\xc5\
\xb4\x35\xac\x11\x0d\xf2\x83\xe5\xe9\x7a\x24\x9f\x46\xda\x35\xfb\
\xdb\xb9\xf7\x5a\xfa\xb1\x48\x56\xde\x48\xd2\xbf\xaf\x47\x0a\xc4\
\x69\x48\xf6\x4d\x41\xfd\xd1\x3b\x49\xa2\xe1\xde\x8b\xfa\x83\x10\
\xf9\xb6\xc3\x8e\x2d\x22\x99\x00\x38\xcc\xee\xe1\x51\xbb\xff\x46\
\xbb\xff\x26\xd4\x47\x6c\x44\xfd\xfb\xc9\x48\xd6\xb5\xa1\x3e\x63\
\x95\x95\xad\xc1\xee\xa5\x8d\x24\xca\xee\x10\xa4\x98\xe7\x50\x7f\
\x3e\x0d\x0f\x62\xb8\xbf\x09\x13\x9d\xaf\xa3\x71\x0a\x24\x4a\x69\
\x70\xb5\x7e\x92\x64\x82\x27\x8b\xde\xf1\x4a\x4b\xd3\x82\xc6\x0d\
\x61\x72\x7e\x47\x69\xf3\xc8\x83\x60\x06\xdb\x5b\x81\xc3\x75\xd3\
\xe5\x9a\x9b\x3a\xfe\x7a\x41\x9a\xa5\xa8\x7e\x85\xb4\x19\x54\x7f\
\x17\x14\xe4\x1d\xa1\xfa\x17\x02\x80\xad\xb6\xef\xcb\x48\x26\xc6\
\x9e\x4a\xdd\xef\x8b\x68\x2c\x15\xa5\x8e\xbd\x86\x94\xdd\xf4\xb1\
\x57\xd1\x78\x35\x7d\xcc\xd9\xc7\xf4\x69\x97\x92\x5c\x1e\x7e\x3f\
\x63\x23\x4b\x36\xb7\xd1\xd2\x91\xe7\x3f\x9f\x5a\xcd\x3f\x3d\xb2\
\x92\x95\xf5\x1d\xb2\xfc\x02\x0d\x6d\x39\xbe\x36\x6d\x15\x5f\x9b\
\xb6\x9a\xad\xad\x39\x96\x6d\x6d\xe7\xe5\x15\x4d\x04\x9b\x6d\x14\
\xb1\x2d\x6d\x9a\x9e\x1e\xcf\xe5\x63\x7e\xf6\xf2\x7a\x5e\x58\xde\
\xc8\x8a\xfa\x76\xbe\xfd\xec\x5a\x36\xb7\x74\x6e\xb3\x54\x67\x8a\
\xe4\x13\x7e\x8b\x22\x7d\xb6\x7b\xe8\xdd\x1c\x8f\x76\x90\x57\xb1\
\xbf\xa3\x22\x79\x65\x23\x3d\xb3\x05\x1b\x5b\xf7\xc8\x44\xc0\x3e\
\xa6\x1c\x09\xd4\xe5\x24\x1d\x03\x68\x20\x32\x17\x29\x13\x0d\x68\
\xad\xc5\x6c\xa4\xf0\x1d\x8f\x84\xe3\x42\xa4\xcc\x82\x06\x29\x8f\
\x92\x58\x11\x63\xa4\x8c\x0c\x47\x2e\x60\xf3\x50\x88\xfc\x0c\x1a\
\xc8\xfc\x05\x0d\x04\xae\x44\x42\xfe\x28\x34\x88\xf9\x1d\x1a\xd8\
\x4f\x46\x03\x90\xb1\x48\xd0\xbf\x85\x06\x17\x95\x48\x10\xaf\x46\
\x7b\xe5\x1d\x63\xf9\x5e\x86\x06\x1d\xbf\x47\x1d\xea\xfb\x91\xe2\
\x51\x38\x77\x12\x93\x04\xa3\xf8\x1d\x1a\x00\x5c\x64\xc7\xf3\x96\
\xf7\x85\x48\xa1\x09\xeb\x5b\x8e\x45\xca\x52\x3d\x5a\x5f\xd2\x6c\
\xe5\xcd\xa1\x01\x47\x88\x5c\xb8\x9a\x64\x30\x52\x89\x06\x86\xd3\
\x50\x24\xc3\x23\xd0\xc0\x63\xa0\x9d\xf3\x10\xea\xb8\xdf\x89\x14\
\xa3\x1b\x91\x50\x7a\xc0\xce\x2d\x9c\xe1\xbf\x0e\x0d\xcc\x7e\x89\
\x84\xc6\x2d\x48\x48\x2c\x46\xc2\xa0\xd1\xde\xc5\xab\x48\xe9\xbb\
\xd8\xf2\xbd\xd9\xde\xdf\x6f\x2d\xaf\xeb\x2d\xdd\x29\x48\xa9\x7a\
\x31\xf5\xbe\x86\xa3\xc1\xe8\x73\xc8\x25\xf0\x34\x7b\xbe\xcf\xd9\
\xbb\xfa\xb5\xfd\xff\x24\x1a\x54\xa5\xd3\x4e\xb1\xcf\x95\x28\x58\
\xc5\x2f\x91\xb0\x1b\x63\xf5\x66\x96\x95\xf5\x4a\x7b\x97\xf7\xd8\
\xb3\x2f\xf6\x8e\x76\x46\x10\x8c\xf5\x68\x86\xba\xd6\x9e\xeb\x1c\
\x7b\x56\x83\xd1\x60\xf0\x4f\x68\x60\x79\x81\x95\xe3\x06\x34\x08\
\xfc\x3d\xc9\x24\x42\x05\x1a\x74\xbe\x69\xef\xfc\x1c\x34\x70\xbe\
\xc6\xd2\xfc\x16\x0d\x06\x6e\xb6\xf7\x39\x05\x29\x8e\xaf\xa2\xb6\
\x51\x89\x66\x9c\x2b\xac\x2c\x15\x56\x8f\x86\x5b\xbd\x1e\x64\x75\
\xea\x01\x34\x00\xb8\x0e\x4d\xac\xbc\x89\x5c\xb4\x4a\x52\xf7\xb4\
\xc4\xea\xc5\x87\x80\xff\x07\xfc\x2d\x6a\x9f\x2d\x56\x7f\x06\x93\
\x4c\x30\x8d\x26\x69\xaf\x0b\xec\xf9\x4e\x43\x83\xe5\x31\xf6\x7c\
\xc3\x3b\x1c\x8e\x94\x83\x19\xf6\x0e\x3e\x88\x06\xdd\xbf\x45\x6d\
\xf1\xda\x5d\x7c\xfe\x8e\x93\xa6\x0c\x05\x9f\xf9\x37\x34\x59\xd6\
\x13\xb7\xce\x30\x00\x0d\x9f\xab\x50\x7f\xf0\x1b\xd4\x3f\xbc\x0f\
\xf5\xff\xa7\x20\xd9\xf1\x18\xea\xa7\xb7\x20\xeb\x50\x15\x52\xce\
\x26\xa0\xbe\xe0\x17\x68\x80\x7c\x05\x72\xdd\xbc\x0a\xc9\x98\xa7\
\x50\x7b\x89\x50\x5f\x9b\x6e\xd3\xef\x43\xed\x35\x78\xf2\x4c\x41\
\x93\xb1\xbf\x47\xb2\xaf\xc2\xca\x79\x93\xfd\xfe\x1b\xd4\xf7\xdf\
\x40\x57\x83\x46\x8c\xfa\xbc\xd3\x91\x5b\xe9\xbb\xed\xdc\x95\x48\
\x0e\xd5\x5b\xf9\x5a\x50\x3f\x52\x8b\xe4\x47\x09\xea\x1b\xd6\xd9\
\x35\x27\xa0\xfe\xf6\x75\xd4\x67\xbe\x69\xe9\x3b\xed\xda\xad\x48\
\x4e\x1c\x87\xfa\xa2\x3b\x90\x0c\x3e\x3a\x55\x96\xe0\x1d\xd3\x66\
\xcf\x2a\x43\x57\x8b\x5d\x78\xde\x03\xed\xbe\x5e\xb0\xe7\x14\xee\
\x35\x78\xdc\x9c\x8e\x26\x12\xde\x85\xfa\xb8\x65\xf6\x0c\x96\x20\
\xf9\xdf\xa7\xc7\xb1\x87\x18\x61\x8f\xdd\xc2\x68\xee\xe9\x28\xef\
\xd9\xd4\xb1\x42\xd7\xe8\x9e\xa6\xcd\xa4\x7e\xcf\xb0\x7d\xdd\x2a\
\x2c\x53\xa6\xc8\xf7\xf0\x77\x36\x95\x4f\x77\x79\xa7\xaf\x1f\xca\
\x57\xac\xfc\x51\xea\x7b\x49\xc1\xb1\x4c\x0f\x8f\x39\xfb\x98\x3e\
\x6b\x11\xce\x44\x11\x6f\xae\x69\x66\xce\xfa\x56\x3e\x78\xf2\x60\
\xda\x73\x31\x83\xaa\x4a\x68\x68\xcb\xf3\xd2\x8a\x26\xc6\x0e\x2c\
\x27\x8a\x60\xd6\xda\x16\xb6\xb4\xe4\xa8\x2d\xcf\x92\xcb\xc7\x4c\
\x19\x55\xcd\xe4\xa1\x95\x64\xa3\x88\x18\xd8\xd8\xd4\x49\x5b\x67\
\xcc\xc0\xaa\x2c\x95\xa5\x19\xe2\x58\x8a\xe3\xd6\xd6\x1c\x0d\x6d\
\x39\xfa\x97\x67\xe9\x57\x91\xdd\x76\x7c\x73\x4b\x8e\xa6\xf6\x1c\
\x75\x15\x25\xf4\x2b\x57\x1d\xef\xa2\x7c\xda\x97\x88\x88\xd6\x5c\
\x9e\x8d\xcd\xf2\xe4\x1c\x50\xa9\xfc\x3b\xf3\x31\xf5\x2d\x39\xaa\
\x4a\xb3\x6c\x6e\xe9\xa4\x2c\x1b\x31\xb0\xaa\x64\xdb\xb9\x1d\xb9\
\x98\x0d\xcd\x9d\x1a\x21\x57\x95\x50\x92\x8d\x08\x5e\xcc\x9b\x9a\
\x73\x34\x77\xe4\xa9\xab\xc8\x52\x53\xae\xb2\x6e\x6e\xc9\x51\x92\
\x89\xb6\x59\xa0\x37\x37\x77\x52\x59\x9a\xa1\xb2\x34\x43\x6b\x47\
\xcc\xa6\x96\x4e\x4a\x32\x11\x83\xab\x4a\x88\x80\xe1\xb5\x65\x9c\
\x38\xa2\x8a\x3f\xbd\xb9\x99\x2f\x5f\x30\xfc\x40\x6b\x59\x39\x34\
\xb3\x56\x96\x3a\x16\x14\x39\x90\x72\x51\x83\x66\x8e\x8f\x44\x03\
\x89\x06\x24\x84\x73\x24\xf5\xb9\x9d\xae\xae\x9e\x61\xfd\xc7\x74\
\x34\xb3\xbf\xda\x8e\x5f\x8f\x66\xe9\x16\xda\x35\xcf\xb2\xf3\x5e\
\x42\x02\xbe\x1f\x12\xc4\xfd\x2c\xff\xd7\x91\xe2\x57\x0e\x9c\x6b\
\xff\xaf\x41\xb3\x7c\xab\xd1\x80\x7e\x08\x1a\x18\xd4\xa1\xc1\x4e\
\xa5\x7d\xef\xc7\xf6\x4a\x56\x84\x66\xe6\x9f\x45\x42\xfd\x15\x2b\
\xe7\x2a\x12\x37\xe0\x39\xf6\xc1\xd2\x9c\x8a\xac\xda\xc1\xda\x77\
\x9b\xdd\xdf\x59\x68\x70\xb6\x94\xc4\x45\x37\x0c\x34\x5a\xd1\x20\
\x63\x32\x52\x80\x87\x21\xab\xc0\x56\xa4\x90\x2c\x44\x03\x9c\xcb\
\x91\x92\xd3\x8a\x94\xab\x66\x92\x19\xd4\xf4\xbb\x18\x8b\x14\x9b\
\x15\x48\x09\x3d\xdf\xee\xb1\xd9\xf2\x2c\xb1\xb2\xbe\x81\x06\x35\
\x4d\xc8\xdd\xfb\x18\x3b\x7f\xa0\x7d\x82\xc5\x74\x85\xdd\x63\x58\
\x93\x17\x5c\x73\x47\xa0\xc1\x5c\x27\x1a\xb0\x0d\x4e\x5d\x73\x9d\
\xfd\xbf\xc5\x9e\xf9\xe1\x68\xc0\x94\x23\x51\xce\x8e\x04\x1e\xb6\
\x73\xd6\x58\xf9\xaf\xb2\xeb\x6c\x46\x03\xbc\x2b\xec\xf7\x37\xec\
\xbe\x7b\xd3\x64\x3a\xd0\x80\xf9\x38\x7b\x17\x5b\x90\x12\x58\x87\
\x2c\xd6\x33\xd1\x40\xae\xce\x3e\x23\xed\x1d\xfc\xc9\xde\xd7\x74\
\x64\xcd\x0e\x0a\xe8\x4c\x92\xa0\x21\x83\xad\x3e\x65\x90\xe2\x5a\
\x6d\x75\xb2\xc9\xee\xe1\xc3\x96\xc7\x53\x24\x13\x28\xe1\xff\xf4\
\x7b\x0b\x9f\xb9\x68\x30\x3f\x1a\x29\xa2\xf3\xec\x1d\x4d\xa1\x6b\
\x00\x9a\x52\x34\x99\xf4\xa4\xd5\x89\x93\xd0\x36\x15\xdf\xa0\x6b\
\x70\x9b\xc2\x6b\xb5\x58\x3d\xa8\xb7\x67\xfe\x3a\x52\x20\xfa\x5b\
\x1d\xa8\x44\x13\x25\x8d\xf6\xee\x8f\xb2\xf3\x86\xdb\xbd\xb6\x92\
\xb8\x59\x3a\xce\xae\x92\x43\x96\xd5\x25\x48\x61\xda\x55\x57\xfb\
\x52\xd4\x4f\x3d\x6c\xe7\x6f\x26\x59\x6a\xb3\x16\x4d\xf2\xac\x43\
\xed\xfd\x0a\xd4\x17\xcf\x41\x6d\xfe\x4d\xd4\x8e\x2e\x45\x6d\xb6\
\x02\xf5\x95\x6b\xed\xb7\xe0\xad\x52\x8e\xfa\xf6\x30\xa9\x58\x8d\
\xea\x7e\x25\xaa\xff\x20\x45\x74\x0e\x92\x37\x9b\xac\x0c\x55\xa8\
\x0f\x5f\x8b\x94\xc2\xfe\x96\x57\x39\xea\x0f\x20\x51\x1e\xcf\xb7\
\xef\xf5\xc8\xfd\x33\xf4\xc1\x7f\x40\x4a\xf1\x34\xe0\xd3\x96\x47\
\x70\x67\x5e\x8b\xac\x53\x2b\xed\x7b\x7f\x24\x5f\x9b\x52\x65\x5a\
\x57\x70\xed\x75\xa8\xfd\x7f\xdc\x9e\xfb\xf4\x82\xe7\x3d\xd8\x9e\
\x4d\xa1\xcb\x74\x20\xbd\xfc\xe6\x15\xbb\xde\xab\x24\xfd\xd5\x50\
\xbb\x97\xd0\x1f\xfe\x88\xc4\x1a\xb7\x19\x29\xef\xde\x5f\x38\x8e\
\xd3\x6b\xfa\xac\x22\x0c\x31\x0f\xcd\xdf\xca\xd8\x81\xe5\x0c\xac\
\x2a\x61\x75\x43\x3b\x15\x25\x19\x8e\x1b\x56\xc5\x73\x4b\x1b\xb9\
\x76\x52\x1d\x65\xd9\x88\x17\x96\x37\x71\xea\xa8\x2a\x16\x6e\x68\
\x23\x13\x45\x3c\xf9\x76\x03\xcf\x2d\x6d\xe4\xff\x4c\x1d\xc1\x1d\
\x6f\x6e\xe2\x91\x05\xf5\x74\xe4\x62\x06\x57\x97\xf0\xf9\x73\x86\
\x31\x6e\x60\x39\x0f\xce\xdf\xca\xef\x66\x6c\xa2\x3d\x97\xa7\xb2\
\x24\xc3\x5f\x9d\x3e\x84\x33\x46\xd7\x70\xef\x9c\x2d\xdc\x3e\x73\
\x13\x9d\x79\xe8\x57\x9e\xe1\x63\xa7\x0e\xe1\xe4\x91\xdb\xbb\x18\
\x67\xa2\x88\xa5\x5b\xda\xf8\xf6\xb3\x6b\x59\xdd\xd8\x41\x67\x3e\
\x66\x58\x4d\x29\x5f\x3a\x6f\x38\xe5\x25\x11\x5f\x79\x78\x05\xc3\
\x6a\x4a\x59\xbe\xa5\x9d\x86\xf6\x1c\x1f\x3c\x69\x30\xd7\x4e\xaa\
\x63\x53\x73\x27\xdf\x7b\x7e\x1d\xb3\xd7\xb5\x90\x8d\x22\x26\x0d\
\xad\xe4\x93\x67\x0e\xa5\xb6\x3c\xcb\x1d\x6f\x6e\xe2\xee\xd9\x9b\
\x01\xa8\x2a\xcd\xf2\xd7\xa7\x0f\xe1\xf4\xd1\xd5\xfc\xf7\xd3\x6b\
\x18\x33\xa0\x9c\x4f\x4c\x19\x42\x4b\x47\x9e\x7f\x9f\xbe\x9a\xab\
\x27\xd6\x31\x61\x48\x05\xdf\x7c\x66\x2d\x2b\xeb\xdb\xe9\xcc\xc7\
\x5c\x38\xae\x96\x0f\x9f\x32\x98\xf2\x28\xe2\xcc\xd1\x35\xfc\x65\
\xee\x0a\x56\x6e\x6d\xe7\xf0\xba\x32\xf6\xe0\x72\xe9\xbd\x4d\x3b\
\x1a\x68\x9c\x88\x06\xe0\x41\x29\xbe\x05\x29\x6b\x63\x91\x90\x7f\
\x9c\x44\x01\x5b\x4f\xe2\x8a\xb5\x23\xf7\x92\x36\xa4\x44\xe7\x90\
\x12\x30\x09\x0d\x4c\xc2\xfa\xcc\xe0\x72\x33\xc6\xae\xf7\x04\x52\
\x1a\x26\x90\x28\x67\xed\x05\xf9\x47\x74\x5d\xeb\x8a\x7d\x6f\x43\
\x0a\xe6\xa3\x68\x90\x33\x84\xee\x83\x9c\x94\x91\x58\x02\xaa\x49\
\xac\xd8\x20\x85\x62\x04\xc9\x0c\x64\xb0\x1e\x77\x92\x84\xeb\x3f\
\x21\x75\x5f\xbf\xb5\xf2\x5e\x41\xb2\x16\x26\x8f\x06\x71\x1f\x47\
\x56\xd7\x74\x94\xc5\x10\x80\x24\x6d\x0d\x69\xb3\xf2\x94\xd9\xf5\
\xab\x53\x65\x8d\x48\xd6\xcc\x05\x57\xbd\x2a\xd4\x8f\xa4\xd7\xe5\
\x86\xf5\xcc\xe9\xf5\xa9\x21\x72\xe4\x53\xf6\x5c\x83\x7b\x7b\x78\
\x86\x21\xff\x40\x08\x1e\x71\x9f\xbd\xeb\x91\x76\xef\x87\x17\x94\
\x37\x9c\xbf\xde\xd2\x86\x75\xe2\x1b\xed\x5d\x86\x67\x33\xce\xfe\
\x0e\xae\x57\x11\x9a\x1c\x78\xd1\x9e\xc7\xbb\xd0\x80\xf3\x15\x76\
\xdd\xc2\x10\xa1\x7a\x7b\x06\x9a\x9c\x99\x86\x06\x70\x79\xa4\x40\
\xde\x88\x5c\x8b\x17\xd8\xfb\x0a\x83\xb6\x6a\x4b\x53\x43\x32\xf3\
\x1d\xd6\x63\xa7\xd7\xf5\xb6\xa2\x01\xf4\xd3\x48\xc9\x0f\x6e\x91\
\x7f\x44\x83\xc0\xb3\x90\x42\xfc\xd3\xd4\xb3\x26\x95\xe7\x40\x92\
\xb5\xdb\xe9\xf7\x9d\xa3\xf8\x2c\x7a\x0e\x4d\xb8\x9c\x02\x7c\x1f\
\x4d\x0c\xcd\xb2\xba\x15\xa2\x77\x96\x58\xba\x3a\xba\xae\x7b\x4f\
\xaf\x57\x9c\x84\x2c\x5d\x0f\xa6\xee\x3d\xed\x6e\xd6\x69\xef\x76\
\x1a\x52\xca\x87\xb0\xf7\xa2\x8d\x3b\x87\x06\x79\xd4\x0f\xde\x8b\
\xda\xc8\xae\x4e\x6c\xe5\x51\x7b\xeb\x67\xdf\x2b\x48\xfa\xb7\x1c\
\xc9\x8e\x06\xf3\x90\x4c\x1a\x81\xac\xae\x90\x78\x46\x3c\x6d\x69\
\x4f\xb2\xbc\xaa\x49\xfa\xba\x6a\xd4\x36\x9a\x91\xa2\x1b\xda\x74\
\x98\xdc\x0a\xe5\x6d\x41\xfd\x02\xa8\x7d\x95\xda\xb5\x9b\x90\xe7\
\xcb\x0c\xd4\xf6\x82\xcc\x48\xc7\x60\x58\x0c\xfc\x37\xc9\xb2\xa0\
\xe0\xee\x0c\x5d\xfb\x9c\x74\xdc\x89\xb4\x2c\x8b\x0a\xf2\x03\xb5\
\xd5\x66\xe4\x29\xf4\x26\x49\x34\xdc\x2d\xc8\xc2\x5c\x85\x26\xf3\
\x3e\x00\xfc\x3b\x89\x42\x9f\x8e\xec\xdf\x1d\x61\xeb\x9d\x30\x01\
\x5e\x43\x22\xcb\xe7\xd9\xbd\xb4\xa7\xd2\x87\x32\xa5\xe3\x6a\x38\
\x8e\xe3\xf4\x8a\x3e\xab\x08\xb7\x74\xe4\x79\x6b\x6d\x0b\x37\x1d\
\x3f\x70\x9b\x8b\x6f\x1c\xc3\x94\xd1\xd5\xdc\xf6\xc6\x46\x56\x37\
\x74\x50\x5b\x9e\x65\xe1\xc6\x56\xce\x1d\xd3\x8f\x05\x1b\xda\x20\
\x82\xa6\xf6\x1c\x9b\x5a\x3a\x59\xdb\xd8\xc1\x6f\x67\x6c\xe4\xaf\
\xa6\x48\xc9\xfd\xc1\x0b\xeb\x78\x6e\x69\x23\x65\xd9\x0c\xdf\x7d\
\x6e\x1d\xef\x3f\x69\x10\x17\x8e\xeb\xc7\x5d\xb3\xb6\xf0\xd8\xc2\
\x7a\x2a\x4b\x32\xfc\xfc\xe5\xf5\x7c\x62\xca\x50\x4e\x18\x5e\xc9\
\x43\xf3\xb7\xf2\xed\xe7\xd6\xf2\xcd\x2b\x47\x6f\x2f\x49\x23\x98\
\xb6\xa8\x81\xb2\x92\x0c\x5f\xbf\x74\x14\xf5\x6d\x39\xbe\xf2\xf0\
\x0a\x9e\x5d\xda\xc0\x85\x47\xd6\xb2\x60\x43\x2b\x93\x86\x56\xf2\
\xa9\x33\x87\x72\xef\x9c\x2d\xfc\x76\xc6\x46\x2e\x3a\xaa\x1f\xbf\
\x79\x7d\x23\xcb\xb7\xb6\xf3\xd5\x8b\x46\x12\x45\xf0\x8d\x27\xd7\
\x70\xc7\x9b\x9b\x38\x71\x78\x15\xbf\x78\x75\x03\x5f\x38\xf7\x30\
\x8e\x1d\x56\xc9\x9f\xdf\xda\xcc\x37\x9e\x5a\xc3\x8f\xaf\x3d\x82\
\x4d\xcd\x9d\x0c\xa8\x94\xb5\x37\x8e\x63\x36\x34\x75\xd2\xda\x99\
\xe7\xf1\x45\xf5\x2c\xda\xd4\xc6\x37\x2e\x1f\xc5\xba\xc6\x4e\x7e\
\xfe\xca\x7a\x2e\x1b\xdf\x9f\xb1\x03\xca\x39\xac\x5f\x29\x25\x99\
\x88\x39\xeb\x5b\x39\x62\x40\x39\x1c\x38\x81\xb3\x22\xa4\x3c\xfe\
\x0d\x8a\x7c\xb9\x08\x29\xbf\xa3\x90\xcb\x54\xb0\x1e\xd5\x21\x17\
\xe1\x4a\x12\xb7\x96\x1d\x0d\x78\xf2\x48\xb1\xbe\x1a\xd5\xf9\x49\
\x68\x60\x9e\xb6\x22\x87\xeb\x07\x01\x9c\x41\x03\xff\xe1\x6c\x1f\
\x91\xb0\xd0\x4d\x26\x10\x06\xf1\x4f\x21\x6b\xf0\x66\xa4\xb8\x95\
\xa2\xd9\xf2\x42\x85\x23\x6c\xff\xf4\x6e\x64\x41\x38\x15\x29\x37\
\xe3\xed\x9a\x2f\xd9\xb3\xb8\xd9\xf2\xa8\x21\x19\x64\x5d\x6f\xcf\
\x63\x0a\xc9\xda\xd6\xe5\x68\x80\x74\x2b\x52\x5c\xde\x4a\x95\x31\
\xdc\x43\x88\xb2\x38\xa3\xe0\x3e\xb0\x34\xcb\xd0\x8c\xfb\xfb\x91\
\x22\x3a\x05\x29\x61\x81\x36\x64\xc1\x7e\x87\x95\x7d\x82\x3d\xcb\
\x15\x68\x20\x75\x0a\x1a\x20\x16\x3e\x97\x46\xb4\xae\xeb\x3c\x34\
\xb8\x3c\x19\x0d\x04\x17\x92\x4c\x2e\xc4\xa9\x32\x2d\x44\xca\xed\
\x54\x64\xf9\x3e\x03\xb9\xec\xa5\x9f\x79\xb8\xaf\x85\x96\xe6\x22\
\x2b\xfb\x99\x96\xf6\x69\xe4\x3d\x50\x85\x94\xb0\x99\xf6\x4e\x46\
\xda\xf3\xbe\xdc\xee\x71\x83\x1d\xaf\xa7\x77\x64\x91\x05\xa5\x15\
\x29\xdc\x3f\xb0\x7a\x93\xae\x4b\xa5\xa8\xce\xd6\xd9\xb3\x78\xc1\
\xde\xe1\x91\x56\xee\x10\x80\xaa\xf0\xb9\x85\xb5\x47\x17\xa3\x81\
\xe8\x91\xf6\x0e\x1a\x90\xeb\xe7\xcb\xa8\x7e\xaf\x23\x99\xd4\x69\
\x46\x56\x9d\xeb\x50\x14\xef\x89\x24\xeb\xa4\xd2\xcf\xae\xd0\xe5\
\x3d\x7d\xdd\x05\x68\x42\xe5\xf3\xa8\xee\x86\xf5\xe0\x0b\xd1\xa0\
\xfa\x22\x2b\xdb\xe9\x24\x01\x4f\x0a\x5d\x1e\xc3\xb1\xac\x95\x21\
\x28\xba\xf5\x68\x6d\xfa\x00\x2b\xff\xf9\x56\x97\x4e\x43\x96\xf9\
\x99\xec\xba\x02\xe3\x38\x81\x76\xd4\x77\xec\x4a\x1d\x4a\x4f\x0e\
\x4d\x47\xb2\xa2\x14\xb5\xe7\x55\xa8\x6f\x4d\xbb\x69\x5e\x84\x94\
\xca\xf9\xa8\x3d\x6f\x42\xb2\x2a\x47\xb2\x97\x68\x39\x52\xe4\x2e\
\x40\xfd\x69\x08\x3e\x75\x2f\x52\x28\xd3\x6d\xba\x1d\x79\xf2\x84\
\xfc\x5f\x40\x41\x22\xdf\x8b\x26\xd5\x42\xfb\x4b\x47\xa4\x3d\x8e\
\x64\x2d\x7e\xfa\x3e\x0a\x5d\xbd\x41\xd6\xd4\x57\x91\xac\x19\x87\
\x64\xcd\x2b\xa8\x2d\xa6\x5d\x42\x0b\x9f\x47\x3d\xea\x2f\x47\xa3\
\x7e\xff\x2c\x24\x33\x8f\x47\xb2\x22\xb2\x67\xf5\x02\xc9\xe4\x65\
\x2e\x75\xfe\x4a\x24\x43\xca\x29\xae\xcc\x66\x90\xec\x58\x8e\x94\
\xe8\xd0\xd7\x2f\x48\x95\xa3\xd8\x64\x5d\x64\xcf\x24\xc8\x1d\x5f\
\x23\xec\x38\x4e\xaf\xc8\x8e\xac\x2d\xfb\xf2\x75\x93\x07\x54\xd4\
\x94\xf5\x9d\x65\x16\x51\x04\x5b\x5a\x73\xfc\x61\xe6\x26\x2e\x3a\
\xaa\x96\x23\xea\xca\x69\x68\xcf\xf1\x97\xb9\x5b\xb8\xfa\x98\x3a\
\x16\x6f\x6a\xa7\xb2\x24\x43\x4b\x67\xcc\x82\x8d\xad\x9c\x75\x44\
\x0d\xd3\x17\x37\x70\xcd\xa4\x01\xac\xd8\xda\xc1\xdb\x9b\xdb\xb8\
\x72\x62\x1d\xb3\xd6\xb6\xf2\xe4\xdb\x0d\xac\xa8\xef\xe0\x84\xe1\
\x55\x9c\x37\xae\x1f\x0b\x37\xb6\xf2\xda\xaa\x66\xbe\x78\xde\x70\
\x86\x54\x97\x72\xc2\xf0\x4a\xa6\x8c\xae\xe1\xe9\x25\x0d\xdc\x3f\
\x6f\x2b\xad\x1d\x79\x9e\x5b\xd6\xc4\xdb\x9b\xdb\x59\xb0\xb1\x95\
\x73\xc6\xf4\xe3\xa5\xe5\x4d\x1c\x39\xa8\x9c\x61\x35\xa5\x3c\xb6\
\xb0\x9e\xab\x8f\xa9\xe3\xf0\xba\x72\x36\xb7\xe4\x78\x62\x71\x3d\
\xcf\x2c\x69\x64\xce\xba\x56\xa6\x8c\xae\x66\xdc\x40\x05\xf5\xfa\
\xc4\x94\x21\x4c\x1c\x52\x41\x2e\x86\x47\x17\xd4\x73\xc9\xd1\xb5\
\xfc\xec\xe5\x0d\x6c\x6c\xee\x64\xf1\xa6\x36\x5e\x5e\xd1\xc4\xb2\
\xad\xed\xb4\x74\xe4\xe9\xcc\xc7\xe4\x81\x4f\x9d\x39\x94\xba\xca\
\x12\xc6\x0c\x28\xe7\xce\x59\x9b\x39\x79\x64\x35\x33\x56\xb7\x30\
\xb0\xaa\x84\xb3\x8f\xa8\xa1\x23\x17\x73\xff\xbc\xad\x1c\x3b\xac\
\x92\xc3\xeb\xca\x79\x78\xfe\x56\x66\xac\x56\x30\xba\x8b\x8f\xaa\
\x65\xc2\x90\x0a\xb2\x99\x88\x92\x6c\xc4\x13\x0b\xeb\x19\x54\x5d\
\xc2\x09\xc3\xab\xfa\x94\x1e\x9c\xcb\xc3\x03\xf3\xb6\xb6\xce\x59\
\xdf\xfa\x10\xdb\x07\x32\x89\xd0\x8c\xf7\x1b\x48\xb0\xf5\x47\x82\
\xf4\x2e\xa4\x68\xbc\x4d\x12\xf5\xf2\x05\x24\x2c\x57\xb2\xf3\x48\
\x7b\x11\x12\xb0\x6b\xd1\x60\x7c\x0e\x1a\xec\x34\x23\x2b\xe3\x66\
\xa4\x4c\x6c\x42\xca\xe3\x72\xe4\xd2\xb5\x0a\x0d\x58\xd6\xd8\x67\
\x6d\x2a\xed\x46\xe4\x92\xba\xc5\xca\x90\xb3\xfc\x96\x23\x25\x74\
\x8d\x5d\x6b\x0d\x72\xb3\xab\x47\x83\x91\x25\x74\x75\xdb\xde\x80\
\x06\x14\x55\x56\xa6\x59\xf6\xfb\x6a\xa4\x74\x2c\x40\x0a\x43\x33\
\x1a\x40\xad\x41\x33\xfe\x6d\x48\xa9\x7a\x06\x0d\xa0\x5a\xad\xbc\
\x2b\xec\x3e\xda\x2d\xef\xa0\x84\x2e\xb5\x7b\x5a\x8f\x14\xab\x55\
\x96\xd7\x3a\xbb\x97\x70\xff\x8b\xec\x19\x54\xda\xb1\xe7\xec\x58\
\x03\xc9\xe0\x66\x19\x89\x1b\xf8\x42\xa4\x88\x37\x59\x99\xab\xec\
\x5a\xab\x49\x5c\xd0\xeb\xed\xbe\xdf\x44\x96\x8e\x81\x24\x16\xce\
\x56\x2b\x67\xd8\x62\x20\xbc\xaf\x36\x7b\x16\x95\x48\x71\x9e\x4e\
\x12\x90\x69\xbd\x7d\x5a\xed\xbc\x10\xbc\xa6\x12\x59\x15\x9e\xb4\
\xbf\x97\xdb\x3d\x0d\x41\xca\xd5\xd3\x76\xbf\xed\x76\x3f\x2f\xd8\
\x33\x2c\x41\x13\x30\xc1\xb3\x20\x4d\x8c\x06\x8d\x0d\x68\x50\x5b\
\xd8\x51\x76\x58\x19\x96\xa7\xca\xf1\xb6\x1d\x5f\x63\xd7\xdd\x64\
\xf7\xbc\x00\x4d\x6e\xac\xb1\x63\xcd\xa9\x7b\xc5\xde\xe5\x66\x7b\
\x6e\x79\x7b\x6f\xcb\x90\x12\x1b\x9e\xf7\x72\x2b\xeb\x2a\xbb\x97\
\xa1\x56\x07\xef\x27\x51\xe6\x57\xd8\x39\x61\x4d\xef\x53\x96\xcf\
\xa6\xd4\xb3\x0b\x83\xd6\x35\x56\x77\xd7\xdb\x79\x61\x32\xa2\x11\
\x0d\xb0\x83\xa7\xc2\x52\xab\x7f\x9b\xec\xda\x4d\xf6\x5e\x42\x3b\
\x5c\x63\xef\x71\x39\x49\x20\x9c\xa5\x76\x8d\x41\xf6\xfe\x9f\xb7\
\x74\x8b\xec\x9a\x8d\x76\xcf\x1d\x56\xc7\x67\x5a\x7d\x73\x8b\xb0\
\xb3\x23\xb2\x68\xfd\xfc\x1c\xba\x0f\x86\xb5\xab\x13\x29\x6d\xa8\
\xfe\x6f\x44\xf5\x7b\x35\xea\x2f\x97\xa1\xb6\xd5\x80\xfa\xef\x65\
\xa8\xff\x58\x82\xfa\x9a\x7e\xa8\x5e\xbf\x8c\xda\x41\x88\xa9\x10\
\xfa\xcd\xc5\xa8\x3f\xad\xb3\x3c\x9e\xb3\x73\x8b\xb5\xe9\xd0\x1f\
\x84\x25\x33\x8b\x53\x65\x78\x15\xb5\xa7\x79\x96\xcf\x20\xa4\x84\
\x4f\xa7\xab\x3c\x49\xb7\xe5\x42\x16\xd8\x35\x06\x22\x99\xf1\x24\
\x6a\x7b\x9b\x2c\x7d\x3d\x6a\xb7\x9d\xa8\xdf\x58\x61\x65\x6d\xb5\
\x74\xcf\xa2\x36\x1b\xae\xfd\xa4\xa5\xdf\x62\xf7\xb1\x0a\xc9\x82\
\xe6\x54\x79\x9a\xd0\xe4\xe8\x72\x7b\xb6\x61\xc2\x73\xb3\xdd\x4f\
\xce\xae\x37\x87\x64\xb7\x83\xe7\x90\x5c\xd9\xc4\xf6\xb2\x21\x50\
\x89\x62\x71\x4c\x63\xd7\x27\x3d\x1c\x51\x89\xda\xd1\x73\x74\x7d\
\x67\x8e\x73\x28\x50\x8d\xfa\xa6\x47\xfa\xac\x45\x38\x50\xd8\xfb\
\x55\x94\x64\x38\xe3\xf0\x6a\x9e\x59\xda\xc8\x90\xea\x12\x4e\x19\
\x59\x4d\x65\xe9\xf6\x4a\x7c\x79\x36\xc3\x67\xcf\x1e\xc6\xec\xb5\
\x2d\xbc\xbc\xb2\x89\x5f\xbd\xb6\x81\x39\xeb\x5a\x38\x7d\x74\x4d\
\x97\x80\x54\x8d\xed\x79\x66\xad\x6d\xa1\xa9\x3d\xcf\xa8\xda\x32\
\xae\x3f\x76\x00\x65\xd9\x88\x5c\x1e\x5a\x3a\xf3\x8c\xac\x2d\x25\
\x5f\xa0\x49\xe6\xf2\xf0\xab\xd7\x36\xb0\x62\x6b\x3b\xd7\x1c\x53\
\xc7\xc8\xfe\x65\xd4\xb7\xe5\xb6\x29\x9c\x21\x80\x55\x3e\x96\x31\
\xb6\xb5\x33\x4f\x67\x4e\xdf\xcf\x18\x5d\xc3\xd4\x23\x6b\xc9\xc7\
\x31\xcd\xed\x79\x06\x56\x95\xf0\xca\xca\xa6\xed\x47\xdf\x96\x57\
\x36\x4a\xf2\x8b\x81\xce\x5c\x4c\x3e\x86\x49\x43\x2b\xf8\xf7\x4b\
\x47\x31\x63\x55\x33\xaf\xae\x6a\xe6\x9e\xd9\x5b\xf8\xea\x45\x23\
\x38\x77\x4c\xbf\xed\xca\x7b\x80\x11\x21\xc1\xfa\x04\x5d\x2d\x84\
\x19\x92\xd0\xf4\x21\x5d\xd8\x82\xa6\x27\x1d\x78\x8c\x14\xb1\x37\
\x48\x2c\x89\x8b\xec\xb7\xb0\xde\xe8\x39\x3b\x3e\x83\x24\x82\x6e\
\x61\xde\x61\x0d\xe8\xd3\xf6\x3d\xed\x4a\x9b\x3e\xe7\x2d\x12\xcb\
\x56\x98\xa1\x4f\x47\x15\x04\x0d\x00\x9e\x4f\x95\x2f\xdc\x67\x7a\
\x3b\x8b\xa5\x24\x51\x0d\xc3\xb9\xed\x68\x09\x7f\x7e\x8e\x00\x00\
\x07\xf6\x49\x44\x41\x54\x50\x92\x3e\x67\x46\xea\xda\xe9\x68\x85\
\x21\xef\x59\x76\xff\x85\x96\xed\x90\x47\x70\x5b\x0e\xdb\x81\x3c\
\x5c\x70\xcf\xe9\xe7\x90\x2b\x78\x46\xe1\xf7\x79\x68\x80\x17\xca\
\x9d\x41\x03\xa8\xe7\x52\x69\xc2\xfe\xbd\xe1\x1d\xb4\xda\x33\x28\
\x9c\xd1\x8f\xec\x7d\x3f\x5c\x70\x9f\xab\xd1\x80\x2b\x93\x7a\xbe\
\xd9\x6e\xd2\x52\x50\xce\xe0\x0a\xff\x70\xea\x39\xdc\x57\xe4\x9c\
\x9e\x92\x41\x4a\xef\x62\xfb\x3e\x97\xa4\x4e\xbe\x9d\xca\x37\x7d\
\xcf\xe1\xbc\x5b\x50\x47\xbc\x00\x59\xe8\x9f\xb0\x7a\x95\xae\x4f\
\x2f\xa6\xca\xf9\x06\x5a\x6f\x9b\x7e\xde\xc5\xea\xd8\xcb\xf6\x7d\
\x23\xf2\xa2\x80\xae\xef\x3c\x44\xde\x5c\x89\x06\xba\x19\x34\x90\
\x5c\x5b\xf0\x0e\x22\xcb\xe3\x11\xba\xb6\xc3\xb0\xe6\x7c\x7a\x2a\
\x5d\xf8\xff\x69\x92\xf6\x13\xae\xf9\x52\xea\x3e\xc2\xbd\x83\xdc\
\xa5\x43\x9e\xcf\x14\xd4\x09\xc7\xd9\x97\x84\xa8\xf4\xe1\x7b\x9e\
\xae\xb2\x22\xd4\xfb\x10\xd5\x36\xc8\xa8\xd0\x36\x42\xdf\x11\x96\
\x67\x40\x57\xf9\xb4\x9e\xa4\x2d\x92\xca\xaf\x58\x9b\x4e\xb3\x98\
\xae\xde\x35\xa1\x6d\x14\x8b\x48\x1b\xae\x19\x26\xb7\x8a\xb5\xa3\
\x76\xd4\xd7\xa6\xdb\x5a\xbb\xe5\x97\x21\xe9\x3b\xa2\x54\xb9\x82\
\x97\x56\xb8\x56\xb1\x6b\x77\x17\xf9\x36\x22\x51\xfe\x4f\x25\xe9\
\x13\x1b\x91\x12\x9d\xb6\xb0\xd7\xdb\x75\xd2\xcf\x08\x92\x48\xbd\
\x69\xf2\xc8\x1a\xbe\x06\x29\xe4\x7d\xc7\x8a\xe3\x38\xce\x01\x47\
\x9f\xec\x40\xe2\x18\x6a\xca\x32\x0c\xa8\x2c\x61\x6b\x6b\x4e\x01\
\xaa\x62\xdb\x53\x26\x8e\x39\x7d\x54\x0d\xb3\xd6\xb6\xf0\xfc\xb2\
\x46\xce\x3a\xbc\x86\x38\x96\xd2\x49\x9c\x28\xce\x6b\x1b\x3b\xf8\
\xfa\xf4\xd5\x54\x97\x65\xf8\xcc\x99\xc3\xb8\x70\x5c\x2d\x8b\x37\
\xb5\x31\xba\x7f\x19\xcd\x1d\x79\x1e\x5d\xb8\x95\xb5\x0d\x1d\xfc\
\xe6\xf5\x8d\xfc\xfe\x8d\x8d\x1c\x37\xac\x52\x0a\x6b\x3e\xe6\xb8\
\xc3\xaa\xd8\xd0\xd4\xc1\x83\xf3\xb6\x92\xb1\xa0\x5b\x21\xdf\x18\
\x68\xeb\xcc\x33\x67\x7d\x2b\xc7\x0c\xad\xe4\xec\x31\xfd\x68\x6c\
\xcb\xb1\x60\x43\x2b\xad\x9d\xf1\xb6\xf2\x27\x1a\xbc\xf6\x1f\xae\
\x28\x8d\x38\x75\x54\x15\x8b\x36\xb6\x31\xaa\x7f\x29\xe3\x06\x96\
\xf3\xc4\xe2\x06\x16\x6e\x6c\xe5\xe4\x11\xd5\xcc\xdf\xd0\xca\x13\
\x8b\xea\x59\x5d\xdf\xce\x9f\xde\xda\x44\x59\x49\xc4\xe1\x75\x65\
\x1c\xd6\xaf\x94\x79\xeb\x5b\x59\xbe\xa5\x9d\x67\x97\x36\x32\x6f\
\x43\x2b\xd9\x4c\xc4\x83\xf3\xb6\xf2\x87\x37\x36\xf1\x8e\xa3\xfb\
\xf3\xb9\xb3\x87\x51\x55\x96\x61\x6d\x63\x07\x51\x04\xcd\xed\x79\
\xb6\xb6\xe6\x18\x5c\x55\xba\xbf\x5f\x65\x6f\x09\x42\xba\x30\x9a\
\x5e\x38\x1e\xa2\xf9\xed\xea\xa0\x39\x1d\xa1\x2f\xfc\x5d\x18\x09\
\xb0\x30\x5d\xb1\x88\x84\x69\x57\xe3\xc2\x08\x84\x51\x91\x3c\xd2\
\x03\x99\xc2\xc1\x4e\xb8\x9f\x74\x94\xc5\xc2\x28\x87\xc5\xdc\xbf\
\x8b\x9d\x93\xbe\x4e\x61\xdb\xee\x69\x24\xc4\xc2\xe7\xdc\xdd\x44\
\x43\x77\x11\x10\x77\x25\x9a\x62\xe1\x75\x0b\x49\xd7\x83\x74\x39\
\x8b\xdd\x73\xb1\xb4\xc5\xde\x79\x48\x97\xd9\xc1\x39\xbb\x42\x61\
\x79\x8a\x45\xb9\x4c\xdf\x73\xf8\xfd\x1e\x34\x88\xab\x41\xd1\xa4\
\xc3\x24\xcc\xae\xd4\xa7\xee\x8e\x15\xbe\xc3\xb4\xab\x64\xb1\xe7\
\xd8\xdd\x3b\xe8\xae\x1d\x52\x90\x77\x86\xed\xdb\x4f\xb1\xf7\x9d\
\x5e\x62\x90\xbe\xd7\xc2\x3a\xe1\x38\xfb\x9a\x62\xd1\x64\x8b\xf5\
\xdf\x81\xee\xfa\xa6\x62\xf2\xa9\xbb\xfe\x74\x67\x11\x63\xd3\xbf\
\xa7\xaf\x9d\xdd\xc1\x79\x3b\x9b\x4c\xda\x51\x34\xde\xee\xfa\x9e\
\xee\xda\x6a\x4f\xee\x23\x28\xcf\x73\x49\x96\x21\x15\x2b\x63\xb1\
\x67\x54\x28\x47\xd2\x79\x6e\x41\x93\xe2\x1e\x24\xcb\x71\x9c\xdd\
\xa2\xcf\x5a\x84\x2b\x4b\x33\x1c\x7f\x58\x25\xb3\xd6\x36\x73\xcd\
\x31\x75\x64\x2c\x32\x72\x49\x26\x62\x74\x5d\x19\xe3\x07\x57\x10\
\x01\xa3\xfa\x97\xd1\xd0\x96\x63\x68\x75\x09\xd9\x0c\x54\x95\x66\
\xa8\xab\xc8\x32\xb4\xa6\x84\x53\x47\x55\xf1\xfd\x17\xd6\x51\x92\
\x89\xa8\x28\x89\xf8\xc8\xa9\x72\x57\xfe\xeb\x29\x43\xb8\x6d\xe6\
\x26\x6e\x9f\xb9\x99\x7e\xe5\x19\xfe\xf6\xcc\xa1\x1c\x77\x58\x15\
\x9f\x98\x32\x84\x5f\xbf\xb6\x91\x5f\xbd\xb6\x91\x08\xf8\xc0\x49\
\x83\xa8\xab\xc8\x32\xb0\xb2\x84\xea\xd2\x0c\xa5\xd9\x88\x21\xd5\
\x25\xf4\x2b\xcf\x72\xf3\x09\x03\xf9\xdf\x57\x36\xf0\xea\xca\x26\
\x46\xd6\x96\x71\xca\xc8\x6a\x5a\x3a\xf2\x44\x11\x0c\xae\x2e\xa1\
\x34\x2b\x13\x6e\x69\x36\xc3\xd0\x9a\x12\xb2\x99\x88\x0f\x9f\x32\
\x84\x6f\x3f\xbb\x96\x2f\x3f\x24\xaf\xa5\x11\xb5\x65\x9c\x3b\xa6\
\x1f\x23\x6a\xcb\xf8\xe0\xc9\x83\xf8\xc9\x4b\xeb\x89\x22\x59\xbd\
\xff\xee\xdc\xc3\x18\x52\x55\xca\xb5\x93\x06\xf0\xf5\x27\x57\xf3\
\xb9\xfb\x97\x71\x44\x5d\x39\x93\x86\x56\x52\x9e\x8d\x38\x66\x54\
\x35\xd3\x16\x37\xf0\xf9\xfb\x97\x91\xcd\x44\x9c\x30\xbc\x92\xf3\
\xc6\xf6\x23\x06\x56\x37\xb4\xd3\x91\x8b\x99\x34\xb4\x82\xf8\xc0\
\xb6\x0e\x3b\xce\xc1\x48\x77\x16\x25\xc7\x71\x9c\x83\x8d\x10\x3c\
\x72\x4f\xf6\x71\xf3\x28\xee\xb1\xe5\x38\x8e\xb3\x4b\x44\xa7\x8d\
\xaa\xde\xf2\xeb\x1b\xc7\xf5\x1f\x56\x53\xd2\xa7\xd6\x92\x66\xa2\
\x88\x19\xab\x9b\xf9\xee\x73\x6b\xf9\x8f\xcb\x46\x51\x57\x59\xc2\
\xa6\xe6\x4e\xfa\x57\x64\x29\xcb\x46\x6c\x6e\xcd\x11\x01\x75\x15\
\x59\xda\x72\x31\x5b\x5a\x73\x0c\xaa\xd4\xf7\xd6\xce\x3c\x03\x2b\
\x75\x3f\x1b\x9a\x3b\x69\xee\xc8\x33\xa0\x22\x4b\xff\x4a\xdb\x26\
\x09\x6d\x4b\x54\xdf\x96\x63\x60\x55\x09\xb5\xe5\x19\xf2\xb6\x7d\
\xd2\xa6\xe6\x4e\x1a\xda\xf2\xf4\xaf\xc8\x52\x67\xe9\x37\x36\x77\
\x52\x51\x92\xd9\x76\xdd\x41\x95\x59\xb2\x99\x88\x0d\xcd\x9d\xb4\
\x74\xe4\x19\x5c\x55\xb2\xcd\x52\x5c\x5b\x9e\x65\x53\x4b\x8e\x3a\
\x2b\x67\x5b\x2e\x66\x4b\x4b\x27\x83\xaa\xa5\xc4\x77\xe4\x62\xd6\
\x37\x75\x92\x8f\x63\x86\x54\x97\x52\x5e\x92\x6c\x9f\xb4\x31\x94\
\xb5\x32\x4b\xbf\xf2\x64\x4b\xa7\xfa\xd6\x1c\x5b\x5a\x73\x0c\xac\
\x2c\xa1\x23\x1f\x53\x9e\x8d\xa8\x2e\xcb\xd0\xdc\x91\x67\x43\x53\
\x27\x99\x48\x0a\x7a\x59\x49\x44\x26\x8a\xf8\xc5\xab\x1b\x58\xbe\
\xa5\x9d\x7f\xb8\xb0\xef\x6d\x9f\xd4\xd6\x19\xf3\xa9\x7b\x97\x6e\
\xb9\x73\xd6\xe6\xcf\x22\xf7\x33\x57\x00\x9c\xbe\x4c\x0e\xf8\x6b\
\xe4\x8e\x7d\x2f\x6e\xb5\x74\x9c\xfd\x4d\x19\xf0\x25\xe0\xcf\x68\
\x79\x80\xcb\x10\xc7\xd9\x35\x42\x24\xf1\x2f\x01\xff\x85\xaf\xb3\
\x76\x0e\x2d\x62\x14\xd7\xe0\xe3\xc0\x17\xfa\xac\x45\x38\x1f\xc7\
\x1c\x3b\xac\x82\xf1\x43\x2a\x78\x62\x71\x03\x37\x1e\x37\x80\x21\
\xa6\xac\xc7\x68\xdf\x5e\x90\x1b\x72\x59\x36\x22\x28\xf2\xd5\x19\
\x29\x89\x41\x89\x1c\x5a\x53\x92\xec\xe9\x12\x27\x4f\x60\x40\x55\
\x96\x81\x55\xd9\xc4\xad\xda\x7e\x1f\x58\x55\xc2\xa0\xaa\xae\xe9\
\x07\x57\x97\x6c\x73\xbb\x4e\x4f\x18\x0c\xa9\x0e\xd1\x9c\xf5\x77\
\xb8\xee\xd0\x54\x39\xcb\xb2\x11\x87\xf5\x2b\xdd\xb6\x5e\xb8\x24\
\x13\x31\xb2\xb6\x74\xdb\xf5\xd2\x93\x0f\x83\x53\xf9\xc5\xa9\x32\
\xd5\x96\x67\xe9\x6f\x7b\x1d\x87\x9b\xc9\xc7\x50\x59\x92\xe1\xf0\
\xba\x32\x7b\x5e\x4a\xbf\xa6\xa1\x83\x19\xab\x9a\xf9\xc4\x94\x21\
\x64\x23\x0e\xa4\xad\x93\x1c\xc7\x71\x1c\xc7\x71\x1c\xc7\x71\xf6\
\x09\x7d\x56\x11\x06\xc8\x66\x22\x6e\x39\x69\x10\x4b\xb7\xb4\xd3\
\x99\x67\xdb\x36\x4a\xb0\xfd\x8e\x40\x69\x25\x37\x1d\x61\x2b\x8e\
\xb7\x0f\xb8\xb5\xab\xc7\xe3\xb8\xfb\xef\x5d\xd2\xc6\xdb\xa7\x81\
\xed\x95\xd1\xee\x94\xd3\x6e\xcb\x94\xce\x33\xee\xe6\xb8\x91\xcb\
\xc7\xdc\x7c\xe2\x40\x26\x0c\xa9\x70\x25\xd8\x71\x1c\xc7\x71\x1c\
\xc7\x71\x1c\xa7\x08\x7d\x5a\x11\x8e\x63\x18\xd6\xaf\x94\xc3\xfa\
\x95\x1d\xe8\x91\x90\xf7\x09\x71\x0c\xc3\x6b\x4b\x19\x59\x5b\x46\
\xce\x9f\x97\xe3\x38\x8e\xe3\x38\x8e\xe3\x38\x4e\x51\xfa\xb4\x22\
\x0c\xc1\x4a\xea\x4a\x5d\x4f\x89\x63\xc8\xf9\xf3\x72\x1c\xc7\x71\
\x1c\xc7\x71\x1c\xc7\xe9\x16\x0f\x32\xe1\x38\x8e\xe3\x38\x8e\xe3\
\x38\x8e\xe3\x1c\x52\x94\x44\x40\x36\x82\xac\xed\x97\xeb\x38\x7b\
\x8d\x08\xb2\x99\x58\xfb\x42\x6b\x5b\xe8\xdc\xfe\x2e\x92\xe3\xec\
\x84\x7c\xc1\xc7\x23\x6b\x3a\xce\xfe\x23\x46\xed\x30\xfc\xef\x32\
\xc4\x71\x76\x9d\x74\x3b\xca\xe1\xb2\xcd\x39\xb4\x08\xe3\x39\x00\
\x4a\x1a\xda\xf3\x65\xaf\xad\x6a\x66\x60\x65\xd6\x15\x61\x67\xaf\
\xd3\x91\x8b\xd9\xd0\xd4\x59\x0e\x4c\x40\x5b\xd1\xb8\x57\x82\xd3\
\x97\xc9\x03\x23\xd1\x96\x2d\x27\xe1\xf5\xd5\x71\xf6\x37\xa5\x68\
\xeb\x8b\x09\x68\x79\x97\xb7\x49\xc7\xd9\x35\x62\xa0\x16\x18\x04\
\x1c\x8b\xf6\xb5\x77\x45\xd8\x39\x54\x88\x81\x01\x40\x0d\x10\x45\
\xa5\xd9\xe8\xbe\x41\x55\x25\xed\x19\x6f\x02\xce\xbe\x20\x86\x4d\
\x2d\xb9\xf2\xd6\xce\xfc\x66\xa0\x7d\x7f\x17\xc7\x71\x7a\x40\x1d\
\xd0\x01\x34\xed\xef\x82\x38\x8e\x43\x84\xf6\x40\x6d\xc0\x65\x88\
\xe3\xf4\x96\x2c\x6a\x47\x9b\x70\xcf\x0a\xe7\xd0\xa3\x04\x8d\xe9\
\xfe\x25\x42\x96\x8e\x18\xdc\x20\xec\xec\x33\x7c\x06\xdf\x39\x50\
\x08\xbb\x77\x17\x7e\x77\x1c\xc7\x71\x1c\xc7\x71\x0e\x4c\x62\x64\
\xe4\x70\x1c\xc7\x71\x1c\xc7\x71\x1c\xc7\x71\x1c\xc7\x71\x1c\xc7\
\x71\x1c\xc7\x71\x1c\xc7\x71\x1c\xc7\x71\x1c\xc7\x71\x1c\xc7\x71\
\x1c\xc7\x71\x1c\xc7\x71\x1c\xc7\x71\x1c\xc7\x71\x1c\xc7\x71\x1c\
\xc7\x71\x1c\xc7\x71\x1c\xc7\x71\x1c\xc7\x71\x1c\xc7\x71\x1c\xc7\
\x71\x1c\xc7\x71\xf6\x3b\xff\x3f\x77\x95\x01\xd2\xdd\x18\x80\x57\
\x00\x00\x00\x25\x74\x45\x58\x74\x64\x61\x74\x65\x3a\x63\x72\x65\
\x61\x74\x65\x00\x32\x30\x31\x38\x2d\x30\x38\x2d\x32\x38\x54\x30\
\x38\x3a\x35\x34\x3a\x31\x38\x2d\x30\x34\x3a\x30\x30\xe9\x75\x8e\
\x24\x00\x00\x00\x25\x74\x45\x58\x74\x64\x61\x74\x65\x3a\x6d\x6f\
\x64\x69\x66\x79\x00\x32\x30\x31\x38\x2d\x30\x38\x2d\x32\x38\x54\
\x30\x38\x3a\x35\x34\x3a\x31\x38\x2d\x30\x34\x3a\x30\x30\x98\x28\
\x36\x98\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\x82\
"
qt_resource_name = b"\
\x00\x09\
\x06\x6a\xa2\x03\
\x00\x41\
\x00\x41\x00\x44\x00\x20\x00\x63\x00\x6c\x00\x61\x00\x73\x00\x73\
\x00\x16\
\x0b\x06\xca\x87\
\x00\x41\
\x00\x41\x00\x44\x00\x43\x00\x6c\x00\x61\x00\x73\x00\x73\x00\x5f\x00\x76\x00\x32\x00\x72\x00\x65\x00\x73\x00\x69\x00\x7a\x00\x65\
\x00\x64\x00\x2e\x00\x70\x00\x6e\x00\x67\
"
qt_resource_struct = b"\
\x00\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x01\
\x00\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x02\
\x00\x00\x00\x18\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\
"
def qInitResources():
QtCore.qRegisterResourceData(0x01, qt_resource_struct, qt_resource_name, qt_resource_data)
def qCleanupResources():
QtCore.qUnregisterResourceData(0x01, qt_resource_struct, qt_resource_name, qt_resource_data)
qInitResources() | ADMIRE-maastricht | /ADMIRE_maastricht-1.1.1.1.zip/ADMIRE_maastricht-1.1.1.1/ADMIRE_maastricht/Resource_rc5.py | Resource_rc5.py |
import sys
sys.path.append('C:\\myokit\\myokit')
import myokit
import numpy as np
from PyQt5 import QtCore, QtGui, QtWidgets
#from PyQt4 import QtCore, QtGui, uic
from os import walk
import csv
import os
from . import Qt5file
print("ADMIRE 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.")
#form_class = uic.loadUiType("ADMIRE.ui")[0] # Load the UI
model1 = 0
data1b = 1
data1 = 1
data1_ref = 1
settingValuesforAAD = 0
#class MyWindowClass(QtGui.QMainWindow, form_class):
class MyWindowClass(QtWidgets.QMainWindow, Qt5file.Ui_MainWindow):
def __init__(self, parent=None):
QtWidgets.QMainWindow.__init__(self, parent)
#QtGui.QMainWindow.__init__(self, parent)
self.setupUi(self)
self.statusBar()
self.spinAADConcentration.valueChanged.connect(self.processAADConcentration)
self.spinICaL.valueChanged.connect(self.updateSlide)
self.spinIK1.valueChanged.connect(self.updateSlide)
self.spinIKr.valueChanged.connect(self.updateSlide)
self.spinIKs.valueChanged.connect(self.updateSlide)
self.spinIf.valueChanged.connect(self.updateSlide)
self.spinINa.valueChanged.connect(self.updateSlide)
self.spinINaL.valueChanged.connect(self.updateSlide)
self.spinINaK.valueChanged.connect(self.updateSlide)
self.spinINCX.valueChanged.connect(self.updateSlide)
self.spinIto.valueChanged.connect(self.updateSlide)
self.spinAADConcentration_3.valueChanged.connect(self.processAADConcentration)
self.spinICaL_2.valueChanged.connect(self.updateSlide2)
self.spinIK1_2.valueChanged.connect(self.updateSlide2)
self.spinIKr_2.valueChanged.connect(self.updateSlide2)
self.spinIKs_2.valueChanged.connect(self.updateSlide2)
self.spinIf_2.valueChanged.connect(self.updateSlide2)
self.spinINa_2.valueChanged.connect(self.updateSlide2)
self.spinINaL_2.valueChanged.connect(self.updateSlide2)
self.spinINaK_2.valueChanged.connect(self.updateSlide2)
self.spinINCX_2.valueChanged.connect(self.updateSlide2)
self.spinIto_2.valueChanged.connect(self.updateSlide2)
self.slideICaL_2.valueChanged.connect(self.updateSpin2)
self.slideIK1_2.valueChanged.connect(self.updateSpin2)
self.slideIKr_2.valueChanged.connect(self.updateSpin2)
self.slideIKs_2.valueChanged.connect(self.updateSpin2)
self.slideIf_2.valueChanged.connect(self.updateSpin2)
self.slideINa_2.valueChanged.connect(self.updateSpin2)
self.slideINaL_2.valueChanged.connect(self.updateSpin2)
self.slideINaK_2.valueChanged.connect(self.updateSpin2)
self.slideINCX_2.valueChanged.connect(self.updateSpin2)
self.slideIto_2.valueChanged.connect(self.updateSpin2)
self.cmdRun.clicked.connect(self.startSimulation)
self.cmdReset.clicked.connect(self.resetSimulation)
#self.s1s2_button.clicked.connect(self.s1s2protocol)
self.export_1.clicked.connect(self.savecsv1)
self.resetaxes_button.clicked.connect(self.resetaxes)
self.cmbModel1.currentIndexChanged.connect(self.populateOutputBox)
self.cmbOutput1Top.currentIndexChanged.connect(self.updateOutput)
self.cmbOutput1Bottom.currentIndexChanged.connect(self.updateOutput)
self.xaxis_mdl1_from.valueChanged.connect(self.xaxis_adjustment1)
self.xaxis_mdl1_to.valueChanged.connect(self.xaxis_adjustment1)
self.ref_mdl1_top.stateChanged.connect(self.plotselection)
self.aad1_mdl1_top.stateChanged.connect(self.plotselection)
self.aad2_mdl1_top.stateChanged.connect(self.plotselection)
self.ref_mdl1_bottom.stateChanged.connect(self.plotselection)
self.aad1_mdl1_bottom.stateChanged.connect(self.plotselection)
self.aad2_mdl1_bottom.stateChanged.connect(self.plotselection)
mdldirectory = os.path.join(
os.path.dirname(os.path.abspath(__file__)), 'models')
(_, _, filenames) = next(walk(mdldirectory))
for fn in filenames:
if fn.endswith('.mmt'):
self.cmbModel1.addItem(fn[:(len(fn)-4)])
#(_, _, filenames) = walk('models/').next()
def processAADConcentration(self):
global settingValuesforAAD
if self.sender().objectName() == 'spinAADConcentration':
age = self.spinAADConcentration.value()
else:
age = self.spinAADConcentration_3.value()
blockICaL = 0
blockIK1 = 0
blockIKr = 0
blockIKs = 0
blockIf = 0
blockINa = 0
blockINaL = 0
blockINaK = 0
blockINCX = 0
blockIto = 0
def updateSlide(self):
global settingValuesforAAD
sending_spin = self.sender()
if sending_spin.objectName() == 'spinICaL':
self.slideICaL.setValue(sending_spin.value())
if sending_spin.objectName() == 'spinIK1':
self.slideIK1.setValue(sending_spin.value())
if sending_spin.objectName() == 'spinIKr':
self.slideIKr.setValue(sending_spin.value())
if sending_spin.objectName() == 'spinIKs':
self.slideIKs.setValue(sending_spin.value())
if sending_spin.objectName() == 'spinIf':
self.slideIf.setValue(sending_spin.value())
if sending_spin.objectName() == 'spinINa':
self.slideINa.setValue(sending_spin.value())
if sending_spin.objectName() == 'spinINaL':
self.slideINaL.setValue(sending_spin.value())
if sending_spin.objectName() == 'spinINaK':
self.slideINaK.setValue(sending_spin.value())
if sending_spin.objectName() == 'spinINCX':
self.slideINCX.setValue(sending_spin.value())
if sending_spin.objectName() == 'spinIto':
self.slideIto.setValue(sending_spin.value())
def updateSlide2(self):
global settingValuesforAAD
sending_spin2 = self.sender()
if sending_spin2.objectName() == 'spinICaL_2':
self.slideICaL_2.setValue(sending_spin2.value())
if sending_spin2.objectName() == 'spinIK1_2':
self.slideIK1_2.setValue(sending_spin2.value())
if sending_spin2.objectName() == 'spinIKr_2':
self.slideIKr_2.setValue(sending_spin2.value())
if sending_spin2.objectName() == 'spinIKs_2':
self.slideIKs_2.setValue(sending_spin2.value())
if sending_spin2.objectName() == 'spinIf_2':
self.slideIf_2.setValue(sending_spin2.value())
if sending_spin2.objectName() == 'spinINa_2':
self.slideINa_2.setValue(sending_spin2.value())
if sending_spin2.objectName() == 'spinINaL_2':
self.slideINaL_2.setValue(sending_spin2.value())
if sending_spin2.objectName() == 'spinINaK_2':
self.slideINaK_2.setValue(sending_spin2.value())
if sending_spin2.objectName() == 'spinINCX_2':
self.slideINCX_2.setValue(sending_spin2.value())
if sending_spin2.objectName() == 'spinIto_2':
self.slideIto_2.setValue(sending_spin2.value())
def updateSpin2(self):
global settingValuesforAAD
sending_slide2 = self.sender()
if sending_slide2.objectName() == 'slideICaL_2':
self.spinICaL_2.setValue(sending_slide2.value())
if sending_slide2.objectName() == 'slideIK1_2':
self.spinIK1_2.setValue(sending_slide2.value())
if sending_slide2.objectName() == 'slideIKr_2':
self.spinIKr_2.setValue(sending_slide2.value())
if sending_slide2.objectName() == 'slideIKs_2':
self.spinIKs_2.setValue(sending_slide2.value())
if sending_slide2.objectName() == 'slideIf_2':
self.spinIf_2.setValue(sending_slide2.value())
if sending_slide2.objectName() == 'slideINa_2':
self.spinINa_2.setValue(sending_slide2.value())
if sending_slide2.objectName() == 'slideINaL_2':
self.spinINaL_2.setValue(sending_slide2.value())
if sending_slide2.objectName() == 'slideINaK_2':
self.spinINaK_2.setValue(sending_slide2.value())
if sending_slide2.objectName() == 'slideINCX_2':
self.spinINCX_2.setValue(sending_slide2.value())
if sending_slide2.objectName() == 'slideIto_2':
self.spinIto_2.setValue(sending_slide2.value())
def populateOutputBox(self):
global model1
global data1
global data1_ref
sending_cmb = self.sender()
mdldirectory = os.path.join(os.path.dirname(os.path.abspath(__file__)), "models")
mdlname = sending_cmb.currentText() + ".mmt"
mdlpath = mdldirectory + "\\" + mdlname
#mdlname = "models/" + sending_cmb.currentText() + ".mmt"
print(mdlname)
if sending_cmb.objectName() == 'cmbModel1':
data1 = 1
#model1, p1, s1 = myokit.load(mdlname)
model1, p1, s1 = myokit.load(mdlpath)
self.cmbOutput1Top.clear()
self.cmbOutput1Bottom.clear()
#for s in model1.states():
# self.cmbOutput1Top.addItem(s.qname())
# self.cmbOutput1Bottom.addItem(s.qname())
self.startSimulation(1)
self.ref_mdl1_top.setChecked(True)
self.aad1_mdl1_top.setChecked(True)
self.aad2_mdl1_top.setChecked(True)
self.ref_mdl1_bottom.setChecked(True)
self.aad1_mdl1_bottom.setChecked(True)
self.aad2_mdl1_bottom.setChecked(True)
#print(data1.variable_info())
model_vars = data1[0].variable_info()
for items in sorted(model_vars):
self.cmbOutput1Top.addItem(items)
self.cmbOutput1Bottom.addItem(items)
ind_Vm_top = self.cmbOutput1Top.findText('output.Vm')
if ind_Vm_top >= 0:
self.cmbOutput1Top.setCurrentIndex(ind_Vm_top)
ind_Cai_bottom = self.cmbOutput1Bottom.findText('output.Cai')
if ind_Cai_bottom >= 0:
self.cmbOutput1Bottom.setCurrentIndex(ind_Cai_bottom)
def updateOutput(self):
global data1b
global data1
global data1_ref
global model1
sending_cmb = self.sender()
print("Sender = " + sending_cmb.objectName())
if sending_cmb.currentText() != "":
if sending_cmb.objectName() == 'cmbOutput1Top':
if data1 != 1:
self.mplOutput1Top.axes.clear()
#self.mplOutput1Top.axes.hold(True)
for k, item in enumerate(data1):
cur_data1_ref = data1_ref[k]
cur_data1 = data1[k]
cur_data1b = data1b[k]
if self.aad1_mdl1_top.isChecked():
self.mplOutput1Top.axes.plot(cur_data1[model1.time()],cur_data1[sending_cmb.currentText()],'-r')
if self.aad2_mdl1_top.isChecked():
self.mplOutput1Top.axes.plot(cur_data1b[model1.time()],cur_data1b[sending_cmb.currentText()],'-b')
if self.ref_mdl1_top.isChecked():
self.mplOutput1Top.axes.plot(cur_data1_ref[model1.time()],cur_data1_ref[sending_cmb.currentText()],'-k')
self.mplOutput1Top.axes.set_xlim(self.xaxis_mdl1_from.value(), self.xaxis_mdl1_to.value())
#else:
# self.mplOutput1Top.axes.plot(data1_ref[model1.time()],data1_ref[sending_cmb.currentText()],'-k')
self.mplOutput1Top.draw()
if sending_cmb.objectName() == 'cmbOutput1Bottom':
if data1 != 1:
self.mplOutput1Bottom.axes.clear()
#self.mplOutput1Bottom.axes.hold(True)
for k, item in enumerate(data1):
cur_data1_ref = data1_ref[k]
cur_data1 = data1[k]
cur_data1b = data1b[k]
if self.aad1_mdl1_bottom.isChecked():
self.mplOutput1Bottom.axes.plot(cur_data1[model1.time()],cur_data1[sending_cmb.currentText()],'-r')
if self.aad2_mdl1_bottom.isChecked():
self.mplOutput1Bottom.axes.plot(cur_data1b[model1.time()],cur_data1b[sending_cmb.currentText()],'-b')
if self.ref_mdl1_bottom.isChecked():
self.mplOutput1Bottom.axes.plot(cur_data1_ref[model1.time()],cur_data1_ref[sending_cmb.currentText()],'-k')
self.mplOutput1Bottom.axes.set_xlim(self.xaxis_mdl1_from.value(), self.xaxis_mdl1_to.value())
#self.mplOutput1Bottom.axes.plot(data1[model1.time()],data1[sending_cmb.currentText()],'-r', data1b[model1.time()],data1b[sending_cmb.currentText()],'-b', data1_ref[model1.time()],data1_ref[sending_cmb.currentText()],'-k')
#else:
# self.mplOutput1Bottom.axes.plot(data1_ref[model1.time()],data1_ref[sending_cmb.currentText()],'-k')
self.mplOutput1Bottom.draw()
def resetSimulation(self):
global settingValuesforAAD
self.slideICaL.setSliderPosition(0)
self.slideIK1.setSliderPosition(0)
self.slideIKr.setSliderPosition(0)
self.slideIKs.setSliderPosition(0)
self.slideIf.setSliderPosition(0)
self.slideINa.setSliderPosition(0)
self.slideINaL.setSliderPosition(0)
self.slideINaK.setSliderPosition(0)
self.slideINCX.setSliderPosition(0)
self.slideIto.setSliderPosition(0)
self.spinICaL.setValue(0)
self.spinIK1.setValue(0)
self.spinIKr.setValue(0)
self.spinIKs.setValue(0)
self.spinIf.setValue(0)
self.spinINa.setValue(0)
self.spinINaL.setValue(0)
self.spinINaK.setValue(0)
self.spinINCX.setValue(0)
self.spinIto.setValue(0)
self.slideICaL_2.setSliderPosition(0)
self.slideIK1_2.setSliderPosition(0)
self.slideIKr_2.setSliderPosition(0)
self.slideIKs_2.setSliderPosition(0)
self.slideIf_2.setSliderPosition(0)
self.slideINa_2.setSliderPosition(0)
self.slideINaL_2.setSliderPosition(0)
self.slideINaK_2.setSliderPosition(0)
self.slideINCX_2.setSliderPosition(0)
self.slideIto_2.setSliderPosition(0)
self.spinICaL_2.setValue(0)
self.spinIK1_2.setValue(0)
self.spinIKr_2.setValue(0)
self.spinIKs_2.setValue(0)
self.spinIf_2.setValue(0)
self.spinINa_2.setValue(0)
self.spinINaL_2.setValue(0)
self.spinINaK_2.setValue(0)
self.spinINCX_2.setValue(0)
self.spinIto_2.setValue(0)
self.txtRateModel1.setText("60")
self.spinStimDur1.setValue(1.0)
self.spinStimAmp1.setValue(50)
self.spinPrepacingModel1.setValue(100)
self.spinShowbeatsModel1.setValue(3)
self.stimamp.setValue(-120)
self.I_hyper.setValue(0.0)
self.spinCao1.setValue(2.00)
self.spinKo1.setValue(4.00)
self.spinNao1.setValue(140.00)
self.xaxis_mdl1_from.setValue(0)
self.xaxis_mdl1_to.setValue(1000)
self.spinAADConcentration.setValue(30.0)
self.spinAADConcentration_3.setValue(30.0)
self.ref_mdl1_top.setChecked(True)
self.aad1_mdl1_top.setChecked(True)
self.aad2_mdl1_top.setChecked(True)
self.ref_mdl1_bottom.setChecked(True)
self.aad1_mdl1_bottom.setChecked(True)
self.aad2_mdl1_bottom.setChecked(True)
def startSimulation(self, flag=3): # CtoF button event handler
global model1, data1, data1_ref, data1b
#global protocol1, protocol2
if flag == False:
flag = 3
print("Simulation starting... flag = " + str(flag))
progrep = MyokitProgressReporter(self.statusBar())
if flag == 1 or flag == 3:
#Extract BCLs
bcls = self.txtRateModel1.text().split(",")
data1_ref = []
data1 = []
data1b = []
self.mplOutput1Top.axes.clear()
self.mplOutput1Bottom.axes.clear()
self.lblAPDCaTModel1Ctrl.setText("")
self.lblAPDCaTModel1Alt.setText("")
self.lblAPDCaTModel1Alt_2.setText("")
for k, bcl_text in enumerate(bcls):
bcl = 1000 * 60.0 / float(bcl_text) #self.spinRateModel1.value()
stimdur = self.spinStimDur1.value()
stimamp = 0.01 * self.spinStimAmp1.value()
prebeats = self.spinPrepacingModel1.value()
showbeats = self.spinShowbeatsModel1.value()
p = myokit.Protocol()
p.schedule(stimamp,10,stimdur,bcl,0)
s = myokit.Simulation(model1, p)
s.set_constant('parameters.Ca_o', self.spinCao1.value())
s.set_constant('parameters.K_o', self.spinKo1.value())
s.set_constant('parameters.Na_o', self.spinNao1.value())
age = 30 #self.spinAADConcentration.value()
age_ncxb = -0.022731 * age + 0.841199
age_sercab = 0.005793 * age + 0.532222
age_cal_buff = -0.001973 * age + 0.283936
age_calSR_buff = -0.007122 * age + 12.466850
age_steep_ical = -0.154673 * age - 0.454007
age_V_shift_ical = 0.75 * age - 42.5
age_icalb = -0.042499 * age + 1.871332
age_ik1b = -11.67 + (11.67)/(1+10**((67.45 - age)*(-0.03752)))
age_Cm = 20 + (57.17 - 20)/(1+10**((34.14 - age)*(-0.03764)))
age_inab = 0.28 + (0.75 - 0.28)/(1+10**((55 - age)*(-0.1191)))
age_ina_act_shift = (-5.5) + ((-1) - (-5.5))/(1+10**((55 - age)*(0.1191)))
#age_ik1b = -0.2025 * age + 7.8
#age_Cm = -0.6315 * age + 60.26
age_factor_icab = 0.094065 * age + 0.841047
s.set_constant("cell.Cm", age_Cm)
s.set_constant("parameters.age_INCX_Block", age_ncxb)
s.set_constant("parameters.JsercaB", age_sercab)
s.set_constant("calcium.Buf_C", age_cal_buff)
s.set_constant("calcium.Buf_SR", age_calSR_buff)
s.set_constant("ical.steep1", age_steep_ical)
s.set_constant("parameters.age_ICaL_Block", age_icalb)
s.set_constant("parameters.age_IK1_Block", age_ik1b)
s.set_constant("ical.shift_act", age_V_shift_ical)
s.set_constant("icab.factor_icab", age_factor_icab)
s.set_constant("parameters.age_INa_Block", age_inab)
s.set_constant("ina.act_shift", age_ina_act_shift)
s.set_constant('membrane.stim_amplitude', self.stimamp.value())
s.set_constant("membrane.I_hyper", self.I_hyper.value())
progrep.msgvar = "Model 1 - Control Condition -"
s.pre(prebeats*bcl, progress=progrep)
data1_ref_temp = s.run(showbeats*bcl, progress=progrep, log=myokit.LOG_STATE+myokit.LOG_INTER+myokit.LOG_BOUND)
data1_ref.append(data1_ref_temp)
apds1_ref = data1_ref_temp.apd(v='output.Vm', threshold=0.9*np.min(data1_ref_temp['output.Vm']))
CaT_ref = np.max(data1_ref_temp['output.Cai']) - np.min(data1_ref_temp['output.Cai'])
#Syst_ref = np.max(data1_ref_temp['output.Cai'])
#Diast_ref = np.min(data1_ref_temp['output.Cai'])
dvdt_ref = np.diff(data1_ref_temp['output.Vm']) / np.diff(data1_ref_temp[model1.time()])
dvdtmax_ref = np.max(dvdt_ref)
if len(apds1_ref['duration']) > 0:
self.lblAPDCaTModel1Ctrl.setText("%s\n %.1f Hz REF - APD: %d ms // dV/dt_max: %d mV/ms // CaT: %d nM" % (self.lblAPDCaTModel1Ctrl.text(), (1000/bcl), apds1_ref['duration'][0], dvdtmax_ref, 1000*CaT_ref))
else:
self.lblAPDCaTModel1Ctrl.setText("%s\n %.1f Hz REF - APD: ? ms // dV/dt_max: ? mV/ms // CaT: ? nM" % (self.lblAPDCaTModel1Ctrl.text(), (1000/bcl)))
#mdlname = "models/" + self.cmbModel1.currentText() + ".mmt"
#print(mdlname)
#m1, p1, s1 = myokit.load(mdlname)
s = myokit.Simulation(model1, p)
s.set_constant('parameters.Ca_o', self.spinCao1.value())
s.set_constant('parameters.K_o', self.spinKo1.value())
s.set_constant('parameters.Na_o', self.spinNao1.value())
s.set_constant('parameters.ICaL_Block', self.spinICaL.value() / 100.0)
s.set_constant('parameters.IK1_Block', self.spinIK1.value() / 100.0)
s.set_constant('parameters.IKr_Block', self.spinIKr.value() / 100.0)
s.set_constant('parameters.IKs_Block', self.spinIKs.value() / 100.0)
s.set_constant('parameters.If_Block', self.spinIf.value() / 100.0)
s.set_constant('parameters.INa_Block', self.spinINa.value() / 100.0)
s.set_constant('parameters.INaL_Block', self.spinINaL.value() / 100.0)
s.set_constant('parameters.INaK_Block', self.spinINaK.value() / 100.0)
s.set_constant('parameters.INCX_Block', self.spinINCX.value() / 100.0)
s.set_constant('parameters.Ito_Block', self.spinIto.value() / 100.0)
age = self.spinAADConcentration.value()
age_ncxb = -0.022731 * age + 0.841199
age_sercab = 0.005793 * age + 0.532222
age_cal_buff = -0.001973 * age + 0.283936
age_calSR_buff = -0.007122 * age + 12.466850
age_steep_ical = -0.154673 * age - 0.454007
age_V_shift_ical = 0.75 * age - 42.5
age_icalb = -0.042499 * age + 1.871332
age_ik1b = -11.67 + (11.67)/(1+10**((67.45 - age)*(-0.03752)))
age_Cm = 20 + (57.17 - 20)/(1+10**((34.14 - age)*(-0.03764)))
age_inab = 0.28 + (0.75 - 0.28)/(1+10**((55 - age)*(-0.1191)))
age_ina_act_shift = (-5.5) + ((-1) - (-5.5))/(1+10**((55 - age)*(0.1191)))
#age_ik1b = -0.2025 * age + 7.8
#age_Cm = -0.6315 * age + 60.26
age_factor_icab = 0.094065 * age + 0.841047
s.set_constant("cell.Cm", age_Cm)
s.set_constant("parameters.age_INCX_Block", age_ncxb)
s.set_constant("parameters.JsercaB", age_sercab)
s.set_constant("calcium.Buf_C", age_cal_buff)
s.set_constant("calcium.Buf_SR", age_calSR_buff)
s.set_constant("ical.steep1", age_steep_ical)
s.set_constant("parameters.age_ICaL_Block", age_icalb)
s.set_constant("parameters.age_IK1_Block", age_ik1b)
s.set_constant("ical.shift_act", age_V_shift_ical)
s.set_constant("icab.factor_icab", age_factor_icab)
s.set_constant("parameters.age_INa_Block", age_inab)
s.set_constant("ina.act_shift", age_ina_act_shift)
s.set_constant('membrane.stim_amplitude', self.stimamp.value())
s.set_constant("membrane.I_hyper", self.I_hyper.value())
progrep.msgvar = "- Cell 1 -"
s.pre(prebeats*bcl, progress=progrep)
data1_temp = s.run(showbeats*bcl, progress=progrep, log=myokit.LOG_STATE+myokit.LOG_INTER+myokit.LOG_BOUND)
data1.append(data1_temp)
apds1_alt = data1_temp.apd(v='output.Vm', threshold=0.9*np.min(data1_temp['output.Vm']))
CaT_alt = np.max(data1_temp['output.Cai']) - np.min(data1_temp['output.Cai'])
#Syst_alt = np.max(data1_temp['output.Cai'])
#Diast_alt = np.min(data1_temp['output.Cai'])
dvdt_alt = np.diff(data1_temp['output.Vm']) / np.diff(data1_temp[model1.time()])
dvdtmax_alt = np.max(dvdt_alt)
#self.lblAPDCaTModel2Alt.setText('APD: ' + str(apds2_alt[0]) + ' ms / CaT: ' + str(CaT_alt) + ' uM')
if len(apds1_alt['duration']) > 0:
self.lblAPDCaTModel1Alt.setText("%s\n %.1f Hz Cell 1 - APD: %d ms // dV/dt_max: %d mV/ms // CaT: %d nM" % (self.lblAPDCaTModel1Alt.text(), (1000/bcl), apds1_alt['duration'][0], dvdtmax_alt, 1000*CaT_alt))
else:
self.lblAPDCaTModel1Alt.setText("%s\n %.1f Hz Cell 1 - APD: ? ms // dV/dt_max: ? mV/ms // CaT: ? nM" % (self.lblAPDCaTModel1Alt.text(), (1000/bcl)))
s = myokit.Simulation(model1, p)
s.set_constant('parameters.Ca_o', self.spinCao1.value())
s.set_constant('parameters.K_o', self.spinKo1.value())
s.set_constant('parameters.Na_o', self.spinNao1.value())
s.set_constant('parameters.ICaL_Block', self.spinICaL_2.value() / 100.0)
s.set_constant('parameters.IK1_Block', self.spinIK1_2.value() / 100.0)
s.set_constant('parameters.IKr_Block', self.spinIKr_2.value() / 100.0)
s.set_constant('parameters.IKs_Block', self.spinIKs_2.value() / 100.0)
s.set_constant('parameters.If_Block', self.spinIf_2.value() / 100.0)
s.set_constant('parameters.INa_Block', self.spinINa_2.value() / 100.0)
s.set_constant('parameters.INaL_Block', self.spinINaL_2.value() / 100.0)
s.set_constant('parameters.INaK_Block', self.spinINaK_2.value() / 100.0)
s.set_constant('parameters.INCX_Block', self.spinINCX_2.value() / 100.0)
s.set_constant('parameters.Ito_Block', self.spinIto_2.value() / 100.0)
age = self.spinAADConcentration_3.value()
age_ncxb = -0.022731 * age + 0.841199
age_sercab = 0.005793 * age + 0.532222
age_cal_buff = -0.001973 * age + 0.283936
age_calSR_buff = -0.007122 * age + 12.466850
age_steep_ical = -0.154673 * age - 0.454007
age_V_shift_ical = 0.75 * age - 42.5
age_icalb = -0.042499 * age + 1.871332
age_ik1b = -11.67 + (11.67)/(1+10**((67.45 - age)*(-0.03752)))
age_Cm = 20 + (57.17 - 20)/(1+10**((34.14 - age)*(-0.03764)))
age_inab = 0.28 + (0.75 - 0.28)/(1+10**((55 - age)*(-0.1191)))
age_ina_act_shift = (-5.5) + ((-1) - (-5.5))/(1+10**((55 - age)*(0.1191)))
#age_ik1b = -0.2025 * age + 7.8
#age_Cm = -0.6315 * age + 60.26
age_factor_icab = 0.094065 * age + 0.841047
s.set_constant("cell.Cm", age_Cm)
s.set_constant("parameters.age_INCX_Block", age_ncxb)
s.set_constant("parameters.JsercaB", age_sercab)
s.set_constant("calcium.Buf_C", age_cal_buff)
s.set_constant("calcium.Buf_SR", age_calSR_buff)
s.set_constant("ical.steep1", age_steep_ical)
s.set_constant("parameters.age_ICaL_Block", age_icalb)
s.set_constant("parameters.age_IK1_Block", age_ik1b)
s.set_constant("ical.shift_act", age_V_shift_ical)
s.set_constant("icab.factor_icab", age_factor_icab)
s.set_constant("parameters.age_INa_Block", age_inab)
s.set_constant("ina.act_shift", age_ina_act_shift)
s.set_constant('membrane.stim_amplitude', self.stimamp.value())
s.set_constant("membrane.I_hyper", self.I_hyper.value())
progrep.msgvar = "- Cell 2 -"
s.pre(prebeats*bcl, progress=progrep)
data1b_temp = s.run(showbeats*bcl, progress=progrep, log=myokit.LOG_STATE+myokit.LOG_INTER+myokit.LOG_BOUND)
data1b.append(data1b_temp)
apds1b_alt = data1b_temp.apd(v='output.Vm', threshold=0.9*np.min(data1b_temp['output.Vm']))
CaTb_alt = np.max(data1b_temp['output.Cai']) - np.min(data1b_temp['output.Cai'])
#Systb_alt = np.max(data1b_temp['output.Cai'])
#Diastb_alt = np.min(data1b_temp['output.Cai'])
dvdtb_alt = np.diff(data1b_temp['output.Vm']) / np.diff(data1b_temp[model1.time()])
dvdtmaxb_alt = np.max(dvdtb_alt)
#self.lblAPDCaTModel2Alt.setText('APD: ' + str(apds2_alt[0]) + ' ms / CaT: ' + str(CaT_alt) + ' uM')
if len(apds1b_alt['duration']) > 0:
self.lblAPDCaTModel1Alt_2.setText("%s\n %.1f Hz Cell 2 - APD: %d ms // dV/dt_max: %d mV/ms // CaT: %d nM" % (self.lblAPDCaTModel1Alt_2.text(), (1000/bcl), apds1b_alt['duration'][0], dvdtmaxb_alt, 1000*CaTb_alt))
else:
self.lblAPDCaTModel1Alt_2.setText("%s\n %.1f Hz Cell 2 - APD: ? ms // dV/dt_max: ? mV/ms // CaT: ? nM" % (self.lblAPDCaTModel1Alt_2.text(), (1000/bcl)))
if len(self.cmbOutput1Top.currentText()) > 1:
#self.mplOutput1Top.axes.hold(True)
#self.mplOutput1Bottom.axes.hold(True)
for k, item in enumerate(data1):
data1_temp = data1[k]
data1b_temp = data1b[k]
data1_ref_temp = data1_ref[k]
if self.aad1_mdl1_top.isChecked():
self.mplOutput1Top.axes.plot(data1_temp[model1.time()],data1_temp[self.cmbOutput1Top.currentText()],'-r')
if self.aad2_mdl1_top.isChecked():
self.mplOutput1Top.axes.plot(data1b_temp[model1.time()],data1b_temp[self.cmbOutput1Top.currentText()],'-b')
if self.ref_mdl1_top.isChecked():
self.mplOutput1Top.axes.plot(data1_ref_temp[model1.time()],data1_ref_temp[self.cmbOutput1Top.currentText()],'-k')
if self.aad1_mdl1_bottom.isChecked():
self.mplOutput1Bottom.axes.plot(data1_temp[model1.time()],data1_temp[self.cmbOutput1Bottom.currentText()],'-r')
if self.aad2_mdl1_bottom.isChecked():
self.mplOutput1Bottom.axes.plot(data1b_temp[model1.time()],data1b_temp[self.cmbOutput1Bottom.currentText()],'-b')
if self.ref_mdl1_bottom.isChecked():
self.mplOutput1Bottom.axes.plot(data1_ref_temp[model1.time()],data1_ref_temp[self.cmbOutput1Bottom.currentText()],'-k')
self.mplOutput1Top.axes.set_xlim(self.xaxis_mdl1_from.value(), self.xaxis_mdl1_to.value())
self.mplOutput1Bottom.axes.set_xlim(self.xaxis_mdl1_from.value(), self.xaxis_mdl1_to.value())
self.mplOutput1Top.draw()
self.mplOutput1Bottom.draw()
def plotselection(self):
global data1_ref, data1, data1b
if len(self.cmbOutput1Top.currentText()) > 1:
self.mplOutput1Top.axes.clear()
self.mplOutput1Bottom.axes.clear()
#self.mplOutput1Top.axes.hold(True)
#self.mplOutput1Bottom.axes.hold(True)
for k, item in enumerate(data1):
data1_temp = data1[k]
data1b_temp = data1b[k]
data1_ref_temp = data1_ref[k]
if self.aad1_mdl1_top.isChecked():
self.mplOutput1Top.axes.plot(data1_temp[model1.time()],data1_temp[self.cmbOutput1Top.currentText()],'-r')
if self.aad2_mdl1_top.isChecked():
self.mplOutput1Top.axes.plot(data1b_temp[model1.time()],data1b_temp[self.cmbOutput1Top.currentText()],'-b')
if self.ref_mdl1_top.isChecked():
self.mplOutput1Top.axes.plot(data1_ref_temp[model1.time()],data1_ref_temp[self.cmbOutput1Top.currentText()],'-k')
if self.aad1_mdl1_bottom.isChecked():
self.mplOutput1Bottom.axes.plot(data1_temp[model1.time()],data1_temp[self.cmbOutput1Bottom.currentText()],'-r')
if self.aad2_mdl1_bottom.isChecked():
self.mplOutput1Bottom.axes.plot(data1b_temp[model1.time()],data1b_temp[self.cmbOutput1Bottom.currentText()],'-b')
if self.ref_mdl1_bottom.isChecked():
self.mplOutput1Bottom.axes.plot(data1_ref_temp[model1.time()],data1_ref_temp[self.cmbOutput1Bottom.currentText()],'-k')
self.mplOutput1Top.axes.set_xlim(self.xaxis_mdl1_from.value(), self.xaxis_mdl1_to.value())
self.mplOutput1Bottom.axes.set_xlim(self.xaxis_mdl1_from.value(), self.xaxis_mdl1_to.value())
self.mplOutput1Top.draw()
self.mplOutput1Bottom.draw()
def xaxis_adjustment1(self):
self.mplOutput1Top.axes.set_xlim(self.xaxis_mdl1_from.value(), self.xaxis_mdl1_to.value())
self.mplOutput1Top.draw()
self.mplOutput1Bottom.axes.set_xlim(self.xaxis_mdl1_from.value(), self.xaxis_mdl1_to.value())
self.mplOutput1Bottom.draw()
def resetaxes(self):
self.xaxis_mdl1_from.setValue(0)
self.xaxis_mdl1_to.setValue(1000)
def savecsv1(self):
global model1, data1, data1_ref, data1b
export_mdl1 = QtWidgets.QFileDialog.getSaveFileName(self, 'Save File', '', "CSV (*.csv);;Text (*.txt);;All Files (*.*)")
main1 = export_mdl1[0][:-4]
ext1 = export_mdl1[0][-4:]
export_mdl1_top = ''.join(main1)+("_Top")+''.join(ext1)
with open(export_mdl1_top,'wb') as f1_top:
for k, item in enumerate(data1):
#print k
data1_temp = data1[k]
data1b_temp = data1b[k]
data1_ref_temp = data1_ref[k]
max_length = np.max([len(data1_ref_temp[model1.time()]),len(data1_temp[model1.time()]),len(data1b_temp[model1.time()])])
time1_ref_temp = np.concatenate((data1_ref_temp[model1.time()], np.zeros(max_length-len(data1_ref_temp[model1.time()])+1)))
time1_temp = np.concatenate((data1_temp[model1.time()], np.zeros(max_length-len(data1_temp[model1.time()])+1)))
time1b_temp = np.concatenate((data1b_temp[model1.time()], np.zeros(max_length-len(data1b_temp[model1.time()])+1)))
val1_ref_temp = np.concatenate((data1_ref_temp[self.cmbOutput1Top.currentText()], np.zeros(max_length-len(data1_ref_temp[self.cmbOutput1Top.currentText()])+1)))
val1_temp = np.concatenate((data1_temp[self.cmbOutput1Top.currentText()], np.zeros(max_length-len(data1_temp[self.cmbOutput1Top.currentText()])+1)))
val1b_temp = np.concatenate((data1b_temp[self.cmbOutput1Top.currentText()], np.zeros(max_length-len(data1b_temp[self.cmbOutput1Top.currentText()])+1)))
np.savetxt(f1_top, np.c_[time1_ref_temp, val1_ref_temp, time1_temp, val1_temp, time1b_temp, val1b_temp], delimiter=',', footer='\n\n')
#np.savetxt(f1_top, np.c_[data1_ref_temp[model1.time()], data1_ref_temp[self.cmbOutput1Top.currentText()], data1_temp[self.cmbOutput1Top.currentText()], data1b_temp[self.cmbOutput1Top.currentText()]], delimiter=',')
export_mdl1_bottom = ''.join(main1)+("_Bottom")+''.join(ext1)
with open(export_mdl1_bottom,'wb') as f1_bottom:
for k, item in enumerate(data1):
data1_temp = data1[k]
data1b_temp = data1b[k]
data1_ref_temp = data1_ref[k]
max_length = np.max([len(data1_ref_temp[model1.time()]),len(data1_temp[model1.time()]),len(data1b_temp[model1.time()])])
time1_ref_temp = np.concatenate((data1_ref_temp[model1.time()], np.zeros(max_length-len(data1_ref_temp[model1.time()])+1)))
time1_temp = np.concatenate((data1_temp[model1.time()], np.zeros(max_length-len(data1_temp[model1.time()])+1)))
time1b_temp = np.concatenate((data1b_temp[model1.time()], np.zeros(max_length-len(data1b_temp[model1.time()])+1)))
val1_ref_temp = np.concatenate((data1_ref_temp[self.cmbOutput1Bottom.currentText()], np.zeros(max_length-len(data1_ref_temp[self.cmbOutput1Bottom.currentText()])+1)))
val1_temp = np.concatenate((data1_temp[self.cmbOutput1Bottom.currentText()], np.zeros(max_length-len(data1_temp[self.cmbOutput1Bottom.currentText()])+1)))
val1b_temp = np.concatenate((data1b_temp[self.cmbOutput1Bottom.currentText()], np.zeros(max_length-len(data1b_temp[self.cmbOutput1Bottom.currentText()])+1)))
np.savetxt(f1_bottom, np.c_[time1_ref_temp, val1_ref_temp, time1_temp, val1_temp, time1b_temp, val1b_temp], delimiter=',', footer='\n\n')
#np.savetxt(f1_bottom, np.c_[data1_ref_temp[model1.time()], data1_ref_temp[self.cmbOutput1Bottom.currentText()], data1_temp[self.cmbOutput1Bottom.currentText()], data1b_temp[self.cmbOutput1Bottom.currentText()]], delimiter=',')
class MyokitProgressReporter(myokit.ProgressReporter):
target = None
msgvar = None
def __init__(self, tar=None):
self.target = tar
def enter(self, msg=None):
print("Starting sim...")
def exit(self):
#self.target.clearMessage()
print("Done!")
def update(self, progress):
val = progress * 100.0
#print("Progress = " + str(progress))
#self.target.setValue(int(val))
self.target.showMessage(self.msgvar + " Progress: " + str(val) + "%", 2000);
QtWidgets.QApplication.processEvents(QtCore.QEventLoop.ExcludeUserInputEvents)
#QtGui.QApplication.processEvents(QtCore.QEventLoop.ExcludeUserInputEvents)
return True
def run():
app = QtWidgets.QApplication(sys.argv)
#app = QtGui.QApplication(sys.argv)
myWindow = MyWindowClass(None)
myWindow.show()
app.exec_()
run() | ADMIRE-maastricht | /ADMIRE_maastricht-1.1.1.1.zip/ADMIRE_maastricht-1.1.1.1/ADMIRE_maastricht/ADMIRE.py | ADMIRE.py |
import sys
sys.path.append('C:\\myokit\\myokit')
import myokit
import numpy as np
from PyQt5 import QtCore, QtGui, QtWidgets
#from PyQt4 import QtCore, QtGui, uic
from os import walk
import csv
import os
from . import Qt5file
print("ADMIRE 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.")
#form_class = uic.loadUiType("ADMIRE.ui")[0] # Load the UI
model1 = 0
data1b = 1
data1 = 1
data1_ref = 1
settingValuesforAAD = 0
#class MyWindowClass(QtGui.QMainWindow, form_class):
class MyWindowClass(QtWidgets.QMainWindow, Qt5file.Ui_MainWindow):
def __init__(self, parent=None):
QtWidgets.QMainWindow.__init__(self, parent)
#QtGui.QMainWindow.__init__(self, parent)
self.setupUi(self)
self.statusBar()
self.spinAADConcentration.valueChanged.connect(self.processAADConcentration)
self.spinICaL.valueChanged.connect(self.updateSlide)
self.spinIK1.valueChanged.connect(self.updateSlide)
self.spinIKr.valueChanged.connect(self.updateSlide)
self.spinIKs.valueChanged.connect(self.updateSlide)
self.spinIf.valueChanged.connect(self.updateSlide)
self.spinINa.valueChanged.connect(self.updateSlide)
self.spinINaL.valueChanged.connect(self.updateSlide)
self.spinINaK.valueChanged.connect(self.updateSlide)
self.spinINCX.valueChanged.connect(self.updateSlide)
self.spinIto.valueChanged.connect(self.updateSlide)
self.spinAADConcentration_3.valueChanged.connect(self.processAADConcentration)
self.spinICaL_2.valueChanged.connect(self.updateSlide2)
self.spinIK1_2.valueChanged.connect(self.updateSlide2)
self.spinIKr_2.valueChanged.connect(self.updateSlide2)
self.spinIKs_2.valueChanged.connect(self.updateSlide2)
self.spinIf_2.valueChanged.connect(self.updateSlide2)
self.spinINa_2.valueChanged.connect(self.updateSlide2)
self.spinINaL_2.valueChanged.connect(self.updateSlide2)
self.spinINaK_2.valueChanged.connect(self.updateSlide2)
self.spinINCX_2.valueChanged.connect(self.updateSlide2)
self.spinIto_2.valueChanged.connect(self.updateSlide2)
self.slideICaL_2.valueChanged.connect(self.updateSpin2)
self.slideIK1_2.valueChanged.connect(self.updateSpin2)
self.slideIKr_2.valueChanged.connect(self.updateSpin2)
self.slideIKs_2.valueChanged.connect(self.updateSpin2)
self.slideIf_2.valueChanged.connect(self.updateSpin2)
self.slideINa_2.valueChanged.connect(self.updateSpin2)
self.slideINaL_2.valueChanged.connect(self.updateSpin2)
self.slideINaK_2.valueChanged.connect(self.updateSpin2)
self.slideINCX_2.valueChanged.connect(self.updateSpin2)
self.slideIto_2.valueChanged.connect(self.updateSpin2)
self.cmdRun.clicked.connect(self.startSimulation)
self.cmdReset.clicked.connect(self.resetSimulation)
#self.s1s2_button.clicked.connect(self.s1s2protocol)
self.export_1.clicked.connect(self.savecsv1)
self.resetaxes_button.clicked.connect(self.resetaxes)
self.cmbModel1.currentIndexChanged.connect(self.populateOutputBox)
self.cmbOutput1Top.currentIndexChanged.connect(self.updateOutput)
self.cmbOutput1Bottom.currentIndexChanged.connect(self.updateOutput)
self.xaxis_mdl1_from.valueChanged.connect(self.xaxis_adjustment1)
self.xaxis_mdl1_to.valueChanged.connect(self.xaxis_adjustment1)
self.ref_mdl1_top.stateChanged.connect(self.plotselection)
self.aad1_mdl1_top.stateChanged.connect(self.plotselection)
self.aad2_mdl1_top.stateChanged.connect(self.plotselection)
self.ref_mdl1_bottom.stateChanged.connect(self.plotselection)
self.aad1_mdl1_bottom.stateChanged.connect(self.plotselection)
self.aad2_mdl1_bottom.stateChanged.connect(self.plotselection)
mdldirectory = os.path.join(
os.path.dirname(os.path.abspath(__file__)), 'models')
(_, _, filenames) = next(walk(mdldirectory))
for fn in filenames:
if fn.endswith('.mmt'):
self.cmbModel1.addItem(fn[:(len(fn)-4)])
#(_, _, filenames) = walk('models/').next()
def processAADConcentration(self):
global settingValuesforAAD
if self.sender().objectName() == 'spinAADConcentration':
age = self.spinAADConcentration.value()
else:
age = self.spinAADConcentration_3.value()
blockICaL = 0
blockIK1 = 0
blockIKr = 0
blockIKs = 0
blockIf = 0
blockINa = 0
blockINaL = 0
blockINaK = 0
blockINCX = 0
blockIto = 0
def updateSlide(self):
global settingValuesforAAD
sending_spin = self.sender()
if sending_spin.objectName() == 'spinICaL':
self.slideICaL.setValue(sending_spin.value())
if sending_spin.objectName() == 'spinIK1':
self.slideIK1.setValue(sending_spin.value())
if sending_spin.objectName() == 'spinIKr':
self.slideIKr.setValue(sending_spin.value())
if sending_spin.objectName() == 'spinIKs':
self.slideIKs.setValue(sending_spin.value())
if sending_spin.objectName() == 'spinIf':
self.slideIf.setValue(sending_spin.value())
if sending_spin.objectName() == 'spinINa':
self.slideINa.setValue(sending_spin.value())
if sending_spin.objectName() == 'spinINaL':
self.slideINaL.setValue(sending_spin.value())
if sending_spin.objectName() == 'spinINaK':
self.slideINaK.setValue(sending_spin.value())
if sending_spin.objectName() == 'spinINCX':
self.slideINCX.setValue(sending_spin.value())
if sending_spin.objectName() == 'spinIto':
self.slideIto.setValue(sending_spin.value())
def updateSlide2(self):
global settingValuesforAAD
sending_spin2 = self.sender()
if sending_spin2.objectName() == 'spinICaL_2':
self.slideICaL_2.setValue(sending_spin2.value())
if sending_spin2.objectName() == 'spinIK1_2':
self.slideIK1_2.setValue(sending_spin2.value())
if sending_spin2.objectName() == 'spinIKr_2':
self.slideIKr_2.setValue(sending_spin2.value())
if sending_spin2.objectName() == 'spinIKs_2':
self.slideIKs_2.setValue(sending_spin2.value())
if sending_spin2.objectName() == 'spinIf_2':
self.slideIf_2.setValue(sending_spin2.value())
if sending_spin2.objectName() == 'spinINa_2':
self.slideINa_2.setValue(sending_spin2.value())
if sending_spin2.objectName() == 'spinINaL_2':
self.slideINaL_2.setValue(sending_spin2.value())
if sending_spin2.objectName() == 'spinINaK_2':
self.slideINaK_2.setValue(sending_spin2.value())
if sending_spin2.objectName() == 'spinINCX_2':
self.slideINCX_2.setValue(sending_spin2.value())
if sending_spin2.objectName() == 'spinIto_2':
self.slideIto_2.setValue(sending_spin2.value())
def updateSpin2(self):
global settingValuesforAAD
sending_slide2 = self.sender()
if sending_slide2.objectName() == 'slideICaL_2':
self.spinICaL_2.setValue(sending_slide2.value())
if sending_slide2.objectName() == 'slideIK1_2':
self.spinIK1_2.setValue(sending_slide2.value())
if sending_slide2.objectName() == 'slideIKr_2':
self.spinIKr_2.setValue(sending_slide2.value())
if sending_slide2.objectName() == 'slideIKs_2':
self.spinIKs_2.setValue(sending_slide2.value())
if sending_slide2.objectName() == 'slideIf_2':
self.spinIf_2.setValue(sending_slide2.value())
if sending_slide2.objectName() == 'slideINa_2':
self.spinINa_2.setValue(sending_slide2.value())
if sending_slide2.objectName() == 'slideINaL_2':
self.spinINaL_2.setValue(sending_slide2.value())
if sending_slide2.objectName() == 'slideINaK_2':
self.spinINaK_2.setValue(sending_slide2.value())
if sending_slide2.objectName() == 'slideINCX_2':
self.spinINCX_2.setValue(sending_slide2.value())
if sending_slide2.objectName() == 'slideIto_2':
self.spinIto_2.setValue(sending_slide2.value())
def populateOutputBox(self):
global model1
global data1
global data1_ref
sending_cmb = self.sender()
mdldirectory = os.path.join(os.path.dirname(os.path.abspath(__file__)), "models")
mdlname = sending_cmb.currentText() + ".mmt"
mdlpath = mdldirectory + "\\" + mdlname
#mdlname = "models/" + sending_cmb.currentText() + ".mmt"
print(mdlname)
if sending_cmb.objectName() == 'cmbModel1':
data1 = 1
#model1, p1, s1 = myokit.load(mdlname)
model1, p1, s1 = myokit.load(mdlpath)
self.cmbOutput1Top.clear()
self.cmbOutput1Bottom.clear()
#for s in model1.states():
# self.cmbOutput1Top.addItem(s.qname())
# self.cmbOutput1Bottom.addItem(s.qname())
self.startSimulation(1)
self.ref_mdl1_top.setChecked(True)
self.aad1_mdl1_top.setChecked(True)
self.aad2_mdl1_top.setChecked(True)
self.ref_mdl1_bottom.setChecked(True)
self.aad1_mdl1_bottom.setChecked(True)
self.aad2_mdl1_bottom.setChecked(True)
#print(data1.variable_info())
model_vars = data1[0].variable_info()
for items in sorted(model_vars):
self.cmbOutput1Top.addItem(items)
self.cmbOutput1Bottom.addItem(items)
ind_Vm_top = self.cmbOutput1Top.findText('output.Vm')
if ind_Vm_top >= 0:
self.cmbOutput1Top.setCurrentIndex(ind_Vm_top)
ind_Cai_bottom = self.cmbOutput1Bottom.findText('output.Cai')
if ind_Cai_bottom >= 0:
self.cmbOutput1Bottom.setCurrentIndex(ind_Cai_bottom)
def updateOutput(self):
global data1b
global data1
global data1_ref
global model1
sending_cmb = self.sender()
print("Sender = " + sending_cmb.objectName())
if sending_cmb.currentText() != "":
if sending_cmb.objectName() == 'cmbOutput1Top':
if data1 != 1:
self.mplOutput1Top.axes.clear()
#self.mplOutput1Top.axes.hold(True)
for k, item in enumerate(data1):
cur_data1_ref = data1_ref[k]
cur_data1 = data1[k]
cur_data1b = data1b[k]
if self.aad1_mdl1_top.isChecked():
self.mplOutput1Top.axes.plot(cur_data1[model1.time()],cur_data1[sending_cmb.currentText()],'-r')
if self.aad2_mdl1_top.isChecked():
self.mplOutput1Top.axes.plot(cur_data1b[model1.time()],cur_data1b[sending_cmb.currentText()],'-b')
if self.ref_mdl1_top.isChecked():
self.mplOutput1Top.axes.plot(cur_data1_ref[model1.time()],cur_data1_ref[sending_cmb.currentText()],'-k')
self.mplOutput1Top.axes.set_xlim(self.xaxis_mdl1_from.value(), self.xaxis_mdl1_to.value())
#else:
# self.mplOutput1Top.axes.plot(data1_ref[model1.time()],data1_ref[sending_cmb.currentText()],'-k')
self.mplOutput1Top.draw()
if sending_cmb.objectName() == 'cmbOutput1Bottom':
if data1 != 1:
self.mplOutput1Bottom.axes.clear()
#self.mplOutput1Bottom.axes.hold(True)
for k, item in enumerate(data1):
cur_data1_ref = data1_ref[k]
cur_data1 = data1[k]
cur_data1b = data1b[k]
if self.aad1_mdl1_bottom.isChecked():
self.mplOutput1Bottom.axes.plot(cur_data1[model1.time()],cur_data1[sending_cmb.currentText()],'-r')
if self.aad2_mdl1_bottom.isChecked():
self.mplOutput1Bottom.axes.plot(cur_data1b[model1.time()],cur_data1b[sending_cmb.currentText()],'-b')
if self.ref_mdl1_bottom.isChecked():
self.mplOutput1Bottom.axes.plot(cur_data1_ref[model1.time()],cur_data1_ref[sending_cmb.currentText()],'-k')
self.mplOutput1Bottom.axes.set_xlim(self.xaxis_mdl1_from.value(), self.xaxis_mdl1_to.value())
#self.mplOutput1Bottom.axes.plot(data1[model1.time()],data1[sending_cmb.currentText()],'-r', data1b[model1.time()],data1b[sending_cmb.currentText()],'-b', data1_ref[model1.time()],data1_ref[sending_cmb.currentText()],'-k')
#else:
# self.mplOutput1Bottom.axes.plot(data1_ref[model1.time()],data1_ref[sending_cmb.currentText()],'-k')
self.mplOutput1Bottom.draw()
def resetSimulation(self):
global settingValuesforAAD
self.slideICaL.setSliderPosition(0)
self.slideIK1.setSliderPosition(0)
self.slideIKr.setSliderPosition(0)
self.slideIKs.setSliderPosition(0)
self.slideIf.setSliderPosition(0)
self.slideINa.setSliderPosition(0)
self.slideINaL.setSliderPosition(0)
self.slideINaK.setSliderPosition(0)
self.slideINCX.setSliderPosition(0)
self.slideIto.setSliderPosition(0)
self.spinICaL.setValue(0)
self.spinIK1.setValue(0)
self.spinIKr.setValue(0)
self.spinIKs.setValue(0)
self.spinIf.setValue(0)
self.spinINa.setValue(0)
self.spinINaL.setValue(0)
self.spinINaK.setValue(0)
self.spinINCX.setValue(0)
self.spinIto.setValue(0)
self.slideICaL_2.setSliderPosition(0)
self.slideIK1_2.setSliderPosition(0)
self.slideIKr_2.setSliderPosition(0)
self.slideIKs_2.setSliderPosition(0)
self.slideIf_2.setSliderPosition(0)
self.slideINa_2.setSliderPosition(0)
self.slideINaL_2.setSliderPosition(0)
self.slideINaK_2.setSliderPosition(0)
self.slideINCX_2.setSliderPosition(0)
self.slideIto_2.setSliderPosition(0)
self.spinICaL_2.setValue(0)
self.spinIK1_2.setValue(0)
self.spinIKr_2.setValue(0)
self.spinIKs_2.setValue(0)
self.spinIf_2.setValue(0)
self.spinINa_2.setValue(0)
self.spinINaL_2.setValue(0)
self.spinINaK_2.setValue(0)
self.spinINCX_2.setValue(0)
self.spinIto_2.setValue(0)
self.txtRateModel1.setText("60")
self.spinStimDur1.setValue(1.0)
self.spinStimAmp1.setValue(50)
self.spinPrepacingModel1.setValue(100)
self.spinShowbeatsModel1.setValue(3)
self.stimamp.setValue(-120)
self.I_hyper.setValue(0.0)
self.spinCao1.setValue(2.00)
self.spinKo1.setValue(4.00)
self.spinNao1.setValue(140.00)
self.xaxis_mdl1_from.setValue(0)
self.xaxis_mdl1_to.setValue(1000)
self.spinAADConcentration.setValue(30.0)
self.spinAADConcentration_3.setValue(30.0)
self.ref_mdl1_top.setChecked(True)
self.aad1_mdl1_top.setChecked(True)
self.aad2_mdl1_top.setChecked(True)
self.ref_mdl1_bottom.setChecked(True)
self.aad1_mdl1_bottom.setChecked(True)
self.aad2_mdl1_bottom.setChecked(True)
def startSimulation(self, flag=3): # CtoF button event handler
global model1, data1, data1_ref, data1b
#global protocol1, protocol2
if flag == False:
flag = 3
print("Simulation starting... flag = " + str(flag))
progrep = MyokitProgressReporter(self.statusBar())
if flag == 1 or flag == 3:
#Extract BCLs
bcls = self.txtRateModel1.text().split(",")
data1_ref = []
data1 = []
data1b = []
self.mplOutput1Top.axes.clear()
self.mplOutput1Bottom.axes.clear()
self.lblAPDCaTModel1Ctrl.setText("")
self.lblAPDCaTModel1Alt.setText("")
self.lblAPDCaTModel1Alt_2.setText("")
for k, bcl_text in enumerate(bcls):
bcl = 1000 * 60.0 / float(bcl_text) #self.spinRateModel1.value()
stimdur = self.spinStimDur1.value()
stimamp = 0.01 * self.spinStimAmp1.value()
prebeats = self.spinPrepacingModel1.value()
showbeats = self.spinShowbeatsModel1.value()
p = myokit.Protocol()
p.schedule(stimamp,10,stimdur,bcl,0)
s = myokit.Simulation(model1, p)
s.set_constant('parameters.Ca_o', self.spinCao1.value())
s.set_constant('parameters.K_o', self.spinKo1.value())
s.set_constant('parameters.Na_o', self.spinNao1.value())
age = 30 #self.spinAADConcentration.value()
age_ncxb = -0.022731 * age + 0.841199
age_sercab = 0.005793 * age + 0.532222
age_cal_buff = -0.001973 * age + 0.283936
age_calSR_buff = -0.007122 * age + 12.466850
age_steep_ical = -0.154673 * age - 0.454007
age_V_shift_ical = 0.75 * age - 42.5
age_icalb = -0.042499 * age + 1.871332
age_ik1b = -11.67 + (11.67)/(1+10**((67.45 - age)*(-0.03752)))
age_Cm = 20 + (57.17 - 20)/(1+10**((34.14 - age)*(-0.03764)))
#age_ik1b = -0.2025 * age + 7.8
#age_Cm = -0.6315 * age + 60.26
age_factor_icab = 0.094065 * age + 0.841047
s.set_constant("cell.Cm", age_Cm)
s.set_constant("parameters.age_INCX_Block", age_ncxb)
s.set_constant("parameters.JsercaB", age_sercab)
s.set_constant("calcium.Buf_C", age_cal_buff)
s.set_constant("calcium.Buf_SR", age_calSR_buff)
s.set_constant("ical.steep1", age_steep_ical)
s.set_constant("parameters.age_ICaL_Block", age_icalb)
s.set_constant("parameters.age_IK1_Block", age_ik1b)
s.set_constant("ical.shift_act", age_V_shift_ical)
s.set_constant("icab.factor_icab", age_factor_icab)
s.set_constant('membrane.stim_amplitude', self.stimamp.value())
s.set_constant("membrane.I_hyper", self.I_hyper.value())
progrep.msgvar = "Model 1 - Control Condition -"
s.pre(prebeats*bcl, progress=progrep)
data1_ref_temp = s.run(showbeats*bcl, progress=progrep, log=myokit.LOG_STATE+myokit.LOG_INTER+myokit.LOG_BOUND)
data1_ref.append(data1_ref_temp)
apds1_ref = data1_ref_temp.apd(v='output.Vm', threshold=0.9*np.min(data1_ref_temp['output.Vm']))
CaT_ref = np.max(data1_ref_temp['output.Cai']) - np.min(data1_ref_temp['output.Cai'])
#Syst_ref = np.max(data1_ref_temp['output.Cai'])
#Diast_ref = np.min(data1_ref_temp['output.Cai'])
dvdt_ref = np.diff(data1_ref_temp['output.Vm']) / np.diff(data1_ref_temp[model1.time()])
dvdtmax_ref = np.max(dvdt_ref)
if len(apds1_ref['duration']) > 0:
self.lblAPDCaTModel1Ctrl.setText("%s\n %.1f Hz REF - APD: %d ms // dV/dt_max: %d mV/ms // CaT: %d nM" % (self.lblAPDCaTModel1Ctrl.text(), (1000/bcl), apds1_ref['duration'][0], dvdtmax_ref, 1000*CaT_ref))
else:
self.lblAPDCaTModel1Ctrl.setText("%s\n %.1f Hz REF - APD: ? ms // dV/dt_max: ? mV/ms // CaT: ? nM" % (self.lblAPDCaTModel1Ctrl.text(), (1000/bcl)))
#mdlname = "models/" + self.cmbModel1.currentText() + ".mmt"
#print(mdlname)
#m1, p1, s1 = myokit.load(mdlname)
s = myokit.Simulation(model1, p)
s.set_constant('parameters.Ca_o', self.spinCao1.value())
s.set_constant('parameters.K_o', self.spinKo1.value())
s.set_constant('parameters.Na_o', self.spinNao1.value())
s.set_constant('parameters.ICaL_Block', self.spinICaL.value() / 100.0)
s.set_constant('parameters.IK1_Block', self.spinIK1.value() / 100.0)
s.set_constant('parameters.IKr_Block', self.spinIKr.value() / 100.0)
s.set_constant('parameters.IKs_Block', self.spinIKs.value() / 100.0)
s.set_constant('parameters.If_Block', self.spinIf.value() / 100.0)
s.set_constant('parameters.INa_Block', self.spinINa.value() / 100.0)
s.set_constant('parameters.INaL_Block', self.spinINaL.value() / 100.0)
s.set_constant('parameters.INaK_Block', self.spinINaK.value() / 100.0)
s.set_constant('parameters.INCX_Block', self.spinINCX.value() / 100.0)
s.set_constant('parameters.Ito_Block', self.spinIto.value() / 100.0)
age = self.spinAADConcentration.value()
age_ncxb = -0.022731 * age + 0.841199
age_sercab = 0.005793 * age + 0.532222
age_cal_buff = -0.001973 * age + 0.283936
age_calSR_buff = -0.007122 * age + 12.466850
age_steep_ical = -0.154673 * age - 0.454007
age_V_shift_ical = 0.75 * age - 42.5
age_icalb = -0.042499 * age + 1.871332
age_ik1b = -11.67 + (11.67)/(1+10**((67.45 - age)*(-0.03752)))
age_Cm = 20 + (57.17 - 20)/(1+10**((34.14 - age)*(-0.03764)))
#age_ik1b = -0.2025 * age + 7.8
#age_Cm = -0.6315 * age + 60.26
age_factor_icab = 0.094065 * age + 0.841047
s.set_constant("cell.Cm", age_Cm)
s.set_constant("parameters.age_INCX_Block", age_ncxb)
s.set_constant("parameters.JsercaB", age_sercab)
s.set_constant("calcium.Buf_C", age_cal_buff)
s.set_constant("calcium.Buf_SR", age_calSR_buff)
s.set_constant("ical.steep1", age_steep_ical)
s.set_constant("parameters.age_ICaL_Block", age_icalb)
s.set_constant("parameters.age_IK1_Block", age_ik1b)
s.set_constant("ical.shift_act", age_V_shift_ical)
s.set_constant("icab.factor_icab", age_factor_icab)
s.set_constant('membrane.stim_amplitude', self.stimamp.value())
s.set_constant("membrane.I_hyper", self.I_hyper.value())
progrep.msgvar = "- Cell 1 -"
s.pre(prebeats*bcl, progress=progrep)
data1_temp = s.run(showbeats*bcl, progress=progrep, log=myokit.LOG_STATE+myokit.LOG_INTER+myokit.LOG_BOUND)
data1.append(data1_temp)
apds1_alt = data1_temp.apd(v='output.Vm', threshold=0.9*np.min(data1_temp['output.Vm']))
CaT_alt = np.max(data1_temp['output.Cai']) - np.min(data1_temp['output.Cai'])
#Syst_alt = np.max(data1_temp['output.Cai'])
#Diast_alt = np.min(data1_temp['output.Cai'])
dvdt_alt = np.diff(data1_temp['output.Vm']) / np.diff(data1_temp[model1.time()])
dvdtmax_alt = np.max(dvdt_alt)
#self.lblAPDCaTModel2Alt.setText('APD: ' + str(apds2_alt[0]) + ' ms / CaT: ' + str(CaT_alt) + ' uM')
if len(apds1_alt['duration']) > 0:
self.lblAPDCaTModel1Alt.setText("%s\n %.1f Hz Cell 1 - APD: %d ms // dV/dt_max: %d mV/ms // CaT: %d nM" % (self.lblAPDCaTModel1Alt.text(), (1000/bcl), apds1_alt['duration'][0], dvdtmax_alt, 1000*CaT_alt))
else:
self.lblAPDCaTModel1Alt.setText("%s\n %.1f Hz Cell 1 - APD: ? ms // dV/dt_max: ? mV/ms // CaT: ? nM" % (self.lblAPDCaTModel1Alt.text(), (1000/bcl)))
s = myokit.Simulation(model1, p)
s.set_constant('parameters.Ca_o', self.spinCao1.value())
s.set_constant('parameters.K_o', self.spinKo1.value())
s.set_constant('parameters.Na_o', self.spinNao1.value())
s.set_constant('parameters.ICaL_Block', self.spinICaL_2.value() / 100.0)
s.set_constant('parameters.IK1_Block', self.spinIK1_2.value() / 100.0)
s.set_constant('parameters.IKr_Block', self.spinIKr_2.value() / 100.0)
s.set_constant('parameters.IKs_Block', self.spinIKs_2.value() / 100.0)
s.set_constant('parameters.If_Block', self.spinIf_2.value() / 100.0)
s.set_constant('parameters.INa_Block', self.spinINa_2.value() / 100.0)
s.set_constant('parameters.INaL_Block', self.spinINaL_2.value() / 100.0)
s.set_constant('parameters.INaK_Block', self.spinINaK_2.value() / 100.0)
s.set_constant('parameters.INCX_Block', self.spinINCX_2.value() / 100.0)
s.set_constant('parameters.Ito_Block', self.spinIto_2.value() / 100.0)
age = self.spinAADConcentration_3.value()
age_ncxb = -0.022731 * age + 0.841199
age_sercab = 0.005793 * age + 0.532222
age_cal_buff = -0.001973 * age + 0.283936
age_calSR_buff = -0.007122 * age + 12.466850
age_steep_ical = -0.154673 * age - 0.454007
age_V_shift_ical = 0.75 * age - 42.5
age_icalb = -0.042499 * age + 1.871332
age_ik1b = -11.67 + (11.67)/(1+10**((67.45 - age)*(-0.03752)))
age_Cm = 20 + (57.17 - 20)/(1+10**((34.14 - age)*(-0.03764)))
#age_ik1b = -0.2025 * age + 7.8
#age_Cm = -0.6315 * age + 60.26
age_factor_icab = 0.094065 * age + 0.841047
s.set_constant("cell.Cm", age_Cm)
s.set_constant("parameters.age_INCX_Block", age_ncxb)
s.set_constant("parameters.JsercaB", age_sercab)
s.set_constant("calcium.Buf_C", age_cal_buff)
s.set_constant("calcium.Buf_SR", age_calSR_buff)
s.set_constant("ical.steep1", age_steep_ical)
s.set_constant("parameters.age_ICaL_Block", age_icalb)
s.set_constant("parameters.age_IK1_Block", age_ik1b)
s.set_constant("ical.shift_act", age_V_shift_ical)
s.set_constant("icab.factor_icab", age_factor_icab)
s.set_constant('membrane.stim_amplitude', self.stimamp.value())
s.set_constant("membrane.I_hyper", self.I_hyper.value())
progrep.msgvar = "- Cell 2 -"
s.pre(prebeats*bcl, progress=progrep)
data1b_temp = s.run(showbeats*bcl, progress=progrep, log=myokit.LOG_STATE+myokit.LOG_INTER+myokit.LOG_BOUND)
data1b.append(data1b_temp)
apds1b_alt = data1b_temp.apd(v='output.Vm', threshold=0.9*np.min(data1b_temp['output.Vm']))
CaTb_alt = np.max(data1b_temp['output.Cai']) - np.min(data1b_temp['output.Cai'])
#Systb_alt = np.max(data1b_temp['output.Cai'])
#Diastb_alt = np.min(data1b_temp['output.Cai'])
dvdtb_alt = np.diff(data1b_temp['output.Vm']) / np.diff(data1b_temp[model1.time()])
dvdtmaxb_alt = np.max(dvdtb_alt)
#self.lblAPDCaTModel2Alt.setText('APD: ' + str(apds2_alt[0]) + ' ms / CaT: ' + str(CaT_alt) + ' uM')
if len(apds1b_alt['duration']) > 0:
self.lblAPDCaTModel1Alt_2.setText("%s\n %.1f Hz Cell 2 - APD: %d ms // dV/dt_max: %d mV/ms // CaT: %d nM" % (self.lblAPDCaTModel1Alt_2.text(), (1000/bcl), apds1b_alt['duration'][0], dvdtmaxb_alt, 1000*CaTb_alt))
else:
self.lblAPDCaTModel1Alt_2.setText("%s\n %.1f Hz Cell 2 - APD: ? ms // dV/dt_max: ? mV/ms // CaT: ? nM" % (self.lblAPDCaTModel1Alt_2.text(), (1000/bcl)))
if len(self.cmbOutput1Top.currentText()) > 1:
#self.mplOutput1Top.axes.hold(True)
#self.mplOutput1Bottom.axes.hold(True)
for k, item in enumerate(data1):
data1_temp = data1[k]
data1b_temp = data1b[k]
data1_ref_temp = data1_ref[k]
if self.aad1_mdl1_top.isChecked():
self.mplOutput1Top.axes.plot(data1_temp[model1.time()],data1_temp[self.cmbOutput1Top.currentText()],'-r')
if self.aad2_mdl1_top.isChecked():
self.mplOutput1Top.axes.plot(data1b_temp[model1.time()],data1b_temp[self.cmbOutput1Top.currentText()],'-b')
if self.ref_mdl1_top.isChecked():
self.mplOutput1Top.axes.plot(data1_ref_temp[model1.time()],data1_ref_temp[self.cmbOutput1Top.currentText()],'-k')
if self.aad1_mdl1_bottom.isChecked():
self.mplOutput1Bottom.axes.plot(data1_temp[model1.time()],data1_temp[self.cmbOutput1Bottom.currentText()],'-r')
if self.aad2_mdl1_bottom.isChecked():
self.mplOutput1Bottom.axes.plot(data1b_temp[model1.time()],data1b_temp[self.cmbOutput1Bottom.currentText()],'-b')
if self.ref_mdl1_bottom.isChecked():
self.mplOutput1Bottom.axes.plot(data1_ref_temp[model1.time()],data1_ref_temp[self.cmbOutput1Bottom.currentText()],'-k')
self.mplOutput1Top.axes.set_xlim(self.xaxis_mdl1_from.value(), self.xaxis_mdl1_to.value())
self.mplOutput1Bottom.axes.set_xlim(self.xaxis_mdl1_from.value(), self.xaxis_mdl1_to.value())
self.mplOutput1Top.draw()
self.mplOutput1Bottom.draw()
def plotselection(self):
global data1_ref, data1, data1b
if len(self.cmbOutput1Top.currentText()) > 1:
self.mplOutput1Top.axes.clear()
self.mplOutput1Bottom.axes.clear()
#self.mplOutput1Top.axes.hold(True)
#self.mplOutput1Bottom.axes.hold(True)
for k, item in enumerate(data1):
data1_temp = data1[k]
data1b_temp = data1b[k]
data1_ref_temp = data1_ref[k]
if self.aad1_mdl1_top.isChecked():
self.mplOutput1Top.axes.plot(data1_temp[model1.time()],data1_temp[self.cmbOutput1Top.currentText()],'-r')
if self.aad2_mdl1_top.isChecked():
self.mplOutput1Top.axes.plot(data1b_temp[model1.time()],data1b_temp[self.cmbOutput1Top.currentText()],'-b')
if self.ref_mdl1_top.isChecked():
self.mplOutput1Top.axes.plot(data1_ref_temp[model1.time()],data1_ref_temp[self.cmbOutput1Top.currentText()],'-k')
if self.aad1_mdl1_bottom.isChecked():
self.mplOutput1Bottom.axes.plot(data1_temp[model1.time()],data1_temp[self.cmbOutput1Bottom.currentText()],'-r')
if self.aad2_mdl1_bottom.isChecked():
self.mplOutput1Bottom.axes.plot(data1b_temp[model1.time()],data1b_temp[self.cmbOutput1Bottom.currentText()],'-b')
if self.ref_mdl1_bottom.isChecked():
self.mplOutput1Bottom.axes.plot(data1_ref_temp[model1.time()],data1_ref_temp[self.cmbOutput1Bottom.currentText()],'-k')
self.mplOutput1Top.axes.set_xlim(self.xaxis_mdl1_from.value(), self.xaxis_mdl1_to.value())
self.mplOutput1Bottom.axes.set_xlim(self.xaxis_mdl1_from.value(), self.xaxis_mdl1_to.value())
self.mplOutput1Top.draw()
self.mplOutput1Bottom.draw()
def xaxis_adjustment1(self):
self.mplOutput1Top.axes.set_xlim(self.xaxis_mdl1_from.value(), self.xaxis_mdl1_to.value())
self.mplOutput1Top.draw()
self.mplOutput1Bottom.axes.set_xlim(self.xaxis_mdl1_from.value(), self.xaxis_mdl1_to.value())
self.mplOutput1Bottom.draw()
def resetaxes(self):
self.xaxis_mdl1_from.setValue(0)
self.xaxis_mdl1_to.setValue(1000)
def savecsv1(self):
global model1, data1, data1_ref, data1b
export_mdl1 = QtWidgets.QFileDialog.getSaveFileName(self, 'Save File', '', "CSV (*.csv);;Text (*.txt);;All Files (*.*)")
main1 = export_mdl1[0][:-4]
ext1 = export_mdl1[0][-4:]
export_mdl1_top = ''.join(main1)+("_Top")+''.join(ext1)
with open(export_mdl1_top,'wb') as f1_top:
for k, item in enumerate(data1):
#print k
data1_temp = data1[k]
data1b_temp = data1b[k]
data1_ref_temp = data1_ref[k]
max_length = np.max([len(data1_ref_temp[model1.time()]),len(data1_temp[model1.time()]),len(data1b_temp[model1.time()])])
time1_ref_temp = np.concatenate((data1_ref_temp[model1.time()], np.zeros(max_length-len(data1_ref_temp[model1.time()])+1)))
time1_temp = np.concatenate((data1_temp[model1.time()], np.zeros(max_length-len(data1_temp[model1.time()])+1)))
time1b_temp = np.concatenate((data1b_temp[model1.time()], np.zeros(max_length-len(data1b_temp[model1.time()])+1)))
val1_ref_temp = np.concatenate((data1_ref_temp[self.cmbOutput1Top.currentText()], np.zeros(max_length-len(data1_ref_temp[self.cmbOutput1Top.currentText()])+1)))
val1_temp = np.concatenate((data1_temp[self.cmbOutput1Top.currentText()], np.zeros(max_length-len(data1_temp[self.cmbOutput1Top.currentText()])+1)))
val1b_temp = np.concatenate((data1b_temp[self.cmbOutput1Top.currentText()], np.zeros(max_length-len(data1b_temp[self.cmbOutput1Top.currentText()])+1)))
np.savetxt(f1_top, np.c_[time1_ref_temp, val1_ref_temp, time1_temp, val1_temp, time1b_temp, val1b_temp], delimiter=',', footer='\n\n')
#np.savetxt(f1_top, np.c_[data1_ref_temp[model1.time()], data1_ref_temp[self.cmbOutput1Top.currentText()], data1_temp[self.cmbOutput1Top.currentText()], data1b_temp[self.cmbOutput1Top.currentText()]], delimiter=',')
export_mdl1_bottom = ''.join(main1)+("_Bottom")+''.join(ext1)
with open(export_mdl1_bottom,'wb') as f1_bottom:
for k, item in enumerate(data1):
data1_temp = data1[k]
data1b_temp = data1b[k]
data1_ref_temp = data1_ref[k]
max_length = np.max([len(data1_ref_temp[model1.time()]),len(data1_temp[model1.time()]),len(data1b_temp[model1.time()])])
time1_ref_temp = np.concatenate((data1_ref_temp[model1.time()], np.zeros(max_length-len(data1_ref_temp[model1.time()])+1)))
time1_temp = np.concatenate((data1_temp[model1.time()], np.zeros(max_length-len(data1_temp[model1.time()])+1)))
time1b_temp = np.concatenate((data1b_temp[model1.time()], np.zeros(max_length-len(data1b_temp[model1.time()])+1)))
val1_ref_temp = np.concatenate((data1_ref_temp[self.cmbOutput1Bottom.currentText()], np.zeros(max_length-len(data1_ref_temp[self.cmbOutput1Bottom.currentText()])+1)))
val1_temp = np.concatenate((data1_temp[self.cmbOutput1Bottom.currentText()], np.zeros(max_length-len(data1_temp[self.cmbOutput1Bottom.currentText()])+1)))
val1b_temp = np.concatenate((data1b_temp[self.cmbOutput1Bottom.currentText()], np.zeros(max_length-len(data1b_temp[self.cmbOutput1Bottom.currentText()])+1)))
np.savetxt(f1_bottom, np.c_[time1_ref_temp, val1_ref_temp, time1_temp, val1_temp, time1b_temp, val1b_temp], delimiter=',', footer='\n\n')
#np.savetxt(f1_bottom, np.c_[data1_ref_temp[model1.time()], data1_ref_temp[self.cmbOutput1Bottom.currentText()], data1_temp[self.cmbOutput1Bottom.currentText()], data1b_temp[self.cmbOutput1Bottom.currentText()]], delimiter=',')
class MyokitProgressReporter(myokit.ProgressReporter):
target = None
msgvar = None
def __init__(self, tar=None):
self.target = tar
def enter(self, msg=None):
print("Starting sim...")
def exit(self):
#self.target.clearMessage()
print("Done!")
def update(self, progress):
val = progress * 100.0
#print("Progress = " + str(progress))
#self.target.setValue(int(val))
self.target.showMessage(self.msgvar + " Progress: " + str(val) + "%", 2000);
QtWidgets.QApplication.processEvents(QtCore.QEventLoop.ExcludeUserInputEvents)
#QtGui.QApplication.processEvents(QtCore.QEventLoop.ExcludeUserInputEvents)
return True
def run():
app = QtWidgets.QApplication(sys.argv)
#app = QtGui.QApplication(sys.argv)
myWindow = MyWindowClass(None)
myWindow.show()
app.exec_()
run() | ADMIRE-maastricht | /ADMIRE_maastricht-1.1.1.1.zip/ADMIRE_maastricht-1.1.1.1/ADMIRE_maastricht/ADMIREv1.py | ADMIREv1.py |
__version__ = "1.0.0"
from PyQt5.QtWidgets import QSizePolicy
from PyQt5.QtCore import QSize
from matplotlib.backends.backend_qt4agg import FigureCanvasQTAgg as Canvas
from matplotlib.figure import Figure
from matplotlib import rcParams
rcParams['font.size'] = 9
class MatplotlibWidget(Canvas):
"""
MatplotlibWidget inherits PyQt4.QtGui.QWidget
and matplotlib.backend_bases.FigureCanvasBase
Options: option_name (default_value)
-------
parent (None): parent widget
title (''): figure title
xlabel (''): X-axis label
ylabel (''): Y-axis label
xlim (None): X-axis limits ([min, max])
ylim (None): Y-axis limits ([min, max])
xscale ('linear'): X-axis scale
yscale ('linear'): Y-axis scale
width (4): width in inches
height (3): height in inches
dpi (100): resolution in dpi
hold (False): if False, figure will be cleared each time plot is called
Widget attributes:
-----------------
figure: instance of matplotlib.figure.Figure
axes: figure axes
Example:
-------
self.widget = MatplotlibWidget(self, yscale='log', hold=True)
from numpy import linspace
x = linspace(-10, 10)
self.widget.axes.plot(x, x**2)
self.wdiget.axes.plot(x, x**3)
"""
def __init__(self, parent=None, title='', xlabel='', ylabel='',
xlim=None, ylim=None, xscale='linear', yscale='linear',
width=4, height=3, dpi=100, hold=False):
self.figure = Figure(figsize=(width, height), dpi=dpi)
self.axes = self.figure.add_subplot(111)
self.axes.set_title(title)
self.axes.set_xlabel(xlabel)
self.axes.set_ylabel(ylabel)
if xscale is not None:
self.axes.set_xscale(xscale)
if yscale is not None:
self.axes.set_yscale(yscale)
if xlim is not None:
self.axes.set_xlim(*xlim)
if ylim is not None:
self.axes.set_ylim(*ylim)
#self.axes.hold(hold)
Canvas.__init__(self, self.figure)
self.setParent(parent)
Canvas.setSizePolicy(self, QSizePolicy.Expanding, QSizePolicy.Expanding)
Canvas.updateGeometry(self)
def sizeHint(self):
w, h = self.get_width_height()
return QSize(w, h)
def minimumSizeHint(self):
return QSize(10, 10)
#===============================================================================
# Example
#===============================================================================
if __name__ == '__main__':
import sys
from PyQt5.QtGui import QMainWindow, QApplication
from numpy import linspace
class ApplicationWindow(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.mplwidget = MatplotlibWidget(self, title='Example',
xlabel='Linear scale',
ylabel='Log scale',
hold=True, yscale='log')
self.mplwidget.setFocus()
self.setCentralWidget(self.mplwidget)
self.plot(self.mplwidget.axes)
def plot(self, axes):
x = linspace(-10, 10)
axes.plot(x, x**2)
axes.plot(x, x**3)
app = QApplication(sys.argv)
win = ApplicationWindow()
win.show()
sys.exit(app.exec_()) | ADMIRE-maastricht | /ADMIRE_maastricht-1.1.1.1.zip/ADMIRE_maastricht-1.1.1.1/ADMIRE_maastricht/MatplotlibWidget5.py | MatplotlibWidget5.py |
import sys
sys.path.append('C:\\myokit\\myokit')
import myokit
import numpy as np
from PyQt5 import QtCore, QtGui, QtWidgets
#from PyQt4 import QtCore, QtGui, uic
from os import walk
import csv
import os
from . import Qt5file
print("ADMIRE 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.")
#form_class = uic.loadUiType("ADMIRE.ui")[0] # Load the UI
model1 = 0
data1b = 1
data1 = 1
data1_ref = 1
settingValuesforAAD = 0
#class MyWindowClass(QtGui.QMainWindow, form_class):
class MyWindowClass(QtWidgets.QMainWindow, Qt5file.Ui_MainWindow):
def __init__(self, parent=None):
QtWidgets.QMainWindow.__init__(self, parent)
#QtGui.QMainWindow.__init__(self, parent)
self.setupUi(self)
self.statusBar()
self.spinAADConcentration.valueChanged.connect(self.processAADConcentration)
self.spinICaL.valueChanged.connect(self.updateSlide)
self.spinIK1.valueChanged.connect(self.updateSlide)
self.spinIKr.valueChanged.connect(self.updateSlide)
self.spinIKs.valueChanged.connect(self.updateSlide)
self.spinIf.valueChanged.connect(self.updateSlide)
self.spinINa.valueChanged.connect(self.updateSlide)
self.spinINaL.valueChanged.connect(self.updateSlide)
self.spinINaK.valueChanged.connect(self.updateSlide)
self.spinINCX.valueChanged.connect(self.updateSlide)
self.spinIto.valueChanged.connect(self.updateSlide)
self.spinAADConcentration_3.valueChanged.connect(self.processAADConcentration)
self.spinICaL_2.valueChanged.connect(self.updateSlide2)
self.spinIK1_2.valueChanged.connect(self.updateSlide2)
self.spinIKr_2.valueChanged.connect(self.updateSlide2)
self.spinIKs_2.valueChanged.connect(self.updateSlide2)
self.spinIf_2.valueChanged.connect(self.updateSlide2)
self.spinINa_2.valueChanged.connect(self.updateSlide2)
self.spinINaL_2.valueChanged.connect(self.updateSlide2)
self.spinINaK_2.valueChanged.connect(self.updateSlide2)
self.spinINCX_2.valueChanged.connect(self.updateSlide2)
self.spinIto_2.valueChanged.connect(self.updateSlide2)
self.slideICaL_2.valueChanged.connect(self.updateSpin2)
self.slideIK1_2.valueChanged.connect(self.updateSpin2)
self.slideIKr_2.valueChanged.connect(self.updateSpin2)
self.slideIKs_2.valueChanged.connect(self.updateSpin2)
self.slideIf_2.valueChanged.connect(self.updateSpin2)
self.slideINa_2.valueChanged.connect(self.updateSpin2)
self.slideINaL_2.valueChanged.connect(self.updateSpin2)
self.slideINaK_2.valueChanged.connect(self.updateSpin2)
self.slideINCX_2.valueChanged.connect(self.updateSpin2)
self.slideIto_2.valueChanged.connect(self.updateSpin2)
self.cmdRun.clicked.connect(self.startSimulation)
self.cmdReset.clicked.connect(self.resetSimulation)
#self.s1s2_button.clicked.connect(self.s1s2protocol)
self.export_1.clicked.connect(self.savecsv1)
self.resetaxes_button.clicked.connect(self.resetaxes)
self.cmbModel1.currentIndexChanged.connect(self.populateOutputBox)
self.cmbOutput1Top.currentIndexChanged.connect(self.updateOutput)
self.cmbOutput1Bottom.currentIndexChanged.connect(self.updateOutput)
self.xaxis_mdl1_from.valueChanged.connect(self.xaxis_adjustment1)
self.xaxis_mdl1_to.valueChanged.connect(self.xaxis_adjustment1)
self.ref_mdl1_top.stateChanged.connect(self.plotselection)
self.aad1_mdl1_top.stateChanged.connect(self.plotselection)
self.aad2_mdl1_top.stateChanged.connect(self.plotselection)
self.ref_mdl1_bottom.stateChanged.connect(self.plotselection)
self.aad1_mdl1_bottom.stateChanged.connect(self.plotselection)
self.aad2_mdl1_bottom.stateChanged.connect(self.plotselection)
mdldirectory = os.path.join(
os.path.dirname(os.path.abspath(__file__)), 'models')
(_, _, filenames) = next(walk(mdldirectory))
for fn in filenames:
if fn.endswith('.mmt'):
self.cmbModel1.addItem(fn[:(len(fn)-4)])
#(_, _, filenames) = walk('models/').next()
def processAADConcentration(self):
global settingValuesforAAD
if self.sender().objectName() == 'spinAADConcentration':
age = self.spinAADConcentration.value()
else:
age = self.spinAADConcentration_3.value()
blockICaL = 0
blockIK1 = 0
blockIKr = 0
blockIKs = 0
blockIf = 0
blockINa = 0
blockINaL = 0
blockINaK = 0
blockINCX = 0
blockIto = 0
def updateSlide(self):
global settingValuesforAAD
sending_spin = self.sender()
if sending_spin.objectName() == 'spinICaL':
self.slideICaL.setValue(sending_spin.value())
if sending_spin.objectName() == 'spinIK1':
self.slideIK1.setValue(sending_spin.value())
if sending_spin.objectName() == 'spinIKr':
self.slideIKr.setValue(sending_spin.value())
if sending_spin.objectName() == 'spinIKs':
self.slideIKs.setValue(sending_spin.value())
if sending_spin.objectName() == 'spinIf':
self.slideIf.setValue(sending_spin.value())
if sending_spin.objectName() == 'spinINa':
self.slideINa.setValue(sending_spin.value())
if sending_spin.objectName() == 'spinINaL':
self.slideINaL.setValue(sending_spin.value())
if sending_spin.objectName() == 'spinINaK':
self.slideINaK.setValue(sending_spin.value())
if sending_spin.objectName() == 'spinINCX':
self.slideINCX.setValue(sending_spin.value())
if sending_spin.objectName() == 'spinIto':
self.slideIto.setValue(sending_spin.value())
def updateSlide2(self):
global settingValuesforAAD
sending_spin2 = self.sender()
if sending_spin2.objectName() == 'spinICaL_2':
self.slideICaL_2.setValue(sending_spin2.value())
if sending_spin2.objectName() == 'spinIK1_2':
self.slideIK1_2.setValue(sending_spin2.value())
if sending_spin2.objectName() == 'spinIKr_2':
self.slideIKr_2.setValue(sending_spin2.value())
if sending_spin2.objectName() == 'spinIKs_2':
self.slideIKs_2.setValue(sending_spin2.value())
if sending_spin2.objectName() == 'spinIf_2':
self.slideIf_2.setValue(sending_spin2.value())
if sending_spin2.objectName() == 'spinINa_2':
self.slideINa_2.setValue(sending_spin2.value())
if sending_spin2.objectName() == 'spinINaL_2':
self.slideINaL_2.setValue(sending_spin2.value())
if sending_spin2.objectName() == 'spinINaK_2':
self.slideINaK_2.setValue(sending_spin2.value())
if sending_spin2.objectName() == 'spinINCX_2':
self.slideINCX_2.setValue(sending_spin2.value())
if sending_spin2.objectName() == 'spinIto_2':
self.slideIto_2.setValue(sending_spin2.value())
def updateSpin2(self):
global settingValuesforAAD
sending_slide2 = self.sender()
if sending_slide2.objectName() == 'slideICaL_2':
self.spinICaL_2.setValue(sending_slide2.value())
if sending_slide2.objectName() == 'slideIK1_2':
self.spinIK1_2.setValue(sending_slide2.value())
if sending_slide2.objectName() == 'slideIKr_2':
self.spinIKr_2.setValue(sending_slide2.value())
if sending_slide2.objectName() == 'slideIKs_2':
self.spinIKs_2.setValue(sending_slide2.value())
if sending_slide2.objectName() == 'slideIf_2':
self.spinIf_2.setValue(sending_slide2.value())
if sending_slide2.objectName() == 'slideINa_2':
self.spinINa_2.setValue(sending_slide2.value())
if sending_slide2.objectName() == 'slideINaL_2':
self.spinINaL_2.setValue(sending_slide2.value())
if sending_slide2.objectName() == 'slideINaK_2':
self.spinINaK_2.setValue(sending_slide2.value())
if sending_slide2.objectName() == 'slideINCX_2':
self.spinINCX_2.setValue(sending_slide2.value())
if sending_slide2.objectName() == 'slideIto_2':
self.spinIto_2.setValue(sending_slide2.value())
def populateOutputBox(self):
global model1
global data1
global data1_ref
sending_cmb = self.sender()
mdldirectory = os.path.join(os.path.dirname(os.path.abspath(__file__)), "models")
mdlname = sending_cmb.currentText() + ".mmt"
mdlpath = mdldirectory + "\\" + mdlname
#mdlname = "models/" + sending_cmb.currentText() + ".mmt"
print(mdlname)
if sending_cmb.objectName() == 'cmbModel1':
data1 = 1
#model1, p1, s1 = myokit.load(mdlname)
model1, p1, s1 = myokit.load(mdlpath)
self.cmbOutput1Top.clear()
self.cmbOutput1Bottom.clear()
#for s in model1.states():
# self.cmbOutput1Top.addItem(s.qname())
# self.cmbOutput1Bottom.addItem(s.qname())
self.startSimulation(1)
self.ref_mdl1_top.setChecked(True)
self.aad1_mdl1_top.setChecked(True)
self.aad2_mdl1_top.setChecked(True)
self.ref_mdl1_bottom.setChecked(True)
self.aad1_mdl1_bottom.setChecked(True)
self.aad2_mdl1_bottom.setChecked(True)
#print(data1.variable_info())
model_vars = data1[0].variable_info()
for items in sorted(model_vars):
self.cmbOutput1Top.addItem(items)
self.cmbOutput1Bottom.addItem(items)
ind_Vm_top = self.cmbOutput1Top.findText('output.Vm')
if ind_Vm_top >= 0:
self.cmbOutput1Top.setCurrentIndex(ind_Vm_top)
ind_Cai_bottom = self.cmbOutput1Bottom.findText('output.Cai')
if ind_Cai_bottom >= 0:
self.cmbOutput1Bottom.setCurrentIndex(ind_Cai_bottom)
def updateOutput(self):
global data1b
global data1
global data1_ref
global model1
sending_cmb = self.sender()
print("Sender = " + sending_cmb.objectName())
if sending_cmb.currentText() != "":
if sending_cmb.objectName() == 'cmbOutput1Top':
if data1 != 1:
self.mplOutput1Top.axes.clear()
#self.mplOutput1Top.axes.hold(True)
for k, item in enumerate(data1):
cur_data1_ref = data1_ref[k]
cur_data1 = data1[k]
cur_data1b = data1b[k]
if self.aad1_mdl1_top.isChecked():
self.mplOutput1Top.axes.plot(cur_data1[model1.time()],cur_data1[sending_cmb.currentText()],'-r')
if self.aad2_mdl1_top.isChecked():
self.mplOutput1Top.axes.plot(cur_data1b[model1.time()],cur_data1b[sending_cmb.currentText()],'-b')
if self.ref_mdl1_top.isChecked():
self.mplOutput1Top.axes.plot(cur_data1_ref[model1.time()],cur_data1_ref[sending_cmb.currentText()],'-k')
self.mplOutput1Top.axes.set_xlim(self.xaxis_mdl1_from.value(), self.xaxis_mdl1_to.value())
#else:
# self.mplOutput1Top.axes.plot(data1_ref[model1.time()],data1_ref[sending_cmb.currentText()],'-k')
self.mplOutput1Top.draw()
if sending_cmb.objectName() == 'cmbOutput1Bottom':
if data1 != 1:
self.mplOutput1Bottom.axes.clear()
#self.mplOutput1Bottom.axes.hold(True)
for k, item in enumerate(data1):
cur_data1_ref = data1_ref[k]
cur_data1 = data1[k]
cur_data1b = data1b[k]
if self.aad1_mdl1_bottom.isChecked():
self.mplOutput1Bottom.axes.plot(cur_data1[model1.time()],cur_data1[sending_cmb.currentText()],'-r')
if self.aad2_mdl1_bottom.isChecked():
self.mplOutput1Bottom.axes.plot(cur_data1b[model1.time()],cur_data1b[sending_cmb.currentText()],'-b')
if self.ref_mdl1_bottom.isChecked():
self.mplOutput1Bottom.axes.plot(cur_data1_ref[model1.time()],cur_data1_ref[sending_cmb.currentText()],'-k')
self.mplOutput1Bottom.axes.set_xlim(self.xaxis_mdl1_from.value(), self.xaxis_mdl1_to.value())
#self.mplOutput1Bottom.axes.plot(data1[model1.time()],data1[sending_cmb.currentText()],'-r', data1b[model1.time()],data1b[sending_cmb.currentText()],'-b', data1_ref[model1.time()],data1_ref[sending_cmb.currentText()],'-k')
#else:
# self.mplOutput1Bottom.axes.plot(data1_ref[model1.time()],data1_ref[sending_cmb.currentText()],'-k')
self.mplOutput1Bottom.draw()
def resetSimulation(self):
global settingValuesforAAD
self.slideICaL.setSliderPosition(0)
self.slideIK1.setSliderPosition(0)
self.slideIKr.setSliderPosition(0)
self.slideIKs.setSliderPosition(0)
self.slideIf.setSliderPosition(0)
self.slideINa.setSliderPosition(0)
self.slideINaL.setSliderPosition(0)
self.slideINaK.setSliderPosition(0)
self.slideINCX.setSliderPosition(0)
self.slideIto.setSliderPosition(0)
self.spinICaL.setValue(0)
self.spinIK1.setValue(0)
self.spinIKr.setValue(0)
self.spinIKs.setValue(0)
self.spinIf.setValue(0)
self.spinINa.setValue(0)
self.spinINaL.setValue(0)
self.spinINaK.setValue(0)
self.spinINCX.setValue(0)
self.spinIto.setValue(0)
self.slideICaL_2.setSliderPosition(0)
self.slideIK1_2.setSliderPosition(0)
self.slideIKr_2.setSliderPosition(0)
self.slideIKs_2.setSliderPosition(0)
self.slideIf_2.setSliderPosition(0)
self.slideINa_2.setSliderPosition(0)
self.slideINaL_2.setSliderPosition(0)
self.slideINaK_2.setSliderPosition(0)
self.slideINCX_2.setSliderPosition(0)
self.slideIto_2.setSliderPosition(0)
self.spinICaL_2.setValue(0)
self.spinIK1_2.setValue(0)
self.spinIKr_2.setValue(0)
self.spinIKs_2.setValue(0)
self.spinIf_2.setValue(0)
self.spinINa_2.setValue(0)
self.spinINaL_2.setValue(0)
self.spinINaK_2.setValue(0)
self.spinINCX_2.setValue(0)
self.spinIto_2.setValue(0)
self.txtRateModel1.setText("60")
self.spinStimDur1.setValue(1.0)
self.spinStimAmp1.setValue(50)
self.spinPrepacingModel1.setValue(100)
self.spinShowbeatsModel1.setValue(3)
self.stimamp.setValue(-120)
self.I_hyper.setValue(0.0)
self.spinCao1.setValue(2.00)
self.spinKo1.setValue(4.00)
self.spinNao1.setValue(140.00)
self.xaxis_mdl1_from.setValue(0)
self.xaxis_mdl1_to.setValue(1000)
self.spinAADConcentration.setValue(30.0)
self.spinAADConcentration_3.setValue(30.0)
self.ref_mdl1_top.setChecked(True)
self.aad1_mdl1_top.setChecked(True)
self.aad2_mdl1_top.setChecked(True)
self.ref_mdl1_bottom.setChecked(True)
self.aad1_mdl1_bottom.setChecked(True)
self.aad2_mdl1_bottom.setChecked(True)
def startSimulation(self, flag=3): # CtoF button event handler
global model1, data1, data1_ref, data1b
#global protocol1, protocol2
if flag == False:
flag = 3
print("Simulation starting... flag = " + str(flag))
progrep = MyokitProgressReporter(self.statusBar())
if flag == 1 or flag == 3:
#Extract BCLs
bcls = self.txtRateModel1.text().split(",")
data1_ref = []
data1 = []
data1b = []
self.mplOutput1Top.axes.clear()
self.mplOutput1Bottom.axes.clear()
self.lblAPDCaTModel1Ctrl.setText("")
self.lblAPDCaTModel1Alt.setText("")
self.lblAPDCaTModel1Alt_2.setText("")
for k, bcl_text in enumerate(bcls):
bcl = 1000 * 60.0 / float(bcl_text) #self.spinRateModel1.value()
stimdur = self.spinStimDur1.value()
stimamp = 0.01 * self.spinStimAmp1.value()
prebeats = self.spinPrepacingModel1.value()
showbeats = self.spinShowbeatsModel1.value()
p = myokit.Protocol()
p.schedule(stimamp,10,stimdur,bcl,0)
s = myokit.Simulation(model1, p)
s.set_constant('parameters.Ca_o', self.spinCao1.value())
s.set_constant('parameters.K_o', self.spinKo1.value())
s.set_constant('parameters.Na_o', self.spinNao1.value())
age = 30 #self.spinAADConcentration.value()
age_ncxb = -0.022731 * age + 0.841199
age_sercab = 0.005793 * age + 0.532222
age_cal_buff = -0.001973 * age + 0.283936
age_calSR_buff = -0.007122 * age + 12.466850
age_steep_ical = -0.154673 * age - 0.454007
age_V_shift_ical = 0.75 * age - 42.5
age_icalb = -0.042499 * age + 1.871332
age_ik1b = -11.67 + (11.67)/(1+10**((67.45 - age)*(-0.03752)))
age_Cm = 20 + (57.17 - 20)/(1+10**((34.14 - age)*(-0.03764)))
age_inab = 0.28 + (0.75 - 0.28)/(1+10**((55 - age)*(-0.1191)))
age_ina_act_shift = (-5.5) + ((-1) - (-5.5))/(1+10**((55 - age)*(0.1191)))
#age_ik1b = -0.2025 * age + 7.8
#age_Cm = -0.6315 * age + 60.26
age_factor_icab = 0.094065 * age + 0.841047
s.set_constant("cell.Cm", age_Cm)
s.set_constant("parameters.age_INCX_Block", age_ncxb)
s.set_constant("parameters.JsercaB", age_sercab)
s.set_constant("calcium.Buf_C", age_cal_buff)
s.set_constant("calcium.Buf_SR", age_calSR_buff)
s.set_constant("ical.steep1", age_steep_ical)
s.set_constant("parameters.age_ICaL_Block", age_icalb)
s.set_constant("parameters.age_IK1_Block", age_ik1b)
s.set_constant("ical.shift_act", age_V_shift_ical)
s.set_constant("icab.factor_icab", age_factor_icab)
s.set_constant("parameters.age_INa_Block", age_inab)
s.set_constant("ina.act_shift", age_ina_act_shift)
s.set_constant('membrane.stim_amplitude', self.stimamp.value())
s.set_constant("membrane.I_hyper", self.I_hyper.value())
progrep.msgvar = "Model 1 - Control Condition -"
s.pre(prebeats*bcl, progress=progrep)
data1_ref_temp = s.run(showbeats*bcl, progress=progrep, log=myokit.LOG_STATE+myokit.LOG_INTER+myokit.LOG_BOUND)
data1_ref.append(data1_ref_temp)
apds1_ref = data1_ref_temp.apd(v='output.Vm', threshold=0.9*np.min(data1_ref_temp['output.Vm']))
CaT_ref = np.max(data1_ref_temp['output.Cai']) - np.min(data1_ref_temp['output.Cai'])
#Syst_ref = np.max(data1_ref_temp['output.Cai'])
#Diast_ref = np.min(data1_ref_temp['output.Cai'])
dvdt_ref = np.diff(data1_ref_temp['output.Vm']) / np.diff(data1_ref_temp[model1.time()])
dvdtmax_ref = np.max(dvdt_ref)
if len(apds1_ref['duration']) > 0:
self.lblAPDCaTModel1Ctrl.setText("%s\n %.1f Hz REF - APD: %d ms // dV/dt_max: %d mV/ms // CaT: %d nM" % (self.lblAPDCaTModel1Ctrl.text(), (1000/bcl), apds1_ref['duration'][0], dvdtmax_ref, 1000*CaT_ref))
else:
self.lblAPDCaTModel1Ctrl.setText("%s\n %.1f Hz REF - APD: ? ms // dV/dt_max: ? mV/ms // CaT: ? nM" % (self.lblAPDCaTModel1Ctrl.text(), (1000/bcl)))
#mdlname = "models/" + self.cmbModel1.currentText() + ".mmt"
#print(mdlname)
#m1, p1, s1 = myokit.load(mdlname)
s = myokit.Simulation(model1, p)
s.set_constant('parameters.Ca_o', self.spinCao1.value())
s.set_constant('parameters.K_o', self.spinKo1.value())
s.set_constant('parameters.Na_o', self.spinNao1.value())
s.set_constant('parameters.ICaL_Block', self.spinICaL.value() / 100.0)
s.set_constant('parameters.IK1_Block', self.spinIK1.value() / 100.0)
s.set_constant('parameters.IKr_Block', self.spinIKr.value() / 100.0)
s.set_constant('parameters.IKs_Block', self.spinIKs.value() / 100.0)
s.set_constant('parameters.If_Block', self.spinIf.value() / 100.0)
s.set_constant('parameters.INa_Block', self.spinINa.value() / 100.0)
s.set_constant('parameters.INaL_Block', self.spinINaL.value() / 100.0)
s.set_constant('parameters.INaK_Block', self.spinINaK.value() / 100.0)
s.set_constant('parameters.INCX_Block', self.spinINCX.value() / 100.0)
s.set_constant('parameters.Ito_Block', self.spinIto.value() / 100.0)
age = self.spinAADConcentration.value()
age_ncxb = -0.022731 * age + 0.841199
age_sercab = 0.005793 * age + 0.532222
age_cal_buff = -0.001973 * age + 0.283936
age_calSR_buff = -0.007122 * age + 12.466850
age_steep_ical = -0.154673 * age - 0.454007
age_V_shift_ical = 0.75 * age - 42.5
age_icalb = -0.042499 * age + 1.871332
age_ik1b = -11.67 + (11.67)/(1+10**((67.45 - age)*(-0.03752)))
age_Cm = 20 + (57.17 - 20)/(1+10**((34.14 - age)*(-0.03764)))
age_inab = 0.28 + (0.75 - 0.28)/(1+10**((55 - age)*(-0.1191)))
age_ina_act_shift = (-5.5) + ((-1) - (-5.5))/(1+10**((55 - age)*(0.1191)))
#age_ik1b = -0.2025 * age + 7.8
#age_Cm = -0.6315 * age + 60.26
age_factor_icab = 0.094065 * age + 0.841047
s.set_constant("cell.Cm", age_Cm)
s.set_constant("parameters.age_INCX_Block", age_ncxb)
s.set_constant("parameters.JsercaB", age_sercab)
s.set_constant("calcium.Buf_C", age_cal_buff)
s.set_constant("calcium.Buf_SR", age_calSR_buff)
s.set_constant("ical.steep1", age_steep_ical)
s.set_constant("parameters.age_ICaL_Block", age_icalb)
s.set_constant("parameters.age_IK1_Block", age_ik1b)
s.set_constant("ical.shift_act", age_V_shift_ical)
s.set_constant("icab.factor_icab", age_factor_icab)
s.set_constant("parameters.age_INa_Block", age_inab)
s.set_constant("ina.act_shift", age_ina_act_shift)
s.set_constant('membrane.stim_amplitude', self.stimamp.value())
s.set_constant("membrane.I_hyper", self.I_hyper.value())
progrep.msgvar = "- Cell 1 -"
s.pre(prebeats*bcl, progress=progrep)
data1_temp = s.run(showbeats*bcl, progress=progrep, log=myokit.LOG_STATE+myokit.LOG_INTER+myokit.LOG_BOUND)
data1.append(data1_temp)
apds1_alt = data1_temp.apd(v='output.Vm', threshold=0.9*np.min(data1_temp['output.Vm']))
CaT_alt = np.max(data1_temp['output.Cai']) - np.min(data1_temp['output.Cai'])
#Syst_alt = np.max(data1_temp['output.Cai'])
#Diast_alt = np.min(data1_temp['output.Cai'])
dvdt_alt = np.diff(data1_temp['output.Vm']) / np.diff(data1_temp[model1.time()])
dvdtmax_alt = np.max(dvdt_alt)
#self.lblAPDCaTModel2Alt.setText('APD: ' + str(apds2_alt[0]) + ' ms / CaT: ' + str(CaT_alt) + ' uM')
if len(apds1_alt['duration']) > 0:
self.lblAPDCaTModel1Alt.setText("%s\n %.1f Hz Cell 1 - APD: %d ms // dV/dt_max: %d mV/ms // CaT: %d nM" % (self.lblAPDCaTModel1Alt.text(), (1000/bcl), apds1_alt['duration'][0], dvdtmax_alt, 1000*CaT_alt))
else:
self.lblAPDCaTModel1Alt.setText("%s\n %.1f Hz Cell 1 - APD: ? ms // dV/dt_max: ? mV/ms // CaT: ? nM" % (self.lblAPDCaTModel1Alt.text(), (1000/bcl)))
s = myokit.Simulation(model1, p)
s.set_constant('parameters.Ca_o', self.spinCao1.value())
s.set_constant('parameters.K_o', self.spinKo1.value())
s.set_constant('parameters.Na_o', self.spinNao1.value())
s.set_constant('parameters.ICaL_Block', self.spinICaL_2.value() / 100.0)
s.set_constant('parameters.IK1_Block', self.spinIK1_2.value() / 100.0)
s.set_constant('parameters.IKr_Block', self.spinIKr_2.value() / 100.0)
s.set_constant('parameters.IKs_Block', self.spinIKs_2.value() / 100.0)
s.set_constant('parameters.If_Block', self.spinIf_2.value() / 100.0)
s.set_constant('parameters.INa_Block', self.spinINa_2.value() / 100.0)
s.set_constant('parameters.INaL_Block', self.spinINaL_2.value() / 100.0)
s.set_constant('parameters.INaK_Block', self.spinINaK_2.value() / 100.0)
s.set_constant('parameters.INCX_Block', self.spinINCX_2.value() / 100.0)
s.set_constant('parameters.Ito_Block', self.spinIto_2.value() / 100.0)
age = self.spinAADConcentration_3.value()
age_ncxb = -0.022731 * age + 0.841199
age_sercab = 0.005793 * age + 0.532222
age_cal_buff = -0.001973 * age + 0.283936
age_calSR_buff = -0.007122 * age + 12.466850
age_steep_ical = -0.154673 * age - 0.454007
age_V_shift_ical = 0.75 * age - 42.5
age_icalb = -0.042499 * age + 1.871332
age_ik1b = -11.67 + (11.67)/(1+10**((67.45 - age)*(-0.03752)))
age_Cm = 20 + (57.17 - 20)/(1+10**((34.14 - age)*(-0.03764)))
age_inab = 0.28 + (0.75 - 0.28)/(1+10**((55 - age)*(-0.1191)))
age_ina_act_shift = (-5.5) + ((-1) - (-5.5))/(1+10**((55 - age)*(0.1191)))
#age_ik1b = -0.2025 * age + 7.8
#age_Cm = -0.6315 * age + 60.26
age_factor_icab = 0.094065 * age + 0.841047
s.set_constant("cell.Cm", age_Cm)
s.set_constant("parameters.age_INCX_Block", age_ncxb)
s.set_constant("parameters.JsercaB", age_sercab)
s.set_constant("calcium.Buf_C", age_cal_buff)
s.set_constant("calcium.Buf_SR", age_calSR_buff)
s.set_constant("ical.steep1", age_steep_ical)
s.set_constant("parameters.age_ICaL_Block", age_icalb)
s.set_constant("parameters.age_IK1_Block", age_ik1b)
s.set_constant("ical.shift_act", age_V_shift_ical)
s.set_constant("icab.factor_icab", age_factor_icab)
s.set_constant("parameters.age_INa_Block", age_inab)
s.set_constant("ina.act_shift", age_ina_act_shift)
s.set_constant('membrane.stim_amplitude', self.stimamp.value())
s.set_constant("membrane.I_hyper", self.I_hyper.value())
progrep.msgvar = "- Cell 2 -"
s.pre(prebeats*bcl, progress=progrep)
data1b_temp = s.run(showbeats*bcl, progress=progrep, log=myokit.LOG_STATE+myokit.LOG_INTER+myokit.LOG_BOUND)
data1b.append(data1b_temp)
apds1b_alt = data1b_temp.apd(v='output.Vm', threshold=0.9*np.min(data1b_temp['output.Vm']))
CaTb_alt = np.max(data1b_temp['output.Cai']) - np.min(data1b_temp['output.Cai'])
#Systb_alt = np.max(data1b_temp['output.Cai'])
#Diastb_alt = np.min(data1b_temp['output.Cai'])
dvdtb_alt = np.diff(data1b_temp['output.Vm']) / np.diff(data1b_temp[model1.time()])
dvdtmaxb_alt = np.max(dvdtb_alt)
#self.lblAPDCaTModel2Alt.setText('APD: ' + str(apds2_alt[0]) + ' ms / CaT: ' + str(CaT_alt) + ' uM')
if len(apds1b_alt['duration']) > 0:
self.lblAPDCaTModel1Alt_2.setText("%s\n %.1f Hz Cell 2 - APD: %d ms // dV/dt_max: %d mV/ms // CaT: %d nM" % (self.lblAPDCaTModel1Alt_2.text(), (1000/bcl), apds1b_alt['duration'][0], dvdtmaxb_alt, 1000*CaTb_alt))
else:
self.lblAPDCaTModel1Alt_2.setText("%s\n %.1f Hz Cell 2 - APD: ? ms // dV/dt_max: ? mV/ms // CaT: ? nM" % (self.lblAPDCaTModel1Alt_2.text(), (1000/bcl)))
if len(self.cmbOutput1Top.currentText()) > 1:
#self.mplOutput1Top.axes.hold(True)
#self.mplOutput1Bottom.axes.hold(True)
for k, item in enumerate(data1):
data1_temp = data1[k]
data1b_temp = data1b[k]
data1_ref_temp = data1_ref[k]
if self.aad1_mdl1_top.isChecked():
self.mplOutput1Top.axes.plot(data1_temp[model1.time()],data1_temp[self.cmbOutput1Top.currentText()],'-r')
if self.aad2_mdl1_top.isChecked():
self.mplOutput1Top.axes.plot(data1b_temp[model1.time()],data1b_temp[self.cmbOutput1Top.currentText()],'-b')
if self.ref_mdl1_top.isChecked():
self.mplOutput1Top.axes.plot(data1_ref_temp[model1.time()],data1_ref_temp[self.cmbOutput1Top.currentText()],'-k')
if self.aad1_mdl1_bottom.isChecked():
self.mplOutput1Bottom.axes.plot(data1_temp[model1.time()],data1_temp[self.cmbOutput1Bottom.currentText()],'-r')
if self.aad2_mdl1_bottom.isChecked():
self.mplOutput1Bottom.axes.plot(data1b_temp[model1.time()],data1b_temp[self.cmbOutput1Bottom.currentText()],'-b')
if self.ref_mdl1_bottom.isChecked():
self.mplOutput1Bottom.axes.plot(data1_ref_temp[model1.time()],data1_ref_temp[self.cmbOutput1Bottom.currentText()],'-k')
self.mplOutput1Top.axes.set_xlim(self.xaxis_mdl1_from.value(), self.xaxis_mdl1_to.value())
self.mplOutput1Bottom.axes.set_xlim(self.xaxis_mdl1_from.value(), self.xaxis_mdl1_to.value())
self.mplOutput1Top.draw()
self.mplOutput1Bottom.draw()
def plotselection(self):
global data1_ref, data1, data1b
if len(self.cmbOutput1Top.currentText()) > 1:
self.mplOutput1Top.axes.clear()
self.mplOutput1Bottom.axes.clear()
#self.mplOutput1Top.axes.hold(True)
#self.mplOutput1Bottom.axes.hold(True)
for k, item in enumerate(data1):
data1_temp = data1[k]
data1b_temp = data1b[k]
data1_ref_temp = data1_ref[k]
if self.aad1_mdl1_top.isChecked():
self.mplOutput1Top.axes.plot(data1_temp[model1.time()],data1_temp[self.cmbOutput1Top.currentText()],'-r')
if self.aad2_mdl1_top.isChecked():
self.mplOutput1Top.axes.plot(data1b_temp[model1.time()],data1b_temp[self.cmbOutput1Top.currentText()],'-b')
if self.ref_mdl1_top.isChecked():
self.mplOutput1Top.axes.plot(data1_ref_temp[model1.time()],data1_ref_temp[self.cmbOutput1Top.currentText()],'-k')
if self.aad1_mdl1_bottom.isChecked():
self.mplOutput1Bottom.axes.plot(data1_temp[model1.time()],data1_temp[self.cmbOutput1Bottom.currentText()],'-r')
if self.aad2_mdl1_bottom.isChecked():
self.mplOutput1Bottom.axes.plot(data1b_temp[model1.time()],data1b_temp[self.cmbOutput1Bottom.currentText()],'-b')
if self.ref_mdl1_bottom.isChecked():
self.mplOutput1Bottom.axes.plot(data1_ref_temp[model1.time()],data1_ref_temp[self.cmbOutput1Bottom.currentText()],'-k')
self.mplOutput1Top.axes.set_xlim(self.xaxis_mdl1_from.value(), self.xaxis_mdl1_to.value())
self.mplOutput1Bottom.axes.set_xlim(self.xaxis_mdl1_from.value(), self.xaxis_mdl1_to.value())
self.mplOutput1Top.draw()
self.mplOutput1Bottom.draw()
def xaxis_adjustment1(self):
self.mplOutput1Top.axes.set_xlim(self.xaxis_mdl1_from.value(), self.xaxis_mdl1_to.value())
self.mplOutput1Top.draw()
self.mplOutput1Bottom.axes.set_xlim(self.xaxis_mdl1_from.value(), self.xaxis_mdl1_to.value())
self.mplOutput1Bottom.draw()
def resetaxes(self):
self.xaxis_mdl1_from.setValue(0)
self.xaxis_mdl1_to.setValue(1000)
def savecsv1(self):
global model1, data1, data1_ref, data1b
export_mdl1 = QtWidgets.QFileDialog.getSaveFileName(self, 'Save File', '', "CSV (*.csv);;Text (*.txt);;All Files (*.*)")
main1 = export_mdl1[0][:-4]
ext1 = export_mdl1[0][-4:]
export_mdl1_top = ''.join(main1)+("_Top")+''.join(ext1)
with open(export_mdl1_top,'wb') as f1_top:
for k, item in enumerate(data1):
#print k
data1_temp = data1[k]
data1b_temp = data1b[k]
data1_ref_temp = data1_ref[k]
max_length = np.max([len(data1_ref_temp[model1.time()]),len(data1_temp[model1.time()]),len(data1b_temp[model1.time()])])
time1_ref_temp = np.concatenate((data1_ref_temp[model1.time()], np.zeros(max_length-len(data1_ref_temp[model1.time()])+1)))
time1_temp = np.concatenate((data1_temp[model1.time()], np.zeros(max_length-len(data1_temp[model1.time()])+1)))
time1b_temp = np.concatenate((data1b_temp[model1.time()], np.zeros(max_length-len(data1b_temp[model1.time()])+1)))
val1_ref_temp = np.concatenate((data1_ref_temp[self.cmbOutput1Top.currentText()], np.zeros(max_length-len(data1_ref_temp[self.cmbOutput1Top.currentText()])+1)))
val1_temp = np.concatenate((data1_temp[self.cmbOutput1Top.currentText()], np.zeros(max_length-len(data1_temp[self.cmbOutput1Top.currentText()])+1)))
val1b_temp = np.concatenate((data1b_temp[self.cmbOutput1Top.currentText()], np.zeros(max_length-len(data1b_temp[self.cmbOutput1Top.currentText()])+1)))
np.savetxt(f1_top, np.c_[time1_ref_temp, val1_ref_temp, time1_temp, val1_temp, time1b_temp, val1b_temp], delimiter=',', footer='\n\n')
#np.savetxt(f1_top, np.c_[data1_ref_temp[model1.time()], data1_ref_temp[self.cmbOutput1Top.currentText()], data1_temp[self.cmbOutput1Top.currentText()], data1b_temp[self.cmbOutput1Top.currentText()]], delimiter=',')
export_mdl1_bottom = ''.join(main1)+("_Bottom")+''.join(ext1)
with open(export_mdl1_bottom,'wb') as f1_bottom:
for k, item in enumerate(data1):
data1_temp = data1[k]
data1b_temp = data1b[k]
data1_ref_temp = data1_ref[k]
max_length = np.max([len(data1_ref_temp[model1.time()]),len(data1_temp[model1.time()]),len(data1b_temp[model1.time()])])
time1_ref_temp = np.concatenate((data1_ref_temp[model1.time()], np.zeros(max_length-len(data1_ref_temp[model1.time()])+1)))
time1_temp = np.concatenate((data1_temp[model1.time()], np.zeros(max_length-len(data1_temp[model1.time()])+1)))
time1b_temp = np.concatenate((data1b_temp[model1.time()], np.zeros(max_length-len(data1b_temp[model1.time()])+1)))
val1_ref_temp = np.concatenate((data1_ref_temp[self.cmbOutput1Bottom.currentText()], np.zeros(max_length-len(data1_ref_temp[self.cmbOutput1Bottom.currentText()])+1)))
val1_temp = np.concatenate((data1_temp[self.cmbOutput1Bottom.currentText()], np.zeros(max_length-len(data1_temp[self.cmbOutput1Bottom.currentText()])+1)))
val1b_temp = np.concatenate((data1b_temp[self.cmbOutput1Bottom.currentText()], np.zeros(max_length-len(data1b_temp[self.cmbOutput1Bottom.currentText()])+1)))
np.savetxt(f1_bottom, np.c_[time1_ref_temp, val1_ref_temp, time1_temp, val1_temp, time1b_temp, val1b_temp], delimiter=',', footer='\n\n')
#np.savetxt(f1_bottom, np.c_[data1_ref_temp[model1.time()], data1_ref_temp[self.cmbOutput1Bottom.currentText()], data1_temp[self.cmbOutput1Bottom.currentText()], data1b_temp[self.cmbOutput1Bottom.currentText()]], delimiter=',')
class MyokitProgressReporter(myokit.ProgressReporter):
target = None
msgvar = None
def __init__(self, tar=None):
self.target = tar
def enter(self, msg=None):
print("Starting sim...")
def exit(self):
#self.target.clearMessage()
print("Done!")
def update(self, progress):
val = progress * 100.0
#print("Progress = " + str(progress))
#self.target.setValue(int(val))
self.target.showMessage(self.msgvar + " Progress: " + str(val) + "%", 2000);
QtWidgets.QApplication.processEvents(QtCore.QEventLoop.ExcludeUserInputEvents)
#QtGui.QApplication.processEvents(QtCore.QEventLoop.ExcludeUserInputEvents)
return True
def run():
app = QtWidgets.QApplication(sys.argv)
#app = QtGui.QApplication(sys.argv)
myWindow = MyWindowClass(None)
myWindow.show()
app.exec_()
run() | ADMIRE-maastricht | /ADMIRE_maastricht-1.1.1.1.zip/ADMIRE_maastricht-1.1.1.1/ADMIRE_maastricht/__init__.py | __init__.py |
import numpy as np
from scipy import stats
import scipy.linalg as la
import FTIRE
__all__ = ['FT']
#%%
class FT:
"""FT method to apply for X and Y"""
def __init__(self, X, y, d = 1, m = 30, weighted = False, W = None, spX = False):
self.d = d
self.m = m
self.X = np.array(X)
self.y = np.array(y)
self.M = None
self.B = None
self.values = None
self.pval = None
self.test = None
self.weighted = weighted
self.W = W
self.spX = spX
def __str__(self):
return "This is FT method (standardized f(y)) applied for {} dimension reduction with m={} and weight={}.".format(self.d, self.m, self.weighted)
def dr(self, d = None):
if d is None:
d = self.d
n, p = self.X.shape
## kernel matrix
self.kernel()
## covariance matrix
# n = self.X.shape[0]
covX = FTIRE.SpCov.spcovCV(self.X) if self.spX else np.cov(self.X.T)
## SVD
if p == 1:
self.B = np.ones((p,d))
elif n < p:
self.B = np.zeros((p,d))
else:
self.values, vectors = la.eigh(self.M, covX)
decsort = np.argsort(self.values)[::-1]
self.B = vectors[:,decsort[range(d)]]
return covX
def upd(self):
""" update dimension d """
self.testd()
self.d = next((i for i, j in enumerate(self.pval > 0.05) if j), None)
if self.d is None:
self.d = self.X.shape[1]
self.dr(self.d)
return self.B
def transformX(self):
self.dr(self.d)
newX = self.X @ self.B
return newX
def kernel(self, weighted=None):
if weighted is None:
weighted = self.weighted
n, p = self.X.shape
self.y = self.y.T.reshape(n,-1)
q = self.y.shape[1]
X0 = self.X - np.mean(self.X, axis = 0)
if self.W is None:
sig = 0.1 * np.pi ** 2/ np.median(la.norm(self.y, axis = 1) **2)
self.W = np.random.rand(q, self.m) * sig
# Mxy = np.zeros((p, 2*self.m))
My = np.zeros((n, 2*self.m))
for i in range(self.m):
w = self.W[:,i]
if q > 1:
w = w/( np.linalg.norm(self.W[:,i]) * np.ones((1,q)) )
yw = self.y @ w.T #* 2 * np.pi
cosy = np.array(np.cos(yw))
cosy = (cosy - np.mean(cosy, axis = 0))/np.std(cosy, axis = 0)
My[:, 2*i] = np.array(cosy).reshape(-1)
siny = np.sin(yw)
siny = (siny - np.mean(siny, axis = 0))/np.std(siny, axis = 0)
My[:, 2*i + 1] = np.array(siny).reshape(-1)
sigcov = np.cov(np.concatenate((X0, My), axis = 1),rowvar=False)
sigxf = sigcov[0:p, p:]
sigff = sigcov[p:, p:]
if weighted:
ivcovy = self.matpower(cov = sigff, a = -1)
self.M = sigxf @ ivcovy @ sigxf.T
else:
self.M = sigxf @ sigxf.T
return sigxf
def testd(self):
n, p = self.X.shape
## kernel matrix
self.kernel()
## covariance matrix
covX = FTIRE.SpCov.spcovCV(self.X) if self.spX else np.cov(self.X.T)
## SVD
self.values, vectors = la.eigh(self.M, covX)
## Sequential Tests
decsort = np.argsort(np.abs(self.values))[::-1]
self.pval = self.test = np.zeros(p)
for r in range(p):
self.test[r] = n * np.sum(self.values[decsort[r:p]])
self.pval[r] = 1 - stats.chi2.cdf(self.test[r], (p-r)*(2*self.m-r))
return covX
def matpower(cov, a, err=1e-3):
value, vector = la.eigh(cov)
indv = value > err
trcov = vector[:,indv] @ np.diag(np.power(value[indv], a)) @ vector[:,indv].T
return trcov | ADMMFTIRE | /ADMMFTIRE-0.0.3.tar.gz/ADMMFTIRE-0.0.3/FTIRE/FT.py | FT.py |
import numpy as np
import scipy.linalg as la
import sys
import dcor
from sklearn.model_selection import KFold # import KFold
import FTIRE
ft = FTIRE.FT.FT
sir = FTIRE.SIR.SIR
__all__ = ["estimate", "CV"]
def projloss(B, b):
"""
Projection Distance between B and b matrices
Args:
B: p times d matrix
b: p times d estimated matrix
Returns:
projection norm loss
"""
if np.linalg.cond(B) < 1/sys.float_info.epsilon and np.linalg.cond(b) < 1/sys.float_info.epsilon:
#np.isfinite(np.linalg.cond(B)) and np.isfinite(np.linalg.cond(b)):
loss = la.norm(B @ la.solve(B.T @ B, B.T) - b @ la.solve(b.T @ b, b.T), 2)
else:
loss = 100
return(loss)
def corrloss(B, b, sigt = None, sigs = None):
"""
distance correlation between B and b
Args:
B: p times d matrix
b: p times d estimated matrix
Returns:
distance correlation
"""
if np.linalg.cond(B) < 1/sys.float_info.epsilon and np.linalg.cond(b) < 1/sys.float_info.epsilon: #np.isfinite(np.linalg.cond(B)) and np.isfinite(np.linalg.cond(b)):
if sigt is None:
p = b.shape[0]
sigt = np.diag(np.ones(p))
if sigs is None:
p = B.shape[0]
sigs = np.diag(np.ones(p))
## normalize B and b
B = B @ la.inv(la.sqrtm(B.T @ sigs @ B))
b = b @ la.inv(la.sqrtm(b.T @ sigt @ b))
d = B.shape[1]
loss = np.trace(la.solve(B.T @ sigs @ B, B.T @ sigs @ b) @ la.solve(b.T @ sigs @ b, b.T @ sigs @ B))/d
else:
loss = 0
return(loss)
def updateC(B, Ups):
## update C
UpsB = (Ups).T @ B
W1, D, W2 = la.svd(UpsB, full_matrices=False)
C = W2 @ W1.T ##!
return(C)
def estimate(X, y, d, m, lamb, method = "ft", NoB = 5, NoC = 20, NoW=2, spX=False, standard=False):
"""
Estimate B
Args:
X: covariates
y: outcome
d: structural dimension
m: number of transfroms
lamb: regularization parameter
method: "ft" or "sir"
NoB: number of iterate over B within ADMM
NoC: number of iterate over C
NoW: number of updating weights
spX: sparse X or not
standard: standardize X or not
Returns:
B: estimate
covxx: covariance matrix of X
err2: differences between objective functions since last step
"""
## init B, C, Ups
[n,p] = X.shape
sdr = sir(X = X, y = y, d = d, n_slice = m) if method=='sir' else ft(X = X, y = y,d = d, m = m)
Ups = sdr.kernel() # phi: p X 2m, My: n X 2m
# initial B
# ft.kernel()
M = sdr.M
_, B = la.eigh(M, eigvals = (p-d,p-1))
## update C
C = updateC(B, Ups)
## Covariance
covxx = FTIRE.SpCov.spcovCV(X, standard = standard) if spX else np.cov(X.T)
## initial weight
weight = np.ones(p)
def updateB(C, weight, lamb):
rho = 1
Z = np.zeros((p,d))
U = np.zeros((p,d))
for i in range(NoB):
## update B
B = la.solve(covxx + rho * np.eye(p), Ups @ C.T + rho*Z - rho*U) #speed up
## update Z
Zold = Z.copy()
lambj = lamb * weight
K = np.maximum(1 - lambj/(rho* la.norm(B + U, axis = 1)), np.zeros(p))
Z = np.diag(K) @ (B+U)
## update U
U = U + (B-Z)
#stop criteria
epsabs = 1e-4
epsrel = 1e-4
epspri = np.sqrt(p) * epsabs + epsrel * max(la.norm(B), la.norm(Z))
epsdual = np.sqrt(p) * epsabs + epsrel * la.norm(U)
# err = max(la.norm(B-Z), la.norm(rho*(Zold-Z)))
# if i == 99:
# print('admm %i times' %100)
if (la.norm(B-Z) < epspri) and (la.norm(rho*(Zold-Z)) < epsdual):
# print('admm %i times' %i)
break
return(Z)
err2 = np.zeros((NoW,NoC+1))
for j in range(NoW):
oldB = B
err2[j, 0] = np.trace( - Ups.T @ B @ C + C.T @ B.T @ covxx @ B @ C) + lamb * np.dot(weight[np.logical_not(np.isinf(weight))], la.norm(B[np.logical_not(np.isinf(weight)),:], axis = 1))
for k in range(NoC):
## update B
B = updateB(C, weight, lamb)
## update C
C = updateC(B, Ups)
## stop criteria
err2[j, k+1] = np.trace( - Ups.T @ B @ C + C.T @ B.T @ covxx @ B @ C) + lamb * np.dot(weight[np.logical_not(np.isinf(weight))], la.norm(B[np.logical_not(np.isinf(weight)),:], axis = 1))
# err2 = np.append(err2, np.trace( - Ups.T @ B @ C + C.T @ B.T @ covxx @ B @ C) + lamb * np.dot(weight[np.logical_not(np.isinf(weight))], la.norm(B[np.logical_not(np.isinf(weight)),:], axis = 1)) )
if np.isclose(err2[j, k], 0):
break
else:
if abs(err2[j, k+1] - err2[j, k])/abs(err2[j, k]) < 1e-4:
break
# update weight
Bnorm = la.norm(B, axis = 1)
close0 = np.isclose(Bnorm, np.zeros(p))
weight[close0] = np.inf
no0 = np.logical_not(close0)
weight[no0] = (1/Bnorm[no0]) ** 1/2
weight[no0] = weight[no0]/min(weight[no0]) if sum(no0) > 1 else weight[no0]
# stop criteria for updating weight
if np.isclose(la.norm(oldB), 0):
break
else:
if projloss(oldB,B)/la.norm(oldB) < 1e-4:
# print('update weight %i times' %j)
break
return B, covxx, err2
# cross validation
def CV(X, y, d, m, method="ft", nolamb = 50, nofold=10, NoB = 5, NoC = 20, NoW=2, spX=False, standard=False):
"""
Estimate B using the best lambda with cross-validation
Args:
X: covariates
y: outcome
d: structural dimension
m: number of transfroms
method: "ft" or "sir"
nolamb: the number of lambda
nofold: the number of fold
NoB: number of iterate over B within ADMM
NoC: number of iterate over C
NoW: number of updating weights
spX: sparse X or not
standard: standardize X or not
Returns:
B: estimate
covxx: covariance matrix of X
lambcv: best lambda
minimum loss
"""
## par.
#method = 'sir' # or 'ft'
#nofold = 10
#nolamb = 50
#spX = False
#standard = False
#NoB = 5
#NoC = 20
#NoW = 2
## generate lambda candidate
lambmax = 1 #np.max(sdr0.M)/10
lambmin = lambmax/1000 if method == 'sir' else lambmax/10
lambseq = np.exp(np.linspace(np.log(lambmin), np.log(lambmax), num=nolamb))
kf = KFold(n_splits=nofold)
cvloss = np.zeros((nofold, nolamb))
k = 0
for train_index, test_index in kf.split(X):
print('Fold-', k)
X_train, X_test = X[train_index], X[test_index]
y_train, y_test = y[train_index], y[test_index]
#print("TRAIN:", (X_train.shape), "TEST:", (X_test.shape))
for i in range(nolamb):
Btrain = estimate(X_train,
y_train,
d,
m,
lambseq[i],
method,
NoB,
NoC,
NoW,
spX,
standard
)[0] # estimate(X, y, d, m, lamb, method = "ft", NoB = 5, NoC = 20, NoW=2, spX=False, standard=False)
if np.linalg.cond(Btrain) < 1/sys.float_info.epsilon:
sigs = np.cov(X_train.T)
Btrain = Btrain @ la.inv(la.sqrtm(Btrain.T @ sigs @ Btrain))
cvloss[k, i] = 1 - dcor.distance_correlation(X_test @ Btrain, y_test)/d
else:
cvloss[k, i] = 100
k = k + 1
l_mean = np.mean(cvloss, axis = 0)
lambcv = lambseq[np.argmin(l_mean)]
B, covxx, err= estimate(X, y, d, m, lambcv, method, NoB, NoC, NoW, spX, standard)
return B, covxx, lambcv, np.argmin(l_mean) | ADMMFTIRE | /ADMMFTIRE-0.0.3.tar.gz/ADMMFTIRE-0.0.3/FTIRE/ftire.py | ftire.py |
import numpy as np
from scipy import stats
import scipy.linalg as la
import FTIRE
__all__ = ['SIR']
class SIR:
"""SIR method to apply for X and Y"""
def __init__(self, X, y, d = 1, n_slice = 10, spX = False):
self.d = d
self.n_slice = n_slice
self.X = np.array(X)
self.y = np.array(y)
self.M = None
self.B = None
self.values = None
self.pval = None
self.test = None
self.spX = spX
def __str__(self):
return "This is SIR method applied for {} dimension reduction with {} slices.".format(self.d, self.n_slice)
def dr(self, d = None):
if d is None:
d = self.d
n, p = self.X.shape
## kernel matrix
self.kernel()
## covariance matrix
# n = self.X.shape[0]
covX = FTIRE.SpCov.spcovCV(self.X) if self.spX else np.cov(self.X.T)
## SVD
if p == 1:
self.B = np.ones((p,d))
elif n < p:
self.B = np.zeros((p,d))
else:
self.values, vectors = la.eigh(self.M, covX)
decsort = np.argsort(self.values)[::-1]
self.B = vectors[:,decsort[range(d)]]
return covX
def upd(self):
""" update dimension d """
self.testd()
self.d = next((i for i, j in enumerate(self.pval > 0.05) if j), None)
if self.d is None:
self.d = self.X.shape[1]
self.dr(self.d)
return self.B
def transformX(self):
self.dr(self.d)
newX = self.X @ self.B
return newX
def kernel(self):
n, p = self.X.shape
X0 = self.X - np.mean(self.X, axis = 0)
# slice y into n_slice
YI = np.argsort(self.y.reshape(-1))
split = np.array_split(YI, self.n_slice)
## kernel matrix
self.M = np.zeros((p, p))
Ups = np.zeros((p, self.n_slice))
for i in range(self.n_slice):
if p == 1:
tt = X0[split[i]].reshape(-1, p)
else:
tt = X0[split[i],].reshape(-1, p)
Xh = np.mean(tt, axis = 0).reshape(p, 1)
Ups[:,i] = np.sqrt(len(split[i])/n) * Xh.reshape(-1)
self.M = self.M + Xh @ Xh.T * len(split[i])/n
return Ups
def testd(self):
n, p = self.X.shape
## kernel matrix
self.kernel()
## covariance matrix
covX = FTIRE.SpCov.spcovCV(self.X) if self.spX else np.cov(self.X.T)
## SVD
self.values, vectors = la.eigh(self.M, covX)
## Sequential Tests
decsort = np.argsort(np.abs(self.values))[::-1]
self.pval = self.test = np.zeros(p)
for r in range(p):
self.test[r] = n * np.sum(self.values[decsort[r:p]])
self.pval[r] = 1 - stats.chi2.cdf(self.test[r], (p-r)*(self.n_slice-1-r))
return covX | ADMMFTIRE | /ADMMFTIRE-0.0.3.tar.gz/ADMMFTIRE-0.0.3/FTIRE/SIR.py | SIR.py |
import numpy as np
import scipy.linalg as la
__all__ = ['generateX', 'generateY']
def generateX(n, p, covstr):
"""
Generate X for simulation
Args:
n (int): sample size
p (int): number of dimension of X
covstr (0-3): covariance structure
Returns:
X: n times p array
"""
## generate X
if covstr == 0:
covx = np.eye(p)
elif covstr == 1:
v = 0.5 ** np.arange(p)
covx = la.toeplitz(v)
elif covstr == 2:
offdiag = 0.2
covx = np.ones((p,p)) * offdiag
covx = covx + np.eye(p) * (1-offdiag)
elif covstr == 3:
v = 0.8 ** np.arange(p)
covx = la.toeplitz(v)
L = np.linalg.cholesky(covx)
Z = np.random.randn(p,n)
X = (L @ Z).T
return(X)
def generateY(X, M):
"""
Generate Y based on X
Args:
X: input covariate
M: model 1-7 uni; 10-15 multi
Returns:
Y: outcome
d: structural dimension
p: the dimension of Y
b: the true beta
"""
[n,p] = X.shape
## generate Y
if M == 1: # Qian M1
d = 1
q = 1
b = np.zeros((p,d))
y = np.zeros((n,q))
index = np.arange(5)
b[index,:] = 1
y[:,0] = np.exp(X @ b[:,0]) + np.random.randn(n)
elif M == 2: # Qian M2
d = 2
q = 1
b = np.zeros((p,d))
y = np.zeros((n,q))
index1 = np.arange(4) #np.random.randint(p, size = 5)
index2 = np.arange(p-4,p)
b[index1,0] = 1
b[index2, 1] = 1
y[:,0] = np.sign(X @ b[:,0]) * np.log( np.abs( X @ b[:,1] + 5 ) ) + 0.2 * np.random.randn(n)
elif M == 3: # Tan AOS Model 1
d = 1
q = 1
b = np.zeros((p,d))
y = np.zeros((n,q))
index = np.arange(5)
b[index,:] = 1
y[:,0] = np.sin(X @ b[:,0]) ** 2 + X @ b[:,0] + np.random.randn(n)
elif M == 4: # Tan AOS Model 2
d = 1
q = 1
b = np.zeros((p,d))
y = np.zeros((n,q))
index = np.arange(5)
b[index,:] = 1
y[:,0] = 2 * np.tanh(X @ b[:,0]) + np.random.randn(n)
elif M == 5: # Cook Zhang
d = 1
q = 1
b = np.zeros((p,d))
index = np.arange(1)
b[index,:] = 1
X = 1/4 * np.sqrt(0.1) * ( np.random.randn(p,n) + 1) + 1/2 * np.sqrt(0.1) * ( np.random.randn(p,n) + 2 ) + 1/4 * np.sqrt(10) * (np.random.randn(p,n) + 1)
X = X.T
y = np.abs( np.sin( X @ b[:,0] ) ) + 0.2 * np.random.randn(n)
elif M == 6:
d = 2
q = 1
b = np.zeros((p,d))
b[0,0] = 1
b[1,1] = 1
X[:,1] = X[:,0] + X[:,1]
X[:,3] = ( 1+X[:,1] ) * X[:,3]
y = X @ b[:,0] + 0.5 * (X @ b[:,1])** 2
elif M == 7:
d = 2
q = 1
b = np.zeros((p,d))
y = np.zeros((n,q))
index1 = np.arange(1)
index2 = np.arange(1,3)
b[index1,0] = 1
b[index2, 1] = 1
y = (X @ b[:,0]) * (X @ b[:,1] + 1) + np.random.randn(n)
elif M == 10:
## simple
d = 2
q = 3
b = np.zeros((p,d))
y = np.zeros((n,q))
#index = np.random.randint(p, size = 5)
index = np.arange(5)
b[index[0:2], 0] = 1
b[index[2:], 1] = 1
y[:,0] = np.exp( X @ b[:,0]) + 0.5 * np.random.randn(n)
y[:,1] = X @ b[:,1] + 0.1 * np.random.randn(n)
y[:,2] = 0.1 * np.random.randn(n)
elif M == 11: ## Zhu Zhu wen 2010 Example 3
## complex
d = 2
q = 5
covy = np.diag([1,1/2,1/2,1/3,1/4])
covy[0,1] = covy[1,0] = -1/2
L = np.linalg.cholesky(covy)
Z = np.random.randn(q,n)
eps = (L @ Z).T
b = np.zeros((p,d))
y = np.zeros((n,q))
index = np.arange(3) #np.random.randint(p, size = 5)
b[index[0], 0] = 1
b[index[1:], 1] = 1
y[:,0] = 1 + X @ b[:,0] + np.sin(X @ b[:,1]) + eps[:,0]
y[:,1] = X @ b[:,1] / (0.5 + (X @ b[:,0])**2) + eps[:,1]
y[:,2] = np.abs(X @ b[:,1]) * eps[:,2]
y[:,3] = eps[:,3]
y[:,4] = eps[:,4]
elif M == 12: ## Zhu Zhu wen 2010 Example 2 and Bing Li 2008 Model 4.3
d = 1
q = 2
b = np.zeros((p,d))
b[0:2,0] = [0.8, 0.6]
top = np.ones((n,2))
top[:,1] = np.sin(X @ b[:,0])
y = np.zeros((n,q))
for i in range(n):
covy = la.toeplitz(top[i,:])
L = np.linalg.cholesky(covy)
Z = np.random.randn(q,1)
y[i,:] = (L @ Z).T
elif M == 13: # Bing Li, Weng, Li 2008 Model 4.1
d = 2
q = 4
covy = np.diag([1,1,1,1])
covy[0,1] = covy[1,0] = -1/2
L = np.linalg.cholesky(covy)
Z = np.random.randn(q,n)
eps = (L @ Z).T
b = np.zeros((p,d))
y = np.zeros((n,q))
index = range(3)
b[index[0:1], 0] = 1
b[index[1:], 1] = [2,1]
y[:,0] = X @ b[:,0] + eps[:,0]
y[:,1] = X @ b[:,1] + eps[:,1]
y[:,2] = eps[:,2]
y[:,3] = eps[:,3]
elif M == 14: # Bing li 2008 Model 4.2
d = 1
q = 4
b = np.zeros((p,d))
b[0:2,0] = [0.8, 0.6]
top = np.sin(X @ b[:,0])
y = np.zeros((n,q))
for i in range(n):
covy = np.eye(q)
covy[0,1] = covy[1,0] = top[i]
L = np.linalg.cholesky(covy)
Z = np.random.randn(q,1)
eps = (L @ Z).T
y[i,:] = eps
y[i,0] = np.exp(eps[0,0])
elif M == 15: # Bing Li 08 Model 4.4
d = 2
q = 5
covy = np.diag([1,1/2,1/2,1/3,1/4])
covy[0,1] = covy[1,0] = -1/2
L = np.linalg.cholesky(covy)
Z = np.random.randn(q,n)
eps = (L @ Z).T
b = np.zeros((p,d))
y = np.zeros((n,q))
index = np.arange(5) #np.random.randint(p, size = 5)
b[index[0:2], 0] = 1
b[index[2:], 1] = 1
y[:,0] = X @ b[:,0] + X @ b[:,1] / (0.5 + (X @ b[:,0])**2) + eps[:,0]
y[:,1] = X @ b[:,0] + np.exp( 0.5 * X @ b[:,1]) + eps[:,1]
y[:,2] = X @ b[:,0] + X @ b[:,1] + eps[:,2]
y[:,3] = eps[:,3]
y[:,4] = eps[:,4]
return y, d, q, b | ADMMFTIRE | /ADMMFTIRE-0.0.3.tar.gz/ADMMFTIRE-0.0.3/FTIRE/genxy.py | genxy.py |
<!--
* @Description:
* @Author: SongJ
* @Date: 2020-12-29 13:52:28
* @LastEditTime: 2021-04-12 10:44:01
* @LastEditors: SongJ
-->
## 自适应密度峰值树聚类（Adaptive Density Peak Tree Clustering）
本算法是在快速搜索与发现密度峰值聚类算法（Clustering by fast search and find of density peaks）CFSFDP的基础上进行改进的成果，主要解决的问题有:
- 手动选择聚类中心
- 单簇多密度峰值导致类簇误分
- 面向时空数据聚类时，无法顾及时空耦合
### 原理：
通过CFSFDP算法的核心概念：局部密度和斥群值，构建密度峰值树，通过直达点、连通点和切割点分离子树，达到类簇划分的目的。
<img src="https://cdn.jsdelivr.net/gh/SuilandCoder/PicStorage//img/image-20210409210616098.png" alt="image-20210409210616098" style="zoom: 80%;" />
### 使用方法：
#### 1. 安装:
```python
pip install ADPTC-LIB
```
#### 2. 空间数据聚类：
```python
import numpy as np
from ADPTC_LIB.cluster import ADPTC
from ADPTC_LIB import visual
X = np.loadtxt(r"../test_data/Aggregation.txt", delimiter="\t")
X = X[:,[0,1]]
atdpc_obj = ADPTC(X)
atdpc_obj.clustering(2)
visual.show_result(atdpc_obj.labels,X,np.array(list(atdpc_obj.core_points)))
```
#### 3. 空间属性数据聚类：
```python
from ADPTC_LIB.cluster import ADPTC
from ADPTC_LIB import visual
import xarray as xr
import os
import numpy as np
filePath = os.path.join(r'Z:\regions_daily_010deg\\05\\2013.nc')
dataset = xr.open_dataset(filePath)
pre_ds = dataset['precipitation']
lon = pre_ds.lon
lat = pre_ds.lat
lon_range = lon[(lon>-30)&(lon<70)]
lat_range = lat[(lat>30)&(lat<90)]
var = pre_ds.sel(lon=lon_range,lat = lat_range)
var = var.resample(time='1M',skipna=True).sum()
var_t = var.sel(time=var.time[0])
reduced = var_t.coarsen(lon=5).mean().coarsen(lat=5).mean()
data_nc = np.array(reduced)
spatial_eps=4
attr_eps=8
density_metric='gauss'
spre = ADPTC(data_nc)
spre.spacial_clustering_raster(spatial_eps,attr_eps,density_metric,knn_num=100,leaf_size=3000,connect_eps=0.9)
visual.show_result_2d(reduced,spre.labels)
```
#### 4.时空属性聚类：
```python
from ADPTC_LIB.cluster import ADPTC
from ADPTC_LIB import visual
import xarray as xr
import numpy as np
temp= xr.open_dataset(r'Z:\MSWX\temp\2020.nc')
temp_2020 = temp['air_temperature']
lon = temp_2020.lon
lat = temp_2020.lat
time = temp_2020.time
lon_range = lon[(lon>70)&(lon<140)]
lat_range = lat[(lat>15)&(lat<55)]
var = temp_2020.sel(lon=lon_range,lat = lat_range)
reduced = var.coarsen(lon=5).mean().coarsen(lat=5).mean()
data_nc = np.array(reduced)
s_eps = 5
t_eps = 1
attr_eps = 2.5
density_metric='gauss'
spre = ADPTC(data_nc)
spre.st_clustering_raster(s_eps,t_eps,attr_eps,density_metric,knn_num=100,leaf_size=3000,connect_eps=0.9)
visual.show_result_3d(reduced,spre,[70, 140, 15, 50],[0,12],21)
```
 | ADPTC-LIB | /ADPTC_LIB-0.0.7.tar.gz/ADPTC_LIB-0.0.7/README.md | README.md |
import time
import xarray as xr
import math
import matplotlib.pyplot as plt
import numba
import numpy as np
from numba import jit, njit
from scipy.spatial.distance import pdist, squareform
from sklearn.neighbors import BallTree, DistanceMetric, KDTree
from . import DPTree
# from DPTree import DPTree, label_these_node, split_cluster
# from DPTree_ST import (DPTree, label_these_node, label_these_node_new,
# label_these_node_new2, split_cluster_new, split_outlier)
from . import DPTree_ST
def fn_timer(*args,**kwargs):
def mid_fn(function):
def function_timer(*in_args, **kwargs):
t0 = time.time()
result = function(*in_args, **kwargs)
t1 = time.time()
print (" %s: %s seconds" %
(args[0], str(t1-t0))
)
return result
return function_timer
return mid_fn
def check_netcdf(X):
if type(X)!=xr.DataArray:
raise ValueError("Only support datatype DataArray of xarray, please handle netcdf data by the library xarray.")
# 二维栅格数据转换为样本点数据，每个网格为一个样本点
def rasterArray_to_sampleArray(data):
rows,cols = data.shape
data_all = np.zeros((rows*cols,3))
num = 0
for i in range(rows):
for j in range(cols):
data_all[num,:] = [i,j,data[i,j]]
num+=1
pass
pass
data_all[:,[0,1]]=data_all[:,[1,0]]
not_none_pos = np.where(data_all[:,2]!=0)[0] #* 去除零值后的数据，在全局的位置 [638,629,1004,……] 值为 data_all数据下标
nan_pos = np.where(np.isnan(data_all[:,2]))[0] #* 获取 值为 nan 的下标
not_none_pos = np.setdiff1d(not_none_pos,nan_pos)
data_not_none = data_all[not_none_pos]
pos_not_none = np.full((rows*cols),-1,dtype=np.int64) #* 全局数据中，不为零的下标[-1,-1,0,-1,1,-1,2,3,4,……] 值为 data_not_none 下标
pos_not_none[not_none_pos] = np.array(range(len(not_none_pos)))
return data_not_none,pos_not_none
# 三维时空立方体转换为样本点矩阵，每个单元立方格为一个样本点
def rasterCube_to_sampleArray(data):
times,rows,cols = data.shape
data_not_none = np.zeros((times*rows*cols,4))
data_all = np.zeros((times*rows*cols,4))
num = 0
for i in range(rows):
for j in range(cols):
for k in range(times):
data_all[num,:] = [i,j,k,data[k,i,j]]
num+=1
pass
pass
# data[:,[0,1]]=data[:,[1,0]]
not_none_pos = np.where(data_all[:,3]!=0)[0] #* 去除零值后的数据，在全局的位置 [638,629,1004,……] 值为 data_all数据下标
nan_pos = np.where(np.isnan(data_all[:,3]))[0] #* 获取 值为 nan 的下标
not_none_pos = np.setdiff1d(not_none_pos,nan_pos)
data_not_none = data_all[not_none_pos]
pos_not_none = np.full((times*rows*cols),-1,dtype=np.int64) #* 全局数据中，不为零的下标[-1,-1,0,-1,1,-1,2,3,4,……] 值为 data_not_none 下标
pos_not_none[not_none_pos] = np.array(range(len(not_none_pos)))
return data_not_none,pos_not_none
#* 聚类结果转换为netcdf
def labeled_res_to_netcdf(ori_nc,data_table,labels):
#* 将聚类结果写入DataArray
ori_ndarray = np.array(ori_nc)
dr_labels = np.full(ori_ndarray.shape,-2)
for i in range(len(data_table)):
if(ori_ndarray.ndim==2):
dr_labels[int(data_table[i][1])][int(data_table[i][0])] = labels[i]
elif(ori_ndarray.ndim==3):
dr_labels[int(data_table[i][2])][int(data_table[i][0])][int(data_table[i][1])] = labels[i]
else:
raise ValueError("Two or Three-dimensional matrix is needed")
pass
labeled_res= xr.DataArray(
dr_labels,
coords=ori_nc.coords,
dims=ori_nc.dims
)
ds = xr.Dataset(data_vars = dict(label=labeled_res,attr=ori_nc))
return ds
@fn_timer("计算距离矩阵")
def calc_dist_matrix(data, metric='euclidean'):
dist_mat = squareform(pdist(data, metric=metric))
return dist_mat
def calc_attr_dist_mat(data,attrs_index,metric='euclidean'):
rows = data.shape[0]
try:
attr_dist_mat = squareform(pdist(data[:,attrs_index].reshape(rows, 1),metric=metric))
except:
attr_dist_mat = squareform(pdist(data[:,attrs_index].reshape(rows, 1),metric='euclidean'))
return attr_dist_mat
@fn_timer("计算截断密度")
@njit
def calcu_cutoff_density(dist_mat, eps):
'''
计算截断密度
'''
local_cutoff_density = np.where(dist_mat < eps, 1, 0).sum(axis=1)
local_cutoff_density = local_cutoff_density
return local_cutoff_density
@fn_timer("计算空间属性邻近域")
def calc_homo_near_grid(data,s_eps,attr_eps,pos_not_none):
'''
获取点的空间属性邻近域 mixin_near_matrix
'''
mixin_near_matrix = {}
rows,cols = data.shape
num = 0
for i in range(rows):
for j in range(cols):
#* 计算每个点的邻域范围:
left_lon = i-s_eps if i-s_eps>=0 else 0
rigth_lon = i+s_eps if i+s_eps<rows else rows
up_lat = j-s_eps if j-s_eps>=0 else 0
down_lat = j+s_eps if j+s_eps<cols else cols
s_near = data[left_lon:rigth_lon+1,up_lat:down_lat+1]
if(data[i,j]!=0 and (not np.isnan(data[i,j]))):
pos_s_near = np.where((np.abs(s_near-data[i,j])<=attr_eps) & (s_near!=0) &(~np.isnan(s_near)))
pos_data = np.vstack(pos_s_near) + np.array([[left_lon],[up_lat]])
pos_in_matrix = cols*pos_data[0]+pos_data[1] #* 获取全局邻域位置（全局包含空值点）
pos = pos_not_none[pos_in_matrix]
mixin_near_matrix[num] = pos
num+=1
pass
pass
return mixin_near_matrix
def calc_homo_near_cube(data,s_eps,t_eps,attr_eps,pos_not_none):
'''
获取点的时空属性邻近域 mixin_near_matrix
'''
mixin_near_matrix = {}
time_len,rows,cols = data.shape
num = 0
for i in range(rows):
for j in range(cols):
for k in range(time_len):
#* 计算每个点的邻域范围:
left_lon = i-s_eps if i-s_eps>=0 else 0
rigth_lon = i+s_eps if i+s_eps<rows else rows
up_lat = j-s_eps if j-s_eps>=0 else 0
down_lat = j+s_eps if j+s_eps<cols else cols
early_time = k-t_eps if k-t_eps>=0 else 0
lated_time = k+t_eps if k+t_eps<time_len else time_len
s_near = data[early_time:lated_time+1,left_lon:rigth_lon+1,up_lat:down_lat+1]
# s_near = s_near[np.where(~np.isnan(s_near) & (s_near!=0))]
if(data[k,i,j]!=0 and (not np.isnan(data[k,i,j]))):
pos_s_near = np.where((np.abs(s_near-data[k,i,j])<=attr_eps) & (s_near!=0) &(~np.isnan(s_near)))
pos_data = np.vstack(pos_s_near) + np.array([[early_time],[left_lon],[up_lat]])
pos_in_matrix = time_len*cols*pos_data[1]+time_len*pos_data[2]+pos_data[0] #* 获取全局邻域位置（全局包含空值点）
pos = pos_not_none[pos_in_matrix]
mixin_near_matrix[num] = pos
num+=1
pass
pass
pass
return mixin_near_matrix
@fn_timer("计算高斯密度")
def calc_gaus_density_spatial(data,s_eps,attr_eps):
'''
此处 data 为空间栅格矩阵数据，行列分别为：lon,lat
'''
rows,cols = data.shape
zero_num = np.where(data==0,1,0).sum()
nan_num = np.where(np.isnan(data),1,0).sum()
density_list_len = rows*cols - zero_num - nan_num
density = np.zeros(density_list_len,dtype=np.float32)
num = 0
for i in range(rows):
for j in range(cols):
#* 计算每个点的邻域范围:
left_lon = i-s_eps if i-s_eps>=0 else 0
rigth_lon = i+s_eps if i+s_eps<rows else rows
up_lat = j-s_eps if j-s_eps>=0 else 0
down_lat = j+s_eps if j+s_eps<cols else cols
s_near = data[left_lon:rigth_lon+1,up_lat:down_lat+1]
s_near = s_near[np.where((~np.isnan(s_near)) & (s_near!=0))]
if(data[i,j]!=0 and (not np.isnan(data[i,j]))):
density[num] = np.exp(-1*((1-(np.abs(s_near-data[i,j])))/attr_eps)**2).sum()
num+=1
pass
pass
return density
@fn_timer("密度计算")
# @njit
def calc_gaus_density_st(data,s_eps,t_eps,attr_eps):
'''
此处 data 为立方体数据，三个维度：time,lon,lat
'''
time_len,rows,cols = data.shape
zero_num = np.where(data==0,1,0).sum()
nan_num = np.where(np.isnan(data),1,0).sum()
density_list_len = time_len*rows*cols - zero_num - nan_num
density = np.zeros(density_list_len,dtype=np.float32)
num = 0
for i in range(rows):
for j in range(cols):
for k in range(time_len):
#* 计算每个点的邻域范围:
left_lon = i-s_eps if i-s_eps>=0 else 0
rigth_lon = i+s_eps if i+s_eps<rows else rows
up_lat = j-s_eps if j-s_eps>=0 else 0
down_lat = j+s_eps if j+s_eps<cols else cols
early_time = k-t_eps if k-t_eps>=0 else 0
lated_time = k+t_eps if k+t_eps<time_len else time_len
s_near = data[early_time:lated_time+1,left_lon:rigth_lon+1,up_lat:down_lat+1]
s_near = s_near[np.where((~np.isnan(s_near)) & (s_near!=0))]
if(data[k,i,j]!=0 and (not np.isnan(data[k,i,j]))):
density[num] = np.exp(-1*((1-(np.abs(s_near-data[k,i,j])))/attr_eps)**2).sum()
num+=1
pass
pass
pass
return density
@fn_timer("计算空间近邻")
def calc_spatial_neighbor(X_spatial,eps,leaf_size):
'''
使用 kdtree 计算空间近邻
主要是借助kdtree解决大数据量的计算问题
'''
tree = KDTree(X_spatial, leaf_size=leaf_size)
ind = tree.query_radius(X_spatial, eps, return_distance=False, count_only=False, sort_results=False)
return ind
@fn_timer("计算时空邻居")
# @njit
def calc_st_neighbor(X_time,eps,spatial_neighbor):
'''
计算时间近邻
'''
st_neighbor = []
flattened_time = X_time.flatten()
rows = len(flattened_time)
for i in range(rows):
cur_spat_neighbor = spatial_neighbor[i]
st_neighbor.append(cur_spat_neighbor[np.where(abs(flattened_time[cur_spat_neighbor]-flattened_time[i])<=eps)[0]])
pass
return np.array(st_neighbor)
# @fn_timer("计算时空邻居")
# def calc_st_neighbor(spatial_neighbor,time_neighbor):
# st_neighbor={}
# rows = spatial_neighbor.shape[0]
# for i in range(rows):
# st_neighbor[i]=np.intersect1d(spatial_neighbor[i],time_neighbor[i])
# pass
# return st_neighbor
@fn_timer("计算混合邻居")
def calc_mixin_near_matrix(space_dist_mat,spatial_eps,attr_dist_mat,attr_eps):
rows = space_dist_mat.shape[0]
mixin_near_matrix = {}
for i in range(rows):
space_near = np.where(space_dist_mat[i,:]<=spatial_eps)[0]
attr_near = np.where(attr_dist_mat[i,:]<=attr_eps)[0]
mixin_near_matrix[i]=np.intersect1d(space_near,attr_near)
return mixin_near_matrix
# @njit
def calc_gaus_density_njit(rows,ind,dist,st_neighbors,eps):
local_gaus_density = np.zeros((rows,),dtype=np.float32)
for i in range(rows):
arg_intersect_ind = np.where(np.in1d(ind[i],st_neighbors[i]))
local_gaus_density[i] = np.exp(-1 *(dist[i][arg_intersect_ind]/eps)**2).sum()
return local_gaus_density
def calc_mixin_near_matrix(rows,ind,st_neighbors):
mixin_near_matrix = {}
for i in range(rows):
arg_intersect_ind = np.where(np.in1d(ind[i],st_neighbors[i]))
mixin_near_matrix[i] = ind[i][arg_intersect_ind]
return mixin_near_matrix
@fn_timer("计算高斯密度")
@njit
def calcu_gaus_density_spatial(near_matrix,dist_mat, eps):
'''
计算高斯密度
'''
rows = dist_mat.shape[0]
local_gaus_density = np.zeros((rows,),dtype=np.float32)
for i in range(rows):
near_nodes = near_matrix[1][np.where(near_matrix[0]==i)]
local_gaus_density[i] = np.exp(-1*((1-dist_mat[i][near_nodes])/eps)**2).sum()
return local_gaus_density
@fn_timer("计算高斯密度")
@njit
def calcu_gaus_density(dist_mat, eps):
'''
计算高斯密度
'''
rows = dist_mat.shape[0]
local_gaus_density = np.zeros((rows,),dtype=np.float32)
for i in range(rows):
local_gaus_density[i] = np.exp(-1 *((dist_mat[i, :])/(eps))**2).sum()
pass
return local_gaus_density
def calc_density(dist_mat,eps,density_metric):
if(density_metric=='gauss'):
return calcu_gaus_density(dist_mat,eps)
else:
return calcu_cutoff_density(dist_mat,eps)
def calc_repulsive_force(data,density,k_num,leaf_size,dist_mat=[],fast=False):
if(fast):
denser_pos,denser_dist,density_and_k_relation = calc_repulsive_force_fast(data,k_num,density,leaf_size)
pass
else:
denser_pos,denser_dist,density_and_k_relation = calc_repulsive_force_classical(data,density,dist_mat)
return denser_pos,denser_dist,density_and_k_relation
@fn_timer("计算斥群值_快速")
def calc_repulsive_force_fast(data, k_num, density, leaf_size):
#* b. 求每个点的k近邻
# tree = BallTree(data,leaf_size=2000,metric=DistanceMetric.get_metric('mahalanobis',V=np.cov(data.T)))
tree = KDTree(data, leaf_size=leaf_size)
dist, ind = tree.query(data, k=k_num)
#* 统计 密度 与 k 值的相关性：
density_and_k_relation = np.zeros((ind.shape[0],2),dtype=np.float32)
#* c. 计算 k近邻点 是否能找到斥群值
denser_dist = np.full(ind.shape[0], -1,dtype=np.float32)
denser_pos = np.full(ind.shape[0],-1,dtype=np.int32)
for i in range(ind.shape[0]):
denser_list = np.where(density[ind[i]]>density[i])[0]
if(len(denser_list)>0):
denser_dist[i] = dist[i][denser_list[0]]
denser_pos[i] = ind[i][denser_list[0]] #* 这个pos为data中的下标，没有属性为空的点
density_and_k_relation[i][0] = density[i]
density_and_k_relation[i][1] = denser_list[0]
pass
#* d. 增加 k值，寻找斥群值:0.
not_found_data = list(np.where(denser_pos==-1)[0])
#* 对密度进行排序，剔除密度最大的点
max_density_idx = not_found_data[np.argmax(density[not_found_data])]
density[max_density_idx] = density[max_density_idx]+1
not_found_data.pop(np.argmax(density[not_found_data]))
num = 1
cur_k = k_num
while(len(not_found_data)>0):
cur_data_id = not_found_data.pop()
cur_k = cur_k+k_num
if(cur_k>=data.shape[0]):
break
cur_dist, cur_ind= tree.query(data[cur_data_id:cur_data_id+1], k=cur_k)
cur_dist, cur_ind = cur_dist[0], cur_ind[0]
denser_list = np.where(density[cur_ind]>density[cur_data_id])
while(len(denser_list[0])==0):
cur_k = cur_k + k_num
# print("cur_k:",cur_k)
if(cur_k>=data.shape[0]):
break
cur_dist, cur_ind= tree.query(data[cur_data_id:cur_data_id+1], k=cur_k)
cur_dist, cur_ind = cur_dist[0], cur_ind[0]
denser_list = np.where(density[cur_ind]>density[cur_data_id])
pass
if(len(denser_list[0])>0):
# print(num)
num = num+1
denser_pos[cur_data_id] = cur_ind[denser_list[0][0]]
denser_dist[cur_data_id] = cur_dist[denser_list[0][0]]
density_and_k_relation[cur_data_id][0] = density[cur_data_id]
density_and_k_relation[cur_data_id][1] = denser_list[0][0]
else:
print("没找到:",cur_data_id)
pass
denser_dist[max_density_idx] = np.max(denser_dist)+1
denser_pos[max_density_idx] =max_density_idx
return denser_pos,denser_dist,density_and_k_relation
@fn_timer("计算斥群值_经典")
def calc_repulsive_force_classical(data,density,dist_mat):
rows = len(data)
#* 密度从大到小排序
sorted_density = np.argsort(density)
#* 初始化，比自己密度大的且最近的距离
denser_dist = np.zeros((rows,))
#* 初始化，比自己密度大的且最近的距离对应的节点id
denser_pos = np.zeros((rows,), dtype=np.int32)
for index,nodeId in enumerate(sorted_density):
nodeIdArr_denser = sorted_density[index+1:]
if nodeIdArr_denser.size != 0:
#* 计算比当前密度大的点之间距离：
over_density_sim = dist_mat[nodeId][nodeIdArr_denser]
#* 获取比自身密度大，且距离最小的节点
denser_dist[nodeId] = np.min(over_density_sim)
min_distance_index = np.argwhere(over_density_sim == denser_dist[nodeId])[0][0]
# 获得整个数据中的索引值
denser_pos[nodeId] = nodeIdArr_denser[min_distance_index]
else:
#* 如果是密度最大的点，距离设置为最大，且其对应的ID设置为本身
denser_dist[nodeId] = np.max(denser_dist)+1
denser_pos[nodeId] = nodeId
return denser_pos,denser_dist,[]
def calc_gamma(density,denser_dist):
normal_den = density / np.max(density)
normal_dis = denser_dist / np.max(denser_dist)
gamma = normal_den * normal_dis
return gamma
@fn_timer("自动聚类")
def extract_cluster_auto_st(data,density,dc_eps,denser_dist,denser_pos,gamma,mixin_near_matrix):
'''
使用 DPTree 进行数据聚类
dc_eps：density-connectivity 阈值
'''
sorted_gamma_index = np.argsort(-gamma)
tree = DPTree_ST.DPTree()
tree.createTree(data,sorted_gamma_index,denser_pos,denser_dist,density,gamma)
outlier_forest, cluster_forest, uncertain_forest=DPTree_ST.split_cluster_new(tree,density,dc_eps,denser_pos,mixin_near_matrix)
labels,core_points = DPTree_ST.label_these_node_new(outlier_forest,cluster_forest,len(data),uncertain_forest,mixin_near_matrix)
core_points = np.array(list(core_points))
labels = labels
return labels, core_points
@fn_timer("自动聚类")
def extract_cluster_auto(data,density,eps,dc_eps,denser_dist,denser_pos,gamma,dist_mat):
'''
使用 DPTree 进行数据聚类
dc_eps：density-connectivity 阈值
'''
sorted_gamma_index = np.argsort(-gamma)
tree = DPTree.DPTree()
tree.createTree(data,sorted_gamma_index,denser_pos,denser_dist,density,gamma)
outlier_forest, cluster_forest=DPTree.split_cluster(tree,density,dist_mat,eps,dc_eps,denser_dist)
labels,core_points = DPTree.label_these_node(outlier_forest,cluster_forest,len(data))
core_points = np.array(list(core_points))
labels = labels
return labels, core_points | ADPTC-LIB | /ADPTC_LIB-0.0.7.tar.gz/ADPTC_LIB-0.0.7/ADPTC_LIB/myutil.py | myutil.py |
import numpy as np
import copy
import matplotlib.pyplot as plt
import time
def split_cluster(tree,local_density,dist_mat,eps,dc_eps,closest_dis_denser):
'''
dc_eps: density_connectivity 阈值
使用父子节点的直接距离，与子节点与兄弟节点的连通距离进行聚簇划分；
使用平均密度划分outlier
返回：
outlier_forest
cluster_forest
'''
mean_density = np.mean(local_density)
outlier_forest = {}
cluster_forest = {}
not_direct_reach = []
not_direct_reach = np.where(closest_dis_denser>eps)[0]#* 计算不直接可达的点
#* 将不直接距离可达的点按层次排列：
# not_direct_reach = np.array(not_direct_reach)
depth_list_not_direct_reach= np.zeros(len(not_direct_reach),dtype=np.int16)
for i in range(len(not_direct_reach)):
# depth_list_not_direct_reach[i] = tree.node_dir[not_direct_reach[i]].getLvl()
depth_list_not_direct_reach[i] = tree.calcu_depth(not_direct_reach[i],0)
pass
not_direct_reach = list(not_direct_reach[np.argsort(depth_list_not_direct_reach)])
#* 模拟栈结构，层次深的先处理
start = time.clock()
while(len(not_direct_reach)>0):
#* 判断是否 连通：距离小于阈值，并且密度要大于子树的平均密度
node_id = not_direct_reach.pop()
node = tree.node_dir[node_id]
parent_id = node.parent_id
parent_node = tree.node_dir[parent_id]
children = parent_node.getChildren()
siblings_reliable = [ i for i in children if i not in not_direct_reach] #* 求得兄弟节点，其中兄弟节点不能是不直接可达的点
not_reliable_nodes = [i for i in children if i not in siblings_reliable]
if node_id in not_reliable_nodes:
not_reliable_nodes.remove(node_id)
if node_id in siblings_reliable:
siblings_reliable.remove(node_id)
min_dist = is_connected(tree,local_density,dist_mat,eps,dc_eps,node_id,siblings_reliable,not_reliable_nodes)
if min_dist>eps:
if(node_id==tree.root_node.node_id):
continue
if(local_density[node_id]-mean_density*dc_eps)>=0:
cluster_forest[node_id] = tree.remove_subtree(node_id)
pass
else:
outlier_forest[node_id] = tree.remove_subtree(node_id)
pass
pass
pass
end = time.clock()
print('切割树耗时 %s' % str(end - start))
cluster_forest[tree.root_node.node_id] = tree #* 添加根节点的树
return outlier_forest, cluster_forest
def split_cluster_new(tree,local_density,dc_eps,closest_denser_nodes_id,mixin_near_matrix):
'''
dc_eps: density_connectivity 阈值
使用父子节点的直接距离，与子节点与兄弟节点的连通距离进行聚簇划分；
使用平均密度划分outlier
返回：
outlier_forest
cluster_forest
'''
mean_density = np.mean(local_density)
outlier_forest = {}
cluster_forest = {}
uncertain_forest = {}
not_direct_reach = []
#* 计算不可直接可达的点：
for k in range(len(closest_denser_nodes_id)):
near_nodes = mixin_near_matrix[1][np.where(mixin_near_matrix[0]==k)]
if closest_denser_nodes_id[k] not in near_nodes:
not_direct_reach.append(k)
pass
not_direct_reach = np.array(not_direct_reach)
# not_direct_reach = np.where(closest_dis_denser>eps)[0]
#* 将不直接距离可达的点按层次排列：
# not_direct_reach = np.array(not_direct_reach)
depth_list_not_direct_reach= np.zeros(len(not_direct_reach),dtype=np.int16)
for i in range(len(not_direct_reach)):
# depth_list_not_direct_reach[i] = tree.node_dir[not_direct_reach[i]].getLvl()
depth_list_not_direct_reach[i] = tree.calcu_depth(not_direct_reach[i],0)
pass
not_direct_reach = list(not_direct_reach[np.argsort(depth_list_not_direct_reach)])
#* 模拟栈结构，层次深的先处理
start = time.clock()
# 不直接可达点，有多少子孙：
# for nodeid in not_direct_reach:
# lenspr = len(tree.get_subtree_offspring_id(nodeid, []))
# print('id:',nodeid," 子孙个数：",lenspr," 密度：", local_density[nodeid])
# pass
while(len(not_direct_reach)>0):
#* 判断是否 连通：距离小于阈值，并且密度要大于子树的平均密度
node_id = not_direct_reach.pop()
dout_nodes= [1612,159,844,1661,400,817,659]
if(node_id in dout_nodes):
print(node_id)
node = tree.node_dir[node_id]
parent_id = node.parent_id
parent_node = tree.node_dir[parent_id]
children = parent_node.getChildren()
siblings_reliable = [ i for i in children if i not in not_direct_reach] #* 求得兄弟节点，其中兄弟节点不能是不直接可达的点
not_reliable_nodes = [i for i in children if i not in siblings_reliable]
if node_id in not_reliable_nodes:
not_reliable_nodes.remove(node_id)
if node_id in siblings_reliable:
siblings_reliable.remove(node_id)
pairs_nodes = is_connected_new(tree,local_density,dc_eps,node_id,siblings_reliable,not_reliable_nodes,mixin_near_matrix)
if len(pairs_nodes)==0:
if(node_id==tree.root_node.node_id):
continue
if(local_density[node_id]-mean_density*dc_eps)>=0:
#* 获取子节点个数:
offspring_id = tree.get_subtree_offspring_id(node_id,[node_id])
if(len(offspring_id)<local_density[node_id]):
uncertain_forest[node_id] = tree.remove_subtree(node_id)
pass
else:
cluster_forest[node_id] = tree.remove_subtree(node_id)
pass
pass
else:
outlier_forest[node_id] = tree.remove_subtree(node_id)
pass
pass
pass
end = time.clock()
print('切割树耗时 %s' % str(end - start))
cluster_forest[tree.root_node.node_id] = tree #* 添加根节点的树
return outlier_forest, cluster_forest, uncertain_forest
def split_cluster_entropy(tree,local_density,dist_mat,eps,dc_eps,closest_dis_denser):
'''
dc_eps: density_connectivity 阈值
使用父子节点的直接距离，与子节点与兄弟节点的连通距离进行聚簇划分；
使用平均密度划分outlier
返回：
outlier_forest
cluster_forest
'''
mean_density = np.mean(local_density)
outlier_forest = {}
cluster_forest = {}
not_direct_reach = []
start = time.clock()
not_direct_reach = np.where(closest_dis_denser<eps)[0]#* 计算不直接可达的点
end = time.clock()
print('计算直接可达耗时 %s' % str(end - start))
#* 将不直接距离可达的点按层次排列：
start = time.clock()
# not_direct_reach = np.array(not_direct_reach)
depth_list_not_direct_reach= np.zeros(len(not_direct_reach),dtype=np.int16)
for i in range(len(not_direct_reach)):
# depth_list_not_direct_reach[i] = tree.node_dir[not_direct_reach[i]].getLvl()
depth_list_not_direct_reach[i] = tree.calcu_depth(not_direct_reach[i],0)
pass
not_direct_reach = list(not_direct_reach[np.argsort(depth_list_not_direct_reach)])
end = time.clock()
print('计算深度耗时 %s' % str(end - start))
#* 模拟栈结构，层次深的先处理
start = time.clock()
while(len(not_direct_reach)>0):
#* 判断是否 连通：距离小于阈值，并且密度要大于子树的平均密度
node_id = not_direct_reach.pop()
node = tree.node_dir[node_id]
parent_id = node.parent_id
parent_node = tree.node_dir[parent_id]
children = parent_node.getChildren()
siblings_reliable = [ i for i in children if i not in not_direct_reach] #* 求与父节点直接可达的兄弟节点
not_reliable_nodes = [i for i in children if i not in siblings_reliable]
if node_id in not_reliable_nodes:
not_reliable_nodes.remove(node_id)
if node_id in siblings_reliable:
siblings_reliable.remove(node_id)
max_dist = is_connected_entropy(tree,local_density,dist_mat,eps,dc_eps,node_id,siblings_reliable,not_reliable_nodes)
if max_dist<eps:
if(node_id==tree.root_node.node_id):
continue
if(local_density[node_id]-mean_density*dc_eps)>=0:
cluster_forest[node_id] = tree.remove_subtree(node_id)
pass
else:
outlier_forest[node_id] = tree.remove_subtree(node_id)
pass
pass
pass
end = time.clock()
print('切割树耗时 %s' % str(end - start))
cluster_forest[tree.root_node.node_id] = tree #* 添加根节点的树
return outlier_forest, cluster_forest
def is_connected(tree,local_density,dist_mat,eps,dc_eps,cur_node_id,reliable_nodes,not_reliable_nodes):
'''
cur_node: 当前待判断与父节点连通度的点；
reliable_nodes：兄弟节点中与父节点直接相连的点；
not_reliable_nodes：兄弟节点中不与父节点直接相连的点，但可能间接相连；
连通度判断方案：
1. 判断 cur_node 与 reliable_nodes 是否可达，是则返回；没有则执行2；
2. 判断 cur_node 与 not_reliable_nodes(假设为[a,b,c,d,e]) 是否可达，若与[a,b,c]可达，与[d,e]不可达，执行3；
3. 循环遍历[a,b,c],递归调用本方法 is_connected_entropy(……,cur_node_id=[a],reliable_nodes,not_reliable_nodes=[b,c,d,e])
'''
#* 1.
min_dist = float('inf')
if(len(reliable_nodes)==0):
return min_dist
for reliable_node_id in reliable_nodes:
dist_tmp, connected_nodes = tree.calcu_dist_betw_subtree(cur_node_id,reliable_node_id,dist_mat,eps)
#* 如果距离小于阈值，并且连通点平均密度大于局部密度阈值，则更新最小距离
#! 此处使用子树平均密度*dc_eps作为连通阈值
if dist_tmp>eps:
continue
cur_node_offspring = tree.get_subtree_offspring_id(cur_node_id,[cur_node_id])
local_density_cur_offspring = np.mean(local_density[cur_node_offspring])
local_density_connected_nodes = np.mean(local_density[connected_nodes])
if(local_density_connected_nodes>local_density_cur_offspring*dc_eps and dist_tmp < min_dist):
min_dist = dist_tmp
pass
if min_dist<=eps:
break
pass
if min_dist <= eps:
return min_dist
#* 2.
min_dist_indirect = float('inf')
for i in range(len(not_reliable_nodes)):
dist_tmp, connected_nodes = tree.calcu_dist_betw_subtree(cur_node_id,not_reliable_nodes[i],dist_mat,eps)
#* 如果距离小于阈值，并且连通点平均密度大于局部密度阈值，则更新最大相似度
if dist_tmp>eps:
continue
cur_node_offspring = tree.get_subtree_offspring_id(cur_node_id,[cur_node_id])
local_density_cur_offspring = np.mean(local_density[cur_node_offspring])
local_density_connected_nodes = np.mean(local_density[connected_nodes])
if(local_density_connected_nodes>local_density_cur_offspring*dc_eps and dist_tmp < min_dist_indirect):
min_dist_indirect = dist_tmp
pass
if min_dist_indirect>=eps:
min_dist = is_connected(tree,local_density,dist_mat,eps,dc_eps,not_reliable_nodes[i],reliable_nodes,not_reliable_nodes[i+1:])
if min_dist <= eps:
return min_dist
pass
return min_dist
def is_connected_new(tree,local_density,dc_eps,cur_node_id,reliable_nodes,not_reliable_nodes,mixin_near_matrix):
'''
cur_node: 当前待判断与父节点连通度的点；
reliable_nodes：兄弟节点中与父节点直接相连的点；
not_reliable_nodes：兄弟节点中不与父节点直接相连的点，但可能间接相连；
连通度判断方案：
1. 判断 cur_node 与 reliable_nodes 是否可达，是则返回；没有则执行2；
2. 判断 cur_node 与 not_reliable_nodes(假设为[a,b,c,d,e]) 是否可达，若与[a,b,c]可达，与[d,e]不可达，执行3；
3. 循环遍历[a,b,c],递归调用本方法 is_connected_entropy(……,cur_node_id=[a],reliable_nodes,not_reliable_nodes=[b,c,d,e])
'''
#* 1.
# return []
if(len(reliable_nodes)==0):
return []
for reliable_node_id in reliable_nodes:
pairs_nodes, connected_nodes = tree.calcu_neighbor_btw_subtree(cur_node_id,reliable_node_id,mixin_near_matrix)
if(len(pairs_nodes)==0):
continue
# return pairs_nodes
cur_node_offspring = tree.get_subtree_offspring_id(cur_node_id,[cur_node_id])
local_density_cur_offspring = np.mean(local_density[cur_node_offspring])
local_density_connected_nodes = np.mean(local_density[connected_nodes])
if(local_density_connected_nodes>local_density_cur_offspring*dc_eps):
return pairs_nodes
pass
#* 2.
for i in range(len(not_reliable_nodes)):
pairs_nodes, connected_nodes = tree.calcu_neighbor_btw_subtree(cur_node_id,not_reliable_nodes[i],mixin_near_matrix)
if(len(pairs_nodes)==0):
pairs_nodes = is_connected_new(tree,local_density,dc_eps,not_reliable_nodes[i],reliable_nodes,not_reliable_nodes[i+1:],mixin_near_matrix)
if(len(pairs_nodes)>0):
return pairs_nodes
else:
return pairs_nodes
# #* 连通点平均密度大于局部密度阈值，则更新最大相似度
# cur_node_offspring = tree.get_subtree_offspring_id(cur_node_id,[cur_node_id])
# local_density_cur_offspring = np.mean(local_density[cur_node_offspring])
# local_density_connected_nodes = np.mean(local_density[connected_nodes])
# if(local_density_connected_nodes>local_density_cur_offspring*dc_eps):
# return pairs_nodes
# if(len(pairs_nodes)==0):
# pairs_nodes = is_connected_new(tree,local_density,dc_eps,not_reliable_nodes[i],reliable_nodes,not_reliable_nodes[i+1:],mixin_near_matrix)
# if(len(pairs_nodes)>0):
# return pairs_nodes
# pass
return []
def is_connected_entropy(tree,local_density,dist_mat,eps,dc_eps,cur_node_id,reliable_nodes,not_reliable_nodes):
'''
cur_node: 当前待判断与父节点连通度的点；
reliable_nodes：兄弟节点中与父节点直接相连的点；
not_reliable_nodes：兄弟节点中不与父节点直接相连的点，但可能间接相连；
连通度判断方案：
1. 判断 cur_node 与 reliable_nodes 是否可达，是则返回；没有则执行2；
2. 判断 cur_node 与 not_reliable_nodes(假设为[a,b,c,d,e]) 是否可达，若与[a,b,c]可达，与[d,e]不可达，执行3；
3. 循环遍历[a,b,c],递归调用本方法 is_connected_entropy(……,cur_node_id=[a],reliable_nodes,not_reliable_nodes=[b,c,d,e])
'''
#* 1.
max_dist = -1
if(len(reliable_nodes)==0):
return max_dist
for reliable_node_id in reliable_nodes:
dist_tmp, connected_nodes = tree.calcu_dist_betw_subtree_entropy(cur_node_id,reliable_node_id,dist_mat,eps)
#* 如果距离小于阈值，并且连通点平均密度大于局部密度阈值，则更新最大相似度
#! 此处使用子树平均密度*dc_eps作为连通阈值
if dist_tmp<eps:
continue
cur_node_offspring = tree.get_subtree_offspring_id(cur_node_id,[cur_node_id])
local_density_cur_offspring = np.mean(local_density[cur_node_offspring])
local_density_connected_nodes = np.mean(local_density[connected_nodes])
if(local_density_connected_nodes>local_density_cur_offspring*dc_eps and dist_tmp > max_dist):
max_dist = dist_tmp
pass
if max_dist>=eps:
break
pass
if max_dist >= eps:
return max_dist
#* 2.
max_dist_indirect = -1
for i in range(len(not_reliable_nodes)):
dist_tmp, connected_nodes = tree.calcu_dist_betw_subtree_entropy(cur_node_id,not_reliable_nodes[i],dist_mat,eps)
#* 如果距离小于阈值，并且连通点平均密度大于局部密度阈值，则更新最大相似度
#! 此处使用子树平均密度*dc_eps作为连通阈值
if dist_tmp<eps:
continue
cur_node_offspring = tree.get_subtree_offspring_id(cur_node_id,[cur_node_id])
local_density_cur_offspring = np.mean(local_density[cur_node_offspring])
local_density_connected_nodes = np.mean(local_density[connected_nodes])
if(local_density_connected_nodes>local_density_cur_offspring*dc_eps and dist_tmp > max_dist_indirect):
max_dist_indirect = dist_tmp
pass
if max_dist_indirect>=eps:
max_dist = is_connected_entropy(tree,local_density,dist_mat,eps,dc_eps,not_reliable_nodes[i],reliable_nodes,not_reliable_nodes[i+1:])
if max_dist >= eps:
return max_dist
pass
return max_dist
def label_these_node(outlier_forest,cluster_forest,node_num):
'''
给森林中的样本点贴标签
'''
labels = np.full((node_num),-1,dtype=np.int32)
for outlier_id in outlier_forest:
outlier_tree = outlier_forest[outlier_id]
outlier_idlist = outlier_tree.get_subtree_offspring_id(outlier_id,[outlier_id])
labels[outlier_idlist] = -1
pass
label = 0
for tree_id in cluster_forest:
cluster_tree = cluster_forest[tree_id]
cluster_idlist = cluster_tree.get_subtree_offspring_id(tree_id,[tree_id])
labels[cluster_idlist] = label
label = label + 1
pass
core_points = cluster_forest.keys()
return labels,core_points
def label_these_node_new(outlier_forest,cluster_forest,node_num,uncertain_forest,mixin_near_matrix):
'''
给森林中的样本点贴标签
考虑不确定点的分配
'''
labels = np.full((node_num),-1,dtype=np.int32)
for outlier_id in outlier_forest:
outlier_tree = outlier_forest[outlier_id]
outlier_idlist = outlier_tree.get_subtree_offspring_id(outlier_id,[outlier_id])
labels[outlier_idlist] = -1
pass
label = 0
for tree_id in cluster_forest:
cluster_tree = cluster_forest[tree_id]
cluster_idlist = cluster_tree.get_subtree_offspring_id(tree_id,[tree_id])
labels[cluster_idlist] = label
label = label + 1
pass
for uncertain_tree_id in uncertain_forest:
uncertain_tree = uncertain_forest[uncertain_tree_id]
uncertain_nodes_id = uncertain_tree.get_subtree_offspring_id(uncertain_tree_id,[uncertain_tree_id])
all_near_nodes = mixin_near_matrix[1][np.where(np.in1d(mixin_near_matrix[0],uncertain_nodes_id))[0]]
all_near_nodes = np.unique(all_near_nodes)
all_near_nodes = all_near_nodes[np.where(labels[all_near_nodes]!=-1)]
unique_labels,counts=np.unique(labels[all_near_nodes],return_counts=True)
if(len(counts)==0):
cur_label = -1
else:
cur_label = unique_labels[np.argmax(counts)]
labels[uncertain_nodes_id]=cur_label
pass
core_points = cluster_forest.keys()
return labels,core_points
'''
密度峰值树；
根据cfsfdp算法生成的局部密度、高密度最近邻距离、决策指标来生成 DPTree；
'''
class Node():
def __init__(self,node_id,attr_list,parent_id=None,dist_to_parent=None,each_dist_to_parent=[],density=None,gamma=None,children=[]):
self.node_id = node_id
self.attr_list = attr_list
self.parent_id = parent_id
self.dist_to_parent = dist_to_parent
self.each_dist_to_parent = each_dist_to_parent
self.density = density
self.children = children
self.gamma = gamma
self.offspring_num = None
self.lvl = None
def addChild(self,child):
self.children+=[child]
def removeChild(self,child):
self.children.remove(child)
def resetChildren(self):
self.children = []
def setParentId(self,parent_id):
self.parent_id = parent_id
def setOffspringNum(self,num):
self.offspring_num = num
def setLvl(self,lvl):
self.lvl = lvl
def getAttr(self):
return self.attr_list
def getNodeId(self):
return self.node_id
def getParentId(self):
return self.parent_id
def getDistToParent(self):
return self.dist_to_parent
def getDensity(self):
return self.density
def getGamma(self):
return self.gamma
def getChildren(self):
return self.children
def hasChildren(self,child_id):
if child_id in self.children:
return True
else:
return False
def getOffspringNum(self):
return self.offspring_num
def getLvl(self):
return self.lvl
class DPTree():
def __init__(self):
self.node_count = 0
self.node_dir = {}
self.root_node = None
self.node_offspring = {}
pass
def createTree(self,X,sorted_gamma_index,closest_node_id,closest_dis_denser,local_density,gamma):
#* 根据 gamma 顺序新建节点
node_dir = {}
node_created = np.zeros(len(sorted_gamma_index))
for i in range(len(sorted_gamma_index)):
node_id = sorted_gamma_index[i]
parent_id = closest_node_id[node_id] #* closest_node_id是根据排序后的gamma获得的
attr_list = X[node_id]
dist_to_parent = closest_dis_denser[node_id]
density = local_density[node_id]
if(node_created[node_id]==0):
node = Node(node_id,attr_list,parent_id,dist_to_parent,density,gamma[node_id],children=[])
node_created[node_id] = 1
node_dir[node_id] = node
node_dir[node_id].setParentId(parent_id)
if(node_created[parent_id]==0):
parent_node = Node(parent_id,X[parent_id],parent_id=None,dist_to_parent=closest_dis_denser[parent_id],density=local_density[parent_id],gamma=gamma[parent_id],children=[])
node_created[parent_id] = 1
node_dir[parent_id] = parent_node
parent_node = node_dir[parent_id]
cur_node = node_dir[node_id]
if(node_id != parent_id):#* 非根节点
parent_node.addChild(node_id)
# parent_lvl = parent_node.getLvl()
# cur_node.setLvl(parent_lvl+1)
else:
if(parent_node.getLvl()==None):
parent_node.setLvl(0)
#* 设置节点层次信息
# for i in tree.node_dir:
# pass
self.root_node = node_dir[sorted_gamma_index[0]]
self.node_dir = node_dir
self.node_count = len(sorted_gamma_index)
pass
def printTree2(self,parent_id,spaceStr=''):
for node_id in self.node_dir:
if(node_id==self.root_node.node_id):
continue
node = self.node_dir[node_id]
if(node.parent_id==parent_id):
print(spaceStr, node.node_id, sep = '')
self.printTree2(node.node_id,spaceStr+' ')
pass
def calcu_subtree_offspring_num(self,node_id):
node = self.node_dir[node_id]
cur_offsprings = node.getOffspringNum()
if(cur_offsprings!=None):
return cur_offsprings
child_num = len(node.children)
if(child_num==0):
return 0
for i in node.children:
cur_offsprings = self.calcu_subtree_offspring_num(i)
child_num+=cur_offsprings
node.setOffspringNum(child_num)
return child_num
def get_subtree_offspring_id(self,node_id,other_idlist):
'''
获取所有子孙的node_id
考虑：是否需要存储在node属性中。
'''
def fn_get_subtree_offspring_id(node_id,offspring_idlist):
if(node_id in self.node_offspring.keys()):
return self.node_offspring[node_id]
else:
node = self.node_dir[node_id]
children = node.getChildren()
child_num = len(children)
if(child_num==0):
self.node_offspring[node_id] = offspring_idlist
return offspring_idlist
offspring_idlist= list(offspring_idlist) + children
for i in children:
child_offspring_idlist = fn_get_subtree_offspring_id(i,[])
self.node_offspring[i] = child_offspring_idlist
offspring_idlist= list(offspring_idlist) + child_offspring_idlist
pass
self.node_offspring[node_id] = offspring_idlist
return offspring_idlist
offspring_idlist = fn_get_subtree_offspring_id(node_id,[])
return np.array(list(offspring_idlist) + other_idlist)
def calcu_subtree_entropy(self,offspring_id,local_density,closest_dis_denser):
p_sum = np.sum(local_density[offspring_id]/closest_dis_denser[offspring_id])
p = (local_density[offspring_id]/closest_dis_denser[offspring_id])/p_sum
entropy = -1*np.sum(p*np.log2(p))
#* 只有一个点的情况返回 0
if(entropy==0):
return 0
return entropy/(-1*np.log2(1/(len(offspring_id))))
def remove_subtree(self,child_id):
'''
删除 node_id 节点的子树：child_id, 被删除的子树形成新的树并返回
1. 更新 self.node_dir, self.node_count
2. 更新 node_id 节点的 children[], 以及所有父级offspring_num
3. 生成新树
'''
offspring_id = self.get_subtree_offspring_id(child_id,[child_id])
offspring_len = len(offspring_id)
node_id = self.node_dir[child_id].parent_id
node = self.node_dir[node_id]
node.removeChild(child_id)
self.node_count = self.node_count-offspring_len
# cur_id = child_id
# parent_id = node_id
# #* 设置父级 offspring_num:
# while(cur_id!=parent_id):
# parent_node = self.node_dir[parent_id]
# if(parent_node.getOffspringNum()!=None):
# parent_node.setOffspringNum(parent_node.getOffspringNum()-offspring_len)
# cur_id = parent_id
# parent_id = parent_node.parent_id
# pass
#* 更新 self.node_dir, 生成新树:
new_tree = DPTree()
for i in offspring_id:
removed_node = self.node_dir.pop(i)
new_tree.node_dir[i] = removed_node
pass
new_tree.node_count = offspring_len
new_tree.root_node = new_tree.node_dir[child_id]
new_tree.root_node.setParentId(child_id)
return new_tree
def calcu_dist_betw_subtree(self,node_id_one,node_id_two,dist_mat,eps):
'''
计算两个子树间的连通距离
return：
1. 最短距离
2. 小于距离阈值的点集
'''
connected_nodes = np.array([],dtype=np.int32)
offspring_one = self.get_subtree_offspring_id(node_id_one,[node_id_one])
offspring_two = self.get_subtree_offspring_id(node_id_two,[node_id_two])
dist = float('inf')
for i in offspring_two:
tmp_dist = np.min(dist_mat[i][offspring_one])
if(tmp_dist<dist):
dist = tmp_dist
pass
connected_nodes_index = np.where(dist_mat[i][offspring_one]<eps)[0]
if len(connected_nodes_index)>0:
connected_nodes = np.r_[[i],connected_nodes,offspring_one[connected_nodes_index]]
pass
return dist, np.unique(connected_nodes)
def calcu_neighbor_btw_subtree(self,node_id_one,node_id_two,mixin_near_matrix):
'''
计算两个子树间的邻近点
return:
邻近的点对
所有邻近点
'''
connected_nodes = np.array([],dtype=np.int32)
offspring_one = self.get_subtree_offspring_id(node_id_one,[node_id_one])
offspring_two = self.get_subtree_offspring_id(node_id_two,[node_id_two])
pairs_nodes = []
for i in offspring_two:
connected_nodes_index = np.intersect1d(mixin_near_matrix[1][np.where(mixin_near_matrix[0]==i)],offspring_one)
if len(connected_nodes_index)>0:
for j in connected_nodes_index:
pairs_nodes.append([i,j])
pass
pass
if(len(pairs_nodes)==0):
return pairs_nodes,connected_nodes
return np.array(pairs_nodes), np.unique(np.array(pairs_nodes).flatten())
def calcu_dist_betw_subtree_entropy(self,node_id_one,node_id_two,dist_mat,eps):
'''
计算两个子树间的连通距离
return：
1. 最大相似距离
2. 大于相似距离阈值的点集
'''
connected_nodes = np.array([],dtype=np.int32)
offspring_one = self.get_subtree_offspring_id(node_id_one,[node_id_one])
offspring_two = self.get_subtree_offspring_id(node_id_two,[node_id_two])
dist = -1
for i in offspring_two:
tmp_dist = np.max(dist_mat[i][offspring_one])
if(tmp_dist>=dist):
dist = tmp_dist
pass
connected_nodes_index = np.where(dist_mat[i][offspring_one]>=eps)[0]
if len(connected_nodes_index)>0:
connected_nodes = np.r_[[i],connected_nodes,offspring_one[connected_nodes_index]]
pass
return dist, np.unique(connected_nodes)
def calcu_depth(self,node_id, depth):
node = self.node_dir[node_id]
parent_id = node.parent_id
if(node_id==parent_id):
return depth
else:
return self.calcu_depth(parent_id,depth+1) | ADPTC-LIB | /ADPTC_LIB-0.0.7.tar.gz/ADPTC_LIB-0.0.7/ADPTC_LIB/DPTree.py | DPTree.py |
from sklearn.utils import check_array
import time
from . import myutil
from . import visual
from . import prepare
class ADPTC:
def __init__(self, X, lon_index=0, lat_index=1, time_index=2, attrs_index=[3]):
self.X = X
self.lon_index = lon_index
self.lat_index = lat_index
self.time_index = time_index
self.attrs_index = attrs_index
pass
def clustering(self,eps, density_metric='cutoff', dist_metric='euclidean', algorithm='auto', knn_num=20, leaf_size=300, connect_eps=1,fast=False):
'''
description: 普通聚类，不考虑属性类型，计算混合距离
return {*}
eps：
阈值
density_metric:
密度计算方式，默认为截断密度，支持 gauss
dist_metric：
距离计算方法，默认为 euclidean，支持['euclidean','braycurtis', 'canberra', 'chebyshev', 'cityblock',
'correlation', 'cosine', 'dice', 'hamming','jaccard', 'jensenshannon', 'kulsinski', 'mahalanobis', 'matching',
'minkowski', 'rogerstanimoto', 'russellrao', 'seuclidean',
'sokalmichener', 'sokalsneath', 'sqeuclidean', 'yule'.]
algorithm：
近邻计算方法，计算最近邻点及距离，默认'kd_tree',支持['kd_tree','ball_tree']
knn_num:
近邻个数
leaf_size:
近邻计算方法中用到的叶子节点个数，会影响计算和查询速度
connect_eps:
密度连通性阈值
fast:
是否启用快速聚类，通过最近邻查找算法，优化斥群值查找速度
'''
start=time.clock()
try:
data = check_array(self.X, accept_sparse='csr')
except:
raise ValueError("输入的数据集必须为矩阵")
dist_mat = myutil.calc_dist_matrix(data,dist_metric)
density = myutil.calc_density(dist_mat,eps,density_metric)
denser_pos,denser_dist,density_and_k_relation = myutil.calc_repulsive_force(data,density,knn_num,leaf_size,dist_mat,fast)
if(-1 in denser_pos):
raise ValueError('阈值太小啦~,或者尝试使用高斯密度呢：density_metric=gauss')
pass
gamma = myutil.calc_gamma(density,denser_dist)
labels, core_points=myutil.extract_cluster_auto(data,density,eps,connect_eps,denser_dist,denser_pos,gamma,dist_mat)
self.labels = labels
self.core_points = core_points
self.density_and_k_relation = density_and_k_relation
self.density = density
end=time.clock()
self.calc_time = str(end-start)
return self
def spacial_clustering_raster(self,spatial_eps,attr_eps,density_metric='cutoff',dist_metric='euclidean', algorithm='auto', knn_num=20, leaf_size=300, connect_eps=1):
'''
description: 地理空间栅格数据聚类分析；输入数据为二维矩阵，行和列分别为地理空间的纬度和经度。
return {*}
spatial_eps：
空间阈值
attr_eps：
属性阈值
density_metric:
密度计算方式，默认为截断密度，支持 gauss
dist_metric：
距离计算方法，默认为 euclidean，支持['euclidean','braycurtis', 'canberra', 'chebyshev', 'cityblock',
'correlation', 'cosine', 'dice', 'hamming','jaccard', 'jensenshannon', 'kulsinski', 'mahalanobis', 'matching',
'minkowski', 'rogerstanimoto', 'russellrao', 'seuclidean',
'sokalmichener', 'sokalsneath', 'sqeuclidean', 'yule'.]
algorithm：
近邻计算方法，计算最近邻点及距离，默认'kd_tree',支持['kd_tree','ball_tree','brute','Annoy','HNSW']
knn_num:
近邻个数
leaf_size:
近邻计算方法中用到的叶子节点个数，会影响计算和查询速度
connect_eps:
密度连通性阈值
'''
start=time.clock()
try:
data = check_array(self.X)
except:
raise ValueError("Two-dimensional matrix is needed,the rows and columns are the latitude and longitude.")
#* 立方体数据转二维矩阵，行为样本，列为要素
data_not_none,pos_not_none = myutil.rasterArray_to_sampleArray(data)
self.data_not_none = data_not_none
mixin_near_matrix = myutil.calc_homo_near_grid(data,spatial_eps,attr_eps,pos_not_none)
density = myutil.calc_gaus_density_spatial(data,spatial_eps,attr_eps)
denser_pos,denser_dist,density_and_k_relation = myutil.calc_repulsive_force(data_not_none,density,knn_num,leaf_size,fast=True)
if(-1 in denser_pos):
raise ValueError('阈值太小啦~,或者尝试使用高斯密度呢：density_metric=gauss')
pass
gamma = myutil.calc_gamma(density,denser_dist)
labels, core_points = myutil.extract_cluster_auto_st(data_not_none,density,connect_eps,denser_dist,denser_pos,gamma,mixin_near_matrix)
self.labels = labels
self.core_points = core_points
self.density_and_k_relation = density_and_k_relation
self.density = density
end=time.clock()
self.calc_time = str(end-start)
return self
def st_clustering_raster(self,spatial_eps,time_eps,attr_eps,density_metric='cutoff',dist_metric='euclidean', algorithm='auto', knn_num=20, leaf_size=300, connect_eps=1):
'''
description: 地理时空栅格数聚类，输入数据为三维矩阵，三个维度分别为纬度、经度、时间。
return {*}
spatial_eps：
空间阈值
time_eps:
时间阈值
attr_eps：
属性阈值
density_metric:
密度计算方式，默认为截断密度，支持 gauss
dist_metric：
距离计算方法，默认为 euclidean，支持['euclidean','braycurtis', 'canberra', 'chebyshev', 'cityblock',
'correlation', 'cosine', 'dice', 'hamming','jaccard', 'jensenshannon', 'kulsinski', 'mahalanobis', 'matching',
'minkowski', 'rogerstanimoto', 'russellrao', 'seuclidean',
'sokalmichener', 'sokalsneath', 'sqeuclidean', 'yule'.]
algorithm：
近邻计算方法，计算最近邻点及距离，默认'kd_tree',支持['kd_tree','ball_tree','brute','Annoy','HNSW']
knn_num:
近邻个数
leaf_size:
近邻计算方法中用到的叶子节点个数，会影响计算和查询速度
connect_eps:
密度连通性阈值
'''
start=time.clock()
try:
data = check_array(self.X,allow_nd=True)
except:
raise ValueError("Three-dimensional matrix is needed, latitude, longitude and time.")
#* 立方体数据转二维矩阵，行为样本，列为要素
data_not_none,pos_not_none = myutil.rasterCube_to_sampleArray(data)
self.data_not_none = data_not_none
mixin_near_matrix = myutil.calc_homo_near_cube(data,spatial_eps,time_eps,attr_eps,pos_not_none)
density = myutil.calc_gaus_density_st(data,spatial_eps,time_eps,attr_eps)
denser_pos,denser_dist,density_and_k_relation = myutil.calc_repulsive_force(data_not_none,density,knn_num,leaf_size,fast=True)
if(-1 in denser_pos):
raise ValueError('阈值太小啦~,或者尝试使用高斯密度呢：density_metric=gauss')
pass
gamma = myutil.calc_gamma(density,denser_dist)
labels, core_points = myutil.extract_cluster_auto_st(data_not_none,density,connect_eps,denser_dist,denser_pos,gamma,mixin_near_matrix)
self.labels = labels
self.core_points = core_points
self.density_and_k_relation = density_and_k_relation
self.density = density
end=time.clock()
self.calc_time = str(end-start)
return self | ADPTC-LIB | /ADPTC_LIB-0.0.7.tar.gz/ADPTC_LIB-0.0.7/ADPTC_LIB/cluster.py | cluster.py |
import matplotlib.pyplot as plt
import numpy as np
from . import myutil
import cartopy.crs as ccrs
from cartopy.mpl.gridliner import LATITUDE_FORMATTER, LONGITUDE_FORMATTER
import matplotlib.ticker as mticker
from matplotlib.colors import LinearSegmentedColormap
import matplotlib.pyplot as plt
from mpl_toolkits.basemap import Basemap
from mpl_toolkits.mplot3d import Axes3D
#*************************************** 结果展示*******************************************#
# 绘制密度和时间距离图
def showDenDisAndDataSet(den, dis):
# 密度和时间距离图显示在面板
plt.figure(num=1, figsize=(15, 9))
ax1 = plt.subplot(121)
plt.scatter(x=den, y=dis, c='k', marker='o', s=30)
for i in range(len(den)):
plt.text(den[i],dis[i],i,fontdict={'fontsize':16})
plt.xlabel('Density')
plt.ylabel('Distance')
plt.title('Decision Diagram')
plt.sca(ax1)
plt.show()
# 确定类别点,计算每点的密度值与最小距离值的乘积，并画出决策图，以供选择将数据共分为几个类别
def show_nodes_for_chosing_mainly_leaders(gamma):
plt.figure(num=2, figsize=(15, 10))
# -np.sort(-gamma) 将gamma从大到小排序
y=-np.sort(-gamma)
indx = np.argsort(-gamma)
plt.scatter(x=range(len(gamma)), y=y, c='k', marker='o', s=50)
for i in range(int(len(y))):
plt.text(i,y[i],indx[i],fontdict={'fontsize':16},c='#f00')
plt.xlabel('n',fontsize=20)
plt.ylabel('γ',fontsize=20)
# plt.title('递减顺序排列的γ')
plt.show()
def show_result(labels, data, corePoints=[]):
# 画最终聚类效果图
plt.figure(num=3, figsize=(15, 10))
# 一共有多少类别
clusterNum = np.unique(labels)
scatterColors = [
'#FF0000','#FFA500','#00FF00','#228B22',
'#0000FF','#FF1493','#EE82EE','#000000',
'#00FFFF','#F099C0','#0270f0','#96a9f0',
'#99a9a0','#22a9a0','#a99ff9','#a90ff9'
]
# 绘制分类数据
for i in clusterNum:
if(i==-1 or i==-2):
colorSytle = '#510101'
subCluster = data[np.where(labels == i)]
plt.scatter(subCluster[:, 0], subCluster[:, 1], c=colorSytle, s=80, marker='*', alpha=1)
continue
# 为i类别选择颜色
colorSytle = scatterColors[i % len(scatterColors)]
# 选择该类别的所有Node
subCluster = data[np.where(labels == i)]
plt.scatter(subCluster[:, 0], subCluster[:, 1], c=colorSytle, s=25, marker='o', alpha=1,label=i)
# 绘制每一个类别的聚类中心
if(len(corePoints)!=0):
plt.scatter(x=data[corePoints, 0], y=data[corePoints, 1], marker='+', s=300, c='k', alpha=1)
# plt.title('聚类结果图')
plt.legend(loc='upper left',fontsize='18')
plt.tick_params(labelsize=18)
plt.show()
def show_data(data):
plt.figure(num=3, figsize=(15, 10))
plt.scatter(data[:,0],data[:,1],s=300,edgecolor='')
for i in range(len(data)):
plt.text(data[i,0],data[i,1],i,fontdict={'fontsize':16})
plt.show()
# 绘制密度和时间距离图
def showDenDisAndDataSet_label(den, dis,labels,font_show = True):
# 一共有多少类别
clusterNum = np.unique(labels)
scatterColors = [
'#FF0000', '#FFA500', '#228B22',
'#0000FF', '#FF1493', '#EE82EE', '#000000', '#FFA500',
'#006400', '#00FFFF', '#0000FF', '#FFFACD',
]
# 密度和时间距离图显示在面板
plt.figure(num=1, figsize=(15, 9))
ax1 = plt.subplot(121)
# 绘制分类数据
for i in clusterNum:
if(i==-1 or i==-2):
colorSytle = '#510101'
subCluster_id = np.where(labels == i)[0]
plt.scatter(den[subCluster_id], dis[subCluster_id], c=colorSytle, s=200, marker='*', alpha=1)
continue
# 为i类别选择颜色
colorSytle = scatterColors[i % len(scatterColors)]
subCluster_id = np.where(labels == i)[0]
plt.scatter(x=den[subCluster_id], y=dis[subCluster_id], c=colorSytle, s=200, marker='o', alpha=1)
# 绘制每一个类别的聚类中心
# plt.scatter(x=den[corePoints], y=dis[corePoints], marker='+', s=200, c='k', alpha=1)
if font_show == True:
for i in range(len(den)):
plt.text(den[i],dis[i],i,fontdict={'fontsize':16})
plt.xlabel('Density - ρ',fontdict={'fontsize':22})
plt.ylabel('Distance - δ',fontdict={'fontsize':22})
plt.title('Decision Diagram',fontdict={'fontsize':22})
plt.sca(ax1)
plt.show()
# 确定类别点,计算每点的密度值与最小距离值的乘积，并画出决策图，以供选择将数据共分为几个类别
def show_nodes_for_chosing_mainly_leaders_label(gamma,labels,font_show = True):
# 一共有多少类别
clusterNum = np.unique(labels)
scatterColors = [
'#FF0000', '#FFA500', '#228B22',
'#0000FF', '#FF1493', '#EE82EE', '#000000', '#FFA500',
'#006400', '#00FFFF', '#0000FF', '#FFFACD',
]
plt.figure(num=2, figsize=(15, 10))
# -np.sort(-gamma) 将gamma从大到小排序
y=-np.sort(-gamma)
indx = np.argsort(-gamma)
# 绘制分类数据
for i in clusterNum:
if(i==-1 or i==-2):
colorSytle = '#510101'
subCluster_id = np.where(labels == i)[0]
ori_indx = [np.where(indx==i)[0][0] for i in subCluster_id]
plt.scatter(x=ori_indx, y=gamma[subCluster_id], c=colorSytle, s=200, marker='*', alpha=1)
continue
# 为i类别选择颜色
colorSytle = scatterColors[i % len(scatterColors)]
subCluster_id = np.where(labels == i)[0]
ori_indx = [np.where(indx==i)[0][0] for i in subCluster_id]
plt.scatter(x=ori_indx, y=gamma[subCluster_id], c=colorSytle, s=200, marker='o', alpha=1)
# plt.scatter(x=range(len(gamma)), y=y, c='k', marker='o', s=50)
if font_show == True:
for i in range(int(len(y))):
plt.text(i,y[i],indx[i],fontdict={'fontsize':16},c='#000')
plt.xlabel('n',fontsize=20)
plt.ylabel('γ',fontsize=20)
# plt.title('递减顺序排列的γ')
plt.show()
def show_data_label(data,labels,font_show = True):
# 一共有多少类别
clusterNum = np.unique(labels)
scatterColors = [
'#FF0000', '#FFA500', '#228B22',
'#0000FF', '#FF1493', '#EE82EE', '#000000', '#FFA500',
'#006400', '#00FFFF', '#0000FF', '#FFFACD',
]
plt.figure(num=3, figsize=(15, 10))
# 绘制分类数据
for i in clusterNum:
if(i==-1 or i==-2):
colorSytle = '#510101'
subCluster_id = np.where(labels == i)[0]
plt.scatter(x=data[subCluster_id,0], y=data[subCluster_id,1], c=colorSytle, s=200, marker='*', alpha=1)
continue
# 为i类别选择颜色
colorSytle = scatterColors[i % len(scatterColors)]
subCluster_id = np.where(labels == i)[0]
plt.scatter(x=data[subCluster_id,0], y=data[subCluster_id,1], c=colorSytle, s=200, marker='o', alpha=1)
# plt.scatter(data[:,0],data[:,1],s=300,edgecolor='')
if font_show == True:
for i in range(len(data)):
plt.text(data[i,0],data[i,1],i,fontdict={'fontsize':16})
plt.show()
def create_map_label(ax):
# * 创建画图空间
#* 设置网格点属性
gl = ax.gridlines(crs=ccrs.PlateCarree(),draw_labels=True,linewidth=1.2,color='k',alpha=0.5,linestyle='--')
gl.xlabels_top = False
gl.ylabels_right = False
gl.xformatter = LONGITUDE_FORMATTER
gl.yformatter = LATITUDE_FORMATTER
# gl.xlocator = mticker.FixedLocator(np.arange(-30,70,15))
# gl.xlocator = mticker.FixedLocator([-30,-15,0,15,30,45,60])
gl.xlabel_style = {'fontsize': 30}
gl.ylabel_style = {'fontsize': 30}
return ax
#* 聚类结果可视化
def showlabel(da,labels):
# proj = ccrs.TransverseMercator(central_longitude=20.0)
proj = ccrs.PlateCarree()
fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(20,10), subplot_kw={'projection':proj})
cbar_kwargs={
'label': 'Lables',
'ticks':np.arange(-1,np.max(labels),1),
}
levels = np.arange(-1,np.max(labels),1)
ax = create_map_label(ax)
ncolors = 256
color_array = plt.get_cmap('Spectral_r')(range(ncolors))
color_array[0] = [0,0,0,0]
map_object = LinearSegmentedColormap.from_list(name='my_spectral_r',colors=color_array)
pre_pic = da.plot.contourf(ax=ax,levels=levels, cmap=map_object, extend='both', cbar_kwargs = cbar_kwargs,transform=ccrs.PlateCarree())
ax.set_title(' ', fontsize=30)
# ax.set_aspect('equal')
cb = pre_pic.colorbar
cb.ax.set_ylabel('labels',fontsize=30)
cb.ax.tick_params(labelsize=24)
ax.coastlines()
fig.show()
pass
def show_result_2d(ori_nc,labels):
myutil.check_netcdf(ori_nc)
data_nc = np.array(ori_nc)
data_not_none,pos_not_none = myutil.rasterArray_to_sampleArray(data_nc)
label_nc = myutil.labeled_res_to_netcdf(ori_nc,data_nc,data_not_none,labels)
showlabel(label_nc['label'],labels)
pass
def show_result_3d(ori_nc,adptc,extent,time_extent,label,path=''):
'''
ori_nc: 包含类别标签的 netcdf 数据（xarray.DataArray）
adptc：聚类结果对象
extent: 经纬度范围 [lon,lon,lat,lat]
time_extent:时间范围 [time1,time2]
label：要显示的类别
'''
res = myutil.labeled_res_to_netcdf(ori_nc,adptc.data_not_none,adptc.labels)
label_nc = res['label']
data_nc = np.array(label_nc)
times,rows,cols = data_nc.shape
data_not_none = np.zeros((times*rows*cols,4))
data_all = np.zeros((times*rows*cols,4))
num = 0
for i in range(rows):
for j in range(cols):
for k in range(times):
data_all[num,:] = [i,j,k,data_nc[k,i,j]]
num+=1
pass
pass
data = data_all[np.where(data_all[:,3]==label)[0]]
lons = []
lats = []
times = []
for i in range(len(data)):
lons.append(float(label_nc.lon[int(data[i,1])].values))
lats.append(float(label_nc.lat[int(data[i,0])].values))
times.append(int(data[i,2]))
pass
colors = ["#CC5C5C","#CF0000","#D80000","#E90000","#FC0000","#FF5100","#FF9D00","#FFBD00","#FBD500","#F0EA00","#D8F500","#B0FF00","#49FF00","#00F700","#00E400","#00CF00","#00BA00","#00A700","#009D1D","#00A668","#00AA95","#00AAA8","#00A0C7","#0095DD","#0080DD","#0054DD","#0009DD","#0000C5","#0D00A8","#58009F","#830094","#7A008B","#41004B"]
draw_geo3dscatter(lons,lats,times,colors[i%len(colors)],extent,time_extent,path)
pass
def draw_geo3dscatter(lons,lats,times,label_color,extent,time_extent,path=''):
fig = plt.figure(figsize=(20,20))
ax = fig.gca(projection='3d')
# Create a basemap instance that draws the Earth layer
bm = Basemap(llcrnrlon=extent[0], llcrnrlat=extent[2],
urcrnrlon=extent[1], urcrnrlat=extent[3],
projection='cyl', resolution='l', fix_aspect=False, ax=ax)
ax.add_collection3d(bm.drawcoastlines(linewidth=0.25))
ax.view_init(azim=250, elev=20)
ax.set_xlabel('Longitude (°E)', labelpad=20,fontsize=30)
ax.set_ylabel('Latitude (°N)', labelpad=20,fontsize=30)
ax.set_zlabel('Month', labelpad=10,fontsize=30)
# Add meridian and parallel gridlines
lon_step = 10
lat_step = 15
meridians = np.arange(extent[0], extent[1] + lon_step, lon_step)
parallels = np.arange(extent[2], extent[3] + lat_step, lat_step)
ax.set_yticks(parallels)
ax.set_yticklabels(parallels)
ax.set_xticks(meridians)
ax.set_xticklabels(meridians)
ax.set_zlim(time_extent[0], time_extent[1])
# ax1 = fig.add_subplot(projection='3d')
ax.scatter(lons, lats, times,c=label_color,alpha=0.5,s=20,marker='s')
ax.scatter(lons, lats,c='#00000005',alpha=0.5,s=20,marker='o')
plt.tick_params(labelsize=25)
if(path!=''):
plt.savefig(path)
plt.show()
pass
#*展示箱图
def show_box(data,labels,attr_index,labels_show):
'''
data: 样本点数据集合 data_not_none
labels: 聚类结果
attr_index: 非时空属性下标
labels_show:要展示的类别标签集合
'''
import matplotlib.pyplot as plt
fig,axes = plt.subplots()
for i in range(len(labels_show)):
cur_label_cell_pos = np.where(labels==labels_show[i])
axes.boxplot(x=data[cur_label_cell_pos,attr_index][0],sym='rd',positions=[i],showfliers=False,notch=True)
plt.xlabel('label',fontsize=20) # x轴标注
plt.ylabel('attr',fontsize=20) # y轴标注
plt.xticks(range(len(labels_show)),labels_show)
plt.tick_params(labelsize=15)
pass
#* 展示小提琴图
def show_vlines(data,labels,attr_index,labels_show):
'''
data: 样本点数据集合 data_not_none
labels: 聚类结果
attr_index: 非时空属性下标
labels_show:要展示的类别标签集合
'''
import matplotlib.pyplot as plt
fig,axes = plt.subplots()
for i in range(len(labels_show)):
cur_label_cell_pos = np.where(labels==labels_show[i])
axes.violinplot(data[cur_label_cell_pos,attr_index][0],positions=[i],showmeans=False,showmedians=True)
plt.xlabel('label',fontsize=20) # x轴标注
# plt.xticks(labels_show)
plt.ylabel('attr',fontsize=20) # x轴标注
plt.xticks(range(len(labels_show)),labels_show)
plt.tick_params(labelsize=15)
pass | ADPTC-LIB | /ADPTC_LIB-0.0.7.tar.gz/ADPTC_LIB-0.0.7/ADPTC_LIB/visual.py | visual.py |
import numpy as np
import copy
import matplotlib.pyplot as plt
import time
def split_cluster_new(tree,local_density,dc_eps,closest_denser_nodes_id,mixin_near_matrix):
'''
dc_eps: density_connectivity 阈值
使用父子节点的直接距离，与子节点与兄弟节点的连通距离进行聚簇划分；
使用平均密度划分outlier
返回：
outlier_forest
cluster_forest
'''
mean_density = np.mean(local_density)
outlier_forest = {}
cluster_forest = {}
uncertain_forest = {}
not_direct_reach = []
#* 计算不可直接可达的点：
for k in range(len(closest_denser_nodes_id)):
near_nodes = mixin_near_matrix[k]
if closest_denser_nodes_id[k] not in near_nodes:
not_direct_reach.append(k)
pass
not_direct_reach = np.array(not_direct_reach)
# not_direct_reach = np.where(closest_dis_denser>eps)[0]
#* 将不直接距离可达的点按层次排列：
# not_direct_reach = np.array(not_direct_reach)
depth_list_not_direct_reach= np.zeros(len(not_direct_reach),dtype=np.int16)
for i in range(len(not_direct_reach)):
# depth_list_not_direct_reach[i] = tree.node_dir[not_direct_reach[i]].getLvl()
depth_list_not_direct_reach[i] = tree.calcu_depth(not_direct_reach[i],0)
pass
not_direct_reach = list(not_direct_reach[np.argsort(depth_list_not_direct_reach)])
#* 模拟栈结构，层次深的先处理
start = time.clock()
while(len(not_direct_reach)>0):
#* 判断是否 连通：距离小于阈值，并且密度要大于子树的平均密度
node_id = not_direct_reach.pop()
if(node_id==129193 or node_id==61589 or node_id == 123593):
print(node_id)
if node_id in tree.sorted_gamma_index[0:10]:
cluster_forest[node_id] = tree.remove_subtree(node_id)
continue
node = tree.node_dir[node_id]
parent_id = node.parent_id
parent_node = tree.node_dir[parent_id]
children = parent_node.getChildren()
siblings_reliable = [ i for i in children if i not in not_direct_reach] #* 求得兄弟节点，其中兄弟节点不能是不直接可达的点
not_reliable_nodes = [i for i in children if i not in siblings_reliable]
if node_id in not_reliable_nodes:
not_reliable_nodes.remove(node_id)
if node_id in siblings_reliable:
siblings_reliable.remove(node_id)
pairs_nodes = is_connected_new(tree,local_density,dc_eps,node_id,siblings_reliable,not_reliable_nodes,mixin_near_matrix)
if len(pairs_nodes)==0:
if(node_id==tree.root_node.node_id):
continue
if(local_density[node_id]-mean_density*dc_eps)>=0:
#* 获取子节点个数:
offspring_id = tree.get_subtree_offspring_id(node_id,[node_id])
if(len(offspring_id)<local_density[node_id]):
uncertain_forest[node_id] = tree.remove_subtree(node_id)
pass
else:
cluster_forest[node_id] = tree.remove_subtree(node_id)
pass
pass
else:
outlier_forest[node_id] = tree.remove_subtree(node_id)
pass
pass
pass
end = time.clock()
print('切割树耗时 %s' % str(end - start))
cluster_forest[tree.root_node.node_id] = tree #* 添加根节点的树
return outlier_forest, cluster_forest, uncertain_forest
def is_connected_new(tree,local_density,dc_eps,cur_node_id,reliable_nodes,not_reliable_nodes,mixin_near_matrix):
'''
cur_node: 当前待判断与父节点连通度的点；
reliable_nodes：兄弟节点中与父节点直接相连的点；
not_reliable_nodes：兄弟节点中不与父节点直接相连的点，但可能间接相连；
连通度判断方案：
1. 判断 cur_node 与 reliable_nodes 是否可达，是则返回；没有则执行2；
2. 判断 cur_node 与 not_reliable_nodes(假设为[a,b,c,d,e]) 是否可达，若与[a,b,c]可达，与[d,e]不可达，执行3；
3. 循环遍历[a,b,c],递归调用本方法 is_connected_entropy(……,cur_node_id=[a],reliable_nodes,not_reliable_nodes=[b,c,d,e])
'''
#* 1.
if(len(reliable_nodes)==0):
return []
for reliable_node_id in reliable_nodes:
pairs_nodes, connected_nodes = tree.calcu_neighbor_btw_subtree(cur_node_id,reliable_node_id,mixin_near_matrix)
if(len(pairs_nodes)==0):
continue
# return pairs_nodes
cur_node_offspring = tree.get_subtree_offspring_id(cur_node_id,[cur_node_id])
local_density_cur_offspring = np.mean(local_density[cur_node_offspring])
local_density_connected_nodes = np.mean(local_density[connected_nodes])
if(local_density_connected_nodes>local_density_cur_offspring*dc_eps):
return pairs_nodes
pass
#* 2.
for i in range(len(not_reliable_nodes)):
pairs_nodes, connected_nodes = tree.calcu_neighbor_btw_subtree(cur_node_id,not_reliable_nodes[i],mixin_near_matrix)
if(len(pairs_nodes)==0):
pairs_nodes = is_connected_new(tree,local_density,dc_eps,not_reliable_nodes[i],reliable_nodes,not_reliable_nodes[i+1:],mixin_near_matrix)
if(len(pairs_nodes)>0):
return pairs_nodes
else:
cur_node_offspring = tree.get_subtree_offspring_id(cur_node_id,[cur_node_id])
local_density_cur_offspring = np.mean(local_density[cur_node_offspring])
local_density_connected_nodes = np.mean(local_density[connected_nodes])
if(local_density_connected_nodes>local_density_cur_offspring*dc_eps):
return pairs_nodes
# return pairs_nodes
# #* 连通点平均密度大于局部密度阈值，则更新最大相似度
cur_node_offspring = tree.get_subtree_offspring_id(cur_node_id,[cur_node_id])
local_density_cur_offspring = np.mean(local_density[cur_node_offspring])
local_density_connected_nodes = np.mean(local_density[connected_nodes])
if(local_density_connected_nodes>local_density_cur_offspring*dc_eps):
return pairs_nodes
if(len(pairs_nodes)==0):
pairs_nodes = is_connected_new(tree,local_density,dc_eps,not_reliable_nodes[i],reliable_nodes,not_reliable_nodes[i+1:],mixin_near_matrix)
if(len(pairs_nodes)>0):
return pairs_nodes
# pass
return []
def label_these_node_new(outlier_forest,cluster_forest,node_num,uncertain_forest,mixin_near_matrix):
'''
给森林中的样本点贴标签
考虑不确定点的分配
'''
labels = np.full((node_num),-1,dtype=np.int32)
for outlier_id in outlier_forest:
outlier_tree = outlier_forest[outlier_id]
outlier_idlist = outlier_tree.get_subtree_offspring_id(outlier_id,[outlier_id])
labels[outlier_idlist] = -1
pass
label = 0
for tree_id in cluster_forest:
cluster_tree = cluster_forest[tree_id]
cluster_idlist = cluster_tree.get_subtree_offspring_id(tree_id,[tree_id])
labels[cluster_idlist] = label
label = label + 1
pass
#todo 修改此处代码
for uncertain_tree_id in uncertain_forest:
uncertain_tree = uncertain_forest[uncertain_tree_id]
uncertain_nodes_id = uncertain_tree.get_subtree_offspring_id(uncertain_tree_id,[uncertain_tree_id])
all_near_nodes = np.array([],dtype=np.int32)
for node_id in uncertain_nodes_id:
all_near_nodes = np.append(all_near_nodes,mixin_near_matrix[node_id])
pass
# all_near_nodes = mixin_near_matrix[uncertain_nodes_id]
all_near_nodes = np.unique(all_near_nodes)
all_near_nodes = all_near_nodes[np.where(labels[all_near_nodes]!=-1)]
unique_labels,counts=np.unique(labels[all_near_nodes],return_counts=True)
if(len(counts)==0):
cur_label = -1
else:
cur_label = unique_labels[np.argmax(counts)]
labels[uncertain_nodes_id]=cur_label
pass
core_points = cluster_forest.keys()
return labels,core_points
'''
密度峰值树；
根据cfsfdp算法生成的局部密度、高密度最近邻距离、决策指标来生成 DPTree；
'''
class Node():
def __init__(self,node_id,attr_list,parent_id=None,dist_to_parent=None,each_dist_to_parent=[],density=None,gamma=None,children=[]):
self.node_id = node_id
self.attr_list = attr_list
self.parent_id = parent_id
self.dist_to_parent = dist_to_parent
self.each_dist_to_parent = each_dist_to_parent
self.density = density
self.children = children
self.gamma = gamma
self.offspring_num = None
self.lvl = None
def addChild(self,child):
self.children+=[child]
def removeChild(self,child):
self.children.remove(child)
def resetChildren(self):
self.children = []
def setParentId(self,parent_id):
self.parent_id = parent_id
def setOffspringNum(self,num):
self.offspring_num = num
def setLvl(self,lvl):
self.lvl = lvl
def getAttr(self):
return self.attr_list
def getNodeId(self):
return self.node_id
def getParentId(self):
return self.parent_id
def getDistToParent(self):
return self.dist_to_parent
def getDensity(self):
return self.density
def getGamma(self):
return self.gamma
def getChildren(self):
return self.children
def hasChildren(self,child_id):
if child_id in self.children:
return True
else:
return False
def getOffspringNum(self):
return self.offspring_num
def getLvl(self):
return self.lvl
class DPTree():
def __init__(self):
self.node_count = 0
self.node_dir = {}
self.root_node = None
self.node_offspring = {}
self.sorted_gamma_index = None
pass
def createTree(self,X,sorted_gamma_index,closest_node_id,closest_dis_denser,local_density,gamma):
#* 根据 gamma 顺序新建节点
node_dir = {}
node_created = np.zeros(len(sorted_gamma_index))
self.sorted_gamma_index = sorted_gamma_index
for i in range(len(sorted_gamma_index)):
node_id = sorted_gamma_index[i]
parent_id = closest_node_id[node_id] #* closest_node_id是根据排序后的gamma获得的
attr_list = X[node_id]
dist_to_parent = closest_dis_denser[node_id]
density = local_density[node_id]
if(node_created[node_id]==0):
node = Node(node_id,attr_list,parent_id,dist_to_parent,density,gamma[node_id],children=[])
node_created[node_id] = 1
node_dir[node_id] = node
node_dir[node_id].setParentId(parent_id)
if(node_created[parent_id]==0):
parent_node = Node(parent_id,X[parent_id],parent_id=None,dist_to_parent=closest_dis_denser[parent_id],density=local_density[parent_id],gamma=gamma[parent_id],children=[])
node_created[parent_id] = 1
node_dir[parent_id] = parent_node
parent_node = node_dir[parent_id]
cur_node = node_dir[node_id]
if(node_id != parent_id):#* 非根节点
parent_node.addChild(node_id)
# parent_lvl = parent_node.getLvl()
# cur_node.setLvl(parent_lvl+1)
else:
if(parent_node.getLvl()==None):
parent_node.setLvl(0)
#* 设置节点层次信息
# for i in tree.node_dir:
# pass
self.root_node = node_dir[sorted_gamma_index[0]]
self.node_dir = node_dir
self.node_count = len(sorted_gamma_index)
pass
def printTree2(self,parent_id,spaceStr=''):
for node_id in self.node_dir:
if(node_id==self.root_node.node_id):
continue
node = self.node_dir[node_id]
if(node.parent_id==parent_id):
print(spaceStr, node.node_id, sep = '')
self.printTree2(node.node_id,spaceStr+' ')
pass
def calcu_subtree_offspring_num(self,node_id):
node = self.node_dir[node_id]
cur_offsprings = node.getOffspringNum()
if(cur_offsprings!=None):
return cur_offsprings
child_num = len(node.children)
if(child_num==0):
return 0
for i in node.children:
cur_offsprings = self.calcu_subtree_offspring_num(i)
child_num+=cur_offsprings
node.setOffspringNum(child_num)
return child_num
def get_subtree_offspring_id(self,node_id,other_idlist):
'''
获取所有子孙的node_id
考虑：是否需要存储在node属性中。
'''
def fn_get_subtree_offspring_id(node_id,offspring_idlist):
if(node_id in self.node_offspring.keys()):
return self.node_offspring[node_id]
else:
node = self.node_dir[node_id]
children = node.getChildren()
child_num = len(children)
if(child_num==0):
self.node_offspring[node_id] = offspring_idlist
return offspring_idlist
offspring_idlist= list(offspring_idlist) + children
for i in children:
child_offspring_idlist = fn_get_subtree_offspring_id(i,[])
self.node_offspring[i] = child_offspring_idlist
offspring_idlist= list(offspring_idlist) + child_offspring_idlist
pass
self.node_offspring[node_id] = offspring_idlist
return offspring_idlist
offspring_idlist = fn_get_subtree_offspring_id(node_id,[])
return np.array(list(offspring_idlist) + other_idlist)
def calcu_subtree_entropy(self,offspring_id,local_density,closest_dis_denser):
p_sum = np.sum(local_density[offspring_id]/closest_dis_denser[offspring_id])
p = (local_density[offspring_id]/closest_dis_denser[offspring_id])/p_sum
entropy = -1*np.sum(p*np.log2(p))
#* 只有一个点的情况返回 0
if(entropy==0):
return 0
return entropy/(-1*np.log2(1/(len(offspring_id))))
def remove_subtree(self,child_id):
'''
删除 node_id 节点的子树：child_id, 被删除的子树形成新的树并返回
1. 更新 self.node_dir, self.node_count
2. 更新 node_id 节点的 children[], 以及所有父级offspring_num
3. 生成新树
'''
# print("删除子节点：",child_id)
offspring_id = self.get_subtree_offspring_id(child_id,[child_id])
offspring_len = len(offspring_id)
node_id = self.node_dir[child_id].parent_id
node = self.node_dir[node_id]
node.removeChild(child_id)
self.node_count = self.node_count-offspring_len
#* 删除存储的子孙节点
if(node_id in self.node_offspring.keys()):
for node_to_delete in offspring_id:
self.node_offspring[node_id].remove(node_to_delete)
print("删除子孙节点:",node_to_delete)
pass
pass
# cur_id = child_id
# parent_id = node_id
# #* 设置父级 offspring_num:
# while(cur_id!=parent_id):
# parent_node = self.node_dir[parent_id]
# if(parent_node.getOffspringNum()!=None):
# parent_node.setOffspringNum(parent_node.getOffspringNum()-offspring_len)
# cur_id = parent_id
# parent_id = parent_node.parent_id
# pass
#* 更新 self.node_dir, 生成新树:
new_tree = DPTree()
for i in offspring_id:
removed_node = self.node_dir.pop(i)
new_tree.node_dir[i] = removed_node
pass
new_tree.node_count = offspring_len
new_tree.root_node = new_tree.node_dir[child_id]
new_tree.root_node.setParentId(child_id)
return new_tree
def calcu_dist_betw_subtree(self,node_id_one,node_id_two,dist_mat,eps):
'''
计算两个子树间的连通距离
return：
1. 最短距离
2. 小于距离阈值的点集
'''
connected_nodes = np.array([],dtype=np.int32)
offspring_one = self.get_subtree_offspring_id(node_id_one,[node_id_one])
offspring_two = self.get_subtree_offspring_id(node_id_two,[node_id_two])
dist = float('inf')
for i in offspring_two:
tmp_dist = np.min(dist_mat[i][offspring_one])
if(tmp_dist<dist):
dist = tmp_dist
pass
connected_nodes_index = np.where(dist_mat[i][offspring_one]<eps)[0]
if len(connected_nodes_index)>0:
connected_nodes = np.r_[[i],connected_nodes,offspring_one[connected_nodes_index]]
pass
return dist, np.unique(connected_nodes)
def calcu_neighbor_btw_subtree(self,node_id_one,node_id_two,mixin_near_matrix):
'''
计算两个子树间的邻近点
return:
邻近的点对
所有邻近点
'''
connected_nodes = np.array([],dtype=np.int32)
offspring_one = self.get_subtree_offspring_id(node_id_one,[node_id_one])
offspring_two = self.get_subtree_offspring_id(node_id_two,[node_id_two])
pairs_nodes = []
for i in offspring_two:
connected_nodes_index = np.intersect1d(mixin_near_matrix[i],offspring_one)
if len(connected_nodes_index)>0:
for j in connected_nodes_index:
pairs_nodes.append([i,j])
pass
pass
if(len(pairs_nodes)==0):
return pairs_nodes,connected_nodes
return np.array(pairs_nodes), np.unique(np.array(pairs_nodes).flatten())
def calcu_dist_betw_subtree_entropy(self,node_id_one,node_id_two,dist_mat,eps):
'''
计算两个子树间的连通距离
return：
1. 最大相似距离
2. 大于相似距离阈值的点集
'''
connected_nodes = np.array([],dtype=np.int32)
offspring_one = self.get_subtree_offspring_id(node_id_one,[node_id_one])
offspring_two = self.get_subtree_offspring_id(node_id_two,[node_id_two])
dist = -1
for i in offspring_two:
tmp_dist = np.max(dist_mat[i][offspring_one])
if(tmp_dist>=dist):
dist = tmp_dist
pass
connected_nodes_index = np.where(dist_mat[i][offspring_one]>=eps)[0]
if len(connected_nodes_index)>0:
connected_nodes = np.r_[[i],connected_nodes,offspring_one[connected_nodes_index]]
pass
return dist, np.unique(connected_nodes)
def calcu_depth(self,node_id, depth):
node = self.node_dir[node_id]
parent_id = node.parent_id
if(node_id==parent_id):
return depth
else:
return self.calcu_depth(parent_id,depth+1) | ADPTC-LIB | /ADPTC_LIB-0.0.7.tar.gz/ADPTC_LIB-0.0.7/ADPTC_LIB/DPTree_ST.py | DPTree_ST.py |
ADPY
====
##Description
ADPY is a Python library for algorithmic differentiation (http://en.wikipedia.org/wiki/Automatic_differentiation).
It aims to provide an easy way to extract partial derivatives of vector valued function (Jacobian matrix). In addition it allows to created callable function for obtaining function values using computational graphs.
Features:
* optimize numerical evaluation by using computational graph
* create callable function from Sympy expressions (calls lambdify once and creates a computational graph)
* extract partial derivatives using forward or reverse algorithmic differentiation
* bonus: a small nonlinear solver using all advantages mentioned above
##How to use
Due the small amount of features the handling is quite easy.
For the easiest use you need a callable function which takes a list of float numbers and returns a list.
def f(x):
return [x[0]**2,2*x[1]]
You need a valid values for x which cause no singularities while evaluating the function.
x1 = [1.,2.]
Initialize the ADFUN object.
from ADPY import adfun
adpy_test = adfun(f,x1)
Now you have a callable function with computational graph optimization.
y1 = adpy_test(x1)
If you want to use derivatives just do
adpy_test.init_reverse_jac()
or
adpy_test.init_forward_jac()
Now you can evaluate them using
J_forward = adpy_test.jac_reverse(x1)
or
J_forward = adpy_test.jac_forward(x1)
For more information see the attached examples.
##Install
clone git
git clone https://github.com/zwenson/ADPY
and run setup.py
python setup.py install
or use easy_install
easy_install ADPY
##How it works
Without going in to detail. It uses an overloaded class "adfloat" to record a list of the mathematical operations required to obtain the result. This list is then translated in to python expressions and made executable. The list is also used to perform automatic differentiation.
##To do
* more testing
* add more operations
* maybe add Hessian matrix?
* add Taylor arithmetic?
| ADPY | /ADPY-0.12.alpha.tar.gz/ADPY-0.12.alpha/README.md | README.md |
[](https://travis-ci.org/PYNE-AD/cs207-FinalProject)
[](https://codecov.io/gh/PYNE-AD/cs207-FinalProject)
# cs207-FinalProject
## Group No. 12
-
Paulina Toro Isaza
- Yaowei Li
- Nikhil Vanderklaauw
- Emma Li
## Installation
### Requirements
1. Ensure you can run Python from the command line.
- You can check this by running: `python --version`
2. Ensure you can run pip form the command line.
- You can check this by running: `pip --version`
### Install the package
1. Using virtual environment
- Create an environment with the command: `conda create --name env_name python`
- Activating the environment: `conda activate env_name`
- You can get out of the environment (deactivate it) by typing: `conda deactivate`
2. Install the package from PyPi and dependencies
- Type `pip install ADPYNE-207`
| ADPYNE-207 | /ADPYNE-207-0.1.4.tar.gz/ADPYNE-207-0.1.4/README.md | README.md |
import numpy as np
class Dual():
def __init__(self, Real, Dual = 1):
self.Real = Real
self.Dual = Dual
self.coefficients = []
def makeHighestOrder(self, order):
theLongdual = self._createNestedduals(self.Real, self.Dual, order)**1
return theLongdual
def _createNestedduals(self, value, dual, order):
if order == 1:
return Dual(value)
else:
return Dual(self._createNestedduals(value, dual, order - 1), dual)
def buildCoefficients(self, n):
coeffs = []
for i in range(n + 1):
theCoeff = self
# get duals
for j in range(i):
theCoeff = theCoeff.Dual
# get Reals
for k in range(n-i):
theCoeff = theCoeff.Real
coeffs.append(theCoeff)
self.coefficients = coeffs
def __str__(self):
if len(self.coefficients) == 0:
return "{} + {}ε".format(self.Real, self.Dual)
else:
return "{}".format(self.coefficients)
def __add__(self, other):
try:
return Dual(self.Real + other.Real, self.Dual + other.Dual)
except AttributeError:
return Dual(self.Real + other, self.Dual)
def __radd__(self, other):
try:
return Dual(self.Real + other.Real, self.Dual + other.Dual)
except AttributeError:
return Dual(self.Real + other, self.Dual)
def __sub__(self, other):
try:
return Dual(self.Real - other.Real, self.Dual - other.Dual)
except AttributeError:
return Dual(self.Real - other, self.Dual)
def __rsub__(self, other):
try:
return Dual(self.Real - other.Real, self.Dual - other.Dual)
except AttributeError:
return Dual(other - self.Real, -1 * self.Dual)
def __mul__(self, other):
try:
return Dual(self.Real * other.Real, self.Dual * other.Real + self.Real * other.Dual)
except AttributeError:
return Dual(self.Real * other, self.Dual * other)
def __rmul__(self, other):
try:
return Dual(self.Real * other.Real, self.Dual * other.Real + self.Real * other.Dual)
except AttributeError:
return Dual(self.Real * other, self.Dual * other)
def __truediv__(self, other):
try:
return Dual(self.Real / other.Real, (self.Dual*other.Real - self.Real*other.Dual) / other.Real**2)
except AttributeError:
return Dual(self.Real / other, (self.Dual / other))
def __rtruediv__(self, other):
try:
return Dual(other.Real / self.Real, (other.Dual*self.Real - other.Real*self.Dual) / self.Real**2)
except AttributeError:
return Dual(other / self.Real, -1.0*((other*self.Dual)/(self.Real**2)))
def __pow__(self, other):
other = float(other) if type(other)==int else other
try: # need to do
return Dual(self.Real ** other.Real, self.Dual ** other.Dual)
except AttributeError:
return Dual(self.Real ** other, other * self.Dual * (self.Real ** (other - 1)))
def __rpow__(self, other):
try: # need to do
return Dual(other.Real ** self.Real, other.Dual ** self.Dual)
except AttributeError:
return Dual(other ** self.Real, self.Dual * np.log(other) * (other ** self.Real))
# Unary functions
def __neg__(self):
try:
return Dual(-1.0 * self.Real, -1.0 * self.Dual)
except:
return -1.0 * self
def __abs__(self):
return Dual(abs(self.Real), self.Dual/abs(self.Real))
def __pos__(self):
try:
return Dual(self.Real, self.Dual)
except:
return self
# Comparison
def __eq__(self, other):
try:
if np.all(self.Dual == other.Dual) and np.all(self.Real == other.Real):
return True
else:
return False
except AttributeError:
return False
def __ne__(self, other):
try:
if np.all(self.Dual == other.Dual) and np.all(self.Real == other.Real):
return False
else:
return True
except AttributeError:
return True
def vectorizeDual(functions, order):
n = len(functions)
m = order + 1
vector = np.zeros([n, m])
for i, f in enumerate(functions):
f.buildCoefficients(order)
for j, coeff in enumerate(f.coefficients):
vector[i,j] = coeff
# Create a copy of one function
f_everything = functions[0]
f_everything.coefficients = np.zeros([n, m])
for i in range(m):
f_everything.coefficients[:, i] = vector[:, i]
return f_everything
def makeHessianVars(x,y):
xh = x.makeHighestOrder(3)
yh = y.makeHighestOrder(3)
return xh, yh | ADPYNE-207 | /ADPYNE-207-0.1.4.tar.gz/ADPYNE-207-0.1.4/ADPYNE/Dual.py | Dual.py |
import warnings
import numpy as np
from ADPYNE.AutoDiff import AutoDiff
from ADPYNE.Dual import Dual
#-------------------BASE TRIG FUNCTIONS-------------------#
# Sine function
def sin(x):
''' Compute the sine of an AutoDiff object and its derivative.
Compute the sine of Dual Number
INPUTS
======
x: an AutoDiff object
RETURNS
=======
A new AutoDiff object with calculated value and derivative.
EXAMPLES
========
>>> x = AutoDiff(0.5, 2.0, 1.0)
>>> myAutoDiff = sin(x)
>>> myAutoDiff.val
0.479425538604
>>> myAutoDiff.der
1.75516512378
>>> myAutoDiff.jacobian
0.87758256189
'''
try:
new_val = np.sin(x.val)
new_der = np.cos(x.val) * x.der
new_jacobian = np.cos(x.val) * x.jacobian
return AutoDiff(new_val, new_der, x.n, 0, new_jacobian)
except AttributeError:
try:
return Dual(np.sin(x.Real), x.Dual * np.cos(x.Real))
except AttributeError:
try:
return Dual(sin(x.Real), x.Dual * cos(x.Real))
except AttributeError:
return np.sin(x)
# Cosine function
def cos(x):
''' Compute the cosine of an AutoDiff object and its derivative.
INPUTS
======
x: an AutoDiff object
RETURNS
=======
A new AutoDiff object with calculated value and derivative.
EXAMPLES
========
>>> x = AutoDiff(0.5, 2.0, 1.0)
>>> myAutoDiff = cos(x)
>>> myAutoDiff.val
0.87758256189
>>> myAutoDiff.der
-0.958851077208
>>> myAutoDiff.jacobian
-0.479425538604
'''
try:
new_val = np.cos(x.val)
new_der = -1.0 * np.sin(x.val) * x.der
new_jacobian = -1.0 * np.sin(x.val) * x.jacobian
return AutoDiff(new_val, new_der, x.n, 0, new_jacobian)
except AttributeError:
try:
return Dual(np.cos(x.Real), x.Dual * -np.sin(x.Real))
except AttributeError:
try:
return Dual(cos(x.Real), x.Dual * -sin(x.Real))
except AttributeError:
return np.cos(x)
# Tangent function
def tan(x):
''' Compute the tangent of an AutoDiff object and its derivative.
INPUTS
======
x: an AutoDiff object
'''
try:
# Value and derivative undefined when divisible by pi/2 but not pi
# To make sure the asymptotes are undefined:
if x.val%(np.pi/2)==0 and x.val%np.pi!=0:
new_val = np.nan
new_der = np.nan
new_jacobian = np.nan
warnings.warn('Undefined at value', RuntimeWarning)
else:
new_val = np.tan(x.val)
new_der = x.der / (np.cos(x.val)**2.0)
new_jacobian = x.jacobian / (np.cos(x.val)**2.0)
return AutoDiff(new_val, new_der, x.n, 0, new_jacobian)
except AttributeError:
try:
if x.Real%(np.pi/2)==0 and x.Real%np.pi!=0:
ans = Dual(np.nan,np.nan)
warnings.warn('Undefined at value', RuntimeWarning)
return ans
else:
return Dual(np.tan(x.Real), x.Dual / (np.cos(x.Real))**2)
except AttributeError:
try:
if x.Real%(np.pi/2)==0 and x.Real%np.pi!=0:
ans = Dual(np.nan,np.nan)
warnings.warn('Undefined at value', RuntimeWarning)
return ans
else:
# return Dual(tan(x.Real), x.Dual / (cos(x.Real))**2)
return sin(x)/cos(x)
except AttributeError:
if x%(np.pi/2)==0 and x%np.pi!=0:
warnings.warn('Undefined at value', RuntimeWarning)
return np.nan
else:
return np.tan(x)
#-------------------INVERSE TRIG FUNCTIONS-------------------#
# arc sin
def arcsin(X):
''' Compute the arcsin of an AutoDiff object and its derivative.
INPUTS
======
X: an AutoDiff object or constant
RETURNS
=======
A new AutoDiff object or scalar with calculated value and derivative.
EXAMPLES
========
>>> X = AutoDiff(0.5, 2)
>>> arcsinAutoDiff = arcsin(X)
>>> arcsinAutoDiff.val
0.5235987755982988
>>> arcsinAutoDiff.der
2.3094010767585034
>>> arcsinAutoDiff.jacobian
1.1547005383792517
'''
try:
# Is another ADT
new_val = np.arcsin(X.val)
new_der = (1/np.sqrt(1-X.val**2))*X.der
new_jacobian = (1/np.sqrt(1-X.val**2))*X.jacobian
return AutoDiff(new_val, new_der, X.n, 0, new_jacobian)
except AttributeError:
try:
return Dual(np.arcsin(X.Real), X.Dual/np.sqrt(1-X.Real**2))
except AttributeError:
try:
# return Dual(arcsin(X.Real), X.Dual/sqrt(1-X.Real**2))
return Dual(arcsin(X.Real), (X.Dual*(1-X.Real**2)**-0.5))
except AttributeError:
# Constant
return_val = np.arcsin(X)
return return_val
# arc cosine
def arccos(X):
''' Compute the arccos of an AutoDiff object and its derivative.
INPUTS
======
X: an AutoDiff object or constant
RETURNS
=======
A new AutoDiff object or scalar with calculated value and derivative.
EXAMPLES
========
>>> X = AutoDiff(0.5, 2)
>>> arccosAutoDiff = arccos(X)
>>> arccosAutoDiff.val
1.0471975511965976
>>> arccosAutoDiff.der
-2.3094010767585034
>>> arccosAutoDiff.jacobian
-1.1547005383792517
'''
try:
# Is another ADT
new_val = np.arccos(X.val) #if (-1 <= X.val and X.val <= 1) else np.nan
new_der = (-1/np.sqrt(1-X.val**2))*X.der #if (-1 < X.val and X.val < 1) else np.nan
new_jacobian = (-1/np.sqrt(1-X.val**2))*X.jacobian #if (-1 < X.val and X.val < 1) else np.nan
return AutoDiff(new_val, new_der, X.n, 0, new_jacobian)
except AttributeError:
try:
return Dual(np.arccos(X.Real), -X.Dual/np.sqrt(1-X.Real**2))
except AttributeError:
try:
return Dual(arccos(X.Real), -X.Dual/sqrt(1-X.Real**2))
except AttributeError:
# Constant
return_val = np.arccos(X)
return return_val
# arc tangent
def arctan(X):
''' Compute the arctan of an AutoDiff object and its derivative.
INPUTS
======
X: an AutoDiff object or constant
RETURNS
=======
A new AutoDiff object or scalar with calculated value and derivative.
EXAMPLES
========
>>> X = AutoDiff(3, 2)
>>> arctanAutoDiff = arctan(X)
>>> arctanAutoDiff.val
1.2490457723982544
>>> arctanAutoDiff.der
0.2
>>> arctanAutoDiff.jacobian
0.1
'''
try:
# Is another ADT
new_val = np.arctan(X.val)
new_der = (1/(1+X.val**2))*X.der
new_jacobian = (1/(1+X.val**2))*X.jacobian
return AutoDiff(new_val, new_der, X.n, 0, new_jacobian)
except AttributeError:
try:
return Dual(np.arctan(X.Real), X.Dual/(1+X.Real**2))
except AttributeError:
try:
return Dual(arctan(X.Real), X.Dual/(1+X.Real**2))
except AttributeError:
# Constant
return_val = np.arctan(X)
return return_val
#-------------------HYPERBOLIC TRIG FUNCTIONS-------------------#
# hyperbolic sin
def sinh(X):
''' Compute the sinh of an AutoDiff object and its derivative.
INPUTS
======
X: an AutoDiff object
RETURNS
=======
A new AutoDiff object with calculated value and derivative.
EXAMPLES
========
>>> X = AutoDiff(0.5, 2, 1)
>>> sinhAutoDiff = sinh(X)
>>> sinhAutoDiff.val
0.5210953054937474
>>> sinhAutoDiff.der
2.2552519304127614
>>> sinhAutoDiff.jacobian
1.1276259652063807
'''
try:
val = np.sinh(X.val)
der = np.cosh(X.val)*X.der
jacobian = np.cosh(X.val)*X.jacobian
return AutoDiff(val, der, X.n, 0, jacobian)
except AttributeError:
try:
return Dual(np.sinh(X.Real), X.Dual*np.cosh(X.Real))
except AttributeError:
try:
return Dual(sinh(X.Real), X.Dual*cosh(X.Real))
except AttributeError:
# Constant
return_val = np.sinh(X)
return return_val
# hyperbolic cos
def cosh(X):
''' Compute the cosh of an AutoDiff object and its derivative.
INPUTS
======
X: an AutoDiff object
RETURNS
=======
A new AutoDiff object with calculated value and derivative.
EXAMPLES
========
>>> X = AutoDiff(0.5, 2, 1)
>>> coshAutoDiff = cosh(X)
>>> coshAutoDiff.val
1.1276259652063807
>>> coshAutoDiff.der
1.0421906109874948
>>> coshAutoDiff.jacobian
0.5210953054937474
'''
try:
val = np.cosh(X.val)
der = np.sinh(X.val)*X.der
jacobian = np.sinh(X.val)*X.jacobian
return AutoDiff(val, der, X.n, 0, jacobian)
except AttributeError:
try:
return Dual(np.cosh(X.Real), X.Dual*np.sinh(X.Real))
except AttributeError:
try:
return Dual(cosh(X.Real), X.Dual*sinh(X.Real))
except AttributeError:
# Constant
return_val = np.cosh(X)
return return_val
# hyperbolic tan
def tanh(X):
''' Compute the tanh of an AutoDiff object and its derivative.
INPUTS
======
X: an AutoDiff object
RETURNS
=======
A new AutoDiff object with calculated value and derivative.
EXAMPLES
========
>>> X = AutoDiff(0.5, 2, 1)
>>> tanhAutoDiff = tanh(X)
>>> tanhAutoDiff.val
0.46211715726000974
>>> tanhAutoDiff.der
1.572895465931855
>>>tanhAutoDiff.jacobian
0.7864477329659275
'''
try:
val = np.tanh(X.val)
der = 1/(np.cosh(X.val)**2)*X.der
jacobian = 1/(np.cosh(X.val)**2)*X.jacobian
return AutoDiff(val, der, X.n, 0, jacobian)
except AttributeError:
try:
return Dual(np.tanh(X.Real), X.Dual/(np.cosh(X.Real)**2))
except AttributeError:
try:
X.Real
return sinh(X)/cosh(X)
except AttributeError:
# Constant
return_val = np.tanh(X)
return return_val
#-------------------ARC HYPERBOLIC TRIG FUNCTIONS-------------------#
# hyperbolic arcsin
def arcsinh(x):
''' Compute the hyperbolic arc sine of an AutoDiff object and its derivative.
INPUTS
======
x: an AutoDiff object
RETURNS
=======
A new AutoDiff object with calculated value and derivative.
EXAMPLES
========
>>> x = AutoDiff(0.5, 2, 1)
>>> myAutoDiff = arcsinh(x)
>>> myAutoDiff.val
2.3124383412727525
>>> myAutoDiff.der
0.39223227027
>>> myAutoDiff.jacobian
0.19611613513818404
'''
try:
new_val = np.arcsinh(x.val)
new_der = ((1)/np.sqrt(x.val**2 + 1))*x.der
new_jacobian = ((1)/np.sqrt(x.val**2 + 1))*x.jacobian
return AutoDiff(new_val, new_der, x.n, 0, new_jacobian)
except AttributeError:
try:
return Dual(np.arcsinh(x.Real), x.Dual/np.sqrt((x.Real**2)+1))
except AttributeError:
try:
return Dual(arcsinh(x.Real), (x.Dual*(1+x.Real**2)**-0.5))
except AttributeError:
# Constant
return_val = np.arcsinh(x)
return return_val
# hyperbolic arc cosine
def arccosh(x):
''' Compute the hyperbolic arc cosine of an AutoDiff object and its derivative.
INPUTS
======
x: an AutoDiff object
RETURNS
=======
A new AutoDiff object with calculated value and derivative.
EXAMPLES
========
>>> x = AutoDiff(1.1, 2)
>>> myAutoDiff = arccosh(x)
>>> myAutoDiff.val
0.4435682543851154
>>> myAutoDiff.der
(2/np.sqrt(1.1**2 - 1))
>>> myAutoDiff.jacobian
(1/np.sqrt(1.1**2 - 1))
'''
try:
new_val = np.arccosh(x.val)
# Derivative of arccosh is only defined when x > 1
new_der = ((1)/np.sqrt(x.val**2 - 1))*x.der # if x.val > 1 else None
new_jacobian = ((1)/np.sqrt(x.val**2 - 1))*x.jacobian # if x.val > 1 else None
return AutoDiff(new_val, new_der, x.n, 0, new_jacobian)
except AttributeError:
try:
return Dual(np.arccosh(x.Real), x.Dual/np.sqrt((x.Real**2)-1))
except AttributeError:
try:
return Dual(arccosh(x.Real), (x.Dual*((x.Real**2)-1)**-0.5))
except AttributeError:
# Constant
return_val = np.arccosh(x)
return return_val
# hyperbolic arc tangent
def arctanh(x):
''' Compute the hyperbolic arc tangent of an AutoDiff object and its derivative.
INPUTS
======
x: an AutoDiff object
RETURNS
=======
A new AutoDiff object with calculated value and derivative.
EXAMPLES
========
>>> x = AutoDiff(0.5, 2)
>>> myAutoDiff = arctanh(x)
>>> myAutoDiff.val
0.5493061443340548
>>> myAutoDiff.der
2/(1-(0.5)**2)
>>> myAutoDiff.jacobian
1/(1-(0.5)**2)
'''
try:
new_val = np.arctanh(x.val)
new_der = ((1)/(1-x.val**2))*x.der
new_jacobian = ((1)/(1-x.val**2))*x.jacobian
return AutoDiff(new_val, new_der, x.n, 0, new_jacobian)
except AttributeError:
try:
if(np.abs(x.Real)==1):
real = np.inf
dual = np.inf
warnings.warn('Undefined at value', RuntimeWarning)
else:
real = np.arctanh(x.Real)
dual = x.Dual/(1-x.Real**2)
return Dual(real, dual)
except AttributeError:
try:
return Dual(arctanh(x.Real), x.Dual/(1-x.Real**2))
except AttributeError:
# Constant
return_val = np.arctanh(x)
return return_val
#--------------------------EXPONENT FAMILY----------------------------#
# Exponential
def exp(x):
''' Compute the exponential of an AutoDiff object and its derivative.
INPUTS
======
x: an AutoDiff object
RETURNS
=======
A new AutoDiff object with calculated value and derivative.
EXAMPLES
========
>>> x = AutoDiff(10, 2)
>>> myAutoDiff = exp(x)
>>> myAutoDiff.val
22026.465794806718
>>> myAutoDiff.der
2*22026.465794806718
>>> myAutoDiff.jacobian
22026.465794806718
'''
try:
new_val = np.exp(x.val)
new_der = np.exp(x.val) * x.der
new_jacobian = np.exp(x.val) * x.jacobian
return AutoDiff(new_val, new_der, x.n, 0, new_jacobian)
except AttributeError:
try:
return Dual(np.exp(x.Real), x.Dual*np.exp(x.Real))
except AttributeError:
try:
return Dual(exp(x.Real), x.Dual*exp(x.Real))
except AttributeError:
# Constant
return_val = np.exp(x)
return return_val
# natural log
def log(x):
''' Compute the natural log of an AutoDiff object and its derivative.
INPUTS
======
x: an AutoDiff object
RETURNS
=======
A new AutoDiff object with calculated value and derivative.
EXAMPLES
========
x = AutoDiff(4, 2)
>>> myAutoDiff = log(x)
>>> myAutoDiff.val
1.3862943611198906
>>> myAutoDiff.der
0.5
>>> myAutoDiff.jacobian
0.25
'''
try:
new_val = np.log(x.val)
# Derivative not defined when x = 0
new_der = (1/(x.val*np.sum(1)))*x.der # if x.val != 0 else None
new_jacobian = (1/(x.val*np.sum(1)))*x.jacobian # if x.val != 0 else None
return AutoDiff(new_val, new_der, x.n, 0, new_jacobian)
except AttributeError:
try:
if(x.Real==0):
real = -np.inf
dual = np.inf
else:
real = np.log(x.Real)
dual = x.Dual/x.Real
return Dual(real, dual)
except AttributeError:
try:
return Dual(log(x.Real), x.Dual/x.Real)
except AttributeError:
# Constant
return_val = np.log(x)
return return_val
# log base 10
def log10(x):
''' Compute the natural log of an AutoDiff object and its derivative.
INPUTS
======
x: an AutoDiff object
RETURNS
=======
A new AutoDiff object with calculated value and derivative.
EXAMPLES
========
>>> X = AutoDiff(0.5, 2, 1)
>>> myAutoDiff = log(X)
>>> myAutoDiff.val
-0.3010299956639812
>>> myAutoDiff.der
1.737177927613007
>>>myAutoDiff.jacobian
0.8685889638065035
'''
try:
new_val = np.log10(x.val)
# Derivative not defined when x = 0
new_der = (1/(x.val*np.log(10)))*x.der
new_jacobian = (1/(x.val*np.log(10)))*x.jacobian
return AutoDiff(new_val, new_der, x.n, 0, new_jacobian)
except AttributeError:
try:
real = np.log10(x.Real)
dual = x.Dual/(x.Real*np.log(10))
return Dual(real, dual)
except AttributeError:
try:
return Dual(log(x.Real)/np.log(10), x.Dual/(x.Real*(np.log(10))))
except AttributeError:
# Constant
return_val = np.log10(x)
return return_val
# Square Root
def sqrt(x):
''' Compute the square root an AutoDiff object and its derivative.
INPUTS
======
x: an AutoDiff object
RETURNS
=======
A new AutoDiff object with calculated value and derivative.
EXAMPLES
========
>>> x = AutoDiff(np.array([[5]]).T, np.array([[1]]), 1, 1)
>>> myAutoDiff = sqrt(x)
>>> myAutoDiff.val
2.2360679775
>>> myAutoDiff.der
0.2236068
'''
try:
new_val = np.sqrt(x.val)
new_der = 0.5 * x.val ** (-0.5) * x.der
new_jacobian = 0.5 * x.val ** (-0.5) * x.jacobian
return AutoDiff(new_val, new_der, x.n, 0, new_jacobian)
except AttributeError:
try:
if x.Real < 0.0:
warnings.warn('Undefined at value', RuntimeWarning)
dual=np.nan
elif(x.Real==0):
warnings.warn('Undefined at value', RuntimeWarning)
dual = np.inf
else:
dual = 0.5 * x.Real ** (-0.5) * x.Dual
real = np.sqrt(x.Real)
return Dual(real, dual)
except AttributeError:
if x < 0.0:
warnings.warn('Undefined at value', RuntimeWarning)
return np.nan
else:
return np.sqrt(x)
# log base
def logbase(x,base):
''' Compute any log base of an AutoDiff object and its derivative.
INPUTS
======
x: an AutoDiff object
RETURNS
=======
A new AutoDiff object with calculated value and derivative.
EXAMPLES
========
x = AutoDiff(2, 2)
>>> myAutoDiff = logbase(x,7)
>>> myAutoDiff.val
0.35620719
>>> myAutoDiff.der
0.51389834
>>> myAutoDiff.jacobian
0.25694917
'''
try:
new_val = np.log(x.val)/np.log(base)
# Derivative not defined when x = 0
new_der = (1/(x.val*np.log(base)))*x.der
new_jacobian = (1/(x.val*np.log(base)))*x.jacobian
return AutoDiff(new_val, new_der, x.n, 0, new_jacobian)
except AttributeError:
try:
return Dual(np.log(x.Real)/np.log(base), x.Dual/(x.Real*np.log(base)))
except AttributeError:
try:
return Dual(log(x.Real)/np.log(base), x.Dual/(x.Real*(np.log(base))))
except AttributeError:
# Constant
return_val = np.log(x)/np.log(base)
return return_val
def logistic(x):
''' Compute logistic function for AutoDiff or Dual object.
INPUTS
======
x: an AutoDiff object or Dual object
RETURNS
=======
A new AutoDiff or Dual object with calculated value and derivative.
'''
try:
f_l = (1/(1+np.exp(-x.val)))
new_val = f_l
new_der = (1 - f_l)*f_l*x.der
new_jacobian = (1 - f_l)*f_l*x.jacobian
return AutoDiff(new_val, new_der, x.n, 0, new_jacobian)
except AttributeError:
try:
f_l = (1/(1 + np.exp(-x.Real)))
return Dual(f_l, (1 - f_l)*f_l*x.Dual)
except AttributeError:
try:
return Dual(logistic(x.Real), (1 - logistic(x.Real))*logistic(x.Real)*x.Dual)
except AttributeError:
# Constant
return_val = (1/(1+np.exp(-x)))
return return_val | ADPYNE-207 | /ADPYNE-207-0.1.4.tar.gz/ADPYNE-207-0.1.4/ADPYNE/elemFunctions.py | elemFunctions.py |
import numpy as np
class AutoDiff():
'''
An auto-differentiation object for scalar and vector functions
'''
def __init__(self, eval_value, der_value, n=1, k=1, jacobian_value = np.array([[None]])):
'''
INPUTS
======
eval_value: value to be evaluated at
der_value: evaluated value of the derivative
n: number of input variables the final function will use
k: denotes that the autodiff uses the kth input variable in a vector of 1 to n variables
jacob_value: denotes the evaluted value of the jacobian
RETURNS
=======
An AutoDiff object with calculated value, derivative, and jacobian.
EXAMPLES
========
>>> myAutoDiff = AutoDiff(3, 2)
>>> myAutoDiff.val
3
>>> myAutoDiff.der
2
>>> myAutoDiff.jacobian
1
'''
# Convert int or float to array
self.val = self._convertNonArray(eval_value, k)
self.jacobian = self._calcJacobian(k, n, jacobian_value)
self.der = self._calcDerivative(der_value, k)
self.n = n
def _convertNonArray(self, value, k):
# try:
# value.shape
# return value
# except:
# return np.array([[value]])
if k != 0:
try:
return np.array(value).reshape(len(value), 1)
except:
return np.array([[value]])
else:
return value
def _calcJacobian(self, k, n, jacobian_value):
if np.all(np.equal(jacobian_value, None)):
if k != 0:
rows = self.val.shape[0]
seed = np.zeros([rows, n])
seed[:, k-1] = 1
return seed
else:
return jacobian_value
def _calcDerivative(self, der_value, k):
if k != 0:
jacobian = (np.array([self.jacobian[0]]))
der = self._convertNonArray(der_value, k)
return np.dot(der, jacobian) * self.jacobian**0
else:
return self._convertNonArray(der_value, k)
def __str__(self):
return "Value:\n{}\nDerivative:\n{}\nJacobian:\n{}\n".format(self.val, self.der, self.jacobian)
def __repr__(self):
return "Value:\n{}\nDerivative:\n{}\nJacobian:\n{}\n".format(self.val, self.der, self.jacobian)
def __add__(self, other):
try:
# If AutoDiff of same variable, values and derivatives should both just add
return AutoDiff(self.val + other.val, self.der + other.der, self.n, 0, self.jacobian + other.jacobian)
except AttributeError:
# If trying to add a constant to AutoDiff, only add values. Constant has derivative of 0 so no addition needed.
return AutoDiff(self.val + other, self.der, self.n, 0, self.jacobian)
# Account for reverse addition
def __radd__(self, other):
try:
return AutoDiff(self.val + other.val, self.der + other.der, self.n, 0, self.jacobian + other.jacobian)
except AttributeError:
return AutoDiff(self.val + other, self.der, self.n, 0, self.jacobian)
def __sub__(self, other):
try:
# If AutoDiff of same variable, values and derivatives should both just add
return AutoDiff(self.val - other.val, self.der - other.der, self.n, 0, self.jacobian - other.jacobian)
except AttributeError:
# If trying to add a constant to AutoDiff, only add values. Constant has derivative of 0 so no subtraction needed.
return AutoDiff(self.val - other, self.der, self.n, 0, self.jacobian)
# Account for reverse subtraction
def __rsub__(self, other):
try:
return AutoDiff(other.val - self.val, other.der - self.der, self.n, 0, other.jacobian - self.jacobian)
except AttributeError:
return AutoDiff(other - self.val, self.der, self.n, 0, self.jacobian)
def __mul__(self, other):
try:
# Use product rule
return AutoDiff(self.val * other.val, self.val * other.der + self.der * other.val, self.n, 0, self.val * other.jacobian + self.jacobian * other.val)
except AttributeError:
return AutoDiff(self.val * other, self.der * other, self.n, 0, self.jacobian * other)
# Account for reverse multiplication
def __rmul__(self, other):
try:
# Use product rule
return AutoDiff(self.val * other.val, self.val * other.der + self.der * other.val, self.n, 0, self.val * other.jacobian + self.jacobian * other.val)
except AttributeError:
return AutoDiff(self.val * other, self.der * other, self.n, 0, self.jacobian * other)
def __truediv__(self, other):
try:
# Use quotient rule
return AutoDiff(self.val / other.val, (self.der * other.val - self.val * other.der)/(other.val**2), self.n, 0, (self.jacobian * other.val - self.val * other.jacobian)/(other.val**2))
except AttributeError:
return AutoDiff(self.val / other, self.der / other, self.n, 0, self.jacobian / other)
# Account for reverse true division
def __rtruediv__(self, other):
try:
# Use quotient rule
# other/self
return AutoDiff(other.val / self.val, (self.val * other.der - other.val * self.der)/(self.val**2), self.n, 0, (other.jacobian * self.val - other.val * self.jacobian)/(self.val**2) )
except AttributeError:
return AutoDiff(other / self.val, (self.val * 0 - other * self.der)/(self.val**2), self.n, 0, (self.val * 0 - other * self.jacobian)/(self.val**2))
def __pow__(self, other):
# Convert to float so that negative integers will work
other = float(other) if type(other)==int else other
try:
return AutoDiff(self.val**other.val, other.val * (self.val ** (other.val-1)) * self.der + (self.val**other.val) *np.log(np.abs(self.val)) * other.der, self.n, 0, other.val * (self.val**(other.val-1)) * self.jacobian + (self.val**other.val * np.log(np.abs(self.val)) * other.jacobian))
except AttributeError:
return AutoDiff(self.val**other, other * (self.der) * self.val**(other-1), self.n, 0, other * (self.jacobian) * self.val**(other-1))
def __rpow__(self, other):
try:
return AutoDiff(other.val**self.val, other.val * (self.val ** (other.val-1)) * self.der + (self.val**other.val) *np.log(np.abs(self.val)) * other.der, self.n, 0, other.val * (self.val**(other.val-1)) * self.jacobian + (self.val**other.val * np.log(np.abs(self.val)) * other.jacobian))
except AttributeError:
return AutoDiff(other**self.val, np.log(other) * other**self.val * self.der, self.n, 0, np.log(other) * other**self.val * self.jacobian)
# Unary operations
# Unary addition: identity
def __pos__(self):
return self
# Unary subtration: negation
def __neg__(self):
# If AutoDiff of same variable, values and derivatives should both just add
return AutoDiff(self.val * -1, self.der * -1, self.n, 0, self.jacobian * -1)
def __abs__(self):
return AutoDiff(abs(self.val), ((self.val * self.der) / abs(self.val)),
self.n, 0, ((self.val * self.jacobian) / abs(self.val)))
def __invert__(self):
return AutoDiff(~self.val, self.der * -1, self.n, 0, self.jacobian * -1)
def __eq__(self, other):
try:
if np.all(np.equal(self.val,other.val)) and np.all(np.equal(self.der,other.der)):
return True
else:
return False
except AttributeError:
return False
def __ne__(self, other):
try:
if np.all(np.equal(self.val,other.val)) and np.all(np.equal(self.der,other.der)):
return False
else:
return True
except AttributeError:
return True
def vectorize(ad_functions, n_inputs = 1, n_vectors = 1):
'''
INPUTS
======
ad_functions: a list or row vector of AutoDiff objects
n_inputs: number of input variables the final function will use
n_vectors: length of vector for input variables
RETURNS
=======
An AutoDiff object of vector functions with calculated value, derivative, and jacobian.
EXAMPLES
========
>>> x = AutoDiff(3, np.array([[2, 0, 0]]), n=3, k=1)
>>> y = AutoDiff(2, np.array([[0, 2, 0]]), n=3, k=2)
>>> z = AutoDiff(-1, np.array([[0, 0, 2]]), n=3, k=3)
>>> fs = [3*x + 2*y + 4*z, x - y + z, x/2, 2*x - 2*y]
>>> f = vectorize(fs, 3)
>>> f.val
np.array([[9],[0],[1.5],[2]]
>>> f.der
np.array([[6, 4, 8], [2, -2, 2], [1, 0, 0], [4, -4, 0]])
>>> f.jacobian
np.array([[3, 2, 4], [1, -1, 1], [0.5, 0, 0], [2, -2, 0]])
'''
if n_vectors == 1:
val = np.zeros([len(ad_functions), n_vectors])
der = np.zeros([len(ad_functions), n_inputs])
jacobian = np.zeros([len(ad_functions), n_inputs])
for i, f in enumerate(ad_functions):
val[i, :] = f.val
der[i, :] = f.der
jacobian[i, :] = f.jacobian
else:
val = np.zeros([len(ad_functions), n_vectors])
der = np.zeros([n_vectors, len(ad_functions), n_inputs])
jacobian = np.zeros([n_vectors, len(ad_functions), n_inputs])
for j in range(n_vectors):
der_j = der[j]
jac_j = jacobian[j]
for i, f in enumerate(ad_functions):
val[i, :] = f.val.T
der_j[i, :] = f.der[j]
jac_j[i, :] = f.jacobian[j]
return AutoDiff(val, der, n_inputs, 0, jacobian) | ADPYNE-207 | /ADPYNE-207-0.1.4.tar.gz/ADPYNE-207-0.1.4/ADPYNE/AutoDiff.py | AutoDiff.py |
Aircraft Design Recipes in Python
=================================
[](https://badge.fury.io/py/ADRpy)
[](https://travis-ci.com/sobester/ADRpy)
A library of aircraft conceptual design and performance analysis tools, including
virtual (design) atmospheres, constraint analysis methods, propulsion system
performance models, conversion functions and much else.
For a detailed description of the library, please consult the
[Documentation](https://adrpy.readthedocs.io/en/latest/). To get started,
follow the instructions below.
For video tutorials and explainers (a.k.a. *ADRpy Shorts*) scroll to the bottom of this page.
author: Andras Sobester
Installation / Usage
--------------------
ADRpy is written in Python 3 and tested in Python 3.5, 3.6, 3.7 and 3.8.
It is not available for Python 2.
On most systems you should be able to simply open an operating system terminal
and at the command prompt type
$ pip install ADRpy
or
$ python -m pip install ADRpy
NOTE: `pip` is a Python package; if it is not available on your system, download
[get-pip.py](https://bootstrap.pypa.io/get-pip.py) and run it in Python by entering
$ python get-pip.py
at the operating system prompt.
An alternative approach to installing ADRpy is to clone the GitHub repository, by typing
$ git clone https://github.com/sobester/ADRpy.git
at the command prompt and then executing the setup file in the same directory by entering:
$ python setup.py install
A 'hello world' example: atmospheric properties
-----------------------------------------------
There are several options for running the examples shown here: you could copy and paste them
into a `.py` file, save it and run it in Python, or you could enter the lines, in sequence,
at the prompt of a Python terminal. You could also copy and paste them into a Jupyter notebook
(`.ipynb` file) cell and execute the cell.
```python
from ADRpy import atmospheres as at
from ADRpy import unitconversions as co
# Instantiate an atmosphere object: an ISA with a +10C offset
isa = at.Atmosphere(offset_deg=10)
# Query the ambient density in this model at 41,000 feet
print("ISA+10C density at 41,000 feet (geopotential):",
isa.airdens_kgpm3(co.feet2m(41000)), "kg/m^3")
```
You should see the following output:
ISA+10C density at 41,000 feet (geopotential): 0.274725888531 kg/m^3
A design example: wing/powerplant sizing for take-off
-----------------------------------------------------
```python
# Compute the thrust to weight ratio required for take-off, given
# a basic design brief, a basic design definition and a set of
# atmospheric conditions
from ADRpy import atmospheres as at
from ADRpy import constraintanalysis as ca
from ADRpy import unitconversions as co
# The environment: 'unusually high temperature at 5km' atmosphere
# from MIL-HDBK-310.
# Extract the relevant atmospheric profiles...
profile_ht5_1percentile, _ = at.mil_hdbk_310('high', 'temp', 5)
# ...then use them to create an atmosphere object
m310_ht5 = at.Atmosphere(profile=profile_ht5_1percentile)
#====================================================================
# The take-off aspects of the design brief:
designbrief = {'rwyelevation_m':1000, 'groundrun_m':1200}
# Basic features of the concept:
# aspect ratio, engine bypass ratio, throttle ratio
designdefinition = {'aspectratio':7.3, 'bpr':3.9, 'tr':1.05}
# Initial estimates of aerodynamic performance:
designperf = {'CDTO':0.04, 'CLTO':0.9, 'CLmaxTO':1.6,
'mu_R':0.02} # ...and wheel rolling resistance coeff.
# An aircraft concept object can now be instantiated
concept = ca.AircraftConcept(designbrief, designdefinition,
designperf, m310_ht5)
#====================================================================
# Compute the required standard day sea level thrust/MTOW ratio reqd.
# for the target take-off performance at a range of wing loadings:
wingloadinglist_pa = [2000, 3000, 4000, 5000]
tw_sl, liftoffspeed_mpstas, _ = concept.twrequired_to(wingloadinglist_pa)
# The take-off constraint calculation also supplies an estimate of
# the lift-off speed; this is TAS (assuming zero wind) - we convert
# it to equivalent airspeed (EAS), in m/s:
liftoffspeed_mpseas = \
m310_ht5.tas2eas(liftoffspeed_mpstas, designbrief['rwyelevation_m'])
print("Required T/W and V_liftoff under MIL-HDBK-310 conditions:")
print("\nT/W (std. day, SL, static thrust):", tw_sl)
print("\nLiftoff speed (KEAS):", co.mps2kts(liftoffspeed_mpseas))
```
You should see the following output:
Required T/W and V_liftoff under MIL-HDBK-310 conditions:
T/W (std. day, SL, static thrust): [ 0.19618164 0.2710746 0.34472518 0.41715311]
Liftoff speed (KEAS): [ 96.99203483 118.79049722 137.1674511 153.35787248]
More extensive examples - a library of notebooks
------------------------------------------------
To view them on GitHub, go to [ADRpy's notebooks folder](https://github.com/sobester/ADRpy/tree/master/docs/ADRpy/notebooks).
Alternatively, grab the whole repository as a .zip by clicking the big, green 'Code' button at the top of this page.
ADRpy Shorts - video tutorials and explainers
---------------------------------------------------------
**1. An Aircraft Engineer's Brief Introduction to Modelling the Atmosphere**
[](http://www.youtube.com/watch?v=II9vuVCgV-w)
**2. On V-n Diagrams and How to Build them in ADRpy**
[](http://www.youtube.com/watch?v=s-d5z-BQovY)
**3. Speed in aviation - GS, WS, TAS, IAS, CAS and EAS**
[](http://www.youtube.com/watch?v=WSzDXlTlXiI)
**4. Wing and propulsion system sizing with ADRpy**
[](https://www.youtube.com/watch?v=TMM7mE1NjaE)
| ADRpy | /ADRpy-0.2.5.tar.gz/ADRpy-0.2.5/README.md | README.md |
import requests
from multiprocessing.synchronize import Lock
import multiprocessing as mp
from dataclasses import dataclass
from time import sleep
import logging as log
import traceback
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from .errors import AdsError
from .configs import UserProxyConfig, FingepringConfig
methods = {
'GET':requests.get,
'POST':requests.post
}
@dataclass
class AdsApi:
base_url_ads: str
lock: Lock = mp.Lock()
def request(self, endpoint: str, params: dict | None = None, data: dict | None = None, attempts: int = 5, method:str = 'GET', json:dict = None):
req_info = f'request {self.base_url_ads+endpoint}\n data = {data}\n params = {params}\njson={json}\n'
for attempt in range(attempts):
try:
self.lock.acquire()
sleep(1) # because limite 1 request per second\
if data:
d_n = data.copy()
for i in d_n:
if data[i] == None:
del data[i]
response = methods[method](
self.base_url_ads + endpoint, params=params, data=data, json=json, timeout =5).json()
self.lock.release()
except:
self.lock.release()
#log.error(f'Error with {req_info}-- {traceback.format_exc()}')
if attempt == attempts-1:
raise AdsError('')
continue
if response["code"] != 0:
log.error(f'Error with {req_info}')
raise AdsError(response["msg"])
log.info(f'Success request to ads {req_info}response = {response}')
if 'data' in response:
return response['data']
return response
def query_group(self, page_size: int = 100, group_name: str | None = None, page: int = 1) -> list[dict]:
resp = self.request(
'/api/v1/group/list', params={'page_size': page_size, 'page': page, 'group_name': group_name})
resp = resp['list']
return resp
def update_group(self, group_id: int, group_name: str) -> None:
resp = self.request(
'/api/v1/group/update', data={'group_id': group_id, 'group_name': group_name}, method='POST')
def create_group(self, group_name: str) -> dict:
resp = self.request('/api/v1/group/create',
data={'group_name': group_name}, method='POST')
return resp
def open_browser(self, user_id: str, serial_number: str | None = None,
open_tabs: int = 0, ip_tab: int = 1, launch_args: str | None = None, headless: int = 0,
disable_password_filling: int = 0, clear_cache_after_closing: int = 0, enable_password_saving: str = 0) -> dict:
resp = self.request('/api/v1/browser/start', params={'user_id': user_id, 'serial_number': serial_number, 'open_tabs': open_tabs,
'ip_tab': ip_tab, 'launch_args': launch_args, 'headless': headless,
'disable_password_filling': disable_password_filling, 'clear_cache_after_closing': clear_cache_after_closing,
'enable_password_saving': enable_password_saving})
return resp
def close_browser(self, user_id: str, serial_number: int | None = None) -> None:
resp = self.request(
'/api/v1/browser/stop', params={'user_id': user_id, 'serial_number': serial_number})
def check_open_status(self, user_id: str, serial_number: int | None = None) -> dict:
resp = self.request('/api/v1/browser/active',
params={'user_id': user_id, 'serial_number': serial_number})
return resp
def create_account(self, name: str | None = None, domain_name: int | None = None, open_urls: list[str] | None = None,
repeat_config: list[int] | None = None, username: str | None = None, password: str | None = None,
cookie: str | None = None, ignore_cookie_error: int = 0, group_id: int | None = None, ip: str | None = None,
country: str | None = None, city: str | None = None, remark: str | None = None,
user_proxy_config: dict = UserProxyConfig().dict(), fingerprint_config: dict =FingepringConfig().dict()) -> dict:
resp = self.request('/api/v1/user/create',
json={'name': name, 'domain_name': domain_name, 'open_urls':open_urls, 'repeat_config':repeat_config, 'username':username,
'password':password, 'cookie':cookie, 'ignore_cookie_error':ignore_cookie_error, 'group_id':group_id,
'ip':ip, 'country':country, 'city':city, 'remark':remark, 'user_proxy_config':user_proxy_config,
'fingerprint_config':fingerprint_config}, method='POST')
return resp
def update_account(self, name: str, domain_name: int | None = None, open_urls: list[str] | None = None,
repeat_config: list[int] | None = None, username: str | None = None, password: str | None = None,
cookie: str | None = None, ignore_cookie_error: int = 0, group_id: int | None = None, ip: str | None = None,
country: str | None = None, city: str | None = None, remark: str | None = None,
user_proxy_config: dict = UserProxyConfig().dict(), fingerprint_config: dict =FingepringConfig().dict()) -> dict:
resp = self.request('/api/v1/user/update',
data={'name': name, 'domain_name': domain_name, 'open_urls':open_urls, 'repeat_config':repeat_config, 'username':username,
'password':password, 'cookie':cookie, 'ignore_cookie_error':ignore_cookie_error, 'group_id':group_id,
'ip':ip, 'country':country, 'city':city, 'remark':remark, 'user_proxy_config':user_proxy_config,
'fingerprint_config':fingerprint_config}, method='POST')
return resp
def query_account(self, group_id:int|None = None, user_id:str|None = None, serial_number:int|None = None, page:int=1, page_size:int = 1) -> list[dict]:
resp = self.request('/api/v1/user/list',
params={'group_id': group_id, 'user_id': user_id, 'serial_number':serial_number, 'page':page, 'page_size':page_size})
return resp['list']
def delete_account(self, user_ids:list[int]) -> dict:
resp = self.request('/api/v1/user/delete',
json={'user_ids': user_ids}, method='POST')
return resp
def update_account_group(self, user_ids:list[int], group_id:int) -> dict:
resp = self.request('/api/v1/user/regroup',
data={'user_ids': user_ids, 'group_id':group_id}, method='POST')
return resp
def connect_ads_to_selenium(self, user_id:int) -> webdriver.Chrome:
data = self.open_browser(user_id=user_id)
chrome_driver = data["webdriver"]
chrome_options = Options()
chrome_options.add_experimental_option("debuggerAddress", data["ws"]["selenium"])
driver = webdriver.Chrome(chrome_driver, options=chrome_options)
driver.get("https://www.baidu.com")
return driver | ADS-BROWSER-SDK | /ADS_BROWSER_SDK-1.0.4.tar.gz/ADS_BROWSER_SDK-1.0.4/ADS_BROWSER_SDK/ads.py | ads.py |
from time import sleep_ms
__ADS1115_CONV_REG = 0x00 #Conversion Register
__ADS1115_CONFIG_REG = 0x01 #Configuration Register
__ADS1115_LO_THRESH_REG = 0x02 #Low Threshold Register
__ADS1115_HI_THRESH_REG = 0x03 #High Threshold Register
__ADS1115_DEFAULT_ADDR = 0x48
__ADS1115_REG_RESET_VAL = 0x8583
__ADS1115_REG_FACTOR = 0x7FFF
__ADS1115_BUSY = 0x0000
__ADS1115_START_ISREADY = 0x8000
__ADS1115_COMP_INC = 0x1000
ADS1115_RANGE_6144 = 6144
ADS1115_RANGE_4096 = 4096
ADS1115_RANGE_2048 = 2048
ADS1115_RANGE_1024 = 1024
ADS1115_RANGE_512 = 512
ADS1115_RANGE_256 = 256
ADS1115_ASSERT_AFTER_1 = 0x0000
ADS1115_ASSERT_AFTER_2 = 0x0001
ADS1115_ASSERT_AFTER_4 = 0x0002
ADS1115_DISABLE_ALERT = 0x0003
ADS1115_LATCH_DISABLED = 0x0000
ADS1115_LATCH_ENABLED = 0x0004
ADS1115_ACT_LOW = 0x0000
ADS1115_ACT_HIGH = 0x0008
ADS1115_MAX_LIMIT = 0x0000
ADS1115_WINDOW = 0x0010
ADS1115_8_SPS = 0x0000
ADS1115_16_SPS = 0x0020
ADS1115_32_SPS = 0x0040
ADS1115_64_SPS = 0x0060
ADS1115_128_SPS = 0x0080
ADS1115_250_SPS = 0x00A0
ADS1115_475_SPS = 0x00C0
ADS1115_860_SPS = 0x00E0
ADS1115_RANGE_6144 = 0x0000
ADS1115_RANGE_4096 = 0x0200
ADS1115_RANGE_2048 = 0x0400
ADS1115_RANGE_1024 = 0x0600
ADS1115_RANGE_0512 = 0x0800
ADS1115_RANGE_0256 = 0x0A00
ADS1115_COMP_0_1 = 0x0000
ADS1115_COMP_0_3 = 0x1000
ADS1115_COMP_1_3 = 0x2000
ADS1115_COMP_2_3 = 0x3000
ADS1115_COMP_0_GND = 0x4000
ADS1115_COMP_1_GND = 0x5000
ADS1115_COMP_2_GND = 0x6000
ADS1115_COMP_3_GND = 0x7000
ADS1115_CONTINUOUS = 0x0000
ADS1115_SINGLE = 0x0100
class ADS1115(object):
__autoRangeMode = False
__voltageRange = 2048
__measureMode = ADS1115_SINGLE
def __init__(self, address = __ADS1115_DEFAULT_ADDR, i2c = None):
self.__address = address
if i2c is None:
try:
i2c = I2C(0)
except:
i2c = I2C()
self.__i2c = i2c
try:
self.reset()
except:
raise ValueError("Can't connect to the ADS1115. Check wiring, address, etc.")
self.setVoltageRange_mV(ADS1115_RANGE_2048)
self.__writeADS1115(__ADS1115_LO_THRESH_REG, 0x8000)
self.__writeADS1115(__ADS1115_HI_THRESH_REG, 0x7FFF)
self.__measureMode = ADS1115_SINGLE
self.__autoRangeMode = False
def setAlertPinMode(self, mode):
currentConfReg = self.__getConfReg()
currentConfReg &= ~(0x8003)
currentConfReg |= mode
self.__setConfReg(currentConfReg)
def setAlertLatch(self, latch):
currentConfReg = self.__getConfReg()
currentConfReg &= ~(0x8004)
currentConfReg |= latch
self.__setConfReg(currentConfReg)
def setAlertPol(self, polarity):
currentConfReg = self.__getConfReg()
currentConfReg &= ~(0x8008)
currentConfReg |= polarity
self.__setConfReg(currentConfReg)
def setAlertModeAndLimit_V(self, mode, hiThres, loThres):
currentConfReg = self.__getConfReg()
currentConfReg &= ~(0x8010)
currentConfReg |= mode
self.__setConfReg(currentConfReg)
alertLimit = self.__calcLimit(hiThres)
self.__writeADS1115(__ADS1115_HI_THRESH_REG, alertLimit)
alertLimit = self.__calcLimit(loThres)
self.__writeADS1115(__ADS1115_LO_THRESH_REG, alertLimit)
def __calcLimit(self, rawLimit):
limit = int((rawLimit * __ADS1115_REG_FACTOR / self.__voltageRange) * 1000)
if limit > 32767:
limit -= 65536
return limit
def reset(self):
return self.__setConfReg(__ADS1115_REG_RESET_VAL)
def setVoltageRange_mV(self, newRange):
currentVoltageRange = self.__voltageRange
currentConfReg = self.__getConfReg()
currentRange = (currentConfReg >> 9) & 7
currentAlertPinMode = currentConfReg & 3
self.setMeasureMode(ADS1115_SINGLE)
if newRange == ADS1115_RANGE_6144:
self.__voltageRange = 6144;
elif newRange == ADS1115_RANGE_4096:
self.__voltageRange = 4096;
elif newRange == ADS1115_RANGE_2048:
self.__voltageRange = 2048;
elif newRange == ADS1115_RANGE_1024:
self.__voltageRange = 1024;
elif newRange == ADS1115_RANGE_0512:
self.__voltageRange = 512;
elif newRange == ADS1115_RANGE_0256:
self.__voltageRange = 256;
if (currentRange != newRange) and (currentAlertPinMode != ADS1115_DISABLE_ALERT):
alertLimit = self.__readADS1115(__ADS1115_HI_THRESH_REG)
alertLimit = alertLimit * (currentVoltageRange / self.__voltageRange)
self.__writeADS1115(__ADS1115_HI_THRESH_REG, alertLimit)
alertLimit = self.__readADS1115(__ADS1115_LO_THRESH_REG)
alertLimit = alertLimit * (currentVoltageRange / self.__voltageRange)
self.__writeADS1115(__ADS1115_LO_THRESH_REG, alertLimit)
currentConfReg &= ~(0x8E00)
currentConfReg |= newRange
self.__setConfReg(currentConfReg)
rate = self.__getConvRate()
self.__delayAccToRate(rate)
def setAutoRange(self):
currentConfReg = self.__getConfReg()
self.setVoltageRange_mV(ADS1115_RANGE_6144)
if self.__measureMode == ADS1115_SINGLE:
self.setMeasureMode(ADS1115_CONTINUOUS)
convRate = self.__getConvRate()
self.__delayAccToRate(convRate)
rawResult = abs(self.__getConvReg())
optRange = ADS1115_RANGE_6144
if rawResult < 1093:
optRange = ADS1115_RANGE_0256
elif rawResult < 2185:
optRange = ADS1115_RANGE_0512
elif rawResult < 4370:
optRange = ADS1115_RANGE_1024
elif rawResult < 8738:
optRange = ADS1115_RANGE_2048
elif rawResult < 17476:
optRange = ADS1115_RANGE_4096
self.__setConfReg(currentConfReg)
self.setVoltageRange_mV(optRange)
def setPermanentAutoRangeMode(self, autoMode):
if autoMode:
self.__autoRangeMode = True
else:
self.__autoRangeMode = False
def setMeasureMode(self, mMode):
currentConfReg = self.__getConfReg()
self.__measureMode = mMode
currentConfReg &= ~(0x8100)
currentConfReg |= mMode
self.__setConfReg(currentConfReg)
def setCompareChannels(self, compChannels):
currentConfReg = self.__getConfReg()
currentConfReg &= ~(0xF000)
currentConfReg |= compChannels
self.__setConfReg(currentConfReg)
if not (currentConfReg & 0x0100): # if not single shot mode
convRate = self.__getConvRate()
for i in range(2):
self.__delayAccToRate(convRate)
def setSingleChannel(self, channel):
if channel >= 4:
return
self.setCompareChannels((ADS1115_COMP_0_GND + ADS1115_COMP_INC) * channel)
def isBusy(self):
currentConfReg = self.__getConfReg()
return not((currentConfReg>>15) & 1)
def startSingleMeasurement(self):
currentConfReg = self.__getConfReg()
currentConfReg |= (1 << 15)
self.__setConfReg(currentConfReg)
def getResult_V(self):
return self.getResult_mV()/1000
def getResult_mV(self):
rawResult = self.getRawResult()
return rawResult * self.__voltageRange / __ADS1115_REG_FACTOR
def getRawResult(self):
rawResult = self.__getConvReg()
if self.__autoRangeMode:
if (abs(rawResult) > 26214) and (self.__voltageRange != 6144): # 80%
self.setAutoRange()
rawResult = self.__getConvReg()
elif (abs(rawResult) < 9800) and (self.__voltageRange != 256): # 30%
self.setAutoRange()
rawResult = self.__getConvReg()
return rawResult
def __getConvReg(self):
rawResult = self.__readADS1115(__ADS1115_CONV_REG)
if rawResult > 32767:
rawResult -= 65536
return rawResult
def getResultWithRange(self, minLimit, maxLimit):
rawResult = self.getRawResult()
result = rawResult * (maxLimit - minLimit) / 65536
return result
def getResultWithRangeAndMaxVolt(self, minLimit, maxLimit, maxMillivolt):
result = self.getResultWithRange(minLimit, maxLimit)
result = result * self.__voltageRange / maxMillivolt
return result
def getVoltageRange_mV(self):
return self.__voltageRange
def setAlertPinToConversionReady(self):
self.__writeADS1115(__ADS1115_LO_THRESH_REG, (0<<15))
self.__writeADS1115(__ADS1115_HI_THRESH_REG, (1<<15))
def clearAlert(self):
self.__readADS1115(__ADS1115_CONV_REG)
def __setConfReg(self, regVal):
self.__writeADS1115(__ADS1115_CONFIG_REG, regVal)
def __getConfReg(self):
return self.__readADS1115(__ADS1115_CONFIG_REG)
def __getConvRate(self):
currentConfReg = self.__getConfReg()
return (currentConfReg & 0xE0)
def setConvRate(self, rate):
currentConfReg = self.__getConfReg()
currentConfReg &= ~(0x80E0)
currentConfReg |= rate
self.__setConfReg(currentConfReg)
def __delayAccToRate(self, rate):
if rate == ADS1115_8_SPS:
sleep_ms(130)
elif rate == ADS1115_16_SPS:
sleep_ms(65)
elif rate == ADS1115_32_SPS:
sleep_ms(32)
elif rate == ADS1115_64_SPS:
sleep_ms(16)
elif rate == ADS1115_128_SPS:
sleep_ms(8)
elif rate == ADS1115_250_SPS:
sleep_ms(4)
elif rate == ADS1115_475_SPS:
sleep_ms(3)
elif rate == ADS1115_860_SPS:
sleep_ms(2)
def __writeADS1115(self, reg, val):
self.__i2c.writeto_mem(self.__address, reg, self.__toBytearray(val))
def __readADS1115(self, reg):
regVal = self.__i2c.readfrom_mem(self.__address, reg, 2)
return self.__bytesToInt(regVal)
def __toBytearray(self, intVal):
return bytearray(intVal.to_bytes(2, 'big'))
def __bytesToInt(self, bytesToConvert):
intVal = int.from_bytes(bytesToConvert, 'big') # "big" = MSB at beginning
return intVal | ADS1115-mic-py | /ADS1115_mic_py-1.0.2.tar.gz/ADS1115_mic_py-1.0.2/ADS1115.py | ADS1115.py |
import RPi.GPIO as GPIO
from time import sleep
from smbus2 import SMBus, i2c_msg
class ADS1219:
COMMAND_RESET = 0x06
COMMAND_START_SYNC = 0x08
COMMAND_POWERDOWN = 0x02
COMMAND_RDATA = 0x10
COMMAND_RREG = 0x20
COMMAND_WREG = 0x40
MUX_MASK = 0x1F
MUX_DIF_0_1 = 0x00
MUX_DIF_2_3 = 0x20
MUX_DIF_1_2 = 0x40
MUX_SINGLE_0 = 0x60
MUX_SINGLE_1 = 0x80
MUX_SINGLE_2 = 0xa0
MUX_SINGLE_3 = 0xc0
MUX_SHORTED = 0xe0
GAIN_MASK = 0xF3
GAIN_ONE = 0x00
GAIN_FOUR = 0x10
DATA_RATE_MASK = 0xF3
DATA_RATE_20 = 0x00
DATA_RATE_90 = 0x04
DATA_RATE_330 = 0x08
DATA_RATE_1000 = 0x0c
MODE_MASK = 0xFD
MODE_SINGLESHOT = 0x00
MODE_CONTINUOUS = 0x02
VREF_MASK = 0xFE
VREF_INTERNAL = 0x00
VREF_EXTERNAL = 0x01
def __write_command( self, cmd ):
"""Wrapper to send data easly
Parameters
----------
cmd : hex
command to send
"""
self.bus.write_byte( self.i2c_adr, cmd )
def __read_registers( self, reg, size ):
"""Wrapper to read data easly
Parameters
----------
reg : hex
register to write
size : int
size of data
Returns
-------
list
Data read
"""
write = i2c_msg.write( self.i2c_adr, [reg] )
read = i2c_msg.read( self.i2c_adr, size )
self.bus.i2c_rdwr( write, read )
return list( read )
def start( self ):
"""Start the conversion"""
self.__write_command( self.COMMAND_START_SYNC )
def resetConfig( self ):
"""Reset Chip"""
self.config = 0x00
self.gain = 1
self.datarate = 20
self.Vref = 2.048
self.__write_command( self.COMMAND_RESET )
def poweroff( self ):
"""Power off the Chip"""
self.__write_command( self.COMMAND_POWERDOWN )
def __sendConfig ( self ):
"""Send config to the chip """
self.bus.write_byte_data( self.i2c_adr, self.COMMAND_WREG, self.config )
def setGain( self, gain ):
"""
Define the gain
Parameters
----------
gain : int
value of the gain: 1 or 4 (default: 1)
:Example:
ads.setGain(4)
"""
self.config &= self.GAIN_MASK
if ( gain == 4) :
self.config |= self.GAIN_4
self.gain = 4
elif( gain == 1) :
self.config |= self.GAIN_1
self.gain = 1
else : raise ValueError("'gain' can only be either 1 or 4")
self.__sendConfig()
def setDataRate( self, datarate ):
"""
Define the datarate
Parameters
----------
datarate : int
value of the datarate: 20, 90, 330 or 1000 (default: 20)
size : int
size of data
:Example:
ads.setDataRate(1000)
"""
self.config &= self.DATA_RATE_MASK
if( datarate == 20 ) :
self.config |= self.DATA_RATE_20
self.datarate = 20
elif( datarate == 90 ) :
self.config |= self.DATA_RATE_90
self.datarate = 90
elif( datarate == 330 ) :
self.config |= self.DATA_RATE_330
self.datarate = 330
elif( datarate == 1000 ) :
self.config |= self.DATA_RATE_1000
self.datarate = 1000
else : raise ValueError("'datarate' can only be either 20, 90, 330 or 1000")
self.__sendConfig()
def setSingleShot( self ):
"""Configure the chip in Single Shot mode """
self.config &= self.MODE_MASK
self.config |= self.MODE_SINGLESHOT
self.__sendConfig()
def setContinuous( self ):
"""Configure the chip in Continuous mode """
self.config &= self.MODE_MASK
self.config |= self.MODE_CONTINUOUS
self.__sendConfig()
def setExternalReference( self , value):
"""Configure the chip with an external reference
Parameters
----------
value : float
value of the external reference
"""
self.Vref = value
self.config &= self.VREF_MASK
self.config |= self.VREF_EXTERNAL
self.__sendConfig()
def setInternalReference( self ):
"""Configure the chip with the internal reference """
self.Vref = 2.048
self.config &= self.VREF_MASK
self.config |= self.VREF_INTERNAL
self.__sendConfig()
def readSingleEnded( self, channel ):
"""
Read a value from a specific channel
Parameters
----------
channel : int
channel number: 0 to 3
:Example:
ads.readSingleEnded(0)
"""
self.config &= self.MUX_MASK
if( channel == 0 ) : self.config |= self.MUX_SINGLE_0
elif( channel == 1 ) : self.config |= self.MUX_SINGLE_1
elif( channel == 2 ) : self.config |= self.MUX_SINGLE_2
elif( channel == 3 ) : self.config |= self.MUX_SINGLE_3
else : raise ValueError("'channel' can only be either 0, 1, 2 or 3")
self.__sendConfig()
self.start()
self.waitResult()
return self.readConversionResult()
def readConversionResult( self ):
""" Get the result data from the chip """
buffer = self.__read_registers( self.COMMAND_RDATA, 3 )
value = (buffer[0]<<16) | (buffer[1]<<8) | (buffer[2])
if value >= 0x800000:
value = value-0x1000000
return value
def isReady( self ):
""" Software function to get the moment who the data is available """
value = self.__read_registers( self.COMMAND_RREG|4, 1 )
return value[0] & 0x80
def waitResult( self ):
"""Blocking fonction to wait data"""
if self.readyPin>0:
GPIO.wait_for_edge( self.readyPin, GPIO.FALLING )
else:
while not self.isReady():
sleep(0.0001)
def readDifferential_0_1( self ):
"""Read a value between 0 and 1 channel"""
self.config &= self.MUX_MASK
self.config |= self.MUX_DIF_0_1
self.__sendConfig()
self.start()
self.waitResult()
return self.readConversionResult()
def readDifferential_1_2( self ):
"""Read a value between 1 and 2 channel"""
self.config &= self.MUX_MASK
self.config |= self.MUX_DIF_1_2
self.__sendConfig()
self.start()
self.waitResult()
return self.readConversionResult()
def readDifferential_2_3( self ):
"""Read a value between 2 and 3 channel"""
self.config &= self.MUX_MASK
self.config |= self.MUX_DIF_2_3
self.__sendConfig()
self.start()
self.waitResult()
return self.readConversionResult()
def readShorted( self ):
"""
Set the chip to get an offset to calibrate
.. note:: Please refer to 8.3.7 in the datasheet ( https://www.ti.com/lit/ds/sbas924a/sbas924a.pdf )
"""
self.config &= self.MUX_MASK
self.config |= self.MUX_SHORTED
self.__sendConfig()
self.start()
self.waitResult()
return self.readConversionResult()
def convertToV(self, value):
"""Function to convert the value in Volt using Gain and Vref.
Parameters
----------
value : float
Value to convert
Returns
---------
float
Value in V.
"""
return ( self.Vref / self.gain ) * ( value / pow(2,23) )
def __init__( self, port=1, address=0x40, readyPin=0 ):
"""
Constructor
Parameters
----------
port : int
I2C port, for raspberry with port 2 and 3 please set to port=1
address : hex
I2C adress of the chip. Default is 0x40
readyPin: int
Input pin of the raspberry to know if data is available. 0 to desactivate and use software information
:Example:
ads = ADS1219(1, 0x40, 4)
"""
self.i2c_adr = address
self.bus = SMBus( port, True )
self.readyPin = readyPin
self.config = 0x00
self.gain = 1
self.datarate = 20
self.Vref = 2.048
if( readyPin>0 ):
GPIO.setmode( GPIO.BCM )
GPIO.setup(readyPin, GPIO.IN )
def __enter__( self ):
"""Enter function"""
return self
def __del__( self ):
"""Delete function"""
self.bus.close()
def __exit__( self, exc_type, exc_value, traceback ):
"""Exit function"""
self.bus.close() | ADS1219-lib | /ADS1219_lib-0.0.2-py3-none-any.whl/ADS1219_lib/core.py | core.py |
from smbus2 import SMBus
import time
# ADS1x15 default i2c address
I2C_address = 0x48
class ADS1x15:
"General ADS1x15 family ADC class"
# ADS1x15 register address
CONVERSION_REG = 0x00
CONFIG_REG = 0x01
LO_THRESH_REG = 0x02
HI_THRESH_REG = 0x03
# Input multiplexer configuration
INPUT_DIFF_0_1 = 0
INPUT_DIFF_0_3 = 1
INPUT_DIFF_1_3 = 2
INPUT_DIFF_2_3 = 3
INPUT_SINGLE_0 = 4
INPUT_SINGLE_1 = 5
INPUT_SINGLE_2 = 6
INPUT_SINGLE_3 = 7
# Programmable gain amplifier configuration
PGA_6_144V = 0
PGA_4_096V = 1
PGA_2_048V = 2
PGA_1_024V = 4
PGA_0_512V = 8
PGA_0_256V = 16
# Device operating mode configuration
MODE_CONTINUOUS = 0
MODE_SINGLE = 1
INVALID_MODE = -1
# Data rate configuration
DR_ADS101X_128 = 0
DR_ADS101X_250 = 1
DR_ADS101X_490 = 2
DR_ADS101X_920 = 3
DR_ADS101X_1600 = 4
DR_ADS101X_2400 = 5
DR_ADS101X_3300 = 6
DR_ADS111X_8 = 0
DR_ADS111X_16 = 1
DR_ADS111X_32 = 2
DR_ADS111X_64 = 3
DR_ADS111X_128 = 4
DR_ADS111X_250 = 5
DR_ADS111X_475 = 6
DR_ADS111X_860 = 7
# Comparator configuration
COMP_MODE_TRADITIONAL = 0
COMP_MODE_WINDOW = 1
COMP_POL_ACTIV_LOW = 0
COMP_POL_ACTIV_HIGH = 1
COMP_LATCH = 0
COMP_NON_LATCH = 1
COMP_QUE_1_CONV = 0
COMP_QUE_2_CONV = 1
COMP_QUE_4_CONV = 2
COMP_QUE_NONE = 3
# I2C object from smbus library
i2c = SMBus(1)
# I2C address
_address = I2C_address
# Default config register
_config = 0x8583
# Default conversion delay
_conversionDelay = 8
# Maximum input port
_maxPorts = 4
# Default conversion lengths
_adcBits = 16
def __init__(self, busId: int, address: int = I2C_address) :
"Constructor with SMBus ID and I2C address input"
self.i2c = SMBus(busId)
self._address = address
# Store initial config resgister to config property
self._config = self.readRegister(self.CONFIG_REG)
def writeRegister(self, address: int, value) :
"Write 16-bit integer to an address pointer register"
registerValue = [(value >> 8) & 0xFF, value & 0xFF]
self.i2c.write_i2c_block_data(self._address, address, registerValue)
def readRegister(self, address: int) :
"Read 16-bit integer value from an address pointer register"
registerValue = self.i2c.read_i2c_block_data(self._address, address, 2)
return (registerValue[0] << 8) + registerValue[1]
def setInput(self, input: int) :
"Set input multiplexer configuration"
# Filter input argument
if input < 0 or input > 7 : inputRegister = 0x0000
else : inputRegister = input << 12
# Masking input argument bits (bit 12-14) to config register
self._config = (self._config & 0x8FFF) | inputRegister
self.writeRegister(self.CONFIG_REG, self._config)
def getInput(self) :
"Get input multiplexer configuration"
return (self._config & 0x7000) >> 12
def setGain(self, gain: int) :
"Set programmable gain amplifier configuration"
# Filter gain argument
if gain == self.PGA_4_096V : gainRegister = 0x0200
elif gain == self.PGA_2_048V : gainRegister = 0x0400
elif gain == self.PGA_1_024V : gainRegister = 0x0600
elif gain == self.PGA_0_512V : gainRegister = 0x0800
elif gain == self.PGA_0_256V : gainRegister = 0x0A00
else : gainRegister = 0x0000
# Masking gain argument bits (bit 9-11) to config register
self._config = (self._config & 0xF1FF) | gainRegister
self.writeRegister(self.CONFIG_REG, self._config)
def getGain(self) :
"Get programmable gain amplifier configuration"
gainRegister = self._config & 0x0E00
if gainRegister == 0x0200 : return self.PGA_4_096V
elif gainRegister == 0x0400 : return self.PGA_2_048V
elif gainRegister == 0x0600 : return self.PGA_1_024V
elif gainRegister == 0x0800 : return self.PGA_0_512V
elif gainRegister == 0x0A00 : return self.PGA_0_256V
else : return 0x0000
def setMode(self, mode: int) :
"Set device operating mode configuration"
# Filter mode argument
if mode == 0 : modeRegister = 0x0000
else : modeRegister = 0x0100
# Masking mode argument bit (bit 8) to config register
self._config = (self._config & 0xFEFF) | modeRegister
self.writeRegister(self.CONFIG_REG, self._config)
def getMode(self) :
"Get device operating mode configuration"
return (self._config & 0x0100) >> 8
def setDataRate(self, dataRate: int) :
"Set data rate configuration"
# Filter dataRate argument
if dataRate < 0 or dataRate > 7 : dataRateRegister = 0x0080
else : dataRateRegister = dataRate << 5
# Masking dataRate argument bits (bit 5-7) to config register
self._config = (self._config & 0xFF1F) | dataRateRegister
self.writeRegister(self.CONFIG_REG, self._config)
def getDataRate(self) :
"Get data rate configuration"
return (self._config & 0x00E0) >> 5
def setComparatorMode(self, comparatorMode: int) :
"Set comparator mode configuration"
# Filter comparatorMode argument
if comparatorMode == 1 : comparatorModeRegister = 0x0010
else : comparatorModeRegister = 0x0000
# Masking comparatorMode argument bit (bit 4) to config register
self._config = (self._config & 0xFFEF) | comparatorModeRegister
self.writeRegister(self.CONFIG_REG, self._config)
def getComparatorMode(self) :
"Get comparator mode configuration"
return (self._config & 0x0010) >> 4
def setComparatorPolarity(self, comparatorPolarity: int) :
"Set comparator polarity configuration"
# Filter comparatorPolarity argument
if comparatorPolarity == 1 : comparatorPolarityRegister = 0x0008
else : comparatorPolarityRegister = 0x0000
# Masking comparatorPolarity argument bit (bit 3) to config register
self._config = (self._config & 0xFFF7) | comparatorPolarityRegister
self.writeRegister(self.CONFIG_REG, self._config)
def getComparatorPolarity(self) :
"Get comparator polarity configuration"
return (self._config & 0x0008) >> 3
def setComparatorLatch(self, comparatorLatch: int) :
"Set comparator polarity configuration"
# Filter comparatorLatch argument
if comparatorLatch == 1 : comparatorLatchRegister = 0x0004
else : comparatorLatchRegister = 0x0000
# Masking comparatorPolarity argument bit (bit 2) to config register
self._config = (self._config & 0xFFFB) | comparatorLatchRegister
self.writeRegister(self.CONFIG_REG, self._config)
def getComparatorLatch(self) :
"Get comparator polarity configuration"
return (self._config & 0x0004) >> 2
def setComparatorQueue(self, comparatorQueue: int) :
"Set comparator queue configuration"
# Filter comparatorQueue argument
if comparatorQueue < 0 or comparatorQueue > 3 : comparatorQueueRegister = 0x0002
else : comparatorQueueRegister = comparatorQueue
# Masking comparatorQueue argument bits (bit 0-1) to config register
self._config = (self._config & 0xFFFC) | comparatorQueueRegister
self.writeRegister(self.CONFIG_REG, self._config)
def getComparatorQueue(self) :
"Get comparator queue configuration"
return (self._config & 0x0003)
def setComparatorThresholdLow(self, threshold: float) :
"Set low threshold for voltage comparator"
self.writeRegister(self.LO_THRESH_REG, round(threshold))
def getComparatorThresholdLow(self) :
"Get voltage comparator low threshold"
threshold = self.readRegister(self.LO_THRESH_REG)
if threshold >= 32768 : threshold = threshold - 65536
return threshold
def setComparatorThresholdHigh(self, threshold: float) :
"Set high threshold for voltage comparator"
self.writeRegister(self.HI_THRESH_REG, round(threshold))
def getComparatorThresholdHigh(self) :
"Get voltage comparator high threshold"
threshold = self.readRegister(self.HI_THRESH_REG)
if threshold >= 32768 : threshold = threshold - 65536
return threshold
def isReady(self) :
"Check if device currently not performing conversion"
value = self.readRegister(self.CONFIG_REG)
return bool(value & 0x8000)
def isBusy(self) :
"Check if device currently performing conversion"
return not self.isReady()
def _requestADC(self, input) :
"Private method for starting a single-shot conversion"
self.setInput(input)
# Set single-shot conversion start (bit 15)
if self._config & 0x0100 :
self.writeRegister(self.CONFIG_REG, self._config | 0x8000)
def _getADC(self) -> int :
"Get ADC value with current configuration"
t = time.time()
isContinuos = not (self._config & 0x0100)
# Wait conversion process finish or reach conversion time for continuous mode
while not self.isReady() :
if ((time.time() - t) * 1000) > self._conversionDelay and isContinuos :
break
return self.getValue()
def getValue(self) -> int :
"Get ADC value"
value = self.readRegister(self.CONVERSION_REG)
# Shift bit based on ADC bits and change 2'complement negative value to negative integer
value = value >> (16 - self._adcBits)
if value >= (2 ** (self._adcBits - 1)) : value = value - (2 ** (self._adcBits))
return value
def requestADC(self, pin: int) :
"Request single-shot conversion of a pin to ground"
if (pin >= self._maxPorts or pin < 0) : return
self._requestADC(pin + 4)
def readADC(self, pin: int) :
"Get ADC value of a pin"
if (pin >= self._maxPorts or pin < 0) : return 0
self.requestADC(pin)
return self._getADC()
def requestADC_Differential_0_1(self) :
"Request single-shot conversion between pin 0 and pin 1"
self._requestADC(0)
def readADC_Differential_0_1(self) :
"Get ADC value between pin 0 and pin 1"
self.requestADC_Differential_0_1()
return self._getADC()
def getMaxVoltage(self) -> float :
"Get maximum voltage conversion range"
if self._config & 0x0E00 == 0x0000 : return 6.144
elif self._config & 0x0E00 == 0x0200 : return 4.096
elif self._config & 0x0E00 == 0x0400 : return 2.048
elif self._config & 0x0E00 == 0x0600 : return 1.024
elif self._config & 0x0E00 == 0x0800 : return 0.512
else : return 0.256
def toVoltage(self, value: int = 1) -> float :
"Transform an ADC value to nominal voltage"
volts = self.getMaxVoltage() * value
return volts / ((2 ** (self._adcBits - 1)) - 1)
class ADS1013(ADS1x15) :
"ADS1013 class derifed from general ADS1x15 class"
def __init__(self, busId: int, address: int = I2C_address) :
"Initialize ADS1013 with SMBus ID and I2C address configuration"
self.i2c = SMBus(busId)
self._address = address
self._conversionDelay = 2
self._maxPorts = 1
self._adcBits = 12
# Store initial config resgister to config property
self._config = self.readRegister(self.CONFIG_REG)
class ADS1014(ADS1x15) :
"ADS1014 class derifed from general ADS1x15 class"
def __init__(self, busId: int, address: int = I2C_address) :
"Initialize ADS1014 with SMBus ID and I2C address configuration"
self.i2c = SMBus(busId)
self._address = address
self._conversionDelay = 2
self._maxPorts = 1
self._adcBits = 12
# Store initial config resgister to config property
self._config = self.readRegister(self.CONFIG_REG)
class ADS1015(ADS1x15) :
"ADS1015 class derifed from general ADS1x15 class"
def __init__(self, busId: int, address: int = I2C_address) :
"Initialize ADS1015 with SMBus ID and I2C address configuration"
self.i2c = SMBus(busId)
self._address = address
self._conversionDelay = 2
self._maxPorts = 4
self._adcBits = 12
# Store initial config resgister to config property
self._config = self.readRegister(self.CONFIG_REG)
def requestADC_Differential_0_3(self) :
"Request single-shot conversion between pin 0 and pin 3"
self._requestADC(1)
def readADC_Differential_0_3(self) :
"Get ADC value between pin 0 and pin 3"
self.requestADC_Differential_0_3()
return self._getADC()
def requestADC_Differential_1_3(self) :
"Request single-shot conversion between pin 1 and pin 3"
self._requestADC(2)
def readADC_Differential_1_3(self) :
"Get ADC value between pin 1 and pin 3"
self.requestADC_Differential_1_3()
return self._getADC()
def requestADC_Differential_2_3(self) :
"Request single-shot conversion between pin 2 and pin 3"
self._requestADC(3)
def readADC_Differential_2_3(self) :
"Get ADC value between pin 2 and pin 3"
self.requestADC_Differential_2_3()
return self._getADC()
class ADS1113(ADS1x15) :
"ADS1113 class derifed from general ADS1x15 class"
def __init__(self, busId: int, address: int = I2C_address) :
"Initialize ADS1113 with SMBus ID and I2C address configuration"
self.i2c = SMBus(busId)
self._address = address
self._conversionDelay = 8
self._maxPorts = 1
self._adcBits = 16
# Store initial config resgister to config property
self._config = self.readRegister(self.CONFIG_REG)
class ADS1114(ADS1x15) :
"ADS1114 class derifed from general ADS1x15 class"
def __init__(self, busId: int, address: int = I2C_address) :
"Initialize ADS1114 with SMBus ID and I2C address configuration"
self.i2c = SMBus(busId)
self._address = address
self._conversionDelay = 8
self._maxPorts = 1
self._adcBits = 16
# Store initial config resgister to config property
self._config = self.readRegister(self.CONFIG_REG)
class ADS1115(ADS1x15) :
"ADS1115 class derifed from general ADS1x15 class"
def __init__(self, busId: int, address: int = I2C_address) :
"Initialize ADS1115 with SMBus ID and I2C address configuration"
self.i2c = SMBus(busId)
self._address = address
self._conversionDelay = 8
self._maxPorts = 4
self._adcBits = 16
# Store initial config resgister to config property
self._config = self.readRegister(self.CONFIG_REG)
def requestADC_Differential_0_3(self) :
"Request single-shot conversion between pin 0 and pin 3"
self._requestADC(1)
def readADC_Differential_0_3(self) :
"Get ADC value between pin 0 and pin 3"
self.requestADC_Differential_0_3()
return self._getADC()
def requestADC_Differential_1_3(self) :
"Request single-shot conversion between pin 1 and pin 3"
self._requestADC(2)
def readADC_Differential_1_3(self) :
"Get ADC value between pin 1 and pin 3"
self.requestADC_Differential_1_3()
return self._getADC()
def requestADC_Differential_2_3(self) :
"Request single-shot conversion between pin 2 and pin 3"
self._requestADC(3)
def readADC_Differential_2_3(self) :
"Get ADC value between pin 2 and pin 3"
self.requestADC_Differential_2_3()
return self._getADC() | ADS1x15-ADC | /ADS1x15_ADC-1.2.2-py3-none-any.whl/ADS1x15/ADS1x15.py | ADS1x15.py |
# ADSBibTeX
[](https://travis-ci.org/ryanvarley/adsbibtex)
[](https://coveralls.io/github/ryanvarley/adsbibtex?branch=master)
ADSBibTeX builds a bibtex file for a LaTeX document using by querying a list of bibcodes with NASA ADS, it was inspired by a similar script by [Alex Merson](http://www.ucl.ac.uk/star/people/amerson).
## Why?
Two main reasons
1. If you cite a preprint paper, this will automatically update the entry to the published version, when it is published
2. For really long bibtex files, its much easier to manage a list of bibcodes than bibtex entries, and you can divide
them into sections with comments i.e.
```bash
# Transmission Spectroscopy
2008Natur.452..329S Swain2008 # The presence of methane in the atmosphere of an extrasolar planet
2006AGUSM.A21A..06T Tinetti2006
# Detrending Techniques
2013ApJ...766....7W Waldmann2013
```
It is also fast after the initial run, entries are cached so they are only fetched from ADS again after they are older than your ttl (time to live) setting in the config. This means you can integrate it into your latex compilation without worrying about it adding a significant overhead to your build.
## Setup and installation
You'll need an ADS API key, the following is from the `ads` [module docs](https://github.com/andycasey/ads)
1. You'll need an API key from NASA ADS labs. Sign up for the newest version of ADS search at https://ui.adsabs.harvard.edu, visit account settings and generate a new API token. The official documentation is available at https://github.com/adsabs/adsabs-dev-api
2. When you get your API key, save it to a file called ``~/.ads/dev_key`` or save it as an environment variable named ``ADS_DEV_KEY``
Then install this package
```bash
pip install adsbibtex
```
or get the latest development version from here with
```bash
git clone https://github.com/ryanvarley/adsbibtex.git
cd adsbibtex
python setup.py install
```
## Usage
```bash
adsbibtex <config_file>
```
config_file defaults to `config.adsbib`, see the next section for an example file
## Example config file
The config file consists of a top section of `yaml` where the config is stored and a list of bibcode citename entries
(after `---`). Comments can be entered with `#`.
All entries must have a valid bibcode, if no citename is given then the bibcode will be the citename
```bash
cache_ttl: 168 # hours, 3d = 72, 1w=168, 2w=336
cache_file: adsbibtex.cache # location to store cached entries
bibtex_file: example.bib # location to output bibtex file
---
# Bibcode Name # Optional Comment
2008Natur.452..329S Swain2008
2006AGUSM.A21A..06T # no name needed
# You can use comments to divide papers into sections
2013ApJ...766....7W Waldmann2013 # You could put the paper title or subject here
```
Running `adsbibtex` on this file produces the following output
```bibtex
@ARTICLE{Swain2008,
author = {{Swain}, M.~R. and {Vasisht}, G. and {Tinetti}, G.},
title = "{The presence of methane in the atmosphere of an extrasolar planet}",
journal = {\nat},
year = 2008,
month = mar,
volume = 452,
pages = {329-331},
doi = {10.1038/nature06823},
adsurl = {http://adsabs.harvard.edu/abs/2008Natur.452..329S},
adsnote = {Provided by the SAO/NASA Astrophysics Data System}
}
@ARTICLE{2006AGUSM.A21A..06T,
author = {{Tinetti}, G. and {Meadows}, V.~S. and {Crisp}, D. and {Kiang}, N. and
{Fishbein}, E. and {Kahn}, B. and {Turnbull}, M.},
title = "{Detectability of Surface and Atmospheric Signatures in the Disk-averaged Spectra of the Earth}",
journal = {AGU Spring Meeting Abstracts},
keywords = {5210 Planetary atmospheres, clouds, and hazes (0343), 5704 Atmospheres (0343, 1060), 0343 Planetary atmospheres (5210, 5405, 5704), 0406 Astrobiology and extraterrestrial materials},
year = 2006,
month = may,
pages = {A6},
adsurl = {http://adsabs.harvard.edu/abs/2006AGUSM.A21A..06T},
adsnote = {Provided by the SAO/NASA Astrophysics Data System}
}
@ARTICLE{Waldmann2013,
author = {{Waldmann}, I.~P. and {Tinetti}, G. and {Deroo}, P. and {Hollis}, M.~D.~J. and
{Yurchenko}, S.~N. and {Tennyson}, J.},
title = "{Blind Extraction of an Exoplanetary Spectrum through Independent Component Analysis}",
journal = {\apj},
archivePrefix = "arXiv",
eprint = {1301.4041},
primaryClass = "astro-ph.EP",
keywords = {methods: data analysis, methods: observational, methods: statistical, planets and satellites: atmospheres, planets and satellites: individual: HD189733b, techniques: spectroscopic },
year = 2013,
month = mar,
volume = 766,
eid = {7},
pages = {7},
doi = {10.1088/0004-637X/766/1/7},
adsurl = {http://adsabs.harvard.edu/abs/2013ApJ...766....7W},
adsnote = {Provided by the SAO/NASA Astrophysics Data System}
}
```
| ADSBibTeX | /ADSBibTeX-1.0.9.tar.gz/ADSBibTeX-1.0.9/README.md | README.md |
import yaml
import re
import query_ads
import adsbibtex_cache
import adsbibtex_exceptions
def run_adsbibtex(config_file):
config_document = load_config_file(config_file)
yaml_front_matter, bibcode_lines = parse_config_file(config_document)
config = parse_yaml_front_matter(yaml_front_matter)
bibcode_list = parse_bibcode_lines(bibcode_lines)
cache = adsbibtex_cache.load_cache(config['cache_file'])
cache_ttl = config['cache_ttl'] * 3600 # to seconds
for i, bibcode_entry in enumerate(bibcode_list):
bibcode = bibcode_entry['bibcode']
try:
bibtex = adsbibtex_cache.read_key(cache, bibcode, cache_ttl)
print '{} successfully fetched from cache'.format(bibcode)
except KeyError: # bibcode not cached or old
try:
bibtex = query_ads.bibcode_to_bibtex(bibcode)
adsbibtex_cache.save_key(cache, bibcode, bibtex)
print '{} successfully fetched from ADS'.format(bibcode)
except adsbibtex_exceptions.ADSBibtexBibcodeNotFound:
print '{} not found on ADS, skipping'.format(bibcode)
continue
bibcode_entry['bibtex'] = bibtex
cache.close()
bibtex_ouput = generate_bibtex_output(bibcode_list)
save_bibtex_output(bibtex_ouput, out_path=config['bibtex_file'])
def load_config_file(config_file):
""" Loads the given file into a list of lines
:param config_file: file name of the config file
:type config_file: str
:return: config file as a list (one item per line) as returned by open().readlines()
"""
with open(config_file, 'r') as f:
config_document = f.readlines()
return config_document
def parse_config_file(config_document):
""" Parses the config file into a yaml front matter and a list of bibcode lines
:param config_file: config file as a list (one item per line) as returned by open().readlines()
:type config_file: [str, str, ...]
:return: yaml_front_matter, bibcode_lines
:rtype: str, list
"""
yaml_front_matter = []
i = 0
yaml_front_matter_found = False
for i, line in enumerate(config_document):
if line.startswith('---'):
yaml_front_matter_found = True
break
else:
yaml_front_matter.append(line)
if not yaml_front_matter_found:
raise adsbibtex_exceptions.ADSBibtexConfigError("YAML Front matter not found")
yaml_front_matter = ''.join(yaml_front_matter)
bibcode_lines = config_document[i + 1:]
return yaml_front_matter, bibcode_lines
def parse_yaml_front_matter(yaml_front_matter):
""" Parses the YAML front matter and checks for essential config params
:param yaml_front_matter:
:return: config
:rtype: dict
"""
config = yaml.load(yaml_front_matter)
# TODO check essential config params / set defaults
return config
def parse_bibcode_lines(bibcode_lines):
""" Cleans up the bibcode line list, removing comments and returning a list of
{"cite_name": cite_name, "bibcode": bibcode} pairs
:param bibcode_lines: lists of bibcode lines
:return:
"""
bibcode_list = []
for bibcode_line in bibcode_lines:
try:
cite_name, bibcode = parse_bibcode_line(bibcode_line)
bibcode_list.append({'cite_name': cite_name, 'bibcode': bibcode})
except TypeError: # None was returned
pass
return bibcode_list
def parse_bibcode_line(bibcode_line):
""" Parses a single bibcode line into cite_name, bibcode
:param bibcode_line: a line containing bibcode [cite_name] [# comment]
:return: cite_name, bibcode
"""
# TODO (ryan) think about replacing with regex
if not is_comment(bibcode_line): # line is just a comment
bibcode_line = bibcode_line.replace('\t', ' ')
bibcode_line = bibcode_line.replace('\n', '')
bibcode_line = ' '.join(bibcode_line.split())
# replace multiple whitespace with single space
bibcode_split = bibcode_line.split(' ', 2)
num_splits = len(bibcode_split)
if num_splits == 1:
bibcode = cite_name = bibcode_split[0]
elif num_splits > 1:
bibcode, cite_name = bibcode_split[:2]
if is_comment(cite_name):
cite_name = bibcode
else:
return None
if bibcode and cite_name:
return cite_name, bibcode
else:
return None
else:
return None
def is_comment(s):
""" Checks if a string looks like a comment line (first non whitespace char is #)
:param s: string to check
:return: True/False
"""
if re.match(r'(\s+|)#(.*?)', s):
return True
else:
return False
def replace_bibtex_cite_name(bibtex, current_name, new_name):
"""replaces the cite_name in a bibtex file with something else
:param: string of bibtex to do the replacing on
:param current_name: current cite name in the bibtex
:param new_name: name to replace it with
"""
new_bibtex = bibtex.replace(current_name, new_name, 1)
return new_bibtex
def generate_bibtex_output(bibcode_list):
output = []
for bibcode_item in bibcode_list:
try:
bibtex = bibcode_item['bibtex']
except KeyError: # Bibcode not found
continue
bibcode = bibcode_item['bibcode']
cite_name = bibcode_item['cite_name']
new_bibtex = replace_bibtex_cite_name(bibtex, bibcode, cite_name)
output.append(new_bibtex)
return ''.join(output)
def save_bibtex_output(bibtex_output, out_path):
with open(out_path, 'w') as f:
f.write(bibtex_output) | ADSBibTeX | /ADSBibTeX-1.0.9.tar.gz/ADSBibTeX-1.0.9/adsbibtex/adsbibtex.py | adsbibtex.py |
# ADTdq
[Github Project](https://github.com/pjgibson25/ADTdq)
## Setup
-----------------------
First off, please make sure you have a Python version >=3.6 .
If you don't have Python, you can get it by downloading [Anaconda](https://docs.anaconda.com/anaconda/install/).
You will likely have to install a few supporting packages. In your command prompt or terminal (dependent on OS type), please type the following required dependencies.
pip install hl7
pip install regex
pip install plotly
pip install tqdm
pip install ipywidgets
pip install xlrd
and if you didn't already install my package,
pip install ADTdq
## Background
-----------------------
#### How it Started
My name is PJ Gibson and I created this python library while working as a data analyst with the Indiana State Department of Health.
My Informatics department arranged a grant with a group who could improve the quality of hospital reporting.
We needed to track the progress of this hospital reporting, which required diving into HL7 Admission/Discharge/Transfer (ADT) messages and assessing for data completion and validity.
Enter me.
#### The Goal
The main purpose of this package is to give data quality analysis functions to workers in public health informatics.
## Functions
<p>(click on function name for extended description)</p>
-----------------------
<details>
<summary>list_elements</summary>
## Documentation
list_elements(include_priority=False):
Displays all potential elements we can search for
Parameters
----------
include_priority: bool, optional (default is False)
- returns 2 column pandas dataframe. Element Name & Priority
Returns
-------
np.array() (list-like) that contains all elements we can search for
dataframe IF include_priority = True
## Code Examples
```
# import the library and all its functions
from HL7reporting import *
# set pandas setting to disply a max of 100 rows.
pd.options.display.max_rows = 100
# save elements/priority as 2 column pandas dataframe.
a = list_elements(include_priority=True)
a
```
## Visualization of Output
<img src="https://github.com/pjgibson25/HL7reporting/raw/master/pics/list_elements.png" alt="list_elements">
<br>
</details>
<details>
<summary>NSSP_Element_Grabber</summary>
## Documentation
NSSP_Element_Grabber(data,explicit_search=None,Priority_only=False,outfile='None',no_FAC=False,no_MRN=False,no_VisNum=False):
Creates dataframe of important elements from PHESS data.
Timed with cool updating progressbar (tqdm library).
NOTE: Your input should contain the column titles:
MESSAGE , FACILITY_NAME
Parameters
----------
data: pandas DataFrame, required
- input containing columns MESSAGE, FACILITY_NAME
explicit_search: list, optional (default is None)
- list of priority element names you want specifically.
Use argument-less list_elements() function to see all options
Priority_only: bool, optional (default is False)
- If True, only gives priority 1 or 2 elements
outfile: str, optional (default is 'None')
- Replace with file name for dataframe to be wrote to as csv
Will be located in working directory.
DO NOT INCLUDE .csv IF YOU CHOOSE TO MAKE ONE
no_FAC: Bool, optional (default is False)
- If you don't have a FACILITY_NAME in your input, change to True
NOTE: without a FACILITY_NAME, usage of other functions within library can return errors
no_MRN: Bool, optional (default is False)
- If you do not want output to contain MRN information, change to True
NOTE: without a MRN, usage of other functions within library can return errors
no_VisNum: Bool, optional (default is False)
- If you do not want output to contain patient_visit_number information, change to True
NOTE: without a VisNum, usage of other functions within library can return errors
Returns
-------
dataframe
## Code Examples
```
# import the library and all its functions
from HL7reporting import *
# read in data
data1 = pd.read_csv('somefile.csv',engine='python')
# process through NSSP_Element_Grabber() function
parsed_df = NSSP_Element_Grabber(data1, Priority_only=True,outfile='nameofoutputfile')
```
*if you don't have no facility_name
```
data1 = pd.read_csv('somefile.csv',engine='python')
# process through NSSP_Element_Grabber() function
parsed_df = NSSP_Element_Grabber(new_input_dataframe, Priority_only=True,outfile='outfilename', no_FAC=True)
```
## Visualization of Output
<img src="https://github.com/pjgibson25/HL7reporting/raw/master/pics/nssp_element_grabber.png" alt="nssp_element_grabber_visual">
*note personal details are replaced with random ints and NaN values
<br>
</details>
<details>
<summary>priority_cols</summary>
## Documentation
priority_cols(df, priority='both', extras=None, drop_cols=None)
Spits out NSSP priority columns from a dataframe.
Priority can be 1,2, or both.
Extras indicate additional columns from the original dataframe you would like the output to contain.
Drop_Cols indicate columns that you want to NOT include
Parameters
----------
df: pandas dataframe, required
*priority: str, optional (default is both)
'both' - returns priority 1 and priority 2 element columns
'one' or '1' - returns priority 1 element columns only
'two' or '2' - returns priority 2 element columns only
*extras: list, optional (default is None)
list must contain valid column values from df.
*drop_cols: list, optional (default is None)
list must contain valid column values from df.
Returns
-------
pandas Dataframe
## Code Examples
```
# import the library and all its functions
from ADTdq import *
# read in data
data1 = pd.read_csv('somefile.csv',engine='python')
# process through NSSP_Element_Grabber() function
parsed_df = NSSP_Element_Grabber(data1,Timed=False,
Priority_only=True,outfile='None')
# take the priority element columns from our output dataframe
#### remove two columns that are processed backend (always NaN)
only_priority1_df = priority_cols(parsed_df,priority='1',drop_cols=['Site_ID','C_Facility_ID'])
```
## Visualization of Output
<img src="https://github.com/pjgibson25/ADTdq/raw/master/pics/priority_cols.png" alt="priority_cols_Visual">
*note personal details are replaced with random ints and NaN values
*also note the lower number of columns
<br>
</details>
<details>
<summary>Visualization_interactive</summary>
## Documentation
Visualization_interactive(df_before,df_after,str_date_list,priority='both_combined',grid=True,outfile=False,show_plot=False,Timed=True):
Creates an annotated heatmap that is interactive with hoverover.
Heatmap colors represent data completeness as of the first date
Annotations show the completion percent change with respect to the second date
(+ indicates increased completeness)
Parameters
----------
df_before : pandas.DataFrame, required (output of NSSP_Element_Grabber() Function)
-must be the dataframe representing EARLIER data
df_after : pandas.DataFrame, required (output of NSSP_Element_Grabber() Function)
-must be the dataframe representing LATER data
str_date_list: list of strings, required
-best form example: ['Feb 1 2020','Aug 31 2020']
*priority: str, optional (default = 'both combined')
-describes output visualization. Valid options include 'both_combined','both_individuals','1','2'
both_combined writes all NSSP Priority 1&2 to one x axis
both_individual writes two separate figures for Priority 1 and 2 respectively
*grid: bool, optional (default = True)
-describes output visualization. Draws grid lines over all heatmap cells.
NOTE: cyan line divides priority 1 and priority 2 elements regardless of argument.
only relevant for priority->both combined
*outfile: bool, optional (default = False)
-writes .html file to folder '../figures/'
-if str_date_list=['Feb 1 2020','Aug 31 2020'] and priority='both combined',
outfile has name -> Feb12020_to_Aug312020_priority1and2.html
*show_plot: bool, optional (default = False)
- displays the figure
*Timed : bool, optional (default = True)
-gives completion time in seconds
Returns
-------
nothing
## Code Examples
```
# import the library and all its functions
from HL7reporting import *
# Read in the two datasets (already ran NSSP_Element_Grabber on)
before = pd.read_csv('path_to_parsed_df_file1',engine='python')
after = pd.read_csv('path_to_parsed_df_file2',engine='python')
Visualization_interactive(before,after,['Oct 11 2020','Oct 28 2020'],priority='both_combined',outfile=True,show_plot=False)
```
## Visualization of Output
<img src="https://github.com/pjgibson25/HL7reporting/raw/master/pics/Visualization_interactive.png" alt="Visualization_interactive_Visual">
*note that this image above is simply an image. In reality the output is an interactive HTML file with hover_over capabilities
*also note that the y axis is marked over and typically contains facility names.
<br>
</details>
<details>
<summary>issues_in_messages</summary>
## Documentation
issues_in_messages(df, Timed=True, combine_issues_on_message = False, split_issue_column = False):
Description
----------
Processes dataframe outputted by NSSP_Element_Grabber() function.
Outputs dataframe describing message errors. See optional args for output dataframe customation.
Parameters
----------
df - required, pandas Dataframe, output from NSSP_Element_Grabber() function
*Timed - optional, bool, default is True. Outputs runtime in seconds upon completion.
*combine_issues_on_message - optional, bool, default is False. SEE (2) below
*split_issue_column - optional, bool, default is False. SEE (3) below
NOTE: only one of 'combine_issues_on_message' or 'split_issue_column' can be True
Returns
----------------------------------------------------------------------------
Pandas dataframe. Columns include:
(1)
DEFAULT: WHEN split_issue_colum = False , combine_issue_on_message = False
Group_ID -> string concatenation of FACILITY_NAME|PATIENT_MRN|PATIENT_VISIT_NUMBER
MESSAGE -> full original message
Issue -> string concatenation of 'error_type|element_name|priority|description|valid_options|message_value|suggestion|comment'
------
(2)
WHEN combine_issue_on_message = True, split_issue_colum = False
Group_ID -> string concatenation of FACILITY_NAME|PATIENT_MRN|PATIENT_VISIT_NUMBER
MESSAGE -> full original message
Issue -> string concatenation of 'error_type|element_name|priority|description|valid_options|message_value|suggestion|comment'
MULTIPLE string concatenations per cell, separated by newline '\n'
Num_Missings -> number of issues that had a type of 'Missing or Null'
Num_Invalids -> number of issues that had a type of 'Invalid'
Num_Issues_Total -> number of total issues
------
(3)
WHEN combine_issue_on_message = False , split_issue_colum = True
Group_ID -> string concatenation of FACILITY_NAME|PATIENT_MRN|PATIENT_VISIT_NUMBER
MESSAGE -> full original message
error_type -> 'Missing or Null' or 'Invalid'
element_name -> NSSP Priority Element name with issue
priority -> NSSP Priority '1' or '2'
description -> Describes location/parameters of element in HL7 message
valid_options -> IF element can be checked for validity, describes a valid entry.
message_value -> IF element was determined as invalid, give the invalid element value.
suggestion -> IF element was determined as invalid, give an educated guess as to what they meant.
comment -> IF element was determined as invalid, give feedback/advice on the message error.
## Code Examples
Version 1:
```
# import the library and all its functions
from ADTdq import *
# read in data
data1 = pd.read_csv('somefile.csv',engine='python')
# process through NSSP_Element_Grabber() function
parsed_df = NSSP_Element_Grabber(data1,Timed=False,
Priority_only=True,outfile='None')
# Find issues in messages
split_by_issue = issues_in_messages(parsed_df, split_issue_column=True)
# Get the facility name from the grouper ID
split_by_issue['Fac_Name'] = split_by_issue.Grouper_ID.str.split('\|').str[0]
# First sort the values so that all facility rows are next to one another, then by message similarly
split_by_issue = split_by_issue.sort_values(['Fac_Name','Grouper_ID','MESSAGE','Priority'])
# Set the indices so that when we export to excel, the index cells will merge making it look pretty
split_by_issue = split_by_issue.set_index(['Fac_Name','Grouper_ID','MESSAGE','Issue_Type'])
# Send it to an excel file!
split_by_issue.to_excel('split_by_issue_version1.xlsx')
```
Version 2:
```
# import the library and all its functions
from ADTdq import *
# read in data
data1 = pd.read_csv('somefile.csv',engine='python')
# process through NSSP_Element_Grabber() function
parsed_df = NSSP_Element_Grabber(data1,Timed=False,
Priority_only=True,outfile='None')
# Find issues in messages
comb_issues = issues_in_messages(parsed_df, combine_issues_on_message=True)
# Get the facility name
comb_issues['Fac_Name'] = comb_issues.Grouper_ID.str.split('\|').str[0]
# Make first issue start with bullet point
comb_issues['Issue'] = comb_issues['Issue'].str.replace('^(.*)','• \g<1>',regex=True)
# Make each new line have a bullet point.
comb_issues['Issue'] = comb_issues['Issue'].str.replace('\n','\n• ')
# First sort the values so that all facility rows are next to one another, then by message similarly
comb_issues = comb_issues.sort_values(['Fac_Name','Grouper_ID','MESSAGE'])
# Set the indices so that when we export to excel, the index cells will merge making it look pretty
comb_issues = comb_issues.set_index(['Fac_Name','Grouper_ID','MESSAGE','Issue'])
# Send it to an excel file!
comb_issues.to_excel('comb_issue_version2.xlsx')
```
## Visualization of Output
Version 1
<img src="https://github.com/pjgibson25/ADTdq/raw/master/pics/issues_in_messages_v1.png" alt="issues_in_messages_Visual1">
<br>
Version 2
<img src="https://github.com/pjgibson25/ADTdq/raw/master/pics/issues_in_messages_v2.png" alt="issues_in_messages_Visual2">
<br>
</details>
<details>
<summary>validity_check</summary>
## Documentation
validity_check(df, Timed=True)
Checks to see which elements in a dataframe's specific NSSP priority columns meet NSSP validity standards.
Returns a True/False dataframe with FACILITY_NAME,PATIENT_MRN,PATIENT_VISIT_NUMBER as only string-type columns
Parameters
----------
df - required, pandas Dataframe, output from NSSP_Element_Grabber() function
Timed - optional, boolean (True/False), default is True. Returns time in seconds of completion.
Returns
--------
validity_report - True/False dataframe with FACILITY_NAME,PATIENT_MRN,PATIENT_VISIT_NUMBER as only string-type columns
## Code Examples
```
# import the library and all its functions
from ADTdq import *
# read in data
data1 = pd.read_csv('somefile.csv',engine='python')
# process through NSSP_Element_Grabber() function
parsed_df = NSSP_Element_Grabber(data1,Timed=False,
Priority_only=True,outfile='None')
# take the priority element columns from our output dataframe
#### remove two columns that are processed backend (always NaN)
only_priority1_df = priority_cols(parsed_df,priority='1',drop_cols=['Site_ID','C_Facility_ID'])
# run the validity check function on it
val = validity_check(only_priority1_df)
```
## Visualization of Output
<img src="https://github.com/pjgibson25/ADTdq/raw/master/pics/validity_check.png" alt="validity_check_Visual">
*note the lower number of columns. Not all columns able to be assessed for validity
<br>
</details>
<details>
<summary>validity_and_completeness_report</summary>
## Documentation
validity_and_completeness_report(df,description='long',visit_count=False,outfile=None, Timed=True)
dataframe1 -> Returns completenesss report by hospital with facility,element,percentmissing,percentinvalid,description
dataframe2 -> Determines the incompleteness (0), invalid (1), or valid and complete (2) for every element in all messages
Parameters
----------
df: pandas DataFrame, required (output from NSSP_Element_Grabber() funciton)
description: str, optional. (Either 'long' or 'short')
if 'short', description of location is shorter and less descriptive
elif 'long', description is sentence structured and descriptive
visit_count: bool, optional
if True, add the number of visits to dataframe2
outfile: string, optional
if True, send excel file (in current directory). Name defined by outfile
*DO NOT INCLUDE .xlsx or full path
Returns
-------
df1
Dataframe showing issues in messages for each hospitals. Report structure
df2
Dataframe assessing all messages for incomlete,invalid,valid elements represented as 0s, 1s, and 2s
## Code Examples
```
# import the library and all its functions
from ADTdq import *
# read in data
data1 = pd.read_csv('somefile.csv',engine='python')
# process through NSSP_Element_Grabber() function
parsed_df = NSSP_Element_Grabber(data1,Timed=False,
Priority_only=True,outfile='None')
# run the validity function on it
val = validity_and_completeness_report(parsed_df, description='long')[0] # don't care about array of 0, 1, 2 for now
```
## Visualization of Output[0]
<img src="https://github.com/pjgibson25/ADTdq/raw/master/pics/validity_and_completeness_report.png" alt="validity_and_completeness_report_Visual">
<br>
</details>
<details>
<summary>heatmap_compNvalid</summary>
## Documentation
heatmap_compNvalid(df, outfilename=None, daterange=None, hospitals='IHA')
Create 2 heatmap subplots of elements that:
(left) can be assessed for completion
(right) can be assessed for validity
Input
-----
df - pd.Dataframe, required
Output from NSSP_Element_Grabber() function
outfilename - str, optional
Specify the name of HTML file to be written to ../figures/
*** DO NOT INCLUDE .html ***
daterange - str, optional
Specify the range that the assessment is being taken over.
Example: 'Sep 7, 2020 - Sep 14, 2020'
hospitals - str, optional
Specify the name of the hospitals we are working with
Output
------
completion_df - the dataframe that makes up the completion heatmap
validity_df - the dataframe that makes up the validity heatmap
## Code Examples
```
# import the library and all its functions
from ADTdq import *
# read in data
data1 = pd.read_csv('somefile.csv',engine='python')
# process through NSSP_Element_Grabber() function
parsed_df = NSSP_Element_Grabber(data1,Timed=False,
Priority_only=True,outfile='None')
heatmap_compNvalid(parsed_df, outfilename='heatmap visualization completion and validity')
```
## Visualization of Output
<img src="https://github.com/pjgibson25/ADTdq/raw/master/pics/heatmap_compNvalid.png" alt="heatmap_compNvalid_Visual">
*note that typically the y-axis will show facility names. Hidden here for confidentiality.
<br>
</details>
<details>
<summary>Visualize_Facility_DQ</summary>
## Documentation
Visualize_Facility_DQ(df, fac_name, hide_yticks = False, Timed = True)
Returns Visualization of data quality in the form of a heatmap.
Rows are all individual visits for the inputted facility.
Columns are NSSP Priority elements that can be checked for validity.
Color shows valid entries (green), invalid entries (yellow), and absent entries (red)
Parameters
----------
df - required, pandas Dataframe, output from NSSP_Element_Grabber() function
fac_name - required, str, valid name of facility.
if unsure of valid entry options, use the following code for options:
df['FACILITY_NAME'].unique() # may need to change for your df name
Returns
--------
out[0] = Pandas dataframe used to create visualization. 2D composed of 0s (red), 1s (yellow), 2s (green)
out[1] = Pandas dataframe of data behind visit. Multiple HL7 messages composing 1 visit concatenated by '~' character
Output
-------
sns.heatmap visualization
## Code Examples
```
# import the library and all its functions
from ADTdq import *
# read in data
data1 = pd.read_csv('somefile.csv',engine='python')
# process through NSSP_Element_Grabber() function
parsed_df = NSSP_Element_Grabber(data1,Timed=False,
Priority_only=True,outfile='None')
# produce the visualization
visual = Visualize_Facility_DQ(parsed_df, 'hospital_name')
```
## Visualization of Output
<img src="https://github.com/pjgibson25/ADTdq/raw/master/pics/Visualize_Facility_DQ.png" alt="Visualize_Facility_DQ_Visual">
*note that this only produces the visualization for 1 facility
<br>
</details>
## FAQs
-----------------------
#### Where can I access function documentation outside of this location?
Within a Jupyter Notebook document, you can type:
``FunctionNameHere?``
into a jupyter notebook cell and then run it with `SHIFT` + `ENTER`.
The output will show you all the function documentation including a brief description and argument descriptions.
#### Why Python?
I work entirely in Python.
In the field of public health informatics, SASS is the most popular programming language, perhaps followed by R (at least in syndromic surveillance).
I have created this package to run as intuitively as possible with a minimal amount of python knowledge.
I could be wrong, but I believe that one day, public health informatics may become Python-dominant, so this package could help as an introduction to the environment to those unfamiliar.
#### For plottting, what if I want to make small changes such as color changes, formatting, or simple customizing?
Right now I don't have things set up for that sort of work. My best solution would be for you to dive into my Github reposiory python file linked [here](https://github.com/pjgibson25/ADTdq/blob/master/ADTdq/__init__.py). You can copy the defined functions into your document and make minor adjustments as you see fit.
#### Why isn't one of my functions working?
The most common problem in this situation is a incorrectly formatted input to a function. Most of DQ functions stems from an intial NSSP_Element_Grabber() run. The input to this function should contain the following columns:
`['MESSAGE','FACILITY_NAME'] `
Note that you can pass the argument No_FAC, No_VisNum, or No_MRN. When these optional arguments are passed, the resulting output could return erros when used in conjunction with other DQ functions.
This is because many of my functions collapse messages into individual visits. The collapsing process requires Facility, MRN, and Visit Number. Missing elements in these fields throws a wrench into the process.
#### My version is out of date (there has been a more recent release). How do I update?
Type the following into your command line / terminal
pip install ADTdq --update
#### My question isn't listed above...what should I do?
feel free to contact me at:
[email protected]
with any additional questions.
## The Author
PJ Gibson - Data Analyst for Washington State Department of Health
## Special Thanks
* Harold Gil - Director of Public Health Informatics for Indiana State Department of Health.
Harold assigned me this project, gave me relevant supporting documentation, and helped me along the way with miscellaneous troubleshooting.
* Matthew Simmons - Data Analyst for Indiana State Department of Health.
Matthew helped walk me through some troubleshooting and was a supportive figure throughout the project.
* Ben Sewell, Shuennhau Chang, Logan Downing, Ryan Hastings, Nicholas Hinkley, Rachel Winchell.
Members of my informatics team that also supported me indirectly!
| ADTdq | /ADTdq-1.1.2.tar.gz/ADTdq-1.1.2/README.md | README.md |
import collections, warnings
from . import hbds
__all__ = (
"Cache",
)
class Cache(collections.MutableSet):
"""
Implémente un *cache d'objet* comme un *set* python.
Si un objet est ajouté dans le *cache*, sa classe sera instrumentée
pour réagir à la modification des attributs (setattr)
Si cet objet est un objet hbds, il sera également instrumenté
pour réagir à la création des relations entre objets.
Par exemple, on définit 2 classes HBDS reliées entre elles:
>>> class Humain(metaclass=hbds.Class):
... nom = str
>>> class Voiture(metaclass=hbds.Class):
... type = str
>>> possede = hbds.Link(Humain, 'possede', Voiture)
Puis on crée des instances
>>> h1 = Humain("Jean"); h2 = Humain("Paul")
Que l'on ajoute à un cache
>>> cache = Cache((h1, h2))
Toutes les modifications des attributs et des relations seront notifées:
>>> h1.nom = "Jean-Paul"
>>> h2.nom = "Pierre-Paul"
>>> v1 = Voiture("X"); v2 = Voiture("Y")
>>> p1 = possede(h1, v1); p2 = possede(h2, v2)
"""
_caching_types = {}
_caches = []
def __init__(self, iterable=[]):
self._cache = set(iterable)
self._caches.append(self)
def __contains__(self, obj):
return obj in self._cache
def __iter__(self):
return iter(self._cache)
def __len__(self):
return len(self._cache)
def __del__(self):
self._caches.remove(self)
def add(self, obj):
self._cache.add(obj)
self._instrument(obj)
def discard(self, obj):
self._cache.discard(obj)
self._uninstrument(obj)
def _instrument(self, obj):
cls = type(obj)
if cls in self._caching_types: return
oldfset = cls.__setattr__
def fset(instance, attr, value):
oldvalue = getattr(instance, attr, None)
for cache in Cache._caches:
if instance in cache:
cache.before_setattr(instance, attr, oldvalue )
oldfset(instance, attr, value)
for cache in Cache._caches:
if instance in cache:
cache.after_setattr(instance, attr, value)
cls.__setattr__ = fset
self._caching_types[cls] = oldfset
for R in list((cls,) | hbds.PSC)+ list( (cls,) | hbds.NSC): # relations in & out
oldinit = R.__init__
def init(rel, *args, **kargs):
oldinit(rel, *args, **kargs)
self.link(type(rel), args[0], args[1])
R.__init__ = init
oldcut = R.cut
def cut(rel):
oinit = rel.__oinit__
ofin = rel.__ofin__
oldcut(rel)
self.unlink(type(rel), oinit, ofin)
type.__setattr__(R, 'cut', cut) # R.cut = cut
def before_setattr(self, obj, attr, old_value):
warnings.warn("Cache before_setattr() is not Implemented")
# do nothing in default implementation
def after_setattr(self, obj, attr, new_value):
warnings.warn("Cache after_setattr() is not Implemented")
# do nothing in default implementation
def link(self, relcls, oinit, ofin):
warnings.warn("Cache link() is not Implemented")
# do nothing in default implementation
def unlink(self, relcls, oinit, ofin):
warnings.warn("Cache unlink() is not Implemented")
# do nothing in default implementation
def _uninstrument(self, obj):
if len([o for cache in Cache._caches for o in cache \
if type(o) is type(obj)]) == 0:
fset = self._caching_types[type(obj)]
type(obj).__setattr__ = fset | ADTthious | /ADTthious-0.5.tar.gz/ADTthious-0.5/util.py | util.py |
<h1>Table of Contents<span class="tocSkip"></span></h1>
<div class="toc" style="margin-top: 1em;"><ul class="toc-item"></ul></div>
```
class D:
def __init__(self):
self.classvars = {}
def __set_name__(self, cls, name):
self.name = name
def __get__(self, instance, ownerclass):
if instance:
if isinstance(instance, type):
return self.classvars[instance]
return instance.__dict__.get(self.name, None)
return ownerclass.__dict__[self.name]
def __set__(self, instance, val):
if isinstance(instance, type):
self.classvars[instance] = val
else:
instance.__dict__[self.name] = val
class Class(type):
def __new__(cls, name, base, clsdict):
for att in clsdict:
if att.startswith('_'): continue
if not isinstance(clsdict[att], D):
raise TypeError("Attribute must be of type 'Att'")
def fset(instance, att, val):
#print("%s.__setattr__(fset)" % type(instance).__name__, instance, att, val)
if not hasattr(type(instance), att):
m = "Class instance '%s' has no Att '%s'"
raise AttributeError(m % (instance, att))
super(type(instance), instance).__setattr__(att, val)
clsdict['__setattr__'] = fset
return type.__new__(cls, name, base, clsdict)
def __setattr__(cls, att, val):
#print("Class.__setattr__", cls, att, val)
if not hasattr(type(cls), att):
m = "Class type '%s' has no Att '%s'"
raise AttributeError(m % (cls, att))
super().__setattr__(att, val)
class YT(Class, metaclass=Class):
d = D()
class Y(metaclass=YT): pass
class X(metaclass=YT):
a = D()
Y.d = 1
X.d = 2
Y.d, X.d
YT.d.classvars
try:
Y.x = 12
except AttributeError as e:
print(e)
try:
YT.a = 12
except AttributeError as e:
print(e)
try:
YT.d = 1
except AttributeError as e:
print(e)
x = X()
try:
x.z = 12
except AttributeError as e:
print(e)
x.a = 12
x.a
try:
class Z(metaclass=Class):
i = 1
except TypeError as e:
print(e)
```
| ADTthious | /ADTthious-0.5.tar.gz/ADTthious-0.5/Class instance of Type.ipynb | Class instance of Type.ipynb |
calendar = b'iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAEnQAABJ0Ad5mH3gAAANJSURBVFhH7Zc7S2NBFMf/iW9BRLAQbVS0sBF8FVYmkCCKlY1gqyBW+QaChWBj4QfwrYhGEDUIIr6VRBQrsRKFdDY+8C3q3Tknc2/uTWZv1mzAXXZ/MMz8j+P1zJlzZkaHJsA34pT9t/F3OHB4eAiHw8EtHA5LK1BbW8u2np4eaQHW1taMube3t9JqA+VAIrKysrS9vT1tYmJCq6ysZNvCwoJWXFzMY/rM1dWVMb68vNT6+/u15uZmttlhG4FgMIiVlRW8vr6iuroadXV1HIHt7W0sLy+jsbGR5xUWFmJ8fBxbW1usS0tLUVNTg7OzM6yuruL6+prtSqQjcVRUVPBq9HZzc6Odnp5abJ2dnTy3rKzMYicCgYDFNjw8zPZYlBEQ4cP5+blUEcQ2cDOTmZnJfXp6Ovdm9J/p+Hw+PD09SRVF6cD+/r4cRaGwb2xsSBUhFApxf3Fxwb3O8fExdnd3pYpydHQkR1GUB1Fvby/W19eNVdAUymin04n8/Hy2ES8vL7i/v0dBQYERBZortgsZGRnIy8tjm14RS0tLqK+vZ5vOn3kStrW1sdepYnR0lL+n2halAx8fH3IUz93dHecD5cnJyQnbNjc3cXBwAHFWsN7Z2WFNdkJfDG1hHLQFsbS2tnLpqBDnglFaRUVFmnDW0PrvxGo6wGgsnGZtRhkBO8yrUJXfV/nyFxoaGjA1NcUVQhVBDk1OTiInJ8fYuunpaWRnZ+Ph4YG1WCj3KhJGYHFxES6XCx6PB0NDQ3h8fMTMzAzm5+f54iHIIb/fj7m5Odazs7P8c3IkIZGdsGLOgcHBQWM/Ozo6NHGYGLq8vFz7/Pw0NDUiVv9WDry9vckR8Pz8jPf3d6nA0RAOSJUk0hELdlWQDGNjY8lHYGBggOuYWnt7O5//ui4pKeHE0zU1IlYr61+S0AFzqVHmmzXdjnYf/xUSlmFVVRW8Xi/S0tL4AUIXj9vtRm5uLkQS8iqbmpq4JPV8oPlUlnQpESLS3CuJ7ISVlpaWlOaAeC0lnwOpwO5uUV7HIyMj6O7u5nedeHbxvZ8MtD20LX19fawVf+rnce7q6uKwpaqJB678shXbBwmtnF4yejklA31e3JpSxfP/f8N/3QHgBz2bl1olyd2uAAAAAElFTkSuQmCC'
pyclass = b'iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAHYgAAB2IBOHqZ2wAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAAO8SURBVFiF7ZVvaJVVHMc/v3N33UjFNNoyyGpJfxSaV0tEFH2TYlghIyJCkxTbWkYYFIGF9EIqLUEx8yqMVCLK8EVgbxT7t6KNMgSlrJboomxKOnfvnuee3zm/XmzTzY1BdKU3+8ADz3M4h+/nd855zoERmLp2ayUbNrj+79zad+tyjfkFI435t7jhGmc07VydeyZ/cnysKuY6b05yTfn9AET3Go4D5RSouLph5rO7HjOzXQhtCEsBzGzREMnnm6+3Uml2xrmJYBe6JPnsl23PpQB1Tfk7MzAjipWyIXusbcdT7bPW7MyGrFvohElAp1ZVfnts84rCEAEzWwHgnD3+3banf+1r/vTqfqJ+uYg0mHHOIDfeqk4vXNl8X9c4nWtmh0z4XkyiOgWYHbOyX7AFZhwFajPF9BVgzxABEZtiJn5A+LBUZbt3J6XrTiCZ25xxxuCJi2PTnESZhggGe4XYOsaVjvcNmQ6cxGS7y8bWMa67E4bZA2bSDmTrmvLTRxJI0nHbwB3EmB9hAoBFmSTKXiDvzBrBtZRi1Tez1uzMGtKIcRGxfFQ5laZjVw0rAPEtIDr4KNeUX9737BnSTbgf+EuMNwTSywVk3FRDPlZxS4BmYJqr0BuQeKNzti7CfKBoTuYOK3B0e8MXOBZjnAO2grwpQgIgwlkxO9X7LhuBMSb2iRgdhrWbULSMVQu2I2N2HGGJYBvb3mn605k8GE0OO2gDfrLIlt46ruLhTYfu9RrmqPqJGvRSTELb56/Xt420HP+FQQIPbT4yT4OuV1+6Sb3WBfWo96a+VN+65cmy/v/9DFoCH8IdIWg2aMiEoARVgnqJQeddi3DoO4gWv/31pAqfzPOaVkfV8yH48+p9KaqfGYKSdT5jf6x7lEzmZ6ne9ENZBZZtaqlOteeYBl/TW7UneCVengGlZkLIIvIhvmh2evUCmbL7y3IJuJKlS0PQmv4w1SvBQRWLkZm3FLrQAmhBCIX6coUDVGjwtQMCzcXSgbtqLnaGECAG7q7p+fvFB35bhCYQEohJbVkFTPV8UE9Qz+0Tu3a8t/zEMmAyFiEmENLe4JBATCGmF8oq4E1b+6d+1ZwzXcBkor8S2B8e0l6h6A+XVeDIq4+0zH3pgxdCCIsmVGpxQLUdhPRHQs8VGewESfJ+OQUGHUTW0bCSkDT3TX1KSAqE5BLm98n0r9aXM7ifwXeBdnf27vYiaKESLfxO9C8D3dcifKjArfsOEnoa8YVWtHAWCwp2Dz09W6+VwCijjDLKKP87/wBXLynO0kO6IQAAAABJRU5ErkJggg=='
pyfunction = b'iVBORw0KGgoAAAANSUhEUgAAABsAAAAHCAYAAAD5wDa1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAHYgAAB2IBOHqZ2wAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAAGzSURBVCiRtZG/a5NxEMY/932TNCqxVBBtRdBStyJNXETs4h9QEKSCmxRfIbEODuKPpW6drVEai3R30KlLRURxUGgjlaIiRFERwRY1pBib9/0+DkmxTWaf5Y7juOfuc5YtlMRWvS4Xw8P8ByUAEO/ldB1Anl8D4ze7MqSH4yj4vHRn7F0uPzOgwB9IJ2rPq+zclop8zjfiN5ZIHDJpb/da8uGT2bN1gOz4vd0Wx8PefCYwXizcOv92q5mRcLgegBi/0v2na5dPMh+4eAq4KKcxPFfWGpn+lKJ+cPMWuIpJaaCvuiO6D4wO5UvH8NGcDAz76KVPwMiGmWvF/ZImJU06s9P/Drd2xJv1qFwM9wEvBSeaO3MDSMfOBsvFcGhd0ZkOjIKFV8Xw6EbxSDjd26z7oIV5e7uTE4utdAU02CK0B1hdmjr3BWD5dqHW+bM21ft6VlPffzYMO54rlE4Knepock4AZkit+814JpHPXZi+TOye4tS7WAwfZAt3Z0EjTqgCfN08Z3lidF3YBHBQ2DWwOaEKRkNyv4UqkqoA8nwDPgAkrX4VbEayS3J6LGviFb4m9OMvVom7Q0c4yR8AAAAASUVORK5CYII='
pymodule = b'iVBORw0KGgoAAAANSUhEUgAAAB0AAAAUCAYAAABxnDbHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAHYgAAB2IBOHqZ2wAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAAN3SURBVEiJrZRvaNVVGMc/z+/eO1qzhZKRigZBE9pYmg0iCpUM/2BgL9KQBFl5h1dxRURRLxq9KytwzcksV0Hv9EX4IiukYb3oRUwbc6H2IlLTTSq3G/fe3++e5zmnF/Pa3boJdv3C4XCec57zeb7PgSPMUkducLGigwBeeHFkf3ZsVU9POn9l4eEAc4j44FRf9ujsvFpatf3j26aaXInAoVP92Rcq8fTsgz5yTQRZAyCEPUDX5O8LnhZhE4AE+bxydkV2IBOlM/d4dePDB7tcddxFfi4x+VrFRDcodFSQ51pf+mieBOkGRqs3l+UO5nxGJlX0vM/I5PJdAzsBHtr5YbvPyMVUKjWRn+OO3BQ0BDkKXGlIrB94VET6rjvpHlgiQi8SviyWUs0BvgLp7cgNLg5ReAto9tAWAp/dFFQkWBD2I7IF+DoEO1PZ815agJR4hs4OPv9XFMI3QFql3ALcL4RfR/ZnxyIXjtW6+19vWi0zPZRJpZ80H96OpKrSKJzzXiyIrFraeejTEOlqApoODedU9OeArH1w18FWH6QdwvW85bmB10CeuNGbMnogd/VkX3btSH/XUHV8eF/XeUG6gfW3N1qeIOtCoPuH/s4LRP5NIB/BaQjbqvMCtCKsEWZpw3vHW6ys91lZU6Zu/K4z7sfDhzdbraJWZAcyNLIgnjt3fKxnc7k6njRG807v2zFRK28GdOO7Q33O6b2myUZ1DnMOVXfi+71bV4OEWhf8H81or6l7xGv5uJkGU8VMMdWVy3cPLrhVQLjmdH3vt/OtUFriTTtNdb45RV2yzlTvUOfYvvJyx+7HJ8vcPecnkR6tF5p+6v0TW7VU/iR4n/FqmHOYOkz12uzYsiy/DW97+G3iGLChXmik6l42dZkKYBr2zwgQ39mQNKMFsML6cP7ZhXU7NdWlVZC8mfvCzOXVHJm08frai5caKLyKlsDH4JMW4FK90LypNpk6d+CZ0XfaFpXeABrxOg2xGDSZnn0MWi7W6zQy1ZPTbbWzbYviTUAjloAVQKvG9PpPSlOn64WmvY9fMefTZu4PgrZhMVgCPh7D4hifgMZgiUOkVx4ertvpjM8hXNgxgsXt+AQsvoDFRSzJIP4xeeC7y/XCKpr592rhKlqstHQxrrCX4H6hWKzb3X9DfSmLLxxBCxNYPIlI57WWTt1K6N/5VQVqxtaQ4AAAAABJRU5ErkJggg==' | ADTthious | /ADTthious-0.5.tar.gz/ADTthious-0.5/output.py | output.py |
import PySimpleGUI as sg
from ADT import hbds
import types
class QueryTree:
"""
One instance of QueryTree means a item of a Tree and request to
give sub items. This class doesn't produce any sub query.
It will be convenient to refined it to define real query.
"""
def __init__(self, obj):
"""
Ceate a query with *obj* on which excute the query.
"""
self.obj = obj
self.sub_queries = []
self.already_exec = False
def __call__(self):
"""
Execute the query if it didn't already executed
and return the resulting sub queries.
"""
if not self.already_exec:
self.sub_queries = self.exec()
self.already_exec = True
return self.sub_queries
def exec(self):
"""
Execute the query to retrieve sub queries.
You must refine this method to produce your own queries.
"""
return []
@property
def attrs(self):
"""
Return list of values to be display.
By default, return the *obj* as python *str* carried by the query.
"""
return [str(self.obj)]
@property
def icon(self):
"""
Return icon, None by default.
"""
return None
def create_QueryTree(name, attrs=None, icon=None):
"""
Facility function for define QueryTree without declare a class.
*name* is a name of created query class that will inherit from QueryTree,
*attrs* must be a function, *icon* an object.
If *attrs* and *icon* are None, ...
"""
def update(clsdic):
if attrs:
clsdic['attrs'] = property(fget=attrs)
if icon:
clsdic['icon'] = property(fget=lambda i: icon)
return types.new_class(name, bases=(QueryTree,), exec_body=update)
class Tree(sg.Tree):
def __init__(self, query, **kargs):
kargs['key'] = self._key(query)
self.queries_by_key = {self._key(query): query}
treedata = sg.TreeData()
treedata.Insert("", self._key(query),
text=query.attrs[0], values=query.attrs[1:],
icon=query.icon)
self._exec(query, treedata)
super().__init__(data=treedata, enable_events=True, **kargs)
## show_expanded=False,
def _exec(self, query, treedata=None):
"""
Insert sub queries of *query* into the tree.
"""
# on execute la première query pour savoir s'il elle produit des sous queries
for q in query():
if self._key(q) in self.queries_by_key:
continue
self.queries_by_key[self._key(q)] = q
if treedata:
treedata.Insert(self._key(query), self._key(q),
text=q.attrs[0], values=q.attrs[1:],
icon=q.icon)
else:
self.Insert(self._key(query), self._key(q),
text=q.attrs[0], value=q.attrs[1:],
icon=q.icon)
def _key(self, query):
return str(id(query))
def treeview_open(self, event):
super().treeview_open(event)
try:
query = self.queries_by_key[self.SelectedRows[0]]
except KeyError:
print('error')
return
for q in query():
self._exec(q)
def test():
import inspect
from ADT import images
class Qmodule(QueryTree):
"""*obj* of the query is a module"""
def exec(self):
sub = []
for n in dir(self.obj):
o = getattr(self.obj, n)
if inspect.ismodule(o):
if o.__name__ != 'builtins':
sub.append(Qmodule(o))
elif inspect.isclass(o):
sub.append(Qclass(o))
elif inspect.isfunction(o):
sub.append(Qfunction(o))
else:
sub.append(Qother(o))
return sub
@property
def attrs(self):
return [self.obj.__name__]
@property
def icon(self):
return images.pymodule
Qclass = create_QueryTree('Qclass', attrs=lambda self: [self.obj.__name__],
icon=images.pyclass)
Qfunction = create_QueryTree('Qfunction', attrs=lambda self: [self.obj.__name__],
icon=images.pyfunction)
Qother = create_QueryTree('Qother', attrs=lambda self: [str(self.obj), type(self.obj)])
import sys
current_module = sys.modules[ globals()['__name__']]
tree = Tree(Qmodule(current_module), col0_width=30, max_col_width=40, num_rows=30,
headings=[ 'type'])
layout = [
[ tree ],
]
window = sg.Window('QueryTree Test', resizable=True).Layout(layout)
while True:
event, values = window.Read()
if event is None:
break
if event == '__TIMEOUT__': continue
query_key = values[event][0]
if query_key in tree.queries_by_key:
q = tree.queries_by_key[query_key]
print('query obj', q.obj, q.attrs)
else:
print(event, values)
if __name__ == '__main__':
test() | ADTthious | /ADTthious-0.5.tar.gz/ADTthious-0.5/querytree3.py | querytree3.py |
import enum
class Unit(enum.Enum):
"""
Classe de base pour définir des unités de mesure.
Inspirée de *Python Standard Library*, § DataTypes, enum.
"""
def __new__(cls, val, symbol):
obj = object.__new__(cls)
obj._value_ = val
obj._symbol = symbol
return obj
def convert(self, value, other):
raise NotImplementedError
@property
def symbol(self): return self._symbol
_units_map = {}
class OrderUnit(Unit):
"""
Classe de base pour les unités de mesures qui ont des
multiples et sous multiples.
Inspiré de *Python Standard Library*, § DataTypes, enum.
"""
def convert(self, value, other):
"""
Si *value* est exprimée dans le multiple *self*,
retourne cette valeur exprimée dans un *other* multiple.
Par exemple, pour les multiples du mètre:
```
>>> Meter.kilometre.convert(10, Meter.metre)
>>> 10000
```
"""
other = self._match(other)
if other is NotImplemented: raise ValueError
return value*(10**(self.value - other.value))
def _match(self, other):
if self.__class__ is other.__class__: return other
return _units_map.get(other, NotImplemented)
def __ge__(self, other):
other = self._match(other)
return other if other is NotImplemented else self.value >= other.value
def __gt__(self, other):
other = self._match(other)
return other if other is NotImplemented else self.value > other.value
def __le__(self, other):
other = self._match(other)
return other if other is NotImplemented else self.value <= other.value
def __lt__(self, other):
other = self._match(other)
return other if other is NotImplemented else self.value < other.value
def __eq__(self, other):
other = self._match(other)
return other if other is NotImplemented else super().__eq__(other)
def __hash__(self): return super().__hash__()
class Meter(OrderUnit):
"""
Définit l'énumaration des multiples de l'unité de mesure du **mètre**
selon [wikipedia](https://fr.wikipedia.org/wiki/M%C3%A8tre)
"""
yoctometre = (-24, 'ym')
zeptometre = (-21, 'zm')
attometre = (-18, 'am')
femtometre = (-15, 'fm')
picometre = (-12, 'pm')
nanometre = ( -9, 'nm')
micormetre = ( -6, 'µm')
millimetre = ( -3, 'mm')
centimetre = ( -2, 'cm')
decimetre = ( -1, 'dm')
metre = ( 0, 'm')
decametre = ( 1, 'dam')
hectometre = ( 2, 'hm')
kilometre = ( 3, 'km')
megametre = ( 6, 'Mm')
gigametre = ( 9, 'Gm')
terametre = ( 12, 'Tm')
petametre = ( 15, 'Pm')
exametre = ( 18, 'Em')
zettametre = ( 21, 'Zm')
yottametre = ( 24, 'Ym')
class Kilogram(OrderUnit):
"""
Définit l'énumaration des multiples de l'unité de mesure du **kilogramme**
selon [wikipedia](https://fr.wikipedia.org/wiki/Kilogramme)
Seuls sont définis:
* la tonne (Mégagramme) comme multiples;
* les sous-multiples les plus utilisés.
"""
microgram = ( -9, 'µg')
milligram = ( -6, 'mg')
centigram = ( -5, 'cg')
decigram = ( -4, 'dg')
gram = ( -3, 'g')
decagram = ( -2, 'dag')
hectogram = ( -1, 'hg')
kilogram = ( 0, 'kg')
tonne = ( 3, 't')
class SquareMeter(OrderUnit):
"""
Définit l'énumaration des multiples de l'unité de mesure du **Mètre carré**
selon [wikipedia](https://fr.wikipedia.org/wiki/M%C3%A8tre_carr%C3%A9)
"""
millimeter_square = ( -6, 'mm²')
centimeter_square = ( -4, 'cm²')
decimeter_square = ( -2, 'dm²')
meter_square = ( 0, 'm²') # == centiare
centiare = ( 0, 'ca')
decameter_square = ( 2, 'dm²') # == are
are = ( 2, 'a')
hectometer_square = ( 4, 'hm²') # == hectare
hectare = ( 4, 'ha')
kilometer_square = ( 6, 'km²')
class CubicMeter(OrderUnit):
"""
Définit l'énumaration des multiples de l'unité de mesure du **Mètre Cube**
selon [wikipedia](https://fr.wikipedia.org/wiki/M%C3%A8tre_cube)
"""
cubic_millimeter = (-9, 'mm3')
cubic_centimeter = (-6, 'cm3')
cubic_decimeter = (-3, 'dm3')
cubic_meter = ( 0, 'm3')
cubic_decameter = ( 3, 'dam3')
cubic_hectometer = ( 6, 'hm3')
cubic_kilometer = ( 9, 'km3')
class Liter(OrderUnit):
"""
Définit l'énumaration des multiples de l'unité de mesure du **Litre**
selon [wikipedia](https://fr.wikipedia.org/wiki/Litre)
"""
milliliter = (-3, 'ml')
centiliter = (-2, 'cl')
deciliter = (-1, 'dl')
liter = ( 0, 'l')
hectoliter = ( 2, 'hl')
_units_map[Liter.liter] = CubicMeter.cubic_decimeter
_units_map[Liter.milliliter] = CubicMeter.cubic_millimeter
_units_map[CubicMeter.cubic_decimeter] = Liter.liter
_units_map[CubicMeter.cubic_millimeter] = Liter.milliliter
class SpeedUnit(Unit):
"""
Définit l'énumaration des multiples de l'unité de mesure du **Litre**
selon [wikipedia](https://fr.wikipedia.org/wiki/M%C3%A8tre_par_seconde) et
[wikipedia](https://fr.wikipedia.org/wiki/Kilom%C3%A8tre_par_heure)
"""
meter_per_second = (0, 'm/s')
kilometer_per_hour = (1, 'km/h')
def convert(self, value, other):
"""
Si *value* est exprimée dans une des deux grandeurs,
retourne cette valeur exprimée dans l'*other*.
"""
if (self, other) == (SpeedUnit.meter_per_second, SpeedUnit.kilometer_per_hour):
return value*3.6
if (self, other) == (SpeedUnit.kilometer_per_hour, SpeedUnit.meter_per_second):
return value/3.6
raise ValueError
class TemperatureUnit(Unit):
celcius = (0, '°C')
kelvin = (1, 'K')
def convert(self, value, other):
"""
Si *value* est exprimée dans une des deux grandeurs,
retourne cette valeur exprimée dans l'*other*.
"""
if (self, other) == (TemperatureUnit.celcius, TemperatureUnit.kelvin):
return value+273.15
if (self, other) == (TemperatureUnit.kelvin, TemperatureUnit.celcius):
return value-273.15
raise ValueError
__all__ = (
"Unit",
"Meter",
"Kilogram",
"SquareMeter",
"CubicMeter",
"Liter",
"SpeedUnit",
"TemperatureUnit",
) | ADTthious | /ADTthious-0.5.tar.gz/ADTthious-0.5/units.py | units.py |
import sys
if sys.version_info[0] >= 3:
import tkinter as tk
from tkinter import filedialog
from tkinter.colorchooser import askcolor
from tkinter import ttk
import tkinter.scrolledtext as tkst
import tkinter.font
else:
import Tkinter as tk
import tkFileDialog
import ttk
import tkColorChooser
import tkFont
import ScrolledText
import types
import datetime
import time
import textwrap
import pickle
import calendar
from random import randint
import uuid
g_time_start = 0
g_time_end = 0
g_time_delta = 0
def TimerStart():
global g_time_start
g_time_start = time.time()
def TimerStop():
global g_time_delta, g_time_end
g_time_end = time.time()
g_time_delta = g_time_end - g_time_start
print(int(g_time_delta*1000))
"""
Welcome to the "core" PySimpleGUI code....
It's a mess.... really... it's a mess internally... it's the external-facing interfaces that
are not a mess. The Elements and the methods for them are well-designed.
PEP8 - this code is far far from PEP8 compliant.
It was written PRIOR to learning that PEP8 existed.
The variable and function naming in particular are not compliant. There is
liberal use of CamelVariableAndFunctionNames. If you've got a serious enough problem with this
that you'll pass on this package, then that's your right and I invite you to do so. However, if
perhaps you're a practical thinker where it's the results that matter, then you'll have no
trouble with this code base. There is consisency however.
I truly hope you get a lot of enjoyment out of using PySimpleGUI. It came from good intentions.
"""
# ----====----====----==== Constants the user CAN safely change ====----====----====----#
# Base64 encoded GIF file
DEFAULT_BASE64_ICON = b'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'
DEFAULT_BASE64_LOADING_GIF = b'R0lGODlhQABAAKUAAAQCBJyenERCRNTS1CQiJGRmZLS2tPTy9DQyNHR2dAwODKyqrFRSVNze3GxubMzKzPz6/Dw6PAwKDKSmpExKTNza3CwqLLy+vHx+fBQWFLSytAQGBKSipERGRNTW1CQmJGxqbLy6vPT29DQ2NHx6fBQSFKyurFRWVOTi5HRydPz+/Dw+PP7+/gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJCQAsACwAAAAAQABAAAAG/kCWcEgsGo/IpHLJbDqf0CjxwEmkJgepdrvIAL6A0mJLdi7AaMC4zD4eSmlwKduuCwNxdMDOfEw4D0oOeWAOfEkmBGgEJkgphF8ph0cYhCRHeJB7SCgJAgIJKFpnkGtTCoQKdEYGEmgSBlEqipAEEEakcROcqGkSok8PkGCBRhNwcrtICYQJUJnDm0YHASkpAatHK4Qrz8Nf0mTbed3B3wDFZY95kk8QtIS2bQ29r8BPE8PKbRquYBuxpJCwdKhBghUrQpFZAA8AgX2T7DwIACiixYsYM2rc+OSAhwrZOEa5QGHDlw0dLoiEAqEAoQK3VjJxCQmEzCUhzgXciOKE/gIFJ+4NEXBOAEcPyL6UqEBExLkvIjYyiMOAyICnAAZs9IdGgVWsWjWaTON1yAGsUTVOTUOhyLhh5TQi7cqUyIVzKjmiYCBBQtAjNAnZvKmk5cuYhJVc6DAWZd7ETTx6CAm5suXLRQY4sPDTQoqwmIlAADE2DYi0oUUQhbQC8WUQ5wZf9oDVA58KdaPAflqgTgMEXxA0iPIB64c6I9AgiFL624Y2FeLkbtJ82HM2tNPYfmLBOHLlUQJ/6z0POADhUa4+3V7HA/vw58gfEaFBA+qMIt6Su9/UPAL+F4mwWxwwJZGLGitp9kFfHzgAGhIHmhKaESIkB8AIrk1YBAQmDJiQoYYghijiiFAEAQAh+QQJCQApACwAAAAAQABAAIUEAgSEgoREQkTU0tRkYmQ0MjSkpqTs6ux0cnQUEhSMjozc3ty0trT09vRUUlRsamw8OjwMCgxMSkx8fnwcGhyUlpTk5uS8vrz8/vwEBgSMioxERkTc2txkZmQ0NjS0srT08vR0dnQUFhSUkpTk4uS8urz8+vxsbmw8Pjz+/v4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG/sCUcEgsGo/IpHLJbDqf0Kh0Sl0aPACAx1DtOh/ZMODhLSMNYjHXzBZi01lPm42BizHz5CAk2YQGSSYZdll4eUUYCHAhJkhvcAWHRiGECGeEa0gNAR4QEw1TA4RZgEcdcB1KBwViBQdSiqOWZ6wABZlIE3ATUhujAAJsj2FyUQK/wWbDcVInvydsumm8UaKjpWWrra+whNBtDRMeHp9UJs5pJ4aSXgMnGxsI2Oz09fb3+Pn6+/xEJh8KRjBo1M/JiARiEowoyIQAIQIMk1T4tXAfBw6aEI5KAArfgjcFFhj58CsLg3zDIhXRUBKABnwc4GAkoqDly3vWxMxLQbLk/kl8tbKoJAJCIyGO+RbUCnlkxC8F/DjsLOLQDsSISRREEBMBKlYlDRgoUMCg49ezaNOqVQJCqtm1Qy5IGAQgw4YLcFOYOGWnA8G0fAmRSVui5c+zx0omM2NBgwYLUhq0zPKWSIMFHCojsUAhiwjIUHKWnPpBAF27H5YEEBOg2mQA80A4ICQBRBJpWVpDAfHabAMUv1BoFkJChGcSUoCXREGEUslZRxoHAB3lQku8Qg7Q/ZWB26HAdgYLmTi5Aru9hPwSqdryKrsLG07fNTJ7soN7IAZwsH2EfUn3ETk1WUVYWbDdKBlQh1Usv0D3VQPLpOHBcAyBIAFt/K31AQrbBqGQWhtBAAAh+QQJCQAyACwAAAAAQABAAIUEAgSEgoTEwsREQkTk4uQsLiykoqRkYmQUEhTU0tRUUlT08vS0srSMjox8enwMCgzMysw8OjwcGhxcWlz8+vy8urxMSkzs6uysqqxsamzc2tyUlpQEBgSMiozExsTk5uQ0NjSkpqRkZmQUFhRUVlT09vS0trSUkpR8fnwMDgzMzsw8PjwcHhxcXlz8/vy8vrxMTkzc3tz+/v4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG/kCZcEgsGo/IpHLJbDqf0Kh0Sq1ar8nEgMOxqLBgZCIFKAMeibB6aDGbB2u1i+Muc1xxJSWmoSwpdHUcfnlGJSgIZSkoJUptdXCFRRQrdQArhEcqD24PX0wUmVMOlmUOSiqPXkwLLQ8PLQtTFCOlAAiiVyRuJFMatmVpYIB1jVEJwADCWCWBdsZQtLa4artmvaO2p2oXrhyxVCWVdSvQahR4ViUOZAApDuaSVhQaGvHy+Pn6+/z9/v8AAzrxICJCBBEeBII6YOnAPYVDWthqAfGIgGQC/H3o0OEDEonAKPL7IKHMCI9GQCQD0S+AmwBHVAJjyQ/FyyMgJ/YjUAvA/ggCFjFqDNAxSc46IitOOlqmRS6lQwSIABHhwAuoWLNq3cq1ogcHLVqgyFiFAoMGJ0w8teJBphsQCaWcaFcGwYkwITiV4hAiCsNSB7B4cLYXwpMNye5WcVEgWZkC6ZaUSAQMwUMnFRybqdCEgWYTVUhpBrBtSQfNHZC48BDCgIfIRKxpxrakAWojLjaUNCNhA2wZsh3TVuLZMWgiJRTYgiFKtObSShbQLZUinohkIohkHs25yYnERVRo/iSDQmPHBdYi+Wsp6ZDrjrNH1Uz2SYPpKRocOZ+sQJEQhLnBgQFTlHBWAyZcxoJmEhjRliVw4cMfMP4ZQYEADpDQggMvJ/yWB3zYYQWBZnFBxV4p8mFVAgzLqacQBSf0ZNIJLla0mgGu1ThFEAAh+QQJCQAqACwAAAAAQABAAIUEAgSUkpRERkTMyswkIiTs6uy0trRkZmQ0MjTU1tQcGhykpqRUVlT09vTEwsQsKix8enwMCgycnpzU0tS8vrw8Ojzc3txcXlz8/vwEBgSUlpRMSkzMzswkJiT08vS8urxsamw0NjTc2twcHhysqqz8+vzExsQsLix8fnxkYmT+/v4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG/kCVcEgsGo/IpHLJbDqf0Kh0Sq1ar8tEAstdWk4AwMnSLRfBYbF5nUint+tu2w2Ax5OFghMdPt2TBg9hDwZMImgnIn9HH3QAhUxaTw0LCw1WHY4dax6CAA8eVAWOYXplEm4SoqQApl2oaapUmXSbZgW0HaFUBo6QZpQLu1UGub+LWHnIy8zNzs/Q0dLTzSYQFxcoDtRMAwiOCCZJDRwDl88kGawZC0YlEOoAGRDnywPx6wNEHnxpJ8N/SvRjdaLEkAOsDiyjwMrRByEe8NHJADAOhIZ0IAgZgFHcIgYY3TAQYqIjMpAhw4xUEXFdxTUXUwLQKAQhKYXIGsl8CHGg/piXa0p4wvgAA5EG8MLMq4esZEiPRRoMMMGU2QKJbthxQ2LiG51wW5NgcACBwQUIFIyGXcu2bdgGGjZ06LBBQ1UoJg5UqHAAKhcTBByN8OukRApHKe5OcYA1TQbCTC6wuoClQeCGIxQjcYBxm5UAKQM8kdyQshUBKQU8CYERwZURKUc88crKNZIJZRlAmIAEdkjZTkhPPtLAppsDd1GHVO2Ec0PPREoodyTAIBHQIUWPHm5EA0btQxoowKgAaJISwtNcsF7ENyvgRCg0Vgq5iYMDISqkoIDEQkoyRZjgXhojQHcHRyHpYwRcAhBAgAB2LeNfSACyNaBgbqngXUPgGLElHSvVZahCA4fRcYFma3GQGwQciAhNEAAh+QQJCQAwACwAAAAAQABAAIUEAgSEgoTEwsRERkTk4uQkIiSkpqRsamwUEhTU0tT08vSUkpRUUlQ0MjS0trQMCgzMyszs6ux8enwcGhzc2tz8+vyMioxMTkysrqw8OjwEBgSEhoTExsRMSkzk5uQkJiSsqqxsbmwUFhTU1tT09vSUlpRUVlQ0NjS8vrwMDgzMzszs7ux8fnwcHhzc3tz8/vz+/v4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG/kCYcEgsGo/IpHLJbDqf0Kh0Sq1ar9hs1sNiebRgowsBACBczJcKA1K9wkxWucxSVgKTOUC0qcCTcnN1SBEnenoZX39iZAApaEcVhod6J35SFSgoJE4EXYpHFpSUAVIqBWUFKlkVIqOHIpdOJHlzE5xXEK+UHFAClChYBruHBlAowMLEesZPtHoiuFa6y2W9UBAtZS2rWK3VsVIkmtJYosuDi1Ekk68n5epPhe4R8VR3rnN8svZTLxAg2vDrR7CgwYMItZAo0eHDhw4l4CVMwgHVoRbXjrygMOLNQQEaXmnISARErQnNCFbQtqsFPBCUUtpbUG0BkRe19EzwaG9A/rUBREa8GkHQIrEWRCgMJcjyKJFvsHjG87kMaMmYBWkus1nEwEmZ9p7tmqBA44gRA/uhCDlq5MQlHJrOaSHgLZOFAwoUGBDRrt+/gAMLhkMiwYiyV0iogCARCwUTbDWYoHBPQmQJjak4eEDpgQMpKxpQarAiCwXOox4QhXLg1YEsDIgxgKKALSUNiKvUXpb5CLVXJKeoqNatCQdiwY2QyH0kAfEnu9syJ0Jiw4dUGxorqNb7SOtRr4+saDeH9BETsqOEHl36yIVXF46MQN15NRQSlstowIzk+K7kMGzW2WdUKAABB90FQEwp8l1g2wX2xfOda0oolkB3YWyw4GBCIfgHHIdCvDdKByAKsd4h5pUIAwkBsNRCdioWoUB7MRoUBAAh+QQJCQAuACwAAAAAQABAAIUEAgSEhoTMzsxMSkykpqQcHhz08vRkYmQUEhSUlpS0trTc3twsLixsbmwMCgzU1tSsrqz8+vycnpyMjoxUUlQkJiRsamwcGhy8vrw0NjR0dnQEBgTU0tSsqqz09vRkZmQUFhScmpy8urzk5uQ0MjR0cnQMDgzc2ty0srT8/vykoqSUkpRUVlQsKiz+/v4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG/kCXcEgsGo8RRWlAaSgix6h0Sp2KKoCstiKqer/fkHasTYDP6KFoQ25303BqBNsmV6DxvBFSr0P0gEMNfW0WgYEDhGQDRwsTFhYTC4dTiYpajEQeB2xjBx6URxaXWoZDHiR9JKChRHykAH9DB4oHcQIlJQJRc6R3Qwukk2gcnRscUSKkb0ITpBNpo6VSCZ11ZkS0l7Zo0lmmUQp0YxUKRtq1aQLGyFNJDUxOeEXOl9DqDbqhJ6QnrYDo6nD7l8cDgz4MWBHMYyBglgMGFh46MeHDhwn+JGrcyLGjx48gO3rg8CBiSDQnWBhjkfFkFQUO2jgwF8UACgUmPz6IWcfB/oMjGBBkQYABJAVFFIwYMDEGQc6NBqz1USjk1RhZHAWQ2kUERRsUHrVe4jpk6RgTTzV6IEVVCAamAEwU/XiUUNIjNlGk5bizj0+XVGDKpAl4yoO6WSj8LOzFgwAObRlLnky5suXLEg2o0FCCwF40KU48SEGwg1AtCDrk6XAhywUCrTr0UZ1GNhnYhwycbuMUdGsyF0gHkqBIApoHfRYDKqGoAcrkhzQoKoEmAog2IIRHSSEiQAAR84wQJ2Qcje0xuKOcaDGmhfIiZuughUPg9+spI66TATEiyvnbeaTwwAPhidLHB1IQsBsACKS3kX7YTWGABLlI8BlBEShSIGUQIO6HmRDekIHgh/lh19+HLjzA3hbvfZiEdwpoh+KMjAUBACH5BAkJACYALAAAAABAAEAAhQQCBISGhMzKzERCRDQyNKSmpOzq7GRiZBQSFHRydJyanNTW1LS2tPz6/Dw6PAwODLSytPTy9GxubBweHHx6fKSipNze3AQGBIyKjMzOzExOTDQ2NKyqrOzu7GRmZBQWFHR2dJyenNza3Ly+vPz+/Dw+PP7+/gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAb+QJNwSCwaj8ikcslsmjoYx+fjwHSc2KyS8QF4vwiGdjxmXL5or5jMXnYQ6TTi2q4bA/F4wM60UDZTGxQWRw55aRt8SSQUhyAkRQ+HaA+KRw0akwAaDUSSmgCVRg0hA1MDCp1ZIKAACUQbrYlFBrGIBlgirV4LQ3ige0QNtnEbqkwSuwASQ2+aD3RDCpoKTgTKBEQMmmtEhpMlTp+tokMMcGkP3UToh+VL46DvQh0BGwgIGwHRkc/W2HW+HQrXJNkuZm2mTarWZIGyXm2GHTKGhRWoV3ZqFcOFBZMmTooaKCiBr0SqMQ0sxgFxzJIiESAI4CMAQoTLmzhz6tzJs6f+z59Ah0SoACJBgQhByXDoAoZD0iwcDjlFIuDAAQFPOzCNM+dIhjMALmRIGkJTiCMe0BxIavAQwiIH1CZNoAljka9exJI1iySDVaxJneV5gPQpk6h5Chh2UqAdAASKFzvpEKJoCH6SM2vezLmz58+gQ7fhsOHCBQeR20SAwKDwzbZf3o4ZgQ7BiJsFDqXOEiFeV0sCEZGBEGcqHxKaIGkhngaCJRJg41xQnkWwF8IuiQknM+LTg9tMBAQIADhJ7sRtOrDGfIRE3C8HWhqB7UV2Twx6lhQofWHDbp8TxDGBaEIgl4d8nwWYxoAEmvALGsEQ6J5aCIYmHnkNZqghgUEBAAAh+QQJCQAnACwAAAAAQABAAIUEAgSEgoRERkTEwsTk4uRkYmQ0MjQUFhRUVlTU1tT08vSkpqQMCgxMTkzMysxsbmz8+vzs6uwcHhxcXlzc3tysrqwEBgSEhoRMSkzExsRkZmQ8OjwcGhxcWlzc2tz09vSsqqwMDgxUUlTMzsx0dnT8/vzs7uz+/v4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG/sCTcEgsGo/IpHLJbA5NjozJSa02RxiAFiAYWb/g08Ky3VoW4TRzxCiXLV613Jh1lwVzJ4RCgCQjdnZTeUkZImQAFiIZRxmBbgOERyUkjyQlRQOPZZFIFCAVHmGVmyRFgJtag0UUAncUVpqpAJ1Drpt4RhQHdgewVHWpGEUOiHZwR7d2uU0fbbMWfkRjx2hGHqkJTtizWqLEylwOSAup1kzc3d9GERlSShWpIE4fxpvRaumB2k7BuHPh7lSRlapWml29flEhZYkQARF31lGBwNANCWmEPIAAwS9MhgaILDQwKEnSHgoYS6pcqRJCSpZzMhTgBeBAAZIwrXzo8AjB/oecXxQYSGVgFdAmCLohODoEhAELFjacE+KoGy2mD+w8IJLU6lKgIB6d42C15tENjwwMKatFQc4SqTCdYAvALcwS9t7IpdntwNGhgdQK4en1aNhA5wjOwrkyq5utXJUyFbLgqQUDU4UIJWp3MhMFXe0gMOqZyYAJZAFwmMC4dBMIP13Lnk27tu3buHPnSYABKoaOYRwUKMBIZYJnWhgAtzIiZBxJ/rQw+6KhTIGSEPImkvulgPWSeI+9pNJcC7KS0bmoGTFhwnNJx8sod10BAYIKTRLcErD86IUyAeiGhAn2WECagCeMYMd7CJ5A4BsHIhgAgA0eUd99FWao4YYcAy4RBAA7OEloRWRqYW9jdzhOTjdUeHV4MTVCcmpRRWxDKzdGSWtiWnV5UUlCY0t5QTlKYmUzU25OM3ArSDd0K3JOMEtOTw=='
if sys.version_info[0] >= 3:
DEFAULT_WINDOW_ICON = DEFAULT_BASE64_ICON
else:
DEFAULT_WINDOW_ICON = 'default_icon.ico'
DEFAULT_ELEMENT_SIZE = (45, 1) # In CHARACTERS
DEFAULT_BUTTON_ELEMENT_SIZE = (10, 1) # In CHARACTERS
DEFAULT_MARGINS = (10, 5) # Margins for each LEFT/RIGHT margin is first term
DEFAULT_ELEMENT_PADDING = (5, 3) # Padding between elements (row, col) in pixels
DEFAULT_AUTOSIZE_TEXT = True
DEFAULT_AUTOSIZE_BUTTONS = True
DEFAULT_FONT = ("Helvetica", 10)
DEFAULT_TEXT_JUSTIFICATION = 'left'
DEFAULT_BORDER_WIDTH = 1
DEFAULT_AUTOCLOSE_TIME = 3 # time in seconds to show an autoclose form
DEFAULT_DEBUG_WINDOW_SIZE = (80, 20)
DEFAULT_WINDOW_LOCATION = (None, None)
MAX_SCROLLED_TEXT_BOX_HEIGHT = 50
DEFAULT_TOOLTIP_TIME = 400
DEFAULT_TOOLTIP_OFFSET = (20,-20)
#################### COLOR STUFF ####################
BLUES = ("#082567", "#0A37A3", "#00345B")
PURPLES = ("#480656", "#4F2398", "#380474")
GREENS = ("#01826B", "#40A860", "#96D2AB", "#00A949", "#003532")
YELLOWS = ("#F3FB62", "#F0F595")
TANS = ("#FFF9D5", "#F4EFCF", "#DDD8BA")
NICE_BUTTON_COLORS = ((GREENS[3], TANS[0]),
('#000000', '#FFFFFF'),
('#FFFFFF', '#000000'),
(YELLOWS[0], PURPLES[1]),
(YELLOWS[0], GREENS[3]),
(YELLOWS[0], BLUES[2]))
COLOR_SYSTEM_DEFAULT = '1234567890' # Colors should never be this long
if sys.platform == 'darwin':
DEFAULT_BUTTON_COLOR = COLOR_SYSTEM_DEFAULT # Foreground, Background (None, None) == System Default
OFFICIAL_PYSIMPLEGUI_BUTTON_COLOR = COLOR_SYSTEM_DEFAULT # Colors should never be this long
else:
DEFAULT_BUTTON_COLOR = ('white', BLUES[0]) # Foreground, Background (None, None) == System Default
OFFICIAL_PYSIMPLEGUI_BUTTON_COLOR = ('white', BLUES[0]) # Colors should never be this long
DEFAULT_ERROR_BUTTON_COLOR = ("#FFFFFF", "#FF0000")
DEFAULT_BACKGROUND_COLOR = None
DEFAULT_ELEMENT_BACKGROUND_COLOR = None
DEFAULT_ELEMENT_TEXT_COLOR = COLOR_SYSTEM_DEFAULT
DEFAULT_TEXT_ELEMENT_BACKGROUND_COLOR = None
DEFAULT_TEXT_COLOR = COLOR_SYSTEM_DEFAULT
DEFAULT_INPUT_ELEMENTS_COLOR = COLOR_SYSTEM_DEFAULT
DEFAULT_INPUT_TEXT_COLOR = COLOR_SYSTEM_DEFAULT
DEFAULT_SCROLLBAR_COLOR = None
# DEFAULT_BUTTON_COLOR = (YELLOWS[0], PURPLES[0]) # (Text, Background) or (Color "on", Color) as a way to remember
# DEFAULT_BUTTON_COLOR = (GREENS[3], TANS[0]) # Foreground, Background (None, None) == System Default
# DEFAULT_BUTTON_COLOR = (YELLOWS[0], GREENS[4]) # Foreground, Background (None, None) == System Default
# DEFAULT_BUTTON_COLOR = ('white', 'black') # Foreground, Background (None, None) == System Default
# DEFAULT_BUTTON_COLOR = (YELLOWS[0], PURPLES[2]) # Foreground, Background (None, None) == System Default
# DEFAULT_PROGRESS_BAR_COLOR = (GREENS[2], GREENS[0]) # a nice green progress bar
# DEFAULT_PROGRESS_BAR_COLOR = (BLUES[1], BLUES[1]) # a nice green progress bar
# DEFAULT_PROGRESS_BAR_COLOR = (BLUES[0], BLUES[0]) # a nice green progress bar
# DEFAULT_PROGRESS_BAR_COLOR = (PURPLES[1],PURPLES[0]) # a nice purple progress bar
# A transparent button is simply one that matches the background
TRANSPARENT_BUTTON = ('#F0F0F0', '#F0F0F0')
# --------------------------------------------------------------------------------
# Progress Bar Relief Choices
RELIEF_RAISED = 'raised'
RELIEF_SUNKEN = 'sunken'
RELIEF_FLAT = 'flat'
RELIEF_RIDGE = 'ridge'
RELIEF_GROOVE = 'groove'
RELIEF_SOLID = 'solid'
DEFAULT_PROGRESS_BAR_COLOR = (GREENS[0], '#D0D0D0') # a nice green progress bar
DEFAULT_PROGRESS_BAR_SIZE = (20, 20) # Size of Progress Bar (characters for length, pixels for width)
DEFAULT_PROGRESS_BAR_BORDER_WIDTH = 1
DEFAULT_PROGRESS_BAR_RELIEF = RELIEF_GROOVE
PROGRESS_BAR_STYLES = ('default', 'winnative', 'clam', 'alt', 'classic', 'vista', 'xpnative')
DEFAULT_PROGRESS_BAR_STYLE = 'default'
DEFAULT_METER_ORIENTATION = 'Horizontal'
DEFAULT_SLIDER_ORIENTATION = 'vertical'
DEFAULT_SLIDER_BORDER_WIDTH = 1
DEFAULT_SLIDER_RELIEF = tk.FLAT
DEFAULT_FRAME_RELIEF = tk.GROOVE
DEFAULT_LISTBOX_SELECT_MODE = tk.SINGLE
SELECT_MODE_MULTIPLE = tk.MULTIPLE
LISTBOX_SELECT_MODE_MULTIPLE = 'multiple'
SELECT_MODE_BROWSE = tk.BROWSE
LISTBOX_SELECT_MODE_BROWSE = 'browse'
SELECT_MODE_EXTENDED = tk.EXTENDED
LISTBOX_SELECT_MODE_EXTENDED = 'extended'
SELECT_MODE_SINGLE = tk.SINGLE
LISTBOX_SELECT_MODE_SINGLE = 'single'
TABLE_SELECT_MODE_NONE = tk.NONE
TABLE_SELECT_MODE_BROWSE = tk.BROWSE
TABLE_SELECT_MODE_EXTENDED = tk.EXTENDED
DEFAULT_TABLE_SECECT_MODE = TABLE_SELECT_MODE_EXTENDED
TITLE_LOCATION_TOP = tk.N
TITLE_LOCATION_BOTTOM = tk.S
TITLE_LOCATION_LEFT = tk.W
TITLE_LOCATION_RIGHT = tk.E
TITLE_LOCATION_TOP_LEFT = tk.NW
TITLE_LOCATION_TOP_RIGHT = tk.NE
TITLE_LOCATION_BOTTOM_LEFT = tk.SW
TITLE_LOCATION_BOTTOM_RIGHT = tk.SE
THEME_DEFAULT = 'default'
THEME_WINNATIVE = 'winnative'
THEME_CLAM = 'clam'
THEME_ALT = 'alt'
THEME_CLASSIC = 'classic'
THEME_VISTA = 'vista'
THEME_XPNATIVE = 'xpnative'
# DEFAULT_METER_ORIENTATION = 'Vertical'
# ----====----====----==== Constants the user should NOT f-with ====----====----====----#
ThisRow = 555666777 # magic number
# DEFAULT_WINDOW_ICON = ''
MESSAGE_BOX_LINE_WIDTH = 60
# "Special" Key Values.. reserved
# Key representing a Read timeout
TIMEOUT_KEY = '__TIMEOUT__'
# Key indicating should not create any return values for element
WRITE_ONLY_KEY = '__WRITE ONLY__'
MENU_DISABLED_CHARACTER = '!'
MENU_KEY_SEPARATOR = '::'
# ====================================================================== #
# One-liner functions that are handy as f_ck #
# ====================================================================== #
def RGB(red, green, blue): return '#%02x%02x%02x' % (red, green, blue)
# ====================================================================== #
# Enums for types #
# ====================================================================== #
# ------------------------- Button types ------------------------- #
# todo Consider removing the Submit, Cancel types... they are just 'RETURN' type in reality
# uncomment this line and indent to go back to using Enums
# class ButtonType(Enum):
BUTTON_TYPE_BROWSE_FOLDER = 1
BUTTON_TYPE_BROWSE_FILE = 2
BUTTON_TYPE_BROWSE_FILES = 21
BUTTON_TYPE_SAVEAS_FILE = 3
BUTTON_TYPE_CLOSES_WIN = 5
BUTTON_TYPE_CLOSES_WIN_ONLY = 6
BUTTON_TYPE_READ_FORM = 7
BUTTON_TYPE_REALTIME = 9
BUTTON_TYPE_CALENDAR_CHOOSER = 30
BUTTON_TYPE_COLOR_CHOOSER = 40
# ------------------------- Element types ------------------------- #
# class ElementType(Enum):
ELEM_TYPE_TEXT = 'text'
ELEM_TYPE_INPUT_TEXT = 'input'
ELEM_TYPE_INPUT_COMBO = 'combo'
ELEM_TYPE_INPUT_OPTION_MENU = 'option menu'
ELEM_TYPE_INPUT_RADIO = 'radio'
ELEM_TYPE_INPUT_MULTILINE = 'multiline'
ELEM_TYPE_INPUT_CHECKBOX = 'checkbox'
ELEM_TYPE_INPUT_SPIN = 'spind'
ELEM_TYPE_BUTTON = 'button'
ELEM_TYPE_IMAGE = 'image'
ELEM_TYPE_CANVAS = 'canvas'
ELEM_TYPE_FRAME = 'frame'
ELEM_TYPE_GRAPH = 'graph'
ELEM_TYPE_TAB = 'tab'
ELEM_TYPE_TAB_GROUP = 'tabgroup'
ELEM_TYPE_INPUT_SLIDER = 'slider'
ELEM_TYPE_INPUT_LISTBOX = 'listbox'
ELEM_TYPE_OUTPUT = 'output'
ELEM_TYPE_COLUMN = 'column'
ELEM_TYPE_MENUBAR = 'menubar'
ELEM_TYPE_PROGRESS_BAR = 'progressbar'
ELEM_TYPE_BLANK = 'blank'
ELEM_TYPE_TABLE = 'table'
ELEM_TYPE_TREE = 'tree'
ELEM_TYPE_ERROR = 'error'
ELEM_TYPE_SEPARATOR = 'separator'
ELEM_TYPE_STATUSBAR = 'statusbar'
ELEM_TYPE_PANE = 'pane'
ELEM_TYPE_BUTTONMENU = 'buttonmenu'
# STRETCH == ERROR ELEMENT as a filler
# ------------------------- Popup Buttons Types ------------------------- #
POPUP_BUTTONS_YES_NO = 1
POPUP_BUTTONS_CANCELLED = 2
POPUP_BUTTONS_ERROR = 3
POPUP_BUTTONS_OK_CANCEL = 4
POPUP_BUTTONS_OK = 0
POPUP_BUTTONS_NO_BUTTONS = 5
# ------------------------------------------------------------------------- #
# ToolTip used by the Elements #
# ------------------------------------------------------------------------- #
class ToolTip:
""" Create a tooltip for a given widget
(inspired by https://stackoverflow.com/a/36221216)
"""
def __init__(self, widget, text, timeout=DEFAULT_TOOLTIP_TIME):
self.widget = widget
self.text = text
self.timeout = timeout
# self.wraplength = wraplength if wraplength else widget.winfo_screenwidth() // 2
self.tipwindow = None
self.id = None
self.x = self.y = 0
self.widget.bind("<Enter>", self.enter)
self.widget.bind("<Leave>", self.leave)
self.widget.bind("<ButtonPress>", self.leave)
def enter(self, event=None):
self.schedule()
def leave(self, event=None):
self.unschedule()
self.hidetip()
def schedule(self):
self.unschedule()
self.id = self.widget.after(self.timeout, self.showtip)
def unschedule(self):
if self.id:
self.widget.after_cancel(self.id)
self.id = None
def showtip(self):
if self.tipwindow:
return
x = self.widget.winfo_rootx() + DEFAULT_TOOLTIP_OFFSET[0]
y = self.widget.winfo_rooty() + self.widget.winfo_height() + DEFAULT_TOOLTIP_OFFSET[1]
self.tipwindow = tk.Toplevel(self.widget)
self.tipwindow.wm_overrideredirect(True)
self.tipwindow.wm_geometry("+%d+%d" % (x, y))
self.tipwindow.wm_attributes("-topmost", 1)
label = ttk.Label(self.tipwindow, text=self.text, justify=tk.LEFT,
background="#ffffe0", relief=tk.SOLID, borderwidth=1)
label.pack()
def hidetip(self):
if self.tipwindow:
self.tipwindow.destroy()
self.tipwindow = None
# ---------------------------------------------------------------------- #
# Cascading structure.... Objects get larger #
# Button #
# Element #
# Row #
# Form #
# ---------------------------------------------------------------------- #
# ------------------------------------------------------------------------- #
# Element CLASS #
# ------------------------------------------------------------------------- #
class Element():
def __init__(self, type, size=(None, None), auto_size_text=None, font=None, background_color=None, text_color=None, key=None, pad=None, tooltip=None, visible=True):
'''
Element
:param type:
:param size:
:param auto_size_text:
:param font:
:param background_color:
:param text_color:
:param key:
:param pad:
:param tooltip:
:param visible:
'''
self.Size = size
self.Type = type
self.AutoSizeText = auto_size_text
self.Pad = pad
self.Font = font
self.TKStringVar = None
self.TKIntVar = None
self.TKText = None
self.TKEntry = None
self.TKImage = None
self.ParentForm = None # type: Window
self.ParentContainer = None # will be a Form, Column, or Frame element
self.TextInputDefault = None
self.Position = (0, 0) # Default position Row 0, Col 0
self.BackgroundColor = background_color if background_color is not None else DEFAULT_ELEMENT_BACKGROUND_COLOR
self.TextColor = text_color if text_color is not None else DEFAULT_ELEMENT_TEXT_COLOR
self.Key = key # dictionary key for return values
self.Tooltip = tooltip
self.TooltipObject = None
self.Visible = visible
self.TKRightClickMenu = None
def RightClickMenuCallback(self, event):
self.TKRightClickMenu.tk_popup(event.x_root, event.y_root, 0)
self.TKRightClickMenu.grab_release()
def MenuItemChosenCallback(self, item_chosen): # TEXT Menu item callback
# print('IN MENU ITEM CALLBACK', item_chosen)
self.MenuItemChosen = item_chosen.replace('&','')
self.ParentForm.LastButtonClicked = self.MenuItemChosen
self.ParentForm.FormRemainedOpen = True
if self.ParentForm.CurrentlyRunningMainloop:
self.ParentForm.TKroot.quit() # kick the users out of the mainloop
def FindReturnKeyBoundButton(self, form):
for row in form.Rows:
for element in row:
if element.Type == ELEM_TYPE_BUTTON:
if element.BindReturnKey:
return element
if element.Type == ELEM_TYPE_COLUMN:
rc = self.FindReturnKeyBoundButton(element)
if rc is not None:
return rc
if element.Type == ELEM_TYPE_FRAME:
rc = self.FindReturnKeyBoundButton(element)
if rc is not None:
return rc
if element.Type == ELEM_TYPE_TAB_GROUP:
rc = self.FindReturnKeyBoundButton(element)
if rc is not None:
return rc
if element.Type == ELEM_TYPE_TAB:
rc = self.FindReturnKeyBoundButton(element)
if rc is not None:
return rc
return None
def TextClickedHandler(self, event):
if self.Key is not None:
self.ParentForm.LastButtonClicked = self.Key
else:
self.ParentForm.LastButtonClicked = self.DisplayText
self.ParentForm.FormRemainedOpen = True
if self.ParentForm.CurrentlyRunningMainloop:
self.ParentForm.TKroot.quit() # kick the users out of the mainloop
def ReturnKeyHandler(self, event):
MyForm = self.ParentForm
button_element = self.FindReturnKeyBoundButton(MyForm)
if button_element is not None:
button_element.ButtonCallBack()
def ListboxSelectHandler(self, event):
# first, get the results table built
# modify the Results table in the parent FlexForm object
if self.Key is not None:
self.ParentForm.LastButtonClicked = self.Key
else:
self.ParentForm.LastButtonClicked = ''
self.ParentForm.FormRemainedOpen = True
if self.ParentForm.CurrentlyRunningMainloop:
self.ParentForm.TKroot.quit() # kick the users out of the mainloop
def ComboboxSelectHandler(self, event):
# first, get the results table built
# modify the Results table in the parent FlexForm object
if self.Key is not None:
self.ParentForm.LastButtonClicked = self.Key
else:
self.ParentForm.LastButtonClicked = ''
self.ParentForm.FormRemainedOpen = True
if self.ParentForm.CurrentlyRunningMainloop:
self.ParentForm.TKroot.quit() # kick the users out of the mainloop
def RadioHandler(self):
if self.Key is not None:
self.ParentForm.LastButtonClicked = self.Key
else:
self.ParentForm.LastButtonClicked = ''
self.ParentForm.FormRemainedOpen = True
if self.ParentForm.CurrentlyRunningMainloop:
self.ParentForm.TKroot.quit()
def CheckboxHandler(self):
if self.Key is not None:
self.ParentForm.LastButtonClicked = self.Key
else:
self.ParentForm.LastButtonClicked = ''
self.ParentForm.FormRemainedOpen = True
if self.ParentForm.CurrentlyRunningMainloop:
self.ParentForm.TKroot.quit()
def TabGroupSelectHandler(self, event):
if self.Key is not None:
self.ParentForm.LastButtonClicked = self.Key
else:
self.ParentForm.LastButtonClicked = ''
self.ParentForm.FormRemainedOpen = True
if self.ParentForm.CurrentlyRunningMainloop:
self.ParentForm.TKroot.quit()
def KeyboardHandler(self, event):
if self.Key is not None:
self.ParentForm.LastButtonClicked = self.Key
else:
self.ParentForm.LastButtonClicked = ''
self.ParentForm.FormRemainedOpen = True
if self.ParentForm.CurrentlyRunningMainloop:
self.ParentForm.TKroot.quit()
def ClickHandler(self, event):
if self.Key is not None:
self.ParentForm.LastButtonClicked = self.Key
else:
self.ParentForm.LastButtonClicked = ''
self.ParentForm.FormRemainedOpen = True
if self.ParentForm.CurrentlyRunningMainloop:
self.ParentForm.TKroot.quit()
def __del__(self):
try:
self.TKStringVar.__del__()
except:
pass
try:
self.TKIntVar.__del__()
except:
pass
try:
self.TKText.__del__()
except:
pass
try:
self.TKEntry.__del__()
except:
pass
# ---------------------------------------------------------------------- #
# Input Class #
# ---------------------------------------------------------------------- #
class InputText(Element):
def __init__(self, default_text='', size=(None, None), disabled=False, password_char='',
justification=None, background_color=None, text_color=None, font=None, tooltip=None,
change_submits=False, enable_events=False, do_not_clear=False, key=None, focus=False, pad=None, right_click_menu=None, visible=True):
'''
InputText
:param default_text:
:param size:
:param disabled:
:param password_char:
:param justification:
:param background_color:
:param text_color:
:param font:
:param tooltip:
:param change_submits:
:param enable_events:
:param do_not_clear:
:param key:
:param focus:
:param pad:
:param right_click_menu:
:param visible:
'''
self.DefaultText = default_text
self.PasswordCharacter = password_char
bg = background_color if background_color is not None else DEFAULT_INPUT_ELEMENTS_COLOR
fg = text_color if text_color is not None else DEFAULT_INPUT_TEXT_COLOR
self.Focus = focus
self.do_not_clear = do_not_clear
self.Justification = justification
self.Disabled = disabled
self.ChangeSubmits = change_submits or enable_events
self.RightClickMenu = right_click_menu
super().__init__(ELEM_TYPE_INPUT_TEXT, size=size, background_color=bg, text_color=fg, key=key, pad=pad,
font=font, tooltip=tooltip, visible=visible)
def Update(self, value=None, disabled=None, select=None, visible=None):
if disabled is True:
self.TKEntry['state'] = 'readonly'
elif disabled is False:
self.TKEntry['state'] = 'normal'
if value is not None:
try:
self.TKStringVar.set(value)
except:
pass
self.DefaultText = value
if select:
self.TKEntry.select_range(0, 'end')
if visible is False:
self.TKEntry.pack_forget()
elif visible is True:
self.TKEntry.pack()
def Get(self):
try:
text = self.TKStringVar.get()
except:
text = ''
return text
def SetFocus(self):
try:
self.TKEntry.focus_set()
except:
pass
def __del__(self):
super().__del__()
# ------------------------- INPUT TEXT Element lazy functions ------------------------- #
In = InputText
Input = InputText
# ---------------------------------------------------------------------- #
# Combo #
# ---------------------------------------------------------------------- #
class Combo(Element):
def __init__(self, values, default_value=None, size=(None, None), auto_size_text=None, background_color=None,
text_color=None, change_submits=False, enable_events=False, disabled=False, key=None, pad=None, tooltip=None, readonly=False, font=None, visible=True):
'''
Combo
:param values:
:param default_value:
:param size:
:param auto_size_text:
:param background_color:
:param text_color:
:param change_submits:
:param enable_events:
:param disabled:
:param key:
:param pad:
:param tooltip:
:param readonly:
:param font:
:param visible:
'''
self.Values = values
self.DefaultValue = default_value
self.ChangeSubmits = change_submits or enable_events
self.TKCombo = None
# self.InitializeAsDisabled = disabled
self.Disabled = disabled
self.Readonly = readonly
bg = background_color if background_color else DEFAULT_INPUT_ELEMENTS_COLOR
fg = text_color if text_color is not None else DEFAULT_INPUT_TEXT_COLOR
super().__init__(ELEM_TYPE_INPUT_COMBO, size=size, auto_size_text=auto_size_text, background_color=bg,
text_color=fg, key=key, pad=pad, tooltip=tooltip, font=font or DEFAULT_FONT, visible=visible)
def Update(self, value=None, values=None, set_to_index=None, disabled=None, readonly=None, font=None, visible=None):
if values is not None:
try:
self.TKCombo['values'] = values
self.TKCombo.current(0)
except:
pass
self.Values = values
if value is not None:
for index, v in enumerate(self.Values):
if v == value:
try:
self.TKCombo.current(index)
except:
pass
self.DefaultValue = value
break
if set_to_index is not None:
try:
self.TKCombo.current(set_to_index)
self.DefaultValue = self.Values[set_to_index]
except:
pass
if disabled == True:
self.TKCombo['state'] = 'disable'
elif disabled == False:
self.TKCombo['state'] = 'enable'
if readonly is not None:
self.Readonly = readonly
if self.Readonly:
self.TKCombo['state'] = 'readonly'
if font is not None:
self.TKCombo.configure(font=font)
if visible is False:
self.TKCombo.pack_forget()
elif visible is True:
self.TKCombo.pack()
def __del__(self):
try:
self.TKCombo.__del__()
except:
pass
super().__del__()
# ------------------------- INPUT COMBO Element lazy functions ------------------------- #
InputCombo = Combo
DropDown = InputCombo
Drop = InputCombo
# ---------------------------------------------------------------------- #
# Option Menu #
# ---------------------------------------------------------------------- #
class OptionMenu(Element):
def __init__(self, values, default_value=None, size=(None, None), disabled=False, auto_size_text=None,
background_color=None, text_color=None, key=None, pad=None, tooltip=None, visible=True):
'''
OptionMenu
:param values:
:param default_value:
:param size:
:param disabled:
:param auto_size_text:
:param background_color:
:param text_color:
:param key:
:param pad:
:param tooltip:
:param visible:
'''
self.Values = values
self.DefaultValue = default_value
self.TKOptionMenu = None
self.Disabled = disabled
bg = background_color if background_color else DEFAULT_INPUT_ELEMENTS_COLOR
fg = text_color if text_color is not None else DEFAULT_INPUT_TEXT_COLOR
super().__init__(ELEM_TYPE_INPUT_OPTION_MENU, size=size, auto_size_text=auto_size_text, background_color=bg,
text_color=fg, key=key, pad=pad, tooltip=tooltip, visible=visible)
def Update(self, value=None, values=None, disabled=None, visible=None):
if values is not None:
self.Values = values
if self.Values is not None:
for index, v in enumerate(self.Values):
if v == value:
try:
self.TKStringVar.set(value)
except:
pass
self.DefaultValue = value
break
if disabled == True:
self.TKOptionMenu['state'] = 'disabled'
elif disabled == False:
self.TKOptionMenu['state'] = 'normal'
if visible is False:
self.TKOptionMenu.pack_forget()
elif visible is True:
self.TKOptionMenu.pack()
def __del__(self):
try:
self.TKOptionMenu.__del__()
except:
pass
super().__del__()
# ------------------------- OPTION MENU Element lazy functions ------------------------- #
InputOptionMenu = OptionMenu
# ---------------------------------------------------------------------- #
# Listbox #
# ---------------------------------------------------------------------- #
class Listbox(Element):
def __init__(self, values, default_values=None, select_mode=None, change_submits=False,enable_events=False, bind_return_key=False, size=(None, None), disabled=False, auto_size_text=None, font=None, background_color=None, text_color=None, key=None, pad=None, tooltip=None, right_click_menu=None, visible=True):
'''
Listbox
:param values:
:param default_values:
:param select_mode:
:param change_submits:
:param enable_events:
:param bind_return_key:
:param size:
:param disabled:
:param auto_size_text:
:param font:
:param background_color:
:param text_color:
:param key:
:param pad:
:param tooltip:
:param right_click_menu:
:param visible:
'''
self.Values = values
self.DefaultValues = default_values
self.TKListbox = None
self.ChangeSubmits = change_submits or enable_events
self.BindReturnKey = bind_return_key
self.Disabled = disabled
if select_mode == LISTBOX_SELECT_MODE_BROWSE:
self.SelectMode = SELECT_MODE_BROWSE
elif select_mode == LISTBOX_SELECT_MODE_EXTENDED:
self.SelectMode = SELECT_MODE_EXTENDED
elif select_mode == LISTBOX_SELECT_MODE_MULTIPLE:
self.SelectMode = SELECT_MODE_MULTIPLE
elif select_mode == LISTBOX_SELECT_MODE_SINGLE:
self.SelectMode = SELECT_MODE_SINGLE
else:
self.SelectMode = DEFAULT_LISTBOX_SELECT_MODE
bg = background_color if background_color else DEFAULT_INPUT_ELEMENTS_COLOR
fg = text_color if text_color is not None else DEFAULT_INPUT_TEXT_COLOR
self.RightClickMenu = right_click_menu
super().__init__(ELEM_TYPE_INPUT_LISTBOX, size=size, auto_size_text=auto_size_text, font=font,
background_color=bg, text_color=fg, key=key, pad=pad, tooltip=tooltip, visible=visible)
def Update(self, values=None, disabled=None, set_to_index=None, visible=None):
if disabled == True:
self.TKListbox.configure(state='disabled')
elif disabled == False:
self.TKListbox.configure(state='normal')
if values is not None:
self.TKListbox.delete(0, 'end')
for item in values:
self.TKListbox.insert(tk.END, item)
self.TKListbox.selection_set(0, 0)
self.Values = values
if set_to_index is not None:
self.TKListbox.selection_clear(0)
try:
self.TKListbox.selection_set(set_to_index, set_to_index)
except:
pass
if visible is False:
self.TKListbox.pack_forget()
elif visible is True:
self.TKListbox.pack()
def SetValue(self, values):
for index, item in enumerate(self.Values):
try:
if item in values:
self.TKListbox.selection_set(index)
else:
self.TKListbox.selection_clear(index)
except:
pass
self.DefaultValues = values
def GetListValues(self):
return self.Values
def SetFocus(self):
try:
self.TKListbox.focus_set()
except:
pass
def __del__(self):
try:
self.TKListBox.__del__()
except:
pass
super().__del__()
# ---------------------------------------------------------------------- #
# Radio #
# ---------------------------------------------------------------------- #
class Radio(Element):
def __init__(self, text, group_id, default=False, disabled=False, size=(None, None), auto_size_text=None,
background_color=None, text_color=None, font=None, key=None, pad=None, tooltip=None, change_submits=False, enable_events=False, visible=True):
'''
Radio
:param text:
:param group_id:
:param default:
:param disabled:
:param size:
:param auto_size_text:
:param background_color:
:param text_color:
:param font:
:param key:
:param pad:
:param tooltip:
:param change_submits:
:param enable_events:
:param visible:
'''
self.InitialState = default
self.Text = text
self.TKRadio = None
self.GroupID = group_id
self.Value = None
self.Disabled = disabled
self.TextColor = text_color or DEFAULT_TEXT_COLOR
self.ChangeSubmits = change_submits or enable_events
super().__init__(ELEM_TYPE_INPUT_RADIO, size=size, auto_size_text=auto_size_text, font=font,
background_color=background_color, text_color=self.TextColor, key=key, pad=pad,
tooltip=tooltip, visible=visible)
def Update(self, value=None, disabled=None, visible=None):
location = EncodeRadioRowCol(self.Position[0], self.Position[1])
if value is not None:
try:
self.TKIntVar.set(location)
except:
pass
self.InitialState = value
if disabled == True:
self.TKRadio['state'] = 'disabled'
elif disabled == False:
self.TKRadio['state'] = 'normal'
if visible is False:
self.TKRadio.pack_forget()
elif visible is True:
self.TKRadio.pack()
def __del__(self):
try:
self.TKRadio.__del__()
except:
pass
super().__del__()
# ---------------------------------------------------------------------- #
# Checkbox #
# ---------------------------------------------------------------------- #
class Checkbox(Element):
def __init__(self, text, default=False, size=(None, None), auto_size_text=None, font=None, background_color=None, text_color=None, change_submits=False,enable_events=False, disabled=False, key=None, pad=None, tooltip=None, visible=True):
'''
Checkbox
:param text:
:param default:
:param size:
:param auto_size_text:
:param font:
:param background_color:
:param text_color:
:param change_submits:
:param enable_events:
:param disabled:
:param key:
:param pad:
:param tooltip:
:param visible:
'''
self.Text = text
self.InitialState = default
self.Value = None
self.TKCheckbutton = None
self.Disabled = disabled
self.TextColor = text_color if text_color else DEFAULT_TEXT_COLOR
self.ChangeSubmits = change_submits or enable_events
super().__init__(ELEM_TYPE_INPUT_CHECKBOX, size=size, auto_size_text=auto_size_text, font=font,
background_color=background_color, text_color=self.TextColor, key=key, pad=pad,
tooltip=tooltip, visible=visible)
def Get(self):
return self.TKIntVar.get()
def Update(self, value=None, disabled=None, visible=None):
if value is not None:
try:
self.TKIntVar.set(value)
self.InitialState = value
except:
pass
if disabled == True:
self.TKCheckbutton.configure(state='disabled')
elif disabled == False:
self.TKCheckbutton.configure(state='normal')
if visible is False:
self.TKCheckbutton.pack_forget()
elif visible is True:
self.TKCheckbutton.pack()
def __del__(self):
super().__del__()
# ------------------------- CHECKBOX Element lazy functions ------------------------- #
CB = Checkbox
CBox = Checkbox
Check = Checkbox
# ---------------------------------------------------------------------- #
# Spin #
# ---------------------------------------------------------------------- #
class Spin(Element):
# Values = None
# TKSpinBox = None
def __init__(self, values, initial_value=None, disabled=False, change_submits=False,enable_events=False , size=(None, None), auto_size_text=None, font=None, background_color=None, text_color=None, key=None, pad=None, tooltip=None, visible=True):
'''
Spin
:param values:
:param initial_value:
:param disabled:
:param change_submits:
:param enable_events:
:param size:
:param auto_size_text:
:param font:
:param background_color:
:param text_color:
:param key:
:param pad:
:param tooltip:
:param visible:
'''
self.Values = values
self.DefaultValue = initial_value
self.ChangeSubmits = change_submits or enable_events
self.TKSpinBox = None
self.Disabled = disabled
bg = background_color if background_color else DEFAULT_INPUT_ELEMENTS_COLOR
fg = text_color if text_color is not None else DEFAULT_INPUT_TEXT_COLOR
super().__init__(ELEM_TYPE_INPUT_SPIN, size, auto_size_text, font=font, background_color=bg, text_color=fg,
key=key, pad=pad, tooltip=tooltip, visible=visible)
return
def Update(self, value=None, values=None, disabled=None, visible=None):
if values != None:
old_value = self.TKStringVar.get()
self.Values = values
self.TKSpinBox.configure(values=values)
self.TKStringVar.set(old_value)
if value is not None:
try:
self.TKStringVar.set(value)
except:
pass
self.DefaultValue = value
if disabled == True:
self.TKSpinBox.configure(state='disabled')
elif disabled == False:
self.TKSpinBox.configure(state='normal')
if visible is False:
self.TKSpinBox.pack_forget()
elif visible is True:
self.TKSpinBox.pack()
def SpinChangedHandler(self, event):
# first, get the results table built
# modify the Results table in the parent FlexForm object
if self.Key is not None:
self.ParentForm.LastButtonClicked = self.Key
else:
self.ParentForm.LastButtonClicked = ''
self.ParentForm.FormRemainedOpen = True
if self.ParentForm.CurrentlyRunningMainloop:
self.ParentForm.TKroot.quit() # kick the users out of the mainloop
def Get(self):
return self.TKStringVar.get()
def __del__(self):
try:
self.TKSpinBox.__del__()
except:
pass
super().__del__()
# ---------------------------------------------------------------------- #
# Multiline #
# ---------------------------------------------------------------------- #
class Multiline(Element):
def __init__(self, default_text='', enter_submits=False, disabled=False, autoscroll=False, size=(None, None),
auto_size_text=None, background_color=None, text_color=None, change_submits=False, enable_events=False,do_not_clear=False, key=None, focus=False, font=None, pad=None, tooltip=None, right_click_menu=None, visible=True):
'''
Multiline
:param default_text:
:param enter_submits:
:param disabled:
:param autoscroll:
:param size:
:param auto_size_text:
:param background_color:
:param text_color:
:param change_submits:
:param enable_events:
:param do_not_clear:
:param key:
:param focus:
:param font:
:param pad:
:param tooltip:
:param right_click_menu:
:param visible:
'''
self.DefaultText = default_text
self.EnterSubmits = enter_submits
bg = background_color if background_color else DEFAULT_INPUT_ELEMENTS_COLOR
self.Focus = focus
self.do_not_clear = do_not_clear
fg = text_color if text_color is not None else DEFAULT_INPUT_TEXT_COLOR
self.Autoscroll = autoscroll
self.Disabled = disabled
self.ChangeSubmits = change_submits or enable_events
self.RightClickMenu = right_click_menu
super().__init__(ELEM_TYPE_INPUT_MULTILINE, size=size, auto_size_text=auto_size_text, background_color=bg,
text_color=fg, key=key, pad=pad, tooltip=tooltip, font=font or DEFAULT_FONT, visible=visible)
return
def Update(self, value=None, disabled=None, append=False, font=None, text_color=None, background_color=None, visible=None):
if value is not None:
try:
if not append:
self.TKText.delete('1.0', tk.END)
self.TKText.insert(tk.END, value)
except:
pass
self.DefaultText = value
if self.Autoscroll:
self.TKText.see(tk.END)
if disabled == True:
self.TKText.configure(state='disabled')
elif disabled == False:
self.TKText.configure(state='normal')
if background_color is not None and background_color != COLOR_SYSTEM_DEFAULT:
self.TKText.configure(background=background_color)
if text_color is not None and text_color != COLOR_SYSTEM_DEFAULT:
self.TKText.configure(fg=text_color)
if font is not None:
self.TKText.configure(font=font)
if visible is False:
self.TKText.pack_forget()
elif visible is True:
self.TKText.pack()
def Get(self):
return self.TKText.get(1.0, tk.END)
def SetFocus(self):
try:
self.TKText.focus_set()
except:
pass
def __del__(self):
super().__del__()
# ---------------------------------------------------------------------- #
# Text #
# ---------------------------------------------------------------------- #
class Text(Element):
def __init__(self, text, size=(None, None), auto_size_text=None, click_submits=False, enable_events=False, relief=None, font=None, text_color=None, background_color=None, justification=None, pad=None, key=None, right_click_menu=None, tooltip=None, visible=True):
'''
Text
:param text:
:param size:
:param auto_size_text:
:param click_submits:
:param enable_events:
:param relief:
:param font:
:param text_color:
:param background_color:
:param justification:
:param pad:
:param key:
:param right_click_menu:
:param tooltip:
:param visible:
'''
self.DisplayText = text
self.TextColor = text_color if text_color else DEFAULT_TEXT_COLOR
self.Justification = justification
self.Relief = relief
self.ClickSubmits = click_submits or enable_events
if background_color is None:
bg = DEFAULT_TEXT_ELEMENT_BACKGROUND_COLOR
else:
bg = background_color
self.RightClickMenu = right_click_menu
self.TKRightClickMenu = None
super().__init__(ELEM_TYPE_TEXT, size, auto_size_text, background_color=bg, font=font if font else DEFAULT_FONT,
text_color=self.TextColor, pad=pad, key=key, tooltip=tooltip, visible=visible)
return
def Update(self, value=None, background_color=None, text_color=None, font=None, visible=None):
if value is not None:
self.DisplayText = value
stringvar = self.TKStringVar
stringvar.set(value)
if background_color is not None and background_color != COLOR_SYSTEM_DEFAULT:
self.TKText.configure(background=background_color)
if text_color is not None and text_color != COLOR_SYSTEM_DEFAULT:
self.TKText.configure(fg=text_color)
if font is not None:
self.TKText.configure(font=font)
if visible is False:
self.TKText.pack_forget()
elif visible is True:
self.TKText.pack()
def __del__(self):
super().__del__()
# ------------------------- Text Element lazy functions ------------------------- #
Txt = Text
T = Text
# ---------------------------------------------------------------------- #
# StatusBar #
# ---------------------------------------------------------------------- #
class StatusBar(Element):
def __init__(self, text, size=(None, None), auto_size_text=None, click_submits=None, enable_events=False, relief=RELIEF_SUNKEN, font=None, text_color=None, background_color=None, justification=None, pad=None, key=None, tooltip=None, visible=True):
'''
StatusBar
:param text:
:param size:
:param auto_size_text:
:param click_submits:
:param enable_events:
:param relief:
:param font:
:param text_color:
:param background_color:
:param justification:
:param pad:
:param key:
:param tooltip:
:param visible:
'''
self.DisplayText = text
self.TextColor = text_color if text_color else DEFAULT_TEXT_COLOR
self.Justification = justification
self.Relief = relief
self.ClickSubmits = click_submits or enable_events
if background_color is None:
bg = DEFAULT_TEXT_ELEMENT_BACKGROUND_COLOR
else:
bg = background_color
super().__init__(ELEM_TYPE_STATUSBAR, size=size, auto_size_text=auto_size_text, background_color=bg, font=font or DEFAULT_FONT, text_color=self.TextColor, pad=pad, key=key, tooltip=tooltip, visible=visible)
return
def Update(self, value=None, background_color=None, text_color=None, font=None, visible=None):
if value is not None:
self.DisplayText = value
stringvar = self.TKStringVar
stringvar.set(value)
if background_color is not None and background_color != COLOR_SYSTEM_DEFAULT:
self.TKText.configure(background=background_color)
if text_color is not None and text_color != COLOR_SYSTEM_DEFAULT:
self.TKText.configure(fg=text_color)
if font is not None:
self.TKText.configure(font=font)
if visible is False:
self.TKText.pack_forget()
elif visible is True:
self.TKText.pack()
def __del__(self):
super().__del__()
# ---------------------------------------------------------------------- #
# TKProgressBar #
# Emulate the TK ProgressBar using canvas and rectangles
# ---------------------------------------------------------------------- #
class TKProgressBar():
def __init__(self, root, max, length=400, width=DEFAULT_PROGRESS_BAR_SIZE[1], style=DEFAULT_PROGRESS_BAR_STYLE,
relief=DEFAULT_PROGRESS_BAR_RELIEF, border_width=DEFAULT_PROGRESS_BAR_BORDER_WIDTH,
orientation='horizontal', BarColor=(None, None), key=None):
self.Length = length
self.Width = width
self.Max = max
self.Orientation = orientation
self.Count = None
self.PriorCount = 0
if orientation[0].lower() == 'h':
s = ttk.Style()
s.theme_use(style)
if BarColor != COLOR_SYSTEM_DEFAULT:
s.configure(str(key) + "my.Horizontal.TProgressbar", background=BarColor[0], troughcolor=BarColor[1],
troughrelief=relief, borderwidth=border_width, thickness=width)
else:
s.configure(str(key) + "my.Horizontal.TProgressbar", troughrelief=relief, borderwidth=border_width,
thickness=width)
self.TKProgressBarForReal = ttk.Progressbar(root, maximum=self.Max,
style=str(key) + 'my.Horizontal.TProgressbar', length=length,
orient=tk.HORIZONTAL, mode='determinate')
else:
s = ttk.Style()
s.theme_use(style)
if BarColor != COLOR_SYSTEM_DEFAULT:
s.configure(str(length) + str(width) + "my.Vertical.TProgressbar", background=BarColor[0],
troughcolor=BarColor[1], troughrelief=relief, borderwidth=border_width, thickness=width)
else:
s.configure(str(length) + str(width) + "my.Vertical.TProgressbar", troughrelief=relief,
borderwidth=border_width, thickness=width)
self.TKProgressBarForReal = ttk.Progressbar(root, maximum=self.Max,
style=str(length) + str(width) + 'my.Vertical.TProgressbar',
length=length, orient=tk.VERTICAL, mode='determinate')
def Update(self, count=None, max=None):
if max is not None:
self.Max = max
try:
self.TKProgressBarForReal.config(maximum=max)
except:
return False
if count is not None and count > self.Max: return False
if count is not None:
try:
self.TKProgressBarForReal['value'] = count
except:
return False
return True
def __del__(self):
try:
self.TKProgressBarForReal.__del__()
except:
pass
# ---------------------------------------------------------------------- #
# TKOutput #
# New Type of TK Widget that's a Text Widget in disguise #
# Note that it's inherited from the TKFrame class so that the #
# Scroll bar will span the length of the frame #
# ---------------------------------------------------------------------- #
class TKOutput(tk.Frame):
def __init__(self, parent, width, height, bd, background_color=None, text_color=None, font=None, pad=None):
self.frame = tk.Frame(parent)
tk.Frame.__init__(self, self.frame)
self.output = tk.Text(self.frame, width=width, height=height, bd=bd, font=font)
if background_color and background_color != COLOR_SYSTEM_DEFAULT:
self.output.configure(background=background_color)
self.frame.configure(background=background_color)
if text_color and text_color != COLOR_SYSTEM_DEFAULT:
self.output.configure(fg=text_color)
self.vsb = tk.Scrollbar(self.frame, orient="vertical", command=self.output.yview)
self.output.configure(yscrollcommand=self.vsb.set)
self.output.pack(side="left", fill="both", expand=True)
self.vsb.pack(side="left", fill="y", expand=False)
self.frame.pack(side="left", padx=pad[0], pady=pad[1], expand=True, fill='y')
self.previous_stdout = sys.stdout
self.previous_stderr = sys.stderr
sys.stdout = self
sys.stderr = self
self.pack()
def write(self, txt):
try:
self.output.insert(tk.END, str(txt))
self.output.see(tk.END)
except:
pass
def Close(self):
sys.stdout = self.previous_stdout
sys.stderr = self.previous_stderr
def flush(self):
sys.stdout = self.previous_stdout
sys.stderr = self.previous_stderr
def __del__(self):
sys.stdout = self.previous_stdout
sys.stderr = self.previous_stderr
# ---------------------------------------------------------------------- #
# Output #
# Routes stdout, stderr to a scrolled window #
# ---------------------------------------------------------------------- #
class Output(Element):
def __init__(self, size=(None, None), background_color=None, text_color=None, pad=None, font=None, tooltip=None,
key=None, right_click_menu=None, visible=True):
'''
Output
:param size:
:param background_color:
:param text_color:
:param pad:
:param font:
:param tooltip:
:param key:
:param right_click_menu:
:param visible:
'''
self._TKOut = None
bg = background_color if background_color else DEFAULT_INPUT_ELEMENTS_COLOR
fg = text_color if text_color is not None else DEFAULT_INPUT_TEXT_COLOR
self.RightClickMenu = right_click_menu
super().__init__(ELEM_TYPE_OUTPUT, size=size, background_color=bg, text_color=fg, pad=pad, font=font,
tooltip=tooltip, key=key, visible=visible)
@property
def TKOut(self):
if self._TKOut is None:
print('*** Did you forget to call Finalize()? Your code should look something like: ***')
print('*** form = sg.Window("My Form").Layout(layout).Finalize() ***')
return self._TKOut
def Update(self, value=None, visible=None):
if value is not None:
self._TKOut.output.delete('1.0', tk.END)
self._TKOut.output.insert(tk.END, value)
if visible is False:
self._TKOut.frame.pack_forget()
elif visible is True:
self._TKOut.frame.pack()
def __del__(self):
try:
self._TKOut.__del__()
except:
pass
super().__del__()
# ---------------------------------------------------------------------- #
# Button Class #
# ---------------------------------------------------------------------- #
class Button(Element):
def __init__(self, button_text='', button_type=BUTTON_TYPE_READ_FORM, target=(None, None), tooltip=None,
file_types=(("ALL Files", "*.*"),), initial_folder=None, disabled=False, change_submits=False, enable_events=False, image_filename=None, image_data=None, image_size=(None, None), image_subsample=None, border_width=None, size=(None, None), auto_size_button=None, button_color=None, font=None, bind_return_key=False, focus=False, pad=None, key=None, visible=True):
'''
Button
:param button_text:
:param button_type:
:param target:
:param tooltip:
:param file_types:
:param initial_folder:
:param disabled:
:param change_submits:
:param enable_events:
:param image_filename:
:param image_data:
:param image_size:
:param image_subsample:
:param border_width:
:param size:
:param auto_size_button:
:param button_color:
:param font:
:param bind_return_key:
:param focus:
:param pad:
:param key:
:param visible:
'''
self.AutoSizeButton = auto_size_button
self.BType = button_type
self.FileTypes = file_types
self.TKButton = None
self.Target = target
self.ButtonText = button_text
if sys.platform == 'darwin' and button_color is not None:
print('Button *** WARNING - Button colors are not supported on the Mac ***')
self.ButtonColor = button_color if button_color else DEFAULT_BUTTON_COLOR
self.ImageFilename = image_filename
self.ImageData = image_data
self.ImageSize = image_size
self.ImageSubsample = image_subsample
self.UserData = None
self.BorderWidth = border_width if border_width is not None else DEFAULT_BORDER_WIDTH
self.BindReturnKey = bind_return_key
self.Focus = focus
self.TKCal = None
self.CalendarCloseWhenChosen = None
self.DefaultDate_M_D_Y = (None, None, None)
self.InitialFolder = initial_folder
self.Disabled = disabled
self.ChangeSubmits = change_submits or enable_events
super().__init__(ELEM_TYPE_BUTTON, size=size, font=font, pad=pad, key=key, tooltip=tooltip, visible=visible)
return
# Realtime button release callback
def ButtonReleaseCallBack(self, parm):
self.LastButtonClickedWasRealtime = False
self.ParentForm.LastButtonClicked = None
# Realtime button callback
def ButtonPressCallBack(self, parm):
self.ParentForm.LastButtonClickedWasRealtime = True
if self.Key is not None:
self.ParentForm.LastButtonClicked = self.Key
else:
self.ParentForm.LastButtonClicked = self.ButtonText
if self.ParentForm.CurrentlyRunningMainloop:
self.ParentForm.TKroot.quit() # kick out of loop if read was called
# ------- Button Callback ------- #
def ButtonCallBack(self):
# global _my_windows
# print('Button callback')
# print(f'Parent = {self.ParentForm} Position = {self.Position}')
# Buttons modify targets or return from the form
# If modifying target, get the element object at the target and modify its StrVar
target = self.Target
target_element = None
if target[0] == ThisRow:
target = [self.Position[0], target[1]]
if target[1] < 0:
target[1] = self.Position[1] + target[1]
strvar = None
should_submit_window = False
if target == (None, None):
strvar = self.TKStringVar
else:
if not isinstance(target, str):
if target[0] < 0:
target = [self.Position[0] + target[0], target[1]]
target_element = self.ParentContainer._GetElementAtLocation(target)
else:
target_element = self.ParentForm.FindElement(target)
try:
strvar = target_element.TKStringVar
except:
pass
try:
if target_element.ChangeSubmits:
should_submit_window = True
except:
pass
filetypes = (("ALL Files", "*.*"),) if self.FileTypes is None else self.FileTypes
if self.BType == BUTTON_TYPE_BROWSE_FOLDER:
folder_name = tk.filedialog.askdirectory(initialdir=self.InitialFolder) # show the 'get folder' dialog box
if folder_name != '':
try:
strvar.set(folder_name)
self.TKStringVar.set(folder_name)
except:
pass
elif self.BType == BUTTON_TYPE_BROWSE_FILE:
if sys.platform == 'darwin':
file_name = tk.filedialog.askopenfilename(initialdir=self.InitialFolder) # show the 'get file' dialog box
else:
file_name = tk.filedialog.askopenfilename(filetypes=filetypes, initialdir=self.InitialFolder) # show the 'get file' dialog box
if file_name != '':
strvar.set(file_name)
self.TKStringVar.set(file_name)
elif self.BType == BUTTON_TYPE_COLOR_CHOOSER:
color = tk.colorchooser.askcolor() # show the 'get file' dialog box
color = color[1] # save only the #RRGGBB portion
strvar.set(color)
self.TKStringVar.set(color)
elif self.BType == BUTTON_TYPE_BROWSE_FILES:
if sys.platform == 'darwin':
file_name = tk.filedialog.askopenfilenames(initialdir=self.InitialFolder)
else:
file_name = tk.filedialog.askopenfilenames(filetypes=filetypes, initialdir=self.InitialFolder)
if file_name != '':
file_name = ';'.join(file_name)
strvar.set(file_name)
self.TKStringVar.set(file_name)
elif self.BType == BUTTON_TYPE_SAVEAS_FILE:
if sys.platform == 'darwin':
file_name = tk.filedialog.asksaveasfilename(initialdir=self.InitialFolder) # show the 'get file' dialog box
else:
file_name = tk.filedialog.asksaveasfilename(filetypes=filetypes,
initialdir=self.InitialFolder) # show the 'get file' dialog box
if file_name != '':
strvar.set(file_name)
self.TKStringVar.set(file_name)
elif self.BType == BUTTON_TYPE_CLOSES_WIN: # this is a return type button so GET RESULTS and destroy window
# first, get the results table built
# modify the Results table in the parent FlexForm object
if self.Key is not None:
self.ParentForm.LastButtonClicked = self.Key
else:
self.ParentForm.LastButtonClicked = self.ButtonText
self.ParentForm.FormRemainedOpen = False
self.ParentForm._Close()
if self.ParentForm.CurrentlyRunningMainloop:
self.ParentForm.TKroot.quit()
if self.ParentForm.NonBlocking:
self.ParentForm.TKroot.destroy()
# _my_windows.Decrement()
Window.DecrementOpenCount()
elif self.BType == BUTTON_TYPE_READ_FORM: # LEAVE THE WINDOW OPEN!! DO NOT CLOSE
# first, get the results table built
# modify the Results table in the parent FlexForm object
if self.Key is not None:
self.ParentForm.LastButtonClicked = self.Key
else:
self.ParentForm.LastButtonClicked = self.ButtonText
self.ParentForm.FormRemainedOpen = True
if self.ParentForm.CurrentlyRunningMainloop: # if this window is running the mainloop, kick out
self.ParentForm.TKroot.quit() # kick the users out of the mainloop
elif self.BType == BUTTON_TYPE_CLOSES_WIN_ONLY: # special kind of button that does not exit main loop
self.ParentForm._Close()
if self.ParentForm.NonBlocking:
self.ParentForm.TKroot.destroy()
Window.DecrementOpenCount()
# _my_windows.Decrement()
elif self.BType == BUTTON_TYPE_CALENDAR_CHOOSER: # this is a return type button so GET RESULTS and destroy window
should_submit_window = False
root = tk.Toplevel()
root.title('Calendar Chooser')
root.wm_attributes("-topmost", 1)
self.TKCal = TKCalendar(master=root, firstweekday=calendar.SUNDAY, target_element=target_element, close_when_chosen=self.CalendarCloseWhenChosen, default_date=self.DefaultDate_M_D_Y )
self.TKCal.pack(expand=1, fill='both')
root.update()
if should_submit_window:
self.ParentForm.LastButtonClicked = target_element.Key
self.ParentForm.FormRemainedOpen = True
if self.ParentForm.CurrentlyRunningMainloop:
self.ParentForm.TKroot.quit() # kick the users out of the mainloop
return
def Update(self, text=None, button_color=(None, None), disabled=None, image_data=None, image_filename=None, visible=None, image_subsample=None, image_size=None):
try:
if text is not None:
self.TKButton.configure(text=text)
self.ButtonText = text
if sys.platform == 'darwin' and button_color != (None, None):
print('Button.Update *** WARNING - Button colors are not supported on the Mac***')
if button_color != (None, None):
self.TKButton.config(foreground=button_color[0], background=button_color[1])
except:
return
if disabled == True:
self.TKButton['state'] = 'disabled'
elif disabled == False:
self.TKButton['state'] = 'normal'
if image_data is not None:
image = tk.PhotoImage(data=image_data)
if image_size is not None:
width, height = image_size
else:
width, height = image.width(), image.height()
if image_subsample:
image = image.subsample(image_subsample)
self.TKButton.config(image=image, width=width, height=height)
self.TKButton.image = image
if image_filename is not None:
self.TKButton.config(highlightthickness=0)
image = tk.PhotoImage(file=image_filename)
if image_size is not None:
width, height = image_size
else:
width, height = image.width(), image.height()
if image_subsample:
image = image.subsample(image_subsample)
self.TKButton.config(image=image, width=width, height=height)
self.TKButton.image = image
if visible is False:
self.TKButton.pack_forget()
elif visible is True:
self.TKButton.pack()
def GetText(self):
return self.ButtonText
def SetFocus(self):
try:
self.TKButton.focus_set()
except:
pass
def __del__(self):
try:
self.TKButton.__del__()
except:
pass
super().__del__()
# ---------------------------------------------------------------------- #
# ButtonMenu Class #
# ---------------------------------------------------------------------- #
class ButtonMenu(Element):
def __init__(self, button_text,menu_def, tooltip=None,disabled=False,
image_filename=None, image_data=None, image_size=(None, None), image_subsample=None,border_width=None,
size=(None, None), auto_size_button=None, button_color=None, font=None, pad=None, key=None, tearoff=False, visible=True):
'''
ButtonMenu
:param button_text:
:param menu_def:
:param tooltip:
:param disabled:
:param image_filename:
:param image_data:
:param image_size:
:param image_subsample:
:param border_width:
:param size:
:param auto_size_button:
:param button_color:
:param font:
:param pad:
:param key:
:param tearoff:
:param visible:
'''
self.MenuDefinition = menu_def
self.AutoSizeButton = auto_size_button
self.ButtonText = button_text
self.ButtonColor = button_color if button_color else DEFAULT_BUTTON_COLOR
self.TextColor = self.ButtonColor[0]
self.BackgroundColor = self.ButtonColor[1]
self.BorderWidth = border_width
self.ImageFilename = image_filename
self.ImageData = image_data
self.ImageSize = image_size
self.ImageSubsample = image_subsample
self.Disabled = disabled
self.IsButtonMenu = True
self.MenuItemChosen = None
self.Tearoff = tearoff
self.TKButtonMenu = None
self.TKMenu = None
# self.temp_size = size if size != (NONE, NONE) else
super().__init__(ELEM_TYPE_BUTTONMENU, size=size, font=font, pad=pad, key=key, tooltip=tooltip, text_color=self.TextColor, background_color=self.BackgroundColor, visible=visible)
return
def MenuItemChosenCallback(self, item_chosen): # ButtonMenu Menu Item Chosen Callback
# print('IN MENU ITEM CALLBACK', item_chosen)
self.MenuItemChosen = item_chosen.replace('&','')
self.ParentForm.LastButtonClicked = self.Key
self.ParentForm.FormRemainedOpen = True
if self.ParentForm.CurrentlyRunningMainloop:
self.ParentForm.TKroot.quit() # kick the users out of the mainloop
def Update(self, menu_definition, visible=None):
self.MenuDefinition = menu_definition
if menu_definition is not None:
self.TKMenu = tk.Menu(self.TKButtonMenu, tearoff=self.Tearoff) # create the menubar
AddMenuItem(self.TKMenu, menu_definition[1], self)
self.TKButtonMenu.configure(menu=self.TKMenu)
if visible is False:
self.TKButtonMenu.pack_forget()
elif visible is True:
self.TKButtonMenu.pack()
def __del__(self):
try:
self.TKButton.__del__()
except:
pass
super().__del__()
# ---------------------------------------------------------------------- #
# ProgreessBar #
# ---------------------------------------------------------------------- #
class ProgressBar(Element):
def __init__(self, max_value, orientation=None, size=(None, None), auto_size_text=None, bar_color=(None, None),
style=None, border_width=None, relief=None, key=None, pad=None, visible=True):
'''
ProgressBar
:param max_value:
:param orientation:
:param size:
:param auto_size_text:
:param bar_color:
:param style:
:param border_width:
:param relief:
:param key:
:param pad:
:param visible:
'''
self.MaxValue = max_value
self.TKProgressBar = None
self.Cancelled = False
self.NotRunning = True
self.Orientation = orientation if orientation else DEFAULT_METER_ORIENTATION
self.BarColor = bar_color
self.BarStyle = style if style else DEFAULT_PROGRESS_BAR_STYLE
self.BorderWidth = border_width if border_width else DEFAULT_PROGRESS_BAR_BORDER_WIDTH
self.Relief = relief if relief else DEFAULT_PROGRESS_BAR_RELIEF
self.BarExpired = False
super().__init__(ELEM_TYPE_PROGRESS_BAR, size=size, auto_size_text=auto_size_text, key=key, pad=pad, visible=visible)
# returns False if update failed
def UpdateBar(self, current_count, max=None):
if self.ParentForm.TKrootDestroyed:
return False
self.TKProgressBar.Update(current_count, max=max)
try:
self.ParentForm.TKroot.update()
except:
Window.DecrementOpenCount()
# _my_windows.Decrement()
return False
return True
def Update(self, visible=None):
if visible is False:
self.TKProgressBar.TKProgressBarForReal.pack_forget()
elif visible is True:
self.TKProgressBar.TKProgressBarForReal.pack()
def __del__(self):
try:
self.TKProgressBar.__del__()
except:
pass
super().__del__()
# ---------------------------------------------------------------------- #
# Image #
# ---------------------------------------------------------------------- #
class Image(Element):
def __init__(self, filename=None, data=None, background_color=None, size=(None, None), pad=None, key=None,
tooltip=None, right_click_menu=None, visible=True, enable_events=False):
'''
Image
:param filename:
:param data:
:param background_color:
:param size:
:param pad:
:param key:
:param tooltip:
:param right_click_menu:
:param visible:
:param enable_events:
'''
self.Filename = filename
self.Data = data
self.tktext_label = None
self.BackgroundColor = background_color
if data is None and filename is None:
print('* Warning... no image specified in Image Element! *')
self.EnableEvents = enable_events
self.RightClickMenu = right_click_menu
self.AnimatedFrames = None
self.CurrentFrameNumber = 0
self.TotalAnimatedFrames = 0
self.LastFrameTime = 0
self.Source = filename or data
super().__init__(ELEM_TYPE_IMAGE, size=size, background_color=background_color, pad=pad, key=key,
tooltip=tooltip, visible=visible)
return
def Update(self, filename=None, data=None, size=(None,None), visible=None):
if filename is not None:
image = tk.PhotoImage(file=filename)
elif data is not None:
# if type(data) is bytes:
try:
image = tk.PhotoImage(data=data)
except:
return # an error likely means the window has closed so exit
else:
return
width, height = size[0] or image.width(), size[1] or image.height()
self.tktext_label.configure(image=image, width=width, height=height)
self.tktext_label.image = image
if visible is False:
self.tktext_label.pack_forget()
elif visible is True:
self.tktext_label.pack()
def UpdateAnimation(self, source, time_between_frames=0):
if self.Source != source:
self.AnimatedFrames = None
self.Source = source
if self.AnimatedFrames is None:
self.TotalAnimatedFrames = 0
self.AnimatedFrames = []
for i in range(1000):
if type(source) is not bytes:
try:
self.AnimatedFrames.append(tk.PhotoImage(file=source, format='gif -index %i' % (i)))
except:
break
else:
try:
self.AnimatedFrames.append(tk.PhotoImage(data=source, format='gif -index %i' % (i)))
except:
break
self.TotalAnimatedFrames += 1
self.LastFrameTime = time.time()
self.CurrentFrameNumber = 0
# show the frame
now = time.time()
if time_between_frames:
if (now - self.LastFrameTime) * 1000 > time_between_frames:
self.LastFrameTime = now
self.CurrentFrameNumber = self.CurrentFrameNumber + 1 if self.CurrentFrameNumber+1< self.TotalAnimatedFrames else 0
else: # don't reshow the frame again if not time for new frame
return
else:
self.CurrentFrameNumber = self.CurrentFrameNumber + 1 if self.CurrentFrameNumber+1< self.TotalAnimatedFrames else 0
image = self.AnimatedFrames[self.CurrentFrameNumber]
self.tktext_label.configure(image=image, width=image.width(), heigh=image.height())
def __del__(self):
super().__del__()
# ---------------------------------------------------------------------- #
# Canvas #
# ---------------------------------------------------------------------- #
class Canvas(Element):
def __init__(self, canvas=None, background_color=None, size=(None, None), pad=None, key=None, tooltip=None, right_click_menu=None, visible=True):
'''
Canvas
:param canvas:
:param background_color:
:param size:
:param pad:
:param key:
:param tooltip:
:param right_click_menu:
:param visible:
'''
self.BackgroundColor = background_color if background_color is not None else DEFAULT_BACKGROUND_COLOR
self._TKCanvas = canvas
self.RightClickMenu = right_click_menu
super().__init__(ELEM_TYPE_CANVAS, background_color=background_color, size=size, pad=pad, key=key,
tooltip=tooltip, visible=visible)
return
@property
def TKCanvas(self):
if self._TKCanvas is None:
print('*** Did you forget to call Finalize()? Your code should look something like: ***')
print('*** form = sg.Window("My Form").Layout(layout).Finalize() ***')
return self._TKCanvas
def __del__(self):
super().__del__()
# ---------------------------------------------------------------------- #
# Graph #
# ---------------------------------------------------------------------- #
class Graph(Element):
def __init__(self, canvas_size, graph_bottom_left, graph_top_right, background_color=None, pad=None, change_submits=False, drag_submits=False, enable_events=False, key=None, tooltip=None, right_click_menu=None, visible=True):
'''
Graph
:param canvas_size:
:param graph_bottom_left:
:param graph_top_right:
:param background_color:
:param pad:
:param change_submits:
:param drag_submits:
:param enable_events:
:param key:
:param tooltip:
:param right_click_menu:
:param visible:
'''
self.CanvasSize = canvas_size
self.BottomLeft = graph_bottom_left
self.TopRight = graph_top_right
self._TKCanvas = None
self._TKCanvas2 = None
self.ChangeSubmits = change_submits or enable_events
self.DragSubmits = drag_submits
self.ClickPosition = (None, None)
self.MouseButtonDown = False
self.Images = []
self.RightClickMenu = right_click_menu
super().__init__(ELEM_TYPE_GRAPH, background_color=background_color, size=canvas_size, pad=pad, key=key,
tooltip=tooltip, visible=visible)
return
def _convert_xy_to_canvas_xy(self, x_in, y_in):
if None in (x_in,y_in):
return None, None
scale_x = (self.CanvasSize[0] - 0) / (self.TopRight[0] - self.BottomLeft[0])
scale_y = (0 - self.CanvasSize[1]) / (self.TopRight[1] - self.BottomLeft[1])
new_x = 0 + scale_x * (x_in - self.BottomLeft[0])
new_y = self.CanvasSize[1] + scale_y * (y_in - self.BottomLeft[1])
return new_x, new_y
def _convert_canvas_xy_to_xy(self, x_in, y_in):
if None in (x_in,y_in):
return None, None
scale_x = (self.CanvasSize[0] - 0) / (self.TopRight[0] - self.BottomLeft[0])
scale_y = (0 - self.CanvasSize[1]) / (self.TopRight[1] - self.BottomLeft[1])
new_x = x_in/scale_x+self.BottomLeft[0]
new_y = (y_in - self.CanvasSize[1]) / scale_y + self.BottomLeft[1]
return int(new_x), int(new_y)
def DrawLine(self, point_from, point_to, color='black', width=1):
if point_from == (None, None):
return
converted_point_from = self._convert_xy_to_canvas_xy(point_from[0], point_from[1])
converted_point_to = self._convert_xy_to_canvas_xy(point_to[0], point_to[1])
if self._TKCanvas2 is None:
print('*** WARNING - The Graph element has not been finalized and cannot be drawn upon ***')
print('Call Window.Finalize() prior to this operation')
return None
return self._TKCanvas2.create_line(converted_point_from, converted_point_to, width=width, fill=color)
def DrawPoint(self, point, size=2, color='black'):
if point == (None, None):
return
converted_point = self._convert_xy_to_canvas_xy(point[0], point[1])
if self._TKCanvas2 is None:
print('*** WARNING - The Graph element has not been finalized and cannot be drawn upon ***')
print('Call Window.Finalize() prior to this operation')
return None
return self._TKCanvas2.create_oval(converted_point[0] - size, converted_point[1] - size,
converted_point[0] + size, converted_point[1] + size, fill=color,
outline=color)
def DrawCircle(self, center_location, radius, fill_color=None, line_color='black'):
if center_location == (None, None):
return
converted_point = self._convert_xy_to_canvas_xy(center_location[0], center_location[1])
if self._TKCanvas2 is None:
print('*** WARNING - The Graph element has not been finalized and cannot be drawn upon ***')
print('Call Window.Finalize() prior to this operation')
return None
return self._TKCanvas2.create_oval(converted_point[0] - radius, converted_point[1] - radius,
converted_point[0] + radius, converted_point[1] + radius, fill=fill_color,
outline=line_color)
def DrawOval(self, top_left, bottom_right, fill_color=None, line_color=None):
converted_top_left = self._convert_xy_to_canvas_xy(top_left[0], top_left[1])
converted_bottom_right = self._convert_xy_to_canvas_xy(bottom_right[0], bottom_right[1])
if self._TKCanvas2 is None:
print('*** WARNING - The Graph element has not been finalized and cannot be drawn upon ***')
print('Call Window.Finalize() prior to this operation')
return None
return self._TKCanvas2.create_oval(converted_top_left[0], converted_top_left[1], converted_bottom_right[0],
converted_bottom_right[1], fill=fill_color, outline=line_color)
def DrawArc(self, top_left, bottom_right, extent, start_angle, style=None, arc_color='black'):
converted_top_left = self._convert_xy_to_canvas_xy(top_left[0], top_left[1])
converted_bottom_right = self._convert_xy_to_canvas_xy(bottom_right[0], bottom_right[1])
tkstyle = tk.PIESLICE if style is None else style
if self._TKCanvas2 is None:
print('*** WARNING - The Graph element has not been finalized and cannot be drawn upon ***')
print('Call Window.Finalize() prior to this operation')
return None
return self._TKCanvas2.create_arc(converted_top_left[0], converted_top_left[1], converted_bottom_right[0],
converted_bottom_right[1], extent=extent, start=start_angle, style=tkstyle,
outline=arc_color)
def DrawRectangle(self, top_left, bottom_right, fill_color=None, line_color=None):
converted_top_left = self._convert_xy_to_canvas_xy(top_left[0], top_left[1])
converted_bottom_right = self._convert_xy_to_canvas_xy(bottom_right[0], bottom_right[1])
if self._TKCanvas2 is None:
print('*** WARNING - The Graph element has not been finalized and cannot be drawn upon ***')
print('Call Window.Finalize() prior to this operation')
return None
return self._TKCanvas2.create_rectangle(converted_top_left[0], converted_top_left[1], converted_bottom_right[0],
converted_bottom_right[1], fill=fill_color, outline=line_color)
def DrawText(self, text, location, color='black', font=None, angle=0):
if location == (None, None):
return
converted_point = self._convert_xy_to_canvas_xy(location[0], location[1])
if self._TKCanvas2 is None:
print('*** WARNING - The Graph element has not been finalized and cannot be drawn upon ***')
print('Call Window.Finalize() prior to this operation')
return None
text_id = self._TKCanvas2.create_text(converted_point[0], converted_point[1], text=text, font=font, fill=color,
angle=angle)
return text_id
def DrawImage(self, filename=None, data=None, location=(None, None), color='black', font=None, angle=0):
if location == (None, None):
return
if filename is not None:
image = tk.PhotoImage(file=filename)
elif data is not None:
# if type(data) is bytes:
try:
image = tk.PhotoImage(data=data)
except:
return None # an error likely means the window has closed so exit
converted_point = self._convert_xy_to_canvas_xy(location[0], location[1])
if self._TKCanvas2 is None:
print('*** WARNING - The Graph element has not been finalized and cannot be drawn upon ***')
print('Call Window.Finalize() prior to this operation')
return None
self.Images.append(image)
text_id = self._TKCanvas2.create_image(converted_point, image=image, anchor=tk.NW)
return text_id
def Erase(self):
if self._TKCanvas2 is None:
print('*** WARNING - The Graph element has not been finalized and cannot be drawn upon ***')
print('Call Window.Finalize() prior to this operation')
return None
self._TKCanvas2.delete('all')
def DeleteFigure(self, id):
try:
self._TKCanvas2.delete(id)
except:
print('DeleteFigure - bad ID {}'.format(id))
def Update(self, background_color, visible=None):
if self._TKCanvas2 is None:
print('*** WARNING - The Graph element has not been finalized and cannot be drawn upon ***')
print('Call Window.Finalize() prior to this operation')
return None
if background_color is not None and background_color != COLOR_SYSTEM_DEFAULT:
self._TKCanvas2.configure(background=background_color)
if visible is False:
self._TKCanvas2.pack_forget()
elif visible is True:
self._TKCanvas2.pack()
def Move(self, x_direction, y_direction):
zero_converted = self._convert_xy_to_canvas_xy(0, 0)
shift_converted = self._convert_xy_to_canvas_xy(x_direction, y_direction)
shift_amount = (shift_converted[0] - zero_converted[0], shift_converted[1] - zero_converted[1])
if self._TKCanvas2 is None:
print('*** WARNING - The Graph element has not been finalized and cannot be drawn upon ***')
print('Call Window.Finalize() prior to this operation')
return None
self._TKCanvas2.move('all', shift_amount[0], shift_amount[1])
def MoveFigure(self, figure, x_direction, y_direction):
zero_converted = self._convert_xy_to_canvas_xy(0, 0)
shift_converted = self._convert_xy_to_canvas_xy(x_direction, y_direction)
shift_amount = (shift_converted[0] - zero_converted[0], shift_converted[1] - zero_converted[1])
if figure is None:
print('*** WARNING - Your figure is None. It most likely means your did not Finalize your Window ***')
print('Call Window.Finalize() prior to all graph operations')
return None
self._TKCanvas2.move(figure, shift_amount[0], shift_amount[1])
@property
def TKCanvas(self):
if self._TKCanvas2 is None:
print('*** Did you forget to call Finalize()? Your code should look something like: ***')
print('*** form = sg.Window("My Form").Layout(layout).Finalize() ***')
return self._TKCanvas2
# Realtime button release callback
def ButtonReleaseCallBack(self, event):
self.ClickPosition = (None, None)
self.LastButtonClickedWasRealtime = not self.DragSubmits
if self.Key is not None:
self.ParentForm.LastButtonClicked = self.Key
else:
self.ParentForm.LastButtonClicked = '__GRAPH__' # need to put something rather than None
if self.ParentForm.CurrentlyRunningMainloop:
self.ParentForm.TKroot.quit()
if self.DragSubmits:
self.ParentForm.LastButtonClicked = None
self.MouseButtonDown = False
# Realtime button callback
def ButtonPressCallBack(self, event):
self.ClickPosition = self._convert_canvas_xy_to_xy(event.x, event.y)
self.ParentForm.LastButtonClickedWasRealtime = self.DragSubmits
if self.Key is not None:
self.ParentForm.LastButtonClicked = self.Key
else:
self.ParentForm.LastButtonClicked = '__GRAPH__' # need to put something rather than None
if self.ParentForm.CurrentlyRunningMainloop:
self.ParentForm.TKroot.quit() # kick out of loop if read was called
self.MouseButtonDown = True
# Realtime button callback
def MotionCallBack(self, event):
if not self.MouseButtonDown:
return
self.ClickPosition = self._convert_canvas_xy_to_xy(event.x, event.y)
self.ParentForm.LastButtonClickedWasRealtime = self.DragSubmits
if self.Key is not None:
self.ParentForm.LastButtonClicked = self.Key
else:
self.ParentForm.LastButtonClicked = '__GRAPH__' # need to put something rather than None
if self.ParentForm.CurrentlyRunningMainloop:
self.ParentForm.TKroot.quit() # kick out of loop if read was called
def __del__(self):
super().__del__()
# ---------------------------------------------------------------------- #
# Frame #
# ---------------------------------------------------------------------- #
class Frame(Element):
def __init__(self, title, layout, title_color=None, background_color=None, title_location=None,
relief=DEFAULT_FRAME_RELIEF, size=(None, None), font=None, pad=None, border_width=None, key=None,
tooltip=None, right_click_menu=None, visible=True):
'''
Frame
:param title:
:param layout:
:param title_color:
:param background_color:
:param title_location:
:param relief:
:param size:
:param font:
:param pad:
:param border_width:
:param key:
:param tooltip:
:param right_click_menu:
:param visible:
'''
self.UseDictionary = False
self.ReturnValues = None
self.ReturnValuesList = []
self.ReturnValuesDictionary = {}
self.DictionaryKeyCounter = 0
self.ParentWindow = None
self.Rows = []
# self.ParentForm = None
self.TKFrame = None
self.Title = title
self.Relief = relief
self.TitleLocation = title_location
self.BorderWidth = border_width
self.BackgroundColor = background_color if background_color is not None else DEFAULT_BACKGROUND_COLOR
self.RightClickMenu = right_click_menu
self.Layout(layout)
super().__init__(ELEM_TYPE_FRAME, background_color=background_color, text_color=title_color, size=size,
font=font, pad=pad, key=key, tooltip=tooltip, visible=visible)
return
def AddRow(self, *args):
''' Parms are a variable number of Elements '''
NumRows = len(self.Rows) # number of existing rows is our row number
CurrentRowNumber = NumRows # this row's number
CurrentRow = [] # start with a blank row and build up
# ------------------------- Add the elements to a row ------------------------- #
for i, element in enumerate(args): # Loop through list of elements and add them to the row
element.Position = (CurrentRowNumber, i)
element.ParentContainer = self
CurrentRow.append(element)
if element.Key is not None:
self.UseDictionary = True
# ------------------------- Append the row to list of Rows ------------------------- #
self.Rows.append(CurrentRow)
def Layout(self, rows):
for row in rows:
self.AddRow(*row)
def _GetElementAtLocation(self, location):
(row_num, col_num) = location
row = self.Rows[row_num]
element = row[col_num]
return element
def Update(self, visible=None):
if visible is False:
self.TKFrame.pack_forget()
elif visible is True:
self.TKFrame.pack()
def __del__(self):
for row in self.Rows:
for element in row:
element.__del__()
super().__del__()
# ---------------------------------------------------------------------- #
# Separator #
# Routes stdout, stderr to a scrolled window #
# ---------------------------------------------------------------------- #
class VerticalSeparator(Element):
def __init__(self, pad=None):
'''
VerticalSeperator - A separator that spans only 1 row in a vertical fashion
:param pad:
'''
self.Orientation = 'vertical' # for now only vertical works
super().__init__(ELEM_TYPE_SEPARATOR, pad=pad)
def __del__(self):
super().__del__()
VSeperator = VerticalSeparator
VSep = VerticalSeparator
# ---------------------------------------------------------------------- #
# Tab #
# ---------------------------------------------------------------------- #
class Tab(Element):
def __init__(self, title, layout, title_color=None, background_color=None, font=None, pad=None, disabled=False,
border_width=None, key=None, tooltip=None, right_click_menu=None, visible=True):
'''
Tab
:param title:
:param layout:
:param title_color:
:param background_color:
:param font:
:param pad:
:param disabled:
:param border_width:
:param key:
:param tooltip:
:param right_click_menu:
:param visible:
'''
self.UseDictionary = False
self.ReturnValues = None
self.ReturnValuesList = []
self.ReturnValuesDictionary = {}
self.DictionaryKeyCounter = 0
self.ParentWindow = None
self.Rows = []
self.TKFrame = None
self.Title = title
self.BorderWidth = border_width
self.Disabled = disabled
self.ParentNotebook = None
self.TabID = None
self.BackgroundColor = background_color if background_color is not None else DEFAULT_BACKGROUND_COLOR
self.RightClickMenu = right_click_menu
self.Layout(layout)
super().__init__(ELEM_TYPE_TAB, background_color=background_color, text_color=title_color, font=font, pad=pad,
key=key, tooltip=tooltip, visible=visible)
return
def AddRow(self, *args):
''' Parms are a variable number of Elements '''
NumRows = len(self.Rows) # number of existing rows is our row number
CurrentRowNumber = NumRows # this row's number
CurrentRow = [] # start with a blank row and build up
# ------------------------- Add the elements to a row ------------------------- #
for i, element in enumerate(args): # Loop through list of elements and add them to the row
element.Position = (CurrentRowNumber, i)
element.ParentContainer = self
CurrentRow.append(element)
if element.Key is not None:
self.UseDictionary = True
# ------------------------- Append the row to list of Rows ------------------------- #
self.Rows.append(CurrentRow)
def Layout(self, rows):
for row in rows:
self.AddRow(*row)
return self
def Update(self, disabled=None, visible=None): # TODO Disable / enable of tabs is not complete
if disabled is None:
return
self.Disabled = disabled
state = 'disabled' if disabled is True else 'normal'
self.ParentNotebook.tab(self.TabID, state=state)
if visible is False:
self.ParentNotebook.pack_forget()
elif visible is True:
self.ParentNotebook.pack()
return self
def _GetElementAtLocation(self, location):
(row_num, col_num) = location
row = self.Rows[row_num]
element = row[col_num]
return element
def __del__(self):
for row in self.Rows:
for element in row:
element.__del__()
super().__del__()
# ---------------------------------------------------------------------- #
# TabGroup #
# ---------------------------------------------------------------------- #
class TabGroup(Element):
def __init__(self, layout, tab_location=None, title_color=None, selected_title_color=None, background_color=None,
font=None, change_submits=False, enable_events=False,pad=None, border_width=None, theme=None, key=None, tooltip=None, visible=True):
'''
TabGroup
:param layout:
:param tab_location:
:param title_color:
:param selected_title_color:
:param background_color:
:param font:
:param change_submits:
:param enable_events:
:param pad:
:param border_width:
:param theme:
:param key:
:param tooltip:
:param visible:
'''
self.UseDictionary = False
self.ReturnValues = None
self.ReturnValuesList = []
self.ReturnValuesDictionary = {}
self.DictionaryKeyCounter = 0
self.ParentWindow = None
self.SelectedTitleColor = selected_title_color
self.Rows = []
self.TKNotebook = None
self.TabCount = 0
self.BorderWidth = border_width
self.Theme = theme
self.BackgroundColor = background_color if background_color is not None else DEFAULT_BACKGROUND_COLOR
self.ChangeSubmits = change_submits or enable_events
self.TabLocation = tab_location
self.Layout(layout)
super().__init__(ELEM_TYPE_TAB_GROUP, background_color=background_color, text_color=title_color, font=font,
pad=pad, key=key, tooltip=tooltip, visible=visible)
return
def AddRow(self, *args):
''' Parms are a variable number of Elements '''
NumRows = len(self.Rows) # number of existing rows is our row number
CurrentRowNumber = NumRows # this row's number
CurrentRow = [] # start with a blank row and build up
# ------------------------- Add the elements to a row ------------------------- #
for i, element in enumerate(args): # Loop through list of elements and add them to the row
element.Position = (CurrentRowNumber, i)
element.ParentContainer = self
CurrentRow.append(element)
if element.Key is not None:
self.UseDictionary = True
# ------------------------- Append the row to list of Rows ------------------------- #
self.Rows.append(CurrentRow)
def Layout(self, rows):
for row in rows:
self.AddRow(*row)
def _GetElementAtLocation(self, location):
(row_num, col_num) = location
row = self.Rows[row_num]
element = row[col_num]
return element
def FindKeyFromTabName(self, tab_name):
for row in self.Rows:
for element in row:
if element.Title == tab_name:
return element.Key
return None
def __del__(self):
for row in self.Rows:
for element in row:
element.__del__()
super().__del__()
# ---------------------------------------------------------------------- #
# Slider #
# ---------------------------------------------------------------------- #
class Slider(Element):
def __init__(self, range=(None, None), default_value=None, resolution=None, tick_interval=None, orientation=None, disable_number_display=False, border_width=None, relief=None, change_submits=False, enable_events=False, disabled=False, size=(None, None), font=None, background_color=None, text_color=None, key=None, pad=None, tooltip=None, visible=True):
'''
Slider
:param range:
:param default_value:
:param resolution:
:param tick_interval:
:param orientation:
:param disable_number_display:
:param border_width:
:param relief:
:param change_submits:
:param enable_events:
:param disabled:
:param size:
:param font:
:param background_color:
:param text_color:
:param key:
:param pad:
:param tooltip:
:param visible:
'''
self.TKScale = None
self.Range = (1, 10) if range == (None, None) else range
self.DefaultValue = self.Range[0] if default_value is None else default_value
self.Orientation = orientation if orientation else DEFAULT_SLIDER_ORIENTATION
self.BorderWidth = border_width if border_width else DEFAULT_SLIDER_BORDER_WIDTH
self.Relief = relief if relief else DEFAULT_SLIDER_RELIEF
self.Resolution = 1 if resolution is None else resolution
self.ChangeSubmits = change_submits or enable_events
self.Disabled = disabled
self.TickInterval = tick_interval
self.DisableNumericDisplay = disable_number_display
temp_size = size
if temp_size == (None, None):
temp_size = (20, 20) if self.Orientation.startswith('h') else (8, 20)
super().__init__(ELEM_TYPE_INPUT_SLIDER, size=temp_size, font=font, background_color=background_color,
text_color=text_color, key=key, pad=pad, tooltip=tooltip, visible=visible)
return
def Update(self, value=None, range=(None, None), disabled=None, visible=None):
if value is not None:
try:
self.TKIntVar.set(value)
if range != (None, None):
self.TKScale.config(from_=range[0], to_=range[1])
except:
pass
self.DefaultValue = value
if disabled == True:
self.TKScale['state'] = 'disabled'
elif disabled == False:
self.TKScale['state'] = 'normal'
if visible is False:
self.TKScale.pack_forget()
elif visible is True:
self.TKScale.pack()
def SliderChangedHandler(self, event):
# first, get the results table built
# modify the Results table in the parent FlexForm object
if self.Key is not None:
self.ParentForm.LastButtonClicked = self.Key
else:
self.ParentForm.LastButtonClicked = ''
self.ParentForm.FormRemainedOpen = True
if self.ParentForm.CurrentlyRunningMainloop:
self.ParentForm.TKroot.quit() # kick the users out of the mainloop
def __del__(self):
super().__del__()
# ---------------------------------------------------------------------- #
# TkScrollableFrame (Used by Column) #
# ---------------------------------------------------------------------- #
class TkFixedFrame(tk.Frame):
def __init__(self, master, **kwargs):
tk.Frame.__init__(self, master, **kwargs)
self.canvas = tk.Canvas(self)
self.canvas.pack(side="left", fill="both", expand=True)
# reset the view
self.canvas.xview_moveto(0)
self.canvas.yview_moveto(0)
# create a frame inside the canvas which will be scrolled with it
self.TKFrame = tk.Frame(self.canvas, **kwargs)
self.frame_id = self.canvas.create_window(0, 0, window=self.TKFrame, anchor="nw")
self.canvas.config(borderwidth=0, highlightthickness=0)
self.TKFrame.config(borderwidth=0, highlightthickness=0)
self.config(borderwidth=0, highlightthickness=0)
# ---------------------------------------------------------------------- #
# TkScrollableFrame (Used by Column) #
# ---------------------------------------------------------------------- #
class TkScrollableFrame(tk.Frame):
def __init__(self, master, vertical_only, **kwargs):
tk.Frame.__init__(self, master, **kwargs)
# create a canvas object and a vertical scrollbar for scrolling it
self.vscrollbar = tk.Scrollbar(self, orient=tk.VERTICAL)
self.vscrollbar.pack(side='right', fill="y", expand="false")
if not vertical_only:
self.hscrollbar = tk.Scrollbar(self, orient=tk.HORIZONTAL)
self.hscrollbar.pack(side='bottom', fill="x", expand="false")
self.canvas = tk.Canvas(self, yscrollcommand=self.vscrollbar.set, xscrollcommand=self.hscrollbar.set)
else:
self.canvas = tk.Canvas(self, yscrollcommand=self.vscrollbar.set)
self.canvas.pack(side="left", fill="both", expand=True)
self.vscrollbar.config(command=self.canvas.yview)
if not vertical_only:
self.hscrollbar.config(command=self.canvas.xview)
# reset the view
self.canvas.xview_moveto(0)
self.canvas.yview_moveto(0)
# create a frame inside the canvas which will be scrolled with it
self.TKFrame = tk.Frame(self.canvas, **kwargs)
self.frame_id = self.canvas.create_window(0, 0, window=self.TKFrame, anchor="nw")
self.canvas.config(borderwidth=0, highlightthickness=0)
self.TKFrame.config(borderwidth=0, highlightthickness=0)
self.config(borderwidth=0, highlightthickness=0)
# scrollbar = tk.Scrollbar(frame)
# scrollbar.pack(side=tk.RIGHT, fill='y')
# scrollbar.config(command=treeview.yview)
# self.vscrollbar.config(command=self.TKFrame.yview)
# self.TKFrame.configure(yscrollcommand=self.vscrollbar.set)
self.bind('<Configure>', self.set_scrollregion)
self.bind_mouse_scroll(self.canvas, self.yscroll)
if not vertical_only:
self.bind_mouse_scroll(self.hscrollbar, self.xscroll)
self.bind_mouse_scroll(self.vscrollbar, self.yscroll)
def resize_frame(self, e):
self.canvas.itemconfig(self.frame_id, height=e.height, width=e.width)
def yscroll(self, event):
if event.num == 5 or event.delta < 0:
self.canvas.yview_scroll(1, "unit")
elif event.num == 4 or event.delta > 0:
self.canvas.yview_scroll(-1, "unit")
def xscroll(self, event):
if event.num == 5 or event.delta < 0:
self.canvas.xview_scroll(1, "unit")
elif event.num == 4 or event.delta > 0:
self.canvas.xview_scroll(-1, "unit")
def bind_mouse_scroll(self, parent, mode):
# ~~ Windows only
parent.bind("<MouseWheel>", mode)
# ~~ Unix only
parent.bind("<Button-4>", mode)
parent.bind("<Button-5>", mode)
def set_scrollregion(self, event=None):
""" Set the scroll region on the canvas"""
self.canvas.configure(scrollregion=self.canvas.bbox('all'))
# ---------------------------------------------------------------------- #
# Column #
# ---------------------------------------------------------------------- #
class Column(Element):
def __init__(self, layout, background_color=None, size=(None, None), pad=None, scrollable=False, vertical_scroll_only=False, right_click_menu=None, key=None, visible=True):
'''
Column
:param layout:
:param background_color:
:param size:
:param pad:
:param scrollable:
:param vertical_scroll_only:
:param right_click_menu:
:param key:
:param visible:
'''
self.UseDictionary = False
self.ReturnValues = None
self.ReturnValuesList = []
self.ReturnValuesDictionary = {}
self.DictionaryKeyCounter = 0
self.ParentWindow = None
self.ParentPanedWindow = None
self.Rows = []
self.TKFrame = None
self.TKColFrame = None
self.Scrollable = scrollable
self.VerticalScrollOnly = vertical_scroll_only
self.RightClickMenu = right_click_menu
bg = background_color if background_color is not None else DEFAULT_BACKGROUND_COLOR
self.Layout(layout)
super().__init__(ELEM_TYPE_COLUMN, background_color=bg, size=size, pad=pad, key=key, visible=visible)
return
def AddRow(self, *args):
''' Parms are a variable number of Elements '''
NumRows = len(self.Rows) # number of existing rows is our row number
CurrentRowNumber = NumRows # this row's number
CurrentRow = [] # start with a blank row and build up
# ------------------------- Add the elements to a row ------------------------- #
for i, element in enumerate(args): # Loop through list of elements and add them to the row
element.Position = (CurrentRowNumber, i)
element.ParentContainer = self
CurrentRow.append(element)
if element.Key is not None:
self.UseDictionary = True
# ------------------------- Append the row to list of Rows ------------------------- #
self.Rows.append(CurrentRow)
def Layout(self, rows):
for row in rows:
self.AddRow(*row)
def _GetElementAtLocation(self, location):
(row_num, col_num) = location
row = self.Rows[row_num]
element = row[col_num]
return element
def Update(self, visible=None):
if visible is False:
if self.TKColFrame:
self.TKColFrame.pack_forget()
if self.ParentPanedWindow:
self.ParentPanedWindow.remove(self.TKColFrame)
elif visible is True:
if self.TKColFrame:
self.TKColFrame.pack()
if self.ParentPanedWindow:
self.ParentPanedWindow.add(self.TKColFrame)
def __del__(self):
for row in self.Rows:
for element in row:
element.__del__()
try:
del (self.TKFrame)
except:
pass
super().__del__()
# ---------------------------------------------------------------------- #
# Pane #
# ---------------------------------------------------------------------- #
class Pane(Element):
def __init__(self, pane_list, background_color=None, size=(None, None), pad=None, orientation='vertical', show_handle=True, relief=RELIEF_RAISED, handle_size=None, border_width=None, key=None, visible=True):
'''
Pane
:param pane_list:
:param background_color:
:param size:
:param pad:
:param orientation:
:param show_handle:
:param relief:
:param handle_size:
:param border_width:
:param key:
:param visible:
'''
self.UseDictionary = False
self.ReturnValues = None
self.ReturnValuesList = []
self.ReturnValuesDictionary = {}
self.DictionaryKeyCounter = 0
self.ParentWindow = None
self.Rows = []
self.TKFrame = None
self.PanedWindow = None
self.Orientation = orientation
self.PaneList = pane_list
self.ShowHandle = show_handle
self.Relief = relief
self.HandleSize = handle_size or 8
self.BorderDepth = border_width
bg = background_color if background_color is not None else DEFAULT_BACKGROUND_COLOR
self.Rows = [pane_list]
super().__init__(ELEM_TYPE_PANE, background_color=bg, size=size, pad=pad, key=key, visible=visible)
return
def Update(self, visible=None):
if visible is False:
self.PanedWindow.pack_forget()
elif visible is True:
self.PanedWindow.pack()
# ---------------------------------------------------------------------- #
# Calendar #
# ---------------------------------------------------------------------- #
class TKCalendar(ttk.Frame):
"""
This code was shamelessly lifted from moshekaplan's repository - moshekaplan/tkinter_components
"""
# XXX ToDo: cget and configure
datetime = calendar.datetime.datetime
timedelta = calendar.datetime.timedelta
def __init__(self, master=None, target_element=None, close_when_chosen=True, default_date=(None, None, None), **kw):
"""
WIDGET-SPECIFIC OPTIONS
locale, firstweekday, year, month, selectbackground,
selectforeground
"""
self._TargetElement = target_element
default_mon, default_day, default_year = default_date
# remove custom options from kw before initializating ttk.Frame
fwday = kw.pop('firstweekday', calendar.MONDAY)
year = kw.pop('year', default_year or self.datetime.now().year)
month = kw.pop('month', default_mon or self.datetime.now().month)
locale = kw.pop('locale', None)
sel_bg = kw.pop('selectbackground', '#ecffc4')
sel_fg = kw.pop('selectforeground', '#05640e')
self._date = self.datetime(year, month, default_day or 1)
self._selection = None # no date selected
self._master = master
self.close_when_chosen = close_when_chosen
ttk.Frame.__init__(self, master, **kw)
# instantiate proper calendar class
if locale is None:
self._cal = calendar.TextCalendar(fwday)
else:
self._cal = calendar.LocaleTextCalendar(fwday, locale)
self.__setup_styles() # creates custom styles
self.__place_widgets() # pack/grid used widgets
self.__config_calendar() # adjust calendar columns and setup tags
# configure a canvas, and proper bindings, for selecting dates
self.__setup_selection(sel_bg, sel_fg)
# store items ids, used for insertion later
self._items = [self._calendar.insert('', 'end', values='')
for _ in range(6)]
# insert dates in the currently empty calendar
self._build_calendar()
def __setitem__(self, item, value):
if item in ('year', 'month'):
raise AttributeError("attribute '%s' is not writeable" % item)
elif item == 'selectbackground':
self._canvas['background'] = value
elif item == 'selectforeground':
self._canvas.itemconfigure(self._canvas.text, item=value)
else:
ttk.Frame.__setitem__(self, item, value)
def __getitem__(self, item):
if item in ('year', 'month'):
return getattr(self._date, item)
elif item == 'selectbackground':
return self._canvas['background']
elif item == 'selectforeground':
return self._canvas.itemcget(self._canvas.text, 'fill')
else:
r = ttk.tclobjs_to_py({item: ttk.Frame.__getitem__(self, item)})
return r[item]
def __setup_styles(self):
# custom ttk styles
style = ttk.Style(self.master)
arrow_layout = lambda dir: (
[('Button.focus', {'children': [('Button.%sarrow' % dir, None)]})]
)
style.layout('L.TButton', arrow_layout('left'))
style.layout('R.TButton', arrow_layout('right'))
def __place_widgets(self):
# header frame and its widgets
hframe = ttk.Frame(self)
lbtn = ttk.Button(hframe, style='L.TButton', command=self._prev_month)
rbtn = ttk.Button(hframe, style='R.TButton', command=self._next_month)
self._header = ttk.Label(hframe, width=15, anchor='center')
# the calendar
self._calendar = ttk.Treeview(self, show='', selectmode='none', height=7)
# pack the widgets
hframe.pack(in_=self, side='top', pady=4, anchor='center')
lbtn.grid(in_=hframe)
self._header.grid(in_=hframe, column=1, row=0, padx=12)
rbtn.grid(in_=hframe, column=2, row=0)
self._calendar.pack(in_=self, expand=1, fill='both', side='bottom')
def __config_calendar(self):
cols = self._cal.formatweekheader(3).split()
self._calendar['columns'] = cols
self._calendar.tag_configure('header', background='grey90')
self._calendar.insert('', 'end', values=cols, tag='header')
# adjust its columns width
font = tkinter.font.Font()
maxwidth = max(font.measure(col) for col in cols)
for col in cols:
self._calendar.column(col, width=maxwidth, minwidth=maxwidth,
anchor='e')
def __setup_selection(self, sel_bg, sel_fg):
self._font = tkinter.font.Font()
self._canvas = canvas = tk.Canvas(self._calendar,
background=sel_bg, borderwidth=0, highlightthickness=0)
canvas.text = canvas.create_text(0, 0, fill=sel_fg, anchor='w')
canvas.bind('<ButtonPress-1>', lambda evt: canvas.place_forget())
self._calendar.bind('<Configure>', lambda evt: canvas.place_forget())
self._calendar.bind('<ButtonPress-1>', self._pressed)
def __minsize(self, evt):
width, height = self._calendar.master.geometry().split('x')
height = height[:height.index('+')]
self._calendar.master.minsize(width, height)
def _build_calendar(self):
year, month = self._date.year, self._date.month
# update header text (Month, YEAR)
header = self._cal.formatmonthname(year, month, 0)
self._header['text'] = header.title()
# update calendar shown dates
cal = self._cal.monthdayscalendar(year, month)
for indx, item in enumerate(self._items):
week = cal[indx] if indx < len(cal) else []
fmt_week = [('%02d' % day) if day else '' for day in week]
self._calendar.item(item, values=fmt_week)
def _show_selection(self, text, bbox):
"""Configure canvas for a new selection."""
x, y, width, height = bbox
textw = self._font.measure(text)
canvas = self._canvas
canvas.configure(width=width, height=height)
canvas.coords(canvas.text, width - textw, height / 2 - 1)
canvas.itemconfigure(canvas.text, text=text)
canvas.place(in_=self._calendar, x=x, y=y)
# Callbacks
def _pressed(self, evt):
"""Clicked somewhere in the calendar."""
x, y, widget = evt.x, evt.y, evt.widget
item = widget.identify_row(y)
column = widget.identify_column(x)
if not column or not item in self._items:
# clicked in the weekdays row or just outside the columns
return
item_values = widget.item(item)['values']
if not len(item_values): # row is empty for this month
return
text = item_values[int(column[1]) - 1]
if not text: # date is empty
return
bbox = widget.bbox(item, column)
if not bbox: # calendar not visible yet
return
# update and then show selection
text = '%02d' % text
self._selection = (text, item, column)
self._show_selection(text, bbox)
year, month = self._date.year, self._date.month
try:
self._TargetElement.Update(self.datetime(year, month, int(self._selection[0])))
if self._TargetElement.ChangeSubmits:
self._TargetElement.ParentForm.LastButtonClicked = self._TargetElement.Key
self._TargetElement.ParentForm.FormRemainedOpen = True
self._TargetElement.ParentForm.TKroot.quit() # kick the users out of the mainloop
except:
pass
if self.close_when_chosen:
self._master.destroy()
def _prev_month(self):
"""Updated calendar to show the previous month."""
self._canvas.place_forget()
self._date = self._date - self.timedelta(days=1)
self._date = self.datetime(self._date.year, self._date.month, 1)
self._build_calendar() # reconstuct calendar
def _next_month(self):
"""Update calendar to show the next month."""
self._canvas.place_forget()
year, month = self._date.year, self._date.month
self._date = self._date + self.timedelta(
days=calendar.monthrange(year, month)[1] + 1)
self._date = self.datetime(self._date.year, self._date.month, 1)
self._build_calendar() # reconstruct calendar
# Properties
@property
def selection(self):
"""Return a datetime representing the current selected date."""
if not self._selection:
return None
year, month = self._date.year, self._date.month
return self.datetime(year, month, int(self._selection[0]))
# ---------------------------------------------------------------------- #
# Menu #
# ---------------------------------------------------------------------- #
class Menu(Element):
def __init__(self, menu_definition, background_color=None, size=(None, None), tearoff=False, pad=None, key=None, visible=True):
'''
Menu
:param menu_definition:
:param background_color:
:param size:
:param tearoff:
:param pad:
:param key:
:param visible:
'''
self.BackgroundColor = background_color if background_color is not None else DEFAULT_BACKGROUND_COLOR
self.MenuDefinition = menu_definition
self.TKMenu = None
self.Tearoff = tearoff
self.MenuItemChosen = None
super().__init__(ELEM_TYPE_MENUBAR, background_color=background_color, size=size, pad=pad, key=key, visible=visible)
return
def MenuItemChosenCallback(self, item_chosen): # Menu Menu Item Chosen Callback
# print('IN MENU ITEM CALLBACK', item_chosen)
self.MenuItemChosen = item_chosen
self.ParentForm.LastButtonClicked = item_chosen
self.ParentForm.FormRemainedOpen = True
if self.ParentForm.CurrentlyRunningMainloop:
self.ParentForm.TKroot.quit() # kick the users out of the mainloop
def Update(self, menu_definition, visible=None):
self.MenuDefinition = menu_definition
self.TKMenu = tk.Menu(self.ParentForm.TKroot, tearoff=self.Tearoff) # create the menubar
menubar = self.TKMenu
for menu_entry in menu_definition:
# print(f'Adding a Menubar ENTRY {menu_entry}')
baritem = tk.Menu(menubar, tearoff=self.Tearoff)
pos = menu_entry[0].find('&')
# print(pos)
if pos != -1:
if pos == 0 or menu_entry[0][pos - 1] != "\\":
menu_entry[0] = menu_entry[0][:pos] + menu_entry[0][pos + 1:]
if menu_entry[0][0] == MENU_DISABLED_CHARACTER:
menubar.add_cascade(label=menu_entry[0][len(MENU_DISABLED_CHARACTER):], menu=baritem, underline=pos)
menubar.entryconfig(menu_entry[0][len(MENU_DISABLED_CHARACTER):], state='disabled')
else:
menubar.add_cascade(label=menu_entry[0], menu=baritem, underline=pos)
if len(menu_entry) > 1:
AddMenuItem(baritem, menu_entry[1], self)
self.ParentForm.TKroot.configure(menu=self.TKMenu)
#TODO add visible code for menus
def __del__(self):
super().__del__()
MenuBar = Menu # another name for Menu to make it clear it's the Menu Bar
# ---------------------------------------------------------------------- #
# Table #
# ---------------------------------------------------------------------- #
class Table(Element):
def __init__(self, values, headings=None, visible_column_map=None, col_widths=None, def_col_width=10,
auto_size_columns=True, max_col_width=20, select_mode=None, display_row_numbers=False, num_rows=None, row_height=None, font=None, justification='right', text_color=None, background_color=None, alternating_row_color=None, row_colors=None, vertical_scroll_only=True,
size=(None, None), change_submits=False, enable_events=False, bind_return_key=False, pad=None, key=None, tooltip=None, right_click_menu=None, visible=True):
'''
Table
:param values:
:param headings:
:param visible_column_map:
:param col_widths:
:param def_col_width:
:param auto_size_columns:
:param max_col_width:
:param select_mode:
:param display_row_numbers:
:param num_rows:
:param row_height:
:param font:
:param justification:
:param text_color:
:param background_color:
:param alternating_row_color:
:param size:
:param change_submits:
:param enable_events:
:param bind_return_key:
:param pad:
:param key:
:param tooltip:
:param right_click_menu:
:param visible:
'''
self.Values = values
self.ColumnHeadings = headings
self.ColumnsToDisplay = visible_column_map
self.ColumnWidths = col_widths
self.MaxColumnWidth = max_col_width
self.DefaultColumnWidth = def_col_width
self.AutoSizeColumns = auto_size_columns
self.BackgroundColor = background_color if background_color is not None else DEFAULT_BACKGROUND_COLOR
self.TextColor = text_color
self.Justification = justification
self.InitialState = None
self.SelectMode = select_mode
self.DisplayRowNumbers = display_row_numbers
self.NumRows = num_rows if num_rows is not None else size[1]
self.RowHeight = row_height
self.TKTreeview = None
self.AlternatingRowColor = alternating_row_color
self.VerticalScrollOnly = vertical_scroll_only
self.SelectedRows = []
self.ChangeSubmits = change_submits or enable_events
self.BindReturnKey = bind_return_key
self.StartingRowNumber = 0 # When displaying row numbers, where to start
self.RowHeaderText = 'Row'
self.RightClickMenu = right_click_menu
self.RowColors = row_colors
super().__init__(ELEM_TYPE_TABLE, text_color=text_color, background_color=background_color, font=font,
size=size, pad=pad, key=key, tooltip=tooltip, visible=visible)
return
def Update(self, values=None, num_rows=None, visible=None):
if values is not None:
children = self.TKTreeview.get_children()
for i in children:
self.TKTreeview.detach(i)
self.TKTreeview.delete(i)
children = self.TKTreeview.get_children()
# self.TKTreeview.delete(*self.TKTreeview.get_children())
for i, value in enumerate(values):
if self.DisplayRowNumbers:
value = [i+self.StartingRowNumber] + value
id = self.TKTreeview.insert('', 'end', text=i, iid=i + 1, values=value, tag=i % 2)
if self.AlternatingRowColor is not None:
self.TKTreeview.tag_configure(1, background=self.AlternatingRowColor)
self.Values = values
self.SelectedRows = []
if visible is False:
self.TKTreeview.pack_forget()
elif visible is True:
self.TKTreeview.pack()
if num_rows is not None:
self.TKTreeview.config(height=num_rows)
def treeview_selected(self, event):
selections = self.TKTreeview.selection()
self.SelectedRows = [int(x) - 1 for x in selections]
if self.ChangeSubmits:
MyForm = self.ParentForm
if self.Key is not None:
self.ParentForm.LastButtonClicked = self.Key
else:
self.ParentForm.LastButtonClicked = ''
self.ParentForm.FormRemainedOpen = True
if self.ParentForm.CurrentlyRunningMainloop:
self.ParentForm.TKroot.quit()
def treeview_double_click(self, event):
selections = self.TKTreeview.selection()
self.SelectedRows = [int(x) - 1 for x in selections]
if self.BindReturnKey:
MyForm = self.ParentForm
if self.Key is not None:
self.ParentForm.LastButtonClicked = self.Key
else:
self.ParentForm.LastButtonClicked = ''
self.ParentForm.FormRemainedOpen = True
if self.ParentForm.CurrentlyRunningMainloop:
self.ParentForm.TKroot.quit()
def __del__(self):
super().__del__()
# ---------------------------------------------------------------------- #
# Tree #
# ---------------------------------------------------------------------- #
class Tree(Element):
def __init__(self, data=None, headings=None, visible_column_map=None, col_widths=None, col0_width=10,
def_col_width=10, auto_size_columns=True, max_col_width=20, select_mode=None, show_expanded=False, change_submits=False, enable_events=False, font=None, justification='right', text_color=None, background_color=None, num_rows=None, row_height=None, pad=None, key=None, tooltip=None,right_click_menu=None, visible=True):
'''
Tree
:param data:
:param headings:
:param visible_column_map:
:param col_widths:
:param col0_width:
:param def_col_width:
:param auto_size_columns:
:param max_col_width:
:param select_mode:
:param show_expanded:
:param change_submits:
:param enable_events:
:param font:
:param justification:
:param text_color:
:param background_color:
:param num_rows:
:param pad:
:param key:
:param tooltip:
:param right_click_menu:
:param visible:
'''
self.TreeData = data
self.ColumnHeadings = headings
self.ColumnsToDisplay = visible_column_map
self.ColumnWidths = col_widths
self.MaxColumnWidth = max_col_width
self.DefaultColumnWidth = def_col_width
self.AutoSizeColumns = auto_size_columns
self.BackgroundColor = background_color if background_color is not None else DEFAULT_BACKGROUND_COLOR
self.TextColor = text_color
self.Justification = justification
self.InitialState = None
self.SelectMode = select_mode
self.ShowExpanded = show_expanded
self.NumRows = num_rows
self.Col0Width = col0_width
self.TKTreeview = None
self.SelectedRows = []
self.ChangeSubmits = change_submits or enable_events
self.RightClickMenu = right_click_menu
self.RowHeight = row_height
self.IconList = {}
super().__init__(ELEM_TYPE_TREE, text_color=text_color, background_color=background_color, font=font, pad=pad,
key=key, tooltip=tooltip, visible=visible)
return
def treeview_open(self, event):
self.SelectedRows = [self.TKTreeview.focus()]
if self.ChangeSubmits:
MyForm = self.ParentForm
# if self.Key is not None:
# self.ParentForm.LastButtonClicked = self.Key + '_EXPAND_'
# else:
# self.ParentForm.LastButtonClicked = '_EXPAND_'
self.ParentForm.FormRemainedOpen = True
if self.ParentForm.CurrentlyRunningMainloop:
self.ParentForm.TKroot.quit()
def treeview_close(self, event):
self.SelectedRows = [self.TKTreeview.focus()]
if self.ChangeSubmits:
MyForm = self.ParentForm
# if self.Key is not None:
# self.ParentForm.LastButtonClicked = self.Key + '_COLLAPSE_'
# else:
# self.ParentForm.LastButtonClicked = '_COLLAPSE_'
self.ParentForm.FormRemainedOpen = True
if self.ParentForm.CurrentlyRunningMainloop:
self.ParentForm.TKroot.quit()
def treeview_selected(self, event):
selections = self.TKTreeview.selection()
self.SelectedRows = [x for x in selections]
if self.ChangeSubmits:
MyForm = self.ParentForm
if self.Key is not None:
self.ParentForm.LastButtonClicked = self.Key
else:
self.ParentForm.LastButtonClicked = ''
self.ParentForm.FormRemainedOpen = True
if self.ParentForm.CurrentlyRunningMainloop:
self.ParentForm.TKroot.quit()
def add_treeview_data(self, node):
# print(f'Inserting {node.key} under parent {node.parent}')
if node.key != '':
if node.icon:
try:
if type(node.icon) is bytes:
photo = tk.PhotoImage(data=node.icon)
else:
photo = tk.PhotoImage(file=node.icon)
node.photo = photo
self.TKTreeview.insert(node.parent, 'end', node.key, text=node.text, values=node.values,
open=self.ShowExpanded, image=node.photo)
except:
self.photo = None
else:
self.TKTreeview.insert(node.parent, 'end', node.key, text=node.text, values=node.values,
open=self.ShowExpanded)
for node in node.children:
self.add_treeview_data(node)
def Insert(self, parent_key, key, text=None, value=None, icon=None, visible=None):
self.TreeData.Insert(parent_key, key, text, value, icon)
node = self.TreeData.tree_dict[key]
self.add_treeview_data(node)
if visible is False:
self.TKTreeview.pack_forget()
elif visible is True:
self.TKTreeview.pack()
return self
def Delete(self, key):
self.TreeData.Delete(key)
self.TKTreeview.detach(key)
self.TKTreeview.delete(key)
def Update(self, values=None, key=None, value=None, text=None, icon=None, visible=None):
if values is not None:
children = self.TKTreeview.get_children()
for i in children:
self.TKTreeview.detach(i)
self.TKTreeview.delete(i)
children = self.TKTreeview.get_children()
self.TreeData = values
self.add_treeview_data(self.TreeData.root_node)
self.SelectedRows = []
if key is not None:
item = self.TKTreeview.item(key)
if value is not None:
self.TKTreeview.item(key, values=value)
if text is not None:
self.TKTreeview.item(key, text=text)
if icon is not None:
try:
if type(icon) is bytes:
photo = tk.PhotoImage(data=icon)
else:
photo = tk.PhotoImage(file=icon)
self.TKTreeview.item(key, image=photo)
self.IconList[key] = photo # save so that it's not deleted (save reference)
except:
pass
item = self.TKTreeview.item(key)
if visible is False:
self.TKTreeview.pack_forget()
elif visible is True:
self.TKTreeview.pack()
return self
def __del__(self):
super().__del__()
class TreeData(object):
class Node(object):
def __init__(self, parent, key, text, values, icon=None):
self.parent = parent
self.children = []
self.key = key
self.text = text
self.values = values
self.icon = icon
def _Add(self, node):
self.children.append(node)
def _Del(self, node):
self.children.remove(node)
def __init__(self):
self.tree_dict = {}
self.root_node = self.Node("", "", 'root', [], None)
self.tree_dict[""] = self.root_node
def _AddNode(self, key, node):
self.tree_dict[key] = node
def Insert(self, parent, key, text, values, icon=None):
node = self.Node(parent, key, text, values, icon)
self.tree_dict[key] = node
parent_node = self.tree_dict[parent]
parent_node._Add(node)
def Delete(self, key):
node = self.tree_dict[key]
self.tree_dict[node.parent]._Del(node)
del self.tree_dict[node.key]
def __repr__(self):
return self._NodeStr(self.root_node, 1)
def _NodeStr(self, node, level):
return '\n'.join(
[str(node.key) + ' : ' + str(node.text)] +
[' ' * 4 * level + self._NodeStr(child, level + 1) for child in node.children])
# ---------------------------------------------------------------------- #
# Error Element #
# ---------------------------------------------------------------------- #
class ErrorElement(Element):
def __init__(self, key=None):
'''
Error Element
:param key:
'''
self.Key = key
super().__init__(ELEM_TYPE_ERROR, key=key)
return
def Update(self, *args, **kwargs):
PopupError('Keyword error in Update',
'You need to stop this madness and check your spelling',
'Bad key = {}'.format(self.Key),
'Your bad line of code may resemble this:',
'window.FindElement("{}")'.format(self.Key))
return self
def Get(self):
return 'This is NOT a valid Element!\nSTOP trying to do things with it or I will have to crash at some point!'
def __del__(self):
super().__del__()
# ---------------------------------------------------------------------- #
# Stretch Element #
# ---------------------------------------------------------------------- #
# This is for source code compatibility with tkinter version. No tkinter equivalent
Stretch = ErrorElement
# ------------------------------------------------------------------------- #
# Window CLASS #
# ------------------------------------------------------------------------- #
class Window:
NumOpenWindows = 0
user_defined_icon = None
hidden_master_root = None
animated_popup_dict = {}
def __init__(self, title, default_element_size=DEFAULT_ELEMENT_SIZE, default_button_element_size=(None, None),
auto_size_text=None, auto_size_buttons=None, location=(None, None), size=(None, None), element_padding=None, margins=(None, None), button_color=None, font=None,
progress_bar_color=(None, None), background_color=None, border_depth=None, auto_close=False,
auto_close_duration=DEFAULT_AUTOCLOSE_TIME, icon=DEFAULT_WINDOW_ICON, force_toplevel=False,
alpha_channel=1, return_keyboard_events=False, use_default_focus=True, text_justification=None,
no_titlebar=False, grab_anywhere=False, keep_on_top=False, resizable=False, disable_close=False, disable_minimize=False, right_click_menu=None):
'''
Window
:param title:
:param default_element_size:
:param default_button_element_size:
:param auto_size_text:
:param auto_size_buttons:
:param location:
:param size:
:param element_padding:
:param button_color:
:param font:
:param progress_bar_color:
:param background_color:
:param border_depth:
:param auto_close:
:param auto_close_duration:
:param icon:
:param force_toplevel:
:param alpha_channel:
:param return_keyboard_events:
:param use_default_focus:
:param text_justification:
:param no_titlebar:
:param grab_anywhere:
:param keep_on_top:
:param resizable:
:param disable_close:
:param disable_minimize:
:param right_click_menu:
'''
self.AutoSizeText = auto_size_text if auto_size_text is not None else DEFAULT_AUTOSIZE_TEXT
self.AutoSizeButtons = auto_size_buttons if auto_size_buttons is not None else DEFAULT_AUTOSIZE_BUTTONS
self.Title = title
self.Rows = [] # a list of ELEMENTS for this row
self.DefaultElementSize = default_element_size
self.DefaultButtonElementSize = default_button_element_size if default_button_element_size != (
None, None) else DEFAULT_BUTTON_ELEMENT_SIZE
self.Location = location
self.ButtonColor = button_color if button_color else DEFAULT_BUTTON_COLOR
self.BackgroundColor = background_color if background_color else DEFAULT_BACKGROUND_COLOR
self.ParentWindow = None
self.Font = font if font else DEFAULT_FONT
self.RadioDict = {}
self.BorderDepth = border_depth
self.WindowIcon = Window.user_defined_icon if Window.user_defined_icon is not None else icon if icon is not None else DEFAULT_WINDOW_ICON
self.AutoClose = auto_close
self.NonBlocking = False
self.TKroot = None
self.TKrootDestroyed = False
self.CurrentlyRunningMainloop = False
self.FormRemainedOpen = False
self.TKAfterID = None
self.ProgressBarColor = progress_bar_color
self.AutoCloseDuration = auto_close_duration
self.RootNeedsDestroying = False
self.Shown = False
self.ReturnValues = None
self.ReturnValuesList = []
self.ReturnValuesDictionary = {}
self.DictionaryKeyCounter = 0
self.LastButtonClicked = None
self.LastButtonClickedWasRealtime = False
self.UseDictionary = False
self.UseDefaultFocus = use_default_focus
self.ReturnKeyboardEvents = return_keyboard_events
self.LastKeyboardEvent = None
self.TextJustification = text_justification
self.NoTitleBar = no_titlebar
self.GrabAnywhere = grab_anywhere
self.KeepOnTop = keep_on_top
self.ForceTopLevel = force_toplevel
self.Resizable = resizable
self._AlphaChannel = alpha_channel
self.Timeout = None
self.TimeoutKey = '_timeout_'
self.TimerCancelled = False
self.DisableClose = disable_close
self.DisableMinimize = disable_minimize
self._Hidden = False
self._Size = size
self.XFound = False
self.ElementPadding = element_padding or DEFAULT_ELEMENT_PADDING
self.RightClickMenu = right_click_menu
self.Margins = margins if margins != (None, None) else DEFAULT_MARGINS
@classmethod
def IncrementOpenCount(self):
self.NumOpenWindows += 1
# print('+++++ INCREMENTING Num Open Windows = {} ---'.format(Window.NumOpenWindows))
@classmethod
def DecrementOpenCount(self):
self.NumOpenWindows -= 1 * (self.NumOpenWindows != 0) # decrement if not 0
# print('----- DECREMENTING Num Open Windows = {} ---'.format(Window.NumOpenWindows))
# ------------------------- Add ONE Row to Form ------------------------- #
def AddRow(self, *args):
''' Parms are a variable number of Elements '''
NumRows = len(self.Rows) # number of existing rows is our row number
CurrentRowNumber = NumRows # this row's number
CurrentRow = [] # start with a blank row and build up
# ------------------------- Add the elements to a row ------------------------- #
for i, element in enumerate(args): # Loop through list of elements and add them to the row
element.Position = (CurrentRowNumber, i)
element.ParentContainer = self
CurrentRow.append(element)
# ------------------------- Append the row to list of Rows ------------------------- #
self.Rows.append(CurrentRow)
# ------------------------- Add Multiple Rows to Form ------------------------- #
def AddRows(self, rows):
for row in rows:
self.AddRow(*row)
def Layout(self, rows):
self.AddRows(rows)
return self
def LayoutAndRead(self, rows, non_blocking=False):
raise DeprecationWarning('LayoutAndRead is no longer supported... change your call window.Layout(layout).Read()')
# self.AddRows(rows)
# self.Show(non_blocking=non_blocking)
# return self.ReturnValues
def LayoutAndShow(self, rows):
raise DeprecationWarning('LayoutAndShow is no longer supported... ')
# ------------------------- ShowForm THIS IS IT! ------------------------- #
def Show(self, non_blocking=False):
self.Shown = True
# Compute num rows & num cols (it'll come in handy debugging)
self.NumRows = len(self.Rows)
self.NumCols = max(len(row) for row in self.Rows)
self.NonBlocking = non_blocking
# Search through entire form to see if any elements set the focus
# if not, then will set the focus to the first input element
found_focus = False
for row in self.Rows:
for element in row:
try:
if element.Focus:
found_focus = True
except:
pass
try:
if element.Key is not None:
self.UseDictionary = True
except:
pass
if not found_focus and self.UseDefaultFocus:
self.UseDefaultFocus = True
else:
self.UseDefaultFocus = False
# -=-=-=-=-=-=-=-=- RUN the GUI -=-=-=-=-=-=-=-=- ##
StartupTK(self)
# If a button or keyboard event happened but no results have been built, build the results
if self.LastKeyboardEvent is not None or self.LastButtonClicked is not None:
return BuildResults(self, False, self)
return self.ReturnValues
# ------------------------- SetIcon - set the window's fav icon ------------------------- #
def SetIcon(self, icon=None, pngbase64=None):
if type(icon) is bytes:
wicon = tkinter.PhotoImage(data=icon)
try:
self.TKroot.tk.call('wm', 'iconphoto', self.TKroot._w, wicon)
except: pass
elif pngbase64 != None:
wicon = tkinter.PhotoImage(data=pngbase64)
try:
self.TKroot.tk.call('wm', 'iconphoto', self.TKroot._w, wicon)
except: pass
else:
wicon = icon
self.WindowIcon = wicon
try:
self.TKroot.iconbitmap(wicon)
except:
pass
def _GetElementAtLocation(self, location):
(row_num, col_num) = location
row = self.Rows[row_num]
element = row[col_num]
return element
def _GetDefaultElementSize(self):
return self.DefaultElementSize
def _AutoCloseAlarmCallback(self):
try:
window = self
if window:
if window.NonBlocking:
self.CloseNonBlockingForm()
else:
window._Close()
self.TKroot.quit()
self.RootNeedsDestroying = True
except:
pass
def _TimeoutAlarmCallback(self):
# first, get the results table built
# modify the Results table in the parent FlexForm object
# print('TIMEOUT CALLBACK')
if self.TimerCancelled:
# print('** timer was cancelled **')
return
self.LastButtonClicked = self.TimeoutKey
self.FormRemainedOpen = True
self.TKroot.quit() # kick the users out of the mainloop
def Read(self, timeout=None, timeout_key=TIMEOUT_KEY):
if timeout == 0: # timeout of zero runs the old readnonblocking
event, values = self.ReadNonBlocking()
if event is None:
event = timeout_key
if values is None:
event = None
return event, values # make event None if values was None and return
# Read with a timeout
self.Timeout = timeout
self.TimeoutKey = timeout_key
self.NonBlocking = False
if self.TKrootDestroyed:
return None, None
if not self.Shown:
self.Show()
else:
# if already have a button waiting, the return previously built results
if self.LastButtonClicked is not None and not self.LastButtonClickedWasRealtime:
# print(f'*** Found previous clicked saved {self.LastButtonClicked}')
results = BuildResults(self, False, self)
self.LastButtonClicked = None
return results
InitializeResults(self)
# if the last button clicked was realtime, emulate a read non-blocking
# the idea is to quickly return realtime buttons without any blocks until released
if self.LastButtonClickedWasRealtime:
self.LastButtonClickedWasRealtime = False # stops from generating events until something changes
# print(f'RTime down {self.LastButtonClicked}' )
try:
rc = self.TKroot.update()
except:
self.TKrootDestroyed = True
Window.DecrementOpenCount()
# _my_windows.Decrement()
# print('ROOT Destroyed')
results = BuildResults(self, False, self)
if results[0] != None and results[0] != timeout_key:
return results
else:
pass
# else:
# print("** REALTIME PROBLEM FOUND **", results)
if self.RootNeedsDestroying:
# print('*** DESTROYING really late***')
self.TKroot.destroy()
# _my_windows.Decrement()
self.LastButtonClicked = None
return None, None
# normal read blocking code....
if timeout != None:
self.TimerCancelled = False
self.TKAfterID = self.TKroot.after(timeout, self._TimeoutAlarmCallback)
self.CurrentlyRunningMainloop = True
# print(f'In main {self.Title} {self.TKroot}')
self.TKroot.protocol("WM_DESTROY_WINDOW", self.OnClosingCallback)
self.TKroot.protocol("WM_DELETE_WINDOW", self.OnClosingCallback)
self.TKroot.mainloop()
# print('Out main')
self.CurrentlyRunningMainloop = False
# if self.LastButtonClicked != TIMEOUT_KEY:
# print(f'Window {self.Title} Last button clicked = {self.LastButtonClicked}')
try:
self.TKroot.after_cancel(self.TKAfterID)
except:
pass
# print('** tkafter cancel failed **')
self.TimerCancelled = True
if self.RootNeedsDestroying:
# print('*** DESTROYING LATE ***')
self.TKroot.destroy()
Window.DecrementOpenCount()
# _my_windows.Decrement()
self.LastButtonClicked = None
return None, None
# if form was closed with X
if self.LastButtonClicked is None and self.LastKeyboardEvent is None and self.ReturnValues[0] is None:
Window.DecrementOpenCount()
# _my_windows.Decrement()
# Determine return values
if self.LastKeyboardEvent is not None or self.LastButtonClicked is not None:
results = BuildResults(self, False, self)
if not self.LastButtonClickedWasRealtime:
self.LastButtonClicked = None
return results
else:
if not self.XFound and self.Timeout != 0 and self.Timeout is not None and self.ReturnValues[
0] is None: # Special Qt case because returning for no reason so fake timeout
self.ReturnValues = self.TimeoutKey, self.ReturnValues[1] # fake a timeout
elif not self.XFound and self.ReturnValues[0] is None: # TODO HIGHLY EXPERIMENTAL... added due to tray icon interaction
# print("*** Faking timeout ***")
self.ReturnValues = self.TimeoutKey, self.ReturnValues[1] # fake a timeout
return self.ReturnValues
def ReadNonBlocking(self):
if self.TKrootDestroyed:
try:
self.TKroot.quit()
self.TKroot.destroy()
except:
pass
# print('DESTROY FAILED')
return None, None
if not self.Shown:
self.Show(non_blocking=True)
try:
rc = self.TKroot.update()
except:
self.TKrootDestroyed = True
Window.DecrementOpenCount()
# _my_windows.Decrement()
# print("read failed")
# return None, None
if self.RootNeedsDestroying:
# print('*** DESTROYING LATE ***', self.ReturnValues)
self.TKroot.destroy()
Window.DecrementOpenCount()
# _my_windows.Decrement()
self.Values = None
self.LastButtonClicked = None
return None, None
return BuildResults(self, False, self)
def Finalize(self):
if self.TKrootDestroyed:
return self
if not self.Shown:
self.Show(non_blocking=True)
try:
rc = self.TKroot.update()
except:
self.TKrootDestroyed = True
Window.DecrementOpenCount()
# _my_windows.Decrement()
# return None, None
return self
def Refresh(self):
if self.TKrootDestroyed:
return self
try:
rc = self.TKroot.update()
except:
pass
return self
def Fill(self, values_dict):
FillFormWithValues(self, values_dict)
return self
def FindElement(self, key, silent_on_error=False):
element = _FindElementFromKeyInSubForm(self, key)
if element is None:
if not silent_on_error:
print('*** WARNING = FindElement did not find the key. Please check your key\'s spelling ***')
PopupError('Keyword error in FindElement Call',
'Bad key = {}'.format(key),
'Your bad line of code may resemble this:',
'window.FindElement("{}")'.format(key))
return ErrorElement(key=key)
else:
return False
return element
Element = FindElement # Shortcut function
def FindElementWithFocus(self):
element = _FindElementWithFocusInSubForm(self)
return element
def SaveToDisk(self, filename):
try:
results = BuildResults(self, False, self)
with open(filename, 'wb') as sf:
pickle.dump(results[1], sf)
except:
print('*** Error saving form to disk ***')
def LoadFromDisk(self, filename):
try:
with open(filename, 'rb') as df:
self.Fill(pickle.load(df))
except:
print('*** Error loading form to disk ***')
def GetScreenDimensions(self):
if self.TKrootDestroyed:
return None, None
screen_width = self.TKroot.winfo_screenwidth() # get window info to move to middle of screen
screen_height = self.TKroot.winfo_screenheight()
return screen_width, screen_height
def Move(self, x, y):
try:
self.TKroot.geometry("+%s+%s" % (x, y))
except:
pass
def Minimize(self):
self.TKroot.iconify()
def Maximize(self):
self.TKroot.attributes('-fullscreen', True)
def StartMove(self, event):
try:
self.TKroot.x = event.x
self.TKroot.y = event.y
except:
pass
def StopMove(self, event):
try:
self.TKroot.x = None
self.TKroot.y = None
except:
pass
def OnMotion(self, event):
try:
deltax = event.x - self.TKroot.x
deltay = event.y - self.TKroot.y
x = self.TKroot.winfo_x() + deltax
y = self.TKroot.winfo_y() + deltay
self.TKroot.geometry("+%s+%s" % (x, y))
except:
pass
def _KeyboardCallback(self, event):
self.LastButtonClicked = None
self.FormRemainedOpen = True
if event.char != '':
self.LastKeyboardEvent = event.char
else:
self.LastKeyboardEvent = str(event.keysym) + ':' + str(event.keycode)
if not self.NonBlocking:
BuildResults(self, False, self)
if self.CurrentlyRunningMainloop: # quit if this is the current mainloop, otherwise don't quit!
self.TKroot.quit()
def _MouseWheelCallback(self, event):
self.LastButtonClicked = None
self.FormRemainedOpen = True
self.LastKeyboardEvent = 'MouseWheel:Down' if event.delta < 0 else 'MouseWheel:Up'
if not self.NonBlocking:
BuildResults(self, False, self)
if self.CurrentlyRunningMainloop: # quit if this is the current mainloop, otherwise don't quit!
self.TKroot.quit()
def _Close(self):
try:
self.TKroot.update()
except:
pass
if not self.NonBlocking:
BuildResults(self, False, self)
if self.TKrootDestroyed:
return None
self.TKrootDestroyed = True
self.RootNeedsDestroying = True
return None
def Close(self):
if self.TKrootDestroyed:
return
try:
self.TKroot.destroy()
Window.DecrementOpenCount()
# _my_windows.Decrement()
except:
pass
CloseNonBlockingForm = Close
CloseNonBlocking = Close
# IT FINALLY WORKED! 29-Oct-2018 was the first time this damned thing got called
def OnClosingCallback(self):
# global _my_windows
# print('Got closing callback', self.DisableClose)
if self.DisableClose:
return
self.XFound = True
if self.CurrentlyRunningMainloop: # quit if this is the current mainloop, otherwise don't quit!
self.TKroot.quit() # kick the users out of the mainloop
self.TKroot.destroy() # kick the users out of the mainloop
self.RootNeedsDestroying = True
self.TKrootDestroyed = True
else:
self.TKroot.destroy() # kick the users out of the mainloop
self.RootNeedsDestroying = True
self.RootNeedsDestroying = True
return
def Disable(self):
self.TKroot.grab_set_global()
def Enable(self):
self.TKroot.grab_release()
def Hide(self):
self._Hidden = True
self.TKroot.withdraw()
def UnHide(self):
if self._Hidden:
self.TKroot.deiconify()
self._Hidden = False
def Disappear(self):
self.TKroot.attributes('-alpha', 0)
def Reappear(self):
self.TKroot.attributes('-alpha', 255)
def SetAlpha(self, alpha):
'''
Change the window's transparency
:param alpha: From 0 to 1 with 0 being completely transparent
:return:
'''
self._AlphaChannel = alpha
self.TKroot.attributes('-alpha', alpha)
@property
def AlphaChannel(self):
return self._AlphaChannel
@AlphaChannel.setter
def AlphaChannel(self, alpha):
self._AlphaChannel = alpha
self.TKroot.attributes('-alpha', alpha)
def BringToFront(self):
try:
self.TKroot.lift()
except:
pass
def CurrentLocation(self):
return int(self.TKroot.winfo_x()), int(self.TKroot.winfo_y())
@property
def Size(self):
win_width = self.TKroot.winfo_width()
win_height = self.TKroot.winfo_height()
return win_width, win_height
@Size.setter
def Size(self, size):
try:
self.TKroot.geometry("%sx%s" % (size[0], size[1]))
self.TKroot.update_idletasks()
except:
pass
def VisibilityChanged(self):
# A dummy function. Needed in Qt but not tkinter
return
def __enter__(self):
return self
def __exit__(self, *a):
self.__del__()
return False
def __del__(self):
# print('DELETING WINDOW')
for row in self.Rows:
for element in row:
element.__del__()
FlexForm = Window
# ################################################################################
# ################################################################################
# END OF ELEMENT DEFINITIONS
# ################################################################################
# ################################################################################
# =========================================================================== #
# Button Lazy Functions so the caller doesn't have to define a bunch of stuff #
# =========================================================================== #
# ------------------------- FOLDER BROWSE Element lazy function ------------------------- #
def FolderBrowse(button_text='Browse', target=(ThisRow, -1), initial_folder=None, tooltip=None, size=(None, None),
auto_size_button=None, button_color=None, disabled=False, change_submits=False, enable_events=False,font=None, pad=None, key=None):
return Button(button_text=button_text, button_type=BUTTON_TYPE_BROWSE_FOLDER, target=target,
initial_folder=initial_folder, tooltip=tooltip, size=size, auto_size_button=auto_size_button,
disabled=disabled, button_color=button_color,change_submits=change_submits, enable_events=enable_events, font=font, pad=pad, key=key)
# ------------------------- FILE BROWSE Element lazy function ------------------------- #
def FileBrowse(button_text='Browse', target=(ThisRow, -1), file_types=(("ALL Files", "*.*"),), initial_folder=None,
tooltip=None, size=(None, None), auto_size_button=None, button_color=None, change_submits=False, enable_events=False, font=None, disabled=False,
pad=None, key=None):
return Button(button_text=button_text, button_type=BUTTON_TYPE_BROWSE_FILE, target=target, file_types=file_types,
initial_folder=initial_folder, tooltip=tooltip, size=size, auto_size_button=auto_size_button, change_submits=change_submits, enable_events=enable_events, disabled=disabled, button_color=button_color, font=font, pad=pad, key=key)
# ------------------------- FILES BROWSE Element (Multiple file selection) lazy function ------------------------- #
def FilesBrowse(button_text='Browse', target=(ThisRow, -1), file_types=(("ALL Files", "*.*"),), disabled=False,
initial_folder=None, tooltip=None, size=(None, None), auto_size_button=None, button_color=None, change_submits=False,enable_events=False,
font=None, pad=None, key=None):
return Button(button_text=button_text, button_type=BUTTON_TYPE_BROWSE_FILES, target=target, file_types=file_types,
initial_folder=initial_folder,change_submits=change_submits, enable_events=enable_events, tooltip=tooltip, size=size, auto_size_button=auto_size_button,
disabled=disabled, button_color=button_color, font=font, pad=pad, key=key)
# ------------------------- FILE BROWSE Element lazy function ------------------------- #
def FileSaveAs(button_text='Save As...', target=(ThisRow, -1), file_types=(("ALL Files", "*.*"),), initial_folder=None,
disabled=False, tooltip=None, size=(None, None), auto_size_button=None, button_color=None, change_submits=False, enable_events=False, font=None,
pad=None, key=None):
return Button(button_text=button_text, button_type=BUTTON_TYPE_SAVEAS_FILE, target=target, file_types=file_types,
initial_folder=initial_folder, tooltip=tooltip, size=size, disabled=disabled,
auto_size_button=auto_size_button, button_color=button_color, change_submits=change_submits, enable_events=enable_events, font=font, pad=pad, key=key)
# ------------------------- SAVE AS Element lazy function ------------------------- #
def SaveAs(button_text='Save As...', target=(ThisRow, -1), file_types=(("ALL Files", "*.*"),), initial_folder=None,
disabled=False, tooltip=None, size=(None, None), auto_size_button=None, button_color=None, change_submits=False, enable_events=False, font=None,
pad=None, key=None):
return Button(button_text=button_text, button_type=BUTTON_TYPE_SAVEAS_FILE, target=target, file_types=file_types,
initial_folder=initial_folder, tooltip=tooltip, size=size, disabled=disabled,
auto_size_button=auto_size_button, button_color=button_color, change_submits=change_submits, enable_events=enable_events,font=font, pad=pad, key=key)
# ------------------------- SAVE BUTTON Element lazy function ------------------------- #
def Save(button_text='Save', size=(None, None), auto_size_button=None, button_color=None, bind_return_key=True,
disabled=False, tooltip=None, font=None, focus=False, pad=None, key=None):
return Button(button_text=button_text, button_type=BUTTON_TYPE_READ_FORM, tooltip=tooltip, size=size,
auto_size_button=auto_size_button, button_color=button_color, font=font, disabled=disabled,
bind_return_key=bind_return_key, focus=focus, pad=pad, key=key)
# ------------------------- SUBMIT BUTTON Element lazy function ------------------------- #
def Submit(button_text='Submit', size=(None, None), auto_size_button=None, button_color=None, disabled=False,
bind_return_key=True, tooltip=None, font=None, focus=False, pad=None, key=None):
return Button(button_text=button_text, button_type=BUTTON_TYPE_READ_FORM, tooltip=tooltip, size=size,
auto_size_button=auto_size_button, button_color=button_color, font=font, disabled=disabled,
bind_return_key=bind_return_key, focus=focus, pad=pad, key=key)
# ------------------------- OPEN BUTTON Element lazy function ------------------------- #
# ------------------------- OPEN BUTTON Element lazy function ------------------------- #
def Open(button_text='Open', size=(None, None), auto_size_button=None, button_color=None, disabled=False,
bind_return_key=True, tooltip=None, font=None, focus=False, pad=None, key=None):
return Button(button_text=button_text, button_type=BUTTON_TYPE_READ_FORM, tooltip=tooltip, size=size,
auto_size_button=auto_size_button, button_color=button_color, font=font, disabled=disabled,
bind_return_key=bind_return_key, focus=focus, pad=pad, key=key)
# ------------------------- OK BUTTON Element lazy function ------------------------- #
def OK(button_text='OK', size=(None, None), auto_size_button=None, button_color=None, disabled=False,
bind_return_key=True, tooltip=None, font=None, focus=False, pad=None, key=None):
return Button(button_text=button_text, button_type=BUTTON_TYPE_READ_FORM, tooltip=tooltip, size=size,
auto_size_button=auto_size_button, button_color=button_color, font=font, disabled=disabled,
bind_return_key=bind_return_key, focus=focus, pad=pad, key=key)
# ------------------------- YES BUTTON Element lazy function ------------------------- #
def Ok(button_text='Ok', size=(None, None), auto_size_button=None, button_color=None, disabled=False,
bind_return_key=True, tooltip=None, font=None, focus=False, pad=None, key=None):
return Button(button_text=button_text, button_type=BUTTON_TYPE_READ_FORM, tooltip=tooltip, size=size,
auto_size_button=auto_size_button, button_color=button_color, font=font, disabled=disabled,
bind_return_key=bind_return_key, focus=focus, pad=pad, key=key)
# ------------------------- CANCEL BUTTON Element lazy function ------------------------- #
def Cancel(button_text='Cancel', size=(None, None), auto_size_button=None, button_color=None, disabled=False,
tooltip=None, font=None, bind_return_key=False, focus=False, pad=None, key=None):
return Button(button_text=button_text, button_type=BUTTON_TYPE_READ_FORM, tooltip=tooltip, size=size,
auto_size_button=auto_size_button, button_color=button_color, font=font, disabled=disabled,
bind_return_key=bind_return_key, focus=focus, pad=pad, key=key)
# ------------------------- QUIT BUTTON Element lazy function ------------------------- #
def Quit(button_text='Quit', size=(None, None), auto_size_button=None, button_color=None, disabled=False, tooltip=None,
font=None, bind_return_key=False, focus=False, pad=None, key=None):
return Button(button_text=button_text, button_type=BUTTON_TYPE_READ_FORM, tooltip=tooltip, size=size,
auto_size_button=auto_size_button, button_color=button_color, font=font, disabled=disabled,
bind_return_key=bind_return_key, focus=focus, pad=pad, key=key)
# ------------------------- Exit BUTTON Element lazy function ------------------------- #
def Exit(button_text='Exit', size=(None, None), auto_size_button=None, button_color=None, disabled=False, tooltip=None,
font=None, bind_return_key=False, focus=False, pad=None, key=None):
return Button(button_text=button_text, button_type=BUTTON_TYPE_READ_FORM, tooltip=tooltip, size=size,
auto_size_button=auto_size_button, button_color=button_color, font=font, disabled=disabled,
bind_return_key=bind_return_key, focus=focus, pad=pad, key=key)
# ------------------------- YES BUTTON Element lazy function ------------------------- #
def Yes(button_text='Yes', size=(None, None), auto_size_button=None, button_color=None, disabled=False, tooltip=None,
font=None, bind_return_key=True, focus=False, pad=None, key=None):
return Button(button_text=button_text, button_type=BUTTON_TYPE_READ_FORM, tooltip=tooltip, size=size,
auto_size_button=auto_size_button, button_color=button_color, font=font, disabled=disabled,
bind_return_key=bind_return_key, focus=focus, pad=pad, key=key)
# ------------------------- NO BUTTON Element lazy function ------------------------- #
def No(button_text='No', size=(None, None), auto_size_button=None, button_color=None, disabled=False, tooltip=None,
font=None, bind_return_key=False, focus=False, pad=None, key=None):
return Button(button_text=button_text, button_type=BUTTON_TYPE_READ_FORM, tooltip=tooltip, size=size,
auto_size_button=auto_size_button, button_color=button_color, font=font, disabled=disabled,
bind_return_key=bind_return_key, focus=focus, pad=pad, key=key)
# ------------------------- NO BUTTON Element lazy function ------------------------- #
def Help(button_text='Help', size=(None, None), auto_size_button=None, button_color=None, disabled=False, font=None,
tooltip=None, bind_return_key=False, focus=False, pad=None, key=None):
return Button(button_text=button_text, button_type=BUTTON_TYPE_READ_FORM, tooltip=tooltip, size=size,
auto_size_button=auto_size_button, button_color=button_color, font=font, disabled=disabled,
bind_return_key=bind_return_key, focus=focus, pad=pad, key=key)
# ------------------------- GENERIC BUTTON Element lazy function ------------------------- #
def SimpleButton(button_text, image_filename=None, image_data=None, image_size=(None, None), image_subsample=None,
border_width=None, tooltip=None, size=(None, None), auto_size_button=None, button_color=None,
font=None, bind_return_key=False, disabled=False, focus=False, pad=None, key=None):
return Button(button_text=button_text, button_type=BUTTON_TYPE_CLOSES_WIN, image_filename=image_filename,
image_data=image_data, image_size=image_size, image_subsample=image_subsample,
border_width=border_width, tooltip=tooltip, disabled=disabled, size=size,
auto_size_button=auto_size_button, button_color=button_color, font=font,
bind_return_key=bind_return_key, focus=focus, pad=pad, key=key)
# ------------------------- CLOSE BUTTON Element lazy function ------------------------- #
def CloseButton(button_text, image_filename=None, image_data=None, image_size=(None, None), image_subsample=None, border_width=None, tooltip=None, size=(None, None), auto_size_button=None, button_color=None, font=None, bind_return_key=False, disabled=False, focus=False, pad=None, key=None):
return Button(button_text=button_text, button_type=BUTTON_TYPE_CLOSES_WIN, image_filename=image_filename, image_data=image_data, image_size=image_size, image_subsample=image_subsample, border_width=border_width, tooltip=tooltip, disabled=disabled, size=size, auto_size_button=auto_size_button, button_color=button_color, font=font, bind_return_key=bind_return_key, focus=focus, pad=pad, key=key)
CButton = CloseButton
# ------------------------- GENERIC BUTTON Element lazy function ------------------------- #
def ReadButton(button_text, image_filename=None, image_data=None, image_size=(None, None), image_subsample=None,
border_width=None, tooltip=None, size=(None, None), auto_size_button=None, button_color=None, font=None,
bind_return_key=False, disabled=False, focus=False, pad=None, key=None):
return Button(button_text=button_text, button_type=BUTTON_TYPE_READ_FORM, image_filename=image_filename,
image_data=image_data, image_size=image_size, image_subsample=image_subsample,
border_width=border_width, tooltip=tooltip, size=size, disabled=disabled,
auto_size_button=auto_size_button, button_color=button_color, font=font,
bind_return_key=bind_return_key, focus=focus, pad=pad, key=key)
ReadFormButton = ReadButton
RButton = ReadFormButton
# ------------------------- Realtime BUTTON Element lazy function ------------------------- #
def RealtimeButton(button_text, image_filename=None, image_data=None, image_size=(None, None), image_subsample=None,
border_width=None, tooltip=None, size=(None, None), auto_size_button=None, button_color=None,
font=None, disabled=False, bind_return_key=False, focus=False, pad=None, key=None):
return Button(button_text=button_text, button_type=BUTTON_TYPE_REALTIME, image_filename=image_filename,
image_data=image_data, image_size=image_size, image_subsample=image_subsample,
border_width=border_width, tooltip=tooltip, disabled=disabled, size=size,
auto_size_button=auto_size_button, button_color=button_color, font=font,
bind_return_key=bind_return_key, focus=focus, pad=pad, key=key)
# ------------------------- Dummy BUTTON Element lazy function ------------------------- #
def DummyButton(button_text, image_filename=None, image_data=None, image_size=(None, None), image_subsample=None,
border_width=None, tooltip=None, size=(None, None), auto_size_button=None, button_color=None, font=None,
disabled=False, bind_return_key=False, focus=False, pad=None, key=None):
return Button(button_text=button_text, button_type=BUTTON_TYPE_CLOSES_WIN_ONLY, image_filename=image_filename,
image_data=image_data, image_size=image_size, image_subsample=image_subsample,
border_width=border_width, tooltip=tooltip, size=size, auto_size_button=auto_size_button,
button_color=button_color, font=font, disabled=disabled, bind_return_key=bind_return_key, focus=focus,
pad=pad, key=key)
# ------------------------- Calendar Chooser Button lazy function ------------------------- #
def CalendarButton(button_text, target=(None, None), close_when_date_chosen=True, default_date_m_d_y=(None,None,None), image_filename=None, image_data=None, image_size=(None, None),
image_subsample=None, tooltip=None, border_width=None, size=(None, None), auto_size_button=None,
button_color=None, disabled=False, font=None, bind_return_key=False, focus=False, pad=None,
key=None):
button = Button(button_text=button_text, button_type=BUTTON_TYPE_CALENDAR_CHOOSER, target=target,
image_filename=image_filename, image_data=image_data, image_size=image_size,
image_subsample=image_subsample, border_width=border_width, tooltip=tooltip, size=size,
auto_size_button=auto_size_button, button_color=button_color, font=font, disabled=disabled,
bind_return_key=bind_return_key, focus=focus, pad=pad, key=key)
button.CalendarCloseWhenChosen = close_when_date_chosen
button.DefaultDate_M_D_Y = default_date_m_d_y
return button
# ------------------------- Calendar Chooser Button lazy function ------------------------- #
def ColorChooserButton(button_text, target=(None, None), image_filename=None, image_data=None, image_size=(None, None),
image_subsample=None, tooltip=None, border_width=None, size=(None, None), auto_size_button=None,
button_color=None, disabled=False, font=None, bind_return_key=False, focus=False, pad=None,
key=None):
return Button(button_text=button_text, button_type=BUTTON_TYPE_COLOR_CHOOSER, target=target,
image_filename=image_filename, image_data=image_data, image_size=image_size,
image_subsample=image_subsample, border_width=border_width, tooltip=tooltip, size=size,
auto_size_button=auto_size_button, button_color=button_color, font=font, disabled=disabled,
bind_return_key=bind_return_key, focus=focus, pad=pad, key=key)
##################################### ----- RESULTS ------ ##################################################
def AddToReturnDictionary(form, element, value):
if element.Key is None:
form.ReturnValuesDictionary[form.DictionaryKeyCounter] = value
element.Key = form.DictionaryKeyCounter
form.DictionaryKeyCounter += 1
else:
form.ReturnValuesDictionary[element.Key] = value
def AddToReturnList(form, value):
form.ReturnValuesList.append(value)
# ----------------------------------------------------------------------------#
# ------- FUNCTION InitializeResults. Sets up form results matrix --------#
def InitializeResults(form):
BuildResults(form, True, form)
return
# ===== Radio Button RadVar encoding and decoding =====#
# ===== The value is simply the row * 1000 + col =====#
def DecodeRadioRowCol(RadValue):
row = RadValue // 1000
col = RadValue % 1000
return row, col
def EncodeRadioRowCol(row, col):
RadValue = row * 1000 + col
return RadValue
# ------- FUNCTION BuildResults. Form exiting so build the results to pass back ------- #
# format of return values is
# (Button Pressed, input_values)
def BuildResults(form, initialize_only, top_level_form):
# Results for elements are:
# TEXT - Nothing
# INPUT - Read value from TK
# Button - Button Text and position as a Tuple
# Get the initialized results so we don't have to rebuild
form.DictionaryKeyCounter = 0
form.ReturnValuesDictionary = {}
form.ReturnValuesList = []
BuildResultsForSubform(form, initialize_only, top_level_form)
if not top_level_form.LastButtonClickedWasRealtime:
top_level_form.LastButtonClicked = None
return form.ReturnValues
def BuildResultsForSubform(form, initialize_only, top_level_form):
button_pressed_text = top_level_form.LastButtonClicked
for row_num, row in enumerate(form.Rows):
for col_num, element in enumerate(row):
if element.Key is not None and WRITE_ONLY_KEY in str(element.Key):
continue
value = None
if element.Type == ELEM_TYPE_COLUMN:
element.DictionaryKeyCounter = top_level_form.DictionaryKeyCounter
element.ReturnValuesList = []
element.ReturnValuesDictionary = {}
BuildResultsForSubform(element, initialize_only, top_level_form)
for item in element.ReturnValuesList:
AddToReturnList(top_level_form, item)
if element.UseDictionary:
top_level_form.UseDictionary = True
if element.ReturnValues[0] is not None: # if a button was clicked
button_pressed_text = element.ReturnValues[0]
if element.Type == ELEM_TYPE_FRAME:
element.DictionaryKeyCounter = top_level_form.DictionaryKeyCounter
element.ReturnValuesList = []
element.ReturnValuesDictionary = {}
BuildResultsForSubform(element, initialize_only, top_level_form)
for item in element.ReturnValuesList:
AddToReturnList(top_level_form, item)
if element.UseDictionary:
top_level_form.UseDictionary = True
if element.ReturnValues[0] is not None: # if a button was clicked
button_pressed_text = element.ReturnValues[0]
if element.Type == ELEM_TYPE_PANE:
element.DictionaryKeyCounter = top_level_form.DictionaryKeyCounter
element.ReturnValuesList = []
element.ReturnValuesDictionary = {}
BuildResultsForSubform(element, initialize_only, top_level_form)
for item in element.ReturnValuesList:
AddToReturnList(top_level_form, item)
if element.UseDictionary:
top_level_form.UseDictionary = True
if element.ReturnValues[0] is not None: # if a button was clicked
button_pressed_text = element.ReturnValues[0]
if element.Type == ELEM_TYPE_TAB_GROUP:
element.DictionaryKeyCounter = top_level_form.DictionaryKeyCounter
element.ReturnValuesList = []
element.ReturnValuesDictionary = {}
BuildResultsForSubform(element, initialize_only, top_level_form)
for item in element.ReturnValuesList:
AddToReturnList(top_level_form, item)
if element.UseDictionary:
top_level_form.UseDictionary = True
if element.ReturnValues[0] is not None: # if a button was clicked
button_pressed_text = element.ReturnValues[0]
if element.Type == ELEM_TYPE_TAB:
element.DictionaryKeyCounter = top_level_form.DictionaryKeyCounter
element.ReturnValuesList = []
element.ReturnValuesDictionary = {}
BuildResultsForSubform(element, initialize_only, top_level_form)
for item in element.ReturnValuesList:
AddToReturnList(top_level_form, item)
if element.UseDictionary:
top_level_form.UseDictionary = True
if element.ReturnValues[0] is not None: # if a button was clicked
button_pressed_text = element.ReturnValues[0]
if not initialize_only:
if element.Type == ELEM_TYPE_INPUT_TEXT:
try:
value = element.TKStringVar.get()
except:
value = ''
if not top_level_form.NonBlocking and not element.do_not_clear and not top_level_form.ReturnKeyboardEvents:
element.TKStringVar.set('')
elif element.Type == ELEM_TYPE_INPUT_CHECKBOX:
value = element.TKIntVar.get()
value = (value != 0)
elif element.Type == ELEM_TYPE_INPUT_RADIO:
RadVar = element.TKIntVar.get()
this_rowcol = EncodeRadioRowCol(row_num, col_num)
value = RadVar == this_rowcol
elif element.Type == ELEM_TYPE_BUTTON:
if top_level_form.LastButtonClicked == element.ButtonText:
button_pressed_text = top_level_form.LastButtonClicked
if element.BType != BUTTON_TYPE_REALTIME: # Do not clear realtime buttons
top_level_form.LastButtonClicked = None
if element.BType == BUTTON_TYPE_CALENDAR_CHOOSER:
try:
value = element.TKCal.selection
except:
value = None
else:
try:
value = element.TKStringVar.get()
except:
value = None
elif element.Type == ELEM_TYPE_INPUT_COMBO:
value = element.TKStringVar.get()
elif element.Type == ELEM_TYPE_INPUT_OPTION_MENU:
value = element.TKStringVar.get()
elif element.Type == ELEM_TYPE_INPUT_LISTBOX:
try:
items = element.TKListbox.curselection()
value = [element.Values[int(item)] for item in items]
except:
value = ''
elif element.Type == ELEM_TYPE_INPUT_SPIN:
try:
value = element.TKStringVar.get()
except:
value = 0
elif element.Type == ELEM_TYPE_INPUT_SLIDER:
try:
value = float(element.TKScale.get())
except:
value = 0
elif element.Type == ELEM_TYPE_INPUT_MULTILINE:
try:
value = element.TKText.get(1.0, tk.END)
if not top_level_form.NonBlocking and not element.do_not_clear and not top_level_form.ReturnKeyboardEvents:
element.TKText.delete('1.0', tk.END)
except:
value = None
elif element.Type == ELEM_TYPE_TAB_GROUP:
try:
value = element.TKNotebook.tab(element.TKNotebook.index('current'))['text']
tab_key = element.FindKeyFromTabName(value)
if tab_key is not None:
value = tab_key
except:
value = None
elif element.Type == ELEM_TYPE_TABLE:
value = element.SelectedRows
elif element.Type == ELEM_TYPE_TREE:
value = element.SelectedRows
elif element.Type == ELEM_TYPE_GRAPH:
value = element.ClickPosition
elif element.Type == ELEM_TYPE_MENUBAR:
if element.MenuItemChosen is not None:
button_pressed_text = top_level_form.LastButtonClicked = element.MenuItemChosen
value = element.MenuItemChosen
element.MenuItemChosen = None
elif element.Type == ELEM_TYPE_BUTTONMENU:
value = element.MenuItemChosen
element.MenuItemChosen = None
# if element.MenuItemChosen is not None:
# button_pressed_text = top_level_form.LastButtonClicked = element.MenuItemChosen
# value = element.MenuItemChosen
# element.MenuItemChosen = None
else:
value = None
# if an input type element, update the results
if element.Type != ELEM_TYPE_BUTTON and \
element.Type != ELEM_TYPE_TEXT and \
element.Type != ELEM_TYPE_IMAGE and \
element.Type != ELEM_TYPE_OUTPUT and \
element.Type != ELEM_TYPE_PROGRESS_BAR and \
element.Type != ELEM_TYPE_COLUMN and \
element.Type != ELEM_TYPE_FRAME \
and element.Type != ELEM_TYPE_TAB:
AddToReturnList(form, value)
AddToReturnDictionary(top_level_form, element, value)
elif (element.Type == ELEM_TYPE_BUTTON and
element.BType == BUTTON_TYPE_CALENDAR_CHOOSER and
element.Target == (None, None)) or \
(element.Type == ELEM_TYPE_BUTTON and
element.BType == BUTTON_TYPE_COLOR_CHOOSER and
element.Target == (None, None)) or \
(element.Type == ELEM_TYPE_BUTTON
and element.Key is not None and
(element.BType in (BUTTON_TYPE_SAVEAS_FILE, BUTTON_TYPE_BROWSE_FILE, BUTTON_TYPE_BROWSE_FILES,
BUTTON_TYPE_BROWSE_FOLDER))):
AddToReturnList(form, value)
AddToReturnDictionary(top_level_form, element, value)
# if this is a column, then will fail so need to wrap with tr
try:
if form.ReturnKeyboardEvents and form.LastKeyboardEvent is not None:
button_pressed_text = form.LastKeyboardEvent
form.LastKeyboardEvent = None
except:
pass
try:
form.ReturnValuesDictionary.pop(None, None) # clean up dictionary include None was included
except:
pass
if not form.UseDictionary:
form.ReturnValues = button_pressed_text, form.ReturnValuesList
else:
form.ReturnValues = button_pressed_text, form.ReturnValuesDictionary
return form.ReturnValues
def FillFormWithValues(form, values_dict):
FillSubformWithValues(form, values_dict)
def FillSubformWithValues(form, values_dict):
for row_num, row in enumerate(form.Rows):
for col_num, element in enumerate(row):
value = None
if element.Type == ELEM_TYPE_COLUMN:
FillSubformWithValues(element, values_dict)
if element.Type == ELEM_TYPE_FRAME:
FillSubformWithValues(element, values_dict)
if element.Type == ELEM_TYPE_TAB_GROUP:
FillSubformWithValues(element, values_dict)
if element.Type == ELEM_TYPE_TAB:
FillSubformWithValues(element, values_dict)
try:
value = values_dict[element.Key]
except:
continue
if element.Type == ELEM_TYPE_INPUT_TEXT:
element.Update(value)
elif element.Type == ELEM_TYPE_INPUT_CHECKBOX:
element.Update(value)
elif element.Type == ELEM_TYPE_INPUT_RADIO:
element.Update(value)
elif element.Type == ELEM_TYPE_INPUT_COMBO:
element.Update(value)
elif element.Type == ELEM_TYPE_INPUT_OPTION_MENU:
element.Update(value)
elif element.Type == ELEM_TYPE_INPUT_LISTBOX:
element.SetValue(value)
elif element.Type == ELEM_TYPE_INPUT_SLIDER:
element.Update(value)
elif element.Type == ELEM_TYPE_INPUT_MULTILINE:
element.Update(value)
elif element.Type == ELEM_TYPE_INPUT_SPIN:
element.Update(value)
elif element.Type == ELEM_TYPE_BUTTON:
element.Update(value)
def _FindElementFromKeyInSubForm(form, key):
for row_num, row in enumerate(form.Rows):
for col_num, element in enumerate(row):
if element.Type == ELEM_TYPE_COLUMN:
matching_elem = _FindElementFromKeyInSubForm(element, key)
if matching_elem is not None:
return matching_elem
if element.Type == ELEM_TYPE_FRAME:
matching_elem = _FindElementFromKeyInSubForm(element, key)
if matching_elem is not None:
return matching_elem
if element.Type == ELEM_TYPE_TAB_GROUP:
matching_elem = _FindElementFromKeyInSubForm(element, key)
if matching_elem is not None:
return matching_elem
if element.Type == ELEM_TYPE_PANE:
matching_elem = _FindElementFromKeyInSubForm(element, key)
if matching_elem is not None:
return matching_elem
if element.Type == ELEM_TYPE_TAB:
matching_elem = _FindElementFromKeyInSubForm(element, key)
if matching_elem is not None:
return matching_elem
if element.Key == key:
return element
def _FindElementWithFocusInSubForm(form):
for row_num, row in enumerate(form.Rows):
for col_num, element in enumerate(row):
if element.Type == ELEM_TYPE_COLUMN:
matching_elem = _FindElementWithFocusInSubForm(element)
if matching_elem is not None:
return matching_elem
if element.Type == ELEM_TYPE_FRAME:
matching_elem = _FindElementWithFocusInSubForm(element)
if matching_elem is not None:
return matching_elem
if element.Type == ELEM_TYPE_TAB_GROUP:
matching_elem = _FindElementWithFocusInSubForm(element)
if matching_elem is not None:
return matching_elem
if element.Type == ELEM_TYPE_TAB:
matching_elem = _FindElementWithFocusInSubForm(element)
if matching_elem is not None:
return matching_elem
if element.Type == ELEM_TYPE_INPUT_TEXT:
if element.TKEntry is not None:
if element.TKEntry is element.TKEntry.focus_get():
return element
if element.Type == ELEM_TYPE_INPUT_MULTILINE:
if element.TKText is not None:
if element.TKText is element.TKText.focus_get():
return element
if sys.version_info[0] >= 3:
def AddMenuItem(top_menu, sub_menu_info, element, is_sub_menu=False, skip=False):
return_val = None
if type(sub_menu_info) is str:
if not is_sub_menu and not skip:
# print(f'Adding command {sub_menu_info}')
pos = sub_menu_info.find('&')
if pos != -1:
if pos == 0 or sub_menu_info[pos - 1] != "\\":
sub_menu_info = sub_menu_info[:pos] + sub_menu_info[pos + 1:]
if sub_menu_info == '---':
top_menu.add('separator')
else:
try:
item_without_key = sub_menu_info[:sub_menu_info.index(MENU_KEY_SEPARATOR)]
except:
item_without_key = sub_menu_info
if item_without_key[0] == MENU_DISABLED_CHARACTER:
top_menu.add_command(label=item_without_key[len(MENU_DISABLED_CHARACTER):], underline=pos,
command=lambda: element.MenuItemChosenCallback(sub_menu_info))
top_menu.entryconfig(item_without_key[len(MENU_DISABLED_CHARACTER):], state='disabled')
else:
top_menu.add_command(label=item_without_key, underline=pos,
command=lambda: element.MenuItemChosenCallback(sub_menu_info))
else:
i = 0
while i < (len(sub_menu_info)):
item = sub_menu_info[i]
if i != len(sub_menu_info) - 1:
if type(sub_menu_info[i + 1]) == list:
new_menu = tk.Menu(top_menu, tearoff=element.Tearoff)
return_val = new_menu
pos = sub_menu_info[i].find('&')
if pos != -1:
if pos == 0 or sub_menu_info[i][pos - 1] != "\\":
sub_menu_info[i] = sub_menu_info[i][:pos] + sub_menu_info[i][pos + 1:]
if sub_menu_info[i][0] == MENU_DISABLED_CHARACTER:
top_menu.add_cascade(label=sub_menu_info[i][len(MENU_DISABLED_CHARACTER):], menu=new_menu, underline=pos, state='disabled')
else:
top_menu.add_cascade(label=sub_menu_info[i], menu=new_menu, underline=pos)
AddMenuItem(new_menu, sub_menu_info[i + 1], element, is_sub_menu=True)
i += 1 # skip the next one
else:
AddMenuItem(top_menu, item, element)
else:
AddMenuItem(top_menu, item, element)
i += 1
return return_val
else:
def AddMenuItem(top_menu, sub_menu_info, element, is_sub_menu=False, skip=False):
if not isinstance(sub_menu_info, list):
if not is_sub_menu and not skip:
# print(f'Adding command {sub_menu_info}')
pos = sub_menu_info.find('&')
if pos != -1:
if pos == 0 or sub_menu_info[pos - 1] != "\\":
sub_menu_info = sub_menu_info[:pos] + sub_menu_info[pos + 1:]
if sub_menu_info == '---':
top_menu.add('separator')
else:
try:
item_without_key = sub_menu_info[:sub_menu_info.index(MENU_KEY_SEPARATOR)]
except:
item_without_key = sub_menu_info
if item_without_key[0] == MENU_DISABLED_CHARACTER:
top_menu.add_command(label=item_without_key[len(MENU_DISABLED_CHARACTER):], underline=pos,
command=lambda: element.MenuItemChosenCallback(sub_menu_info))
top_menu.entryconfig(item_without_key[len(MENU_DISABLED_CHARACTER):], state='disabled')
else:
top_menu.add_command(label=item_without_key, underline=pos,
command=lambda: element.MenuItemChosenCallback(sub_menu_info))
else:
i = 0
while i < (len(sub_menu_info)):
item = sub_menu_info[i]
if i != len(sub_menu_info) - 1:
if isinstance(sub_menu_info[i + 1], list):
new_menu = tk.Menu(top_menu, tearoff=element.Tearoff)
pos = sub_menu_info[i].find('&')
if pos != -1:
if pos == 0 or sub_menu_info[i][pos - 1] != "\\":
sub_menu_info[i] = sub_menu_info[i][:pos] + sub_menu_info[i][pos + 1:]
if sub_menu_info[i][0] == MENU_DISABLED_CHARACTER:
top_menu.add_cascade(label=sub_menu_info[i][len(MENU_DISABLED_CHARACTER):], menu=new_menu, underline=pos, state='disabled')
else:
top_menu.add_cascade(label=sub_menu_info[i], menu=new_menu, underline=pos)
AddMenuItem(new_menu, sub_menu_info[i + 1], element, is_sub_menu=True)
i += 1 # skip the next one
else:
AddMenuItem(top_menu, item, element)
else:
AddMenuItem(top_menu, item, element)
i += 1
# ------------------------------------------------------------------------------------------------------------------ #
# ------------------------------------------------------------------------------------------------------------------ #
# ===================================== TK CODE STARTS HERE ====================================================== #
# ------------------------------------------------------------------------------------------------------------------ #
# ------------------------------------------------------------------------------------------------------------------ #
def PackFormIntoFrame(form, containing_frame, toplevel_form:Window):
def CharWidthInPixels():
return tkinter.font.Font().measure('A') # single character width
border_depth = toplevel_form.BorderDepth if toplevel_form.BorderDepth is not None else DEFAULT_BORDER_WIDTH
# --------------------------------------------------------------------------- #
# **************** Use FlexForm to build the tkinter window ********** ----- #
# Building is done row by row. #
# --------------------------------------------------------------------------- #
focus_set = False
######################### LOOP THROUGH ROWS #########################
# *********** ------- Loop through ROWS ------- ***********#
for row_num, flex_row in enumerate(form.Rows):
######################### LOOP THROUGH ELEMENTS ON ROW #########################
# *********** ------- Loop through ELEMENTS ------- ***********#
# *********** Make TK Row ***********#
tk_row_frame = tk.Frame(containing_frame)
for col_num, element in enumerate(flex_row):
element.ParentForm = toplevel_form # save the button's parent form object
if toplevel_form.Font and (element.Font == DEFAULT_FONT or not element.Font):
font = toplevel_form.Font
elif element.Font is not None:
font = element.Font
else:
font = DEFAULT_FONT
# ------- Determine Auto-Size setting on a cascading basis ------- #
if element.AutoSizeText is not None: # if element overide
auto_size_text = element.AutoSizeText
elif toplevel_form.AutoSizeText is not None: # if form override
auto_size_text = toplevel_form.AutoSizeText
else:
auto_size_text = DEFAULT_AUTOSIZE_TEXT
element_type = element.Type
# Set foreground color
text_color = element.TextColor
elementpad = element.Pad if element.Pad is not None else toplevel_form.ElementPadding
# Determine Element size
element_size = element.Size
if (element_size == (None, None) and element_type not in (ELEM_TYPE_BUTTON, ELEM_TYPE_BUTTONMENU)): # user did not specify a size
element_size = toplevel_form.DefaultElementSize
elif (element_size == (None, None) and element_type in (ELEM_TYPE_BUTTON, ELEM_TYPE_BUTTONMENU)):
element_size = toplevel_form.DefaultButtonElementSize
else:
auto_size_text = False # if user has specified a size then it shouldn't autosize
# ------------------------- COLUMN element ------------------------- #
if element_type == ELEM_TYPE_COLUMN:
if element.Scrollable:
element.TKColFrame = TkScrollableFrame(tk_row_frame, element.VerticalScrollOnly) # do not use yet! not working
PackFormIntoFrame(element, element.TKColFrame.TKFrame, toplevel_form)
element.TKColFrame.TKFrame.update()
if element.Size == (None, None): # if no size specified, use column width x column height/2
element.TKColFrame.canvas.config(width=element.TKColFrame.TKFrame.winfo_reqwidth(),
height=element.TKColFrame.TKFrame.winfo_reqheight() / 2)
else:
element.TKColFrame.canvas.config(width=element.Size[0], height=element.Size[1])
if not element.BackgroundColor in (None, COLOR_SYSTEM_DEFAULT):
element.TKColFrame.canvas.config(background=element.BackgroundColor)
element.TKColFrame.TKFrame.config(background=element.BackgroundColor, borderwidth=0,
highlightthickness=0)
element.TKColFrame.config(background=element.BackgroundColor, borderwidth=0, highlightthickness=0)
else:
if element.Size != (None, None):
element.TKColFrame = TkFixedFrame(tk_row_frame)
PackFormIntoFrame(element, element.TKColFrame.TKFrame, toplevel_form)
element.TKColFrame.TKFrame.update()
if element.Size[1] is not None:
element.TKColFrame.canvas.config(height=element.Size[1])
elif element.Size[0] is not None:
element.TKColFrame.canvas.config(width=element.Size[0])
else:
element.TKColFrame = tk.Frame(tk_row_frame)
PackFormIntoFrame(element, element.TKColFrame, toplevel_form)
element.TKColFrame.pack(side=tk.LEFT, padx=elementpad[0], pady=elementpad[1], expand=True, fill='both')
if element.Visible is False:
element.TKColFrame.pack_forget()
element.TKColFrame = element.TKColFrame
if element.BackgroundColor != COLOR_SYSTEM_DEFAULT and element.BackgroundColor is not None:
element.TKColFrame.configure(background=element.BackgroundColor, highlightbackground=element.BackgroundColor,
highlightcolor=element.BackgroundColor)
if element.RightClickMenu or toplevel_form.RightClickMenu:
menu = element.RightClickMenu or toplevel_form.RightClickMenu
top_menu = tk.Menu(toplevel_form.TKroot, tearoff=False)
AddMenuItem(top_menu, menu[1], element)
element.TKRightClickMenu = top_menu
element.TKColFrame.bind('<Button-3>', element.RightClickMenuCallback)
# ------------------------- Pane element ------------------------- #
if element_type == ELEM_TYPE_PANE:
bd = element.BorderDepth if element.BorderDepth is not None else border_depth
element.PanedWindow = tk.PanedWindow(tk_row_frame,
orient=tk.VERTICAL if element.Orientation.startswith('v') else tk.HORIZONTAL,
borderwidth=bd,
bd=bd,
)
if element.Relief is not None:
element.PanedWindow.configure(relief=element.Relief)
element.PanedWindow.configure(handlesize=element.HandleSize)
if element.ShowHandle:
element.PanedWindow.config(showhandle=True)
if element.Size != (None, None):
element.PanedWindow.config(width=element.Size[0], height=element.Size[1])
if element.BackgroundColor is not None and element.BackgroundColor != COLOR_SYSTEM_DEFAULT:
element.PanedWindow.configure(background=element.BackgroundColor)
for pane in element.PaneList:
pane.TKColFrame = tk.Frame(element.PanedWindow)
pane.ParentPanedWindow = element.PanedWindow
PackFormIntoFrame(pane, pane.TKColFrame, toplevel_form)
if pane.Visible:
element.PanedWindow.add(pane.TKColFrame)
if pane.BackgroundColor != COLOR_SYSTEM_DEFAULT and pane.BackgroundColor is not None:
pane.TKColFrame.configure(background=pane.BackgroundColor, highlightbackground=pane.BackgroundColor,
highlightcolor=pane.BackgroundColor)
element.PanedWindow.pack(side=tk.LEFT, padx=elementpad[0], pady=elementpad[1], expand=True, fill='both')
if element.Visible is False:
element.PanedWindow.pack_forget()
# ------------------------- TEXT element ------------------------- #
elif element_type == ELEM_TYPE_TEXT:
# auto_size_text = element.AutoSizeText
display_text = element.DisplayText # text to display
if auto_size_text is False:
width, height = element_size
else:
lines = display_text.split('\n')
max_line_len = max([len(l) for l in lines])
num_lines = len(lines)
if max_line_len > element_size[0]: # if text exceeds element size, the will have to wrap
width = element_size[0]
else:
width = max_line_len
height = num_lines
# ---===--- LABEL widget create and place --- #
stringvar = tk.StringVar()
element.TKStringVar = stringvar
stringvar.set(display_text)
if auto_size_text:
width = 0
if element.Justification is not None:
justification = element.Justification
elif toplevel_form.TextJustification is not None:
justification = toplevel_form.TextJustification
else:
justification = DEFAULT_TEXT_JUSTIFICATION
justify = tk.LEFT if justification == 'left' else tk.CENTER if justification == 'center' else tk.RIGHT
anchor = tk.NW if justification == 'left' else tk.N if justification == 'center' else tk.NE
# tktext_label = tk.Label(tk_row_frame, textvariable=stringvar, width=width, height=height,
# justify=justify, bd=border_depth, font=font)
tktext_label = tk.Label(tk_row_frame, textvariable=stringvar, width=width, height=height,
justify=justify, bd=border_depth, font=font)
# Set wrap-length for text (in PIXELS) == PAIN IN THE ASS
wraplen = tktext_label.winfo_reqwidth() + 40 # width of widget in Pixels
if not auto_size_text and height == 1:
wraplen = 0
# print(display_text, "wraplen, width, height", wraplen, width, height, font)
tktext_label.configure(anchor=anchor, wraplen=wraplen) # set wrap to width of widget
if element.Relief is not None:
tktext_label.configure(relief=element.Relief)
if element.BackgroundColor is not None and element.BackgroundColor != COLOR_SYSTEM_DEFAULT:
tktext_label.configure(background=element.BackgroundColor)
if element.TextColor != COLOR_SYSTEM_DEFAULT and element.TextColor is not None:
tktext_label.configure(fg=element.TextColor)
tktext_label.pack(side=tk.LEFT, padx=elementpad[0], pady=elementpad[1], expand=True)
if element.Visible is False:
tktext_label.pack_forget()
element.TKText = tktext_label
if element.ClickSubmits:
tktext_label.bind('<Button-1>', element.TextClickedHandler)
if element.Tooltip is not None:
element.TooltipObject = ToolTip(element.TKText, text=element.Tooltip, timeout=DEFAULT_TOOLTIP_TIME)
if element.RightClickMenu or toplevel_form.RightClickMenu:
menu = element.RightClickMenu or toplevel_form.RightClickMenu
top_menu = tk.Menu(toplevel_form.TKroot, tearoff=False)
AddMenuItem(top_menu, menu[1], element)
element.TKRightClickMenu = top_menu
tktext_label.bind('<Button-3>', element.RightClickMenuCallback)
# ------------------------- BUTTON element ------------------------- #
elif element_type == ELEM_TYPE_BUTTON:
stringvar = tk.StringVar()
element.TKStringVar = stringvar
element.Location = (row_num, col_num)
btext = element.ButtonText
btype = element.BType
if element.AutoSizeButton is not None:
auto_size = element.AutoSizeButton
else:
auto_size = toplevel_form.AutoSizeButtons
if auto_size is False or element.Size[0] is not None:
width, height = element_size
else:
width = 0
height = toplevel_form.DefaultButtonElementSize[1]
if element.ButtonColor != (None, None) and element.ButtonColor != DEFAULT_BUTTON_COLOR:
bc = element.ButtonColor
elif toplevel_form.ButtonColor != (None, None) and toplevel_form.ButtonColor != DEFAULT_BUTTON_COLOR:
bc = toplevel_form.ButtonColor
else:
bc = DEFAULT_BUTTON_COLOR
border_depth = element.BorderWidth
if btype != BUTTON_TYPE_REALTIME:
tkbutton = tk.Button(tk_row_frame, text=btext, width=width, height=height,
command=element.ButtonCallBack, justify=tk.LEFT, bd=border_depth, font=font)
else:
tkbutton = tk.Button(tk_row_frame, text=btext, width=width, height=height, justify=tk.LEFT,
bd=border_depth, font=font)
tkbutton.bind('<ButtonRelease-1>', element.ButtonReleaseCallBack)
tkbutton.bind('<ButtonPress-1>', element.ButtonPressCallBack)
if bc != (None, None) and bc != COLOR_SYSTEM_DEFAULT and bc[1] != COLOR_SYSTEM_DEFAULT:
tkbutton.config(foreground=bc[0], background=bc[1], activebackground=bc[1])
elif bc[1] == COLOR_SYSTEM_DEFAULT:
tkbutton.config(foreground=bc[0])
if border_depth == 0:
tkbutton.config(relief=tk.FLAT)
tkbutton.config(highlightthickness=0)
element.TKButton = tkbutton # not used yet but save the TK button in case
wraplen = tkbutton.winfo_reqwidth() # width of widget in Pixels
if element.ImageFilename: # if button has an image on it
tkbutton.config(highlightthickness=0)
photo = tk.PhotoImage(file=element.ImageFilename)
if element.ImageSubsample:
photo = photo.subsample(element.ImageSubsample)
if element.ImageSize != (None, None):
width, height = element.ImageSize
else:
width, height = photo.width(), photo.height()
tkbutton.config(image=photo, compound=tk.CENTER, width=width, height=height)
tkbutton.image = photo
if element.ImageData: # if button has an image on it
tkbutton.config(highlightthickness=0)
photo = tk.PhotoImage(data=element.ImageData)
if element.ImageSubsample:
photo = photo.subsample(element.ImageSubsample)
if element.ImageSize != (None, None):
width, height = element.ImageSize
else:
width, height = photo.width(), photo.height()
tkbutton.config(image=photo, compound=tk.CENTER, width=width, height=height)
tkbutton.image = photo
if width != 0:
tkbutton.configure(wraplength=wraplen + 10) # set wrap to width of widget
tkbutton.pack(side=tk.LEFT, padx=elementpad[0], pady=elementpad[1])
if element.Visible is False:
tkbutton.pack_forget()
if element.BindReturnKey:
element.TKButton.bind('<Return>', element.ReturnKeyHandler)
if element.Focus is True or (toplevel_form.UseDefaultFocus and not focus_set):
focus_set = True
element.TKButton.bind('<Return>', element.ReturnKeyHandler)
element.TKButton.focus_set()
toplevel_form.TKroot.focus_force()
if element.Disabled == True:
element.TKButton['state'] = 'disabled'
if element.Tooltip is not None:
element.TooltipObject = ToolTip(element.TKButton, text=element.Tooltip,
timeout=DEFAULT_TOOLTIP_TIME)
# ------------------------- BUTTONMENU element ------------------------- #
elif element_type == ELEM_TYPE_BUTTONMENU:
element.Location = (row_num, col_num)
btext = element.ButtonText
if element.AutoSizeButton is not None:
auto_size = element.AutoSizeButton
else:
auto_size = toplevel_form.AutoSizeButtons
if auto_size is False or element.Size[0] is not None:
width, height = element_size
else:
width = 0
height = toplevel_form.DefaultButtonElementSize[1]
if element.ButtonColor != (None, None) and element.ButtonColor != DEFAULT_BUTTON_COLOR:
bc = element.ButtonColor
elif toplevel_form.ButtonColor != (None, None) and toplevel_form.ButtonColor != DEFAULT_BUTTON_COLOR:
bc = toplevel_form.ButtonColor
else:
bc = DEFAULT_BUTTON_COLOR
border_depth = element.BorderWidth
tkbutton = tk.Menubutton(tk_row_frame, text=btext, width=width, height=height, justify=tk.LEFT, bd=border_depth, font=font)
element.TKButtonMenu = tkbutton
if bc != (None, None) and bc != COLOR_SYSTEM_DEFAULT and bc[1] != COLOR_SYSTEM_DEFAULT:
tkbutton.config(foreground=bc[0], background=bc[1], activebackground=bc[1])
elif bc[1] == COLOR_SYSTEM_DEFAULT:
tkbutton.config(foreground=bc[0])
if border_depth == 0:
tkbutton.config(relief=tk.FLAT)
tkbutton.config(highlightthickness=0)
element.TKButton = tkbutton # not used yet but save the TK button in case
wraplen = tkbutton.winfo_reqwidth() # width of widget in Pixels
if element.ImageFilename: # if button has an image on it
tkbutton.config(highlightthickness=0)
photo = tk.PhotoImage(file=element.ImageFilename)
if element.ImageSize != (None, None):
width, height = element.ImageSize
if element.ImageSubsample:
photo = photo.subsample(element.ImageSubsample)
else:
width, height = photo.width(), photo.height()
tkbutton.config(image=photo, compound=tk.CENTER, width=width, height=height)
tkbutton.image = photo
if element.ImageData: # if button has an image on it
tkbutton.config(highlightthickness=0)
photo = tk.PhotoImage(data=element.ImageData)
if element.ImageSize != (None, None):
width, height = element.ImageSize
if element.ImageSubsample:
photo = photo.subsample(element.ImageSubsample)
else:
width, height = photo.width(), photo.height()
tkbutton.config(image=photo, compound=tk.CENTER, width=width, height=height)
tkbutton.image = photo
if width != 0:
tkbutton.configure(wraplength=wraplen + 10) # set wrap to width of widget
tkbutton.pack(side=tk.LEFT, padx=elementpad[0], pady=elementpad[1])
menu_def = element.MenuDefinition
top_menu = tk.Menu(tkbutton, tearoff=False)
AddMenuItem(top_menu, menu_def[1], element)
tkbutton.configure(menu=top_menu)
if element.Visible is False:
tkbutton.pack_forget()
if element.Disabled == True:
element.TKButton['state'] = 'disabled'
if element.Tooltip is not None:
element.TooltipObject = ToolTip(element.TKButton, text=element.Tooltip,
timeout=DEFAULT_TOOLTIP_TIME)
# ------------------------- INPUT element ------------------------- #
elif element_type == ELEM_TYPE_INPUT_TEXT:
default_text = element.DefaultText
element.TKStringVar = tk.StringVar()
element.TKStringVar.set(default_text)
show = element.PasswordCharacter if element.PasswordCharacter else ""
if element.Justification is not None:
justification = element.Justification
else:
justification = DEFAULT_TEXT_JUSTIFICATION
justify = tk.LEFT if justification == 'left' else tk.CENTER if justification == 'center' else tk.RIGHT
# anchor = tk.NW if justification == 'left' else tk.N if justification == 'center' else tk.NE
element.TKEntry = tk.Entry(tk_row_frame, width=element_size[0], textvariable=element.TKStringVar,
bd=border_depth, font=font, show=show, justify=justify)
if element.ChangeSubmits:
element.TKEntry.bind('<Key>', element.KeyboardHandler)
element.TKEntry.bind('<Return>', element.ReturnKeyHandler)
if element.BackgroundColor is not None and element.BackgroundColor != COLOR_SYSTEM_DEFAULT:
element.TKEntry.configure(background=element.BackgroundColor)
if text_color is not None and text_color != COLOR_SYSTEM_DEFAULT:
element.TKEntry.configure(fg=text_color)
element.TKEntry.pack(side=tk.LEFT, padx=elementpad[0], pady=elementpad[1], expand=True, fill='x')
if element.Visible is False:
element.TKEntry.pack_forget()
if element.Focus is True or (toplevel_form.UseDefaultFocus and not focus_set):
focus_set = True
element.TKEntry.focus_set()
if element.Disabled:
element.TKEntry['state'] = 'readonly'
if element.Tooltip is not None:
element.TooltipObject = ToolTip(element.TKEntry, text=element.Tooltip, timeout=DEFAULT_TOOLTIP_TIME)
if element.RightClickMenu or toplevel_form.RightClickMenu:
menu = element.RightClickMenu or toplevel_form.RightClickMenu
top_menu = tk.Menu(toplevel_form.TKroot, tearoff=False)
AddMenuItem(top_menu, menu[1], element)
element.TKRightClickMenu = top_menu
element.TKEntry.bind('<Button-3>', element.RightClickMenuCallback)
# ------------------------- COMBOBOX element ------------------------- #
elif element_type == ELEM_TYPE_INPUT_COMBO:
max_line_len = max([len(str(l)) for l in element.Values])
if auto_size_text is False:
width = element_size[0]
else:
width = max_line_len
element.TKStringVar = tk.StringVar()
style_name = 'TCombobox'
if element.TextColor is not None and element.TextColor != COLOR_SYSTEM_DEFAULT:
# Creates 1 style per Text Color/ Background Color combination
style_name = element.TextColor + element.BackgroundColor + '.TCombobox'
# print(style_name)
combostyle = ttk.Style()
# unique_field = str(time.time()).replace('.','') + '.TCombobox.field'
# Creates a unique name for each field element(Sure there is a better way to do this)
# unique_field = str(datetime.datetime.today().timestamp()).replace('.','') + '.TCombobox.field'
# unique_field = str(randint(1,50000000)) + '.TCombobox.field'
unique_field = str(uuid.uuid4()) + '.TCombobox.field'
# print(unique_field)
# Clones over the TCombobox.field element from the "alt" theme.
# This is what will allow us to change the background color without altering the whole programs theme
combostyle.element_create(unique_field, "from", "alt")
# Create widget layout using cloned "alt" field
combostyle.layout(style_name, [
(unique_field, {'children': [('Combobox.downarrow', {'side': 'right', 'sticky': 'ns'}),
('Combobox.padding',
{'children': [('Combobox.focus',
{'children': [('Combobox.textarea',
{'sticky': 'nswe'})],
'expand': '1',
'sticky': 'nswe'})],
'expand': '1',
'sticky': 'nswe'})],
'sticky': 'nswe'})])
# Copy default TCombobox settings
# Getting an error on this line of code
# combostyle.configure(style_name, *combostyle.configure("TCombobox"))
# Set individual widget options
combostyle.configure(style_name, foreground=element.TextColor)
combostyle.configure(style_name, selectbackground='gray70')
combostyle.configure(style_name, fieldbackground=element.BackgroundColor)
combostyle.configure(style_name, selectforeground=element.TextColor)
element.TKCombo = ttk.Combobox(tk_row_frame, width=width, textvariable=element.TKStringVar, font=font, style=style_name)
if element.Size[1] != 1 and element.Size[1] is not None:
element.TKCombo.configure(height=element.Size[1])
element.TKCombo['values'] = element.Values
element.TKCombo.pack(side=tk.LEFT, padx=elementpad[0], pady=elementpad[1])
if element.Visible is False:
element.TKCombo.pack_forget()
if element.DefaultValue:
for i, v in enumerate(element.Values):
if v == element.DefaultValue:
element.TKCombo.current(i)
break
else:
element.TKCombo.current(0)
if element.ChangeSubmits:
element.TKCombo.bind('<<ComboboxSelected>>', element.ComboboxSelectHandler)
if element.Readonly:
element.TKCombo['state'] = 'readonly'
if element.Disabled is True: # note overrides readonly if disabled
element.TKCombo['state'] = 'disabled'
if element.Tooltip is not None:
element.TooltipObject = ToolTip(element.TKCombo, text=element.Tooltip, timeout=DEFAULT_TOOLTIP_TIME)
# ------------------------- OPTION MENU Element (Like ComboBox but different) element ------------------------- #
elif element_type == ELEM_TYPE_INPUT_OPTION_MENU:
max_line_len = max([len(str(l)) for l in element.Values])
if auto_size_text is False:
width = element_size[0]
else:
width = max_line_len
element.TKStringVar = tk.StringVar()
default = element.DefaultValue if element.DefaultValue else element.Values[0]
element.TKStringVar.set(default)
element.TKOptionMenu = tk.OptionMenu(tk_row_frame, element.TKStringVar, *element.Values)
element.TKOptionMenu.config(highlightthickness=0, font=font, width=width)
element.TKOptionMenu.config(borderwidth=border_depth)
if element.BackgroundColor is not None and element.BackgroundColor != COLOR_SYSTEM_DEFAULT:
element.TKOptionMenu.configure(background=element.BackgroundColor)
if element.TextColor != COLOR_SYSTEM_DEFAULT and element.TextColor is not None:
element.TKOptionMenu.configure(fg=element.TextColor)
element.TKOptionMenu.pack(side=tk.LEFT, padx=elementpad[0], pady=elementpad[1])
if element.Visible is False:
element.TKOptionMenu.pack_forget()
if element.Disabled == True:
element.TKOptionMenu['state'] = 'disabled'
if element.Tooltip is not None:
element.TooltipObject = ToolTip(element.TKOptionMenu, text=element.Tooltip,
timeout=DEFAULT_TOOLTIP_TIME)
# ------------------------- LISTBOX element ------------------------- #
elif element_type == ELEM_TYPE_INPUT_LISTBOX:
max_line_len = max([len(str(l)) for l in element.Values]) if len(element.Values) != 0 else 0
if auto_size_text is False:
width = element_size[0]
else:
width = max_line_len
listbox_frame = tk.Frame(tk_row_frame)
element.TKStringVar = tk.StringVar()
element.TKListbox = tk.Listbox(listbox_frame, height=element_size[1], width=width,
selectmode=element.SelectMode, font=font)
for index, item in enumerate(element.Values):
element.TKListbox.insert(tk.END, item)
if element.DefaultValues is not None and item in element.DefaultValues:
element.TKListbox.selection_set(index)
if element.BackgroundColor is not None and element.BackgroundColor != COLOR_SYSTEM_DEFAULT:
element.TKListbox.configure(background=element.BackgroundColor)
if text_color is not None and text_color != COLOR_SYSTEM_DEFAULT:
element.TKListbox.configure(fg=text_color)
if element.ChangeSubmits:
element.TKListbox.bind('<<ListboxSelect>>', element.ListboxSelectHandler)
vsb = tk.Scrollbar(listbox_frame, orient="vertical", command=element.TKListbox.yview)
element.TKListbox.configure(yscrollcommand=vsb.set)
element.TKListbox.pack(side=tk.LEFT)
vsb.pack(side=tk.LEFT, fill='y')
listbox_frame.pack(side=tk.LEFT, padx=elementpad[0], pady=elementpad[1])
if element.Visible is False:
listbox_frame.pack_forget()
if element.BindReturnKey:
element.TKListbox.bind('<Return>', element.ListboxSelectHandler)
element.TKListbox.bind('<Double-Button-1>', element.ListboxSelectHandler)
if element.Disabled == True:
element.TKListbox['state'] = 'disabled'
if element.Tooltip is not None:
element.TooltipObject = ToolTip(element.TKListbox, text=element.Tooltip,
timeout=DEFAULT_TOOLTIP_TIME)
if element.RightClickMenu or toplevel_form.RightClickMenu:
menu = element.RightClickMenu or toplevel_form.RightClickMenu
top_menu = tk.Menu(toplevel_form.TKroot, tearoff=False)
AddMenuItem(top_menu, menu[1], element)
element.TKRightClickMenu = top_menu
element.TKListbox.bind('<Button-3>', element.RightClickMenuCallback)
# ------------------------- INPUT MULTI LINE element ------------------------- #
elif element_type == ELEM_TYPE_INPUT_MULTILINE:
default_text = element.DefaultText
width, height = element_size
element.TKText = tk.scrolledtext.ScrolledText(tk_row_frame, width=width, height=height, wrap='word',
bd=border_depth, font=font, relief=tk.FLAT)
element.TKText.insert(1.0, default_text) # set the default text
if element.BackgroundColor is not None and element.BackgroundColor != COLOR_SYSTEM_DEFAULT:
element.TKText.configure(background=element.BackgroundColor)
element.TKText.vbar.config(troughcolor=DEFAULT_SCROLLBAR_COLOR)
element.TKText.pack(side=tk.LEFT, padx=elementpad[0], pady=elementpad[1], expand=True, fill='both')
if element.Visible is False:
element.TKText.pack_forget()
if element.ChangeSubmits:
element.TKText.bind('<Key>', element.KeyboardHandler)
if element.EnterSubmits:
element.TKText.bind('<Return>', element.ReturnKeyHandler)
if element.Focus is True or (toplevel_form.UseDefaultFocus and not focus_set):
focus_set = True
element.TKText.focus_set()
if text_color is not None and text_color != COLOR_SYSTEM_DEFAULT:
element.TKText.configure(fg=text_color)
if element.Disabled == True:
element.TKText['state'] = 'disabled'
if element.Tooltip is not None:
element.TooltipObject = ToolTip(element.TKText, text=element.Tooltip, timeout=DEFAULT_TOOLTIP_TIME)
if element.RightClickMenu or toplevel_form.RightClickMenu:
menu = element.RightClickMenu or toplevel_form.RightClickMenu
top_menu = tk.Menu(toplevel_form.TKroot, tearoff=False)
AddMenuItem(top_menu, menu[1], element)
element.TKRightClickMenu = top_menu
element.TKText.bind('<Button-3>', element.RightClickMenuCallback)
# ------------------------- CHECKBOX element ------------------------- #
elif element_type == ELEM_TYPE_INPUT_CHECKBOX:
width = 0 if auto_size_text else element_size[0]
default_value = element.InitialState
element.TKIntVar = tk.IntVar()
element.TKIntVar.set(default_value if default_value is not None else 0)
if element.ChangeSubmits:
element.TKCheckbutton = tk.Checkbutton(tk_row_frame, anchor=tk.NW, text=element.Text, width=width,
variable=element.TKIntVar, bd=border_depth, font=font,
command=element.CheckboxHandler)
else:
element.TKCheckbutton = tk.Checkbutton(tk_row_frame, anchor=tk.NW, text=element.Text, width=width,
variable=element.TKIntVar, bd=border_depth, font=font)
if default_value is None or element.Disabled:
element.TKCheckbutton.configure(state='disable')
if element.BackgroundColor is not None and element.BackgroundColor != COLOR_SYSTEM_DEFAULT:
element.TKCheckbutton.configure(background=element.BackgroundColor)
element.TKCheckbutton.configure(selectcolor=element.BackgroundColor)
element.TKCheckbutton.configure(activebackground=element.BackgroundColor)
if text_color is not None and text_color != COLOR_SYSTEM_DEFAULT:
element.TKCheckbutton.configure(fg=text_color)
element.TKCheckbutton.pack(side=tk.LEFT, padx=elementpad[0], pady=elementpad[1])
if element.Visible is False:
element.TKCheckbutton.pack_forget()
if element.Tooltip is not None:
element.TooltipObject = ToolTip(element.TKCheckbutton, text=element.Tooltip,
timeout=DEFAULT_TOOLTIP_TIME)
# ------------------------- PROGRESS BAR element ------------------------- #
elif element_type == ELEM_TYPE_PROGRESS_BAR:
# save this form because it must be 'updated' (refreshed) solely for the purpose of updating bar
width = element_size[0]
fnt = tkinter.font.Font()
char_width = fnt.measure('A') # single character width
progress_length = width * char_width
progress_width = element_size[1]
direction = element.Orientation
if element.BarColor != (None, None): # if element has a bar color, use it
bar_color = element.BarColor
else:
bar_color = DEFAULT_PROGRESS_BAR_COLOR
element.TKProgressBar = TKProgressBar(tk_row_frame, element.MaxValue, progress_length, progress_width,
orientation=direction, BarColor=bar_color,
border_width=element.BorderWidth, relief=element.Relief,
style=element.BarStyle, key=element.Key)
element.TKProgressBar.TKProgressBarForReal.pack(side=tk.LEFT, padx=elementpad[0], pady=elementpad[1])
if element.Visible is False:
element.TKProgressBar.TKProgressBarForReal.pack_forget()
# ------------------------- RADIO BUTTON element ------------------------- #
elif element_type == ELEM_TYPE_INPUT_RADIO:
width = 0 if auto_size_text else element_size[0]
default_value = element.InitialState
ID = element.GroupID
# see if ID has already been placed
value = EncodeRadioRowCol(row_num, col_num) # value to set intvar to if this radio is selected
if ID in toplevel_form.RadioDict:
RadVar = toplevel_form.RadioDict[ID]
else:
RadVar = tk.IntVar()
toplevel_form.RadioDict[ID] = RadVar
element.TKIntVar = RadVar # store the RadVar in Radio object
if default_value: # if this radio is the one selected, set RadVar to match
element.TKIntVar.set(value)
if element.ChangeSubmits:
element.TKRadio = tk.Radiobutton(tk_row_frame, anchor=tk.NW, text=element.Text, width=width,
variable=element.TKIntVar, value=value, bd=border_depth, font=font,
command=element.RadioHandler)
else:
element.TKRadio = tk.Radiobutton(tk_row_frame, anchor=tk.NW, text=element.Text, width=width,
variable=element.TKIntVar, value=value, bd=border_depth, font=font)
if not element.BackgroundColor in (None, COLOR_SYSTEM_DEFAULT):
element.TKRadio.configure(background=element.BackgroundColor)
element.TKRadio.configure(selectcolor=element.BackgroundColor)
if text_color is not None and text_color != COLOR_SYSTEM_DEFAULT:
element.TKRadio.configure(fg=text_color)
if element.Disabled:
element.TKRadio['state'] = 'disabled'
element.TKRadio.pack(side=tk.LEFT, padx=elementpad[0], pady=elementpad[1])
if element.Visible is False:
element.TKRadio.pack_forget()
if element.Tooltip is not None:
element.TooltipObject = ToolTip(element.TKRadio, text=element.Tooltip, timeout=DEFAULT_TOOLTIP_TIME)
# ------------------------- SPIN element ------------------------- #
elif element_type == ELEM_TYPE_INPUT_SPIN:
width, height = element_size
width = 0 if auto_size_text else element_size[0]
element.TKStringVar = tk.StringVar()
element.TKSpinBox = tk.Spinbox(tk_row_frame, values=element.Values, textvariable=element.TKStringVar,
width=width, bd=border_depth)
element.TKStringVar.set(element.DefaultValue)
element.TKSpinBox.configure(font=font) # set wrap to width of widget
if element.BackgroundColor is not None and element.BackgroundColor != COLOR_SYSTEM_DEFAULT:
element.TKSpinBox.configure(background=element.BackgroundColor)
element.TKSpinBox.pack(side=tk.LEFT, padx=elementpad[0], pady=elementpad[1])
if element.Visible is False:
element.TKSpinBox.pack_forget()
if text_color is not None and text_color != COLOR_SYSTEM_DEFAULT:
element.TKSpinBox.configure(fg=text_color)
if element.ChangeSubmits:
element.TKSpinBox.bind('<ButtonRelease-1>', element.SpinChangedHandler)
if element.Disabled == True:
element.TKSpinBox['state'] = 'disabled'
if element.Tooltip is not None:
element.TooltipObject = ToolTip(element.TKSpinBox, text=element.Tooltip,
timeout=DEFAULT_TOOLTIP_TIME)
# ------------------------- OUTPUT element ------------------------- #
elif element_type == ELEM_TYPE_OUTPUT:
width, height = element_size
element._TKOut = TKOutput(tk_row_frame, width=width, height=height, bd=border_depth,
background_color=element.BackgroundColor, text_color=text_color, font=font,
pad=elementpad)
element._TKOut.pack(side=tk.LEFT, expand=True, fill='both')
if element.Visible is False:
element._TKOut.frame.pack_forget()
if element.Tooltip is not None:
element.TooltipObject = ToolTip(element._TKOut, text=element.Tooltip, timeout=DEFAULT_TOOLTIP_TIME)
if element.RightClickMenu or toplevel_form.RightClickMenu:
menu = element.RightClickMenu or toplevel_form.RightClickMenu
top_menu = tk.Menu(toplevel_form.TKroot, tearoff=False)
AddMenuItem(top_menu, menu[1], element)
element.TKRightClickMenu = top_menu
element._TKOut.bind('<Button-3>', element.RightClickMenuCallback)
# ------------------------- IMAGE element ------------------------- #
elif element_type == ELEM_TYPE_IMAGE:
if element.Filename is not None:
photo = tk.PhotoImage(file=element.Filename)
elif element.Data is not None:
photo = tk.PhotoImage(data=element.Data)
else:
photo = None
print('*ERROR laying out form.... Image Element has no image specified*')
if photo is not None:
if element_size == (
None, None) or element_size == None or element_size == toplevel_form.DefaultElementSize:
width, height = photo.width(), photo.height()
else:
width, height = element_size
if photo is not None:
element.tktext_label = tk.Label(tk_row_frame, image=photo, width=width, height=height,
bd=border_depth)
else:
element.tktext_label = tk.Label(tk_row_frame, width=width, height=height, bd=border_depth)
if element.BackgroundColor is not None:
element.tktext_label.config(background=element.BackgroundColor)
element.tktext_label.image = photo
# tktext_label.configure(anchor=tk.NW, image=photo)
element.tktext_label.pack(side=tk.LEFT, padx=elementpad[0], pady=elementpad[1])
if element.Visible is False:
element.tktext_label.pack_forget()
if element.Tooltip is not None:
element.TooltipObject = ToolTip(element.tktext_label, text=element.Tooltip,
timeout=DEFAULT_TOOLTIP_TIME)
if element.EnableEvents:
element.tktext_label.bind('<ButtonPress-1>', element.ClickHandler)
if element.RightClickMenu or toplevel_form.RightClickMenu:
menu = element.RightClickMenu or toplevel_form.RightClickMenu
top_menu = tk.Menu(toplevel_form.TKroot, tearoff=False)
AddMenuItem(top_menu, menu[1], element)
element.TKRightClickMenu = top_menu
element.tktext_label.bind('<Button-3>', element.RightClickMenuCallback)
# ------------------------- Canvas element ------------------------- #
elif element_type == ELEM_TYPE_CANVAS:
width, height = element_size
if element._TKCanvas is None:
element._TKCanvas = tk.Canvas(tk_row_frame, width=width, height=height, bd=border_depth)
else:
element._TKCanvas.master = tk_row_frame
if element.BackgroundColor is not None and element.BackgroundColor != COLOR_SYSTEM_DEFAULT:
element._TKCanvas.configure(background=element.BackgroundColor, highlightthickness=0)
element._TKCanvas.pack(side=tk.LEFT, padx=elementpad[0], pady=elementpad[1])
if element.Visible is False:
element._TKCanvas.pack_forget()
if element.Tooltip is not None:
element.TooltipObject = ToolTip(element._TKCanvas, text=element.Tooltip,
timeout=DEFAULT_TOOLTIP_TIME)
if element.RightClickMenu or toplevel_form.RightClickMenu:
menu = element.RightClickMenu or toplevel_form.RightClickMenu
top_menu = tk.Menu(toplevel_form.TKroot, tearoff=False)
AddMenuItem(top_menu, menu[1], element)
element.TKRightClickMenu = top_menu
element._TKCanvas.bind('<Button-3>', element.RightClickMenuCallback)
# ------------------------- Graph element ------------------------- #
elif element_type == ELEM_TYPE_GRAPH:
width, height = element_size
if element._TKCanvas is None:
element._TKCanvas = tk.Canvas(tk_row_frame, width=width, height=height, bd=border_depth)
else:
element._TKCanvas.master = tk_row_frame
element._TKCanvas2 = tk.Canvas(element._TKCanvas, width=width, height=height, bd=border_depth)
element._TKCanvas2.pack(side=tk.LEFT)
element._TKCanvas2.addtag_all('mytag')
if element.BackgroundColor is not None and element.BackgroundColor != COLOR_SYSTEM_DEFAULT:
element._TKCanvas2.configure(background=element.BackgroundColor, highlightthickness=0)
element._TKCanvas.configure(background=element.BackgroundColor, highlightthickness=0)
element._TKCanvas.pack(side=tk.LEFT, padx=elementpad[0], pady=elementpad[1])
if element.Visible is False:
element._TKCanvas.pack_forget()
element._TKCanvas2.pack_forget()
if element.Tooltip is not None:
element.TooltipObject = ToolTip(element._TKCanvas, text=element.Tooltip,
timeout=DEFAULT_TOOLTIP_TIME)
if element.ChangeSubmits:
element._TKCanvas2.bind('<ButtonRelease-1>', element.ButtonReleaseCallBack)
element._TKCanvas2.bind('<ButtonPress-1>', element.ButtonPressCallBack)
if element.DragSubmits:
element._TKCanvas2.bind('<Motion>', element.MotionCallBack)
if element.RightClickMenu or toplevel_form.RightClickMenu:
menu = element.RightClickMenu or toplevel_form.RightClickMenu
top_menu = tk.Menu(toplevel_form.TKroot, tearoff=False)
AddMenuItem(top_menu, menu[1], element)
element.TKRightClickMenu = top_menu
element._TKCanvas2.bind('<Button-3>', element.RightClickMenuCallback)
# ------------------------- MENUBAR element ------------------------- #
elif element_type == ELEM_TYPE_MENUBAR:
menu_def = element.MenuDefinition
element.TKMenu = tk.Menu(toplevel_form.TKroot, tearoff=element.Tearoff) # create the menubar
menubar = element.TKMenu
for menu_entry in menu_def:
# print(f'Adding a Menubar ENTRY {menu_entry}')
baritem = tk.Menu(menubar, tearoff=element.Tearoff)
pos = menu_entry[0].find('&')
# print(pos)
if pos != -1:
if pos == 0 or menu_entry[0][pos - 1] != "\\":
menu_entry[0] = menu_entry[0][:pos] + menu_entry[0][pos + 1:]
if menu_entry[0][0] == MENU_DISABLED_CHARACTER:
menubar.add_cascade(label=menu_entry[0][len(MENU_DISABLED_CHARACTER):], menu=baritem, underline=pos)
menubar.entryconfig(menu_entry[0][len(MENU_DISABLED_CHARACTER):], state='disabled')
else:
menubar.add_cascade(label=menu_entry[0], menu=baritem, underline=pos)
if len(menu_entry) > 1:
AddMenuItem(baritem, menu_entry[1], element)
toplevel_form.TKroot.configure(menu=element.TKMenu)
# ------------------------- Frame element ------------------------- #
elif element_type == ELEM_TYPE_FRAME:
labeled_frame = tk.LabelFrame(tk_row_frame, text=element.Title, relief=element.Relief)
element.TKFrame = labeled_frame
PackFormIntoFrame(element, labeled_frame, toplevel_form)
labeled_frame.pack(side=tk.LEFT, padx=elementpad[0], pady=elementpad[1])
if not element.Visible:
labeled_frame.pack_forget()
if element.BackgroundColor != COLOR_SYSTEM_DEFAULT and element.BackgroundColor is not None:
labeled_frame.configure(background=element.BackgroundColor,
highlightbackground=element.BackgroundColor,
highlightcolor=element.BackgroundColor)
if element.TextColor != COLOR_SYSTEM_DEFAULT and element.TextColor is not None:
labeled_frame.configure(foreground=element.TextColor)
if font is not None:
labeled_frame.configure(font=font)
if element.TitleLocation is not None:
labeled_frame.configure(labelanchor=element.TitleLocation)
if element.BorderWidth is not None:
labeled_frame.configure(borderwidth=element.BorderWidth)
if element.Tooltip is not None:
element.TooltipObject = ToolTip(labeled_frame, text=element.Tooltip, timeout=DEFAULT_TOOLTIP_TIME)
if element.RightClickMenu or toplevel_form.RightClickMenu:
menu = element.RightClickMenu or toplevel_form.RightClickMenu
top_menu = tk.Menu(toplevel_form.TKroot, tearoff=False)
AddMenuItem(top_menu, menu[1], element)
element.TKRightClickMenu = top_menu
labeled_frame.bind('<Button-3>', element.RightClickMenuCallback)
# ------------------------- Tab element ------------------------- #
elif element_type == ELEM_TYPE_TAB:
element.TKFrame = tk.Frame(form.TKNotebook)
PackFormIntoFrame(element, element.TKFrame, toplevel_form)
if element.Disabled:
form.TKNotebook.add(element.TKFrame, text=element.Title, state='disabled')
else:
form.TKNotebook.add(element.TKFrame, text=element.Title)
form.TKNotebook.pack(side=tk.LEFT, padx=elementpad[0], pady=elementpad[1])
element.ParentNotebook = form.TKNotebook
element.TabID = form.TabCount
form.TabCount += 1
if element.BackgroundColor != COLOR_SYSTEM_DEFAULT and element.BackgroundColor is not None:
element.TKFrame.configure(background=element.BackgroundColor,
highlightbackground=element.BackgroundColor,
highlightcolor=element.BackgroundColor)
# if element.TextColor != COLOR_SYSTEM_DEFAULT and element.TextColor is not None:
# element.TKFrame.configure(foreground=element.TextColor)
# ttk.Style().configure("TNotebook", background='red')
# ttk.Style().map("TNotebook.Tab", background=[("selected", 'orange')],
# foreground=[("selected", 'green')])
# ttk.Style().configure("TNotebook.Tab", background='blue', foreground='yellow')
if element.BorderWidth is not None:
element.TKFrame.configure(borderwidth=element.BorderWidth)
if element.Tooltip is not None:
element.TooltipObject = ToolTip(element.TKFrame, text=element.Tooltip,
timeout=DEFAULT_TOOLTIP_TIME)
if element.RightClickMenu or toplevel_form.RightClickMenu:
menu = element.RightClickMenu or toplevel_form.RightClickMenu
top_menu = tk.Menu(toplevel_form.TKroot, tearoff=False)
AddMenuItem(top_menu, menu[1], element)
element.TKRightClickMenu = top_menu
element.TKFrame.bind('<Button-3>', element.RightClickMenuCallback)
# ------------------------- TabGroup element ------------------------- #
elif element_type == ELEM_TYPE_TAB_GROUP:
custom_style = str(element.Key) + 'customtab.TNotebook'
style = ttk.Style(tk_row_frame)
if element.Theme is not None:
style.theme_use(element.Theme)
if element.TabLocation is not None:
position_dict = {'left': 'w', 'right': 'e', 'top': 'n', 'bottom': 's', 'lefttop': 'wn',
'leftbottom': 'ws', 'righttop': 'en', 'rightbottom': 'es', 'bottomleft': 'sw',
'bottomright': 'se', 'topleft': 'nw', 'topright': 'ne'}
try:
tab_position = position_dict[element.TabLocation]
except:
tab_position = position_dict['top']
style.configure(custom_style, tabposition=tab_position)
if element.BackgroundColor is not None and element.BackgroundColor != COLOR_SYSTEM_DEFAULT:
style.configure(custom_style, background=element.BackgroundColor, foreground='purple')
# style.theme_create("yummy", parent="alt", settings={
# "TNotebook": {"configure": {"tabmargins": [2, 5, 2, 0]}},
# "TNotebook.Tab": {
# "configure": {"padding": [5, 1], "background": mygreen},
# "map": {"background": [("selected", myred)],
# "expand": [("selected", [1, 1, 1, 0])]}}})
# style.configure(custom_style+'.Tab', background='red')
if element.SelectedTitleColor != None:
style.map(custom_style + '.Tab', foreground=[("selected", element.SelectedTitleColor)])
if element.TextColor is not None and element.TextColor != COLOR_SYSTEM_DEFAULT:
style.configure(custom_style + '.Tab', foreground=element.TextColor)
# style.configure(custom_style, background='blue', foreground='yellow')
element.TKNotebook = ttk.Notebook(tk_row_frame, style=custom_style)
PackFormIntoFrame(element, toplevel_form.TKroot, toplevel_form)
if element.ChangeSubmits:
element.TKNotebook.bind('<<NotebookTabChanged>>', element.TabGroupSelectHandler)
if element.BorderWidth is not None:
element.TKNotebook.configure(borderwidth=element.BorderWidth)
if element.Tooltip is not None:
element.TooltipObject = ToolTip(element.TKNotebook, text=element.Tooltip,
timeout=DEFAULT_TOOLTIP_TIME)
# ------------------------- SLIDER element ------------------------- #
elif element_type == ELEM_TYPE_INPUT_SLIDER:
slider_length = element_size[0] * CharWidthInPixels()
slider_width = element_size[1]
element.TKIntVar = tk.IntVar()
element.TKIntVar.set(element.DefaultValue)
if element.Orientation[0] == 'v':
range_from = element.Range[1]
range_to = element.Range[0]
slider_length += DEFAULT_MARGINS[1] * (element_size[0] * 2) # add in the padding
else:
range_from = element.Range[0]
range_to = element.Range[1]
if element.ChangeSubmits:
tkscale = tk.Scale(tk_row_frame, orient=element.Orientation, variable=element.TKIntVar,
from_=range_from, to_=range_to, resolution=element.Resolution,
length=slider_length, width=slider_width, bd=element.BorderWidth,
relief=element.Relief, font=font, tickinterval=element.TickInterval,
command=element.SliderChangedHandler)
else:
tkscale = tk.Scale(tk_row_frame, orient=element.Orientation, variable=element.TKIntVar,
from_=range_from, to_=range_to, resolution=element.Resolution,
length=slider_length, width=slider_width, bd=element.BorderWidth,
relief=element.Relief, font=font, tickinterval=element.TickInterval)
tkscale.config(highlightthickness=0)
if element.BackgroundColor is not None and element.BackgroundColor != COLOR_SYSTEM_DEFAULT:
tkscale.configure(background=element.BackgroundColor)
if DEFAULT_SCROLLBAR_COLOR != COLOR_SYSTEM_DEFAULT:
tkscale.config(troughcolor=DEFAULT_SCROLLBAR_COLOR)
if element.DisableNumericDisplay:
tkscale.config(showvalue=0)
if text_color is not None and text_color != COLOR_SYSTEM_DEFAULT:
tkscale.configure(fg=text_color)
tkscale.pack(side=tk.LEFT, padx=elementpad[0], pady=elementpad[1])
if element.Visible is False:
tkscale.pack_forget()
element.TKScale = tkscale
if element.Disabled == True:
element.TKScale['state'] = 'disabled'
if element.Tooltip is not None:
element.TooltipObject = ToolTip(element.TKScale, text=element.Tooltip, timeout=DEFAULT_TOOLTIP_TIME)
# ------------------------- TABLE element ------------------------- #
elif element_type == ELEM_TYPE_TABLE:
element = element # type: Table
frame = tk.Frame(tk_row_frame)
height = element.NumRows
if element.Justification == 'left':
anchor = tk.W
elif element.Justification == 'right':
anchor = tk.E
else:
anchor = tk.CENTER
column_widths = {}
for row in element.Values:
for i, col in enumerate(row):
col_width = min(len(str(col)), element.MaxColumnWidth)
try:
if col_width > column_widths[i]:
column_widths[i] = col_width
except:
column_widths[i] = col_width
if element.ColumnsToDisplay is None:
displaycolumns = element.ColumnHeadings if element.ColumnHeadings is not None else element.Values[0]
else:
displaycolumns = []
for i, should_display in enumerate(element.ColumnsToDisplay):
if should_display:
displaycolumns.append(element.ColumnHeadings[i])
column_headings = element.ColumnHeadings
if element.DisplayRowNumbers: # if display row number, tack on the numbers to front of columns
displaycolumns = [element.RowHeaderText, ] + displaycolumns
column_headings = [element.RowHeaderText, ] + element.ColumnHeadings
element.TKTreeview = ttk.Treeview(frame, columns=column_headings,
displaycolumns=displaycolumns, show='headings', height=height,
selectmode=element.SelectMode,)
treeview = element.TKTreeview
if element.DisplayRowNumbers:
treeview.heading(element.RowHeaderText, text=element.RowHeaderText) # make a dummy heading
treeview.column(element.RowHeaderText, width=50, anchor=anchor)
headings = element.ColumnHeadings if element.ColumnHeadings is not None else element.Values[0]
for i, heading in enumerate(headings):
treeview.heading(heading, text=heading)
if element.AutoSizeColumns:
width = max(column_widths[i], len(heading))
else:
try:
width = element.ColumnWidths[i]
except:
width = element.DefaultColumnWidth
treeview.column(heading, width=width * CharWidthInPixels(), anchor=anchor)
# Insert values into the tree
for i, value in enumerate(element.Values):
if element.DisplayRowNumbers:
value = [i+element.StartingRowNumber] + value
id = treeview.insert('', 'end', text=value, iid=i + 1, values=value, tag=i)
if element.AlternatingRowColor is not None: # alternating colors
for row in range(0, len(element.Values), 2):
treeview.tag_configure(row, background=element.AlternatingRowColor)
if element.RowColors is not None: # individual row colors
for row_def in element.RowColors:
if len(row_def) == 2: # only background is specified
treeview.tag_configure(row_def[0], background=row_def[1])
else:
treeview.tag_configure(row_def[0], background=row_def[2], foreground=row_def[1])
if element.BackgroundColor is not None and element.BackgroundColor != COLOR_SYSTEM_DEFAULT:
ttk.Style().configure("Treeview", background=element.BackgroundColor,
fieldbackground=element.BackgroundColor)
if element.TextColor is not None and element.TextColor != COLOR_SYSTEM_DEFAULT:
ttk.Style().configure("Treeview", foreground=element.TextColor)
if element.RowHeight is not None:
ttk.Style().configure("Treeview", rowheight=element.RowHeight)
ttk.Style().configure("Treeview", font=font)
# scrollable_frame.pack(side=tk.LEFT, padx=elementpad[0], pady=elementpad[1], expand=True, fill='both')
treeview.bind("<<TreeviewSelect>>", element.treeview_selected)
if element.BindReturnKey:
treeview.bind('<Return>', element.treeview_double_click)
treeview.bind('<Double-Button-1>', element.treeview_double_click)
scrollbar = tk.Scrollbar(frame)
scrollbar.pack(side=tk.RIGHT, fill='y')
scrollbar.config(command=treeview.yview)
if not element.VerticalScrollOnly:
hscrollbar = tk.Scrollbar(frame, orient=tk.HORIZONTAL)
hscrollbar.pack(side=tk.BOTTOM, fill='x')
hscrollbar.config(command=treeview.xview)
treeview.configure(xscrollcommand=hscrollbar.set)
treeview.configure(yscrollcommand=scrollbar.set)
element.TKTreeview.pack(side=tk.LEFT, expand=True, padx=0, pady=0, fill='both')
if element.Visible is False:
element.TKTreeview.pack_forget()
frame.pack(side=tk.LEFT, expand=True, padx=0, pady=0)
if element.Tooltip is not None:
element.TooltipObject = ToolTip(element.TKTreeview, text=element.Tooltip,
timeout=DEFAULT_TOOLTIP_TIME)
if element.RightClickMenu or toplevel_form.RightClickMenu:
menu = element.RightClickMenu or toplevel_form.RightClickMenu
top_menu = tk.Menu(toplevel_form.TKroot, tearoff=False)
AddMenuItem(top_menu, menu[1], element)
element.TKRightClickMenu = top_menu
element.TKTreeview.bind('<Button-3>', element.RightClickMenuCallback)
# ------------------------- Tree element ------------------------- #
elif element_type == ELEM_TYPE_TREE:
element = element #type: Tree
frame = tk.Frame(tk_row_frame)
height = element.NumRows
if element.Justification == 'left': # justification
anchor = tk.W
elif element.Justification == 'right':
anchor = tk.E
else:
anchor = tk.CENTER
if element.ColumnsToDisplay is None: # Which cols to display
displaycolumns = element.ColumnHeadings
else:
displaycolumns = []
for i, should_display in enumerate(element.ColumnsToDisplay):
if should_display:
displaycolumns.append(element.ColumnHeadings[i])
column_headings = element.ColumnHeadings
# ------------- GET THE TREEVIEW WIDGET -------------
element.TKTreeview = ttk.Treeview(frame, columns=column_headings,
displaycolumns=displaycolumns, show='tree headings', height=height,
selectmode=element.SelectMode)
treeview = element.TKTreeview
for i, heading in enumerate(element.ColumnHeadings): # Configure cols + headings
treeview.heading(heading, text=heading)
if element.AutoSizeColumns:
width = min(element.MaxColumnWidth, len(heading) + 1)
else:
try:
width = element.ColumnWidths[i]
except:
width = element.DefaultColumnWidth
treeview.column(heading, width=width * CharWidthInPixels(), anchor=anchor)
def add_treeview_data(node):
# print(f'Inserting {node.key} under parent {node.parent}')
if node.key != '':
if node.icon:
if type(node.icon) is bytes:
photo = tk.PhotoImage(data=node.icon)
else:
photo = tk.PhotoImage(file=node.icon)
node.photo = photo
treeview.insert(node.parent, 'end', node.key, text=node.text, values=node.values, open=element.ShowExpanded, image=node.photo)
else:
treeview.insert(node.parent, 'end', node.key, text=node.text, values=node.values, open=element.ShowExpanded)
for node in node.children:
add_treeview_data(node)
add_treeview_data(element.TreeData.root_node)
treeview.column('#0', width=element.Col0Width * CharWidthInPixels(), anchor=anchor)
# ----- configure colors -----
if element.BackgroundColor is not None and element.BackgroundColor != COLOR_SYSTEM_DEFAULT:
ttk.Style().configure("Treeview", background=element.BackgroundColor,
fieldbackground=element.BackgroundColor)
if element.TextColor is not None and element.TextColor != COLOR_SYSTEM_DEFAULT:
ttk.Style().configure("Treeview", foreground=element.TextColor)
ttk.Style().configure("Treeview", font=font)
if element.RowHeight:
ttk.Style().configure("Treeview", rowheight=element.RowHeight)
scrollbar = tk.Scrollbar(frame)
scrollbar.pack(side=tk.RIGHT, fill='y')
scrollbar.config(command=treeview.yview)
treeview.configure(yscrollcommand=scrollbar.set)
element.TKTreeview.pack(side=tk.LEFT, expand=True, padx=0, pady=0, fill='both')
if element.Visible is False:
element.TKTreeview.pack_forget()
frame.pack(side=tk.LEFT, expand=True, padx=0, pady=0)
treeview.bind("<<TreeviewSelect>>", element.treeview_selected)
treeview.bind("<<TreeviewOpen>>", element.treeview_open)
treeview.bind("<<TreeviewClose>>", element.treeview_close)
if element.Tooltip is not None: # tooltip
element.TooltipObject = ToolTip(element.TKTreeview, text=element.Tooltip,
timeout=DEFAULT_TOOLTIP_TIME)
if element.RightClickMenu or toplevel_form.RightClickMenu:
menu = element.RightClickMenu or toplevel_form.RightClickMenu
top_menu = tk.Menu(toplevel_form.TKroot, tearoff=False)
AddMenuItem(top_menu, menu[1], element)
element.TKRightClickMenu = top_menu
element.TKTreeview.bind('<Button-3>', element.RightClickMenuCallback)
# ------------------------- Separator element ------------------------- #
elif element_type == ELEM_TYPE_SEPARATOR:
element = element # type: VerticalSeparator
separator = ttk.Separator(tk_row_frame, orient=element.Orientation, )
separator.pack(side=tk.LEFT, padx=elementpad[0], pady=elementpad[1], fill='both', expand=True)
# ------------------------- StatusBar element ------------------------- #
elif element_type == ELEM_TYPE_STATUSBAR:
# auto_size_text = element.AutoSizeText
display_text = element.DisplayText # text to display
if auto_size_text is False:
width, height = element_size
else:
lines = display_text.split('\n')
max_line_len = max([len(l) for l in lines])
num_lines = len(lines)
if max_line_len > element_size[0]: # if text exceeds element size, the will have to wrap
width = element_size[0]
else:
width = max_line_len
height = num_lines
# ---===--- LABEL widget create and place --- #
stringvar = tk.StringVar()
element.TKStringVar = stringvar
stringvar.set(display_text)
if auto_size_text:
width = 0
if element.Justification is not None:
justification = element.Justification
elif toplevel_form.TextJustification is not None:
justification = toplevel_form.TextJustification
else:
justification = DEFAULT_TEXT_JUSTIFICATION
justify = tk.LEFT if justification == 'left' else tk.CENTER if justification == 'center' else tk.RIGHT
anchor = tk.NW if justification == 'left' else tk.N if justification == 'center' else tk.NE
# tktext_label = tk.Label(tk_row_frame, textvariable=stringvar, width=width, height=height,
# justify=justify, bd=border_depth, font=font)
tktext_label = tk.Label(tk_row_frame, textvariable=stringvar, width=width, height=height,
justify=justify, bd=border_depth, font=font)
# Set wrap-length for text (in PIXELS) == PAIN IN THE ASS
wraplen = tktext_label.winfo_reqwidth() + 40 # width of widget in Pixels
if not auto_size_text and height == 1:
wraplen = 0
# print("wraplen, width, height", wraplen, width, height)
tktext_label.configure(anchor=anchor, wraplen=wraplen) # set wrap to width of widget
if element.Relief is not None:
tktext_label.configure(relief=element.Relief)
if element.BackgroundColor is not None and element.BackgroundColor != COLOR_SYSTEM_DEFAULT:
tktext_label.configure(background=element.BackgroundColor)
if element.TextColor != COLOR_SYSTEM_DEFAULT and element.TextColor is not None:
tktext_label.configure(fg=element.TextColor)
tktext_label.pack(side=tk.LEFT, padx=elementpad[0], pady=elementpad[1],fill=tk.BOTH, expand=True)
if element.Visible is False:
tktext_label.pack_forget()
element.TKText = tktext_label
if element.ClickSubmits:
tktext_label.bind('<Button-1>', element.TextClickedHandler)
if element.Tooltip is not None:
element.TooltipObject = ToolTip(element.TKText, text=element.Tooltip, timeout=DEFAULT_TOOLTIP_TIME)
# ............................DONE WITH ROW pack the row of widgets ..........................#
# done with row, pack the row of widgets
# tk_row_frame.grid(row=row_num+2, sticky=tk.NW, padx=DEFAULT_MARGINS[0])
tk_row_frame.pack(side=tk.TOP, anchor='nw', padx=toplevel_form.Margins[0], expand=False)
if form.BackgroundColor is not None and form.BackgroundColor != COLOR_SYSTEM_DEFAULT:
tk_row_frame.configure(background=form.BackgroundColor)
toplevel_form.TKroot.configure(padx=toplevel_form.Margins[0], pady=toplevel_form.Margins[1])
return
def ConvertFlexToTK(MyFlexForm:Window):
master = MyFlexForm.TKroot
master.title(MyFlexForm.Title)
InitializeResults(MyFlexForm)
try:
if MyFlexForm.NoTitleBar:
MyFlexForm.TKroot.wm_overrideredirect(True)
except:
pass
PackFormIntoFrame(MyFlexForm, master, MyFlexForm)
# ....................................... DONE creating and laying out window ..........................#
if MyFlexForm._Size != (None, None):
master.geometry("%sx%s" % (MyFlexForm._Size[0], MyFlexForm._Size[1]))
screen_width = master.winfo_screenwidth() # get window info to move to middle of screen
screen_height = master.winfo_screenheight()
if MyFlexForm.Location != (None, None):
x, y = MyFlexForm.Location
elif DEFAULT_WINDOW_LOCATION != (None, None):
x, y = DEFAULT_WINDOW_LOCATION
else:
master.update_idletasks() # don't forget to do updates or values are bad
win_width = master.winfo_width()
win_height = master.winfo_height()
x = screen_width / 2 - win_width / 2
y = screen_height / 2 - win_height / 2
if y + win_height > screen_height:
y = screen_height - win_height
if x + win_width > screen_width:
x = screen_width - win_width
move_string = '+%i+%i' % (int(x), int(y))
master.geometry(move_string)
master.update_idletasks() # don't forget
return
# ----====----====----====----====----==== STARTUP TK ====----====----====----====----====----#
def StartupTK(my_flex_form:Window):
# global _my_windows
# ow = _my_windows.NumOpenWindows
ow = Window.NumOpenWindows
# print('Starting TK open Windows = {}'.format(ow))
if not ow and not my_flex_form.ForceTopLevel:
# if first window being created, make a throwaway, hidden master root. This stops one user
# window from becoming the child of another user window. All windows are children of this
# hidden window
Window.IncrementOpenCount()
Window.hidden_master_root = tk.Tk()
Window.hidden_master_root.attributes('-alpha', 0) # HIDE this window really really really
Window.hidden_master_root.wm_overrideredirect(True)
Window.hidden_master_root.withdraw()
# good
# _my_windows.Increment()
# _my_windows.hidden_master_root = tk.Tk()
# _my_windows.hidden_master_root.attributes('-alpha', 0) # HIDE this window really really really good
# _my_windows.hidden_master_root.wm_overrideredirect(True) # damn, what did this do again?
# _my_windows.hidden_master_root.withdraw() # no, REALLY hide it
root = tk.Toplevel()
else:
root = tk.Toplevel()
try:
root.attributes('-alpha', 0) # hide window while building it. makes for smoother 'paint'
except:
pass
if my_flex_form.BackgroundColor is not None and my_flex_form.BackgroundColor != COLOR_SYSTEM_DEFAULT:
root.configure(background=my_flex_form.BackgroundColor)
Window.IncrementOpenCount()
# _my_windows.Increment()
my_flex_form.TKroot = root
# Make moveable window
if (my_flex_form.GrabAnywhere is not False and not (
my_flex_form.NonBlocking and my_flex_form.GrabAnywhere is not True)):
root.bind("<ButtonPress-1>", my_flex_form.StartMove)
root.bind("<ButtonRelease-1>", my_flex_form.StopMove)
root.bind("<B1-Motion>", my_flex_form.OnMotion)
if not my_flex_form.Resizable:
root.resizable(False, False)
if my_flex_form.DisableMinimize:
root.attributes("-toolwindow", 1)
if my_flex_form.KeepOnTop:
root.wm_attributes("-topmost", 1)
# root.protocol("WM_DELETE_WINDOW", MyFlexForm.DestroyedCallback())
# root.bind('<Destroy>', MyFlexForm.DestroyedCallback())
ConvertFlexToTK(my_flex_form)
my_flex_form.SetIcon(my_flex_form.WindowIcon)
try:
root.attributes('-alpha', my_flex_form.AlphaChannel) # Make window visible again
except:
pass
if my_flex_form.ReturnKeyboardEvents and not my_flex_form.NonBlocking:
root.bind("<KeyRelease>", my_flex_form._KeyboardCallback)
root.bind("<MouseWheel>", my_flex_form._MouseWheelCallback)
elif my_flex_form.ReturnKeyboardEvents:
root.bind("<Key>", my_flex_form._KeyboardCallback)
root.bind("<MouseWheel>", my_flex_form._MouseWheelCallback)
if my_flex_form.AutoClose:
duration = DEFAULT_AUTOCLOSE_TIME if my_flex_form.AutoCloseDuration is None else my_flex_form.AutoCloseDuration
my_flex_form.TKAfterID = root.after(duration * 1000, my_flex_form._AutoCloseAlarmCallback)
if my_flex_form.Timeout != None:
my_flex_form.TKAfterID = root.after(my_flex_form.Timeout, my_flex_form._TimeoutAlarmCallback)
if my_flex_form.NonBlocking:
my_flex_form.TKroot.protocol("WM_DESTROY_WINDOW", my_flex_form.OnClosingCallback)
my_flex_form.TKroot.protocol("WM_DELETE_WINDOW", my_flex_form.OnClosingCallback)
else: # it's a blocking form
# print('..... CALLING MainLoop')
my_flex_form.CurrentlyRunningMainloop = True
my_flex_form.TKroot.protocol("WM_DESTROY_WINDOW", my_flex_form.OnClosingCallback)
my_flex_form.TKroot.protocol("WM_DELETE_WINDOW", my_flex_form.OnClosingCallback)
my_flex_form.TKroot.mainloop()
my_flex_form.CurrentlyRunningMainloop = False
my_flex_form.TimerCancelled = True
# print('..... BACK from MainLoop')
if not my_flex_form.FormRemainedOpen:
Window.DecrementOpenCount()
# _my_windows.Decrement()
if my_flex_form.RootNeedsDestroying:
my_flex_form.TKroot.destroy()
my_flex_form.RootNeedsDestroying = False
return
# ==============================_GetNumLinesNeeded ==#
# Helper function for determining how to wrap text #
# ===================================================#
def _GetNumLinesNeeded(text, max_line_width):
if max_line_width == 0:
return 1
lines = text.split('\n')
num_lines = len(lines) # number of original lines of text
max_line_len = max([len(l) for l in lines]) # longest line
lines_used = []
for L in lines:
lines_used.append(len(L) // max_line_width + (len(L) % max_line_width > 0)) # fancy math to round up
total_lines_needed = sum(lines_used)
return total_lines_needed
# ============================== PROGRESS METER ========================================== #
def ConvertArgsToSingleString(*args):
max_line_total, width_used, total_lines, = 0, 0, 0
single_line_message = ''
# loop through args and built a SINGLE string from them
for message in args:
# fancy code to check if string and convert if not is not need. Just always convert to string :-)
# if not isinstance(message, str): message = str(message)
message = str(message)
longest_line_len = max([len(l) for l in message.split('\n')])
width_used = max(longest_line_len, width_used)
max_line_total = max(max_line_total, width_used)
lines_needed = _GetNumLinesNeeded(message, width_used)
total_lines += lines_needed
single_line_message += message + '\n'
return single_line_message, width_used, total_lines
METER_REASON_CANCELLED = 'cancelled'
METER_REASON_CLOSED = 'closed'
METER_REASON_REACHED_MAX = 'finished'
METER_OK = True
METER_STOPPED = False
class QuickMeter(object):
active_meters = {}
exit_reasons = {}
def __init__(self, title, current_value, max_value, key, *args, orientation='v', bar_color=(None, None),
button_color=(None, None), size=DEFAULT_PROGRESS_BAR_SIZE, border_width=None, grab_anywhere=False):
self.start_time = datetime.datetime.utcnow()
self.key = key
self.orientation = orientation
self.bar_color = bar_color
self.size = size
self.grab_anywhere = grab_anywhere
self.button_color = button_color
self.border_width = border_width
self.title = title
self.current_value = current_value
self.max_value = max_value
self.close_reason = None
self.window = self.BuildWindow(*args)
def BuildWindow(self, *args):
layout = []
if self.orientation.lower().startswith('h'):
col = []
col += [[T(arg)] for arg in args]
col += [[T('', size=(30,10), key='_STATS_')],
[ProgressBar(max_value=self.max_value, orientation='h', key='_PROG_', size=self.size, bar_color=self.bar_color)],
[Cancel(button_color=self.button_color), Stretch()]]
layout = [Column(col)]
else:
col = [[ProgressBar(max_value=self.max_value, orientation='v', key='_PROG_', size=self.size, bar_color=self.bar_color)]]
col2 = []
col2 += [[T(arg)] for arg in args]
col2 += [[T('', size=(30,10), key='_STATS_')],
[Cancel(button_color=self.button_color), Stretch()]]
layout = [Column(col), Column(col2)]
self.window = Window(self.title, grab_anywhere=self.grab_anywhere, border_depth=self.border_width)
self.window.Layout([layout]).Finalize()
return self.window
def UpdateMeter(self, current_value, max_value):
self.current_value = current_value
self.max_value = max_value
self.window.Element('_PROG_').UpdateBar(self.current_value, self.max_value)
self.window.Element('_STATS_').Update('\n'.join(self.ComputeProgressStats()))
event, values = self.window.Read(timeout=0)
if event in('Cancel', None) or current_value >= max_value:
self.window.Close()
del(QuickMeter.active_meters[self.key])
QuickMeter.exit_reasons[self.key] = METER_REASON_CANCELLED if event == 'Cancel' else METER_REASON_CLOSED if event is None else METER_REASON_REACHED_MAX
return QuickMeter.exit_reasons[self.key]
return METER_OK
def ComputeProgressStats(self):
utc = datetime.datetime.utcnow()
time_delta = utc - self.start_time
total_seconds = time_delta.total_seconds()
if not total_seconds:
total_seconds = 1
try:
time_per_item = total_seconds / self.current_value
except:
time_per_item = 1
seconds_remaining = (self.max_value - self.current_value) * time_per_item
time_remaining = str(datetime.timedelta(seconds=seconds_remaining))
time_remaining_short = (time_remaining).split(".")[0]
time_delta_short = str(time_delta).split(".")[0]
total_time = time_delta + datetime.timedelta(seconds=seconds_remaining)
total_time_short = str(total_time).split(".")[0]
self.stat_messages = [
'{} of {}'.format(self.current_value, self.max_value),
'{} %'.format(100 * self.current_value // self.max_value),
'',
' {:6.2f} Iterations per Second'.format(self.current_value / total_seconds),
' {:6.2f} Seconds per Iteration'.format(total_seconds / (self.current_value if self.current_value else 1)),
'',
'{} Elapsed Time'.format(time_delta_short),
'{} Time Remaining'.format(time_remaining_short),
'{} Estimated Total Time'.format(total_time_short)]
return self.stat_messages
def OneLineProgressMeter(title, current_value, max_value, key, *args, orientation='v', bar_color=(None, None),
button_color=None, size=DEFAULT_PROGRESS_BAR_SIZE, border_width=None, grab_anywhere=False):
if key not in QuickMeter.active_meters:
meter = QuickMeter(title, current_value, max_value, key, *args, orientation=orientation, bar_color=bar_color,
button_color=button_color, size=size, border_width=border_width, grab_anywhere=grab_anywhere)
QuickMeter.active_meters[key] = meter
else:
meter = QuickMeter.active_meters[key]
rc = meter.UpdateMeter(current_value, max_value)
OneLineProgressMeter.exit_reasons = getattr(OneLineProgressMeter,'exit_reasons', QuickMeter.exit_reasons)
return rc == METER_OK
def OneLineProgressMeterCancel(key):
try:
meter = QuickMeter.active_meters[key]
meter.window.Close()
del(QuickMeter.active_meters[key])
QuickMeter.exit_reasons[key] = METER_REASON_CANCELLED
except: # meter is already deleted
return
# input is #RRGGBB
# output is #RRGGBB
def GetComplimentaryHex(color):
# strip the # from the beginning
color = color[1:]
# convert the string into hex
color = int(color, 16)
# invert the three bytes
# as good as substracting each of RGB component by 255(FF)
comp_color = 0xFFFFFF ^ color
# convert the color back to hex by prefixing a #
comp_color = "#%06X" % comp_color
return comp_color
# ======================== EasyPrint =====#
# ===================================================#
class DebugWin():
debug_window = None
def __init__(self, size=(None, None), location=(None, None), font=None, no_titlebar=False, no_button=False,
grab_anywhere=False, keep_on_top=False, do_not_reroute_stdout=True):
# Show a form that's a running counter
self.size = size
self.location = location
self.font = font
self.no_titlebar = no_titlebar
self.no_button = no_button
self.grab_anywhere = grab_anywhere
self.keep_on_top = keep_on_top
self.do_not_reroute_stdout = do_not_reroute_stdout
win_size = size if size != (None, None) else DEFAULT_DEBUG_WINDOW_SIZE
self.window = Window('Debug Window', no_titlebar=no_titlebar, auto_size_text=True, location=location,
font=font or ('Courier New', 10), grab_anywhere=grab_anywhere, keep_on_top=keep_on_top)
self.output_element = Multiline(size=win_size, autoscroll=True, key='_MULTILINE_') if do_not_reroute_stdout else Output(size=win_size)
if no_button:
self.layout = [[self.output_element]]
else:
self.layout = [
[self.output_element],
[DummyButton('Quit'), Stretch()]
]
self.window.AddRows(self.layout)
self.window.Read(timeout=0) # Show a non-blocking form, returns immediately
return
def Print(self, *args, end=None, sep=None):
sepchar = sep if sep is not None else ' '
endchar = end if end is not None else '\n'
if self.window is None: # if window was destroyed alread re-open it
self.__init__(size=self.size, location=self.location, font=self.font, no_titlebar=self.no_titlebar, no_button=self.no_button, grab_anywhere=self.grab_anywhere, keep_on_top=self.keep_on_top, do_not_reroute_stdout=self.do_not_reroute_stdout)
event, values = self.window.Read(timeout=0)
if event == 'Quit' or event is None:
self.Close()
self.__init__(size=self.size, location=self.location, font=self.font, no_titlebar=self.no_titlebar, no_button=self.no_button, grab_anywhere=self.grab_anywhere, keep_on_top=self.keep_on_top, do_not_reroute_stdout=self.do_not_reroute_stdout)
if self.do_not_reroute_stdout:
outstring = ''
for arg in args:
outstring += str(arg) + sepchar
outstring += endchar
self.output_element.Update(outstring, append=True)
else:
print(*args, sep=sepchar, end=endchar)
def Close(self):
self.window.Close()
self.window.__del__()
self.window = None
def PrintClose():
EasyPrintClose()
def EasyPrint(*args, size=(None, None), end=None, sep=None, location=(None, None), font=None, no_titlebar=False,
no_button=False, grab_anywhere=False, keep_on_top=False, do_not_reroute_stdout=False):
if DebugWin.debug_window is None:
DebugWin.debug_window = DebugWin(size=size, location=location, font=font, no_titlebar=no_titlebar,
no_button=no_button, grab_anywhere=grab_anywhere, keep_on_top=keep_on_top, do_not_reroute_stdout=do_not_reroute_stdout)
DebugWin.debug_window.Print(*args, end=end, sep=sep)
Print = EasyPrint
eprint = EasyPrint
def EasyPrintClose():
if DebugWin.debug_window is not None:
DebugWin.debug_window.Close()
DebugWin.debug_window = None
# ======================== Scrolled Text Box =====#
# ===================================================#
def PopupScrolled(*args, button_color=None, yes_no=False, auto_close=False, auto_close_duration=None, size=(None, None), location=(None, None), title=None, non_blocking=False):
if not args: return
width, height = size
width = width if width else MESSAGE_BOX_LINE_WIDTH
window = Window(title=title or args[0], auto_size_text=True, button_color=button_color, auto_close=auto_close,
auto_close_duration=auto_close_duration, location=location)
max_line_total, max_line_width, total_lines, height_computed = 0, 0, 0, 0
complete_output = ''
for message in args:
# fancy code to check if string and convert if not is not need. Just always convert to string :-)
# if not isinstance(message, str): message = str(message)
message = str(message)
longest_line_len = max([len(l) for l in message.split('\n')])
width_used = min(longest_line_len, width)
max_line_total = max(max_line_total, width_used)
max_line_width = width
lines_needed = _GetNumLinesNeeded(message, width_used)
height_computed += lines_needed
complete_output += message + '\n'
total_lines += lines_needed
height_computed = MAX_SCROLLED_TEXT_BOX_HEIGHT if height_computed > MAX_SCROLLED_TEXT_BOX_HEIGHT else height_computed
if height:
height_computed = height
window.AddRow(Multiline(complete_output, size=(max_line_width, height_computed)))
pad = max_line_total - 15 if max_line_total > 15 else 1
# show either an OK or Yes/No depending on paramater
button = DummyButton if non_blocking else Button
if yes_no:
window.AddRow(Text('', size=(pad, 1), auto_size_text=False), button('Yes'), button('No'))
else:
window.AddRow(Text('', size=(pad, 1), auto_size_text=False), button('OK', size=(5, 1), button_color=button_color))
if non_blocking:
button, values = window.Read(timeout=0)
else:
button, values = window.Read()
return button
ScrolledTextBox = PopupScrolled
# ============================== SetGlobalIcon ======#
# Sets the icon to be used by default #
# ===================================================#
def SetGlobalIcon(icon):
# global _my_windows
try:
with open(icon, 'r') as icon_file:
pass
except:
raise FileNotFoundError
# _my_windows.user_defined_icon = icon
Window.user_defined_icon = icon
return True
# ============================== SetOptions =========#
# Sets the icon to be used by default #
# ===================================================#
def SetOptions(icon=None, button_color=None, element_size=(None, None), button_element_size=(None, None),
margins=(None, None),
element_padding=(None, None), auto_size_text=None, auto_size_buttons=None, font=None, border_width=None,
slider_border_width=None, slider_relief=None, slider_orientation=None,
autoclose_time=None, message_box_line_width=None,
progress_meter_border_depth=None, progress_meter_style=None,
progress_meter_relief=None, progress_meter_color=None, progress_meter_size=None,
text_justification=None, background_color=None, element_background_color=None,
text_element_background_color=None, input_elements_background_color=None, input_text_color=None,
scrollbar_color=None, text_color=None, element_text_color=None, debug_win_size=(None, None),
window_location=(None, None), error_button_color=(None,None), tooltip_time=None):
global DEFAULT_ELEMENT_SIZE
global DEFAULT_BUTTON_ELEMENT_SIZE
global DEFAULT_MARGINS # Margins for each LEFT/RIGHT margin is first term
global DEFAULT_ELEMENT_PADDING # Padding between elements (row, col) in pixels
global DEFAULT_AUTOSIZE_TEXT
global DEFAULT_AUTOSIZE_BUTTONS
global DEFAULT_FONT
global DEFAULT_BORDER_WIDTH
global DEFAULT_AUTOCLOSE_TIME
global DEFAULT_BUTTON_COLOR
global MESSAGE_BOX_LINE_WIDTH
global DEFAULT_PROGRESS_BAR_BORDER_WIDTH
global DEFAULT_PROGRESS_BAR_STYLE
global DEFAULT_PROGRESS_BAR_RELIEF
global DEFAULT_PROGRESS_BAR_COLOR
global DEFAULT_PROGRESS_BAR_SIZE
global DEFAULT_TEXT_JUSTIFICATION
global DEFAULT_DEBUG_WINDOW_SIZE
global DEFAULT_SLIDER_BORDER_WIDTH
global DEFAULT_SLIDER_RELIEF
global DEFAULT_SLIDER_ORIENTATION
global DEFAULT_BACKGROUND_COLOR
global DEFAULT_INPUT_ELEMENTS_COLOR
global DEFAULT_ELEMENT_BACKGROUND_COLOR
global DEFAULT_TEXT_ELEMENT_BACKGROUND_COLOR
global DEFAULT_SCROLLBAR_COLOR
global DEFAULT_TEXT_COLOR
global DEFAULT_WINDOW_LOCATION
global DEFAULT_ELEMENT_TEXT_COLOR
global DEFAULT_INPUT_TEXT_COLOR
global DEFAULT_TOOLTIP_TIME
global DEFAULT_ERROR_BUTTON_COLOR
# global _my_windows
if icon:
Window.user_defined_icon = icon
# _my_windows.user_defined_icon = icon
if button_color != None:
DEFAULT_BUTTON_COLOR = button_color
if element_size != (None, None):
DEFAULT_ELEMENT_SIZE = element_size
if button_element_size != (None, None):
DEFAULT_BUTTON_ELEMENT_SIZE = button_element_size
if margins != (None, None):
DEFAULT_MARGINS = margins
if element_padding != (None, None):
DEFAULT_ELEMENT_PADDING = element_padding
if auto_size_text != None:
DEFAULT_AUTOSIZE_TEXT = auto_size_text
if auto_size_buttons != None:
DEFAULT_AUTOSIZE_BUTTONS = auto_size_buttons
if font != None:
DEFAULT_FONT = font
if border_width != None:
DEFAULT_BORDER_WIDTH = border_width
if autoclose_time != None:
DEFAULT_AUTOCLOSE_TIME = autoclose_time
if message_box_line_width != None:
MESSAGE_BOX_LINE_WIDTH = message_box_line_width
if progress_meter_border_depth != None:
DEFAULT_PROGRESS_BAR_BORDER_WIDTH = progress_meter_border_depth
if progress_meter_style != None:
DEFAULT_PROGRESS_BAR_STYLE = progress_meter_style
if progress_meter_relief != None:
DEFAULT_PROGRESS_BAR_RELIEF = progress_meter_relief
if progress_meter_color != None:
DEFAULT_PROGRESS_BAR_COLOR = progress_meter_color
if progress_meter_size != None:
DEFAULT_PROGRESS_BAR_SIZE = progress_meter_size
if slider_border_width != None:
DEFAULT_SLIDER_BORDER_WIDTH = slider_border_width
if slider_orientation != None:
DEFAULT_SLIDER_ORIENTATION = slider_orientation
if slider_relief != None:
DEFAULT_SLIDER_RELIEF = slider_relief
if text_justification != None:
DEFAULT_TEXT_JUSTIFICATION = text_justification
if background_color != None:
DEFAULT_BACKGROUND_COLOR = background_color
if text_element_background_color != None:
DEFAULT_TEXT_ELEMENT_BACKGROUND_COLOR = text_element_background_color
if input_elements_background_color != None:
DEFAULT_INPUT_ELEMENTS_COLOR = input_elements_background_color
if element_background_color != None:
DEFAULT_ELEMENT_BACKGROUND_COLOR = element_background_color
if window_location != (None, None):
DEFAULT_WINDOW_LOCATION = window_location
if debug_win_size != (None, None):
DEFAULT_DEBUG_WINDOW_SIZE = debug_win_size
if text_color != None:
DEFAULT_TEXT_COLOR = text_color
if scrollbar_color != None:
DEFAULT_SCROLLBAR_COLOR = scrollbar_color
if element_text_color != None:
DEFAULT_ELEMENT_TEXT_COLOR = element_text_color
if input_text_color is not None:
DEFAULT_INPUT_TEXT_COLOR = input_text_color
if tooltip_time is not None:
DEFAULT_TOOLTIP_TIME = tooltip_time
if error_button_color != (None,None):
DEFAULT_ERROR_BUTTON_COLOR = error_button_color
return True
#################### ChangeLookAndFeel #######################
# Predefined settings that will change the colors and styles #
# of the elements. #
##############################################################
LOOK_AND_FEEL_TABLE = {'SystemDefault':
{'BACKGROUND': COLOR_SYSTEM_DEFAULT,
'TEXT': COLOR_SYSTEM_DEFAULT,
'INPUT': COLOR_SYSTEM_DEFAULT, 'TEXT_INPUT': COLOR_SYSTEM_DEFAULT,
'SCROLL': COLOR_SYSTEM_DEFAULT,
'BUTTON': OFFICIAL_PYSIMPLEGUI_BUTTON_COLOR,
'PROGRESS': COLOR_SYSTEM_DEFAULT,
'BORDER': 1, 'SLIDER_DEPTH': 1,
'PROGRESS_DEPTH': 0},
'Reddit': {'BACKGROUND': '#ffffff',
'TEXT': '#1a1a1b',
'INPUT': '#dae0e6',
'TEXT_INPUT': '#222222',
'SCROLL': '#a5a4a4',
'BUTTON': ('white', '#0079d3'),
'PROGRESS': DEFAULT_PROGRESS_BAR_COLOR,
'BORDER': 1,
'SLIDER_DEPTH': 0,
'PROGRESS_DEPTH': 0,
'ACCENT1': '#ff5414',
'ACCENT2': '#33a8ff',
'ACCENT3': '#dbf0ff'},
'Topanga': {'BACKGROUND': '#282923',
'TEXT': '#E7DB74',
'INPUT': '#393a32',
'TEXT_INPUT': '#E7C855',
'SCROLL': '#E7C855',
'BUTTON': ('#E7C855', '#284B5A'),
'PROGRESS': DEFAULT_PROGRESS_BAR_COLOR,
'BORDER': 1, 'SLIDER_DEPTH': 0,
'PROGRESS_DEPTH': 0,
'ACCENT1': '#c15226',
'ACCENT2': '#7a4d5f',
'ACCENT3': '#889743'},
'GreenTan': {'BACKGROUND': '#9FB8AD',
'TEXT': COLOR_SYSTEM_DEFAULT,
'INPUT': '#F7F3EC', 'TEXT_INPUT': 'black',
'SCROLL': '#F7F3EC',
'BUTTON': ('white', '#475841'),
'PROGRESS': DEFAULT_PROGRESS_BAR_COLOR,
'BORDER': 1, 'SLIDER_DEPTH': 0,
'PROGRESS_DEPTH': 0},
'Dark': {'BACKGROUND': 'gray25',
'TEXT': 'white',
'INPUT': 'gray30',
'TEXT_INPUT': 'white',
'SCROLL': 'gray44',
'BUTTON': ('white', '#004F00'),
'PROGRESS': DEFAULT_PROGRESS_BAR_COLOR,
'BORDER': 1,
'SLIDER_DEPTH': 0,
'PROGRESS_DEPTH': 0},
'LightGreen': {'BACKGROUND': '#B7CECE',
'TEXT': 'black',
'INPUT': '#FDFFF7',
'TEXT_INPUT': 'black',
'SCROLL': '#FDFFF7',
'BUTTON': ('white', '#658268'),
'PROGRESS': DEFAULT_PROGRESS_BAR_COLOR,
'BORDER': 1,
'SLIDER_DEPTH': 0,
'ACCENT1': '#76506d',
'ACCENT2': '#5148f1',
'ACCENT3': '#0a1c84',
'PROGRESS_DEPTH': 0},
'Dark2': {'BACKGROUND': 'gray25',
'TEXT': 'white',
'INPUT': 'white',
'TEXT_INPUT': 'black',
'SCROLL': 'gray44',
'BUTTON': ('white', '#004F00'),
'PROGRESS': DEFAULT_PROGRESS_BAR_COLOR,
'BORDER': 1,
'SLIDER_DEPTH': 0,
'PROGRESS_DEPTH': 0},
'Black': {'BACKGROUND': 'black',
'TEXT': 'white',
'INPUT': 'gray30',
'TEXT_INPUT': 'white',
'SCROLL': 'gray44',
'BUTTON': ('black', 'white'),
'PROGRESS': DEFAULT_PROGRESS_BAR_COLOR,
'BORDER': 1,
'SLIDER_DEPTH': 0,
'PROGRESS_DEPTH': 0},
'Tan': {'BACKGROUND': '#fdf6e3',
'TEXT': '#268bd1',
'INPUT': '#eee8d5',
'TEXT_INPUT': '#6c71c3',
'SCROLL': '#eee8d5',
'BUTTON': ('white', '#063542'),
'PROGRESS': DEFAULT_PROGRESS_BAR_COLOR,
'BORDER': 1,
'SLIDER_DEPTH': 0,
'PROGRESS_DEPTH': 0},
'TanBlue': {'BACKGROUND': '#e5dece',
'TEXT': '#063289',
'INPUT': '#f9f8f4',
'TEXT_INPUT': '#242834',
'SCROLL': '#eee8d5',
'BUTTON': ('white', '#063289'),
'PROGRESS': DEFAULT_PROGRESS_BAR_COLOR,
'BORDER': 1,
'SLIDER_DEPTH': 0,
'PROGRESS_DEPTH': 0},
'DarkTanBlue': {'BACKGROUND': '#242834',
'TEXT': '#dfe6f8',
'INPUT': '#97755c',
'TEXT_INPUT': 'white',
'SCROLL': '#a9afbb',
'BUTTON': ('white', '#063289'),
'PROGRESS': DEFAULT_PROGRESS_BAR_COLOR,
'BORDER': 1,
'SLIDER_DEPTH': 0,
'PROGRESS_DEPTH': 0},
'DarkAmber': {'BACKGROUND': '#2c2825',
'TEXT': '#fdcb52',
'INPUT': '#705e52',
'TEXT_INPUT': '#fdcb52',
'SCROLL': '#705e52',
'BUTTON': ('black', '#fdcb52'),
'PROGRESS': DEFAULT_PROGRESS_BAR_COLOR,
'BORDER': 1,
'SLIDER_DEPTH': 0,
'PROGRESS_DEPTH': 0},
'DarkBlue': {'BACKGROUND': '#1a2835',
'TEXT': '#d1ecff',
'INPUT': '#335267',
'TEXT_INPUT': '#acc2d0',
'SCROLL': '#1b6497',
'BUTTON': ('black', '#fafaf8'),
'PROGRESS': DEFAULT_PROGRESS_BAR_COLOR,
'BORDER': 1, 'SLIDER_DEPTH': 0,
'PROGRESS_DEPTH': 0},
'Reds': {'BACKGROUND': '#280001',
'TEXT': 'white',
'INPUT': '#d8d584',
'TEXT_INPUT': 'black',
'SCROLL': '#763e00',
'BUTTON': ('black', '#daad28'),
'PROGRESS': DEFAULT_PROGRESS_BAR_COLOR,
'BORDER': 1,
'SLIDER_DEPTH': 0,
'PROGRESS_DEPTH': 0},
'Green': {'BACKGROUND': '#82a459',
'TEXT': 'black',
'INPUT': '#d8d584',
'TEXT_INPUT': 'black',
'SCROLL': '#e3ecf3',
'BUTTON': ('white', '#517239'),
'PROGRESS': DEFAULT_PROGRESS_BAR_COLOR,
'BORDER': 1,
'SLIDER_DEPTH': 0,
'PROGRESS_DEPTH': 0},
'BluePurple': {'BACKGROUND': '#A5CADD',
'TEXT': '#6E266E',
'INPUT': '#E0F5FF',
'TEXT_INPUT': 'black',
'SCROLL': '#E0F5FF',
'BUTTON': ('white', '#303952'),
'PROGRESS': DEFAULT_PROGRESS_BAR_COLOR,
'BORDER': 1,
'SLIDER_DEPTH': 0,
'PROGRESS_DEPTH': 0},
'Purple': {'BACKGROUND': '#B0AAC2',
'TEXT': 'black',
'INPUT': '#F2EFE8',
'SCROLL': '#F2EFE8',
'TEXT_INPUT': 'black',
'BUTTON': ('black', '#C2D4D8'),
'PROGRESS': DEFAULT_PROGRESS_BAR_COLOR,
'BORDER': 1,
'SLIDER_DEPTH': 0,
'PROGRESS_DEPTH': 0},
'BlueMono': {'BACKGROUND': '#AAB6D3',
'TEXT': 'black',
'INPUT': '#F1F4FC',
'SCROLL': '#F1F4FC',
'TEXT_INPUT': 'black',
'BUTTON': ('white', '#7186C7'),
'PROGRESS': DEFAULT_PROGRESS_BAR_COLOR,
'BORDER': 1,
'SLIDER_DEPTH': 0,
'PROGRESS_DEPTH': 0},
'GreenMono': {'BACKGROUND': '#A8C1B4',
'TEXT': 'black',
'INPUT': '#DDE0DE',
'SCROLL': '#E3E3E3',
'TEXT_INPUT': 'black',
'BUTTON': ('white', '#6D9F85'),
'PROGRESS': DEFAULT_PROGRESS_BAR_COLOR,
'BORDER': 1,
'SLIDER_DEPTH': 0,
'PROGRESS_DEPTH': 0},
'BrownBlue': {'BACKGROUND': '#64778d',
'TEXT': 'white',
'INPUT': '#f0f3f7',
'SCROLL': '#A6B2BE',
'TEXT_INPUT': 'black',
'BUTTON': ('white', '#283b5b'),
'PROGRESS': DEFAULT_PROGRESS_BAR_COLOR,
'BORDER': 1,
'SLIDER_DEPTH': 0,
'PROGRESS_DEPTH': 0},
'BrightColors': {'BACKGROUND': '#b4ffb4',
'TEXT': 'black',
'INPUT': '#ffff64',
'SCROLL': '#ffb482',
'TEXT_INPUT': 'black',
'BUTTON': ('black', '#ffa0dc'),
'PROGRESS': DEFAULT_PROGRESS_BAR_COLOR,
'BORDER': 1,
'SLIDER_DEPTH': 0,
'PROGRESS_DEPTH': 0},
'NeutralBlue': {'BACKGROUND': '#92aa9d',
'TEXT': 'black',
'INPUT': '#fcfff6',
'SCROLL': '#fcfff6',
'TEXT_INPUT': 'black',
'BUTTON': ('black', '#d0dbbd'),
'PROGRESS': DEFAULT_PROGRESS_BAR_COLOR,
'BORDER': 1,
'SLIDER_DEPTH': 0,
'PROGRESS_DEPTH': 0},
'Kayak': {'BACKGROUND': '#a7ad7f',
'TEXT': 'black',
'INPUT': '#e6d3a8',
'SCROLL': '#e6d3a8',
'TEXT_INPUT': 'black',
'BUTTON': ('white', '#5d907d'),
'PROGRESS': DEFAULT_PROGRESS_BAR_COLOR,
'BORDER': 1,
'SLIDER_DEPTH': 0,
'PROGRESS_DEPTH': 0},
'SandyBeach': {'BACKGROUND': '#efeccb',
'TEXT': '#012f2f',
'INPUT': '#e6d3a8',
'SCROLL': '#e6d3a8',
'TEXT_INPUT': '#012f2f',
'BUTTON': ('white', '#046380'),
'PROGRESS': DEFAULT_PROGRESS_BAR_COLOR,
'BORDER': 1, 'SLIDER_DEPTH': 0,
'PROGRESS_DEPTH': 0},
'TealMono': {'BACKGROUND': '#a8cfdd',
'TEXT': 'black',
'INPUT': '#dfedf2', 'SCROLL': '#dfedf2',
'TEXT_INPUT': 'black',
'BUTTON': ('white', '#183440'),
'PROGRESS': DEFAULT_PROGRESS_BAR_COLOR,
'BORDER': 1,
'SLIDER_DEPTH': 0,
'PROGRESS_DEPTH': 0}
}
def ListOfLookAndFeelValues():
return list(LOOK_AND_FEEL_TABLE.keys())
def ChangeLookAndFeel(index):
# global LOOK_AND_FEEL_TABLE
if sys.platform == 'darwin':
print('*** Changing look and feel is not supported on Mac platform ***')
return
# look and feel table
try:
colors = LOOK_AND_FEEL_TABLE[index]
SetOptions(background_color=colors['BACKGROUND'],
text_element_background_color=colors['BACKGROUND'],
element_background_color=colors['BACKGROUND'],
text_color=colors['TEXT'],
input_elements_background_color=colors['INPUT'],
button_color=colors['BUTTON'],
progress_meter_color=colors['PROGRESS'],
border_width=colors['BORDER'],
slider_border_width=colors['SLIDER_DEPTH'],
progress_meter_border_depth=colors['PROGRESS_DEPTH'],
scrollbar_color=(colors['SCROLL']),
element_text_color=colors['TEXT'],
input_text_color=colors['TEXT_INPUT'])
except: # most likely an index out of range
print('** Warning - Look and Feel value not valid. Change your ChangeLookAndFeel call. **')
# ============================== sprint ======#
# Is identical to the Scrolled Text Box #
# Provides a crude 'print' mechanism but in a #
# GUI environment #
# ============================================#
sprint = ScrolledTextBox
# Converts an object's contents into a nice printable string. Great for dumping debug data
def ObjToStringSingleObj(obj):
if obj is None:
return 'None'
return str(obj.__class__) + '\n' + '\n'.join(
(repr(item) + ' = ' + repr(obj.__dict__[item]) for item in sorted(obj.__dict__)))
def ObjToString(obj, extra=' '):
if obj is None:
return 'None'
return str(obj.__class__) + '\n' + '\n'.join(
(extra + (str(item) + ' = ' +
(ObjToString(obj.__dict__[item], extra + ' ') if hasattr(obj.__dict__[item], '__dict__') else str(
obj.__dict__[item])))
for item in sorted(obj.__dict__)))
# ------------------------------------------------------------------------------------------------------------------ #
# ===================================== Upper PySimpleGUI ======================================================== #
# Pre-built dialog boxes for all your needs These are the "high level API calls #
# ------------------------------------------------------------------------------------------------------------------ #
# ----------------------------------- The mighty Popup! ------------------------------------------------------------ #
def Popup(*args, title=None, button_color=None, background_color=None, text_color=None, button_type=POPUP_BUTTONS_OK,
auto_close=False, auto_close_duration=None, custom_text=(None, None), non_blocking=False, icon=DEFAULT_WINDOW_ICON, line_width=None,
font=None, no_titlebar=False, grab_anywhere=False, keep_on_top=False, location=(None, None)):
"""
Popup - Display a popup box with as many parms as you wish to include
:param args:
:param button_color:
:param background_color:
:param text_color:
:param button_type:
:param auto_close:
:param auto_close_duration:
:param non_blocking:
:param icon:
:param line_width:
:param font:
:param no_titlebar:
:param grab_anywhere:
:param keep_on_top:
:param location:
:return:
"""
if not args:
args_to_print = ['']
else:
args_to_print = args
if line_width != None:
local_line_width = line_width
else:
local_line_width = MESSAGE_BOX_LINE_WIDTH
_title = title if title is not None else args_to_print[0]
window = Window(_title, auto_size_text=True, background_color=background_color, button_color=button_color,
auto_close=auto_close, auto_close_duration=auto_close_duration, icon=icon, font=font,
no_titlebar=no_titlebar, grab_anywhere=grab_anywhere, keep_on_top=keep_on_top, location=location)
max_line_total, total_lines = 0, 0
for message in args_to_print:
# fancy code to check if string and convert if not is not need. Just always convert to string :-)
# if not isinstance(message, str): message = str(message)
message = str(message)
if message.count('\n'):
message_wrapped = message
else:
message_wrapped = textwrap.fill(message, local_line_width)
message_wrapped_lines = message_wrapped.count('\n') + 1
longest_line_len = max([len(l) for l in message.split('\n')])
width_used = min(longest_line_len, local_line_width)
max_line_total = max(max_line_total, width_used)
# height = _GetNumLinesNeeded(message, width_used)
height = message_wrapped_lines
window.AddRow(
Text(message_wrapped, auto_size_text=True, text_color=text_color, background_color=background_color))
total_lines += height
if non_blocking:
PopupButton = DummyButton # important to use or else button will close other windows too!
else:
PopupButton = CloseButton
# show either an OK or Yes/No depending on paramater
if custom_text != (None, None):
if type(custom_text) is not tuple:
window.AddRow(PopupButton(custom_text,size=(len(custom_text),1), button_color=button_color, focus=True, bind_return_key=True))
elif custom_text[1] is None:
window.AddRow(PopupButton(custom_text[0],size=(len(custom_text[0]),1), button_color=button_color, focus=True, bind_return_key=True))
else:
window.AddRow(PopupButton(custom_text[0], button_color=button_color, focus=True, bind_return_key=True, size=(len(custom_text[0]), 1)),
PopupButton(custom_text[1], button_color=button_color, size=(len(custom_text[0]), 1)))
elif button_type is POPUP_BUTTONS_YES_NO:
window.AddRow(PopupButton('Yes', button_color=button_color, focus=True, bind_return_key=True, pad=((20, 5), 3),
size=(5, 1)), PopupButton('No', button_color=button_color, size=(5, 1)))
elif button_type is POPUP_BUTTONS_CANCELLED:
window.AddRow(
PopupButton('Cancelled', button_color=button_color, focus=True, bind_return_key=True, pad=((20, 0), 3)))
elif button_type is POPUP_BUTTONS_ERROR:
window.AddRow(PopupButton('Error', size=(6, 1), button_color=button_color, focus=True, bind_return_key=True,
pad=((20, 0), 3)))
elif button_type is POPUP_BUTTONS_OK_CANCEL:
window.AddRow(PopupButton('OK', size=(6, 1), button_color=button_color, focus=True, bind_return_key=True),
PopupButton('Cancel', size=(6, 1), button_color=button_color))
elif button_type is POPUP_BUTTONS_NO_BUTTONS:
pass
else:
window.AddRow(PopupButton('OK', size=(5, 1), button_color=button_color, focus=True, bind_return_key=True,
pad=((20, 0), 3)))
if non_blocking:
button, values = window.Read(timeout=0)
else:
button, values = window.Read()
return button
# ============================== MsgBox============#
# Lazy function. Same as calling Popup with parms #
# This function WILL Disappear perhaps today #
# ==================================================#
# MsgBox is the legacy call and should not be used any longer
def MsgBox(*args):
raise DeprecationWarning('MsgBox is no longer supported... change your call to Popup')
# --------------------------- PopupNoButtons ---------------------------
def PopupNoButtons(*args, title=None, button_color=None, background_color=None, text_color=None, auto_close=False,
auto_close_duration=None, non_blocking=False, icon=DEFAULT_WINDOW_ICON, line_width=None, font=None,
no_titlebar=False, grab_anywhere=False, keep_on_top=False, location=(None, None)):
"""
Show a Popup but without any buttons
:param args:
:param button_color:
:param background_color:
:param text_color:
:param auto_close:
:param auto_close_duration:
:param non_blocking:
:param icon:
:param line_width:
:param font:
:param no_titlebar:
:param grab_anywhere:
:param keep_on_top:
:param location:
:return:
"""
Popup(*args, title=title, button_color=button_color, background_color=background_color, text_color=text_color,
button_type=POPUP_BUTTONS_NO_BUTTONS,
auto_close=auto_close, auto_close_duration=auto_close_duration, non_blocking=non_blocking, icon=icon,
line_width=line_width,
font=font, no_titlebar=no_titlebar, grab_anywhere=grab_anywhere, keep_on_top=keep_on_top, location=location)
# --------------------------- PopupNonBlocking ---------------------------
def PopupNonBlocking(*args, title=None, button_type=POPUP_BUTTONS_OK, button_color=None, background_color=None, text_color=None,
auto_close=False, auto_close_duration=None, non_blocking=True, icon=DEFAULT_WINDOW_ICON,
line_width=None, font=None, no_titlebar=False, grab_anywhere=False, keep_on_top=False,
location=(None, None)):
"""
Show Popup box and immediately return (does not block)
:param args:
:param button_type:
:param button_color:
:param background_color:
:param text_color:
:param auto_close:
:param auto_close_duration:
:param non_blocking:
:param icon:
:param line_width:
:param font:
:param no_titlebar:
:param grab_anywhere:
:param keep_on_top:
:param location:
:return:
"""
Popup(*args, title=title, button_color=button_color, background_color=background_color, text_color=text_color,
button_type=button_type,
auto_close=auto_close, auto_close_duration=auto_close_duration, non_blocking=non_blocking, icon=icon,
line_width=line_width,
font=font, no_titlebar=no_titlebar, grab_anywhere=grab_anywhere, keep_on_top=keep_on_top, location=location)
PopupNoWait = PopupNonBlocking
# --------------------------- PopupQuick - a NonBlocking, Self-closing Popup ---------------------------
def PopupQuick(*args,title=None, button_type=POPUP_BUTTONS_OK, button_color=None, background_color=None, text_color=None,
auto_close=True, auto_close_duration=2, non_blocking=True, icon=DEFAULT_WINDOW_ICON, line_width=None,
font=None, no_titlebar=False, grab_anywhere=False, keep_on_top=False, location=(None, None)):
"""
Show Popup box that doesn't block and closes itself
:param args:
:param button_type:
:param button_color:
:param background_color:
:param text_color:
:param auto_close:
:param auto_close_duration:
:param non_blocking:
:param icon:
:param line_width:
:param font:
:param no_titlebar:
:param grab_anywhere:
:param keep_on_top:
:param location:
:return:
"""
Popup(*args, title=title, button_color=button_color, background_color=background_color, text_color=text_color,
button_type=button_type,
auto_close=auto_close, auto_close_duration=auto_close_duration, non_blocking=non_blocking, icon=icon,
line_width=line_width,
font=font, no_titlebar=no_titlebar, grab_anywhere=grab_anywhere, keep_on_top=keep_on_top, location=location)
# --------------------------- PopupQuick - a NonBlocking, Self-closing Popup with no titlebar and no buttons ---------------------------
def PopupQuickMessage(*args, title=None, button_type=POPUP_BUTTONS_NO_BUTTONS, button_color=None, background_color=None, text_color=None,
auto_close=True, auto_close_duration=2, non_blocking=True, icon=DEFAULT_WINDOW_ICON, line_width=None,
font=None, no_titlebar=True, grab_anywhere=False, keep_on_top=False, location=(None, None)):
"""
Show Popup box that doesn't block and closes itself
:param args:
:param button_type:
:param button_color:
:param background_color:
:param text_color:
:param auto_close:
:param auto_close_duration:
:param non_blocking:
:param icon:
:param line_width:
:param font:
:param no_titlebar:
:param grab_anywhere:
:param keep_on_top:
:param location:
:return:
"""
Popup(*args, title=title, button_color=button_color, background_color=background_color, text_color=text_color,
button_type=button_type,
auto_close=auto_close, auto_close_duration=auto_close_duration, non_blocking=non_blocking, icon=icon,
line_width=line_width,
font=font, no_titlebar=no_titlebar, grab_anywhere=grab_anywhere, keep_on_top=keep_on_top, location=location)
# --------------------------- PopupNoTitlebar ---------------------------
def PopupNoTitlebar(*args, title=None, button_type=POPUP_BUTTONS_OK, button_color=None, background_color=None, text_color=None,
auto_close=False, auto_close_duration=None, non_blocking=False, icon=DEFAULT_WINDOW_ICON,
line_width=None, font=None, grab_anywhere=True, keep_on_top=False, location=(None, None)):
"""
Display a Popup without a titlebar. Enables grab anywhere so you can move it
:param args:
:param button_type:
:param button_color:
:param background_color:
:param text_color:
:param auto_close:
:param auto_close_duration:
:param non_blocking:
:param icon:
:param line_width:
:param font:
:param grab_anywhere:
:param keep_on_top:
:param location:
:return:
"""
Popup(*args, title=title, button_color=button_color, background_color=background_color, text_color=text_color,
button_type=button_type,
auto_close=auto_close, auto_close_duration=auto_close_duration, non_blocking=non_blocking, icon=icon,
line_width=line_width,
font=font, no_titlebar=True, grab_anywhere=grab_anywhere, keep_on_top=keep_on_top, location=location)
PopupNoFrame = PopupNoTitlebar
PopupNoBorder = PopupNoTitlebar
PopupAnnoying = PopupNoTitlebar
# --------------------------- PopupAutoClose ---------------------------
def PopupAutoClose(*args, title=None, button_type=POPUP_BUTTONS_OK, button_color=None, background_color=None, text_color=None,
auto_close=True, auto_close_duration=None, non_blocking=False, icon=DEFAULT_WINDOW_ICON,
line_width=None, font=None, no_titlebar=False, grab_anywhere=False, keep_on_top=False,
location=(None, None)):
"""
Popup that closes itself after some time period
:param args:
:param button_type:
:param button_color:
:param background_color:
:param text_color:
:param auto_close:
:param auto_close_duration:
:param non_blocking:
:param icon:
:param line_width:
:param font:
:param no_titlebar:
:param grab_anywhere:
:param keep_on_top:
:param location:
:return:
"""
Popup(*args, title=title, button_color=button_color, background_color=background_color, text_color=text_color,
button_type=button_type,
auto_close=auto_close, auto_close_duration=auto_close_duration, non_blocking=non_blocking, icon=icon,
line_width=line_width,
font=font, no_titlebar=no_titlebar, grab_anywhere=grab_anywhere, keep_on_top=keep_on_top, location=location)
PopupTimed = PopupAutoClose
# --------------------------- PopupError ---------------------------
def PopupError(*args, title=None, button_color=(None, None), background_color=None, text_color=None, auto_close=False,
auto_close_duration=None, non_blocking=False, icon=DEFAULT_WINDOW_ICON, line_width=None, font=None,
no_titlebar=False, grab_anywhere=False, keep_on_top=False, location=(None, None)):
"""
Popup with colored button and 'Error' as button text
:param args:
:param button_color:
:param background_color:
:param text_color:
:param auto_close:
:param auto_close_duration:
:param non_blocking:
:param icon:
:param line_width:
:param font:
:param no_titlebar:
:param grab_anywhere:
:param keep_on_top:
:param location:
:return:
"""
tbutton_color = DEFAULT_ERROR_BUTTON_COLOR if button_color == (None, None) else button_color
Popup(*args, title=title, button_type=POPUP_BUTTONS_ERROR, background_color=background_color, text_color=text_color,
non_blocking=non_blocking, icon=icon, line_width=line_width, button_color=tbutton_color, auto_close=auto_close,
auto_close_duration=auto_close_duration, font=font, no_titlebar=no_titlebar, grab_anywhere=grab_anywhere,
keep_on_top=keep_on_top, location=location)
# --------------------------- PopupCancel ---------------------------
def PopupCancel(*args,title=None, button_color=None, background_color=None, text_color=None, auto_close=False,
auto_close_duration=None, non_blocking=False, icon=DEFAULT_WINDOW_ICON, line_width=None, font=None,
no_titlebar=False, grab_anywhere=False, keep_on_top=False, location=(None, None)):
"""
Display Popup with "cancelled" button text
:param args:
:param button_color:
:param background_color:
:param text_color:
:param auto_close:
:param auto_close_duration:
:param non_blocking:
:param icon:
:param line_width:
:param font:
:param no_titlebar:
:param grab_anywhere:
:param keep_on_top:
:param location:
:return:
"""
Popup(*args, title=title, button_type=POPUP_BUTTONS_CANCELLED, background_color=background_color, text_color=text_color,
non_blocking=non_blocking, icon=icon, line_width=line_width, button_color=button_color, auto_close=auto_close,
auto_close_duration=auto_close_duration, font=font, no_titlebar=no_titlebar, grab_anywhere=grab_anywhere,
keep_on_top=keep_on_top, location=location)
# --------------------------- PopupOK ---------------------------
def PopupOK(*args, title=None, button_color=None, background_color=None, text_color=None, auto_close=False,
auto_close_duration=None, non_blocking=False, icon=DEFAULT_WINDOW_ICON, line_width=None, font=None,
no_titlebar=False, grab_anywhere=False, keep_on_top=False, location=(None, None)):
"""
Display Popup with OK button only
:param args:
:param button_color:
:param background_color:
:param text_color:
:param auto_close:
:param auto_close_duration:
:param non_blocking:
:param icon:
:param line_width:
:param font:
:param no_titlebar:
:param grab_anywhere:
:param keep_on_top:
:param location:
:return:
"""
Popup(*args, title=title, button_type=POPUP_BUTTONS_OK, background_color=background_color, text_color=text_color,
non_blocking=non_blocking, icon=icon, line_width=line_width, button_color=button_color, auto_close=auto_close,
auto_close_duration=auto_close_duration, font=font, no_titlebar=no_titlebar, grab_anywhere=grab_anywhere,
keep_on_top=keep_on_top, location=location)
# --------------------------- PopupOKCancel ---------------------------
def PopupOKCancel(*args, title=None, button_color=None, background_color=None, text_color=None, auto_close=False,
auto_close_duration=None, non_blocking=False, icon=DEFAULT_WINDOW_ICON, line_width=None, font=None,
no_titlebar=False, grab_anywhere=False, keep_on_top=False, location=(None, None)):
"""
Display popup with OK and Cancel buttons
:param args:
:param button_color:
:param background_color:
:param text_color:
:param auto_close:
:param auto_close_duration:
:param non_blocking:
:param icon:
:param line_width:
:param font:
:param no_titlebar:
:param grab_anywhere:
:param keep_on_top:
:param location:
:return: OK, Cancel or None
"""
return Popup(*args, title=title, button_type=POPUP_BUTTONS_OK_CANCEL, background_color=background_color, text_color=text_color,
non_blocking=non_blocking, icon=icon, line_width=line_width, button_color=button_color,
auto_close=auto_close, auto_close_duration=auto_close_duration, font=font, no_titlebar=no_titlebar,
grab_anywhere=grab_anywhere, keep_on_top=keep_on_top, location=location)
# --------------------------- PopupYesNo ---------------------------
def PopupYesNo(*args, title=None, button_color=None, background_color=None, text_color=None, auto_close=False,
auto_close_duration=None, non_blocking=False, icon=DEFAULT_WINDOW_ICON, line_width=None, font=None,
no_titlebar=False, grab_anywhere=False, keep_on_top=False, location=(None, None)):
"""
Display Popup with Yes and No buttons
:param args:
:param button_color:
:param background_color:
:param text_color:
:param auto_close:
:param auto_close_duration:
:param non_blocking:
:param icon:
:param line_width:
:param font:
:param no_titlebar:
:param grab_anywhere:
:param keep_on_top:
:param location:
:return: Yes, No or None
"""
return Popup(*args, title=title, button_type=POPUP_BUTTONS_YES_NO, background_color=background_color, text_color=text_color,
non_blocking=non_blocking, icon=icon, line_width=line_width, button_color=button_color,
auto_close=auto_close, auto_close_duration=auto_close_duration, font=font, no_titlebar=no_titlebar,
grab_anywhere=grab_anywhere, keep_on_top=keep_on_top, location=location)
##############################################################################
# The PopupGet_____ functions - Will return user input #
##############################################################################
# --------------------------- PopupGetFolder ---------------------------
def PopupGetFolder(message, title=None, default_path='', no_window=False, size=(None, None), button_color=None,
background_color=None, text_color=None, icon=DEFAULT_WINDOW_ICON, font=None, no_titlebar=False,
grab_anywhere=False, keep_on_top=False, location=(None, None), initial_folder=None):
"""
Display popup with text entry field and browse button. Browse for folder
:param message:
:param default_path:
:param no_window:
:param size:
:param button_color:
:param background_color:
:param text_color:
:param icon:
:param font:
:param no_titlebar:
:param grab_anywhere:
:param keep_on_top:
:param location:
:return: Contents of text field. None if closed using X or cancelled
"""
# global _my_windows
if no_window:
# if _my_windows.NumOpenWindows:
if Window.NumOpenWindows:
root = tk.Toplevel()
else:
root = tk.Tk()
try:
root.attributes('-alpha', 0) # hide window while building it. makes for smoother 'paint'
except:
pass
folder_name = tk.filedialog.askdirectory() # show the 'get folder' dialog box
root.destroy()
return folder_name
layout = [[Text(message, auto_size_text=True, text_color=text_color, background_color=background_color)],
[InputText(default_text=default_path, size=size), FolderBrowse(initial_folder=initial_folder)],
[CloseButton('Ok', size=(5, 1), bind_return_key=True), CloseButton('Cancel', size=(5, 1))]]
window = Window(title=title, icon=icon, auto_size_text=True, button_color=button_color,
background_color=background_color,
font=font, no_titlebar=no_titlebar, grab_anywhere=grab_anywhere, keep_on_top=keep_on_top,
location=location)
(button, input_values) = window.Layout(layout).Read()
if button != 'Ok':
return None
else:
path = input_values[0]
return path
# --------------------------- PopupGetFile ---------------------------
def PopupGetFile(message, title=None, default_path='', default_extension='', save_as=False, file_types=(("ALL Files", "*.*"),),
no_window=False, size=(None, None), button_color=None, background_color=None, text_color=None,
icon=DEFAULT_WINDOW_ICON, font=None, no_titlebar=False, grab_anywhere=False, keep_on_top=False,
location=(None, None), initial_folder=None):
"""
Display popup with text entry field and browse button. Browse for file
:param message:
:param default_path:
:param default_extension:
:param save_as:
:param file_types:
:param no_window:
:param size:
:param button_color:
:param background_color:
:param text_color:
:param icon:
:param font:
:param no_titlebar:
:param grab_anywhere:
:param keep_on_top:
:param location:
:return: string representing the path chosen, None if cancelled or window closed with X
"""
# global _my_windows
if no_window:
# if _my_windows.NumOpenWindows:
if Window.NumOpenWindows:
root = tk.Toplevel()
else:
root = tk.Tk()
try:
root.attributes('-alpha', 0) # hide window while building it. makes for smoother 'paint'
except:
pass
if save_as:
filename = tk.filedialog.asksaveasfilename(filetypes=file_types,
defaultextension=default_extension) # show the 'get file' dialog box
else:
filename = tk.filedialog.askopenfilename(filetypes=file_types,
defaultextension=default_extension) # show the 'get file' dialog box
root.destroy()
return filename
browse_button = SaveAs(file_types=file_types, initial_folder=initial_folder) if save_as else FileBrowse(file_types=file_types, initial_folder=initial_folder)
layout = [[Text(message, auto_size_text=True, text_color=text_color, background_color=background_color)],
[InputText(default_text=default_path, size=size), browse_button],
[CloseButton('Ok', size=(6, 1), bind_return_key=True), CloseButton('Cancel', size=(6, 1))]]
window = Window(title=title, icon=icon, auto_size_text=True, button_color=button_color, font=font,
background_color=background_color,
no_titlebar=no_titlebar, grab_anywhere=grab_anywhere, keep_on_top=keep_on_top, location=location)
(button, input_values) = window.Layout(layout).Read()
if button != 'Ok':
return None
else:
path = input_values[0]
return path
# --------------------------- PopupGetText ---------------------------
def PopupGetText(message, title=None, default_text='', password_char='', size=(None, None), button_color=None,
background_color=None, text_color=None, icon=DEFAULT_WINDOW_ICON, font=None, no_titlebar=False,
grab_anywhere=False, keep_on_top=False, location=(None, None)):
"""
Display Popup with text entry field
:param message:
:param default_text:
:param password_char:
:param size:
:param button_color:
:param background_color:
:param text_color:
:param icon:
:param font:
:param no_titlebar:
:param grab_anywhere:
:param keep_on_top:
:param location:
:return: Text entered or None if window was closed
"""
layout = [[Text(message, auto_size_text=True, text_color=text_color, background_color=background_color, font=font)],
[InputText(default_text=default_text, size=size, password_char=password_char)],
[CloseButton('Ok', size=(5, 1), bind_return_key=True), CloseButton('Cancel', size=(5, 1))]]
window = Window(title=title, icon=icon, auto_size_text=True, button_color=button_color, no_titlebar=no_titlebar,
background_color=background_color, grab_anywhere=grab_anywhere, keep_on_top=keep_on_top,
location=location)
(button, input_values) = window.Layout(layout).Read()
if button != 'Ok':
return None
else:
return input_values[0]
# --------------------------- PopupAnimated ---------------------------
def PopupAnimated(image_source, message=None, background_color=None, text_color=None, font=None, no_titlebar=True, grab_anywhere=True, keep_on_top=True, location=(None, None), alpha_channel=.8, time_between_frames=0):
if image_source is None:
for image in Window.animated_popup_dict:
window = Window.animated_popup_dict[image]
window.Close()
Window.animated_popup_dict = {}
return
if image_source not in Window.animated_popup_dict:
layout = [[Image(data=image_source, background_color=background_color, key='_IMAGE_',)],]
if message:
layout.append([Text(message, background_color=background_color, text_color=text_color, font=font)])
window = Window('Animated GIF', no_titlebar=no_titlebar, grab_anywhere=grab_anywhere, keep_on_top=keep_on_top,
background_color=background_color, location=location, alpha_channel=alpha_channel, element_padding=(0,0), margins=(0,0)).Layout(layout).Finalize()
Window.animated_popup_dict[image_source] = window
else:
window = Window.animated_popup_dict[image_source]
window.Element('_IMAGE_').UpdateAnimation(image_source, time_between_frames=time_between_frames)
window.Refresh() # call refresh instead of Read to save significant CPU time
def main():
from random import randint
ChangeLookAndFeel('GreenTan')
# ------ Menu Definition ------ #
menu_def = [['&File', ['!&Open', '&Save::savekey', '---', '&Properties', 'E&xit']],
['!&Edit', ['!&Paste', ['Special', 'Normal', ], 'Undo'], ],
['&Toolbar', ['Command &1', 'Command &2', 'Command &3', 'Command &4']],
['&Help', '&About...'], ]
treedata = TreeData()
treedata.Insert("", '_A_', 'Tree Item 1', [1, 2, 3], )
treedata.Insert("", '_B_', 'B', [4, 5, 6], )
treedata.Insert("_A_", '_A1_', 'Sub Item 1', ['can', 'be', 'anything'], )
treedata.Insert("", '_C_', 'C', [], )
treedata.Insert("_C_", '_C1_', 'C1', ['or'], )
treedata.Insert("_A_", '_A2_', 'Sub Item 2', [None, None])
treedata.Insert("_A1_", '_A3_', 'A30', ['getting deep'])
treedata.Insert("_C_", '_C2_', 'C2', ['nothing', 'at', 'all'])
for i in range(100):
treedata.Insert('_C_', i, i, [])
frame1 = [
[Input('Input Text', size=(25, 1)), ],
[Multiline(size=(30, 5), default_text='Multiline Input')],
]
frame2 = [
[Listbox(['Listbox 1', 'Listbox 2', 'Listbox 3'], size=(20, 5))],
[Combo(['Combo item 1', ], size=(20, 3), text_color='red', background_color='red')],
[Spin([1, 2, 3], size=(4, 3))],
]
frame3 = [
[Checkbox('Checkbox1', True), Checkbox('Checkbox1')],
[Radio('Radio Button1', 1), Radio('Radio Button2', 1, default=True)],
[T('', size=(1, 4))],
]
frame4 = [
[Slider(range=(0, 100), orientation='v', size=(7, 15), default_value=40),
Slider(range=(0, 100), orientation='h', size=(11, 15), default_value=40), ],
]
matrix = [[str(x * y) for x in range(4)] for y in range(8)]
frame5 = [
[Table(values=matrix, headings=matrix[0],
auto_size_columns=False, display_row_numbers=True, change_submits=False, justification='right',
num_rows=10, alternating_row_color='lightblue', key='_table_', text_color='black',
col_widths=[5, 5, 5, 5], size=(400, 200)), T(' '),
Tree(data=treedata, headings=['col1', 'col2', 'col3'], change_submits=True, auto_size_columns=True,
num_rows=10, col0_width=10, key='_TREE_', show_expanded=True, )],
]
graph_elem = Graph((800, 150), (0, 0), (800, 300), key='+GRAPH+')
frame6 = [
[graph_elem],
]
tab1 = Tab('Graph Number 1', frame6)
tab2 = Tab('Graph Number 2', [[]])
layout1 = [
[Menu(menu_def)],
[Text('You are running the PySimpleGUI.py file itself', font='ANY 15')],
[Text('You should be importing it rather than running it', font='ANY 15')],
[Frame('Input Text Group', frame1, title_color='red'),
Image(data=DEFAULT_BASE64_LOADING_GIF, key='_IMAGE_')],
[Frame('Multiple Choice Group', frame2, title_color='green'),
Frame('Binary Choice Group', frame3, title_color='purple'),
Frame('Variable Choice Group', frame4, title_color='blue')],
[Frame('Structured Data Group', frame5, title_color='red'), ],
# [Frame('Graphing Group', frame6)],
[TabGroup([[tab1, tab2]])],
[ProgressBar(max_value=800, size=(60, 25), key='+PROGRESS+'), Button('Button'), Button('Exit')],
]
layout=[[Column(layout1)]]
window = Window('Window Title',
font=('Helvetica', 13),
right_click_menu=['&Right', ['Right', '!&Click', '&Menu', 'E&xit', 'Properties']],
).Layout(layout).Finalize()
graph_elem.DrawCircle((200, 200), 50, 'blue')
i = 0
while True: # Event Loop
# TimerStart()
event, values = window.Read(timeout=0)
if event != TIMEOUT_KEY:
print(event, values)
if event is None or event == 'Exit':
break
if i < 800:
graph_elem.DrawLine((i, 0), (i, randint(0, 300)), width=1, color='#{:06x}'.format(randint(0, 0xffffff)))
else:
graph_elem.Move(-1, 0)
graph_elem.DrawLine((i, 0), (i, randint(0, 300)), width=1, color='#{:06x}'.format(randint(0, 0xffffff)))
window.FindElement('+PROGRESS+').UpdateBar(i % 800)
window.Element('_IMAGE_').UpdateAnimation(DEFAULT_BASE64_LOADING_GIF, time_between_frames=50)
i += 1
# TimerStop()
window.Close()
# layout = [[Text('You are running the PySimpleGUI.py file itself')],
# [Text('You should be importing it rather than running it', size=(50, 2))],
# [Text('Here is your sample input window....')],
# [Text('Source Folder', size=(15, 1), justification='right'), InputText('Source', focus=True),
# FolderBrowse(tooltip='Browse for a folder')],
# [Text('Destination Folder', size=(15, 1), justification='right'), InputText('Dest'), FolderBrowse()],
# [Ok(bind_return_key=True), Cancel()]]
#
# window = Window('Demo window..').Layout(layout)
# event, values = window.Read()
# window.Close()
if __name__ == '__main__':
main()
exit(69) | ADTthious | /ADTthious-0.5.tar.gz/ADTthious-0.5/PySimpleGUI.py | PySimpleGUI.py |
__all__ = [
"public_attrs_fromdict",
"public_attrs",
"to_iterable",
"Fonct",
"CLASS",
"attrs",
"valattrs",
"OBJOF",
]
import inspect, enum, warnings
from collections.abc import Iterable
def public_attrs_fromdict(dic):
"""
Return all public names of *dic*.
Public names do not begin with '_', are not function
and are not *property*!
"""
return [attr for attr in dic \
if not attr.startswith('_') \
and not inspect.isroutine(dic[attr]) \
and not isinstance(dic[attr], property)]
def getattrsfromdict(dic):
warnings.warn(
"getattrsfromdict is deprecated, use public_attrs_fromdict(dict) instead.",
DeprecationWarning,
stacklevel=4,
)
return public_attrs_fromdict(dic)
def public_attrs(obj, follow_mro=True):
"""
Return names of public attributes of *obj* throught class hierarchy and
in respect of declaration order. If obj is a class, *names* are class attributes.
"""
if obj in (object, type): return []
obj_attrs = public_attrs_fromdict(obj.__dict__)
class_attrs = []
cls = obj if isinstance(obj, type) else type(obj)
if follow_mro:
try:
class_attrs += public_attrs(cls.mro()[1], follow_mro)
except TypeError: # If we want mro of class of class!
pass
class_attrs += public_attrs_fromdict(cls.__dict__)
i = 0
for a in class_attrs:
if a in obj_attrs:
i += 1
continue
obj_attrs.insert(i, a)
i += 1
return obj_attrs
def getattrs(obj, follow_mro=True):
warnings.warn(
"getattrs is deprecated, use public_attrs(...) instead.",
DeprecationWarning,
stacklevel=4,
)
return public_attrs(obj, follow_mro)
def to_iterable(obj):
"""Return obj as an imutable iterable if necessary, except for str.
If obj is already an iterable, return obj unchanged.
"""
if not isinstance(obj, Iterable) \
or isinstance(obj, (str, bytes)) \
or isinstance(obj, enum.EnumMeta):
return (obj,)
return obj
# see https://www.peterbe.com/plog/fastest-way-to-uniquify-a-list-in-python-3.6
# and collections.Counter doc
# and essentially a pipe package in https://github.com/JulienPalard/Pipe
# You can read for more general purpose:
# * www.dabeaz.com/generators/Generators.pdf
# * http://www.dabeaz.com/tutorials.html in generators
from pipe import *
class Fonct(Pipe):
"""
Same as Pipe except you can use object that is not a iterable
at first arg. ie, if x is an instance:
x | valattrs | CLASS return all types (classes) of attribute values of x.
this is the same as (x,) | valattrs | CLASS, but more shorter!
"""
def __ror__(self, other):
return self.function(to_iterable(other))
def __call__(self, *args, **kwargs):
return Fonct(lambda x: self.function(x, *args, **kwargs))
@Fonct
def CLASS(objects):
"""Return generator on types (or classes) of objects"""
return (type(o) for o in objects)
@Fonct
def attrs(objects, follow_mro=True):
"""Return generator on all public attribute names of objects.
By default, follow_mro is true to retreive all attributes throught
classes herarchy (mro).
"""
for obj in objects:
for att in public_attrs(obj, follow_mro):
yield att
@Fonct
def valattrs(objects, attrnames=[], follow_mro=True):
"""Return generator on all public attribute values of objects.
By default, follow_mro is true to retreive all attributes throught
classes herarchy (mro).
"""
if len(attrnames) != 0:
for obj in objects:
for att in public_attrs(obj, follow_mro):
if att not in attrnames: continue
yield getattr(obj,att)
else:
for obj in objects:
for att in public_attrs(obj, follow_mro):
yield getattr(obj,att)
@Fonct
def OBJOF(objects, *classes):
"""Return generator to filter objects that are instances of classes."""
return (obj for obj in objects if isinstance(obj, classes)) | ADTthious | /ADTthious-0.5.tar.gz/ADTthious-0.5/fonctors.py | fonctors.py |
ADT
- Parfois les contrôles de type de base sont trop spécifiques. Ex : TypeError: '2021-03-24 05:03:30' for '<Att(type=<class 'ADT.basictypes.datetime'>, default=None, mandatory=<class 'ADT.hbds.Att.required'>)>named begin'. Should be '<class 'ADT.basictypes.datetime'>' instead of '<class 'datetime.datetime'>'
# Versions
* 0.4:
* ré-écriture des *foncteurs* avec le module *pipe*
* parsing des *date, time et datetime* avec le module *dateutils* dans *basictypes*
* 0.3:
* ajout des couleurs, prise en compte de certains formats de chaine de caractères pour les datetime et date,
* correction d'un bug sur les foncteurs *psc et nsc* si null.
* Ajout d'une gestion de cache à l'essai dans *util*
* début d'un dev pour la génération d'IHM avec pySimpleGUI :)
* 0.2: archivage et partage sur pip
* 0.1: début. Non archivé | ADTthious | /ADTthious-0.5.tar.gz/ADTthious-0.5/README.md | README.md |
import pathlib
from ADT import basictypes, fonctors, hbds, units
import PySimpleGUI as sg
from ADT import images
CALENDAR_ICON = pathlib.Path(__file__, '../calendar.png')
def boolWidget(valtype, val, key, disabled=False, size=(None,None)):
if val is None: val = False
return [
sg.Check('', default=val, key=key,
change_submits=True, disabled=disabled),
]
def red_greenButtons(valtype, val, key, disabled=False, size=(None,None)):
if val is None:
img = images.mac_gray
else:
img = images.mac_green if val else images.mac_red
b = sg.Button('', image_data=img, key=key, #change_submits=True,
button_color=(sg.DEFAULT_BACKGROUND_COLOR, sg.COLOR_SYSTEM_DEFAULT),
border_width=0, disabled=disabled, target=key
)
return [b]
def intWidget(valtype, val, key, disabled=False, size=(None,None)):
if val is None: val = ''
return [
sg.In(val, key=key, change_submits=True, do_not_clear=True,
size=(20,1), disabled=disabled),
]
def floatWidget(valtype, val, key, disabled=False, size=(None,None)):
if val is None: val = ''
return [
sg.In(val, key=key, change_submits=True, do_not_clear=True,
size=(20,1), disabled=disabled),
]
def strWidget(valtype, val, key, disabled=False, size=(None,None)):
if val is None: val = ''
return [
sg.In(val, key=key, change_submits=True, do_not_clear=True,
size=(20,1), disabled=disabled),
]
def EnumWidget(valtype, val, key, disabled=False, size=(None,None)):
V = [e.name for e in valtype] + ['None']
# ajoute 2 à la longueur car si non la flêche de la combo cache la fin du text
S = (max([len(v) for v in V])+2, sg.DEFAULT_ELEMENT_SIZE[1])
return [
sg.Combo(values=V, size=S,
default_value=val.name if val else 'None',
key=key, change_submits=True, disabled=disabled),
]
def dateWidget(valtype, val, key, disabled=False, size=(None,None)):
if val is None: val = ''
return [
sg.In(val, size=(20,1), key=key, change_submits=True, do_not_clear=True,
disabled=disabled),
sg.CalendarButton("", target=key,
default_date_m_d_y=(val.month, val.day, val.year),
image_filename=CALENDAR_ICON,
image_size=(25, 25),
image_subsample=1,
border_width=0),
]
def timeWidget(valtype, val, key, disabled=False, size=(None,None)):
if val is None: val = ''
return [
sg.In(val, size=(20,1), key=key, change_submits=True, do_not_clear=True,
disabled=disabled),
]
def datetimeWidget(valtype, val, key, disabled=False, size=(None,None)):
if val is None: val = ''
return [
sg.In(val, size=(20,1), key=key, change_submits=True, do_not_clear=True,
disabled=disabled),
sg.CalendarButton("", target=key,
default_date_m_d_y=(val.month, val.day, val.year),
image_filename=CALENDAR_ICON,
image_size=(30, 30),
image_subsample=1,
border_width=0),
]
def ColorWidget(valtype, val, key, disabled=False, size=(None,None)):
if val is None: val = ''
return [
sg.In(val, size=(8,1), key=key, change_submits=True, do_not_clear=True,
disabled=disabled),
sg.ColorChooserButton('' if val else '?', key='__'+key, size=(2,1),
target=key, button_color=(val,val) if val else (None,None)),
]
def PathWidget(valtype, val, key, disabled=False, size=(None,None)):
if val is None: val = basictypes.Path('.')
if val.is_dir():
return [
sg.In(val, key=key, do_not_clear=True, change_submits=True,
disabled=disabled),
sg.FolderBrowse(target=key, initial_folder=val, disabled=disabled)
]
else:
return [
sg.In(val, key=key, do_not_clear=True, change_submits=True,
disabled=disabled),
sg.FileBrowse(target=key, initial_folder=val, disabled=disabled)
]
type_to_widget = {
bool: boolWidget, #red_greenButtons,
int: intWidget,
float: floatWidget,
str: strWidget,
basictypes.Enum: EnumWidget,
basictypes.date: dateWidget,
basictypes.time: timeWidget,
basictypes.datetime: datetimeWidget,
basictypes.Color: ColorWidget,
basictypes.Path: PathWidget,
}
def basicWidget(valtype, val, key, disabled=False, size=(None,None)):
if valtype:
widget = None
for t in valtype.__mro__:
wtype = type_to_widget.get(t, None)
if wtype:
widget = wtype(valtype, val, key, disabled=disabled, size=size)
if widget:
return widget
return [sg.T("Unknown widget for %s" % valtype)]
def make_keys(obj, attr):
idobj = id(obj)
attr_key = "%s.%s" %(idobj, attr)
attrlabel_key = "_%s.%s" %(idobj, attr)
return attrlabel_key, attr_key
def id_attr_from_keys(key):
ID, attr = key.split('.')
return int(ID), attr
def is_hbds(obj):
return isinstance(type(obj), hbds.Class)
def is_ComposedAtt(obj, attr):
typeattr = getattr(type(obj), attr)
return type(typeattr).__name__.find('ComposedAtt_') != -1
def AttrElements(obj, attr, attrname_size=(None,None), attrinput_size=(None,None),
layout_type='align-left', disabled=False):
layout = []
val = getattr(obj, attr)
nkey, key = make_keys(obj, attr)
unit_widget = None
if is_hbds(obj):
if is_ComposedAtt(obj, attr):
W = AttrsElements(val, None, attrname_size, attrinput_size,
layout_type, disabled)
layout.append(sg.Frame(attr, W))
return layout
typeattr = getattr(type(obj), attr)
valtype = typeattr.type
if getattr(type(obj), attr).unit:
## V = [v.symbol for v in list(type(typeattr.unit).__members__.values())]
## print(V)
## S = (max([len(v) for v in V]), sg.DEFAULT_ELEMENT_SIZE[1])
## # bug dans PySimpleGUI ligne 5097: feild non unique!
## unit_widget = sg.Combo(values=V, size=S,
## default_value=typeattr.unit.name,
## key="u_"+key, change_submits=True)
# Ou juste le symbol
unit_widget = sg.T(typeattr.unit.symbol, tooltip=typeattr.unit.name)
else: # No hbds.Class
valtype = type(val)
layout = basicWidget(valtype, val, key, disabled=disabled)
err_button = sg.Button("?", visible=False, key="?"+nkey)
if layout_type == 'align-left':
label = sg.T(attr, size=attrname_size, key=nkey, pad=(0,0),
auto_size_text=False, justification='left')
layout = [label] + layout + [err_button]
elif layout_type == 'align-center-left':
label = sg.T(attr, size=attrname_size, key=nkey, pad=(0,0),
auto_size_text=False, justification='right')
layout = [label] + layout + [err_button]
elif layout_type == 'align-right':
label = sg.T(attr, size=attrname_size, key=nkey, pad=(0,0),
auto_size_text=False, justification='right')
layout = layout + [label, err_button]
elif layout_type == 'align-center-right':
label = sg.T(attr, size=attrname_size, key=nkey, pad=(0,0),
auto_size_text=False, justification='left')
layout = layout + [label, err_button]
else:
msg = "layout_type param must be in (align-left, "
msg += "align-right, align-center-left, align-center-right). "
msg += "Is '%s'." % layout_type
raise ValueError(msg)
if unit_widget:
layout.append(unit_widget)
return layout
def AttrsElements(obj, attrs=None, attrname_size=(None,None),
attrinput_size=(None,None), layout_type='align-left', disabled=False):
if attrs is None:
attrs = [a for a in fonctors.getattrs(obj)]
attrname_size = (
max([len(a) for a in attrs]),
sg.DEFAULT_ELEMENT_SIZE[1]
)
layout = []
for attr in attrs:
W = AttrElements(obj, attr, attrname_size, attrinput_size, layout_type, disabled)
layout.append(W)
return layout
def convert_enum(pytype, val):
if basictypes.Enum not in pytype.__mro__: return val
if val == 'None':
return None
return getattr(pytype, val, val)
class ADTWindow(sg.Window):
def __init__(self, *args, **kargs):
super().__init__(*args, **kargs)
self.objects = {}
self.errors = {}
def Layout(self, objects, layout):
self.objects.update(dict([(id(o), o) for o in objects]))
return super().Layout(layout).Finalize()
def Read(self, timeout=None, timeout_key=sg.TIMEOUT_KEY):
event, values = super().Read(timeout, timeout_key)
if event is None: return event, values
if event[0:2] == "?_":
sg.PopupError(self.errors[event[2:]])
return event, values
try:
i, attr = id_attr_from_keys(event)
except ValueError:
return event, values
try:
obj = self.objects[i]
except KeyError:
return event, values
try:
newval = values[event]
except KeyError: # if widget is not input widget as defined by PySimpleGui
return event, values
if newval == '': newval = None
# try to validate new value
try:
if is_hbds(obj):
pytype = getattr(type(obj), attr).type
newval = convert_enum(pytype, newval)
newval = getattr(type(obj), attr)._validate(newval)
else:
pytype = type(getattr(obj, attr))
newval = convert_enum(pytype, newval)
newval = pytype(newval)
except (TypeError, ValueError) as e:
self.find_element('_'+event).Update(text_color='red')
self.find_element('?_'+event).Update(visible=True)
#self.find_element(event).Update(getattr(obj, attr))
self.errors[event] = str(e)
return event, values
# update helper basetype button
if isinstance(newval, basictypes.Color):
self.find_element('__'+event).Update(text='', button_color=(None,newval))
# reset label and help if no errors
self.find_element('_'+event).Update(text_color=sg.DEFAULT_TEXT_COLOR)
self.find_element('?_'+event).Update(visible=False)
if event in self.errors:
del self.errors[event]
return event, values
def show_py_object():
class X: pass
Genre = basictypes.Enum('Genre', "Homme Femme XXY YYX XYX")
x = X()
x.nom = "xx"
x.age = 12
x.taille = 1.8
x.marie = True
x.date_de_naissance = basictypes.date("19/08/1963")
x.heure_de_naissance = basictypes.time(10)
x.genre = Genre.Homme
x.X = []
x.now = basictypes.datetime.now()
window = ADTWindow('py object', resizable=True).Layout( (x,), AttrsElements(x))
while True:
event, values = window.Read()
if event is None: return
print(event, values)
def show_hbds_object():
Blindage = basictypes.Enum('Blindage', "dur mou")
class Equipement(metaclass=hbds.Class):
nom = str, "toto"
blindage = Blindage
volume = float, units.CubicMeter.cubic_meter
masse = float, units.Kilogram.tonne
filtration_d_air = bool
dimensions = hbds.ComposedAtt(
longueur = (float, units.Meter.metre),
largeur = (float, units.Meter.metre),
)
pente = hbds.ComposedAtt(
pente_max = float, # degré
ralentissement = float, # pourcent
)
color = basictypes.Color
e1 = Equipement(nom="1")
e2 = Equipement(nom="2", blindage=Blindage.dur)
W = AttrsElements(e1, layout_type='align-center-left')
W1 = AttrsElements(e2, ["nom", "blindage", "volume", "masse", "filtration_d_air"] )
W2 = AttrsElements(e2, ["dimensions", "pente"] )
O = (e1, e2, e1.dimensions, e1.pente, e2.dimensions, e2.pente)
window = ADTWindow('ADT: Equipement').Layout( O,
[[sg.Column(W), sg.VSep(), sg.Column(W1), sg.VSep(), sg.Column(W2)]])
while True:
event, values = window.Read()
## print(event, values)
if event is None: return
def test_size():
ST = (15,1)
SI = (10,1)
window = sg.Window('Test').Layout([
[sg.T('A', size=ST), sg.In(size=SI)],
[sg.T('A'*4, size=ST), sg.In(size=SI)],
[sg.T('w'*15, size=ST), sg.In(size=SI)],
])
while True:
event, values = window.Read()
if event is None: return
def main():
import random
# PB avec COLOR_SYSTEM_DEFAULT qui apparait trop souvent
index = random.choice(sg.ListOfLookAndFeelValues())
colors = sg.LOOK_AND_FEEL_TABLE[index]
## print(index, colors)
sg.ChangeLookAndFeel(index)
sg.DEFAULT_TEXT_COLOR = colors['TEXT']
sg.SetOptions(
font=('Times', 12),
auto_size_text=True
)
## print(sg.DEFAULT_TEXT_COLOR)
#show_py_object()
show_hbds_object()
#test_size()
if __name__ == '__main__':
main() | ADTthious | /ADTthious-0.5.tar.gz/ADTthious-0.5/sgadt.py | sgadt.py |
mac_red = b'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'
mac_green = b'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'
mac_orange = b'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'
mac_gray = b'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'
pymodule = b'iVBORw0KGgoAAAANSUhEUgAAAB0AAAAUCAYAAABxnDbHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAHYgAAB2IBOHqZ2wAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAAN3SURBVEiJrZRvaNVVGMc/z+/eO1qzhZKRigZBE9pYmg0iCpUM/2BgL9KQBFl5h1dxRURRLxq9KytwzcksV0Hv9EX4IiukYb3oRUwbc6H2IlLTTSq3G/fe3++e5zmnF/Pa3boJdv3C4XCec57zeb7PgSPMUkducLGigwBeeHFkf3ZsVU9POn9l4eEAc4j44FRf9ujsvFpatf3j26aaXInAoVP92Rcq8fTsgz5yTQRZAyCEPUDX5O8LnhZhE4AE+bxydkV2IBOlM/d4dePDB7tcddxFfi4x+VrFRDcodFSQ51pf+mieBOkGRqs3l+UO5nxGJlX0vM/I5PJdAzsBHtr5YbvPyMVUKjWRn+OO3BQ0BDkKXGlIrB94VET6rjvpHlgiQi8SviyWUs0BvgLp7cgNLg5ReAto9tAWAp/dFFQkWBD2I7IF+DoEO1PZ815agJR4hs4OPv9XFMI3QFql3ALcL4RfR/ZnxyIXjtW6+19vWi0zPZRJpZ80H96OpKrSKJzzXiyIrFraeejTEOlqApoODedU9OeArH1w18FWH6QdwvW85bmB10CeuNGbMnogd/VkX3btSH/XUHV8eF/XeUG6gfW3N1qeIOtCoPuH/s4LRP5NIB/BaQjbqvMCtCKsEWZpw3vHW6ys91lZU6Zu/K4z7sfDhzdbraJWZAcyNLIgnjt3fKxnc7k6njRG807v2zFRK28GdOO7Q33O6b2myUZ1DnMOVXfi+71bV4OEWhf8H81or6l7xGv5uJkGU8VMMdWVy3cPLrhVQLjmdH3vt/OtUFriTTtNdb45RV2yzlTvUOfYvvJyx+7HJ8vcPecnkR6tF5p+6v0TW7VU/iR4n/FqmHOYOkz12uzYsiy/DW97+G3iGLChXmik6l42dZkKYBr2zwgQ39mQNKMFsML6cP7ZhXU7NdWlVZC8mfvCzOXVHJm08frai5caKLyKlsDH4JMW4FK90LypNpk6d+CZ0XfaFpXeABrxOg2xGDSZnn0MWi7W6zQy1ZPTbbWzbYviTUAjloAVQKvG9PpPSlOn64WmvY9fMefTZu4PgrZhMVgCPh7D4hifgMZgiUOkVx4ertvpjM8hXNgxgsXt+AQsvoDFRSzJIP4xeeC7y/XCKpr592rhKlqstHQxrrCX4H6hWKzb3X9DfSmLLxxBCxNYPIlI57WWTt1K6N/5VQVqxtaQ4AAAAABJRU5ErkJggg=='
pyclass = b'iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAHYgAAB2IBOHqZ2wAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAAO8SURBVFiF7ZVvaJVVHMc/v3N33UjFNNoyyGpJfxSaV0tEFH2TYlghIyJCkxTbWkYYFIGF9EIqLUEx8yqMVCLK8EVgbxT7t6KNMgSlrJboomxKOnfvnuee3zm/XmzTzY1BdKU3+8ADz3M4h+/nd855zoERmLp2ayUbNrj+79zad+tyjfkFI435t7jhGmc07VydeyZ/cnysKuY6b05yTfn9AET3Go4D5RSouLph5rO7HjOzXQhtCEsBzGzREMnnm6+3Uml2xrmJYBe6JPnsl23PpQB1Tfk7MzAjipWyIXusbcdT7bPW7MyGrFvohElAp1ZVfnts84rCEAEzWwHgnD3+3banf+1r/vTqfqJ+uYg0mHHOIDfeqk4vXNl8X9c4nWtmh0z4XkyiOgWYHbOyX7AFZhwFajPF9BVgzxABEZtiJn5A+LBUZbt3J6XrTiCZ25xxxuCJi2PTnESZhggGe4XYOsaVjvcNmQ6cxGS7y8bWMa67E4bZA2bSDmTrmvLTRxJI0nHbwB3EmB9hAoBFmSTKXiDvzBrBtZRi1Tez1uzMGtKIcRGxfFQ5laZjVw0rAPEtIDr4KNeUX9737BnSTbgf+EuMNwTSywVk3FRDPlZxS4BmYJqr0BuQeKNzti7CfKBoTuYOK3B0e8MXOBZjnAO2grwpQgIgwlkxO9X7LhuBMSb2iRgdhrWbULSMVQu2I2N2HGGJYBvb3mn605k8GE0OO2gDfrLIlt46ruLhTYfu9RrmqPqJGvRSTELb56/Xt420HP+FQQIPbT4yT4OuV1+6Sb3WBfWo96a+VN+65cmy/v/9DFoCH8IdIWg2aMiEoARVgnqJQeddi3DoO4gWv/31pAqfzPOaVkfV8yH48+p9KaqfGYKSdT5jf6x7lEzmZ6ne9ENZBZZtaqlOteeYBl/TW7UneCVengGlZkLIIvIhvmh2evUCmbL7y3IJuJKlS0PQmv4w1SvBQRWLkZm3FLrQAmhBCIX6coUDVGjwtQMCzcXSgbtqLnaGECAG7q7p+fvFB35bhCYQEohJbVkFTPV8UE9Qz+0Tu3a8t/zEMmAyFiEmENLe4JBATCGmF8oq4E1b+6d+1ZwzXcBkor8S2B8e0l6h6A+XVeDIq4+0zH3pgxdCCIsmVGpxQLUdhPRHQs8VGewESfJ+OQUGHUTW0bCSkDT3TX1KSAqE5BLm98n0r9aXM7ifwXeBdnf27vYiaKESLfxO9C8D3dcifKjArfsOEnoa8YVWtHAWCwp2Dz09W6+VwCijjDLKKP87/wBXLynO0kO6IQAAAABJRU5ErkJggg=='
pyfunction = b'iVBORw0KGgoAAAANSUhEUgAAABsAAAAHCAYAAAD5wDa1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAHYgAAB2IBOHqZ2wAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAAGzSURBVCiRtZG/a5NxEMY/932TNCqxVBBtRdBStyJNXETs4h9QEKSCmxRfIbEODuKPpW6drVEai3R30KlLRURxUGgjlaIiRFERwRY1pBib9/0+DkmxTWaf5Y7juOfuc5YtlMRWvS4Xw8P8ByUAEO/ldB1Anl8D4ze7MqSH4yj4vHRn7F0uPzOgwB9IJ2rPq+zclop8zjfiN5ZIHDJpb/da8uGT2bN1gOz4vd0Wx8PefCYwXizcOv92q5mRcLgegBi/0v2na5dPMh+4eAq4KKcxPFfWGpn+lKJ+cPMWuIpJaaCvuiO6D4wO5UvH8NGcDAz76KVPwMiGmWvF/ZImJU06s9P/Drd2xJv1qFwM9wEvBSeaO3MDSMfOBsvFcGhd0ZkOjIKFV8Xw6EbxSDjd26z7oIV5e7uTE4utdAU02CK0B1hdmjr3BWD5dqHW+bM21ft6VlPffzYMO54rlE4Knepock4AZkit+814JpHPXZi+TOye4tS7WAwfZAt3Z0EjTqgCfN08Z3lidF3YBHBQ2DWwOaEKRkNyv4UqkqoA8nwDPgAkrX4VbEayS3J6LGviFb4m9OMvVom7Q0c4yR8AAAAASUVORK5CYII='
import base64
def strtopng(s, filename):
with open(filename, 'bw') as f:
f.write(base64.b64decode(s))
def pngtostr(filename):
with open(filename, 'br') as f:
return base64.b64encode(f.read())
if __name__ == '__main__':
## for s in ('mac_red', 'mac_green', 'mac_orange', 'mac_gray'):
## strtopng(eval(s), "%s.png" % s)
print(pngtostr('./pyfunction.png') ) | ADTthious | /ADTthious-0.5.tar.gz/ADTthious-0.5/images.py | images.py |
import collections, types
from .fonctors import *
from .units import Unit
__all__ = (
'Att',
'create_Att',
'ComposedAtt',
'Class',
'CLASS',
'ATT',
'OATT',
'raise_init',
'OBJ',
'keep_objects_relationship',
'Relation',
'create_relation',
'Link',
'PSC',
'NSC',
'INIT',
'FIN',
'OPSC',
'OPSCR',
'ONSC',
'ONSCR',
'OINIT',
'OFIN',
'Role',
)
class Att:
"""
Used to define a class attribute to provide:
* existing control
* type control
* default value
* and also mandatory information, docstring and contrainst function.
at intance level.
Att is a python descriptor, so must be use as class variable
in class definition.
TODO: revoir les contraintes pour utiliser des méthodes
"""
class required:
"""
Just to tell if Att is mandarory (or required). See Att.__init__.
"""
pass
def __init__(self, att_type=None, default=None, mandatory=False,
doc=None, constraint=None, unit=None):
self.type = att_type
self.mandatory = mandatory
self.doc = doc
self.constraint = constraint
self.name = None
self.default = self._validate(default)
if self.type is None and self.default is not None:
self.type = type(self.default)
self.unit = unit
self.classvars = {}
def __get__(self, instance, ownerclass):
if instance is None:
for c in ownerclass.__mro__:
if self.name in c.__dict__:
return c.__dict__[self.name]
if isinstance(instance, type):
try:
return self.classvars[instance]
except KeyError as e:
msg = "type '%s' use class var already define in its metaclass" \
% instance
# cf. tests.hbds.ClassOfClassTest.test_already_declare_att_in_metaclass
raise TypeError(msg)
return instance.__dict__.get(self.name, self.default)
def _validate(self, value):
if value is None:
return value
# try to catch value with type
if self.type:
if not isinstance(value, self.type):
try:
value = self.type(value)
except (ValueError, TypeError):
m = "'%s' for '%s'. Should be '%s' instead of '%s'" \
% (value, self, self.type, type(value))
raise TypeError(m)
# try to apply contraint
if self.constraint:
self.constraint(value)
return value
def __set__(self, instance, value):
value = self._validate(value)
if value is None and self.mandatory:
raise ValueError("'%s' Att is mandatory. Can't be set to None" % self.name)
if isinstance(instance, type):
self.classvars[instance] = value
else:
instance.__dict__[self.name] = value
def __set_name__(self, cls, name):
self.name = name
def __repr__(self):
s = "<Att(type=%s, default=%s, mandatory=%s)>" \
% (self.type, self.default, self.mandatory)
if self.name is None:
s = "Not named " + s
else:
s += "named %s" % self.name
return s
class ComposedAtt:
def __init__(self, **attr_defs):
name = "%s_tmp" % self.__class__.__name__
self._class = create_class(name, attr_defs)
L = [v for v in (self._class,) | ATT if v.mandatory and not v.default]
if len(L) != 0:
raise AttributeError("Impossible to use mandatory attribute without default value in ComposedAtt")
def __get__(self, instance, ownerclass):
if not instance: return self._class()
return instance.__dict__.setdefault(self._name, self._class())
def __set__(self, instance, value):
raise AttributeError("%s '%s' of %s is'nt settable" % \
(type(self).__name__, self._name, instance))
def __set_name__(self, cls, name):
self._name = name
self._class.__name__ = "%s_%s" % (self.__class__.__name__, name)
class Class(type):
# We use 'clsnamespace' for dictionary product par the interpreter to init
# a new class. In python doc, we find 'namespace'. In litterature we
# could find 'clsdict' or also 'attrs'.
@classmethod
def __prepare__(mcls, name, bases, **kwds):
# be sure namespace of a new class will keep order of declaration
return collections.OrderedDict()
def __new__(mcls, clsname, bases, clsnamespace):
# Warning: clsnamespace MUST BE modified directly
# It's impossible to use an other dict or a copy
# else __new__ doesn't run!
# all (implicit!) explanations are available in python doc metaclass
# transform python public attributes (and that not method)
# of the new class to an Att if needed
for public_att in public_attrs_fromdict(clsnamespace):
val = clsnamespace[public_att]
# to detect embeded class definitions as
# class C(metclass=Class):
# class X(metaclass=Class): et class X tout cours?
if isinstance(val, Class): continue
val = to_iterable(val)
clsnamespace[public_att] = create_Att(*val)
# if the new class is not a child of Class,
# we will make the __init__ method
parent_classes = [c for b in bases for c in b.__mro__]
if Class not in parent_classes:
# we create an ordered dictionnary of all inherited Att,
# indexed by base classes...
up_attrs_by_bases = collections.OrderedDict()
for b in bases:
if b is object: continue
up_attrs_by_bases[b] = collections.OrderedDict([ \
(a,getattr(b,a)) for a in public_attrs(b) \
if isinstance(getattr(b,a), Att)] )
# ... and an another just for new class
attrs = collections.OrderedDict([(a,clsnamespace[a]) for a in clsnamespace \
if isinstance(clsnamespace[a], Att)])
# these will be usefull for create __init__ method
code = mcls._make_init_method(up_attrs_by_bases, attrs)
# we try to add the __init__ method to new class namespace
# using 'exec' (please (re)read python doc of metaclass)
try:
# __init__ must have the form, for example:
# class Z(Y, T):
# def __init__(self, x=Y.x, y=Y.y, z=z, t=T.t):
# Y.__init__(self, x, y)
# T.__init__(self, t)
# ...
# Pb is Y and T are just accessible from scope where Z
# is defined. It can be not necessary global
# So we set local variables with all base classes
# to bind names with base classes from locals()
# I spent a lot of time to find this!
for i,b in enumerate(bases):
exec("%s = bases[i]" % b.__name__)
exec(code , locals(), clsnamespace)
except SyntaxError as e:
e.msg = make_readable_SyntaxError(code, e)
raise e
# then we make a instance __setattr__ method
# to avoid set of undeclare attribute at new class instance level
def fset(instance, att, val):
if not att.startswith('_'): # TODO: why do we need private att?
if not hasattr(type(instance), att):
m = "Class instance '%s' has no Att '%s'"
raise AttributeError(m % (instance, att))
if isinstance(instance, type):
type.__setattr__(instance, att, val)
else:
object.__setattr__(instance, att, val)
clsnamespace['__setattr__'] = fset
# and finally with create the new class
newcls = super().__new__(mcls, clsname, bases, clsnamespace)
return newcls
def __setattr__(cls, att, val):
if not att.startswith('_'):
if not hasattr(type(cls), att):
m = "Class type '%s' has no Att '%s'"
raise AttributeError(m % (cls, att))
# super doesn't run here. I don't no why
#super().__setattr__(att, val)
type.__setattr__(cls, att, val)
@classmethod
def _make_init_method(mcls, up_attrs_by_bases, attrs):
args = make_code_args(up_attrs_by_bases, attrs)
if args == "": return ""
code = """def __init__(self, %s):\n""" % args
for b in up_attrs_by_bases:
attnames = [a for a in up_attrs_by_bases[b]]
code += " %s.__init__(self, %s)\n" % (b.__name__, ', '.join(attnames))
code += make_attrs_init(attrs)
return code
def make_code_args(up_attrs_by_bases, attrs):
code_args = []
for b in up_attrs_by_bases:
for a in up_attrs_by_bases[b]:
att = up_attrs_by_bases[b][a]
code_args.append(make_code_arg(a, att, b.__name__))
for a in attrs:
code_args.append(make_code_arg(a, attrs[a]))
args = ', '.join(code_args)
return args
def make_code_arg(attname, att, basename=""):
codebase = "%s." % basename if basename != "" else ""
if att.default is not None:
code = "%s=%s%s.default" % (attname, codebase, attname)
elif att.mandatory:
code = attname
else:
code = "%s=None" % attname
return code
def make_attrs_init(attrs):
return ''.join([' self.%s = %s\n' % (a, a) for a in attrs])
def make_readable_SyntaxError(code, exception):
msg = exception.msg
msg += " line %d in dynamic created __init__\n" % exception.lineno
for n, l in enumerate(code.splitlines()):
msg += ''.join(["%2d: %s\n" % (n+1,l) ])
if n+1 == exception.lineno:
msg += "%s^\n" %(' '*(exception.offset+3)) # the 2 line number + ':'
return msg
def create_Att(*vals):
"""
Return an *Att* instance from tuple *vals*.
The tuple is interpreted as parameters of Att in any order
and it may be empty.
If tuple does'nt respect Att params, **AttributeError** is raised.
TODO: add contrainsts
"""
if len(vals) > 4:
raise TypeError("Too many args for Att (%d). Must be 4 max" % len(vals))
# because order is not important, so re-order vals
typ, default, mandatory, unit = None, None, not Att.required, None
# manque des tests car il peut y avoir 4 valeurs sans Unit par ex.
for v in vals:
if v is Att.required: mandatory = v
elif isinstance(v, Unit): unit = v
elif isinstance(v, type): typ = v
else: default = v
# vals is already a Att
if isinstance(default, (Att, ComposedAtt)):
if len(vals) != 1:
raise TypeError("Too many Att definition (%d). Use just one" % len(vals))
return default
return Att(typ, default, mandatory, unit=unit)
def create_class(name, attr_defs):
"""
Return class from *name* and *attr_defs* dictionary.
Do the same thing as instruction:
class X(metaclass=Class):
a1 = Att(int, 1)
a2 = float
with *name* = 'X' and *attr_defs* = {'a1': Att(int, 1), 'a2': Att(float)}
see Class and Att definitions.
"""
meta = {'metaclass': Class }
def update(clsdic):
for att, val in attr_defs.items():
clsdic[att] = val
return types.new_class(name, kwds=meta, exec_body=update)
from pipe import Pipe
@Pipe
def ATT(classes):
return classes | valattrs | OBJOF(Att)
@Pipe
def OATT(objects):
return (getattr(obj, a.name) for obj in objects for a in (obj,) | CLASS | ATT )
def raise_init(cls):
"""
Decorate the class *cls* to prevent instance creation. It can be use
for just create simple type that you don't want to instanciate it.
>>> @raise_init
... class Road: pass
>>> Road()
Traceback (most recent call last):
...
TypeError: Instance creation is not allowed for <class 'ADT.hbds.Road'>
"""
def init(self):
raise TypeError("Instance creation is not allowed for %s" % cls)
cls.__init__ = init
return cls
@Pipe
def OBJ(classes):
return (o for cls in classes for o in getattr(cls, '__obj__'))
def keep_objects_relationship(cls):
"""
Decorate the class *cls* to add to it a *__obj__* list to keep track
of all instances of the class.
You can use it for a class
>>> @keep_objects_relationship
... class X: pass
>>> x1 = X(); x2 = X()
>>> X.__obj__ #doctest: +ELLIPSIS
[<ADT.hbds.X object at 0x...>, <ADT.hbds.X object at 0x...>]
>>> @keep_objects_relationship
... class TerrainType(type): pass
>>> class X(metaclass=TerrainType): pass
>>> class Y(metaclass=TerrainType): pass
>>> TerrainType.__obj__
[<class 'ADT.hbds.X'>, <class 'ADT.hbds.Y'>]
Usage of *__obj__* is just for tests. It's more pretty to use fonctor OBJ
>>> L = list((TerrainType,) | OBJ) # creation order is preserved
>>> X in L and Y in L and len(L) == 2 #
True
Warning: decorator must be use only with classes
with invariant number of instances because __del__ is not implemented!
"""
if not hasattr(cls, '__obj__'):
setattr(cls, '__obj__', [])
oldinit = getattr(cls, '__init__', None)
def newinit(self, *args, **kargs):
if oldinit:
oldinit(self, *args, **kargs)
cls.__obj__.append(self)
cls.__init__ = newinit
# Attention: ne fonctionne pas!
## olddel = getattr(cls, '__del__', None)
## def newdel(self):
## if olddel:
## olddel(sel)
## cls.__obj__.remove(self)
## cls.__del__ = newdel
return cls
"""
Cardinalités des rôles des relations
L: X (n,m) -> (n,m) Y
@noreverse
pour ne pas implémenter le negative semi cocircuit
nommer la relation inverse => inverser les psc, nsp
Optimisation de l'acces
if m == 1: SC != list
Contrôles relatifs aux cardinalités
if m is not None: n <= m
if m is not None: contrôle si len(sc) == m avant création de la relation
if n != 0:
=> contraintes à la création des objets init et fin
si ni != 0 => nf == 0 et inversement
X (2, 3) (0,2) Y
X(..., y1, y2)
X(0,2) (1,3) Y
Y(..., x1)
m = 'all' => relation avec tous les Y?
"""
class SemiCocircuit:
# Attention:
# * pas d'héritage de liens
# * et confusion entre SC d'object et SC de type object
def __init__(self, name):
self.name = name
self.sc = []
self.classvars = {}
def __get__(self, obj, cls):
if obj is None:
# when uses class attribute
return self.sc
if isinstance(obj, type):
if obj not in self.classvars:
self.classvars[obj] = SemiCocircuit(self.name)
return self.classvars[obj].sc
if self.name not in obj.__dict__:
obj.__dict__[self.name] = SemiCocircuit(self.name)
return obj.__dict__[self.name].sc
def __set__(self, obj, value):
raise AttributeError(self.name + " are not settable")
class Relation(Class):
def __new__(mcls, clsname, bases, clsnamespace):
if '__cinit__' not in clsnamespace:
raise TypeError("Relation must define the '__cinit__' class")
if '__cfin__' not in clsnamespace:
raise TypeError("Relation must define the '__cfin__' class")
if '__cards__' not in clsnamespace:
# set default cardinalities
clsnamespace['__cards__'] = ((0,'m'),(0,'m'))
def cut(self):
type(self).unlink_objects(self)
clsnamespace['cut'] = cut #lambda l: mcls.unlink_objects(l)
clsobj = Class.__new__(mcls, clsname, bases, clsnamespace)
return clsobj
@classmethod
def _make_init_method(mcls, up_attrs_by_bases, attrs):
args = make_code_args(up_attrs_by_bases, attrs)
if args == "":
code = """def __init__(self, oinit, ofin):\n"""
else:
code = """def __init__(self, oinit, ofin, %s):\n""" % args
code += " type(self).link_objects(self, oinit, ofin)\n"
for b in up_attrs_by_bases:
attnames = [a for a in up_attrs_by_bases[b]]
code += " %s.__init__(self, %s)\n" % (b.__name__, ', '.join(attnames))
code += make_attrs_init(attrs)
return code
def __init__(rel, name, bases, clsnamespace):
super(Relation, rel).__init__(name, bases, clsnamespace)
rel.create_class_links()
@property
def cocircuit(clsrel):
return SemiCocircuit
def create_class_links(clsrel):
for cls in (clsrel.__cinit__, clsrel.__cfin__):
for a in ('__psc__', '__nsc__'):
if not hasattr(cls, a):
setattr(cls, a, clsrel.cocircuit(a))
clsrel.__cinit__.__psc__.append(clsrel)
clsrel.__cfin__.__nsc__.append(clsrel)
def link_objects(clsrel, objrel, oinit, ofin):
assert isinstance(objrel, clsrel)
objrel.__oinit__ = oinit
objrel.__ofin__ = ofin
objrel.__oinit__.__psc__.append(objrel)
objrel.__ofin__.__nsc__.append(objrel)
def unlink_objects(clsrel, objrel):
assert isinstance(objrel, clsrel)
objrel.__oinit__.__psc__.remove(objrel)
objrel.__ofin__.__nsc__.remove(objrel)
def create_relation(cinit, name, cfin):
meta = {'metaclass': Relation, }
def update(clsdic):
clsdic['__cinit__'] = cinit
clsdic['__cfin__'] = cfin
return types.new_class(name, kwds=meta, exec_body=update)
# Alias
Link = create_relation
@Pipe
def PSC(classes):
return (r for cls in classes for r in getattr(cls, '__psc__', () ) )
@Pipe
def NSC(classes):
return (r for cls in classes for r in getattr(cls, '__nsc__', () ) )
@Pipe
def INIT(rels):
return (r.__cinit__ for r in rels)
@Pipe
def FIN(rels):
return (r.__cfin__ for r in rels)
@Pipe
def opsc(objects, rel=None):
if rel is None: return (r for obj in objects for r in obj.__psc__)
return (r for obj in objects for r in obj.__psc__ if isinstance(r, rel))
OPSC = opsc
OPSCR = opsc
@Pipe
def onsc(objects, rel=None):
if rel is None: return (r for obj in objects for r in obj.__nsc__)
return (r for obj in objects for r in obj.__nsc__ if isinstance(r, rel))
ONSC = onsc
ONSCR = onsc
@Pipe
def OINIT(orels): return (r.__oinit__ for r in orels)
@Pipe
def OFIN(orels): return (r.__ofin__ for r in orels)
class Role:
# Role doit dériver de Att
# Faire un role qui retourne un objet et non une liste (fct de la card de R?)
# les rôles ne sont pas fournit à la complétion
def __init__(self, relname):
self.relname = relname
def __get__(self, instance, owner_cls):
rel = list(r for r in (owner_cls,) | PSC if r.__name__ == self.relname)[0]
# et si rel is None?
objs = list((instance,) | OPSCR(rel) | OFIN)
if len(objs) == 0:
return ()
else:
return objs
class Role01:
def __init__(self, relname):
self.relname = relname
def __get__(self, instance, owner_cls):
rel = list(r for r in owner_cls | PSC if r.__name__ == self.relname)[0]
objs = list((instance,) | OPSCR(rel) | OFIN)
if len(objs) == 0:
return None
return list(objs)[0] | ADTthious | /ADTthious-0.5.tar.gz/ADTthious-0.5/hbds.py | hbds.py |
import re
from enum import Enum
# TODO: remplacer datetime par un module plus cohérent!
from datetime import time, timedelta
from datetime import datetime as pydatetime
from datetime import date as pydate
from dateutil import parser
# cf. https://pypi.org/project/colour/
import colour
from pathlib import Path
__all__ = [
'Enum',
'datetime', 'date', 'time', 'timedelta',
'PosInt',
'Percent',
'MaxInclusive', 'Interval', 'MinExclusive', 'MaxExclusive', 'MinInclusive',
'positive', 'negative',
'Regex', 'SizedString',
'Color',
'Path',
]
class datetime(pydatetime):
def __new__(cls, *args, **kargs):
if isinstance(args[0], pydatetime):
return args[0]
try:
return parser.parse(*args, **kargs)
except TypeError:
return pydatetime.__new__(cls, *args, **kargs)
class date(pydate):
def __new__(cls, *args, **kargs):
d = parser.parse(*args, **kargs)
d = pydate.__new__(cls, d.year, d.month, d.day)
return d
class MaxInclusive:
def __init__(self, max_value):
self.max = max_value
def __call__(self, value):
if value > self.max:
raise ValueError("Expected <= %s, not %s" % (str(self.max), str(value)))
class MinExclusive(object):
def __init__(self, min_value):
self.min = min_value
def __call__(self, value):
if value <= self.min:
raise ValueError("Expected > %s, not %s" % (str(self.min), str(value)))
class MaxExclusive(MaxInclusive):
def __call__(self, value):
if value >= self.max:
raise ValueError("Expected < %s, not %s" % (str(self.max), str(value)))
class MinInclusive(MinExclusive):
def __call__(self, value):
if value < self.min:
raise ValueError("Expected >= %s, not %s" % (str(self.min), str(value)))
positive = MinInclusive(0)
negative = MaxInclusive(0)
class PosInt(int):
def __new__(cls, *args, **kargs):
v = int.__new__(cls, *args, **kargs)
positive(v)
return v
class SizedString(object):
def __init__(self, maxlen):
self.maxlen = maxlen
def __call__(self, value):
if len(value) > self.maxlen:
raise ValueError("Expected len = %s, not %s" % (str(self.maxlen), str(value)))
class Regex(object):
def __init__(self, pattern):
self.pattern = pattern
self.compiled_pattern = re.compile(pattern)
def __call__(self, value):
if not self.compiled_pattern.match(value):
raise ValueError("Invalid value '%s' don't match with pattern '%s'" \
% (str(value), self.pattern))
class Interval(MinInclusive, MaxInclusive):
def __init__(self, mininc, maxinc):
MinInclusive.__init__(self, mininc)
MaxInclusive.__init__(self, maxinc)
def __call__(self, value):
MinInclusive.__call__(self, value)
MaxInclusive.__call__(self, value)
class Percent(float):
def __new__(cls, *args, **kargs):
v = float.__new__(cls, *args, **kargs)
interval = Interval(0,1)
interval(v)
return v
class Color(colour.Color):
@property
def RGB(self):
h = self.hex_l
return int(h[1:3], 16), int(h[3:5], 16), int(h[5:7], 16) | ADTthious | /ADTthious-0.5.tar.gz/ADTthious-0.5/basictypes.py | basictypes.py |
from tkinter import *
from tkinter.dnd import *
class Dragged:
"""
This is a thing to be dragged and dropped.
"""
def __init__(self):
print("An instance of Dragged has been created")
def dnd_end(self,Target,Event):
#this gets called when we are dropped
print("I have been dropped; Target=%s"%Target)
class CanvasDnd(Canvas):
"""
This is a canvas to which we have added a "dnd_accept" method, so it
can act as a Target Widget for drag and drop. To prove that the Target
Object can be different from the Target Widget, CanvasDnd accepts as
argument "GiveDropTo" the object to which the dropped object is to
be given.
"""
def __init__(self, Master, GiveDropTo, **kw):
Canvas.__init__(self, Master, kw)
#Simply remember the TargetObject for later use.
self.GiveDropTo = GiveDropTo
def dnd_accept(self,Source,Event):
#Tkdnd is asking us if we want to tell it about a TargetObject.
#We do, so we pass it a reference to the TargetObject which was
#given to us when we started
print("Canvas: dnd_accept")
return self.GiveDropTo
class Receptor:
"""
This is a thing to act as a TargetObject
"""
def dnd_enter(self,Source,Event):
#This is called when the mouse pointer goes from outside the
#Target Widget to inside the Target Widget.
print("Receptor: dnd_enter")
def dnd_leave(self,Source,Event):
#This is called when the mouse pointer goes from inside the
#Target Widget to outside the Target Widget.
print("Receptor: dnd_leave")
def dnd_motion(self,Source,Event):
#This is called when the mouse pointer moves withing the TargetWidget.
print("Receptor: dnd_motion")
def dnd_commit(self,Source,Event):
#This is called if the DraggedObject is being dropped on us
print("Receptor: dnd_commit; Object received= %s"%Source)
def on_dnd_start(Event):
"""
This is invoked by InitiationObject to start the drag and drop process
"""
#Create an object to be dragged
ThingToDrag = Dragged()
#Pass the object to be dragged and the event to Tkdnd
dnd_start(ThingToDrag,Event)
Root = Tk()
Root.title("Drag-and-drop 'bare-bones' demo")
#Create an object whose job is to act as a TargetObject, that is, to
# received the dropped object.
TargetObject = Receptor()
#Create a button to act as the InitiationObject and bind it to <ButtonPress> so
# we start drag and drop when the user clicks on it.
InitiationObject = Button(Root,text='InitiationObject')
InitiationObject.pack(side=TOP)
InitiationObject.bind('<ButtonPress>',on_dnd_start)
#Create a canvas to act as the Target Widget for the drag and drop. Note that
# since we are going out of our way to have the Target Widget and the Target
# Object be different things, we pass a reference to the Target Object to
# the canvas we are creating.
TargetWidget = CanvasDnd(Root,GiveDropTo=TargetObject,relief=RAISED,bd=2)
TargetWidget.pack(expand=YES,fill=BOTH)
Root.mainloop() | ADTthious | /ADTthious-0.5.tar.gz/ADTthious-0.5/dnd_example1.py | dnd_example1.py |
import PySimpleGUI as sg
from ADT import hbds
class Thing(metaclass=hbds.Class):
name = str
i = int
j = 1.2
Contain = hbds.Link(Thing, 'Contain', Thing)
t = Thing('t', 0)
t1 = Thing('t1', 1)
t2 = Thing('t2', 2)
Contain(t, t1); Contain(t, t2)
t11 = Thing('t11', 11)
t12 = Thing('t12', 12)
Contain(t1, t11); Contain(t1, t12)
t21 = Thing('t21', 21)
t22 = Thing('t22', 22)
Contain(t2, t21); Contain(t2, t22)
class QueryTree:
def __init__(self, obj):
self.obj = obj
self.sub_queries = None
def __call__(self):
if not self.sub_queries:
self.sub_queries = [QueryTree(obj) for obj in self.obj | hbds.OPSC() | hbds.OFIN()]
return self.sub_queries
def show(self):
return [self.obj.name, [self.obj.i, self.obj.j]]
@property
def key(self):
return str(id(self))
class Tree(sg.Tree):
def __init__(self, query, **kargs):
self.queries_by_key = {query.key: query}
treedata = sg.TreeData()
treedata.Insert("", query.key, *query.show())
for q in query():
self.queries_by_key[q.key] = q
treedata.Insert(query.key, q.key, *q.show())
super().__init__(data=treedata, **kargs)
def ask(self, window, a_key):
try:
query = self.queries_by_key[a_key]
except KeyError:
return
for q in query():
for sq in q():
self.queries_by_key[sq.key] = sq
window.Element(self.Key).Insert(q.key, sq.key, *sq.show())
tree = Tree(QueryTree(t), headings=['i', 'j'],
key='_QT_',
show_expanded=False,
enable_events=True)
layout = [
[ tree],
## [ sg.Button('Add'), sg.Button('Remove')]
]
window = sg.Window('QueryTree Test').Layout(layout)
select = []
new = 0
while True:
event, values = window.Read()
if event is None:
break
print(event, values)
if event == '_QT__EXPAND_':
select = values['_QT_']
print(select)
tree.ask(window, select[0]) | ADTthious | /ADTthious-0.5.tar.gz/ADTthious-0.5/querytree2.py | querytree2.py |
import pathlib
from ADT import basictypes, fonctors, hbds, units
import PySimpleGUI as sg
from ADT import images
CALENDAR_ICON = pathlib.Path(__file__, '../calendar.png')
def boolWidget(valtype, val, key, disabled=False, size=(None,None)):
if val is None: val = False
return [
sg.Check('', default=val, key=key,
change_submits=True, disabled=disabled),
]
def red_greenButtons(valtype, val, key, disabled=False, size=(None,None)):
if val is None:
img = images.mac_gray
else:
img = images.mac_green if val else images.mac_red
b = sg.Button('', image_data=img, key=key, #change_submits=True,
button_color=(sg.DEFAULT_BACKGROUND_COLOR, sg.COLOR_SYSTEM_DEFAULT),
border_width=0, disabled=disabled, target=key
)
return [b]
def intWidget(valtype, val, key, disabled=False, size=(None,None)):
if val is None: val = ''
return [
sg.In(val, key=key, change_submits=True, do_not_clear=True,
size=(20,1), disabled=disabled),
]
def floatWidget(valtype, val, key, disabled=False, size=(None,None)):
if val is None: val = ''
return [
sg.In(val, key=key, change_submits=True, do_not_clear=True,
size=(20,1), disabled=disabled),
]
def strWidget(valtype, val, key, disabled=False, size=(None,None)):
if val is None: val = ''
return [
sg.In(val, key=key, change_submits=True, do_not_clear=True,
size=(20,1), disabled=disabled),
]
def EnumWidget(valtype, val, key, disabled=False, size=(None,None)):
V = [e.name for e in valtype] + ['None']
# ajoute 2 à la longueur car si non la flêche de la combo cache la fin du text
S = (max([len(v) for v in V])+2, sg.DEFAULT_ELEMENT_SIZE[1])
return [
sg.Combo(values=V, size=S,
default_value=val.name if val else 'None',
key=key, change_submits=True, disabled=disabled),
]
def dateWidget(valtype, val, key, disabled=False, size=(None,None)):
if val is None: val = ''
return [
sg.In(val, size=(20,1), key=key, change_submits=True, do_not_clear=True,
disabled=disabled),
sg.CalendarButton("", target=key,
default_date_m_d_y=(val.month, val.day, val.year),
image_filename=CALENDAR_ICON,
image_size=(25, 25),
image_subsample=1,
border_width=0),
]
def timeWidget(valtype, val, key, disabled=False, size=(None,None)):
if val is None: val = ''
return [
sg.In(val, size=(20,1), key=key, change_submits=True, do_not_clear=True,
disabled=disabled),
]
def datetimeWidget(valtype, val, key, disabled=False, size=(None,None)):
if val is None: val = ''
return [
sg.In(val, size=(20,1), key=key, change_submits=True, do_not_clear=True,
disabled=disabled),
sg.CalendarButton("", target=key,
default_date_m_d_y=(val.month, val.day, val.year),
image_filename=CALENDAR_ICON,
image_size=(30, 30),
image_subsample=1,
border_width=0),
]
def ColorWidget(valtype, val, key, disabled=False, size=(None,None)):
if val is None: val = ''
return [
sg.In(val, size=(8,1), key=key, change_submits=True, do_not_clear=True,
disabled=disabled),
sg.ColorChooserButton('' if val else '?', key='__'+key, size=(2,1),
target=key, button_color=(val,val) if val else (None,None)),
]
def PathWidget(valtype, val, key, disabled=False, size=(None,None)):
if val is None: val = basictypes.Path('.')
if val.is_dir():
return [
sg.In(val, key=key, do_not_clear=True, change_submits=True,
disabled=disabled),
sg.FolderBrowse(target=key, initial_folder=val, disabled=disabled)
]
else:
return [
sg.In(val, key=key, do_not_clear=True, change_submits=True,
disabled=disabled),
sg.FileBrowse(target=key, initial_folder=val, disabled=disabled)
]
type_to_widget = {
bool: boolWidget, #red_greenButtons,
int: intWidget,
float: floatWidget,
str: strWidget,
basictypes.Enum: EnumWidget,
basictypes.date: dateWidget,
basictypes.time: timeWidget,
basictypes.datetime: datetimeWidget,
basictypes.Color: ColorWidget,
basictypes.Path: PathWidget,
}
def basicWidget(valtype, val, key, size=(None,None), disabled=False):
if valtype:
widget = None
for t in valtype.__mro__:
wtype = type_to_widget.get(t, None)
if wtype:
widget = wtype(valtype, val, key, disabled=disabled, size=size)
if widget:
return widget
return [sg.T("Unknown widget for %s" % valtype)]
def make_keys(obj, attr):
idobj = id(obj)
in_key = "%s.%s" %(idobj, attr)
label_key = "_%s.%s" %(idobj, attr)
unit_key = "u_%s.%s" %(idobj, attr)
error_key = "?_%s.%s" %(idobj, attr)
return label_key, in_key, unit_key, error_key
def id_attr_from_keys(key):
if key[0] == 'u':
type_key = 'unit'
key = key[2:]
elif key[0] == '?':
type_key = 'error'
key = key[2:]
elif key[0] == '_':
type_key = 'label'
key = key[1:]
else:
type_key = 'in'
try:
ID, attr = key.split('.')
ID = int(ID)
except ValueError:
type_key = 'other'
ID = None
attr = key
return type_key, ID, attr
def is_hbds(obj):
if isinstance(obj, type):
return isinstance(obj, hbds.Class)
return isinstance(type(obj), hbds.Class)
def is_ComposedAtt(obj, attr):
if not is_hbds(obj): return False
if isinstance(obj, type):
typeattr = getattr(obj, attr)
else:
typeattr = getattr(type(obj), attr)
return type(typeattr).__name__.find('ComposedAtt_') != -1
def typeattr_val(obj, attr):
if isinstance(obj, type):
typeattr = getattr(obj, attr)
val = typeattr.default
else:
typeattr = getattr(type(obj), attr)
val = getattr(obj, attr)
return typeattr, val
def AttrElements(obj, attr, attrname_size=(None,None), attrinput_size=(None,None),
layout_type='align-left', disabled=False, enable_change_unit=False):
layout = []
label_key, in_key, unit_key, error_key = make_keys(obj, attr)
unit_widget = None
if is_hbds(obj):
if is_ComposedAtt(obj, attr):
val = getattr(obj, attr)
W = AttrsElements(val, None, attrname_size, attrinput_size,
layout_type, disabled)
layout.append(sg.Frame(attr, W))
return layout
typeattr, val = typeattr_val(obj, attr)
if typeattr.unit is not None:
## if enable_change_unit:
## # une combo avec la possibilité de changer l'unité
## V = [v.symbol for v in type(typeattr.unit)]
## S = (max([len(v) for v in V]), sg.DEFAULT_ELEMENT_SIZE[1])
## # bug dans PySimpleGUI ligne 5102: feild non unique!
## unit_widget = sg.Combo(values=V, size=S,
## default_value=typeattr.unit.symbol,
## key=unit_key, change_submits=True,
## tooltip=typeattr.unit.name)
## else:
## # Ou juste le symbol
unit_widget = sg.T(typeattr.unit.symbol, tooltip=typeattr.unit.name)
valtype = typeattr.type
else: # No hbds.Class
val = getattr(obj, attr)
valtype = type(val)
layout = basicWidget(valtype, val, in_key, attrinput_size, disabled)
err_button = sg.Button("?", visible=False, key=error_key)
# do layout based on layout type
if layout_type == 'align-left':
label = sg.T(attr, size=attrname_size, key=label_key, pad=(0,0),
auto_size_text=False, justification='left')
layout = [label] + layout + [err_button]
elif layout_type == 'align-center-left':
label = sg.T(attr, size=attrname_size, key=label_key, pad=(0,0),
auto_size_text=False, justification='right')
layout = [label] + layout + [err_button]
elif layout_type == 'align-right':
label = sg.T(attr, size=attrname_size, key=label_key, pad=(0,0),
auto_size_text=False, justification='right')
layout = layout + [label, err_button]
elif layout_type == 'align-center-right':
label = sg.T(attr, size=attrname_size, key=label_key, pad=(0,0),
auto_size_text=False, justification='left')
layout = layout + [label, err_button]
else:
msg = "layout_type param must be in (align-left, "
msg += "align-right, align-center-left, align-center-right). "
msg += "Is '%s'." % layout_type
raise ValueError(msg)
if unit_widget:
layout.append(unit_widget)
return layout
def AttrsElements(obj, attrs=None, attrname_size=(None,None),
attrinput_size=(None,None), layout_type='align-left', disabled=False,
enable_change_unit=False):
if attrs is None:
attrs = [a for a in fonctors.getattrs(obj)]
attrname_size = (
max([len(a) for a in attrs]),
sg.DEFAULT_ELEMENT_SIZE[1]
)
## print(attrname_size)
layout = []
for attr in attrs:
W = AttrElements(obj, attr, attrname_size, attrinput_size, layout_type, disabled,
enable_change_unit)
layout.append(W)
return layout
def convert_enum(pytype, val):
if basictypes.Enum not in pytype.__mro__: return val
if val == 'None':
return None
return getattr(pytype, val, val)
class ADTWindow(sg.Window):
def __init__(self, *args, **kargs):
super().__init__(*args, **kargs)
self.objects = {}
self.errors = {}
def Layout(self, objects, layout):
self.objects.update(dict([(id(o), o) for o in objects]))
return super().Layout(layout).Finalize()
def Read(self, timeout=None, timeout_key=sg.TIMEOUT_KEY):
event, values = super().Read(timeout, timeout_key)
if event is None: return event, values
type_key, i, attr = id_attr_from_keys(event)
if type_key == 'other':
return event, values
if type_key == "error":
sg.PopupError(self.errors[event[2:]])
return event, values
try:
obj = self.objects[i]
except KeyError:
return event, values
if type_key == "unit":
# try to convert value in input field
typeattr, val = typeattr_val(obj, attr)
for v in type(typeattr.unit):
if v.symbol == values[event]: break
k = "%d.%s"%(i,attr)
input_elt = self.Element(k)
newval = typeattr.unit.convert(float(values[k]), v)
input_elt.Update(newval)
return event, values
try:
newval = values[event]
except KeyError: # if widget is not input widget as defined by PySimpleGui
return event, values
if newval == '': newval = None
# try to validate new value
try:
if is_hbds(obj):
typeattr, val = typeattr_val(obj, attr)
newval = convert_enum(typeattr.type, newval)
newval = typeattr._validate(newval)
else:
pytype = type(getattr(obj, attr))
newval = convert_enum(pytype, newval)
newval = pytype(newval)
except (TypeError, ValueError) as e:
self.FindElement('_'+event).Update(text_color='red')
self.FindElement('?_'+event).Update(visible=True)
self.errors[event] = str(e)
return event, values
# update helper basetype button
if isinstance(newval, basictypes.Color):
self.FindElement('__'+event).Update(text='', button_color=(None,newval))
# reset label and help if no errors
self.FindElement('_'+event).Update(text_color=sg.DEFAULT_TEXT_COLOR)
self.FindElement('?_'+event).Update(visible=False)
if event in self.errors:
del self.errors[event]
return event, values
def py_objects_and_gui():
class X: pass
Genre = basictypes.Enum('Genre', "Homme Femme XXY YYX XYX")
x = X()
x.nom = "xx"
x.age = 12
x.taille = 1.8
x.marie = True
x.date_de_naissance = basictypes.date("19/08/1963")
x.heure_de_naissance = basictypes.time(10)
x.genre = Genre.Homme
x.X = []
x.now = basictypes.datetime.now()
return [x], AttrsElements(x)
def py_classes_and_gui():
class X: pass
Genre = basictypes.Enum('Genre', "Homme Femme XXY YYX XYX")
X.nom = "xx"
X.age = 12
X.taille = 1.8
X.marie = True
X.date_de_naissance = basictypes.date("19/08/1963")
X.heure_de_naissance = basictypes.time(10)
X.genre = Genre.Homme
X.X = []
X.now = basictypes.datetime.now()
return [X], AttrsElements(X)
def show(objs, layout):
window = ADTWindow('py object', resizable=True).Layout( objs, layout)
while True:
event, values = window.Read()
if event is None: return
type_key, id, attr = id_attr_from_keys(event)
if type_key == 'in':
obj = window.objects[id]
nv = values[event]
print("Changed: obj %s, attr %s, old value %s, new value %s" % \
(obj, attr, str(getattr(obj, attr)), nv ))
else:
print(event, values)
def hbds_model():
Blindage = basictypes.Enum('Blindage', "dur mou")
class Equipement(metaclass=hbds.Class):
nom = str, "toto"
blindage = Blindage
volume = float, units.CubicMeter.cubic_meter
masse = float, units.Kilogram.tonne
filtration_d_air = bool
dimensions = hbds.ComposedAtt(
longueur = (float, units.Meter.metre),
largeur = (float, units.Meter.metre),
)
pente = hbds.ComposedAtt(
pente_max = float, # degré
ralentissement = float, # pourcent
)
color = basictypes.Color
return Equipement, Blindage
def hbds_objects_and_gui():
Equipement, Blindage = hbds_model()
e1 = Equipement(nom="1")
e2 = Equipement(nom="2", blindage=Blindage.dur)
W = AttrsElements(e1, layout_type='align-center-left')
W1 = AttrsElements(e2, ["nom", "blindage", "volume", "masse", "filtration_d_air"], )
W2 = AttrsElements(e2, ["dimensions", "pente"] )
O = (e1, e2, e1.dimensions, e1.pente, e2.dimensions, e2.pente)
gui = [[sg.Column(W), sg.VSep(), sg.Column(W1), sg.VSep(), sg.Column(W2)]]
return O, gui
def hbds_classes_and_gui():
Equipement, Blindage = hbds_model()
W1 = AttrsElements(Equipement, ["nom", "blindage", "volume", "masse", "filtration_d_air"] )
W2 = AttrsElements(Equipement, ["dimensions", "pente"] )
O = (Equipement)
gui = [[sg.Column(W1), sg.VSep(), sg.Column(W2)]]
return O, gui
def test_size():
ST = (20,1)
SI = (10,1)
def T(t):
return sg.T(t, size=ST, pad=(0,0), auto_size_text=False,
background_color='white')
def TA(t):
return sg.T(t, pad=(0,0), auto_size_text=True,
background_color='#F2F2F2')
window = sg.Window('Test').Layout([
[T('A'), sg.In(size=SI)],
[T('A'*10), sg.In(size=SI)],
[T('w'*22), sg.In(size=SI), sg.Button('?')],
[TA('A'), sg.In(size=SI)],
[TA('A'*10), sg.In(size=SI)],
[TA('w'*22), sg.In(size=SI)],
])
while True:
event, values = window.Read()
if event is None: return
def test_ADTCreateWindow():
cls, layout = py_classes_and_gui()
layout += [[sg.Button("Create"), sg.Button("Cancel")]]
w = ADTWindow("test").Layout(cls, layout)
cls = cls[0]
while True:
event, values = w.Read()
if event is None or event == "Cancel": return None
if event == "Create":
o = cls()
for v in values:
type_key, id, attr = id_attr_from_keys(v)
if type_key != 'in': continue
setattr(o, attr, values[v])
return o
def main():
import random
from tkinter import font
import tkinter
root = tkinter.Tk()
fonts = list(font.families())
fonts.sort()
root.destroy()
# PB avec COLOR_SYSTEM_DEFAULT qui apparait trop souvent
index = random.choice(sg.ListOfLookAndFeelValues())
colors = sg.LOOK_AND_FEEL_TABLE[index]
## print(index, colors)
sg.ChangeLookAndFeel(index)
sg.DEFAULT_TEXT_COLOR = colors['TEXT']
f = (random.choice(fonts), random.randrange(8, 25))
print(f)
sg.SetOptions(
font=f
)
## print(sg.DEFAULT_TEXT_COLOR)
#show(*py_objects_and_gui())
#show(*py_classes_and_gui())
#show(*hbds_objects_and_gui())
#show(*hbds_classes_and_gui())
## o = test_ADTCreateWindow()
## d = dict([(a, getattr(o,a)) for a in fonctors.getattrs(o)])
## print(d)
test_size()
if __name__ == '__main__':
main() | ADTthious | /ADTthious-0.5.tar.gz/ADTthious-0.5/sgadt2.py | sgadt2.py |
Verbosity = 1
#When you drag an existing object on a canvas, we normally make the original
# label into an invisible phantom, and what you are ACTUALLY dragging is
# a clone of the objects label. If you set "LeavePhantomVisible" then you
# will be able to see the phantom which persists until the object is
# dropped. In real life you don't want the user to see the phantom, but
# for demonstrating what is going on it is useful to see it. This topic
# beaten to death in the comment string for Dragged.Press, below.
LeavePhantomVisible = 0
from tkinter import *
from tkinter import dnd
def MouseInWidget(Widget,Event):
"""
Figure out where the cursor is with respect to a widget.
Both "Widget" and the widget which precipitated "Event" must be
in the same root window for this routine to work.
We call this routine as part of drawing a DraggedObject inside a
TargetWidget, eg our Canvas. Since all the routines which need
to draw a DraggedObject (dnd_motion and it's friends) receive
an Event, and since an event object contain e.x and e.y values which say
where the cursor is with respect to the widget you might wonder what all
the fuss is about; why not just use e.x and e.y? Well it's never
that simple. The event that gets passed to dnd_motion et al was an
event against the InitiatingObject and hence what e.x and e.y say is
where the mouse is WITH RESPECT TO THE INITIATINGOBJECT. Since we want
to know where the mouse is with respect to some other object, like the
Canvas, e.x and e.y do us little good. You can find out where the cursor
is with respect to the screen (w.winfo_pointerxy) and you can find out
where it is with respect to an event's root window (e.*_root). So we
have three locations for the cursor, none of which are what we want.
Great. We solve this by using w.winfo_root* to find the upper left
corner of "Widget" with respect to it's root window. Thus we now know
where both "Widget" and the cursor (e.*_root) are with respect to their
common root window (hence the restriction that they MUST share a root
window). Subtracting the two gives us the position of the cursor within
the widget.
Yes, yes, we could have said:
return (Event.X_root-Widget.winfo_rootx(),Event.y_root-Widget.winfo_rooty())
and done it all on one line, but this is DEMO code and the three line version
below makes it rather more obvious what's going on.
"""
x = Event.x_root - Widget.winfo_rootx()
y = Event.y_root - Widget.winfo_rooty()
return (x,y)
def Blab(Level,Message):
"""
Display Message if Verbosity says to.
"""
if Verbosity >= Level:
print(Message)
class Dragged:
"""
This is a prototype thing to be dragged and dropped.
Derive from (or mixin) this class to creat real draggable objects.
"""
#We use this to assign a unique number to each instance of Dragged.
# This isn't a necessity; we do it so that during the demo you can
# tell one instance from another.
NextNumber = 0
def __init__(self):
Blab(1, "An instance of Dragged has been created")
#When created we are not on any canvas
self.Canvas = None
self.OriginalCanvas = None
#This sets where the mouse cursor will be with respect to our label
self.OffsetX = 20
self.OffsetY = 10
#Assign ourselves a unique number
self.Number = Dragged.NextNumber
Dragged.NextNumber += 1
#Use the number to build our name
self.Name = 'DragObj-%s'%self.Number
def dnd_end(self,Target,Event):
#this gets called when we are dropped
Blab(1, "%s has been dropped; Target=%s"%(self.Name,Target))
if self.Canvas==None and self.OriginalCanvas==None:
#We were created and then dropped in the middle of nowhere, or
# we have been told to self destruct. In either case
# nothing needs to be done and we will evaporate shortly.
return
if self.Canvas==None and self.OriginalCanvas!=None:
#We previously lived on OriginalCanvas and the user has
# dragged and dropped us in the middle of nowhere. What you do
# here rather depends on your own personal taste. There are 2 choices:
# 1) Do nothing. The dragged object will simply evaporate. In effect
# you are saying "dropping an existing object in the middle
# of nowhere deletes it". Personally I don't like this option because
# it means that if the user, while dragging an important object,
# twitches their mouse finger as the object is in the middle of
# nowhere then the object gets immediately deleted. Oops.
# 2) Resurrect the original label (which has been there but invisible)
# thus saying "dropping an existing dragged object in the middle of
# nowhere is as if no drag had taken place". Thats what the code that
# follows does.
self.Canvas = self.OriginalCanvas
self.ID = self.OriginalID
self.Label = self.OriginalLabel
self.Label['text'] = self.OriginalText
self.Label['relief'] = RAISED
#We call the canvases "dnd_enter" method here to keep its ObjectDict up
# to date. We know that we had been dragged off the canvas, so before
# we call "dnd_enter" the cansases ObjectDict says we are not on the
# canvas. The call to "dnd_enter" will till the canvas that we are,
# in effect, entering the canvas. Note that "dnd_enter" will in turn
# call our "Appear" method, but "Appear" is smart enough to realize
# that we already have a label on self.Canvas, so it quietly does
# does nothing,
self.Canvas.dnd_enter(self,Event)
return
#At this point we know that self.Canvas is not None, which means we have an
# label of ourself on that canvas. Bind <ButtonPress> to that label so the
# the user can pick us up again if and when desired.
self.Label.bind('<ButtonPress>',self.Press)
#If self.OriginalCanvas exists then we were an existing object and our
# original label is still around although hidden. We no longer need
# it so we delete it.
if self.OriginalCanvas:
self.OriginalCanvas.delete(self.OriginalID)
self.OriginalCanvas = None
self.OriginalID = None
self.OriginalLabel = None
def Appear(self, Canvas, XY):
"""
Put an label representing this Dragged instance on Canvas.
XY says where the mouse pointer is. We don't, however, necessarily want
to draw our upper left corner at XY. Why not? Because if the user
pressed over an existing label AND the mouse wasn't exactly over the
upper left of the label (which is pretty likely) then we would like
to keep the mouse pointer at the same relative position inside the
label. We therefore adjust X and Y by self.OffsetX and self.OffseY
thus moving our upper left corner up and/or left by the specified
amounts. These offsets are set to a nominal value when an instance
of Dragged is created (where it matters rather less), and to a useful
value by our "Press" routine when the user clicks on an existing
instance of us.
"""
if self.Canvas:
#we are already on a canvas; do nothing
return
self.X, self.Y = XY
#Create a label which identifies us, including our unique number
self.Label = Label(Canvas,text=self.Name,borderwidth=2, relief=RAISED)
#Display the label on a window on the canvas. We need the ID returned by
# the canvas so we can move the label around as the mouse moves.
self.ID = Canvas.create_window(self.X-self.OffsetX, self.Y-self.OffsetY, window=self.Label, anchor="nw")
#Note the canvas on which we drew the label.
self.Canvas = Canvas
def Vanish(self,All=0):
"""
If there is a label representing us on a canvas, make it go away.
if self.Canvas is not None, that implies that "Appear" had prevously
put a label representing us on the canvas and we delete it.
if "All" is true then we check self.OriginalCanvas and if it not None
we delete from it the label which represents us.
"""
if self.Canvas:
#we have a label on a canvas; delete it
self.Canvas.delete(self.ID)
#flag that we are not represented on the canvas
self.Canvas = None
#Since ID and Label are no longer meaningful, get rid of them lest they
#confuse the situation later on. Not necessary, but tidy.
del self.ID
del self.Label
if All and self.OriginalCanvas:
#Delete label representing us from self.OriginalCanvas
self.OriginalCanvas.delete(self.OriginalID)
self.OriginalCanvas = None
del self.OriginalID
del self.OriginalLabel
def Move(self,XY):
"""
If we have a label a canvas, then move it to the specified location.
XY is with respect to the upper left corner of the canvas
"""
assert self.Canvas, "Can't move because we are not on a canvas"
self.X, self.Y = XY
self.Canvas.coords(self.ID,self.X-self.OffsetX,self.Y-self.OffsetY)
def Press(self,Event):
"""
User has clicked on a label representing us. Initiate drag and drop.
There is a problem, er, opportunity here. In this case we would like to
act as both the InitiationObject (because the user clicked on us
and it't up to us to start the drag and drop) but we also want to
act as the dragged object (because it's us the user wants to drag
around). If we simply pass ourself to "Tkdnd" as the dragged object
it won't work because the entire drag and drop process is moved
along by <motion> events as a result of a binding by the widget
on which the user clicked. That widget is the label which represents
us and it get moved around by our "move" method. It also gets
DELETED by our "vanish" method if the user moves it off the current
canvas, which is a perfectly legal thing from them to do. If the
widget which is driving the process gets deleted, the whole drag and
drop grinds to a real quick halt. We use a little sleight of hand to
get around this:
1) From the label which is currently representing us (self.Label)
we take the text and save it in self.OriginalText. This will allow
us to resurrect the label at a later time if so desired. (It turns
out we so desire if the user tries to drop us in the middle of
nowhere, but that's a different story; see "dnd_end", above).
2) We take the label which is currently representing us (self.Label)
and we make it into an invisible phantom by setting its text to ''
and settings its relief to FLAT. It is now, so to speak, a polar
bear in a snowstorm. It's still there, but it blends in with the
rest of then canvas on which it sits.
3) We move all the information about the phantom label (Canvas, ID
and Label) into variables which store information about the
previous label (PreviousCanvas, PreviousID and PreviousLabel)
4) We set self.Canvas and friends to None, which indicates that we
don't have a label representing us on the canvas. This is a bit
of a lie (the phantom is technically on the canvas) but it does no
harm.
5) We call "self.Appear" which, noting that don't have a label
representing us on the canvas, promptly draws one for us, which
gets saved as self.Canvas etc.
We went to all this trouble so that:
a) The original widget on which the user clicked (now the phantom)
could hang around driving the drag and drop until it is done, and
b) The user has a label (the one just created by Appear) which they
can drag around, from canvas to canvas as desired, until they
drop it. THIS one can get deleted from the current canvas and
redrawn on another canvas without Anything Bad happening.
From the users viewpoint the whole thing is seamless: they think
the ARE dragging around the original label, but they are not. To
make it really clear what is happening, go to the top of the
code and set "LeavePhantomVisible" to 1. Then when you drag an
existing object, you will see the phantom.
The phantom is resolved by routine "dnd_end" above. If the user
drops us on a canvas, then we take up residence on the canvas and
the phantom label, no longer needed, is deleted. If the user tries
to drop us in the middle of nowhere, then there will be no
'current' label for us (because we are in the middle of nowhere)
and thus we resurrect the phantom label which in this case
continues to represent us.
Note that this whole deal happens ONLY when the user clicks on an
EXISTING instance of us. In the case where the user clicks over
the button marked "InitiationObject" then it it that button that
IS the initiation object, it creates a copy of us and the whole
opportunity never happens, since the "InitiationObject" button
is never in any danger of being deleted.
"""
Blab(1, "Dragged.press")
#Save our current label as the Original label
self.OriginalID = self.ID
self.OriginalLabel = self.Label
self.OriginalText = self.OriginalLabel['text']
self.OriginalCanvas = self.Canvas
#Made the phantom invisible (unless the user asked to see it)
if LeavePhantomVisible:
self.OriginalLabel['text'] = '<phantom>'
self.OriginalLabel['relief']=RAISED
else:
self.OriginalLabel['text'] = ''
self.OriginalLabel['relief']=FLAT
#Say we have no current label
self.ID = None
self.Canvas = None
self.Label = None
#Ask Tkdnd to start the drag operation
if dnd.dnd_start(self,Event):
#Save where the mouse pointer was in the label so it stays in the
# same relative position as we drag it around
self.OffsetX, self.OffsetY = MouseInWidget(self.OriginalLabel,Event)
#Draw a label of ourself for the user to drag around
XY = MouseInWidget(self.OriginalCanvas,Event)
self.Appear(self.OriginalCanvas,XY)
class CanvasDnd(Canvas):
"""
A canvas to which we have added those methods necessary so it can
act as both a TargetWidget and a TargetObject.
Use (or derive from) this drag-and-drop enabled canvas to create anything
that needs to be able to receive a dragged object.
"""
def __init__(self, Master, cnf={}, **kw):
if cnf:
kw.update(cnf)
Canvas.__init__(self, Master, kw)
#ObjectDict is a dictionary of dragable object which are currently on
# this canvas, either because they have been dropped there or because
# they are in mid-drag and are over this canvas.
self.ObjectDict = {}
#----- TargetWidget functionality -----
def dnd_accept(self,Source,Event):
#Tkdnd is asking us (the TargetWidget) if we want to tell it about a
# TargetObject. Since CanvasDnd is also acting as TargetObject we
# return 'self', saying that we are willing to be the TargetObject.
Blab(2, "Canvas: dnd_accept")
return self
#----- TargetObject functionality -----
def dnd_enter(self,Source,Event):
#This is called when the mouse pointer goes from outside the
# Target Widget to inside the Target Widget.
Blab(1, "Receptor: dnd_enter")
#Figure out where the mouse is with respect to this widget
XY = MouseInWidget(self,Event)
#Since the mouse pointer is just now moving over us (the TargetWidget),
# we ask the DraggedObject to represent itself on us.
# "Source" is the DraggedObject.
# "self" is us, the CanvasDnd on which we want the DraggedObject to draw itself.
# "XY" is where (on CanvasDnd) that we want the DraggedObject to draw itself.
Source.Appear(self,XY)
#Add the DraggedObject to the dictionary of objects which are on this
# canvas.
self.ObjectDict[Source.Name] = Source
def dnd_leave(self,Source,Event):
#This is called when the mouse pointer goes from inside the
# Target Widget to outside the Target Widget.
Blab(1, "Receptor: dnd_leave")
#Since the mouse pointer is just now leaving us (the TargetWidget), we
# ask the DraggedObject to remove the representation of itself that it
# had previously drawn on us.
Source.Vanish()
#Remove the DraggedObject from the dictionary of objects which are on
# this canvas
del self.ObjectDict[Source.Name]
def dnd_motion(self,Source,Event):
#This is called when the mouse pointer moves withing the TargetWidget.
Blab(2, "Receptor: dnd_motion")
#Figure out where the mouse is with respect to this widget
XY = MouseInWidget(self,Event)
#Ask the DraggedObject to move it's representation of itself to the
# new mouse pointer location.
Source.Move(XY)
def dnd_commit(self,Source,Event):
#This is called if the DraggedObject is being dropped on us.
#This demo doesn't need to do anything here (the DraggedObject is
# already in self.ObjectDict) but a real application would
# likely want to do stuff here.
Blab(1, "Receptor: dnd_commit; Object received= %s"%Source)
#----- code added for demo purposes -----
def ShowObjectDict(self,Comment):
"""
Print Comment and then print the present content of our ObjectDict.
"""
print(Comment)
if len(self.ObjectDict) > 0:
for Name,Object in self.ObjectDict.items():
print(' %s %s'%(Name,Object))
else:
print(" <empty>" )
class TrashBin(CanvasDnd):
"""
A canvas specifically for deleting dragged objects.
"""
def __init__(self,Master,**kw):
#Set default height/width if user didn't specify.
if 'width' not in kw:
kw['width'] =150
if 'height' not in kw:
kw['height'] = 25
CanvasDnd.__init__(self, Master, kw)
#Put the text "trash" in the middle of the canvas
X = kw['width'] / 2
Y = kw['height'] /2
self.create_text(X,Y,text='TRASH')
def dnd_commit(self,Source,Event):
"""
Accept an object dropped in the trash.
Note that the dragged object's 'dnd_end' method is called AFTER this
routine has returned. We call the dragged objects "Vanish(All=1)"
routine to get rid of any labels it has on any canvas. Having done
so, it will, at 'dnd_end' time, allow itself to evaporate. If you
DON'T call "Vanish(All=1)" AND there is a phantom label of the dragged
object on an OriginalCanvas then the dragged object will think it
has been erroniously dropped in the middle of nowhere and it will
resurrect itself from the OriginalCanvas label. Since we are trying
to trash it, we don't want this to happen.
"""
Blab(1, "TrashBin: dnd_commit")
#tell the dropped object to remove ALL labels of itself.
Source.Vanish(All=1)
#were a trash bin; don't keep objects dropped on us.
self.ObjectDict.clear()
if __name__ == "__main__":
def on_dnd_start(Event):
"""
This is invoked by InitiationObject to start the drag and drop process
"""
#Create an object to be dragged
ThingToDrag = Dragged()
#Pass the object to be dragged and the event to Tkdnd
dnd.dnd_start(ThingToDrag,Event)
def ShowObjectDicts():
"""
Some demo code to let the user see what ojects we think are
on each of the three canvases.
"""
TargetWidget_TargetObject.ShowObjectDict('UpperCanvas')
TargetWidget_TargetObject2.ShowObjectDict('LowerCanvas')
Trash.ShowObjectDict('Trash bin')
print('----------')
Root = Tk()
Root.title('Drag-and-drop "real-world" demo')
#Create a button to act as the InitiationObject and bind it to <ButtonPress> so
# we start drag and drop when the user clicks on it.
#The only reason we display the content of the trash bin is to show that it
# has no objects, even after some have been dropped on it.
InitiationObject = Button(Root,text='InitiationObject')
InitiationObject.pack(side=TOP)
InitiationObject.bind('<ButtonPress>',on_dnd_start)
#Create two canvases to act as the Target Widgets for the drag and drop. Note that
# these canvases will act as both the TargetWidget AND the TargetObject.
TargetWidget_TargetObject = CanvasDnd(Root,relief=RAISED,bd=2)
TargetWidget_TargetObject.pack(expand=YES,fill=BOTH)
TargetWidget_TargetObject2 = CanvasDnd(Root,relief=RAISED,bd=2)
TargetWidget_TargetObject2.pack(expand=YES,fill=BOTH)
#Create an instance of a trash can so we can get rid of dragged objects
# if so desired.
Trash = TrashBin(Root, relief=RAISED,bd=2)
Trash.pack(expand=NO)
#Create a button we can press to display the current content of the
# canvases ObjectDictionaries.
Button(text='Show canvas ObjectDicts',command=ShowObjectDicts).pack()
Root.mainloop() | ADTthious | /ADTthious-0.5.tar.gz/ADTthious-0.5/dnd_example2.py | dnd_example2.py |
import ipywidgets as widgets
from . import basictypes
def select_widget(obj, attr):
val = getattr(obj, attr)
# On récupère le type de l'attribut et pas seulement de la valeur
try:
valtype = getattr(type(obj), attr).type
except AttributeError:
valtype = type(getattr(obj, attr))
if valtype is bool:
widget = widgets.Checkbox(value=val,
description=attr,
disabled=False)
elif valtype is int:
widget = widgets.IntText(value=val,
description=attr,
disabled=False)
elif valtype is float:
widget = widgets.FloatText(value=val,
description=attr,
disabled=False)
elif valtype is str:
widget = widgets.Text(value=val,
description=attr,
disabled=False,
placeholder='')
elif isinstance(val, basictypes.Enum):
widget = widgets.Dropdown(value=val.name,
options=list(type(val).__members__.keys()),
description=attr,
disabled=False)
elif isinstance(val, basictypes.date):
widget = widgets.DatePicker(value=val,
description=attr,
disabled=False)
elif isinstance(val, basictypes.time):
widget = widgets.Text(value=val.strftime("%H:%M:%S"),
description=attr,
disabled=False,
placeholder='hh:mm:ss')
elif isinstance(val, basictypes.datetime):
widget = widgets.HBox((
widgets.Label(value=attr),
widgets.DatePicker(value=val),
widgets.Text(value=val.strftime("%H:%M:%S"),
placeholder='hh:mm:ss')
))
else:
widget = None
return widget
def objatt2widget(obj, attr, widget_selector=select_widget):
def on_value_change(change):
newval = change['new']
oldval = getattr(obj, attr)
print(oldval, newval)
if isinstance(oldval, basictypes.Enum):
newval = type(oldval).__members__[newval]
if oldval != newval:
if isinstance(oldval, basictypes.datetime) \
and isinstance(newval, basictypes.date):
newval = basictypes.datetime(newval.year, newval.month, newval.day)
setattr(obj, attr, newval)
widget = widget_selector(obj, attr)
if widget is None:
widget = widgets.Text(value="Unknown widget for type '%s' for '%s'" % (type(val), val),
description=attr,
disabled=True)
widget.observe(on_value_change, names='value')
return widget | ADTthious | /ADTthious-0.5.tar.gz/ADTthious-0.5/ipyadt.py | ipyadt.py |
# ADVECTOR V1.0
The ADVECTOR is a whole-ocean marine debris transport model which is built to handle millions of particles and terabytes of data. It models the transport of debris based on its size, shape, and density, and simulates basic physical processes including 3D ocean current-driven advection, wind-driven drift, wind-driven near-surface vertical mixing, buoyancy-driven vertical transport, and eddy-driven diffusion. It automatically processes forcing datasets arbitrarily larger than memory capacity, and supports fully parallelized computation on CPUs and GPUs via OpenCL.
## Model Description
The ADVECTOR contains solvers (kernels) for two domains: ocean surface, and whole-ocean.
* 2D kernel: model domain is constrained to the surface of the ocean (assumption: floating debris), and debris particles are idealized, with no consideration of their size/shape/density.
* 3D kernel: model domain is the whole oceans, from surface to bathymetry, and physical processes depend on the size/shape/density of debris.
### 2D Kernel
Each particle is released at some location in space and time. Upon release, each particle is transported according to the following physical processes:
#### Surface ocean current-driven advection
Particles are transported in a time-evolving 2D velocity field of surface ocean currents, which the user must provide. The particles are advected according to one of two schemes: forward-Euler, or a second-order Taylor-expansion scheme which corrects for the outward-drift error the Euler method experiences in a curved field.
#### Wind-driven drift
Optionally, the user may provide a time-evolving 2D velocity field of 10-meter wind, which will move particles according to a user-provided windage coefficient.
#### Eddy-driven diffusion
Finally, the user may specify a constant eddy diffusivity, which will add random noise to the particle's movements. This simulates the effect of eddies smaller than the spatial resolution of the ocean currents.
#### Boundary processes
The model domain only includes the surface waters of the ocean (as defined by the non-null region in the ocean current vectorfield); particles cannot leave this domain, and thus the model does not include beaching. Instead, when particles are pushed against a coastline, their onshore displacement component is cropped to keep them in the model domain, generally resulting in a lateral displacement, as if the boundary was frictionless.
### 3D Kernel
Each particle is initialized with a size, shape, density, release date, and release location. Upon release, particles are transported according to the following physical processes:
#### 3D ocean current-driven advection
Particles are transported according to a time-evolving 3D velocity field of ocean currents, which the user provides. The particles are advected according to one of two schemes: forward-Euler, or a 3D adaptation of the second-order Taylor-expansion scheme from the 2D kernel.
#### Buoyancy-driven transport
The user must provide a time-evolving 3D dataset containing the density of seawater in the ocean domain. Particles are transported vertically according to their terminal sinking (or rising) velocity, which is calculated using their size, shape, and density, as well as the density of the surrounding seawater.
#### Wind-driven drift
Optionally, the user may provide a time-evolving 2D velocity field of 10-meter wind, which will move particles floating at the surface based on a parameterization which depends on their emerged surface area. The user may optionally provide a multiplier which scales this drift, for the sake of experimentation.
#### Wind-driven vertical mixing
If wind is provided, the user may optionally enable the simulation of wind-driven vertical mixing. Mixing transport is based on an equilibrium between a particle's rising velocity and the size of ocean waves (estimated from wind).
#### Eddy-driven diffusion
Finally, the user may specify a vertical profile of vertical and horizontal eddy diffusivities, which will add noise to the particle's movements according to its depth. This simulates eddies smaller than the spatial resolution of the ocean currents, and allows the user the flexibility to account for the depth-dependent nature of eddy diffusivity in the world's oceans.
#### Boundary processes
The model domain only includes the waters of the ocean above bathymetry (as defined by the non-null region in the ocean current vectorfield); particles cannot leave this domain, and thus the model does not include beaching or sedimentation. Instead, when particles are pushed against coastline/bathymetry, their out-of-domain displacement components are cropped to keep them in the model domain. This is the 3D analog of the frictionless coastlines used in the 2D kernel, and similarly allows particles to travel parallel to domain boundaries.
## Installation Instructions
1. In a terminal, clone this repository and navigate to its root.
2. Install ADVECTOR as a package by running
```
pip install .
```
3. (Optional) Run tests
To ensure everything is working before you go through the effort of downloading forcing data, run `python -m pytest` from the repository root. If any tests do not pass, a first step is to check out the "hardware compatability" section below.
4. Acquire forcing data
Run ```ADVECTOR_download_sample_data``` and follow the prompts.
5. Run example advection
Run ```ADVECTOR_examples_2D``` or ```ADVECTOR_examples_3D``` and follow the prompts to see it in action!
## Using ADVECTOR in your own programs
The key entry-point scripts to the ADVECTOR are `ADVECTOR/run_advector_2D.py` and `ADVECTOR/run_advector_3D.py`. Those files include documentation on all their respective arguments. There are also supplementary documentation files in the `documentation` folder; you'll want to read all of these carefully to understand what you can/can't feed into the ADVECTOR, and what it'll give you back.
In short, your script will look something like:
```
from ADVECTOR import run_advector_2D # or run_advector_3D
outputfile_paths = run_advector_2D(<many arguments here>)
```
That's it!
If you need information on the arguments and don't want to refer directly to the source code, just open an interactive python prompt, import the runner as above, then run `help(run_advector_2D)`.
As a general rule, you can pretty much copy the structure of `ADVECTOR/examples/ECCO_advect_2D.py` or `ADVECTOR/examples/ECCO_advect_3D.py`, providing your own data and generating your own source/configfiles. The examples exist for your reference!
## Extra: the INTEGRATOR
3D ocean model output generally only includes the zonal/meridional current velocity; ADVECTOR comes bundled with a tool called the INTEGRATOR which can generate vertical velocity fields from zonal/meridional velocity fields, using the continuity equation. Check out `INTEGRATOR/README.md` for more information. Currently it doesn't install via pip, so you'll need to clone this repository and run the files directly.
### Hardware compatability
At this time, ADVECTOR only has known support for CPUs/GPUs with opencl driver versions 1.1, 1.2, and 2.1. Running tests is one way to check if your hardware is compatible. If they fail, you can run this in a python prompt to directly check your driver version:
```
import pyopencl
print(pyopencl.create_some_context(interactive=True).devices[0].driver_version)
```
Follow the instructions to select a compute device, and its driver version will be displayed.
| ADVECTOR | /ADVECTOR-1.0.1.tar.gz/ADVECTOR-1.0.1/README.md | README.md |
cs107 Final Project - Group 28: Byte Me
=====
Members
-----
- Luo, Yanqi
- Pasco, Paolo
- Ayouch, Rayane
- Clifton, Logan
## TravisCI badge
[](https://app.travis-ci.com/cs107-byteme/cs107-FinalProject)
## Codecov badge
[](https://codecov.io/gh/cs107-byteme/cs107-FinalProject)
## Broader Impact and Inclusivity Statement
Our automatic differentiation library can lead to a number of benefits in a variety of fields. Since automatic differentiation can be used in fields like physics, statistics, and machine learning, our package has the potential to accelerate advances in those fields by facilitating the key process of automatic differentiation. One potential impact to be wary of is the fact that while the package can be used for many important scientific methods, we don't have much control over how the package is used on the user end. This means that the burden is on the user to use our package responsibly (i.e., if the user is using this package for machine learning, it's important to check that the input data is free of biases or error. Otherwise, this package will be used to perpetuate the biases present in the training data). Ultimately, this package is a tool, and like all tools, it's helpful for its presumed purpose but can be misused.
In addition, we've worked to make this package as accessible and easy to understand as possible, making its use approachable for anyone regardless of programming/mathematical experience. Our workflow for this project has also been inclusive—all pull requests are reviewed by other members of the team, giving everyone a hand in contributing to the code. The biggest barrier to access (both on the contributing side and the implementation side) is getting started. While we've attempted to document the code and make it intuitive enough that any user can get started with our package, the fact remains that the steps needed to install/start contributing to the package (creating a virtual environment, or getting started with git/test suites/version control), while not impossible to learn, can be intimidating to someone without a certain level of programming experience. Our hope is that these steps are easy enough to research that this intimidation can be overcome, but we do recognize that for underrepresented populations without as much access to CS education, an intimidating first step can be enough to dissuade someone from pursuing a project further. | ADbase | /ADbase-0.1.7.tar.gz/ADbase-0.1.7/README.md | README.md |
import networkx as nx
import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
import numpy as np
import pandas as pd
from ADnum_rev_timed_vis import ADnum
from mpl_toolkits.mplot3d import Axes3D
def gen_graph(y):
""" Function to create a directed graph from an ADnum.
INPUTS
======
y : ADnum
OUTPUTS
=======
A networkx digraph
"""
G = nx.DiGraph()
d = y.graph
if len(d)== 0:
G.add_node(y)
for key in d:
G.add_node(key)
neighbors = d[key]
for neighbor in neighbors:
G.add_edge(key, neighbor[0], label = neighbor[1])
return G
def reverse_graph(y):
""" Function to create a dictionary containing edges of y reversed.
INPUTS
======
y : ADnum
OUTPUTS
=======
A dictionary
"""
d = y.graph
parents = {}
for key in d:
neighbors = d[key]
for neighbor in neighbors:
if neighbor[0] not in parents:
parents[neighbor[0]] = []
parents[neighbor[0]].append((key, neighbor[1]))
return parents
def get_labels(y):
""" Function to generate labels for plotting networkx graph.
INPUTS
======
y : ADnum
OUTPUTS
=======
A dictionary of ADnum objects mapped to string labels
"""
parents = reverse_graph(y)
total = len(y.graph) - sum([entry.constant for entry in y.graph.keys()])
new_names = {}
nodes = [y]
while len(nodes)>0:
node = nodes.pop(0)
if node not in new_names:
if node.constant:
new_names[node] = str(np.round(node.val, decimals=1))
else:
new_names[node] = 'X' + str(total)
total = total - 1
if node in parents:
neighbors = parents[node]
for neighbor in neighbors:
nodes.append(neighbor[0])
return new_names
def get_labels_rev(y):
""" Function to generate labels for plotting networkx graph.
INPUTS
======
y : ADnum
OUTPUTS
=======
A dictionary of ADnum objects mapped to string labels
"""
parents = reverse_graph(y)
#total = len(y.graph) - sum([entry.constant for entry in y.graph.keys()])
total = 0
new_names = {}
nodes = [y]
while len(nodes)>0:
node = nodes.pop()
if node not in new_names:
if node.constant:
new_names[node] = str(np.round(node.val, decimals=1))
else:
new_names[node] = 'X' + str(total)
total = total + 1
if node in parents:
neighbors = parents[node]
for neighbor in neighbors:
nodes.append(neighbor[0])
return new_names
def get_colors(G, y):
""" Function to assign colors to nodes in the graph.
INPUTS
======
G : networkx digraph
y : ADnum
OUTPUTS
=======
A list of colors for the graph
"""
colors = []
parents = reverse_graph(y)
for node in G:
if node.constant:
colors.append('blue')
else:
if node == y:
colors.append('green')
else:
if node in parents:
colors.append('red')
else:
colors.append('magenta')
return colors
def get_sizes(G, y, labs):
""" Function to assign sizes to nodes in the graph.
INPUTS
======
G : networkx digraph
y : ADnum
labs : dictionary of graph labels
OUTPUTS
=======
A list of sizes for the graph
"""
sizes = []
for node in G:
label = labs[node]
sizes.append(len(label)*200)
return sizes
def draw_graph(y):
""" Function to draw the graph.
INPUTS
======
y : ADnum
OUTPUTS
=======
A plot of the graph
"""
fig = plt.figure()
G = gen_graph(y)
edge_labs = nx.get_edge_attributes(G, 'label')
pos = nx.spring_layout(G)
labs = get_labels(y)
nx.draw_networkx(G, pos, labels = labs, node_color = get_colors(G, y), node_size = get_sizes(G, y, labs), font_color= 'white')
nx.draw_networkx_edge_labels(G, pos, edge_labels = edge_labs)
limits = plt.axis('off')
mag_patch = mpatches.Patch(color = 'magenta', label = 'input')
red_patch = mpatches.Patch(color = 'red', label = 'intermediate')
blue_patch = mpatches.Patch(color = 'blue', label = 'constant')
green_patch = mpatches.Patch(color = 'green', label = 'output')
plt.legend(handles = [mag_patch, red_patch, blue_patch, green_patch])
return fig
def draw_graph2(y, G, edge_labs, pos, labs):
""" Function to draw the graph.
INPUTS
======
y : ADnum
OUTPUTS
=======
A plot of the graph
"""
fig = plt.figure()
#G = gen_graph(y)
#edge_labs = nx.get_edge_attributes(G, 'label')
#pos = nx.spring_layout(G)
#labs = get_labels(y)
nx.draw_networkx(G, pos, labels = labs, node_color = get_colors(G, y), node_size = get_sizes(G, y, labs), font_color= 'white')
nx.draw_networkx_edge_labels(G, pos, edge_labels = edge_labs)
limits = plt.axis('off')
mag_patch = mpatches.Patch(color = 'magenta', label = 'input')
red_patch = mpatches.Patch(color = 'red', label = 'intermediate')
blue_patch = mpatches.Patch(color = 'blue', label = 'constant')
green_patch = mpatches.Patch(color = 'green', label = 'output')
plt.legend(handles = [mag_patch, red_patch, blue_patch, green_patch])
plt.show()
#return fig
def draw_graph_rev(y):
""" Function to draw the graph.
INPUTS
======
y : ADnum
OUTPUTS
=======
A plot of the graph
"""
fig = plt.figure()
G = gen_graph(y)
G = G.reverse()
edge_labs = nx.get_edge_attributes(G, 'label')
pos = nx.spring_layout(G)
labs = get_labels(y)
#labs = get_labels_rev(y)
nx.draw_networkx(G, pos, labels = labs, node_color = get_colors(G, y), node_size = get_sizes(G, y, labs), font_color= 'white')
nx.draw_networkx_edge_labels(G, pos, edge_labels = edge_labs)
limits = plt.axis('off')
mag_patch = mpatches.Patch(color = 'magenta', label = 'input')
red_patch = mpatches.Patch(color = 'red', label = 'intermediate')
blue_patch = mpatches.Patch(color = 'blue', label = 'constant')
green_patch = mpatches.Patch(color = 'green', label = 'output')
plt.legend(handles = [mag_patch, red_patch, blue_patch, green_patch])
return fig
def draw_graph_rev2(y, G, edge_labs, pos, labs):
""" Function to draw the graph.
INPUTS
======
y : ADnum
OUTPUTS
=======
A plot of the graph
"""
fig = plt.figure()
#G = gen_graph(y)
G = G.reverse()
#edge_labs = nx.get_edge_attributes(G, 'label')
#pos = nx.spring_layout(G)
#labs = get_labels(y)
#labs = get_labels_rev(y)
nx.draw_networkx(G, pos, labels = labs, node_color = get_colors(G, y), node_size = get_sizes(G, y, labs), font_color= 'white')
nx.draw_networkx_edge_labels(G, pos, edge_labels = edge_labs)
limits = plt.axis('off')
mag_patch = mpatches.Patch(color = 'magenta', label = 'input')
red_patch = mpatches.Patch(color = 'red', label = 'intermediate')
blue_patch = mpatches.Patch(color = 'blue', label = 'constant')
green_patch = mpatches.Patch(color = 'green', label = 'output')
plt.legend(handles = [mag_patch, red_patch, blue_patch, green_patch])
plt.show()
#return fig
def get_graph_setup(y):
G = gen_graph(y)
#G = G.reverse()
edge_labs = nx.get_edge_attributes(G, 'label')
pos = nx.spring_layout(G, k=.15, iterations=20)
labs = get_labels(y) #changed from get labels rev
return G, edge_labs, pos, labs
def axis_reverse_edge(y, G, edge_labs, pos, labs, ax, edgelist, idx):
edge = edgelist[idx]
nx.draw_networkx(G, pos, ax = ax, labels = labs, node_color = get_colors(G, y), node_size = get_sizes(G, y, labs), font_color= 'white')
nx.draw_networkx_edges(G, pos=pos, ax=ax, edgelist = edge, width = 4, edge_color = 'y', style = 'dashed')
nx.draw_networkx_edge_labels(G, pos=pos, ax=ax, edge_labels = edge_labs)
limits = plt.axis('off')
def draw_graph_rev_dynamic(y, edgelist, G, edge_labs, pos, labs, val):
edgelist.reverse()
fig = plt.figure()
#G, edge_labs, pos, labs = get_graph_setup(y)
G = G.reverse()
ax = fig.add_subplot(111)
plt.title('Press enter to start. \n Then use the left and right arrow keys to step through the calculation.')
plt.axis("off")
global curr_pos
curr_pos = 0
#axis_reverse_edge(y, G, edge_labs, pos, labs, ax, edgelist, curr_pos)
#plt.show()
def key_event(e):
global curr_pos
ax.cla()
if e.key == 'enter':
curr_pos = curr_pos
elif e.key == 'right':
curr_pos = curr_pos +1
if curr_pos >= len(edgelist):
curr_pos = len(edgelist)-1
elif e.key == 'left':
curr_pos = curr_pos -1
if curr_pos<0:
curr_pos = 0
else:
return
#curr_pos = curr_pos%len(edgelist)
axis_reverse_edge(y, G, edge_labs, pos, labs, ax, edgelist, curr_pos)
if curr_pos == len(edgelist)-1:
plt.title('Step ' + str(curr_pos+1) +': Calculation Complete')
else:
plt.title('Step ' + str(curr_pos+1))
plt.show()
if len(edgelist)>0:
fig.canvas.mpl_connect('key_press_event', key_event)
elif val == 1:
plt.close()
draw_graph_rev2(y, G, edge_labs, pos, labs)
else:
#draw_graph_rev2(y, G, edge_labs, pos, labs)
plt.title('No dependence on input variable.')
plt.show()
def draw_graph_rev_dynamic_old(y, edgelist):
""" Function to draw the graph.
INPUTS
======
y : ADnum
OUTPUTS
=======
A plot of the graph
"""
edgelist.reverse()
fig = plt.figure()
G = gen_graph(y)
G = G.reverse()
edge_labs = nx.get_edge_attributes(G, 'label')
pos = nx.spring_layout(G)
labs = get_labels_rev(y)
nx.draw_networkx(G, pos, labels = labs, node_color = get_colors(G, y), node_size = get_sizes(G, y, labs), font_color= 'white')
nx.draw_networkx_edge_labels(G, pos, edge_labels = edge_labs)
limits = plt.axis('off')
mag_patch = mpatches.Patch(color = 'magenta', label = 'input')
red_patch = mpatches.Patch(color = 'red', label = 'intermediate')
blue_patch = mpatches.Patch(color = 'blue', label = 'constant')
green_patch = mpatches.Patch(color = 'green', label = 'output')
plt.legend(handles = [mag_patch, red_patch, blue_patch, green_patch])
figset = []
for edge in edgelist:
fignew = plt.figure()
nx.draw_networkx(G, pos, labels = labs, node_color = get_colors(G, y), node_size = get_sizes(G, y, labs), font_color= 'white')
nx.draw_networkx_edges(G, pos=pos, edgelist = edge, width = 4, edge_color = 'y', style = 'dashed')
nx.draw_networkx_edge_labels(G, pos=pos, edge_labels = edge_labs)
figset.append(fignew)
return fig, figset
def gen_table(y):
""" Function to generate tables for the ADnum.
INPUTS
======
y : ADnum
OUTPUTS
=======
A pandas data frame of the computational traces
"""
parents = reverse_graph(y)
labs = get_labels(y)
visited = []
data = {}
data['Trace'] = []
data['Operation']=[]
data['Value']= []
data['Derivative']=[]
nodes = [y]
while len(nodes)>0:
node = nodes.pop()
if node not in visited:
if node.constant:
visited.append(node)
else:
visited.append(node)
data['Trace'].append(labs[node])
data['Value'].append(node.val)
data['Derivative'].append(node.der)
if node in parents:
if len(parents[node]) == 1:
link = parents[node][0][1]+'('+labs[parents[node][0][0]]+')'
else:
link = parents[node][0][1]+'(' +labs[parents[node][0][0]]+ ' , ' + labs[parents[node][1][0]] + ')'
neighbors = parents[node]
for neighbor in neighbors:
nodes.append(neighbor[0])
else:
link = 'input'
data['Operation'].append(link)
result = pd.DataFrame.from_dict(data)
result['Number'] = [int(name[1:]) for name in result['Trace']]
result2 = result.sort_values('Number')
resultorder = result2[['Trace', 'Operation', 'Value', 'Derivative']]
return resultorder
def gen_table_rev(y):
""" Function to generate tables for the ADnum.
INPUTS
======
y : ADnum
OUTPUTS
=======
A pandas data frame of the computational traces
"""
parents = reverse_graph(y)
labs = get_labels(y)
#labs = get_labels_rev(y)
visited = []
data = {}
data['Trace'] = []
data['Operation']=[]
#data['Value']= []
data['Derivative']=[]
data['Weight'] = []
nodes = [y]
while len(nodes)>0:
node = nodes.pop()
if node not in visited:
if node.constant:
visited.append(node)
else:
visited.append(node)
data['Trace'].append(labs[node])
#data['Value'].append(node.val)
data['Derivative'].append(node.der)
data['Weight'].append(node.rder)
if node in parents:
if len(parents[node]) == 1:
link = parents[node][0][1]+'('+labs[parents[node][0][0]]+')'
else:
link = parents[node][0][1]+'(' +labs[parents[node][0][0]]+ ' , ' + labs[parents[node][1][0]] + ')'
neighbors = parents[node]
for neighbor in neighbors:
nodes.append(neighbor[0])
else:
link = 'input'
data['Operation'].append(link)
result = pd.DataFrame.from_dict(data)
result['Number'] = [int(name[1:]) for name in result['Trace']]
result2 = result.sort_values('Number')
resultorder = result2[['Trace', 'Operation', 'Weight']]
return resultorder
def plot_ADnum(f, ins=1, xmin = -10, xmax = 10):
'''Function to plot f and its derivative for single variable input
INPUTS
======
x : ADnum
xmin : starting value of input
xmax : ending value of input
OUTPUTS
=======
A plot of x evaluated from xmin to xmax and its derivative
'''
if ins == 1:
vals = np.linspace(xmin, xmax, 100)
evals = [f(ADnum(value, der=1)).val for value in vals]
ders = [f(ADnum(value, der=1)).der for value in vals]
fig = plt.figure()
plt.plot(vals, evals, label = 'f', linewidth = 2)
plt.plot(vals, ders, label = 'df/dx', linewidth = 2)
plt.legend(fontsize = 20)
plt.xlabel('x', fontsize = 20)
plt.ylabel('f', fontsize = 20)
plt.xticks(fontsize = 12)
plt.yticks(fontsize = 12)
return fig
if ins == 2:
fig = plt.figure()
ax = fig.gca(projection = '3d')
vals = np.linspace(xmin, xmax, 100)
z = f(vals, vals)
ax.plot_trisurf(vals, vals, z, antialiased = True)
return fig
if ins > 2:
fig = plt.figure()
return fig | ADgui-lindseysbrown | /ADgui_lindseysbrown-0.0.1-py3-none-any.whl/ADgui/ADgraph_GUI.py | ADgraph_GUI.py |
import numpy as np
#import AD20
#from AD20.ADnum import ADnum
#from AD20 import ADmath as ADmath
from ADnum_rev_timed_vis import ADnum
import ADmath_rev as ADmath
import ADgraph_GUI as ADgraph
import math
import tkinter as tk
from tkinter import messagebox
import matplotlib.pyplot as plt
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk
from matplotlib.figure import Figure
from pandastable import Table
if __name__ == '__main__':
preset = tk.Tk()
preset.title('Number of inputs.')
preset.geometry("300x200")
num_ins = tk.IntVar()
tk.Label(preset, text = "Number of function inputs:", height = 3, width = 30).grid(row = 0, column=0)
tk.Entry(preset, textvariable = num_ins, width = 30).grid(row=1, column =0)
def close_window():
if type(num_ins.get())!= int:
messagebox.showinfo('Error', 'Please enter a positive integer number of inputs.')
elif num_ins.get()>5:
messagebox.showinfo('Error', 'More than 5 inputs is not supported in the GUI environment. Please either use the AD20 package, or experiment with a function of fewer variables.')
elif num_ins.get()>0:
preset.destroy()
else:
messagebox.showinfo('Error', 'Please enter a positive integer number of inputs.')
tk.Button(preset, text = 'Next', height = 3, width = 30, command = close_window).grid(row = 2, column = 0)
preset.mainloop()
global master_ins
master_ins = num_ins.get()
preset2 = tk.Tk()
preset2.title('Number of outputs.')
preset2.geometry("300x200")
num_outs = tk.IntVar()
tk.Label(preset2, text = "Number of output functions:", height = 3, width = 30).grid(row = 0, column=0)
tk.Entry(preset2, textvariable = num_outs, width = 30).grid(row=1, column =0)
def close_window():
if type(num_outs.get())!= int:
messagebox.showinfo('Error', 'Please enter a positive integer number of inputs.')
elif num_outs.get()>3:
messagebox.showinfo('Error', 'More than 3 functions is not supported in the GUI environment. Please either use the AD20 package, or experiment with fewer outputs.')
elif num_outs.get()>0:
preset2.destroy()
else:
messagebox.showinfo('Error', 'Please enter a positive integer number of inputs.')
tk.Button(preset2, text = 'Next', height = 3, width = 30, command = close_window).grid(row = 2, column = 0)
preset2.mainloop()
global master_outs
master_outs = num_outs.get()
master = tk.Tk()
master.title("AutoDiff Calculator")
#master.attributes("-fullscreen", True)
master.state('zoomed')
#master.bind('<Escape>', end_fullscreen(master))
def instruction():
text = "This calculator generates functions of multiple variables. Use the buttons below to define your function(s)." +\
"The magenta buttons in the last row are the input variables. Use standard calculator syntax to define your function." +\
"When you are done defining your function, press \'Calculate\' to get the result. Press \'Clear Function\' to start over for a particular function."
#text = "This calculator performs basic calculations and generates functions of a single variable. \n \n" +\
#"Use the buttons below to define your function. The magenta X is the input variable. \n \n" +\
#"All of the special functions should use standard calculator syntax. For example, to define the sine of X:" +\
#"press \'sin\', press \'(\', and then press \')\'. To define x squared:" +\
#"press \'X\', press \'pow\', press \'(\', press '2', and press press \')\'. \n \n" +\
#"When you are done defining your function, press \'Calculate\' to get the result. Press \'Clear All\' to start over."
messagebox.showinfo("Welcome to AutoDiff Education Mode",text)
def versionInfo():
messagebox.showinfo("Welcome to AutoDiff Education Mode","AD20 version 1.0")
##master button
button_instruction = tk.Button(master, text = "Instructions",fg = "Orange",command = instruction)
button_instruction.place(relx=0, rely= 0,anchor=tk.NW)
#button_version = tk.Button(master, text = "Check Version", command = versionInfo)
#button_version.pack(side = 'top')
#===End of master configuration
#===Tool box for global variables
global function_expression, function_output, func_content
function_expression = ["", "", ""]
function_output = [None]*3
function_output[0] = lambda x: 0
function_output[1] = lambda x: 0
function_output[2] = lambda x: 0
func_content = [tk.StringVar(), tk.StringVar(), tk.StringVar()]
function_expression2 = ""
function_output2 = lambda x: 0
func_content2 = tk.StringVar()
function_expression3 = ""
function_output3 = lambda x: 0
func_content3 = tk.StringVar()
#====End of global variables set===
#===Block for Graph top level window===
def graph_master(master):
# print(function_output)
# print(function_expression)
# for i in range(master_outs):
# print(function_output[i](1))
# f = lambda x: eval(function_expression[i])
# print(f(5))
#if local_func:
# for i in range(master_outs):
# print(local_func[i](1))
def show_plot():
plot_window = tk.Toplevel(graph_window)
plot_window.title("Function and derivative plot")
#plot_window.geometry("600x600")
plot_window.state('zoomed')
fig = ADgraph.plot_ADnum(function_output, ins = master_ins)
canvas = FigureCanvasTkAgg(fig, master=plot_window) # A tk.DrawingArea.
canvas.draw()
canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)
toolbar = NavigationToolbar2Tk(canvas, plot_window)
toolbar.update()
canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)
def graph_instructions():
text = "Use this window to visualize how automatic differentiation is performed on your function.\n \n" +\
"First, type numbers into the boxes to set values for the input variables. Press \'Set Input Values\' to calculate the value and" +\
" derivative of your function at this point. \n \n" +\
"After setting the input values, you can visualize the computational graph and evaluation table associated with each function in forward mode. Press the button corresponding to the function you want to analyze under each heading." +\
"You can also dynamically visualize the steps in the calculation of a derivative in Reverse Mode or view the entire reverse graph."
messagebox.showinfo('Visualize Function Computations', text, parent=graph_window)
graph_master = tk.Toplevel(master)
#graph_window.geometry("400x675")
graph_master.state('zoomed')
graph_master.title("Graph Generator")
graph_window = tk.Frame(graph_master, height = 32, width = 32)
graph_window.place(relx=.5, rely=.5, anchor=tk.CENTER)
#global function_output
instruction_graph = tk.Button(graph_master, text = 'Instructions',fg = "Orange",command = graph_instructions).place(relx=0, rely=0, anchor = tk.NW)
#if master_ins < 3:
# show_plot = tk.Button(graph_window, text = "Visualize function", height = 3, width = 20, command = show_plot).grid(row = 4, column = 0, columnspan = 2)
value_x = tk.DoubleVar()
value_y = tk.DoubleVar()
value_z = tk.DoubleVar()
value_m = tk.DoubleVar()
value_n = tk.DoubleVar()
value_k = tk.DoubleVar()
def draw_graph():
try:
fig = ADgraph.draw_graph2(out_num[0], G[0], edge_labs[0], pos[0], labs[0])
except NameError:
#plot_graph.destroy()
messagebox.showinfo("Error", "Please use \'Set Input Values\' to define your input values.", parent=graph_window)
except AttributeError:
messagebox.showinfo('Error', 'Function is a constant.', parent=graph_window)
plt.close()
def draw_graph1():
try:
fig = ADgraph.draw_graph2(out_num[1], G[1], edge_labs[1], pos[1], labs[1])
except NameError:
#plot_graph.destroy()
messagebox.showinfo("Error", "Please use \'Set Input Values\' to define your input values.", parent=graph_window)
except AttributeError:
messagebox.showinfo('Error', 'Function is a constant.', parent=graph_window)
plt.close()
def draw_graph2():
try:
fig = ADgraph.draw_graph2(out_num[2], G[2], edge_labs[2], pos[2], labs[2])
except NameError:
#plot_graph.destroy()
messagebox.showinfo("Error", "Please use \'Set Input Values\' to define your input values.", parent=graph_window)
except AttributeError:
messagebox.showinfo('Error', 'Function is a constant.', parent=graph_window)
plt.close()
def draw_table():
try:
plot_graph2 = tk.Toplevel(graph_window)
plot_graph2.title("Forward Computational Table")
plot_graph2.geometry("600x600")
# fig = ADgraph.gen_table(function_output)
f = tk.Frame(plot_graph2)
f.pack(side=tk.TOP,fill=tk.BOTH,expand=1)
df = ADgraph.gen_table(out_num[0])
#df = ADgraph.gen_table(function_output(ADnum(value_x.get(),ins=6,ind=0),ADnum(value_y.get(),ins=6,ind=1),ADnum(value_z.get(),ins=6,ind=2),ADnum(value_m.get(),ins=6,ind=3),ADnum(value_n.get(),ins=6,ind=4),ADnum(value_k.get(),ins=6,ind=5)))
table = pt = Table(f, dataframe=df, showtoolbar=True, showstatusbar=True)
pt.show()
except NameError:
plot_graph2.destroy()
messagebox.showinfo("Error", "Please use \'Set Input Values\' to define your input values.", parent=graph_window)
except AttributeError:
messagebox.showinfo('Error', 'Function is a constant.', parent=graph_window)
def draw_table1():
try:
plot_graph2 = tk.Toplevel(graph_window)
plot_graph2.title("Forward Computational Table")
plot_graph2.geometry("600x600")
# fig = ADgraph.gen_table(function_output)
f = tk.Frame(plot_graph2)
f.pack(side=tk.TOP,fill=tk.BOTH,expand=1)
df = ADgraph.gen_table(out_num[1])
#df = ADgraph.gen_table(function_output(ADnum(value_x.get(),ins=6,ind=0),ADnum(value_y.get(),ins=6,ind=1),ADnum(value_z.get(),ins=6,ind=2),ADnum(value_m.get(),ins=6,ind=3),ADnum(value_n.get(),ins=6,ind=4),ADnum(value_k.get(),ins=6,ind=5)))
table = pt = Table(f, dataframe=df, showtoolbar=True, showstatusbar=True)
pt.show()
except NameError:
plot_graph2.destroy()
messagebox.showinfo("Error", "Please use \'Set Input Values\' to define your input values.", parent=graph_window)
except AttributeError:
messagebox.showinfo('Error', 'Function is a constant.', parent=graph_window)
plt.close()
def draw_table2():
try:
plot_graph2 = tk.Toplevel(graph_window)
plot_graph2.title("Forward Computational Table")
plot_graph2.geometry("600x600")
# fig = ADgraph.gen_table(function_output)
f = tk.Frame(plot_graph2)
f.pack(side=tk.TOP,fill=tk.BOTH,expand=1)
df = ADgraph.gen_table(out_num[2])
#df = ADgraph.gen_table(function_output(ADnum(value_x.get(),ins=6,ind=0),ADnum(value_y.get(),ins=6,ind=1),ADnum(value_z.get(),ins=6,ind=2),ADnum(value_m.get(),ins=6,ind=3),ADnum(value_n.get(),ins=6,ind=4),ADnum(value_k.get(),ins=6,ind=5)))
table = pt = Table(f, dataframe=df, showtoolbar=True, showstatusbar=True)
pt.show()
except NameError:
plot_graph2.destroy()
messagebox.showinfo("Error", "Please use \'Set Input Values\' to define your input values.", parent=graph_window)
except AttributeError:
messagebox.showinfo('Error', 'Function is a constant.', parent=graph_window)
plt.close()
def vis_rev_x():
try:
fig = ADgraph.draw_graph_rev_dynamic(out_num[0], x[0].revder(out_num[0])[1], G[0], edge_labs[0], pos[0], labs[0], x[0].revder(out_num[0])[0])
except NameError:
messagebox.showinfo("Error", "Please use \'Set Input Values\' to define your input values.", parent=graph_window)
except AttributeError:
messagebox.showinfo('Error', 'Function is a constant.', parent=graph_window)
plt.close()
def vis_rev_y():
try:
fig = ADgraph.draw_graph_rev_dynamic(out_num[0], y[0].revder(out_num[0])[1], G[0], edge_labs[0], pos[0], labs[0], y[0].revder(out_num[0])[0])
except NameError:
#plot_graph.destroy()
messagebox.showinfo("Error", "Please use \'Set Input Values\' to define your input values.", parent=graph_window)
except AttributeError:
messagebox.showinfo('Error', 'Function is a constant.', parent=graph_window)
plt.close()
def vis_rev_z():
try:
fig = ADgraph.draw_graph_rev_dynamic(out_num[0], z[0].revder(out_num[0])[1], G[0], edge_labs[0], pos[0], labs[0], z[0].revder(out_num[0])[0])
except NameError:
#plot_graph.destroy()
messagebox.showinfo("Error", "Please use \'Set Input Values\' to define your input values.", parent = graph_window)
except AttributeError:
messagebox.showinfo('Error', 'Function is a constant.', parent=graph_window)
plt.close()
def vis_rev_u():
try:
fig = ADgraph.draw_graph_rev_dynamic(out_num[0], u[0].revder(out_num[0])[1], G[0], edge_labs[0], pos[0], labs[0], u[0].revder(out_num[0])[0])
except NameError:
#plot_graph.destroy()
messagebox.showinfo("Error", "Please use \'Set Input Values\' to define your input values.", parent=graph_window)
except AttributeError:
messagebox.showinfo('Error', 'Function is a constant.', parent=graph_window)
plt.close()
def vis_rev_v():
try:
fig = ADgraph.draw_graph_rev_dynamic(out_num[0], v[0].revder(out_num[0])[1], G[0], edge_labs[0], pos[0], labs[0], v[0].revder(out_num[0])[0])
except NameError:
#plot_graph.destroy()
messagebox.showinfo("Error", "Please use \'Set Input Values\' to define your input values.", parent=graph_window)
plt.close()
except AttributeError:
messagebox.showinfo('Error', 'Function is a constant.', parent=graph_window)
plt.close()
def vis_rev_x1():
try:
fig = ADgraph.draw_graph_rev_dynamic(out_num[1], x[1].revder(out_num[1])[1], G[1], edge_labs[1], pos[1], labs[1], x[1].revder(out_num[1])[0])
except NameError:
messagebox.showinfo("Error", "Please use \'Set Input Values\' to define your input values.", parent=graph_window)
except AttributeError:
messagebox.showinfo('Error', 'Function is a constant.', parent=graph_window)
plt.close()
def vis_rev_y1():
try:
fig = ADgraph.draw_graph_rev_dynamic(out_num[1], y[1].revder(out_num[1])[1], G[1], edge_labs[1], pos[1], labs[1], y[1].revder(out_num[1])[0])
except NameError:
#plot_graph.destroy()
messagebox.showinfo("Error", "Please use \'Set Input Values\' to define your input values.", parent=graph_window)
except AttributeError:
messagebox.showinfo('Error', 'Function is a constant.', parent=graph_window)
plt.close()
def vis_rev_z1():
try:
fig = ADgraph.draw_graph_rev_dynamic(out_num[1], z[1].revder(out_num[1])[1], G[1], edge_labs[1], pos[1], labs[1], z[1].revder(out_num[1])[0])
except NameError:
#plot_graph.destroy()
messagebox.showinfo("Error", "Please use \'Set Input Values\' to define your input values.", parent = graph_window)
except AttributeError:
messagebox.showinfo('Error', 'Function is a constant.', parent=graph_window)
plt.close()
def vis_rev_u1():
try:
fig = ADgraph.draw_graph_rev_dynamic(out_num[1], u[1].revder(out_num[1])[1], G[1], edge_labs[1], pos[1], labs[1], u[1].revder(out_num[1])[0])
except NameError:
#plot_graph.destroy()
messagebox.showinfo("Error", "Please use \'Set Input Values\' to define your input values.", parent=graph_window)
plt.close()
except AttributeError:
messagebox.showinfo('Error', 'Function is a constant.', parent=graph_window)
plt.close()
def vis_rev_v1():
try:
fig = ADgraph.draw_graph_rev_dynamic(out_num[1], v[1].revder(out_num[1])[1], G[1], edge_labs[1], pos[1], labs[1], v[1].revder(out_num[1])[0])
except NameError:
#plot_graph.destroy()
messagebox.showinfo("Error", "Please use \'Set Input Values\' to define your input values.", parent=graph_window)
plt.close()
except AttributeError:
messagebox.showinfo('Error', 'Function is a constant.', parent=graph_window)
plt.close()
def vis_rev_x2():
try:
fig = ADgraph.draw_graph_rev_dynamic(out_num[2], x[2].revder(out_num[2])[1], G[2], edge_labs[2], pos[2], labs[2], x[2].revder(out_num[2])[0])
except NameError:
messagebox.showinfo("Error", "Please use \'Set Input Values\' to define your input values.", parent=graph_window)
except AttributeError:
messagebox.showinfo('Error', 'Function is a constant.', parent=graph_window)
plt.close()
def vis_rev_y2():
try:
fig = ADgraph.draw_graph_rev_dynamic(out_num[2], y[2].revder(out_num[2])[1], G[2], edge_labs[2], pos[2], labs[2], y[2].revder(out_num[2])[0])
except NameError:
#plot_graph.destroy()
messagebox.showinfo("Error", "Please use \'Set Input Values\' to define your input values.", parent=graph_window)
except AttributeError:
messagebox.showinfo('Error', 'Function is a constant.', parent=graph_window)
plt.close()
def vis_rev_z2():
try:
fig = ADgraph.draw_graph_rev_dynamic(out_num[2], z[2].revder(out_num[2])[1], G[2], edge_labs[2], pos[2], labs[2], z[2].revder(out_num[2])[0])
except NameError:
#plot_graph.destroy()
messagebox.showinfo("Error", "Please use \'Set Input Values\' to define your input values.", parent = graph_window)
except AttributeError:
messagebox.showinfo('Error', 'Function is a constant.', parent=graph_window)
plt.close()
def vis_rev_u2():
try:
fig = ADgraph.draw_graph_rev_dynamic(out_num[2], u[2].revder(out_num[2])[1], G[2], edge_labs[2], pos[2], labs[2], u[2].revder(out_num[2])[0])
except NameError:
#plot_graph.destroy()
messagebox.showinfo("Error", "Please use \'Set Input Values\' to define your input values.", parent=graph_window)
except AttributeError:
messagebox.showinfo('Error', 'Function is a constant.', parent=graph_window)
plt.close()
def vis_rev_v2():
try:
fig = ADgraph.draw_graph_rev_dynamic(out_num[2], v[2].revder(out_num[2])[1], G[2], edge_labs[2], pos[2], labs[2], v[2].revder(out_num[2])[0])
except NameError:
#plot_graph.destroy()
messagebox.showinfo("Error", "Please use \'Set Input Values\' to define your input values.", parent=graph_window)
except AttributeError:
messagebox.showinfo('Error', 'Function is a constant.', parent=graph_window)
plt.close()
def rev_draw_graph():
try:
fig = ADgraph.draw_graph_rev2(out_num[0], G[0], edge_labs[0], pos[0], labs[0])
except NameError:
#plot_graph.destroy()
messagebox.showinfo("Error", "Please use \'Set Input Values\' to define your input values.", parent = graph_window)
except AttributeError:
messagebox.showinfo('Error', 'Function is a constant.', parent = graph_window)
plt.close()
def rev_draw_graph1():
try:
fig = ADgraph.draw_graph_rev2(out_num[1], G[1], edge_labs[1], pos[1], labs[1])
except NameError:
messagebox.showinfo("Error", "Please use \'Set Input Values\' to define your input values.", parent = graph_window)
except AttributeError:
messagebox.showinfo('Error', 'Function is a constant.', parent=graph_window)
plt.close()
def rev_draw_graph2():
try:
fig = ADgraph.draw_graph_rev2(out_num[2], G[2], edge_labs[2], pos[2], labs[2])
except NameError:
messagebox.showinfo("Error", "Please use \'Set Input Values\' to define your input values.", parent = graph_window)
except AttributeError:
messagebox.showinfo('Error', 'Function is a constant.', parent=graph_window)
plt.close()
def rev_draw_table():
try:
plot_graph2 = tk.Toplevel(graph_window)
plot_graph2.title("Reverse Computational Table")
plot_graph2.geometry("600x600")
# fig = ADgraph.gen_table(function_output)
f = tk.Frame(plot_graph2)
f.pack(side=tk.TOP,fill=tk.BOTH,expand=1)
df = ADgraph.gen_table_rev(out_num[0])
#df = ADgraph.gen_table(function_output(ADnum(value_x.get(),ins=6,ind=0),ADnum(value_y.get(),ins=6,ind=1),ADnum(value_z.get(),ins=6,ind=2),ADnum(value_m.get(),ins=6,ind=3),ADnum(value_n.get(),ins=6,ind=4),ADnum(value_k.get(),ins=6,ind=5)))
table = pt = Table(f, dataframe=df, showtoolbar=True, showstatusbar=True)
pt.show()
except NameError:
plot_graph2.destroy()
messagebox.showinfo("Error", "Please use \'Set Input Values\' to define your input values.", parent = graph_window)
except AttributeError:
messagebox.showinfo('Error', 'Function is a constant.', parent=graph_window)
if func_content[0].get()[0] != 'f':
func_content[0].set('f1 = '+func_content[0].get())
if master_outs > 1:
if func_content[1].get()[0] != 'f':
func_content[1].set('f2 = '+func_content[1].get())
if master_outs >2:
if func_content[2].get()[0]!= 'f':
func_content[2].set('f3 = '+func_content[2].get())
#orientation labels
if master_outs == 1:
func_label = tk.Label(graph_window, textvariable = func_content[0], font = ('wasy10', 24)).grid(row=0, column=2, columnspan=2)
if master_outs == 2:
func1_label = tk.Label(graph_window, textvariable = func_content[0], font = ('wasy10', 24)).grid(row=0, column = 0, columnspan = 2)
func2_label = tk.Label(graph_window, textvariable = func_content[1], font = ('wasy10', 24)).grid(row=0, column = 2, columnspan = 3)
if master_outs == 3:
func1_label = tk.Label(graph_window, textvariable = func_content[0], font = ('wasy10', 24)).grid(row=0, column = 0, columnspan = 2)
func2_label = tk.Label(graph_window, textvariable = func_content[1], font = ('wasy10', 24)).grid(row=0, column = 2, columnspan = 3)
func3_label = tk.Label(graph_window, textvariable = func_content[2], font = ('wasy10', 24)).grid(row=0, column = 5, columnspan=5)
setup_label = tk.Label(graph_window, text = 'EVALUATE AT', height = 3, width = 30, font= ('wasy10', 20)).grid(row=1, column = 0, columnspan = 2)
forward_label = tk.Label(graph_window, text = 'FORWARD MODE', height=3, width = 30, font = ('wasy10', 20)).grid(row = 1, column = 2, columnspan = 3)
reverse_label = tk.Label(graph_window, text = 'REVERSE MODE', height = 3, width = 30, font = ('wasy10', 20)).grid(row=1, column=5, columnspan = 5)
value_prompt_x = tk.Label(graph_window, text = " Evaluate at x = ",height = 3, width = 15, font = ('wasy10', 12)).grid(row = 2, column = 0)
enter_value_x = tk.Entry(graph_window, textvariable = value_x, width = 10).grid(row = 2, column = 1)
if master_ins > 1:
value_prompt_y = tk.Label(graph_window, text = " Evaluate at y = ",height = 3, width = 15, font = ('wasy10',12)).grid(row = 3, column = 0)
enter_value_y = tk.Entry(graph_window, textvariable = value_y, width = 10).grid(row = 3, column = 1)
if master_ins >2:
value_prompt_z = tk.Label(graph_window, text = " Evaluate at z = ",height = 3, width = 15, font = ('wasy10', 12)).grid(row = 4, column = 0)
enter_value_z = tk.Entry(graph_window, textvariable = value_z, width = 10).grid(row = 4, column = 1)
if master_ins > 3:
value_prompt_m = tk.Label(graph_window, text = " Evaluate at u = ",height = 3, width = 15, font = ('wasy10', 12)).grid(row = 5, column = 0)
enter_value_m= tk.Entry(graph_window, textvariable = value_m, width = 10).grid(row = 5, column = 1)
if master_ins > 4:
value_prompt_n= tk.Label(graph_window, text = " Evaluate at v = ",height = 3, width = 15, font = ('wasy10', 12)).grid(row = 6, column = 0)
enter_value_n= tk.Entry(graph_window, textvariable = value_n, width = 10).grid(row = 6, column = 1)
if master_ins>5:
value_prompt_k= tk.Label(graph_window, text = " Evaluate at w = ",height = 3, width = 15).grid(row = 7, column = 0)
enter_value_k= tk.Entry(graph_window, textvariable = value_k, width = 10).grid(row = 7, column = 1)
def display():
if not (type(value_x.get())==float and type(value_y.get())==float and type(value_z.get())==float
and type(value_m.get())==float and type(value_n.get())==float and type(value_k.get())==float):
messagebox.showerror('Error', 'Please enter a numeric value for the inputs.')
global x
x = [ADnum(value_x.get(), ins = master_ins, ind = 0)]*master_outs
if master_ins>1:
global y
y = [ADnum(value_y.get(), ins = master_ins, ind =1)]*master_outs
if master_ins>2:
global z
z = [ADnum(value_z.get(), ins = master_ins, ind = 2)]*master_outs
if master_ins >3:
global u
u = [ADnum(value_m.get(), ins = master_ins, ind=3)]*master_outs
if master_ins > 4:
global v
v = [ADnum(value_n.get(), ins = master_ins, ind = 4)]*master_outs
if master_ins>5:
global w
w = ADnum(value_k.get(), ins = master_ins, ind = 5)
global out_num
out_num = [None]*master_outs
for i in range(master_outs):
if master_ins == 1:
out_num[i] = function_output[i](x[i])
if master_ins == 2:
out_num[i] = function_output[i](x[i], y[i])
if master_ins == 3:
out_num[i] = function_output[i](x[i], y[i], z[i])
if master_ins == 4:
out_num[i] = function_output[i](x[i], y[i], z[i], u[i])
if master_ins == 5:
out_num[i] = function_output[i](x[i], y[i], z[i], u[i], v[i])
if master_ins == 6:
out_num[i] = function_output[i](x, y, z, u, v, w)
#disp_val = str([np.round(f.val, 2) for f in out_num])
#disp_der = str([np.round(f.der, 2) for f in out_num])
disp_val = '['
disp_der = '['
for out in out_num:
try:
disp_val += str(np.round(out.val,2))
disp_der += str(np.round(out.der, 2))
except AttributeError:
disp_val += str(np.round(out, 2))
disp_der += str([0]*master_ins)
disp_val += ',\n'
disp_der += ',\n'
disp_val = disp_val[:-2]+']'
disp_der = disp_der[:-2]+']'
show_value = tk.Label(graph_window, text = disp_val, height = 3, width = 15, font = ('wasy10', 12), fg = 'green').grid(row = 3, column = 2, columnspan=3)
show_derivatice = tk.Label(graph_window, text = disp_der, height = 3, width = 25, font = ('wasy10', 12), fg='green').grid(row = 5, column =2, columnspan = 3)
inputs_list = ['x', 'y', 'z', 'u', 'v']
vis_funcs = [[vis_rev_x, vis_rev_x1, vis_rev_x2], [vis_rev_y, vis_rev_y1, vis_rev_y2], [vis_rev_z, vis_rev_z1, vis_rev_z2], [vis_rev_u, vis_rev_u1, vis_rev_u2], [vis_rev_v, vis_rev_v1, vis_rev_v2]]
for i in range(master_ins):
for j in range(master_outs):
tk.Button(graph_window, text = "df" + str(j+1)+"/d" + inputs_list[i], height=3, width=5, command=vis_funcs[i][j]).grid(row=3+j, column=5+i, columnspan =1)
global G, edge_labs, pos, labs
G = [None]*master_outs
edge_labs = [None]*master_outs
pos = [None]*master_outs
labs = [None]*master_outs
for i, out in enumerate(out_num):
try:
G[i], edge_labs[i], pos[i], labs[i] = ADgraph.get_graph_setup(out)
except AttributeError:
pass
result_val = tk.Label(graph_window, text = "Function Value:",height = 3, width = 15, font = ('wasy10', 12)).grid(row =2, column =2, columnspan=3)
result_der = tk.Label(graph_window, text= "Gradient: ",height = 3, width = 15, font = ('wasy10', 12)).grid(row = 4, column = 2, columnspan=3)
#result_ops = tk.Label(graph_window, text="Forward Ops:", height =3, width=15, font = ('wasy10', 12)).grid(row= 6, column = 2, columnspan=3)
vis_label = tk.Label(graph_window, text = 'Visualize Reverse Calculation:', height = 3, width = 25, font = ('wasy10', 12)).grid(row=2, column=5, columnspan=5)
enter_button = tk.Button(graph_window, text = "Set Input Values", height = 3, width = 20, command = display).grid(row = master_ins + 2, column = 0, columnspan = 2)
#vis_rev_prompt = tk.Button(graph_window, text = "Visualize Reverse Calc", height = 3, width = 20, command = vis_rev_x).grid(row=2, column = 5, columnspan=1)
eval_label = tk.Label(graph_window, text = 'Computational Graph:', height =3, width = 30, font = ('wasy10', 12)).grid(row=8, column=2, columnspan=3)
eval_prompt = tk.Button(graph_window, text = "f1",height = 3, width = 5, command = draw_graph).grid(row = 9, column = 2,columnspan = 1)
table_label = tk.Label(graph_window, text = 'Evaluation Table:', height =3, width =30, font = ('wasy10', 12)).grid(row=10, column=2, columnspan=3)
table_prompt = tk.Button(graph_window, text = "f1",height = 3, width = 5, command = draw_table).grid(row = 11, column = 2,columnspan = 1)
rev_eval_label = tk.Label(graph_window, text = "Reverse Graph:", height = 3, width = 30, font = ('wasy10', 12)).grid(row=8, column =5, columnspan=5)
#rev_table_label = tk.Label(graph_window, text = 'Reverse Table:', height = 3, width = 30, font = ('wasy10', 12)).grid(row=10, column=5, columnspan=5)
rev_eval_prompt = tk.Button(graph_window, text = "f1",height = 3, width = 5, command = rev_draw_graph).grid(row = 9, column = 6,columnspan = 1)
#rev_table_prompt = tk.Button(graph_window, text = "f1",height = 3, width = 5, command = rev_draw_table).grid(row = 11, column = 5,columnspan = 1)
if master_outs>1:
eval_prompt1 = tk.Button(graph_window, text = "f2",height = 3, width = 5, command = draw_graph1).grid(row = 9, column = 3,columnspan = 1)
table_prompt1 = tk.Button(graph_window, text = "f2",height = 3, width = 5, command = draw_table1).grid(row = 11, column = 3,columnspan = 1)
rev_eval_prompt1 = tk.Button(graph_window, text = "f2",height = 3, width = 5, command = rev_draw_graph1).grid(row = 9, column = 7,columnspan = 1)
if master_outs>2:
eval_prompt2 = tk.Button(graph_window, text = "f3",height = 3, width = 5, command = draw_graph2).grid(row = 9, column = 4,columnspan = 1)
table_prompt2 = tk.Button(graph_window, text = "f3",height = 3, width = 5, command = draw_table2).grid(row = 11, column = 4,columnspan = 1)
rev_eval_prompt2 = tk.Button(graph_window, text = "f3",height = 3, width = 5, command = rev_draw_graph2).grid(row = 9, column = 8,columnspan = 1)
#===Block for Error message====
def error_window():
error_window = tk.Toplevel(master)
error_window.title("Error!")
error_message = tk.Label(error_window, text = "Invalid expression! Please start over and try again!")
error_message.pack(side = 'top')
#=====Function for master configuration's buttons======
def var_number_x():
edit_func("x")
global function_expression
function_expression[editing] +='x'
def add():
edit_func("+")
global function_expression
function_expression[editing] +='+'
def sub():
edit_func("-")
global function_expression
function_expression[editing] +='-'
def mul():
edit_func("*")
global function_expression
function_expression[editing] +='*'
def div():
edit_func("/")
global function_expression
function_expression[editing] +='/'
def num_0():
edit_func("0")
global function_expression
function_expression[editing] +='0'
def num_1():
edit_func("1")
global function_expression
function_expression[editing] +='1'
def num_2():
edit_func("2")
global function_expression
function_expression[editing] +='2'
def num_3():
edit_func("3")
global function_expression
function_expression[editing] += '3'
def num_4():
edit_func("4")
global function_expression
function_expression[editing] += '4'
def num_5():
edit_func("5")
global function_expression
function_expression[editing] += '5'
def num_6():
edit_func("6")
global function_expression
function_expression[editing] += '6'
def num_7():
edit_func("7")
global function_expression
function_expression[editing] += '7'
def num_8():
edit_func("8")
global function_expression
function_expression[editing] += '8'
def num_9():
edit_func("9")
global function_expression
function_expression[editing] += '9'
def num_dot():
edit_func(".")
global function_expression
function_expression[editing] += '.'
#===Add more functions to the added buttons===
def sin():
edit_func("sin(")
global function_expression
function_expression[editing] += 'ADmath.sin('
def cos():
edit_func("cos(")
global function_expression
function_expression[editing] += 'ADmath.cos('
def tan():
edit_func("tan(")
global function_expression
function_expression[editing] += 'ADmath.tan('
def exp():
edit_func("exp(")
global function_expression
function_expression[editing] += 'ADmath.exp('
def log():
edit_func("log(")
global function_expression
function_expression[editing] += 'ADmath.log('
def pow_to():
edit_func("pow(")
global function_expression
function_expression[editing] += '**('
def sqrt():
edit_func("sqrt(")
global function_expression
function_expression[editing] += 'ADmath.sqrt('
def right_par():
edit_func("(")
global function_expression
function_expression[editing] += '('
def left_par():
edit_func(")")
global function_expression
function_expression[editing] += ")"
#====End of Function of master buttons
#===2019 Add Functions to Extra Buttons===
def var_number_y():
edit_func("y")
global function_expression
function_expression[editing] +='y'
def var_number_z():
edit_func("z")
global function_expression
function_expression[editing] +='z'
def var_number_m():
edit_func("u")
global function_expression
function_expression[editing] +='u'
def var_number_n():
edit_func("v")
global function_expression
function_expression[editing] +='v'
def var_number_k():
edit_func("w")
global function_expression
function_expression[editing] +='w'
#===2019 Add Functions to Extra Buttons Ends===
def back_space():
global function_expression
function_expression[editing] = backstep(function_expression[editing])
back_func()
def backstep(text):
if len(text) == 0:
func_content[editing].set("")
return ""
if text[-1]=='(' and text[-2] in ['n', 't', 'p', 's', 'g', '*']:
if text[-2] == 't':
return text[:-12]
elif (text[-2] == '*' and text[-3]=='*'):
return text[:-3]
else:
return text[:-12]
else:
return text[:-1]
def clear_all():
func_content[editing].set("")
function_expression[editing] = " "
function_output[editing] = lambda x :0
def get_func(function_expression, i):
if master_ins == 1:
def f(x):
return eval(function_expression[i])
if master_ins == 2:
def f(x,y):
return eval(function_expression[i])
if master_ins == 3:
def f(x,y,z):
return eval(function_expression[i])
if master_ins == 4:
def f(x, y, z, u):
return eval(function_expression[i])
if master_ins == 5:
def f(x,y,z,u,v):
return eval(function_expression[i])
return f
def confirm():
try:
for i in range(master_outs):
function_output[i] = get_func(function_expression, i)
if master_ins ==1:
function_output[i](1)
if master_ins == 2:
function_output[i](1,1)
if master_ins ==3:
function_output[i](1,1,1)
if master_ins ==4:
function_output[i](1,1,1,1)
if master_ins ==5:
function_output[i](1,1,1,1,1)
graph_master(master)
except AttributeError:
if master_ins ==1:
messagebox.showinfo("Constant result:","The value is {}".format(function_output(1)))
if master_ins ==2:
messagebox.showinfo("Constant result:","The value is {}".format(function_output(1,1)))
if master_ins ==3:
messagebox.showinfo("Constant result:","The value is {}".format(function_output(1,1,1)))
if master_ins ==4:
messagebox.showinfo("Constant result:","The value is {}".format(function_output(1,1,1,1)))
if master_ins ==5:
messagebox.showinfo("Constant result:","The value is {}".format(function_output(1,1,1,1,1)))
except NameError:
messagebox.showerror("Error", "Syntax error in your expression. Please edit the expression, and try again.")
except SyntaxError:
messagebox.showerror("Error", "Syntax error in your expression. Please edit the expression, and try again.")
def edit_func(text):
content = func_content[editing].get()+text
func_content[editing].set(content)
def back_func():
content = func_content[editing].get()
if len(content) == 0:
content = content
elif content[-1]=='(' and content[-2] in ['t', 'n', 'w', 's', 'p', 'g']:
if content[-2] == 't':
content = content[:-5]
elif content[-2] == 'w' and content[-3]!='o':
content = content[:-1]
else:
content = content[:-4]
else:
content = content[:-1]
func_content[editing].set(content)
##Set up button
cal_frame = tk.Frame(master,height=32, width=32)
cal_frame.place(relx=0.5, rely=0.5, anchor=tk.CENTER)
#===2019 Add Variable Buttons===
if master_ins>1:
button_y = tk.Button(cal_frame, text = "y", font=('wasy10', 20),fg = "magenta",height=2, width=5,command = var_number_y).grid(row = 8, column = 1)
if master_ins>2:
button_z = tk.Button(cal_frame, text = "z", font=('wasy10', 20),fg = "magenta",height=2, width=5,command = var_number_z).grid(row = 8, column = 2)
if master_ins>3:
button_m = tk.Button(cal_frame, text = "u", font=('wasy10', 20),fg = "magenta",height=2, width=5,command = var_number_m).grid(row = 8, column = 3)
if master_ins>4:
button_n = tk.Button(cal_frame, text = "v", font=('wasy10', 20),fg = "magenta",height=2, width=5,command = var_number_n).grid(row = 8, column = 4)
if master_ins>5:
button_k = tk.Button(cal_frame, text = "w", font=('wasy10', 20),fg = "magenta",height=2, width=5,command = var_number_k).grid(row = 8, column = 5)
#===2019 Add Variable Buttons End===
#===Add Buttons=====
button_sin = tk.Button(cal_frame, text = "sin", font=('wasy10', 20),height=2, width=5,command = sin).grid(row = 3, column = 0)
button_cos = tk.Button(cal_frame, text = "cos", font=('wasy10', 20),height=2, width=5,command = cos).grid(row = 3, column = 1)
button_tan = tk.Button(cal_frame, text = "tan", font=('wasy10', 20),height=2, width=5,command = tan).grid(row = 3, column = 2)
button_exp = tk.Button(cal_frame, text = "exp", font=('wasy10', 20),height=2, width=5,command = exp).grid(row = 3, column = 3)
button_log = tk.Button(cal_frame, text = "log", font=('wasy10', 20),height=2, width=5,command = log).grid(row = 3, column = 4)
button_pow = tk.Button(cal_frame, text = "pow", font=('wasy10', 20),height=2, width=5,command = pow_to).grid(row = 4, column = 4)
button_sqrt = tk.Button(cal_frame, text = "sqrt", font=('wasy10', 20),height=2, width=5,command = sqrt).grid(row = 5, column =4)
button_rightPar = tk.Button(cal_frame, text = "(", font=('wasy10', 20),height=2, width=5,command = right_par).grid(row = 6, column =4)
button_leftPar = tk.Button(cal_frame, text = ")", font=('wasy10', 20),height=2, width=5,command = left_par).grid(row = 7, column =4)
#=====Add Buttons End===
if master_ins==1:
show_function = tk.Label(cal_frame, text = "f1(x) = ").grid(row = 0, column = 0)
if master_outs >1:
show_function2 = tk.Label(cal_frame, text = "f2(x)= ").grid(row=0, column=9)
if master_outs >2:
show_function3 = tk.Label(cal_frame, text = "f3(x)= ").grid(row=0, column=18)
if master_ins==2:
show_function = tk.Label(cal_frame, text = "f1(x, y) = ").grid(row = 0, column = 0)
if master_outs >1:
show_function2 = tk.Label(cal_frame, text = "f2(x, y)= ").grid(row=0, column=9)
if master_outs >2:
show_function3 = tk.Label(cal_frame, text = "f3(x, y)= ").grid(row=0, column=18)
if master_ins==3:
show_function = tk.Label(cal_frame, text = "f1(x, y, z) = ").grid(row = 0, column = 0)
if master_outs >1:
show_function2 = tk.Label(cal_frame, text = "f2(x, y, z)= ").grid(row=0, column=9)
if master_outs >2:
show_function3 = tk.Label(cal_frame, text = "f3(x, y, z)= ").grid(row=0, column=18)
if master_ins==4:
show_function = tk.Label(cal_frame, text = "f1(x, y, z, u) = ").grid(row = 0, column = 0)
if master_outs >1:
show_function2 = tk.Label(cal_frame, text = "f2(x, y, z, u)= ").grid(row=0, column=9)
if master_outs >2:
show_function3 = tk.Label(cal_frame, text = "f3(x, y, z, u)= ").grid(row=0, column=18)
if master_ins==5:
show_function = tk.Label(cal_frame, text = "f1(x, y, z, u, v) = ").grid(row = 0, column = 0)
if master_outs >1:
show_function2 = tk.Label(cal_frame, text = "f2(x, y, z, u, v)= ").grid(row=0, column=9)
if master_outs >2:
show_function3 = tk.Label(cal_frame, text = "f3(x, y, z, u, v)= ").grid(row=0, column=18)
global editing
editing = 0
def edit_select1():
global editing
editing = 0
def edit_select2():
global editing
editing = 1
def edit_select3():
global editing
editing = 2
if master_outs>1:
tk.Button(cal_frame, text = "Edit f1", command=edit_select1).grid(row=1, column=0)
tk.Button(cal_frame, text = "Edit f2", command=edit_select2).grid(row=1, column=9)
if master_outs>2:
tk.Button(cal_frame, text = "Edit f3", command = edit_select3).grid(row=1, column=18)
button_backspace = tk.Button(cal_frame, text= u'\u2B05', font=('wasy10', 20), height=2, width=5,command= back_space).grid(row=7, column = 2)
button_x = tk.Button(cal_frame, text = "x", font=('wasy10', 20),fg = "magenta",height=2, width=5,command = var_number_x).grid(row = 8, column =0)
button_add = tk.Button(cal_frame, text = '+', font=('wasy10', 20),height=2, width=5,command = add).grid(row = 4, column = 3) # can add command
button_sub = tk.Button(cal_frame, text = "-",font=('wasy10', 20),height=2, width=5,command = sub).grid(row = 5, column = 3)
button_mul = tk.Button(cal_frame, text = "*",font=('wasy10', 20),height=2, width=5,command = mul).grid(row = 6, column = 3)
button_div = tk.Button(cal_frame, text = "/",font=('wasy10', 20),height=2, width=5,command = div).grid(row = 7, column = 3)
button_0 = tk.Button(cal_frame, text = "0",font=('wasy10', 20),height=2, width=5,command = num_0).grid(row = 7, column = 0)
button_1 = tk.Button(cal_frame, text = "1",font=('wasy10', 20),height=2, width=5,command = num_1).grid(row = 6, column = 0)
button_2 = tk.Button(cal_frame, text = "2",font=('wasy10', 20),height=2, width=5,command = num_2).grid(row = 6, column = 1)
button_3 = tk.Button(cal_frame, text = "3",font=('wasy10', 20),height=2, width=5,command = num_3).grid(row = 6, column = 2)
button_4 = tk.Button(cal_frame, text = "4",font=('wasy10', 20),height=2, width=5,command = num_4).grid(row = 5, column = 0)
button_5 = tk.Button(cal_frame, text = "5",font=('wasy10', 20),height=2, width=5,command = num_5).grid(row = 5, column = 1)
button_6 = tk.Button(cal_frame, text = "6",font=('wasy10', 20),height=2, width=5,command = num_6).grid(row = 5, column = 2)
button_7 = tk.Button(cal_frame, text = "7",font=('wasy10', 20),height=2, width=5,command = num_7).grid(row = 4, column = 0)
button_8 = tk.Button(cal_frame, text = "8",font=('wasy10', 20),height=2, width=5,command = num_8).grid(row = 4, column = 1)
button_9 = tk.Button(cal_frame, text = "9",font=('wasy10', 20),height=2, width=5,command = num_9).grid(row = 4, column = 2)
button_dot = tk.Button(cal_frame, text = ".",font=('wasy10', 20),height=2, width=5,command = num_dot).grid(row = 7, column = 1)
button_confirm = tk.Button(cal_frame, text = "Calculate",font=('wasy10', 20),height=2, width=22,command = confirm).grid(row = 9, columnspan =8)
button_clearAll = tk.Button(cal_frame, text = "Clear Function",font=('wasy10', 20),height=2, width=22,command = clear_all).grid(row = 10,columnspan =8)
show_func = tk.Label(cal_frame, textvariable = func_content[0],height=2, width=30,bg = 'Seashell').grid(row = 0,column = 1,columnspan =7)
if master_outs>1:
show_func2 = tk.Label(cal_frame, textvariable = func_content[1],height=2, width=30,bg = 'Seashell').grid(row = 0,column = 10,columnspan =7)
if master_outs>2:
show_func3 = tk.Label(cal_frame, textvariable = func_content[2],height=2, width=30,bg = 'Seashell').grid(row = 0,column = 19,columnspan =7)
#=====End of configuration========
# if __name__=='main':
master.resizable(width=True, height=True)
master.mainloop() | ADgui-lindseysbrown | /ADgui_lindseysbrown-0.0.1-py3-none-any.whl/ADgui/AD20_GUI_Multiout.py | AD20_GUI_Multiout.py |
import numpy as np
from ADnum_rev_timed_vis import ADnum
#TRIGONOMETRIC FUNCTIONS
def sin(X):
try:
y = ADnum(np.sin(X.val), der = np.cos(X.val)*X.der, ops = (1-X.counted)*X.ops+2, rops =1, tfops = X.tfops+2+X.ins, trops = X.trops+2+2*X.ins)
X.counted = 1
y.graph = X.graph
if X not in y.graph:
y.graph[X] = []
y.graph[X].append((y, 'sin', np.cos(X.val)))
return y
except AttributeError:
return np.sin(X)
def cos(X):
try:
y = ADnum(np.cos(X.val), der = -np.sin(X.val)*X.der, ops = (1-X.counted)*X.ops+3, rops=2, tfops = X.tfops+2+X.ins, trops = X.trops+2+2*X.ins)
X.counted = 1
y.graph = X.graph
if X not in y.graph:
y.graph[X] = []
y.graph[X].append((y, 'cos', -np.sin(X.val)))
return y
except AttributeError:
return np.cos(X)
def tan(X):
try:
y = ADnum(np.tan(X.val), der = (1/np.cos(X.val)**2)*X.der, ops = (1-X.counted)*X.ops+4, rops=3, tfops = X.tfops+2+X.ins, trops = X.trops+2+2*X.ins)
X.counted = 1
y.graph = X.graph
if X not in y.graph:
y.graph[X] = []
y.graph[X].append((y, 'tan', (1/np.cos(X.val))**2))
return y
except AttributeError:
return np.tan(X)
def csc(X):
try:
y = ADnum(1/np.sin(X.val), der = (-1/np.tan(X.val))*(1/np.sin(X.val))*X.der, ops = (1-X.counted)*X.ops+5, rops=4, tfops = X.tfops+2+X.ins, trops = X.trops+2+2*X.ins)
X.counted = 1
y.graph = X.graph
if X not in y.graph:
y.graph[X] = []
y.graph[X].append((y, 'csc',(-1/np.tan(X.val))*(1/np.sin(X.val))))
return y
except:
return 1/np.sin(X)
def sec(X):
try:
y = ADnum(1/np.cos(X.val), der = np.tan(X.val)/np.cos(X.val)*X.der, ops = (1-X.counted)*X.ops+4, rops=3, tfops = X.tfops+2+X.ins, trops = X.trops+2+2*X.ins)
X.counted = 1
y.graph = X.graph
if X not in y.graph:
y.graph[X] = []
y.graph[X].append((y, 'sec', np.tan(X.val)/np.cos(X.val)))
return y
except AttributeError:
return 1/np.cos(X)
def cot(X):
try:
y = ADnum(1/np.tan(X.val), der = -1/(np.sin(X.val)**2)*X.der, ops = (1-X.counted)*X.ops+4, rops=3, tfops = X.tfops+2+X.ins, trops = X.trops+2+2*X.ins)
X.counted = 1
y.graph = X.graph
if X not in y.graph:
y.graph[X] = []
y.graph[X].append((y, 'cot', -1/(np.sin(X.val)**2)))
return y
except AttributeError:
return 1/np.tan(X)
#INVERSE TRIGONOMETRIC FUNCTIONS
def arcsin(X):
try:
y = ADnum(np.arcsin(X.val), der = 1/np.sqrt(1-X.val**2)*X.der, ops = (1-X.counted)*X.ops+5, rops=4, tfops = X.tfops+2+X.ins, trops = X.trops+2+2*X.ins)
X.counted = 1
y.graph = X.graph
if X not in y.graph:
y.graph[X] = []
y.graph[X].append((y, 'arcsin', 1/np.sqrt(1-X.val**2)))
return y
except AttributeError:
return np.arcsin(X)
def arccos(X):
try:
y = ADnum(np.arccos(X.val), der = -1/np.sqrt(1-X.val**2)*X.der, ops = (1-X.counted)*X.ops+5, rops=4, tfops = X.tfops+2+X.ins, trops = X.trops+2+2*X.ins)
X.counted = 1
y.graph = X.graph
if X not in y.graph:
y.graph[X] = []
y.graph[X].append((y, 'arccos', -1/np.sqrt(1-X.val**2)))
return y
except AttributeError:
return np.arccos(X)
def arctan(X):
try:
y = ADnum(np.arctan(X.val), der = 1/(1+X.val**2)*X.der, ops = (1-X.counted)*X.ops+4, rops=3, tfops = X.tfops+2+X.ins, trops = X.trops+2+2*X.ins)
X.counted = 1
y.graph = X.graph
if X not in y.graph:
y.graph[X] = []
y.graph[X].append((y, 'arctan', 1/(1+X.val**2)))
return y
except AttributeError:
return np.arctan(X)
#HYPERBOLIC TRIG FUNCTIONS
def sinh(X):
try:
y = ADnum(np.sinh(X.val), der = np.cosh(X.val)*X.der, ops = (1-X.counted)*X.ops+2, rops=1, tfops = X.tfops+2+X.ins, trops = X.trops+2+2*X.ins)
X.counted = 1
y.graph = X.graph
if X not in y.graph:
y.graph[X] = []
y.graph[X].append((y, 'sinh', np.cosh(X.val)))
return y
except AttributeError:
return np.sinh(X)
def cosh(X):
try:
y = ADnum(np.cosh(X.val), der = np.sinh(X.val)*X.der, ops=(1-X.counted)*X.ops+2, rops=1, tfops = X.tfops+2+X.ins, trops = X.trops+2+2*X.ins)
X.counted = 1
y.graph = X.graph
if X not in y.graph:
y.graph[X] = []
y.graph[X].append((y, 'cosh', np.sinh(X.val)))
return y
except AttributeError:
return np.cosh(X)
def tanh(X):
try:
y = ADnum(np.tanh(X.val), der = 1/(np.cosh(X.val)**2)*X.der, ops = (1-X.counted)*X.ops+4, rops=3, tfops = X.tfops+2+X.ins, trops = X.trops+2+2*X.ins)
X.counted = 1
y.graph = X.graph
if X not in y.graph:
y.graph[X] = []
y.graph[X].append((y, 'tanh', 1/(np.cosh(X.val)**2)))
return y
except AttributeError:
return np.tanh(X)
#NATURAL EXPONENTIAL AND NATURAL LOGARITHM
def exp(X):
try:
y = ADnum(np.exp(X.val), der = np.exp(X.val)*X.der, ops = (1-X.counted)*X.ops+2, rops=1, tfops = X.tfops+2+X.ins, trops = X.trops+2+2*X.ins)
X.counted = 1
y.graph = X.graph
if X not in y.graph:
y.graph[X] = []
y.graph[X].append((y, 'exp', np.exp(X.val)))
return y
except AttributeError:
return np.exp(X)
def log(X):
try:
y = ADnum(np.log(X.val), der = 1/X.val*X.der, ops = (1-X.counted)*X.ops+2, rops=1, tfops = X.tfops+2+X.ins, trops = X.trops+2+2*X.ins)
X.counted = 1
y.graph = X.graph
if X not in y.graph:
y.graph[X] = []
y.graph[X].append((y, 'log', 1/X.val))
return y
except AttributeError:
return np.log(X)
def logistic(X):
return 1/(1+exp(-1*X))
def sqrt(X):
try:
y = ADnum(np.sqrt(X.val), der = X.der/(2*np.sqrt(X.val)), ops=(1-X.counted)*X.ops+3, rops=3, tfops = X.tfops+2+X.ins, trops = X.trops+2+2*X.ins)
X.counted = 1
y.graph = X.graph
if X not in y.graph:
y.graph[X] = []
y.graph[X].append((y, 'sqrt', 1/(2*np.sqrt(X.val))))
return y
except AttributeError:
return np.sqrt(X) | ADgui-lindseysbrown | /ADgui_lindseysbrown-0.0.1-py3-none-any.whl/ADgui/ADmath_rev.py | ADmath_rev.py |
import numpy as np
from timeit import default_timer as timer
class ADnum:
""" Class to create ADnum objects on which to perform differentiation.
ATTRIBUTES
==========
val : scalar for scalar valued quantities or numpy array for vector valued functions, the value of the ADnum object for a set input value
der : scalar for sclar functions of a single variable or numpy array for functions of multiple variables the derivative
graph : dictionary containing the edges of the computational graph
constant : 0 or 1 indicating whether the ADnum object is constant
METHODS
=======
This class overloads the methods for basic arithmetic operations.
EXAMPLES
========
# >>> x = ADnum(2, der = 1)
# >>> f = 2*x+3
# >>> print(f.val)
# 7.0
# >>> print(f.der)
# 2.0
"""
def __init__(self, value, **kwargs):
try:
scalarinput = (isinstance(value, int) or isinstance(value, float))
value = np.array(value)
value = value.astype(float)
if 'der' not in kwargs:
try:
ins = kwargs['ins']
ind = kwargs['ind']
if scalarinput:
der = np.zeros(ins)
der[ind] = 1.0
else:
if ins>1:
der = np.zeros((ins, len(value)))
der[ind, :] = 1.0 #np.ones(len(value))
else:
der = np.ones(len(value))
except:
raise KeyError('Must provide ins and ind if der not provided.')
else:
der = kwargs['der']
der = np.array(der)
der = der.astype(float)
if 'ins' in kwargs:
ins = kwargs['ins']
if len(der) != ins:
raise ValueError('Shape of derivative does not match number of inputs.')
except:
raise ValueError('Value and derivative of ADnum object must be numeric.')
self.val = value
self.der = der
self.ins = len(self.der)
self.rder = None
if 'graph' not in kwargs:
self.graph = {}
else:
self.graph = kwargs['graph']
if 'constant' not in kwargs:
self.constant = 0
else:
self.constant = kwargs['constant']
if 'ops' not in kwargs:
self.ops = 0
else:
self.ops = kwargs['ops']
if 'rops' not in kwargs:
self.rops = 0
else:
self.rops = kwargs['rops']
if 'tfops' not in kwargs:
self.tfops = 0
else:
self.tfops = kwargs['tfops']
if 'trops' not in kwargs:
self.trops = 0
else:
self.trops = kwargs['trops']
if 'ftime' not in kwargs:
self.ftime = 0
else:
self.ftime = kwargs['ftime']
if 'rtime' not in kwargs:
self.rtime = 0
else:
self.rtime = kwargs['rtime']
self.counted = 0
def revder(self, f):
f.rder = 1
edge_visits = []
#tolops = 0
if self == f:
return 1, []
if True: #self.rder is None:
try:
children = f.graph[self]
calc = 0
for child in children:
calc = calc + child[2]*child[0].revder(f)[0]#[0]
edge_visits = edge_visits +[[(child[0], self)]]+child[0].revder(f)[1]
#tolops = tolops + child[0].revder(f)[1]+child[0].rops+2*self.ins
self.rder = calc
except KeyError:
self.rder = 0
return self.rder, edge_visits #, tolops
def __neg__(self):
fstart = timer()
a=-self.der
fend = timer()
y = ADnum(-self.val, der = -self.der, ops = (1-self.counted)*self.ops+1, rops = 0, tfops = self.tfops+3*self.ins, trops = self.trops+4*self.ins, ftime = self.ftime+fend-fstart, rtime = self.rtime)
self.counted = 1
y.graph = self.graph
rstart = timer()
if self not in y.graph:
y.graph[self] = []
y.graph[self].append((y, 'neg', -1))
rend = timer()
y.rtime = y.rtime+rend-rstart
return y
def __mul__(self,other):
try:
graph = merge_dicts(self.graph, other.graph)
if self.constant or other.constant:
opcount = (1-self.counted)*self.ops*(1-self.constant)+(1-other.counted)*other.ops*(1-other.constant)+1
else:
opcount = (1-self.counted)*self.ops*(1-self.constant)+(1-other.counted)*other.ops*(1-other.constant)+3
fstart = timer()
a = self.val*other.der + self.der*other.val
fend = timer()
y = ADnum(self.val*other.val, der = self.val*other.der+self.der*other.val, ops = opcount, rops=0, tfops = 3*self.ins+self.tfops+other.tfops, trops = 4*self.ins+self.trops+other.trops, ftime = self.ftime+other.ftime+fend-fstart, rtime = self.rtime+other.rtime)
self.counted = 1
other.counted = 1
y.graph = graph
rstart = timer()
if self not in y.graph:
y.graph[self] = []
y.graph[self].append((y, 'multiply', other.val))
if other not in y.graph:
y.graph[other] = []
y.graph[other].append((y, 'multiply', self.val))
rend = timer()
y.rtime = y.rtime + rend-rstart
return y
except AttributeError:
other = ADnum(other*np.ones(np.shape(self.val)), der = np.zeros(np.shape(self.der)), constant = 1)
return self*other
def __rmul__(self,other):
return self.__mul__(other)
def __add__(self,other):
try:
graph = merge_dicts(self.graph, other.graph)
opcount = (1-self.counted)*self.ops*(1-self.constant)+(1-other.counted)*other.ops*(1-other.constant)+1
fstart = timer()
a=self.der+other.der
fend = timer()
y = ADnum(self.val+other.val, der = self.der+other.der, ops = opcount, rops=0, tfops = self.tfops+other.tfops+self.ins, trops = self.trops + other.trops+2*self.ins, ftime = self.ftime+other.ftime+fend-fstart, rtime = self.rtime+other.rtime)
self.counted = 1
other.counted = 1
y.graph = graph
rstart = timer()
if self not in y.graph:
y.graph[self] = []
y.graph[self].append((y, 'add', 1))
if other not in y.graph:
y.graph[other] = []
y.graph[other].append((y, 'add', 1))
rend = timer()
y.rtime = y.rtime + rend-rstart
return y
except AttributeError:
other = ADnum(other*np.ones(np.shape(self.val)), der = np.zeros(np.shape(self.der)), constant = 1)
return self + other
def __radd__(self,other):
return self.__add__(other)
def __sub__(self,other):
try:
graph = merge_dicts(self.graph, other.graph)
opcount = (1-self.counted)*self.ops*(1-self.constant)+(1-other.counted)*other.ops*(1-other.constant)+1
fstart = timer()
a=self.der-other.der
fend = timer()
y = ADnum(self.val-other.val,der = self.der-other.der, ops = opcount, rops=0, tfops = self.tfops+other.tfops+self.ins, trops = self.trops+other.trops+2*self.ins, ftime = self.ftime+other.ftime+fend-fstart, rtime = self.rtime+other.rtime)
self.counted = 1
other.counted = 1
y.graph = graph
rstart = timer()
if self not in y.graph:
y.graph[self] = []
y.graph[self].append((y, 'subtract', 1))
if other not in y.graph:
y.graph[other] = []
y.graph[other].append((y, 'subtract', -1))
rend = timer()
y.rtime = y.rtime + rend-rstart
return y
except AttributeError:
other = ADnum(other*np.ones(np.shape(self.val)), der = np.zeros(np.shape(self.der)), constant = 1)
return self-other
def __rsub__(self, other):
try:
return ADnum(other.val-self.val, der = other.der-self.der)
except AttributeError:
other = ADnum(other*np.ones(np.shape(self.val)), der = np.zeros(np.shape(self.der)), constant = 1)
return other-self
def __truediv__(self, other):
try:
graph = merge_dicts(self.graph, other.graph)
opcount = (1-self.counted)*self.ops*(1-self.constant)+(1-other.counted)*other.ops*(1-other.constant)
if self.constant and not other.constant:
opcount = opcount + 3
elif other.constant and not self.constant:
opcount = opcount + 1
else:
opcount = opcount+5
fstart = timer()
a= (other.val*self.der-self.val*other.der)/(other.val**2)
fend = timer()
y = ADnum(self.val/other.val, der = (other.val*self.der-self.val*other.der)/(other.val**2), ops = opcount, rops = 1, tfops = self.tfops+other.tfops+5*self.ins, trops = self.trops+other.trops+4*self.ins, ftime = self.ftime+other.ftime+fend-fstart, rtime = self.rtime+other.rtime)
self.counted = 1
other.counted = 1
y.graph = graph
rstart = timer()
if self not in y.graph:
y.graph[self] = []
y.graph[self].append((y, 'divide', 1/other.val))
if other not in y.graph:
y.graph[other] = []
y.graph[other].append((y, 'divide', -1*self.val/(other.val**2)))
rend = timer()
y.rtime = y.rtime + rend - rstart
return y
except AttributeError:
other = ADnum(other*np.ones(np.shape(self.val)), der = np.zeros(np.shape(self.der)), constant = 1)
return self/other
def __rtruediv__(self, other):
try:
opcount = (1-self.counted)*self.ops*(1-self.constant)+(1-other.counted)*other.ops*(1-other.constant)
if self.constant and not other.constant:
opcount = opcount + 3
elif other.constant and not self.constant:
opcount = opcount + 1
else:
opcount = opcount+5
fstart = timer()
a=(self.val*other.der - other.val*self.der)/(self.val**2)
fend = timer()
return ADnum(other.val/self.val, der = (self.val*other.der-other.val*self.der)/(self.val**2), ops = opcount, tfops = self.tfops+other.tfops+5*self.ins, trops = self.trops+other.trops+4*self.ins, ftime = self.ftime+other.ftime+fend-fstart, rtime = self.rtime+other.rtime)
except AttributeError:
other = ADnum(other*np.ones(np.shape(self.val)), der = np.zeros(np.shape(self.der)), constant = 1)
return other/self
def __pow__(self, other, modulo=None):
try:
graph = merge_dicts(self.graph, other.graph)
opcount = (1-self.counted)*self.ops*(1-self.constant)+(1-other.counted)*other.ops*(1-other.constant)
if self.constant and not other.constant:
opcount = opcount + 4
elif other.constant and not self.constant:
opcount = opcount + 4
else:
opcount = opcount + 10
if self.val == 0:
fstart = timer()
a =other.val*(self.val**(other.val-1))*self.der+self.val**other.val
fend = timer()
y = ADnum(self.val**other.val, der = other.val*(self.val**(other.val-1))*self.der+(self.val**other.val), ops = opcount, rops=3, tfops = self.tfops+other.tfops+2+self.ins, trops = self.trops+other.trops+2+2*self.ins, ftime = self.ftime+other.ftime+fend-fstart, rtime = self.rtime+other.rtime)
self.counted = 1
other.counted =1
else:
fstart = timer()
a=other.val*(self.val**(other.val-1))*self.der+(self.val**other.val)*np.log(np.abs(self.val))*other.der
fend = timer()
y = ADnum(self.val**other.val, der = other.val*(self.val**(other.val-1))*self.der+(self.val**other.val)*np.log(np.abs(self.val))*other.der, ops = opcount, tfops=self.tfops+other.tfops+2+self.ins, trops = self.trops+other.trops+2+2*self.ins, ftime = self.ftime+other.ftime+fend-fstart, rtime = self.rtime+other.rtime)
self.counted = 1
other.counted = 1
y.graph = graph
rstart = timer()
if self not in y.graph:
y.graph[self] = []
y.graph[self].append((y, 'pow', other.val*self.val**(other.val-1)))
if other not in y.graph:
y.graph[other] = []
y.graph[other].append((y, 'pow', self.val**other.val*np.log(np.abs(self.val))))
rend = timer()
y.rtime = y.rtime + rend-rstart
return y
except AttributeError:
other = ADnum(other*np.ones(np.shape(self.val)), der = np.zeros(np.shape(self.der)), constant = 1)
return self**other
def __rpow__(self, other):
try:
opcount = (1-self.counted)*self.ops*(1-self.constant)+(1-other.counted)*other.ops*(1-other.constant)
if self.constant and not other.constant:
opcount = opcount + 4
elif other.constant and not self.constant:
opcount = opcount + 4
else:
opcount = opcount + 10
fstart = timer()
a=self.val*(other.val**(self.val-1))*other.der+(other.val**self.val)*np.log(np.abs(other.val))*self.der
fend = timer()
return ADnum(other.val**self.val, der = self.val*(other.val**(self.val-1))*other.der+(other.val**self.val)*np.log(np.abs(other.val))*self.der, ops = (1-self.counted)*self.ops+other.ops+10, tfops=self.tfops+other.tfops+2+self.ins, trops=self.trops+other.trops+2+2*self.ins, ftime = self.ftime+other.ftime+fend-fstart, rtime = self.rtime+other.rtime)
except AttributeError:
other = ADnum(other*np.ones(np.shape(self.val)), der = np.zeros(np.shape(self.der)), constant = 1)
return other**self
def merge_dicts(d1, d2):
''' Function to merge two dictionaries.
INPUTS
======
d1 : dictionary
d2 : dictionary
OUTPUTS
=======
dnew : new dictionary that is a combination of d1 and d2
'''
dnew = d1.copy()
for key in d2:
if key in dnew:
for item in d2[key]:
if item not in dnew[key]:
dnew[key] = dnew[key]+[item]
else:
dnew[key] = d2[key]
return dnew | ADgui-lindseysbrown | /ADgui_lindseysbrown-0.0.1-py3-none-any.whl/ADgui/ADnum_rev_timed_vis.py | ADnum_rev_timed_vis.py |
==============================================
ADiPy, Automatic Differentiation for Python
==============================================
ADiPy is a fast, pure-python automatic differentiation (AD) library. This
package provides the following functionality:
- Arbitrary order univariate differentiation
- First-order multivariate differentiation
- Univariate Taylor polynomial function generator
- Jacobian matrix generator
- Compatible linear algebra routines
Installation
------------
To install ``adipy``, simply do one of the following in a terminal window
(administrative priviledges may be required):
- Download the tarball, unzip, then run ``python setup.py install`` in the
unzipped directory.
- Run ``easy_install [--upgrade] adipy``
- Run ``pip install [--upgrade] adipy``
Where to Start
--------------
To start, we use the simple import::
from adipy import *
This imports the necessary constructors and elementary functions (sin, exp,
sqrt, etc.) as well as ``np`` which is the root NumPy module.
Now, we can construct AD objects using either ``ad(...)`` or ``adn(...)``. For
multivariate operations, it is recommended to construct them all at once using
the ``ad(...)`` function, but this is not required. The syntax is only a little
more complicated if they are initialized separately.
Univariate Examples
-------------------
Here are some examples of univariate operations::
# A single, first-order differentiable object
x = ad(1.5)
y = x**2
print y
# output is: ad(2.25, array([3.0]))
# What is dy/dx?
print y.d(1)
# output is: 3.0
z = x*sin(x**2)
print z
# output is: ad(1.1671097953318819, array([-2.0487081053644052]))
# What is dz/dx?
print z.d(1)
# output is: -2.0487081053644052
# A single, fourth-order differentiable object
x = adn(1.5, 4)
y = x**2
print y
# output is: ad(2.25, array([ 3., 2., 0., -0.]))
# What is the second derivative of y with respect to x?
print y.d(2)
# output is: 2.0
z = x*sin(x**2)
print z
# output is:
# ad(1.1671097953318819, array([ -2.04870811, -16.15755076, -20.34396265, 194.11618384]))
# What is the fourth derivative of z with respect to x?
print z.d(4)
# output is: 194.116183837
As can be seen in the examples, when an AD object is printed out, you see two
sets of numbers. The first is the nominal value, or the zero-th derivative.
The next set of values are the 1st through the Nth order derivatives, evaluated
at the nominal value.
Multivariate Examples
---------------------
For multivariate sessions, things look a little bit different and can only
handle first derivatives (for the time being), but behave similarly::
x = ad(np.array([-1, 2.1, 0.25]))
y = x**2
print y
# output is:
# ad(array([ 1. , 4.41 , 0.0625]), array([[[-2. , 0. , 0. ],
# [-0. , 4.2, 0. ],
# [-0. , 0. , 0.5]]]))
This essentially just performed the ``**2`` operator on each object individually,
so we can see the derivatives for each array index and how they are not
dependent on each other. Using standard indexing operations, we can access the
individual elements of an AD multivariate object::
print x[0]
# output is:
# ad(-1, array([ 1., 0., 0.]))
What if we want to use more than one AD object in calculations? Let's see what
happens::
z = x[0]*sin(x[1]*x[2])
print z
# output is:
# ad(-0.50121300467379792, array([[ 0.501213 , -0.21633099, -1.81718028]]))
The result here shows both the nominal value for z, but also the partial
derivatives for each of the x values. Thus, dz/dx[0] = 0.501213, etc.
Jacobian
--------
If we have multiple outputs, like::
y = [0]*2
y[0] = x[0]*x[1]/x[2]
y[1] = -x[2]**x[0]
we can use the ``jacobian`` function to summarize the partial derivatives for
each index of y::
print jacobian(y)
# output is: [[ 8.4 -4. 33.6 ]
# [ 5.54517744 0. 16. ]]
Just as before, we can extract the first partial derivatives::
print z.d(1)
# output is: [ 0.501213 -0.21633099 -1.81718028]
For the object y, we can't yet use the ``d(...)`` function yet, because it is
technically a list at this point. However, we can convert it to a single,
multivariate AD object using the ``unite`` function, then we'll have access
to the ``d(...)`` function. The ``jacobian`` function's result is the same in
both cases::
y = unite(y)
print y.d(1)
# output is: [[ 8.4 -4. 33.6 ]
# [ 5.54517744 0. 16. ]]
print jacobian(y)
# output is: [[ 8.4 -4. 33.6 ]
# [ 5.54517744 0. 16. ]]
Like was mentioned before, multivariate sessions can initialize individual
independent AD objects, though not quite as conveniently as before, using
the following syntax::
x = ad(-1, np.array([1, 0, 0]))
y = ad(2.1, np.array([0, 1, 0]))
z = ad(0.25, np.array([0, 0, 1]))
This allows all the partial derivatives to be tracked, noted at the respective
unitary index at initialization. Conversely to singular construction, we can
break-out the individual elements, if desired::
x, y, z = ad([np.array([-1, 2.1, 0.25]))
And the results are the same.
Univariate Taylor Series Approximation
--------------------------------------
For univariate functions, we can use the ``taylorfunc`` function to generate
an callable function that allows approximation to some specifiable order::
x = adn(1.5, 6) # a sixth-order AD object
z = x*sin(x**2)
fz = taylorfunc(z, at=x.nom)
The "at" keyword designates the point that the series is expanded about, which
will likely always be at the nominal value of the original independent AD
object (e.g., ``x.nom``). Now, we can use ``fz`` whenever we need to
approximate ``x*sin(x**2)``, but know that the farther it is evaluated from
``x.nom``, the more error there will be in the approximation.
If Matplotlib is installed, we can see the difference in the order of the
approximating Taylor polynomials::
import matplotlib.pyplot as plt
xAD = [adn(1.5, i) for i in xrange(1, 7)] # a list of ith-order AD objects
def z(x):
return x*sin(x**2)
x = np.linspace(0.75, 2.25)
plt.plot(x, z(x), label='Actual Function')
for i in xrange(len(xAD)):
fz = taylorfunc(z(xAD[i]), at=xAD[i].nom)
plt.plot(x, fz(x), label='Order %d Taylor'%(i+1))
plt.legend(loc=0)
plt.show()
.. image:: https://raw.github.com/tisimst/adipy/master/taylorfunc_example.png
Notice that at x=1.5, all the approximations are perfectly accurate (as we
would expect) and error increases as the approximation moves farther from that
point, but less so with the increase in the order of the approximation.
Linear Algebra
--------------
Several linear algebra routines are available that are AD-compatible:
- Decompositions
- Cholesky (``chol``)
- QR (``qr``)
- LU (``lu``)
- Linear System solvers
- General solver, with support for multiple outputs (``solve``)
- Least squares solver (``lstsq``)
- Matrix inverse (``inv``)
- Matrix Norms
- Frobenius norm, or 2-norm (``norm``)
These require a separate import ``import adipy.linalg``, then they can be
using something like ``adipy.linalg.solve(...)``.
See the source code for relevant documentation and examples. If you are
familiar with NumPy's versions, you will find these easy to use.
Support
-------
Please contact the `author`_ with any questions, comments, or good examples of
how you've used ``adipy``!
License
-------
This package is distributed under the BSD License. It is free for public and
commercial use and may be copied royalty free, provided the author is given
credit.
.. _author: mailto:[email protected]
| ADiPy | /ADiPy-0.6.3.tar.gz/ADiPy-0.6.3/README.rst | README.rst |
from __future__ import division
import numpy as np
from math import factorial
import copy
class ad(object):
def __init__(self, nom=None, der=None):
"""
AD class constructor. A single nominal or a 1-d array of n nominal
values supported. If no value given for "der", then the default
is "1" for a single nominal or an n-by-n identity matrix for a
nominal array. Constants can be used by setting "der=0".
"""
if nom is None:
self.val = []
self.der = []
elif der is None: # for constant with derivative 0
self.val = nom
try:
nom[0]
except:
self.der = 1
else:
self.der = np.eye(len(nom))
else:
self.val = nom
self.der = der
def copy(self):
return copy.copy(self)
@property
def nom(self):
"""
Get the 0th-order value (i.e., the nominal value
"""
return taylornominal(self)
def d(self, n):
"""
Get the nth derivative
Example
-------
A 3rd-order differentiable object at 1.5::
>>> x = adn(1.5, 3)
>>> y = x**2
>>> y.d(1)
3.0
>>> y.d(2)
2.0
>>> y.d(3)
0.0
"""
assert n>=0, 'Derivative order must not be negative.'
if n==0:
return self.nom
else:
derivs = taylorderivatives(self)
assert len(derivs)>=n, \
"You didn't track derivatives of order = {}".format(n)
return derivs[n - 1]
def __getitem__(self, idx):
return ad(self.val[idx], self.der[idx])
def __len__(self):
return len(self.val)
def __repr__(self):
return 'ad' + repr((self.val, self.der))
def __str__(self):
return 'ad' + repr((self.nom, taylorderivatives(self)))
def double(self):
"""
Convert ad object to vector of doubles
"""
return np.hstack((self.val*1.0, self.der*1.0))
def __add__(self, other):
if isinstance(other, ad):
return ad(self.val + other.val, self.der + other.der)
else:
return ad(self.val + other, self.der)
def __radd__(self, other):
return self + other
def __neg__(self):
return -1*self
def __sub__(self, other):
return self + (-1)*other
def __rsub__(self, other):
return (-1)*self + other
def __mul__(self, other):
if isinstance(other, ad):
return ad(self.val*other.val,
self.val*other.der + self.der*other.val)
else:
return ad(self.val*other, self.der*other)
def __rmul__(self, other):
return self*other
def __div__(self, other):
return self*(other**-1)
def __rdiv__(self, other):
return other*(self**-1)
def __truediv__(self, other):
return self.__div__(other)
def __rtruediv__(self, other):
return self.__rdiv__(other)
def __pow__(self, other):
if isinstance(other, ad):
return ad(self.val**other.val,
other.val*self.val**(other.val - 1)*self.der + \
self.val**other.val*log(self.val)*other.der)
else:
return ad(self.val**other, other*self.val**(other - 1)*self.der)
def __rpow__(self, other):
return ad(other**self.val, other**self.val*log(other)*self.der)
def __abs__(self):
if self==0:
return ad(0*self.val, 0*self.der)
else:
return (self**2)**0.5
def __eq__(self, other):
if isinstance(other, ad):
return self.nom==other.nom
else:
return self.nom==other
def __lt__(self, other):
if isinstance(other, ad):
return self.nom<other.nom
else:
return self.nom<other
def __le__(self, other):
return self<other or self==other
def __gt__(self, other):
return not self<=other
def __ge__(self, other):
return not self<other
def __ne__(self, other):
return not self==other
def __nonzero__(self):
return self!=0
def adn(nom, order=1):
"""
Construct an ad object that tracks derivatives up to ``order``.
Parameters
----------
nom : scalar
The base, nominal value where the derivatives will be calculated at.
Optional
--------
order : int
The greatest order of derivatives to be tracked (Default: 1)
"""
if order==1:
return ad(nom)
else:
return ad(adn(nom, order - 1))
def taylornominal(u):
"""
Collect the zeroth order term that would be used in a Taylor polynomial
expansion (assumes any necessary calculations have been done prior).
"""
if isinstance(u, ad):
return taylornominal(u.val)
else:
return u
def taylorderivatives(u):
"""
Collect all the derivative coefficients (unscaled) necessary for a Taylor
polynomial expansion (assumes any necessary calculations have been done
prior).
"""
if isinstance(u, ad):
order = 0
tmp = u
while hasattr(tmp, 'val'):
tmp = tmp.val
order += 1
c = [0.0]*order
for idx in xrange(order):
tmp = u
for v in xrange(order - idx - 1):
tmp = tmp.val
for d in xrange(idx + 1):
if hasattr(tmp, 'der'):
tmp = tmp.der
else:
break
c[idx] = tmp
return np.array(c)
else:
return np.ones_like(u)
def taylorcoef(u):
"""
Collect all the scaled derivative coefficients necessary for a Taylor
polynomial expansion (assumes any necessary calculations have been done
prior).
"""
if isinstance(u, ad):
c = taylorderivatives(u)
for idx in xrange(len(c)):
c[idx] = c[idx]/factorial(idx + 1)
return c
else:
return np.ones_like(u)
def taylorterms(u):
"""
Collect all the coefficients necessary for a Taylor polynomial expansion,
including the zeroth order term (assumes any necessary calculations have
been done prior).
"""
if isinstance(u, ad):
return np.hstack((taylornominal(u), taylorcoef(u)))
else:
return np.array([u])
def taylorfunc(u, at=None):
"""
Construct a univariate taylor polynomial expansion about a reference point.
Parameters
----------
u : an ad object
The object that contains information about its derivatives
at : scalar
The point about which the series will be expanded (default: 0).
Returns
-------
func : function
The taylor series polynomial function that approximates ``u``,
expanded about the point ``at``.
Example
-------
::
>>> from ad import series, taylorfunc
>>> x = adn(3, 6) # a sixth order derivative tracker, nominal=3
>>> f = x*sin(x*x)
>>> func = taylorfunc(f, 3)
>>> func(3)
1.2363554557252698
"""
if at is None:
at = 0 # assume it's expanded about the origin
c = taylorterms(u)
def approxfunc(x):
try:
x[0]
except:
return c[0] + np.sum([c[i]*(x - at)**i for i in xrange(1, len(c))])
else:
tmp = [c[0] + np.sum([c[i]*(xi - at)**i
for i in xrange(1, len(c))]) for xi in x]
return np.array(tmp)
return approxfunc
def exp(u):
try:
u[0]
except:
if isinstance(u, ad):
return ad(exp(u.val), exp(u.val)*u.der)
else:
return np.exp(u)
else:
return [exp(ui) for ui in u]
def log(u):
try:
u[0]
except:
if isinstance(u, ad):
return ad(log(u.val), 1/(u.val)*u.der)
else:
return np.log(u)
else:
return [log(ui) for ui in u]
def sqrt(u):
try:
u[0]
except:
if isinstance(u, ad):
return ad(sqrt(u.val), u.der/(2*sqrt(u.val)))
else:
return np.sqrt(u)
else:
return [sqrt(ui) for ui in u]
def sin(u):
try:
u[0]
except:
if isinstance(u, ad):
return ad(sin(u.val), cos(u.val)*u.der)
else:
return np.sin(u)
else:
return [sin(ui) for ui in u]
def cos(u):
try:
u[0]
except:
if isinstance(u, ad):
return ad(cos(u.val), -sin(u.val)*u.der)
else:
return np.cos(u)
else:
return [cos(ui) for ui in u]
def tan(u):
try:
u[0]
except:
if isinstance(u, ad):
return ad(tan(u.val), 1/(cos(u.val)**2)*u.der)
else:
return np.tan(u)
else:
return [tan(ui) for ui in u]
def asin(u):
try:
u[0]
except:
if isinstance(u, ad):
return ad(asin(u.val), 1/sqrt(1 - u.val**2)*u.der)
else:
return np.arcsin(u)
else:
return [asin(ui) for ui in u]
def acos(u):
try:
u[0]
except:
if isinstance(u, ad):
return ad(acos(u.val), -1/sqrt(1 - u.val**2)*u.der)
else:
return np.arccos(u)
else:
return [acos(ui) for ui in u]
def atan(u):
try:
u[0]
except:
if isinstance(u, ad):
return ad(atan(u.val), 1/(1 + u.val**2)*u.der)
else:
return np.arctan(u)
else:
return [atan(ui) for ui in u]
def jacobian(deps):
"""
Construct the Jacobian matrix of a set of AD objects that are dependent
on other independent AD objects.
Parameters
----------
deps : array
A list of objects that depend on AD objects.
Returns
-------
jac : 2d-array
A matrix where each row corresponds to each dependent AD object and
each column corresponds to each independent AD object.
Example
-------
Separate ad objects::
>>> x = ad(-1, np.array([1, 0, 0]))
>>> y = ad(2.1, np.array([0, 1, 0]))
>>> z = ad(0.25, np.array([0, 0, 1]))
>>> u = x*y/z
>>> v = y - z**x
>>> w = sin(y**2/x)
>>> jacobian([u, v, w])
array([[ 8.4 , -4. , 33.6 ],
[ 5.54517744, 1. , 16. ],
[ 1.31330524, 1.25076689, 0. ]])
A single 3 ad object array::
>>> x = ad(np.array([-1, 2.1, 0.25]))
>>> y = [0]*3
>>> y[0] = x[0]*x[1]/x[2]
>>> y[1] = x[1] - x[2]**x[0]
>>> y[2] = sin(x[1]**2/x[0])
>>> jacobian(y)
array([[ 8.4 , -4. , 33.6 ],
[ 5.54517744, 1. , 16. ],
[ 1.31330524, 1.25076689, 0. ]])
You can also break-out the individual components before using them::
>>> x, y, z = ad(np.array([-1, 2.1, 0.25]))
>>> x
ad(-1.0, array([ 1., 0., 0.]))
>>> y
ad(2.1, array([ 0., 1., 0.]))
>>> z
ad(0.25, array([ 0., 0., 1.]))
"""
assert all([isinstance(depi, ad) for depi in deps]), 'All inputs must be dependent on AD objects'
return np.vstack([depi.d(1) for depi in deps])
def unite(ad_objs):
"""
Unite multivariate AD objects into a single AD object
Example
-------
::
>>> x = ad(np.array([-1, 2.1, 0.25]))
>>> y = [0]*2
>>> y[0] = x[0]*x[1]/x[2]
>>> y[1] = x[1] - x[2]**x[0]
# up to this point, y is a list, not an AD object, so y.d(1) won't work
>>> y = unite(y)
# now, we can do things like y.d(1)
>>> y.d(1)
array([[ 8.4 , -4. , 33.6 ],
[ 5.54517744, 1. , 16. ]])
>>> jacobian(y) # the result here is the same when y was a list object
array([[ 8.4 , -4. , 33.6 ],
[ 5.54517744, 1. , 16. ]])
"""
assert all([isinstance(adi, ad) for adi in ad_objs]), 'All inputs must be dependent on AD objects'
try:
ad_objs[0]
except:
return ad_objs
else:
ad_noms = np.array([adi.nom for adi in ad_objs])
ad_ders = np.array([adi.der for adi in ad_objs])
return ad(ad_noms, ad_ders)
if __name__=='__main__':
def fdf(a):
x = ad(a, 1)
y = exp(-sqrt(x))*sin(x*log(1 + x**2))
return y.double()
def newtonfdf(a):
delta = 1
while abs(delta)>0.000001:
fvec = fdf(a)
delta = fvec[0]/fvec[1]
a = a - delta
return a
print '\nnewtonfdf(5) should equal 4.8871:\n', newtonfdf(5)
def fgradf(a0, v0, h0):
a = ad(a0, np.array([1, 0, 0])) # angle in degrees
v = ad(v0, np.array([0, 1, 0])) # velocity in ft/sec
h = ad(h0, np.array([0, 0, 1])) # height in ft
rad = a*np.pi/180
tana = tan(rad)
vhor = (v*cos(rad))**2
f = (vhor/32)*(tana + sqrt(tana**2 + 64*h/vhor)) # horizontal range
return f.double()
print '\nfgradf(20, 44, 9) should equal [56.0461, 1.0717, 1.9505, 1.4596]:\n', fgradf(20, 44, 9)
def FJF(A):
x = ad(A[0], np.array([1, 0, 0]))
y = ad(A[1], np.array([0, 1, 0]))
z = ad(A[2], np.array([0, 0, 1]))
f1 = 3*x - cos(y*z) - 0.5
f2 = x**2 - 81*(y + 0.1)**2 + sin(z) + 1.06
f3 = exp(-x*y) + 20*z + (10*np.pi - 3)/3
values = np.array([f1.double(), f2.double(), f3.double()])
F = values[:, 0]
J = values[:, 1:4]
return (F, J)
def newtonFJF(A):
delta = 1
while np.max(np.abs(delta))>0.000001:
[F, J] = FJF(A)
delta = np.linalg.solve(J, F)
A = A - delta
return A
print '\nnewtonFJF([0.1, 0.1, -0.1]) should equal [0.5000, 0.0000, -0.5236]:\n', newtonFJF(np.array([0.1, 0.1, -0.1]))
x = adn(3, 3)
f = x*sin(x*x)
print '\nf.d(3) should equal 495.9280:\n', f.d(3) | ADiPy | /ADiPy-0.6.3.tar.gz/ADiPy-0.6.3/adipy/adipy.py | adipy.py |
from __future__ import division
import numpy as np
__all__ = ['np', 'chol', 'qr', 'lu', 'solve', 'lstsq', 'inv', 'norm']
###############################################################################
def chol(A, side='lower'):
"""
Cholesky decomposition of a symmetric, positive-definite matrix, defined
by A = L*L.T = U.T*U, where L is a lower triangular matrix and U is an
upper triangular matrix.
Parameters
----------
A : 2d-array
The input matrix
Optional
--------
side : str
If 'lower' (default), then the lower triangular form of the
decompostion is returned. If 'upper', then the upper triangular
form of the decomposition is returned (the transpose of 'lower')
Returns
-------
L : 2d-array
The lower (or upper) triangular matrix that helps define the
decomposition.
Example
-------
Example 1::
>>> A = [[25, 15, -5],
... [15, 18, 0],
... [-5, 0, 11]]
...
>>> L = chol(A)
>>> L
array([[ 5., 0., 0.],
[ 3., 3., 0.],
[-1., 1., 3.]])
>>> U = chol(A, 'upper')
>>> U
array([[ 5., 3., -1.],
[ 0., 3., 1.],
[ 0., 0., 3.]])
Example 2::
>>> A = [[18, 22, 54, 42],
... [22, 70, 86, 62],
... [54, 86, 174, 134],
... [42, 62, 134, 106]]
...
>>> L = chol(A)
>>> L
array([[ 4.24264069, 0. , 0. , 0. ],
[ 5.18544973, 6.5659052 , 0. , 0. ],
[ 12.72792206, 3.0460385 , 1.64974225, 0. ],
[ 9.89949494, 1.62455386, 1.84971101, 1.39262125]])
"""
A = np.array(A)
assert A.shape[0]==A.shape[1], 'Input matrix must be square'
L = [[0.0] * len(A) for _ in xrange(len(A))]
for i in xrange(len(A)):
for j in xrange(i+1):
s = sum(L[i][k] * L[j][k] for k in xrange(j))
L[i][j] = (A[i][i] - s)**0.5 if (i == j) else \
(1.0 / L[j][j] * (A[i][j] - s))
if side=='lower':
return np.array(L)
elif side=='upper':
return np.array(L).T
###############################################################################
def qr(A):
"""
QR Decomposition
Parameters
----------
A : 2d-array
The input matrix (need not be square).
Returns
-------
qm : 2d-array
The orthogonal Q matrix from the decomposition
rm : 2d-array
The R matrix from the decomposition
Example
-------
A square input matrix::
>>> A = [[12, -51, 4],
... [ 6, 167, -68],
... [-4, 24, -41]]
...
>>> q, r = qr(A)
>>> q
array([[-0.85714286, 0.39428571, 0.33142857],
[-0.42857143, -0.90285714, -0.03428571],
[ 0.28571429, -0.17142857, 0.94285714]])
>>> r
array([[ -1.40000000e+01, -2.10000000e+01, 1.40000000e+01],
[ 5.97812398e-18, -1.75000000e+02, 7.00000000e+01],
[ 4.47505281e-16, 0.00000000e+00, -3.50000000e+01]])
A non-square input matrix::
>>> A = [[12, -51, 4],
... [ 6, 167, -68],
... [-4, 24, -41],
... [-1, 1, 0],
... [ 2, 0, 3]]
...
>>> q, r = qr(A)
>>> q
array([[-0.84641474, 0.39129081, -0.34312406, 0.06613742, -0.09146206],
[-0.42320737, -0.90408727, 0.02927016, 0.01737854, -0.04861045],
[ 0.28213825, -0.17042055, -0.93285599, -0.02194202, 0.14371187],
[ 0.07053456, -0.01404065, 0.00109937, 0.99740066, 0.00429488],
[-0.14106912, 0.01665551, 0.10577161, 0.00585613, 0.98417487]])
>>> r
array([[ -1.41774469e+01, -2.06666265e+01, 1.34015667e+01],
[ 3.31666807e-16, -1.75042539e+02, 7.00803066e+01],
[ -3.36067949e-16, 2.87087579e-15, 3.52015430e+01],
[ 9.46898347e-17, 5.05117109e-17, -9.49761103e-17],
[ -1.74918720e-16, -3.80190411e-16, 8.88178420e-16]])
>>> import numpy as np
>>> np.all(np.dot(q, r) - A<1e-12)
True
"""
A = np.atleast_2d(A)
m, n = A.shape
qm = np.eye(m)
rm = A.copy()
for i in xrange(n-1 if m==n else n):
x = getSubmatrix(rm, i, i, m, i)
h = np.eye(m)
h = setSubmatrix(h, i, i, householder(x))
qm = np.dot(qm, h)
rm = np.dot(h, rm)
return qm, rm
###############################################################################
def lu(A):
"""
Decomposes a nxn matrix A by PA=LU and returns L, U and P.
Parameters
----------
A : 2d-array
The input matrix
Returns
-------
L : 2d-array
The lower-triangular matrix of the decomposition
U : 2d-array
The upper-triangular matrix of the decomposition
P : 2d-array
The pivoting matrix used in the decomposition
Examples
--------
Example 1::
>>> A = [[1, 3, 5],
... [2, 4, 7],
... [1, 1, 0]]
...
>>> L, U, P = lu(A)
>>> L
array([[ 1. , 0. , 0. ],
[ 0.5, 1. , 0. ],
[ 0.5, -1. , 1. ]])
>>> U
array([[ 2. , 4. , 7. ],
[ 0. , 1. , 1.5],
[ 0. , 0. , -2. ]])
>>> P
array([[ 0., 1., 0.],
[ 1., 0., 0.],
[ 0., 0., 1.]])
Example 2::
>>> A = [[11, 9, 24, 2],
... [ 1, 5, 2, 6],
... [ 3, 17, 18, 1],
... [ 2, 5, 7, 1]]
...
>>> L, U, P = lu(A)
>>> L
array([[ 1. , 0. , 0. , 0. ],
[ 0.27272727, 1. , 0. , 0. ],
[ 0.09090909, 0.2875 , 1. , 0. ],
[ 0.18181818, 0.23125 , 0.00359712, 1. ]])
>>> U
array([[ 11. , 9. , 24. , 2. ],
[ 0. , 14.54545455, 11.45454545, 0.45454545],
[ 0. , 0. , -3.475 , 5.6875 ],
[ 0. , 0. , 0. , 0.51079137]])
>>> P
array([[ 1., 0., 0., 0.],
[ 0., 0., 1., 0.],
[ 0., 1., 0., 0.],
[ 0., 0., 0., 1.]])
"""
A = np.array(A)
assert A.shape[0]==A.shape[1], 'Input matrix must be square'
n = len(A)
L = [[0.0]*n for i in xrange(n)]
U = [[0.0]*n for i in xrange(n)]
# Create the pivoting matrix for A
P = [[float(i == j) for i in xrange(n)] for j in xrange(n)]
for j in xrange(n):
row = max(xrange(j, n), key=lambda i: A[i][j])
if j != row:
P[j], P[row] = P[row], P[j]
A2 = np.dot(P, A)
for j in xrange(n):
L[j][j] = 1.0
for i in xrange(j+1):
s1 = sum(U[k][j] * L[i][k] for k in xrange(i))
U[i][j] = A2[i][j] - s1
for i in xrange(j, n):
s2 = sum(U[k][j] * L[i][k] for k in xrange(j))
L[i][j] = (A2[i][j] - s2) / U[j][j]
return (np.array(L), np.array(U), np.array(P))
###############################################################################
def solve(A, b):
"""
Solve a system of equations Ax = b by Gaussian elimination
Parameters
----------
A : 2d-array
The LHS of the system of equations. The number of rows must not be less
than the number of columns, but can be more.
b : array-like
The RHS of the system of equations (must have the same number of rows
as ``A``. If more than one column is given, a solution is generated for
each column
Returns
-------
x : array-like
The solution that satisifies the equality ``Ax==b``. If multiple ``b``
are given, a solution column will be given satisfying each set.
Example
-------
::
>>> A = [[1, 2, 1], [4, 6, 3], [9, 8, 2]]
>>> b = [3, 2, 1]
>>> solve(A, b)
array([ -7., 11., -12.])
"""
try:
A = np.matrix(A)
except Exception:
raise Exception('A must be a 2-dimensional array')
assert A.shape[0]>=A.shape[1], 'A must not have less rows than columns'
b = np.array(b)
numout = 1 if b.ndim==1 else b.shape[1]
assert A.shape[0]==b.shape[0], 'b must have the same number of rows as A'
# Make the LHS array square if it isn't already and adjust RHS if needed
if A.shape[0]>A.shape[1]:
b = A.T*b
A = A.T*A
eqs = np.column_stack((A, b))
n, m = eqs.shape
# Forward substitution
for k in range(n-1):
# Pivot test
p = k
piv_el = abs(eqs[k, k])
for i in range(k + 1, n):
tmp = abs(eqs[i, k])
if tmp>piv_el:
piv_el = tmp
p = i
# Swap the kth and pth rows if a pivot element was found
if p!=k:
rtmp = np.array(eqs[p, :])
eqs[p, :] = eqs[k, :]
eqs[k, :] = rtmp
for i in range(k + 1, n):
f = 1.*eqs[i, k]/eqs[k, k]
for j in range(k, m):
eqs[i, j] -= f*eqs[k, j]
# Backward substitution
for k in range(1, n)[::-1]:
for i in range(k)[::-1]:
f = 1.*eqs[i, k]/eqs[k, k]
for j in range(m)[::-1]:
eqs[i, j] -= f*eqs[k, j]
# Normalize
for i in range(n):
x = 1.*eqs[i, i]
for j in range(m):
eqs[i, j] = eqs[i, j]/x
if numout==1:
return np.array(eqs[:, -(m-n):]).ravel()
else:
return np.array(eqs[:, -(m-n):])
###############################################################################
def lstsq(A, b):
"""
Solve Ax = b with the linear least squares method.
Parameters
----------
A : 2d-array
The linear system matrix
b : array
The right-hand-side of the equation
Returns
-------
x : array
The solution to the system of equations
Example
-------
(Taken from the NumPy lstsq example)::
>>> x = np.array([0, 1, 2, 3])
>>> y = np.array([-1, 0.2, 0.9, 2.1])
>>> A = np.vstack([x, np.ones(len(x))]).T
>>> A
array([[ 0., 1.],
[ 1., 1.],
[ 2., 1.],
[ 3., 1.]])
>>> print lstsq(A, y)
[ 1. -0.95]
"""
q, r = qr(A)
n = r.shape[1]
x = solveUpperTriangular(getSubmatrix(r, 0, 0, n - 1, n - 1),
np.dot(q.T, b))
return x.ravel()
###############################################################################
def inv(A):
"""
Calculate the multiplicative inverse of a matrix.
Parameters
----------
A : 2d-array
The input matrix
Returns
-------
Ainv : 2d-array
The inverse of A
Example
-------
::
>>> A = [[25, 15, -5],
... [15, 18, 0],
... [-5, 0, 11]]
...
>>> Ainv = inv(A)
>>> Ainv
array([[ 0.09777778, -0.08148148, 0.04444444],
[-0.08148148, 0.12345679, -0.03703704],
[ 0.04444444, -0.03703704, 0.11111111]])
>>> np.dot(Ainv, A)
array([[ 1.00000000e+00, 0.00000000e+00, 0.00000000e+00],
[ 2.77555756e-16, 1.00000000e+00, 0.00000000e+00],
[ 0.00000000e+00, 1.11022302e-16, 1.00000000e+00]])
"""
shape = np.atleast_2d(A).shape
assert shape[0]==shape[1], 'Matrix must be square'
return solve(A, np.eye(shape[0]))
###############################################################################
def norm(A):
"""
Calculate the Frobenius norm of a matrix or vector, which is defined as
the square root of the sum of the absolute squares of its elements.
Parameters
----------
A : array
The input matrix or vector
Returns
-------
N : scalar
The inverse of A
Example
-------
::
>>> A = [[25, 15, -5],
... [15, 18, 0],
... [-5, 0, 11]]
...
>>> N = norm(A)
>>> N
XXXX
"""
A = np.atleast_2d(A).ravel()
return (np.sum(np.abs(A)**2))**0.5
###############################################################################
#
#
# All functions below are utility functions for some of the above
# linear algebra functions. They should NOT be used directly.
#
#
###############################################################################
def ematrix(m, n, x, i, j):
a = np.empty((m, n))
a[:, :] = 0.0
a[i, j] = x
return a
def unitVector(n):
return ematrix(n, 1, 1, 0, 0)
def signValue(r):
if r<0:
return -1
elif r==0:
return 0
else:
return 1
def householder(A):
m = len(A)
u = A - np.sqrt(np.dot(A.T, A)[0, 0])*unitVector(m)
v = u
beta = 2/np.dot(v.T, v)
return np.eye(m) - beta*(np.dot(v, v.T).T)
def getSubmatrix(obj, i1, j1, i2, j2):
"""
i1, j1, i2, j2 are inclusive indices
"""
return obj[i1:i2 + 1, j1:j2 + 1]
def setSubmatrix(obj, i1, j1, subobj):
"""
i1, j1 are the top left corner indices where subobj will be inserted
"""
m, n = np.atleast_2d(subobj).shape
obj[i1:i1+m, j1:j1+n] = subobj
return obj
def solveUpperTriangular(r, b):
r = np.atleast_2d(r)
n = r.shape[1]
x = np.zeros((n, 1))
for k in xrange(n - 1, -1, -1):
idx = min(n - 1, k)
x[k, 0] = (b[k] - np.dot(getSubmatrix(r, k, idx, k, n - 1),
getSubmatrix(x, idx, 0, n - 1, 0)))/r[k, k]
return x
def polyfit(x, y, n):
"""
Fit a polynomial of order n to data arrays x and y
Parameters
----------
x : array
A data array that defines the first dimension coordinates.
y : array
A data array that defines the second dimension coordinates.
n : int
The order of the polynomial (e.g., 1 for linear, 2 for quadratic, etc.)
Returns
-------
b : array
The polynomial coefficients, in ascending order.
Example
-------
::
>>> x = range(11)
>>> y = [1, 6, 17, 34, 57, 86, 121, 162, 209, 262, 321]
>>> polyfit(x, y, 2)
array([ 1., 2., 3.])
"""
a = np.empty((len(x), n + 1))
for i in xrange(a.shape[0]):
for j in xrange(a.shape[1]):
a[i, j] = 1 if j==0 else x[i]**j
return lstsq(a, y) | ADiPy | /ADiPy-0.6.3.tar.gz/ADiPy-0.6.3/adipy/linalg/linalg.py | linalg.py |
========
ADwin.py
========
This is the python wrapper module for the ADwin API to communicate with ADwin-systems.
--------------------------------------------------------------------------------------
:Version: 0.18.0
:Date: August 2022
:Organisation: Jaeger Computergesteuerte Messtechnik GmbH
Requirements, downloadable at www.adwin.de:
* Linux / Mac: libadwin.so
* Windows: adwin32.dll / adwin64.dll
**Changelog**
Version 0.18.0
* new mode: useNumpyArrays
Version 0.17.2
* minor enhancements
Version 0.17.1
* bugfix File2Data
Version 0.17.0
* new function: SanitizeFloatingPointValues
Version 0.16.4
* bugfix Data_Type() T12/ADwinX
Version 0.16.3
* ctypes.WinDLL() needs full path
* additional functions for ADwinX
Version 0.16.2
* bugfix
Version 0.16.1
* bugfix
Version 0.16.0
* Changed license to Apache V2
* CODING cp1252 added in example*.py
* changed bas_demos to python3 and Qt5
Version 0.15
* bugfixes
* new functions: Set_FPar_Double, Get_FPar_Double, Get_FPar_Block_Double, Get_FPar_All_Double,
SetData_Double, GetData_Double, SetFifo_Double, GetFifo_Double,
Data_Type, Data2File, File2Data
* renamed Get_Last_Error_Text() to Get_Error_Text()
* changed returnvalue from Processor_Type to str (1010 -> "T10")
* div pep8-style changes
* several improvements
* winreg-key
* examples reworked
Version 0.14
* bugfix GetData_String()
Version 0.13
* new function: GD_Transsize
Version 0.12
* bugfixes
Version 0.11
* bugfixes
Version 0.10
* bas_demo7: float() instead of QString.toDouble()
* examples: c_int32 instead of c_long
* new functions: Clear_Data(), Retry_Counter()
Version 0.9
* adwin32.dll / adwin64.dll depending on the python-version
* bas_demos: str() instead of QtCore.QString.number()
* bas_dmo3: bugfix div/0
Version 0.8
* ctypes.c_int32 instead of ctypes.c_long
Version 0.7
* bugfix Windows-registry
* python3-support for Windows
Version 0.6
* bugfix GetData_String()
Version 0.5
* removed Get- and Set_Globaldelay()
* bugfixes Fifo_Count() and Fifo_Empty()
Version 0.4
* new class-attribute ADwindir
* bas_demos (1, 2, 3, 7) created
* indenting fixed
Version 0.3
* one file for booth python-versions (2/3)
* no exception if Test_Version() fails
Version 0.2
* usage of the module ctypes
* class ADwin
* python3-support for linux
Version 0.1
* first issue
| ADwin | /ADwin-0.18.0.zip/ADwin-0.18.0/README.txt | README.txt |
import foolbox as fb
import torch
import torchvision
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt
import torchvision.datasets as td
import os
def dataset_init(dataset):
data = td.MNIST('mnist', train=True, transform=torchvision.transforms.ToTensor(), download=True)
if dataset == 'cifar10':
data = td.CIFAR10('cifar10', train=True, transform=torchvision.transforms.ToTensor(), download=True)
elif dataset == 'cifar100':
data = td.CIFAR100('cifar100', train=True, transform=torchvision.transforms.ToTensor(), download=True)
elif dataset == 'imagenet':
data = td.ImageNet('imagenet', train=True, transform=torchvision.transforms.ToTensor(), download=True)
# 产生一个数据的迭代器data_loader
data_loader = DataLoader(data, batch_size=16)
return data_loader
def plot(raw, labels, predic):
plt.figure(figsize=(16, 8))
id = 0
for cnt in range(4):
for j in range(4):
plt.subplot(4, 4, id + 1)
plt.imshow(raw[id, 0].reshape(28, 28), cmap="gray")
plt.title(f"{labels[id]}->{predic[id]}", {"color": "red"})
plt.axis("off")
id += 1
plt.show()
def attack(model_weights, Net, methodName, epsilon, steps=None, distance=None, dataset='mnist'):
os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
model, device, fmodel, data_loader = init(model_weights, Net, dataset)
attack_dataset(model, methodName, fmodel, device, data_loader, epsilon, steps, distance)
def init(model_weights, Net, dataset):
# 如果保存的是模型参数，则应修改model.py为对应的网络结构，并使用以下方式读取模型：
model = Net()
model.load_state_dict(torch.load(model_weights))
# model = torch.load(model)
# 求值模式
model.eval()
data_loader = dataset_init(dataset)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
fmodel = fb.PyTorchModel(model, bounds=(0, 1))
return model, device, fmodel, data_loader
def attack_dataset(model, methodName, fmodel, device, data_loader, epsilon, steps, distance):
global attack
# 方法1（需要初始化steps的算法）
if methodName == 'VirtualAdversarialAttack':
attack = fb.attacks.VirtualAdversarialAttack(steps=steps)
# 方法2~7，需要初始化distance
elif methodName == 'BinarySearchContrastReductionAttack':
attack = fb.attacks.BinarySearchContrastReductionAttack(distance=distance)
elif methodName == 'DatasetAttack':
attack = fb.attacks.DatasetAttack(distance=distance)
elif methodName == 'GaussianBlurAttack':
attack = fb.attacks.GaussianBlurAttack(distance=distance)
elif methodName == 'InversionAttack':
attack = fb.attacks.InversionAttack(distance=distance)
elif methodName == 'LinearSearchBlendedUniformNoiseAttack':
attack = fb.attacks.LinearSearchBlendedUniformNoiseAttack(distance=distance)
elif methodName == 'LinearSearchContrastReductionAttack':
attack = fb.attacks.LinearSearchContrastReductionAttack(distance=distance)
elif methodName == 'PointwiseAttack':
attack = fb.attacks.PointwiseAttack()
elif methodName == 'BoundaryAttack':
attack = fb.attacks.BoundaryAttack()
elif methodName == 'L2CarliniWagnerAttack':
attack = fb.attacks.L2CarliniWagnerAttack()
elif methodName == 'DDNAttack':
attack = fb.attacks.DDNAttack()
elif methodName == 'EADAttack':
attack = fb.attacks.EADAttack()
elif methodName == 'FGM':
attack = fb.attacks.FGM()
elif methodName == 'FGSM':
attack = fb.attacks.FGSM()
elif methodName == 'NewtonFoolAttack':
attack = fb.attacks.NewtonFoolAttack()
elif methodName == 'PGD':
attack = fb.attacks.PGD()
elif methodName == 'SaltAndPepperNoiseAttack':
attack = fb.attacks.SaltAndPepperNoiseAttack()
elif methodName == 'L1BrendelBethgeAttack':
attack = fb.attacks.L1BrendelBethgeAttack()
elif methodName == 'L1FMNAttack':
attack = fb.attacks.L1FMNAttack()
elif methodName == 'L2AdditiveGaussianNoiseAttack':
attack = fb.attacks.L2AdditiveGaussianNoiseAttack()
elif methodName == 'L2AdditiveUniformNoiseAttack':
attack = fb.attacks.L2AdditiveUniformNoiseAttack()
elif methodName == 'L2BasicIterativeAttack':
attack = fb.attacks.L2BasicIterativeAttack()
elif methodName == 'L2BrendelBethgeAttack':
attack = fb.attacks.L2BrendelBethgeAttack()
elif methodName == 'L2ClippingAwareAdditiveGaussianNoiseAttack':
attack = fb.attacks.L2ClippingAwareAdditiveGaussianNoiseAttack()
elif methodName == 'L2ClippingAwareAdditiveUniformNoiseAttack':
attack = fb.attacks.L2ClippingAwareAdditiveUniformNoiseAttack()
elif methodName == 'L2ClippingAwareRepeatedAdditiveGaussianNoiseAttack':
attack = fb.attacks.L2ClippingAwareRepeatedAdditiveGaussianNoiseAttack()
elif methodName == 'L2ClippingAwareRepeatedAdditiveUniformNoiseAttack':
attack = fb.attacks.L2ClippingAwareRepeatedAdditiveUniformNoiseAttack()
elif methodName == 'L2ContrastReductionAttack':
attack = fb.attacks.L2ContrastReductionAttack()
elif methodName == 'L2DeepFoolAttack':
attack = fb.attacks.L2DeepFoolAttack()
elif methodName == 'L2FastGradientAttack':
attack = fb.attacks.L2FastGradientAttack()
elif methodName == 'L2FMNAttack':
attack = fb.attacks.L2FMNAttack()
elif methodName == 'L2PGD':
attack = fb.attacks.L2PGD()
elif methodName == 'L2ProjectedGradientDescentAttack':
attack = fb.attacks.L2ProjectedGradientDescentAttack()
elif methodName == 'L2RepeatedAdditiveGaussianNoiseAttack':
attack = fb.attacks.L2RepeatedAdditiveGaussianNoiseAttack()
elif methodName == 'L2RepeatedAdditiveUniformNoiseAttack':
attack = fb.attacks.L2RepeatedAdditiveUniformNoiseAttack()
elif methodName == 'LinfAdditiveUniformNoiseAttack':
attack = fb.attacks.LinfAdditiveUniformNoiseAttack()
elif methodName == 'LinfBasicIterativeAttack':
attack = fb.attacks.LinfBasicIterativeAttack()
elif methodName == 'LinfDeepFoolAttack':
attack = fb.attacks.LinfDeepFoolAttack()
elif methodName == 'LinfFastGradientAttack':
attack = fb.attacks.LinfFastGradientAttack()
elif methodName == 'LInfFMNAttack':
attack = fb.attacks.LInfFMNAttack()
elif methodName == 'LinfinityBrendelBethgeAttack':
attack = fb.attacks.LinfinityBrendelBethgeAttack()
elif methodName == 'LinfPGD':
attack = fb.attacks.LinfPGD()
elif methodName == 'LinfProjectedGradientDescentAttack':
attack = fb.attacks.LinfProjectedGradientDescentAttack()
elif methodName == 'LinfRepeatedAdditiveUniformNoiseAttack':
attack = fb.attacks.LinfRepeatedAdditiveUniformNoiseAttack()
for images, labels in data_loader:
raw, clipped, is_adv = attack(fmodel, images.to(device), labels.to(device), epsilons=epsilon)
predic = torch.argmax(model(raw.to(device)), dim=1).detach().cpu()
plot(raw, labels, predic) | AE-Toolbox | /AE_Toolbox-0.2.0-py3-none-any.whl/AE_Toolbox/common.py | common.py |
===================
Usage documentation
===================
Communication with the engine
_____________________________
The link used for communication is not specified by the AEI protocol. This
implementation uses either stdio or a socket for the communication. Stdio is
the preferred method for general operation, but in certain programming
languages or environments it may be easier to use socket communication.
When using a socket the controller will listen on an ip and port given to the
engine by adding "--server <dotted quad ip>" and "--port <port number>" options
to its command line. The engine should connect to the specified address and
expect the AEI protocol identifier from the controller.
analyze
_______
A simple script that runs an engine and has it search a given position or
move sequence. As an example use it with simple_engine.py that just makes a
random moves::
cp analyze_example.cfg analyze.cfg
analyze example_position.txt
If you replace the simple_engine.py with your own bot that implements AEI you
can point your bot at any position.
roundrobin
__________
Plays engines against each other in a round robin tournament. This is a very
handy way to test your bot against other bots.
The example_roundrobin.cfg contains a config for playing simple_engine against
itself. It is a good idea to try doing this first to make sure the AEI
tournament is working properly before you put your own bot in there.
First you'll need to make a copy of the example cfg file::
cp roundrobin_example.cfg roundrobin.cfg
To run the tournament you start it from the commandline::
roundrobin
Example of the output::
Number of rounds: 100
At timecontrol 3s/30s/100/60s/10m
Giving these settings to all bots:
hash: 50
27s
+-----------------+
8| . . r r R . . . |
7| r . . . . . . . |
6| . . x . . x h . |
5| H . . . . . . . |
4| . . h H . R R r |
3| R D x . . x . . |
2| . C . . R . . . |
1| . R . . . D . M |
+-----------------+
a b c d e f g h
Random beat Randomer because of g playing side g
After round 1 and 0s:
Random has 1 wins and 0 timeouts
1 by g
Randomer has 0 wins and 0 timeouts
...
66g
+-----------------+
8| . . . C . . . . |
7| . . . . . . . . |
6| R . x . . x . R |
5| . H . . . . . . |
4| . . . . . . . . |
3| . . x . . x . . |
2| . . . . . . . . |
1| . . . . d . . . |
+-----------------+
a b c d e f g h
Randomer beat Random because of e playing side g
After round 100 and 2m22s:
Random has 59 wins and 0 timeouts
4 by e
5 by m
50 by g
Randomer has 41 wins and 0 timeouts
5 by m
8 by e
28 by g
The example tournament only has two bot players. To add additional players
add a new section and add the commandline to execute the player (this should be
an executable that responds to the AEI protocol), e.g.
::
[MyBot]
cmdline = ./my_bot
And to add the bot to the tournament modify the bots property::
bots = random randomer MyBot
or simply replacing one with your own::
bots = random MyBot
getMove and Older Bots
______________________
Older bots still implement the getMove interface for Arimaa. To use these bots
with an AEI controller you can use the ``adapt.py`` adapter script written by
Greg Clark and available as part of his `Arimaa client
<https://bitbucket.org/Rabbits/arimaa-client>`_. Place the executable for the
bot and `adapt.py` in the AEI directory and configure the bot. For example if
you download bot_fairy from `arimaa.com <http://arimaa.com/arimaa/download/>`_
you can add it to ``roundrobin.cfg`` like this::
[Fairy]
cmdline = python adapt.py . Fairy
Don't forget to also modify the bots property to add it to the list of bots
that take part in the tournament.
gameroom
________
AEI controller that connects to the arimaa.com gameroom and plays a game.
Similiar to roundrobin or analyze above you'll need to first setup
a ``gameroom.cfg`` file with the bot configuration and gameroom login
information.
Then starting a new game is as simple as::
gameroom [side]
The first usage starts a single game and waits for an opponent, after which
it plays a full game with that opponent. <side> indicates the side to play
and should be either 'g' for Gold or 's' for Silver, or if not specified,
then it is s. (w or b will also work but may be removed in the future)
To join an existing game use::
gameroom play|move <opponent name or game number> [side]
This starts an engine then plays a game or move on the server as
specified by the command line arguments. Configuration is provided in the file
``gameroom.cfg``.
The second usage joins a game and either plays a full game or just one move.
'play' indicates the full game should be played. 'move' will play only one
move at most then exit, if it is the opponent's move the interface will exit
immediately. This is handy for postal games. As in the first usage, <side>
optionally indicates which side to play.
postal_controller
_________________
Monitors and directs a bot to play in all of its postal games.
Regular usage just involves setting up a ``gameroom.cfg`` file with the
desired bot settings and simply running::
postal_controller
If needed you can create a [postal] section in ``gameroom.cfg`` with log
settings or specific bot sections to use in certain games, see the
``gameroom_example.cfg`` file for details.
To cleanly exit the controller after the current move is played create a file
called ``stop_postal`` in the directory ``postal_controller`` was run from.
| AEI | /AEI-1.3.0.tar.gz/AEI-1.3.0/usage.rst | usage.rst |
==========
AEI Readme
==========
This package provides a specification for the Arimaa Engine Interface (AEI).
It also includes some tools for using engines that implement AEI. Including an
interface to the arimaa.com gameroom. A full description of AEI can be found in
the file ``aei-protocol.txt``.
The scripts included for working with an AEI engine are:
``analyze``
A simple script that runs an engine and has it search a given position or
move sequence.
``gameroom``
AEI controller that connects to the arimaa.com gameroom and plays a game.
``postal_controller``
Keeps a bot making moves as needed in any postal games it is a participant
in.
``roundrobin``
Plays engines against each other in a round robin tournament.
``simple_engine``
Very basic AEI engine, just plays random step moves.
Basic examples of using the scripts can be found in the file ``usage.rst``.
The pyrimaa package also includes modules implementing the controller side of
the AEI protocol (``aei.py``), the Arimaa position representation (as bitboards
in ``board.py`` and x88 in ``x88board.py``), and a few utility functions for
handling Arimaa timecontrols (``util.py``).
If you have python2 and pip on your machine you can install the latest
release with::
pip install aei
On an operating system with a system supplied python you probably want to keep
the aei install separate from your system installed packages. To accomplish
that you can use either a virtualenv or user install. A user install is done
simply by adding the ``--user`` option::
pip install --user aei
AEI may also be built and installed with
python setup.py install
| AEI | /AEI-1.3.0.tar.gz/AEI-1.3.0/readme.rst | readme.rst |
import logging
import time
import signal
import socket
import sys
import os
from threading import Thread, Event
from subprocess import Popen, PIPE
try:
from Queue import Queue, Empty
except ModuleNotFoundError:
from queue import Queue, Empty
if sys.platform == 'win32':
import ctypes
from collections import defaultdict
def _get_child_pids():
class ProcessEntry(ctypes.Structure):
_fields_ = [("dwSize", ctypes.c_ulong),
("cntUsage", ctypes.c_ulong),
("th32ProcessID", ctypes.c_ulong),
("th32DefaultHeapID", ctypes.c_void_p),
("th32ModuleID", ctypes.c_ulong),
("cntThreads", ctypes.c_ulong),
("th32ParentProcessID", ctypes.c_ulong),
("pcPriClassBase", ctypes.c_long),
("dwFlags", ctypes.c_ulong),
("szExeFile", ctypes.c_char * 260), ]
TH32CS_SNAPPROCESS = 0x2
kernel32 = ctypes.windll.kernel32
psnap = kernel32.CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0)
childIDs = defaultdict(list)
entry = ProcessEntry()
entry.dwSize = ctypes.sizeof(ProcessEntry)
kernel32.Process32First.argtypes = [ctypes.c_ulong,
ctypes.POINTER(ProcessEntry)]
if kernel32.Process32First(psnap, ctypes.byref(entry)) == 0:
errno = kernel32.GetLastError()
raise OSError("Received error from Process32First, %d" % (errno, ))
else:
childIDs[entry.th32ParentProcessID].append(entry.th32ProcessID)
while kernel32.Process32Next(psnap, ctypes.pointer(entry)):
childIDs[entry.th32ParentProcessID].append(entry.th32ProcessID)
errno = kernel32.GetLastError()
if errno != 18:
raise OSError("Received error from Process32Next, %d" % (errno, ))
kernel32.CloseHandle(psnap)
return childIDs
def _kill_proc_tree(pid, cid_map=None):
if cid_map is None:
cid_map = _get_child_pids()
if len(cid_map[pid]) > 0:
for cid in cid_map[pid]:
_kill_proc_tree(cid, cid_map)
PROCESS_TERMINATE = 0x1
handle = ctypes.windll.kernel32.OpenProcess(PROCESS_TERMINATE, False, pid)
if handle is not None:
ctypes.windll.kernel32.TerminateProcess(handle, -1)
ctypes.windll.kernel32.CloseHandle(handle)
else:
raise OSError("Could not kill process, %d" % (pid, ))
START_TIME = 5.0
INIT_TIME = 15.0
STOP_TIME = 5.0
class EngineException(Exception):
def __init__(self, message=None):
self.message = message
def find_line_end(posline):
nloc = posline.find("\n")
rloc = posline.find("\r")
return max(nloc, rloc)
class _ProcCom(Thread):
def __init__(self, proc, log):
Thread.__init__(self)
self.proc = proc
self.log = log
self.outq = Queue()
self.stop = Event()
self.setDaemon(True)
def run(self):
while not self.stop.isSet() and self.proc.poll() is None:
msg = self.proc.stdout.readline()
if self.log:
self.log.debug("Received from bot: %s" % (repr(msg)))
self.outq.put(msg.strip())
class StdioEngine:
def __init__(self, cmdline, log=None):
proc = Popen(cmdline,
shell=True,
stdin=PIPE,
stdout=PIPE,
universal_newlines=True)
self.proc = proc
self.log = log
self.proc_com = _ProcCom(proc, log)
self.proc_com.start()
self.active = True
def __del__(self):
try:
if self.active:
self.cleanup()
except AttributeError:
pass
def is_running(self):
return self.proc.poll() is None
def send(self, msg):
if self.log:
self.log.debug("Sending to bot: %s" % repr(msg))
self.proc.stdin.write(msg)
self.proc.stdin.flush()
def readline(self, timeout=None):
try:
msg = self.proc_com.outq.get(timeout=timeout)
except Empty:
raise socket.timeout()
return msg
def waitfor(self, expect, timeout=0.5):
endtime = time.time() + timeout
response = []
while time.time() <= endtime:
wait = endtime - time.time()
try:
line = self.readline(timeout=wait)
response.append(line)
if line.lstrip().lower().startswith(expect):
break
except socket.timeout:
pass
else:
raise EngineException("Engine did not respond in alloted time.")
return response
def cleanup(self):
self.active = False
self.proc_com.stop.set()
if self.proc.poll() is None:
if sys.platform == 'win32':
_kill_proc_tree(self.proc.pid)
else:
self.proc.terminate()
stop_time = time.time() + STOP_TIME
while time.time() < stop_time and self.proc.poll() is None:
pass
if self.proc.poll() is None:
self.proc.kill()
for stream in [self.proc.stdin, self.proc.stdout]:
try:
stream.close()
except Exception:
pass
class SocketEngine:
def __init__(self, con, proc=None, legacy_mode=False, log=None):
if len(con) != 2 or not hasattr(con[0], "settimeout"):
address = ("127.0.0.1", 40015)
listensock = socket.socket()
while True:
try:
listensock.bind(address)
listensock.listen(1)
listensock.settimeout(30)
break
except socket.error as exc:
if (hasattr(exc, 'args') and
(exc.args[0] == 10048 or exc.args[0] == 98)):
address = (address[0], address[1] + 1)
else:
raise
if legacy_mode:
botargs = con + " 127.0.0.1 " + str(address[1])
else:
botargs = con + " --server 127.0.0.1 --port " + str(address[1])
if con == "listen":
print("Listening on %s:%s" % address)
proc = None
else:
proc = Popen(botargs, shell=True)
con = listensock.accept()
listensock.close()
self.proc = proc
self.log = log
self.sock = con[0]
self.address = con[1]
self.buf = ""
self.active = True
def __del__(self):
if self.active:
self.cleanup()
def is_running(self):
return self.proc.poll() is None
def send(self, msg):
if self.log is not None:
self.log.debug("Sending to bot: %s" % repr(msg))
self.sock.sendall(msg.encode("utf-8"))
def readline(self, timeout=None):
sock = self.sock
buf = self.buf
if buf:
lineend = find_line_end(buf)
if lineend != -1:
self.buf = buf[lineend + 1:]
return buf[:lineend + 1].strip()
if timeout is None:
endtime = None
sock.settimeout(None)
else:
endtime = time.time() + timeout
response = buf
first = True
while first or endtime is None or time.time() <= endtime:
try:
if endtime is None:
sock.settimeout(None)
else:
wait = endtime - time.time()
if wait < 0:
wait = 0
sock.settimeout(wait)
packet = sock.recv(4096).decode("utf-8")
if self.log:
self.log.debug("Received from bot: %s" % (repr(packet)))
response += packet
if find_line_end(response) != -1:
break
except socket.timeout:
pass
except socket.error as exc:
if (hasattr(exc, 'args') and
(exc.args[0] == 10035 or exc.args[0] == 11)):
pass
else:
raise
first = False
else:
raise socket.timeout()
line = response[:find_line_end(response) + 1]
self.buf = response[len(line):]
return line.strip()
def waitfor(self, expect, timeout=0.5):
endtime = time.time() + timeout
response = []
while time.time() <= endtime:
wait = endtime - time.time()
try:
line = self.readline(timeout=wait)
response.append(line)
if line.lstrip().lower().startswith(expect):
break
except socket.timeout:
pass
else:
raise EngineException("Engine did not respond in alloted time.")
return response
def cleanup(self):
self.active = False
self.sock.close()
if self.proc and self.proc.poll() is None:
if sys.platform == 'win32':
_kill_proc_tree(self.proc.pid)
else:
self.proc.terminate()
stop_time = time.time() + STOP_TIME
while time.time() < stop_time and self.proc.poll() is None:
pass
if self.proc.poll() is None:
self.proc.kill()
def get_engine(channel, cmd, logname=None):
"""Get the appropriate Engine for a given communication channel.
Valid channel types are 'stdio', 'socket' and '2008cc'
"""
if logname is not None:
log = logging.getLogger(logname)
else:
log = None
if channel == "stdio":
engine = StdioEngine(cmd, log=log)
elif channel == "socket":
engine = SocketEngine(cmd, log=log)
elif channel == "2008cc":
engine = SocketEngine(cmd, legacy_mode=True, log=log)
else:
raise ValueError("Unrecognized channel given to get_engine (%s)" %
channel)
return engine
class EngineResponse:
def __init__(self, msg_type):
self.type = msg_type
class EngineController:
def __init__(self, engine):
self.engine = engine
try:
engine.send("aei\n")
except IOError:
raise EngineException("Could not send initial message to engine.")
try:
response = engine.waitfor("aeiok", START_TIME)
except socket.timeout:
raise EngineException("No aeiok received from engine.")
self.protocol_version = 0
if response[0].lstrip().startswith("protocol-version"):
version = response[0].lstrip().split()[1].strip()
response = response[1:]
self.protocol_version = 1
if engine.log:
if version != "1":
engine.log.warn(
"Unrecognized protocol version from engine, %s." %
(version, ))
engine.log.info("Setting aei protocol to version 1")
self.ident = dict()
for line in response:
line = line.lstrip()
if line.startswith('id'):
var, val = line[2:].strip().split(None, 1)
self.ident[var] = val
self.isready(INIT_TIME)
def cleanup(self):
self.engine.cleanup()
def is_running(self):
return self.engine.is_running()
def _parse_resp(self, rstr):
resp = EngineResponse(rstr.split()[0].lower())
if resp.type == "info":
resp.message = rstr[rstr.find("info") + len("info"):].strip()
if resp.type == "log":
resp.message = rstr[rstr.find("log") + len("log"):].strip()
if resp.type == "bestmove":
resp.move = rstr[rstr.find("bestmove") + len("bestmove"):].strip()
return resp
def get_response(self, timeout=None):
rstr = self.engine.readline(timeout=timeout)
if rstr == "":
raise socket.timeout()
return self._parse_resp(rstr)
def isready(self, timeout=15):
self.engine.send("isready\n")
rstrs = self.engine.waitfor("readyok", timeout)
if rstrs[-1].strip().lower() != "readyok":
raise EngineException("Unexpected final response to isready (%s)" %
(rstrs[-1], ))
responses = []
for rstr in rstrs[:-1]:
responses.append(self._parse_resp(rstr))
return responses
def newgame(self):
self.engine.send("newgame\n")
def makemove(self, move):
self.engine.send("makemove %s\n" % (move))
def setposition(self, pos):
side_colors = "wb"
if self.protocol_version != 0:
side_colors = "gs"
self.engine.send("setposition %s %s\n" % (side_colors[pos.color],
pos.board_to_str("short")))
def go(self, searchtype=None):
gocmd = ["go"]
if searchtype == "ponder":
gocmd.append(" ponder")
gocmd.append("\n")
gocmd = "".join(gocmd)
self.engine.send(gocmd)
def stop(self):
self.engine.send("stop\n")
def setoption(self, name, value=None):
setoptcmd = "setoption name %s" % (name, )
if value is not None:
setoptcmd += " value %s" % (value, )
self.engine.send(setoptcmd + "\n")
def quit(self):
self.engine.send("quit\n") | AEI | /AEI-1.3.0.tar.gz/AEI-1.3.0/pyrimaa/aei.py | aei.py |
import re
def _parse_timefield(full_field, start_unit="m"):
unit_order = " smhd"
units = {"s": 1, "m": 60, "h": 60 * 60, "d": 60 * 60 * 24}
num_re = re.compile("[0-9]+")
units[":"] = units[start_unit]
seconds = 0
field = full_field
if field.startswith(":"):
field = "0" + field
nmatch = num_re.match(field)
while nmatch:
end = nmatch.end()
num = int(field[:end])
if len(field) == end or field[end] == ":":
sep = start_unit
start_unit = unit_order[unit_order.find(start_unit) - 1]
else:
sep = field[end]
if sep not in units:
raise ValueError("Invalid time unit encountered %s" % (sep))
seconds += num * units[sep]
if ":" in units:
del units[":"]
field = field[end + 1:]
nmatch = num_re.match(field)
if field:
raise ValueError("Invalid time field encountered %s" % (full_field))
return seconds
def _time_str(seconds):
units = [("d", 60 * 60 * 24), ("h", 60 * 60), ("m", 60)]
out = list()
for tag, length in units:
span = seconds // length
if span != 0:
out.append("%s%s" % (int(span), tag))
seconds -= span * length
if seconds != 0:
out.append("%gs" % (seconds, ))
if len(out) == 0:
out = ["0"]
return "".join(out)
field_re = re.compile("[^/]*")
class TimeControl(object):
def __init__(self, tc_str):
def _split_tc(tstr):
fmatch = field_re.match(tc_str)
if not fmatch:
f_str = tstr
rest = ""
else:
end = fmatch.end()
f_str = tstr[:end]
rest = tstr[end + 1:]
return (f_str, rest)
f_str, tc_str = _split_tc(tc_str)
self.move = _parse_timefield(f_str)
f_str, tc_str = _split_tc(tc_str)
if not f_str:
raise ValueError("Initial reserve time not specified")
self.reserve = _parse_timefield(f_str)
f_str, tc_str = _split_tc(tc_str)
if f_str:
self.percent = int(f_str)
else:
self.percent = 100
f_str, tc_str = _split_tc(tc_str)
self.max_reserve = _parse_timefield(f_str)
f_str, tc_str = _split_tc(tc_str)
if f_str and f_str[-1] == 't':
self.turn_limit = int(f_str[:-1])
self.time_limit = 0
else:
self.turn_limit = 0
self.time_limit = _parse_timefield(f_str, "h")
self.max_turntime = _parse_timefield(tc_str)
def __str__(self):
out = [_time_str(self.move), _time_str(self.reserve)]
out.append(str(self.percent))
out.append(_time_str(self.max_reserve))
if self.turn_limit:
out.append("%st" % (self.turn_limit, ))
else:
out.append(_time_str(self.time_limit))
out.append(_time_str(self.max_turntime))
defaults = (None, None, "100", "0", "0", "0")
while out[-1] == defaults[-1]:
out = out[:-1]
defaults = defaults[:-1]
if out == ["0", "0", "0"]:
out = ["0", "0", "0", "0"]
return "/".join(out) | AEI | /AEI-1.3.0.tar.gz/AEI-1.3.0/pyrimaa/util.py | util.py |
import logging
import time
import socket
from collections import defaultdict
from pyrimaa.board import BLANK_BOARD, Color, IllegalMove, Position
log = logging.getLogger("game")
class Game(object):
def __init__(self, gold, silver,
timecontrol=None,
start_position=None,
strict_setup=True,
min_timeleft=None):
self.engines = (gold, silver)
try:
self.timecontrol = timecontrol[0]
self.side_tc = timecontrol
except TypeError:
self.timecontrol = timecontrol
self.side_tc = [timecontrol, timecontrol]
self.reserves = [None, None]
if timecontrol:
for side, eng in enumerate(self.engines):
if not self.side_tc[side]:
continue
self.reserves[side] = self.side_tc[side].reserve
eng.setoption("tcmove", self.side_tc[side].move)
eng.setoption("tcreserve", self.side_tc[side].reserve)
eng.setoption("tcpercent", self.side_tc[side].percent)
eng.setoption("tcmax", self.side_tc[side].max_reserve)
eng.setoption("tcturns", self.side_tc[side].turn_limit)
eng.setoption("tctotal", self.side_tc[side].time_limit)
eng.setoption("tcturntime", self.side_tc[side].max_turntime)
for eng in self.engines:
eng.newgame()
if start_position:
eng.setposition(start_position)
resps = eng.isready()
side = "gs" [self.engines.index(eng)]
eng_name = eng.ident["name"]
for response in resps:
if response.type == "info":
log.info("%s (%s) info: %s", eng_name, side,
response.message)
elif response.type == "log":
log.info("%s (%s) log: %s", eng_name, side,
response.message)
else:
log.warn(
"Unexpected response while initializing %s (%s) (%s).",
eng_name, side, response.type)
self.insetup = False
self.position = start_position
if not start_position:
self.insetup = True
self.position = Position(Color.GOLD, 4, BLANK_BOARD)
self.strict_setup = strict_setup
self.min_timeleft = min_timeleft
self.movenumber = 1
self.limit_winner = 1
self.moves = []
self.repetition_count = defaultdict(int)
self.result = None
def play(self):
if self.result:
raise RuntimeError("Tried to play a game that was already played.")
starttime = time.time()
while not self.position.is_end_state() or self.insetup:
try:
result = self.play_next_move(starttime)
if result:
break
except IllegalMove as e:
log.info("Illegal move played: %s" % e)
result = (self.position.color ^ 1, "i")
break
if not result:
if self.position.is_goal():
result = (0 - min(self.position.is_goal(), 0), "g")
elif self.position.is_rabbit_loss():
result = (0 - min(self.position.is_rabbit_loss(), 0), "e")
else: # immobilization
assert len(self.position.get_steps()) == 0
result = (self.position.color ^ 1, "m")
self.result = result
return result
def play_next_move(self, starttime):
position = self.position
side = position.color
engine = self.engines[side]
tc = self.side_tc[side]
if tc:
if tc.time_limit:
endtime_limit = starttime + tc.time_limit
if engine.protocol_version == 0:
if self.reserves[0] is not None:
engine.setoption("wreserve", int(self.reserves[0]))
if self.reserves[1] is not None:
engine.setoption("breserve", int(self.reserves[1]))
engine.setoption("tcmoveused", 0)
if self.reserves[0] is not None:
engine.setoption("greserve", int(self.reserves[0]))
if self.reserves[1] is not None:
engine.setoption("sreserve", int(self.reserves[1]))
engine.setoption("moveused", 0)
movestart = time.time()
engine.go()
if tc:
timeout = movestart + tc.move + self.reserves[side]
if tc.max_turntime and movestart + tc.max_turntime < timeout:
timeout = movestart + tc.max_turntime
if tc.time_limit and endtime_limit < timeout:
timeout = endtime_limit
else:
timeout = None
waittime = None
resp = None
stopsent = False
stoptime = None
if timeout and self.min_timeleft:
stoptime = timeout - self.min_timeleft
while True:
now = time.time()
if stoptime and not stopsent and now >= stoptime:
# try and get a move before time runs out
engine.stop()
log.info("Engine sent stop command to prevent timeout")
stopsent = True
if timeout and now > timeout:
if not stopsent:
engine.stop()
break
if timeout:
waittime = timeout - now
if stoptime and not stopsent and now + waittime > stoptime:
waittime = max(0, (stoptime - now) + 0.2)
try:
resp = engine.get_response(waittime)
if resp.type == "bestmove":
break
if resp.type == "info":
log.info("%s (%s) info: %s", engine.ident["name"],
"gs" [side], resp.message)
elif resp.type == "log":
log.info("%s (%s) log: %s", engine.ident["name"],
"gs" [side], resp.message)
except socket.timeout:
pass
moveend = time.time()
if tc and moveend > timeout:
if tc.time_limit and endtime_limit < moveend:
return (self.limit_winner, "s")
else:
return (side ^ 1, "t")
if not resp or resp.type != "bestmove": # pragma: no cover
raise RuntimeError(
"Stopped waiting without a timeout or a move")
if tc:
if not self.insetup:
reserve_change = tc.move - (moveend - movestart)
if reserve_change > 0:
# if we are adding to the reserve only apply the
# percentage specified by the time control
reserve_change *= tc.percent / 100.0
self.reserves[side] += reserve_change
if tc.max_reserve:
self.reserves[side] = min(self.reserves[side],
tc.max_reserve)
move = resp.move
if move.lower() == "resign":
return (side ^ 1, "r")
self.moves.append("%d%s %s" % (self.movenumber,
"gs" [position.color], move))
if self.insetup:
position = position.do_move_str(
move,
strict_checks=self.strict_setup)
else:
position = position.do_move_str(move)
if position.bitBoards == self.position.bitBoards:
raise IllegalMove("Tried move that did not change the position, %s" % move)
self.repetition_count[position] += 1
if self.repetition_count[position] > 2:
raise IllegalMove("Tried move resulting in a 3rd time repetition")
self.position = position
if position.color == Color.GOLD:
self.movenumber += 1
log.debug("position:\n%s", position.board_to_str())
for eng in self.engines:
eng.makemove(move)
if self.insetup and side == Color.SILVER:
self.insetup = False
if not self.insetup:
bstr = position.board_to_str("short")
gp = 0
for p in "EMHDCR":
gp += bstr.count(p)
sp = 0
for p in "emhdcr":
sp += bstr.count(p)
if gp > sp:
limit_winner = 0
elif sp > gp:
limit_winner = 1
if tc and tc.turn_limit and self.movenumber > tc.turn_limit:
return (limit_winner, "s") | AEI | /AEI-1.3.0.tar.gz/AEI-1.3.0/pyrimaa/game.py | game.py |
from __future__ import print_function
import logging
import socket
import sys
import time
from argparse import ArgumentParser
try:
from ConfigParser import SafeConfigParser, NoOptionError
ConfigParser = SafeConfigParser
except ModuleNotFoundError:
from configparser import ConfigParser, NoOptionError
from pyrimaa import aei, board
log = logging.getLogger("analyze")
class ParseError(Exception):
pass
def parse_start(start_lines, stop_move=None):
start_lines = [l.strip() for l in start_lines]
start_lines = [l for l in start_lines if l]
while start_lines and not start_lines[0][0].isdigit():
del start_lines[0]
if not start_lines:
raise ParseError("No board or moves")
if len(start_lines) < 2 or start_lines[1][0] != '+':
have_board = False
start = []
while start_lines and start_lines[0][0].isdigit():
move = start_lines.pop(0)
if stop_move and move.startswith(stop_move):
break
start.append(move)
else:
movenum, start = board.parse_long_pos(start_lines)
have_board = True
return have_board, start
def get_config(args=None):
class NotSet:
pass
notset = NotSet()
parser = ArgumentParser(description="Analyze a given position.")
parser.add_argument("-b", "--bot",
help="Which engine to use in config file")
parser.add_argument("-c", "--config",
default="analyze.cfg",
help="Configuration file to use.")
parser.add_argument("--log", help="Set log output level.")
parser.add_argument("--strict-checks",
action="store_true",
default=notset,
help="Use strict checking on move legality")
parser.add_argument("--skip-checks",
action="store_false",
dest="strict_checks",
help="Skip extra legality checks for moves")
parser.add_argument(
"--strict-setup",
action="store_true",
default=notset,
help="Require the setup moves to be complete and legal")
parser.add_argument(
"--allow-setup",
dest="strict_setup",
action="store_false",
help="Allow incomplete or otherwise illegal setup moves")
parser.add_argument("position_file", help="File with board or move list")
parser.add_argument("move_number", help="Move to analyze", nargs="?")
args = parser.parse_args(args)
config = ConfigParser()
if config.read(args.config) != [args.config]:
print("Could not open '%s'" % (args.config, ))
sys.exit(1)
try:
loglevel = config.get("global", "log_level")
except NoOptionError:
loglevel = None
loglevel = loglevel if args.log is None else args.log
if loglevel is not None:
loglevel = logging.getLevelName(loglevel)
if not isinstance(loglevel, int):
print("Bad log level \"%s\", use ERROR, WARNING, INFO or DEBUG." % (
loglevel,
))
sys.exit(1)
logging.basicConfig(level=loglevel)
if args.strict_checks is notset:
try:
args.strict_checks = config.getboolean("global", "strict_checks")
except NoOptionError:
args.strict_checks = False
if args.strict_setup is notset:
try:
args.strict_setup = config.getboolean("global", "strict_setup")
except NoOptionError:
args.strict_setup = None
try:
args.search_position = config.getboolean("global", "search_position")
except NoOptionError:
args.search_position = True
if args.bot is None:
args.bot = config.get("global", "default_engine")
cfg_sections = config.sections()
if args.bot not in cfg_sections:
print("Engine configuration for %s not found in config." % (args.bot, ))
print("Available configs are:", end=' ')
for section in cfg_sections:
if section != "global":
print(section, end=' ')
print()
sys.exit(1)
try:
args.com_method = config.get(args.bot, "communication_method").lower()
except NoOptionError:
args.com_method = "stdio"
try:
args.enginecmd = config.get(args.bot, "cmdline")
except NoOptionError:
print("No engine command line found in config file.")
print("Add cmdline option for engine %s" % (args.bot, ))
sys.exit(1)
args.bot_options = list()
for option in config.options(args.bot):
if option.startswith("bot_"):
value = config.get(args.bot, option)
args.bot_options.append((option[4:], value))
args.post_options = list()
for option in config.options(args.bot):
if option.startswith("post_pos_"):
value = config.get(args.bot, option)
args.post_options.append((option[9:], value))
return args
def main(args=None):
try:
cfg = get_config(args)
except SystemExit as exc:
return exc.code
with open(cfg.position_file, 'r') as pfile:
plines = pfile.readlines()
try:
have_board, start = parse_start(plines, cfg.move_number)
except ParseError:
print("File %s does not appear to be a board or move list." % (
cfg.position_file,
))
return 0
if cfg.strict_checks:
print("Enabling full legality checking on moves")
if cfg.strict_setup is not None:
if cfg.strict_setup:
print("Enabling full legality checking on setup")
else:
print("Disabling full legality checking on setup")
eng_com = aei.get_engine(cfg.com_method, cfg.enginecmd, "analyze.aei")
try:
eng = aei.EngineController(eng_com)
except aei.EngineException as exc:
print(exc.message)
print("Bot probably did not start. Is the command line correct?")
eng_com.cleanup()
return 1
try:
for option, value in cfg.bot_options:
eng.setoption(option, value)
eng.newgame()
if have_board:
pos = start
eng.setposition(pos)
else:
pos = board.Position(board.Color.GOLD, 4, board.BLANK_BOARD)
for mnum, full_move in enumerate(start):
move = full_move[3:]
if mnum < 2 and cfg.strict_setup is not None:
do_checks = cfg.strict_setup
else:
do_checks = cfg.strict_checks
try:
pos = pos.do_move_str(move, do_checks)
except board.IllegalMove as exc:
print("Illegal move found \"%s\", %s" % (full_move, exc))
return 1
eng.makemove(move)
print(pos.board_to_str())
for option, value in cfg.post_options:
eng.setoption(option, value)
if cfg.search_position:
eng.go()
while True:
try:
resp = eng.get_response(10)
if resp.type == "info":
print(resp.message)
elif resp.type == "log":
print("log: %s" % (resp.message, ))
elif resp.type == "bestmove":
print("bestmove: %s" % (resp.move, ))
break
except socket.timeout:
if not cfg.search_position:
break
finally:
eng.quit()
stop_waiting = time.time() + 20
while time.time() < stop_waiting:
try:
resp = eng.get_response(1)
if resp.type == "info":
print(resp.message)
elif resp.type == "log":
print("log: %s" % (resp.message, ))
except socket.timeout:
try:
eng.quit()
except IOError:
pass
if not eng.is_running():
break
eng.cleanup()
return 0
if __name__ == "__main__":
main() | AEI | /AEI-1.3.0.tar.gz/AEI-1.3.0/pyrimaa/analyze.py | analyze.py |
import sys
import time
try:
import exceptions
AttributeError = exceptions.AttributeError
from Queue import Queue, Empty
except ModuleNotFoundError:
from queue import Queue, Empty
from threading import Thread, Event
from pyrimaa.board import (BASIC_SETUP, BLANK_BOARD, Color, parse_short_pos,
Position, IllegalMove)
class _ComThread(Thread):
def __init__(self):
Thread.__init__(self)
self.stop = Event()
self.messages = Queue()
self.setDaemon(True)
def send(self, msg):
sys.stdout.write(msg + "\n")
sys.stdout.flush()
def run(self):
while not self.stop.isSet():
try:
msg = sys.stdin.readline()
except AttributeError:
# during shutdown sys will change to None
return
self.messages.put(msg.strip())
class AEIException(Exception):
pass
class AEIEngine(object):
def __init__(self, controller):
self.strict_checks = True
self.move_delay = None
self.total_move_time = 0.0
self.controller = controller
try:
header = controller.messages.get(30)
except Empty:
raise AEIException("Timed out waiting for aei header")
if header != "aei":
raise AEIException("Did not receive aei header, instead (%s)" %
(header))
controller.send("protocol-version 1")
controller.send("id name Sample Engine")
controller.send("id author Janzert")
controller.send("aeiok")
self.newgame()
def newgame(self):
self.position = Position(Color.GOLD, 4, BLANK_BOARD)
self.insetup = True
def setposition(self, side_str, pos_str):
side = "gswb".find(side_str) % 2
self.position = parse_short_pos(side, 4, pos_str)
self.insetup = False
def setoption(self, name, value):
std_opts = set(["tcmove", "tcreserve", "tcpercent", "tcmax", "tctotal",
"tcturns", "tcturntime", "greserve", "sreserve",
"gused", "sused", "lastmoveused", "moveused",
"opponent", "opponent_rating"])
if name == "checkmoves":
self.strict_checks = value.lower().strip() not in ["false", "no", "0"]
elif name == "delaymove":
self.move_delay = float(value)
elif name not in std_opts:
self.log("Warning: Received unrecognized option, %s" % (name))
def makemove(self, move_str):
try:
self.position = self.position.do_move_str(move_str,
self.strict_checks)
except IllegalMove as exc:
self.log("Error: received illegal move %s" % (move_str,))
return False
if self.insetup and self.position.color == Color.GOLD:
self.insetup = False
return True
def go(self):
pos = self.position
start_time = time.time()
if self.insetup:
setup = Position(Color.GOLD, 4, BASIC_SETUP)
setup_moves = setup.to_placing_move()
move_str = setup_moves[pos.color][2:]
else:
steps, result = pos.get_rnd_step_move()
if steps is None:
# we are immobilized, return an empty move
move_str = ""
self.log("Warning: move requested when immobilized.")
else:
move_str = pos.steps_to_str(steps)
if self.move_delay:
time.sleep(self.move_delay)
move_time = time.time() - start_time
self.total_move_time += move_time
self.info("time %d" % (int(round(move_time),)))
self.bestmove(move_str)
def info(self, msg):
self.controller.send("info " + msg)
def log(self, msg):
self.controller.send("log " + msg)
def bestmove(self, move_str):
self.controller.send("bestmove " + move_str)
def main(self):
ctl = self.controller
while not ctl.stop.isSet():
msg = ctl.messages.get()
if msg == "isready":
ctl.send("readyok")
elif msg == "newgame":
self.newgame()
elif msg.startswith("setposition"):
side, pos_str = msg.split(None, 2)[1:]
self.setposition(side, pos_str)
elif msg.startswith("setoption"):
words = msg.split()
name = words[2]
v_ix = msg.find(name) + len(name)
v_ix = msg.find("value", v_ix)
if v_ix != -1:
value = msg[v_ix + 5:]
else:
value = None
self.setoption(name, value)
elif msg.startswith("makemove"):
move_str = msg.split(None, 1)[1]
if not self.makemove(move_str):
return
elif msg.startswith("go"):
if len(msg.split()) == 1:
self.go()
elif msg == "stop":
pass
elif msg == "quit":
self.log("Debug: Exiting after receiving quit message.")
if self.total_move_time > 0:
self.info("move gen time %f" % (self.total_move_time,))
return
def main():
ctl = _ComThread()
ctl.start()
try:
eng = AEIEngine(ctl)
eng.main()
finally:
ctl.stop.set()
if __name__ == "__main__":
main() | AEI | /AEI-1.3.0.tar.gz/AEI-1.3.0/pyrimaa/simple_engine.py | simple_engine.py |
# Copyright (c) 2009-2015 Brian Haskin Jr.
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
from __future__ import print_function
import logging
import re
import socket
import sys
import time
from argparse import ArgumentParser
try:
from ConfigParser import SafeConfigParser, NoOptionError
ConfigParser = SafeConfigParser
except ModuleNotFoundError:
from configparser import ConfigParser, NoOptionError
xrange = range
from pyrimaa import aei
from pyrimaa.game import Game
from pyrimaa.util import TimeControl
log = logging.getLogger("roundrobin")
class ConfigError(Exception):
pass
def run_bot(bot, config, global_options):
cmdline = config.get(bot['name'], "cmdline")
if config.has_option(bot['name'], "communication_method"):
com_method = config.get(bot['name'], "communication_method").lower()
else:
com_method = "stdio"
eng_com = aei.get_engine(com_method, cmdline, "roundrobin.aei")
engine = aei.EngineController(eng_com)
for option, value in global_options:
engine.setoption(option, value)
for name, value in config.items(bot['name']):
if name.startswith("bot_"):
engine.setoption(name[4:], value)
return engine
def format_time(seconds):
hours = int(seconds / 3600)
seconds -= hours * 3600
minutes = int(seconds / 60)
seconds -= minutes * 60
fmt_tm = []
if hours:
fmt_tm.append("%dh" % hours)
if minutes or fmt_tm:
fmt_tm.append("%dm" % minutes)
fmt_tm.append("%ds" % seconds)
return "".join(fmt_tm)
def get_config(args=None):
class NotSet:
pass
notset = NotSet()
parser = ArgumentParser(
description="Play engines in a round robin tournament.")
parser.add_argument("--config",
default="roundrobin.cfg",
help="Configuration file to use")
parser.add_argument("--log", help="Set log output level")
parser.add_argument("--pgn", help="PGN results filename")
parser.add_argument("-r", "--rounds",
type=int,
help="Number of rounds to run")
parser.add_argument(
"--stop-time",
type=int,
help="Number of seconds to leave when sending a bot a stop command")
parser.add_argument(
"--strict-setup",
action="store_true",
default=notset,
help="Require the setup moves to be complete and legal")
parser.add_argument(
"--allow-setup",
dest="strict_setup",
action="store_false",
help="Allow incomplete or otherwise illegal setup moves")
parser.add_argument("--timecontrol", "--tc", help="Timecontrol to use")
parser.add_argument("bots", nargs="*", help="Bots to use in tournament")
args = parser.parse_args(args)
config = ConfigParser()
if config.read(args.config) != [args.config]:
raise ConfigError("Could not open '%s'" % (args.config, ))
args.ini = config
args.bot_sections = set(config.sections())
if "global" not in args.bot_sections:
raise ConfigError("Did not find expected 'global' section in configuration file.")
args.bot_sections.remove('global')
try:
loglevel = config.get("global", "loglevel")
except NoOptionError:
loglevel = None
loglevel = loglevel if args.log is None else args.log
if loglevel is not None:
loglevel = logging.getLevelName(loglevel)
if not isinstance(loglevel, int):
print("Bad log level %s, use ERROR, WARNING, INFO or DEBUG." % (
loglevel,
))
logging.basicConfig(level=loglevel)
if args.pgn is None:
try:
args.pgn = config.get("global", "pgn_filename")
except:
pass
if args.rounds is None:
try:
args.rounds = config.getint("global", "rounds")
except NoOptionError:
pass
if args.timecontrol is None:
try:
args.timecontrol = config.get("global", "timecontrol")
except NoOptionError:
pass
if args.strict_setup is notset:
try:
args.strict_setup = config.getboolean("global", "strict_setup")
except NoOptionError:
args.strict_setup = None
if args.stop_time is None:
try:
args.stop_time = config.getint("global", "stop_time")
except NoOptionError:
pass
if len(args.bots) == 0:
try:
args.bots = config.get("global", "bots").split()
except NoOptionError:
args.bots = args.bot_sections
args.global_options = list()
for option, value in config.items("global"):
if option.startswith("bot_"):
args.global_options.append((option[4:], value))
return args
def main(args=None):
try:
cfg = get_config(args)
except ConfigError as exc:
print(exc)
return 1
if cfg.rounds:
print("Number of rounds: %d" % (cfg.rounds, ))
else:
print("Number of rounds not specified, running 1 round.")
cfg.rounds = 1
try:
tctl_str = cfg.timecontrol
if tctl_str.lower() == "none":
timecontrol = None
else:
timecontrol = TimeControl(tctl_str)
print("At timecontrol %s" % (tctl_str, ))
except NoOptionError:
timecontrol = None
if cfg.global_options:
print("Giving these settings to all bots:")
for name, value in cfg.global_options:
print(" %s: %s" % (name, value))
print("Playing bots: ", end='')
for bot in cfg.bots:
print(bot, end=' ')
print()
# setup to write a bayeselo compatible pgn file
write_pgn = False
if cfg.pgn is not None:
try:
pgn_file = open(cfg.pgn, "a+")
except IOError:
print("Could not open pgn file %s" % (cfg.pgn, ))
return 1
print("Writing results to pgn file: %s" % (cfg.pgn, ))
write_pgn = True
bots = []
for bname in cfg.bots:
for bsection in cfg.bot_sections:
if bname.lower() == bsection.lower():
bot_options = []
for name, value in cfg.ini.items(bsection):
if name.startswith("bot_"):
bot_options.append((name[4:], value))
bot = {
'name': bsection,
'options': bot_options,
'gold': 0,
'wins': 0,
'timeouts': 0,
'reasons': dict()
}
if cfg.ini.has_option(bsection, "timecontrol"):
tctl_str = cfg.ini.get(bsection, "timecontrol")
if tctl_str.lower() == "none":
tc = None
else:
tc = TimeControl(tctl_str)
print("bot %s at timecontrol %s" % (bsection, tctl_str))
bot['timecontrol'] = tc
bots.append(bot)
break
else:
print("Did not find a bot section for %s" % (bname))
return 1
start_time = time.time()
for round_num in xrange(cfg.rounds):
for bot_ix, bot in enumerate(bots[:-1]):
for opp in bots[bot_ix + 1:]:
if bot['gold'] <= opp['gold']:
gbot = bot
sbot = opp
else:
gbot = opp
sbot = bot
gbot['gold'] += 1
gengine = run_bot(gbot, cfg.ini, cfg.global_options)
sengine = run_bot(sbot, cfg.ini, cfg.global_options)
tc = [timecontrol, timecontrol]
if 'timecontrol' in gbot:
tc[0] = gbot['timecontrol']
if 'timecontrol' in sbot:
tc[1] = sbot['timecontrol']
game = Game(gengine, sengine, tc,
strict_setup=cfg.strict_setup,
min_timeleft=cfg.stop_time)
wside, reason = game.play()
gengine.quit()
sengine.quit()
winner = [gbot, sbot][wside]
loser = [gbot, sbot][wside ^ 1]
# Display result of game
print("%d%s" % (game.movenumber, "gs" [game.position.color]))
print(game.position.board_to_str())
print("%s beat %s because of %s playing side %s" % (
winner['name'], loser['name'], reason, "gs" [wside]
))
# Record game result stats
winner['wins'] += 1
if reason == 't':
[gbot, sbot][wside ^ 1]['timeouts'] += 1
winner['reasons'][reason] = winner['reasons'].get(reason, 0) + 1
# write game result to pgn file
if write_pgn:
ply_count = game.movenumber * 2
if game.position.color:
ply_count -= 1
else:
ply_count -= 2
results = ['1-0', '0-1']
pgn_file.write('[White "%s"]\n' % (gbot['name'], ))
pgn_file.write('[Black "%s"]\n' % (sbot['name'], ))
if timecontrol:
pgn_file.write('[TimeControl "%s"]\n' % (tctl_str, ))
pgn_file.write('[PlyCount "%s"]\n' % (ply_count, ))
pgn_file.write('[ResultCode "%s"]\n' % (reason, ))
pgn_file.write('[Result "%s"]\n' % (results[wside], ))
pgn_file.write('\n')
for move in game.moves:
pgn_file.write('%s\n' % (move, ))
pgn_file.write('%s\n\n' % (results[wside]))
pgn_file.flush()
# give the engines up to 30 more seconds to exit normally
for i in range(30):
if (not gengine.is_running() and not sengine.is_running()):
break
time.sleep(1)
gengine.cleanup()
sengine.cleanup()
round_end = time.time()
total_time = round_end - start_time
print("After round %d and %s:" % (round_num + 1,
format_time(total_time)))
for bot in bots:
print("%s has %d wins and %d timeouts" % (bot['name'], bot['wins'],
bot['timeouts']))
for name, value in bot['reasons'].items():
print(" %d by %s" % (value, name))
return 0
if __name__ == "__main__":
sys.exit(main()) | AEI | /AEI-1.3.0.tar.gz/AEI-1.3.0/pyrimaa/roundrobin.py | roundrobin.py |
import logging
import optparse
import os.path
import sys
import time
try:
from ConfigParser import Error as ConfigError
from ConfigParser import SafeConfigParser as ConfigParser
except ModuleNotFoundError:
from configparser import Error as ConfigError
from configparser import ConfigParser
from pyrimaa import gameroom
log = logging.getLogger("postal")
def main(args=sys.argv):
opt_parser = optparse.OptionParser(
usage="usage: %prog [-c CONFIG] [-b BOT]",
description="Manage bot playing multiple postal games.")
opt_parser.add_option('-c', '--config',
default="gameroom.cfg",
help="Configuration file to use.")
opt_parser.add_option('-b', '--bot',
help="Bot section to use as the default.")
options, args = opt_parser.parse_args(args)
if len(args) > 1:
print("Unrecognized command line arguments: %s" % (args[1:], ))
return 1
config = ConfigParser()
read_files = config.read(options.config)
if len(read_files) == 0:
print("Could not open '%s'." % (options.config, ))
return 1
try:
log_dir = config.get("postal", "log_dir")
except ConfigError:
try:
log_dir = config.get("Logging", "directory")
except ConfigError:
log_dir = "."
if not os.path.exists(log_dir):
print("Log directory '%s' not found, attempting to create it." % (
log_dir
))
os.makedirs(log_dir)
try:
log_filename = config.get("postal", "log_file")
except ConfigError:
log_filename = "postal-" + time.strftime("%Y-%m") + ".log"
log_path = os.path.join(log_dir, log_filename)
logfmt = logging.Formatter(fmt="%(asctime)s %(levelname)s: %(message)s",
datefmt="%Y-%m-%d %H:%M:%S")
loghandler = logging.FileHandler(log_path)
loghandler.setFormatter(logfmt)
log.addHandler(loghandler)
consolehandler = logging.StreamHandler()
consolehandler.setFormatter(logfmt)
log.addHandler(consolehandler)
log.propagate = False
gameroom.init_logging(config)
gameroom_url = config.get("global", "gameroom_url")
if options.bot:
bot_section = options.bot
else:
bot_section = config.get("global", "default_engine")
try:
bot_username = config.get(bot_section, "username")
bot_password = config.get(bot_section, "password")
except ConfigError:
try:
bot_username = config.get("global", "username")
bot_password = config.get("global", "password")
except NoOptionError:
log.error("Could not find username/password in config.")
return 1
while True:
try:
open("stop_postal", 'r')
log.info("Exiting after finding stop file")
return 0
except IOError:
pass
gr_con = gameroom.GameRoom(gameroom_url)
gr_con.login(bot_username, bot_password)
games = gr_con.mygames()
gr_con.logout()
total_games = len(games)
games = [g for g in games if g['postal'] == '1']
postal_games = len(games)
games = [g for g in games if g['turn'] == g['side']]
my_turn_games = len(games)
log.info("Found %d games with %d postal games and %d on my turn." %
(total_games, postal_games, my_turn_games))
if games:
games.sort(key=lambda x: x['turnts'])
for game_num, game in enumerate(games):
try:
open("stop_postal", 'r')
log.info("Exiting after finding stop file")
return 0
except IOError:
pass
log.info("%d/%d: Playing move against %s game #%s" %
(game_num + 1, my_turn_games, game['player'],
game['gid']))
game_args = ["gameroom", "move", game['gid'], game['side']]
if config.has_option("postal", game['gid']):
section = config.get("postal", game['gid'])
game_args += ["-b", section]
log.info("Using section %s for use with gid #%s" %
(section, game['gid']))
elif config.has_option("postal", game['player']):
section = config.get("postal", game['player'])
game_args += ["-b", section]
log.info("Using section %s for use against %s" %
(section, game['player']))
gmoptions = gameroom.parseargs(game_args)
res = gameroom.run_game(gmoptions, config)
if res is not None and res != 0:
log.warning("Error result from gameroom run %d." % (res, ))
else:
log.info("No postal games with a turn found, sleeping.")
time.sleep(300)
return 0
if __name__ == "__main__":
sys.exit(main()) | AEI | /AEI-1.3.0.tar.gz/AEI-1.3.0/pyrimaa/postal_controller.py | postal_controller.py |
from __future__ import print_function
try:
xrange(1)
except NameError:
xrange = range
import math
import sys
import random
import time
from argparse import ArgumentParser
class Color:
GOLD = 0
SILVER = 1
class Piece:
EMPTY = 0
GRABBIT = 1
GCAT = 2
GDOG = 3
GHORSE = 4
GCAMEL = 5
GELEPHANT = 6
COLOR = 8
SRABBIT = 9
SCAT = 10
SDOG = 11
SHORSE = 12
SCAMEL = 13
SELEPHANT = 14
COUNT = 15
PCHARS = " RCDHMExxrcdhme"
DECOLOR = ~COLOR
ALL_BITS = 0xFFFFFFFFFFFFFFFF
NOT_A_FILE = 0xFEFEFEFEFEFEFEFE
NOT_H_FILE = 0x7F7F7F7F7F7F7F7F
NOT_1_RANK = 0xFFFFFFFFFFFFFF00
NOT_8_RANK = 0x00FFFFFFFFFFFFFF
TRAP_C3_IX = 18
TRAP_F3_IX = 21
TRAP_C6_IX = 42
TRAP_F6_IX = 45
TRAP_C3_BIT = 1 << 18
TRAP_F3_BIT = 1 << 21
TRAP_C6_BIT = 1 << 42
TRAP_F6_BIT = 1 << 45
TRAPS = 0x0000240000240000
BASIC_SETUP = (0x0000FFFFFFFF0000, 0x00000000000000FF, 0x0000000000002400,
0x0000000000008100, 0x0000000000004200, 0x0000000000000800,
0x0000000000001000, None, None, 0xFF00000000000000,
0x0024000000000000, 0x0081000000000000, 0x0042000000000000,
0x0010000000000000, 0x0008000000000000)
BLANK_BOARD = (ALL_BITS, 0, 0, 0, 0, 0, 0, None, None, 0, 0, 0, 0, 0, 0)
def neighbors_of(bits):
""" get the neighboring bits to a set of bits """
bitboard = (bits & NOT_A_FILE) >> 1
bitboard |= (bits & NOT_H_FILE) << 1
bitboard |= (bits & NOT_1_RANK) >> 8
bitboard |= (bits & NOT_8_RANK) << 8
return bitboard
def bit_to_index(bit):
""" get the index of a bit """
cnt = (bit & 0xAAAAAAAAAAAAAAAA) != 0
cnt |= ((bit & 0xCCCCCCCCCCCCCCCC) != 0) << 1
cnt |= ((bit & 0xF0F0F0F0F0F0F0F0) != 0) << 2
cnt |= ((bit & 0xFF00FF00FF00FF00) != 0) << 3
cnt |= ((bit & 0xFFFF0000FFFF0000) != 0) << 4
cnt |= ((bit & 0xFFFFFFFF00000000) != 0) << 5
return cnt
def index_to_alg(cnt):
""" Convert a bit index to algebraic notation """
column = "abcdefgh" [int(cnt % 8)]
rank = "12345678" [int(cnt // 8)]
return column + rank
def alg_to_index(sqr):
""" Convert algebraic notation to a bit index """
index = ord(sqr[0]) - 97
index += (int(sqr[1]) - 1) * 8
return index
def index_to_sq(ix):
"""Convert an index to a column and rank"""
return (ix % 8, ix // 8)
def sq_to_index(column, rank):
"""Convert a column and rank to an index"""
return (rank * 8) + column
MOVE_OFFSETS = [[[], []], [[], []]]
def _generate_move_offsets():
for i in xrange(64):
bit = 1 << i
moves = neighbors_of(bit)
grmoves = moves
if bit & NOT_1_RANK:
grmoves ^= (bit >> 8)
srmoves = moves
if bit & NOT_8_RANK:
srmoves ^= (bit << 8)
MOVE_OFFSETS[0][1].append(moves)
MOVE_OFFSETS[1][1].append(moves)
MOVE_OFFSETS[0][0].append(grmoves)
MOVE_OFFSETS[1][0].append(srmoves)
_generate_move_offsets()
RMOVE_OFFSETS = MOVE_OFFSETS[0][1]
ZOBRIST_KEYS = [[], [], []]
# generate zobrist keys, assuring no duplicate keys or 0
def _zobrist_newkey(used_keys, rnd):
candidate = 0
while candidate in used_keys:
candidate = rnd.randint(-(2**63 - 1), 2**63 - 1)
used_keys.append(candidate)
return candidate
def _generate_zobrist_keys():
rnd = random.Random()
rnd.seed(0xF00F)
used_keys = [0]
ZOBRIST_KEYS[0] = _zobrist_newkey(used_keys, rnd)
for piece in xrange(Piece.COUNT):
ZOBRIST_KEYS[2].append([])
for index in xrange(64):
if piece == Piece.EMPTY:
ZOBRIST_KEYS[2][piece].append(0)
else:
ZOBRIST_KEYS[2][piece].append(_zobrist_newkey(used_keys, rnd))
for step in xrange(5):
ZOBRIST_KEYS[1].append(_zobrist_newkey(used_keys, rnd))
_generate_zobrist_keys()
ZOBRIST_KEYS = ZOBRIST_KEYS[2]
TRAP_NEIGHBORS = neighbors_of(TRAPS)
class IllegalMove(ValueError):
pass
class Position(object):
def __init__(self, side, steps_left, bitboards,
inpush=False,
last_piece=Piece.EMPTY,
last_from=None,
placement=None,
zobrist=None):
self.color = side
self.stepsLeft = steps_left
self.bitBoards = tuple(bitboards)
self.inpush = inpush
self.last_piece = last_piece
self.last_from = last_from
if placement is None:
placement = [0, 0]
for piece in range(Piece.GRABBIT, Piece.GELEPHANT + 1):
placement[Color.GOLD] |= bitboards[piece]
placement[Color.SILVER] |= bitboards[piece | Piece.COLOR]
self.placement = list(placement)
if zobrist is None:
#zobrist = ZOBRIST_KEYS[0][sideMoving] ^ ZOBRIST_KEYS[1][stepsLeft]
zobrist = 0
for piece in xrange(Piece.COUNT):
pieces = bitboards[piece]
while pieces:
pbit = pieces & -pieces
pieces ^= pbit
pix = bit_to_index(pbit)
zobrist ^= ZOBRIST_KEYS[piece][pix]
self._zhash = zobrist
def __eq__(self, other):
try:
#if self._zhash != other._zhash:
# return False
if (self.color != other.color or
self.stepsLeft != other.stepsLeft):
return False
if (self.inpush != other.inpush or
self.last_from != other.last_from or
self.last_piece != other.last_piece):
return False
#if self.placement != other.placement:
# return False
if self.bitBoards != other.bitBoards:
return False
except:
return False
return True
def __ne__(self, other):
return not self.__eq__(other)
def __hash__(self):
return self._zhash
def check_hash(self):
""" Check to make sure the hash is correct """
bitboards = self.bitBoards
# zobrist = ZOBRIST_KEYS[0][sideMoving] ^ ZOBRIST_KEYS[1][stepsLeft]
zobrist = 0
for piece in xrange(Piece.COUNT):
pieces = bitboards[piece]
while pieces:
pbit = pieces & -pieces
pieces ^= pbit
pix = bit_to_index(pbit)
zobrist ^= ZOBRIST_KEYS[piece][pix]
if zobrist != self._zhash:
raise RuntimeError("hash value is incorrect.")
def check_boards(self):
""" Check the internal consistency of the bitboards """
bitboards = self.bitBoards
cplacement = [0, 0]
empty = ALL_BITS
for pnum, pboard in enumerate(bitboards):
if pnum == 0 or pboard is None:
continue
for cnum, cboard in enumerate(bitboards[pnum + 1:]):
if cboard is None:
continue
double = pboard & cboard
if pboard & cboard:
print("%X %X %X %d %d" % (pboard, cboard, double, pnum,
cnum))
raise RuntimeError(
"Two pieces occupy one square: %s %s" %
(Piece.PCHARS[pnum], Piece.PCHARS[cnum]))
if pnum != 0:
if (pnum ^ Piece.COLOR) & Piece.COLOR:
cplacement[0] |= pboard
else:
cplacement[1] |= pboard
empty &= ~pboard
if cplacement != self.placement:
if cplacement[0] != self.placement[0]:
print("gplacement %X %X" % (cplacement[0], self.placement[0]))
if cplacement[1] != self.placement[1]:
print("splacement %X %X" % (cplacement[1], self.placement[1]))
raise RuntimeError("Placement boards are incorrect")
if empty != bitboards[0]:
raise RuntimeError("Empty board is incorrect %X %X" %
(bitboards[0], empty))
def is_goal(self):
""" Check to see if this position is goal for either side """
ggoal = self.bitBoards[Piece.GRABBIT] & ~NOT_8_RANK
sgoal = self.bitBoards[Piece.SRABBIT] & ~NOT_1_RANK
if ggoal or sgoal:
if self.color == Color.GOLD:
if sgoal:
return -1
else:
return 1
else:
if ggoal:
return 1
else:
return -1
else:
return False
def is_rabbit_loss(self):
""" Check that both sides still have rabbits """
grabbits = self.bitBoards[Piece.GRABBIT]
srabbits = self.bitBoards[Piece.SRABBIT]
if not grabbits or not srabbits:
if self.color == Color.GOLD:
if not grabbits:
return -1
else:
return 1
else:
if not srabbits:
return 1
else:
return -1
else:
return False
def is_end_state(self):
goal = self.is_goal()
if goal:
return goal
norabbits = self.is_rabbit_loss()
if norabbits:
return norabbits
if len(self.get_steps()) == 0:
if self.color == Color.GOLD:
return -1
else:
return 1
return False
def _to_long_str(self, dots=True):
bitBoards = self.bitBoards
layout = [" +-----------------+"]
for row in xrange(8, 0, -1):
rows = ["%d| " % row]
rix = 8 * (row - 1)
for col in xrange(8):
ix = rix + col
bit = 1 << ix
if bit & (self.placement[0] | self.placement[1]):
piece = "* "
for pi in xrange(Piece.GRABBIT, Piece.COUNT):
if bitBoards[pi] is not None and bit & bitBoards[pi]:
piece = Piece.PCHARS[pi] + " "
break
rows.append(piece)
else:
if (col == 2 or col == 5) and (row == 3 or row == 6):
rows.append("x ")
else:
if dots:
rows.append(". ")
else:
rows.append(" ")
rows.append("|")
rows = "".join(rows)
layout.append(rows)
layout.append(" +-----------------+")
layout.append(" a b c d e f g h ")
return "\n".join(layout)
def _to_short_str(self):
bitBoards = self.bitBoards
placement = self.placement[0] | self.placement[1]
layout = ["["]
for rank in xrange(7, -1, -1):
rix = rank * 8
for col in xrange(8):
ix = rix + col
bit = 1 << ix
if bit & placement:
piece = "*"
for pi in xrange(Piece.GRABBIT, Piece.COUNT):
if bitBoards[pi] is not None and bit & bitBoards[pi]:
piece = Piece.PCHARS[pi]
break
layout.append(piece)
else:
layout.append(" ")
layout.append("]")
layout = "".join(layout)
return layout
def board_to_str(self, format="long", dots=True):
"""Generate string representation of the board"""
if format == "long":
return self._to_long_str(dots)
elif format == "short":
return self._to_short_str()
else:
raise ValueError("Invalid board format")
def to_placing_move(self, old_colors=False):
""" Generate a placing move string representation of the position """
if old_colors:
color_str = "wb"
else:
color_str = "gs"
whitestr = [color_str[Color.GOLD]]
for piece, pieceBoard in enumerate(
self.bitBoards[Piece.GRABBIT:Piece.GELEPHANT + 1]):
pname = Piece.PCHARS[piece + 1]
while pieceBoard:
bit = pieceBoard & -pieceBoard
pieceBoard ^= bit
pix = bit_to_index(bit)
sqr = index_to_alg(pix)
whitestr.append(pname + sqr)
whitestr = " ".join(whitestr)
blackstr = [color_str[Color.SILVER]]
for piece, pieceBoard in enumerate(
self.bitBoards[Piece.SRABBIT:Piece.SELEPHANT + 1]):
pname = Piece.PCHARS[(piece + 1) | Piece.COLOR]
while pieceBoard:
bit = pieceBoard & -pieceBoard
pieceBoard ^= bit
pix = bit_to_index(bit)
sqr = index_to_alg(pix)
blackstr.append(pname + sqr)
blackstr = " ".join(blackstr)
return (whitestr, blackstr)
def steps_to_str(self, steps):
"""Convert steps to a move string"""
dir_chars = {1: "w", -1: "e", 8: "s", -8: "n"}
pos = self
move_rep = []
for step in steps:
step_rep = []
from_bit = 1 << step[0]
for piece in xrange(Piece.GRABBIT, Piece.COUNT):
if (pos.bitBoards[piece] is not None and
pos.bitBoards[piece] & from_bit):
break
if not pos.bitBoards[piece] & from_bit:
raise ValueError("Tried to move empty piece")
step_rep.append(Piece.PCHARS[piece])
step_rep.append(index_to_alg(step[0]))
direction = step[0] - step[1]
try:
step_rep.append(dir_chars[direction])
except KeyError:
step_rep.append("," + index_to_alg(step[1]))
move_rep.append("".join(step_rep))
npos = pos.do_step(step)
trap = neighbors_of(from_bit) & TRAPS
pcolor = (piece & Piece.COLOR) >> 3
if ((pos.placement[pcolor] & trap or trap &
(1 << step[1])) and npos.bitBoards[Piece.EMPTY] & trap):
tix = bit_to_index(trap)
if tix == step[1]:
tpiece = piece
else:
pcbit = pcolor << 3
for tpiece in xrange(Piece.GRABBIT | pcbit,
(Piece.GELEPHANT | pcbit) + 1):
if (pos.bitBoards[tpiece] is not None and
pos.bitBoards[tpiece] & trap):
break
step_rep = [Piece.PCHARS[tpiece]]
step_rep.append(index_to_alg(tix))
step_rep.append("x")
move_rep.append("".join(step_rep))
pos = npos
return " ".join(move_rep)
def place_piece(self, piece, index):
bit = 1 << index
if not self.bitBoards[Piece.EMPTY] & bit:
raise ValueError("Tried to place a piece on another piece")
newBoards = [b for b in self.bitBoards]
newPlacement = [self.placement[0], self.placement[1]]
newBoards[piece] |= bit
newBoards[Piece.EMPTY] &= ~bit
newPlacement[(piece & Piece.COLOR) >> 3] |= bit
zobrist = self._zhash ^ ZOBRIST_KEYS[piece][index]
return Position(self.color, self.stepsLeft, newBoards,
placement=newPlacement,
zobrist=zobrist)
def remove_piece(self, index):
bit = 1 << index
if self.placement[Color.GOLD] & bit:
side = Color.GOLD
elif self.placement[Color.SILVER] & bit:
side = Color.SILVER
else:
raise ValueError("Tried to remove non-existant piece")
piece = Piece.GRABBIT
while (self.bitBoards[piece] is None or
not (self.bitBoards[piece] & bit)):
piece += 1
newBoards = [b for b in self.bitBoards]
newPlacement = [self.placement[0], self.placement[1]]
newBoards[piece] &= ~bit
newBoards[Piece.EMPTY] |= bit
newPlacement[side] &= ~bit
zobrist = self._zhash ^ ZOBRIST_KEYS[piece][index]
return Position(self.color, self.stepsLeft, newBoards,
placement=newPlacement,
zobrist=zobrist)
def check_step(self, step):
""" check the legality of a step
In the case of an illegal step returns an object that evaluates to
False and will also give an informative str() description for why the
step is invalid.
"""
class BadStep:
def __init__(self, msg):
self.message = msg
def __str__(self):
return self.message
def __bool__(self):
return False
__nonzero__ = __bool__
bitboards = self.bitBoards
placement = self.placement
from_bit = 1 << step[0]
to_bit = 1 << step[1]
if from_bit & bitboards[Piece.EMPTY]:
return BadStep("Tried to move from an empty square")
if not (to_bit & bitboards[Piece.EMPTY]):
return BadStep("Tried to move to a non-empty square")
piece = self.piece_at(from_bit)
direction = step[1] - step[0]
from_neighbors = neighbors_of(from_bit)
pcbit = piece & Piece.COLOR
pcolor = pcbit >> 3
pstrength = piece & Piece.DECOLOR
if not neighbors_of(from_bit) & to_bit:
return BadStep("Tried to move to non-adjacent square")
if pcolor == self.color:
if self.is_frozen_at(from_bit):
return BadStep("Tried to move a frozen piece")
if pstrength == Piece.GRABBIT:
if ((pcolor == Color.GOLD and direction == -8) or
(pcolor == Color.SILVER and direction == 8)):
return BadStep("Tried to move a rabbit back")
if self.inpush:
if self.last_from != step[1]:
return BadStep("Tried to neglect finishing a push")
if pstrength <= self.last_piece & Piece.DECOLOR:
return BadStep("Tried to push with too weak of a piece")
else:
if self.inpush:
return BadStep(
"Tried to move opponent piece while already in push")
if (self.last_piece == Piece.EMPTY or self.last_from != step[1] or
pstrength >= self.last_piece & Piece.DECOLOR):
if self.stepsLeft == 1:
return BadStep("Tried to start a push on the last step")
stronger_and_unfrozen = False
for s in xrange((piece ^ Piece.COLOR) + 1,
(Piece.GELEPHANT | (self.color << 3)) + 1):
if from_neighbors & bitboards[s] & \
(~self.frozen_neighbors(from_bit)):
stronger_and_unfrozen = True
break
if not stronger_and_unfrozen:
return BadStep(
"Tried to push a piece with no pusher around")
return True
def piece_at(self, bit):
""" return the piece type occupying the given square
The bitboard passed in should have exactly one bit set.
"""
bitboards = self.bitBoards
for piece in range(Piece.GRABBIT, Piece.COUNT):
if bitboards[piece] is not None and bitboards[piece] & bit:
return piece
return Piece.EMPTY
def is_frozen_at(self, bit):
""" test if a piece is frozen
The argument bitboard passed in should have exactly one bit set.
"""
bitboards = self.bitBoards
placement = self.placement
neighbors = neighbors_of(bit)
piece = self.piece_at(bit)
pcbit = piece & Piece.COLOR
pcolor = pcbit >> 3
isfrozen = (not neighbors & placement[pcolor] and
neighbors & placement[pcolor ^ 1])
if isfrozen:
isfrozen = False
for s in xrange((piece ^ Piece.COLOR) + 1,
(Piece.GELEPHANT | (pcbit ^ Piece.COLOR)) + 1):
if neighbors & bitboards[s]:
return True
return False
def frozen_neighbors(self, bits):
""" returns a bitboard with the frozen neighbors of the given bitboard
"""
frozen_neighbors = 0
neighbor_bits = ((bits & NOT_A_FILE) >> 1, (bits & NOT_H_FILE) << 1, \
(bits & NOT_1_RANK) >> 8, (bits & NOT_8_RANK) << 8)
for nbit in neighbor_bits:
if self.is_frozen_at(nbit):
frozen_neighbors |= nbit
return frozen_neighbors
def do_step(self, step):
""" Generate a new position from this position with the given steps """
bitBoards = self.bitBoards
placement = self.placement
stepsLeft = self.stepsLeft
color = self.color
zobrist = self._zhash
newBoards = [b for b in bitBoards]
newPlacement = [placement[0], placement[1]]
from_ix = step[0]
from_bit = 1 << from_ix
to_ix = step[1]
to_bit = 1 << to_ix
pcolor = bool(placement[1] & from_bit)
pcbit = pcolor << 3
for piece in xrange(Piece.GRABBIT | pcbit,
(Piece.GELEPHANT | pcbit) + 1):
if bitBoards[piece] & from_bit:
break
ispush = False
ispull = False
if pcolor != color:
pstrength = piece & Piece.DECOLOR
if (self.last_piece != Piece.EMPTY and self.last_from == to_ix and
pstrength < (self.last_piece & Piece.DECOLOR)):
ispull = True
else:
ispush = True
# update the new bitboards
step_bits = from_bit | to_bit
newBoards[piece] ^= step_bits
newPlacement[pcolor] ^= step_bits
newBoards[Piece.EMPTY] ^= step_bits
# update the zobrist hash
zobrist ^= ZOBRIST_KEYS[piece][from_ix]
zobrist ^= ZOBRIST_KEYS[piece][to_ix]
# remove trapped pieces, can only be one if any
ntrap = (
neighbors_of(from_bit) & TRAPS & ~neighbors_of(newPlacement[pcolor])
)
if ntrap & newPlacement[pcolor]:
nottrapped = ~ntrap
tix = bit_to_index(ntrap)
newBoards[Piece.EMPTY] |= ntrap
newPlacement[pcolor] &= nottrapped
for tpiece in xrange(Piece.GRABBIT | pcbit,
(Piece.GELEPHANT | pcbit) + 1):
if newBoards[tpiece] & ntrap:
zobrist ^= ZOBRIST_KEYS[tpiece][tix]
newBoards[tpiece] &= nottrapped
break # can only ever be one trapped piece
stepsLeft -= 1
if stepsLeft < 1:
color ^= 1
stepsLeft = 4
piece = Piece.EMPTY
from_ix = None
if self.inpush or ispull:
piece = Piece.EMPTY
from_ix = None
return Position(color, stepsLeft, newBoards, ispush, piece, from_ix,
placement=newPlacement,
zobrist=zobrist)
def do_move(self, steps, strict_checks=True):
""" Generate a new position from the given move steps """
pos = self
if len(steps) > self.stepsLeft:
raise IllegalMove("Tried to take more than 4 steps")
for step in steps:
if strict_checks:
is_legal = pos.check_step(step)
if not is_legal:
raise IllegalMove(str(is_legal))
pos = pos.do_step(step)
if pos.color == self.color:
pos = Position(self.color ^ 1, 4, pos.bitBoards,
placement=pos.placement)
return pos
def _check_setup_step(self, piece, ix, bitboards, available):
if piece & Piece.COLOR != self.color * Piece.COLOR:
raise IllegalMove("Tried to place opposing side's piece")
if ((self.color and ix < 48) or (not self.color and ix > 15)):
raise IllegalMove("Tried to place a piece outside of setup area")
if available[piece & ~Piece.COLOR] < 1:
raise IllegalMove("Tried to place too many '%s'" %
(Piece.PCHARS[piece], ))
def do_move_str(self, move_str, strict_checks=True):
try:
steps = parse_move(move_str)
result = self.do_move(steps, strict_checks)
except ValueError as exc:
if str(exc) == "Can't represent placing step":
bitboards = [b for b in self.bitBoards]
available = {
Piece.GRABBIT: 8,
Piece.GCAT: 2,
Piece.GDOG: 2,
Piece.GHORSE: 2,
Piece.GCAMEL: 1,
Piece.GELEPHANT: 1
}
for step_str in move_str.split():
if len(step_str) != 3:
raise IllegalMove("Found mixture of step types")
piece = Piece.PCHARS.index(step_str[0])
ix = alg_to_index(step_str[1:])
bit = 1 << ix
if strict_checks:
self._check_setup_step(piece, ix, bitboards, available)
available[piece & ~Piece.COLOR] -= 1
if not bitboards[Piece.EMPTY] & bit:
raise IllegalMove("Tried to place a piece onto another")
bitboards[piece] |= bit
bitboards[Piece.EMPTY] &= ~bit
if strict_checks:
not_placed = [p[0] for p in available.items() if p[1] > 0]
if not_placed:
raise IllegalMove("Did not place all pieces in setup")
result = Position(self.color ^ 1, 4, bitboards)
else:
raise
return result
def get_single_steps(self):
""" Generate all regular steps from this position """
color = self.color
bitboards = self.bitBoards
placementBoards = self.placement
newstepsleft = self.stepsLeft - 1
if newstepsleft < 1:
newcolor = color ^ 1
newstepsleft = 4
else:
newcolor = color
move_list = [] # list to return generated steps in
move_list_append = move_list.append
stronger = placementBoards[color ^ 1] # stronger enemy pieces
neighbors_of_my = neighbors_of(placementBoards[color])
pcbit = color << 3
for piece in xrange(Piece.GRABBIT | pcbit,
(Piece.GELEPHANT | pcbit) + 1):
# remove enemy of the same rank
stronger ^= bitboards[piece ^ Piece.COLOR]
piecestomove = bitboards[piece] & (neighbors_of_my | ~
neighbors_of(stronger))
while piecestomove:
from_bit = piecestomove & -piecestomove
piecestomove ^= from_bit
from_ix = bit_to_index(from_bit)
potential_squares = (
bitboards[Piece.EMPTY] & MOVE_OFFSETS[color][(
piece & Piece.DECOLOR) != Piece.GRABBIT][from_ix]
)
while potential_squares:
to_bit = potential_squares & -potential_squares
potential_squares ^= to_bit
to_ix = bit_to_index(to_bit)
# create new position
# make copies of the current boards
newBoards = [b for b in bitboards]
newPlacement = [placementBoards[0], placementBoards[1]]
# update the new bitboards
step_bits = from_bit | to_bit
newBoards[Piece.EMPTY] ^= step_bits
newBoards[piece] ^= step_bits
newPlacement[color] ^= step_bits
# update the zobrist hash
zobrist = self._zhash
zobrist ^= ZOBRIST_KEYS[piece][from_ix]
zobrist ^= ZOBRIST_KEYS[piece][to_ix]
# remove trapped pieces, can only be one if any
if ((from_bit & TRAP_NEIGHBORS) and
(newPlacement[color] & TRAPS)):
my_placement = newPlacement[color]
trapped = 0
if ((my_placement & TRAP_C3_BIT) and
(not (RMOVE_OFFSETS[TRAP_C3_IX] & my_placement))):
trapped = TRAP_C3_BIT
trapped_idx = TRAP_C3_IX
elif ((my_placement & TRAP_F3_BIT) and
(not
(RMOVE_OFFSETS[TRAP_F3_IX] & my_placement))):
trapped = TRAP_F3_BIT
trapped_idx = TRAP_F3_IX
elif ((my_placement & TRAP_C6_BIT) and
(not
(RMOVE_OFFSETS[TRAP_C6_IX] & my_placement))):
trapped = TRAP_C6_BIT
trapped_idx = TRAP_C6_IX
elif ((my_placement & TRAP_F6_BIT) and
(not
(RMOVE_OFFSETS[TRAP_F6_IX] & my_placement))):
trapped = TRAP_F6_BIT
trapped_idx = TRAP_F6_IX
if trapped:
newBoards[Piece.EMPTY] ^= trapped
newPlacement[color] ^= trapped
for trappiece in xrange(
Piece.GRABBIT | pcbit,
(Piece.GELEPHANT | pcbit) + 1):
if newBoards[trappiece] & trapped:
zobrist ^= ZOBRIST_KEYS[trappiece][trapped_idx]
newBoards[trappiece] ^= trapped
break
if newcolor == color:
pos = Position(newcolor, newstepsleft, newBoards,
False, piece, from_ix,
placement=newPlacement,
zobrist=zobrist)
else:
pos = Position(newcolor, newstepsleft, newBoards,
False, Piece.EMPTY, None,
placement=newPlacement,
zobrist=zobrist)
move_list_append(((from_ix, to_ix), pos))
return move_list
def get_steps(self):
""" Get all the steps from this position """
color = self.color
bitboards = self.bitBoards
placement = self.placement
last_from = self.last_from
neighbors_of_my = neighbors_of(self.placement[color])
step_list = []
if self.inpush:
lastbit = 1 << last_from
lf_neighbors = neighbors_of(lastbit)
stronger = 0
attackers = 0
pcbit = color << 3
lstrength = self.last_piece & Piece.DECOLOR
for piece in xrange(Piece.GELEPHANT | pcbit, lstrength | pcbit, -1):
attackers |= (bitboards[piece] & lf_neighbors &
(neighbors_of_my | ~neighbors_of(stronger)))
stronger |= bitboards[piece ^ Piece.COLOR]
while attackers:
abit = attackers & -attackers
attackers ^= abit
step = (bit_to_index(abit), last_from)
step_list.append((step, self.do_step(step)))
else:
opponent = color ^ 1
stronger = (placement[opponent] ^ bitboards[Piece.GRABBIT |
(opponent << 3)])
pcbit = color << 3
attackers = 0
if self.stepsLeft > 1:
for piece in xrange(Piece.GCAT | pcbit,
(Piece.GELEPHANT | pcbit) + 1):
stronger ^= bitboards[piece ^ Piece.COLOR]
attackers |= (bitboards[piece] &
(neighbors_of_my | ~neighbors_of(stronger)))
ocbit = opponent << 3
empty_neighbors = neighbors_of(bitboards[Piece.EMPTY])
for vpiece in xrange(Piece.GRABBIT | ocbit,
Piece.GELEPHANT | ocbit):
pullsdone = 0
if self.last_piece & Piece.DECOLOR > vpiece & Piece.DECOLOR:
last_from = self.last_from
lastbit = 1 << last_from
pulls = bitboards[vpiece] & neighbors_of(lastbit)
pullsdone |= lastbit | pulls
while pulls:
pbit = pulls & -pulls
pulls ^= pbit
step = (bit_to_index(pbit), last_from)
step_list.append((step, self.do_step(step)))
if self.stepsLeft < 2:
continue
attackers &= ~bitboards[vpiece ^ Piece.COLOR]
victims = (
bitboards[vpiece] & neighbors_of(attackers) & empty_neighbors
)
while victims:
vbit = victims & -victims
victims ^= vbit
vix = bit_to_index(vbit)
to_bits = neighbors_of(vbit) & bitboards[Piece.EMPTY]
while to_bits:
tbit = to_bits & -to_bits
to_bits ^= tbit
if (vbit & pullsdone) and (tbit & pullsdone):
continue
step = (vix, bit_to_index(tbit))
step_list.append((step, self.do_step(step)))
step_list += self.get_single_steps()
return step_list
def get_null_move(self):
""" Generate a null move """
return Position(self.color ^ 1, 4, self.bitBoards,
placement=self.placement,
zobrist=self._zhash)
def get_moves(self):
""" Generate all possible moves from this position """
color = self.color
partial = {self: ()}
finished = {}
while partial:
nextpart = {}
for npos, nsteps in partial.items():
for step, move in npos.get_steps():
if move.color == color:
if move not in nextpart:
nextpart[move] = nsteps + (step, )
elif move not in finished:
finished[move] = nsteps + (step, )
if not npos.inpush:
move = npos.get_null_move()
if move not in finished:
finished[move] = nsteps
partial = nextpart
del finished[self.get_null_move()]
return finished
def get_moves_nodes(self):
""" Generate all possible moves from this position, also keep track of
and return the number of nodes visited while generating them. """
color = self.color
partial = {self: ()}
finished = {}
nodes = 0
while partial:
nextpart = {}
for npos, nsteps in partial.items():
steps = npos.get_steps()
nodes += len(steps)
for step, move in steps:
if move.color == color:
if move not in nextpart:
nextpart[move] = nsteps + (step, )
elif move not in finished:
finished[move] = nsteps + (step, )
if not npos.inpush:
move = npos.get_null_move()
if move not in finished:
finished[move] = nsteps
partial = nextpart
del finished[self.get_null_move()]
return (finished, nodes)
def get_rnd_step_move(self):
""" Generate a move from this position by taking random steps. """
pos = self
taken = []
deadends = set()
while pos.color == self.color:
steps = pos.get_steps()
steps = [s for s in steps if s[1] not in deadends]
if pos.bitBoards != self.bitBoards and not pos.inpush:
nullmove = pos.get_null_move()
steps.append(((), nullmove))
if pos.stepsLeft == 1:
# This is the last step, if it returns the board to the
# starting state it is illegal
steps = [s for s in steps if s[1].bitBoards != self.bitBoards]
if len(steps) == 0:
if taken:
# This is a deadend with no legal steps.
# Can occur when a push returns the position to the start
# and has no steps left to change the position after that.
# This method almost certainly introduces some bias in the
# results that could be avoided with proper backtracking.
deadends.add(pos)
pos = self
taken = []
continue
else:
# nothing can move we must be either eliminated or
# immobilized
return (None, pos)
randstep = random.choice(steps)
taken.append(randstep[0])
pos = randstep[1]
if not taken[-1]:
taken = taken[:-1]
if pos.bitBoards == self.bitBoards: # pragma: no cover
raise RuntimeError("Produced illegal null move.")
return (taken, pos)
def parse_move(line):
""" Parse steps from a move string """
text = line.split()
if len(text) == 0:
raise ValueError("No steps in move given to parse. %s" % (repr(line)))
steps = []
for step in text:
from_ix = alg_to_index(step[1:3])
if len(step) > 3:
if step[3] == 'x':
continue
elif step[3] == 'n':
to_ix = from_ix + 8
elif step[3] == 's':
to_ix = from_ix - 8
elif step[3] == 'e':
to_ix = from_ix + 1
elif step[3] == 'w':
to_ix = from_ix - 1
else:
raise ValueError("Invalid step direction.")
steps.append((from_ix, to_ix))
else:
raise ValueError("Can't represent placing step")
return steps
def parse_long_pos(text):
""" Parse a position from a long format string """
text = [x.strip() for x in text]
for emptynum, line in enumerate(text):
if line:
break
text = text[emptynum:]
while text[0] and not text[0][0].isdigit():
del text[0]
movecolorix = 0
while text[0][:movecolorix + 1].isdigit():
movecolorix += 1
movenumber = int(text[0][:movecolorix])
if text[0][movecolorix].lower() in "bs":
color = Color.SILVER
elif text[0][movecolorix].lower() in "wg":
color = Color.GOLD
else:
raise ValueError("Could not find side to move")
if len(text[0][movecolorix + 1:]) > 0:
raise NotImplementedError(
"Can not parse positions with steps already taken")
else:
steps = 4
if text[1] != "+-----------------+":
raise ValueError("Board does not start after move line")
ranknum = 7
bitboards = [b for b in BLANK_BOARD]
for line in text[2:10]:
if not line[0].isdigit() or int(line[0]) - 1 != ranknum:
raise ValueError("Unexpected rank number at rank %d" % (ranknum + 1,))
for piece_index in xrange(3, 18, 2):
colnum = (piece_index - 3) // 2
bit = 1 << ((ranknum * 8) + colnum)
piecetext = line[piece_index]
if piecetext in [' ', 'X', 'x', '.']:
continue
piece = Piece.PCHARS.find(piecetext)
if piece != -1:
bitboards[piece] |= bit
bitboards[Piece.EMPTY] &= ~bit
else:
raise ValueError("Invalid piece at %s%d" %
("abcdefgh" [colnum], ranknum + 1))
ranknum -= 1
pos = Position(color, steps, bitboards)
if len(text) > 12:
for line in text[12:]:
line = line.strip()
if not line or line[0] == '#':
break
line = " ".join(line.split()[1:])
move = parse_move(line)
pos = pos.do_move(move)
if pos.color == Color.GOLD:
movenumber += 1
return (movenumber, pos)
def parse_short_pos(side, stepsleft, text):
""" Parse a position from a short format string """
if side not in [Color.GOLD, Color.SILVER]:
raise ValueError("Invalid side passed into parse_short_pos, %d" %
(side))
if stepsleft > 4 or stepsleft < 0:
raise ValueError("Invalid steps left passed into parse_short_pos, %d" %
(stepsleft))
bitboards = [b for b in BLANK_BOARD]
for place, piecetext in enumerate(text[1:-1]):
if piecetext != ' ':
try:
piece = Piece.PCHARS.index(piecetext)
except ValueError:
raise ValueError("Invalid piece at position %d, %s" %
(place, piecetext))
index = sq_to_index(place % 8, 7 - (place // 8))
bit = 1 << index
bitboards[piece] |= bit
bitboards[Piece.EMPTY] &= ~bit
pos = Position(side, stepsleft, bitboards)
return pos
def test_random_play():
""" Randomly plays games printing out each move. """
total_turns = 0
goal_wins = immo_wins = 0
start_time = time.time()
for i in xrange(100):
pos = Position(Color.GOLD, 4, BASIC_SETUP)
turn = 2
while not pos.is_goal():
moves = pos.get_moves()
del moves[pos.get_null_move()]
print(turn)
print(pos.board_to_str())
print(len(moves))
print(time.time() - start_time)
print()
if len(moves) == 0:
immo_wins += 1
print("%d, %d win by immobilization. " % (i + 1, immo_wins))
break
turn += 1
pos = random.choice(moves.keys())
total_turns += turn
if len(moves) != 0:
goal_wins += 1
print("%d, %d win by goal." % (i + 1, goal_wins))
print("%.2f %d %d %.2f" % (
total_turns / 100.0, goal_wins, immo_wins, time.time() - start_time
))
def rnd_step_game(pos):
while (not pos.is_goal()) and (not pos.is_rabbit_loss()):
steps, result = pos.get_rnd_step_move()
if steps is None: # immobilization or elimination
assert len(pos.get_moves()) == 0
if pos.color == Color.GOLD:
return -1
else:
return 1
pos = result
if pos.is_goal():
return pos.is_goal()
else:
return pos.is_rabbit_loss()
def rnd_game(pos):
while (not pos.is_goal()) and (not pos.is_rabbit_loss()):
moves = pos.get_moves()
del moves[pos.get_null_move()]
if len(moves) == 0:
if pos.color == Color.GOLD:
return -1
else:
return 1
pos = random.choice(moves.keys())
if pos.is_goal():
return pos.is_goal()
else:
return pos.is_rabbit_loss()
def test_rnd_steps():
""" Randomly play games by choosing random steps. """
total_turns = 0
goal_wins = 0
immo_wins = 0
for i in xrange(100):
pos = Position(Color.GOLD, 4, BASIC_SETUP)
turn = 3
while not pos.is_goal():
print("%d%s" % (math.ceil(turn / 2.0), ['b', 'w'][turn % 2]), end=' ')
steps, result = pos.get_rnd_step_move()
if steps is None:
print()
print(pos.board_to_str())
print("Win by elimination/immobilization.")
print()
moves = pos.get_moves()
if len(moves) != 0:
print("Uh, oh. immo not immo.")
print(immo_wins)
return
immo_wins += 1
break
print(pos.steps_to_str(steps))
pos = result
turn += 1
total_turns += turn
if steps is not None:
print("%d%s" % (math.ceil(turn / 2.0), ['b', 'w'][turn % 2]))
print(pos.board_to_str())
print("Win by goal.")
print()
goal_wins += 1
print("%.2f %d %d" % (total_turns / 100.0, goal_wins, immo_wins))
def main(args=None):
""" Main entry point
Takes a filename and attempts to parse it as a board position,
then outputs a few statistics about the possible moves.
"""
parser = ArgumentParser(
description="Give a few statistics and possible moves for a position"
)
parser.add_argument("filename", help="Position file to look at")
config = parser.parse_args(args)
filename = config.filename
positionfile = open(filename, 'r')
positiontext = positionfile.readlines()
if positiontext[1][0] == '[':
positiontext = [x.strip() for x in positiontext]
movenum = int(positiontext[0][:-1])
pos = parse_short_pos("wbgs".index(positiontext[0][-1]) % 2, 4,
positiontext[1])
else:
movenum, pos = parse_long_pos(positiontext)
print("%d%s" % (movenum, "gs" [pos.color]))
print()
print(pos.board_to_str())
print()
short_str = pos.board_to_str("short")
print(short_str)
print()
if parse_short_pos(pos.color, 4, short_str) != pos:
print("Short string board round trip failed")
rpos = parse_short_pos(pos.color, 4, short_str)
print(rpos.board_to_str())
return
placing = pos.to_placing_move()
print(placing[0])
print(placing[1])
print()
steps, result = pos.get_rnd_step_move()
if steps is None:
print("No move found by random steps.")
else:
print("Random step move: %s" % (pos.steps_to_str(steps), ))
print()
starttime = time.time()
moves, nodes = pos.get_moves_nodes()
gentime = time.time() - starttime
print("%d unique moves generated in %.2f seconds" % (len(moves), gentime))
real_steps = [s for s, m in pos.get_steps()]
for i in xrange(64):
for j in xrange(64):
tstep = (i, j)
check_resp = pos.check_step(tstep)
if check_resp and not tstep in real_steps:
print("check_step thought %s to %s was valid step %d,%d" % (
index_to_alg(tstep[0]), index_to_alg(tstep[1]), tstep[0],
tstep[1]))
return
if not check_resp and tstep in real_steps:
print("check_step thought %s to %s was invalid step" % (
index_to_alg(tstep[0]), index_to_alg(tstep[1])
))
return
from pyrimaa import x88board
mn, opos = x88board.parse_long_pos(positiontext)
omoves = opos.get_moves()
new_res = set([p.board_to_str("short") for p in moves.keys()])
if len(new_res) != len(moves):
print("duplicate boards in results %d!=%d" % (len(new_res), len(moves)))
checked = {}
for upos, move in moves.items():
bstr = upos.board_to_str("short")
if bstr in checked:
cpos = checked[bstr][0]
print("found duplicate board")
print(pos.steps_to_str(move))
print(upos.board_to_str())
print()
print(pos.steps_to_str(checked[bstr][1]))
print(cpos.board_to_str())
print("upos inpush %s lf %s lp %s" % (
upos.inpush, upos.last_from, Piece.PCHARS[upos.last_piece]
))
print("cpos inpush %s lf %s lp %s" % (
cpos.inpush, cpos.last_from, Piece.PCHARS[cpos.last_piece]
))
if upos._zhash != cpos._zhash:
print("zobrist %X, %X" % (upos._zhash, cpos._zhash))
if upos.placement != cpos.placement:
print("placement %s, %s" % (upos.placement, cpos.placement))
else:
checked[bstr] = (upos, move)
old_res = set([p.board_to_str("short") for p in omoves.keys()])
if new_res != old_res or len(omoves) != len(moves):
discount = 0
print("Only in new results:")
for upos, move in moves.items():
if upos.board_to_str("short") not in old_res:
discount += 1
print(pos.steps_to_str(move))
print(upos.board_to_str("short"))
if upos.color == pos.color:
print("result position with same color")
if upos.stepsLeft != 4:
print("result position with steps taken")
if upos.inpush:
print("result position in push")
if upos.last_from is not None or upos.last_piece != Piece.EMPTY:
print("result position with last piece information")
if discount > 40:
print("Stopping results")
break
print()
print("Only in old results:")
for upos, move in omoves.items():
if upos.board_to_str("short") not in new_res:
print(upos.steps_to_str(move))
print(upos.board_to_str("short"))
discount += 1
if discount > 40:
print("Stopping results")
break
if __name__ == "__main__":
sys.exit(main()) | AEI | /AEI-1.3.0.tar.gz/AEI-1.3.0/pyrimaa/board.py | board.py |
try:
xrange(1)
except NameError:
xrange = range
import random
import sys
import time
from argparse import ArgumentParser
class Color(object):
GOLD = 0
SILVER = 1
class Piece(object):
EMPTY = 0
GRABBIT = 1
GCAT = 2
GDOG = 3
GHORSE = 4
GCAMEL = 5
GELEPHANT = 6
SCOLOR = 8
SRABBIT = 9
SCAT = 10
SDOG = 11
SHORSE = 12
SCAMEL = 13
SELEPHANT = 14
COUNT = 15
PCHARS = " RCDHMExxrcdhme"
DECOLOR = ~SCOLOR
def index_to_sq(ix):
return ((ix // 16), (ix & 7))
def sq_to_index(sq):
return (sq[0] * 16) + sq[1]
def index_to_alg(ix):
"""Convert an index to algebraic notation"""
rank, column = index_to_sq(ix)
return "abcdefgh" [column] + "12345678" [rank]
def alg_to_index(str):
"""Convert algebraic notation for a square to an index"""
return sq_to_index((int(str[1]) - 1, "abcdefgh".index(str[0])))
def packed_to_index(ix):
"""Convert 0-63 index to 0x88 index"""
return ix + (ix & ~7)
def index_to_packed(px):
"""Convert 0x88 index to 0-63 index"""
return ((px & ~7) // 2) + (px & 7)
def bit_neighbors(bit):
""" get the neighboring bits to a set of bits """
bitboard = (bit & 0xFEFEFEFEFEFEFEFE) >> 1
bitboard |= (bit & 0x7F7F7F7F7F7F7F7F) << 1
bitboard |= (bit & 0xFFFFFFFFFFFFFF00) >> 8
bitboard |= (bit & 0x00FFFFFFFFFFFFFF) << 8
return bitboard
def bit_to_packed(bit):
cnt = (bit & 0xAAAAAAAAAAAAAAAA) != 0
cnt |= ((bit & 0xCCCCCCCCCCCCCCCC) != 0) << 1
cnt |= ((bit & 0xF0F0F0F0F0F0F0F0) != 0) << 2
cnt |= ((bit & 0xFF00FF00FF00FF00) != 0) << 3
cnt |= ((bit & 0xFFFF0000FFFF0000) != 0) << 4
cnt |= ((bit & 0xFFFFFFFF00000000) != 0) << 5
return cnt
ALL_BITS = 0xFFFFFFFFFFFFFFFF
ZOBRIST_KEYS = [0, [], []]
# generate zobrist keys, assuring no duplicate keys or 0
def _zobrist_newkey(used_keys, rnd):
candidate = 0
while candidate in used_keys:
candidate = rnd.randint(-(2**63 - 1), 2**63 - 1)
used_keys.append(candidate)
return candidate
def _generate_zobrist_keys():
rnd = random.Random()
rnd.seed(0xF00F)
used_keys = [0]
ZOBRIST_KEYS[0] = _zobrist_newkey(used_keys, rnd)
for piece in xrange(Piece.COUNT):
ZOBRIST_KEYS[2].append([])
for index in xrange(0x78):
if piece == Piece.EMPTY:
ZOBRIST_KEYS[2][piece].append(0)
elif index & 0x88:
ZOBRIST_KEYS[2][piece].append(0)
else:
ZOBRIST_KEYS[2][piece].append(_zobrist_newkey(used_keys, rnd))
for step in xrange(5):
ZOBRIST_KEYS[1].append(_zobrist_newkey(used_keys, rnd))
_generate_zobrist_keys()
class IllegalStepException(Exception):
pass
class Position(object):
def __init__(self, side, steps, board_array,
last_piece=Piece.EMPTY,
last_from=0x08,
inpush=False,
zobrist=None,
frozen=None):
self.color = side
self.steps = steps
self.board = board_array
self.last_piece = last_piece
self.last_from = last_from
self.in_push = inpush
if frozen is None:
offsets = (-1, 1, -16, 16)
frozen = 0
for px in xrange(64):
ix = packed_to_index(px)
if board_array[ix] != Piece.EMPTY:
piece = board_array[ix]
strength = piece & Piece.DECOLOR
isfrozen = False
for o in offsets:
nix = ix + o
if nix & 0x88 or board_array[nix] == Piece.EMPTY:
continue
if not ((piece ^ board_array[nix]) & Piece.SCOLOR):
isfrozen = False
break
elif strength < board_array[nix] & Piece.DECOLOR:
isfrozen = True
if isfrozen:
frozen |= 1 << px
self.frozen = frozen
if zobrist is None:
zobrist = ZOBRIST_KEYS[1][steps]
if side:
zobrist ^= ZOBRIST_KEYS[0]
for rank in range(8):
for col in range(8):
ix = sq_to_index((rank, col))
zobrist ^= ZOBRIST_KEYS[2][board_array[ix]][ix]
self._zhash = zobrist
def __eq__(self, other):
try:
if (self.color != other.color or self.steps != other.steps):
return False
if (self.last_from != other.last_from or
self.last_piece != other.last_piece):
return False
if self.board != other.board:
return False
except:
return False
return True
def __ne__(self, other):
return not self.__eq__(other)
def __hash__(self):
return self._zhash
def is_goal(self):
"""Check to see if this position is a goal for either side"""
board = self.board
ggoal = False
for ix in xrange(0x70, 0x78):
if board[ix] == Piece.GRABBIT:
ggoal = True
break
sgoal = False
for ix in xrange(8):
if board[ix] == Piece.SRABBIT:
sgoal = True
break
if ggoal or sgoal:
if self.color == Color.GOLD:
if sgoal:
return -1
else:
return 1
else:
if ggoal:
return 1
else:
return -1
else:
return False
def is_elimination(self):
"""Check to see if either side has lost all rabbits"""
board = self.board
gelim = True
selim = True
for rank in range(8):
for col in range(8):
ix = sq_to_index((rank, col))
if board[ix] == Piece.GRABBIT:
gelim = False
elif board[ix] == Piece.SRABBIT:
selim = False
if not (gelim or selim):
break
if gelim or selim:
if self.color == Color.GOLD:
if gelim:
return -1
else:
return 1
else:
if selim:
return 1
else:
return -1
else:
return False
def is_end(self):
goal = self.is_goal()
if goal:
return goal
elim = self.is_elimination()
if elim:
return elim
if len(self.get_steps()) == 0:
if self.color == Color.GOLD:
return -1
else:
return 1
return False
def to_long_board(self, dots=True):
"""Generate long string representation of the board"""
board = self.board
piece_rep = Piece.PCHARS
if dots:
piece_rep = "." + piece_rep[1:]
brepr = [" +-----------------+"]
for rank in range(8, 0, -1):
rank_rep = ["%d| " % rank]
rix = sq_to_index((rank - 1, 0))
for col in range(8):
ix = rix + col
piece = board[ix]
if (piece == Piece.EMPTY and (rank in [3, 6]) and
(col in [2, 5])):
rank_rep.append("x")
else:
rank_rep.append(piece_rep[piece])
rank_rep.append(" ")
rank_rep.append("|")
brepr.append("".join(rank_rep))
brepr.append(" +-----------------+")
brepr.append(" a b c d e f g h ")
return "\n".join(brepr)
def to_short_board(self):
"""Generate short string representation of the board"""
board = self.board
brepr = ["["]
for rank in range(7, -1, -1):
for col in range(8):
ix = sq_to_index((rank, col))
brepr.append(Piece.PCHARS[board[ix]])
brepr.append("]")
return "".join(brepr)
def board_to_str(self, format="long", dots=True):
if format == "long":
return self.to_long_board(dots)
elif format == "short":
return self.to_short_board()
else:
raise ValueError("Invalid board format")
def to_placing_moves(self):
"""Generate placing moves for this board"""
board = self.board
gmove = ["g"]
smove = ["s"]
for rank in range(8):
for col in range(8):
ix = sq_to_index((rank, col))
piece = board[ix]
if piece != Piece.EMPTY:
sq_str = [Piece.PCHARS[piece]]
sq_str.append(index_to_alg(ix))
sq_str = "".join(sq_str)
if piece & Piece.SCOLOR:
smove.append(sq_str)
else:
gmove.append(sq_str)
return (" ".join(gmove), " ".join(smove))
def place_piece(self, piece, index):
if self.board[index] != Piece.EMPTY:
raise ValueError("Tried to place a piece on another piece")
newboard = [x for x in self.board]
newboard[index] = piece
zobrist = self._zhash ^ ZOBRIST_KEYS[2][piece][index]
return Position(self.color, self.steps, newboard, zobrist=zobrist)
def remove_piece(self, index):
if self.board[index] == Piece.EMPTY:
raise ValueError("Tried to remove empty piece")
newboard = [x for x in self.board]
piece = newboard[index]
newboard[index] = Piece.EMPTY
zobrist = self._zhash ^ ZOBRIST_KEYS[2][piece][index]
return Position(self.color, self.steps, newboard, zobrist=zobrist)
def do_step(self, step):
"""Generate a new position using the given step"""
board = self.board
if board[step[0]] == Piece.EMPTY:
raise IllegalStepException("Tried to move from empty square %s" %
index_to_alg(step[0]))
if board[step[1]] != Piece.EMPTY:
raise IllegalStepException("Tried to move to a full square %s" %
index_to_alg(step[1]))
offsets = (-1, 1, -16, 16)
ispush = False
ispull = False
newfrom = step[0]
piece = board[newfrom]
pcolor = Color.GOLD
if piece & Piece.SCOLOR:
pcolor = Color.SILVER
pstrength = piece & Piece.DECOLOR
if pcolor == self.color:
isfrozen = bool(self.frozen & (1 << index_to_packed(newfrom)))
if isfrozen:
print(self.to_long_board())
print(hex(self.frozen))
raise IllegalStepException(
"Tried to move frozen piece %s%s" %
(Piece.PCHARS[piece], index_to_alg(newfrom)))
if pstrength == Piece.GRABBIT:
illegal_dir = [-16, 16][pcolor]
if step[1] == newfrom + illegal_dir:
raise IllegalStepException("Tried to move rabbit back %s" %
index_to_alg(newfrom))
if self.in_push and pstrength <= (self.last_piece & Piece.DECOLOR):
raise IllegalStepException(
"Tried to finish push with weak piece %s%s" %
(Piece.PCHARS[piece], index_to_alg(newfrom)))
else:
if self.in_push:
raise IllegalStepException(
"Tried to move opponent piece while in push %s%s to %s" %
(Piece.PCHARS[piece], index_to_alg(newfrom),
index_to_alg(step[1])))
if (self.last_piece != Piece.EMPTY and step[1] == self.last_from
and pstrength < (self.last_piece & Piece.DECOLOR)):
ispull = True
else:
if self.steps > 2:
raise IllegalStepException("Tried to push on last step")
stronger = False
for noffset in [-1, 1, -16, 16]:
nix = newfrom + noffset
if (not (nix & 0x88) and board[nix] != Piece.EMPTY and
((board[nix] ^ piece) & Piece.SCOLOR) and
pstrength < board[nix] & Piece.DECOLOR):
nstrength = board[nix] & Piece.DECOLOR
isfrozen = bool(self.frozen &
(1 << index_to_packed(nix)))
if not isfrozen:
stronger = True
break
if not stronger:
raise IllegalStepException(
"Tried to push without pusher %s%s" %
(Piece.PCHARS[piece], index_to_alg(newfrom)))
ispush = True
zobrist = (self._zhash ^ ZOBRIST_KEYS[2][piece][newfrom] ^
ZOBRIST_KEYS[1][self.steps])
newboard = [s for s in board]
newfrozen = self.frozen
istrapped = False
if step[1] in (0x22, 0x25, 0x52, 0x55):
istrapped = True
tix = step[1]
for noff in [-1, 1, -16, 16]:
nix = tix + noff
if (not ((nix & 0x88) or nix == newfrom) and
board[nix] != Piece.EMPTY and
(not (board[nix] ^ piece) & Piece.SCOLOR)):
istrapped = False
break
else:
for tix in (0x22, 0x25, 0x52, 0x55):
if board[tix] == Piece.EMPTY:
continue
offset = step[0] - tix
if offset not in offsets:
continue
if (board[tix] ^ piece) & Piece.SCOLOR:
break
captrap = True
for toff in offsets:
if toff == offset:
continue
tnix = tix + toff
if tnix & 0x88 or board[tnix] == Piece.EMPTY:
continue
if not ((board[tnix] ^ board[tix]) & Piece.SCOLOR):
captrap = False
break
if captrap:
zobrist ^= ZOBRIST_KEYS[2][board[tix]][tix]
cstrength = newboard[tix] & Piece.DECOLOR
px = index_to_packed(tix)
fn_bits = newfrozen & bit_neighbors(1 << px)
while fn_bits:
fnb = fn_bits & -fn_bits
fn_bits ^= fnb
nix = packed_to_index(bit_to_packed(fnb))
nstrength = newboard[nix] & Piece.DECOLOR
isfrozen = False
for noff in offsets:
nnix = nix + noff
if nnix & 0x88 or nnix == tix:
continue
if newboard[nnix] & Piece.DECOLOR > nstrength:
isfrozen = True
break
nbit = 1 << index_to_packed(nix)
if isfrozen:
newfrozen |= nbit
else:
newfrozen &= ~nbit
newboard[tix] = Piece.EMPTY
break
if not istrapped:
newboard[step[1]] = piece
zobrist ^= ZOBRIST_KEYS[2][piece][step[1]]
for off in offsets:
nix = step[1] + off
if nix & 0x88 or newboard[nix] == Piece.EMPTY:
continue
nbit = 1 << index_to_packed(nix)
if not ((piece ^ newboard[nix]) & Piece.SCOLOR):
newfrozen &= ~nbit
elif (not (newfrozen & nbit) and
(newboard[nix] & Piece.DECOLOR) < pstrength):
isfrozen = True
for noff in offsets:
nnix = nix + noff
if (nnix & 0x88 or nnix == nix or
newboard[nnix] == Piece.EMPTY):
continue
if (newboard[nnix] ^ piece) & Piece.SCOLOR:
isfrozen = False
break
if isfrozen:
newfrozen |= nbit
for off in offsets:
nix = newfrom + off
if (nix & 0x88 or newboard[nix] == Piece.EMPTY):
continue
nbit = 1 << index_to_packed(nix)
nstrength = newboard[nix] & Piece.DECOLOR
if (newboard[nix] ^ piece) & Piece.SCOLOR:
if newfrozen & nbit:
isfrozen = False
for noff in offsets:
nnix = nix + noff
if (nnix & 0x88 or nnix == newfrom or
newboard[nnix] == Piece.EMPTY):
continue
if newboard[nnix] & Piece.DECOLOR > nstrength:
isfrozen = True
break
if not isfrozen:
newfrozen ^= nbit
else:
isfrozen = False
for noff in offsets:
nnix = nix + noff
if (nnix & 0x88 or nnix == newfrom or
newboard[nnix] == Piece.EMPTY):
continue
if not ((newboard[nnix] ^ piece) & Piece.SCOLOR):
isfrozen = False
break
elif nstrength < newboard[nnix] & Piece.DECOLOR:
isfrozen = True
if isfrozen:
newfrozen |= nbit
newboard[newfrom] = Piece.EMPTY
fbit = 1 << index_to_packed(newfrom)
newfrozen &= ~fbit
newcolor = self.color
newsteps = self.steps + 1
if newsteps == 4:
newsteps = 0
newcolor ^= 1
zobrist ^= ZOBRIST_KEYS[0]
piece = Piece.EMPTY
newfrom = 0x08
zobrist ^= ZOBRIST_KEYS[1][newsteps]
if self.in_push or ispull:
piece = Piece.EMPTY
newfrom = 0x08
return Position(newcolor, newsteps, newboard, piece, newfrom, ispush,
zobrist, newfrozen)
def do_move(self, steps):
"""Generate a new position from the given move"""
npos = self
for step in steps:
npos = npos.do_step(step)
if npos.color == self.color:
npos = npos.get_null_move()
def get_steps(self):
"""Get all steps from this position"""
board = self.board
steps = []
if self.in_push:
lastfrom = self.last_from
lstrength = self.last_piece & Piece.DECOLOR
for noffset in (-1, 1, -16, 16):
pix = lastfrom + noffset
if (pix & 0x88 or
((board[pix] & Piece.SCOLOR) >> 3) != self.color):
continue
pstrength = board[pix] & Piece.DECOLOR
if pstrength > lstrength:
isfrozen = bool(self.frozen & (1 << index_to_packed(pix)))
if not isfrozen:
step = (pix, lastfrom)
steps.append((step, self.do_step(step)))
else:
lastcolor = (self.last_piece & Piece.SCOLOR) >> 3
if (lastcolor == self.color and
(self.last_piece & Piece.DECOLOR) > Piece.GRABBIT):
# finish any possible pulls
lastfrom = self.last_from
lstrength = self.last_piece & Piece.DECOLOR
for noff in [-1, 1, -16, 16]:
pix = lastfrom + noff
if (pix & 0x88) or board[pix] == Piece.EMPTY:
continue
if ((board[pix] ^ self.last_piece) & Piece.SCOLOR and
(board[pix] & Piece.DECOLOR) < lstrength):
step = (pix, lastfrom)
steps.append((step, self.do_step(step)))
for rank in range(8):
for col in range(8):
ix = sq_to_index((rank, col))
if board[ix] == Piece.EMPTY:
continue
pstrength = board[ix] & Piece.DECOLOR
if (board[ix] & Piece.SCOLOR) >> 3 == self.color:
isfrozen = bool(self.frozen &
(1 << index_to_packed(ix)))
if not isfrozen:
to_offs = (-1, 1, -16, 16)
if pstrength == Piece.GRABBIT:
if self.color == Color.GOLD:
to_offs = (-1, 1, 16)
else:
to_offs = (-1, 1, -16)
for toff in to_offs:
tix = ix + toff
if (not (tix & 0x88) and
board[tix] == Piece.EMPTY):
step = (ix, tix)
steps.append((step, self.do_step(step)))
elif self.steps < 3:
# start any pushes
haspusher = False
for noff in (-1, 1, -16, 16):
nix = ix + noff
if nix & 0x88:
continue
nstrength = board[nix] & Piece.DECOLOR
if (((board[ix] ^ board[nix]) & Piece.SCOLOR) and
nstrength > pstrength):
isfrozen = bool(self.frozen &
(1 << index_to_packed(nix)))
if not isfrozen:
haspusher = True
break
if haspusher:
for poff in (-1, 1, -16, 16):
tix = ix + poff
if (not (tix & 0x88) and
board[tix] == Piece.EMPTY):
step = (ix, tix)
steps.append((step, self.do_step(step)))
return steps
def get_null_move(self):
"""Get position with opposite side to move"""
zobrist = self._zhash ^ ZOBRIST_KEYS[0]
zobrist ^= ZOBRIST_KEYS[1][self.steps] ^ ZOBRIST_KEYS[1][0]
return Position(self.color ^ 1, 0, self.board,
zobrist=zobrist,
frozen=self.frozen)
def get_moves(self):
"""Generate all possible moves from this position"""
color = self.color
partial = {self: ()}
finished = {}
while partial:
nextpart = {}
for pos, steps in partial.items():
for step, npos in pos.get_steps():
if npos.color == color:
if npos not in nextpart:
nextpart[npos] = steps + step
elif npos not in finished:
finished[npos] = steps + step
if not pos.in_push:
npos = pos.get_null_move()
if npos not in finished:
finished[npos] = steps
partial = nextpart
del finished[self.get_null_move()]
return finished
def steps_to_str(self, steps):
"""Convert steps to a move string"""
dir_chars = {-1: "e", 1: "w", -16: "s", 16: "n"}
pos = self
move_rep = []
for step in steps:
step_rep = []
step_rep.append(Piece.PCHARS[pos.board[step[0]]])
step_rep.append(ix_to_alg(step[0]))
direction = step[0] - step[1]
try:
step_rep.append(dir_chars[direction])
except KeyError:
step_rep.append("," + ix_to_alg(step[1]))
move_rep.append("".join(step_rep))
pos = pos.do_step(step)
if pos.board[step[1]] == Piece.EMPTY:
step_rep = [step_rep[0]]
step_rep.append(ix_to_alg(step[1]))
step_rep.append("x")
move_rep.append("".join(step.rep))
return " ".join(move_rep)
def parse_move(line):
"""Parse steps from a move string"""
dir_offsets = {"e": -1, "w": 1, "s": -16, "n": 16}
words = line.split()
steps = []
for step in words:
if step[3] == 'x':
continue
piece = Piece.PCHARS.index(step[0])
index = alg_to_index(step[1:3])
try:
tix = index + dir_offsets[step[3]]
except KeyError:
raise ValueError("Invalid step direction.")
steps.append((index, tix))
return steps
def parse_long_pos(text):
"""Parse a position from a long format string"""
text = [l.strip() for l in text]
for prenum, line in enumerate(text):
if line or not line[0].isdigit():
break
text = text[prenum:]
colorix = 0
while text[0][colorix].isdigit():
colorix += 1
movenumber = int(text[0][:colorix])
if text[0][colorix].lower() in "wg":
color = Color.GOLD
elif text[0][colorix].lower() in "bs":
color = Color.SILVER
else:
raise ValueError("Could not find side to move")
if text[0][colorix + 1:]:
raise NotImplementedError(
"Can not parse position with steps already taken")
else:
steps = 0
if len(text) < 2 or text[1][0] != '+':
raise ValueError("Board does not start after move line")
rank = 7
board = [Piece.EMPTY for x in xrange(0x80)]
for line in text[2:10]:
if not line[0].isdigit() or int(line[0]) - 1 != rank:
raise ValueError("Unexpected rank number at rank %d" % rank + 1)
for pc_index in xrange(3, 18, 2):
col = (pc_index - 3) // 2
ix = sq_to_index((rank, col))
pc = line[pc_index]
if pc in [' ', 'X', 'x', '.']:
continue
piece = Piece.PCHARS.find(pc)
if piece == -1:
raise ValueError("Invalid piece at %s" % (index_to_alg(ix)))
board[ix] = piece
rank -= 1
pos = Position(color, steps, board)
return (movenumber, pos)
def parse_short_pos(side, steps, text):
"""Parse a position from a short format string"""
board = [Piece.EMPTY for x in xrange(0x80)]
for place, piecetext in enumerate(text[1:-1]):
if piecetext != ' ':
try:
piece = Piece.PCHARS.index(piecetext)
except ValueError:
raise ValueError("Invalid piece %s at position %d" %
(piecetext, place))
col = place % 8
rank = 7 - (place // 8)
ix = sq_to_index((rank, col))
board[ix] = piece
return Position(side, steps, board)
def main(args=None):
"""Takes a filename and attempts to parse it as a position,
then outputs a few statistics about the possible moves.
"""
parser = ArgumentParser(
description="Give a few statistics and possible moves for a position"
)
parser.add_argument("filename", help="Position file to look at")
config = parser.parse_args(args)
positionfile = open(config.filename, 'r')
ptext = positionfile.readlines()
if ptext[1][0] == '[':
ptext = [l.strip() for l in ptext]
movenum = int(ptext[0][:-1])
side = "wbgs".index(ptext[0][-1]) % 2
pos = parse_short_pos(side, 0, ptext[1])
else:
movenum, pos = parse_long_pos(ptext)
print("%d%s" % (movenum, "gs" [pos.color]))
print()
print(pos.to_long_board())
print()
moves = pos.to_placing_moves()
print(moves[0])
print(moves[1])
print()
steps = pos.get_steps()
print("%d initial steps" % (len(steps), ))
starttime = time.time()
moves = pos.get_moves()
print("%d unique moves" % (len(moves), ))
gentime = time.time()
print("%.2f seconds to generate moves" % (gentime - starttime, ))
return 0
if __name__ == "__main__":
sys.exit(main()) | AEI | /AEI-1.3.0.tar.gz/AEI-1.3.0/pyrimaa/x88board.py | x88board.py |
import optparse
import logging
import os
import os.path
import signal
import socket
import traceback
import sys
import re
import time
try:
from ConfigParser import SafeConfigParser, NoOptionError
ConfigParser = SafeConfigParser
from urllib2 import Request, urlopen, URLError
from urllib import urlencode
class URLRequest(Request):
@property
def data(self):
return self.get_data()
except ModuleNotFoundError:
from configparser import ConfigParser, NoOptionError
from urllib.parse import urlencode
from urllib.request import Request, urlopen
from urllib.error import URLError
URLRequest = Request
from pyrimaa import aei
_GR_CGI = "bot1gr.cgi"
log = logging.getLogger("gameroom")
netlog = logging.getLogger("gameroom.net")
positionlog = logging.getLogger("gameroom.position")
enginelog = logging.getLogger("gameroom.engine")
console = None
class EngineCrashException(Exception):
pass
def post(url, values, logname="network"):
"""Send a post request to the specified url."""
data = urlencode(values).encode("utf-8")
req = URLRequest(url, data)
oldtimeout = socket.getdefaulttimeout()
if values.get('wait', 0) != 0:
stimeout = max(5, values['maxwait'] + 2)
else:
stimeout = 5
netlog.debug("Setting server connection timeout to %d", stimeout)
socket.setdefaulttimeout(stimeout)
try:
body = ""
try_num = 0
while True:
try_num += 1
timedout = False
try:
try:
netlog.debug("%s request:\n%s", logname, req.data)
response = urlopen(req)
body = response.read().decode("utf-8")
except socket.timeout:
netlog.debug("Socket timed out to server")
body = ""
timedout = True
except URLError as err:
if isinstance(err.reason, socket.timeout):
# time out probably in urlopen
netlog.debug("Socket timed out with URLError: %s", err)
body = ""
timedout = True
elif (isinstance(err.reason, socket.gaierror) and
err.reason[0] == 10060):
netlog.debug(
"URLError: getaddressinfo connection timed out")
body = ""
else:
raise
except OSError as err:
netlog.debug(
"OSError from connection: %s %s" % (str(err), repr(err))
)
body = ""
if body != "" or try_num == 5:
break
if timedout:
netlog.info("Timed out connecting to server retrying (%d).",
try_num)
socket.setdefaulttimeout(stimeout + try_num)
else:
netlog.info("Retrying connection in %d seconds", try_num ** 2)
time.sleep(try_num ** 2)
finally:
socket.setdefaulttimeout(oldtimeout)
netlog.debug("%s response body:\n%s", logname, body)
info = parsebody(body)
if 'error' in info:
log.error("Error in response to %s: %s", logname, info['error'])
if (info['error'].startswith("Gameserver: No Game Data") or
info['error'].startswith("Gameserver: Invalid Session Id")):
raise ValueError("Game server did not recognize game session: %s" %
(info['error'], ))
return info
def unquote(qstr):
"""Unquote a string from the server."""
qstr = qstr.replace("%13", "\n")
qstr = qstr.replace("%25", "%")
return qstr
def parsebody(body):
"""Parse a message from the server returning a dict."""
data = dict()
lines = body.splitlines()
for line in lines:
equal_ix = line.find('=')
if equal_ix > 0:
key = line[:equal_ix]
data[key] = unquote(line[equal_ix + 1:])
return data
def log_response(response, unexpected=None):
if response.type == "info":
enginelog.info("%s", response.message)
elif response.type == "log":
if response.message.startswith("Error:"):
enginelog.error("%s", response.message)
elif response.message.startswith("Warning:"):
enginelog.warning("%s", response.message)
elif response.message.startswith("Debug:"):
enginelog.debug("%s", response.message)
else:
enginelog.info("%s", response.message)
elif unexpected is not None:
if response.type not in ["info", "log"]:
log.warning("Unexpected response %s (%s)." %
(unexpected, response.type))
class Table:
def __init__(self, gameroom, tableinfo):
self.min_move_time = 5
self.min_timeleft = 5
self.ponder = True
self.gameroom = gameroom
self.gid = tableinfo['gid']
self.side = tableinfo['side']
self.sid = None
self.auth = ""
self.state = {}
self.sent_tc = {
'tcmove': None,
'tcreserve': None,
'tcpercent': None,
'tcmax': None,
'tctotal': None,
'tcturns': None,
'tcturntime': None
}
def _check_engine(self, timeout=None):
if self.engine.engine.proc.poll() is not None:
raise EngineCrashException("Process gone")
try:
response = self.engine.get_response(timeout)
log_response(response)
return response
except socket.timeout:
raise
except socket.error as exc:
if (hasattr(exc, "args") and len(exc.args) > 0 and
exc.args[0] == 32):
raise EngineCrashException("Socket reset")
else:
raise
def _update_timecontrol(self, state):
tc_vars = ['tcmove', 'tcreserve', 'tcpercent', 'tcmax', 'tctotal',
'tcturns', 'tcturntime']
for var in tc_vars:
if var in state and self.sent_tc.get(var, None) != state[var]:
log.info("Sending %s of %s to engine.", var, state[var])
self.engine.setoption(var, state[var])
self.sent_tc[var] = state[var]
def reserveseat(self):
gameroom = self.gameroom
values = dict(gid=self.gid,
side=self.side,
sid=gameroom.sid,
action="reserve")
self.seat = post(gameroom.url, values, "Table.reserveseat")
self.url = self.seat['base'] + '/' + self.seat['cgi']
def sitdown(self):
values = dict(sid=self.seat['tid'],
grid=self.seat['grid'],
action="sit")
response = post(self.url, values, "Table.sitdown")
try:
self.sid = response['sid']
except KeyError:
pass
def leave(self):
values = dict(sid=self.sid, auth=self.auth, action="leave")
try:
response = post(self.url, values, "Table.leave")
except URLError:
return False
try:
ret = bool(int(response.get('ok', 0)))
except ValueError:
ret = False
return ret
def updatestate(self, wait=0):
lastchange = 0
if (self.state and (self.state.get('lastchange', "") != "")):
lastchange = self.state['lastchange']
values = dict(sid=self.sid,
what="gamestate",
wait=0,
lastchange=lastchange)
if wait:
values['wait'] = 1
values['maxwait'] = wait
gamestate = post(self.url, values, "Table.updatestate")
if gamestate.get('auth', "") != "":
self.auth = gamestate['auth']
self.state = gamestate
return gamestate
def startgame(self):
values = dict(sid=self.sid, action="startmove", auth=self.auth)
response = post(self.url, values, "Table.startgame")
try:
ret = bool(int(response.get('ok', 0)))
except ValueError:
ret = False
return ret
def move(self, move):
values = dict(sid=self.sid, action="move", move=move, auth=self.auth)
if move.lower() == "resign":
values['action'] = "resign"
values['move'] = ""
response = post(self.url, values, "Table.move")
try:
ret = bool(int(response.get('ok', 0)))
except ValueError:
ret = False
return ret
def chat(self, message):
values = dict(sid=self.sid,
action="chat",
chat=message,
auth=self.auth)
response = post(self.url, values, "Table.chat")
try:
ret = bool(int(response.get('ok', 0)))
except ValueError:
ret = False
return ret
def playgame(self, engine, greeting, onemove=False):
self.engine = engine
if self.side == 'w':
opside = 'b'
else:
opside = 'w'
opmove_re = re.compile(r"\b(\d+%s [^\n]+)\n[^\n]*$" % (opside))
opplayer = opside + "player"
state = self.updatestate()
if (int(state.get('postal', "0")) and
(state.get(opplayer, "") == "" or
state.get('turn', "") != self.side)):
log.info("Postal game and it's not my turn")
return
engine.newgame()
resps = engine.isready()
for response in resps:
log_response(response, unexpected="after newgame command")
self._update_timecontrol(state)
resps = engine.isready()
for response in resps:
log_response(response, unexpected="after timecontrol sent")
if len(state.get('moves', "")) > 4:
log.info("Catching engine up to current move.")
moves = state['moves'].splitlines()
if len(moves) > 2:
# the last move in the list is blank,
# i.e. the server is waiting for it
if (state.get('turn', "") == self.side):
# the second to last move is also sent to the engine below
# when it's our turn so don't send it either now.
sendto = -2
else:
sendto = -1
for move in moves[:sendto]:
steps = move.split()[1:]
log.debug("sending move to engine: %s" % " ".join(steps))
engine.makemove(" ".join(steps))
resps = engine.isready()
for response in resps:
log_response(response,
unexpected="while sending moves")
if int(state.get('plycount', "0")) <= 1:
# send a greeting if it's the first move of the game.
self.chat(greeting)
oplogged = False
while state.get('result', "") == "":
turnchange = time.time()
while (state.get('result', "") == "" and state.get('turn'
"") != self.side
):
if onemove:
return
try:
# eat any log, info, etc. messages the engine has sent
while True:
self._check_engine(0)
except socket.timeout:
pass
# To safeguard against broken tcp connections never wait more
# than the move time minus 5 seconds. To keep from flooding the
# server with new requests never wait less than a quarter of
# the move time. Otherwise wait till the end of the opponents
# regular turn time.
tused_key = "%sused" % ("wb" [("wb".index(self.side) + 1) % 2], )
if tused_key in state:
moveused = int(state[tused_key])
else:
moveused = 0
movetime = int(state['tcmove'])
waittime = max(movetime / 4, movetime - moveused)
waittime = min(movetime - 5, waittime)
state = self.updatestate(waittime)
if not oplogged and state.get(opplayer, "") != "":
opname = state[opplayer]
if opname.startswith('*'):
opname = opname[2:]
log.info("Playing against %s", opname)
engine.setoption("rating", state[self.side + "rating"])
engine.setoption("opponent", opname)
engine.setoption("opponent_rating",
state[opside + "rating"])
engine.setoption("rated", state.get('rated', 1))
oplogged = True
oppresent = opside + "present"
if (state.get('starttime', "") == "" and
state.get(opplayer, "") != "" and
int(state.get(oppresent, "0")) < 1 and
state.get('timecontrol', "") != ""):
while (time.time() - turnchange < 5 * 60 and
int(state.get(oppresent, "0")) < 1):
time.sleep(10)
state = self.updatestate()
if int(state.get(oppresent, "0")) < 1:
log.info("%s left before game started", state[opplayer])
return
if not oplogged and state.get(opplayer, "") != "":
opname = state[opplayer]
if opname.startswith('*'):
opname = opname[2:]
log.info("Playing against %s", opname)
engine.setoption("rating", state[self.side + "rating"])
engine.setoption("opponent", opname)
engine.setoption("opponent_rating", state[opside + "rating"])
engine.setoption("rated", state.get('rated', 1))
oplogged = True
if not oplogged and int(state.get('postal', "0")) < 1:
# if the game hasn't started and not postal wait some more
state = self.updatestate(300)
continue
gotmove = opmove_re.search(state.get('moves', ""))
if gotmove:
gotmove = gotmove.group(1)
log.info("Received move %s", gotmove)
enginemove = " ".join(gotmove.split()[1:])
engine.makemove(enginemove)
else:
log.info("Starting game")
self.startgame()
positionlog.info("\n%s", state['position'])
if state.get('result', "") == "":
try:
# eat any log, info, etc. messages the engine has sent
while True:
self._check_engine(0)
except socket.timeout:
pass
tused_key = "%sused" % (self.side, )
if tused_key in state:
moveused = int(state[tused_key])
else:
moveused = 0
starttime = time.time() - moveused
timeusedname = "moveused"
gusedname = "gused"
susedname = "sused"
if engine.protocol_version == 0:
timeusedname = "tcmoveused"
gusedname = "wused"
susedname = "bused"
engine.setoption(timeusedname, moveused)
self._update_timecontrol(state)
if engine.protocol_version == 0:
engine.setoption("wreserve", state['tcwreserve2'])
engine.setoption("breserve", state['tcbreserve2'])
else:
engine.setoption("greserve", state['tcwreserve2'])
engine.setoption("sreserve", state['tcbreserve2'])
if 'wused' in state:
engine.setoption(gusedname, state['wused'])
if 'bused' in state:
engine.setoption(susedname, state['bused'])
if 'lastmoveused' in state:
if engine.protocol_version == 0:
engine.setoption("tclastmoveused",
state['lastmoveused'])
engine.setoption("lastmoveused", state['lastmoveused'])
engine.go()
stopsent = False
myreserve = "tc%sreserve2" % (self.side, )
stoptime = starttime + int(state['tcmove']) + int(
state[myreserve])
if ('turntime' in state and
(starttime + state['turntime']) < stoptime):
stoptime = int(starttime + state['turntime'])
stoptime -= self.min_timeleft
waittime = 10
secondtimeupdate = False
while True:
now = time.time()
if not stopsent and now + waittime > stoptime:
waittime = (stoptime - now) + 0.2
if waittime < 0:
waittime = 0
if not stopsent and now >= stoptime:
# try and get a move before time runs out
engine.stop()
log.info("Engine sent stop command to prevent timeout")
waittime = 10
stopsent = True
try:
response = self._check_engine(waittime)
if response.type == "bestmove":
break
if (response.type == "info" and
response.message.startswith("time") and
not secondtimeupdate):
engine.setoption(timeusedname,
int(time.time() - starttime))
secondtimeupdate = True
except socket.timeout:
pass
engine.makemove(response.move)
endtime = time.time()
if (self.min_move_time > endtime - starttime and
int(state.get('plycount', 0)) > 1):
stime = self.min_move_time - (endtime - starttime)
if stime > 0:
log.info("Waiting %.2f seconds before sending move",
stime)
time.sleep(stime)
log.info("Sending move %s", response.move)
self.move(response.move)
if self.ponder and not stopsent:
engine.go("ponder")
state = self.updatestate()
positionlog.info("\n%s", state['position'])
win = "I won"
if state['result'].lower()[0] != self.side.lower():
win = "I lost"
log.info("Game over, %s result: '%s'", win, state['result'])
log.info("Getting permanent id from %s", self.gid)
permanent_id = state.get("finishedId", None)
get_id_tries = 0
while not permanent_id and get_id_tries <= 3:
time.sleep(2 * get_id_tries)
permanent_id = post(self.gameroom.url,
{"action": "findgameid",
"tid": self.gid},
"Table.findgameid").get("gid", None)
get_id_tries += 1
if permanent_id:
log.info("Permanent game id is #%s", permanent_id)
class GameRoom:
def __init__(self, url):
if url.endswith("/"):
self.url = url + _GR_CGI
else:
self.url = url + "/" + _GR_CGI
self.sid = None
def login(self, username, password):
values = dict(username=username, password=password, action="login")
response = post(self.url, values, "GameRoom.login")
self.sid = response['sid']
log.info("Logged into gameroom as %s", username)
def logout(self):
if not self.sid:
log.warning("GameRoom.logout called before sid set.")
return '0'
values = dict(sid=self.sid, action="leave")
response = post(self.url, values, "GameRoom.logout")
try:
ret = bool(int(response['ok']))
except KeyError:
ret = False
return ret
def newgame(self, side, timecontrol="2/2/100/2/0", rated=False):
if rated:
rated = 1
else:
rated = 0
if (side != 'b') and (side != 'w'):
raise ValueError("Invalid value for side, %s" % (side))
values = dict(timecontrol=timecontrol,
rated=rated,
side=side,
sid=self.sid,
action="newGame")
tableinfo = post(self.url, values, "GameRoom.newgame")
tableinfo = parsebody(list(tableinfo.values())[0])
return Table(self, tableinfo)
def mygames(self):
values = dict(sid=self.sid, what="myGames")
gamedata = post(self.url, values, "GameRoom.mygames")
games = list()
for gameid, gameinfo in gamedata.items():
if re.match(r"\d+:[wb]", gameid):
games.append(parsebody(gameinfo))
return games
def opengames(self):
values = dict(sid=self.sid, what="join")
gamedata = post(self.url, values, "GameRoom.opengames")
games = list()
for gameid, gameinfo in gamedata.items():
if re.match(r"\d+:[wb]", gameid):
games.append(parsebody(gameinfo))
return games
def parseargs(args):
parser = optparse.OptionParser(
usage="usage: %prog [-c CONFIG] [-b BOT] [play|move opponent|id] [side]",
description="Interface to the Arimaa gameserver",
epilog="".join(
["Positional arguments: ",
"'play' or 'move' as the first argument specify whether to play ",
"an existing full game or just one move before exiting . They ",
"must be followed by either the name of the opponents game to ",
"join or an explicit game number. ",
"The side to play can be given by itself or following the ",
"previous arguments."]))
parser.add_option('-c', '--config',
default="gameroom.cfg",
help="Configuration file to use.")
parser.add_option('-b', '--bot',
help="bot section to use from configuration.")
options, args = parser.parse_args(args)
ret = dict()
ret['config'] = options.config
ret['bot'] = options.bot
if len(args) < 2:
ret.update(dict(against='', side='b', onemove=False))
return ret
first = args[1].lower()
if len(first) == 1 and first in "wbgs":
ret.update(dict(against='', side=first, onemove=False))
return ret
if first == "play" or first == "move":
if len(args) < 3:
raise ValueError("Not enough arguments given for command")
ret.update(dict(against=args[2].lower()))
if len(args) > 3:
ret['side'] = args[3].lower()
else:
ret['side'] = ""
if first == "move":
ret['onemove'] = True
else:
ret['onemove'] = False
return ret
parser.print_help()
raise ValueError("Bad commandline arguments")
def touch_run_file(run_dir, rfile):
filename = os.path.join(run_dir, rfile)
run_file = open(filename, 'w')
run_file.write("%d\n" % os.getpid())
run_file.close()
log.info("Created run file at %s" % filename)
def remove_run_file(run_dir, rfile):
filename = os.path.join(run_dir, rfile)
try:
os.remove(filename)
except OSError:
pass
log.info("Removed run file at %s" % filename)
def how_many_bots(run_dir):
files = os.listdir(run_dir)
count = 0
for filename in files:
if filename.endswith('.bot'):
with open(os.path.join(run_dir, filename), 'r') as run_file:
try:
pid = int(run_file.read())
if sys.platform == 'win32':
count += 1
else:
try:
os.kill(pid, 0)
count += 1
except OSError:
pass
except ValueError:
pass
return count
def already_playing(run_dir, gameid, side):
isplaying = False
runfn = os.path.join(run_dir, "%s%s.bot" % (gameid, side))
try:
with open(runfn, 'r') as run_file:
try:
pid = int(run_file.read())
if sys.platform == 'win32':
isplaying = True
else:
try:
if os.kill(pid, signal.SIGCONT) > 0:
isplaying = True
except OSError:
pass
except ValueError:
pass
except IOError:
pass
log.info("The file %s indicates we are already playing at %s on side %s" %
(runfn, gameid, side))
return isplaying
def str_loglevel(strlevel):
strlevel = strlevel.lower()
if strlevel == "debug":
return logging.DEBUG
elif strlevel == "info":
return logging.INFO
elif strlevel == "warning":
return logging.WARNING
elif strlevel == "error":
return logging.ERROR
else:
raise ValueError("Unrecognised logging level")
def shutdown_engine(engine_ctl):
try:
engine_ctl.quit()
except (socket.error, IOError):
pass
for i in range(30):
if engine_ctl.engine.proc.poll() is not None:
break
time.sleep(1)
else:
log.warning("Engine did not exit in 30 seconds, killing process")
try:
if sys.platform == 'win32':
import ctypes
handle = int(engine_ctl.engine.proc._handle)
ctypes.windll.kernel32.TerminateProcess(handle, 0)
else:
os.kill(engine_ctl.engine.proc.pid, signal.SIGTERM)
except os.error:
# don't worry about errors when trying to kill the engine
pass
engine_ctl.cleanup()
time.sleep(1)
def init_logging(config):
aeilog = logging.getLogger("gameroom.aei")
if config.has_section("Logging"):
logdir = config.get("Logging", "directory")
if not os.path.exists(logdir):
print("Log directory '%s' not found, attempting to create it." % (
logdir
))
os.makedirs(logdir)
logfilename = "%s-%s" % (time.strftime("%Y%m%d-%H%M"),
str(os.getpid()), )
logfilename = os.path.join(logdir, logfilename)
if config.has_option("Logging", "level"):
loglevel = str_loglevel(config.get("Logging", "level"))
else:
loglevel = logging.WARN
logging.basicConfig(
level=loglevel,
filename=logfilename + ".log",
datefmt="%Y-%m-%d %H:%M:%S",
format="%(asctime)s %(levelname)s:%(name)s:%(message)s", )
if (config.has_option("Logging", "console") and
config.getboolean("Logging", "console")):
global console
if console is None:
console = logging.StreamHandler()
if config.has_option("Logging", "console_level"):
conlevel = str_loglevel(config.get("Logging", "console_level"))
else:
conlevel = logging.INFO
console.setLevel(conlevel)
logging.getLogger('').addHandler(console)
if config.has_option("Logging", "net_level"):
netlevel = str_loglevel(config.get("Logging", "net_level"))
netlog.setLevel(netlevel)
if config.has_option("Logging", "engine_level"):
enginelevel = str_loglevel(config.get("Logging", "engine_level"))
enginelog.setLevel(enginelevel)
if config.has_option("Logging", "aei_level"):
aeilog.setLevel(str_loglevel(config.get("Logging", "aei_level")))
positionlog.setLevel(logging.ERROR)
if (config.has_option("Logging", "log_position") and
config.getboolean("Logging", "log_position")):
positionlog.setLevel(logging.INFO)
if (config.has_option("Logging", "separate_net_log") and
config.getboolean("Logging", "separate_net_log")):
netfmt = logging.Formatter(
fmt="%(asctime)s %(levelname)s: %(message)s",
datefmt="%Y-%m-%d %H:%M:%S")
nethandler = logging.FileHandler(logfilename + "-net.log")
nethandler.setFormatter(netfmt)
netlog.addHandler(nethandler)
netlog.propagate = False
log.info("Created net log file %s at level %s" %
(logfilename + "-net.log",
logging.getLevelName(netlevel)))
def run_game(options, config):
run_dir = config.get("global", "run_dir")
if not os.path.exists(run_dir):
log.warning("Run file directory '%s' not found, attempting to create it."
% (run_dir))
os.makedirs(run_dir)
bot_count = how_many_bots(run_dir)
if bot_count >= config.getint("global", "max_bots"):
log.info(
"Max number of bot limit %d reached, need to wait until some bots finish."
% (config.getint("global", "max_bots")))
return
if options['bot']:
bot_section = options['bot']
else:
bot_section = config.get("global", "default_engine")
if config.has_option(bot_section, "communication_method"):
com_method = config.get(bot_section, "communication_method").lower()
else:
com_method = "stdio"
enginecmd = config.get(bot_section, "cmdline")
gameid_or_opponent = options['against']
unknowns_caught = 0
bot_crashes = 0
while True:
try:
engine_com = aei.get_engine(com_method, enginecmd,
logname="gameroom.aei")
engine_ctl = aei.EngineController(engine_com)
except OSError as exc:
log.error("Could not start the engine; exception thrown: %s", exc)
return 1
try:
for option in config.options(bot_section):
if option.startswith("bot_"):
value = config.get(bot_section, option)
engine_ctl.setoption(option[4:], value)
log.info("Setting bot option %s = %s", option[4:], value)
resps = engine_ctl.isready()
for response in resps:
log_response(response, "while sending bot options")
try:
bot_username = config.get(bot_section, "username")
bot_password = config.get(bot_section, "password")
except NoOptionError:
try:
bot_username = config.get("global", "username")
bot_password = config.get("global", "password")
except NoOptionError:
log.error("Could not find username/password in config.")
return 1
bot_greeting = config.get(bot_section, "greeting")
gameroom = GameRoom(config.get("global", "gameroom_url"))
gameroom.login(bot_username, bot_password)
side = options['side']
if side == "g":
side = "w"
elif side == "s":
side = "b"
table = None
if gameid_or_opponent == "":
log.info("Starting a new game")
if side == "":
side = 'b'
timecontrol = config.get(bot_section, "timecontrol")
rated = config.getboolean(bot_section, "rated")
log.info("Will play on side %s, using timecontrol %s" %
(side, timecontrol))
table = gameroom.newgame(side, timecontrol, rated)
else:
# look through my games for correct opponent and side
games = gameroom.mygames()
for game in games:
if (gameid_or_opponent == game['player'].lower() or
gameid_or_opponent == game['gid']):
if (side == "" or
side == game['side'] and not already_playing(
run_dir, game['gid'], game['side'])):
table = Table(gameroom, game)
log.info("Found in progress game")
break
if table == None:
games = gameroom.opengames()
for game in games:
if (gameid_or_opponent == game['player'].lower() or
gameid_or_opponent == game['gid']):
if (side == "" or
side == game['side'] and not already_playing(
run_dir, game['gid'], game['side'])):
table = Table(gameroom, game)
log.info("Found game to join")
break
if table == None:
log.error("Could not find game against %s with side '%s'",
gameid_or_opponent, side)
engine_ctl.quit()
engine_ctl.cleanup()
return 1
# Set the game to play in to current game id in case of a restart
gameid_or_opponent = table.gid
if options['against'] != "":
joinmsg = "Joined game gid=%s side=%s; against %s" % (
table.gid, table.side, options['against']
)
else:
joinmsg = "Created game gid=%s side=%s; waiting for opponent"\
% (table.gid, table.side)
log.info(joinmsg)
if console is None:
print(joinmsg)
# force the std streams to flush so the bot starter script used
# on the arimaa.com server can pick up the join message
sys.stdout.flush()
sys.stderr.flush()
if config.has_option(bot_section, "ponder"):
table.ponder = config.getboolean(bot_section, "ponder")
if table.ponder:
log.info("Set pondering on.")
else:
log.info("Set pondering off.")
else:
table.ponder = False
if config.has_option("global", "min_move_time"):
table.min_move_time = config.getint("global", "min_move_time")
log.info("Set minimum move time to %d seconds.",
table.min_move_time)
else:
table.min_move_time = 5
if config.has_option("global", "min_time_left"):
table.min_timeleft = config.getint("global", "min_time_left")
log.info("Setting emergency stop time to %d seconds" %
table.min_timeleft)
else:
table.min_timeleft = 5
except:
shutdown_engine(engine_ctl)
raise
try:
try:
log.info("Joining game on %s side", table.side)
table.reserveseat()
table.sitdown()
table.updatestate()
engine_ctl.setoption("rated", table.state.get('rated', 1))
try:
touch_run_file(run_dir, "%s%s.bot" %
(table.gid, table.side))
time.sleep(1) # Give the server a small break.
log.info("Starting play")
table.playgame(engine_ctl, bot_greeting, options['onemove'])
finally:
log.info("Leaving game")
remove_run_file(run_dir, "%s%s.bot" %
(table.gid, table.side))
table.leave()
break
finally:
shutdown_engine(engine_ctl)
except EngineCrashException as exc:
bot_crashes += 1
if bot_crashes >= 1000:
log.error("Bot engine crashed 1000 times, giving up.")
return 2
log.error("Bot engine crashed (%s), restarting.", exc.args[0])
time.sleep(1)
except Exception:
unknowns_caught += 1
if unknowns_caught > 5:
log.error("Caught 6 unknown exceptions, giving up.\n%s" %
(traceback.format_exc(), ))
return 2
log.error("Caught unkown exception #%d, restarting.\n%s" %
(unknowns_caught, traceback.format_exc()))
time.sleep(2)
def main(args=sys.argv):
"""Main entry for script.
Parses the command line. Reads 'gameroom.cfg' for the configuration.
Starts the engine and gives it any initial configuration. Joins or creates
the specified game. Then finally controls the engine passing it the game
information and sending engine responses back to the server.
"""
try:
options = parseargs(args)
except ValueError:
print("Command not understood '%s'" % (" ".join(args[1:])))
return 2
config = ConfigParser()
config_filename = options['config']
files_read = config.read(config_filename)
if len(files_read) == 0:
print("Could not open '%s'" % (config_filename, ))
print("this file must be readable and contain the configuration")
print("for connecting to the gameroom.")
return 1
init_logging(config)
return run_game(options, config)
if __name__ == "__main__":
sys.exit(main()) | AEI | /AEI-1.3.0.tar.gz/AEI-1.3.0/pyrimaa/gameroom.py | gameroom.py |
### GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
### Preamble
The licenses for most software are designed to take away your freedom
to share and change it. By contrast, the GNU General Public License is
intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Lesser General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if
you distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on,
we want its recipients to know that what they have is not the
original, so that any problems introduced by others will not reflect
on the original authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at
all.
The precise terms and conditions for copying, distribution and
modification follow.
### TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
**0.** This License applies to any program or other work which
contains a notice placed by the copyright holder saying it may be
distributed under the terms of this General Public License. The
"Program", below, refers to any such program or work, and a "work
based on the Program" means either the Program or any derivative work
under copyright law: that is to say, a work containing the Program or
a portion of it, either verbatim or with modifications and/or
translated into another language. (Hereinafter, translation is
included without limitation in the term "modification".) Each licensee
is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the Program
(independent of having been made by running the Program). Whether that
is true depends on what the Program does.
**1.** You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a
fee.
**2.** You may modify your copy or copies of the Program or any
portion of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
**a)** You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
**b)** You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any part
thereof, to be licensed as a whole at no charge to all third parties
under the terms of this License.
**c)** If the modified program normally reads commands interactively
when run, you must cause it, when started running for such interactive
use in the most ordinary way, to print or display an announcement
including an appropriate copyright notice and a notice that there is
no warranty (or else, saying that you provide a warranty) and that
users may redistribute the program under these conditions, and telling
the user how to view a copy of this License. (Exception: if the
Program itself is interactive but does not normally print such an
announcement, your work based on the Program is not required to print
an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
**3.** You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
**a)** Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections 1
and 2 above on a medium customarily used for software interchange; or,
**b)** Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your cost of
physically performing source distribution, a complete machine-readable
copy of the corresponding source code, to be distributed under the
terms of Sections 1 and 2 above on a medium customarily used for
software interchange; or,
**c)** Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is allowed
only for noncommercial distribution and only if you received the
program in object code or executable form with such an offer, in
accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
**4.** You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt otherwise
to copy, modify, sublicense or distribute the Program is void, and
will automatically terminate your rights under this License. However,
parties who have received copies, or rights, from you under this
License will not have their licenses terminated so long as such
parties remain in full compliance.
**5.** You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
**6.** Each time you redistribute the Program (or any work based on
the Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
**7.** If, as a consequence of a court judgment or allegation of
patent infringement or for any other reason (not limited to patent
issues), conditions are imposed on you (whether by court order,
agreement or otherwise) that contradict the conditions of this
License, they do not excuse you from the conditions of this License.
If you cannot distribute so as to satisfy simultaneously your
obligations under this License and any other pertinent obligations,
then as a consequence you may not distribute the Program at all. For
example, if a patent license would not permit royalty-free
redistribution of the Program by all those who receive copies directly
or indirectly through you, then the only way you could satisfy both it
and this License would be to refrain entirely from distribution of the
Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
**8.** If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
**9.** The Free Software Foundation may publish revised and/or new
versions of the General Public License from time to time. Such new
versions will be similar in spirit to the present version, but may
differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation. If the Program does not specify a
version number of this License, you may choose any version ever
published by the Free Software Foundation.
**10.** If you wish to incorporate parts of the Program into other
free programs whose distribution conditions are different, write to
the author to ask for permission. For software which is copyrighted by
the Free Software Foundation, write to the Free Software Foundation;
we sometimes make exceptions for this. Our decision will be guided by
the two goals of preserving the free status of all derivatives of our
free software and of promoting the sharing and reuse of software
generally.
**NO WARRANTY**
**11.** BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
**12.** IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.
### END OF TERMS AND CONDITIONS
### How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these
terms.
To do so, attach the following notices to the program. It is safest to
attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
one line to give the program's name and an idea of what it does.
Copyright (C) yyyy name of author
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.
Also add information on how to contact you by electronic and paper
mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) year name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details
type `show w'. This is free software, and you are welcome
to redistribute it under certain conditions; type `show c'
for details.
The hypothetical commands \`show w' and \`show c' should show the
appropriate parts of the General Public License. Of course, the
commands you use may be called something other than \`show w' and
\`show c'; they could even be mouse-clicks or menu items--whatever
suits your program.
You should also get your employer (if you work as a programmer) or
your school, if any, to sign a "copyright disclaimer" for the program,
if necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright
interest in the program `Gnomovision'
(which makes passes at compilers) written
by James Hacker.
signature of Ty Coon, 1 April 1989
Ty Coon, President of Vice
This General Public License does not permit incorporating your program
into proprietary programs. If your program is a subroutine library,
you may consider it more useful to permit linking proprietary
applications with the library. If this is what you want to do, use the
[GNU Lesser General Public
License](https://www.gnu.org/licenses/lgpl.html) instead of this
License.
| AEMET-OpenData | /AEMET_OpenData-0.4.4-py3-none-any.whl/AEMET_OpenData-0.4.4.dist-info/LICENSE.md | LICENSE.md |
from datetime import datetime
from typing import Any
from zoneinfo import ZoneInfo
from .const import (
AEMET_ATTR_IDEMA,
AEMET_ATTR_STATION_ALTITUDE,
AEMET_ATTR_STATION_DATE,
AEMET_ATTR_STATION_DEWPOINT,
AEMET_ATTR_STATION_HUMIDITY,
AEMET_ATTR_STATION_LATITUDE,
AEMET_ATTR_STATION_LOCATION,
AEMET_ATTR_STATION_LONGITUDE,
AEMET_ATTR_STATION_PRECIPITATION,
AEMET_ATTR_STATION_PRESSURE,
AEMET_ATTR_STATION_PRESSURE_SEA,
AEMET_ATTR_STATION_TEMPERATURE,
AEMET_ATTR_STATION_TEMPERATURE_MAX,
AEMET_ATTR_STATION_TEMPERATURE_MIN,
AEMET_ATTR_STATION_WIND_DIRECTION,
AEMET_ATTR_STATION_WIND_SPEED,
AEMET_ATTR_STATION_WIND_SPEED_MAX,
AOD_ALTITUDE,
AOD_COORDS,
AOD_DATETIME,
AOD_DEW_POINT,
AOD_DISTANCE,
AOD_HUMIDITY,
AOD_ID,
AOD_NAME,
AOD_OUTDATED,
AOD_PRECIPITATION,
AOD_PRESSURE,
AOD_TEMP,
AOD_TEMP_MAX,
AOD_TEMP_MIN,
AOD_TIMESTAMP,
AOD_TIMEZONE,
AOD_WIND_DIRECTION,
AOD_WIND_SPEED,
AOD_WIND_SPEED_MAX,
ATTR_DATA,
ATTR_DISTANCE,
STATION_MAX_DELTA,
)
from .helpers import get_current_datetime, parse_api_timestamp, timezone_from_coords
class Station:
"""AEMET OpenData Station."""
altitude: float
coords: tuple[float, float]
_datetime: datetime
distance: float
dew_point: float | None
humidity: float | None
id: str
name: str
precipitation: float | None
pressure: float | None
temp: float | None
temp_max: float | None
temp_min: float | None
wind_direction: float | None
wind_speed: float | None
wind_speed_max: float | None
zoneinfo: ZoneInfo
def __init__(self, data: dict[str, Any]) -> None:
"""Init AEMET OpenData Station."""
self.altitude = float(data[AEMET_ATTR_STATION_ALTITUDE])
self.coords = (
float(data[AEMET_ATTR_STATION_LATITUDE]),
float(data[AEMET_ATTR_STATION_LONGITUDE]),
)
self.distance = float(data[ATTR_DISTANCE])
self.id = str(data[AEMET_ATTR_IDEMA])
self.name = str(data[AEMET_ATTR_STATION_LOCATION])
self.zoneinfo = timezone_from_coords(self.coords)
self.update_sample(data)
def get_altitude(self) -> float:
"""Return Station altitude."""
return self.altitude
def get_coords(self) -> tuple[float, float]:
"""Return Station coordinates."""
return self.coords
def get_datetime(self) -> datetime:
"""Return Station datetime of data."""
return self._datetime
def get_distance(self) -> float:
"""Return Station distance from selected coordinates."""
return round(self.distance, 3)
def get_dew_point(self) -> float | None:
"""Return Station dew point."""
return self.dew_point
def get_humidity(self) -> float | None:
"""Return Station humidity."""
return self.humidity
def get_id(self) -> str:
"""Return Station ID."""
return self.id
def get_name(self) -> str | None:
"""Return Station name."""
return self.name
def get_outdated(self) -> bool:
"""Return Station data outdated."""
cur_dt = get_current_datetime()
return cur_dt > self.get_datetime() + STATION_MAX_DELTA
def get_precipitation(self) -> float | None:
"""Return Station precipitation."""
return self.precipitation
def get_pressure(self) -> float | None:
"""Return Station pressure."""
return self.pressure
def get_temp(self) -> float | None:
"""Return Station temperature."""
return self.temp
def get_temp_max(self) -> float | None:
"""Return Station maximum temperature."""
return self.temp_max
def get_temp_min(self) -> float | None:
"""Return Station minimum temperature."""
return self.temp_min
def get_timestamp(self) -> str:
"""Return Station timestamp."""
return self._datetime.isoformat()
def get_timezone(self) -> ZoneInfo:
"""Return Station timezone."""
return self.zoneinfo
def get_wind_direction(self) -> float | None:
"""Return Station wind direction."""
return self.wind_direction
def get_wind_speed(self) -> float | None:
"""Return Station wind speed."""
return self.wind_speed
def get_wind_speed_max(self) -> float | None:
"""Return Station maximum wind speed."""
return self.wind_speed_max
def update_sample(self, data: dict[str, Any]) -> None:
"""Update Station data from sample."""
station_dt = parse_api_timestamp(data[AEMET_ATTR_STATION_DATE])
self._datetime = station_dt.astimezone(self.get_timezone())
if AEMET_ATTR_STATION_DEWPOINT in data:
self.dew_point = float(data[AEMET_ATTR_STATION_DEWPOINT])
if AEMET_ATTR_STATION_HUMIDITY in data:
self.humidity = float(data[AEMET_ATTR_STATION_HUMIDITY])
if AEMET_ATTR_STATION_PRECIPITATION in data:
self.precipitation = float(data[AEMET_ATTR_STATION_PRECIPITATION])
if AEMET_ATTR_STATION_PRESSURE_SEA in data:
self.pressure = float(data[AEMET_ATTR_STATION_PRESSURE_SEA])
elif AEMET_ATTR_STATION_PRESSURE in data:
self.pressure = float(data[AEMET_ATTR_STATION_PRESSURE])
if AEMET_ATTR_STATION_TEMPERATURE in data:
self.temp = float(data[AEMET_ATTR_STATION_TEMPERATURE])
if AEMET_ATTR_STATION_TEMPERATURE_MAX in data:
self.temp_max = float(data[AEMET_ATTR_STATION_TEMPERATURE_MAX])
if AEMET_ATTR_STATION_TEMPERATURE_MIN in data:
self.temp_min = float(data[AEMET_ATTR_STATION_TEMPERATURE_MIN])
if AEMET_ATTR_STATION_WIND_DIRECTION in data:
self.wind_direction = float(data[AEMET_ATTR_STATION_WIND_DIRECTION])
if AEMET_ATTR_STATION_WIND_SPEED in data:
self.wind_speed = float(data[AEMET_ATTR_STATION_WIND_SPEED])
if AEMET_ATTR_STATION_WIND_SPEED_MAX in data:
self.wind_speed_max = float(data[AEMET_ATTR_STATION_WIND_SPEED_MAX])
def update_samples(self, samples: dict[str, Any]) -> None:
"""Update Station data from samples."""
latest: dict[str, Any]
latest_dt: datetime | None = None
for sample in samples[ATTR_DATA]:
dt = parse_api_timestamp(sample[AEMET_ATTR_STATION_DATE])
if latest_dt is None or dt > latest_dt:
latest = sample
latest_dt = dt
if (
latest_dt is not None
and self.get_datetime() < latest_dt <= get_current_datetime()
):
self.update_sample(latest)
def data(self) -> dict[str, Any]:
"""Return station data."""
data: dict[str, Any] = {
AOD_ALTITUDE: self.get_altitude(),
AOD_COORDS: self.get_coords(),
AOD_DATETIME: self.get_datetime(),
AOD_DISTANCE: self.get_distance(),
AOD_ID: self.get_id(),
AOD_NAME: self.get_name(),
AOD_OUTDATED: self.get_outdated(),
AOD_TIMESTAMP: self.get_timestamp(),
AOD_TIMEZONE: self.get_timezone(),
}
dew_point = self.get_dew_point()
if dew_point is not None:
data[AOD_DEW_POINT] = dew_point
humidity = self.get_humidity()
if humidity is not None:
data[AOD_HUMIDITY] = humidity
precipitation = self.get_precipitation()
if precipitation is not None:
data[AOD_PRECIPITATION] = precipitation
pressure = self.get_pressure()
if pressure is not None:
data[AOD_PRESSURE] = pressure
temp = self.get_temp()
if temp is not None:
data[AOD_TEMP] = temp
temp_max = self.get_temp_max()
if temp_max is not None:
data[AOD_TEMP_MAX] = temp_max
temp_min = self.get_temp_min()
if temp_min is not None:
data[AOD_TEMP_MIN] = temp_min
wind_direction = self.get_wind_direction()
if wind_direction is not None:
data[AOD_WIND_DIRECTION] = wind_direction
wind_speed = self.get_wind_speed()
if wind_speed is not None:
data[AOD_WIND_SPEED] = wind_speed
wind_speed_max = self.get_wind_speed_max()
if wind_speed_max is not None:
data[AOD_WIND_SPEED_MAX] = wind_speed_max
return data
def weather(self) -> dict[str, Any]:
"""Return Station weather data."""
weather: dict[str, Any] = {}
dew_point = self.get_dew_point()
if dew_point is not None:
weather[AOD_DEW_POINT] = dew_point
humidity = self.get_humidity()
if humidity is not None:
weather[AOD_HUMIDITY] = humidity
precipitation = self.get_precipitation()
if precipitation is not None:
weather[AOD_PRECIPITATION] = precipitation
pressure = self.get_pressure()
if pressure is not None:
weather[AOD_PRESSURE] = pressure
temp = self.get_temp()
if temp is not None:
weather[AOD_TEMP] = temp
wind_direction = self.get_wind_direction()
if wind_direction is not None:
weather[AOD_WIND_DIRECTION] = wind_direction
wind_speed = self.get_wind_speed()
if wind_speed is not None:
weather[AOD_WIND_SPEED] = wind_speed
wind_speed_max = self.get_wind_speed_max()
if wind_speed_max is not None:
weather[AOD_WIND_SPEED_MAX] = wind_speed_max
return weather | AEMET-OpenData | /AEMET_OpenData-0.4.4-py3-none-any.whl/aemet_opendata/station.py | station.py |
from datetime import datetime
from typing import Any, Final
from .const import (
AEMET_ATTR_DIRECTION,
AEMET_ATTR_FEEL_TEMPERATURE,
AEMET_ATTR_HUMIDITY,
AEMET_ATTR_MAX,
AEMET_ATTR_MIN,
AEMET_ATTR_PERIOD,
AEMET_ATTR_PRECIPITATION,
AEMET_ATTR_PRECIPITATION_PROBABILITY,
AEMET_ATTR_SKY_STATE,
AEMET_ATTR_SNOW,
AEMET_ATTR_SNOW_PROBABILITY,
AEMET_ATTR_SPEED,
AEMET_ATTR_STORM_PROBABILITY,
AEMET_ATTR_SUN_RISE,
AEMET_ATTR_SUN_SET,
AEMET_ATTR_TEMPERATURE,
AEMET_ATTR_UV_MAX,
AEMET_ATTR_VALUE,
AEMET_ATTR_WIND,
AEMET_ATTR_WIND_GUST,
AOD_COND_CLEAR_NIGHT,
AOD_COND_CLOUDY,
AOD_COND_FOG,
AOD_COND_LIGHTNING,
AOD_COND_LIGHTNING_RAINY,
AOD_COND_PARTLY_CLODUY,
AOD_COND_POURING,
AOD_COND_RAINY,
AOD_COND_SNOWY,
AOD_COND_SUNNY,
AOD_CONDITION,
AOD_FEEL_TEMP,
AOD_FEEL_TEMP_MAX,
AOD_FEEL_TEMP_MIN,
AOD_HUMIDITY,
AOD_HUMIDITY_MAX,
AOD_HUMIDITY_MIN,
AOD_PRECIPITATION,
AOD_PRECIPITATION_PROBABILITY,
AOD_RAIN,
AOD_RAIN_PROBABILITY,
AOD_SNOW,
AOD_SNOW_PROBABILITY,
AOD_STORM_PROBABILITY,
AOD_SUNRISE,
AOD_SUNSET,
AOD_TEMP,
AOD_TEMP_MAX,
AOD_TEMP_MIN,
AOD_TIMESTAMP,
AOD_UV_INDEX,
AOD_WIND_DIRECTION,
AOD_WIND_SPEED,
AOD_WIND_SPEED_MAX,
API_PERIOD_24H,
API_PERIOD_FULL_DAY,
API_PERIOD_HALF_2_DAY,
API_PERIOD_SPLIT,
)
API_CONDITIONS_MAP: Final[dict[str, list[str]]] = {
AOD_COND_CLEAR_NIGHT: [
"11n", # Despejado (de noche)
],
AOD_COND_CLOUDY: [
"14", # Nuboso
"14n", # Nuboso (de noche)
"15", # Muy nuboso
"15n", # Muy nuboso (de noche)
"16", # Cubierto
"16n", # Cubierto (de noche)
"17", # Nubes altas
"17n", # Nubes altas (de noche)
],
AOD_COND_FOG: [
"81", # Niebla
"81n", # Niebla (de noche)
"82", # Bruma - Neblina
"82n", # Bruma - Neblina (de noche)
],
AOD_COND_LIGHTNING: [
"51", # Intervalos nubosos con tormenta
"51n", # Intervalos nubosos con tormenta (de noche)
"52", # Nuboso con tormenta
"52n", # Nuboso con tormenta (de noche)
"53", # Muy nuboso con tormenta
"53n", # Muy nuboso con tormenta (de noche)
"54", # Cubierto con tormenta
"54n", # Cubierto con tormenta (de noche)
],
AOD_COND_LIGHTNING_RAINY: [
"61", # Intervalos nubosos con tormenta y lluvia escasa
"61n", # Intervalos nubosos con tormenta y lluvia escasa (de noche)
"62", # Nuboso con tormenta y lluvia escasa
"62n", # Nuboso con tormenta y lluvia escasa (de noche)
"63", # Muy nuboso con tormenta y lluvia escasa
"63n", # Muy nuboso con tormenta y lluvia escasa (de noche)
"64", # Cubierto con tormenta y lluvia escasa
"64n", # Cubierto con tormenta y lluvia escasa (de noche)
],
AOD_COND_PARTLY_CLODUY: [
"12", # Poco nuboso
"12n", # Poco nuboso (de noche)
"13", # Intervalos nubosos
"13n", # Intervalos nubosos (de noche)
],
AOD_COND_POURING: [
"27", # Chubascos
"27n", # Chubascos (de noche)
],
AOD_COND_RAINY: [
"23", # Intervalos nubosos con lluvia
"23n", # Intervalos nubosos con lluvia (de noche)
"24", # Nuboso con lluvia
"24n", # Nuboso con lluvia (de noche)
"25", # Muy nuboso con lluvia
"25n", # Muy nuboso con lluvia (de noche)
"26", # Cubierto con lluvia
"26n", # Cubierto con lluvia (de noche)
"43", # Intervalos nubosos con lluvia escasa
"43n", # Intervalos nubosos con lluvia escasa (de noche)
"44", # Nuboso con lluvia escasa
"44n", # Nuboso con lluvia escasa (de noche)
"45", # Muy nuboso con lluvia escasa
"45n", # Muy nuboso con lluvia escasa (de noche)
"46", # Cubierto con lluvia escasa
"46n", # Cubierto con lluvia escasa (de noche)
],
AOD_COND_SNOWY: [
"33", # Intervalos nubosos con nieve
"33n", # Intervalos nubosos con nieve (de noche)
"34", # Nuboso con nieve
"34n", # Nuboso con nieve (de noche)
"35", # Muy nuboso con nieve
"35n", # Muy nuboso con nieve (de noche)
"36", # Cubierto con nieve
"36n", # Cubierto con nieve (de noche)
"71", # Intervalos nubosos con nieve escasa
"71n", # Intervalos nubosos con nieve escasa (de noche)
"72", # Nuboso con nieve escasa
"72n", # Nuboso con nieve escasa (de noche)
"73", # Muy nuboso con nieve escasa
"73n", # Muy nuboso con nieve escasa (de noche)
"74", # Cubierto con nieve escasa
"74n", # Cubierto con nieve escasa (de noche)
],
AOD_COND_SUNNY: [
"11", # Despejado
],
}
WIND_DIRECTION_MAP: Final[dict[str, float | None]] = {
"C": None,
"N": 0.0,
"NE": 45.0,
"E": 90.0,
"SE": 135.0,
"S": 180.0,
"SO": 225.0,
"O": 270.0,
"NO": 315.0,
}
def hash_api_conditions(conditions_map: dict[str, list[str]]) -> dict[str, str]:
"""Hash API conditions for faster access."""
res: dict[str, Any] = {}
for k, v in conditions_map.items():
for c in v:
res[c] = k
return res
CONDITIONS_DICT: Final[dict[str, str]] = hash_api_conditions(API_CONDITIONS_MAP)
class ForecastValue:
"""AEMET OpenData Town Forecast value."""
@classmethod
def parse_condition(cls, condition: str) -> str:
"""Parse forecast condition from API to human readable."""
return CONDITIONS_DICT.get(condition, condition)
@classmethod
def parse_precipitation(cls, precipitation: str | None) -> float | None:
"""Parse forecast precipitation into a float."""
if precipitation is None:
return None
if precipitation == "Ip":
return 0.0
return float(precipitation)
@classmethod
def parse_wind_direction(cls, wind_direction: str) -> float | None:
"""Parse forecast wind direction into a float."""
return WIND_DIRECTION_MAP.get(wind_direction)
class DailyForecastValue(ForecastValue):
"""AEMET OpenData Town Daily Forecast value."""
condition: str
_datetime: datetime
feel_temp_max: int
feel_temp_min: int
humidity_max: int
humidity_min: int
periods: list[str] = [
API_PERIOD_FULL_DAY,
API_PERIOD_HALF_2_DAY,
]
precipitation_prob: int
temp_max: int
temp_min: int
uv_index: int | None
wind_direction: float | None
wind_speed: float | None
def __init__(self, data: dict[str, Any], dt: datetime) -> None:
"""Init AEMET OpenData Town Daily Forecast."""
condition = self.parse_value(data[AEMET_ATTR_SKY_STATE])
if condition is None or not condition:
raise ValueError
self.condition = self.parse_condition(condition)
self._datetime = dt
self.feel_temp_max = int(
self.parse_value(data[AEMET_ATTR_FEEL_TEMPERATURE], key=AEMET_ATTR_MAX)
)
self.feel_temp_min = int(
self.parse_value(data[AEMET_ATTR_FEEL_TEMPERATURE], key=AEMET_ATTR_MIN)
)
self.humidity_max = int(
self.parse_value(data[AEMET_ATTR_HUMIDITY], key=AEMET_ATTR_MAX)
)
self.humidity_min = int(
self.parse_value(data[AEMET_ATTR_HUMIDITY], key=AEMET_ATTR_MIN)
)
self.precipitation_prob = int(
self.parse_value(data[AEMET_ATTR_PRECIPITATION_PROBABILITY])
)
self.temp_max = int(
self.parse_value(data[AEMET_ATTR_TEMPERATURE], key=AEMET_ATTR_MAX)
)
self.temp_min = int(
self.parse_value(data[AEMET_ATTR_TEMPERATURE], key=AEMET_ATTR_MIN)
)
self.wind_direction = self.parse_wind_direction(
self.parse_value(data[AEMET_ATTR_WIND], key=AEMET_ATTR_DIRECTION),
)
if self.wind_direction is not None:
self.wind_speed = int(
self.parse_value(data[AEMET_ATTR_WIND], key=AEMET_ATTR_SPEED)
)
else:
self.wind_speed = None
if AEMET_ATTR_UV_MAX in data:
self.uv_index = int(data[AEMET_ATTR_UV_MAX])
else:
self.uv_index = None
def get_condition(self) -> str | None:
"""Return Town daily forecast condition."""
return self.condition
def get_datetime(self) -> datetime:
"""Return Town daily forecast datetime."""
return self._datetime
def get_feel_temp_max(self) -> int:
"""Return Town daily forecast maximum feel temperature."""
return self.feel_temp_max
def get_feel_temp_min(self) -> int:
"""Return Town daily forecast minimum feel temperature."""
return self.feel_temp_min
def get_humidity_max(self) -> int:
"""Return Town daily forecast maximum humidity."""
return self.humidity_max
def get_humidity_min(self) -> int:
"""Return Town daily forecast minimum humidity."""
return self.humidity_min
def get_precipitation_prob(self) -> int:
"""Return Town daily forecast precipitation probability."""
return self.precipitation_prob
def get_temp_max(self) -> int:
"""Return Town daily forecast maximum temperature."""
return self.temp_max
def get_temp_min(self) -> int:
"""Return Town daily forecast minimum temperature."""
return self.temp_min
def get_timestamp(self) -> str:
"""Return Town daily forecast timestamp."""
return self._datetime.isoformat()
def get_uv_index(self) -> int | None:
"""Return Town daily forecast UV index."""
return self.uv_index
def get_wind_direction(self) -> float | None:
"""Return Town daily forecast wind direction."""
return self.wind_direction
def get_wind_speed(self) -> float | None:
"""Return Town daily forecast wind speed."""
return self.wind_speed
def data(self) -> dict[str, Any]:
"""Return Town daily forecast data."""
data: dict[str, Any] = {
AOD_CONDITION: self.get_condition(),
AOD_FEEL_TEMP_MAX: self.get_feel_temp_max(),
AOD_FEEL_TEMP_MIN: self.get_feel_temp_min(),
AOD_HUMIDITY_MAX: self.get_humidity_max(),
AOD_HUMIDITY_MIN: self.get_humidity_min(),
AOD_PRECIPITATION_PROBABILITY: self.get_precipitation_prob(),
AOD_TEMP_MAX: self.get_temp_max(),
AOD_TEMP_MIN: self.get_temp_min(),
AOD_TIMESTAMP: self.get_timestamp(),
AOD_UV_INDEX: self.get_uv_index(),
AOD_WIND_DIRECTION: self.get_wind_direction(),
AOD_WIND_SPEED: self.get_wind_speed(),
}
return data
def parse_value(
self, values: dict[str, Any] | list[Any], key: str = AEMET_ATTR_VALUE
) -> Any:
"""Parse Town daily forecast value from data."""
if isinstance(values, list):
if len(values) > 1:
for value in values:
if key not in value:
continue
if isinstance(value[key], str) and not value[key]:
continue
for period in self.periods:
if value[AEMET_ATTR_PERIOD] == period:
return value[key]
else:
if key in values[0]:
return values[0][key]
if isinstance(values, dict):
if key in values:
return values[key]
return None
class HourlyForecastValue(ForecastValue):
"""AEMET OpenData Town Hourly Forecast value."""
condition: str
_datetime: datetime
feel_temp: int | None
humidity: int | None
rain: float | None
rain_probability: int | None
snow: float | None
snow_probability: int | None
storm_probability: int | None
sunrise: str
sunset: str
temp: int | None
wind_direction: float | None
wind_speed: float | None
wind_speed_max: float | None
def __init__(self, data: dict[str, Any], dt: datetime, hour: int) -> None:
"""Init AEMET OpenData Town Hourly Forecast."""
condition = self.parse_value(data[AEMET_ATTR_SKY_STATE], hour)
if condition is None:
raise ValueError
self.condition = self.parse_condition(condition)
self._datetime = dt.replace(hour=hour)
self.sunrise = str(data[AEMET_ATTR_SUN_RISE])
self.sunset = str(data[AEMET_ATTR_SUN_SET])
feel_temp = self.parse_value(data[AEMET_ATTR_FEEL_TEMPERATURE], hour)
if feel_temp is not None:
self.feel_temp = int(feel_temp)
else:
self.feel_temp = None
humidity = self.parse_value(data[AEMET_ATTR_HUMIDITY], hour)
if humidity is not None:
self.humidity = int(humidity)
else:
self.humidity = None
temp = self.parse_value(data[AEMET_ATTR_TEMPERATURE], hour)
if temp is not None:
self.temp = int(temp)
else:
self.temp = None
rain_probability = self.parse_interval_value(
data[AEMET_ATTR_PRECIPITATION_PROBABILITY], hour
)
if rain_probability is not None:
self.rain_probability = int(rain_probability)
rain = self.parse_value(data[AEMET_ATTR_PRECIPITATION], hour)
if rain is not None:
self.rain = self.parse_precipitation(rain)
else:
self.rain = None
else:
self.rain = None
self.rain_probability = None
snow_probability = self.parse_interval_value(
data[AEMET_ATTR_SNOW_PROBABILITY], hour
)
if snow_probability is not None:
self.snow_probability = int(snow_probability)
snow = self.parse_value(data[AEMET_ATTR_SNOW], hour)
if snow is not None:
self.snow = self.parse_precipitation(snow)
else:
self.snow = None
else:
self.snow = None
self.snow_probability = None
storm_probability = self.parse_interval_value(
data[AEMET_ATTR_STORM_PROBABILITY], hour
)
if storm_probability is not None:
self.storm_probability = int(storm_probability)
else:
self.storm_probability = None
wind_direction = self.parse_value(
data[AEMET_ATTR_WIND_GUST],
hour,
key=AEMET_ATTR_DIRECTION,
)
if wind_direction is not None:
self.wind_direction = self.parse_wind_direction(wind_direction[0])
else:
self.wind_direction = None
if self.wind_direction is not None:
self.wind_speed = float(
self.parse_value(
data[AEMET_ATTR_WIND_GUST], hour, key=AEMET_ATTR_SPEED
)[0]
)
self.wind_speed_max = float(
self.parse_value(data[AEMET_ATTR_WIND_GUST], hour)
)
else:
self.wind_speed = None
self.wind_speed_max = None
def get_condition(self) -> str:
"""Return Town hourly forecast condition."""
return self.condition
def get_datetime(self) -> datetime:
"""Return Town hourly forecast datetime."""
return self._datetime
def get_feel_temp(self) -> int | None:
"""Return Town hourly forecast feel temperature."""
return self.feel_temp
def get_humidity(self) -> int | None:
"""Return Town hourly forecast humidity."""
return self.humidity
def get_precipitation(self) -> float | None:
"""Return Town hourly forecast precipitation."""
rain = self.get_rain()
snow = self.get_snow()
if rain is not None or snow is not None:
rain = rain or 0.0
snow = snow or 0.0
return rain + snow
return None
def get_precipitation_probability(self) -> int | None:
"""Return Town hourly forecast precipitation probability."""
rain_prob = self.get_rain_probability()
snow_prob = self.get_snow_probability()
if rain_prob is not None or snow_prob is not None:
rain_prob = rain_prob or 0
snow_prob = snow_prob or 0
return max(rain_prob, snow_prob)
return None
def get_rain(self) -> float | None:
"""Return Town hourly forecast rain."""
return self.rain
def get_rain_probability(self) -> int | None:
"""Return Town hourly forecast rain probability."""
return self.rain_probability
def get_snow(self) -> float | None:
"""Return Town hourly forecast snow."""
return self.snow
def get_snow_probability(self) -> int | None:
"""Return Town hourly forecast snow probability."""
return self.snow_probability
def get_storm_probability(self) -> int | None:
"""Return Town hourly forecast storm probability."""
return self.storm_probability
def get_sunrise(self) -> str:
"""Return Town hourly forecast sunrise."""
return self.sunrise
def get_sunset(self) -> str:
"""Return Town hourly forecast sunset."""
return self.sunset
def get_temp(self) -> int | None:
"""Return Town hourly forecast temperature."""
return self.temp
def get_timestamp(self) -> str:
"""Return Town hourly forecast timestamp."""
return self._datetime.isoformat()
def get_wind_direction(self) -> float | None:
"""Return Town hourly forecast wind direction."""
return self.wind_direction
def get_wind_speed(self) -> float | None:
"""Return Town hourly forecast wind speed."""
return self.wind_speed
def get_wind_speed_max(self) -> float | None:
"""Return Town hourly forecast maximum wind speed."""
return self.wind_speed_max
def data(self) -> dict[str, Any]:
"""Return Town hourly forecast data."""
data: dict[str, Any] = {
AOD_CONDITION: self.get_condition(),
AOD_FEEL_TEMP: self.get_feel_temp(),
AOD_HUMIDITY: self.get_humidity(),
AOD_PRECIPITATION: self.get_precipitation(),
AOD_PRECIPITATION_PROBABILITY: self.get_precipitation_probability(),
AOD_RAIN: self.get_rain(),
AOD_RAIN_PROBABILITY: self.get_rain_probability(),
AOD_SNOW: self.get_snow(),
AOD_SNOW_PROBABILITY: self.get_snow_probability(),
AOD_STORM_PROBABILITY: self.get_storm_probability(),
AOD_SUNRISE: self.get_sunrise(),
AOD_SUNSET: self.get_sunset(),
AOD_TEMP: self.get_temp(),
AOD_TIMESTAMP: self.get_timestamp(),
AOD_WIND_DIRECTION: self.get_wind_direction(),
AOD_WIND_SPEED: self.get_wind_speed(),
AOD_WIND_SPEED_MAX: self.get_wind_speed_max(),
}
return data
def parse_interval_value(
self, values: Any, hour: int, key: str = AEMET_ATTR_VALUE
) -> Any:
"""Parse Town hourly forecast interval value from data."""
period_offset = None
for value in values:
if key not in value:
continue
period = value[AEMET_ATTR_PERIOD]
period_start = int(period[0:API_PERIOD_SPLIT])
if period_offset is None or period_start < period_offset:
period_offset = period_start
if period_offset is None:
period_offset = 0
for value in values:
if key not in value:
continue
period = value[AEMET_ATTR_PERIOD]
period_start = int(period[0:API_PERIOD_SPLIT])
period_end = int(period[API_PERIOD_SPLIT : API_PERIOD_SPLIT * 2])
period_start -= period_offset
period_end -= period_offset
if period_end < period_start:
period_end = period_end + API_PERIOD_24H
if hour == 0:
hour = hour + API_PERIOD_24H
if period_start <= hour < period_end:
return None if not value[key] else value[key]
return None
def parse_value(self, values: Any, hour: int, key: str = AEMET_ATTR_VALUE) -> Any:
"""Parse Town hourly forecast value from data."""
for value in values:
if key not in value:
continue
if int(value[AEMET_ATTR_PERIOD]) == hour:
return None if not value[key] else value[key]
return None | AEMET-OpenData | /AEMET_OpenData-0.4.4-py3-none-any.whl/aemet_opendata/forecast.py | forecast.py |
from datetime import timedelta
from typing import Final
AEMET_ATTR_DATA: Final[str] = "datos"
AEMET_ATTR_DATE: Final[str] = "fecha"
AEMET_ATTR_DAY: Final[str] = "dia"
AEMET_ATTR_DIRECTION: Final[str] = "direccion"
AEMET_ATTR_ELABORATED: Final[str] = "elaborado"
AEMET_ATTR_FEEL_TEMPERATURE: Final[str] = "sensTermica"
AEMET_ATTR_FORECAST: Final[str] = "prediccion"
AEMET_ATTR_GUST: Final[str] = "rachaMax"
AEMET_ATTR_HUMIDITY: Final[str] = "humedadRelativa"
AEMET_ATTR_ID: Final[str] = "id"
AEMET_ATTR_IDEMA: Final[str] = "idema"
AEMET_ATTR_MAX: Final[str] = "maxima"
AEMET_ATTR_MIN: Final[str] = "minima"
AEMET_ATTR_NAME: Final[str] = "nombre"
AEMET_ATTR_PERIOD: Final[str] = "periodo"
AEMET_ATTR_PRECIPITATION: Final[str] = "precipitacion"
AEMET_ATTR_PRECIPITATION_PROBABILITY: Final[str] = "probPrecipitacion"
AEMET_ATTR_SKY_STATE: Final[str] = "estadoCielo"
AEMET_ATTR_SNOW: Final[str] = "nieve"
AEMET_ATTR_SNOW_PROBABILITY: Final[str] = "probNieve"
AEMET_ATTR_SPEED: Final[str] = "velocidad"
AEMET_ATTR_STATION_ALTITUDE: Final[str] = "alt"
AEMET_ATTR_STATION_DATE: Final[str] = "fint"
AEMET_ATTR_STATION_DEWPOINT: Final[str] = "tpr"
AEMET_ATTR_STATION_HUMIDITY: Final[str] = "hr"
AEMET_ATTR_STATION_LATITUDE: Final[str] = "lat"
AEMET_ATTR_STATION_LOCATION: Final[str] = "ubi"
AEMET_ATTR_STATION_LONGITUDE: Final[str] = "lon"
AEMET_ATTR_STATION_PRECIPITATION: Final[str] = "prec"
AEMET_ATTR_STATION_PRESSURE: Final[str] = "pres"
AEMET_ATTR_STATION_PRESSURE_SEA: Final[str] = "pres_nmar"
AEMET_ATTR_STATION_TEMPERATURE: Final[str] = "ta"
AEMET_ATTR_STATION_TEMPERATURE_MAX: Final[str] = "tamax"
AEMET_ATTR_STATION_TEMPERATURE_MIN: Final[str] = "tamin"
AEMET_ATTR_STATION_WIND_DIRECTION: Final[str] = "dv"
AEMET_ATTR_STATION_WIND_SPEED: Final[str] = "vv"
AEMET_ATTR_STATION_WIND_SPEED_MAX: Final[str] = "vmax"
AEMET_ATTR_STATE: Final[str] = "estado"
AEMET_ATTR_STORM_PROBABILITY: Final[str] = "probTormenta"
AEMET_ATTR_SUN_RISE: Final[str] = "orto"
AEMET_ATTR_SUN_SET: Final[str] = "ocaso"
AEMET_ATTR_TEMPERATURE: Final[str] = "temperatura"
AEMET_ATTR_TOWN_ALTITUDE: Final[str] = "altitud"
AEMET_ATTR_TOWN_RESIDENTS: Final[str] = "num_hab"
AEMET_ATTR_TOWN_LATITUDE: Final[str] = "latitud"
AEMET_ATTR_TOWN_LATITUDE_DECIMAL: Final[str] = "latitud_dec"
AEMET_ATTR_TOWN_LONGITUDE: Final[str] = "longitud"
AEMET_ATTR_TOWN_LONGITUDE_DECIMAL: Final[str] = "longitud_dec"
AEMET_ATTR_UV_MAX: Final[str] = "uvMax"
AEMET_ATTR_VALUE: Final[str] = "value"
AEMET_ATTR_WEATHER_STATION_LATITUDE: Final[str] = "latitud"
AEMET_ATTR_WEATHER_STATION_LONGITUDE: Final[str] = "longitud"
AEMET_ATTR_WIND: Final[str] = "viento"
AEMET_ATTR_WIND_GUST: Final[str] = "vientoAndRachaMax"
AOD_ALTITUDE: Final[str] = "altitude"
AOD_COND_CLEAR_NIGHT: Final[str] = "clear-night"
AOD_COND_CLOUDY: Final[str] = "cloudy"
AOD_COND_FOG: Final[str] = "fog"
AOD_COND_LIGHTNING: Final[str] = "lightning"
AOD_COND_LIGHTNING_RAINY: Final[str] = "lightning-rainy"
AOD_COND_PARTLY_CLODUY: Final[str] = "partly-cloudy"
AOD_COND_POURING: Final[str] = "pouring"
AOD_COND_RAINY: Final[str] = "rainy"
AOD_COND_SNOWY: Final[str] = "snowy"
AOD_COND_SUNNY: Final[str] = "sunny"
AOD_CONDITION: Final[str] = "condition"
AOD_COORDS: Final[str] = "coordinates"
AOD_DATETIME: Final[str] = "datetime"
AOD_DEW_POINT: Final[str] = "dew-point"
AOD_DISTANCE: Final[str] = "distance"
AOD_FEEL_TEMP: Final[str] = "feel-temperature"
AOD_FEEL_TEMP_MAX: Final[str] = "feel-temperature-max"
AOD_FEEL_TEMP_MIN: Final[str] = "feel-temperature-min"
AOD_FORECAST: Final[str] = "forecast"
AOD_FORECAST_CURRENT: Final[str] = "forecast-current"
AOD_FORECAST_DAILY: Final[str] = "forecast-daily"
AOD_FORECAST_HOURLY: Final[str] = "forecast-hourly"
AOD_HUMIDITY: Final[str] = "humidity"
AOD_HUMIDITY_MAX: Final[str] = "humidity-max"
AOD_HUMIDITY_MIN: Final[str] = "humidity-min"
AOD_ID: Final[str] = "id"
AOD_NAME: Final[str] = "name"
AOD_OUTDATED: Final[str] = "outdated"
AOD_RAIN: Final[str] = "rain"
AOD_RAIN_PROBABILITY: Final[str] = "rain-probability"
AOD_PRECIPITATION: Final[str] = "precipitation"
AOD_PRECIPITATION_PROBABILITY: Final[str] = "precipitation-probability"
AOD_PRESSURE: Final[str] = "pressure"
AOD_RESIDENTS: Final[str] = "residents"
AOD_SNOW: Final[str] = "snow"
AOD_SNOW_PROBABILITY: Final[str] = "snow-probability"
AOD_STATION: Final[str] = "station"
AOD_STORM_PROBABILITY: Final[str] = "storm-probability"
AOD_SUNRISE: Final[str] = "sunrise"
AOD_SUNSET: Final[str] = "sunset"
AOD_TEMP: Final[str] = "temperature"
AOD_TEMP_FEELING: Final[str] = "temperature-feeling"
AOD_TEMP_MAX: Final[str] = "temperature-max"
AOD_TEMP_MIN: Final[str] = "temperature-min"
AOD_TIMESTAMP: Final[str] = "timestamp"
AOD_TIMEZONE: Final[str] = "timezone"
AOD_TOWN: Final[str] = "town"
AOD_UV_INDEX: Final[str] = "uv-index"
AOD_WEATHER: Final[str] = "weather"
AOD_WIND_DIRECTION: Final[str] = "wind-direction"
AOD_WIND_SPEED: Final[str] = "wind-speed"
AOD_WIND_SPEED_MAX: Final[str] = "wind-speed-max"
API_ID_PFX: Final[str] = "id"
API_MIN_STATION_DISTANCE_KM: Final[int] = 40
API_MIN_TOWN_DISTANCE_KM: Final[int] = 40
API_PERIOD_24H: Final[int] = 24
API_PERIOD_FULL_DAY: Final[str] = "00-24"
API_PERIOD_HALF_1_DAY: Final[str] = "00-12"
API_PERIOD_HALF_2_DAY: Final[str] = "12-24"
API_PERIOD_QUARTER_1_DAY: Final[str] = "00-06"
API_PERIOD_QUARTER_2_DAY: Final[str] = "06-12"
API_PERIOD_QUARTER_3_DAY: Final[str] = "12-18"
API_PERIOD_QUARTER_4_DAY: Final[str] = "18-24"
API_PERIOD_SPLIT: Final[int] = 2
API_TIMEOUT: Final[int] = 15
API_URL: Final[str] = "https://opendata.aemet.es/opendata/api"
ATTR_DATA: Final[str] = "data"
ATTR_DISTANCE: Final[str] = "distance"
ATTR_RESPONSE: Final[str] = "response"
RAW_FORECAST_DAILY: Final[str] = "forecast-daily"
RAW_FORECAST_HOURLY: Final[str] = "forecast-hourly"
RAW_STATIONS: Final[str] = "stations"
RAW_TOWNS: Final[str] = "towns"
STATION_MAX_DELTA: Final[timedelta] = timedelta(hours=2) | AEMET-OpenData | /AEMET_OpenData-0.4.4-py3-none-any.whl/aemet_opendata/const.py | const.py |
from datetime import datetime
from typing import Any
from zoneinfo import ZoneInfo
from .const import (
AEMET_ATTR_DATE,
AEMET_ATTR_DAY,
AEMET_ATTR_ELABORATED,
AEMET_ATTR_FORECAST,
AEMET_ATTR_ID,
AEMET_ATTR_NAME,
AEMET_ATTR_TOWN_ALTITUDE,
AEMET_ATTR_TOWN_LATITUDE_DECIMAL,
AEMET_ATTR_TOWN_LONGITUDE_DECIMAL,
AEMET_ATTR_TOWN_RESIDENTS,
AOD_ALTITUDE,
AOD_CONDITION,
AOD_COORDS,
AOD_DISTANCE,
AOD_FEEL_TEMP,
AOD_FORECAST,
AOD_FORECAST_CURRENT,
AOD_FORECAST_DAILY,
AOD_FORECAST_HOURLY,
AOD_HUMIDITY,
AOD_ID,
AOD_NAME,
AOD_PRECIPITATION,
AOD_PRECIPITATION_PROBABILITY,
AOD_RAIN,
AOD_RAIN_PROBABILITY,
AOD_RESIDENTS,
AOD_SNOW,
AOD_SNOW_PROBABILITY,
AOD_STORM_PROBABILITY,
AOD_TEMP,
AOD_TIMESTAMP,
AOD_TIMEZONE,
AOD_UV_INDEX,
AOD_WIND_DIRECTION,
AOD_WIND_SPEED,
AOD_WIND_SPEED_MAX,
ATTR_DATA,
ATTR_DISTANCE,
)
from .forecast import DailyForecastValue, HourlyForecastValue
from .helpers import get_current_datetime, parse_api_timestamp, timezone_from_coords
class DailyForecast:
"""AEMET OpenData Town Daily Forecast."""
_datetime: datetime
forecast: list[DailyForecastValue]
zoneinfo: ZoneInfo
def __init__(self, data: dict[str, Any], zoneinfo: ZoneInfo) -> None:
"""Init AEMET OpenData Town Daily Forecast."""
self._datetime = parse_api_timestamp(data[AEMET_ATTR_ELABORATED])
self.forecast: list[DailyForecastValue] = []
self.zoneinfo = zoneinfo
cur_dt = get_current_datetime(zoneinfo)
cur_day = cur_dt.date()
for day_data in data[AEMET_ATTR_FORECAST][AEMET_ATTR_DAY]:
day = parse_api_timestamp(day_data[AEMET_ATTR_DATE], zoneinfo)
if cur_day <= day.date():
try:
self.forecast += [DailyForecastValue(day_data, day)]
except ValueError:
pass
def get_current_forecast(self) -> DailyForecastValue | None:
"""Return Town current daily forecast."""
cur_date = get_current_datetime(self.get_timezone()).date()
for forecast in self.forecast:
forecast_date = forecast.get_datetime().date()
if cur_date == forecast_date:
return forecast
return None
def get_timestamp(self) -> str:
"""Return Town daily forecast timestamp."""
return self._datetime.isoformat()
def get_timezone(self) -> ZoneInfo:
"""Return Town daily forecast timezone."""
return self.zoneinfo
def data(self) -> dict[str, Any]:
"""Return Town daily forecast data."""
data: dict[str, Any] = {
AOD_FORECAST: [],
AOD_TIMESTAMP: self.get_timestamp(),
AOD_TIMEZONE: self.get_timezone(),
}
cur_date = get_current_datetime(self.get_timezone()).date()
for forecast in self.forecast:
forecast_date = forecast.get_datetime().date()
if cur_date <= forecast_date:
data[AOD_FORECAST] += [forecast.data()]
cur_forecast = self.get_current_forecast()
if cur_forecast is not None:
data[AOD_FORECAST_CURRENT] = cur_forecast.data()
return data
def weather(self) -> dict[str, Any]:
"""Return Town daily weather data."""
weather: dict[str, Any] = {}
forecast = self.get_current_forecast()
if forecast is not None:
weather[AOD_CONDITION] = forecast.get_condition()
weather[AOD_PRECIPITATION_PROBABILITY] = forecast.get_precipitation_prob()
weather[AOD_UV_INDEX] = forecast.get_uv_index()
weather[AOD_WIND_DIRECTION] = forecast.get_wind_direction()
weather[AOD_WIND_SPEED] = forecast.get_wind_speed()
return weather
class HourlyForecast:
"""AEMET OpenData Town Hourly Forecast."""
_datetime: datetime
forecast: list[HourlyForecastValue]
zoneinfo: ZoneInfo
def __init__(self, data: dict[str, Any], zoneinfo: ZoneInfo) -> None:
"""Init AEMET OpenData Town Hourly Forecast."""
self._datetime = parse_api_timestamp(data[AEMET_ATTR_ELABORATED])
self.forecast: list[HourlyForecastValue] = []
self.zoneinfo = zoneinfo
cur_dt = get_current_datetime(zoneinfo)
cur_day = cur_dt.date()
cur_hour = cur_dt.hour
for day_data in data[AEMET_ATTR_FORECAST][AEMET_ATTR_DAY]:
day = parse_api_timestamp(day_data[AEMET_ATTR_DATE], zoneinfo)
day_date = day.date()
if cur_day <= day_date:
if cur_day == day_date:
start_hour = cur_hour
else:
start_hour = 0
for hour in range(start_hour, 24):
try:
cur_forecast = HourlyForecastValue(day_data, day, hour)
self.forecast += [cur_forecast]
except ValueError:
pass
def get_current_forecast(self) -> HourlyForecastValue | None:
"""Return Town current hourly forecast."""
cur_dt = get_current_datetime(self.get_timezone())
for forecast in self.forecast:
forecast_dt = forecast.get_datetime()
if cur_dt == forecast_dt:
return forecast
return None
def get_timestamp(self) -> str:
"""Return Town hourly forecast timestamp."""
return self._datetime.isoformat()
def get_timezone(self) -> ZoneInfo:
"""Return Town hourly forecast timezone."""
return self.zoneinfo
def data(self) -> dict[str, Any]:
"""Return Town hourly forecast data."""
data: dict[str, Any] = {
AOD_FORECAST: [],
AOD_TIMESTAMP: self.get_timestamp(),
AOD_TIMEZONE: self.get_timezone(),
}
cur_dt = get_current_datetime(self.get_timezone())
for forecast in self.forecast:
forecast_dt = forecast.get_datetime()
if cur_dt <= forecast_dt:
data[AOD_FORECAST] += [forecast.data()]
cur_forecast = self.get_current_forecast()
if cur_forecast is not None:
data[AOD_FORECAST_CURRENT] = cur_forecast.data()
return data
def weather(self) -> dict[str, Any]:
"""Return Town hourly weather data."""
weather: dict[str, Any] = {}
forecast = self.get_current_forecast()
if forecast is not None:
weather[AOD_FEEL_TEMP] = forecast.get_feel_temp()
weather[AOD_CONDITION] = forecast.get_condition()
weather[AOD_HUMIDITY] = forecast.get_humidity()
weather[AOD_PRECIPITATION] = forecast.get_precipitation()
weather[
AOD_PRECIPITATION_PROBABILITY
] = forecast.get_precipitation_probability()
weather[AOD_TEMP] = forecast.get_temp()
weather[AOD_RAIN] = forecast.get_rain()
weather[AOD_RAIN_PROBABILITY] = forecast.get_rain_probability()
weather[AOD_SNOW] = forecast.get_snow()
weather[AOD_SNOW_PROBABILITY] = forecast.get_snow_probability()
weather[AOD_STORM_PROBABILITY] = forecast.get_storm_probability()
weather[AOD_WIND_DIRECTION] = forecast.get_wind_direction()
weather[AOD_WIND_SPEED] = forecast.get_wind_speed()
weather[AOD_WIND_SPEED_MAX] = forecast.get_wind_speed_max()
return weather
class Town:
"""AEMET OpenData Town."""
altitude: int
coords: tuple[float, float]
daily: DailyForecast | None
distance: float
id: str
name: str
residents: int
zoneinfo: ZoneInfo
def __init__(self, data: dict[str, Any]) -> None:
"""Init AEMET OpenData Town."""
self.altitude = int(data[AEMET_ATTR_TOWN_ALTITUDE])
self.coords = (
float(data[AEMET_ATTR_TOWN_LATITUDE_DECIMAL]),
float(data[AEMET_ATTR_TOWN_LONGITUDE_DECIMAL]),
)
self.daily: DailyForecast | None = None
self.distance = float(data[ATTR_DISTANCE])
self.hourly: HourlyForecast | None = None
self.id = str(data[AEMET_ATTR_ID])
self.name = str(data[AEMET_ATTR_NAME])
self.residents = int(data[AEMET_ATTR_TOWN_RESIDENTS])
self.zoneinfo = timezone_from_coords(self.coords)
def get_altitude(self) -> int:
"""Return Town altitude."""
return self.altitude
def get_coords(self) -> tuple[float, float]:
"""Return Town coordinates."""
return self.coords
def get_distance(self) -> float:
"""Return Town distance from selected coordinates."""
return round(self.distance, 3)
def get_id(self) -> str:
"""Return Town ID."""
return self.id
def get_residents(self) -> int:
"""Return Town residents."""
return self.residents
def get_name(self) -> str:
"""Return Town name."""
return self.name
def get_timezone(self) -> ZoneInfo:
"""Return Town zoneinfo."""
return self.zoneinfo
def update_daily(self, forecast: dict[str, Any]) -> None:
"""Update Town daily forecast."""
self.daily = DailyForecast(forecast[ATTR_DATA][0], self.get_timezone())
def update_hourly(self, forecast: dict[str, Any]) -> None:
"""Update Town hourly forecast."""
self.hourly = HourlyForecast(forecast[ATTR_DATA][0], self.get_timezone())
def data(self) -> dict[str, Any]:
"""Return Town data."""
data: dict[str, Any] = {
AOD_ALTITUDE: self.get_altitude(),
AOD_COORDS: self.get_coords(),
AOD_DISTANCE: self.get_distance(),
AOD_ID: self.get_id(),
AOD_NAME: self.get_name(),
AOD_RESIDENTS: self.get_residents(),
AOD_TIMEZONE: self.get_timezone(),
}
if self.daily is not None:
data[AOD_FORECAST_DAILY] = self.daily.data()
if self.hourly is not None:
data[AOD_FORECAST_HOURLY] = self.hourly.data()
return data
def weather_daily(self) -> dict[str, Any]:
"""Return Town daily weather data."""
if self.daily is not None:
return self.daily.weather()
return {}
def weather_hourly(self) -> dict[str, Any]:
"""Return Town hourly weather data."""
if self.hourly is not None:
return self.hourly.weather()
return {} | AEMET-OpenData | /AEMET_OpenData-0.4.4-py3-none-any.whl/aemet_opendata/town.py | town.py |
from datetime import datetime
from typing import Any
from zoneinfo import ZoneInfo
from .const import (
AEMET_ATTR_PERIOD,
AEMET_ATTR_VALUE,
API_ID_PFX,
API_PERIOD_24H,
API_PERIOD_FULL_DAY,
API_PERIOD_SPLIT,
)
TZ_UTC = ZoneInfo("UTC")
def dict_nested_value(data: dict[str, Any] | None, keys: list[str] | None) -> Any:
"""Get value from dict with nested keys."""
if keys is None or len(keys) == 0:
return None
for key in keys or {}:
if data is not None:
data = data.get(key)
return data
def get_current_datetime(tz: ZoneInfo = TZ_UTC) -> datetime:
"""Return current datetime in UTC."""
return datetime.now(tz=tz).replace(minute=0, second=0, microsecond=0)
def get_forecast_day_value(
values: dict[str, Any] | list[Any], key: str = AEMET_ATTR_VALUE
) -> Any:
"""Get day value from forecast."""
if isinstance(values, list):
if len(values) > 1:
for value in values:
if key not in value:
continue
if value[AEMET_ATTR_PERIOD] == API_PERIOD_FULL_DAY:
return value[key]
else:
if key in values[0]:
return values[0][key]
if isinstance(values, dict):
if key in values:
return values[key]
return None
def get_forecast_hour_value(values: Any, hour: int, key: str = AEMET_ATTR_VALUE) -> Any:
"""Get hour value from forecast."""
for value in values:
if key not in value:
continue
if int(value[AEMET_ATTR_PERIOD]) == hour:
return None if not value[key] else value[key]
return None
def get_forecast_interval_value(
values: Any, hour: int, key: str = AEMET_ATTR_VALUE
) -> Any:
"""Get hour value from forecast interval."""
for value in values:
if key not in value:
continue
period_start = int(value[AEMET_ATTR_PERIOD][0:API_PERIOD_SPLIT])
period_end = int(
value[AEMET_ATTR_PERIOD][API_PERIOD_SPLIT : API_PERIOD_SPLIT * 2]
)
if period_end < period_start:
period_end = period_end + API_PERIOD_24H
if hour == 0:
hour = hour + API_PERIOD_24H
if period_start <= hour < period_end:
return None if not value[key] else value[key]
return None
def split_coordinate(coordinate: str) -> str:
"""Split climatological values station coordinate."""
coord_deg = coordinate[0:2]
coord_min = coordinate[2:4]
coord_sec = coordinate[4:6]
coord_dir = coordinate[6:7]
return f"{coord_deg} {coord_min}m {coord_sec}s {coord_dir}"
def parse_api_timestamp(timestamp: str, tz: ZoneInfo = TZ_UTC) -> datetime:
"""Parse AEMET OpenData timestamp into datetime."""
return datetime.fromisoformat(timestamp).replace(tzinfo=tz)
def parse_station_coordinates(latitude: str, longitude: str) -> str:
"""Parse climatological values station coordinates."""
return f"{split_coordinate(latitude)} {split_coordinate(longitude)}"
def parse_town_code(town_id: str) -> str:
"""Parse town code from ID if needed."""
if isinstance(town_id, str) and town_id.startswith(API_ID_PFX):
return town_id[len(API_ID_PFX) :]
return town_id
def timezone_from_coords(coords: tuple[float, float]) -> ZoneInfo:
"""Convert coordinates to timezone."""
if coords[0] < 32 and coords[1] < -11.5:
return ZoneInfo("Atlantic/Canary")
return ZoneInfo("Europe/Madrid") | AEMET-OpenData | /AEMET_OpenData-0.4.4-py3-none-any.whl/aemet_opendata/helpers.py | helpers.py |
import asyncio
from dataclasses import dataclass, field
import logging
from typing import Any, cast
from aiohttp import ClientError, ClientSession
from aiohttp.client_reqrep import ClientResponse
import geopy.distance
from geopy.distance import Distance
from .const import (
AEMET_ATTR_DATA,
AEMET_ATTR_STATE,
AEMET_ATTR_STATION_LATITUDE,
AEMET_ATTR_STATION_LONGITUDE,
AEMET_ATTR_TOWN_LATITUDE_DECIMAL,
AEMET_ATTR_TOWN_LONGITUDE_DECIMAL,
AEMET_ATTR_WEATHER_STATION_LATITUDE,
AEMET_ATTR_WEATHER_STATION_LONGITUDE,
AOD_CONDITION,
AOD_DEW_POINT,
AOD_FEEL_TEMP,
AOD_HUMIDITY,
AOD_PRECIPITATION,
AOD_PRECIPITATION_PROBABILITY,
AOD_PRESSURE,
AOD_RAIN,
AOD_RAIN_PROBABILITY,
AOD_SNOW,
AOD_SNOW_PROBABILITY,
AOD_STATION,
AOD_STORM_PROBABILITY,
AOD_TEMP,
AOD_TIMESTAMP,
AOD_TOWN,
AOD_UV_INDEX,
AOD_WEATHER,
AOD_WIND_DIRECTION,
AOD_WIND_SPEED,
AOD_WIND_SPEED_MAX,
API_MIN_STATION_DISTANCE_KM,
API_MIN_TOWN_DISTANCE_KM,
API_TIMEOUT,
API_URL,
ATTR_DATA,
ATTR_DISTANCE,
ATTR_RESPONSE,
RAW_FORECAST_DAILY,
RAW_FORECAST_HOURLY,
RAW_STATIONS,
RAW_TOWNS,
)
from .exceptions import (
AemetError,
ApiError,
AuthError,
StationNotFound,
TooManyRequests,
TownNotFound,
)
from .helpers import get_current_datetime, parse_station_coordinates, parse_town_code
from .station import Station
from .town import Town
_LOGGER = logging.getLogger(__name__)
@dataclass
class ConnectionOptions:
"""AEMET OpenData API options for connection."""
api_key: str
station_data: bool = False
@dataclass
class LegacyWeather:
"""Legacy class for AEMET weather data."""
daily: dict[str, Any] = field(default_factory=dict)
hourly: dict[str, Any] = field(default_factory=dict)
station: dict[str, Any] = field(default_factory=dict)
class AEMET:
"""Interacts with the AEMET OpenData API."""
_api_raw_data: dict[str, Any]
aiohttp_session: ClientSession
coords: tuple[float, float] | None
dist_hp: bool
headers: dict[str, Any]
legacy: dict[str, Any]
options: ConnectionOptions
station: Station | None
town: Town | None
def __init__(
self,
aiohttp_session: ClientSession,
options: ConnectionOptions,
) -> None:
"""Init AEMET OpenData API."""
self._api_raw_data = {
RAW_FORECAST_DAILY: {},
RAW_FORECAST_HOURLY: {},
RAW_STATIONS: {},
RAW_TOWNS: {},
}
self.aiohttp_session = aiohttp_session
self.coords = None
self.dist_hp = False
self.headers = {
"Cache-Control": "no-cache",
"api_key": options.api_key,
}
self.legacy = {
"daily": None,
"hourly": None,
"station": None,
}
self.options = options
self.station = None
self.town = None
async def api_call(self, cmd: str, fetch_data: bool = False) -> dict[str, Any]:
"""Perform Rest API call."""
_LOGGER.debug("api_call: cmd=%s", cmd)
try:
resp: ClientResponse = await self.aiohttp_session.request(
"GET",
f"{API_URL}/{cmd}",
timeout=API_TIMEOUT,
headers=self.headers,
)
except ClientError as err:
raise AemetError(err) from err
if resp.status == 401:
raise AuthError("API authentication error")
if resp.status == 404:
raise ApiError("API data error")
if resp.status == 429:
raise TooManyRequests("Too many API requests")
if resp.status != 200:
raise AemetError(f"API status={resp.status}")
resp_json = await resp.json(content_type=None)
_LOGGER.debug("api_call: cmd=%s resp=%s", cmd, resp_json)
if isinstance(resp_json, dict):
if resp_json.get(AEMET_ATTR_STATE) == 404:
raise ApiError("API data error")
json_response = cast(dict[str, Any], resp_json)
if fetch_data and AEMET_ATTR_DATA in json_response:
data = await self.api_data(json_response[AEMET_ATTR_DATA])
if data:
json_response = {
ATTR_RESPONSE: json_response,
ATTR_DATA: data,
}
if isinstance(json_response, list):
json_response = {
ATTR_DATA: json_response,
}
return json_response
async def api_data(self, url: str) -> dict[str, Any]:
"""Fetch API data."""
_LOGGER.debug("api_data: url=%s", url)
try:
resp: ClientResponse = await self.aiohttp_session.request(
"GET",
url,
timeout=API_TIMEOUT,
)
except ClientError as err:
raise AemetError(err) from err
if resp.status == 404:
raise ApiError("API data error")
if resp.status == 429:
raise TooManyRequests("Too many API requests")
if resp.status != 200:
raise AemetError(f"API status={resp.status}")
resp_json = await resp.json(content_type=None)
_LOGGER.debug("api_data: url=%s resp=%s", url, resp_json)
if isinstance(resp_json, dict):
if resp_json.get(AEMET_ATTR_STATE) == 404:
raise ApiError("API data error")
return cast(dict[str, Any], resp_json)
def legacy_weather(self) -> LegacyWeather:
"""Return legacy weather data."""
return LegacyWeather(
self.legacy["daily"],
self.legacy["hourly"],
self.legacy["station"],
)
def raw_data(self) -> dict[str, Any]:
"""Return raw AEMET OpenData API data."""
return self._api_raw_data
def data(self) -> dict[str, Any]:
"""Return AEMET OpenData data."""
data: dict[str, Any] = {}
if self.station is not None:
data[AOD_STATION] = self.station.data()
if self.town is not None:
data[AOD_TOWN] = self.town.data()
weather = self.weather()
if weather is not None:
data[AOD_WEATHER] = weather
data[AOD_TIMESTAMP] = get_current_datetime().isoformat()
return data
def calc_distance(
self, start: tuple[float, float], end: tuple[float, float]
) -> Distance:
"""Calculate distance between 2 points."""
if self.dist_hp:
return geopy.distance.geodesic(start, end)
return geopy.distance.great_circle(start, end)
def distance_high_precision(self, dist_hp: bool) -> bool:
"""Enable/Disable high precision for distance calculations."""
self.dist_hp = dist_hp
return self.dist_hp
async def get_climatological_values_stations(
self, fetch_data: bool = True
) -> dict[str, Any]:
"""Get stations available for climatological values."""
return await self.api_call(
"valores/climatologicos/inventarioestaciones/todasestaciones", fetch_data
)
async def get_climatological_values_station_by_coordinates(
self, latitude: float, longitude: float
) -> dict[str, Any]:
"""Get closest climatological values station to coordinates."""
station: dict[str, Any] | None = None
stations = await self.get_climatological_values_stations()
search_coords = (latitude, longitude)
distance = API_MIN_STATION_DISTANCE_KM
for cur_station in stations[ATTR_DATA]:
station_coords = parse_station_coordinates(
cur_station[AEMET_ATTR_WEATHER_STATION_LATITUDE],
cur_station[AEMET_ATTR_WEATHER_STATION_LONGITUDE],
)
station_point = geopy.point.Point(station_coords)
cur_coords = (station_point.latitude, station_point.longitude)
cur_distance = self.calc_distance(search_coords, cur_coords).km
if cur_distance < distance:
distance = cur_distance
station = cur_station
if station is None:
raise StationNotFound(f"No stations found for [{latitude}, {longitude}]")
_LOGGER.debug("distance: %s, station: %s", distance, station)
return station
async def get_climatological_values_station_data(
self, station: str, fetch_data: bool = True
) -> dict[str, Any]:
"""Get data from climatological values station."""
return await self.api_call(
f"valores/climatologicos/inventarioestaciones/estaciones/{station}",
fetch_data,
)
async def get_conventional_observation_stations(
self, fetch_data: bool = True
) -> dict[str, Any]:
"""Get stations available for conventional observations."""
return await self.api_call("observacion/convencional/todas", fetch_data)
async def get_conventional_observation_station_by_coordinates(
self, latitude: float, longitude: float
) -> dict[str, Any]:
"""Get closest conventional observation station to coordinates."""
station: dict[str, Any] | None = None
stations = await self.get_conventional_observation_stations()
search_coords = (latitude, longitude)
distance = API_MIN_STATION_DISTANCE_KM
for cur_station in stations[ATTR_DATA]:
cur_coords = (
cur_station[AEMET_ATTR_STATION_LATITUDE],
cur_station[AEMET_ATTR_STATION_LONGITUDE],
)
cur_distance = self.calc_distance(search_coords, cur_coords).km
if cur_distance < distance:
distance = cur_distance
station = cur_station
if station is None:
raise StationNotFound(f"No stations found for [{latitude}, {longitude}]")
_LOGGER.debug("distance: %s, station: %s", distance, station)
station[ATTR_DISTANCE] = distance
return station
async def get_conventional_observation_station_data(
self, station: str, fetch_data: bool = True
) -> dict[str, Any]:
"""Get data from conventional observation station."""
res = await self.api_call(
f"observacion/convencional/datos/estacion/{station}", fetch_data
)
self._api_raw_data[RAW_STATIONS][station] = res
return res
async def get_lightnings_map(self) -> dict[str, Any]:
"""Get map with lightning falls (last 6h)."""
return await self.api_call("red/rayos/mapa")
async def get_specific_forecast_town_daily(
self, town: str, fetch_data: bool = True
) -> dict[str, Any]:
"""Get daily forecast for specific town (daily)."""
res = await self.api_call(
f"prediccion/especifica/municipio/diaria/{parse_town_code(town)}",
fetch_data,
)
self._api_raw_data[RAW_FORECAST_DAILY][town] = res
return res
async def get_specific_forecast_town_hourly(
self, town: str, fetch_data: bool = True
) -> dict[str, Any]:
"""Get hourly forecast for specific town (hourly)."""
res = await self.api_call(
f"prediccion/especifica/municipio/horaria/{parse_town_code(town)}",
fetch_data,
)
self._api_raw_data[RAW_FORECAST_HOURLY][town] = res
return res
async def get_town(self, town: str) -> dict[str, Any]:
"""Get information about specific town."""
res = await self.api_call(f"maestro/municipio/{town}")
self._api_raw_data[RAW_TOWNS][town] = res
return res
async def get_town_by_coordinates(
self, latitude: float, longitude: float
) -> dict[str, Any]:
"""Get closest town to coordinates."""
town: dict[str, Any] | None = None
towns = await self.get_towns()
search_coords = (latitude, longitude)
distance = API_MIN_TOWN_DISTANCE_KM
for cur_town in towns[ATTR_DATA]:
cur_coords = (
cur_town[AEMET_ATTR_TOWN_LATITUDE_DECIMAL],
cur_town[AEMET_ATTR_TOWN_LONGITUDE_DECIMAL],
)
cur_distance = self.calc_distance(search_coords, cur_coords).km
if cur_distance < distance:
distance = cur_distance
town = cur_town
if town is None:
raise TownNotFound(f"No towns found for [{latitude}, {longitude}]")
_LOGGER.debug("distance: %s, town: %s", distance, town)
town[ATTR_DISTANCE] = distance
return town
async def get_towns(self) -> dict[str, Any]:
"""Get information about towns."""
return await self.api_call("maestro/municipios")
async def select_coordinates(self, latitude: float, longitude: float) -> None:
"""Select town and station based on provided coordinates."""
coords = (latitude, longitude)
if self.options.station_data:
try:
station_data = (
await self.get_conventional_observation_station_by_coordinates(
latitude,
longitude,
)
)
except StationNotFound as err:
_LOGGER.error(err)
station_data = None
else:
station_data = None
town_data = await self.get_town_by_coordinates(latitude, longitude)
self.coords = coords
if station_data is not None:
self.station = Station(station_data)
self.town = Town(town_data)
async def update_daily(self) -> None:
"""Update AEMET OpenData town daily forecast."""
if self.town is not None:
town_id = self.town.get_id()
daily = await self.get_specific_forecast_town_daily(town_id)
self.legacy["daily"] = daily
self.town.update_daily(daily)
async def update_hourly(self) -> None:
"""Update AEMET OpenData town hourly forecast."""
if self.town is not None:
town_id = self.town.get_id()
hourly = await self.get_specific_forecast_town_hourly(town_id)
self.legacy["hourly"] = hourly
self.town.update_hourly(hourly)
async def update_station(self) -> None:
"""Update AEMET OpenData station."""
if self.station is not None:
station_id = self.station.get_id()
station = await self.get_conventional_observation_station_data(station_id)
self.legacy["station"] = station
self.station.update_samples(station)
async def update(self) -> None:
"""Update all AEMET OpenData data."""
tasks = [
self.update_daily(),
self.update_hourly(),
self.update_station(),
]
await asyncio.gather(*tasks)
def weather(self) -> dict[str, Any] | None:
"""Update AEMET OpenData town daily forecast."""
daily: dict[str, Any]
hourly: dict[str, Any]
station: dict[str, Any]
if self.station is not None and not self.station.get_outdated():
station = self.station.weather()
else:
station = {}
if self.town is not None:
daily = self.town.weather_daily()
hourly = self.town.weather_hourly()
else:
daily = {}
hourly = {}
condition = hourly.get(AOD_CONDITION) or daily.get(AOD_CONDITION)
dew_point = station.get(AOD_DEW_POINT)
feel_temp = hourly.get(AOD_FEEL_TEMP)
humidity = station.get(AOD_HUMIDITY)
if humidity is None:
humidity = hourly.get(AOD_HUMIDITY)
pressure = station.get(AOD_PRESSURE)
precipitation = station.get(AOD_PRECIPITATION)
if precipitation is None:
precipitation = hourly.get(AOD_PRECIPITATION)
precipitation_prob = hourly.get(AOD_PRECIPITATION_PROBABILITY)
if precipitation_prob is None:
precipitation_prob = daily.get(AOD_PRECIPITATION_PROBABILITY)
rain = station.get(AOD_PRECIPITATION)
if rain is None:
rain = hourly.get(AOD_RAIN)
rain_prob = hourly.get(AOD_RAIN_PROBABILITY)
snow = hourly.get(AOD_SNOW)
snow_prob = hourly.get(AOD_SNOW_PROBABILITY)
storm_prob = hourly.get(AOD_STORM_PROBABILITY)
temp = station.get(AOD_TEMP)
if temp is None:
temp = hourly.get(AOD_TEMP)
uv_index = daily.get(AOD_UV_INDEX)
wind_direction = (
station.get(AOD_WIND_DIRECTION)
or hourly.get(AOD_WIND_DIRECTION)
or daily.get(AOD_WIND_DIRECTION)
)
wind_speed = (
station.get(AOD_WIND_SPEED)
or hourly.get(AOD_WIND_SPEED)
or daily.get(AOD_WIND_SPEED)
)
wind_speed_max = station.get(AOD_WIND_SPEED_MAX) or hourly.get(
AOD_WIND_SPEED_MAX
)
weather: dict[str, Any] = {
AOD_CONDITION: condition,
AOD_DEW_POINT: dew_point,
AOD_HUMIDITY: humidity,
AOD_FEEL_TEMP: feel_temp,
AOD_PRECIPITATION: precipitation,
AOD_PRECIPITATION_PROBABILITY: precipitation_prob,
AOD_PRESSURE: pressure,
AOD_RAIN: rain,
AOD_RAIN_PROBABILITY: rain_prob,
AOD_SNOW: snow,
AOD_SNOW_PROBABILITY: snow_prob,
AOD_STORM_PROBABILITY: storm_prob,
AOD_TEMP: temp,
AOD_UV_INDEX: uv_index,
AOD_WIND_DIRECTION: wind_direction,
AOD_WIND_SPEED: wind_speed,
AOD_WIND_SPEED_MAX: wind_speed_max,
}
return weather | AEMET-OpenData | /AEMET_OpenData-0.4.4-py3-none-any.whl/aemet_opendata/interface.py | interface.py |
import os
import time
# Torch
import torch
from torch import nn
from torch.utils.tensorboard import SummaryWriter
# from torchsummary import summary
from torch.optim import lr_scheduler
# Libs
import numpy as np
from math import inf
import pandas as pd
# Own module
from AEML.data.loader import get_data_into_loaders_only_x, get_test_data_into_loaders
from AEML.models.Transformer.model_maker import Transformer
from AEML.models.Transformer.utils.evaluation_helper import plotMSELossDistrib
class Network(object):
def __init__(self, dim_g, dim_s, feature_channel_num=32, nhead_encoder=8,
dim_fc_encoder=64,num_encoder_layer=6, head_linear=None,
tail_linear=None, sequence_length=8, model_name=None,
ckpt_dir=os.path.join(os.path.abspath(''),'Transformer_trained_results'),
inference_mode=False, saved_model=None):
if head_linear is None:
head_linear = [dim_g, sequence_length*feature_channel_num]
if tail_linear is None:
tail_linear = [dim_s]
if inference_mode: # If inference mode, use saved model
self.ckpt_dir = os.path.join(ckpt_dir, saved_model)
self.saved_model = saved_model
print("This is inference mode, the ckpt is", self.ckpt_dir)
else: # training mode, create a new ckpt folder
if model_name is None:
self.ckpt_dir = os.path.join(ckpt_dir, time.strftime('%Y%m%d_%H%M%S', time.localtime()))
else:
self.ckpt_dir = os.path.join(ckpt_dir, model_name)
self.log = SummaryWriter(self.ckpt_dir) # Create a summary writer for keeping the summary to the tensor board
self.best_validation_loss = float('inf') # Set the BVL to large number
self.best_training_loss = float('inf') # Set the BTL to large number
# marking the flag object with these information
class FlagsObject(object):
pass
flags = FlagsObject()
field_list = ['dim_g', 'dim_s', 'feature_channel_num', 'nhead_encoder', 'dim_fc_encoder',
'num_encoder_layer', 'head_linear', 'tail_linear', 'sequence_length', 'model_name']
for field in field_list:
setattr(flags, field, eval(field))
# flags.dim_g, flags.dim_s, flags.feature_channel_num, flags.nhead_encoder, flags.dim_fc_encoder,
# flags.num_encoder_layer, flags.head_linear, flags.tail_linear, flags.sequence_length,
# flags.model_name = dim_g, dim_s, feature_channel_num, nhead_encoder, dim_fc_encoder,num_encoder_layer,
# head_linear, tail_linear, sequence_length, model_name
self.flags = flags
self.model = self.create_model()
def create_model(self):
"""
Function to create the network module
:return: the created nn module
"""
model = Transformer(self.flags)
print(model)
return model
def make_loss(self, logit=None, labels=None, G=None):
"""
Create a tensor that represents the loss. This is consistant both at training time \
and inference time for Backward model
:param logit: The output of the network, the predicted geometry
:param labels: The ground truth labels, the Truth geometry
:param boundary: The boolean flag indicating adding boundary loss or not
:param z_log_var: The log variance for VAE kl_loss
:param z_mean: The z mean vector for VAE kl_loss
:return: the total loss
"""
MSE_loss = nn.functional.mse_loss(logit, labels, reduction='mean') # The MSE Loss
BDY_loss = 0
if G is not None: # This is using the boundary loss
X_range, X_lower_bound, X_upper_bound = self.get_boundary_lower_bound_uper_bound()
X_mean = (X_lower_bound + X_upper_bound) / 2 # Get the mean
relu = torch.nn.ReLU()
BDY_loss_all = 1 * relu(torch.abs(G - self.build_tensor(X_mean)) - 0.5 * self.build_tensor(X_range))
self.MSE_loss = MSE_loss
self.Boundary_loss = BDY_loss
return torch.add(MSE_loss, BDY_loss)
def make_optimizer(self, optim, lr, weight_decay):
"""
Make the corresponding optimizer from the Only below optimizers are allowed. Welcome to add more
:return:
"""
if optim == 'Adam':
op = torch.optim.Adam(self.model.parameters(), lr=lr, weight_decay=weight_decay)
elif optim == 'RMSprop':
op = torch.optim.RMSprop(self.model.parameters(), lr=lr, weight_decay=weight_decay)
elif optim == 'SGD':
op = torch.optim.SGD(self.model.parameters(), lr=lr, weight_decay=weight_decay)
else:
raise Exception("Your Optimizer is neither Adam, RMSprop or SGD, please change in param or contact Ben")
return op
def make_lr_scheduler(self, optm, lr_scheduler_name, lr_decay_rate, warm_restart_T_0=50):
"""
Make the learning rate scheduler as instructed. More modes can be added to this, current supported ones:
1. ReduceLROnPlateau (decrease lr when validation error stops improving
:return:
"""
if lr_scheduler_name == 'warm_restart':
return lr_scheduler.CosineAnnealingWarmRestarts(optm, warm_restart_T_0, T_mult=1, eta_min=0, last_epoch=-1, verbose=False)
elif lr_scheduler_name == 'reduce_plateau':
return lr_scheduler.ReduceLROnPlateau(optimizer=optm, mode='min',
factor=lr_decay_rate,
patience=10, verbose=True, threshold=1e-4)
def save(self, ckpt_dir=None):
"""
Saving the model to the current check point folder with name best_model_forward.pt
:return: None
"""
if ckpt_dir is None:
ckpt_dir = self.ckpt_dir
# torch.save(self.model.state_dict, os.path.join(self.ckpt_dir, 'best_model_state_dict.pt'))
torch.save(self.model, os.path.join(ckpt_dir, 'best_model_forward.pt'))
def load_model(self, pre_trained_model=None, model_directory=None):
"""
Loading the model from the check point folder with name best_model_forward.pt
:return:
"""
if pre_trained_model is None: # Loading the trained model
if model_directory is None:
model_directory = self.ckpt_dir
# self.model.load_state_dict(torch.load(os.path.join(self.ckpt_dir, 'best_model_state_dict.pt')))
self.model = torch.load(os.path.join(model_directory, 'best_model_forward.pt'))
print("You have successfully loaded the model from ", model_directory)
else: # Loading the pretrained model from the internet
print("Loading pre-trained model, if this fails, check that you have the same architecture!")
self.model = torch.load(os.path.join('pre_trained_models','Transformer',
pre_trained_model, 'best_model_forward.pt'))
print("You have successfully loaded the pretrained model for ", pre_trained_model)
def train_(self, train_loader, test_loader, save_model=False, epochs=500, optm='Adam', weight_decay=5e-4,
lr=1e-3, lr_scheduler_name=None, lr_decay_rate=0.3, eval_step=10,
stop_threshold=1e-7):
"""
The major training function. This would start the training using information given in the flags
:return: None
"""
print("Starting training now")
cuda = True if torch.cuda.is_available() else False
if cuda:
self.model.cuda()
# Construct optimizer after the model moved to GPU
self.optm = self.make_optimizer(optm, lr, weight_decay)
if lr_scheduler_name is not None:
self.lr_scheduler = self.make_lr_scheduler(self.optm, lr_scheduler_name, lr_decay_rate)
for epoch in range(epochs):
# Set to Training Mode
train_loss = 0
self.model.train()
for j, (geometry, spectra) in enumerate(train_loader):
if cuda:
geometry = geometry.cuda() # Put data onto GPU
spectra = spectra.cuda() # Put data onto GPU
self.optm.zero_grad() # Zero the gradient first
S_pred = self.model(geometry)
loss = self.make_loss(logit=S_pred, labels=spectra)
loss.backward() # Calculate the backward gradients
self.optm.step() # Move one step the optimizer
train_loss += loss.cpu().data.numpy() # Aggregate the loss
del S_pred, loss
# Calculate the avg loss of training
train_avg_loss = train_loss / (j + 1)
# Recording the best training loss
if train_avg_loss < self.best_training_loss:
self.best_training_loss = train_avg_loss
if epoch % eval_step == 0: # For eval steps, do the evaluations and tensor board
# Record the training loss to the tensorboard
self.log.add_scalar('Loss/total_train', train_avg_loss, epoch)
# Set to Evaluation Mode
self.model.eval()
print("Doing Evaluation on the model now")
test_loss = 0
for j, (geometry, spectra) in enumerate(test_loader): # Loop through the eval set
if cuda:
geometry = geometry.cuda()
spectra = spectra.cuda()
S_pred = self.model(geometry)
loss = self.make_loss(logit=S_pred, labels=spectra)
test_loss += loss.cpu().data.numpy() # Aggregate the loss
del loss, S_pred
# Record the testing loss to the tensorboard
test_avg_loss = test_loss/ (j+1)
self.log.add_scalar('Loss/total_test', test_avg_loss, epoch)
print("This is Epoch %d, training loss %.5f, validation loss %.5f" \
% (epoch, train_avg_loss, test_avg_loss ))
# Model improving, save the model down
if test_avg_loss < self.best_validation_loss:
self.best_validation_loss = test_avg_loss
if save_model:
print("Saving the model down...")
self.save()
if self.best_validation_loss < stop_threshold:
print("Training finished EARLIER at epoch %d, reaching loss of %.5f" %\
(epoch, self.best_validation_loss))
break
if lr_scheduler_name is not None:
# Learning rate decay upon plateau
self.lr_scheduler.step(train_avg_loss)
def __call__(self, test_X, batch_size=512):
"""
This is to call this model to do testing,
:param: test_X: The testing X to be input to the model
"""
# put model to GPU if cuda available
cuda = True if torch.cuda.is_available() else False
if cuda:
self.model.cuda()
# Converting the numpy into cuda
#if isinstance(test_X, np.ndarray):
# print('your input is an numpy array, converting to an tensor for you')
# test_X = torch.tensor(test_X).cuda()
# Make the model to eval mode
self.model.eval()
# Preparing for eval
Ypred = None
test_loader = get_data_into_loaders_only_x(test_X)
# Partitioning the model output into small batches to avoid RAM overflow
for j, geometry in enumerate(test_loader): # Loop through the eval set
if cuda:
geometry = geometry.cuda()
# output the Ypred
Ypred_batch = self.model(geometry).cpu().data.numpy()
if Ypred is None:
Ypred = Ypred_batch
else:
Ypred = np.concatenate([Ypred, Ypred_batch], axis=0)
print('Inference finished, result in ypred shape', np.shape(Ypred))
return Ypred
def evaluate(self, test_x, test_y, save_output=False, save_dir='data/', prefix=''):
# Make sure there is a place for the evaluation
if not os.path.isdir(save_dir):
os.makedirs(save_dir)
# Put things on conda
cuda = True if torch.cuda.is_available() else False
if cuda:
self.model.cuda()
# Set to evaluation mode for batch_norm layers
self.model.eval()
saved_model_str = prefix
# Get the file names
Ypred_file = os.path.join(save_dir, 'test_Ypred_{}.csv'.format(saved_model_str))
Xtruth_file = os.path.join(save_dir, 'test_Xtruth_{}.csv'.format(saved_model_str))
Ytruth_file = os.path.join(save_dir, 'test_Ytruth_{}.csv'.format(saved_model_str))
test_loader = get_test_data_into_loaders(test_x, test_y)
# Open those files to append
with open(Xtruth_file, 'a') as fxt,open(Ytruth_file, 'a') as fyt,\
open(Ypred_file, 'a') as fyp:
for j, (geometry, spectra) in enumerate(test_loader):
if cuda:
geometry = geometry.cuda()
spectra = spectra.cuda()
Ypred = self.model(geometry).cpu().data.numpy()
np.savetxt(fxt, geometry.cpu().data.numpy())
np.savetxt(fyt, spectra.cpu().data.numpy())
np.savetxt(fyp, Ypred)
if not save_output:
os.remove(Xtruth_file)
os.remove(Ypred_file)
os.remove(Ypred_file)
MSE = plotMSELossDistrib(Ypred_file, Ytruth_file)
return MSE | AEML | /models/Transformer/class_wrapper.py | class_wrapper.py |
# From Built-in
from time import time
# From libs
import torch
import torch.nn as nn
import torch.optim
import numpy as np
import torch.nn.functional as F
import matplotlib.pyplot as plt
from tqdm import tqdm
class Transformer(nn.Module):
"""
The constructor for Transformer network
:param flags: inut flags from configuration
:return: The transformer network
"""
def __init__(self, flags):
super(Transformer, self).__init__()
# Transferring flags field into self field
self.head_linear = flags.head_linear
self.sequence_length = flags.sequence_length
# Use a small MLP to get to large dimension
self.head_linears = nn.ModuleList([])
self.head_bn_linears = nn.ModuleList([])
print('last dim of head linear', flags.head_linear[-1])
print('flags. feature channel num', flags.feature_channel_num)
print('sequence length ', flags.sequence_length)
assert flags.head_linear[-1] / flags.feature_channel_num == flags.sequence_length, 'In using MLP to get to larger dimension, the feature channel num should be divisible to the number of neurons in the last layer'
for ind, fc_num in enumerate(flags.head_linear[0:-1]): # Excluding the last one as we need intervals
self.head_linears.append(nn.Linear(fc_num, flags.head_linear[ind + 1]))
self.head_bn_linears.append(nn.BatchNorm1d(flags.head_linear[ind + 1]))
# Transformer Encoder module
self.encoder_layer = nn.TransformerEncoderLayer(d_model=flags.feature_channel_num, nhead=flags.nhead_encoder,
dim_feedforward=flags.dim_fc_encoder)
self.transformer_encoder = nn.TransformerEncoder(encoder_layer=self.encoder_layer,
num_layers=flags.num_encoder_layer)
# For the no decoder case, the output spectra
self.tail_linears = nn.ModuleList([])
self.tail_bn_linears = nn.ModuleList([])
# Due to the possible ways of preparing the sequences, the number of nodes at the last layer varies
last_layer_node_num = flags.sequence_length * flags.feature_channel_num
if flags.tail_linear:
self.tail_linears.append(nn.Linear(last_layer_node_num, flags.tail_linear[0]))
self.tail_bn_linears.append(nn.BatchNorm1d(flags.tail_linear[0]))
else:
self.tail_linears.append(nn.Linear(last_layer_node_num, flags.dim_S))
self.tail_bn_linears.append(nn.BatchNorm1d(flags.dim_S))
for ind, fc_num in enumerate(flags.tail_linear[0:-1]): # Excluding the last one as we need intervals
self.tail_linears.append(nn.Linear(fc_num, flags.tail_linear[ind + 1]))
self.tail_bn_linears.append(nn.BatchNorm1d(flags.tail_linear[ind + 1]))
def forward(self, G):
"""
The forward function of the transformer
"""
if self.head_linear:
"""
In this case we are using a MLP structure to convert the MM problem into a transformer problem
"""
out = G
for ind, (fc, bn) in enumerate(zip(self.head_linears, self.head_bn_linears)):
if ind != len(self.head_linears) - 1:
out = F.relu(bn(fc(out))) # ReLU + BN + Linear
else:
out = fc(out)
# Reshape the output into the transformer taking shape
out = out.view([out.size(0), self.sequence_length, -1])
else:
"""
In this case we are using the MLP mixer approach of changing the
[dim_G x 1] to [sentence_length (10) x embedding_length(512)], which is [flags.sequence_length x flags.feature_channel_num]
"""
out = torch.unsqueeze(G, 2) # Batch_size x dim_G x 1
out = out.view([out.size(0), self.sequence_length, -1])
out = self.sequence_fc_layer(out)
# Get the the data transformed
out = self.transformer_encoder(out)
out = out.view([out.size(0), -1])
# Go through the decoder, which is a MLP layer
for ind, (fc, bn) in enumerate(zip(self.tail_linears, self.tail_bn_linears)):
if ind != len(self.tail_linears) - 1:
out = F.relu(bn(fc(out))) # ReLU + BN + Linear
else:
out = fc(out)
return out | AEML | /models/Transformer/model_maker.py | model_maker.py |
import os
import shutil
from copy import deepcopy
import sys
import pickle
import numpy as np
# from ensemble_mm.predict_ensemble import ensemble_predict_master
# 1
def get_Xpred(path, name=None):
"""
Get certain predicion or truth numpy array from path, with name of model specified.
If there is no name specified, return the first found such array
:param path: str, the path for which to search
:param name: str, the name of the model to find
:return: np array
"""
out_file = None
if name is not None:
name = name.replace('/','_')
for filename in os.listdir(path):
if ("Xpred" in filename):
if name is None:
out_file = filename
print("Xpred File found", filename)
break
else:
if (name in filename):
out_file = filename
break
assert out_file is not None, "Your Xpred model did not found" + name
return np.loadtxt(os.path.join(path,out_file))
# 2
def get_Ypred(path, name=None):
"""
Get certain predicion or truth numpy array from path, with name of model specified.
If there is no name specified, return the first found such array
:param path: str, the path for which to search
:param name: str, the name of the model to find
:return: np array
"""
out_file = None
name = name.replace('/','_')
for filename in os.listdir(path):
if ("Ypred" in filename):
if name is None:
out_file = filename
print("Ypred File found", filename)
break
else:
if (name in filename):
out_file = filename
break
assert out_file is not None, "Your Xpred model did not found" + name
return np.loadtxt(os.path.join(path,out_file))
# 3
def get_Xtruth(path, name=None):
"""
Get certain predicion or truth numpy array from path, with name of model specified.
If there is no name specified, return the first found such array
:param path: str, the path for which to search
:param name: str, the name of the model to find
:return: np array
"""
out_file = None
if name is not None:
name = name.replace('/','_')
for filename in os.listdir(path):
if ("Xtruth" in filename):
if name is None:
out_file = filename
print("Xtruth File found", filename)
break
else:
if (name in filename):
out_file = filename
break
assert out_file is not None, "Your Xpred model did not found" + name
return np.loadtxt(os.path.join(path,out_file))
# 4
def get_Ytruth(path, name=None):
"""
Get certain predicion or truth numpy array from path, with name of model specified.
If there is no name specified, return the first found such array
:param path: str, the path for which to search
:param name: str, the name of the model to find
:return: np array
"""
out_file = None
name = name.replace('/','_')
for filename in os.listdir(path):
if ("Ytruth" in filename):
if name is None:
out_file = filename
print("Ytruth File found", filename)
break
else:
if (name in filename):
out_file = filename
break
assert out_file is not None, "Your Xpred model did not found" + name
return np.loadtxt(os.path.join(path,out_file))
# 5
def put_param_into_folder(ckpt_dir):
"""
Put the parameter.txt into the folder and the flags.obj as well
:return: None
"""
"""
Old version of finding the latest changing file, deprecated
# list_of_files = glob.glob('models/*') # Use glob to list the dirs in models/
# latest_file = max(list_of_files, key=os.path.getctime) # Find the latest file (just trained)
# print("The parameter.txt is put into folder " + latest_file) # Print to confirm the filename
"""
# Move the parameters.txt
destination = os.path.join(ckpt_dir, "parameters.txt");
shutil.move("parameters.txt", destination)
# Move the flags.obj
destination = os.path.join(ckpt_dir, "flags.obj");
shutil.move("flags.obj", destination)
# 6
def save_flags(flags, save_dir, save_file="flags.obj"):
"""
This function serialize the flag object and save it for further retrieval during inference time
:param flags: The flags object to save
:param save_file: The place to save the file
:return: None
"""
with open(os.path.join(save_dir, save_file),'wb') as f: # Open the file
pickle.dump(flags, f) # Use Pickle to serialize the object
# 7
def load_flags(save_dir, save_file="flags.obj"):
"""
This function inflate the pickled object to flags object for reuse, typically during evaluation (after training)
:param save_dir: The place where the obj is located
:param save_file: The file name of the file, usually flags.obj
:return: flags
"""
with open(os.path.join(save_dir, save_file), 'rb') as f: # Open the file
flags = pickle.load(f) # Use pickle to inflate the obj back to RAM
return flags
# 8
def write_flags_and_BVE(flags, ntwk, forward_best_loss=None):
"""
The function that is usually executed at the end of the training where the flags and the best validation loss are recorded
They are put in the folder that called this function and save as "parameters.txt"
This parameter.txt is also attached to the generated email
:param flags: The flags struct containing all the parameters
:param ntwk: The network object that contains the bvl, save_dir
:return: None
Deprecated parameters:
:param best_validation_loss: The best_validation_loss recorded in a training
:param forard_best_loss: The forward best loss only applicable for Tandem model
"""
flags.best_validation_loss = ntwk.best_validation_loss
try:
flags.best_training_loss = ntwk.best_training_loss
except:
print("There is no training loss, this is an older version of the coder")
if forward_best_loss is not None:
flags.best_forward_validation_loss = forward_best_loss
copy_flags = deepcopy(flags)
flags_dict = vars(copy_flags)
# Convert the dictionary into pandas data frame which is easier to handle with and write read
with open(os.path.join(ntwk.ckpt_dir, 'parameters.txt'), 'w') as f:
print(flags_dict, file=f)
# Pickle the obj
save_flags(flags, save_dir=ntwk.ckpt_dir)
# 16
def normalize_eval(x, x_max, x_min):
"""
Normalize the x into [-1, 1] range in each dimension [:, i]
:param x: np array to be normalized
:return: normalized np array
"""
for i in range(len(x[0])):
x_range = (x_max - x_min ) /2.
x_avg = (x_max + x_min) / 2.
x[:, i] = (x[:, i] - x_avg) / x_range
return x
# 17
def unnormalize_eval(x, x_max, x_min):
"""
UnNormalize the x into [-1, 1] range in each dimension [:, i]
:param x: np array to be normalized
:return: normalized np array
"""
for i in range(len(x[0])):
x_range = (x_max - x_min ) /2.
x_avg = (x_max + x_min) / 2.
x[:, i] = x[:, i] * x_range + x_avg
return x | AEML | /models/Transformer/utils/helper_functions.py | helper_functions.py |
import os
import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns; sns.set()
from utils import helper_functions
from utils.evaluation_helper import compare_truth_pred
from sklearn.neighbors import NearestNeighbors
from pandas.plotting import table
from scipy.spatial import distance_matrix
from scipy.sparse import csr_matrix
from scipy.sparse.csgraph import minimum_spanning_tree
from matplotlib.lines import Line2D
def InferenceAccuracyExamplePlot(model_name, save_name, title, sample_num=10, fig_size=(15,5), random_seed=1,
target_region=[0,300 ]):
"""
The function to plot the Inference accuracy and compare with FFDS algorithm.
It takes the Ypred and Ytruth file as input and plot the first <sample_num> of spectras.
It also takes a random of 10 points to at as the target points.
:param model_name: The model name as the postfix for the Ytruth file
:param save_name: The saving name of the figure
:param title: The saving title of the figure
:param sample_num: The number of sample to plot for comparison
:param fig_size: The size of the figure
:param random_seed: The random seed value
:param target_region: The region that the targets get
:return:
"""
# Get the prediction and truth file first
Ytruth_file = os.path.join('data','test_Ytruth_{}.csv'.format(model_name))
Ypred_file = os.path.join('data','test_Ypred_{}.csv'.format(model_name))
Ytruth = pd.read_csv(Ytruth_file, header=None, delimiter=' ').values
Ypred = pd.read_csv(Ypred_file, header=None, delimiter=' ').values
# Draw uniform random distribution for the reference points
np.random.seed(random_seed) # To make sure each time we have same target points
targets = target_region[0] + (target_region[1] - target_region[0]) * np.random.uniform(low=0, high=1, size=10) # Cap the random numbers within 0-299
targets = targets.astype("int")
# Make the frequency into real frequency in THz
fre_low = 0.86
fre_high = 1.5
frequency = fre_low + (fre_high - fre_low)/len(Ytruth[0, :]) * np.arange(300)
for i in range(sample_num):
# Start the plotting
f = plt.figure(figsize=fig_size)
plt.title(title)
plt.scatter(frequency[targets], Ytruth[i,targets], label='S*')
plt.plot(frequency, Ytruth[i,:], label='FFDS')
plt.plot(frequency, Ypred[i,:], label='Candidate')
plt.legend()
plt.ylim([0,1])
plt.xlim([fre_low, fre_high])
plt.grid()
plt.xlabel("Frequency (THz)")
plt.ylabel("Transmittance")
plt.savefig(os.path.join('data',save_name + str(i) + '.png'))
def RetrieveFeaturePredictionNMse(model_name):
"""
Retrieve the Feature and Prediciton values and place in a np array
:param model_name: the name of the model
return Xtruth, Xpred, Ytruth, Ypred
"""
# Retrieve the prediction and truth and prediction first
feature_file = os.path.join('data', 'test_Xtruth_{}.csv'.format(model_name))
pred_file = os.path.join('data', 'test_Ypred_{}.csv'.format(model_name))
truth_file = os.path.join('data', 'test_Ytruth_{}.csv'.format(model_name))
feat_file = os.path.join('data', 'test_Xpred_{}.csv'.format(model_name))
# Getting the files from file name
Xtruth = pd.read_csv(feature_file,header=None, delimiter=' ')
Xpred = pd.read_csv(feat_file,header=None, delimiter=' ')
Ytruth = pd.read_csv(truth_file,header=None, delimiter=' ')
Ypred = pd.read_csv(pred_file,header=None, delimiter=' ')
#retrieve mse, mae
Ymae, Ymse = compare_truth_pred(pred_file, truth_file) #get the maes of y
print(Xtruth.shape)
return Xtruth.values, Xpred.values, Ytruth.values, Ypred.values, Ymae, Ymse
def ImportColorBarLib():
"""
Import some libraries that used in a colorbar plot
"""
import matplotlib.colors as colors
import matplotlib.cm as cmx
from matplotlib.collections import LineCollection
from matplotlib.colors import ListedColormap, BoundaryNorm
import matplotlib as mpl
print("import sucessful")
return mpl
def UniqueMarkers():
import itertools
markers = itertools.cycle(( 'x','1','+', '.', '*','D','v','h'))
return markers
def SpectrumComparisonNGeometryComparison(rownum, colnum, Figsize, model_name, boundary = [-1,1,-1,1]):
"""
Read the Prediction files and plot the spectra comparison plots
:param SubplotArray: 2x2 array indicating the arrangement of the subplots
:param Figsize: the size of the figure
:param Figname: the name of the figures to save
:param model_name: model name (typically a list of numebr containing date and time)
"""
mpl = ImportColorBarLib() #import lib
Xtruth, Xpred, Ytruth, Ypred, Ymae, Ymse = RetrieveFeaturePredictionNMse(model_name) #retrieve features
print("Ymse shape:",Ymse.shape)
print("Xpred shape:", Xpred.shape)
print("Xtrth shape:", Xtruth.shape)
#Plotting the spectrum comaprison
f = plt.figure(figsize=Figsize)
fignum = rownum * colnum
for i in range(fignum):
ax = plt.subplot(rownum, colnum, i+1)
plt.ylabel('Transmission rate')
plt.xlabel('frequency')
plt.plot(Ytruth[i], label = 'Truth',linestyle = '--')
plt.plot(Ypred[i], label = 'Prediction',linestyle = '-')
plt.legend()
plt.ylim([0,1])
f.savefig('Spectrum Comparison_{}'.format(model_name))
"""
Plotting the geometry comparsion, there are fignum points in each plot
each representing a data point with a unique marker
8 dimension therefore 4 plots, 2x2 arrangement
"""
#for j in range(fignum):
pointnum = fignum #change #fig to #points in comparison
f = plt.figure(figsize = Figsize)
ax0 = plt.gca()
for i in range(4):
truthmarkers = UniqueMarkers() #Get some unique markers
predmarkers = UniqueMarkers() #Get some unique markers
ax = plt.subplot(2, 2, i+1)
#plt.xlim([29,56]) #setting the heights limit, abandoned because sometime can't see prediciton
#plt.ylim([41,53]) #setting the radius limits
for j in range(pointnum):
#Since the colored scatter only takes 2+ arguments, plot 2 same points to circumvent this problem
predArr = [[Xpred[j, i], Xpred[j, i]] ,[Xpred[j, i + 4], Xpred[j, i + 4]]]
predC = [Ymse[j], Ymse[j]]
truthplot = plt.scatter(Xtruth[j,i],Xtruth[j,i+4],label = 'Xtruth{}'.format(j),
marker = next(truthmarkers),c = 'm',s = 40)
predplot = plt.scatter(predArr[0],predArr[1],label = 'Xpred{}'.format(j),
c =predC ,cmap = 'jet',marker = next(predmarkers), s = 60)
plt.xlabel('h{}'.format(i))
plt.ylabel('r{}'.format(i))
rect = mpl.patches.Rectangle((boundary[0],boundary[2]),boundary[1] - boundary[0], boundary[3] - boundary[2],
linewidth=1,edgecolor='r',
facecolor='none',linestyle = '--',label = 'data region')
ax.add_patch(rect)
plt.autoscale()
plt.legend(bbox_to_anchor=(0., 1.02, 1., .102),
mode="expand",ncol = 6, prop={'size': 5})#, bbox_to_anchor=(1,0.5))
cb_ax = f.add_axes([0.93, 0.1, 0.02, 0.8])
cbar = f.colorbar(predplot, cax=cb_ax)
#f.colorbar(predplot)
f.savefig('Geometry Comparison_{}'.format(model_name))
class HMpoint(object):
"""
This is a HeatMap point class where each object is a point in the heat map
properties:
1. BV_loss: best_validation_loss of this run
2. feature_1: feature_1 value
3. feature_2: feature_2 value, none is there is no feature 2
"""
def __init__(self, bv_loss, f1, f2 = None, f1_name = 'f1', f2_name = 'f2'):
self.bv_loss = bv_loss
self.feature_1 = f1
self.feature_2 = f2
self.f1_name = f1_name
self.f2_name = f2_name
#print(type(f1))
def to_dict(self):
return {
self.f1_name: self.feature_1,
self.f2_name: self.feature_2,
self.bv_loss: self.bv_loss
}
def HeatMapBVL(plot_x_name, plot_y_name, title, save_name='HeatMap.png', HeatMap_dir = 'HeatMap',
feature_1_name=None, feature_2_name=None,
heat_value_name = 'best_validation_loss'):
"""
Plotting a HeatMap of the Best Validation Loss for a batch of hyperswiping thing
First, copy those models to a folder called "HeatMap"
Algorithm: Loop through the directory using os.look and find the parameters.txt files that stores the
:param HeatMap_dir: The directory where the checkpoint folders containing the parameters.txt files are located
:param feature_1_name: The name of the first feature that you would like to plot on the feature map
:param feature_2_name: If you only want to draw the heatmap using 1 single dimension, just leave it as None
"""
one_dimension_flag = False #indication flag of whether it is a 1d or 2d plot to plot
#Check the data integrity
if (feature_1_name == None):
print("Please specify the feature that you want to plot the heatmap");
return
if (feature_2_name == None):
one_dimension_flag = True
print("You are plotting feature map with only one feature, plotting loss curve instead")
#Get all the parameters.txt running related data and make HMpoint objects
HMpoint_list = []
df_list = [] #make a list of data frame for further use
print("going through folder: ", HeatMap_dir)
for subdir, dirs, files in os.walk(HeatMap_dir):
for file_name in files:
#print("passing file-name:", file_name)
if (file_name == 'parameters.txt'):
file_path = os.path.join(subdir, file_name) #Get the file relative path from
# df = pd.read_csv(file_path, index_col=0)
flag = helper_functions.load_flags(subdir)
flag_dict = vars(flag)
df = pd.DataFrame()
for k in flag_dict:
df[k] = pd.Series(str(flag_dict[k]), index=[0])
#print(df)
if (one_dimension_flag):
df_list.append(df[[heat_value_name, feature_1_name]])
HMpoint_list.append(HMpoint(float(df[heat_value_name][0]), eval(str(df[feature_1_name][0])),
f1_name = feature_1_name))
else:
if feature_2_name == 'linear_unit' or feature_1_name =='linear_unit': # If comparing different linear units
print('You are plotting versus linear unit')
# linear_unit has always need to be at the feature_2 and either from linear or linear_f,
# If you want to test for linear_b for Tandem, make sure you modify manually here
try:
df['linear_unit'] = eval(df['linear'][0])[1]
except:
try:
df['linear_unit'] = eval(df['head_linear'][0])[1]
except:
df['linear_unit'] = eval(df['tail_linear'][0])[1]
#df['best_validation_loss'] = get_bvl(file_path)
if feature_2_name == 'kernel_second': # If comparing different kernel convs
#print(df['conv_kernel_size'])
#print(type(df['conv_kernel_size']))
df['kernel_second'] = eval(df['conv_kernel_size'][0])[1]
df['kernel_first'] = eval(df['conv_kernel_size'][0])[0]
df_list.append(df[[heat_value_name, feature_1_name, feature_2_name]])
HMpoint_list.append(HMpoint(float(df[heat_value_name][0]),eval(str(df[feature_1_name][0])),
eval(str(df[feature_2_name][0])), feature_1_name, feature_2_name))
#print("df_list =", df_list)
if len(df_list) == 0:
print("Your df list is empty, which means you probably mis-spelled the folder name or your folder does not have any parameters.txt?")
#Concatenate all the dfs into a single aggregate one for 2 dimensional usee
df_aggregate = pd.concat(df_list, ignore_index = True, sort = False)
df_aggregate = df_aggregate.astype({heat_value_name: 'float'})
print("before transformation:", df_aggregate)
[h, w] = df_aggregate.shape
#print('df_aggregate has shape {}, {}'.format(h, w))
# making the 2d ones with list to be the lenghth (num_layers)
for i in range(h):
for j in range(w):
#print('debugging for nan: ', df_aggregate.iloc[i,j])
if isinstance(df_aggregate.iloc[i,j], str) and 'nan' not in df_aggregate.iloc[i,j]:
if isinstance(eval(df_aggregate.iloc[i,j]), list):
df_aggregate.iloc[i,j] = len(eval(df_aggregate.iloc[i,j]))
# If the grid is random (making too sparse a signal), aggregate them
# The signature of a random grid is the unique value of rows for feature is very large
if len(np.unique(df_aggregate.values[:, -1])) > 0.95 * h and False: # If the number of unique features is more than 80%, this is random
print('This is probably a randomly selected trail? check if not!!!')
df_aggregate = df_aggregate.astype('float')
num_bins = 5 # Put all random values into 5 bins
num_items = int(np.floor(h/num_bins)) # each bins have num_item numbers inside, last one being more
feature_1_value_list = df_aggregate.values[:, -1] # Get the values
feature_2_value_list = df_aggregate.values[:, -2]
feature_1_order = np.argsort(feature_1_value_list) # Get the order
feature_2_order = np.argsort(feature_2_value_list)
for i in range(num_bins):
if i != num_bins - 1:
df_aggregate.iloc[feature_1_order[i*num_items: (i+1)*num_items], -1] = df_aggregate.iloc[feature_1_order[i*num_items], -1]
df_aggregate.iloc[feature_2_order[i*num_items: (i+1)*num_items], -2] = df_aggregate.iloc[feature_2_order[i*num_items], -2]
else:
df_aggregate.iloc[feature_1_order[i*num_items: ], -1] = df_aggregate.iloc[feature_1_order[i*num_items], -1]
df_aggregate.iloc[feature_2_order[i*num_items: ], -2] = df_aggregate.iloc[feature_2_order[i*num_items], -2]
#print('type of last number of df_aggregate is', type(df_aggregate.iloc[-1, -1]))
########################################################################################################
#df_aggregate.iloc[:, df.columns != heat_value_name] = df_aggregate.iloc[:, df.columns != heat_value_name].round(decimals=3)
########################################################################################################
#print("after transoformation:",df_aggregate)
#Change the feature if it is a tuple, change to length of it
for cnt, point in enumerate(HMpoint_list):
#print("For point {} , it has {} loss, {} for feature 1 and {} for feature 2".format(cnt,
# point.bv_loss, point.feature_1, point.feature_2))
assert(isinstance(point.bv_loss, float)) #make sure this is a floating number
if (isinstance(point.feature_1, tuple)):
point.feature_1 = len(point.feature_1)
if (isinstance(point.feature_2, tuple)):
point.feature_2 = len(point.feature_2)
f = plt.figure()
#After we get the full list of HMpoint object, we can start drawing
if (feature_2_name == None):
print("plotting 1 dimension HeatMap (which is actually a line)")
HMpoint_list_sorted = sorted(HMpoint_list, key = lambda x: x.feature_1)
#Get the 2 lists of plot
bv_loss_list = []
feature_1_list = []
for point in HMpoint_list_sorted:
bv_loss_list.append(point.bv_loss)
feature_1_list.append(point.feature_1)
print("bv_loss_list:", bv_loss_list)
print("feature_1_list:",feature_1_list)
#start plotting
plt.plot(feature_1_list, bv_loss_list,'o-')
else: #Or this is a 2 dimension HeatMap
print("plotting 2 dimension HeatMap")
#point_df = pd.DataFrame.from_records([point.to_dict() for point in HMpoint_list])
df_aggregate = df_aggregate.round(decimals=9)
df_aggregate = df_aggregate.reset_index()
df_aggregate.sort_values(feature_1_name, axis=0, inplace=True)
df_aggregate.sort_values(feature_2_name, axis=0, inplace=True)
df_aggregate.sort_values(heat_value_name, axis=0, inplace=True)
print("before dropping", df_aggregate)
df_aggregate = df_aggregate.drop_duplicates(subset=[feature_1_name, feature_2_name], keep='first')
print("after dropping", df_aggregate)
point_df_pivot = df_aggregate.reset_index().pivot(index=feature_1_name, columns=feature_2_name, values=heat_value_name).astype(float)
#point_df_pivot = point_df_pivot.rename({'5': '05'}, axis=1)
# Trying to sort the indexs
point_df_pivot.sort_index(axis=0, inplace=True, key=lambda x: x.astype(float))
point_df_pivot.sort_index(axis=1, inplace=True, key=lambda x: x.astype(float))
#point_df_pivot = point_df_pivot.reindex(sorted(point_df_pivot.columns), axis=1)
print("pivot=")
csvname = HeatMap_dir + 'pivoted.csv'
point_df_pivot.to_csv(csvname, float_format="%.3g")
print(point_df_pivot)
sns.heatmap(point_df_pivot, cmap = "YlGnBu")
plt.xlabel(plot_y_name) # Note that the pivot gives reversing labels
plt.ylabel(plot_x_name) # Note that the pivot gives reversing labels
plt.title(title)
plt.savefig(save_name)
point_df_pivot.to_csv(save_name.replace('.png','.csv'))
def PlotPossibleGeoSpace(figname, Xpred_dir, compare_original = False,calculate_diversity = None):
"""
Function to plot the possible geometry space for a model evaluation result.
It reads from Xpred_dir folder and finds the Xpred result insdie and plot that result
:params figname: The name of the figure to save
:params Xpred_dir: The directory to look for Xpred file which is the source of plotting
:output A plot containing 4 subplots showing the 8 geomoetry dimensions
"""
Xpred = helper_functions.get_Xpred(Xpred_dir)
Xtruth = helper_functions.get_Xtruth(Xpred_dir)
f = plt.figure()
ax0 = plt.gca()
print(np.shape(Xpred))
if (calculate_diversity == 'MST'):
diversity_Xpred, diversity_Xtruth = calculate_MST(Xpred, Xtruth)
elif (calculate_diversity == 'AREA'):
diversity_Xpred, diversity_Xtruth = calculate_AREA(Xpred, Xtruth)
for i in range(4):
ax = plt.subplot(2, 2, i+1)
ax.scatter(Xpred[:,i], Xpred[:,i + 4],s = 3,label = "Xpred")
if (compare_original):
ax.scatter(Xtruth[:,i], Xtruth[:,i+4],s = 3, label = "Xtruth")
plt.xlabel('h{}'.format(i))
plt.ylabel('r{}'.format(i))
plt.xlim(-1,1)
plt.ylim(-1,1)
plt.legend()
if (calculate_diversity != None):
plt.text(-4, 3.5,'Div_Xpred = {}, Div_Xtruth = {}, under criteria {}'.format(diversity_Xpred, diversity_Xtruth, calculate_diversity), zorder = 1)
plt.suptitle(figname)
f.savefig(figname+'.png')
def PlotPairwiseGeometry(figname, Xpred_dir):
"""
Function to plot the pair-wise scattering plot of the geometery file to show
the correlation between the geometry that the network learns
"""
Xpredfile = helper_functions.get_Xpred(Xpred_dir)
Xpred = pd.read_csv(Xpredfile, header=None, delimiter=' ')
f=plt.figure()
axes = pd.plotting.scatter_matrix(Xpred, alpha = 0.2)
#plt.tight_layout()
plt.title("Pair-wise scattering of Geometery predictions")
plt.savefig(figname)
def calculate_AREA(Xpred, Xtruth):
"""
Function to calculate the area for both Xpred and Xtruth under using the segmentation of 0.01
"""
area_list = np.zeros([2,4])
X_list = [Xpred, Xtruth]
binwidth = 0.05
for cnt, X in enumerate(X_list):
for i in range(4):
hist, xedges, yedges = np.histogram2d(X[:,i],X[:,i+4], bins = np.arange(-1,1+binwidth,binwidth))
area_list[cnt, i] = np.mean(hist > 0)
X_histgt0 = np.mean(area_list, axis = 1)
assert len(X_histgt0) == 2
return X_histgt0[0], X_histgt0[1]
def calculate_MST(Xpred, Xtruth):
"""
Function to calculate the MST for both Xpred and Xtruth under using the segmentation of 0.01
"""
MST_list = np.zeros([2,4])
X_list = [Xpred, Xtruth]
for cnt, X in enumerate(X_list):
for i in range(4):
points = X[:,i:i+5:4]
distance_matrix_points = distance_matrix(points,points, p = 2)
csr_mat = csr_matrix(distance_matrix_points)
Tree = minimum_spanning_tree(csr_mat)
MST_list[cnt,i] = np.sum(Tree.toarray().astype(float))
X_MST = np.mean(MST_list, axis = 1)
return X_MST[0], X_MST[1]
def get_bvl(file_path):
"""
This is a helper function for 0119 usage where the bvl is not recorded in the pickled object but in .txt file and needs this funciton to retrieve it
"""
df = pd.read_csv(file_path, delimiter=',')
bvl = 0
for col in df:
if 'best_validation_loss' in col:
print(col)
strlist = col.split(':')
#print("in get_bvl, str is: ", strlist[1])
if strlist[1].endswith(']') or strlist[1].endswith('}') :
strlist[1] = strlist[1][:-1]
bvl = eval(strlist[1])
print("bvl = ", bvl)
if bvl == 0:
print("Error! We did not found a bvl in .txt.file")
else:
return float(bvl)
def get_xpred_ytruth_xtruth_from_folder(data_dir):
"""
This function get the list of Xpred and single Ytruth file in the folder from multi_eval and output the list of Xpred, single Ytruth and Single Xtruth numpy array for further operation
Since this is not operating on NA series, there is no order in the Xpred files
###########################################################
#NOTE: THIS FUNCTION SHOULD NOT OPERATE ON NA BASED METHOD#
###########################################################
:param data_dir: The directory to get the files
:output Xpred_list: The list of Xpred files, each element is a numpy array with same shape of Xtruth
:output Ytruth: The Ytruth numpy array
:output Xtruth: The Xtruth numpy array
"""
# Reading Truth files
Yt = pd.read_csv(os.path.join(data_dir, 'Ytruth.csv'), header=None, delimiter=' ').values
Xt = pd.read_csv(os.path.join(data_dir, 'Xtruth.csv'), header=None, delimiter=' ').values
# Reading the list of prediction files
Xpred_list = []
for files in os.listdir(data_dir):
if 'Xpred' in files:
Xp = pd.read_csv(os.path.join(data_dir, files), header=None, delimiter=' ').values
Xpred_list.append(Xp)
return Xpred_list, Xt, Yt
def reshape_xpred_list_to_mat(Xpred_list):
"""
This function reshapes the Xpred list (typically from "get_xpred_ytruth_xtruth_from_folder") which has the shape: #initialization (2048, as a list) x #data_point (1000) x #xdim
into a matrix form for easier formatting for the backpropagation in NA modes
:param Xpred_list: A list of #init, each element has shape of (#data_point 1000 x #xdim)
:output X_init_mat: A matrix of shape (2048, 1000, dxim)
"""
# Get length of list (2048)
list_length = len(Xpred_list)
# Get shape of Xpred files
xshape = np.shape(Xpred_list[0])
# Init the big matrix
X_init_mat = np.zeros([list_length, xshape[0], xshape[1]])
# Fill in the matrix
for ind, xpred in enumerate(Xpred_list):
X_init_mat[ind,:,:] = np.copy(xpred)
return X_init_mat
def get_mse_mat_from_folder(data_dir):
"""
The function to get the mse matrix from the giant folder that contains all the multi_eval files.
Due to the data structure difference of NA storing, we would handle NA in different way than other algorithms
:param data_dir: The directory where the data is in
"""
Yt = pd.read_csv(os.path.join(data_dir, 'Ytruth.csv'), header=None, delimiter=' ').values
print("shape of ytruth is", np.shape(Yt))
# Get all the Ypred into list
Ypred_list = []
####################################################################
# Special handling for NA as it output file structure is different #
####################################################################
if 'NA' in data_dir or 'on' in data_dir or 'GA' in data_dir:
l, w = np.shape(Yt)
print("shape of Yt", l,' ', w)
num_trails = 200
#num_trails = 2048
Ypred_mat = np.zeros([l, num_trails, w])
check_full = np.zeros(l) # Safety check for completeness
for files in os.listdir(data_dir):
if '_Ypred_' in files:
Yp = pd.read_csv(os.path.join(data_dir, files), header=None, delimiter=' ').values
if len(np.shape(Yp)) == 1: # For ballistic data set where it is a coloumn only
Yp = np.reshape(Yp, [-1, 1])
print("shape of Ypred file is", np.shape(Yp))
# Truncating to the top num_trails inferences
if len(Yp) != num_trails:
Yp = Yp[:num_trails,:]
number_str = files.split('inference')[-1][:-4]
print(number_str)
number = int(files.split('inference')[-1][:-4])
Ypred_mat[number, :, :] = Yp
check_full[number] = 1
assert np.sum(check_full) == l, 'Your list is not complete, {} Ypred files out of {} are present'.format(np.sum(check_full), l)
# Finished fullfilling the Ypred mat, now fill in the Ypred list as before
for i in range(num_trails):
Ypred_list.append(Ypred_mat[:, i, :])
else:
for files in os.listdir(data_dir):
if 'Ypred' in files:
#print(files)
Yp = pd.read_csv(os.path.join(data_dir, files), header=None, delimiter=' ').values
if len(np.shape(Yp)) == 1: # For ballistic data set where it is a coloumn only
Yp = np.reshape(Yp, [-1, 1])
#print("shape of Ypred file is", np.shape(Yp))
Ypred_list.append(Yp)
# Calculate the large MSE matrix
mse_mat = np.zeros([len(Ypred_list), len(Yt)])
print("shape of mse_mat is", np.shape(mse_mat))
for ind, yp in enumerate(Ypred_list):
if np.shape(yp) != np.shape(Yt):
print("Your Ypred file shape does not match your ytruth, however, we are trying to reshape your ypred file into the Ytruth file shape")
print("shape of the Yp is", np.shape(yp))
print("shape of the Yt is", np.shape(Yt))
yp = np.reshape(yp, np.shape(Yt))
if ind == 1:
print(np.shape(yp))
# For special case yp = -999, it is out of numerical simulator
print("shape of np :", np.shape(yp))
print("shape of Yt :", np.shape(Yt))
if np.shape(yp)[1] == 1: # If this is ballistics (actually sinewave also is 1d)
print("this is ballistics dataset, checking the -999 situation now")
valid_index = yp[:, 0] != -999
invalid_index = yp[:, 0] == -999
#valid_index = np.arange(len(yp[:, 0]))[valid_index]
#invalid_index = np.arange(len(yp[:, 0]))[not valid_index]
print("shape of valid flag :", np.shape(valid_index))
mse = np.mean(np.square(yp - Yt), axis=1)
mse_mat[ind, valid_index] = mse[valid_index]
mse_mat[ind, invalid_index] = -999
#valid_num = np.sum(valid_index)
#yp = yp[valid_index, :]
#Yt_valid = Yt[valid_index, :]
#print("shape of np after valid :", np.shape(yp))
#print("shape of Yt after valid :", np.shape(Yt_valid))
#mse = np.mean(np.square(yp - Yt_valid), axis=1)
#if valid_num == len(valid_index):
# mse_mat[ind, :] = mse
#else:
# mse_mat[ind, :valid_num] = mse
# mse_mat[ind, valid_num:] = np.mean(mse)
else:
mse = np.mean(np.square(yp - Yt), axis=1)
mse_mat[ind, :] = mse
print("shape of the yp is", np.shape(yp))
print("shape of mse is", np.shape(mse))
# Extra step to work with -999 case for ballistics
if np.shape(yp)[1] == 1:
print("Processing the ballistics data due to -999")
for i in range(len(Yt)):
# Get that list
mse_list = mse_mat[:, i]
# change ones with -999 to mean of others
valid_list = mse_list != -999
invalid_list = mse_list == -999
mse_mat[invalid_list, i] = np.mean(mse_list[valid_list])
return mse_mat, Ypred_list
def MeanAvgnMinMSEvsTry(data_dir):
"""
Plot the mean average Mean and Min Squared error over Tries
:param data_dir: The directory where the data is in
:param title: The title for the plot
:return:
"""
# Read Ytruth file
if not os.path.isdir(data_dir):
print("Your data_dir is not a folder in MeanAvgnMinMSEvsTry function")
print("Your data_dir is:", data_dir)
return
# Get the MSE matrix from the giant folder with multi_eval
mse_mat, Ypred_list = get_mse_mat_from_folder(data_dir)
# Shuffle array and average results
shuffle_number = 0
if shuffle_number > 0:
# Calculate the min and avg from mat
mse_min_list = np.zeros([len(Ypred_list), shuffle_number])
mse_avg_list = np.zeros([len(Ypred_list), shuffle_number])
for shuf in range(shuffle_number):
rng = np.random.default_rng()
rng.shuffle(mse_mat)
for i in range(len(Ypred_list)):
mse_avg_list[i, shuf] = np.mean(mse_mat[:i+1, :])
mse_min_list[i, shuf] = np.mean(np.min(mse_mat[:i+1, :], axis=0))
# Average the shuffled result
mse_avg_list = np.mean(mse_avg_list, axis=1)
mse_min_list = np.mean(mse_min_list, axis=1)
else: # Currently the results are not shuffled as the statistics are enough
# Calculate the min and avg from mat
mse_min_list = np.zeros([len(Ypred_list),])
mse_avg_list = np.zeros([len(Ypred_list),])
mse_std_list = np.zeros([len(Ypred_list),])
mse_quan2575_list = np.zeros([2, len(Ypred_list)])
if 'NA' in data_dir:
cut_front = 0
else:
cut_front = 0
for i in range(len(Ypred_list)-cut_front):
mse_avg_list[i] = np.mean(mse_mat[cut_front:i+1+cut_front, :])
mse_min_list[i] = np.mean(np.min(mse_mat[cut_front:i+1+cut_front, :], axis=0))
mse_std_list[i] = np.std(np.min(mse_mat[cut_front:i+1+cut_front, :], axis=0))
mse_quan2575_list[0, i] = np.percentile(np.min(mse_mat[cut_front:i+1+cut_front, :], axis=0), 25)
mse_quan2575_list[1, i] = np.percentile(np.min(mse_mat[cut_front:i+1+cut_front, :], axis=0), 75)
# Save the list down for further analysis
np.savetxt(os.path.join(data_dir, 'mse_mat.csv'), mse_mat, delimiter=' ')
np.savetxt(os.path.join(data_dir, 'mse_avg_list.txt'), mse_avg_list, delimiter=' ')
np.savetxt(os.path.join(data_dir, 'mse_min_list.txt'), mse_min_list, delimiter=' ')
np.savetxt(os.path.join(data_dir, 'mse_std_list.txt'), mse_std_list, delimiter=' ')
np.savetxt(os.path.join(data_dir, 'mse_quan2575_list.txt'), mse_quan2575_list, delimiter=' ')
# Plotting
f = plt.figure()
x_axis = np.arange(len(Ypred_list))
plt.plot(x_axis, mse_avg_list, label='avg')
plt.plot(x_axis, mse_min_list, label='min')
plt.legend()
plt.xlabel('inference number')
plt.ylabel('mse error')
plt.savefig(os.path.join(data_dir,'mse_plot vs time'))
return None
def MeanAvgnMinMSEvsTry_all(data_dir): # Depth=2 now based on current directory structure
"""
Do the recursive call for all sub_dir under this directory
:param data_dir: The mother directory that calls
:return:
"""
for dirs in os.listdir(data_dir):
print("entering :", dirs)
print("this is a folder?:", os.path.isdir(os.path.join(data_dir, dirs)))
print("this is a file?:", os.path.isfile(os.path.join(data_dir, dirs)))
#if this is not a folder
if not os.path.isdir(os.path.join(data_dir, dirs)):
print("This is not a folder", dirs)
continue
for subdirs in os.listdir(os.path.join(data_dir, dirs)):
if os.path.isfile(os.path.join(data_dir, dirs, subdirs, 'mse_min_list.txt')): # if this has been done
continue;
print("enters folder", subdirs)
MeanAvgnMinMSEvsTry(os.path.join(data_dir, dirs, subdirs))
return None
def DrawBoxPlots_multi_eval(data_dir, data_name, save_name='Box_plot'):
"""
The function to draw the statitstics of the data using a Box plot
:param data_dir: The mother directory to call
:param data_name: The data set name
"""
# Predefine name of mse_mat
mse_mat_name = 'mse_mat.csv'
#Loop through directories
mse_mat_dict = {}
for dirs in os.listdir(data_dir):
print(dirs)
if not os.path.isdir(os.path.join(data_dir, dirs)):# or 'NA' in dirs:
print("skipping due to it is not a directory")
continue;
for subdirs in os.listdir((os.path.join(data_dir, dirs))):
if subdirs == data_name:
# Read the lists
mse_mat = pd.read_csv(os.path.join(data_dir, dirs, subdirs, mse_mat_name),
header=None, delimiter=' ').values
# Put them into dictionary
mse_mat_dict[dirs] = mse_mat
# Get the box plot data
box_plot_data = []
for key in sorted(mse_mat_dict.keys()):
data = mse_mat_dict[key][0, :]
# data = np.mean(mse_mat_dict[key], axis=1)
box_plot_data.append(data)
print('{} avg error is : {}'.format(key, np.mean(data)))
# Start plotting
f = plt.figure()
plt.boxplot(box_plot_data, patch_artist=True, labels=sorted(mse_mat_dict.keys()))
plt.ylabel('mse')
ax = plt.gca()
ax.set_yscale('log')
plt.savefig(os.path.join(data_dir, data_name + save_name + '.png'))
return None
def DrawAggregateMeanAvgnMSEPlot(data_dir, data_name, save_name='aggregate_plot',
gif_flag=False, plot_points=200,resolution=None, dash_group='nobody',
dash_label='', solid_label='',worse_model_mode=False): # Depth=2 now based on current directory structure
"""
The function to draw the aggregate plot for Mean Average and Min MSEs
:param data_dir: The mother directory to call
:param data_name: The data set name
:param git_flag: Plot are to be make a gif
:param plot_points: Number of points to be plot
:param resolution: The resolution of points
:return:
"""
# Predefined name of the avg lists
min_list_name = 'mse_min_list.txt'
avg_list_name = 'mse_avg_list.txt'
std_list_name = 'mse_std_list.txt'
quan2575_list_name = 'mse_quan2575_list.txt'
# Loop through the directories
avg_dict, min_dict, std_dict, quan2575_dict = {}, {}, {}, {}
for dirs in os.listdir(data_dir):
# Dont include NA for now and check if it is a directory
print("entering :", dirs)
print("this is a folder?:", os.path.isdir(os.path.join(data_dir, dirs)))
print("this is a file?:", os.path.isfile(os.path.join(data_dir, dirs)))
if not os.path.isdir(os.path.join(data_dir, dirs)):# or dirs == 'NA':# or 'boundary' in dirs::
print("skipping due to it is not a directory")
continue;
for subdirs in os.listdir((os.path.join(data_dir, dirs))):
if subdirs == data_name:
# Read the lists
mse_avg_list = pd.read_csv(os.path.join(data_dir, dirs, subdirs, avg_list_name),
header=None, delimiter=' ').values
mse_min_list = pd.read_csv(os.path.join(data_dir, dirs, subdirs, min_list_name),
header=None, delimiter=' ').values
mse_std_list = pd.read_csv(os.path.join(data_dir, dirs, subdirs, std_list_name),
header=None, delimiter=' ').values
mse_quan2575_list = pd.read_csv(os.path.join(data_dir, dirs, subdirs, quan2575_list_name),
header=None, delimiter=' ').values
print("The quan2575 error range shape is ", np.shape(mse_quan2575_list))
print("dirs =", dirs)
print("shape of mse_min_list is:", np.shape(mse_min_list))
# Put them into dictionary
avg_dict[dirs] = mse_avg_list
min_dict[dirs] = mse_min_list
std_dict[dirs] = mse_std_list
quan2575_dict[dirs] = mse_quan2575_list
#print("printing the min_dict", min_dict)
def plotDict(dict, name, data_name=None, logy=False, time_in_s_table=None, avg_dict=None,
plot_points=50, resolution=None, err_dict=None, color_assign=False, dash_group='nobody',
dash_label='', solid_label='', plot_xlabel=False, worse_model_mode=False):
"""
:param name: the name to save the plot
:param dict: the dictionary to plot
:param logy: use log y scale
:param time_in_s_table: a dictionary of dictionary which stores the averaged evaluation time
in seconds to convert the graph
:param plot_points: Number of points to be plot
:param resolution: The resolution of points
:param err_dict: The error bar dictionary which takes the error bar input
:param avg_dict: The average dict for plotting the starting point
:param dash_group: The group of plots to use dash line
:param dash_label: The legend to write for dash line
:param solid_label: The legend to write for solid line
:param plot_xlabel: The True or False flag for plotting the x axis label or not
:param worse_model_mode: The True or False flag for plotting worse model mode (1X, 10X, 50X, 100X worse model)
"""
import matplotlib.colors as mcolors
if worse_model_mode:
color_dict = {"(1X": "limegreen", "(10X": "blueviolet", "(50X":"cornflowerblue", "(100X": "darkorange"}
else:
# # manual color setting
# color_dict = {"VAE": "blueviolet","cINN":"crimson", "INN":"cornflowerblue", "Random": "limegreen",
# "MDN": "darkorange", "NA_init_lr_0.1_decay_0.5_batch_2048":"limegreen"}
# Automatic color setting
color_dict = {}
if len(dict.keys()) < 10:
color_pool = mcolors.TABLEAU_COLORS.keys()
else:
color_pool = mcolors.CSS4_COLORS.keys()
for ind, key in enumerate(dict.keys()):
color_dict[key] = list(color_pool)[ind]
f = plt.figure(figsize=[6,3])
ax = plt.gca()
ax.spines['bottom'].set_color('black')
ax.spines['top'].set_color('black')
ax.spines['left'].set_color('black')
ax.spines['right'].set_color('black')
text_pos = 0.01
# List for legend
legend_list = []
print("All the keys=", dict.keys())
print("All color keys=", color_dict.keys())
for key in sorted(dict.keys()):
######################################################
# This is for 02.02 getting the T=1, 50, 1000 result #
######################################################
#text = key.replace('_',' ')+"\n" + ': t1={:.2e},t50={:.2e},t1000={:.2e}'.format(dict[key][0][0], dict[key][49][0], dict[key][999][0])
#print("printing message on the plot now")
#plt.text(1, text_pos, text, wrap=True)
#text_pos /= 5
# Linestyle
if dash_group is not None and dash_group in key:
linestyle = 'dashed'
else:
linestyle = 'solid'
x_axis = np.arange(len(dict[key])).astype('float')
x_axis += 1
if time_in_s_table is not None:
x_axis *= time_in_s_table[data_name][key]
#print("printing", name)
print('key = ', key)
#print(dict[key])
if err_dict is None:
if color_assign:
line_axis, = plt.plot(x_axis[:plot_points:resolution], dict[key][:plot_points:resolution],c=color_dict[key.split('_')[0]],label=key, linestyle=linestyle)
else:
line_axis, = plt.plot(x_axis[:plot_points:resolution], dict[key][:plot_points:resolution],label=key, linestyle=linestyle)
else:
# This is the case where we plot the continuous error curve
if resolution is None:
# For mm_bench, this is not needed
#label = key.split('_')[0]
label = key
if linestyle == 'dashed':
label = None
#color_key = key.split('_')[0].split(')')[0] # '_' is for separating BP_ox_FF_ox and ')' is for worse model
color_key = key
#print("color key = ", color_key)
line_axis, = plt.plot(x_axis[:plot_points], dict[key][:plot_points], color=color_dict[color_key], linestyle=linestyle, label=label)
lower = - err_dict[key][0, :plot_points] + np.ravel(dict[key][:plot_points])
higher = err_dict[key][1, :plot_points] + np.ravel(dict[key][:plot_points])
plt.fill_between(x_axis[:plot_points], lower, higher, color=color_dict[color_key], alpha=0.2)
else:
if color_assign:
line_axis = plt.errorbar(x_axis[:plot_points:resolution], dict[key][:plot_points:resolution],c=color_dict[key.split('_')[0]], yerr=err_dict[key][:, :plot_points:resolution], label=key.replace('_',' '), capsize=5, linestyle=linestyle)#, errorevery=resolution)#,
else:
line_axis = plt.errorbar(x_axis[:plot_points:resolution], dict[key][:plot_points:resolution], yerr=err_dict[key][:, :plot_points:resolution], label=key.replace('_',' '), capsize=5, linestyle=linestyle)#, errorevery=resolution)#,
#dash_capstyle='round')#, uplims=True, lolims=True)
legend_list.append(line_axis)
if logy:
ax = plt.gca()
ax.set_yscale('log')
print(legend_list)
legend_list.append(Line2D([0], [0], color='k', linestyle='dashed', lw=1, label=dash_label))
legend_list.append(Line2D([0], [0], color='k', linestyle='solid', lw=1, label=solid_label))
#ax.legend(handles=legend_list, loc=1, ncol=2, prop={'size':8})
if time_in_s_table is not None and plot_xlabel:
plt.xlabel('inference time (s)')
elif plot_xlabel:
plt.xlabel('# of inference made (T)')
#plt.ylabel('MSE')
plt.xlim([1, plot_points])
if 'ball' in data_name:
data_name = 'D1: ' + data_name
elif 'sine' in data_name:
data_name = 'D2: ' + data_name
elif 'robo' in data_name:
data_name = 'D3: ' + data_name
elif 'meta' in data_name:
data_name = 'D4: ' + data_name
else: # This is not a standard dataset
plt.legend(prop={'size': 2})
plt.savefig(os.path.join(data_dir, data_name + save_name + name), transparent=True, dpi=300)
plt.close('all')
return
plt.grid(True, axis='both',which='major',color='b',alpha=0.2)
#plt.title(data_name.replace('_',' '), fontsize=20)
ax = plt.gca()
data_index = int(data_name.split(':')[0].split('D')[-1])
if data_index % 2 == 0: # If this is a even number
ax.yaxis.tick_right()
else:
ax.yaxis.tick_left()
if data_index < 3:
ax.xaxis.tick_top()
plt.xticks([1, 10, 20, 30, 40, 50])
plt.savefig(os.path.join(data_dir, data_name + save_name + name), transparent=True, dpi=300)
plt.close('all')
ax = plotDict(min_dict,'_minlog_quan2575.png', plot_points=plot_points, logy=True, avg_dict=avg_dict, err_dict=quan2575_dict, data_name=data_name,
dash_group=dash_group, dash_label=dash_label, solid_label=solid_label, resolution=resolution, worse_model_mode=worse_model_mode)
#plotDict(min_dict,'_min_quan2575.png', plot_points, resolution, logy=False, avg_dict=avg_dict, err_dict=quan2575_dict)
#plotDict(min_dict,'_minlog_std.png', plot_points, resolution, logy=True, avg_dict=avg_dict, err_dict=std_dict)
#plotDict(min_dict,'_min_std.png', plot_points, resolution, logy=False, avg_dict=avg_dict, err_dict=std_dict)
# if plot gifs
if not gif_flag:
return
else:
for i in range(2,20,1):
plotDict(min_dict, str(i), logy=True, plot_points=i)
for i in range(20,1000,20):
plotDict(min_dict, str(i), logy=True, plot_points=i)
return ax
def DrawEvaluationTime(data_dir, data_name, save_name='evaluation_time', logy=False, limit=1000):
"""
This function is to plot the evaluation time behavior of different algorithms on different data sets
:param data_dir: The mother directory where all the results are put
:param data_name: The specific dataset to analysis
:param save_name: The saving name of the plotted figure
:param logy: take logrithmic at axis y
:param limit: the limit of x max
:return:
"""
eval_time_dict = {}
for dirs in os.listdir(data_dir):
print("entering :", dirs)
print("this is a folder?:", os.path.isdir(os.path.join(data_dir, dirs)))
print("this is a file?:", os.path.isfile(os.path.join(data_dir, dirs)))
if not os.path.isdir(os.path.join(data_dir, dirs)):
print("skipping due to it is not a directory")
continue;
for subdirs in os.listdir((os.path.join(data_dir, dirs))):
if subdirs == data_name:
# Read the lists
eval_time = pd.read_csv(os.path.join(data_dir, dirs, subdirs, 'evaluation_time.txt'),
header=None, delimiter=',').values[:, 1]
# Put them into dictionary
eval_time_dict[dirs] = eval_time
# Plotting
f = plt.figure()
for key in sorted(eval_time_dict.keys()):
average_time = eval_time_dict[key][-1] / len(eval_time_dict[key])
plt.plot(np.arange(len(eval_time_dict[key])), eval_time_dict[key], label=key + 'average_time={0:.2f}s'.format(average_time))
plt.legend()
plt.xlabel('#inference trails')
plt.ylabel('inference time taken (s)')
plt.title(data_name + 'evaluation_time')
plt.xlim([0, limit])
if logy:
ax = plt.gca()
ax.set_yscale('log')
plt.savefig(os.path.join(data_dir, data_name + save_name + 'logy.png'))
else:
plt.savefig(os.path.join(data_dir, data_name + save_name + '.png'))
if __name__ == '__main__':
# NIPS version
#MeanAvgnMinMSEvsTry_all('/work/sr365/NA_compare/')
#datasets = ['ballistics']
#datasets = ['meta_material', 'robotic_arm','sine_wave','ballistics']
#lr_list = ['lr1','lr0.5','lr0.05']
#for lr in lr_list:
# MeanAvgnMinMSEvsTry_all('/work/sr365/NA_compare/'+lr)
# for dataset in datasets:
# DrawAggregateMeanAvgnMSEPlot('/work/sr365/NA_compare/'+lr, dataset)
#
#DrawAggregateMeanAvgnMSEPlot('/work/sr365/NA_compare/', 'ballistics')
# NIPS version
work_dir = '/home/sr365/mm_bench_multi_eval'
#lr_list = [10, 1, 0.1, 0.01, 0.001]
MeanAvgnMinMSEvsTry_all(work_dir)
#datasets = ['Yang_sim','Peurifoy']
#datasets = ['Yang_sim']
#for lr in lr_list:
for dataset in datasets:
#DrawAggregateMeanAvgnMSEPlot(work_dir, dataset, resolution=5)
DrawAggregateMeanAvgnMSEPlot(work_dir, dataset)
"""
# NIPS version on Groot
#work_dir = '/data/users/ben/robotic_stuck/retrain5/'
work_dir = '/data/users/ben/multi_eval/'
MeanAvgnMinMSEvsTry_all(work_dir)
datasets = ['ballistics','robotic_arm']
##datasets = ['meta_material', 'robotic_arm','sine_wave','ballistics']
for dataset in datasets:
DrawAggregateMeanAvgnMSEPlot(work_dir, dataset)
"""
# NIPS version for INN robo
#MeanAvgnMinMSEvsTry_all('/work/sr365/multi_eval/special/')
#datasets = ['robotic_arm']
#datasets = ['meta_material', 'robotic_arm','sine_wave','ballistics']
#for dataset in datasets:
# DrawAggregateMeanAvgnMSEPlot('/work/sr365/multi_eval/special', dataset)
#MeanAvgnMinMSEvsTry_all('/home/sr365/ICML_exp_cINN_ball/')
#DrawAggregateMeanAvgnMSEPlot('/home/sr365/ICML_exp_cINN_ball', dataset)
"""
# Modulized version (ICML)
#data_dir = '/data/users/ben/' # I am groot!
data_dir = '/home/sr365/' # quad
#data_dir = '/work/sr365/'
algo_list = ['cINN','INN','VAE','MDN','Random']
#algo_list = ''
for algo in algo_list:
MeanAvgnMinMSEvsTry_all(data_dir + 'ICML_exp/' + algo + '/')
#datasets = ['meta_material']
#datasets = ['robotic_arm','sine_wave','ballistics']
datasets = ['robotic_arm','sine_wave','ballistics','meta_material']
for dataset in datasets:
DrawAggregateMeanAvgnMSEPlot(data_dir+ 'ICML_exp/'+algo+'/', dataset)
"""
# Modulized version plots (ICML_0120)
#data_dir = '/data/users/ben/'
##data_dir = '/work/sr365/'
##algo_list = ['cINN','INN','VAE','MDN','Random']
#algo_list = ['Ball','rob','sine','MM']
#for algo in algo_list:
# #MeanAvgnMinMSEvsTry_all(data_dir + 'ICML_exp_0120/top_ones_' + algo + '/')
# #datasets = ['robotic_arm','ballistics']
# datasets = ['robotic_arm','sine_wave','ballistics','meta_material']
# for dataset in datasets:
# DrawAggregateMeanAvgnMSEPlot(data_dir+ 'ICML_exp_0120/top_ones_'+algo+'/', dataset)
## Draw the top ones
#datasets = ['robotic_arm','sine_wave','ballistics','meta_material']
#draw_dir = '/data/users/ben/best_plot/'
#for dataset in datasets:
# DrawAggregateMeanAvgnMSEPlot(draw_dir + dataset , dataset) | AEML | /models/Transformer/utils/plotsAnalysis.py | plotsAnalysis.py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.