Repository: AgnostiqHQ/covalent (language: python)

Issue:
Switch from `workflow.dispatch` to `covalent.dispatch`
### What should we add?

Currently we are using `workflow.dispatch` to send a lattice `workflow` for execution to the dispatcher server. Maybe we can use a more intuitive approach for dispatching which is similar to how we obtain the result for a particular dispatch. The proposal is to have a function `covalent.dispatch` similar to `covalent.get_result` so that it is more intuitive for users to send a job the same way they get the result.

Resolving this issue may also involve updating the `README.md`s, tutorials, documentation, etc. So it will turn into a big issue.

### Describe alternatives you've considered.

_No response_


Discussion / hints:
Hey @kessler-frost , dont forget this list as well (could be separate issues as well)
- including depreciation warning for `lattice.dispatch()`
- ~Changing tutorials/how-to/readme/examples~

Edit: already added

Fix patch:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 87d5ed6bf..bb19c6ad1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,11 +5,33 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.23.0] - 2022-02-03
+
+### Added
+
+- Added `BaseDispatcher` class to be used for creating custom dispatchers which allow connection to a dispatcher server.
+- `LocalDispatcher` inheriting from `BaseDispatcher` allows connection to a local dispatcher server running on the user's machine.
+- Covalent only gives interface to the `LocalDispatcher`'s `dispatch` and `dispatch_sync` methods.
+- Tests for both `LocalDispatcher` and `BaseDispatcher` added.
+
+### Changed
+
+- Switched from using `lattice.dispatch` and `lattice.dispatch_sync` to `covalent.dispatch` and `covalent.dispatch_sync`.
+- Dispatcher address now is passed as a parameter (`dispatcher_addr`) to `covalent.dispatch` and `covalent.dispatch_sync` instead of a metadata field to lattice.
+- Updated tests, how tos, and tutorials to use `covalent.dispatch` and `covalent.dispatch_sync`.
+- All the contents of `covalent_dispatcher/_core/__init__.py` are moved to `covalent_dispatcher/_core/execution.py` for better organization. `__init__.py` only contains function imports which are needed by external modules.
+- `dispatch`, `dispatch_sync` methods deprecated from `Lattice`.
+
+### Removed
+
+- `_server_dispatch` method removed from `Lattice`.
+- `dispatcher` metadata field removed from `lattice`.
+
 ## [0.22.19] - 2022-02-03
 
 ### Fixed
 
-- _write_dispatch_to_python_file isn't called each time a task is saved. It is now only called in the final save in _run_planned_workflow (in covalent_dispatcher/_core/__init__.py).
+- `_write_dispatch_to_python_file` isn't called each time a task is saved. It is now only called in the final save in `_run_planned_workflow` (in covalent_dispatcher/_core/__init__.py).
 
 ## [0.22.18] - 2022-02-03
 
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 027dd48ef..5003261f1 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -220,7 +220,7 @@ fi
 -   For single line statements and associated output, use Python console syntax (pycon):
 
 ```python
->>> pipeline.dispatch(**params) # Dispatching a workflow returns a unique dispatch id.
+>>> ct.dispatch(pipeline)(**params) # Dispatching a workflow returns a unique dispatch id.
 '8a7bfe54-d3c7-4ca1-861b-f55af6d5964a'
 ```
 
@@ -230,7 +230,7 @@ fi
 >>> dispatch_ids = []
 >>> params = [1, 2, 3, 4]
 >>> for a in params:
-...     dispatch_ids.append(pipeline.dispatch(a=a))
+...     dispatch_ids.append(ct.dispatch(pipeline)(a=a))
 ```
 
 -   For larger, more complicated code blocks, use standard Python code-block with Python console syntax for displaying output:
@@ -245,7 +245,7 @@ fi
 ...     res = identity(a)
 ...     return res
 ...
->>> dispatch_id = pipeline.dispatch(a=1)
+>>> dispatch_id = ct.dispatch(pipeline)(a=1)
 >>> result = pipeline.get_result(dispatch_id=dispatch_id)
 >>> print(result)
 
diff --git a/README.md b/README.md
index 415de9c7c..a8bc5dddf 100644
--- a/README.md
+++ b/README.md
@@ -154,8 +154,9 @@ def run_experiment(C=1.0, gamma=0.7):
     )
     return score
 
-dispatch_id =
-    run_experiment.dispatch(
+dispatchable_func = ct.dispatch(run_experiment)
+
+dispatch_id = dispatchable_func(
     	C=1.0,
     	gamma=0.7
     )
diff --git a/VERSION b/VERSION
index f9d93ed3c..ca222b7cf 100644
--- a/VERSION
+++ b/VERSION
@@ -1,1 +1,1 @@
-0.22.19
+0.23.0
diff --git a/covalent/__init__.py b/covalent/__init__.py
index c68db1e2e..b57e979fd 100644
--- a/covalent/__init__.py
+++ b/covalent/__init__.py
@@ -23,6 +23,8 @@
 import os
 
 from . import executor
+from ._dispatcher_plugins import local_dispatch as dispatch
+from ._dispatcher_plugins import local_dispatch_sync as dispatch_sync
 from ._results_manager.results_manager import cancel, get_result, sync
 from ._shared_files.config import get_config, reload_config, set_config
 from ._shared_files.util_classes import RESULT_STATUS as status
diff --git a/covalent/_dispatcher_plugins/__init__.py b/covalent/_dispatcher_plugins/__init__.py
new file mode 100644
index 000000000..ea46da1e7
--- /dev/null
+++ b/covalent/_dispatcher_plugins/__init__.py
@@ -0,0 +1,25 @@
+# Copyright 2021 Agnostiq Inc.
+#
+# This file is part of Covalent.
+#
+# Licensed under the GNU Affero General Public License 3.0 (the "License").
+# A copy of the License may be obtained with this software package or at
+#
+#      https://www.gnu.org/licenses/agpl-3.0.en.html
+#
+# Use of this file is prohibited except in compliance with the License. Any
+# modifications or derivative works of this file must retain this copyright
+# notice, and modified files must contain a notice indicating that they have
+# been altered from the originals.
+#
+# Covalent is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the License for more details.
+#
+# Relief from the License may be granted by purchasing a commercial license.
+
+from .base import BaseDispatcher
+from .local import LocalDispatcher
+
+local_dispatch = LocalDispatcher.dispatch
+local_dispatch_sync = LocalDispatcher.dispatch_sync
diff --git a/covalent/_dispatcher_plugins/base.py b/covalent/_dispatcher_plugins/base.py
new file mode 100644
index 000000000..278ac8820
--- /dev/null
+++ b/covalent/_dispatcher_plugins/base.py
@@ -0,0 +1,54 @@
+# Copyright 2021 Agnostiq Inc.
+#
+# This file is part of Covalent.
+#
+# Licensed under the GNU Affero General Public License 3.0 (the "License").
+# A copy of the License may be obtained with this software package or at
+#
+#      https://www.gnu.org/licenses/agpl-3.0.en.html
+#
+# Use of this file is prohibited except in compliance with the License. Any
+# modifications or derivative works of this file must retain this copyright
+# notice, and modified files must contain a notice indicating that they have
+# been altered from the originals.
+#
+# Covalent is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the License for more details.
+#
+# Relief from the License may be granted by purchasing a commercial license.
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+from .._results_manager.result import Result
+from .._workflow.lattice import Lattice
+
+
+class BaseDispatcher(ABC):
+    """
+    The base dispatcher class to allow defining custom dispatchers.
+    Subclassed dispatchers must implement the `dispatch` method and
+    `dispatch_sync` methods. These dispatchers act as the interface
+    to the covalent dispatcher server and using the `dispatch` method
+    will allow the user to submit jobs to the dispatcher server.
+    """
+
+    def __init__(self) -> None:
+        pass
+
+    @abstractmethod
+    def dispatch(self, lattice: Lattice, custom_variables: Any) -> None:
+        """
+        Dispatch a lattice to the dispatcher server.
+        """
+
+        pass
+
+    @abstractmethod
+    def dispatch_sync(self, lattice: Lattice, custom_variables: Any) -> Result:
+        """
+        Dispatch a lattice to the dispatcher server and wait for the results.
+        """
+
+        pass
diff --git a/covalent/_dispatcher_plugins/local.py b/covalent/_dispatcher_plugins/local.py
new file mode 100644
index 000000000..9d27bb4a1
--- /dev/null
+++ b/covalent/_dispatcher_plugins/local.py
@@ -0,0 +1,141 @@
+# Copyright 2021 Agnostiq Inc.
+#
+# This file is part of Covalent.
+#
+# Licensed under the GNU Affero General Public License 3.0 (the "License").
+# A copy of the License may be obtained with this software package or at
+#
+#      https://www.gnu.org/licenses/agpl-3.0.en.html
+#
+# Use of this file is prohibited except in compliance with the License. Any
+# modifications or derivative works of this file must retain this copyright
+# notice, and modified files must contain a notice indicating that they have
+# been altered from the originals.
+#
+# Covalent is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the License for more details.
+#
+# Relief from the License may be granted by purchasing a commercial license.
+
+import inspect
+from copy import deepcopy
+from functools import wraps
+from typing import Callable
+
+import cloudpickle as pickle
+import requests
+
+from .._results_manager.result import Result
+from .._results_manager.results_manager import get_result
+from .._shared_files.config import get_config
+from .._workflow.lattice import Lattice
+from .base import BaseDispatcher
+
+
+class LocalDispatcher(BaseDispatcher):
+    """
+    Local dispatcher which sends the workflow to the locally running
+    dispatcher server.
+    """
+
+    @staticmethod
+    def dispatch(
+        orig_lattice: Lattice,
+        dispatcher_addr: str = get_config("dispatcher.address")
+        + ":"
+        + str(get_config("dispatcher.port")),
+    ) -> Callable:
+        """
+        Wrapping the dispatching functionality to allow input passing
+        and server address specification.
+
+        Afterwards, send the lattice to the dispatcher server and return
+        the assigned dispatch id.
+
+        Args:
+            orig_lattice: The lattice/workflow to send to the dispatcher server.
+            dispatcher_addr: The address of the dispatcher server.
+
+        Returns:
+            Wrapper function which takes the inputs of the workflow as arguments
+        """
+
+        @wraps(orig_lattice)
+        def wrapper(*args, **kwargs) -> str:
+            """
+            Send the lattice to the dispatcher server and return
+            the assigned dispatch id.
+
+            Args:
+                *args: The inputs of the workflow.
+                **kwargs: The keyword arguments of the workflow.
+
+            Returns:
+                The dispatch id of the workflow.
+            """
+
+            lattice = deepcopy(orig_lattice)
+
+            if lattice.workflow_function:
+                kwargs.update(
+                    dict(zip(list(inspect.signature(lattice.workflow_function).parameters), args))
+                )
+
+            lattice.build_graph(**kwargs)
+
+            # Serializing the transport graph and then passing it to the Result object
+            lattice.transport_graph = lattice.transport_graph.serialize()
+
+            pickled_res = pickle.dumps(Result(lattice, lattice.metadata["results_dir"]))
+            test_url = "http://" + dispatcher_addr + "/api/submit"
+
+            r = requests.post(test_url, data=pickled_res)
+            r.raise_for_status()
+            return r.content.decode("utf-8").strip().replace('"', "")
+
+        return wrapper
+
+    @staticmethod
+    def dispatch_sync(
+        lattice: Lattice,
+        dispatcher_addr: str = get_config("dispatcher.address")
+        + ":"
+        + str(get_config("dispatcher.port")),
+    ) -> Callable:
+        """
+        Wrapping the synchronous dispatching functionality to allow input
+        passing and server address specification.
+
+        Afterwards, sends the lattice to the dispatcher server and return
+        the result of the executed workflow.
+
+        Args:
+            orig_lattice: The lattice/workflow to send to the dispatcher server.
+            dispatcher_addr: The address of the dispatcher server.
+
+        Returns:
+            Wrapper function which takes the inputs of the workflow as arguments
+        """
+
+        @wraps(lattice)
+        def wrapper(*args, **kwargs) -> Result:
+            """
+            Send the lattice to the dispatcher server and return
+            the result of the executed workflow.
+
+            Args:
+                *args: The inputs of the workflow.
+                **kwargs: The keyword arguments of the workflow.
+
+            Returns:
+                The result of the executed workflow.
+            """
+
+            return get_result(
+                LocalDispatcher.dispatch(lattice, dispatcher_addr)(*args, **kwargs),
+                lattice.metadata["results_dir"],
+                wait=True,
+            )
+
+        return wrapper
diff --git a/covalent/_workflow/lattice.py b/covalent/_workflow/lattice.py
index 646a7c195..bccd28bf7 100644
--- a/covalent/_workflow/lattice.py
+++ b/covalent/_workflow/lattice.py
@@ -31,7 +31,6 @@
 import matplotlib.pyplot as plt
 import networkx as nx
 
-from .._results_manager.results_manager import get_result
 from .._shared_files import logger
 from .._shared_files.config import get_config
 from .._shared_files.context_managers import active_lattice_manager
@@ -289,77 +288,45 @@ def check_consumable(self) -> None:
 
     def dispatch(self, *args, **kwargs) -> str:
         """
-        Run the lattice-defined workflow with the dispatcher asynchronously.
+        Deprecated function to dispatch workflows
 
         Args:
-            *args: Positional arguments to be passed to the workflow function.
-            **kwargs: Keyword arguments to pass to the workflow function.
+            *args: Positional arguments for the workflow
+            **kwargs: Keyword arguments for the workflow
 
         Returns:
-            dispatch_id: the unique id of the dispatched job obtained from the dispatcher server.
+            Dispatch id assigned to job
         """
 
-        # Positional args are converted to kwargs
-        if self.workflow_function:
-            kwargs.update(
-                dict(zip(list(inspect.signature(self.workflow_function).parameters), args))
-            )
-
-        from .._results_manager import Result
-
-        self.build_graph(**kwargs)
-        self.check_consumable()
-
-        # Serializing the transport graph and then passing it to the Result object
-        transport_graph = self.transport_graph.serialize()
-        self.transport_graph, transport_graph = transport_graph, self.transport_graph
-
-        dispatch_id = self._server_dispatch(Result(self, self.metadata["results_dir"]))
+        app_log.warning(
+            "workflow.dispatch(your_arguments_here) is deprecated and may get removed without notice in future releases. Please use covalent.dispatch(workflow)(your_arguments_here) instead.",
+            exc_info=DeprecationWarning,
+        )
 
-        # Getting the transport graph back to the original state
-        self.transport_graph, transport_graph = transport_graph, self.transport_graph
+        from .._dispatcher_plugins import local_dispatch
 
-        return dispatch_id
+        return local_dispatch(self)(*args, **kwargs)
 
     def dispatch_sync(self, *args, **kwargs) -> "Result":
         """
-        Run the lattice-defined workflow with the dispatcher synchronously.
+        Deprecated function to dispatch workflows synchronously
 
         Args:
-            *args: Positional arguments to be passed to the workflow function.
-            **kwargs: Keyword arguments to pass to the workflow function.
+            *args: Positional arguments for the workflow
+            **kwargs: Keyword arguments for the workflow
 
         Returns:
-            result: Result of the workflow execution.
-
-        Note: Since it is synchronous dispatching, the result is waited for completion or failure.
+            Result of workflow execution
         """
 
-        # Positional args are converted to kwargs
-        if self.workflow_function:
-            kwargs.update(
-                dict(zip(list(inspect.signature(self.workflow_function).parameters), args))
-            )
-
-        return get_result(self.dispatch(**kwargs), self.metadata["results_dir"], wait=True)
-
-    def _server_dispatch(self, result_object: "Result") -> str:
-        """
-        Run the lattice-defined workflow with the dispatcher in server.
-
-        Args:
-            dispatch_id: A unique id assigned to the dispatch by the dispatcher.
-        """
-
-        import cloudpickle as pickle
-        import requests
+        app_log.warning(
+            "workflow.dispatch_sync(your_arguments_here) is deprecated and may get removed without notice in future releases. Please use covalent.dispatch_sync(workflow)(your_arguments_here) instead.",
+            exc_info=DeprecationWarning,
+        )
 
-        pickled_res = pickle.dumps(result_object)
-        test_url = "http://" + self.metadata["dispatcher"] + "/api/submit"
+        from .._dispatcher_plugins import local_dispatch_sync
 
-        r = requests.post(test_url, data=pickled_res)
-        r.raise_for_status()
-        return r.content.decode("utf-8").strip().replace('"', "")
+        return local_dispatch_sync(self)(*args, **kwargs)
 
 
 def lattice(
@@ -368,9 +335,6 @@ def lattice(
     backend: Optional[
         Union[List[Union[str, "BaseExecutor"]], Union[str, "BaseExecutor"]]
     ] = _DEFAULT_CONSTRAINT_VALUES.backend,
-    dispatcher: Optional[str] = get_config("dispatcher.address")
-    + ":"
-    + str(get_config("dispatcher.port")),
     results_dir: Optional[str] = get_config("dispatcher.results_dir"),
     # Add custom metadata fields here
     # e.g. schedule: True, whether to use a custom scheduling logic or not
@@ -394,7 +358,6 @@ def lattice(
 
     constraints = {
         "backend": backend,
-        "dispatcher": dispatcher,
         "results_dir": results_dir,
     }
 
diff --git a/covalent/executor/base.py b/covalent/executor/base.py
index 717a4a20f..a467a1319 100644
--- a/covalent/executor/base.py
+++ b/covalent/executor/base.py
@@ -27,12 +27,11 @@
 import tempfile
 from abc import ABC, abstractmethod
 from pathlib import Path
-from typing import Any, Iterable, Tuple, Union, ContextManager
+from typing import Any, ContextManager, Iterable, Tuple
 
 import cloudpickle as pickle
 
 from .._shared_files import logger
-from .._shared_files.config import get_config
 from .._shared_files.context_managers import active_dispatch_info_manager
 from .._shared_files.util_classes import DispatchInfo
 from .._workflow.transport import TransportableObject
@@ -41,11 +40,6 @@
 log_stack_info = logger.log_stack_info
 
 
-class ExecutorResult:
-    output: Any
-    error: Union[str, Exception]
-
-
 class BaseExecutor(ABC):
     """
     Base executor class to be used for defining any executor
@@ -80,10 +74,7 @@ def __init__(
         self.current_env_on_conda_fail = current_env_on_conda_fail
         self.current_env = ""
 
-    def get_dispatch_context(
-        self, 
-        dispatch_info: DispatchInfo
-    ) -> ContextManager[DispatchInfo]:
+    def get_dispatch_context(self, dispatch_info: DispatchInfo) -> ContextManager[DispatchInfo]:
         """
         Start a context manager that will be used to
         access the dispatch info for the executor.
@@ -321,4 +312,3 @@ def get_conda_path(self) -> bool:
             return False
         self.conda_path = which_conda
         return True
-
diff --git a/covalent_dispatcher/_core/__init__.py b/covalent_dispatcher/_core/__init__.py
index ff1745702..eab011719 100644
--- a/covalent_dispatcher/_core/__init__.py
+++ b/covalent_dispatcher/_core/__init__.py
@@ -18,412 +18,4 @@
 #
 # Relief from the License may be granted by purchasing a commercial license.
 
-"""
-Defines the core functionality of the dispatcher
-"""
-
-from datetime import datetime, timezone
-from typing import Any, Coroutine, Dict, List
-
-import cloudpickle as pickle
-import dask
-from dask.distributed import Client, Variable
-
-from covalent._results_manager import Result
-from covalent._results_manager import results_manager as rm
-from covalent._shared_files import logger
-from covalent._shared_files.context_managers import active_lattice_manager
-from covalent._shared_files.defaults import (
-    attr_prefix,
-    electron_dict_prefix,
-    electron_list_prefix,
-    exclude_from_postprocess,
-    generator_prefix,
-    parameter_prefix,
-    sublattice_prefix,
-    subscript_prefix,
-)
-from covalent._shared_files.util_classes import TaskExecutionMetadata
-from covalent._workflow.lattice import Lattice
-from covalent.executor import _executor_manager
-from covalent_ui import result_webhook
-
-app_log = logger.app_log
-log_stack_info = logger.log_stack_info
-
-dask_client = Client(processes=False, dashboard_address=":0")
-
-
-def get_task_inputs(task_input: dict, node_id: int, node_name: str, result_object: Result) -> dict:
-    """
-    Return the required inputs for a task execution.
-    This makes sure that any node with child nodes isn't executed twice and fetches the
-    result of parent node to use as input for the child node.
-
-    Args:
-        task_input: Input dictionary for the task containing the kwargs
-                    assigned to its function.
-        node_id: Node id of this task in the transport graph.
-        node_name: Name of the node.
-        result_object: Result object to be used to update and store execution related
-                       info including the results.
-
-    Returns:
-        inputs: Input dictionary to be passed to the task containing kwargs
-                and any parent node execution results if present.
-    """
-
-    if node_name.startswith(electron_list_prefix):
-        values = [
-            result_object.lattice.transport_graph.get_node_value(parent, "output")
-            for parent in result_object.lattice.transport_graph.get_dependencies(node_id)
-        ]
-        task_input = {"x": values}
-    elif node_name.startswith(electron_dict_prefix):
-        values = {}
-        for parent in result_object.lattice.transport_graph.get_dependencies(node_id):
-            key = result_object.lattice.transport_graph.get_edge_value(parent, node_id, "variable")
-            value = result_object.lattice.transport_graph.get_node_value(parent, "output")
-            values[key] = value
-        task_input = {"x": values}
-    else:
-        for parent in result_object.lattice.transport_graph.get_dependencies(node_id):
-            key = result_object.lattice.transport_graph.get_edge_value(parent, node_id, "variable")
-            value = result_object.lattice.transport_graph.get_node_value(parent, "output")
-            task_input[key] = value
-    return task_input
-
-
-def post_process(lattice: Lattice, node_outputs: dict) -> Any:
-    """
-    Post processing function to be called after the lattice execution.
-    This takes care of executing statements that were not an electron
-    but were inside the lattice's function. It also replaces any calls
-    to an electron with the result of that electron execution, hence
-    preventing a local execution of electron's function.
-
-    Note: Here `node_outputs` is used instead of `electron_outputs`
-    since an electron can be called multiple times with possibly different
-    arguments, but every time it's called, it will be executed as a separate node.
-    Thus, output of every node is used.
-
-    Args:
-        lattice: Lattice object that was dispatched.
-        node_outputs: Dictionary containing the output of all the nodes.
-
-    Reurns:
-        result: The result of the lattice function.
-    """
-
-    with active_lattice_manager.claim(lattice):
-        lattice.post_processing = True
-        lattice.electron_outputs = node_outputs
-        result = lattice.workflow_function(**lattice.kwargs)
-        lattice.post_processing = False
-        return result
-
-
-def _run_task(
-    inputs: Dict,
-    result_object: Result,
-    node_id: int,
-) -> None:
-    """
-    Run a task with given inputs on the selected backend.
-    Also updates the status of current node execution while
-    checking if a redispatch has occurred. Exclude those nodes
-    from execution which were completed.
-
-    Also verifies if execution of this dispatch has been cancelled.
-
-    Args:
-        inputs: Inputs for the task.
-        result_object: Result object being used for current dispatch
-        node_id: Node id of the task to be executed.
-
-    Returns:
-        None
-    """
-
-    serialized_callable = result_object.lattice.transport_graph.get_node_value(node_id, "function")
-    task_md = result_object.lattice.transport_graph.get_node_value(node_id, "exec_plan")
-    node_name = (
-        result_object.lattice.transport_graph.get_node_value(node_id, "name") + f"({node_id})"
-    )
-
-    shared_var = Variable(result_object.dispatch_id, client=dask_client)
-    if shared_var.get() == str(Result.CANCELLED):
-        app_log.info("Cancellation requested for dispatch %s", result_object.dispatch_id)
-
-        result_object._update_node(
-            node_id,
-            node_name,
-            None,
-            None,
-            Result.CANCELLED,
-            None,
-            None,
-        )
-
-        result_object.save()
-        result_webhook.send_update(result_object)
-
-        return
-
-    if result_object._get_node_status(node_id) == Result.COMPLETED:
-        return
-
-    # the executor is determined during scheduling and provided in the execution metadata
-    executor = _executor_manager.get_executor(task_md.selected_executor)
-
-    # run the task on the executor and register any failures
-    try:
-        start_time = datetime.now(timezone.utc)
-        result_object._update_node(
-            node_id, node_name, start_time, None, Result.RUNNING, None, None
-        )
-        result_object.save()
-        result_webhook.send_update(result_object)
-
-        if node_name.startswith(sublattice_prefix):
-            func = serialized_callable.get_deserialized()
-            sublattice_result = func.dispatch_sync(**inputs)
-            output = sublattice_result.result
-
-            end_time = datetime.now(timezone.utc)
-
-            result_object._update_node(
-                node_id,
-                node_name,
-                start_time,
-                end_time,
-                Result.COMPLETED,
-                output,
-                None,
-                sublattice_result,
-            )
-
-        else:
-            output, stdout, stderr = executor.execute(
-                serialized_callable,
-                inputs,
-                task_md.execution_args,
-                result_object.dispatch_id,
-                node_id,
-            )
-
-            end_time = datetime.now(timezone.utc)
-
-            result_object._update_node(
-                node_id,
-                node_name,
-                start_time,
-                end_time,
-                Result.COMPLETED,
-                output,
-                None,
-                stdout=stdout,
-                stderr=stderr,
-            )
-
-    except Exception as ex:
-        end_time = datetime.now(timezone.utc)
-        result_object._update_node(
-            node_id,
-            node_name,
-            start_time,
-            end_time,
-            Result.FAILED,
-            None,
-            ex,
-        )
-
-    result_object.save()
-    result_webhook.send_update(result_object)
-
-
-def _run_planned_workflow(result_object: Result) -> Result:
-    """
-    Run the workflow in the topological order of their position on the
-    transport graph. Does this in an asynchronous manner so that nodes
-    at the same level are executed in parallel. Also updates the status
-    of the whole workflow execution.
-
-    Args:
-        result_object: Result object being used for current dispatch
-
-    Returns:
-        None
-    """
-
-    shared_var = Variable(result_object.dispatch_id, client=dask_client)
-    shared_var.set(str(Result.RUNNING))
-
-    result_object._status = Result.RUNNING
-    result_object._start_time = datetime.now(timezone.utc)
-
-    order = result_object.lattice.transport_graph.get_topologically_sorted_graph()
-
-    for nodes in order:
-        tasks: List[Coroutine] = []
-
-        for node_id in nodes:
-            # Get all inputs for the current task
-            task_input = result_object.lattice.transport_graph.get_node_value(node_id, "kwargs")
-            node_name = result_object.lattice.transport_graph.get_node_value(node_id, "name")
-
-            if node_name.startswith(
-                (subscript_prefix, generator_prefix, parameter_prefix, attr_prefix)
-            ):
-                if node_name.startswith(parameter_prefix):
-                    output = list(task_input.values())[0]
-                else:
-                    parent = result_object.lattice.transport_graph.get_dependencies(node_id)[0]
-                    output = result_object.lattice.transport_graph.get_node_value(parent, "output")
-
-                    if node_name.startswith(attr_prefix):
-                        attr = task_input["attr"]
-                        output = getattr(output, attr)
-                    else:
-                        key = task_input["key"]
-                        output = output[key]
-
-                result_object._update_node(
-                    node_id,
-                    node_name + f"({node_id})",
-                    datetime.now(timezone.utc),
-                    datetime.now(timezone.utc),
-                    Result.COMPLETED,
-                    output,
-                    None,
-                )
-                continue
-
-            task_input = get_task_inputs(task_input, node_id, node_name, result_object)
-
-            # Add the task generated for the node to the list of tasks
-            tasks.append(dask.delayed(_run_task)(task_input, result_object, node_id))
-
-        # run the tasks for the current iteration in parallel
-        dask.compute(*tasks)
-
-        # When one or more nodes failed in the last iteration, don't iterate further
-        for node_id in nodes:
-            if result_object._get_node_status(node_id) == Result.FAILED:
-                result_object._status = Result.FAILED
-                result_object._end_time = datetime.now(timezone.utc)
-                result_object._error = f"Node {result_object._get_node_name(node_id)} failed: {result_object._get_node_error(node_id)}"
-                result_object.save()
-                result_webhook.send_update(result_object)
-                return
-
-            elif result_object._get_node_status(node_id) == Result.CANCELLED:
-                result_object._status = Result.CANCELLED
-                result_object._end_time = datetime.now(timezone.utc)
-                result_object.save()
-                result_webhook.send_update(result_object)
-                return
-
-    # post process the lattice
-    node_outputs_for_post_processing = {
-        k: v
-        for k, v in result_object.get_all_node_outputs().items()
-        if all(prefix not in k for prefix in exclude_from_postprocess)
-    }
-    result_object._result = post_process(result_object.lattice, node_outputs_for_post_processing)
-
-    result_object._status = Result.COMPLETED
-    result_object._end_time = datetime.now(timezone.utc)
-    result_object.save(write_source=True)
-    result_webhook.send_update(result_object)
-
-
-def _plan_workflow(result_object: Result) -> None:
-    """
-    Plan the workflow for execution, assigning the executor to each node
-    and assigning some common execution arguments to each node.
-
-    Args:
-        result_object: Result object being used for current dispatch
-
-    Returns:
-        None
-    """
-
-    serialized_tg = result_object.lattice.transport_graph.serialize(metadata_only=True)
-
-    schedule = result_object.lattice.transport_graph.lattice_metadata.get("schedule", False)
-
-    if schedule:
-        # Custom scheduling logic
-        pass
-    else:
-        # Default scheduling logic
-        workflow_schedule = {"nodes": [], "schedule_quality": 1}
-        deserialized_tg = pickle.loads(serialized_tg)
-
-        # Certain metadata fields are transformed and passed to the executor
-        for node in deserialized_tg["nodes"]:
-            workflow_schedule["nodes"].append(
-                {
-                    "id": node["id"],
-                    "backend": node["metadata"]["backend"][0]
-                    if isinstance(node["metadata"]["backend"], list)
-                    else node["metadata"]["backend"],
-                    # Mutate executor-specific arguments here
-                    "backend_args": {"results_dir": result_object.results_dir},
-                }
-            )
-
-    # Attach the execution plan to the transport graph
-    for node in workflow_schedule["nodes"]:
-        exec_plan = TaskExecutionMetadata(node["backend"], node["backend_args"])
-        result_object._lattice.transport_graph.set_node_value(node["id"], "exec_plan", exec_plan)
-
-
-def run_workflow(dispatch_id: str, results_dir: str) -> None:
-    """
-    Plan and run the workflow by loading the result object corresponding to the
-    dispatch id and retrieving essential information from it.
-    Returns without changing anything if a redispatch is done of a (partially or fully)
-    completed workflow with the same dispatch id.
-
-    Args:
-        dispatch_id: Dispatch id of the workflow to be run
-        results_dir: Directory where the result object is stored
-
-    Returns:
-        None
-    """
-
-    result_object = rm._get_result_from_file(dispatch_id, results_dir)
-
-    if result_object.status == Result.COMPLETED:
-        return
-
-    try:
-        _plan_workflow(result_object)
-        _run_planned_workflow(result_object)
-
-    except Exception as ex:
-        result_object._status = Result.FAILED
-        result_object._end_time = datetime.now(timezone.utc)
-        result_object._error = ex
-        result_object.save()
-        raise
-
-
-def cancel_workflow(dispatch_id: str) -> None:
-    """
-    Cancels a dispatched workflow using publish subscribe mechanism
-    provided by Dask.
-
-    Args:
-        dispatch_id: Dispatch id of the workflow to be cancelled
-
-    Returns:
-        None
-    """
-
-    shared_var = Variable(dispatch_id, client=dask_client)
-    shared_var.set(str(Result.CANCELLED))
+from .execution import cancel_workflow, run_workflow
diff --git a/covalent_dispatcher/_core/execution.py b/covalent_dispatcher/_core/execution.py
new file mode 100644
index 000000000..ebf6c2438
--- /dev/null
+++ b/covalent_dispatcher/_core/execution.py
@@ -0,0 +1,432 @@
+# Copyright 2021 Agnostiq Inc.
+#
+# This file is part of Covalent.
+#
+# Licensed under the GNU Affero General Public License 3.0 (the "License").
+# A copy of the License may be obtained with this software package or at
+#
+#      https://www.gnu.org/licenses/agpl-3.0.en.html
+#
+# Use of this file is prohibited except in compliance with the License. Any
+# modifications or derivative works of this file must retain this copyright
+# notice, and modified files must contain a notice indicating that they have
+# been altered from the originals.
+#
+# Covalent is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the License for more details.
+#
+# Relief from the License may be granted by purchasing a commercial license.
+
+"""
+Defines the core functionality of the dispatcher
+"""
+
+from datetime import datetime, timezone
+from typing import Any, Coroutine, Dict, List
+
+import cloudpickle as pickle
+import dask
+from dask.distributed import Client, Variable
+
+from covalent import dispatch_sync
+from covalent._results_manager import Result
+from covalent._results_manager import results_manager as rm
+from covalent._shared_files import logger
+from covalent._shared_files.context_managers import active_lattice_manager
+from covalent._shared_files.defaults import (
+    attr_prefix,
+    electron_dict_prefix,
+    electron_list_prefix,
+    exclude_from_postprocess,
+    generator_prefix,
+    parameter_prefix,
+    sublattice_prefix,
+    subscript_prefix,
+)
+from covalent._shared_files.util_classes import TaskExecutionMetadata
+from covalent._workflow.lattice import Lattice
+from covalent.executor import _executor_manager
+from covalent_ui import result_webhook
+
+app_log = logger.app_log
+log_stack_info = logger.log_stack_info
+
+dask_client = Client(processes=False, dashboard_address=":0")
+
+
+def _get_task_inputs(
+    task_input: dict, node_id: int, node_name: str, result_object: Result
+) -> dict:
+    """
+    Return the required inputs for a task execution.
+    This makes sure that any node with child nodes isn't executed twice and fetches the
+    result of parent node to use as input for the child node.
+
+    Args:
+        task_input: Input dictionary for the task containing the kwargs
+                    assigned to its function.
+        node_id: Node id of this task in the transport graph.
+        node_name: Name of the node.
+        result_object: Result object to be used to update and store execution related
+                       info including the results.
+
+    Returns:
+        inputs: Input dictionary to be passed to the task containing kwargs
+                and any parent node execution results if present.
+    """
+
+    if node_name.startswith(electron_list_prefix):
+        values = [
+            result_object.lattice.transport_graph.get_node_value(parent, "output")
+            for parent in result_object.lattice.transport_graph.get_dependencies(node_id)
+        ]
+        task_input = {"x": values}
+    elif node_name.startswith(electron_dict_prefix):
+        values = {}
+        for parent in result_object.lattice.transport_graph.get_dependencies(node_id):
+            key = result_object.lattice.transport_graph.get_edge_value(parent, node_id, "variable")
+            value = result_object.lattice.transport_graph.get_node_value(parent, "output")
+            values[key] = value
+        task_input = {"x": values}
+    else:
+        for parent in result_object.lattice.transport_graph.get_dependencies(node_id):
+            key = result_object.lattice.transport_graph.get_edge_value(parent, node_id, "variable")
+            value = result_object.lattice.transport_graph.get_node_value(parent, "output")
+            task_input[key] = value
+    return task_input
+
+
+def _post_process(lattice: Lattice, node_outputs: dict) -> Any:
+    """
+    Post processing function to be called after the lattice execution.
+    This takes care of executing statements that were not an electron
+    but were inside the lattice's function. It also replaces any calls
+    to an electron with the result of that electron execution, hence
+    preventing a local execution of electron's function.
+
+    Note: Here `node_outputs` is used instead of `electron_outputs`
+    since an electron can be called multiple times with possibly different
+    arguments, but every time it's called, it will be executed as a separate node.
+    Thus, output of every node is used.
+
+    Args:
+        lattice: Lattice object that was dispatched.
+        node_outputs: Dictionary containing the output of all the nodes.
+
+    Reurns:
+        result: The result of the lattice function.
+    """
+
+    with active_lattice_manager.claim(lattice):
+        lattice.post_processing = True
+        lattice.electron_outputs = node_outputs
+        result = lattice.workflow_function(**lattice.kwargs)
+        lattice.post_processing = False
+        return result
+
+
+def _run_task(
+    inputs: Dict,
+    result_object: Result,
+    node_id: int,
+) -> None:
+    """
+    Run a task with given inputs on the selected backend.
+    Also updates the status of current node execution while
+    checking if a redispatch has occurred. Exclude those nodes
+    from execution which were completed.
+
+    Also verifies if execution of this dispatch has been cancelled.
+
+    Args:
+        inputs: Inputs for the task.
+        result_object: Result object being used for current dispatch
+        node_id: Node id of the task to be executed.
+
+    Returns:
+        None
+    """
+
+    serialized_callable = result_object.lattice.transport_graph.get_node_value(node_id, "function")
+    task_md = result_object.lattice.transport_graph.get_node_value(node_id, "exec_plan")
+    node_name = (
+        result_object.lattice.transport_graph.get_node_value(node_id, "name") + f"({node_id})"
+    )
+
+    shared_var = Variable(result_object.dispatch_id, client=dask_client)
+    if shared_var.get() == str(Result.CANCELLED):
+        app_log.info("Cancellation requested for dispatch %s", result_object.dispatch_id)
+
+        result_object._update_node(
+            node_id,
+            node_name,
+            None,
+            None,
+            Result.CANCELLED,
+            None,
+            None,
+        )
+
+        result_object.save()
+        result_webhook.send_update(result_object)
+
+        return
+
+    if result_object._get_node_status(node_id) == Result.COMPLETED:
+        return
+
+    # the executor is determined during scheduling and provided in the execution metadata
+    executor = _executor_manager.get_executor(task_md.selected_executor)
+
+    # run the task on the executor and register any failures
+    try:
+        start_time = datetime.now(timezone.utc)
+        result_object._update_node(
+            node_id, node_name, start_time, None, Result.RUNNING, None, None
+        )
+        result_object.save()
+        result_webhook.send_update(result_object)
+
+        if node_name.startswith(sublattice_prefix):
+            func = serialized_callable.get_deserialized()
+            sublattice_result = dispatch_sync(func)(**inputs)
+            output = sublattice_result.result
+
+            end_time = datetime.now(timezone.utc)
+
+            result_object._update_node(
+                node_id,
+                node_name,
+                start_time,
+                end_time,
+                Result.COMPLETED,
+                output,
+                None,
+                sublattice_result,
+            )
+
+        else:
+            output, stdout, stderr = executor.execute(
+                serialized_callable,
+                inputs,
+                task_md.execution_args,
+                result_object.dispatch_id,
+                node_id,
+            )
+
+            end_time = datetime.now(timezone.utc)
+
+            result_object._update_node(
+                node_id,
+                node_name,
+                start_time,
+                end_time,
+                Result.COMPLETED,
+                output,
+                None,
+                stdout=stdout,
+                stderr=stderr,
+            )
+
+    except Exception as ex:
+        end_time = datetime.now(timezone.utc)
+        result_object._update_node(
+            node_id,
+            node_name,
+            start_time,
+            end_time,
+            Result.FAILED,
+            None,
+            ex,
+        )
+
+    result_object.save()
+    result_webhook.send_update(result_object)
+
+
+def _run_planned_workflow(result_object: Result) -> Result:
+    """
+    Run the workflow in the topological order of their position on the
+    transport graph. Does this in an asynchronous manner so that nodes
+    at the same level are executed in parallel. Also updates the status
+    of the whole workflow execution.
+
+    Args:
+        result_object: Result object being used for current dispatch
+
+    Returns:
+        None
+    """
+
+    shared_var = Variable(result_object.dispatch_id, client=dask_client)
+    shared_var.set(str(Result.RUNNING))
+
+    result_object._status = Result.RUNNING
+    result_object._start_time = datetime.now(timezone.utc)
+
+    order = result_object.lattice.transport_graph.get_topologically_sorted_graph()
+
+    for nodes in order:
+        tasks: List[Coroutine] = []
+
+        for node_id in nodes:
+            # Get all inputs for the current task
+            task_input = result_object.lattice.transport_graph.get_node_value(node_id, "kwargs")
+            node_name = result_object.lattice.transport_graph.get_node_value(node_id, "name")
+
+            if node_name.startswith(
+                (subscript_prefix, generator_prefix, parameter_prefix, attr_prefix)
+            ):
+                if node_name.startswith(parameter_prefix):
+                    output = list(task_input.values())[0]
+                else:
+                    parent = result_object.lattice.transport_graph.get_dependencies(node_id)[0]
+                    output = result_object.lattice.transport_graph.get_node_value(parent, "output")
+
+                    if node_name.startswith(attr_prefix):
+                        attr = task_input["attr"]
+                        output = getattr(output, attr)
+                    else:
+                        key = task_input["key"]
+                        output = output[key]
+
+                result_object._update_node(
+                    node_id,
+                    node_name + f"({node_id})",
+                    datetime.now(timezone.utc),
+                    datetime.now(timezone.utc),
+                    Result.COMPLETED,
+                    output,
+                    None,
+                )
+                continue
+
+            task_input = _get_task_inputs(task_input, node_id, node_name, result_object)
+
+            # Add the task generated for the node to the list of tasks
+            tasks.append(dask.delayed(_run_task)(task_input, result_object, node_id))
+
+        # run the tasks for the current iteration in parallel
+        dask.compute(*tasks)
+
+        # When one or more nodes failed in the last iteration, don't iterate further
+        for node_id in nodes:
+            if result_object._get_node_status(node_id) == Result.FAILED:
+                result_object._status = Result.FAILED
+                result_object._end_time = datetime.now(timezone.utc)
+                result_object._error = f"Node {result_object._get_node_name(node_id)} failed: {result_object._get_node_error(node_id)}"
+                result_object.save()
+                result_webhook.send_update(result_object)
+                return
+
+            elif result_object._get_node_status(node_id) == Result.CANCELLED:
+                result_object._status = Result.CANCELLED
+                result_object._end_time = datetime.now(timezone.utc)
+                result_object.save()
+                result_webhook.send_update(result_object)
+                return
+
+    # post process the lattice
+    node_outputs_for_post_processing = {
+        k: v
+        for k, v in result_object.get_all_node_outputs().items()
+        if all(prefix not in k for prefix in exclude_from_postprocess)
+    }
+    result_object._result = _post_process(result_object.lattice, node_outputs_for_post_processing)
+
+    result_object._status = Result.COMPLETED
+    result_object._end_time = datetime.now(timezone.utc)
+    result_object.save(write_source=True)
+    result_webhook.send_update(result_object)
+
+
+def _plan_workflow(result_object: Result) -> None:
+    """
+    Plan the workflow for execution, assigning the executor to each node
+    and assigning some common execution arguments to each node.
+
+    Args:
+        result_object: Result object being used for current dispatch
+
+    Returns:
+        None
+    """
+
+    serialized_tg = result_object.lattice.transport_graph.serialize(metadata_only=True)
+
+    schedule = result_object.lattice.transport_graph.lattice_metadata.get("schedule", False)
+
+    if schedule:
+        # Custom scheduling logic
+        pass
+    else:
+        # Default scheduling logic
+        workflow_schedule = {"nodes": [], "schedule_quality": 1}
+        deserialized_tg = pickle.loads(serialized_tg)
+
+        # Certain metadata fields are transformed and passed to the executor
+        for node in deserialized_tg["nodes"]:
+            workflow_schedule["nodes"].append(
+                {
+                    "id": node["id"],
+                    "backend": node["metadata"]["backend"][0]
+                    if isinstance(node["metadata"]["backend"], list)
+                    else node["metadata"]["backend"],
+                    # Mutate executor-specific arguments here
+                    "backend_args": {"results_dir": result_object.results_dir},
+                }
+            )
+
+    # Attach the execution plan to the transport graph
+    for node in workflow_schedule["nodes"]:
+        exec_plan = TaskExecutionMetadata(node["backend"], node["backend_args"])
+        result_object._lattice.transport_graph.set_node_value(node["id"], "exec_plan", exec_plan)
+
+
+def run_workflow(dispatch_id: str, results_dir: str) -> None:
+    """
+    Plan and run the workflow by loading the result object corresponding to the
+    dispatch id and retrieving essential information from it.
+    Returns without changing anything if a redispatch is done of a (partially or fully)
+    completed workflow with the same dispatch id.
+
+    Args:
+        dispatch_id: Dispatch id of the workflow to be run
+        results_dir: Directory where the result object is stored
+
+    Returns:
+        None
+    """
+
+    result_object = rm._get_result_from_file(dispatch_id, results_dir)
+
+    if result_object.status == Result.COMPLETED:
+        return
+
+    try:
+        _plan_workflow(result_object)
+        _run_planned_workflow(result_object)
+
+    except Exception as ex:
+        result_object._status = Result.FAILED
+        result_object._end_time = datetime.now(timezone.utc)
+        result_object._error = ex
+        result_object.save()
+        raise
+
+
+def cancel_workflow(dispatch_id: str) -> None:
+    """
+    Cancels a dispatched workflow using publish subscribe mechanism
+    provided by Dask.
+
+    Args:
+        dispatch_id: Dispatch id of the workflow to be cancelled
+
+    Returns:
+        None
+    """
+
+    shared_var = Variable(dispatch_id, client=dask_client)
+    shared_var.set(str(Result.CANCELLED))
diff --git a/doc/source/api/api.rst b/doc/source/api/api.rst
index cc4b5fb22..a2451eda7 100644
--- a/doc/source/api/api.rst
+++ b/doc/source/api/api.rst
@@ -7,7 +7,8 @@ The following API documentation describes how to use Covalent.
 
 - :ref:`electrons_api` and :ref:`lattices_api` are used for constructing workflows
 - :ref:`results_api` is used for collecting and manipulating results
-- The :ref:`dispatcher_api` is used for interfacing with the Covalent servers
+- :ref:`dispatcher_api` is used for dispatching workflows
+- The :ref:`dispatcher_server_api` is used for interfacing with the Covalent servers
 
 .. _electrons_api:
 
@@ -36,6 +37,19 @@ Lattice
 ----------------------------------------------------------------
 
 
+.. _dispatcher_api:
+
+Dispatcher
+""""""""""""""
+
+Dispatching jobs to the dispatcher servers
+
+.. autofunction:: dispatch
+.. autofunction:: dispatch_sync
+
+
+----------------------------------------------------------------
+
 .. _results_api:
 
 Results
@@ -54,7 +68,7 @@ Collecting and managing results
 
 .. currentmodule:: covalent_dispatcher
 
-.. _dispatcher_api:
+.. _dispatcher_server_api:
 
 Covalent CLI Tool
 """"""""""""""""""
diff --git a/doc/source/concepts/concepts.rst b/doc/source/concepts/concepts.rst
index 3af0c9ddc..6abf17b5c 100644
--- a/doc/source/concepts/concepts.rst
+++ b/doc/source/concepts/concepts.rst
@@ -193,7 +193,7 @@ There are a few best practices to highlight when working with lattices.
         abc_dict = task_1()
         return pd.DataFrame.from_dict(abc_dict)
 
-    res = workflow.dispatch_sync(a=1)
+    res = ct.dispatch_sync(workflow)(a=1)
 
 The code snippet above will not execute properly, since lattices are supposed to be used to construct the workflow and not manipulate the execution results of an electron. When :ref:`dispatch<Workflow dispatch>` is called, a :ref:`transport graph<Transport graph>` is built using the electrons as graph nodes. During construction, these electrons are not executed, but rather simply added to the transport graph; however, any non-electron is executed. In the example above, :code:`pd.DataFrame.from_dict()` (non-electron) is executed during construction while :code:`task_1` (electron) is not executed. This raises an error since the output of :code:`task_1` is not available to be used as an input for :code:`pd.DataFrame.from_dict()`.
 
@@ -216,7 +216,7 @@ The above example can be restructured using an extra electron to transform the d
         abc_dict = task_1()
         return task_2(abc_dict)
 
-    res = workflow.dispatch_sync(a=1)
+    res = ct.dispatch_sync(workflow)(a=1)
 
 However, lattices do support some basic parsing of electron outputs:
 
@@ -247,7 +247,7 @@ However, lattices do support some basic parsing of electron outputs:
         # len(a) -> getting the length
         # a[0] = 1 -> assigning a value
 
-    res = workflow.dispatch_sync(a=1)
+    res = ct.dispatch_sync(workflow)(a=1)
 
 Note that while the lattice construction has some minor restrictions, as indicated through these examples, electrons can be constructed from any Python function.
 
@@ -347,7 +347,7 @@ Once a workflow has been constructed, it is dispatched to the Covalent dispatche
 .. code-block:: python
     :linenos:
 
-    dispatch_id = run_experiment.dispatch(C=1.0, gamma=0.7)
+    dispatch_id = ct.dispatch(run_experiment)(C=1.0, gamma=0.7)
 
 
 Once the workflow has been submitted to the dispatcher, all the relevant workflow information, including execution status and results, are tagged with a unique dispatch ID. In other words, the workflow details and execution results are not tied to the initial workflow definition, but rather an instance of the workflow execution. Covalent is designed in this way so that the user can retrieve and analyze results at a later point in time.
@@ -434,7 +434,7 @@ The Covalent result manager is responsible for storing, updating, and retrieving
 
 .. code-block:: python
 
-    dispatch_id = workflow.dispatch(**params)
+    dispatch_id = ct.dispatch(workflow)(**params)
     result = ct.get_result(dispatch_id=dispatch_id, wait=False, results_dir='./results')
 
 The result manager allows us to retrieve the result object even if the computations have not completed by setting the :code:`wait` parameter to :code:`False` as shown above.
diff --git a/doc/source/getting_started/index.rst b/doc/source/getting_started/index.rst
index 975ba9277..6166710aa 100644
--- a/doc/source/getting_started/index.rst
+++ b/doc/source/getting_started/index.rst
@@ -156,7 +156,7 @@ Let's look at a simple example to get started with Covalent. Before starting, en
        return excitement(phrase)
 
    # Dispatch the workflow
-   dispatch_id = simple_workflow.dispatch("Hello", "World")
+   dispatch_id = ct.dispatch(simple_workflow)("Hello", "World")
 
 Navigate to the Covalent UI at `<http://0.0.0.0:47007>`_ to see your workflow in the queue:
 
diff --git a/doc/source/how_to/collection/query_electron_execution_result.ipynb b/doc/source/how_to/collection/query_electron_execution_result.ipynb
index 2ffd8f701..9b12b95a2 100644
--- a/doc/source/how_to/collection/query_electron_execution_result.ipynb
+++ b/doc/source/how_to/collection/query_electron_execution_result.ipynb
@@ -34,7 +34,7 @@
     "    res_1 = add(x=x, y=y)\n",
     "    return multiply(x=res_1, y=y)\n",
     "\n",
-    "dispatch_id = workflow.dispatch(x=2, y=3)\n",
+    "dispatch_id = ct.dispatch(workflow)(x=2, y=3)\n",
     "result = ct.get_result(dispatch_id=dispatch_id, wait=True, results_dir=RESULTS_DIR)"
    ]
   },
diff --git a/doc/source/how_to/collection/query_lattice_execution_result.ipynb b/doc/source/how_to/collection/query_lattice_execution_result.ipynb
index 8dcc98e5d..8e0543ee9 100644
--- a/doc/source/how_to/collection/query_lattice_execution_result.ipynb
+++ b/doc/source/how_to/collection/query_lattice_execution_result.ipynb
@@ -52,7 +52,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "dispatch_id = workflow.dispatch(x=2, y=3)\n",
+    "dispatch_id = ct.dispatch(workflow)(x=2, y=3)\n",
     "result = ct.get_result(dispatch_id=dispatch_id, wait=True, results_dir=RESULTS_DIR)"
    ]
   },
diff --git a/doc/source/how_to/collection/query_multiple_lattice_execution_results.ipynb b/doc/source/how_to/collection/query_multiple_lattice_execution_results.ipynb
index ba1d14670..2eaa63bef 100644
--- a/doc/source/how_to/collection/query_multiple_lattice_execution_results.ipynb
+++ b/doc/source/how_to/collection/query_multiple_lattice_execution_results.ipynb
@@ -46,7 +46,7 @@
     "\n",
     "\n",
     "params = [1, 2, 3, 4]\n",
-    "dispatch_ids = [workflow.dispatch(a=param) for param in params]\n",
+    "dispatch_ids = [ct.dispatch(workflow)(a=param) for param in params]\n",
     "\n",
     "print(dispatch_ids)"
    ]
diff --git a/doc/source/how_to/execution/cancel_dispatch.ipynb b/doc/source/how_to/execution/cancel_dispatch.ipynb
index f8a445cd8..0178fc99a 100644
--- a/doc/source/how_to/execution/cancel_dispatch.ipynb
+++ b/doc/source/how_to/execution/cancel_dispatch.ipynb
@@ -44,7 +44,7 @@
     "    task_2(task_1(), x)\n",
     "    return x ** 2\n",
     "\n",
-    "dispatch_id = workflow.dispatch(10)\n",
+    "dispatch_id = ct.dispatch(workflow)(10)\n",
     "print(dispatch_id)"
    ]
   },
diff --git a/doc/source/how_to/execution/choosing_conda_environments.ipynb b/doc/source/how_to/execution/choosing_conda_environments.ipynb
index 04cab7461..c294a03c7 100644
--- a/doc/source/how_to/execution/choosing_conda_environments.ipynb
+++ b/doc/source/how_to/execution/choosing_conda_environments.ipynb
@@ -86,7 +86,6 @@
    "source": [
     "@ct.lattice(\n",
     "    results_dir=RESULTS_DIR,\n",
-    "    dispatcher=\"0.0.0.0:48008\",\n",
     ")\n",
     "def workflow(a):\n",
     "    val_1 = identity(x=a)\n",
@@ -97,7 +96,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    ".. note:: Ensure that the covalent dispatcher server has been started properly before attempting to execute the lattice. Custom ports can be assigned via `covalent start --port [port no.]` which then needs to be modified accordingly in the `dispatcher` constraint. More details discussed in [How to add constraints to lattices](../orchestration/add_constraints_to_lattice.ipynb)."
+    ".. note:: Ensure that the covalent dispatcher server has been started properly before attempting to execute the lattice. Custom ports can be assigned via `covalent start --port [port no.]` which then needs to be modified accordingly in the `dispatcher_addr` parameter below. More details discussed in [How to add constraints to lattices](../orchestration/add_constraints_to_lattice.ipynb)."
    ]
   },
   {
@@ -113,7 +112,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "dispatch_id = workflow.dispatch(a=2)"
+    "dispatch_id = ct.dispatch(workflow, dispatcher_addr=\"0.0.0.0:48008\")(a=2)"
    ]
   },
   {
diff --git a/doc/source/how_to/execution/choosing_executors.ipynb b/doc/source/how_to/execution/choosing_executors.ipynb
index 882e196c3..995afc3ad 100644
--- a/doc/source/how_to/execution/choosing_executors.ipynb
+++ b/doc/source/how_to/execution/choosing_executors.ipynb
@@ -75,10 +75,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "@ct.lattice(\n",
-    "    results_dir=RESULTS_DIR,\n",
-    "    dispatcher=\"0.0.0.0:48008\",\n",
-    ")\n",
+    "@ct.lattice(results_dir=RESULTS_DIR,)\n",
     "def workflow(a):\n",
     "    val_1 = identity(x=a)\n",
     "    return square(x=val_1)"
@@ -88,7 +85,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    ".. note:: Ensure that the covalent dispatcher server has been started properly before attempting to execute the lattice. Custom ports can be assigned via `covalent start --port [port no.]` which then needs to be modified accordingly in the `dispatcher` constraint. More details discussed in [How to add constraints to lattices](../orchestration/add_constraints_to_lattice.ipynb)."
+    ".. note:: Ensure that the covalent dispatcher server has been started properly before attempting to execute the lattice. Custom ports can be assigned via `covalent start --port [port no.]` which then needs to be modified accordingly in the `dispatcher_addr` parameter below. More details discussed in [How to add constraints to lattices](../orchestration/add_constraints_to_lattice.ipynb)."
    ]
   },
   {
@@ -112,7 +109,7 @@
     }
    ],
    "source": [
-    "dispatch_id = workflow.dispatch(a=2)\n",
+    "dispatch_id = ct.dispatch(workflow, dispatcher_addr=\"0.0.0.0:48008\")(a=2)\n",
     "print(dispatch_id)"
    ]
   },
diff --git a/doc/source/how_to/execution/execute_individual_electron.ipynb b/doc/source/how_to/execution/execute_individual_electron.ipynb
index 22370b96b..a605a34e1 100644
--- a/doc/source/how_to/execution/execute_individual_electron.ipynb
+++ b/doc/source/how_to/execution/execute_individual_electron.ipynb
@@ -46,9 +46,18 @@
    "cell_type": "code",
    "execution_count": 2,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "caf6cafb-2c6c-4e87-a1c8-087636644d29\n"
+     ]
+    }
+   ],
    "source": [
-    "dispatch_id = product(2, 3)"
+    "dispatch_id = ct.dispatch(product)(2, 3)\n",
+    "print(dispatch_id)"
    ]
   },
   {
@@ -75,7 +84,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.8"
+   "version": "3.8.12"
   }
  },
  "nbformat": 4,
diff --git a/doc/source/how_to/execution/execute_lattice.ipynb b/doc/source/how_to/execution/execute_lattice.ipynb
index 31cf695f1..444fb44e4 100644
--- a/doc/source/how_to/execution/execute_lattice.ipynb
+++ b/doc/source/how_to/execution/execute_lattice.ipynb
@@ -66,7 +66,7 @@
     }
    ],
    "source": [
-    "dispatch_id = workflow.dispatch(a=2)\n",
+    "dispatch_id = ct.dispatch(workflow)(a=2)\n",
     "dispatch_id"
    ]
   },
diff --git a/doc/source/how_to/execution/execute_multiple_lattices.ipynb b/doc/source/how_to/execution/execute_multiple_lattices.ipynb
index 4bfd6587a..1359591ea 100644
--- a/doc/source/how_to/execution/execute_multiple_lattices.ipynb
+++ b/doc/source/how_to/execution/execute_multiple_lattices.ipynb
@@ -75,7 +75,7 @@
    ],
    "source": [
     "params = [1, 2, 3, 4]\n",
-    "dispatch_ids = [workflow.dispatch(a=param) for param in params]\n",
+    "dispatch_ids = [ct.dispatch(workflow)(a=param) for param in params]\n",
     "\n",
     "dispatch_ids"
    ]
diff --git a/doc/source/how_to/execution/execute_sublattice.ipynb b/doc/source/how_to/execution/execute_sublattice.ipynb
index a18495f29..619362ca6 100644
--- a/doc/source/how_to/execution/execute_sublattice.ipynb
+++ b/doc/source/how_to/execution/execute_sublattice.ipynb
@@ -78,7 +78,7 @@
     }
    ],
    "source": [
-    "dispatch_id = workflow.dispatch(a=2)\n",
+    "dispatch_id = ct.dispatch(workflow)(a=2)\n",
     "print(\"Dispatch id:\", dispatch_id)\n",
     "\n",
     "result = ct.get_result(dispatch_id, wait=True, results_dir=RESULTS_DIR)\n",
diff --git a/doc/source/how_to/execution/synchronize_lattice.ipynb b/doc/source/how_to/execution/synchronize_lattice.ipynb
index 4248a112c..6ebdfef05 100644
--- a/doc/source/how_to/execution/synchronize_lattice.ipynb
+++ b/doc/source/how_to/execution/synchronize_lattice.ipynb
@@ -35,7 +35,7 @@
     "    return x + 5\n",
     "\n",
     "inputs = [1, 2, 3]\n",
-    "dispatch_ids = [workflow.dispatch(x=x) for x in inputs]\n",
+    "dispatch_ids = [ct.dispatch(workflow)(x=x) for x in inputs]\n",
     "print(dispatch_ids)"
    ]
   },
diff --git a/doc/source/how_to/orchestration/add_constraints_to_lattice.ipynb b/doc/source/how_to/orchestration/add_constraints_to_lattice.ipynb
index d263ce712..2bfccdad5 100644
--- a/doc/source/how_to/orchestration/add_constraints_to_lattice.ipynb
+++ b/doc/source/how_to/orchestration/add_constraints_to_lattice.ipynb
@@ -35,8 +35,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "@ct.lattice(results_dir=\"/tmp/results\",\n",
-    "            dispatcher=\"0.0.0.0:5001\")\n",
+    "@ct.lattice(results_dir=\"/tmp/results\")\n",
     "def workflow(a):\n",
     "    return identity(x=a)"
    ]
@@ -45,7 +44,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    ".. tip:: When the dispatcher server is started via `covalent start`, a default port is set. The same default port is the default value of the dispatcher constraint. If we started the dispatcher server with `covalent start --port [port no.]`, we then have to change the dispatcher field in the `lattice` decorator."
+    ".. tip:: When the dispatcher server is started via `covalent start`, a default port is set. The same default port is the default value of the dispatcher address field in `ct.dispatch`. If we started the dispatcher server with `covalent start --port [port no.]`, we then have to change the dispatcher address field in `ct.dispatch`."
    ]
   },
   {
diff --git a/doc/source/how_to/status/query_electron_execution_status.ipynb b/doc/source/how_to/status/query_electron_execution_status.ipynb
index 788d2b7ac..b3f60505a 100644
--- a/doc/source/how_to/status/query_electron_execution_status.ipynb
+++ b/doc/source/how_to/status/query_electron_execution_status.ipynb
@@ -84,7 +84,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "dispatch_id = workflow.dispatch(x=1, y=2)"
+    "dispatch_id = ct.dispatch(workflow)(x=1, y=2)"
    ]
   },
   {
diff --git a/doc/source/how_to/status/query_lattice_execution_status.ipynb b/doc/source/how_to/status/query_lattice_execution_status.ipynb
index d8435e34e..53a898187 100644
--- a/doc/source/how_to/status/query_lattice_execution_status.ipynb
+++ b/doc/source/how_to/status/query_lattice_execution_status.ipynb
@@ -52,7 +52,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "dispatch_id = workflow.dispatch(x=2, y=3)"
+    "dispatch_id = ct.dispatch(workflow)(x=2, y=3)"
    ]
   },
   {
diff --git a/doc/source/how_to/status/query_lattice_execution_time.ipynb b/doc/source/how_to/status/query_lattice_execution_time.ipynb
index a88f9a65c..df96c7f25 100644
--- a/doc/source/how_to/status/query_lattice_execution_time.ipynb
+++ b/doc/source/how_to/status/query_lattice_execution_time.ipynb
@@ -58,7 +58,7 @@
     }
    ],
    "source": [
-    "dispatch_id = workflow.dispatch(x=2, y=3)\n",
+    "dispatch_id = ct.dispatch(workflow)(x=2, y=3)\n",
     "result = ct.get_result(dispatch_id=dispatch_id, wait=True, results_dir=RESULTS_DIR)\n",
     "print(f\"Execution time: {(result.end_time - result.start_time).total_seconds():.2f} seconds\")"
    ]
diff --git a/doc/source/tutorials/astronomy/star_tracker.ipynb b/doc/source/tutorials/astronomy/star_tracker.ipynb
index 0820dc20f..d600da4d0 100644
--- a/doc/source/tutorials/astronomy/star_tracker.ipynb
+++ b/doc/source/tutorials/astronomy/star_tracker.ipynb
@@ -230,7 +230,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABnAAAALICAYAAABPU745AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOzdd1QT2d8G8CeAdJAqWBAFBRQ79t4rgr33CjbW3bWs6NrLWtauWLD33sC1Y3ctKFYURVFBEUGkt3DfP3zJzyjWFSaS53OOxyQzmTwzuSST+525IxNCCBAREREREREREREREZHK0JA6ABERERERERERERERESljAYeIiIiIiIiIiIiIiEjFsIBDRERERERERERERESkYljAISIiIiIiIiIiIiIiUjEs4BAREREREREREREREakYFnCIiIiIiIiIiIiIiIhUDAs4REREREREREREREREKoYFHCIiIiIiIiIiIiIiIhXDAg4REREREREREREREZGKYQGHiIiIiIiIiIiIiIhIxbCAQ0REREREREREREREpGJYwCEiIiIiIiIiIiIiIlIxLOAQERERERERERERERGpGBZwiIiIiIiIiIiIiIiIVAwLOERERERERERERERERCqGBRwiIiIiIiIiIiIiIiIVwwIOERERERERERERERGRimEBh4iIiIiIiIiIiIiISMWwgENERERERERERERERKRiWMAhIiIiIiIiIiIiIiJSMSzgEBERERERERERERERqRgWcIiIiIiIiIiIiIiIiFQMCzhEREREREREREREREQqhgUcIiIiIiIiIiIiIiIiFcMCDhERERERERERERERkYphAYeIiIiIiIiIiIiIiEjFsIBDRERERERERERERESkYljAISIiIiIiIiIiIiIiUjEs4BAREREREREREREREakYFnCIiIiIiIiIiIiIiIhUDAs4REREREREREREREREKoYFHCIiIiIiIiIiIiIiIhXDAg4REREREREREREREZGKYQGHiIiIiIiIiIiIiIhIxbCAQ0REREREREREREREpGJYwCEiIiIiIiIiIiIiIlIxLOAQERERERERERERERGpGBZwiIiIiIiIiIiIiIiIVAwLOERERERERERERERERCqGBRwiIiIiIiIiIiIiIiIVwwIOERERERERERERERGRimEBh4iIiIiIiIiIiIiISMWwgENERERERERERERERKRiWMAhIiIiIiIiIiIiIiJSMSzgEBERERERERERERERqRgWcIiIiIiIiIiIiIiIiFQMCzhEREREREREREREREQqhgUcIiIiIiIiIiIiIiIiFcMCDhERERERERERERERkYphAYeIiIiIiIiIiIiIiEjFsIBDRERERERERERERESkYljAISIiIiIiIiIiIiIiUjEs4BAREREREREREREREakYFnCIiIiIiIiIiIiIiIhUDAs4REREpFZkMhkMDAzg7e39VfP7+vrC0NAQMpkMDx8+zOF0pC7YDkkVsB2SlL61/X1Jw4YNoauri9q1a/+Q5RERERGpAhZwiIiISO0EBQVh+vTpAIAHDx7A3d0dlpaWMDMzQ7NmzXD//n3FvP3790dCQoJUUSkPe78dvn79GrVq1YK5uTlMTExQo0YNnD9/XjEv2yHllPfbIQAcPHgQZcqUgaGhIWrWrIm7d+8qprEd0o/2YfsbNGgQHB0doaGhgXXr1inNe/v2bTRr1gwWFhaQyWQfLevkyZPw8fHJ6chEREREuYoFHCIiIlJrsbGxcHNzw/379xEZGYmqVavC3d1d6likZgwNDbFmzRpERUXhzZs3GDNmDFq3bo2MjAypo5EaCQkJQffu3eHj44PY2Fi0bt0abm5ubIeUa8qXL49ly5ahUqVKH03Lly8fOnXqBF9fXwmSEREREUmDBRwiIiJSa1WrVkX//v1hZmaGfPnyYeTIkbh//z6io6OljkZqRFdXV3HUuRACmpqaePPmDWJiYqSORmrkyJEjqFOnDmrXrg0tLS2MGTMG4eHhOH36tNTRSE0MHToUjRo1gq6u7kfTHB0d0b9/fzg7O0uQjIiIiEgaLOAQERERvefMmTOwtraGubm51FFIDZUrVw66urpwc3PDgAEDUKBAAakjkZoRQijdFkLg9u3bEiYiIiIiIlJfLOAQERER/b/nz59j6NCh+Pvvv6WOQmrq5s2biIuLw5YtW3ghbsp1jRs3xunTpxEQEIC0tDTMmDEDaWlpSEpKkjoaEREREZFaYgGHiIiICEBUVBSaNm2KIUOGoGvXrlLHITWmq6uLrl27YtasWQgKCpI6DqkRJycnrF+/HsOGDUPBggXx+vVrlC5dGkWKFJE6GhERERGRWmIBh4iIiNTemzdv0LRpU7i5ucHb21vqOEQAgPT0dISGhkodg9RMhw4dcPv2bURHR2Py5Ml48uQJqlSpInUsIiIiIiK1xAIOERERqbW4uDg0a9YMtWrVwqxZs6SOQ2rq0qVLOHfuHNLS0pCcnIy//voLkZGRqFatmtTRSM1cu3YNcrkcUVFRGDRoENzc3ODk5CR1LFITaWlpSElJgRAC6enpSElJQWZmJoB312RKSUlBWloaACAlJQWpqalSxiUiIiLKcSzgEBERkVrbu3cvrly5grVr18LQ0FDx7+nTp1JHIzWSmpqKoUOHwtzcHIULF4a/vz/8/PxQqFAhqaORmvHy8oKJiQkcHR1hamqKVatWSR2J1EjTpk2hp6eHCxcuYNCgQdDT08OZM2cAAGFhYdDT04OzszMAQE9PD46OjlLGJSIiIspxLOAQERGRWtHR0YGLiwsmTJgAAOjduzeEEEhMTERCQoLiX9GiRQEAa9euhYmJCXR0dKChwV0n+jE+bIf16tVDUFAQ4uPjERMTg9OnT6Nu3bqK+dkOKSd82A4B4Ny5c4p2uGLFChgYGCimsR3Sj5Rd+wsICIAQQulf/fr1AQDFihX7aNqTJ08Uz23SpAmGDx8OHR2dXF4TIiIiopwjE0IIqUMQERERERERERERERHR//CwKSIiIiIiIiIiIiIiIhXDAg4REREREREREREREZGKYQGHiIiISALOzs4ICAj45PQZM2ZgwIABuReI6Cu1aNEC69evlzoGSeRLn12UvT59+mD8+PFSx8hT2Ba/D9siERHRz4UFHCIiIiIAT548gUwmQ0ZGRq683p07dxQXZs7OuHHjsHr16lzJQjkjJ9pUQEAAihQp8sOW9z0OHz6M3r17f3E+mUyGhw8ffnaeJUuWoHLlytDR0UGfPn1+UELVkJOfKY8fP4aGhgY8PT1/+LK/5EufXd+iWbNmOHr0KCZNmoQePXr8kGV+jXXr1kEmk2H79u259ppSYlv8MrZFIiIiUlUs4BAREZFKEkIgMzNT6hhf7Ud2jOVWEUndqEub+pnaT6FChTB+/Hj069cvx18rL73/GzZsgKmpKbZv347U1FTJ83yPxMREXL16FfXq1fuhy/0a69evh5mZGTZs2JDrrw2wLeZknu+hzm2RiIiIVB8LOERERPRDFStWDDNnzkTp0qVhamqKvn37IiUlBQDw5s0buLq6wtLSEqampnB1dcXz588Vz61fvz68vb1Rq1Yt6OvrIzQ0FGvXrkWpUqVgZGQEOzs7rFixQjF/1tkIs2fPRoECBVCwYEHs27cP/v7+cHBwgJmZGWbMmKGYPzMzE7NmzYK9vT3Mzc3RqVMnxMTEAADq1q0LADAxMYGhoSEuXrwIAFizZg1KlSoFU1NTNGvWDGFhYYrlyWQyLF26FCVLlkTJkiU/2havX7+Gq6srTExMYGZmhjp16ig67YoVK4bjx48DACZNmoQOHTqgR48eMDY2xrp165SOAs7urIv3n3/58mVUrlwZxsbGsLKywq+//vo9b53KYpt6JzExES1atEBERAQMDQ1haGiIiIiIbNvP5cuXUaNGDZiYmKBgwYIYNmwY0tLSlF5n0aJFsLOzg4WFBUaNGqVom+vWrUOtWrUwbNgw5M+fH05OTjhx4oTSNs06O+zhw4eoV68e8ufPDwsLC3Tu3Flp3cuXLw9DQ8NPHl3erl07tGnTBubm5nz/v/D+ZxFCYMOGDZg2bRry5cuHgwcPKk2XyWRYtmwZSpYsCSMjI0yYMAGPHj1CzZo1YWxsjE6dOim1hUOHDqFChQowMTFBzZo1cfPmTaVt/9dff6FcuXIwMDBARkaG0mePXC7HjBkzYG9vDyMjI7i4uODZs2cAAC8vL9jY2MDY2BguLi44e/asUs4TJ06gVq1a0NHR+eR7DwAHDhyAs7MzTExMUL9+fdy7d08x7a+//kLhwoVhZGQER0dHpXb6KWFhYTh9+jRWrlyJI0eO4OXLl4ppWe//vHnzFO//2rVrFdOLFi2KUqVKQVNTE1paWihfvjxq1qwJ4F1brF+/PrS1taGhoQFDQ0MsX75c8dx//vkHp06dUrTF1atXo2jRotDU1ISmpiaKFCmiaIt//fUXLCwsoKGhoWjbbItsi++3xejoaLRu3RrGxsaoUqUKxo8fj9q1ayumBwcHo0mTJjAzM4OjoyN27NjxyRyf2+7fs15ERET0gwkiIiKi/8jT01N4enoKIYSwtbUVzs7O4unTpyI6OlrUrFlTeHt7CyGEeP36tdi1a5dITEwUcXFxokOHDsLd3V2xnHr16gkbGxtx+/ZtkZ6eLtLS0sShQ4fEw4cPRWZmpggICBB6enri2rVrQgghTp06JTQ1NcXkyZNFWlqaWLlypbCwsBBdu3YVcXFx4vbt20JXV1eEhoYKIYRYsGCBqFatmnj27JlISUkRgwYNEl26dBFCCPH48WMBQKSnpyvy7Nu3T9jb24u7d++K9PR0MXXqVFGjRg3FdACicePGIjo6WiQlJQkhhMifP784e/asEEKIsWPHisGDB4u0tDSRlpYmzpw5IzIzMxXb6dixY0IIISZOnCi0tLTE3r17hVwuF0lJSWLixImie/fuivUsXLiw0jZ///nVq1cXGzZsEEIIER8fLy5evPif3k9VwDaVfZvKri1k136uXr0qLl68KNLT08Xjx4+Fk5OTmD9/vtLr1K9fX0RHR4uwsDBRsmRJsWrVKiGEEGvXrhWampri77//FmlpaWLbtm3C2NhYREdHK7Zp1rxdunQR06ZNE3K5XCQnJytyZr1GSEjIV73f3t7eonfv3nz/v/D+CyHEmTNnhLa2toiJiRHDhg0Trq6uStsSgHBzcxNv374Vt2/fFtra2qJhw4bi0aNHIjY2VpQqVUqsW7dOCCFEYGCgsLS0FJcuXRIZGRli3bp1wtbWVqSkpCi2ffny5cXTp08Ved7/7Jk9e7YoU6aMCA4OFpmZmeLGjRvi9evXQgghNm7cKF6/fi3S09PF3LlzhZWVlUhOTlbkHDx4sPDx8RFCCKXPu/fdv39f6Ovri6NHj4q0tDTx119/CXt7e5GamiqCg4NFkSJFRHh4uGJ7P3z4MNv29b4pU6aIKlWqCCGEKFOmjJg7d65iWtb7P2HCBJGWlib8/PyEpqam6NevnxBCCH19fWFsbCzu378vzp8/L7S1tUWRIkWEEEKEhYUJMzMzsXz5chETEyMaN24s8uXLJ+7cuSOEEMLKykoYGxuL27dvi8uXLwsLCwsxb948cf/+fbF27VphZWUl9PT0xO7du0WRIkXEzp07haamphg5cqS4d+8e2yLbotDT0xMxMTFCCCE6d+4sOnfuLBITE8WdO3dEkSJFRK1atYQQQiQkJIgiRYqINWvWiPT0dBEYGCjMzc0VbbF3796Kz9DPbffvXS8iIiL6sVjAISIioh/K1tZWLF++XHHfz89P2NnZZTvv9evXhYmJieJ+vXr1xIQJEz67fHd3d7FgwQIhxLsODl1dXZGRkSGEECIuLk4AEJcuXVLMX6lSJbF3714hhBBOTk7i+PHjimkRERFCS0tL0cn9YQdX8+bNxerVqxX35XK50NPTE0+ePBFCvOucOnHixCezTpgwQbi5uWXbif1hAadOnTpK07+lgFOnTh3x559/iqioqE9m+ZmxTf3Ppwo4H7afD82fP1+0adNGcR+AOHz4sOL+0qVLRcOGDYUQ7wo4BQsWVBQbhRCiSpUqiiLh+wWcnj17ioEDB4pnz5599Jr/pYDzPr7/yvr3768oUl24cEFoaWmJyMhIxXQA4ty5c0p5Z82apbj/66+/Ci8vLyGEEB4eHmL8+PFKy3dwcBABAQFCiHfb3tfXV2n6+589Dg4OYt++fZ/Nm8XExETcuHFDcd/GxkY8ffpUCPHpTvMpU6aIjh07Ku7L5XJRqFAhcerUKRESEiIsLS3FsWPHRFpa2ldlEEKIEiVKKIqZM2bMEOXKlVNMy3r/33/PLC0txcWLF0VGRoYAICZNmqSY1rlzZ6GrqyuEEGLbtm2idu3aimnXr18X2traivmtrKwU0z+13WvVqiW8vb2FpaWlmDt3Ltsi2+In26KWlpYIDg5WTPP29lYUcD5si0IIMWjQIEVbfL+A87nt/r3rRURERD8Wh1AjIiKiH87GxkZx29bWFhEREQCApKQkDB48GLa2tjA2NkbdunURGxsLuVye7XOBdxdMr169OszMzGBiYgJ/f3+8fv1aMd3c3ByampoAAD09PQCAlZWVYrqenh4SEhIAvBuupG3btjAxMYGJiYliKJzIyMhs1yMsLAxeXl6K+c3MzCCEQHh4+Cfzvm/UqFEoUaIEmjZtCjs7O8yaNeurttm38vX1xYMHD+Dk5IQqVarg0KFD370sVcU29fXbBwAePHgAV1dXWFtbw9jYGOPGjVNaxw+f8/42BYDChQtDJpN9cnqW2bNnQwiBqlWrwtnZGWvWrPlkxhYtWiiGftu8efN3r586v//JycnYuXMnunfvDgCoUaMGihYtii1btijN92Hez+WfN2+eIo+JiQmePXum9F5/Ls+zZ89gb2+f7bS5c+eiVKlSyJ8/P0xMTPD27VvFdr516xby58//xbYeEREBW1tbxX0NDQ3Y2NggPDwcJUqUwIIFCzBp0iQUKFAAXbp0ybaNvu/8+fN4/PgxunTpAgDo1q0bbt26hRs3bijmMTc3h5aWluK+vr4+EhISEBUVBQAoW7asYpqjo6NiCLCQkBBcuHABGhoakMlkqFixItLS0pQyGRsbA/jfdjcwMICWlhY0NDTw4MEDXLp0CTKZDAsWLMC6deuQmpqK7t27IyIigm3xC3nUrS1mZGQoZX7/dlhYGP7991+lbbl582alIdren/dT2/171ouIiIh+PBZwiIiI6IfLGnceAJ4+fYpChQoBAObNm4f79+/j33//RVxcHM6cOQPg3Tj6Wd7vNE5NTUX79u3x+++/IzIyErGxsWjZsqXS/N/CxsYGhw8fRmxsrOJfSkrKR53V78+/YsUKpfmTk5MV1zz4MO+HjIyMMG/ePISGhuLAgQP4+++/Pzl+/OeWY2BggKSkJMV9uVyu6EwEgJIlS2Lr1q149eoVxowZgw4dOiAxMfGz2+Jnwzb1+WkfPu7p6QknJyeEhIQgLi4OM2bM+GgdP7VNASA8PFxp/g+nZ7G2tsaqVasQERGBFStWYMiQIXj48GG2GQ8fPoyEhAQkJCQoOn2/Ft//d/bu3Yu4uDgMGTIE1tbWsLa2Rnh4ONavX//d+b29vZXyJCUloWvXrl+Vx8bGBo8ePfro8bNnz2L27NnYsWMH3rx5g9jYWOTPn1+xnf39/dGyZcsv5itUqJDSdVmEEHj27BkKFy4M4F2n97lz5xAWFgaZTIYxY8Z8dnnr16+HEAIVKlSAtbU1qlWrpnj8SywtLQG86/DPcv/+fWhrawMAgoKCYGxsjIiICAghcP36dQDA0qVLP1qWjY0NxowZAyEEtm3bhtTUVAgh4OrqCiEEunXrhsWLF6NgwYJftV5Zy2RbVJ+2qKWlpXS9r/c/I21sbFCvXj2lbZmQkKB0Tab35/3cdv/W9SIiIqIfjwUcIiIi+uGWLl2K58+fIyYmBtOnT1dc2Dw+Ph56enowMTFBTEwMJk+e/NnlpKWlITU1VdFZcfjwYRw9evS7c3l4eMDb21vRCRMVFYX9+/cDeNchoqGhgdDQUKX5Z86ciTt37gAA3r59i507d2a77AsXLmDt2rVKHcGHDh3Cw4cPIYRA/vz5oampCQ2Nb9/9cnBwQEpKCvz8/JCeno5p06YhNTVVMX3Tpk2IioqChoYGTExMAOC7XkeVqWObyo6VlRWio6Px9u3bz84XHx8PY2NjGBoaIjg4ONuOuzlz5uDNmzd49uwZFi5cqNimAPDq1SssWrQI6enp2LlzJ+7du5dtJ+fOnTsVnYimpqaQyWSKtmdlZaW07tnJyMhASkoK5HI55HI5UlJSkJGR8dF8fP/fWb9+Pfr166c4Uv/GjRs4f/48goKClAoLX2vgwIHw8fHBv//+CyEEEhMT4efnh/j4+K96/oABAzBhwgSEhIRACIGbN28iOjoa8fHx0NLSgqWlJTIyMjBlyhTExcUpnufv749WrVopLSszMxMpKSmKf6mpqejUqRP8/Pxw4sQJpKenY968edDR0UHNmjVx//59nDx5EqmpqdDV1YWent5nP/dSUlKwY8cOrFy5UrHtbty4gcWLF2PLli3Ztrv3aWpqQl9fH/Pnz0dISAguXbqEvXv3wsLCAsC7s9ayPqcjIyMxceJEAFC60P37233lypVITU2FhYUFUlNTMXnyZBw9ehTR0dE4efIk0tLSIJPJvrheWdgW1asttmvXDpMmTUJSUhKCg4OxYcMGxXRXV1c8ePAAGzduRHp6OtLT03HlypVPtsVPbfdvXS8iIiLKGfz2JSIiov/Mw8MDHh4eivvdunVTDBtmb2+P8ePHAwB++eUXJCcnw8LCAtWrV0fz5s0/u1wjIyMsWrQInTp1gqmpKbZs2QI3N7fvzunl5QU3Nzc0bdoURkZGqF69Ov79918A74Ym8fb2Rq1atWBiYoJLly6hbdu2GDNmDLp06QJjY2OUKVMGhw8fznbZhQsXxuLFi5EvXz4cPHgQwLshdRo3bgxDQ0PUqFEDQ4YMQYMGDb45d/78+bFs2TIMGDAAhQsXhoGBAYoUKaKY/s8//8DZ2RmGhobw8vLCtm3bFMPt/KzYpv7H0NAQZ8+eBQA4OTmha9eusLOzg4mJySeHs5k7dy62bNkCIyMjDBw4UKk4k8Xd3R0uLi6oUKECWrVqhf79+yumVatWDSEhIbCwsIC3tzd27doFc3Pzj5Zx5coVVKtWDYaGhnBzc8PChQthZ2cHAJg0aRJ69+4NExMT7NixI9uc06ZNg56eHmbNmoVNmzZBT08P06ZN4/v/nqz3Pzw8HCdOnMAvv/yiOOPB2toaLi4uaN68+Xed+VC5cmWsWrUKw4YNg6mpKUqUKIF169Z99fN//fVXdOrUCU2bNoWxsTH69++P5ORkNGvWDM2bN4eDgwNsbW2hq6urGOIpNjYWd+/eVTrTAwC2bt0KPT09xT97e3s4Ojpi06ZNGD58OCwsLHDw4EEcPHgQ2traSE1NxdixY2FhYQFra2u8evUKM2fO/GTWffv2QU9PD7169VLafv369UNGRgb++eefbJ8XHR2NBQsWAHg3pJWVlRWcnJxQu3ZtlCxZUjFs1+jRo1G2bFkMHjwYhQoVwvHjxwFAqdj+/nb39fVFkSJF0LBhQxgbG2PNmjVo0aIF5HI5xo4dC3d3d0RERHxxvbKwLeb9tvi+JUuW4O3bt7C2tkbPnj3RtWtX6OjoAHj3OXf06FFs27YNhQoVgrW1NcaMGfPJtvip7f6t60VEREQ5Qya+d7wAIiIiomwUK1YMq1evRuPGjaWOkuvS0tIwYcIEbNq0CWvXrkXTpk2ljpQnqHObyikymQwhISEoUaLER9PWrVuH1atX49y5cxIk+xjf/7xlx44d2LVr1yeLeqrsw7Y4ZswYvHz58ruHDSNp/cxt8UNsi0RERHkXz8AhIiIi+kG0tbXx119/YePGjejfvz9+/fVXpKSkSB2LiEhlmJiYYOTIkVLH+C7p6ekIDQ2FEAKXL1+Gr68v2rZtK3Us+k4/c1sMDg7GzZs32RaJiIjUAAs4RERERD9Yw4YNcePGDYSFhaFatWqKawwQEam7pk2bokaNGjm2/BYtWsDQ0PCjfzNmzPjPyxZCYNKkSTAwMEDnzp3x22+/wd3d/QekJin8zG0xPj4e7dq1Y1skIiJSAxxCjYiIiCiHCCGwZs0ajB07FpMmTcKQIUMgk8mkjkVEREREREREPwEWcIiIiIhy2IMHD9C9e3cUKFAAa9euRYECBaSOREREREREREQqjkOoEREREeUwBwcHXLhwAeXLl0eFChVw+PBhqSMRERERERERkYpjAYeIiIgoF+TLlw8zZszA1q1b4eHhgREjRiA5OVnqWKSCli9fjqtXr0odg9Tc1q1bcezYMaljEAEABg0aBLlcLnUMIiIiolzHAg4RERFRLqpXrx5u3LiByMhIVK1aFbdu3ZI6EqmYc+fO4f79+1LHIDV35coVfj6Ryti4cSPS0tKkjkFERESU61jAISIiIsplpqam2LZtG37//Xc0bNgQCxcuRGZmptSxiIiIiIiIiEiFsIBDREREJAGZTIbevXvj0qVL2Lp1K1q2bImXL19KHYuIiIiIiIiIVAQLOEREREQSsre3x9mzZ1G1alVUrFgRBw8elDoSEREREREREakAFnCIiIiIJJYvXz5MmTIFO3fuxIgRIzBkyBAkJSVJHYuIiIiIiIiIJMQCDhEREZGKqF27Nq5fv47Y2FhUrlwZN27ckDoSEREREREREUmEBRwiIiIiFWJiYoItW7bA29sbTZo0wbx585CZmSl1LCIiIiIiIiLKZSzgEBEREamg7t274/Lly9izZw+aNWuGiIgIqSMRERERERERUS5iAYeIiIhIRRUvXhynT59GnTp1UKlSJezbt0/qSERERERERESUS1jAISIiIlJhWlpa+PPPP7F37178+uuvGDx4MBITE6WORUR5XPny5eHg4CB1DCIiIiIitSYTQgipQxARERHRl8XFxWH48OG4dOkStmzZAhcXF6kjUQ5ITExEvnz5oK2tLXUUUmPJycnQ0NCAjo6O1FGIoKenh5iYGOjp6UkdhYiIiChX8QwcIiIiop+EsbEx1q9fj8mTJ6NFixb466+/IJfLpY5FP5iBgQGLNyQ5PT09Fm+IiIiIiCTGM3CIiIiIfkJhYWHo2bMnNDU1sXHjRhQpUkTqSERERDmCZ+AQERGRuuIZOEREREQ/IVtbW5w6dQpNmjSBi4sLdu/eLXUkIiIiIiIiIvqBeAYOERER0U/u8uXL6N69O+rWrYuFCxfC0NBQ6khEREQ/DM/AISIiInXFM3CIiIiIfnJVq1bF9evXAQAVK1bE5cuXJU5E/0VMTAzCwsIU/7p27YonT57g7du3UkcjNcJ2SEREREQkPZ6BQ0RERJSH7Nq1C0OHDoWXlxfGjBkDTU1NqSPRN+jRowfOnz8PIyMjxWMPHz6Evb09hgwZAk9PTwnTkbrIrh0+evQIdnZ2bIckCZ6BQ0REROqKBRwiIiKiPObZs2fo1asX5HI5Nm3ahKJFi0odib5SuXLlcPPmTaXHKlWqhMDAQIkSkTpiOyRVwwIOERERqSsOoUZERESUx9jY2OD48eNo1aoVKleujO3bt0sdib5SlSpVsGjRIqxfvx4ZGRnIzMxEgwYNpI5FasbJyQlPnjxRGkKtRIkSAIAXL15InI6IiIiISH1oSR2AiIiIiH48TU1NjBkzBo0bN0a3bt3g7++PxYsXw9jYWOpo9BnBwcEwNDTEq1evcPXqVcycORNBQUFSxyI1c//+fbi5uSk9ljVwg5eXF3bs2CFFLFJjK1asQL58+aSOQURERJTrOIQaERERUR6XmJiIkSNH4sSJE9i0aRNq1KghdST6hPLlyyMoKAiZmZmoWLEigoKCULlyZVy9elXqaERERERERJTLeAYOERERUR5nYGCAlStXYu/evWjbti2uX78Oa2tryGQyqaPRBypXroxTp06hQYMG0NDQQHR0NNLT06WORWpm/fr12T7eu3fvXE5CRERERKTeeAYOERERkRp58+YNdHV1eSFoFeXs7Ix79+7B1tYWr169QqFChTBv3ryPhrMiykkjRoxQ3E5NTcWpU6fg7OyMvXv3SpiKiIiIiEj9sIBDRERERKQinj59qritq6uLAgUKSJiG6J2kpCS0adMGR48elToKEREREZFa4RBqREREREQq4v1jq5KTkxEWFgYAsLW1lSoSEZKSkvDw4UOpYxARERERqR0WcIiIiIiIVETr1q0hhIBMJkNiYiLCwsJQokQJBAcHSx2N1IidnZ2imCiEQGxsLKZPny5xKlJXWYXsD7GwTUREROqABRwiIiIiNZaeno6bN2+ifPny0NLirqHUbt68qXT/ypUrWLJkiURpSF1dvXpVcTs1NRWHDh1CQkKChIlInbVu3Vpxm4VtIiIiUje8Bg4RERGRmsrIyMChQ4dw7NgxLF26FJmZmZDJZJDJZFJHo/eULVsWt27dkjoGqblKlSohMDBQ6hhEisL2+vXrpY5CRERElON4mCURERGRmtq3bx88PT1Rp04dAICGhgaAd0MmCSEU9yl3Xb16FefPnwcA1KpVC/7+/oph1Yhyw/sd45mZmbh16xZ0dXUlTETq7tixYzhy5AhkMhmaNm3KYiIRERGpDf4qJyIiIlJTJUuWhLm5OYyNjfHrr79ixowZCA0NhUwmY/Eml3Xv3h2JiYmYMmUKPDw8EBsbi9jYWAwaNAjr1q1j8YZy1bVr1xT/bt26hWLFisHf31/qWKSmFi9ejD///BOOjo7YvXs3du3ahY4dO4KDiRAREZE64BBqRERERGpq0KBBKFy4MCZOnIiIiAjs2rULW7ZsQdGiRbFmzRoYGhoq5uXwajmrYsWKuH79OpycnBAUFAQdHR0A765RVLZsWV7rgSQRHx8PDQ0NGBgYSB2F1Fi5cuVw8eJFGBgYKIbyq1q1Ki5fvix1NCIiIqIcx0MriYiIiNTQs2fPcPHiRfTq1QsAcOPGDZQtWxaXLl1CsWLFcO3aNQDAixcvkJmZCQ0NDRZvclBqaiqSk5NhZWWF9PR0pccLFCggYTJSR0+ePEHt2rXh5OQES0tLNG7cGKGhoVLHIjWWVUTMGuIzLS1N4kREREREuYPXwCEiIiJSQ3v37kX58uVRvHhxTJ06FdevX0dGRgbGjRuHwMBAtG7dGgDQt29fZGRkoEGDBujfvz+sra0Vy5DL5dDU1JRqFfKUPn36oG7duihWrBhcXFzg6uoKADh48CAqV64scTpSN56envjll1/QoUMHVKpUCStWrMDQoUNx+PBhqaORGjIyMkJERAQKFSqExMREuLm5oW3btlLHIiIiIsoVLOAQERERqSFdXV3cunUL8+fPR0hICMaOHYuqVavC19cXK1asQO3atXHr1i2cOXMGK1aswM2bN3H37l0kJCQgLi4OlSpVYvHmBxo9ejSaNm2Ka9euoUaNGorHPTw8JExF6urFixfo0KEDgHdnPNjb2+P169cSpyJ1tWnTJuTLlw8A8Mcff6BkyZKoXbu2xKmIiIiIcgcLOERERERqaNCgQShTpgyuXLmCkJAQrF+/HgAwZ84c9OzZEzKZDBs3bkSXLl3Qs2dPAMCBAwfQt29fpKWlwczMDH/88Qfq1q2rtNys4dbo21WoUAEVKlQAwGuPkLQyMjKU7l++fBn6+voSpSF1V7x4cVy9ehVbtmwB8O4ABCIiIiJ1wV/XRERERGpGCAEAqFmzJry8vLBv3z4UKlQIS5YsQWRkJPr06YOoqCgEBARgxIgRAIB9+/bh2LFj6NevH/799180atQIo0ePxrp165SWnVW8yXoN+ja89gipgi5duuDmzZsAgPT0dPzxxx9YtWqVxKlI3XTv3h2JiYmYMmUKPDw8EBsbi9jYWAwaNAhTp06VOh4RERFRrpAJ/romIiIiUktZF4N+/4yZoKAglC9fHvPmzcPevXtx7tw5yOVy+Pr6IioqCp6enjAzM8O0adNw8eJFrF27FmlpaQgICMCxY8cwcOBApaFtbt++DTs7Ox69/5VatGiB/v37K649snPnTgwbNozXHqEcN2PGDIwbN07qGEQKFStWxPXr1+Hk5ISgoCDo6OgAeFdULFu2LIKDgyVOSERERJTzeAYOERERkZqSyWTQ0NCAEAKZmZkAgPLlywMAmjRpgnnz5gEANDU1ERkZidevX8PMzAzR0dFITU1Fo0aNYGFhgXbt2sHAwABdunTBuHHjsGnTJgDvhl3au3cvXr9+zTNyvhKvPUJS2blzp9QRiJSkpqYiOTkZVlZWSE9PV3q8QIECEiYjIiIiyj0s4BARERGpuaxCzvvKlSuHatWqKe7b29vj1q1bCAkJwYIFC3D58mU0atQIBw4cQGBgIObPn4/IyEj89ddfuHTpEkJDQzFixAj4+/sjNjYWMpkst1frp8Rrj5BU+DdKqqZPnz6oW7cuChQoABcXF/z222/47bffUKlSJRQpUkTqeERERES5gkOoEREREdFHsnYRZTIZ3rx5Ax0dHRw/fhwbN25EcnIyKlSogGnTpqFVq1bo2rUrWrZsibFjx8Lf3x+1a9fGli1b4Obmhnz58uHx48fYuXMnSpYsqVh+ZmYmNDQ0EB8fDyMjI6lWU+VMmzYNbm5uKFeuHMqUKQMrKyssX74cDg4OUkejPC5ruCoiVXLjxg1cu3YNb9++/Wjar7/+KkEiIiIiotylJXUAIiIiIlI97x+Nf+DAAaxZswYDBw5EnTp1EBAQgFatWgEAatSogeTkZJiZmWHlypVISEiAtrY2tmzZglKlSmHy5MnQ19f/6MySrDN+/vjjD1SoUAEDBgzIvZVTYePHj1fcvn37NgDg4sWLUsUhNcIzcEgVVahQARUqVJA6BhEREZFkWMAhIiIios/q3bs3qlatirlz58LU1BR//vmnokOtUaNGGD58OM6ePYsePXqgUqVKkMlkOHHiBBo0aKA4k0dL63+7nUIIyGQyBAcHIz4+HoULFwYADBkyBCNHjlQ6U0fdXLhwAdu2bUN8fLzisQMHDsDNzQ1t2rSBu7u7hOkoL+vYsaPi9tOnT1G0aFEJ0xD9T79+/bK9jtratWsxceJETJ48WYJURERERLmDBRwiIiIi+qJSpUrB19dXUXzJUqNGDZw/fx5Lly7Frl27YGtri4yMDOjq6qJBgwYwMDD45DIPHjyIAgUKoEaNGgCAOXPmKJadmZkJmUymdmcFDBw4EKNGjYKxsbHisTNnzsDV1RWOjo4SJqO87o8//lDctrOzQ7t27bB27VrF3zCHWCOpuLq6fnJavXr1cjEJERERUe7jNXCIiIiI6LvJ5XJoamoqPRYVFYX27dujfPnyWLRokVIRJqsAFB0djZEjR8LNzQ0dOnRAs2bN4OXlhZYtW35x+XmZi4sLrl27pvRYpUqVEBgYKFEiUkeVKlVCv379sGbNGmzfvh0lS5ZkOyRJpaam4v79+wAAR0dH6OjoSJyIiIiIKHdoSB2AiIiIiH5eWcWVzMxMxWOWlpZYuXIl8ufPj+fPnyvNn3XskL+/P/T19VGnTh1cu3YNGhoacHBwQFRUFEaPHo2//voLcXFxiuVfvXoVT58+zaW1yl3Dhg1T3N61a9dH03fv3p2bcYgghMCwYcOwZMkSuLm54dChQ9kOYUWUG06dOgVHR0cMHz4cI0aMQMmSJXHixAmpYxERERHlChZwiIiIiOg/09D4326lEAJOTk6YNm0abGxsIJfLleYTQuDChQuoWLEirKyssHbtWtSoUQPFixfHvHnzkJ6ejujoaLi6uuLEiROIjIzErFmzkJKSIsWq5bjz588rbhcvXvyj6dk9RpSTss6aq1mzJk6fPo05c+Yozn4gym2//fYbTp48idOnTyMgIACnTp3CqFGjpI5FRERElCtYwCEiIiKiH0omk0EIgZCQEAD/O0snIyMDAPDPP//gxYsXqFOnDl6+fIm7d++idevW0NTUxPXr16GlpYXZs2dj8+bNsLGxwZQpU3Ds2DFcvHhRsnXKSep2nR9SfatXr1bcLlCgAE6ePIkjR45ImIjUmVwuh52dneK+vb290oEBRERERHkZCzhERERE9MMlJydj8eLFaNy4MbZu3QoA0NLSAvDu+hqDBg1C6dKlsXTpUpQsWRJFixYFAGzZsgVCCKxYsQI2NjZwcHDAy5cv0bNnT/j4+GDPnj2SrVNO4dBUpGqKFy+OX375BS4uLqhUqRJGjhyJMmXKSB2L1FSVKlXQt29fnDx5EidPnkTv3r1RpUoVqWMRERER5QqZ4C9GIiIiIsohUVFRWLlyJbZv344hQ4agf//+yJcvn2L6tm3bUKhQIdjb2+PKlSto06YNHjx4gL59+2LZsmWIj4/H9OnTsXPnThgaGkIIkefOWOHF4UnVtG3bFi4uLujRowcAYOPGjQgMDMTevXslTkbqKD09HStWrEBAQAAAoG7duvD09FT6LiEiIiLKq1jAISIiIqIcl5aWhps3b8Le3h6mpqYfTQ8PD0ffvn2RnJyM1q1bY+fOnTh06BBmzZoFc3NzeHl5wcjIKE8WcNavX4/evXtLHYNIoXz58ggKCvriY0RERERElLO0pA5ARERERHmftrY2Kleu/MnphQsXxtGjR3Ht2jUEBARg06ZNMDMzw/PnzzFo0CAYGRkByJvXi3m/eNOvX7/PDqm2du3a3IhEas7AwAABAQGoX78+AODUqVMwMDCQNhSpLTs7u2w/Fx8/fixBGiIiIqLcxQIOEREREUlOLpdDU1MTLi4ucHFxAQCkpKSgSJEi6Ny5MzZt2oRy5cpJnDLnubq6Sh2BCKtWrUKvXr3w+vVrAICZmRk2btwocSpSV1evXlXcTk1Nxd69e/Hq1SsJExERERHlHg6hRkREREQqIzMzExoaGkqPrVu3DhUrVkT58uUlSkWknhISEgAAhoaGEichUubi4oJr165JHYOIiIgox/EMHCIiIiJSGe8Xb7Kud9OnTx/pAuWyhg0bZjtU0KlTpzBw4ECsWrVKglSkbiZPnpzt4xMnTszlJERQKtTI5XJcu3YNGRkZEiYiIiIiyj0s4BARERGRSsruejfZnaGTl8ydO/eT03777bdcTELqLOuaU8C7Iav8/Pzg6OgoYSJSZ6NGjVLc1tLSgq2tLXbu3ClhIiIiIqLcwyHUiIiIiOinIJfLcebMGcTFxcHd3V3qODni5s2bKFy4MMzNzREbG4vQ0FBUqFAhTxetSPVlZGSgSZMmOHXqlNRRiIiIiIjUCn8JEhEREdFPQVNTE4aGhhg5ciQ8PDyQmJgodaQfrm/fvtDW1kZSUhKqVKmCsWPHon///lLHIjX39u1bPHv2TOoYRERERERqhwUcIiIiIvppVKlSBdevX0dSUhJcXFwQGBgodaQfKjMzE0ZGRjhy5AhatmyJo0eP8kLdlOvKlSuHsmXLoly5cnB2doajoyO8vLykjkVqLD09PdvrgxERERHldbwGDhERERH9VPLnz48NGzZg69ataN68OUaNGoXffvstTwwzJpPJcOfOHWzYsAEeHh6Kx4hy06FDhxS3tbS0YGVlBU1NTQkTkbqzsrJCeHg49PT0pI5CRERElKt+/l+5RERERKSWunbtisuXL+PAgQNo0qQJnj9/LnWk/2zWrFno2bMnzM3N0bRpU8TFxaFfv35SxyI1U7RoUSQmJuLAgQPYu3cvQkJCpI5Eai45OVnqCERERESSYAGHiIiIiH5axYoVQ0BAABo0aAAXFxfs3r1b6kj/SdOmTREYGIjVq1dDJpPB2NgYRYoUkToWqZmdO3eiTZs2ePHiBWbOnInRo0dj8+bNUsciIiIiIlI7MsGBZImIiIgoD/j333/RvXt31K9fHwsWLIChoaHUkb7Znj17sG7dOsTHxwN4N3zalStXULlyZfTp0we9e/eWOCGpg4oVK+Lo0aOwtLREpUqVcOXKFdSsWRP//vuv1NFITenp6SEmJoZDqBEREZHa4TVwiIiIiChPqFatGq5fv44RI0agUqVK2Lx5M6pUqSJ1rG8ybtw4+Pj4wNjYGMC7Ak63bt0wd+5cFC5cWOJ0pC4yMzNhaWkJABBCQFNTE+np6RKnIiIiIiJSPyzgEBEREVGeYWRkhLVr12LHjh1o1aoVRo4cidGjR/80F2DX19dH/fr1lR7T09ODi4uLNIFILWlra+PNmzcwNTVFSkoKhg4dimrVqkkdi4iIiIhI7XAINSIiIiLKk54+fYpevXpBCIGNGzeiaNGiUkf6otTUVOjo6HzxMaKcdPnyZVhbW6No0aKYMmUK7Ozs0L17d8hkMqmjkZriEGpERESkrljAISIiIqI8Sy6XY86cOfj777+xZMkSdOrUSepIRET0jVjAISIiInXFAg4RERER5XlXr15Ft27dULNmTSxevBhGRkZSR/qk5ORkaGlpIV++fFJHISJSCSzgEBERkbrSkDoAEREREVFOq1y5MgIDA5EvXz5UrFgRly5dkjrSJ61ZswaXL1+WOgapuVevXiEmJkbqGEREREREao0FHCIiIiJSC4aGhli1ahX++usvuLu7Y+rUqZDL5VLH+siFCxfw5MkTqWOQmps1axbWrVsndQwiIiIiIrXGAg4RERERqZX27dvj2rVrCAgIQP369VksISIiIiIiIpXEAg4RERERqZ0iRYrg2LFjcHNzQ5UqVbBlyxapIxEREREREREpYQGHiIiIiNSShoYGRo0ahSNHjmDKlCno2bMn3r59K3UsIiIiIiIiIgAs4BARERGRmqtUqRICAwNhYGCAChUq4Pz585LkmDVrFiwsLLBr1y54eHjAysoKV65ckSQLqa+1a9fCwsICy5cvx4QJE2BpaYl//vlH6likpmrVqgULCwukpKSgSJEicHZ2ljoSERERUa5iAYeIiIiI1J6+vj58fHywYMECtG/fHhMnTkRGRkauZqhSpQoSExORlpaGhIQEJCYmwtHRMVczELm4uCA+Ph4pKSlISkpCXFwcypUrJ3UsUlOOjo6KMyNjY2NhZ2cncSIiIiKi3MUCDhERERHR/3N3d0dgYCAuXryIOnXqIDQ0NNdeu2HDhoqCjba2NkaPHg1jY+Nce30iAChXrhwaNGgAANDU1ESfPn1QqFAhiVORupo8eTK0tLQAvPtcnDVrlsSJiIiIiHIXCzhERERERO8pVKgQ/vnnH3Tq1AnVqlXDhg0bIITI8deVyWSYN28eNDQ0IJPJ8Msvv+T4axJlZ/bs2dDS0oJMJsPEiROljkNqzMbGBl27dgXwrsjNIdSIiIhI3chEbvwaJSIiIiL6CQUFBaFbt24oW7YsfHx8YGJikqOvJ4RAgQIF0LRpU2zevDlHX4voc0qWLIlChQrh9OnTUkchNffs2TPY2toiMDAQFSpUkDoOERERUa5iAYeIiIiI6DOSk5MxatQoHDx4EBs3bkTdunVz9PUSEhKgp6cHTU3NHH0dos9JSkpCvnz5kC9fPqmjEOHt27fInz+/1DGIiIiIch0LOEREREREX+HQoUMYOHAg+vfvj4kTJ7Jjm4iIiIiIiHIUCzhERERERF8pMjISffv2xevXr7FlyxaUKFFC6khERERERESUR2lIHYCIiIiI6GdhZWUFPz8/9OjRAzVq1MDatWshhIAQAps3b0ZKSorUEYmIiIiIiCiP4Bk4RERERETf4datW+jWrRucnJxQt25djBgxArNnz8aoUaOkjkZERERERER5AAs4RERERETfKSUlBYMHD8bGjRshhICRkRGeP38OY2NjqaMRERERERHRT45DqBERERERfSctLS0EBgYq7icnJ2PatGkSJiIiIiIiIqK8ggUcIiL6IWQyGQwMDODt7f1V8/v6+sLQ0BAymQwPHz7M4XSkLtgOKbe9efMGMpkM2tra0NXVRWZmJubOnYtnz5599nlsq6QKvrUdHj9+HIaGhtDQ0MDx48dzOB3ldd/a/r7E3t4e2tra6NGjxw9ZHqmvH902GzZsCF1dXdSuXfuHLI+IiNQLCzhERPTDBAUFYfr06Yr7crkc48ePR6FChWBkZISKFSsiNjYWANC/f38kJCRIlJTysvfb4dmzZ2FoaKj0TyaTYffu3QDYDum/s7S0xM2bN5GcnIxHjx7h6NGjGD58+FcNofbhZ+agQYPg6OgIDQ0NrFu3TmletlXKKR+2w5MnT6JSpUowNjaGnZ0dVq5cqZjWuHFjJCQkoGjRolJEpTzoWz4HAWD+/PmwtraGsbEx+vXrh9TUVMW0R48eYdy4cbkRm9TAt7TNbdu2wdHREfnz50eBAgXQu3dvxMXFKaafPHkSPj4+uRWdiIjyGBZwiIgox0ycOBEXLlzAxYsXERcXh40bN0JXV1fqWKRG6tSpg4SEBMW/Q4cOwdDQEM2bN5c6GuUxMpkMhQoVQqNGjbBw4ULkz5//m5dRvnx5LFu2DJUqVcqBhERflp6ejrZt22Lw4MF4+/Yttm/fjl9//RVBQUFSRyM18bnPwSNHjmDWrFk4ceIEwsLCEBoaiokTJ0qQktTR59pmrVq1cP78ebx9+xahoaHIyMjA+PHjJUhJRER5kZbUAYiIKG968+YNFixYgKCgINja2gIAypQpI3EqUnfr169Hhw4dYGBgIHUUoo8MHToUAFjoJsnExMQgLi4OPXv2hEwmQ5UqVVCqVCncvXsX5cuXlzoeqYHPfQ6uX78e/fv3h7OzMwBgwoQJ6N69O2bNmpWrGUk9fa5t2tjYKN3X1NTkcKdERPTD8AwcIiLKEbdu3YKWlhZ27doFa2trODg4YOnSpVLHIjWWmJiIXbt2oXfv3lJHISJSSVZWVujatSvWrl0LuVyOixcvIiwsjNdtIJVw584dpUJi+fLlERkZiejoaAlTEb1z7tw55M+fH0ZGRti9ezd++eUXqSMREVEewTNwiIgoRzx//hxv377FgwcP8PjxY4SEhKBRo0ZwcHBAkyZNpI5HamjPnj2wsLBAvXr1pI5CRKSyunbtigEDBsDLywsAsHz58o+OLieSQkJCgtLwlFm34+PjYW5uLlUsIgBA7dq18fbtW4SHh2PVqlUoVqyY1JGIiCiP4Bk4RESUI/T09AAAf/75J/T09FCuXDl06dIF/v7+EicjdbV+/Xr06tULMplM6ihERCopODgYXbp0wYYNG5CWloY7d+5g9uzZ8PPzkzoaEQwNDZUuDJ9128jISKpIRB8pXLgwmjdvji5dukgdhYiI8ggWcIiIKEeUK1cOAJQ6y9lxTlJ59uwZAgIC0KtXL6mjEBGprNu3b8PBwQHNmjWDhoYGHB0d0apVKxw+fFjqaERwdnZGUFCQ4n5QUBCsrKx49g2pnIyMDDx69EjqGERElEewgENERDnC3t4ederUwfTp05Gamop79+5h27ZtcHV1lToaqaGNGzeiZs2asLe3lzoK0SelpaUhJSUFQgikp6cjJSUFmZmZUsciNVKxYkWEhITg5MmTEELg0aNHOHTokOKgDKKc9rnPwV69esHX1xd3795FbGwspk2bhj59+kgbmNTG59rm5s2b8fTpUwBAWFgYvL290ahRIynjEhFRHsICDhER5ZitW7ciLCwM5ubmaNWqFaZOncofMySJDRs2oHfv3lLHIPqspk2bQk9PDxcuXMCgQYOgp6eHM2fOSB2L1Ii9vT3WrFmDESNGwNjYGPXq1UP79u0xYMAAqaORmvjc52Dz5s0xevRoNGjQAEWLFoWtrS0mT54scWJSF59rm3fv3kXNmjVhYGCAWrVqwdHREatWrZI4MRER5RUyIYSQOgQREf38dHV1oaOjgxEjRmDq1KlfnH/t2rUYOXIkUlJScPfuXdjZ2eVCSsrr2A7pZ8G2SqrgW9vhiRMn0L59e6SmpsLf3x8NGjTIhZSUV31r+/sSR0dHhIeHo1OnTlizZs0PSEjq6ke3zSZNmuDSpUuoWrUqTpw48QMSEhGROmEBh4iIiIiIiIiIiIiISMVwCDUiIiIiIiIiIiIiIiIVwwIOERERERERERERERGRimEBh4iI8hRnZ2cEBAR8cvqMGTN4MWZSSS1atMD69euljkFERHlUnz59MH78eKljKHxpn42IiIiIWMAhIqIc9uTJE8hkMmRkZOTK6925cwf169f/5PRx48Zh9erVuZKFckZOtKmAgAAUKVLkhy3vexw+fBi9e/f+4nwymQwPHz787DxLlixB5cqVoaOjgz59+vyghOpr0qRJ6NGjh9QxvluxYsVw/PhxACxiE5Hq+NI+W056/3PRz88PtWvXhomJCaytrTFgwADEx8cr5k1NTUW/fv1gbGwMa2tr/P3330rLOnHiBJycnKCvr48GDRogLCzsq59L0sut3yqf2ze7dOkSmjRpAjMzM1haWqJjx4548eKFYvr8+fNhZ2cHY2NjFCpUCCNHjvxk3rS0NHTo0AHFihWDTCb7qEg6Z84clClTBkZGRihevDjmzJmjNP3Jkydo0KAB9PX14eTkpPg7AQAPDw8YGhoq/uno6MDIyOi/bRgiIvoiFnCIiNSMEAKZmZlSx/hqP/LHVG4VkdSNurSpn6n9FCpUCOPHj0e/fv2kjkL/TxWKhMDXF7Hr16/PYrea+poiMZB7bVrVzhqhvOft27cYP348IiIicO/ePYSHh2PUqFGK6ZMmTUJISAjCwsJw6tQpzJ49G//88w8A4PXr12jXrh2mTp2KmJgYVK5cGZ07d/6q51L28up+5ef2zd68eYNBgwbhyZMnCAsLg5GREfr27auY7ubmhsDAQMTFxeH27dsICgrCokWLPvlatWvXxqZNm2Btbf3RNCEENmzYgDdv3uCff/7BkiVLsG3bNsX0rl27omLFioiOjsb06dPRoUMHREVFAQB8fHyQkJCg+Ne1a1d07Njxq9afiIi+Hws4REQ/iWLFimHmzJkoXbo0TE1N0bdvX6SkpAB4t9Pv6uoKS0tLmJqawtXVFc+fP1c8t379+vD29katWrWgr6+P0NBQrF27FqVKlYKRkRHs7OywYsUKxfxZnTKzZ89GgQIFULBgQezbtw/+/v5wcHCAmZkZZsyYoZg/MzMTs2bNgr29PczNzdGpUyfExMQAAOrWrQsAMDExgaGhIS5evAgAWLNmDUqVKgVTU1M0a9ZM6WhFmUyGpUuXomTJkihZsuRH2+L169dwdXWFiYkJzMzMUKdOHcUPvfePqJw0aRI6dOiAHj16wNjYGOvWrVM6kj67zqf3n3/58mVUrlwZxsbGsLKywq+//vo9b53KYpt6JzExES1atEBERITiiMKIiIhs28/ly5dRo0YNmJiYoGDBghg2bBjS0tKUXmfRokWws7ODhYUFRo0apWib69atQ61atTBs2DDkz58fTk5OOHHihNI2zeowf/jwIerVq4f8+fPDwsJC0RmUte7ly5eHoaEhtm/fnu17265dO7Rp0wbm5uZfbgikMn6mIiHlPWx/ec/169dRqVIlGBkZoXPnzl/1Hb9z5064uLgoLefvv/+Gu7s7AMDf3x+lS5eGkZERChcujLlz5342w7fss3Xq1Am9evWCkZERnJ2dcfXqVcVynj17hnbt2sHS0hLm5uYYNmyYYtrnvv+/Rrdu3dC8eXPo6+vD1NQUAwcOxPnz5xXT169fjwkTJsDU1BSlSpXCwIEDsW7dOgDAnj174OzsjI4dO0JXVxeTJk1CUFAQgoODv/jcvIb7lZ/3uX2zFi1aoGPHjjA2Noa+vj6GDRum1Abt7e1hYmIC4F0BRkND45OFdm1tbfzyyy+oXbs2NDU1P5o+evRoVKpUCVpaWnB0dIS7u7vitR48eIDAwEBMnjwZenp6aN++PcqWLYvdu3d/tJzExETs3r37q84eJyKi/0gQEZHK8vT0FJ6enkIIIWxtbYWzs7N4+vSpiI6OFjVr1hTe3t5CCCFev34tdu3aJRITE0VcXJzo0KGDcHd3VyynXr16wsbGRty+fVukp6eLtLQ0cejQIfHw4UORmZkpAgIChJ6enrh27ZoQQohTp04JTU1NMXnyZJGWliZWrlwpLCwsRNeuXUVcXJy4ffu20NXVFaGhoUIIIRYsWCCqVasmnj17JlJSUsSgQYNEly5dhBBCPH78WAAQ6enpijz79u0T9vb24u7duyI9PV1MnTpV1KhRQzEdgGjcuLGIjo4WSUlJQggh8ufPL86ePSuEEGLs2LFi8ODBIi0tTaSlpYkzZ86IzMxMxXY6duyYEEKIiRMnCi0tLbF3714hl8tFUlKSmDhxoujevbtiPQsXLqy0zd9/fvXq1cWGDRuEEELEx8eLixcv/qf3UxWwTWXfprJrC9m1n6tXr4qLFy+K9PR08fjxY+Hk5CTmz5+v9Dr169cX0dHRIiwsTJQsWVKsWrVKCCHE2rVrhaampvj7779FWlqa2LZtmzA2NhbR0dGKbZo1b5cuXcS0adOEXC4XycnJipxZrxESEvJV77e3t7fo3bv3V82r7sLDw0W7du2EhYWFKFasmFi4cKFi2vufG0IIcfHiRVGjRg2RP39+Ua5cOXHq1CnFtOjoaNGnTx9RsGBBYWJiItzd3UVCQoLQ1dUVMplMGBgYCAMDAxEeHi4mTpwo2rdvL7p37y6MjIzEqlWrRHh4uGjdurUwNTUV9vb2YuXKlUo5OnbsKHr27CkMDQ1F6dKlxZUrV764bh9+LmatS3JysujevbswMzMT+fPnF5UrVxYvX74U48aNExoaGkJHR0cYGBiIoUOH/tfNS+95+vSpaNu2rbCwsBBmZmZi6NChQi6Xi6lTp4qiRYsKS0tL0bNnTxEbGyuE+N9n3rp164SNjY0wNzcX06ZNE0K8a7e6urqKzxEhhAgMDBTm5uYiLS1NCCGEr6+vcHJyEiYmJqJp06biyZMninkBiCVLlogSJUqIYsWKiTp16ggAQl9fXxgYGIht27Zluw6fatMpKSnCy8tLFCxYUBQsWFB4eXmJlJSUz26PtWvXilq1aik9lvU5t2LFCqGlpSXy5csnDAwMhKur6ye3ISlLTU0VRYsWVXzn7Ny5U2hpaQlvb+/PfsenpKQIU1NTcffuXcWyKlSoIHbt2iWEEMLa2lqcOXNGCCFETEyM4nv+U75ln01HR0f4+fmJjIwMMXbsWFGtWjUhhBAZGRmiXLly4pdffhEJCQlK34tf+v7/lPdf+0NeXl6ic+fOinUEIF6+fKmYvnPnTlGmTBkhhBAjRowQHh4eSs93dnYWu3bt+uJz8wLuV2a/X/k5X7NvNn/+fEX7z7J582ZhZGQkAAgLCwtx48aNL75W4cKFlfZRPpSZmSkqVKggli9fLoQQYs+ePcLJyUlpnqFDh4phw4Z99Nz169eL4sWLK/6eiYgo57CAQ0T0k7C1tVXsXAshhJ+fn7Czs8t23uvXrwsTExPF/Xr16okJEyZ8dvnu7u5iwYIFQoh3P4p0dXVFRkaGEEKIuLg4AUBcunRJMX+lSpXE3r17hRBCODk5iePHjyumRURECC0tLUUn94c/ipo3by5Wr16tuC+Xy4Wenp6iUwmAOHHixCezTpgwQbi5uWXbif1hZ0CdOnWUpn9LAadOnTrizz//FFFRUZ/M8jNjm/qfTxVwPmw/H5o/f75o06aN4j4AcfjwYcX9pUuXioYNGwoh3nVSFixYUOmHbpUqVRRFwvcLOD179hQDBw4Uz549++g1WcD5cbI6nuRyuahUqZKYPHmySE1NFY8ePRLFixcX//zzjxBC+XPj+fPnwszMTPj5+Qm5XC6OHj0qzMzMxKtXr4QQQrRs2VJ06tRJxMTEiLS0NBEQECCE+PoiYZ06dYSnp6dITk4W169fFxYWFoq2+7kOzs/5VAHHx8dHuLq6isTERJGRkSGuXr0q3r59K4RQbo9ZWrVqJWbOnPld25re+VRHtK+vr7C3txePHj0S8fHxom3btqJHjx5CiP91Lg4YMEAkJSWJGzduCG1tbUUHe4MGDZQKfb///rsYPHiwEOL7OiG/9jMmuzY9YcIEUa1aNREZGSlevXolatSoIcaPH//Z5XyugCOEEL1791Z0An9uG5Ky06dPf/SdU6NGDaVtmeXD73gPDw8xbtw4IYQQt2/fFiYmJopCnI2NjfDx8VF8VnzJt+yzNWrUSDHtzp07QldXVwghxIULF4SFhYXS936WL33/f8qnCjhHjx4VJiYm4v79+0KId8VCACI5OVlpHltbWyGEEP369RNjxoxRWkbNmjXF2rVrv/jcvOZn2a988eKFGDNmjAAgbty4kSP7lZ/zpX2zoKAgYWpqqiiUfujBgwdi/Pjx4sWLF198rS8VcP78809Rrlw5xd/3hg0bPtqvGDduXLZ5GzZsKCZOnPjFDERE9N9xCDUiop+IjY2N4ratrS0iIiIAAElJSRg8eDBsbW1hbGyMunXrIjY2FnK5PNvnAu8umF69enWYmZnBxMQE/v7+eP36tWK6ubm54rR7PT09AICVlZViup6eHhISEgAAYWFhaNu2LUxMTGBiYoJSpUpBU1MTkZGR2a5HWFgYvLy8FPObmZlBCIHw8PBP5n3fqFGjUKJECTRt2hR2dnaYNWvWV22zb+Xr64sHDx7AyckJVapUwaFDh757WaqKberrtw/wbmgJV1dXWFtbw9jYGOPGjVNaxw+f8/42BYDChQtDJpN9cnqW2bNnQwiBqlWrwtnZGWvWrPlkxhYtWiiGftu8efM3r6M6W7ZsGZYtW4YrV64gKioKf/75J7S1tWFnZ4eBAwcqjQmfZdOmTWjZsiVatmwJDQ0NNGnSBJUrV4a/vz9evHiBw4cPw8fHB6ampsiXLx/q1av32Qw1atRAmzZtoKGhgdevX+P8+fP466+/oKuriwoVKmDAgAHYsGGDYv7atWujZcuW0NTURM+ePREUFPTd658vXz5ER0fj4cOH0NTUhIuLC4yNjT85/6FDhzB27Njvfj16NzRnREQE5syZAwMDA+jq6qJ27drYvHkzfv31V9jZ2cHQ0BAzZ87Etm3blIY1mzhxIvT09FC+fHmUL19e8d5369YNW7duBfBuaJ1t27ahW7duAN5dr+CPP/5AqVKloKWlhXHjxuHGjRtKQwH98ccfMDMzU3wu/xebN2/Gn3/+iQIFCsDS0hITJ07Exo0b//Ny3/epbUjKIiIisv3OAb78Hd+7d29s2bIFQghs3LgRnTp1go6ODgBg9+7d8Pf3h62tLerVq6cYbupTvmWf7f3rdejr6yMlJQUZGRl49uwZbG1toaWl9dFzvub7/2tdunQJ3bp1w65du+Dg4AAAMDQ0BADExcUp5ouLi1NcuN3Q0FBp2vvTv/TcvEiV9yvd3Nygra2NggULYv78+dDW1oaFhUW26/Ff9yu/d9/s4cOHaNGiBRYuXIg6depkO0/JkiXh7OyMIUOGfPVys7NkyRJs2LABfn5+ir/vz7Xn9z19+hQBAQHo1avXf8pARERfhwUcIqKfyLNnzxS3nz59ikKFCgEA5s2bh/v37+Pff/9FXFwczpw5A+BdR06W93/Ap6amon379vj9998RGRmJ2NhYtGzZUmn+b2FjY4PDhw8jNjZW8S8lJeWjjoP351+xYoXS/MnJyahZs2a2eT9kZGSEefPmITQ0FAcOHMDff/+tdC2R931uOQYGBkhKSlLcl8vliot0Au9+IG3duhWvXr3CmDFj0KFDByQmJn52W/xs2KY+P+3Dxz09PeHk5ISQkBDExcVhxowZH63jp7YpAISHhyvN/+H0LNbW1li1ahUiIiKwYsUKDBky5JNjnR8+fFhxMdnu3bt/ch3p08LCwhAREaHoqDExMcGMGTOyLRiGhYVh586dSvOeO3cOL168wLNnz2BmZgZTU9Ovfu33O4AiIiJgZmam1FFia2ur1GH0qQ7O79GzZ080a9YMXbp0QaFChTB69Gikp6d/17Lo63yqIzoiIkLRuQ68e98zMjKU2uCH731Wx2T79u1x8eJFvHjxAmfOnIGGhoai4y+nitufkt16ZFek/i8+15lP/1OwYMFsv3OAL3/HV69eHdra2jh79iy2bNmCnj17KpZRpUoV7N+/H69evUKbNm3QqVOnz+b4ln22T7GxscHTp0+z/az7mu//r3H9+nW4ublhzZo1aNSokeJxU1NTFCxYUKlYHhQUBGdnZwCAs7Oz0rTExEQ8evQIzs7OX3xuXqRq+5WJiYlYtGgR5HI5ChQogHnz5uHNmzdITU1Fampqju1Xfs++WVhYGBo3bowJEyYo/c1lJyMjA48ePfqq5WZnzZo1mDVrFk6cOKF0PVBnZ2eEhoYiPj5e8Vh2bXbjxo2oVasW7OzsvjsDERF9PRZwiIh+IkuXLsXz588RExOD6dOnKy5sHh8fDz09PZiYmCAmJgaTJ0/+7HLS0tKQmpoKS0tLaGlp4fDhwzh69Oh35/Lw8IC3t7fiiN6oqCjs378fAGBpaQkNDQ2EhoYqzT9z5kzcuXMHAPD27Vvs3Lnzq1/v0KFDePjwIYQQyJ8/PzQ1NaGh8e1faQ4ODkhJSYGfnx/S09Mxbdo0pKamKqZv2rQJUVFR0NDQUFw49HteR5WxTb1jZWWF6OhovH379rPzxcfHw9jYGIaGhggODsby5cs/mmfOnDl48+YNnj17hoULFyq2KQC8evUKixYtQnp6Onbu3Il79+6hZcuWHy1j586diov7mpqaQiaTKdqelZWV0rpnJyMjAykpKZDL5ZDL5f+pk18d2NjYoHjx4kodNfHx8fD398923p49eyrNm5iYiLFjx8LGxgYxMTGIjY396HlfUyQsVKgQYmJilDpOnj59isKFC//3lcxGvnz5MHHiRNy9excXLlzAoUOHFGf7fK5jir7fpzqiCxUqpHRWzNOnT6GlpaV0NPmnmJqaomnTpti+fTu2bNmCLl26KN6//9oJ+TnZPS+79ciuSP2+Dw+mePny5Wdf53Od+fQ/NWrUgJaWluI7Z8+ePbh8+TKAr/uO79WrF4YNG4Z8+fIpznBKS0vD5s2b8fbtW+TLlw/GxsZf3C/6EftsVatWRcGCBTF27FgkJiYiJSVFcdH1//r9DwC3b99G8+bNsXjxYrRu3fqj6b169cK0adPw5s0bBAcHY9WqVejTpw8AoG3btrh9+zZ2796NlJQUTJkyBeXKlYOTk9MXn5sXqcp+5dWrVxESEoJff/0VFy9exMCBA2Fraws3NzeYmJjk+H5ldj63bxYeHo6GDRti2LBh8PDw+Oi5q1evxqtXrwAAd+/excyZM5UKjR9KTU1FSkoKgHfbMiUlRVH82rx5M8aNG4djx459VIBxcHBAhQoVMHnyZKSkpGDv3r24efMm2rdvrzTfhg0b8nQ7JiJSNXmrF4qIKI/x8PBQ2onv1q2bYggKe3t7jB8/HgDwyy+/IDk5GRYWFqhevTqaN2/+2eUaGRlh0aJF6NSpE0xNTbFlyxa4ubl9d04vLy+4ubmhadOmMDIyQvXq1fHvv/8CeHeUsLe3N2rVqgUTExNcunQJbdu2xZgxY9ClSxcYGxujTJkyOHz48Gdfw9DQEGfPngUAhISEoHHjxjA0NESNGjUwZMgQNGjQ4Jtz58+fH8uWLcOAAQNQuHBhGBgYKB2F9s8//8DZ2RmGhobw8vLCtm3bfsgQM1Jim/qf99uUk5MTunbtCjs7O5iYmHzyiPG5c+diy5YtMDIywsCBA5WKM1nc3d3h4uKCChUqoFWrVujfv79iWrVq1RASEgILCwt4e3tj165dMDc3/2gZV65cQbVq1WBoaAg3NzcsXLhQ8SN70qRJ6N27N0xMTLBjx45sc06bNg16enqYNWsWNm3aBD09PUybNu2z20OdVa1aFUZGRvjrr7+QnJwMuVyO27dv48qVKx/N26NHDxw8eBBHjhxRdMAEBATg+fPnKFiwIFq0aIEhQ4bgzZs3SE9PVxxl/DVFQhsbG9SsWRN//PEHUlJScPPmTfj6+qJHjx45st6nTp3CrVu3IJfLYWxsjHz58n1ToZC+3ac6ort27Yr58+fj8ePHSEhIwLhx49C5c+evPsukW7du2LBhA3bt2qUYPg34vk7Ir33vs2vTXbt2xbRp0xAVFYXXr19jypQpX2y/5cuXx507d3Djxg2kpKRg0qRJn83zuc58+h9tbW3s2bMH69atg5mZGbZv34527doB+Lrv+J49e+L27dsfvX8bN25EsWLFYGxsDB8fny8OD/Uj9tk0NTVx8OBBPHz4EEWLFkWRIkWwfft2APiu7/8sWcXBefPmISoqCv3791cMe/X+GQeTJ0+Gvb29Yti4UaNGKbaZpaUldu/eDW9vb5iamuLff/9VGn7zc8/NC1Rtv3L79u2oXLkyOnbsCD09PcyZMwdbt27FokWLcnW/Mjuf2zdbvXo1QkNDMWnSJEUbzBqCDwDOnz+PsmXLwsDAQDGM64wZMxTTnZ2dlf4WHR0doaenh/DwcDRr1gx6enqK4vr48eMRHR2NKlWqKF7n/fdw27ZtuHr1KkxNTTF27Fjs2rULlpaWiukXL17E8+fP0bFjxy++H0RE9IPk6hV3iIjou33qYqtE34tt6sfDZy7+nd2FuklagwcPVlzsPTw8XHTp0kVYWVkJExMTUa1aNaWLa3fv3l3xvEuXLom6desKU1NTYWFhIVq2bCnCwsKEEEJER0eLXr16iQIFCggTExPRtm1bxfP69u0rzMzMRP78+UV4ePhHyxVCiGfPnolWrVoJU1NTYWdnp3RB6A/nz+7Cy9n58ELhWcvYsmWLcHBwEPr6+qJAgQJi+PDhimVduHBBlCxZUpiYmIjhw4cLId5d1Hn69OnfsIUpO2FhYcLd3V2YmZkJc3NzMXz4cCGXy8XkyZNFkSJFhIWFhejevbuIiYkRQmT/PterV0+sWrVKcT8pKUkYGhqK0qVLf/R6GzZsEGXKlBFGRkaiSJEiom/fvopp2X1mLV++XFhbW4v8+fOL7du3f3ZdPmzTycnJYvjw4cLa2lpYW1uL4cOHK13A/VOmTZsmzM3NRZEiRcTGjRuVcj148ECUL19e5M+fX7i7u39yG9KPldWmHjx4IHWUHGFqaiquX78udYw8Rar9yrt374rhw4cLMzMz4erqKvz8/ERGRkau5yAiIsopMiG+c3B6IiLKVcWKFcPq1avRuHFjqaNQHvGztykhhMoN8ySTyRASEoISJUp8NG3dunVYvXo1zp07J0EyIiKir/f333/j0KFDOHny5A9d7pEjR3D69Gmlswdy29GjR9GxY0dERETAwMBAshx5TW7uV6alpWHv3r1Yvnw57t+/j/79+yuGSSMiIspreOVHIiIi+uls374dGzduxKFDh6SOQkRElKcUK1YMQgjs27fvq+afMWNGtgWZOnXqKA079c8//6BXr15fvdz/4uzZs2jRosVHj6ekpMDGxgarVq1i8eYn9OTJE6xcuRJr1qxB6dKlMXToULi7u0NbW1vqaERERDmGZ+AQERHRT+X06dPo2LEjTpw4gbJly0odh0hyT58+RenSpbOddvfuXRQtWjSXE1Fe8bUd87m1HPp5vV+8qVmzptRx6Ccil8tx+PBh+Pj44OLFi+jZsyc8PDzg5OQkdTQiIqJcwQIOERFJLjk5GefOnUOTJk2kjkIq7s6dO2jYsCG2bt2Khg0bSh2HiIiIvoDFG/oekZGR8PX1xcqVK1GgQAF4enqic+fO0NfXlzoaERFRrtKQOgAREVFaWhq6dOmCx48fSx2FVFh4eDhatmyJ+fPns3hDaik+Ph4nTpyQOgYRAgMDMX/+fKlj0E8gq3izf/9+Fm/oi4QQCAgIQOfOneHk5ITHjx9j9+7duHz5Mvr27cviDRERqSWegUNERCrhzz//xNOnT7Fu3Tqpo5AKiouLQ506ddCtWzeMGTNG6jhEkggPD0e5cuUQHh4OXV1dqeOQGgsPD0fZsmXx5MkTGBsbSx2HVNT7xZsaNWpIHYdUWGxsLDZs2AAfHx/IZDJ4eHigZ8+eMDExkToaERGR5HgGDhERqYTffvsN/v7+uHfvntRRSMWkpaWhXbt2qFOnDkaPHi11HCLJFC5cGOXKlYOfn5/UUUjNFS5cGA0bNsSmTZukjkIqisUb+hpXr15F//79Ubx4cVy8eBE+Pj64ffs2hg8fzuINERHR/2MBh4iIVEL+/Pnx22+/YeLEiVJHIRUihED//v1haGiIhQsXQiaTSR2JSFK9evXCxo0bpY5BhCFDhmDp0qXggA70ocOHD7N4Q5+UlJQEX19fVK5cGR07dkTJkiURHByMrVu3om7dutzXIyIi+gCHUCMiIpWRmJiIkiVLws/PDxUrVpQ6DqkAb29vnDx5EidOnOC450R4N5ygjY0NHj16BAsLC6njkBoTQqB06dLw8fFBvXr1pI5DKuLw4cPo3bs3Dhw4gOrVq0sdh1TIvXv34OPjg02bNqFmzZrw9PREs2bNoKmpKXU0IiIilcYzcIiISGUYGBjgjz/+wPjx46WOQirAx8cHO3fuxMGDB1m8Ifp/xsbGaNmyJbZv3y51FFJzMplMcRYOEcDiDX0sLS0N27dvR/369dGwYUMYGRkhMDAQBw8eRMuWLVm8ISIi+go8A4eIiFRKamoqHBwcsHXrVtSsWVPqOCSRAwcOwMPDA+fOnYOdnZ3UcYhUir+/P6ZMmYJLly5JHYXU3Nu3b1GsWDHcuXMHhQoVkjoOScjf3x99+vRh8YYAAE+ePMHKlSuxZs0alC5dGh4eHmjTpg20tbWljkZERPTT4Rk4RESkUnR0dPDnn3/C29ub4+qrqX///RcDBgzA/v37WbwhykbTpk3x5MkTPHjwQOoopOby58+Pzp07Y9WqVVJHIQmxeEMAIJfL4efnB1dXV7i4uCApKQkBAQE4efIkOnXqxOINERHRd+IZOEREpHIyMjJQunRpLFu2DI0bN5Y6DuWikJAQ1K1bF76+vmjZsqXUcYhU1siRI2FkZIQpU6ZIHYXU3M2bN9GiRQs8efIE+fLlkzoO5TIWbygyMhK+vr5YuXIlChQoAE9PT3Tu3JnD3xIREf0gPAOHiIhUjpaWFqZMmcKzcNTMq1ev0KJFC0yZMoXFG6Iv6NmzJzZu3IjMzEypo5CaK1euHOzs7LB//36po1Au8/PzY/FGTQkhEBAQgM6dO8PR0RGhoaHYvXs3Ll++jL59+7J4Q0RE9AOxgENERCqpU6dOSElJwcGDB6WOQrkgMTERrq6u6NatGwYOHCh1HCKVV7FiRejr6+P8+fNSRyHC0KFDsWzZMqljUC7y8/ND3759cfDgQRZv1EhsbCwWLVoEZ2dnDBkyBLVr18aTJ0+wevVquLi4SB2PiIgoT+IQakREpLIOHDiA8ePH48aNG9DQ4DEHeVVGRgbatm0LCwsLrFmzBjKZTOpIRD+FWbNmITQ0FCtXrpQ6Cqm5tLQ02Nra4sSJEyhdurTUcSiHvV+8qVatmtRxKBdcvXoVy5cvx549e9C8eXN4enqiTp063GcjIiLKBewNIyIildW6dWvo6elh+/btUkehHCKEwNChQ5GWloaVK1eyI4DoG3Tv3h27d+9GSkqK1FFIzWlra2PAgAFYvny51FEoh7F4oz6SkpLg6+uLKlWqoGPHjihZsiSCg4OxdetW1K1bl/tsREREuYRn4BARkUo7fvw4hgwZgrt370JLS0vqOPSDTZ8+Hbt27cKZM2dgZGQkdRyin07btm0xffp0nvVAknv27BnKly+PsLAwfp7nUYcOHUK/fv1YvMnj7t27Bx8fH2zatAk1a9aEp6cnmjVrBk1NTamjERERqSWegUNERCqtUaNGKFy4MNavXy91FPrB1q9fj9WrV8Pf35+dfUTfaceOHbC3t5c6BhFsbGxQv359bN68WeoolANYvMnb0tLSsH37dtSvXx8NGzaEkZERAgMDcfDgQbRs2ZLFGyIiIgnxDBwiIlJ5wcHBMDMzg6WlJYdryCOOHTuGHj16ICAgAKVKlZI6DhER/QDHjx/HyJEjcfPmTX5f5yFZxZtDhw6hatWqUsehH+jJkydYtWoV1qxZg1KlSsHDwwNt2rSBtra21NGIiIjo//EMHCIiUnlOTk4oUKAAO4PyiBs3biiu3cHiDRFR3tGoUSOkp6fj3LlzUkehH4TFm7xHLpfDz88Prq6ucHFxQWJiIk6dOoWTJ0+iU6dOLN4QERGpGJ6BQ0RERLkmLCwMtWrVwoIFC9ChQwep4xAR0Q+2cOFCXLx4Edu2bZM6Cv1HLN7kLZGRkfD19cXKlStRoEABeHp6onPnztDX15c6GhEREX0GCzhERESUK968eYNatWph8ODB8PLykjoOUZ4ihOBZiqQSYmNjUbx4cdy7dw/W1tZSx6HvxOJN3iCEwOnTp+Hj44MjR46gffv28PT0hIuLi9TRiIiI6CuxgENEREQ5TgiBiIgInDp1Cj169JA6DlGeERoaCn19fVy6dAlNmjSBgYGB1JGIMHjwYBQpUgQTJkyQOgp9BxZvfn6xsbHYsGEDfHx8AACenp7o2bMnTExMpA1GRERE34wFHCIi+mlERUXB3NwcGhq8hNvPimcJEP04QgjUqlULDx8+hLe3NwYPHgxdXV2pYxEhKCgIrVq1wpMnT6ClpSV1HPoGBw8exIABA3Do0CFUqVJF6jj0ja5evYrly5djz549aN68OTw9PVGnTh3uexEREf3E2ANGREQqLzAwEEuWLMGYMWMQEhIidRz6D9iBQPRj+Pv7o2XLlgAAAwMDeHl5QVdXFzw2i1RB+fLlUaxYMRw4cEDqKPQNWLz5OSUlJcHX1xdVqlRBhw4dUKJECQQHB2Pr1q2oW7cu972IiIh+cizgEBGRylu/fj1Gjx6NypUrw9HRkR2URKS20tPT0bdvX4wbNw6urq64cOECxo0bh9WrV0sdjUjJkCFDsGzZMqlj0Fdi8ebnc+/ePXh5ecHGxgb79u3D5MmT8ejRI/zxxx+wsrKSOh4RERH9ICzgEBGRykpPT8ekSZNw6dIl9O3bFzdv3lQMwZWZmSl1PCKiXLdy5Uo8ffoUN27cwNChQwEAHTp0wL59+3DlyhXIZDLI5XKJUxIB7du3x+3btxEcHCx1FPqCAwcOoH///ize/ATS0tKwfft2NGjQAA0bNoSRkRECAwNx8OBBtGzZEpqamlJHJCIioh+M18AhIiKV1atXL4SHh2Pt2rUoWrQoVq5cieDgYPz9998AgMzMTF4Ph4jUQlbx+tq1axg5ciT++OMPHD16FMnJyWjTpg10dHQwfvx4nD9/XuqoRAre3t5ISEjAwoULpY5Cn3DgwAEMHDiQxRsV9+TJE6xatQpr1qxBqVKl4OHhgTZt2kBbW1vqaERERJTD2OtFREQqafbs2Xj16hVOnDgBKysrvH79Gt27d0dKSgqGDx8OACze/ASyzpTi8SJE/41MJoMQAi4uLujXrx/mz58PS0tL1KpVC2PHjkWDBg1gY2ODu3fvSh2VSGHw4MHYtGkTEhISpI5C2cgq3vj5+bF4o4Lkcjn8/Pzg6uoKFxcXJCYm4tSpUzh58iQ6derE4g0REZGa0JI6ABERUXZMTU0hhMCFCxewfv16vHz5ElZWVli5ciWaNWuGixcvokaNGlLHpM+4d+8eihcvDl1dXaSmpkJXV1fqSER5QpcuXbBgwQI0a9YMLi4ueP78OQoXLoySJUuiUKFCUscjUihatCjq1KmDLVu2YNCgQVLHoffs378fgwYNgp+fHypXrix1HHpPZGQkfH19sXLlShQoUAAeHh7YsWMH9PX1pY5GREREEuAQakREpLKWL1+u6FgYOnQopk+fjqSkJDx79gwzZ85EhQoVpI5InzFt2jTo6uoiNDQUmZmZ8PHxkToS0U9PLpdDU1MTW7duxdmzZ6GtrY0jR46gQoUKmD9/PqytrREXFwdjY2PFsGtEUjp27Bh+//133Lhxg+1RRbB4o3qEEDhz5gyWL1+OI0eOoH379vD09ISLi4vU0YiIiEhiHHuGiIhUTtawW56enrC0tERUVBQsLS0xdOhQbN68GXZ2dqhQoQLS09Px6tUrpeeQtN6/eHrNmjXx559/4smTJ5g9e7aEqYjyjqwLVHft2hVv377Fjh074O3tja1bt8La2hrLli1DvXr1cPv2bchkMn42kuQaNWqE5ORkXLhwQeooBBZvVE1sbCwWLVoEZ2dneHp6olatWnj8+DFWr17N4g0REREB4Bk4RESkojIzM6GhoYG0tDR4eXnh+fPnOHPmDEaOHIlJkyYhOTkZHTt2RExMDPz8/GBqaqp4Dkkj68wAAPD394eOjg4CAgLw+PFjLFiwAMbGxtDW1uZZAUT/UdbfWlRUFDQ0NGBubo6rV69i6tSpuHr1KqpWrQobGxssWrRI6qhEAIAFCxbgypUr2Lx5s9RR1BqLN6rj6tWrWL58Ofbs2YPmzZvDw8MDdevW5f4RERERfYS9XEREpJI0NDQgl8uhra2NqVOnIi4uDtOnT8ekSZPw9OlTuLu74+nTp2jSpAk6d+4MuVzO4o1E4uLiALw7MyAkJATVq1fH/v37UbZsWUydOhVCCCxcuFDx/rBzgui/ySqUWlpaQkdHB0OGDMGgQYNQsWJFhIeHY+/evQgLC8Ply5clTkr0Tu/eveHv74/IyEipo6gtFm+kl5SUhDVr1qBKlSro0KEDSpQogeDgYGzduhX16tXj/hERERFli2fgEBGRSss6qyY+Ph5GRka4fPkyxowZgzJlymDx4sUAAF9fX7Rp0wbm5uZKz6GcN2vWLJQrVw4tW7ZEamoqevbsCVdXV/Tq1Usxz4sXL9ClSxcMGzYMhw8fRvXq1Xkxa6IfJDU1FR4eHvD29kaJEiUAAPHx8Xj9+jUAwMbGBlpaWvxcJMkNHDgQxYsXx7hx46SOonayijf+/v4clksC9+7dg4+PDzZt2oSaNWvC09MTzZo1UxTjiYiIiD6HBRwiIvppvHz5EnXq1EHfvn0VHUDBwcEIDg7G5cuXYWtri8GDBwMAh+nKYWfOnEGJEiVQoEABZGRk4Pbt26hcuTLGjRuHoKAgVKtWDc+ePcPDhw8xbdo0aGlpYdu2bXj58iVWrVoFQ0NDqVeB6Kf3/rCFAJCRkQE/Pz9cuXIF58+fh0wmQ8WKFTFv3jx+JpLkrl+/Dnd3d4SGhkJLS0vqOGqDxRtppKWlYe/evfDx8cG9e/fQv39/DBo0CLa2tlJHIyIiop8MCzhERPRTCQ4OhpOTEwDgypUr2Lt3L16+fAlHR0ccOnQIHTp0gJeXl8Qp87bY2Fj069cP9evXR//+/bFv3z4sW7YMGzZsgKGhISZPnowGDRrA2toajx49wq1btzBv3jwkJydDT08PAM+SIvpR3v9bCg0Nxfjx41G3bl24uLigSpUqqFatGlasWIEKFSrw744kV7NmTYwZMwbu7u5SR1EL+/btw+DBg1m8yUVPnjzBqlWr4Ovri1KlSsHT0xNt2rSBtra21NGIiIjoJ8VfcERE9FPIOt7A0dFR8diRI0eQlpaG0aNHY8yYMdi+fTv8/Pxw8+ZNqWLmeUIImJiYwMPDA9euXcOFCxfQvXt3lCtXDitWrIC5uTmWLVuGjh07olChQti6dSscHBwAgMUbohyQ9bckhMDGjRthYWEBDw8PVKlSBQDg4OCA/fv3K81LJJUhQ4Zg+/btUsdQCyze5Izsjn+Vy+Xw8/ODq6srXFxckJiYiFOnTuHUqVPo1KkTizdERET0n/BXHBER/RSyhv7J+j86OhqnTp3CgAED4OTkhNTUVCxevBhPnjzB8ePHkZqamu2PbPpvsrZ/06ZNUapUKRw8eBDPnj3DpEmTcPXqVRw4cABv377F/v370bx5c7Rt21YxrF0WdiIT/VizZ8/GtWvXoK+vrxhS7d69e5g+fToCAwPx5s0bPH36VOKUREDnzp2xcuVKZGZmSh0lTztx4gQGDx6Mw4cPs3jzA8jlcsXtD4eiTEtLw7hx4zB58mS0a9cOz549w4IFC1CqVKncjklERER5FIdQIyKin46fnx8aNGiAzp07o23btmjbti18fX0RGhqK2rVro3PnzkrXhfjwOhH032SdQfP27Vv8/vvvcHJywm+//YZ9+/Zh6dKl+Pvvv2FmZgYNDQ0ULFhQ6TlE9OPt27cPq1evxqFDh9CiRQvo6ekhMTERZcuWRb169eDq6qrU6cjr4RDlDU+ePEFaWpriTFfg3fftzZs3kZmZiUqVKkmY7ueUVVzMbp8lPj4e169fh729PQoXLqx4/M2bNzA1Nc21jERERKReWMAhIqKfjpeXFwwNDTF9+nS4uroiMjISFhYWGDx4MFq1aoW5c+ciPT0dMTExmDt3LrS0tFjE+UZCCLx8+VJRgPmwwzerIHPmzBmsWrUKnTt3hqurK4YOHYoOHTqgQYMGSvMRUc5q3bo1rK2tERISghIlSqBChQpo164ddHR0MGfOHBQpUgQFCxZE+/btWcAhlRQVFQVLS0upY/w0kpKSMH36dKSnp2Pq1KnQ0dFRTOM+z48jhMDixYuxZMkSVKtWDbdu3YKXlxf69u0rdTQiIiJSEyzgEBHRT6lOnTooV64cAgMD0bhxY7Ru3RouLi7o2rUrdu3ahX/++Qd37tzB2bNnsWfPHqnj/nTu3r2LkydPolKlSti3bx+6dOnyySN5//77b1y5cgVz5sxB4cKF2TFMJIE3b97gwoUL0NXVhampKSpVqoS1a9di/PjxiIqKQmBgIIYOHYqZM2eiZs2a7OAllTN06FDo6+tjzpw5UkdReVkHR1y6dAm7du1CnTp14O7uLnWsn0JmZiaEENl+/kVFReHkyZM4f/48XF1d0bRpU9y4cQPjx4/HypUrkZSUhN9++w0ODg5sp0RERJRrWMAhIqKfUlJSEo4ePQoLCwvY29ujYMGCGDNmDB4/foyuXbvCx8cH+/fvx9ChQzFixAiUL19e8Tx9fX2J06uu98+Y6dy5MwICAlC3bl3s3Lnzo3mzjuJPTk7G8ePH0bp164+mEZE04uLi4ObmhsWLF2PVqlWoWrUqChcujJkzZ+Lo0aNSxyNSyCompqeno2rVqli+fDmqV68udSyVd/jwYSxatAgpKSmwsLCAj48PzM3NpY6lkvbv348HDx5g1KhRSo+/fv0a5ubmkMvlWLduHZYuXYpWrVpBLpfjwoUL2LhxI6KiotC3b1/cvHkTcrkcJ0+exJIlS7B//36J1oaIiIjUDcc0ISKin5K+vj7atGmD2rVrK4b50tLSwqBBg9C2bVtUqVIFTZs2xYsXL2BkZIT79+9j5cqVOH36NDIyMiROr3qEEB8Nd9a4cWM4Ojqie/fu2T5HJpNBLpdDT09PqXiTNY2Icl/WsVmXLl2Cubk5ypYti19++QWLFi3C48ePlf5WExMTpYpJBABKZ0Lcv38f1tbW8PT0lDiV6rt79y6mT5+OqVOnYtq0aZDL5di8eTN4bGb2SpUqpSi4pKamYsmSJShdujTatWuHqVOnQktLC/nz50dERASmTZuGmTNnomTJkjhx4gS0tLRQrFgxREZGQlNTE5mZmXj79i3u378v8VoRERGRumABh4iI8gwtLS2sWLECADBt2jRUqVIF7u7usLCwQOfOnbFx40bY2dkpLlBL/yOTyaChoYHr16+jS5cu8PX1Rb169TB79mzs2bMHJ06c+Og57w/B9PbtW0RGRuZ2bCL6QFbxtG7duggLC8PNmzdhZ2eHdu3aYezYsXB2dsaJEyewZMkSbN26FdHR0RInJnWUVWiQyWR4/fo1Vq5ciVWrVqFFixawsbHBb7/9JnFC1ZaUlISkpCRUrlwZtWrVQo8ePRAUFIS7d+9KHU0l2dvbK7bNq1evsHfvXhw8eBBnzpzBtm3b4O/vDwcHB1SuXBkPHz4EADg4OOD58+ewtLSEEAI7duwA8K54lpmZiZs3b0q2PkRERKReWMAhIqKfXlZH0OTJk5Geno5hw4bh9evXmDdvHlq3bo2pU6eiTJkyCA8PR2RkJLS1tSVOrJq2bNkCDw8P9OjRA48fP0aHDh1QvXp1FClSBGfOnEFQUBAWL16MyMhIZGZmKoo3a9euRceOHXnkL5GKkMvl0NXVhaenJ7y9vfH06VOMHTsWERERsLe3x4QJEzBnzhzY2dnxOjgkiaxC46VLl7B48WIEBwejXLly6NOnDw4cOICjR4+yGPEZBQsWRI0aNRQHV7Ru3RqXLl3CkiVLkJKSInE61aOpqYmSJUvi4cOHCA4ORvHixWFqagoA8PDwwM2bNyGTyWBjY4MrV64AAJycnPDixQtkZmZi3LhxuHDhAooUKYLr16/DwcEBMTExUq4SERERqREWcIiI6KeXNZQXAOzZsweVKlWCjo4OLly4gHHjxkFfXx/z5s3D/Pnz8eTJExYaAKWzkNLT0wEA8fHx2LlzJ+RyOY4ePQoPDw8AgKenJ+RyOQYNGoQLFy7AwsICGhoaiI2NRe/evfHvv/9i//79sLa2lmRdiEhZVlGmf//+GDhwIMzMzPD48WNMnz4dEyZMQLt27aCrq4vMzEyYmJhIG5bUUlJSElasWIFdu3ZBJpPB3d0d/fv3h7GxMQDg5MmTKF26tMQpVVfBggVha2uLzZs34969e3j48CEKFy6MihUr8izjT+jatStOnjwJXV1dmJmZ4fXr1wAAKysrBAYGwsHBAUWLFsWFCxcAACVLlkRycjLCwsJQo0YNrFq1Cs+fP8dff/2FhIQENGzYUMrVISIiIjUiE+zFIiKiPOLDa7iMGzcONjY2aNiwIRwdHQG8O1tH3a/P8v52OnfuHK5fv47hw4ejb9++OHr0KOrVqwdvb284Ozvj/v37MDU1RYECBfD06VMULVoUAHDz5k14eXlh3LhxaNKkiZSrQ0TZeP+zLiEhAWPHjoWpqSlq1qyJFi1awN/fH2lpaWjTpo20QUktJSQkYNKkSShevDjc3NxgY2MDgN/R3yIhIQHLli3D8ePH8fLlS8yYMQOurq5Sx1JZ9+/fx2+//YZ9+/Zh+PDhMDMzw/Tp07Fs2TLcunULy5cvx969e3H27Fn8/fffAN4d4JIvXz4AwL59+7Bo0SK8fv0anTp1wtixY6GlpSXlKhEREZGaYAGHiIjypNjYWDRv3hwjRoxAt27dPjnfh0UfdREREYFff/0VL168QGJiIlasWAFLS0tUqlQJp0+fhrOzM+7du4cRI0ZgyJAhaNu2rdLzY2JioKurC319fYnWgIi+1pEjRzB37lzs3LkTRkZGHDaNVEJERAQKFCjATvBvcPPmTdjb28PAwEDx2LNnzxQFMPqfD4uBGRkZsLKyQnR0NIKDgzF58mTcuXMH5ubmWLFiBRwcHLJdTtZ+Ynh4OLS0tGBlZZVbq0BEREQEgAUcIiLKg7J+tG/ZsgVnzpzB0qVLs+2wzJovMjIScXFxKFmypARpc8f7haq4uDj06dMHDRo0QNeuXfHbb7/BysoKI0eOxKFDh7BixQqUKVMGN2/exNChQ9G/f3+J0xPR98j6jEtJSYGzszNOnjwJW1tbqWMRKRFCIDU1Fbq6ulJHUWm7d+/GiBEjEBoaCh0dHanjqKzY2Fhs2LABL1++hLe3t1Kxy8XFBTt37oSdnR2ioqJgbGz80bbkWWBERESkatTvkGMiIsrzsn54d+vWDbNmzfqoeJN17IJMJkNwcDBGjRoFX19fpKWl5XrW3KKhoYH4+HiMGjUKMTExePHiBRo3bgwLCwv8/vvviImJwdatWzFw4EDs3bsX3bp1w+HDhxXFGx7vQfTzyfos1NXVxcGDBxUX7c4O/8ZJSgMGDEBISIjUMVTW7t27MXToUBw6dIjFm0+4evUqBgwYgOLFi+PChQtwd3f/6CzhK1euwM7ODnK5HJaWltDR0UFmZqbSdYNYvCEiIiJVwwIOERHlSWfPngUAmJiYKP0wf//IyrNnz2LmzJlwcnJCjx49oK2tjZSUFEny5rRTp05hxIgR0NbWRtGiRVG/fn2cOXMGaWlpKFu2LAwMDHDkyBEcO3YMNjY2aNq0KaysrCCXywGwQ4PoZ3XmzBkAQOnSpWFkZPTR9KzPR5lMhlevXiEgICA34xFBJpOhSJEi8PHxkTqKSsoq3vzzzz+oWLGi1HFUSlJSEtasWYMqVaqgQ4cOsLe3R3BwMLZt24Zq1ap9tO+ioaEBIYTSgT0aGhpqOZQuERER/Ty4p0JERHlSWFgYhgwZAuDdj/OsIyyzfszv2bMHK1asQIUKFTB06FCUKVMGFy9exMKFC6WM/UO8X7DKcvjwYezevRuTJk2ChoYGHBwccO/ePSxduhTp6el49eoVdHV1cevWLQD/Oxqf18og+rmFhoZi5syZAJTPssm6ndVxuXv3bowaNQo7duxAQkJC7gcltTZ48GCsX78eSUlJUkdRKe8XbypUqCB1HJVx7949eHl5wcbGBnv37sWkSZPw6NEj/PHHH1+8Rg0PSCEiIqKfDQs4RESUJ2WdUZPVcfn+EZarVq3Cnj170LBhQ4wYMQLR0dHo3bs3KlasCA8PDylj/2dyuVyxnjdu3MCjR48AAFOmTEHx4sUVBar27dvDzc0Nx44dQ82aNdG2bVv07dsXjx8/BsAODqK8omfPnti3bx+ePn0KDQ0NyOVypWJ2YGAgRo4ciYMHD6JevXrw8vKCoaGhxKlJ3RQvXhw1atTAtm3bpI6iMli8UZaWloYdO3agQYMGaNCgAQwNDREYGIiDBw+iVatWPOCEiIiI8iyZ4IDXRESURwkh0LZtW7i7u6Nv374AgIULF+Ls2bPo0aMH2rRpg8uXL+PPP/9E+fLlMXHiRMV46XK5/KfqDEhNTVUaF//XX3/FmTNnULJkSRQqVAjz5s3D2bNnMWTIEGzbtg3Ozs4AgMTERMjlcgQHB6N///74/fff0bt3b6lWg4hywL///osFCxZg69atiseioqKwceNGXLt2DY6OjnBzc1N0Ei9fvhwODg5o1KiRRIlJHR0+fBjjx4/H1atX1f4ggl27dmHYsGEs3uDdGdUrV67EmjVr4OTkBE9PT7Rp0wba2tpSRyMiIiLKFTwDh4iI8iyZTIbt27fjypUriIyMBPDuzJNhw4ahTZs2OHDgAEaPHg13d3f88ccfiI6OxtGjRwG8Gzosu6HIVNGLFy+wfPlyAO86OgYOHAhdXV1cvXoV9vb2WLx4Mfbt24c6deqga9euGDBggOK5BgYGCAoKwp9//onFixezeEOUB1WrVg0AcO7cOeD/2LvvqKiuxuvjewBFFBEVGxYUNWrsNbbYEnuvWNDYxRJLEo2osfeSqLH3HmPvvbeosYBijd2AXVEQpM77R36ZNz52BS7l+1mLFWfunXv2kIHRu+ecK+nWrVvq1KmTbt68qWbNmmnAgAHKkyePfvzxR02bNk0tWrRQ7ty5jYyMBKhq1ary9/fX8ePHjY5iKMqbfz5Es3nzZtWqVUtFihRRYGCg9uzZo71796pJkyaUNwAAIEFhBg4AIN4LCwuTlZXVSzNqfvnlF61bt07fffed6tatKx8fH33//feysrJSpkyZNHv2bAMTf7hWrVrJ29tbGTNmVN++fVWwYEF16tRJKVKkUOHChTV27FgdPHhQqVKlUrdu3TRkyBA5Oztz4V4ggXj+/LnOnz+v4sWLS5I2bNigYsWKydnZWRs2bNC0adOUOXNmtWzZUuXKlTM4LRKq8ePH68yZM1q0aJHRUQzxb3mzfft2FSxY0Og4Me7evXuaN2+eZs6cqTRp0qhz585q2rSpZXY0AABAQkSBAwBIMMxms2VZlo0bNypZsmQqUqSIHB0dNX36dK1cuVJ79uxR5cqV1aJFC7Vu3VrSPwVQokSJDEz+bh07dtT69es1ZcoUNW7cWCdPntTQoUO1fv16SZKTk5Pq1aunOXPmGJwUQGxx8eJFjRo1So8fP1aTJk1Up04dhYeHKygoSJkzZzY6HhKgR48eKUeOHPrrr7/k5ORkdJwYlVDLG7PZrAMHDmj69Onavn27GjZsKA8PDxUrVszoaAAAALECH7sFACQY/11Tv3bt2ipZsqS2bdsms9mshg0bKnfu3Hry5Ilmz56tpEmT6s6dO5o/f762b9+u2P55hwkTJmjatGmaMGGC/P39lThxYtnZ2WnlypUaNGiQ3NzcLNcBkhTrnw+A6Ldr1y5lyJBBv/zyi1q2bCk/Pz916NBBbdq00YwZMyT9s5QREFNSp06tevXqae7cuUZHiVErV65McOWNv7+/Jk+erLx586pz584qU6aMrl+/rjlz5lDeAAAA/AczcAAACVqzZs2UNm1aTZo0SQ0aNFC3bt1UqVIlPXr0SPXq1dOLFy+0YcMGpUmTRjY2NkbHfad27dopWbJkmjx5sgYOHKidO3cqb968mjp1qmxtbY2OByAW+O9sxICAAD19+lSZMmXShAkTtGfPHi1YsEBffPGF/vzzT6VOndrgtEhoTpw4ocaNG+vKlSsvLX0aX61cuVLffvttgilvTpw4oRkzZmj16tWqWrWqOnfurHLlyr30IRsAAAD8f8zAAQAkSP9+fuG3337TyZMn5enpqfPnz8ve3l4PHz7UDz/8oMSJEysoKEjPnz+PE+WNJI0YMUK7du2yLKM2adIkzZkzR7a2toqMjDQ6HoBY4L8nSv38/PTdd99JkkqUKKECBQooTZo06tKli3bv3m1URCRgxYoVU5o0abR161ajo0S7hFLeBAUFad68eSpevLgaNWqk7Nmz6+LFi1q+fLnKly9PeQMAAPAWzMABACRYERERsra21pMnT3T69GklSZJEn332mdq2bavPPvtMo0aN0rRp05QkSRJ16tTJ6Ljv7fz589q6datat25t+fR8ZGSkrKz43AaAV1WrVk2tWrVSrly5NHbsWP3+++8ym83au3ev/P39de7cOTVu3Fi5c+c2OioSiIULF+r333/Xli1bjI4SbVasWKHu3bvH6/LmwoULmjlzppYsWaJSpUrJw8ND1apVSxAzqwAAAKIKBQ4AIEH7b7ERHBysbt26KU+ePHJ3d1f69OkNTvfp/i2pAOB//fv7wdvbW506dVLWrFklScuXL1dgYKC6d++uZcuWadKkSXJ3d1fSpEn5pDxiRHBwsLJkyaKjR48qe/bsRseJcitWrFCPHj20bdu2eFfehIaGat26dZo+fbouXLigdu3aqWPHjnJxcTE6GgAAQJwUN9aDAQAgmvx3VkpAQICuXr2qDh06xIvyxmw2U94AeCNra2tFRkaqYMGCWr58uW7evKly5cppxYoVmjFjhkqUKKHy5cvr4cOHSpYsmdFxkYDY2dmpTZs2mjFjhsaNG2d0nCj1b3mzfft2FShQwOg4UebmzZuaNWuW5s2bp9y5c8vDw0P169dX4sSJjY4GAAAQpzEDBwCA/xg+fLguXLigpUuXvnShbwCI70JDQzVs2DD5+PioZcuWatCggS5fvqxFixZp+PDhRsdDAnPt2jV98cUXunXrluzs7IyOEyXiW3kTERGhbdu2afr06frjjz/k7u4uDw8P5cmTx+hoAAAA8QYFDgAA0ktlTUBAgJInT25woo8TEhIis9kss9kcb054AYgZt27dUseOHTV79mxlzpyZEhuGq1mzpho3bqzWrVsbHeWT/f777+rRo4d27NgR58ube/fuad68eZo1a5acnJzUuXNnNW3aVEmTJjU6GgAAQLzD1YwBAJBkMpn072cakidPrrj4+YaIiAg1a9ZMXbp0ka2trdFxAMQxWbJk0cOHD7Vjxw5JoryB4bp06aKpU6caHeOT/f777+rZs2ecLm/MZrP279+vpk2bKnfu3Lp69apWrlypP//8U23btqW8AQAAiCbMwAEAIB4wm83q3r27zp07p61bt1LgAPggERERsra2lq+vrxIlSqS0adMaHQlQRESEcubMqd9//13Fixc3Os5H+be8iavLpvn7+2vx4sWaMWOGzGazPDw81KpVKzk6OhodDQAAIEGgwAEAIB4YP368Fi5cqIMHD3JSBcAnY/k0xBZjx47V+fPntWDBAqOjfLC4XN6cPHlS06dP1+rVq1W1alV17txZ5cqV4/cCAABADLMxOgAAALFJUFCQIiMjZW9vb3SU9/bbb79p0qRJOnLkCOUNgCjBSVrEFm3btlXOnDn16NEjpU6d2ug47+2/y6blz5/f6DjvJSgoSMuXL9eMGTN0//59derUSRcvXlS6dOmMjgYAAJBgcQ0cAAD+w9fXV/nz59fz58+NjvJe9u7dqx49emjLli3KnDmz0XEAxHGRkZFx8hpgiL+cnJxUp04dzZs3z+go7y2ulTcXLlxQz549lTlzZq1Zs0aDBg3S1atX5enpSXkDAABgMAocAAD+I2fOnCpRooR+/fVXo6O8k4+Pj9zc3LR8+fI4cYIIQOx39uxZbd261egYwEu6du2q6dOnKyIiwugo7xRXypvQ0FCtWLFCFStWVMWKFZUsWTKdOnVKmzZtUs2aNWVtbW10RAAAAIgCBwCAVwwZMkQTJkyQv7+/0VHe6O+//1aNGjU0ceJEVapUyeg4AOKJ8+fPx4kCGwlL8eLFlSpVKm3fvt3oKG+1fPnyWF/e3Lx5U/3795eLi4umT58uDw8P3bp1SyNGjJCLi4vR8QAAAPA/KHAAAPgfuXPnVq1atfTzzz8bHeW1nj59qho1aqhr165q3ry50XEAxCN169bV0aNHdffuXaOjABYmk0ldu3bV1KlTjY7yRsuXL1evXr1iZXkTERGhLVu2qHbt2ipSpIgCAwO1Z88e7d27V25ubkqcOLHREQEAAPAGJjOLXAMA8IobN26oaNGiunjxotKkSWN0HIvQ0FBVr15defLk0a+//sqFxgFEuTZt2qhAgQLq1auX0VEAi6CgIGXJkkXHjx+Xq6ur0XFe8m95s3PnTuXLl8/oOBb37t3TvHnzNGvWLDk5Oalz585q2rSpkiZNanQ0AAAAvCdm4AAA8BpZs2ZV06ZNNXr0aKOjWERGRqpt27ZKnjy5Jk2aRHkDIFq0bNlSixYtMjoG8JKkSZOqdevWmjFjhtFRXhLbyhuz2az9+/eradOmyp07t65evaqVK1fqzz//VNu2bSlvAAAA4hhm4AAA8AZ+fn7Kly+fzp49q4wZMxodR56entq3b592797NCRgA0SYyMlIuLi7aunVrrDghDfzrypUrKlWqlG7duiU7Ozuj4+i3337Td999FyvKG39/fy1evFgzZsyQ2WyWh4eHWrVqJUdHR0NzAQAA4NMwAwcAgDdwdnZW+/btNXz4cKOjaNq0aVq9erU2btxIeQMgWllZWcnd3V2LFy82Ogrwkhw5cqhYsWJasWKF0VFiTXlz8uRJtW/fXtmyZdPhw4c1bdo0nTt3Tt27d6e8AQAAiAcocAAAeIsff/xRK1eu1LVr1wzLsH79eg0fPlzbtm2Tk5OTYTkAJBwtW7bUkiVLtGLFCrVt21YhISFGRwIkSV26dNG0adP04sULbd26VRERETGewejyJigoSPPmzVOJEiXUsGFDubq66uLFi1q+fLnKly/PEqsAAADxCEuoAQDwDoMHD9b169fVvn17rVmzRr/88kuMjf3HH3+oTp062rJli4oXLx5j4wJIuC5duqQRI0Zo6dKlsrW1VXBwsIKCgmLFklXA1atXVbhwYUVERCg4OFh//fWXsmfPHmPjG1neXLx4UTNmzNDixYtVqlQpde7cWdWqVZO1tXWM5gAAAEDMocABAOAd9u3bp8qVK8vGxkYvXrxQZGRkjHy69fLlyypXrpzmzZunGjVqRPt4ACBJv/zyi3744QdFRkZKkuzt7RUQEGBwKkBavny5mjdvLisrK0VERMjW1lZ+fn5KlSpVjIy/bNky/fDDD9qxY0eMlTehoaFat26dpk+frgsXLqhdu3bq2LGjXFxcYmR8AAAAGMvG6AAAAMRm8+fPV7t27WQ2mxUeHi6TyaTIyMho/7TrvXv3VL16dQ0bNozyBkCM6tmzp54+faqxY8cqODhYadKkMToSIEmqWrWqihUrprNnzyoiIkKhoaFKkSJFjIz9b3mzc+dO5c2bN9rHu3nzpmbNmqV58+Ypd+7c8vDwUP369ZU4ceJoHxsAAACxB9fAAQDgLerUqaOvvvpKSZMmlSSZTCaFh4dHy1hLlizRoEGDFBgYqFq1aqlFixbq0KFDtIwFAG9iMpk0ePBgDR8+XJKUJEkSgxMB/0iZMqUOHTqkWrVqydraWjY2NjGyfFhMlTcRERHasmWLateurSJFiigwMFB79uzR3r175ebmRnkDAACQALGEGgAA72A2mzVlyhR9//33CgsLU2BgoJIlSxbl4xQtWlRnzpyRk5OTKleurIULF3IhYgCG8vT0lL+/v6ZPn250FMDCbDarTZs2WrlypZ4/fx7lx3/w4IEaNmyoRYsW6fDhw+rdu3e0ljf379/X3LlzNWvWLDk5Oalz585yc3OLlr9rAAAAIG6hwAEA4D2dOnVK9evX15UrV5QoUaIoPXZQUJAcHR0VFhYmKysrffHFF9q2bZscHByidBwAAOKLsLCwKH8/lqTp06ere/fuSpo0qWxtbbV3794oL2/MZrMOHDigGTNmaNu2bWrYsKE8PDxUrFixKB0HAAAAcRtLqAEA8J6KFCmimzdvRsvJokOHDsnK6p+35USJEunYsWPau3dvlI8DAEB8ER3vx5I0b948hYeH69mzZ4qIiIjSmTD+/v769ddflS9fPnl4eKhUqVK6fv265syZQ3kDAACAV1DgAAAQC0ycOFEhISFKmTKl+vTpo1u3bqlu3bpGxwIAIEG5f/++vLy8JElWVlYKCAiwXA/qU5w8eVLt27dXtmzZdPjwYU2dOlXnz59X9+7d5ejo+MnHBwAAQPxkY3QAAAAgValSRfXq1VO7du1i5ILMAADgVWPGjFF4eLgcHBzUvHlztWzZUiVLlvyoYwUFBWn58uWaMWOG7t+/r44dO+rixYtKly5dFKcGAABAfMU1cAAAAAAA0D/Xu7t586bq1q1rWdr0Q128eFEzZszQkiVLVLJkSXXu3FnVqlXjAxoAAAD4YBQ4AAAAAAB8gtDQUK1bt07Tp0/XhQsX1K5dO3Xo0EFZs2Y1OhoAAADiMK6BAwDARzCZTEqWLJn69+//XvsPGjRIyZIlk8lkUnh4eDSnA4Cowe86xDYf+pp8l0qVKilJkiQqW7bsO/e9f/++tm7d+tJ9N2/e1IABA+Ti4qJp06bJw8NDt27d0ogRIyhvAAAA8MkocAAA+Eje3t4aMWKE5fa/J5Xs7e1lb2+v9u3bW7YNGTJE586dMyImAHyS//1d5+XlpaJFiypp0qQqWrSo5YLvEr/rEDP+9zXZsWNH5cqVS1ZWVlqwYMFL+y5cuFBFixaVg4ODMmXKpD59+rxULu7Zs0czZsx455jPnz9XhQoVVK9ePT1+/FhbtmxR7dq1VaRIEQUEBGjPnj3at2+f3NzclDhx4ih7rgAAAEjYKHAAAIhC3t7eCgwMVGBgoObMmWN0HACIUqGhoapbt67c3d315MkTffPNN6pbt65CQ0ONjoYErGDBgpo2bZqKFCnyyragoCBNnDhRDx8+1LFjx7R7926NHz/+g44fHh6uOnXq6Nq1azKbzcqZM6cGDRqk+vXr69atW5o0aZLy5MkTVU8HAAAAsLAxOgAAAACAuGHfvn0KDw9Xz549ZTKZ1L17d40fP1579uxRtWrVjI6HBKpr166SpCRJkryyrXPnzpY/Z8yYUS1atNDevXvf+9hms1l16tTR/v37FRERIUlKnDixjh8/LpPJ9InJAQAAgLdjBg4AAFGoXLlySp8+vRo0aKAbN24YHQcAotS5c+dUoECBl05cFyhQgGXTEGccOHBAefPmfe/9b926pd27d8tsNsva2lpJkybV3bt3dfbs2WhMCQAAAPyDAgcAgCiyf/9+3bhxQxcvXpSzs7Nq1arFRbwBxCuBgYFKkSLFS/elSJFCAQEBBiUC3t+8efN04sQJ/fDDD+/9GBcXF4WEhCgiIkLPnj3TxYsXdfbs2Q8qgQAAAICPxRJqAABEkXLlykn6Z2mVSZMmycHBQRcuXFD+/PkNTgYAUcPe3l7Pnj176b5nz54pefLkBiUC3s+6devk6empXbt2ycnJ6aOOkTRpUiVNmlSZM2eO4nQAAADA6zEDBwCAaGIymWQ2m42OAQBRJm/evDpz5sxLv9vOnDnDbATEatu2bVOHDh20ceNGPlQBAACAOIUCBwCAKHDu3Dl5eXkpIiJCgYGB+v7775UxY0blyZPH6GgAEGUqVKgga2trTZ48WSEhIZoyZYokqVKlSgYnQ0IWGhqqFy9eyGw2KywsTC9evFBkZKQkac+ePWrRooVWr16tEiVKGJwUAAAA+DAUOAAARIF79+7Jzc1NDg4OcnV11Y0bN7Rp0yYlSpTI6GgAEGUSJ06sdevWadGiRXJ0dNS8efO0bt06JU6c2OhoSMCqVKkiOzs7HTlyRB07dpSdnZ0OHDggSRo2bJiePn2qGjVqyN7eXvb29qpevbrBiQEAAID3YzKztgsAAB8sSZIksrW1Vffu3TVs2LB37j9kyBD9/PPPCgkJ0fPnz2VtbR0DKQHg0/C7DrHNh74m36Vy5co6evSoSpQood27d0dBQgAAACDqUOAAAAAAAAAAAADEMiyhBgAAAAAAAAAAEMtQ4AAAAAAAAAAAAMQyFDgAAAAAAAAAAACxDAUOACDeGzx4sNzd3Y2O8dGyZs2qXbt2SZJGjhyp9u3bG5wIQEL0399Fb3Pjxg2ZTCbZ29vL3t5eWbNm1ejRo1/Zb9++fTKZTBozZkx0xMV7eN//px9j3759ypQp00c//l3vd9GZ/W0+9u8US5cuVZUqVaIhEQAAAOIzChwAAN7Dp56Iiir9+vXTnDlz3rlfhQoV3ms/AIgu/v7+CgwM1KpVqzRs2DDt3Lnzpe0LFy5UqlSptGjRIoMSIjZ73/e72OjfEjM8PNxyX4sWLbRjxw4DUwEAACAuosABACCK/PdEDQDEVqdOnVLhwoWVPHlyNW7cWG5ubhowYIAkadOmTSpUqJAcHR1VunRpnTlzRpLUsmVL3bp1S7Vr15a9vb3Gjh373uMVK1ZMefPmlZeXl+W+58+fa9WqVZo6dar++usvnThxIkqfI/AmvFcDAAAgLqHAAQDEC35+fmrYsKHSpEmjbNmyafLkyW/c9+jRoypdurQcHR1VsGBB7du3z7Lt8ePHatOmjZydnZUyZUrVq1dPz58/V/Xq1eXn52dZEsjPz0+DBw9Wo0aN5O7uLgcHBy1YsEB+fn6qU6eOUqVKpRw5cmj27NmWYw8ePFhNmjRRq1atlDx5cuXNm/eDT1r+d+mWFy9eyN3dXalTp5ajo6OKFy+ue/fuqX///jp48KC6desme3t7devW7cO+mQDirdDQUNWvX1+tW7fW48eP1axZM61du1aSdPr0abVt21YzZ87Uo0eP1KlTJ9WpU0chISFavHixsmTJoo0bNyowMFB9+vR57zGPHj0qHx8f5ciRw3LfmjVrZG9vr8aNG6tq1apauHBhlD9XvL+QkBD17NlTzs7OcnZ2Vs+ePRUSEmLZvn79ehUqVEgODg7Knj27tm3bJkmaP3++8uTJo+TJk8vV1VUzZ8784LHHjBmjjBkzKnny5MqVK5d2794t6dWlyhYvXiwXFxelTp1aI0aMeOkYkZGRGj16tLJnz67UqVOrSZMmevz4saT/Pxtm7ty5ypIliypVqiRJmjdvnvLkyaOUKVOqatWqunnzpuV4PXr0UObMmeXg4KCiRYvq4MGDH/ScypUrJ0lydHSUvb29/vjjDy1YsEBly5a17GMymTRt2jTlzJlTyZMn108//aSrV6+qdOnScnBwUJMmTRQaGmrZ/03lKgAAAOI3ChwAQJzVpUsXdenSRZGRkapdu7YKFiwoX19f7d69WxMnTtT27dtfeYyvr69q1qypAQMG6PHjxxo/frwaNmyoBw8eSPrnU+ZBQUE6d+6c7t+/r169eilZsmTaunWrnJ2dFRgYqMDAQDk7O0v656RWo0aN5O/vrxYtWqhp06bKlCmT/Pz8tGrVKvXr10979uyxjL9hwwY1bdpU/v7+qlOnzieVKwsXLtTTp091+/ZtPXr0SDNmzJCdnZ1GjBihL7/8UlOmTFFgYKCmTJkiSapVq9Zrr0MBIOE4evSowsPD1b17dyVKlEgNGjRQiRIlJEmzZs1Sp06d9MUXX8ja2lrffPONbG1tdfTo0Y8ay8nJSXZ2dipVqpS6dOmievXqWbYtXLhQbm5usra2VvPmzbV8+XKFhYVFxVPERxgxYoSOHj0qLy8veXt76/jx4xo+fLgk6fjx42rVqpXGjRsnf39/HThwQFmzZpUkpU2bVps2bdKzZ880f/589erVS6dOnXrvcS9duqQpU6bozz//VEBAgLZv32459n+dP39enTt31uLFi+Xn56dHjx7p77//tmz/9ddftW7dOu3fv19+fn5KmTKlunbt+tIx9u/frwsXLmj79u1av369Ro4cqTVr1ujBgwf68ssv1axZM8u+xYsXl5eXlx4/fqzmzZurcePGevHixXs/rwMHDkj6/8sIlipV6rX7bd++XSdPntTRo0c1duxYdezYUUuWLNHt27fl4+Oj3377TdLby1UAAADEbxQ4AIA4a9q0aZo2bZr+/PNPPXjwQAMHDlTixInl6uqqDh06aPny5a88ZsmSJapRo4Zq1KghKysrVa5cWcWKFdOWLVt0584dbd26VTNmzFDKlCmVKFEilS9f/q0ZSpUqpXr16snKykoPHz7U4cOHNWbMGCVJkkSFChVS+/btX7q+Q9myZVWjRg1ZW1urZcuW8vb2/ujnnyhRIj169EhXrlyRtbW1ihYtKgcHhzfuv2nTJvXt2/ejxwMQ9/n5+SljxowymUyW+zJnzixJunnzpiZMmCBHR0fL1+3bt+Xn5/dRYz18+FCBgYGaMGGC9u3bZylobt++rb1796pFixaSpLp16+rFixfavHnzJz47fKylS5dq4MCBSps2rdKkSaNBgwZp8eLFkqS5c+eqbdu2qly5sqysrJQxY0blzp1bklSzZk1lz55dJpNJ5cuXV5UqVT5otoq1tbVCQkJ0/vx5hYWFKWvWrMqePfsr+61atUq1atVSuXLlZGtrq2HDhsnK6v//U3bGjBkaMWKEMmXKJFtbWw0ePFirVq16abm0wYMHK1myZLKzs9OMGTPk6empPHnyyMbGRv369ZOXl5dlFs6/s1ttbGz0/fffKyQkRJcuXfqo7+3b9OnTRw4ODsqbN6/y5cunKlWqyNXVVSlSpFD16tV1+vRpSVFfrgIAACDuoMABAMR5N2/elJ+f30snHUeOHKl79+69dt+VK1e+tO+hQ4d0584d3b59W6lSpVLKlCnfe+x/T3xK/5wYTZUqlZInT265z8XFRb6+vpbb6dOnt/w5adKkevHixUevx9+yZUtVrVpVTZs2lbOzs/r06cMn2AG8VYYMGeTr6yuz2Wy57/bt25L++X3Wv39/+fv7W76CgoIsMxP+W/q8L2tra3333XdKkiSJpk2bJumfpbD+nTmZPn16ubq66sWLFyyjZiA/Pz+5uLhYbru4uFiKu9u3b7+2VJGkrVu3qmTJkkqVKpUcHR21ZcsWPXz48L3HzZEjhyZOnKjBgwcrbdq0atq06WsLQz8/v5feb5MlS6bUqVNbbt+8eVP169e3vK/nyZNH1tbWL/094L+Pv3nzpnr06GHZP1WqVDKbzZb36/HjxytPnjxKkSKFHB0d9fTp0w96Xu8rXbp0lj/b2dm9cjswMNCSNyrLVQAAAMQdFDgAgDgvc+bMypYt20snHQMCArRly5bX7tuyZcuX9n3+/Ln69u2rzJkz6/Hjx/L393/lcW86cfnf+52dnfX48WMFBARY7rt165YyZsz46U/yNRIlSqRBgwbp/PnzOnLkiDZt2mSZ7fMxJ1oBxH+lSpWStbW1pkyZovDwcK1fv17Hjx+XJHXo0EEzZszQsWPHZDab9fz5c23evNnyOy1dunS6du3aR43bt29fjR071lLUDBo0SF5eXpav1atXa8uWLXr06FGUPVe8P2dn55euAXPr1i3LUqGZM2fW1atXX3lMSEiIGjZsqB9++EH37t2Tv7+/atSo8VI5+D6aN2+uQ4cO6ebNmzKZTPrxxx9f2SdDhgyWolGSgoKCXnqtZM6cWVu3bn3pvf3Fixcvvf/+76yzmTNnvrR/cHCwSpcurYMHD2rs2LFasWKFnjx5In9/f6VIkeKDnldUvwe/q1wFAABA/EWBAwCI80qUKKHkyZNrzJgxCg4OVkREhHx8fPTnn3++sq+7u7s2btyo7du3KyIiQi9evNC+ffv0999/K0OGDKpevbq6dOmiJ0+eKCwszLKOfbp06fTo0SM9ffr0jTkyZ86s0qVLy9PTUy9evNCZM2c0d+7cly7CHJX27t2rs2fPKiIiQg4ODkqUKJFlSZlPOdEKIP5KnDix1qxZo7lz58rR0VFLlixRrVq1ZGtrq2LFimn27Nnq1q2bUqZMqRw5cmjBggWWx3p6emr48OFydHTU+PHjP2jcmjVrKmXKlBo3bpxu3ryprl27Kn369JavOnXqKEeOHJZrfiBmNWvWTMOHD9eDBw/08OFDDR061PLe1a5dO82fP1+7d+9WZGSkfH19dfHiRYWGhiokJERp0qSRjY2Ntm7dqh07dnzQuJcuXdKePXsUEhKiJEmSyM7O7qWl0f7VqFEjbdq0SYcOHVJoaKgGDhyoyMhIy3YPDw/179/fUkI9ePBA69evf+O4Hh4eGjVqlM6dOydJevr0qVauXClJCggIkI2NjdKkSaPw8HANHTpUz549+6DnlSZNGllZWUXZ+/C7ylUAAADEXxQ4AIA4y8PDQx4eHrK2ttamTZvk5eWlbNmyycnJSe3bt39t2ZI5c2bLxYvTpEmjzJkza9y4cZYTQYsXL1aiRImUO3dupU2bVhMnTpQk5c6dW82aNZOrq6scHR3fuGzJb7/9phs3bsjZ2Vn169fXkCFD9PXXX0fL8797964aNWokBwcH5cmTR+XLl1fLli0lST169NCqVauUMmVKde/eXZJUvXp1jRw5MlqyAIg7ihUrJi8vLwUGBmrlypXy9fVVpkyZJEnVqlXTn3/+KX9/f925c0crV660LAtZt25d3bp1S/7+/vrhhx/eePysWbPKbDbLxsbGcp/JZNK5c+f0008/6cWLF0qTJs0rjzt37py6desWxc8W72PAgAEqVqyYChQooPz586tIkSIaMGCApH8+JDF//nz16tVLKVKkUPny5XXz5k0lT55ckydPVpMmTZQyZUotW7ZMderU+aBxQ0JC1LdvXzk5OSl9+vS6f/++Ro0a9cp+efPm1dSpU9W8eXNlyJBBKVOmtLxmpX/e8+rUqaMqVaooefLkKlmypI4dO/bGcevXr68ff/xRTZs2lYODg/Lly6etW7dKkqpWrapq1arps88+k4uLi5IkSfLS8mvvI2nSpOrfv7/KlCkjR0fHT75WzbvKVQAAAMRfJvOHznEHAAAAEGft379fuXLlkpOTk5YuXSoPDw9du3ZNGTJkiJHxw8LClChRohgZCwAAAADiMmbgAAAAAAnIpUuXVLBgQTk6OmrChAlatWrVB5c3S5culb29/StfefPmfevjvL29lSlTJm3fvv1TngIAAAAAJAjMwAEAwGC3bt3S559//tpt58+fV5YsWWI4EQBEn8OHD6tevXpau3atypYta3QcRLPoeo8zm80ymUyfEu2TLF26VJ06dXrlfhcXF8u1dQAAAIBPRYEDAAAAIEZt375dLVu21I4dO1SoUCGj4yCOOXz4sMaNG6d169YZHQUAAACIViyhBgAAACBGVa1aVdOmTVONGjV0+fJlo+MgDjGbzfL09FT9+vWNjgIAAABEOwocAACiWLt27XTjxg2jYwBArNaoUSMNHz5clStX1q1bt4yOgzhix44devDggdzd3Y2OAgAAAEQ7G6MDAAAQ35w5c0YPHjxQ1qxZjY4CALFa27Zt9fTpU1WuXFkHDx5U2rRpjY6EWMxsNmvAgAEaOnSorK2tjY4DAAAARDsKHAAAAACG6dWrl/z9/VW1alXt3btXjo6ORkdCLLVu3TqFh4erYcOGRkcBAAAAYgRLqAEAAAAw1ODBg/Xll1+qVq1aCgoKMjoOYqGIiAj99NNPGj58uKys+GcsAAAAEgb+5gsAAADAUCaTSRMnTlT27NnVoEEDhYaGGh0Jscxvv/0mBwcH1ahRw+goAAAAQIyhwAEAAABgOCsrK82dO1d2dnZq0aKFIiIijI6EWCIsLEyDBw/WiBEjZDKZjI4DAAAAxBgKHAAAAACxgo2NjX777Tc9efJEnTp1ktlsNjoSYoH58+crW7ZsqlixotFRAAAAgBhFgQMAAAAg1kiSJInWrVsnHx8f/fDDD5Q4CdyLFy80bNgwjRgxwugoAAAAQIyjwAEAAAAQq9jb22vLli3auXMnJ+4TuBkzZqhIkSIqUaKE0VEAAACAGGdjdAAAAAAA+F+pUqXSjh07VLZsWTk6Oqpbt25GR0IMCwwM1OjRo7Vjxw6jowAAAACGoMABACCKJUqUiIssA0AUSJ8+vXbt2qUvv/xSDg4OatWqldGREIMmT56sihUrqkCBAkZHAQAAAAxhMrOoNAAAUSoiIkJWVlaUOAAQRS5cuKCKFStq5syZqlu3rtFxEAOePHminDlz6siRI/rss8+MjgMAAAAYghk4AABEMWtra6MjAEC8kidPHm3atEk1atSQvb29vvrqK6MjIZqNHz9edevWpbwBAABAgsYMHAAAAABxwv79+9W4cWNt3LhRX3zxhdFxEE3u37+vPHny6NSpU3JxcTE6DgAAAGAYChwAAAAAccbmzZvVtm1b7dq1S/nz5zc6DqJBr169FBERocmTJxsdBQAAADAUBQ4AAACAOOW3335T7969tX//fmXPnt3oOIhCf//9twoWLKhz584pffr0RscBAAAADGVldAAAAOKTx48f6+bNm5avZs2a6caNG3r69KnR0QAg3mjWrJl++uknVa5cWb6+vkbHQRQaNmyYOnToQHkDAAAASLIxOgAAAPGFu7u7Dh8+rOTJk1vuu3Llinx8fNSlSxd17tzZwHQAEL906tRJ/v7+qlKlivbv3y8nJyejI+ETXb16VatXr9bly5eNjgIAAADECiyhBgBAFClQoIDOnDnz0n1FihTRqVOnDEoEAPGfp6endu3apd27d8vBwcHoOPgELVu2VM6cOTVw4ECjowAAAACxAkuoAQAQRYoXL67Jkydr4cKFCg8PV2RkpCpWrGh0LACI10aOHKlixYqpTp06Cg4ONjoOPpKPj4927Nihnj17Gh0FAAAAiDUocAAAiCIXL17U1atXtW3bNvXq1UtBQUHy9vY2OhYAxGsmk0lTpkyRs7OzmjRporCwMKMj4SMMHDhQffr0YRYVAAAA8B8soQYAQBQpWLCgvL29FRkZqcKFC8vb21vFihXTiRMnjI4GAPFeWFiY6tevrxQpUmjx4sWysuKzanHFiRMnVK9ePf3111+ys7MzOg4AAAAQa/CvGgAAokixYsW0d+9eWVlZycrKSo8ePeKT4AAQQxIlSqSVK1fK19dX3bp1E59TizsGDBig/v37U94AAAAA/4MZOAAARJG8efPqwoULcnFx0f379+Xs7KwJEyaoTp06RkcDgATj2bNnqlSpkqpUqaKRI0caHQfvcPDgQX3zzTe6ePGiEidObHQcAAAAIFahwAEAIIrcunXL8uckSZIobdq0BqYBgITr4cOHKleunFq3bq0+ffoYHQdvYDabVb58ebVr107ffPON0XEAAACAWMfG6AAAAMQX//1MRHBwsG7evClJcnFxMSoSACRITk5O2rlzp8qWLStHR0d17NjR6Eh4jR07dujBgwdyd3c3OgoAAAAQK1HgAAAQRWrXri2z2SyTyaTnz5/r5s2bypEjhy5evGh0NABIcDJmzKidO3eqfPnycnBwUNOmTY2OhP8wm83q37+/hg4dKmtra6PjAAAAALESBQ4AAFHkzJkzL93+888/NWXKFIPSAABy5Mihbdu26euvv1by5MlVs2ZNoyPh/2zZskURERFq2LCh0VEAAACAWItr4AAAEI3y58+vs2fPGh0DABK0o0ePqk6dOlq1apXKlStndJwEz2w269GjRzp37pzKly9vdBwAAAAg1qLAAQAgCp04cUKHDx+WJJUpU0bp0qVTpkyZZDKZDE4GAAnb7t271axZM23dulVFixY1Ok6CFxkZKZPJxPsjAAAA8BZWRgcAACCua9GihZ4/f66hQ4fKw8ND/v7+8vf3V8eOHbVgwQJOTgFALPDVV19p1qxZqlWrli5cuGB0nATPysqK90cAAADgHZiBAwDAJypcuLBOnz6t3Llzy9vbW7a2tpKksLAw5c+fXxcvXjQ4IQDgX4sWLdK4cePk7e0tKys+zxYTnjx5okOHDql27dpGRwEAAADiFP7FAgDAJwoJCVFwcLDSpUunsLCwl+5PmzatgckAAP+rVatWWrt27Uu/r/8VGhqqM2fOGJAqfmvevLlu375tdAwAAAAgzqHAAQDgE7Vu3VrlypVT2rRpVbRoUX3//ff6/vvvVaRIEWXKlMnoeACA/5EjRw7LbMn/atSokUqUKKEhQ4YYkCp+atGihZydndWlSxdJEgtAAAAAAO+PAgcAgE/Up08fzZ49W9WqVVOnTp2UMWNGZcyYUR4eHipWrJjR8QAA7+HIkSPy9/fXixcvdO3aNTVp0kTBwcFGx4rTPD09tWrVKjk7O+vRo0eKiIjgujcAAADAB+AaOAAARLGAgABZWVkpWbJkRkcBALyHsLAwZcqUScePH5eLi4t2796tWbNmafHixUqcOLHR8eKkhQsXaubMmVq+fLkGDhwoa2tr9enTR7ly5TI6GgAAABBnMAMHAIAocuPGDZUtW1a5c+dWmjRp9PXXX+vatWtGxwIAvIOnp6fs7Ozk4uKi4OBgnTt3TnZ2dvL397fs8/z5c+MCxjHXrl1TunTptHr1amXJkkUzZ86UnZ2d+vfvr+PHjysyMtLoiAAAAECcQIEDAEAU6dy5s3r27ClfX1/lzp1bM2fOVNeuXY2OBQB4i3Pnzmnr1q3q3r27nJ2dVadOHfn5+alRo0ZKmzatIiIi9OTJE9WpU0eDBw+mfHiH06dPq1u3brKzs1OGDBkUEhIiW1tbTZkyRQULFtTgwYO1Y8cOhYaGGh0VAAAAiPVsjA4AAEB8cefOHTVq1EjSPxdpzp49ux4+fGhwKgDAm0RGRqps2bLau3evChUqJF9fXwUHB2v06NGWfebNm6e7d+/q8OHDsre3l5UVn4F7kwcPHqhjx47q1auXypcvL0mytbW1bP/pp580d+5c9enTRwsWLFCRIkWMigoAAADECfzrAwCAKBIeHv7S7ePHjytp0qQGpQEAvMuTJ080aNAgFSpUSJKUM2dOWVtbS5ICAwM1a9YszZ07VwULFlSNGjXUsWNHSVJERIRRkWO1kSNHqnz58mrevLkiIyN16dIljRkzRtu3b1dgYKAkqV27dlq0aBHlDQAAAPAemIEDAEAUadq0qc6cOaMCBQooLCxMnp6emj17ttGxAABvkDp1avXs2dNy+/Tp00qTJo2eP3+uYcOGacOGDdq8ebNcXV21Z88eS7nz73/xspw5c1r+3LdvX127dk13797V0qVL5ebmpv79+0uSpTADAAAA8HbMwAEAIIoMGDBABQoUkCT5+Pho9+7devTokcGpAADvIzIyUi4uLkqZMqXKlCkjf39/RUZGaurUqTp37pwOHjyovHnzGh0zVvv88881efJkVaxYUXv37tU333yjQ4cOac2aNdqxYwfviQAAAMAHYgYOAABR5MiRI1q+fLkCAgIs923YsEF16tRRvXr1VLduXQPTAQDexsrKSv369dOePXt09+5djRs3TmazWd9++63y58+v1q1bK3PmzIqMjOQ6OP8jPDxc1tbWqlChgnbt2qUHDx7o888/t1z/5t69e5Z9AAAAALw/ChwAAKJIhw4d1Lt3bzk4OFjuO3DggGrVqqVcuXIZmAwA8L4qVaqkSpUqSZJMJpOmTJkiR0dHpU+fXpIob/5j165dypo1q3LkyGG5LlCmTJmUKVMmSVJwcLD+/vtvde3aVcOHD5ejo6OBaQEAAIC4x2Q2m81GhwAAID4oWrSoTp48+dJ9RYoU0alTpwxKBACICjly5NDYsWPVoEEDo6PEKn/++afKli2r7du3q0KFCpL+WYouMjJSNjY2OnTokKZOnaovv/xSXbp0MTYsAAAAEAfx8TEAAD5Bt27dLH9etWrVK9tXr14dk3EAAFHIbDYrMjJS7dq1U7169YyOE+sUL15c169fV9OmTTVnzhxJ/8xQsrH5Z6GHS5cuqVOnTpQ3AAAAwEdiBg4AAJ+gcOHCOn36tNExAAAxIDg4WKGhoUqRIoXRUWKV58+fq2TJkqpZs6ZGjx4tSapfv76SJk2qpUuXGpwOAAAAiLuYgQMAwCcwmUxGRwAAxKDSpUvr9u3bRseIVZIlSyYvLy9dvHhRHTt21NChQ/Xo0SPKGwAAAOATUeAAAPAJmMgKAAmHnZ2d2rZtq8qVK+v+/ftGx4lVrK2ttW7dOtnb22vMmDFat26d0ZEAAACAOI8l1AAA+ARFihTRqVOnjI4BAIhBP/30kzZv3qy9e/eynNr/MZvNllmpAQEBSp48ucGJAAAAgLiPGTgAAHyCHj16GB0BABDDhg4dqjJlyqhWrVoKCgoyOk6scPbsWQUHB0sS5Q0AAAAQRZiBAwBAFGnbtu1bl1SbP39+DKYBAESnyMhItW7dWg8fPtS6deuUOHFioyMZxmw2q3jx4powYYLKly9vdBwAAAAg3rAxOgAAAPFFrVq1jI4AAIghVlZWmjdvnho1aqSWLVtq2bJlsra2NjqWIdauXavIyEh9+eWXRkcBAAAA4hVm4AAAAADAR3rx4oVq1qwpV1dXzZo1y3IdmIQiIiJCBQoU0Lhx41SjRg2j4wAAAADxCgUOAABRpFKlSq9dQm3v3r3q0KGDZs+ebUAqAEB0CwgI0Ndff61y5cpp7NixCarEWbJkiaZPn65Dhw4lqOcNAAAAxAQKHAAAosipU6dee3+RIkV08eJF5c6dO4YTAQBiyuPHj1W+fHk1a9ZM/fr1MzpOjAgLC1Pu3Lk1d+5cVahQweg4AAAAQLzDNXAAAIgiNjY2ypgxo1KnTi1/f39du3ZNhQoVkiTKGwCI51KlSqUdO3aobNmySpEihbp27Wp0pGg3b948ubq6Ut4AAAAA0YQZOAAARJGiRYtq3759sra2VsGCBZUtWzZlzJhR8+fPNzoaACCGXL9+XeXKldOoUaPk7u5udJxo8+LFC+XMmVOrV69WiRIljI4DAAAAxEtWRgcAACC+iIyMVPLkybV9+3bVqFFDO3bs0MmTJ42OBQCIQdmyZdP27dv1ww8/aMOGDUbHiTbTp09X0aJFKW8AAACAaESBAwBAFDGZTDp37pwWLVqkGjVqWO4DACQsn3/+uTZu3Kj27dtr7969RseJcoGBgRozZoyGDRtmdBQAAAAgXqPAAQAgiowePVotW7ZU6tSpVaVKFT179kxt27Y1OhYAwADFixfXihUr5ObmpuPHjxsdJ0pNmjRJlSpVUv78+Y2OAgAAAMRrXAMHAIBotHr1ajVs2NDoGAAAg2zatEnt27fXrl27lC9fPqPjfLInT57os88+05EjR5QzZ06j4wAAAADxGgUOAABRZM2aNVqwYIECAgIk/bN82p9//qlixYqpdevW+uabbwxOCAAwwrJly9SnTx8dOHBArq6uRsf5JP3799e9e/c0Z84co6MAAAAA8R4FDgAAUSR37tyaMWOGHBwcJP1T4DRv3lxLlixRxowZlT59eoMTAgCMMn36dI0fP14HDx6Us7Oz0XE+yr179/T555/r9OnTypIli9FxAAAAgHjPxugAAADEF0mTJlWFChVeus/Ozk5FixY1JhAAINbo3Lmz/P39VblyZR04cECpU6c2OtIHGzVqlFq0aEF5AwAAAMQQZuAAABBFQkJCZGtr+877AAAJk9lsVt++fbV3717t3r1byZMnNzrSe7t9+7YKFiyo8+fPM6MUAAAAiCEUOAAAAAAQQ8xmszw8PPTXX39py5YtSpIkidGR3kvHjh2VOnVqjRo1yugoAAAAQIJBgQMAQBQLCAiQnZ2dbGxYqRQA8KqIiAi1aNFCwcHBWrVqlRIlSmR0pLe6cuWKSpYsqcuXLytVqlRGxwEAAAASDCujAwAAEN/06NFDly9fNjoGACCWsra21qJFixQeHq42bdooMjLS6EhvNXjwYPXo0YPyBgAAAIhhFDgAAESxs2fP6vnz50bHAADEYokTJ9bKlSt169Ytffvtt4qtCyP4+Pho586d6tmzp9FRAAAAgASHAgcAAAAADJA0aVJt3LhRR48e1U8//WR0nNcaOHCg+vTpo+TJkxsdBQAAAEhwWJwfAAAAAAySIkUKbdu2TeXKlVOKFCnUu3dvoyNZ/Pnnnzp+/LiWLl1qdBQAAAAgQaLAAQAgivy7/I3ZbLZ8mUwmg1MBAGK7NGnSaOfOnfryyy/l6OioDh06GB1JkjRgwAD1799fdnZ2RkcBAAAAEiSTObYutgwAQBxTt25dbdiwwXLb2tpat2/fVoYMGQxMBQCIK/766y9VqFBBP//8s9zc3AzNcuDAAbVu3VoXL15U4sSJDc0CAAAAJFRcAwcAgCjSpEkT2dvbW27ny5dP6dOnNzARACAuyZkzp7Zu3aru3btr69atMT5+SEiIfH19ZTab1b9/fw0ePJjyBgAAADAQBQ4AAFGkadOmcnR0lCQlSZJEEyZMYAk1AMAHKVCggNatW6dWrVrp4MGDMTr2xo0blSVLFlWqVEl3795VixYtYnR8AAAAAC+jwAEAIIpYW1tr9OjRkmQ5AQYAwIcqVaqUli1bpoYNG+rUqVMxNm5wcLBsbW21b98+3bx5U126dFFoaGiMjQ8AAADgZRQ4AABEoaZNmypFihQaOHAgs28AAB+tcuXKmjFjhmrWrKmLFy/GyJjh4eGKjIyUJFlZWWn79u0KDg6OkbEBAAAAvMrG6AAAAMQn1tbW8vf3NzoGACAeaNCggZ49e6YqVarowIED+uWXXxQZGalff/01WsYLDQ1VSEiIbG1t1bRpU02bNk1JkyaNlrEAAAAAvBsFDgAAAADEUq1bt9aTJ0+UP39+hYeHK1GiRJo0aZKsrKJ+MYXz58/LyspKS5YsUaNGjaL8+AAAAAA+jMlsNpuNDgEAAAAAeFVoaKjq16+vnTt3KiwsTPb29tq1a5e++OKLKB/ryZMn8vf3V7Zs2aL82AAAAAA+HNfAAQAAAIBY6tatWzp06JBsbW0lSYGBgVqxYkW0jJUyZUrKGwAAACAWYQYOAAAAAMRioaGh2rp1q6ZMmaLdu3crefLkevr0qdGxAAAAAEQzChwAAAAAiCPu3r2r3bt3q0WLFkZHAQAAABDNKHAAAAAAAAAAAABiGa6BAwDARzCZTEqWLJn69+//XvsPGjRIyZIlk8lkUnh4eDSnA97sQ1+771KpUiUlSZJEZcuWjZLjAfgwUf0znT17diVOnFju7u5RcjwAAAAAH48CBwCAj+Tt7a0RI0a8cv+iRYtkMpk0Z84cy31DhgzRuXPnYjIe8Eb/+9rt2LGjcuXKJSsrKy1YsOCV/a9du6ZatWopefLkcnJyUp8+fSzb9uzZoxkzZsREbABv8KE/0//66quvXvlgwdWrV9WvX7/ojAsAAADgPVHgAAAQhZ48eaKRI0cqb968RkcB3lvBggU1bdo0FSlS5JVtoaGhqly5sipVqqS7d+/q77//5pP5QCz3tp/pfy1dulRhYWExmAoAAADAh7IxOgAAAPGJp6enunfvrhUrVhgdBXhvXbt2lSQlSZLklW0LFiyQs7OzvvvuO8t9BQoUiLFsAD7c236mJenp06caMmSIFi1apFKlSsVkNAAAAAAfgBk4AABEkePHj+vEiRPy8PAwOgoQZY4ePaqsWbOqevXqcnJyUoUKFXT27FmjYwH4BP369VPnzp2VPn16o6MAAAAAeAsKHAAAokBERIS6dOmiKVOmyMqKt1fEH3///beWL1+u7t27y8/PTzVr1lTdunUVGhpqdDQAH+HEiRM6fPiwvv32W6OjAAAAAHgHzjABABAFpk2bpgIFCqhkyZJGRwGilJ2dncqWLavq1asrceLE+uGHH/To0SNduHDB6GgAPlBkZKS6dOmiSZMmycaG1bQBAACA2I4CBwCAKLB7926tXbtW6dOnV/r06XXkyBF9//336tatm9HRgE9SoEABmUwmo2MAiALPnj3TiRMn5ObmpvTp06t48eKSpEyZMungwYMGpwMAAADwv/jYFQAAUWDBggV68eKF5XaDBg3UqFEjtWvXzsBUwPsJDQ1VZGSkzGazwsLC9OLFCyVOnFhWVlZyd3fXhAkTtGvXLlWsWFGTJ0+Wk5OT8uTJY3RsAG/wpp/pFClSyM/Pz7Lf7du3VaJECZ08eVJp0qQxMDEAAACA12EGDgAAUcDR0dEy+yZ9+vRKnDixHBwclCJFCqOjAe9UpUoV2dnZ6ciRI+rYsaPs7Ox04MABSVKuXLm0ZMkSeXh4KGXKlFq/fr02bNigxIkTG5wawJu86WfaZDK99F71b2mTLl06fqYBAACAWMhkNpvNRocAACCuSZIkiWxtbdW9e3cNGzbsnfsPGTJEP//8s0JCQvT8+XNZW1vHQErgVR/62n2XypUr6+jRoypRooR2794dBQkBfIio/pnOlSuXfH191aRJE82bNy8KEgIAAAD4WBQ4AAAAAAAAAAAAsQxLqAEAAAAAAAAAAMQyFDgAAAAAAAAAAACxDAUOAAAxLGvWrNq1a5fRMQAAMSw+//5v3bq1BgwYYHQMAAAAIF6hwAEA4CPE55NwiP9u3Lghk8mk8PDwaDn+0KFDZTKZXvoZ8fX1Vd26dZUqVSplypRJM2bMeOPjN2/erLJly8rR0VHp06dX+/btFRAQYNn++PFjubm5KXXq1HJyclKLFi307NkzSdL9+/fVrFkzOTs7K0WKFCpTpoyOHTtmeezIkSNlb29v+bKzs5OVlZUePnwYDd8JAAAAAAA+HgUOAACAwcxmsyIjI42O8d7eVvxcvXpVK1euVIYMGV66393dXdmyZdO9e/e0efNm9evXT3v37n3tMZ4+faoBAwbIz89PFy5ckK+vr3r37m3ZPmDAAD158kTXr1/X1atXde/ePQ0ePFiSFBgYqOLFi+vkyZN6/PixvvnmG9WsWVOBgYGSpH79+ikwMNDy9eOPP6pChQpycnL6xO8KEDtEVzELAAAAIOZR4AAAErRTp06pcOHCSp48uRo3biw3NzfLEjCbNm1SoUKF5OjoqNKlS+vMmTOSpJYtW+rWrVuqXbu27O3tNXbs2LeOsXjxYrm4uCh16tQaMWLES9siIyM1evRoZc+eXalTp1aTJk30+PFjy/ZDhw6pdOnScnR0VObMmbVgwYKo/Qbgk2TNmlWjRo3S559/rpQpU6pNmzZ68eKFJOnJkyeqVauW0qRJo5QpU6pWrVr6+++/LY+tUKGC+vfvrzJlyihp0qS6du2a5s+frzx58ih58uRydXXVzJkzLfvv27dPmTJl0tixY5U2bVplyJBB69at05YtW/TZZ58pVapUGjlypGX/t722ypUrJ0lydHSUvb29/vjjD0nSvHnzlCdPHqVMmVJVq1bVzZs3LcczmUyaOnWqcubMqZw5c77xe9K1a1eNGTNGiRMnttwXGBioffv2qX///kqUKJEKFiyoRo0aad68ea89RvPmzVWtWjUlTZpUKVOmVIcOHXT48GHL9uvXr6tevXpycHBQihQpVL9+fZ07d06S5Orqqu+++04ZMmSQtbW1OnbsqNDQUF26dOmVccxmsxYtWqRvvvnmjc8HiGpeXl4qUKCAUqRIITc3N8vvjNmzZytHjhxKlSqV6tSpIz8/P0mvnzFXoUIFzZkzR5K0YMEClSlTRr169VLq1KktZebrXL16VZUqVXpp9pq/v79le9asWTV+/PjX5pOksWPHKkOGDHJ2dtacOXNkMpl05cqV1471pvdQAAAAAO+PAgcAkGCFhoaqfv36at26tR4/fqxmzZpp7dq1kqTTp0+rbdu2mjlzph49eqROnTqpTp06CgkJ0eLFi5UlSxZt3LhRgYGB6tOnzxvHOH/+vDp37qzFixfLz89Pjx49eukk/q+//qp169Zp//798vPzU8qUKdW1a1dJ0s2bN1W9enV9++23evDggby8vFSoUKFo/Z7g3bp06aIuXbpYbi9dulTbt2/X1atXdfnyZQ0fPlzSPwVKmzZtdPPmTd26dUt2dnbq1q3bS8davHixZs2apYCAALm4uCht2rTatGmTnj17pvnz56tXr146deqUZf+7d+/qxYsX8vX11dChQ9WhQwctWbJEJ0+e1MGDBzVs2DBdv35d0ttfWwcOHJAk+fv7KzAwUKVKldL69es1cuRIrVmzRg8ePNCXX36pZs2avZR33bp1OnbsmM6fPy/pnwLo0KFDlu0rV66Ura2tatSo8dLjzGbzS//9988+Pj7v9T0/cOCA8ubNa7ndtWtXbdq0SU+ePNGTJ0+0evVqVa9e/bWP9fLyUmhoqHLkyPHKtoMHD+r+/ftq2LDhe+UAosKKFSu0bds2Xb9+XWfOnNGCBQu0Z88eeXp6asWKFbpz545cXFzUtGnT9z7msWPH5Orqqnv37ql///5v3M9sNsvT09Myu+327duvFD6vyydJ27Zt088//6xdu3bpypUr2rdv3xvHedt7KAAAAIAPYAYAIIHav3+/2dnZ2RwZGWm5r0yZMub+/fubPTw8zAMGDHhp/88++8y8b98+s9lsNru4uJh37tz5zjGGDBlidnNzs9wODAw0J0qUyPLY3Llzm3ft2mXZ7ufnZ7axsTGHhYWZR44caa5Xr94nPUdELxcXF/P06dMttzdv3mx2dXV97b6nT582Ozo6Wm6XL1/e/NNPP731+HXr1jVPnDjRbDabzXv37jUnSZLEHB4ebjabzeZnz56ZJZmPHj1q2b9IkSLmtWvXms3mt7+2rl+/bpZkDgsLs2yvVq2aec6cOZbbERERZjs7O/ONGzfMZrPZLMm8e/fuN2Z99uyZOUeOHObr169bvjf//RkpU6aMuVu3bubg4GDzyZMnzSlTpjR/9tlnb33+ZrPZvGPHDrOjo6P50qVLlvt8fX3NX331ldlkMplNJpP566+/NoeEhLzy2KdPn5rz5ctnHjly5GuP3bZtW/M333zzzgxAVHFxcTEvXrzYcrt3797mTp06mdu2bWvu3bu35f6AgACzjY2N+fr165af16dPn1q2ly9f3jx79myz2Ww2z58/35w5c+aPyrN27VpzoUKF3pnPbDab27RpY+7bt69l219//WWWZP7rr7/MZrPZ/M0335j79+9vNpvN73wPBQAAAPB+mIEDAEiw/Pz8lDFjRplMJst9mTNnlvTP7JcJEybI0dHR8nX79m3LkjYfMsa/x5SkZMmSKXXq1JbbN2/eVP369S1j5MmTR9bW1rp3755u376t7Nmzf+KzRHT77/9fFxcXy2skKChInTp1kouLixwcHFSuXDn5+/srIiLitY+VpK1bt6pkyZJKlSqVHB0dtWXLFj18+NCyPXXq1LK2tpYk2dnZSZLSpUtn2W5nZ2e51svbXluvc/PmTfXo0cOyf6pUqWQ2m+Xr6/vGvP81ePBgtWzZUlmzZn3t9qVLl+r69evKnDmzOnfuLHd3d2XKlOmNx5Oko0ePqnnz5lq1apU+++wzy/1NmjTRZ599poCAAD179kzZs2eXu7v7S48NDg5W7dq1VbJkSXl6er5y7KCgIK1cuZLl0xDj0qdPb/lz0qRJFRgYKD8/P7m4uFjut7e3V+rUqeXt7a1Ro0ZJknbs2PHGY77tZ/O/7t27p6ZNmypjxoxycHCQu7v7S79j3pRPevX97G1jRtV7KAAAAJDQUeAAABKsDBkyyNfX96VlnW7fvi3pnxNT/fv3l7+/v+UrKCjIsqTUf0ufd43x7zGlf04aP3r0yHI7c+bM2rp160vjvHjxQhkzZlTmzJl19erVqHiqiEb//f9769YtOTs7S5ImTJigS5cu6dixY3r27Jll2bL/vt7++zoKCQlRw4YN9cMPP+jevXvy9/dXjRo1Xtr/Q7zttfW612/mzJk1c+bMl/YPDg5W6dKlX5v3f+3evVuTJ09W+vTplT59et2+fVtNmjTRmDFjJP1Tbm3atEkPHjzQsWPH9PDhQ5UoUeKNxzt9+rTq1KmjefPm6auvvnppm5eXlzp16qRkyZLJ3t5eHh4e2rJli2V7SEiI6tWrp0yZMr10HaH/Wrt2rVKlSqUKFSq8MQMQU5ydnV+65tTZs2f14MEDtWzZ0lL6VqlSxbL97t27Lz3+fd+T+vXrJ5PJpLNnz+rZs2dasmTJe/+OyZAhw0tLgP73d9//etd7KAAAAID3Q4EDAEiwSpUqJWtra02ZMkXh4eFav369jh8/Lknq0KGDZsyYoWPHjslsNuv58+favHmzAgICJP0z6+HatWvvHKNRo0batGmTDh06pNDQUA0cOFCRkZGW7R4eHurfv7/lxN2dO3eUIUMGTZkyRc2aNdOuXbu0YsUKhYeH69GjR/Ly8or6bwQ+ydSpU/X333/r8ePHGjFihNzc3CRJAQEBsrOzk6Ojox4/fqwhQ4a89TihoaEKCQlRmjRpZGNjo61bt771E/fv8r+vrQcPHmj9+vWSpDRp0sjKyuql17CHh4dGjRqlc+fOSZKePn2qlStXvvd4u3fvlo+Pj7y8vOTl5SVnZ2fNnDnTct2dCxcuKCAgQKGhoVqyZIl27Nih77777rXH8vHxUbVq1fTrr7+qdu3ar2wvXry45syZo+DgYAUHB2vWrFkqUKCAJCksLEyNGjWSnZ2dFi5cKCur1/91d+HChWrVqtV7n/gGolOzZs00f/58/f7773Jzc1OJEiXk7OysK1euaM6cOcqYMaOWLFmiiIgIzZs376PL/YCAANnb2ytFihTy9fXVuHHj3vuxTZo00fz583XhwgUFBQVp2LBhb9z3Xe+hAAAAAN4PBQ4AIMFKnDix1qxZo7lz58rR0VFLlixRrVq1ZGtrq2LFimn27Nnq1q2bUqZMqRw5clgu5CxJnp6eGj58uBwdHTV+/Pg3jpE3b15NnTpVzZs3V4YMGZQyZcqXlo3q0aOH6tSpoypVqih58uQqW7as6tSpo+XLl6tFixaaNm2aJkyYoFSpUqlQoULy9vaOzm8J3oOHh4c8PDwst5s3b64qVarI1dVV2bNn14ABAyRJPXv2VHBwsJycnFSyZElVq1btrcdNnjy5Jk+erCZNmihlypRatmyZ6tSp89E5//e1VbJkSR07dkzSP8si9e/fX2XKlJGjo6OOHj2q+vXr68cff1TTpk3l4OCgfPnyaevWrW8dw97eXgcPHpT0z/Ju/86+SZ8+vaytrZUyZUrZ29tLkrZv3y5XV1elTJlSM2bM0LZt25QmTZrXHmvChAl68OCB2rVrJ3t7e9nb2ytv3ryWfefNm6cbN24oU6ZMypgxo65du6aFCxdKko4cOaJNmzZpx44dcnR0tDz+32NLkq+vr/bs2aNWrVp99PcXiEpJkiRRunTp1KJFC23cuFHly5fXH3/8obRp00qSZs+erXHjxil16tQ6d+7cSzPjPsSgQYN06tQppUiRQjVr1lSDBg3e+7HVq1dX9+7dVbFiReXIkUMlS5aUJNna2r6y77veQwEAAAC8H5P5Y9flAAAgHvriiy/k4eGhNm3aGDL+li1bVKNGDUVGRmr69OkaNGiQevbsqR9//FGJEiUyJBPeLGvWrJozZ46+/vpro6MAiGPMZrO2bt2qUaNGyc/PT71791br1q2VJEkSo6O9lwsXLihfvnwKCQmRjY2N0XEAAACAeIkZOACABG3//v26e/euwsPDtXDhQp05c+adMyWiS0REhNq2bau5c+fKyspKXbt21alTp3TkyBEVK1ZMJ06cMCQXACDqhIeH67ffflOhQoXk6empLl266NKlS/Lw8Ij15c3atWsVEhKiJ0+e6Mcff1Tt2rUpbwAAAIBoRIEDAEjQLl26pIIFC8rR0VETJkzQqlWrlCFDhg86xtKlSy3LNP33679LPr0Pa2trHThwQCNHjtSgQYNkNpuVJUsWbd68Wb1791bNmjXVu3dvBQUFfdBxAQDGe/HihWbOnKlcuXJp6tSpGjlypLy8vNSsWbMoLUE8PDxe+57036UfP9bMmTOVNm1aZc+eXdbW1po+fXoUJAYAAADwJiyhBgBALHPv3j3VqlVL+fPn18yZMy1Lpz148EA9evTQ8ePHNXv2bFWsWNHgpACAd3n27JlmzpypX375RYULF5anp6fKli0bJcdev369Lly4oL59+0bJ8QAAAADELhQ4AADEQoGBgXJzc1NERIRWrlyp5MmTW7Zt2rRJXbp0UdWqVTVu3Dg5OjoaFxQA8FoPHjzQpEmTNGPGDFWuXFl9+/ZVwYIFo+z4vr6+Kly4sDZt2qQSJUpE2XEBAAAAxB4soQYAQCxkb2+v9evXK3PmzCpfvrzu3Llj2VarVi35+PgoUaJEypcvn9atW2dcUADAS27duqXu3bsrV65cevDggY4eParffvstSsubyMhItW7dWt9++y3lDQAAABCPUeAAABBL2djYaNasWapfv75Kly6tixcvWrY5ODho2rRpWrZsmX788Uc1adJE9+7dMzAt4psXL15o586dRscA4ozz58/rm2++UeHChZUkSRKdO3dOM2fOVI4cOaJ8rMmTJ+v58+fy9PSM8mMDAAAAiD0ocAAAiMVMJpN++uknDRo0SOXLl9ehQ4de2l6uXDl5eXkpe/bsKlCggBYuXChWR0VUOH/+vH788UejYwCx3vHjx1W/fn1VrFhROXPm1JUrVzR27FhlyJAhWsY7e/asRowYocWLF8vGxiZaxgAAAAAQO1DgAAAQB7Ru3VqLFi1S/fr1tXr16pe22dnZadSoUdq2bZsmTZqkatWq6caNG8YEBYAEwGw2a9euXfrqq6/UuHFjVapUSdevX9eAAQOUMmXKaBs3JCRELVq00JgxY5Q9e/ZoGwcAAABA7ECBAwBAHFG1alVt375d3bt31+TJk1/ZXrhwYR07dkyVKlVSsWLFNGnSJEVERBiQFADip8jISK1evVolSpRQ9+7d1apVK125ckXffvutkiZNGu3jDxgwQDly5FCbNm2ifSwAAAAAxjOZWWcFAIA45caNG6pevbpq1qypsWPHysrq1c9jXL58WR06dFBISIjmzp2rvHnzGpAUcdmpU6fUvn17nTp1yugogOFCQ0O1dOlSjRkzRilSpJCnp6fq1Knz2t+/0WXPnj1q2bKlvL295eTkFGPjAgAAADAOM3AAAIhjsmbNqsOHD+vo0aNq3ry5QkJCXtnns88+0969e9W6dWtVqFBBQ4YMUWhoqAFpASDuev78uSZOnKjs2bNr2bJlmjZtmo4ePap69erFaHnz5MkTtW7dWnPnzqW8AQAAABIQChwAAOKgVKlSadeuXQoPD1fVqlX15MmTV/axsrKSh4eHTp8+rRMnTqho0aI6duyYAWkBIG55/Pixhg4dqmzZsunQoUNas2aNdu7cqUqVKslkMsV4ni5duqhu3bqqVq1ajI8NAAAAwDgUOAAAxFFJkiTR77//rkKFCunLL7/UrVu3XrtfpkyZtGHDBvXv319169bVd999p+fPn8dwWgCI/Xx9ffXDDz8oR44cunHjhg4cOKBVq1apePHihmVatmyZvL29NWbMGMMyAAAAADAGBQ4AAHGYtbW1Jk6cqLZt26pMmTLy9vZ+7X4mk0lNmzaVj4+PHjx4oPz582vXrl0xnBYAYqe//vpLHTp0UP78+RUeHi5vb2/NmzdPuXPnNjTXzZs31bNnTy1ZskRJkyY1NAsAAACAmEeBAwBAPPDdd99p/Pjxqly58luLGScnJy1evFhTp05Vu3bt1LZt29cuvwYACcHp06fl5uam0qVLy9nZWZcvX9bEiROVOXNmo6MpIiJC33zzjb777jsVKVLE6DgAAAAADECBAwBAPOHm5qZVq1apRYsWWrx48Vv3rV69unx8fJQ0aVLly5dPq1evjqGUAGAss9ms/fv3q1q1aqpVq5ZKlCiha9euaciQIXJycjI6nsWECRMUGRmp3r17Gx0FAAAAgEFMZrPZbHQIAAAQdc6dO6caNWrIw8NDffv2fecFtw8dOqT27dsrb968mjJlijJkyBBDSRGbnTp1Su3bt9epU6eMjgJEicjISG3evFmjRo3SgwcP1KdPH7Vq1Uq2trZGR3uFl5eXKleurD///FNZs2Y1Og4AAAAAgzADBwCAeCZv3rz6448/9Pvvv6tLly4KDw9/6/5ly5aVl5eX8uTJo4IFC2revHni8x0A4ovw8HAtWbJEBQsW1MCBA9WzZ09dvHhRHTp0iJXlTXBwsFq0aKGff/6Z8gYAAABI4JiBAwBAPPXs2TM1bNhQdnZ2Wr58+XtdANvb21vt2rWTo6OjZs2aJVdX1xhIitiIGTiI64KDgzV//nyNGzdOWbJkkaenp6pWrfrOWYlG69Gjh+7evavly5fH+qwAAAAAohczcAAAiKccHBy0efNmOTo6qlKlSnrw4ME7H1OwYEEdPXpU1apVU4kSJfTzzz8rIiIiBtICQNR4+vSpRo8eLVdXV23btk1Lly61XPMmthciO3bs0Jo1azR9+vRYnxUAAABA9KPAAQAgHkucOLEWLlyor776SqVLl9aVK1fe+RgbGxv98MMPOnr0qDZu3KjSpUvr7NmzMZAWAD7evXv35OnpKVdXV/n4+GjHjh3asGGDSpcubXS09/Lo0SO1bdtWCxYsUKpUqYyOAwAAACAWoMABACCeM5lMGjFihL7//nt9+eWXOn78+Hs9LkeOHNqzZ4/at2+vSpUqadCgQQoJCYnmtADwYW7cuKGuXbsqT548evbsmU6cOKElS5Yof/78Rkd7b2azWR07dlSTJk301VdfGR0HAAAAQCxBgQMAQALh4eGhWbNmqWbNmtq4ceN7PcZkMqlDhw7y8vKSt7e3ChcurD/++COakwLAu/n4+Khly5YqWrSoHBwcdOHCBU2dOlXZsmUzOtoHW7hwoS5fvqyRI0caHQUAAABALEKBAwBAAlK7dm1t2rRJHTt21MyZM9/7cRkzZtTatWs1ZMgQNWjQQN27d1dgYGA0JgWA1/vjjz9Up04dff311/r888917do1jRo1SunSpTM62ke5du2aevfuraVLlypJkiRGxwEAAAAQi1DgAACQwHzxxRc6ePCgxo8frwEDBshsNr/X40wmkxo3biwfHx89e/ZM+fLl0/bt26M5LQD8s8TYtm3bVKFCBTVv3lzVqlXT9evX5enpqRQpUhgd76OFh4erVatW8vT0VIECBYyOAwAAACCWocABACABypEjh44cOaKdO3eqdevWCg0Nfe/Hpk6dWgsWLNDMmTPVqVMnffPNN3r06FE0pgWQUEVERGjFihUqWrSofvjhB7Vv316XL19Wly5dZGdnZ3S8TzZmzBjZ2tqqZ8+eRkcBAAAAEAtR4AAAkEClSZNGe/bs0ZMnT1SrVi09e/bsgx5ftWpV+fj4yNHRUfny5dOKFSveezYPALxNSEiI5syZozx58mjixIkaMmSIzpw5I3d3dyVKlMjoeFHixIkTmjRpkhYsWCArK/5ZBgAAAOBV/EsBAIAELFmyZFqzZo1cXV1Vrlw5+fn5fdDj7e3tNWnSJK1Zs0aDBw9WvXr15OvrG01pAcR3gYGBmjBhglxdXbVq1SrNnj1bhw8fVu3ateNVyfH8+XO1aNFCv/76qzJnzmx0HAAAAACxVPz5VxAAAPgoNjY2mj59utzc3FS6dGmdP3/+g49RqlQpnT59WoUKFVKhQoU0a9YsRUZGRkNaAPHRw4cPNWjQIGXLlk3Hjh3Txo0btW3bNpUvX14mk8noeFGud+/eKlGihNzc3IyOAgAAACAWo8ABAAAymUzy9PTUsGHDVLFiRR04cOCDj2Fra6shQ4Zoz549mjNnjr766itduXIlGtICiC9u376tnj176rPPPpOfn5+OHDmiFStWqEiRIkZHizabN2/Wli1bNGXKFKOjAAAAAIjlKHAAAIBFy5YttWTJEjVq1EgrVqz4qGPkz59ff/zxh2rXrq2SJUtq3LhxCg8Pj+KkAOKyS5cuqW3btipYsKCsra119uxZzZ49Wzlz5jQ6WrS6f/++OnTooIULFypFihRGxwEAAAAQy1HgAACAl1SuXFk7d+7U999/r19++eWjjmFtba3vvvtOx48f17Zt21SyZEl5e3tHcVIAcc3JkyfVqFEjffnll8qaNav++usvTZgwQRkzZjQ6WrQzm83q0KGDWrVqpfLlyxsdBwAAAEAcQIEDAABeUbBgQR0+fFhz5sxRr169Pvp6Nq6urtq1a5e6dOmiypUrq3///nrx4kUUpwUQm5nNZu3Zs0eVK1dWvXr1VLZsWV2/fl0DBw5U6tSpjY4XY+bMmaNbt25p6NChRkcBAAAAEEdQ4AAAgNfKkiWLDh06pFOnTsnNze2jixeTyaS2bdvK29tbly5dUqFChXTo0KEoTgsgtomMjNS6detUsmRJdenSRc2bN9fVq1fVs2dPJUuWzOh4Meqvv/6Sp6enli5dqsSJExsdBwAAAEAcQYEDAADeKGXKlNqxY4esrKxUuXJlPX78+KOPlSFDBq1atUojR46Um5ubunXrpoCAgChMCyA2CAsL08KFC5UvXz4NHz5cffr00blz59SmTZsEWV6EhYXJ3d1dgwYN0ueff250HAAAAABxCAUOAAB4K1tbW/3222/64osvVKZMGd24ceOTjtegQQP5+PgoODhY+fLl05YtW6ImKKJUgQIFtH//fqNjIA4JCgrSr7/+qhw5cmjRokWaNGmS/vzzTzVs2FDW1tZGxzPMiBEjlDJlSnXt2tXoKAAAAADiGJPZbDYbHQIAAMQNkyZN0tixY7Vp0yYVLlz4k4+3a9cudezYUaVLl9bEiRPl5OQUBSkBxKQnT55o2rRpmjx5skqXLq2+ffvqiy++MDpWrPDHH3+oXr16On36tJydnY2OAwAAACCOYQYOAAB4bz169NCkSZNUtWpV7dix45OP9/XXX+vs2bNKly6d8uXLJ29vb/HZEiBuuHPnjvr06aMcOXLo8uXL2rt3r9auXUt5838CAwPVsmVLTZ8+nfIGAAAAwEdhBg4AAPhghw4dUsOGDTVmzBi1bt06So55/PhxZcuWTWnSpHnt9vDwcNnY2ETJWAA+3tWrVzVu3DitWLFC7u7u+v777+Xi4mJ0rFinQ4cOioiI0Lx584yOAgAAACCO4iwIAAD4YGXLltW+fftUo0YN3b59WwMGDJDJZPqkY5YoUeK1s2/MZrNMJpNsbGz09OlT/f777/rqq6+UPXv2TxoPwIfx9vbW6NGjtXPnTnl4eOjixYtKmzat0bFipXXr1mnPnj3y8vIyOgoAAACAOIwCBwAAfJQ8efLoyJEjqlmzpm7fvq1p06Z98gyZ15VAc+bM0d69e9WgQQM5ODjo+PHjypIli7Jnz86snGjk4OBgKc/+l9lsVkBAgAGpEB0iIyNlZfXmlZUjIiK0ePFi9evXTz179tTMmTPl4OAQgwnjlrt378rDw0Nr1qxR8uTJjY4DAAAAIA5jCTUAAPBJAgIC1LhxY9nY2Oj3339XsmTJouS44eHhmj59upYuXaoff/xRq1atkslk0meffaYePXooRYoUln3fVDQAeJm/v78cHR0VGhqqxIkTv7Tt1q1bevz4sQoVKvTKz9TDhw9lb2+vJEmSxHTkOMVsNqtmzZoqWrSohg0bZnQcAAAAAHHcmz9qBwAA8B6SJ0+ujRs3Km3atKpQoYLu3bsXJcf18fHR33//rWHDhql+/fpyd3fXuXPnlDZtWp05c0YNGzbUrFmzFBIS8tKJZj6bEjUePXqkyZMna+HChQoPD1dERISeP39udCx8gl9++UWdOnWSpJfKm9WrV6tkyZJq3ry5fv75Z23btu2VQtTJyYny5j1Mnz5dDx480MCBA42OAgAAACAeoMABAACfLFGiRJo7d65q1Kih0qVL6/Lly598zHv37unBgwcqXry4JOn27duqVauW1q5dq+3bt2vEiBE6c+aMevTo8dLj/j3xHBkZ+ckZErLatWvr6tWr2rZtm3r16qXg4GDVrVvX6Fj4BKVKldK1a9e0c+dO1a1bV5UrV9aNGzeUIUMGrV+/XocOHVKqVKk0e/ZsXb161ei4cc6FCxc0cOBALVmyRIkSJTI6DgAAAIB4gAIHAABECZPJpCFDhsjT01Ply5fX0aNHP+l4kZGR8vX1laOjowIDA+Xl5aVEiRLp6NGjWrt2rebNmyd3d3c9e/ZMV65cUXh4uHbs2KG5c+fqyZMnb72mB97t+fPnmjRpkpYuXaoDBw7I3t5e/v7+RsfCJ8ifP79sbW21ZMkS/fjjjypevLgmTpwoJycnbdmyRZ9//rkuX76sRIkS6cCBA0bHjVNCQ0Pl7u6u4cOHK1euXEbHAQAAABBPcGYDAABEqfbt22vu3LmqXbu21q9f/9HHyZ8/v6ysrFSzZk21bt1aV65c0d9//62KFSvq3LlzypAhg/r166fDhw8rR44catWqlVatWqUDBw6oaNGiWrZsGbNwPkGxYsW0d+9eWVlZycrKSo8ePVJYWJjRsfAJkiVLpnTp0slkMql06dJyc3NT0qRJtXz5cm3btk1//vmntmzZomTJkkXJLLqEZMiQIcqQIYNliToAAAAAiAo2RgcAAADxT40aNbR161bVqVNHvr6+6tKlywcfI1OmTNq6dav27t2rM2fO6P79+8qXL58OHz4sSerVq5d69eolSdq8ebN8fHx06tQp2djYKCgoSH///TezcD7B0aNHNX/+fLm4uOj+/fsqWbKkfv75Z6Nj4RM1btxYc+fOlSS5uLjI0dFRT58+1dq1azVjxgxduHBBt2/flp+fnx4+fCgnJyeDE8d+Bw8e1Lx58+Tl5fXKtYMAAAAA4FOYzFzpFwAARJNr166pWrVqatCggUaOHPlJhUpoaKisra3VokUL3blzR/Xr19cXX3yhUqVKqW7duqpataq6dOmi58+fK1myZIqIiJC1tXUUPpuE5datW5Y/J0mSRGnTpjUwDaKKr6+vatasqT179ihVqlSaOXOmbt26JX9/f/n4+CggIED9+vVT0aJFlS1bNqPjxnpPnz5VoUKFNHnyZNWuXdvoOAAAAADiGT6WCgAAoo2rq6uOHDmi/fv3q1WrVgoNDf3oYyVOnFjW1tZavny5hg8fritXrujChQuS/lluzcbmn4nFyZIlkyTKm0+UJUsW2dvby2w2Kzg4WDdv3lSzZs1048YNPX361Oh4eE937txRRESE5XbGjBmVKlUqbdiwQZKUO3du5cyZU3379tXmzZt16tQpNWrUiPLmPXXv3l1VqlShvAEAAAAQLZiBAwAAol1QUJBatGihZ8+eac2aNUqRIkWUHNdsNstkMmn//v3q06ePGjdurObNm8vJyUmJEyeOkjESKnd3dx0+fFjJkye33Hf16lW5urqqS5cu6ty5s4Hp8DZms1m7du3SqFGjlCZNGi1atEi2traW7XPmzJGjo6MaNWpkYMq4b+XKlerfv79Onz5tKY4BAAAAICpR4AAAgBgRERGhHj166MCBA9qyZYsyZcoUJcf9t8Tx9vbWL7/8oly5cunbb7+Vvb39S9vxYQoUKKAzZ868dF+RIkV06tQpgxLhXSIiIrRu3TqNGjVKQUFB6tu3r5o1a6ZEiRIZHS3e8fX1VZEiRbRx40aVKFHC6DgAAAAA4ikbowMAAICEwdraWr/++qvGjRun0qVLa8uWLcqXL98nH/ffcqZgwYJasGDBK9ufPXumO3fuKHfu3J88VkJSvXr1V+6rXLmyAUnwLqGhoVqyZInGjh2rFClSaMCAAapTp84nXXMKbxYZGanWrVura9eulDcAAAAAohUzcAAAQIxbtmyZevbsqd9//10VK1aMtnHMZrNOnjyp6tWrq2fPnurTpw+zERBvPH/+XLNnz9aECROUO3dueXp6qmLFisw4i2aTJk3S8uXLdfDgQcu1twAAAAAgOlDgAAAAQ+zZs0dNmzbVpEmT1KxZs2gd69atW/Lw8JCvr6/mzp2rYsWKRet4QHR6/Pixfv31V02dOlXlypVT3759eU3HEB8fH1WsWFFHjx5V9uzZjY4DAAAAIJ5jXQUAAGCISpUqaffu3frxxx81btw4RednSrJkyaLNmzerd+/eqlmzpvr06aOgoKBoGy8+MJvNioiIMDoG/sPX11fff/+9cuTIoZs3b+rAgQNatWoV5U0MCQkJUYsWLTR69GjKGwAAAAAxggIHAAAYJn/+/Dpy5IgWLVqk7t27R2thYDKZ5O7urrNnz+r27dsqUKCA9u7dG23jxXWnT59W8eLFjY4BSX/99Zc6dOig/PnzKzIyUt7e3po3bx7XdYphAwYMkKurq9q2bWt0FAAAAAAJBAUOAAAwVKZMmXTw4EH5+PiocePGCg4Ojtbx0qZNq99++02//PKLWrVqpQ4dOsjf3z9axwQ+xunTp9WkSROVLl1azs7Ounz5sn755RdlzpzZ6GgJzt69e7Vs2TLNnj2bawwBAAAAiDEUOAAAwHCOjo7atm2bkiRJoq+++kqPHj2K9jFr164tHx8f2djYKF++fFq3bl20jwm8i9ls1v79+1WtWjXVrl1bJUuW1PXr1zVkyBA5OTkZHS9BevLkib755hvNnTuX/wcAAAAAYhQFDgAAiBVsbW21ZMkSlStXTqVLl9b169ejfcwUKVJo+vTpWrp0qfr06aMmTZro3r170T4u8L8iIyO1YcMGlSlTRh06dFCjRo109epVfffdd7K3tzc6XoLWtWtX1alTR9WqVTM6CgAAAIAEhgIHAADEGlZWVho9erS6d++uMmXK6OTJkzEybvny5eXt7S1XV1flz59fCxculNlsjpGxkbCFh4dryZIlKlCggAYPHqxevXrpwoULat++vWxtbY2Ol+AtW7ZMp0+f1tixY42OAgAAACABMpk5OwEAAGKhtWvXqmPHjlq0aJGqV68eY+OeOnVK7dq1U9q0aTVz5kxlzZo1xsaOTU6dOqX27dvr1KlTRkeJl4KDgzV//nyNGzdOLi4u8vT0VJUqVbi+Sixy69YtFStWTNu2bVORIkWMjgMAAAAgAWIGDgAAiJXq16+v9evXq02bNpo7d26MjVukSBEdP35cFStWVLFixTRp0iRFRETE2PiI354+fapRo0YpW7Zs2rZtm5YtW6Z9+/apatWqlDexSEREhFq1aqXvvvuO8gYAAACAYShwAABArFW6dGnt379fI0aM0ODBg2NsWbNEiRKpb9++Onz4sFavXq2yZcvq/PnzMTI24qd79+7J09NTrq6uOn/+vHbt2qUNGzaoVKlSRkfDa/z888+KjIxU7969jY4CAAAAIAGjwAEAALFarly59Mcff2jTpk1q166dwsLCYnTsffv26ZtvvlH58uU1dOhQhYaGxtj4iPuuX7+uLl26KHfu3Hr27JlOnDihxYsXK1++fEZHwxt4eXlp7NixWrRokaytrY2OAwAAACABo8ABAACxXrp06bRv3z7dvXtXderUUWBgYIyNbWVlJQ8PD506dUrHjx9X0aJFdfz48RgbH3GTj4+P3N3dVbx4cTk6OurixYuaOnWqsmXLZnQ0vEVwcLDc3d31888/J9jrXwEAAACIPShwAABAnGBvb68NGzYoU6ZMKl++vO7evRuj42fOnFkbN25Uv379VKdOHX333Xd6/vx5jGZA7HfkyBHVrl1blStXVr58+XT16lWNHDlS6dKlMzoa3oOnp6fy5s0rd3d3o6MAAAAAAAUOAACIO2xsbDRr1izVrVtXpUuX1qVLl2J0fJPJpGbNmsnHx0f3799X/vz5tXv37hjNgNjHbDZr27ZtKl++vFq0aKEaNWro2rVr6tu3r1KkSGF0PLynnTt3avXq1Zo+fbpMJpPRcQAAAABANkYHAAAA+BAmk0kDBw5U5syZVb58ea1evVplypSJ0QxOTk5asmSJtm7dqrZt2+rrr7/W+PHjlTJlyhjNAWNFRERo9erVGj16tMLCwtS3b1+5ubnJxoa/Ysc1jx49Ups2bbRgwQKlSpXK6DgAAAAAIIkZOAAAII5q06aNFi5cqHr16mnNmjWGZKhevbp8fHxkZ2enfPnyGZYDMSskJESzZ89W7ty5NWnSJA0dOlTe3t5q0aIF5U0cZDab1alTJzVp0kRff/210XEAAAAAwIICBwAAxFlVq1bV9u3b9e233+rXX381JEPy5Mk1ZcoU/f777+rXr58aNmyoO3fuGJIF0SsgIEATJkyQq6ur1qxZo7lz5+rQoUOqVauWrKz4a3VctWjRIl26dEkjR440OgoAAAAAvIR/aQIAgDitSJEiOnz4sKZOnarevXsrMjLSkBxly5aVl5eX8uTJo4IFC2revHkym82GZEHUevjwoQYOHChXV1cdP35cmzZt0tatW1WuXDmulRLHXb9+XT/88IOWLFmiJEmSGB0HAAAAAF5CgQMAAOK8rFmz6vDhw/rjjz/UokULhYSEGJIjSZIkGj58uHbu3Klp06apSpUqunbtmiFZ8Olu376tnj176rPPPtPdu3d15MgR/f777ypcuLDR0RAFIiIi1LJlS/Xt21cFCxY0Og4AAAAAvIICBwAAxAupU6fWzp07FRoaqqpVq8rf39+wLAULFtTRo0dVpUoVlShRQj///LMiIiIMy4MPc/HiRbVt21YFCxaUjY2NfHx8NGvWLOXMmdPoaIhCY8aMUeLEidWrVy+jowAAAADAa1HgAACAeMPOzk4rVqxQwYIFVbZsWd2+fduwLDY2Nurdu7eOHj2qjRs3qnTp0jp79qxhefBuJ06cUMOGDVWuXDlly5ZNV65c0fjx4+Xs7Gx0NESxEydOaOLEiVq4cCHXLwIAAAAQa/GvFQAAEK9YW1tr4sSJatu2rUqXLq0zZ84YmidHjhzavXu32rdvr0qVKmnQoEGGLfGGV5nNZu3Zs0eVK1dWgwYNVK5cOV2/fl0//fSTUqVKZXQ8RIOgoCC5u7tr8uTJypw5s9FxAAAAAOCNKHAAAEC8YzKZ9N1332n8+PH6+uuvtXv3bkPzWFlZqUOHDvLy8pKXl5cKFy6sP/74w9BMCV1kZKTWrl2rkiVLqmvXrmrRooWuXLmiHj16KFmyZEbHQzTq3bu3ihUrpqZNmxodBQAAAADeysboAAAAANHFzc1N6dOnV5MmTTRhwgS5u7sbmidjxoxat26dVq5cqQYNGqhJkyYaMWKE7O3tDc2VkISFhWnZsmUaM2aMkiVLJk9PT9WrV49ltBKILVu2aPPmzfLy8jI6CgAAAAC8E/9SBQAA8Vr58uW1Z88e9e/fX6NHj5bZbDY0j8lkUpMmTeTj4yN/f3/lz59fO3bsMDRTQhAUFKTJkycrR44cWrx4sSZPnqzjx4+rQYMGlDcJxIMHD9S+fXstXLhQjo6ORscBAAAAgHcymY0+iwEAABADfH19VaNGDZUpU0a//vqrrK2tjY4kSdq+fbs6deqkChUq6Oeffzb8uisBAQEaMGCA/v77b+3fv18NGzbUF198obZt2xqa62M9efJEU6dO1a+//qoyZcqob9++KlGihNGxEMPMZrPq16+vXLlyacyYMUbHAQAAAID3wscNAQBAgpAxY0YdPHhQly9fVoMGDRQUFGR0JElS1apV5ePjoxQpUihv3rxauXKlobOETCaT5s6dqzVr1ujRo0eaM2dOnLxez507d9SnTx/lyJFDV65c0b59+7RmzRrKmwRq7ty5unnzpoYOHWp0FAAAAAB4bxQ4AAAgwXBwcNCWLVvk4OCgSpUq6cGDB0ZHkiTZ29tr0qRJWrNmjQYNGqT69evLz8/PsCx9+vSRra2tJClx4sQaNGiQIVk+xtWrV9WpUyflzZtXISEhOn36tBYsWKA8efIYHQ0G+euvv9S3b18tWbLE8roGAAAAgLiAAgcAACQoiRMn1qJFi1SpUiWVLl1aV69eNTqSRalSpXT69GkVKFBABQsW1OzZsw2ZjdOzZ0/LdWFatGihTJkyxXiGD+Xt7a1mzZrpiy++UNq0aXXp0iVNmjRJWbJkMToaDBQeHq6WLVtq4MCByps3r9FxAAAAAOCDcA0cAACQYE2fPl1Dhw7V+vXrY93SWmfOnFH79u1lb2+vWbNmKUeOHDE6voeHh2bOnKnbt2/H6gLn4MGDGj16tLy8vNSrVy917NhRDg4ORsdCLDFkyBAdOXJEW7dutZSSAAAAABBXUOAAAIAEbcOGDWrXrp3mz5+vWrVqGR3nJREREZo0aZJGjhypvn37qmfPnrKxsYmRsf39/bV48WJ9++23MTLehzCbzdqyZYtGjRqlu3fvqk+fPmrVqpWSJElidDTEIkePHlXdunV1+vRpOTs7Gx0HAAAAAD4YBQ4AAEjwjh07pnr16mnIkCHq2LGj0XFece3aNXXo0EFPnz7V3LlzVbBgQaMjGSI8PFwrV67U6NGjZTKZ1LdvXzVq1CjGSi3EHYGBgSpUqJDGjBmjhg0bGh0HAAAAAD4KBQ4AAID+udB59erV1axZMw0dOlQmk8noSC8xm82aP3+++vbtq44dO2rAgAEJZsbJixcvtGDBAo0bN04ZM2aUp6enqlWrFuv+HyH26NChg8LDwzV//nyjowAAAADAR2MhaAAAAEk5c+bUkSNHtH37drVp00ZhYWFGR3qJyWRS27Zt5e3trQsXLqhw4cI6fPiw0bGi1bNnzzR27Fi5urpq8+bNWrRokQ4cOKDq1atT3uCN1q9fr927d2vSpElGRwEAAACAT0KBAwAA8H/Spk2rvXv36tGjR6pZs6aePXtmdKRXZMiQQatXr9bw4cPVuHFjffvttwoICJD0zzVzTp48aXDCT3f//n31799frq6u8vb21rZt27Rx40aVKVPG6GiI5e7evatOnTpp8eLFcnBwMDoOAAAAAHwSChwAAID/SJYsmdauXStXV1eVL19efn5+Rkd6rYYNG+rcuXMKCgpSvnz5tHXrVk2YMEHFixeXt7e30fE+ys2bN/Xtt98qd+7cevz4sY4fP66lS5eqQIECRkdDHGA2m9W2bVu1b9+esg8AAABAvMA1cAAAAF7DbDZr1KhRmjVrlrZs2aLPP//c6EhvtGvXLrVp00Z37txRRESEChcurJMnT8aZZcbOnz+v0aNHa/PmzerQoYN69uyp9OnTGx0Lccz06dM1b948HTlyRIkSJTI6DgAAAAB8MgocAACAt1i0aJF69+6tVatW6csvvzQ6zmuZzWaVKFFCJ0+elNlslq2trebMmSN3d3ejo71k0aJFSp48uerXry9JOnbsmEaNGqWjR4+qe/fu6tKlixwdHY0NCQAAAABALMESagAAAG/RqlUrLVmyRA0bNtTKlSuNjvNaFy5c0MmTJ5U0aVLZ29srNDRUbdu2tVwb579MJpOSJUum/v37R8nY2bNnV+LEid9ZFh0+fFgdO3ZUp06dtG3bNlWqVElubm6qXLmyrl27pn79+lHeJGBR/bps3bq17OzslClTpig5HgAAAAAYgQIHAADgHSpXrqwdO3aoV69e+uWXX4yO84rPP/9cAQEBOnnypNatW6dZs2apUaNGb1xCzdvbWyNGjLDc7tixo3LlyiUrKystWLDgpX0XLFgga2tr2dvbW7727dtn2X716lX169fvrfnu3r2r2rVrKyQkRI8ePVK7du3Upk0b/fXXX+ratauSJk360c8d8ceHvC7NZrMGDBigjBkzKkWKFKpQoYLOnTtn2b5gwQJt3bo1pqIDAAAAQLSgwAEAAHgPhQoV0pEjRzR79mz9+OOPim2r0CZLlky5cuXSV199pfbt22vZsmWyt7d/r8cWLFhQ06ZNU5EiRV67vVSpUgoMDLR8VahQ4b1zhYSE6IsvvtCTJ08kSZGRkUqUKJFatGjBdUrwVm97Xa5cuVLz5s3TwYMH9fjxY5UqVUotW7Y0ICUAAAAARB8bowMAAADEFVmyZNHhw4e1bt06hYaGytbW1uhIUaJr166SpCRJkkT5sU+ePKknT54oTZo0sra2VlhYmEJCQnT//n2lT58+ysdD/PG21+X169dVtmxZubq6SpLc3d1j5ew4AAAAAPgUzMABAAD4AClTplTr1q3jTXnzPk6fPi0nJyd99tlnGjZsmMLDw9/7saVLl9azZ890//593blzRw8fPtSdO3cob/BJmjZtqqtXr+ry5csKCwvTwoULVa1aNaNjAQAAAECUYgYOAADAB3rTtWX+ZTab37lPXFGuXDn5+PjIxcVF586dk5ubm2xsbOTp6Wl0NCRgGTJkUNmyZZUrVy5ZW1src+bM2rNnj9GxAAAAACBKMQMHAAAgCpw7d07Pnz+XJO3bt08LFixQUFCQwak+naurq7JlyyYrKyvlz59fAwcO1KpVq4yOhQRu6NCh+vPPP3X79m29ePFCgwYNUqVKleLFzxwAAAAA/IsCBwAA4BP4+/urd+/e6t69uwoXLqxp06bp4MGDOnfunAIDA42OF+VMJpPMZrPRMZDAeXl5yc3NTZkyZZKNjY1at26tJ0+e6Pz580ZHAwD8v/buPCyqunH/+D2gIgo6uG+4oOmjlltqJq5pJO6k4oJrLlkumT5pLqmpYXpplpl77pC5b4h7pmVqj0puRWm4JEqigoyswvn90a/5Ru4KzADv13XNdTmccz6f+5yZ/qCbzzkAACDNUOAAAAA8pZSUFM2bN0/R0dFas2aNjh49qi1btigyMlItWrRQkSJFrPsmJyfbMOnDJSYmKj4+XoZhKCkpSfHx8UpJSZEkBQcHKyIiQpL0yy+/aPLkyWrXrp0t4yKbeNj3sk6dOlq7dq0iIiKUkpKilStXKikpSRUqVLBxagAAAABIOxQ4AAAAT+n69eu6cuWKfH19VbBgQaWkpCg8PFylSpVScnKyPv74Y61du1aS5OjoaOO0D+bl5SVnZ2cdOnRIAwYMkLOzsw4cOCBJ2rt3r6pVq6a8efOqZcuWev311zVmzBgbJ0Z28LDv5ahRo1S9enXVqFFDZrNZs2bN0vr162U2m20bGgAAAADSkMngHhgAAABP5dy5c+rYsaNCQkIkSV9//bV+/vlnnT9/Xjdv3tT48eM1ffp0GYahwMBA5c6d23psSkqKHBwy/m9pcufOLScnJw0dOlSTJ09+5vEqVapkLbGWLFmSBgmRHaX197Jv375au3atihQponPnzqVBQgAAAADIeDlsHQAAACCzcnJyUqFChbRu3TqVKlVKy5cvV/369bV9+3YVKFBA3377rZYsWaJZs2bpzz//VOnSpa3HOjg42KTEiY+PT9PxQkND03Q8ZE9p/b388ssv9eWXX6bpmAAAAACQ0ViBAwAA8AyOHTumadOmKTIyUoUKFZKrq6tiY2P11VdfadiwYTpw4IB++eUX/fbbb4qIiNCBAwd06dIlDR06VGXLlrV1fAAAAAAAYKcocAAAANLAb7/9phMnTqhw4cLaunWrPvnkE0nS5cuXFRYWplKlSql169bq16+fLBaLVqxYodmzZ6tly5Y2Tg4AAAAAAOwRBQ4AAEAaioyMVJcuXZQvXz6NHDlSVapUUb58+VShQgWlpKTo999/lyRdv35d0dHRqlChgiTp4MGD6tevX5rdkmz//v3q3r27/vjjjzQZ737mzZuniRMn6s6dO7p48aIKFiyYbnMBAAAAAJDdZPyTcwEAALKwQoUKac+ePXrllVc0Y8YM/fTTT7p8+bJSUlJUtGhRGYahhIQEFSlSRMnJydbjGjZsmKq8KVu2rPbs2WOLU3gsSUlJGj58uHbt2iWLxfLQ8sZkMtn0QfK2nh+P78KFCzKZTLp79266jD9p0iSZTKZU/21duXJF7dq1U4ECBVSqVCnNnz//gccHBQWpQYMGMpvNKlasmPr166eYmBjr9ps3b6pz584qWLCgChUqJD8/P92+fVuS9Oeff6pr164qUaKE8ufPL09PTx05csR6rL+/v1xcXKwvZ2dnOTg4KDIyMh2uBAAAAIDMgAIHAAAgHQwePFjr1q3Tyy+/LHd3d7m7u+vOnTsymUxycnKSJDk6Oto45dOLiIhQfHy8qlatmq7zGIahlJSUdJ0DD5bZrv/Dip/z589r7dq1Kl68eKqfd+/eXeXKlVNERISCgoI0ZswYffPNN/cdIzo6WuPGjVN4eLh+/vlnXblyRe+99551+7hx43Tr1i2FhYXp/PnzioiI0MSJEyVJFotFderU0bFjx3Tz5k316tVLrVq1ksVikSSNGTNGFovF+ho1apSaNGmiQoUKPeNVAQAAAJBZUeAAAACkoY8//ljly5eXq6urqlSpoi1btkiSSpYsqfPnz2vChAmqX7++JKl69epycXHR119/rf3796tUqVKSpB49eujSpUtq06aNXFxcNH369FTb//bPVTpxcXHq3bu33NzcVKVKFf3444+p9g0PD1eHDh1UuHBhlStXTrNnz37kuSQkJGjYsGEqUaKESpQooWHDhikhIUG//vqrKlWqJEkym8165ZVXHjhGo0aN7jnXW7duqXXr1ipcuLDc3NzUunXrVLd6a9KkicaOHStPT0/lyZNHv//+u3bt2qVKlSopf/78evvtt9W4cWMtXrzYesySJUtUuXJlubm56bXXXtPFixcfOH92ULZsWU2dOlVVqlSRm5ub+vTpo/j4eEl6quu/dOlSVa5cWa6urvLw8NCCBQus+//93Zw+fbqKFCmi4sWLa9OmTdq+fbsqVqyoAgUKyN/f37p/SkqK9b+TggULytfXVzdv3pT0f5+X2WyWi4uLfvjhB0kP/nylv1ZYffHFF3ruuef03HPPPfCaDBo0SNOmTVOuXLmsP7NYLNq/f7/Gjh2rnDlzqnr16urYsaOWLFly3zG6deumFi1aKE+ePHJzc1P//v31/fffW7eHhYWpffv2ypcvn/Lnzy8fHx+dOXNGkuTh4aHhw4erePHicnR01IABA5SYmHjf2yYahqEVK1aoV69eDzwfAAAAAFkfBQ4AAEAaKl++vA4ePKjo6GhNmDBBPXr00NWrV+Xl5aUqVarI1dVVX331lSTpp59+ksViUefOnVONsXLlSpUuXVpbt26VxWLRyJEjHznvhx9+qPPnz+v8+fPauXOnli9fbt2WkpKiNm3aqHr16rpy5Yr27t2rTz/9VDt37nzoXrFWNAAALYlJREFUmB999JEOHz6skJAQ/fTTTzp69KimTJmiihUrWv+ndFRUlPbt2/fAMQ4cOHDPuaakpKhPnz66ePGiLl26JGdnZw0ePPiea7Bw4ULFxMQof/786tixo6ZOnaobN26oUqVKOnTokHXfzZs3y9/fXxs2bND169fVsGFDde3a9YHzZ1Vvv/223n77bev7gIAA7dy5U+fPn9evv/6qKVOmSNITX/8yZcqoSJEi2rZtm27fvq2lS5fq3Xff1fHjx637X7t2TfHx8bpy5YomTZqk/v37a9WqVTp27JgOHjyoyZMnKywsTJL0+eefa9OmTfr2228VHh4uNzc3DRo0SNL/fV5RUVGyWCx6+eWXH/r5/m3Tpk06cuSIzp49K+mvAui7776zbl+7dq2cnJzUsmXLVMf9/TjQfz4W1DAMnT59+rGu+YEDB1KtQhs0aJC2bdumW7du6datW1q/fr28vb3ve2xISIgSExOtz8H6p4MHD+rPP/9Uhw4dHisHAAAAgCzKAAAAQLqpXr26sWnTJmPp0qWGp6en9eeSjN9++82IjY01LBaL8c033xglS5a0bi9Tpoyxe/du6/t/b//3PuXKlTOCg4Ot2xYsWGDd//Dhw4a7u3uqY/39/Y3evXs/NLuHh4cRFBRkfb9jxw6jTJkyhmEYRlhYmCHJSEpKeuQ1+PtcH+TEiROG2Wy2vm/cuLHxwQcfWN8vX77cqFevnvV9SkqKUapUKWPRokWGYRhGixYtjMWLF1u3JycnG87OzsaFCxcea/6sqEyZMsa8efOs74OCggwPD4/77vuo638/7dq1Mz799FPDMP76bubOndu4e/euYRiGcfv2bUOScfjwYev+tWrVMjZu3GgYhmH85z//Mfbs2WPdFh4ebuTIkcNISkq67/fqcT7fvXv3PjDr7du3jQoVKhhhYWHWa/PP/7Y8PT2NwYMHG3FxccaxY8cMNzc3o2LFig89f8MwjF27dhlms9kIDQ21/uzKlStGs2bNDJPJZJhMJqN58+ZGQkLCPcdGR0cbzz//vOHv73/fsd944w2jV69ej8wAAAAAIGtjBQ4AAEAaWrFihWrUqCGz2Syz2azTp08/9CHkN2/eVP369XX9+vVnmjc8PFzu7u7W92XKlLH+++LFiwoPD7dmMpvN8vf3V0RExCPH/Oc4ZcqUUXh4+DPllKTY2Fi9+eabKlOmjPLly6dGjRopKipKycnJ1n3+eS7/PjeTyZTqdnIXL17UO++8Yz23AgUKyDAMXbly5ZmzZmb//j78/dk96fWXpODgYNWrV08FChSQ2WzW9u3bU32vCxYsaH2mk7OzsySpaNGi1u3Ozs7WZ71cvHhRPj4+1s+rcuXKcnR0fOD38XE+33/n/aeJEyeqR48eKlu27H23BwQEKCwsTO7u7nrrrbfUvXv3e25X+G+HDx9Wt27dtG7dOlWsWNH6c19fX1WsWFExMTG6ffu2ypcvr+7du6c6Ni4uTm3atFG9evU0evToe8aOjY3V2rVruX0aAAAAAG6hBgAAkFYuXryo/v37a86cObpx44aioqL0/PPPp7o907+VKFFC3bp10+DBg5WUlGT9uclkSrVf3rx5FRsba32fnJycqvQpXry4Ll++bH1/6dIl67/d3d1Vrlw5RUVFWV8xMTHavn37Q8+nRIkSqZ41cunSJZUoUeKhxzyOmTNnKjQ0VEeOHNHt27ett83653X65/kXL1481TNaDMNI9d7d3V0LFixIdX5xcXHWZw1lV//+Pvz92T3p9U9ISFCHDh303//+VxEREYqKilLLli0f+r1+GHd3dwUHB6f6vOLj41WyZMl7vvd/7/+oz/d+x/1t7969mj17tooVK6ZixYrp8uXL8vX11bRp0yT9VW5t27ZN169f15EjRxQZGam6des+cLwTJ06obdu2WrJkiZo1a5ZqW0hIiN58803lzZtXLi4uGjhwYKr/zhISEtS+fXuVKlUq1XOE/mnjxo0qUKCAmjRp8sAMAAAAALIHChwAAIA0cufOHZlMJhUuXFiStHTp0gc+S6No0aL6/fffZTKZNGrUKPXr10+RkZHav39/qu1/q1ixouLj4xUUFKSkpCRNmTJFCQkJ1u2+vr6aOnWqbt26pT/++EOff/65dVvdunXl6uqqadOmKS4uTsnJyTp9+rR+/PHHh55P165dNWXKFF2/fl2RkZGaNGnSPasJHse/zyUmJkbOzs4ym826efOmPvzww4ce36pVK506dUqbNm3S3bt39cUXX+jatWvW7QMHDtTUqVOtz+WJjo7W2rVrHzh/dvHFF1/ojz/+0M2bN/XRRx9Zn//zpNc/MTFRCQkJKly4sHLkyKHg4GDt2rXrqXMNHDhQY8eOtZaD169f1+bNmyVJhQsXloODQ6rP61Gf76Ps3btXp0+fVkhIiEJCQlSiRAktWLDA+tydn3/+WTExMUpMTNSqVau0a9cuDR8+/L5jnT59Wi1atNDnn3+uNm3a3LO9Tp06Wrx4seLi4hQXF6eFCxeqWrVqkqSkpCR17NhRzs7OWr58uRwc7v+r2PLly9WzZ8+HllIAAAAAsgcKHAAAgDRSpUoVjRgxQi+//LKKFi2qU6dOydPT8777Tpw4Ub169ZLZbNaaNWv06quvqkCBAvL19dXq1as1evRoTZkyRWazWTNmzFD+/Pk1d+5c9evXTyVLllTevHlT3eZpwoQJKlOmjMqVKycvLy/16NHDus3R0VHbtm1TSEiIypUrp0KFCqlfv36Kjo5+6PmMGzdOtWvXVrVq1fTCCy+oVq1aGjdu3BNfl3+f67BhwxQXF6dChQqpXr16atGixUOPL1SokNauXauRI0eqYMGCOnv2rGrXri0nJydJko+Pj0aNGqUuXbooX758ev755xUcHPzA+bOqgQMHauDAgdb33bp1k5eXlzw8PFS+fHnrZ/ek19/V1VWzZ8+Wr6+v3NzcFBgYqLZt2z51znfeeUdt27aVl5eXXF1dVa9ePR05ckSSlCdPHo0dO1aenp4ym806fPjwIz/f+3FxcdHBgwcl/XV7t79X3xQrVkyOjo5yc3OTi4uLJGnnzp3y8PCQm5ub5s+frx07dlhL2H+PNXPmTF2/fl19+/aVi4uLXFxcVLVqVeu+S5Ys0YULF1SqVCmVLFlSv//+u5YvXy5JOnTokLZt26Zdu3bJbDZbj/97bEm6cuWK9u3bp549ez719QUAAACQdZiMp733AQAAANLcyZMn1apVK73zzjsaMWIEf4V/HykpKSpVqpQCAgLUtGlTW8exS2XLltXixYvVvHlzW0d5KMMw+I4DAAAAwAOwAgcAAMCOVKtWTYcOHdKyZcv0zjvvpHqwfHa2c+dORUVFKSEhQf7+/jIMQ/Xq1bN1LDyjlStXymKx2DoGAAAAANglChwAAAA74+7uru+++06nTp2Sr6+v4uLi0m0ub29v662c/vny9/d/7DE2b94sZ2fn+46TVn744QeVL19ehQoV0tatW7Vp0yY5Ozun2fjIeGFhYRoxYoTOnz+vNWvW6Ndff7V1JAAAAACwK9xCDQAAwE4lJCSod+/eunTpkrZs2aKCBQvaOtJ9Xb16VdWrV9eOHTtUq1YtW8dBJpCcnKzGjRurffv2aty4sVq1aqXjx4+neq4TAAAAAGR3rMABAACwU05OTgoICFCDBg3k6empsLAwW0e6r+LFi2v27Nnq2rWr7ty5Y+s4yASmT5+uXLlyqV+/furatavmzZtHeQMAAAAA/8IKHAAAgExgzpw5mjp1qrZs2aIXX3zR1nHuq1evXsqVK5cWLVpk6yiwY8eOHZO3t7f+97//afTo0XJ1ddX8+fNtHQsAAAAA7A4FDgAAQCaxceNGDRgwQCtWrJC3t7et49wjJiZGNWrU0PTp09WhQwdbx4Edio2NVa1atTRhwgQlJiZq+vTp+vHHH5UnTx5bRwMAAAAAu0OBAwAAkIkcOnRIr7/+uvz9/fXGG2/YOs49jhw5orZt2+rYsWPcEgv3GDRokKKiojRhwgR5enpq3759euGFF2wdCwAAAADsEgUOAABAJhMaGipvb2/16tVL48ePl8lksnWkVKZMmaJ9+/Zp9+7dcnR0tHUc2Int27frrbfe0tGjR+Xt7a3+/fvrrbfesnUsAAAAALBbFDgAAACZ0LVr19S6dWtVr15d8+fPV86cOW0dySo5OVlNmzZVq1atNGrUKFvHgR24fv26qlevrsDAQG3ZskVhYWHasGGD3ZWPAAAAAGBPKHAAAAAyKYvFIl9fXxmGobVr18rFxcXWkawuXbqk2rVra/v27apdu7at48CGDMOQj4+PKlasqCZNmmjgwIEKCQlRgQIFbB0NAAAAAOyag60DAAAA4Om4uLho8+bNKlmypBo3bqxr167ZOpJV6dKlNWfOHHXr1k0Wi8XWcWBDX375pS5cuKC3335bffv21apVqyhvAAAAAOAxsAIHAAAgkzMMQ5MnT9ayZcsUHBysSpUq2TqSVZ8+feTo6KjFixfbOgps4Ny5c3r55Ze1b98+DR8+XJ6enpo4caKtYwEAAABApkCBAwAAkEUsXbpUo0eP1oYNG1S/fn1bx5EkxcTEqFatWvr444/VoUMHW8dBBrp7964aNGigrl27Kj4+XkFBQdq3b59y5Mhh62gAAAAAkCnw2xMAAEAW0adPHxUvXlzt2rXTwoUL5ePjY+tIcnV1VUBAgNq0aaO6devK3d3d1pGQQT766CPly5dPdevWVfv27fXjjz9S3gAAAADAE2AFDgAAQBZz/PhxtWnTRqNHj9bgwYNtHUeS5O/vr927d2vPnj1ydHS0dRyksyNHjqht27b69ttv1bJlS82cOdMuCkUAAAAAyEwocAAAALKgsLAweXt7q23btvr444/l4OBg0zzJyclq1qyZWrRooffff9+mWZC+LBaLatasKX9/f23YsEFubm6aO3eurWMBAAAAQKZDgQMAAJBF3bhxQ23btlWZMmW0dOlSOTk52TTP5cuX9eKLLyooKEh16tSxaRaknwEDBigxMVGNGzfWJ598oqNHj8rZ2dnWsQAAAAAg07Htn2ICAAAg3RQsWFB79uxRQkKCWrRooaioKJvmcXd31xdffKFu3brJYrHYNAvSx5YtW7Rnzx4NGTJEI0eO1OrVqylvAAAAAOApsQIHAAAgi0tOTtbw4cO1d+9eBQcHy93d3aZ53njjDUnSkiVLbJoDaevatWuqWbOmAgICNGLECA0cOFBvvvmmrWMBAAAAQKZFgQMAAJANGIahTz75RJ9++qmCgoJUrVo1m2X55zNSOnXqZLMcSDuGYah169aqUaOG7ty5oz/++ENr166VyWSydTQAAAAAyLRy2DoAAAAA0p/JZNKIESNUsmRJNW/eXKtXr9Yrr7xikywuLi4KDAxUq1at9NJLL6l06dI2yYG0M3/+fEVERKh27doaNmyYQkJCKG8AAAAA4BmxAgcAACCb2b9/v3x9fTVr1iz5+fnZLMfUqVO1Y8cO7du3T46OjjbLgWcTGhoqT09PbdiwQb6+vlq3bp0aNGhg61gAAAAAkOlR4AAAAGRDZ86cUcuWLfXWW29p1KhRNlktkZycrGbNmsnLy0tjxozJ8Pnx7JKSkvTyyy+rT58+Wr9+vZo2baoPPvjA1rEAAAAAIEtwsHUAAAAAZLyqVavq0KFD+uqrrzR48GAlJydneAZHR0etXLlSn332mY4ePZrh8+PZffjhhypatKiioqKUnJxMEQcAAAAAaYgVOAAAANlYdHS0OnToYH0uTZ48eTI8w7p16/T+++/rxIkTcnV1zfD58XS+//57dejQQYsXL1bfvn117NgxlSpVytaxAAAAACDLYAUOAABANpY/f35t375drq6uatasmSIjIzM8Q8eOHdWkSRMNHTo0w+fG07l9+7Z69OihmTNnasiQIVq4cCHlDQAAAACkMVbgAAAAQIZhaOzYsVq3bp2Cg4NVvnz5DJ3fYrGoVq1amjJlinx9fTN0bjy5Pn36yNHRUTExMSpcuLDmzJlj60gAAAAAkOWwAgcAAAAymUzy9/fXu+++q4YNG+rHH3/M0Pn/voXb4MGDdenSpQydG09m3bp1OnjwoGrWrKmff/5ZM2bMsHUkAAAAAMiSWIEDAACAVLZs2aK+fftq2bJlatWqVYbOPW3aNAUFBembb76Ro6Njhs6NRwsPD1fNmjX12WefaciQIfr2229VpUoVW8cCAAAAgCyJAgcAAAD3OHz4sHx8fDRp0iT1798/w+ZNSUlR8+bN1axZM40dOzbD5sWjpaSkqEWLFqpbt662bt2qwYMHZ+h3AwAAAACymxy2DgAAAAD7U69ePR04cEDe3t66fPmyPvzwQ5lMpnSf18HBQStWrNCLL76o5s2b66WXXkr3OfF45syZo9u3bysqKkqVKlVSv379bB0JAAAAALI0VuAAAADggf7880+1bt1aVapU0aJFi5QzZ84MmXfDhg0aOXKkTpw4IVdX1wyZEw925swZNW7cWFOmTNG0adN04sQJmc1mW8cCAAAAgCyNAgcAAAAPdefOHXXp0kWJiYlat25dhhUq/fv3V2JiopYvX54h8+H+EhIS9NJLL8nPz08zZ87Uhg0bVL9+fVvHAgAAAIAsz8HWAQAAAGDf8ubNq40bN6pcuXJq1KiRrl69miHzfvrppzp8+LBWr16dIfPh/saPH68yZcooKChIQ4YMobwBAAAAgAxCgQMAAIBHypEjh+bNm6dOnTqpfv36+vnnn9N9zrx58yowMFBDhw7VxYsX030+3OvChQtauXKlqlSpIpPJpPfff9/WkQAAAAAg2+AWagAAAHgiK1as0Hvvvad169apYcOG6T7f9OnTtXv3bu3atUsmkynd58P/iYuL0549e9S/f38dO3ZMJUuWtHUkAAAAAMg2KHAAAADwxHbv3i0/Pz/NnTtXHTt2TNe5UlJSdOzYMdWoUUM5c+ZM17lwr9jYWP3vf/9To0aNbB0FAAAAALIVChwAAAA8lZCQELVu3Vr//e9/NWzYsHSdKyUlRQ4O3P0XAAAAAJB9UOAAAADgqV26dEktWrRQixYtNGPGDJuULJQ7acswDG5VBwAAAAB2gN90AQAA8NRKly6t77//XseOHVPXrl0VHx+fIfOmpKTo66+/liQ5ODgoOTk5Q+bNyv6+hiaTSSkpKTZOAwAAAACgwAEAAMAzcXNz086dOyVJr732mm7dupXuc966dUubN29W9+7dJUmOjo7pPmdWZhiGdu/erYULFyopKUmTJ09WZGSkrWMBAAAAQLZGgQMAAIBnljt3bn311VeqXbu2PD09dfHixXSZ59KlS1q8eLFWr16twMBAlS1bVpMnT5YkXbx4US1btpTFYkmXubMyk8mkhg0basaMGSpTpowqVKigQoUK2ToWAAAAAGRrFDgAAABIEw4ODpo5c6YGDBggT09PhYSEpOn40dHRmjx5snbs2KFTp06pXbt2slgsypUrlwzDkJ+fnypUqCAXFxfdvXs3TefOqv6+VZphGIqPj1fp0qXl7OysihUrSpISExNtGQ8AAAAAsjUKHAAAAKSpYcOGadasWfLy8tLu3bvTbNzLly/rzJkzWrNmjebPn68iRYpo+/bt6tSpk/z8/PTCCy/os88+U3JyspYtW6YbN26k2dxZUXJyshwc/vp14PLly3Jzc9OePXs0a9Ys9evXT6dPn1auXLl4vhAAAAAA2AgFDgAAANJcp06dtH79enXv3l0rVqxIkzE9PDzk6uqqUaNGadGiRQoJCdGsWbM0ffp0Xb16VZ988okmTJigGjVqKDQ0VAULFpRhGGkyd1aTnJwsR0dHGYah9u3ba/To0apdu7bOnDmjtm3bqkuXLurbt6/OnTunIUOG6NSpU7aODAAAAADZDgUOAAAA0kXDhg21f/9+TZgwQf7+/s9cpuTJk0c7d+6Um5ubJkyYID8/Px0/flxHjx7VqlWr5OzsrGvXrik8PNw6l8lkSotTyTLOnj2rsLAwOTo66vbt22rZsqXq1KmjgIAA3bp1S7169dKFCxc0evRo1a9fX506dZKHh4deeOEFW0cHAAAAgGzHZPBniQAAAEhHV69eVatWrVS3bl3NmTNHOXLkeOYxT58+rZ07d2rmzJnaunWrXnzxRc2YMUMbN27Uxo0bNXv2bHl5ealRo0ZpcAZZx/Hjx9W0aVNFRkYqZ86c+v7771W5cmV17txZXl5eOn/+vEJCQrRv3z7lyZNH4eHhKlGihK1jAwAAAEC2RIEDAACAdBcTE6OOHTsqV65cWr16tfLmzfvMY27evFkJCQny9fXVunXrNGnSJH355ZeqU6dOGiTOulauXKmFCxfq4MGDkqSAgAAFBQUpMDBQFy5c0HPPPacpU6Zo1KhRNk4KAAAAANkbBQ4AAAAyRFJSkgYMGKCzZ89q69atKlKkSJqMGxMToyZNmmjatGlq3ry5EhMTlStXrjQZO6saMmSI7ty5oyVLlmj37t1asGCBBg0apE2bNqlAgQJ67733lCdPHlvHBAAAAIBsjWfgAAAAIEPkzJlTS5Ys0Wuvvab69evr3LlzaTKug4ODihYtqsOHD0sS5c1jmD17ts6fP6/PP/9cTZs2VZ06dTRhwgTFxsZqwoQJlDcAAAAAYAdYgQMAAIAMt2jRIo0fP16bNm3SSy+99Mzj3b17V59++qm6d++uYsWKpUHCrC8hIUGVK1fW/Pnz5eXlpcjISBUqVMjWsQAAAAAA/x8FDgAAAGwiKChIffr00eLFi9W2bds0HTs5OVmOjo5pOmZWEBoaKnd3d+sKm2vXrqlmzZo6f/68cufOLQcHFugDAAAAgL3gNzQAAADYRKtWrRQUFKSBAwdq/vz5aTZuSkqKfv31V0VHR6fZmFlBbGys2rdvr3nz5ik+Pl6SVKxYMYWFhSlPnjyUNwAAAABgZ1iBAwAAAJs6f/68vL291bFjR3300UcymUzPPObIkSN15coVBQQEpEHCrGHw4MH66aefFB4errNnz8rJycnWkQAAAAAAD8Gf2QEAAMCmypcvr0OHDumbb75Rr169lJiY+MxjTpw4USdOnNCqVavSIGHmFxwcrA0bNig0NFSBgYGUNwAAAACQCbACBwAAAHYhNjZW3bp1k8Vi0fr165U/f/5nGi8kJESvvvqqjhw5Ig8PjzRKmflcv35d1atXV6FCheTn56dRo0bZOhIAAAAA4DFQ4AAAAMBuJCcna+jQofruu++0fft2lSxZ8pnG++STT7Ru3TodOHBAOXLkSKOUmYdhGHr99dcVERGhvHnzaufOnTzrBgAAAAAyCX57AwAAgN1wdHTUnDlz1K1bN9WvX19nzpx5pvGGDRsmV1dXTZ48OY0SZi5LlizRyZMnFRYWphUrVlDeAAAAAEAmwgocAAAA2KWAgAANHz5ca9asUePGjZ96nKtXr6pWrVpau3atGjRokIYJ7du5c+dUt25dOTk5acmSJfL29rZ1JAAAAADAE6DAAQAAgN3at2+funTpos8//1ydO3d+6nG2bdumIUOG6MSJEzKbzWkX0E7dvXtXDRo00J07d+Tl5aWZM2faOhIAAAAA4AlR4AAAAMCunTx5Uq1bt9Y777yj4cOHy2QyPdU4gwYN0s2bNxUYGPjUY2QWkyZNUmBgoPLmzatDhw7JycnJ1pEAAAAAAE+IAgcAAAB27/Lly/L29lbz5s01c+ZMOTo6PvEYcXFxql27tkaNGqWePXumQ0r7cOTIEbVs2VKS9MMPP6hixYo2TgQAAAAAeBoUOAAAAMgUoqKi5OPjo4IFC2rlypVydnZ+4jFOnjypZs2a6fDhwypfvnw6pLQti8Wi6tWrKyEhQf7+/lm6qAIAAACArM7B1gEAAACAx2E2m7Vjxw7lzJlTr776qm7cuPHEY1SrVk1jx46Vn5+fkpKS0iGlbY0YMUKOjo5q0qSJevToYes4AAAAAIBnQIEDAACATMPJyUkBAQHy9PSUp6enwsLCnniMoUOHymw2a9KkSemQ0Ha2bNmijRs36u7du5o7d26Wf84PAAAAAGR13EINAAAAmdKcOXM0depUbd26VbVq1XqiY69du6aaNWtqzZo1atiwYTolzDgRERF64YUXlJSUpF27dqlOnTq2jgQAAAAAeEaswAEAAECmNHjwYM2ZM0ctWrTQjh07nujYYsWKadGiRerevbuioqLSJ2AGMQxDffr0Ua5cuTRmzBjKGwAAAADIIihwAAAAkGn5+Pho06ZN6t27t5YuXfpEx7Zu3Vpt2rTRwIEDlZkXpS9YsEAnTpxQ5cqVNWLECFvHAQAAAACkEW6hBgAAgEwvNDRU3t7e6t27tz744IPHfv5LXFyc6tSpo/fee0+9evVK55RpLzQ0VHXr1pWTk5NOnjypYsWK2ToSAAAAACCNUOAAAAAgS7h27Zpat26tmjVrat68ecqRI8djHXfy5Ek1a9ZMP/zwgypUqJDOKdNOUlKS6tSpo4sXL2r16tV67bXXbB0JAAAAAJCGuIUaAAAAsoRixYpp//79unLlitq1ayeLxfJYx1WrVk3jxo2Tn5+fkpKS0jll2vnwww919epV9e3bl/IGAAAAALIgVuAAAAAgS0lKStJbb72lkJAQBQUFqWjRoo88xjAMtWzZUi+++KKmTJmSASmfzffffy9vb295eHjo6NGjypUrl60jAQAAAADSGAUOAAAAshzDMDR58mQtX75cwcHBqlix4iOPiYiIUI0aNfT111+rUaNGGZDy6dy+fVuVK1eWxWLRsWPHMtVt3wAAAAAAj49bqAEAACDLMZlMGj9+vMaNG6dGjRrp0KFDjzymaNGiWrx4sXr06KFbt25lQMqn8/bbb+vOnTv64osvKG8AAAAAIAtjBQ4AAACytB07dqhnz55asGCBfHx8Hrn/kCFD9Oeff2r16tUymUwZkPDxrV+/Xn369FHr1q0VGBho6zgAAAAAgHREgQMAAIAs7/jx42rTpo3GjBmjQYMGPXTfuLg41a1bV8OHD1efPn0yKOGjhYeHq3LlysqXL5/Onj0rV1dXW0cCAAAAAKQjChwAAABkC2FhYfL29la7du00depUOTg8+G7Cp06dUtOmTfXDDz/oueeey8CU95eSkqLGjRvr+PHjOnDggF588UVbRwIAAAAApDOegQMAAIBsoVy5cvr+++/13XffqUePHkpISHjgvi+88ILGjx8vPz8/JSUlZWDK+5s9e7ZOnDihCRMmUN4AAAAAQDbBChwAAABkK3Fxcerevbtu3bqlDRs2yGw233c/wzDUqlUr1ahRQ/7+/hkb8h/OnDmjOnXqqHbt2tq/f/9DVw4BAAAAALIOChwAAABkO8nJyRo+fLj27dun7du3y93d/b77RUREqEaNGvrqq6/UpEmTjA0pKSEhQVWrVlVkZKRCQ0NVtGjRDM8AAAAAALAN/nwPAAAA2Y6jo6M+/fRT9e7dW56enjp16tR99ytatKi+/PJL9ezZUzdv3szglNJ///tfXblyRV9//TXlDQAAAABkMxQ4AAAAyJZMJpNGjBih6dOnq3nz5tq3b99992vZsqV8fHz05ptv6vjx42ratKlu3LiRbrneeustlS1bVgEBAVq0aJH69eun1157Ld3mAwAAAADYJ26hBgAAgGxv//796ty5s2bNmqVu3brdsz02NlYeHh66efOmTCaTgoOD9corr6RLltKlS+vy5cuSpMKFC+uPP/5Qrly50mUuAAAAAID9YgUOAAAAsr0mTZpo3759Gj16tKZNm6Z//o1TUlKSvLy8FB0draSkJJlMJv3888/pliUiIsL67+vXr6tdu3bpNhcAAAAAwH5R4AAAAACSqlatqkOHDikwMFBDhgxRcnKyrl69qiVLlqh06dIymUwymUxKSEjQ8ePH0yVDTEyMEhMTre9NJpPu3r2bLnMBAAAAAOwbt1ADAAAA/uH27dt6/fXXlTt3bv3yyy8KCwvThQsXZLFY9O6772rnzp0qXry4wsPD03zuvXv3qnnz5pL+KpRWrFihWrVqpfk8AAAAAAD7xwocAAAA4B/y5cunTZs26ciRI/r999+VI0cOzZ8/X5UrV9aOHTu0c+dO+fj4pMvc//nPf+Tu7q6dO3fq9OnTlDcAAAAAkI2xAgcAAAD4l/79+2vp0qVKTk6WJOXPn1+RkZHKkSOHjZMBAAAAALILVuAAAAAA/+Lj46OWLVvK1dVVTk5Oio6O1vz5820dCwAAAACQjbACBwAAAHiAlJQUnTp1SnPnzlXTpk3VpUsXW0cCAAAAAGQTFDgAAADAEzKZTMqTJ4+GDRumjz766JnHe+WVV3To0CHVrl1b3333XRokBAAAAABkdtxCDQAAAHgKP/30U6ryZsCAAapUqZIcHBy0bNmyVPsOHDhQLi4u1peTk5NcXV2t2/ft28ct2gAAAAAAqVDgAAAAAGmgevXqmjt3rmrVqnXPtvnz58tisVhfXbt2VadOnWyQEgAAAACQWeSwdQAAAAAgKxg0aJAkKXfu3A/d786dO1q/fr22bduWEbEAAAAAAJkUK3AAAACADLR+/XoVLlxYjRo1snUUAAAAAIAdo8ABAAAAMtDy5cvVs2dPmUwmW0cBAAAAANgxChwAAAAgg1y6dEn79+9Xz549bR0FAAAAAGDnKHAAAACADLJy5Up5enrKw8PD1lEAAAAAAHaOAgcAAABIA4mJiYqPj5dhGEpKSlJ8fLxSUlJS7bNixQr17t3bNgEBAAAAAJkKBQ4AAACQBry8vOTs7KxDhw5pwIABcnZ21oEDB6zbf/jhB/3xxx/q1KmTDVMCAAAAADILk2EYhq1DAAAAAJlJ7ty55eTkpKFDh2ry5MnPPN6rr76qw4cPq27dutq7d28aJAQAAAAAZHYUOAAAAAAAAAAAAHaGW6gBAAAAAAAAAADYGQocAAAAAAAAAAAAO0OBAwAAAGSQgIAAeXl5Zdh8ZcuW1Z49ezJsPgAAAABA2qHAAQAAAP6/9C48/Pz8tGvXrnQZu3fv3ho3bly6jA0AAAAAyHgUOAAAAAAAAAAAAHaGAgcAAABZzvHjx1WzZk25urqqU6dO6ty5s3V1yrZt21SjRg2ZzWbVr19fJ0+elCT16NFDly5dUps2beTi4qLp06c/dI5OnTqpWLFiyp8/vxo1aqQzZ85IksLDw+Xi4mJ95cmTRyaTSZK0bNkyNWjQwDqGyWTS3Llz9dxzz8nV1VUffPCBzp8/r/r16ytfvnzy9fVVYmLifY/9+/hz585p4cKFCggI0PTp0+Xi4qI2bdpY9wkJCVG1atWUP39+de7cWfHx8c94dQEAAAAAGYECBwAAAFlKYmKifHx81Lt3b928eVNdu3bVxo0bJUknTpzQG2+8oQULFujGjRt688031bZtWyUkJGjlypUqXbq0tm7dKovFopEjRz50Hm9vb/3222/6888/VatWLfn5+UmSSpQoIYvFYn35+PioS5cuDxxn586dOnbsmA4fPqzp06drwIABWrVqlS5fvqzTp0/rq6++euQ5DxgwQH5+fho5cqQsFou2bt1q3bZmzRrt2LFDYWFhOnnypJYtW/YYVxEAAAAAYGsUOAAAAMhSDh8+rLt372ro0KHKmTOnXn/9ddWtW1eStHDhQr355pt66aWX5OjoqF69esnJyUmHDx9+4nneeOMNubq6ysnJSRMnTtRPP/2k6OjoVPtMmzZNv/zyi5YsWfLAcUaOHKl8+fKpatWqev755+Xl5SUPDw/lz59f3t7eOnHixBNn+6ehQ4eqRIkSKlCggNq0aaOQkJBnGg8AAAAAkDEocAAAAJClhIeHq2TJktbblkmSu7u7JOnixYuaOXOmzGaz9XX58mWFh4c/0RzJycl6//33Vb58eeXLl09ly5aVJEVGRlr3CQ4O1meffaZNmzbJ2dn5gWMVLVrU+m9nZ+d73lsslifK9m/FihWz/jtPnjzPPB4AAAAAIGNQ4AAAACBLKV68uK5cuSLDMKw/u3z5sqS/ipyxY8cqKirK+oqNjVXXrl0lKVXp8zCBgYHavHmz9uzZo+joaF24cEGSrHOGhoaqV69eWrNmjbU8elZ58+ZVbGys9f21a9dSbX/c7AAAAACAzIECBwAAAFnKyy+/LEdHR82ZM0d3797V5s2bdfToUUlS//79NX/+fB05ckSGYejOnTsKCgpSTEyMpL9Ww/z++++PnCMmJkZOTk4qWLCgYmNjNWbMGOu227dvq127dvroo4/UoEGDNDuv6tWr68yZMwoJCVF8fLwmTpyYavvjZgcAAAAAZA4UOAAAAMhScuXKpQ0bNujLL7+U2WzWqlWr1Lp1azk5Oal27dpatGiRBg8eLDc3N1WoUEHLli2zHjt69GhNmTJFZrNZM2bMeOAcPXv2VJkyZVSyZElVqVJF9erVs247fvy4QkND9e6778rFxcX6elYVK1bU+PHj1bx5cz333HP3lEN9+/bV2bNnZTab1b59+2eeDwAAAABgWybjn/eWAAAAALKgl156SQMHDlSfPn1sHQUAAAAAgMfCChwAAABkOd9++62uXbumu3fvavny5Tp58qRatGhh61gAAAAAADw2ChwAAABkOaGhoapevbrMZrNmzpypdevWqXjx4k80RkBAQKpboP39qlq1ajqlBgAAAADg/3ALNQAAAAAAAAAAADvDChwAAAAAAAAAAAA7Q4EDAAAAAAAAAABgZyhwAAAAAAAAAAAA7AwFDgAAAAAAAAAAgJ2hwAEAAAAAAAAAALAzFDgAAAAAAAAAAAB2hgIHAAAAAAAAAADAzlDgAAAAAAAAAAAA2BkKHAAAAAAAAAAAADtDgQMAAAAAAAAAAGBnKHAAAAAAAAAAAADsDAUOAAAAAAAAAACAnaHAAQAAAAAAAAAAsDMUOAAAAAAAAAAAAHaGAgcAAAAAAAAAAMDOUOAAAAAAAAAAAADYGQocAAAAAAAAAAAAO0OBAwAAAAAAAAAAYGcocAAAAAAAAAAAAOwMBQ4AAAAAAAAAAICdocABAAAAAAAAAACwMxQ4AAAAAAAAAAAAdoYCBwAAAAAAAAAAwM5Q4AAAAAAAAAAAANgZChwAAAAAAAAAAAA7Q4EDAAAAAAAAAABgZyhwAAAAAAAAAAAA7AwFDgAAAAAAAAAAgJ2hwAEAAAAAAAAAALAzFDgAAAAAAAAAAAB2hgIHAAAAAAAAAADAzlDgAAAAAAAAAAAA2BkKHAAAAAAAAAAAADtDgQMAAAAAAAAAAGBnKHAAAAAAAAAAAADsDAUOAAAAAAAAAACAnaHAAQAAAAAAAAAAsDMUOAAAAAAAAAAAAHaGAgcAAAAAAAAAAMDOUOAAAAAAAAAAAADYGQocAAAAAAAAAAAAO0OBAwAAAAAAAAAAYGcocAAAAAAAAAAAAOwMBQ4AAAAAAAAAAICdocABAAAAAAAAAACwMxQ4AAAAAAAAAAAAdoYCBwAAAAAAAAAAwM5Q4AAAAAAAAAAAANgZChwAAAAAAAAAAAA7Q4EDAAAAAAAAAABgZyhwAAAAAAAAAAAA7AwFDgAAAAAAAAAAgJ35f7qB7u2S/oDuAAAAAElFTkSuQmCC",
       "text/plain": [
        "<Figure size 1656x720 with 1 Axes>"
       ]
@@ -272,7 +272,7 @@
     }
    ],
    "source": [
-    "altitude_azimuth = final_calc.dispatch_sync()\n",
+    "altitude_azimuth = ct.dispatch_sync(final_calc)()\n",
     "print(altitude_azimuth.result)"
    ]
   },
@@ -301,7 +301,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 504x252 with 1 Axes>"
       ]
@@ -346,7 +346,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 504x252 with 1 Axes>"
       ]
diff --git a/doc/source/tutorials/machine_learning/classical_quantum_svm.ipynb b/doc/source/tutorials/machine_learning/classical_quantum_svm.ipynb
index 114456fb3..cb1278d12 100644
--- a/doc/source/tutorials/machine_learning/classical_quantum_svm.ipynb
+++ b/doc/source/tutorials/machine_learning/classical_quantum_svm.ipynb
@@ -203,7 +203,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "dispatch_id = workflow.dispatch()\n"
+    "dispatch_id = ct.dispatch(workflow)()\n"
    ]
   },
   {
diff --git a/doc/source/tutorials/quantum_chemistry/nitrogen_copper_interaction.ipynb b/doc/source/tutorials/quantum_chemistry/nitrogen_copper_interaction.ipynb
index 969034fb4..c80c0f7d4 100644
--- a/doc/source/tutorials/quantum_chemistry/nitrogen_copper_interaction.ipynb
+++ b/doc/source/tutorials/quantum_chemistry/nitrogen_copper_interaction.ipynb
@@ -214,7 +214,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "dispatch_id = compute_energy.dispatch(initial_height=3, distance=1.10)\n"
+    "dispatch_id = ct.dispatch(compute_energy)(initial_height=3, distance=1.10)\n"
    ]
   },
   {
@@ -411,7 +411,7 @@
    "outputs": [],
    "source": [
     "distance = np.linspace(1, 1.5, 7)\n",
-    "dispatch_id = vary_distance.dispatch(distance=distance)\n"
+    "dispatch_id = ct.dispatch(vary_distance)(distance=distance)\n"
    ]
   },
   {
diff --git a/doc/source/tutorials/quantum_gravity/spacetime_classification.ipynb b/doc/source/tutorials/quantum_gravity/spacetime_classification.ipynb
index e6d598e34..f95190e48 100644
--- a/doc/source/tutorials/quantum_gravity/spacetime_classification.ipynb
+++ b/doc/source/tutorials/quantum_gravity/spacetime_classification.ipynb
@@ -116,7 +116,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAARwAAAEGCAYAAAC3uSodAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAABvM0lEQVR4nO19eXwU5f3/e47dJQl3EDAHR1ioTVJCNQgIUg4typH6/XKIeBYx1YK1VQHbfrlrPfD4qUFbiloPFBFrw6EocsihAlETTBBJ5EqCIAkQSUj2mHl+f8w+kzmemd0ENgkw79dLX2R3ZvbZ2ZnPfM73myOEEDhw4MBBE4Bv7gU4cODg0oFjcBw4cNBkcAyOAwcOmgyOwXHgwEGTwTE4Dhw4aDKIzb2AhqJTp07o0aNHcy/DgYNLEocOHUJFRUWj97/gDE6PHj2Ql5fX3Mtw4OCSRGZm5jnt74RUDhw4aDJEzeBMnToVnTt3Rnp6uu12u3fvhiiKWLVqVbSW4sCBgxaCqBmcu+66C+vXr7fdRpIkzJ49G7/+9a+jtQwHDhy0IETN4AwdOhQdO3a03eaFF17A+PHj0blz52gtw4EDBy0IzZbDKS8vx/vvv4/77rsv7LZLly5FZmYmMjMzceLEiSZYnQMHDqKBZjM4f/zjH/HEE0+A58MvITs7G3l5ecjLy8Nll13WBKtzcD5RWe1DQelpVFb7mnspDpoZzVYWz8vLw+TJkwEAFRUV+OCDDyCKIm666abmWpKDKCA3vxyz39sDF88jIMt4cnxfZPVLbO5lOWgmNJvBOXjwoPrvu+66C2PHjnWMzUWGymofZr+3B3UBGXWQAQCz3tuDwd5OiG/taebVOWgORM3g3HLLLdiyZQsqKiqQlJSEBQsWIBAIAADuvffeaH2sgxaEslO1cPG8amwAwMXzKDtV6xicSxRRMzhvv/12xNv++9//jtYyHDQjkjrEICDLutcCsoykDjHNtCIHzQ2n09hB1BDf2oMnx/dFKxePNh4RrVw8nhzf1/FuLmFccLNUDi4sZPVLxGBvJxQdrQLAIS2hbXMvyUEzwjE4DqKO7SUVTqXKAQAnpHIQZWgrVWd8QdQFZMx6b4/Tk3OJwvFwHEQVVpWqoqNVaBfjVhPIZadqkdQhxsnvXORwDI6DqIJVqaoLSrjn9Ty4BQF1QQmyTBDjFhCUiRNuXeRwQioH5wy70QVjpcoj8iCEwBckOOMLIiARSASo9km6cEt7TGc04uKB4+E4OCfQ0QWR5+CXCOaNS8WtA7rrtsnql4jUy9tie0kFanwBvPTpAVT7JObxBJ7D8p1H8OKWErh4HrWBIDiOQytRcBLOFwEcg+Og0dAmhCn++n4hQIBbB9Ybndz8cjy0Mh9BmXUUPQJBGUs2F8MXJJq8D0FACgJwRiMudDghlYNGo+xULUSeM70+d3WhGv5UVvswa1VBRMYGAO4e0hNuQQj7uQ4uTDgGx0FEqKz2Yev+H7F1/wnVmCR1iIGPYUkkGaFGP8U4RKpef9+vUjDt2hRTklmLuoCMOLe9QXLQcuGEVA7CIje/HA+/W4CApFgOkQeemdQPBIAkWVkTxfOJcwvwW25TD4/IYdq1KWqSedZ7e8BzHM76zbmeDwuPYUqc2ymlX4BwDI4DWygh0R7V2ABAUAYefjcfHMeD5YuIPNQRhhq/BI/AwWcwOhwA+opL4LB4QoZqOLTjENNeyzMZrOc27sfzm4rhEXmnlH6BwQmpHNii7FQtBEaehgPPfN0lcHhmUj/VeCR1iAHH2E5rQjgA7WPdurJ3fGsPhvbpjPtH9DbtG5SBgERMpXQHLR+OwXHABO19iXMLCEhmP4ZAhiTrPQ+XwOHDP1yr8zaMfThukYdH0Bsgv0Rw7xtfYvATm7A6v1z33pQB3eARzQZLC4HnnETyBQInpHJggpYW1C9JJsMCAPOy0tHGI+IhTW6HEIK9P/wEb5c2um1piFR2qhZxbgFjc7YDhjDpbEDJ1RjL3vGtPbi5fzJe//yI5Xp9oURyQelpJ6fTwuEYHAc6sGhBjYhzC0hPaIekDjHQRktB2bpPJr61R33NLilsZASsrPZhZV6Z7ZolmWDMC9vgFpzmwJYOJ6RyoAMdtrSDRAiSOsSg6GgVBMO21GDYIatfInbMHoF/3HalKVwyMgJGsh4CqKMSTk6nZcMxOA50YA1bijzgEXnEugV4RB7Th3mxvvAY7nk9z+ShREohSpPCiydk2DICstYTCZycTsuEE1I50EHbB0MJs7IyEvD+1+WQgzICMpATGj0wwiM2nEJUm9+h+ZfKap/ub+N6+nfvgG0llZbHpM2BxuM4aH44BseBCVojsPNAJf7+4T7d+yxjE+sS8I/br8LQPucmVGilY6VNOo95YZvtMdwChw8Kj6kDoE5ep+UgagZn6tSpWLt2LTp37ozCwkLT+8uXL8cTTzwBQgjatGmDl156CRkZGdFajgMLGL0A7d9JHWIw8ePvIjqODNJgvuLKah+W7zyCJZtL4BaUiphMlB4blo5VfGsPCkpPQ+B4AOxpc0ApgBkHQJ2hz5aBqBmcu+66CzNmzMAdd9zBfL9nz5749NNP0aFDB3z44YfIzs7Gzp07o7UcBwwYvYlJVyXhnbwyCDwHSSaYMdwLV8gQWCHOI0AKdfs25GbOzS/HrFUFqrfEmskC9FWrymofqmoDCIbJ6RCZwOUS4AvWr9vRw2oZiJrBGTp0KA4dOmT5/jXXXKP+e+DAgSgrsy99Oji/YJW/X/9C3+vy3Mb9pioUoORqOA548Po+6BjrRr/k9qbem0g+mxWaGeGTlHyM1jjKhIDnAEZ7EAAghjG/5ehhtQy0iBzOyy+/jBtvvNHy/aVLl2Lp0qUAgBMnTjTVsi5qsLiGjQjKwD3X9sCrnx2CwHEISDIe/vXPMCAlHoXlVVi0bm+jciR2ny3ygMArBq0uIIMjSo+NMdTyiByenpgBgMODK7+GtlgmEYKb+iXo+ncmZSY53k0LQLMbnM2bN+Pll1/G9u3bLbfJzs5GdnY2ACAzM7OplnZRI9Jy86BenTDt2hRTnufmpZ83WjPc6rM9Io/FE/oi9fK2GP28khg2Dn1SuAUByR3jkJHcHjIhuirWnLGpWLR2r277lXlluGNgD9T4Jadq1YxoVoOzZ88eTJs2DR9++CHi4+ObcymXHGi5eeaqPWrOxh+UdUOVdOpb2yUMsD0UnuNQdLQKQ/t0jvizZ2nGJ2YM740b07viaFUdtpecgFu0zx35pfoQyVhat/KgRj+/DR6HqrRZ0WwG58iRI/jf//1fvPHGG+jTp09zLeOihLbSBJglWOj7Z+qCAAhAFLKI2wd1wzu7SyFwPCQi6ygjtGB5KGf9ihLD4gkZpr4aFoxGYntJBW54bqslM6DIAxzHqXNbQUnGjpIK1WgYjaJJKSJEg+p3qEqbFRwhkfKxNQy33HILtmzZgoqKCnTp0gULFixAIBAAANx7772YNm0a3nvvPXTvrnDfiqKIvLy8sMfNzMyMaLtLFdrkKouAnACY/d4eCByHGkOXsFvk8dbdV8MlCmHDjtX55Zi5ao+puuQSOPAcGjTXVFntwzWPb7RMIrsEDvOz0jDnv4W6RDHPAR//caguYU2NaeHRKixauxcCz8EflMFDH5618Yh4c9oAZCS3t12bAz3O9f6LmsGJFhyDY43Kah8GP7FJR2quhTK3xFmWoAGlae6piRm2RoLe1LsPVuLJj76zZfRr5eKxY/YIW+NVUHoatyz9Qp0YZ61p2rU98eKWA6b3KPtgVr9EU5k/q+/l+G/+UYg8h7OGcxLJuhyYca73X7MnjR2cP4SrPAkcT5k/LeGXiGW4oW3UkwnRsQBaIZL+l6QOMZCItRH0SwRLPzUbG6B+Qj318ramMv/KL8vV/Sms+oacMYimgWNwLiKEqzxJRA7la+zBSgAbG/VYcAtK8llrhyLpf4lv7cHiCRn40zv5RpocFXYtOy6eR37p6bBl/ji3gAXj0jD8is46o2I1TuHg/MOZFr+IYGTXE3kl/0EnsRdPyMDiCX1109l/GX0F3AYGPpoApux7lNc4XKOeJBNVNqaVi2dOf1MY1TSz+iVi11+vw32/SmnwRRmQZfRLbh+2zC8RYjI22gZIh94i+nA8nIsMxuoPQCVbOLXEbawidW3bypQA9gXrQ6vlO4/Y5n0oJFKv4iDLBB/84VpmB7KVRxHf2oPZN/4c065NQdHRn/BTbQAPvZuvM3RuARiXkYA1BUfhEUV1f2+XNqap8kmZSViZVxYqvcuYPswLQB8+scJQZwwienAMzkUIbYnY7uamyOqXiPaxbtz7xpe6xK2L51F0tApLNhc3eA0eUTBVwQD2SAWLVpROnRub+uj6/zI61ZRzYVFdPDCyTyjvVIylWw/guY37dZW7OWNSTZ6RMwYRPTgG5yJGJDc3RVpCW+jb/mgvCwe3IMAXDDbos/2SjKraACqrfWGbBu08CpYRAcx9NxSs11/cUgJfkGi+Q7108KJ1e9XOZK1Rc7yb6MAxOBcxGnJzx7f2YM7YVCxYsxeuUPL3yfF9kZbQ1uQBCBwgCjzcAg9fUAIBTBWroCRj+vKvdF4Jnfb2G1Qg6ICmFayMS2PPgRYunkd6QjvsmD3CqVI1ARyDcxGDVbWyChdy88tDT3kOgaCMeePS1EqNMTfy5Pi+am4nZ9N+sNpnJAKc8dV39Z6pC6rDnpIswyVwEHhOHdAcm7P9vFWHKqt9KDr6EwCChHb2lTt6Ps7FqDmIHI7BuYjBmpdihQva0Iti0bq9uCG9K+JbeyxpQF/cUgJjmsYlcKauXoHnsGBNEfyaaW+3QEAdHZ9EAJv+H7pGOxpSitz8cjy0Ml8dkXAJHG65OllNHrO6rx1D03RwDM4FgsY2phH6f6IV19UjktBL6wFUVvuwed+Paglc93kygWx4PSARE5GXyAsg0DcPWoV7LKKwlV+WmRLJSvm+QDePFZAI3tldhnX3D8HRqlr8VBsAwKFtjIi0hHaOsWliOAbnAoBVpSmcEdITXbGF5oCGh15Ws1iA0qAnEgKPqOR4rOgi/JJkGtRkfaYdUZg2EZ56eVvkl54Gz5kNq8ArHMcvbCpWDZzAAc/e3C+i8+jg/MExOC0cVpUmbU7Eqjs20qRxfGsPJmUm6dQtWYRVrNCLhRiXiCW3Xol2MS71Jm7jETV0FDIkRl5lzthU02dGQhQmywSjntsKj8CjlrE2SSbI0RgbQMkxPbgyH2fqgli4di+omVo8wekyjiacTuMWDpYQHM2JWHXH6nTBI/BcSo6fwYpdeorXlXllpm5b1lpiXTxEwSxml5bQFhnJ7VUDMtjbCUtvz8SSW3+Jpyf2hVvUV6WomqcRkRCF+SUlH2Qc0ASUHM6M4V4IjPAvKAP/999C+IIy6oIyfEEZf1pZ4HQZRxGOh9PCwQx3JAKOMRJVdqoW20sqNLrgMq71xmNrcSVcIjtpnJtfjgcZM0wsT4i1FhnAgqw0tY+F1dFL6UhFnkOtXymjG/mIgzJh9u1Y6WTZyf/GuHjMvuEKpFwWh7SQEXthUwlzW2NWS5IJPv++EmMzEiyPr/1uThjWMDgGp4WDdcM9eF0fk1ZUXUBGICiZwq9P9ikc0JIMLPxNui5coElW1sCkllHPbi00lLshrSuzo9ct8MxcjxZK34+5b4fCWCUrOlpla3CCMsG4jASdIZiXlYq/vq+XK7JKo1eE8XCcYc/GwzE4LQysJyeLQtMjcLrSs1vgcKjyrGW+QyLAwrVFaqkbUDwiK42nGcO9zPIzXYt2PouC3dFrb2w8Ig9ZlhGU9X07NLGt/fx6siz7ifeZv/6Zyeu4dUB3gADz1xQCBAjICpcOKx01xNvJ8tisnNrMVQ57YKRwDE4Lgt2T09SYZqjG+CWCkzV+23yHwOnDJDsemo5xbsv1aMM2+nr3+LiwyV0WZELgFgUENF6QwCv0GPmlVapInvbz0xLaQuTBpCOdlJmI7F/1Uv/WGqxbB3bHgJ4dQwTthGls7hjUzVbyhpXE9gVlvLXzCO4f2btB3/1ShGNwWgBoZ+ys0MS29snZPtatTnlTbC+pQFAy3y3PfLIfc8amYuGavczpbonowyQ7HpqFa/cCICb1ShbR1az39mDtjCERqUAYMfPXP8Mzn+zXvVbjk3DXK7vVW5p+F+r5AMADI/vghU3FEHkeAUnCpMxu+O3gHjpjQQ2myHPwSwTzxqUiPaEdeJ4DdN4hcOc1PZCR1AGDesXbNhnGuQXmuc3ZXIwpA7o5Xk4YOAanmbH8i8NYsHYvBM6sPukLyrj3jS8hg+h6b2a/t4eZd6FzQZ89MgJv7TyC5zbuV70AkQeTFJ1Oiv/u9TzUaj5f4Dko5LP6xjwW0ZWLV/I02vyOsaP316ldsLrgB91nCxww/qokxLUSTfkVluly8TyW7zyiaoZzHHDfsF66G50ahzi3YCrh//X9Qjwwwmsq6/sl4LXPDsEtlqIuIIMQgli3aGoyrAtKIISAY4R0bkFwKC0igGNwmhHLvziMv/7XrLuuBaWLoN4OQCxDF+1cULf4WAg8B5FXErLzs9ItE5tpCW1NRIABSTYNZFoRXdHhSxYXjzbvtPHbH3UJ5Fi3iLJTtUhPaIc4N5vOQgu/JJs0w5dsKcGUAd0A6ENSX1BiKnPmbGFXq/wSdJ3QNJ9kbDJUYD6wtt3AqWBZI2p9OFOnTkXnzp2Rnp7OfJ8Qgj/84Q/wer3o27cvvvrqq2gtpUWi5PgZzFtTFPH2vqCMaa/txj2v56EuaL4xPWI9u562w7guKCMgK7NRVv0ldFLcLfKI8wjwiDxY3Pqj0rqgxi9hzthUldEPgDp8uTq/HPGtPWr/jfbfSr6ILb/Leo+F667oDJegv2QpHaqRuc8vEQQZFkcMz7DaKEzKTAIAPL+xGNc8vgm3LduJwU9sUlkTHSiImsG56667sH79esv3P/zwQxQXF6O4uBhLly7FfffdF62ltDjk5pdj9PPbEIyAhFwLv6TkVEhodCDOI8AlcLhvWAo+e2SE6sGwGvRoX43VerST4lMH90Arl5kuIjf/B0xe+jkWrtmLB6/rAzl0Q/skEpaa00h/qqUfpe95RB6xbuU7CQzD8NHeY6j26Y0tpUN9a+cR03dmgYBnHvtc8fauUgx67BM8s2E/fEGHrtQKUTM4Q4cORceOHS3fz83NxR133AGO4zBw4ECcPn0aP/zwg+X2Fwvok9hOWiUcYlwifju4BwJBGW6Bx6s7DmFHSYX6fkNmo7SeQY1fgl8ieHn7QeaIAADUBpSO3Cc+2ge3GLlRA5R80Y7ZI/DmtAHYMXuELsQjULxeSSbgAGQPTUGswehZsZz6ggQ5m4tNPDss3PTLBDx7cz94RA6xLgEekVO9EyM8Io8x6V3DHhNQmjFZEaHAc7bn5FJDs402lJeXIzk5Wf07KSkJ5eVs93Pp0qXIzMxEZmYmTpw40VRLjApY3kdD4ZdkvLrjIPwSQY1fMj1J7byJSNajjAqEI0wH/MHIjJoW2jCLorLah4ffLQh5cDL8EsG/th2IKMyicAsCZgz3opVL8fyskJt/FO1j3Vh3/7V4O3sgPntkJJ6ckIFHb0qHNloTOGDu2FQsvCk9pOfVONT4JBSWVzV6/4sNF8QsVXZ2NvLy8pCXl4fLLrusuZdzTmB5Hy4BJuUELeh7boGHR+QxY7gXbkF/Uxm9CztvwrieSDwDFu4e0jMio2aEUbFh2bYDZsZAGaHQTjm+R+Qh2lytAVnGlAHdsGP2CLw1bSAevSnd5IEB9ZW/sTnbcbiyRl3vDelddXQbElHyXgAwd1xa2O9kB7v82aWGZqtSJSYmorS0VP27rKwMiYmXRnv49GFe5Bga2gDg4VV7TF5DnFvAb/olYtWXR5SKE5HRMc4dUcgUCYtdfGsPZgz34ukN+223Y2H8lUkYf2US8ktPo19ye9uGOQpjM+GcMalYto0tcgdAR/25o6RCLbvTEnWMq165Qcvdk5HcXm3yM4av2sof7RAuO1Vr4m6mRjzSKhqghGHG9gaWztelimYzOFlZWcjJycHkyZOxc+dOtGvXDpdffnlzLadJoL3ZAILbBnXDoJROamNfQrtWmLxspy6ZHJQJ3vuqVFe2bSzxt1W5dsqAbnhhU7FlXsklcJANAnceQeGYoT0xkcwUscYCFqwpglvkEfCbvaxXdhzEtGtT1JEGu7I767t7u7TBUxMzMHPVHgDsPqc5ud/gxVszw+a9IgnvPCKHpydmmKRtaGJ78QR7CeVLAVEzOLfccgu2bNmCiooKJCUlYcGCBQgEAgCAe++9F6NHj8YHH3wAr9eL2NhYvPrqq9FaSrPDqpP4pS0H8PpnhyERomooCQCCUJ6UHKd4Q0u3HjA9eVnE31qDAuhvxnBjE/eP6M30ckSBw9vTBuC2V3ZB0iaSOc7UE2NHEUrXY2oaFHgELPJFrGY6o9cWzshSxkNWsx4AfPDNcZQcP8PUtdIa8SfH98VD7xYw5Y218sFjMxIgE2Kr83Up9+ZEzeC8/fbbtu9zHIclS5ZE6+NbDOiNzoNjtsRTN11LfgUoT9+/3HgFxl+VhCWGZjUW8bfWoBjDjTljUrFo3V5buZgpA7ohJ2RAtFiQlYbMnvGmm9HKEBoNhLbzl6XYIBFl5GD+6iJmo6FVEtrKWzMa3XrGQ2sPJb/0NLxd2lhK0gBA6uVtmfv+ZfQVuKJrG/xUG0DbGDcqq31hdb7axbgv2aZAp9M4CrBrr28Invr4O4y/Ksnyycv6HK33QLtladiiBYuzePGEDMwK0YcGJEW54dYB3QGwwxkrQ0hBjSCRCXwSQStXvWKDlsR8sLcTFjKaIFkMgNrjGr01Rf+8njB+xnBvRAOl/dQpdHbea/kXhzFvTZGpbyrOLaAuIOPu1/JM1KWDvZ1MOl91QQl3v5YHj8gjKJNLktbCMTjnGcb2ep7BNBfjElDL0lYxwCUoRkF7s9Pk5fIvDqsUo1afoz2OMT/D8h7snvCA+Wa0C0FYdKT03x4ReOx/fwGAoG2MG0VHq0wJWysGQCt6iNTL2+JhQ8jz3Mb9EAwlfyMHjnE63Og52Y2fBG2oS3f+5Trd+akLSup2lLLjUgyxHINzHsG6GYxTlh6Rwz9vvxKlJ2t1nMQsFjuJENUoxLf2qLQQWgJzq88xHmfeuMiSzEZ1BrukrJ2BsuMi5jgOD7zztSoTI3AwGcygTJjhlBU9xEtbSpil9Xuu7YFXPzuk+96UcN1YWWNV0BbYjJ8EJDlE2q5HUFb03LXcQXe9utu0HW0KdAyOg0aBdTN4BA6E4+ASOAQkgrnjUtXy6A3pXXU3a0ZSeyxYUwSXwEMiJKzHEA501knLyhfpUKHp5hurUDsY97UyUHZcxMbvIIU4R+k5AgBJlrGjpMIUcljRQ+TmH2V+1qBenTDt2hTT9zaW8K0qaC6Bs6zeyUTh82FDMUT081h58UDw0tMwdwzOeQTrJuN4Dg9d1wdPffwdXAKPRWv3oo1HRFa/RFOIcuvA7iYjRBGJeoERskzwwR+uVW+uSNUlWTffX98vRJxbUA2hUV6FRcpFQwptDkcmygiD0RtxiTwkTUI5KJtDDjUnxLjJPS4BJCDpHD2Rh9pyYPe9rXS27CpodqCfWw92uHv3kJ6XlHcDOAbnvILF+Uv7ZfwSUfto7GJ3q5sjEvUCI1yiwl/TIc7doAvbyrjRMI7K1Cxcuxc8ByWZyinzRNoq2I7ZI9TSPc09xbkFjHlhO4xVI0lmM//RkCOchycRgoU3pWPhmiIIHA+JyEz+HyPsdLb8koxpQ3pi2faDzHK4EW6BA8eZeYfSEtqC5/ReDgdg2rUpYY95scExOOcZLP7hSLShwoFJpn59Hyz+6DvLm6HGJ2He6iL8X26hZUWElacJZ9wEnsPc1YWwm4ggRDFcxrkpQNF+0va0iDwwP6T8YFx/YXkVMpLbWxrBWLcAWeN1NSRsDGfEAhLBa58disjYeEQO/7oj01LN02hwhAtiqOj8wzE4UYDRS4l0cjscjMZse0kFM7zQQuuVpF7eFjV+KWwzoNa4CTyHGgMlRCAo2xobQEnkbtp3XDW6LFJ4LRE7fc/I/Ec1zllG0CNy+MdtV+pu8oaEjVZyxVqwtK600Db9WY0ulJ2qRYxLVNsUAGXiX+u9Gc/RxUri5Ricc0AkFwW9eWdq+kMiHXK0Op42xLCibGDhxue3KQlpmWDuWPtmQK1xo7pS1DD99poeeOlT6/kniuc2lmDJ5hLdvJO2u1l7g1ZW++AReLgZSVrqKbHK8I2ZTwonVxwJPCKPuWNTkZ5oTqRrUVntYzY80oeOsXdo8YS+IMBFK0PjGJxGItIqDgD8UFUHSZbBQZmhojiXp1hDk8g0bKA9IHNXFyLGxZ44N3oLGcntdclsAFi69YBdJV6FVv7l4VC/jLFCRHmdRY6YjE1dQKEvBdjNhwWlp5mjHXYGoLHNmHEeAUFJxozhvZmE6cbP114j2oZHKhZ4qsZv6h16cGU+BJ7XjcBcTP06jsFpBCKt4gDArHfzsfJLhecnKFtrg9sZLBbC5VlEHhBCROOsm4vFZ0O5iel31N48xjEKg0qNpaicFv6gjNHPb8NTEzPUKte/th3AP0Lekp+xj0fQeyF0HUaDryU7t/MKGmqoaY5ozhjFm7GaGmf18Bg9SI8I3DawG17ZcRBLtx7A85v2w9j/GZQVuhItGpPza6ngSLgkQAtDZmYm8vLymnUNBaWncduynbqYXItWLh47Zo/AqRo/rnt2q+n9GJcASZZNT/OYUNl48YTwU9dlp2pReLRKbebTqiT4JRkzhnsxKKUjpizbadlHct+vUvDqZ4cAKEbJI3DgeE5389Jj0Sd6ZbUPg5/YpDNiLh748IGh2PTdj/j7B/uYn2U8Pw9eF0p4hyk7e0Qe6+4foss9sdbA+owds0cwvZBw+1K4eQAcp4x4DOyuemJugdONJrCO6RY4uEVeR4ka5xEQCJp/d9PnCrwuBLP6Ls2Bc73/HA+nEQjnXdAnUvHxM8z3A5IMj8jrVAIAqLSeD71boOovGUOE5V8cxoI1eyHwStVDm0cAoJPbfWFTsUmDSf89YrF2xpCQMJzCTQyJmJQKnt6wHzmbi7F4QgZT8M4lCjhaVYvsob0Q5xbV5kVfUALAmcjMCYFJqtgKI6/ojLE52xssumflFbCqfXRSn46JSCEqDoUxg2DRur2o8QXVNftDzxka6lhNwZvGSSQSet06byRwiixxQ6lHLhQ4BqcRCFvFCSUEaXhixIzhvfCPrdZJ14BEsGzbAVNL/pm6YP1cT+gj568pwhd/Hqk++U1yuzZP00Xr9mLp7VfBIwrwS2xvjYLSK7AE77R8L8bmxVM1fhMJFqtTmAW3wGHjvuMmCow3p14NX5gymV0lcLC3E5bengmAIKFdDGr8Eu4Y2AM1fglVtQFkv5Gno+IgBHjyI7OB5KAQa6UltDOdE9Y4yZyxylS8Hf54XR/cOqC7rrwP6HNVFzIcg9NI2FVxtE+kMeldsa7wmLrfpMxE/PH6nyHlstaY9d4ecOCYg5zLth1AQIZuQFFieFUBiahscnajFSLP4awh96AQgXERNxQKPIf80tNMdU8j34s28fzUxAzVo/BJMogkIxAmkKdUqkYKDACYsmynrbq4VjLHCK0ap1H0js5ZGcMtX1BGrMvsqdUGJEx7LQ9PTcxgViKNfUEAMC/XWofMI3KqxhYrV2UMby9EOAbnHGBVxTFeKG4BmHiVXopW24vy21d36xwRgYOp65bnFBopdmpWuf2YoR7H4ZmJGQBgYqILyDLSEtoyQ4x3dpeZPBHaSCgRgqmDe+C1zw6b+F5YYYxx2n3MC9uAoPl7xLr5EK1Eb/XGM1JgRJJ7YRlmwLpCRXNxs97bo3h8AqeElyG4BQ5Bwj73fongoXcLMPPXP4NMCHiDWqnW+BaUnjb14yjfu7550cjtYyxOaMPbC7FUfon2O54faMnAqeExtuEromzAe1+XoUOcW7c/7UUxypYsvCndRGlZG5CZNJc8Vz+3E9/aY5I88QVlPLQyHw+vKsDN/ZOZpOdawvW1M4Zg/JXJWH731Uz9JqoS8cqOg5bCdizQ8+Pt0gaLJ2SYCNEFDrjvV1589shI3D+yt3qjUvUJOogaCegclpG4vOxUrW2jH/X4OMM2PM9h3riQ+B9DwSEgEfz9w30ISCQko0OYn2/XvMgiurdS+LA6/oUAx8NpJOwoO1mhDc9x2LzvRwy/orOtB6CN041dtyxo743Kah/e2V1q2oYmg1fmlWHtDH3Fh0JLf0GTpy6R19OKaiAKPH6TkYD3viqHwCuEXQ9e1yciVz+rXyJSL2+LG5/bCnp4iehlewFFndQflLHkll/ivuUNU2ZleVtWk+YUVh6fNjxaU3AU89fstTwGBYt6gpWwtmtetCtOXKilcsfgNAIsV1ebv2BdKGf9Ev7ynz3gBZ7ZI2JsyWcpBXhcAohMUKu5abQt8mWnaiFwPNSMsgECz6nGhkrKaFvpjZzLdgnnGp+E3Pyjuhv47x/uQ9nps1j4m19Y7qfu75fQyiUi4GNTlM797zdqtQxQiNyNEHkO/3tloolHCFAGL7Va30r1rsQy96PN+1g9AOJbezAuIwF/W7c3bId3QGLz+YQjOdNC26VuIoDX9ExdSHBCqkYgnJRufGtFq9sIv4yI5V9ZetuSTEy0ldowRtnH+k6o8Ul4efsBDH7CrH29fOcR00XtFjhTCOLRxEKsBrjXPz+CEot2AG0IaqeSUHL8jM7YAGAOUPIcwdi+lzNvvBnDvWou7ZrHN6oSvKweGIED1t0/RPcQ0IbIWsS39uCZSfUhsHKOzN913jg2PardsSnoeSo5fgbd4+Ow7v4heOj6PvCIHFPP/UKC4+FEiHDkUsb8RXKHGMS4eKZkbiTusBXVxclqv0nTSvsEXjwhAw+uzLd8Aq8uUOSUtZ5Z6uVtsWRzsWlbv0RMeRxJlhHn5lHDkHWhoKTkWrBCUCuK0s37frQ8thYeUQTAmQyzW+CQkdweJcfPaEjUrdEqQs0pCqOXQvWyWFzQDQWLB5oQxYAuv3sApizbCaA+TL7Qxh6ianDWr1+PBx54AJIkYdq0aXjkkUd07x85cgR33nknTp8+DUmS8Pjjj2P06NHRXFKjwLpZ5oxNxYI1e+ESzAOZykBegeWFHum0uKn0HurpAAiyh6boun/pxZ/VLxFn6oKYv7oQPKevtrDg4hXOHJHn4WOEYsbd3aK5oc2IHvGxur+tQtC1M4ao/TB04ruy2oeARY+Niwe09tsvmXMudaHGvd8v/xL+oGzL9UxR45Ow82Clqn8VCbQhcEPCJAqWpA+LdJ/+++kN++ESlHEV7Y8i8Na5wZaIqI02SJKEPn36YMOGDUhKSkL//v3x9ttvIzW1PtTIzs7GL3/5S9x3333Yu3cvRo8ejUOHDtket6lHG5it/AIHngNEnq9/og3sbrk9BR0daOjcFOuYtN3dyLSnneGJBK1cPH79885YvedY+I1DEKyblyFwwH9+P1h3827d/yPuffMrXR+QW+BBQHTqDXRKmgNMnqHAKU1xz2tIy0UeeGZSP3W8YNm2AxFNsVvh0ZvS1d8ROL8UEdpjrS88po5I1AUkcBwHj8ijLihD4NhyQnaIc/OQCJi5wfONFjvasGvXLni9XqSkKKxmkydPRm5urs7gcByHn376CQBQVVWFhISEaC2n0WBVnOgFTz2CRev2YkDPjqFOVb9p+1iXgCcn9EVyx1idp8IaMmRd5FYkXkVHqyyVLMOB8rg8eF2fiMYMtOGhnYPjEnmTVAzL26OzQoFQh7OijkksvUJB4DEopSNyNte/pqUhBYCXtx807ecWOIDj4AmNWgQlYjkQsWBNEW5I72rLFdQYaI911h9Uz59fzZcTdYo/GGYEljZycqjv2Kbh7YUQXkXN4JSXlyM5OVn9OykpCTt37tRtM3/+fPz617/GCy+8gJqaGnzyySfMYy1duhRLly4FAJw4ceK8r9VOsTISak9CgNHPbwuNCEgmwmwZBIN6xQMAbl76uc5AaCkbrC5yq5wRwEU0w0NVEdwhcnY6+ZzUISaifIlH5DD7hiuw+KPvwuY6JmUm4VSNH5v3/Yge8bER5VAAJTQghqY5LThCMGXZzlCIVL+NNlnPmlMiAN6++2q4RAFJHWLw1s4jljrqVJYHgG0VsiFgKnlEABYvEKBwZC+fejUm/+sL03sCz7V4ob1mTRq//fbbuOuuu/DQQw/h888/x+23347CwkLwhgpQdnY2srOzASgu3bnCivz7rD80ce3SC5VpcwR+SYYky7qkLH3SsOaRXAKn5ncKSk+bqj7+oIwbnt+GWaN+hmc27Le8yFmt82kJbSOa4aFic6zwoJ9F3sIl1Bsouv/j68N7Qst3lupURFnlbBYkmdgoIKA+F2Wjr8VqjOQA3PbKLjw5vi8ykttbKozS/e1oYVk3c7iwqzHk9zEuDot+8wv0S26PDwuPIWdzMdxCfejpEgV4RAFBg/H3BWTc83qebtuW1o0cNYOTmJiI0tL6JrSysjIkJuq//Msvv4z169cDAAYNGoS6ujpUVFSgc+eGs7hFCv1siuKNaMm/QYhKKUBveGNScH3RsYia8gClMY+6/IXlVTq6AoqgRPD3D/bpSs6AvppFNbKhabG3aiSz4vZl3RDeLm1wx6BuOiMxJr0r/nR9H1ODIP0sSTarLlBIBvcuMvJxHnPHKaF2uPNKQwoPo0pHjTIHoE59CJirOVRhVJZk+GXFg+M4TncsoyGvC0qmm5kAJrY+4w3eGPJ7vwQ1CXx/lzaYMqCbzgMvOvqTaa4LUNQwfEGos2ctMcSKmsHp378/iouLcfDgQSQmJmLFihV46623dNt069YNGzduxF133YVvv/0WdXV1uOyyy6K1pAa7t9puUS21p0fgw5aGKdyCoLrpi9bZd6gak4X+UHPX1v0nQk15BLSpz8oYGtn6IsHC3/wCdwzsgVd2HMKqL49ga3EFNn73o+oVUNAOYUpnESlEnkOMSzBRQdQGgiBE8YIWrd2LJ8f3xX2/SrFN/HI8h3UW3dLUKBNi9qq0xpulZGo8dyyv1ifV38x0mFb7k1FaEaP3Q6fEtcbXKmQCAGIwJqxBTkmWVUMHKA11xs7wltiNHDWDI4oicnJyMGrUKEiShKlTpyItLQ1z585FZmYmsrKy8PTTT+Oee+7Bs88+C47j8O9//xscQ8nwfKGh7q2xW1TPhcuoQom8yWhQlz/cHA+gXIQygfr08gdlhYeYNx9XezFpjWEkNAasMKBDnBv/+boMfqk+NGQ9IWv8EpPOItatJKFZFRbOUMZ/YGQfFB2twj2v58EXJDqi97UzhuCVHQdNIY+WrNzY40O/U32+yHwjG1sRwhlkrVGqqg1g+vKvdEOXPAf4DF9VO7lvlHyWDUZEJgSxLg5nGWPzMW7BZCjYD8v6fWWYB1tZ7RfNTc4e1RzO6NGjTX01CxcuVP+dmpqKHTt2RHMJOjTUvb17cA/135Fw4UqE4IERXvxz2wFTM9v6wmPMcEoLjuPAa4whgXIRBxiETcaLKdKqitV2kcrZhFNPeG7jfl14pqxVPycV39qDdjFuk564i+dR45fUkEdb6g9HVm5l0GNcPAgQEYmVFa1qZbXPnCuzuAx+qg1oPFJrT9ojCiG2Q+tckvH7hYNduAlEfo1EE5dUp7GVq2x8KAs8QGTgtc8P45UdhzB3XCo8Ah/WQwlKBC99+j3mjUvT3SCV1T5mOHVVt3b48kiV+vd1V3TG1uIKWzIsFpVByfEzmLlqD/xhiLdZT0laJYuke5p1Do0DiAt/8wtc3SMeD60s0JFkGY2X3edlJLdvcCOdZX5MljFz1BVoH+vG1v0/WupGhbsZpw/z6jq854xNxbzcQt21w3NKWCVwZo/UCG1yX8m9ELh5qLN2xjXGuYWwvVV24Wa4+b+mwkVvcIxPLau2dJpEnjqkJ/619QAkQG1U++v7hYh18WE1igAlSblo3V4dBy3Le2gl8thT/pNu34+/PQ7eJqR0C2Ydptz8csx8t8CUD2B5J6x1aInNrUYNjAinnjCoVzyMM6SskIb1edpj0fxRuDDAyqADQECCjmfZJXB4emKGqffJ6mbUVjEBgtsGdcOglE5IS2iLNh4RM1cpBiYoy5AJ0eXZrOAWeVNyn5VL0qLGL5k6rbWgw6escBOw7uVq6hzPRWlwVJJxBhOfUdPbmEDcXlLBnEPSGhuaT5iUmYQVu8tM6geRPM3rGB8SkAgEjqhyIrWBIAjqE4MyITh9NqB6TUVHf8KsVXuYyUeWd2IVUvpDVRytNG+knsX6wmPqOdYy0kVivFjCfoOf2KTbJxKNpobk5gISwcxV+id7QxorX9pyAK9/dlhtF/jskZFqnuf3y78MGza7BQ4f3D+kQXrvVNvKCh5BUf0c2se64BKpBxttXHQGhyVyFs6FpDmWBWv3gg/T6Rnr5nH34J7IykhQSsoDe2DUc1t1MX1dUGI+zVk0A0ZIBBA5YMmtv0RCuxiMfn6b+ryknbVUYoYHuw3ebUGxSdfxsI1HZDfFTFF/juu7XFmMdEbjxfJUtHkSY95j5qoCIPQd7X7DhubmjFw1DWmsBGBKcgPAvh9+Mhkbj8hh6pCeeGX7QV053coLYUEb6lkKXHCcSsJmBcpgYDX/11S4qAxOuMSulQu5/IvD9eTkYXDWL+Pl7QexdNsBtSHOGAQRQnCqxm8K5fb+8JOqwWQHtyCgXYwbHxQeM3cN8xwWrCmyLKkan6DGm1zt5zEgkqed1quyM5yUkW7H7BFqWBQuR8KixxA4HsaTy/oNqSF9yCAqx6oaAkqvUCThXVpCW5NiphGjQ2qmrA7suaGp8WlDUhpVGWLl5qiUIv2WLoHD3HGpJn4jI3Lzy0PNoBwCQWX+rzmaAi8qgxPOtWaRFpUcP4N5a+yZ9I3QPuGW3n6ViadWFHh11EHb6fvqDvasDwHRCaIFZGWdLMqIQFBmtvDHuBQ+4LuH9FSpTK3E2Yz3hhXpOKsj28qrMkLrRYRLWFZW+5jfNSjLpjYJK8M42NsJxpy+Lyib8h4ugcPiCeHDO/r+jOFey1EI+mCzkn1JDq2zIT1RFFa5ORnK1Py0a1MwqFc89v1wRvFaeA4BWUlEG6kxWA9iqtnueDjnACvXmj7pKGkRfbrSHzXI8BZcPAdwxKSMaIZZ9aD+QtSTcxvLwABw/4je6B4fa3q61vgl5vZ3D+mJV3Yc0r0m8kryVyLAS58ewL+2HcCCrHST8iNrsDPWJeAft19liv+tOrIjhbaHqeholSkZrvVUyk7VWp6bE9V1ujL7pMwkyxEC1jG0xuauQd1VvmQWWIbBahTCLfDgQMLQfzSsp4waeEpTYeXFBmTg1c8OoUOsu14rK/TeX98vBAh0U+/hEsZN2ZtzURkclmv84PV98NRH3wGoJy2auWoPeI6zTLgCwPzfpKGNR9SV0I1P9rqAjIR2rXSf6ZMUw6a9EK3kWKgsSHxrj+npyur98IgcOsS6EdS4+crQI9GNGAVlRTu8lWjQDhd4ZnOYMf5n0o02ELSHyWpa3MhUyPquN6Z3xdic7brXV+aV4YGRfXQ3SpxbQFVtIGz489auI7h/ZG/bbVi9ONq+IF9QwsSrkvE/v0zAba/sshydF3mEzatoYWwUDNcAK/AcUysL0E+904Sz8dzQ89/UvTlhDc7s2bPxxBNPhH2tpcDoGpedqjV1xipKBgVMMTVR4LBAw9im7Ta957XdOkNCda+Nla6xOdt1F6IVOfecsfrYm5WX0G6flZFgopIwzi7Vv26mAA3KBEb6IxYdEiufYoR2At0vKfpOHlFAXVACCPDmF0fwyo6DTM/IGMJZ5VCOVtVaekbbSyowa9UeEKKMgHhsRgXUfQX7MrDVzUd/X6pqurrgKFZ9VYbrruiMT/b9CLegjGkASv5NIjIWT8iI2FsI10XMQiAowy3wql4963tqS/qSLKvVT20LQlP35oQ1OBs2bDAZlw8//LDFGhzAfPOywiyWsXELHD74w7W6KoK2isIZZXM5Tn1Ka0usc8aypVqtGPysnixGQ9bQGSYKWsafPkwRltPmm7Qk7AAs8yla0F6W1MvbIr/0NPolt0eHOLduXMFKd10bwhmZCo0lcnosLfySjNKTZ/GwIUEcjtkQYHfwUtg1RdLrwahquq7wGNwCkD3Uq3ZRNyY0YYWcRkzKTML7X5er31mSiaVJkgjRsQfS7+MRgcf+9xdoG+NCWkLbZunNsTQ4L730El588UUcOHAAffv2VV8/c+YMBg8eHJXFRAPapyfPmdUnAeWJS4ii6WxVsmRVQiRZxo6SCjUfZEzQpifWKy9Q7Sr6Qxp5cbS9ISy3vqD0dFhdahZiXDxm/roPxmUoxswoLGdMwlrlQrTgOeBMXZCp+R1uXxkEaQltLb0JbZLZaGyUcq5sMjZWcPOAHGr1l4h9GThcU6SVnrlfqh/b0D50AOuKkRbh6GgBpct4bN/LkashTJeIwhGkMAzUdypzPI/pw7w4WmX+PhzH4cGV+WoxY86Y1CbvzbE0OFOmTMGNN96IP//5z3j88cfV19u0aYOOHTtGbUHRAH16zl5VgE/2mQm8aPgwL7cQbTyiZQx7pi6ou9BpX0zq5W1NT5NF6/ZizphULFy710RfwJqL8QVlvLXzCLqFSKtYJFwsvhcKj8jhpn6JeMcgmVIbkPHYh/vQMc7D5PaZPsyr2z6SnhZR4NXSvJGj2LivyCs8vKLAIRAk+O01PXCqxm/pygPA5n0/msZIWrl4SJIyhsIKI1jgBR4fWLT6GxGuKZL13Si0YV5D8iFWhtUI5XfnTMbcLQqYM+bncAk8esTH4rMDJ7FkczGWbj3AJIIzFjMWrdtr6Y1HC1HjNI4WGsupWnL8DK57dmvY7Twih88eGcksEQ96bKMpTxDnEbBgXBoWrNlrCFUU9j9t5OYSOHzx55E4VeNnrsXFK3kR7QVIuYvjW3uwOr9cVQc465d0LvWkzCSsLjhq2YOkPQ7l/122/SA8op5sDID6OVbzZm6Rh4vndDmiNh4Rb04bgMOVNaZczJm6IObmFqrRqMCbE9htPCLuGZqCF7eU6BoKtefOLbCn9CnUvJLIIyDpS8SRVGJW55fj4VDfixba78Zq3mzl4rF2xhCMzdnO5J22+ryC0tO4bdlOy/ATULzvxROUtgo7rmxwMOXLqLF3C+xiBv1eNNcZSSjYYjmNWxryS09HtJ3AsWPYslO1zJAmIBH0S25vevrVMurplL6gXYwbLoEzhQU8z0PgOGhncbT9LFo9cmN+479fl9tyGfNc/XHWFx5TOWfoJLo2WWg3b0aT3YvW6meXqCue1CFGp8QAANc8vlGX+pJks/63X5KxhFF+FnkOQVlRVWcZm1YuHrIs4/4RfTBlQDelY3xNEVwCj0Vr96KNR4xoPALQ8/34DUl/7VDpWzuPmFj4avySySujvx3Azu2E8yZpvovmW+aMTcXCNXsZonhsnyHGJWLJrVcCIPipNoiH3i2ANhlNv1dj+oQai0vG4Jys8YffCIBE2DGsVUgzb5yS95kzNhULVu8NW5oFOMS5BSg02OaKkWR4rcYnobC8SvcUYlE7CLx9Q95Zf/1xFjAaHY3t/lbzZvQCVQYX69nu5oxNVdUttZpZ3ePjmGqgAqd8Js0nTB/mxT+3fg9f0FxZA6AzADQJbqStoEOcfomoDwYtOXsklRhvlzZ4amKG5RxYfGsP7h/ZG1MGdEPR0SoAHBLatcKqr8pMow01PgnLvziE1Xt+sKR7tRt5Ccgy9v3wE6a9nge3oBjeqYN74LXPDuNs+AYxBGQlwU5n3ViVKqfxLwqorPbhmU/Y3aJa8Bwsy5na5LNW8OyGtK54fmMxlmwuMYnGGSHyQOnJs8h+Iw8cjE9y4KmJGTjjC5poNuevKcLCtUXqE5WV7KsNyGE/f/6aIiR3jLH01OyShdpqXUHpaZypC4JSngYlWUfVQG8emvtgqYFKBBA0xFwA8MLmEtN2RsS5lRCWpcPESvwKPBeiZa3/vuGa3iLRmaL5GipYZ4WVXyqJXrqmh94tAM9B5x39645M/O6NPJM0TlAi9Y19oWfLKzsOwqqhUBtCaT1RY6Vqya2/tKTpiDYuCYMT6TSxS+DUxCULrNLtNY9vDJv0o5WEuePS1AuAQuSB/3dzPwzq1UmtRhk1xVVZmmB9so8l76LmSBRlFNPUe0Ai+MmiQc5KmpY13qAdjFVvZMYp0BJqsdRAjRWeeeNSw3IaS4SoxsZoLFghisQguYqk6c0uzIiEjM0Kxt9y5qo9WHf/EGb/IOuqEgUe9w7tpVYb6wKyqndm9J5Y1z2d02sOYwNcIgYn0mliyj+s/TGsko200hLO2PBQQqV549KQntDOdAEEZeBgxVmMzaifXLarRgHKjdwxzm3Jq9zKLeD3v+qFxR+bvbozdUET3aXAATekdTVte67jDX5Jn/tYU3AUj3+4T0fNofU2bh3QHSBQczASIToOZG0YYGUsrDh2WK81tumtMUoMVvAFZXxYeCwiYwso53/KgG4qsXqcW8DRqloAysR4uB605qCk0OKSMDi6cIjnUGPBWRKOtlN78fuCUkQysjKU/MOCtXvx1t1XM72LnM3F6lM+vrUHkzKTdPNDfKgCoV2nkqhmf2ZAIriiaxvTfhyAOZpqEUWsW2Qa2sboKWmh7VOKb+3BuIwEk9SM8ZzfOrA7bkjXK048MLKPaezDyliwwqHKap9JUrig9HTYpjerh01D6DBo9RAwcw5TPLdxP/50XR88MMKLFz/93taoaz1RO8NL34+UVK2pcEkYHICh071ur04wHtDz3rIuamoE1Iu0IU/7oIwpy3bi+p93wbpCvayu1rOqrPbh7V2lpv09Iq9Lxnq7tMFN/RKw0tB3AwBXJrXD3a9/qf7NQzF8BOYwC2A/9Rr6FBd5Dh4XrzPmWmVMakwj4WRhjXlo/w7XIattwNMShBn7muye/uFuZPo9QAj8oWsoEJQBDvAISqsBlYDOvjbFtks8KEP1Rof2jsfW4krG+QUWZKXrJsEjoQ1tjO55NBFVg7N+/Xo88MADkCQJ06ZNwyOPPGLaZuXKlZg/fz44jkNGRoZJSuZ8gl6MGcnt1aeoFbVjJDeclrSa0pO+st2sOEDhlwg+2XfcJBGivdCLjlaZnnAyAZ6e2BfJHeN0T2365NQi+9qeWLpNT4NhZzKsyLoa8hT3iBzW3X8t8ktPY97qIl3+SWsIcvPLsXDNXgicYoDnazhZGjKxHKmxCEfCZjXbdqrGbxpe1e6n45aRCP5y4xUYkBKvfr7xe1gpXbDAMjYA8Kfr+uCGdH3YyyKOt+ILam5DQxE1gyNJEqZPn44NGzYgKSkJ/fv3R1ZWlk5bvLi4GI899hh27NiBDh064Mcfw8vOni+E+xEiueFYpNU/79oWs97bA4DtQrsFAdlDU5CzuUSnolm/FnaY1jbGjYzk9mqViKVhHucW0MolMPdnwUjWpUWkYSigEE15u7RBhzg3/vz+N7r3KPthZbXPNJIwPzTV3NAOXbtQIVISNgDoHh+HtaHfTzvbdjYQNKky8Jwio5uW0M50/Gc+2a9r8DsX422FF7d8jxc2l+jODYs4vrlzNOEQNYOza9cueL1epKSkAAAmT56M3NxcncH517/+henTp6NDhw4AEFXFzYaCXtSszlOg3jMw3qxaFzYQlDBl2U6TN9Mxzg2jiiZFWkJbU+4FUMrprCSuFhIhETOw0A5WO7pL2gi3uuAoXt5+gJmgjnMLSA81+AHm6XP6N8tzC0gEn39f2ajkrVWoEM4zDcgyCsurcPPSz03EZHb5qrN+RXlzxvDeDR54ZBnI312bgpwtJZZyM0ZQT23mqj1oH+tGQrtWTOL4OWPZ1caWgqgZnPLyciQnJ6t/JyUlYefOnbpt9u9X4tbBgwdDkiTMnz8fN9xwg+lYS5cuxdKlSwEAJ06YZ6GihcHeTnhmYgb+tDLfpJpo5RkAeu9p8tXJugRwVkYCFq3by1TRpPuwjMaCNUXgOD2/r8jrczusDmAW7huWgvG/TNINlbIQTvgPqJ/Arqz2YfO+H9HKJeieum5RUBvkWKio9jF7ZyKpFrK8VCtvQm0WZPSmzF9TBJG37tKm8AUJcjYXm75LJF6F1kDuPFCJpzbsh8hxpkbP8GuQ8bs38iDJxFS0MBr/lohmTRoHg0EUFxdjy5YtKCsrw9ChQ/HNN9+gffv2uu2ys7ORnZ0NQJnlaApovQlCiKlDMxIi7JLjZ7Bitz6pyxpBMLLfeUTB1EnKcZzSxKYBbV1vF+Oy7LtwcQAn8KF8g9Ks2LqVaJr0NoYwkfaazBmbatGfo+CsX8K01/Jw95CeEAzsHiIPDPF2MlWuaHd1pHzIWjBzM5qOZNY5shIbZIGGxEu2lDS48kPHSoz9UwIUPzfSoEttEDR4jHb0Gy0FUTM4iYmJKC2tr7aUlZUhMdEg9J6UhAEDBsDlcqFnz57o06cPiouL0b9//2gtKyKwsv8N7dC01IsSeNNrRvY7ZmeuLEOpN+n3o70X2te0EERezVPQz6BDgHYhTCRJ8zi3gOQOMch+40tbw+SXCF769AAErr4blhCCpyZmwNulDbIyzNU2yrkLsPtlEtq1wqHKs+iX3N42rGUloc8ln+KXZLUPhnpukTL7VVb7mGMlEhRKW2N/FKC0RLgENhm8O9ThaaW02RIR3o9sJPr374/i4mIcPHgQfr8fK1asQFZWlm6bm266CVu2bAEAVFRUYP/+/WrOpzlBbzYtIunQpAndkuNnLDlpgyGi61YuHm08Ilq5zOx3c8elmfaTCXTUoi6BM5Xx6YCf8djeLm1U+Re7yoYWSR1iws6FBWWCAydqwiqSUkhEKQFzUDqhAcUL/M/X5aZtaVjF+i0kmWDCP7/Aw6v24Lpnt2LWqgIUlJ5GZbVP3YZWI7XnpyA0wPvk+L5o5eIR6448wU4xY7gX8a092F5Sgew3vsT05V9h8BObsDrf/B2MoAPALAQsmBt5TqlQtmIN5nJKaP/mtAHYMXtEs6gwNBRR83BEUUROTg5GjRoFSZIwdepUpKWlYe7cucjMzERWVhZGjRqFjz/+GKmpqRAEAYsXL0Z8fHy0lhQxGiMaZuSktWoKlGQZbTwiU3COGo3kDjGm8Qbj9RiQSGieia3OYKXFzaps0I5gY57ETrGAkmEt/ug7pkSKHWinMZ1eDjJ21852mX4LgyFfmVeGtQVHIQPMcMt0fsamYuntmfipNoCH3s03tTHEupV8D0sGumOcu9GyuUkdYtRh1EgR4xLRNsbNTIHRweELCZcMH05DoeWECZc3qKz2WXKVsMDiSWnMGIFL4PDspH546N0CncttxcNitU6BA24d0A0rv9SPEJypCzL1ungAPM9uIjxfePR/6pvctL9FXVCyPS/G7271nWNdPIIEuKlfgq4TWOSVfNn8cWkAB9O4QSsXj6W3X4Xpy7/W8dhQbhmad2IhN78cD2lmyoSQyJTdz0y/D6UI0Q4Oa5UZmgoOH06U0JAOTRaDn8gr/DYib6Y1pTKy7WLc6lPc+MQMN/kNKAaJRQZvVaa1ystIBHj9C30X9cxVe0AYuSRASW6GS4N4RB5TB/cAOOCV7QchCrxtLw+FkcQegI4HqPxULf5sM3Nk/O5W35lKN6/MK8MDI7zICQ1DKsaAYP6aIrx8ZyY8Isdo5DQrcITzgKlXpDXSIs+pA72s8RkrPuyW0DHcWDgGxwbhmgNpCBIISqYnaFAGVt1zNc4GJBNZVl1Qec0tCPBLMiZcmWTKg3hEAQTERFlgBIsM3urij3MLzO1ZEHgOkkSHIhoGt8BBlmW8+cURBGQZc8emIT2xHXYerMRTH+9nGmFA8dg+NJDYU9BKWDjQ8JAikqY7Vj9MQCIoP1VrMjYsaSC7hC29RliNmm5BKWMbw2s6O8biw75QDQ2FY3AaieVfHMaCtXuVMYWg4oprn14egYNLFDC0ZzwWT8jQka8bKQqW7zpiOr5SqWqYkFqsW4BsQRZOQzYuwgg6KBFLDyccaLI84NNw545JxTMb9sPFc/AFJabn8IcRvZnGxq5EzwMQNOyJQUnGe1+WqaMG4Ro4AcBl0Q/jCyrUD0ZpoKNVtbouZSuPI1yjphXjHk1KN6VeVFPBMTiNgFaL3G8xHsPx9RIyLBlaK9AGNUqhYMUGZ5zH8ogc/nHblcyyPeuGNTLuUVceUJ7iHAhkmCfVjdK5gKKOAJ6Hx4I7l6WHbkyeUlFAFuxK9DEeAX5Nz5JEgL9/uA9uXiFRpzcqizqUgnCw7BEySgPJgOqdUkOQ1CEGBaWnTQUAY5hsbNS084qaWi+qqeAYnAbCqpfCriciEukVQC/pQvdNvbwtRv2/raabYV5Wmoltf2gf9mgI64aNdeubBgHg6h7x+NPKfAD1PLlugcP1P++Mj/Yeh5uh3AkoNzZ92se5BYx5YTt03LkSgVF2iea4IukhsSvR+4MyhNA50L0eSjTRG5VSh85ctQeyTBCQic4oAcDMVQUQOF4VsvN2aWNSuZBkGT6p3jvVMvj5JRkzhntVrhrjOTc2alrRYDSHXlRTwTE4DYQVmTrtiWC52JHmToySLoAyQxPrFk3idekJ7bB2xhBViM6uPGpV5k9o1wo1fkmlcOBhJnb3SwTrCo8DsJZnmTO2vjybm1+uI0h3CRwevt7MTkhzXC5RCJsEjW/twfgrE/EWg7YjKBEEbMYDtAl6SovqEnhwnKQSr9PP1iZlAUVVYbC3k5pjqaoNYPryr3S/hTE8fnrDfuRsLsbcsWnMc25s1GR1UQ/2dmpxxFnnC47BaSDCkakbYcydUO6dOWNScbLGjxc2FevcfF+Q6NxnK2NBOX2sYnzjU9OY5JyUmYSxOduZ4wgNgXZ+h1WJ4TngisvbMHMhLlGwLSNrMXVwT6bBCZeRqgtKuPu1PIPEjPJ9Kb0pBc2lWI1SVFb7IiDJV37DhWv3Yu44ZW5LCNFYGAcrrUKnHbNHtDjirPMFx+A0EDraBm1PhKaMS8HKncgy0ckJZyS3x71vfKmbnTKSSRkZAOkAqFWMT28YkVfyPFSfSTfF/vIuyyQqoOQawumLA/r5HSsOXYAz5UK0OS4WjAbT26UN7hjUTXceWHDxHAIygUfgIAOmRL1+W3OYYpc/2V5SYZK3sYIvKONktR9zxqSGKFM5hbALUK8Vu9DpYimDG+EYnEYg0ouBeUGJvM6jSEtoC5lB8h3nFlRCdeOc0X++LodHYA+AAjAZub++XwgQhb5ze0kFc8ZLC5EHnp6YwezCpWJzLKkRK28sLaFtg57YVh7Gwt/8AncM7IHtJSfw6LpvzclrgcOyOzOR0C4GR6tqcfe/d1t+R7o2ep7D5U+KjlaZvLdweH5jMTgOIdka5Txqf4twHe0XQxncCMfgNBKRXAysC8o4Cc3yYPp376BOc7PGJIISQdCQQ6JEV6xZKUChtxjQs6PljJcRg3rF4+b+emqN0b/ogkW/+QUAtrCbHYWo1kgb+0u0YHkYD69S5JS9XdrA26UNavwSWrlEtexOcf+I3mrivMYvwS0KCDDCRVoJpGFluPyJEkZxtsOsxioXYD0fNXd1IZI7xjbYEF8MiNrwpoP6G9CIRev2qoOGldU+kwezraQSdQEZZ3xBRb87gpEJOqGiVHQY4YPAIz9EHB4OMS4RRUerTOvaFNJlNw5GUmipN/1BGb+9podOdie+tQeHKmswNmc7blu2kzn0yBrW9AdljH5+G1bnl6Oy2ocqhtSNsaxulWv7y+gr8Na0gVg7YwhW5pWp57kuIKtMjU+O7wuXptVbCgnK2TUQiiEp4kggyUD263kY/MQmAMCO2SMuqAHMc4FjcKKM9IR2iDNMJWvDH9YNZoRH4HQ3AAsxrnrlhXnjzEYuIBP0iI813TSKZrdx2/onutW6jdB6JjV+Zd7ppU8P4JrHN6pGRbuN9ibXTnlbdQb7JYKH3i3ANY9vxPTlX6kqknQqfu64NJSdqlWPRXNtrVw84twC3AKHR29KR/bQXshIbo8av2T5/Yx9U0E51LwYmsSniX/tOZw7Lg33j+gd9neiqAvKOiPHMuAXI5yQKspgPWmN/DeRcCe/PfVqE12p8ZhxbgFb9/+I5A6x+MvoK/DUR9+B45SqCUcIbntlF3NW54wviPmri8CHmmWoV2b0IuxKs1bNedqqm5UyplFieM7YVMxfXcSkJFWOqYRSlKOo9GQtFq3da0qS2+Xa7PInrL4pF8+rrQhGBQZCCBaGGBkbottFj3sx9NdECsfgRBl2hN/a9606ij0h7uTMnvE6zevaQBAcx8Et8ghIBFkZCbjx+W3qBS/ywKxRV+Cpj78DEGrkkwje2V2GpydmoG2MiLSEdtheUoE5/y0MdRMr+/7f+4XwuPRVKiP/jhF2hpPeVJHktIyKCHZQKmBQK3YU2sSsVa4t3O9iZ4yMCgxBmXZOm9frEXnc3D8J7+wuBcdxpvD4YumviRQOPUUTIZwMyuMffot/fHpA91qsS8A/br8KQ/tcxjzO+sJjWLCmSBmGZOR5XIIyBGrkv4l1CZBB1JJtJElkj8jhs0dG2j6JV+eXMw2nljJi+c7DTMqHHbNHAACTSiLOIyAomflpFKqITPx++Zem7+gWOHz+Z/v1Ata/y/Kdh03J76x+iSg5fgajn98eUT+OUjXrj6F9LlM/J1z/VEuHQ09xgUA75qD9G1Au+ld3HDTtIxFioq+kT+zKah8WrdurK7kaIXJmOlMAas/PgjVFEY+HUrE++h1YhpOGMG/tPIKczcW6eSO6Lc1psbSr6L+N0jcLxqWhX3J7fFh4DDmbS3SzSGkJbS2T5NpQpeT4GWZXNssD0nlZQaXPKqtfolquj3So1S8RJLRrpfscrSbaxdRfEykcg9NEsCMCp+MSPgP1HaWzZCESzmEZivojKx8ChPiVI2wsYcmrsJ7O8a09uH9kb0vO33A5LWMoIxECX1BWy9cAQfbQFN1Iwu9/lYL/t7HEtB895tz/fqPy/QDAHYO6YWGovG9EyfEzmGmYLF+0bq/aUhApyRqgJPtZXdwXY39NpHCqVE2AcNUZFu2n3fQ0ED7ZLPLA4gkZuCGtq+WkukQI5v8mzXaS3SNwaOXiFXmVUK7EqsKkhRXnr7Z6ZOR0Zr1n/FxfkGDJlnrjMve/35iMjTbfVHL8jM7YAIpkc8nxM6Y15+aXKxPlBiPs4nlsLzkBroF0IeG6qS9FOB5OE8CuhR0AU9Bs7ri0sAONxknmW/on47I2HnSPj8WgXsqYQ0HpaeakOhXyy+qXiOQOsbjntd26WadYl4AnJ/RF2xgRCi8PiUg/CtB7CcbxAAC2XDLGylLZqVoIhlFzeu4Onqg2GRMAACHqZ+WHiNONyC89rQut6EOBFZ7VBSX8/YNvwRo5M45QqK9bSChf6nAMThMgXAmWlbeIRNCM3pzLth3A0q0H8O/PDwNQul4X3qRwArM+2yjkl5bQlsH7QlBVG8DDqwpUAilj9GWsMAE28jg8j+U7j+BFg54Ta3hTG3IsWFNkCktoeDdvNZtqlNeUmvtZDIeerPHr/rYKUd0CB5kQ0xgFBcdzmHldHzy1YT9cAoegJGPG8N66kM9BPZyQqglgF0awDIKdoBmVO6GhzPrCY3jp0wO6tnqJKKXh5V8cZn421YOyWx8rlJEYrfrzVhfquqatvAS/JCNnU7EuJJu5ag+27j+hC8tKjp/BqrxSlBw/g2c//g6rC34wHeveoSlYtG6v5VwT0aiB1vgl/CbjctM2iz/+LmzDoVvgsCArDW7RLCcTE2oAnJSZhGc+2a8mmOeOTcP9I3s7xsYCUfVw1q9fjwceeACSJGHatGl45JFHmNu99957mDBhAnbv3t1kyppNDasmtHD9IBSV1T4s33kESzRVGlrWtsLc1YW4Ib2rjoQc4JDQrpWJoY4VyoRLSgNKD0rR0SoM7dPZch+XwOFabzw+2aeXafYFZdz7xpeQoZSd8w6dZIdIBtT4g5Zr4zngqYkZOorOOgbxWUAi6roB9u8wKTMJ89cUmQZYPSKHf95+FRLaxWBsznZdIpkK+DkGh42oGRxJkjB9+nRs2LABSUlJ6N+/P7KyspCaqm+7P3PmDJ577jkMGDAgWktpMbCqToSbPs/NL8esVQXqhU/7XCjtgVVZXJKBz7+vRHLHWLX/A1AoRF0CB57jsHhCfaXJuL5IFSp/qg1YzjgBAA9iMjYUtERv1fjIQkqn1maFUQ74203p6N+jI45W1YWI62Vbg/lTbUBneI0DpmNztjOMDY/FExR2xYLQbNrFyMwXLUTN4OzatQter1dV0pw8eTJyc3NNBmfOnDmYPXs2Fi9eHK2lXBCwMkY0TDFLlShlbauJZIo/vfM13KJgzoNISmfsQ+8WMLlytR3QAGyNwQMr8lXKCjrj5BbrZWEiUIdpEHp3bs30CgmAsTnbwYMLa7x4TqEH1fYKZfVLVH8HljHRNmJaGdhLrXO4oYhaDqe8vBzJycnq30lJSSgv108Gf/XVVygtLcWYMWNsj7V06VJkZmYiMzMTJ06wn5QXK+yGOwMywcPX90ErF48Yl9U2sGX0o6EFC2fqgpAJAReGV08Kifad8QURlJWb+fe/6mW7z7lgyrKdAPRT1oO9nTBrldJ6oCUzoxB5JScT61IGOfnQjFlDhkhlKI2YufnlGPzEJmS/kdeg8Q8HzZg0lmUZDz74IJ5++umw22ZnZyMvLw95eXm47LLLwm5/IcOYFLbrt5FlGc98sh9zxqRi0W/SFfWERoCGFtobjipTBCSCOo13FecR4BI4W6E+tyAgzhOZ8xznEdDKpYQpdwzS9x1Z9Qf5JWKasl6+8wjTq4l1K8d/ZlI/fP7nkfjH7VfiL6N/jlYu6wl+wDrRD2hECw2lK56Djo7DgRlRC6kSExNRWlrPQVtWVobExPqu1DNnzqCwsBDDhg0DABw7dgxZWVlYvXr1RZs4DgerbmSr4U5laFDGonV7sXbGEHA8H14S0wBWaDHY24mZjI5181gwLg094mMx4Z9fWB4zIMsY4u1k0uoygo4tDL+is5pDuWNgD+SXnkaHWBdKT9XiUEUNlu86Yupz0eZKKqt9WLK52HR8t6CXzqHnl8XjbAyFKqt9zH4hVqhV/3mCk78Jg6h5OP3790dxcTEOHjwIv9+PFStWICsrS32/Xbt2qKiowKFDh3Do0CEMHDjwkjY2Vt3IJcfPoHt8HJ6e2BexLnN5FlBuvhq/hBnDvbafwfqxOZhDi6KjVXAJ5q19QYJ+ye3hEgV4GC4O9SaeHN8X3i5t8MykfvCI9WGMaDikRIhqbCi8XdpgT9lp3P36l5i/Zi/+/flh3JjexURupTUQdDTECMoASI2Slq+HgnpY2lCIhky3LduJsTnbcbiyRkejWhdkh6hO/iY8oubhiKKInJwcjBo1CpIkYerUqUhLS8PcuXORmZmpMz4OrBvPRj+/DR5RgC9oVm6koBf6jeld8f8+2W+iugSUvhFJ1g96ungOLoE3EbgDnEmoDgAkmWDMC9swd2yaqVGQJcRnrL7tKKkIW/5njSKsLjiGv9x4RajfxbxvJKMhVg2WdDCUUp4CZp13owgdi2DB6SyODFHtwxk9ejRGjx6te23hwoXMbbds2RLNpbR4sHI1NEeg5V4BoIYqlHnuyfF9sb2kArNWFTCNDaCoZxrL5wGZgOPMVZbSk2cRtKBf8AWJyn5HhfioABxL9VNbfYuEfH57Cbso4BY5kwY3AHVq3gjjaAhLG8w4GBqQZUwf5rUtdZedqkWMS68TxqIRccCG02ncQmBMUrpFnhm2AADPcVj1u4F4J3uQWqGxKp0DSi5j5BVmVU6PwOG6n3fRvTYqrQsWrdtrabiAeva7HbNH4J6hKQAIlm49wOQoZn1POs5gTFQDQKfWrZj7dWrdismlzKriGUdDcvPLMTZnu6oN5hZ4eEQeD17XBwvW6gdSczYX25a67apXDsLDmaVqQWA1nrHufI8o6ETk7BKZgFKy/njvMfMbHIeN+47rXsrN/wEeY7LFeDzNDfjilhL4gkQdDo1EA9uOqqOqNmBeJhQVCRZYORW/VL8+ljaYX5IhcMAT6/eZTq9bEJA9NAVLDDNfDe0Md8CGY3BaGLQhiFV1it7wlEUuzi3YdgUTsKtFw/pchu0lFfBBf8MaP0/glMlwj0GLqiGdttq1WuVIAPbk/N/+J932hjbmVGSZ4FSNPyTP62caYysPLiDLmDKgm6oPbkc0dqmSaJ0LHIPTgmHHoKedFaJzP2/vKm0Qife24hNMalK3wAEcB4+g12syEmqFE3Kj0Ho0LJ0tO8a/GBePZEO5Wnujs3IqEgFG/b+tiHWL8AUl2/BQ970Nid9w9CCOoWk4HIPTwqFl0KM3GlDP/Utvznd2l9rSQwkcIAo8RIFTRw5YxgZQlDWN/Sd2PUJ24QVL2M5oAewY/2oDMu55PQ+LJ2SAAKY1pF7eltnwJxHojFA4GCk7HEQHjsG5QKB9orJCGYHjQTjCjBUEDnj25n4Y7O2Ezft+xLzVeo4Zo2rkpMwkJjmV1mjMXLUH7WPdGOztxKweUbDK0R6BAzF4UHZhpC9IQjNdBL4gUY/10LsF4DngXGUA6ECmY2yiD8fgXIBgc+jIIMTs43gEDv8KKQcAwPArOuP/cgsN++r3WZlXhgdG9tERvxuNhpFawkp5gLVWjuewTuNBAVCntrP6JYa6n/VGR+A5gHCAJt/UUA0oFpySdtPCKYtfgGDN+SyekIF5WWbFTY7Xk5hHUn43zhUp8sHmsOVsQEJdQMbDq/aoHMHGWTCrmSRvlzbISG6P7SUValfv4Cc2YW7uN3jo3QJTmCTJBFIEagl2crtuASZlTKek3bRwPJwLFJaVEkJ5cnhIhDBLtuHK71TFk3od20sqINlUwaj29+T+yVj5pV7Vc7C3kyWHMStUe/1zMwEXDXkAJZQTeEUrKijJJu8sKBPEunhTfsot8pjcPwnLNV3MznR308MxOBcwWJWSWwd2j0j3yFh+NzLd0e5bv6SMVITjxvJLRB1JMOZYtNU1LYdxJKyC2pAnN78cAAmFVgQ3pHXFukJ9f5FMzMlwt8Dhrbuvxi3LduoMFAmRrYcTKXRw/uAYnIsQDS3ZsjweXVXJALcNy6AWRi1wbVOgHUOgFlQMsLLah1mraDe1ksf5iNXMqEGcR1BVM88GJFPOJygDy7YdwKufHbpglTAvNDgG5xIES4XSjunOBI5DjAjUWoxSWIHmhtYXHsOCtXvhFjiVIbBVqKnQ2E8kyTJ2lFTgUOVZJj2HFYzUF1v3s2e0lm07gIAMy0FNB+cXjsG5xBBOhZJVVRJ5QOD5evL20OAmwjABGuGXZOw8UIm/f7hP+TvUJuMRgSW3/hJpofmnd3bX8ygFZSVvIzeQ58dIfVF68qxpG4ED3KKAAEN22DE40YFjcC4hWKlQXt0jHld0baMmdVnNfKwE9V/fZ+tCWWHq4B546uPvTK+LAo92MW7Vw+I4JUdDQYiiNRUJuZg2jNImp+czCMVm36BQXmjhcNpEF47BuYRgpUL5x3e+RlBWenY4XqncsJr5tE/99IR2iHObydmt4BE5DOrVCa9/fhh+yUzoTm/yOLdgou70S7JtuZtC4ICXbr3SRJNRdLSK2bNzxeVtnEHMJoZjcC4hWKlQ0lyIT1I6lWe9twc7Zo9gqmJSJHWIgRRBi2+sW4AcKs+nJbRl7jNvXKp6k9f4JXgETic77BE4jPx5F3ygqUhxUJLXOnlit6h6SnpYGSvOGcRsYjiNf5cQvF3amIjKWTA2/rFAG/rCUVlQb4lKsNAmwDi3Qjv6aEiSmCKpQwxg0BJn0WiIPEzbWYVDaQltTfSmIg+14Y/Fs+MgOnA8nEsMC3/zC9wxsAe2l5zA3z/4FqyIKNI8Rla/RLSPdePeN75kSrN4BA7JHWN1uRSrJkCK7SUV8BvKT9dd0RlbiyvU8rqyRmBMamds/O7HsOFQfGsPpgzopmsqdLS/mweOwbkE4e3SBt4ubdAxzqPKrWjVOKcPsydj1yItoS1ki2oVx3Mqb49RptjYBAgoSe2H3y0wHW3Dt8dDiWQ9Ptl3HOvuv9bSeFFUVvuwMq9M95pxXsxB08AJqS5hZPVLxI7ZI/D7YV64BQAhjt8lW0oiogulHbpzxqailat+JotSeFLenmse34hnNuyHLyhbCs/l5pdj9PPbmMldUeAx/kpzM55bEHC0yjr0o3NdRUerTDSkkYSNDs4/ourhrF+/Hg888AAkScK0adPwyCOP6N5/5plnsGzZMoiiiMsuuwyvvPIKunfvbnE0B9HCi1tKdKEVrRLRJrhTNX7kl55Gj/hYuERBna/SctPMGZOKyho/cjbth8hzkIiMM3VBLFq3ly1TbNCVmv3eHhuNdIKpg3viva/KdMeqC0q45/U8k1wvoCf9ouMZWjjl7+ZB1AyOJEmYPn06NmzYgKSkJPTv3x9ZWVk6bfFf/vKXyMvLQ2xsLF566SXMmjUL77zzTrSW5IABu3kmF89jzn+/wQeF9QlbpQmQgxyS96X7LVxbBICDX4Ja9l6wpghui6SySVfKag0Cp3LVLJ6QoZaw/ZIMSZbhk8yjE4BZ6kXklSFQN4ODx0HTIWoGZ9euXfB6vUhJSQEATJ48Gbm5uTqDM3z4cPXfAwcOxJtvvhmt5TiwgJ2UsF+SdcYGoGqfLJIv3vQ6x5mlaQCzhpMV/YXIAx/+4Vp1/EJbwq6qDWD68q90rH72VKUiltx6JdrFuJzydzMiajmc8vJyJCcnq38nJSWhvNw6J/Dyyy/jxhtvZL63dOlSZGZmIjMzEydOsGdiHDQO2vI25Ypp5eLRysXOm1ghKMsmo+ELEjx8fR+VC8cjcnjo+j747JERugHJ+NYepoxNjEs0NRbSEnZaQltLPmUrruW0hLZO+buZ0SKqVG+++Sby8vLw6aefMt/Pzs5GdnY2AFyyUsDRBAn938Xz4CBh+jAvpgzohlM1fry1q5S5j3G+avowL3I2Fesa8QCFGdCOghRQkrvGPhtAL/ei3ZYey65L2OkgbpmImsFJTExEaWn9xVpWVobERPMT85NPPsGjjz6KTz/9FB6Pc0E0NWjCVkv7sGRLCaYM6KY2Cmr7V0ReqRoZ56sAIGdzCYwDnTmbizFlQDfbruWyU7VwC4KuzwYAZgz36owEi8idGjM6ZlFZ7UN8a4/TQdxCETWD079/fxQXF+PgwYNITEzEihUr8NZbb+m2+frrr/G73/0O69evR+fOZpfaQfRhVRqmFSTaKGisUrHmq2YM9+LpDfphSLcg2E5fW/HiuAW9NjiLHZCOYBSWV6l0F0G5nmPZkXJpeYiawRFFETk5ORg1ahQkScLUqVORlpaGuXPnIjMzE1lZWZg5cyaqq6sxceJEAEC3bt2wevXqaC3JAQOsYcm6gKIvTg0LbRRkQRviTBnQDS9sKtYliuuCEgJB9oCnzmMxyutKBOuLjqljD6xKlovnsWzbAbz06QEA9XQXDqdNywVHjLKFLRyZmZnIy8tr7mVcNCgoPY1J//jMlHuJdQlhFRmMIc6kzCS8tfMIkxjLyLtTWe1TtbXs8OhN6bh1YHfm9h6RhyzLMB4iziPgrWkDbcM4B43Dud5/TqfxJY6kDjHgePPYAFVkMHYEA4qx2Lr/BGatUkIc2j38+udsYwMovDslx8/Ydv+ysGBNkZqXMao/zBjuhVsUTPto6S4ctCy0iCqVg+YDvZFnvbcHPMfhrKEMbWTAo14ND46peGmHP7//Db4pr7Ls/mXBJdR/vjERDCgJbiO0dBcOWhYcg+NAvZGLjlbhntfzdOMDfklGVW1A9XJo4rYx2H3oFADY8yUbIBG9t2JMBFNjKXAcApKMeePSdHQXDloWHIPjAIByIw/t01k3PlAXlBCUZNz75peQZIIZw73MEQRKsjUpMwkr88qYnlJj4BZ4zBlr76045e8LC07S2IEJldU+FB2twtR/79blZGiznzaU8ogc/nVHpkrrWVntw+ffV+KPK75GA0UddOABxLgFVczPkW5pGXCSxg7OO6iXYEzRBGXglquT4RZ4xLj4kCJmBob2UXqoCkpPY33hMTy8qoDJX0MR6zYneo2QodCNWiWuHVyYcEIqBxZgG4zXPzusBFQSVNpOmkgWOC4sqfpfRl+BAT3jUVhehUXr9oIDh1oGW6AWjnTLxQPH4DhggvIAG70c7Z9UMwogTM4bilYiB4kA04b0xPgrk9QBzBvSu6LoaBV+++puk0a4Fg53zcUDJ6RywER8aw+emdQPHpFDrEuAS+DgYvTrAAo1hR0CEoEsE7z5xRFc8/gmvLCxWO2tGdqnM569uf5zPCKHOwZ10/XbOIOXFw+cpLEDW9DRhTi3gDEvbDN5Mh6RByEkIq1x/X4cFk/IUJPB2hEJmnx2Kk8tD07S2EFUQcMfyrinJfBzCRxu7p8EWfPMcgkc7vtVCmJd9olhX5DoksFGqRZHuuXihJPDcRAx6hsEfwJAkNAuBmNztuvyPDwHjL8yCa9+dijs8Zxk8KUHx8Nx0CAoeZfLMLRPZ9T4JdM8lFtQeGm0c0+K/Iz5WE4y+NKD4+E4aDSsqDyTOsQgI7m92gFslf8J10Xs4OKD4+E4aDRYE9zaihLNw9T4JbgFfU4nzi0gPaFdcyzbQTPC8XAcnBMimWVieUJB2aGQuBTheDgOzhnhKkrUE6KqEAAQlGTsKKloqiU6aCFwDI6DJsFgbydoW74kAjz0boEzI3WJwTE4DpoERUerTGMSAYmg6GhV8yzIQbPAMTgOmghW0+PWU+UOLj44BsdBk4AOg2oh8srrDi4dRNXgrF+/Hj/72c/g9Xrx+OOPm973+Xy4+eab4fV6MWDAABw6dCiay3HQjDAOg3pEDs9M6uf04VxiiFpZXJIkTJ8+HRs2bEBSUhL69++PrKwspKamqtu8/PLL6NChA0pKSrBixQrMnj0b77zzTrSW5KCZ4dCBOoiah7Nr1y54vV6kpKTA7XZj8uTJyM3N1W2Tm5uLO++8EwAwYcIEbNy4ERfY8LqDBsIZyry0ETWDU15ejuTkZPXvpKQklJeXW24jiiLatWuHyspK07GWLl2KzMxMZGZm4sSJE9FasgMHDqKMCyJpnJ2djby8POTl5eGyyy5r7uU4cOCgkYiawUlMTERpaan6d1lZGRITEy23CQaDqKqqQnx8fLSW5MCBg2ZG1AxO//79UVxcjIMHD8Lv92PFihXIysrSbZOVlYXXXnsNALBq1SqMGDHClu3fgQMHFzaiVqUSRRE5OTkYNWoUJEnC1KlTkZaWhrlz5yIzMxNZWVm4++67cfvtt8Pr9aJjx45YsWJFtJbjwIGDFoALjtO4U6dOiIuLa3G5nBMnTrSoNbW09QDOmiJFS17ToUOHUFFxDkO35ALEVVdd1dxLMKGlramlrYcQZ02R4mJe0wVRpXLgwMHFAcfgOHDgoMlwQRqc7Ozs5l6CCS1tTS1tPYCzpkhxMa/pgksaO3Dg4MLFBenhOHDg4MKEY3AcOHDQZGiRBufkyZO4/vrr0bt3b1x//fU4deqUaZvNmzejX79+6n+tWrXCf//7XwDAXXfdhZ49e6rv5efnN8maAEAQBPVztZ3VBw8exIABA+D1enHzzTfD7/c3yZry8/MxaNAgpKWloW/fvjr6j/N5ns6F++ixxx6D1+vFz372M3z00UeNXkND1/TMM88gNTUVffv2xciRI3H48GH1PavfMZrr+fe//43LLrtM/dxly5ap77322mvo3bs3evfurXbnN8Wa/vSnP6nr6dOnD9q3b6++16hzdF6K6+cZM2fOJI899hghhJDHHnuMzJo1y3b7yspK0qFDB1JTU0MIIeTOO+8k7777brOsKS4ujvn6xIkTydtvv00IIeR3v/sdefHFF5tkTd999x3Zv38/IYSQ8vJy0rVrV3Lq1ClCyPk7T8FgkKSkpJDvv/+e+Hw+0rdvX1JUVKTbZsmSJeR3v/sdIYSQt99+m0yaNIkQQkhRURHp27cvqaurIwcOHCApKSkkGAw2yZo2bdqkXjMvvviiuiZCrH/HaK7n1VdfJdOnTzftW1lZSXr27EkqKyvJyZMnSc+ePcnJkyebZE1aPP/88+S3v/2t+ndjzlGL9HC0PDl33nmn6rlYYdWqVbjxxhsRGxvbYtakBSEEmzZtwoQJExq1/7msqU+fPujduzcAICEhAZ07dz7vFB/nwn2Um5uLyZMnw+PxoGfPnvB6vdi1a1eTrGn48OHqNTNw4ECUlZWd8+eey3qs8NFHH+H6669Hx44d0aFDB1x//fVYv359k6/p7bffxi233HJOn9kiDc7x48dx+eWXAwC6du2K48eP226/YsUK04n461//ir59++JPf/oTfL5zlyKJdE11dXXIzMzEwIEDVQNQWVmJ9u3bQxSV0TUWN1A010Sxa9cu+P1+9OrVS33tfJync+E+imTfaK1Ji5dffhk33nij+jfrd2yK9bz33nvo27cvJkyYoDIptIRzdPjwYRw8eBAjRoxQX2vMOWo25c3rrrsOx44dM73+6KOP6v7mOM52gvyHH37AN998g1GjRqmvPfbYY+jatSv8fj+ys7PxxBNPYO7cuU2ypsOHDyMxMREHDhzAiBEj8Itf/ALt2jVe0vZ8nqfbb78dr732Gnheec409jxdbHjzzTeRl5eHTz/9VH2N9TtqDXU0MG7cONxyyy3weDz45z//iTvvvBObNm2K6mdGihUrVmDChAkQNJLNjTlHzWZwPvnkE8v3unTpgh9++AGXX345fvjhB3Tu3Nly25UrV+J//ud/4HK51NfoU9/j8eC3v/0tnnrqqSZbE+X8SUlJwbBhw/D1119j/PjxOH36NILBIERRZHIDRXNNP/30E8aMGYNHH30UAwcOVF9v7HkyoiHcR0lJSTruo0j2jdaaAOX8Pvroo/j000/h8Xh0+wP63/FcDE4k69FyQU2bNg2zZs1S992yZYtu32HDhjV6LQ1ZE8WKFSuwZMkS0/5AA89RI3JNUcfDDz+sS4bOnDnTctsBAwaQTZs26V47evQoIYQQWZbJAw88QGbPnt0kazp58iSpq6sjhBBy4sQJ4vV61STchAkTdEnjJUuWNMmafD4fGTFiBHn22WdN752v8xQIBEjPnj3JgQMH1ORjYWGhbpucnBxd0njixImEEEIKCwt1SeOePXuel6RxJGv66quvSEpKippUp7D7HaO5Hvp7EELIf/7zHzJgwABCiJI07tGjBzl58iQ5efIk6dGjB6msrDyn9US6JkII+fbbb0n37t2JLMvqa409Ry3S4FRUVJARI0YQr9dLRo4cqZ7c3bt3k7vvvlvd7uDBgyQhIYFIkqTbf/jw4SQ9PZ2kpaWRW2+9lZw5c6ZJ1rRjxw6Snp5O+vbtS9LT08myZcvU/b///nvSv39/0qtXLzJhwgT1x4r2mt544w0iiiLJyMhQ//v6668JIef3PK1bt4707t2bpKSkkL/97W+EEELmzJlDcnNzCSGE1NbWkgkTJpBevXqR/v37k++//17d929/+xtJSUkhffr0IR988EGj19DQNY0cOZJ07txZPS/jxo0jhNj/jtFczyOPPEJSU1NJ3759ybBhw8i3336r7vvyyy+TXr16kV69epFXXnnlvKwnkjURQsi8efNMD6PGniNntMGBAwdNhhZZpXLgwMHFCcfgOHDgoMngGBwHDhw0GRyD48CBgyaDY3AcOHDQZHAMjgMHDpoMjsFx4MBBk8ExOA6ijt27d6Nv376oq6tDTU0N0tLSUFhY2NzLctAMcBr/HDQJ/u///g91dXWora1FUlIS/vznPzf3khw0AxyD46BJ4Pf70b9/f7Rq1QqfffaZburYwaUDJ6Ry0CSorKxEdXU1zpw5g7q6uuZejoNmguPhOGgSZGVlYfLkyTh48CB++OEH5OTkNPeSHDQDmo0Px8Glg9dffx0ulwtTpkyBJEm45pprsGnTJh17nINLA46H48CBgyaDk8Nx4MBBk8ExOA4cOGgyOAbHgQMHTQbH4Dhw4KDJ4BgcBw4cNBkcg+PAgYMmg2NwHDhw0GT4/6OambdgA0U8AAAAAElFTkSuQmCC",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -126,7 +126,7 @@
     }
    ],
    "source": [
-    "dispatch_id = ct.lattice(generate_flat_spacetime).dispatch(num_elements=1000, dim=2)\n",
+    "dispatch_id = ct.dispatch(ct.lattice(generate_flat_spacetime))(num_elements=1000, dim=2)\n",
     "coordinates = ct.get_result(dispatch_id, wait=True).result\n",
     "visualize_spacetime(coordinates)"
    ]
@@ -358,7 +358,7 @@
     "}\n",
     "\n",
     "# Visualize workflow graph on the GUI\n",
-    "dispatch_id = generate_training_data.dispatch(\n",
+    "dispatch_id = ct.dispatch(generate_training_data)(\n",
     "    nsamples=nsamples, \n",
     "    num_elements=size, \n",
     "    dimensions=dims\n",
@@ -505,7 +505,7 @@
    ],
    "source": [
     "# Summarize the model using synchronous dispatch\n",
-    "model = ct.lattice(construct_model).dispatch_sync(layers=layer_sizes).result\n",
+    "model = ct.dispatch_sync(ct.lattice(construct_model))(layers=layer_sizes).result\n",
     "print(model.summary())"
    ]
   },
@@ -603,7 +603,7 @@
     "    dimensions=dims\n",
     ")\n",
     "\n",
-    "spacetime_learning_workflow.dispatch_sync(\n",
+    "ct.dispatch_sync(spacetime_learning_workflow)(\n",
     "    arch=layer_sizes, \n",
     "    training_predictors=training_predictors, \n",
     "    training_classes=training_classes, \n",
@@ -659,7 +659,7 @@
     "    return model, history\n",
     "\n",
     "# Dispatch the full workflow\n",
-    "model, history = spacetime_classifier.dispatch_sync(\n",
+    "model, history = ct.dispatch_sync(spacetime_classifier)(\n",
     "    nsamples=nsamples, \n",
     "    size=size, \n",
     "    dims=dims, \n",
@@ -695,7 +695,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -765,7 +765,7 @@
     "    \n",
     "    return test_accuracy\n",
     "\n",
-    "accuracy = test_model.dispatch_sync(\n",
+    "accuracy = ct.dispatch_sync(test_model)(\n",
     "    model=model, \n",
     "    nsamples=nsamples, \n",
     "    num_elements=size, \n",


Test patch:
diff --git a/tests/covalent_dispatcher_tests/_core/init_test.py b/tests/covalent_dispatcher_tests/_core/init_test.py
index 6d6070653..55ccf2525 100644
--- a/tests/covalent_dispatcher_tests/_core/init_test.py
+++ b/tests/covalent_dispatcher_tests/_core/init_test.py
@@ -23,11 +23,10 @@
 """
 
 import cloudpickle as pickle
-import covalent as ct
 
-from covalent_dispatcher._core import _plan_workflow
+import covalent as ct
 from covalent._results_manager import Result
-from covalent._results_manager import results_manager as rm
+from covalent_dispatcher._core.execution import _plan_workflow
 
 TEST_RESULTS_DIR = "/tmp/results"
 
@@ -43,7 +42,6 @@ def task(x):
         print("Error!", file=sys.stderr)
         return x
 
-
     @ct.lattice(results_dir=TEST_RESULTS_DIR)
     def pipeline(x):
         return task(x)
@@ -58,8 +56,7 @@ def pipeline(x):
 
 
 def test_plan_workflow():
-    """Test workflow planning method.
-    """
+    """Test workflow planning method."""
 
     mock_result = get_mock_result()
     _plan_workflow(result_object=mock_result)
@@ -67,4 +64,4 @@ def test_plan_workflow():
     # Updated transport graph post planning
     updated_tg = pickle.loads(mock_result.lattice.transport_graph.serialize(metadata_only=True))
 
-    assert 'results_dir' in updated_tg['nodes'][0]['exec_plan'].execution_args
+    assert "results_dir" in updated_tg["nodes"][0]["exec_plan"].execution_args
diff --git a/tests/covalent_dispatcher_tests/choose_conda_test.py b/tests/covalent_dispatcher_tests/choose_conda_test.py
index 29b4efccc..7cdd72d4f 100644
--- a/tests/covalent_dispatcher_tests/choose_conda_test.py
+++ b/tests/covalent_dispatcher_tests/choose_conda_test.py
@@ -23,6 +23,7 @@
 """
 
 import covalent as ct
+import covalent._results_manager.results_manager as rm
 
 
 def test_using_current_env() -> None:
@@ -47,7 +48,9 @@ def passthrough(x):
     def workflow(y):
         return passthrough(x=y)
 
-    dispatch_id = workflow.dispatch(y="input")
+    dispatch_id = ct.dispatch(workflow)(y="input")
     output = ct.get_result(dispatch_id, wait=True)
 
+    rm._delete_result(dispatch_id)
+
     assert output.result == "input"
diff --git a/tests/covalent_tests/choose_executor_test.py b/tests/covalent_tests/choose_executor_test.py
index 091d466c0..80ff57022 100644
--- a/tests/covalent_tests/choose_executor_test.py
+++ b/tests/covalent_tests/choose_executor_test.py
@@ -24,6 +24,7 @@
 
 
 import covalent as ct
+import covalent._results_manager.results_manager as rm
 
 
 def test_executors_exist():
@@ -47,9 +48,11 @@ def passthrough(x):
         def workflow(y):
             return passthrough(x=y)
 
-        dispatch_id = workflow.dispatch(y="input")
+        dispatch_id = ct.dispatch(workflow)(y="input")
         output = ct.get_result(dispatch_id, wait=True)
 
+        rm._delete_result(dispatch_id)
+
         assert output.result == "input"
 
 
@@ -70,9 +73,11 @@ def workflow(y):
 
         output = ""
         try:
-            dispatch_id = workflow.dispatch(y="input")
+            dispatch_id = ct.dispatch(workflow)(y="input")
             output = ct.get_result(dispatch_id, wait=True)
         except:
             pass
 
+        rm._delete_result(dispatch_id)
+
         assert output.result == "input"
diff --git a/tests/covalent_tests/dispatcher_plugins/__init__.py b/tests/covalent_tests/dispatcher_plugins/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/covalent_tests/dispatcher_plugins/base_test.py b/tests/covalent_tests/dispatcher_plugins/base_test.py
new file mode 100644
index 000000000..b3751c8c7
--- /dev/null
+++ b/tests/covalent_tests/dispatcher_plugins/base_test.py
@@ -0,0 +1,67 @@
+# Copyright 2021 Agnostiq Inc.
+#
+# This file is part of Covalent.
+#
+# Licensed under the GNU Affero General Public License 3.0 (the "License").
+# A copy of the License may be obtained with this software package or at
+#
+#      https://www.gnu.org/licenses/agpl-3.0.en.html
+#
+# Use of this file is prohibited except in compliance with the License. Any
+# modifications or derivative works of this file must retain this copyright
+# notice, and modified files must contain a notice indicating that they have
+# been altered from the originals.
+#
+# Covalent is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the License for more details.
+#
+# Relief from the License may be granted by purchasing a commercial license.
+
+import pytest
+
+from covalent._dispatcher_plugins.base import BaseDispatcher
+from covalent._results_manager.result import Result
+
+
+def test_dispatcher_creation_with_dispatch_functions():
+    """
+    Test that the dispatcher class can be created with the
+    `dispatch` and `dispatch_sync` methods.
+    """
+
+    class TestDispatcher(BaseDispatcher):
+        """
+        A test dispatcher class.
+        """
+
+        def dispatch(self) -> None:
+            """
+            Test dispatch wrapper.
+            """
+
+            pass
+
+        def dispatch_sync(self) -> Result:
+            """
+            Test dispatch_sync wrapper.
+            """
+
+            pass
+
+    assert TestDispatcher()
+
+
+def test_dispatcher_creation_wo_dispatch_functions():
+    """
+    Test that the dispatcher class cannot be created without the
+    `dispatch` and `dispatch_sync` method.
+    """
+
+    class TestDispatcher(BaseDispatcher):
+        """
+        A test dispatcher class.
+        """
+
+    with pytest.raises(TypeError):
+        TestDispatcher()
diff --git a/tests/covalent_tests/dispatcher_plugins/local_test.py b/tests/covalent_tests/dispatcher_plugins/local_test.py
new file mode 100644
index 000000000..4fc0734fb
--- /dev/null
+++ b/tests/covalent_tests/dispatcher_plugins/local_test.py
@@ -0,0 +1,50 @@
+# Copyright 2021 Agnostiq Inc.
+#
+# This file is part of Covalent.
+#
+# Licensed under the GNU Affero General Public License 3.0 (the "License").
+# A copy of the License may be obtained with this software package or at
+#
+#      https://www.gnu.org/licenses/agpl-3.0.en.html
+#
+# Use of this file is prohibited except in compliance with the License. Any
+# modifications or derivative works of this file must retain this copyright
+# notice, and modified files must contain a notice indicating that they have
+# been altered from the originals.
+#
+# Covalent is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the License for more details.
+#
+# Relief from the License may be granted by purchasing a commercial license.
+
+import covalent as ct
+from covalent._dispatcher_plugins.local import LocalDispatcher
+
+dispatcher = LocalDispatcher()
+
+
+@ct.electron
+def add(a, b):
+    return a + b
+
+
+@ct.lattice
+def workflow(x, y):
+    res = add(x, y)
+    return add(res, y)
+
+
+def test_local_dispatcher_dispatch():
+    """Tests whether the local dispatcher can dispatch a workflow successfully."""
+
+    dispatch_id = dispatcher.dispatch(workflow)(1, 2)
+
+    assert isinstance(dispatch_id, str)
+
+
+def test_local_dispatcher_dispatch_sync():
+    """Tests whether the local dispatcher can synchronously dispatch a workflow successfully."""
+
+    result = dispatcher.dispatch_sync(workflow)(1, 2)
+    assert result.result == 5
diff --git a/tests/electron_return_value_test.py b/tests/electron_return_value_test.py
index 6cbfa6248..a17d23e69 100644
--- a/tests/electron_return_value_test.py
+++ b/tests/electron_return_value_test.py
@@ -104,7 +104,7 @@ def type_conversion_test_dict(a):
 def test_arithmetic_1(test_operand, expected):
     """Test arithmetic operations"""
 
-    dispatch_id = arithmetic_test_1.dispatch(a=2, operand=test_operand)
+    dispatch_id = ct.dispatch(arithmetic_test_1)(a=2, operand=test_operand)
 
     res = get_result(dispatch_id, wait=True)
     _delete_result(dispatch_id)
@@ -116,7 +116,7 @@ def test_arithmetic_1(test_operand, expected):
 def test_arithmetic_1_rev(test_operand, expected):
     """Test reverse arithmetic operations"""
 
-    dispatch_id = arithmetic_test_1_rev.dispatch(a=2, operand=test_operand)
+    dispatch_id = ct.dispatch(arithmetic_test_1_rev)(a=2, operand=test_operand)
 
     res = get_result(dispatch_id, wait=True)
     _delete_result(dispatch_id)
@@ -130,7 +130,7 @@ def test_arithmetic_1_rev(test_operand, expected):
 def test_arithmetic_2(test_b, test_operand, expected):
     """Test arithmetic operations"""
 
-    dispatch_id = arithmetic_test_2.dispatch(a=2, b=test_b, operand=test_operand)
+    dispatch_id = ct.dispatch(arithmetic_test_2)(a=2, b=test_b, operand=test_operand)
 
     res = get_result(dispatch_id, wait=True)
     _delete_result(dispatch_id)
@@ -142,7 +142,7 @@ def test_arithmetic_2(test_b, test_operand, expected):
 def test_type_conversion_numbers(test_type_to):
     """Test type conversion for number types"""
 
-    dispatch_id = type_conversion_test_numbers.dispatch(a=2, type_to=test_type_to)
+    dispatch_id = ct.dispatch(type_conversion_test_numbers)(a=2, type_to=test_type_to)
 
     res = get_result(dispatch_id, wait=True)
     _delete_result(dispatch_id)
@@ -154,7 +154,7 @@ def test_type_conversion_numbers(test_type_to):
 def test_type_conversion_iterables(test_type_to):
     """Test type conversion for iterables"""
 
-    dispatch_id = type_conversion_test_iterables.dispatch(a=[2], type_to=test_type_to)
+    dispatch_id = ct.dispatch(type_conversion_test_iterables)(a=[2], type_to=test_type_to)
 
     res = get_result(dispatch_id, wait=True)
     _delete_result(dispatch_id)
@@ -165,7 +165,7 @@ def test_type_conversion_iterables(test_type_to):
 def test_type_conversion_dict():
     """Test type conversion for dictionary"""
 
-    dispatch_id = type_conversion_test_dict.dispatch(a={"x": 2})
+    dispatch_id = ct.dispatch(type_conversion_test_dict)(a={"x": 2})
 
     res = get_result(dispatch_id, wait=True)
     _delete_result(dispatch_id)
diff --git a/tests/functional_tests/basic_dispatcher_test.py b/tests/functional_tests/basic_dispatcher_test.py
index 476424d6b..a3634500a 100644
--- a/tests/functional_tests/basic_dispatcher_test.py
+++ b/tests/functional_tests/basic_dispatcher_test.py
@@ -68,17 +68,19 @@ def bad_workflow(name):
 def test_dispatcher_functional():
     # Dispatch after starting the dispatcher server.
 
-    dispatch_id = workflow.dispatch(name="q")
+    dispatch_id = ct.dispatch(workflow)(name="q")
     output = ct.get_result(dispatch_id, wait=True).result
 
     assert output == "aqbq"
 
     try:
-        output = bad_workflow.dispatch("z")
+        output = ct.dispatch(bad_workflow)("z")
     except Exception as ex:
         print(f"Exception thrown for dispatching bad workflow as {ex}.")
         output = "failed"
 
+    rm._delete_result(dispatch_id)
+
     assert output == "failed"
 
     Path(the_executor.log_stdout).unlink(missing_ok=True)
@@ -98,9 +100,11 @@ def square(x):
     def outer_lattice(y):
         return ct.electron(lattice_square)(x=y)
 
-    dispatch_id = outer_lattice.dispatch(y=5)
+    dispatch_id = ct.dispatch(outer_lattice)(y=5)
     output = ct.get_result(dispatch_id, wait=True).result
 
+    rm._delete_result(dispatch_id, results_dir="/tmp/results")
+
     assert output == 25
 
     rm._delete_result(
diff --git a/tests/functional_tests/dispatcher_server_test.py b/tests/functional_tests/dispatcher_server_test.py
index 340a419ab..8eac76492 100644
--- a/tests/functional_tests/dispatcher_server_test.py
+++ b/tests/functional_tests/dispatcher_server_test.py
@@ -19,6 +19,7 @@
 # Relief from the License may be granted by purchasing a commercial license.
 
 import covalent as ct
+import covalent._results_manager.results_manager as rm
 
 
 @ct.electron
@@ -43,7 +44,7 @@ def pipeline(a, b):
 
 def test_dispatcher_server():
     # After the dispatcher server has been started, you can run the following
-    dispatch_id = pipeline.dispatch(a=2, b=1)
+    dispatch_id = ct.dispatch(pipeline)(a=2, b=1)
     assert dispatch_id is not None
 
     # Wait for it to complete
@@ -55,3 +56,5 @@ def test_dispatcher_server():
     assert result.end_time > result.start_time
     assert result.status == ct.status.COMPLETED
     assert result.result == 3
+
+    rm._delete_result(dispatch_id)
diff --git a/tests/functional_tests/serialization_test.py b/tests/functional_tests/serialization_test.py
index 00ec4c63a..91699ce7f 100644
--- a/tests/functional_tests/serialization_test.py
+++ b/tests/functional_tests/serialization_test.py
@@ -38,10 +38,7 @@ def electron_function(x):
 
 
 @etron
-@cova.lattice(
-    results_dir="./",
-    dispatcher="super long fake dispatcher to test really long arguments                                                                                                                                                                                end_fake_dispatcher_name",
-)
+@cova.lattice(results_dir="./")
 def sub_lattice_function(y):
     return y
 
@@ -116,10 +113,7 @@ def test_lattice_object_serialization():
     expected_string = "\n".join(
         [
             "# @etron",
-            "# @cova.lattice(",
-            '#     results_dir="./",',
-            '#     dispatcher="super long fake dispatcher to test really long arguments                                                                                                                                                                                end_fake_dispatcher_name",',
-            "# )",
+            '# @cova.lattice(results_dir="./")',
             "def sub_lattice_function(y):",
             "    return y",
         ]
diff --git a/tests/workflow_stack_test.py b/tests/workflow_stack_test.py
index a7c5d67ea..78bbd45de 100644
--- a/tests/workflow_stack_test.py
+++ b/tests/workflow_stack_test.py
@@ -22,34 +22,34 @@
 
 import os
 
+import covalent as ct
 import covalent._results_manager.results_manager as rm
-from covalent import electron, lattice
 from covalent._results_manager.result import Result
 
 
-@electron
+@ct.electron
 def add(a, b):
     return a + b
 
 
-@electron
+@ct.electron
 def identity(a):
     return a
 
 
-@lattice
+@ct.lattice
 def check(a, b):
     result1 = add(a=a, b=b)
     return identity(a=result1)
 
 
-@lattice
+@ct.lattice
 def check_alt(a, b):
     result1 = add(a=a, b=b)
     return identity(a=result1)
 
 
-@electron
+@ct.electron
 def collect(l_electrons):
     return l_electrons
 
@@ -82,14 +82,14 @@ def test_electron_takes_nested_iterables():
     Test to check whether electron can take in nested dicts and lists
     """
 
-    @lattice
+    @ct.lattice
     def workflow():
         # Use keywords to specify parameters
         a_list = [identity(a=i) for i in range(5)]
         b_list = [identity(a=i) for i in range(5, 10)]
         return collect(l_electrons=[a_list, b_list])
 
-    dispatch_id = workflow.dispatch()
+    dispatch_id = ct.dispatch(workflow)()
 
     assert rm.get_result(dispatch_id, wait=True).result == [
         [0, 1, 2, 3, 4],
@@ -105,14 +105,14 @@ def test_sublatticing():
     and used inside of a bigger lattice.
     """
 
-    sublattice_add = lattice(add)
+    sublattice_add = ct.lattice(add)
 
-    @lattice
+    @ct.lattice
     def workflow(a, b):
-        res_1 = electron(sublattice_add)(a=a, b=b)
+        res_1 = ct.electron(sublattice_add)(a=a, b=b)
         return identity(a=res_1)
 
-    dispatch_id = workflow.dispatch(a=1, b=2)
+    dispatch_id = ct.dispatch(workflow)(a=1, b=2)
 
     workflow_result = rm.get_result(dispatch_id, wait=True)
 
@@ -131,16 +131,16 @@ def test_parallelization():
     import timeit
 
     SETUP_CODE = """
-from covalent import electron, lattice
+import covalent as ct
 
-@electron
+@ct.electron
 def heavy_function(a):
     import time
 
     time.sleep(1)
     return a
 
-@lattice
+@ct.lattice
 def workflow(x=10):
     for i in range(x):
         heavy_function(a=i)
@@ -148,7 +148,7 @@ def workflow(x=10):
 """
 
     TEST_CODE_1 = "workflow()"
-    TEST_CODE_2 = "workflow.dispatch_sync()"
+    TEST_CODE_2 = "ct.dispatch_sync(workflow)()"
 
     time_for_normal = timeit.timeit(
         setup=SETUP_CODE,
@@ -171,15 +171,15 @@ def test_electrons_with_positional_args():
     inside a lattice.
     """
 
-    @electron
+    @ct.electron
     def test_func(a, b):
         return a + b
 
-    @lattice
+    @ct.lattice
     def workflow(a, b):
         return test_func(a, b)
 
-    dispatch_id = workflow.dispatch(a=1, b=2)
+    dispatch_id = ct.dispatch(workflow)(a=1, b=2)
 
     workflow_result = rm.get_result(dispatch_id, wait=True)
 
@@ -193,15 +193,15 @@ def test_lattice_with_positional_args():
     Test to check whether the lattice can be dispatched with positional arguments.
     """
 
-    @electron
+    @ct.electron
     def test_func(a, b):
         return a + b
 
-    @lattice
+    @ct.lattice
     def workflow(a, b):
         return test_func(a=a, b=b)
 
-    dispatch_id = workflow.dispatch(1, 2)
+    dispatch_id = ct.dispatch(workflow)(1, 2)
 
     workflow_result = rm.get_result(dispatch_id, wait=True)
 
@@ -215,15 +215,15 @@ def test_positional_args_integration():
     Test whether positional and keyword arguments work together in both lattice and electrons.
     """
 
-    @electron
+    @ct.electron
     def new_func(a, b, c, d, e):
         return a + b + c + d + e
 
-    @lattice
+    @ct.lattice
     def work_func(a, b, c):
         return new_func(a, b, c, d=4, e=5)
 
-    dispatch_id = work_func.dispatch(1, 2, c=3)
+    dispatch_id = ct.dispatch(work_func)(1, 2, c=3)
 
     workflow_result = rm.get_result(dispatch_id, wait=True)
 
@@ -238,17 +238,17 @@ def test_stdout_stderr_redirection():
     """
     import sys
 
-    @electron
+    @ct.electron
     def test_func(a, b):
         print(a)
         print(b, file=sys.stderr)
         return a + b
 
-    @lattice
+    @ct.lattice
     def work_func(a, b):
         return test_func(a, b)
 
-    dispatch_id = work_func.dispatch(1, 2)
+    dispatch_id = ct.dispatch(work_func)(1, 2)
 
     workflow_result = rm.get_result(dispatch_id, wait=True)
 
@@ -285,7 +285,7 @@ def circuit(params):
     def workflow():
         return circuit([0.54, 0.12])
 
-    dispatch_id = workflow.dispatch()
+    dispatch_id = ct.dispatch(workflow)()
     workflow_result = rm.get_result(dispatch_id, wait=True)
 
     rm._delete_result(dispatch_id)
@@ -300,23 +300,23 @@ def test_dispatch_cancellation():
 
     import time
 
-    @electron
+    @ct.electron
     def task_1():
         time.sleep(4)
         print("Task 1")
         return 5
 
-    @electron
+    @ct.electron
     def task_2(x):
         time.sleep(x)
         print("Task 2")
 
-    @lattice
+    @ct.lattice
     def workflow():
         task_2(task_1())
         return 10
 
-    dispatch_id = workflow.dispatch()
+    dispatch_id = ct.dispatch(workflow)()
     result = rm.get_result(dispatch_id)
 
     assert result.status in [Result.RUNNING, Result.NEW_OBJ]
@@ -325,4 +325,6 @@ def workflow():
 
     result = rm.get_result(dispatch_id, wait=True)
 
+    rm._delete_result(dispatch_id)
+
     assert result.status == Result.CANCELLED