transitions-0.7.2/0000755000076500000240000000000013606034310015014 5ustar alneumanstaff00000000000000transitions-0.7.2/.coveragerc0000644000076500000240000000006412647164525017155 0ustar alneumanstaff00000000000000[run] source = transitions include = */transitions/*transitions-0.7.2/.pylintrc0000644000076500000240000003464213277560102016701 0ustar alneumanstaff00000000000000[MASTER] # A comma-separated list of package or module names from where C extensions may # be loaded. Extensions are loading into the active Python interpreter and may # run arbitrary code extension-pkg-whitelist= # Add files or directories to the blacklist. They should be base names, not # paths. ignore=CVS # Add files or directories matching the regex patterns to the blacklist. The # regex matches against base names, not paths. ignore-patterns= # Python code to execute, usually for sys.path manipulation such as # pygtk.require(). #init-hook= # Use multiple processes to speed up Pylint. jobs=1 # List of plugins (as comma separated values of python modules names) to load, # usually to register additional checkers. load-plugins= # Pickle collected data for later comparisons. persistent=yes # Specify a configuration file. #rcfile= # Allow loading of arbitrary C extensions. Extensions are imported into the # active Python interpreter and may run arbitrary code. unsafe-load-any-extension=no [MESSAGES CONTROL] # Only show warnings with the listed confidence levels. Leave empty to show # all. Valid levels: HIGH, INFERENCE, INFERENCE_FAILURE, UNDEFINED confidence= # Disable the message, report, category or checker with the given id(s). You # can either give multiple identifiers separated by comma (,) or put this # option multiple times (only on the command line, not in the configuration # file where it should appear only once).You can also use "--disable=all" to # disable everything first and then reenable specific checks. For example, if # you want to run only the similarities checker, you can use "--disable=all # --enable=similarities". If you want to run only the classes checker, but have # no Warning level messages displayed, use"--disable=all --enable=classes # --disable=W" disable=print-statement,parameter-unpacking,unpacking-in-except,old-raise-syntax,backtick,long-suffix,old-ne-operator,old-octal-literal,import-star-module-level,raw-checker-failed,bad-inline-option,locally-disabled,locally-enabled,file-ignored,suppressed-message,useless-suppression,deprecated-pragma,apply-builtin,basestring-builtin,buffer-builtin,cmp-builtin,coerce-builtin,execfile-builtin,file-builtin,long-builtin,raw_input-builtin,reduce-builtin,standarderror-builtin,unicode-builtin,xrange-builtin,coerce-method,delslice-method,getslice-method,setslice-method,no-absolute-import,old-division,dict-iter-method,dict-view-method,next-method-called,metaclass-assignment,indexing-exception,raising-string,reload-builtin,oct-method,hex-method,nonzero-method,cmp-method,input-builtin,round-builtin,intern-builtin,unichr-builtin,map-builtin-not-iterating,zip-builtin-not-iterating,range-builtin-not-iterating,filter-builtin-not-iterating,using-cmp-argument,eq-without-hash,div-method,idiv-method,rdiv-method,exception-message-attribute,invalid-str-codec,sys-max-int,bad-python3-import,deprecated-string-function,deprecated-str-translate-call # Enable the message, report, category or checker with the given id(s). You can # either give multiple identifier separated by comma (,) or put this option # multiple time (only on the command line, not in the configuration file where # it should appear only once). See also the "--disable" option for examples. enable= [REPORTS] # Python expression which should return a note less than 10 (10 is the highest # note). You have access to the variables errors warning, statement which # respectively contain the number of errors / warnings messages and the total # number of statements analyzed. This is used by the global evaluation report # (RP0004). evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10) # Template used to display messages. This is a python new-style format string # used to format the message information. See doc for all details #msg-template= # Set the output format. Available formats are text, parseable, colorized, json # and msvs (visual studio).You can also give a reporter class, eg # mypackage.mymodule.MyReporterClass. output-format=text # Tells whether to display a full report or only the messages reports=no # Activate the evaluation score. score=yes [REFACTORING] # Maximum number of nested blocks for function / method body max-nested-blocks=5 [BASIC] # Naming hint for argument names argument-name-hint=(([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$ # Regular expression matching correct argument names argument-rgx=(([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$ # Naming hint for attribute names attr-name-hint=(([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$ # Regular expression matching correct attribute names attr-rgx=(([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$ # Bad variable names which should always be refused, separated by a comma bad-names=foo,bar,baz,toto,tutu,tata # Naming hint for class attribute names class-attribute-name-hint=([A-Za-z_][A-Za-z0-9_]{2,30}|(__.*__))$ # Regular expression matching correct class attribute names class-attribute-rgx=([A-Za-z_][A-Za-z0-9_]{2,30}|(__.*__))$ # Naming hint for class names class-name-hint=[A-Z_][a-zA-Z0-9]+$ # Regular expression matching correct class names class-rgx=[A-Z_][a-zA-Z0-9]+$ # Naming hint for constant names const-name-hint=(([A-Z_][A-Z0-9_]*)|(__.*__))$ # Regular expression matching correct constant names const-rgx=(([A-Z_][A-Z0-9_]*)|(__.*__))$ # Minimum line length for functions/classes that require docstrings, shorter # ones are exempt. docstring-min-length=-1 # Naming hint for function names function-name-hint=(([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$ # Regular expression matching correct function names function-rgx=(([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$ # Good variable names which should always be accepted, separated by a comma good-names=i,j,k,ex,Run,_ # Include a hint for the correct naming format with invalid-name include-naming-hint=no # Naming hint for inline iteration names inlinevar-name-hint=[A-Za-z_][A-Za-z0-9_]*$ # Regular expression matching correct inline iteration names inlinevar-rgx=[A-Za-z_][A-Za-z0-9_]*$ # Naming hint for method names method-name-hint=(([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$ # Regular expression matching correct method names method-rgx=(([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$ # Naming hint for module names module-name-hint=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$ # Regular expression matching correct module names module-rgx=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$ # Colon-delimited sets of names that determine each other's naming style when # the name regexes allow several styles. name-group= # Regular expression which should only match function or class names that do # not require a docstring. no-docstring-rgx=^_ # List of decorators that produce properties, such as abc.abstractproperty. Add # to this list to register other decorators that produce valid properties. property-classes=abc.abstractproperty # Naming hint for variable names variable-name-hint=(([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$ # Regular expression matching correct variable names variable-rgx=(([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$ [FORMAT] # Expected format of line ending, e.g. empty (any line ending), LF or CRLF. expected-line-ending-format= # Regexp for a line that is allowed to be longer than the limit. ignore-long-lines=^\s*(# )??$ # Number of spaces of indent required inside a hanging or continued line. indent-after-paren=4 # String used as indentation unit. This is usually " " (4 spaces) or "\t" (1 # tab). indent-string=' ' # Maximum number of characters on a single line. max-line-length=120 # Maximum number of lines in a module max-module-lines=1000 # List of optional constructs for which whitespace checking is disabled. `dict- # separator` is used to allow tabulation in dicts, etc.: {1 : 1,\n222: 2}. # `trailing-comma` allows a space between comma and closing bracket: (a, ). # `empty-line` allows space-only lines. no-space-check=trailing-comma,dict-separator # Allow the body of a class to be on the same line as the declaration if body # contains single statement. single-line-class-stmt=no # Allow the body of an if to be on the same line as the test if there is no # else. single-line-if-stmt=no [LOGGING] # Logging modules to check that the string format arguments are in logging # function parameter format logging-modules=logging [MISCELLANEOUS] # List of note tags to take in consideration, separated by a comma. notes=FIXME,XXX,TODO [SIMILARITIES] # Ignore comments when computing similarities. ignore-comments=yes # Ignore docstrings when computing similarities. ignore-docstrings=yes # Ignore imports when computing similarities. ignore-imports=no # Minimum lines number of a similarity. min-similarity-lines=4 [SPELLING] # Spelling dictionary name. Available dictionaries: none. To make it working # install python-enchant package. spelling-dict= # List of comma separated words that should not be checked. spelling-ignore-words= # A path to a file that contains private dictionary; one word per line. spelling-private-dict-file= # Tells whether to store unknown words to indicated private dictionary in # --spelling-private-dict-file option instead of raising a message. spelling-store-unknown-words=no [TYPECHECK] # List of decorators that produce context managers, such as # contextlib.contextmanager. Add to this list to register other decorators that # produce valid context managers. contextmanager-decorators=contextlib.contextmanager # List of members which are set dynamically and missed by pylint inference # system, and so shouldn't trigger E1101 when accessed. Python regular # expressions are accepted. generated-members= # Tells whether missing members accessed in mixin class should be ignored. A # mixin class is detected if its name ends with "mixin" (case insensitive). ignore-mixin-members=yes # This flag controls whether pylint should warn about no-member and similar # checks whenever an opaque object is returned when inferring. The inference # can return multiple potential results while evaluating a Python object, but # some branches might not be evaluated, which results in partial inference. In # that case, it might be useful to still emit no-member and other checks for # the rest of the inferred objects. ignore-on-opaque-inference=yes # List of class names for which member attributes should not be checked (useful # for classes with dynamically set attributes). This supports the use of # qualified names. ignored-classes=optparse.Values,thread._local,_thread._local # List of module names for which member attributes should not be checked # (useful for modules/projects where namespaces are manipulated during runtime # and thus existing member attributes cannot be deduced by static analysis. It # supports qualified module names, as well as Unix pattern matching. ignored-modules= # Show a hint with possible names when a member name was not found. The aspect # of finding the hint is based on edit distance. missing-member-hint=yes # The minimum edit distance a name should have in order to be considered a # similar match for a missing member name. missing-member-hint-distance=1 # The total number of similar names that should be taken in consideration when # showing a hint for a missing member. missing-member-max-choices=1 [VARIABLES] # List of additional names supposed to be defined in builtins. Remember that # you should avoid to define new builtins when possible. additional-builtins= # Tells whether unused global variables should be treated as a violation. allow-global-unused-variables=yes # List of strings which can identify a callback function by name. A callback # name must start or end with one of those strings. callbacks=cb_,_cb # A regular expression matching the name of dummy variables (i.e. expectedly # not used). dummy-variables-rgx=_+$|(_[a-zA-Z0-9_]*[a-zA-Z0-9]+?$)|dummy|^ignored_|^unused_ # Argument names that match this expression will be ignored. Default to name # with leading underscore ignored-argument-names=_.*|^ignored_|^unused_ # Tells whether we should check for unused import in __init__ files. init-import=no # List of qualified module names which can have objects that can redefine # builtins. redefining-builtins-modules=six.moves,future.builtins,builtins [CLASSES] # List of method names used to declare (i.e. assign) instance attributes. defining-attr-methods=__init__,__new__,setUp # List of member names, which should be excluded from the protected access # warning. exclude-protected=_asdict,_fields,_replace,_source,_make # List of valid names for the first argument in a class method. valid-classmethod-first-arg=cls # List of valid names for the first argument in a metaclass class method. valid-metaclass-classmethod-first-arg=mcs [DESIGN] # Maximum number of arguments for function / method max-args=5 # Maximum number of attributes for a class (see R0902). max-attributes=7 # Maximum number of boolean expressions in a if statement max-bool-expr=5 # Maximum number of branch for function / method body max-branches=12 # Maximum number of locals for function / method body max-locals=15 # Maximum number of parents for a class (see R0901). max-parents=7 # Maximum number of public methods for a class (see R0904). max-public-methods=20 # Maximum number of return / yield for function / method body max-returns=6 # Maximum number of statements in function / method body max-statements=50 # Minimum number of public methods for a class (see R0903). min-public-methods=2 [IMPORTS] # Allow wildcard imports from modules that define __all__. allow-wildcard-with-all=no # Analyse import fallback blocks. This can be used to support both Python 2 and # 3 compatible code, which means that the block might have code that exists # only in one or another interpreter, leading to false positives when analysed. analyse-fallback-blocks=no # Deprecated modules which should not be used, separated by a comma deprecated-modules=regsub,TERMIOS,Bastion,rexec # Create a graph of external dependencies in the given file (report RP0402 must # not be disabled) ext-import-graph= # Create a graph of every (i.e. internal and external) dependencies in the # given file (report RP0402 must not be disabled) import-graph= # Create a graph of internal dependencies in the given file (report RP0402 must # not be disabled) int-import-graph= # Force import order to recognize a module as part of the standard # compatibility libraries. known-standard-library= # Force import order to recognize a module as part of a third party library. known-third-party=enchant [EXCEPTIONS] # Exceptions that will emit a warning when being caught. Defaults to # "Exception" overgeneral-exceptions=Exception transitions-0.7.2/Changelog.md0000644000076500000240000003657113606026370017250 0ustar alneumanstaff00000000000000# Changelog ## 0.7.2 (January 2020) Release 0.7.2 is a minor release and contains bugfixes and and a new feature - Bugfix #386: Fix transitions for enums with str behavior (thanks @artofhuman) - Bugfix #378: Don't mask away KeyError when executing a transition (thanks @facundofc) - Feature #387: Add support for dynamic model state attribute (thanks @v1k45) ## 0.7.1 (September 2019) Release 0.7.1 is a minor release and contains several documentation improvements and a new feature: - Feature #334: Added Enum (Python 3.4+: `enum` Python 2.7: `enum34`) support (thanks @artofhuman and @justinttl) - Replaced test framework `nosetests` with `pytest` (thanks @artofhuman) - Extended `add_ordered_transitions` documentation in `Readme.md` - Collected code snippets from earlier discussions in `examples/Frequently asked questions.ipynb` - Improved stripping of `long_description` in `setup.py` (thanks @artofhuman) ## 0.7.0 (August 2019) Release 0.7.0 is a major release with fundamental changes to the diagram extension. It also introduces an intermediate `MarkupMachine` which can be used to transfer and (re-)initialize machine configurations. - Feature #263: `MarkupMachine` can be used to retrieve a Machine's dictionary representation - `GraphMachine` uses this representation for Graphs now and does not rely on `Machine` attributes any longer - Feature: The default value of `State.ignore_invalid_triggers` changed to `None`. If it is not explicitly set, the `Machine`'s value is used instead. - Feature #325: transitions now supports `pygraphviz` and `graphviz` for the creation of diagrams. Currently, `GraphMachine` will check for `pygraphviz` first and fall back to `graphviz`. To use `graphviz` directly pass `use_pygraphiv=False` to the constructor of `GraphMachine` - Diagram style has been overhauled. Have a look at `GraphMachine`'s attributes `machine_attributes` and `style_attributes` to adjust it to your needs. - Feature #305: Timeouts and other features are now marked in the graphs - Bugfix #343: `get_graph` was not assigned to models added during machine runtime ## 0.6.9 (October 2018) Release 0.6.9 is a minor release and contains two bugfixes: - Bugfix #314: Do not override already defined model functions with convenience functions (thanks @Arkanayan) - Bugfix #316: `state.Error` did not call parent's `enter` method (thanks @potens1) ## 0.6.8 (May, 2018) Release 0.6.8 is a minor release and contains a critical bugfix: - Bugfix #301: Reading `Readme.md` in `setup.py` causes a `UnicodeDecodeError` in non-UTF8-locale environments (thanks @jodal) ## 0.6.7 (May, 2018) Release 0.6.7 is identical to 0.6.6. A release had been necessary due to #294 related to PyPI. ## 0.6.6 (May, 2018) Release 0.6.6 is a minor release and contains several bugfixes and new features: - Bugfix: `HierarchicalMachine` now considers the initial state of `NestedState` instances/names passed to `initial`. - Bugfix: `HierarchicalMachine` used to ignore children when `NestedStates` were added to the machine. - Bugfix #300: Fixed missing brackets in `TimeoutState` (thanks @Synss) - Feature #289: Introduced `Machine.resolve_callable(func, event_data)` to enable customization of callback definitions (thanks @ollamh and @paulbovbel) - Feature #299: Added support for internal transitions with `dest=None` (thanks @maueki) - Feature: Added `Machine.dispatch` to trigger events on all models assigned to `Machine` ## 0.6.5 (April, 2018) Release 0.6.5 is a minor release and contains a new feature and a bugfix: - Feature #287: Embedding `HierarchicalMachine` will now reuse the machine's `initial` state. Passing `initial: False` overrides this (thanks @mrjogo). - Bugfix #292: Models using `GraphMashine` were not picklable in the past due to `graph` property. Graphs for each model are now stored in `GraphMachine.model_graphs` (thanks @ansumanm). ## 0.6.4 (January, 2018) Release 0.6.4 is a minor release and contains a new feature and two bug fixes related to `HierachicalMachine`: - Bugfix #274: `initial` has not been passed to super in `HierachicalMachine.add_model` (thanks to @illes). - Feature #275: `HierarchicalMachine.add_states` now supports keyword `parent` to be a `NestedState` or a string. - Bugfix #278: `NestedState` has not been exited correctly during reflexive triggering (thanks to @hrsmanian). ## 0.6.3 (November, 2017) Release 0.6.3 is a minor release and contains a new feature and two bug fixes: - Bugfix #268: `Machine.add_ordered_transitions` changed states' order if `initial` is not the first or last state (thanks to @janekbaraniewski). - Bugfix #265: Renamed `HierarchicalMachine.to` to `to_state` to prevent warnings when HSM is used as a model. - Feature #266: Introduce `Machine.get_transitions` to get a list of transitions for alteration (thanks to @Synss). ## 0.6.2 (November, 2017) Release 0.6.2 is a minor release and contains new features and bug fixes but also several internal changes: - Documentation: Add docstring to every public method - Bugfix #257: Readme example variable had been capitalized (thanks to @fedesismo) - Add `appveyor.yml` for Windows testing; However, Windows testing is disabled due to #258 - Bugfix #262: Timeout threads prevented program from execution when main thread ended (thanks to @tkuester) - `prep_ordered_arg` is now protected in `core` - Convert `logger` instances to `_LOGGER` to comply with protected module constant naming standards - `traverse` is now protected in `HierarchicalMachine` - Remove abstract class `Diagram` since it did not add functionality to `diagrams` - Specify several overrides of `add_state` or `add_transition` to keep the base class parameters instead of `*args` and `**kwargs` - Change several `if len(x) > 0:` checks to `if x:` as suggested by the static code analysis to make use of falsy empty lists/strings. ## 0.6.1 (September, 2017) Release 0.6.1 is a minor release and contains new features as well as bug fixes: - Feature #245: Callback definitions ('before', 'on_enter', ...) have been moved to classes `Transition` and `State` - Bugfix #253: `Machine.remove_transitions` converted `defaultdict` into dict (thanks @Synss) - Bugfix #248: `HierarchicalStateMachine`'s copy procedure used to cause issues with function callbacks and object references (thanks @Grey-Bit) - Renamed `Machine.id` to `Machine.name` to be consistent with the constructor parameter `name` - Add `Machine.add_transitions` for adding multiple transitions at once (thanks @Synss) ## 0.6.0 (August, 2017) Release 0.6.0 is a major release and introduces new state features and bug fixes: - `add_state_features` convenience decorator supports creation of custom states - `Tags` makes states taggable - `Error` checks for error states (not accepted states that cannot be left); subclass of `Tags` - `Volatile` enables scoped/temporary state objects to handle context parameters - Removed `add_self` from `Machine` constructor - `pygraphviz` is now optional; use `pip install transitions[diagrams]` to install it - Narrowed warnings filter to prevent output cluttering by other 3rd party modules (thanks to @ksandeep) - Reword HSM exception when wrong state object had been passedn (thanks to @Blindfreddy) - Improved handling of partials during graph generation (thanks to @Synss) - Introduced check to allow explicit passing of callback functions which match the `on_enter_` scheme (thanks to @termim) - Bug #243: on_enter/exit callbacks defined in dictionaries had not been assigned correctly in HSMs (thanks to @Blindfreddy) - Introduced workaround for Python 3 versions older than 3.4 to support dill version 0.2.7 and higher (thanks to @mmckerns) - Improved manifest (#242) to comply with distribution standards (thanks to @jodal) ## 0.5.3 (May, 2017) Release 0.5.3 is a minor release and contains several bug fixes: - Bug #214: `LockedMachine` as a model prevented correct addition of `on_enter/exit_` (thanks to @kr2) - Bug #217: Filtering rules for auto transitions in graphs falsely filtered certain transitions (thanks to @KarolOlko) - Bug #218: Uninitialized `EventData.transition` caused `AttributeError` in `EventData.__repr__` (thanks to @kunalbhagawati) - Bug #215: State instances passed to `initial` parameter of `Machine` constructor had not been processed properly (thanks @mathiasimmer) ## 0.5.2 (April, 2017) Release 0.5.2 is a minor release and contains a bug fix: - Bug #213: prevent `LICENSE` to be installed to root of installation path ## 0.5.1 (April, 2017) Release 0.5.1 is a minor release and contains new features and bug fixes: - Added reflexive transitions (thanks to @janLo) - Wildcards for reflexive (`wildcard_same`) and all (`wildcard_all`) destinations are `Machine` class variables now which can be altered if necessary. - Add LICENSE to packaged distribution (thanks to @bachp) - Bug #211: `prepare` and `finalized` had not been called for HierarchicalMachines (thanks to @booware) ## 0.5.0 (March, 2017) Release 0.5.0 is a major release: - CHANGED API: `MachineError` is now limited to internal error and has been replaced by `AttributeError` and `ValueError` where applicable (thanks to @ankostis) - CHANGED API: Phasing out `add_self`; `model=None` will add NO model starting from next major release; use `model='self'` instead. - Introduced deprecation warnings for upcoming changes concerning `Machine` keywords `model` and `add_self` - Introduced `Machine.remove_transition` (thanks to @PaleNeutron) - Introduced `Machine._create_state` for easier subclassing of states - `LockedMachine` now supports custom context managers for each model (thanks to @paulbovbel) - `Machine.before/after_state_change` can now be altered dynamically (thanks to @peendebak) - `Machine.add_ordered_transitions` now supports `prepare`, `conditons`, `unless`, `before` and `after` (thanks to @aforren1) - New `prepare_event` and `finalize_event` keywords to handle transitions globally (thanks to @ankostis) - New `show_auto_transitions` keyword for `GraphMachine.__init__` (default `False`); if enabled, show auto transitions in graph - New `show_roi` keyword for `GraphMachine._get_graph` (default `False`); if `True`, show only reachable states in retrieved graph - Test suite now skips contextual tests (e.g. pygraphviz) if dependencies cannot be found (thanks to @ankostis) - Improved string representation of several classes (thanks to @ankostis) - Improved `LockedMachine` performance by removing recursive locking - Improved graph layout for nested graphs - `transitions.extensions.nesting.AGraph` has been split up into `Graph` and `NestedGraph` for easier maintenance - Fixed bug related to pickling `RLock` in nesting - Fixed order of callback execution (thanks to @ankostis) - Fixed representation of condition names in graphs (thanks to @cemoody) ## 0.4.3 (December, 2016) Release 0.4.3 is a minor release and contains bug fixes and several new features: - Support dynamic model addition via `Machine.add_model` (thanks to @paulbovbel) - Allow user to explicitly pass a lock instance or context manager to LockedMachine (thanks to @paulbovbel) - Fixed issue related to parsing of HSMs (thanks to @steval and @user2154065 from SO) - When `State` is passed to `Machine.add_transition`, it will check if the state (and not just the name) is known to the machine ## 0.4.2 (October, 2016) Release 0.4.2 contains several new features and bugfixes: - Machines can work with multiple models now (thanks to @gemerden) - New `initial` keyword for nested states to automatically enter a child - New `Machine.trigger` method to trigger events by name (thanks to @IwanLD) - Bug fixes related to remapping in nested (thanks to @imbaczek) - Log messages in `Transition.execute` and `Machine.__init__` have been reassigned to DEBUG log level (thanks to @ankostis) - New `Machine.get_triggers` method to return all valid transitions from (a) certain state(s) (thanks to @limdauto and @guilhermecgs) ## 0.4.1 (July, 2016) Release 0.4.1 is a minor release containing bug fixes, minor API changes, and community feedback: - `async` is renamed to `queued` since it describes the mechanism better - HierarchicalStateMachine.is_state now provides `allow_substates` as an optional argument(thanks to @jonathanunderwood) - Machine can now be used in scenarios where multiple inheritance is required (thanks to @jonathanunderwood) - Adds support for tox (thanks to @medecau and @aisbaa) - Bug fixes: - Problems with conditions shown multiple times in graphs - Bug which omitted transitions with same source and destination in diagrams (thanks to @aisbaa) - Conditions passed incorrectly when HSMs are used as a nested state - Class nesting issue that prevented pickling with dill - Two bugs in HierarchicalStateMachine (thanks to @ajax2leet) - Avoided recursion error when naming a transition 'process' (thanks to @dceresuela) - Minor PEP8 fixes (thanks to @medecau) ## 0.4.0 (April, 2016) Release 0.4 is a major release that includes several new features: - New `async` Machine keyword allows queueing of transitions (thanks to @khigia) - New `name` Machine keyword customizes transitions logger output for easier debugging of multiple running instances - New `prepare` Transition keyword for callbacks before any 'conditions' are checked (thanks to @TheMysteriousX) - New `show_conditions` GraphSupport keyword adds condition checks to dot graph edges (thanks to @khigia) - Nesting now supports custom (unicode) substate separators - Nesting no longer requires a leaf state (e.g. to_C() does not enter C_1 automatically) - Factory for convenient extension mixins - Numerous minor improvements and bug fixes ## 0.3.1 (January 3, 2016) Mostly a bug fix release. Changes include: - Fixes graphing bug introduced in 0.3.0 (thanks to @wtgee) - Fixes bug in dynamic addition of before/after callbacks (though this is a currently undocumented feature) - Adds coveralls support and badge - Adds a few tests to achieve near-100% coverage ## 0.3.0 (January 2, 2016) Release 0.3 includes a number of new features (nesting, multithreading, and graphing) as well as bug fixes and minor improvements: - Support for nested states (thanks to @aleneum) - Basic multithreading support for function access (thanks to @aleneum) - Basic graphing support via graphviz (thanks to @svdgraaf) - Stylistic edits, minor fixes, and improvements to README - Expanded and refactored tests - Minor bug fixes ## 0.2.9 (November 10, 2015) - Enabled pickling in Python 3.4 (and in < 3.4 with the dill module) - Added reference to generating Transition in EventData objects - Fixed minor bugs ## 0.2.8 (August, 6, 2015) - README improvements, added TOC, and typo fixes - Condition checks now receive optional data - Removed invasive basicConfig() call introduced with logging in 0.2.6 ## 0.2.7 (July 27, 2015) - Fixed import bug that prevented dependency installation at setup ## 0.2.6 (July 26, 2015) - Added rudimentary logging for key transition and state change events - Added generic before/after callbacks that apply to all state changes - Ensured string type compatibility across Python 2 and 3 ## 0.2.5 (May 4, 2015) - Added ability to suppress invalid trigger calls - Shorthand definition of transitions via lists ## 0.2.4 (March 11, 2015) - Automatic detection of predefined state callbacks - Fixed bug in automatic transition creation - Added Changelog ## 0.2.3 (January 14, 2015) - Added travis-ci support - Cleaned up and PEP8fied code - Added 'unless' argument to transitions that mirrors 'conditions' ## 0.2.2 (December 28, 2014) - Python 2/3 compatibility - Added automatic to_{state}() methods - Added ability to easily add ordered transitions transitions-0.7.2/LICENSE0000644000076500000240000000211213530722244016023 0ustar alneumanstaff00000000000000The MIT License Copyright (c) 2014 - 2019 Tal Yarkoni, Alexander Neumann 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. transitions-0.7.2/MANIFEST.in0000644000076500000240000000035113537642734016573 0ustar alneumanstaff00000000000000include *.md include *.txt include .coveragerc include .pylintrc include LICENSE include MANIFEST include tox.ini recursive-include examples *.ipynb recursive-include tests *.py recursive-exclude examples/.ipynb_checkpoints *.ipynb transitions-0.7.2/PKG-INFO0000644000076500000240000020754713606034310016130 0ustar alneumanstaff00000000000000Metadata-Version: 2.1 Name: transitions Version: 0.7.2 Summary: A lightweight, object-oriented Python state machine implementation. Home-page: http://github.com/pytransitions/transitions Author: Tal Yarkoni Author-email: tyarkoni@gmail.com Maintainer: Alexander Neumann Maintainer-email: aleneum@gmail.com License: MIT Download-URL: https://github.com/pytransitions/transitions/archive/0.7.2.tar.gz Description: ## Quickstart They say [a good example is worth](https://www.google.com/webhp?ie=UTF-8#q=%22a+good+example+is+worth%22&start=20) 100 pages of API documentation, a million directives, or a thousand words. Well, "they" probably lie... but here's an example anyway: ```python from transitions import Machine import random class NarcolepticSuperhero(object): # Define some states. Most of the time, narcoleptic superheroes are just like # everyone else. Except for... states = ['asleep', 'hanging out', 'hungry', 'sweaty', 'saving the world'] def __init__(self, name): # No anonymous superheroes on my watch! Every narcoleptic superhero gets # a name. Any name at all. SleepyMan. SlumberGirl. You get the idea. self.name = name # What have we accomplished today? self.kittens_rescued = 0 # Initialize the state machine self.machine = Machine(model=self, states=NarcolepticSuperhero.states, initial='asleep') # Add some transitions. We could also define these using a static list of # dictionaries, as we did with states above, and then pass the list to # the Machine initializer as the transitions= argument. # At some point, every superhero must rise and shine. self.machine.add_transition(trigger='wake_up', source='asleep', dest='hanging out') # Superheroes need to keep in shape. self.machine.add_transition('work_out', 'hanging out', 'hungry') # Those calories won't replenish themselves! self.machine.add_transition('eat', 'hungry', 'hanging out') # Superheroes are always on call. ALWAYS. But they're not always # dressed in work-appropriate clothing. self.machine.add_transition('distress_call', '*', 'saving the world', before='change_into_super_secret_costume') # When they get off work, they're all sweaty and disgusting. But before # they do anything else, they have to meticulously log their latest # escapades. Because the legal department says so. self.machine.add_transition('complete_mission', 'saving the world', 'sweaty', after='update_journal') # Sweat is a disorder that can be remedied with water. # Unless you've had a particularly long day, in which case... bed time! self.machine.add_transition('clean_up', 'sweaty', 'asleep', conditions=['is_exhausted']) self.machine.add_transition('clean_up', 'sweaty', 'hanging out') # Our NarcolepticSuperhero can fall asleep at pretty much any time. self.machine.add_transition('nap', '*', 'asleep') def update_journal(self): """ Dear Diary, today I saved Mr. Whiskers. Again. """ self.kittens_rescued += 1 def is_exhausted(self): """ Basically a coin toss. """ return random.random() < 0.5 def change_into_super_secret_costume(self): print("Beauty, eh?") ``` There, now you've baked a state machine into `NarcolepticSuperhero`. Let's take him/her/it out for a spin... ```python >>> batman = NarcolepticSuperhero("Batman") >>> batman.state 'asleep' >>> batman.wake_up() >>> batman.state 'hanging out' >>> batman.nap() >>> batman.state 'asleep' >>> batman.clean_up() MachineError: "Can't trigger event clean_up from state asleep!" >>> batman.wake_up() >>> batman.work_out() >>> batman.state 'hungry' # Batman still hasn't done anything useful... >>> batman.kittens_rescued 0 # We now take you live to the scene of a horrific kitten entreement... >>> batman.distress_call() 'Beauty, eh?' >>> batman.state 'saving the world' # Back to the crib. >>> batman.complete_mission() >>> batman.state 'sweaty' >>> batman.clean_up() >>> batman.state 'asleep' # Too tired to shower! # Another productive day, Alfred. >>> batman.kittens_rescued 1 ``` ## The non-quickstart ### Basic initialization Getting a state machine up and running is pretty simple. Let's say you have the object `lump` (an instance of class `Matter`), and you want to manage its states: ```python class Matter(object): pass lump = Matter() ``` You can initialize a (_minimal_) working state machine bound to `lump` like this: ```python from transitions import Machine machine = Machine(model=lump, states=['solid', 'liquid', 'gas', 'plasma'], initial='solid') # Lump now has state! lump.state >>> 'solid' ``` I say “minimal”, because while this state machine is technically operational, it doesn't actually _do_ anything. It starts in the `'solid'` state, but won't ever move into another state, because no transitions are defined... yet! Let's try again. ```python # The states states=['solid', 'liquid', 'gas', 'plasma'] # And some transitions between states. We're lazy, so we'll leave out # the inverse phase transitions (freezing, condensation, etc.). transitions = [ { 'trigger': 'melt', 'source': 'solid', 'dest': 'liquid' }, { 'trigger': 'evaporate', 'source': 'liquid', 'dest': 'gas' }, { 'trigger': 'sublimate', 'source': 'solid', 'dest': 'gas' }, { 'trigger': 'ionize', 'source': 'gas', 'dest': 'plasma' } ] # Initialize machine = Machine(lump, states=states, transitions=transitions, initial='liquid') # Now lump maintains state... lump.state >>> 'liquid' # And that state can change... lump.evaporate() lump.state >>> 'gas' lump.trigger('ionize') lump.state >>> 'plasma' ``` Notice the shiny new methods attached to the `Matter` instance (`evaporate()`, `ionize()`, etc.). Each method triggers the corresponding transition. You don't have to explicitly define these methods anywhere; the name of each transition is bound to the model passed to the `Machine` initializer (in this case, `lump`). Additionally, there is a method called `trigger` now attached to your model. This method lets you execute transitions by name in case dynamic triggering is required. ### States The soul of any good state machine (and of many bad ones, no doubt) is a set of states. Above, we defined the valid model states by passing a list of strings to the `Machine` initializer. But internally, states are actually represented as `State` objects. You can initialize and modify States in a number of ways. Specifically, you can: - pass a string to the `Machine` initializer giving the name(s) of the state(s), or - directly initialize each new `State` object, or - pass a dictionary with initialization arguments The following snippets illustrate several ways to achieve the same goal: ```python # Create a list of 3 states to pass to the Machine # initializer. We can mix types; in this case, we # pass one State, one string, and one dict. states = [ State(name='solid'), 'liquid', { 'name': 'gas'} ] machine = Machine(lump, states) # This alternative example illustrates more explicit # addition of states and state callbacks, but the net # result is identical to the above. machine = Machine(lump) solid = State('solid') liquid = State('liquid') gas = State('gas') machine.add_states([solid, liquid, gas]) ``` States are initialized *once* when added to the machine and will persist until they are removed from it. In other words: if you alter the attributes of a state object, this change will NOT be reset the next time you enter that state. Have a look at how to [extend state features](#state-features) in case you require some other behaviour. #### Callbacks A `State` can also be associated with a list of `enter` and `exit` callbacks, which are called whenever the state machine enters or leaves that state. You can specify callbacks during initialization, or add them later. For convenience, whenever a new `State` is added to a `Machine`, the methods `on_enter_«state name»` and `on_exit_«state name»` are dynamically created on the Machine (not on the model!), which allow you to dynamically add new enter and exit callbacks later if you need them. ```python # Our old Matter class, now with a couple of new methods we # can trigger when entering or exit states. class Matter(object): def say_hello(self): print("hello, new state!") def say_goodbye(self): print("goodbye, old state!") lump = Matter() # Same states as above, but now we give StateA an exit callback states = [ State(name='solid', on_exit=['say_goodbye']), 'liquid', { 'name': 'gas' } ] machine = Machine(lump, states=states) machine.add_transition('sublimate', 'solid', 'gas') # Callbacks can also be added after initialization using # the dynamically added on_enter_ and on_exit_ methods. # Note that the initial call to add the callback is made # on the Machine and not on the model. machine.on_enter_gas('say_hello') # Test out the callbacks... machine.set_state('solid') lump.sublimate() >>> 'goodbye, old state!' >>> 'hello, new state!' ``` Note that `on_enter_«state name»` callback will *not* fire when a Machine is first initialized. For example if you have an `on_enter_A()` callback defined, and initialize the `Machine` with `initial='A'`, `on_enter_A()` will not be fired until the next time you enter state `A`. (If you need to make sure `on_enter_A()` fires at initialization, you can simply create a dummy initial state and then explicitly call `to_A()` inside the `__init__` method.) In addition to passing in callbacks when initializing a `State`, or adding them dynamically, it's also possible to define callbacks in the model class itself, which may increase code clarity. For example: ```python class Matter(object): def say_hello(self): print("hello, new state!") def say_goodbye(self): print("goodbye, old state!") def on_enter_A(self): print("We've just entered state A!") lump = Matter() machine = Machine(lump, states=['A', 'B', 'C']) ``` Now, any time `lump` transitions to state `A`, the `on_enter_A()` method defined in the `Matter` class will fire. #### Checking state You can always check the current state of the model by either: - inspecting the `.state` attribute, or - calling `is_«state name»()` And if you want to retrieve the actual `State` object for the current state, you can do that through the `Machine` instance's `get_state()` method. ```python lump.state >>> 'solid' lump.is_gas() >>> False lump.is_solid() >>> True machine.get_state(lump.state).name >>> 'solid' ``` If you'd like you track it using a different attribute, you could do that using the `model_attribute` argument while initializing the `Machine`. ```python lump = Matter() machine = Machine(lump, states=['solid', 'liquid', 'gas'], model='matter_state', initial='solid') lump.matter_state >>> 'solid' ``` #### Enumerations So far we have seen how we can give state names and use these names to work with our state machine. If you favour stricter typing and more IDE code completion (or you just can't type 'sesquipedalophobia' any longer because the word scares you) using [Enumerations](https://docs.python.org/3/library/enum.html) might be what you are looking for: ```python import enum # Python 2.7 users need to have 'enum34' installed from transitions import Machine class States(enum.Enum): ERROR = 0 RED = 1 YELLOW = 2 GREEN = 3 transitions = [['proceed', States.RED, States.YELLOW], ['proceed', States.YELLOW, States.GREEN], ['error', '*', States.ERROR]] m = Machine(states=States, transitions=transitions, initial=States.RED) assert m.is_RED() assert m.state is States.RED state = m.get_state(States.RED) # get transitions.State object print(state.name) # >>> RED m.proceed() m.proceed() assert m.is_GREEN() m.error() assert m.state is States.ERROR ``` You can mix enums and strings if you like (e.g. `[States.RED, 'ORANGE', States.YELLOW, States.GREEN]`) but note that internally, `transitions` will still handle states by name (`enum.Enum.name`). Thus, it is not possible to have the states `'GREEN'` and `States.GREEN` at the same time. ### Transitions Some of the above examples already illustrate the use of transitions in passing, but here we'll explore them in more detail. As with states, each transition is represented internally as its own object – an instance of class `Transition`. The quickest way to initialize a set of transitions is to pass a dictionary, or list of dictionaries, to the `Machine` initializer. We already saw this above: ```python transitions = [ { 'trigger': 'melt', 'source': 'solid', 'dest': 'liquid' }, { 'trigger': 'evaporate', 'source': 'liquid', 'dest': 'gas' }, { 'trigger': 'sublimate', 'source': 'solid', 'dest': 'gas' }, { 'trigger': 'ionize', 'source': 'gas', 'dest': 'plasma' } ] machine = Machine(model=Matter(), states=states, transitions=transitions) ``` Defining transitions in dictionaries has the benefit of clarity, but can be cumbersome. If you're after brevity, you might choose to define transitions using lists. Just make sure that the elements in each list are in the same order as the positional arguments in the `Transition` initialization (i.e., `trigger`, `source`, `destination`, etc.). The following list-of-lists is functionally equivalent to the list-of-dictionaries above: ```python transitions = [ ['melt', 'solid', 'liquid'], ['evaporate', 'liquid', 'gas'], ['sublimate', 'solid', 'gas'], ['ionize', 'gas', 'plasma'] ] ``` Alternatively, you can add transitions to a `Machine` after initialization: ```python machine = Machine(model=lump, states=states, initial='solid') machine.add_transition('melt', source='solid', dest='liquid') ``` The `trigger` argument defines the name of the new triggering method that gets attached to the base model. When this method is called, it will try to execute the transition: ```python >>> lump.melt() >>> lump.state 'liquid' ``` By default, calling an invalid trigger will raise an exception: ```python >>> lump.to_gas() >>> # This won't work because only objects in a solid state can melt >>> lump.melt() transitions.core.MachineError: "Can't trigger event melt from state gas!" ``` This behavior is generally desirable, since it helps alert you to problems in your code. But in some cases, you might want to silently ignore invalid triggers. You can do this by setting `ignore_invalid_triggers=True` (either on a state-by-state basis, or globally for all states): ```python >>> # Globally suppress invalid trigger exceptions >>> m = Machine(lump, states, initial='solid', ignore_invalid_triggers=True) >>> # ...or suppress for only one group of states >>> states = ['new_state1', 'new_state2'] >>> m.add_states(states, ignore_invalid_triggers=True) >>> # ...or even just for a single state. Here, exceptions will only be suppressed when the current state is A. >>> states = [State('A', ignore_invalid_triggers=True), 'B', 'C'] >>> m = Machine(lump, states) >>> # ...this can be inverted as well if just one state should raise an exception >>> # since the machine's global value is not applied to a previously initialized state. >>> states = ['A', 'B', State('C')] # the default value for 'ignore_invalid_triggers' is False >>> m = Machine(lump, states, ignore_invalid_triggers=True) ``` If you need to know which transitions are valid from a certain state, you can use `get_triggers`: ``` m.get_triggers('solid') >>> ['melt', 'sublimate'] m.get_triggers('liquid') >>> ['evaporate'] m.get_triggers('plasma') >>> [] # you can also query several states at once m.get_triggers('solid', 'liquid', 'gas', 'plasma') >>> ['melt', 'evaporate', 'sublimate', 'ionize'] ``` #### Automatic transitions for all states In addition to any transitions added explicitly, a `to_«state»()` method is created automatically whenever a state is added to a `Machine` instance. This method transitions to the target state no matter which state the machine is currently in: ```python lump.to_liquid() lump.state >>> 'liquid' lump.to_solid() lump.state >>> 'solid' ``` If you desire, you can disable this behavior by setting `auto_transitions=False` in the `Machine` initializer. #### Transitioning from multiple states A given trigger can be attached to multiple transitions, some of which can potentially begin or end in the same state. For example: ```python machine.add_transition('transmogrify', ['solid', 'liquid', 'gas'], 'plasma') machine.add_transition('transmogrify', 'plasma', 'solid') # This next transition will never execute machine.add_transition('transmogrify', 'plasma', 'gas') ``` In this case, calling `transmogrify()` will set the model's state to `'solid'` if it's currently `'plasma'`, and set it to `'plasma'` otherwise. (Note that only the _first_ matching transition will execute; thus, the transition defined in the last line above won't do anything.) You can also make a trigger cause a transition from _all_ states to a particular destination by using the `'*'` wildcard: ```python machine.add_transition('to_liquid', '*', 'liquid') ``` Note that wildcard transitions will only apply to states that exist at the time of the add_transition() call. Calling a wildcard-based transition when the model is in a state added after the transition was defined will elicit an invalid transition message, and will not transition to the target state. #### Reflexive transitions from multiple states A reflexive trigger (trigger that has the same state as source and destination) can easily be added specifying `=` as destination. This is handy if the same reflexive trigger should be added to multiple states. For example: ```python machine.add_transition('touch', ['liquid', 'gas', 'plasma'], '=', after='change_shape') ``` This will add reflexive transitions for all three states with `touch()` as trigger and with `change_shape` executed after each trigger. #### Internal transitions In contrast to reflexive transitions, internal transitions will never actually leave the state. This means that transition-related callbacks such as `before` or `after` will be processed while state-related callbacks `exit` or `enter` will not. To define a transition to be internal, set the destination to `None`. ```python machine.add_transition('internal', ['liquid', 'gas'], None, after='change_shape') ``` #### Ordered transitions A common desire is for state transitions to follow a strict linear sequence. For instance, given states `['A', 'B', 'C']`, you might want valid transitions for `A` → `B`, `B` → `C`, and `C` → `A` (but no other pairs). To facilitate this behavior, Transitions provides an `add_ordered_transitions()` method in the `Machine` class: ```python states = ['A', 'B', 'C'] # See the "alternative initialization" section for an explanation of the 1st argument to init machine = Machine(states=states, initial='A') machine.add_ordered_transitions() machine.next_state() print(machine.state) >>> 'B' # We can also define a different order of transitions machine = Machine(states=states, initial='A') machine.add_ordered_transitions(['A', 'C', 'B']) machine.next_state() print(machine.state) >>> 'C' # Conditions can be passed to 'add_ordered_transitions' as well # If one condition is passed, it will be used for all transitions machine = Machine(states=states, initial='A') machine.add_ordered_transitions(conditions='check') # If a list is passed, it must contain exactly as many elements as the # machine contains states (A->B, ..., X->A) machine = Machine(states=states, initial='A') machine.add_ordered_transitions(conditions=['check_A2B', ..., 'check_X2A']) ``` #### Queued transitions The default behaviour in Transitions is to process events instantly. This means events within an `on_enter` method will be processed _before_ callbacks bound to `after` are called. ```python def go_to_C(): global machine machine.to_C() def after_advance(): print("I am in state B now!") def entering_C(): print("I am in state C now!") states = ['A', 'B', 'C'] machine = Machine(states=states, initial='A') # we want a message when state transition to B has been completed machine.add_transition('advance', 'A', 'B', after=after_advance) # call transition from state B to state C machine.on_enter_B(go_to_C) # we also want a message when entering state C machine.on_enter_C(entering_C) machine.advance() >>> 'I am in state C now!' >>> 'I am in state B now!' # what? ``` The execution order of this example is ``` prepare -> before -> on_enter_B -> on_enter_C -> after. ``` If queued processing is enabled, a transition will be finished before the next transition is triggered: ```python machine = Machine(states=states, queued=True, initial='A') ... machine.advance() >>> 'I am in state B now!' >>> 'I am in state C now!' # That's better! ``` This results in ``` prepare -> before -> on_enter_B -> queue(to_C) -> after -> on_enter_C. ``` **Important note:** when processing events in a queue, the trigger call will _always_ return `True`, since there is no way to determine at queuing time whether a transition involving queued calls will ultimately complete successfully. This is true even when only a single event is processed. ```python machine.add_transition('jump', 'A', 'C', conditions='will_fail') ... # queued=False machine.jump() >>> False # queued=True machine.jump() >>> True ``` #### Conditional transitions Sometimes you only want a particular transition to execute if a specific condition occurs. You can do this by passing a method, or list of methods, in the `conditions` argument: ```python # Our Matter class, now with a bunch of methods that return booleans. class Matter(object): def is_flammable(self): return False def is_really_hot(self): return True machine.add_transition('heat', 'solid', 'gas', conditions='is_flammable') machine.add_transition('heat', 'solid', 'liquid', conditions=['is_really_hot']) ``` In the above example, calling `heat()` when the model is in state `'solid'` will transition to state `'gas'` if `is_flammable` returns `True`. Otherwise, it will transition to state `'liquid'` if `is_really_hot` returns `True`. For convenience, there's also an `'unless'` argument that behaves exactly like conditions, but inverted: ```python machine.add_transition('heat', 'solid', 'gas', unless=['is_flammable', 'is_really_hot']) ``` In this case, the model would transition from solid to gas whenever `heat()` fires, provided that both `is_flammable()` and `is_really_hot()` return `False`. Note that condition-checking methods will passively receive optional arguments and/or data objects passed to triggering methods. For instance, the following call: ```python lump.heat(temp=74) # equivalent to lump.trigger('heat', temp=74) ``` ... would pass the `temp=74` optional kwarg to the `is_flammable()` check (possibly wrapped in an `EventData` instance). For more on this, see the [Passing data](#passing-data) section below. #### Callbacks You can attach callbacks to transitions as well as states. Every transition has `'before'` and `'after'` attributes that contain a list of methods to call before and after the transition executes: ```python class Matter(object): def make_hissing_noises(self): print("HISSSSSSSSSSSSSSSS") def disappear(self): print("where'd all the liquid go?") transitions = [ { 'trigger': 'melt', 'source': 'solid', 'dest': 'liquid', 'before': 'make_hissing_noises'}, { 'trigger': 'evaporate', 'source': 'liquid', 'dest': 'gas', 'after': 'disappear' } ] lump = Matter() machine = Machine(lump, states, transitions=transitions, initial='solid') lump.melt() >>> "HISSSSSSSSSSSSSSSS" lump.evaporate() >>> "where'd all the liquid go?" ``` There is also a `'prepare'` callback that is executed as soon as a transition starts, before any `'conditions'` are checked or other callbacks are executed. ```python class Matter(object): heat = False attempts = 0 def count_attempts(self): self.attempts += 1 def is_really_hot(self): return self.heat def heat_up(self): self.heat = random.random() < 0.25 def stats(self): print('It took you %i attempts to melt the lump!' %self.attempts) states=['solid', 'liquid', 'gas', 'plasma'] transitions = [ { 'trigger': 'melt', 'source': 'solid', 'dest': 'liquid', 'prepare': ['heat_up', 'count_attempts'], 'conditions': 'is_really_hot', 'after': 'stats'}, ] lump = Matter() machine = Machine(lump, states, transitions=transitions, initial='solid') lump.melt() lump.melt() lump.melt() lump.melt() >>> "It took you 4 attempts to melt the lump!" ``` Note that `prepare` will not be called unless the current state is a valid source for the named transition. Default actions meant to be executed before or after *every* transition can be passed to `Machine` during initialization with `before_state_change` and `after_state_change` respectively: ```python class Matter(object): def make_hissing_noises(self): print("HISSSSSSSSSSSSSSSS") def disappear(self): print("where'd all the liquid go?") states=['solid', 'liquid', 'gas', 'plasma'] lump = Matter() m = Machine(lump, states, before_state_change='make_hissing_noises', after_state_change='disappear') lump.to_gas() >>> "HISSSSSSSSSSSSSSSS" >>> "where'd all the liquid go?" ``` There are also two keywords for callbacks which should be executed *independently* a) of how many transitions are possible, b) if any transition succeeds and c) even if an error is raised during the execution of some other callback. Callbacks passed to `Machine` with `prepare_event` will be executed *once* before processing possible transitions (and their individual `prepare` callbacks) takes place. Callbacks of `finalize_event` will be executed regardless of the success of the processed transitions. Note that if an error occurred it will be attached to `event_data` as `error` and can be retrieved with `send_event=True`. ```python from transitions import Machine class Matter(object): def raise_error(self, event): raise ValueError("Oh no") def prepare(self, event): print("I am ready!") def finalize(self, event): print("Result: ", type(event.error), event.error) states=['solid', 'liquid', 'gas', 'plasma'] lump = Matter() m = Machine(lump, states, prepare_event='prepare', before_state_change='raise_error', finalize_event='finalize', send_event=True) try: lump.to_gas() except ValueError: pass print(lump.state) >>> I am ready! >>> Result: Oh no >>> initial ``` ### Callback resolution and execution order As you have probably already realized, the standard way of passing callbacks to states and transitions is by name. When processing callbacks, `transitions` will use the name to retrieve the related callback from the model. If the method cannot be retrieved and it contains dots, Transitions will treat the name as a path to a module function and try to import it. Alternatively, you can pass callables such as (bound) functions directly. As mentioned earlier, you can also pass lists/tuples of callbacks to the callback parameters. Callbacks will be executed in the order they were added. ```python from transitions import Machine from mod import imported_func class Model(object): def a_callback(self): imported_func() model = Model() machine = Machine(model=model, states=['A'], initial='A') machine.add_transition('by_name', 'A', 'A', after='a_callback') machine.add_transition('by_reference', 'A', 'A', after=model.a_callback) machine.add_transition('imported', 'A', 'A', after='mod.imported_func') model.by_name() model.by_reference() model.imported() ``` The callback resolution is done in `Machine.resolve_callbacks`. This method can be overridden in case more complex callback resolution strategies are required. In summary, callbacks on transitions are executed in the following order: | Callback | Current State | Comments | |--------------------------------|:-------------:|-------------------------------------------------------------| | `'machine.prepare_event'` | `source` | executed *once* before individual transitions are processed | | `'transition.prepare'` | `source` | executed as soon as the transition starts | | `'transition.conditions'` | `source` | conditions *may* fail and halt the transition | | `'transition.unless'` | `source` | conditions *may* fail and halt the transition | | `'machine.before_state_change'`| `source` | default callbacks declared on model | | `'transition.before'` | `source` | | | `'state.on_exit'` | `source` | callbacks declared on the source state | | `` | | | | `'state.on_enter'` | `destination` | callbacks declared on the destination state | | `'transition.after'` | `destination` | | | `'machine.after_state_change'` | `destination` | default callbacks declared on model | | `'machine.finalize_event'` | `source/destination` | callbacks will be executed even if no transition took place or an exception has been raised | If any callback raises an exception, the processing of callbacks is not continued. This means that when an error occurs before the transition (in `state.on_exit` or earlier), it is halted. In case there is a raise after the transition has been conducted (in `state.on_enter` or later), the state change persists and no rollback is happening. Callbacks specified in `machine.finalize_event` will always be executed unless the exception is raised by a finalizing callback itself. ### Passing data Sometimes you need to pass the callback functions registered at machine initialization some data that reflects the model's current state. Transitions allows you to do this in two different ways. First (the default), you can pass any positional or keyword arguments directly to the trigger methods (created when you call `add_transition()`): ```python class Matter(object): def __init__(self): self.set_environment() def set_environment(self, temp=0, pressure=101.325): self.temp = temp self.pressure = pressure def print_temperature(self): print("Current temperature is %d degrees celsius." % self.temp) def print_pressure(self): print("Current pressure is %.2f kPa." % self.pressure) lump = Matter() machine = Machine(lump, ['solid', 'liquid'], initial='solid') machine.add_transition('melt', 'solid', 'liquid', before='set_environment') lump.melt(45) # positional arg; # equivalent to lump.trigger('melt', 45) lump.print_temperature() >>> 'Current temperature is 45 degrees celsius.' machine.set_state('solid') # reset state so we can melt again lump.melt(pressure=300.23) # keyword args also work lump.print_pressure() >>> 'Current pressure is 300.23 kPa.' ``` You can pass any number of arguments you like to the trigger. There is one important limitation to this approach: every callback function triggered by the state transition must be able to handle _all_ of the arguments. This may cause problems if the callbacks each expect somewhat different data. To get around this, Transitions supports an alternate method for sending data. If you set `send_event=True` at `Machine` initialization, all arguments to the triggers will be wrapped in an `EventData` instance and passed on to every callback. (The `EventData` object also maintains internal references to the source state, model, transition, machine, and trigger associated with the event, in case you need to access these for anything.) ```python class Matter(object): def __init__(self): self.temp = 0 self.pressure = 101.325 # Note that the sole argument is now the EventData instance. # This object stores positional arguments passed to the trigger method in the # .args property, and stores keywords arguments in the .kwargs dictionary. def set_environment(self, event): self.temp = event.kwargs.get('temp', 0) self.pressure = event.kwargs.get('pressure', 101.325) def print_pressure(self): print("Current pressure is %.2f kPa." % self.pressure) lump = Matter() machine = Machine(lump, ['solid', 'liquid'], send_event=True, initial='solid') machine.add_transition('melt', 'solid', 'liquid', before='set_environment') lump.melt(temp=45, pressure=1853.68) # keyword args lump.print_pressure() >>> 'Current pressure is 1853.68 kPa.' ``` ### Alternative initialization patterns In all of the examples so far, we've attached a new `Machine` instance to a separate model (`lump`, an instance of class `Matter`). While this separation keeps things tidy (because you don't have to monkey patch a whole bunch of new methods into the `Matter` class), it can also get annoying, since it requires you to keep track of which methods are called on the state machine, and which ones are called on the model that the state machine is bound to (e.g., `lump.on_enter_StateA()` vs. `machine.add_transition()`). Fortunately, Transitions is flexible, and supports two other initialization patterns. First, you can create a standalone state machine that doesn't require another model at all. Simply omit the model argument during initialization: ```python machine = Machine(states=states, transitions=transitions, initial='solid') machine.melt() machine.state >>> 'liquid' ``` If you initialize the machine this way, you can then attach all triggering events (like `evaporate()`, `sublimate()`, etc.) and all callback functions directly to the `Machine` instance. This approach has the benefit of consolidating all of the state machine functionality in one place, but can feel a little bit unnatural if you think state logic should be contained within the model itself rather than in a separate controller. An alternative (potentially better) approach is to have the model inherit from the `Machine` class. Transitions is designed to support inheritance seamlessly. (just be sure to override class `Machine`'s `__init__` method!): ```python class Matter(Machine): def say_hello(self): print("hello, new state!") def say_goodbye(self): print("goodbye, old state!") def __init__(self): states = ['solid', 'liquid', 'gas'] Machine.__init__(self, states=states, initial='solid') self.add_transition('melt', 'solid', 'liquid') lump = Matter() lump.state >>> 'solid' lump.melt() lump.state >>> 'liquid' ``` Here you get to consolidate all state machine functionality into your existing model, which often feels more natural way than sticking all of the functionality we want in a separate standalone `Machine` instance. A machine can handle multiple models which can be passed as a list like `Machine(model=[model1, model2, ...])`. In cases where you want to add models *as well as* the machine instance itself, you can pass the string placeholder `'self'` during initialization like `Machine(model=['self', model1, ...])`. You can also create a standalone machine, and register models dynamically via `machine.add_model`. Remember to call `machine.remove_model` if machine is long-lasting and your models are temporary and should be garbage collected: ```python class Matter(): pass lump1 = Matter() lump2 = Matter() machine = Machine(states=states, transitions=transitions, initial='solid', add_self=False) machine.add_model(lump1) machine.add_model(lump2, initial='liquid') lump1.state >>> 'solid' lump2.state >>> 'liquid' machine.remove_model([lump1, lump2]) del lump1 # lump1 is garbage collected del lump2 # lump2 is garbage collected ``` If you don't provide an initial state in the state machine constructor, you must provide one every time you add a model: ```python machine = Machine(states=states, transitions=transitions, add_self=False) machine.add_model(Matter()) >>> "MachineError: No initial state configured for machine, must specify when adding model." machine.add_model(Matter(), initial='liquid') ``` Models with multiple states could attach multiple machines using different `model_attribute` values: ```python lump = Matter() lump.state >>> 'solid' lump.shipping_state >>> 'delivered' matter_machine = Machine(lump, model_attribute='state', **kwargs) shipment_machine = Machine(lump, model_attribute='shipping_state', **kwargs) ``` ### Logging Transitions includes very rudimentary logging capabilities. A number of events – namely, state changes, transition triggers, and conditional checks – are logged as INFO-level events using the standard Python `logging` module. This means you can easily configure logging to standard output in a script: ```python # Set up logging; The basic log level will be DEBUG import logging logging.basicConfig(level=logging.DEBUG) # Set transitions' log level to INFO; DEBUG messages will be omitted logging.getLogger('transitions').setLevel(logging.INFO) # Business as usual machine = Machine(states=states, transitions=transitions, initial='solid') ... ``` ### (Re-)Storing machine instances Machines are picklable and can be stored and loaded with `pickle`. For Python 3.3 and earlier `dill` is required. ```python import dill as pickle # only required for Python 3.3 and earlier m = Machine(states=['A', 'B', 'C'], initial='A') m.to_B() m.state >>> B # store the machine dump = pickle.dumps(m) # load the Machine instance again m2 = pickle.loads(dump) m2.state >>> B m2.states.keys() >>> ['A', 'B', 'C'] ``` ### Extensions Even though the core of transitions is kept lightweight, there are a variety of MixIns to extend its functionality. Currently supported are: - **Diagrams** to visualize the current state of a machine - **Hierarchical State Machines** for nesting and reuse - **Threadsafe Locks** for parallel execution - **Custom States** for extended state-related behaviour There are two mechanisms to retrieve a state machine instance with the desired features enabled. The first approach makes use of the convenience `factory` with the three parameters `graph`, `nested` and `locked` set to `True` if the certain feature is required: ```python from transitions.extensions import MachineFactory # create a machine with mixins diagram_cls = MachineFactory.get_predefined(graph=True) nested_locked_cls = MachineFactory.get_predefined(nested=True, locked=True) # create instances from these classes # instances can be used like simple machines machine1 = diagram_cls(model, state, transitions...) machine2 = nested_locked_cls(model, state, transitions) ``` This approach targets experimental use since in this case the underlying classes do not have to be known. However, classes can also be directly imported from `transitions.extensions`. The naming scheme is as follows: | | Diagrams | Nested | Locked | | -----------------------------: | :------: | :----: | :----: | | Machine | ✘ | ✘ | ✘ | | GraphMachine | ✓ | ✘ | ✘ | | HierarchicalMachine | ✘ | ✓ | ✘ | | LockedMachine | ✘ | ✘ | ✓ | | HierarchicalGraphMachine | ✓ | ✓ | ✘ | | LockedGraphMachine | ✓ | ✘ | ✓ | | LockedHierarchicalMachine | ✘ | ✓ | ✓ | | LockedHierarchicalGraphMachine | ✓ | ✓ | ✓ | To use a full featured state machine, one could write: ```python from transitions.extensions import LockedHierarchicalGraphMachine as Machine #enable ALL the features! machine = Machine(model, states, transitions) ``` #### Diagrams Additional Keywords: * `title` (optional): Sets the title of the generated image. * `show_conditions` (default False): Shows conditions at transition edges * `show_auto_transitions` (default False): Shows auto transitions in graph * `show_state_attributes` (default False): Show callbacks (enter, exit), tags and timeouts in graph Transitions can generate basic state diagrams displaying all valid transitions between states. To use the graphing functionality, you'll need to have `graphviz` and/or `pygraphviz` installed: To generate graphs with the package `graphviz`, you need to install [Graphviz](https://graphviz.org/) manually or via a package manager. sudo apt-get install graphviz # Ubuntu and Debian brew install graphviz # MacOS conda install graphviz python-graphviz # (Ana)conda Now you can install the actual Python packages pip install graphviz pygraphviz # install graphviz and/or pygraphviz manually... pip install transitions[diagrams] # ... or install transitions with 'diagrams' extras which currently depends on pygraphviz Currently, `GraphMachine` will use `pygraphviz` when available and fall back to `graphviz` when `pygraphviz` cannot be found. This can be overridden by passing `use_pygraphviz=False` to the constructor. Note that this default might change in the future and `pygraphviz` support may be dropped. With `Model.get_graph()` you can get the current graph or the region of interest (roi) and draw it like this: ```python # import transitions from transitions.extensions import GraphMachine as Machine m = Model() # without further arguments pygraphviz will be used machine = Machine(model=m, ...) # when you want to use graphviz explicitely machine = Machine(model=m, use_pygraphviz=False, ...) # in cases where auto transitions should be visible machine = Machine(model=m, show_auto_transitions=True, ...) # draw the whole graph ... m.get_graph().draw('my_state_diagram.png', prog='dot') # ... or just the region of interest # (previous state, active state and all reachable states) roi = m.get_graph(show_roi=True).draw('my_state_diagram.png', prog='dot') ``` This produces something like this: ![state diagram example](https://user-images.githubusercontent.com/205986/47524268-725c1280-d89a-11e8-812b-1d3b6e667b91.png) Also, have a look at our [example](./examples) IPython/Jupyter notebooks for a more detailed example. ### Hierarchical State Machine (HSM) Transitions includes an extension module which allows to nest states. This allows to create contexts and to model cases where states are related to certain subtasks in the state machine. To create a nested state, either import `NestedState` from transitions or use a dictionary with the initialization arguments `name` and `children`. Optionally, `initial` can be used to define a sub state to transit to, when the nested state is entered. ```python from transitions.extensions import HierarchicalMachine as Machine states = ['standing', 'walking', {'name': 'caffeinated', 'children':['dithering', 'running']}] transitions = [ ['walk', 'standing', 'walking'], ['stop', 'walking', 'standing'], ['drink', '*', 'caffeinated'], ['walk', ['caffeinated', 'caffeinated_dithering'], 'caffeinated_running'], ['relax', 'caffeinated', 'standing'] ] machine = Machine(states=states, transitions=transitions, initial='standing', ignore_invalid_triggers=True) machine.walk() # Walking now machine.stop() # let's stop for a moment machine.drink() # coffee time machine.state >>> 'caffeinated' machine.walk() # we have to go faster machine.state >>> 'caffeinated_running' machine.stop() # can't stop moving! machine.state >>> 'caffeinated_running' machine.relax() # leave nested state machine.state # phew, what a ride >>> 'standing' # machine.on_enter_caffeinated_running('callback_method') ``` A configuration making use of `initial` could look like this: ```python # ... states = ['standing', 'walking', {'name': 'caffeinated', 'initial': 'dithering', 'children': ['dithering', 'running']}] transitions = [ ['walk', 'standing', 'walking'], ['stop', 'walking', 'standing'], # this transition will end in 'caffeinated_dithering'... ['drink', '*', 'caffeinated'], # ... that is why we do not need do specify 'caffeinated' here anymore ['walk', 'caffeinated_dithering', 'caffeinated_running'], ['relax', 'caffeinated', 'standing'] ] # ... ``` Some things that have to be considered when working with nested states: State *names are concatenated* with `NestedState.separator`. Currently the separator is set to underscore ('_') and therefore behaves similar to the basic machine. This means a substate `bar` from state `foo` will be known by `foo_bar`. A substate `baz` of `bar` will be referred to as `foo_bar_baz` and so on. When entering a substate, `enter` will be called for all parent states. The same is true for exiting substates. Third, nested states can overwrite transition behaviour of their parents. If a transition is not known to the current state it will be delegated to its parent. In some cases underscore as a separator is not sufficient. For instance if state names consists of more than one word and a concatenated naming such as `state_A_name_state_C` would be confusing. Setting the separator to something else than underscore changes some of the behaviour (auto_transition and setting callbacks). You can even use unicode characters if you use python 3: ```python from transitions.extensions.nesting import NestedState NestedState.separator = '↦' states = ['A', 'B', {'name': 'C', 'children':['1', '2', {'name': '3', 'children': ['a', 'b', 'c']} ]} ] transitions = [ ['reset', 'C', 'A'], ['reset', 'C↦2', 'C'] # overwriting parent reset ] # we rely on auto transitions machine = Machine(states=states, transitions=transitions, initial='A') machine.to_B() # exit state A, enter state B machine.to_C() # exit B, enter C machine.to_C.s3.a() # enter C↦a; enter C↦3↦a; machine.state, >>> 'C↦3↦a' machine.to('C↦2') # not interactive; exit C↦3↦a, exit C↦3, enter C↦2 machine.reset() # exit C↦2; reset C has been overwritten by C↦3 machine.state >>> 'C' machine.reset() # exit C, enter A machine.state >>> 'A' # s.on_enter('C↦3↦a', 'callback_method') ``` Instead of `to_C_3_a()` auto transition is called as `to_C.s3.a()`. If your substate starts with a digit, transitions adds a prefix 's' ('3' becomes 's3') to the auto transition `FunctionWrapper` to comply with the attribute naming scheme of python. If interactive completion is not required, `to('C↦3↦a')` can be called directly. Additionally, `on_enter/exit_<>` is replaced with `on_enter/exit(state_name, callback)`. To check whether the current state is a substate of a specific state `is_state` supports the keyword `allow_substates`: ```python machine.state >>> 'C.2.a' machine.is_C() # checks for specific states >>> False machine.is_C(allow_substates=True) >>> True ``` You can use enumerations in HSMs as well but `enum` support is currently limited to the root level as model state enums lack hierarchical information. An attempt of nesting an `Enum` will raise an `AttributeError` in `NestedState`. ```python # will work states = [States.RED, States.YELLOW, {'name': States.GREEN, 'children': ['tick', 'tock']}] # will raise an AttributeError states = ['A', {'name': 'B', 'children': States}] ``` #### Reuse of previously created HSMs Besides semantic order, nested states are very handy if you want to specify state machines for specific tasks and plan to reuse them. Be aware that this will *embed* the passed machine's states. This means if your states had been altered *before*, this change will be persistent. ```python count_states = ['1', '2', '3', 'done'] count_trans = [ ['increase', '1', '2'], ['increase', '2', '3'], ['decrease', '3', '2'], ['decrease', '2', '1'], ['done', '3', 'done'], ['reset', '*', '1'] ] counter = Machine(states=count_states, transitions=count_trans, initial='1') counter.increase() # love my counter states = ['waiting', 'collecting', {'name': 'counting', 'children': counter}] transitions = [ ['collect', '*', 'collecting'], ['wait', '*', 'waiting'], ['count', 'collecting', 'counting'] ] collector = Machine(states=states, transitions=transitions, initial='waiting') collector.collect() # collecting collector.count() # let's see what we got; counting_1 collector.increase() # counting_2 collector.increase() # counting_3 collector.done() # collector.state == counting_done collector.wait() # collector.state == waiting ``` If a `HierarchicalStateMachine` is passed with the `children` keyword, the initial state of this machine will be assigned to the new parent state. In the above example we see that entering `counting` will also enter `counting_1`. If this is undesired behaviour and the machine should rather halt in the parent state, the user can pass `initial` as `False` like `{'name': 'counting', 'children': counter, 'initial': False}`. Sometimes you want such an embedded state collection to 'return' which means after it is done it should exit and transit to one of your states. To achieve this behaviour you can remap state transitions. In the example above we would like the counter to return if the state `done` was reached. This is done as follows: ```python states = ['waiting', 'collecting', {'name': 'counting', 'children': counter, 'remap': {'done': 'waiting'}}] ... # same as above collector.increase() # counting_3 collector.done() collector.state >>> 'waiting' # be aware that 'counting_done' will be removed from the state machine ``` If a reused state machine does not have a final state, you can of course add the transitions manually. If 'counter' had no 'done' state, we could just add `['done', 'counter_3', 'waiting']` to achieve the same behaviour. Note that the `HierarchicalMachine` will not integrate the machine instance itself but the states and transitions by creating copies of them. This way you are able to continue using your previously created instance without interfering with the embedded version. #### Threadsafe(-ish) State Machine In cases where event dispatching is done in threads, one can use either `LockedMachine` or `LockedHierarchicalMachine` where **function access** (!sic) is secured with reentrant locks. This does not save you from corrupting your machine by tinkering with member variables of your model or state machine. ```python from transitions.extensions import LockedMachine as Machine from threading import Thread import time states = ['A', 'B', 'C'] machine = Machine(states=states, initial='A') # let us assume that entering B will take some time thread = Thread(target=machine.to_B) thread.start() time.sleep(0.01) # thread requires some time to start machine.to_C() # synchronized access; won't execute before thread is done # accessing attributes directly thread = Thread(target=machine.to_B) thread.start() machine.new_attrib = 42 # not synchronized! will mess with execution order ``` Any python context manager can be passed in via the `machine_context` keyword argument: ```python from transitions.extensions import LockedMachine as Machine from threading import RLock states = ['A', 'B', 'C'] lock1 = RLock() lock2 = RLock() machine = Machine(states=states, initial='A', machine_context=[lock1, lock2]) ``` Any contexts via `machine_model` will be shared between all models registered with the `Machine`. Per-model contexts can be added as well: ``` lock3 = RLock() machine.add_model(model, model_context=lock3) ``` It's important that all user-provided context managers are re-entrant since the state machine will call them multiple times, even in the context of a single trigger invocation. #### Adding features to states If your superheroes need some custom behaviour, you can throw in some extra functionality by decorating machine states: ```python from time import sleep from transitions import Machine from transitions.extensions.states import add_state_features, Tags, Timeout @add_state_features(Tags, Timeout) class CustomStateMachine(Machine): pass class SocialSuperhero(object): def __init__(self): self.entourage = 0 def on_enter_waiting(self): self.entourage += 1 states = [{'name': 'preparing', 'tags': ['home', 'busy']}, {'name': 'waiting', 'timeout': 1, 'on_timeout': 'go'}, {'name': 'away'}] # The city needs us! transitions = [['done', 'preparing', 'waiting'], ['join', 'waiting', 'waiting'], # Entering Waiting again will increase our entourage ['go', 'waiting', 'away']] # Okay, let' move hero = SocialSuperhero() machine = CustomStateMachine(model=hero, states=states, transitions=transitions, initial='preparing') assert hero.state == 'preparing' # Preparing for the night shift assert machine.get_state(hero.state).is_busy # We are at home and busy hero.done() assert hero.state == 'waiting' # Waiting for fellow superheroes to join us assert hero.entourage == 1 # It's just us so far sleep(0.7) # Waiting... hero.join() # Weeh, we got company sleep(0.5) # Waiting... hero.join() # Even more company \o/ sleep(2) # Waiting... assert hero.state == 'away' # Impatient superhero already left the building assert machine.get_state(hero.state).is_home is False # Yupp, not at home anymore assert hero.entourage == 3 # At least he is not alone ``` Currently, transitions comes equipped with the following state features: * **Timeout** -- triggers an event after some time has passed - keyword: `timeout` (int, optional) -- if passed, an entered state will timeout after `timeout` seconds - keyword: `on_timeout` (string/callable, optional) -- will be called when timeout time has been reached - will raise an `AttributeError` when `timeout` is set but `on_timeout` is not - Note: A timeout is triggered in a thread. This implies several limitations (e.g. catching Exceptions raised in timeouts). Consider an event queue for more sophisticated applications. * **Tags** -- adds tags to states - keyword: `tags` (list, optional) -- assigns tags to a state - `State.is_` will return `True` when the state has been tagged with `tag_name`, else `False` * **Error** -- raises a `MachineError` when a state cannot be left - inherits from `Tags` (if you use `Error` do not use `Tags`) - keyword: `accepted` (bool, optional) -- marks a state as accepted - alternatively the keyword `tags` can be passed, containing 'accepted' - Note: Errors will only be raised if `auto_transitions` has been set to `False`. Otherwise every state can be exited with `to_` methods. * **Volatile** -- initialises an object every time a state is entered - keyword: `volatile` (class, optional) -- every time the state is entered an object of type class will be assigned to the model. The attribute name is defined by `hook`. If omitted, an empty VolatileObject will be created instead - keyword: `hook` (string, default='scope') -- The model's attribute name fore the temporal object. You can write your own `State` extensions and add them the same way. Just note that `add_state_features` expects *Mixins*. This means your extension should always call the overridden methods `__init__`, `enter` and `exit`. Your extension may inherit from *State* but will also work without it. In case you prefer to write your own custom states from scratch be aware that some state extensions *require* certain state features. `HierarchicalStateMachine` requires your custom state to be an instance of `NestedState` (`State` is not sufficient). To inject your states you can either assign them to your `Machine`'s class attribute `state_cls` or override `Machine.create_state` in case you need some specific procedures done whenever a state is created: ```python from transitions import Machine, State class MyState(State): pass class CustomMachine(Machine): # Use MyState as state class state_cls = MyState class VerboseMachine(Machine): # `Machine._create_state` is a class method but we can # override it to be an instance method def _create_state(self, *args, **kwargs): print("Creating a new state with machine '{0}'".format(self.name)) return MyState(*args, **kwargs) ``` #### Using transitions together with Django Christian Ledermann developed `django-transitions`, a module dedicated to streamline the work with `transitions` and Django. The source code is also hosted on [Github](https://github.com/PrimarySite/django-transitions). Have a look at [the documentation](https://django-transitions.readthedocs.io/en/latest/) for usage examples. ### I have a [bug report/issue/question]... For bug reports and other issues, please open an issue on GitHub. For usage questions, post on Stack Overflow, making sure to tag your question with the `transitions` and `python` tags. Do not forget to have a look at the [extended examples](./examples)! For any other questions, solicitations, or large unrestricted monetary gifts, email [Tal Yarkoni](mailto:tyarkoni@gmail.com). Platform: UNKNOWN Classifier: License :: OSI Approved :: MIT License Classifier: Programming Language :: Python :: 2 Classifier: Programming Language :: Python :: 2.7 Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.3 Classifier: Programming Language :: Python :: 3.4 Classifier: Programming Language :: Python :: 3.5 Classifier: Programming Language :: Python :: 3.6 Classifier: Programming Language :: Python :: 3.7 Description-Content-Type: text/markdown Provides-Extra: diagrams Provides-Extra: test transitions-0.7.2/README.md0000644000076500000240000016565013606032567016324 0ustar alneumanstaff00000000000000# transitions [![Version](https://img.shields.io/badge/version-v0.7.2-orange.svg)](https://github.com/pytransitions/transitions) [![Build Status](https://travis-ci.org/pytransitions/transitions.svg?branch=master)](https://travis-ci.org/pytransitions/transitions) [![Coverage Status](https://coveralls.io/repos/pytransitions/transitions/badge.svg?branch=master&service=github)](https://coveralls.io/github/pytransitions/transitions?branch=master) [![Pylint](https://img.shields.io/badge/pylint-9.71%2F10-green.svg)](https://github.com/pytransitions/transitions) [![PyPi](https://img.shields.io/pypi/v/transitions.svg)](https://pypi.org/project/transitions) [![GitHub commits](https://img.shields.io/github/commits-since/pytransitions/transitions/0.7.1.svg)](https://github.com/pytransitions/transitions/compare/0.7.1...master) [![License](https://img.shields.io/github/license/pytransitions/transitions.svg)](LICENSE) A lightweight, object-oriented state machine implementation in Python. Compatible with Python 2.7+ and 3.0+. ## Installation pip install transitions ... or clone the repo from GitHub and then: python setup.py install ## Table of Contents - [Quickstart](#quickstart) - [Non-Quickstart](#the-non-quickstart) - [Basic initialization](#basic-initialization) - [States](#states) - [Callbacks](#state-callbacks) - [Checking state](#checking-state) - [Enumerations](#enum-state) - [Transitions](#transitions) - [Automatic transitions](#automatic-transitions-for-all-states) - [Transitioning from multiple states](#transitioning-from-multiple-states) - [Reflexive transitions from multiple states](#reflexive-from-multiple-states) - [Internal transitions](#internal-transitions) - [Ordered transitions](#ordered-transitions) - [Queued transitions](#queued-transitions) - [Conditional transitions](#conditional-transitions) - [Callbacks](#transition-callbacks) - [Callback resolution and execution order](#execution-order) - [Passing data](#passing-data) - [Alternative initialization patterns](#alternative-initialization-patterns) - [Logging](#logging) - [(Re-)Storing machine instances](#restoring) - [Extensions](#extensions) - [Diagrams](#diagrams) - [Hierarchical State Machine](#hsm) - [Threading](#threading) - [State features](#state-features) - [Django](#django-support) - [Bug reports etc.](#bug-reports) ## Quickstart They say [a good example is worth](https://www.google.com/webhp?ie=UTF-8#q=%22a+good+example+is+worth%22&start=20) 100 pages of API documentation, a million directives, or a thousand words. Well, "they" probably lie... but here's an example anyway: ```python from transitions import Machine import random class NarcolepticSuperhero(object): # Define some states. Most of the time, narcoleptic superheroes are just like # everyone else. Except for... states = ['asleep', 'hanging out', 'hungry', 'sweaty', 'saving the world'] def __init__(self, name): # No anonymous superheroes on my watch! Every narcoleptic superhero gets # a name. Any name at all. SleepyMan. SlumberGirl. You get the idea. self.name = name # What have we accomplished today? self.kittens_rescued = 0 # Initialize the state machine self.machine = Machine(model=self, states=NarcolepticSuperhero.states, initial='asleep') # Add some transitions. We could also define these using a static list of # dictionaries, as we did with states above, and then pass the list to # the Machine initializer as the transitions= argument. # At some point, every superhero must rise and shine. self.machine.add_transition(trigger='wake_up', source='asleep', dest='hanging out') # Superheroes need to keep in shape. self.machine.add_transition('work_out', 'hanging out', 'hungry') # Those calories won't replenish themselves! self.machine.add_transition('eat', 'hungry', 'hanging out') # Superheroes are always on call. ALWAYS. But they're not always # dressed in work-appropriate clothing. self.machine.add_transition('distress_call', '*', 'saving the world', before='change_into_super_secret_costume') # When they get off work, they're all sweaty and disgusting. But before # they do anything else, they have to meticulously log their latest # escapades. Because the legal department says so. self.machine.add_transition('complete_mission', 'saving the world', 'sweaty', after='update_journal') # Sweat is a disorder that can be remedied with water. # Unless you've had a particularly long day, in which case... bed time! self.machine.add_transition('clean_up', 'sweaty', 'asleep', conditions=['is_exhausted']) self.machine.add_transition('clean_up', 'sweaty', 'hanging out') # Our NarcolepticSuperhero can fall asleep at pretty much any time. self.machine.add_transition('nap', '*', 'asleep') def update_journal(self): """ Dear Diary, today I saved Mr. Whiskers. Again. """ self.kittens_rescued += 1 def is_exhausted(self): """ Basically a coin toss. """ return random.random() < 0.5 def change_into_super_secret_costume(self): print("Beauty, eh?") ``` There, now you've baked a state machine into `NarcolepticSuperhero`. Let's take him/her/it out for a spin... ```python >>> batman = NarcolepticSuperhero("Batman") >>> batman.state 'asleep' >>> batman.wake_up() >>> batman.state 'hanging out' >>> batman.nap() >>> batman.state 'asleep' >>> batman.clean_up() MachineError: "Can't trigger event clean_up from state asleep!" >>> batman.wake_up() >>> batman.work_out() >>> batman.state 'hungry' # Batman still hasn't done anything useful... >>> batman.kittens_rescued 0 # We now take you live to the scene of a horrific kitten entreement... >>> batman.distress_call() 'Beauty, eh?' >>> batman.state 'saving the world' # Back to the crib. >>> batman.complete_mission() >>> batman.state 'sweaty' >>> batman.clean_up() >>> batman.state 'asleep' # Too tired to shower! # Another productive day, Alfred. >>> batman.kittens_rescued 1 ``` ## The non-quickstart ### Basic initialization Getting a state machine up and running is pretty simple. Let's say you have the object `lump` (an instance of class `Matter`), and you want to manage its states: ```python class Matter(object): pass lump = Matter() ``` You can initialize a (_minimal_) working state machine bound to `lump` like this: ```python from transitions import Machine machine = Machine(model=lump, states=['solid', 'liquid', 'gas', 'plasma'], initial='solid') # Lump now has state! lump.state >>> 'solid' ``` I say “minimal”, because while this state machine is technically operational, it doesn't actually _do_ anything. It starts in the `'solid'` state, but won't ever move into another state, because no transitions are defined... yet! Let's try again. ```python # The states states=['solid', 'liquid', 'gas', 'plasma'] # And some transitions between states. We're lazy, so we'll leave out # the inverse phase transitions (freezing, condensation, etc.). transitions = [ { 'trigger': 'melt', 'source': 'solid', 'dest': 'liquid' }, { 'trigger': 'evaporate', 'source': 'liquid', 'dest': 'gas' }, { 'trigger': 'sublimate', 'source': 'solid', 'dest': 'gas' }, { 'trigger': 'ionize', 'source': 'gas', 'dest': 'plasma' } ] # Initialize machine = Machine(lump, states=states, transitions=transitions, initial='liquid') # Now lump maintains state... lump.state >>> 'liquid' # And that state can change... lump.evaporate() lump.state >>> 'gas' lump.trigger('ionize') lump.state >>> 'plasma' ``` Notice the shiny new methods attached to the `Matter` instance (`evaporate()`, `ionize()`, etc.). Each method triggers the corresponding transition. You don't have to explicitly define these methods anywhere; the name of each transition is bound to the model passed to the `Machine` initializer (in this case, `lump`). Additionally, there is a method called `trigger` now attached to your model. This method lets you execute transitions by name in case dynamic triggering is required. ### States The soul of any good state machine (and of many bad ones, no doubt) is a set of states. Above, we defined the valid model states by passing a list of strings to the `Machine` initializer. But internally, states are actually represented as `State` objects. You can initialize and modify States in a number of ways. Specifically, you can: - pass a string to the `Machine` initializer giving the name(s) of the state(s), or - directly initialize each new `State` object, or - pass a dictionary with initialization arguments The following snippets illustrate several ways to achieve the same goal: ```python # Create a list of 3 states to pass to the Machine # initializer. We can mix types; in this case, we # pass one State, one string, and one dict. states = [ State(name='solid'), 'liquid', { 'name': 'gas'} ] machine = Machine(lump, states) # This alternative example illustrates more explicit # addition of states and state callbacks, but the net # result is identical to the above. machine = Machine(lump) solid = State('solid') liquid = State('liquid') gas = State('gas') machine.add_states([solid, liquid, gas]) ``` States are initialized *once* when added to the machine and will persist until they are removed from it. In other words: if you alter the attributes of a state object, this change will NOT be reset the next time you enter that state. Have a look at how to [extend state features](#state-features) in case you require some other behaviour. #### Callbacks A `State` can also be associated with a list of `enter` and `exit` callbacks, which are called whenever the state machine enters or leaves that state. You can specify callbacks during initialization, or add them later. For convenience, whenever a new `State` is added to a `Machine`, the methods `on_enter_«state name»` and `on_exit_«state name»` are dynamically created on the Machine (not on the model!), which allow you to dynamically add new enter and exit callbacks later if you need them. ```python # Our old Matter class, now with a couple of new methods we # can trigger when entering or exit states. class Matter(object): def say_hello(self): print("hello, new state!") def say_goodbye(self): print("goodbye, old state!") lump = Matter() # Same states as above, but now we give StateA an exit callback states = [ State(name='solid', on_exit=['say_goodbye']), 'liquid', { 'name': 'gas' } ] machine = Machine(lump, states=states) machine.add_transition('sublimate', 'solid', 'gas') # Callbacks can also be added after initialization using # the dynamically added on_enter_ and on_exit_ methods. # Note that the initial call to add the callback is made # on the Machine and not on the model. machine.on_enter_gas('say_hello') # Test out the callbacks... machine.set_state('solid') lump.sublimate() >>> 'goodbye, old state!' >>> 'hello, new state!' ``` Note that `on_enter_«state name»` callback will *not* fire when a Machine is first initialized. For example if you have an `on_enter_A()` callback defined, and initialize the `Machine` with `initial='A'`, `on_enter_A()` will not be fired until the next time you enter state `A`. (If you need to make sure `on_enter_A()` fires at initialization, you can simply create a dummy initial state and then explicitly call `to_A()` inside the `__init__` method.) In addition to passing in callbacks when initializing a `State`, or adding them dynamically, it's also possible to define callbacks in the model class itself, which may increase code clarity. For example: ```python class Matter(object): def say_hello(self): print("hello, new state!") def say_goodbye(self): print("goodbye, old state!") def on_enter_A(self): print("We've just entered state A!") lump = Matter() machine = Machine(lump, states=['A', 'B', 'C']) ``` Now, any time `lump` transitions to state `A`, the `on_enter_A()` method defined in the `Matter` class will fire. #### Checking state You can always check the current state of the model by either: - inspecting the `.state` attribute, or - calling `is_«state name»()` And if you want to retrieve the actual `State` object for the current state, you can do that through the `Machine` instance's `get_state()` method. ```python lump.state >>> 'solid' lump.is_gas() >>> False lump.is_solid() >>> True machine.get_state(lump.state).name >>> 'solid' ``` If you'd like you track it using a different attribute, you could do that using the `model_attribute` argument while initializing the `Machine`. ```python lump = Matter() machine = Machine(lump, states=['solid', 'liquid', 'gas'], model='matter_state', initial='solid') lump.matter_state >>> 'solid' ``` #### Enumerations So far we have seen how we can give state names and use these names to work with our state machine. If you favour stricter typing and more IDE code completion (or you just can't type 'sesquipedalophobia' any longer because the word scares you) using [Enumerations](https://docs.python.org/3/library/enum.html) might be what you are looking for: ```python import enum # Python 2.7 users need to have 'enum34' installed from transitions import Machine class States(enum.Enum): ERROR = 0 RED = 1 YELLOW = 2 GREEN = 3 transitions = [['proceed', States.RED, States.YELLOW], ['proceed', States.YELLOW, States.GREEN], ['error', '*', States.ERROR]] m = Machine(states=States, transitions=transitions, initial=States.RED) assert m.is_RED() assert m.state is States.RED state = m.get_state(States.RED) # get transitions.State object print(state.name) # >>> RED m.proceed() m.proceed() assert m.is_GREEN() m.error() assert m.state is States.ERROR ``` You can mix enums and strings if you like (e.g. `[States.RED, 'ORANGE', States.YELLOW, States.GREEN]`) but note that internally, `transitions` will still handle states by name (`enum.Enum.name`). Thus, it is not possible to have the states `'GREEN'` and `States.GREEN` at the same time. ### Transitions Some of the above examples already illustrate the use of transitions in passing, but here we'll explore them in more detail. As with states, each transition is represented internally as its own object – an instance of class `Transition`. The quickest way to initialize a set of transitions is to pass a dictionary, or list of dictionaries, to the `Machine` initializer. We already saw this above: ```python transitions = [ { 'trigger': 'melt', 'source': 'solid', 'dest': 'liquid' }, { 'trigger': 'evaporate', 'source': 'liquid', 'dest': 'gas' }, { 'trigger': 'sublimate', 'source': 'solid', 'dest': 'gas' }, { 'trigger': 'ionize', 'source': 'gas', 'dest': 'plasma' } ] machine = Machine(model=Matter(), states=states, transitions=transitions) ``` Defining transitions in dictionaries has the benefit of clarity, but can be cumbersome. If you're after brevity, you might choose to define transitions using lists. Just make sure that the elements in each list are in the same order as the positional arguments in the `Transition` initialization (i.e., `trigger`, `source`, `destination`, etc.). The following list-of-lists is functionally equivalent to the list-of-dictionaries above: ```python transitions = [ ['melt', 'solid', 'liquid'], ['evaporate', 'liquid', 'gas'], ['sublimate', 'solid', 'gas'], ['ionize', 'gas', 'plasma'] ] ``` Alternatively, you can add transitions to a `Machine` after initialization: ```python machine = Machine(model=lump, states=states, initial='solid') machine.add_transition('melt', source='solid', dest='liquid') ``` The `trigger` argument defines the name of the new triggering method that gets attached to the base model. When this method is called, it will try to execute the transition: ```python >>> lump.melt() >>> lump.state 'liquid' ``` By default, calling an invalid trigger will raise an exception: ```python >>> lump.to_gas() >>> # This won't work because only objects in a solid state can melt >>> lump.melt() transitions.core.MachineError: "Can't trigger event melt from state gas!" ``` This behavior is generally desirable, since it helps alert you to problems in your code. But in some cases, you might want to silently ignore invalid triggers. You can do this by setting `ignore_invalid_triggers=True` (either on a state-by-state basis, or globally for all states): ```python >>> # Globally suppress invalid trigger exceptions >>> m = Machine(lump, states, initial='solid', ignore_invalid_triggers=True) >>> # ...or suppress for only one group of states >>> states = ['new_state1', 'new_state2'] >>> m.add_states(states, ignore_invalid_triggers=True) >>> # ...or even just for a single state. Here, exceptions will only be suppressed when the current state is A. >>> states = [State('A', ignore_invalid_triggers=True), 'B', 'C'] >>> m = Machine(lump, states) >>> # ...this can be inverted as well if just one state should raise an exception >>> # since the machine's global value is not applied to a previously initialized state. >>> states = ['A', 'B', State('C')] # the default value for 'ignore_invalid_triggers' is False >>> m = Machine(lump, states, ignore_invalid_triggers=True) ``` If you need to know which transitions are valid from a certain state, you can use `get_triggers`: ``` m.get_triggers('solid') >>> ['melt', 'sublimate'] m.get_triggers('liquid') >>> ['evaporate'] m.get_triggers('plasma') >>> [] # you can also query several states at once m.get_triggers('solid', 'liquid', 'gas', 'plasma') >>> ['melt', 'evaporate', 'sublimate', 'ionize'] ``` #### Automatic transitions for all states In addition to any transitions added explicitly, a `to_«state»()` method is created automatically whenever a state is added to a `Machine` instance. This method transitions to the target state no matter which state the machine is currently in: ```python lump.to_liquid() lump.state >>> 'liquid' lump.to_solid() lump.state >>> 'solid' ``` If you desire, you can disable this behavior by setting `auto_transitions=False` in the `Machine` initializer. #### Transitioning from multiple states A given trigger can be attached to multiple transitions, some of which can potentially begin or end in the same state. For example: ```python machine.add_transition('transmogrify', ['solid', 'liquid', 'gas'], 'plasma') machine.add_transition('transmogrify', 'plasma', 'solid') # This next transition will never execute machine.add_transition('transmogrify', 'plasma', 'gas') ``` In this case, calling `transmogrify()` will set the model's state to `'solid'` if it's currently `'plasma'`, and set it to `'plasma'` otherwise. (Note that only the _first_ matching transition will execute; thus, the transition defined in the last line above won't do anything.) You can also make a trigger cause a transition from _all_ states to a particular destination by using the `'*'` wildcard: ```python machine.add_transition('to_liquid', '*', 'liquid') ``` Note that wildcard transitions will only apply to states that exist at the time of the add_transition() call. Calling a wildcard-based transition when the model is in a state added after the transition was defined will elicit an invalid transition message, and will not transition to the target state. #### Reflexive transitions from multiple states A reflexive trigger (trigger that has the same state as source and destination) can easily be added specifying `=` as destination. This is handy if the same reflexive trigger should be added to multiple states. For example: ```python machine.add_transition('touch', ['liquid', 'gas', 'plasma'], '=', after='change_shape') ``` This will add reflexive transitions for all three states with `touch()` as trigger and with `change_shape` executed after each trigger. #### Internal transitions In contrast to reflexive transitions, internal transitions will never actually leave the state. This means that transition-related callbacks such as `before` or `after` will be processed while state-related callbacks `exit` or `enter` will not. To define a transition to be internal, set the destination to `None`. ```python machine.add_transition('internal', ['liquid', 'gas'], None, after='change_shape') ``` #### Ordered transitions A common desire is for state transitions to follow a strict linear sequence. For instance, given states `['A', 'B', 'C']`, you might want valid transitions for `A` → `B`, `B` → `C`, and `C` → `A` (but no other pairs). To facilitate this behavior, Transitions provides an `add_ordered_transitions()` method in the `Machine` class: ```python states = ['A', 'B', 'C'] # See the "alternative initialization" section for an explanation of the 1st argument to init machine = Machine(states=states, initial='A') machine.add_ordered_transitions() machine.next_state() print(machine.state) >>> 'B' # We can also define a different order of transitions machine = Machine(states=states, initial='A') machine.add_ordered_transitions(['A', 'C', 'B']) machine.next_state() print(machine.state) >>> 'C' # Conditions can be passed to 'add_ordered_transitions' as well # If one condition is passed, it will be used for all transitions machine = Machine(states=states, initial='A') machine.add_ordered_transitions(conditions='check') # If a list is passed, it must contain exactly as many elements as the # machine contains states (A->B, ..., X->A) machine = Machine(states=states, initial='A') machine.add_ordered_transitions(conditions=['check_A2B', ..., 'check_X2A']) ``` #### Queued transitions The default behaviour in Transitions is to process events instantly. This means events within an `on_enter` method will be processed _before_ callbacks bound to `after` are called. ```python def go_to_C(): global machine machine.to_C() def after_advance(): print("I am in state B now!") def entering_C(): print("I am in state C now!") states = ['A', 'B', 'C'] machine = Machine(states=states, initial='A') # we want a message when state transition to B has been completed machine.add_transition('advance', 'A', 'B', after=after_advance) # call transition from state B to state C machine.on_enter_B(go_to_C) # we also want a message when entering state C machine.on_enter_C(entering_C) machine.advance() >>> 'I am in state C now!' >>> 'I am in state B now!' # what? ``` The execution order of this example is ``` prepare -> before -> on_enter_B -> on_enter_C -> after. ``` If queued processing is enabled, a transition will be finished before the next transition is triggered: ```python machine = Machine(states=states, queued=True, initial='A') ... machine.advance() >>> 'I am in state B now!' >>> 'I am in state C now!' # That's better! ``` This results in ``` prepare -> before -> on_enter_B -> queue(to_C) -> after -> on_enter_C. ``` **Important note:** when processing events in a queue, the trigger call will _always_ return `True`, since there is no way to determine at queuing time whether a transition involving queued calls will ultimately complete successfully. This is true even when only a single event is processed. ```python machine.add_transition('jump', 'A', 'C', conditions='will_fail') ... # queued=False machine.jump() >>> False # queued=True machine.jump() >>> True ``` #### Conditional transitions Sometimes you only want a particular transition to execute if a specific condition occurs. You can do this by passing a method, or list of methods, in the `conditions` argument: ```python # Our Matter class, now with a bunch of methods that return booleans. class Matter(object): def is_flammable(self): return False def is_really_hot(self): return True machine.add_transition('heat', 'solid', 'gas', conditions='is_flammable') machine.add_transition('heat', 'solid', 'liquid', conditions=['is_really_hot']) ``` In the above example, calling `heat()` when the model is in state `'solid'` will transition to state `'gas'` if `is_flammable` returns `True`. Otherwise, it will transition to state `'liquid'` if `is_really_hot` returns `True`. For convenience, there's also an `'unless'` argument that behaves exactly like conditions, but inverted: ```python machine.add_transition('heat', 'solid', 'gas', unless=['is_flammable', 'is_really_hot']) ``` In this case, the model would transition from solid to gas whenever `heat()` fires, provided that both `is_flammable()` and `is_really_hot()` return `False`. Note that condition-checking methods will passively receive optional arguments and/or data objects passed to triggering methods. For instance, the following call: ```python lump.heat(temp=74) # equivalent to lump.trigger('heat', temp=74) ``` ... would pass the `temp=74` optional kwarg to the `is_flammable()` check (possibly wrapped in an `EventData` instance). For more on this, see the [Passing data](#passing-data) section below. #### Callbacks You can attach callbacks to transitions as well as states. Every transition has `'before'` and `'after'` attributes that contain a list of methods to call before and after the transition executes: ```python class Matter(object): def make_hissing_noises(self): print("HISSSSSSSSSSSSSSSS") def disappear(self): print("where'd all the liquid go?") transitions = [ { 'trigger': 'melt', 'source': 'solid', 'dest': 'liquid', 'before': 'make_hissing_noises'}, { 'trigger': 'evaporate', 'source': 'liquid', 'dest': 'gas', 'after': 'disappear' } ] lump = Matter() machine = Machine(lump, states, transitions=transitions, initial='solid') lump.melt() >>> "HISSSSSSSSSSSSSSSS" lump.evaporate() >>> "where'd all the liquid go?" ``` There is also a `'prepare'` callback that is executed as soon as a transition starts, before any `'conditions'` are checked or other callbacks are executed. ```python class Matter(object): heat = False attempts = 0 def count_attempts(self): self.attempts += 1 def is_really_hot(self): return self.heat def heat_up(self): self.heat = random.random() < 0.25 def stats(self): print('It took you %i attempts to melt the lump!' %self.attempts) states=['solid', 'liquid', 'gas', 'plasma'] transitions = [ { 'trigger': 'melt', 'source': 'solid', 'dest': 'liquid', 'prepare': ['heat_up', 'count_attempts'], 'conditions': 'is_really_hot', 'after': 'stats'}, ] lump = Matter() machine = Machine(lump, states, transitions=transitions, initial='solid') lump.melt() lump.melt() lump.melt() lump.melt() >>> "It took you 4 attempts to melt the lump!" ``` Note that `prepare` will not be called unless the current state is a valid source for the named transition. Default actions meant to be executed before or after *every* transition can be passed to `Machine` during initialization with `before_state_change` and `after_state_change` respectively: ```python class Matter(object): def make_hissing_noises(self): print("HISSSSSSSSSSSSSSSS") def disappear(self): print("where'd all the liquid go?") states=['solid', 'liquid', 'gas', 'plasma'] lump = Matter() m = Machine(lump, states, before_state_change='make_hissing_noises', after_state_change='disappear') lump.to_gas() >>> "HISSSSSSSSSSSSSSSS" >>> "where'd all the liquid go?" ``` There are also two keywords for callbacks which should be executed *independently* a) of how many transitions are possible, b) if any transition succeeds and c) even if an error is raised during the execution of some other callback. Callbacks passed to `Machine` with `prepare_event` will be executed *once* before processing possible transitions (and their individual `prepare` callbacks) takes place. Callbacks of `finalize_event` will be executed regardless of the success of the processed transitions. Note that if an error occurred it will be attached to `event_data` as `error` and can be retrieved with `send_event=True`. ```python from transitions import Machine class Matter(object): def raise_error(self, event): raise ValueError("Oh no") def prepare(self, event): print("I am ready!") def finalize(self, event): print("Result: ", type(event.error), event.error) states=['solid', 'liquid', 'gas', 'plasma'] lump = Matter() m = Machine(lump, states, prepare_event='prepare', before_state_change='raise_error', finalize_event='finalize', send_event=True) try: lump.to_gas() except ValueError: pass print(lump.state) >>> I am ready! >>> Result: Oh no >>> initial ``` ### Callback resolution and execution order As you have probably already realized, the standard way of passing callbacks to states and transitions is by name. When processing callbacks, `transitions` will use the name to retrieve the related callback from the model. If the method cannot be retrieved and it contains dots, Transitions will treat the name as a path to a module function and try to import it. Alternatively, you can pass callables such as (bound) functions directly. As mentioned earlier, you can also pass lists/tuples of callbacks to the callback parameters. Callbacks will be executed in the order they were added. ```python from transitions import Machine from mod import imported_func class Model(object): def a_callback(self): imported_func() model = Model() machine = Machine(model=model, states=['A'], initial='A') machine.add_transition('by_name', 'A', 'A', after='a_callback') machine.add_transition('by_reference', 'A', 'A', after=model.a_callback) machine.add_transition('imported', 'A', 'A', after='mod.imported_func') model.by_name() model.by_reference() model.imported() ``` The callback resolution is done in `Machine.resolve_callbacks`. This method can be overridden in case more complex callback resolution strategies are required. In summary, callbacks on transitions are executed in the following order: | Callback | Current State | Comments | |--------------------------------|:-------------:|-------------------------------------------------------------| | `'machine.prepare_event'` | `source` | executed *once* before individual transitions are processed | | `'transition.prepare'` | `source` | executed as soon as the transition starts | | `'transition.conditions'` | `source` | conditions *may* fail and halt the transition | | `'transition.unless'` | `source` | conditions *may* fail and halt the transition | | `'machine.before_state_change'`| `source` | default callbacks declared on model | | `'transition.before'` | `source` | | | `'state.on_exit'` | `source` | callbacks declared on the source state | | `` | | | | `'state.on_enter'` | `destination` | callbacks declared on the destination state | | `'transition.after'` | `destination` | | | `'machine.after_state_change'` | `destination` | default callbacks declared on model | | `'machine.finalize_event'` | `source/destination` | callbacks will be executed even if no transition took place or an exception has been raised | If any callback raises an exception, the processing of callbacks is not continued. This means that when an error occurs before the transition (in `state.on_exit` or earlier), it is halted. In case there is a raise after the transition has been conducted (in `state.on_enter` or later), the state change persists and no rollback is happening. Callbacks specified in `machine.finalize_event` will always be executed unless the exception is raised by a finalizing callback itself. ### Passing data Sometimes you need to pass the callback functions registered at machine initialization some data that reflects the model's current state. Transitions allows you to do this in two different ways. First (the default), you can pass any positional or keyword arguments directly to the trigger methods (created when you call `add_transition()`): ```python class Matter(object): def __init__(self): self.set_environment() def set_environment(self, temp=0, pressure=101.325): self.temp = temp self.pressure = pressure def print_temperature(self): print("Current temperature is %d degrees celsius." % self.temp) def print_pressure(self): print("Current pressure is %.2f kPa." % self.pressure) lump = Matter() machine = Machine(lump, ['solid', 'liquid'], initial='solid') machine.add_transition('melt', 'solid', 'liquid', before='set_environment') lump.melt(45) # positional arg; # equivalent to lump.trigger('melt', 45) lump.print_temperature() >>> 'Current temperature is 45 degrees celsius.' machine.set_state('solid') # reset state so we can melt again lump.melt(pressure=300.23) # keyword args also work lump.print_pressure() >>> 'Current pressure is 300.23 kPa.' ``` You can pass any number of arguments you like to the trigger. There is one important limitation to this approach: every callback function triggered by the state transition must be able to handle _all_ of the arguments. This may cause problems if the callbacks each expect somewhat different data. To get around this, Transitions supports an alternate method for sending data. If you set `send_event=True` at `Machine` initialization, all arguments to the triggers will be wrapped in an `EventData` instance and passed on to every callback. (The `EventData` object also maintains internal references to the source state, model, transition, machine, and trigger associated with the event, in case you need to access these for anything.) ```python class Matter(object): def __init__(self): self.temp = 0 self.pressure = 101.325 # Note that the sole argument is now the EventData instance. # This object stores positional arguments passed to the trigger method in the # .args property, and stores keywords arguments in the .kwargs dictionary. def set_environment(self, event): self.temp = event.kwargs.get('temp', 0) self.pressure = event.kwargs.get('pressure', 101.325) def print_pressure(self): print("Current pressure is %.2f kPa." % self.pressure) lump = Matter() machine = Machine(lump, ['solid', 'liquid'], send_event=True, initial='solid') machine.add_transition('melt', 'solid', 'liquid', before='set_environment') lump.melt(temp=45, pressure=1853.68) # keyword args lump.print_pressure() >>> 'Current pressure is 1853.68 kPa.' ``` ### Alternative initialization patterns In all of the examples so far, we've attached a new `Machine` instance to a separate model (`lump`, an instance of class `Matter`). While this separation keeps things tidy (because you don't have to monkey patch a whole bunch of new methods into the `Matter` class), it can also get annoying, since it requires you to keep track of which methods are called on the state machine, and which ones are called on the model that the state machine is bound to (e.g., `lump.on_enter_StateA()` vs. `machine.add_transition()`). Fortunately, Transitions is flexible, and supports two other initialization patterns. First, you can create a standalone state machine that doesn't require another model at all. Simply omit the model argument during initialization: ```python machine = Machine(states=states, transitions=transitions, initial='solid') machine.melt() machine.state >>> 'liquid' ``` If you initialize the machine this way, you can then attach all triggering events (like `evaporate()`, `sublimate()`, etc.) and all callback functions directly to the `Machine` instance. This approach has the benefit of consolidating all of the state machine functionality in one place, but can feel a little bit unnatural if you think state logic should be contained within the model itself rather than in a separate controller. An alternative (potentially better) approach is to have the model inherit from the `Machine` class. Transitions is designed to support inheritance seamlessly. (just be sure to override class `Machine`'s `__init__` method!): ```python class Matter(Machine): def say_hello(self): print("hello, new state!") def say_goodbye(self): print("goodbye, old state!") def __init__(self): states = ['solid', 'liquid', 'gas'] Machine.__init__(self, states=states, initial='solid') self.add_transition('melt', 'solid', 'liquid') lump = Matter() lump.state >>> 'solid' lump.melt() lump.state >>> 'liquid' ``` Here you get to consolidate all state machine functionality into your existing model, which often feels more natural way than sticking all of the functionality we want in a separate standalone `Machine` instance. A machine can handle multiple models which can be passed as a list like `Machine(model=[model1, model2, ...])`. In cases where you want to add models *as well as* the machine instance itself, you can pass the string placeholder `'self'` during initialization like `Machine(model=['self', model1, ...])`. You can also create a standalone machine, and register models dynamically via `machine.add_model`. Remember to call `machine.remove_model` if machine is long-lasting and your models are temporary and should be garbage collected: ```python class Matter(): pass lump1 = Matter() lump2 = Matter() machine = Machine(states=states, transitions=transitions, initial='solid', add_self=False) machine.add_model(lump1) machine.add_model(lump2, initial='liquid') lump1.state >>> 'solid' lump2.state >>> 'liquid' machine.remove_model([lump1, lump2]) del lump1 # lump1 is garbage collected del lump2 # lump2 is garbage collected ``` If you don't provide an initial state in the state machine constructor, you must provide one every time you add a model: ```python machine = Machine(states=states, transitions=transitions, add_self=False) machine.add_model(Matter()) >>> "MachineError: No initial state configured for machine, must specify when adding model." machine.add_model(Matter(), initial='liquid') ``` Models with multiple states could attach multiple machines using different `model_attribute` values: ```python lump = Matter() lump.state >>> 'solid' lump.shipping_state >>> 'delivered' matter_machine = Machine(lump, model_attribute='state', **kwargs) shipment_machine = Machine(lump, model_attribute='shipping_state', **kwargs) ``` ### Logging Transitions includes very rudimentary logging capabilities. A number of events – namely, state changes, transition triggers, and conditional checks – are logged as INFO-level events using the standard Python `logging` module. This means you can easily configure logging to standard output in a script: ```python # Set up logging; The basic log level will be DEBUG import logging logging.basicConfig(level=logging.DEBUG) # Set transitions' log level to INFO; DEBUG messages will be omitted logging.getLogger('transitions').setLevel(logging.INFO) # Business as usual machine = Machine(states=states, transitions=transitions, initial='solid') ... ``` ### (Re-)Storing machine instances Machines are picklable and can be stored and loaded with `pickle`. For Python 3.3 and earlier `dill` is required. ```python import dill as pickle # only required for Python 3.3 and earlier m = Machine(states=['A', 'B', 'C'], initial='A') m.to_B() m.state >>> B # store the machine dump = pickle.dumps(m) # load the Machine instance again m2 = pickle.loads(dump) m2.state >>> B m2.states.keys() >>> ['A', 'B', 'C'] ``` ### Extensions Even though the core of transitions is kept lightweight, there are a variety of MixIns to extend its functionality. Currently supported are: - **Diagrams** to visualize the current state of a machine - **Hierarchical State Machines** for nesting and reuse - **Threadsafe Locks** for parallel execution - **Custom States** for extended state-related behaviour There are two mechanisms to retrieve a state machine instance with the desired features enabled. The first approach makes use of the convenience `factory` with the three parameters `graph`, `nested` and `locked` set to `True` if the certain feature is required: ```python from transitions.extensions import MachineFactory # create a machine with mixins diagram_cls = MachineFactory.get_predefined(graph=True) nested_locked_cls = MachineFactory.get_predefined(nested=True, locked=True) # create instances from these classes # instances can be used like simple machines machine1 = diagram_cls(model, state, transitions...) machine2 = nested_locked_cls(model, state, transitions) ``` This approach targets experimental use since in this case the underlying classes do not have to be known. However, classes can also be directly imported from `transitions.extensions`. The naming scheme is as follows: | | Diagrams | Nested | Locked | | -----------------------------: | :------: | :----: | :----: | | Machine | ✘ | ✘ | ✘ | | GraphMachine | ✓ | ✘ | ✘ | | HierarchicalMachine | ✘ | ✓ | ✘ | | LockedMachine | ✘ | ✘ | ✓ | | HierarchicalGraphMachine | ✓ | ✓ | ✘ | | LockedGraphMachine | ✓ | ✘ | ✓ | | LockedHierarchicalMachine | ✘ | ✓ | ✓ | | LockedHierarchicalGraphMachine | ✓ | ✓ | ✓ | To use a full featured state machine, one could write: ```python from transitions.extensions import LockedHierarchicalGraphMachine as Machine #enable ALL the features! machine = Machine(model, states, transitions) ``` #### Diagrams Additional Keywords: * `title` (optional): Sets the title of the generated image. * `show_conditions` (default False): Shows conditions at transition edges * `show_auto_transitions` (default False): Shows auto transitions in graph * `show_state_attributes` (default False): Show callbacks (enter, exit), tags and timeouts in graph Transitions can generate basic state diagrams displaying all valid transitions between states. To use the graphing functionality, you'll need to have `graphviz` and/or `pygraphviz` installed: To generate graphs with the package `graphviz`, you need to install [Graphviz](https://graphviz.org/) manually or via a package manager. sudo apt-get install graphviz # Ubuntu and Debian brew install graphviz # MacOS conda install graphviz python-graphviz # (Ana)conda Now you can install the actual Python packages pip install graphviz pygraphviz # install graphviz and/or pygraphviz manually... pip install transitions[diagrams] # ... or install transitions with 'diagrams' extras which currently depends on pygraphviz Currently, `GraphMachine` will use `pygraphviz` when available and fall back to `graphviz` when `pygraphviz` cannot be found. This can be overridden by passing `use_pygraphviz=False` to the constructor. Note that this default might change in the future and `pygraphviz` support may be dropped. With `Model.get_graph()` you can get the current graph or the region of interest (roi) and draw it like this: ```python # import transitions from transitions.extensions import GraphMachine as Machine m = Model() # without further arguments pygraphviz will be used machine = Machine(model=m, ...) # when you want to use graphviz explicitely machine = Machine(model=m, use_pygraphviz=False, ...) # in cases where auto transitions should be visible machine = Machine(model=m, show_auto_transitions=True, ...) # draw the whole graph ... m.get_graph().draw('my_state_diagram.png', prog='dot') # ... or just the region of interest # (previous state, active state and all reachable states) roi = m.get_graph(show_roi=True).draw('my_state_diagram.png', prog='dot') ``` This produces something like this: ![state diagram example](https://user-images.githubusercontent.com/205986/47524268-725c1280-d89a-11e8-812b-1d3b6e667b91.png) Also, have a look at our [example](./examples) IPython/Jupyter notebooks for a more detailed example. ### Hierarchical State Machine (HSM) Transitions includes an extension module which allows to nest states. This allows to create contexts and to model cases where states are related to certain subtasks in the state machine. To create a nested state, either import `NestedState` from transitions or use a dictionary with the initialization arguments `name` and `children`. Optionally, `initial` can be used to define a sub state to transit to, when the nested state is entered. ```python from transitions.extensions import HierarchicalMachine as Machine states = ['standing', 'walking', {'name': 'caffeinated', 'children':['dithering', 'running']}] transitions = [ ['walk', 'standing', 'walking'], ['stop', 'walking', 'standing'], ['drink', '*', 'caffeinated'], ['walk', ['caffeinated', 'caffeinated_dithering'], 'caffeinated_running'], ['relax', 'caffeinated', 'standing'] ] machine = Machine(states=states, transitions=transitions, initial='standing', ignore_invalid_triggers=True) machine.walk() # Walking now machine.stop() # let's stop for a moment machine.drink() # coffee time machine.state >>> 'caffeinated' machine.walk() # we have to go faster machine.state >>> 'caffeinated_running' machine.stop() # can't stop moving! machine.state >>> 'caffeinated_running' machine.relax() # leave nested state machine.state # phew, what a ride >>> 'standing' # machine.on_enter_caffeinated_running('callback_method') ``` A configuration making use of `initial` could look like this: ```python # ... states = ['standing', 'walking', {'name': 'caffeinated', 'initial': 'dithering', 'children': ['dithering', 'running']}] transitions = [ ['walk', 'standing', 'walking'], ['stop', 'walking', 'standing'], # this transition will end in 'caffeinated_dithering'... ['drink', '*', 'caffeinated'], # ... that is why we do not need do specify 'caffeinated' here anymore ['walk', 'caffeinated_dithering', 'caffeinated_running'], ['relax', 'caffeinated', 'standing'] ] # ... ``` Some things that have to be considered when working with nested states: State *names are concatenated* with `NestedState.separator`. Currently the separator is set to underscore ('_') and therefore behaves similar to the basic machine. This means a substate `bar` from state `foo` will be known by `foo_bar`. A substate `baz` of `bar` will be referred to as `foo_bar_baz` and so on. When entering a substate, `enter` will be called for all parent states. The same is true for exiting substates. Third, nested states can overwrite transition behaviour of their parents. If a transition is not known to the current state it will be delegated to its parent. In some cases underscore as a separator is not sufficient. For instance if state names consists of more than one word and a concatenated naming such as `state_A_name_state_C` would be confusing. Setting the separator to something else than underscore changes some of the behaviour (auto_transition and setting callbacks). You can even use unicode characters if you use python 3: ```python from transitions.extensions.nesting import NestedState NestedState.separator = '↦' states = ['A', 'B', {'name': 'C', 'children':['1', '2', {'name': '3', 'children': ['a', 'b', 'c']} ]} ] transitions = [ ['reset', 'C', 'A'], ['reset', 'C↦2', 'C'] # overwriting parent reset ] # we rely on auto transitions machine = Machine(states=states, transitions=transitions, initial='A') machine.to_B() # exit state A, enter state B machine.to_C() # exit B, enter C machine.to_C.s3.a() # enter C↦a; enter C↦3↦a; machine.state, >>> 'C↦3↦a' machine.to('C↦2') # not interactive; exit C↦3↦a, exit C↦3, enter C↦2 machine.reset() # exit C↦2; reset C has been overwritten by C↦3 machine.state >>> 'C' machine.reset() # exit C, enter A machine.state >>> 'A' # s.on_enter('C↦3↦a', 'callback_method') ``` Instead of `to_C_3_a()` auto transition is called as `to_C.s3.a()`. If your substate starts with a digit, transitions adds a prefix 's' ('3' becomes 's3') to the auto transition `FunctionWrapper` to comply with the attribute naming scheme of python. If interactive completion is not required, `to('C↦3↦a')` can be called directly. Additionally, `on_enter/exit_<>` is replaced with `on_enter/exit(state_name, callback)`. To check whether the current state is a substate of a specific state `is_state` supports the keyword `allow_substates`: ```python machine.state >>> 'C.2.a' machine.is_C() # checks for specific states >>> False machine.is_C(allow_substates=True) >>> True ``` You can use enumerations in HSMs as well but `enum` support is currently limited to the root level as model state enums lack hierarchical information. An attempt of nesting an `Enum` will raise an `AttributeError` in `NestedState`. ```python # will work states = [States.RED, States.YELLOW, {'name': States.GREEN, 'children': ['tick', 'tock']}] # will raise an AttributeError states = ['A', {'name': 'B', 'children': States}] ``` #### Reuse of previously created HSMs Besides semantic order, nested states are very handy if you want to specify state machines for specific tasks and plan to reuse them. Be aware that this will *embed* the passed machine's states. This means if your states had been altered *before*, this change will be persistent. ```python count_states = ['1', '2', '3', 'done'] count_trans = [ ['increase', '1', '2'], ['increase', '2', '3'], ['decrease', '3', '2'], ['decrease', '2', '1'], ['done', '3', 'done'], ['reset', '*', '1'] ] counter = Machine(states=count_states, transitions=count_trans, initial='1') counter.increase() # love my counter states = ['waiting', 'collecting', {'name': 'counting', 'children': counter}] transitions = [ ['collect', '*', 'collecting'], ['wait', '*', 'waiting'], ['count', 'collecting', 'counting'] ] collector = Machine(states=states, transitions=transitions, initial='waiting') collector.collect() # collecting collector.count() # let's see what we got; counting_1 collector.increase() # counting_2 collector.increase() # counting_3 collector.done() # collector.state == counting_done collector.wait() # collector.state == waiting ``` If a `HierarchicalStateMachine` is passed with the `children` keyword, the initial state of this machine will be assigned to the new parent state. In the above example we see that entering `counting` will also enter `counting_1`. If this is undesired behaviour and the machine should rather halt in the parent state, the user can pass `initial` as `False` like `{'name': 'counting', 'children': counter, 'initial': False}`. Sometimes you want such an embedded state collection to 'return' which means after it is done it should exit and transit to one of your states. To achieve this behaviour you can remap state transitions. In the example above we would like the counter to return if the state `done` was reached. This is done as follows: ```python states = ['waiting', 'collecting', {'name': 'counting', 'children': counter, 'remap': {'done': 'waiting'}}] ... # same as above collector.increase() # counting_3 collector.done() collector.state >>> 'waiting' # be aware that 'counting_done' will be removed from the state machine ``` If a reused state machine does not have a final state, you can of course add the transitions manually. If 'counter' had no 'done' state, we could just add `['done', 'counter_3', 'waiting']` to achieve the same behaviour. Note that the `HierarchicalMachine` will not integrate the machine instance itself but the states and transitions by creating copies of them. This way you are able to continue using your previously created instance without interfering with the embedded version. #### Threadsafe(-ish) State Machine In cases where event dispatching is done in threads, one can use either `LockedMachine` or `LockedHierarchicalMachine` where **function access** (!sic) is secured with reentrant locks. This does not save you from corrupting your machine by tinkering with member variables of your model or state machine. ```python from transitions.extensions import LockedMachine as Machine from threading import Thread import time states = ['A', 'B', 'C'] machine = Machine(states=states, initial='A') # let us assume that entering B will take some time thread = Thread(target=machine.to_B) thread.start() time.sleep(0.01) # thread requires some time to start machine.to_C() # synchronized access; won't execute before thread is done # accessing attributes directly thread = Thread(target=machine.to_B) thread.start() machine.new_attrib = 42 # not synchronized! will mess with execution order ``` Any python context manager can be passed in via the `machine_context` keyword argument: ```python from transitions.extensions import LockedMachine as Machine from threading import RLock states = ['A', 'B', 'C'] lock1 = RLock() lock2 = RLock() machine = Machine(states=states, initial='A', machine_context=[lock1, lock2]) ``` Any contexts via `machine_model` will be shared between all models registered with the `Machine`. Per-model contexts can be added as well: ``` lock3 = RLock() machine.add_model(model, model_context=lock3) ``` It's important that all user-provided context managers are re-entrant since the state machine will call them multiple times, even in the context of a single trigger invocation. #### Adding features to states If your superheroes need some custom behaviour, you can throw in some extra functionality by decorating machine states: ```python from time import sleep from transitions import Machine from transitions.extensions.states import add_state_features, Tags, Timeout @add_state_features(Tags, Timeout) class CustomStateMachine(Machine): pass class SocialSuperhero(object): def __init__(self): self.entourage = 0 def on_enter_waiting(self): self.entourage += 1 states = [{'name': 'preparing', 'tags': ['home', 'busy']}, {'name': 'waiting', 'timeout': 1, 'on_timeout': 'go'}, {'name': 'away'}] # The city needs us! transitions = [['done', 'preparing', 'waiting'], ['join', 'waiting', 'waiting'], # Entering Waiting again will increase our entourage ['go', 'waiting', 'away']] # Okay, let' move hero = SocialSuperhero() machine = CustomStateMachine(model=hero, states=states, transitions=transitions, initial='preparing') assert hero.state == 'preparing' # Preparing for the night shift assert machine.get_state(hero.state).is_busy # We are at home and busy hero.done() assert hero.state == 'waiting' # Waiting for fellow superheroes to join us assert hero.entourage == 1 # It's just us so far sleep(0.7) # Waiting... hero.join() # Weeh, we got company sleep(0.5) # Waiting... hero.join() # Even more company \o/ sleep(2) # Waiting... assert hero.state == 'away' # Impatient superhero already left the building assert machine.get_state(hero.state).is_home is False # Yupp, not at home anymore assert hero.entourage == 3 # At least he is not alone ``` Currently, transitions comes equipped with the following state features: * **Timeout** -- triggers an event after some time has passed - keyword: `timeout` (int, optional) -- if passed, an entered state will timeout after `timeout` seconds - keyword: `on_timeout` (string/callable, optional) -- will be called when timeout time has been reached - will raise an `AttributeError` when `timeout` is set but `on_timeout` is not - Note: A timeout is triggered in a thread. This implies several limitations (e.g. catching Exceptions raised in timeouts). Consider an event queue for more sophisticated applications. * **Tags** -- adds tags to states - keyword: `tags` (list, optional) -- assigns tags to a state - `State.is_` will return `True` when the state has been tagged with `tag_name`, else `False` * **Error** -- raises a `MachineError` when a state cannot be left - inherits from `Tags` (if you use `Error` do not use `Tags`) - keyword: `accepted` (bool, optional) -- marks a state as accepted - alternatively the keyword `tags` can be passed, containing 'accepted' - Note: Errors will only be raised if `auto_transitions` has been set to `False`. Otherwise every state can be exited with `to_` methods. * **Volatile** -- initialises an object every time a state is entered - keyword: `volatile` (class, optional) -- every time the state is entered an object of type class will be assigned to the model. The attribute name is defined by `hook`. If omitted, an empty VolatileObject will be created instead - keyword: `hook` (string, default='scope') -- The model's attribute name fore the temporal object. You can write your own `State` extensions and add them the same way. Just note that `add_state_features` expects *Mixins*. This means your extension should always call the overridden methods `__init__`, `enter` and `exit`. Your extension may inherit from *State* but will also work without it. In case you prefer to write your own custom states from scratch be aware that some state extensions *require* certain state features. `HierarchicalStateMachine` requires your custom state to be an instance of `NestedState` (`State` is not sufficient). To inject your states you can either assign them to your `Machine`'s class attribute `state_cls` or override `Machine.create_state` in case you need some specific procedures done whenever a state is created: ```python from transitions import Machine, State class MyState(State): pass class CustomMachine(Machine): # Use MyState as state class state_cls = MyState class VerboseMachine(Machine): # `Machine._create_state` is a class method but we can # override it to be an instance method def _create_state(self, *args, **kwargs): print("Creating a new state with machine '{0}'".format(self.name)) return MyState(*args, **kwargs) ``` #### Using transitions together with Django Christian Ledermann developed `django-transitions`, a module dedicated to streamline the work with `transitions` and Django. The source code is also hosted on [Github](https://github.com/PrimarySite/django-transitions). Have a look at [the documentation](https://django-transitions.readthedocs.io/en/latest/) for usage examples. ### I have a [bug report/issue/question]... For bug reports and other issues, please open an issue on GitHub. For usage questions, post on Stack Overflow, making sure to tag your question with the `transitions` and `python` tags. Do not forget to have a look at the [extended examples](./examples)! For any other questions, solicitations, or large unrestricted monetary gifts, email [Tal Yarkoni](mailto:tyarkoni@gmail.com). transitions-0.7.2/examples/0000755000076500000240000000000013606034310016632 5ustar alneumanstaff00000000000000transitions-0.7.2/examples/Frequently asked questions.ipynb0000644000076500000240000003622513536646570025151 0ustar alneumanstaff00000000000000{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Frequently asked questions\n", "\n", "* [How to use transitions with django models?](#How-to-use-transitions-with-django-models?)\n", "* [transitions memory footprint is too large for my Django app and adding models takes too long.](#transitions-memory-footprint-is-too-large-for-my-Django-app-and-adding-models-takes-too-long.) \n", "* [Is there a during callback which is called when no transition has been successful?](#Is-there-a-'during'-callback-which-is-called-when-no-transition-has-been-successful?)\n", "* [How to have a dynamic transition destination based on a function's return value?](#How-to-have-a-dynamic-transition-destination-based-on-a-function's-return-value)\n", "* [Machine.get_triggers should only show valid transitions based on some conditions.](#Machine.get_triggers-should-only-show-valid-transitions-based-on-some-conditions.)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### How to use `transitions` with django models?\n", "\n", "In [this comment](https://github.com/pytransitions/transitions/issues/146#issuecomment-300277397) **proofit404** provided a nice example about how to use `transitions` and django together:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from django.db import models\n", "from django.db.models.signals import post_init\n", "from django.dispatch import receiver\n", "from django.utils.translation import ugettext_lazy as _\n", "from transitions import Machine\n", "\n", "\n", "class ModelWithState(models.Model):\n", " ASLEEP = 'asleep'\n", " HANGING_OUT = 'hanging out'\n", " HUNGRY = 'hungry'\n", " SWEATY = 'sweaty'\n", " SAVING_THE_WORLD = 'saving the world'\n", " STATE_TYPES = [\n", " (ASLEEP, _('asleep')),\n", " (HANGING_OUT, _('hanging out')),\n", " (HUNGRY, _('hungry')),\n", " (SWEATY, _('sweaty')),\n", " (SAVING_THE_WORLD, _('saving the world')),\n", " ]\n", " state = models.CharField(\n", " _('state'),\n", " max_length=100,\n", " choices=STATE_TYPES,\n", " default=ASLEEP,\n", " help_text=_('actual state'),\n", " )\n", "\n", "\n", "@receiver(post_init, sender=ModelWithState)\n", "def init_state_machine(instance, **kwargs):\n", "\n", " states = [state for state, _ in instance.STATE_TYPES]\n", " machine = instance.machine = Machine(model=instance, states=states, initial=instance.state)\n", " machine.add_transition('work_out', instance.HANGING_OUT, instance.HUNGRY)\n", " machine.add_transition('eat', instance.HUNGRY, instance.HANGING_OUT)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### `transitions` memory footprint is too large for my Django app and adding models takes too long.\n", "\n", "We analyzed the memory footprint of `transitions` in [this discussion](https://github.com/pytransitions/transitions/issues/146) and could verify that the standard approach is not suitable to handle thousands of models. However, with a static (class) machine and some `__getattribute__` tweaking we can keep the convenience loss minimal:" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "from transitions import Machine\n", "from functools import partial\n", "from mock import MagicMock\n", "\n", "\n", "class Model(object):\n", "\n", " machine = Machine(model=None, states=['A', 'B', 'C'], initial=None,\n", " transitions=[\n", " {'trigger': 'go', 'source': 'A', 'dest': 'B', 'before': 'before'},\n", " {'trigger': 'check', 'source': 'B', 'dest': 'C', 'conditions': 'is_large'},\n", " ], finalize_event='finalize')\n", "\n", " def __init__(self):\n", " self.state = 'A'\n", " self.before = MagicMock()\n", " self.after = MagicMock()\n", " self.finalize = MagicMock()\n", "\n", " @staticmethod\n", " def is_large(value=0):\n", " return value > 9000\n", "\n", " def __getattribute__(self, item):\n", " try:\n", " return super(Model, self).__getattribute__(item)\n", " except AttributeError:\n", " if item in self.machine.events:\n", " return partial(self.machine.events[item].trigger, self)\n", " raise\n", "\n", "\n", "model = Model()\n", "model.go()\n", "assert model.state == 'B'\n", "assert model.before.called\n", "assert model.finalize.called\n", "model.check()\n", "assert model.state == 'B'\n", "model.check(value=500)\n", "assert model.state == 'B'\n", "model.check(value=9001)\n", "assert model.state == 'C'\n", "assert model.finalize.call_count == 4" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Is there a 'during' callback which is called when no transition has been successful?\n", "\n", "Currently, `transitions` has no such callback. This example from the issue discussed [here](https://github.com/pytransitions/transitions/issues/342) might give you a basic idea about how to extend `Machine` with such a feature:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Explicitly assigned callback\n", "Dynamically assigned callback\n", "Explicitly assigned callback\n", "Dynamically assigned callback\n" ] } ], "source": [ "from transitions.core import Machine, State, Event, EventData, listify\n", "\n", "\n", "class DuringState(State):\n", "\n", " # add `on_during` to the dynamic callback methods\n", " # this way on_during_ can be recognized by `Machine`\n", " dynamic_methods = State.dynamic_methods + ['on_during']\n", " \n", " # parse 'during' and remove the keyword before passing the rest along to state\n", " def __init__(self, *args, **kwargs):\n", " during = kwargs.pop('during', [])\n", " self.on_during = listify(during)\n", " super(DuringState, self).__init__(*args, **kwargs)\n", "\n", " def during(self, event_data):\n", " for handle in self.on_during:\n", " event_data.machine.callback(handle, event_data)\n", "\n", "\n", "class DuringEvent(Event):\n", "\n", " def _trigger(self, model, *args, **kwargs):\n", " # a successful transition returns `res=True` if res is False, we know that\n", " # no transition has been executed\n", " res = super(DuringEvent, self)._trigger(model, *args, **kwargs)\n", " if res is False:\n", " state = self.machine.get_state(model.state)\n", " event_data = EventData(state, self, self.machine, model, args=args, kwargs=kwargs)\n", " event_data.result = res\n", " state.during(event_data)\n", " return res\n", "\n", "\n", "class DuringMachine(Machine):\n", " # we need to override the state and event classes used by `Machine`\n", " state_cls = DuringState\n", " event_cls = DuringEvent\n", "\n", "\n", "class Model:\n", "\n", " def on_during_A(self):\n", " print(\"Dynamically assigned callback\")\n", "\n", " def another_callback(self):\n", " print(\"Explicitly assigned callback\")\n", "\n", "\n", "model = Model()\n", "machine = DuringMachine(model=model, states=[{'name': 'A', 'during': 'another_callback'}, 'B'],\n", " transitions=[['go', 'B', 'A']], initial='A', ignore_invalid_triggers=True)\n", "machine.add_transition('test', source='A', dest='A', conditions=lambda: False)\n", "\n", "assert not model.go()\n", "assert not model.test()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### How to have a dynamic transition destination based on a function's return value\n", "\n", "This has been a feature request [here](https://github.com/pytransitions/transitions/issues/269). We'd encourage to write a wrapper which converts a condensed statement into individual condition-based transitions. However, a less expressive version could look like this:" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "from transitions import Machine, Transition\n", "from six import string_types\n", "\n", "class DependingTransition(Transition):\n", "\n", " def __init__(self, source, dest, conditions=None, unless=None, before=None,\n", " after=None, prepare=None, **kwargs):\n", "\n", " self._result = self._dest = None\n", " super(DependingTransition, self).__init__(source, dest, conditions, unless, before, after, prepare)\n", " if isinstance(dest, dict):\n", " try:\n", " self._func = kwargs.pop('depends_on')\n", " except KeyError:\n", " raise AttributeError(\"A multi-destination transition requires a 'depends_on'\")\n", " else:\n", " # use base version in case transition does not need special handling\n", " self.execute = super(DependingTransition, self).execute\n", "\n", " def execute(self, event_data):\n", " func = getattr(event_data.model, self._func) if isinstance(self._func, string_types) \\\n", " else self._func\n", " self._result = func(*event_data.args, **event_data.kwargs)\n", " super(DependingTransition, self).execute(event_data)\n", "\n", " @property\n", " def dest(self):\n", " return self._dest[self._result] if self._result is not None else self._dest\n", "\n", " @dest.setter\n", " def dest(self, value):\n", " self._dest = value\n", "\n", "# subclass Machine to use DependingTransition instead of standard Transition\n", "class DependingMachine(Machine):\n", " transition_cls = DependingTransition\n", " \n", "\n", "def func(value):\n", " return value\n", "\n", "m = DependingMachine(states=['A', 'B', 'C', 'D'], initial='A')\n", "# define a dynamic transition with a 'depends_on' function which will return the required value\n", "m.add_transition(trigger='shuffle', source='A', dest=({1: 'B', 2: 'C', 3: 'D'}), depends_on=func)\n", "m.shuffle(value=2) # func returns 2 which makes the transition dest to be 'C'\n", "assert m.is_C()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that this solution has some drawbacks. For instance, the generated graph might not include all possible outcomes." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### `Machine.get_triggers` should only show valid transitions based on some conditions.\n", "\n", "This has been requested [here](https://github.com/pytransitions/transitions/issues/256). `Machine.get_triggers` is usually quite naive and only checks for theoretically possible transitions. If you need more sophisticated peeking, this `PeekMachine._can_trigger` might be a solution:" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [], "source": [ "from transitions import Machine, EventData\n", "from functools import partial\n", "\n", "\n", "class Model(object):\n", "\n", " def fails(self, condition=False):\n", " return False\n", "\n", " def success(self, condition=False):\n", " return True\n", "\n", " # condition is passed by EventData\n", " def depends_on(self, condition=False):\n", " return condition\n", "\n", " def is_state_B(self, condition=False):\n", " return self.state == 'B'\n", "\n", "\n", "class PeekMachine(Machine):\n", "\n", " def _can_trigger(self, model, *args, **kwargs):\n", " # We can omit the first two arguments state and event since they are only needed for \n", " # actual state transitions. We do have to pass the machine (self) and the model as well as \n", " # args and kwargs meant for the callbacks.\n", " e = EventData(None, None, self, model, args, kwargs)\n", "\n", " return [trigger_name for trigger_name in self.get_triggers(model.state)\n", " if any(all(c.check(e) for c in t.conditions)\n", " for ts in self.events[trigger_name].transitions.values()\n", " for t in ts)]\n", "\n", " # override Machine.add_model to assign 'can_trigger' to the model\n", " def add_model(self, model, initial=None):\n", " super(PeekMachine, self).add_model(model, initial)\n", " setattr(model, 'can_trigger', partial(self._can_trigger, model))\n", "\n", "\n", "states = ['A', 'B', 'C', 'D']\n", "transitions = [\n", " dict(trigger='go_A', source='*', dest='A', conditions=['depends_on']), # only available when condition=True is passed\n", " dict(trigger='go_B', source='*', dest='B', conditions=['success']), # always available\n", " dict(trigger='go_C', source='*', dest='C', conditions=['fails']), # never available\n", " dict(trigger='go_D', source='*', dest='D', conditions=['is_state_B']), # only available in state B\n", " dict(trigger='reset', source='D', dest='A', conditions=['success', 'depends_on']), # only available in state D when condition=True is passed\n", " dict(trigger='forwards', source='A', dest='D', conditions=['success', 'fails']), # never available\n", "]\n", "\n", "model = Model()\n", "machine = PeekMachine(model, states=states, transitions=transitions, initial='A', auto_transitions=False)\n", "assert model.can_trigger() == ['go_B']\n", "assert set(model.can_trigger(condition=True)) == set(['go_A', 'go_B'])\n", "model.go_B(condition=True)\n", "assert set(model.can_trigger()) == set(['go_B', 'go_D'])\n", "model.go_D()\n", "assert model.can_trigger() == ['go_B']\n", "assert set(model.can_trigger(condition=True)) == set(['go_A', 'go_B', 'reset'])" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 2", "language": "python", "name": "python2" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 2 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython2", "version": "2.7.16" } }, "nbformat": 4, "nbformat_minor": 2 } transitions-0.7.2/examples/Graph MIxin Demo Nested.ipynb0000644000076500000240000336247013530722244024040 0ustar alneumanstaff00000000000000{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": { "hide_input": false }, "outputs": [], "source": [ "import os, sys, inspect, io\n", "\n", "cmd_folder = os.path.realpath(\n", " os.path.dirname(\n", " os.path.abspath(os.path.split(inspect.getfile( inspect.currentframe() ))[0])))\n", "\n", "if cmd_folder not in sys.path:\n", " sys.path.insert(0, cmd_folder)\n", "\n", "from transitions.extensions.states import Timeout, Tags, add_state_features\n", "from transitions.extensions.factory import HierarchicalGraphMachine as Machine\n", "from IPython.display import Image, display, display_png\n", "\n", "@add_state_features(Timeout, Tags)\n", "class CustomStateMachine(Machine):\n", " pass\n", "\n", "class Matter(object):\n", " def do_x(self):\n", " pass\n", " def do_y(self):\n", " pass\n", " def do_z(self):\n", " pass\n", " def is_hot(self):\n", " return True\n", " def is_too_hot(self):\n", " return False\n", " def show_graph(self, **kwargs):\n", " stream = io.BytesIO()\n", " self.get_graph(**kwargs).draw(stream, prog='dot', format='png')\n", " display(Image(stream.getvalue()))\n", "\n", "extra_args = dict(auto_transitions=False, initial='standing', title='Mood Matrix',\n", " show_conditions=True, show_state_attributes=True)" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "hide_input": false }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "states = [{'name': 'caffeinated', 'on_enter': 'do_x', 'children':['dithering', 'running']},\n", " {'name': 'standing', 'on_enter': ['do_x', 'do_y'], 'on_exit': 'do_z'},\n", " {'name': 'walking', 'tags': ['accepted', 'pending'], 'timeout': 5, 'on_timeout': 'do_z'},\n", " \n", " ]\n", "transitions = [\n", " ['walk', 'standing', 'walking'],\n", " ['go', 'standing', 'walking'],\n", " ['stop', 'walking', 'standing'],\n", " {'trigger': 'drink', 'source': '*', 'dest': 'caffeinated_dithering',\n", " 'conditions':'is_hot', 'unless': 'is_too_hot'},\n", " ['walk', 'caffeinated_dithering', 'caffeinated_running'],\n", " ['relax', 'caffeinated', 'standing'],\n", " ['sip', 'standing', 'caffeinated']\n", "]\n", "\n", "model = Matter()\n", "machine = CustomStateMachine(model=model, states=states, transitions=transitions, **extra_args)\n", "model.show_graph()" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "model.walk()\n", "model.show_graph()" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "model.drink()\n", "model.show_graph()" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "model.walk()\n", "model.show_graph()" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "model.relax()\n", "model.show_graph()" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "model.show_graph(show_roi=True)" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# multimodel test\n", "model1 = Matter()\n", "model2 = Matter()\n", "machine = CustomStateMachine(model=[model1, model2], states=states, transitions=transitions, **extra_args)\n", "model1.drink()\n", "model1.drink()\n", "model2.walk()\n", "model1.show_graph()" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "model2.show_graph()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.3" } }, "nbformat": 4, "nbformat_minor": 1 } transitions-0.7.2/examples/Graph MIxin Demo.ipynb0000644000076500000240000272101013536646570022636 0ustar alneumanstaff00000000000000{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "### Table of Content \n", "\n", "- [The Matter graph](#The-Matter-graph)\n", "- [Hide auto transitions](#Hide-auto-transitions)\n", "- [Previous state and transition notation](#Previous-state-and-transition-notation)\n", "- [One Machine and multiple models](#One-Machine-and-multiple-models)\n", "- [Show only the current region of interest](#Show-only-the-current-region-of-interest)\n", "- [Example graph from Readme.md](#Example-graph-from-Readme.md)\n", "- [Custom styling](#Custom-styling)" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "hide_input": false }, "outputs": [], "source": [ "import os, sys, inspect, io\n", "\n", "cmd_folder = os.path.realpath(\n", " os.path.dirname(\n", " os.path.abspath(os.path.split(inspect.getfile( inspect.currentframe() ))[0])))\n", "\n", "if cmd_folder not in sys.path:\n", " sys.path.insert(0, cmd_folder)\n", " \n", "from transitions import *\n", "from transitions.extensions import GraphMachine\n", "from IPython.display import Image, display, display_png\n", "\n", "class Matter(object):\n", " def alert(self):\n", " pass\n", " \n", " def resume(self):\n", " pass\n", " \n", " def notify(self):\n", " pass\n", " \n", " def is_valid(self):\n", " return True\n", " \n", " def is_not_valid(self):\n", " return False\n", " \n", " def is_also_valid(self):\n", " return True\n", " \n", " # graph object is created by the machine\n", " def show_graph(self, **kwargs):\n", " stream = io.BytesIO()\n", " self.get_graph(**kwargs).draw(stream, prog='dot', format='png')\n", " display(Image(stream.getvalue()))\n", " \n", "extra_args = dict(initial='solid', title='Matter is Fun!',\n", " show_conditions=True, show_state_attributes=True)" ] }, { "cell_type": "markdown", "metadata": { "hide_input": true }, "source": [ "### The Matter graph" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "hide_input": true }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAABSoAAAGgCAYAAACtyFkTAAAAAXNSR0IArs4c6QAAQABJREFUeAHsnQW8VNX6v1+7sEAFVBQQUTFRAREMVMIAE8XGbsWOa7fXzms3omJgYGFgU4IKiIGUQSq2IF7nv5/3/tf89hlmzplzzsw5E9/1+ayze+21nj1nZu/vfmORRCLxvKmIgAiIgAiIgAiIgAiIgAiIgAiIgAiIgAiIgAiIQD0SWCQSKhP1eH6dWgREQAREQAREQAREQAREQAREQAREQAREQAREQARsUTEQAREQAREQAREQAREQAREQAREQAREQAREQAREQgfomIKGyvq+Azi8CIiACIiACIiACIiACIiACIiACIiACIiACIiCLSn0GREAEREAEREAEREAEREAEREAEREAEREAEREAE6p+ALCrr/xqoByIgAiIgAiIgAiIgAiIgAiIgAiIgAiIgAiJQ9gQkVJb9R0AAREAEREAEREAEREAEREAEREAEREAEREAERKD+CUiorP9roB6IgAiIgAiIgAiIgAiIgAiIgAiIgAiIgAiIQNkTkFBZ9h8BARABERABERABERCBwiDw6KOP2nLLLWezZs0qjA6VSC/eeOMNO+WUU5IVzpREImE77LCD7brrrgU30jFjxtgFF1xgbdu2tUsvvTTZv+eff96aN29ur732WnJdfIYxse3000+3Vq1a+RjZfuqppybHD4vZs2fHD9O8CIiACIiACIhAgRCQUFkgF0LdEAEREAEREAEREIHqEkCUKaXy999/2x9//GELFiwopWHVaiy5uMajRo2yW265xQW+c88913bbbTfv0z///GNjx461jz/+2JgvpPLbb7/ZhAkTvG9xBpMnT7apU6ca03SFcUybNs0efPBBmzJlii2yyCK+W79+/eyEE06wL774wllIqExHT+tEQAREQAREoP4JSKis/2ugHoiACIiACIiACIhAtQkgyOy444723//+t9rH6oDiIJDra9ytWzdr0qSJrbTSSg5gscUWs6+++soFwUUXLazHgm222cYOP/zwhS4U1pAIlcccc8xC21jBmI488khbf/31fT7stPbaa1vr1q2NdlVEQAREQAREQAQKl8Dihds19UwEREAEREAEREAERCATgfPOO8/eeuutpGtrpv20vngJ1MU1DqJlIVJafPH0jyprrbVWld1FeC008bXKTmsHERABERABERABS//rLzAiIAIiIAIiIAIiIAIFSwAB65prrvH+HXHEEbbmmmvaFVdc4cvz5s2z2267zYYNG2Z//vmnbbLJJnbSSSfZ6quvXu3xDB8+3G666SZ3ocVCrX379rbppptagwYNvF0a/OCDD+zZZ5+1ESNG+Ppjjz3WevbsmTzXM888YwMHDrSffvrJWrZsab169bLu3bsnt9dkZtCgQUadOXOmbb755nbWWWfZiiuuaFdddZX3gzZXWGEFu/32271PYT374BJMqazfv/zyixELkX7fcMMN9sgjj9iQIUOcIXETYRoKnIn5+Pnnn1uzZs2sR48ett9++4XNbv338MMP29JLL+3H3Xjjjbbzzjt7vMTK+lDZNc40/uRJs5zh8zF48GDr37+/PfXUU0kLxNpcs8CaLtTmGmQaApzpL2LlUUcdldxt6NChdu+997pLOHEt58yZk3T7Tu6kGREQAREQAREQgcInEMV8UREBERABERABERABESgiApE4llhvvfUIUJmIrCoTLFN++OGHxMYbb5yIEqQkPv3008R7772XiASdRGQ15/PVGSLHRhZticcffzwxd+7cxNZbb+3ni0TRxCGHHOJNsU9ktZaIxL/E/PnzE1EMwETkepuI4gD69kiISzRs2DARiUaJSBRLRK7qiUj4y9iNBx54wM/x7bffZtzn/PPPT2y33XY+nnvuuSexxBJLOIsotmUiinGZiMRUb4O2QomEx0QUqzARJWjxVVX1++STT05EwqK306JFi8T++++f2HbbbX05SvaTmDRpkrdzxx13JJZccsnE/fffn4jiISYiwdT36d27t2+PktgkIvHS10VCbyISar2/kdjr/a+MXaZrXNn4w3hTp1dffbX3Ydy4cclNUcIiv45cYz5HUVxQ31bda5Zs8P/P5Ooa0Nyrr77qfbv44ou99Uig9M83/f3Xv/71/8+YSERCcGL55ZdPvPjiiwk+B5dccokft+yyyyb3CTOXX365bxs/fnxYpakIiIAIiIAIiEABEcBdSEUEREAEREAEREAERKDICGy55ZYuvsW7HcXm83VRDL/k6jfffNOFmXXXXdfFxOSGKmaihCsuOiI8UZ577jlv5+ijj04eGVkX+rqPPvrI1yEUISJFFoa+HFlXJlZZZRUXOlnx7rvvJhDNMpWqhEqERoTQKFlKsonIOtPPedddd/k6zkEfIqvF5D70nf1Cqarf7Lf99tt7O4hloUQxE31dFB8xMXHiRBczWRcvQdAMQilCMv2JLFpdrP3mm28S1Gz6kHqNsxl/vC9hPp1QGbYFYTcIldW9ZqGd+DRX1yBVqOQcL730kvMMQiUieGQp62Jy6ANiZWTNmZBQGYhoKgIiIAIiIALFQ6CwomZHd3EqIiACIiACIiACIiAC2REIGY3ZO7r9tCeeeMKaNm3qbrGhBZKHRFaAnjQlsqgLq6uckhWZRD1ff/2177vVVlv59Mcff0weG1n32ciRI939GjfxO++807dFQlzyGFxwccXFlbpTp06eeTnZQDVncLGmT3vuuadFIp5XEquss8469vPPP3trnTt3dvf0SORyt2tW4hKMS3ooVfWb/WBG2WyzzXzKH46jkCUb92vc7AMX3xD9wfWbgvs0Jbjc4+6O+zdu+tRs+sDx8Wuczfg5pjplqaWWqrA746ntNcvVNajQsf+/kNrfAQMG+LXv0qVLcvdlllnGIsviCuySGzUjAiIgAiIgAiJQ0AQkVBb05VHnREAEREAEREAERCAzgbiIFbny2q+//rpQAhESknTo0MEb+fLLLzM3lrJlp5128jWRNaJPJ0yY4NMgxLEQuT177Ml27dq5GEjsxXghVmPfvn09xuXuu+/uIh5xEWtaIpdyj3s4atQoC5V+RdaNduaZZyabjVzQjYzZkWu4ff/99/bJJ59YZCGa3F5Vv5M7psyQOZoELcTb5JyU1IQtiHSUwDpsJxt1vGTbh/g1znb88fNUdz5X1yxf1yB1PJ999pmvIv5pvMAtzi6+TfMiIAIiIAIiIAKFS0BCZeFeG/VMBERABERABERABColEBdiVl55ZUOUjOI7Ji0Jw8FrrLGGzzZu3DisqnJKMhcsF5ked9xx1q9fP09aE7k6J48lAQvCZeRy7qIgCXfiJXIbt8gF2qI4l0YfXnvtNYviN8Z3qdZ85MprJLpBsEstkydPTq468MADjWzWUexIu/vuu+3QQw91NmGHqvod9kudIj4igEZu9Lbqqqv65ijeZYXdsmWdbR/i1zjb8VfoUDUXcnXN8nUNUofz119/+ar3338/dZOWRUAEREAEREAEipCAhMoivGjqsgiIgAiIgAiIgAggYOEGjbBEwUIvuCm/8847FQBhfYg7bNheYWOGBSwfo+Q87sJ84oknGkIQmcbjwhnL9CFkuf7999+9NdzQKVjVzZgxw7dHyX38/G+//bbF3cd9xyz/hP5H8Qnd1T0cFiWAsbPPPjssGoIelpzTp0+3Sy+91IXU5MZopqp+x/eNz0fxJn1x1113TVqppmPNTlHyofihC81n04fUa5zt+Bc6WTVW5Oqa5esapA4lZGAnK3u88H+BqKwiAiIgAiIgAiJQXAQkVBbX9VJvRUAEREAEREAERMAJEPsQQfC+++5zy0FcYKOM2i4k3nrrrR4/kR2J4fj555/bueeea1hdZlvOOOMMQ1zEbRqRcuDAgfbyyy+7eBnawIKTQrxFLATPOeccXx4xYoThMo6Iedttt/m6KPu3i3sbbrihWzv6ymr+iRL5WJTd2Z5++mnr1q2bx8Q8/vjj7YADDrAbb7yxQmtYgSL04Y4eZT6vsK2qfsd3JrYmBRE2ym5uWI0eccQRhliJe3yUATwZj5L9XnnlFYsSCLn1KcvE+qSwX7xk04fUaxxlO896/PFzVTaPhSolSlDk01xes9peA9z2KYQ1CCW1v4cddpitttpqhmVrlHXdXfKjLOAWZU23KKmOXX/99TZz5sxwuKYiIAIiIAIiIAKFTqB48v6opyIgAiIgAiIgAiIgAoFA//79PcN3JMYlTjvttERkPeabImEtEbklJyLru8Spp56aaNWqVeLiiy9ORAJUODSraZQYx7MrR/eyFaaRS3Uisor0Nl544YVE5E6eWGKJJRJdu3ZNkP27efPmich6M3HFFVckIgHRsy9HLuQJsmOTiTsSPTOePxKY/FyR+3rGfSLrSc+gHfoVxY1MkNk8XYnETM9Wnrqtqn6zfyREel8ii70EmbGjBDiJKDFRIrIQTTY3d+7cRJ8+fXy8kXu5Z56OhNhEJBr7PlyLSNj0dshWvs8++yQi0c23ZdOHdNe4OuMPHU2X9ZvM8Hvvvbd/hmAZJdFJRJa31b5m4RyZpjW9Brfffrszp2985qIQBIlI9E5EsSidJ1m9I2HSTxuJ6RU4k+Ed7ptvvnkiEu8TUUzRZPcuv/xyP378+PHJdZoRAREQAREQAREoHAKL0JXoBkBFBERABERABERABESgyAiQnZlkLVgrxgtWcSSZIbkOrrEhg3V8n6rmI5HTyLCMCzVWgVin/fbbb27BSXzGhx56yJtYsGCBUXH1peByyzKu5mTFJtM1lnG4pmNpmIvC7SvZyLGYJIkK03QFF3OsSNNtr6zftEXyncGDB7v7OGNfccUVrVGjRulO41amZFTHcrNFixZp90m3sqo+cEy6a5zt+MM5cTPH2pU+YtFaWcn1NavNNaisn+m28Tnjs861wgoTS8vUEgnobgEcCZXWpk2b1M1aFgEREAEREAERqGcC//PXqedO6PQiIAIiIAIiIAIiIALVJ5BJ+CPD9EYbbbRQg5dddpkNGjRoofXxFZGlmu2777520003uUDJOeJJchD+SIoTSmRNadRQcGkObs2IlBRcmHNZEB4jS9Eqm0wVcOMHVNbv+H4IwakZpePbmUfAxC27uiWbPqS7xtmOP7U/ZCuvqqS7ZsR6/O6776xnz54ebgChNFPdf//9rUuXLi5WI8SS7AbhvLJK+5VtZ1v8fIyB5TDNNJ+6neWQ/IjPN0Im1xeeTEONL6fOh893VVOubaZ9eAGAcJ86Df839FNFBERABERABMqVgCwqy/XKa9wiIAIiIAIiIAJlR2D06NFuiVjZwLGE/OqrryxyJ/es33vssYdF7tUeY3H48OEe73LAgAHWtGnTypop+m0dO3b0OIcwa9u2bb2OBytVkhth2ck0XtOti+87f/58I2YoMRsRwhCaqc2aNTO2UbGiDPNhyjpERsRGhMJcFIRARPQwZT5dTbeddYiGlPg003zYL2wnRijjwMoYYbN169YuFjKPUErNZp42gtUw01A5vraFMaYTMFMFTf5Ha1KxeuY4plieNmjQwGv8RUNtx6DjRUAEREAERKC2BCRU1pagjhcBERABERABERCBEiOAWHXllVfaq6++amQMR+DaYIMN7JBDDjES2tTElbxYECFEkSwnig/pIlQU59BOPvlki2JQVjkEEu4ghMUr63CZZxqv2a5DdEQMq6ogcqUTrxC5sJJkGq/p1qXbN1h9VjZFXKtsO58fBMlSLoicQbSsbIrwy/8XInBNp4jImQTquIgd5ulbZYVrF0TLuIDJuvhymCehFe71WF9Tw3yY8jlSEQEREAEREIGaEpBQWVNyOk4EREAEREAEREAEyoAAogjCQ7BMK7UhIyqRSfrnn39OVtycwzoExSAMxQXIdPOZrOpgF7diQ/BJrUEUCutZjlvAxUXIsD6+TuJQqX0yczceBNEgWjINgjmf7VCDoB4E9MrW879Bpd10BeE6iJZhGhc0g1UvoRnCfJiyjs+3igiIgAiIQPkSkFBZvtdeIxcBERABERABERCBoieA0Bhl3zbiL5K4hSnLVJaDAMn6MB+fItCkKwh/UbZpw3qMitAS5uNT1iMqZtrONgTFUhV607HTuvIggFUo/0tB1A8CZlgXXx/WMQ3/n0yxDE0tCJ1BuGQaFzSZJ5kXsVtTq8T6VJJaFgEREIHiJCChsjivm3otAiIgAiIgAiIgAiVFAMHwhx9+WKjGRY1081g2phbcjBEZETWYYtVVncoxiCUqIiAC+SWA2Mn/NS8VUv+/063jO2L27Nm+f6oFMy8FMomYiJokT2rcuHGyYr2sIgIiIAIiUHgEJFQW3jVRj0RABERABERABESgqAlgSYWYEGo6ATJ1XaobKTEXU62p4lZWlc1j3agiAiJQugQQKRE258yZs1Dleyfdeqw54wVhMy5chvkmTZostJ59VURABERABOqGgITKuuGss4iACIiACIiACIhAURIIgkAQHTNNEQbCNqyk4gXX50aNGlWrIkTKXTpOUfMiIAK1IcDLkJkzZy5UZ8yYsdA6RNB4QahcY401bPXVV09OU+dZliV2nJrmRUAERKBmBCRU1oybjhIBERABERABERCBoiVAXEdERR7aZ82atdBDevxhnv3IhB0vuEbjYplNxeUSoVJFBERABIqFAC9bwncjQub333+frCTbCsvsE7Kq82KFFzJB0AxC5lprrWXUZs2a+VTJgorlU6B+ioAI1BcBCZX1RV7nFQEREAEREAEREIEcEyCm2/Tp040Ha6ahploM4XYdHq7pAkkoUuO3BTdIpmxDcAzx35ZYYokc91zNiYAIiEDxEeClD9+zQbiMi5jMU6dNm+aZ1sPoEDPjwmXqfNOmTY04uyoiIAIiUK4EJFSW65XXuEVABERABERABIqCAK7XWO3wIMwDcaoIGRcj43EecUEk1hoPvelirsWFSBLNqIiACIiACOSHAC+RvvnmGxctES5T5xE0g+X64osv7i7mLVq0sJYtWxrTeOU7XWEx8nOd1KoIiEBhEJBQWRjXQb0QAREQAREQAREoQwJkug5WN6lThEnWIURitRMKsdJ4UM1UgziJ1Y6KCIiACIhA4RNApOQ7P4iYU6dOtcmTJycryyH279JLL23NmzevIF7GBU1Cc6iIgAiIQDETkFBZzFdPfRcBERABERABEShYAj/99JNbzWA5E+q3336bFCZ5KI1nocUCEvGR+GYhxtmaa66ZTN7AOrYvt9xyBTtmdUwEREAERCD3BLCs58VVXLxkftKkSb6O35MQzoMQHa1atbJ11123QmXdCiuskPvOqUUREAERyDEBCZU5BqrmREAEREAEREAESp/Ar7/+aoiOQYBMN8VaMhQsXEikEETI1ClJF3i4lDtfIKapCIiACIhAtgQI+4HV5ddff21fffWV14kTJ/p0ypQpSbdyQn4EATMuZrZu3dqU5Cdb2tpPBEQg3wQkVOabsNoXAREQAREQAREoKgJYpZD1moe+dBXXvLglJK7YWD4iRGaq7KMiAiIgAiIgAnVNYMGCBW51GQTMMEXI5DcOa01ekpHUZ4MNNkjW9ddf3+dJpKYiAiIgAnVJQEJlXdLWuURABERABERABOqdAPEesYDkAQ3REWsTpkGUZD4kpSHzKtaOa6+9drKGDK1BlFQ8sHq/pOqACIiACIhADQgQ9xL38QkTJtjnn3/u0zD/22+/eYsIlUHADOIly/wWygugBtB1iAiIQJUEJFRWiUg7iIAIiIAIiIAIFBMBLCLJjJ0ayyssI1KG7KokJeBhixoXI8M8lpJkYFURAREQAREQgXIiwG9lXLwMAiYeBxQ8BTbaaCPbeOONk5VlWWCW06dEYxWB/BCQUJkfrmpVBERABERABEQgjwRwvQ5JBMI0CJFYSM6bN8/PToIaRMgWLVosVBEjV1ttNVmE5PE6qWkREAEREIHSIjB37ly3vBw3bpyNHTvWK/M//PCDD7RJkyZJ4TKImG3atLFlllmmtEBoNCIgAnkjIKEyb2jVsAiIgAiIgAiIQG0IYBVJYoBQiacV5ufMmeNN43aGa3YQIlu2bJmcZx1JaxZddNHadEPHioAIiIAIiIAIVEGAzONx8RIR87PPPvMXh/wOk7xn0003tc0339zatm3rlZeFKiIgAiKQSkBCZSoRLYuACIiACIiACNQJAQL4Ew8SATIuQgYxMmTNXmqppQwBksqDzjrrrOOVeawi2a4iAiIgAiIgAiJQWAQIs8Lve7C8/Pjjj2306NH27bffekd5mRhEyyBg8ruuIgIiUN4EJFSW9/XX6EVABERABEQg7wSmT59uX375pYVMo2Geh5eQtGbFFVdMCpAIkXFBkjiRCtif98ukE4iACIiACIhAnRDAK2LMmDEuWjKlco9AjOmGDRtWEC/bt2/v9wd10jGdRAREoCAISKgsiMugToiACIiACIhAcRP48ccfXYwMImSY8uARMocSeH/ddddN1tatW/s800aNGhU3APVeBERABERABESgxgR+/fVX++STTyoImLiOL1iwwO8R2rVrZ4iWoa666qo1PpcOFAERKGwCEioL+/qodyIgAiIgAiJQMARw4SJRDVlAqV988UVyfvbs2d5P3LCxiIyLkIiTLDdt2rRgxqKOiIAIiIAIiIAIFDYBEuNhbTlixIhkxRuD0rx5c+vQoUNSuMR1fNllly3sAal3IiACWRGQUJkVJu0kAiIgAiIgAuVDAKuGVCGS5birNqLj+uuvX6Gut9561qxZMyWvKZ+PikYqAiIgAiIgAnVKAA+OkSNHJoVLRMxZs2bZYostZhtttJF16tQpWRXvsk4vjU4mAjkjIKEyZyjVkAiIgAiIgAgUF4G5c+d6Rs7x48f7FBcr6nfffecDWXLJJd01OwiSCJHMM11hhRWKa7DqrQiIgAiIgAiIQEkSmDp1qguXw4YNs/fff99jX+IyTrKeuHBJ1vHFF1+8JBloUCJQSgQkVJbS1dRYREAEREAERCANAYLWBxEyLkrOmDHD915++eVdgGzTpo1tuOGGxhQxskWLFm6hkKZJrRIBERABERABERCBgiTw559/utUloiX1gw8+MF7OLrfccu4u3rlzZxcwt9pqK714LcgrqE6VOwEJleX+CdD4RUAEREAESobAL7/8YuPGjbOxY8d6ZR6BMsSPJLM2ImRqXWuttUqGgQYiAiIgAiIgAiIgAnECZBOfMGGCi5ZBvCScDe7ixLbs0qWLbb/99oaAyctbFREQgfolIKGyfvnr7CIgAiIgAiJQbQJ//fWXx5CMC5LMT5s2zdviJps4TdRgIYk4iQuUigiIgAiIgAiIgAiUO4GZM2faO++8Y0OHDrW33nrLhUzcwrfYYosKwiVWmCoiIAJ1S0BCZd3y1tlEQAREQAREoFoEEB8//vjjpJUkguSXX35pf//9txFDEhftjTfe2EXJMCV4/CKLLFKt82hnERABERABERABEShXAgiXiJahkkRwiSWWsC233LKCcLnMMsuUKyKNWwTqjICEyjpDrROJgAiIgAiIQGYC8+fPN+JHfvLJJxUqMZUQHZs3b15BkESUbN26td9EZ25VW0RABERABERABERABKpLgDjeiJZYWzLlJfFSSy3l7uFdu3Y1atu2bfViuLpgtb8IZEFAQmUWkLSLCIiACIiACOSSwKxZs1yMxFIyCJO8ucdKkjf1uGyTmXKzzTbz6SabbKJg77m8AGpLBERABERABERABKpB4LvvvrMhQ4Z4feONNwwLzFVWWcV23HFH69Gjh3Xv3t2aNm1ajRa1qwiIQCYCEiozkdF6ERABERABEcgBAVy3R48eXaFOnz7dW1599dVdiESUDMIkVpKLLrpoDs6sJkRABERABERABERABHJNgOQ8hOJBuHz11Vc91iWeMdzLIVpSO3XqJK+XXINXe2VDQEJl2VxqDVQEREAERCCfBLhp/frrrysIkmPGjLE5c+a4W9C6667rmSXJLomrEDezq666aj67pLZFQAREQAREQAREQATyTOCPP/6wt99+21555RWvuImvsMIK1q1bN9ttt91s5513ttVWWy3PvVDzIlA6BCRUls611EhEQAREQATqiACi5MSJE23kyJE2atQoFydx4/75559tscUWsw022CApSiJM4sJNJm4VERABERABERABERCB0iYwadIkGzx4sFfiW/7111/Wrl07Fy133313I6SPigiIQGYCEiozs9EWERABERABEXAC3377rYuSCJNBnPzpp5/cpYekNoiRoXLzqYyQ+uCIgAiIgAiIgAiIgAj8/vvvRkxLhMsXXnjBCP9DgsRevXp53XbbbeUiro+JCKQQkFCZAkSLIiACIiAC5U0AV22sJIMoyZTMj8SNXH/99f2NOG/FqbhvkwFSRQREQAREQAREQAREQAQqI4BHDveVzz//vFfiXK600krWs2dP22uvvTwhj152V0ZQ28qFgITKcrnSGqcIiIAIiMBCBHDFwWV72LBhyTp58mTfr0WLFhVEyS222MIaNGiwUBtaIQIiIAIiIAIiIAIiIALVJcA956BBg+yZZ56xDz74wJZeemmPZ4loiXipsEHVJar9S4WAhMpSuZIahwiIgAiIQJUEyMAdFyXJxk2WxoYNG1qHDh1sq622svbt27tA2ahRoyrb0w4iIAIiIAIiIAIiIAIiUFsCM2fOdNHy2WeftTfffNNjnpM9vHfv3hItawtXxxcdAQmVRXfJ1GEREAEREIFsCPz555/uXhMXJokLtPjiixtxJRElQ23dunU2TWofERABERABERABERABEcgrgR9//NFFy4EDB3p8SxI1kjl8//3394Q8cg/PK341XgAEJFQWwEVQF0RABERABGpPYNasWfb+++/be++951OsJRcsWGBNmzZNCpIIk1tuuaUtu+yytT+hWhABERABERABERABERCBPBIIouXjjz/ulpbcw5I5/IADDrCuXbv6C/g8nl5Ni0C9EJBQWS/YdVIREAEREIHaECAY+eeff+6CZBAnJ06c6AlvNtpoI+vUqZPXzp0729prr12bU+lYERABERABERABERABEah3AriHY2U5YMAA+/DDD22VVVaxPn362MEHH+xhi+q9g+qACOSIgITKHIFUMyIgAiIgAvkj8Pfff9tHH31kb7/9tltMEnD8hx9+cMtIYksiTCJKYjG54oor5q8jalkEREAEREAEREAEREAE6pnAlClTrH///vboo4/6y/v11lvPBUtEy7XWWquee6fTi0DtCEiorB0/HS0CIiACIpAHAmTjHjFihAuT77zzjltO/v7779a4cWPbZpttkhaTbdu2lctLHvirSREQAREQAREQAREQgeIgMHLkSHvkkUcM93Be5O+www52+OGH25577umZxItjFOqlCPwfAQmV/8dCcyIgAiIgAvVEgMQ3JL1BlMRqknnWrbnmmrbtttvadttt55W3xSoiIAIiIAIiIAIiIAIiIAIVCRCbffDgwfbAAw/YSy+9ZA0aNPAEPEceeaRtvvnmFXfWkggUMAEJlQV8cdQ1ERABEShVAvPnz/fYOm+++aa99dZbbj2JFWXz5s2ToiTiZMuWLUsVgcYlAiIgAiIgAiIgAiIgAnkhQDxLrCzvv/9+mzBhgm2xxRZ21FFHeRKe5ZdfPi/nVKMikCsCEipzRVLtiIAIiIAIZCRAjEncUhAmqcSYnDdvnguRXbp0se23394tJxVTJyNCbRABERABERABERABERCBahN477337O6777annnrKFltsMbeyPO6444wQSioiUIgEJFQW4lVRn0RABESgBAiMHz/e3njjDXv99dfdnfuXX36xNdZYw+PmIE4SP0cZuUvgQmsIIiACIiACIiACIiACBU/gp59+civLO++80z777DPr2LGjHX/88da7d29baqmlCr7/6mD5EJBQWT7XWiMVAREQgbwSmDFjhouSr732mk+nT59uK620kiFK7rTTTl5bt26d1z6ocREQAREQAREQAREQAREQgcoJDB061O644w579tlnbeWVV7ajjz7aRcvVV1+98gO1VQTqgICEyjqArFOIgAiIQCkSIM4kyW8QJqmffvqpLbnkkrb11ltbt27dXJgkHs6iiy5aisPXmERABERABERABERABESgqAlgWHDXXXcZVpY//vij7bPPPtavXz9r3759UY9LnS9uAhIqi/v6qfciIAIiUKcEvvrqK3vllVe88ib2jz/+sDZt2ljXrl1dnCQBznLLLVenfdLJREAEREAEREAEREAEREAEak6ApJaPP/643XzzzTZ69Gh3Cz/jjDNsjz32kNFBzbHqyBoSkFBZQ3A6TAREQATKgQAJb8jK/dJLL3mdNGmSrbjiim4t2b17d+vRo4c1a9asHFBojCIgAiIgAiIgAiIgAiJQ8gTeffddu/766+3555+3ddZZx0477TTr27evLbPMMiU/dg2wMAhIqCyM66BeiIAIiEDBEJg6daoNHjzYKyLln3/+aZtttpntsssutvPOO9tWW21liy++eMH0Vx0RAREQAREQAREQAREQARHILYEvv/zSbrjhBnvooYds+eWXt1NOOcVOPPFEN1rI7ZnUmghUJCChsiIPLYmACIhA2RH4559/bPjw4fbiiy/aCy+8YGPHjvWbEdy5gzipwNpl97HQgEVABERABERABERABETAZs2aZbfccovddtttlkgkPOnOqaeeaquttproiEBeCEiozAtWNSoCIiAChU0AK0kS4ODSgTg5e/Zsa9GihfXs2dN22203I9YkiXFUREAEREAEREAEREAEREAEROCXX37xTOE33nij/frrr3bMMcfY2WefbU2aNBEcEcgpAQmVOcWpxkRABESgcAnMmTPHRclBgwbZkCFDjPiTHTp0sN1339169erlSXEKt/fqmQiIgAiIgAiIgAiIgAiIQH0TwODhnnvusWuuucbmzp3rguVZZ51lTZs2re+u6fwlQkBCZYlcSA1DBERABNIR+Oabbwxh8plnnjECYy+xxBKeCAdhktq4ceN0h2mdCIiACIiACIiACIiACIiACGQkgNEDguXVV1/tguUJJ5xg55xzjjVq1CjjMdogAtkQkFCZDSXtIwIiIAJFRGDy5Mn21FNPeR0xYoStsMIKHmtyr7328mQ4DRo0KKLRqKsiIAIiIAIiIAIiIAIiIAKFSgDB8q677rIrr7zSk3CSJfz000/3mPeF2mf1q7AJSKgs7Ouj3omACIhAVgS+/vprGzhwoNfRo0dbw4YNbY899rC9997bLSgVbzIrjNpJBERABERABERABERABESgBgR+//13u+mmm+y6666zxRdf3M4//3xPvINHl4oIVIeAhMrq0NK+IiACIlBABKZNm2ZPPvmkPf744/bRRx/Zqquu6uJk7969rUuXLn6DUEDdVVdEQAREQAREQAREQAREQARKnABxK3EHJ1P4Gmus4ZaW++67b4mPWsPLJYFFc9mY2hIBERABCIwZM8YuuOACa9u2rV166aVJKGSYbt68uWebTq7M4UxV7ScSCT83rgitWrUyloutzJo1y2677TbbeuutnSUuFptttpmPa/r06Xb33Xdb165dJVIW24VVf0VABERABERABERABESgBAisvPLKnmjniy++8GeWPn36WMeOHW348OElMDoNoS4ISKisC8o6hwgUKIF8CXW//fabTZgwwT7++OMKYiCxE6dOnWpM81Gqav+ff/4xrBAffPBBmzJlii2yyCL56EbO24TnI4884vElV199dTv33HNtnXXWsRdffNFmzpxp9957r4uTiy22WM7PrQZFQAREQAREQAREQAREQAREoLoE1lprLXv44Yfd82vppZd2sfKQQw6x77//vrpNaf8yIyDX7zK74BquCAQCiHY77bSTDRkyxPIhcL300ku266672sUXX2wXXXRROK0Lhfxo5asgRFbVfqdOnWzUqFE2f/78fHWj1u3+97//tTfeeMN/3J999llbsGCB9ejRww488EDr2bOnLbvssrU+hxoQAREQAREQAREQAREQAREQgbog8PTTT9sZZ5xhs2fPtn/961+ecEdx9OuCfPGdQxaVxXfN1GMRyAmB8847z956660KFo85afj/N0IA5XSlKhEx3THVWZdN+4suuqhRC7GMHz/ezjzzTGvWrJl1797dJk2a5AGpZ8yYYbi277fffhIpC/HCqU8iIAIiIAIiIAIiIAIiIAIZCZDkE687vMMuv/xy22STTdwwI+MB2lC2BNIrCWWLQwMXgfIggEh5zTXX+GCPOOIIW3PNNe2KK67w5Xnz5nkMxGHDhtmff/7pPyAnnXSS4XJc2/L5559b//793eLxqKOOSjb3119/2c0332zvvfee/fTTT9auXTtbe+213dKT+Iu33367YWFIkhh+4AjOjFs55eSTT/bYJ8xnan/o0KHuHo1rOHEz58yZU1Bu34yZhDgPPPCAjRgxwmNPwufggw/2WJqMTUUEREAEREAEREAEREAEREAEipkALuBYUx500EF2yimnuIcfMSxvvPFGa9KkSTEPTX3PIYHCNCnK4QDVlAiIwMIEdt99d1tvvfV8w2GHHWa9evXy+R9//NHat29vL7/8srtrI2g+9thjtuGGG9r777+/cEPVWEM7ZHvj7RlxKkMh/uK2227r1p3333+/3XnnnS5CIkB+8803LkJuueWW9sQTT9i4ceP8sLPPPttWXHFFX4c4ScnUPrEdGd/+++9vr7/+uq222mouaBZCfMq3337bxcimTZu660Pr1q39rSJWlJdccolESr+y+iMCIiACIiACIiACIiACIlBKBDBKGTRokMfcx0Bmgw02sPvuuy9v3n6lxK4cxiKhshyussYoAikEOnToYMsvv7xbFW6//fbGMgUBEDEQy76NN97YiOVI4hks/hA0sXysaTnggAOSVpzxNhAuyQB3yy23WKNGjfxH6vjjj4/vYm3atKmwjMiIpWW8pGv/hx9+MKxBd9ttN4+Xucwyy7hb9QorrBA/tE7nsea89tprXSiGPdnwsCYlYzei6g477FBQ1p51CkcnEwEREAEREAEREAEREAERKBsC5DTg+fPwww+3Y445xp+FJk6cWDbj10DTE5BQmZ6L1opAWRCIWxWSARyrRaz74nEet9lmG1tuueXsq6++Slo01hTOUksttdChd911l62xxhoVrAexlqxJSW1/wIAB9vPPP1uXLl2SzSFWIsLGx57cmMeZMWPG+A8wsSevvPJKz9KN+zqu3kcffbTVp3iax2GraREQAREQAREQAREQAREQARHISIBnzeuvv96wrJw7d65tuummduutt8q6MiOx0t8gobL0r7FGKAIZCcTFulmzZtmvv/66UJIZkuIEi8svv/wyY1s12fD999+7teY666xTk8OrPOazzz7zfVq2bFlhX8YdH3uFjTleePPNN12U3HzzzW3kyJF200032XfffedxQPkRVhEBERABERABERABERABERCBcidAuC+el8gMftppp3n8ymnTppU7lrIcv4TKsrzsGrQI/I9AXKxbeeWVDVHy22+/rRBDkj2xeKQ0btzYp7n+M3r0aPv7779z3WzSVb228TVr0jHiYXbs2NF23HFHTwT02muv2dixY92lYdlll61JkzpGBERABERABERABERABERABEqWwBJLLOGx+j/88EMPjUW4r2eeeaZkx6uBpScgoTI9F60VgZIngEhJJu0gEC655JLJuI/vvPNOhfGPGjXKcJlOjQtZYacaLOBmjmhHQh3OEcr8+fPDrE8RUCm4cYcS+v3PP/+EVQtNN9lkE183ZMiQCts4trLjKuxczQVcFnA179q1q6200kruwhCsKqvZlHYXAREQAREQAREQAREQAREQgbIjgHXlRx99ZL1797a9997bjjvuOJs3b17ZcSjXAUuoLNcrr3GXPYHVV1/d436QXY1s27hJ33DDDe4STUyQ8ENAhm4ya5977rmG1WW2BbduCi7lofzyyy8+G0z4EUuPOuooX3fQQQd5jMznnnvOyDYeL1gmkvynf//+3tf//Oc/dtlll/kuL774YtICNLV9EgCR5fu9996zs846ywjM/PDDD7t4+Mcff3gslJkzZ8ZPVeN5xkRCH/qKAPzuu+969vTgNl/jhnWgCIiACIiACIiACIiACIiACJQZAQxlyGcwcOBAe/zxxz3R65QpU8qMQnkOd7GLo1KeQ9eoRaC8CWBR+Oyzz9rgwYONGJEHHnigrb322kYsRcS8J5980ohJef7559vJJ5/s07ireGX07rjjDrv00ksN4ZAkPMS+ROy85JJLPEAyPzBkEsfqkMzi48ePd/HwqaeesgkTJljPnj0Nq87OnTt7bBJcACi4UyNk0vcTTzzRcAlo3769rb/++j6W1PbJIte9e3cbOnSoPf/880a/fv/9d6M9EgYRI7Jdu3a29NJLVzacSrdh/Unm8v3339/HifB7zTXXVEhIVGkD2igCIiACIiACIiACIiACIiACIpCWQJs2bdyykkSp1113nXv5tWrVKu2+WlkaBBaJMv0mSmMoGoUIiEB1CcyZM8eT5zRs2LDCoVgEIhgiMOI+TSa2fJfp06fbYost5haQL7zwgvXq1cvOOeccu+qqq5Knpj+4bWPZyZSvryBiJnfKMIOFJ+MgozhWnlha1rYQd/KEE06wGTNm2EUXXeSCLi70KiIgAiIgAiIgAiIgAiIgAiIgArkjgEfcMcccY4899pj9+9//ttNPPz13jaulgiLwv8BvBdUldUYERKCuCKyyyippT4VguNFGGy20DXfrQYMGLbQ+vmKFFVawt956K74qq3niVVZVcP8OJcStDMtVTXF1D6W2IuWPP/5o/fr1s0ceecT22msvH++aa64ZmtdUBERABERABERABERABERABEQghwTIbcDzF3kTCOtF6DJCgslQJIeQC6QpCZUFciHUDREoBgK4UuNmXVkhlkg2BatNXMkXXXThULlff/21N/Hnn39m01Sd7oO7PMGcEXNxJ8dNXUUEREAEREAEREAEREAEREAERCD/BLCkXG+99Tw/wKRJkzw0GMYyKqVDQK7fpXMtNRIRKCgCCJHjxo3zOJIff/yxEZdy8uTJNnv2bMNsP2T25s1YgwYNjB+X5s2be2ZvYmOS4RsXb1y/MfGv74Lb+UknnWQPPfSQ9e3b12688UbP6l3f/dL5RUAEREAEREAEREAEREAERKDcCHz66afWo0cPa9Kkib3yyis5Ce1VbgwLdbwSKgv1yqhfIlCEBBYsWOCZrsnMRpxJxEYEyLZt21rLli1diOSHBHGSSozJ3377zSv7YklJYh2Eyrlz53o8yR122MGDJ++zzz5Zx6PMNboPPvjAyEpOX0mWIyvKXBNWeyIgAiIgAiIgAiIgAiIgAiJQPQIYwnTr1s099cgfgOGLSvETkFBZ/NdQIxCBeieAteFdd91lN910k5EUh0zee++9t+24445GlrZ07t1VdZos4a+++qq/HSPbN/E0jz32WM/23ahRo6oOz8l2hFQyeF9wwQX+A3j//fdb48aNc9K2GhEBERABERABERABERABERABEagdgZkzZ7plJQlTESs33HDD2jWoo+udgITKer8E6oAIFDeB/v372xlnnGHEkzzqqKM883WzZs1yOqhvv/3W7rzzTrv77rvtn3/+8Sxvhx12mL85y+mJYo2REf3ggw+2N954w66++mo77bTTYls1KwIiIAIiIAIiIAIiIAIiIAIiUAgE8M7r1auXjR071gYPHmwdO3YshG6pDzUkIKGyhuB0mAiUO4GffvrJhbyXXnrJY0hefvnl1rBhw7xiwXLzwgsvtFtvvdU6d+5sTz31lFta5vqko0aN8mzeWII+8cQT1qFDh1yfQu2JgAiIgAiIgAiIgAiIgAiIgAjkiMC8efNs3333tTfffNM98/DyUylOAhIqi/O6qdciUK8EJk6caDvvvLNbUT755JO29dZb12l/SM6z1157uUUlb8yqykRenc498MADdvzxx9u2225rAwYMyLv4Wp2+aV8REAEREAEREAEREAEREAEREIH0BP7++28XK/GKI3xYu3bt0u+otQVNYNGC7p06JwIiUHAEJk2aZF26dPGM3KNHj65zkRIgm222mQ0fPtwzvGFZiXBa20KW8lNOOcUOP/xw69evnycFyreFaG37rONFQAREQAREQAREQAREQAREQAT+R2DxxRe3xx9/3HMmdO/e3T755BOhKUICsqgswoumLotAfRHA9XqLLbbwbNxDhgyxlVZaqb664uclLuZ2221nv/zyiw0bNqzG/eH4/fbbz95++2178MEH/S1cvQ5MJxcBERABERABERABERABERABEagRAdzAd911V49ZyTPeBhtsUKN2dFD9EJBQWT/cdVYRKEoCffr0saFDh9qYMWOsadOmBTEGsoy3b9/e69NPP13tPk2dOtV22WUXmzt3rj333HNyD6g2QR0gAiIgAiIgAiIgAiIgAiIgAoVF4Pfff7du3brZlClT7J133rF11lmnsDqo3mQkINfvjGi0QQREIE7glVde8cQyjzzySMGIlPQPwfT++++3Z555xl577bV4l6ucx3V9q622siWWWMJGjhwpkbJKYtpBBERABERABERABERABERABAqfwHLLLefhvFZffXXbcccdDQMXleIgIIvK4rhO6qUI1CuBf/75xzbeeGNbb731XBCs185EJ+ft2Pjx4+3HH390S0isIW+77TZbsGCBbbPNNvbDDz/Y7NmzfXubNm3S9hnhtXfv3taxY0fDEnP55Zev72Hp/CIgAiIgAiIgAiIgAiIgAiIgAjkkwDMjyV8bNGjglpXLLrtsDltXU/kgIKEyH1TVpgiUGAFEPbJ8f/bZZwUR34NYmVhSIlgussgiRtBkphSS4lAprDv//PPt0ksv9eXw57HHHrO+ffvaAQccYPfcc49bVIZtmoqACIiACIiACIiACIiACIiACJQOga+//to96UjEipHKoovKubiQr66uTiFfHfVNBAqEAGLetttuWxAiJUiwfjzssMNcoEwkEm5J+ddffxk1iJTsxzbiksQLlpcHHXSQZ/gmcQ5u3yoiIAIiIAIiIAIiIAIiIAIiIAKlSYD4lM8++6y7gp955pmlOcgSGpWEyhK6mBqKCOSDwN9//+2xH7E+LKRy0kknGX2rrGDWTwzKUK644grjuCuvvNKuvfbasFpTERABERABERABERABERABERCBEiaANSW5DW644Qa78847S3ikxT80CZXFfw01AhHIK4ERI0bYb7/9ZjvssENez1Pdxlu3bm077bSTLbbYYmkPxZyf7biFUy655BK74IIL7D//+Y+dc845aY/RShEQAREQARGoigC/iSSW22+//WzllVdO7o4VP7+Vu+66a3JdLmeyaZ99SCx3+umnW6tWrdyzIJd9UFsiIAIiIAIiUMwEML7hufDEE0+0V199tZiHUtJ9/98TfEkPUYMTARGoDYFPP/3UVlppJVt33XVr00xejj311FPt9ddfT9s28SmJq0m58MIL7fLLL7e7777bjjzyyLT7a6UIiIAIiEDpEUC4CzGMczW6X375xebPn+/uY8RMDoXEc2PHjrUll1zSmM91/Kts2mefadOmGaFNfv7555yPPYxVUxEQAREQAREoVgI8G3711VfWp08f++ijj6xly5bFOpSS7beS6ZTspdXARCA3BLA+5G3TmDFjctNgDlvhAbR58+b+UJau2UmTJnmynGuuucbuvfdej2uZbj+tEwEREAERKD0Cb7zxhmf3xHIiH6V9+/Y2cuTIClaLP/30kwuUK6ywQj5Oadm236lTJxs1apQLqnnpiBoVAREQAREQgSImMG/ePOvYsaO/0Pvggw9s6aWXLuLRlF7X5fpdetdUIxKBnBKYOXOmZ9jOaaM5agwrmdNOOy2t+/faa6/tsUcQKYlFQvIdFREQAREQgfIgMHXqVMO9K55gLdcjD6FF4u3igZAvkZLzZNs+1py5tuiMj1PzIiACIiACIlDMBBAmn3rqKcOw5eSTTy7moZRk3yVUluRl1aBEIHcEcCPLFAcyd2epeUsIkKmZu1lu2LChXX/99fbQQw/ZoYceWvMT6EgREAEREIGiIvD111/bNttsY7NmzbJBgwbZ4Ycf7paPYRDDhg3z2FTEMeY35IknngibajX9888//aFnzz33XEggJd7zMcccY9ttt53tvvvu7pq977772oIFCwxLjgMPPNBd0J5++mnvw9VXX+3LuKWxnVJZ+0OHDrWDDjrIsKQk7tacOXPk9u3U9EcEREAEREAE0hMgE/gDDzzgHngPP/xw+p20tl4IKEZlvWDXSUWguAjgYl2oBcsVHkLvuecef+Cjnzz4ffzxx/boo4+6RU2h9l39ykyAB/Lff/89Wf/4448K82wnRly6+tdff7lIQFZ4rKmo8fl08erCOiykqIjz8SnzvHldZpllvIb5TFP2C9vIPk/MOhUREIG6IdCgQQM77rjj7LzzzrN27drZIYccYmuttZafnIRq/fr1c4v7M8880+64446kQPjkk0/WuIOzZ8+2M844wx577DH/von/bvbv39+OP/544yHopptuMpaPOuoo34+kPFtvvbUNHz7cPQQ22GAD23vvve3ss8+2Y4891mMrd+vWzeNEZ2qfNk444QQbMGCAJ/O59tpr7fPPPze+e1REQAREQAREQAQyE+DlIgnouG9o27atbbzxxpl31pY6IyChss5Q60QiUJwEVlttNfvss88KuvMnnXSSP2zGO3njjTdKpIwDqeN5LHF/+OEHrz/++KNR586d69P4MskeSExBjc8jNmcqiIoIfwiB8elSSy3l67CoDSJjquCYzhUyCApM46Im4mYQOOkPsWyoiKRhilAajs/UX9bTz+WXX94rIkqYR2hfccUV3VWUKW6dYco8GYXDlGOCoFrZubRNBMqdQOPGjW2TTTZxDC1atLDtt9/e57G0JFwIlochHAjhQbCwHDhwoFs59u3b1/et7p9VV13VLfgRCLGeDIXwKYiUPXv2dEtK1pPU7ZZbbvHEO2G/Nm3ahFmf8r++2WabJddlap/vWX4Dd9ttt2S2cQRYPAr4/lIRAREQAREQARGonABeDLww3GeffTy+M/fcKvVLQEJl/fLX2UWg4AmsscYa9t133xV0P9dff33r0qWLDY1c3xCNiE95yimnFHSfi7FziHUzZsyw6dOnV5hiSYSLZXzKwzNiZbwgJOKSHyoiHJXrFcQ6hLsg3i233HIWr1gHscy0UAQ7Pm+IlXHxMoiYYR2WoWQGpv7222/JeZYRaL/55pukUEuiDARbLEhTC6JrYMa0UaNGSZYwDctMQ11llVXyGi8vtY9aFoFCIxD/rsANnP/PrbbaqkI3e/To4Ul3nnnmGaupUBka5HsuXrBy5P88iKVhG995NSnp2uc7g9/AULDoxiIEzwIVERABERABERCByglg4EAYGF4Q8gxJfgOV+iUgobJ++evsIlDwBNZbbz0XprCCQwwp1ILr3FtvveUCFnHAVKpHAGHx22+/XagiUgdxkn3i1oNY+jVp0sSwusXaB5fFbbfd1ufDuiCe8dkpRTdERBAsO6m5LIjCiJZYoYZpsEgN02CZStIQ5rk+TFOtUbEwjQuXzCNghppuuaYiSi4ZqC0RyAWBuFA5ceJEbzLVsrpz586+/ssvv8zFKSu0ETwSiIOVjxLab9myZYXmGXd87BU2akEEREAEREAERKACgdVXX91Die2xxx7uAUE8aZX6IyChsv7Y68wiUBQEiO9FwZUt1SKkUAbw9ttv23XXXefWdlivde/evVC6VhD9QLhChETQSlcRI7H+CwWRas011/RKXLcOHT97e2wAAEAASURBVDq4INm0aVPPAM8UgTLX4lw4v6bmCaIQf6nVLVhqIlqSTINpmA/LTBFscHFhnopVaLwEcRMxMy5kxudTt2EJqyIChUYgLtaF/6f33nvPjjjiiGRX8Ryg4DKer8JvaNzqMVfnISYv5f3337cdd9wxV82qHREQAREQAREoOwKIk3hWHH300R4/Otw3lB2IAhiwhMoCuAjqgggUGgGs5niQe+GFFzzbKG5kO++8c6F1c6H+ILbwUEpSASwsidmFuBp/UF3ooBJYwfXCHXvSpEk2efJknzJPnTJlin3//fdJN2zERcRH3K1D7LYgSoYpMRRVipdAiH/ZvHnzrAeBwB9ES6ZxcTMsf/XVV/bhhx8mBdBM4iZiZmoNrulhfVjGhT3VlTXrTmtHEaiEQPjej39OeelCeeeddyocOWrUKF/mdyPXpVWrVt4kFv8kyAkl3i/W4XZGwY07lBBjMjWMRtjONMTiHDJkiF144YXJTRxb2XHJHTUjAiIgAiIgAiKQJHDzzTfbm2++6WLls88+m1yvmbolsEj0gFu46XzrloXOJgJlT4AHG2JyEIQfFzjcvnfYYQfbaKON3LKrkC3o+CrDJfbee++1TTfd1N3AcYnDHe7UU0/1H5tcZ16uS3d4krxgDYlYRMUijhrESeKuURB9EKgYN5V5RMlQ82kxVPb/QGUGgHibQcQMImew4Ew35f8Fa8/UQkgAhEsqwmV8Ph6TMyQVYl2Yx/JTRQTSESA+I9k7t9hiC8/wjThJIp2uXbva66+/bk8//bTttddefujhhx/uL+b43ePzlW3h+5XvZWL0BqsL4lt98sknRuIevoN5UbTuuut63Fl+i3bddVd799137ZJLLvHT8N3N9zZxabFU58XgVVdd5VbOF110kcf+xcKDBye+x1Pb538KMZQ+kEQHK5APPvjADj30UG8fbwOSB+m7P9urqv1EQAREQATKnQAvF/FSeOCBB5K/p+XOpK7HL6GyronrfCJQoARwn+YBBws8sqFilUgw/mIriJXhQXPChAmeDRzxkrgjd955pz+k1nZMCDT9+vXzB9CXXnqpts0lj0dsJbHKF1984TUIkky5LiH2IFZpPJhSiXvGwzDWkUxxYQyWRMmGNSMCBUKAz3AQMREuqakxN+PLIT4nU8T61ILISagCKuJlfBrWBwtTXNPj8/FlEhWplBYBXKIJXfLpp5+6FfngwYP9pRufpeOOO86ee+4523fffY392Ies38TZzaYQLoM28DqgEJv3rLPO8gcaEvLwXU7Cnttuu82F0ueff94OOeQQt5bkc8dvLNYaY8eO9eQ+waoYgfLyyy/3PhHCZM8997Rzzz3X9t57b/cQ4IEpXfv0f7/99jMyjvNZ3mmnnVxA5f8DkRIhlv8HFREQAREQAREQgewI8KzH7y6/1XijqdQtAQmVdctbZxOBgiPAwz/uYjwg4Sp9yy23uBVewXW0Fh0iPiOWLE899ZRP//3vfyfd7KrbLJYq+++/v02bNs2tYHDTCw+Z2bZFBtggRsanCJIhViRiJFY4iJGp0yDEZns+7ScCpUAAyzFETGpcwOR/kMq6+JR5/tc4jinu7ZkKgg4iZhAvmRICgUqm+UxTjqusVve7IVP/tL5mBHB9xuIRS8TUBDoI5uPGjfOHD1705Lsg0mMBz3c6YiKWnqNHj64gVNIHPq94N/A9zxTRM1vLYaw3+bwiSmJhSVIzFREQAREQAREQgeoT4Jls88039/uEV199tfoN6IhaEZBQWSt8OlgEipsALmdYYbz22mtu+RFPLlDcI0vf+/79+xsZwTt16uRWKTzQZVt4yMRV78orr/QH3mDdhQthpgQG7IP4iBsgFi+hInJScEXHIhIX+9SKUKkiAiKQOwKIVkG0ZBqfjwuaYT2W01QEztQp66hVxQBEHIsLmbj1huVM83wvhX2YZrOcKsLljlp5tYS4l0085jPOOMNfWNWGTiahsjZt6lgREAEREAEREIHcEcBApXPnzsYzJIYqKnVHQEJl3bHWmUSgoAjg7kasLCw6XnzxRevYsWNB9S9fnWG8PIi2bt3aBVrEgqoKLuQIuuPHj68gTGDlglsAFpoUrFn4QSPhCFNipCEGkySB85H0gPiZuNSvv/76brkql9Oq6Gu7CBQuAf6/iS1YVeWtfNgnPs+61GXWIYLG96+KAPGDETQz1SB4hu2ZrEVTLUc5rpxCSZDgBjftqsqWW27p4Taq2i/TdiwlmzZt6jFesRAmbIGKCIiACIiACIhA4REgNBqhXgivojAqdXd9JFTWHWudSQQKisABBxxgxFccOnSoB+cvqM7luTMIj9tss42/ISObW6YHcVzubr31VsN6hnkeLlMLsS+JT4YwiaUkwiNCJMJv+/btXZzccMMNq+0ennoeLYuACJQnAb57EDPj4mXqPMupNQieqetZjluI8tIqU+G7EXETARPX+CBwVrYc4oBmmobs1pnOWerrP/roI7v00kuTgijxJB9++GEXLkt97BqfCIiACIiACBQbAeKpY2Cyzz77eO6DYut/sfZXQmWxXrk66DcPMog4WNvhGsxb/1CwODj55JPt7rvvtm7duoXVOZnyUIYrLZZuBL9PV9hnyJAhRrwIAuLjXptJbCI4Pn0kY2ZdljFjxrh7MfwIiE8cyEIpiG/EbHzllVc86H6h9Ksu+/H+++9bly5d3J2bZAWphbiWBx98sJFkiM9bZYV2yI6+9dZbuzjJQ7yKCIiACBQDAcJapIqXYZn7gHjFLb6qZfZBWM1UsP6Mi5jEA02tbE9dxzKWDGGKgFqMBWEYETleGK+s6+NENC8CIiACIiAChUPgkUcesb59+7rXHIYoKvknsHj+T6Ez1AUBhJRMQl1Nz0/MLtygXn75ZY/lFW9n8uTJHqCeaa4LMb/IrkX8PubTxd5iPdZrDz74oCdPqGzswa0u1/2sqj0e5rDcw/13jz32qLB7Pq5XhRNUsjBx4kQ7++yzXTjFkqNcC3EqSSB03nnnWa9evQyrx1Aef/xxO+qoo9xtuyqRks/noYce6jUcr6kIiIAIFAsBQljgepxL92Pi8yJYZlO51wh15syZFRIgsR7RNF1B2AuiZVzAZD7U1EzwYZxsZz6b0B/pzl2bddzbUFVEQAREQAREQASKgwDGK2QAJ9fBqFGj9HKxDi6bLCrrAHK+T4Foh+CEhWE+3sjz1mDkyJELWZUhFK611lp5GR7ZWxGAeAiprCA28WWBoJqpNG/e3Lp27Wr33HNPpl3yth7XauJAXnzxxXbRRRf5efJ9vaoazO67724IzMRqLHcXPK4FLtpYs5AUB6vhY4891p588smqMCa38z+HKwDipooIiIAIiEBuCQTRE9EyZHJnmmme/biHiGeBZx3f96kFkZbs2oiW2UwbNmzo+zHl/qSyl6Sp59KyCIiACIiACIhA8RL44osvPKTX1Vdf7Z6JxTuS4ui5LCqL4zpV2ksswt56662FhMRKD6rGxkxiVr5ESrrGQ0M2BTEzncVlNsfWxT7p2OX7elU2LkRd3Paxkk3Xt8qOLcVtfHauu+46jzF5/fXX+/yMGTOqNVQeonGh5yG4kD+L1RqUdhYBERCBAiHAy6BgCVnTLmEZj3Un4mZcwGSZF1Ssi095GIkvI3SmWteHfiFwBgEzzDdq1MiorE+dso9+K2p6JXWcCIiACIiACNQPgfXWW8/OPPNMN0A66KCDbNVVV62fjpTJWSVUFvmFRvS65pprfBRHHHGErbnmmnbFFVf48rBhw+zRRx/1DFXNmjWzHj16eObiXAyZrFf9+/d3i0pcZEMZMWKE3XfffX5OHiyIzYhVIftilXn77bcbwk7v3r1t7733Nt5I4BpNIeYlMf5w1SY2Jcc89dRTFaxESfxy7733ukVg27ZtPWNmbSwaePAgCQqB7PniGT58uGf1Wm211bw/LVq08DidxOpE2DvllFNs8803D8P16aBBg4yKyxrbzjrrrIwZwSq7XhUazdMC/Mk6zWdB5X8ESKrTrl07e+ihh+ywww7zh1MeUGfPnm0//PBD8mEVV/50Fjl8/njYxUKVTLAqIiACIiAChUWA72ksIKncD1W38N3P9zwB9fl9qGw6btw4387vB/ulenzQF+6PEDBXWWWVhabxdcyH5Xx4zFSXg/YXAREQAREQgXImQF6D+++/38VKnqtV8kdAQmX+2NZJy7jxPvPMM8bbf0SWEG/pP//5j/Xr18/uvPNOF+DuuOMO69Onjz399NPVcmtNN4jHHnvMBUbiSP7rX/9K7oKwePzxx7vod9NNN7nQiIhJpmQC0CJCIgSedtppRoIbhEpiJeJqG5LyrLvuup5hmXNwXNyCgTZOOOEEGzBggCcuufbaa10QXXbZZZN9qO7Mv//9b49TyAMIIivCJFmc+eJBnNxkk01cKCXZAFZzJO/5/vvvk9YQF1xwgb377rsuDhOPkvHDmEQ64VrE+5TpesX3ydc8Afzp25VXXpmvUxRtu8cdd5xR+TxXlqABixweUkMNVjgsq4hAIFDIibRCHzUVARHIngAWkFhCUqtbiLGJYBmEy/h0zpw5vp4XY9xDsI113JPEC+Im58Z6I1QEzDDPlBesobINt3YVERABERABERCB3BHgOfGyyy5z/eKkk07ybOC5a10txQlIqIzTKML5Dh06eHw9bmK33357H8HXX3/tYiAmyYiXFKwusbAcOHCgPRgloOkbZa2qaTnggAP8hnmXXXZJNoE1ISJdz549DTGOcuSRR9ott9ziiXHCjm3atAmzPqXfm222WXIdN9tYtmGxiXAYCjfvfBnstttuHvOR9VhA4q6LoFnTglA6a9Ysu+GGGzwZCuIuhYcErFGxjuS8FJjRN7JB4/aOJSjJWIj3iIUG8TKxAEXMRFQ9+uij/bj4n3TXK749n/NkuUZo4xqpVCTA5wqLZEIoMJ+phEy1+Qx7kOncWl89Arzk4PulPkplibTqoz86pwiIQP0R4KGGWh1LTu5rgmiJcImQGWpYnjRpkr/8Dcu8UA0lLmwG8ZJp48aNk7VJkybJ+cpe0IU2NRUBERABERABETDXV9A40CJeeOEFIckTAQmVeQJb183GH8hxQ543b55ttdVWFbqBu+8777zjFpi1ESppdKmllqrQNlaOxHAKYmnYSGbNmpR07SMedunSJdkcFosbb7xx0nU8uaGaM6GPtBUKMSgoWFSGsv766/vs1KlTXahEyMSNHff2ULCcWGeddRayhgjbwzR+vcK6fE+x8uLBZO211873qYqufQTyli1buiVsZUJl0Q2sTDuMm2Y+E4xVhZVwArwUwIJZRQREQASqS4BQM0FUzPZYLPx58ZqpfvbZZ/4yjhfLqV4ACJWcL4iXTZs29fnUKfsovnW2V0T7iYAIiIAIlCKBkOOgW7du9uabb7qnZymOs77HJKGyvq9Ajs4fF74mTpzoraYGa+/cubOv//LLL3N01v9rhhtgCiJdPkpoHzEpXhh3fOzxbbWZX3rppRc6PLhRBasF3O2Jd0WCmuqWfPS5qj5g+YlrvUp6ArCBkUrxE6jPhFWBnh7mAwlNRUAE6oJASDjUunXrKk9HKBgETZLHIVzGK+uIs/n666/b9OnT/aVLaJB7F9zKETAJkxNq6jKCp74DAzVNRUAEREAESo1A165dPefDGWec4VpAqu5SauOtj/FIqKwP6nk4Z1z4wjqM8t5777k7azjdGmus4bO8Ec9XwV07bvWYq/NwU03BfXnHHXfMVbO1aofYmFiRIlgGC8zQIIIX8S4zlfj1yrRPrtfT12A9muu2S6E92KTGBSuFcZXbGCpLWJWLBGNYJj/xxBP+gN68eXN7/PHHbcqUKR4ygFASlSW8wIqJ8Btvv/228cKoffv2HpajQYMGyctEzGH2wTqKFzO9evWy7t27e4w7zkUbhxxyiN16660eImPfffe1/fff3/tAbF/iABOG4pxzzkm+xMnmvMkOaEYERKDkCSy55JKefJEEjFWVP/74wwVLBEyEyzAlXjehcLjvYz2u6qFwj4OrOfednINpamU9L3tVREAEREAERKAYCVx33XWepJaQb4ceemgxDqGg+yyhsqAvT3ad44YQF2RiGvEGmziIFNy84yVY/pHUJtelVatW3iQx/nhYDyU122V4wx4XhEKMyXQZlUM7wQV7yJAhduGFF4bVPubKjkvuWM2ZeBKfTIcSW/PJJ5/0BCwIC0F8JIs4yYTYlq6kXq90+1S2jvEi1iJOkJCIzKHZFDhXJqJk00Yp7wMbQiaoFDeBTAmrcpFgDIGRZGBkeCexBWEUNt98cxcMP/zwQ39oJ3FZpsL/LHHlxo8fb1999ZV17NjRrZUefvhhP4Q2SECGiIkrJmEIsCbnPMRQ5buFOHfEwuWF0DfffGMHH3ywvfzyy96nbbfd1mMRDx482F9KEDeYUtV5fSf9EQEREIE0BHgpi7dMVR4z3O8hWCJghoqQ+d133/n3GPdvzP/555/JsxD3GcGS7zVqmA9T1rGPigiIgAiIgAgUGoENN9zQDj/8cM8ATg6P4H1ZaP0s2v5EgoxKkROIHswT0QcwEWX4Ttx3332J6CE4EcVn83VRjLTk6KLEOonIZScRZZ9MrstmJnpI9rYiN6Hk7lFGbF8XPST7uujmMxHdzPq6U089NRG5DCUuuugiX6ZvkQDk+0UxHBPRTWcietPufY0e6hORBajvxzgiyyTfb9NNN/V1UWIgX46sAf0Y2ooC1yaih/xElNgm2X70RiMRveX3fVP/0P8osU/q6uRylHXc24mzisRWXxe9IUnuF1ko+bpIJPB1UQB7Hwt9gnckhCSizNEJzhfdnPs+DzzwgB8TCQbJdtJdr+TGLGYiodLb5LyRmXkiMj13FpH4W+nR0RdognPXpETCTOL8889PROJs4pJLLkk28dxzz/l4owRCyXW5nKmqfVhw7kg8SkQPUQmWa1pqw6em59Rx+SGw5ZZbJqIXAsnGo3AYiSicQyK6mUiuYyYS9vx/if/TbMvQoUP9mMhqMfl5i6yqvf1I7E5E4qE3xeeS/9GLL77YlyOrpEQUezcRvWRInop+Ri95kst8F/EdHVlA+rp33303cfXVV/s834G0F1lqJyLLJV/HuFjHZz98r0fW3L6O73tKNuf1HfVHBERABOqAAN9fn376aSJ6wZK45557EtHLZ/9u5l4migWeiCzM/TuM7zZq5NKeiF5WJ6IXNwnupfhOjKzHE5HXUGLatGmJ6CVsHfRapxABERABERCBhQlEuSsSkZdC4q677lp4o9bUioDV6mgdXBAE+vfv7w/lPJgj2CDW8KDbp0+fRJRwJhGZIicii5pEpPonIuucrPuM2BZliE7eMPJQH1llJm677bZE5JLo6yO3nUSUGdvbRFSK3GeT60855ZRElKDGl4NQyY5XXnmli5qRdWVi1113Tdx7770uVvKQ/uKLLyYiK0EfDzeoUUIgPyfHffLJJ34Ty3oEgcgd0pcji6ZElLU7EblKsttChb5mEio5LvSZvkaWSIkok3dyXfQ2PxG5WyYiN0sXEDh3FP8pgVBLiSycElGMpiQjRMooqK5vu/322xORVYBv40Y7ckn19emul2+oxh/6ESpiJRWekZtoInJLTSAIp5baCHGRda5fF84ZhBfajyxHvR+I5PkoVbXPAwoPOg0bNvTPRG36UBs+tTmvjs09AQRA/idC4UUGn9277747rPIp30Ws53su2zJy5Eg/hpcS8RK5Y/t6Hr4pqUIl6xAWI4ujBC8V+B7luwfxMpQHH3zQ24hcyhN8n/JdHiXlCZv9ezGKNZxcZob/+yiJWYV1iLI77LBDcl1V503uqBkREAERKAAC3MMiZnJPxkvgc889N3HggQcmokRl/nKU771wD8Q8L3D4HowSRfpLcl4+RR4+iciCPRHFFS+AEakLIiACIiACpUqAZ4K11lorEXkWlOoQ62VcEirrBXvuTzp79uyklU28daz+sADiZq0uShRLMvH5558n33AjInIzGRcq6QfWQcECiJtIjsu2YL0ZRMkoAHy2h+VtP8QELDwRA7K16Mt0vbLtZLhBT50i4CJYI37st99+LnaEL83aCnE8MHC+uFBJf3mTlM+STftROAN/m1WbftSWT23OrWNzSwChkv+FUILVNC9F4gUBns90FGM2vrrS+UxCJf8XtDVgwAA/Pp1QyfceL5OwGEeUjMJ0VBAqI5dIf9AO/9dRNsFE3JKd/+1UoTJyEV9IqMQiiQf6UKo6b9hPUxEQAREoBgK8pMR6PYpb7taVvHQ65phjki+weUkfvkf5LeAlMkImluaXXnppAm8ZLDK5n8z2vq0YuKiPIiACIiACdU+A3yOevfEUVckdAcWojO5kSqGQhTFdIX7hdtttt9Cmyy67zAYNGrTQ+vgKgpwTc7I6hdgMqYll0h0fjzkUvQ1Pt0vGdWSZDIVg7fVdIvHAQozObPuS6XplezznjL4GFtqdWKUUYkVFruye9INYd7179/bYUfGkHQsdXMWKTNcpeoNUxZG125xN+5H1nFFVRCAQ4H8klLpIMDZhwgQ/Hdnj0xX+N0l8E7kqWuTSbZEVsEWhOirsShzZyBLIswiefvrp9tprr/n/bvSyqcJ+1VnI5rzVaU/7ioAIiEB9E4jEx2QyoExx18lqTqIzahQSI1lJNBm9ALWQpDGyQPfkhyQvC7E4wzxJEdmuIgIiIAIiIAKZCBBXOfLetOilmcesjETLTLtqfTUIVE8hqkbD2rWwCUQu1xbFAqq0k9Eb6Uq3V7WRh24eyikETy/Xf1oERTL4RtatnrE3sm7ybOGZpr/99psndYEZyV2oqfNVsWc7/CmRG7hF1ls+T6bPKLZnzjKTRdazFrmyG2IiSUBC4QHg5ptv9szzjL1du3aeEISHC5IQRW7xngAKAZWEQFHMKfv444/98JNPPtnCg0em9hFuIus4f/Bo27ats40LU6EfmpYnAT4LdZ1gjM8k/wdRCIm00Mnm/corr1gUEsNFSnbifzP+wuGEE07wLOCRNbRF8do8aRYJfCLr8+QxqY3Hj0/dxnI25013nNaJgAiIQDET4EU2tX379gsNI7Ki9MQ+QcAkyVkUE90zmEfhfgyRk8JvCS/HeRnNS6h4RdSs7X3yQh3TChEQAREQgaIkEIUo8WdTnk+5n1epPQEJlbVnWJQtkKmWmq/y0UcfWeRe4wIS50CQIrNt06ZN83XKOm03cldPZrckiyUZLiM3dItcun3MiJKhRoHjXTRJ7SCZNLFaTa1R3Dpr0qSJv8XnTT43wkzj82QArkqg4HxYuNLXyO3JM2c2btw4ZyJlFMzeBcaxY8d65vMwPoTWKLmQCyuRe5Xf8J900kl2/fXXW5SQyMhEPHz4cM+evMEGG7hQSab4yD3XohiCFrm7ulCZqX3a5AcgcrG1KA6fXXvttZ51GZ4qIgABHiz5/8Bikf+BKNatfyajJF8u3O21114OCuEQ6+Yozm61wUWxaI3POlbKAwcO9P9/vuN4GUDhO4ESHnj5P6fwEMzndtiwYZ6pm3VRzFt/EEZcjWJX2uWXX+7/P5FruP//RjFuvX3GFMW35BAvvMCIkuV49u+wDvGT9VGMN1+VzXkziauhTU1FQAREoJQI4IERMo1H8dcXGhrf7QiXQcCMQvtYFOLHopAeRiZzvosRMbGiiYuXYR6LzHJ9Ob8QTK0QAREQgTIgsMYaa9jRRx9tUa4Lt67Ub0DtL7qEytozVAtpCPDgi+VevMTdvePrC3Ee0TG8aWeKm1AQJJkiSAahkJtVXEsRFxE9qBtttFFyPqxjn5VXXjkpTGJdWNOC9SIWAekKLtpYU+JaetBBB1kUgN4tCpgiYuSqRDEdfTy77LJLhSYRWRAiuakn9AAVcfKNN95I7temTZvkPDMwxNIyXtK1j+iL6Bll/zSsgilRFngXQYMFabwNzZcnAVysn3/+eYuCW9upp55qUVwyFxNZ5n+C7Vj9RskaLIpT6Z/j6pJCIIxiTRri/5dffmlRwgc7+OCDvZkoRo3fqLCA4I7QSLgNPrNRsh3/f0Bsx+qY/kXxLb2/fKdEibssSnrmfYoS77h4zwMz/0OU8ePHWxSLzS0zgxUz2xFfr7jiCl+P4Dlu3Djr27evWy9XdV5vWH9EQAREQAScAC+g+H6nphZeBPGdyz1OqHh/vPDCC8kXVAihWNgH4TJKwmi8mMWTCYGUex4VERABERCB0iKAQU6U5NXDOGGAo1I7AhIqa8dPR2cggFVRsCzKsEu9rkYQwC2duHLcYPLWPC5MIkJQEP242WzevLnxpgQBkikWW1TmsRLFaqsuS+pNLqInwiVvb3ClRjDBqrE2Ymg240n3tuiuu+5yLvG4nViJ1qSkto8VJRZlXbp0STaHxSnCeHAdT26owQwPHRdccIFbn/Kggrgen8bn2VbIn/EaDL9kDkHkxjKXh0UEewpiIZ8fxG5EPP6viT9W04JYTsiCGTNmuDVkPEYqomIQFuPtv/jiix72IVg5sg0xMSxjAYrlNNaYfLZ4yRHKkCFDwmxyGiWSSM6HGeJappaqzpu6v5ZFQAREQATSE+Ceg3tBamrhZXCwvgwiJi/EsLrnBTcF7w9iuSNaBvGSeURNvv9VREAEREAEipMA2gDP4HgRYl0ZfzYozhHVb68lVNYvf509zwSwmsLaKQiSYfrFF1+4yySnJ4YRsYZw1dlzzz1dvEDAYBm3nnyLfTVBEITK0Dfi2R1yyCG2++67+01wTdrMxTEILMSk3GSTTXLR3EJtYGlG4drECzwCk/j66s7T9+eee85+/fVXd+sN8UIztYNAHcTMVBEz3XK6dfHj2a4ftUy0q7c+LvLFj6xtgjFCDYSCwBhExrCuqmnq/vHl8JDKjU6uS/w8tJ26nOvzqT0REAERKDcCJC/MZIlJrGFejIf7UOYJF8JLcqzg+e3npXiqgMlypt+zcuOr8YqACIhAoRMgGSZxKklaHEJNFXqfC7V/EioL9cqoX9UmgMj0ySefuGXdmDFjfIqwRYxGBD3ER274dtxxRzvxxBOTN4O4YxdbwdKTm2GssXBjLbSb2NGjR7v7eaZM4TXlHbJ0YknGdcx1IekPPyzxgks5gmUQL8M03bqwjSmWn4QJiK/jGCoPJZkK1hZBvAxTRKXqVkTPXIi3mfpZauuzTTCGRSaFa6siAiIgAiIgAtkQwLqfRIEhWWA4Zv78+W6FGRcwSc6Gdwr3CxRCB2244YZuxck01OAxENrSVAREQAREoH4JYDHfq1cvz6EgobJ210JCZe346eh6IkDG7BEjRiQTUiBMTpkyxXuDaEe8Q6wMiV+IdR/xgVLdiOup6zk5LTe0uK4WWsENHqGNm+tRo0Z5EhP6yI14vAQBM54YJMSYzBR7k+ODpSZusBdeeGGySY6t7LjkjjWYoa+4DVNzVYhxBaNUETN1OewTMsQTFyvMh2mmuKNYZyBWxgVOXPAZB9N0NXUbxwar3VyNvVDbySbBGMl3+vXr50PgM0jsy2uuucatsgt1XOqXCIiACIhA4RLg3jQIj/FeEqKIxD1YXvLSnfjEJKokoWC4d+KeKy5g4o5ODHB+u1VEQAREQATqhwD6Q+fOne29997zaf30ovjPKqGy+K9hyY+AmzVu1D788EMXJply04YwRTbrLbfc0siCjThJxV271Et9iJSpWYxhjFhGId4nBQs+EnyQJISkJST3wJ31oosu8u3hT8eOHd1qsH///m4hgJBJshEK8fQQmbm2qe0jDNEmX/xkaib+xwcffOCfC44lJgjnJcFJIRdiXFGxkqhtwToTgTMIl5VNebjB8hjBk/l4TRWTQ78QO4OoGRcymccamWl8Pr6O9UGUDu0V83T77bf376H4GBijigiIgAiIgAjkkgD3UyEzOfdE8fLNN9+4cIl4ScxlvExI4BBeXHIcomUQMYnjzXwpvbCP89C8CIiACBQSgU6dOrmxznXXXSehshYXRkJlLeDp0PwQQHjBdfitt97yOmzYMBdXEHa22GIL23nnne3SSy/1LwDeJqvkn0C6LMbE0bvhhhv85MR1PPvss926DMGRmEtkXe7Tp4+7qPfs2dPd8kNPsbo899xzjQzhZDDu3r27Z0lmHdd0zpw5Llimax9Ltv32289N6tlO0iBc+mkTK8IQ5y+cq9SnWDwGsbA2Y0WoRMSMi5ep8/HtxHmdO3euH8MUgZSXCqkFoTOTkImoietamMbnWVfXSapS+566zGer3D5fqQy0LAIiIAIiUL8EgoDZo0ePZEf4/cWzKIiXTN944w277bbbbN68ef7SEO8iwgbhnRKmJIVUEQEREAERyC0BrCr32Wcf43kJd3CV6hNYJPphW/jJsvrt6AgRqDEBPoJkRUSYfPPNN+2dd95xsYQkN2R3xnR6q622cmvJUrLOqjGwGh544IEH+tv21BiMNWyuysOmT5/ubsNcxxdeeMHjdZxzzjkuSIaDsQTEbRtRiimfhWzFKSw8CVyPtd+sWbNq7X5b13wCg1KZYuGMWBnES0TNMB+m8XVhngQDbE9n0YnIiXgZajpBM4ibJMkh7ANTiYml8qnSOERABERABGpDgJf/ZCAnhjv32mGKVSaF38y4cImAifu4fkdrQ13HioAIlDsBnosQKHfYYQePOVzuPGoyfllU1oSajqk1AYSll19+2QYPHuziJAkqEBy22247dwHmnxo3FZXcEcCNqC7fS2Rj7UqymFCqK0LHMyMjhta2wEbJZ2pOEWvW2lh2/vHHH4ZoGYTLTPNY6xKnC3GTfdJZcmJdy8NXXLwMy6nTIG4S00vXv+bXX0eKgAiIgAgUHgG8LvA6oeKNEgq/oXHhkpA6JPAhhjbH8IAdBExiOLdt2zYn4WrC+TUVAREQgVImwHPRKaeckvQ4VKio6l9tCZXVZ6YjakAAEYiEN8QfRJwcOXKkLbnkki5MnnfeeW45yVtc/qlV8kMAURArx/ooxESkcANcqIXENfoRqb+rg7hIrW6MWaxFeODiZUeohA4I82GKG1yYZxoyyIcRI5TzsoS4oYiX1EzzCONsU7yvQE9TERABERCBYiKAhwLGAdRQgvVlXMC8/fbbPakP+/D7jGAZhEvm6yNmeuivpiIgAiJQyAQOOeQQD3X20EMPuWhZyH0txL7J9bsQr0qJ9Akh4NVXXzXiF7700ksukhELZ5dddrFdd93VYwviuqtSNwSI60m2SFyA6rJcfPHFdu+999p3333nQtCVV17pcSnrsg/ZnItETMTKJIuzSukTIOxAXLhkHoEz1NmzZ1eYZ/uCBQsqgEH8R7CkBvEyzLMcr6zPNqxBhZNoQQREQAREQATqkQC/i8SOx+AgTCdOnOheOngpxMVLRMxWrVrJ8KAer5dOLQIiUDgEjj32WHv77bdtwoQJhdOpIumJhMoiuVDF0k3Eyddee80GDhzoAiVumR06dHBhEnGSmxmV+iFAbMq9997b3WWJ61hXhYQscZdzLNeIPVhIhUDzMLn//vuNWJUqIpCOAJ9lBMxQCWER5sOUdWF9qtUmFixkpEfAjE+bNGniy6wLleRhKiIgAiIgAiJQiAR42ffxxx8nhUsETB7EiTfOPR4vf0mAueWWW1q7du2MRD4Kr1KIV1J9EgERyCcB4gLzfUhyM0LbqWRPQEJl9qy0ZwYCPIyTiRlxEjEMcZLkN/vuu69nu6quK2eG02h1LQngHotV12OPPebXppbNldThWPzutttubvWZTWzNkhq8BpM3AiQMmjlzpguXQcBMt8w6RNB4IWYmAmZq5fNJZT1TXNQVMiNOTvMiUD8EsDZ75plnPMTNnnvuaRdeeGH9dERnFYF6IsBL33HjxiXFS8I8jR071kOt4IEQhMsgXrZs2bKeeqrTioAIiEDdEejUqZORWwGtRCV7AhIqs2elPVMIkNACC7QBAwYYD+RYTgZxslmzZil7a7EQCHTr1s1jgxIrVOX/CPTp08emTZtmH3zwwf+t1JwI1CEBHvAQLEOdMWOGpavEmY3HesVCGStMboCCiMl8vBJyA0FT1ix1eEF1qnohUJ9J0d599127+eab7emnnzZCnlx00UX1wkAnFYFCIoAxAzEvR40a5RXx8rPPPnPLS7wMEC3jVTEvC+nqqS8iIAK5IPDoo4/aYYcdZlOnTvX781y0WQ5tSKgsh6ucwzHi3sg/GwIlb03JIti3b1/bf//9FVA7h5zz1RTWHr179zYSi3DtVMx/NNZdd12Po0nQYxURKHQCWF8iYiJahvr9999XmGcZ17xQiI+JkIloiZU701BZDutIcqYiAsVI4J9//vHY13h4kLW4PgrW+YS5kVBZH/R1zmIhwMs23MaDeMn0888/N/6HCY2CcInxA7V9+/aGoKkiAiIgAsVKYP78+X6ffdJJJ8nbohoXUUJlNWCV665kASRT9wMPPOBTYqftt99+/magY8eO5YqlKMfNTSDZ1RHmEC1VzA4++GD78MMP/SYZ6zQVESgVAmSyR7AkkVWYMh+vCJ3EFKNgcUl4CERLrOJTK5YuiJv1JQKVynXROPJD4JxzzvFkaCS9qq/vcmJ0k5RNQmV+rrFaLV0C/F4R5xLREqvL4cOH2+TJk33AxLdEsAziJfexeqlWup8FjUwESpHA2Wefbf3793cDGd1HZ3eFJVRmx6ks9yLLLdma77jjDvvmm2+sS5cuLk6SkEWJHor3IxEepIgnuvvuuxfvQHLQ89dff926du3qoi0xxVREoNwI8PIC68xvv/22QuU7P1REziBmcnOFWzmi5dprr522LrvssuWGUeOtZwLnnXeeXXXVVd4LLOMR26+44gpfHjZsmHuCYLGF+N6jRw9/2VqdLhN7+/nnn/f4UjfccIM98sgjHpub/4ULLrjANtlkE2/u/7H3HvB2VFX7/+b1x0sX6SAgQXoTEAHB0IuIkGAIPfQSEBI6kd5bqKGEjqFIh1CkSe9NkCJVQF4EAWkqTfj4d/+f78J9mHtyypx7Tz9rfT5zZ+6cmT17nml7P3utZ6XvazFRiazIxIkTw+OPP26JRsgCuv766xeqwMAh2lXI6KDbN2TIECM8CWVn34svvjjsu+++Rt7cdNNN5nU2evToMO+881q5lA05u/vuuweyLierdty0nc8dgXZEgCguCMs0QWDyjEwxxRSWnDMRl8xd77Idr6DXyRFwBBICr776qjkK3XrrrdYOSet9Xh4BJyrLY9Ozv6Alc9ppp1nSFUYst9tuu7DrrruG+eabr2cx6bYTRyeDzg6j172qBwQ5Q4du8ODB4aqrruq2S+zn4wjUDQHITDwv0XHNTmjtpCmbDIjQvUGDBhUmOpAQKkyQm+4JU7dL4wX9FwGIjK233jq8/PLL4Z577rHBVMiLs846K+yxxx7h7LPPtmybDLyOHTvWJFBqee9DAJ577rkBLVnuYxIG4pl8//33h2mmmcYShrC+FFH50EMPhZVXXtkkc5DJ2Wuvvaw+6PThKYZHP8ncXnnlFSuLZcLH99xzT/MQhYDl+SJrKMeAHOW8mEOQMniAF+ltt91merUMLJBgq9px/eZxBDoNAYh7npNEXDKnz8L9jw5z8rok2ovnn6R0bo6AI+AItAsC9DkZMCW/h1sOBPTSd3MEosK7owTg4yqrrBJ128RFFlkknnnmmVGhGI5OFyLw2WefxcUXXzyqkxOVDbwLz7DyKUm7Ly677LJRIfBRHcDKG/uvjoAjUBUBebnEZ555Jt5www1RCUWiSJYoL+UociVOP/309l3h2yICJWpwJK666qpx++23j/J6i1deeWVUuF+kDDdHoL8ISNcuSr6gsLu8F+KUU04ZNdhaWMeCSEO7HyVn02d9tX+4Z7mHb7/99sKmlM26kSNH2jp+4395VBa2kcelrVMCQlunZHb2v/S+7X95V0aRLIVvsZLyxOOOO66wv4hN2/6UU04prBsxYoSt06ByYZ2IWlunwQNbV+24hR19wRHoYASkdxlFykd5OkclRowaJLPngG8N7dwdd9wxXnDBBVEDA1GDbh18pl51R8AR6HQENOBp7RJv7+a7ki7IphZlLxujkOglMGKPSzKj+HgEEA7r1r0IEJqJ7uhPfvITCy8jAcBMM83UvSecOTM8Uwi5wzPswQcf9BH3DDa+6Aj0FwGRkebdlUJgi8vRgIjpjb3++uuB6bXXXrP53Xffbc8iWsgYXjHzzz+/hcfgbYaebppPO+20xcX6/45AHwSyme2RN8EDEu/HrBH6jSck4dbbKBlgXsNzEsOzMdlBBx1knpIkBilnbEMoNx78eIDh3YkhrYBRP9YtvfTSljWc71P2GDxb2BJLLGFz/iy00EK2nH3eUoI8vJyJlKh23EJhvuAIdDACGowIK664ok3pNIiYwVMZ2QfmJAElgc93vvMde97S9nhd+ncloeZzR8ARaDQCG2+8sUm0aIA+7LTTTo0+XMeX70Rlx1/C/p0A2ac0wmghUIQJaXTeQoHpELr1BgJ0ZCAJ1l57bSMs6bQtuuiiXX3ykPFoUX700UfhrrvuMkKkq0/YT84RaBMEyNrKlNXPS1VjwOyNN96wwTKeUaY//elPps0H6ZL0MUnkwzcKQiZN8v43PcIsQZXK9XnvIZC9D7iPMMKgs0boFUYI6UANKQPKRzevnCF1wO/y4jcC8mc/+1mQV2Vhc5IT3nvvvWHChAmmG803GWKlEoECOVNsk08+ua3iecKqHdc28j+OQBciMPvss1tbL2mP80zI499IS4hL+j+HHHKIySZA9ifikjmyJW6OgCPgCDQCAQYeN9hgg3DRRRc5UZkDYCcqc4DUTZso5NdG7k866aSAhwv6k/vtt5/phnXTefq55EMAbyXE9ocPH27aPnjWokda3LHLV1r7biUH83DeeedZMgKIDhqqvarN2b5XyWvWqwhAsPAuYio2Oph4YKI9CLHE/LnnnrPEIx988IFtDqEDYclAC9Niiy0WFPJnz3iWuCou2//vPgSy15sM9hie85IZKJwshDc222yzFdb1d4F7Eg3XUvduKvOaa64JCkkNktMJChG3AcL0G3OIeIWhm7j+3nvvbVEtG220kZGX2e1qXa523FrL8+0dgU5FgG+MpCFsGjVqlJ0GThrouNIGZkKDlu8N2q9EG6UJ72YSVbk5Ao6AI1APBNDTJrKDAflKbYd6HKvTy/A3b6dfwZz1/+qrr4ygPPLIIy38gYyT++yzT2DU0a23EZhjjjmsQ8S9QScJQu/QQw+1ER9E+jvZ6EDiuXL44YfbaDrnd8QRR1jGyE4+L6+7I9ArCNDBJMw1hbpmz/vDDz8MZHImKUma8JQmgzk23XTTGWmJxwwTobNLLrlkSKG02bJ8ufMRgKREQgDiD2KBsE6MMO+sSQ/V/sV7aqBG4h4M2Zxydvzxx1u98JzEGDDGGEDDGBxkG35HdmeNNdYI9913n3n+zzjjjLZN8Z+0b/H67P/Vjpvd1pcdgV5DAEKSAQEmjNBw3g2Ql0y0FYm+QfKBd0kiLnlv8G1xcwQcAUegPwjwnef9g1flUUcd1Z8iemYfJyq7/FLTmL3iiivCgQceaFlbGUkcM2ZMz+gRdvnlrdvpQQbQKNt8882DBPit4cZLlLCZ1Vdf3byT8E4pFW5Wt0oMsCBIyQkKnSPbI/qTdCAnTpxoOmBofvFbVuNrgIfz3R0BR6DFCKCrmzqP2aqgQ/v888+HP/7xj+Z9SVbYq6++2qII2I7MyRCWaAIus8wyFo7OgI1bZyPAN4s2D2GdfNPQflxzzTXDnXfeaXqUw4YNsxMkOzZaqEST9MduvPHGsMMOOxjhyHcFGYLksYmXFva3v/2tUHTyxkIzUgl5bCCQHx9//PGg5FNGYp5xxhnWYYGYhBTBsws9Peydd96xOfd1Mkh6LOlcspw8jImWwaodd+jQobad/3EEHIEQpppqqrDSSivZBB68S1588cUCcXnZZZcFBvQZwGfgCwkJtmfu3w+/gxwBRyAvAkQtbrnlluGSSy6xd0o2EiRvGT2znV7Ebl2KwB133BGlB2ZZViUYH0XedOmZ+mnVGwGFWkYyhs4333yWRVUvRMui2ElzudPHAw44ICo0r97weHmOgCPQgQiI1Ik33XRTVGczbrjhhvH73/9+4b2mjmbUgEbUgE289dZbo4igDjzD3q6yEgPa90qN/kimbDL8irSzTMAiISJZsTfbbLMoaQDLAFwrWvKatPtFJEVcbrnl4lxzzRVFVEQl7rCiFNpt6/hOimS07w8/cM8pzDyKPI3ypIhk/yYzMXUi670GCOO3v/3tqIFBy1AuDUvLYsy+ZDKWB7AdVwNtUUnwoiRaCuvmnnvuqMHoePrpp1vmcI4teZOoQbqqx6V8N0fAEciPAM+6JBXi7rvvHjXIFUVa2rNJW5n3iyKSouRJ8hfoWzoCjkBPIEB7JGuSMLJ3h6Rpsqt9uQiByfhfDRu3LkIAL5Kkc7TuuuuG4447zj3Juuj6NutU1PGxzGR4p+B9hAcHGVTb2RiV2mqrrQqeU3ivqMNqYXndprvZztfB6+YIdAoCJDn5wx/+YCF/hP098cQTlp2c+qMdhFceXpuE+6F96e+R9r6yeBVyjYpDpvl+0TZCmxiP2v7YeuutF0QUmofj559/bhICePXmMTwkmaaeemrbnPB0/seLi+8q0Qp4Y5IAB2/Pelml49brGF6OI9CrCHz66aemeY4O7gMPPBAee+yxwLsB/dvknbnyyiubB6Z/O3r1LvHz7nUEiPgjukMOZOaRnfBAU531p512Wlrl8yIEnKgsAqST/+WDedhhh4Vx48ZZZskTTjghQNS4OQK1IkA2REJcILmRCugkg1jdcccdLWyHEB00y+T5Evbcc09LHpXC6TrpnLyujoAj0DwEILvocDKReIv5J598YqG4kJZ0QPm2EjaewmubVzs/Uj0R4Dt3/fXXVyxS3o4mJZKIyvfeey/MOuusFffxHx0BR6D3EGBgQB7TRlqijYvWJVIM6CKnbwfE5bLLLmvyFL2HkJ+xI9B7CPzqV78yHWreD9k2I5wNeSGQcPGBjNL3hROVpXHpuLXob0HEIAZ9zDHHGFHjN33HXcaWV5hRn912282yH55zzjkF3a2WV6yGCkBMohlGpmDOJxmkJR+IbbfdNqDVykiWmyPgCDgC1RDgnUKmcbxm6HziOaMQQEuoQKcTYXQmf6dUQ7L9fn/qqafCa6+9VrFieD1CUqJ//Oijjwb2Qd+0mhGwRMcET3++Pa5DVQ0x/90R6C4EeAfw7eCbkb4daM7iWY23/iqrrBL4hrDczhrw3XVV/GwcgeYhIAmyILkWOyARfzjOSPLF/ieaRxJ99g6YdtppzfOa/il627UaA+qnnnpqeOONN6wPLHkai4ZM5VLeww8/bLkb0MdmPYmVyeGQ7LrrrjM9dyKNJI0UhgwZEn7605+mn1syd6KyJbDX76CktodYwp1YOpRh7NixdQ0bql9NvaR2R4DM8Ij7Iu5PAqYNNtig3atctn54yJAIqJSRZIHOIx5RkPt0QJ3UL4WUr3MEHIFyCJBtnIRdZBm/++67zWtGeoFB+oImNQFxCcHl1vkIQFTzbbzqqqsKHvqLL754IMEcWYHxmEpzwrj5ljKxX9b4zkwxxRTWQSCTMJ6ahI4T6s1EB4aJ8PT5558/zDnnnE5uZgH0ZUegCxCg3wZped9999n8//7v/+y9gJclxCUTUiO8I9wcAUegsxGAQJR+bZB2rbUZaReSMI82A/1QnGogC+FySGj7z3/+M/z2t781D+y8Z47nNmVdeumlRixKT9tISdoTJMQluzjbMChy4YUXBml1myza2WefHV544YUgXWuLHqI/rLwO9u5hmXLoJ7fSnKhsJfoDODb6RnhOMi200EJh/PjxNd3UAzi079qFCJBNlIyoaLRBVPLC63Sj0cdoVXFnMZ2Xh4UnJHzuCDgCA0EAz220LZWExyaW8Y5Ze+21w8Ybb2yj0oxeu7U/AnhAQULTucATiglty5R5mzOAVISUphMwwwwzmB4mcyY6IehMMiCW5twftNn4FkFkfvbZZwGpHjokaGciNfD++++Ht956y6Yvv/zSgMLrCp1UMgwvtdRS5nnBd80JjPa/j7yGjkBeBCAqs8QlRCbvjx/96EfWFoe4JGzcvyF5EfXtHIH2QoDvNpIQ2Sg/JMqQKttjjz3C5ZdfHt5++20bvIBY5LtPu4M2RB6D6KT9SduBvu2NN94Yhg4dGnbaaadAdCSWJN2oB16c6G1DRkJubrHFFmGXXXYJShQWeP8gkUYEEeRmq+XfnKjMcwe02Taw37gPMz/qqKPC6NGj+2getFl1vTptjgCNJJIuQVby4iJxTjcYDT8aeHlMGX8tpA9PFjdHwBFwBAaCAGHhjIgTRnPnnXfa95l37CabbGIj1CmhykCO4fvWDwHIyNtuu83CMwmNgjzkGhHKj+dkmgiFgqBsdIgmGph0FpggTZ955pnw9NNPB9YTQs43Gs8IiHC+ce65W797wUtyBFqNAEm18La89957bY4nFs89msg4EfDMDx482KRHWl1XP74j4AhURwCiEsmY5DjDgCi6tdNNN51F5SyyyCLmbclzDUnIYGYiFKuXHkw6gsFV3hV4R/7tb3+zhF7Dhw+3UG7KIMrj2WeftQEQtoU/op1KWDoamnhdEpk7aNAgy3UC+Uk9Wj1A8j95APBt2gMBmPiTTjqpIOCPtxgZjfmAuTkC/UGAFyHaONxDaG91C0kJFnTk0Nao9HwQiseHAjLBScr+3EG+jyPgCBQjMPvss4cddtgh3HLLLaZlSUZHNH8ItyEJC3PkKZLnXPH+/n9jEaAtRcg+WlA0yvFYpG0FAXnwwQebdywDd3jG/vrXvw577723fUvwcmg0ScmZkzGYDgt6yscff7yRqJDfCO7/5je/Me8q5H6QGSC7OTpSEyZMsBD0xiLnpTsCjkCjEUCfjm8EnlAMVODNjdcTurh4SjHoxXNP2x2C4fbbbzcP7UbXy8t3BByB/iOQ1aiGSCRBI31QcirQBkFahv4qYeEYIdh5jczhGBGR2IsvvmjzddZZx+b8wTuTdiik6fnnn2/th8KPWmAgHaISjUu8MdmXvCctN7G6bh2AgD5UcbXVVou60aJEWKPCiDqg1l7Fdkbgpptuigohi/LKiApBa+eq9rtuGj2K+jhEvWgnmVgvvbCorL79Lt93dAQcAUcgLwLyiItnnnlm1CBKVAM1akQ9jhw5Mmp0O28Rvt0AEHj11VfjQQcdFOUVad8DdfyjiMkoYfko8nIAJbdmV3leRYWORYVv2beM75mkBqK8QzvyfFqDoh/VEegsBDRoEaUjH5UII4rksHeZCI6oZF9x//33j7/73e+iPKE666S8to5AFyMgGYfIM5pMg9T2P31TEYPxyCOPjBrgtu+29LDtmZb2edq86pznXXkZrEzeC5KKifvtt1+fdoCSLkeFhUfpUlp5Gqy148ij0v4XcWpz3i3Sx7bf5L1t61r5J7Ty4H7sfAhws2qEPUpcPcp1ON9OvpUjUAGBcePG2Qtr++23j0osU2HLzv9pxIgRhQ9ClrCEKEgv7M4/Sz8DR8AR6CQEpEcUTzzxxLjYYotZg1BhxvY/ZKZbfRFQGGWUF5LhLF1J68zLU6m+B2lxafIANdJypZVWsvNU+JeR4p9//nmLa+aHdwQcgUYigCOLNO6i9Ogizz3tXGlcRnll20AMfUh5RjWyCl62I+AIVEBAXozmNJPtb0Ne8qxefPHFEacalhm0Vhh4lJxLVLKdCiX2/Uk61zYALo/rKG3LkgMV6XhK/mc7sy3HVK4T+1+SgpF3CSb5GyM7+Z3lVpqHfusqtKvpxjANAbKHqvFpegW4/rtqMBXJAABAAElEQVQ5Av1FAI0KQhLJ4oU+Be7flUKj+3ucdtqP8yxlCJXvu+++pstZ6ndf5wg4Ao5AoxAgvI+QYgTT0QviG69Rdcv0vMEGG1iIHwlY3PqPAJIeZM9F043kNYoiCGgypySE/S+5/fYkg/h2221nSTmef/5507LbZ599ArqaGph0mYH2u2ReI0egLgggNbLppptaqDgadSTlQLKCRKtIRZCcg0RfzPnGkCBDhEldju2FOAKOQHUEaO/B6ZA8h6zb5Bg5+eSTA+Hgp59+uiXPmWeeecIll1xicg/yjLZntnrJX2/Btx79SfSseb7lPWnJddDbTpb6+ooqsaQ5yEZgiiixkHH0M8844wxbh7QEIegaSDfNTFvZqj+tZEn92OURIBSXcB5CvfF+c3MEBooAnjrKHBilyRgZSeklU1a1Pl6VPFO43ksDzEIwTzjhhF6Cw8/VEXAE2hABvN+kRRbVobTRdyIpDjzwwChtwjasbftWSdpOUULw5i3w85//vGflPQgRlY65eWeIsIwTJ05s34vmNXMEHIGGIEBoqYjLiMcUHuXiG0z2SRruURq4UVq8USRFQ47thToCjkCMGjCwNh2SY3yTk9QMffFZZpnFvBcJ14bzOeyww2p+HokO5LkunpSYJxJRgiH3RpsSb2s5wEXlqIjS6Lb2AZKCm2++edSAp4WQa9AzSgM7ivRs+eXzrN+tYogrHJcRf7ItIbaqhmWQ7kiFrf0nR6A6AiReQhwXMV29GC2bafW9umcLRpVIliMiIDCaxKhyMka18KyULkjQy74pyRLSsX3uCDgCjkApBBA0Z+T9vPPOC++//769v3fddVfziim1va8LllFTDe7AhEA97/Y11lij56F56623wpgxY4LCQ61tyXdujjnm6HlcHABHoBcRkFavZRgmodg999xjfU0yDeN5zvsSz0s8qdwcAUegfggoPNuS5+CtmDU8GUl+w/Mop5pA2w/vylqMKElpVFsyHNqL9HWJIsGDU0SoZfSmPDypmaaeemornqgd/leoefjXv/5l/V9pXxtXMPPMM9dShYZt60Rlw6DtX8EPP/xwkCBqwJWfMCXPRNw/HH2vbxC47LLLwo477miEN1nFil+S32zZ3Ut0Xt98800Ljyk+01tvvdWyLEoH1lziyQTr5gg4Ao5AqxGgEXnNNdcEJeGxkB5pWYZf/vKXQd4xQd7xra5e2xz/tddeC9IjDk8//XSQOHwYPXq0dQrapoJtUJF77703SJfaMn+SJZwB8WKjg0NYGtIobo6AI9D9CCA/Ih1Lm+R9Ze8HeV4FJXAtEJdISLg5Ao5A4xBAmg1Skb7qbrvtZg41119/fcUDIvmiBHrWJoSgLCYXea6VXCscd9xxFctp5x+dqGyjq3PllVeGrbfeOsgd33RFpp122jaqXftXBa/B6667Lvz2t781sveQQw6xSuNBSKfl3HPPDcpwXfJE8DhgPyaFRwf0ITrdeOkxyjJ+/HgbpVF4c9frUVa6ZowW4VGqJDolN2OUecMNNwzcC5C7PIdujkA1BBi1xPOddwcNAglV2y6Kl7BGPiOVN998c7Viav49T/nd+F6rGagu2gESDsKS95OyNxpZybdNCRS66CxrPxWeu4022igw0ITGE2SuW2kElB3U2kNo2KFRRacInSwMj0vaDBL+t4Hy0iX4WkfAEehWBBSSGpS01UhLPLwefPBB885i8D55W+JxiTONmyPgCNQXAUjHv//979aX4DlkAJa+PN9t+hrM+R9PSCb6s2jSokXLdxtdSfQw6YfQp5VskHlVKkFPUMh3fSvbpNL+X5OO44epggCdDzocTCeddFJZMqVKMU35mQ5yatg25YA5D8JDjPs0nTmSEST785//bAL6zMsZYfYI0EIo/PjHPy63WcesRz6Ajpsym5qo7vDhwzum7o2q6JRTTlmxaDq5jzzySBg5cmRQhthw6KGHWph4OWKzYmH+Y1si0Ih3l/SELVEFXrmffPJJ4bxp8D/33HNGjrNc7/soT/nd9l4rgNujC9IwslDwsWPHWrIEBqGYkPVATJ1Btl4zBiAJiSeZBMnhCH9yK4/ANNNMYx0XZQQOO++8s3WEpJkVdt99d0vqxJ6///3vyxfgvzgCjkDXIkA7BW9qpv32289IkUcffdTCUiEulaHYQkUJDYe4ZFp11VUDnl1ujoAjUDsC9BvwaiaSARKS54zvMwSkckuEL774omyhcDEkyeG5ldasTcUbL7nkkrZq+umnNxJTOrVh7rnnDvPNN58l8WGgGyITR552NPeobIOrAiFyxBFHWCbKdvfk4wG6//77w+GHH94GyE1ahVtuuSVIPD9IjNaIprQFIb/VwujvuOMO87gkI2i7X4d0XqXmYIDe4pxzzmkhg73ubVMKo2rrGDig80bHX8kt7OVebR//vb0RaPS7a7nllrNGAmRoMkZGaUA0qhGfp/xuea8lTH3+DQKQ1YQG4S1PZxI9a/R2IS7rTYx/c9T2WTrllFPsPU376eCDD26finVITYhAof1JlnA8dLNZ5tF17lWZmA65fF5NR6DpCOAQ8sADDxSIS7IMJ3JzzTXXNOJyxRVX9AGjpl8ZP2AnIEBkH1m2eYYee+wxc2bAsYh+A1G0EIg4XBH9ifQC3pEzzDCDfYuZM6EviXckxGLK5J3OPZGaSLjgfQkJyrecidBwyE8mOBE8LpmjkUk56HovvfTS1o7kGV5iiSXaoh3pHpXp6rZgzo2JJwAeAQjm77DDDi2oRf5D8jApK5TpHebfq7lbFj+06ejVSEq2Sx27NE/7dsocLTMSxdBphag866yzCoK5nXIO7VJPnkte1HjpMBpFmNx6663XLtXzetSIQDPeXaXePQjUN9LylJ/eZ2neyPp42c1FgGs6bNgwmwjRO/HEE02+Au9wBlq22Wabrk0ORqKhvffe286ZuVt+BGgrnH766QF5nC+//NI6SVmSkpKQ0sFbys0RcAQcgYQAZIqyAdvEOhKEkJCHgWDky5CSQO6GQX6ISybID29/JAR93msIEFl1ww03hNtuu82cGfCahJOgj0kE3+KLL24TCXTwkMSbEq9HpFlqNZ49jPlMM81UdXfqAmH57LPPBgYdiKbguESKQYrSBoA0HTJkSEC3thXmRGUrUNcxISkhJvHWuvrqq01TsUVVyXVYdBJg9wklxIODrFC77LKLaSIwQnDGGWeYRwds/g9+8IMwatSofnmhMcIPHngKId7Mw5G0Avt7HMKf0W/gxUBSmWTUFYFZQr4ZnUhZttoxrD3Vudz85ZdfNhKZOeFv2223XblNfX1OBGhcPfnkkyZqTNIBZBm4X9KHIGcxvlmLEWjWu6v4NHm/ICXBu4dkKHgsYTQMxo0bZ9pPvOfQleHdw+8kSYF0YcST9xCacTzTeIwx6olQNu9arFz53fResxP1P7kQoHHLxP2CfAxagxBRfIuZ8pDauQ7UBhvhJcy3nPNzkrK2C0LEBUL9DN7gkVvKaA85UVkKGV/nCDgCWQRokyAzxYTxXoG0ZMLjHdIDz+yUmAficoEFFsgW4cuOQNchQCg3Di7o1yM7N8ccc5izC04wtNPwnCxnEIP045theGWi6c2EYw5GuyAl2KKtRSZyZGKS885mm23W3GgLEWZuTUZAHc4oIilKSykqAUOTj96/w7377rtRIdHENEZ5aUSNoEXWyZ04yj04Slw5ipGP8uqIIgSjOkW2XMvRlPE86oMWNUIX1dmOYvLjySefbEXkPc7tt99udVTot+0nksDqR70PPPDAQnU0WhCXWWaZKC+5KNHZKFfrKGLU9pX+V2G7Tlg455xzolzBowiP+Morr3RClTuujhpQiNL3iAsttFCUjmXH1b+XK9yMdxf4KuzW3h8sa0AnKitzlJelrZMHE6ujwjCixK6jPBLsPSdNGnvP8X5Sg962YVuNhBbKYqUEsaM8EqIaN7ZNufK76b1mJ+p/+o0A97087KNGxaOkB2yZb2un2zvvvBM1sh8lOt/pp9L0+muwN0p/2d4tvHPKTRo0iYqeaXr9/ICOgCPQXQjQLxRhGSXJFeWNae8c+oj0gZUULkqDr7tO2M+mZxFQuHVUdKy18fm2SgPS2l0K9Y4i/3LjAhfC/vAS7WCclwjXOGLEiCiNa+OuRGo2rS+MZ59bExGApNx2223tQsvbpolHHvihIFV5eKRPWShMXqFRnj9Ro2iFdXfffbdtp1GzqLCiwvpqC2Lso0bnjDhkW2k4RHmw2W55j1NMVLKzPAisPlmikg4c5yLvEyufPwpZsHWdQlRCVkiLzAiMAw44ICYypHBCvlBXBCCLNNIV6cRJw7Sme7uuFfHCakag0e8uKpQlKlMFpVtp75T0bI4ZM8b+/9Of/pQ2iddee62tS0QlPyihl60rbKSFWWedtUBUpvXF5XfDey2dm8/rg8A//vEP+7ZBftNR5B7k29GpttZaa0WFtkdIebfaEVCId5Tntr1faAOVm+hkuTkCjoAjUC8EFE1iDiw4ksirzAZy6T9KXinKMz4qIWGUrl69DuflOAJNQQAHBHgDBlAVcRclvWbOXLWQk9mK8o3G2UuRV9nVbbHMucpTNCrZlrUd6PcopL2hdfsfNVLcmojATjvtFDSKZO7AZBbuREuh0bozTZMEl2bCqpOttNJKgcyS6oyb+3BaX21Otm30Tgi5vfHGG03jBDfpgR6nVBZQ9BtJNpNNNEMyDCydX7X6tvJ3QkJx1SY8S96tpgtTSiOvlXXstmOjGSIiPJBoB30v7lN04dw6B4H0bA/0nZL3jIvfPfJ+tvcOGoLJyMTXXysuv9Pfa/3FwfcrjwCJnDSQFd544w0LlVYjMwwaNMhCpuV1WX7HNvwFaZg777zTMs9ON910bVjD9q8SEhN8wwjL5H2Y3onFNX/99dcrZhst3t7/dwQcAUegEgJISqBdSQIvkol89NFH1tcjazj6fWhfootHmDhJTUk6Uk6eotJx/DdHoBkIIMdEX5D21FFHHRXkhGbtrIsvvjhwT5f7tlarG99oRamG3/3ud9U2bfrvaNQqqta0Nun/8ryus846Ad4HqbRGmBOVjUC1TJn77LOPNbDlQVMQIi6zaVuvTg+fvDIso1SxSDKEmcIb7RwUipz7XDbZZBN7AOhQkbWUmx+9tXofh/LIgDXvvPP2qVs6rzTv82Ob/IM2KNhsscUWpgmDjsTKK6/cJrXrjWogfow4MuQ82DP4IPmA3jj5Dj/L9GzX+52SBxaeXTQp5amUZ/Oat+nk91rNJ+s71IwADUwygqOXRMIDBrv4BqK9y73Z7kbSF+pPQj+ym7sNDAF0pxD4R6OKjlGxMZiDwL6bI+AIOAKNQIDBJpJUnnrqqebUwncIbT70+9Diph+JBubw4cPD2WefHdAbd3ME2gEBSYAFeRUGeB30stFmPfbYY4Min+pSPXQq77vvvqBorLqU14hCGHRAh5/s5RjOXuQuIdN4Pc2JynqiWaEsbmDpLYYJEyYEaXVU2LL9f0qdfZh0SMm33nrLHtJszfFWxGrJEkXWSbw9rrjiCvM6YjQBgeZ6H4dkFhjsP52fTjGynC622GLh+eefNy/K8ePHB/cqac3VYwRNYSrW2b/pppvCwgsvbIMQdO7c2heBRr27ajnjp556KhRn2K1l/3Lbdup7rdz5+PrGICA9YxNHx2PuhBNOsOgOPHwhARnAa1cjKRVtjeOPP75dq9hx9SJJnPSwTBi/OCID8pKIDTdHwBFwBJqBANF5Cpu1tjSkJY4YJEwjkSrfJ75TJFnFWYAEhe4g0Iyr4sfIIoAX5cEHH2wJceA3cFqB36l3skJJ3IRPP/3Uvs/Z47fjMgQlHtKXXHKJPZckVK5ntKETlU246oT7EXqFizDeAJ1qqZOfyD1G4pdaaik7nfvvv7/PaZHinuzI6fc+P5b5hzBvQtHwrGQkn30ZUeBhTeXU4ziE8JKFDm/N7MOUyIN2CzUACzz3GLUhmzf/r7LKKmVQ9NXNRIB7VYLHYcMNN7RrwwgwHT+39kKg0e+uPGdLIxySiPcZ78dk6X2a/meeSAPp8NlqCHAaSJXeTZ32Xsuery83H4Epp5zSsj+/+uqr1tAmXAkPS2lQh3TfNb9W5Y9IuDIDl2kQtPyW/kstCPzwhz8MDJ4gg5PeO+zPO9OJylqQ9G0dAUegngjgmIHntzTGLUyc/iDRZM8884xlKMbbkja3tLnb3vusnrh4Wa1BAH6CrPUnnniiyacgV5CVj6tnrSDkib7CYYv2vxJvhnPPPdeIfLyL29Hgt3CkUoJlk2847bTT+lRTSXmCdDdrd9YTAG4NRECaSpbsJJuApoGHa2jRarSaeCrZsp944ol40kknRRGHlkyHjNNk6sYUum3rjjjiiJrqow9Qn8zcGjWL+lBFEhDlPQ4ir3oyTCw+HZxsVaxD4DYZSXpYN88885jorcg/E3dm3YorrhjvuOOOtGnL5mQjHzVqlCVv0cc4itxoWV38wNURUOMpSlfE7isyosljqfpOvkVTEGj0u4uT4F3C+0Mh2IVzQiSedQpZsnW77767/U+iCnmOx+uvv96E5Nkmm0yHdyfrRMxEEgGJCLfviMiDqHBNeydSYHH5nfBeK4DjC22FgAj0KJ0lE3En8Y68LSPZHtvByJrJ86Bwq3aoTlfWAZF8ksVJysewBm/eL26OgCPgCLQbAvSPSERIElbaU7yvyEhMdnGFkkcRO+1WZa9PByNAf07koSXyo6/XSCPpFG0dhVZHSYxF6Yzb/a0oB5vL+a2Rhx9w2SQRksastSXo8/CskqyYBEE8pyR1rMU863ctaNW4LY1redDYi7TGXdtyc3n+RLn02o3GwyOXZ6unEt/EWWaZJcrrMe655572IJPVDYKxFhMbbw/kL37xiyjPwShh5fjQQw8Viqh2HHlcRHkVWf14IMiELZ0Te7nwcPCw77ffflYeWbUUShDlFWrbk1EXolSh1JaVHWK0VQZuF1xwgWFKvVjmwXfrDAQgn8h4L+Fwe/YVrtgZFe/iWjby3cX1VQilvUd4z8j7uUAuQiyyjizeDDSQqXjIkCGFbSECUqbuLFFJhnmNStp20muKGkm1LHuULQkRI8EhL4vLb+f3WhffXl11akpwEPfff3/r9H33u9+NStAUaTi30hRqZQMBraxDLxyb90c2IzjfMNa5OQKOgCPQzggwGCxPszhs2LACIUJ/UAlOovSY4/vvv9/O1fe6tTECipqLiuSISqAa33vvvYbU9J133om0cwYPHlzgJfj+pjY+/Yg04bzQCXbeeecZjwEPlkjWdA6fffZZ7lOYjC21o1udEUBYlSzWhCzjtl5KrLzOh2xKcYQecm7yHgrZJDqEJRICi4gq+gRk/a7V0CEhHA1tEsLKcesvtnocJ1smum7oXhHyhluyXgoWnpndppnL3CvIBODmrQ5DkGdV3bUvmnk+vXosde5Mj/bII4+0ZFBo6qCx42GLrbsjGvnuqvWs1CixbwLC22icirwMIiotBDdb1ptvvmnC8ryXeD8ROp7H2u29lqfOvk17IaAGuSXdQboGWQGysCJ10QojvE+dBEuokPf4tBXaWYg+73nUazvaoGTdzWMkt9hrr70s5AydOEIw3RwBR8AR6AQEePcr6i8oMs5CZx999FGTzkHmAu0/EpWQCIR+ppsjUAkBEdyWJGb22WcPt99+e5DDU6XN+/0bbRW4k5deeqlqGUiyJDm8qhu3YAM4FfTPCVGn30V/uNhefvnl3GHzTlQWo1eH/9F3UviwEXnyCOzphCdkopVnZFVUyZy12WabVd2uWzdAKxOigvtFI4LWQSRBi1tnIwBhhK4IYst88NDw4F5ffPHFO/vEeqD2zXp3VSIqewBmP8U2R4CBSRIaXHrppUESL6bPpFH/ptaaJIToHkl2puRx6ZjSKSUDpSJZAo3gf/zjHyW37eWVDAQzyAzp+9Of/jQMHTrUkhWWwkQRLNYmg6geMWJEqU18nSPgCDgCbY8ADjR33313gbj805/+ZM40aP1DWjItssgibX8eXsHmIkD/bY011ghvv/22ZbZW5GhDKwChDndUzX+QQeR6ZRev5wl98MEHYcyYMeGiiy4y/qvSQPGdd95p2OY5vhOVeVCqYRvYY7J6I/ZLynaF7dWwd/dtSqIIGrzV7Ec/+pF5NVbbrtt+p1OF1yQdrNVWWy1IY85Gb7rtPHv9fPjgkbUWEWa8ZSHvd9ttt7DOOuv08UzudZza6fyb9e7Ce0mSGUFaLoFlN0egHRF4+umnbZDlrrvuCpJnsezbkrhoaVXxMiZJIROdCbwM6HwuuuiiQTqb7jGTuTq0TSFvFSJpbVMSU2AMnh144IGWTTezuS2SZOeee+4Je++9d/FP/r8j4Ag4Ah2JgPIomKcliUr4nv3973+3vjrelgzgkDCFhKtuvY0AA7SSWrLBT9oUzTDlpTBPxFJeiByfhHf0J4myajdjwJhBTenvV6wa0bgXXnhh2HrrrStuV/gxd5C4b5gLAbHJcYoppojoU7o5AuUQUOM/6mNomhMkypFLeblNfX0XIaDOoukXapTOrj3izGPHjo0aieqis/RTyYvAoYceato3+iBHNYxNYynvvr6dI9AKBDSoZknu0E8i2VurtL9IpDDHHHOYMDva0568rLa7geQ5aLopa6npKaORmxIiZktyjcosGr7sCDgC3YQA7zcSl5DwluQlIoIsCQgJYjWAY4lc5RnWTafs55IDAZIxkcMCTfhmGt9l2jXZpHb0D9KkEPRmVqfmY/E8bbzxxpNoUqb6MwdXEjfmNfeoFGr1squvvjroAhlTLAHfehXr5XQJAng0KNFKULb08PDDD4dVV13VPBkYvXPrPQTQIlGiCnOTx3sP/Td0SZdbbrneA6NHzxgPJ32sC2fPaKky4hX+9wVHoB0RYOScEXE8DkRuBSXfMY9gQosbbRyP9yTh4Eq6Z1EIjQ7JavQ5tbJ8PDcI7+YaEhYuAji3dlQr6+3HdgQcAUeg3gjQJiNMHG9LNAn//Oc/m3zb6quvbiHieFwqy3i9D+vltRkCRLt9+OGHgXDsZucYIcJyvfXWK4kI0afor7az0T4kUuOaa64xjcriutLP2WGHHaz/W/xbqf+dqCyFSj/WKQN2WGGFFcI222wTlGm6HyX4Lt2KwKeffmqdunHjxgVCDngBoeOAFoWbI6DsZxYWPn78eJOM4ENER5xBj/4kpXJEHQFHwBFoBgJ82xBNR9ICspD58OHDG3ZoZSQP6667bnjllVfCJZdcYjI7DTtYjxWMFulGG20U0G9DN7fZOqQ9BrefriPgCHQAAq+++mqBtEQGA71LRUJZiDjalhCYjUqw0gHwdGUV4XNIbENyW6T8WmH0/yZOnDhJIhraVzjFtbtBVpJ3hIFPnLSKDSL41ltvLV5d8n8nKkvCUttKRmAQef/ud79rehd5MyvWdhTfutMQ4GVH1iuSEPDQQmKjQ9dqXa9Ow7GX6ksyJQhLRqLwTuJFv/3221sSi17Cwc/VEXAEOgeBv/71r+aRB3lIpACDciS/KWeQm3QE8E7Ja+iIoT9Je4vEOf4dzYtc/u3w7McTgg4E3kQrrbRS/p19S0fAEXAEuhgBkoMoTLxAXKLhi97ej3/8Y/uW8T2DC2CdW+ciQKQGOUb++Mc/tkwLkmSe888/vxHjCUm4pV133TWccsopaVVbz+E9Nt1003DddddNQlaSLPjFF1/MVf+eeJpI5X7wwQdbpkMSlyQjycugQYPspZPWZeeE5OH+jZA4N0w2RC+7HUQCou6w3E5SZpHpvWU8TAhJk9aJdcTIbCUduvCXv/zFPG29c9V790QtZ8x9Q9IdEkMcdthhgWzwhIIvueSSljDi448/rqU439YRcAQcgYYjwCAtmR6RNOEbSFZpkoXhAVlsRBXQHsMzAO+9PEYHcciQIYH33wMPPOAkZR7Q+rGN9NXDVVddZV6r66+/fkCexM0RcAQcAUcgWP9+5ZVXDtLXs/BbyCQG5+AHkHGirU42ZsiZX//619aOd9w6CwHINSTa4HVambCG+4gkgVmjPrS1OsUImSexDskXi8PnGdzOa3UlKssReXkr06jtaDjD3JK1MltHtCcId2FeynBXffPNN414onFd6qYlzBv3XMiF2WabrVQxvq7LEeA+gZDccsstg4Ruw8iRI8Occ85p62jo77XXXmGGGWbochT89OqJwMwzz2yZoBnRo/NPOPgBBxxgH6ktttjCPLdLudPXsw5eliPgCDgCtSCAZwmeCOedd555hTMwh4c4jf9kyFrw/7/+9S8jxP75z3+mn8rOkUrBewVPv7nnnrvsdv7DwBGgQ0F7dpFFFgkbbrihDcIPvFQvwRFwBByB7kJgpplm6kNKEkWH1i8Danzn5pprrrD44oubsxNOT3zz3NobATQpuX6tCvnOokNWbCJU0HTEGLCFW+gkS2Tl0KFD+5CVtPvQG89lIu7qYiJqooTV61JWIwohU6UAifJS6lO8iMo+/5f6R1qClqWo+Lcnn3zSMnwXl1m8nf/ffQiQ2equu+6Ku+yySxRBbfcW2bvPPPPMKAHe7jthP6OWI0A2OBEAkfuMd5k+WJFst2octbxuXgFHwBFwBLIIKEQ77rPPPpZRWmHe8d57740KAbJ3F+8vJjKs/uxnP4sadMnu2mf5/vvvjxokjhdffHGf9bX+w/uTMshI+Z3vfKfW3Xtue0WBGE6KKOq5c/cTdgQcAUdgIAgoyjLedtttcc8994yLLbaYfe+mmmqqqPBwyyT9/PPPD6R437dBCBx99NHxe9/7XoNKr73Y1157zfin1GaiHdWJJpI1yrOyTzZwaY3nOpW6eFTilYiuTXbUXKC2lSVGurhSuiGLV03yP3oTxZoTsMGInRKqSRiTW/cjgEYWYVGMcuA5ucYaa5i326hRo8LLL79s2cEYRZtxxhm7Hww/w6YjQDZoMqUx4oenLpqnV155pWnBEWp58sknh3fffbfp9fIDOgKOgCNQjAAJBtCixCscLwA8A3bcccc+kSlknEYLsVwbSq3YwPcV4XUiFgZitNnQYMQrk2+5W2UE8AYaO3ZsOPXUU619U3lr/9URcAQcAUcgISBS0nQraZfzDUzyX9NPP72Fjou8tOgAQozpV5aSSUll+bx5CCBHQzRBuxiJm0SeFqrTaR6VqeJwcNznSMoke+utt9JixfmAk+mI7Q2rrbaaPYQ8eGg0yMvMkj/g5kxoNB1rXDwRT6fRWWuMPQ/4+eefHx5//PFAZ32eeeax7JLpzPIcB7drhG7l/WiagexLZ58QF8hKGtDJxFjb8QgJhwCQ55yFiKNDmWyrrbayBvYzzzxjpFVa7/PuQYBODcLJZHq7++677T7m7MjuTuZudBdcc7J7rncnngkdeTTb0MlBIxeZizXXXDNssskmYYMNNnDJgU68qF5nR6ALERgxYoQNrEBOljIasWSdzhpJxXiXEVK36KKLZn/q9zJt1CeeeKKPDFC/C+vyHZEXod2ORjJtZTdHwBFwBByBgSHAe5VvEIN0TMil0JZfdtllC0l5FDnVJ1R2YEf0vfMiwIAq4fpwV+XsnXfeMTlBRU82JZyf++Wggw4KEHvI6qAl3Y6GPCID1JCptNcg64uN9h/65DfccENQhEuuAegBE5XvvfdeuPDCC00/DQ8fvM1go0kqwwWfZZZZbESW0Wy8LpmT8h1PxLyGeC3eayQl4aEmE24afWCe5zjFROVll10WjjvuOGsAH3jggTbCQX3o8JNV6fLLLw+rr766eQRw3Kmnnjp89tlnVmUIAbwpW5m6Pi92vl1+BHgJ8MFgglznQwIJPu+88xoZv/baa9tHRGFj+Qv1LR2BJiHAvXrTTTdZh1IhJ5Zlba211rLOP6Sl37dNuhB+GEfAEeiDwLPPPmuDvjS4yxmNb769kGLJaNuh74wOeL1MUj42AEnH0K06AnQm8OTHYcB12Kvj5Vs4Ao6AI1ALAnj44xAFvwFXQZQq7XWcDnCwou+ZJ/qzlmP6tuURgEwrjsLFKQ2uiyTM5CzBIOaaRRrSdvrqq6/ClFNOacduxz+pjtQN/OD5GHxmkBpP4mRobTIADTGPpmtVU2NtwCbCzvQXDj/88EJZatiYrlBWA1JeabadvNCivNUK21Za0A1h+yjLVmEziZwWlvMeRy8AK0celYV9b7nlFlsnotLWffDBB1FgRhGhhW3QmRBDHEVU2jpl440K7Y1KmFLYxhc6CwG0s9QhisrOHffdd9+oj0AUoW73gkL84xJLLBHlYRuVtS1y/7k5Ap2GAPe4Bl2i3OxNR/d///d/47rrrmv3vAZ3Ou10vL6OgCPQoQio8RqVDMz0KNUgte9sqblE10139/3337cz1cChbUv7spql950yg8dXX301anA5oi2ukfuoDkaf3RURYeVmVz700EOmp6lBcXtPqjOS/TkqqaJpsCsE3crM6jaiSY02NW1UtqNNwXuX9686PFafI444ItJuPeaYY/rocfIuPuecc6IG8Q0jScdEtDTbyRQNFaebbrooD5N2qpbXxRFwBByBrkRAyX+jJDdMvxnuge+lHMDiHnvsESVdEuEl3JqDgByWoghjuwYLLbRQhC+Cy1LG9yi5w+ZU4r9HGahOdzMqC7cnKbwoZ8AogjJOM800UZHQhhvttGQiXe1eTv9XmuNuPGBLRCWNMYyGKQ0bhXj3KRsxTSrNQ0cimjxGWfJos30gB+XBGeWVabvWcpxSRCXJUKhLIiqVCt7+P/fcc/tUTayw1ZvjyUMpQrQqxLLPNv5PeyDAgyCNifjggw/Ga6+9Np522mnWcYB8VkbSAiHJddfIRFxqqaWiwvhN3Fgh3m3XSWgPVL0WnYwAzwQfODrPEJYa6YqS64innHKKdaI7+dy87o6AI9DeCNCe4nubZ+LdNHjw4Ehb8YILLrABYoiyajZ69Gj7nnMM2ot87yEd+Z825+uvv14oopiopK3AACUDlzSyFVFjgu80tpOttNJKhUSMJEiQl6f9RIcSQpTjKBu5tSdInkC7gnUQkAsvvHDcaaedojLE2jpIzWQkVqA9SaOd5AoMikuLM/3cNvNhw4bZ96NtKuQVcQQcAUegBxBQpFS84447bCANJxq+K/Rd4SJOOumkKP3LHkCh+acIGUy7grYB33gSRrvVjgD9z+OPP94c/EgAm2fgufgoX+c8151fD8MNFhPTHDQq3MfVk/W4gqK7gN6fsv2EH/7wh6yuaJSJuy3h3hp5tpBsNfTMlbSex6ESL7zwgtUF8dKsUQcmNAvQK9Toe1DjN7uJLw8AAZIwcb8gC4DGHsvMS038xqSbvzDhNo8EABMuxcm4ZjPPPLMJFqsTYfce8gPzzTdf0MiIhXQXJ0lK+/rcEegWBNAMIREFE88NySQIEZcHfFCnOqAtLE8kEznm/ezPRLdceT8PR6D1CBD2jWaRolGsMhossRCmUjUj5ApdaHmOWJuLMPA8oU7jxo0LHAd98bPPPttC5SifRAW0H9VQtvWljkm4nQahLSkZdVMW8kAbE+mXBRdc0MLw0AEmBA9jTvg4JhIyILPBO5b2LeF7JNNDu33++ee3UHbKIXydECdkZH7/+9/bvui2U18RsyaVhKYTx+P82800yBvA2M0RcAQcAUegeQgQWkwIOBPJ6f76178WtC3loR/k3W/fV75LTGznCV0Hdn3+rPwk5KBQhERQZGUgJ4lb/xCgbbTffvtZW4x2Hcl0xowZE7h34WjyWEOIShplNNrQ/ENrgeQ3yVLGorxaN5BYNJLQB6BTjbYkOpgk5KGBV6/jUD/i/zGISDQxs0ZDloYmE2LsbuURoAHOA07HBNFZJoVzBYXW2xxC8eOPP7bMmxAnSfuzVIlonZJAKU3y1A1M6B3MMccc1lFAy4MXszwWbEIXlftr1llntQ5AqXJ9nSPQiwjw3Gy66aY2QQrQAUdzhezhxx57rGkK09BBEwd9y/S+7kWs/JwdAUdg4AgoUiUwMbCM9jMT7x1F1ViSRYV8W4OV9xFGmw+iUN4jpmuZtwZp8FjejIVdEKCHqHz66acL64oX2IaBGgbO0ciE6MTQZMTQBoNgZDvWKXLIBsztR/2hPUKDm3dl6iAyGErblAFS2sPYoEGDjHSlTYwhNC8vShv0ZpAWfXQyjqI13G4G6Up7joFg2mRujoAj4Ag4As1HAO5j2223tQlegoEvBtuYLrroIkvKA0eRiEuW+ca65UOAxH1gB4dAG4Vvv9vAEYCfoY0Dt7bzzjsbN4j+Ne2kalZ9i2ol6PfEipIlGWNUmsYiD9D999/fJ6sP62igZRuTtlOZPzDbClG0hitZBzlJRsmvv/56S3ZTr+NweLIbYnKzDocccogt84fGGY1HRrxprLp9jQlesXihKvzJGtg0srledEiS0aidffbZjQCBQMTDkQY7DXoIRogTGPc00ehPpCRz7iU3R8ARqD8CfCAUAm4T71g6zdLtNTHvXXbZxd55eFtCWjKR1IykYm6OgCPgCNSKAAOHEIJMGJ0s3jkQl3gR0lbEEzEZHQYiHwZiDJLjIU7URTmjjcHvCLvTnsSjUuFJhc1p35aL6ilsVGKhlMg+79xs1AeYHHbYYeaJyUA8HpqVSNUSh2nKqpSIDUKVDoebI+AIOAKOQGsR4NsGEcl08MEHW8SUQpSNtMQTkKgpBspwPkjE5VxzzdXaSrfx0eEwwAquBwcO+Ai3+iJA0m0Gf4cOHRpYhrxMHGK5I9WFqIThx+jk0gilwXnyySeHVVZZxUbSyfpD+A4jyS+99FLh4SlXqeL1ePvwEEJ4SZDcfk5Zw/MeB3dpLEui0ejC8P7DGKU4+uijgzSLzFVVukLh4YcftlF2ficLOJ6Aeb1B2acbDJKWkQWmP/zhDzZBUNLgZqSGUHnpLJnnK6HVdA6Y8DCAmKx2E3YDRn4OjkCnIwApyaRkEObpxHucDIRMEJl06JUUwwhLSEvewQwwuDkCjoAjUCsCdLLwmmRS8jrbnQiLxx9/3MhL2nbIBOHJ11/PbgZTIURpn5Sza665xjzM8eKUDrodM7ttpage2oT9NcrdeOONrf2JhymDt9Ll7G9xDd0veeRQZzdHwBFwBByB9kMAx58NN9zQJmoH34I0Cd6Wo0aNsnY9bfxEWtKOzyOt0n5nWv8awQfBL+FIxUBlitCo/5G8RNpNEydONLyJ1mCwtqIVi1b2538EyOWNaCKvYkqjRsKtGDInkk1Zo9QRgXFVyATJ1djJfRgSo2g01wTSd9ttt0jWRcpS47NQRrXjqAEaNYpg9aOsAw44wDIYimCzdepsR8XQW3lkiET8XKCZoLrIVhNT1ci3JVzRyHvhuN26QCbK6667znCWZp0l4AAPxODl0WqivvJutWyaCP26OQKOQHcjILLAstiSFCL7flS4pGUiVGc/Kiyyu0Hws3MEHIGmIYCAPVlO8yYuJKs27RQSLiYbP368rTvrrLPSqlicTIeM5OynQWjbhvYk/5OhG6MNSjbuZCT54Xd1/NKqqMFYSwJUWKEFsrWuuuqq2VWW/ZLEPNhVV11l5ey+++6FbXifakCo8H+7LNx3331W1yy27VI3r4cj4Ag4Ao5AZQRISifCMu61115RZKW9zxXdapwKiTXlfFS5gC7/dZNNNolyhouSquvyM22f06NdpgFry6JeqVaT8aMaXQM2Rq2THiUj5ckYgSU0mAQohFbXylJTLtpFlMPIOt572fLrdZxUTprjgUldlV7dwpsJUerWkQc8I/EiZeQFMXi8JjGuF6LxaXKthnR3+NwR6G0E8EzHCwivSyYSWfCuRjeWMBTCKNM8hQ32NmJ+9o6AI1ALAnhs8w7BmzuPrbfeeuHmm28O5513Xthhhx1M+5qRezwleD8lbUU8Jmir8g5DjkbEpXlwKtt3ELEYDj30UGvzbbDBBhaahAcKOunKrmpRPSLrbH7FFVcEdW5C+h/PUI6DodONTAZala+++qqtQ4sbj5dFFlkkENaOl4sG3i1CR5nRrQ7oBGMaKLZkPJTZDsY7nggpzpVwdTdHwBFwBByBzkWAHCJ8g5gIFydalJDc5G1JCDTfq14wwrwJRQYLZK7cmocASYtoD9G+Ksex1Y2orPW0aCSiBVTN9tlnH8v4XW27RvxOYxE36nuVmZFGWjcZmkw8nLg4E9pJyBX6SGiAMtFgTyLw3XTefi6OgCNQfwTk9WSaxIRtkuWWOZIayD7QWWfQI010vlnnkhD1vw5eoiPQLQj0l6jkPUODl8FmBlevvvpqIwMZ6EZ796abbjKICHsjvJxkfxCbJPmj3XPcccdZuw9SDk1ywrMZeKE9RGgYxCNk40knnWTL8ra0jh4D6JQjD0kLZUc2CKMhjqQQ69E/x0gISag5ROett95qAzwQpQyOo1W5+OKLW/sMCZ12MCcq2+EqeB0cAUfAEag/AjiC0WZPxCXLtM8ZoIO4ZEBtmWWWKekkVv/aNLdEzp3BSJLpkazZrbkI0E5DmockhWSwL2UtIypJvANRVs3w0IFEe+ONN2yC9f/8889txBqxcsROmdBChGhjIuYdPbWBGB1vGqOMyJNJqxsM7EhCRMOdERReRDTMaXzjjYC3qpsj4Ag4AvVAgI4+DZ6nnnrKPI3wNnr99dfN85IOOZ1xGggLLrhgYYLALDeqVo86eRkDR4AgDLzwmWjkMaWoB7xqs0EaaRmNO4icNPE/Hm58p5On28Br5iV0EwL9JSohHmkj4g2SN/FLup9TsjDuZ9aR+DFvVE9/scfjM6v1W/x/f8ut535OVNYTTS/LEXAEHIH2RYBBu5SUB/KSQT6+pWuttZaRlngdws10g5EDZYsttggvv/yyOVB0wzl12jn86le/ChMmTDDnllLcXcuIynJAEiLOiPcNN9xg4cgpCU7KFs3DQmOSBiRkJ9tDKtI4JZyHRiUnKh0ge6Ag4SAcazXpOBhBiRgt4UGdajS2CYciDTxzyElGSEhwROKjbAO5U8/R6+0IOAKdgQDhj8hoQFri7s8ymfakb2kEF0TW3HPPbcQlpCWhKNmJpBpkznUrjQCJz9I3Mc35PrIM9iwzsQyZwzwtpwFAwlaZKCtNX331VUgT35R6G2RlIi75fvN9Z+Jbn773aZmBSb5bpSa83khKwgRR5V679b5SzSuvv0SlhyfX/xo5UVl/TL1ER8ARcAQ6AQHCciEskYdD8gnuZckllyx4W/KtLkUwdcK54YxGW5HkLm6tQQAZgkGS5Ln88suNmyquRdsQlXRaCaVB9weycbXVVjNvRvSDcMmddtppi+s+yf90quj04sFDODNhNu+//76RlmS8IgQnTydXCXXMzVlCn4VslJMcrM1X8GJB9whXZjwp8Zwk3AgM6Oi5OQKOgCPQLghAjBFSyfubTL1MeF8SPs5oLiQZBpHJSK6So5lW2myzzdZnjn4ag1roYtL4gMxqZ7IK0i8RicVzyMXiCW+rtC67nNbhCVbOIP7wZOVbyjxNiQBMhGAiCZnj3UrkAhMN0ezEt5QJ78jsxPGLMeebzoT3ZVrmmnL+pebcDxCniTxNy8w5V849O0G2Fht1SsQlA5zcF9n7heX0v0TUjdwsLsP/bx0CtRKVSWuS9t/SSy/duop34ZGdqOzCi+qn5Ag4Ao5AjQjQBrtXcngpTBxPRNqScDaEiOMIRVRrJ9iHH35o/QcltitkSq9Wb0ja448/3rT56Y8kLX4cLHCqoJ2J7AvEJxFltLd33nnnsP766xeKxjHj/PPPL/yOxMuJJ55Y+L0XF9BExSkQsrLYWk5U4gWJ9yJ6kIQCjh49OgwfPrwu+oiEnd1zzz3h9NNPNy9N9IpY5mEqZ+xDA5mOFglmijtc5fZrh/UQtTxw55xzjj0ovCy22247SwjEQ+TmCDgCjkCnIQCxhZcUpGWa8LRnHVrHac6gFERY1nh/Q1ZCWkJeMkgDIQcBlwi5tMwc4o3GByRXmqdlvg2JbEshz2meQkUh3WjIMCVvxOShmCXbINYgJit5J2alTZIXIfM0cV5pudScBhLrEzHJeXSrcV0gLhmUI2yJBijz7DL3R7pfuGc++OCDPvcL9wMeu8UTpDgNSaZOjq7otGufl6jkGdx+++3Db37zG5MgYGCbdiQDs271QcCJyvrg6KU4Ao6AI9BNCLwhWb7kbXn33XdbOwwZuURa4rFIG7QdDTIRvomcHbSV89i6665rDnBwS+hLozNN3wCi9uCDD7bBfPSvL7zwQsuvAr919tlnW4I+ZK4wficXCIn7wG6zzTaztmqe43frNhC1TO++++4kp9jSGLrTTjstEJsOC01SF8K062l0UnlImHiY9t13X0vgQ4IcvA0JDys2GruPPfaYJYboFJKSTvv48eONoETPk2yV6Etw3p1yDsXXwf93BBwBRwAEIAzxomRafvnly4JCYwGCiomGB+/CNE/LeOMl4hAiEbIq+38iHhMhmZ1zYMi+clPW2zB5IuLR993vfrdPGHPyZGROAy47JWKRuWs3lr3Uk/zAPQIRzcSAZB7j2nKvQFoiHYPnbnai0c3/kJtsi0FyQ1gOUphKmtMoZ1AQqQLIY7fmIsDzeOqpp9qUjszz5+YIOAKOgCPgCDgCjUOAttDIkSNtYsAeb8LkbUlUKoP/DDom4pKQ8XbhJYjkpd2Wl6R88sknjZyEYKTdjoTescceG/7whz/YQCl9lEMOOcTaiyQNpU9A0mgS55FkFKIS5zzC5/E8xZivuOKKjbtAHVIyUTC0xXEoKHYIaAlRiWcJo92w2VxwyMpGd8p4mEgiQzg4o+90eNHCJPlOMrxcxowZY5kbOyF0iBAnwuU5L0jX3XbbzVyMCWdzcwQcAUeglxCg8UPYBZObI1ANAchNGkRMRHOUM7xe8eSlgcmAZ5q/+OKL1mhFXweCG6MsSMvstNBCCwWmdvUqKHfenbQegtrNEXAEHAFHwBFwBFqDAKQk3oJMRx99tJFOyPChbXnyyScb14PMDsl4IOiYt7K9jvceETR5DRINQ5oqGVwSRCXROxCVBx10kOX/ILIDpze8KTHCvTEc8xhMZzvWke26VLizbdxDf9J14Jq0nKjEowXPSRr5d911V1hllVWaeinIWgWzPWzYsPDjH//YtCzRGMCOOeYY08Q66qijmlqnWg9GSDovAR7+pZZaKpx33nnmOgx77+YIOAKOgCPgCDgC9UGAQVRG3ZlKGeH+EJhorGYnGql//vOfC+H9NMQSacmcQVLmNFwhTd0cAUfAEXAEHAFHwBHoBgQgnMiozUTE09NPP228BR6X22yzjQ3wLrPMMkZaQlzCyUB2NsuQX6plAJkkzUgyEbGKYxtRUSRcxhGOthwGD0Mk17LLLmv8DB6VRAwnw6EihYUj0wdJicfliBEj0iY9OU/XgWtSbM27I3RkPBMQFCVhwn333RcWXXTR4vo05X88DtEXILHMeuutZ67KdBTwTjzuuOMmYXObUqkcB2FkAoISvaDBgwebN0clvc0cRfomjoAj4Ag4Ao6AI9BPBGiYEtKT9IeyxRAKBVlJYxbReSYS3V1zzTXmbcC2aGNCWi6yyCLWJkpzvDKb2WjP1tuX8yNAB6xdQtny19q3dAQcAUfAEXAEmoMA30giVZn2339/S4qIvA4OV0ju4SCGljzajSlMnEHcRlst326IyVtuucV4o1WVoBivSaSBiA5ObTXadptuuqmRj4TEc45ZI/oGQpakzXvuuaclPCbCGIko5Pp61Spdh6YSlXvssUcgxv+RRx5pGUmZbgI6FySeQQAVxhvSFK0pwqfbzSAmebDRfsBVGpIX12o3R8ARcAQcAUfAEWhPBGi8LrDAAjZlsz5SWxL/QFxCYr7wwgs2XXDBBRZajiYmnpzsS9uEabHFFrMQdQjR1Chuz7PunVoRFUT77PDDD++dk/YzdQQcAUfAEXAEBoAAupBDhw61iWIIp05JeeCKkAhk0BbSEo4GzgNvxlbb66+/bhG5SBZCrBYnKiYjOGQkSXYwPC8xBjQxBq5POeUUIzIhaCFmkSO8/vrre5qoNHDK/GkaUUl2JBK+wDZX0oMqU8+GrIYdR6eSzgAhW7jntlMHADfpAw44wDwnuZkJJUth6g0BxAt1BBwBR8ARcAQcgYYjQKIlRtaZskZyJ8hL5HESgXnllVdaG4UGMIOshBnRjkrkJcvoHnkIeRbJxi6jVbr55puHHXfcsbEH8tIdAUfAEXAEHIEuRiBFpYwaNSp8+eWXlnAG4hLuCGKPRIbJsQziEseyZhskI16SyBcSlUudCFlGFuhHP/qRVSdxSGhQ4nVJHhbs8ccfDzfccIO12WjPkSEcvc6URJqEQ26lEZhMLO/XNG/p3+uyloY3DWpItiuuuKIuZdazEEKsXnvttYA3A5lg6SQ8//zz5u2ASy9aA8009K4gKMGKmx/tzDXXXLOZVfBjOQKOgCPgCDgCjkCbIEDjnbYJoePZCcKMZhyNZtpZZJv8wQ9+UJhmmmmmNjmD2qpBw502I52URhgeDExkmiSEa7/99jMPCY5F5M+1115rnZB11103oCWF9+u2224bttxyS2sv0mlCDD+1bXfZZZdCW7Fc2UgBEOpGW5NM5aeffrpdy/PPPz/MNddc4Ze//GVA85T/28nwGkVPHqxmnXXWdqqa18URcAQcAUegixHgO8t3E9ISfUhynSCXA8nHhHZkIghrgWGrrbYyPckbb7wx127//Oc/LXQdr8piI+8JbQYc3nbYYQdLrgNRiZzghhtuaN9OyMuNN97Y2gkMVFN3nOTwHEV6sFL4c/Hxuu3/t99+29pARA6vsMIKfU6vKR6VNLrI5NOoBmefM8rxD0w46eHxWHjooYcK2Zhwv+Vm52ZBT5N5M70/cREm1T03LNoMZPPmBndzBBwBR8ARcAQcgd5FgLCnJZdc0qYsCoiP43kJefnss8+G5557LtDw/uCDD2wzMlFmiUuITBrGeGb2quHNQBsQzW/agRCEdDLI3onXBF4dSBShG4XYPbpa/IbsDh0k2mcQkwwoM5BNhyfpaVUqmw7MZZddZrCTSf7DDz+0UH8SPJK5nMSIhP2PHTs2zDjjjL16efy8HQFHwBFwBBwBQ4DwaiIXmOBm4G0gBG+++WbjSwjBRhaPnCMMLDYqkzhkGiHr6EsycAxhiiMebQYGOplTB4hV6sngMUZeFv5Hj5zvOwN+RMdQHp6hHgljMJX903CikosB8QYJSIO5HQzSNLnjFteHEe9khFJxYw3UGD2nIYvmVCnDGwKtgjFjxpieAR6UaGWW275UGb7OEXAEHAFHwBFwBHoLAUKP8DwsloV55513CsQlBCbJ+MaNG2cee7Qt0L1caqmljPhM814gx5DUYUCYTgUdIDw3kSQizOySSy4JO+20k82JtMHr4dFHH7XsnmeddZYRmg8++KCJ4EP+YrQT8ZzAqpVNO4/OCYQnAvq085566inz6KSzgscIbdBeuA4GmP9xBBwBR8ARcARyIkDbhe8t04knnhjwbkykJd9uCMEVV1zREjcPGTLEBhZzFl1xM8qFDMULMn370w5wOIR1p+gV6pjlb3CASx6ffOfTIDFtDLfqCDScqMR7kdCk3XffvXptmrQFGZkYSccLoVzkOzdT0hwYSLVwV2YUHQyOOOKISYqikbrrrruafgHbkflqlllmmWQ7X+EIOAKOgCPgCDgCjkAeBBgYZvrpT39a2BwSjBBmCDW8AphDjpG5EoO4w2sT4jJNjPi3e0gS7bjithx1LlXvSy+91LwZfvGLXxRwIZoFnal//OMfti4NUIMHWuYYxC6WsLJ/9Cd7jDxl46WJbbDBBuZJkW1nusSPQeN/HAFHwBFwBByBqgjQPhk9erRNRJcw4EjukRNOOMGcvyAD1brDyAAAQABJREFUISxJ3MOg5Le+9a2qZZbaAKc7yEoiLxicJNqWsoiGIBx9o402Ct/+9rdL7errBohAw4lKwpfR/2kn5piGJV6L3LjljBuQeg/E8GjYbLPNrAgISFyCk9cDDxQhQmgUwf5DWNJBcHMEHAFHwBFwBBwBR6DeCDCqj6Yi0xZbbFEonrZKIi4hL/EwpI1EmBKNb0KfsxOh48lDoFBICxcmTJgQtttuuz41oG2Fx2KxQdRyTr///e+Lf6r4f7kOTpaozFN2CvMqV17FSviPjoAj4Ag4Ao6AIzAJAkSXIJfHRNsFvUNIS6RwTj75ZAsJh4dhkBDvyFpsyimnNDk+kkJTFgOW6DWvtdZagUzfxUkRaynbt62MQMOJyjvuuMNCXCpXo/m/0qCkwUgjE6a82GDOB0Ic8pBAUkJIYhyL/9GRwsuSEYDPP//cRNppYGcbu8V18f8dAUfAEXAEHAFHwBFoBALJ+3KdddYpFE/7hJBxtBmZCHkm/BltJhrteBQwmJsITNpLrG+FIaYPWZk11pUydKMQxacNSPb0rBEOjrdELZZtu9W77Frq4ds6Ao6AI+AIOAKOwNecy+DBgwMTRCLfe8KzSXRHNAVRE4Rq18Lz0KZgInqDxMsp8sLxbiwCDSUqEXOn4bf88ss39ixqLB0BVG5csjdedNFFZfcm9Km/RqYnxNohLDHIUMK/eSgQVkWzEn0FD/PuL8K+nyPgCDgCjoAj4Ag0AgFIN7wEsp4ChI4jmZPIS+ZXXHGFEX94WBIevcwyyxiByZz2ThKUb0QdU5lE7OSN2qFdd9VVV4UDDzzQPCQS0Yj3BZm4+S2Ppf0gbpMNtGwyftMJInGSmyPgCDgCjoAj4AgMHAEGJUl4w0SeEjwtSfCcvuO1HIF9nKSsBbGBbfs/A9u98t6MxmMDDaGufJTaf8VtlwY3NynaBaVCmMjAOPvss9deuPYgWyRh3YmkTIVAVkJSQlBCkDpJmZDxuSPgCDgCjoAj4Ai0MwK0lRCSJxEMpB5JYf7+979buwZ9RvQwGZA95JBDTNKGEGs8L9n+tNNOs2yd6EG20hDcJ3MnWlOEf5199tmWJGfzzTe3NiF1oyODJc1Kljkv7KOPPrJ50pq85ZZbLIycdmWest9//33bnyQAWSOKZ8EFFzSd0Oxxs9v4siMwEAQYWKBvghd0Kc38gZTdrH2RnaiU8wCif/XVV7ekF42oU6PLz9b5rrvusnPlfJl4x2KEsg4aNMgSpGW3b/UyEYQkJNtkk00sEVmqTx7M2IaEb3vvvbcNOvF/HiMEl/fusssuaxgl3iHPvmzTCiw7/Tksd53z4FnuOu+555597vX0ncx7HWvZDm6HDOJZfeha9m/mtq24P5t5fnmO1VCi8q9//auNDBPH3y5GI5MG5T777GMvUjwfS4V+95dcpdE+fPjwsqdLCDhEpTdEy0LkPzgCjoAj4Ag4Ao5AByCAdwHejHROx44dG+hc08567bXXwuWXX27ZN9HAhBghDCuRl9tss00488wzw2OPPWZhVM06VcK9ENyHaEQEf5dddgmQjb/+9a/DnHPOaVlEd955Z6sOdcMDA29LCB7syiuvDBdeeKF5j0LaPvnkk6aJBelZqWzC65H/IcEktv3224cLLrjAlvlDBw7vTAjLvJ30ws6+0DEItPLaQjC8+OKLlkSrlfUYyMX64osvTDarXBk4iDz33HN2jsXOIuX2qWV9o8vP1gUdXQZ4ICX3339/y3PA70QqMnDCvJ0MSQ3eYSRooy+cLA9mbPPmm2+ahMcbb7yRy9ONvjvvXchJnH9mnHHGgj5hOna1eSuw7PTnsNx1ButqeJa7znvssYclFiZEm3u+kURltXuinX4vh2envr/7ha1OtmGmRmv83ve+17Dy+1Owwn3izDPPHBX+Xdhdo/1RngIM39ik1PFRjdPC77UsSKS1T1mpzOycY40YMaKWYn1bR8ARcAQcAUfAEXAEOhYBNbqjEizGMWPGxDXWWCMqcsXaXLSJFDYdd9hhhygPx6gOelTIeVTnpWHnqg5TVIRLfPXVVyPL/TF1lKM8IyPzrPW3bHmbRqZ2M3nO2nV677332q1qHVUfEeNR3sYtrfPNN99s1/Kwww5raT36e/B55pnH3hOV9v/444+jnEEqbTKg3xpdfqqcHGnsWim3QVpVmIuoLCy324K8G63e2XrlxUzJZSN98DymASQ7jqIjbXOuOX1t1tdircCy059D8C11nVmfB89y11mJh+0aPv/88xTVUJP8X1x//fUbeox6FF6MJ+2N1VZbLSoyuB7Ft0UZb731Vtlnt6EalYwMt5PWDiM8ZIL81a9+FcgOlezII48Mv/nNb9K/NqJdi8Bq2pEQIoRaqxlh57jwDxs2zERdq23vvzsCjoAj4Ag4Ao6AI9DJCOAZxJSiTtRCNs9LPIfShMciOuJ4PGb1Met93skTdCDlEiFTKvlOf8tuhp7nQM7X9+0/AupsBuQFCDlspSHf0O2GdFcjrdHl56m7nIDybNaSbUrdY3kx453KlMeI2sTSHM94JNXQSq7FWoFlKYxqqXM7bFvuHPLgWct1bodzbWUdivE84IADLDKD9lMvWPd/sTJXcdy4ceFb3/qWuRdnVpsm0KhRo4zEhETk4teaSIds3mTyrmTpweQYhMMTVkT2KTdHwBFwBBwBR8ARcAR6CYFE6BE6vummm9qpExpG+JeiTnoJCj/XLkYAGQR5wAT09HBmgFhBcgBdPezRRx8154WXXnrJ+iPrrLOOSSnUAgm6d5D8EPwMBpDkihDa9dZbL8iD2fo+5cqTt5sllkJz9pVXXgnLLbecJRzNOnRcd911tg0OH9///vdN3x9NWmQeOBZlkCQUZxDOY+ONNzapA+pw2WWXWX/nJz/5iTmK8NxjeY5brs7l1hMaLm81cz655pprCudNlt4zzjjDsGYbZBvo9yWtWc7rt7/9beA86StynUi4Mddcc4VjjjmmkLOgVPmcP9iVMnmImSQEv1EmkzyTLXcDshLTTz99qd0qrgNfnGsgMBLx/Ze//CWcf/754fHHHzdHHHmemsxYxYIyPx577LG2L6uQ50CWg+uf1lPPCRMm9OualcIsHfree++1ehPiinYqSXjT/ZG2KTefb7757CcSoLFMeDzXmLDht99+u7Abkh7lcG4ElhwYuZCJEycWrgdyIvLeK9Sp1EK1a1jtHi5VZvG6dD1ZX+k683t/zqEUnpQ1kOvM/p1o5Z533ntIySBdgMEHKcLEpHL4n/fvtttuy6K9S7PPOiQlyaAx5GN4Px199NF2rQ499FArd+WVV7bfu+ZPI30+pQUZ9YJo5CFyl41L+AwzzBDLhTvo5Rg1mm2up5NPPnlNLrWff/55XGCBBaJIUNtfN0dhTln8P+WUU8af/exnUR/AKI2Y3PX2DR0BR8ARcAQcAUfAEeglBAgNa2Tody9hOdBz9dDvgSGo5ExRZJf1BaTNGu+5557IOmz8+PEW6ird0yhSz2Sn6DNstNFGuQ8qEiBKV9/Kp5+DjMJ2221nfR7KEilaKEv6rLZdti8kwtH6MMo6Hwm5FIERCYtMRiit9P8i/SSRTibbQP+OvgzPKceYe+657bhKimFz1smDNC688MJRyU6i9FttOxFgqdhY7biFDTMLlUK/RQRHkaUF+S1F9dmeH374YVxiiSWikuxE6RnGBx980GTJkJ5gGVNnP4qYszpS5w033LBwbiJ7bZty5Y8cOdIwpqxnnnkmatDFypF+ou3Hn4MOOiiussoqdrzzzjsv0jdUJuJI/7GclQr9Fmlh5wK+SJklW2mllQr929tuu82uffotz5wwUhEkVm/p9RZ2kR5hFHEYRYTbujzXbIUVVrBy2KEcZvx28cUXRyU2iyKIDYfDDz/c9qMvnscIgUXKDSy4vqlvLSLHninWr7XWWnZNSpXXKCy5D+SYFEXsRml2xl133dX4AQ3AFapR6jmsdA3z3MOFwiss5L3Oec4he505ZDk8a7nO3RL6Xe15R0ZFA0p27yKHg+QL7yPpcxakZErhqUEte29wb/Md4X8MOR3WKemW/d9pfyqFfuM92DCTkLp9MPqr/1PPivER4uMrJrtssRJ7L7zwym5U4gex2rYfNwkfH17qTDQW+JDQyKMB4OYIOAKOgCPgCDgCjoAjUBkBJyor49PMX52oHDjakDH0ESBjkqGPihMDpGLW5BFj22YJo+zvpZYhKylfXosFzVWIEcrHiULeWrZbMUECUSaJLiMfU7nKhhvl5Zz+jfIGM0Io9Z8eeOCBCImGQWRxXEkgRMgUjPNinbzcojwubR36tKyTp5D9n+e4tmHRn0pEZdo0EW6JqET7lj5ZVuvt7rvvtvrgZAKZhJE7gDpCMCWTt5P1HdP/zIvLh4QGBwwilH4g/U0lh7F1kHxcg/Q/KyH8ONY555xj25T6U4qoZDuFONu+iaiE4KYsSJ5kP//5z9Ni7jnXlXJwqkl2ww03WF35P+81Kyaw2LcYM0hveTlGJRjjZzPKB7c8RKW8Jo14ZnvqDOmbrjeFSb7N9AeL9YO/PtI3fxuBpbzlrE5KtGYHSs++JN8KBy5+Dqtdw7z3cOEAFRaqXWd2zXMOpa5zMZ61XuduICrzPu8QjbyXINnl3T3Jd4DrUIwn63g/s1/WePcyAMLAQCdaJaKyPqHfytSlgPmg1FshvPtukMCQ3hshLCBX+iEzzxy++PnPw9Qt1kX5v2eeCbvPNlv4jkITytleCskeN/nkYTnVW3ENX282xRRBfvshLLJICCusEBSrEeSXXigCl/OUuZEQgnXXXTfoAxQ0cmcZyAob+oIj4Ag4Ao6AI+AIOAKOgCPgCPQkAupgFs6b0EDCOYu1WAn9vv/++y0MWR6Yhe0rLUwzzTT2MyHN6RgLLrighWDLoykgT0WYYLFNNdVUQV6Ugf3J5nvJJZcEJZmyeqVtqR8a/ITmEhZNCGuSx5JHnB2P8FqyLmOE4aJfJy/LIA9PWyfvoSDS1LJVsyLPcW3HfvzJ5kZQp91C4ueYYw4LlU7FyXvNzplzBRt5pFqd+F0elWkz0zskbJVs1qncNE8bEXKMEcop0tnyHMhT1s6f9eQk4Les1Jc8qAwnRfuxSU1WfHxCwNHKlRdXIHxYTjeFMNJaCh48eHAgP4NINLtOhI8TTk7YMjaQa1ZcZzkyBc4dSYRklC/SxjK2p3Wl5k8//XRQ4lp7bkTw2X2JXAj35t577x2U4CyILA8iWavqXRbXqx5Ych2GiEPgnkLijWcH49qUs0rHreUeLld+dn2168y2/TkH9ivGcyDXmfLayZClKbZSeqp5n/dVV13Vnq2zzjrL5CC4Z4utGM/0e3rHp/9594rMTv921TyfYm2pU/7qq6A32NfEnV5mQjvoyxrC558HiUGEIDHjZfRhunattcLUIiv5v5XTOausEo7Qx7ZSHaZRPQ9baqmw1Oyzf7MdjQq9ACUCEMLyywcJmgQJYYTw1lumpYEWCloe6LqgiSFG24Ti0we7FHS+zhFwBBwBR8ARcAQcAUegOxBAIxDdKcgciAI3R6AUAtkOZuqYFnd2IRIw+hUDNfQkMTQYyxkaaSeccEJA2wxdwixRxz6bbLJJgDCFFBo6dGiASEV3sJKV6mBDXpJkNVm146btBjKXh5El5yrGmLosT59OVgln8hrktRNPPNGSguGskiUNINHk+VdIGEbiMIUpG5m277775i2+7HbcU5IOMB1NeWgGeYkaSVd2hwo/KEw5QMjQl0VLVaHspnOadqnXNXvhhResyHR/pvI5l+wzktZn5wq1t/42xCREOPcuBrkmj1bT7kP/E6K1VqsHlspabs8bGrQQvfJQrVqNSscd6D1c6uDVrnN/zqHUcQZynUuV18p1DAbwPkgTz0Ipq+V5R8OW8hgkeuedd0oVV3JdtWek5E4durJ/HpUaCZEichAFHDRcF6Q0HIKIwKCHs9NtpD6iZOcLEnefxDTqFiTObATtqaeGmXfbLVykUTMNy02yqa9wBBwBR8ARcAQcAUfAEeh+BD799FMjH5K3T73OGG+aTuyUQIxde+21Rigccsgh9YKj48vJXksyFGPSgzNyJZ0c3onYbIoCG6hBiGGQV6UMTz8S3ygsOSgk1LwiU5RY2p4EoApDN4ISj7Xf/e53QRqaAU/D/lqe4/a37Ox+EFmQkgotLHgJpt/riTPkxGGHHWaEJCRf1hTKbEQE2yhEOftTIIkMBMhADCzxeoVUlEaoJS/aeuutLVEQ0X212BZbbBEg+SA+wY1ymGP1vGaSQ7MyH3roIUskYv/k+ENiKhIGSe+z8HxwL+LlS/IjSYaYVyhJR/pj9cCSJE4kh8OJCVJVMgNVq1LpuAxc1PsernSdqWx/zqHUSfb3Opcqq9XrpMsb+M4nY/ChlNXyvJ900knmWc1gCd7YeNIXD6qUOkb2O1Lq925a9z81nYyyu1lItF5kYe21Q9ALIyikIMhrshtISrCQtog4yhIkJT8uvnjQlyjIrzxoCCfoTR7CYouRGotf3RwBR8ARcAQcAUfAEXAEegwBQknpaNTT7rrrLjU5D6tnkQ0ti3BWMiCTaRoSDq8yyC83FKMUnSUjhDhZ8uijc5o1PO4wSJeBGmQiYaWE1JYyslwr+Yq6cWsVQre5jhDkyfC+UvIf86zEY42wb7Jck/G7nGX3L7VNnuOW2q/WdXiGpTD1UjgTbpx+r7XstD0eiGTgJYwfMoOQdwxCjUziqXxpSvbBlazKZGQfqEF2QiDj4aUEHCZHRp2QFqjVIFm2kfcs3l14hmc9Q+t5zZAowO64444+VYQULxVimzaCjMXwYM969UKs8s7h3qUfnwgytoXcrFQm2ySrB5ZkZYZ4xBMZo05YpWei0nEbcQ9Xus7UtT/nwH7F1t/rXFxOO/yvBFtG3EPeM2WlHLL1y/u8KxFOmDBhQnjkkUdMKgDSXsl0skWVXOZbwv3Fs5I1vDK70fITlbhpS29BQzZBX6ggv/AQ/jvq143AVDwnffiCvCkDmPDxX3XVr70sK+7kPzoCjoAj4Ag4Ao6AI9A7CCh5SBg7dmzF8MpWoUFn48orr6zb4ZPnUT0KJLJHWZOtQ1KP8hpVBoTAjTfeaB5EyuxsdYb4Ku5ENer4nVIuGvaYkiNYCDCElhKehDXXXNM09SCBkoGfshmbZ1tal3eO91by+lE2WdM+I7wQsgMjnBcjnBRLXkEQzFxHPNGeeuopI3omTpwYnnvuObsHzzjjDNseWSsI1sXkpKEstVY+BExWaxECSYlR+mjyQdawXgl5ch/XNuzHn9Rhx0sUA2s696effnpBe5Pn66WXXpKS1/4FHU3IWCx7LhZhp3VKVmG/8ae4fLCBZCDkG8ISAxOOhynreUDLEw9jZQI3zcJf/vKX9qyccsoptk0tf4qPz768x1L9ua8wJVayea1/lCXe8CJkGZI7WZ57hW3TPaaEN2nXSTBTUiUjVvEmxoMTGQS0VCFvuHfwNFNm5ML+aWGZZZYx70IwoAz0RfGWhVgjhJb7ExIdggz8WQ/BVO591Ags03eAUHQ8E39FBKoM4hrdTCxhlJ5D1lW6hnnvYcrJa+WuM/vXcg6NuM55z6Edt8vzvPOO2Uo5U7iu3LN436Lhy2AG79xkpe5PviW8X/B8h6AnvB7JB97HSuyVdu2euU62uj31VIwzzhjj4MExKtNWbvv3v2N84YUYle1OeetjvPji9p0uuSTGiRNjfOSRGD/5JPcpKr1ejIccwthjjCeckH8/39IRcAQcAUfAEXAEHIEuRkAhcLhm2UQWYBEhUR22QmbicqfejKzf0tGLIirKVWGS9SIj4j777BPJyqzEiVHETp9tijO5ph9F+ESRolHafnb+CotOP0Xp/kV5LkWRuVEElWXYVQc3yivLMBMhZJmSwaxVVpz1W94c8c4777QspdI0tHqqY1u4zul6M5enXquq3VbHJbO0yBPDSORPVGfU6kcmbZ4RefbZPUIWZK65Op811f+JJ56wsrlvpPsXycgr4jgqUUOhHHWGoxLq2Hbq1Nq9yLUkQ7TCDaNCoSMZrKX9Z/9TX+5PEeaWjVkeRHbNyQrNs6BwxSii1cpjf3XQoxLzRJ7ddA+wD+fCfZDW8SyITK163ELFMwucm7z8Mmu+WRSpGEVKWUZcjqVw6CjvVNuAZ1Ued1HeTlHh0ZbVXN7KkfPHRGjZNWA/MkYrCYqdT6qzEl9EyTpMUr68nqMSEdm5gZ90CaOSqEQl77F1KfOzvCejCIYCBmQvJ/N4JSuV9VukqF1f6iXiMIrki0oIFLmeCiGPu+22m71nOEd5EVYqvuJvIlQjGb+zVu1eEclombYTZrwnyXhd7prIOzJKD9UwEclo7z7+Bz8RODH7nszWQwmfCs8Sx1J4f1Qos2U8lvekqIrBhXuA+0XEe3b3wnKjsFQIepRsg2V/577nHhg0aJDdX0cffXQs9RzmuYbV7uHCidWwUOo6s3ulc+CeU6h94V7mOvOclcKTsmq5zt2Q9ZtzrvS8i5S3dwzvTCVkZnPDTx7RhinvCZ6bcnjKa9rubw2+xL322suec3li2r680zrRKmX9hpWtbHoBRoGnr0yMn39eeVt+/eqrKORjHDok/mfqqb8m8PQi+Y8uyH8mn7yNp//3TV118f+z7I/4ckW9+aqfM1vow667JMbzz8+3vW/lCPQQAp+I/NdoaZQWkjWoeujU/VQdAUfAEehZBBRGGOmEps6rwvJsGdJAXkVRendqNqrdWGTtRlTK88fIG4VqRUgnhcPaeUl3rlDzUkQlpKP01CL7S7vOOq/SqVNz+vMIyZEISTrodKrBZ9FFFzXCCMzA75577onyliocp9kLiahU8sg4evRoI8CoW7qW6dqWmjtR+c3VguhRRuICOfbNLzF+8MEHUWHa9nt2fd7lRFTKSyrKWydyXyYSLk8Z7JO17P/yhLSflDBUvio1OKtkCyyznD0OmxT/X2a3fq2WV50RxJAIEKXNNohDCCmIijwkYimislSduc68k3inUH4t171UeayTB2nZOhZfo+L/y5VZbj33VSIl5UVZbrNJ1kOUQ4KXwhLig8GdUt+WSQrKrKgXlhxXXsSFkpVEyq5PYUXRQt7j1vsernSdaz2HolOa5N8817lbiEpOvtbnfRLAKqzgPcy1y1q9383Zshu9XImo/FohV62LkkYG71/8Isj3OwSFAARpeZQ1xcuj2RgPOzSEd98LXy36/fDlkJXDv+edM/x71hmUs/7rsIOy+7fDDzqH//n4kzD5X94N//vC62GKIw4Pkx18UJhspDKay4Vbfurlazl6dFAa8BDkMm+6lWQYd3ME2gwBvWwKWknNrBru62gz3XrrrZaBsZnH9mM5Ao6AI+AItAYBNOAQh1dHzCqQsv4SLkbSifFKSCiPJNNoGjZsmCXsIPNwu5lISNM5Q+uPMFrCIgnXEkEUFlxwwZLVJbHOscceawkz0K0jFJNQQMqSV5CFhBLuuNpqq1loJFpqIqysrKTFRqINeXOVLL8ZK9HdI5EKlkJK03HTtUz/l5oTjioC1n5KOo3Myy2zYaXfs/t1+7a0mdAxLGUJB34jSzehxZg8XQNhxen37LzWZcpjn3L7Vfs9u1+7bYt2arPOrdS5J73M4jpktyUEH5PXlSXhqbRtdj/eHWlb9iXkuJSxDYZeoUhRW07r0v6srLRc7fdseXm3TSH7eY9L+HepbfmO8E7tTx3YB61LwsrT/mQZ592dLK1P/zPnOUQygd+YCGNP2zHnfYql30stzz777CaTkN0vu5y+N6zjHcyc72nx+zntYwf87x9FBAR5bRdWEXZczjh/pmSEg6eQ8LSulnmSv2Cfchmzs7qjtZTdjtuCf9mcJwOsMNIgxVZqXfE2nfh/ZaISkV/0TCRaWzGz9fPPh7j1ViE8/Uz41+Clw2e/HBb+M+P0nYeH9C3+M/N3wpdMSy8cPtlorTDVo8+GaS69KEx2ycVhstOkN7LlluXPS1pM4ckng4RHgoQzePuX39Z/cQSajADC/DSO0AxrtvGBQpT73HPPtY5ds4/vx3MEHAFHwBFoPgLoLpXqMFGTRHShX4eeHjp56Iyh24c+GZ28ehmkD1poWWMdyRxSsgN+I8MqWWSLDb2xIUOGSKr9h0FhoaYzxzZ/+ctfijct/H/ppZcaQZsV3edYCoEv6OClzhv6dmCl0FzbPxGV5bArHKTBC9Rp+PDhYYJE/9EmhPTgGpXTfCuuDh33ESNGEL1lP2XneZbZie3qsW09yypXn2rHqPZ7tlxIAXnX9jl39seymIBx0qVU9IotZ38vXi7ev/h3/k/bpHl2XbnlVm1by3Gzda+2X7XfG11WesZIasN7IE3Z46Zl6joQKya5BlJWr++rsO+2hYBs31v+l8dI9xOVLV4utY5tSq0vta7WbdGu5V7mm8y+a6yxhpGkxfXKljvQ4zJ42igi0YDyP3VBoDxRqVFiDXWHcNFFX3tUljvc5ZcHiZaEf3935vDPA7YP/98ck7K85XZt+/X/O3n4YuVlwhfLLxGmvfG+MJWETye7556gFmoomeWch1jipmpZBKVLCxqiavtT9Ar2BgJJmH/HHXds6QkPZDSupRX3gzsCjoAj0CUIKCTJPDvw7sCDoR7zVEZxeVkSsBJ8qVPOnGQieGGSoIJkA+W8LyqVV/wbpCgZcYuN7LFkXE2GF04pohIvSoUnBmnQWRZfPCrJ6FvJFH5ryUpSFudS23KeGORfKUsds1K/NWtd8tYj2Qo4QihDXOLJhMdNIpxL1YcEHMUEcantfF3/EeB5kSahFaAwXEsOQxKRejw3/a+V79kKBCB7EnlZvEx9iteV2za7vtp+1X7PlpVdrrZftd9rKSu7bXa52jGq/V5LWbVs26rj1lLHTt+WxGNu7Y9AeaJSmYcC4csaCS1rylYU9947fLH6cuHTX6yultbXDa6y23fqDwpb/1TelV8tPChMP+HyEJQtbjI12Ep6mcplOxxySFDqvBB23z2EOebo1LP2encJAoQ+EFpGh+/666+3bHNke6PDRedSgr2WaY8OJpnyRo0aFZKXR14I6OyRsY79Bg0aZB0ZibCH9dZbL4yRZ3a5ThjlM5KGNw2Z+qQ5E5ZbbjnL1JfC//BYOf/8882Tg3USIQ8nnniiVe2jjz6yY1EGGdTI8kcmR2lhWngDdbjsssvMA4awO7LvpY5ftePmPXffzhFwBByB/iAAYVhM7DXjf2lP5aou70o86gjfrjYnhKx4O/aBbMyGy5U7cCK88FjceeedLaOlEoLUjWzh25HCqlMdqJ/E6HNlyiRkW0lPLNx75MiRIU8nh5BKZE8gLKVLmQ5rc8jReRXWXc3S96rads36XQlDwt5q9zPxreX7CmnJdzpdw2xd2q3+2bp1yzLSAI888kif0yEDrFvvIcDz5s9c7113P+PaEeAbzOCjW3sjUJqoJDW6wmFsKld/afOopRI+3XCN8MUay5fbqqvWf7XEAuHjPbYI3znzyhCGDg2T3XJLac9KdCrxpjzrrK89K7sKBT+ZTkOADhrEpLKtGjkJoaeskwGSjwaukhqEU0891TpUyu5oIW14ikDs5TEIRjp76Oko+54RiXQ26cTQeEbjBR2ycoZeigTmg7JFBgmBBzqnhC+h3YURqkAYAPqWdHjZHqKS8rfffnvTcEL/i44khCwdJkIb2J46KSOdEbFKBBCmn35602+i3GrHZRs3R8AR6H4E8OJLHoHZeXYZArEaiVi8fbX/K3miZVHH664aUZh+531eTBj2939lxc5Wo1/LvKvLEZUMYEHW4nW3nSJzeJ8r47EdB/KrnQwPNULFNtlkE6tW8hRNXiWl6qoMw6Yvd6AG/hmMSwQCuoN8c9GPK2dpW0Lh2tXQRiQslYmQcDxWCXenbZFIy3Qe7XoO3VAvnn0mN0fAEXAEHAFHoJsQKE1UKimO1MGDhIJKn6vCDKK8rj4bumrPkJQJiH/PPVv4+64bhxlOvSyI8Qhy9Uo/fTOnca8GtxTInaj8BhVfahEC6KXgKYnhwQE5iREGTugWXocQlxidw9VXXz1su+229hvhbtVMGU3DyfKuplz0lJJIOZ6USy65pOlSQpIm7a1seXT87733XtMFo2PD/ghFJ+8AQtYpD/0ujLmywdoynSRCnujkElKOBuf/z96ZwF01rX98vYRyETJkDjeJDMmYSnEjkSFjJcXFNV+XDJmKkOnKdDMWmUoyJMlQSFKJlCIyZRbKVDL9nf/6PnmO9e73jO97zvue4Xk+n3XW3mvvs/fav7332mv91jOg1YMGKX5H8CNGoAPI0759+8q1qwleuvPKCezHEDAEahUBiLuQ3NPlKEGo5alytuHjkDy6X/R4anac7mIh1pQQTJfTLlWXIIz+L5N2OF3d62o7OEXJPNprSD++GWgnHugnfgv9GtVtCb4qqXe/fv0EUgi60aNHyzV8jk93L1gvICeccIIE03n44Yfd3nvv7Q455BD3xhtvuCf9JDeapghBEBAm60JRqwb2xTcm/qWZECxUwRKCRF8AbVOCBXHdatpeqPW2ehkChoAhYAgYAoZAYSKQmKjE7453np1QfAS/WPdu7pedW7if9llGGCTcr4QLf9+osfu+1/6u4a1DXIUndSR4TvR6fYfU2xP5AEMznXdoFN1q64ZAnSCg2g0MHDHVXs+7JlCSkgq1bdtWIrCi2QiJiWZkJkLUVgRCVM8B4YgJNpqRHCsRUcmAHE1K/o+JHIMbzg2xgFA3yFUGh2hKorkx3PvFVcF3FufDHE2j1xGogEElWpaQlEgTb47OgBniE0l3XtnJfgyBMkUA0+CQ4IsSe7quBKCup8uT7a/lGhk6Hey836mIQt3Ge067wLqWaa5koK5nkjOZYpIdAuAMEcw9I+ebAznJZFj47cnuqLnbO5VbkvAsaEVqQDhclPCtgnhEWxQ3Kp999pmQkvwHc2hMby+//HLZTjAaojGTcF1CFG2+WWPGjIn7b8QyAd+YWB+gFcukHd/T13yARs6DRUAxCHh27NhREsHz5s6dWwzVtjoaAoaAIWAIGAKGQIEhUJWoXLjQuffec96GMnFVTz3F/VFvOffDkcs0nBLvVPqlv267hft5jx1dfY9HhZ8pd9FQ8S1bOm9n6rzNqRGVpf84FM0VKomIxgfm1ZhCh8JgksieaEQwGMuUqAyPES5vttlmsprKDwgO3/v37y8akTiER1NyJgS/F+o71Gt4Y6Z92223CUn5P+92giiiqSSRySLXFppapjpvqmPbNkOgthDA7FNJvGiupGC0PBfrmONmIhB3SvhproSfrpMzEbGW/0bqtprmmZJLmVyD7ZNfBLjXtL1oTaJhSERv/Q7l98zpj867kqngb5nJMr4h+J5EmFRjnWccORkrm4jgygT3J2j6c918E/X6u3Tp4kiJBA1TfD8zuQa5WYyaidz7lvSFTQwBQ8AQMAQMgTJDoFevXq5z585xlzFldvk5udyqRKXOfv7pJ6jSWXDW/PAj7sdTvI8eH2Cm3GWxN31fadY8V4HmpDd3qSS+QyrRvxXPShttxRCoGwR0gISmIYNHBlA6ENIaoemBYDJeU1FtiqZNmyY8FBpUaF1+/PHHYuKN9tOQIUPi+7J9Vx/Ua9asWRLVEk0VGn7M4jBRr66kO291j2v/Kz0E0D5ORBhGiUJdj+Y1IQ6jJrPJ0IXUCInBZEQgGsgQ9Mm2JyrXskTHL0byJBmGVp4fBPAb/MUXX7hGjRpVOQHPN98gJsUIOEOuy4X4bEHMh1q1fENJ6YTvLu5IshUwyCTgTrbHtf0NAUPAEDAEDAFDIL8IYLnImFp9W6c6GxYnuDNjDIwPa4LDYo1IMFksEgmGS1qwYIEoEZ1zzjmVlI0eeeQR8YWNYhAToriMoc+Pcg9jXiw2sM640sdQUWWg008/Xdyp0RfDdzYWkGeffba4TsPig/EC+9APefTRRyXR5/m3DxYdKjLhwuaGG26Q43JOxumdOnVKdbkZb6vaw/JOsEWiGoIUerPL35pu4n7devNl+5T5b6z+im5Jx13cKv4hqPCmqd7GrDIiYKh4Vt5ia4ZArSKgBKU65ofYwNE/PhvxfUXwGRXKICXYXlPB/yTmfdtss03CQ9Gw0jDT6KnpNkEKlKAhKtugQYOkocVRP0F1CLhAY52KqNT/JzypL0x33mT/s/K6Q4B7moj007IoQRhd1/00j25Pts47k+55UlTQ5E1E6CnZpzmazI0bN86KMEx2XI5ZiKSOYmJ5eSPApBLBVaZ66xIlIjVHIxE/ogiTZ7gLIeGHmOBoJoaAIWAIGAKGgCFgCJQ6ApB7KOMgKO8s9BbOKBIRawGLQuI14E4GBSCsN/ABjdUFYwPiOhB3gr4VFkxYgLz11lui4EO8BvxbN2/eXIhK4keceOKJEj8C39n0t66++mpxXfP9999LYDyISfpukJwQlLihwZIJCxLG7Li8wSc3Yw/G6bh7geBEexQ3Ofvuu68QrgRJrKlUJSo1wiABYULxoMV8xX467uCwtOyXl7bezq3yxCTnhg1z/omojIcfQHpVnMpltmYI1AECiRzz4/SeQDjM2jDTAuFBo0g07UsuuSTu3zGb6mIyvnjxYkekcaKcMvPDDI0GStBgA8y+4IeLgBPIiBEjhHhkMEukboTGkf8xI3XRRRcJsbPffvvJNo1IzvEhkWhcVSCcGPxipqcC+Un5t99+K0Xpzov2SzJyVY9ZrjlmwUr2ketylOhLVq77JdseLdd1JdnT4Q4pHyUMk5F8kCO8G0ogRnP9X7Q80TplOiGQro623RAoNQTwMQzxGCY6zaxDVCK8l7StkJHMtjNBpeQk34NQxo0bF67asiFgCBgChoAhYAgYAiWJAMo4+LrGXzWk5amnnirjYchAxugQgsReYPzLRC5kIb6ycanDOJv9IBMZi/Tv3z8esA9/16EwTokqIkFe4hIOXoBzn3HGGfIXxtb33Xef+NI+zQfRRnr37u0pr2FiDYMi0llnneXat18WGJHtAwcOdLi8IbZEfohKzpJIfFRD16C++2XbxCacif5SFmXeBP6X7bZwKz08ylVEicqyAMAushgQSOSYv0WLFhKtFA1FGhVM9FD1JpopMyLVEQhCIn1jNs4g9ZZbbhFtTRrfk046SYhQjktwARpEZmEgHxmUMkN0yimniPo4vippaG+88UZRWWfGh/3e8/5z2Ya5OANg9QlGQB4CNDDwZVYJwSdY165dZQaKclTfUaOnkWWWKNV5H3/8cTlGIf9wPUri1WZOoJVMhI+mEoZK+CXL0/kvVGIw+n8t15ztnNPEEDAEco8AZCRtcJiUmGTSCMEsqEmTJkJA4rYDbX1cf0BI0qmlXTAxBAwBQ8AQyA4BJuVtMjQ7zGxvQ6C2EECZAnPsUCh79tlnHcoyKm3atBHiUdfDXJWKDjroIOkr7bjjjq5Pnz4yfj344L8UBTkegWNVSYe+1q233io+oTHBxvd1lIwMz5NoWWNWhEo6zZo1k13RqFQhjgSCYhPKHigVETxQzckZm1I3+nqMTRmf1USqalQmO5rXlPp1i02cp2uT7VG25b8039StdI+PlI5j9hrekLIF0S48rwigmZjIMT+NGf7DUCUnuM6AAQNEbby6lUHdHP8XX375pWjO6KAUHx3JyL8nnnhCIn6rliPnhkxkHe09BsA0fJCd+N3QYzL45QMQlcmTJ0eL3DPPPFOlLNV5q+ycogC/IlGiULUGk+XR/auzHgYGSlE9wSsk8nQ5UQ7micq1LBlRGC1nXbVoU9XNthkChkBhIYD2I5M8JEjIkJRkxh1h1h7SkTaYDix+j5SMxGQoE7+NhXXV2dcG0gBXJLR1xRKRO/urrPwPJgjbtm3rdt55Z0m58GNd+Qy2ZggYAokQmDBhgrhpwtrJxBAwBAoPAcZkaEVGhbE32pAqWByiIZlIdHxLH0sF/92MzXDLlkzwgYmrtbvvvlsCF2LSjSYk56qJMPaLivrp5npRSEKwesS8PB+SMVEZmzXT/bb1xvmoQ9Ef8/eN1nUVnkjxbI/zdHbRX49dQGkiQAOYyDE/DSLalVFhUIqfiXTCbA+DVBUaVFI2Et1f16mzEl7pghHQaCrhpwShrmuu5cly3S/TnONAomYi4JyI0FMSMMyZnQrX0/1P9020n35UMqmj7WMIGAKljQAEG5M+SkZqDiHJMo7YEdWMpN3FaTokFe0863xHyr1dYRJt9uzZ8n1iWQcYYFeqmk+Y548cOVKsFLhGopEraUneqlWrGk10gp2JIWAIVEYAzaXu3bvHrYUqb7U1Q8AQKAQEIAW/+eabSlVhbAaBdwVBl6spK6+8sijzQFiqhqMeCgKU/hgKM3fddZe41MEUG+UcyFDIy3wKdUPwoxkVLCxRgKrphGbGRKVb8JX7Y/eto/WwdY/AH6v/Scr8afpkoBgCpYAAauDnnXde2ktBNV1nVRgAYxqcjAhMV64Eoe4XXdfyRDmDxUyEATYfDyX3kuWQfgT4UfIv2X6ZlpeDllEm+Ns+hoAhkF8E8BNMB/aDDz6okubPny8TOtSATiYmOqT23scQbkB0HRLK2qzk94mJJzROIShDkpLv0D/+8Q/R9g+1IpIfqXi24DKFKKCQ2QxMXnnlFYkOeu2114rlA9e79dZbC3lJvwDiEo1bnWwsniu1mhoChYEAk0e4ZUJxgCCS+HnHjdJOO+0k7fjNN98sgcroE/Ou4UdOzUezuQICbhBpmO8Dpp1MPODGCfJFzT6JCoyZJ+895QTkwCpLBb/wRCjW7XxDaBtMDAFDoPoIYMLNBCEu2Yj9oO4feB95Z9mG27SrrrpKoovjUg1rD3xdYiGj/Tg1E6cmEJtIunEzE5KphP4ibQH1wuy95Z/Kehz36KOPdvi+rDWissIzo7GVVkhV37LdRvRvET84MDEECgUBfGMkIvSU/MtVzqBFg9Rg3p2pj0AGL5mQfEQww4ehEobJ8uixovvp9lIbPBbK82b1MAQMgdpBgMkgokJCRjKw1FyJSYKVIXRoiS6PywwS5BEdS5bJ11tvvdqpcImeBc33qJx//vnu+eefF63K6LZSWee6GQyRVHgeITsgKSAxCYKHNgUTg/i8grQk8QyybuSlIme5IZAcAUgAiEnaFchJBv+43YCAYHIJLWfICvwHo3WJnzrcGmnAyeRH/msL7pI4Fqai++yzj/hvx4R0ww03lCCXBM5gn3bt2rmhQ4eKRjVaYvjMI7Iw/oeRHj16CEGCz3kCfXTr1s2Iyr9gtiVDIC0C2nejL4fLNIRgOQSoIco3Jt242nnjjTfck08+GQ+Yg2UfkxaXXXaZKNjssssuEqGbbzUxKFZddVUxS8d6Em4AN28IbQXfcSYVcAOHhIQmkceRMDitao0y7uc7fvrpp4vGKMF5aRewiKSuxJagzaqpZK5RyZl8p7cQZPYnX7qxr7/jnpnzruu8XTPXZ7+2Uq2n3pjnLhj5jPtv986u/VabVakqzPDEuR+65+d+4MbNmuemXXJSnJmusnN1CtIwz9U5pP2nuBHgmastwjAkHllONxOiyEIsKomXKqfxQZsiSgAyWwP5x381hcSiHjP6v1ALRetiuSFgCBgC5Y4A3ww6hpj8kSAjSUpIolWjM+F0QDH9aeID2NAhZbCqxCTltLsmVRFAO4mED2RM29EGwIqAzjf+ltSlB988tBOGDx8uB0HT6JhjjpFJQHxT4pOKCJx8AyET0GpA0E5loH/55Zc7NB8IUsdxGeyXokCekNT3Fv0PLC3wq/Xaa69JGjFihJCXDG4YMEFagj0aI5CXakZWivjYNRkC1UEAbSTVaKQ9h1BECBpJcEi+C7x3COTinnvuKe0T2zKdDMCvPO8rQS5px9CCOvDAA13nzp3dbbfdJseGeOSbo5MMuIVCw5pJCYhKvlOTJk0SopM/QHhCVJgYAuWOQCbKMbxbEP1MciL0H3gPyRs1aiTEP+/n+PHjJUEsYuqtZCbv70033SQTBwS4gXS8/fbbxdqD72rfvn2FxCToLO8mxCdlTFZDPD7yyCPxPg6BbBm3Q4Yy8YHQt2HSESIVrWkt49rYn34U9cGHLhPktE+XXnqp7FfTn+yIypqeLUf/X/LLr27el9+4Nz/1PvQ8Uany8TffuU8X/eA+WrjMx5KWa/6Hv5GffvuDGzHlDffD0l9yS1LqSSwvSAR4iZXIUy1DXU+V6zb+k83/wn0zBURJviihF11nhgQtmWi5ricjBnV7NFc18kzrafsZAoaAIWAIVB8BtGEgIklooikhqTnByPhmIWiU0ymFiMQUjwGkEpPkuKcwyQ4BCEMG1ZCIBJI7+eSTRQMAp/d08i+++GKHRgIkACZNEGrgTse7V69e0lnHN/MDDzwgJlR6r9iHDj++pCAz+dYiWBowwMAsulSJyugdoF+BPy0SAzCEwRjkJcSlEpgQwGheMnEJ4QFpifkYOQmi2MQQMARcfMxKe4PGMiSDkpTgQ6Arvhe4pICoZBIgE4F8YGIGM3PeQSIII3ynVC688EJ3wAEHyDHRnFYCQzWtqAffI/ajjLZSJ3f0GJYbAuWGABxCJsL3L9X7wiT0p59+Ku8o31Ymo8Ox+5AhQ4RcZBKbCQqUhUKBlDz11FOlv0IfB9NvtLPV1zjWDv/5z3/Cv8hERSL3bxwnKpCXaHbj6xxrHSbQcyVFSVTu+veN3eKff3VjZ75TCYcT9tzZdd6+mdtwzYaVynVlef8gHLX79m74lFlu1kdfaLHltYgAHdWQxAsJwGh5SBKyrOua6/7pcvZHQyUT4cVXwjAd4ccAUfepaY5WY9joZFJX28cQMAQMAUOgsBDAPyQdSiUiNYeQ1OUlS5bEK813BCKSBDlG0BpdJ492OON/tIVqITBz5kzRJkA7daONNhITSTQi0Ri69957xcwKcgztALSTGHC/+OKLrmvXruL/jZNibok55Ntvvy2mzloR7h8ddL7l7f/UfGIb2poEIYLILGdhMIb/O5KSl5AumLlxX0iQxTfeeKMEfAIryBglLdHmIkF+6gCrnPG0ay8vBHSMgL9KyH00wEPBuok26LnnnpMJgUyJSnzqQj6OHj3anX322TJ5w3E7deoUPzzkB26eMOXkfUSjErNRFeqGWTjm3mhhQrqgcXnUUUfpLpYbAjlHADc4WDWgecx3m8T3WScJc37COjwg71iyoLJwEEgq/7Qheah+K3N5ObipoG3ItRQlUQkI9XyHJ5EkIynDfZfzN5tUzsLsWTqCr6bbExGKRGbOROjQJiL/omU0RtooRbeF6+Ey/yFRFi3P1L9iJtdg+xgChoAhYAiUDgJEMVQSUnPIx3BZo2Zz1ZjcQIahbUKOKZwus05CA8akZghAdqlWox6JTr0O7LWMHD9s9H/wr6YCcYwWQOibCaKRYBG33HKLmDWhKRCVZP2F6Hkho4877rjo323dIwBWYE/C95YK5mgheYlWKoE56ENCUkJWKnGJGTnLEPtR7PV4lhsCxY6APttoREE08N1BC5/nXkVNQbMJYIFZJ74myZk0mDp1qkyuHHvssXpYcW9x5JFHCvmI+ShkaCi0qWhizpo1SzSz0DZH+xzihAkfE0MgHwhAoGMBwbsQCmN8vrsQl7wTWCEqkak5bl4gOnl2MzHPDo9vy7WHQJ0RlWNff9s9PuNt9/3Sn90ma63uOm27hevwp1/Jn3/73Q194VX36oefOZa32mAdd1z7HV3j1VOrkr7rzcEffuVNt8Gaq7mebVrGUZw87yN3/+SZYhK+zYaN3aLFSwumM4P6bU0Jwer8XyM+xUFKssDLGyXzkq3jw1AJwHS5HiPZfpn6VklSbSs2BAwBQ8AQMAQyRgAC5LPPPotrPUJAhlqQrKtjcQ7KNwwfhEo4MpOsy+Rso6Nskn8E8M0WDqo5I/6aEpkoYZZNXwXT43SCY3r8PBGoAp9PoUZCqv8qoZBqH9uWGgE0idH0IqkwqOT+zZ49O57Q3oKsQbg/mNdvtdVWrnnz5vHUxLtNYPLbxBAoRgS0PVHLMMZHfG9ow9D27tmzZ/yyKGNclY1mE2NIvm24rcCk9L///W8Vf7H43oXQOeKII+RcahWgE0RoqA8aNEiITDTc8OuLfz38ABtRGb89tpAHBPhGMAEZ8ho80/TnSGjpQ+zzDeB5ZT99bpkoJgAcptUmhYlAnRCV0z/41J15/5NuSv8T3correiOGjzSvfPF10JUfrtkqTt40H2u0SoruwGHdfQm3r+4E4eOdsMmzXD3n3y423nzjRIi+fD0Oe6mp6e4uZ9/7c7o9JcD34emzXbnjnja3XbsQa5Ns03c/56d6t5bsNA1WKF2Lv1SP0s11qviR8lE1Tak4c9EeMmU3EuX48MwGQGYbbmZ12Ryd2wfQ8AQMAQMgUJFgE4p5nJKPEZzSEj8QuKaBOG7xyy8Eo+YwOmykpNmkl04dxvfbJCVoVCWSNByhXiE8EIrLxQG2/hZU2HAjqYffhUhQiEFMiG8lFjQ41ieGwQgaFSLMjwi9xOffBCYb775pmiHPfXUUw5/XQh9Zu51SF5ifo4ZHX1iE0OgkBFQc06i/OInknbouuuuc0TZZUKGAFY84xD2uKMgoAVal5kK/nYJnIE2JBMykJ1onRE4jEAeiJqK4oMSbXOCgyGQPJiMM0GA30z8/6K9tt9++8n2bKKPyx/sxxDIEgFIcVyxpJKQxEQBi74e3wC+90ZSpkKu7rfVDlsXuU7IQ0yv8RlZ3xOGZ/uo3a948hIZ8OhzQja+dtkpcV+TNx69vzvkhgfc6fc84V686AS3Yr3lI0d07pCdWrjVV27guv/vwfi2RYt/cn0ffMbtvc3fXUefkFM67upumTDNzwwtG5DEd87TwuaerafDnC1BGN1fPxJ5qqYd1hAwBAwBQ8AQKEoE0O6AfIwm1YrELEi1USCRMItTE2w6qWiJKBFJzkArE0KqKMEqwUpDOCXz3RS9XDSNRo4c6S644AIJlKOkIpG5cQbPNgTzR8hPyC8C42B6jO/EM844I3rISuscjwloBkZhvw0yDU1Ok9wjAK64VYhGGQZzgiWFCT+kENLcI+4VExJNmzatkiCok5n25/4K7IiGQHIE0BAm8jdBqHCPMHbsWIe7AwhCtBb5hnXo0MGNGTNGCETatmwEk23aOkjGUFB64RwEAOOYuK9Aw5yJG94j6oJvX/xWQlTyTvEOQlLiKoPgHPhcNjEE8okAz75qSKY7DyQlrhLQwMStS+iqJ91/bXvdIFAnRGWrTTfwGpKvu72uGOIuO7yj22ebpq7FhuvKg/bYa3Pdug1XiZOUwELwnJVXXMF9+PW37m2vMbntxo0TohUlMB999S33o9fI3H2Lv/x3NPDHab7+Oj5i+IKEx8h1YQ//QvTwfnWyETq4zATje9HEEDAEDAFDwBAoVwSY+UbbEW2RKBGp62F0Usw/ISFJRDBltl1JSXI0Is21SLk+TU6C5QwcOFCifO+9994y2EabCG2lyZMnCzD4qiQiJlpLmO8TFOKZZ56RwTrPE1p9CEQYwnOIySSC9hODJqJwopkLCUCE8ZNOOslhSo4fOJPaQQACk+AipFCYtIBIITqyJsgXCCD63tw/JiqYtOC+NvGm42jehDn32SYzQlRtOV8I8L3CfFX9Uepz16VLF9GAhIgnuM6AAQOq5fMYLcxzzz3X9e7d2xEBHF/MBIWjDSNBVO6///7iFgUXKWilI7w7rKNYw3d6wYIFQlZibst7o/XMFy523PJGgPcBjd7p06c7SPVUpKNqUTLRyHcYDWSIynIXvnX0aXiH+f6FMmPGDMEKX9FM7hNYsGPHjuEutbJcJ0Tlga22cviNfHDqbNfr1lFuj+abusG9D3BLvP+ZJbdmwWAAAEAASURBVL/86lZrsFKli6+3/HJuhybru5f8f97/amFSorLSn/zKO198I0X4wAylosKvkQpEMAsn4hqd2eeff95NmTJFIqcRQc3EEDAEnHTS8J9DlEGCIOA8GUnVyCpuaFPxPxJmKH379tVNlhsChkAdI8CgSAlH8pCQZJn3l8EQQmcTgkCJyH322Se+rGV0WE0MgWQIYMqIFtChhx7qxo8fLwkNC6J8o133/vvvC3lJrgNtBuCQXrgPwA0AAx069RCcCBGsb775ZteqVSvRIEL7EmISjSK0MSdMmCDfKn2Ok9XNymsHATQl0QAjRYX2KCQx0b4kvfTSS9I24ScTgTyizYHA1AkQJkF4hjQ3H7VRdG29ugjQFvGsRYVvItqVUaGtIjJ3Otluu+2k7YOgxJ0J5rAqmI8zQaPCxEvoDgyNcdUap346AZipdrse13JDIBUCKG8xkaS+iSHtISd5Znn+acchxtme6BvLPqpFWe5m3oyZ1YoEzJlgADfeXZa1zwPp27VrV3f55Zc7JnbRmsYfdNkQlZhd33h0F7fnVpu7fg+PdxPnfuiOu/NRN/K0bt4cvMJ98d2P7pOF37uNGjWMP7saSGftVTOPkPnbn/4fX3n/U9duy6oNfPzgtbxApClm7iEm6cDCVqMyzweAl4wHRX2S1HLV7HRljkC0ESsUOJjdZdaYd+Wggw6KVytZIxvfwS/QYeN9Y2CJdouJIWAI1B4CRO+FcFQCMrrMdpVQG5IBExpvkAB0Msn5LurASP9juSGQLQIMViDAISPptDPI0c47Jr98Z0KBgISsDAUCMpF0795dnlv6cUpUnXbaaTL5bH5NEyFWWGVoi2FmS4oK/Q18+EFczp8/P57TpuE6gGcKzTYVtFSUuKTtWm+99eIpXDeXAIqY5blCoGHDhu68885Lezj8UiInnHCC9K351hL5G+UZNC2HDx+e9hi2gyGQCwTQdEdLl+dOEz6HGfuxjb4fbjog13m28aG6ww47iIYvLluISh8KBCVtdqhFGW4vt2WwIPDQs88+G49yDkZgTn9FSUpwwY0E3zW0LXGFxP2oq+9UnWhUnvvgU+7ig/Z0B+24lWhTHnLD/W7Kux+LNiUm4LM+/tJNfe9jT1QuM68BtFkffyH+LFtstC6rGQnRwpGJb3/o+ng/mCoQpbE/Yrqa9xw1eEhJJSZx4o7AYOvsLOs6E8DDQufGxBCoTQQgzXHSjSPuQhP8vDIAePjhhytVLVkjG+7EhwwzPnySsL+JIWAI5AYBZrr5vkVJSF1HQxINJQQiiA6PEo/4FVICUvNsAgDk5grsKOWKAM9jvjR/EhGSicrKFftivW7tm9M/b9OmTcLLoJ8CYUm7GOaYlNO/gujElQVtpwqRZyExlbxMlkM+mRgCmSCA1jBBdtIJwXnoF6NlTsAwyCCCTtFnJpgYz6aJIZBLBFAegQfRpKSk+g6mnW3SpIlo96LBd+aZZ4q7FZ7LZH6Do34qeaY5BuO+QlNQ6dWrl+vcubP4Rs8lrumOhdsZrHZRSAolkRUS5DCiigF8k+pK6oSo/MOThEMmvur6HtDerfG3Bq5Vkw3c7548bNigvrv00H+4A6+7z935wquuyw7NhZxEu/LdLxe6c/ZvJwFzAOvL7xcLZt/8uCSO3Y9Lf5HlTxct8xvUbbdt3fXjJjs0Ki95ZII7uk1LN/2Dz9xr85dFAhw8fqo7dOcWbp3VVokfI1cLzK7e7n0nTPAv5KcPPSSDNG64kpGcJyQpw/PSganLhyKsiy2XBwIQC2iCHH/88QV7wdpgRiuYqJGN7qMzRZpHt9u6IWAIVEVAg9TQPmhS82zWGXxjDYAw8YZPN0hHElprugw5ybZkncyqZ7YSQ8AQMASKDwG0wjW6eLLaM1DEbBHSkkQ7GuaMH3RbOGZA2zMRiRmWsVxXmi/JrtfKCxcBvskoJ5B+/vln+Uardnnh1tpqVugI8CyhqYfJNklJSXKsSpFVVllF/IhjPQMxTk5CaxIfktkIMT3wSc65eH5xu4LP1myPk805q7vvgw8+KMpoBHFMJwTQQkEHrCA3Mb8GQyw6evbsWenvBACEmIX4pb+Nmxo9ByTlVVddJfsTgAv3JJh143oQa8P777/fjRo1SvzQ4ouSSTXk9NNPFwwJpDVx4kRx00Q543G0Wpm0w4f3nDlzZL9BgwaxOadSJ0QlZC5E5DzvQ7LhyvXdAk86/rd7Z692WiGBc+458TD3n/vGus7X3O3abNHEPT37XdGI/E+n3eXi75r4mrvh6Zdl+ZHpbwrB2Xj1VdytE16RsqfemOcu9dHDLz54Tzfy9G7uhCGPucHjp8n2dls2cX9ft5FrsGI9iTxO1PF8CIO0Rf5BmMvsqn8QIEjCDke6c/KC4ySWWVa0UEK/IOn+a9sNgWwQwPyN2ShmuR577DHpNONfC58USKrGL5vz4GPyIU/a4/sCUztmcvExp1Kd80QbWdWYpPzKK68Uk2/eHQgTxDpgirblhoCTwXIiAlLJyIULF8ZhQpuH9wjSEdMb3l9dJ+c7Ze9XHC5bMAQMAUMgIQK0k+uss44k2tJkAqFJGwyRGSUzWcefPYQmGpqh4kOU0AyJTNXcNEIzGerlW16IpE753o3Cv3ImqXGBATkYkpKs04ek/YL7oM/YrFkzMdWGXGMZQjLXlqMQc9QpUy1K2uGodmEhof7WW2853MbQztNe44ahZcuWErMB0hAMdZxOYCBM3G+99VZ39tlnu8GDB4spPCQnZvEHHnigYwyuJCduSZgs69Onj3vggQdEwx8ssPw4+eST5f7BDXTr1k369ozZIYJxicI3B3JT7x8KTmheo61ZXdH7kGgMkR+WLk1NB/XcTzQlv/S+KFeot7xrtMqyCGL6t322bepmX3m6m/flN27xz7+6c7u0c39baUXd7I7Zo5WkeMGfC8fusWO0yG3tTckn9/uX41wrr7SCD9RT333ttTCz8XVZ5aAZFAD2/v7BIk3yDxrO13FKDAsdmnwkOxQPmgrH4uEJ/dtEl3mIGSjy8JkYAtkgwEwNxCQzLjR6zGzxYUHSNX6ZnoeGlsaMDxgNGhEEaYSVqKzOeRI1stQH0yuIV94RZojoxO+3335S1USNYKbXYPsZAsWEAN8ZTA8hIpV4DJcpg9BHeC94X3jvIR3xY6PLSkaa2WEx3X2rqyFgCBQ7Atr3p/+fyGemXh+DvFSEZjoNzZDIDJf5JrBuGpqKtOWGQHkhAPFHv1EDjGkOMYmptipgqUYj2pB77rmnkFoQkrhXqS1LGrQo0RrMlHBn7Mu1FapstdVW7t577xUMcYuEMg/jZ8bLkIkEeGPMDqGIefxRRx0lmpZcDziwP8pBd999t+vdu7dD259vSvv27eOXPGzYMNHARDEOAZMdd9wx7l+bZb4DKhdddJGce/To0aLhSfkLL7wgBGoydyj631S5+nbm/FGpE6JStRg1QE60Uqwv71n45usv8zGZaHu2ZeG58k1SRuuGfz38fxAhkuhJqP1GzcDD//AgETwEDTedRVUzEM2JesUyZI0y0RwDM1geKk3a6YDEDJP5AgsRL+/lddddN94JJqqgNmKZNn6ZoHfPPffIzBoaj3xE+vfvL9qO/Le65+HDGG1kOd7VV1/tUJdn5oj3gYSq+wUXXMBmE0OgJBD44Ycf4iSkEpHkusy3A+fZCB1FNcuGgGzdunUlbUi2acTOkgDHLsIQMAQMgTJBIBtCk+BljB10bEGuyxCaLDO5qwQEEDI4VtIymusYwwjNMnnY7DJLDgEC1UA6QkIyHiPpckhGEhwO4hEyEldh5CQ07QphIruJ90mZjdCWPfXUU9n8Jet9wfacc86p9D/KCGiDayUVSL5EPmVV+Yw+Ou0wAoGJwBEhWEJiah/1xYmGKSbcaFJCVCJ8K6KSDZHMcfr16+cY06OAxzgcDdZkwQWj50q2/sknn8gm7klUMiYqY544dN6PpEkCBP4cDHr2McHGv4qYEUV194orrhAyZciQIUIyRjUsaQww3eClI6US/ks0Su1oKJGpOb4KWOaBDs/DoBSCKiQvWU5Upi9HqnrYttJAIGzEsmn80l09DSgq6ait33DDDa5Lly5u++23l7/V9DzRRpbZJlTS+XiqEB0OCa9Pt1luCBQaArTVBGOAdOQDrgRkmH///ffxavPNgIAkETzqoIMOqkRE0q7bsx+HyxYMAUPAECg7BPgGMLAkpdPQDAlNHV9onk5DM0pmRtcLgdQou5tvF1zWCMATQDqSICKJ7K45fU1VeMIlBWTk5ptvLsQXy5roZ5aS0AaCBz4z86W8xYQP/h+jgrIZ51ZBkzARUanbw1xdnGkZpDISjcGgGo5YMqrUdBwAcYrfSjQr8U0JCTtu3Dh344036imqlc+YMUO09xs1alTl/6mZtXD31VZ1yy39OSyx5T8RqPjpT1wyjMiH1hpkCs6Lr7/+ernBsOEalCARo5wMbDQzIWXUV0Cy/WiE6HgwU0qDRR4mGi3McynDhEQbLY4HUZmI0GTwS6MW5onUdpPVycoLD4GwEcum8Ut3JTj0RT0cFXR8Zey9994yC8PzksvzQMjz/GoDrfXS69Jcyy03BOoCATThlYRUIjLMGRCqNiQ+Vmnf1QQbgl9JSc2t3a2Lu2jnNAQMAUOg9BCgn1QdQjOqqYnpId8yxhWhD00Gu1HykvWwjOVSI0ZK70mxKyoUBCDb8BepSUlJzX/66SepKv1J+o0QkWjmoTSC/0HWSeXUl9xjjz3iEe+PPPLIvNxK8IR7CQWrQky1UVrLhdBWI5iCYz2oorwQHI1KLsbAmJ0TAwI/mGh64ioqk6C2WodEOWTnXnvtlWiTy5yo9A/y8gsWJTxIuRfWU1z8S56NQPLxoBI5CW0zTFYhWWhEci1hx2ObbbZJeXhmACB86FwkIjVnz54tasvsQ2CUUNAEDYlLdRieKMfvTnRmIDyWLdc+AmEjlk3jl66maIjdddddEoXsrLPOEn+tzB5BXubyPNoZxvQb9fqotmW6etp2Q6CmCNCG4xsS4jGaaxkTUyq0jXzsSfibOeSQQ2RZSUgmiaIzpfpfyw0BQ8AQMAQMgbpAIBxXpNPQ5LsYJTLV8gv/aLpMv02F/psSmJqrqbmukzOWsG+komZ5qSHApDXjcbWowa9iNOEKCOGd5J1o4q0xUYo6+OCDJWcZQpJozzbuXvaEoNkNOYYZc76IymVnyu/vLrvsIifQSN16tldffVUWcfWE8GygEMd4HCW3VKLKapqH+zKBRBRwrCOJbzFmzJhwc9bLkOmQrJC3iSR1TYN/VOy0s1vh2SeDEltUBOp9+KmLrbG6q/gzsrCWZ5rjqBr12X//+9+icRYl/zI9Tq72Uw0eZeNTHRdiCMISQlNTuM7sDp0QNIhIofk5Lw0PPAN1nb0lj67rNjoj6V6uVHW1bckR4F4gYScx08Yv+VH/2nLKKaeIc180Kzt27CgfB6KWLVq0yOXyPHyEeaY4Lg2fztDoc6daan/VzJYMgcwQ4NmhbYN8xFSGxHI0aYAajoo5Cc8kJCSuCHgelZQkZ1umjr8zq6XtZQgYApki0KtXL3EIz3fJxBAwBPKDAP1L+u+kdIoS9N2UtFRTc13Hzz/+/ilXDTFqzLiAcQMEDRN7moeWYChQkAgoYWIIFAoCEEGMjZnETpZ43nUMA8kIWY+FDQmNSPImf7qKY9kUNDK/uyeeeKIoB8ydO9c1b9488z/W0p4Q1Ejo6kkDANFWIgSLRatx/Pjx4o+ya9euUo7/Tdpc9ZHJc8PzhttBeB5csqFVqyQ3RDhkNqLm4ljb8r+oQCpi+k2bypi+JgLhyTkIsptIMiYq3b77unq33+6W+36x+6Nh1ag8iQ5eLmX1Z7/vKvbtXOPLpXH517/+VePj1OYB8HXJYJuUTnhBUE9nsB9NSmTiU3PSpEnScDMDq+bwemzUi7XDA4GZaBkfB5STQxTYTKuilzzXhujJJ590BxxwgDjgpSHKpPFLftS/tnAfb775ZnG+C5EIOYnmLvcz00aWjzXCsxNKtJGlUUZLGRX4u72pOc8BTn8R/GHiJ5PrMjEEFAGeIZ4vyEfycFlJSQZL2lnkfzxX2vZBQhLpUNeVhDT/voqw5YZAdggkmsnP7gjp9yawIROymRCVDA7QvGBiAe2xQYMG+W7xvjLBzJn4tpCYsMVPLN8h9cXHAPTOO++USVtMwRhMXnvttQ5ff3T2+T5iYYA2NSZVM2fOlMrjCwptCLBgX85/9tlnu2nTpokWA+QM+6At8+ijj0qCtGHSmzqo0L9iMMBxIWogaHG0b2IIFBoC9A9JW2+9dcqq8c3mm8xAXolMXUdBArNztjGOCNsStfpS4pKc90hzljXxjddJ/JSVsY2GQAIEIJe0PxnNta/JM6uWYEro62Q2YxXGY7pOzvfKFHYSgJ2mCCsmbSe4FyyToxi25ZZbur59+8r3O81hcrY5E61WSEKIVIRvPn0K/M/jHxKh/8JY+thjj5Xo3mg3Evn78MMPl2eKiR20LNX/JuWPP/64aEESIR3FiUMPPVQCPXO8Hj16uAsvvFCIzDlz5lDkTjvtNDk+eShYfHXo0EGswGrCsdBWY1F83XXXJdX0rfANeCw8uRs1yvkek/MOstAT/WuTV8ePrdfYLWmzrftp3zZ/lZf50vILFrpGl9zmnCd4IHMrCTgShMg/TCbZI4AGEzMGSmLi54HEeqJlysIoWpyRF4iXlA6Hkpcsk+gMaR4uU1ZuBAMfSsxOadhogMaOHetatGghjTiN3+jRoys1fg899FBWs080gE888YQ0jNwPPhI0iKqSzsci1XnwhTFw4EDRXoPcxEcGpD5kKhHNaMaYHYIMxYcfHx0GZlwXnU5mfGigaZSJTta2bdvsH0j7R1EhQPtBmwBxwPMWHdCEnZZQO0PNzSDv6RQmS6YJWVSPg1W2yBDAz/COO+4ofrzzVfVMfUU999xzEjUTwpFBDd8VltFGgPxj4MAE6+WXX+7QzOD7hGYCDvPxx9euXTv59hEtE42wbt26Sd+G64Lw5DvWv39/iabJt4zBye1eMQDNBwYhV111lXz/GPjyfYOYpH3C1zk5xCkDHyb/0KKAdGEQRv8Hsyq+fxCcaLNdcMEF4nJFj50Jtlg/tG/fXiYJmSA2MQSKBQEmF5nc5vtPX0Bzlikn1wSpGVrd8E4xblCrLvqSupxMSQLlDZPSRWDx4sXx50Wfm/CZCsvC8WjYr6TN1v4lORPcOrlt2pDZPTt8i0PSNyQh0RDE4ol78uOPP1Y5MN9mvpccg28kY0lM5YtZaMMgGRnH00+ICmMi+gVwHjURMOPZZUKIYEvVlX322UfuEf0otDwTSVWi0nei/FSr87qgzk+9Vv6PH/z/Mfhmt7D/iS5W3xpjwFntnifcSl8tdhXvvruMlAwRA0c/0PW9zbDUlvOIALMmvIi8rKRky2yDBCWHJIvy9XQ2INR4mVPlbIM405xlZmyLUeigoTWCtkd0hgScUjV+6a6X+8KgkI8I2NLJSyQ1PU94TBpSPlI01hBRzFYW670Jr6uclxmIM1ER1cgOO4cs03Fkv1Ajm+dPzcIwDdPEx5ZlclKyZ7OccbdrNwRqGwE0/pgkgFDLl2RKVHL+F7w/ZTQIaCOIlkrfAiGHUIUQZLCJUHcIydtuu83REccsD61+SEIEEycm7hD2Y38lKimDgITsDMlEfDujdQCxecYZZ7Cb69mzpwSlI+Kmajz07t3bDRs2TL7lDFYwA6Mfg0YnwsBit912kzaP73EmQl0xMeQ7yuDOxBAoRQToL9AHjfYvVFkizHnvGUOExCaYoLGsyhCJFCF0TMGYQROa1+WmHFHXzw9jPsgrrPxI3EvuaboUuvbhGrifoXYuy/QzybVPyXeMZ8Ek9whAcKF5qgLZxViPCYrou6n7ML7l24+pNN9CBAs8LCKIPs0Y2CQxAmAKfvRRUGjSfkzivVOXXnPNNe7888+XSV4UjZJJvSob/IBNxM8W++niypv9jGyF11ha+enJbsmBHSpvK8O1eh9/4VaaNttVEHre37gq4jGc37Spa1JlgxXkCwEaHzW/zPQcvHj6oaKTwgdLk5ZrzgCFbayTIMOiAhEXkpd0QkiUhbmWk+OnVBPrdTErS+OTaAaG6+MjS4S0UOjMYfqWTvr06SMaJOzHhzuVJDpPqv1TbQND9bdhncBUSNXNNt4d3iXeuXRJyUneuVC4x2g4aEeR54tOi/qm0k4j67x/JoaAIVAcCDB5gNZirgT/y+qrSY9J2bPPPlvJEgNNTsywo6LfLohH7Wewz/XXXy8TIqEmBpo0RFBFA1I1G7Ag4HouvfRSN3z48Ojh067TL0BCH3/NmjWTsjCQCRqfCJOOECGYhNP2MaBDIGOoG997nUCUDSl+qDfnN5IyBUi2qegRQINSzb4zuRjGDvRhQnIrUV+GSX4dU5Dz3kUFc17eMVKisQIEKG4jyMOkZfRxmYjXVKom62DOhAmJdhaykYQrgDDXZcpph3XMpjll4UQ294M2kTZTtWXJIa1atWoVLwv7m/Qvk2mBRe+vrecHASwMMGF+wU8kcj9RZkglvON8x7CSwIpQ5aabbnLTp0+XScTQXFq3W+7ERBu3MvQ73nvvPTErry4ukMJYPmItkoqk5PhViUo6Oahf+qi5VYhKP3NQ4Q+6srdV/6Xllu73jf8kNatb02L+32+/u9XuH+e8Danz4aKqXolvQJd6f4stPLHVyJuc4leAhAkQL4pJ4SDAxwmCjNTUE8vZCB9LNDJJfAAT5XwQSWhc6DL7sRwGrwnPi/q/EpfkYcckXNZOCjmJzkp0WTsw4fFzsUyHCl+Q6QRtE5PSRYAOYfS55l1I1GHXMjrr/C8qPOv6LmrOQJ8Oow4gwtzIxyiCtm4IlAYCkG/M1qP5kotBNwOY+5lUjgjm2XybVfh+JiIq6Scg0f7bO++8I99qjbCpxwnzoUOHymQdGpaQlPilxJdUTQXCNCo6cOZ61SE+pumYl1dX0DIJydDqHsf+ZwiUEgK0CUpqZXNdEJVKmJHTf9IxQbhMGRYi73qLPfpLYUo2dtB60DZAWmr/n3XGFZqzHK4z6QtZSvtBnihp20d7rG1ymLNMew1hFE0QjFpG28RENdcQ5uEyGCkhGeaprpv7QfvNGEnHTeSMVSAcIbVUi5W+oy5rjnaktvOKo+WFjwCTgBMmTEhbUZ5f3gdIzVALkz/yrqAhuPvuu4sVxLhx42QskvagZbQDmsFgiMIW2pDVHdvjSo4o6yeccILDUiSdVCUqfWMl5Ju32/d2JVX/7/3VeUN+1/DOx9yic3q52CrFaeZa9cKyK1n1wafd8t8vcRV33eV8i131z36WHgOZF/2D/6h/KWCPMc9h8I3ZD6QlAT1oVE2KFwGdvVRti2yvhI8uHRNm/TRF13WmkE4K/lHme+ezYYdFy1PNJNGB0LrSUGvnRXPdFs2ZeSJRHl2mw8PghXKWNdeBUrZY2P61gwDPHDPROiPNMolnK3zWos8Y62zn+dTONOt0PqPCM6BEIzkdQAhHOgdhebjMPvbsRJG0dUOgPBFASwJyDQIw1HyoLhr0tdB8CoXvFue44oorwuKslvk20g5CWKqGox4AApR2D42BWbNmORzYP/DAAxLMhj7Dnj4AVz6FuiFoikSF9p82Ha2gdIIfr+OOOy7dbrbdEDAEMkCAdkddz2Swe8Jd6O/TZ9N+mvbpQlIvXMZkmb6fJohAljkGE8gsYy6bKtHXUzdZ5OEylWSdsQZkhiaIP13WnH4exCgJslSXIRW1DIx03EGeKDF+UcUN/su6EqcJQbPCkkSgvfefzNiCbyyEeCKBeKcPgLZkaJUQ7ovrFjQt9957b4mfgM/KdEG9wv+X+jLuX5hY4T0Gz+oIrmvwl3388cdLTIlMjpH4TIQ2P/dc4qE7PxVR+Ti+EaoYMcIt12oHt/oto9x3px1Zdv4q//bEi67+VG/y7Vlhb1taGR9d89EZIXx38J1t0oABA0RVFsISUxyiO3KjMaft3LmzJCLHmpQXAnykVUOspleuHRc6Hko8hbl2ZJLldFbw6Rh2blimg0NKZK6SqM40YjpTS2cjTJQnS9pZYbsuk2unJsxZ1sR7xDJ5NGmDqp2lMA+X2Y91knZ0ojnXGi3jo0jnLFEelulMctgJpCy6rjPNzCynS9wPTXp/NKdcl7mH4T1PRCzqfeT6dUZaO4CaMwPNhzyZeVJorqQDZD2u5YaAIWAIZIMAk2A4aSfSdS6IymzOnc2+aOmMHDlS/E8SZE6/EUTpxiwcEpTOOVqUaHRCwKo/LIhKvlkIkz8qfBeQZIMu3U+JAl2P5ph4055TL8zeVYuE4x599NG+m39uWqKSgRv9AvqsJoaAIVAYCNDnVU3AwqiR1cIQqBsECGDH2ATriETCN5ZxCyQlAfBSCX2OyZMni1UFEbUJkIf/Z8ZGJk7G79XBgT4EAXPRVAVT+h6ZSmKiEpMUDuKjDnrqs+qxvBlexYTnXL3Wu7nVbxrhvjvp0PLQrPSExCqPv+AaPD3FVeCY3GtGJhSvFutDDDvv5bzSZl4A/PWR8LnGDXvSRwvHZxEz7XQqIS2JPgWByQyRiSGQKQL57rgwKIL8iqaQFFNyTAm0MNeZXHLKdZ0BmpJylIXmH0rcJcrTDdIyxa2Q9+OehqStLivZq1qskMEsQyriQ0fLyUnMNIcJIlHXdZn/sqwD7ULGxepmCBgCpY8A0a/pH11yySWilV2XV0yfDfnggw8qVQPzpYEDB7qHH35YNDEg9N544w3p2zHg4Zv44IMPSmRwfOXut99+8n9MzBCc+dP2QmK2aNFCvotMbCOYvtMfxGzxiy++kLKQ0GRyEQl9earWKJoPfC9OP/10IUvpU6I9Sr+SurZu3TojAhiSlbpSNxNDwBAwBAwBQ6CuEUD5gglCAs7xneUbiRsGvonh2BCSEmutSZMmuUyVwdB2fsFbwvIdRvuPQHT9+vUTS1idWKzr6y+W8xPY9IYbbhCLYkzHn3/+ea/D1zar6leN+q1/95F4hKgkmrV3LptQvDPN2D/2cn8s8T7Kjj3Q/d4kdaCMhMcoksKKn352q9071q04571l5t6JzOL1WvBZ6VWQfZhkHBppadIcDacpU6aIfwRMbFBfhr1Hi4DZd0zE6cxCTpgYAobAMgTQCoHAJKGBonlUU5Ft7EtiW3Q5LGMbH7nwQ6fL0ZxaQOrxrpJ0OVGump185Eip1pWMJDcxBAwBQ6BcEcA6gIBoRLf+73//m3MYmOBhIKLEYLITjBkzRjQS3/Z+x2m7CZwzePBgmRTiP/TfDj30UKdRtBk03eXdAhElHKfz9OXQfoKkZL158+ZyPTopBNFJVHAm6QjWw/FxNA/pick1miCQtZCUmK1deeWVQoaSU4Y2CT6jIFPZD7KSQRmO6jknmgzUh+8b58TsCm1PJrFSyUsvvSSDCvql1MvEEDAEDAFDwBCoCwQYq0EgjvBWvUz+odiCGz2+kfAk+IJm4pDvHMJYC8UNSEoUwaojuHTBxzOTe0w08m3GEoLvMMemD2GyDAHGyLjBIZAfLntQxHvmmWckOBgalKecckq18EpOVGKG4jtTrlMn5+9+8vsAew0x581DftprZ/dTp91drEEJEWoe+JVmzHWrPvycq6jfwFU8NMo5HxUyqfgb43uGTIUvy5PumHwDnUzMbXAOS8JxKS8DnV0iUjK7zWw4HV8TQ8AQMAQMAUPAEDAEShEBAtCceuqpbtq0aW6HHXYo2Eukk05fDSIQclVJSAZNTJYxyPrss89kWyIzMnzNsR/9OnKOh0Z9rgTSF5KUARsanOmEQSCm4pCuWP+YGAKGgCFgCBgCtYmAkpO4L8FnJJNxuFvp1auXTGDi516Fib4NN9xQ9oGkhFhkso1vWE1l/vz5MtnHpGUqX5g1PU+p/J8+Bop2TOCSaqJol5yoBC18MHq22tukONe9e3L8fIcK7cuY94ET++P/3NJ2Ld3S1tu7P9YsYtPlX39z9V9/2638wmtu+Y8+dxXHHOP8FHhy7VLQ8Z1Q35N23lanitl3cvDSb4GdRl2WFw4VZxh+BF8LaFruvPPODl8KOH1ltt/EEDAEDAFDwBAwBAyBYkcAwo4OLz6OmKU3lzi1c0cxuydCOWbsuRjo1U6t7SyGgCFgCBgCxYwAfvVR0oIUJK6HkpOHH364+I7EjV4yufbaa8VKokmTJqJJCXGZa6F+WFcsWrRIXLtU9/j33nuvTALecccd4oqruscplP8xAQtBiYl3OFlb0/qlJio5uvdp42691Tkfxdqr8qU+33ffOXfddS52y2BX8c1C9/sm67tfN27s/m/dNX3AHa9luXwBOyP1XGvFL7+65b79wa3w2VduhXc/9p7MfQSzgz1Re+FFzoc3Tn3tXt3VtW/v/FNLiEXnPZin3r8GW/HBAGFJmjp1qnvttdckWAb+5Vq1aiXEJeQliZfVxBAwBAwBQ8AQMAQMgWJEAD9HaFPiJxG/jeYWI793EbNw/Fli7oapm4khYAgYAoaAIZAvBLA24NsOOYlFKXEMdtxxR/n+HHbYYRJYL5NzY5lA1G60L/E1WagC+QqZd+GFF2YVWKZQryef9UpPVHpzFU9hi2m3mDOnMnvWmnr1W0+HO+f92sQg7T5437kffvTEnz9WwUqF85S2c43XdRXe3MXtudeyYDnrrJO+xt5puQTW+fBD59lD5zbdNP1/crgHqtFvvfWWmEa98sorjjTH+8eknIjSmIzzwpNYXnfddXN4djuUIWAIGAKGgCFgCBgC+UOAiJ7t/WQwQWFwom++ofKD9c033ywBePB5edZZZ+XnJHZUQ8AQMAQMgbJFAEsJlKwgJkl83wnwia/JLl26iG9lTLerI7hbSeRepTrHytd/mAh84IEHJDgfSmYmyRFIT1TyX++rxnXrJsSj8yqqrkeP5Ecsty2YYXft6pxn8b3XUOe23LIgEEA1ecaMGUJaTvdkMSZT+CdCUIUOyUsITKJimRgChoAhYAgYAoaAIVCICGBBQnCYZs2aOXxWYWJkkhsE8IuJw/vrvFUUQXpYNjEEDAFDwBAwBHKBALzEs946F81JEpYSG2+8sdfz2l8SQWpq4sswF3WsjWOgPYr5+tVXX+1OO+202jhlUZ8jM6KSS0Szko4LfhqPPtq5QYOcZ7eK+uJrVHn8ct5yyzJMvG9IN8oH2cmDL4Qa1THy52+95iczGEpcQl5+/LE3cfeCiThm45hXaU5EKxNDwBAwBAwBQ8AQMAQKAQF8Q2GOjAucG2+80R1JMEeTGiGARc4///lP8Ud5u/c338OUEWqEp/3ZEDAEDAFDwLlPPvkkTkxi0k2QNtzSQU6iObnddtuVHUz4fyZA3bvvvmtubDK4+5kTlXowr6LrPMjii/Hss5ctl1P0aQhbMOjf37k333Tea+uy5RVXVISKKv/qq69E2xLtS0hMciUvN9poIyEuIS+J/kjKh2PaogLMKmsIGAKGgCFgCBgCdYYAEazP9n0vIoLv7n2n9+vXTwLuaKTtOqtYkZ2YKOVodQwdOlT6enfddZcEaSyyy7DqGgKGgCFgCBQAAricmzJlihs7dqyk2bNn+5Adq/gYwx2FmOzcuXNZu5+bN2+eBD6m73LssccWwB0r/CpkT1RyTQSO8ZGVnHe47by5iLfFca5Tp2URr9EqJJBMhff5WAriHbr6kFPLSEk/G+AefXRZdG+ioV92GaG3JerTDx6TUvH9+M033whhqcQl5OWH3v8mPiUaNWokhOX222/vSJCXmGFZtPFSeNjtGgyBmiFw3333uX/961/SXuAfN9eCycTo0aOlA4QJ6Mknn5zwFPi7wZk25iVoX1188cWy3+OPPy7+19AawuF2sQgREKm7Cq47jjrqKFmlXT7mmGOkHe7bt2+8jEjJDRo0EKz0f5YvQyDZ86ERplPhRvRpNV2CJANzNWdSfHGn0rNnT121PE8ITJs2zV1wwQUSIRRTKt51fFhu5ftl9FUs6M5fwOO36/vvv3eQk+DGMzxx4kSJ6E372KtXr4L36/XX1diSIWAIGAKGQCEgQGCYp3xMkieffNI9/fTTDutNvseQkiR8S5eDSXcm94I+Cm74Zs2aZd/bTADz+9TLcL/Ku622mnOXXurcOec4N3y486EBnTe0X6ZlWXnP0lmDeCXyt+/M+VGhc5tvHr82BjW9e/cWk2oGLm18wKHWrVsLa17oDl3jFxEsrLXWWjKIDwfydHB5sRjgzZw5040fP97dcMMN7rfffhOn9lt783dUuLf1GGlioGBiCBgCyRGAGCklLSD8nOGHhnYhHwJJxEwtHSL82SQTNK7mzp0rbdVBTCr9KUy4fPTRR0Kkalm+81zcY9x0YOaK/7hu3l90GEgE4mHYsGFSpkQlpAQz2RA1hexYPBfYVOf+JXs+MsENK4TJPmgez+Guu+4qp+e7v8UWW8SfN6JUGlFZnTuT3X922WUX6YvwrN99991C5hMExiQ1AvTN9tlnH5n0YSBpE82p8bKthoAhYAgYAssQoN8GF6B9cQL41qtXz7Vr185ddNFF4kea/pBJZQQmTZrkHnvsMRm/FCM3VPlqam+tekSl1g/NyeOPX5YwiSZYyxdfOOcHiV79Tvcq7rx+feen5p1XV1kWFTzJ1WA6gxYFGkX333+/aB8SyYmBDDP8EJd0qlddddUkRyjs4oYNG0ojREOk8quP7o5vI4jLN954QxJaP2hkIuuvv76Ql9tss41r0aKFpObNm1caZOuxLDcEyg0BSBEi3KGNZQPFzO4+bSjmEhCVqaRt27Y+vtmPfg7NT6IF8u9//1u0rnDgXRuS63vM5FEmkRB5nvB/Q2eoUDtEucYmm/uZ7PnIBDdcoRzt/XTzrdf3lm/9JptsIokOu0ntIkAf47/efzqJSVXMq9DqwB+WyTIEeFZX80oGPKe49TExBAwBQ8AQMAQyQQCrUcYq9L1JBMJhjM9EF4HXGMtg4m2SHAHc1YDTvvvum3wn21IFgdz1qH0nSMg8CL0ylL/97W9iSoMpNNoaCJpFzz//vHvppZccpB6aU1v6qOAdOnQQv0qQl018EJtiFbR11AQ8vIYvPFmtxCU5quBoXzJoYNC8uddGVeKSHDOtpk2bmmp4CKItlzwC559/vrQPzE6aZI6AkkPp/pGMMKotkpL61cY9hnTg2xIlH1ZfffV0ENXp9trAJtUFJns+MsFNyV/NU53HttUuAkyq4hrBxBAwBAwBQ8AQMASqhwDjd0y6CfyCFQn+J1G+OvXUU0VrkvG/SWYIPPjgg2J1i0s9k+wQyB1Rmd15S3JvCLiRI0fKDINeICQEJCXCMuaI+Ce4xUcMZx0THPw33HnnnS6TAZIet5Dz9dZbz5EwLVKhgUPDZ86cOfH00EMPuSuuuEIaP8iHzTbbTEhLtC5JEJj4vyxWLVS9dssNgSgCkDRXXXWVFBNtlSBVl19+uaz/7P3i3nzzzW7q1Kni/xZXCqd51xrMXmYr+CK73vsSnj9/vkySEG0PFw3MfHJc5OWXX/audx91mG9QTkQ6ovGp4OuRd/W7776Td/SAAw6o9G7rfpnmRAGkvdPzoeFzrfd5fNZZZzl8UEK6DfcuRd555x3vYeRSaR9wRwEmodCmoMH9wAMPuCVLlkik2nQRgIkYjMY7ZOXx3hqANpjrv+eeeyQ4B3iN8cHS8K95+umnu0033VSwAR+ILTQy0ahTQWsLbPD1hhYX+HJfwTHVPcb8g7RgwQI53jnejQoES3UE3z88GyEBu3TpUjHL4VpHjRoV1/xLhn2m56WThZYq18dMOg7BuU/4yAxNndM9w6mwSVWXDz74QGbvcTHAc8L9Pvzwwx33tX///jIZho/UTt5ndqp7k+wcyXCj/Morr5TO+gorrCBaaRyDOpgYAoaAIWAIGAKGgCFQzAjQx8etG8QkBOXnn38ufWEseXCtwpjeXLplf4fpD+OWCb/yRu5mjx8DNZMcI+DJt5gfwKAmlVHq3r17jmtQPIfzL3DM+5eK+dmGmB9oxo444oiYN+OK+cF3HDtPesY8mRvzA9CYN+2KeSfwMU96xrwfvOK5UKupIRAg4EnImCfh5Rn3Wtcx1pGFCxfK8+/9L8b8bGbMa2PHPAEV85MYshwcIu0i//XkWmzEiBExT9rEvAa3nM+TojFvuir/Zx+vFRbznZCY13iOnXLKKTE/aRDz5JNs9yRebM0114x5dw4xT9bEfICWmPeTmPTcPmqsnMP7kky6jze7lXedHXxnKLbGGmvIvrzPvhMk/9c/e2JN6ue1BbUo5klD2QdMPJEYAyuv3S1lnpSN7+c1uaWMdgXxpJ1gS7vsA3BImSefYp4glP18ByLmHV0LBmACTp6Mi3nSNuaJL9nHB0yLeYJU/suP77jFvDZ4zE9Gxd58882YN62MecJOtie7xxdeeGHMuwOR+3nHHXfEPPElz4LXwI8fN7pAPam3n+iJbpJ17xc55slCWfY+FOX+cu/5T9hOJsM+4UEjhVzfbrvtJsf0xGjMa8PLtXIfwMsTz/KPTJ7hZNhETplw1ZPTUgdPcFfa7onumPdHGi9LdW/YKfp8JMPNmzzFWrVqFdt///3lPfKTjTE/qSZ18BGT4+fTBXD3Pip11XJDwBAwBAwBQ8AQMAQKCgHvfifm/Z/HLrvsspj3sy19f/r/jBUGDBgQmz59eox9TGqGgFe4iPnJ/ZhXxKjZgcr030ZU5unGM2DSgWIqwtJrC8YYIJlURsBrzAgZ6bWbYl7bKnbCCSfI4N77Z5MBIpiCr48sJiSCV0WPQVJAYnrtGiFdKh/R1gyBwkLA+7SVCY2wVscdd5yU+YAv8eLnnntOnnkIMcjETAVihU4H7xLio2XLcXiXVLzjaynzmnJSxPvDu+X978m6166MeW1GIWgo8M6gY5BmySQdUek1O+X4dIxUfPRuXYx5sxLZHi/wC167MZaIqIQ0VdFrg3SEWEKiRBRl3reOHF+JSsrOPPNMKRs0aBCrIn7mU8p8ABstivmouFKm9wZikQmVsB7cU9okleg99g7I5Z58/PHHuouQnWDutRPjZdGFdEQl5Gi/fv0q/c1rd0p9lahMh32lPydZ8dYAckwfPC3mXZzIXoMHD5YyJbAzfYaj2CQ5ZcJiMAczrwEb3+7drsSmTJki65ncm0TPB3+O4gaxzLmUvGcfr/0sZUZUgoaJIWAIGAKGgCFgCBQ6AigdeCskmWSmb03fBmUgJrpRGFq0aFGhX0JR1Y++vvdhHhs4cGBR1buQKmum3/4tzYfce++9zmthOEzVMFNLJJiNYZa59tprJ9pc1mWYgvsBvyRPuFTCAqe+mFliSo4ZPWnGjBlidk9EVgTfYZhDYrqJSTm5JkxN2eaJzkrHtRVDoLYRCE1H/YfB4ccEtwmhGS+BP/CBq64TQtPjVPX9+uuvxWyaqNBE4NMIxb4jEv+bJ2EcptwcE7PnW2+9VbZhIozwH8rwvYufWUzCa2K6wHXxHnJezoFpN2be1ZGuXbvG/8Y1YD5PVHCv+Re/1vgOfy5gJh0VNbkmIIcKLicQNY9nGf/CCFHDuY4GDRrIubg3tEm0+dwjzDxCCe8xAVgwWfeam/FdMFvHbQhBQKorXHv4zHCc6LXmAnuuGcEfJteN4KIDoe3N9hkOsZGDZPiDj6QJEyaI6Tnm9rT/BOfRZzzTe5PodFHccNOywQYbyDuk+3NOpLr11+NYbggYAoaAIWAIGAKGQD4QgH/wE7gSCMdPzjqvQSmugIiR4SfpxU0O7qBM8oNAnz59hG8Aa5PqIbBc9f5m/0qHAD68vHaSRLhONJiBJGMQTPRQk+wQIHKl18Zx3bp1c14jzA0bNkx8h+HvDcJASUt8zBGsh3LIEK9JJpHLISoZjDK496aM4uMM/3iQxvhfw3ceAYEY+JoYAvlEIGwbIHqIVA3JHgptBdGuEQj6TIXocojXNpQc/7gI/vtUCIiFXxqCT+A3MhqNzrticL1793ZeG88deOCB8l/89VVXuN6hQ4dK5Gr8GxJES+tX3WPq/7zpiixC0NZU6tevX+UQ+CZEvIZifBu+LK+55hppV2jzlcyM7+AXwnuMP0faLzqLmtRvMREBqytEAo8SldFj5Qt7JpVUsn2GQ2z0GJnkEOaQpd6tgRC83oTe4ZsylEzuTbh/omWux5uyC7kebtd6ax5us2VDwBAwBAwBQ8AQMATqAgGUd7yli/OWnc67bpL+KZPkKBzgs5w+zQsvvCD+vo2kzN8dAmPilsAtMNYyqR4CplJWPdwy+heDcDSkohqB+ucPP/xQGg4CSYSBZ3S75dkjQOAdGmNSVND2gYD0qtiizYVGlyYis7P85ZdfilYQ/4WYQJOGATE5ZID3URfPdZkBsWlnRtG29UwQCIkO76tRniO0AtHag1BX4flDeOYyFQKWvPXWWxLUBc1u7xfQEbTl2GOPjR+CTgsBSf73v/8J0ePNzOPbWGA21ptzC0EJmf/MM884739POjmVdsxwBW1CtN5mzZrl/vOf/0ggHG9SLTOO3tdkhkdJvJsG3aLdrQ3hWgjkQnviTeKlQzhkyJAqpw7vsTcBkckUCEvV2tQ/8D1A27Q6gjYomuOpJJ/Y63mzfYZDbPQYmeSQowR98ib87vbbb5egShqciv9nem/SnUsD4RFEyLtdqKKlmu7/tt0QMAQMAUPAEDAEDIF8IYA1Dn13+udoTdKXpD/coUMH502OhV/AQtGk9hBg7EQQVIJOevdWtXfiEjyTEZV5vqk8pJg3XnzxxXECjEEWA6wePXpIpFk0nEgQlt73V55rVL6HZ1CMyTdJTQSjaKAtReRhJTA1hzyC6IHIREMz1CrjuERCg0RS8lKXKWdGK5ogLEzKGwGeGwgVPmgQ3cy4YVaNpt2LL75YKYoyZZizZmN2zTPKzClRuyGxfCAqF33uIHeoA5qTCGbICKQ+4oPrSBRrtnfs2NF534AS4RrzcZ7pbIUOlPcFKcQoEak5HlHPiYANUamEP5rRaB5SD+qXiXazD0okriJyQVTq9ae6PnAlMiKRwBUL8Av/G73H3D9mWGn/iRbOdoTI48y6sq06Qoc0naTDPt3/M9mezTMcxSaT44f7eF+Y7pJLLhHynWeI50Ulk3uj+6bK0brn3vK8M5nF84rwziKZPJeyo/0YAoaAIWAIGAKGgCFQQwToE/tAN3FiErdN9DtxNwevQJRuxrhqBVTD09nfq4EA4y00W33wz2r82/4SImBEZYhGnpYZlGJOPG7cOBnYoClFqHrMjxmgv+DVg/FfgAo2puA+KEIlbao8VcsOmwABGvYmTZpISrA5XoSJrpKWEJfRZfwCUs4AF9IlKtz7KHmp6z6KrsNvHonBt+bMkGnCP5ySHNFj23pxIABhTucCLTyeOzoWPiCJ8xGh3U033SSai5ggo13pA0QJKYPGWqaCbxQfOVy0F9EkhuxE+xf/ehDoiBKD+Ixs3769tD2U015hkk2H6Oabb3Y++I08r5igQ+bzjFZX0DLHZQMayjrTqGbbdLAghCCh0LREm9NHLBecfLTnStrpYKJC24p5ug+WI/53KP/8889lM+a7KvouogWpAjZI6CMSghdhokLFOyGXReqDKDGG+TEkKxMZuJ1A6Jwwgx29x9xb3mFcTHCthxxyiNwj6j158mT5b7Y/kKNokHMuviUq4bWqtmUq7PV/qXLaOSTEiucTUd+nmT7DUWx4/tXfpRwwzQ/PMtq9EN5Rs+9M7k2i54NTRnFDC/m8884TQv3uu++Wd4f3AeH7DfbqZkEK7ccQMAQMAUPAEDAEDIEcIYAVzvjx48U3N5PyuGzC2o9+JJPl9EF0wjxHp7TDVBMBlAJQUGNcZZqs1QQx/JsfKJvUAgJ+8CPRYD32MT+YrHJGTwjEfDCGmB9QxrxWSsyrDMf8oLDKflZQfAgQddeTJRKN3GtOSWTye+65R6KUe03bGBHLu3fvLtHLiTjrA5/EvEZmzGvQSUQ2nplo8n4MY57wiBEF3TeEMU9yxzzZE/MfrZgP1BHzs2qx448/PuY/YDFPisd8oxnzvvRi3sQ35okxifrmyZSYJ3hi/qMn0XKJSOz95cW8mXDMD+Il+psnQeJRo4sP+cKusSdYJMK3J5wl8rTXzpIKe0Iu5gNsxbz2XcybR8v97d+/f4w2IhvxQXCqPDc8R55kjE2cOFEONWbMGHnWPFEa8xqTMaJ/e6Jenj0iG/NcetJHnilvMh7zPixjnlBLWg2ea87hNZAT7uODzcj5vYmzPPdek1yuUa/dE4Mxb8Ysx/CdsJg3640RHbpdu3Yxokp7TbaYJxFjXsNTjuNJInnuef71mjgxz7nXhpPjcL3eDD7mCVdpX6kf1+QJKDmmnwiQ/Tjv2LFjJTqfllEHT0TGPHEs0c/5L+8n7w73g4jlvIveND92xRVXxHzAIVn3/odjnjiNJbrHtAGepJNzcjw/cRUjsnsqSRX120+ISPRxIjfS1njiMOYJUHm2OL4nAGOepI6lwz7V+dnmJ19i3pep1Jtr9j415VngXnIeMKNtQTJ5hhNhI3/O4gcseQaiku7e0B5Gn49kuPHMca18l7lOT5BK+0r7S6RMr/1c6fSe/I95ArVSma0YAoaAIWAIGAKGgCGQCQJ+Aj3m/UrGvI/4eF+FfqsPHCn9TO/WKZPD2D51gADjJD/pHvOug+rg7KV3ygouyXe+TWoBAWZECCCBxkkyQVsJDasBAwaI1spJJ53k8A2H9pFJ+SHA84D2Elo+aHGGafHixY6ERlW4/NNPP0kZOQkTYM1ZJhGZWM0XM0EVdwVogSZKmHtquS6HebjMfunWw31SLeu2TOpfqPugpUfwnOhMqCdaHEFWuN8E3dIIy9lcBz4gwch3dBwBZngGeE5oXzwRKkGoOB7PGEnNwnkuWMfUnOcErU60z7hva621VjZVqLIvprIcn+vDxQKaflx/VNB4ZLYYrWHqrXUL9+PThTYf2KkGXbi9tpZ5N8PzR9cT3WPqjtY11wcG6bSjMdFHq2/OnDkJ3YNwDu5PWI/o9WeKffR/1V3P5BlOhE225+MYyZ7L6L2IrmdzLvxV4gIEP6I8k9yzRM8l2tFEda+uGX82dbJ9DQFDwBAwBAwBQ6C4EaCv7yfbRWMSzUn6evQlCPiKtiSJoJdqBVXcV1u6taffh99/3He1adOmdC+0Fq/MiMpaBDubU0Em3XLLLRJRFhVvfHBhgpYusms257B9yxsBCCMlLSGkSASMCJd1nTyaGLiHZboe5uEy+6Zbz3beBLJAiU9IOU2Qa9FlLSOPJkg5ysKcZRJkBEmXNWf/dARTrp8wJjAwN00lkFUEeTn55JOFoIySOOp022vppTqMbSsgBJSoxCxezeRzVT1M46PR3hMdG1cC3bp1S7QpJ2WZPtteAzwn58vHQWjjaCsw6TeiMh8I2zENAUPAEDAEDIHiRoCxEL4lJ0yYICbdLDO5S2BEJSa9JVG1lBSKG5nirT1uoXBfRADlO+64o3gvpMBqbj4qC+yGaHUgQ/BbCdkwdOhQd/XVV0t0UwaKZ5xxRsKo1vpfyw2BTBBgZk59Xmayf23sgyZflMwMCc5ExGhYpmSrlul6mDNzGa6HZC3LJP6fjjSFpFTSEo1HCArydGmVVVaRfciTJUjQRIJPxy233DLRpngZdfJmvrJ+wgknuIMOOkh83hL5m84Qvh2HDx8e398WCh8B7ikENEGNcJiOP1E0ZnMh+MBFWzOdeBP8dLvUaHumz3aNTpKnP+M/1bs9EOfpvNO0BSaGgCFgCBgChoAhYAhAQnrXShKdm8lWJp2xzCBmBUH6CFxJju9tk+JEAF+hjAvha0xyh4BpVOYOy7wyxCCjAAA22ElEQVQeCQKHoAGYjc+ePVsCbkBYen8VCU0n81oZO7ghUOIIQFJCZkJa0plIlGNyzzZNrGuZLoe5mulTxjKEbDLB1D4ZiankcqocbVLv30aiSc+aNUvMRZjpI1gX5GV1TMmT1dXKDQFDwBAwBAwBQ8AQMAQMAUPASeBcglliwQQxiSkwrmdw49ahQwcJwEi++eabG1wlgID39y98DJPWXbp0KYErKpxLMKKycO5FxjVBVXzQoEES4ZbZGCKeYhqO3zkTQ8AQKA4EmHxQ36KJciU0o9vo7IS+SnWZ/ZL5HWWWD805tPIyTewfTaYpVhzPltXSEDAEDAFDwBAwBAwBQ6B2EPABbuLEpA+a6xYtWuQaNWokFjBKTjZv3rx2KmNnqTUEMPneeuutxWQfyxqT3CJgRGVu8azVo82bN0/8WA4bNkw0ufCLham4OXCt1dtgJzMECgYBND+VuIzmGpQJojNdgvRMZPqOc+8oeanrPrq2bCMnwA35GmusUSmZJmfBPCpWEUPAEDAEDAFDwBAwBAyBaiAAMUkAHBLE5IIFC6QPjG9JJSYJhlnbvuyrcSn2lxoggKUaAZDefPNNGe/U4FD21wQIGFGZAJRiK4KcGDFihBs8eLB79dVXXYsWLRzRwnv27Ck+CIvteqy+hoAhULcIECEaspJAXhCc0ZSoXMvImUmmXYoKflGj5CXriUjNaBmaoNbhiyJq64aAIWAIGAKGgCFgCBgC+UKAiXvcrikxiSn3119/LWNsAhziN3zPPfd0O+ywg8N1k0l5IEBw04MPPtiZyXf+7rcRlfnDtk6ODFFJtHCIy+WWW8716NFDfNLReJoYAoaAIVBbCOCDE5MITUpgkmuZ5tEytEGjQnsGeRkSmGhuEtUc85pkCY1PIzijaNq6IWAIGAKGgCFgCBgChkAUASbrZ86cGScmJ02aJBPw9D+xWtxjjz2EnGzZsqURk1HwymT9888/d2jMErD0zjvvLJOrrv3LNKKy9jGvlTMy8Mck/LbbbnNz586VSLEE0ejevbsE6aiVSthJDAFDwBCoBgJESITEjBKY0TI0N7/55hu3cOFCSawTsT0UZrchNJMRmYnK2Z+ARCaGgCFgCBgChoAhYAgYAqWLAD7jicoNIYnWJFG5sSSif4gpN8Qk+XbbbWcBbEv3Mcj4ytCw3Xvvvd1HH33kXn/9dQtQmjFy2e9oRGX2mBXdP2h4b7/9djdq1CiJ/tutWzfRstxxxx2L7lqswoaAIWAIpEIAk3UlLjPN6ZBGhajrURKTgGUktDijy+xrJj9RFG3dEDAEDAFDwBAwBAyBwkEAq50pU6YIIckYedq0aeKuaN1113Vt27YVYhJyEldqZpFTOPetUGpy7bXXuvPPP9+9/PLLzriU/N4VIyrzi29BHR1tJCJS3XHHHeL0FZV1tCwhLjGPNDEEDAFDoBwRIFo62pipiE00N/FJpDntaRhwiM4s/jajRCbr66yzjpRHc3x2mhgChoAhYAgYAoaAIWAI5AeBL7/8Mk5Koi05a9Ysh+XO3//+dyEmMecmbbHFFvmpgB21ZBBAg3LXXXd1l1xyiTvvvPNK5roK9UKMqCzUO5Pnek2ePFm0LB966CE5ExHD//nPf8osks0e5Rl8O7whYAgUPQJ0ciE2Q/IyXFZC86uvvpJ92AYhqkI7i78jyMsogck6M/uas8y+1jYrepYbAoaAIWAIGAKGgCFQGQEmkN955x3HOBdSkvTee++JxQum22hMKjHZuHHjyn+2NUMgBQI//PCDaFBusMEGbsKECeYGIAVWudpkRGWukCzS42DySOCdIUOGuOnTp7vNN9/cHXPMMa53796OF9HEEDAEDAFDoOYI0HnG5ybEpZKX0WXITC2DBMWhu8oKK6wQJzWjJGZIaLINLU4zQ1fkLDcEDAFDwBAwBAyBUkRgyZIlMn7FDJeESTcWMg0aNHC77LJLnJjcbbfdJEp3KWJg11Q7CBx66KFCfKNVud5669XOScv8LEZUlvkDEF7+7Nmz3dChQ919990ngSxwFHvssce6Ll26WGCJEChbNgQMAUMgzwigsYlW5oIFC4S8DPNwWYnNMIgQEdLxo4m2AMSl5uGylrEf+5sYAoaAIWAIGAKGgCFQyAgQwCQkJTHjxlplww03dK1bt5YEKYl7MyZ4TQyBXCBw/fXXuz59+rjx48dLxPdcHNOOkR4BIyrTY1R2e/z6669u9OjRQlo+++yzbrXVVnNHHnmk69Wrl8xOlR0gdsGGgCFgCBQ4AmjHQ2Dii4nEsq6HOcu08SpoXqKBCXHJDDF5smUCDJkYAoaAIWAIGAKGgCGQbwR+/vlniaqMliQJgvLzzz8XAnL77bePk5K77767EJX5ro8dvzwR4NkjuBJ+Kfv27VueINTRVRtRWUfAF8tp+SCgYTls2DD31ltvuWbNmglh2bNnT/soFMtNtHoaAoaAIRAgQCCgkLxUcvOLL76IE50so9EZmp//7W9/q0JmQm5GE1qa5k8zANwWDQFDwBAwBAwBQyAlAu+++65E4J46dap75ZVX3MyZM91vv/0mFiJoSarG5E477SSm3SkPZhsNgRwgQF+ZyN74Nx0zZoz1bXOAaTaHMKIyG7TKfN9XX31VCMvhw4eLaXiHDh3cUUcd5bp27Spal2UOj12+IWAIGAIlhQDm55iWQ2RGSUwlN5nMYvmnn36KXzvmVpiZRwlM1tdff/14OfuYL804bLZgCBgChoAhYAiUBQL4kZw2bVo8QUxStuKKKzq0JfEvqYno3CaGQG0jgEsluA78x/N8rrHGGrVdhbI/nxGVZf8IZA8AZoNjx4519957r+T4NzvggANcjx49XKdOneQjk/1R7R+GgCFgCBgCxYoApueQmekS+6nw7SAQEOSlJiUzdZ2cfcyPpqJmuSFgCBgChoAhUDwILF26VLQjUXiB8IGgRHsS2Wyzzdyuu+4aJyUhKVdaaaXiuTirackiQHDhRx55xKHh27x585K9zkK+MCMqC/nuFEHdMCEcNWqUu//++92LL74osw2HHXaYkJZt2rQxFekiuIdWRUPAEDAEagsBNC9DMhONzGhie0hoonWJ9mVIXrK8wQYbVCrD5NzEEDAEDAFDwBAwBOoGAZRZCM4KKTl9+nTJ33zzTQl4s+aaa4oZrWpKktt3u27uk501NQLXXXedO/vss8Xcu3Pnzql3tq15Q8CIyrxBW34H/uSTTxxm4fi05CNFBLbDDz/cHXHEEW7nnXcuP0Dsig0BQ8AQMASqhQCEZkhgQl6G65999pmsL1myJH58tDBUIxMSU4nMaI6vTRNDwBAwBAwBQ8AQqD4CuIchfkFIShKFG7Jy1VVXdTvssIPDnyQ+/sjRnjQxBAodgXHjxrkuXbq4gQMHCllZ6PUt5foZUVnKd7cOr23OnDnuwQcflIR6/6abbhonLVu2bFmHNbNTGwKGgCFgCJQKAj/88EOcwFTyMsxZxocmDvlVGjZsKBNpSmYyqcay5ixbQCBFy3JDwBAwBAyBckcA8hHNyBkzZkh6/fXXHaQkk4oNGjQQv5IhKbnFFluYy5Zyf2iK8Ppfe+011759e3fIIYe4u+++uwivoLSqbERlad3PgrwaPmYjRoxwI0eOdPPnz3d8vA499FBpBJhtMzEEDAFDwBAwBPKFQCwWk6BAaGRCXIbp008/ja9/99138Sqgnanm5SGBqcvkaG8SOMjEEDAEDAFDwBAoFQSwVICEZPwGMUmOAgoTfiuvvLJEQGb8RkJbcquttnL16tUrlcu36yhTBD788ENHdPltt91WYnBY/67uHwQjKuv+HpRVDXCgDGH58MMPu48++sg1adJEooYzc0HjUFFRUVZ42MUaAoaAIWAIFAYCDM4gMUPyMrq8YMEC98cff0iF+V4R6EfJy6hWppZjAmdiCBgChoAhYAgUGgJfffWVkJJKTEJKvvPOO/KdW3311R1WcBCSmjdr1sw0JQvtJlp9aozAwoULXevWrR2ugSZOnCiuC2p8UDtAjREworLGENoBqosA6tUQlqR58+aJ9srBBx/sDjzwQFG7tpmM6iJr/zMEDAFDwBDIBwK///67BANSrcyQyAxJzp9//jl+eojKKIkZXbfI5nG4bMEQMAQMAUMgxwigDfn222+7N954I05MsoxrFKRx48ZxMlJJSdx2mRgCpY4A7gv+8Y9/SN9uypQp8i6U+jUXy/UZUVksd6rE64lJAYTlo48+Kh/Q1VZbze27777ugAMOcETbYlbPxBAwBAwBQ8AQKAYEFi1alFQzUwlN9lFhYg5TcgjMKImpZeT169fXv1huCBgChoAhYAhUQeDrr7+OE5JKTBL0Bj+TK664omvevLmYb2PiStp+++3d2muvXeU4VmAIlDoCTCoTOGfmzJlu0qRJbssttyz1Sy6q6zOisqhuV3lUFpPw0aNHu8cff9y9+OKLDv9i7dq1i5OWTZs2LQ8g7CoNAUPAEDAEShaBpUuXSiCgZFqZEJpEO0eLU6VRo0ZpyUz2MTEEDAFDwBAobQTwq0yAGxIKH5ogKpF1111XiMjtttsuTkxCUprFWmk/F3Z1mSGAljGWnJMnT3bPPfecaBRn9k/bq7YQMKKytpC281QLge+//949+eSTQlo+9dRTjo/y3//+d9GyRNNyjz32MA2TaiFrfzIEDAFDwBAodATwh4kPsZDMDJfVBP3HH3+MXwpalwQCUh+ZoUamLrPdBqtxyGzBEDAEDIGCRQD/yXPnzo0TkUpM8i1AcC+y9dZbS2rRooUjbbPNNkJUFuxFWcUMgTpE4P/+7//ckUce6Z5++mn37LPPul122aUOa2OnToaAEZXJkLHygkMArRJ8R0BckjBnIPpchw4dXKdOnVzHjh0dTp5NDAFDwBAwBAyBckIAolJJy0REJtuigYAw9VPiMlm+xhprlBOMdq2GgCFgCNQZAt98840QkpCS+JMkJ3388cdiXdagQQMx24aUVEKSfOONN66zOtuJDYFiQwCS8uijj3aPPfaYGzdunFhtFts1lEt9jagslztdgtfJwIsGBtJywoQJ7ocffnAbbbSREJaQlnvttZf5XCnB+26XZAgYAoaAIZA9Akz2ETghFaH5+eefO7R3VJgMRPsyGZFJOb41TTtTEbPcEDAEDIHkCODOChdXIRGpxCREJYKGJL7ySJhqkyAnN998c4u4nRxa22IIpEUAc280KbHSxM0cQXRMChcBIyoL995YzbJAgAHYK6+8IurbqHBPmzbNMWOCg2g0Lklt27Z1DRs2zOKotqshYAgYAoaAIVBeCOBiRcnMaA6RSRnm6JilIxUVFTIpGJKZIbmpy+Y7s7yeI7taQ6CcEaCNnDdvnnv33Xcl12XWCeCB4ENSiUhyJSZx22FiCBgCuUWA9+6QQw6RoDljx44VXiC3Z7Cj5RoBIypzjagdryAQwAzu+eefd+PHj3cvvPCC+HVhMNWyZUvXvn17SW3atLFo4gVxt6wShoAhYAgYAsWEAJODBPoJiUwlMbWM9cWLF8cva6WVVoprZyp5Gea6jBaniSFgCBgChY7AokWL3Pvvvy9kZJSQxMc+QnuGb/0tttiiUoKYXH311Qv9Eq1+hkBJIICliEb3Rpty5513LonrKvWLMKKy1O+wXZ8ggDnFxIkThbSEuMQRNcQlphS77767g7Qkb9KkiSFmCBgChoAhYAgYAjlAAJcsEJdKYmquZaxHI5tj+QBpGSbMy1nXvHHjxkIA5KCKdghDwBAwBBIigGXWJ5984j744AMhJCElw2UlI3F9semmm8aJyKZNm8aX0TRnvGFiCBgCdYMA/rkhKXG5gNXltttuWzcVsbNmjYARlVlDZn8oBQQgLl966SU3efJkyWfMmOF+/fVXGQhBWBL9i7TDDjvYYKgUbrhdgyFQJAiggfboo4+6J554wj3zzDPu22+/lZrj1wq/uzjTx2QlkbAPnTCiGOJ7Bw0PGyAlQsrKCgkBTMi//vrrSmQmBGY0sY+am1N/CE2IS0hL8jBpGfmaa65ZSJdrdTEEDIECQYBvJiQGBMb8+fPjOWQkiTJ82iH4jdxss83ETyS+InWZfJNNNnH16tUrkKuyahgChoAi8M4777h9993XLb/88hLXAu1mk+JBwIjK4rlXVtM8IoDfiunTpwtp+fLLL4u/S/zL0PEgoh4q4hCXrVq1cltttZUFDsjjvbBDGwK1gQADlEIk8SBnCBB25plnOlxYUE8EzQ5IlxVXXFE0PJZbbrkqMLHPXXfd5c4991yHpgfmuSaGQKkgwPNNMCA0MMMULYN4YOJRhXcGX3BKarLMu0SKLq+yyir6N8sNAUOgyBGgzaCtIGo2pCNJSUmWKVd/kRAZaD9iWYV2JGRkSEiuvfbaRY6GVd8QKC8EJk2a5A466CDRbh4zZoxba621yguAErhaIypL4CbaJeQHAToxBOghMA/5a6+95pYuXerws7XNNtuIv0s0Lkmso+lkYggYAoWPAFpZRPpD+5DBSSEKkyNMnihRSR0JcgJBudpqq6WsMlrhr776qvvll19S7mcbDYFSRIB3Bt9xSmCS6zIkpq6Ts1/4juFPDvIymtZZZx0pI9flNdZYoyAnO0rxnto1GQJRBHTiAtPsTz/9VCbwyMNlJv7YD8E8e6ONNhLtR8hIEpqQmhPAxrQioyjbuiFQnAjce++97vjjj3f77befu++++2yMXpy30RlRWaQ3zqpd+wjQ2Zk7d67DTPz111+XfObMmQ4fXJAHqJNDWIaJ2dhEmk+1X3s7oyFgCCgC5513nrvqqqvEpKtQByatW7d2U6ZMqUSiaP3T5W3bthWikokVE0PAEEiOAGadWE9AWkJiJkvss3Dhwkqm57QdaFlBXCbKKdOEJocRm8nvg20xBBQBJg5wz4QmJESjak/rMrn6uFUSkn42kwsQkRCOmusyhCQ+bq0/rihbbgiUJgJYEp111lnuxhtvdH369JG+vr33xXuvjags3ntnNS8ABOhQvffee27WrFlu9uzZ8YRvG7S20LJs1qyZI7rflltuGc+J/odmpokhYAjULgLnn3++GzhwoJz06KOPlkHN5ZdfLutTp06Vmde3335bBjqdOnVyRxxxRNYVRMPjzjvvFE1sTEkZJF177bXx42RynihRCemIb8r777/fjRo1qpImKAHCON+HH34omt4TJkwQ87affvopfk5bMAQMgZohACkCgQJpSYLUJMd3ZqKcScxQIDYbNWok5mcQl9Gk28jxq0lOVOBCdFERXpctGwLpEKCvjL9lfXfC94dlJgqUiGRZ/UJyXLSc1f+sBtSCgFQSkpxyNCZNDAFDoHwRoC057LDDZKJ+yJAh7sgjjyxfMErkyo2oLJEbaZdRWAhAEBBZfM6cOaKFCfGBNiZEAoMdZncgL4gMiCZmmGOGYiRmYd1Pq03pIIArh169ejkcbD///PMymYD/2VtuucWdccYZ7tZbb3V77rmnGzx4sLv66qul0zNy5MisAGjXrp0EvunXr58EtunWrZuYmHKQTM8TEpUQIcwMP/DAA+J3kkGcaoJi3nLKKae44cOHS72vueYax3kZ3C1ZsiSretvOhoAhkDsE8JMJscn7q0nX0c5kOUyURd014JoCTUwlLyEww8Q2EoRmNKcNMDEE8oEAz6k+w+TRxPOuRD7kAesh+Qj5zjOtrhTwF6skJKRkuEzQLBNDwBAwBFIhQHwJFAvwSU1ASovsnQqt4tlmRGXx3CuraQkgQOeOSLwQl/PmzRNtTNZJdOoQOnB00nDmHSaITcxZSEZklsDDYJdQZwjstNNO4nNWIwi///77EjSre/fujllYlT322MO9+OKLEqCmd+/eWpwyx1F/Ez/ZcNlll7kLLrhA9t1///0linc25wmJSj0hhCr+cpWoZHCIe4nOnTsLicl+aF4y6MP8xYhKRc5yQ6A4EFi8eHEV0of3HF+aiRJaaqQweJBeKQO2RAQmPm4hf8I8XA631a9fXw9neYkhwLcCv8eZJJ69kIyMflvot/KsQT6S1BWCEpGYZeuyukooVP/QJXab7XIMgZJGAOUf+tsDBgxwWEExec+knUlpIFCvNC7DrsIQKA4EIBiJIk6KChF+ITIwG0fzUhNBMeb7wD7qb44OIZ3AjTfeuJIfHqIVQnD+f3vnAm1VVf3hpYiYCCHmI3y/ALXyhUUGUqmhKWpWapFlWjqsjDJfo5R8NNLKtAfYIEdmWWSZpkilYmiK6ch84IPwlYkiJBiSDwhU/n7L5vlvN/tc7r0c7uWe+60xFnOttfdee+9v33vZ53fmmjNqnz59yqewLwEJ/I8Av0dRrr766pz5c+jQoTGULS89CJVXXXVVaq1Qye8lXzCcfvrpObj/2Wefnb0dmXBlz1P+ggIvSrJ7v+9976tdN+EmiJNL/FyLBCTQtQgQKiLCRbTlynk/QLBEdFqR5T2DZen87Qgb7xflc+K5HdfEO0W0sVV9vDjLlb9JVWOKoGXa1X0+iLNKp1x5ZjGGcMg7JBWxO9r1LM+9StzmeSNUIzoWK/+nDRkypCZEhiAZFi9fhcfq5+eoBCSwagjgGDB69OjseHDhhRemE044YdWcyFk7jYBCZaeh98QSeCMBXvp32WWXXN+45fUeS2dmzZqVxY+iJRv5pEmTcsDx4otn7969s2cVy2jwsKrKYhrfcCtqVhF3rJkJFIVK4sxSygG3hw0blsfxfm5tYd5LLrkksdx7woQJWaQcP358+sQnPpE9qJmnEedhnhkzZmDSNttsk238wzUU7y/GtRKQQHMSQAyk8kVlewoe2EXhEiErKsJX1BDCos9KkGhjEcxCQCtmU6+6Jv4O8uVLVITLaGPLfcbwEkVMIx5hayznKFb+Ltbrs41rbm1FQIRbsVaNxXbez1hVU6xVY7E9OBbf66o4MgYb3uOqKj8TjIe4TBsP2qIQGW32sUhAAhJY3QlceumlOVwTqwxZacQX9JbmI6BQ2XzP1DtqUgKRPXT33XevvENerol3RUDyYlByMiYSnPy+++6rZTTlA0mx8IGAwP5xDmwx0D/fmtOPb8+xekMUCdruagSKQh4/75Rp06alY445pnYreClTEPlbW/igimcmCba+/OUv5yXZxMTkw2Ijz8P1xAfY2267LcfEbO01up8EJCCBIgFEv/j/vTi+Mu3FixfXPP7C8y/Et+gjyrFfiHMr6iOGEvoixD/a0S9b9uHvMe9GhPmIWq/POP8vtLYieMKttRVxNYRYRGXEweiHCBt93q+KnqjFdtk7lT7XYpGABCTQ7ARYdXjcccelqVOnZg/K8847z8+jTfzQFSqb+OF6a92LAC/XITTuvPPOLd48HwYIcB41Av2HRfBk6XkE+mcpGS/xxcLLcWQmLdqqQP+METME6zf2RYq2O4MAvyvh+cKHTGI/UljmXSyEXaAQL7K1hd8blqDgRUmG7r333juLnyz7HjlyZJ6mEedhoggWPmXKlDR27NjaJfIBPeJv1gZtSEACEuhAAohtVP7ft0hAAhKQgATaS4B39u9973v5XZdVRHxBXw7X1N65PW71JWAyndX32XhlElhtCCB6lIOpR4D/CLBeFeifZWLlglcBomUIl2VbFDVjW4xxrEUCK0vgkEMOSddcc03O8M3PFC87Y8aMSTfeeGO68sor06GHHppPcfTRR6drr702J77iZ7E1hWXkzPfAAw/kkAssjST0wuWXX54zEu67776tOs9WryXkIf4OXyaEJyahIfDUJMYcL2r8fm233XZ5n5NPPjkde+yxicyHeHBSzj///LzkvC0eoa25R/eRgAQkIAEJSEACEpDAqibAu/mJJ56Y38VJUnnaaafl8B+r+rzO3/kEFCo7/xl4BRJoWgJ4duGNGRUxk3bRFtvFbXh9lgvemCFaYqMWBc0YYxkbbSzLpiwSCAITJ07MAh59lmcj6BEO4fjjj88C5mGHHZaXVRMu4Yorrkg77LBDHLpCi1BJVnF+Jg844IAcl5Ljv/vd7+YlhSS7aOk8s2fPztsRSCl77bVXOuWUU3LmcZL64NmMEDpu3LhEGAiu8fDDD08zZ87MyQz22WefLHDi8UxcTMRWkiNYJCABCUhAAhKQgAQk0BUIPPTQQ+mkk05KkydPTgceeGB+jx44cGBXuHSvsUEEFCobBNJpJCCBxhIghlWViFkco12uJAAoF4TKEC0jDhc24m4W43FGm4DzluYlQFgD4nrxc1EseAjjDRnZu4vbWtPG+zhioyE64vlYFT9sZc9Tvhbi0pJAC1ESL0wSZVkkIAEJSEACEpCABCTQVQjwPnvuuefmhJSDBw9OF1xwQeJLeEv3I6BQ2f2euXcsgaYmEF6cIWDG0nQsY1hEquI4/bIHJ9lFQ7QMi/gTcUDLbQQvYh9ampPAOeeck4gz2VIhk+pNN93U0i5uk4AEJCABCUhAAhKQgAQKBGbMmJFjvF922WX5s9YZZ5yRY7z36NGjsJfN7kRAobI7PW3vVQISqEuAbKKRPCgsyYWijY1kQ3issUy9mGCI/0gRNBEwiQkYttyOPkKopesQuPvuu3NsyJauGM9dlqdYJCABCUhAAhKQgAQkIIH6BF588cVEWKOLL7443XrrrWnQoEE5JNNRRx2VevXqVf9At3QLAgqV3eIxe5MSkECjCeC5WRYvETJJnoKQiS22WcpeLP369cuCJsJlsSJwliueehYJSEACEpCABCQgAQlIQAJdlcDixYvTddddl2PAk9hy6dKladSoUTkhJAknXZ3WVZ9s469bobLxTJ1RAhKQwHIE8NgsCpchZBYtAieVhCvFwreKLDlHwIyl50UbS9MZo00il6q4iMU5bUtAAhKQgAQkIAEJSEACEliVBObMmZPFSRJF3nDDDWnRokVp+PDhORkkCSHL8eJX5bU4d9choFDZdZ6VVyoBCXQTAkuWLMmCJaIlXpohYEa76MnJWDmBEMvQI3lQiJjYYgKhYlIh2uxvHJhu8gPmbUpAAhKQgAQkIAEJSGAVEHj++efzUu6pU6emKVOmpPvuuy8RHmnvvffO3pMHH3xwXk22Ck7tlE1EQKGyiR6mtyIBCXRPAgibEUsT4TLaYSOBEP1IIkRcmGJhqQUZo0PgDPGSfrEyjsdmjNFea621ilPZloAEJCABCUhAAhKQgAS6AYG5c+em22+/PU2bNi0LlPfcc0965ZVX0tvf/vacsXvkyJFpr732Suuss043oOEtNoqAQmWjSDqPBCQggS5EgCznIWBiIyN6sV3MnB5tRNFy6dOnTxYuES1DxIx20RKXs9xX5CzTtC8BCUhAAhKQgAQkIIHVjwDekgiRd955Z6533HFHeuKJJ/KqrJ133jkNGzYsi5IjRozI4ahWvzvwiroKAYXKrvKkvE4JSEACqwEBPDHJeB7CJTb62HI7xhYuXJi/XS3fwnrrrZcQMEPEjHZLFs9PtmMVOstE7UtAAhKQgAQkIAEJSGDlCMyePTvdf//9afr06VmcvPfee9MjjzySXn311TRgwIA0ZMiQNHTo0Fz32GOPxDu9RQKNIqBQ2SiSziMBCUhAAnUJLFu2LMfSJFFQiJfRxpbbMRaWZERVpXfv3jXREuGyKGJGH0vm9Ko+4z179qya2jEJSEACEpCABCQgAQk0NQESe86YMaNWH3zwwSxQ4oxA2XLLLdOuu+5aqwiUb33rW5uaiTfX+QQUKjv/GXgFEpCABCSwAgIvv/xywisT4bJsY4zxqOUxEg6x3L2qEOA7RMwQNLFtrQqeVXQdk4AEJCABCUhAAhLoTAKsiHr00UezR+TDDz+cqDNnzkwPPfRQfrfm2ki8udNOO6Udd9wxx5ckxiSVd2SLBDqagEJlRxP3fBKQgAQk0CkEECoRMhEtQ9AstovbGK9XCRBeVQgSjrhJzE5qtMMWx8rtOCasAcerCDsmAQlIQAISkIAEJFAmwMqlOXPmpMcff7xWH3vssRSVbRRCJm211VZp4MCBadCgQWnw4MG57rDDDmnDDTcsT2tfAp1GQKGy09B7YglIQAIS6IoEXnrppboiJkHGETixxXaMhWUby9mJ81NVeJEk1k8Il9h6fcajxn7lPkvke/ToUXUqxyQgAQlIQAISkIAEVmMCfNn+1FNPpVmzZqUnn3wyW5LYFGusHOLLbpZrb7vttrlut9122W6//fZp6623NuTRavycvbT/J6BQ+f8sbElAAhKQgAQ6jADffrMUJ0TNEC+L/WgjakY7LGMxjmWuet6e3BRL3ItCJuJlCJrYYr9eO/aL7euuu25aY401OoyZJ5KABCQgAQlIQALNRIBYkE8//XStksSGijAZdt68eYn3Rgrvc5tvvnkWI/GORJSkIkJSiR/pu1kz/YR0z3tRqOyez927loAEJCCBJiSwaNGiLGiGiFkUMmMMoRNRM/rYYr/cjm/o6+FCrES4LNeiqFneRr94XLTDxva111673mkdl4AEJCABCUhAAqslAVbfPPPMM2nu3LmJZDVR6bMMu2gXL15cuwfef8iovdlmm6VNN900W9rULbbYIguUxJK0SKDZCShUNvsT9v4kIAEJSEACK0GAREZVYiaCZtTYHv2irdrGCzz7LF26tMUrYwl8iJZli6hZVWO/qm2M4YkQ22hTLRKQgAQkIAEJSKAeAUL3zJ8/Pz377LMJ70ba2GgjSkZljHefYunXr1/aZJNNahWvx2JFnKSauKZIzXZ3JqBQ2Z2fvvcuAQlIQAIS6EQCiKBFUTMEzLBsK7fpxxgepLFPjIdlnO314oDGbbM8KsTLsFWCZoyFuFnutzQe+xI3ylihQV4rAQlIQAIS6DgCLJ1GcFywYEGtsuyaPhYREhtt+lHLX6zyfz6ejSSgibrRRhulYt14441TVFeIdNxz9kzNQUChsjmeo3chAQlIQAISkEAFAZZUhXiJcNmWNvvGMUVLu1jZr7h0q+IyakM9e/bMwiiiZYib2Jb6sQ1bbre2j3eqRQISkIAEJNBVCfD/LEIjdeHChTVL+7nnnstjtKOPAMl4VMbLsbz5srJv376pf//+aYMNNljOMoYgWbQIk6zesEhAAquOgELlqmPrzBKQgAQkIAEJdBMCeGrwISoEzBA5o1+2sW/Y2F6vH+PYYl2Rx2jgx5MzhE5sr1696vbL2+K4GMdGxUsk5ouxliz7G+Q/nopWAhKQQPMSIMZ1hH/BFivxsukXEwTSRoSsZ5csWVIJiy/7WDLN8mpstOmvv/76eTza9Mt1zTXXrJzXQQlIoPMIKFR2HnvPLAEJSEACEpCABFaKAB/cQrhE7Iw2tqrPB8fiPu3pc0zUeh8cW7qptoqbIXwiiHJsubK9PBb9lraxT3m7H1hbenJuk4AEmoVA/B8RX5IVv1yjHZXt0cZGuJWipV1VCe9Sr+Dl36dPn1olAV/08XCkXbS0qYiQZctKBYsEJNBcBBQqm+t5ejcSkIAEJCABCUigQwmEaBmWD8C0Q0QNG9tbY2OOqn2Zr16N87bW07QMCs/TEDmrhEzEUj4UU/mgjWW/GCu2Y6xoi9s5vtgvz1U8LtrF/Tk+rqHY1mO1/FTtS2D1IECcw/Lfrvgbx3j8/SqO1ftbGOPYqBwX7eIXVVVtVgGsqPD3JmIsFxPVRbtoaVMRHKMdfcbKlS+JLBKQgATqEVCorEfGcQlIQAISkIAEJCCBLkkAoTI+9FcJA+WxYr+l49iG2ICnEMeE8ICNWtwWY1X7xTbm4ZiWvI/a8hDwCkXYLIqX5TbbEWVjvMq2djv7xb5V7Za2ca1xTNiqMbaVx+kXa+zTnjGOQeCtZ9vC331fJ4AQxu9hS5V4gbE92lWWsdZUfofYr8rG71jZsj+/i4yHLbbj9zTGol+05b8FVX3G2lP4uUbUo5bDbNCPGtujj434x8V2MTZyVRthMsRJzm2RgAQk0BkEFCo7g7rnlIAEJCABCUhAAhKQQIEAwk5R/Ih2iB7RDxvCCbbYZnt5rN52xkPYiWOqbL19GI9t0S72Y/7YVu7HeIhVBRyrVRMRsyUhMwTO2K9ouZFiP9pV48Ux2hT2L5Zyv7iNdtlTLvpVtjhGe0WV51TcJ/rx/NgWY+Xr6ow+AjxiWwjxxXaMhQ1xv2zZztiKang7V1nGWqohRLJPua1Y2Bk/OZ5TAhLobAIKlZ39BDy/BCQgAQlIQAISkIAEJPAGrzkErxAyizbGQxxjW7TDtnYs5ioKbIytTD+EPB5ntMO2daz4I8EcbS0hapYt8zAWtdyP8bItC7LRx7bUju1liwgXY9Gusoy1piIqsh+WeS0SkIAEJNA1CShUds3n5lVLQAISkIAEJCABCUhAAhKQgAQkIAEJSKCpCPhVU1M9Tm9GAhKQgAQkIAEJSEACEpCABCQgAQlIQAJdk4BCZdd8bl61BCQgAQlIQAISkIAEJCABCUhAAhKQgASaioBCZVM9Tm9GAhKQgAQkIAEJSEACEpCABCQgAQlIQAJdk4BCZdd8bl61BCQgAQlIQAISkIAEJCABCUhAAhKQgASaioBCZVM9Tm9GAhKQgAQkIAEJSEACEpCABCQgAQlIQAJdk4BCZdd8bl61BCQgAQlIQAISkIAEJCABCUhAAhKQgASaisBaTXU33owEJCABCUhAAhJYzQncdddd6ec//3ntKt/xjnekY445ptYvN+69997005/+tDY8ePDgdPzxx9f6q1tj0qRJ6Ytf/GL68Y9/nD7wgQ+0+fLGjh2bFi5cuMLjPve5z6VBgwatcL+27PDnP/85nXvuuemiiy5K22yzTVsOdV8JSEACEpCABCQggQYQUKhsAESnkIAEJCABCUhAAq0lsNtuu6X1118/vfe9701PPvlketOb3pQOPvjg9Ja3vKVyirPPPjv97ne/y9tOP/30dPjhh1fuVzW4bNmytMYaayy3qd74cju2Y+Dxxx9PTzzxRMK2pxx77LHplFNOSb/61a9S79690/e///3Uq1evPNULL7yQpk+fniZMmJD222+/hguVF198cbr++uvTb37zm3Taaae15/I9RgISkIAEJCABCUhgJQgoVK4EPA+VgAQkIAEJSEACbSWAcIi33ogRI9IvfvGLtGjRojRu3Lh05plnLjcVYl+IlGz89Kc/nfr377/cflUDr776atpnn33SlClTUo8ePWq7/OlPf0q33HJLOuuss2pjjWyMGTMmfehDH0pbbLFFu6bdbLPNshiLULnxxhtXepvicblkyZJ2ze9BEpCABCQgAQlIQAKrLwFjVK6+z8Yrk4AEJCABCUigiQn07ds3DRgwIN8hQuVLL7203N3+8Ic/TB/84Adr43369Km1V9T46le/mm666aaE92QUPB0//vGPp1deeSWGVoltr0gZF7Oi+0TU3XPPPWP3htktt9wyz7Wy19+wC3IiCUhAAhKQgAQk0M0IKFR2swfu7UpAAhKQgAQksPoQ+OxnP5v69euXnn322TfEoeQKn3/++fSTn/wkfeUrX6m84AULFuQ4kKNHj0577LFH+vznP59YGk1BpPzWt76V28S//NrXvpYee+yxNHz48PTMM8+kq6++Oh199NHpzjvvzPvMmzcvsaz8wAMPTB/72MfSddddl8f55+WXX06TJ0/OXpIInSeddFJedv3UU0/V9ik2Zs6cmc4444zEMuooLHH/+te/nvbff//00Y9+NM8R29pquT68Lh955JHEvR9xxBHpyiuvzNOcd955uc/YX/7ylzxGTFB4fPOb30zE+yS+5/vf//502WWXLXfqrbfeOo8pVC6HxgEJSEACEpCABCTQIQQUKjsEsyeRgAQkIAEJSEACyxPAczAS41xwwQVv8HS85JJL0tve9rY0dOjQ5Q98bQTB7vzzz0+XXnpp+tnPfpaXkZNghkLMy0g0w3Lxgw46KK233nq1cyFsfvKTn8zLs1le/u53vzttvvnmWdCbO3duFhQ5P+VTn/pUGjVqVBY3Dz300PTb3/42x3EMkTPv9L9/Jk6cmA477LD0jW98I8epjG0IimuuuWb64x//mD7zmc+kmDu217NLly7NiXVY6j1//vxa/EiWteNROWTIkPTrX/86PfDAA3mKU089Nb35zW/OYwimM2bMSCeccEJOkDN+/Ph05JFHphdffDHdc8896aijjqoJtXF+hcogoZWABCQgAQlIQAKdQ0ChsnO4e1YJSEACEpCABCSQCZAhm2Qx//jHP2qegQhxLPuu501JXMubb745C409e/ZMO+64Yxo4cGC6/fbb85zvete7EiIo8TBJ2kOfeI9kGKcgyDHOGOegfdxxx2Xxj6zXFDwsKb/85S9zPE3aiJZcJyIlYmi5sKw8PDljG16Yt956a1prrddDo48cObLVy7bxxNxpp51qlWXwsInCfRcL97vLLrvUhtgenpMkMLrjjjtyxnW8K5ln2rRptX1pwIV4nptuuukbxu1IQAISkIAEJCABCXQMgdffGDvmXJ5FAhKQgAQkIAEJSKBEYJNNNsnejSyV/s53vpM9Eq+99tq81yGHHJIWL15cOiLlTOEPPvhgzor9n//8J4txLIUu71uV8ZvJYpzl5STrYfk5y6IpxK/cdtttswck862zzjq1WJpcD56ReDLWK5GhO7azjBoBEOET4ZEs5iTKaU0h6RBL1qMgeiLItqWQVZ2CxyhZxCkhcLIMvlgQKKnF5EPF7bYlIAEJSEACEpCABFYtAT0qVy1fZ5eABCQgAQlIQAIrJIBXIwLg3/72t5wA58ILL0xf+tKX8li9gzfaaKMsbO611155WffgwYOX2zUEyfKGGH/44YfzJmJKcm4qy6IfffTRxDZESgrXRmmPgMe5WOqNIDthwoS0/fbbp2uuuSbP19Z/SHYzduzYtPbaa7f10DfsX+8+EFnD6/QNB9iRgAQkIAEJSEACEugQAgqVHYLZk0hAAhKQgAQkIIH6BIgnGUupSbBz//33J2JL1it4PRILkqQ3U6dOzUuyq8S7ECTL88T4uuuumzdVxZskC/m//vWv8qFt7nOtxNmcPn16zjiOByhLyLnu9hQSA1Xda3vmqjrmwx/+cNWwYxKQgAQkIAEJSEACHUBAobIDIHsKCUhAAhKQgAQkUCbAsmoSu0Q5+eSTc5OlzsSLjGXKxZiMy5Yty/tcddVVWaTcd999U//+/fMYc8V2BhAjEQnJ2h0lBMr//ve/eYgl3iTZueKKK7InZezHOUm2M2vWrBhqtyVZDx6jeIAS75JM5sxP5vF6Je65eD9V+0bcS5LtRIn7jTlivLWWJDsWCUhAAhKQgAQkIIHOIaBQ2TncPasEJCABCUhAAt2cAFmp8ZyMQubtYcOGZW9BMlVHmTNnTjRzFms6ffv2zWOXX355mjRpUs7Wfffdd6clS5bkmJPMO2DAgCxcIgyy9JoM2IxR/vCHP+Rl3uPGjUsk80HQHDFiRDrzzDMT2ceHDx+e40qSHZwyb968bEmks6KCxySlKHKSmZts4pQDDjgg2/e85z3ZVv0T+zIHcTTrFZiRNAgBlHv80Y9+lM4555y8++TJk3Pm8ZirKGYS65Ly73//O9v456KLLkok3eFYiwQkIAEJSEACEpBAxxPo8doL6Zkdf1rPKAEJSEACEpCABLongdtuuy0dccQROUP33//+93T99den/fbbL4uPG264YY4DeeSRR2Y4P/jBD9KYMWNqghr74inI9rvuuisvp77llluywHnQQQelG264IQuSeAUiZpIo5/e//31OjjN69Oi0wQYbZGGTxDnMRbzHj3zkI+npp59Of/3rX3Mm8SlTpqT9998/Z+8mliOZvBE2OS9Zslkuvttuu1U+vPHjx6ezzjorLViwIP3zn/9Mzz33XNp9991zbMqJEyfm2JcIiqNGjUonnnhiLalPcTJic377299OZDbHoxLvUbKTk/27XMh4Trnxxhtz3Euu8Qtf+EJm+853vjN7i5566qn5/rhHvE7xVEUI5tqIxYmn56677prn4Rpvfi2b+p577pk43iIBCUhAAhKQgAQk0LEE1njtBfD1NUQde17PJgEJSEACEpCABCSwkgTwXgzvSqYq9+fPn58T4cTycPZBzMOjkMQ0kSSH8RdeeCELdywHx0uxUYXzsRwbr83Zs2cnMnkXz9uI8+B1yTnwhsTyehsiZlvm51rx4txqq63acpj7SkACEpCABCQgAQk0iIBCZYNAOo0EJCABCUhAAhKQgAQkIAEJSEACEpCABCTQfgLGqGw/O4+UgAQkIAEJSEACEpCABCQgAQlIQAISkIAEGkRAobJBIJ1GAhKQgAQkIAEJSEACEpCABCQgAQlIQAISaD8Bhcr2s/NICUhAAhKQgAQkIAEJSEACEpCABCQgAQlIoEEEFCobBNJpJCABCUhAAhKQgAQkIAEJSEACEpCABCQggfYTUKhsPzuPlIAEJCABCUhAAhKQgAQkIAEJSEACEpCABBpEQKGyQSCdRgISkIAEJCABCUhAAhKQgAQkIAEJSEACEmg/AYXK9rPzSAlIQAISkIAEJCABCUhAAhKQgAQkIAEJSKBBBBQqGwTSaSQgAQlIQAISkIAEJCABCUhAAhKQgAQkIIH2E1CobD87j5SABCQgAQlIQAISkIAEJCABCUhAAhKQgAQaREChskEgnUYCEpCABCQgAQlIQAISkIAEJCABCUhAAhJoPwGFyvaz80gJSEACEpCABCQgAQlIQAISkIAEJCABCUigQQQUKhsE0mkkIAEJSEACEpCABCQgAQlIQAISkIAEJCCB9hP4P0W0brkbhZCpAAAAAElFTkSuQmCC\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "transitions = [\n", " { 'trigger': 'melt', 'source': 'solid', 'dest': 'liquid' },\n", " { 'trigger': 'evaporate', 'source': 'liquid', 'dest': 'gas', 'conditions':'is_valid' },\n", " { 'trigger': 'sublimate', 'source': 'solid', 'dest': 'gas', 'unless':'is_not_valid' },\n", " { 'trigger': 'ionize', 'source': 'gas', 'dest': 'plasma', \n", " 'conditions':['is_valid','is_also_valid'] }\n", "]\n", "states=['solid', 'liquid', {'name': 'gas', 'on_exit': ['resume', 'notify']},\n", " {'name': 'plasma', 'on_enter': 'alert', 'on_exit': 'resume'}]\n", "\n", "model = Matter()\n", "machine = GraphMachine(model=model, states=states, transitions=transitions, \n", " show_auto_transitions=True, **extra_args)\n", "model.show_graph()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Hide auto transitions" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "hide_input": false }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "machine.auto_transitions_markup = False # hide auto transitions\n", "model.show_graph(force_new=True) # rerender graph" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Previous state and transition notation" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "hide_input": false }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "model.melt()\n", "model.show_graph()" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "model.evaporate()\n", "model.show_graph()" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "model.ionize()\n", "model.show_graph()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### One Machine and multiple models" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# multimodel test\n", "model1 = Matter()\n", "model2 = Matter()\n", "machine = GraphMachine(model=[model1, model2], states=states, transitions=transitions, **extra_args)\n", "model1.melt()\n", "model1.show_graph()" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "model2.sublimate()\n", "model2.show_graph()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Show only the current region of interest" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# show only region of interest which is previous state, active state and all reachable states\n", "model2.show_graph(show_roi=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Example graph from Readme.md" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "hide_input": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAACXsAAAI5CAYAAAD6hXu0AAAAAXNSR0IArs4c6QAAQABJREFUeAHs3QmcjeX///GPnaxlSdmiiOwJ2bNEtopCkWQnUWlRSaS+iQp9EdnSguxL9t3Ysq8hZC2J7Pv+7319f/f8xzSYGWfMOWde1+Nxz33Ofe77uq/reabMuc7n+lzxrv5TjIIAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIODPAiHx/bl1tA0BBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQOB/AgR78ZuAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCASAAMFeAfAm0UQEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAICEECCCAAAIIIIAAArdf4Pz587Zo0SJbs2aN7dy5044fP26XL1++/Q0J8DsmTJjQUqdObffff78VKVLESpUqZYkTJw7wXtF8BBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBCIWiHf1nxLxSxxFAAEEEEAAAQQQ8LXAypUrrW/fvjZu3Dg7ffq0Zc6c2XLmzGlp0qQxBS5RoiZw6dIlO3r0qG3bts32799vKVOmtLp169orr7xihQoVilplnI0AAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIICAfwuEEOzl328QrUMAAQQQQACBIBH47bffrH379jZ58mQrXLiwNWvWzJ588kkX7BUkXYz1buzZs8cmTZpkgwYNsl9++cVq165tPXv2tKxZs8Z622gAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAj4QCInvg0qoAgEEEEAAAQQQQOAGAv369bP8+fPbrl27bPr06W7pxpdffplArxuYReelbNmyWbt27Wzjxo02ceJEF/CVN29eGzx4cHSq4xoEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEE/E6AYC+/e0toEAIIIIAAAggEi8DFixetYcOGLgDp7bffttWrV9sTTzwRLN3z634oa9q6devcco4tWrQwbZcvX/brNtM4BBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBG4mQLDXzYR4HQEEEEAAAQQQiIbA+fPn3TKNWlZQ2by6dOliiRIlikZNXBJdgSRJkli3bt3c0o7Dhw+3Z5991i5duhTd6rgOAQQQQAABBBBAAAEEEEAAAQQQuGWByZMn23333WezZs2KVF1RPT9SlXISAggggAACCCCAQEALEOwV0G8fjUcAAQQQQAABfxS4cuWK1a9f337++WebP3++Va5c2R+bGWfaVLNmTZs9e7bNmTPHGjduHGf6TUcRQAABBBBAAAEEEEAAAQQQQMD/BHbt2mV79uwx7SNTonp+ZOrkHAQQQAABBBBAAIHAFoh39Z8S2F2g9QgggAACCCCAgH8JKIuXMkrNnTvXSpcu7V+Ni8OtUcBXtWrV7JNPPrG33norDkvQdQQQQAABBBBAAAEEEEAAAQQQiE2BvXv3WtasWSPdhKieH+mKOREBBBBAAAEEEEAgEAVCCPYKxLeNNiOAAAIIIICA3wosW7bMBXj17dvXWrdu7bftjKsN+/zzz+3dd9+1lStXWqFCheIqA/1GAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBAITAGCvQLzfaPVCCCAAAIIIOCPApcvX7aCBQta5syZbcaMGf7YxDjfJiW1LVeunJ09e9ZWrFhh8eLFi/MmACCAAAIIIIAAAggggAACCCAQ7AJr1661UaNG2b333mv33Xef/fjjj7Z7926rUaOGdejQwRIkSGCXLl1y4zlDhgyx3r17W58+fWzTpk02ePBgN9bz888/2w8//GBbt261LFmy2BNPPGH16tVzdDt37nT1qA6NNTz33HNWt25dd64ywJ8/f95atmzprtH1w4cPd5m9mjdv7q7ft2+fu4/GKlKkSGHZsmUzTVhTieh8HT937pxpsqHapXGOAgUKWNu2bV0f9fqxY8dsypQpNn78ePvyyy9t4sSJ9tNPP7m+KOt5xowZdRoFAQQQQAABBBBAIPAEQhIGXptpMQIIIIAAAggg4J8CGvD79ddfbcKECf7ZQFrlBlw1EFq4cGEbN26cPfvss6gggAACCCCAAAIIIIAAAggggEAQCyxcuNDat29va9assTvvvNMFUj388MMuiEoZ2n///Xf76quvrFGjRjZixAgnoWUTDx8+bHv27HHZwRUk9dprr9mAAQPsrbfecucroEtjC6NHj7YcOXLYiy++aE8++aSrXwFWKrlz53bBVb/99psL9FL9n376qW3cuNE6duzoztGPBg0aWMWKFW369Ok2c+ZMe/75512w1/XOP3LkiD322GOWPn16F5h24sQJq1+/vmufArxKlSrl2titWzc7deqUbdmyxfLmzWunT5+2b775xg4dOuQCv0IbwAMEEEAAAQQQQACBgBKIH1CtpbEIIIAAAggggIAfC3zxxRf2wgsvWM6cOf24lTRNM12feeaZ0BmyiCCAAAIIIIAAAggggAACCCCAQPAKKMN3z549XQcfeughF/Sl7F3KiJU0aVIbOHCgC/hSti2dq6LAL2XrWrlypeXLl88Fi2nMp3Hjxi6Yq3v37la2bFkbM2aMDRs2zF1Ts2ZNF7ClADFl6PLKvHnzXNYvPVdAlq4NW3T+okWLLGHC/+VnqFKlipUsWdKdEtH5ekHZyJR1TIFb+fPnd8FdaoeyeamNFy5csPfee8+efvppV88777xjY8eOtSVLlliGDBksJCTEHecHAggggAACCCCAQGAKEOwVmO8brUYAAQQQQAABPxPQ4J9mZb788st+1jKaE5GA3qfly5fb5s2bI3qZYwgggAACCCCAAAIIIIAAAgggEEQCyZMnd73RBDAts6iSK1cut9Ti5cuXXeCUjmmZRxUFScWPH98eeeQRmzx5slsy8dFHH3WveT+0jKOKl8VLj1955RXt7Ouvv3Z7ZRO7cuWKhb02SZIk7jXvR9asWS179uz2/vvvW6tWrezgwYM2cuRI72ULf/7Vq1fdkpT33HOPWwrSO7FMmTKmfm7fvj20P8mSJXMvK8OYVxTwpkxgWlqSggACCCCAAAIIIBCYAgR7Beb7RqsRQAABBBBAwM8ElCI/W7ZsVrRoUT9rGc2JSECzbzWTVcswUBBAAAEEEEAAAQQQQAABBBBAIG4KaPlFFWXEUlGAl0qCBAncXj927NjhHnuveS+ULl3aPdy2bZt3yJTdK0uWLPbjjz/a8ePHbdCgQdayZcvQ1yN6oOCzoUOHWsaMGV2QmDLGT5o0KaJT3TEFg508eTK0rd6JygxWvHhx9zRsm7zXvX3YvnnH2COAAAIIIIAAAggElgDBXoH1ftFaBBBAAAEEEPBTgaVLl1r58uX9tHU0K7yABmi1NMOyZcvCv8RzBBBAAAEEEEAAAQQQQAABBBCIIwJbtmxxPVWA1fVK+vTp3UuLFy++5pRMmTK553fffXfocQVSKTvXmTNn3PKQygrWoEGD0NcjeqDMYsr8tX79erfMo7JuaRlJLf8YUbnzzjvdko+///67aQnIsCWiNoV9nccIIIAAAggggAACwSFAsFdwvI/0AgEEEEAAAQRiWWDr1q2WL1++WG4Ft4+KgN4vb1A3KtdxLgIIIIAAAggggAACCCCAAAIIBIfAggUL3FKI+fPnv26HvGxZISEh15yzatUq97xkyZLXHG/WrJklTpzY3n77batataqlSpXqmtfDP9m1a5e98cYbLgP58OHDbciQIW7px4kTJ4Y/1T1X3YUKFXKPI2qTlm70Xo+wAg4igAACCCCAAAIIBLwAwV4B/xbSAQQQQAABBBDwB4HDhw9bunTp/KEptCGSApqZe+TIkUiezWkIIIAAAggggAACCCCAAAIIIBDoAsqWderUKdeNMWPG2F9//WUff/yxC87SwUOHDrnXdu7c6fb6Ub16datUqZLp2Pjx40OPz5gxw40FKagrbMmQIYPVqVPHHYpoCUdl7lLZu3ev2+vHqFGj7MCBA+657qdSqlQpt4/o/J49e5qWf+zTp4+dO3fOnacsX5qM+O6775qyf6l4dWpJSa942cA0lkVBAAEEEEAAAQQQCEwBgr0C832j1QgggAACCCDgZwIaWEuaNKmftYrm3EggSZIkoQOiNzqP1xBAAAEEEEAAAQQQQAABBBBAIDgEtLxiwYIFTdm4Wrdubf3797eGDRu6TFrPP/+8zZ8/33W0adOmLsOW12sFhj333HP2wgsv2EsvveSWW1yxYoUps5YXWOWdq32bNm2scOHCVrRo0bCHrV+/fi6Llw5OmjTJOnTo4F7XUo5qU9u2bV39r7/+utWtW/e655cpU8Zdv3v3bitRooS1b9/eBaR17tzZOnbs6Ors0aOHzZkzxz1WQJraq+CzHTt2uGNaXpKAL0fBDwQQQAABBBBAIOAE4l39pwRcq2kwAggggAACCCDgZwLx48e3kSNHWr169fysZTdujv4UrFixoinF/9SpU2988v+9OnnyZGvXrp0NHDjQKleuHKlrYuoktX/27Nk2c+ZMN8i5fft2N7M1MvcbOnSovfrqq3by5MnInM45CCCAAAIIIIAAAggggAACCCAQoAJaclGBVwrw+vTTT13GqwceeMA0nhOVouCoTZs2uaUfs2fPfsNL//7770hlgb9y5YpdunTJFPD1xx9/WI4cOSLdLl2zZcsWN7ZRoEABS548+Q3bxIsIIIAAAggggAACQSEQkjAoukEnEEAAAQQQQAABBKIloAHFjRs3uuUK9Dgyg5y7du0ypfzXPraL2qxlD4YNG2ZakkBLGFAQQAABBBBAAAEEEEAAAQQQQACB6wmkSpXKtEWnpE2b1sqVKxepS9OlSxep8zQWkzhxYneuAtCiUhIkSGD58uWLyiWciwACCCCAAAIIIBAEAgR7BcGbSBcQQAABBBBAAIHoCmhQUNmwNLAYmUAv3UfZsGrVquVmsUb3vr66Tu1v1qyZffPNN6ZZuhQEEEAAAQQQCDyB06dP26lTp0zLKoXdtEy2tvPnz7tNjy9cuGAXL150e2XA0GPtvU3ZLcJuCgzXc2UD1WNt3mPtw26S0/Owe/eEHwgggAACCCAQ8AIHDhxwfdDSicq4RUEAAQSCTcCbBKv99TaNpYbdNB4c9nmiRIksoi1hwoSWJEmSa7akSZOGPtfjO+64w60eob02HaMggAACCMScAMFeMWdLzQgggAACCCCAQEAIpEmTJsrtzJo1a5SvickLohKsFpPtoG4EEEAAAQTisoCCqvRF6p9//mn79++3Q4cOhW76UvXo0aOhmzJynjhxwgV5KQDrRkVfVHhfLCjrhbawX0DoiwdvC/tFhffFhfd3grf3vvjQcxXvufbec/fg/17zHrNHAAEEEEAAgcAU0N8n69atc43/66+/bOXKlZY/f34CEQLz7aTVCCBwHQFvYos3oUWneY+11+v6zObtvUky3vOwk2k0qSb8pok3moCj45Ep+nyVLFkyF/iVIkUKS5kypYXd67GyLKZOnTp00zi19/zOO+80ZVPUXp/zKAgggAAC1woQ7HWtB88QQAABBBBAAIEYF9AXm5MnT7YxY8ZYz5497fvvv7fZs2fbvffea506dbICBQq4NmipxO+++84NPupYr169rGrVqi6zlj5Y9+3b137++Wc7e/asu6Zt27auDl3crVs3W7FihatHH5r79evnPkx7x/WhWUsf6tqpU6fa8OHDbezYsaEfnMePH+/ad+zYMcuRI4c9+eSTVqVKFVff1q1b3fkK+GrevLk7ph9qyw8//GB6PUuWLPbEE09YvXr1Ql9fvXq1jRs3zrWjWrVq9vXXX9uvv/5qjRs3toYNG4aepy+Gv/zySzcQq0GARo0aubpCT/jnwYIFC2zw4MFuKcnChQu7WbneF7Rhz+MxAggggAACCPhWQIFcygq6Y8cOt2lZZy2prL9b9Jq+KPCK/h1Pnz6927SMkQbp77vvPrfX3yL6G0XneIP+yZMnd18EhJ0JriAvb1kjr172CCCAAAIIIIBAVAQ0hqItbInOxLew1/MYAQQQiKsCChzzsi97e/0/1svSrPFm77G3VybnkydPusk+3uPDhw+7sV1NBNKmcWidE/YzpYw15qvPjgr8uuuuu9xenzMzZMjgtrCPM2bMaNr4DBlXfzvpNwJxS4Bgr7j1ftNbBBBAAAEEEPADAQV0DRw40A00bty40R599FGXjULBVtOnTzcd0xenL730ku3bt89y587tlirSY81GVWDUY4895r447d27t8uKUb9+fRswYIBNmTLFSpUqZW+//baVLFnSBXxpiUPNlFJ55ZVX3OyoNWvWuEwbb775po0YMcItfaQP6irLli1zQVzbtm0zfelao0YN27x5swv20rmffvqpa2PHjh3d+frRv39/e+2111wb3nrrLfvqq6/sueeec8Fdo0ePdtcrGE11K6ht5MiRpiCttWvX2sKFC10fixYt6vr9+OOPm+pQQJjuoQC3IUOGWJMmTdz9FBzXpk0bV0eFChXss88+cwFm+mI4rpcuXbq4wEH9rlSqVMkGDRoUGsAXkY3e84oVK7pZdgr602DLhAkT3O/RrFmzXPaViK7jGAIIIIBA8AtoacX169eb/mZQJgz9LbBlyxY3AK/e69/d+++/3wWFFylSxGrXru2WeL7nnnvcv/XaaxY3BQEEEEAAAQQQiG0BLSXGcmKx/S5wfwQQCBYBBV/F1P9XNVapgC8Ffx05ciR0U2CYnmuvTZOFNXat/cGDB02fX8MWBYbpM6m3ZcqUyTJnzuwmKHt7TUiiIIAAAoEsEO+f/2n+71u9QO4FbUcAAQQQQAABBGJZQMsAKYApbCarGzWpfPnyLjvVzJkzrXLlyu7Upk2b2tChQ61ly5YuaErZq3SegqN+++03l71KJ3744Ycu+Gn37t3uS1Udmz9/vinwKWfOnLZp0yY3e2nx4sVWpkwZFyw1bdo0neYyiikQa8aMGe65fhQvXtwFhSkFt5ZAat26tcvypawdmumqepYsWWIdOnRw1yggzQvE+vjjj13b8uXLZwo4U1CWV8qVK2chISGmYDMFrqkPDzzwgOXNm9eWL1/uAskUJPbyyy+7DGevv/66+6JYM7SUtUtF2cJKlCjhPphrOSh9mNcXy7q/As9UNFtMM7aUajz8B3t3wnV+yPrVV191AwjXOSWgDivzmwLhFDz3xhtvuEAvBQ7qvbleUbp2b7abF0yo35X27ds7Fz4qXE+O4wgggEBwCWi2tZYz0r/PCsTWpr8DNKNa2bgKFSrk/v1+6KGHLE+ePJYrV67QbKLBJUFvEEAAAQQQQAABBBBAAAEEAk1An2kV+KVs0xFtf/zxh5tUrYAxryhgTatTZM+e3e77JwN12E0rXdx9993eqewRQAABfxQIIbOXP74ttAkBBBBAAAEEgl5AGbNU9OWpV95//30X7KXsGSoK8lLR8on68KlZRwq+GTVqlAt+0jKKXlFQl+rUF7MK9nr44YetdOnSVrBgQVNAmZZWypYtmwuiatWqlXeZ22t5pLBFmcaUJUyZt7ScYs2aNa9pZ/jzJ06c6LKU6bqwRcs4KthLS0Iq2MvL7qEP0V7/9aWximZgadaWskopwMwzUDCSgrsUTKd04Aqo08wuBcF5RfXmz58/9BrveFzba1lPZUXTUlgKolNwnuxuVBIkSOB+Z+SrTb9zzZo1c5nn9KU/BQEEEEAgOAUUPK1/oxVYroBuZfBS0LRmPetviLp167q/A/S3gAa8KQgggAACCCCAAAIIIIAAAgj4q4AyT2vsW9uNiiYNa8Lr77//7vZ79+41TajWmPrs2bPdcU2IVtHSkZropMnV2sI+1qQoCgIIIBDbAgR7xfY7wP0RQAABBBBAAIH/E9CHUQXcHDt2zB3RYxUF5HjFC4pKnTq1d8jtlZFLGbrmzZvnUljri1oVLXfYokULl+VJGbT0Za6WZbxRUXYyffk7bNgwe+qpp1zmsR9++CF0Kcjw1+7YscMd8trrva5gMxWl1L5eCds37zwtc6nMUhEVLSGlotlVYYvSh2uLq0WBcBqY0O+BilxvFujlWSm4Lnzx6gl/nOcIIIAAAoEpcP78eRfcpQDwOXPm2IYNG9y/mwo617/XWtZZyz+HDSQPzJ7SagQQQAABBBBAAAEEEEAAAQQiFtCkYQVtaYuoaOKxsoBphQqNVSsITPvRo0fbzp077cKFC+4yLQHpBX9prwnNWl1BY9bhx8gjug/HEEAAAV8IEOzlC0XqQAABBBBAAAEEfCCgD45aLkkzha5XNGtIgTiafeRl6/LOzZQpk3sYNsV0gwYN7O2333YZw3Rdo0aNQgOCvOvC75XZQ0svKjOXlgOcNWuW1alTxwWAhT9Xz9OnT+8Oa7lHLUXplYja470W0V4zsFQiyiilVNzK/OV9oFYWkooVK0ZUTZw79sUXX9iyZcvc787cuXOtSZMmpgGHHj162NGjR23MmDFuaUf9fhUrVsy6d+8eGrin2WxTp0614cOHu6U7wwbfxTlIOowAAggEmYCWP/7pp5/cEs4K4ta/pRqA1vLRXbt2tbJly7psmkHWbbqDAAIIIIAAAggggAACCCCAQLQENDaqSVDawq4socoUCKbxeC8IzAsEU9ZsTcLVihwa39bnbq1CoeAvb68s2hQEEEDA1wIEe/lalPoQQAABBBBAAIFoCsyfP99dWb169evWkDhxYrek4qpVq1yGjoYNG4aeq2OanRR2aUh9wHzppZesd+/e7otdffC8WVE2MAUEKcOXlgVUUNXChQvtyJEjdtddd/3rcmUUU9EH27BF7VFRppDIFGWiSpEihQtOUoCalo5SUQDciy++6JYlLFCggDumtNoffPCBe6wfClDTeXGxaJlNLY05btw4l82rdevW5i21+fzzz7tZZ7/88oubiVaiRAkXNPfdd9/ZoUOHXCaXESNGOD8NSFAQQAABBAJbQDONNeNYyyIreFp/Byi4S8sya1lo/XtBQQABBBBAAAEEEEAAAQQQQACBqAkoEEyZu7RpknTYcvr0adP466ZNm2zjxo1uP23aNPvrr7/caWnTpg0N/lIAmMbvtddYPgUBBBCIrsD/1gaK7tVchwACCCCAAAIIIHBLApMnT3bX6wOhlk3MnTt3aHYsBeOo6IvbsKVnz55u6aU+ffqYlu9T0ayirVu32rvvvmvK/hW2KPhHSxxWrVo1wuWZTpw44U7fu3ev22uWUt++fd1jBXcpmCtv3ryh2T/Cn6/gtEqVKrl2jh8/PvTWM2bMcBmmFLilcuDAAbc/fvy42+uH2q2iQDIFsrVr187NkipXrpx16dLF1NcyZcpY9uzZrWjRota4cWPLkCGDKYuY6tUSkgpc+vnnn13GEmW58j5Eu4rjwA+lCtdMMRVlU5OTguKUtUuZXDQTLVGiRG5Wmc5VFjAVZWT79ttvzVvy0x3kBwIIIIBAwAko2+dnn31mjzzyiAv61b+F+ndAf2P8/fffpn+bmzVrRqBXwL2zNBgBBBBAAAEEEEAAAQQQQCAQBJInT+5WVNCKC7169TJNVNZYuMb3582bZ507d3bLPq5evdpNvtV4e8qUKd2YriZz6xpNpD516lQgdJc2IoCAnwiQ2ctP3giagQACCCCAAAJxU0ABW4MGDTIttaSAJgXnKDBHyy55QVLKqqVlFL/66isXoKPgp0mTJrmgMGVqUkppna8PjR07dvwXpAJ8lKGrZcuW17ym4K727dvbhg0b3HEt+aggL2V4Urs2b97sAsf+/PNPGzhwoMWPH9/69evnArB0gdrQoUMHlwVMSwUqqOyFF16wunXruuUWVa8+pCr4TAFrrVq1cvdZvny569vTTz9tnTp1csdGjRrlgsoU4KVgLS0j+eGHH7ogtebNm7usZDpRH4L1YVlZx/TFtoLBFGimIDllL1EbkyZN6uqM6z80M0wzyjTYoAC977//3mX38gIEPR8vC5j3nD0CCCCAgP8LaABYGR0V8Ky/HdKkSWO1atWyTz75xCpUqHDTJZv9v4e0EAEEEEAAAQQQQAABBBBAAIHAFkiXLp0buw+7JKTG3jWBee3ataFbt27dXGCYxrY1lq/JXNqKFSvmVr9gvDuwfw9oPQIxJRDvn/+hsF5LTOlSLwIIIIAAAgjEGQF9EBs5cqQLQopMp2vUqGFTp041BVKdOXPGUqdObUrnHJWiDFxbtmxxy/Ipg4eCeq5XlDlLQVfK8HWzomAgfYBUAJqybelDaWTL4cOHXZpqZZNS8Fp0i77E1odeLe2oAK+IitqnPsvu4MGDLuNXROdd79jQoUPt1VdfdX7XOydQjiswT9nXWrRoYV9//XVos0+ePOkypM2dO9def/1169+/v61bty40I5xOLFu2rC1atMguXrwYGhygpTeVAYyPCqGUPEAAAQT8QkD/b1aQuJZq1P+3lV1TSx1Xq1bN/ZvtF42kEQgggAACCCCAAAIIIIAAAgggECUBTcxW5i9tq1atcpvG2hMmTOiyd2s1B2UEe/TRR93E58iM80epAZyMAAKBJhBCZq9Ae8toLwIIIIAAAggElYCCxHLkyBGtPiVIkCB0+b6bVaDlGCNbvJlC9957b2QvCT1PAWtagvFWS4oUKaxQoUI3rCZs+7S0Y3TKpUuXXFY0zZK6++67o1OF316jYEBlWdNAgYK59DswZMgQv20vDUMAAQQQiFhAyx9r2V1l2VTGxoIFC9qnn35q9evXd/9vj/gqjiKAAAIIIIAAAggggAACCCCAQKAIaPK0NmXt9spvv/1mK1assJUrV7q9snufPXvWTX72Ar8U/KVNE70pCCAQtwQI9opb7ze9RQABBBBAAIEYElCAVPjl8W50K83KUfnjjz+inJHqRvXyWuQFzp8/7zJXPfXUU26vD9MK+vK2IkWKmILOAqF4Gbi8vdo8fvx4mzFjhste5gX7nT59mmxdgfCG0kYEEEDgH4FNmza55ZO1DK+Kgru0zLFm81IQQAABBBBAAAEEEEAAAQQQQCC4BbTqhbbnn3/edVQZvjds2GA///yz20aMGGFdu3Z1q3nkyZPHtFpDiRIl3P7BBx+M1CofwS1I7xAIbgGCvYL7/aV3CCCAAAIIIHCbBJTR6tChQze9m7ItNW3a1KVh1snNmjWzdu3aWaNGjW56LSf4VkDvV7Zs2Wz58uWhs6M0U6pnz5524MABU+a0/Pnzuw/H3gfl6GZh823L/13btm3b3MGdO3eGvpgqVSr3+Mcff7QKFSq4AYA1a9a4YxMmTLAHHnjA9e/EiRPumDKAef3TEpkqMkqfPr17zA8EEEAAgZgXUNCulnnWv0Xz58+3XLly2SeffOL+TtCyxRQEEEAAAQQQQAABBBBAAAEEEIibAokSJTJNUNbWpk0bh6Dx22XLltnSpUvdfvjw4S77l76v0Jh2qVKl3KaJY0mSJImbcPQagSAViPfPQOLVIO0b3UIAAQQQQAABBG6bQOXKlS1Tpkwu48bNbnrs2LFrTlFWMG/pxGte4EmMCmiJwwsXLtjEiRP/dZ99+/a5IDB9SNa2du1ad27GjBlDZ0eVLVvWHn74YUuYMHbnT/Tt29cFBezatcsSJ05sDRs2tLffftsFcz355JM2ffp0u+eee9wAQPLkye311193y3/279/fXacMYPpIoHTfH3zwgen4Tz/95EzURwUcaACBggACCCAQcwJahkFLNfbu3dsUwFulShX3/+vHH3+cmbgxx07NCCCAAAIIIIAAAggggAACCASVgLJ/rVu3zpYsWRK6/fnnny7Q65FHHrHSpUtbmTJlXCAYSz8G1VtPZ+KeQAjBXnHvTafHCCCAAAIIIBADAp07d3Zf0u7evTsGaqdKXwtcuXLFBUC98cYbLjDqZvVric7Vq1e7wC8vAOzgwYOm4CnNkFJQlD4kFy9e3O8C95S5y8vypX6Gf36zvvM6AggggEDMCSgA/KuvvrIvv/zS/f/5hRdecEFeDz30UMzdlJoRQAABBBBAAAEEEEAAAQQQQCDOCGg1iMWLF4duW7dudX3Ply+fG9PWuLY2TWanIIBAwAgQ7BUwbxUNRQABBBBAAAG/Fli5cqUVK1bMtAygUiJT/FtgwYIFVr58efvll18sul+o60NxSEhI6KZsYEqFrd8DLZuoTdmylG2LggACCCCAQFgBLRfcq1cvl00xfvz4Lvviq6++ahkyZAh7Go8RQAABBBBAAAEEEEAAAQQQQAABnwocPnzYBX4tWrTItK1Zs8YuXbpkOXLkcEFfmtis7YEHHvDpfakMAQR8KkCwl085qQwBBBBAAAEE4rRAgQIF3HJ333zzTZx2CITOawnHvXv32s8//+yz5iqrm4K/Fi5caPPmzTM9v+OOO6xUqVKhwV9aDjFBggQ+uycVIYAAAggElsD+/futR48eNnDgQEudOrXL4tWqVatrMjAGVo9oLQIIIIAAAggggAACCCCAAAIIBLLA6dOn3Ti5xrYV/KUx87Nnz7qVMbzAL+3z5s1r8eLFC+Su0nYEgkmAYK9gejfpCwIIIIAAAgjErsC3335rzZo1s82bN1vOnDljtzHc/boCGzdutIIFC9ro0aPt2Wefve55t/rCrl27bO7cuS7wa/78+aYsLmnSpLGKFStalSpVrHLlypYtW7ZbvQ3XI4AAAggEgMAff/xhn376qQ0aNMjSpUtnHTp0sObNm/vd0r8BQEkTEUAAAQQQQAABBBBAAAEEEEAgBgUuXLhgq1atCl3RYsmSJXbixAlLmzaty/xVrlw506YxdmUrpyCAQKwIEOwVK+zcFAEEEEAAAQSCUuDy5ctWqFAht7b9jBkzgrKPgd6pq1evug+impmkJTdv50wkBQHOnj3bZs6c6bJ/nTlzxh588MHQwC8tK6lMYBQEEEAAgeAR+Ouvv6xbt242YMAAt0TjO++8Y02bNnXL/gZPL+kJAggggAACCCCAAAIIIIAAAggEq4C+91i3bl3oqhbK/nXkyBGXsbx06dJuvF3BXw8//LAlTJgwWBnoFwL+JkCwl7+9I7QHAQQQQAABBAJbYNmyZaYPOH379rXWrVsHdmeCsPWff/65vfvuu7Zy5UoXmBdbXTx//rwtXrzYZs2a5YK/NmzY4L74V8BXjRo1rHr16mT9iq03h/sigAACPhDQoKeWa+zTp48b/HzvvfesRYsWljhxYh/UThUIIIAAAggggAACCCCAAAIIIIBA7AhoQvWmTZvchOaFCxe6ILCDBw9aihQprFSpUqYlHxX8VbRoUcZBYuct4q5xQ4Bgr7jxPtNLBBBAAAEEELidAl26dHFZPLSEnwK/KP4hoKxa1apVs08++cTeeust/2jU/7VCSzxOmzbNpk6d6rJ/nTx50vLmzesCvxT8VbJkSVJi+9U7RmMQQACBiAWUtbFXr1722WefWaJEiUyZvF5++WVLlixZxBdwFAEEEEAAAQQQQAABBBBAAAEEEAhwga1bt4YGfykAbP/+/W4spESJEi7wSwFgjz76qCVNmjTAe0rzEfAbAYK9/OatoCEIIIAAAgggEDQCV65csTp16ti8efNszpw5VqRIkaDpW6B2ZOnSpW65xKefftq+//57v+7GhQsX3GwoBX5p2759u6VPn96efPJJq1WrllWsWJEPxX79DtI4BBCIiwKXLl2yQYMGWdeuXe306dP25ptvWvv27d2s1rjoQZ8RQAABBBBAAAEEEEAAAQQQQCDuCuzYsSN02UcFf+3Zs8etbFGsWLHQZR8VCJY8efK4i0TPEbg1AYK9bs2PqxFAAAEEEEAAgYgFtEyfAouWLFliY8eOtcqVK0d8IkdjXOCnn36y5557zr0HY8aMsYQJE8b4PX15A82KmjBhgk2cONEtP6kPwE888YT7/apZs6alSpXKl7ejLgQQQACBKAro33ktEbx37163hHPHjh1dkG4Uq+F0BBBAAAEEEEAAAQQQQAABBBBAICgFFOyloC9v2UcFgykjuibKa8lHbVoCkrHuoHz76VTMCBDsFTOu1IoAAggggAACCJhdvHjRmjRpYiNGjLAPPvjA3nvvPfcBBpvbI6CAOy2p2b17d2vWrJn179/fEiRIcHtuHkN3UfprBX1pW7BggVvasUqVKi6TnDJ/8WE4huCpFgEEEIhAYNmyZS6Dl/b169e3jz/+2O67774IzuQQAggggAACCCCAAAIIIIAAAggggIAnoHFuL/hLe0141th9oUKFQoO/SpcubXfddZd3CXsEELhWgGCvaz14hgACCCCAAAII+F6gb9++9vbbb9sDDzxgPXr0cFmZfH8XagwrMHnyZOvQoYP9/vvv1qtXLxfsFfb1YHh89OhRmzRpko0ePdotFxo/fnz3u1W3bl1Txq+UKVMGQzfpAwIIIOB3Ar/99pu98847LnPnY489Zp9//jlLNvvdu0SDEEAAAQQQQAABBBBAAAEEEEAgUAQOHjwYuuxjSEiIbdy40TU9X758LvirbNmypu3uu+8OlC7RTgRiWoBgr5gWpn4EEEAAAQQQQEAC+mK4ffv2piCkwoULu+AjZWLKnDkzQD4SUCpoBT8NGjTIfvnlF6tdu7b17NnTsmbN6qM7+G81CvxSti8Ffs2dO9ctVfnUU09ZgwYNTJm/lBKbggACCCBwawInTpywjz76yP773//a/fff7zJHKriWggACCCCAAAIIIIAAAggggAACCCDgO4EjR47Y4sWLQ5d9XLt2rV2+fNly5crlgr684K9s2bL57qbUhEBgCRDsFVjvF61FAAEEEEAAgUAXWLlypSnT17hx4+z06dMu2CtnzpyWJk0aF6AT6P273e2/dOmSKdBp27ZtptTPymZVp04da9u2rUv5fLvb4w/30wfhMWPG2PDhw90HYqW6rlevngv8KlmypD80kTYggAACASWgwcTBgwdbp06d7MqVK/bhhx9ay5Yt+Xc7oN5FGosAAggggAACCCCAAAIIIIAAAoEqcPLkSVuyZInL/qXMX/qe5cKFC26itwK/ypQp44LAcufOHahdpN0IRFWAYK+oinE+AggggAACCCDgC4Hz58/bokWLbM2aNbZz5047fvy4m5nii7rjUh0JEya01KlTuwwrRYoUsVKlSlnixInjEsEN+6psZyNGjHCBX8p2liNHDmvcuLE1atTIsmTJcsNreREBBBBAwGzevHn22muv2datW61Nmzb2wQcf2J133gkNAggggAACCCCAAAIIIIAAAggggEAsCZw7d86WL18eGvy1bNkyN7k+ffr0LvBLwV/aChUqZAkSJIilVnJbBGJUgGCvGOWlcgQQQAABBBBAAAEE/ERg/fr1NmzYMBf4dfjwYatYsaI1adLEnn76aUuaNKmftJJmIIAAAv4hoGDZN954w2XirF69un3xxRf24IMP+kfjaAUCCCCAAAIIIIAAAggggAACCCCAQKiAVgDRxHpNsFfmL2UB0xi4VgIpUaJEaABYsWLFLFmyZKHX8QCBABYg2CuA3zyajgACCCCAAAIIIIBAlAUuXrxoU6ZMsaFDh9qMGTMsRYoUbolHLUmWP3/+KNfHBQgggEAwCZw9e9a6d+9uPXr0cBkQe/fubVWrVg2mLtIXBBBAAAEEEEAAAQQQQAABBBBAIKgFrl69aps3b3bBXwoA07Zv3z63KohWCFHWr9KlS7uVQu66666gtqBzQStAsFfQvrV0DAEEEEAAAQQQQACBmwgcOHDAvvvuOxs8eLBt377dSpYsaa1atbI6deqQ7esmdryMAALBJzBhwgS3ZOPRo0etU6dO9uqrr7I0cPC9zfQIAQQQQAABBBBAAAEEEEAAAQTioICyuC9evNgFfmmvYDCVhx56yAV/lS1b1rRlypQpDurQ5QAUINgrAN80mowAAggggAACCCCAgE8FNNNp3rx5NmDAAJs0aZJLb/3SSy+5wK+cOXP69F5UhgACCPibwO7du61t27Yu62HDhg1dVq+MGTP6WzNpDwIIIIAAAggggAACCCCAAAIIIICAjwSOHDnilnv0Mn+tXr3atCpGjhw5XNBXuXLlTFv27Nl9dEeqQcCnAgR7+ZSTyhBAAAEEEEAAAQQQCHABZfsaMmSIDRo0yPbu3WvVqlVz2W0ef/zxAO8ZzUcAAQSuFdAAXs+ePa1r166WNWtW69+/vz322GPXnsQzBBBAAAEEEEAAAQQQQAABBBBAAIGgFzhz5owtXbrUQkJC3LZ8+XI7d+6c3XfffVahQgW3lS9f3u69995oW3z00Uf24osvWrZs2aJdBxci8H8CIfGhQAABBBBAAAEEEEAAAQQ8AWWz6dixo+3cudPGjx9vp0+ftsqVK7t01sr8pQ+9FAQQQCDQBTRrs3Dhwvbhhx/ae++9Z+vXryfQK9DfVNqPAAIIIIAAAgjEssCaNWusdu3aLiNIiRIlbPbs2Tdt0eTJk92XyLNmzXLnrl271i0prr9VNSmBggACCCCAAAK3R+COO+6wSpUquX9/FyxYYMeOHbOFCxdao0aNbPv27dakSRO3xGOePHmsTZs2boWMEydORLpxZ8+etY8//tjy5ctnY8aMifR1nIjA9QQI9rqeDMcRQAABBBBAAAEEEIjDAvHjx7enn37a5s+f74IgSpYsaa+//rplzpzZBUb89ddfcViHriOAQKAKKEW/BueUhl/ZvDZt2uQCXBMnThyoXaLdCCCAAAIIIIAAAn4goC+EFej1zDPP2PTp0+2XX36xr7/++qYt27Vrl+3Zs8e0Vzl16pRt2bLF1q1bZ1evXr3p9ZyAAAIIIIAAAjEjkCRJErecY5cuXVymr6NHj9rMmTPtqaeeMmX90r/7adOmtVKlSrnJhMoKdvny5es2Zs6cOXbhwgX3b33dunWtadOmTKy+rhYvREYg3j9/LPLXYmSkOAcBBBBAAAEEEEAAgTgu8Pfff5uye/Xp08eOHz/uZjW9+eabljNnzjguQ/cRQCAQBCZNmmStWrUyBbN++eWX9uyzzwZCs2kjAggggAACCCCAQAAIfP/9925Zpj///NOUMXv//v2WKlUqS5EixU1bv3fvXjcRwTtx2rRpVr16ddOXy507d/YOs0cAAQQQQAABPxI4fPiwKYBLmTy16d/z1KlTu+xgTzzxhGnTxGmvNG/e3L799lu7ePGiO5QwYUKX3XPs2LFWsGBB7zT2CERWgGUcIyvFeQgggAACCCCAAAIIxHWBdOnS2fvvv+9mHffu3dvmzZtnuXPndgETK1eujOs89B8BBPxUQNm8GjRo4LIVVqlSxWVZINDLT98smoUAAggggAACCASogLJxqeiLW5V77703UoFeOlcZZ8MWr46wx3iMAAIIIIAAAv4loKxe9erVs8GDB7vx8q1bt9pHH33ksnW1a9fOsmTJYgUKFLC3337bjaNPnDgxNNBLPbl06ZLL7PnII4+4ydX+1TtaEwgCLOMYCO8SbUQAAQQQQAABBBBAwI8EkiZN6rLj/PrrrzZq1Cg3a6lYsWJuttKyZcv8qKU0BQEE4rqABtIeeughW7hwoU2dOtWGDRtmadKkiess9B8BBBBAAAEEEEDARwK7d+92y4SPHj3a1agvd7VsuJZyUtH+rbfecsuIK1vXTz/95I57P/TFcKdOnWzQoEHeIfYIIIAAAgggEIACDz74oLVt29aUoVMTD2fMmGEVK1a0yZMnu71WzQhftOyjgr5effVVq1atmilbWHTLiRMnbOTIkfbSSy9ZoUKF7M4777QECRJYvHjx2HxkkCxZMsuUKZM9/vjjLvvqqlWrovt2+eQ6lnH0CSOVIIAAAggggAACCCAQtwVmzZplXbt2tSVLlrhU1VpqonTp0nEbhd4jgECsCWhwTANsGuRq3Lix9erVy6XSj7UGcWMEEEAAAQQQQACBoBQ4deqUKWDrnXfesblz57ovdLWMY44cOdzxsmXL2tChQ+3555+39u3b24ABA2zz5s2WK1cuGzFihH366ae2ceNG69ixo3388cfOSJ+vlZGWZRyD8leGTiGAAAIIxEEBBXP179//msxe4RmU2VMBWppcXb58+fAvX/f5vn377JNPPjEtKX3hwgUrVaqUaWL2/fff78bC4scn/9N18aL4wrlz5+zQoUPub7f58+e7jG7K3vbGG2/YCy+8YLfZOuR/+WSj2AlORwABBBBAAAEEEEAAAQTCClSuXNm0aXBbQV9lypRxH0o1WF2yZMmwp/IYAQQQiFEBzaBUNoVEiRK52ZRVq1aN0ftROQIIIIAAAggggEDcFUiRIoVp+aW77rrLIejxPffc4x7PnDnTrly5Yvnz57fEiROb/i7t16+frVy50gV71a9f332pq0weFAQQQAABBBAIXoF58+bdMNBLPVeGL01eVDawd9991z788MPQ5aEjklFg13/+8x/r3r27Wz66W7du1rBhQzLaR4QVQ8dWrFjh/rbTOOTnn3/uMrUWL148hu7272oJ4/u3CUcQQAABBBBAAAEEEEAgmgL6MKrl0hYsWOAGtTWTqGbNmrZhw4Zo1shlCCCAQOQENLtO2by0PI6CTzdt2uS+UIvc1ZyFAAIIIIAAAggggIBvBd5//30X2PXwww/b8uXLXVYv3UEZOLySJEkS7yF7BBBAAAEEEAhCgT/++MONUUWmawoSv3r1qsv8WaJECdNy0RGVnTt3moKKvvjiC3fur7/+6sbE0qRJE9HpHIshAWVQ+/bbb13WVmV21aR3TX7Xe3g7CsFet0OZeyCAAAIIIIAAAgggEMcEypUr5wK+ZsyYYfv377fChQu7VMb6IEpBAAEEfC2ggFJlUVDKei2H891337Fso6+RqQ8BBBBAAAEEEEAgSgLK5nXs2DErWrSoDR48mIkIUdLjZAQQQAABBIJDYMqUKf/qSLx48VzWLv2t4G3KUO8tA6igr1WrVlnBggXdso5hK1i2bJn720J1aDzstddec9ntw57D49sroOW5tQz3l19+6VY9ee6559ySmjHdCpZxjGlh6kcAAQQQQAABBBBAIA4LVKlSxWXYGTNmjHXq1Mly585trVq1ss6dO1vatGnjsAxdRwABXwhoppwGUt555x3TbLqpU6datmzZfFE1dSCAAAIIIIAAAgggcEsCY8eONX3Zp6UbW7ZsaVrCiYIAAggggAACcUtg3bp19uCDD9odd9xhqVKlCt2SJ09uWg46MnuNfym4a+nSpfb4449bpUqVXBBY0qRJ4xamn/f2lVdecct3P/nkk1a7dm2bOHHiDZfivNXuEOx1q4JcjwACCCCAAAIIIIAAAjcU0AfRunXrug8433zzjQv6+uGHH9xeH4A0a4mCAAIIRFXgwIED9tJLL9ncuXNdAOm7775rCRIkiGo1nI8AAggggAACCCCAwC0LeMv1eHtV2L17d7t8+bLVq1fP1X/69Gm3D3uOO8APBBBAAAEEEAhagf79+/ukb9u2bbMaNWq4idUKKGcMzCesPq9EK57Mnj3bKlasaC1atLChQ4f6/B5ehSzj6EmwRwABBBBAAAEEEEAAgRgVSJgwoTVv3ty2b9/usnu99957ljdvXps0aVKM3pfKEUAg+ATmzJljBQoUsB07dtjixYvt/fffZ5Ar+N5meoQAAggggAACCASMgL6AVdm5c2dom/UZWEV/q+pLWWWjVVmxYkXo5+ATJ064Y3v37nV7/di/f797fPDgwdBjPEAAAQQQQACBuCtw9uxZe+aZZyxnzpw2cuRIxsD8/FdBqw+MGjXKhg0bZgMHDoyx1ibo8k+JsdqpGAEEEEAAAQQQQAABBBAIJ5AkSRI3s6Vhw4a2efNmN/C9ZMkSK168uKVLly7c2TxFAAEE/r/AlStX7MMPP3SBozVr1rRp06ZZjhw5/v8JPEIAAQQQQAABBBBA4DYKKEircePGtmjRIlPGrrVr19rFixfd59uMGTO6pRs1OeHw4cP21Vdf2axZs2z9+vWWJ08e27Bhg/vb9ujRo7Z79247duyYmxzVtWtXUxCYJkqdPHnSfX6+jV3iVggggAACCCDgZwKaND1//ny3pU2b1s9aR3MiElBg3oULF0x/1zVo0MDSpEkT0Wm3cmxPvH/++Lx6KzVwLQIIIIAAAggggAACCCBwKwJLly61Nm3auMCvN954wwV/3XHHHbdSJdcigEAQCiizgQZH9EVaz5497eWXXw7CXtIlBBBAAAEEEEAAgWASUOCXNu8z7qVLl9zzZMmSBVM36QsCCCCAAAIIxJCAsoc+9NBDLmhcywJSAkdAwV6FChVy75+yvPq4hBDs5WNRqkMAAQQQQAABBBBAAIGoC1y+fNl9YO3UqZOlTp3aevfubbVq1Yp6RVyBAAJBKaAAr+eee86UGXDMmDFWpEiRoOwnnUIAAQQQQAABBBBAAAEEEEAAAQQQQMAT0MRHZQVVRtD48eN7h9kHiMDkyZPt6aeftjVr1rjALx82O4TfBh9qUhUCCCCAAAIIIIAAAghETyBBggTWtm1b+/XXX61cuXJWu3Ztq1atmlvKIno1chUCCASDgJKR9+jRwypUqGBFixZ1AyMEegXDO0sfEEAAAQQQQAABBBBAAAEEEEAAAQRuJPDXX3+5SY8dOnQg0OtGUH782pNPPukye/Xr18/nrSSzl89JqRABBBBAAAEEEEAAAQRuVSAkJMRat27tgr0++ugje/XVV00BYRQEEIg7AidPnrSGDRva1KlT7dNPPzUt80pBIDICWh7pwIEDpqU/Dx8+bEeOHHF7PdZ29OhRO3XqlJ0+fdptYR8rxb6yTaqOsJsCDykIIIAAAggggAACCCCAgD8LxIsXz7SpeI/DPw//mjIFRWdLmDChG6vTeF1UHidKlMidr2v0OPxz73jYvfc4ceLEpk3X3Ggf0WvKFO5d74D4gUAACPTt29c6duxoCvpKmjRpALSYJkYkoFVMunTpYocOHXL//4ronGgcYxnHaKBxCQIIIIAAAggggAACCNwGAX3h3q1bN/vkk0+sQIECNnjwYCtYsOBtuDO3QACB2BbYtm2bS3GuIJ2xY8da6dKlY7tJ3N9PBBR0tX//ftu1a5ft3LnTBQX/8ccf7piOa1OQ15UrV0JbrC8f7rzzTkubNq3b9DhFihSWPHnyf+3DftGgLxS06XqWSgjl5AECCCCAAAIIIIAAAgj4oYA3QUX78I/DP1fzvfP02SmymybGeOfqsTdRJqqPL1686CbXRGWvc7VpvFB7r09RfSsU/OYFfSkAzAsCC7sP/1jPFWijzXvs7SM6FvY1vZ4sWTJ3bfg9nzOj+u7FvfNr1Kjhfn/GjBkT9zofRD3W+NX9999vCxcutLJly/qqZyEJfVUT9SCAAAIIIIAAAggggAACvhTQwEvnzp2tbt261rx5c3vkkUdcZh8d0+AIBQEEglNg2rRpVr9+fcuVK5fNnj3bMmXKFJwdpVc3FFDQ1tatW0M3BQAqwGvPnj12/vx5d60G0LNly2aZM2e2e++916XF197b7r77bhfclSZNmtDZ7Te8KS8igAACCCCAAAIIIIAAAggEhIAyMXuBX2H3YR97wWE6pk2fJb19ZB575547d86UfVzX6HH4fdhjuiayRWOfNwoG0/intjvuuMPtwz6O6Fj413WOt+k1L8tbZNvHebEvsGbNGjLdx/7bcMstyJEjh6VPn970fvow2MsI9rrlt4YKEEAAAQQQQAABBBBAICYF8uTJY4sWLbIBAwbYO++8YxMmTLBhw4ZZiRIlYvK21I0AArEgoGx+77//vlu+8euvv3YzZmOhGdzyNgpoWcX169eHblu2bHEBXidOnHCtUKBW7ty57atbaBUAAEAASURBVMEHH7SSJUta9uzZQzcFdTFYfRvfLG6FAAIIIIAAAggggAACCPiJgJeJ2U+aE9oMZRwLGwx29uxZFyAWnb2u0Xbs2DGXxVqPz5w5446Ffxw2u3VoY8I80GdnLxjMCwDz9sp67T329joWlU3XkaksDLgPHiqI8M8//3STIX1QHVXEsoAmtWoSoy8LwV6+1KQuBBBAAAEEEEAAAQQQiBEBDUi0bt3aatas6bJ8aUm3N954w7p27epmwMXITakUAQRum8Dp06etcePGLpizV69e1q5du9t2b250+wT27dtnK1assNWrV4cGd2kJRpUMGTK4pXoV0NWkSRMX4KUgL2XnoiCAAAIIIIAAAggggAACCCAQCAIaw1S2Lm23syjALHwAmALDNN6ifdgtomN6XdnL/vrrr9BzT506FXq9rlE2tRsV9TlsgFiKFCncc+29Ta97jyPzus6Jq0Fkx48fd9ypU6e+ETuvBYiAJjN676mvmkywl68kqQcBBBBAAAEEEEAAAQRiXEBLdU2fPt0GDx5s7du3tylTpti3335rRYsWjfF7cwMEEIgZgd27d9tTTz3lZqnOmjXLypcvHzM3otbbKnD06FEX2LVy5Uq3V5CXBo01SKuMjQULFnRBfdpry5gx421tHzdDAAEEEEAAAQQQQAABBBBAIFgEkiRJ4rKjK6AkpooCyhT05QWLeY+vt1ewmLfpHGX29gLIvOPaK0hNGdGuV5Q1LGXKlC5ILPxewWDhj4V9rsfht0SJEl3vVn51/PLly649ymJHCXyBBAkS3DRgMqq95DcjqmKcjwACCCCAAAIIIIAAArEu0KxZM6tcubI1bdrULefYoUMH69y5syVOnDjW20YDEEAg8gI///yzC/S65557bNWqVZYtW7bIX8yZfiWwZ88et+Tu4sWLTdvmzZvdYK3e02LFitmbb77pAnOLFCniBmj9qvE0BgEEEEAAAQQQQAABBBBAAAEEbijgBZTdddddNzwvqi8q0EvBYBEFginbmI57+7CPdUzLHG7bti00qMw7T5nKrleUgSx8AJiep0qV6l/HdUyZtbSPaFMAD+XfApMnT3YT/AYOHOjG8P99xrVH9DtQsWJFt9To1KlTr33RB89iun4fNDFaVRDsFS02LkIAAQQQQAABBBBAAIHYFsiaNaspC9CAAQPsrbfechm/hg8f7jLGxHbbuD8CCNxcYPTo0daoUSOrVKmSjRw5kgCgm5P51Rnbt2+3efPm2YIFC1xw1++//+4CbhXMVa1aNevWrZs9+uijlj59er9qN41BAAEEEEAAAQQQQAABBBBAAAH/EdDSl97Sjr5q1ZUrV1yAmIK/wm8nTpz41zHvnL1791rY173HXpat8O1T1rEbBYPdLFjMCyALlGxj4ft/vee7du0yTQrUPjJF79fGjRvduJIe+3rpzpiuPzJ9jIlz4v0TxXb9nHgxcUfqRAABBBBAAAEEEEAAAQR8LLBjxw574YUXbMOGDfb555/byy+/7OM7UB0CCPhS4D//+Y916tTJ2rZta7169fL5II4v20pd/xPYv3+/zZ071wV4ab9v3z43GFu6dGkrU6aMaa8MXpohS0EAAQQQQAABBBBAAAEEEEAAAQSCRUAZxRT4db3t+PHj131N1+h1BZRdunQpQpJkyZL9K3OYAsA00XnJkiVWsmTJCK/z54MKnNNk7ciWY8eOufFBBcDFRInp+m/W5qeeespljvvhhx9udmpkXw8hs1dkqTgPAQQQQAABBBBAAAEE/FbggQcecJllunbt6lJEK93z0KFD7e677/bbNtMwBOKiwIULF6xFixamgY0+ffpYmzZt4iJDQPT5/PnztnDhQpc1ccaMGbZ161Y3w7JEiRKmpXSVXl/BXcE2+zQg3hwaiQACCCCAAAIIIIAAAggggAACt03Ayzx277333tI9tbxkRAFjEQWLHThw4JbuFdsXRyXQS21NkyZNjDY5puuP0cZfp3KCva4Dw2EEEEAAAQQQQAABBBAILIGECROagr2eeOIJl+WrQIECLuCrevXqgdURWotAkAocOXLEatWqZWvXrrUpU6a4/1aDtKsB262dO3e64K7p06fb/PnzTYOQ+fLls5o1a9qXX37psndpiQIKAggggAACCCCAAAIIIIAAAggggEDUBDSmoi1jxow3vVAZ1idOnHjT87wTFEQ2efJkGzNmjPXs2dO+//57mz17tilATdn1NVauzGKa0DdkyBDr3bu3m4i5adMmGzx4sGXOnNnOnTtnffv2tZ9//tnOnj3rrlFWftWhMaMOHTq4OrT05nPPPWd169Z1kwO7dOlimjTYsmVLN96nCYPDhw93mb2aN2/umqgM8brPihUrXKb4bNmyuRU69KLupcnbumbs2LGWIEECd82N2qMTlK1LY4zjx49341by+umnn1xfPvnkk1DniOpfvXq1jRs3zrWlWrVq9vXXX9uvv/5qjRs3toYNG7r7ez+WL1/uvHbv3m25c+d2kx8LFizorpVrbBWCvWJLnvsigAACCCCAAAIIIIBAjAgorfX69evtlVdesRo1atjrr79un376qctIEyM3pFIEELipgAaEFIipgR+ln8+fP/9Nr+GEmBe4cuWKacBq0qRJbtNgXMqUKa1SpUpuEKtq1apugCzmW8IdEEAAAQQQQAABBBBAAAEEEEAAAQSiK6CAroEDB7qArY0bN9qjjz5qmhyt4ClN6tOx999/30aMGOFuoWUWDx8+bHv27LGVK1e6ILTHHnvM0qdP78aEFDxWv359GzBggAuoKlWqlL344ov25JNPmgK1FGClouAnBYr99ttvbuxP9WssXvfr2LGjO0c/GjRo4LLEqy0zZ860559/3gV7HTp0yN58803XLgWjXb161V2jSaM3a89XX31l3bp1My2zuWXLFsubN6+dPn3avvnmG1O9CvyKqP7NmzebgtiWLVvmAtlGjhxphQsXdhNUleVefSpatKhrh8Yx1Q6tUlClShXTxPJhw4a5PleoUMG+/fZbd15s/IgfGzflnggggAACCCCAAAIIIIBATAooWEEftDSDadCgQaYPowo2oSCAwO0XWLNmjSkIU/9dKrCIQK/b/x6EvaNmRWq2pGZWamam3hsN/GkWo7J5aaBPA3Z6XYN1FAQQQAABBBBAAAEEEEAAAQQQQAAB/xZQRnYFeKkoQEtBVwpcatKkiQuA6t69u8ucVa5cOXdOo0aN3Hi5Ar2eeuopl7VLWb4UKKWxO42nK6hJ2bOU7erChQsu83vFihVdgJgydHll3rx57no9V4CY7hW2KKBs0aJFLvhMxxU0pfEoFQWXaRz/4Ycfds+9H8oidrP2vPfee/b000+7S9555x03vqXgrAwZMlhISIg7HlH9Dz30kPveQCfceeedLpPZd999Z8oGpomRixcvdtfqhwLXFID27LPPuqUm1S4VjaPFZqCX2kCwlxQoCCCAAAIIIIAAAgggEJQCL7zwgikls2YFaXbO6NGjg7KfdAoBfxWYM2eOm/2mlOYLFiwITZ/ur+0N1nZpOUYFdNWrV8/SpUvnBueUAVGzGDVwtmPHDvviiy/ce5UoUaJgZaBfCCCAAAIIIIAAAggggAACCCCAQNAKJE+e3PWtUKFCoX1UNi+VdevWub0m/qkoSCp+/Pj2yCOPmJZlHDVqlN1zzz1u6UV3wj8/ypQpY6pz+/btbvxIx7WahoqWPVTRJE8FSHmBZjqWJEkS7UJL1qxZLXv27C6zWKtWrezgwYOmbFphS9hrFFwV2fYkS5bMVaNsXF5RMJcyk2mFAa+ErV/HvOuyZMni+qhjuk5F7fOKMoNdvnzZZS7TMa+fyjwW24Vgr9h+B7g/AggggAACCCCAAAIIxKhArly53OwcBX4p0EEfKJXZhoIAAjEroBmEmuWm9O7KJKXMXpTbJ+AFeNWtW9fNknzuuedc6vrPPvvMfv/9d9MMTKXTV4p7CgIIIIAAAggggAACCCCAAAIIIIBA8AloyUUFdSlDl4oeqyRIkMDt9UPBTSdPngx9zXtBy0AWL17cPd22bZvb16xZ0xQg9eOPP9rx48fdqhotW7b0Lolwr2CyoUOHukmgChLLmTOnTZo0KcJzdTAq7YmokrB9i+j16x2L6LpKlSq50732arlIlSeeeMLtY/MHwV6xqc+9EUAAAQQQQAABBBBA4LYIaOZOv379bNy4cW5WUIkSJVjW8bbIc5O4KqAsUQqwbNeunUuLTrao2/OboJT6GnxSYKvS1CvAS8sy6v3Yv3+/Ka1+69at3fKNt6dF3AUBBBBAAAEEEEAAAQQQQAABBBBAILYEFKSlzFsKsLpe0VKGCuzS5EAtuRi2ZMqUyT29++673V4BUZpMrUmGAwcOtMmTJ1uDBg3CXvKvx8qMpYxYyjKvZR6VdUvLSGqcKqISlfZEdL0vj2mpyFq1apn2GlN77bXX7O2333bLY/ryPtGpi2Cv6KhxDQIIIIAAAggggAACCASkQO3atd2yjppNVKRIEfvpp58Csh80GgF/FVCa9TfeeMPeeustF2D0+eefu1Tw/treYGiXzBctWuQG2pRuXwNQmgHpBXjNnTvXvZYhQ4Zg6C59QAABBBBAAAEEEEAAAQQQQAABBBCIpMD8+fPdmdWrV7/uFYkTJzZv6ceQkJBrzlu1apVb8tB7XS82a9bMdI2CnqpWrWqpUqW65prwT3bt2uXGCzU2NXz4cBsyZIgLQJs4cWL4U93zqLYnwkp8dPDs2bNuIuX48ePdEpZLliyx7t27+8V4J8FePnqTqQYBBBBAAAEEEEAAAQQCQyBHjhy2dOlSU+DXU0895WblaHYRBQEEbk3g0qVL1rBhQ+vbt68buHn99ddvrUKuvqHA5s2b7d1337X77rvPypYta8uWLbMOHTrY3r17TQN5mmVJgNcNCXkRAQQQQAABBBBAAAEEEEAAAQQQCDoBZdtSOX36tA0bNsxy585tTZs2dccOHTrk9jt37nR770fPnj1dAFOfPn3s3Llz7rCyfG3dutWNPynbllc03lSnTh33NKIlHJW5S0VjVF4ZNWqUHThwwD31As9KlSrlveyyfemJd01k2+PVqSUlveJlJ1O2e6+Eb9ONrjty5Ih3mb355pu2YcMGl5VMgV5jxoyx6dOnuwCw0JNi6QHBXrEEz20RQAABBBBAAAEEEEAg9gSSJk3qZhANGjTIevXqZZUrV3aZcGKvRdwZgcAWOH/+vD377LOmGXlTpkyx559/PrA75KetP3bsmA0YMMCKFy9uefPmtREjRrj09xs3bnSDTppRmTlzZj9tPc1CAAEEEEAAAQQQQAABBBBAAAEEEIhpAQVsaexIQV5JkiSxBQsWmJZf1Hidl+lLwV/KsOWVMmXK2KRJk2z37t1WokQJa9++vVWqVMk6d+5sHTt29E4L3bdp08YKFy5sRYsWDT2mB/369XNZvPRY9WliooomW5csWdLatm1rL730kmmSaN26dV1wl8YUFVCloiUhV69ebZFpT48ePWzOnDnuOo2JrVixwhR8tmPHjtC6tHRk+PrVLk2SVFm+fLnLUKbJ4Z06dXLHFJg2dOhQ91jLT2o8Tq+pbrW9WrVq9sADD1j4LGjugtv4I94/6f6v3sb7cSsEEEAAAQQQQAABBBBAwK8E1q5d6z7wKVhlwoQJ//qA6leNpTEI+KGAZgkqS54GYqZOneoGbvywmQHbpCtXrpiWYvzmm2/c/6Pix4/vMhM2btzYypcv7xdp4wMWl4YjgAACCCCAAAIIIIAAAggggAACfiiwf/9+y5QpkymblIKkIlNq1Kjhxub+/PNPO3PmjKVOndrSpk0bmUtDz1FQ1pYtW+zkyZNWoEABS548eehr4R/8/fffli5duvCH//VcY1taEUB1//HHH6aVNzS+FZkSlfZEpr6onqOgNAXMKchLWdHkeurUKRcolz59evv2228jVaXGTlOmTGk//PBDpM6PxEkhCSNxEqcggAACCCCAAAIIIIAAAkEroBlIClLRzCbNGFLWHH14oyCAwM0FNLNNs9l+++03NzOwUKFCN7+IMyIl8Pvvv9vgwYPdTMJ9+/a5WZX//e9/rV69epYqVapI1cFJCCCAAAIIIIAAAggggAACCCCAAAKBKxCd3E0KpFJAVXSKMoDly5cvUpdGJtBLFak9iRMndnUqI1ZUSlTaE5V6I3Nu//79rXfv3i7IS31VpjSvaFnLWbNmeU9vutf7GC9evJueF5UTCPaKihbnIoAAAggggAACCCCAQFAKpEmTxs16UkpqZctZs2aN9ezZ0xIm5CNTUL7hdMonAgcPHnRLoB4+fNilLX/wwQd9Um9crkQzHadNm2YDBw50e82+VPCp/r8UdkApLhvRdwQQQAABBBBAAAEEEEAAAQQQQCDYBZQFSkVZpCJbNEanouxZGTJkiOxlnHcdgXPnzrlXWrRoYU8//bRly5bNdu7c6ZZ+3Lp1q40cOfI6V/77sN5HZWrzZeGbC19qUhcCCCCAAAIIIIAAAggErIBmGHXr1s2U6UuBFRs3brTRo0eb0jFTEEDgWgFlmqpUqZIpOGnx4sVusOPaM3gWFQENwg0ZMsRl8lJGrwoVKtiIESOsVq1alihRoqhUxbkIIIAAAggggAACCCCAAAIIIIAAAgEukCJFCreEosbgbla01GHTpk1t1apV7tRmzZpZu3btrFGjRje7lNdvIPDyyy+bVjWYOXOmNWnSxE0Mz5Mnj7344ov2xRdf3HCJy/DVarzvscceC3/4lp7H+ydd2NVbqoGLEUAAAQQQQAABBBBAAIEgE1i/fr0LstAH5UmTJhlL0wXZG0x3bklASzYqGElLCc6ePdsyZsx4S/XF5YsXLFhgffv2tYkTJ9pdd93lsnhptmBUU9rHZUP6jgACCCCAAAIIIIAAAggggAACCASjQIkSJezhhx+2fv363bR7CkoKW5ImTWraKL4RUJavJEmSRGspxhMnTpiWfRw7dqz7zsE3LbKQ+D6qiGoQQAABBBBAAAEEEEAAgaARKFiwoK1cudIFXJQuXdomTJgQNH2jIwjcisCOHTusXLlyLhX8woULCfSKBubp06dtwIABli9fPitfvrz9+eef9v3335tm+PXo0YNAr2iYcgkCCCCAAAIIIIAAAggggAACCCAQbAKabDljxoxIdStNmjQWdiPQK1JskT5JnvHixYv0+WFPnDVrlrtWY6q+LAR7+VKTuhBAAAEEEEAAAQQQQCBoBNKmTetSNDds2NCeeeYZt8Rj0HSOjiAQDYFt27a5QK9MmTK5jF7KREWJvMDOnTvttddeM/m1b9/eihcvbmvWrLElS5bY888/b4kTJ458ZZyJAAIIIIAAAggggAACCCCAAAIIIBDUArVr1zaNJy1dujSo+xnsndMkTy3h6OuxVJZxDPbfHPqHAAIIIIAAAggggAACtyzQp08fe/31161+/fo2aNAgl7L5liulAgQCSGDr1q1u6cZs2bK5GYWpU6cOoNbHblNDQkKsV69eNnnyZMuSJYu1adPGmjZt6vMBntjtJXdHAAEEEEAAAQQQQAABBBBAAAEEEPC1wCOPPGLZs2e3MWPG+Lpq6rsNAtu3b7c8efLYyJEjrU6dOr68YwjBXr7kpC4EEEAAAQQQQAABBBAIWoGZM2davXr1LG/evG5ZxwwZMgRtX+kYAmEFNm/e7AK97r//fps+fbqlSpUq7Ms8jkDg4sWLNmrUKBfkpexdJUuWdFm9NCMzQYIEEVzBIQQQQAABBBBAAAEEEEAAAQQQQAABBK4VmDRpktWqVctWrFhhCvyiBJZA3bp1bdOmTW6LH9+nCy8S7BVYvwq0FgEEEEAAAQQQQAABBGJTYMuWLVazZk27dOmSTZ061QV+xWZ7uDcCMS3wyy+/uECvXLly2bRp0yxlypQxfcuArv/EiRP29ddfW+/eve3gwYP27LPPuqyAxYoVC+h+0XgEEEAAAQQQQAABBBBAAAEEEEAAgdgR0BKAx48ft5UrV1rChAljpxHcNcoC+v6gRo0a7nuEatWqRfn6m1xAsNdNgHgZAQQQQAABBBBAAAEEELhG4PDhw2421YYNG2z8+PEuEOaaE3iCQJAIbNy40SpWrOhSjWtwIkWKFEHSM993448//rAvv/zSBXpdvXrVWrRo4TJ5Zc6c2fc3o0YEEEAAAQQQQAABBBBAAAEEEEAAgTgjoKUACxcu7MabevbsGWf6Hcgd1Vjhww8/bJUrV7bvv/8+JrpCsFdMqFInAggggAACCCCAAAIIBLfA+fPn7aWXXrJx48bZoEGDrFGjRsHdYXoX5wS0dKNmDWrZ0ilTpljy5MnjnEFkOiynzz77zIYPH27p0qWzV1991Vq1amWpU6eOzOWcgwACCCCAAAIIIIAAAggggAACCCCAwE0FRowYYQ0aNLCBAwda8+bNb3o+J8SegDL/ly9f3s6cOeOyscXQBNqQBF3+KbHXTe6MAAIIIIAAAggggAACCASegNJlP/PMM3bu3Dl78803XQcUGENBIBgENFtQAxIPPvigTZ8+nUCvCN7UVatW2SuvvGLt2rUzBX9+8sknNnToUCtXrpwlTZo0gis4hAACCCCAAAIIIIAAAggggAACCCCAQPQE8ufPb/HixbO33nrLsmbN6jJ9Ra8mropJgWPHjln16tVt3759Nm/ePLv77rtj6nZ7WNAzpmipFwEEEEAAAQQQQAABBIJaQB+uFeCRPXt2e/nll23Xrl02ePBgS5QoUVD3m84Ft4B+jytUqGDZsmUzLd14xx13BHeHo9i7BQsWuP/uZ8+ebY888oiNHTvWLeuq/x9QEEAAAQQQQAABBBBAAAEEEEAAAQQQiCmBzp0726VLl6xp06a2e/du0/P48ePH1O2oN4oCmkBbq1YtO378uM2dO9d9bxDFKqJ0Ou98lLg4GQEEEEAAAQQQQAABBBC4VkBps7XM3YQJE6xq1aqmNM0UBAJRQDPOFOiVIUMGmzFjhqVMmTIQuxEjbZ41a5aVKlXKZTy7cOGC6fnKlSutdu3ablZljNyUShFAAAEEEEAAAQQQQAABBBBAAAEEEAgj8NFHH9mAAQOse/fuVqlSJfvtt9/CvMrD2BC4evWqW15TE0OTJUtmS5cutTx58sR4Uwj2inFiboAAAggggAACCCCAAALBLlClShULCQmxzZs3u2XcDhw4EOxdpn9BJvDnn3+6QC8FeCmQKU2aNEHWw+h1Rxm8FOSl/8ZTp05tS5YsMWX3evzxx6NXIVchgAACCCCAAAIIIIAAAggggAACCCBwCwItWrRwAUWHDx+2vHnzWvv27e3333+/hRq5NDoCCvLSyghFixZ1K3+0bNnSFi9ebFmyZIlOdVG+Jt4/Dbga5au4AAEEEEAAAQQQQAABBBBA4F8CSp+toJCLFy+6zEi5cuX61zkcQMDfBA4ePGiPPfaYaXhg4cKFLrOXv7XxdrdHqdaVCl/BXfpv+sMPP7TixYvf7mZwPwQQQAABBBBAAAEEEEAAAQQQQAABBCIU0Bh0r1697IsvvjAFflWuXNlq1qxpxYoVsxw5criJiyzzGCFdtA6eO3fODh06ZJs2bbJ58+bZuHHjbNeuXVajRg37z3/+YwUKFIhWvdG8KIRgr2jKcRkCCCCAAAIIIIAAAgggEJHA33//7T7gKYW2ZvbowzUFAX8VOHLkiAv0Onv2rAv0uvfee/21qbelXfPnz3dBXosWLXIDZF26dLESJUrclntzEwQQQAABBBBAAAEEEEAAAQQQQAABBDyB8+fP2759+2zv3r1u8x7v3LnTBRkpU3/GjBlNmelXr15tP/74o82ZM8dOnTrlVcE+hgRy587tAuuaNGliehwLhWCvWEDnlggggAACCCCAAAIIIBDkAmfOnLE6deq44JkxY8ZY1apVg7zHdC8QBU6fPm0VK1Y0DQwpuClr1qyB2A2ftFlLMyqTl5ZjrVSpksvkVbJkSZ/UTSUIIIAAAggggAACCCCAAAIIIIAAAghEJHDhwgWbPHlyaDCXVo7QJGIFdh07diz0EmXoSpgwoV25csUuXbrkjmfKlMllpc/2/9g7D3ApiqwNH1wVRDDnNWAWxbjmiC6KERXBiBkxLGBGMQEGEBUTgglFFCNgwACYUFRUVsGAmHMOa0J0jfPXe9iavxlm7p25ccJXz9O3ezpWvd23Q9VX31lppfR6LH/nnXd8fz/++KP9+eef6WUNPYFT/vzzz2+9e/du6EPXy/GaNWtmiy++uLVu3doWXXTRejlGATuV2KsAWFpVBERABERABERABERABERABPImwEd3t27d7JZbbrHhw4dbly5d8t5WK4pAfROgImm33XazV155xYVelRpyFHEXIi/EXjvssIOLvLbeeuv6xq/9i4AIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAT2HjjjW3q1Kku5iI0Y3UJ0ddSSy3lQq9WrVpVt3qjLCfU4brrrmvjx4+39u3bN0oeyvygk+Yp8wKqeCIgAiIgAiIgAiIgAiIgAiLQKAT46L7xxhvtpJNOskMOOcQGDx7cKPnQQUUgkwA9+g488ED797//7RUulSj0ogJtp512su22286aNGnijl6PPfaYSeiVebXotwiIgAiIgAiIgAiIgAiIgAiIgAiIgAiIQH0SoCNiKpWyfIVeSy65pD399NNWrEIvWFEXvuaaa3r9W32yq+R9S+xVyWdfZRcBERABERABERABERABEah3AgMHDrQBAwZYz5493TWo3g+oA4hANQSOPvpoe+ihh+z++++3DTfcsJq1y2sxNvgHHHCA0WMSK/uJEyfa448/bttss015FVSlEQEREAEREAEREAEREAEREAEREAEREAERKAkCu+++u6299tpGqMaqEp2Ll1hiCRd6rbzyylWt2qjLvvvuOxs5cqT16NHDO1k2ambK+OBVXy1lXHAVTQREQAREQAREQAREQAREQAQaisBpp51m1113nZ177rl2/PHHe0+thjq2jiMCSQKnnnqqjRgxwkaNGlVRAqevvvrKK5hat25t06ZNs9GjR9tzzz1nbdu2TeLRtAiIgAiIgAiIgAiIgAiIgAiIgAiIgAiIgAg0KAFc5/v27Wt//fVXzuMi9Fp88cVd6LXKKqvkXK8YFgwbNsxDUh566KHFkJ2yzYPEXmV7alUwERABERABERABERABERCBYiJw1FFH2R133GHXXHON8aH7xx9/FFP2ijovVHZstdVWtuKKK9oRRxxhhCGsKmF7vsMOO9huu+3mq/300092yy232H777WeLLrpoVZuW9TIc5gYNGuRir8imrAscCse55/pZddVV7e6777arrrrKpk+fbh07diz3oqt8IiACIiACIiACIiACIiACIiACIiACIiACJUDg008/dRFX8+bNszphIfRabLHFfB3quIo5UW87ZMgQO/zww61FixbFnNWSz5vEXiV/ClUAERABERABERABERABERCBUiHQuXNnD52H6KRTp07222+/lUrWGy2fl112mY0dO9bGjx9vO++8sw0fPtxef/31KvNDL7hXX33VXnrpJe8RR7i+X3/91caNG2fff/99lduW60Kc5c444wwbPHiwHXjggeVazHS5fv/9dxd2UQF2+eWXe9nffvtt69atm/csTK+oCREQAREQAREQAREQAREQAREQAREQAREQARFoBAIffPCBHXPMMYZTF/XF2TonIvSi8+rTTz9tq622WiPksrBDUo/70UcfWffu3QvbUGsXTKBJ6PGcKngrbSACIiACIiACIiACIiACIiACIlBjApMnT7Zdd93VNt98c7vnnntsgQUWqPG+yn1DxDo77rijO6LRM4xKkHx6sCHqmmeeeWyhhRZKI9p0003t3//+d8WF0bzvvvtsn332sXPOOceHNJAynKCKAwe9s846y+gVScUSIjd6PyqJgAiIgAiIgAiIgAiIgAiUPwG+CR555BHvMDRx4kQP417+pVYJRUAERCA/AghxevbsaXQK3GmnnardiHvqP//5T6+7fPDBB6tdXyvkR4AOif3797eRI0faCiusYKeffroddthh9re//c1WXnll++STT7z+EqHXIossYs8884ytscYa+e28kdfabrvtvD72/vvvb+SclP3hJ8nZq+zPsQooAiIgAiIgAiIgAiIgAiJQbAS23HJLe/zxx+2FF16wXXbZxUPNFVseiyE///3vf13cRcUGiQqPfIRerEtFSFLoxby4H6YrJT377LN2wAEHWNeuXcte6DVp0iTbeOONrUuXLrbNNtvYW2+9ZZdccomEXpVysaucIiACIiACIiACIiACIhAIIEx444037Oqrr7Z33nmnQZlwbCUREAERKGYC77//vn344YfGOJ+U6Z6fzzZaJzeB1157zR3311prLaMz8LBhw7z+Cif6+eef3+s++/Tp4zugHnThhRd2R69SEXpNmTLFqJ87+eSTc0PQkjojIGevOkOpHYmACIiACIiACIiACIiACIhAYQSmT59u7dq1s1atWnmvYwRKSrMJDBo0yBAqjRkzxqgA2WKLLWyJJZawiy66yL777jsbNWqUPfnkk14hgmPXwIEDrUWLFr7xL7/8YvQ2vPXWW2306NFeUcICRHbss1Iq4N98803baqutfMAKnkqickxUUPbq1cvPdfv27V3g1aZNm3IsqsokAiIgAiIgAiIgAiIgAiKQJ4F1113XOw/NnDkzzy1qtxqCCL7vcRUr12+v2hHS1iIgAsVCgBB7K664Yt7Zyeaen/fGWtEJTJ061S644AKP8LDOOuvYmWeeafvuu69HJchE9Pvvv9tKK61kv/76qzt6US9aKqlz587+7CWyglK9E5g0u3t0vR9HBxABERABERABERABERABERABEcgkgCCF3k7Yoe+www728MMPu6Apc71K/L3HHnu4jTliL9y8jj32WGvatKmjwKnqvffeM3rDYXuOEIwK/Jtvvtm+/vprO+WUU+y2226zP/74o2KEXZnXyOeff24777yzW7wT1rAcGxt++uknt7y/9NJLXTD5wAMP2G677ZaJQr9FQAREQAREQAREQAREQAQqkEBDfwMRPp6wkZXSuagCLykVWQTKhkAhQi8Krc6pNT/1zz33nJ1//vneKXWjjTbyTq177bWXNWnSJOdO55tvPqMT7AYbbOAdYHOuWGQLqKu95557vPNtkWWtbLOjMI5le2pVMBEQgUiAj6s///zTG/t+++03QxFNwx89bfThFSlpLAINR4AeDB07drRVVlnFG+fp7VZdIo48rjeIIEjTpk2zs88+2zbccEM799xzq9tcy0VABESgqAlgw/3UU08ZveS22247++KLL4o6vw2VObhEd6a///3vtskmm9h6661nuHY98cQT3gORyo+1117bBU04dpGWXHJJGzFihFGBUqkJ4duuu+7q4rj777/fFlhggbJCwXv88OHDbfXVV7drrrnGLrzwQnv11Vcl9Cqrs6zCiIAIiIAIiIAIiIAIiEDdEMDBBjeV7bff3rp3725fffXVHDv+73//6+7AnTp18m+K3r1722effVbQOgi9cJsmHXnkke7YMscO9EMERKCiCdCecfrpp9uVV15ptHUceOCB7j7fv39/b78EDu2WdGLbe++9PcwiHRnpxPfJJ584O0RD3MNwEDz88MPtzjvvTDNFZIOjEtvS9nLXXXf5MkLa7r///j5//Pjx6Xm0rVx//fXp7T/++GMjdOAuu+zi++HYMVEPh2s++6atNabq7p3Uc44cOdLzw/4HDx5sO+20kx1xxBEVUfdJNALOFR1Uv/32Wxd7vfjii86xKqFX5EtH19atW8efJTGmM+YKK6xgPE+VGoaAnL0ahrOOIgIlTYCHNw9tHujJcXI6c1n8HdfBahKRVeYQxVeZ8+PvzOU07MQBoVacZpzrdz7w55lnHldRM05O88DNnMdvegXRuFjoQLzluA3TNLw1a9YsPU5Ox2XJecnpuJz8KIlAqRDgBZ+PDSpYBgwY4A331157re24445VFiEzjjxOHq+//rq99NJLRi8IJREQAREodQIIWhF84e7Vtm1b7w287LLLlnqx6iX/vAPh6LXgggvajz/+aLfccou7e/HemUzRBSw5rxKmeY/mWYtoEAHc4osvXlbF5v/khBNOsJdfftmOOeYY69evX9mVsaxOmAojAiIgAiIgAiIgAiIgAo1IgDrEzTff3BvMP/zwQ+84hJjilVdesYUWWsgb4PkGp9PQ5Zdf7t+YiDDoVMJ6W221VV7r7Lnnnnb33Xfbm2++6SIMvluVREAERAACiH5OOukkoxP8oosu6uH56KCIEIt6G8RcQ4cOtUMPPdRd6tkGkep//vMfF30RDo+OfNSFcG869dRTfX1EXLjhI+yiY/0hhxxiHTp08P1zPyIR/m/55Ze3d99914VjuODHDnOEEYzpoIMO8qgD48aNswkTJhhCo0suuSSnez7iperunZSJNqDYlkPowlmzZnnnPVz5KVM5JgwLzjvvPHv66aed0aOPPupsy7GsyTJxvdIxk+uroZ01k/motGmJvSrtjKu8ZU0AURa9+Gn0YswDtKoxD9Xk8PPPP8/xm2WItmgwyichOkqKkeI0HzYIm5JCpyh4opEuTjPOtk5czjKOkRRg1eR3FIVljjMFY1Uth3UUpGUbZ4rUWAfBG+ckrs868M0UxtFQycDx80nNmzf3xs4WLVoYA0yzTVe1bOGFF7Y4sF4+qvJ88qZ1RCCTAC/wVKwQrmyZZZbxDxoqVqpLxx9/vPd4iPbC22yzjd/f+JhREgEREIFyIYB71RPBsSoKvh5//HFjntLcBJZaainr27evPfbYY3biiSd65RUC4EpPvD/Su/P555/38KCICMslffDBB9arVy8bNWqU9wRF7EVFoZIIiIAIiIAIiIAIiIAIiIAI5CJAPTfuN9QlUj/fNgi7cMdB2HXOOefYaaedZtOnTze+N2K940033eTf5XxbsSyfdTbbbDNr2bKl16tzDCUREAERiARw8cfxiHsD7vR0YuPexL1l/fXXt+uuu85wB7z11lvt008/dXEYwi9cvBCI0XaHCLVLly5e58N+cRLkXkYdCfesww47zPbYYw9vd6GubMqUKbbpppt6FqhfRHhFYj8IznCDj4n2GvLUvn17n8V4yy239Onono8wjX3GlM99kTLRYR93L1zNKBNp6aWX9jqruK9yGdP2hcgLcR4MEXshGK6UxDWGLgDnNqWGIyCxV8Ox1pFEoEoCCIB++OEHD9+D802czjZGzJVtQJyVK+FsgIiHD444RhQUBxrM4nRSPBTdozLHUciVHCPGUqo7Anx8Rme05Dg5HQV6iMgYuAaS04j9Pv/886zL2E+2hIAO8Q0vkHEchWC55jF/scUW85dEXhTVcykbWc2DAC/3pHnnnf0Kstxyy/nvfP7ECpe4btxH/K2xCIiACJQDAdy8koKviRMneg+8cihbXZUB0f2+++7rvRypjOId5IYbbqir3Zf0frDhp0fnQw89ZBtssEFJlyVmnvdbwhpQMcq7AJVnu+++e1yssQiIgAiIgAiIgAiIgAiIgAjkJLDEEku40IsVaCPp2rWrCyQmT57sna0RgvEdnqx3RBhGW8nbb7/t4eKrWwdBGC49JHWidgz6IwIikEGAewppvfXWS98n1lhjDa/fuvnmm11YigNXbC8hmgltdRtvvLENGjTI2wpxKUwmQjxOmjTJXQURe5EQiCH2IpoKYi/EYhhdJLfNdMLn/rfyyivbWWedZYRbPPfcc+3222/3/cU/yW3oaJjvfTG2FeIwFhOCN+o+aQNN7jcuL6UxbDEkIJINjpEI7hDFbbLJJqVUjFrnlfbmq666yo499lh/ftZ6h9pB3gQk9soblVYUgeoJ8IBDhIVVIRaWccz0d999V+WAQCdbQpi1yCKLuPAmjhHgrLrqqi7EYTrbkBR1sQ/csZRKiwAvOQwIqeoj0VAahWGICjMHruXMeQjHMuchVMxM5BvRV1IAlpyOywgrFAeWc43rgziTZnn8/iD0juMjgY8PUs+ePV3lTwULvUSoYLnnnnv8RZh7FmGZeDGOiZ4j9Gzhw+Ooo46KszUWAREQgbIkQA83RF44fNH7jwqQFVZYoSzLWl2hotNpHLM+VvTjx483XB95fyAhCEqu4zMr7A89OalcQvjWrl27sig9FWaEKeCdFev/f/3rX/quKYszq0KIgAiIgAiIgAiIgAiIQOMQiC4rhBD76quvPHJAZv07HUxx6sINB4cWOlRXtc5bb70lsVfjnE4dVQRKngDhF0mYgJAQeJGSYfDeeecdnxeX+Y/wZ+utt/ZJ7kEx0aZCHeIdd9zhneauv/56O/roo+PirGPa5G688UYP3YhIDKHXkCFD3Eks2wb53DuT98XMfSTLlrmsVH7TvgonOicSvnefffYxRHuI+SoxDRs2zPURPXr0qMTiN2qZJfZqVPw6eDET4EaNQOubb77JOSDmioIuxqzPdsnEhwHClswBdXbmPIQuceDjgaEcHnpJHpouHgJcW/E6q02IKMJQIgDLFDVm/uZ/hJfSKHxkOaEsk4k88X+BAIxeVwzJaX5jGxvHTCN2VCp+Apyz4447zl1YiA9PzHfCOPIx88wzz9i2227rHxQ0UhO/fu+997YZM2YYvVtyxZEv/lIrhyIgAiJQcwK4riL4Iuwtgi+mV1pppZrvsES3jBVW7733XroE8dlPxRWCOGzr6alIQji82mqr2brrruuVDMz76KOP/HnD9GeffcbIqNjnPaJcEtdHt27drHfv3mVhl04PeiqIHn74YTvkkEPsoosuMv4nlERABERABERABERABERABESgNgTi9+Tqq6/u9dC033zyySdGGLPkN3esL6fusrp16LAVkzoyRxIai4AI5EMgRkLhnpQrxforwgIeeeSR6dXifSp5D6KNjY70Z555poeHHDt2rId8TG+UZYJ2bZy/Xn75ZTvxxBO9PYaQi7RjU++WmWjDK+S+mLl9Kf/G/AJRFx0SMTignYtOqUnnslIuX03yDhPq7TBpSF6LNdmXtimcQJ2JvYLTngXTjRAuzEKvWwu9qgvPTENtQeQojHKCI6G1aoWtakMdWcdpTAJ//PGHN+rQsJMcUCAnfzPNPAQpme4AfAhkik9w2EKMgqtAtnH8eGjMsuvYIlCfBLBhZUC4U2jCpSFTNMlvRJZxzMc2L5nM4/+T0JXJRPhQ/i9pAOSlN9uYFwzmM0S73OQ+NF3/BHDrwnI4OrAwjUU6acKECW4lTMM853OXXXbxniP0nEPslS2OfP3nWEcQAREQgcYnwHONnsS4NLVt29aefPLJOUJLNH4O6zcH2H8Tuo9EuEbcIHv16mU77rij7bbbbjZu3DgXEuP2dMUVV3iFVN++fe3qq6+2Tp06uX062x500EF2zjnn+Hwq8EksZ9//+Mc//Hcp/8H9smPHji6URjRdyolOBFSYUUnEOwCOoLGnaimXS3kXAREQAREQAREQAREQAREoDgJ8Y5Oof6QecoMNNrAXXnjBvz0OPvjgdCaZR503obiqW4flJIReiCZoi0IIoSQCIiAC1RHAzZ9oJrSN5Eo4DZJi1JS4HvcpEpFTkon6s379+nkdGuKw6tqp33//fbvsssu8TYboKnQ8Zbt77703q9grn3tnvC8m81XK04ScxEl/4MCBQQvzuSGGO/300z0KVymXqy7yPmLECPvyyy/t1FNPrYvdaR8FEqjV2waOgkG8GGKRpoIrh4WXmNJTTS2ySMp23rlJaAAw23VX7BELJKjVG5UAMWC/+OILHxBocTPJNcZFKCneQt2cdAeiMW399dd3sQjTLEsOCLl4gCmJgAjUHQEEQAzJXlPV7Z1GwCjQjAKw+DuKN3GOisJNbLaTCbFXFH4hAmNAqBan45h51b0EJ/er6ZoTIBZ8hw4d3O78+eeft2uuucZ3Rnz4mEo9dnssh8YiIAIiUCgB3kcfe+wx23777b2CBcFX7LlX6L5Kbf3u3bsbQ7b0wAMPuHNX8ll92GGHpZ/dmRVd7IPK/HJLvO8gfGvdurVRuVLKvcjvv/9+D83J+x2CL5y91EBSblesyiMCIiACIiACIiACIiACDUtg1qxZRh0jYc1oTyLU1DbbbOMOwuSETkC4aQ8ePNg6d+5szZo1c5cvOtUglsDBJp912BcuOLRBIQiYb7753Cln7bXXZpGSCIiACDgBBKeYINAuNmrUKG/Xxikqtj9Tz0PC4T7W/1HvQ0fQRx991F2k6PBHGj9+vLdj0zEymWj/4n6GcCtbCMcff/zRV8cJP6Y777zTzj77bG8r43ikGPaW6eQ2OB7me1+kDZ9EdKCYYkdMDB+4bxZzwnyC0JYXX3yxm8QggoM3Aj0ltEF/2oUXXujiN56zSg1PoEZir6CZCSfO7KqrUjbP38x22vV3GzT0d1tnvT9s2eX+shYtG74ghRyRKHs//tDE3n93Hpv673nt0fHz2x57/M2dvvr1axJi0MrtqxCedb0uNwYEGyhjo5CLMUKuzN/JhwP5oLGHhxhiDcbYJhIaLP5mjJCLAXeZUm4MqWvu2p8IlAoBelTxIpXvyxQf8UkRaHKa+wovzc8++6zfX3i5TIpCo2MZwq9sA85UDNxb+IBXqhkBPmSISR97ytEYTyO+kgiIgAiIwGwCdDqIgi9EXwi+ojtiJTNKCr3gkPm73NnwjrPnnnt6Me+77z5vlCjFMmN737NnT0Pshf39oEGDdH2X4olUnkVABERABERABERABESgyAgQ5v7cc8/1DqZ09P/000+9IxXfHLFtCOEX31M04G+xxRa+nG+TPn36eBg0ipTPOqy37777GiHTjj32WHeePvzww5mtJAIiIAJpAoiHuB/RpvTWW2+5Cz2ugn/99Zc700+cONHX5Z502mmnpcM2Igzj3tIliBi41/z222/uaI/bF6LUzIQL/owZM7zNJblsyJAhLtRiHvc+jkH4Pdrm6TiJ0Oudd97xexjHQRB20kknzeGejxN/PvdFXNsRqJEQSC2yyCIuhmX/JJz4R48e7VGzfEYR/cFEIrJCNExozFNOOUX1VRnn6Pbbb/dwlricKTUOgSahUbuggIvhXmL/+lcq3HRSduyJ/7X9D/616MVd+aD94L157OrLm9mo2+YPL3Rmw4c3sSrC4+azS62TQYCYrQi4PvvsMx8znW1AiMFDLSZceKLrTlJswYMw+RtxF70ulERABESgpgRiuNdMcWlSaBqnk2JTKgdoiKfhnfsSY3okMM4cmjdvXtPslcV2fCDwYcKzADYkXuj3339/f3mmpwm9W7AKxtUjviTGecSaP//88327hx9+2Nq3b2+E7KICRkkEREAEyp0AzyfCOfIJh+CL9+FKSlQ8USGEUJvnCAMuUIieGLBUx70XETE9JKns4llD2HUGnETLxSmKa4Bn5yOPPGKTJ0/2Ti6ldi1wvugZ2b9/f2vVqlXoTHZV1vAApVYu5VcEREAEREAEREAEREAERKC4CNBoz7cj3x1R5JWZQ743X3/9dWPd9dZbz2iXykz5rMNx5gkhhDAbUBIBERCBSICQi3R2R7CFExLtTKuttprfL+I6+YwxLJg+fbqbIay88spVbsL9iIgB1SXa5Gkb4x6HKBbnLu5j+aR87ov57KdY1vnuu+/syiuvtCuuuMJ5IJpD7JYPx2IpQ0Plg7rJddZZxzbeeOMQCfDmhjqsjjMngUl5O3uF//EQUsFs6FCzAw/9zXr3+9laLjTn3kr5V6tV/rKBV/5sh3b71Xr1WDAo/ecJYTCa2P+cEEu5aPWedx4CCLR4AMRGl8wxy3ioJLWFURgRhRDEI47TcYxogoYaJREQARFoCAI0AMf7T3XHI5wkL+TRhTA55h74yiuv+DJsd5MC1oUXXjgtBEMQFgeOm5zGVawcU3wOxDFlJM45HwX77befF5meEqTkOj5Df0RABESgwgkg7kL8iuBrhx12MHr70eGhXBPP1ieeeMLLSaUYFe+Iukh8I/DcxLGXZyadPhB5UTHPcyQOPKupqCHxnKcibeutt/YwHTgA5+sU6jsooj/nnHOO3XPPPTZhwoSSFHohUqPCjHcmBNtUnMkltYguMGVFBERABERABERABERABMqIQMuWLY2hqkTHoTZt2lS1incuqm4dCQKqRKiFIiACgQDO9DV1p6dtndCz+aR870cIu2IYSerNCkn53DsL2V9jrUs7HqEpcfOi/vD4IIphwI1MKTuBMWPG2JtvvmmMlRqPQF5ir9CebZ06W6hoT9nQ4bNs1z1/b7wc1/OR127zp9094Ufr17u5deo0f+hd3MSOO66eD1rEu6cxBaFWHD755JP0NPP4TSMMit+YuPFFwQJjekEQVzg5DxFXfHDE7TQWAREQgVIiQMMyPSeq6z2BiAknFu6VNGjGcZzGSpfpTFdD3EjifTN5D43TjLmX8jJdSglrYhKuLJSPFF1WzjrrLBcwRJeuKVOmuJUwIaqSMeF9o/AHbiTYKYmACIhApRBAHIzgi4qddu3auRCKip5ySYT0u+uuu+zOO++0qVOnugCIno84Pp5wwgle+b7GGmsU1CEEsde7777rA2JsLO7pcYblPfvCNh4bfHoulkK644473OVy2LBhHmKkFPIc80gPVIRd8N977709POkKK6wQF2ssAiIgAiIgAiIgAiIgAiIgAiIgAiIgAmVHgPoQEm3rSsVDgPY6XOevvfZad3Q844wzvHNidQLh4ilB4+QEowYi8HQMrkmtW7dunEzoqE6g2jCOaHj23MtCaIiU3XTXTNvgH39WDLohlzWzi89bwK6/3qxr1/IrNnGBEWvF4eOPP/bpOGZ+fPhQ+uh4s/zyy7t4C6EBQ/xNoz2/y9WNpvyuAJVIBESgmAhEURgCpuTAy3/8zXTyvkyPC1xe4v033pcZJ+cVQ+8DYrvTSE8ceJzONthgAzviiCOsR48e9sADD4TnbFf79ttvXeyFjfE+++zjIjkEYLih0asCgRg9XoiPTiguwjzyrKJ8xwVl9gUXXFBMp1R5EQEREIF6JcA7O85UhIZA/MW9slQTFQSE5sUiffz48V4mKgt4FuDClS18Rm3LSqeW559/3u699167/fbb/Zmz1VZbWffu3Y2Qw/na1dc2H4Vuj8MZ552wx5dddlmhmzfq+rfddpu/C9Dph5CNe+0VKhqUREAEREAEREAEREAEREAERKCRCbz88st2//33e4ej1157zaPU0PGUti465NLhlk5IW2yxhe26664+r5GzrMOLgAiUEAHquk488UR74403/L5ChBOinZSzW3+xnx7aqzgHN9xwg9GJ9pRTTvG6tubNmxd71osif6NHj/b6U56fRG5TajQCk6oVe4XICnbTiJTddm9lCb3iKbl8YDO78uJmofGhSehNHucW/5he6jSA0wjEDYtxcmAZjeoxEfYEcQC9qhFvMTDNvCjm4qFTrI0esRwai4AIiEC5E/j111/dHQzhVxSCJcdxGkFvTLygJoVgcTre3/mNU0xjuoT9/vvvxhBfpnGM5LcExPEsaiwCIiACcxNABIvwBwEsYqn6EEXNfdS6nUOF1+mnn25UDuDe1bNnT688j66PdXu07HtDcE1YweHDhxuVFfRII0xi586drUmTJtk3aoS5iL9pYKAS5cEHH2zU53Yhxf/www9dqE3ISQTbiLprGq6gkONqXREQAREQAREQAREQAREQARHIRYB6RxyHL7nkEhdg0HEWMRffW4i7cHWhkxBO0bSt0VkI92nayPhWPPXUU9XAnQuu5ouACMxBgHsJQzIVQwf9ZH4qZRrnf0wEuP9z3z/ttNPclKBp06aVgqDW5cTMgWclkd3oQKvW2dwCAABAAElEQVTUqASqFnuNGmVBlWchdONPZR26sbpT0P3IBe25p+azGTOa2JJLVrd2/S+n5zshqxBxUXGeFHRFYRchw1iPRM9pGvRXXHHFtJgrU9SVb9ze+i+djiACIiACIlAXBKiIiMIvxskBwS+/iUMenxVUVFCRkSkEi4KwOI5irLrIo/YhAiIgAiJQewL0CiSkY5s2bVwARCeOUkjvvPOOC38ee+wxI1zveeedVxQV5fA899xzPYwkLpQIwKi8aOxEpSDCPnqX08hQCk5uiOiuvPJKO/vss/1b9PpgmY17mpIIiIAIiIAIiIAIiIAIiIAINCaB5557zqMMvPXWW3bggQfasccea5tuumm1nX1mzpxpd9xxhw0dOtSmT5/uEQv4li3FjleNyV/HFgEREIGGJvD6669b//79XZy08sorW+/eve3ggw+2+eabr6GzUvLHGzlypB122GGGE+aaa65Z8uUp8QLkFnth+rTWWinbcdffrP9l/+8OUuIFrlH2f5pp1n6rhW3bbeaxEHmi3hOuLVHAhZgLAVcUdkUxV1QAx8Z5xFtRzJWcZh6OXMXUI73eAeoAIiACIiACeRGgBxsuIVH8FQVh8TdjluMWGRPW5Qi/ovgr27R6pURaGouACIhAwxDAFWv77be3Lbfc0u65556irqhAZIwA6IwzzrA11ljDw/kVowBoxowZ1q1bN/v3v//tYiXcxxrSbSzzyqEBAhc0hF6rr7565uKi+801edRRR7ljGxVonG86ISmJgAiIgAiIgAiIgAiIgAiIQGMSuPbaa6179+62zTbb2HXXXWerrbZawdnhu5bQX3wn0h6H8zIOMUoiIAIiIALFRYD6qQsuuMDGjBkTdC9ref3U/vvvXzJu+cVF04yIPERE2Hrrrb2DbLHlrwLzk1vs1auX2Y03/mVPvPiDtVyoAtFkFPmRcfPZUQe1sClTLITOyFhYg5+//PKLoSJ9++23DctABnq3M6ZhPTqt4KDCyyKhWRBuMcRpxjSyS3VagxOgTURABERABPIiwPPom2++cUEY4q+kECw5/dNPP6X3x7MrUwSGY1hy3tJLLy0hcpqYJkRABESg9gSmhA+Vdu3aWfv27b2ncWOG5s1VGnpBd+nSxcaNG2dnnXWW96Ir5m8ZbMkvv/xyz+v6669v9913n3ekyVW++ppPz8M+ffo4N85xMSc6JfXr189DodAzHjevtddeu5izrLyJgAiIgAiIgAiIgAiIgAhUCIGBAwe6QAv3Yb5bamuSgFnDrrvu6g7MzzzzjLffVQhKFVMEREAEipoAnTfPP/98Gzt2rOHcf+aZZ9o+++xT6/t+URe6ATKH0Bk3zDfffNNwSFNqdALZxV4h8lMI45Syk8/8xboe92uj57JYMtCxfUv7+7Lz2tj78s8RoSsQdb3yyituZ4e1K73E33vvPaPxgEYYRFurrrrqHEMUdSm8Yv6staYIiIAIiEDjEfjhhx88NGRVgrD//Oc/6QzSuE+Pt0wRGIKwOI/lxSwCSBdGEyIgAiJQJAQmTZpkO++8s+27777eu6q2Fdd1WawPPvjAK8EJM0xvOlzISiUR2nH33Xf3DjkI1XAka6h07733WseOHd0Njd7nxZwmTpzobmhfffWVDRgwwCt/iukaLGZ2ypsIiIAIiIAIiIAIiIAIiED9ErgthO056KCD7LLLLrMTTjihzg72/fff23bbbecCAgRfCulYZ2i1IxEQAREomMDTTz9thNd9+OGHPTwvnU332GOPgvejDeYmQAQg6kSpe77mmmvmXkFzGoNAdrFXiKphZ5yZsudf+95atGyMfBXnMR+8dz7r0XVB+/DDJsGdZO48Eg7r1VdftalTp6YHRF64eNFYzT/AOuus40ObNm18jMirMcOBzF0KzREBERABERCB+iGA2wehIpOOYMlpln3xxReGUJpEAzGhiJMCsCgEi2OWqRKlfs6X9ioCIlCaBCZMmGAdOnRwoQ2uVMWQcC/eYYcdbLHFFrMHHnjARb3FkK9C8vD11187V5yZCdGx2WabzbV5dGeuK4ETnYQ233xzO+CAA4xQI8WaZs2aZb2CNfjVV1/tjIYMGVKS57hY+SpfIiACIiACIiACIiACIiACtSOA+QLOLocffrhdccUVtdtZlq1x+NokhARCUIDriZIIiIAIiEDDEnjsscdc5PXkk096mF5EXjvttFPDZqLMj0Z938knn+yR6miXUyoKAtnFXtttl7LFl/ndLrtmVlHkslgyEQSLtuFqi9hFA5vYcceZN1Y/99xzFocXX3zRaMim0ZkwHxtttFF6IHSF3EmK5UwqHyIgAiIgAsVKAKHX559/XqUojHDHPG9jWnjhhasUhCEMk1NmpKWxCIhAJRAYNWqU7b///nbOOed4+L9sZaZDygILLJBtUZ3O++ijj9zFa9lll/VedYsuumid7r8hdwazzp07+/ff5MmT0w5fPJNuueUWD11IpdIyyyxT62zhmEkYRJ5fOGbNP//8td5nfezgiSeesCOOOMLI7+DBg+3AAw+sj8NonyIgAiIgAiIgAiIgAiIgAiJQYwK77LKLt+e98MIL1rRp0xrvp6oNR48e7S7bfCvSaUdJBERABESg/gk89NBDLvJCq9GuXTsjTO+2225b/weusCPQ0XO11Vaz/fbbz4qlc3GFnYJcxZ1b7PVriNq44IIpGzT0Z9urc1A3Kc1B4KguLWyePz+y6dO384ZowjDi0sXLGwM9vNdcc02bZ5555thOP0RABERABERABOqOwDfffJMWhGW6g8XfNDzH1KxZMw8bWZVLGI3zctuMxDQWAREodQLXX3+9h9S7Mtg29+jRY47iIAa79NJL7dlnn51jfl3/mDlzpm211Va+26eeesoQ55Z6QvC1/fbbG05fVCjBkjAghKfE2eull17yjj+1KSf7wZ2NzkQMCOWKLVHJ07t3b7vqqqs8r9i314XIrdjKqfyIgAiIgAiIgAiIgAiIgAiUNgE6z+A0/fjjj/u3XH2WBqEB34yEc1QSAREQARGoHwLUm91zzz12/vnn27Rp02y33XZzkVc2F/76yUHl7bVfv35el0z0BhkrFNX5nzRvZnZef91C+KQmts56f2Qu0u9AoE3gMnbUCta9e3cXd2288cbWokULsREBERABERABEWhAArxQMuCkmSv99NNPaUFYZvhIKngQhX311VfeOM8+EGovvfTSc7mExZCRjBkUNjIXcc0XAREoJgJHHXWUffvtt3b88ccbblpdunTx7OG+xDwqRhB7bbHFFvWWbY7JfXbKlCllIfQCFG5oCJyoxKfTD+mPP/7/2/nLL7/0ebX506dPH3dBwzWrMYReJ554ojt0EYYkW5o0aZK7eXF93XzzzelrK9u6micCIiACIiACIiACIiACIiACjUlg0KBBLvKi0059J77lcJSZOnWqR/2p7+Np/yIgAiJQSQT++usvu/POO+2CCy6wGTNmWMeOHT107oYbblhJGBq8rNR1XnLJJXbGGWdI6NXg9Ks/4Fxiry++mL3Rssv9Vf3WFbjGMoHLF180s9NPP70CS68ii4AIiIAIiEDpEECMjdsmQ670+++/e9jI6AaWHOPO8uCDDxphI3/F+vR/CWeaKPzKNV5qqaXk8hmBaSwCItBoBE477TR3nDr88MNdbEU4iQsvvNDzg5MhoqX6Entde+21fg9FsLTiiis2GoO6PDCitYEDB3rvQRyekyIvjoNo+Iv4QV3DA993333eMxGnrPo6N1Vl7f7773c7dvIxffp0a968eXr1n3/+2St2cIvbfffdjXPcGGK0dIY0IQIiIAIiIAIiIAIiIAIiIAJVEKCeb9y4cS4OqGK1Gi96//337dVXXzU6nMaBOkHMIjbYYAOf9+OPPxpDp06d7LjjjqvxsbShCIiACFQqAerfRo4caQMGDDCcpQgliOhrnXXWqVQkDVruvn37er3yCSec0KDH1cHyIzCX2Cu8k3hq0TK/HVTaWoS4nDWrSaUVW+UVAREQAREQgbIkMN9887kIoSohAu43MWwkDmFJlzCmX3jhBReE4XASEyIKGsCXW265OYRh8Xcct2ypF67ITGMREIH6IYC4i3sYlcrcs2KiouSuu+5yYc+SSy4ZZ9fJ+L333rOTTz7ZevXqZVtvvXWd7LMxd4IweI899rAJEyZ4uF+eC5lCL/LHvb82zl5vvPGGHXzwwYYrW7du3Rq8yAjVOH6TJk3so48+spNOOskQnZGefvppQzTItXTTTTfZIYcc0uD50wFFQAREQAREQAREQAREQAREoBACY8eO9cg8e+65ZyGb5b0uHUTZN99QdAiiAxDpxRdf9PrCP//803CiIclAwjHojwiIgAjkTeC3336z4cOHe8dVxLvUWT3wwAO2+uqr570PrVg7Am+++aYNGzbMrrvuOo92ULu9aev6IDCX2CvUWytVQSC8syk1EIHHHnvMeBmPiTAihIJhXs+ePf3GstNOO8XFjT6m5wYxgnnQPPzww+6iQKZoDPrnP//pN0EcYrIl1nnkkUe8AYle9G+//bZ/IGRbNzmPsDhnnXWWxyTecsst7cgjj7T11lsvuUq1008++aSroYcOHWqrrLJKtevTSEgeKQtxkEu9N0o+56daKEWwQq5riDA88YOSbHK91HWDbhEUX1kQgXolQIUN/zcM9MrLlX755RcXfXGfzBywb8cthUogPlJiwn0suoNFARjjOLAM0dj8888fN9FYBERABAoiMGvWLBfufP755+mwtckd8MHeu3fv5KxaT59yyim20korWb9+/Wq9r2LYAcJg3qkeffRRo7K+qlRTsRc9vffaay8PDUmozYZOvEseeOCBoWPTLL9OKCfOXXxvIfS64oorbOeddza+HXhGKYmACIiACIiACIiACIiACIhAsRPA1Yu2Gb7p6iNttdVWLjqgPSdbh6B4zGbNmlnbtm3jT41FQAREQASqIEA7y/XXX28XXXSRdzqk8yHRC1q1alXFVlpUHwQQKrdu3doOPfTQ+ti99lkHBOYSe9XBPrULEagTAjilECLk0ksvtQMOOMB4ISZhjfvhhx/6uE4OVEc7oYGGMF98QMycOTO9V4Q2WPnSUM907N2RXiFMMJ/e8/SS/+GHH/ISetEAQ+MLXEaMGGGjRo2yffbZx1DZZjtG8njJaR6YuBTg7JBP7xLU0wi9HnroIdthhx2Su6qXaRqeEFoUmvLdLp/zU+ixG2P9XNcQtppclwgkOc9HH320xF6NcYJ0zIogsMACC9iqq67qQ64Cc2/6z3/+42IwhF+IwpLj1157zX9//fXXaaEm98DFF198DgFYFIMxjg5iSy+9tLvK5Dq25ouACFQeAe4lvC8Sji+bSInKaIRFVJgU8v5YFclJkyZ5BwjeFeurQr2q49fXsvbt29uYMWOsY8eOWUVzHBeeNRF78WygUwvfE48//nijCHz55iLkJnmJiecPAjC+Y2644QY77LDD4iKNRUAEREAEREAEREAEREAERKDoCUyZMsVD0ddnRql3pw4+2zc3x8Xxi+9ydeSsz7OgfYuACJQDAUxVrr76ahs0aJDXkeF6f+qpp3pn+XIoX6mVgc6f9957r+sB6qreuNQYlEJ+JfYqhbNU4XnkRXiZZZZJUzj++ONt77339rBb6ZlFMEGDe9euXd1x7N///nc6R7zM07ODG2GumyHrsC12lIjc8kl8qLz88st22WWX2dprr+1uA8TNff75522LLbbIZxc1WmezzTazI444wm/uNdpBARvh7kaDYaGuEAif2rVr525psK0q5XN+qtq+WJbluoZw1SBts802LvYqlvwqHyJQqQRoOF9iiSV8WH/99XNiQDCACw9CsOSAOAxx8HPPPefzv/vuu/Q+eMYstdRSaVFYFIFFQVj8jSisuntjeqeaEAERKFkChFKkBzNC/ap6GHOvwZm2Q4cOdVLWPn36+HvYLrvsUif7K6adEJ7j1ltvdQFUUhQV88g7KLwLTQMGDLDx48fbxIkTG8U1a9q0aS74yywTv2mwwGH5MAm9Cj2tWl8EREAEREAEREAEREAERKARCRCmnsgohUZCKTTLhBU7+eSTc4q9+K7CxVlJBERABEQgOwFMUOiMSns3UVGIKMV9lbYOpcYhwLOLyA2YvpRjHW/jUK2fo0rsVT9ctdd6JrDiiivW8xFqvvt5553732qRRRbJa4dVCcIyd0DjPymOcU8gxBjCr0JSFAMVwrQhRAK4t+EkcNRRRxVSHF/3jDPO8MayzAarXDvK9/zk2r6Y5hdyDRVTvpUXERCBOQnwLFlhhRV8mHPJnL/++9//+nMgmzAMoQe9L3hO8MEUUxSFRfFXcsx0HBCFqddhpKaxCJQeAQTzOAlWl3ivI0RfXYi9XnzxRXeHItxhuab999/ffv75Zw+fnq2M3I8LSTh5nXPOOd5rkRAgDZ0oS6dOnXIeFqEgecQNuCbv5Tl3rAUiIAIiIAIiIAIiIAIiIAIiUI8EiBBDWmONNerxKGYLL7ywt2PQMej333+f61h0Ctp1113nmq8ZIiACIlDpBKi3ROB11VVXeYSnHj16uFPiYostVuloGr38t9xyi2FsM3Xq1EbPizJQNYG5VSlVr1/jpa++9JKNGzvWmrdoYdvvuKPdFsLVvRfcjjofdJB13G+/OfY7IYSIezgM34SwI23WW8+ODk5OCy20kF0bQvq9GNyMSGuvu651CkKQAaHn+O9B5UnaePPNrVv37vZsaNgccd119rfQUDpo6NB0+D9fqUT+4NRBWL4nn3zS3nrrLdt0001t4MCB1iLwI9H7+s477/Se361CjNo77rjDPvjgA9t99929VzaNNvmsQ+U9vcgJy3H55Ze7cpYwL8OGDbPll1/eaETmJouDCDFy6QXBzRaXEBqRCfnCPnAqoeFj3333tTfeeMP69u3roeMIGbfzzjt7nrH6YyC0yUYbbWS9evXyF2FfWMAf9s+LM+KkZIPD3Xff7cy+//57W2WVVbzBinAr+SR60+OUReJaGzJkiLOO83lhJ8Ridecl27HgRthD8jx69Og53FQIlQJrPjw23HBDjz0My3wSocJIhF9kunfv3n6uCNeD80tMf//736vkvPLKK/uqmWKvyZMnewgeuHDdHXPMMbbHHnvE3fqYnv5jw//1bbfdZrNmzbKDwv8z10Eyce2MHDnSrwuEC1wP+/3vfz7X9XfWWWf5BxI9b7hmECoce+yx7iqQ3He2aYRe/K+QjjzySL+OcQbLdZ0TGi3b+SH0IfuhoRRhBP+DuBpQBljhzEPCSY3/Hf7/1lprLV8Ptx6YxV5DVV37iNpuvvlmv0+xPi82qKRxsONc0vj6Urh/tmzZ0mMix/8nP3j4U5trKO5DYxEQgdIlQChfnnkMVSWeRdxLoyiMcZzm/sU9n99JpzCeR9wjo/grjnHbZOB3nObZqSQCIlBcBHBiwonqvPPO89DovM9kq3jmfQ4xD060q6++eq0KwXvLBhts4I5itdpRkW+Myy0iKb6LMhPvr/km3tkJV08odt79GiMRcgTHyFwhR2KeKOv2229vq622WpylsQiIgAiIgAiIgAiIgAiIgAgULQGcvUgN4QxD2wXtR9kS38h0qFQSAREQARGYTQCdwCWXXOIhGxdYYAHXC3QP+g61MRTHFUI4zdNPP90Io1lVdJriyK1yYcH5Zo50113Bly3M/eDbb+tseGTy5NRGm2wS9muppZZZJrVG69apvffdNxX+aVOhITF136OPpo/V/eSTU5ttuWVq9EMPpS68/PJUcLZIrbLaaqk3Pv009fonn6SWWHJJ389TL73k29w+dqz/Zp/JPLOPM/r1m2NecnlNp4fcONP5zAGtHn4EkVIqNLakgl1h6rXXXnNWwQ7WjxTEHakglvJyL7rooqnwspgKDQ4ppmEcXixT+azDzoJzkm/DduwzuDz57yCcSgVFbWrddddNBYu+1CuvvJIK7iCpIHJJBRckn2b7IPTx9dkumYK9YipY06ZnBfFOarvttvPtQq/w1HzzzZdac801U6GRJL1O5sSFF17o+w7is/SiIJjyPJHfM888Mz0/NFKngtI39c0336RCg3YqhKxJXXrppenl1U0E0VEqiHn8eCGUYnr1H3/80a/RIJzzeVWdl7hRCKHo++F3aOxJHXLIIX4dk+fQwBZXSwWBTyoIeFIhbI5zCIIk36558+bpdaqaCA0yqSA48m04T6+//rqvHgRKqeDE4vN33HHHVAj1WNVuUsF5wdcNoqP0epzr0CCYCh8oqSB6Sv3rX/9KBQFh6s033/R17rnnHt+GayGIxfwaiccMwqf0foYOHep5ufHGG1NBTJAKAj/frnPnzr5OruuP9fv37+/rhobKVAhpkwofZ+n9VjURxGV+bcGb7fid6zic61znJwiuUhtvvHFq5syZqSCo8+uAfYZGrlRoEPUswIl7VBBbpoJAIrVluO+wThBK+n5ZqaprP4SpTAXxmG8ThGKpINbw/43w8EwFMWUqiPhS11xzTeqZZ55JtW3b1tcLwsx08Qu5hs4//3zfnvuJkgiIgAjkIhBE3qkgQE7xXB0zZkwqCL79ect7BvfFIExOBYGXPxO438WBZxf3sOBKkwqiBX9ucN8JgmZ/zgW3n1QQNczxHMyVB80XARGoewL8X4dOGf4/y7tL/N+NY97NTzzxxFodOAj/UwsuuGAqdJqo1X5KaeP4vRI5Mub7lvf06hLfebw78g7I+2ZjJO7zybxXNx06Pug+3hgnSscUAREQAREQAREQAREQAREomABtDLS/NFQKEVfSbQjx24pv7XPPPbehsqDjiIAIiEBRE/j4449ToTNhKnRg9zaGIPhKBWFRUee5EjMXjH5cc4LmQqnoCTzZIGIvhFVPhkY+XnBWD5XZM8I/M/POC//EzDsrNAby+8Enn3SByeQgLIpirG2D0Ih1+gfhDvN6nHKK/74kNCLEddYNYieEKC8EIQrzpgfRymKLL556JYhL4jp1NW4IsRcCqKZNm7pgKV5CiE5CL+r408VccKFRNdjA+nyEONwgYcENE8FXdeuwISIs1gs98b1hItjy+bhr167+cpoUASFyYV2EaIiASAirmBccjvw3f2gMfvbZZ/03QinyFHqMp5cjmmKba6+9Nj0vcyI2niTFXqwTwhX6tkmxV3CdcuETghvSU089lWL7QhLbkCcas2O67777UuSVlM95Yb2k2IvfpCgki2IvbpDBLSwVevLPXiH8Zf8IIPMRewXHJxdYsT55RjgX980OEQsFF668GpreffddPz8I3mI6++yzfb80zpMQpHGc4NDlv6PYi3MfE6xYh3IhknvnnXf8ekQgkEzbbrutrxdFdbmuv3hMRHCFJv5faGhLplzHYZ3M8/PCCy94Hvv06ZPeBdc05QvOOOl5wUlvDnaRQVA7+zr5XPsI0thvcMtzoSL/uwx77713KjiTpY/F/xPrBScdn1foNSSxVxqlJkRABOqAAEKG4ASW4j43bty4VBTp8rGGoHebbbbx95bgcuj3Lu5fDAiJQ4/KVHAy9OfroYce6kJgBNoIuhHB8tznHhffb+ogu9qFCIjA/wjwns/3Q/x/jP+bjBFqIdiqabr99ttdBE9nh0pK8b05yTKfTgrBycuZN5YQn/dNGj54Z07mPTlNwwS/6VTUpUuXVHDzrbKzTiWdd5VVBERABERABERABERABESguAnQAZG2ioZKdNqm3iv5TcV0CIHVUFnQcURABESgKAlgbkG7KaYhGGAMHjzY20OLMrMVnqkQ+cHP05VXXlnhJEqm+E82WBhHwgyRlgsh5ZovuKBPr77mmj7+zzff+PjeEI6O+NXdDj7Yf/PnlxAeY8UQpnDmjz/6vAMOOcSGXHqpjbn9dusUQl6QCLdG2Im7QyjDbiG8xN1hP+1CGLRStfvDsjBU+ltocLEgmjHiohJWhZCKMbGMRNi3UEHv08QeJ4wiIeEIxRjDzFW1DqEaCclICk5cHq4uCGUQAXqYSEI0JcP7hcZbzxf54RiEY8RaMTTOWhBueQg74rdyHjcPYTVJhPDj/ATxiv/mDyH/CD34ww8/pOflOxGEcHOtyrHCy7SHQiR8DOEGscctJG299dZuRzhhwgQjtF5wK/MQi4QvJOVzXnIdLzPPoTHMy04olJjYf3Do8pB9cV62MSH9OFeUmdBbhH8MQj8P9xcc1Ty8ZhBaWRAe+fnMto/kPMI8MgRBXno2YRQ7dOjg55cwhbAlhUah9DpMdOzYMf2b9bmePvnkE79+gxuVX7PxOogrEoaQ0IiE3SS8ULbrL67LOF7fyXn5TGduV9VxMs8P4RNJhFCNabPNNvPQqN9++62HLmM+63FtB8Gc8f8Xy8o6pHyu/ZivICr0UI4wDO4OHkIzOKelrweOw/8MIZi4F9TmGvLM6Y8IiIAI1IIA96IYwrG63fDMJ0Qk9vlxnJx+9dVXfRmhzwjvG1MQGbjVPsfB7j7bOM7jfqkkAiJQPQHe84MzqQVRvZ100knGOyPv/STCvfJ+QRjsmiTCVvNuu+SSS9Zk85LdJvTS9m8bQnFHltjRVxWmgzDsfLMQCj30/m7wsvOtRvhIznnMM5ngvkuoT+7xhDDnm4p3d743Mt+tGzzTOqAIiIAIiIAIiIAIiIAIiIAIFEgg+b1T4KYFrx6ii9gJJ5wwRzse38d8TymJgAiIQCUSoO16wIABFjp5u9YgRBGx0PnbguirEnGURJmpLw6GP0Z4YqXSINBgYq9sOJLiEpa/GwRELVq2tAcmTsy2us9bLgghtt9xR3ssCHI+eO89ey80UPwVRBAtF1rI7gqV5Yi9Rt54o10SbhilnIgj3rdvXxdRhZAqFsJ7pEUfVZUrhFDyxd9//31a7JW5fnIdllGZT0qeDxpcEZyEng++LP4JYV8M0Utw+HIhDGIvGgGCEtdCKDsLzhwWwjTa0UcfHTdxIRLCu+CWlJ5X1xP77befBSczC2EHbc8997SddtrJhTbBUaSgQ4VwhR6DljIcd9xxFkIgWnBvSu+jpuclvYP/TcyYMcOn4rmIy2lEqa4hBbYhFJY3EIVe9nbxxRe7yA+BVgjbaMElwOMbI1bLJyF0QhCYTDxouYZCqBYXzQW3M28UTK6TbTo4RbhIEBEUjYekeH3F9RHVkaKQKi5PXn9xXcbV8Uium5zO3K664yS3RdQIlxDi0hvvEFe+8cYb1ioIT4OLWnrVdu3aGWI4hHWnnnqqhVCavoxGMRIvMtVd+9nyFdkEpwhviPWdZfypzTWUsSv9FAEREIF6JcA9NLiT+lDVgaiACyGkXfiFUAJBWHKMmDg4Tvr84PzlYtu4P55bPKMRVzAkpzN/I4aP9964vcYiUGkEeL/l/S6Eh7YzzjjD3/sQlodw3DUWewW3UqPjQSWmQYMGWbCdt+uuu86Lz70rV+KdEkEdHWYQXDVGCmHfXfTHsfm+Q2jLfZPvOq4L3nEzvwMbI586pgiIgAiIgAiIgAiIgAiIgAjUlADfNLRx0dmlIeqBgnOyHRLMKkJEE+9EQ2eapAFCTcuh7URABESg1AhgFnPBBRcYnR0RDlH/iCCWOiil4iWAGc7999/vbeM6V8V7njJzVlT/VQs0b24/hZcvRF+rhn/+ZPo4OC2t8D/xykGHH+5ir9tGjLCXgoDo5NBA8VxwERoRBDrXDR7sitD1SlgtT0MLDl0h7KGF0IK22GKL+Y0wySPXdBSbcPPM1WshuU6u/SAi4h+ZhtXochXXxQWKFHurI9LB/SqEVfQGjrFjxxoNCDGFsITuUIbwJSmUYfn7779vK6+8cly1xmMaKHiJRmRDI9PDDz9sIYyUC8AK2elBBx3kQqkQjsrLj8I43tBqc14y8/Dbb7/5LNyvQijEzMU5f+MgNWXKFAshCdP8KScNM9yAt9xyS3cno9GukLTPPvvMsfro0aNt//33tyFDhrhwD3FfPokPGhLXX3R1wD0i6RCRef1Ut99M0VZ168flNd2O7REmhHChLvRr27atO5whgAzhK9PXA+vBGdEV42BDas8995xfPyF0JYutptc+25FCqCUfJ/+EcJ/+kVrTayi5L02LgAiIQDER4L6NEIuhTZs2VWaNijqExQgqMgfu1wjFEGyzjPVwqomJCj6OkRSGIXJIDjzD4lCqTrGxvBrXnADvqbiR4rjLdcUzuBxTCLHtAnVESFTG8G66+OKLF1RUHPwQYT7yyCP12sGjoEw18Mp8e+GIzDccnTDoPJIt0VEAgSpOh3zzNXTCgZZ3+3jPxckZl0QaQnCVvvPOO32oz3zh+s19uHXr1kZnkcZwN6vP8mnfIiACIiACIiACIiACIiACjU+AdjW+0/gG4vujIRLtZLETEHVRtNsoiYAIiEClEKCj9vnnn+8GGdTv42hPG3ZDCG4rhXF9lZNnFu6UiJQL0S3UV3603/wJFJXYa+0Qwu7BEP7j4nAjuDo4NEWxxouhQvyGEEZuaBDzkNqGnsZ/Dw5fw4IQpVVwsmofeqYjDkPs1b9PH7sw9Egv5UR4u/Hjx7tDEy+kJBpQcom3kmV9Irhb0chAOMBXXnkluSg9nVwnPTNjggYIwiDixkUj18GJ0JrMI+RgMkxi165drV+/fi50QdiTbBhlPdS7iMFGjRqVPq+TJ0929wCW1TbhyIXADIcv3K24ET355JP+Ih8Z5nMMRDaEFsTVgJAshEmMqTbnJe4jjqOTFg1i55xzTpztveppwM6VaLgmTZs2zcOucB5IiNNoJKFBmx4jCIGiSA2BGIK6qh6mlDmZYIm4DZ4krj9Sddcgjg64tyD2wgGOxPWTTNHhDWFaVSn+/xOmtdDEtuQfEWDkUOg+EG8RpvL000/3xi/c6zIToW9woeHawKUNV4co1GLdml77hGvElY7/l169eqWtnrk26B102mmnpd3YCr2GMsug3yIgAiJQigR4pkWxVnX559n13XffpUVhiHaSAjF+c89nzIA7TzLxTkSlYBwQwTDNODnwvsFvxoSVzOVYmdy3pouPAO88dCBAqMO7NKIU3rEQw8Qw6sWX69rliHelddZZx8NFI2zj3ZFruZAEGyoD4vtbIduWy7qUndCHvK8RcjtXIpRmDJWYa536ms/9EFEe7+EIXGv6nlzb/HFPpiMQ/2fcc3n35RuyW7duBV97tc2LthcBERABERABERABERABEShPAsuHNkTSxx9/3GBiL0I20ibw0ksveScfNZiX57WlUomACMxJ4Nlnn7XzzjvPxo0bZ//4xz+8zZQoXJVcTzgnoeL/RRQxzH84h0qlRaDBxF5fh8Yz0szQWzimT8NLFun7UNlLOjC4KA297DIbHxyKugSRxS5B9f5GcM2ZGFyaxgTxU0w08B0QxCmXBFHYMSFkHb/XCL2CN958c3sjNFB0yHApituVyjgKpQiLuMMOO7hb0NSpUz37OAshpomJXtlUkEdhCI2XN9988xzxbqtbB4EQiYbO6LrEb0Iy4iA1OLilobylsYt/dHr9I+zC/SsmGgtYh7i7yRCOLKfSnpi8Y8aM8fCKuEjReIZzEs5WhSZ6nJPoNR8Twh5i/aIYppEVoRGNKDS2FpqIQ3vFFVd4CBOEczHlc14Q2X322We+CVyju1Uyz4iCDg/udFhY4nqFmAdGiN9whiIhGurSpUvavctnhj88JGmUYX/sA9cAykh+aVSm7IjcEJMRzhEHittvv93dwGiszpaGDh3qQrxbbrklHbIyNvyw/7bB2apPEFGScBUjZGFMXAsx8QBAHMd5JS+77babh4AhFCJiKIRTJISMNJJTblKu62+55Zbz5eyvQ4cOLhojVnA+iW1pzMIaFPHb5uHekOs47C/z/ODkwXVMGRCwIeDif4yGKBroYjrllFP8WkaEhzsDQjb+F2joo5E0n2s/ma+4X85Vz549rX///v4/SLm5/vgfonGO8JqEdq3JNRSPobEIiIAIVAoBPip5PjLgIlNdQsjLvRlBBOM4ze844JLKNIJfeohmCpM5Ji45HJP3pULG5Sooqo57Yy/nveHaa6+1vn37+rs11uKXhe8SQjvzLlFJiW+CzFDjlVT+2paVbxDcmfmOU6qaAMI4vi/o/HPJJZfYhRde6N8IhEfP9e1S9R61VAREQAREQAREQAREQAREQARmE6ADPO0cb731VrozdUOw6dGjh3dm4ZswdtZviOPqGCIgAiLQ0ASeCAY0iLzQIdB2STsxEbiUSosAdcHoKzCnadWqVWllXrl1p57QtvH/6a67QktHkEl88O23dTZMmjo1FcIqhv1aKjR+pbr16JEaM25cavkVV/R5LRdaKDXwyiv9eEHUlVpqmWV8PusHB6/UbffdN1deprz+eiqEdUy9/eWX6WWXXXNN6uAjjkj/rssyxH0NuXGm8zn00FRqwIBU6u67U6nXXkulfv31/xnWdioIl1JBZJIKIrZUEF+lguAjFcQ8/juIeFJBUJMK4d2cUXAbSoXGmNQWW2yRCuKS1NVXX50+fHXrcJwQqi8VGrB8X8GNKTVs2LD09kyEkIypIFhKhd4IqRNPPDEVhGap0AiWYtvMFMRKqdBzIXO2/2ZZEOCkz+tK4dyFm3/WdePMUNnv64dwMnFWKgi6vLxcG0H8kgqCIV8WGuT8d3AUSIUQeqlddtklFYRk6e0Kndhpp51SQdQ0x2bVnZcg1EoFW950GUNInNQDDzyQCuI2v+7JcxAdpYIgyPcbBEKpINjx9YM4KtW+fXv/vdFGG6WC0C71/fffz3H8+COIslJcB+yPITQip0L4yVRwI0kFJ4bU1ltvnT4e10YQCsZNs46DLaPvJ4j60stDSMhUcEzxayM4paWC9WYq3OBT4eMkFQRGqdC4nQquX6kgNPNzHsKvpNZff/1UEJql98FE6LXv1xjbhZCYqQMOOCAVnCNSIfShX0NVXX+h4TxdziC6S7366qtz7LuqH0F06Ay433Ddktds13kQL2Y9Pz/88EP6Oouc4ziI1tKHvibcc+L85BgukUVV1z7/X8lroFOnTn4eOUBwZ0sFhwP/v2fffu/s1i0VBHzp4xdyDYUHtec1OHakt9eECIiACIhA3RAIwvsUz5TgvJl67LHHUsGZMRWEQ+FdcYC/qwQH1BTPj+23396flzzXgog46zMkCBxSwUXKn5dBaJTaa6+9UmwfXB1TQQyRGjFiRCoIof1dkGMGB6G6KUQF7yV0IPD3p1AJnAoC61QQ8lUwDRVdBBqHAPdR3leD4NXvf4W8+zdOjnVUERABERABERABERABERCBhiRAewH16aGzfip0tvb2ML7jk/XypTQdOph7m8vuu++euuiii1LB/bghcepYIiACIlBjAsHUI0W7MPdc6rura++v8YG0YYMQCAI9r4ujXVqp5Ag82YQsh3/GdApRw2zffc0++Ha221Z6QQNOkKUPg7MOrggrBgUh42zp2+CmsFgixAgh23Ayig5M2bap7bwH753P/nVEi+BQZSH0BO5S4U4WCAYjoxAqz4Lbjtmaa84e4nQw+qlRwm0oWZbkbxyEcPfBhYoe0F988YU7fuFyFlM+68R1qxoHkZPhYDFz5kx3jKrKcQKXC1ybsiXOK2FhOJ+4BeQ6r3FbQgkSQi+IvTy0TJyfbUyoFJzHcNWiF3iuPGTbNts8XDpw4siWx+R5YNvM39n2V9U88gxTHEAIH4UzVD7p7bff9jCFODxl5vPTTz91FlgGV+dGQY96XNJaZah1cSVgiGEJ+f/id7I3iv+vBrc3HEuS12pm/nE+4TzilEaPmnwTecNNLogDqwxDmW1/XIv8P5C3QhPXexCmuUsebi1c+zi94PiFIxkhjihHEJJZ06ZN7bDgNIjzC/cfnPZwFMPVLTTI+6ELvfaT+WV/77zzjruKtWzZMrkoPZ3PNYQLGE5t5J1wVEoiIAIiIAKNT4DnKuHMGHj3iOPoGMY4DjzXGHjeZIaIw+WTMIM4WzLg1BrHhC3gOUrYy8z3hcYn0Pg5wGWV8IPwwaE2iNcbP1PKgQhUMAGcgglbHjqb+Ls4rtBKIiACIiACIiACIiACIiAClUsgdIr3SCi4cVMvQuSNYH4Q2uHW9DacGKWkmAjdeOONRggzon/kSrNmzfJoIUQNCR0HvWxE2undu7cFY4Bcm2m+CIiACDQKAdo5g+DWHaDQH+DgdfbZZ7ujV6NkSAetEwK47QdjFo+uFcxk6mSf2kmDEpjUYGEcCykWDVGtghioupQUerEuL3VVCU6q218hyydMmL120H8EG9jZwi8i2iEAC66FIQyMBdHH7HWIJBiFX3GMIIxojEGXlDNlliXzd9yQ+bmWFbJOXDdzTEi+Nm3aZM7O+rsqkRXnNRmCMusOsszkZb66hNCLRMNmMmEfee+99yZnzTUNO0L1JVNVAqFM1pm/k/vJZzqZ53yFXuw3OLHl3D2NvMmQnDlXDAsQRLXKEHqxPiKxpFCM/6/MDyf/X82ybebx+KjhQ6XQRN6iOKzQc1nVtVhVPmh4D85uHsKRcJjJxMsMYSwpT3DRs8svv9wb3TkWoruYEAo+HMLPxlTTa5/tCR+JaK+qlM81hFhNSQREQAREoLgI8Jzl2V/I858SIARGIM5ACG9E/wyIfxkQ9jJmOc8uEu9KwRHWn/mIvwhNzMC7GUMuQbFvXKZ/JoQXeoReVE4QzrqqDg1likDFEoGiI8B3Cfb/wX04dELb14LztIevL7qMKkMiIAIiIAIiIAIiIAIiIAL1SoD6jOuvv96C03kwW/ibER4xOJ/n3e5Rr5mrZufB6aYgQwI6vT/yyCN25ZVXeh1Fu3btLEQV8Xqbag6lxSIgAiJQrwS4P40ePdowlAgu7NahQwe/P/3jH/+o1+Nq5/VPADMb6t9CxDST0Kv+edfXEeYSewU9h6dg5uRuVfV14FLdL1xCdMWQ/SZehAUWsOAAMHvILFMwV3LxVxSBMUYIVpUbGCIwNCPVmTvh8kDCwSlXymedXNsWw3wcpBBShRB8xkOjbdu27qRUSN5COMw5RDjZtk06VWVbrnnFQaChziVOdgi+xowZ40IzhI58TIawqPboo49a586d/bqMrirdunWzEGLLXVOIa/z888/bG+Gf/fbbby8KcF26dHH3uRDW1POddP8rigwqEyIgAiIgAgUTQAjMgFNqVYnnGe+KuGQmB5wqqUT8+OOPjQ92EoIzhOStW7f2AREz0zVx16wqT8WyLITfthBa05/r9LjlWa8kAiJQHAToYHLVVVcZroVHHXWUjxFmKomACIiACIiACIiACIiACFQGAdzPqdemQ/VJJ53kEStq2+m+IckV2hGdOnvcvBgmT55sxxxzjEfZue666+yggw5qyKzrWCIgAiLgBGgrve2226x///7B9OYtr0MdOXKkrbvuuiJUJgTOOOMMjyAWQgmXSYkqsxhzhXEMbqEWROM27Z3vbdHFZjsBVCaa7KUeeeP8NuiC5iHUzmyxV/a1qp6bdAPDCSyKwZjO5gYWBWDRDezxx8e76AlBCUIlxFCEPEy6QoR4udWuU3UutVQEKpfAU089ZUOHDnVXgRhac8cdd7Tu3bvb5ptv7mAI78hLDq4gWJbSKEWjOGFnEIDJHaRyrx+VXAREQARKhcBvv/3mIYoJF8zAhzvvl4Qz/vzzz70YvGvyfONDngHXS8aEjSzVhAvaRhtt5J0JcICV0KtUz6TyXQkEjjvuOA/nOGXKFIUir4QTrjKKgAgUJYG+ffumOwrgNILLSlXvTzix/POf//Q6ywcffNBdae+55x574IEHvNGe0OVKIiACIiACIpCLAB3UiLxB/TvhpWJ9fK71y3E+nfdOP/10u/TSS43GeBx1lERABESgIQhw/xkxYoQNGDAgmNd8ZAceeKDfhwidq1Q+BDA44fk6fPhwb9cun5JVXEkmzSX2Cu9RwSXA7O4JP9pGmwQbK6U5CJx35gI27fmm9uKLNRd7zbHDjB+ZbmBRDJZ0A1tppf+GcDsMZmusMTsc5CabLDKHGxiuQ9F5KB6CntFKIiAC+ROggpL/o+rc31inadOmRrhGJREQAREQAREoBwI//PBDWvg1ffp0e+WVV9yqG6EUiV6qhBnecMMNXTiFeApnsFJ4FuIWirANsfbCCy9cDqdLZRCBsiVAJSMOz4Sv5X82GWa+bAutgomACIhAERG47LLLPNz1k08+aSeffLILvQjfggt6roQLAB0D5p9/fneS5f3xoYcecmeWmTNnpsOM59pe80VABERABCqXwAcffOChpDA2wNAgaXBQiVRuuukmdzsmhCXCLyUREAERqC8CtHPecMMNbi7z5Zdf2qGHHuqi0+oiS9RXfrTf+iNAB3AiqvGMfQwXKKVSJjC32CtoG2yx4OjV/ZRfrOtxv5Zy4eol7x3bt7SNN5zXrr22Xnafc6e4gb399v+7gOVyA0u6gMVpRGGhfkVJBERABERABERABOYioJ76cyHRjCoIfPPNNy76Qvz10ksv2dSpU23GjBlu+UxoSQRgCL822WQT23jjjY1eX8UkABs1apS74k6aNMkrkKsoqi+ifOeff76Xdemll7Zzzz3XcPusKo0dO9Z69uxphFugN/K0adPs7rvvdjcLQtGdc845VW2ec9knn3zi+8AVY6uttrLevXvnXPeUU07xsNSsAP+zzz7bFl988Zzra0HdEyBUKucqJv4fDj744PhT4wIIvPvuu+4oyPOqV69eBWypVUVABERABGpLYNVVV/V3n2uuucYQcdEIz7zq0vfff2+EpEqG3Np0002NHuR0rFMSAREQAREQgUwCPDt4VlC3MHHiRHXO+h+gO++80511CLOF8FpJBERABOqSwKxZs4Lm4Vq7+OKLjftw165dve5lhRVWqMvDaF9FRIB6Yjr10Iln5ZVXLqKcKSs1IDBp3syNMKbZeecm9uj4+SX2yoDz9VdNbNoLf7OzcrerZGxRdz9DBJ0QNmf2kLnX6AYWXcAYhw539uGHFipQLFirW/hntdDYNntYa63/nw5tVkoiIAIiIAIiIAIVSoCXeoQpyZ76J510UpU99f/66y//EKCnPtM//vijW+uPGzfO6KmvVN4EcPTafvvtfYglJbQCH4cIoxgmT55sNAjSS4gGPkQum222mVfaMl522WXjpjUeYyNOCCGEU/k6/dBAeeaZZ1qXLl3yEnpRwdGxY0cPl4B1OQI2Kj+qE3sRcuLD8CLOmIQjEaExEcfttddeNS4zoaWfeeYZIxxSdWEshgwZEtyaV7ExY8YY7r5yMKsx9oI2pPE6ihsR5K0RbJjjee/cubPEXgXR/P+VERUgYLzwwgvt6KOP1vX8/2g0JQIiIAL1SoDe/Yi75p13dvUxoRvzEXqRqWzRBeJ+6jXT2rkIiIAIiEDJEjjkkEPs559/tqeeekrv/ImzuN9++xmdv0477TSvX9luu+0SSzUpAiIgAjUjQJ0+9Ye4Bv4SHGeOOeYYr3vBoVepfAnQKZn6NdqFJPQqj/M8VxhHikUH5D32SNkTL/xorVb5qzxKWgelGHp5M7vuymb22WdNQli3OthhPe8i0w0sisFC1JrQGDv74ER2jA5gSTGY3MDq+eRo9yIgAiIgAiJQBATUU78ITkKZZgGhF+5fuDdMmTLFnn/+eXszvIwiEFxxxRVdrLTFFlsYA6EgEQ8WkrAVp6fZOuusY7fddlvoFBF6RVST7rnnHuvUqZOHcMynofKWW24xKps///xzD0X02WefuXiNXsbVJcRolDMmQhcRPhJnoj59+sTZBY9xi8ItrH///lU6exGCevfddzeczJQahgC25zjG9evXb64DIkjE1e2uu+6aa5lm5EeASsjll1/e+Z544on5baS1REAEREAEakxg0KBB9uyzz7pwfK3Qa5R3NkT/uIp89913/o5BhxFCY+PCMnDgQHdi4YA0FiFOv/XWW2306NGhE2rohRrSlltu6fuUs5fj0B8REAEREIEEAcIVHnnkkf5NRccZpbkJ8E358ssv2/Tp06158+Zzr6A5IiACIpAHgW+//dauuOIKu/LKK72etnv37kY9C+/6SuVN4Pfff/fOzHQKfuKJJ9IdVsu71GVfurmdvSjyrrvOdoK6OoibBl75c9lTyKeAvwQMw69pGuJjl4bQizJV5QYW2qoshoKMY9zAQrtUuLnPdgNr1cosuoDFMYIwuYHlc8VoHREQAREQAREobgLqqV/c56fUc4d4C0cvhmOPPdaLg1gD4ddzzz3nA+ER//Of/1izZs3sH//4h4cm3Hrrrb0hsLqQgw8//LCHBkJARthIwivSyzU2Jmbjd+ONN1r79u3zdqTAjYsUXSiWW265bLvNOi8p9EruI+vKBcwkHBIpjgvYVKvWIwGc3A488MDwrXhUPR6lsneNSyCufAg9Jfaq7GtBpRcBEWgYAnvssYcRugWXUETyvM81bdrUD37AAQfYe++9Z6+99pq9/fbbLgTD4ffmm2+2r7/+2h0BEOP/8ccfCtnYMKdLRxEBERCBkibAM+TUU0+1Hj16eL1ASRemHjN/9dVXW+vWrV1gna2TUT0eWrsWAREoAwJEDMDFa+jQoR4lgege3HezOfKWQXFVhCwE6DzM9xsdtGNkgiyraVaJEZgrjCP5pw2hX78mdthh89uh3X61tdv8WWLFqvvsXn1FM/t5VpPw0ln3+26MPdJWxbDDDnMePbqBRRcwxqGDegiTM7cbWKYj2OqrW3BlmHN/+iUCIiACIiACIlB8BGJPfVyWcKM54ogjat1Tv/hKqRwVGwHEGu3atfMh5g03CMI+4hyBA8TFF1/si6jARPjFQIiCpHgKNwjEXly/DKSzzz7bGyNpWFyTl9SMhMME1/pVV12VsWTun4QrQjyGSxOpZ8+eLkjDSQxHCvKLSxjCNVy+sDmnQTSmN0JPCpwsyHN14p97773XGL788ksXrfXq1WuOcBXkG2ttwjfiDrXSSiv5YWr6QU4DLL33CC3YsmVLO/TQQ23nnXf2fdIgO378eBfTXH755TZ48GDvMUxITnoOI7JJzh82bJg7LSEchSsiPvKLyxqVRVEchxCKxl9EfSzDJnyXXXax448/PiLLOoYzdvKE3yQE4j777OMsyDuJ88L5yJVv8rfkkkt6RTjnEoEcziOE46TxmvMTey1WdR5efPFFv7Y417uGXlGE8kRkePjhh3tYxnfffdfDmlJpxn5wgKNBnOMo1S0BnPlo4CBEqqzm65at9iYCIiACmQQIRcwzlvT3v/89/VzjWU8vcN7ReDdZe+21PWwx73Iknr0jRowIHUzf8Hcln6k/IiACIiACIlAFAdxleObUxgW7it2XzSJCq1FnMGDAADvhhBNs0UUXLZuyqSAiIAL1R4B6Kupbr7vuOq/HPOuss+y4445Lu/LW35G152IigMDrggsu8Gshn4gXxZR35aVqAlnFXmwSOs2GimyzXj0WtLsn/FjRIp4Z0/9muJxddFGTUGlRNdBSX5qvG1gUg9EGlssNLCkGkxtYqV8Zyr8IiIAIiEA5EVBP/XI6m6VdFhoSGQ477DAvCFbiiHyefvppH2gs/PXXX61VsJxF9MWw1FJL2ffffz9HwRF98dG67rrrurgHIVHS/QqBEI2T22+//RzbZfuBAIhKD0IxIuTBvYJK1VVWWcVFV9tuu63hEsYHMr3gCKUwY8YMLwdiM8RZr776qp155pnZdp+eh0Dtqaee8v3gIsYxcc+YNm1acOhdIIRdn+n5XXbZZT0E0hdffOGhINlBTcReCGR23HFH7zGNaIn8IbpCxIXgE+EX+SdRdlzXEGoRypJ8Zs4nRCehI9q2besNuwjBcG/D4QqB2AMPPODnjnP78ccfB8fgtYzwnkxTlurEXgi5CP8JY8R/iL1wb0NcRwUV4SxZJ1e+uSdDEAAAQABJREFUyd/1occKAreJEyfauHHjbL/99nOHEa4D+MdxrvMAM4RrNGAjXrv99ts97CjniNBVlAnRGOKuM844wxvC4ZUUJzo4/akTAlFYwPmQ2KtOkGonIiACIlAwAd5RcPRacMEF/blP2Gt6hyP+TqboApacp2kREAEREAERyCRA5x46dBx99NESL2XCyfKbcGuIvagrQfClJAIiIAK5CFCnR6h16jCp68TVqVu3bl7nmGsbzS9PAoRvpH6WTrDUcyqVF4F5chWnSZMQtnB4E/vg3XmsX+/Kjf/8ww9N7LjDWgRLcnqP56JVGfOjExiReEJbTuj5b6FXtdlPP1mIFW6h8cNCY4sFy8fZbmCnnGKhQc5C49jseZtvPnt5eJ7Y3XdbqByy0ABUGexUShEQAREQAREoJgKIa9q0aeNZij31cdyJPfURKlTVU5+weUoiUB8EFltsMdt9991dMIXgC1EXQh0+SBEgIYhiebZwjfQE5uP15JNPtm222cbDC8U8IqaiURLRWHUJByfCT5IXEtO4NBFacsKECe4mhqiMUJWIpaicRlhEQuhERUp1CfEZFbQ0kG611VaGa9gOwXIXxyjmkS666CLDVQonPizVERYdeeSR1e0653K4IMyiEh2RFMcn0aOPhBsZYjoSAirCM1Eu3Duyzd9zzz1dfIXr1/Dhw11oR1luuukmP284XyHOwdWLhBCMxmH2ixAsn4RbSDIhcttggw2Ss3Lme/nll3eB12677ea9FXEHi9tSVoRe1Z0Hjh/PB72mcS+jPFSQITDkGl069Grh/klCgARj5inVPQH+53h+4RajJAIiIAIi0HgEEN7jDoAAnvcm3lGUREAEREAERKAmBOhE8+mnn/o3cU22r7RtcOimE1PsqFVp5Vd5RUAEqifwzjvveP3h6iEcFx0f6ZxJZ1Y6XdJxQ6nyCBD6lzpnhH/JztGVR6I8S5zT2YviEpZvxIgm1qnT/Lbc8n/Zv078b3lSyFGqX342O3L/FvbHb03srruahH+AHCtW+Ozq3MCiCxhjhmxuYEkXsDitNpIKv7BUfBEQAREQgQYnoJ76DY5cB6yGAKH/EM8wkHCGQkD0wgsv+O9sfwjzSIjFddZZx0MG4gSFYxi92GriiJU8BsKoDh06eMhFXKdwsCLhVhVTPk4WI0eOdJEYrmAxzZo1y7DR/uGHH3wWvZsRYyJuiYkeWKRCy4FLGKEnEY3FMIiI1DgeH/m4ccA6hl7ca6+9fD5CN1K2+XC+8847DeexpJMVQjuEdbh8IASL27Zv396PgQirrlM8RjLfhKQkESo0ps0228yd07geyHc+5yFWhBH6kXKRogiN0I3JVOh5SW6r6fwI8H+M65ySCIiACIhA4xDg/WHfffd1ET7OmIjjcQlVEgEREAEREIGaEOC7je+r1VZbrSabV+Q21Enw7P3mm2+8nqMiIajQIiACcxEg6gCdE++44w6PTnBtCN928MEH27zzVikFmWs/mlFeBIigQRSKwYMHz1HHXF6lrOzSVPsf3rGjhQugiXXvvoD9/pvZCadVhuALRy+EXu+/87cQtqRJ6J1d2RdKTUuPGxhDZsQc3N1pd4kCMDpnIwILkVZCyJrZR1t4YbMo/EqOee9v2rSmOdJ2IiACIiACIiACVRGgp37fvn3tsccesxNPPNF76kdxSFXbaZkINBQBwjUiNKoq4fLFgBPYqFGjXJyFmKm2CWch3MZw+sIlCmevfF2qksemN9VCCy2UU7SGiAhBC8K2ZIpiojhOLqtqOgqeCF1IWMRcKfbuynROyzafPCIiW5iX9kSiEglR1eOPP+5CqygYy9xnYpNaT2bLH6IzhHePPvqoIaRDqIUjFO5ua/JxEVJ15yFXxnKVpdDzkmv/mp+bAP/HmaHCcq+tJSIgAiIgArUhEN+34ph93R2s+mmYxxkguqDynE2uU5tjalsREAEREIHKIjB16lTbnJAwSnkTgBfP3WnTptmOO+6Y93ZaUQREoDwJUG9//vnn+3s64lkc6XEAzFV3VZ4UVKpsBH4KodkQ/NEB91jCtimVJYFqxV6U+l//mi2uOfroZvbOW3+zCy+fZS1aliUPL9SM6X/z0I04eiH0at26fMvaWCWjrY1oJ/+LeDJHNj77bLYIDAFYFIPl4wZGmw0hI5VEQAREQAREQARqRkA99WvGTVs1HAHC6P1aQBxwKkARHeE8QRjG2qbRo0fb/vvvb0OGDPFwiOy7Jql58+Ye1hCxURQexf28H+KkE0aVRBhHypuPW1jcPtuY45FiuMnkOj///LOLtgoNPUhYQ4Rdn3zyiX344Ye20korpXeLIxmp0H2md1AHE4i7HnroIQ/7iTMc4WcRqOFwFns1VnceCMtYSJLYqxBaWlcEREAERKDYCUSxOCGYY0KsTsIxgBDUvJvRUE/iGYszC+GuCd9MIgz3Kqus4tOfUeEX0tdff21LLrmkT+uPCIiACIhAZRPgGdOuXbvKhlBg6XmG4tpN3YGSCIhA5RIg4gAiLzqhbrjhht7ZtWNw8FHdVOVeE5klp4MO32VyYs4kU16/58m3OF27mj38cBN77qn5rP1WC9sj42Y3QOS7fSmsR9jGSwc0sz3/2dJWXL5J6GkvoVdjnLfoBIbINIQSDjGFLby4WuiRbxaMHOz2280OO8xCD8LZbmCnnGIhtI+FUCwWXnItOAmYHXqoBbtKszFjzF57zUIjWWOURMcUAREQAREQgeIlEHvfxzE5jT316RmonvrFe+4qOWe4NCUrLXB0wm2LIQp4Mvm0aNHCEPXgyDVs2LDMxTl/x/+NOGbFgQMHevhFesiRcLIgJdfxGdX8wRWMdOaZZ86xLdbap512mhHqkP/BX375xZ5++un03nArI/3111/peflMEK4RDric0fs3JvZzyCGHeENsnJfvGOaxHJPomZFIhNkk/GFcnlg0xyTloYy5UjynMbQl6xXCgIYDKrqGDx9uhOB8LXwYJPMUp3Odh1z5ypwfr8lChIiZ+9BvERABERABESgmAldddZWdfPLJniVE811DxTDiL74TdtttNxds4aDasmVLu+KKKzz8M+7AuH526tQp1N+FCryQDjrooFCvN87DYCMOJ7EcQbuSCIiACIiACPCth3BJqTACMEt+Jxe2tdYWAREoZQLUwe20007uikgnCsRedL7YZ5995qgzLeUyKu+1JzAmCCRuvPHGEFHt+mCUI6ec2hMt3j3MW0jW/vlPsxkzmgSr7iZ21EEtbKNN/rAjj/2v7bjr76GBpZA9Fde6X3/VxEbd1tSGX9PUfp7VxC66qIn17GmhoqK48lnpucENLHQO9CGTxeefWwjLMqcjWKiLCi4DNIbNPpd0zMf9Kw5rrTV7Wve4TJr6LQIiIAIiUAkE1FO/Es5y+ZURZypco5ZYYgn/UMU5CscufieHOI8xtuX0dBs5cqQ3VOZLJfk/shy9EUKK4iOEQ21Db4M+ffr4/ClTpth9991ne+655xxOFr4w/IlOFjhLkbp162YDBgwIHRPGeAUNFTI0iuJE9cwzz/g6vXr1stNPP92OPPJIu+mmm7yclIN07733eq+9fHtAI8zqGT5w+ofeENttt52HcsSZg+NvueWWHpaS/VJJREIkFd25+J1r/qWXXur7Gzx4sHXu3NkIsUdDLuES+/XrZ7h/MU1KuoLwG5EXrmY0Co8dO9YIu5iZtthiC29EvvXWW61Nmzbucnbeeef5alRm0eCMo1i2/NHL+eijj/YG6YkTJ7rgD8EbwrcYWjKf8/DFF1/48ZIV6bGx+ttvv/Vl8frg/HXo0CGEp59UZbjMzHLqtwiIgAiIgAgUG4Hu3bsbQ7bEM5ge4tHli3UOC70y42/eLTIToa+VREAEREAERCCTAA7z8Ts7c5l+5yZAPUfsCJV7LS0RAREoJwKPPPKI129S57Ttttsav/OtFywnDipL9QSot6SzDvWie+21V/UbaI2SJtAk9EJP1aQEoZ3Fzvs/9s4E3qqx++Mr8zy/wj+EyluRISpzvKYUlURSKYoMyfimImM0IEJJhiiZZyKiFDJERcbMFBKFhHj1f77rWte+u3POPefcc+895961Pp/n7vnZe//2Pvs+z3p+67fCWMOTTyyXNUNWkD33/VN2aPSnbLbFX7L22ssDezSbWivmmNB+lJ9+rCGffryyzJyxSigry/rri/ToUUPOO0+ClHjFXIefpfwR+O03kblz/yGCkRaS8aYQjBgcU0Xn59nHCWAQwYLyfEiZU/7X6GdwBBwBR8ARcAQqGgEi9SFpQIaABELudoglpF2BqED0/eZBMvO0kMubVGhnnXWWEi1Gjhypx6EARhOyWbNmMmDAAGH9448/rrdBZ5O6GzduXNG35edzBJIiYGQvIx4l3TFsIN3QmWeeqeQtlK9QfzrhhBOkV69eGi1HZxmSD2SvQYMGaeTct99+q8pR64eGJe8/xCYGPHv27KlkJIhdpDsk+hYVjIEDB8r06dNV2cKIYJCWUKDaf//99fJwevft21fVMpYtWyabbrqpkpsgRqGI0a1bt4QEKQ5GVatVq1aq5KWVhT9//PGHnBKkczkH94UaVY8ePYKS7rWaJhLlDchf7Fe3bl1VGOMcidZDQDPjt88y5DCuneVOnTrJhRdeKE8++aR+W8AdZ3Tbtm1lxIgRmrppyZIlig1YQroaNWqUVVliCnY8PzA45JBDtA5wgSDHcwHv+HVzPQxCI2MfJ5lROWpfHIOleg4cS9pOSIaoyKFwgpOE++P7ac+b5d13310Je1tttZXeN+Q0M9Jycu/33XefrfJplggceuih+q65BH2WAPphjoAj4Ag4Ao6AI+AIOAKOQB4hQB/5qquuKjUwCx8UxIann35aCOaJKlZX9O3QJyeY6uabb9bgrYo+P+fDf0e/l76xmyPgCFRtBAi0wC9G2kYUvQhATRQwWbVR8LtLFwGIwAT64hclOBkfsVuVRmBq1mQvgyWMWYRIbJHnniPF3nJBYemXoI6Vz7bSSsuV3IXS02671ZDgL9bi73s+P7XcX1tUDcxIYEyjamC1a4uYAhiEMJt3NbDcPw+v0RFwBBwBRyB/EIhH6seX8+dK/UocgfQQyITsVVqNkKEopIbE6ESznE3nGYf1xx9/rMSrbbfdNqHcOiQniGLbhM7L0qVLdR87d7JrTUT2sn0hWX300UeqcEXqpVwYxLT33ntPVboaNWqkJNF06kXda8iQIUr+ggSXzFD/AmeUwpiCGwSqVMb1HHvssXLnnXeqIhh1cD5IWpBbSekIplg6zyHVudgGgY7IOUh7EMOi5mSvKBplm3eyV9nw86MdAUeg/BDgf6G1CWgXlDYf3W7Hss7mbcq66ProPPvEC/+PbF1p82yPFv4fRpeZj66Lzts21lkBXZtPNmUfji3NOD4ds1TK7Gvz0WmqebYlK/wvt22J5m1ddJpqnm3x7YmWbT+bcg02n+m0LMemc67S6k+0Pb4uupzJvO3L1M0RiCPA9yP+LbPlRN9HWxedpvr22rZkU/4HUFd0u9XNOua5HpvatTG1byf3FP0O8q7b+27vP79TAmrs94o6FoV1Nk8/JFoI9mOZKWX1EOluU+ZRamZq87Zs545jnYvldMle4EPgYp8+ffT+6N9VlPEsohiQvpgAsZtuuklVUyrqOqLncbJXFA2fdwSqHgJ8dwi2xp85a9YsOfzww5Xk1aRJk6p3s35HOUWgf//+MmzYMA1cbdiwYU7r9sryEoGpq5T1smrVkhCdXlRCt7qs1VXQ8YVynRUERzU9TRAsCaolEhQISgJgamBRAtiLL4rcemtiNbAoCSyIIITOUMn6fMkRcAQcAUfAEcgFAji2IGn88ssvSviA9JFoPr7u999/V0UcHI6QRqykWjYno03pYCabt204FM3RaPM2NSekLdt+OBlxHkadi+ZYTLTOtkF0QXGMYvM2tXXs6+YIlAcC5iy3us2RbsuZTHEY46RNZfwWIIJhvN/p2uLFixPuSipD1Mpyafymo0pW6daNw4rUhxMnTkx5SJSUBt6lGd83oh1btmwpkM+ixjeLlJuk+DRL5znYvsmmfOeMPBbdh28w3083R8ARcAQcgbIhwLedb+pvwWlDic+zTKGtG59PZ128jZysrRxdb/NM+f+SK+P/Ev9b44P2ti66nnWUaHs7Op9qG/tZsXNGl23epuxj80xZxpgmK2xnXyy+j67M8I+dk8OimNt8qinbrNjxthzt69g6prbeponW2TamRvBgPrrelpOtS7U+emwm+8WPS7ac4SPIu93tvbJ3kmWbt2l0Xap5qys+jdbDNiy+T3Q5vt2WbRqvw9YzxWx7qnndMYM/vLtxs3XxKfvF17EcXZds2dZnMrX32o5JtmzrS5vG77O8l6PfZusbRqe2nWm08F4lKlyvvQM2NWyYYmAQJYsxb9+fKMmM+ej/KuYpmRp+GwKKKPhebGp+Gab0M21K/y1RQf0adWSmmfRtuV6wQk1r9OjR8tlnn2V6C1nvD9akSUNVjOeH9e7dW5WbUXV2cwQcAUcglwjwLb/33ns1IwBBjKjao9Cfaz9eLq/Z68ofBCZNmqRZKCAjO9Erf55LeV9J6Z7y8r4Cr98RyDMEQt9FdtyxqMQvDTWwKAmMeYhgcTWwKAHM1cDiKPqyI+AIOALVFwFUZRYuXCjfffedlkWLFsmPP/6oBWJGqnmiFs2xlwhBHF843azgOGMep1w0cpN5HHM42CCRxLexDgcWTkUr1G3zTBMtc23mYEw0NWdkdBtORhuMYwqZ7fvvvy+xLj5oxzKENgbkUhn3YBiYwxGHYtS5mM4yUaZOHEuFtG/LRwRQwEKqe++995ZNNtlEU62SmjXfbMaMGZqGg99ZLo3vDN8XUjVuE9S7IKLxTSAdI46P9u3b67cgl+eM10VqD1TFUFFj4IPvsZsj4Ag4AlUBAYhWtGkpBB/YvE1tu01Zb/PxaXwb7Tz2ocTnaUtmYrRpKRYskGg+vo42I+ui7ePocnR9fJ6BfdZREs1H10X3SUQIoK3t5ghUFAL04/h92ZT5bEqy4+PrUy1Ht5U2b9uj0+i83VN0XXw+vhw9hm3pFJ5Tsv2i22zephwTn7dl3RD+2D7x9bY9Oo3uy3r67XFLtc622TRaB+tsvc3Hl23/6PZU83GfAvvG10WXbT6daXQf5in0BZJN2Ubhe2zztmzrot/q+Hwc50JYNoJzlAzN/10r9r/YpvY/PjqlDWABifhofvjhB/XV4LuKFupMZGCMX4p6MjGOq0jr16+fpo2M/8ac6FWRT8HP5QhUfQTwYY0bN06uvPJK+eSTT6RDhw5y//33S4MGDar+zfsd5gSBefPmSceOHeXoo4+WHj165KROr6QwEHCyV2E8J7/KPEHA1MCaNy95QcEPKXPnFhHBjAwWVwML48uSiATmamAlsfQlR8ARcAQKCQEcX998842Wb7/9VhYsWFBM5jJSV3SKAyxqOKmMfATZAUcXZaONNlIlH1tmynb2jRKYosQuSF3VyYhQNXUzUzOLTuPzOCFJR2nl68DgtnlIdszzPBMZOEOe4blYKW0Z1aCoGlGien2dI1BeCMyfP7+8qs5pvb169cppfVYZ30OcYiNGjJBrrrlGv82bbrqpHHTQQTJ48GBp1qyZ7Vpu0yOOOEIobo6AI+AIVBQC0baRtZGiU+YTLdt6mzKQa/NMbdkGeOODnYnujzYuwQWmBGLTROtoU9l69oOcxTQ6n2hddDvzceJWouvydY6AI7AiApBsKpo8seJV+BpHwBGoSAT4n0mpCIPAEPXHmP/FpmeffXZWl/HFF1/I2LFjNZgH9ZIBAwYIfT4z/DukfXzllVe0LYPiM/3PLbbYwnZRH1CqfSB60X/ETjzxRKkV0hwNHDhQ3n//fbnrrrsEwpcNqL/xxhsabESgz2GHHSajRo0KogEfSLdu3aRz587F54T8Rp1Tp05VAiIp2XbffXfZcssttT6CtdwcAUeg+iDANwHlrkGDBgm+PL4XKOCXlgWg+iDkd5oOAvyvheTFeAQKmG7VCwEne1Wv5+13W04IBL9iqWpgRgJLpQYWJ4Nttlk5XbBX6wg4Ao6AI5ASAVRh6GAREfHVV1/plHnWQRKyKc6pqEHG+te//qVKOkw3Cx/yHYNcZHQdjhsK6yBxuWWHANG0psyVXQ0rHkXHCNKXOR2ZR3GNCFUrqLExz3vx1ltviS1zDJHgUWNgkuecTsEpmWt1o+i1+LwjUN0Q2GeffYQCKQFHP0QCN0fAEXAEKhsB2goQ0hn0jKph2LxNbR+mqQr7Q8hin9JUT1E0sUCB6NQCCfhO0jZFCZLtLEf3Y9mKbY8uQ7iyZdppbo6AI+AIOAKOgCPgCKBmCbGbksj69OmTaHXKdbR/COCpX79+yLjyuUyZMkWeeOIJ9dHgJ8Jn0zxE6+OLufbaa9XPg9oJaa3Yb6+99kprn9atW8tDDz1UTNqinTN+/HglZbz99tvSv39/vc53331XiWTTp09XMtndd98tu+yyi8ycOVNeeOEF+XdI/QKhC2vbtq0q/U+ePFmeeuopOeaYY7TPuv/++8uFF14oTN0cAUeg6iNAIA2k0KFDh2qWixNOOEH4Hm699dZV/+b9DnOOAO/O7NmzNcsDpGO36oWAe1+q1/P2u60EBFKpgYWsLiES5B9FsJdeErntNgkdkKILjauBGRnM1cAq4UH6KR0BR6BKIQCZ68svv9T0Wp9++ql89tlnWnASER0ImYt9MAbGIOL83//9nzptiKzZd999dSAMMpeVmjVrerq/An9LcEISAUPJ1Bi8hRhm5C/SUVq6ThTfbP7jjz8unodMFjXODxGQd4qBVnu3Ei17xy2KnM87AskRQK0Cp7ybI+AIOAKZIsD/dgYTSUWUaMq66HpbTjaFkAUxK5VBmLL009Ep8xTUKGw+OoV8xXJ8Gl0HCd3NEXAEHAFHwBFwBByBQkeAPt69996rwT2o4kDsQsELYhcKXwx6z5kzR/18lm5xzJgxcsABB6jSFtvS2adp06aq2M75OAfGOohrqHeZkWYNlTH8hWzjWmiDjRw5Uk499VR5MaSAgeyF+hcEr4suukjw6bRv315TtkEKQykMP5CbI+AIVG0E6FuaCj39xpNOOknOO++8EqqDVRsBv7tcI/DAAw/IsGHDNA2op/3MNbqFUZ+TvQrjOflVVkEEUAPbYYeiEr+9IBoTIkaKipHBIIIFLkJQDYF4IIHhLSEqpGRqSMhg3ieIo+nLjoAjUJ0RIIXie++9J0TZIZ/+4YcfavksfFBRccJItVe7dm0tRN4RuWfy6Ui042yBhOPmCKRCAFKgpXjcbrvtUu1avA0FDiOB2RRimKUGRT1sxowZusy7HFUOwzEYJ4NBSLTCu2sDwsUn9Jm8RwAVKhzJbo6AI+AIOAKZI8A3FEIVDnQrEKttPtnUCFvR7axLRcxCuYpBPP4f05ZkGi2Qt1m2faLboutsninFU6ll/tz9CEfAEXAEHAFHwBGoXgjQzkLFGYPM3r17dyVYvfzyy6qSBREMX54RvdiP/WlrzZ07V1DlKm0fCGG77rorh67QR09EoLcAI/yJnAezQXf8PBh+HwzfpBnkMcheqJE52ctQ8akjUPUQIEB4+PDhct111+mYxGmnnSaksUWB0M0RyBYB/ld17dpVeJ+OO+64bKvx4wocASd7FfgD9MuvmghA2KL8HTBSfJMhUCV0SFYkgSVSAzMVMKYU1MAgmLk5Ao6AI1AVEYC4BakLuVpS6zGlmEMFGfftw8ewXr160qlTJ422g5BDwUnk5ghUBgKrrbZaMTmrtPP/+eef+j4bEYwpKUVt+c0335THH39cVemiaZxIDQkBDPKXEcHiy/wGnGBU2hMo/+2Q+Q488EB59tlnfbC//OH2MzgCjkAeIYCaqqVRxglOamSmRtRKNbVtELUgaEWJ0dFb5H8uhCuIWfGCgittQiNtpTNFgcvNEXAEHAFHwBFwBBwBR6DyESAtIwaZCj8g7UJSU0cNoj7Equeff15ef/31UveBkJWM7BWtN9V8nMQP4Qyi2KRJkzRAAVLY+yHSnwBUfJZujoAjUPUQIHgX1aUbbrhBs4f07t1bKMlS21Y9BPyOygsBsou0adNG/1fxjrlVXwSc7FV9n73feQEiEPoCSdXAwphviZSQKIJBAvvss8RqYPQfTBkMYpmbI+AIOAKFggDELghdOGdQPYLkQhQD6xnII3Jup512khYtWoRv5g66DLnFzREoZARwTKLURUllqJrgSEAVbN68eVpsnumrr76q2xhIN8PZSMRrvGwdZERZR2Rqvg1qo9xi0bJ2H4U+7devn0yePFkjkQv9Xvz6HQFHoPohQDsMRQIKqYwTzRuJi6kVSF2QtBIZ/58g7EO+ik+JgE60nnVW7BiWEykwJDqnr3MEHAFHwBFwBBwBR8ARKCwEaPNhdUO0OwQK/Cf4Pz7//POQHSWkR/nbzDe47bbblrpPzZo17bCcBcfhw5gwYYK0atUqBPk31wF6yGkPP/ywXk/xCX3GEXAECh4BgnOvuuoquemmmwTlv/PPP1/Vl+x7VfA36DdQqQgQMNehQwch4Js0jp6VplIfR6Wf3Mlelf4I/AIcgdwgsNlmEtI5pacGFhSN5fbbJTjYi85NfwjyV5QAxryrgeXm2XgtjoAjUDYE5s+fLy+FXLbIsb/yyisqb/57kDqkc0Taxf3331/OOeccJXj9O7BYceq4OQLVFQEUuhgAp/D7SGaQpYwM9uWXX6oT9IsvvhDK9OnTdRpNX4XqiZG/oqQwIlC32WabCo1II1q3YcOG0r9/f+nZs2deDOA/8sgjQvn222/VYfvf//63OJL4jTfekAcffFAVZQ477DAZNWqUppXt1q2bdO7cWR8RRK/Bgwfr/IknnqhKbAMHDtTlVHXjvL7zzjuVjNeoUSONFoToSpTgqaeeqp3+W265Jdlr4OsdAUfAEUiIAOpYELYsxXB0yoAUy1FCF8QuFBTittZaa2mK44033linKCwwcIbSKvMUFChtPrrMekj8bo6AI+AIOAKOgCPgCOQTAgRYocb89NNPa7AOKfjcKhcB1Low+sK0H3feeWcNDp06dWpxn5vtBIxCuth9991L3Yc6MHwsDKqjtp4Lf+Mnn3wiRx55pBI/aPsSXOcmSs574oknhIJSW9++fR0WR6AgEcDHOmTIEMEXB/n00ksvVd8lfWM3RyBXCEAe5H/ctGnTBJ+9W/VGwEdDq/fz97uvBgiUpgb2wQf/KIIlUwOLk8BQBHM1sGrw8lTULQYVgMDkEQmD4fLRR0UsxNCBdoshAIEpOAEkRJ9J48Yie+8twYMR26lqLCKVbo1VGqyffvqppjSDyLDHHnvIKaecoo4ZiF2eeq5qPHO/i4pHgIhSBtspyQyFMCOARaeQL++++24lNuHoxnBSQvqKFyJmIYThUM2V8Y2AaHDWWWcpQQpSVJcuXSot9eGFF16onWuug3SykKwgd+H05/vVq1cvJdChygZukPDY9sILLwSV1X/r96x169by0EMPFZPADK9UdUPK69q1q+BIoh6iuZgnehDC2OjRozWdGU6mjTbaKFfwez2OgCNQoAj8+uuv+n2AlMp3wqbMR8lczEPeiqZDpL3Fd8TIxEz5vjNQxnqKEbqi866mVaAvi1+2I+AIOAKOgCPgCCRFgD4wqfdGjhyZE/JP0hMl2MC53Q8mmgKRvi9Eqd9++01JFaRIxC+AXXPNNbLffvvJ9ddfL+3bt9fgKAKleG6XXHKJEjDS2Ye66MeD+6233qrKKc2aNdNU42zDT2JGmxqLqqhzToy2NYZ/4OSTT5aWLVsqURDyB2nGSSe+22676T7V9Q8BJfiannzySQFjN0eg0BCAyDlo0CC54447gijHZqrqhW8u3zIlFBqufr0rInBbSOmFatzYsWOr/f+OFdGpnmtqhIZK0QhN9bx/v2tHwBFIgEAQzJG5cyUMOBYVSGA2n0gNLEoGczWwBID6qsQIzJ4tIVm5yH33SeglFzEIeZlCxEPwliQ+pjqvhQAX0txIIDkEOR4J3gCRo46SwCKQICNTsMjQDHn33XeV9ADxAZIXDhIcHnTucdbsHYhtzOMAcXMEHIH8QQCFPZyXOCwTFVRfzHB0xIlgODTr1KkjpFLIxGF9e5An7d69ezERgWOpC6dKu3bt7JQlppdffrmMGzdOnbslNpRxYdasWdqx5v4tIvfQQw+ViRMnqoLXSSedJB9//LHeJ2pkpNGEaMfAAKQwHMyQ1jBIE6iAGcEinbqnTJmi6oY4oDkPBD2sVq1aMmnSJI0+5nrcHIGqggDvM98MBlvcRL8XkLNQQaV8/fXXxSSuKJmL+Z9ob0eMKGNUtvg+R0lcRIVGl5mHyLXyyitHjvZZR8ARcAQcAUfAEXAEqjcCO+64o3z22WcJ1U3LAxn6iQceeKCqilWldhlqrgxa08dPx+69915VyoEctNNOO6liOYr/V199dYkgs8cff1yDoOg7sJ3lTp06CQFVK620kp4qnX3Gjx+vx3EAfXf8GsOGDROIHWQcQG0cAhfptF5//XWtm+wDbdq00ePwFRAcR9//qODHJfiLY+OG2hdBY+kavhSIJFVJAQvFvIMPPliuuOKKKnVf6T5T368wEYBEyjtLcCcZEVBcOv744z2tXmE+zry/avzAfCfJKIGv280RCAhM9dF0fw8cAUdgBQQyUQODBEZKyNC3DYMNEjo0Eho1K6aEdDWwFWCuvitC5FXIuSchmbRIgwYSeugiQdEkSL9UX0wyvXMixx57TELoWpHKV9u2ErwaEjwOmdZU4ftD7nrnnXeEhikFcheDlDhIkOk+88wzNfqucVAv81zjFf54/ISOQEYIoNiSSh2MlF6JSGCPPvqorieVJEaUG2QtI3/htKSwjKMk7sj+IDQ+SJ+AkhXGdwVnKY5TnL1Dhw6Vgw46SLdl+8cIV9HjzSEcXQeBjJQObfkO/23cF9duEb2m0gUZDKIX1oD/f8FwUEctSnpLp25IXtghhxyiOELyMmMgwM0RcAQKFwEIs0biSjaFIE9KGbN11123mMAFiQtVVByBRupinc17ikRDzaeOgCPgCDgCjoAj4AhkjkC8n5p5DZkd0a9fP1WDqu7aDcccc4xQ8DcQ7FQ7+JOj/WhD9fDDD9dACNS32feyyy4r7o9nsk/Hjh21PY0/AAVb7PTTT7cqiqevvfZa8bzNxEldXAvt9dkhAJrgOa4L9V38JgzcM4VMVl3NfC42ra44+H0XBgJvvfWWoPD/QBjjwjeK2hLfi4r+31AYaPlV5gKBuUGhhSBnyMT8T3NzBAwBJ3sZEj51BByBtBAI4wMh+lsCGaPk7onUwF5+uYgIZmpgoS8jURUwCGAsuxpYSSyr9BLMwN690cCWkK9KQsukSt9uud3cVlvhWSgqQd5a+vQRCRGFSvgK0WT5ZHFyF+pdOGOIakO1C2dG8+bNNbLNO0P59OT8WhyBsiOAExOiASWRQVL4KKTvpaBKxRQCKMpdixYt0kMgfeK8NfIX05dDA+MPUgBHzMhZc+bMUUcs3xdIX02bNo3slf4sDtZoSgZUbUw1K1oLxDPIqjNmzIiuLnU+2fcu6qROp25zgiarr9QL8R0cgSqOAGRMiJN77rln6HPUzYu7pW2E0tZXX31VXEhDY8vMQ+5iAMgMxdPNN99c08hA8oQgzzRaUC0wQqkd51NHwBFwBBwBR8ARcAQcgfJFgH4jqZRQVkbNecCAAYJSqhlpBm8ImQ1eeeUVJfbQP+4VVPotcMf2Y7upURMohKItpCYMotfgwYN1HjUngnwgGVQFow+cDYENfwMlldFP3mGHHVLtosSM0vbZZJNNUtaRzkZ8GARhkMIx7iPh/gmKw++QrnFM1H+Q7nGZ7IeS+5133qmBZVwzimYtWrQIrv3g2w/2yCOPaKFvs2vIOoGPF38vhk/n/vvv10wOH4YsFU2aNNF3OJq1AaIbCu2kb8T3Q7AfZvd15ZVXFvtlCPhDMYk+z4033ij4fggc5JrcHIGKRAD/H4pKj4VAfBQeUfQi+NT8cxV5LX6u6oMAwYCtWrXS4GJShdp3svog4HeaCgEne6VCx7c5Ao5A2gikowaGCpilhBwzhjz1K6qBxclgYUzDrSogEAbalJw0apTIuedKoJ6L8NK4lR2B4CQIEjZFmIaUYMF7JDJ6dKWlwsTZQFrGyZMnq3JXnNxFx9zIXd4JKvvj9xocgUJGAIUZCqla4/bDDz8UE8GMDPbmm2+GzL/3Cc7yZM5giB3Y9OnTNf0rHWEchJkaKRaWLFlSfBiErkQGAYPUaBCztqcRE7FsonKjnfVc1x25NJ91BKo8AhBASblywQUXaLpZom0riuyFYimDfhSIW1EiF4SueSEdd5SwSppEBuwY1GOgiYE9lqPkLtLbuDkCjoAj4Ag4Ao6AI+AI5BcC9BmbNWsm9evX1zYnCvZPPPGEoPhCH5J+LT4w2nvXXnut9h1Rfrnpppt0Pwj82MiRI1XpnvXnnXeejBgxQtMCktaPPnDrkBHhoRA0S7+zW7duJdIV5hcimV8N5B8Urqq64augD8AzJbiMdj9kNFI/QhRs3769vjPp4sC7FyVOpXtcuvs9//zz0rVrV+3L/DtE7KOsTr+GoD3IXqTDnDZtmpIOUSw7NfikubeZM2fq+3nssceqAjvZHVCj2WOPPfQ5Qx7DeOak16TPQ1+NeiHCYeYX6dGjhxLjSFX/ZAh2huiFsZ4gF3zPbo5ARSEAKRGS19NPPy277767Eh1RELT3taKuw89T/RCAGMu7RkAgJEPLIFH9kPA7ToaAk72SIePrHQFHIGcIpFIDCyIexQQwyGBhbFYggsXVwOIkMFcDy9njKf+KSC3ToYPIhAmZq3nxIgTikATmegh/K/9rzZczrLmmBG1wCd4ikQ03LP2qVlutiOwVOs4h7E+C/IyEHrYI6yvA6NTjBMCpBbmLQU5T7nJyV/k9AKLkwJ7IDsgvhW50VIhiJL2dRQIW+j359WePAOkRiPykRA0CB+kjSzNLa4YTBqcg0XaW9rG0Y9mOLHY6tvPOO6vzvX///hq1ak4e1Mdw5uOYT9c4Fgcw107Ualnr5n4hxaWDV7rX6Ps5AvmOAN8Ifnf8JiFcYvye4ilUsr0PflcQtiByEelupK7oPI44jN80qg4QtyikmYWAass29d9otk/Dj3MEHAFHwBFwBBwBR6ByEaC9d++996pyPYOwELtQ6KIviMJXn6DEjwLRZ599Jluh0h9sTHB8H3DAAUraYhsEmrPPPls6deqk69gHFS/qQRmJ/SHdoGLF+ThHVTICwGhfV3VDhYrnCZGP4LIFCxZoX+GgEMDL84Y0mK7hA8QXCFGqvIx3FGIWhCwC3FBjN7XzWbNmaVAd/S0CViAtQtiaOHGiqtx17txZfcQE9qHYhZ+PNHcE5ZkNGTJE3njjDSUwEthCQbWOfpwZimqQyiCSoXx22GGH6Sb8z7vsskvCwEE71qeOQK4QYMwDkhfkQt5p/IyHHHJIrqr3ehyBlAjgJ4Y8C9kbwiH/M90cgTgCTvaKI+LLjoAjUGEIMFYb1K21xE8a1H+LSWBRNbDQNw4DoRJkUSV0kkUsFWSUDEaGQLc8QqB7dwmtYAk9Pgnej9IvDAZgyHG+PEhB1whElupuy+vVlRpt2oqccEJR3tNUgNDpDdFgQRdcpEsXCTrCjDSmOiKrbTip6OhYIcKKiEVPy5gVnBkd9H74IJLijigO5quqEeFIxMoJ4b0nbZ+bI2AIQKgwIpetSzXFGQ7hichq5m8L/194r3JlJ510kjo5iWAlJQMkMc41IRCc6YRjRKhiPxqTPcxzHxiR3mak8eBab731VnWI7hdyZuPQT1U35FosTmQhYhhn6tKlSzWK1gmUhrJPqyoC/HYYYGBwgMhx++3b/cZ/I7Y+PoWoxe+Ttg6FAQymRuqizcO5MAZsGNwg3QiDdwxy2DzLbHMiVxxhX3YEHAFHwBFwBBwBR6DqIAAZBV8YRruve/CBQtIi+Ic2I0QwCDlG9GI/9keViDYrZC8IBJB34mQf1F6nTp2qil6QvTDauPlo3APXS/uYe0NxioKvkL4oU5aj22wftj/33HOa5rxmzZr5eHs5uyaePYV3g2eerTrL7NmzNVBsm6AQVp5mqUYhtvBsCVbBIDNCQGjbNvir/7ZffvlF04vh9+C+UPTieUMUI80p73s0UBU1O5S68FuYWbBf9D3n3b/ooouUeAbhBpU80p2icOfmCJQnAk899ZSSvPie/+c//9FvdVUj25Ynfl53bhA4/fTT5ZlnnlEFSFQW3RyBRAg42SsRKr7OEXAEKh0B+naUMM5ZwkKQVEjrJIHJ/A8ZjKx1pamBQQaj7xD6JW4VicCwYRJ6YBK0yUsnekHs6t9Plj/8iPy18Qbye6O6sqx5e/lzi03lr3XXCipVq1bklVfuuf74U1b6eamsMn+BrPbB57L67bfIyiHiKehZS2AVSJCoSX59TZtKCHcqInyxb79+yfdNcwsddYhdNCwpDJjScWdQs1evXhqRuNtuu6n8eJpV+m4ZIgB5hAFs0gHgzDnyyCPl6quvVrUiHB04XQrdGGAnsvHtt99WRx/Om0GDBqnzCIcOaRHcHIEPP/wwKQirrbZasXoXKRBR0UFanYhPS42QS6IXF4IaHdGrRx11lHa8Sb8A2QNSJo5Lvpc9e/bUa3711Vflv//9r7Rp00ajU1mJ879p+G5zXUcffbQSOU855RQ566yz1HmZqu7HH39c66MeVBVJ+0CUMN8EnMdElkP6MmIK+7k5AlUNAd7vhx9+WP9HQoK2FNHR9x6CqH07+F0kInNB6KIYOROciC7nf27t2rX1d8pvlIE6Cr9zVLvcHIFkCPAORgeqku3n6x0BR8ARcAQcAUeg6iBgaRkJysG/Qaq6eOANqrP0AfGz0Ub9CEd3MGvHGhooyGDWjmU+X9sWEJhQcILYQ4kb103Kwug9QhaiYKwHl+pi4JEt0QuMUBbC3wDxBF8ZwZIUfCC5NHtePLuooTADgW/GjBnR1SXm6StdfPHF6t/DvwFJAUUwjN8GymT2jtuB9n7blPXgdMYZZ6gP5cYbb1QfCCSc4cOH22E+dQRyhgB9OFTk8EOjPIeaHGQv0pC6OQIVjcAll1wiN998swYB77nnnhV9ej9fASFQfVpQBfRQ/FIdAUcgOQIhSCotNTAjg0ECC+M2rgaWHNLy2xIIG0GvXELrWEJ4V/LzkObx0ktleSAm/W/zTWTJSe1kWSB6hZ5+8mOq+pZVV5G/NlpPllF2qCNL2h4gq73zkawz4SVZOZAWapx7rmKWNE1j6OzLVVdJ0IEXCXLgge2QEWKkQHrttdeUwAC5C4ICnZ3GjRurbOyBBx6onRxXq8gI1qx2ZlAa6X+IXaR0g+zVokWLEg6yrCrOw4Nw4DB4TiHN1VXhHYbMQgQfDitSgiLfjgPRrfoigFMR4z2AyIQRTc33CdIpxC5+K9tuu20JRzhpIaIOQz0wR39w+lA/aQ04R/TczPM9jVsilaGOHTuqOhgOVdJYYqnqNoduvG6WIb5xPRjENzdHoCoigBMWIjRR4zYQQRsmkb355ps6IBJV5mKAIkrmOiakwrZlCF7xgblE9fo6RyARAqhToMSBc9bNEXAEHAFHwBFwBKoPArQvsbp168qGG26oBCb6igQb4Oswg6iDoWRFsA724osvaho7XQh/ovvYuvLq01r92U4hakGKeOihh4oJXNG68CnGFbo5hr48A9n0hTm2R48e0cN8PgECYElwJEFkqIvjNyPoC38ZQSn40/AVkH6xvPy2+Bgg9eGf2Z4I+4ihjMx1ECiDOvK0adPUv4GCudmyZct0FjINfs/SrpM0jgSDcp+oJ+OXJjDHzRHIFQL4EUizOnDgQFVc5PfFt2nXXXfN1Sm8HkcgIwSuu+46JczyHvI+ujkCqRBwslcqdHybI+AIFBQCmaqB3XGHyOLFRbcYsiSFzsk/xdJDhr55iCApKBjy52JDaislGQUVk6QWUlstPzJIPocBuCVt95df99stkLxqJN292m4ImCzbsa78EIhfa7w4U9Ydfp3Ic5OkRlBBCxraiWEJUU+q8MVzCJ3n0shzCxcu1MgwoqNQkiHCig40joPevXtrR9rIB4lP6GtzjcCXX36pKeFwnuDQwOmVr469XN879RE5SGfmiCOOEKL3+vbtq5GvpOny/PTlgXhh1InsP05DSF1W8kFdh99mLlKO4uyOW7Z1O8krjqQvVxUE+P8ICRjVy9JIXnbPDEZADNtuu+0EIheFATg3RyDXCDCYy4ClD1bmGlmvzxFwBBwBR8ARyH8EUOvCCNIjAIdAJNSPIIF37ty5+AZYR8Ab25cuXarr2Sdqpppkah70C1HCgjSVjypYrVu31rTq0XtINs+9QNi58847lexGHx+lphNPPLG4fZ/s2Oq+niBQ1OAeeeSREBDfUH1mEMB4XyB+GfmLNJkHhQBgiF8tQ6aIXPpNeG/vu+8+7V9BkOF5YiggkeIR1XHUx/Anmy+ZNI9cJ0Y6SNb/8MMPSnIkRR5mhMB4AA/7kiIV8gNK6NyjmyOQCwR458aPHy9XXHGFphrlW8TyDjvskIvqvQ5HICsExowZoxkfhg4d6n6FrBCsfgfVCP9gi/7DVr979zt2BBwBR0C+/bZkSkhTBIurgUEEMwKYzW+xhQOYFIHQ4Qx55opIRmFAPqEFxZHl/zlA/vptqSzu0Vb+t0VRJFvCfX1lCQRW/vZ7WX/0w7JyjVWkxqTnil7OEnv8vUBqTFI+BudJGHUqsQf//mfOnKkd5AkTJqhTAGcREtpE4+GYatCgQYljfKHiEHgvPDuIdqiKkJ6KqNDqbu+++66mdETN6dlnn9UB++qOid9/+gggwU70K2ne3BwBR6AwEYCMjvoW6aWzMdI0RhUVsqnDjykcBFAMYLAJNQGc+IcGpeFjjz1WB7ogZDG4SBrsRo0aybCQep62LwNSGINnlG9DZ5FoblLwmtLbokWLNOqb9LmkVWrSpIkMHjxYGFBDUREVBQiJDL6xjQEpUgqTzokBKtLXrBsijY4//ni9psJB1K/UEXAEHAFHwBFwBKIIQHiZO3eu9jEJliQwifYGRBXaCRBgaIfst99+qkINmYu2B+0Q1GRRAEWNCYOUM2nSJE3VdCT+1GAnnHCC+uxobxCkQDAcyrY33XSTKl03a9Ysr/x2tHFoN6UabiSoD1xQcrd2F/dKPx1yxW233SZdunRhlVsCBCD7gTEBLCihJTPU5CCFQYqCgEi7mHapqYPviK84DZs+fbpANjzggAM0HaMdQoAw7zBpSiHttWvXTgNx8C+/9NJLqozEbwHlOlRpXnnlFbkyZPTAuG4C5dgXBX/6ZxAbNt54Y0HBC4U7zsnvg7rNUAnjvgn+5DdkQT+23aeOQCYI8Ju4IyhB8F7SdzvuuOOkX79+Uq9evUyq8X0dgZwj8OCDD6rfi+8jvmw3RyANBKY62SsNlHwXR8ARqH4IBAXhECVTRAQzAhhTiquBpfE+BMJQGEmhB5d453nzZPkezeTPlZfL4lPby/J1PMVUYqCSr62x9FfZYOQDssovy6TG9FdEgkJFQgudleA1UeLdr7/+qs4jOvyU+fPnazQVg1sQvOhEM1DlVrkIIHm+1157aSo4npNLk//zPFCg431dsGCBOpCIBnRzBNJBwMle6aDk+zgC+Y0AJC/aKgwgMaDG4ANkHAzlBEsHkuwuGOiAiONW9RFAyQ2FAFL8Eg3Lu3LIIYfo+4NSaNeuXdWp/+8QzcN7g4OfIAcGKRl0ZWCWFB6Q7xl0IiUvQRIocDBwRSpe0ocywEu6XZQsII/xPjJIyUAB54DQVb9+fVXsYBD3vPPOC3EYO6oKwpQpU4R0NgzkujkCjoAj4Ag4Ao5A4SFw7733yqWXXqr+CVRn5wVfJ23Nq6++WtsMdkcQblCsIi0j21nu1KmTtjmMsLI4OJshiEPmQlmG9gkqtqgm0ZbAUJvhOOyss85SwpQpKunKCv4DqQ0SD/eD72rOnDmavg9STiIjwBRiDwPZ4BU32lwouRPol0jxOr5/dVymXUtblXcjXVIKiloQCXlOTz75pHwTsmzwHIz41bx5c+1LxfFkfwIeIOJB0mvbtq1mHbC0o7SvjzrqKPUtcyx13n777fqO826g0k/2iM0331xOO+00WXvttfW9hdT32GOPqT+adjnBELzvKI/RXmYb9Xbr1k322WefEpdFUCxBFLTT3RyBbBCAlDt69GgZMmSIfrvps0Gqgbzo5ghUNgL2/Tv55JPl+uuvr+zL8fMXDgJO9iqcZ+VX6gg4AvmCQGlqYCgXh/5NcVrIqCJY6NdXfQsRZ3rzQXknjKiseL+hUb28aRP53/cLZNGZHWX52p4nc0WQ0ltT49ffZcPrxsvKa60nNWaEVI2h47yCBQntwByS04MSxm2hw0ynZrfddtNOfatWrTQN2grH+IpKQ2DJkiUabcdg4uTJk2W99dartGvJ1xMj877vvvtqJCsS8WDl5giUhoCTvUpDyLc7AoWBAEQbBsogyWCQa15//XV57bXXdLCJKaQwBr5WXXXVYgIYyzh1GWhzq/oIMACK6gWqA5bStmnTpkrqQukAZQ0GW7cIUs2ocUEmx5jSToZ4D6EQ451DVW7UqFGafgllDZRwGTTDGHBigBbiF8YgGm1s1AgGDBig61DoIP3MLbfcossMjEISY/CL4As3R8ARcAQcAUfAEShcBFA3og1ROwRhJiNfocgEiZx9URWF+JLIaLsYaSoR+YDzQBCz1HiJ6ijPdRDqaRdB7kKZietBbYm2D4V2Oe0fS8fHtYAJwRoQ3Bm8trZZ/DqpG1I86qi0p5JhGT+uuizTz4H8RBsTcko2xnPgGUHkosyePVuDfiFRWbpHI3OlUz/10ZbmWREcEX9mPNOoXzO+zDkgetE+530npSl1JHpH2I+2O+1olMHcHIFMEID0OHLkSCXj4i/o0aOHBuJ4EHEmKPq+5YkA32QjuvKuxr+n5Xlur7vgEZi6SsHfgt+AI+AIOAIVjEBQIA4yxBLIBiVPHPocqgaGiJKpgL36alEGPVMDQzTJ0kAytXkytFUZvkJomATtZQkjKCUBsqWQHmV56Agu7tPViV6GSZbT5WuuLotPbicbDR4jNUIEoKZrjNcVBpJCb1h2D6nvdglOlZYtW6rkdXw3X84PBIjkxLn35ptvlnCI5MfV5cdV4NSkA4Rahw3m5seV+VU4Ao6AI+AIVDQCpAaxwSU7N0QdBjEokIL5nwrZHTUmt6qPAINOEPtINxMdKCKlDAOPDJAyUISh9kU6JXPyk/aRwViUC8wYGGAQk0EBCOYoejFAy2DV2LFjleTF+xU3c84yqEtKbpRaUQ7DOAd1ci0cyzW4OQKOgCPgCDgCjkBhIkB6ZkoqQxkJRaPSjFR2pH1MZpWheAWZBx8MBC8I86g2kWYP1Sfa4aY8xjXTxkLh1Aw1L9o5KD4xiJ3KIAWhZAah6eyzz9Y026n2r07bSEdP+xTl2j59+mR967RPSedIueyyywQVNp4rz7dnz57yR/AdEyBhql+lvbPUl4p4FSV6cdHxZdah0AxRDEtEguR9o81MsA+pS1OdTyvxP45ABAH6cDfccIN+T34PqXzwu59zzjmaYjSym886ApWKAARn/keiDO5Er0p9FAV7cid7Feyj8wt3BByBfEMg9E1C+o+iEr82UwOLpoQMmT5C1DjOfqKcJEhdi5gKmE0hg1WmGljo4wVVhPjdlLIcZJyVCRccGSvYCy/I8ptvlp9PbCN/bbLBCpt9ReYI/LXhevJTxxaywU1jRTp2RFC6syIAAEAASURBVH6gZCW8XEGS+3gYhxWkZkG0GYNln3/+uTqBiBBDZhwnT7rGQB1ODAbVaPCWZi+EdwupW/ZFYrwQjajIcePGqaMF1RK35AgQ8YfCxjFBsa5Dhw7hFW+efOdqtuXiiy+WZ4OyIimpSHfGgDeO5WQW/62hLsegNA6/Z555RhYtWpTsUF+fxwjEn2v8UjN9T+LH+7IjkM8I8D+CQgocjAEC2gZEirtVfQRof0LQiqfBph1qbVEGjLD4/8cPQmeNQagZM2YkBYoUM3xDn3vuOSWdkwrSSFzRg4zs9SGqx8FoCzNw6eYIOAKOgCPgCDgCjkA+IwApHZK8kYBoR9OuQu0U0laLFi2SKouRFhsSPUpNtLdQTCXd5VY4vdMwSEikxu4Y/JuQxK688so0jqrauxCwQnpDglzuueeenKq98FxIn0mh/YwPCOIXPl1Ie7WDWp0RvyAhQsyqSEOpt3cIGt8+DJB89NFHSjasyPP7uQoXAbJC8B4PHz5cb6JXr15y5plnBn2CIFDg5gjkEQKMZ+G76ty5s451mB8hjy7RL6UAEEh/1LUAbsYv0RFwBByBfEWgNDWwKAksmRqYqYAxpdSrV/5qYCGgKhAFRAYPlhD1kya6QZZc2rVbcedA3ll+1pmybIc68nvjwIpzyxkCyxrVld93qS+rnX2W1AjEquBRKVk30YM8yAownEHdunWTF198USP6zj33XLn00ktlp512ElLYpGsMzL799tvqSLAorlTHEuU2ZswYoTNXiMY9nnfeedK+fXtVXyvEe6joawYrnjnvGOot3hkSjVSjkwj5kUg1iF4MLKeKxoz/1lAqIdrtqaee0hQTFf1c/XzZIwDBy34H8edqxAZqHzZsmJJjM3lPsr8qP9IRqHwEeP8ZeHKrHgjYIBT/x1AnIJ2n2a+//roCwcu2MUUJjP+DkL4YVIoainEMiOGIRQVh2rRpOtBpKUWj+zJv32NTF6OtEjcIiCh/MXjn5gg4Ao6AI+AIOAKOQGUhQJDX008/rQQv2lAs1wuOZ4g+qIyQwtpI86VdI74/0jVCdKfEyfWlHU9QHyn7SPsIaezmEDRMIGh1NHyr+L4ICOW5JFLGyhUuqGqhHkbBn0AgL8QvCs8T9TpUcXknDjvsMKkIlTnum/cHdbmhQ4cqeTBX9+v1VE0EFixYoKkaR4wYIauvvrr6jCF6rb/++lXzhv2uChoBCLyQvPh/B7nVfAgFfVN+8ZWCQGw0uFKuwU/qCDgCjkC1RcDUwMgU0revBOKChNzzEjrVIqiBhfF6ueYaFWYKqUOKsvQh3rTzzkgbS4iwKRJyCkEuEtqw8vzzIvPm5Q5OBJKmTJEg4SzSpo0EVYQ06oZs869/rbhjcBrUmDlLlhyRXI58xYN8TboILDli3/CAPpAgybPiITyPCiJBQbxp3bq1DpDhCEB9CeUD1L0yMTrzc+fOlfcCeTBKUkhWBzK3EMoK1R588EEdWBw4cGCh3kKlXDdRnqTnwunlJipNTiQsvz0cskQ+piJ6gVn8t0bahe7duwelyX87pAWEAN9ZlGbM4s/V1jNFwj7T9yR6vM87Ao6AI5DPCPB/jIhtBinHjx9ffKmoVBx33HGhr5S8s7Qznaxg/fv3Fwi0ZqQDJWXOQw89pAOhqCuQVhpDBSG6rzloIU5jpGtcZ511NC3RzJkzdR1/GETr0qWLEseKV/qMI+AIOAKOgCPgCDgCFYQA5Parr75amgeldJRLaZd8/fXXcsEFFwjKpGy/6qqrdHu6RC8unfYWgUX0T+mXZmMMfhNMigI+6mCvEhldjQyy24ABA2T//ffXtIqTJ08OrvYEvvZywgQ/LCkT8VG+9dZbQoAt/jeCFHr06KGBChAAB4fo8HfffbecrkKUWEabnlR8p512WrmdxysufATo46HchRrdHXfcob8f3lu+Z070KvznWxXv4LbbbtP/l5ARGT8zP0JVvFe/p/JHwMle5Y+xn8ERcAQcgawQCP1szYYY+lChcy2hkyuB/CIhBY3IO++IBG6InHyyyGabSYi2YVBCQto7CXLZEgb6JXSG6WCLXHaZyH33icyeLRKC2TMyRLpq1Cg6hEx6iCIEonlID5aimt9+kxA6seIOgY227N/byP9q1Vxxm68pMwL/q7mxqqYtDwSPFSxInwvPpZyN6BmcQXF59gMOOEAHuTI9PTLxmUStZetEyvS6ymN/GvUtW7aUunXrlkf1VbbORo0aCe8X+FV3+y38xnFkmBOW3wMDzOlYot+a1ZPO8b5PEQKQTklRUdFGyjLSXEBkiFqi51qW9yRat887Ao6AI5DPCFx00UV6eSeGFOZEyf73v//V/4mNGzfWFJ/fffedbictTtROOukkJUxDwidQgeha0trwjUUV0dqlROCipEl6G0jnDMiRAhlVWshmGIOTpIOEYHvGGWfoN5r0Nwx8XhOiefbZZx+9lt133z16CT7vCDgCjoAj4Ag4Ao5AuSCA4unzIUoY9W98TwR4QeDZcsstZdy4cbJw4cIS27O9CAKLaOeU1VCRop2FutOee+6pg+LlSSwq6/Xm4njalBBVeDa0PWkz0sYkoK8ybeutt1ayFepv33//vQYx8A5BFmzYsKG2syHaEITGe5ZLQ53J/VO5RLRq1YUftGfPnrLtttuGsbIHZdCgQYIiM9kzCLhxcwTyEYHrrrtOA60hI/Kdd3MEyoqAp3EsK4J+vCPgCDgCFYyAqYElykYTuDaBbFOkwGXTO++U0MiVMMBQRNwK2UdCp7EoFaSlhGQ59J1XsDBeESLVi1b/+WfRdOxYCU4ACYMWRWpkaaU6J+L9mYny2zGHrHAOX5E7BH5r0lBWG/O4yOLFIoEoVZHGgBYDX9iTgRlIChzsz/DiQALbZZddtKPFujfeeEM7YHS6kP6GqANJjPSPRO9hpNmhnrvuukseeOCB4mjALwPT8JZbblE5cY7H4UCkYdQ43+233y7PPPOMdvYuv/zyvE6PQ+rJKUFCz/CL3ovPl44A78zJgfmKsgay89XRcLBNnz5dVUJwrjGwjaT+kCFDVNnk/pCTl8haonNxvBJ9aU6PZL+16ohjWe8ZoheOaNJOlGaLw3eaSGVUYujkP/LII5oeoVZgbF9xxRWByB2Y3H/bK0HyE+f7+0FeE0f8oYceWnwO0hkQ7ct3jzrmz58vp5xyiiq6xb+hyd6TDTfcsFhZBifq+eefr/dx4403ypw5c2SNQBjG0ezmCDgCjkChIEDkP+2Cy0LUC21CUv/0DTLKkLNIRQP5C+N/I6lxSPOBWgKKYBMnTpSjjjpKJk2apIW2JnXwfd98882VnI+iKCQwzsM3/KyzzlISFwQw9oGMTnu3XUhtz7eYlJDfBtlm6rnkkks0ahdVBFKdF7qhYEZbAjJxtLCeZaYUBi+ZMgDIvE3pK1BYZgpxOV5QQWMd03QKSmumtpZqHuyj24mmRsnCCsR5m080te2kDiVdaCaF/63JCu+rbeO8bo6AI+AIOAKOQLYIQMyh3UL7hzYOCkmkNyfVIun49thjj2J/W7bnKM/jaIfh28OngdIVxKK99tpLMwpAAKONRZBToZKBSOmNmtqsWbPk2WefVf8ASlaorBEgQP8/3wxfEu8PhXYZqmuW7pF2McER0XSPtK/dHIFcI0A2EHxn+Mr4nQwfPlzHFWiXuzkC+YoAfU/8EvjrKWTIcXMEcoGAk71ygaLX4Qg4Ao5AniCAGhglHkAV/OkhnVdJIhhqYBC3SBmJEexg5C+bQhKLW/DBq4X+W0gTJmHQRIJMblFayfi+xcsh9UmNZcGx32Db4lU+k3sEltUP+MLqmzpV5Igjcn+CFDWSKg6Hy9jwUjHfNuQmZcAGh8zdd99dLDdOFB7ytBBTUD5gG0Qw0tow4Eb0GpLLNHZJvUMdNljD6ZGD/0+QsMNZhaPq2GOPXYHshdIT18BxEMMgPzDQlq82NTwvrjXTVJf5ej8VfV0QXxg8JMUSaZWqo+GkxblBFBtqXpB9iH7E+I2gXPJOkITEGYIzF+n9OwMTGGWTZL+16ohjRd4zxAKiqJcsWaLpanFaQ0yACMBzwVmKkY6TCFnUZYhM5LgOHTros74vyHbiaOV5Q2BAHQan8FprraWRjfFvaLL3hG8xxASczHwrITRgEBEgUJIyws0RcAQcgUJCAIIMxFX+x6F+iOosRByMbyElmfF/8quvvhLItJB/iBK3lArUC1GXoAZT+aKerl27llimXct5GaA0sg5t0muvvVZTLPO/ujwVGiBTMXhYWoGkFd3HlhNNWRcvkLmi7fRkmNp6BmKNGGVTngvrowUSVbSAIcXIVbZs0zhJi/Wss8L54/OJ1nEvUVIZ/ZA4uSy6nW0sQ1RLVozYFt3Oceka+BjxCxIY//f530yJzqdax7tKIYWNzVOnmyPgCDgCjkDVRIC+P+0V+pQEDvH/E3VRSOatWrXStk2h3TnkfMj4EKIgdwwdOlT7zYV2H8mul7YLCrS9e/dWwoopxSbbP1/Wc920nSkQb1BZMuJX9+7dtZ3ENmt/169fP18u3a+jQBHg+0Z6UYIt69Spo35/xgoKlfBZoI/BLzsLBOgPojxOsD8KjiZ4kEVVfogjsAICTvZaARJf4Qg4Ao5A1UOAoAaUwNJRA0MRDBIYWU1S+aEhfVHIkoLaKIHpIfOJFA2jxDB86y35a8P15K/1XT43hkxOF5evtYb8tenGsnLAu6LJXgyiQbDCkPKG+IVBOkAdxgbYiCCEEEaHDDUZHE8MTkBoQCHhxRdfVMICjV5UbF6Dlfi3MWg2bdo0jRBjFZFiRPLF7eabby5ejzrOSy+9FN8lr5bfCs+LgcTooGFeXWCeX0zNmjWVOAiO1ZXsVa9ePSVG8qgg6lhKKAZlpwTVuL333lt/g/z+2BeyJYaKSaLfmm70P+WKAOSs90KuZBzVEBJIAYnxPkMAxSAakGKjU6dO6vBlHapsfDch0o4ZM0YJBhC1sG222UaaN2+u84mea7L3hAMuvPBC/QY/+uijqrjIOt4dyLi8P26OgCPgCBQiAjj9001pHL0/iEG0VZNZvM0WX2bgi29y3CDnMMgFwWrevHlK8o2SrSD9plpmW3wf2z+6HgJSKuP+IA7RTrcp89Fl1kMOYmr72DxTyEK2bPNGSoJwzjzTaOG8bvSx/9JABchytNWiimiJ5m0fppDEeeZMeeYUe5ds2absA2EtkUG2M+KXkcBsynrmN9poI+2vJZrSf3NzBBwBR8ARyA8EIBYTPAnJBpIXKczo66Okj/oogYXlSTKvKBRoR3AvFij5xRdfaJ8Z1exk/+8q6tqyPQ//T3lW+Gqqwv/W2iF4lwBfCkGGBOnyXkLO69Onj7bLjfhFqk/zFWeLnx9XfRAgmIbMHaQ1JViSTCBHH310cWBN9UHC77QQEaBfBmGZMSq+iYxpuTkCuUTAyV65RNPrcgQcAUegABFIpgYW/AMh8qb0G2IsIWSh07SOIS26DF52lBy7PERPRw/95hv5a4P1omt8vpwQ+GvDdWXlgHe+GINdcWNgCEOJyJwZODYwUpGZmTKRLUMoY+CMfOakcyQqEWWwuO20007FqyCgkdYOJ0O+Ore+Cc8rH6XZi0EsgBlS36FK5FYSAX5rRL3xO0OFBKIl6l4MJEYt/luLbvP5xAigJmdpwGwP1hFpzCCrGUQpopATmX0LUTQ041sIyYq6SMvIs2rWrJlt1ilqdhDCSAHZNajJmMUH0TN5rtRzUWBvo/iGAw2HM0Q00uu6OQKOgCNQXRAg2jZOnuKbHl+XaDm6H9tt2aZ2TGlELNQ3IF3xv9sIWPFlvtHxddF9S5u3/z/V5bnm233SP+IZUAh+KU+DAEAb0Arpu5i3aaJ5+llsJ9U8hcGJuDE4m4gExjreTwopxaNTtiXqG8br9mVHwBFwBByB0hHAdzZhwgQdNKYPis+LICCUvVHvatq0aZX/5uIjpLjlJwL4YCE3UCC6E3Roql+o3UIsx7cB+atFixbarsjPO/GrqkwECHbER4UK/a677qoq923atFHV3sq8rmzP/dhjj4UxtDOEQHUjrqaqC+VhMpzQbyiPrCXlXX+qe0u2DZVtiMsUxARIe1jIBjGZ79y3336r/l5UHN0cgVwj4GSvXCPq9TkCjoAjUEUQQNkr+HBDSor0byi0xeQ4GS1DL18otzcV2Xnnv48NDuK/Vl8t/Yp8z6wR+Gu18NASOOSzrrCCDmRgqzSDyHDbbbep82rUqFFK9EI1DNWbZGYyzpmkmElWV3mtZwAFpQe37BEAv0QDUdnXWHWO3DQwei+++GIlPRLVC7Fo1qxZVecGK+lOIAQQSRg3og2JpDbj3UxG9rJ9otPot/Aj8i8Hiw+MmtLWhx9+GD20TM4uHEc4nFD44rsKkY10ucOHDy9xDl9wBBwBR6AyEKAdh6oRxUhT0Xlbl2oaJ12xb3Qd86WpQvA9TkSyihKzILgY2Sq6Pn5cdFt0HsUlN0cgVwjwPvFOUrI1fheLFi1S4leyKaQwttF2WbhwoabWQmklavx+EpHBjByGIjMKp0wpDAK7OQKOgCPgCPyDAGrmpt6FCj7E2/33318GhchbCF5OfPoHK5/LLwRoA0DaoPC+fhIGHSzVKAFmkMHYZqpf22+/fX7dgF9NhSOAWiEkr0mTJmmaUIhOqBUWuuEvJHNJ1G+Y6p74bbz99ttCm575uH8w1bHpbCvv+tO5hvg+kJlRwOKZx4Nf4/vm+zJkRciJ+OZfffVV2XrrrfP9kv36ChQBJ3sV6IPzy3YEHAFHoLwRIJ1jMmMMAhJYGHcJOdElpAWTEDVWRO7auX9L2enc9rL+zl3/OZwdS0h9/bPJ51ZEYP6in+SZtz+SZ+fMlSbbbim9D10xVeGKR0XWgHcVNJQQaOTPnj1bpejHjx+vqc+22GILOeCAAwr2jhnAjCvypHMzKP/gJAEP1JuIcDr99NPVQZLO8bZPplE8dLiJRKLTRarNXFlZInfAL58JfbnCKNN6+M0ga04UESlQGWC79dZbM63G90+AACQuBjOjRsoq0i5eccUV0dVZzzP4iZHe9sQTTyyuh1SdGAOiUcvmOxI9nlS6fFNGjBihaoMHHnigbLDBBtFdfN4RcAQcAUUAwivKgxCukk2j25hPVSBeRbfbsk3ZVppBloW4akQrm0aJVKgo8Q2NrovvF90Wn89EMbG06/XtjkChIEDwjBGyMrlmvhPff/+9Er++++67YhKYkcFYh+Lsyy+/rOrOrI8q39GuMvKXTeOEMJY333xz/e1ncm2+ryPgCDgChYAAbazJkycXE7xQXuS717JlS02Jd9BBBxWr5RfC/fg1OgKGwLbbbqvBZgScoTJq6R7xR5x33nlSt27dYuIXwW4WyGvH5+sUPy33QuDcG2+8oaQ2yO/R9k2+XntZrov+FG1Fsmvsu+++0rp1a8mWsPfMM88oyQsfZvPmzZXshbJVVbHevXtL27Zt0ybn0selvQzJK9dELzAt7/qzeW6Mb3Tp0kWzDUQDYrOpqzKPIRvNCSecoMpszOdrxpnKxMjPnTsEnOyVOyy9JkfAEXAEqhQCIWhACV0Qu0L2BzWCa1Hr2m23oinZ8urXLyJ8Fd/8RS+LrNm6eNFnMkdg4c9L5fVPvpJJcz6WxtsUDepnXkvVO4Kol2HDhqnqDIo6dPYgQJDqLF/IXvPmzdNBxPJGn8gb7nnn8IMklRupKruGNGyQvoj2zMQyjeL57LPPZMyYMRrdn8l5Stu3KkXulHav5bHdyG425Ry8G08//bTgTIDohaFcEt1HVxbQH66d1KcM7FV1I/UGRsrGqM2YMUMX99yziAhsJC8ci6WZPXubRvfnHenevbtcd911csopp+igQnS7zzsCjkDlIUAqtniBSME6fvs2ZT5akq2P7sNAIoV10amtTzSl7ZCOoTgBAQvSBtN4YWCAdQwOMLXl6LytYxqfj65zIlY6T8T3cQQqDgF+/5ASKOkY3xUIYLTzSHPCNDqPahgEeLahJBZty9CGIQAIMqdN4/NE1JfHIFk69+b7OAKOgCOQLgJff/21BtahekR6Rojvu+yyi6B+hHrXbsEha/2/dOv0/RyBfEZgvfXWUzV0FNEhRUXTPV5zzTUagBZN91jWFNicI9cEEtRNr7rqKk3NB9F99913F/w1/G4JoCsUslq27wl+RtpsBCODQ58+fZT0df7552uKznTqRbUQJS9UCw855BANWDVV+3SOL6R9MlVhLO8gzPKuP5tnY212m2ZTR2UdgyoyvwG+X2TY4DdRiPdRWfj5ebNDwMle2eHmRzkCjoAjUOURCIED0q6dBLWgf4hdf4uJVPl7r+wbbLTVZtK+6Q7ywGtzZOUaK1X25aR9fohOWFSKGGc8hrKQGR1A7Mcff7RVKmHMAo57M6K7MI4l6gu79957Nc2YRTOyDqlvjChHm5KqDkMtyqYNGjTQ+fL8Q+QSkUzHH3+8OivKkjIl1XWCA1HwTDGIb0SNRbFPdXx0W6ZRPNzbHXfcoRGm0XrKOl9VInfKikO2x1tKP+TwzXCaYffcc4+SA5GPfvPNN3Xdww8/LHXq1JEdd9xRIylZGf2tzZ8/X/dj0M0UpnRFJf+BuMDgHdGCnTt3Dv+n2hWs+lSqbyEOQiK2UddCth7i3pFHHqnoQ+Dj20KqRYxBTWzChAlyxBFHKDkMhbFE39BE74ke/PcfjiONIwoaRIq7OQKFgAAD/hCfKDjW4vOss/U2H5/i9I+uiy5H56P7MG/ntPV2blsfXU5nnm9cvHBcNsb/dwhQ8UIKCFsHCYt5phTSptl8dL2ti04hZLGcaprrgZRscPBjHAFHoDAQYBCE9gelNOO7aIQw2qz0Q23K/Ouvv67rGHw1Y6CVPqSRwGrVqiWULbfcsrjQpoKk5uYIOAKOQEUhQDt25syZxSnt8OvQvsLHw0AxBC++W26OQHVAgL4DBB/K4MGD5eOPP9YgNIhAXUOAK7+XaLrHeqQaydAOPvhgOe2004r9KxkeXmJ3rmfUqFECqYn2A0plBCWbj6bEztVkAfI+AcnDhw/XtIsEKoMR/sdEhrIrfi8Cl0njCdkLslwuDd8YGSruv/9+/a6OHTtWybQ8pwsvvFAaNWqkvgB8bWRDuPbaa+X666+XOXPmyC233KLtRQKgbrjhBsGviuo0x/Tq1av4WV955ZV67Vw3vlj8amQEsPX0s8eEwGkyZBDADuGrR48exbeJz4/rQwmOMRB8e5DeOBeZNTjmgQceKCYqlnY91ANpmHoJ6CRQnt8RbV+yEVgwRqL6+T/04IMP6vWTOpPn90FIAQR5ET9s1EhNCF4EhjMW06RJE9kpqENw72CUrnEdKPuRvpHfkqU7jJObwX/cuHGKI214iKDHHHOMnibde2ZnfN3gMmvWLFXcYqyDuspqBLJzPeDCe9apU6eyVunHOwJpIeBkr7Rg8p0cAUfAEah+CASlcLdKRGClkJYOW2mlwsh/CRnhkksu0WtGmpZOHNGH5557rq6jY3LRRRcpCapnz566joYvZAVyl9O5wiAvcSzbTKHquOOO0w4VHSMGXImOggRBdDcREqSpo4OErDFGA51OEB2q9957T9fRIaFjU95qQAz2cu0o75BSEQcdHSEkmuno5MqQs2ZAhE6aGdHqlGws0yie8hq8tUgXm2ZzL9XxGBwOOIIx3g3UmfhtQdbht4KEPCn6cGjRmeV3c/HFF8vIkSPlqKOOKvFbGzBggK7//PPPtT62U3fjxo11OR/+4FBD7Yp75XtCh5zfGY4hSAeVaen+NoYMGaIkLq6VZ8VvEKcS3zWM7x6OHJw9qGzhIOBbBwmEbyP3bxGtEFlxouCQgfyGMyr+XHlHiJBN9J5EHaQ4nPbff391rvnvUB+F/8lDBGhT4EA18hRtg1wbpAAKv+n4PM5HW2fT6Drm4wUFqvg6O8bWQ8KKF7bF1yVaNvIWU7YzTfd7lGvsvD5HwBFwBMobAb6NRtZKdS4GjqIkMJtnSgDEo48+qtvpw2G0fSCbMXhEmyhRyacgiFT37tscAUcgfxHg24QPjYF4Ct8kCF0Qu/Cb4Ueq7H5t/qLnV1adENhuu+3kzDPP1ELAMGQcCCuQVfA348vAD0SBBEbfLJUREPz8889rwY+Mfyzb3xoBevhtIDadc8450r9/f0/TFsCnLYUvkoIPCn8W5J+bbrppBaIQz4pARghFd955Z0bkoFTPOb6NMYebb75ZVazfDqlsmjVrpu8KPjf8pay74IILZPz48XoogbA8X/yiBBDQl2/evLkGwkJsgjzWsWNHvSe+4bx7+PUYr4CsdvvttxePATA2wHgG7U7qh9DE+XhfzMCJ95HgzLXXXlv/F7z77rtBgGFXfc85jrYqvlCMQPnSrmfEiBE6LrJkyRIdG2nYsKFmeuDaIDrxO2LK7yhaP+eFxMY1QYZjjIfxHUjJL7zwghK6jIwHMYvrgHwFMQ3/85hAaKONDsmPQPF07Oeff1Y/JGM2PBMCY6kLi5K98GHzPeBdIt0r99ihQwclpt133326zFhQqnumTgLleT+pg3ePZ9GiRQv1yZJ2MVsDM/y2+GOY5713cwQqCoEa4QNR9IWoqDP6eRwBR8ARcASqNgIbbigh/EbkpJP+uc8wGL9s6rOyuFeHf9aVMvf6x1/Jk7M/kJmfzZe1V19Njt9nVzmkUV096udff5en3/pQHn/zfbn0qAPl/lfflinvfyqbrb+unN1iL2lYq6aksw+Vffn9j3JfOH6NVVeRBv+3qdz03Kvyn4bbyUkHNJHf/vhTbpsyQ2Z8Ok/n2d69+W6y2Qbr6nVc9/TLMvPzIvWbddZYTQYfc6isHaa2ft01Vpfrjz9c91348y8yevLrMuerb2WdMAB3TLMd5YBwHrNfl/0h1z8zXV4L973KyivJlhutL3e+OFMubLO/nH7wHrZbqdP1R94vq+8S9o82qEOjO7A/JPRqSj0+n3cgOojODYO6RGwT6ZJvZAQiMEmDZMb10dRiQALnA4QNOhAMwppBUqGjyGBDacb9EzEGcY0INxwKGOdA3h9VJzppG2+8sUYDZRvFQ53JoorYRqcI5yQR9XQUn3nmGX0eSG5Ho/G5Tgr70Uml80sn1yxR5A4RQ0TwsW+6RhQYTiCOdVsRAd4vU/lia3x5xSPydw2/L35nUYPQwPeB3xXqV/zOeEejjj7eTYv+ih5bKPM4mogqZNBxm222WeGyuX8cUUS/leW7CJkMhw7RcskiL1c4ua9wBCoQAcidkLxwrBtJit+6zdvU1kWnzEcL+7IcJ3Q5SaoCH6ifyhFwBByBSkaANhSDSqhEW2EwmHYVg30UovTNfc6gMO2x2rVra7srPmWgqixtsUqGw0/vCDgC5YQA3xUCFhhgh2yCKgspGSF44StiMN3NEXAE0kMAvzBEE35PFFSHCIbD38rviT5joqBWyCIQWTiePh9+RBSMyNCQieGPRSGMegjQM/JLJnVUl33xY/ft21dT2eHPhoxTGUZQ45QpU2TixIn67LgGVNhuu+02Ofnkk5VABHEJQhMkQEhaELTwZbOd4MzPgnoVbUBsclBJgNBUt25d9dVB8CHd+D777KPvIcr7GIpikJIgKmKQy4xghJ8SgxAHyYkgdt5b6uH9JhUg1rRpUyWR4QfBfwExLJ3rYbwBPygELALjMXz2/P+JZluJ18/7jT8QghgB7RDQ+O0QREwAKQHEGL817gc/Lb8n7rV169ZhSPCkjPzzkPHAgt+xBaNC6ISERaAspCyuid8pJDvu3Wy//fbTYFjGJroG9b907hm/MSngCZTF8H/uscceKhAA+TpTo4/AdUIY5LsA5hacm2ldvr8jkCUCU1NTnbOs1Q9zBBwBR8ARcATKgsBrH38pR1wzVq7r3Er6HdFcBjwwSbqOekBeHHCSbFdzYxn0+AsyNhChfv/zf/Le/AXSeJv/k1UCqeaJme/L8+98LFMu6CE3P/9aqft88f1iOePOx2X+op+lTqj3D0hEP/wkC376JaRR3FHaDhsnG6+zllzW/iBZ8tvv0vO2R+WOaW/KXaceLU222zKQsJpJy6F3BMLX13qtEL2wE5s3lu3OniLP9T1Rlz9fuFjaDx8vpx3UTA5sWEeueGyKHHvjvTKsU0vpuOdOWnfba++SmuutI7f2ODKcf4kcN+I+PTYawaArqvEfnOZ0nrBCISEweIBBoIDMhROBThKRHgxU09nMxMAA5R5Ufejo0EHhHBBB6Bx+/fXXxYML2UbxcD3JooqI1IkaHVs6W3Rs6CTRKcKBidFZQ3lp4MCBGkVEp5D7JxqIQZJ0I3ei5/P57BCIEr2oIb6cXa35cxQONgyHBdFcEB4hFR577LH6O7NUr/lzxZlfCQROnBjJjG9DIhJYsv3j6/mOUAdOE6IcC+UbG78PX64eCDCwXpaIy+qBkt+lI+AIOAKOQDoI0P6B6E5hsCuRMYgFEczIXxDBGPBjUO7ZZ58VSBwMwGH0V42cT9uM/1lMrWSrxJzounydI+AI5C8C+EhQhCEADzIKqaLwBRGURHowVEssjVb+3oVfmSOQnwhALNl33321DB06VBXSjfgF2QODdAMZhWL+jYcffriYvI0fCb8qZB7IPfhU0zGCbKkbNT4IPa74mRo1yEk8I9To6cMT9Is6VkUb319s5513Lj415BzIXnyfMdqCGBlIaB9CyOVbThYSyPxG9GIf3gHqpC1IYCbvEelHUXOCUGbBmPjKLcMJx0WDv1nG8MGhVgXpl3eRdzZ6ndFjMrkeU60jvaIZmQGmBNIbbVur16a2jx2H0q3hxnEYARBmKIPZ7wiSFveBoTyWiUEk4/dkRC+OJR0kZuNiBJLj87Vz6MbwB2InYyQErEP2smtPds+Mz/AdgFRnz517gPjJM+cc8QBjO1eiKcHtfHPAFNW2s88+u/iaE+3v6xyB8kLAyV7lhazX6wg4Ao6AI5A1ApPf/SQ0pkXqb7GprLbKyqq0dfvUN5RUBdlr4NEHy7vzFsjLc7+Qoce2kOYNttVznTn2Cbl7+ltyQ1DIGtqxRVr73HD8EXJkIFr9HMhcr116qvywZKnWddnDzwci2XfyxuWnSa2gsoUN79JK2l03PhDEnpCpF56k13ZJuwOVmPboG+9Khz2KcpG/+OHn0rz+NrLDljX1uIsfnCR71dta1clY0T+odUESuzKQviB73fDMK/LWF9/IyxedLOuvtYYW1l/52At6fC7+LAiAvhCijdzKFwE6XcmMaCbsl19+0SgPok4gcOAYSNc5QMeDaBOILHTGkIg2Q5IashdKJVi/fv2UZEVECdFT0SgeOkIY50VW+f3339coIV0Z/iCfzblwoNDJufjiizWqyLbblHPaNeCoJPIIo8NEtBbSyHQOIdsQpUSHl5z1RPkQ9ULaOSJ36GRRiKqKSlnbeUqbgi0OFyLq3Ko2AjaQluwu7XdGlBrEJRwmvJs49+i0u62IABj17t1btt9+e3WS2vdhxT19jSPgCDgCjoAj4Ag4AtUPAfpdtCVtsDiOAKR5lKeNBAYRjH4QA4AoIEMGszYqqYBQqE5UIIbZIFX8HL7sCDgC+Y8Avh4IoJBOCIJjEBhyAOpd+EcI9osPquf/XfkVOgL5jwD/n1EboixevLg43eNll12m5AuIHwSvosZkQbncFSQPCsGpKBShgITiTzKDxIJyD6QgFPrWXbco80ey/X39PwhAiMG/TNo98Mskm8M/teR2zpTxeWcw/OAYvnAzyE0EK0ezVLANEhtBArwHpF+E7IWddtpp6vMePXq0vlezZ8/W/wG6McmfY445RslCvH8oY5k61DrrrLPCEZleT7yC6L3Ft6VaTnQcWTZQ/iK4HfWt9957T6uAgJWucT8EsEOUi5qRvGz60Ucf6WZ7RravHcczSGbRa7f9CFCHmFUWg8zdPWTSgRDHeIgr/JUFTT+2rAg42ausCPrxjoAj4Ag4AjlH4KwWe4eUjfWk0VabyRshhSJqWtj8RT8Vn2ut1YsILQ3/JlSxgeMge5EqEUtnn83WL2o47x8IY6Ry3GLD9TRq45E33pOaYZsRvaivWZ2tZK3VVpVPv1sk7wciGNfXtM6Wmv5x8nufaErILTdeX+56aVYxsQtFsAmzP5T11ly9+Lr+F5zBW2+ygaxUo4amhxwT7o/rgMhmtkvtomiSGraijNM5gYSEmpRb+SJAZy8dM8IKHRoKAwNE+9BJyNbiHR7qscGCZBEt5mi0qZ27tKgi2y+afx6Fr+eee047wRDMcJi0bdvWdlWSG5EyJhWdTuRO8cGlzBAZhtQ2qSXdHAFDwH5npOahQIQkIg9Hits/CBBBh/ODqFYiLoledHMEHAFHwBFwBBwBR8ARSA8B+mEEuFBs0Cl6JP0ilMEggFEIUqGgpnzXXXcJyggYA1ooR9BnojB4bfNMUw1AR8/n846AI1BxCODLYcCXApGEPigEgDPOOEMH+FGzcXMEHIGKQ4BAUghFFIjWlu4RX5ARrxNdDWQv1ItQi0c1LJF16tRJMzewrxO9EiGUel379u2VHH/uuecqMSbTbBepa898K8QfyH+kYkxmpOPD128pviGImeFLw0iNaEYWD4hsKIZxHIHXpY0V8F4SEA5J6pxzztFAAbBCLSpumV5P/PhcLhNk/u6772qwOe1a0iFy75mosKO0hREMHlUbi1+nBcmT4pJAcbNEz8C2JZoSdIGhvBm3pUuX6phG9HnG92H5p59+UmIpzxgS4w033FDlMmgkum9fl98IpDcimd/34FfnCDgCjoAjUMUQQM3rx19/k4MH3SY71Kqpyl7Pzili8Ke61S2DAlfwj8qPS5Ort8T3gXCFrfz3lPnvfv5Ffvl9mRK0WDZbZeWVZNdAwkK56+MF3yvZi20n7NdYzh3/lIx7aaZ027exvPPVAjl4x6KOwscLiqRrzw5EtFMObGpVFU8516Jffg1pIWsVr2OmmORVPFNic8YLBwQHdCrVqYwr9AMSIkCUUirnAQfRyWMfHBDkmic6BbJVWYheCS8mycpoREuSXZQMQ6cynagiq8M6r7xnqHWRKnDGjBm2ucQ03cidEgelWMDJglrYqFGjUuzlm6oCAnT+05HUhtiFo32TTTbRzjeEQJzvTvRa8S1AIn7RokVK+LLf8Yp7+RpHwBFwBBwBR8ARcAQcgWwQoP9Vu3ZtLYkGNpcsWVJMAGOwjP4hJPxp06ZpUJD1LxngMxIYA5OQwWxqg2DZXJ8f4wg4AukjADEAJRPUuyB4vf3220r6QIkFf8Rhhx2WtnJ7+mf1PR0BRyAbBPBv7LffflrweZBpwIIC4/XxvxbydfPmzQXVnwEDBpRQeCJAF7VOyCb+PzeOXvrLZ555pmLYrVs3eeedd4rTBKZfQ+72xEeIkVY3mZGem5SK+LdRwbc0oezPOoKsoykXIRN1DekESVV56aWXCmqvpRlqYIMHD1Z/Jal+//Of/2hAM0pycaJ/ptdT2rnLsh0/KwHspFBEsfbqq68WI1OlW2+tWrX0HrlXflvcO2ZtX1Pis1Tr8UwENu5gWUdKOy/taBTTyAwCMY3UmRjn6dKli/Tp06cEeS9eH0pukNkghnHf0SD3+L6+7AhUJAJFuoQVeUY/lyPgCDgCjoAjUAoCj7/5nnS4/h45bq+d5ZpOLaXOZv8oXqU6FAIWWfS23TS55HI6+2yw1pqy8ko15OvFP6taV/Scm21QJNH8r3XXLl7drskOSgwb//JsGfviTDmm2Y4CMQxbMxAOsFmff63T6J+ly/4I5yhSKyON4+9//Bnd7PNVCAEc/ERq0wkkuowoMJwIN954o2y66aZ5l8+dThVRRffcc48QJYNDg6iidI3OHZEukL7iRjR7PHInvo8vOwLZIGBEJTrudNLphJM645prrtH3OJs6q8sxEE4Nv+pyz36fjoAj4Ag4Ao6AI+AI5AMCtF1R/2nTpo2mlBkxYoRMnDhRSV8MpEH+YnngwIGqNsIA0wMPPKDBLgxu0Z8kkAh11mOPPVYHqFFahpDC4LabI+AIlA0BfBv85hjA32yzzYTfHSpBkDfxlSxcuFC3o+DiJJCyYe1HOwLlgQBBqY888khSopedE8IH+15++eWq1PnFF1/oJjIUQAKBqEQmBLeyIUA7h+8q6W0r2h577DE9JWl3CXAmE4YpRZnSKsT7qOFTxKd//fXXy2+/FQkMoOr4/vvvS9++fQUyftROOeUU3b9Fixaayje6jfvG7N1iHgVY1KEwyF0Qmxo2bKhtO9bFj0n3eshwgFmGDea5bgySllm8/lTHQcoyQ6HtrbfeElJVoqAHgYrxjmjdtm+qqaX05DkQeA6Jmt8gxu+WLB4Q8kgbybOBZGX29NNPa5Cv1ZHq2rkuyHIob4I5RNCLL75Yfcb77LOPbLPNNklTMXLfXB9kNFJ2QlR0opc9BZ/mAwJO9sqHp+DX4Ag4Ao6AI1ACgeufmS5/hc5Vm8YNdP3S3//QKUSuVPZSUNzCDtyhTtLd0tkHZTEUxbBXPirq2FmFs7/4WtM97hBJH0lqxw7NGsmCn36Rqya8qCQ127/2vzbUdJKPBQLb218WNbLZ9tdfy+X0MY+FxuVy2WCtNTSd46sff2mHyf/Cdqy0ey4+wGfyDgHSeVAgUNApQQqczgGRZEgz5zOxgqgiOkioINFxI0qJNInRTl0qwC2qqX///iUU5V5++WV1kFjkDoMXRO6YxSN3bL1PHYFkCBiRErLSkUceKY8++qg6Foi6xPnOb7BQDKdT7aD6wICBmyPgCDgCjoAj4Ag4Ao6AI0CfERUCVIMYPEQ1gfYuaXMgfTFoxyAYihDNmzcX+leQUhiQYkCaQUOUbiGnQESBMMZgHH089nVzBByBxAgwoHzdddcJKiv8hgjaQ3GPwW0GeZm37QweuzkCjkD+IkDKtnT9mdwFpC9S0kG4efDBB1WlCRIYil9uZUcAkvr555+vuGZKDCrr2SFsQaaC5IUfEXIRfkXI8qb0RRvq1ltvLT4VRCDaXp8Fla499thDifkQjy666CLB7x23evXq6f+Ok08+ucQmAr5J04hRHwRCjHeL68Knybkhgt18882aOvKoo47SNhv7kSKSdIfpXM+QIUO0fchxEKFee+014XoIIMCoC5JWvH6uq2fPnroPQQMciy/f3n2IzqQvxGhnLl68WLdRN4Ro1C1Rno0rcOkBSf7wf/W8886Tr7/+Wv24YEu6TLJ4bL/99vqcOJT2K/+LSafKuciWwn1xLgh36dwz7xsEL3CG8HfJJZfo//UddthBldgSXeL48eOlfv36SmTjGiCbObE7EVK+rjIRWKUyT+7ndgQcAUfAEXAEEiGwyt+D81c+9oLsVW8rGfLENN1t5ufz5anZH0qLneoVHzbxrbnSKSiAkXbxnulvSZ2aGwey1U7F25lJtc/CJUt1388XLi5xzKVHHSitrxknt0yZIYfvWl8JXl9+/6PM/eZ7+W+rfQNBa80S+3fdd1e5efLrmnKyVkgnaQZxrEfz3eW6iS9rfaf8p4mss8bq8sSs92X3bWvJLiEt5OkH7yGXPzJZzhr3pAzvcrhsuPaacs1TRQSYCbM/EIhl+/17G6vSp3mMAJE+GNN9991X1YXorK2//j/vRC4uf968eaqONX/+fNliiy20ShSMMDqFDRoUESVLi2ixY6NRPEgvW1QRkTQWVYTUORHj2JdfFhETmdJBxr766qviKSkVidDCKcLARLt27bRzOmHCBI32YUc6jHTu6WARTbXxxhuXiNxBSpkOnpsjkAwBHDK8I6h4tW7dulLl35NdYybrUb1jwI5p1HD82Lclut7nHQFHoGoggLPx2Wef1f+tfNNGjx5dImVI/C75JhBRilrok08+KaT/evjhhzWVEGRRV3GJI+bLjoAj4AhUTQQIathqq620WNobu1MGqmlXfvjhhzJ37tziKYE2rKe/R/tyyy231IE0BtMYnGRKoV5vfxqaPq0OCPCbYECb1IykaHzvvffUj0OgHgPbDGDH02lVB1z8Hh2BqoCAqTkZMZP/kVZS3R9ZCSC+/P7779KrV6+c+3ZTnbuqbyPIGAI6/mAjQFXEPaOUClkePz1+aLO7777bZhNODz/8cCUj8b/h559/lssuuyylD5L64opf3DMlbhDL1lhjDcHHzzsKwdgMAn8iK+168LlTotakSRNNNxxdl6h+/Ktxi6udsR1lMwhrEK9QRQNXfBPcD4VxkXQM3y5ELcYgGFtAYYu6ILxF00IyJgGuELbmzJmjbVX2NUv3ntmfAGFSbUJ+I6gCYlncCKzo3bu3PPfcc0qUGzRokH8D4iD5ct4gsEreXIlfiCPgCDgCjoAj8DcCZ7bYS84eN0FTIn6y4Ae5sesRcsLND8rkdz+RnbfevATZ69ZAxhoXUid+8+MS2WrjDeThs9rLqqGRGLVk+0ACu/Th53XXl+d+ISeOfkgGdzhENgkpGpvV2Uru7NleCViHDR0je9erLRPfnivnttxHzjp0r2j1Or9dIJntV38b6bJPUa7v6A7ntdpHvvv5F7l7+mxV/mJb5713lj6BNIademBT+SGQzkYHstiR194lm6yzltb1zlcLlLy2eiCMuRUGAnvttZccccQRqohVs2aROlyur7xHjx7aoWKwl4gWOihXXHGFzJo1S09FJ4sUjAwAE+WN0eGhU0RnKxrFQ8eGDiqR3RiRPUhHW1QRHRs6p0TX0MliQIHzM2CAER1+1113KbGLDi/WrVs3lVmmA02EENdAISqH6yItJEbkDh00omFRYCKyi6hZIouikTu6s/9xBP5GwIiURHDxfkWdM4UOEk4EZMAZXDPDAQn5AyIIDhA3R8ARqFoIDBs2TBh8QD0TJzdEr7PPPluILE1mfBdIbYAjmHkI2wxAkDIBx7ObI+AIOAKOgCNAv40BMMohhxxSAhD+Z6BK9MEHH2iBEPbmm28WD6CxM4RiyF8E9lDon9k0OvBWomJfcAQKDAEUSUgBBcGLdhTKP3Xr1hUG0VFgQT0lnxXZCwxuv1xHoNIQgDyDctDaa6+thfTJzCeb2n78LyWYhv+j+ELdcocAGKOmhWpSRZK9eKYEOWdj+ORS9dOjdWZCDobohVlAdrSeVPOZXE+qerLZNnLkSCVLQfLi92WB4NTFOALBaI0bNy61asYGeA8w/Bv2bHg/khl+YFIwltX4/VtmkmhdBM+h2sY9kmadFJUourk5AvmMQI0wmFdKUqx8vny/NkfAEXAEHIG8Q4A85SGFgARln2ILUTDLpj4ri3t1KF5V2swfIaruj//9JaRIxP4M86xb8+/l40bcK5PmfCxvX3mGLA2KQ+sFtayNAkkqaunsE90/0fz/wiDah98slCW/LZMG/7eprL16cnn2Rb/8qikZk0XA/hLq+PS7RVL7Xxuoulf8fMv+/J/MX/yTbB1Ia0uX/aGRtHb/8X2TLa8/8n5ZfZfQAL3jjn92GTdOpHt3CYnl/1nnc3mDQOfOnXWgFqnkfLHfwruSLKook2ukmclAAr8JOmyJfhtEykUjd9gn0wEEyDBE4owaNSqTy/N9qxECRIiNC99CIs8KyVC/Iy0Pyno+0FBIT86vtbwQQF0B0jDk5apg/O+C6HzTTTepygqpIVhXmjE4iaN6vfXWK96VSF1SlLiLpxgSn3EEHAFHwBHIEAHILpDAaDNbYZk+3Z9//qn9OdTAGNQjpY1NmSd4pzwN8g0DgpkMoJbn9XjdhYkA5EZT70LpDtt7772lVatWSvKC5OjmCDgCjoAhQCAOAawWJGvrfVp2BMj+wLeXAOPyCpi2q4SsQ2pOyO1kknArGwIErfHbIGC1TZs2GuCN+hepH2k/otiGb6I022233TQwobT9KmI74xOMK5DaESIdgfUEtON3cXME8hyBqa7sledPyC/PEXAEHIHqigDqXFGFrlVWXkkocauxUg2pvUkgmKWwdPZJdvjKoUFXf4v0nJakX0xla6+xmqZkTLYPKR/tXlKRypId7+sdgVwhkG1UUfz8ELfq1KkTX11iOd3InRIH+YIjkGcIPPLII6poRzrVXXfdVdX0kIUnIuzCCy9UEgeXzCAYaXZMIh5yBs4DDIcISnkoexE12q9fPyV6sY10p7Vq1VKZe9KLEGVGvenKolOHmyPgCOQXAhCrIXcZkROHYjpEL+7C0ipH78jqia7zeUfAEXAEHAFHIBMEIFIxIBpXMCDwwNTAaLOi6sygKcrNKExiHBslfzVo0EAJYSg8Jwr6yeS6OD/qDwMGDFDF6Xbt2mVyeNr7opjJYCX/n7kvUvu5lUSA9gZkc1OOK+uzLVl77pcgKU6bNq2Y4IVKOe9qixYtZOzYsUIgQaJ2Ve6vxGusaggQtAhxkILKf9++favaLfr9BAQgB8X/JzowuUGgWbNmGqg0c+ZM/RbnptaStfB/HH/ajBkzdEP3EAx/xhlnaKaKknv6UiYInHrqqUIAGlk9TjjhBPVpQPzv0qWLXH311aqcV7t27UyqrLR9afuhMEcbE+IhKVsvuOCCEoF1lXZxfmJHIE0EnOyVJlC+myPgCDgCjkAZEAjOoBqh4ZRLW7TkV63um8U/y79C2sVEls4+iY4r5HU1/gqCnWGw0K1wEGBwFwekW/YI0Hn3Qe7s8fMjy4YApCsGEAYOHKgDXzg9HnzwQcFhhXw5DoOmTZvqoNH9998vRK61bt1aLr300mIHE46FQYMGaWq2/v376wWxz0MPPaTqChDCSKeDkfKNyNKGDRs62UsR8T+OQOEhgAN0+vTpmobxueeeUwcp6Q+GDBmiJFG+FaR2RH0CUigKf6QZwH799VdN1Qw59IEHHvAUr4X3+P2KHQFHwBEoOARWXXVVJXJB5qKNGrX58+drG9hIYBDBUOtgwAxDtZnjIH8ZAYwpBGf6wukYg7SQpElBSSp3VCRQxcyFEgh9cVS2CcYgdbqR19K5ruq+D32dgw8+WDp27CgtW7ZM+3mWN24o1JGW8fHHH9c0jT/++KMSD3lvSNG455575s21ljcWXn/5IbBgwQJN7/Xkk08KpBW3qokABGDUp9xyjwDEW1Lyffrpp7mv/O8a/5+984CXorze/0tMxGiMUWNiixJrsCGxxUQFsWCLBRuKPUrsiAYRC6AIKliwgopRFGwoWKIGRMWCvSs2UPkZRU2sEY0l/8z/fA85m7lzt8zeu3vv7O45n8/cuTv7zjvvPDM7877nfc5z6GeMHj1aFzuIBTjbZ1+Xj0DHjh1VAQsVLPpnfM46+TvfWeJfhdj1yiuvqH926NChAQVbN0eg1hBwsletXTFvryPgCDgCtYiARP11+Nc3FWk5aRWPu+6u8Pw7CxyH/SfcFQ7bcqOw92/Wy9WfpkyucJ390+Gbb0MQNRm32kEA9Z85c+bUToMz2FKiicDRzRFoawSef/75cNZZZ6lzCocAEb2QL4huI1K8r6Q0Rs0L1YMePXooweuhhx4KvXr10mgxay8TJEyW7LDDDrZJCWKLL764Oky6d++e237iiSeqYl5yoi1XwP9xBByBzCPARCPPDIihTHYfccQR6iCl4aSoYlJh1qxZAfUJIsm/+OKLcO2114Z//OMfqmwCQZTJaU/ZmPlL7Q10BBwBR6DuEVh++eUDC+q1cWOMBvGLCTRbkx7nnXfe0fcXE4OQvtZbbz1d1l13XV3nI3BBgIZwhsIXhpLO6quvHi655BJVkYgfN+3/BAyRFnrYsGEBwtrWW2+twRsEaaBOzfjSU/c0RxPcuLb0UUjXxEQpJCoUPFAf3n///dsFN+4zS88IoZ5r161bN52MhqiRVj21+Rn7FkcgPwIoeqNiM2HCBCcP5oeoLrZCFnX1v+pdSrAF42qaX79qohtCrZHn8KFMmTJF+38vvPCCpqK86aablBTQXSKYAABAAElEQVReXaS8dkegegg42at62HrNjoAj4Ag4AobAKquEhf7+SRCPXpBZa9vaojVpFc/ccxtdrIKOP2j6OktTxvatt/VCH34cguDtVjsIrCLXy1K61U6rs9NSBmmQ5Ugj4eYIVAoBZLyTlm+yB8cuEx677bZbrviXX36pkwlxhxVkrcMPPzyMGTMmkOoxH8GTCa98loyOI/oR6Xk3R8ARqF0E1lhjjZyq5worrBA22mgjPRlUu2bMmBE222wzndRmEpyyTFpiyyyzTBg/frymfX3yySd1m/9xBBwBR8ARcASyiACTq/lSQtJXRgUMUvOLL76oC4ESH3zwgZ6GvRd5N7Kginv//ffn3psUgvAMEfrAAw/UAAtIW6RCT2svvfSSplJnTXAGKSJJN+lWGgFUUlBiYUHNqF+/fpriExVSxihXXHFF+POf/xzWXHPN0pW1osS3334bCKJBvQuSF0R5+kmkZ6RNKI6RbtLNEagmAuYjsHU1j+V1tw8C+HvSqlC2Twtr+6hg69kuavsa1krr+S0TnEtWhpdfflmDcK+55prQpUuXWjkFb6cjUBCBprPjBYv5F46AI+AIOAKOQCsQkGinDl9/ExZ67+/h/63481ZUtGDXJRZdpGQdacqUrKTGCkCo+94XX4YgeLvVDgJEA6LUgXMS4pdbeQgwQJs/f37YYIMNytvRSzsCRRCAPIjqgBmTGR999JF9zK1ff/11nUQgtUwpO/PMM3Xyg9QwpLVBtSuNJcleafbxMo6AI1CbCJCulcnvxRZbTNNIoRCIcgapEeJWiBwaL9Oo/5NSh2fzp59+qum+sowD15v0nZ07d3aF0ixfKG+bI+AIVBQB3nGM3ZLjN8bEKCzQr2ZBBczSmy+88MIF1SwhSZMm8txzz1WlzFJ9Z5QyCcJgHA7ZrNqkpIqCl9HKUM2C5HXMMcdoamoIehC+9txzz4q2mHuEFKEQvKZNm6aEPxTh9t57b03PiCqbk24qCnnNVQZp5K9//auq9pG67eKLL9ZJ/XHjxoUVV1wx3HbbbboQgMUzANXsuEr8o48+qoovBFWQQp1nBYq8ZgRmnH322Zq+EbVBI4nacwfVb/MjfP/73w8nnXRSgMB66aWXajtQwLngggusOl87AplH4N1331VCLaRalOwHDRqU+TZ7Ax2BOAIEGdAn4dn7f//3f9o3QSl9nXXWiRfz/x2BmkbAyV41ffm88Y6AI+AI1AgCXbuGaJmfho4vzQ5fVYDsVSNn3ebNXPjF2SH6saT8EgeXW+0gQLQzziXSHxx33HG10/CMtBTcSPXRVZ4zbo5ApRA4//zzlURo9RWKCl900UWVkAGxIDlR9PbbbzdRnDvvvPNU8euNN97QSRAi0dNMRpjj2Nria0fAEUiPAMQfJmtIM8SkDhORWTdSvw4dOjTcd999oX///jqBTcpYt8IIPPPMM4GoXCYh5s6dW7hghr9hsnrnnXfW94OT/zN8obxpjoAjUDUEUGUilSKLGe9xJuR4HxYyyB0sRx99tKp8QeYixWM+GzFihBLIIHjwv6u15EOp5dt4l0GWOf7445WARYDLscce2/IKZU/U10y9i/4cBBtUkyHVkJ7RyDatOojvXDcIoPbHMwODdPXxxx/r5P5TTz2lBNKHH35YVV1ILXvkkUdqSvXnnnsuQMCfOXNm2GKLLZQUgPIL9zEK3qQIRWkXNcEtt9wyLLfccqoOgxrhjjvuqMeyMfthhx2m6Wi59++66y4lelGA7RBdH3jgAS3vfxyBWkGA9zC/De5n1BzdHIFaQQCiItkVxo4dq8FzBx98sPYnPa1zrVxBb2c5CHyvnMJe1hFwBBwBR8ARKIlAvjSNsq1Dn/3CDx9/OYT/SCpHt6og8MPHXwodevcOQaLHmlgF0mc2qc8/VBQBov2IeCXS0K08BEi1R3ROb7nvzblWXg1e2hHIj8Duu++uaWFwFrPE0zTG91h//fX1I6oDpBQ1Y5Jj4MCB9jE8/vjjSkQgFRuT+TjLLrrootz3hf7hvkZqPClrjzqYmyPgCDRF4KuvvgpM4ECs5L26/PLLKxmYaHwmbCBaZt34ve+1116qSEDKKp4/qJm45UfAJuUsxdd+++0X7r333jBv3jxV9eK5nOWFexZyGsT1Hj16aIrO1VZbTe9fSMRujoAj4Ag0OgIQoHk3MmYuZTzvUQRbe+21w6hRo3S/+D5sO/XUU8Nll10WSDnoRK84OpX7HzIWakpgTDpFJlnLsW+++Ub7QUcddZQSudZbbz0dN6GCSfolyDsoN9n35dTtZesfgYkTJ4Zu3brpidKPRkEfohekQAiCqOaiTkTKUfpe9LfYhpFOFh8TpEX636QE5fnD/tjIkSMDAQaMNUhTi6LgH/7wB/3O/qDYetppp+nH22+/3TYHFAgJUCRVu5sjUEsIoIB3wAEHaJP9vVlLV65x28rzdo899tDgW9J80xeB/HvJJZdoAG7jIuNnXs8IONmrnq+un5sj4Ag4Au2BgMhcS7hT8yMfcUT43kefho7PvNL8O9/SagQWfv71sNC8v4dw1NHN65IUd6I/3ny7b8kMAkQhEy3IZJ9begRuuukmnSQlItPNEWgPBPr27avpGG+99daw7bbb6mQG9+O+++6bS8/w+eefq3MMtbClllpKUziQvgGCGJHqZkbgsrQPbIeswsQVDgqIjTwnSGmDcxk1AjdHoFERYOKF1EsQpfkdMgFIqhWi8UktMXnyZE2XavjgmC6k8mFl2nrNbxuzNf/TbiYwt9lmG31esI20A/EybGt043nJJB0TZhAAHnzwQU1/OWzYMFWEQXGhFkhyqEgw+QghkVRDEL+YyH7ttddUFeL0009vRvZt9Gvv5+8IOAKNhwDkZ977aYwAie+++05Ts5Em0vraU6ZM0W08a48Q35Rb9REYMGBAII09pCxSLhYzFJIY7xBgs/TSSyvJhuAZyDqoeaGSZN+jjuTmCBRDgDE0tuuuu6qSNkEBqH3xHOEe4zML6bxQeGG8jkEGhdgFuYX7zoiKf/vb3/R7FGJIyYjKl9nGG2+s/8aDDw866KCAUiEqg6QexSZMmBBQlXFrPwS4BpBQ6We7lYeAKdLbury9vbQjUH0EPvnkEyWGk5oRBUaCv8aPH68kr8GDB2vfovqt8CM4Au2HQOmwmPZrmx/ZEXAEHAFHoBYRWHbZEEQmtZnJYLjD/vuHH0l6lW+6yMB44R80K+IbWojAd/8Oi9/5UOiw5x5BZoaaV4JjguvillkEunTpElASOumkk8J2221XExOU7Q0mahiQZVDxiDvb2rtdfvzGQoDJCCKAiRqbPn26LkzcX3311eoIfvPNN/W3zdocY6SSIy0kcvj83kkrxwQ/ZDCMCGBUwXBEovADCZRJKdLX4CAmtRvEDyay3ByBRkJg1qxZGn1PqhUm+lB+gMTF5Epc/S7fb4PfX6dOnTIFlymNoThgZiljb7zxRlUbQBXw2Wef1a+ZqEb1CbWBODnUUv7h0MSYVGKCqV6N+4CJOjCAGEX/qV6M+7lXr146OYn6I/0cSA6TJk0KqNu4OQKOgCPQaAigsgOhN0l6Rj3KFHCTRLAlllhC3B/L6rsQhalDDjkkQL44/PDDW51SsNHwb+358h4jXV6fPn3Cyy+/rIqrVif9OUvPiCIbwTAoLZ177rmannHFFVe0or52BMpCwMbdcRUiFLzoZ3OvFTICBT777LOw0UYbBRS8UfYiRTjG2B1VuaQyl5G8bE1ZyPykL0Xh69JLL1Wi6T333JNK2Zv93aqDAOQ+CH34XRkX4mtBdX3TTTfN+WoqdWTGcJDLIJb94he/UL/P3nvvnaseAiFBS08++aQGLOFD4tmX1hj7EiAECRYSM+86nrHUybPztttu0wXfE+RFUhfzbjSDTMvY0o7P+5HgE7N//etf4eyzz1ZFet63tA+z+xyVPAtSJPAGTCFCcr/TDp7nF1xwgVXna0egKgjQR8Q/yu+Ae557lcwfqDWipOjmCDQSAq7s1UhX28/VEXAEHIG2QACy0X8npZodTgYK3/vmu/Cj22c0+8o3tByBxe56OHzv8y9DOPe8/JWIEy0vCSx/ad/aTggwsGewjIqDW2kETj755PDpp5+qA6J0aS/hCFQPAZyD7wrJefbs2WHOnDnh7bff1kgyjkik8PPPP69RxKSVw1AZwOnGpNV7770XdtxxR414hxDGNiKLIXphKIThWP7oo480XQTOtWOOOUbJHEOGDNEy/scRaBQESMu05JJLhm+//VaJXvwemOCNE70KYQEB7Je//GWhr9t8OykETjjhBD0uqSdRqYL8haIXzwQIW6gELr744uHCCy/UCYihQ4eKeO4XSi5F1Qxj8pTJIyYqmMDAIJ+SYqYejYkJJtl+/vOf67O1nohe8evFJOVxxx2nKYB5T5BuiHeLmyPgCDgCjYYA7zsULpnAQ7WRSetddtlF35tM2qO0A2EIAgf9cd73kDWYYCetL0EVjK+ZhGZC3K3tEUCVGPVVxjAYKl+QEbiWfMeELMEujHcg1kA6cKJX21+nej/ioosuqoEC+dJkWx+LIAKCseiXX3nllZqm0XBh/IHRxybgpJTRjyc4hbSxN9xwgyrPos7t1n4IQMLjXYIRbAcZiXEFqTdJx8m7BJJTa433EqlE8ftAQiFgAwIK5DIzxnD09xnHcb+h4l6OoXoIOQuCC4Ei3LsEIaJMB8mQ991hhx2mQTGkMN5kk01y5zZz5syw+eabBxSQeE8yRiaQxgKRGG/yPQFH1AtOlMOM7EXdPLdRv4MUyTsWYzuEs3odo+lJ+p92RwDVViNtkmEB8iTPWlRAeXY70avdL5E3oB0QcGWvdgDdD+kIOAKOQF0jIJF4olUdZBQdJGyq6amKc67DZWPCoqLE892qK4Zvft256ff+qWwEFn5pdlh02mOhg3Rmw0orNd+fgapEwkqYT/PvfEumECBSCmUfnJtM6u2www6Zal+WGoPDgclvIuVw+rs5Au2NAE4vFHeqYTgfk5ZvW7KMf3YE6hEBnOU473Bu48gmchhHOVGdxQwiJep4TCri0E4upHsxFYBi9VTqO9I3s+QzJjpRrTKVL8qgSGKff/vb3zbbDSd7vRuTa0zAofpBGueOHTvW+ymrihsEN857q6220uh67/fU/WWv6xOk7/7HP/5RyYuF1OpQNEURBZIOEzhpjec8vxMmc++66660u3m5jCNACmYCfFpKkoBYhPrJQw891BDvjSxeTggvqL1AZn/sscc0GAZCAH05+nRGHshi271N9YMASl0333yzqqaimGr3Hf0siDF8R8AVgSSmwATRFOP9AgFxqaWWCqQKe+SRR/R9w3cWdJIci1AWEg9+K1S6IRK5tS8CEP64lmamBs07hpSbEK4YX9D3gEC10047KRHMyqdZE8B3/PHHawYCS9vJfYXSF/fdNddco4GBBPv07NlTq2Sdb3xX7HgTJ07UwEGULyF+Ma6EnMV4liBDCIwoiuFbNiIYakd9+/ZVUhj3K2rRqNkxjuQZDVGMrAkjR45UUiPESN69LJDhUGo0wx/FWBxSI6Qv81/PmDFDn+tJBTzbz9eOQEsRQA2d5zT3Pj4g5lDI9HHAAQc0Iea2tH7fzxGodQRc2avWr6C33xFwBByBrCEAQWWhhUKQ9DN5TaJXwtFHhR+P/0v4wex38hbxjekQ+P7b74Ul/nx76CBpCcSLkH8nIcWI9yGIJy3/9741Uwgw8GZCF+cSctpuzRHAUb+/pITFmUE0nJsj4Ag4Ao5A4yGw6667BiI6ST/RufOC4IFSZC3esWuttZYq6xFhz+cttthCHeGQA3Bu49yHiEDaCghFvItR2WprM2KXHTf52bY3ypooXSZcmAhhoqQRiF52bSHEEE3POTMxnkZNwvb1tSNQSQTiE6QtrZdJcVKx2wRrvnqYoESp0JRW8pXJt42JS94LKKomJ90r0fZ8x/Rt1UcAolBLiV607swzz9RJaFRK3NoPAYgAXAOuB8rHKBSj7GWEm/ZrmR+5HhGwvns8VTr9fhRzb731Vu3vo0gEUQUlbUs3Rzo6DNVACDIox2CMByC0kAoPg/gCqYV3Dvc0hsLS9OnT9X/7A+mHOlGkRb3XrX0RYLyX7B9Yi4y0Rz/77rvv1mtMHxwVd/osKLOnMe6Dr7/+OvzmN79pUpzADWzy5MkSp72SBh5xnxHsi5I7Y9NyjWAljHEx4+ANN9wwXH/99UpYRKmLzyz0qXjuoiCPcVyIXTyDn3jiCVXnYjvqSBjKZCh1MTY223jjjfXf+DMb3/UyyyyjRDn7zUHqN5Kb7etrR6ClCKDSOnz4cL1XuYfJiAKRELIk44QRI0Y40aul4Pp+dYfAgh5M3Z2Wn5Aj4Ag4Ao5AuyGALDV56C+6aAEBSQYczezCi0KHDz4MP7ns5vD5Yb3Ct2ut0qyIbyiOwA9enxt+csXk0GFrcRiISkVBkygyGfkF0Y0uWMS/yBYCRLEzUMYZRGQ78t9uCxBAlhw5cCZ8iZB0cwQcAUfAEWhsBHBuk86JCRgc17NmzVJnd9KRT9TysGHDmoDF5D8kIhyFtpDSg5SsKIHg8Ca6H2OyGTWwTp06NVMFY3ujk7GaAFvhD1wnJuLAmGheS79S4cNkurqll15aFSGYsCH9J2lA3RyBtkSAZ+rWW2+txMOFCOyqovXr10/TCTEZWo7RLp7fTHjGyb/33XefqjqRys+tsRB45ZVXdELQ0k811tln72xRWCXVNMQDFDncHIFKI8C7ioDABx54QKuGlDVw4EAl7tCXwp/EPQgpi4X78Oqrr86loEO5CDUufHKktEMJCf8T+2200UZa18cff6y+qC233FLT8+G3e+GFF8Kaa67ZLBiB9xjl2Df+Xqr0eddbfRCuIIaTUpHF/m/pOl5HcoyYDzsb//EdilwYQUCMOS3ISDfm+TNnzhzdmrzepnTFfQVhChWxffbZR1WnIXqhrIVKUTlmx4j3y1DjYsxEauNCxriYdMfclyjeoeyFsjQG8Yx73NprdRjJy9ZshzyHEisKX7QfMiRpKS9iPsjNEWgBAvz2SDOKQi9qiK+++qqSZSEvojjXvXt3JdC2oGrfxRGoewSc7FX3l9hP0BFwBByBdkBg0KAQ1l47yMg4iJ5w8wZAAJPBTAcZeC9x2YTw5S7dw1dbbxJkxNO8rG9phsAPH3gq/Gjy/aHD7r1CmDAxSE+3WRndIMoHouMcwlVX5f/et2YSASL/iDZEvQrHEakdC6V6yuQJVKFRTPSed955YZA8W3DejRs3zp1lBXAeOnSoTsRBUmBS7kpJ8Rp3/iR3A9t4ypv58+erUg7OHsgOSNq7OQKOgCOQZQRwOhvpi2hqSF9M8OIAN4c+qVeSxn5ERLOQ4iJpRHjzLDUimK1JJ0i0/wcffJBLBUKqlkJksE5CEFtkkUWS1fvnlAgw4Ua6HFQVGplUR6rgyy67TCeCevfu3WwSJiWcXswRaBECJ598sk6e029sCyuX6GVtSipAQSqBLErKOLfGQwAFFVLfMtZxa38EUKfkPQ5BH4KAmyNQaQTo+xdTSEKl6d133w2k2mMcsMoqq+ja2kFQIX1/lJxI+YdBIuYzxBYMwgFqXtRD3x8CEn1VK6+F/vvn22+/1dR69N9q3eIErFKkqzi5qlTZ5Pfsa+O3YpiheMs1AfdC6yWWWCIsu+yyuTKM3VAKKmX4ZBkHkgYR9bczzjhDn1mliF7Ui9IVxtgFsqEZSlkYKm8QWlD+giQICRY1LlIxMiYlXX1rDDz++c9/BkhfEBDjxliWe5ZxLGMJCFooWt9///25YtyzGONdrnkpNWXwQRGbexy88EEm+2K5yv0fRyAPAgTfQb6FKEjabXzQqMqR+hkFRoiHRmzMs7tvcgQcgf8iUGB22PFxBBwBR8ARcARagQADChkwhAEDgvTOgiS5b14ZBKXx40OH9dYLi0mkVcdZb4Z/7rVt+H/LLxgYNd/Btyz04cdh8ZvuDT94Y27oIIPNIE73ggQ5idIJEhUdDjoohC5dHLwaQ4BIqxslFSpyxUS34xBlIB6X0a6xU2pxc1FpwYHw6KOPhrPOOiv86U9/anFd9b4j6QdQg3vwwQdV+QOiF6kD1llnnYKnjiON9APcc/yPYwinDgPtL774ouB+/oUj4Ag4AllDgEkboj4hfsVJX7Rz9dVXL7u5OPpxiLPkM1J0oARmJDDWfEZNgGjtTz75RHejXUw0dBLSl9UXX+MY51huzRGAgDx48GCdYOnatWvzAg22BdLKNddco30hUxpoMAga/nQhPRL0wGQl/btevXrpxBrAQGy69tprlVy6noyx6Rei1sBYAtVgVHFJcUgaKyYVLaUQ+zKxQopU+pCoTpCu55xzzgk/+tGPZMh5sv5POSYuIc8yRsFK1auFyvzDuU2cOFHTHEHSQn2CIASIO5wDz3ei/WkH6Vt4vmJMEKMEwL5MZPI8RlEFlQr2mTdvXjjiiCNUyaLMJnnxGkWACeyePXs2IXPU6KnURbPp60C8Q23PyV51cUlr8iTol0OgL2QoyMZVZLlvk/10fCcQxTDUf5OGXwVywlUSeAupp9jxkvuW87kcAlaSVGWfjZiV/GzbWbNUkoAFCbcQQYvtxb4zcldLyB+8E+hHFzKCJLk/UHODBNW9e3f9bKk6C+0X377JJhLILvbQQw/FN+eUtkhJz5iRPho+XvosPBfpX9FXaS3ZC6UulJBRqaNfx/lg+FNHjx6t39G/g3C2N1lZxL788ktdQ+inb0UQE+NYCGtGlrY0l8n7gLKo4dE/o49F/8zNESiGAON7fh8QvFBeffnll9UfDakLlThIty3x3RQ7pn/nCDQCAu5RbISr7OfoCDgCjkB7ICCkDPHKBpEnCuJ1DTLSzd8KSUXSQSJXvv+HQ8JSw8eFbzZcK/xriw3Cd6s2V2DIX0H9b/3+3Hlh0QefCR2fmhXCWp1Dh8ceC+KBL37iBx+84HvJZ+5WmwgwKEedBHUvJjrWWmstVbU66qijdAKmNs8qfatxRpCmCLl0JniZ3PKJ3uL4gRf3C5N4Y8aM0TQDq666atGdcGjFU94QTWipC5566qmi+/qXtYsAjjxz/NXuWXjLHYH8CHBvJ0lf1ZhkQa3rV7/6lS75WgJ5Nk4Es/8hcPO/OdZ5DkP46lSADMaESKP+XlFKYIIJsonbAgSInt9ggw3UOc47361xEBgvgVKMDVAtIaUnRC7uASbjmPA9SIJ8UCThuYQyA/+jYrHzzjtruQESiLXDDjvoBCD7Mgl9yCGHKICkEnrrrbc0FS79QtRPIP1DHiNtEUQrVCIOljEmk7AYzzGOX6xeLVjGH9QtuMcJRGCiEkMtgoAPJodI57K2KIjz/CT1FmQzJhZZExDC/kxI0s+BqMbEI88PUhUdcMABSiArozletMYR4D6iP+CWHQR+/etfK2E1Oy3yljgClUXg4osv1sA7/DC8J3lXPfHEExVJR2iELFunUduMK2AZUSpJpkIBqxQBy/YttKbOlhCwKot+8dqs/xIvBbEP5TYCa/G1kkoRAlNLDTUi1K0gstB3gpSPoVj0UwmEJ9UhaRLxc0JsgbDOPlg+pWn9osAf+j4Y/TdTDuvbt6/2mcgWse222ypx7cUXXwx33323psejvJEX6VNCaBsyZAib1efKOJU2nnTSSUpAgxxHClQjvEFIwy/LOZoRYApxDdWythiboMzHb+oxmRvhHFGNdMsuAgSUPPzww0rwguT13HPPaV993XXX1euHWmK3bt3yqiNm96y8ZY5A9hBwslf2rom3yBFwBByB+kBA5NkljCSEzTcPIi0TJISk8HnJQKHDM5JuUAY7Hc85Oyxy3rXhP0v9JHy7+i/Cv0Xp6z+LLxaihRvnldXhu3+HDl98Gb4/7x+h45x3w/c++jREErndQRz8koeiMHHOECaNJkQ7pJhbMUi16nzdvggQGUYUPhFf5wp5j88rr7yyRqozOEImvB7SQzGZS+Q9Tnki7pDFxxnMeRNx1qgT3WnvPlOYMccN5IFSRC+rO5/MutVjZXxdPwgQjYlzjig67hM3R6BeEYiTvj788MM2P01SFXURdVWWfIaD3ghgtkaJBuIGCj2WRoNJGohghchgOODr1S6//HIlaNTzOZZ77egbbbHFFprWoi0mVMptn5evDgLvvfeepnVnQo3IdwxyE5MmpAFCBRdiFkpWEE2ZCPvoo4+0HAo6TOahUoFBnILMxSQfZC/64DNmzNB6mfQkwIRJTybRMMYeBBLwTKUesxMkaKtYvVaunDXqdUsuuaSS0mw/yFqQvCZMmKCTj6iSYUwqmnIG4yHIcKiCESBi36NwhqGmGG+7bvQ/dY0ApD9+A/nSONf1iWf85LgepGxycwTaEgF8JbzrjCSVdm37WHn7XGxtBCxLF8h7LWn07QuRpmw7PhoIWPbZ1kmiVrHPtUDASmJTzc9G9qI/w4JCW58+fTS41hS5KnF8FLUgm0Mc22uvvXRMB+GKPgt9HMheKGuh8gXRa86cOZrOkbJpDH8O7UZNGkMVbKBkTGHNmGnq1Klhjz32UMIZpDP8x5AOjRAGmd4CPFFzve6665QUxn6Q46mLNqLWRb/yZz/7mZK46G+SGjKZ2pHU25Rj30oT/ujT0q+D3DVz5kxVKPv8889zMEH2cssOAtzXZOdAgdoWexaiSMwYlvEL5C768W6OgCNQOQQaZ+a8cph5TY6AI+AIOAJpEUB9SgYNQSKFhY0SJEy38J4y0JKk8aGDLMJsCd+TVGQdhfnf8fGXg+gHhw7ffFt43zr7Juq4cJARoKh4rR06HCmRqBKN3UEi+FPZ0KFB8myEgDQ1RDu3ukCAAfP+opLH8vTTT2sEO8pX06ZNU3ltnFe1bhDWiHRjggklM1QIkCB3K43AeeedpxNyOH1Ii8HEHVgSIVUsLQ8146iMp7xx8k9pvAuVYPIRxQyTwy9Urr23M2mKY9Ac0e3dHj++I1BtBHDmW5qvah+rnPohJ7CQLi1pPM9JOWYkMFtDeCAyG0I0ZTBIGJ0KqIJBcEDdphYNRzETEBBY3JoiQH8QAg/9v3og/Dc9O/+UDwEUq1C2IrWJGROETHjZbxx1Voy0ddwXkCpQ55oyZUpg0pjgEYyJGAICGF9wDzH5ye+NVFRMqjHph7pXcnzBs9QsTb0tvTeTk4gc0yZoUS0zY8wASQ1VM9vH1lbG1vG22zZf1zcC/F4w+33U99nWztlxPXi28BzycWftXLdqtJT7oBwSlZUttDYCln1vn1mnGffy/jBCVaF1IQJWsjyBc7xT6aMnv3MCVjXupnR1ci0w/IyQ5HvL/EM13hHcJ6iwQpgiRR1kKMZkZqQAJRCJ5yBkfj6XQ5KiLPUXMgj9jBUh/tP/of54P4i+JOqvKJoZJvT7+Gz9LXyJqHlRD23nd4XispWPH5sApWeffVaVWOPby/2fsa0RhSB3kVqcc+D3SzCCKbfG64XI5tY+CHA9XnnlFb32qHVxD7BGfZffFSrEqAOj2EugSmsU89rnDP2ojkBtIeBkr9q6Xt5aR8ARcARqDwEiU6TjLzkfgowSgowOgowOip8HBA9Z/udOLl683r5t0XmLk1tGq0FCmhdgLGkq3OoTAQZMLG6OgCGAbDkpwJBqZ/KOKEKb7CqWlidfyhur09flI4AUP9GSacheOEaQ8ieF0mhRviTdA47AcePG6eQs8vgsOAFRcUFKn/QKZqQEIGL0s88+U+cd5EgmdzGuK1GYTOriYIaEtt122+l3EL3OgRAsRuQnE8HDhw/Xz/7HEXAEsoMATnx+nyyb5yHv44x/5513mpHBcIzfeOON+uyws4H8i5O+U6dOuuZ/W3CQ2/vCymdlDXkZpzBR4m5NEeCZzuQlyktE0rvVPwJMfmEoQsQtPklpE4VxAgWESYxUQaiCFTJUG4ZK0BC/u/79+2sqSCOH2T7xicK09dq+1VjHz7NU/fG2lyrr39cHAkbuKOfa3yEBhxBpmdAuRy2EY2211VY6SU4QTSFLWy6+PxOn9Pv/IsrtpKQcPHiwft2SutixpecYb1Nr/rfrYdenNXX5vpVHIE7ASpKmkp/jZCr7Lu06LQEL0jDkkyRhKv6Z9yJk5/i2Uvvk+97uzcqj6jVmBQHuExS2yJBQjrX03kBlCwWjpNFfQ1UMW2211Zp8PWzYMPUDNdmY+IB6tKl6Jb7KfaTNybpzX8o/kKdYzCAoJtX9aSNEMQzyYtIgZ3Eu+LR+85vfFD1ecl8+8x4giAn/FX4w/FI8g+jf0X58ZmaMffMZ41u36iLAdcLvgL/SFsYlEL0IuOA5zW8KvyUp01HJI+V6Of306p6B1+4INAYCTvZqjOvsZ+kIOAKOQPsiINLFovu7QOGLCRsZCMhIoH3bVE9Hf+aZIFI+QXL+BBkVBgn5rqez83NxBByBEgiQasccIZCNbGIcJyqKB0RR5UvLky/lTYlD+dcVQgACFiodGI4Toj5J2/bUU08F0pY9LMqWOLtQ8SHqFCIfkz04ppncR/2OiVacbkRm4miB7IX6D2m9BgwYoCpjSPRvv/326oBD8Y3IOiaMXn/9deFgH5yL3KzQaXk1joAj0EYI8EyH3FsoXS+TbXPnzm1GBiN9K88JiKIYjnQmPnCUGwEsvoZs1l6OWtI6E3lvBJY2grYmDsN14R0ORk72qolL1upG2qQgRHDSn8QNda84ITz+nSkw0L9IGs8JFLoghJI6iP4I/Q9IlkzcJS0+2Zmm3iylZ4m3PXle/tkRMAR4P9IfZ12OMeHN85jfqU1+2/5Mktr9V6yclU+uUShjPAD5ctddd8193ZK62Lml55g7sP/T5gjkI2CVIlUZEcvK2edia75LQ8JLS8DCL8HY1YhVRsYq9Nm2x9f222lz0P2AdYkABPlyiV4AwX70l9rCUG2Nq5jmOya/kfa2sWPHhn79+mlaR9JQWlrtctrF7xtfJs8exqb2/EHxLI3hC4P45tZ6BOhTfPDBB9oH4nria4wvvEswxqCkY4Tgftxxx4WuXbuGzp07NyMKtr5FXoMj4AiUi4CTvcpFzMs7Ao6AI+AItAwB8qjLRLUkhg+SmH4B8UsmoSVnW8vq872CzNaHcNZZC1JlSt5zydERJOzGkXEEHAFHQBHACZQmLU9WVV3yXUYkwJmEXG655ZSgAEkBNYr2IiPka2OabRMnTlTJfqTpIX4dffTRKnsOqWHPPffUiRjU2n73u9+FW265JUydOlXTKvXt21dTmlGOc8bZjhLHzJkz9bAnnHBC6N69e/jjH/+on8+SdwQy/qeeeqqm9yTKDrUvHGuUc3MEHIH6RIAJNVKcseQzHOpM+CYX0i9AEjOHLhHelnokHyEMMke1JuLef/99dSjna79vW+BsByO3xkDAJidJa3r44Yfn0g7Rj6CfgEJoPoMQyiQlaqCohDIpgzGpQ/T9wIEDdYIOtVEm7SzFCilYbNKN8vzOmXwjuIDnQpp6s0D2sucTygNutYsA5ENUIlAOqabxG0A9i/deOUafnBRY9M/jBGWU8pgAP/3007W6QuWKHQt1T0gGBH7ErSV1sX9LzzF+7Eb/n2cjBKw4cSr+vxGsSq1tHyuX7zPb4s/iQtgzJkySqeKkKb5DAcsIWFa21DpZB5/tuVqoLb7dEah1BPjdPSNB1QTZsUAoIp1hWxjqSCxZN54lvIdIszhq1KgWZ5/gfUvfErV7xqGkEqfeQkpecVy4LvSP8Q2yLLvssnn/x//V6MZ7hqAOFkjt9r995v42zPEP08+HiIfKKb5KCF30wwoFlzQ6vn7+jkAWEHCyVxaugrfBEXAEHIFGQQCn2bRpQTzS5JII0lMMMpMdRGpkAQFszTVDkNz24kHOJCJI3pMqq12MyJZPPw0SWhFktIn+fhDPYQirrx7ChAkh9O6NF75dmuYHdQQcgewikCYtT3Zb37xlpEZ55JFHmnzBpArOaxw8OIuINoMEFl+YJEnjKG9ScZEPTBoyaRo3tqGawwSpGapqkLfyGe3DiNLnHEjPiloHk6lMNJlRH84WlDswJrqIpGTClnSNpPFE/YZznCKk35/Ie9RSL1EX+1I/kxJMBGDupFcY/I8j0LAI8JzgGWLEjyQQpJBNEsEggaEWiVPYnMFM+kECY4krgtn/yZRzyeMU+4yaCWkm3fIjwMQFGLk1BgKoczKZhnoQxO1evXrpux7VT1ISYaTBwd566y1d8welIdLSjRgxQlMJkcqRyTGII7+VACzUYD/55BMtTwrYHj16hMcff1wn3NhIv4I0QPRZ6EdBukFZkL5IqXq10hb8+ec//6l78awxQ20As74Q/zNZhaGOan2q+L6kHrLtpAliHA/xplg6S63Q/2QOgfHjx6vqHH39/UQ1npTpG2ywQVXaWS7RyxrBezVu3J/77ruvqvHGtyfLxb8r9H8ytZaVa0ld7NvSc7TjZnGdj4BlJCpbG5mqtWvGVGnGlXECViFSFQTbcglYybqcgJXFO9LbVEsIMOYxYhd9IHwpEJAgD1l6QohIbv9DAB/UpzJHATGr0Dvqf6UL/0e/FqwhFdGvHDJkiCrcX3PNNerDsjFnvhrwc3WXAEaCX+gnkmKQ///+97+rT8324RlJSs1SC0QmxlfxxfxnVld7r3n3MP7D90efl4UgLs6ZcYAt8c/8b/1j2s/50Q9gnI2KHNjz2bbhT40T19v7nP34joAjkA6BbM6mp2u7l3IEHAFHwBGoVQT22COE3XcPMiu+gKgkjmvpkWb6bHAlHyNLT1k6VqGlQtcK0Mh+nKZuGaSE7bYLktxeGiQtkkl8N0fAEXAEkghA9EmTlie5X5Y/k67qySefDN9++22umahTMNHHgoMHZxPOCc6fxQxH1D333KNpDW1bS9c4nVDnShqTrjgLzVDTKET2MgcK7TIjvSKTsE8//bRtarZmggvCBQ4w0jLinJkgpF+bFD1NyNSlJjKd7NUMVt/gCDgCMQRQ5GHJp6LCc/W9995rRgaDcEJgxLx581Q1iOpwmhvxK0kI4zPpNwoZzuxKPKuoh1QTOPohDFfaql1/sfZybLfGQIDfCoRy1LjoB5G+GeUHlIMgC9x55505EjpqX/Q9LrvsMk33OXTo0ACB8+qrr1aFIX5XpIM+44wzFDzSP5M2iD4SqaOPOuooJZP3798/sC+/a/qTrI844ojAdlJBl6o335WJ93nyfX/ppZeG888/X7+6/fbbVXmMybnp06frNoj2EFwgnZFmBuvTp48qQgwbNixHfGPbJZdcoooP6623nip07C7+h2o8A7QR/qeqCFifmUlc1D8gPqKAa8SvLl26VOT4r732mvbvmfDkN8IE6l/+8hdNgU6ABWlU+a0xEQqBEiIABnmIe4uxAUp7kKMZszDByj68F/ntkPooXs5+D0yYo77Hb5e0SRtvvHE455xzcgp++U4ueUzqgrBJHfnszDPP1Inulp4jdRLYQrsgTXJNaCeEUa4FmJESNq098MADOp4zIlapdSmCVloCFn0BW5KkKftsBCz7XGpNfckybKtEHyYtnl7OEXAE0iFAIB2+FkhdRvDiWQ2RnQA6iPD4UlBHZ6yCQThGOZ19i41dtHAD/alEhgCUZSHmr0nwvxjjxnHjxoXBgwfre5b/ed8kSV9cL/rB9P2Shn8Q0hN9BiN/mb/Q1vjd7H/WvEPyGb7FOPmL6895F1oIsuA7nv/xd0C+/yG54dfk3Rpfx//nnjNiF2uWfOM/jss7mGDfZZZZRhewtM/0V4zM1VKieD58fJsj4AhkBwEne2XnWnhLHAFHwBFoLASk4ysz1AsWzpzIXZH/FY9akLCOzGHxkkg4vyOOrYskknRAhdW9PpPO+0AZTF4ijuypkmprCZFYb2YywJAZswVpGv874GxWxjc4Ao5AwyJgA35bA8TkyZNDqbQ8tQYYqUzyOXTi54HTxAynCpgQsYaDaPvtt7evWrWGxPXRRx81qYOoPxyDTP601JgoIOoO55M5vKwuSGQ4bDg/Jmy3E9IvaRuniWImk7pjxozRok899ZTtklszgYJjyFIqxZ1NuUL+jyPgCDgCKRBgQhlnMUu3bt2a7YGDGkWTpDIY6WYhppr6EDvigOa51kn6tqzjC476Shj1EDWOE5z/jTRQibqpo9r1V6qdXk/tI0C/4IknntDfEPedvdM5MxQWWPIZE2JMlkGSgSCFEgITV2b8JiC00P+AcG520EEH5T4T/Q+5nLKW6rFUvVZPfL3//vsHlkIG0YwlaUk1VUgml19+eZNikGzyGUR8nkmcQ6V///mO59sqj0BcNcQmfP/2t7+Fc889N5CynHcH9xUBEYXSF5dq1fXXXx9IF8/74pRTTtHiECapHxWNV199VVMYMfFKP5x3GcQv1ijzsj99dMYdjBMgd5188slKhoKkSR+fFKzxctamffbZRxX5Zs2apekgIRnQbydtaz7Ld0zKzZBgEO5xyI78xmk7BDB+u5AmW3qO1gaUhzk2RC3IoeDN+UJsI9iEdVqjTRhjEsZQccJU/H8jUZVLwLL9bE2dTsBKe3W8nCNQPwjQ74kTu0xJCoIRQS0DBgxQYhdqkYVUnCDE86y7+eablexeP+i0/5kwNuTdkvRPMc5Ezf5UmSPhXXbFFVdoY+O+PsaP+Yz3oAUuQeBLY/jL6AezGKkq35o+AOQsWxj3QhRDeTa+jX66GfeOWfx/+jaMT40gZmv64hDG+Mw7jPc521jsf1uzDfKWp1c0hH3tCDQuAk72atxr72fuCDgCjkC2EJCOvMwaZatNsda8DBFN7AyJzDz0oos0ZVjs61b9i+D/DElniXNsW3EoMnHvHfVWQeo7OwINhwBR4Fg8dQ8Df6xYWp51111XHRqUQxmKlDcYEegYDn0iw7JiRFrivIk7Twq1DecJz1ImA5mgwZGUdcMZhRORSSYi/M3p9eijj+okLd8xCUpUPRMsqHGgWEMUP+nSmFxiPyZFLT0bWDHJNHDgQHV6USfKPDjK4pNnWcfG2+cIOAK1gQCO6dUlzThLPmPSfK6oniTJYEwcsw0nO8bEdCXUWiCnzZ49W98d1SB6VLv+fBj6tsZGoKX9MvoIxSa9rN9o6CY/F1LtKVWv1ddea373kIHcaheBQs9uI37x7mAyGLU63j0QvwiKKMdIuUhfeocddsjtBlnLxhAnnXRSOPDAA/U7JpFRt8L4PaL6gmIWqnsY36Moh3Hvde/eXf9PlmMjilUzhKRF6ncIlJDV1lhjDVWc0Z3y/Ml3TIpBaDz66KN1MhhCA+la+R1D9sRaeo7s+4wEP/KeJsUWv3kCTcAcMiWKZqTYLMdIuUXbIFfYeKec/b2sI+AIOAJJBBhjEPiGYpcRvAjQY2yCb4QgFZ7lkLwgE6U1+j97SIYSFB4hwvszKy1yxcuRYpsgR/xXhQwlTVRf8Y9ByIYABmGK9z/vvEoZpCoWU+ysVL1ejyPgCDgCbYWAk73aCmk/jiPgCDgCjkBNI0BqGpyMRGwMHz5co0greUI4JXHy4Qhk8h7Cl0vrVhJhr8sRqF8ESFNjKW8efvjhcOihhyrZp1RaHpSgcFrxfMOIAkcune0oIGB8T91EOranEb3PpArnh7MNqf1CxrMaghOpXWg7EzekLsmaQaTDIOitsMIK+n/fvn114oTJGSLeSTnE9cERhioOBlGLa845EeW+ySabqLMLhZxjjz1WlcVwZKIyxiQKdUGSI80KRhQrDjJSIDGphLOzpSoIWqH/cQQcAUegDASYJCaVFUs+++STT5T0RbqUSlm1+9TVrr9SOHg9joAjkD0E6LPaQh+P/9OuyylrdVZ7nzT1pylj7WVt45JiV8+IX5B7ISQxpsFuuumm8DsJrEPVqZShpJE02w+VYDP6zfhuUPGwfWxtZWydJAUky1E/il6khoLsfN111ylBuVBKKauXdbKuQYMG6ddgdsghh+j4AHUy0iyaJfdhe5pztHGLBRixH2MQyF68t8sle0Ho9qATUHRzBByBliLA8yhO7Hr55Zf1/QlBCIVEnomsSfeX79lXznEh/0LiveGGG5Q4W86+XrY5ArynIHDtLJlTCEAtZfiwLpLAe67DyJEj1WdZSbJXqeP7946AI+AIZB0BJ3tl/Qp5+xwBR8ARcAQygQCRjDglWYjmOeaYYyoaRcJJrrbaauo0ROELksa9997rhK9MXH1vhCOQbQSI4GbJZ6XS8kACSlqlUh0m6y3nMxF+ELsgeLEwyQMxacMNN9SUjJ9Jyl8k05OGwgqOINKroHjV1sbxSxnvEYh1pEDB/vCHP6jqFmsmPqZOnaoku+nTpwcWnFicjxHCIGpdfPHF4ZVXXlEi2/vvv6+y9pDchg4dGj788EMtf/rpp2vU6WGHHaZKB9auvfbaK9xxxx2aXqZ///6eisCA8bUj4AhkAgFIrCxMfFfCUE256667VHmENG88p+nXQ4SFeIaKCwqQvHcOPvjgoinm8rUnWT/vK5QUUU9kkr93796B5y6qLzyjIQdAZCtXdSbfsX2bI5AGARvDxskzbCv1uZwyVlc5+6QpW+16q11/mnNMcw3bqgx9SZ6RxdbFvkvu25qyEIGsPlRZ0hrjBYhfBNNB/OrRo0eOzJS2jlLlaFdaS5K98u1HwAbvh/vuuy/QN4dY9vzzz+crmmob6S2ffvrp0LNnTw0CSrVTolDyHDfffHMlSzA2IY0V72jea6TRSqaeT1TlHx0BR8ARaDUCkGFRTzTFLtYQTSFxEZiI74eUf5C7zG/S6oPGKlh77bXVb0NAHX14xipuLUeAeRX8WaQXLsdQ3iKgE4U2Uhm6OQKOgCPgCCxAwMlefic4Ao6AI+AIOAIlEMBZ+OZ/0zhaUSKEyh2U2L7F1nHC19Zbb62EL1Rp3BwBR8ARaCkCyTQ8yc8trbdS+zERhnqVKXdB8oKwhIw6zjom37fYYgtVoCLyHKLSLrvs0uTwTEhQD8pWKF6xb1tbmgh82sTEFxGhhYxzfvfdd/W9wwQRqTXjE0UocpHyhFSbTH7F0yoxwUWqltGjR4c5c+aEVVddtZkTjBQuqIbRDndSFroKvt0RcATqAQGUSP70pz9pnx3yFWRZJhYI2kAJAHIwz2NSu6BOQkpcJtlNCbEUBvnq55lN6lwi1SHrTp48WauhXpQGGFPUG9GrGKGl2HdGtEmuy9mnnLJ2nGrvU636rd5yzoN9smRG3rF1OWSgluxTqH7qog8V/z7+vx2r1Lpa+1Sr3uT5xI/D/1k1+v0othQyiGE84+kTHyQptlD3JUUX/dyWpj0tdKxyt8f78Pn25fcMIfidd97RQBfaTF+/pQZxGeIY470rr7yypdU02w9yF0rDO+20U+guavQo5aC0PGXKFFfoaoaWb3AEHIHWIEB/nWcZfXVT7kIBkT4NfWuUyVFvZE0fvhxCcGvahaIUz0FS+uKTKvV8b82x6nlfyMgodHENO3fu3KJThSTt5gg4Ao6AI/A/BJzs9T8s/D9HwBFwBBwBRyAvAgwyccKZ4UhkYmjAgAE6sLTtlVozOT/jvykdIXwRPemEr0qh6/U4Ao5AeyOAIhcOHlPuIj3h559/rs850qyccMIJSu5iEgHyUtI222yzJpuYnCJ6/9prr009Qd+kggx+wHEI+TefQfTCICkUMtRq1l9//UJfNyGIFSzkXzgCjkBqBCBooqTIwnPMUinFK0hTJl6+Lf9nwgKy7BVXXKFk0LY8djWPxST/+PHjVX0ENQCM9FukyeIZS/8aZQAmsUlhfOSRR4ZHHnkk9bskX/0c4/e//70qDKDSwnE33nhjNof7778/kFKrUgY5DRKEkX+SayMHFVvbd7avfS62jn/H/1kx3p30CeIEliS5pdDncvZJUxbySbltSVNvsv3V3qeS9fukaFZ+KbXXjnzp/vgt8PyhX0zaeUi2qHhxz2Kffvppu56o3e+oORYzCMF//etfQ79+/XJBGChnQXYo18ADpWACUEj5bukbeQ9BzIKo1Roj9XyvXr1UUWWJJZbI1d+aOn1fR8ARcARQbec5ZcSuJ554Qp/hBPqh2kWQBCRWguLKTRlbSXRJ2z5p0qTQrVu3cOKJJ4ZRo0ZVsvqGqAsF5F133VUxzDdebggQ/CQdAUfAEagCAk72qgKoXqUj4Ag4Ao5AfSHw0ksvacRO3OGGwxH5ZkvDVekzRhWACZzuEjWJ03LatGntHpVa6XP0+hwBR6AxEPjqq6/UcWfKXUysk/YKCXYUu1DiYr3uuuumio4k4t1Ss/AsHjJkiKbMykcMawyE/SwdAUegvRFgEhXiKukCiTLPZ2nK5Nsvvo2+qE0gx7e39v+3335b0+WyrkcjxUvcmDzCmAi3dJGQwDCuU7mWrJ/9Sa8M2YsUkZC9nn32WSUmFLo/yj0m5XkHot5SjJBT7Lskccg+l7NPOWWrVb+1oRq/jZZcF9/HEXAEKosAzw6M3zi/d96FpOw6SFS8ILxWStGXNGEYKltmH3zwgf5LYIoZk9XYxx9/nAu+iO+LL8eCMlCBQemRcRD+o2Q5U1y+8cYb1e/DOIn3BYZqFsRk1Hyx5PspWRcEL/oipG+E9IWBFenf9957b/0c30c3yJ8050j/gBTEO+64o/rAwJzgEgIVN9xwQ6vK146AI+AIFEWA4Gl87BC6WHjmEWDNs+qXv/ylErpOP/10XXfp0iVv8F/RA1T5Swhn11xzjSpI0v/Hl+WWDoG5c+cGAtpR4bz55ptz5Ox0e3spR8ARcAQcgWIIONmrGDr+nSPgCDgCjoAjIAiQMgASAWo0ZgxQUd+aOnWqOtNseyXXDHQhfOHIJHKICaP2jGKq5Ll5XY6AI1C/CBBJjzKKKXc988wzmlqFiY/NN99cHWOsIWy11LbZZhuNfsfRRmosN0fAEXAE2hMBlAhRFZkwYUKwSelke9KUSe4T/0w/kMliJkAqbSiK7Lbbbpr2qtJ110p9ha5bS9uPuhdkMibwzz//fE2nxUR5JQ0VOSb33RwBR8ARqGcEIHhhTPyT3r13796h0imcLr30Un1Wc5zbb79dA0mWXnppVVlnGyouqLqQYpFU6VifPn00dfqwYcM0Jb1t47lMEMt6660XGAftvvvummYdBTJS18fLMaaBQHXPPfeouuRRRx0VLrzwwtC/f/8wVJRs2AfVTez666/XNvAugTgWr2v48OGaFoty+K8gGaPY+P777+tCfS09x1tuuSWARadOncKdd96pC8cxQ+3r1ltvtY++dgQcAUcghwDkWSN2seaZSOAfRFeIoow/NtlkEw2W+fnPf57bL8v/7LvvvgHVxsMOOyyg3Dx27FhVmcxym9u7bY8++qi+zwj4RM0SdUg3R8ARcAQcgcoh4GSvymHpNTkCjoAj4AjUKQLPP/98+O6775qdHU5HnGY408wB2axQKzfgUIMwAeELcgQTfSuvvHIra/XdHQFHwBGoHAJMIhixizWRmhgqKTy3IBGg3LXCCitU7KCnnnqqKoO5ikfFIPWKHAFHoJUIWF/Q1vmqs+9sna9Mvm2oiDCxwKRCtWyllVaqVtUNWS/kscMPPzyccsopOlFPqsxzzjmnIbHwk3YEHAFHoDUIQKaG6Lzmmmu2ppqi+0KyYkkaJK+4QaJCsTFukKHy2XPPPaeqmfhveO9D7MpnpIBGcctUviiDapl9Pu2005rtlu+Y8+fPb1YuvgHSeUvP8dVXXw2LL754eOGFF5Tk8MUXXyhhA8UvMGJNsKKbI+AINC4CPBeefvrpHLkL1S6UA+kTr7POOkrqgrALuatz585V86O3xRXgPCCn7bfffkpg+/Of/5w6DXxbtC8rxyBofsSIEbpsv/324brrrsu927LSRm+HI+AIOAL1gICTverhKvo5OAKOgCPgCFQVAZx0SEon7T//+U94LY9n6gAAQABJREFU7bXXdLBy4IEHJr+u2GdSAKDwte222yphAsIXcv5ujoAj4Ai0BwJvvfWWqssYwYvodlJJde3aVWXZzzjjjLDZZptpBHi12ucqh9VC1ut1BBwBEEChcNKkSdr/euONN1QhA6IOKYvMiEo/++yzNWUSCrBGxo+TUNOUsfoKrd98882w5ZZbavqm2267TdM5HXHEETqh8PXXX6uyk6XHRUXkmGOOyaWPKlRncjv92YkTJ6qyF4QynvMDBw5UVUbOBxWVvfbaS/u9KI0QzY6yyHbbbZesyj/HEDj00EOVoMBEOCm1bOI+VsT/dQQcAUfAESiBwA477FCiRDa/huCVlgCVfD8kP7fnGRL4iC8KBTL6GXHDT4YSGspfbo6AI9A4CKAc+Morr2gaRlPu4jN+coL8IHQRHM0aBS9Lm15PCPFuIu0ufXzStKP2ePLJJ7vyvFxkSF6oG0PU/vDDD8OoUaPCscceq+mY6+ke8HNxBBwBRyArCDjZKytXwtvhCDgCjoAjkEkEiExCtaaYnXTSSWHvvfeuqmwzaQoeeOABnVRDKWf69Olh7bXXLtYs/84RcAQcgVYjgAMfpx2pw4zc9d577+nzjsh2CAA8k3772982IUG0+sA1XgG4ocj4wx/+MNx11101fjZNmw+5j4jMZCo57guIL6SVyTex9dRTTwWIKqhlknpsn332yVuu6dFC+Oqrr0Lfvn3DBRdcEJZZZpnk15n5fOaZZ2pqgmJpRSFuo+7DPQG5ptpGWgnUIljAfNCgQdU+ZMn6L7vssrDkkkvq9S9ZuB0LcH9CeJo1a1aYPXt22HTTTQN9wmuvvVZbxf8QsCCeoq5B1DqToJiRvdKU0R1K/IFgBrmLyYONNtpI00WiwvXJJ5+E7t276+9i9OjRqgqC+hepROyal6havyYtFL9dVBlRocJIu4uSys4776wktsmTJ+t27u8VV1wxQECrJaIXiikYqWQ4N64X9vnnn+uaP6inYeBariXrt/3pv++5555KpKt0Ckc7hq8dAUfAEXAEmiNAIAoGIcGtdQiAIYQvUjXSx0ehB6Ue+vb4pXjPpSWnURf9pEqnTm7dGfrejoAjUAqBefPm5RS7IHeh4IWaICSuDTbYIEB8wj8AuauSiu6l2tXe35ONg4Dsm266KQwePFgVywh83GWXXdRHtsYaa2j6XXsntXd7q3V8fDbMnaD+eO+99+r7guCp/fffPxAo5ArS1ULe63UEHAFHYAECTvbyO8ERcAQcAUfAESiCACkaixkT+n//+9/DhRdeqAoIxcq29jsmR3GmMZnI5N60adNUSae19fr+joAj4AgYAv/+978DaoZG7HrkkUfCxx9/rGk7IIsceeSRqjAI4aBjx462W8OveRcYwQMwiGiFOLHwwgvr/+WmbGtvQJPnY+2ZOXOmOusmTJhgmzRS86yzztKUNqgMQcxKGu8uiCEQoi699FJ1BHM/Pfnkk0ocSZaPf1500UVVUYhoWRypOFSzZEStcs60rxjRizbPnTs3XHPNNS0ikxQ650LXivL0T7hmkMtoXxaMtEQQiCCRDhs2LAtNatYG1LhmzJihCoUodpGSFkf9Y489lis7cuRITdnx+uuvqwP/Jz/5iUZ1G1mKgmnK5Cos8g8pQkxJg0lW+oAYClz0U7mvzIHO/dWjR49AahG+4xlUyiCI0cdMKqf8/ve/V9Iqvzt+qxB8sfvvvz9A2qsFg9wFAfXFF1/U5hJxT5DG8OHD9TOTVahu7brrrsHSZDFZw0TVIYccUvIU89V/ySWX6KSX7UzKLO533ptujoAj4Ag4Am2DAERp+t+fffZZ2xywjo+yyCKLqNop7/7zzz9f+5eQmUlLieppOX1MrgfpIOPjpjqGzk/NEahJBCDuPPPMM0ruQj2Y/jJBRDxTSb9IP5nAGNZG/qzJE61gowkARwV56tSpGuTBs/Gjjz6q4BFqoyqe7ZD/jj76aA0GPe6442o6XWdtoO6tdAQcAUcgBCd7+V3gCDgCjoAj4AgUQYDJeqIO80WEMgHIJCvkCCa6mexlsqyahmPsr3/9q05KMZl39913q9pENY/pdTsCjkD9IgA5h0l8U+569NFHNULzpz/9qSp2nXrqqbpef/31PQK7wG0AsWvrrbfWCEaLUmeNGhAO0VojeuU7H06ddw8pyXD4Qj4xI8oX1SGiOCHIJA0FHRyfXbp0UZIF30OQRh2I7dxzpQxyEMSlnj17ahQx78IsGH2D7bffXkkchx9+eMkmkfJ5/PjxqtRZsnCKApBw+O0mVdZs11//+teqzgQ5z+5N+6691pD3UJ1ad911wy9+8Yu85MD2apsdF0U+FL2IVEexCSU7fs88L83GjBmjUeuQwMyMDGUTmGnK2L5p11Y3/U9ISSiLGdGLOlBapN20F7IX90AaK0TexVHPfXb55Zcr2YtUJTwjypnYTXP8apUBG5TXkka0fdJQcivXCtUfrwdVOAI03BwBR8ARcATaDgHel50kQIBUzG6tR4D+BQv9D/pD9JVaYlyPfArALanL93EEHIHWI8Bv+tVXX22i2oUfnHEuY34IXYz16fsTuJCVcXjrz7zyNfDeIcDN1I9RDUYNGSVh5g3q2Rh/osJOkBT/42PcYostwp133hnwRTSS2ls9X2c/N0fAEcguAk72yu618ZY5Ao6AI+AIZAABJsqY1EJy2QZnOLZWW201VXwglSKDGZZqE70MDiZKGTAxSQ7BADl9G0xaGV87Ao6AI5APAdKKofRjyl2k3/jmm2+UdIED/9xzz1WnDBGbbukQILUaaXZxlMYNpZ9atHzng3oV6jSkIYOkFbeuXbvqR4g7+QxCChL+I0aMyH1NqhfeYVdddZWSxCCClTIUoUg1xz1aiNxUqo7496QUgLzWrVu3+Oay/kdFid8Q7+S0VinSFc5jFJlQdypmRja0dbGybfUdChEoYPXv319TXy611FJtdejUx0GxgpQTEJ1oJ6ptpCDFIB6ieEiKjrgZEYt1mjLxfdP+b8egfp7nSyyxRJNd6a8yKYP6FhOqacleTSqJfUDdi9/2jTfeqGoeV155pT4HYkXq8l/whchZyv70pz+lSkkKgdrNEXAEHAFHoG0R4B1IkIJb5RCgH9JSohet4Hqg+uLmCDgC7YMAfVyUumyBlENwC79rnpkEFQ8aNEjHEyuvvHL7NLJOjgp+jYohQVA873v37q1Bf/hNdtpppzq5sn4ajoAj4AhkDwEne2XvmniLHAFHwBFwBDKEAFFLqBoYoYs1g19SKaLm1V6GAgMkLyaqUTxBKQQZbTdHwBFwBOII/OMf/wikYkT9hwX1JaI0UaMh0g6iCOtOGUuNFz+HLP8PMQqJfuwPf/iDEqFID0YaOFLnTZw4UVVlIPh88sknSpiA+HTAAQeEiy++OLz22mtKeuL5TSq266+/Xh2vpDgk1ZgRO6j/tttu0+XDDz9URyypx+JED6LsSR+GU43jk/btmGOOCcsvv7yqZ5E+kWu/5557ht13312JU0ZeOfbYY8Nvf/vbUOh8UCh6++23AwSpcg0FSgwlp7hBlsZuv/12dQD+7W9/C+PGjdMoUFLv4BiF2GUGiYX3MWpzpBONq4tZmXLWkHiIMiVCGcIGmJRDxCK9xeDBg5WsBAk7bpMnT9Z0N6SqWWWVVfQ9jSpZ3HC0X3311ar4QxlSXHJOJ5xwQnjvvff02t9www2BNIFnnHGGXjsII1xjIoS33HJLJRRxX5i6GufCtYcUB6kTBVJzMMfvJdrBfcL5cw9C5oE0TvoJDCIZqe8gu1MH9+KDDz6ozxC+ZzKAFIyrrrqqXov3339f7yvSAKLaxfmj3kbbIMJBEITst+yyy7K72n777RcGDBigfalRo0bZ5kys+Z1ARiRFH8RYyGgQE80gP2KkN4Esm08VK00Zq6+ctV1HAgz4TZBShetl15m6LHK6tb8R6uI3gWod5Lwrrrgi3HHHHblnHt+XMsie3I8ESay++ur6e+B+597hvij2m+P8uBbtYTxbue9L2YYbbliqSNW+BxswcnMEHAFHwBHIjwB9G/rC8+fP13RS+Uv51rZCgJRmKPpyTdwcAUeg+ggwXn3uued0fG3kLnwOjCfwBxEggl8b1S58B96vrP41aaQjkB2A8TI+HAKI+vXrp+PIfGPnRsLFz9URcAQcgaogIBHobo6AI+AIOAKOgCNQBgJ9+vSJJNq/jD2qV1QmYiOZkI1ksB7JBHD1DuQ1OwKOQE0gIOSESAgckSgwRaLOhdRUJIo+kThaIiH0RJMmTYokrV5NnEslGylEmkgcmpWsUusSwky05pprKs6i7hXxWUg8kZC5InGW6vbvvvsuktQIkZCp9LMQa/R6iFqQrrlGotAUiXJQJOmAo6WXXlrLCTkr114hOEWiQBUJcS8SZZ1ICDh6XHHgahlRGYqETBUJGTl68cUXtZykF4tEXUz/p9D555+v9Q4dOlT34f3B8Ti+EFl0W77z4QshOuv9pIUK/BEimNbF8ePGeXEMISjFN0dChNPthxxyiG4XZbnI2iYpIyMhszQpzweJPNZ9hFDX7LtyN0g6hei8886LwIn2SUqZ6KKLLopkQjBVVTfffLPuJ2SWJuVlEisSclAkE1qREK+irbbaSrG3QqLIqfsJ2S0SclUkpC39LEQpLcL9YveA7SNEOP0dc+9g/IaFPKX7ieJZxL3HNonKjkQtIZKo2UhIhXrfCbFGy40cOdKqiy677LJo4YUXjv785z9H4vCPhDioZYQImCsDNuDCvYxxv1hbJS1erhzHFhWs6Msvv4y4LkLU0/247kKgy933tClpnLMQxyJRTk1+VfDztttuGwmpTa+VTF5EQngpWLalX9i1FYd0rgqJdFfMbAPXGHymT59umyLuW7YZ1mnK5HYu8Y+QR7Xu0047LVdSiEa67dprr81t4x+e/eAqBNMm24t9EPKj1iWkrmbFhGCq5865Cam12ffFNgihVOuln8o9J+Qu/Uxd/M/vj9+IEDgjIXdGQhSMhJQciWpZtNtuu0USDV6s+ob+jmeIEE4bGgM/eUfAEXAEiiHAe5D34dixY4sV8+/aCAEh90dCptY+Yxsd0g/jCDQMAoyn6EPjK5CAvkiUs3P9bkmvFzHukgCiaOrUqTpObBhg/EQzgQC+Hwmmj0QVPpJgtky0yRvhCDgCjkAdIfAg6UbcHAFHwBFwBBwBR6AMBETFJRLVhDL2qH5Rm/QdMmRI9Q/mR3AEHIHMICCqPOrQg2gjyi46iQ4RaNNNN40GDhwYQRAQdaHMtLe9GjJ69OhIFK6qcngIFxAZkibS9Xo9IO9gEHEgOEAqgpyFzZkzR7eJyk2OmCEKWrrt4IMP1jIQWiBFQOQzE5UoLXP55ZfrJlF51DaIwo8ViSSNm5YRNZ1I1IdyRBQjVFEQ0g9tMrIX25LnQ/u5pyCSFbNCZC8jvIj6VJPdIXVwbEhAEI74H1KemSho2r+5NYQiyokSWm5ba//h/ERBS8+bumkvhJdSpEhwpLwo5jVpgqggRaLAlXOiizJUJMpGuTJG9hLlrdw2UWDSyS/bINHVWrd9Zg2hyshefBYFLS0jKS35qAYpkDbFHagQsNhmBCTuOUmjGBnJzvYVhT8tJ2pjugkyHMQt7lczO6YoMtimiGPGCUKi2KX1SKqGXBnaLqk7c5/tH1H2atZe+67QGtIkRDKIjJwXk4YQ8OkHcS2MAFlo/zTbjbTFdRHluUhSmeixOB73LYRGrimfee5CeGObpHXUbbTx3nvvTVUmTXsow3OA40Hmk9ShSlTkfHn2QH6DWIjxW2Ibkznl2JQpU7R+fsf5jEAHjg/hshzj9wXJi32LLTxjWOJlmKDnt8Tv3q0pAkzogY/9Xpt+658cAUfAEXAEDAFIyvSzrT9u233dtgjQP2Msdtxxx7Xtgf1ojkCdIvDWW29FkmY9ElXoiKApUZrWfvRiiy2mn9lOUBK+BTdHIAsI4IfA14SPIe4ryELbvA2OgCPgCNQ4Ag+65rt4E90cAUfAEXAEHIFyEEDemhRLpOSSSeFydq1aWZmIDBKtpal2kMcXdZIgaj5VO55XnD0EZOIvzJ49O5AKTRQxNP1W9lq5oEXcmzLxr6nDSOtULI1TVs+hPdpFSjUhFGgqNVKLkZaRVHCkkBNyVxBykKZkRIZfJoHbo4mZPSbp48CK1GpCPCjZTrBOWrFnqpArksWbpXYjLTDlSLFm7w5SmZEugTR6pGXDOklKTSHjaGo2PpNqj3RdonLDRzUhP2gaNCHkELwTSJW23HLLBVHJsSJBnL5BnL36XHj55Zdz29P8Ez8fccoFmSDT+tPsmywjpBx9X9LOuFEnBh60W0hFmqKRZxhpC0lhmDTudSGEBFFKS35V8DPHTR6b87NzBH9RD9KFVIWiaKUpB0khSapBUVJqkiLPDmRtAPe48fsTBYkgUauaypCUBaQwSJpEW+c2rbPOOoG0kjy7uU/KMTsP9iHdJniSlsNMSIf6r5UjtSIpP2ln3Eh1xDOFFIyiFqbPaNKLSnS4bifdK/thpCcl9SLPbnHUaspIq8uePULIsk2aCnvGjBnNUh5aGlKwjLc5t2Oef0hbSBpPUkByX/MsZCG9JWlIuT/AlvNj4dlI2sBybJttttF03ffcc48e66ijjtJrKWp8QUh+msqQ1J9C2tTtpNQUQltgP1Llitqf/v7TlEnbLtKI0/8kFQYpR0kTy31DGlRSyHKetIO0mUOGDNG0i2nrJsWrKP9pceoTonCzVI1g8Morr2ja07T1Uo7fFylcaXcxs+cBZXjWch/16tVLU9/mex4Xq6sRvuM+I2WrKM41wun6OToCjoAjUDYCvLPoB9OPu+6667SfIESjsuvxHSqDAP1qxi1pUiRX5oheiyNQPwjg45VgD03HKIEXumYb/WzGAxL4EUSNOTDuE+VX96/Vz6WvqzPB90UqX+Yv8F1KcJT6L8r1f9QVKH4yjoAj4AhUCAEne1UISK/GEXAEHAFHoHEQYLINg3TRvXt3/T8Lf0TZRQkEkg5MJyAlrY9Oemahbd6G6iDARJ+km9JFlEV04q86R6perTjhRTEoSDqzsMceezQjyFTvyNmvGWLS008/rUQGSBiiBKROckhBv/vd7wJEAggYTPZCcHArjADPbQiRPLclmrBwwf9+A/FIlLRy5SStXsChWsiMSFPo+2LbO3bs2OxrHLdGfhCVJiXecC/kM0mxpiQhI85YGerYZJNNgih8hTfeeCNHJrPvi63j5yOR+Fo0DUkuX50QuSTyWNsY/x5iEwaJheNJSsEAuUjUypToBQEFslXSIIFAsklrkJFExapJ8YsvvjgcffTRTbbxQRSZlGSHM12UvZRIs9dee+UlexXChWcZxCaOu8suuwRJO6iEPYlgbXY828C1wpKkNPu+2NquFWRGcBF1qSbF7XtbQ97DkuRF2497xUxUypTsBeGLZ40omyqp6LHHHlNsIHtBrIqTDG3f+LoQoRfyHpb2evIb5HcJeYj287tmgYiESeR6kFSkutBG7iV+R5Dh+d2LKpYu/L/iiivqPvn+ULeomAVR49PfnpUxEpx9FrW0IGp0AQIazwzuiSuuuEIJuOWUsbLF1vz+RN1L709RE8tdP8iE77//vhIg+U0NGzZMJ7eL1ZX8DvwMw+R39hky2bRp0+xjWWuuEc9ee6YV2pn7BGIrzwFIl1wHiIWSbkYJboX2a8Ttd9xxRxCFFL3/G/H8/ZwdAUfAEUgiwDsb4ryocwbI2gQPQAIXhVMlGIkSaeCdyWSzW9siADmf60CfSVRT2/bgfjRHoMYQIKjr2WefzZG7GJcylsYIYIHQxbONNX4gC7SpsdP05jYoAvgtIf+K2nk48MAD9R4WhTodozcoJH7ajoAj4AhUBAEne1UERq/EEXAEHAFHoJEQYHJF0spkjuzFNUAF4e677w677rqrqlLceuutZauENNK1rNVzheQFWYGJ9/nz54cddthB1dyYwGbCGdUsm9jP4jmi0oFDHqcVzisUSojsOv7449UZz6RzS4klWTzftG3CsQdRwVS7+J9rjXIQKk04yCFcQHTI8vVNe75tWQ6VIXBkAigN2QuVG35bZvymilk1rweEGH4vkL5QDIob5BaUnCALQTiRNI5NiEl8hzGxAnkwrcXPB/U9PsfxSFsP5Tp37qzkJ37v8fajkIkRfQzBAxUm1GpQT7r++uvV+cf7FjKoGecAFkQwpzV+OxCv4sa2uKE0ADEIVUzatdpqqwVJcRkg9xRyoJsSVRIXSIWSWi2glCXpM5Qgs+eeeyoG8WNW6n+7VnZ9UVCStJ0FibMQn7BHHnlEFaGsHfF7xbYxgUCk+C233KLENZS9IN5ANoKcx7m2RiXDCJQo26Uxjo2DOHn9bF/efyyQhTDay2TJE088ocTZSZMm6WQjpDqUuCB/GWGMNc8JI96xf/J3n/xMGd5VphwGeTmfFSoDQU9SUObbpck2iL2cE+Qnzi9pkKTy/SbKrT9Zb/Izfd9CBtY8j9588019Vs2aNUuVwFBt4zdr92mh/Tk3ng/8Do14SFnU0saNG+dkrxhwPC95xhDc4eYIOAKOQCMjQL/RyF2ohfB8pJ8PyZ9+mKmbSrppJXGjjEk5I5s3MnZtde70scGd/iR9fDdHwBH4HwKM3wiIwCdmC6qE+MsYq/C7gRDDmucZAWhujkA9IMA7mnc4wX0E3J111ln6jig1ZqyHc/dzcAQcAUegGgg42asaqHqdjoAj4Ag4AnWPAJOCDEyyaEyMzxBVkR133FEnRCF/MWHuVh8IoPBEyiZUZ5hkP+aYY9QRVEtnx6Quqd0gErD88Y9/VGWS0aNHa+opVGQgEiTTjNXSOaZp66effqpqXVxTFkgJKJ8wmQ+pC8cHpAbINm6tQwCnEWkQSYlIZH8pY1IirVE3k0sQX+JEkbT7l1JzIgUgCn5MVEFWMQcYk1X8ZviOMih/cR/tv//+uUOzDbIS33N/YUy6mNFmLJ4mLXk+yOpD7kEhoSV2xBFHqDw/k3FxYgsObUg+/M4hiVxwwQUBNS+UfLbaait9zpFyME724rmHQcZKa5QtVB6VKDCETIIqEm2B8AVhmudUMYN0iYEL6mRmkFUh4qLwBVGFcyE9ZDmpn+0+giQDwYh7hHsseZ04JsQuDKUq0oNyHIhcHBdLXmPU3jDulbiZchzO1rih7sU7h1SXKIZCmkSxDAIYx4Rs3FJDkQordH2S9ZKGCUzTpnogHSrnEz8nrjO/BUhxrOkjQe7k2QspC3IifTyuKURE1jyTS90Pybam+YwaX5p0RmkIqvmOV8n6uc+41/nNQCq1xQhekCTtWUafE9y41yByQ4KLP5fibeVeR90QBz/pOZMqcCjw7bzzznqt6C+4BX1Ggje/TTdHwBFwBBoJAfo406dPV4IX/Ur6ERAievbsqeNJ1FTzkSF4vxMEB1mCPj7qiK6KXP07h6Al3uEENDFeSb7jq98CP4IjkB0EGMcRBGGkLtb4lCF8Md4jCIVxFenYeVaVUk7Ozpl5SxyBliGw7LLLamAcvpOBAwfq+338+PGqyt2yGn0vR8ARcAQaGAFxyLk5Ao6AI+AIOAKOQJkICMkmksm3Mvdq2+IyAReJSkUkToJIpPPb9uB+tKogcPbZZ0fiJI0kBUUkE31VOUZ7Vzp37txIHPaROOCjCy+8sL2bU9Hjz5s3L7rpppsiIYNEQiaIhFSjixAKIiHERKJmFIk6U0WP6ZX9DwFxpkYy7IuE3PG/jRX4T4gvWu/YsWOjq666KhJFG61V0tvpdlG60c9CVNLPQhLKHVXSvuk2SSmT2yZKUfo7F6Ue3SbqR5GQW7ScyN1HY8aM0ftFCFi5+0WIO3ovSdRvJBMruh+/Je6xM844Qz/LRIvWI5Ni2k5RropE5Unr5Rwoj+U7HyEeRpKGMBLikJbJ96dbt25al6SUbfa1EJ8iIZ3lnltgJBNvkaj6adnZs2dHMjkXyaSdfjasRNK/SV0ysafHENJbk+0t+SCqXZEQTRQjIXdFQpAqqxpRWouEABTxXI5bnz59IiHm5TYJmTXiNy5kLd0m6kV6DuLsz5Xhe+5Nu3e4ZnwWRbBI0glGMjGpx+J63n777VqXpPTTMjIxEMlkQSRp77Qt7Me9wXWQSPFIVJK0nBCeonvvvVePyX1EOZn4zLVBSDmRKDdFMpGa28Y/3DdCGopEvSp3/WWiVfe3eyu+A+8n6hYVrtxmIXPptuR7S8h1kd3nucIF/qEfY+dfoEiLNwuRKeL5IGSyaMCAAZFEGmvfifNgEdKYPrMlpWd02mmnRUIajUQtrBlWLW5ABnaUVJoR9xT3lyiHRqImFnG+QtiKhOCn2Bseooii/Uve1UI4ikaNGqX30vPPPx8Jma7J2YDtZ599phja/qz57bCW9M0R+wmJLBICWUTflWempBuNJKVo9Nprr0Xc4927d29Sb6N+4P1Av14ImI0KgZ+3I+AINBACQsSO6ONKoEZEH5d3B2NhSWcfieJxJET1SAgUqRGhv0SfmvcXz1O36iHAu1+ClyIJRHBfVPVg9pozjICoWqvvhz4142TG0vR9GVcwBpKgzUgCaSLGhOU8xzJ8yt40R6DFCEggY9SpUycdd+JrcHMEHAFHwBEoC4EHib50cwQcAUfAEXAEHIEyERDVIZ24tsnbMndvs+JM3jHRKypKkah9tdlx/UCVRQDnD2QgnNuiflPZyjNYG+c7YsQIdehLascMtjBdk5iwlvRxkaQSiYzsALmEyQrOS1SLIog8bm2HgESXR6JylSPeVOLIokSlRAiIKFxXSFOQc/iMQxdn7uTJkyMj2DBR1bdvXyX2QMChDIsoj0WStiES5aLcNknbEEEIw/klajm57ZB57r///ibNF5UCJW9xfpImRe+5oUOHNjlXflcQNbgPRf0xEkUr3QfCBhNmWPJ8+D3irMYxLVH5TY7Jh8cee0zbzvOJ84C4NHjw4CblJGJZyQmQyzjulltu2YTMCdmL95QoKEWi5KNkG86BY8cN0hmko0q8eyW1ZQQRC9JWS82IXPF2Smq1SKKzFRN++6JmFs2cOVMPceihh+ZILhKxHXHelDHiC9sghYqCUgQpEDxF/Sy64oorlGDOpJmoUCnpChINpFHKQP546aWXdDtkJYh0bIfYB/mMiU3IXEyYYqIqGIlSl/ZjuMckRaBeN+6/fMZkBCRDM85XFLC0rbaNtUTlap0cG7IjhCjudT6zQNixZx7nzjaekWmM3y51xrFOs19ryoiymp4DbRQFrghSIOdt+NJ+SIo808Fz0KBBkaQhjCAlQtxjojMLxvWGLAcBj988zwXIQqKAoucjylu5a8Q58TuFYMUzieAG7jmIgTwjJDVkWacEuZY6W7rwm4eIyfMlfg+W1Yg6KizqZzpx/uGHH9bRWfmpOAKOgCPwPwQg+4rSqwYfWLAD/UP6XLyLWvtu5V3Gew6yeWv6gP9rsf+XRIBgA0l3HkmKcCd6JcHxz3WJAOM3xuIEhRA0wviAvi9jbsYvjAEZI4iqcASJ1c0RcASaI8CYlWA3fCMnn3yy/1aaQ+RbHAFHwBEohMCDHfhGOh9ujoAj4Ag4Ao6AI1AGAqT/Ia2OKA4EUekoY8+2L0rqHdLniFpDQBKZVExutYUAaYxIMyYqN5perLZa3/LWcr7cu0Kg0bRoLa+p+nvSpRaihKZGIz3aww8/HEizRBoxZPhJy0hKRtKJSVRn9RvkR8iLAKkTSGlIyjDuq0qZEFg0zRtp9Kpl3GNCINQ0jkJ4yqVzjB+PVH+cI6nqSEVH+rSk8R2p/ZZcckldU28ylU2+8xHntcrsC4EnWWXqz6SpEJKCpm+M7yQEHm0L7ed3w/mJky9eRFPXktKUVJykEWytkVqGFJetMXCSySxNq2YpKr/++mv93YvTX9MCilpWiw9ByjxSXQpxMAjpLwhRr0ld4EY6PSH/NcELnEUlUNMPsh/7J/elIiGEByEBaZoQUhUWMtJJglX8PuHcW3NuJ5xwQhCiYBAiuuJU6NhsnzJlSujVq5emdrD0lMXKV/s77lNwF8JakElp/V0KIVLTkQrZM4CXGc970l2SpoJUUzLBrAvYkWaRtC22kM7QljjW/Ea51qSa5Npyj3FdSYvEQmpWUlux/OMf/whCyNLfC2lPSXFFWTOeCdxTtIn0MPwfX/N/a38XdizWPGs4b9IWpzXuV+zcc8/NPad5/vCZFKWkuWlEo08kxEztC5Im1s0RcAQcgXpAgHcXfQFRH9V+Ju9TIXkFCQwIpGVkqXRKe/pXoiypfSAhQId+/frp+7ce8GzPc6BvLWqfYfjw4ZrKWRStNf13e7bJj+0IVBoB+tpCGm2yMO6j/0pqegkCUf8P665du1a0X13pc/H6HIEsIiCBbkECjtRvd8MNN6ivI4vt9DY5Ao6AI5AhBB5ysleGroY3xRFwBBwBR6B2EGCijQk8Bh4SeZL5hjNRyMTq6NGjlTQjyh+Zb7M3cAECkspQr50o6uhkd6PhIipDSviSSMhw2GGHZeb0mcCWlFdK7oLYxQQ0xAkmJyS1iBK7IHjh5GPy3i07CEjal8DCNYO065YOAQgjok6mzyFJR5FupwqVgigiqlBBVKKCpEGtUK2VqUZUJgJEFEk3EER9rTKV1nktku40SNpJJcVK5HvRs4VUBblHVLWU9Fy0cEa+FNURJdtBuIO8yBrilRGxWPO+gKQFeau1xjsG8iZYQiKDXAW5jEVSMAZR1sgtoqDX2sOVvf+xxx4bJG1sgCRXykQBQSfF+F2JymGuOGS3HXbYIUjKR312M5nWSCZpWQOEUlH2CqK01kin7ufqCDgCdYYAhCDGTvfdd58ujKcw3vVG7tp0002bEMyrAQEE6pEjRyoxCSI2E8uidhqqGbhRjfPIQp2QzK+++uqA3wLCu6T5VgKdqHJmoXneBkegxQgwBiXQN07uYmyCderUSX0J+HvwKfAMI5DDzRFwBFqPAIG0BLcwjr7yyiuVoN36Wr0GR8ARcATqFgEne9XtpfUTcwQcAUfAEag6ApKqStVFJC1W1Y9VqQNA9oL0JWkQwkUXXRSYVHPLLgI4lVCCwmEqKaSy29AqtwwiBVHC4CEpN6p8tPzVQ/BE0YjJCZS7UKSZP3++Tqyj2GXKXahGuWM7P4ZZ2QppgElzSbMWJD2iqtpkpW1ZbwfkFEntFiQVo75L2qK9qFMy+YeaVyXV2CrZdojfksIwSPo+JdhUsu56qwuVLpT1brnllpK/PUhTPFuxxx9/XJWtuB9QvZJUirrmf1OCqkWsOB8mRlHc4z0D+YttRgLj3FhQurPzhtyFUhsqXQQegEWW7cknn1SFj1JtpE+66qqrBkn9qOp+yfK8c1F2kzSnQVJSBkl1mixSl5/BAwUanoEQ4JOqh3V50n5SjoAjUDcIECDz1FNP5chdjKF4z/3qV7/SZzrPdVS82oOMDMgo8tAvQQEdIhpjb1SZIRVD3PBxXfNbEfI2fTQUTumfsaBSKimiw4knnqik8+Z7+RZHINsI0BeXNIvqc+KZhe8JVW0MRVwIXfGlVMBKts/WW+cIZB8B3sn4f8aOHatzGBdccIEr5VX4sj344INBUtCGu+66SzPXVLh6rQ7xAXzo+MoY1zKOJyjNzRFwBCqKgJO9KgqnV+YIOAKOgCPQUAiQXg51BjqstWSTJ09WpaTNNtssoBbl0WfZvHo4xokORKUDxZhansxuLcKQc7hfcSwzQdAWE51MvkMEspSMOPyYmCDllRG7WHfu3Lm1p+f7twMCkJa6deumKdBIG0Nkrls6BHDWvPjii6FLly7pdmhlKX73b7zxRuZ/a6Qdwunv79TiF5z01xB64mkK8+1BWidImUzCzpw5U4lhqGRBeCHCPm68EyAK2ULd8cWIYRCkSAPaaKpQcaza438mzlDlIoVrIaOPs/POO+v1KZbqmHcz9wATcCjE7bXXXoWqrPntPGshkZ566qmqNkNKEycd1Pxl9RNwBBoCAVJEm3IXE4k8u1GZhNhlC5+zZBCKmYTEt4PaGOo9jBcYh7o1RYB3Ef1dUoD/+te/Dj179tT3fCXTQDc9on9yBCqLAGnQUYulP2nL66+/Huh7/fznP8+Ruky1i21ujoAj0D4IoPh86KGHaj+C9MAE3rtVBgGI7hDq8L3w/KuG4UfHBzN48GD17aDWlrU+YDXO2+t0BNoYASd7tTHgfjhHwBFwBByBOkKAqBKiQJGtrzVjopRJNZx0f/nLX/IqKNTaOdVbe5GqJl0Z8tU+MR0CkwaoZl177bVh3333rfjlhrhJWj/IXSwvvPCCksvWWGMNJXcZwctJQRWHvt0q5Nm93XbbaXo1VIaI5HdzBByB9kcAQhgKckTzQsZcffXVc41i23777RcgrpdrK6+8cpg7d265u3n5MhGArI4K5m233abLO++8E3iXQojku7hB8sKxjIIppKY0xHZSb+GUvuSSSzS9BylB681h/NJLL2nKRhRFSTNGejE3R8ARcASyigDEKMhdBCjdf//9Su4lvTApuEkBDsFrzTXXzGrzvV2OgCNQxwhA7ILAiQ/UFsYaEDkJ1CHA0khdKHeh4uXmCDgC2UKA8eQ+++yjv2XmYshW4lYZBHr06BEeeOCBqpG9rJW9e/cOkPWc7GWI+NoRqCgCTvaqKJxemSPgCDgCjkBDIUCUKg5M0snUokMAhQwIXwyaSKuEcpJbNhDA8YTyCaoml112WTYalYFWHHjggZoGBAJca43fral2sX711VdVMWy99dbLKXeRntGjOFuLdLb3R2kA4ghR/KecckoYNGhQ5lOiZRtRb50j0HIEIP2MGTMmDBw4UFP2EsW7/PLLN6uQckOHDlWCULMvC2xA9Yt9+J27VR4BVLumTZumz1Kep0QHk3Z511131YXggjhpjxZwTVBgu/HGG7U/Wm6rOM6RRx4Z3n//fY32Pvzww2s+0hvSOSS2SZMm6eQjxP+2UlEsF38v7wg4Ao2LwEcffaSkLlPvItUZqk74E0y5C8WntlBjbtyr4GfuCDgCSQTSELsgd9nigXxJBP2zI5BdBAgaYjxP0H2vXr0C46T2SgGdXZTKb9k222yjZP1qKXtZi/C7Tpw40cleBoivHYHKIuBkr8ri6bU5Ao6AI+AINBICkAQYWKBcAGmqFu2rr75SogP52RkoHXDAAbV4GnXXZiYwSXlExCFqGG4LEEBqv2vXrgGiJUpb5Riy/CiNmHIXEehMMhO9SV0sv/vd7zwFWzmg1klZnBoXXXSRkkCWXXZZlRcn6ozUb26OgCNQfQQgOKMyOmTIEFVxPPHEE9WRyzO6mJGKmpTapPpkKWYoRqHqtdJKKxUr5t+lRODbb7/VtMpTp04NLCgmcL0gSUNUh+QFaT1uTKxRjmcuRC8CJUiZ1Zp0yLSD9IajR48OkA1QjiFF71prraVpsLP+HEepDqIcSl6o4RCIQb+E38Aee+yRSuksjrH/7wg4Ao5ANRCA3MU4ijHYjBkzNJ03RC7UcIzchUJux44dq3F4r9MRcAQcgWYIOLGrGSS+wRFoCAQYM+EDYOx5ww03hE033TRz542/mawUiyyySCCgGDWyX/3qV4GMEvgt9txzz7D77ruHs88+W1PKcgLHHnusZhv47LPP1DeCkvmFF16oc0533nmnjp1HjBgR8FmWY4yXGSvTj4MwR3YDVNJ+9rOfaTVG9mJMevXVV2sA1yqrrBLOPPPMJsHPptpNOQj9jFcJ6DIrdZw42Yug6tNOOy1wrtiPf/zjcM4556iYwrhx48KTTz4ZfvSjHwWU2c8991w7hK8dAUegMAJO9iqMjX/jCDgCjoAj4AiURgCVgj59+uikZOnS2SzBpBtqNnSsWQ8fPtwnl9r5Uh122GE68ff444+3c0uyd/h1111XJxUYrBYyiAMvvvhijtjFoJaUfYsuuqg6ApiMhtz1m9/8RqPQC9Xj2xsLAVQOh0qkIE4ZUjoQLYjjA1WV5ZZbTu+fxkLEzzYtAuPHjw8oD9aT8czEOYnjrdL29ddf6zPZCC4oePH722WXXdSpuPbaa6c+5NNPP63k6E8//bRZikCrxCak/Z1qiJS/xjFM6htSPOBgR4EKohKELhzGLFtuuWVYbLHFClZ+8cUX59IRQg6ArFepaGz6srzrCV4g9SFkee4JnM5ZNpRweN9wz0M4J3jElbyyfMW8bY5AYyDwwQcf6DgKchcLqsqQpnk+QajleY/CeTX6CI2BsJ+lI+AIlIMAgbYE/tEXffbZZ3VJpmI0tS5I8xAE3BwBR6B+EYCEjv8FZenTTz89nHTSSZlRE2WsfNBBBylxCYIX41EySxCMRJuPP/549TsS6MYYFnVqgpeuuuqqcMghhwQIXaiXzZ8/XwlijBNRsn700UfDTjvtFCB+pTWenYy7eT6OGjVKg7V69uypKbbvvfdercbIXhwHZW78QIz5CUBnbI1BzGKszXwRWTFQ14YQRiAX49k0x4mTvVZYYYUwbNiwcP3116uqNT56grTw09NesCGgDFIaiuFujoAjUBIBJ3uVhMgLOAKOgCPgCDgCRRDYe++9dbLrjjvuKFKqNr4igoNBBh16yA6LL754bTS8DlvJ5CmRShBP3JoiMGDAAB30QeYyY/DMhD+DT5S7Zs6cGT7//POw5JJL6uSpKXcRfVRKKcbq9HXjIoCyCs/D22+/XR3KOGDcHAFHoDoI4PSE4IJjM5nmL+0R582bp32XWbNm5SV8MUEN4Quy8L777qtOw1pMv50Wj0qU++677/S9yjuViX7IXV988YVGEvfo0SPY8stf/jL14XAck5bzhBNOUAc218TNEXAEHAFHoP0RePfdd5uQu1BERoERRWXIXSxMxMUVHNq/1d4CR8ARqEcEIOsbocvIXXPmzFFSxDLLLKOKMvh1IC84sase7wA/J0cgHQL46QgChuhFGukJEyZokGa6vatbChVUiPGMfVGfhpyG4a8gSApfP4QmbMyYMUqeMrIX25gP4HyuueaaXFAhalgEzeHrTmv9+/cPY8eODR9//HEueHWTTTZR8hl9P8bjRvbCj45KK4Z6GMdCeQuiLc/at99+O/ziF7/Q7zkHyFiXX3556Nu3b0hzHCN7QXwjCAyiGEF/NveEGlqnTp00+O+UU07R40BuQwHezRFwBEoi8ND3SxbxAo6AI+AIOAKOgCNQEAGcDJdccknB72vpi4MPPjisttpqmjYGxSMkels68VpL5521thK9wyCKe8utOQLgwoCegSWRTRC8UGtBYQT1JSYikJuG4MXEPpP8bo5AOQgQZXbqqafqQnoI1AyQW+d/N0cgHwJEJPLO5JkDIRVFrGJGFCXOPBx8rUlhV+wYlfgOZQ+cp6R8XmihhXKpEjk/IuYhJuOQY4E8xcRwGjM1I869EspOOFEfe+wxdYqS7iBJ0KS9U6ZMUWciUbIDBw7UdwTKrKTKgxjc6AaRi3cppC4W/ue64+jlfTpy5MjQXVRciE5uqZEqgutE2i83R8ARcAQcgfZDgLTGptrF+q233tKAGJ7PKNtC7kJtkBQ6bo6AI+AIVAsBAgGM2MUachfPJwzfDoQulF3wAbEY0UAL+B9HwBFoaATw9UIyos/Su3dvVR9FcX377bdvd1zwT2CoaOGLsEAzyF5pDH8JFh97EyQHieybb75JlTYbn8iVV16pQVpkuTCD1IVqdzLwKq4ujcLXfffdp8FekM5IPbnbbrtZFeobxRcE8azc4xxwwAGqdoZ6WDwYe6WVVgoEkuGLhRB2xhlnaJrO3EH9H0fAESiKQDpvbNEq/EtHwBFwBBwBR6BxESDalWgIiABEmdW6QZTBwUInfuONN1ZJ3SwMlGod13La/+GHH+pgyQaD5ezbCGXBhYEpkUTIRnPPEiHEZDRkRTdHoJIIkJLMiQmVRLQ+68L5BdkLYiApkUknYA6+fGcMwYjoTqI4eecWK5tv/7bcxiQLJB+UnsyI8kT1A2Iyz2NS50IGgyBO32H99dfXBcdr0olodVR6jUN00qRJmsaBVA5mOBBx/uJoZYGgf88994SJEyeGfv36haOPPlodwhC/fv/735ck6lm9tbzmepH6BkIXC2kPX375Zb2OOG2Z4L/wwgv1vbrGGmtU9FT9eVpROL0yR8ARcARSITB79uwmyl2kTu7YsWNA3YH3H+/rTTfdNKf6kKpSL+QIOAKOQBkIoMRrSl3/n70zgbtqat//HaFUJJUir1lKGlFo0KzSSGUoaVBRGZo0SsYihZJ+igYaaNagFJIGhQbzzIvKkMrwIsTfd73/9bzHcZ7xzOdc6/NZz95nn73XXvu7z7OHta513V7gRVsqiU5+xFxdu3bNEHYx4EBJBERABLIjwLWDawqhBZs1a+YEYAzwIixgvJJvA6GNJFIpt2XhlMWA1eDBdQzQy26Qnv8eIRftPoTtJppGqIRANzf7QeSFAI72B/rUfEK899hjjzmBL45hs2fPtoceesi19/t1NBUBEcicgMRembPRNyIgAiIgAiKQLQFeKki8WNCJmAoJMQ1uST169HDx4InJjrOHUmwI4OxF0kjq0Ly9xTO/Uay6lURABEQg3gT8KEhEXzSGIZDCvYsRkaESDVlY8iOMatu2rRuhGTiqMdQ28VqGlT+jOQlbHZwIoesTx46AiA5lQkHXr1/fhS7w38diCldCIjDqldAHCNEQqeFc6hONvi1btnQZNyucwHBmwzWAEa84mtDxTZjC3Dao+n0k0pQGWkJH+E41Otk2b95s33//vSGQIyRDo0aN7JZbbnEiL3WsJdLZU11EQAREIPcEEPTSgYZzgw/Fu2vXLnePQ9DVrVs3J+5C6IXgS0kEREAEIknAP3sSostnnkNx8eJZnQF7tKP26tXLvTMxf/TRR0eyCipLBEQgzQjQfk4bRIMGDdy1BdfSOXPmpPWAYC92Y6AbbSKB7U1ExqCtw6+T1c+FNhLaDmjnKlu27N9WZfCff5bM6X5oB+vSpYtzWKdtwovRaE8iysz27dudYI82mk6dOrmBkbTNKImACGRN4KCsv9a3IiACIiACIiACWREoXry4sxKn8SKVEqMssD8eO3asDR8+3Nq1a6cQZjE6wTSOkWgIS4bEaMxJkyY5YSCjp2KVjjnmmFjtSvsRAREQgSwJ4H7kG88QGOH2SSfq6tWrM92O0ZEIjV5//XXXmJXpignwBc8Ao0aNylFNaKTj/kW43Xgl6ksnNx1HOAXgABkqIR6mAZGwwDt27LDbb7/d3nnnHSd+Qvh+44032iuvvBJq04RcRthFRtxOnTrV+vbt68R2hKjEce2KK66wZcuWGWFquVfTsEqjLUKAe++91y655BIXsjEhD0yVEgEREAERyJQAwmWeNwh3w+AzrvuI0BmstXfvXuvTp4+7J+7bt8+tx7s9jsi+cy7TgvWFCIiACGRDgPce3mVoO+S5mWsLHfc8ezKQYvHixUabKSHUn3/+eXdN+vDDD+2pp55y16iGDRtK6JUNY30tAiKQcwKECKR/hnZ1hKQMWkuk5B2zCH/oE9dREmL9SCbc42kP4VkQ4ZRPtNcwuI32j5wkXNtJQ4cOdVz9Nhs2bHDX9tzuB0EeA80IIc59gvqQEI7169fPSpYs6VzYH330UccEB30lERCB7AnI2St7RlpDBERABERABLIkgIMHnWapmAhxVLFiRSf2wt1j4cKFbiReKh6rjilvBBihSac6nciMwlESAREQgXQjwKhIRjnipEGiwYpQh4SbnTJlil199dVuefAfHKiwqkechDgMN6pETXTS0DlDfbNqiKQBE9eQzFzNYnV8OFZt27bN1q1bl6NdIiDmmYfMcRLmkUZRwhniQMA5wt3MN3bmqNAorfTtt9/a+++/7zIjbAkfym+PBlMatnHs4rdFWATqTUM3z3IsVxIBERABEUhuAoTl4d2LTjamb7zxhnvuOPHEE51DI4JewvGeddZZMQulnNxEVXsREIGcEGBQAcIu79bFlOvP/v37XUgurjk8ezLAgKmePXNCVeuIgAhEmgBi040bNzohEu0rCOInTJgQ0+gZDP4j8X4emHBYZcAZbQ20l3D9ZMAZaenSpYYA9oQTTrAvv/zSLQsUhfH8R6ItAIFVTtKIESPs+uuvdyFycTtDfIvY9pprrrGTTjrJFfH5559nTM844ww370PsMu3evbsbLDZ//nw3KI5BYtwLli9f7p5D2SAn+9m9e7crm2Ni4AHPsCtWrLCePXsaYRtJTz75pPsOt3FCcpJ4plUSARHInkC+vxoD/2sfkf26WkMEREAEREAERCAEgbvuuss5G3322Wchvk2NRbxUtGrVyojFzqi9Fi1apMaBJeBR0DlN4xgdubykJkMiXBlhoPhfGDx4cFSrnIx8ogpEhYuACCQEga5du7rQAX5kZmClaPwivGBmacCAAfbQQw+5RkkfEjKzdeO5nGNDwEZDYajjpG6EUGBUJg2JqZAQ89PoSKMoz0LclxF9IaKiUysaifCYPFPyzBWYCcfIs8GePXvcbnFhPfXUU52wi8Zin0855RR18EfjxKhMERABEYgxAcLu8O4TKO7auXOncxPlfZEOMAZkMS1dunSMa6fdiYAIpCoBxASE0goUdjHAgAEtRx55pBv8wDXI53Llypl3rElVJjouERCB5CPAoGQG3hUrVsyFdeSaFe20ZMkSGzhwoL377rsuVGLr1q1t4sSJVqJECbdrRPl33HGH8c6PIyvf046OiIpBc88995xrOyLUIm1DjzzyiOFyxZR04YUX2rx583LkisggvXvuuccJyhDsMviLfQ0bNsy5sSP68oP5zj33XCdCo36EWmRbluGsRZvEpZdeajyDkhCk4SZet25d9zmr/XCc1113nSsbcRtl4hpP2Eccxkm0adCfgLAMh1qEXgzA495y3333JU3kE3cw+iMC8SGwVmKv+IDXXkVABERABFKIAKNEGH3ByItUDi2HS0mvXr3cAz0d03feeacadKLwO05GMRMvo1gx88KG+0s0UzLyiSYPlS0CIpAYBHCA6t+/f0gRFGENO3To4BrpfLjHwFrTccJzBGIiwvDRwJWoiXBRuJB98MEH/zjWgw46yImhbrrpJjd6NNU6fTZt2uREX3PnzjVGwDLytW3btq7hE/eC7BKNm4zy/eqrr1zmuZEGU0IoBGYcM/2YPMRzuLWQcRgjZKjPhKhMlpDP2bHR9yIgAiIgAubEvLhRIO4iE0qYzj7C8OAGgaiLjHul3Br1ixEBEQiXAM+bDNKgjSUwe6cX2jdxiPWiLqY8j+r5M1zy2l4ERCBWBHjfpi2G5yqETzh5xzvRpsLgOdp9mHItDtVOFKl6sg/ammg/yOt+qCODz7j+Z3YfCGc/CMbYnrYx2kbYB+1LSiIgAjkiILFXjjBpJREQAREQARHIgsC+ffvcKJHFixdb8+bNs1gzNb5ihAejMs455xw3MkajiCN7XiMhZuIlbsaMGc5Onw7ocePGWZMmTdxLLR3NiBLYD/bRnTp1ck4t/ij27t1rdGTj3IKDCKNuRo8e/TfLazodEHbxssyLIqN6sF1mPVxfHn74YV+c+5106dLF2VczIocXOEYE1a9fP2Od3MxEgk9u9qd1RUAERCAnBNasWZMxsjHU+oR6rFmzpvGswIj44ITAh85bRi9iic/6iZqw86fjB4cpGuNINMTReNi0aVObPHmya5xjVCgjVVMt0dC5du1ae+KJJ4yRu4i3eBZi5C2jUnHcIkwBrgjcc5lnGhiGASaFChVyIRiOO+44C87cVwmtQAe/kgiIgAiIQOoR4J3onXfeMYTEhGQk4wJBIjS0d+xi6sPqpB4FHZEIiECsCDDogNDftKfg2MUU967vv//ePcfjXku4ckt/UEAAAEAASURBVJ8RdqXyYNZYcdd+REAE4k+AZy6co3Bbp22cfo1kfs8m9COOW1mlI444wl544YWsVtF3IiACqUNAYq/UOZc6EhEQAREQgXgSoEGWkD4+1no86xKLfROfHcEODUOzZ8/OsoM7FvVJpX2EK2Z6/vnnnU21dx3BMpn58uXL28KFC517DM5shJ8aOnSoIVDAEhpBFgmx1scff2xvvfWWc25hFHnLli2deIzvGYGEVTMd248//rhztMNimW0YJUXZvERTNoLAzZs3s5lLt9xyi+vQCEfIEC4fXxdNRUAERCCSBBA+ZddgiNMVIfaeffZZJ4wK3j8hAxGE9e7dO8PSPnidRPnMtZj7Ax1HiJ9IhElA7MX9gHsA4Q9r1Kjh7g0cV6ImwmR5QRbTwIxgi8+BU+a5FwYnRrnC4tBDD3UiLp4N6aAvWbKkC9vgp3SclSpVyom9gsvQZxEQAREQgdQkwPsY70U+4+T5448/Oocu3pm8uIt7a3bPE6lJSEclAiIQKQK8lyDk4nndZ8SlPPPiCkhbkBd1MWWAIIMQlERABEQglQkwYPmKK65wA9YYuHXhXyERkzFt2bLFuWxlVXeu9RdffHFWq+g7ERCB1CEgsVfqnEsdiQiIgAiIQDwJdOzY0bk2rFixIp7ViOm+EXp17drVCYhuu+02F/dddu7hn4JIiJm8w8yxxx7rXgDpqCZdf/31zoVuypQp7vPLL7/sOusRbmFtjWMXNtJ0yhOelETnA+51hOwiDR8+3O644w577733XCgplnlxlxd70YiI5TIhqrB5xu2FRCfGsGHDnBjALcjDn0jwycNutYkIiIAIZEsAEQ8OXZklxF6HHXaYTZgwwYlyQ61HoyPPFDNnznQNkaHWSZRlCHd9A2K9evUy7hu+fojXBg4caIiQW7Ro4e4ddC7FInEf2rVrl7u3McV9i3uSD6HIFLctzlew4xYuZcWKFXOd7cWLFzcyHe/kwHm/jCnr43TJMc+fP9/mzZvn7puIuhBMt2rVymCEEExJBERABEQgtQnw7kQIRi/sYso9CNdOHDxxTvaZ+2KqhT1O7bMb+aPDaWTVqlVugFaDBg2cQ2pWDq8Iy3HJpiMXoT2iQQZ1LV261A0owKlbKT0I4FZDewvCrsD82WefOQAMNAgUdTFPOPCsfl/pQU5HKQIikK4EuEd269bNOWMxQG3EiBG6Jqbrj0HHLQKpQ2Bt/tQ5Fh2JCIiACIiACMSPAIKYkSNHxq8CcdgzlsCE+7v//vtdZ+5LL71k06dPdw4WcaiOdhlAAJEXqXHjxi6cVJkyZZwLCY3ARYsWdaM7+Z7wW7jM0LH9yy+/uAZjHL0Y1YmYD+cuRF585xMhGgk3RSOhT3RWkLzYjw7vG2+80fr3728PPvigjRkzxjVCEl6SOimJgAiIQCoSILRhKNE3nbhcb3FQRCxbokSJTA+/Q4cOLrQKDZC4QlFmoiZcvB566CHr06ePjR8//h/VrFatmj333HO2cuVKGzRokOtsat++vXteIlRMXhP3JBxSAjOhJck7duxwGZGzdxxjPwiZEV6REeURMtM7bXE+yAi5mLIu98W8JI6ZjAia+yn3XTKhjnlughmhLQkfQShlJREQAREQgeQmgMMlg1EChV28P3EPYsAL70l9+/Z1U+4PhQsXTu4DVu0jSmDcuHH29NNP24svvmj9+vVzQi9+LxUqVMh0Pwh83njjDScgZ573dn6HzzzzTEjn0UwL0hdJRQBXWRz2vaiLeX4H//nPf5xQgWdrQor36NHDCMGIsItBfUoiIAIiIAL/I8C7PoOzaNvmfkuow1mzZtnxxx//v5U0JwIiIAJJRiDfXy+f/425kGQVV3VFQAREQAREIJEIeIckGnZPPfXURKpaTOrC8V9++eVOFITgq1GjRjHZbyruJBLOVR9++KHR2IdYYPLkyQ4TbiN0bt93333uhTYzdjQiMrqYDvqbbrrJvQBTJzrXcUChkxznL8R9PrEuo5ARddFITaIcOjhogKZDHlHgTz/9ZKNGjfKb5WkaCT552rE2EgEREIFsCDAylOsg4XNJCIa4BtJhR8jjrDruAotGGEZI3ffff98I85SVOCxwu3jNr1271mrXrp3l7ml2wO2KcL7cozp16uTmvfOj35hjx4mL+wauBGQv6vLzOHL5VKBAAUPQHJgRJCN6JtPJRY63oxZ1X7RokcvwwlGBkMjNmzd3OZiDPz5NRUAEREAEEocA97J33333b8IuBBfc9+k8ZACYd+xiynuTkghkRYCBVw0bNrRJkya5gQGffvqpG4yV1TZ8h3scz5kIyX3iN4ejnLp6PJHknHL++B14UZeffvLJJ+7cHnnkkS7sIsIun3nHwOlNSQREQAREIOcEEMxedtllrv3h0UcfdYOycr611hQBERCBhCEgZ6+EORWqiAiIgAiIQFITYNQcbkaM6E1HsVeNGjXciOaePXu6DmoEP7hawEQpMQgcfvjhriI0AAcnRFiIs3A1adeunetcR8xFWCpeeH3yAgaEY4weJhxZZgnHkmuvvdbuvvtue+SRR1xIssWLF2e2upaLgAiIQNITqFixohE+kEQH3AknnOBG1RNaNzcj6xECPfnkk67T+NJLL3XhERP5fpqd0AseOD+2bdvWhTJkFC2hLKdNm+Y6qeCEExfuj4QU/v3339nECaIQbDHKFjEUIYuY8tkv476VDIl6E0qZ/O2337qwS0uWLHEhsHv37u04EOoS8RfCbO+UmQzHpjqKgAiIQCoSQKzNQK6tW7fali1bXJheBNi4KCE05v2fEPW4GSOyCcexMhX56ZiyJ8BgKkQ9Pownz3+Iv3KScOsOTr6c4OX6nLgEaIN58803nUOXF3UhPuA6w7MgvwcEXVdffXWGsIvnZiUREAEREIHwCRBKmzZynuXatGlj1113nRsgzXOekgiIgAgkEwGFcUyms6W6ioAIiIAIJCwBXgT8S8IVV1yRsPWMZsUYYYhzCa5ehHTCCnnOnDlpKX6LJue8lk1DIWFDCL05cOBAZ+1PWXRkXHXVVXbzzTcbbiOEILvhhhuc0IvvCQvgRwfjnIIAbM+ePbZu3TrX8c46vmOesgITndpjx461IUOGuLBWhCRTEgEREIFUJUBnDNdLrrW333679erVy7kili1b1l0HCeWX08S1Fieo8847zzU+Ei4x0RNCN0IpekeuUNMff/wx4zAQIeOIgmPjmWeeaYSw5FnKC7kQetHxmWrp6KOPdvdd7r2IqBEDEsIJZ1R+N4SaJNwjGbePQNeOVGORKMeDo+mqVaucixxOpbiiZvXb4/8c8SEuGsuWLXOHgSBkwYIFtnTpUjcqHBc7JREQgeQgwP2L0Lv8H3txF8IL7lkIaMqXL+/CKiPARtiFuDuRRdjJQT29a4nb9saNG927OC7ZhPpGwH7PPffY3r173Ts7oR1xeeU3N3r06IwQoD///LO798ycOdO5pmZ1v0pvyolz9DjX4mzrQy/6qXfrYqAcz8C8S/A8zJTPCvuaOOdQNREBEUhNArRJMECZd8Du3bu7KBYMvCtXrlxqHrCOSgREICUJSOyVkqdVByUCIiACIhAPAjTC4eyV7qlz5852wQUXuLCOVapUMTqo6dBUih0BH+Lq448/ztgpIawQX+G4VqdOHRfKkQ7k+fPnu1HphB1BxEVCpFevXj0jPCcj2UkLFy50wj2EYoMGDbKuXbs6VxY6re+44w63DsIEzjkvySQ6rAnVxYszvwslERABEUhlArh6EP6WcI5cG0l0Bt97773uPtijRw/XWZxTBnTyIADCEYuOZbaPZ+Ie4QVcuHD5eT/98ssvXacldcT5EYEwjlY4EHCPYd47czEtVKiQc4mcMmWKC/FLxyf3Fu4xCL7SIXFvRiRPxu0McQFioeXLl7tzj0Mcz1TNmjVz4i8EB0qRJTBu3DgntqNTHWdahF59+/bNMuwq4nacNzh/zHOeEIW88847TrzYqlWryFZSpYmACESMAI7GCC14x/HCLpx1EN8i4OR+y/sM7zBMuRdn5WYcsYqpoLQigJMnzzq8izMoC0ds/zu7/PLLjfd4BIi4yyH8xwFqxowZxnt+//79bdasWW7AlR+UlVbwEvxgOUdezMWU/PbbbxsiPYR5RALgOkP7CNcX5k888US5uib4eVX1REAEUpsAUS7o1+EejNP2Aw88YN26dUvtg9bRiYAIpAyBfH+9FPyZMkejAxEBERABERCBOBKYOnWqc/H47rvvNNL3r/NAg/ngwYONTrTLLrvMib6OOuqoOJ6h5Ng1Did0LDCKNy/hQAgLhSDr3XffdY2JrVu3tokTJ1qJEiVceDEakvmt0jlJaIBrrrnG7r//fte5wTLCSD3zzDMu5BiuNHTGI16oUKGC6wyl857zyosv57hkyZLOeQRXEka702hZq1atDNgbNmxw4q9du3YZ7m/hpnD5hLt/bS8CIiACeSHAdZFR/evXr891Z85tt93mHJ+effZZq1u3bl52n+02ODTu2LHDCbi8kMtPvZgr0JWLe4oXbzFF0BUo5DrmmGNydZzcTx577DEX+hfRGA4XiL7SOVQN4jrcNhF+MSX8IzwaN27sMs5SkbivZvvjSPEV6GTHQW3SpEnuf5SQWizLLu3bt8+JvAKd1zhXCPNwChsxYkR2Reh7ERCBKBPg/9QLurxrF+9IvPNw/eSdy+eqVasaLsRySYrySVHxGQQQAOFsipOId39FEESbSc2aNV0Yb1ZGMM9vGeGXT9WrV3cDDXGl8+EbCSuKW5i6ejyl6E45V4i8EX+TvcCL51gS7SRezOWnnG+FB4vueVHpIiACIhAOAdpFhg8f7hw1EYBxf9Y7dzhEta0IiEAMCKyV2CsGlLULERABERCB9CBAwzE2v7h70SCn9F8CK1eudAIghEWPPvqoXXTRRUKTBYFYiJnosCeMAJ2ZhAwITt9///3fwkYFf2Z9OuYJ13XSSScZI+Q5v9hfB6cxY8a4hk9GIkcixYJPJOqpMkRABEQgkADXrmrVqjmxbW7dLum0QzS9evVq94yREyFK4L6ZJyQvoi0EXD77z0wReiFGI+FWhLDXC7j8NFDchftJNBKdlgiS7777bnePYWQtYYbpHEvnhDBh06ZNTvTFc9Urr7zihEZ09nrxFyOQcZhSyjmBX375xYnaEcLjrBZuQpDJ+ZDYK1yS2l4Eck+A9xLEFoHiLkKkkRAgI+pC0OWnvMPw/qIkAvEiEErsRV0++ugjd2/i3frxxx93jrHcr8g+1a5d24WaktjLE4nelOdjhHY4ACLqYkqmPYXnM8RbtAPi0EX2wi6uO0oiIAIiIALJSYC2l44dO7qB0bNnzzbeu5VEQAREIEEJrM2foBVTtURABERABEQg6QiULVvWjcJkNKXEXv87fXR60RiGS1STJk1cGCoEQIULF/7fSpqLKQHYV65cOdN9BrpUsFLwZ5YhBjj55JOZdY3Rbub///GjiWmQJozn3LlzA7/WvAiIgAikHQGuuYRhRLhEiLdQ19XMoNAZPW3aNOeaSNgfnjOCR5fi+uRFXMFTxFy7d+/OKJ5tEXCRK1Wq5BwdA925SpcuHbcOcMJe4nCBSySNqqNHj3adZhw3Tl+EMkrHhIiLYyePHDnShV2mARrHL0Yb33LLLVasWDHn/EYoZTJhgpQyJ0DYUP6X6Kh97rnnnJtc8eLF7Z577nEb4UxKCGsGcfDc1LNnT+N3SMLNY9myZTZz5kybN2+enIAcFf0RgdgQQLxMeDsfHs1P9+7d6ypw4l/h0BB04RDphV3c15REIFkI4AiFaJh7Ew7bOM4xaEAp+gR4Zg4UdNGOhXvX/v373b2eAReIuRiMgPM5GTd2OQJG/9xoDyIgAiIQSwK8T2/fvt2F9cZt84477nBRNDRQIJZnQfsSARHIKQGJvXJKSuuJgAiIgAiIQDYEeOCnE47Ooeuvvz6btdPrazog6bQlpOB1111nq1atyui4Ti8S2R+tD8PgHVay3yKx1qAhlJGtuIEVLVrUNYbiNhKp5Ll4TpEqV+WIgAiIQLQJ0ED41FNPObEOQpOcJgS0dGIj6OnUqZOde+65duGFF9rnn3+eIfCi85vEswhOAl7MRag/78zllwULxXJaj1iuh+gLBzRG0xImeNSoUUZ4IpwsEMwhHk/nhlaeqwgrQSbRGcmzFR3DAwYMMBw8Od+cfxqqCf9ZqlSpWJ7ChN8Xwq3jjz/e5s+f75xOcfc67LDDXL0Jt8pvjdCid955p/Xt29c9w+LCQnit/v3726xZs4wwH17gnvAHrAqKQJIRQIj58ccfZ4RH86IulvEdoeYRWuCkQyh576rD+4eSCCQrAd51ubcjOnrppZeckBt3dKXIEvj666+daJTnJzICL0SktGGQcLhF1EWYZwR3zNPGoRCMkT0PKk0EREAEEpkA4uvly5cbbTdDhgxx79o4bsq5MZHPmuomAulJQGKv9DzvOmoREAEREIEoEUDsNXny5CiVnvzF0nBJ59k111zjOqppOKMTzXeuJf8Rhn8EvhN+37594RcWhxJ8+C8ap3EVwXEkkslz8ZwiWbbKEgEREIFoEkCgg+ALQXi3bt1cpxH7o2OP8FPekevTTz/92zwdfoTOJeEc8N1337mwjAh5ENN6EZcXdaXSPRVBV8uWLV1+8cUXneirWbNmjt2NN96YEVrBwUnjP95dgucqQjoR8hHnL8RfNEizDGcQRF8IBck0XqdzOv30051YCwbHHXfc31x5CZWJmITOXZ5rEBfiVEr4zCuvvNKmT59uhG/H9UtJBEQgPAIIJrnPIbhAbOGnuOngooezIW7CiLk6dOiQIepiWTqLfsOjrq0TgYAXC/spdVqwYIFz7bzhhhuc0ItlCPoD12GZUs4IfPPNN+66glib64vP3vH26KOPdqJRQrwyyID7Ps9UamvIGV+tJQIiIAKpToBnTQb61KlTx7k68jw6Y8YMI4qJkgiIgAgkCgGJvRLlTKgeIiACIiACKUEA14nhw4fbjh07XMdRShxUhA8CZ4klS5Y4twQ6ahklw2hVhHJKZscee6wTv73//vtWo0aNpEPCi/DatWtdozQj7iOdPvjgA9f4imhCSQREQASSgQBCG1y4EHHhWEXHEkItxCYs45kBhyASQi0fUvHEv0JR0aiIiIt5pohSCI1L+BjE0127dk0GBBGpIyzIuC/cf//9TjQ3dOhQw5EJ11A5V/0XM78xQk2QCQOFy9e6detszZo19sILL9gjjzziBIbly5d3oi9+R6zLb0vpvwSGDRvmwpvS+YtwbtKkSe4L/o99SiVRpT8mTUUgmgQQqyBsDhRdIOziM9cpEm46CC0Qpvbu3dvNc62KxjtFNI9VZYtATgjwvk/Crc4nH+Z7zpw5Vq9ePXv55Zdty5Yt7mtCCzOYCkGSd6BCKInwkbRz5043ReBUokQJN58ufwhn7oVcgVNYkHDl5Fpy5plnWps2bdyUeT07pssvRMcpAiIgAuEROOecc9z9mLYHBgIhAGPwOu/eSiIgAiIQbwISe8X7DGj/IiACIiACKUWA0Eq4bhDKsW3btil1bJE+mC5durjO7u7du7tORjpq77rrLitSpEikd5VU5fH7qVSpkmvYZXRpsqZodcps3LjRqlSpkqxYVG8REIEUJIDrFp1tOHMh3grMLEPMhUsQ6fDDD3cdcCynk4nGwkAxF51O2TmVXHbZZa5Di23p4KNTPJ0SnZyIxO+++26bOHGiy6NHj3YCOMQBkQwdnApcCxcubBdddJHLHM8PP/zgxF8IvxCAIf5CbHjSSSdZrVq1MnLZsmVT4fDzdAy4eeEkSqN+5cqVXYP+0qVL81SWNhKBdCPA9eSjjz4ynLkCM254XtRF+BtEXQxswemS+yFZbjrp9mtJ3+OdMGGCjR071gHAEZv/g4EDB7qwgTiYPvPMM07I3qtXL3vggQdcKEEE3A8//LALW0pYUxJuk4T5ZjnPliTCmlJ2tWrV3OdU+oMjFwLRQNEo4i7CMpII4+pFXa1atXLXFT4zoE5JBERABERABMIhgCB75syZ1qBBA+vTp4/hPD579uwM0XU4ZWtbERABEQiHQL6/Rlb9GU4B2lYEREAEREAERODvBBCi0PHqG+/+/q0+hSKABXLfvn1dJzgNlTRwpnMaMWKETZ061TXYZtfpn06c6DyiobZfv3528803p9Oh61hFQATiSMCLuQJFXIHzOCn412qENV685d24mPrsnRYIZ7xs2TIXCs67OOTmENkf7l6Em0MES4i+dE2//PKLPfHEE/bggw861y+E93SOEjq6QIEC6Yolx8dNeCicQ+hsJjP/008/OVEirqs+I3xCrJhKic5iBCYMPAgMOz1v3jxDVEnoxh49etjzzz/vBiggMBw0aJBDgCMavHDuy5//v+Mon332WRfSgw55nuWURCCVCRBS+L333jPciZh6YRcuvPxf8A7D/bBcuXL/yHLoTeVfho4tEgRw7gp8Pgz+HIl9JHIZPFtzj+a64sVdTH34RYShXtTlp9zP5VKayGdVdRMBERCB1CHAs2/79u3tk08+ce+RvDsqiYAIiECcCKyV2CtO5LVbERABERCB1CVAB+Nrr73mOstS9ygjf2RY7N9www1uVAwvSYxgLVmyZOR3lAQlMvKdjhFG9OLGofRfAvPnz3ed94S6oPNISQREQAQiQQAxF+HZaKgLFHH5+V27dmU4cyHm8sKtUFNCNOYkEW4G56QOHTq4kIQ52SZ4HUROhPj56quvXKi54sWLB6+Sdp8R3yDQWbBggeskJcxlz549nWtV2sHI4wEj0ti6datz/0JISMadDkFTxYoVnfgLNx7EX4QiTWZROm4guAshvsThzCeO7dVXX7W9e/c6lxDCj7do0cI50A4ePNitJrGXp6VpKhPgeoBLV6Coy4u7vJMOTniElgsWdXGPSzWBaCqfax2bCMSawIEDB9yztxeK0gbi5xGTkni25dqCoIvs5yXqivXZ0v5EQAREQASCCezfv98GDBhg48ePN6KXMNWzbzAlfRYBEYgBAYm9YgBZuxABERABEUgzAlj68pBPA5UcJXJ/8pcvX+7CWuE0cd9991mnTp1yX0gKbNGwYUPjxXHt2rUpcDSROQRCc5UpU8YWLVoUmQJVigiIQFoQoLMaMZcXbzENFHbhHuDDLEZKzJUTsIQixDUIgTjhe/OSEEpXr17dSpcu7dyHDjvssLwUk3LbfPnllzZ58mQ3yhaxXv369V2IJEL6IExQyh0BwpTi+EWYcsRf27ZtM0SSOGsQJgo3NQRS5OOPPz53hcdx7YULF1qbNm3c72P16tUZNcHNjONlAMeFF17oXLpwFOH3c/XVV1vLli1deMft27c7IQzhVEnTpk2zzp07u9BbiA6VRCAZCPC/zD0RURf5ww8/dBlRF8sRZCDqRFyBwBMRV+AU4TNh6JVEQAREIBQB3EK5niDkQtDlRV0so72DxDt+sGAUcZd3xA1VrpaJgAiIgAiIQCIQePrpp907IAPW58yZk+e2nUQ4FtVBBEQgKQlI7JWUp02VFgEREAERSGgCuA6dcsopzhHhggsuSOi6JmrlfvzxRxsyZIhz56hZs6ZNmDDBzjrrrEStblTqRScjnY24k7Ru3Toq+0imQgnRddVVVzm3kbyKIpLpeFVXERCBnBOgI/qLL774m4ArUMyFKxHrkAoVKuScAU866SSjgzowsyynzlw5r13maxKKkXsc0/Xr1+fZIYnOs/PPP9+aNGliCM6T2Wkpc1p5+4bwv0uXLrUpU6bYihUrnEtTx44dDccvHJ2U8kYAcQhCp1deeSUj8ztENEnHLCHNfa5atapz/Um03yXPloRc51qBAJDfxcCBA52Ihd9Mt27dbM+ePU7sNWrUKLvkkkuci17v3r2NZ32ez/jfxeWMsjZt2mSEeeRaVLRoUSf4uvPOO/MGWFuJQIQJMIjGC7kCp8wj5vSCZ/5/eY/FqQtBlxd1nXbaae7+GeFqqTgREIEUIoDTbKCYy89zjeF+iUMo1xdEXYQf9+Iu5osUKZJCJHQoIiACIiAC6UaAd8Arr7zSvROOGTPGeGdUEgEREIEYEZDYK0agtRsREAEREIE0I1CqVCnr16+fs/NNs0OP6OESQgdXhS1btrjpyJEjnYtERHeSwIXhHrFq1Sp7/fXXYypASDQkOLQg9mvXrp0TACZa/VQfERCB6BKgExr3rUABl59nSsMaoh5SwYIF/yHmChR2JZpDAIIZnJEmTZrkxCV5Jfncc885sdegQYPstttuy2sxKb0doj+clx577DEn1sERDYFP+/btXZiglD74GBwcQn2e18iEgWRKRy//m3TiEgKSzP3cZ5zBEjXhCEj2oTg4Dj5zjVESgUQjwO+Te6F3sPz3v//trnOIucg8S5MQXeKgg+DCi7oQdvnPRxxxRKIdmuojAiKQQAQQe+P+R2hX7vGB03379rmach1BwOUFXX6e68whhxySQEejqoiACIiACIhA5AgwwPCOO+6w22+/3S6++GLX7lCsWLHI7UAliYAIiEBoAhJ7heaipSIgAiIgAiIQHoFLL73UhbfBylcpPAKMAiXU1eDBg12IkHvuucd1ziaaQ0R4Rxl667179zpnDMKlEN4yHUOk0LHaoEEDIwwXoc7SYdQvnXW4ipBxB+S3H5xysk7wNrH6zHXv+uuvt0ceecQaNWoUq91qP0lMgOs8HdF0UgeKuPxnHAG4FpAIU/ivf/3LvIDLT3HoYv6YY45JOhI33XSTPf74467DLBxnMe6VuBFNnz7dOSEmHYgYVZjf2wsvvGBTp041wvjRcdm4cWPr0KGDtWjRQmKeCJ6HX375xd544w0n/ELYyDyZUOck/pcRfhGqKdDhA2csJREQgf8RQMwVHI4YQRf3STLPhd7BEkGiv096QZefcp8sUKDA/wrWnAiIgAiEIIBLF0IuQi0Girp4TudaQ1sM1xmEXLRVeEEXU0KLK4mACIiACIhAuhJYu3atc/ni+GfNmmW1atVKVxQ6bhEQgdgQWJs/NvvRXkRABERABEQgvQjUrl3bbr31VmdXnw6ipGieXfjRed2mTRsbNmyYde7c2SZPnuxC5qR6OL+jjjrK5s2bZ/yeunfv7sJQpdPvCTefTp06OYcQQpylg9CL/6Wvv/7ahXRbtmyZCw8V6v8rJ+uE2i5wGYKHaPye6ASgA5Kpkgh4Art373a/iVBiLn4viEJIjPg//vjjzYu36tSp8zdhFx1I0fjd+nrGY4oT11NPPWU333yzu87ntQ6EJvzggw/cPfO4446z+vXr57WolN6O30+9evVcJrTZokWLjFDBhF0gzCfPG7h9ITQm5JBS3gkgKjnnnHNcDiwFAacXfjFdvXq1c+786aef3Gr8nyP+IoScdx3yUzlrBZLUfCoQ4Hnsm2++cWIuRFs+I+7yAq/AcMTewZL7JP8nhPBl3udkFD2nwnnUMYhAshH4+eef3XMjoi4v7PLzXpRduHBhdy9GxIUbqhd3cX/W/TjZzrjqKwIiIAIiEAsCtOEz0KlLly5Wt25dGz58uOvPSMcB3LHgrX2IgAiY5furUeFPgRABERABERABEYgsAcLXVK1a1T3cE7JGKXIEfEjHV155xXVoE9ox1Ts1cPVq1aqVXXHFFU4IkA6dzzit0KCMSxSiJzrm0ykRvhNXrLvuuiuksxcscrJOZswI+cZoM/5/opHoyGe0t1L6ECB0SyghF44jLEdUQ6KBCyGSd+QKnvJdOjaCPfnkk3b55ZfbSy+95Bz98vrL4fUe0RLXzXXr1jnXpLyWlW7b4WIxZ84cN/p28+bNLnxy69atDbdW7kEKPRTdXwS/XYSf77zzTkbGUYRwUbh78j1CPYRgCL+8+CtwmshhIaNLT6UnKgEGLnBt8QIuP0XE5ecRcvHc61Px4sVdqEXCLXrxsxdyMS1ZsqRfVVMREAERyJIALlw8i3M/Dc5ch7i38tx9wgknOIcuXLp8RtDFc7mSCIiACIiACIhA3ghMmDDB+vfvb9WrV7eZM2e6Z/y8laStREAERCBTAgrjmCkafSECIiACIiACYRCgYZ+47Hfeeaf16tUrjJK0aSgCNErOmDHDhg4d6kIBDRw40Pr162eHH354qNVTYtnKlSvtkksusWrVqrnO6FQOj0DDc9u2bV1n7+LFi+3CCy9MiXOYm4NAjIWrzKhRo5zbT6htc7JOqO3oTD/33HPtmmuusTvuuCPUKlomAv8g8OOPP7rOIi/eChR2Me8dALwYgw7pYCEXn+m4lmjmH3jdAtxZEEpu27YtLEY+LCEimY0bN6pBMTTuLJfyO8dtjUwIYZw2mzdvboi/GjZs6BzAsixAX0aUAO4jH330kcv8rsl8Zsr/jA9fRxhUhMZcZ/yUef/52GOPlVtbRM9M+haGgBkRIiGIyaHmWYZjl/99cn8sUaJEhpDLi7mYBmaFWUzf35WOXATyQoC2kZ07dzqXLgRduLyScen6+OOPM8SkCEURcAVmhF2EeSVMupIIiIAIiIAIiEDkCeDyddlll7n3gscee8xatGgR+Z2oRBEQgXQmILFXOp99HbsIiIAIiEB0CTRr1sywvcetQyk6BOj8Gzt2rI0ePdqOOOIIu/32213Yv4MOOig6O4xzqYQ6QvBFOLR77rnHWUKn0rH+/vvv9sgjjzgnKzq9FixY4EYWxxl72Lvfu3evzZ0711588UU3ohqhFb9Zrg8+8VtG2EW4SoQwjK7+v//7P7ceYkZSTtbx5WU2pXMcG3EEdWeeeaYTfV177bUuxBZh9Bh19vLLL7t94UrYp08fo3M8N+ndd991I9boaEdQRicD4ek4v3R00sjRrl07Yz3C3e7fv9969OhhF110UW52o3UjTIDzjxAwMzEX1x2f6KwOJeRC4EVWh5EnlbsporkKFSq4ayBhi8NJOK3VrFnTuEfgFibHo7zT5H+C+9H8+fPd9ZFrNE5fF198sROAISRSih+B3377zV23vBiM+xsCMKZkXJO4/5D4f0As78VfTHEtKVWqlHOJxSmWeQZscL9SSh8CiGS5zyHOCpz6eZYHCrsQQPvE7wo3Ln47ZH5jwVMv5jr00EP9ZpqKgAiIQK4I4BKIyBkhV6Coi88+DHKRIkXstNNOc9mLuhB0Ma9nwVzh1soiIAIiIAIiEDECDBShfXXq1Klueu+996rdLGJ0VZAIpD0Bib3S/icgACIgAiIgAlEjgJjjgQcecKMso7YTFewIfP311zZixAgX4rB8+fI2ZswY57yRinh4QRw+fLiNHz/eNeL27dvXiWcChUPJdtzff/+9EweNGzfOddhyTIiAUsXZABETgqe33nrLNc6fd9551rJlS+dOx7n64YcfnACLzsHHH3/cdSYiFmUbRH0DBgzI0To5Oe90EjCSbMiQIXb11Vc7cWS5cuWcwOzCvxzUEPHcf//9xjkhbCjTpUuX5jis3KxZs5xoDWEiznveOWzJkiVu9BoiNoQTPmFnTgf9woUL/SJNo0QAsQMCCPgjKgp25qITG2cAUtGiRTMVcyHyKlSoUJRqqWJp9OMaz/8QnXXhJM4315szzjjDVqxYEZZbWDj1SKVted4gtDLXtGeffdYQfFSqVMm4ZuP4BW+JHRPrjOO2i8OSF38FCsG8GIzz6gVh1J5w2TigePEXU58R8XCvRBCG4xtTBhxIHJYY5x3RFmJXnxHcB85/++23GYIuL+RiyvNOYCKsGeeWc42Qi2mggCtwnt9KOoRYD+SjeREQgegQ4F0N8ZYXdQVOeWckFSxY0IUyDhR1+XmuTUoiIAIiIAIiIAKJSWD27NnWs2dPO/nkk13UDgTZSiIgAiIQJgGJvcIEqM1FQAREQAREIFMCGzZscAIJRl2G22Gb6U70xd8IvPPOO85BiE7Y+vXrO6cvOl5TMdEIjJCGEFMINOrUqWNnn322E2gwojeRHb/oeKVTDTHTK6+84lxn6FRDXIRACDFJqiTcuOgMxmFn9erV7rDOOecc1/HIOSQh7OBcEmqDUdeku+66y7HwYq+crOM2zMGfZcuWOUeakSNH2i233OK2wIHr0UcfdUIgHLlIL7zwgnOv4fr15ptvWk7dKJ555hlr2rTp38RelEdYSkJPbtq0yTmKsaxq1ao2ceJEq1GjBh+VwiDA/xUONl7M5ade1PXFF19khJJCrIUDF/9rgQ5dfh6xl1J8CCA44VqOyOD5558PuxKEhKxdu7YTmCImVYocAUQla9asccIvrnsIVwknzfWe6x25cuXKEgFFDnnUSuI5ChEQnexkxK9+PvhzsDCMSvEMw3XTi79CTVmGMD+zzHU5kZ/dogb/r4K5fyGczGlG8BAo4kLM5T97d5vA+sIVRxvOAaE+vXiLaWbzXIMl4AukqHkREIFIEPDP64i4yDw7BM5710AEXYRX5D3s1FNPzRB3MY9ToK5PkTgbKkMEREAEREAEYk+AtnAiHrz99tsuugIDcZVEQAREIAwCa/OHsbE2FQEREAEREAERyIIAnbU00hE+SWKvLEBF8Cscip5++mkXLo8QWOeff74LDXfbbbe5MHUR3FXci+I3NX36dMMNyzuMLF682BB0IKTyDj1xr2iICtDphiANUREd4YiMCIeVigITrgE4etGJy3lBbIHIi5B5Pj388MMujJQXerGcUI8k35Cfk3XcBrn448vmt0K4WZzFvNCLYmrVquXqTX0ReyHMyknKzNWmd+/eTuxFeEqOb8uWLa6DV0KvnFA19z+N6MCLt4KnhGAknBmJc4CLGuItrotNmjT5m7ALhxKlxCSAO8zkyZOdAHLatGkWbsMf19h58+a5aywh6xCSKkWGAALYRo0auUyJCCwR9SJqxaGNELwIRrjGXXDBBe6ZBLGvnPEiwz+SpXA/9MIfQhxnlbhnIi7as2ePExgxDZxHdERm2c6dO92U+e+++85wZ83q+QyxYLAYDJdTruk+87vz834avIxQowjQOC6euXzO7jN1O3DgQK4yAlXuPTzXkAnNHGoaahnCLIRbCOMzS9SZ/5lALjxDeuEWYgjmeYb0OfAz86xPOUoiIAIiEAsCXAd5TvfhhenUDZznexLXNcRbXMdwgvaiLqaEGNZ1KxZnS/sQAREQAREQgdgSwNVr/fr1boBsly5dbNWqVTZp0iT3zhLbmmhvIiACqUJAYq9UOZM6DhEQAREQgYQjQMcLHXxr1641Ht6VYkcAlytEdrww4VyEsKR58+aGk1GVKlViV5EY7ImO5E6dOrkcg91pF3kgQHgfwlIiALjppptcSDXcdkg4hOAmghNMYPKN+0xzsk7gtjmd9/ugfDpbcb0ITIhOqlev7tyFcCjMqdgrsIzAef4HEZvMmTPHxo4d6wQtPXr0CFwl7ecJJRUs4vKfEZLQWU7i3CDMO/H/u3NxzUPY5Z25EO7585v2UJMQAIIgxJGEOSU8YLjiPARJCMg6d+7swpBdf/31SUgl8avM/2O3bt1cRjTz+uuvO/E5Tq803uJcyf9uxYoV3XMJQjxCQJ511lkSgCX+6c2oIddWBETk3CZ+Fwi+cupgxXpc93GRQxxAZns/H7g8cBnLcY8hs08/H/w5q/ojFsssIx7z3/Gb5p3Hi9KCp4S45BrG8uDvgkVcgYIuP48ATvezrM6UvhMBEYgHAd6fEHHxnM7UC7qYMviKay+J6x9iLjp2L7300gxBF8sID6wkAiIgAiIgAiKQfgQYnEMkB6KSXHXVVa6vghCPtAUpiYAIiEBuCUjslVtiWl8EREAEREAEckGA0EkzZszIxRZaNZIEGjZsaOTly5fbiBEjrFq1ataqVSs3TwerkghEmwAOGe3atbPPPvvMCRAR5+Fk5hMdsqTXXnvNdd7i0hGccrJO8DY5+ew7T+mwprOWjgncoXCE8olR5aRIdEbQMdyzZ08neHjkkUecC9/o0aP9rtJiittLoHgreJ5OfBId6YRoQTxCRnTnhVxMOS/wVEpdAoR2XbBggfXt29c5AoZ7pIiCcYa78cYbDQEqYQOUokeA6yvPGWQvruMai/CLzDV/1qxZzvGR/3dcPFi3bNmyzg0W904yblNKqUOA34UXMSXCUSFGCBSDUT/uLfwmlURABEQgnQnwTM5AC57VffaiLj77cIt01jIAAzHXGWec4UT6XtzFFGdBJREQAREQAREQAREIRaBx48a2fft2J/jCDRwn9n79+mmwSyhYWiYCIpApAYm9MkWjL0RABERABEQgfAKEQcNNig4+Ou6V4kOgadOmRibEI6Iv3DQIlXDzzTfbhRdeGJ9Kaa9pQQCxxooVK+yGG25w4bw4aDoP/GhvrgsIwAjxtG7dOjeqi3UIi0TChSMn67iVc/jHi7xwASHhyMH/xKuvvuqcCDt27JhREssIRcn3kUi43nBNJLxZ165dDcePVEqE6fIdQ0x99qIuQnmSOAe4b3kBV8uWLTPmWYYDGp1HSulLgM7BCRMmOIEyQq0GDRqEDYP/uy+//NI5QSIiikSZYVcqjQrgWo74l0ziPsC1AadHGnhxAuOeQagnf30mLJ0XeCLyJB977LEuH3300c5dinsI60kAmkY/pggdKvcissRdEQKqYkRABJKGAK6JDHLxz+pMvaiL6TfffJNxLLhzcS9G0IVTsZ/nM8/suv9moNKMCIiACIiACIhALgmUKlXKVq5c6Zy+Bg8e7KJCTJ8+3Q3Sy2VRWl0ERCBNCeT7q4Hxv77CaQpAhy0CIiACIiAC0STw008/uY44nHw6dOgQzV2p7BwS4NHnmWeecS9RL774orNIpgO8TZs26uzKIUOtlnMCvLAjLMQZCzerl19+2e6++25XAJ36uLngPDdo0CDnqDVt2jSjA/+6665z4q/zzz/fiaNwgclunZwKNxAWEM4UpztCixFqFqtwQgGeffbZ7jOhlugAoTMDcdbw4cNzfNCLFi2y1q1bG6KxUM6GXAtnzpxpmzdvTjqLcsRawZ1CgZ/37dvnONF5zjk/8f87c8ExcB4HgFAubjmGrBXThsAll1zixEBvvPGGEc4s3MQ9kP/NxYsX25o1a9x1INwytX1kCSDy/fzzz+2DDz4wQuhyLd65c6ft2LEjI3sXwMA9I54lHC/OUfxWEOr6sHmIR8l0SHvnJi/0oQzmA5uGmPeZ7wO/47NPvgzEQoEZt0gy+2K/iIp99uH8mFJH6ko4P58ROvos0asnrakIiIAIiEBuCOC8hbMy91CfEXExz7M7bqf+3sa9k+d0ntd9DvzM/UlJBERABERABERABKJNYNOmTXb55Zfbzz//7Bzec9rOG+16qXwREIGEJrBWYq+EPj+qnAiIgAiIQCoQQEDBqM+pU6emwuGk1DHwEnXPPfcY4hTOUf/+/Z3jCR2QSiIQCQJ02rdo0cIJDHFy6tWrl+vQvummm6xChQrObQ63F0ZvPfDAA0bIRkKsEX4UJ7pLL73UOnfubIi+slsHJ8GcJPaBuAsXGURHy5Ytc3VZsmSJc9vCOaZu3brGZ4RZCL1y6vrx0EMP2dixY40wJwgPCNsYHKpx48aNjsOWLVtyUt2YruOdubyAy3cI+c+EYfSJ8xQo4qJTKDDrOuJJaRoOgV27dln58uXddYD/rUik3377zTlT8D+4fv16Fy4wEuWqjNgR+OGHH5wjJNcknCGZkrmGIQQj00CMcwkuYZxzHCPJ3Jd8psa+s5t5xFvB0+BlboW//ngxGFPK81PCF5P9/phy3/GZOpF9/dg2s8R1lHuJF7KFmg/+LtRnicYyI6zlIiACIpB8BLjf4FSKMJpndabBwi7ujT7hfkmY+sDn9MB5vlcSAREQAREQAREQgUQgwDt99+7dbe7cuS4iye233+4GUiVC3VQHERCBhCQgsVdCnhZVSgREQAREIKUI4Irz2GOPuYbIlDqwFDoYnDPGjBnjXIjoJCTUXI8ePVyjcAodpg4ljgRwhOK35VPwZ5bTEU7IVwREuALSwR7s5JOTdfw+sprSuU7nCB0fgUIuOujfeecdQ0hQsWJFJ0zLqpy8frd7924jjFysE2IIL9wKFHL5ee/MRb1w5sqqYwhHGiURiAUBxOLclxBm1ahRIyK7RAxUr149F6aIchGjKolAPAgg/OL3yH0PJxbuPz5zr/SZRm8/zzTUZ4RloRLXa+7BPuPi4uf9NCfLJBoLRVfLREAERCCyBBBqIeDivYhpYEbUxXLeiUi8xxD+iAEsPLcHZ5ZznVcSAREQAREQAREQgWQiMGXKFLvhhhtc2+zs2bOdaD2Z6q+6ioAIxIyAxF4xQ60diYAIiIAIpC2Bl156yWrXrm0ffvihnXLKKWnLIRkOnBHCDz/8sE2ePNmFdmjWrJlzIGrUqFGG20UyHIfqmH4Evv76a2vSpEm2B457HZbguU3RLj+39clsfeqJmAvxlhdwBc4jICAhpAsMsxgs6uKzxFyZUdbyeBDgPkQYv61bt7pweJGoA6LLmjVrupCihDWWs0UkqKqMeBLALSwzIVigUCy7dTITjeE0FkoUhpAgs+WhviOkpZIIiIAIpBsBHLkIn+jDEiPaYt5PvcAL8a9PPJscf/zxLiPcYp6pzzgSS4jraWkqAiIgAiIgAiKQSgQYjNu+fXvnYEpfRdu2bVPp8HQsIiACkSEgsVdkOKoUERABERABEcicAKNOjzrqKLv//vvtmmuuyXxFfZMwBOjkW7hwoU2cONHWrFnjRHrXXnutC6NVrFixhKmnKiICngBhugj7mF06++yznXNYdusFfx/t8oP3F+ozrmN0CHnxVvCUkf509JMY5X/ssce6kW9eyBU4pYNIYRZDUdayRCWAiJHQr4SAxcY/Uon/GwRfhJNdtWpV1Nz8IlVflSMCsSCQmWjMC8aCXcVCicdYRvjMUOmwww7LcBbLSiTmXcdCTdlO97FQdLVMBEQgHgRwxyX0NM/qO3fu/EdmOd8HXhd5r+b5A8EWU4RcwdNChQrF43C0TxEQAREQAREQARFICAI4Yfft29cNTqdf6YEHHtDg1IQ4M6qECCQMAYm9EuZUqCIiIAIiIAIpTaBx48ZGYya2u0rJReDtt992L1QzZsxw4SJatmxpV111leGykj9//uQ6GNVWBBKYAGG8EJ4g4gqesoxOIgRfJFxR6BBCwBWcTzzxRNdRpFH+CXyyVbU8ERg/frz169fPXn31VWfln6dCQmz03nvvWa1ataxy5cq2dOnSiDmHhdiVFolAWhGgYT4zIZgXjvlpKAGZ/w7BdajEfS6UECyny4oUKeK2L1y4sBxsQwHWMhFIcwIMgMI1F/drMq5cCLZCZa53PiFoZdBFYEbQ5bMXeEmw6olpKgIiIAIiIAIiIAJZE2BQeteuXa106dL25JNPusGAWW+hb0VABNKEgMReaXKidZgiIAIiIAJxJjB69GgbN26caySNc1W0+zwS+PHHH23OnDk2ffp0W79+vZUoUcKuuOIK69ixo1WtWjWPpWozEUgPAn/88YfrGELElVnes2dPBgw6qhFx4cDlxVyB8zRuEIpRSQTSiQD/R4SFpkN106ZNdvDBB0fs8AkPWbduXatXr57NnTs3omVHrJIqSATSlAAuwV74FWqalVAscP3A0GiBKHHDRPCVlUjMC8OC1wleLqF1IFnNi0DiESCkOQKub775xk2D5xF0kRF3ffvtt0boRZ8OP/xw18HIc3hmGYHX0Ucf7TfRVAREQAREQAREQAREIEIEaE+98sor3QBA+pl69uwZoZJVjAiIQBITkNgriU+eqi4CIiACIpBEBHDhOOecc+zNN9+0M888M4lqrqqGIvDJJ5/Y448/7vKHH37ozimir3bt2uUpRF6ofWiZCCQTgd27d9vnn3/+j0xDBMtx5cIdgIRAhY4gxFuhMuIuwlMpiYAI/JMALlyVKlWykSNH2s033/zPFcJYsm7dOsOJtG3btjZ16lQJKsNgqU1FIBEJ4I6J0CNQAJbT+cDtmPdOm8HHiVNPoAAs1HxWy/x3TCMpaA2upz6LQCoQICQigqxQmWdzhFzBYq5gp0D+10qWLOkGMjE95phjXC5VqpSR+eznEYUqiYAIiIAIiIAIiIAIxI8A72G0B915553WqlUrmzJlih111FHxq5D2LAIiEG8CEnvF+wxo/yIgAiIgAulBADcORrjedttt1qdPn/Q46DQ5yo0bNzrRFxbKOBNVrFjRvWwR7lGOX2nyI0jxw6QD6YsvvnCiLaaB8wi5+Pzzzz9nUOBaR4hFshdz+XmmhHBRB24GLs2IQK4J3H333e55Ytu2bVa2bNlcb5/VBitWrLAWLVrYtddeaw888EBWq+o7ERCBNCZA6GWEYoEisODPgd9lNo/bWKBzUCDSggULOrcxxCg+4yzm5wOniFD4HDhlvlChQm4Z83IdC6Sr+UQhwO8fB+m9e/favn37/pF5DucdM5Sgi/+r4MT/Ac/iuFAHirgC5/13LCPkopIIiIAIiIAIiIAIiEByEVizZo1z+cqfP7/NmjXLLrjgguQ6ANVWBEQgUgQk9ooUSZUjAiIgAiIgAtkRYLQFadGiRdmtqu+TkAAjq1988UV3fp9++mknjEHoQqc5uVatWobbgZIIJAoBnLYI0YLrVmD2gi6mLCdknE9FixZ1Iq4yZcr8berFXUzpnFUSARGIHgH+d6tXr+46aHHjIgRbJBNhHC+77DIbNmyYGzEaybJVlgiIgAgEEmBADIIVLwYLnAbPB6/HZ0Qyfjnz3kU0cB9+/tBDD80QfnkRGNPA7AViLCNkXeA0cJ7vAjPPPgov7UmnzxSxov/9+akXPQZ/JtxqKDEXy0M55fHeyHN3sWLFnHgLAVdwDvWdRI3p8/vTkYqACIiACIiACKQ3AZxcO3fubM8884zdeuutNmTIkIi3D6U3YR29CCQFAYm9kuI0qZIiIAIiIAIpQeDBBx+0ESNGuFG5ke6YTQlAKXYQr732mi1evNiJv9544w0n9KpZs6Y1bNjQ6tSpY9WqVTNG3yiJQDQI4ACwa9euDBHXzp07M+a9sIuwLnSykuigZJQ/rlsIuciB834ZHZ1KIiAC8SdAWGjuI7fffrsNHDgw4hV69NFH7ZprrrFRo0ZFpfyIV1gFioAIiMBfBBCoI/rKLONI5r9j3n/286GmCHqCQ9+Fgo04xwvAEH9ll1k/s4zbEt8xDc6I1lgWOGVe75fmXOJ+/fVX9zvgnPF7CDX1y3Cm5Zxzjn0O/BxqnmVeyBVKpMVvAwdb7zzn3egIUY54K6tMCB7/PedYSQREQAREQAREQAREQASyI4ArO+1CuHs98cQTduyxx2a3ib4XARFIHQISe6XOudSRiIAIiIAIJDqBt99+284880x7+eWXnSNHotdX9YscARySVq1a5fLzzz9vX331lXMKOP/88w0BWI0aNezcc891jfuR26tKSjUChHkhhAsiLjKuXEwRcpH9PNNANy46HnnRR7wVmAOXlS5d2nUaphozHY8IpDIBhFiM3tyyZYuVL18+4oc6YcIEF3qahsPrr78+4uWrQBEQARFIFgKIehADefGPnyIW8iIhP/XLmGaWeU7zmXX8PFOESDgG5zYh9kL0hbOTnzJPZoCJnwbOI0riM1Of+UxZfGYanAMdzPy8n1Ln4HmeXxlcAEM/z+fMMutx/Li0BU5Dzft1+A52CL1yk+DkBXpMvXtbdvMIubyIK1DUhTMcy+Vym5uzoHVFQAREQAREQAREQATCJbB161bn0M7g32nTplmzZs3CLVLbi4AIJAcBib2S4zypliIgAiIgAqlCgBBnOGXccsstqXJIOo48EHj33Xdt7dq1Lm/YsME++eQT1zFStmxZ59RStWpVI1euXFkCsDzwTbZNCPeCcAsRoJ8GznthF8vozPIJx4dSpUoJ83WCAABAAElEQVQ5IRfCLQRbTH3mM+IuHAKUREAEUo8AHeKM3GS6cePGqLhFjhkzxo0Qffjhh61Hjx6pB1FHJAIiIAIJSAAhFKIv70Dl55kiaCIHz/OMSOa7wHkviAqcMu8z9xAyn/0808zEWAi2SH4aOB9qGeKvYMFYVp+9AC2UUM0L1gKnfj2csALd0Px88DRwPfalJAIiIAIiIAIiIAIiIAKpQAAH4169etmMGTPsxhtvtNGjR2tgbyqcWB2DCGRNQGKvrPnoWxEQAREQARGILIGuXbvae++9Z+vWrYtswSotqQkQTg/Ht02bNjmHFlxaWEYifN5ZZ51lFSpUsHLlyhmCMPLRRx+d1MecypXH7WH37t32zTff/C1zTn1GuOXn6azzic4vzu0xxxzjhFxMEW0h6gqcMi8Rl6emqQikLwHEw1WqVLFhw4bZ0KFDowKCUJGEoZ46dap16tQpKvtQoSIgAiIgAiIgAiIgAiIgAiIgAiIgAiIgAuERIJTjddddZ6eddprNmTPHTcMrUVuLgAgkMAGJvRL45KhqIiACIiACKUjgqaeesiuvvNIJQY488sgUPEIdUqQI7Nixw7Zv325vvPGGvfnmmy4jFCTUCwlB0Kmnnmonn3xyRj7hhBMM9zgEYoQfUQqPAK4G+/bts7179xo22D4TSpGMoMvP+88IvPw58nvHQaBEiRJOwFWyZEkLzgi6fOY7uQx4cpqKgAjkhMB9991nQ4YMsVdeecUqVqyYk01yvQ5CMsJGzpw504UGyHUB2kAEREAEREAEREAEREAEREAEREAEREAERCDqBD788EPXdkNfwsSJE61jx45R36d2IAIiEBcCEnvFBbt2KgIiIAIikLYEEIsg+pg7d661adMmbTnowPNGgNAon332mXOH42Xt448//lv+6aefMgpGDEYIv0BHKOaLFy/ufoNMyUcddZQVKVLEhZHM2DgFZghFg301+YcffjBCJfr83XffZcwj5gqVEXixXmA4GrDkz5/fCe3g6zMcmfdM+R/3mWXwVRIBERCBaBEg1Fbt2rUNV8HNmzcbIa2ikfr162cPPvigIVxv3bp1NHahMkVABERABERABERABERABERABERABERABMIkQHj3wYMH27hx46xDhw5O9FW4cOEwS9XmIiACCUZAYq8EOyGqjgiIgAiIQBoQqF69ugu5NGnSpDQ4Wh1iLAngLvX55587QRjTnTt32pdffmm7du1ymbCBuFHxsheYcJLCaY6wgEx58UOgRGYel7CCBQu6zHyBAgXs0EMP/VtGXEA5ZEIR+mngfphHPIUwAdeswIw467fffnN1C5z+8ssvFiojbAvOCB28uCswNGJwHTimI444wmWOOVRGBFesWDEnhmPq59lOSQREQAQSjQCjNitVqmT9+/e3kSNHRq16vXr1silTpti8efOsefPmUduPChYBERABERABERABERABERABERABERABEQiPwPLly+3qq6927d+EdaxatWp4BWprERCBRCIgsVcinQ3VRQREQAREID0I3HLLLfb444/bJ598kh4HrKNMOAI4XBFuEHEYDlZk726Fm5UXTOGIxTyiKkITBmYEYz4jzgp2wMrtQefLl8+JxxCNISTzU0IgIi4LzojOAnOhQoWMjJArOCNa8+IupojRlERABEQg1QiMHz/e+vbtaxs3brSzzz47KofHtb5nz542bdo0Cb6iQliFioAIiIAIiIAIiIAIiIAIiIAIiIAIiEDkCDAQHHevdevW2ejRo+3GG2+MXOEqSQREIJ4EJPaKJ33tWwREQAREID0JrF+/3mrWrOlC8Z1++unpCUFHnXIEAl26/DwOXoEJQRfJu355JzD/OXBdzYuACIiACOSOAEKshg0b2hdffGFbtmxxgtjclZCztSX4yhknrSUCIiACIiACIiACIiACIiACIiACIiACiUCAdvpRo0bZiBEjrHHjxm4QX/HixROhaqqDCIhA3glI7JV3dtpSBERABERABPJGgHB1Rx99tN15553Wu3fvvBWirURABERABERABEQgiABCr4oVK9rll19uDz30UNC3kfsowVfkWKokERABERABERABERABERABERABERABEYgFgQ0bNtgVV1xhROp44oknrG7durHYrfYhAiIQHQJrFcMmOmBVqgiIgAiIgAhkSiB//vxWv359W7lyZabr6AsREAEREAEREAERyC2BMmXK2MSJE11esWJFbjfP8fo4NU6aNMmuvvpqu/TSS+3pp5/O8bZaUQREQAREQAREQAREQAREQAREQAREQAREIPYEzj//fNu2bZudd9551qBBAxs2bJgRpUNJBEQgOQlI7JWc5021FgEREAERSHICWOW+8MIL9uuvvyb5kaj6IiACIiACIiACiUTgsssuc6M0u3TpYt9++23UqhYo+Grbtq0EX1EjrYJFQAREQAREQAREQAREQAREQAREQAREIDIEihYtavPmzXMDBceOHWt16tSxzz77LDKFqxQREIGYEpDYK6a4tTMREAEREAER+C+Biy66yP7zn//Y2rVrhUQEREAEREAEREAEIkqAEI44iXbv3j2i5QYXFiz4Wrx4cfAq+iwCIiACIiACIiACIiACIiACIiACIiACIpBgBHr06GGbN2+2ffv2WeXKlW3BggUJVkNVRwREIDsCEntlR0jfi4AIiIAIiEAUCJxwwglWoUIFW7p0aRRKV5EiIAIiIAIiIALpTIBRmtOmTbOFCxfa9OnTo4rCC75wEiOk41NPPRXV/alwERABERABERABERABERABERABERABERCB8AnQR/XKK68Yju2XXHKJXXvttfbLL7+EX7BKEAERiAkBib1iglk7EQEREAEREIF/EmjWrJktW7bsn19oiQiIgAiIgAiIgAiESaBevXp200032fXXX2+ffvppmKVlvTmCr4cffth69+7tQkjOmDEj6w30rQiIgAiIgAiIgAiIgAiIgAiIgAiIgAiIQNwJFCxY0P7v//7P5s6da3PmzLFzzjnH3n777bjXSxUQARHInoDEXtkz0hoiIAIiIAIiEBUCF198sX344Yf23nvvRaV8FSoCIiACIiACIpDeBO666y7717/+ZR07drQDBw5EHca4ceNswIAB1rlzZ5s8eXLU96cdiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIhE8At/Zt27ZZkSJF7Oyzz1a7TvhIVYIIRJ3Awbf+laK+F+1ABERABERABETgHwSOO+44mzBhgpUqVcrOO++8f3yvBSIgAiIgAiIgAiIQDoH8+fNbzZo1beTIka6YOnXqhFNcjrZt0KCB4fTVv39/K1asmFWvXj1H22klERABERABERABERABERABERABERABERCB+BEoWrSoderUyYVyHDRokL311lvWqFEjK1CgQPwqpT2LgAhkRuDfEntlhkbLRUAEREAERCDKBA466CB7/fXXbcuWLe4BOsq7U/EiIAIiIAIiIAJpSOCYY46xI4880oYMGWL169d3Tl/RxoCo7PDDD7e+ffu66QUXXBDtXap8ERABERABERABERABERABERABERABERCBMAnQb0X7EYMHH3jgAZsyZYrVqFHDypQpE2bJ2lwERCDCBP6tMI4RJqriREAEREAERCA3BJo1a2br1q2z7777LjebaV0REAEREAEREAERyDGBPn36WJMmTezKK6+0ffv25Xi7cFYknOODDz5ojAT1zmLhlKdtRUAEREAEREAEREAEREAEREAEREAEREAEYkMAwdf27dutXLlyVqtWLRs1apT9+eefsdm59iICIpAjAhJ75QiTVhIBERABERCB6BC46KKL7I8//rBnn302OjtQqSIgAiIgAiIgAiLwF4GpU6far7/+aj169IgZD0RmjzzyiN1222124403qlEwZuS1IxEQAREQAREQAREQAREQAREQAREQAREIj0CJEiVs2bJlNnr0aBsxYoQL6fjll1+GV6i2FgERiBgBib0ihlIFiYAIiIAIiEDuCRQrVszOO+8898Cc+621hQiIgAiIgAiIgAjkjEDx4sVtxowZNnfuXHv00UdztlEE1urWrZvNnj3bJk6caJ07d7YDBw5EoFQVIQIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiEG0C+fLls759+9qGDRvs008/tUqVKtmKFSuivVuVLwIikAMCEnvlAJJWEQEREAEREIFoErj44ott+fLlzuErmvtR2SIgAiIgAiIgAulNoEGDBkZ4xRtuuMHee++9mMFo166dPf30005odumll9r+/ftjtm/tSAREQAREQAREQAREQAREQAREQAREQAREIDwC1apVsy1btljDhg2tadOm1r9/f/vtt9/CK1Rbi4AIhEUg31+xVRVcNSyE2lgEREAEREAEwiPw5ptv2llnnWUbN260GjVqhFeYthYBERABERABERCBLAjQEHfBBRfY77//bi+//LIdeuihWawd2a/Wr19viNxpIFy0aJEVLlw4sjtQaSIgAiIgAiIgAiIgAiIgAiIgAiIgAiIgAlElMH36dOvVq5eVK1fO5syZY6ecckpU96fCRUAEQhJYK2evkFy0UAREQAREQARiR6BChQp28skn28KFC2O3U+1JBERABERABEQgLQkccsghNmvWLPvwww9t0KBBMWWAyGzNmjWG0L1+/fq2Z8+emO5fOxMBERABERABERABERABERABERABERABEQiPQKdOnZzL14EDB6xKlSqunSm8ErW1CIhAXghI7JUXatpGBERABERABCJMoHXr1s7hIsLFqjgREAEREAEREAER+AeBU0891SZOnGjjxo1z4RX/sUIUF1SqVMleeukl++qrr6x27dq2Y8eOKO5NRYuACIiACIiACIiACIiACIiACIiACIiACESawOmnn+6i1XTu3NmuvPJKY/qf//wn0rtReSIgAlkQUBjHLODoKxEQAREQARGIFYF169ZZrVq17K233rLy5cvHarfajwiIgAiIgAiIQBoT6Natmy1YsMC2bt1qJ5xwQkxJfPHFF9a4cWP74YcfbOXKlc76P6YV0M5EQAREQAREQAREQAREQAREQAREQAREQATCJrBkyRIn9ipevLgL61i5cuWwy1QBIiAC2RJQGMdsEWkFERABERABEYgBgfPPP99Kliwpd68YsNYuREAEREAEREAE/ktg/Pjxdtxxx1n79u3tt99+iymWMmXKGGL3f/3rX1azZk3bsGFDTPevnYmACIiACIiACIiACIiACIiACIiACIiACIRPoHnz5rZ9+3YrXbq01ahRw2hvUhIBEYg+AYVxjD5j7UEEREAEREAEsiVw0EEHWYsWLWzhwoXZrqsVREAEREAEREAERCASBAoWLGhz5861N9980wYNGhSJInNVxlFHHWWrV6927qYNGjSIeUjJXFVWK4uACIiACIiACIiACIiACIiACIiACIiACIQkwGDC5557zoYOHWo33XSTtWzZ0r799tuQ62qhCIhAZAhI7BUZjipFBERABERABMIm0Lp1a3v11VeNsEZKIiACIiACIiACIhALAmeccYY9/PDDNnbs2LiIrQoUKGDz58+3q666ytq0aWOTJ0+OxWFrHyIgAiIgAiIgAiIgAiIgAiIgAiIgAiIgAhEkgKnB8OHDbc2aNbZ161arVKmSvfjiixHcg4oSAREIJCCxVyANzYuACIiACIhAHAnUr1/fihQpolCOcTwH2rUIiIAIiIAIpCOBjh07WpcuXezqq6+2f//73zFHcPDBB9ukSZNcg2D37t1t5MiRMa+DdigCIiACIiACIiACIiACIiACIiACIiACIhA+gZo1a7qwjuecc47Vq1fPbr31Vjtw4ED4BasEERCBvxHI9+df6W9L9EEEREAEREAERCBuBNq3b++sbQlppCQCIiACIiACIiACsSLw888/27nnnmuFChWyl156yQ455JBY7fpv+8HZ69prr7XOnTs7x7H8+fP/7Xt9EAEREAEREAEREAEREAEREAEREAEREAERSA4CEydOtH79+hnCr1mzZlmZMmWSo+KqpQgkPoG1cvZK/JOkGoqACIiACKQRAUI5Ymu7d+/eNDpqHaoIiIAIiIAIiEC8CRQsWNDmzp1rb775pt18881xq84111xjCxcutNmzZ1uzZs3s+++/j1tdtGMREAEREAEREAEREAEREAEREAEREAEREIG8E7juuuts06ZNtnv3bhfWcfHixXkvTFuKgAj8jYDEXn/DoQ8iIAIiIAIiEF8CTZs2NeKaL1myJL4V0d5FQAREQAREQATSjsAZZ5zhwimOGzfO5s2bF7fjb968uRO/v/7664b1/+effx63umjHIiACIiACIiACIiACIiACIiACIiACIiACeSdQsWJFe/XVVw2zg1atWlnv3r1t//79eS9QW4qACDgCCuOoH4IIiIAIiIAIJBgBBF+HHnqoLVq0KMFqpuqIgAiIgAiIgAikA4FevXrZ448/bps3bzYEYPFKn332mXP32rNnjy1dutSqVKkSr6povyIgAiIgAiIgAiIgAiIgAiIgAiIgAiIgAmESePLJJ6179+524oknGvPxbHcK81C0uQjEm4DCOMb7DGj/IiACIiACIhBMoG3btrZixQqFLQoGo88iIAIiIAIiIAIxIYCzV/ny5a1Nmzb2448/xmSfoXbyr3/9y9atW+fqUrt2bVu2bFmo1bRMBERABERABERABERABERABERABERABEQgCQi0b9/etm3bZgULFrRq1arZY489lgS1VhVFIDEJKIxjYp4X1UoEREAERCCNCWBj+8cff9jTTz+dxhR06CIgAiIgAiIgAvEigMMoYRx3795tXbt2jVc13H6PPPJIW758ubVr185atmxpDz30UFzro52LgAiIgAiIgAiIgAiIgAiIgAiIgAiIgAjkncBJJ51kL730kgvn2K1bN7v88stlfpB3nNoyjQlI7JXGJ1+HLgIiIAIikJgEjjrqKGvYsKE99dRTiVlB1UoEREAEREAERCDlCZQpU8bmzJlj8+fPN5y+4pkOOeQQe/TRR+22226zPn36uPz777/Hs0ratwiIgAiIgAiIgAiIgAiIgAiIgAiIgAiIQB4J0NYzevRoF+XmhRdesCpVqtjmzZvzWJo2E4H0JCCxV3qedx21CIiACIhAghPAvWLlypX23XffJXhNVT0REAEREAEREIFUJVCvXj274447bODAgW7EZbyPc8iQIU4Mj8V/06ZNbd++ffGukvYvAiIgAiIgAiIgAiIgAiIgAiIgAiIgAiKQRwKNGjWy7du326mnnmo1a9a0e++91/788888lqbNRCC9COT7659F/y3pdc51tCIgAiIgAklAAJFXyZIlbfLkyXbVVVclQY1VRREQAREQAREQgVQkQJNBmzZtbNOmTbZlyxYrVapU3A+TehDS8fDDD7clS5bY6aefHvc6qQIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAJ5I0D705gxY2zo0KHG4MPp06fbMccck7fCtJUIpAeBtXL2So8TraMUAREQARFIMgJHHnmkMaJBoRyT7MSpuiIgAiIgAiKQYgTy5ctn06ZNs8KFCxvOo7/99lvcj7Bq1arO2r9o0aJWvXp1W716ddzrpAqIgAiIgAiIgAiIgAiIgAiIgAiIgAiIgAjkjQDtTwMGDLB169bZBx98YJUqVbJVq1blrTBtJQJpQkBirzQ50TpMERABERCB5CNAh+qzzz6rEEXJd+pUYxEQAREQARFIKQKI0BcsWGBbt261G264ISGOrXTp0vbiiy+6cI5NmjSxhx56KCHqpUqIgAiIgAiIgAiIgAiIgAiIgAiIgAiIgAjkjcC5557r2p/q1q1rjRs3tkGDBiXEwMO8HY22EoHoEpDYK7p8VboIiIAIiIAI5JkA4YkOOuggW7RoUZ7L0IYiIAIiIAIiIAIiEAkCFSpUcBb6kyZNcmGmI1FmuGUUKFDAZs6cabfeeqv16dPHevbsab/++mu4xWp7ERABERABERABERABERABERABERABERCBOBE44ogjbPbs2TZlyhQbP3681apVyz755JM41Ua7FYHEJSCxV+KeG9VMBERABEQgzQnwQMvIBYVyTPMfgg5fBERABERABBKEQJs2bWzYsGHWu3dvW79+fYLUymzo0KHOeWzWrFl24YUX2q5duxKmbqqICIiACIiACIiACIiACIiACIiACIiACIhA7gl06dLFXnvtNfv555+tSpUq9uSTT+a+EG0hAilMQGKvFD65OjQREAEREIHkJ0Aox9WrV9uePXuS/2B0BCIgAiIgAiIgAklPYOTIkXbRRRfZJZdcYl988UXCHE+rVq1s06ZN9u2331q1atVsw4YNCVM3VUQEREAEREAEREAEREAEREAEREAEREAERCD3BM444wzX3tOhQwe77LLLrFu3bvbTTz/lviBtIQIpSEBirxQ8qTokERABERCB1CFAKMdDDjlE7l6pc0p1JCIgAiIgAiKQ1ATy5ctnTzzxhBUrVsxw+vrll18S5njKlStnmzdvtrPPPtvq1q1rhJxUEgEREAEREAEREAEREAEREAEREAEREAERSF4CBQoUsAkTJtjChQtdpt3n9ddfT94DUs1FIEIEJPaKEEgVIwIiIAIiIALRIFC4cGFD8EWnqpIIiIAIiIAIiIAIJAKBIkWK2OLFi+2DDz6w7t27J0KVMupw5JFHuroNHjzYrrvuOjfic//+/Rnfa0YEREAEREAEREAEREAEREAEREAEREAERCD5CODqvm3bNitevLhVr17dJk6cmHwHoRqLQAQJSOwVQZgqSgREQAREQASiQQB7WkIRffrpp9EoXmWKgAiIgAiIgAiIQK4JnHbaaTZ79mybOXOmjRs3LtfbR3MD3MduvfVWW7Rokc2dO9fq1KmTUCEno3nsKlsEREAEREAEREAEREAEREAEREAEREAEUpXA8ccfby+88IINHDjQ+vTp41zn9+7dm6qHq+MSgSwJSOyVJR59KQIiIAIiIALxJ9CoUSM3UoHOVCUREAEREAEREAERSBQCF110kd199902YMAAW7FiRaJUK6MeLVq0cGEdf/jhB6tSpYqtXLky4zvNiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAIJB+Bgw8+2EaOHGnPP/+8a/epVKmSrVu3LvkORDUWgTAJSOwVJkBtLgIiIAIiIALRJpA/f35r3769QjlGG7TKFwEREAEREAERyDUBRlJeeeWV7lnl7bffzvX20d6gbNmyruGvcePG1rRpUxsxYoT98ccf0d6tyhcBERABERABERABERABERABERABERABEYgiAZzct2/fbpUrV7YLL7zQbr/9drX5RJG3ik48Avn+/CslXrVUIxEQAREQAREQgUACmzZtsho1atirr75q1apVC/xK8yIgAiIgAiIgAiIQVwK//vqr1a9f33bs2GE8s5QoUSKu9cls55MmTbIbb7zRatWqZbNmzUrYemZWfy0XAREQAREQAREQAREQAREQAREQAREQARH4J4Hx48c75/nzzjvPGSccd9xx/1xJS0QgtQislbNXap1QHY0IiIAIiECKEqhevbqdeuqpplCOKXqCdVgiIAIiIAIikMQEDj30UFu4cKE7gtatWxvir0RMPXv2tPXr19tHH33kRn3K4j8Rz5LqJAIiIAIiIAIiIAIiIAIiIAIiIAIiIAK5I9CnTx97+eWXbdeuXUZYx6VLl+auAK0tAklIQGKvJDxpqrIIiIAIiEB6EiBE0uzZs+3AgQPpCUBHLQIiIAIiIAIikLAEihcv7hrS3njjDevWrVvC1hOH1C1bttjZZ59tdevWtTFjxpgMzxP2dKliIiACIiACIiACIiACIiACIiACIiACIpAjAoRzfO2116x58+Yu4+6+f//+HG2rlUQgGQlI7JWMZ011FgEREAERSEsCHTp0sC+//NKee+65tDx+HbQIiIAIiIAIiEBiEyhfvrw99dRTLkTiXXfdlbCVLVq0qC1atMio4+DBg61p06b21VdfJWx9VTEREAEREAEREAEREAEREAEREAEREAEREIHsCRQqVMimTp3qouQ89thjRljH999/P/sNtYYIJCEBib2S8KSpyiIgAiIgAulJgDCOhHN84okn0hOAjloEREAEREAERCDhCTRu3Njuv/9+GzZsmM2fPz9h65svXz4bMGCAEcrxvffecxb/K1euTNj6qmIiIAIiIAIiIAIiIAIiIAIiIAIiIAIiIAI5I3DFFVfY1q1b7eCDD7aqVava9OnTc7ah1hKBJCIgsVcSnSxVVQREQAREQAQ6duzoOk5/+OEHwRABERABERABERCBhCTQu3dvu/baa+2qq66yV199NSHr6CuFkH7btm1Wv359a9KkifXv399+/fVX/7WmIiACIiACIiACIiACIiACIiACIiACIiACSUjglFNOsQ0bNljPnj2tc+fORvQc9a0l4YlUlTMlkO/Pv1Km3+oLERABERABERCBhCKwd+9eK126tE2YMMG6deuWUHVTZURABERABERABETAEzhw4IBdfPHFbhTlxo0b7aSTTvJfJeyUUZ4I1U4//XSbM2eOnXbaaQlbV1VMBERABERABP4fe3cCZ2P9/n/8QvZdkezJEin7UvY1W/a9Ilu2Inshe3tote+FJNlCKmEkW6FkKxRStpTITv/en+//nt+ZaYwZjZlz5rw+j8ft3Oc+9/L5PM9Rt/u+7utCAAEEEEAAAQQQQAABBKIm8PHHH1ubNm0sTZo07ppP8eLFo7YhayHgvwIhZPby3y+HniGAAAIIIPAvgfTp01vDhg1NtcZpCCCAAAIIIICAvwooTf68efMsS5YsLmPWyZMn/bWrof3SRb8tW7aYSjwqxf/06dNDP2MGAQQQQAABBBBAAAEEEEAAAQQQQCAwBWrWrGnffPON5cqVyx544AEbPXq0kRMpML9Lev1/AgR7/Z8FcwgggAACCASEQLt27UwZMnbv3h0Q/aWTCCCAAAIIIBCcAqlSpbKlS5fauXPnrH79+nbhwgW/h1A2L51nKcW/zrlatmxpp06d8vt+00EEEEAAAQQQQAABBBBAAAEEEEAAgWsLZM6c2VasWGFDhw61/v37W506dez48ePX3oBPEPBzAYK9/PwLonsIIIAAAgiEF6hatarlyJHDpk2bFv4j3iOAAAIIIIAAAn4loPLTy5cvt++++85at24dEE9NJk6c2F555RVTiv/Vq1fbvffeaytXrvQrVzqDAAIIIIAAAggggAACCCCAAAIIIBA9gYQJE9ozzzxja9eutV27dlnhwoW55hM9Qtb2IwGCvfzoy6ArCCCAAAIIREVAJ6MqMzRz5ky7fPlyVDZhHQQQQAABBBBAIM4EChYsaAsWLLCFCxda375946wf0T1wjRo1bPv27Va6dGmrXr26PfHEE3b27Nno7ob1EUAAAQQQQAABBBBAAAEEEEAAAQT8SKBMmTK2bds2K1eunOn6z8CBA7nf5kffD12JmgDBXlFzYi0EEEAAAQT8SqBt27Z29OhRlynDrzpGZxBAAAEEEEAAgQgEKlWq5LKSjh492t56660I1vDPRbfddpvNmzfP3n33XZs9e7Z74vPLL7/0z87SKwQQQAABBBBAAAEEEEAAAQQQQACBKAmkTZvW3n//fRs/fryNGTPGKlSoYAcOHIjStqyEgD8IEOzlD98CfUAAAQQQQCCaAnfeeafppunUqVOjuSWrI4AAAggggAACcSPQqlUre+6556xHjx4uy1fc9OLGjqq+qxRlvnz5rHz58ta/f3+7cOHCje2MrRBAAAEEEEAAAQQQQAABBBBAAAEE/EKgY8eO9tVXX9np06etSJEi9sEHH/hFv+gEAtcTINjrekJ8jgACCCCAgJ8KtGvXzpYuXWrHjh3z0x7SLQQQQAABBBBAIKzAM888Y48//ri1bNnS1q5dG/ZDP3+XJUsWd+41YcIEGzdunBUvXty2bNni572mewgggAACCCCAAAIIIIAAAggggAACkQkULFjQNm/ebC1atLCmTZta586d7dy5c5FtwmcIxLkAwV5x/hXQAQQQQAABBG5MoHHjxpYiRQp75513bmwHbIUAAggggAACCMSBwNtvv2116tSxhx56yL799ts46MF/O2SHDh1cvzNmzGilS5e2YcOG2aVLl/7bTtkaAQQQQAABBBBAAAEEEEAAAQQQQCDOBJIlS+Ye7ps/f77NnTvXSpYsaTt27Iiz/nBgBK4nQLDX9YT4HAEEEEAAAT8VSJ48ucuKMWnSJD/tId1CAAEEEEAAAQT+LZAwYUKbNWuWy4z14IMP2v79+/+9kp8vyZUrl33++ef26quv2ssvv2zFihWzDRs2+Hmv6R4CCCCAAAIIIIAAAggggAACCCCAQGQCjRo1sm+++cbSpk3rAr6U4Z2GgD8KEOzlj98KfUIAAQQQQCCKAkolu2fPHlu1alUUt2A1BBBAAAEEEEAg7gWSJk1qCxcuNJVGrFGjhh09ejTuOxXNHiRIkMB69Ohh27dvtzvuuMPKli1rTz75pJ0+fTqae2J1BBBAAAEEEEAAAQQQQAABBBBAAAF/EciRI4etWbPGevXqZV27dnWlHf/44w9/6R79QMAJJPj7n4YFAggggAACCASuwAMPPGDZs2d3aWUDdxT0HAEEEEAAAQSCUeDYsWNWrlw5S5kypbuIliZNmoBlmDlzprsIqOyrY8eOdWUqA3YwdBwBBBBAAAEEEEAAAQQQQAABBBBAwCVbeOSRRyxx4sQ2e/Zs0z05GgJ+IBBCZi8/+BboAgIIIIAAAv9FQNm9FixYEJAZMf7LuNkWAQQQQAABBAJfIFOmTPbJJ5+Ygr7q1atn58+fD9hBtW7d2nbv3m2VKlVyY2natKkdOXIkYMdDxxFAAAEEEEAAAQQQQAABBBBAAIFgF6hcubIr61ioUCGrWLGiPf/883b16tVgZ2H8fiBAsJcffAl0AQEEEEAAgf8i0KxZM0udOrVNmTLlv+yGbRFAAAEEEEAAgTgRyJUrl3388cfuwlnLli3typUrcdKPmDjobbfdZu+8846tWLHCvv76aytQoIBNmjTJSKoeE7rsAwEEEEAAAQQQQAABBBBAAAEEEIh9AV3vWbJkib388ss2bNgwq169uv3666+x3xGOiICPAMFePhjMIoAAAgggEIgCyZIls8cee8wmTpzI0wSB+AXSZwQQQAABBBCwe++91z766COX5att27YBHxxVo0YN++6776x9+/bWpUsXq1Chgm3bto1vGgEEEEAAAQQQQAABBBBAAAEEEEAgAAUSJEhgPXv2tPXr19uhQ4escOHCtmzZsgAcCV2OLwIEe8WXb5JxIIAAAggEtUCnTp3s4MGDtnz58qB2YPAIIIAAAgggELgCZcuWdaWp33//fRcgFbgj+V/PU6RIYa+++qpt2rTJLl++bCVKlLBu3brZ77//HuhDo/8IIIAAAggggAACCCCAAAIIIIBAUAoUK1bMtmzZYjVr1rS6deta79697eLFi0FpwaDjViDBP6UE/o7bLnB0BBBAAAEEEIgJgWrVqlny5MldKtmY2B/7QAABBBBAAAEE4kJg8eLF1rhxY+vevbuNGjUqLroQ48fUpZcZM2bY008/7cpUPvfcc9ahQwdLmJBn8GIcmx0igAACCCCAAAIIIIAAAggggAACsSDwzjvvWNeuXS1//vz23nvvWZ48eWLhqBwCAScQwlVFfgkIIIAAAgjEE4HOnTu7lLHK8EVDAAEEEEAAAQQCVaBevXqmi2WvvfaaDR48OFCHEabfSvWvstvff/+9Pfrooy7DV6lSpWzDhg1h1uMNAggggAACCCCAAAIIIIAAAggggEBgCOgaj7J86SE/Zfx69913A6Pj9DJeCBDsFS++RgaBAAIIIICAWf369S1Tpkw2ceJEOBBAAAEEEEAAgYAWaNGihU2aNMlGjhxpL730UkCPxbfzadKksdGjR9s333xjadOmtQceeMDatm1rR48e9V2NeQQQQAABBBBAAAEEEEAAAQQQQACBABDImzevrV+/3tq3b+8e8NPDfmfOnAmAntPFQBcg2CvQv0H6jwACCCCAwP8XSJw4sXXs2NEFe124cAEXBBBAAAEEEEAgoAXatWtnb7zxhit9+NZbbwX0WMJ3vmDBgrZy5UqbO3eue82XL58Lajt//nz4VXmPAAIIIIAAAggggAACCCCAAAIIIODHAkmSJLExY8bYRx99ZEuXLrXixYvb1q1b/bjHdC0+CBDsFR++RcaAAAIIIIDA/xdQbfBTp07Z7NmzMUEAAQQQQAABBAJe4IknnrAXX3zRunfvblOmTAn48YQfQNOmTW337t321FNP2YgRI0xBXzNmzLCrV6+GX5X3CCCAAAIIIIAAAggggAACCCCAAAJ+LFCnTh2XzT1r1qxWpkwZe/311/24t3Qt0AUSDf2nBfog6D8CCCCAAAII/E8gVapU9v3339vixYutc+fOsCCAAAIIIIAAAgEvUK5cORf81LdvX8uRI4cVLVo04MfkOwBlZ61cubIpk9nPP/9sukzz4YcfWu7cuS1Pnjy+qzKPAAIIIIAAAggggAACCCCAAAIIIODHAqlTp3blHBMmTGgDBgywzZs3W40aNSxFihR+3Gu6FoACB8jsFYDfGl1GAAEEEEAgMoEePXq4JwdWr14d2Wp8hgACCCCAAAIIBIzAsGHDbODAgda+fXubOnVqwPQ7Oh3NnDmzTZgwwbZv3265cuWymjVrWvXq1Un7Hx1E1kUAAQQQQAABBBBAAAEEEEAAAQTiWECBXoMGDbI1a9bYt99+a0WKFDHu2cXxlxIPD0+wVzz8UhkSAggggEBwC5QoUcLKli1Letjg/hkwegQQQAABBOKdwPDhw92Fsg4dOsTbgC99aQUKFLBFixZZSEiInT592ooXL+6eCD1w4EC8+04ZEAIIIIAAAggggAACCCCAAAIIIBBfBXSvbtu2bVa6dGmrWrWqDR482K5cuRJfh8u4YlmAYK9YBudwCCCAAAIIxIaAsnuplOOPP/4YG4fjGAgggAACCCCAQKwIBEvAlzDLly9vGzZssLlz57rXfPnyWdeuXe3QoUOxYs1BEEAAAQQQQAABBBBAAAEEEEAAAQT+m0D69Olt/vz59tZbb9krr7xilSpV4trOfyNl6/8vQLAXPwUEEEAAAQTioUCjRo0sW7Zs9uabb8bD0TEkBBBAAAEEEAhmgWAK+NL33LRpU9u5c6c7r1u6dKnlyZPHunXrZj///HMw/wwYOwIIIIAAAggggAACCCCAAAIIIBAwAl26dLFNmzbZyZMnrXDhwrZgwYKA6Tsd9U+BREP/af7ZNXqFAAIIIIAAAjcqoHrgly5dcqUcn3zySUuSJMmN7ortEEAAAQQQQAABvxOoXLmyXb161fr06WPZs2e3okWL+l0fY7JDiRIlcuUcFeR1xx132JQpU+yFF16wX3/91V0gTJMmTUwejn0hgAACCCCAAAIIIIAAAggggAACCMSwwO23327t2rWzgwcPWv/+/e348eOuvOMtt9wSw0did0EgcIDMXkHwLTNEBBBAAIHgFOjYsaNdvnzZpk2bFpwAjBoBBBBAAAEE4rXAsGHD7Nlnn7UOHTrYxIkT4/VYvcEpgL9Tp072ww8/2GuvvWZLlixxmb6eeOIJO3z4sLcarwgggAACCCCAAAIIIIAAAggggAACfiiQPHlydx1r7ty5NmvWLCtVqpTt2rXLD3tKl/xdgGAvf/+G6B8CCCCAAAI3KKA64K1bt7Y33njDZb64wd2wGQIIIIAAAggg4LcCCvjSpACo0aNH+20/Y7pjCvrq3Lmz7d2718aMGWOLFy+2u+66y1QSQIFgNAQQQAABBBBAAAEEEEAAAQQQQAAB/xVo1qyZbdu2zVKmTGklSpSwyZMnX7ezf//993XXYYXgESDYK3i+a0aKAAIIIBCEAj179rT9+/fbhx9+GISjZ8gIIIAAAgggEAwCyu6lQK/evXvbiBEjgmHIoWNU0JcCvBT0pUxfn376qd19993WqFEjW79+feh6zCCAAAIIIIAAAggggAACCCCAAAII+JdArly5bO3atda9e3d7/PHHrUWLFnbq1KkIO7lz505r1apVhJ+xMDgFEvwT/Uf4X3B+94waAQQQQCBIBJo0aWIHDhywzZs3B8mIGSYCCCCAAAIIBKOASjkq8KlPnz720ksvBSOBy+aqIP9XXnnFNm3aZGXLlnUe9erVs4QJed4vKH8UDBoBBBBAAAEEEEAAAQQQQAABBPxe4LPPPrNHH33UVOZxzpw5Vrp06dA+nz9/3ooUKWJ79uyxKVOmWLt27UI/YyZoBUK40he03z0DRwABBBAIFoF+/frZV199ZZ9//nmwDJlxIoAAAggggEAQCugJyJkzZ7osX926dbNgfLZNAV0K9N+4caOFhIRYhgwZXJavAgUKmILhdHGQhgACCCCAAAIIIIAAAggggAACCCDgXwLVqlWzb775xvLnz2/lypVzDzJ617Z69Ojhsrqrx0888YT99NNP/tV5ehMnAmT2ihN2DooAAggggEDsClSpUsUSJ05sK1asiN0DczQEEEAAAQQQQCCWBRYsWODS3rds2dI97ZgoUaJY7oF/HW737t02atQoe+eddyxt2rTWoUMHVxogZ86c/tVReoMAAggggAACCCCAAAIIIIAAAggEuYACvHQdZ8CAAVapUiV3jat9+/ahKrfccovL+qXyjwkSJAhdzkzQCYQQ7BV03zkDRgABBBAIRgEFedWsWdO2bt3qUr0GowFjRgABBBBAAIHgEdC5T8OGDa1OnTo2a9YsS5IkSfAM/hojPXLkiI0dO9YmT55sR48etdq1a7uylzpHpMTjNdBYjAACCCCAAAIIIIAAAggggAACCMSBwObNm132dl3DuXjxYpgM9gryevXVV61Xr15x0DMO6ScCBHv5yRdBNxBAAAEEELjpAqrnrRI+qvVNQwABBBBAAAEE4ruAyhg+9NBD7mnHDz/80FKlShXfhxyl8V2+fNkWLlxo48aNc2W+c+XKZZ06dbJ27dpZpkyZorQPVkIAAQQQQAABBBC4cYE1a9bY4sWLbenSpaYsrDejKdB/2bJl7hh33XWXvfzyyzfjMOwTAQQQQAABBG6SwJUrV9w1LZV21LWc8E3VfLZt22YFCxYM/xHvg0MgJGFwjJNRIoAAAggggED//v1t3rx59uOPP4KBAAIIIIAAAgjEe4EKFSrY6tWrTRfFVNL6xIkT8X7MURmg0v03adLEVq5c6W4uNmjQwN38y549u7Vq1cp081ElA2gIIIAAAggggAACN0fgp59+sunTp9uePXtuzgH+2evBgwdtw4YNpocefv/995t2HHaMAAIIIIAAAjdHYMiQIa5aT0SBXjqirt20aNHCLl26dHM6wF79XoBgL7//iuggAggggAACMSPQrFkz0008pXalIYAAAggggAACwSBQtGhRW7dunQv0KleunLvpFQzjjuoY8+fPb2PGjLHDhw/b+PHjbd++fVapUiXLkyePDR8+3HQjkoYAAggggAACCCAQswJt2rSxwoULx+xOw+2tVKlSlHYKZ8JbBBBAAAEEAkVg1apV9vzzz9vVq1ev2WUFge3YscNGjBhxzXX4IH4LEOwVv79fRocAAggggECoQKJEiax37942bdo0O378eOhyZhBAAAEEEEAAgfgsoMAlBXwlSZLEypYt6y6Exefx3sjYkidPbm3btrWNGze6TGj169e3t99+23Lnzu2yok2ZMsX++OOPG9k12yCAAAIIIIAAAghEIKDrdDe7KaMrDQEEEEAAAQQCS0CZ6ZV5PSpZ1xUMNnLkSNu0aVNgDZLexohAgn9+JOTmjxFKdoIAAggggID/C5w7d85y5crlbua9+OKL/t9heogAAggggAACCMSQgIKV6tWrZ9u3b7eFCxdaxYoVY2jP8XM3ekJ02bJlNnPmTFu6dKm7yFi7dm13wbFOnTqmADEaAggggAACCCDgTwIHDhxw5y7JkiWz++67z2Uwvfvuu91Dj1euXLGmTZta48aNTdfEtm3b5rrevXt3e+CBB1xg+0cffeTKHr7++uvufHHJkiWWLVs2l1kjc+bM0RrqxYsX7bXXXrO1a9eazqtq1qxpLVu2tEyZMrn9VK9e3T777DM7evSoezDzk08+cYH2umF7++23hx5L562atF6xYsWsX79+ljZt2tDPIzvO3r17LW/evNahQwebNGmSff755zZ//vzQLCHqj0qfHzp0yCZPnuxuFKdKlcpy5sxJZYBQYWYQQAABBBCIXQEFcCl4a/HixfbBBx/YDz/8YAoS1/KIQnv0WY4cOdzDjVyrid3vKo6PFkJmrzj+Bjg8AggggAACsSmgE70+ffq4TA2//fZbbB6aYyGAAAIIIIAAAnEqkC5dOvv000+tWrVq9uCDD9r7778fp/3x94MrE4SC43Rh8ciRIzZu3Dg7ffq0tWjRwjJmzGjNmze3efPm2V9//eXvQ6F/CCCAAAIIIBAEAgpkKl++vA0ePNimTp1qXbt2dcFNq1evthIlStjcuXPtu+++cxL9+/d3AVNatnv3brds7Nix1qVLF1uwYIHVqFHD1qxZ485zlCG/Y8eO0RL8888/XUbZ/fv32+zZs61nz5721FNP2cMPP/yv/VSpUsW2bt3qbt4q4Kpdu3ah6zz77LMuYEzHV5DaK6+8YqVLlzY9zKkWneNo/QIFCpgC2tKnT28DBgxwgV5arn4lTJjQli9f7gLD5EdDAAEEEEAAgbgR0P+Ty5Qp44LNv//+e9u3b5+NGjXKnefoswQJEphv9k4FtB88eND69u0bNx3mqHEmQLBXnNFzYAQQQAABBOJGQBe7FPSlk0MaAggggAACCCAQTAJJkyZ1N/o6d+7sgpZGjx4dTMO/4bEqe4TKPCpY7ueff7aXX37ZZchQNggFfjVq1MhmzJhhKjVAQwABBBBAAAEE4kJAQVPKSKqmIKgdO3aYgq0U3FSwYMEwXdJN0iJFioRZpuCnBg0auGVPP/20C3hXKXBl4goJCQmz7vXeDBkyxAWW6VwzderULnisVKlSrk/KyuHbJk6caO+9954LTFNGLx1TTZnHXnjhBXvnnXdc4Jiyc2mMe/bsccu0TnSOs3PnTre9so09//zzlj17du3ClA1N2ce8m8Z6KEKZzmgIIIAAAggg4B8CuXPnth49erhAdCVxUCC5gsBTpkzpOpg4cWJTwNfbb7/tsob6R6/pRWwIULA7NpQ5BgIIIIAAAn4koBNAZfcaMWKE9e7d22699VY/6h1dQQABBBBAAAEEbq6AnoLUTS6luNc5kZ5+1I04LaddX0AljPTwgKbjx4+77BfKgNGpUye7dOmSuzmojGAq+XjPPfdcf4esgQACCCCAAAIIxJBAlixZ3J4UsKRSjirBqKbAr6g0r/SRSj96TYFiyg524cIF04MD12sqr6SSiQrMSpEiRejqCuJSOcfw55yFCxcOXadQoUK2cuVKl0313XffdTduGzZsGPq5MqredddddurUKZcJLKrHUSmo+++/32VlVdYy36Zz4jvvvNMGDRrkyjkOHz7c5syZ47sK8wgggAACCCAQywLK+rlhwwaXgfTkyZPuPCR8F1QiWg/d/fLLL+7BPGX+fOihh1w2+yRJkoRfnfdxKKAHDfQAQNasWU3nfpUqVbIMGTL85x5xJfM/E7IDBBBAAAEEAk9AN+d00YtsFoH33dFjBBBAAAEEEIgZgV69erksChMmTHBZHChHGH1XZfV6/PHHXckfXWBUaUw9carMX7pZqYwRKjukUpC///579A/AFggggAACCCCAQDQEvECqRIkSRWOryFeN7r6UKUvnlSoh7tuUOUvX4iJrXnYtBYwpg1eaNGnsq6++Cp127dple/fudWWaonOcb7/91mU7i6g8o24+arkC+nVenDdvXlu0aFFk3eQzBBBAAAEEELgJAgraUglnBasXK1bMnnnmGdu8ebML8o7ocDrvUQZSZSutW7euC/LS/8f1UCPNvwSUee3QoUOu2kDTpk3d96YAfD08qfO+G21k9rpRObZDAAEEEEAggAVSpUrlsnopbbuye8VEBHkAc9B1BBBAAAEEEAhSgWbNmrmApPr161v58uVdmR8vI0SQktzwsHV+qTICmlSeSDcmP/74YzdNmzbNXbwqWrSoy3KhTBflypUzbUNDAAEEEEAAAQTik4CXSWP58uUu66lKK3lNGTcUPOat4y2P6FVZwVSOUkFf+fPnD7PKjz/+GJplLLLjeBupHPdPP/3kbjCqRGP37t29j1z2sDJlytg333xjPXv2dKWh2rRpYzon1jkbDQEEEEAAAQRuroCCxJVZ880337S0adNa+/bt3bUVXUOhxT8Bnd+tWLHCZsyYYU2aNHEPSyoxR9WqVaM9WDJ7RZuMDRBAAAEEEIgfAk888YS7uDRmzJj4MSBGgQACCCCAAAII3ICAStps3LjRdPOtdOnS7kbXDeyGTXwE9HRpqVKlbPDgwfbll1+6co/z5s0z3UhcunSp1apVy9KnT28lS5a0p556ymX+OnLkiM8emEUAAQQQQAABBGJOwMuYpfKHXlNJRTUFqcdkU5DUrbfe6rKazp49O3TXyujw8MMP2+HDh0OXRTajLB1qAwcODJPxQedW/fv3d8FYUT2OAszUF2XvUhlzlaX0mgLH9CCoMoPMmjXLpkyZ4kwWLlzorcIrAggggAACCNwkgfXr17tgH5VmfuGFF1xw9siRI41Ar5sE7ge7VeZWZff66KOP7LvvvrNcuXJZtWrVXOb88+fPR6uHBHtFi4uVEUAAAQQQiD8CyqSg8kVvvPEGZXXiz9fKSBBAAAEEEEDgBgTuvPNO0wW2fPnyuYxTlK65AcRINlFgV6NGjeytt96yHTt22K+//mrvvvuuC/4KCQmxFi1a2B133GE5c+Z0F7xUBlI3IfW0Iw0BBBBAAAEEEIiqwPHjx92q+/fvD7OJgvtTp07tgplUsnDcuHE2YsQIt45utKkkopoXfO4bFOZ99ttvv7l1ovLHkCFD3GrKzNGuXTvr16+f3XXXXVa8eHHTeaeaSvn4vmr+559/dsv0qlLZ6vP8+fNNZX7Gjx9vXbt2tVatWpn34Ob1jqMy22oajwK95syZ4wK5lIlVmby8Nnfu3NCx16lTxy0uW7as9zGvCCCAAAIIIHATBBTgVbFiRRfspVLNPXr0CM3ceRMOxy79UKBAgQKufPYHH3zgHoTUOavKeUa1JfinBuSNF4GM6lFYDwEEEEAAAQT8UuD06dMuarxbt24uTaxfdpJOIYAAAggggAACsSRw6dIlU/ZTXXB77rnn7JlnnomlIwf3YXROumHDBtu0aZObNm/e7ALCEiRI4G6IFi5c2JTd4r777rOCBQu6m6XKUEFDAAEEEEAAAQQ8gSVLlrigqt27d7tSiQ0bNrSxY8daxowZ3SrKlqFMGRcvXrQHH3zQ9LnO9RT41KFDB1u5cqUNHTrUZXvVucfEiRNdliu9qlWqVMndhFM2res1ZQtT8LoCys6ePWvJkyd3xxo0aJDp/KZjx46moDOtp2yoyqil/k2fPj10mTJrqfSiyvt4N/0UGK/y2JUrV3ZdiOw48lAw2LZt20yZzXSOq+PWrl3bBbepvORjjz3mzJRtVcH5CvTau3ev6cbjqFGjXF+vN1Y+RwABBBBAAIHoC+g8QZk69f9qTTo/oAW3gLKt6lxMlQdWrVrl7t1eRySEYK/rCPExAggggAAC8V1ANzJ1YqmnHqNywSq+ezA+BBBAAAEEEEDgzTfftJ49e1rznrKLTwAAQABJREFU5s3dTb5kyZKBEssCymixZcsWl3VCmSd0o1Lnq3pmMUmSJJY3b153I1KvypThTVmzZjWVkaQhgAACCCCAAALhBRRgrvKNCmzSq84rFPR0s5qOocxgOXLkuOHjqI/79u1zN4Fz584d4c3g/3IcBYxpe5WZVIlJHYNzqZv1i2C/CCCAAAIImAso79Spk+nak4KxaQh4Asokq5KOf/31l61bty70oQXv83CvBHuFA+EtAggggAACQSdw5swZdyGnTZs29sorrwTd+BkwAggggAACCCAQkcBnn31mzZo1c0FFCxYssCxZskS0GstiUUAXu5StQ+UNvEnZJxQEps/UdMNWAV/ZsmWz7Nmzu9fbb7/dNGXKlMlNesAhXbp0prLmPD0bi18gh0IAAQQQQCCABY4dO2a1atW67gj69OljLVu2vO56rIAAAggggAACwSegAB5lC1W2T68cc/ApMOLIBI4ePWoq56gA/BUrVriMtddYn2Cva8CwGAEEEEAAgaASeP311106ed0s40ZmUH31DBYBBBBAAAEEIhH44Ycf7KGHHrJTp065sj1ly5aNZG0+ikuBI0eOuKwXKnekrGCHDh1ykzJU6EKZbtCqbJNvUynItGnTWpo0aVx5pRQpUpgmlVpSuSN9rknzBIX5yjGPAAIIIIBA8Ako85VXTjGy0WfIkMFSpkwZ2Sp8hgACCNwUAf2bRZn59OpNvu/Dz3v/1vH+7aPXa01aVw/WJE2a1GVaVrZl33m9D79MnytLtib9G0v7oCEQzAJKvHDPPfdYkSJFTOWauc4QzL+GyMe+detWF/A1bNgwV+7zGmsT7HUNGBYjgAACCCAQVAIXLlywfPnyuScUx48fH1RjZ7AIIIAAAggggEBkAn/++ac9+uijtnz5clOAfJcuXSJbnc/8WOCPP/5wQV8nT540zXuTSjqdPXvWTefOnTNNKmfklTTSzV2VUKIhgAACCCCAAAIIIIAAAv4qoLKs+neLN/m+j2he/87x/t0T/jWizy5duuQeoNG9BM1HtymQTEFfXvDXtV4VMKuHcPTqOx/RMu9zZW1OnTq1244Amuh+M6wfWwK9e/e2GTNm2M6dO13W8dg67rWOo/9WVK1a1f29XLp06bVWY3kcCbzwwgs2fPhwl+E+Z86cEfWCYK+IVFiGAAIIIIBAMApMnTrVVCdcJXHy5MkTjASMGQEEEEAAAQQQiFBAF8B0gUVP1LVt29bGjh3rnmKOcGUWIoAAAggggAACCCCAAAIIIBDPBZQ5WZOCv7z58O/Pnz/vHqaJ6qsevNGDOH/99ZebIppXINq1mrKXKQBMgV+avCCwiOaV4dnL9BzRq7alIRBTAso+njdvXhs9erR17do1SrvVtaiYDl703af+LmXOnNll5VP/9PeH5j8CCqotUKCAlS9f3qZNmxZRxwj2ikiFZQgggAACCASjgE7slEK2ePHiNmvWrGAkYMwIIIAAAggggECkAkuWLHFZvpQR9YMPPrAcOXJEuj4fIoAAAggggAACCCCAAAIIIIBAzAkooCx8MJjK4yljs/ca2bz3mbJ4a9J7BcCEbwp8iSggLF26dJY+fXrzfY1oXgFkBM+EVw3e9/3797fZs2fb/v37XUnU60msXLnSQkJC3EOH11s3qp9HtE9lPPd+61HdD+vFnoAywXXs2NEOHjzoAvPCHZlgr3AgvEUAAQQQQCCoBebNm2fNmze3LVu2uLrhQY3B4BFAAAEEEEAAgQgEvv/+e2vcuLH98ssv9u6777oy2BGsxiIEEEAAAQQQQAABBBBAAAEEEPBzAZW4VMCXAr9OnTr1r9fwy37//XdTgIwmb17bh2/KyKRgMS8QLEOGDHat6dZbbw3zmUpc0uKPgH5jd9xxh3Xr1s0GDx583YEdOHDASpUq5YJ8Ro4ced31o7LCzdhnVI7LOv9NQFkRs2bNas8884z16dMn/M4I9govwnsEEEAAAQSCXaB06dLuHyGffvppsFMwfgQQQAABBBBAIEIBlZLo3LmzC/YaNGiQDR06lCd2I5RiIQIIIIAAAggggAACCCCAAALxW0BVU8IHgPkGgyko7OTJk2Gm3377zb1XNrLwLXny5KHBX7fddpt5k4LCvHm9+r6n7GR4Rf95v2HDBrv//vttx44dVrBgwUg7tm/fPqtcubKprKIq8Sjoq0uXLlayZEk7fvy4vf7667Zt2zZXprRNmzZWs2bN0P1pm8mTJ9umTZtcCdOcOXPaq6++atfaZ6FChWzp0qWu0o+y1ydKlMi+/vprmz9/vtu+du3aNmHCBNuzZ4+1bdvWZboPPdg/Mxs3brTXXnvNfvrpJ7v77rtdXwsXLuy2ve+++3xXZf4/COh7lvGaNWvC74Vgr/AivEcAAQQQQCDYBdauXWsVKlSwZcuWkaki2H8MjB8BBBBAAAEEIhXQRa8ePXpY+fLl3cWxTJkyRbo+HyKAAAIIIIAAAggggAACCCCAAAKewKVLl8IEgfkGhSkg7MSJE24KP6/tfFvSpEnDBH9lzJjRdI1Cr97k+15ZxpR9jHbzBcaMGWMvvfSSHTly5LoHO3r0qE2dOtUGDBhgjz32mCnQp0CBAqaHDqtXr259+/a1e++91wYOHGirV6+2KVOmWLt27dx+dV+vatWqNmTIEFuxYoW1bNnS/bYi2qd+Ey+//LIrLXn58mXT70mZ7Dt06GDr16+3LFmyuIDDokWL2pIlS1zGOwWtKehMbd26dVapUiX3EOSDDz5oderUsS+//NKyZctmVapUMZUfpMWMgCz1wKkCQxWQ59NCbvF5wywCCCCAAAIIIOBuVjZo0MD69etnOkmjrjw/CgQQQAABBBBAIGKBTp06WYkSJaxp06ampxdnzZrlLmpFvDZLEUAAAQQQQAABBBBAAAEEEEAAgf8TSJw4sd1+++1u+r+l159T2UkFgoUPAvOCw44dO2Zbt2512aA0r0xjf//9d+iOFTSi7GBeIJheFQymvnivXr/0PmXKlKHbMhM9gV27drksXVHZSuZeVqw777zTBVRpu0aNGrl5XYdSe+GFF1y2MGWbV7CXyjQqkYPu6anp9YEHHnDz19qngoh2797tMoFpRWUde+eddyxPnjyWPn16U3CXvvdx48ZZ165d7YsvvggN9nrxxRfd76lJkyYuAKl///5Wv35987KBuQPzR4wIKAObyjkqu9ddd90VZp8Ee4Xh4A0CCCCAAAIISEBPGShF7LRp06x9+/agIIAAAggggAACCFxDoHjx4u4CaseOHd1Tlnr6UmUdwz1td42tWYwAAggggAACCCCAAAIIIIAAAghETyBNmjSmKXfu3FHaUNmbFAimUoAK/tKrN3nvVR5Q88oEderUqTD7VdCPb/CXN69XBYNlzpzZTXfccYcr4xdm4yB/o2xtCqaLbvMyr50+fdoWLFhg6dKlcyUctR+VDlXgj5I1KBAoR44cpuAwBX+pnOPw4cNtzpw5/zqkt0/vA2WE820qIaqWPXv20AA/r/Skfhte029HfVCJyHz58lmZMmXcRxorLWYFFJSppsBOgr1i1pa9IYAAAgggEC8FdHL2+OOP2+DBg12q1xQpUsTLcTIoBBBAAAEEEEAgJgTSpk1r77//vqms41NPPWVr1qxxqfCVvp6GAAIIIIAAAggggAACCCCAAAIIxKXALbfcEhqQFZV+XLhwwQV9ecFfCgDT5L3fu3evK+Wn9wpCuXr1auhuFRjmBX95rwoC8+a9VwWKqV+B1DTWW2+9NVpdVjCWF7ATnQ29wCyVV1R79tlnrVevXtfchco/qnSjrk0p0Ovtt9+2Rx55JMz63j7DLLzOm4geZqxWrZpt3LjRFi1a5EpLKnuZWs2aNa+zNz6OrkCyZMncJvodhW+B9bcnfO95jwACCCCAAAI3TUAZKd59911Xt1vzNAQQQAABBBBAAIHIBZROX2nymzdv7tLuT5w40ZTSnoYAAggggAACCCCAAAIIIIAAAggEioAyPilblKbrNWV4UtDXkSNH3PTrr7+GzmvZt99+aytWrHDLzpw5E7o7BR4pCCpLliymYLCIXrVMwWEqd+kPTeUTP/vsM9M9M5UtvJHgqaiOw9u3l4xh8+bN/9r07NmzpsxfclR2rW+++cZ69uzpHkBs06aNM61SpUrodt4+Qxfc4Iyy2u/cudP0un//flfysV+/fq6k5A3uks1uQIBgrxtAYxMEEEAAAQSCQUBpZZXydciQIe4ELSon9cHgwhgRQAABBBBAAIHIBO6991776quv3NOWTZs2tccee8zefPNNyhhEhsZnCCCAAAIIIIAAAggggAACCCAQkALK/KRgLU3Xa3/99VdoIJgXFPbLL7+Y5n/++WdTQJPeK4OW17ygsPABYQoEy5o1a+ikTGEqa3gz24EDB1xAVcOGDV35wmHDhlmzZs1i9LheQJayq6mpdF+qVKls3rx5poCqokWLuuXKpta6dWvr37+/C/gaM2aMy+Y1a9Ysq1q1qrVv394WLlxoCvYKv0+3g//wx7lz59x39OGHH7pSoqNGjTIvKO0/7JZNoylAsFc0wVgdAQQQQACBYBLo0aOHKSNF3759be7cucE0dMaKAAIIIIAAAgjcsIAucI0fP95q165tHTp0sLVr17qMqXrKkoYAAggggAACCCCAAAIIIIAAAggEo4BKPCp4SVNk7eLFiy4AzAsE833VvB6yO3z4sJ08eTJ0N17QWfggMN+AMM0rcOpGm7JYeU2lLFu1amXPPPOMS5qgkokxUZZS/VdbtmyZ1atXz0JCQqx79+72/PPPW8WKFd3DhWnSpLH58+e77PIlS5Y09UX38FTqUZnQ6tSp4/ZRtmxZ9xrRPlUS8s8//3SfHzx40AVtKROb2qlTp9yr/lCAm5qvdZ8+fVzGNmUSU6Cevo9MmTJZqVKlol3m0u2cP25IIMHf/7Qb2pKNEEAAAQQQQCAoBJYsWRJ6Qlm+fPmgGDODRAABBBBAAAEEYkpAF8ratm3r0vw//fTTNnjwYL8pPxBTY2Q/CCCAAAIIIIAAAggggAACCCCAQGwLnD9/3mUCU+BXRJMCwzR5WbLUPwVKZcuW7ZpT9uzZLV26dBEORQFNx48fD/OZlzVLmccUbKVrQCqD6bW6deu6MovTp0/3FkX6qkA3BXCp/KUq7ixdutTy589vXbp0sWnTppkyeumYHTt2tNdee82SJ0/ugr20Tfr06V2gl4K/ChQoYMq4pXXD73Py5Mk2YcIEU2YuhQvp4URds3ruuedcdjVlSOvdu7c1aNDAFMT2448/Wtq0aW306NGuEpC27dy587/GIbdFixZZhQoV/vUZC25M4OjRoy6Ab82aNeFdQwj2ujFTtkIAAQQQQCCoBGrWrOlqris6/2anwQ0qWAaLAAIIIIAAAkEhoAtnY8eOden28+XLZzNnzjSVe6QhgAACCCCAAAIIIIAAAggggAACCNxcgRMnToQJBlPJSG86dOiQmz99+nRoJ5SBLHxAmIK5nnzySRccFbpiuBndP7v11ltdtq9OnTq50obRDfbSLhXQpYxaOXPmDHNP7syZMy6wS5nRUqdOHXp0rX/58mW7cuWKG2fu3LnDbBfZPkN3Eo2Znj17uoC2xx57zAW/nT171tS3KVOmWMaMGW3GjBnR2BurRiZAsFdkOnyGAAIIIIAAAtcV2LVrl913333uJqWeFqAhgAACCCCAAAIIRF9AT1bqQtjmzZtt6NChLvhLZQZoCCCAAAIIIIAAAggggAACCCCAAAJxJ6CShl4AmO+rFwymUode2cPr9VJBX8og1q9fP1u9erUpUCyqmb2ut++4/nzcuHHWtWtXF+R12223henO559/bp988om9+OKLYZbz5sYFCPa6cTu2RAABBBBAAIH/L6BI/Xfffdf27NljGTJkwAUBBBBAAAEEEEDgBgT0tKXS6Cu1f+HChd1Tj4UKFbqBPbEJAggggAACCCCAAAIIIIAAAggggEBsCHzxxRdWvnz5aB9KD/ndc889tmrVqnhxb23MmDHWq1cva9iwoSvzqOxj+/fvt40bN9ru3bttzpw5Lrgt2lBsEKFAZMFeCSPcgoUIIIAAAggggEA4gWHDhlnixIld3e5wH/EWAQQQQAABBBBAIIoCerqzb9++tmXLFpdSv3jx4qbzrEuXLkVxD6yGAAIIIIAAAggggAACCCCAAAIIIBCbAsrslSBBguseUvfRvPUyZ85smTJlsmTJkpmCduJDU1avwYMH2y+//GLt2rWzBx980N544w3Lnz+/LV26lECvWPySCfaKRWwOhQACCCCAQCALKOWsslBMnjzZRegH8ljoOwIIIIAAAgggENcCBQsWtHXr1rnU9i+//LIVK1bMlXeM635xfAQQQAABBBBAAAEEEEAAAQQQQACBsAIq56hALt+moC5vmTJ4FSlSxLp162Zz5851JSF//fVXd72nQIECpik+tKRJk7qHFjds2GBnzpyxc+fO2datW03VgVKmTBkfhhgwYyDYK2C+KjqKAAIIIIBA3Au0bNnSKleubF26dLErV67EfYfoAQIIIIAAAgggEMACyvKli2Hbt293T3qWKVPGevToYadPnw7gUdF1BBBAAAEEEEAAAQQQQAABBBBAIH4JKNhLWdl1LUctXbp0VqdOHRs5cqStXbvWBT4p6EllDps2bWpZs2YNGIDFixdbrly57JNPPolWn5WxzMtiFq0NWTlGBAj2ihFGdoIAAggggEDwCLz99tu2Y8cOGzt2bPAMmpEigAACCCCAAAI3USB37ty2cuVKl0F11qxZ7mnP+fPn38QjsmsEEEAAAQQQQAABBBBAAAEEEEAAgagKpEiRwh5//HGbNm2a/fDDD/b777/bkiVLrF+/flauXDlXqjGq+/K39X788Uc7cOCA6dW3/f33375vmfczgQT/fEF8Q372pdAdBBBAAAEE/F1gwIABLthr165d1N/29y+L/iGAAAIIIIBAQAmcOHHC+vbta9OnT3dPiL711lvu6cqAGgSdRQABBBBAAAEEEEAAAQQQQAABBBCwunXr2m233eau8/gzx8GDBy1HjhyhXbx69apVq1bNPv30U1OJSlrcCBw9etQyZ85sa9assQoVKvh2IoTMXr4czCOAAAIIIIBAlAQGDRpkGTJksCeffDJK67MSAggggAACCCCAQNQEdAFQT4muXr3a9u3bZwULFrRhw4bZ+fPno7YD1kIAAQQQQAABBBBAAAEEEEAAAQQQQCAaAr6BXtpMSR9WrVpl5I6KBmIsr3pLLB+PwyGAAAIIIIBAPBBQutoJEyZYjRo1bOHChdagQYN4MCqGgAACCCCAAAII+I9AxYoV7dtvv7UxY8bYiBEj3BOgmue8y3++I3qCAAIIIIAAAggggAACCCCAAAIIxKXA8ePH7fXXX7dt27ZZ6tSprU2bNlazZk1XZvLZZ5+1K1euuO5lypTJqlatanPmzHHvS5UqZW3btnXzu3fvtlmzZrnMXh07dnSBXi+99JL7rH379pYtWzZ77rnn3PuuXbvaxYsXbfLkye49f8SdAJm94s6eIyOAAAIIIBDQAtWrV3cnjd26dbM///wzoMdC5xFAAAEEEEAAAX8USJw4sfXr18/27NljDzzwgDVs2NBdsNu5c6c/dpc+IYAAAggggAACCCCAAAIIIIAAAgjEksCPP/5o999/v2XPnt0FaB05csRq1aplU6dOtfTp09vgwYPt448/tvHjx9u9995rJUqUsPfee89lkVdQmNrs2bOtWbNmNnLkSDtw4IBbVr9+fcufP7+bV0BYvXr13PyZM2ds0qRJLiP9yZMn3TL+iDsBgr3izp4jI4AAAgggEPACo0aNskuXLln//v0DfiwMAAEEEEAAAQQQ8FeBLFmyuCcsQ0JC7NixY3bfffeZnqTU05s0BBBAAAEEEEAAAQQQQAABBBBAAIHgE+jdu7dVqlTJOnXq5B4SfOGFFxzCoEGD3KuyeU2bNs0SJEhgw4cPt6efftoaNWpkTz75pCVM+L9QoVatWpmXxcsTLF26tMsSpu20f71XS5UqlS1fvtyWLl1qGTJk8FbnNY4EKOMYR/AcFgEEEEAAgfggcOutt7r0sA8//LDphLB8+fLxYViMAQEEEEAAAQQQ8EsBnWt99dVXNmPGDBs4cKB7+lKv3bt3t6RJk/pln+kUAggggAACCCCAAAIIIIAAAggggEDUBK5evfqvFb3ALN8PTp8+bQsWLLB06dK5Eo76TCUb77rrLhfIdf78eUuWLJkL1urcubONGzfOjh49anv37vXdjZu/1jUlBXuFb9WqVQu/iPdxJEBmrziC57AIIIAAAgjEF4GWLVta7dq1TXW7z549G1+GxTgQQAABBBBAAAG/FNAFPqXQ/+GHH6xHjx42dOhQl1p/5syZFtEFQb8cBJ1CAAEEEEAAAQQQQAABBBBAAAEEEPiXwJ133mmJEiUKnZSdK6L2/fffu8XPPvusezBQDwdu3brVBXPpMwV6eU0lGrXPP//803799Vdv8XVfIwr2uu5GrBBrAgR7xRo1B0IAAQQQQCD+CkyYMMGVERowYED8HSQjQwABBBBAAAEE/EggZcqUNmzYMNMFvOrVq1u7du2scOHCtmTJEj/qJV1BAAEEEEAAAQQQQAABBBBAAAEEEIiqwOjRo2369Omh06RJkyLcNEWKFG755s2b//W5EjMoi5fXRo0a5TJ+KduXrh9F9WFBgr08Qf98JdjLP78XeoUAAggggEBACWTNmtWVc3zjjTcsJCQkoPpOZxFAAAEEEEAAgUAW0HmYLvx99913li9fPqtXr56VK1fOVq1aFcjDou8IIIAAAggggAACCCCAAAIIIIBA0Ak0btzY2rRpEzo1bNgwQgOVa0yVKpXNmzfPZfTyVlIgV+vWre3gwYNu0YYNG1zg2Pr16901o3Xr1pnu5V2vKdBLZSEvX74cZtWLFy/ahQsXwizjTdwIEOwVN+4cFQEEEEAAgXgnoJPHhx56yJUV+uuvv+Ld+BgQAggggAACCCDgzwJ33323zZ8/3zZu3OhS9VepUsUqV65MIL4/f2n0DQEEEEAAAQQQQAABBBBAAAEEELgBgSRJklj37t1dQFbFihVt6NChpqxg5cuXN5WCLFmypJ06dcoFfml5hgwZ7O2333bXjAYOHGjbt28PParKO6p5AWKaz5Ili/399982ZcoUmzp1qu3cudMuXbrkHjTMnj2727fWo8WdAMFecWfPkRFAAAEEEIh3Airn+Mcff1i/fv3i3dgYEAIIIIAAAgggEAgCpUqVss8++8wFeekpTF3wq1q1qq1duzYQuk8fEUAAAQQQQAABBBBAAAEEEEAAAQSiIKAAr/bt25sSMAwbNsz69OljhQoVsuHDh9u+ffvcNSG9Jkz4v7AglXZMkyaNqcxjzZo1benSpS4ArHfv3u5oixYtsv79+7v5Zs2ama4rdenSxXbs2GEFChRwwV/K6qWgLwWC0eJWIME/XwLfQtx+BxwdAQQQQACBeCUwZ84ce/jhh+3jjz+2GjVqxKuxMRgEEEAAAQQQQCDQBFavXm1DhgxxwV8q7zhgwACrVatWoA2D/iKAAAIIIIAAAggggAACCCCAAAIBJ1C3bl277bbbXCnFm9X5M2fO2N69e02lHVOnTh1jhzlx4oQLFFNWMK8pUEwtRYoU3iJeb6KAAvQyZ85sa9assQoVKvgeKYTMXr4czCOAAAIIIIDAfxZo2bKlNW/e3B577DHTiSANAQQQQAABBBBAIO4EKlWq5C4IhYSEuAt+tWvXtmLFitm8efPs6tWrcdcxjowAAggggAACCCCAAAIIIIAAAggg8J8FUqVKZUWKFInRQC91SkFqvoFeWqYgLwK9JBH3jWCvuP8O6AECCCCAAALxTmDcuHGWOHFi69ChQ7wbGwNCAAEEEEAAAQQCUaB8+fK2bNky27Jli+XJk8datGhhefPmtTfffNP0BCgNAQQQQAABBBBAAAEEEEAAAQQQQAABBAJDgGCvwPie6CUCCCCAAAIBJZAuXTp75513bMmSJTZx4sSA6judRQABBBBAAAEE4rNA0aJF7f3337fdu3dbzZo17emnn7bs2bO718OHD8fnoTM2BBBAAAEEEEDgpgooqL5Ro0aWO3duu//+++3TTz+97vEWL15suXLlsk8++cStu3XrVnv22WdN52zDhw+/7vasgAACCCCAAAJxK/D333/b8ePH3cN1ixYtsrfffttdY3nkkUesYsWK9vXXX8dtBzl6vBW4Jd6OjIEhgAACCCCAQJwKqHZ0//79rWfPnqbyQfny5YvT/nBwBBBAAAEEEEAAgf8TUFYvXYAcMWKEjR8/3t566y0bNWqUNWjQwLp16+bO3/5vbeYQQAABBBBAAAEEIhP4448/XKDXc889Zy+88IKVLFnSJkyYYNWrV49sM/vxxx/twIED7lUrKuPqrl27bNu2be68LNKN+RABBBBAAAEEbrrAiRMn7Oeff7ZDhw65yZv3fb1w4UJoP1T6MFu2bO7BukKFCtlvv/0W+hkzCMSkQIJ/Ig3/jskdsi8EEEAAAQQQQMATuHTpkj3wwAN29epVW79+vSVJksT7iFcEEEAAAQQQQAABPxK4ePGizZs3zwWA6bytYMGCLuhLT6KmSZPGj3pKVxBAAAEEEEAAAf8TUIb71q1b26+//mqZM2e2X375xZ1DpUqV6rqdPXjwoOXIkSN0PZXerlOnjg0dOtSGDBkSupwZBBBAAAEEEIhZgZMnT4YJ4FJAlxfE5c2fP38+9KAZMmRwQVxeMJcypYefT5YsWej6mqlbt64pAGz69OlhlvMGgagIHD161J1brlmzxpRkw6eFkNnLR4NZBBBAAAEEEIhZgcSJE9ucOXOsWLFi1rt3b3vzzTdj9gDsDQEEEEAAAQQQQCBGBBSU//DDD7tJ5YOU9atPnz7Wr18/a9q0qXXo0MHKli0bI8diJwgggAACCCCAQHwTUDYutVtu+d9ttyxZskR5iL6BXr77iPIOWBEBBBBAAAEEwggo39GxY8dc8PXhw4dNkxfE5ft69uzZ0O3SpUvnArkUwKVs6FWqVAkT2KWgrhQpUoSuzwwCcS1AsFdcfwMcHwEEEEAAgXgukCdPHps0aZK1aNHClQNq3LhxPB8xw0MAAQQQQAABBAJboGjRojZ58mR79dVXbdasWW6+XLlydvfdd1v79u1dQNgdd9wR2IOk9wgggAACCCCAQAwI/PTTTzZ8+HALCQlxe+vevbspo4cC5ZXt/ssvv7QFCxbYpk2bTFm+OnfubA899FDokXfv3u3OtxTw1bFjx9DlzCCAAAIIIIBAxAIqeewFcCmTpua9V29emTZVecZradOmDc3AlTt3bpchSUFdvpm5UqZM6a3O600WUDBeggQJbvJR/HP3MTl2gr388zumVwgggAACCMQrgebNm9vq1avdzUHdPNTJNA0BBBBAAAEEEEDAvwX0VGu3bt3c9PXXX9uUKVNs5MiR1r9/f6tataqpxGOjRo3cjUv/Hgm9QwABBBBAAAEEbo6AyjJ17drVVIpx37591rJlS1dqR9e+1q1b524mT5061Z577jnr1auXNWzY0Hbu3Gn58uWz2bNn24svvmjbt2+3gQMH3pwOslcEEEAAAQQCROD06dOuHLICtbxJQVy+8wrm0npeU5ZyZdPUlDVrVitdurR71by3TPNk5PLE4v716tWrVq1aNfv0008tUaJEcd+hWOzBypUr3QMCw4YNi5GjEuwVI4zsBAEEEEAAAQSuJzBmzBjbsGGDNWvWzD3VqJNwGgIIIIAAAggggEBgCBQvXtw06ZxuyZIl9u6777qMFV26dLF69eq5Uo+1atWy5MmTB8aA6CUCCCCAAAIIIBADAsrWVaJECcuQIYPbm+a9DKgrVqww3dC89957TdfBdK6kUtmbN292wV6tWrWy9OnTW+3atWOgJ+wCAQQQQAAB/xNQFqOTJ0/akSNH3KTALd8ALt9Arr/++it0ACqLnClTJhewpf+vqoJMhQoVwgRwKZhLQdfBmiEqFOufmcWLF9t7771nM2fODC0p7fu5P80PGDDAVq1aZfptBFM7cOCA6dwvJjO5EuwVTL8gxooAAggggEAcCiiF/fvvv+9uEj711FM2duzYOOwNh0YAAQQQQAABBBC4EYGkSZNakyZN3KQLtnPnznVT06ZNXaBX3bp13We6mUkJhBsRZhsEEEAAAQQQiC8CgwYNckHxxYoVs40bN9r48ePd0A4dOhQ6RJ1b0RBAAAEEEAg0gVOnTrngraNHj4YGckU0r2WXL18OHZ6CnzNnzhwaxFWoUCGrXr26C5RW8JYCuzRlzJjREiZMGLodM5ELKGvonDlzbPr06ZGv6POpSkxPnjzZVFJa34MytyvjlpoCkxQ4pvt69913n3vwT9d5evToYcePH7fXX3/dtm3bZqlTp7Y2bdpYzZo1Q/f8+++/27x582zNmjX2/fffW6lSpeyll15yWeEV6KV5tfbt27vSmsp+qna9/bqVIvlDv7OPP/7YZaV/7bXX7M0337TvvvvOjTFbtmy2cOFCN+k3qXOzfv36mcp7qm3dutVd29JvMFeuXC5wTqW6dY1L2e19M5ApqYUegJSbyoBq7KpupHatPuicUIFex44dc31QwKMenixZsqTb7kb/INjrRuXYDgEEEEAAAQSiLZA3b16bNm2auwGok5i2bdtGex9sgAACCCCAAAIIIOAfAspgoYtTmvSU7ocffugu6OkiV+LEia1KlSruBudDDz3kyij4R6/pBQIIIIAAAgggEDsCuqH9xx9/uBt5RYoUcZm9Pvroo9g5OEdBAAEEEEAgGgJXrlxxwTYKRgk/KTjGW6Z5TefPnw/du4KyFJx1++23u0AuBXPdc889ofN6r88UxOVlwgzdOEhm/C2L1YwZM0wBSAoQU1ZSBXIp6O6LL76wCxcu2GOPPWYKTr/77rvt4sWLbl7XfZTZXev17dvXZSZVGWptO2XKFGvXrp37NlXSev/+/bZjxw774Ycf7P7773elNxU8Vr9+fXftaM+ePe7+oJcd/scff7zufq/3U1HQmUpkq6m89m+//eaC1pRRdcKECbZ27VpXVnvXrl2uBPf8+fNdkJeC3lRqe8uWLS7jas6cOV0wmIK51q9fbz///HNo8opx48aZklkogF8GSmrRokUL076U7OJafdB1Ml07U7Cb7o22bt3acuTIcb0huc+9305EGewI9ooSISshgAACCCCAQEwJNG7c2J5++ml3MqUnAlQOiIYAAggggAACCCAQ2AK6eNu1a1c36SLw0qVLXRmBPn36uAtaRYsWtQcffNBNDzzwgCtlFNgjpvcIIIAAAggggEDkAh988IG7AajSjZ06dbLPP/888g34FAEEEEAAgRgSUIYhBbucOHHCBXH5vnqBW76vWtcLKlEX9ACXArhUStGb8uXL54K2fIO6NK/1fDMfxdAQ4s1ulP3qzJkzfjOew4cP2xNPPOECnMqVK+f6pWs3ISEh9s0337jrOgrMqly5sv3555+2b98+9zvSit27d7dKlSq58xq9f+GFF1wwlwLHFOx17tw5W716tWm/+g0VLFjQla5W0JRa6dKlXTYwBS5pP17r3bt3pPv11ovsddasWaaxKaOYgq40RgVwKRhR2egVUKZMXGXLljWdo6nc9jvvvGOPP/64jR492h1f/VVQmPqnjF6FCxe2iRMnuiAtBcEpKOyRRx4JTWShLGXK9KVMZtP/yap2rT4ok9jy5ctd9++88053rMjG4vuZ99tR6fDwjWCv8CK8RwABBBBAAIGbLqC0rF9//bVLC6tX1VWnIYAAAggggAACCMQPAV0IVgZXTXrad9WqVS74SxfTXnzxRVfesdI/F/VUHqBChQqmTBeUZ4gf3z2jQAABBBBAIFgFvBvk3qscdANQmVK80j5//fWX4/FdJ1i9GDcCCCCAQNQFrl696jJFKiBL08mTJ13wjW8Al0rg+b5XKT3f/98oeCV9+vQuMMsL4lLWJv2bXAFbXkCX96p1I8okFPVes6YnoIfj1q1b572Nkddly5a5YCVvZyoXraagKd/rK7oXFz5ISNmvFECkEoVeq1Onjqk0p7euyhmq6aE9lXJUGcTTp0/bggULLF26dK6Eoz7Xec5dd93ljqnrP8rUpYxeKVOmdIFiCqZSdi/fTHDazve3FZX9qg9RaV6/GzRo4PqkrGUKZFM/GzZsGLoLnZOp3xqzmvqrpgQVXt8U3NisWTNXzlLlIDUujaNMmTJuXe8PlXFUoJyy3SsjWkR98NbVq7d/32WRzSuzmJoy44VvBHuFF+E9AggggAACCNx0AZ1seulhdcHrk08+4cmPm67OARBAAAEEEEAAgdgX0AU5pfTXpKYnKXXup2nEiBHuInXatGndU58VK1Y0Zf3SE49eKv/Y7zFHRAABBBBAAAEEoi/w/fffu41Utsi7yXfLLf+7BadsFwp0HzJkiFtH5YIWLVrkShkpY4aayg157ZdffnGzyrhCQwABBBCIPwIKvtJ/9xWIpYAt79UL4vICuXzfa17rKeDLt+nf2nqIXpOCt/SqKiree2+Z93rrrbdyD8YXMBbnFUCk7FCXLl1y2a5i4tDKJqUsUl5TRi01LfOCvfQ6dOhQt9z3DwUtqSmgz7d5gV5a5u3DN2Obd67z7LPPugxXvtv6zitgUMdduXKl9ezZ05WC3LZtm+8qYQKeorrfMDu4xpuI+q2SkWnSpLGvvvrqGltde3Hu3LndhyrLvXfvXjfvHcPbysuO5o3D+9zXzltXr9EN9lJ2Mv09VtBg+EawV3gR3iOAAAIIIIBArAjoHxeKdFfKVNW4fvPNN2PluBwEAQQQQAABBBBAIO4ElK5eZYw06UK3no5Uin1No0aNsn79+plujCpVvtL7a1IJyAIFCrjlcddzjowAAggggAACCPxbQEFauq6lcxq1J5980pUx0uvAgQOtQ4cO7gavbgAqu0Xjxo1dJo6SJUuaMjWobJCagr9ULihnzpyuJJKWKfOGsmcoKwcNAQQQQMA/BC5evOiyASkjkAJAvFcFZIWfvIAub7nWDx+0pcAPBd1kyJDBdM/Em/LkyRM6H/4zreNlIvIPFXoRmUCVKlXs7NmzLvtT1apVI1s1yp8NHz7cNHlNWdSfeeYZO3LkiCVJksRbHOGr9/nChQtd1ivflfR71gN5EbUUKVK4xZs3b/7XxxqfMnQp2FDZsHR+pHKI+u1OmTLlX+v7BjxFZb/KPnejTftXkKWCvvLnzx9mN3ogUdeprtV27drlPsqbN6/t3LnTzX/xxRfWvn370E2yZs3q5qPaR9+xh+4kkpmPP/7Y9BuKqBHsFZEKyxBAAAEEEEAgVgR0427GjBkunb1qYXfp0iVWjstBEEAAAQQQQAABBOJeQBe47r33Xjc98cQTrkO60KYnVFWCQJMuCl64cMGSJk1q99xzjyv5qKdiFfylkhPZs2eP9lORcT9yeoAAAggggAAC8UUgR44c7mHGiMaj8kiHDh1ymTy8G5kqZaTMHl4W027duv1r065du/5rGQsQQAABBP6bwOXLl10wigJSNCn4w5v33ivQxXfygrm8ZXofvhyd1ytlDlLQlu+k/0cUKVIkzDLfz715LxOQty9e45eAArmVwVxB3zEV7PVfhHQdRm3mzJnWuXPn0NKNegjvgw8+uGZiBpU9VPavefPmuQf1dH9PTQGMrVu3dkHrKmeo4KQePXq4QC99rpKJ4UuKqqyi/k7qYb+o7DeqgVQ6Xvimv4Pvv/++C8JX371gqy+//NJee+0191n4bbz3q1evNv09lpkC6dQ0Rt/mZQxTpvrImndcXeOKajt8+LB9/vnn7gGAiLYh2CsiFZYhgAACCCCAQKwJNG3a1Hbv3m3du3c3RcdXq1Yt1o7NgRBAAAEEEEAAAQT8S0BPVGpq2bKl65huhupcUSn/vWnJkiV2/Phx97meZlbQl84jvW2912zZsrkgMf8aIb1BAAEEEEAAgWASSJw4cZiSTbqp6ZV3DCYHxooAAghEVUCZs1SSTpOCRHynM2fOhHnvfea7XPOawgdzeWXuIuqHAnIVrKWMRr6TgnR83yvb4rXeX6tkW0THY1nwCSi7uQKgnn/++dByz3Gl0K5dO3vllVds+/btLpt6o0aN3PWWrVu32rfffuu65V1zUXlqrykjmO7jaQwVK1Z0pRz192b+/PmmQCdlLVU2O7X33nvPZaPSw3wqQ6i2YMECU8Y6lbtW8Jce7tN5UpkyZa67X7eDKPzh228v49bjjz/usqaqnzVq1HBZVjXOZcuW2bp168LsVYFV+u+HF9R29OhRFxSnsdepU8fdv/zss89coL/c1BTcpoxmylSvFlEftNwr863j1qtXzwWN9erVSx9ds6kikjL5NWjQIMJ1EvwD+XeEn7AQAQQQQAABBBCIRYFWrVrZ8uXLXSaH8KlUY7EbHAoBBBBAAAEEEEAgAAR+++03FwSmlPoKBtu7d68pK5gmPZXtNZUM0AU1TXfccYe7AKdlXhkMXazXRTwFjXlTsmTJ3E1Y3YjVBXu9ek9gevvlFQEEEEAAAQQQQAABBBDwJwHd8vcmZdoJPx9+md572XWUYUeTHrbx5iN61ecKxtKk7DSavHnvNaJlyoalyQviiuxV/YqsKTjE+7db+H/LabmWaVIQSurUqd3kOx/RMjJrRSbOZzEhoL8XekitVq1aNmHChJjYZZh9qIzjgAED3N/HqASVq6ShsnFt2rTJ7UeZx1Q+Wvfm9ICdApd0rUXXRBo2bGhjx461jBkzuv9GqELPtGnTXEYvXSvp2LGjy5ClrKX6+6tAJt3r0zUYZTDV38uePXtaoUKFbPHixS7A6pFHHnHH1fJXX33V/Xcnsv2GGWwEb3Tchx9+2AWe6b9TslZ5bK/c4vr1661Jkyb2yy+/uK0VyKkxVK5c2b1Xdi4Fqyl7vP4bo0xiKsE9cuRIl/3MO6Sy+6mfKr+tcpX6754Cx5QxTHaR9UHr6hhaX9nCli5d6ky8fYd/VVavfPnyuXKdvXv3Dv+x3ocQ7BURC8sQQAABBBBAINYF9I+9SpUquch/pU9VJDwNAQQQQAABBBBAAIHoCpw4ccJ++ukn+/nnn92FvF9//TX0VUFietJUryrFcb0bCdE9NusjgAACCCCAAAIIIIAAAsEgoICSpEmTuklZbzTvvYaf13sFgkR3UsYtL4DLC/BSIAYNgUAUmDVrlj366KO2du1aK1u2rF8MQVmodF0kumUSlf1KD92pBKMCKMM3ZdZTkKXXwr/XdRsFWepBPN92vf36rhvdeQXA7tu3zz3Mlzt37jAP9XnBXgrkUuCcSjYqC9m1AkF1Tem7775zQVvKLh/VJusDBw6Ygs2utW9vX8rmtWPHDpeBTQ8lRtAI9ooAhUUIIIAAAgggEEcCSomqlK2ZM2d2daj1jz8aAggggAACCCCAAAI3Q0AX2XTBURcTvfIfetVDCHqK3XvKXa8Ehd2Mb4B9IoAAAggggAACCCCAQEwJKMOOggf0eq358J8rYCuqk4KstK4X0KVj0BBAIHoCdevWdUFCX3/9tSvPF72tg3PtESNG2MKFCyMdvALLVq1aFek6kX3oG+ylLGZx3d5++21X2nLlypUuScY1+hNyyzU+YDECCCCAAAIIIBDrAnp6QPWt9VRDixYtXN1rat3H+tfAARFAAAEEEEAAgaAQ0I0OlXHUREMAAQQQQAABBBBAAAEEEEAAAQRupsCMGTNMJRNVGvGTTz6xa2RsupldCLh916lTx+6+++5I+/1fE0coU5eaSifGdVuxYoUrezl06NDIAr1cNynjGNffFsdHAAEEEEAAgX8JqH521apVXc3w8ePH/+tzFiCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCDgjwIqG7hhwwY7deqU1axZM7SLKs1XoUIFK1GihEt4oBKltLgTUAKKnj172u7du12p2ebNm9tLL71kmTJlivVOffrpp6byjU2aNLHp06eHKTUZQWco4xgBCosQQAABBBBAwA8ElJa1cePGNmzYMBs0aJAf9IguIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIBCxwDfffGNz5syx9957zw4cOGAPPfSQLV68OMzKKuNYq1Yty5Url82fP9+yZ88e5nPexJ7A+fPnTZNvi4sM8JMmTbInnnjCFGw2depUVzbXt08RzIckjGAhixBAAAEEEEAAgTgXUPT6W2+9Zc8++6z5Q43sOAehAwgggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAn4l8P3339vw4cOtQIECVqRIEZs7d661aNHCtm3b9q9AL3W8ePHitm7dOjt79qwVLVrUZs2a5VfjCabOqJSmgrt8p9gc/7Fjx1yAV6dOnax///6mUp+33HJLlLoQtbWitCtWQgABBBBAAAEEYlagS5cu9vvvv7to9tSpU9ujjz4aswdgbwgggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAghEQ+DQoUMuqEtZvLZs2WKZM2e2pk2buqxM999//3X3lDdvXtu4caP169fP3fsaN26cDR061KpVq3bdbVkh8AVOnjzpEl28+uqrljZtWlM5yRo1akRrYAn+qRX6d7S2YGUEEEAAAQQQQCCWBZ5++mnTCc+8efOsYcOGsXx0DocAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIBDMAsePH3f3qRTgpcxcygbVqFEja9mypVWuXNkSJryxwnqbNm2ygQMH2meffWb58uWzxo0bW6VKleyee+6x2267zZImTRrM7AE/doVknT592pX1VAnPZcuW2ZIlS9z32qtXL9OUKlWq6I4zhGCv6JKxPgIIIIAAAgjEiUDXrl1typQp9tFHH1n16tXjpA8cFAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAIDgEFOC1cOFCF+T1+eefm8r+1a9f35VpfPDBBy1JkiQxBvHtt9/atGnT3H2wvXv3xth+2ZH/CChwr2LFitakSRMXJHgDQV7eYAj28iR4RQABBBBAAAH/FlDke+vWrW3+/Pku4r1q1ar+3WF6hwACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAgggEFACx44dswULFrgAr9WrV7sMTLVq1bJmzZpZ3bp1LUWKFDd9PCdOnLDdu3ebyv1duHDhph+PA9w8AWV8S506tWXJksXy589viRMnjomDEewVE4rsAwEEEEAAAQRiR+DKlSuudrmeoli8eDG1y2OHnaMggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAvFWQAFeH374oQvwWrNmjQvwql27tjVt2tTq1KljKVOmjLdjZ2ABKUCwV0B+bXQaAQQQQACBIBZQwJcyfOmpikWLFlHSMYh/CwwdAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEELgRgaNHj7pqMh988IEpwCt58uTmG+AVGxm8bqTfbIPAPwIEe/EzQAABBBBAAIHAE1DA12OPPWY6AVfAV40aNQJvEPQYAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAg1gQOHz7skgno/tLatWtdgJdKMyqDlwK9FPBFQyAABEJuCYBO0kUEEEAAAQQQQCCMQKJEiWzGjBmWIEECq1evns2ZM8caNmwYZh3eIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIBLfAnj17XICXKsZs3rzZUqVK5Uozzps3z2rVqkWAV3D/PAJ29An+/qcFbO/pOAIIIIAAAggEtcDVq1etW7duNmnSJJs8ebLL9hXUIAweAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEAhyga+//jo0wGvnzp2WMWNGlzxAiQOqVatmSZMmDXIhhh/gAmT2CvAvkO4jgAACCCAQ1AIJEya0cePGWfr06a1du3b2xx9/2FNPPRXUJgweAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEAgmgStXrriyjMretXDhQjt48KDlzJnTGjRoYGPHjrVy5cqZqsbQEIgvApRxjC/fJONAAAEEEEAgiAWef/55y5Ahg/Xs2dNOnjxpw4cPD2INho4AAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIxG+B8+fP22effWYffvihLVmyxE6cOGH33HOPtW7d2pTBq1ixYvEbgNEFtQDBXkH99TN4BBBAAAEE4o9Anz59XIavTp062aFDh2zixImWOHHi+DNARoIAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIBLHA0aNH7aOPPnLTJ598YufOnbNSpUpZ3759XYBX3rx5g1iHoQeTQIK//2nBNGDGigACCCCAAALxW2Dp0qXWvHlzu//++23+/PmWJk2a+D1gRocAAggggAACCCCAAAIIIIAAAggggAACCCCAAAII/L/27gTeqnn94/jTpIHQoFEhFJIhMhQqlTHRbUCSecyYhDLUdUvJGCmu0CAliUgl0Shj3DI2oEG40mgsWf/f9/m/1r670xn2OQ32Oefze712e++11/D7vdfavdY+61nPU0AF5s2b55m7lL3rvffes5IlS1qzZs3sjDPO8Ee1atUK6MgZFgJZCswg2CtLGz5AAAEEEEAAgfwqMHfuXGvZsqVVrFjRFPxVo0aN/DoU+o0AAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIFBqBDRs22LRp0xIBXkuWLLEqVarY6aefbq1atbLmzZtbmTJlCo0HA0UgEwGCvTJBYRICCCCAAAIIFACBpUuX2mmnnWarV6+2cePGeRrfAjAshoAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIFCiBlStX2muvvWbjx483lWdcv369HXrooYnsXQ0aNLAiRYoUqDEzGAS2QoBgr63AY1EEEEAAAQQQSHOBtWvXeklH3QHyxBNPWKdOndK8x3QPAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEECjYAlEU2QcffGATJ070IK/333/fSpQoYU2aNEkEeNWsWbNgIzA6BPIuQLBX3u1YEgEEEEAAAQTyg8Bff/1lt956q/Xv399uvPFGfy5WrFh+6Dp9RAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQKhMBPP/3kWbuUwWvy5Mn2448/2p577mmnnHKKV2pp0aKF7bLLLgVirAwCge0sQLDXdgZm9QgggAACCCCQJgIjR460Sy+91Bo1amSjRo2yChUqpEnP6AYCCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAgggULAEkrN3KYPXe++9Z7oZX9dpTj31VH/Uq1evYA2a0SCwYwQI9toxzmwFAQQQQAABBNJBYO7cuda6dWtTtq/Ro0dbw4YN06Fb9AEBBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQyPcCK1eutClTpnh5xkmTJm2WvUsBXs2bN7ddd90134+TASDwNwsQ7PU37wA2jwACCCCAAAI7WEBpgi+44AJPEdynTx/r2rWrFSlSZAf3gs0hgAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAvlb4I8//rDZs2d7gJeCvHTTffHixf1m+9NOO43sXfl799L79BUg2Ct99w09QwABBBBAAIHtJaDUwf3797cePXp4LfihQ4da+fLlt9fmWC8CCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAgggkO8FdH1l/vz5ieCuGTNm2G+//Wa1a9e2Fi1a+KNp06Zk78r3e5oBpLkAwV5pvoPoHgIIIIAAArY6BK8AAC9rSURBVAhsRwHdbXLOOed4Wcenn37aTjrppO24NVaNAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCOQvgRUrViSCu9544w374YcfrEKFCtasWTMP7tK1lZo1a+avQdFbBPK3AMFe+Xv/0XsEEEAAAQQQ2FqBVatW2ZVXXmkvvPCCde7c2e69914rXbr01q6W5RFAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQACBfCewZs0amzlzpk2dOtWDvD777DMrWbKkNWrUKJG9q379+lakSJF8NzY6jEABESDYq4DsSIaBAAIIIIAAAlspMGLECLvmmmusatWqptdHHHHEVq6RxRFAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQACB9BZYt26dzZo1y9566y1/fPTRR6ZyjYcccog1b97cA7xOOOEEbpRP791I7wqXAMFehWt/M1oEEEAAAQQQyE5g2bJldsEFF/gdK126dLGePXvy4yU7MD5DAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQACBfCXw888/2+zZsxPBXR9++KFt2rTJ6tata02bNrUmTZr4Q6UaaQggkJYCBHul5W6hUwgggAACCCDwtwnobpVBgwbZbbfdZpUqVbLHH3/cTjzxxL+tP2wYAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEMirwK+//mpvv/12Irjr/ffftz///NMOOOCAzYK7dE2EhgAC+UKAYK98sZvoJAIIIIAAAgjscIHly5db586dbfz48XbxxRdb//79rXz58ju8H2wQAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEhVYOXKlZ65S6UZ9VDmro0bN9r++++fCO5SBq8qVaqkukrmQwCB9BIg2Cu99ge9QQABBBBAAIF0ExgzZoxdd911tmHDBrv77rvtiiuusGLFiqVbN+kPAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIFEKBr7/+2mbOnOmBXQru+vzzz61IkSJ28MEH23HHHeePxo0bW/Xq1QuhDkNGoEAKEOxVIHcrg0IAAQQQQACBbSqwbt0669Wrlz3yyCN20EEH2YABA+yEE07YpttgZQgggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIBAdgJ//fWXzZs3zwO74gCvFStWWMmSJe3II4/0wK7jjz/eGjVqZLvvvnt2q+IzBBDIvwIEe+XffUfPEUAAAQQQQGBHC3zxxRd2ww032OTJk61du3bWp08f22+//XZ0N9geAggggAACCCCAAAII7ACBrl27eqkTbUp3xd9xxx1e2r1Zs2ZWunRpmzBhwg7oReqb+Oijj+zFF1+0V1991Vq3bm133nmnLxxFkeXUZ5Wx13J66KLQbbfdltKGn3vuORsyZIgVLVrU2rRpYxdffLGVKFEipWU1k/p20UUXWZ06dVLapuafMmWKTZo0yd566y3TmPN7Gz9+vGeTfuKJJ+ykk07Kt8PJ7BjSvtIxFTddfDz//PPjtzwjgAACCCCAAAIIpCCwevVqe/fdd23OnDn+0GvdoK5AroYNGyaCuxo0aOABXymsklkQQCD/C8wonv/HwAgQQAABBBBAAIEdI3DAAQf4RQX9Mb5bt2524IEH2qWXXuoXUapWrbpjOsFWEEAAAQQQQAABBBBAYIcIDBw40GrVqmVjx471Cym77bab6S76+fPn20477eSvFeSULu3nn3/2ci0ff/yxnXXWWYlupdLn//73vzZ79mwPYDvmmGMSy2b3Qi4dOnQwBSnpwlLbtm2tTJkyuQrmWbx4sQ0dOtRKlSqVcrCXbsIZNGiQFS++/f+0reAyBfrlpaW6rEruLFmyxPScn1tmx5ACB2vXrm3xMambpgj2ys97mb4jgAACCCCAwPYW0Ln7p59+mgjseuedd+zLL7/0myR047nO1e+55x4P8FKJxnT6PbK9bVg/AghsLpA+f43YvF+8QwABBBBAAAEE0lagVatW/oNLFxheeeUVz+7VvXt30x02NAQQQAABBBBAAAEEECg4Airjrps+qlSp4sFFxYoVs4ULF3pQVbpdWFGpFmXWythS6XP9+vWtU6dOvqjmT6UpyEvZBC677DI77LDDTL+TRowYkcqieZ5H5tddd90OybCsC23KiLZp06Zc93fq1KnWs2fPlJa7/vrrPdjriiuuSGn+dJ0ps2NIwX977bWXnXnmmTskOC9dbegXAggggAACCCCQlYCC/l944QW/ubxJkyamG0wOOeQQu+mmm/wcURl7X375ZVNgvX6HDB8+3K6++mqfJ91+j2Q1RqYjgMD2Edj+tz9tn36zVgQQQAABBBBA4G8V0AUQZfXq2LGjPfLII9a3b1979NFH7aqrrrIuXbpY5cqV/9b+sXEEEEAAAQQQQAABBBDYPgIKcErXllW2q1T6HF8sip9zGuOKFSu8fIwyiinTmQKczjnnnJwW2+zzGjVqeOYsPeempRqQlpt1ZpxXN/SoVKQydOWm6YKdMp4pCC7VVrNmzVRnTev54mMnfk7rztI5BBBAAAEEEEBgBwsoYOvDDz+0999/3x/vvfeeB3Hp3FY3mRx11FF+Hnn00UebsnbtiHPeHUzA5hBAYBsKEOy1DTFZFQIIIIAAAggUPgGVG7n55ptNd2E/9thj9uCDD3rwlwLBND23Fy0KnyAjRgABBBBAAAEEEEhHgbffftvGjRtnugCxyy672JVXXmlnnHGGd3XdunWm0uZjxoyxBx54wO8unzJlilWrVs3uuOMOv8tcM3700Uc2evRon7733nvbqFGj7JtvvrGWLVvaLbfc4hcvFBgzbNgwL+OnO9h1Pn3qqaeash2pqWyJskWpdJ/OrU855RQ7++yz/TOVL1H/1HbddVdT2UX1NZ6uu+KfeeYZ//zHH3+0hx9+2MvJlS1b1i644AJfl3+Yi39+++03L3X47LPP+h348QWYZcuW2ZNPPpnwUjaj++67L6U1f/XVV+7x559/euCTAqbat2/vY1Z2qD/++MN/b2jsyiYs9+nTp9uCBQv8glC/fv183FltLKs+a7puWlH5xhIlSngGJq0j1bKF++67r33yySd+DKg/CvhSZrHPPvss0RVNU7mZrFrJkiX9+MgY7JTqOJcuXerH3xtvvGF169a1O++80ypVqpTY3O+//+435eg40nh1jF177bW+Tc0k80mTJtmQIUPsoYce8t9yGpP6rONJ7ZJLLrE999zTevfu7e+z+0dlKZs2beoX7V566SVTQJxuCFKfsjrOdWzreJJBcoDYu+++633Sd0bZ5XTx79BDD/V9rXGo6djQ/p8xY4aX8NE8Kqmp74rWV7FiRZ9PfdHjhx9+MGXg6tatm2eNyGr8OpY15py+N1t7DHnn+AcBBBBAAAEEECiAAt9//70Hdim4a+7cuf56+fLlPtJ99tnHz9l0TqbzN52f7bzzzgVQgSEhgMB2FQh3JtEQQAABBBBAAAEEtpHAr7/+GoWLSFH4w3gU7qqPwoWaKFwo20ZrZzUIIIAAAggggAACCGx/gVmzZkUhM08UAqWiEEwSde7cOQpBTdGXX37pGw9l9KJw04PSHUXhQkV07rnnRieccIK/DxcpohC8FE2bNi0KFy18Wrly5aJQ5i8KgUCRXmu5EAAThUxQUQhK8fchmCWqVatWFIKOohDQ4tsJN1NEIVgoeuqpp6IQ8BKFiyE+b7t27fzzEKgShYsjPu3pp5/2afonBKNFIWApCsFmPk39CYFJ0eDBg6MQ2BSF8ii+TAjwSSyT2QuNsW3btomPwp34USh16Of5GsPGjRsTn4USilEIzPL3IXjIx5n4MIUXIXjO+xSCxDabO5Rvic4666zEtJNPPjnaf//9ow0bNkSffvppFILcovPPPz/x+eTJk309cV+y6rOMjjjiiCgE3kUhsCr6/PPP3V/juvfeexPry+7FgAEDfFtaJgS2Rdof8+bNi2ShadrXIUAqu1X4Z8cdd1x00UUXbTZfTuPUMaJtVK1aNTrxxBP9ONR7+a1du9bX9dNPP0X16tXzz9UvHdchACoKWc78tWYKGbgSY9DxquW1nhAEF9WpU8dfh+xeUQgW26x/Wb0JF/WiPn36+HIXXnhhpGVDcF6Wx3kI8vI+aps9evRIrFZ91e/JECDp+6dhw4a+Tv3O1DEYtxAYGR155JHR+vXro+eff96Pe60rBJxFb775ps92++23R40bN/Yx//vf//bvmMam365Zjf/FF1/073F235vcHkMaT/zdjfvPMwIIIIAAAgggkN8FQunvaNGiRVEoxRjpvEvn1+EmGD9303mZfi/pN0W4ISV6/fXXo5UrV+b3IdN/BBBID4HpSkNNQwABBBBAAAEEENjGAroopotj8QUu/QE+3MntF8u28aZYHQIIIIAAAggggAAC21QgZOfyixPhLnRf76uvvurvQ4atxHbigCkFF8VNwVy6oBGy3vokBXzpfaNGjSJdBFFTwJiCqBQ8FrJheTCM5tEFkZAlyKdpui6YaD6tM7nFQWVxcNfMmTN9Gwp6idvLL78cKVgobq1bt45Cdqb4bTRnzhxfRoFC2bWMwV7xvHGAWRzspUA0jeFf//pXPEt0+umnJ16n+qJZs2a+npDRKbHI4Ycf7v3VBAXnhExYkeaLm35nhCxU8dsoY7BX/EHGPutClPocB/BpPgVmaVoqwV7Dhw/3QLMyZcr4MvqtE7eQEc73r5xTaQpWu+uuuxKzpjJOBXspoC9ktPLlQgav6JhjjvG+9OrVy6eFbMs+T8gel1i3AqA0RgXM6TebmgKhNE037WzatCkKZXX8WbbaRm5b/H2J+6HlFfSlbWQ8zvXZa6+95p8lB3vpIqG+IwqgU9MxreUvv/xyf69/PvjgA5+WbKfjRfOFjGI+nwIetZ6QAS2xnL4bmufxxx/3aVmNP6fvTW6PIYK9EruAFwgggAACCCCQTwVC+fJI5+pPPPFEdPXVV/vvnJA12M+tdLOMbmAJWYijkHk1Cplno1WrVuXTkdJtBBDIBwLTKeMYftnSEEAAAQQQQACBbS2gciUqDaOHyqKEu969pEmXLl2sY8eOFu5cT5S32dbbZn0IIIAAAggggAACCGyNQAjisFatWnk5EZWSCxmxfHUqVRi3uMxIyNgVTzItF7JwealETYznUcm5uDRg7dq1vUShStqpXF7I5uXLhwAUL+Wo0nFq999/v6kEXwjg8ffxPyplqJJ1IfOQhcxJFrJCeWm7EORkKgkZMjN5OUWVnVQLGY+8HGXI5pToVwjoMZUgDBdkfBshqCtefUrPKj2Y3FQuT6VYNH4Z/fOf/7TnnnsueZaUXl9zzTUWsp1ZCMLxci4q9xKC5BIGpUuXtpDNy11VSjMEXNnChQt9DDltIGOfBw0aZNWrVzftj7iphIxavK/i6cnP6k/Xrl297GEIQPJSkypTeOutt9qZZ57p5TRVLjAEJSX6nbx8Zq+1z2UYt1THqRKFIYuYL6bxheAuL/upEqThD/NeQjQE9G22bs2v41JuOv5UMkflR9VCBjU/JkKQl7/XP9lZJGbK4kXysvE2Mh7nWjTjvtE0lU/UcaqykNpH8fcgXDDUx940j5rKecbt6KOP9vKpmk9jVwlUrScEbsWz2C+//OLHf8iA5tPiviWPP5XvTV6PoURHeIEAAggggAACCKSpgEpd6xxr/vz5fs4YP6v8us4zVTo+ZJA1/RYKWVf994jehxsh0nREdAsBBAqiQNGCOCjGhAACCCCAAAIIpJNAyGTgFxq+/vprCyVvLJRo8R+AuogwcOBAC+VF0qm79AUBBBBAAAEEEECgkAvoxoU1a9ZYgwYNPHAqZM1KSUSBVgqg0rLZtTjAS/NpfrWQfWizRUJmL38ffx5/qOAuteQAl1Bm0oOiQok6CxmN7D//+Y+FzEibzReylVnIhOSPkO3ItH6tI7eBXr7SDP8oqEdBblWqVPFArZA1yhQIldt2xhlnWChraaF0nykQR+MJWdI2W02lSpWsf//+FjKc+UWmkD1gs89TeRNKO/pvEAWoJbc4OCl+Tv4sfq2gugcffNBvagnZ3eyyyy7zC11yD9kNLGSwspCpykKWs3iRHJ/llhzspQXyMk797lJTEJTGqICljMdPyC5lCohSi4+heJ6Mx6Dmyc5Cn2fXkpfNbhuZraN58+Y+OT6OQplNf69gx7gpcE2BYiFrhAdwafoXX3xhe++9t4UyjT5byNzmAXjxsa9nrUvH/8033+zzZNa32Car742CDfU7Ni/HkG+UfxBAAAEEEEAAgTQQCJlePZgrlN32GzbOOeccv0FbNwfUrVvXb9oeO3as6feRgrr0WjcN6FxINxiEsvN+k4POLwn0SoMdShcQKGQCBHsVsh3OcBFAAAEEEEDg7xPQHev6Y7n+sK6LIPrB2K1bN78odNJJJ/nFnJUrV/59HWTLCCCAAAIIIIAAAggEgRdeeMEUVKJMSQo4SjWgSAEiyvykYKfsWhy4kt18e+yxh69i1qxZm61K2ajUKleunJh+3nnnmTJ3KeAqlFTxQCQF9ajFF11Cab7E/PGLUC7Qfvjhh/htnp+VOUmZlxRk1qFDB7/4owy/oWRgrtapYCNlJFO/NA7dJKKxxU3bad++vU2aNMnXrW3owlNu24YNG3yRUKbTdIErN23kyJE++z/+8Q9/Vp91jMj72Wef9YxwocSmlS9fPuXVKgtC8rGQ13Huuuuuvk2tq1y5ct6n5cuXe8a35M5kdgwlf578OjlgK3l6Kq+3Ztnu3bt7Ni49K3PaDTfc4L8dQ1nTxKZ1EVKBdaGckCnwToGBCnILZTR97JpRx78uRiroK2PTzUhZtZy+N99++60vmpdjKKttMh0BBBBAAAEEENheAjpH0u8K/V6IM9Iqe6rOp3Queu6553pG1FBW3kI5ds9i+/HHH/t51meffWbPP/+83XnnnX5+Fkqob9UNAdtrjKwXAQQKnwDBXoVvnzNiBBBAAAEEEPibBfRHf/0xfujQoX5xSSVslPpZWb9UaqNFixb2yCOPeFDY39xVNo8AAggggAACCCBQCAX69evnpd/OPvtsH73KvqmpZEl2TTc0qOkCSXZt2rRpnslJF1ayanH2JZVsTG7KTKTWsGHDxGQFplwYSjp+9913fke+gtTipnKNOtfW3frK6BU3BaXp7vylS5fGk/L8rKCZm266ybNRKeBpyJAhHvSmcoa5beq7Arh0U4gyqsUBTFqPSlcq0Eu/F+JgKu2bnPZLxj7oJhQtr4tZycF0KlejJpusmgLa1FSqPm7aV7qpRU2Basn9UeCWyt1k15o2berlN+N58jrOOLhObjKMS4xmdgypVGT8ebzdjM/63ab+xy4ZP8/qfRzkldtAuuT1ad8oc5YsVN5T3vpexuuO55WtAu8UYKcyoirzmTyu+HWPHj022y/KRHHLLbfEq9niOafvjUzyegxtsTEmIIAAAggggAAC20BAN1GrBL3KqauseseOHb00um4K0Y0iyop67bXX+vm0zgV1U4VuZJg3b55nSdWNK8qqes899/iyhx56aKbltrdBV1kFAgggsE0ECPbaJoysBAEEEEAAAQQQyJuALjzpziH9EV/lRoYPH2677bab/6Fed6TroSAw3bGtMiQ0BBBAAAEEEEAAAQS2t0CcFUvBI8rypbvf1d57770tyhMq+5Sago6eeeYZzwJ2ySWX+LT4HwXhKPuQmoKulE1LZf4UkKNzYLWMAUEKGFMpO03XuXLcFOxUsWJFD4aKp+lZ2Y8UCKNAn+SSgNqGzqcVtNO4cWPr2bOnPfDAA36xRyXoVKoyt02ZktSSA8VGjx5t33//vU+Pg93isoI+McV/VL6wXbt2PnfGEo5x4JfKPMpdWZ/mzp1rytSlbE7z58/3MpZaWNkLklvGPiuYTE37aloIvtOycelFBampNGBmTRnM1HRzypNPPunlJl9//XW/UKYMcAoUa9WqlWeFU+YElaacOnVqZqvyaTpulFVBN8PELZVxal4tu2zZMl/s999/9/7oIp6C+NS0n3VMqK/6XG3JkiVe6vC2227z7F+altUxWK1aNQ+QUvCexqKsDqk0Laem33AKTlQ/stqG5su4bzSta9eufuFRwXUK9NL3ZuLEiR4Aps/VFGSoY0TLK9BS+0HHYRwQqXkuv/xyK1u2rJccUjbpwYMHe7lNZaBTOU61zPqWyvcmr8eQb5R/EEAAAQQQQACBXAropgJlCNbvAZ3TqCR1mzZtPNBd54/KDKxzVWW/HTFihJeWVwn4vn37+vmozhv1m0QZu3Q+fdddd3nWXN2AotLYNAQQQCDfCYQ7rWgIIIAAAggggAACaSYQLthE4aJLFO62jg455BClUIhCiZToiCOOiEIJj2js2LFRuEiWZr2mOwgggAACCCCAAAIFQeCVV16Jwt3vUYkSJaKQRSoKpdqivffeOwp3wEe9e/f2IYaAJj9H1bnqUUcdFYVsUVEItIlCwFOCIJRO9Hlq1KgR1apVKzr22GOjChUqRIMGDfJ5QsBSFAKEEue6bdu2jUKQUmL51atXR+ecc45vN1y0icJNElEohR6FoJvEPMkvQjBLFO7GT57kr3VuHYKaoqJFi/q2QgBQFIJgonDBaIt5kyeUKlUqUp/iFgKFonBBKdLyOj8PF5OiEFgTLVy4MAoZA6IQPBaFLExRKIEZ3XjjjVEIfIoXzdVzyLoUHX744VssEwLWIrlrHKEUYdSnT5/o4Ycf9vfaDyGDge8H9U39CcFgUVZ9DpmZonCBLApBPT6WEGQWhewGUQgMii666KIoZMPaYvuaEAKDfD+Em1Z8OW0rXCCLwgUznz9cTItCxif/TP28/vrrM11PPFG/acLFtShkOI42btzok3Ma5zfffOPbO+igg6IQ+Bc1a9bMj6MQ8LfFPtUxFi78RSHDle+TUHYnCgF/kbahh44vHecaR7jRJgoBbHHXopClzfe19neXLl1S3p8ho1fiN1wIPIxCsFmWx/mjjz7q3w1tP1ykjEIAlW8/XMBM+Oqz+KH9On36dJ9n7dq1iWXjz+PnkO0rMQ4dTyEALbGOvfbaKwoBmDmOP6fvTW6PoRBEGoVAxkS/eIEAAggggAACCMQCOg8MN1JEc+bMicLNJlEISvdzN53T6O/hOueLz3P0rHOi+vXr+7mF/n7++OOPR+FmhSjcKBLpHIWGAAIIFAKB6UU0yPCfIg0BBBBAAAEEEEAgjQWUJUDlR2bOnOkP3Xmvu+aVtSBcCLLw49af9VplWWgIIIAAAggggAACCGyNQLjgYnqoRKKayrbpvUqeqLVs2dImTJjgpRN1l72y04ZALv8s/kcZhpQ5S1m3dEe9zmlDsI2FIKB4lpSeVc7uk08+8XNfZePKqq1atcqzNSmbU2ZNd/IvWrTIVKJO2Y5yahqrxqmsStk1nZfLJwQP2bfffmshsC3XY8y4fpWhUQazzJoyOcXZr/R5xveZLZPVNGUFW758uclV+1F28T7PahlNV6YslcUMAVe+75PnlYUyUqn/IbAo+aNMX2usyiSVPCbNmHFcGd9rHmU/1vIhGHGLEof6XE37RVkgNG8IirOdd975/z9I4V+tW8drXDYzhUV8Fh0TyiKm8ef2eNcKQrCgZ5hQeVJl3tK+0fGrLGPKWjF06FAfk7JEDxs2zFQyUuNT+Udl/FLWLZV0jL8vugSwePFiN9LxmdV3JLPx5fS9SfUYCkF11rp1a3v++ecz2wzTEEAAAQQQQKAACugcRll99dBvgeTXOm+OH8pKq/MnNZ2nqOyizqP0t289Z3zotwcNAQQQKOQCMwj2KuRHAMNHAAEEEEAAgfwpEO7itnCnk5dtUekWXWiJS9/owpXKP6ocSvzQD+Jw97+ppAhpqfPnPqfXCCCAAAIIIIBAOgnEwV66YKPSg5m15GCvxx57LLNZ0nqagr1U+mXKlCl56qcuWqmsZE5NJfsUtENLX4EduS9D5jsvtaggr4wBfyqJqnKNd999twcVqmSoyhglNwV2qWRjyAa9RQBd8nw78rWC0RREqFJLBHvtSHm2hQACCCCAwLYRUED5mjVrvIS3/i4dv9ZNGXooQD75Wa91LqNg9OQWMnJ5IFeVKlX879T6e7VuXNZz/AgZX01B4jQEEEAAgWwFZhTP9mM+RAABBBBAAAEEEEhLAd29FMrD+CPuoH5o6w76L774whYsWOCP0aNHexCYsjDETRcMFPSlO8L1Azv5oUAx/ZjWQ3fXx6/jZXlGAAEEEEAAAQQQQEACOt9Ue+aZZxLZg3xC0j8ff/yxvwvlHHPMjpW0WNq8DGUcbfbs2RZKTXomsMsuu8wzh6XaQZ2DN27cOMfZlZEsp+xhOa6EGbarwI7cl++8846PRYFcyoyn320KqgzlQm3FihUWSmN6wJQuno4cOdIvoirrhTKIKXOdskCHkqk2efLk7WqSysoV8BnKTnomD910pKA5jvVU5JgHAQQQQACB3Aso4FsZTZUhS4/k18rEqYcCsDM+lLFVmTx/+eWXLR4639DfnJP/thz3TOce+ruy/tasDL96VhDXwQcf7O91DqMMXXpoum4Q4SbkWI9nBBBAYOsFyOy19YasAQEEEEAAAQQQSGsB/bDXxYE4LXb8rDuu4ruw9KyHftjrh79+wCc/0nqAdA4BBBBAAAEEEEAAAQQQQAABBBBAAAEEECjEAip/qACsYsWK+bNex+91Q68CreKHbvKNXyubrcpcZ/bQjcG66VgPBXYlv9ZnuSkNXYh3DUNHAAEEtocAZRy3hyrrRAABBBBAAAEEEEAAAQQQQAABBBBAoKAK6CaB5KYMWHokN2UI0CO56QIRDQEEUhfQd0gXYrO7kKosHppPF2ppCCCAAAIIIIAAAggggAAChUKAYK9CsZsZJAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCOR3gRlF8/sI6D8CCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAgggUBgECPYqDHuZMSKAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggEC+FyDYK9/vQgaAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAAChUGAYK/CsJcZIwIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCOR7AYK98v0uZAAIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCBQGASKF4ZBMkYEEEAAAQQQQAABBBBAAAEEEEAAgdwL/PnnnzZgwACbOHGirV+/3urXr29NmjSx4cOH2yuvvJL7Fab5EoVtvGm+O+geAggggAACCCCAAAIIIIAAAggggEAmAkWi0DKZziQEEEAAAQQQQAABBBBAAAEEEEAAgUIu0KFDBxs1apT17t3bDj/8cHvppZds5MiRHvi1cuVKq1ChwjYV0p+pihQpsk3XmZuV5Wa8eelrXpbJTf+ZFwEEEEAAAQQQQAABBBBAAAEEEECgwAvMINirwO9jBogAAggggAACCCCAAAIIIIAAAgjkXmDBggVWp04da968uU2ZMiWxglmzZlmzZs3sgw8+sHr16iWmb+2LqVOn2owZM6xXr15bu6o8LZ+b8ealr3/99VfCslixYnnqIwshgAACCCCAAAIIIIAAAggggAACCBR6gRlFCz0BAAgggAACCCCAAAIIIIAAAggggAACWwgsWrTIpy1ZssQUqBS34447ztq0aWPffvttPGmrn7UNZdXatGnTVq8rrytIdbx57Wv37t3trbfeMpLs53UPsRwCCCCAAAIIIIAAAggggAACCCCAgATI7MVxgAACCCCAAAIIIIAAAggggAACCCCwhcDPP/9s1apV85KNp5xyipdvLFeunM+3ePFiK1OmjFWtWtXuueceW7p0qU8vXry43XrrrVa9enUbOHCgffLJJ1aqVCl78MEH/fMXX3zRxowZY2vWrLFatWpZq1atbL/99rOmTZvasmXLrG7dunbUUUfZVVddZQ0aNPBlVDpSjx9++MHq169v3bp1s912282Dpt5++20bNmyY3Xzzzfbuu+/aK6+8YpUqVbLrrrvO9tlnHxs3bpw/1K/rr7/el/eVZvJPKuP99ddfs+zr6tWrfWzTp083ZQnTOPr162e77LKLKdBLTmqdOnWyPffc00tj6v2PP/5oDz/8sH388cdWtmxZu+CCC0zeNAQQQAABBBBAAAEEEEAAAQQQQAABBDIRoIxjJihMQgABBBBAAAEEEEAAAQQQQAABBBAIAgrcUsCSmgK7HnroIWvfvr2/j/9ZuXKlHXLIIfbdd9/ZhAkT7LTTTvOPNmzYYDvvvLNns1I2sDlz5ljLli09EErT9fr000/3jF5PPfWUB0RdeOGFHux04IEHWuXKle2OO+6wmTNnemDU559/bldffbUHiX300Uc2YMAAD6Bau3atHXbYYR7cpeC0QYMGeZCa+qRyiRs3brRJkyb5+lasWGFFi2ad6D6n8SrgLKu+KkDrq6++sk8//dQWLlxoxx57rJ155pkejKZANAVxffnll+5RunRpO/roo+3rr7+2Fi1aeLCaSmL26NHDpk2bZkOGDLGLL744JuYZAQQQQAABBBBAAAEEEEAAAQQQQACBWIAyjrEEzwgggAACCCCAAAIIIIAAAggggAACmwv07dvX7r//flNwkoK5zj77bGvbtq0pw1XcKlas6EFZev/yyy/Hkz1o6fDDDzcFeqkpA5cCrRSApWxfPXv2NAWEKahLgVlqysbVpEkTn6ZMV8qGNXz4cGvUqJFdeumlduKJJ3rAlKbdcsstdskll/hyCqRS1rBHH33Ug8eWL1/u2bHGjx9vEydO9EArBWppenYtp/Fm1dfffvvNx1uzZk0rUaKEHXTQQVa7dm0PcNP2FNilrF1FihTx8em92k033eTvr7jiCmvYsGEi+9ftt9/un/MPAggggAACCCCAAAIIIIAAAggggAACGQWyvpUx45y8RwABBBBAAAEEEEAAAQQQQAABBBAodAJdunSx+fPnW/PmzX3sY8eO9QAulS2MmzJy7bHHHh7QpbKEaiNGjLCLLroonsWOOeYYUxYwBYApCEsBXJ07d058rhcKhoqblt+0aZO1bt3ajjzySH8sWbLE9t13X1M2LzWVc1RTVqy41alTx1/GAWR6c8ABB/g0LZ9TS2W8WkdyXxUMp4xe6vO6deu8hKWye6k0ZXJLXmb9+vVeYlKe8fhUvlLjU+nH33//PXlRXiOAAAIIIIAAAggggAACCCCAAAIIIOACBHtxICCAAAIIIIAAAggggAACCCCAAAIIZCugAKQpU6bYI4884tm5VEZx1KhRiWUU7HTdddd5gNLAgQM985cyap177rmJeZQVTEFh33zzjZc3VNlDZcRKbsnBUCp5uOuuu9oHH3yQeKiU46JFi7zsYfJyya+VNSxjU7YtNZV0TKXlNF6tI7mvel+pUiXr37+/nXDCCR6sFQeY6bO4JS+zYMECn6xSlfEY5arx6bPMxhGvh2cEEEAAAQQQQAABBBBAAAEEEEAAgcIrQLBX4d33jBwBBBBAAAEEEEAAAQQQQAABBBDIUuCkk07aouzhNddcYyeffLIv8+qrr2627NVXX20777yzPfbYY/bcc895JrDdd989Mc+ff/5pTz/9tAeJVa9e3V5//XVr165d4nO9SA6GKlOmjGfJUtBXxvb1119nnLTV73M73uS+KgNZ+/btbdKkSfbmm2962ciddtppiz4lL6Pxqb3//vtbzKcymSo7SUMAAQQQQAABBBBAAAEEEEAAAQQQQCCjAMFeGUV4jwACCCCAAAIIIIAAAggggAACCCBg5cuXt9tvv30LiQYNGvi05EAuTdD8l156qamMo8oRKotXclPJxu+//96U4WvevHl22GGH2fTp023VqlWJIK8//vgjsYg+V+vRo4dFUZSY/vbbb9stt9ySeJ/xRfK8GT/L7n2q440DtpL7+uKLL3qgV4sWLdxB2/nll18267eWU1CYgt7U4nKNY8aMMWX0ittff/1lnTp1sqVLl8aTeEYAAQQQQAABBBBAAAEEEEAAAQQQQCAhQLBXgoIXCCCAAAIIIIAAAggggAACCCCAAAKxwH777WfDhg0zlRlUAJLa6tWrbcSIEV7K8bLLLotnTTx36dLFihcvbpUrVzYFPiU3BTo9+uijPkmBVUcffbTVrVvXFDRWrVo1n/7aa695ScMHHnjALr/8citbtqyNHTvWlHVr8ODBpuxhHTp0sAcffNDn/+677/x57dq1/qx/fvrpJ3+9bNmyxLSVK1f6a/U/q5bqeDPrq8pNqqm05fjx46179+42d+5c27Bhg40bN87mz5/vY1Qg2pAhQ+ypp57yco0qfSmXxo0bW8+ePU3jPv74422fffaxOKguq/4yHQEEEEAAAQQQQAABBBBAAAEEEECgcAoUCX9k+t+tkYXTgFEjgAACCCCAAAIIIIAAAggggAACCGQQeOaZZ6xfv35WsmRJU1DV/vvv74FYFSpUsAEDBlibNm0yLPH/bxWYpUCl3r17b/b5eeedZyr92KxZMytXrpyvU5nDGjZs6EFRWkYZv2rWrGkTJkywgw8+2ObMmWNt27a1FStW+Lr22msvLwXZtGlTD/jq1auXKdCrXr161rdvX19ez5pWo0YN69+/v2ca03wK+Kpdu7aP6ayzztqsb3qT6ngVwJWxrwcddJC1atXKJk6caFWrVjVlMVNJyxtvvNHHoQCw2bNnW8eOHX27mn7fffd5li9lQVN5SwXUKfuXgugeeughK1269BZ9ZAICCCCAAAIIIIAAAggggAACCCCAQKEXmEGwV6E/BgBAAAEEEEAAAQQQQAABBBBAAAEEthRYs2aNbdy40fbYYw/7+eef7fPPP/cgLWWdKlas2JYLhCkKhFLmq3feeceUKSu5/f7771aqVCkP3Nppp52sYsWKyR97sNOSJUtMAV1Fi/4vGb3uU1y8eLEHQtWqVStR8nGzhbfBm9yMV4FZmfV13bp1Fmf5UpcyvlfAmcamzGbJTb6LFi3y0o7KZkZDAAEEEEAAAQQQQAABBBBAAAEEEEAgCwGCvbKAYTICCCCAAAIIIIAAAggggAACCCCAQIoCCn5SENOgQYM8K5cyeNEQQAABBBBAAAEEEEAAAQQQQAABBBBAYJsLzCi+zVfJChFAAAEEEEAAAQQQQAABBBBAAAEECo3A4MGD7frrr7c6dep4dqoZM2YUmrEzUAQQQAABBBBAAAEEEEAAAQQQQAABBHa0wP9y4u/oLbM9BBBAAAEEEEAAAQQQQAABBBBAAIF8L1C9enUv66hSi/3797cjjzwy34+JASCAAAIIIIAAAggggAACCCCAAAIIIJCuAkWi0NK1c/QLAQQQQAABBBBAAAEEEEAAAQQQQCD9Bf744w8P+CpenCTy6b+36CECCCCAAAIIIIAAAggggAACCCCAQD4WoIxjPt55dB0BBBBAAAEEEEAAAQQQQAABBBBIC4GSJUumRT/oBAIIIIAAAggggAACCCCAAAIIIIAAAgVdgDKOBX0PMz4EEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBAoEAIEexWI3cggEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAoKALEOxV0Pcw40MAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAIECIUCwV4HYjQwCAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEECroAwV4FfQ8zPgQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEECgQAgR7FYjdyCAQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEECgoAsQ7FXQ9zDjQwABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAgQIhQLBXgdiNDAIBBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQKusD/AXWDrYZpRf6bAAAAAElFTkSuQmCC\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from transitions.extensions.states import Timeout, Tags, add_state_features\n", "\n", "@add_state_features(Timeout, Tags)\n", "class CustomMachine(GraphMachine):\n", " pass\n", "\n", "\n", "states = ['new', 'approved', 'ready', 'finished', 'provisioned',\n", " {'name': 'failed', 'on_enter': 'notify', 'on_exit': 'reset',\n", " 'tags': ['error', 'urgent'], 'timeout': 10, 'on_timeout': 'shutdown'},\n", " 'in_iv', 'initializing', 'booting', 'os_ready', {'name': 'testing', 'on_exit': 'create_report'},\n", " 'provisioning']\n", "\n", "transitions = [{'trigger': 'approve', 'source': ['new', 'testing'], 'dest':'approved',\n", " 'conditions': 'is_valid', 'unless': 'abort_triggered'},\n", " ['fail', '*', 'failed'],\n", " ['add_to_iv', ['approved', 'failed'], 'in_iv'],\n", " ['create', ['failed','in_iv'], 'initializing'],\n", " ['init', 'in_iv', 'initializing'],\n", " ['finish', 'approved', 'finished'],\n", " ['boot', ['booting', 'initializing'], 'booting'],\n", " ['ready', ['booting', 'initializing'], 'os_ready'],\n", " ['run_checks', ['failed', 'os_ready'], 'testing'],\n", " ['provision', ['os_ready', 'failed'], 'provisioning'],\n", " ['provisioning_done', 'provisioning', 'os_ready']]\n", "\n", "class Model():\n", " def is_valid(self):\n", " return True\n", " \n", " def abort_triggered(self):\n", " return False\n", " \n", " # graph object is created by the machine\n", " def show_graph(self, **kwargs):\n", " stream = io.BytesIO()\n", " self.get_graph(**kwargs).draw(stream, prog='dot', format='png')\n", " display(Image(stream.getvalue()))\n", "\n", "extra_args['title'] = \"System State\"\n", "extra_args['initial'] = \"new\"\n", "model = Model()\n", "machine = CustomMachine(model=model, states=states, transitions=transitions, **extra_args)\n", "model.approve()\n", "model.show_graph()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Custom styling" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# thanks to @dan-bar-dov (https://github.com/pytransitions/transitions/issues/367)\n", "model = Model()\n", "\n", "transient_states = ['T1', 'T2', 'T3']\n", "target_states = ['G1', 'G2']\n", "fail_states = ['F1', 'F2']\n", "transitions = [['eventA', 'INITIAL', 'T1'], ['eventB', 'INITIAL', 'T2'], ['eventC', 'INITIAL', 'T3'],\n", " ['success', ['T1', 'T2'], 'G1'], ['defered', 'T3', 'G2'], ['fallback', ['T1', 'T2'], 'T3'],\n", " ['error', ['T1', 'T2'], 'F1'], ['error', 'T3', 'F2']]\n", "\n", "machine = GraphMachine(model, states=transient_states + target_states + fail_states,\n", " transitions=transitions, initial='INITIAL', show_conditions=True,\n", " show_state_attributes=True)\n", "\n", "machine.machine_attributes['ratio'] = '0.471'\n", "machine.style_attributes['node']['fail'] = {'fillcolor': 'brown1'}\n", "machine.style_attributes['node']['transient'] = {'fillcolor': 'gold'}\n", "machine.style_attributes['node']['target'] = {'fillcolor': 'chartreuse'}\n", "model.eventC()\n", "\n", "# customize node styling\n", "for s in transient_states:\n", " machine.model_graphs[model].set_node_style(s, 'transient')\n", "for s in target_states:\n", " machine.model_graphs[model].set_node_style(s, 'target')\n", "for s in fail_states:\n", " machine.model_graphs[model].set_node_style(s, 'fail')\n", "\n", "# draw the whole graph ...\n", "model.show_graph()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.4" } }, "nbformat": 4, "nbformat_minor": 1 } transitions-0.7.2/requirements.txt0000644000076500000240000000000413572430257020306 0ustar alneumanstaff00000000000000six transitions-0.7.2/requirements_diagrams.txt0000644000076500000240000000001313525242464022154 0ustar alneumanstaff00000000000000pygraphviz transitions-0.7.2/requirements_test.txt0000644000076500000240000000006113530753142021343 0ustar alneumanstaff00000000000000pytest pytest-cov mock dill graphviz pycodestyle transitions-0.7.2/setup.cfg0000644000076500000240000000023013606034310016630 0ustar alneumanstaff00000000000000[metadata] description-file = README.md [check-manifest] ignore = .travis.yml .scrutinizer.yml appveyor.yml [egg_info] tag_build = tag_date = 0 transitions-0.7.2/setup.py0000644000076500000240000000422513574750016016545 0ustar alneumanstaff00000000000000import codecs import sys from setuptools import setup, find_packages with open('transitions/version.py') as f: exec(f.read()) with codecs.open('README.md', 'r', 'utf-8') as f: import re # cut the badges from the description and also the TOC which is currently not working on PyPi regex = r"([\s\S]*)## Quickstart" readme = f.read() long_description = re.sub(regex, "## Quickstart", readme, 1) assert long_description[:13] == '## Quickstart' # Description should start with a headline (## Quickstart) if len(set(('test', 'easy_install')).intersection(sys.argv)) > 0: import setuptools tests_require = ['dill', 'graphviz', 'pygraphviz'] extras_require = {'diagrams': ['pygraphviz']} extra_setuptools_args = {} if 'setuptools' in sys.modules: extras_require['test'] = ['pytest'] tests_require.append('pytest') setup( name="transitions", version=__version__, description="A lightweight, object-oriented Python state machine implementation.", long_description=long_description, long_description_content_type="text/markdown", author='Tal Yarkoni', author_email='tyarkoni@gmail.com', maintainer='Alexander Neumann', maintainer_email='aleneum@gmail.com', url='http://github.com/pytransitions/transitions', packages=find_packages(exclude=['tests', 'test_*']), package_data={'transitions': ['data/*'], 'transitions.tests': ['data/*'] }, include_package_data=True, install_requires=['six'], extras_require=extras_require, tests_require=tests_require, license='MIT', download_url='https://github.com/pytransitions/transitions/archive/%s.tar.gz' % __version__, classifiers=[ 'License :: OSI Approved :: MIT License', 'Programming Language :: Python :: 2', 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 3.3', 'Programming Language :: Python :: 3.4', 'Programming Language :: Python :: 3.5', 'Programming Language :: Python :: 3.6', 'Programming Language :: Python :: 3.7', ], **extra_setuptools_args ) transitions-0.7.2/tests/0000755000076500000240000000000013606034310016156 5ustar alneumanstaff00000000000000transitions-0.7.2/tests/__init__.py0000644000076500000240000000000012647164525020275 0ustar alneumanstaff00000000000000transitions-0.7.2/tests/test_add_remove.py0000644000076500000240000000520113530722244021700 0ustar alneumanstaff00000000000000try: from builtins import object except ImportError: pass from transitions import Machine from unittest import TestCase import gc import weakref import threading class Dummy(object): pass class TestTransitionsAddRemove(TestCase): def test_garbage_collection(self): states = ['A', 'B', 'C', 'D', 'E', 'F'] machine = Machine(model=[], states=states, initial='A', name='Test Machine') machine.add_transition('advance', 'A', 'B') machine.add_transition('advance', 'B', 'C') machine.add_transition('advance', 'C', 'D') s1 = Dummy() s2 = Dummy() s2_collected = threading.Event() s2_proxy = weakref.proxy(s2, lambda _: s2_collected.set()) machine.add_model([s1, s2]) self.assertTrue(s1.is_A()) self.assertTrue(s2.is_A()) s1.advance() self.assertTrue(s1.is_B()) self.assertTrue(s2.is_A()) self.assertFalse(s2_collected.is_set()) machine.remove_model(s2) del s2 gc.collect() self.assertTrue(s2_collected.is_set()) s3 = Dummy() machine.add_model(s3) s3.advance() s3.advance() self.assertTrue(s3.is_C()) def test_add_model_initial_state(self): states = ['A', 'B', 'C', 'D', 'E', 'F'] machine = Machine(model=[], states=states, initial='A', name='Test Machine') machine.add_transition('advance', 'A', 'B') machine.add_transition('advance', 'B', 'C') machine.add_transition('advance', 'C', 'D') s1 = Dummy() s2 = Dummy() s3 = Dummy() machine.add_model(s1) machine.add_model(s2, initial='B') machine.add_model(s3, initial='C') s1.advance() s2.advance() s3.advance() self.assertTrue(s1.is_B()) self.assertTrue(s2.is_C()) self.assertTrue(s3.is_D()) def test_add_model_no_initial_state(self): states = ['A', 'B', 'C', 'D', 'E', 'F'] machine = Machine(model=[], states=states, name='Test Machine', initial=None) machine.add_transition('advance', 'A', 'B') machine.add_transition('advance', 'B', 'C') machine.add_transition('advance', 'C', 'D') s1 = Dummy() s2 = Dummy() s3 = Dummy() with self.assertRaises(ValueError): machine.add_model(s1) machine.add_model(s1, initial='A') machine.add_model(s2, initial='B') machine.add_model(s3, initial='C') s1.advance() s2.advance() s3.advance() self.assertTrue(s1.is_B()) self.assertTrue(s2.is_C()) self.assertTrue(s3.is_D()) transitions-0.7.2/tests/test_codestyle.py0000644000076500000240000000071413606025607021575 0ustar alneumanstaff00000000000000import unittest import pycodestyle class TestCodeFormat(unittest.TestCase): def test_conformance(self): """Test that we conform to PEP-8.""" style = pycodestyle.StyleGuide(quiet=False, ignore=['E501', 'W605']) style.input_dir('transitions') # style.input_dir('tests') result = style.check_files() self.assertEqual(result.total_errors, 0, "Found code style errors (and warnings).") transitions-0.7.2/tests/test_core.py0000644000076500000240000011401413606025620020524 0ustar alneumanstaff00000000000000try: from builtins import object except ImportError: pass import sys from .utils import InheritedStuff from .utils import Stuff from functools import partial from transitions import Machine, MachineError, State, EventData from transitions.core import listify, _prep_ordered_arg from unittest import TestCase, skipIf try: from unittest.mock import MagicMock except ImportError: from mock import MagicMock def on_exit_A(event): event.model.exit_A_called = True def on_exit_B(event): event.model.exit_B_called = True class TestTransitions(TestCase): def setUp(self): self.stuff = Stuff() def tearDown(self): pass def test_init_machine_with_hella_arguments(self): states = [ State('State1'), 'State2', { 'name': 'State3', 'on_enter': 'hello_world' } ] transitions = [ {'trigger': 'advance', 'source': 'State2', 'dest': 'State3' } ] s = Stuff() m = Machine(model=s, states=states, transitions=transitions, initial='State2') s.advance() self.assertEqual(s.message, 'Hello World!') def test_listify(self): self.assertEqual(listify(4), [4]) self.assertEqual(listify(None), []) self.assertEqual(listify((4, 5)), (4, 5)) self.assertEqual(listify([1, 3]), [1, 3]) def test_property_initial(self): states = ['A', 'B', 'C', 'D'] # Define with list of dictionaries transitions = [ {'trigger': 'walk', 'source': 'A', 'dest': 'B'}, {'trigger': 'run', 'source': 'B', 'dest': 'C'}, {'trigger': 'sprint', 'source': 'C', 'dest': 'D'} ] m = Machine(states=states, transitions=transitions, initial='A') self.assertEqual(m.initial, 'A') m = Machine(states=states, transitions=transitions, initial='C') self.assertEqual(m.initial, 'C') m = Machine(states=states, transitions=transitions) self.assertEqual(m.initial, 'initial') def test_transition_definitions(self): states = ['A', 'B', 'C', 'D'] # Define with list of dictionaries transitions = [ {'trigger': 'walk', 'source': 'A', 'dest': 'B'}, {'trigger': 'run', 'source': 'B', 'dest': 'C'}, {'trigger': 'sprint', 'source': 'C', 'dest': 'D'} ] m = Machine(states=states, transitions=transitions, initial='A') m.walk() self.assertEqual(m.state, 'B') # Define with list of lists transitions = [ ['walk', 'A', 'B'], ['run', 'B', 'C'], ['sprint', 'C', 'D'] ] m = Machine(states=states, transitions=transitions, initial='A') m.to_C() m.sprint() self.assertEqual(m.state, 'D') def test_transitioning(self): s = self.stuff s.machine.add_transition('advance', 'A', 'B') s.machine.add_transition('advance', 'B', 'C') s.machine.add_transition('advance', 'C', 'D') s.advance() self.assertEqual(s.state, 'B') self.assertFalse(s.is_A()) self.assertTrue(s.is_B()) s.advance() self.assertEqual(s.state, 'C') def test_pass_state_instances_instead_of_names(self): state_A = State('A') state_B = State('B') states = [state_A, state_B] m = Machine(states=states, initial=state_A) assert m.state == 'A' m.add_transition('advance', state_A, state_B) m.advance() assert m.state == 'B' state_B2 = State('B', on_enter='this_passes') with self.assertRaises(ValueError): m.add_transition('advance2', state_A, state_B2) m2 = Machine(states=states, initial=state_A.name) assert m.initial == m2.initial with self.assertRaises(ValueError): Machine(states=states, initial=State('A')) def test_conditions(self): s = self.stuff s.machine.add_transition('advance', 'A', 'B', conditions='this_passes') s.machine.add_transition('advance', 'B', 'C', unless=['this_fails']) s.machine.add_transition('advance', 'C', 'D', unless=['this_fails', 'this_passes']) s.advance() self.assertEqual(s.state, 'B') s.advance() self.assertEqual(s.state, 'C') s.advance() self.assertEqual(s.state, 'C') def test_conditions_with_partial(self): def check(result): return result s = self.stuff s.machine.add_transition('advance', 'A', 'B', conditions=partial(check, True)) s.machine.add_transition('advance', 'B', 'C', unless=[partial(check, False)]) s.machine.add_transition('advance', 'C', 'D', unless=[partial(check, False), partial(check, True)]) s.advance() self.assertEqual(s.state, 'B') s.advance() self.assertEqual(s.state, 'C') s.advance() self.assertEqual(s.state, 'C') def test_multiple_add_transitions_from_state(self): s = self.stuff s.machine.add_transition( 'advance', 'A', 'B', conditions=['this_fails']) s.machine.add_transition('advance', 'A', 'C') s.advance() self.assertEqual(s.state, 'C') def test_use_machine_as_model(self): states = ['A', 'B', 'C', 'D'] m = Machine(states=states, initial='A') m.add_transition('move', 'A', 'B') m.add_transition('move_to_C', 'B', 'C') m.move() self.assertEqual(m.state, 'B') def test_state_change_listeners(self): s = self.stuff s.machine.add_transition('advance', 'A', 'B') s.machine.add_transition('reverse', 'B', 'A') s.machine.on_enter_B('hello_world') s.machine.on_exit_B('goodbye') s.advance() self.assertEqual(s.state, 'B') self.assertEqual(s.message, 'Hello World!') s.reverse() self.assertEqual(s.state, 'A') self.assertTrue(s.message.startswith('So long')) def test_before_after_callback_addition(self): m = Machine(Stuff(), states=['A', 'B', 'C'], initial='A') m.add_transition('move', 'A', 'B') trans = m.events['move'].transitions['A'][0] trans.add_callback('after', 'increase_level') m.model.move() self.assertEqual(m.model.level, 2) def test_before_after_transition_listeners(self): m = Machine(Stuff(), states=['A', 'B', 'C'], initial='A') m.add_transition('move', 'A', 'B') m.add_transition('move', 'B', 'C') m.before_move('increase_level') m.model.move() self.assertEqual(m.model.level, 2) m.model.move() self.assertEqual(m.model.level, 3) def test_prepare(self): m = Machine(Stuff(), states=['A', 'B', 'C'], initial='A') m.add_transition('move', 'A', 'B', prepare='increase_level') m.add_transition('move', 'B', 'C', prepare='increase_level') m.add_transition('move', 'C', 'A', prepare='increase_level', conditions='this_fails') m.add_transition('dont_move', 'A', 'C', prepare='increase_level') m.prepare_move('increase_level') m.model.move() self.assertEqual(m.model.state, 'B') self.assertEqual(m.model.level, 3) m.model.move() self.assertEqual(m.model.state, 'C') self.assertEqual(m.model.level, 5) # State does not advance, but increase_level still runs m.model.move() self.assertEqual(m.model.state, 'C') self.assertEqual(m.model.level, 7) # An invalid transition shouldn't execute the callback try: m.model.dont_move() except MachineError as e: self.assertTrue("Can't trigger event" in str(e)) self.assertEqual(m.model.state, 'C') self.assertEqual(m.model.level, 7) def test_state_model_change_listeners(self): s = self.stuff s.machine.add_transition('go_e', 'A', 'E') s.machine.add_transition('go_f', 'E', 'F') s.machine.on_enter_F('hello_F') s.go_e() self.assertEqual(s.state, 'E') self.assertEqual(s.message, 'I am E!') s.go_f() self.assertEqual(s.state, 'F') self.assertEqual(s.exit_message, 'E go home...') assert 'I am F!' in s.message assert 'Hello F!' in s.message def test_inheritance(self): states = ['A', 'B', 'C', 'D', 'E'] s = InheritedStuff(states=states, initial='A') s.add_transition('advance', 'A', 'B', conditions='this_passes') s.add_transition('advance', 'B', 'C') s.add_transition('advance', 'C', 'D') s.advance() self.assertEqual(s.state, 'B') self.assertFalse(s.is_A()) self.assertTrue(s.is_B()) s.advance() self.assertEqual(s.state, 'C') class NewMachine(Machine): def __init__(self, *args, **kwargs): super(NewMachine, self).__init__(*args, **kwargs) n = NewMachine(states=states, transitions=[['advance', 'A', 'B']], initial='A') self.assertTrue(n.is_A()) n.advance() self.assertTrue(n.is_B()) with self.assertRaises(ValueError): NewMachine(state=['A', 'B']) def test_send_event_data_callbacks(self): states = ['A', 'B', 'C', 'D', 'E'] s = Stuff() # First pass positional and keyword args directly to the callback m = Machine(model=s, states=states, initial='A', send_event=False, auto_transitions=True) m.add_transition( trigger='advance', source='A', dest='B', before='set_message') s.advance(message='Hallo. My name is Inigo Montoya.') self.assertTrue(s.message.startswith('Hallo.')) s.to_A() s.advance('Test as positional argument') self.assertTrue(s.message.startswith('Test as')) # Now wrap arguments in an EventData instance m.send_event = True m.add_transition( trigger='advance', source='B', dest='C', before='extract_message') s.advance(message='You killed my father. Prepare to die.') self.assertTrue(s.message.startswith('You')) def test_send_event_data_conditions(self): states = ['A', 'B', 'C', 'D'] s = Stuff() # First pass positional and keyword args directly to the condition m = Machine(model=s, states=states, initial='A', send_event=False) m.add_transition( trigger='advance', source='A', dest='B', conditions='this_fails_by_default') s.advance(boolean=True) self.assertEqual(s.state, 'B') # Now wrap arguments in an EventData instance m.send_event = True m.add_transition( trigger='advance', source='B', dest='C', conditions='extract_boolean') s.advance(boolean=False) self.assertEqual(s.state, 'B') def test_auto_transitions(self): states = ['A', {'name': 'B'}, State(name='C')] m = Machine('self', states, initial='A', auto_transitions=True) m.to_B() self.assertEqual(m.state, 'B') m.to_C() self.assertEqual(m.state, 'C') m.to_A() self.assertEqual(m.state, 'A') # Should fail if auto transitions is off... m = Machine('self', states, initial='A', auto_transitions=False) with self.assertRaises(AttributeError): m.to_C() def test_ordered_transitions(self): states = ['beginning', 'middle', 'end'] m = Machine('self', states) m.add_ordered_transitions() self.assertEqual(m.state, 'initial') m.next_state() self.assertEqual(m.state, 'beginning') m.next_state() m.next_state() self.assertEqual(m.state, 'end') m.next_state() self.assertEqual(m.state, 'initial') # Include initial state in loop m = Machine('self', states) m.add_ordered_transitions(loop_includes_initial=False) m.to_end() m.next_state() self.assertEqual(m.state, 'beginning') # Do not loop transitions m = Machine('self', states) m.add_ordered_transitions(loop=False) m.to_end() with self.assertRaises(MachineError): m.next_state() # Test user-determined sequence and trigger name m = Machine('self', states, initial='beginning') m.add_ordered_transitions(['end', 'beginning'], trigger='advance') m.advance() self.assertEqual(m.state, 'end') m.advance() self.assertEqual(m.state, 'beginning') # Via init argument m = Machine('self', states, initial='beginning', ordered_transitions=True) m.next_state() self.assertEqual(m.state, 'middle') # Alter initial state m = Machine('self', states, initial='middle', ordered_transitions=True) m.next_state() self.assertEqual(m.state, 'end') m.next_state() self.assertEqual(m.state, 'beginning') def test_ordered_transition_error(self): m = Machine(states=['A'], initial='A') with self.assertRaises(ValueError): m.add_ordered_transitions() m.add_state('B') m.add_ordered_transitions() m.add_state('C') with self.assertRaises(ValueError): m.add_ordered_transitions(['C']) def test_ignore_invalid_triggers(self): a_state = State('A') transitions = [['a_to_b', 'A', 'B']] # Exception is triggered by default b_state = State('B') m1 = Machine('self', states=[a_state, b_state], transitions=transitions, initial='B') with self.assertRaises(MachineError): m1.a_to_b() # Set default value on machine level m2 = Machine('self', states=[a_state, b_state], transitions=transitions, initial='B', ignore_invalid_triggers=True) m2.a_to_b() # Exception is suppressed, so this passes b_state = State('B', ignore_invalid_triggers=True) m3 = Machine('self', states=[a_state, b_state], transitions=transitions, initial='B') m3.a_to_b() # Set for some states but not others new_states = ['C', 'D'] m1.add_states(new_states, ignore_invalid_triggers=True) m1.to_D() m1.a_to_b() # passes because exception suppressed for D m1.to_B() with self.assertRaises(MachineError): m1.a_to_b() # State value overrides machine behaviour m3 = Machine('self', states=[a_state, b_state], transitions=transitions, initial='B', ignore_invalid_triggers=False) m3.a_to_b() def test_string_callbacks(self): m = Machine(states=['A', 'B'], before_state_change='before_state_change', after_state_change='after_state_change', send_event=True, initial='A', auto_transitions=True) m.before_state_change = MagicMock() m.after_state_change = MagicMock() m.to_B() self.assertTrue(m.before_state_change[0].called) self.assertTrue(m.after_state_change[0].called) # after_state_change should have been called with EventData event_data = m.after_state_change[0].call_args[0][0] self.assertIsInstance(event_data, EventData) self.assertTrue(event_data.result) def test_function_callbacks(self): before_state_change = MagicMock() after_state_change = MagicMock() m = Machine('self', states=['A', 'B'], before_state_change=before_state_change, after_state_change=after_state_change, send_event=True, initial='A', auto_transitions=True) m.to_B() self.assertTrue(m.before_state_change[0].called) self.assertTrue(m.after_state_change[0].called) def test_state_callbacks(self): class Model: def on_enter_A(self): pass def on_exit_A(self): pass def on_enter_B(self): pass def on_exit_B(self): pass states = [State(name='A', on_enter='on_enter_A', on_exit='on_exit_A'), State(name='B', on_enter='on_enter_B', on_exit='on_exit_B')] machine = Machine(Model(), states=states) state_a = machine.get_state('A') state_b = machine.get_state('B') self.assertEqual(len(state_a.on_enter), 1) self.assertEqual(len(state_a.on_exit), 1) self.assertEqual(len(state_b.on_enter), 1) self.assertEqual(len(state_b.on_exit), 1) def test_state_callable_callbacks(self): class Model: def __init__(self): self.exit_A_called = False self.exit_B_called = False def on_enter_A(self, event): pass def on_enter_B(self, event): pass states = [State(name='A', on_enter='on_enter_A', on_exit='tests.test_core.on_exit_A'), State(name='B', on_enter='on_enter_B', on_exit=on_exit_B), State(name='C', on_enter='tests.test_core.AAAA')] model = Model() machine = Machine(model, states=states, send_event=True, initial='A') state_a = machine.get_state('A') state_b = machine.get_state('B') self.assertEqual(len(state_a.on_enter), 1) self.assertEqual(len(state_a.on_exit), 1) self.assertEqual(len(state_b.on_enter), 1) self.assertEqual(len(state_b.on_exit), 1) model.to_B() self.assertTrue(model.exit_A_called) model.to_A() self.assertTrue(model.exit_B_called) with self.assertRaises(AttributeError): model.to_C() def test_pickle(self): import sys if sys.version_info < (3, 4): import dill as pickle else: import pickle states = ['A', 'B', 'C', 'D'] # Define with list of dictionaries transitions = [ {'trigger': 'walk', 'source': 'A', 'dest': 'B'}, {'trigger': 'run', 'source': 'B', 'dest': 'C'}, {'trigger': 'sprint', 'source': 'C', 'dest': 'D'} ] m = Machine(states=states, transitions=transitions, initial='A') m.walk() dump = pickle.dumps(m) self.assertIsNotNone(dump) m2 = pickle.loads(dump) self.assertEqual(m.state, m2.state) m2.run() def test_pickle_model(self): import sys if sys.version_info < (3, 4): import dill as pickle else: import pickle self.stuff.to_B() dump = pickle.dumps(self.stuff) self.assertIsNotNone(dump) model2 = pickle.loads(dump) self.assertEqual(self.stuff.state, model2.state) model2.to_F() def test_queued(self): states = ['A', 'B', 'C', 'D'] # Define with list of dictionaries def change_state(machine): self.assertEqual(machine.state, 'A') if machine.has_queue: machine.run(machine=machine) self.assertEqual(machine.state, 'A') else: with self.assertRaises(MachineError): machine.run(machine=machine) transitions = [ {'trigger': 'walk', 'source': 'A', 'dest': 'B', 'before': change_state}, {'trigger': 'run', 'source': 'B', 'dest': 'C'}, {'trigger': 'sprint', 'source': 'C', 'dest': 'D'} ] m = Machine(states=states, transitions=transitions, initial='A') m.walk(machine=m) self.assertEqual(m.state, 'B') m = Machine(states=states, transitions=transitions, initial='A', queued=True) m.walk(machine=m) self.assertEqual(m.state, 'C') def test_queued_errors(self): def before_change(machine): if machine.has_queue: machine.to_A(machine) machine._queued = False def after_change(machine): machine.to_C(machine) def failed_transition(machine): raise ValueError('Something was wrong') states = ['A', 'B', 'C'] transitions = [{'trigger': 'do', 'source': '*', 'dest': 'C', 'before': failed_transition}] m = Machine(states=states, transitions=transitions, queued=True, before_state_change=before_change, after_state_change=after_change) with self.assertRaises(MachineError): m.to_B(machine=m) with self.assertRaises(ValueError): m.do(machine=m) def test___getattr___and_identify_callback(self): m = Machine(Stuff(), states=['A', 'B', 'C'], initial='A') m.add_transition('move', 'A', 'B') m.add_transition('move', 'B', 'C') callback = m.__getattr__('before_move') self.assertTrue(callable(callback)) with self.assertRaises(AttributeError): m.__getattr__('before_no_such_transition') with self.assertRaises(AttributeError): m.__getattr__('before_no_such_transition') with self.assertRaises(AttributeError): m.__getattr__('__no_such_method__') with self.assertRaises(AttributeError): m.__getattr__('') type, target = m._identify_callback('on_exit_foobar') self.assertEqual(type, 'on_exit') self.assertEqual(target, 'foobar') type, target = m._identify_callback('on_exitfoobar') self.assertEqual(type, None) self.assertEqual(target, None) type, target = m._identify_callback('notacallback_foobar') self.assertEqual(type, None) self.assertEqual(target, None) type, target = m._identify_callback('totallyinvalid') self.assertEqual(type, None) self.assertEqual(target, None) type, target = m._identify_callback('before__foobar') self.assertEqual(type, 'before') self.assertEqual(target, '_foobar') type, target = m._identify_callback('before__this__user__likes__underscores___') self.assertEqual(type, 'before') self.assertEqual(target, '_this__user__likes__underscores___') type, target = m._identify_callback('before_stuff') self.assertEqual(type, 'before') self.assertEqual(target, 'stuff') type, target = m._identify_callback('before_trailing_underscore_') self.assertEqual(type, 'before') self.assertEqual(target, 'trailing_underscore_') type, target = m._identify_callback('before_') self.assertIs(type, None) self.assertIs(target, None) type, target = m._identify_callback('__') self.assertIs(type, None) self.assertIs(target, None) type, target = m._identify_callback('') self.assertIs(type, None) self.assertIs(target, None) def test_state_and_transition_with_underscore(self): m = Machine(Stuff(), states=['_A_', '_B_', '_C_'], initial='_A_') m.add_transition('_move_', '_A_', '_B_', prepare='increase_level') m.add_transition('_after_', '_B_', '_C_', prepare='increase_level') m.add_transition('_on_exit_', '_C_', '_A_', prepare='increase_level', conditions='this_fails') m.model._move_() self.assertEqual(m.model.state, '_B_') self.assertEqual(m.model.level, 2) m.model._after_() self.assertEqual(m.model.state, '_C_') self.assertEqual(m.model.level, 3) # State does not advance, but increase_level still runs m.model._on_exit_() self.assertEqual(m.model.state, '_C_') self.assertEqual(m.model.level, 4) def test_callback_identification(self): m = Machine(Stuff(), states=['A', 'B', 'C', 'D', 'E', 'F'], initial='A') m.add_transition('transition', 'A', 'B', before='increase_level') m.add_transition('after', 'B', 'C', before='increase_level') m.add_transition('on_exit_A', 'C', 'D', before='increase_level', conditions='this_fails') m.add_transition('check', 'C', 'E', before='increase_level') m.add_transition('prepare', 'E', 'F', before='increase_level') m.add_transition('before', 'F', 'A', before='increase_level') m.before_transition('increase_level') m.before_after('increase_level') m.before_on_exit_A('increase_level') m.after_check('increase_level') m.before_prepare('increase_level') m.before_before('increase_level') m.model.transition() self.assertEqual(m.model.state, 'B') self.assertEqual(m.model.level, 3) m.model.after() self.assertEqual(m.model.state, 'C') self.assertEqual(m.model.level, 5) m.model.on_exit_A() self.assertEqual(m.model.state, 'C') self.assertEqual(m.model.level, 5) m.model.check() self.assertEqual(m.model.state, 'E') self.assertEqual(m.model.level, 7) m.model.prepare() self.assertEqual(m.model.state, 'F') self.assertEqual(m.model.level, 9) m.model.before() self.assertEqual(m.model.state, 'A') self.assertEqual(m.model.level, 11) # An invalid transition shouldn't execute the callback with self.assertRaises(MachineError): m.model.on_exit_A() def test_process_trigger(self): m = Machine(states=['raw', 'processed'], initial='raw') m.add_transition('process', 'raw', 'processed') m.process() self.assertEqual(m.state, 'processed') def test_multiple_models(self): s1, s2 = Stuff(), Stuff() states = ['A', 'B', 'C'] m = Machine(model=[s1, s2], states=states, initial=states[0]) self.assertEqual(len(m.models), 2) self.assertEqual(len(m.model), 2) m.add_transition('advance', 'A', 'B') s1.advance() self.assertEqual(s1.state, 'B') self.assertEqual(s2.state, 'A') m = Machine(model=s1, states=states, initial=states[0]) # for backwards compatibility model should return a model instance # rather than a list self.assertNotIsInstance(m.model, list) def test_dispatch(self): s1, s2 = Stuff(), Stuff() states = ['A', 'B', 'C'] m = Machine(model=s1, states=states, ignore_invalid_triggers=True, initial=states[0], transitions=[['go', 'A', 'B'], ['go', 'B', 'C']]) m.add_model(s2, initial='B') m.dispatch('go') self.assertEqual(s1.state, 'B') self.assertEqual(s2.state, 'C') def test_string_trigger(self): def return_value(value): return value class Model: def trigger(self, value): return value self.stuff.machine.add_transition('do', '*', 'C') self.stuff.trigger('do') self.assertTrue(self.stuff.is_C()) self.stuff.machine.add_transition('maybe', 'C', 'A', conditions=return_value) self.assertFalse(self.stuff.trigger('maybe', value=False)) self.assertTrue(self.stuff.trigger('maybe', value=True)) self.assertTrue(self.stuff.is_A()) with self.assertRaises(AttributeError): self.stuff.trigger('not_available') model = Model() m = Machine(model=model) self.assertEqual(model.trigger(5), 5) def raise_key_error(): raise KeyError self.stuff.machine.add_transition('do_raises_keyerror', '*', 'C', before=raise_key_error) with self.assertRaises(KeyError): self.stuff.trigger('do_raises_keyerror') def test_get_triggers(self): states = ['A', 'B', 'C'] transitions = [['a2b', 'A', 'B'], ['a2c', 'A', 'C'], ['c2b', 'C', 'B']] machine = Machine(states=states, transitions=transitions, initial='A', auto_transitions=False) self.assertEqual(len(machine.get_triggers('A')), 2) self.assertEqual(len(machine.get_triggers('B')), 0) self.assertEqual(len(machine.get_triggers('C')), 1) # self stuff machine should have to-transitions to every state self.assertEqual(len(self.stuff.machine.get_triggers('B')), len(self.stuff.machine.states)) def test_skip_override(self): local_mock = MagicMock() class Model(object): def go(self): local_mock() model = Model() transitions = [['go', 'A', 'B'], ['advance', 'A', 'B']] m = self.stuff.machine_cls(model=model, states=['A', 'B'], transitions=transitions, initial='A') model.go() self.assertEqual(model.state, 'A') self.assertTrue(local_mock.called) model.advance() self.assertEqual(model.state, 'B') model.to_A() model.trigger('go') self.assertEqual(model.state, 'B') @skipIf(sys.version_info < (3, ), "String-checking disabled on PY-2 because is different") def test_repr(self): def a_condition(event_data): self.assertRegex( str(event_data.transition.conditions), r"\[" r".a_condition at [^>]+>\)@\d+>\]") return True # No transition has been assigned to EventData yet def check_prepare_repr(event_data): self.assertRegex( str(event_data), r"', " r"None\)@\d+>") def check_before_repr(event_data): self.assertRegex( str(event_data), r"', " r"\)@\d+>") m.checked = True m = Machine(states=['A', 'B'], prepare_event=check_prepare_repr, before_state_change=check_before_repr, send_event=True, initial='A') m.add_transition('do_strcheck', 'A', 'B', conditions=a_condition) self.assertTrue(m.do_strcheck()) self.assertIn('checked', vars(m)) def test_machine_prepare(self): global_mock = MagicMock() local_mock = MagicMock() def global_callback(): global_mock() def local_callback(): local_mock() def always_fails(): return False transitions = [ {'trigger': 'go', 'source': 'A', 'dest': 'B', 'conditions': always_fails, 'prepare': local_callback}, {'trigger': 'go', 'source': 'A', 'dest': 'B', 'conditions': always_fails, 'prepare': local_callback}, {'trigger': 'go', 'source': 'A', 'dest': 'B', 'conditions': always_fails, 'prepare': local_callback}, {'trigger': 'go', 'source': 'A', 'dest': 'B', 'conditions': always_fails, 'prepare': local_callback}, {'trigger': 'go', 'source': 'A', 'dest': 'B', 'prepare': local_callback}, ] m = Machine(states=['A', 'B'], transitions=transitions, prepare_event=global_callback, initial='A') m.go() self.assertEqual(global_mock.call_count, 1) self.assertEqual(local_mock.call_count, len(transitions)) def test_machine_finalize(self): finalize_mock = MagicMock() def always_fails(event_data): return False def always_raises(event_data): raise Exception() transitions = [ {'trigger': 'go', 'source': 'A', 'dest': 'B'}, {'trigger': 'planA', 'source': 'B', 'dest': 'A', 'conditions': always_fails}, {'trigger': 'planB', 'source': 'B', 'dest': 'A', 'conditions': always_raises} ] m = self.stuff.machine_cls(states=['A', 'B'], transitions=transitions, finalize_event=finalize_mock, initial='A', send_event=True) m.go() self.assertEqual(finalize_mock.call_count, 1) m.planA() event_data = finalize_mock.call_args[0][0] self.assertIsInstance(event_data, EventData) self.assertEqual(finalize_mock.call_count, 2) self.assertFalse(event_data.result) with self.assertRaises(Exception): m.planB() self.assertEqual(finalize_mock.call_count, 3) def test_machine_finalize_exception(self): exception = ZeroDivisionError() def always_raises(event): raise exception def finalize_callback(event): self.assertEqual(event.error, exception) m = self.stuff.machine_cls(states=['A', 'B'], send_event=True, initial='A', before_state_change=always_raises, finalize_event=finalize_callback) with self.assertRaises(ZeroDivisionError): m.to_B() def test_prep_ordered_arg(self): self.assertTrue(len(_prep_ordered_arg(3, None)) == 3) self.assertTrue(all(a is None for a in _prep_ordered_arg(3, None))) with self.assertRaises(ValueError): _prep_ordered_arg(3, [None, None]) def test_ordered_transition_callback(self): class Model: def __init__(self): self.flag = False def make_true(self): self.flag = True model = Model() states = ['beginning', 'middle', 'end'] transits = [None, None, 'make_true'] m = Machine(model, states, initial='beginning') m.add_ordered_transitions(before=transits) model.next_state() self.assertFalse(model.flag) model.next_state() model.next_state() self.assertTrue(model.flag) def test_ordered_transition_condition(self): class Model: def __init__(self): self.blocker = False def check_blocker(self): return self.blocker model = Model() states = ['beginning', 'middle', 'end'] m = Machine(model, states, initial='beginning') m.add_ordered_transitions(conditions=[None, None, 'check_blocker']) model.to_end() self.assertFalse(model.next_state()) model.blocker = True self.assertTrue(model.next_state()) def test_get_transitions(self): states = ['A', 'B', 'C', 'D'] m = Machine('self', states, initial='a', auto_transitions=False) m.add_transition('go', ['A', 'B', 'C'], 'D') m.add_transition('run', 'A', 'D') self.assertEqual( {(t.source, t.dest) for t in m.get_transitions('go')}, {('A', 'D'), ('B', 'D'), ('C', 'D')}) self.assertEqual( [(t.source, t.dest) for t in m.get_transitions(source='A', dest='D')], [('A', 'D'), ('A', 'D')]) def test_remove_transition(self): self.stuff.machine.add_transition('go', ['A', 'B', 'C'], 'D') self.stuff.machine.add_transition('walk', 'A', 'B') self.stuff.go() self.assertEqual(self.stuff.state, 'D') self.stuff.to_A() self.stuff.machine.remove_transition('go', source='A') with self.assertRaises(MachineError): self.stuff.go() self.stuff.machine.add_transition('go', 'A', 'D') self.stuff.walk() self.stuff.go() self.assertEqual(self.stuff.state, 'D') self.stuff.to_C() self.stuff.machine.remove_transition('go', dest='D') self.assertFalse(hasattr(self.stuff, 'go')) def test_reflexive_transition(self): self.stuff.machine.add_transition('reflex', ['A', 'B'], '=', after='increase_level') self.assertEqual(self.stuff.state, 'A') self.stuff.reflex() self.assertEqual(self.stuff.state, 'A') self.assertEqual(self.stuff.level, 2) self.stuff.to_B() self.assertEqual(self.stuff.state, 'B') self.stuff.reflex() self.assertEqual(self.stuff.state, 'B') self.assertEqual(self.stuff.level, 3) self.stuff.to_C() with self.assertRaises(MachineError): self.stuff.reflex() self.assertEqual(self.stuff.level, 3) def test_internal_transition(self): m = Machine(Stuff(), states=['A', 'B'], initial='A') m.add_transition('move', 'A', None, prepare='increase_level') m.model.move() self.assertEqual(m.model.state, 'A') self.assertEqual(m.model.level, 2) def test_dynamic_model_state_attribute(self): class Model: def __init__(self): self.status = None self.state = 'some_value' m = Machine(Model(), states=['A', 'B'], initial='A', model_attribute='status') self.assertEqual(m.model.status, 'A') self.assertEqual(m.model.state, 'some_value') m.add_transition('move', 'A', 'B') m.model.move() self.assertEqual(m.model.status, 'B') self.assertEqual(m.model.state, 'some_value') def test_multiple_machines_per_model(self): class Model: def __init__(self): self.state_a = None self.state_b = None instance = Model() machine_a = Machine(instance, states=['A', 'B'], initial='A', model_attribute='state_a') machine_a.add_transition('melt', 'A', 'B') machine_b = Machine(instance, states=['A', 'B'], initial='B', model_attribute='state_b') machine_b.add_transition('freeze', 'B', 'A') self.assertEqual(instance.state_a, 'A') self.assertEqual(instance.state_b, 'B') instance.melt() self.assertEqual(instance.state_a, 'B') self.assertEqual(instance.state_b, 'B') instance.freeze() self.assertEqual(instance.state_b, 'A') self.assertEqual(instance.state_a, 'B') class TestWarnings(TestCase): def test_warning(self): import sys # does not work with python 3.3. However, the warning is shown when Machine is initialized manually. if (3, 3) <= sys.version_info < (3, 4): return # with warnings.catch_warnings(record=True) as w: # warnings.filterwarnings(action='default', message=r".*transitions version.*") # m = Machine(None) # self.assertEqual(len(w), 1) # for warn in w: # self.assertEqual(warn.category, DeprecationWarning) transitions-0.7.2/tests/test_enum.py0000644000076500000240000001140013600654252020536 0ustar alneumanstaff00000000000000from unittest import TestCase, skipIf try: import enum except ImportError: enum = None from transitions.extensions import MachineFactory @skipIf(enum is None, "enum is not available") class TestEnumsAsStates(TestCase): machine_cls = MachineFactory.get_predefined() def setUp(self): class States(enum.Enum): RED = 1 YELLOW = 2 GREEN = 3 self.States = States def test_pass_enums_as_states(self): m = self.machine_cls(states=self.States, initial=self.States.YELLOW) assert m.state == self.States.YELLOW assert m.is_RED() is False assert m.is_YELLOW() is True assert m.is_RED() is False m.to_RED() assert m.state == self.States.RED assert m.is_RED() is True assert m.is_YELLOW() is False assert m.is_GREEN() is False def test_transitions(self): m = self.machine_cls(states=self.States, initial=self.States.RED) m.add_transition('switch_to_yellow', self.States.RED, self.States.YELLOW) m.add_transition('switch_to_green', 'YELLOW', 'GREEN') m.switch_to_yellow() assert m.is_YELLOW() is True m.switch_to_green() assert m.is_YELLOW() is False assert m.is_GREEN() is True def test_if_enum_has_string_behavior(self): class States(str, enum.Enum): __metaclass__ = enum.EnumMeta RED = 'red' YELLOW = 'yellow' m = self.machine_cls(states=States, auto_transitions=False, initial=States.RED) m.add_transition('switch_to_yellow', States.RED, States.YELLOW) m.switch_to_yellow() assert m.is_YELLOW() is True def test_property_initial(self): transitions = [ {'trigger': 'switch_to_yellow', 'source': self.States.RED, 'dest': self.States.YELLOW}, {'trigger': 'switch_to_green', 'source': 'YELLOW', 'dest': 'GREEN'}, ] m = self.machine_cls(states=self.States, initial=self.States.RED, transitions=transitions) m.switch_to_yellow() assert m.is_YELLOW() m.switch_to_green() assert m.is_GREEN() def test_pass_state_instances_instead_of_names(self): state_A = self.machine_cls.state_cls(self.States.YELLOW) state_B = self.machine_cls.state_cls(self.States.GREEN) states = [state_A, state_B] m = self.machine_cls(states=states, initial=state_A) assert m.state == self.States.YELLOW m.add_transition('advance', state_A, state_B) m.advance() assert m.state == self.States.GREEN def test_state_change_listeners(self): class States(enum.Enum): ONE = 1 TWO = 2 class Stuff(object): def __init__(self, machine_cls): self.state = None self.machine = machine_cls(states=States, initial=States.ONE, model=self) self.machine.add_transition('advance', States.ONE, States.TWO) self.machine.add_transition('reverse', States.TWO, States.ONE) self.machine.on_enter_TWO('hello') self.machine.on_exit_TWO('goodbye') def hello(self): self.message = 'Hello' def goodbye(self): self.message = 'Goodbye' s = Stuff(self.machine_cls) s.advance() assert s.is_TWO() assert s.message == 'Hello' s.reverse() assert s.is_ONE() assert s.message == 'Goodbye' @skipIf(enum is None, "enum is not available") class TestNestedStateEnums(TestEnumsAsStates): machine_cls = MachineFactory.get_predefined(nested=True) def test_root_enums(self): states = [self.States.RED, self.States.YELLOW, {'name': self.States.GREEN, 'children': ['tick', 'tock'], 'initial': 'tick'}] m = self.machine_cls(states=states, initial=self.States.GREEN) self.assertTrue(m.is_GREEN(allow_substates=True)) self.assertTrue(m.is_GREEN_tick()) m.to_RED() self.assertTrue(m.state is self.States.RED) # self.assertEqual(m.state, self.States.GREEN) def test_nested_enums(self): # Nested enums are currently not support since model.state does not contain any information about parents # and nesting states = ['A', 'B', {'name': 'C', 'children': self.States, 'initial': self.States.GREEN}] with self.assertRaises(AttributeError): # NestedState will raise an error when parent is not None and state name is an enum # Initializing this would actually work but `m.to_A()` would raise an error in get_state(m.state) # as Machine is not aware of the location of States.GREEN m = self.machine_cls(states=states, initial='C') transitions-0.7.2/tests/test_factory.py0000644000076500000240000000361213530722244021246 0ustar alneumanstaff00000000000000try: from builtins import object except ImportError: pass from unittest import TestCase from transitions.extensions import MachineFactory class TestFactory(TestCase): def setUp(self): self.factory = MachineFactory() def test_mixins(self): machine_cls = self.factory.get_predefined() self.assertFalse(hasattr(machine_cls, 'set_edge_state')) graph_cls = self.factory.get_predefined(graph=True) self.assertTrue(hasattr(graph_cls, '_get_graph')) nested_cls = self.factory.get_predefined(nested=True) self.assertFalse(hasattr(nested_cls, '_get_graph')) self.assertTrue(hasattr(nested_cls, '_traverse')) locked_cls = self.factory.get_predefined(locked=True) self.assertFalse(hasattr(locked_cls, '_get_graph')) self.assertFalse(hasattr(locked_cls, '_traverse')) self.assertTrue('__getattribute__' in locked_cls.__dict__) locked_nested_cls = self.factory.get_predefined(nested=True, locked=True) self.assertFalse(hasattr(locked_nested_cls, '_get_graph')) self.assertTrue(hasattr(locked_nested_cls, '_traverse')) self.assertEqual(locked_nested_cls.__getattribute__, locked_cls.__getattribute__) self.assertNotEqual(machine_cls.__getattribute__, locked_cls.__getattribute__) graph_locked_cls = self.factory.get_predefined(graph=True, locked=True) self.assertTrue(hasattr(graph_locked_cls, '_get_graph')) self.assertEqual(graph_locked_cls.__getattribute__, locked_cls.__getattribute__) graph_nested_cls = self.factory.get_predefined(graph=True, nested=True) self.assertNotEqual(nested_cls._create_transition, graph_nested_cls._create_transition) locked_nested_graph_cls = self.factory.get_predefined(nested=True, locked=True, graph=True) self.assertNotEqual(locked_nested_graph_cls._create_event, graph_cls._create_event) transitions-0.7.2/tests/test_graphviz.py0000644000076500000240000003065713530722244021442 0ustar alneumanstaff00000000000000try: from builtins import object except ImportError: pass from .utils import Stuff from .test_core import TestTransitions from transitions.extensions import MachineFactory from transitions.extensions.nesting import NestedState from transitions.extensions.states import add_state_features, Timeout, Tags from unittest import skipIf import tempfile import os import re try: # Just to skip tests if graphviz not installed import graphviz as pgv # @UnresolvedImport except ImportError: # pragma: no cover pgv = None @skipIf(pgv is None, 'Graph diagram test requires graphviz.') class TestDiagrams(TestTransitions): machine_cls = MachineFactory.get_predefined(graph=True) use_pygraphviz = False def parse_dot(self, graph): if self.use_pygraphviz: dot = graph.string() else: dot = graph.source nodes = [] edges = [] for line in dot.split('\n'): if '->' in line: src, rest = line.split('->') dst, attr = rest.split(None, 1) nodes.append(src.strip().replace('"', '')) nodes.append(dst) edges.append(attr) return dot, set(nodes), edges def tearDown(self): pass # for m in ['pygraphviz', 'graphviz']: # if 'transitions.extensions.diagrams_' + m in sys.modules: # del sys.modules['transitions.extensions.diagrams_' + m] def setUp(self): self.stuff = Stuff(machine_cls=self.machine_cls, extra_kwargs={'use_pygraphviz': self.use_pygraphviz}) self.states = ['A', 'B', 'C', 'D'] self.transitions = [ {'trigger': 'walk', 'source': 'A', 'dest': 'B'}, {'trigger': 'run', 'source': 'B', 'dest': 'C'}, {'trigger': 'sprint', 'source': 'C', 'dest': 'D', 'conditions': 'is_fast'}, {'trigger': 'sprint', 'source': 'C', 'dest': 'B'} ] def test_diagram(self): m = self.machine_cls(states=self.states, transitions=self.transitions, initial='A', auto_transitions=False, title='a test', use_pygraphviz=self.use_pygraphviz) graph = m.get_graph() self.assertIsNotNone(graph) self.assertTrue(graph.directed) _, nodes, edges = self.parse_dot(graph) # Test that graph properties match the Machine self.assertEqual(set(m.states.keys()), nodes) self.assertEqual(len(edges), len(self.transitions)) for e in edges: # label should be equivalent to the event name self.assertIsNotNone(getattr(m, re.match(r'\[label=([^\]]+)\]', e).group(1))) # write diagram to temp file target = tempfile.NamedTemporaryFile(suffix='.png') graph.draw(target.name, format='png', prog='dot') self.assertTrue(os.path.getsize(target.name) > 0) # backwards compatibility check m.get_graph().draw(target.name, format='png', prog='dot') self.assertTrue(os.path.getsize(target.name) > 0) # cleanup temp file target.close() def test_add_custom_state(self): m = self.machine_cls(states=self.states, transitions=self.transitions, initial='A', auto_transitions=False, title='a test', use_pygraphviz=self.use_pygraphviz) m.add_state('X') m.add_transition('foo', '*', 'X') m.foo() def test_if_multiple_edges_are_supported(self): transitions = [ ['event_0', 'a', 'b'], ['event_1', 'a', 'b'], ['event_2', 'a', 'b'], ['event_3', 'a', 'b'], ] m = self.machine_cls( states=['a', 'b'], transitions=transitions, initial='a', auto_transitions=False, use_pygraphviz=self.use_pygraphviz ) graph = m.get_graph() self.assertIsNotNone(graph) self.assertTrue("digraph" in str(graph)) triggers = [transition[0] for transition in transitions] for trigger in triggers: self.assertTrue(trigger in str(graph)) def test_multi_model_state(self): m1 = Stuff(machine_cls=None, extra_kwargs={'use_pygraphviz': self.use_pygraphviz}) m2 = Stuff(machine_cls=None, extra_kwargs={'use_pygraphviz': self.use_pygraphviz}) m = self.machine_cls(model=[m1, m2], states=self.states, transitions=self.transitions, initial='A', use_pygraphviz=self.use_pygraphviz) m1.walk() self.assertEqual(m.model_graphs[m1].custom_styles['node'][m1.state], 'active') self.assertEqual(m.model_graphs[m2].custom_styles['node'][m1.state], '') # backwards compatibility test dot1, _, _ = self.parse_dot(m1.get_graph()) dot, _, _ = self.parse_dot(m.get_graph()) self.assertEqual(dot, dot1) def test_model_method_collision(self): class GraphModel: def get_graph(self): return "This method already exists" model = GraphModel() with self.assertRaises(AttributeError): m = self.machine_cls(model=model) self.assertEqual(model.get_graph(), "This method already exists") def test_to_method_filtering(self): m = self.machine_cls(states=['A', 'B', 'C'], initial='A', use_pygraphviz=self.use_pygraphviz) m.add_transition('to_state_A', 'B', 'A') m.add_transition('to_end', '*', 'C') _, _, edges = self.parse_dot(m.get_graph()) self.assertEqual(len([e for e in edges if e == '[label=to_state_A]']), 1) self.assertEqual(len([e for e in edges if e == '[label=to_end]']), 3) m2 = self.machine_cls(states=['A', 'B', 'C'], initial='A', show_auto_transitions=True, use_pygraphviz=self.use_pygraphviz) _, _, edges = self.parse_dot(m2.get_graph()) self.assertEqual(len(edges), 9) self.assertEqual(len([e for e in edges if e == '[label=to_A]']), 3) self.assertEqual(len([e for e in edges if e == '[label=to_C]']), 3) def test_loops(self): m = self.machine_cls(states=['A'], initial='A', use_pygraphviz=self.use_pygraphviz) m.add_transition('reflexive', 'A', '=') m.add_transition('fixed', 'A', None) g1 = m.get_graph() def test_roi(self): m = self.machine_cls(states=['A', 'B', 'C', 'D', 'E', 'F'], initial='A', use_pygraphviz=self.use_pygraphviz) m.add_transition('to_state_A', 'B', 'A') m.add_transition('to_state_C', 'B', 'C') m.add_transition('to_state_F', 'B', 'F') g1 = m.get_graph(show_roi=True) dot, nodes, edges = self.parse_dot(g1) self.assertEqual(len(edges), 0) self.assertIn("label=A", dot) # make sure that generating a graph without ROI has not influence on the later generated graph # this has to be checked since graph.custom_style is a class property and is persistent for multiple # calls of graph.generate() m.to_C() m.to_E() _ = m.get_graph() g2 = m.get_graph(show_roi=True) dot, _, _ = self.parse_dot(g2) self.assertNotIn("label=A", dot) m.to_B() g3 = m.get_graph(show_roi=True) _, nodes, edges = self.parse_dot(g3) self.assertEqual(len(edges), 3) self.assertEqual(len(nodes), 4) def test_state_tags(self): @add_state_features(Tags, Timeout) class CustomMachine(self.machine_cls): pass self.states[0] = {'name': 'A', 'tags': ['new', 'polling'], 'timeout': 5, 'on_enter': 'say_hello', 'on_exit': 'say_goodbye', 'on_timeout': 'do_something'} m = CustomMachine(states=self.states, transitions=self.transitions, initial='A', show_state_attributes=True, use_pygraphviz=self.use_pygraphviz) g = m.get_graph(show_roi=True) @skipIf(pgv is None, 'Graph diagram test requires graphviz') class TestDiagramsLocked(TestDiagrams): machine_cls = MachineFactory.get_predefined(graph=True, locked=True) @skipIf(pgv is None, 'NestedGraph diagram test requires graphviz') class TestDiagramsNested(TestDiagrams): machine_cls = MachineFactory.get_predefined(graph=True, nested=True) def setUp(self): super(TestDiagramsNested, self).setUp() self.states = ['A', 'B', {'name': 'C', 'children': [{'name': '1', 'children': ['a', 'b', 'c']}, '2', '3']}, 'D'] self.transitions = [ {'trigger': 'walk', 'source': 'A', 'dest': 'B'}, # 1 edge {'trigger': 'run', 'source': 'B', 'dest': 'C'}, # + 1 edge {'trigger': 'sprint', 'source': 'C', 'dest': 'D', # + 1 edge 'conditions': 'is_fast'}, {'trigger': 'sprint', 'source': 'C', 'dest': 'B'}, # + 1 edge {'trigger': 'reset', 'source': '*', 'dest': 'A'}] # + 10 (8 nodes; 2 cluster) edges = 14 def test_diagram(self): m = self.machine_cls(states=self.states, transitions=self.transitions, initial='A', auto_transitions=False, title='A test', show_conditions=True, use_pygraphviz=self.use_pygraphviz) graph = m.get_graph() self.assertIsNotNone(graph) self.assertTrue("digraph" in str(graph)) _, nodes, edges = self.parse_dot(graph) self.assertEqual(len(edges), 14) # Test that graph properties match the Machine self.assertEqual(set(m.states.keys()) - set(['C', 'C%s1' % NestedState.separator]), set(nodes) - set(['C_anchor', 'C%s1_anchor' % NestedState.separator])) m.walk() m.run() # write diagram to temp file target = tempfile.NamedTemporaryFile(suffix='.png') m.get_graph().draw(target.name, prog='dot') self.assertTrue(os.path.getsize(target.name) > 0) # backwards compatibility check m.get_graph().draw(target.name, prog='dot') self.assertTrue(os.path.getsize(target.name) > 0) # cleanup temp file target.close() def test_roi(self): class Model: def is_fast(self, *args, **kwargs): return True model = Model() m = self.machine_cls(model, states=self.states, transitions=self.transitions, initial='A', title='A test', use_pygraphviz=self.use_pygraphviz, show_conditions=True) model.walk() model.run() g1 = model.get_graph(show_roi=True) _, nodes, edges = self.parse_dot(g1) self.assertEqual(len(edges), 4) self.assertEqual(len(nodes), 4) model.sprint() g2 = model.get_graph(show_roi=True) dot, nodes, edges = self.parse_dot(g2) self.assertEqual(len(edges), 2) self.assertEqual(len(nodes), 3) def test_internal(self): self.use_pygraphviz = True states = ['A', 'B'] transitions = [['go', 'A', 'B'], dict(trigger='fail', source='A', dest=None, conditions=['failed']), dict(trigger='fail', source='A', dest='B', unless=['failed'])] m = self.machine_cls(states=states, transitions=transitions, initial='A', show_conditions=True, use_pygraphviz=self.use_pygraphviz) _, nodes, edges = self.parse_dot(m.get_graph()) self.assertEqual(len(nodes), 2) self.assertEqual(len([e for e in edges if '[internal]' in e]), 1) def test_internal_wildcards(self): internal_only_once = r'^(?:(?!\[internal\]).)*\[internal\](?!.*\[internal\]).*$' states = [ "initial", "ready", "running" ] transitions = [ ["booted", "initial", "ready"], {"trigger": "polled", "source": "ready", "dest": "running", "conditions": "door_closed"}, ["done", "running", "ready"], ["polled", "*", None] ] m = self.machine_cls(states=states, transitions=transitions, show_conditions=True, use_pygraphviz=self.use_pygraphviz, initial='initial') _, nodes, edges = self.parse_dot(m.get_graph()) self.assertEqual(len(nodes), 3) self.assertEqual(len([e for e in edges if re.match(internal_only_once, e)]), 3) @skipIf(pgv is None, 'NestedGraph diagram test requires graphviz') class TestDiagramsLockedNested(TestDiagramsNested): def setUp(self): super(TestDiagramsLockedNested, self).setUp() self.machine_cls = MachineFactory.get_predefined(graph=True, nested=True, locked=True) transitions-0.7.2/tests/test_markup.py0000644000076500000240000001315713606025607021106 0ustar alneumanstaff00000000000000try: from builtins import object except ImportError: pass from transitions.extensions.markup import MarkupMachine, rep from transitions.extensions.factory import HierarchicalMarkupMachine from .utils import Stuff from functools import partial from unittest import TestCase try: from unittest.mock import MagicMock except ImportError: from mock import MagicMock class SimpleModel(object): def after_func(self): pass class TestRep(TestCase): def test_rep_string(self): self.assertEqual(rep("string"), "string") def test_rep_function(self): def check(): return True self.assertTrue(check()) self.assertEqual(rep(check), "check") def test_rep_partial_no_args_no_kwargs(self): def check(): return True pcheck = partial(check) self.assertTrue(pcheck()) self.assertEqual(rep(pcheck), "check()") def test_rep_partial_with_args(self): def check(result): return result pcheck = partial(check, True) self.assertTrue(pcheck()) self.assertEqual(rep(pcheck), "check(True)") def test_rep_partial_with_kwargs(self): def check(result=True): return result pcheck = partial(check, result=True) self.assertTrue(pcheck()) self.assertEqual(rep(pcheck), "check(result=True)") def test_rep_partial_with_args_and_kwargs(self): def check(result, doublecheck=True): return result == doublecheck pcheck = partial(check, True, doublecheck=True) self.assertTrue(pcheck()) self.assertEqual(rep(pcheck), "check(True, doublecheck=True)") def test_rep_callable_class(self): class Check(object): def __init__(self, result): self.result = result def __call__(self): return self.result def __repr__(self): return "%s(%r)" % (type(self).__name__, self.result) ccheck = Check(True) self.assertTrue(ccheck()) self.assertEqual(rep(ccheck), "Check(True)") class TestMarkupMachine(TestCase): def setUp(self): self.machine_cls = MarkupMachine self.states = ['A', 'B', 'C', 'D'] self.transitions = [ {'trigger': 'walk', 'source': 'A', 'dest': 'B'}, {'trigger': 'run', 'source': 'B', 'dest': 'C'}, {'trigger': 'sprint', 'source': 'C', 'dest': 'D'} ] self.num_trans = len(self.transitions) self.num_auto = self.num_trans + len(self.states)**2 def test_markup_self(self): m1 = self.machine_cls(states=self.states, transitions=self.transitions, initial='A') m1.walk() # print(m1.markup) m2 = self.machine_cls(markup=m1.markup) self.assertEqual(m1.state, m2.state) self.assertEqual(len(m1.models), len(m2.models)) self.assertEqual(sorted(m1.states.keys()), sorted(m2.states.keys())) self.assertEqual(sorted(m1.events.keys()), sorted(m2.events.keys())) m2.run() m2.sprint() self.assertNotEqual(m1.state, m2.state) def test_markup_model(self): model1 = SimpleModel() m1 = self.machine_cls(model1, states=self.states, transitions=self.transitions, initial='A') model1.walk() m2 = self.machine_cls(markup=m1.markup) model2 = m2.models[0] self.assertIsInstance(model2, SimpleModel) self.assertEqual(len(m1.models), len(m2.models)) self.assertEqual(model1.state, model2.state) self.assertEqual(sorted(m1.states.keys()), sorted(m2.states.keys())) self.assertEqual(sorted(m1.events.keys()), sorted(m2.events.keys())) def test_conditions_unless(self): s = Stuff(machine_cls=self.machine_cls) s.machine.add_transition('go', 'A', 'B', conditions='this_passes', unless=['this_fails', 'this_fails_by_default']) t = s.machine.markup['transitions'] self.assertEqual(len(t), 1) self.assertEqual(t[0]['trigger'], 'go') self.assertEqual(len(t[0]['conditions']), 1) self.assertEqual(len(t[0]['unless']), 2) def test_auto_transitions(self): m1 = self.machine_cls(states=self.states, transitions=self.transitions, initial='A') m2 = self.machine_cls(states=self.states, transitions=self.transitions, initial='A', auto_transitions_markup=True) self.assertEqual(len(m1.markup.get('transitions')), self.num_trans) self.assertEqual(len(m2.markup.get('transitions')), self.num_auto) m1.add_transition('go', 'A', 'B') m2.add_transition('go', 'A', 'B') self.assertEqual(len(m1.markup.get('transitions')), self.num_trans + 1) self.assertEqual(len(m2.markup.get('transitions')), self.num_auto + 1) m1.auto_transitions_markup = True m2.auto_transitions_markup = False self.assertEqual(len(m1.markup.get('transitions')), self.num_auto + 1) self.assertEqual(len(m2.markup.get('transitions')), self.num_trans + 1) class TestMarkupHierarchicalMachine(TestMarkupMachine): def setUp(self): self.states = ['A', 'B', {'name': 'C', 'children': ['1', '2', {'name': '3', 'children': ['a', 'b', 'c']}]}] self.transitions = [ {'trigger': 'walk', 'source': 'A', 'dest': 'C_1'}, {'trigger': 'run', 'source': 'C_1', 'dest': 'C_3_a'}, {'trigger': 'sprint', 'source': 'C', 'dest': 'B'} ] self.machine_cls = HierarchicalMarkupMachine self.num_trans = len(self.transitions) self.num_auto = self.num_trans + 9**2 transitions-0.7.2/tests/test_nesting.py0000644000076500000240000005324413530722244021254 0ustar alneumanstaff00000000000000# -*- coding: utf-8 -*- try: from builtins import object except ImportError: pass import sys import tempfile from os.path import getsize from transitions.extensions import MachineFactory from transitions.extensions.nesting import NestedState as State from unittest import skipIf from .test_core import TestTransitions as TestsCore from .utils import Stuff try: from unittest.mock import MagicMock except ImportError: from mock import MagicMock try: # Just to skip tests if graphviz not installed import graphviz as pgv # @UnresolvedImport except ImportError: # pragma: no cover pgv = None state_separator = State.separator class Dummy(object): pass class TestTransitions(TestsCore): def setUp(self): states = ['A', 'B', {'name': 'C', 'children': ['1', '2', {'name': '3', 'children': ['a', 'b', 'c']}]}, 'D', 'E', 'F'] machine_cls = MachineFactory.get_predefined(nested=True) self.stuff = Stuff(states, machine_cls) def tearDown(self): State.separator = state_separator pass def test_add_model(self): model = Dummy() self.stuff.machine.add_model(model, initial='E') def test_function_wrapper(self): from transitions.extensions.nesting import FunctionWrapper mo = MagicMock f = FunctionWrapper(mo, ['a', 'long', 'path', 'to', 'walk']) f.a.long.path.to.walk() self.assertTrue(mo.called) with self.assertRaises(Exception): f.a.long.path() def test_init_machine_with_hella_arguments(self): states = [ State('State1'), 'State2', { 'name': 'State3', 'on_enter': 'hello_world' } ] transitions = [ {'trigger': 'advance', 'source': 'State2', 'dest': 'State3' } ] s = Stuff() self.stuff.machine_cls( model=s, states=states, transitions=transitions, initial='State2') s.advance() self.assertEqual(s.message, 'Hello World!') def test_init_machine_with_nested_states(self): a = State('A') b = State('B') b_1 = State('1', parent=b) b_2 = State('2', parent=b) m = self.stuff.machine_cls(states=[a, b]) self.assertEqual(b_1.name, 'B{0}1'.format(state_separator)) m.to("B{0}1".format(state_separator)) def test_property_initial(self): # Define with list of dictionaries states = ['A', 'B', {'name': 'C', 'children': ['1', '2', '3']}, 'D'] # Define with list of dictionaries transitions = [ {'trigger': 'walk', 'source': 'A', 'dest': 'B'}, {'trigger': 'run', 'source': 'B', 'dest': 'C'}, {'trigger': 'sprint', 'source': 'C', 'dest': 'D'} ] m = self.stuff.machine_cls(states=states, transitions=transitions, initial='A') self.assertEqual(m.initial, 'A') m = self.stuff.machine_cls(states=states, transitions=transitions, initial='C') self.assertEqual(m.initial, 'C') m = self.stuff.machine_cls(states=states, transitions=transitions) self.assertEqual(m.initial, 'initial') def test_transition_definitions(self): states = ['A', 'B', {'name': 'C', 'children': ['1', '2', '3']}, 'D'] # Define with list of dictionaries transitions = [ {'trigger': 'walk', 'source': 'A', 'dest': 'B'}, {'trigger': 'run', 'source': 'B', 'dest': 'C'}, {'trigger': 'sprint', 'source': 'C', 'dest': 'D'}, {'trigger': 'run', 'source': 'C', 'dest': 'C%s1' % State.separator} ] m = self.stuff.machine_cls(states=states, transitions=transitions, initial='A') m.walk() self.assertEqual(m.state, 'B') m.run() self.assertEqual(m.state, 'C') m.run() self.assertEqual(m.state, 'C%s1' % State.separator) # Define with list of lists transitions = [ ['walk', 'A', 'B'], ['run', 'B', 'C'], ['sprint', 'C', 'D'] ] m = self.stuff.machine_cls(states=states, transitions=transitions, initial='A') m.to_C() m.sprint() self.assertEqual(m.state, 'D') def test_transitioning(self): s = self.stuff s.machine.add_transition('advance', 'A', 'B') s.machine.add_transition('advance', 'B', 'C') s.machine.add_transition('advance', 'C', 'D') s.machine.add_transition('reset', '*', 'A') self.assertEqual(len(s.machine.events['reset'].transitions['C%s1' % State.separator]), 1) s.advance() self.assertEqual(s.state, 'B') self.assertFalse(s.is_A()) self.assertTrue(s.is_B()) s.advance() self.assertEqual(s.state, 'C') def test_conditions(self): s = self.stuff s.machine.add_transition('advance', 'A', 'B', conditions='this_passes') s.machine.add_transition('advance', 'B', 'C', unless=['this_fails']) s.machine.add_transition('advance', 'C', 'D', unless=['this_fails', 'this_passes']) s.advance() self.assertEqual(s.state, 'B') s.advance() self.assertEqual(s.state, 'C') s.advance() self.assertEqual(s.state, 'C') def test_multiple_add_transitions_from_state(self): s = self.stuff s.machine.add_transition( 'advance', 'A', 'B', conditions=['this_fails']) s.machine.add_transition('advance', 'A', 'C') s.machine.add_transition('advance', 'C', 'C%s2' % State.separator) s.advance() self.assertEqual(s.state, 'C') s.advance() self.assertEqual(s.state, 'C%s2' % State.separator) self.assertFalse(s.is_C()) self.assertTrue(s.is_C(allow_substates=True)) def test_use_machine_as_model(self): states = ['A', 'B', 'C', 'D'] m = self.stuff.machine_cls(states=states, initial='A') m.add_transition('move', 'A', 'B') m.add_transition('move_to_C', 'B', 'C') m.move() self.assertEqual(m.state, 'B') def test_add_custom_state(self): s = self.stuff s.machine.add_states([{'name': 'E', 'children': ['1', '2']}]) s.machine.add_state('3', parent='E') s.machine.add_transition('go', '*', 'E%s1' % State.separator) s.machine.add_transition('walk', '*', 'E%s3' % State.separator) s.machine.add_transition('run', 'E', 'C{0}3{0}a'.format(State.separator)) s.go() self.assertEqual(s.state, 'E{0}1'.format(State.separator)) s.walk() self.assertEqual(s.state, 'E{0}3'.format(State.separator)) s.run() self.assertEqual(s.state, 'C{0}3{0}a'.format(State.separator)) def test_enter_exit_nested_state(self): mock = MagicMock() def callback(): mock() states = ['A', 'B', {'name': 'C', 'on_enter': callback, 'on_exit': callback, 'children': [{'name': '1', 'on_exit': callback}, '2', '3']}, 'D'] transitions = [['go', 'A', 'C{0}1'.format(State.separator)], ['go', 'C', 'D']] m = self.stuff.machine_cls(states=states, transitions=transitions, initial='A') m.go() self.assertTrue(mock.called) self.assertEqual(mock.call_count, 1) m.go() self.assertTrue(m.is_D()) self.assertEqual(mock.call_count, 3) def test_state_change_listeners(self): s = self.stuff s.machine.add_transition('advance', 'A', 'C%s1' % State.separator) s.machine.add_transition('reverse', 'C', 'A') s.machine.add_transition('lower', 'C%s1' % State.separator, 'C{0}3{0}a'.format(State.separator)) s.machine.add_transition('rise', 'C%s3' % State.separator, 'C%s1' % State.separator) s.machine.add_transition('fast', 'A', 'C{0}3{0}a'.format(State.separator)) s.machine.on_enter_C('hello_world') s.machine.on_exit_C('goodbye') s.machine.on_enter('C{0}3{0}a'.format(State.separator), 'greet') s.machine.on_exit('C%s3' % State.separator, 'meet') s.advance() self.assertEqual(s.state, 'C%s1' % State.separator) self.assertEqual(s.message, 'Hello World!') s.lower() self.assertEqual(s.state, 'C{0}3{0}a'.format(State.separator)) self.assertEqual(s.message, 'Hi') s.rise() self.assertEqual(s.state, 'C%s1' % State.separator) self.assertTrue(s.message.startswith('Nice to')) s.reverse() self.assertEqual(s.state, 'A') self.assertTrue(s.message.startswith('So long')) s.fast() self.assertEqual(s.state, 'C{0}3{0}a'.format(State.separator)) self.assertEqual(s.message, 'Hi') s.to_A() self.assertEqual(s.state, 'A') self.assertTrue(s.message.startswith('So long')) def test_enter_exit_nested(self): s = self.stuff s.machine.add_transition('advance', 'A', 'C{0}3'.format(State.separator)) s.machine.add_transition('reverse', 'C', 'A') s.machine.add_transition('lower', ['C{0}1'.format(State.separator), 'C{0}3'.format(State.separator)], 'C{0}3{0}a'.format(State.separator)) s.machine.add_transition('rise', 'C%s3' % State.separator, 'C%s1' % State.separator) s.machine.add_transition('fast', 'A', 'C{0}3{0}a'.format(State.separator)) for state in s.machine.states.values(): state.on_enter.append('increase_level') state.on_exit.append('decrease_level') s.advance() self.assertEqual(s.state, 'C%s3' % State.separator) self.assertEqual(s.level, 2) self.assertEqual(s.transitions, 3) # exit A; enter C,3 s.lower() self.assertEqual(s.state, 'C{0}3{0}a'.format(State.separator)) self.assertEqual(s.level, 3) self.assertEqual(s.transitions, 4) # enter a s.rise() self.assertEqual(s.state, 'C%s1' % State.separator) self.assertEqual(s.level, 2) self.assertEqual(s.transitions, 7) # exit a, 3; enter 1 s.reverse() self.assertEqual(s.state, 'A') self.assertEqual(s.level, 1) self.assertEqual(s.transitions, 10) # exit 1, C; enter A s.fast() self.assertEqual(s.state, 'C{0}3{0}a'.format(State.separator)) self.assertEqual(s.level, 3) self.assertEqual(s.transitions, 14) # exit A; enter C, 3, a s.to_A() self.assertEqual(s.state, 'A') self.assertEqual(s.level, 1) self.assertEqual(s.transitions, 18) # exit a, 3, C; enter A s.to_A() self.assertEqual(s.state, 'A') self.assertEqual(s.level, 1) self.assertEqual(s.transitions, 20) # exit A; enter A if State.separator in '_': s.to_C_3_a() else: s.to_C.s3.a() self.assertEqual(s.state, 'C{0}3{0}a'.format(State.separator)) self.assertEqual(s.level, 3) self.assertEqual(s.transitions, 24) # exit A; enter C, 3, a def test_ordered_transitions(self): states = [{'name': 'first', 'children': ['second', 'third', {'name': 'fourth', 'children': ['fifth', 'sixth']}, 'seventh']}, 'eighth', 'ninth'] m = self.stuff.machine_cls(states=states) m.add_ordered_transitions() self.assertEqual(m.state, 'initial') m.next_state() self.assertEqual(m.state, 'first') m.next_state() m.next_state() self.assertEqual(m.state, 'first{0}third'.format(State.separator)) m.next_state() m.next_state() self.assertEqual(m.state, 'first{0}fourth{0}fifth'.format(State.separator)) m.next_state() m.next_state() self.assertEqual(m.state, 'first{0}seventh'.format(State.separator)) m.next_state() m.next_state() self.assertEqual(m.state, 'ninth') # Include initial state in loop m = self.stuff.machine_cls('self', states) m.add_ordered_transitions(loop_includes_initial=False) m.to_ninth() m.next_state() self.assertEqual(m.state, 'first') # Test user-determined sequence and trigger name m = self.stuff.machine_cls('self', states, initial='first') m.add_ordered_transitions(['first', 'ninth'], trigger='advance') m.advance() self.assertEqual(m.state, 'ninth') m.advance() self.assertEqual(m.state, 'first') # Via init argument m = self.stuff.machine_cls('self', states, initial='first', ordered_transitions=True) m.next_state() self.assertEqual(m.state, 'first{0}second'.format(State.separator)) def test_pickle(self): import sys if sys.version_info < (3, 4): import dill as pickle else: import pickle states = ['A', 'B', {'name': 'C', 'children': ['1', '2', {'name': '3', 'children': ['a', 'b', 'c']}]}, 'D', 'E', 'F'] transitions = [ {'trigger': 'walk', 'source': 'A', 'dest': 'B'}, {'trigger': 'run', 'source': 'B', 'dest': 'C'}, {'trigger': 'sprint', 'source': 'C', 'dest': 'D'} ] m = self.stuff.machine_cls(states=states, transitions=transitions, initial='A') m.walk() dump = pickle.dumps(m) self.assertIsNotNone(dump) m2 = pickle.loads(dump) self.assertEqual(m.state, m2.state) m2.run() m2.to_C_3_a() m2.to_C_3_b() def test_callbacks_duplicate(self): transitions = [ {'trigger': 'walk', 'source': 'A', 'dest': 'C', 'before': 'before_change', 'after': 'after_change'}, {'trigger': 'run', 'source': 'B', 'dest': 'C'} ] m = self.stuff.machine_cls(states=['A', 'B', 'C'], transitions=transitions, before_state_change='before_change', after_state_change='after_change', send_event=True, initial='A', auto_transitions=True) m.before_change = MagicMock() m.after_change = MagicMock() m.walk() self.assertEqual(m.before_change.call_count, 2) self.assertEqual(m.after_change.call_count, 2) def test_with_custom_separator(self): State.separator = '.' self.setUp() self.test_enter_exit_nested() self.setUp() self.test_state_change_listeners() self.test_nested_auto_transitions() State.separator = '.' if sys.version_info[0] < 3 else u'↦' self.setUp() self.test_enter_exit_nested() self.setUp() self.test_state_change_listeners() self.test_nested_auto_transitions() def test_with_slash_separator(self): State.separator = '/' self.setUp() self.test_enter_exit_nested() self.setUp() self.test_state_change_listeners() self.test_nested_auto_transitions() self.setUp() self.test_ordered_transitions() def test_nested_auto_transitions(self): s = self.stuff s.to_C() self.assertEqual(s.state, 'C') state = 'C{0}3{0}a'.format(State.separator) s.to(state) self.assertEqual(s.state, state) # backwards compatibility check (can be removed in 0.7) self.assertEqual(s.state, state) def test_example_one(self): State.separator = '_' states = ['standing', 'walking', {'name': 'caffeinated', 'children': ['dithering', 'running']}] transitions = [['walk', 'standing', 'walking'], ['stop', 'walking', 'standing'], ['drink', '*', 'caffeinated'], ['walk', 'caffeinated', 'caffeinated_running'], ['relax', 'caffeinated', 'standing']] machine = self.stuff.machine_cls(states=states, transitions=transitions, initial='standing', ignore_invalid_triggers=True, name='Machine 1') machine.walk() # Walking now machine.stop() # let's stop for a moment machine.drink() # coffee time machine.state self.assertEqual(machine.state, 'caffeinated') machine.walk() # we have to go faster self.assertEqual(machine.state, 'caffeinated_running') machine.stop() # can't stop moving! machine.state self.assertEqual(machine.state, 'caffeinated_running') machine.relax() # leave nested state machine.state # phew, what a ride self.assertEqual(machine.state, 'standing') machine.to_caffeinated_running() # auto transition fast track machine.on_enter_caffeinated_running('callback_method') def test_example_two(self): State.separator = '.' if sys.version_info[0] < 3 else u'↦' states = ['A', 'B', {'name': 'C', 'children': ['1', '2', {'name': '3', 'children': ['a', 'b', 'c']}] }] transitions = [ ['reset', 'C', 'A'], ['reset', 'C%s2' % State.separator, 'C'] # overwriting parent reset ] # we rely on auto transitions machine = self.stuff.machine_cls(states=states, transitions=transitions, initial='A') machine.to_B() # exit state A, enter state B machine.to_C() # exit B, enter C machine.to_C.s3.a() # enter C↦a; enter C↦3↦a; self.assertEqual(machine.state, 'C{0}3{0}a'.format(State.separator)) machine.to('C{0}2'.format(State.separator)) # exit C↦3↦a, exit C↦3, enter C↦2 machine.reset() # exit C↦2; reset C has been overwritten by C↦3 self.assertEqual(machine.state, 'C') machine.reset() # exit C, enter A self.assertEqual(machine.state, 'A') def test_multiple_models(self): class Model(object): pass s1, s2 = Model(), Model() m = MachineFactory.get_predefined(nested=True)(model=[s1, s2], states=['A', 'B', 'C'], initial='A') self.assertEqual(len(m.models), 2) m.add_transition('advance', 'A', 'B') self.assertNotEqual(s1.advance, s2.advance) s1.advance() self.assertEqual(s1.state, 'B') self.assertEqual(s2.state, 'A') def test_excessive_nesting(self): states = [{'name': 'A', 'children': []}] curr = states[0] for i in range(10): curr['children'].append({'name': str(i), 'children': []}) curr = curr['children'][0] m = self.stuff.machine_cls(states=states, initial='A') def test_intial_state(self): states = [{'name': 'A', 'children': ['1', '2'], 'initial': '2'}, {'name': 'B', 'initial': '2', 'children': ['1', {'name': '2', 'initial': 'a', 'children': ['a', 'b']}]}] transitions = [['do', 'A', 'B'], ['do', 'B{0}2'.format(state_separator), 'B{0}1'.format(state_separator)]] m = self.stuff.machine_cls(states=states, transitions=transitions, initial='A') self.assertEqual(m.state, 'A{0}2'.format(state_separator)) m.do() self.assertEqual(m.state, 'B{0}2{0}a'.format(state_separator)) self.assertTrue(m.is_B(allow_substates=True)) m.do() self.assertEqual(m.state, 'B{0}1'.format(state_separator)) def test_get_triggers(self): states = ['standing', 'walking', {'name': 'caffeinated', 'children': ['dithering', 'running']}] transitions = [ ['walk', 'standing', 'walking'], ['go', 'standing', 'walking'], ['stop', 'walking', 'standing'], {'trigger': 'drink', 'source': '*', 'dest': 'caffeinated_dithering', 'conditions': 'is_hot', 'unless': 'is_too_hot'}, ['walk', 'caffeinated_dithering', 'caffeinated_running'], ['relax', 'caffeinated', 'standing'] ] machine = self.stuff.machine_cls(states=states, transitions=transitions, auto_transitions=False) trans = machine.get_triggers('caffeinated{0}dithering'.format(state_separator)) self.assertEqual(len(trans), 3) self.assertTrue('relax' in trans) def test_internal_transitions(self): s = self.stuff s.machine.add_transition('internal', 'A', None, prepare='increase_level') s.internal() self.assertEqual(s.state, 'A') self.assertEqual(s.level, 2) @skipIf(pgv is None, 'NestedGraph diagram test requires graphviz') class TestWithGraphTransitions(TestTransitions): def setUp(self): State.separator = state_separator states = ['A', 'B', {'name': 'C', 'children': ['1', '2', {'name': '3', 'children': ['a', 'b', 'c']}]}, 'D', 'E', 'F'] machine_cls = MachineFactory.get_predefined(graph=True, nested=True) self.stuff = Stuff(states, machine_cls) def test_ordered_with_graph(self): GraphMachine = MachineFactory.get_predefined(graph=True, nested=True) states = ['A', 'B', {'name': 'C', 'children': ['1', '2', {'name': '3', 'children': ['a', 'b', 'c']}]}, 'D', 'E', 'F'] State.separator = '/' machine = GraphMachine('self', states, initial='A', auto_transitions=False, ignore_invalid_triggers=True) machine.add_ordered_transitions(trigger='next_state') machine.next_state() self.assertEqual(machine.state, 'B') target = tempfile.NamedTemporaryFile() machine.get_graph().draw(target.name, prog='dot') self.assertTrue(getsize(target.name) > 0) target.close() transitions-0.7.2/tests/test_pygraphviz.py0000644000076500000240000001203513530722244022001 0ustar alneumanstaff00000000000000try: from builtins import object except ImportError: pass from .utils import Stuff from .test_graphviz import TestDiagrams, TestDiagramsNested, NestedState from transitions.extensions.states import add_state_features, Timeout, Tags from unittest import skipIf import tempfile import os try: # Just to skip tests if graphviz not installed import pygraphviz as pgv # @UnresolvedImport except ImportError: # pragma: no cover pgv = None @skipIf(pgv is None, 'Graph diagram requires pygraphviz') class PygraphvizTest(TestDiagrams): use_pygraphviz = True def setUp(self): super(PygraphvizTest, self).setUp() # def test_diagram(self): # m = self.machine_cls(states=self.states, transitions=self.transitions, use_pygraphviz=self.use_pygraphviz, # initial='A', auto_transitions=False, title='a test') # graph = m.get_graph() # self.assertIsNotNone(graph) # self.assertTrue(graph.directed) # # # Test that graph properties match the Machine # self.assertEqual( # set(m.states.keys()), set([n.name for n in graph.nodes()])) # triggers = set([n.attr['label'] for n in graph.edges()]) # for t in triggers: # t = edge_label_from_transition_label(t) # self.assertIsNotNone(getattr(m, t)) # # self.assertEqual(len(graph.edges()), len(self.transitions)) # # # write diagram to temp file # target = tempfile.NamedTemporaryFile() # graph.draw(target.name, prog='dot') # self.assertTrue(os.path.getsize(target.name) > 0) # # # cleanup temp file # target.close() # # graph = m.get_graph(force_new=True, title=False) # self.assertEqual("", graph.graph_attr['label']) def test_if_multiple_edges_are_supported(self): transitions = [ ['event_0', 'a', 'b'], ['event_1', 'a', 'b'], ['event_2', 'a', 'b'], ['event_3', 'a', 'b'], ] m = self.machine_cls( states=['a', 'b'], transitions=transitions, initial='a', auto_transitions=False, use_pygraphviz=self.use_pygraphviz ) graph = m.get_graph() self.assertIsNotNone(graph) self.assertTrue("digraph" in str(graph)) triggers = [transition[0] for transition in transitions] for trigger in triggers: self.assertTrue(trigger in str(graph)) def test_multi_model_state(self): m1 = Stuff(machine_cls=None) m2 = Stuff(machine_cls=None) m = self.machine_cls(model=[m1, m2], states=self.states, transitions=self.transitions, initial='A', use_pygraphviz=self.use_pygraphviz) m1.walk() self.assertEqual(m1.get_graph().get_node(m1.state).attr['color'], m1.get_graph().style_attributes['node']['active']['color']) self.assertEqual(m2.get_graph().get_node(m1.state).attr['color'], m2.get_graph().style_attributes['node']['default']['color']) # backwards compatibility test self.assertEqual(id(m.get_graph()), id(m1.get_graph())) def test_to_method_filtering(self): m = self.machine_cls(states=['A', 'B', 'C'], initial='A') m.add_transition('to_state_A', 'B', 'A') m.add_transition('to_end', '*', 'C') e = m.get_graph().get_edge('B', 'A') self.assertEqual(e.attr['label'], 'to_state_A') e = m.get_graph().get_edge('A', 'C') self.assertEqual(e.attr['label'], 'to_end') with self.assertRaises(KeyError): m.get_graph().get_edge('A', 'B') m2 = self.machine_cls(states=['A', 'B'], initial='A', show_auto_transitions=True) self.assertEqual(len(m2.get_graph().get_edge('B', 'A')), 2) self.assertEqual(m2.get_graph().get_edge('A', 'B').attr['label'], 'to_B') def test_roi(self): m = self.machine_cls(states=['A', 'B', 'C', 'D', 'E', 'F'], initial='A') m.add_transition('to_state_A', 'B', 'A') m.add_transition('to_state_C', 'B', 'C') m.add_transition('to_state_F', 'B', 'F') g1 = m.get_graph(show_roi=True) self.assertEqual(len(g1.edges()), 0) self.assertEqual(len(g1.nodes()), 1) m.to_B() g2 = m.get_graph(show_roi=True) self.assertEqual(len(g2.edges()), 4) self.assertEqual(len(g2.nodes()), 4) def test_state_tags(self): @add_state_features(Tags, Timeout) class CustomMachine(self.machine_cls): pass self.states[0] = {'name': 'A', 'tags': ['new', 'polling'], 'timeout': 5, 'on_enter': 'say_hello', 'on_exit': 'say_goodbye', 'on_timeout': 'do_something'} m = CustomMachine(states=self.states, transitions=self.transitions, initial='A', show_state_attributes=True) g = m.get_graph(show_roi=True) @skipIf(pgv is None, 'NestedGraph diagram requires pygraphviz') class TestPygraphvizNested(TestDiagramsNested, PygraphvizTest): use_pygraphviz = True transitions-0.7.2/tests/test_reuse.py0000644000076500000240000002574213363416552020740 0ustar alneumanstaff00000000000000try: from builtins import object except ImportError: pass from transitions import MachineError from transitions.extensions import HierarchicalMachine as Machine from transitions.extensions.nesting import NestedState as State from .utils import Stuff from unittest import TestCase try: from unittest.mock import MagicMock except ImportError: from mock import MagicMock nested_separator = State.separator class TestTransitions(TestCase): def setUp(self): states = ['A', 'B', {'name': 'C', 'children': ['1', '2', {'name': '3', 'children': ['a', 'b', 'c']}]}, 'D', 'E', 'F'] self.stuff = Stuff(states, Machine) def tearDown(self): pass def test_blueprint_reuse(self): states = ['1', '2', '3'] transitions = [ {'trigger': 'increase', 'source': '1', 'dest': '2'}, {'trigger': 'increase', 'source': '2', 'dest': '3'}, {'trigger': 'decrease', 'source': '3', 'dest': '2'}, {'trigger': 'decrease', 'source': '1', 'dest': '1'}, {'trigger': 'reset', 'source': '*', 'dest': '1'}, ] counter = Machine(states=states, transitions=transitions, before_state_change='check', after_state_change='clear', initial='1') new_states = ['A', 'B', {'name': 'C', 'children': counter}] new_transitions = [ {'trigger': 'forward', 'source': 'A', 'dest': 'B'}, {'trigger': 'forward', 'source': 'B', 'dest': 'C%s1' % State.separator}, {'trigger': 'backward', 'source': 'C', 'dest': 'B'}, {'trigger': 'backward', 'source': 'B', 'dest': 'A'}, {'trigger': 'calc', 'source': '*', 'dest': 'C'}, ] walker = Machine(states=new_states, transitions=new_transitions, before_state_change='watch', after_state_change='look_back', initial='A') walker.watch = lambda: 'walk' walker.look_back = lambda: 'look_back' walker.check = lambda: 'check' walker.clear = lambda: 'clear' with self.assertRaises(MachineError): walker.increase() self.assertEqual(walker.state, 'A') walker.forward() walker.forward() self.assertEqual(walker.state, 'C%s1' % State.separator) walker.increase() self.assertEqual(walker.state, 'C%s2' % State.separator) walker.reset() self.assertEqual(walker.state, 'C%s1' % State.separator) walker.to_A() self.assertEqual(walker.state, 'A') walker.calc() self.assertEqual(walker.state, 'C_1') def test_blueprint_initial_false(self): child = Machine(states=['A', 'B'], initial='A') parent = Machine(states=['a', 'b', {'name': 'c', 'children': child, 'initial': False}]) parent.to_c() self.assertEqual(parent.state, 'c') def test_blueprint_remap(self): states = ['1', '2', '3', 'finished'] transitions = [ {'trigger': 'increase', 'source': '1', 'dest': '2'}, {'trigger': 'increase', 'source': '2', 'dest': '3'}, {'trigger': 'decrease', 'source': '3', 'dest': '2'}, {'trigger': 'decrease', 'source': '1', 'dest': '1'}, {'trigger': 'reset', 'source': '*', 'dest': '1'}, {'trigger': 'done', 'source': '3', 'dest': 'finished'} ] counter = Machine(states=states, transitions=transitions, initial='1') new_states = ['A', 'B', {'name': 'C', 'children': [counter, {'name': 'X', 'children': ['will', 'be', 'filtered', 'out']}], 'remap': {'finished': 'A', 'X': 'A'}}] new_transitions = [ {'trigger': 'forward', 'source': 'A', 'dest': 'B'}, {'trigger': 'forward', 'source': 'B', 'dest': 'C%s1' % State.separator}, {'trigger': 'backward', 'source': 'C', 'dest': 'B'}, {'trigger': 'backward', 'source': 'B', 'dest': 'A'}, {'trigger': 'calc', 'source': '*', 'dest': 'C%s1' % State.separator}, ] walker = Machine(states=new_states, transitions=new_transitions, before_state_change='watch', after_state_change='look_back', initial='A') walker.watch = lambda: 'walk' walker.look_back = lambda: 'look_back' counter.increase() counter.increase() counter.done() self.assertEqual(counter.state, 'finished') with self.assertRaises(MachineError): walker.increase() self.assertEqual(walker.state, 'A') walker.forward() walker.forward() self.assertEqual(walker.state, 'C%s1' % State.separator) walker.increase() self.assertEqual(walker.state, 'C%s2' % State.separator) walker.reset() self.assertEqual(walker.state, 'C%s1' % State.separator) walker.to_A() self.assertEqual(walker.state, 'A') walker.calc() self.assertEqual(walker.state, 'C%s1' % State.separator) walker.increase() walker.increase() walker.done() self.assertEqual(walker.state, 'A') self.assertFalse('C.finished' in walker.states) def test_wrong_nesting(self): correct = ['A', {'name': 'B', 'children': self.stuff.machine}] wrong_type = ['A', {'name': 'B', 'children': self.stuff}] siblings = ['A', {'name': 'B', 'children': ['1', self.stuff.machine]}] collision = ['A', {'name': 'B', 'children': ['A', self.stuff.machine]}] m = Machine(states=correct) m.to_B.C.s3.a() with self.assertRaises(ValueError): m = Machine(states=wrong_type) with self.assertRaises(ValueError): m = Machine(states=collision) m = Machine(states=siblings) m.to_B.s1() m.to_B.A() def test_custom_separator(self): State.separator = '.' self.tearDown() self.setUp() self.test_wrong_nesting() def test_example_reuse(self): count_states = ['1', '2', '3', 'done'] count_trans = [ ['increase', '1', '2'], ['increase', '2', '3'], ['decrease', '3', '2'], ['decrease', '2', '1'], {'trigger': 'done', 'source': '3', 'dest': 'done', 'conditions': 'this_passes'}, ] counter = self.stuff.machine_cls(states=count_states, transitions=count_trans, initial='1') counter.increase() # love my counter states = ['waiting', 'collecting', {'name': 'counting', 'children': counter}] states_remap = ['waiting', 'collecting', {'name': 'counting', 'children': counter, 'remap': {'done': 'waiting'}}] transitions = [ ['collect', '*', 'collecting'], ['wait', '*', 'waiting'], ['count', '*', 'counting%s1' % State.separator] ] collector = self.stuff.machine_cls(states=states, transitions=transitions, initial='waiting') collector.this_passes = self.stuff.this_passes collector.collect() # collecting collector.count() # let's see what we got collector.increase() # counting_2 collector.increase() # counting_3 collector.done() # counting_done self.assertEqual(collector.state, 'counting{0}done'.format(State.separator)) collector.wait() # go back to waiting self.assertEqual(collector.state, 'waiting') # reuse counter instance with remap collector = self.stuff.machine_cls(states=states_remap, transitions=transitions, initial='waiting') collector.this_passes = self.stuff.this_passes collector.collect() # collecting collector.count() # let's see what we got collector.increase() # counting_2 collector.increase() # counting_3 collector.done() # counting_done self.assertEqual(collector.state, 'waiting') # # same as above but with states and therefore stateless embedding states_remap[2]['children'] = count_states transitions.append(['increase', 'counting%s1' % State.separator, 'counting%s2' % State.separator]) transitions.append(['increase', 'counting%s2' % State.separator, 'counting%s3' % State.separator]) transitions.append(['done', 'counting%s3' % State.separator, 'waiting']) collector = self.stuff.machine_cls(states=states_remap, transitions=transitions, initial='waiting') collector.collect() # collecting collector.count() # let's see what we got collector.increase() # counting_2 collector.increase() # counting_3 collector.done() # counting_done self.assertEqual(collector.state, 'waiting') # check if counting_done was correctly omitted collector.add_transition('fail', '*', 'counting%sdone' % State.separator) with self.assertRaises(ValueError): collector.fail() def test_reuse_prepare(self): class Model: def __init__(self): self.prepared = False def preparation(self): self.prepared = True ms_model = Model() ms = Machine(ms_model, states=["C", "D"], transitions={"trigger": "go", "source": "*", "dest": "D", "prepare": "preparation"}, initial="C") ms_model.go() self.assertTrue(ms_model.prepared) m_model = Model() m = Machine(m_model, states=["A", "B", {"name": "NEST", "children": ms}]) m_model.to('NEST%sC' % State.separator) m_model.go() self.assertTrue(m_model.prepared) def test_reuse_self_reference(self): class Nested(Machine): def __init__(self, parent): self.parent = parent self.mock = MagicMock() states = ['1', '2'] transitions = [{'trigger': 'finish', 'source': '*', 'dest': '2', 'after': self.print_msg}] super(Nested, self).__init__(states=states, transitions=transitions, initial='1') def print_msg(self): self.mock() self.parent.print_top() class Top(Machine): def print_msg(self): self.mock() def __init__(self): self.nested = Nested(self) self.mock = MagicMock() states = ['A', {'name': 'B', 'children': self.nested}] transitions = [dict(trigger='print_top', source='*', dest='=', after=self.print_msg), dict(trigger='to_nested', source='*', dest='B{0}1'.format(State.separator))] super(Top, self).__init__(states=states, transitions=transitions, initial='A') top_machine = Top() top_machine.to_nested() top_machine.finish() self.assertEqual(top_machine, top_machine.nested.parent) self.assertTrue(top_machine.mock.called) self.assertTrue(top_machine.nested.mock.called) self.assertIsNot(top_machine.nested.get_state('2').on_enter, top_machine.get_state('B{0}2'.format(State.separator)).on_enter) transitions-0.7.2/tests/test_states.py0000644000076500000240000001257013530722244021105 0ustar alneumanstaff00000000000000from transitions import Machine from transitions.extensions.states import * from transitions.extensions.factory import LockedHierarchicalGraphMachine from time import sleep from unittest import TestCase from .test_graphviz import TestDiagramsLockedNested try: from unittest.mock import MagicMock except ImportError: from mock import MagicMock class TestTransitions(TestCase): def test_tags(self): @add_state_features(Tags) class CustomMachine(Machine): pass states = [{"name": "A", "tags": ["initial", "success", "error_state"]}] m = CustomMachine(states=states, initial='A') s = m.get_state(m.state) self.assertTrue(s.is_initial) self.assertTrue(s.is_success) self.assertTrue(s.is_error_state) self.assertFalse(s.is_not_available) def test_error(self): @add_state_features(Error) class CustomMachine(Machine): pass states = ['A', 'B', 'F', {'name': 'S1', 'tags': ['accepted']}, {'name': 'S2', 'accepted': True}] transitions = [['to_B', ['S1', 'S2'], 'B'], ['go', 'A', 'B'], ['fail', 'B', 'F'], ['success1', 'B', 'S2'], ['success2', 'B', 'S2']] m = CustomMachine(states=states, transitions=transitions, auto_transitions=False, initial='A') m.go() m.success1() self.assertTrue(m.get_state(m.state).is_accepted) m.to_B() m.success2() self.assertTrue(m.get_state(m.state).is_accepted) m.to_B() with self.assertRaises(MachineError): m.fail() def test_error_callback(self): @add_state_features(Error) class CustomMachine(Machine): pass mock_callback = MagicMock() states = ['A', {"name": "B", "on_enter": mock_callback}, 'C'] transitions = [ ["to_B", "A", "B"], ["to_C", "B", "C"], ] m = CustomMachine(states=states, transitions=transitions, auto_transitions=False, initial='A') m.to_B() self.assertEqual(m.state, "B") self.assertTrue(mock_callback.called) def test_timeout(self): mock = MagicMock() @add_state_features(Timeout) class CustomMachine(Machine): def timeout(self): mock() states = ['A', {'name': 'B', 'timeout': 0.3, 'on_timeout': 'timeout'}, {'name': 'C', 'timeout': 0.3, 'on_timeout': mock}] m = CustomMachine(states=states) m.to_B() m.to_A() sleep(0.4) self.assertFalse(mock.called) m.to_B() sleep(0.4) self.assertTrue(mock.called) m.to_C() sleep(0.4) self.assertEqual(mock.call_count, 2) with self.assertRaises(AttributeError): m.add_state({'name': 'D', 'timeout': 0.3}) def test_timeout_callbacks(self): timeout = MagicMock() notification = MagicMock() counter = MagicMock() @add_state_features(Timeout) class CustomMachine(Machine): pass class Model(object): def on_timeout_B(self): counter() def timeout(self): timeout() def notification(self): notification() def another_notification(self): notification() states = ['A', {'name': 'B', 'timeout': 0.05, 'on_timeout': 'timeout'}] model = Model() machine = CustomMachine(model=model, states=states, initial='A') model.to_B() sleep(0.1) self.assertTrue(timeout.called) self.assertTrue(counter.called) machine.get_state('B').add_callback('timeout', 'notification') machine.on_timeout_B('another_notification') model.to_B() sleep(0.1) self.assertEqual(timeout.call_count, 2) self.assertEqual(counter.call_count, 2) self.assertTrue(notification.called) machine.get_state('B').on_timeout = [] model.to_B() sleep(0.1) self.assertEqual(timeout.call_count, 2) self.assertEqual(notification.call_count, 2) def test_volatile(self): class TemporalState(object): def __init__(self): self.value = 5 def increase(self): self.value += 1 @add_state_features(Volatile) class CustomMachine(Machine): pass states = ['A', {'name': 'B', 'volatile': TemporalState}] m = CustomMachine(states=states, initial='A') m.to_B() self.assertEqual(m.scope.value, 5) # should call method of TemporalState m.scope.increase() self.assertEqual(m.scope.value, 6) # re-entering state should reset default volatile object m.to_A() self.assertFalse(hasattr(m.scope, 'value')) m.scope.foo = 'bar' m.to_B() # custom attribute of A should be gone self.assertFalse(hasattr(m.scope, 'foo')) # value should be reset self.assertEqual(m.scope.value, 5) class TestStatesDiagramsLockedNested(TestDiagramsLockedNested): def setUp(self): @add_state_features(Error, Timeout, Volatile) class CustomMachine(LockedHierarchicalGraphMachine): pass super(TestStatesDiagramsLockedNested, self).setUp() self.machine_cls = CustomMachine transitions-0.7.2/tests/test_threading.py0000644000076500000240000002441713537642734021566 0ustar alneumanstaff00000000000000try: from builtins import object except ImportError: pass import time from threading import Thread import logging from transitions.extensions import MachineFactory from transitions.extensions.nesting import NestedState from .test_nesting import TestTransitions as TestsNested from .test_core import TestTransitions as TestCore from .utils import Stuff, DummyModel, TestContext try: from unittest.mock import MagicMock except ImportError: from mock import MagicMock logger = logging.getLogger(__name__) logger.addHandler(logging.NullHandler()) def heavy_processing(): time.sleep(1) def heavy_checking(): time.sleep(1) return False class TestLockedTransitions(TestCore): def setUp(self): self.stuff = Stuff(machine_cls=MachineFactory.get_predefined(locked=True)) self.stuff.heavy_processing = heavy_processing self.stuff.machine.add_transition('forward', 'A', 'B', before='heavy_processing') def tearDown(self): pass def test_thread_access(self): thread = Thread(target=self.stuff.forward) thread.start() # give thread some time to start time.sleep(0.01) self.assertTrue(self.stuff.is_B()) def test_parallel_access(self): thread = Thread(target=self.stuff.forward) thread.start() # give thread some time to start time.sleep(0.01) self.stuff.to_C() # if 'forward' has not been locked, it is still running # we have to wait to be sure it is done time.sleep(1) self.assertEqual(self.stuff.state, "C") def test_parallel_deep(self): self.stuff.machine.add_transition('deep', source='*', dest='C', after='to_D') thread = Thread(target=self.stuff.deep) thread.start() time.sleep(0.01) self.stuff.to_C() time.sleep(1) self.assertEqual(self.stuff.state, "C") def test_conditional_access(self): self.stuff.heavy_checking = heavy_checking # checking takes 1s and returns False self.stuff.machine.add_transition('advance', 'A', 'B', conditions='heavy_checking') self.stuff.machine.add_transition('advance', 'A', 'D') t = Thread(target=self.stuff.advance) t.start() time.sleep(0.1) logger.info('Check if state transition done...') # Thread will release lock before Transition is finished res = self.stuff.is_D() time.sleep(0.5) self.assertTrue(res) def test_pickle(self): import sys if sys.version_info < (3, 4): import dill as pickle else: import pickle # go to non initial state B self.stuff.to_B() # pickle Stuff model dump = pickle.dumps(self.stuff) self.assertIsNotNone(dump) stuff2 = pickle.loads(dump) self.assertTrue(stuff2.is_B()) # check if machines of stuff and stuff2 are truly separated stuff2.to_A() self.stuff.to_C() self.assertTrue(stuff2.is_A()) thread = Thread(target=stuff2.forward) thread.start() # give thread some time to start time.sleep(0.01) # both objects should be in different states # and also not share locks begin = time.time() # stuff should not be locked and execute fast self.assertTrue(self.stuff.is_C()) fast = time.time() # stuff2 should be locked and take about 1 second # to be executed self.assertTrue(stuff2.is_B()) blocked = time.time() self.assertAlmostEqual(fast - begin, 0, delta=0.1) self.assertAlmostEqual(blocked - begin, 1, delta=0.1) def test_context_managers(self): class CounterContext(object): def __init__(self): self.counter = 0 self.level = 0 self.max = 0 super(CounterContext, self).__init__() def __enter__(self): self.counter += 1 self.level += 1 self.max = max(self.level, self.max) def __exit__(self, *exc): self.level -= 1 M = MachineFactory.get_predefined(locked=True) c = CounterContext() m = M(states=['A', 'B', 'C', 'D'], transitions=[['reset', '*', 'A']], initial='A', machine_context=c) m.get_triggers('A') self.assertEqual(c.max, 1) # was 3 before self.assertEqual(c.counter, 4) # was 72 (!) before # This test has been used to quantify the changes made in locking in version 0.5.0. # See https://github.com/tyarkoni/transitions/issues/167 for the results. # def test_performance(self): # import timeit # states = ['A', 'B', 'C'] # transitions = [['go', 'A', 'B'], ['go', 'B', 'C'], ['go', 'C', 'A']] # # M1 = MachineFactory.get_predefined() # M2 = MachineFactory.get_predefined(locked=True) # # def test_m1(): # m1 = M1(states=states, transitions=transitions, initial='A') # m1.get_triggers('A') # # def test_m2(): # m2 = M2(states=states, transitions=transitions, initial='A') # m2.get_triggers('A') # # t1 = timeit.timeit(test_m1, number=20000) # t2 = timeit.timeit(test_m2, number=20000) # self.assertAlmostEqual(t2/t1, 1, delta=0.5) class TestMultipleContexts(TestCore): def setUp(self): self.event_list = [] self.s1 = DummyModel() self.c1 = TestContext(event_list=self.event_list) self.c2 = TestContext(event_list=self.event_list) self.c3 = TestContext(event_list=self.event_list) self.c4 = TestContext(event_list=self.event_list) self.stuff = Stuff(machine_cls=MachineFactory.get_predefined(locked=True), extra_kwargs={ 'machine_context': [self.c1, self.c2] }) self.stuff.machine.add_model(self.s1, model_context=[self.c3, self.c4]) del self.event_list[:] self.stuff.machine.add_transition('forward', 'A', 'B') def tearDown(self): self.stuff.machine.remove_model(self.s1) def test_ordering(self): self.stuff.forward() # There are a lot of internal enter/exits, but the key is that the outermost are in the expected order self.assertEqual((self.c1, "enter"), self.event_list[0]) self.assertEqual((self.c2, "enter"), self.event_list[1]) self.assertEqual((self.c2, "exit"), self.event_list[-2]) self.assertEqual((self.c1, "exit"), self.event_list[-1]) def test_model_context(self): self.s1.forward() self.assertEqual((self.c1, "enter"), self.event_list[0]) self.assertEqual((self.c2, "enter"), self.event_list[1]) # Since there are a lot of internal enter/exits, we don't actually know how deep in the stack # to look for these. Should be able to correct when https://github.com/tyarkoni/transitions/issues/167 self.assertIn((self.c3, "enter"), self.event_list) self.assertIn((self.c4, "enter"), self.event_list) self.assertIn((self.c4, "exit"), self.event_list) self.assertIn((self.c3, "exit"), self.event_list) self.assertEqual((self.c2, "exit"), self.event_list[-2]) self.assertEqual((self.c1, "exit"), self.event_list[-1]) # Same as TestLockedTransition but with LockedHierarchicalMachine class TestLockedHierarchicalTransitions(TestsNested, TestLockedTransitions): def setUp(self): NestedState.separator = '_' states = ['A', 'B', {'name': 'C', 'children': ['1', '2', {'name': '3', 'children': ['a', 'b', 'c']}]}, 'D', 'E', 'F'] self.stuff = Stuff(states, machine_cls=MachineFactory.get_predefined(locked=True, nested=True)) self.stuff.heavy_processing = heavy_processing self.stuff.machine.add_transition('forward', '*', 'B', before='heavy_processing') def test_parallel_access(self): thread = Thread(target=self.stuff.forward) thread.start() # give thread some time to start time.sleep(0.01) self.stuff.to_C() # if 'forward' has not been locked, it is still running # we have to wait to be sure it is done time.sleep(1) self.assertEqual(self.stuff.state, "C") def test_callbacks(self): class MachineModel(self.stuff.machine_cls): def __init__(self): self.mock = MagicMock() super(MachineModel, self).__init__(self, states=['A', 'B', 'C']) def on_enter_A(self): self.mock() model = MachineModel() model.to_A() self.assertTrue(model.mock.called) def test_pickle(self): import sys if sys.version_info < (3, 4): import dill as pickle else: import pickle states = ['A', 'B', {'name': 'C', 'children': ['1', '2', {'name': '3', 'children': ['a', 'b', 'c']}]}, 'D', 'E', 'F'] transitions = [ {'trigger': 'walk', 'source': 'A', 'dest': 'B'}, {'trigger': 'run', 'source': 'B', 'dest': 'C'}, {'trigger': 'sprint', 'source': 'C', 'dest': 'D'} ] m = self.stuff.machine_cls(states=states, transitions=transitions, initial='A') m.heavy_processing = heavy_processing m.add_transition('forward', 'A', 'B', before='heavy_processing') # # go to non initial state B m.to_B() # pickle Stuff model dump = pickle.dumps(m) self.assertIsNotNone(dump) m2 = pickle.loads(dump) self.assertTrue(m2.is_B()) m2.to_C_3_a() m2.to_C_3_b() # check if machines of stuff and stuff2 are truly separated m2.to_A() m.to_C() self.assertTrue(m2.is_A()) thread = Thread(target=m2.forward) thread.start() # give thread some time to start time.sleep(0.01) # both objects should be in different states # and also not share locks begin = time.time() # stuff should not be locked and execute fast self.assertTrue(m.is_C()) fast = time.time() # stuff2 should be locked and take about 1 second # to be executed self.assertTrue(m2.is_B()) blocked = time.time() self.assertAlmostEqual(fast - begin, 0, delta=0.1) self.assertAlmostEqual(blocked - begin, 1, delta=0.1) transitions-0.7.2/tests/utils.py0000644000076500000240000000460113537642734017713 0ustar alneumanstaff00000000000000from transitions import Machine class Stuff(object): def __init__(self, states=None, machine_cls=Machine, extra_kwargs={}): self.state = None self.message = None states = ['A', 'B', 'C', 'D', 'E', 'F'] if states is None else states args = [self] kwargs = { 'states': states, 'initial': 'A', 'name': 'Test Machine', } kwargs.update(extra_kwargs) if machine_cls is not None: self.machine = machine_cls(*args, **kwargs) self.level = 1 self.transitions = 0 self.machine_cls = machine_cls @staticmethod def this_passes(): return True @staticmethod def this_fails(): return False @staticmethod def this_fails_by_default(boolean=False): return boolean @staticmethod def extract_boolean(event_data): return event_data.kwargs['boolean'] def goodbye(self): self.message = "So long, suckers!" def hello_world(self): self.message = "Hello World!" def greet(self): self.message = "Hi" def meet(self): self.message = "Nice to meet you" def hello_F(self): if not hasattr(self, 'message'): self.message = '' self.message += "Hello F!" def increase_level(self): self.level += 1 self.transitions += 1 def decrease_level(self): self.level -= 1 self.transitions += 1 def set_message(self, message="Hello World!"): self.message = message def extract_message(self, event_data): self.message = event_data.kwargs['message'] def on_enter_E(self, msg=None): self.message = "I am E!" if msg is None else msg def on_exit_E(self): self.exit_message = "E go home..." def on_enter_F(self): self.message = "I am F!" class InheritedStuff(Machine): def __init__(self, states, initial='A'): self.state = None Machine.__init__(self, states=states, initial=initial) @staticmethod def this_passes(): return True class DummyModel(object): pass class TestContext(object): def __init__(self, event_list): self._event_list = event_list def __enter__(self): self._event_list.append((self, "enter")) def __exit__(self, type, value, traceback): self._event_list.append((self, "exit")) transitions-0.7.2/tox.ini0000644000076500000240000000057613606027232016344 0ustar alneumanstaff00000000000000[tox] envlist = py27, py35, py36, py37, py38, codestyle, check-manifest skip_missing_interpreters = True [testenv] deps = -rrequirements.txt -rrequirements_diagrams.txt -rrequirements_test.txt commands = pytest [testenv:codestyle] deps = pycodestyle commands = pycodestyle --ignore=E501,W605 [testenv:check-manifest] deps = check-manifest commands = check-manifest transitions-0.7.2/transitions/0000755000076500000240000000000013606034310017371 5ustar alneumanstaff00000000000000transitions-0.7.2/transitions/__init__.py0000644000076500000240000000075613525231006021513 0ustar alneumanstaff00000000000000""" transitions ----------- A lightweight, object-oriented state machine implementation in Python. Compatible with Python 2.7+ and 3.0+. """ from __future__ import absolute_import from .version import __version__ from .core import (State, Transition, Event, EventData, Machine, MachineError) __copyright__ = "Copyright (c) 2017 Tal Yarkoni" __license__ = "MIT" __summary__ = "A lightweight, object-oriented finite state machine in Python" __uri__ = "https://github.com/tyarkoni/transitions" transitions-0.7.2/transitions/core.py0000644000076500000240000014653513606025620020715 0ustar alneumanstaff00000000000000""" transitions.core ---------------- This module contains the central parts of transitions which are the state machine logic, state and transition concepts. """ try: from builtins import object except ImportError: # python2 pass try: # Enums are supported for Python 3.4+ and Python 2.7 with enum34 package installed from enum import Enum, EnumMeta except ImportError: # If enum is not available, create dummy classes for type checks class Enum: pass class EnumMeta: pass import inspect import itertools import logging from collections import OrderedDict, defaultdict, deque from functools import partial from six import string_types _LOGGER = logging.getLogger(__name__) _LOGGER.addHandler(logging.NullHandler()) def listify(obj): """Wraps a passed object into a list in case it has not been a list, tuple before. Returns an empty list in case ``obj`` is None. Args: obj: instance to be converted into a list. Returns: list: May also return a tuple in case ``obj`` has been a tuple before. """ if obj is None: return [] return obj if isinstance(obj, (list, tuple, EnumMeta)) else [obj] def _get_trigger(model, machine, trigger_name, *args, **kwargs): """Convenience function added to the model to trigger events by name. Args: model (object): Model with assigned event trigger. machine (Machine): The machine containing the evaluated events. trigger_name (str): Name of the trigger to be called. *args: Variable length argument list which is passed to the triggered event. **kwargs: Arbitrary keyword arguments which is passed to the triggered event. Returns: bool: True if a transitions has been conducted or the trigger event has been queued. """ try: event = machine.events[trigger_name] except KeyError: raise AttributeError("Do not know event named '%s'." % trigger_name) return event.trigger(model, *args, **kwargs) def _prep_ordered_arg(desired_length, arguments=None): """Ensure list of arguments passed to add_ordered_transitions has the proper length. Expands the given arguments and apply same condition, callback to all transitions if only one has been given. Args: desired_length (int): The size of the resulting list arguments (optional[str, reference or list]): Parameters to be expanded. Returns: list: Parameter sets with the desired length. """ arguments = listify(arguments) if arguments is not None else [None] if len(arguments) != desired_length and len(arguments) != 1: raise ValueError("Argument length must be either 1 or the same length as " "the number of transitions.") if len(arguments) == 1: return arguments * desired_length return arguments class State(object): """A persistent representation of a state managed by a ``Machine``. Attributes: name (str): State name which is also assigned to the model(s). on_enter (list): Callbacks executed when a state is entered. on_exit (list): Callbacks executed when a state is exited. ignore_invalid_triggers (bool): Indicates if unhandled/invalid triggers should raise an exception. """ # A list of dynamic methods which can be resolved by a ``Machine`` instance for convenience functions. # Dynamic methods for states must always start with `on_`! dynamic_methods = ['on_enter', 'on_exit'] def __init__(self, name, on_enter=None, on_exit=None, ignore_invalid_triggers=None): """ Args: name (str): The name of the state on_enter (str or list): Optional callable(s) to trigger when a state is entered. Can be either a string providing the name of a callable, or a list of strings. on_exit (str or list): Optional callable(s) to trigger when a state is exited. Can be either a string providing the name of a callable, or a list of strings. ignore_invalid_triggers (Boolean): Optional flag to indicate if unhandled/invalid triggers should raise an exception """ self._name = name self.ignore_invalid_triggers = ignore_invalid_triggers self.on_enter = listify(on_enter) if on_enter else [] self.on_exit = listify(on_exit) if on_exit else [] @property def name(self): if isinstance(self._name, Enum): return self._name.name else: return self._name @property def value(self): return self._name def enter(self, event_data): """ Triggered when a state is entered. """ _LOGGER.debug("%sEntering state %s. Processing callbacks...", event_data.machine.name, self.name) for handle in self.on_enter: event_data.machine.callback(handle, event_data) _LOGGER.info("%sEntered state %s", event_data.machine.name, self.name) def exit(self, event_data): """ Triggered when a state is exited. """ _LOGGER.debug("%sExiting state %s. Processing callbacks...", event_data.machine.name, self.name) for handle in self.on_exit: event_data.machine.callback(handle, event_data) _LOGGER.info("%sExited state %s", event_data.machine.name, self.name) def add_callback(self, trigger, func): """ Add a new enter or exit callback. Args: trigger (str): The type of triggering event. Must be one of 'enter' or 'exit'. func (str): The name of the callback function. """ callback_list = getattr(self, 'on_' + trigger) callback_list.append(func) def __repr__(self): return "<%s('%s')@%s>" % (type(self).__name__, self.name, id(self)) class Condition(object): """ A helper class to call condition checks in the intended way. Attributes: func (callable): The function to call for the condition check target (bool): Indicates the target state--i.e., when True, the condition-checking callback should return True to pass, and when False, the callback should return False to pass. """ def __init__(self, func, target=True): """ Args: func (str): Name of the condition-checking callable target (bool): Indicates the target state--i.e., when True, the condition-checking callback should return True to pass, and when False, the callback should return False to pass. Notes: This class should not be initialized or called from outside a Transition instance, and exists at module level (rather than nesting under the transition class) only because of a bug in dill that prevents serialization under Python 2.7. """ self.func = func self.target = target def check(self, event_data): """ Check whether the condition passes. Args: event_data (EventData): An EventData instance to pass to the condition (if event sending is enabled) or to extract arguments from (if event sending is disabled). Also contains the data model attached to the current machine which is used to invoke the condition. """ predicate = event_data.machine.resolve_callable(self.func, event_data) if event_data.machine.send_event: return predicate(event_data) == self.target return predicate(*event_data.args, **event_data.kwargs) == self.target def __repr__(self): return "<%s(%s)@%s>" % (type(self).__name__, self.func, id(self)) class Transition(object): """ Representation of a transition managed by a ``Machine`` instance. Attributes: source (str): Source state of the transition. dest (str): Destination state of the transition. prepare (list): Callbacks executed before conditions checks. conditions (list): Callbacks evaluated to determine if the transition should be executed. before (list): Callbacks executed before the transition is executed but only if condition checks have been successful. after (list): Callbacks executed after the transition is executed but only if condition checks have been successful. """ # A list of dynamic methods which can be resolved by a ``Machine`` instance for convenience functions. dynamic_methods = ['before', 'after', 'prepare'] def __init__(self, source, dest, conditions=None, unless=None, before=None, after=None, prepare=None): """ Args: source (str): The name of the source State. dest (str): The name of the destination State. conditions (optional[str, callable or list]): Condition(s) that must pass in order for the transition to take place. Either a string providing the name of a callable, or a list of callables. For the transition to occur, ALL callables must return True. unless (optional[str, callable or list]): Condition(s) that must return False in order for the transition to occur. Behaves just like conditions arg otherwise. before (optional[str, callable or list]): callbacks to trigger before the transition. after (optional[str, callable or list]): callbacks to trigger after the transition. prepare (optional[str, callable or list]): callbacks to trigger before conditions are checked """ self.source = source self.dest = dest self.prepare = [] if prepare is None else listify(prepare) self.before = [] if before is None else listify(before) self.after = [] if after is None else listify(after) self.conditions = [] if conditions is not None: for cond in listify(conditions): self.conditions.append(Condition(cond)) if unless is not None: for cond in listify(unless): self.conditions.append(Condition(cond, target=False)) def execute(self, event_data): """ Execute the transition. Args: event_data: An instance of class EventData. Returns: boolean indicating whether or not the transition was successfully executed (True if successful, False if not). """ _LOGGER.debug("%sInitiating transition from state %s to state %s...", event_data.machine.name, self.source, self.dest) machine = event_data.machine for func in self.prepare: machine.callback(func, event_data) _LOGGER.debug("Executed callback '%s' before conditions.", func) for cond in self.conditions: if not cond.check(event_data): _LOGGER.debug("%sTransition condition failed: %s() does not return %s. Transition halted.", event_data.machine.name, cond.func, cond.target) return False for func in itertools.chain(machine.before_state_change, self.before): machine.callback(func, event_data) _LOGGER.debug("%sExecuted callback '%s' before transition.", event_data.machine.name, func) if self.dest: # if self.dest is None this is an internal transition with no actual state change self._change_state(event_data) for func in itertools.chain(self.after, machine.after_state_change): machine.callback(func, event_data) _LOGGER.debug("%sExecuted callback '%s' after transition.", event_data.machine.name, func) return True def _change_state(self, event_data): event_data.machine.get_state(self.source).exit(event_data) event_data.machine.set_state(self.dest, event_data.model) event_data.update(getattr(event_data.model, event_data.machine.model_attribute)) event_data.machine.get_state(self.dest).enter(event_data) def add_callback(self, trigger, func): """ Add a new before, after, or prepare callback. Args: trigger (str): The type of triggering event. Must be one of 'before', 'after' or 'prepare'. func (str): The name of the callback function. """ callback_list = getattr(self, trigger) callback_list.append(func) def __repr__(self): return "<%s('%s', '%s')@%s>" % (type(self).__name__, self.source, self.dest, id(self)) class EventData(object): """ Collection of relevant data related to the ongoing transition attempt. Attributes: state (State): The State from which the Event was triggered. event (Event): The triggering Event. machine (Machine): The current Machine instance. model (object): The model/object the machine is bound to. args (list): Optional positional arguments from trigger method to store internally for possible later use. kwargs (dict): Optional keyword arguments from trigger method to store internally for possible later use. transition (Transition): Currently active transition. Will be assigned during triggering. error (Error): In case a triggered event causes an Error, it is assigned here and passed on. result (bool): True in case a transition has been successful, False otherwise. """ def __init__(self, state, event, machine, model, args, kwargs): """ Args: state (State): The State from which the Event was triggered. event (Event): The triggering Event. machine (Machine): The current Machine instance. model (object): The model/object the machine is bound to. args (tuple): Optional positional arguments from trigger method to store internally for possible later use. kwargs (dict): Optional keyword arguments from trigger method to store internally for possible later use. """ self.state = state self.event = event self.machine = machine self.model = model self.args = args self.kwargs = kwargs self.transition = None self.error = None self.result = False def update(self, state): """ Updates the EventData object with the passed state. Attributes: state (State, str or Enum): The state object, enum member or string to assign to EventData. """ if not isinstance(state, State): self.state = self.machine.get_state(state) def __repr__(self): return "<%s('%s', %s)@%s>" % (type(self).__name__, self.state, getattr(self, 'transition'), id(self)) class Event(object): """ A collection of transitions assigned to the same trigger """ def __init__(self, name, machine): """ Args: name (str): The name of the event, which is also the name of the triggering callable (e.g., 'advance' implies an advance() method). machine (Machine): The current Machine instance. """ self.name = name self.machine = machine self.transitions = defaultdict(list) def add_transition(self, transition): """ Add a transition to the list of potential transitions. Args: transition (Transition): The Transition instance to add to the list. """ self.transitions[transition.source].append(transition) def trigger(self, model, *args, **kwargs): """ Serially execute all transitions that match the current state, halting as soon as one successfully completes. Args: args and kwargs: Optional positional or named arguments that will be passed onto the EventData object, enabling arbitrary state information to be passed on to downstream triggered functions. Returns: boolean indicating whether or not a transition was successfully executed (True if successful, False if not). """ func = partial(self._trigger, model, *args, **kwargs) # pylint: disable=protected-access # noinspection PyProtectedMember # Machine._process should not be called somewhere else. That's why it should not be exposed # to Machine users. return self.machine._process(func) def _trigger(self, model, *args, **kwargs): """ Internal trigger function called by the ``Machine`` instance. This should not be called directly but via the public method ``Machine.trigger``. """ state = self.machine.get_model_state(model) if state.name not in self.transitions: msg = "%sCan't trigger event %s from state %s!" % (self.machine.name, self.name, state.name) ignore = state.ignore_invalid_triggers if state.ignore_invalid_triggers is not None \ else self.machine.ignore_invalid_triggers if ignore: _LOGGER.warning(msg) return False else: raise MachineError(msg) event_data = EventData(state, self, self.machine, model, args=args, kwargs=kwargs) return self._process(event_data) def _process(self, event_data): for func in self.machine.prepare_event: self.machine.callback(func, event_data) _LOGGER.debug("Executed machine preparation callback '%s' before conditions.", func) try: for trans in self.transitions[event_data.state.name]: event_data.transition = trans if trans.execute(event_data): event_data.result = True break except Exception as err: event_data.error = err raise finally: for func in self.machine.finalize_event: self.machine.callback(func, event_data) _LOGGER.debug("Executed machine finalize callback '%s'.", func) return event_data.result def __repr__(self): return "<%s('%s')@%s>" % (type(self).__name__, self.name, id(self)) def add_callback(self, trigger, func): """ Add a new before or after callback to all available transitions. Args: trigger (str): The type of triggering event. Must be one of 'before', 'after' or 'prepare'. func (str): The name of the callback function. """ for trans in itertools.chain(*self.transitions.values()): trans.add_callback(trigger, func) class Machine(object): """ Machine manages states, transitions and models. In case it is initialized without a specific model (or specifically no model), it will also act as a model itself. Machine takes also care of decorating models with conveniences functions related to added transitions and states during runtime. Attributes: states (OrderedDict): Collection of all registered states. events (dict): Collection of transitions ordered by trigger/event. models (list): List of models attached to the machine. initial (str): Name of the initial state for new models. prepare_event (list): Callbacks executed when an event is triggered. before_state_change (list): Callbacks executed after condition checks but before transition is conducted. Callbacks will be executed BEFORE the custom callbacks assigned to the transition. after_state_change (list): Callbacks executed after the transition has been conducted. Callbacks will be executed AFTER the custom callbacks assigned to the transition. finalize_event (list): Callbacks will be executed after all transitions callbacks have been executed. Callbacks mentioned here will also be called if a transition or condition check raised an error. queued (bool): Whether transitions in callbacks should be executed immediately (False) or sequentially. send_event (bool): When True, any arguments passed to trigger methods will be wrapped in an EventData object, allowing indirect and encapsulated access to data. When False, all positional and keyword arguments will be passed directly to all callback methods. auto_transitions (bool): When True (default), every state will automatically have an associated to_{state}() convenience trigger in the base model. ignore_invalid_triggers (bool): When True, any calls to trigger methods that are not valid for the present state (e.g., calling an a_to_b() trigger when the current state is c) will be silently ignored rather than raising an invalid transition exception. name (str): Name of the ``Machine`` instance mainly used for easier log message distinction. """ separator = '_' # separates callback type from state/transition name wildcard_all = '*' # will be expanded to ALL states wildcard_same = '=' # will be expanded to source state state_cls = State transition_cls = Transition event_cls = Event def __init__(self, model='self', states=None, initial='initial', transitions=None, send_event=False, auto_transitions=True, ordered_transitions=False, ignore_invalid_triggers=None, before_state_change=None, after_state_change=None, name=None, queued=False, prepare_event=None, finalize_event=None, model_attribute='state', **kwargs): """ Args: model (object or list): The object(s) whose states we want to manage. If 'self', the current Machine instance will be used the model (i.e., all triggering events will be attached to the Machine itself). Note that an empty list is treated like no model. states (list or Enum): A list or enumeration of valid states. Each list element can be either a string, an enum member or a State instance. If string or enum member, a new generic State instance will be created that is named according to the string or enum member's name. initial (str, Enum or State): The initial state of the passed model[s]. transitions (list): An optional list of transitions. Each element is a dictionary of named arguments to be passed onto the Transition initializer. send_event (boolean): When True, any arguments passed to trigger methods will be wrapped in an EventData object, allowing indirect and encapsulated access to data. When False, all positional and keyword arguments will be passed directly to all callback methods. auto_transitions (boolean): When True (default), every state will automatically have an associated to_{state}() convenience trigger in the base model. ordered_transitions (boolean): Convenience argument that calls add_ordered_transitions() at the end of initialization if set to True. ignore_invalid_triggers: when True, any calls to trigger methods that are not valid for the present state (e.g., calling an a_to_b() trigger when the current state is c) will be silently ignored rather than raising an invalid transition exception. before_state_change: A callable called on every change state before the transition happened. It receives the very same args as normal callbacks. after_state_change: A callable called on every change state after the transition happened. It receives the very same args as normal callbacks. name: If a name is set, it will be used as a prefix for logger output queued (boolean): When True, processes transitions sequentially. A trigger executed in a state callback function will be queued and executed later. Due to the nature of the queued processing, all transitions will _always_ return True since conditional checks cannot be conducted at queueing time. prepare_event: A callable called on for before possible transitions will be processed. It receives the very same args as normal callbacks. finalize_event: A callable called on for each triggered event after transitions have been processed. This is also called when a transition raises an exception. **kwargs additional arguments passed to next class in MRO. This can be ignored in most cases. """ # calling super in case `Machine` is used as a mix in # all keyword arguments should be consumed by now if this is not the case try: super(Machine, self).__init__(**kwargs) except TypeError as err: raise ValueError('Passing arguments {0} caused an inheritance error: {1}'.format(kwargs.keys(), err)) # initialize protected attributes first self._queued = queued self._transition_queue = deque() self._before_state_change = [] self._after_state_change = [] self._prepare_event = [] self._finalize_event = [] self._initial = None self.states = OrderedDict() self.events = {} self.send_event = send_event self.auto_transitions = auto_transitions self.ignore_invalid_triggers = ignore_invalid_triggers self.prepare_event = prepare_event self.before_state_change = before_state_change self.after_state_change = after_state_change self.finalize_event = finalize_event self.name = name + ": " if name is not None else "" self.model_attribute = model_attribute self.models = [] if states is not None: self.add_states(states) if initial is not None: self.initial = initial if transitions is not None: self.add_transitions(transitions) if ordered_transitions: self.add_ordered_transitions() if model: self.add_model(model) def add_model(self, model, initial=None): """ Register a model with the state machine, initializing triggers and callbacks. """ models = listify(model) if initial is None: if self.initial is None: raise ValueError("No initial state configured for machine, must specify when adding model.") else: initial = self.initial for mod in models: mod = self if mod == 'self' else mod if mod not in self.models: self._checked_assignment(mod, 'trigger', partial(_get_trigger, mod, self)) for trigger, _ in self.events.items(): self._add_trigger_to_model(trigger, mod) for _, state in self.states.items(): self._add_model_to_state(state, mod) self.set_state(initial, model=mod) self.models.append(mod) def remove_model(self, model): """ Remove a model from the state machine. The model will still contain all previously added triggers and callbacks, but will not receive updates when states or transitions are added to the Machine. """ models = listify(model) for mod in models: self.models.remove(mod) @classmethod def _create_transition(cls, *args, **kwargs): return cls.transition_cls(*args, **kwargs) @classmethod def _create_event(cls, *args, **kwargs): return cls.event_cls(*args, **kwargs) @classmethod def _create_state(cls, *args, **kwargs): return cls.state_cls(*args, **kwargs) @property def initial(self): """ Return the initial state. """ return self._initial @initial.setter def initial(self, value): if isinstance(value, State): if value.name not in self.states: self.add_state(value) else: assert self._has_state(value) self._initial = value.name else: state_name = value.name if isinstance(value, Enum) else value if state_name not in self.states: self.add_state(state_name) self._initial = state_name @property def has_queue(self): """ Return boolean indicating if machine has queue or not """ return self._queued @property def model(self): """ List of models attached to the machine. For backwards compatibility, the property will return the model instance itself instead of the underlying list if there is only one attached to the machine. """ if len(self.models) == 1: return self.models[0] return self.models @property def before_state_change(self): """Callbacks executed after condition checks but before transition is conducted. Callbacks will be executed BEFORE the custom callbacks assigned to the transition.""" return self._before_state_change # this should make sure that _before_state_change is always a list @before_state_change.setter def before_state_change(self, value): self._before_state_change = listify(value) @property def after_state_change(self): """Callbacks executed after the transition has been conducted. Callbacks will be executed AFTER the custom callbacks assigned to the transition.""" return self._after_state_change # this should make sure that _after_state_change is always a list @after_state_change.setter def after_state_change(self, value): self._after_state_change = listify(value) @property def prepare_event(self): """Callbacks executed when an event is triggered.""" return self._prepare_event # this should make sure that prepare_event is always a list @prepare_event.setter def prepare_event(self, value): self._prepare_event = listify(value) @property def finalize_event(self): """Callbacks will be executed after all transitions callbacks have been executed. Callbacks mentioned here will also be called if a transition or condition check raised an error.""" return self._finalize_event # this should make sure that finalize_event is always a list @finalize_event.setter def finalize_event(self, value): self._finalize_event = listify(value) def get_state(self, state): """ Return the State instance with the passed name. """ if isinstance(state, Enum): state = state.name if state not in self.states: raise ValueError("State '%s' is not a registered state." % state) return self.states[state] # In theory this function could be static. This however causes some issues related to inheritance and # pickling down the chain. def is_state(self, state, model): """ Check whether the current state matches the named state. This function is not called directly but assigned as partials to model instances (e.g. is_A -> partial(_is_state, 'A', model)). Args: state (str): name of the checked state model: model to be checked Returns: bool: Whether the model's current state is state. """ return getattr(model, self.model_attribute) == state def get_model_state(self, model): return self.get_state(getattr(model, self.model_attribute)) def set_state(self, state, model=None): """ Set the current state. Args: state (str or Enum): value of setted state """ state = self.get_state(state) models = self.models if model is None else listify(model) for mod in models: setattr(mod, self.model_attribute, state.value) def add_state(self, *args, **kwargs): """ Alias for add_states. """ self.add_states(*args, **kwargs) def add_states(self, states, on_enter=None, on_exit=None, ignore_invalid_triggers=None, **kwargs): """ Add new state(s). Args: states (list, str, dict, Enum or State): a list, a State instance, the name of a new state, an enumeration (member) or a dict with keywords to pass on to the State initializer. If a list, each element can be a string, State or enumeration member. on_enter (str or list): callbacks to trigger when the state is entered. Only valid if first argument is string. on_exit (str or list): callbacks to trigger when the state is exited. Only valid if first argument is string. ignore_invalid_triggers: when True, any calls to trigger methods that are not valid for the present state (e.g., calling an a_to_b() trigger when the current state is c) will be silently ignored rather than raising an invalid transition exception. Note that this argument takes precedence over the same argument defined at the Machine level, and is in turn overridden by any ignore_invalid_triggers explicitly passed in an individual state's initialization arguments. **kwargs additional keyword arguments used by state mixins. """ ignore = ignore_invalid_triggers if ignore is None: ignore = self.ignore_invalid_triggers states = listify(states) for state in states: if isinstance(state, (string_types, Enum)): state = self._create_state( state, on_enter=on_enter, on_exit=on_exit, ignore_invalid_triggers=ignore, **kwargs) elif isinstance(state, dict): if 'ignore_invalid_triggers' not in state: state['ignore_invalid_triggers'] = ignore state = self._create_state(**state) self.states[state.name] = state for model in self.models: self._add_model_to_state(state, model) # Add automatic transitions after all states have been created if self.auto_transitions: for state in self.states.keys(): self.add_transition('to_%s' % state, self.wildcard_all, state) def _add_model_to_state(self, state, model): self._checked_assignment(model, 'is_%s' % state.name, partial(self.is_state, state.value, model)) # Add dynamic method callbacks (enter/exit) if there are existing bound methods in the model # except if they are already mentioned in 'on_enter/exit' of the defined state for callback in self.state_cls.dynamic_methods: method = "{0}_{1}".format(callback, state.name) if hasattr(model, method) and inspect.ismethod(getattr(model, method)) and \ method not in getattr(state, callback): state.add_callback(callback[3:], method) def _checked_assignment(self, model, name, func): if hasattr(model, name): _LOGGER.warning("%sModel already contains an attribute '%s'. Skip binding.", self.name, name) else: setattr(model, name, func) def _add_trigger_to_model(self, trigger, model): self._checked_assignment(model, trigger, partial(self.events[trigger].trigger, model)) def get_triggers(self, *args): """ Collects all triggers FROM certain states. Args: *args: Tuple of source states. Returns: list of transition/trigger names. """ states = set(args) return [t for (t, ev) in self.events.items() if any(state in ev.transitions for state in states)] def add_transition(self, trigger, source, dest, conditions=None, unless=None, before=None, after=None, prepare=None, **kwargs): """ Create a new Transition instance and add it to the internal list. Args: trigger (str): The name of the method that will trigger the transition. This will be attached to the currently specified model (e.g., passing trigger='advance' will create a new advance() method in the model that triggers the transition.) source(str or list): The name of the source state--i.e., the state we are transitioning away from. This can be a single state, a list of states or an asterisk for all states. dest (str): The name of the destination State--i.e., the state we are transitioning into. This can be a single state or an equal sign to specify that the transition should be reflexive so that the destination will be the same as the source for every given source. If dest is None, this transition will be an internal transition (exit/enter callbacks won't be processed). conditions (str or list): Condition(s) that must pass in order for the transition to take place. Either a list providing the name of a callable, or a list of callables. For the transition to occur, ALL callables must return True. unless (str or list): Condition(s) that must return False in order for the transition to occur. Behaves just like conditions arg otherwise. before (str or list): Callables to call before the transition. after (str or list): Callables to call after the transition. prepare (str or list): Callables to call when the trigger is activated **kwargs: Additional arguments which can be passed to the created transition. This is useful if you plan to extend Machine.Transition and require more parameters. """ if trigger == self.model_attribute: raise ValueError("Trigger name cannot be same as model attribute name.") if trigger not in self.events: self.events[trigger] = self._create_event(trigger, self) for model in self.models: self._add_trigger_to_model(trigger, model) if source == self.wildcard_all: source = list(self.states.keys()) else: source = [s.name if self._has_state(s) or isinstance(s, Enum) else s for s in listify(source)] for state in source: _dest = state if dest == self.wildcard_same else dest if _dest and self._has_state(_dest) or isinstance(_dest, Enum): _dest = _dest.name _trans = self._create_transition(state, _dest, conditions, unless, before, after, prepare, **kwargs) self.events[trigger].add_transition(_trans) def add_transitions(self, transitions): """ Add several transitions. Args: transitions (list): A list of transitions. """ for trans in listify(transitions): if isinstance(trans, list): self.add_transition(*trans) else: self.add_transition(**trans) def add_ordered_transitions(self, states=None, trigger='next_state', loop=True, loop_includes_initial=True, conditions=None, unless=None, before=None, after=None, prepare=None, **kwargs): """ Add a set of transitions that move linearly from state to state. Args: states (list): A list of state names defining the order of the transitions. E.g., ['A', 'B', 'C'] will generate transitions for A --> B, B --> C, and C --> A (if loop is True). If states is None, all states in the current instance will be used. trigger (str): The name of the trigger method that advances to the next state in the sequence. loop (boolean): Whether or not to add a transition from the last state to the first state. loop_includes_initial (boolean): If no initial state was defined in the machine, setting this to True will cause the _initial state placeholder to be included in the added transitions. conditions (str or list): Condition(s) that must pass in order for the transition to take place. Either a list providing the name of a callable, or a list of callables. For the transition to occur, ALL callables must return True. unless (str or list): Condition(s) that must return False in order for the transition to occur. Behaves just like conditions arg otherwise. before (str or list): Callables to call before the transition. after (str or list): Callables to call after the transition. prepare (str or list): Callables to call when the trigger is activated **kwargs: Additional arguments which can be passed to the created transition. This is useful if you plan to extend Machine.Transition and require more parameters. """ if states is None: states = list(self.states.keys()) # need to listify for Python3 len_transitions = len(states) if len_transitions < 2: raise ValueError("Can't create ordered transitions on a Machine " "with fewer than 2 states.") if not loop: len_transitions -= 1 # ensure all args are the proper length conditions = _prep_ordered_arg(len_transitions, conditions) unless = _prep_ordered_arg(len_transitions, unless) before = _prep_ordered_arg(len_transitions, before) after = _prep_ordered_arg(len_transitions, after) prepare = _prep_ordered_arg(len_transitions, prepare) # reorder list so that the initial state is actually the first one idx = states.index(self._initial) states = states[idx:] + states[:idx] for i in range(0, len(states) - 1): self.add_transition(trigger, states[i], states[i + 1], conditions=conditions[i], unless=unless[i], before=before[i], after=after[i], prepare=prepare[i], **kwargs) if loop: self.add_transition(trigger, states[-1], # omit initial if not loop_includes_initial states[0 if loop_includes_initial else 1], conditions=conditions[-1], unless=unless[-1], before=before[-1], after=after[-1], prepare=prepare[-1], **kwargs) def get_transitions(self, trigger="", source="*", dest="*"): """ Return the transitions from the Machine. Args: trigger (str): Trigger name of the transition. source (str): Limits removal to transitions from a certain state. dest (str): Limits removal to transitions to a certain state. """ if trigger: events = (self.events[trigger], ) else: events = self.events.values() transitions = [] for event in events: transitions.extend( itertools.chain.from_iterable(event.transitions.values())) return [transition for transition in transitions if (transition.source, transition.dest) == ( source if source != "*" else transition.source, dest if dest != "*" else transition.dest)] def remove_transition(self, trigger, source="*", dest="*"): """ Removes a transition from the Machine and all models. Args: trigger (str): Trigger name of the transition. source (str): Limits removal to transitions from a certain state. dest (str): Limits removal to transitions to a certain state. """ source = listify(source) if source != "*" else source dest = listify(dest) if dest != "*" else dest # outer comprehension, keeps events if inner comprehension returns lists with length > 0 tmp = {key: value for key, value in {k: [t for t in v # keep entries if source should not be filtered; same for dest. if (source != "*" and t.source not in source) or (dest != "*" and t.dest not in dest)] # }.items() takes the result of the inner comprehension and uses it # for the outer comprehension (see first line of comment) for k, v in self.events[trigger].transitions.items()}.items() if len(value) > 0} # convert dict back to defaultdict in case tmp is not empty if tmp: self.events[trigger].transitions = defaultdict(list, **tmp) # if no transition is left remove the trigger from the machine and all models else: for model in self.models: delattr(model, trigger) del self.events[trigger] def dispatch(self, trigger, *args, **kwargs): """ Trigger an event on all models assigned to the machine. Args: trigger (str): Event name *args (list): List of arguments passed to the event trigger **kwargs (dict): Dictionary of keyword arguments passed to the event trigger Returns: bool The truth value of all triggers combined with AND """ return all([getattr(model, trigger)(*args, **kwargs) for model in self.models]) def callback(self, func, event_data): """ Trigger a callback function with passed event_data parameters. In case func is a string, the callable will be resolved from the passed model in event_data. This function is not intended to be called directly but through state and transition callback definitions. Args: func (str or callable): The callback function. 1. First, if the func is callable, just call it 2. Second, we try to import string assuming it is a path to a func 3. Fallback to a model attribute event_data (EventData): An EventData instance to pass to the callback (if event sending is enabled) or to extract arguments from (if event sending is disabled). """ func = self.resolve_callable(func, event_data) if self.send_event: func(event_data) else: func(*event_data.args, **event_data.kwargs) @staticmethod def resolve_callable(func, event_data): """ Converts a model's method name or a path to a callable into a callable. If func is not a string it will be returned unaltered. Args: func (str or callable): Method name or a path to a callable event_data (EventData): Currently processed event Returns: callable function resolved from string or func """ if isinstance(func, string_types): try: func = getattr(event_data.model, func) except AttributeError: try: mod, name = func.rsplit('.', 1) m = __import__(mod) for n in mod.split('.')[1:]: m = getattr(m, n) func = getattr(m, name) except (ImportError, AttributeError, ValueError): raise AttributeError("Callable with name '%s' could neither be retrieved from the passed " "model nor imported from a module." % func) return func def _has_state(self, state): if isinstance(state, State): if state in self.states.values(): return True else: raise ValueError('State %s has not been added to the machine' % state.name) else: return False def _process(self, trigger): # default processing if not self.has_queue: if not self._transition_queue: # if trigger raises an Error, it has to be handled by the Machine.process caller return trigger() else: raise MachineError("Attempt to process events synchronously while transition queue is not empty!") # process queued events self._transition_queue.append(trigger) # another entry in the queue implies a running transition; skip immediate execution if len(self._transition_queue) > 1: return True # execute as long as transition queue is not empty while self._transition_queue: try: self._transition_queue[0]() self._transition_queue.popleft() except Exception: # if a transition raises an exception, clear queue and delegate exception handling self._transition_queue.clear() raise return True @classmethod def _identify_callback(cls, name): # Does the prefix match a known callback? for callback in itertools.chain(cls.state_cls.dynamic_methods, cls.transition_cls.dynamic_methods): if name.startswith(callback): callback_type = callback break else: return None, None # Extract the target by cutting the string after the type and separator target = name[len(callback_type) + len(cls.separator):] # Make sure there is actually a target to avoid index error and enforce _ as a separator if target == '' or name[len(callback_type)] != cls.separator: return None, None return callback_type, target def __getattr__(self, name): # Machine.__dict__ does not contain double underscore variables. # Class variables will be mangled. if name.startswith('__'): raise AttributeError("'{}' does not exist on " .format(name, id(self))) # Could be a callback callback_type, target = self._identify_callback(name) if callback_type is not None: if callback_type in self.transition_cls.dynamic_methods: if target not in self.events: raise AttributeError("event '{}' is not registered on " .format(target, id(self))) return partial(self.events[target].add_callback, callback_type) elif callback_type in self.state_cls.dynamic_methods: state = self.get_state(target) return partial(state.add_callback, callback_type[3:]) # Nothing matched raise AttributeError("'{}' does not exist on ".format(name, id(self))) class MachineError(Exception): """ MachineError is used for issues related to state transitions and current states. For instance, it is raised for invalid transitions or machine configuration issues. """ def __init__(self, value): super(MachineError, self).__init__(value) self.value = value def __str__(self): return repr(self.value) transitions-0.7.2/transitions/extensions/0000755000076500000240000000000013606034310021570 5ustar alneumanstaff00000000000000transitions-0.7.2/transitions/extensions/__init__.py0000644000076500000240000000112213373234646023714 0ustar alneumanstaff00000000000000""" transitions.extensions ---------------------- Additional functionality such as hierarchical (nested) machine support, Graphviz-based diagram creation and threadsafe execution of machine methods. Additionally, combinations of all those features are possible and made easier to access with a convenience factory. """ from .diagrams import GraphMachine from .nesting import HierarchicalMachine from .locking import LockedMachine from .factory import MachineFactory, HierarchicalGraphMachine, LockedHierarchicalGraphMachine from .factory import LockedHierarchicalMachine, LockedGraphMachine transitions-0.7.2/transitions/extensions/diagrams.py0000644000076500000240000002036613606025620023744 0ustar alneumanstaff00000000000000from transitions import Transition from transitions.extensions.markup import MarkupMachine import warnings import logging from functools import partial _LOGGER = logging.getLogger(__name__) _LOGGER.addHandler(logging.NullHandler()) # make deprecation warnings of transition visible for module users warnings.filterwarnings(action='default', message=r".*transitions version.*") # this is a workaround for dill issues when partials and super is used in conjunction # without it, Python 3.0 - 3.3 will not support pickling # https://github.com/pytransitions/transitions/issues/236 _super = super class TransitionGraphSupport(Transition): """ Transition used in conjunction with (Nested)Graphs to update graphs whenever a transition is conducted. """ def _change_state(self, event_data): graph = event_data.machine.model_graphs[event_data.model] graph.reset_styling() graph.set_previous_transition(self.source, self.dest) _super(TransitionGraphSupport, self)._change_state(event_data) # pylint: disable=protected-access class GraphMachine(MarkupMachine): """ Extends transitions.core.Machine with graph support. Is also used as a mixin for HierarchicalMachine. Attributes: _pickle_blacklist (list): Objects that should not/do not need to be pickled. transition_cls (cls): TransitionGraphSupport """ _pickle_blacklist = ['model_graphs'] transition_cls = TransitionGraphSupport machine_attributes = { 'directed': 'true', 'strict': 'false', 'rankdir': 'LR', } hierarchical_machine_attributes = { 'rankdir': 'TB', 'rank': 'source', 'nodesep': '1.5', 'compound': 'true' } style_attributes = { 'node': { '': {}, 'default': { 'shape': 'rectangle', 'style': 'rounded, filled', 'fillcolor': 'white', 'color': 'black', 'peripheries': '1' }, 'active': { 'color': 'red', 'fillcolor': 'darksalmon', 'peripheries': '2' }, 'previous': { 'color': 'blue', 'fillcolor': 'azure2', 'peripheries': '1' } }, 'edge': { '': {}, 'default': { 'color': 'black' }, 'previous': { 'color': 'blue' } }, 'graph': { '': {}, 'default': { 'color': 'black', 'fillcolor': 'white' }, 'previous': { 'color': 'blue', 'fillcolor': 'azure2', 'style': 'filled' }, 'active': { 'color': 'red', 'fillcolor': 'darksalmon', 'style': 'filled' }, } } # model_graphs cannot be pickled. Omit them. def __getstate__(self): # self.pkl_graphs = [(g.markup, g.custom_styles) for g in self.model_graphs] return {k: v for k, v in self.__dict__.items() if k not in self._pickle_blacklist} def __setstate__(self, state): self.__dict__.update(state) self.model_graphs = {} # reinitialize new model_graphs for model in self.models: try: _ = self._get_graph(model, title=self.title) except AttributeError as e: _LOGGER.warning("Graph for model could not be initialized after pickling: %s", e) def __init__(self, *args, **kwargs): # remove graph config from keywords self.title = kwargs.pop('title', 'State Machine') self.show_conditions = kwargs.pop('show_conditions', False) self.show_state_attributes = kwargs.pop('show_state_attributes', False) # in MarkupMachine this switch is called 'with_auto_transitions' # keep 'auto_transitions_markup' for backwards compatibility kwargs['auto_transitions_markup'] = kwargs.pop('show_auto_transitions', False) self.model_graphs = {} self.graph_cls = self._init_graphviz_engine(kwargs.pop('use_pygraphviz', True)) _LOGGER.debug("Using graph engine %s", self.graph_cls) _super(GraphMachine, self).__init__(*args, **kwargs) # Create graph at beginning for model in self.models: if hasattr(model, 'get_graph'): raise AttributeError('Model already has a get_graph attribute. Graph retrieval cannot be bound.') setattr(model, 'get_graph', partial(self._get_graph, model)) _ = model.get_graph(title=self.title, force_new=True) # initialises graph # for backwards compatibility assign get_combined_graph to get_graph # if model is not the machine if not hasattr(self, 'get_graph'): setattr(self, 'get_graph', self.get_combined_graph) def _init_graphviz_engine(self, use_pygraphviz): if use_pygraphviz: try: if hasattr(self.state_cls, 'separator'): from .diagrams_pygraphviz import NestedGraph as Graph self.machine_attributes.update(self.hierarchical_machine_attributes) else: from .diagrams_pygraphviz import Graph return Graph except ImportError: pass if hasattr(self.state_cls, 'separator'): from .diagrams_graphviz import NestedGraph as Graph self.machine_attributes.update(self.hierarchical_machine_attributes) else: from .diagrams_graphviz import Graph return Graph def _get_graph(self, model, title=None, force_new=False, show_roi=False): if force_new: grph = self.graph_cls(self, title=title if title is not None else self.title) self.model_graphs[model] = grph try: self.model_graphs[model].set_node_style(getattr(model, self.model_attribute), 'active') except AttributeError: _LOGGER.info("Could not set active state of diagram") try: m = self.model_graphs[model] except KeyError: _ = self._get_graph(model, title, force_new=True) m = self.model_graphs[model] m.roi_state = getattr(model, self.model_attribute) if show_roi else None return m.get_graph(title=title) def get_combined_graph(self, title=None, force_new=False, show_roi=False): """ This method is currently equivalent to 'get_graph' of the first machine's model. In future releases of transitions, this function will return a combined graph with active states of all models. Args: title (str): Title of the resulting graph. force_new (bool): If set to True, (re-)generate the model's graph. show_roi (bool): If set to True, only render states that are active and/or can be reached from the current state. Returns: AGraph of the first machine's model. """ _LOGGER.info('Returning graph of the first model. In future releases, this ' 'method will return a combined graph of all models.') return self._get_graph(self.models[0], title, force_new, show_roi) def add_states(self, states, on_enter=None, on_exit=None, ignore_invalid_triggers=None, **kwargs): """ Calls the base method and regenerates all models's graphs. """ _super(GraphMachine, self).add_states(states, on_enter=on_enter, on_exit=on_exit, ignore_invalid_triggers=ignore_invalid_triggers, **kwargs) for model in self.models: model.get_graph(force_new=True) def add_transition(self, trigger, source, dest, conditions=None, unless=None, before=None, after=None, prepare=None, **kwargs): """ Calls the base method and regenerates all models's graphs. """ _super(GraphMachine, self).add_transition(trigger, source, dest, conditions=conditions, unless=unless, before=before, after=after, prepare=prepare, **kwargs) for model in self.models: model.get_graph(force_new=True) transitions-0.7.2/transitions/extensions/diagrams_graphviz.py0000644000076500000240000002436713606025607025670 0ustar alneumanstaff00000000000000""" transitions.extensions.diagrams ------------------------------- Graphviz support for (nested) machines. This also includes partial views of currently valid transitions. """ import logging from functools import partial from collections import defaultdict from os.path import splitext from .nesting import NestedState try: import graphviz as pgv except ImportError: # pragma: no cover pgv = None _LOGGER = logging.getLogger(__name__) _LOGGER.addHandler(logging.NullHandler()) # this is a workaround for dill issues when partials and super is used in conjunction # without it, Python 3.0 - 3.3 will not support pickling # https://github.com/pytransitions/transitions/issues/236 _super = super class Graph(object): """ Graph creation for transitions.core.Machine. Attributes: machine (object): Reference to the related machine. """ def __init__(self, machine, title=None): self.machine = machine self.roi_state = None self.custom_styles = None self.reset_styling() self.generate(title) def set_previous_transition(self, src, dst): self.custom_styles['edge'][src][dst] = 'previous' self.set_node_style(src, 'previous') self.set_node_style(dst, 'active') def set_node_style(self, state, style): self.custom_styles['node'][state] = style def reset_styling(self): self.custom_styles = {'edge': defaultdict(lambda: defaultdict(str)), 'node': defaultdict(str)} def _add_nodes(self, states, container): for state in states: style = self.custom_styles['node'][state['name']] container.node(state['name'], label=self._convert_state_attributes(state), **self.machine.style_attributes['node'][style]) def _add_edges(self, transitions, container): edge_labels = defaultdict(lambda: defaultdict(list)) for transition in transitions: try: dst = transition['dest'] except KeyError: dst = transition['source'] edge_labels[transition['source']][dst].append(self._transition_label(transition)) for src, dests in edge_labels.items(): for dst, labels in dests.items(): style = self.custom_styles['edge'][src][dst] container.edge(src, dst, label=' | '.join(labels), **self.machine.style_attributes['edge'][style]) def _transition_label(self, tran): edge_label = tran.get('label', tran['trigger']) if 'dest' not in tran: edge_label += " [internal]" if self.machine.show_conditions and any(prop in tran for prop in ['conditions', 'unless']): x = '{edge_label} [{conditions}]'.format( edge_label=edge_label, conditions=' & '.join(tran.get('conditions', []) + ['!' + u for u in tran.get('unless', [])]), ) return x return edge_label def generate(self, title=None, roi_state=None): """ Generate a DOT graph with graphviz Args: roi_state (str): Optional, show only custom states and edges from roi_state """ if not pgv: # pragma: no cover raise Exception('AGraph diagram requires graphviz') title = '' if not title else title fsm_graph = pgv.Digraph(name=title, node_attr=self.machine.style_attributes['node']['default'], edge_attr=self.machine.style_attributes['edge']['default'], graph_attr=self.machine.style_attributes['graph']['default']) fsm_graph.graph_attr.update(**self.machine.machine_attributes) # For each state, draw a circle try: states = self.machine._markup.get('states', []) transitions = self.machine._markup.get('transitions', []) if roi_state: transitions = [t for t in transitions if t['source'] == roi_state or self.custom_styles['edge'][t['source']][t['dest']]] state_names = [t for trans in transitions for t in [trans['source'], trans.get('dest', trans['source'])]] state_names += [k for k, style in self.custom_styles['node'].items() if style] states = _filter_states(states, state_names) self._add_nodes(states, fsm_graph) self._add_edges(transitions, fsm_graph) except KeyError: _LOGGER.error("Graph creation incomplete!") setattr(fsm_graph, 'draw', partial(self.draw, fsm_graph)) return fsm_graph def get_graph(self, title=None): return self.generate(title, roi_state=self.roi_state) @staticmethod def draw(graph, filename, format=None, prog='dot', args=''): """ Generates and saves an image of the state machine using graphviz. Args: filename (str): path and name of image output format (str): Optional format of the output file Returns: """ graph.engine = prog try: filename, ext = splitext(filename) format = format if format is not None else ext[1:] graph.render(filename, format=format if format else 'png', cleanup=True) except TypeError: if format is None: raise ValueError("Paramter 'format' must not be None when filename is no valid file path.") filename.write(graph.pipe(format)) def _convert_state_attributes(self, state): label = state.get('label', state['name']) if self.machine.show_state_attributes: if 'tags' in state: label += ' [' + ', '.join(state['tags']) + ']' if 'on_enter' in state: label += '\l- enter:\l + ' + '\l + '.join(state['on_enter']) if 'on_exit' in state: label += '\l- exit:\l + ' + '\l + '.join(state['on_exit']) if 'timeout' in state: label += '\l- timeout(' + state['timeout'] + 's) -> (' + ', '.join(state['on_timeout']) + ')' return label class NestedGraph(Graph): """ Graph creation support for transitions.extensions.nested.HierarchicalGraphMachine. """ def __init__(self, *args, **kwargs): self._cluster_states = [] _super(NestedGraph, self).__init__(*args, **kwargs) def _add_nodes(self, states, container, prefix=''): for state in states: name = prefix + state['name'] label = self._convert_state_attributes(state) if 'children' in state: cluster_name = "cluster_" + name with container.subgraph(name=cluster_name, graph_attr=self.machine.style_attributes['graph']['default']) as sub: style = self.custom_styles['node'][name] sub.graph_attr.update(label=label, rank='source', **self.machine.style_attributes['graph'][style]) self._cluster_states.append(name) with sub.subgraph(name=cluster_name + '_root', graph_attr={'label': '', 'color': 'None', 'rank': 'min'}) as root: root.node(name + "_anchor", shape='point', fillcolor='black', width='0.1') self._add_nodes(state['children'], sub, prefix=prefix + state['name'] + NestedState.separator) else: style = self.custom_styles['node'][name] container.node(name, label=label, **self.machine.style_attributes['node'][style]) def _add_edges(self, transitions, container): edges_attr = defaultdict(lambda: defaultdict(dict)) for transition in transitions: # enable customizable labels label_pos = 'label' src = transition['source'] try: dst = transition['dest'] except KeyError: dst = src if edges_attr[src][dst]: attr = edges_attr[src][dst] attr[attr['label_pos']] = ' | '.join([edges_attr[src][dst][attr['label_pos']], self._transition_label(transition)]) continue else: attr = {} if src in self._cluster_states: attr['ltail'] = 'cluster_' + src src_name = src + "_anchor" label_pos = 'headlabel' else: src_name = src if dst in self._cluster_states: if not src.startswith(dst): attr['lhead'] = "cluster_" + dst label_pos = 'taillabel' if label_pos.startswith('l') else 'label' dst_name = dst + '_anchor' else: dst_name = dst # remove ltail when dst (ltail always starts with 'cluster_') is a child of src if 'ltail' in attr and dst_name.startswith(attr['ltail'][8:]): del attr['ltail'] # # remove ltail when dst is a child of src # if 'ltail' in edge_attr: # if _get_subgraph(container, edge_attr['ltail']).has_node(dst_name): # del edge_attr['ltail'] attr[label_pos] = self._transition_label(transition) attr['label_pos'] = label_pos attr['source'] = src_name attr['dest'] = dst_name edges_attr[src][dst] = attr for src, dests in edges_attr.items(): for dst, attr in dests.items(): del attr['label_pos'] style = self.custom_styles['edge'][src][dst] attr.update(**self.machine.style_attributes['edge'][style]) container.edge(attr.pop('source'), attr.pop('dest'), **attr) def _filter_states(states, state_names, prefix=None): prefix = prefix or [] result = [] for state in states: pref = prefix + [state['name']] if 'children' in state: state['children'] = _filter_states(state['children'], state_names, prefix=pref) result.append(state) elif NestedState.separator.join(pref) in state_names: result.append(state) return result transitions-0.7.2/transitions/extensions/diagrams_pygraphviz.py0000644000076500000240000002564013606025607026234 0ustar alneumanstaff00000000000000""" transitions.extensions.diagrams ------------------------------- Graphviz support for (nested) machines. This also includes partial views of currently valid transitions. """ import logging from .nesting import NestedState try: import pygraphviz as pgv except ImportError: # pragma: no cover pgv = None _LOGGER = logging.getLogger(__name__) _LOGGER.addHandler(logging.NullHandler()) # this is a workaround for dill issues when partials and super is used in conjunction # without it, Python 3.0 - 3.3 will not support pickling # https://github.com/pytransitions/transitions/issues/236 _super = super class Graph(object): """ Graph creation for transitions.core.Machine. Attributes: machine (object): Reference to the related machine. """ def __init__(self, machine, title=None): self.machine = machine self.fsm_graph = None self.roi_state = None self.generate(title) def _add_nodes(self, states, container): for state in states: shape = self.machine.style_attributes['node']['default']['shape'] container.add_node(state['name'], label=self._convert_state_attributes(state), shape=shape) def _add_edges(self, transitions, container): for transition in transitions: src = transition['source'] edge_attr = {'label': self._transition_label(transition)} try: dst = transition['dest'] except KeyError: dst = src if container.has_edge(src, dst): edge = container.get_edge(src, dst) edge.attr['label'] = edge.attr['label'] + ' | ' + edge_attr['label'] else: container.add_edge(src, dst, **edge_attr) def _transition_label(self, tran): edge_label = tran.get('label', tran['trigger']) if 'dest' not in tran: edge_label += " [internal]" if self.machine.show_conditions and any(prop in tran for prop in ['conditions', 'unless']): x = '{edge_label} [{conditions}]'.format( edge_label=edge_label, conditions=' & '.join(tran.get('conditions', []) + ['!' + u for u in tran.get('unless', [])]), ) return x return edge_label def generate(self, title=None): """ Generate a DOT graph with pygraphviz, returns an AGraph object """ if not pgv: # pragma: no cover raise Exception('AGraph diagram requires pygraphviz') title = '' if not title else title self.fsm_graph = pgv.AGraph(label=title, **self.machine.machine_attributes) self.fsm_graph.node_attr.update(self.machine.style_attributes['node']['default']) self.fsm_graph.edge_attr.update(self.machine.style_attributes['edge']['default']) # For each state, draw a circle self._add_nodes(self.machine._markup.get('states', []), self.fsm_graph) self._add_edges(self.machine._markup.get('transitions', []), self.fsm_graph) setattr(self.fsm_graph, 'style_attributes', self.machine.style_attributes) return self.fsm_graph def get_graph(self, title=None): if title: self.fsm_graph.graph_attr['label'] = title if self.roi_state: filtered = self.fsm_graph.copy() kept_nodes = set() active_state = self.roi_state if filtered.has_node(self.roi_state) else self.roi_state + '_anchor' kept_nodes.add(active_state) # remove all edges that have no connection to the currently active state for edge in filtered.edges(): if active_state not in edge: filtered.delete_edge(edge) # find the ingoing edge by color; remove the rest for edge in filtered.in_edges(active_state): if edge.attr['color'] == self.fsm_graph.style_attributes['edge']['previous']['color']: kept_nodes.add(edge[0]) else: filtered.delete_edge(edge) # remove outgoing edges from children for edge in filtered.out_edges_iter(active_state): kept_nodes.add(edge[1]) for node in filtered.nodes(): if node not in kept_nodes: filtered.delete_node(node) return filtered else: return self.fsm_graph def _convert_state_attributes(self, state): label = state.get('label', state['name']) if self.machine.show_state_attributes: if 'tags' in state: label += ' [' + ', '.join(state['tags']) + ']' if 'on_enter' in state: label += '\l- enter:\l + ' + '\l + '.join(state['on_enter']) if 'on_exit' in state: label += '\l- exit:\l + ' + '\l + '.join(state['on_exit']) if 'timeout' in state: label += '\l- timeout(' + state['timeout'] + 's) -> (' + ', '.join(state['on_timeout']) + ')' return label def set_node_style(self, state, style): node = self.fsm_graph.get_node(state) style_attr = self.fsm_graph.style_attributes.get('node', {}).get(style) node.attr.update(style_attr) def set_previous_transition(self, src, dst): try: edge = self.fsm_graph.get_edge(src, dst) except KeyError: self.fsm_graph.add_edge(src, dst) edge = self.fsm_graph.get_edge(src, dst) style_attr = self.fsm_graph.style_attributes.get('edge', {}).get('previous') edge.attr.update(style_attr) self.set_node_style(src, 'previous') self.set_node_style(dst, 'active') def reset_styling(self): for edge in self.fsm_graph.edges_iter(): style_attr = self.fsm_graph.style_attributes.get('edge', {}).get('default') edge.attr.update(style_attr) for node in self.fsm_graph.nodes_iter(): if 'point' not in node.attr['shape']: style_attr = self.fsm_graph.style_attributes.get('node', {}).get('default') node.attr.update(style_attr) for sub_graph in self.fsm_graph.subgraphs_iter(): style_attr = self.fsm_graph.style_attributes.get('graph', {}).get('default') sub_graph.graph_attr.update(style_attr) class NestedGraph(Graph): """ Graph creation support for transitions.extensions.nested.HierarchicalGraphMachine. """ def __init__(self, *args, **kwargs): self.seen_transitions = [] _super(NestedGraph, self).__init__(*args, **kwargs) # self.style_attributes['edge']['default']['minlen'] = 2 def _add_nodes(self, states, container, prefix=''): for state in states: name = prefix + state['name'] label = self._convert_state_attributes(state) if 'children' in state: cluster_name = "cluster_" + name sub = container.add_subgraph(name=cluster_name, label=label, rank='source', **self.machine.style_attributes['graph']['default']) root_container = sub.add_subgraph(name=cluster_name + '_root', label='', color=None, rank='min') # child_container = sub.add_subgraph(name=cluster_name + '_child', label='', color=None) root_container.add_node(name + "_anchor", shape='point', fillcolor='black', width='0.1') self._add_nodes(state['children'], sub, prefix=prefix + state['name'] + NestedState.separator) else: container.add_node(name, label=label, shape=self.machine.style_attributes['node']['default']['shape']) def _add_edges(self, transitions, container): # for sub in container.subgraphs_iter(): # events = self._add_edges(transitions, sub) for transition in transitions: # enable customizable labels label_pos = 'label' src = transition['source'] try: dst = transition['dest'] except KeyError: dst = src edge_attr = {} if _get_subgraph(container, 'cluster_' + src) is not None: edge_attr['ltail'] = 'cluster_' + src src_name = src + "_anchor" label_pos = 'headlabel' else: src_name = src dst_graph = _get_subgraph(container, 'cluster_' + dst) if dst_graph is not None: if not src.startswith(dst): edge_attr['lhead'] = "cluster_" + dst label_pos = 'taillabel' if label_pos.startswith('l') else 'label' dst_name = dst + '_anchor' else: dst_name = dst # remove ltail when dst is a child of src if 'ltail' in edge_attr: if _get_subgraph(container, edge_attr['ltail']).has_node(dst_name): del edge_attr['ltail'] edge_attr[label_pos] = self._transition_label(transition) if container.has_edge(src_name, dst_name): edge = container.get_edge(src_name, dst_name) edge.attr[label_pos] += ' | ' + edge_attr[label_pos] else: container.add_edge(src_name, dst_name, **edge_attr) def set_node_style(self, state, style): try: node = self.fsm_graph.get_node(state) style_attr = self.fsm_graph.style_attributes.get('node', {}).get(style) node.attr.update(style_attr) except KeyError: subgraph = _get_subgraph(self.fsm_graph, 'cluster_' + state) style_attr = self.fsm_graph.style_attributes.get('graph', {}).get(style) subgraph.graph_attr.update(style_attr) def set_previous_transition(self, src, dst): try: edge = self.fsm_graph.get_edge(src, dst) except KeyError: _src = src _dst = dst if _get_subgraph(self.fsm_graph, 'cluster_' + src): _src += '_anchor' if _get_subgraph(self.fsm_graph, 'cluster_' + dst): _dst += '_anchor' try: edge = self.fsm_graph.get_edge(_src, _dst) except KeyError: self.fsm_graph.add_edge(_src, _dst) edge = self.fsm_graph.get_edge(_src, _dst) style_attr = self.fsm_graph.style_attributes.get('edge', {}).get('previous') edge.attr.update(style_attr) self.set_node_style(src, 'previous') self.set_node_style(dst, 'active') def _get_subgraph(graph, name): """ Searches for subgraphs in a graph. Args: g (AGraph): Container to be searched. name (str): Name of the cluster. Returns: AGraph if a cluster called 'name' exists else None """ sub_graph = graph.get_subgraph(name) if sub_graph: return sub_graph for sub in graph.subgraphs_iter(): sub_graph = _get_subgraph(sub, name) if sub_graph: return sub_graph return None transitions-0.7.2/transitions/extensions/factory.py0000644000076500000240000000561613530722244023627 0ustar alneumanstaff00000000000000""" transitions.extensions.factory ------------------------------ This module contains the definitions of classes which combine the functionality of transitions' extension modules. These classes can be accessed by names as well as through a static convenience factory object. """ from ..core import Machine from .nesting import HierarchicalMachine, NestedTransition, NestedEvent from .locking import LockedMachine, LockedEvent from .diagrams import GraphMachine, TransitionGraphSupport from .markup import MarkupMachine class MachineFactory(object): """ Convenience factory for machine class retrieval. """ # get one of the predefined classes which fulfill the criteria @staticmethod def get_predefined(graph=False, nested=False, locked=False): """ A function to retrieve machine classes by required functionality. Args: graph (bool): Whether the returned class should contain graph support. nested: Whether the returned machine class should support nested states. locked: Whether the returned class should facilitate locks for threadsafety. Returns (class): A machine class with the specified features. """ return _CLASS_MAP[(graph, nested, locked)] class NestedGraphTransition(TransitionGraphSupport, NestedTransition): """ A transition type to be used with (subclasses of) `HierarchicalGraphMachine` and `LockedHierarchicalGraphMachine`. """ pass class LockedNestedEvent(LockedEvent, NestedEvent): """ An event type to be used with (subclasses of) `LockedHierarchicalMachine` and `LockedHierarchicalGraphMachine`. """ pass class HierarchicalMarkupMachine(MarkupMachine, HierarchicalMachine): pass class HierarchicalGraphMachine(GraphMachine, HierarchicalMarkupMachine): """ A hierarchical state machine with graph support. """ transition_cls = NestedGraphTransition class LockedHierarchicalMachine(LockedMachine, HierarchicalMachine): """ A threadsafe hierarchical machine. """ event_cls = LockedNestedEvent class LockedGraphMachine(GraphMachine, LockedMachine): """ A threadsafe machine with graph support. """ pass class LockedHierarchicalGraphMachine(GraphMachine, LockedMachine, HierarchicalMarkupMachine): """ A threadsafe hierarchical machine with graph support. """ transition_cls = NestedGraphTransition event_cls = LockedNestedEvent # 3d tuple (graph, nested, locked) _CLASS_MAP = { (False, False, False): Machine, (False, False, True): LockedMachine, (False, True, False): HierarchicalMachine, (False, True, True): LockedHierarchicalMachine, (True, False, False): GraphMachine, (True, False, True): LockedGraphMachine, (True, True, False): HierarchicalGraphMachine, (True, True, True): LockedHierarchicalGraphMachine } transitions-0.7.2/transitions/extensions/locking.py0000644000076500000240000001412313605314437023603 0ustar alneumanstaff00000000000000""" transitions.extensions.factory ------------------------------ Adds locking to machine methods as well as model functions that trigger events. Additionally, the user can inject her/his own context manager into the machine if required. """ from collections import defaultdict from functools import partial from threading import Lock import inspect import warnings import logging from transitions.core import Machine, Event, listify _LOGGER = logging.getLogger(__name__) _LOGGER.addHandler(logging.NullHandler()) # this is a workaround for dill issues when partials and super is used in conjunction # without it, Python 3.0 - 3.3 will not support pickling # https://github.com/pytransitions/transitions/issues/236 _super = super try: from contextlib import nested # Python 2 from thread import get_ident # with nested statements now raise a DeprecationWarning. Should be replaced with ExitStack-like approaches. warnings.simplefilter('ignore', DeprecationWarning) except ImportError: from contextlib import ExitStack, contextmanager from threading import get_ident @contextmanager def nested(*contexts): """ Reimplementation of nested in Python 3. """ with ExitStack() as stack: for ctx in contexts: stack.enter_context(ctx) yield contexts class PicklableLock(object): """ A wrapper for threading.Lock which discards its state during pickling and is reinitialized unlocked when unpickled. """ def __init__(self): self.lock = Lock() def __getstate__(self): return '' def __setstate__(self, value): return self.__init__() def __enter__(self): self.lock.__enter__() def __exit__(self, exc_type, exc_val, exc_tb): self.lock.__exit__(exc_type, exc_val, exc_tb) class LockedEvent(Event): """ An event type which uses the parent's machine context map when triggered. """ def trigger(self, model, *args, **kwargs): """ Extends transitions.core.Event.trigger by using locks/machine contexts. """ # pylint: disable=protected-access # noinspection PyProtectedMember # LockedMachine._locked should not be called somewhere else. That's why it should not be exposed # to Machine users. if self.machine._locked != get_ident(): with nested(*self.machine.model_context_map[model]): return _super(LockedEvent, self).trigger(model, *args, **kwargs) else: return _super(LockedEvent, self).trigger(model, *args, **kwargs) class LockedMachine(Machine): """ Machine class which manages contexts. In it's default version the machine uses a `threading.Lock` context to lock access to its methods and event triggers bound to model objects. Attributes: machine_context (dict): A dict of context managers to be entered whenever a machine method is called or an event is triggered. Contexts are managed for each model individually. """ event_cls = LockedEvent def __init__(self, *args, **kwargs): self._locked = 0 try: self.machine_context = listify(kwargs.pop('machine_context')) except KeyError: self.machine_context = [PicklableLock()] self.machine_context.append(self) self.model_context_map = defaultdict(list) _super(LockedMachine, self).__init__(*args, **kwargs) def add_model(self, model, initial=None, model_context=None): """ Extends `transitions.core.Machine.add_model` by `model_context` keyword. Args: model (list or object): A model (list) to be managed by the machine. initial (str, Enum or State): The initial state of the passed model[s]. model_context (list or object): If passed, assign the context (list) to the machines model specific context map. """ models = listify(model) model_context = listify(model_context) if model_context is not None else [] output = _super(LockedMachine, self).add_model(models, initial) for mod in models: mod = self if mod == 'self' else mod self.model_context_map[mod].extend(self.machine_context) self.model_context_map[mod].extend(model_context) return output def remove_model(self, model): """ Extends `transitions.core.Machine.remove_model` by removing model specific context maps from the machine when the model itself is removed. """ models = listify(model) for mod in models: del self.model_context_map[mod] return _super(LockedMachine, self).remove_model(models) def __getattribute__(self, item): get_attr = _super(LockedMachine, self).__getattribute__ tmp = get_attr(item) if not item.startswith('_') and inspect.ismethod(tmp): return partial(get_attr('_locked_method'), tmp) return tmp def __getattr__(self, item): try: return _super(LockedMachine, self).__getattribute__(item) except AttributeError: return _super(LockedMachine, self).__getattr__(item) # Determine if the returned method is a partial and make sure the returned partial has # not been created by Machine.__getattr__. # https://github.com/tyarkoni/transitions/issues/214 def _add_model_to_state(self, state, model): _super(LockedMachine, self)._add_model_to_state(state, model) # pylint: disable=protected-access for prefix in ['enter', 'exit']: callback = "on_{0}_".format(prefix) + state.name func = getattr(model, callback, None) if isinstance(func, partial) and func.func != state.add_callback: state.add_callback(prefix, callback) def _locked_method(self, func, *args, **kwargs): if self._locked != get_ident(): with nested(*self.machine_context): return func(*args, **kwargs) else: return func(*args, **kwargs) def __enter__(self): self._locked = get_ident() def __exit__(self, *exc): self._locked = 0 transitions-0.7.2/transitions/extensions/markup.py0000644000076500000240000001561613606025620023456 0ustar alneumanstaff00000000000000from six import string_types, iteritems from functools import partial import itertools import importlib from collections import defaultdict from ..core import Machine import numbers class MarkupMachine(Machine): # Special attributes such as NestedState._name/_parent or Transition._condition are handled differently state_attributes = ['on_exit', 'on_enter', 'ignore_invalid_triggers', 'timeout', 'on_timeout', 'tags'] transition_attributes = ['source', 'dest', 'prepare', 'before', 'after'] def __init__(self, *args, **kwargs): self._markup = kwargs.pop('markup', {}) self._auto_transitions_markup = kwargs.pop('auto_transitions_markup', False) self.skip_references = True if self._markup: models_markup = self._markup.pop('models', []) super(MarkupMachine, self).__init__(None, **self._markup) for m in models_markup: self._add_markup_model(m) else: super(MarkupMachine, self).__init__(*args, **kwargs) self._markup['initial'] = self.initial self._markup['before_state_change'] = [x for x in (rep(f) for f in self.before_state_change) if x] self._markup['after_state_change'] = [x for x in (rep(f) for f in self.before_state_change) if x] self._markup['prepare_event'] = [x for x in (rep(f) for f in self.prepare_event) if x] self._markup['finalize_event'] = [x for x in (rep(f) for f in self.finalize_event) if x] self._markup['name'] = "" if not self.name else self.name[:-2] self._markup['send_event'] = self.send_event self._markup['auto_transitions'] = self.auto_transitions self._markup['ignore_invalid_triggers'] = self.ignore_invalid_triggers self._markup['queued'] = self.has_queue @property def auto_transitions_markup(self): return self._auto_transitions_markup @auto_transitions_markup.setter def auto_transitions_markup(self, value): self._auto_transitions_markup = value self._markup['transitions'] = self._convert_transitions() @property def markup(self): self._markup['models'] = self._convert_models() return self._markup def add_transition(self, trigger, source, dest, conditions=None, unless=None, before=None, after=None, prepare=None, **kwargs): super(MarkupMachine, self).add_transition(trigger, source, dest, conditions=conditions, unless=unless, before=before, after=after, prepare=prepare, **kwargs) self._markup['transitions'] = self._convert_transitions() def add_states(self, states, on_enter=None, on_exit=None, ignore_invalid_triggers=None, **kwargs): super(MarkupMachine, self).add_states(states, on_enter=on_enter, on_exit=on_exit, ignore_invalid_triggers=ignore_invalid_triggers, **kwargs) self._markup['states'] = self._convert_states([s for s in self.states.values() if not getattr(s, 'parent', False)]) def _convert_states(self, states): markup_states = [] for state in states: s_def = _convert(state, self.state_attributes, self.skip_references) s_def['name'] = getattr(state, '_name', state.name) if getattr(state, 'children', False): s_def['children'] = self._convert_states(state.children) markup_states.append(s_def) return markup_states def _convert_transitions(self): markup_transitions = [] for event in self.events.values(): if self._omit_auto_transitions(event): continue for transitions in event.transitions.items(): for trans in transitions[1]: t_def = _convert(trans, self.transition_attributes, self.skip_references) t_def['trigger'] = event.name con = [x for x in (rep(f.func, self.skip_references) for f in trans.conditions if f.target) if x] unl = [x for x in (rep(f.func, self.skip_references) for f in trans.conditions if not f.target) if x] if con: t_def['conditions'] = con if unl: t_def['unless'] = unl markup_transitions.append(t_def) return markup_transitions def _add_markup_model(self, markup): initial = markup.get('state', None) if markup['class-name'] == 'self': self.add_model(self, initial) else: mod_name, cls_name = markup['class-name'].rsplit('.', 1) cls = getattr(importlib.import_module(mod_name), cls_name) self.add_model(cls(), initial) def _convert_models(self): models = [] for model in self.models: model_def = dict(state=getattr(model, self.model_attribute)) model_def['name'] = model.name if hasattr(model, 'name') else str(id(model)) model_def['class-name'] = 'self' if model == self else model.__module__ + "." + model.__class__.__name__ models.append(model_def) return models def _omit_auto_transitions(self, event): return self.auto_transitions_markup is False and self._is_auto_transition(event) # auto transition events commonly a) start with the 'to_' prefix, followed by b) the state name # and c) contain a transition from each state to the target state (including the target) def _is_auto_transition(self, event): if event.name.startswith('to_') and len(event.transitions) == len(self.states): state_name = event.name[len('to_'):] if state_name in self.states: return True return False def rep(func, skip_references=False): """ Return a string representation for `func`. """ if isinstance(func, string_types): return func if isinstance(func, numbers.Number): return str(func) if skip_references: return None try: return func.__name__ except AttributeError: pass if isinstance(func, partial): return "%s(%s)" % ( func.func.__name__, ", ".join(itertools.chain( (str(_) for _ in func.args), ("%s=%s" % (key, value) for key, value in iteritems(func.keywords if func.keywords else {}))))) return str(func) def _convert(obj, attributes, skip): s = {} for key in attributes: val = getattr(obj, key, False) if not val: continue if isinstance(val, string_types): s[key] = val else: try: s[key] = [rep(v, skip) for v in iter(val)] except TypeError: s[key] = rep(val, skip) return s transitions-0.7.2/transitions/extensions/nesting.py0000644000076500000240000005652213606025620023627 0ustar alneumanstaff00000000000000# -*- coding: utf-8 -*- """ transitions.extensions.nesting ------------------------------ Adds the capability to work with nested states also known as hierarchical state machines. """ from copy import copy, deepcopy from functools import partial import logging from six import string_types from ..core import Machine, Transition, State, Event, listify, MachineError, EventData, Enum _LOGGER = logging.getLogger(__name__) _LOGGER.addHandler(logging.NullHandler()) # This is a workaround for dill issues when partials and super is used in conjunction # without it, Python 3.0 - 3.3 will not support pickling # https://github.com/pytransitions/transitions/issues/236 _super = super class FunctionWrapper(object): """ A wrapper to enable transitions' convenience function to_ for nested states. This allows to call model.to_A.s1.C() in case a custom separator has been chosen.""" def __init__(self, func, path): """ Args: func: Function to be called at the end of the path. path: If path is an empty string, assign function """ if path: self.add(func, path) self._func = None else: self._func = func def add(self, func, path): """ Assigns a `FunctionWrapper` as an attribute named like the next segment of the substates path. Args: func (callable): Function to be called at the end of the path. path (string): Remaining segment of the substate path. """ if path: name = path[0] if name[0].isdigit(): name = 's' + name if hasattr(self, name): getattr(self, name).add(func, path[1:]) else: setattr(self, name, FunctionWrapper(func, path[1:])) else: self._func = func def __call__(self, *args, **kwargs): return self._func(*args, **kwargs) class NestedState(State): """ A state which allows substates. Attributes: parent (NestedState): The parent of the current state. children (list): A list of child states of the current state. """ separator = '_' u""" Separator between the names of parent and child states. In case '_' is required for naming state, this value can be set to other values such as '.' or even unicode characters such as '↦' (limited to Python 3 though). """ def __init__(self, name, on_enter=None, on_exit=None, ignore_invalid_triggers=None, parent=None, initial=None): if parent is not None and isinstance(name, Enum): raise AttributeError("NestedState does not support nested enumerations.") self._initial = initial self._parent = None self.parent = parent _super(NestedState, self).__init__(name=name, on_enter=on_enter, on_exit=on_exit, ignore_invalid_triggers=ignore_invalid_triggers) self.children = [] @property def parent(self): """ The parent state of this state. """ return self._parent @parent.setter def parent(self, value): if value is not None: self._parent = value self._parent.children.append(self) @property def initial(self): """ When this state is entered it will automatically enter the child with this name if not None. """ try: return self.name + NestedState.separator + self._initial if self._initial else self._initial except TypeError: # we assume an Enum here return self.name + NestedState.separator + self._initial.name @initial.setter def initial(self, value): self._initial = value @property def level(self): """ Tracks how deeply nested this state is. This property is calculated from the state's parent (+1) or 0 when there is no parent. """ return self.parent.level + 1 if self.parent is not None else 0 @property def name(self): """ The computed name of this state. """ if self.parent: return self.parent.name + NestedState.separator + _super(NestedState, self).name return _super(NestedState, self).name @name.setter def name(self, value): self._name = value @property def value(self): return self.name if isinstance(self._name, string_types) else _super(NestedState, self).value def is_substate_of(self, state_name): """Check whether this state is a substate of a state named `state_name` Args: state_name (str): Name of the parent state to be checked Returns: bool True when `state_name` is a parent of this state """ temp_state = self while not temp_state.value == state_name and temp_state.level > 0: temp_state = temp_state.parent return temp_state.value == state_name def exit_nested(self, event_data, target_state): """ Tracks child states to exit when the states is exited itself. This should not be triggered by the user but will be handled by the hierarchical machine. Args: event_data (EventData): Event related data. target_state (NestedState): The state to be entered. Returns: int level of the currently investigated (sub)state. """ if self == target_state: self.exit(event_data) return self.level elif self.level > target_state.level: self.exit(event_data) return self.parent.exit_nested(event_data, target_state) elif self.level <= target_state.level: tmp_state = target_state while self.level != tmp_state.level: tmp_state = tmp_state.parent tmp_self = self while tmp_self.level > 0 and tmp_state.parent.name != tmp_self.parent.name: tmp_self.exit(event_data) tmp_self = tmp_self.parent tmp_state = tmp_state.parent if tmp_self == tmp_state: return tmp_self.level + 1 tmp_self.exit(event_data) return tmp_self.level def enter_nested(self, event_data, level=None): """ Tracks parent states to be entered when the states is entered itself. This should not be triggered by the user but will be handled by the hierarchical machine. Args: event_data (EventData): Event related data. level (int): The level of the currently entered parent. """ if level is not None and level <= self.level: if level != self.level: self.parent.enter_nested(event_data, level) self.enter(event_data) # Prevent deep copying of callback lists since these include either references to callables or # strings. Deep copying a method reference would lead to the creation of an entire new (model) object # (see https://github.com/pytransitions/transitions/issues/248) def __deepcopy__(self, memo): cls = self.__class__ result = cls.__new__(cls) memo[id(self)] = result for key, value in self.__dict__.items(): if key in cls.dynamic_methods: setattr(result, key, copy(value)) else: setattr(result, key, deepcopy(value, memo)) return result class NestedTransition(Transition): """ A transition which handles entering and leaving nested states. Attributes: dest (NestedState): The resolved transition destination in respect to initial states of nested states. """ def execute(self, event_data): """ Extends transitions.core.transitions to handle nested states. """ if self.dest is None: return _super(NestedTransition, self).execute(event_data) dest_state = event_data.machine.get_state(self.dest) while dest_state.initial: dest_state = event_data.machine.get_state(dest_state.initial) self.dest = dest_state.name return _super(NestedTransition, self).execute(event_data) # The actual state change method 'execute' in Transition was restructured to allow overriding def _change_state(self, event_data): machine = event_data.machine model = event_data.model dest_state = machine.get_state(self.dest) source_state = machine.get_model_state(model) lvl = source_state.exit_nested(event_data, dest_state) event_data.machine.set_state(self.dest, model) event_data.update(dest_state) dest_state.enter_nested(event_data, lvl) # Prevent deep copying of callback lists since these include either references to callable or # strings. Deep copying a method reference would lead to the creation of an entire new (model) object # (see https://github.com/pytransitions/transitions/issues/248) def __deepcopy__(self, memo): cls = self.__class__ result = cls.__new__(cls) memo[id(self)] = result for key, value in self.__dict__.items(): if key in cls.dynamic_methods: setattr(result, key, copy(value)) else: setattr(result, key, deepcopy(value, memo)) return result class NestedEvent(Event): """ An event type to work with nested states. """ def _trigger(self, model, *args, **kwargs): state = self.machine.get_model_state(model) while state.parent and state.name not in self.transitions: state = state.parent if state.name not in self.transitions: msg = "%sCan't trigger event %s from state %s!" % (self.machine.name, self.name, self.machine.get_model_state(model)) if self.machine.get_model_state(model).ignore_invalid_triggers: _LOGGER.warning(msg) else: raise MachineError(msg) event_data = EventData(state, self, self.machine, model, args=args, kwargs=kwargs) return self._process(event_data) class HierarchicalMachine(Machine): """ Extends transitions.core.Machine by capabilities to handle nested states. A hierarchical machine REQUIRES NestedStates (or any subclass of it) to operate. """ state_cls = NestedState transition_cls = NestedTransition event_cls = NestedEvent def __init__(self, *args, **kwargs): self._buffered_transitions = [] _super(HierarchicalMachine, self).__init__(*args, **kwargs) @Machine.initial.setter def initial(self, value): if isinstance(value, NestedState): if value.name not in self.states: self.add_state(value) else: assert self._has_state(value) state = value else: state_name = value.name if isinstance(value, Enum) else value if state_name not in self.states: self.add_state(state_name) state = self.get_state(state_name) if state.initial: self.initial = state.initial else: self._initial = state.name def add_model(self, model, initial=None): """ Extends transitions.core.Machine.add_model by applying a custom 'to' function to the added model. """ _super(HierarchicalMachine, self).add_model(model, initial=initial) models = listify(model) for mod in models: mod = self if mod == 'self' else mod # TODO: Remove 'mod != self' in 0.7.0 if hasattr(mod, 'to') and mod != self: _LOGGER.warning("%sModel already has a 'to'-method. It will NOT " "be overwritten by NestedMachine", self.name) else: to_func = partial(self.to_state, mod) setattr(mod, 'to', to_func) def is_state(self, state_name, model, allow_substates=False): """ Extends transitions.core.Machine.is_state with an additional parameter (allow_substates) to Args: state_name (str): Name of the checked state. model (class): The model to be investigated. allow_substates (bool): Whether substates should be allowed or not. Returns: bool Whether the passed model is in queried state (or a substate of it) or not. """ if not allow_substates: return getattr(model, self.model_attribute) == state_name return self.get_model_state(model).is_substate_of(state_name) def _traverse(self, states, on_enter=None, on_exit=None, ignore_invalid_triggers=None, parent=None, remap=None): """ Parses passed value to build a nested state structure recursively. Args: states (list, str, dict, or State): a list, a State instance, the name of a new state, or a dict with keywords to pass on to the State initializer. If a list, each element can be of any of the latter three types. on_enter (str or list): callbacks to trigger when the state is entered. Only valid if first argument is string. on_exit (str or list): callbacks to trigger when the state is exited. Only valid if first argument is string. ignore_invalid_triggers: when True, any calls to trigger methods that are not valid for the present state (e.g., calling an a_to_b() trigger when the current state is c) will be silently ignored rather than raising an invalid transition exception. Note that this argument takes precedence over the same argument defined at the Machine level, and is in turn overridden by any ignore_invalid_triggers explicitly passed in an individual state's initialization arguments. parent (NestedState or str): parent state for nested states. remap (dict): reassigns transitions named `key from nested machines to parent state `value`. Returns: list of new `NestedState` objects """ states = listify(states) new_states = [] ignore = ignore_invalid_triggers remap = {} if remap is None else remap parent = self.get_state(parent) if isinstance(parent, (string_types, Enum)) else parent if ignore is None: ignore = self.ignore_invalid_triggers for state in states: tmp_states = [] # other state representations are handled almost like in the base class but a parent parameter is added if isinstance(state, (string_types, Enum)): if state in remap: continue tmp_states.append(self._create_state(state, on_enter=on_enter, on_exit=on_exit, parent=parent, ignore_invalid_triggers=ignore)) elif isinstance(state, dict): if state['name'] in remap: continue # shallow copy the dictionary to alter/add some parameters state = copy(state) if 'ignore_invalid_triggers' not in state: state['ignore_invalid_triggers'] = ignore if 'parent' not in state: state['parent'] = parent try: state_children = state.pop('children') # throws KeyError when no children set state_remap = state.pop('remap', None) state_parent = self._create_state(**state) nested = self._traverse(state_children, parent=state_parent, remap=state_remap) tmp_states.append(state_parent) tmp_states.extend(nested) except KeyError: tmp_states.insert(0, self._create_state(**state)) elif isinstance(state, HierarchicalMachine): # set initial state of parent if it is None if parent.initial is None: parent.initial = state.initial # (deep) copy only states not mentioned in remap copied_states = [s for s in deepcopy(state.states).values() if s.name not in remap] # inner_states are the root states of the passed machine # which have be attached to the parent inner_states = [s for s in copied_states if s.level == 0] for inner in inner_states: inner.parent = parent tmp_states.extend(copied_states) for trigger, event in state.events.items(): if trigger.startswith('to_'): path = trigger[3:].split(NestedState.separator) # do not copy auto_transitions since they would not be valid anymore; # trigger and destination do not exist in the new environment if path[0] in remap: continue ppath = parent.name.split(NestedState.separator) path = ['to_' + ppath[0]] + ppath[1:] + path trigger = '.'.join(path) # (deep) copy transitions and # adjust all transition start and end points to new state names for transitions in deepcopy(event.transitions).values(): for transition in transitions: src = transition.source # transitions from remapped states will be filtered to prevent # unexpected behaviour in the parent machine if src in remap: continue dst = parent.name + NestedState.separator + transition.dest\ if transition.dest not in remap else remap[transition.dest] conditions, unless = [], [] for cond in transition.conditions: # split a list in two lists based on the accessors (cond.target) truth value (unless, conditions)[cond.target].append(cond.func) self._buffered_transitions.append({'trigger': trigger, 'source': parent.name + NestedState.separator + src, 'dest': dst, 'conditions': conditions, 'unless': unless, 'prepare': transition.prepare, 'before': transition.before, 'after': transition.after}) elif isinstance(state, NestedState): tmp_states.append(state) if state.children: tmp_states.extend(self._traverse(state.children, on_enter=on_enter, on_exit=on_exit, ignore_invalid_triggers=ignore_invalid_triggers, parent=state, remap=remap)) else: raise ValueError("%s is not an instance or subclass of NestedState " "required by HierarchicalMachine." % state) new_states.extend(tmp_states) duplicate_check = [] for new in new_states: if new.name in duplicate_check: # collect state names for the following error message state_names = [s.name for s in new_states] raise ValueError("State %s cannot be added since it is already in state list %s." % (new.name, state_names)) else: duplicate_check.append(new.name) return new_states def add_states(self, states, on_enter=None, on_exit=None, ignore_invalid_triggers=None, **kwargs): """ Extends transitions.core.Machine.add_states by calling traverse to parse possible substates first.""" # preprocess states to flatten the configuration and resolve nesting new_states = self._traverse(states, on_enter=on_enter, on_exit=on_exit, ignore_invalid_triggers=ignore_invalid_triggers, **kwargs) _super(HierarchicalMachine, self).add_states(new_states, on_enter=on_enter, on_exit=on_exit, ignore_invalid_triggers=ignore_invalid_triggers, **kwargs) while self._buffered_transitions: args = self._buffered_transitions.pop(0) self.add_transition(**args) def get_triggers(self, *args): """ Extends transitions.core.Machine.get_triggers to also include parent state triggers. """ # add parents to state set states = [] for state_name in args: state = self.get_state(state_name) while state.parent: states.append(state.parent.name) state = state.parent states.extend(args) return _super(HierarchicalMachine, self).get_triggers(*states) def _add_trigger_to_model(self, trigger, model): # FunctionWrappers are only necessary if a custom separator is used if trigger.startswith('to_') and NestedState.separator != '_': path = trigger[3:].split(NestedState.separator) trig_func = partial(self.events[trigger].trigger, model) if hasattr(model, 'to_' + path[0]): # add path to existing function wrapper getattr(model, 'to_' + path[0]).add(trig_func, path[1:]) else: # create a new function wrapper setattr(model, 'to_' + path[0], FunctionWrapper(trig_func, path[1:])) else: _super(HierarchicalMachine, self)._add_trigger_to_model(trigger, model) # pylint: disable=protected-access def on_enter(self, state_name, callback): """ Helper function to add callbacks to states in case a custom state separator is used. Args: state_name (str): Name of the state callback (str or callable): Function to be called. Strings will be resolved to model functions. """ self.get_state(state_name).add_callback('enter', callback) def on_exit(self, state_name, callback): """ Helper function to add callbacks to states in case a custom state separator is used. Args: state_name (str): Name of the state callback (str or callable): Function to be called. Strings will be resolved to model functions. """ self.get_state(state_name).add_callback('exit', callback) def to_state(self, model, state_name, *args, **kwargs): """ Helper function to add go to states in case a custom state separator is used. Args: model (class): The model that should be used. state_name (str): Name of the destination state. """ event = EventData(self.get_model_state(model), Event('to', self), self, model, args=args, kwargs=kwargs) self._create_transition(getattr(model, self.model_attribute), state_name).execute(event) transitions-0.7.2/transitions/extensions/states.py0000644000076500000240000001564013536646570023476 0ustar alneumanstaff00000000000000""" transitions.extensions.states ----------------------------- This module contains mix ins which can be used to extend state functionality. """ from threading import Timer import logging import inspect from ..core import MachineError, listify, State _LOGGER = logging.getLogger(__name__) _LOGGER.addHandler(logging.NullHandler()) class Tags(State): """ Allows states to be tagged. Attributes: tags (list): A list of tag strings. `State.is_` may be used to check if is in the list. """ def __init__(self, *args, **kwargs): """ Args: **kwargs: If kwargs contains `tags`, assign them to the attribute. """ self.tags = kwargs.pop('tags', []) super(Tags, self).__init__(*args, **kwargs) def __getattr__(self, item): if item.startswith('is_'): return item[3:] in self.tags return super(Tags, self).__getattribute__(item) class Error(Tags): """ This mix in builds upon tag and should be used INSTEAD of Tags if final states that have not been tagged with 'accepted' should throw an `MachineError`. """ def __init__(self, *args, **kwargs): """ Args: **kwargs: If kwargs contains the keywork `accepted` add the 'accepted' tag to a tag list which will be forwarded to the Tags constructor. """ tags = kwargs.get('tags', []) accepted = kwargs.pop('accepted', False) if accepted: tags.append('accepted') kwargs['tags'] = tags super(Error, self).__init__(*args, **kwargs) def enter(self, event_data): """ Extends transitions.core.State.enter. Throws a `MachineError` if there is no leaving transition from this state and 'accepted' is not in self.tags. """ if not event_data.machine.get_triggers(self.name) and not self.is_accepted: raise MachineError("Error state '{0}' reached!".format(self.name)) super(Error, self).enter(event_data) class Timeout(State): """ Adds timeout functionality to a state. Timeouts are handled model-specific. Attributes: timeout (float): Seconds after which a timeout function should be called. on_timeout (list): Functions to call when a timeout is triggered. """ dynamic_methods = ['on_timeout'] def __init__(self, *args, **kwargs): """ Args: **kwargs: If kwargs contain 'timeout', assign the float value to self.timeout. If timeout is set, 'on_timeout' needs to be passed with kwargs as well or an AttributeError will be thrown. If timeout is not passed or equal 0. """ self.timeout = kwargs.pop('timeout', 0) self._on_timeout = None if self.timeout > 0: try: self.on_timeout = kwargs.pop('on_timeout') except KeyError: raise AttributeError("Timeout state requires 'on_timeout' when timeout is set.") else: self._on_timeout = kwargs.pop('on_timeout', []) self.runner = {} super(Timeout, self).__init__(*args, **kwargs) def enter(self, event_data): """ Extends `transitions.core.State.enter` by starting a timeout timer for the current model when the state is entered and self.timeout is larger than 0. """ if self.timeout > 0: timer = Timer(self.timeout, self._process_timeout, args=(event_data,)) timer.setDaemon(True) timer.start() self.runner[id(event_data.model)] = timer super(Timeout, self).enter(event_data) def exit(self, event_data): """ Extends `transitions.core.State.exit` by canceling a timer for the current model. """ timer = self.runner.get(id(event_data.model), None) if timer is not None and timer.is_alive(): timer.cancel() super(Timeout, self).exit(event_data) def _process_timeout(self, event_data): _LOGGER.debug("%sTimeout state %s. Processing callbacks...", event_data.machine.name, self.name) for callback in self.on_timeout: event_data.machine.callback(callback, event_data) _LOGGER.info("%sTimeout state %s processed.", event_data.machine.name, self.name) @property def on_timeout(self): """ List of strings and callables to be called when the state timeouts. """ return self._on_timeout @on_timeout.setter def on_timeout(self, value): """ Listifies passed values and assigns them to on_timeout.""" self._on_timeout = listify(value) class Volatile(State): """ Adds scopes/temporal variables to the otherwise persistent state objects. Attributes: volatile_cls (cls): Class of the temporal object to be initiated. volatile_hook (str): Model attribute name which will contain the volatile instance. """ def __init__(self, *args, **kwargs): """ Args: **kwargs: If kwargs contains `volatile`, always create an instance of the passed class whenever the state is entered. The instance is assigned to a model attribute which can be passed with the kwargs keyword `hook`. If hook is not passed, the instance will be assigned to the 'attribute' scope. If `volatile` is not passed, an empty object will be assigned to the model's hook. """ self.volatile_cls = kwargs.pop('volatile', VolatileObject) self.volatile_hook = kwargs.pop('hook', 'scope') super(Volatile, self).__init__(*args, **kwargs) self.initialized = True def enter(self, event_data): """ Extends `transitions.core.State.enter` by creating a volatile object and assign it to the current model's hook. """ setattr(event_data.model, self.volatile_hook, self.volatile_cls()) super(Volatile, self).enter(event_data) def exit(self, event_data): """ Extends `transitions.core.State.exit` by deleting the temporal object from the model. """ super(Volatile, self).exit(event_data) try: delattr(event_data.model, self.volatile_hook) except AttributeError: pass def add_state_features(*args): """ State feature decorator. Should be used in conjunction with a custom Machine class. """ def _class_decorator(cls): class CustomState(type('CustomState', args, {}), cls.state_cls): """ The decorated State. It is based on the State class used by the decorated Machine. """ pass method_list = sum([c.dynamic_methods for c in inspect.getmro(CustomState) if hasattr(c, 'dynamic_methods')], []) CustomState.dynamic_methods = list(set(method_list)) cls.state_cls = CustomState return cls return _class_decorator class VolatileObject(object): """ Empty Python object which can be used to assign attributes to.""" pass transitions-0.7.2/transitions/version.py0000644000076500000240000000026013606026434021436 0ustar alneumanstaff00000000000000""" Contains the current version of transition which is used in setup.py and can also be used to determine transitions's version during runtime. """ __version__ = '0.7.2' transitions-0.7.2/transitions.egg-info/0000755000076500000240000000000013606034310021063 5ustar alneumanstaff00000000000000transitions-0.7.2/transitions.egg-info/PKG-INFO0000644000076500000240000020754713606034310022177 0ustar alneumanstaff00000000000000Metadata-Version: 2.1 Name: transitions Version: 0.7.2 Summary: A lightweight, object-oriented Python state machine implementation. Home-page: http://github.com/pytransitions/transitions Author: Tal Yarkoni Author-email: tyarkoni@gmail.com Maintainer: Alexander Neumann Maintainer-email: aleneum@gmail.com License: MIT Download-URL: https://github.com/pytransitions/transitions/archive/0.7.2.tar.gz Description: ## Quickstart They say [a good example is worth](https://www.google.com/webhp?ie=UTF-8#q=%22a+good+example+is+worth%22&start=20) 100 pages of API documentation, a million directives, or a thousand words. Well, "they" probably lie... but here's an example anyway: ```python from transitions import Machine import random class NarcolepticSuperhero(object): # Define some states. Most of the time, narcoleptic superheroes are just like # everyone else. Except for... states = ['asleep', 'hanging out', 'hungry', 'sweaty', 'saving the world'] def __init__(self, name): # No anonymous superheroes on my watch! Every narcoleptic superhero gets # a name. Any name at all. SleepyMan. SlumberGirl. You get the idea. self.name = name # What have we accomplished today? self.kittens_rescued = 0 # Initialize the state machine self.machine = Machine(model=self, states=NarcolepticSuperhero.states, initial='asleep') # Add some transitions. We could also define these using a static list of # dictionaries, as we did with states above, and then pass the list to # the Machine initializer as the transitions= argument. # At some point, every superhero must rise and shine. self.machine.add_transition(trigger='wake_up', source='asleep', dest='hanging out') # Superheroes need to keep in shape. self.machine.add_transition('work_out', 'hanging out', 'hungry') # Those calories won't replenish themselves! self.machine.add_transition('eat', 'hungry', 'hanging out') # Superheroes are always on call. ALWAYS. But they're not always # dressed in work-appropriate clothing. self.machine.add_transition('distress_call', '*', 'saving the world', before='change_into_super_secret_costume') # When they get off work, they're all sweaty and disgusting. But before # they do anything else, they have to meticulously log their latest # escapades. Because the legal department says so. self.machine.add_transition('complete_mission', 'saving the world', 'sweaty', after='update_journal') # Sweat is a disorder that can be remedied with water. # Unless you've had a particularly long day, in which case... bed time! self.machine.add_transition('clean_up', 'sweaty', 'asleep', conditions=['is_exhausted']) self.machine.add_transition('clean_up', 'sweaty', 'hanging out') # Our NarcolepticSuperhero can fall asleep at pretty much any time. self.machine.add_transition('nap', '*', 'asleep') def update_journal(self): """ Dear Diary, today I saved Mr. Whiskers. Again. """ self.kittens_rescued += 1 def is_exhausted(self): """ Basically a coin toss. """ return random.random() < 0.5 def change_into_super_secret_costume(self): print("Beauty, eh?") ``` There, now you've baked a state machine into `NarcolepticSuperhero`. Let's take him/her/it out for a spin... ```python >>> batman = NarcolepticSuperhero("Batman") >>> batman.state 'asleep' >>> batman.wake_up() >>> batman.state 'hanging out' >>> batman.nap() >>> batman.state 'asleep' >>> batman.clean_up() MachineError: "Can't trigger event clean_up from state asleep!" >>> batman.wake_up() >>> batman.work_out() >>> batman.state 'hungry' # Batman still hasn't done anything useful... >>> batman.kittens_rescued 0 # We now take you live to the scene of a horrific kitten entreement... >>> batman.distress_call() 'Beauty, eh?' >>> batman.state 'saving the world' # Back to the crib. >>> batman.complete_mission() >>> batman.state 'sweaty' >>> batman.clean_up() >>> batman.state 'asleep' # Too tired to shower! # Another productive day, Alfred. >>> batman.kittens_rescued 1 ``` ## The non-quickstart ### Basic initialization Getting a state machine up and running is pretty simple. Let's say you have the object `lump` (an instance of class `Matter`), and you want to manage its states: ```python class Matter(object): pass lump = Matter() ``` You can initialize a (_minimal_) working state machine bound to `lump` like this: ```python from transitions import Machine machine = Machine(model=lump, states=['solid', 'liquid', 'gas', 'plasma'], initial='solid') # Lump now has state! lump.state >>> 'solid' ``` I say “minimal”, because while this state machine is technically operational, it doesn't actually _do_ anything. It starts in the `'solid'` state, but won't ever move into another state, because no transitions are defined... yet! Let's try again. ```python # The states states=['solid', 'liquid', 'gas', 'plasma'] # And some transitions between states. We're lazy, so we'll leave out # the inverse phase transitions (freezing, condensation, etc.). transitions = [ { 'trigger': 'melt', 'source': 'solid', 'dest': 'liquid' }, { 'trigger': 'evaporate', 'source': 'liquid', 'dest': 'gas' }, { 'trigger': 'sublimate', 'source': 'solid', 'dest': 'gas' }, { 'trigger': 'ionize', 'source': 'gas', 'dest': 'plasma' } ] # Initialize machine = Machine(lump, states=states, transitions=transitions, initial='liquid') # Now lump maintains state... lump.state >>> 'liquid' # And that state can change... lump.evaporate() lump.state >>> 'gas' lump.trigger('ionize') lump.state >>> 'plasma' ``` Notice the shiny new methods attached to the `Matter` instance (`evaporate()`, `ionize()`, etc.). Each method triggers the corresponding transition. You don't have to explicitly define these methods anywhere; the name of each transition is bound to the model passed to the `Machine` initializer (in this case, `lump`). Additionally, there is a method called `trigger` now attached to your model. This method lets you execute transitions by name in case dynamic triggering is required. ### States The soul of any good state machine (and of many bad ones, no doubt) is a set of states. Above, we defined the valid model states by passing a list of strings to the `Machine` initializer. But internally, states are actually represented as `State` objects. You can initialize and modify States in a number of ways. Specifically, you can: - pass a string to the `Machine` initializer giving the name(s) of the state(s), or - directly initialize each new `State` object, or - pass a dictionary with initialization arguments The following snippets illustrate several ways to achieve the same goal: ```python # Create a list of 3 states to pass to the Machine # initializer. We can mix types; in this case, we # pass one State, one string, and one dict. states = [ State(name='solid'), 'liquid', { 'name': 'gas'} ] machine = Machine(lump, states) # This alternative example illustrates more explicit # addition of states and state callbacks, but the net # result is identical to the above. machine = Machine(lump) solid = State('solid') liquid = State('liquid') gas = State('gas') machine.add_states([solid, liquid, gas]) ``` States are initialized *once* when added to the machine and will persist until they are removed from it. In other words: if you alter the attributes of a state object, this change will NOT be reset the next time you enter that state. Have a look at how to [extend state features](#state-features) in case you require some other behaviour. #### Callbacks A `State` can also be associated with a list of `enter` and `exit` callbacks, which are called whenever the state machine enters or leaves that state. You can specify callbacks during initialization, or add them later. For convenience, whenever a new `State` is added to a `Machine`, the methods `on_enter_«state name»` and `on_exit_«state name»` are dynamically created on the Machine (not on the model!), which allow you to dynamically add new enter and exit callbacks later if you need them. ```python # Our old Matter class, now with a couple of new methods we # can trigger when entering or exit states. class Matter(object): def say_hello(self): print("hello, new state!") def say_goodbye(self): print("goodbye, old state!") lump = Matter() # Same states as above, but now we give StateA an exit callback states = [ State(name='solid', on_exit=['say_goodbye']), 'liquid', { 'name': 'gas' } ] machine = Machine(lump, states=states) machine.add_transition('sublimate', 'solid', 'gas') # Callbacks can also be added after initialization using # the dynamically added on_enter_ and on_exit_ methods. # Note that the initial call to add the callback is made # on the Machine and not on the model. machine.on_enter_gas('say_hello') # Test out the callbacks... machine.set_state('solid') lump.sublimate() >>> 'goodbye, old state!' >>> 'hello, new state!' ``` Note that `on_enter_«state name»` callback will *not* fire when a Machine is first initialized. For example if you have an `on_enter_A()` callback defined, and initialize the `Machine` with `initial='A'`, `on_enter_A()` will not be fired until the next time you enter state `A`. (If you need to make sure `on_enter_A()` fires at initialization, you can simply create a dummy initial state and then explicitly call `to_A()` inside the `__init__` method.) In addition to passing in callbacks when initializing a `State`, or adding them dynamically, it's also possible to define callbacks in the model class itself, which may increase code clarity. For example: ```python class Matter(object): def say_hello(self): print("hello, new state!") def say_goodbye(self): print("goodbye, old state!") def on_enter_A(self): print("We've just entered state A!") lump = Matter() machine = Machine(lump, states=['A', 'B', 'C']) ``` Now, any time `lump` transitions to state `A`, the `on_enter_A()` method defined in the `Matter` class will fire. #### Checking state You can always check the current state of the model by either: - inspecting the `.state` attribute, or - calling `is_«state name»()` And if you want to retrieve the actual `State` object for the current state, you can do that through the `Machine` instance's `get_state()` method. ```python lump.state >>> 'solid' lump.is_gas() >>> False lump.is_solid() >>> True machine.get_state(lump.state).name >>> 'solid' ``` If you'd like you track it using a different attribute, you could do that using the `model_attribute` argument while initializing the `Machine`. ```python lump = Matter() machine = Machine(lump, states=['solid', 'liquid', 'gas'], model='matter_state', initial='solid') lump.matter_state >>> 'solid' ``` #### Enumerations So far we have seen how we can give state names and use these names to work with our state machine. If you favour stricter typing and more IDE code completion (or you just can't type 'sesquipedalophobia' any longer because the word scares you) using [Enumerations](https://docs.python.org/3/library/enum.html) might be what you are looking for: ```python import enum # Python 2.7 users need to have 'enum34' installed from transitions import Machine class States(enum.Enum): ERROR = 0 RED = 1 YELLOW = 2 GREEN = 3 transitions = [['proceed', States.RED, States.YELLOW], ['proceed', States.YELLOW, States.GREEN], ['error', '*', States.ERROR]] m = Machine(states=States, transitions=transitions, initial=States.RED) assert m.is_RED() assert m.state is States.RED state = m.get_state(States.RED) # get transitions.State object print(state.name) # >>> RED m.proceed() m.proceed() assert m.is_GREEN() m.error() assert m.state is States.ERROR ``` You can mix enums and strings if you like (e.g. `[States.RED, 'ORANGE', States.YELLOW, States.GREEN]`) but note that internally, `transitions` will still handle states by name (`enum.Enum.name`). Thus, it is not possible to have the states `'GREEN'` and `States.GREEN` at the same time. ### Transitions Some of the above examples already illustrate the use of transitions in passing, but here we'll explore them in more detail. As with states, each transition is represented internally as its own object – an instance of class `Transition`. The quickest way to initialize a set of transitions is to pass a dictionary, or list of dictionaries, to the `Machine` initializer. We already saw this above: ```python transitions = [ { 'trigger': 'melt', 'source': 'solid', 'dest': 'liquid' }, { 'trigger': 'evaporate', 'source': 'liquid', 'dest': 'gas' }, { 'trigger': 'sublimate', 'source': 'solid', 'dest': 'gas' }, { 'trigger': 'ionize', 'source': 'gas', 'dest': 'plasma' } ] machine = Machine(model=Matter(), states=states, transitions=transitions) ``` Defining transitions in dictionaries has the benefit of clarity, but can be cumbersome. If you're after brevity, you might choose to define transitions using lists. Just make sure that the elements in each list are in the same order as the positional arguments in the `Transition` initialization (i.e., `trigger`, `source`, `destination`, etc.). The following list-of-lists is functionally equivalent to the list-of-dictionaries above: ```python transitions = [ ['melt', 'solid', 'liquid'], ['evaporate', 'liquid', 'gas'], ['sublimate', 'solid', 'gas'], ['ionize', 'gas', 'plasma'] ] ``` Alternatively, you can add transitions to a `Machine` after initialization: ```python machine = Machine(model=lump, states=states, initial='solid') machine.add_transition('melt', source='solid', dest='liquid') ``` The `trigger` argument defines the name of the new triggering method that gets attached to the base model. When this method is called, it will try to execute the transition: ```python >>> lump.melt() >>> lump.state 'liquid' ``` By default, calling an invalid trigger will raise an exception: ```python >>> lump.to_gas() >>> # This won't work because only objects in a solid state can melt >>> lump.melt() transitions.core.MachineError: "Can't trigger event melt from state gas!" ``` This behavior is generally desirable, since it helps alert you to problems in your code. But in some cases, you might want to silently ignore invalid triggers. You can do this by setting `ignore_invalid_triggers=True` (either on a state-by-state basis, or globally for all states): ```python >>> # Globally suppress invalid trigger exceptions >>> m = Machine(lump, states, initial='solid', ignore_invalid_triggers=True) >>> # ...or suppress for only one group of states >>> states = ['new_state1', 'new_state2'] >>> m.add_states(states, ignore_invalid_triggers=True) >>> # ...or even just for a single state. Here, exceptions will only be suppressed when the current state is A. >>> states = [State('A', ignore_invalid_triggers=True), 'B', 'C'] >>> m = Machine(lump, states) >>> # ...this can be inverted as well if just one state should raise an exception >>> # since the machine's global value is not applied to a previously initialized state. >>> states = ['A', 'B', State('C')] # the default value for 'ignore_invalid_triggers' is False >>> m = Machine(lump, states, ignore_invalid_triggers=True) ``` If you need to know which transitions are valid from a certain state, you can use `get_triggers`: ``` m.get_triggers('solid') >>> ['melt', 'sublimate'] m.get_triggers('liquid') >>> ['evaporate'] m.get_triggers('plasma') >>> [] # you can also query several states at once m.get_triggers('solid', 'liquid', 'gas', 'plasma') >>> ['melt', 'evaporate', 'sublimate', 'ionize'] ``` #### Automatic transitions for all states In addition to any transitions added explicitly, a `to_«state»()` method is created automatically whenever a state is added to a `Machine` instance. This method transitions to the target state no matter which state the machine is currently in: ```python lump.to_liquid() lump.state >>> 'liquid' lump.to_solid() lump.state >>> 'solid' ``` If you desire, you can disable this behavior by setting `auto_transitions=False` in the `Machine` initializer. #### Transitioning from multiple states A given trigger can be attached to multiple transitions, some of which can potentially begin or end in the same state. For example: ```python machine.add_transition('transmogrify', ['solid', 'liquid', 'gas'], 'plasma') machine.add_transition('transmogrify', 'plasma', 'solid') # This next transition will never execute machine.add_transition('transmogrify', 'plasma', 'gas') ``` In this case, calling `transmogrify()` will set the model's state to `'solid'` if it's currently `'plasma'`, and set it to `'plasma'` otherwise. (Note that only the _first_ matching transition will execute; thus, the transition defined in the last line above won't do anything.) You can also make a trigger cause a transition from _all_ states to a particular destination by using the `'*'` wildcard: ```python machine.add_transition('to_liquid', '*', 'liquid') ``` Note that wildcard transitions will only apply to states that exist at the time of the add_transition() call. Calling a wildcard-based transition when the model is in a state added after the transition was defined will elicit an invalid transition message, and will not transition to the target state. #### Reflexive transitions from multiple states A reflexive trigger (trigger that has the same state as source and destination) can easily be added specifying `=` as destination. This is handy if the same reflexive trigger should be added to multiple states. For example: ```python machine.add_transition('touch', ['liquid', 'gas', 'plasma'], '=', after='change_shape') ``` This will add reflexive transitions for all three states with `touch()` as trigger and with `change_shape` executed after each trigger. #### Internal transitions In contrast to reflexive transitions, internal transitions will never actually leave the state. This means that transition-related callbacks such as `before` or `after` will be processed while state-related callbacks `exit` or `enter` will not. To define a transition to be internal, set the destination to `None`. ```python machine.add_transition('internal', ['liquid', 'gas'], None, after='change_shape') ``` #### Ordered transitions A common desire is for state transitions to follow a strict linear sequence. For instance, given states `['A', 'B', 'C']`, you might want valid transitions for `A` → `B`, `B` → `C`, and `C` → `A` (but no other pairs). To facilitate this behavior, Transitions provides an `add_ordered_transitions()` method in the `Machine` class: ```python states = ['A', 'B', 'C'] # See the "alternative initialization" section for an explanation of the 1st argument to init machine = Machine(states=states, initial='A') machine.add_ordered_transitions() machine.next_state() print(machine.state) >>> 'B' # We can also define a different order of transitions machine = Machine(states=states, initial='A') machine.add_ordered_transitions(['A', 'C', 'B']) machine.next_state() print(machine.state) >>> 'C' # Conditions can be passed to 'add_ordered_transitions' as well # If one condition is passed, it will be used for all transitions machine = Machine(states=states, initial='A') machine.add_ordered_transitions(conditions='check') # If a list is passed, it must contain exactly as many elements as the # machine contains states (A->B, ..., X->A) machine = Machine(states=states, initial='A') machine.add_ordered_transitions(conditions=['check_A2B', ..., 'check_X2A']) ``` #### Queued transitions The default behaviour in Transitions is to process events instantly. This means events within an `on_enter` method will be processed _before_ callbacks bound to `after` are called. ```python def go_to_C(): global machine machine.to_C() def after_advance(): print("I am in state B now!") def entering_C(): print("I am in state C now!") states = ['A', 'B', 'C'] machine = Machine(states=states, initial='A') # we want a message when state transition to B has been completed machine.add_transition('advance', 'A', 'B', after=after_advance) # call transition from state B to state C machine.on_enter_B(go_to_C) # we also want a message when entering state C machine.on_enter_C(entering_C) machine.advance() >>> 'I am in state C now!' >>> 'I am in state B now!' # what? ``` The execution order of this example is ``` prepare -> before -> on_enter_B -> on_enter_C -> after. ``` If queued processing is enabled, a transition will be finished before the next transition is triggered: ```python machine = Machine(states=states, queued=True, initial='A') ... machine.advance() >>> 'I am in state B now!' >>> 'I am in state C now!' # That's better! ``` This results in ``` prepare -> before -> on_enter_B -> queue(to_C) -> after -> on_enter_C. ``` **Important note:** when processing events in a queue, the trigger call will _always_ return `True`, since there is no way to determine at queuing time whether a transition involving queued calls will ultimately complete successfully. This is true even when only a single event is processed. ```python machine.add_transition('jump', 'A', 'C', conditions='will_fail') ... # queued=False machine.jump() >>> False # queued=True machine.jump() >>> True ``` #### Conditional transitions Sometimes you only want a particular transition to execute if a specific condition occurs. You can do this by passing a method, or list of methods, in the `conditions` argument: ```python # Our Matter class, now with a bunch of methods that return booleans. class Matter(object): def is_flammable(self): return False def is_really_hot(self): return True machine.add_transition('heat', 'solid', 'gas', conditions='is_flammable') machine.add_transition('heat', 'solid', 'liquid', conditions=['is_really_hot']) ``` In the above example, calling `heat()` when the model is in state `'solid'` will transition to state `'gas'` if `is_flammable` returns `True`. Otherwise, it will transition to state `'liquid'` if `is_really_hot` returns `True`. For convenience, there's also an `'unless'` argument that behaves exactly like conditions, but inverted: ```python machine.add_transition('heat', 'solid', 'gas', unless=['is_flammable', 'is_really_hot']) ``` In this case, the model would transition from solid to gas whenever `heat()` fires, provided that both `is_flammable()` and `is_really_hot()` return `False`. Note that condition-checking methods will passively receive optional arguments and/or data objects passed to triggering methods. For instance, the following call: ```python lump.heat(temp=74) # equivalent to lump.trigger('heat', temp=74) ``` ... would pass the `temp=74` optional kwarg to the `is_flammable()` check (possibly wrapped in an `EventData` instance). For more on this, see the [Passing data](#passing-data) section below. #### Callbacks You can attach callbacks to transitions as well as states. Every transition has `'before'` and `'after'` attributes that contain a list of methods to call before and after the transition executes: ```python class Matter(object): def make_hissing_noises(self): print("HISSSSSSSSSSSSSSSS") def disappear(self): print("where'd all the liquid go?") transitions = [ { 'trigger': 'melt', 'source': 'solid', 'dest': 'liquid', 'before': 'make_hissing_noises'}, { 'trigger': 'evaporate', 'source': 'liquid', 'dest': 'gas', 'after': 'disappear' } ] lump = Matter() machine = Machine(lump, states, transitions=transitions, initial='solid') lump.melt() >>> "HISSSSSSSSSSSSSSSS" lump.evaporate() >>> "where'd all the liquid go?" ``` There is also a `'prepare'` callback that is executed as soon as a transition starts, before any `'conditions'` are checked or other callbacks are executed. ```python class Matter(object): heat = False attempts = 0 def count_attempts(self): self.attempts += 1 def is_really_hot(self): return self.heat def heat_up(self): self.heat = random.random() < 0.25 def stats(self): print('It took you %i attempts to melt the lump!' %self.attempts) states=['solid', 'liquid', 'gas', 'plasma'] transitions = [ { 'trigger': 'melt', 'source': 'solid', 'dest': 'liquid', 'prepare': ['heat_up', 'count_attempts'], 'conditions': 'is_really_hot', 'after': 'stats'}, ] lump = Matter() machine = Machine(lump, states, transitions=transitions, initial='solid') lump.melt() lump.melt() lump.melt() lump.melt() >>> "It took you 4 attempts to melt the lump!" ``` Note that `prepare` will not be called unless the current state is a valid source for the named transition. Default actions meant to be executed before or after *every* transition can be passed to `Machine` during initialization with `before_state_change` and `after_state_change` respectively: ```python class Matter(object): def make_hissing_noises(self): print("HISSSSSSSSSSSSSSSS") def disappear(self): print("where'd all the liquid go?") states=['solid', 'liquid', 'gas', 'plasma'] lump = Matter() m = Machine(lump, states, before_state_change='make_hissing_noises', after_state_change='disappear') lump.to_gas() >>> "HISSSSSSSSSSSSSSSS" >>> "where'd all the liquid go?" ``` There are also two keywords for callbacks which should be executed *independently* a) of how many transitions are possible, b) if any transition succeeds and c) even if an error is raised during the execution of some other callback. Callbacks passed to `Machine` with `prepare_event` will be executed *once* before processing possible transitions (and their individual `prepare` callbacks) takes place. Callbacks of `finalize_event` will be executed regardless of the success of the processed transitions. Note that if an error occurred it will be attached to `event_data` as `error` and can be retrieved with `send_event=True`. ```python from transitions import Machine class Matter(object): def raise_error(self, event): raise ValueError("Oh no") def prepare(self, event): print("I am ready!") def finalize(self, event): print("Result: ", type(event.error), event.error) states=['solid', 'liquid', 'gas', 'plasma'] lump = Matter() m = Machine(lump, states, prepare_event='prepare', before_state_change='raise_error', finalize_event='finalize', send_event=True) try: lump.to_gas() except ValueError: pass print(lump.state) >>> I am ready! >>> Result: Oh no >>> initial ``` ### Callback resolution and execution order As you have probably already realized, the standard way of passing callbacks to states and transitions is by name. When processing callbacks, `transitions` will use the name to retrieve the related callback from the model. If the method cannot be retrieved and it contains dots, Transitions will treat the name as a path to a module function and try to import it. Alternatively, you can pass callables such as (bound) functions directly. As mentioned earlier, you can also pass lists/tuples of callbacks to the callback parameters. Callbacks will be executed in the order they were added. ```python from transitions import Machine from mod import imported_func class Model(object): def a_callback(self): imported_func() model = Model() machine = Machine(model=model, states=['A'], initial='A') machine.add_transition('by_name', 'A', 'A', after='a_callback') machine.add_transition('by_reference', 'A', 'A', after=model.a_callback) machine.add_transition('imported', 'A', 'A', after='mod.imported_func') model.by_name() model.by_reference() model.imported() ``` The callback resolution is done in `Machine.resolve_callbacks`. This method can be overridden in case more complex callback resolution strategies are required. In summary, callbacks on transitions are executed in the following order: | Callback | Current State | Comments | |--------------------------------|:-------------:|-------------------------------------------------------------| | `'machine.prepare_event'` | `source` | executed *once* before individual transitions are processed | | `'transition.prepare'` | `source` | executed as soon as the transition starts | | `'transition.conditions'` | `source` | conditions *may* fail and halt the transition | | `'transition.unless'` | `source` | conditions *may* fail and halt the transition | | `'machine.before_state_change'`| `source` | default callbacks declared on model | | `'transition.before'` | `source` | | | `'state.on_exit'` | `source` | callbacks declared on the source state | | `` | | | | `'state.on_enter'` | `destination` | callbacks declared on the destination state | | `'transition.after'` | `destination` | | | `'machine.after_state_change'` | `destination` | default callbacks declared on model | | `'machine.finalize_event'` | `source/destination` | callbacks will be executed even if no transition took place or an exception has been raised | If any callback raises an exception, the processing of callbacks is not continued. This means that when an error occurs before the transition (in `state.on_exit` or earlier), it is halted. In case there is a raise after the transition has been conducted (in `state.on_enter` or later), the state change persists and no rollback is happening. Callbacks specified in `machine.finalize_event` will always be executed unless the exception is raised by a finalizing callback itself. ### Passing data Sometimes you need to pass the callback functions registered at machine initialization some data that reflects the model's current state. Transitions allows you to do this in two different ways. First (the default), you can pass any positional or keyword arguments directly to the trigger methods (created when you call `add_transition()`): ```python class Matter(object): def __init__(self): self.set_environment() def set_environment(self, temp=0, pressure=101.325): self.temp = temp self.pressure = pressure def print_temperature(self): print("Current temperature is %d degrees celsius." % self.temp) def print_pressure(self): print("Current pressure is %.2f kPa." % self.pressure) lump = Matter() machine = Machine(lump, ['solid', 'liquid'], initial='solid') machine.add_transition('melt', 'solid', 'liquid', before='set_environment') lump.melt(45) # positional arg; # equivalent to lump.trigger('melt', 45) lump.print_temperature() >>> 'Current temperature is 45 degrees celsius.' machine.set_state('solid') # reset state so we can melt again lump.melt(pressure=300.23) # keyword args also work lump.print_pressure() >>> 'Current pressure is 300.23 kPa.' ``` You can pass any number of arguments you like to the trigger. There is one important limitation to this approach: every callback function triggered by the state transition must be able to handle _all_ of the arguments. This may cause problems if the callbacks each expect somewhat different data. To get around this, Transitions supports an alternate method for sending data. If you set `send_event=True` at `Machine` initialization, all arguments to the triggers will be wrapped in an `EventData` instance and passed on to every callback. (The `EventData` object also maintains internal references to the source state, model, transition, machine, and trigger associated with the event, in case you need to access these for anything.) ```python class Matter(object): def __init__(self): self.temp = 0 self.pressure = 101.325 # Note that the sole argument is now the EventData instance. # This object stores positional arguments passed to the trigger method in the # .args property, and stores keywords arguments in the .kwargs dictionary. def set_environment(self, event): self.temp = event.kwargs.get('temp', 0) self.pressure = event.kwargs.get('pressure', 101.325) def print_pressure(self): print("Current pressure is %.2f kPa." % self.pressure) lump = Matter() machine = Machine(lump, ['solid', 'liquid'], send_event=True, initial='solid') machine.add_transition('melt', 'solid', 'liquid', before='set_environment') lump.melt(temp=45, pressure=1853.68) # keyword args lump.print_pressure() >>> 'Current pressure is 1853.68 kPa.' ``` ### Alternative initialization patterns In all of the examples so far, we've attached a new `Machine` instance to a separate model (`lump`, an instance of class `Matter`). While this separation keeps things tidy (because you don't have to monkey patch a whole bunch of new methods into the `Matter` class), it can also get annoying, since it requires you to keep track of which methods are called on the state machine, and which ones are called on the model that the state machine is bound to (e.g., `lump.on_enter_StateA()` vs. `machine.add_transition()`). Fortunately, Transitions is flexible, and supports two other initialization patterns. First, you can create a standalone state machine that doesn't require another model at all. Simply omit the model argument during initialization: ```python machine = Machine(states=states, transitions=transitions, initial='solid') machine.melt() machine.state >>> 'liquid' ``` If you initialize the machine this way, you can then attach all triggering events (like `evaporate()`, `sublimate()`, etc.) and all callback functions directly to the `Machine` instance. This approach has the benefit of consolidating all of the state machine functionality in one place, but can feel a little bit unnatural if you think state logic should be contained within the model itself rather than in a separate controller. An alternative (potentially better) approach is to have the model inherit from the `Machine` class. Transitions is designed to support inheritance seamlessly. (just be sure to override class `Machine`'s `__init__` method!): ```python class Matter(Machine): def say_hello(self): print("hello, new state!") def say_goodbye(self): print("goodbye, old state!") def __init__(self): states = ['solid', 'liquid', 'gas'] Machine.__init__(self, states=states, initial='solid') self.add_transition('melt', 'solid', 'liquid') lump = Matter() lump.state >>> 'solid' lump.melt() lump.state >>> 'liquid' ``` Here you get to consolidate all state machine functionality into your existing model, which often feels more natural way than sticking all of the functionality we want in a separate standalone `Machine` instance. A machine can handle multiple models which can be passed as a list like `Machine(model=[model1, model2, ...])`. In cases where you want to add models *as well as* the machine instance itself, you can pass the string placeholder `'self'` during initialization like `Machine(model=['self', model1, ...])`. You can also create a standalone machine, and register models dynamically via `machine.add_model`. Remember to call `machine.remove_model` if machine is long-lasting and your models are temporary and should be garbage collected: ```python class Matter(): pass lump1 = Matter() lump2 = Matter() machine = Machine(states=states, transitions=transitions, initial='solid', add_self=False) machine.add_model(lump1) machine.add_model(lump2, initial='liquid') lump1.state >>> 'solid' lump2.state >>> 'liquid' machine.remove_model([lump1, lump2]) del lump1 # lump1 is garbage collected del lump2 # lump2 is garbage collected ``` If you don't provide an initial state in the state machine constructor, you must provide one every time you add a model: ```python machine = Machine(states=states, transitions=transitions, add_self=False) machine.add_model(Matter()) >>> "MachineError: No initial state configured for machine, must specify when adding model." machine.add_model(Matter(), initial='liquid') ``` Models with multiple states could attach multiple machines using different `model_attribute` values: ```python lump = Matter() lump.state >>> 'solid' lump.shipping_state >>> 'delivered' matter_machine = Machine(lump, model_attribute='state', **kwargs) shipment_machine = Machine(lump, model_attribute='shipping_state', **kwargs) ``` ### Logging Transitions includes very rudimentary logging capabilities. A number of events – namely, state changes, transition triggers, and conditional checks – are logged as INFO-level events using the standard Python `logging` module. This means you can easily configure logging to standard output in a script: ```python # Set up logging; The basic log level will be DEBUG import logging logging.basicConfig(level=logging.DEBUG) # Set transitions' log level to INFO; DEBUG messages will be omitted logging.getLogger('transitions').setLevel(logging.INFO) # Business as usual machine = Machine(states=states, transitions=transitions, initial='solid') ... ``` ### (Re-)Storing machine instances Machines are picklable and can be stored and loaded with `pickle`. For Python 3.3 and earlier `dill` is required. ```python import dill as pickle # only required for Python 3.3 and earlier m = Machine(states=['A', 'B', 'C'], initial='A') m.to_B() m.state >>> B # store the machine dump = pickle.dumps(m) # load the Machine instance again m2 = pickle.loads(dump) m2.state >>> B m2.states.keys() >>> ['A', 'B', 'C'] ``` ### Extensions Even though the core of transitions is kept lightweight, there are a variety of MixIns to extend its functionality. Currently supported are: - **Diagrams** to visualize the current state of a machine - **Hierarchical State Machines** for nesting and reuse - **Threadsafe Locks** for parallel execution - **Custom States** for extended state-related behaviour There are two mechanisms to retrieve a state machine instance with the desired features enabled. The first approach makes use of the convenience `factory` with the three parameters `graph`, `nested` and `locked` set to `True` if the certain feature is required: ```python from transitions.extensions import MachineFactory # create a machine with mixins diagram_cls = MachineFactory.get_predefined(graph=True) nested_locked_cls = MachineFactory.get_predefined(nested=True, locked=True) # create instances from these classes # instances can be used like simple machines machine1 = diagram_cls(model, state, transitions...) machine2 = nested_locked_cls(model, state, transitions) ``` This approach targets experimental use since in this case the underlying classes do not have to be known. However, classes can also be directly imported from `transitions.extensions`. The naming scheme is as follows: | | Diagrams | Nested | Locked | | -----------------------------: | :------: | :----: | :----: | | Machine | ✘ | ✘ | ✘ | | GraphMachine | ✓ | ✘ | ✘ | | HierarchicalMachine | ✘ | ✓ | ✘ | | LockedMachine | ✘ | ✘ | ✓ | | HierarchicalGraphMachine | ✓ | ✓ | ✘ | | LockedGraphMachine | ✓ | ✘ | ✓ | | LockedHierarchicalMachine | ✘ | ✓ | ✓ | | LockedHierarchicalGraphMachine | ✓ | ✓ | ✓ | To use a full featured state machine, one could write: ```python from transitions.extensions import LockedHierarchicalGraphMachine as Machine #enable ALL the features! machine = Machine(model, states, transitions) ``` #### Diagrams Additional Keywords: * `title` (optional): Sets the title of the generated image. * `show_conditions` (default False): Shows conditions at transition edges * `show_auto_transitions` (default False): Shows auto transitions in graph * `show_state_attributes` (default False): Show callbacks (enter, exit), tags and timeouts in graph Transitions can generate basic state diagrams displaying all valid transitions between states. To use the graphing functionality, you'll need to have `graphviz` and/or `pygraphviz` installed: To generate graphs with the package `graphviz`, you need to install [Graphviz](https://graphviz.org/) manually or via a package manager. sudo apt-get install graphviz # Ubuntu and Debian brew install graphviz # MacOS conda install graphviz python-graphviz # (Ana)conda Now you can install the actual Python packages pip install graphviz pygraphviz # install graphviz and/or pygraphviz manually... pip install transitions[diagrams] # ... or install transitions with 'diagrams' extras which currently depends on pygraphviz Currently, `GraphMachine` will use `pygraphviz` when available and fall back to `graphviz` when `pygraphviz` cannot be found. This can be overridden by passing `use_pygraphviz=False` to the constructor. Note that this default might change in the future and `pygraphviz` support may be dropped. With `Model.get_graph()` you can get the current graph or the region of interest (roi) and draw it like this: ```python # import transitions from transitions.extensions import GraphMachine as Machine m = Model() # without further arguments pygraphviz will be used machine = Machine(model=m, ...) # when you want to use graphviz explicitely machine = Machine(model=m, use_pygraphviz=False, ...) # in cases where auto transitions should be visible machine = Machine(model=m, show_auto_transitions=True, ...) # draw the whole graph ... m.get_graph().draw('my_state_diagram.png', prog='dot') # ... or just the region of interest # (previous state, active state and all reachable states) roi = m.get_graph(show_roi=True).draw('my_state_diagram.png', prog='dot') ``` This produces something like this: ![state diagram example](https://user-images.githubusercontent.com/205986/47524268-725c1280-d89a-11e8-812b-1d3b6e667b91.png) Also, have a look at our [example](./examples) IPython/Jupyter notebooks for a more detailed example. ### Hierarchical State Machine (HSM) Transitions includes an extension module which allows to nest states. This allows to create contexts and to model cases where states are related to certain subtasks in the state machine. To create a nested state, either import `NestedState` from transitions or use a dictionary with the initialization arguments `name` and `children`. Optionally, `initial` can be used to define a sub state to transit to, when the nested state is entered. ```python from transitions.extensions import HierarchicalMachine as Machine states = ['standing', 'walking', {'name': 'caffeinated', 'children':['dithering', 'running']}] transitions = [ ['walk', 'standing', 'walking'], ['stop', 'walking', 'standing'], ['drink', '*', 'caffeinated'], ['walk', ['caffeinated', 'caffeinated_dithering'], 'caffeinated_running'], ['relax', 'caffeinated', 'standing'] ] machine = Machine(states=states, transitions=transitions, initial='standing', ignore_invalid_triggers=True) machine.walk() # Walking now machine.stop() # let's stop for a moment machine.drink() # coffee time machine.state >>> 'caffeinated' machine.walk() # we have to go faster machine.state >>> 'caffeinated_running' machine.stop() # can't stop moving! machine.state >>> 'caffeinated_running' machine.relax() # leave nested state machine.state # phew, what a ride >>> 'standing' # machine.on_enter_caffeinated_running('callback_method') ``` A configuration making use of `initial` could look like this: ```python # ... states = ['standing', 'walking', {'name': 'caffeinated', 'initial': 'dithering', 'children': ['dithering', 'running']}] transitions = [ ['walk', 'standing', 'walking'], ['stop', 'walking', 'standing'], # this transition will end in 'caffeinated_dithering'... ['drink', '*', 'caffeinated'], # ... that is why we do not need do specify 'caffeinated' here anymore ['walk', 'caffeinated_dithering', 'caffeinated_running'], ['relax', 'caffeinated', 'standing'] ] # ... ``` Some things that have to be considered when working with nested states: State *names are concatenated* with `NestedState.separator`. Currently the separator is set to underscore ('_') and therefore behaves similar to the basic machine. This means a substate `bar` from state `foo` will be known by `foo_bar`. A substate `baz` of `bar` will be referred to as `foo_bar_baz` and so on. When entering a substate, `enter` will be called for all parent states. The same is true for exiting substates. Third, nested states can overwrite transition behaviour of their parents. If a transition is not known to the current state it will be delegated to its parent. In some cases underscore as a separator is not sufficient. For instance if state names consists of more than one word and a concatenated naming such as `state_A_name_state_C` would be confusing. Setting the separator to something else than underscore changes some of the behaviour (auto_transition and setting callbacks). You can even use unicode characters if you use python 3: ```python from transitions.extensions.nesting import NestedState NestedState.separator = '↦' states = ['A', 'B', {'name': 'C', 'children':['1', '2', {'name': '3', 'children': ['a', 'b', 'c']} ]} ] transitions = [ ['reset', 'C', 'A'], ['reset', 'C↦2', 'C'] # overwriting parent reset ] # we rely on auto transitions machine = Machine(states=states, transitions=transitions, initial='A') machine.to_B() # exit state A, enter state B machine.to_C() # exit B, enter C machine.to_C.s3.a() # enter C↦a; enter C↦3↦a; machine.state, >>> 'C↦3↦a' machine.to('C↦2') # not interactive; exit C↦3↦a, exit C↦3, enter C↦2 machine.reset() # exit C↦2; reset C has been overwritten by C↦3 machine.state >>> 'C' machine.reset() # exit C, enter A machine.state >>> 'A' # s.on_enter('C↦3↦a', 'callback_method') ``` Instead of `to_C_3_a()` auto transition is called as `to_C.s3.a()`. If your substate starts with a digit, transitions adds a prefix 's' ('3' becomes 's3') to the auto transition `FunctionWrapper` to comply with the attribute naming scheme of python. If interactive completion is not required, `to('C↦3↦a')` can be called directly. Additionally, `on_enter/exit_<>` is replaced with `on_enter/exit(state_name, callback)`. To check whether the current state is a substate of a specific state `is_state` supports the keyword `allow_substates`: ```python machine.state >>> 'C.2.a' machine.is_C() # checks for specific states >>> False machine.is_C(allow_substates=True) >>> True ``` You can use enumerations in HSMs as well but `enum` support is currently limited to the root level as model state enums lack hierarchical information. An attempt of nesting an `Enum` will raise an `AttributeError` in `NestedState`. ```python # will work states = [States.RED, States.YELLOW, {'name': States.GREEN, 'children': ['tick', 'tock']}] # will raise an AttributeError states = ['A', {'name': 'B', 'children': States}] ``` #### Reuse of previously created HSMs Besides semantic order, nested states are very handy if you want to specify state machines for specific tasks and plan to reuse them. Be aware that this will *embed* the passed machine's states. This means if your states had been altered *before*, this change will be persistent. ```python count_states = ['1', '2', '3', 'done'] count_trans = [ ['increase', '1', '2'], ['increase', '2', '3'], ['decrease', '3', '2'], ['decrease', '2', '1'], ['done', '3', 'done'], ['reset', '*', '1'] ] counter = Machine(states=count_states, transitions=count_trans, initial='1') counter.increase() # love my counter states = ['waiting', 'collecting', {'name': 'counting', 'children': counter}] transitions = [ ['collect', '*', 'collecting'], ['wait', '*', 'waiting'], ['count', 'collecting', 'counting'] ] collector = Machine(states=states, transitions=transitions, initial='waiting') collector.collect() # collecting collector.count() # let's see what we got; counting_1 collector.increase() # counting_2 collector.increase() # counting_3 collector.done() # collector.state == counting_done collector.wait() # collector.state == waiting ``` If a `HierarchicalStateMachine` is passed with the `children` keyword, the initial state of this machine will be assigned to the new parent state. In the above example we see that entering `counting` will also enter `counting_1`. If this is undesired behaviour and the machine should rather halt in the parent state, the user can pass `initial` as `False` like `{'name': 'counting', 'children': counter, 'initial': False}`. Sometimes you want such an embedded state collection to 'return' which means after it is done it should exit and transit to one of your states. To achieve this behaviour you can remap state transitions. In the example above we would like the counter to return if the state `done` was reached. This is done as follows: ```python states = ['waiting', 'collecting', {'name': 'counting', 'children': counter, 'remap': {'done': 'waiting'}}] ... # same as above collector.increase() # counting_3 collector.done() collector.state >>> 'waiting' # be aware that 'counting_done' will be removed from the state machine ``` If a reused state machine does not have a final state, you can of course add the transitions manually. If 'counter' had no 'done' state, we could just add `['done', 'counter_3', 'waiting']` to achieve the same behaviour. Note that the `HierarchicalMachine` will not integrate the machine instance itself but the states and transitions by creating copies of them. This way you are able to continue using your previously created instance without interfering with the embedded version. #### Threadsafe(-ish) State Machine In cases where event dispatching is done in threads, one can use either `LockedMachine` or `LockedHierarchicalMachine` where **function access** (!sic) is secured with reentrant locks. This does not save you from corrupting your machine by tinkering with member variables of your model or state machine. ```python from transitions.extensions import LockedMachine as Machine from threading import Thread import time states = ['A', 'B', 'C'] machine = Machine(states=states, initial='A') # let us assume that entering B will take some time thread = Thread(target=machine.to_B) thread.start() time.sleep(0.01) # thread requires some time to start machine.to_C() # synchronized access; won't execute before thread is done # accessing attributes directly thread = Thread(target=machine.to_B) thread.start() machine.new_attrib = 42 # not synchronized! will mess with execution order ``` Any python context manager can be passed in via the `machine_context` keyword argument: ```python from transitions.extensions import LockedMachine as Machine from threading import RLock states = ['A', 'B', 'C'] lock1 = RLock() lock2 = RLock() machine = Machine(states=states, initial='A', machine_context=[lock1, lock2]) ``` Any contexts via `machine_model` will be shared between all models registered with the `Machine`. Per-model contexts can be added as well: ``` lock3 = RLock() machine.add_model(model, model_context=lock3) ``` It's important that all user-provided context managers are re-entrant since the state machine will call them multiple times, even in the context of a single trigger invocation. #### Adding features to states If your superheroes need some custom behaviour, you can throw in some extra functionality by decorating machine states: ```python from time import sleep from transitions import Machine from transitions.extensions.states import add_state_features, Tags, Timeout @add_state_features(Tags, Timeout) class CustomStateMachine(Machine): pass class SocialSuperhero(object): def __init__(self): self.entourage = 0 def on_enter_waiting(self): self.entourage += 1 states = [{'name': 'preparing', 'tags': ['home', 'busy']}, {'name': 'waiting', 'timeout': 1, 'on_timeout': 'go'}, {'name': 'away'}] # The city needs us! transitions = [['done', 'preparing', 'waiting'], ['join', 'waiting', 'waiting'], # Entering Waiting again will increase our entourage ['go', 'waiting', 'away']] # Okay, let' move hero = SocialSuperhero() machine = CustomStateMachine(model=hero, states=states, transitions=transitions, initial='preparing') assert hero.state == 'preparing' # Preparing for the night shift assert machine.get_state(hero.state).is_busy # We are at home and busy hero.done() assert hero.state == 'waiting' # Waiting for fellow superheroes to join us assert hero.entourage == 1 # It's just us so far sleep(0.7) # Waiting... hero.join() # Weeh, we got company sleep(0.5) # Waiting... hero.join() # Even more company \o/ sleep(2) # Waiting... assert hero.state == 'away' # Impatient superhero already left the building assert machine.get_state(hero.state).is_home is False # Yupp, not at home anymore assert hero.entourage == 3 # At least he is not alone ``` Currently, transitions comes equipped with the following state features: * **Timeout** -- triggers an event after some time has passed - keyword: `timeout` (int, optional) -- if passed, an entered state will timeout after `timeout` seconds - keyword: `on_timeout` (string/callable, optional) -- will be called when timeout time has been reached - will raise an `AttributeError` when `timeout` is set but `on_timeout` is not - Note: A timeout is triggered in a thread. This implies several limitations (e.g. catching Exceptions raised in timeouts). Consider an event queue for more sophisticated applications. * **Tags** -- adds tags to states - keyword: `tags` (list, optional) -- assigns tags to a state - `State.is_` will return `True` when the state has been tagged with `tag_name`, else `False` * **Error** -- raises a `MachineError` when a state cannot be left - inherits from `Tags` (if you use `Error` do not use `Tags`) - keyword: `accepted` (bool, optional) -- marks a state as accepted - alternatively the keyword `tags` can be passed, containing 'accepted' - Note: Errors will only be raised if `auto_transitions` has been set to `False`. Otherwise every state can be exited with `to_` methods. * **Volatile** -- initialises an object every time a state is entered - keyword: `volatile` (class, optional) -- every time the state is entered an object of type class will be assigned to the model. The attribute name is defined by `hook`. If omitted, an empty VolatileObject will be created instead - keyword: `hook` (string, default='scope') -- The model's attribute name fore the temporal object. You can write your own `State` extensions and add them the same way. Just note that `add_state_features` expects *Mixins*. This means your extension should always call the overridden methods `__init__`, `enter` and `exit`. Your extension may inherit from *State* but will also work without it. In case you prefer to write your own custom states from scratch be aware that some state extensions *require* certain state features. `HierarchicalStateMachine` requires your custom state to be an instance of `NestedState` (`State` is not sufficient). To inject your states you can either assign them to your `Machine`'s class attribute `state_cls` or override `Machine.create_state` in case you need some specific procedures done whenever a state is created: ```python from transitions import Machine, State class MyState(State): pass class CustomMachine(Machine): # Use MyState as state class state_cls = MyState class VerboseMachine(Machine): # `Machine._create_state` is a class method but we can # override it to be an instance method def _create_state(self, *args, **kwargs): print("Creating a new state with machine '{0}'".format(self.name)) return MyState(*args, **kwargs) ``` #### Using transitions together with Django Christian Ledermann developed `django-transitions`, a module dedicated to streamline the work with `transitions` and Django. The source code is also hosted on [Github](https://github.com/PrimarySite/django-transitions). Have a look at [the documentation](https://django-transitions.readthedocs.io/en/latest/) for usage examples. ### I have a [bug report/issue/question]... For bug reports and other issues, please open an issue on GitHub. For usage questions, post on Stack Overflow, making sure to tag your question with the `transitions` and `python` tags. Do not forget to have a look at the [extended examples](./examples)! For any other questions, solicitations, or large unrestricted monetary gifts, email [Tal Yarkoni](mailto:tyarkoni@gmail.com). Platform: UNKNOWN Classifier: License :: OSI Approved :: MIT License Classifier: Programming Language :: Python :: 2 Classifier: Programming Language :: Python :: 2.7 Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.3 Classifier: Programming Language :: Python :: 3.4 Classifier: Programming Language :: Python :: 3.5 Classifier: Programming Language :: Python :: 3.6 Classifier: Programming Language :: Python :: 3.7 Description-Content-Type: text/markdown Provides-Extra: diagrams Provides-Extra: test transitions-0.7.2/transitions.egg-info/SOURCES.txt0000644000076500000240000000216013606034310022746 0ustar alneumanstaff00000000000000.coveragerc .pylintrc Changelog.md LICENSE MANIFEST.in README.md requirements.txt requirements_diagrams.txt requirements_test.txt setup.cfg setup.py tox.ini examples/Frequently asked questions.ipynb examples/Graph MIxin Demo Nested.ipynb examples/Graph MIxin Demo.ipynb tests/__init__.py tests/test_add_remove.py tests/test_codestyle.py tests/test_core.py tests/test_enum.py tests/test_factory.py tests/test_graphviz.py tests/test_markup.py tests/test_nesting.py tests/test_pygraphviz.py tests/test_reuse.py tests/test_states.py tests/test_threading.py tests/utils.py transitions/__init__.py transitions/core.py transitions/version.py transitions.egg-info/PKG-INFO transitions.egg-info/SOURCES.txt transitions.egg-info/dependency_links.txt transitions.egg-info/requires.txt transitions.egg-info/top_level.txt transitions/extensions/__init__.py transitions/extensions/diagrams.py transitions/extensions/diagrams_graphviz.py transitions/extensions/diagrams_pygraphviz.py transitions/extensions/factory.py transitions/extensions/locking.py transitions/extensions/markup.py transitions/extensions/nesting.py transitions/extensions/states.pytransitions-0.7.2/transitions.egg-info/dependency_links.txt0000644000076500000240000000000113606034310025131 0ustar alneumanstaff00000000000000 transitions-0.7.2/transitions.egg-info/requires.txt0000644000076500000240000000005213606034310023460 0ustar alneumanstaff00000000000000six [diagrams] pygraphviz [test] pytest transitions-0.7.2/transitions.egg-info/top_level.txt0000644000076500000240000000001413606034310023610 0ustar alneumanstaff00000000000000transitions