diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 501f00439..3c6efca5b 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -66,11 +66,11 @@ jobs:
       - name: Generate developer docs
         run: |
           pdoc \
-          --logo https://bioimage.io/static/img/bioimage-io-logo.svg \
-          --logo-link https://bioimage.io/ \
-          --favicon https://bioimage.io/static/img/bioimage-io-icon-small.svg \
-          --footer-text 'bioimageio.spec ${{steps.get_version.outputs.version}}' \
-          -o ./dist bioimageio.spec
+          --logo "https://bioimage.io/static/img/bioimage-io-logo.svg" \
+          --logo-link "https://bioimage.io/" \
+          --favicon "https://bioimage.io/static/img/bioimage-io-icon-small.svg" \
+          --footer-text "bioimageio.spec ${{steps.get_version.outputs.version}}" \
+          -o ./dist bioimageio.spec bioimageio.spec._internal
       - name: copy legacy file until BioImage.IO-packager is updated  # TODO: remove if packager does not depend on it anymore
         run: cp weight_formats_spec.json ./dist/weight_formats_spec.json
       - name: Get branch name to deploy to
diff --git a/README.md b/README.md
index 68c70923f..2e3f69e70 100644
--- a/README.md
+++ b/README.md
@@ -105,6 +105,13 @@ Made with [contrib.rocks](https://contrib.rocks).
 
 ### bioimageio.spec Python package
 
+#### bioimageio.spec 0.5.3post1
+
+* bump patch version during loading for model 0.5.x
+* improve validation error formatting
+* validate URLs first with a head request, if forbidden, follow up with a get request that is streamed and if that is also forbidden a regular get request.
+* `RelativePath.absolute()` is now a method (not a property) analog to `pathlib.Path`
+
 #### bioimageio.spec 0.5.3
 
 * remove collection description
diff --git a/bioimageio/spec/VERSION b/bioimageio/spec/VERSION
index 5e0138be3..ca0cb298f 100644
--- a/bioimageio/spec/VERSION
+++ b/bioimageio/spec/VERSION
@@ -1,3 +1,3 @@
 {
-    "version": "0.5.3"
+    "version": "0.5.3post1"
 }
diff --git a/bioimageio/spec/_internal/__init__.py b/bioimageio/spec/_internal/__init__.py
index 6a9a2c07e..0a5271434 100644
--- a/bioimageio/spec/_internal/__init__.py
+++ b/bioimageio/spec/_internal/__init__.py
@@ -1 +1,3 @@
+"""internal helper modules; do not use outside of bioimageio.spec!"""
+
 from ._settings import settings as settings
diff --git a/bioimageio/spec/_internal/common_nodes.py b/bioimageio/spec/_internal/common_nodes.py
index bbe464965..866cbc6f4 100644
--- a/bioimageio/spec/_internal/common_nodes.py
+++ b/bioimageio/spec/_internal/common_nodes.py
@@ -54,7 +54,7 @@
 from .io import BioimageioYamlContent
 from .node import Node as Node
 from .url import HttpUrl
-from .utils import assert_all_params_set_explicitly
+from .utils import assert_all_params_set_explicitly, get_format_version_tuple
 from .validation_context import (
     ValidationContext,
     validation_context_var,
@@ -282,34 +282,21 @@ class ResourceDescrBase(
     @model_validator(mode="before")
     @classmethod
     def _ignore_future_patch(cls, data: Union[Dict[Any, Any], Any], /) -> Any:
-        if not isinstance(data, dict) or "format_version" not in data:
+        if (
+            cls.implemented_format_version == "unknown"
+            or not isinstance(data, dict)
+            or "format_version" not in data
+        ):
             return data
 
         value = data["format_version"]
-
-        def get_maj(v: str):
-            parts = v.split(".")
-            if parts and (p := parts[0]).isdecimal():
-                return int(p)
-            else:
-                return 0
-
-        def get_min_patch(v: str):
-            parts = v.split(".")
-            if len(parts) == 3:
-                _, m, p = parts
-                if m.isdecimal() and p.isdecimal():
-                    return int(m), int(p)
-
-            return (0, 0)
+        fv = get_format_version_tuple(value)
+        if fv is None:
+            return data
 
         if (
-            cls.implemented_format_version != "unknown"
-            and value != cls.implemented_format_version
-            and isinstance(value, str)
-            and value.count(".") == 2
-            and get_maj(value) == cls.implemented_format_version_tuple[0]
-            and get_min_patch(value) > cls.implemented_format_version_tuple[1:]
+            fv[0] == cls.implemented_format_version_tuple[0]
+            and fv[1:] > cls.implemented_format_version_tuple[1:]
         ):
             issue_warning(
                 "future format_version '{value}' treated as '{implemented}'",
@@ -364,13 +351,11 @@ def __pydantic_init_subclass__(cls, **kwargs: Any):
             if "." not in cls.implemented_format_version:
                 cls.implemented_format_version_tuple = (0, 0, 0)
             else:
-                cls.implemented_format_version_tuple = cast(
-                    Tuple[int, int, int],
-                    tuple(int(x) for x in cls.implemented_format_version.split(".")),
-                )
-            assert (
-                len(cls.implemented_format_version_tuple) == 3
-            ), cls.implemented_format_version_tuple
+                fv_tuple = get_format_version_tuple(cls.implemented_format_version)
+                assert (
+                    fv_tuple is not None
+                ), f"failed to cast '{cls.implemented_format_version}' to tuple"
+                cls.implemented_format_version_tuple = fv_tuple
 
     @classmethod
     def load(
diff --git a/bioimageio/spec/_internal/io.py b/bioimageio/spec/_internal/io.py
index f45ccebf3..ebde16e97 100644
--- a/bioimageio/spec/_internal/io.py
+++ b/bioimageio/spec/_internal/io.py
@@ -8,6 +8,7 @@
 from datetime import date as _date
 from datetime import datetime as _datetime
 from functools import lru_cache
+from math import ceil
 from pathlib import Path, PurePath
 from typing import (
     Any,
@@ -42,6 +43,7 @@
     model_validator,
 )
 from pydantic_core import core_schema
+from tqdm import tqdm
 from typing_extensions import (
     Annotated,
     LiteralString,
@@ -87,9 +89,13 @@ class RelativePathBase(RootModel[PurePath], Generic[AbsolutePathT], frozen=True)
     def path(self) -> PurePath:
         return self.root
 
-    @property
-    def absolute(self) -> AbsolutePathT:
-        """the absolute path/url (resolved at time of initialization with the root of the ValidationContext)"""
+    def absolute(  # method not property analog to `pathlib.Path.absolute()`
+        self,
+    ) -> AbsolutePathT:
+        """get the absolute path/url
+
+        (resolved at time of initialization with the root of the ValidationContext)
+        """
         return self._absolute
 
     def model_post_init(self, __context: Any) -> None:
@@ -223,10 +229,10 @@ def get_absolute(
 
 
 FileSource = Annotated[
-    Union[HttpUrl, RelativeFilePath, pydantic.HttpUrl, FilePath],
+    Union[HttpUrl, RelativeFilePath, FilePath],
     Field(union_mode="left_to_right"),
 ]
-PermissiveFileSource = Union[FileSource, str]
+PermissiveFileSource = Union[FileSource, str, pydantic.HttpUrl]
 
 V_suffix = TypeVar("V_suffix", bound=FileSource)
 path_or_url_adapter = TypeAdapter(Union[FilePath, DirectoryPath, HttpUrl])
@@ -353,7 +359,7 @@ def _package(value: FileSource, info: SerializationInfo) -> Union[str, Path, Fil
     # package the file source:
     # add it to the current package's file sources and return its collision free file name
     if isinstance(value, RelativeFilePath):
-        src = value.absolute
+        src = value.absolute()
     elif isinstance(value, pydantic.AnyUrl):
         src = HttpUrl(str(value))
     elif isinstance(value, HttpUrl):
@@ -502,13 +508,10 @@ class HashKwargs(TypedDict):
     sha256: NotRequired[Optional[Sha256]]
 
 
-StrictFileSource = Annotated[
-    Union[HttpUrl, FilePath, RelativeFilePath], Field(union_mode="left_to_right")
-]
-_strict_file_source_adapter = TypeAdapter(StrictFileSource)
+_file_source_adapter = TypeAdapter(FileSource)
 
 
-def interprete_file_source(file_source: PermissiveFileSource) -> StrictFileSource:
+def interprete_file_source(file_source: PermissiveFileSource) -> FileSource:
     if isinstance(file_source, (HttpUrl, Path)):
         return file_source
 
@@ -516,7 +519,7 @@ def interprete_file_source(file_source: PermissiveFileSource) -> StrictFileSourc
         file_source = str(file_source)
 
     with validation_context_var.get().replace(perform_io_checks=False):
-        strict = _strict_file_source_adapter.validate_python(file_source)
+        strict = _file_source_adapter.validate_python(file_source)
 
     return strict
 
@@ -553,7 +556,7 @@ def download(
 
     strict_source = interprete_file_source(source)
     if isinstance(strict_source, RelativeFilePath):
-        strict_source = strict_source.absolute
+        strict_source = strict_source.absolute()
 
     if isinstance(strict_source, PurePath):
         if not strict_source.exists():
@@ -652,12 +655,17 @@ def extract_file_name(
 def get_sha256(path: Path) -> Sha256:
     """from https://stackoverflow.com/a/44873382"""
     h = hashlib.sha256()
-    b = bytearray(128 * 1024)
+    chunksize = 128 * 1024
+    b = bytearray(chunksize)
     mv = memoryview(b)
+    desc = f"computing SHA256 of {path.name}"
+    pbar = tqdm(desc=desc, total=ceil(path.stat().st_size / chunksize))
     with open(path, "rb", buffering=0) as f:
         for n in iter(lambda: f.readinto(mv), 0):
             h.update(mv[:n])
-
+            _ = pbar.update()
     sha = h.hexdigest()
+
+    pbar.set_description(desc=desc + f" (result: {sha})")
     assert len(sha) == 64
     return Sha256(sha)
diff --git a/bioimageio/spec/_internal/io_utils.py b/bioimageio/spec/_internal/io_utils.py
index dba88c8a2..7c3d17725 100644
--- a/bioimageio/spec/_internal/io_utils.py
+++ b/bioimageio/spec/_internal/io_utils.py
@@ -1,15 +1,15 @@
 import io
 import warnings
 from contextlib import nullcontext
-from functools import lru_cache
+from dataclasses import dataclass
 from pathlib import Path
+from types import MappingProxyType
 from typing import (
     IO,
     Any,
     Dict,
     List,
     Mapping,
-    NamedTuple,
     Optional,
     TextIO,
     Union,
@@ -28,6 +28,7 @@
 from ._settings import settings
 from .io import (
     BIOIMAGEIO_YAML,
+    SLOTS,
     BioimageioYamlContent,
     FileDescr,
     HashKwargs,
@@ -38,6 +39,7 @@
 )
 from .io_basics import FileName, Sha256
 from .types import FileSource, PermissiveFileSource
+from .utils import cache
 
 yaml = YAML(typ="safe")
 
@@ -113,9 +115,9 @@ def open_bioimageio_yaml(
 
         entry = collection[source]
         logger.info(
-            "{} loading {} {} from {}",
+            "{} loading {}/{} from {}",
             entry.emoji,
-            f"{entry.id}/{entry.version}",
+            entry.id,
             entry.version,
             entry.url,
         )
@@ -136,17 +138,32 @@ def open_bioimageio_yaml(
     return OpenedBioimageioYaml(content, root, downloaded.original_file_name)
 
 
-class _CollectionEntry(NamedTuple):
+@dataclass(frozen=True, **SLOTS)
+class CollectionEntry:
+    """collection entry
+
+    note: The BioImage.IO collection is still under development;
+          this collection entry might change in the future!
+    """
+
     id: str
+    """concept id of the resource; to identify a resource version use <id>/<version>.
+    See `version` below."""
+    version: str
+    """version. To identify a resource version use <id>/<version> for reference"""
     emoji: str
+    """a Unicode emoji string symbolizing this resource"""
     url: str
+    """Resource Description File (RDF) URL"""
     sha256: Optional[Sha256]
-    version: str
+    """SHA256 hash value of RDF"""
     doi: Optional[str]
+    """DOI (regsitered through zenodo.org)
+    as alternative reference of this bioimage.io upload."""
 
 
 def _get_one_collection(url: str):
-    ret: Dict[str, _CollectionEntry] = {}
+    ret: Dict[str, CollectionEntry] = {}
     if not isinstance(url, str) or "/" not in url:
         logger.error("invalid collection url: {}", url)
     try:
@@ -162,9 +179,12 @@ def _get_one_collection(url: str):
         return ret
 
     for raw_entry in collection:
+        assert isinstance(raw_entry, dict), type(raw_entry)
+        v: Any
+        d: Any
         try:
             for i, (v, d) in enumerate(zip(raw_entry["versions"], raw_entry["dois"])):
-                entry = _CollectionEntry(
+                entry = CollectionEntry(
                     id=raw_entry["id"],
                     emoji=raw_entry.get("id_emoji", raw_entry.get("nickname_icon", "")),
                     url=raw_entry["rdf_source"],
@@ -199,8 +219,8 @@ def _get_one_collection(url: str):
     return ret
 
 
-@lru_cache
-def get_collection() -> Mapping[str, _CollectionEntry]:
+@cache
+def get_collection() -> Mapping[str, CollectionEntry]:
     try:
         if settings.resolve_draft:
             ret = _get_one_collection(settings.collection_draft)
@@ -208,11 +228,12 @@ def get_collection() -> Mapping[str, _CollectionEntry]:
             ret = {}
 
         ret.update(_get_one_collection(settings.collection))
-        return ret
 
     except Exception as e:
         logger.error("failed to get resource id mapping: {}", e)
-        return {}
+        ret = {}
+
+    return MappingProxyType(ret)
 
 
 def unzip(
diff --git a/bioimageio/spec/_internal/root_url.py b/bioimageio/spec/_internal/root_url.py
index c88e8ae97..e767e49e9 100644
--- a/bioimageio/spec/_internal/root_url.py
+++ b/bioimageio/spec/_internal/root_url.py
@@ -15,6 +15,10 @@ class RootHttpUrl(ValidatedString):
     root_model: ClassVar[Type[RootModel[Any]]] = RootModel[pydantic.HttpUrl]
     _validated: pydantic.HttpUrl
 
+    def absolute(self):
+        """analog to `absolute` method of pathlib."""
+        return self
+
     @property
     def scheme(self) -> str:
         return self._validated.scheme
diff --git a/bioimageio/spec/_internal/url.py b/bioimageio/spec/_internal/url.py
index 4705d306f..9bee1d902 100644
--- a/bioimageio/spec/_internal/url.py
+++ b/bioimageio/spec/_internal/url.py
@@ -1,10 +1,11 @@
-from typing import Any, ClassVar, Type, Union
+from typing import Any, ClassVar, Optional, Type, Union
 
 import pydantic
 import requests
 import requests.exceptions
-from pydantic import AfterValidator, RootModel
-from typing_extensions import Annotated
+from loguru import logger
+from pydantic import RootModel, model_validator
+from typing_extensions import Literal, assert_never
 
 from .field_warning import issue_warning
 from .root_url import RootHttpUrl
@@ -12,11 +13,16 @@
 
 
 def _validate_url(url: Union[str, pydantic.HttpUrl]) -> pydantic.AnyUrl:
-    url = str(url)
-    context = validation_context_var.get()
-    if not context.perform_io_checks or url in context.known_files:
-        return pydantic.AnyUrl(url)
+    return _validate_url_impl(url, request_mode="head")
+
 
+def _validate_url_impl(
+    url: Union[str, pydantic.HttpUrl],
+    request_mode: Literal["head", "get_stream", "get"],
+    timeout: int = 3,
+) -> pydantic.AnyUrl:
+
+    url = str(url)
     val_url = url
 
     if url.startswith("https://colab.research.google.com/github/"):
@@ -33,7 +39,14 @@ def _validate_url(url: Union[str, pydantic.HttpUrl]) -> pydantic.AnyUrl:
         )
 
     try:
-        response = requests.get(val_url, stream=True, timeout=3)
+        if request_mode == "head":
+            response = requests.head(val_url, timeout=timeout)
+        elif request_mode == "get_stream":
+            response = requests.get(val_url, stream=True, timeout=timeout)
+        elif request_mode == "get":
+            response = requests.get(val_url, stream=False, timeout=timeout)
+        else:
+            assert_never(request_mode)
     except (
         requests.exceptions.ChunkedEncodingError,
         requests.exceptions.ContentDecodingError,
@@ -75,6 +88,17 @@ def _validate_url(url: Union[str, pydantic.HttpUrl]) -> pydantic.AnyUrl:
                     "location": response.headers.get("location"),
                 },
             )
+        elif response.status_code == 403:  # forbidden
+            if request_mode == "head":
+                return _validate_url_impl(
+                    url, request_mode="get_stream", timeout=timeout
+                )
+            elif request_mode == "get_stream":
+                return _validate_url_impl(url, request_mode="get", timeout=timeout)
+            elif request_mode == "get":
+                raise ValueError(f"{response.status_code}: {response.reason} {url}")
+            else:
+                assert_never(request_mode)
         elif response.status_code == 405:
             issue_warning(
                 "{status_code}: {reason} {value}",
@@ -91,6 +115,28 @@ def _validate_url(url: Union[str, pydantic.HttpUrl]) -> pydantic.AnyUrl:
 
 
 class HttpUrl(RootHttpUrl):
-    root_model: ClassVar[Type[RootModel[Any]]] = RootModel[
-        Annotated[pydantic.HttpUrl, AfterValidator(_validate_url)]
-    ]
+    root_model: ClassVar[Type[RootModel[Any]]] = RootModel[pydantic.HttpUrl]
+    _exists: Optional[bool] = None
+
+    @model_validator(mode="after")
+    def _validate_url(self):
+        url = self._validated
+        context = validation_context_var.get()
+        if context.perform_io_checks and str(url) not in context.known_files:
+            self._validated = _validate_url(url)
+            self._exists = True
+
+        return self
+
+    def exists(self):
+        """True if URL is available"""
+        if self._exists is None:
+            try:
+                self._validated = _validate_url(self._validated)
+            except Exception as e:
+                logger.info(e)
+                self._exists = False
+            else:
+                self._exists = True
+
+        return self._exists
diff --git a/bioimageio/spec/_internal/utils.py b/bioimageio/spec/_internal/utils.py
index 3275c77cb..b13cf6843 100644
--- a/bioimageio/spec/_internal/utils.py
+++ b/bioimageio/spec/_internal/utils.py
@@ -5,6 +5,7 @@
 from inspect import signature
 from pathlib import Path
 from typing import (
+    Any,
     Callable,
     Dict,
     Set,
@@ -14,6 +15,7 @@
     Union,
 )
 
+from ruyaml import Optional
 from typing_extensions import ParamSpec
 
 K = TypeVar("K")
@@ -22,15 +24,30 @@
 
 
 if sys.version_info < (3, 9):
+    from functools import lru_cache as cache
 
     def files(package_name: str):
         assert package_name == "bioimageio.spec", package_name
         return Path(__file__).parent.parent
 
 else:
+    from functools import cache as cache
     from importlib.resources import files as files
 
 
+def get_format_version_tuple(format_version: Any) -> Optional[Tuple[int, int, int]]:
+    if (
+        not isinstance(format_version, str)
+        or format_version.count(".") != 2
+        or any(not v.isdigit() for v in format_version.split("."))
+    ):
+        return None
+
+    parsed = tuple(map(int, format_version.split(".")))
+    assert len(parsed) == 3
+    return parsed
+
+
 def nest_dict(flat_dict: Dict[Tuple[K, ...], V]) -> NestedDict[K, V]:
     res: NestedDict[K, V] = {}
     for k, v in flat_dict.items():
diff --git a/bioimageio/spec/generic/v0_3.py b/bioimageio/spec/generic/v0_3.py
index fbffd43f4..795e39923 100644
--- a/bioimageio/spec/generic/v0_3.py
+++ b/bioimageio/spec/generic/v0_3.py
@@ -221,7 +221,7 @@ class GenericModelDescrBase(ResourceDescrBase):
     ] = Field(default_factory=list)
     """∈📦 Cover images."""
 
-    id_emoji: Optional[Annotated[str, Len(min_length=1, max_length=1)]] = None
+    id_emoji: Optional[Annotated[str, Len(min_length=1, max_length=2)]] = None
     """UTF-8 emoji for display alongside the `id`."""
 
     authors: NotEmpty[List[Author]]
diff --git a/bioimageio/spec/model/v0_5.py b/bioimageio/spec/model/v0_5.py
index 0687b6842..c8c080225 100644
--- a/bioimageio/spec/model/v0_5.py
+++ b/bioimageio/spec/model/v0_5.py
@@ -79,7 +79,10 @@
 from .._internal.validator_annotations import RestrictCharacters
 from .._internal.version_type import Version as Version
 from .._internal.warning_levels import INFO
+from ..dataset.v0_2 import DatasetDescr as DatasetDescr02
+from ..dataset.v0_2 import LinkedDataset as LinkedDataset02
 from ..dataset.v0_3 import DatasetDescr as DatasetDescr
+from ..dataset.v0_3 import DatasetId as DatasetId
 from ..dataset.v0_3 import LinkedDataset as LinkedDataset
 from ..dataset.v0_3 import Uploader as Uploader
 from ..generic.v0_3 import (
@@ -1383,10 +1386,13 @@ def convert_axes(
                 ret.append(SpaceInputAxis(id=AxisId(a), size=size, scale=scale))
             else:
                 assert not isinstance(size, ParameterizedSize)
-                if halo is None:
+                if halo is None or halo[i] == 0:
                     ret.append(SpaceOutputAxis(id=AxisId(a), size=size, scale=scale))
+                elif isinstance(size, int):
+                    raise NotImplementedError(
+                        f"output axis with halo and fixed size (here {size}) not allowed"
+                    )
                 else:
-                    assert not isinstance(size, int)
                     ret.append(
                         SpaceOutputAxisWithHalo(
                             id=AxisId(a), size=size, scale=scale, halo=halo[i]
@@ -2339,7 +2345,7 @@ def _validate_output_axes(
     with a few restrictions listed [here](https://docs.python.org/3/library/datetime.html#datetime.datetime.fromisoformat).
     (In Python a datetime object is valid, too)."""
 
-    training_data: Union[None, LinkedDataset, DatasetDescr] = None
+    training_data: Union[None, LinkedDataset, DatasetDescr, DatasetDescr02] = None
     """The dataset used to train this model"""
 
     weights: Annotated[WeightsDescr, WrapSerializer(package_weights)]
@@ -2522,11 +2528,22 @@ def _convert(cls, data: Dict[str, Any]) -> Dict[str, Any]:
         if (
             data.get("type") == "model"
             and isinstance(fv := data.get("format_version"), str)
-            and (fv.startswith("0.3.") or fv.startswith("0.4."))
+            and fv.count(".") == 2
         ):
-            m04 = _ModelDescr_v0_4.load(data)
-            if not isinstance(m04, InvalidDescr):
-                return _model_conv.convert_as_dict(m04)
+            fv_parts = fv.split(".")
+            if any(not p.isdigit() for p in fv_parts):
+                return data
+
+            fv_tuple = tuple(map(int, fv_parts))
+
+            assert cls.implemented_format_version_tuple[0:2] == (0, 5)
+            if fv_tuple[:2] in ((0, 3), (0, 4)):
+                m04 = _ModelDescr_v0_4.load(data)
+                if not isinstance(m04, InvalidDescr):
+                    return _model_conv.convert_as_dict(m04)
+            elif fv_tuple[:2] == (0, 5):
+                # bump patch version
+                data["format_version"] = cls.implemented_format_version
 
         return data
 
@@ -2592,7 +2609,7 @@ def conv_authors(auths: Optional[Sequence[_Author_v0_4]]):
             config=src.config,
             covers=src.covers,
             description=src.description,
-            documentation=src.documentation,  # pyright: ignore[reportArgumentType]
+            documentation=src.documentation,
             format_version="0.5.3",
             git_repo=src.git_repo,  # pyright: ignore[reportArgumentType]
             icon=src.icon,
@@ -2624,6 +2641,43 @@ def conv_authors(auths: Optional[Sequence[_Author_v0_4]]):
                     src.sample_outputs or [None] * len(src.test_outputs),
                 )
             ],
+            parent=(
+                None
+                if src.parent is None
+                else LinkedModel(
+                    id=ModelId(
+                        str(src.parent.id)
+                        + (
+                            ""
+                            if src.parent.version_number is None
+                            else f"/{src.parent.version_number}"
+                        )
+                    )
+                )
+            ),
+            training_data=(
+                None
+                if src.training_data is None
+                else (
+                    LinkedDataset(
+                        id=DatasetId(
+                            str(src.training_data.id)
+                            + (
+                                ""
+                                if src.training_data.version_number is None
+                                else f"/{src.training_data.version_number}"
+                            )
+                        )
+                    )
+                    if isinstance(src.training_data, LinkedDataset02)
+                    else src.training_data
+                )
+            ),
+            packaged_by=[
+                _author_conv.convert_as_dict(a) for a in src.packaged_by
+            ],  # pyright: ignore[reportArgumentType]
+            run_mode=src.run_mode,
+            timestamp=src.timestamp,
             weights=(WeightsDescr if TYPE_CHECKING else dict)(
                 keras_hdf5=(w := src.weights.keras_hdf5)
                 and (KerasHdf5WeightsDescr if TYPE_CHECKING else dict)(
@@ -2789,7 +2843,7 @@ def to_2d_image(data: NDArray[Any], axes: Sequence[AnyAxis]):
 
                     assert data.shape[i] == 3
 
-            slices += (slice(None),)  # type: ignore
+            slices += (slice(None),)
 
         data, axes = squeeze(data, axes)
         assert len(axes) == ndim
@@ -2821,7 +2875,7 @@ def to_2d_image(data: NDArray[Any], axes: Sequence[AnyAxis]):
                 data = data[slices + (slice(s // 2 - 1, s // 2),)]
                 ndim -= 1
 
-            slices += (slice(None),)  # type: ignore
+            slices += (slice(None),)
 
         del slices
         data, axes = squeeze(data, axes)
diff --git a/bioimageio/spec/partner_utils/imjoy/_plugin_parser.py b/bioimageio/spec/partner_utils/imjoy/_plugin_parser.py
index 15bc1aeca..4ab260fae 100644
--- a/bioimageio/spec/partner_utils/imjoy/_plugin_parser.py
+++ b/bioimageio/spec/partner_utils/imjoy/_plugin_parser.py
@@ -196,7 +196,6 @@ def enrich_partial_rdf_with_imjoy_plugin(
 ) -> Dict[str, Any]:
     """
     a (partial) rdf may have 'rdf_source' or 'source' which resolve to rdf data that may be overwritten.
-    Due to resolving imjoy plugins this is not done in bioimageio.spec.collection atm
     """
 
     enriched_rdf: Dict[str, Any] = {}
diff --git a/bioimageio/spec/pretty_validation_errors.py b/bioimageio/spec/pretty_validation_errors.py
index e0051c003..aa15d3c5e 100644
--- a/bioimageio/spec/pretty_validation_errors.py
+++ b/bioimageio/spec/pretty_validation_errors.py
@@ -29,8 +29,7 @@ def __str__(self):
                 ipt = " ".join([il.strip() for il in ipt_lines])
 
                 errors.append(
-                    f"\n{format_loc(e['loc'])}\n  {e['msg']} [type={e['type']},"
-                    + f" input={ipt}]"
+                    f"\n{format_loc(e['loc'], enclose_in='')}\n  {e['msg']} [input={ipt}]"
                 )
 
             return (
@@ -52,8 +51,8 @@ def _custom_exception_handler(
             etype, PrettyValidationError(evalue), tb, tb_offset=tb_offset
         )
         if isinstance(stb, list):
-            orig_stb = list(stb)
-            for line in orig_stb:
+            stb_clean = []
+            for line in stb:
                 if (
                     isinstance(line, str)
                     and "pydantic" in line
@@ -61,7 +60,9 @@ def _custom_exception_handler(
                 ):
                     # ignore pydantic internal frame in traceback
                     continue
-                stb.append(line)
+                stb_clean.append(line)
+
+            stb = stb_clean
 
         self._showtraceback(etype, PrettyValidationError(evalue), stb)  # type: ignore
 
diff --git a/bioimageio/spec/summary.py b/bioimageio/spec/summary.py
index bc21f7a3b..09aa92c2a 100644
--- a/bioimageio/spec/summary.py
+++ b/bioimageio/spec/summary.py
@@ -89,7 +89,7 @@ def sync_severity_with_severity_name(
         return data
 
 
-def format_loc(loc: Loc) -> str:
+def format_loc(loc: Loc, enclose_in: str = "`") -> str:
     if not loc:
         loc = ("__root__",)
 
@@ -99,7 +99,7 @@ def format_loc(loc: Loc) -> str:
     # `weights.pytorch_state_dict.dependencies.source.function-after[validate_url_ok(), url['http','https']]` Input should be a valid URL, relative URL without a base
     # therefore we remove the `.function-after[validate_url_ok(), url['http','https']]` here
     brief_loc_str, *_ = loc_str.split(".function-after")
-    return f"`{brief_loc_str}`"
+    return f"{enclose_in}{brief_loc_str}{enclose_in}"
 
 
 class InstalledPackage(TypedDict):
diff --git a/example/load_model_and_create_your_own.ipynb b/example/load_model_and_create_your_own.ipynb
index dca853719..da36ceb69 100644
--- a/example/load_model_and_create_your_own.ipynb
+++ b/example/load_model_and_create_your_own.ipynb
@@ -13,12 +13,36 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## 0. Activate human readable output error messages"
+    "## 0. Setup\n",
+    "\n",
+    "### 0.1 Install dependencies\n",
+    "(if in Google Colab)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "\n",
+    "if os.getenv(\"COLAB_RELEASE_TAG\"):\n",
+    "    %pip install bioimageio.spec python-devtools"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 0.2 Enable pretty validation errors\n",
+    "\n",
+    "Improves readiblity of format validation errors in Jupyter notebooks by removing redundant error details and hiding calls witin the pydantic library from the stacktrace."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 117,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -26,265 +50,92 @@
     "    enable_pretty_validation_errors_in_ipynb,\n",
     ")\n",
     "\n",
-    "enable_pretty_validation_errors_in_ipynb()\n",
-    "\n",
-    "# Load dependencies\n",
-    "from pathlib import Path\n",
-    "from ruyaml import YAML\n",
-    "import pooch\n",
-    "import json\n",
-    "import matplotlib.pyplot as plt\n",
-    "from imageio.v3 import imread\n",
-    "from bioimageio.spec.utils import download\n",
-    "from bioimageio.spec.model.v0_5 import ArchitectureFromFileDescr\n",
-    "from bioimageio.spec.utils import download\n",
-    "from bioimageio.spec import InvalidDescr, load_description\n",
-    "from bioimageio.spec.common import HttpUrl\n",
-    "from bioimageio.spec.model import ModelDescr"
+    "enable_pretty_validation_errors_in_ipynb()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## 1. Inspect the available models in the BioImage Model Zoo"
+    "## 1. Inspect the available models in the BioImage Model Zoo\n",
+    "\n",
+    "Go to https://bioimage.io to browser available models"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 13,
+   "cell_type": "markdown",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "All models checked.\n",
-      "List of models in BioImageIO:\n",
-      "\n",
-      "NucleiSegmentationBoundaryModel\n",
-      " - affable-shark\n",
-      " - 10.5281/zenodo.6647674\n",
-      "StarDist H&E Nuclei Segmentation\n",
-      " - chatty-frog\n",
-      " - 10.5281/zenodo.6338615\n",
-      "LiveCellSegmentationBoundaryModel\n",
-      " - hiding-tiger\n",
-      " - 10.5281/zenodo.6647688\n",
-      "Neuron Segmentation in EM (Membrane Prediction)\n",
-      " - impartial-shrimp\n",
-      " - 10.5281/zenodo.5874742\n",
-      "Pancreatic Phase Contrast Cell Segmentation (U-Net)\n",
-      " - discreet-rooster\n",
-      " - 10.5281/zenodo.8186255\n",
-      "EnhancerMitochondriaEM2D\n",
-      " - hiding-blowfish\n",
-      " - 10.5281/zenodo.6811922\n",
-      "MitochondriaEMSegmentationBoundaryModel\n",
-      " - kind-seashell\n",
-      " - 10.5281/zenodo.6630266\n",
-      "Cell Segmentation from Membrane Staining for Plant Tissues\n",
-      " - humorous-owl\n",
-      " - 10.5281/zenodo.5888237\n",
-      "PlatynereisEMnucleiSegmentationBoundaryModel\n",
-      " - organized-badger\n",
-      " - 10.5281/zenodo.6028098\n",
-      "StarDist Fluorescence Nuclei Segmentation\n",
-      " - fearless-crab\n",
-      " - 10.5281/zenodo.6348085\n",
-      "B. Sutilist bacteria segmentation - Widefield microscopy - 2D UNet\n",
-      " - placid-llama\n",
-      " - 10.5281/zenodo.7782776\n",
-      "PlatynereisEMcellsSegmentationBoundaryModel\n",
-      " - willing-hedgehog\n",
-      " - 10.5281/zenodo.6647695\n",
-      "HPA Cell Segmentation (DPNUnet)\n",
-      " - loyal-parrot\n",
-      " - 10.5281/zenodo.7702687\n",
-      "Arabidopsis Leaf Segmentation\n",
-      " - non-judgemental-eagle\n",
-      " - 10.5281/zenodo.6348729\n",
-      "3D UNet Arabidopsis Apical Stem Cells\n",
-      " - emotional-cricket\n",
-      " - 10.5281/zenodo.7768142\n",
-      "Neuron Segmentation in 2D EM (Membrane)\n",
-      " - creative-panda\n",
-      " - 10.5281/zenodo.5906839\n",
-      "CovidIFCellSegmentationBoundaryModel\n",
-      " - powerful-chipmunk\n",
-      " - 10.5281/zenodo.6647683\n",
-      "MitchondriaEMSegmentation2D\n",
-      " - shivering-raccoon\n",
-      " - 10.5281/zenodo.6406804\n",
-      "HPA Nucleus Segmentation (DPNUnet)\n",
-      " - conscientious-seashell\n",
-      " - 10.5281/zenodo.7690494\n",
-      "3D UNet Mouse Embryo Live\n",
-      " - powerful-fish\n",
-      " - 10.5281/zenodo.7774490\n",
-      "3D UNet Mouse Embryo Fixed\n",
-      " - loyal-squid\n",
-      " - 10.5281/zenodo.7774505\n",
-      "EpitheliaAffinityModel\n",
-      " - wild-whale\n",
-      " - 10.5281/zenodo.7695872\n",
-      "2D UNet Arabidopsis Ovules\n",
-      " - pioneering-rhino\n",
-      " - 10.5281/zenodo.7805067\n",
-      "3D UNet Lateral Root Primordia Cells\n",
-      " - thoughtful-turtle\n",
-      " - 10.5281/zenodo.7765026\n",
-      "2D UNet Arabidopsis Apical Stem Cells\n",
-      " - laid-back-lobster\n",
-      " - 10.5281/zenodo.7805026\n",
-      "HPA Bestfitting InceptionV3\n",
-      " - straightforward-crocodile\n",
-      " - 10.5281/zenodo.6539073\n",
-      "3D UNet Arabidopsis Ovules\n",
-      " - passionate-t-rex\n",
-      " - 10.5281/zenodo.7805434\n",
-      "EnhancerMitochondriaEM3D\n",
-      " - independent-shrimp\n",
-      " - 10.5281/zenodo.6811492\n",
-      "Small Extracellular Vesicle TEM Segmentation (Fully Residual U-Net)\n",
-      " - naked-microbe\n",
-      " - 10.5281/zenodo.6559475\n",
-      "HPA Bestfitting Densenet\n",
-      " - polite-pig\n",
-      " - 10.5281/zenodo.5942853\n",
-      "Cells and gland Segmentation (FRUNet)\n",
-      " - impartial-shark\n",
-      " - 10.5281/zenodo.6919253\n",
-      "CebraNET Cellular Membranes in Volume SEM\n",
-      " - joyful-deer\n",
-      " - 10.5281/zenodo.8123818\n",
-      "EM3DBoundaryEnhancer\n",
-      " - determined-chipmunk\n",
-      " - 10.5281/zenodo.6808413\n",
-      "EmbryoNet base model\n",
-      " - nice-peacock\n",
-      " - 10.5281/zenodo.7315441\n",
-      "HyLFM-Net-stat\n",
-      " - ambitious-sloth\n",
-      " - 10.5281/zenodo.7642674\n",
-      "Drosophila epithelia cell boundary segmentation of 2D projections\n",
-      " - easy-going-sauropod\n",
-      " - 10.5281/zenodo.7405349\n",
-      "3D UNet Arabidopsis Ovules Nuclei\n",
-      " - noisy-fish\n",
-      " - 10.5281/zenodo.7781091\n",
-      "Mitochondria resolution enhancement Wasserstein GAN\n",
-      " - organized-cricket\n",
-      " - 10.5281/zenodo.7786493\n",
-      "StarDist Plant Nuclei 3D ResNet\n",
-      " - modest-octopus\n",
-      " - 10.5281/zenodo.8432366\n",
-      "2D UNet for label-free prediction of mCherry-H2B\n",
-      " - noisy-hedgehog\n",
-      " - 10.5281/zenodo.8073617\n",
-      "UniFMIRSuperResolutionOnMicrotubules\n",
-      " - ambitious-ant\n",
-      " - 10.5281/zenodo.8420081\n",
-      "UniFMIRSuperResolutionOnFactin\n",
-      " - courteous-otter\n",
-      " - 10.5281/zenodo.8420100\n",
-      "PlantSeg Plant Nuclei 3D UNet\n",
-      " - efficient-chipmunk\n",
-      " - 10.5281/zenodo.8429203\n",
-      "EnhancerBoundaryEM2D\n",
-      " - amiable-crocodile\n",
-      " - 10.5281/zenodo.8171247\n"
-     ]
-    }
-   ],
    "source": [
-    "yaml = YAML(typ=\"safe\")\n",
-    "\n",
-    "COLLECTION_URL = \"https://raw.githubusercontent.com/bioimage-io/collection-bioimage-io/gh-pages/collection.json\"\n",
+    "## 2. Load and inspect a model description\n",
     "\n",
-    "collection_path = Path(pooch.retrieve(COLLECTION_URL, known_hash=None))\n",
+    "bioimage.io resources may be identified via their bioimage.io ID, e.g. \"affable-shark\" or the [DOI](https://doi.org/) of their [Zenodo](https://zenodo.org/) backup.\n",
     "\n",
-    "with collection_path.open() as f:\n",
+    "Both of these options may be version specific (\"affable-shark/1\" or a version specific [Zenodo](https://zenodo.org/) backup [DOI](https://doi.org/)).\n",
     "\n",
-    "    collection = json.load(f)\n",
+    "Alternativly any RDF source may be loaded by providing a local path or URL."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load the model description with one of these options\n",
+    "# 1. version unspecific (implicitly refering to the latest version):\n",
+    "MODEL_ID = \"affable-shark\"\n",
+    "MODEL_DOI = \"10.5281/zenodo.11092561\"\n",
     "\n",
-    "model_urls = [entry[\"rdf_source\"] for entry in collection[\"collection\"] if entry[\"type\"] == \"model\"]\n",
-    "model_rdfs = [yaml.load(Path(pooch.retrieve(mu, known_hash=None))) for mu in model_urls]\n",
+    "# 2. version specific\n",
+    "MODEL_VERSION_ID = \"affable-shark/1\"  # not available for this legacy model\n",
+    "MODEL_VERSION_DOI = \"10.5281/zenodo.11092562\"\n",
     "\n",
-    "print(\"All models checked.\")\n",
+    "# 3. an uploaded draft\n",
+    "MODEL_DRAFT = \"affable-shark/draft\"  # not available for this model without a new version draft\n",
     "\n",
-    "# nickname_list = []\n",
-    "print('List of models in BioImageIO:\\n')\n",
-    "for model in model_rdfs:\n",
-    "    # nickname_list.append(model['config']['bioimageio']['nickname'])\n",
-    "    print(f\"{model['name']}\\n - {model['config']['bioimageio']['nickname']}\\n - {model['config']['bioimageio']['doi']}\")\n"
+    "# 4. from source\n",
+    "MODEL_URL = \"https://zenodo.org/records/11092562/files/rdf.yaml\""
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {},
+   "outputs": [],
    "source": [
-    "## 2. Load and inspect a model description\n",
+    "# Another set of examples to source a bioimage.io model\n",
+    "# 1. version unspecific (implicitly refering to the latest version):\n",
+    "MODEL_ID = \"emotional-cricket\"\n",
+    "MODEL_DOI = \"10.5281/zenodo.6346511\"\n",
     "\n",
-    "To load a model of your choice, you only need to write one of the following ones in the cell and leave the rest empty.\n",
+    "# 2. version specific\n",
+    "MODEL_VERSION_ID = \"emotional-cricket/1\"  # not available for this legacy model\n",
+    "MODEL_VERSION_DOI = \"10.5281/zenodo.7768142\"\n",
     "\n",
-    "**`BMZ_MODEL_ID`**: Unique identifier of the model to load in the BioImage Model Zoo, e.g., impartial-shrimp. These identifiers are given on each model card in the zoo.\n",
+    "# 3. an uploaded draft\n",
+    "MODEL_DRAFT = \"emotional-cricket/draft\"  # not available for this model without a new version draft\n",
     "\n",
-    "OR\n",
-    "\n",
-    "**`BMZ_MODEL_URL`**: URL to the main Zenodo repository as well as to the rdf.yaml file containing the resource description specifications can be used to load models as well."
+    "# 4. from source\n",
+    "MODEL_URL = \"https://uk1s3.embassy.ebi.ac.uk/public-datasets/bioimage.io/emotional-cricket/1/files/rdf.yaml\""
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 124,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\u001b[32m2024-05-07 16:42:53.939\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mbioimageio.spec._internal.io_utils\u001b[0m:\u001b[36mopen_bioimageio_yaml\u001b[0m:\u001b[36m116\u001b[0m - \u001b[1m🦈 loading affable-shark 1 from https://uk1s3.embassy.ebi.ac.uk/public-datasets/bioimage.io/affable-shark/1/files/bioimageio.yaml\u001b[0m\n",
-      "/Users/esti/mambaforge/envs/biospec/lib/python3.10/site-packages/bioimageio/spec/model/v0_5.py:1363: UserWarning: Conversion of channel size from an implicit output shape may by wrong\n",
-      "  warnings.warn(\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "The model 'NucleiSegmentationBoundaryModel' with ID 'affable-shark' has been correctly loaded. This model has version 0.5.0.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "# Load the model description with one of these options\n",
-    "BMZ_MODEL_ID = \"affable-shark\"\n",
-    "BMZ_MODEL_URL = \"\"\n",
-    "\n",
-    "if BMZ_MODEL_ID != \"\":\n",
-    "    url = BMZ_MODEL_ID\n",
-    "elif BMZ_MODEL_URL != \"\":\n",
-    "    url = BMZ_MODEL_URL\n",
-    "else:\n",
-    "    print('Please specify a model ID, DOI or URL')\n",
+    "from bioimageio.spec import InvalidDescr, load_description\n",
+    "from bioimageio.spec.model.v0_5 import ModelDescr\n",
     "\n",
-    "loaded_descr = load_description(url, format_version=\"latest\")\n",
-    "if isinstance(loaded_descr, InvalidDescr):\n",
-    "    loaded_descr.validation_summary.display()\n",
-    "    raise ValueError(f\"Failed to load {example_model_id}\")\n",
-    "elif not isinstance(loaded_descr, ModelDescr):\n",
-    "    raise ValueError(\"This notebook expects a model description\")\n",
-    "else:\n",
-    "    model = loaded_descr\n",
+    "source = MODEL_ID\n",
     "\n",
-    "if BMZ_MODEL_ID != \"\":\n",
-    "    print(f\"The model '{model.name}' with ID '{BMZ_MODEL_ID}' has been correctly loaded. This model has version {model.format_version}.\")\n",
-    "elif BMZ_MODEL_URL != \"\":\n",
-    "    print(f\"The model '{model.name}' with URL '{BMZ_MODEL_URL}' has been correctly loaded. This model has version {model.format_version}.\")\n",
-    "else:\n",
-    "    print(\"Please specify a model ID, DOI or URL\")\n",
-    "example_model_id = model.id"
+    "loaded_description = load_description(source, format_version=\"latest\")"
    ]
   },
   {
@@ -294,123 +145,122 @@
    },
    "source": [
     "## 3. Validation summary of the model\n",
-    "The model specifications can be validated for correctness. By running `model.validation_summary.display()`, the BioImage Model Zoo format is checked (static validation). This validation is also performed when a model is uploaded to the zoo.\n",
+    "A model description is validated with our format specification. \n",
+    "To inspect the corresponding validation summary access the `validation_summary` attribute.\n",
+    "\n",
+    "The validation summary will indicate:\n",
+    "- the version of the `bioimageio.spec` library used to run the validation\n",
+    "- the status of several validation steps\n",
+    "    - ✔️: Success\n",
+    "    - 🔍: information about the validation context\n",
+    "    - ⚠: Warning\n",
+    "    - ❌: Error\n",
     "\n",
-    "Here is a description of the outputs you can get:\n",
-    "- `package version`: The version of the `bioimageio.spec` library used to run the validation.\n",
-    "- ✔️: Validation passes.\n",
-    "- ⚠: Warning messages to bring attention on the lack of useful documentation or recommendations from the BioImageIO developers. \n",
-    "- **X**: Validation does not pass.\n",
-    "\n"
+    "To display the validaiton summary in a terminal or notebook we recommend to run:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "✔️ bioimageio validation: passed\n",
-       "\n",
-       "source: https://uk1s3.embassy.ebi.ac.uk/public-datasets/bioimage.io/affable-shark/1/files/bioimageio.yaml\n",
-       "|     package     |  version   |\n",
-       "|       ---       |    ---     |\n",
-       "| bioimageio.spec | 0.5.2post3 |\n",
-       "\n",
-       "\n",
-       "|  ❓  |                  location                 |                                                                       detail                                                                       |\n",
-       "| --- |                    ---                    |                                                                        ---                                                                         |\n",
-       "| ✔️  |                                           | initialized model 0.4.10                                                                                                                           |\n",
-       "| ✔️  |                                           | bioimageio.spec format validation model 0.4.10                                                                                                     |\n",
-       "| ⚠   | `weights.pytorch_state_dict.dependencies` | Custom dependencies (conda:environment.yaml) specified. Avoid this whenever possible to allow execution in a wider range of software environments. |\n",
-       "|     |                                           |                                                                                                                                                    |\n",
-       "| ✔️  |                                           | initialized model 0.5.0                                                                                                                            |\n",
-       "| ✔️  |                                           | bioimageio.spec format validation model 0.5.0                                                                                                      |\n",
-       "| ⚠   | `documentation`                           | No '# Validation' (sub)section found in documentation.md.                                                                                          |\n",
-       "|     |                                           |                                                                                                                                                    |\n"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "model.validation_summary.display()"
+    "loaded_description.validation_summary.display()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# let's make sure we have a valid model...\n",
+    "if isinstance(loaded_description, InvalidDescr):\n",
+    "    raise ValueError(f\"Failed to load {source}\")\n",
+    "elif not isinstance(loaded_description, ModelDescr):\n",
+    "    raise ValueError(\"This notebook expects a model 0.5 description\")\n",
+    "\n",
+    "model = loaded_description\n",
+    "example_model_id = model.id\n",
+    "assert example_model_id is not None"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## 4. Inspect the content of the model specifications"
+    "## 4. Inspect the model description"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "The model 'NucleiSegmentationBoundaryModel' had the following properties and metadata\n",
-      "\n",
-      " Description Nucleus segmentation for fluorescence microscopy\n",
-      "\n",
-      " The authors of the model are [Author(affiliation='EMBL Heidelberg', email=None, orcid=None, name='Constantin Pape', github_user=None)]\n",
-      " and it is maintained by: [Maintainer(affiliation=None, email=None, orcid=None, name='Constantin Pape', github_user='constantinpape')]\n",
-      " License: CC-BY-4.0\n",
-      "\n",
-      " If you use this model, you are expected to cite [CiteEntry(text='training library', doi=None, url='https://doi.org/10.5281/zenodo.5108853'), CiteEntry(text='architecture', doi=None, url='https://doi.org/10.1007/978-3-319-24574-4_28'), CiteEntry(text='segmentation algorithm', doi=None, url='https://doi.org/10.1038/nmeth.4151'), CiteEntry(text='data', doi=None, url='https://www.nature.com/articles/s41592-019-0612-7')]\n",
-      "\n",
-      " Further documentation can be found here: [CiteEntry(text='training library', doi=None, url='https://doi.org/10.5281/zenodo.5108853'), CiteEntry(text='architecture', doi=None, url='https://doi.org/10.1007/978-3-319-24574-4_28'), CiteEntry(text='segmentation algorithm', doi=None, url='https://doi.org/10.1038/nmeth.4151'), CiteEntry(text='data', doi=None, url='https://www.nature.com/articles/s41592-019-0612-7')]\n",
-      "\n",
-      " GitHub repository: None\n",
-      "\n",
-      "Covers of the model 'NucleiSegmentationBoundaryModel'\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxoAAAEWCAYAAADhHeEAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9d5xVxfk//j63t+290KU3aYJYEBRsWKJiD8YSo0YT9WNviUlMYtcYg37V2FBM1NhAVEREUelIL0vd3svd3dvvPb8/9jfj3NmZc87dXWDB+3699rW758yZeaY/72dmnlFUVVWRRBJJJJFEEkkkkUQSSSTRgzAdbgGSSCKJJJJIIokkkkgiiaMPSaKRRBJJJJFEEkkkkUQSSfQ4kkQjiSSSSCKJJJJIIokkkuhxJIlGEkkkkUQSSSSRRBJJJNHjSBKNJJJIIokkkkgiiSSSSKLHkSQaSSSRRBJJJJFEEkkkkUSPI0k0kkgiiSSSSCKJJJJIIokeR5JoJJFEEkkkkUQSSSSRRBI9DouRQLFYDJWVlUhJSYGiKAdbpiSSSCKJJJJIIokkkkiil0JVVbS2tqKwsBAmk3zdwhDRqKysRJ8+fXpMuCSSSCKJJJJIIokkkkjiyEZZWRmKi4ul7w0RjZSUFABAamoqAoEAVFVFLBaDqqpxKxyqqtK/FUWh/7NhFEVBLBYT/q8oCg3LxiWCKH5VVTvJpBcH+W0ymWA2m+FwOOByuWCz2RAMBtHW1oZwOAxFUWC1WuF2u+nKTmtrK9ra2hAKhWh58HlhfwDQcGwZEphMpriy0ZNbVEbknclkigtH/ie/WXmj0agwHr4c2fRIHvj3JpNJWu/kf7PZjMLCQqSnp8PtdiM9PR0Oh4O+D4fDUFUVDocD4XAYXq8X1dXVqKyshM/no/Ky6fCyyWTkZQI66kTWZniWzoYV5Z/9jm0LvDx8v+HbM6krNgxJWxaPSCY2r6Ky0CofURw5OTnwer0IBoOd2u/RAkVRYDabYbFYYDabYTabEYvFEAqFAHS036FDh+Kkk05CTk4OFi1ahLVr1wr7UW8GGQvYNmVk/OlJZGRk4IorrsCDDz4Im80mbX9Eth07dmD27Nloamo6pHImEQ+bzQaXy4W2trZO4/HRANLvLRYL7HY7LBYLioqKUFxcjN27d6OtrQ0TJkzAX/7ylzgF6/3338ff//537N2795D3pUQg07VEc9WhwPz583H22WfjwIEDmDVrFhoaGoTjqdlshsfjwcaNG5GSkoLhw4ejtrb2kMmZhBiEI8hgiGjwyhlRjIgiRDoUq2SS//XiY79jn5Nv+cbOp8ErbGyaWkoTr9QRhEIhquiyyp3T6UROTg5ycnLgdDoBAA0NDWhoaEBjYyPC4TCi0WgceTGbzZ3iVxQFkUhEKJ+MJIkUQtH3/MDBxscrqTzBE8XN1x/5hiUqbHqishfVl6qq8Pl88Hg8MJvNUFUVkUgEaWlptMxNJhNVPOx2O0wmEyWDAOggxJcv2waIrKLyY8tBVo6iwZgnUmwZs+XLPxdBRMRYmUT9hP1bRDiMthU+XZJHUZskpElVVdhsNmG7ZsuoN0NLkWXfRaPRTgYRk8kEh8OBuXPn4k9/+hNtrzfddBMuvfRSLF269IgoA4KeViZEJF4vrba2NpSUlEBVVaSlpWnGH4vFkJaW1qsVuJ8LyFhMxm/WWHIk9QERSD5isRjC4TCdr1tbW7Fz507Y7XYcf/zxeO6555Cfn48vv/wS5eXlmDlzJn75y1/CZrPhj3/8I/bt2yfUX9i+caiNNVqGYfJbZsDTMoB1Nw8PPPAALrnkEgwbNgx5eXlobm6WGjOj0ShycnJgt9uPOOPO0QZeB5IhocPgZIBnFVV+0DeymiBTbPnfIjLAK3IyxY59R5QGkTWY/Z5Y90l4kjez2Yz09HQUFhbS1QxVVZGSkoK0tDRYLBbhSobJZILFYoHVaoXFYum0ykDC84MPXyZGOzGbNzZffB5JmfDv2HQtFgssFgtsNhvsdjscDgdsNhtVNM1mc5xFVE9+Xq62tja0t7ejvb0dLS0t8Pl88Pv9iEajND2HwwG73Q4ACAaDCIVCdGDhy5KVg29LfBvlCYaoDkTkQ5RXWb55GUT1LVqFEdUdm19+oBellSj4+uHzwvYttt10J82ugq+HrvywSpKMNAHo1G8AYNy4cXjkkUeQnp5O40pPT8cDDzwAm82mKTMhy7J2lOhPImUjgmh8kMlvNpths9noOEDKjY+P/4aMI2S84BEOh7F161a8/fbbVKGTIRQKoaSkBG1tbZrhDgf0yvpQy3GwYbFYkJqaSg0/bPoHG0badk+A6ADRaBSRSIQaIT0eD5577jnk5eXhtNNOw0UXXYSbb74Zs2bNwq5du3DhhReiT58+ce2d7JbIycnBgAEDUFxcjLS0NNjt9k5leLAh6vO8fkDAjpculwuDBw/G008/jfr6ejQ2NmLlypW46KKLkJaWprlHXw8VFRVYsmQJLBYLPvjgA2RlZUn1IpIW0Ql6C3pD/++tMLSiQcAr7AQipYxXXNgwvMWdj49/F4lE4iY2EYMSKbUExPrLWyhl37O/zWYznE4n0tLS4HQ6aWciE6/P56MKBLuyYzabYbfbYbVaYbVaoaoqAoEA7RihUEiq5JP0tVYcjECkPGrVG3lGCIbFYoHL5aLLYsFgEIFAgP6ORCJSi4aIJLH1Fg6HUV9fD1VVkZ2dTZfhnU4nPB4PIpEIfD4fgsEgmpqa4PP5hBZmUT555VBESmTlwivuMmVK1J7Jc1mejRBGWV2Ltnfx/UxkiSJ/y4iBSCa+X7Lfkq2Eh8NyaZRQyciSLD52dUiLcJnNZpxxxhlxTjFIWQ0ZMoRut2S/MZlMdDU0NTUVXq8XVVVVtP/LZOouEmlzWnGYzWZkZGRg7NixOOOMMzBy5EjU19dj5cqVWLFiBXbv3g2/39/JCEXAEivynpepsrISTz/9NFpbW3HbbbfB4/F0kiUWi6G8vBz33Xdfr1/RkLW3Qy0DcPBWGclWQmJ44NPu6XS1+oWRPtPVsVdkpLr22muRlZWFL774Avv370cgEADQoSyHQiE67xOdwGq1Ij8/H//3f/+HOXPmIDs7G6qqYvHixXj66aexZs0aBAIBYbvWyltXylg23svSJfpAXl4ebr75Ztx6662wWH5SG8ePH48FCxagpaUF5557LlatWqVrMBAhEongoosuwpo1azBs2DDs3bsX9957Lz788EPU19cjEonAarWiT58+WL58OSwWCy677DIEg8Fe0d+Aw7OiL9ODekN5sEiIaLCKr0iBEv3PTzwypZp/x/7NM2XRlh6RkiWTgY9f9pwoq3a7HR6PBw6HAyaTCeFwGFarlQ6y7IBLCEhaWhpyc3ORmZkJl8sFn8+HiooK1NXVob29XZi2TC4jSqJe/vTyS74nlpe0tDSkp6cjLy+PEopwOAwACAQCqK6uRmtrK8LhMEKhkLAutRReVVXh9/tRU1MDv98Pv98Pl8sFt9uN9vZ2urLU2tqKmpoaeL1eWr4kLXZgJtYn9hlpJ/wWPyKPoihSBYkNw5ev6IwIW56y9igi4Hxd8GmSZyxZIhMYe96H/Ijk1UuXl19V5WdtyBbBgz2QySZYLbKhNcDKSDVPMEXkn8DtduPCCy8Uli27/ZOts4EDB+Laa6/FpZdeitTUVDQ3N+Pxxx/Hq6++SidJPVm18mR0HEsUhCDNmDEDt9xyC0444QTY7Xaa5pw5c1BTU4OXXnoJ8+bNQ2NjY6c02bZE2qxIZkIinn76aaxbtw7XX389Jk2aRC2XbW1t+P777/Hwww9j9+7dCefFKLqjsPDjx6FQfmR9RNSmexrRaBRtbW1xSmVPpaNnyBQ910u7Kwq7aMw0m82YM2cOUlJS8O9//xv19fU0DNsGSLnY7Xbk5+fjueeew6mnngq73U7jmz17NqxWKx599FGsWrVKanzQytPBamMkL3a7HcOGDcPzzz+PSZMmAQBqamrw/vvvw+fz4aSTTsLIkSORlpaGTz75BNOmTcPWrVulO120ytrv9+O4447DwoULcdJJJ+GJJ57AY489Fjcek3nw7rvvxtdffw2bzQar1Ro3//Pz4tEKs9kMt9uNvn37ol+/fggEAtixYwfq6+sRDocPiUHGaPkmRDR4JUpGMGRCGFUC2AlfZFXWi0PLeib6RovwWCwWOBwO2pgdDgc9o9HU1ITGxkZEIhEqJ1lSHjRoEPr06QOz2YzMzEyYTCakpqYiHA7D7/cbGiS0lCPZZGKEdBGw4Ygy4HA4kJeXh/79+8NsNiMtLQ0+nw+RSATBYBDhcBgulwvFxcU4cOAAWltb4yzCIku4Vn4ikQiam5vR1tYGm80Gp9NJV4BCoRA9dGwymeB2u2Gz2WAymehydiQSoaSE1AO7wkLkYYmFqK3I/idbPxRFoUSL5Fe0/UymJMrSIYqY6JA5eUfqh926QuojGAzSSY0dWGTpaoH9hpWHbTeRSKRLA1hPWdjJbxnREIWXPePLiCWwfPtVlI6D8EVFRULZVq1aRZ1GEOTk5OC5557DjBkz6PaItLQ0PPHEE9i3bx+WLFkiLUu2vA6Hxc5qteKSSy7BbbfdhuHDh3cqc6vViuLiYlx99dVoamrCyy+/TFdziKykDbFtWKYAqKqKlpYWLF68GN988w1SU1Ph8XigKApaWlrQ3NxM4yerrcTYEwqFqDGkq8pFIv1EBll76um6s1qtKCgoQP/+/eFyubB//36UlpZSRy08Dkb7iUajcVZ4o3O0bG5iYYRkaMHIOKD1Xit8eno6PB4PVFXF/v3747bunHzyyUhLS6NOSxRFQUpKCv70pz/hxBNPxP79+/H4449j6dKlsFqtePLJJ3HGGWdg165dKCsrw4EDBzrJL5pTeFkP1thgNpsxcOBAvPLKKxg5ciTWr1+PWbNmob29Pa5vO51OnHnmmZg/fz4+/fRTjBgxAm1tbQkbOwjZmD17NiZPnow33ngDubm5dAVFVVU0NDTgnnvuwbp163DNNdfgwgsvREFBAcxmM5qbm7Fu3Tp8+eWX+Pbbb+nKsd58xY9temOIyWSC1WqlpJGc4zkUBjgCi8WCCRMm4LXXXsOgQYNoOygrK8Nvf/tbLF++XDoeHA4kRDRE0JsItRQsPg72f9G3fLqyMLyVUesbnpTw+wKJpymn00nPKNjtdni9XjQ1NcHr9VLFhHS6/Px8ZGdn0y1fZBmVrBLU1NTolp3oOT9Qy8pORAhl9UA6GTlPQlZi8vLyqNcnomRbLBaEQiG0tbXRlZ7W1lapvCxkkwe7DzYcDtMBmshktVqRmpqKjIwMuN1uejA8FoshEAjA7/cjFAqhvb0dra2tVPFmyQZZ0WAJB4mDXR3gy5m16iiKArfbTVdwyPYhdqLlD8jrkT52NUVWTwQ2mw1FRUW0XiKRCPx+P0pLS+OUMH7VkS9/mYLODrZaBgJeCef7klHy3NUBkK1DkYx67Z7/hpefJxvsu4KCgk7nMAjhfPHFF+PCW61W3HLLLTj11FPj2h8AOBwOXHjhhfjqq686kWJRfhOdsPXiEI21fPihQ4fi/PPPF5IMtg4LCgowaNAgOByOuG1jLNmIRqP0jAZpO6Ltlqra4RTC6/XC6/UKSX92djYmT56ME088EX379kVlZSXWr1+PkpIStLa2orKyEi0tLdQoYKRseMcKWmHdbjfS0tIQiUTQ0tIStwWWzUei/cIoHA4HbrrpJtxwww30HIDf78fzzz+Pl19+GaWlpXErriJjQU+AtHv2fyPfsOiuTHr9m09LJIMsXlkcEyZMgMPhQCAQiCNaZrMZ9913H4qLi3HnnXdi//79sFgsOP/88zF16lRs3boV999/P9auXUuV39dffx39+vXDxRdfjBUrVuDAgQPd7t89Wc9paWmYO3cuRo0ahc2bN+OUU06B3++PCxOLxeDz+fD9998jGAwiPT0dRUVF2LFjR5fSJGRjxYoVGD58OOx2O9xuN1XoFUXBoEGD8Ic//AHjx4+n54TMZjNSU1NRVFSE2bNno66uDv/+97/x6quvSj1YKUr82TMA1Hgn2xJosVhwzDHH4M9//jNmzZoFq9UKv9+Pp556Cq+88gpqamoO+kqCxWLB1KlTsWDBAuTn59PxVFEU9O/fHy+99BLuuOMOfPDBB73mDEvCKxrkt6hhiyyyIoVASwkjCjsbjxG5RApDd5Qu8p6QBOJRiljRA4EAmpub6QFmEjY9PR19+/ZFSkoKPZMRDAZhtVqhKAr1pCRSlrQUAP6dXlhZ2fPvWDnIwVan00mVBqvVCrPZTFcurFYrHA4H2tvb6YDJEzu+rNnzK2zaMvet7DmYtLQ05OTkID09nR6qN5vN1M0tGWhaW1tRV1eHuro6OhiyspF8EkuozWaj1lCyHYgnJ+w2uPT0dHro3+fzobm5Gc3NzfRbtiz51QBRHbEkR1RH7HcWiwX9+vVD3759KdkicZByqq+vpytlfHxsm5ApH6K+ptV/WSQyuXV3EmTbB4FoBYJNT6ufs+WjpbSYzWYMGzZMeOCxuroaP/74I40XAEaOHInf/OY3nUgG+XvAgAHSumLDsc+7U3Zahga+7BRFwbRp0zBq1CjNciHPyWqiCKznN9m4x0JWj1arFYMHD8Ytt9yC6dOn0/4YCoVw2mmnoaWlBa2trdiyZQs++OADuu9dBrKCS1aniQFBVsZmsxkjR47EnXfeiZNPPhkmkwkrV67EY489hh9//JGuqLD5MKoEG4WiKJg7dy5uvPFGDBw4kD5PSUnB7bffDofDgeeeew779+8/qHKwccviNzqX6fWBnkJPxGsymXDRRRfB4/FgzZo18Pv91OtWQUEBMjMzEQqFsG3bNrS1tSEzMxNXXnkl8vPz8ac//Qk//vgjbWMmkwmNjY3w+Xx0ztWSXa8Ou0psZfOToijIyMjA3Llz0djYiIceekjan1RVpWdS/X5/t9zNEjmIntXW1oaGhgY6d48ePRrPPvssLBYLXnzxRaxevRrhcBhFRUXo27cvBg8ejEmTJiE1NRXXX389srKy8MQTT6C+vr7TXGsymZCdnY2pU6di1qxZCIfD+OKLL7BmzRo0NDR06tMWiwUzZ87Egw8+iPHjx9Nt3DabDQ8++CDy8/Px7LPPYu/evQfVG9aIESPwxBNPwOl0Yt68ebjzzjsRjUZhsVgwfvx4fPHFF3j00UdRX1+PZcuWHVTiY7StdWnrVFcS4i2/ZDuKjGBoKUzsb14WLdlkCgcfP/s3mZCIUkqIhdfrRXNzc9xEarPZkJWVBY/HQ5XT1tZW2mDZ+zZ4ucgzVtGVQaY0GLHIsXGLlGFVVREMBuH3++Hz+ejBtkgkQrdNkdWH9vb2OAVDdtheVge8py4e5BB+dnY2dWVnt9upVTklJQUul4vudVcUhSoMrKth0p4sFgs8Hg+ys7ORkpKCUCiEuro6NDc3IxAI0DhI+djtdmRlZSE3Nxdut5su4aakpFALSEtLC93exaZF8qdHZmVgwxCyQ0iv3W5HOBxGMBhEQUEB3cZABmcZGTCiuPJhErWQidpiTyg6rPx8G2Lza5R0k7AiAi8qP6vViunTp3f6PhqN4qWXXkJzczOdXMxmM0499VTqrlWUdiJb0BKtAz2wq7YiGVRVRXl5ORoaGtCvXz9pPKqqYtu2bVi5cmUnSyd5zxt82Od8WBkURUFmZiauueYa/OIXv6BbFhRFoSvIubm5iMViGDRoEPr27Yu///3v2LBhg3DCJ1tEhwwZglGjRiEYDOLAgQPYtGmTcKuFyWTC+PHj8e6776KgoICOA+eddx4mT56MX/7yl1ixYsVBd7VptVoxc+ZMFBcXdyo/m82Gq6++Gjt37sSbb74ZVx8HW3nXGs8OVtoyObTed3ccMplMGD58OKxWKxYtWgSfz0f1mAceeABFRUV46623sHfvXkQiEcyaNQvFxcXYsmUL9uzZQxV1IkdWVhZcLpfwfGF3YXTM4A1bLMLhMA4cOIBRo0Zhzpw5+PLLL+l5TDJPms1m9O/fHx999BFUVcWyZcvoLofuQGSwNJvNeOCBB9C/f38899xz+PTTT+nZTo/Hg6amJlRUVGD37t2IRCKYOXMmzj//fGzfvh3//e9/O52NJWfubrjhBgwYMAAAMGPGDLz66qt47733UFFRQedTs9mM4447Dvfeey9GjhyJxx57DP/973/R3NyMQYMG4a677sLVV18Nv9+PZ599FhUVFQel7RMCeOyxx2Ljxo148MEHaV8PhUL44YcfMH36dHz33Xd4/vnncfzxx/eKO4cSIhr8pC1qDHoWK0B8R4aoYxhRxkQHw9m/2YmOT4e3ZpIf9jlhrWTLEPDTQTh2r6LFYoHT6aTLfA6Hg7q0tdvtCIVCsFgs9IIjvtx4+fUsRaLBk5ddVia8VZsgEomgurqauvIjJIs9TO31etHQ0ICmpiY66LArESKHAbz1mJeVzQ9pU2QAJ2VLziakpKTQMiayeb1eallyOp2wWCxxh6FIHKmpqRg4cCDGjh2LwsJCVFRUYOPGjcI9lmazGSkpKcjMzKR1qaoqVfaDwSCysrLg8/k6eWHiFSvZoM/XMavk8nVPvLzY7XY6wRHFhsjZ2toq3SfK14Fe++Hf6aE73yYKNi/s4T+tsHpxAdoym81m5OTkdCI1jY2N+PDDD+OIg9PpxOzZs6XuGQFg165dhvLa02DHORlUVcVXX32FkSNHIjc3F4WFhZ1WH30+H7766is8//zz+O677zSVJELIZAYSPqwIHo8HEyZMoPvjyZYA4iGP5MnlcmHMmDGYNm0atm3bBp/P1ylNi8WC448/Hr///e9x/PHHw+fz4eWXX0Z9fT3Ky8tpfybIy8vDM888g8LCQnrWhswNhYWF+Pvf/47zzjsPdXV1UvkTIYtaYYlrYdE3qampmDBhApYtW4aSkhJDafV2aBlD2PeJKNVdBSG2qtrhQdLlctEDuZMnT4bL5cLChQtRXV0NRVFw9tlnIy8vD//5z39QVlbWiYgOGzYMOTk5aGho0HTZfDDHUi1UVVXh7rvvxsKFC3HppZdi5syZKC0tpVukiKMbcob1s88+w9VXXx2XT5nBUQ+isLFYDHl5eXQ1iBgHo9EogsEgvdcsEAggLS0NtbW1GDduHC6//HJ8+eWXcd7xzGYzJkyYgOuuuw59+vRBQ0MDTCYT8vLycNVVV6GhoQGLFi1CQ0MDYrEYPB4Pbr/9dowfPx6PPfYY3njjDaor1dTU4Le//S0effRR3HjjjSgrK8MLL7xwULctsfePsYhGo6itrcXmzZsxcOBAPPDAA7jjjjsOCeHXQpfOaOgxb73BQWRF1IpD1tFYJZf8L7KUaVnXRWSJ/Zs0YpPJRBXrSCSCpqamTsqs0+mEy+WiSnI0GqXW7/b2drpaIDq0S+KIRqPS1Qwta7HMkisLx1usyXuySuH1eumhS1Xt2DdJDiCze1NZcknIBps3WV61ZCfP/H4/dafrdrvpQfzU1FRkZWVRP+TNzc0oLS1FSUkJysrKOrkbJnVTWFiIsWPH4uyzz8bIkSOxZcsWBAIButeaDETkXI3L5YqTkxBHcrDfYrGgqamJHroyqmhrEUi+DEh7CwQCMJvNCAaDcDqdaGlpgdvthtfrpQfFWVei/AqilvJihNCz8miF6WmI+jPb9rRIBi+bljFDZjwhCIVCWLp0KSZNmkQVW5/Ph3//+9/Ys2dP3ICfm5uLESNGaMq0atUqQ3KL5OOhRxrYcPwYKWsXXq8X//jHP7Bo0SKMHDkS+fn5iEajaG5uRmNjI8rLy1FWVpbQeQgtQ5KWQqKqKpqamrB48WKMHTuWrmoSSyN7p4/ZbEZWVhaKiorgcrng9/s7lYHb7caVV16JmTNnwmazIT09HVdffTU2btwYd+4O6JjQTzzxRIwZM6bT2EZkHj16NIYMGSLdC54ItIwTkUgEpaWlaG9vF15uqCgd54j0Lj48lJAZv2RjpVY7579NhLyx33ZVcVfVjgPgxxxzDE4++WR4vV4AwHXXXYfBgwfju+++w969e+l8lZeXB7vdjj179lCviURuABgwYAAyMjLw2WefobS0tEsyaUFPydcrh3A4jDVr1uDMM8/EggULUFhYiNzcXPot+b6lpQW33XYb3n//fVom7K3qxGkD0R2Mjtc8IpEIXnrpJTz11FOYNWsW1qxZg7KyMrS1tVFPmO3t7bBarSgqKqLnSvv3708dSxDY7Xacd955yM/Px8KFC/GXv/wFfr8f//jHPzB58mRMnz4dmzdvhtfrRSQSwfHHH4/+/fujuroaJSUldDcL0KEPV1dXo7q6GiaTCYMHD0ZBQQE93N+TUFWVnmV1OBzo27cvtm7dSt8rioJAIICSkhIMHz5cdx7qLoz2wS6d0RBZ1flJUab4sooPP+mxkzx7kJtX/vU6CO8FSUQkZJZ2Vl4A8Pv9tFGRLURtbW1obm6mygVZtUhJSaHnCABQb0jt7e1oamqibly1iBp/5wMvDy8/2evPl41osubTIc/Z78h+a3I/CPu96IAsOTNBJnmi4BOSxh7MZg9gs/HKJqNwOIyGhgZ6eV9WVhY9HJaXl4chQ4YgPz8fzc3NWL9+Perq6mC32ynRY/NKyAP5tqCgAOFwGH369MGOHTvQ0tISt/WI7Dl1u92wWq0AOg6KsbeUq6pKt3GRchS1T62OSMLybnnZth8Oh9HY2Ij09HRkZGRQ63B7eztcLhcaGxs7rZTJylQGkdx8HF2Z2A8G2LI2Ko8REqgVVzgcxoIFCzBgwABMnToVjY2NWLRoEV577bW4A8GKotCLPWWIxWLYs2dPp+e8XIlsn+SfycY0rVUWFqracanm5s2bsWPHDmpFZ503sNs9SNxEuSAGCmIoELm7ZI0UfNo8Wlpa8N///hd9+/bFlVdeSR00kLjYv51OJ/r06YOUlJRObnfJObQxY8bQvqsoCvLy8nDcccdh48aN1GMO6d/Tpk2j56J4ORXlJxegK1eu1CxTvf6jVy+xWAzz5s3DmDFjcMIJJ3RqH6qqYvfu3dTZyKGE1rys1y5F45SRPtrVsSiRcZFFLBbDY489htzcXEyfPh2nnHIK9ZRYV1eHv/3tb/Q28MLCQrrNuLa2Nu58A5kLU1JSYLfbsWHDBpSXlyc0vnZnLDZqWCJK69q1azFjxgycfPLJOOuss5Ceno6SkhJ88cUX2LVrF+rr66nBwWw2o1+/fvjb3/6GU045hc7FgUAAL730Eh5//PFOHqmMIhaL4YMPPsCZZ56JGTNm4I477sA///lPbN++HY2NjdT7HDm7VV5ejkgkgrS0NGRkZMBsNlNDgMvlouecli1bhsrKSrS3t+Prr7/GyJEjMWrUKAwaNAj79++Hz+fDhAkTkJubi8rKSqoPsvpOLBbDgQMHUF9fj+HDh6Nv374HhWgAwPbt2/Hggw/isccewz//+U+cc845dEVMVTsukj7ttNPg9Xrx+uuvHxQZCIzWY5e9TmkptXrhjVh7ecWAV1DZd2SSY9/zll2RPLJnpBMT5ZpY88kdGmQ/PJuWxWKB2+2miilZ/SBnGZqbm9HQ0EC3W4nyoTeIsoqVkbIk38juROBJCgFZVSEKLVuO7PkOYvVPT0+Pu5wwFArB5/PRi/bYrQjs9zIyxLqPJfePkHM9ZJUlIyMDubm5VPEm3mAyMjJQW1uL9vb2TmUUCoWoq0xCDjMzM5GZmYnGxkZ6/oaUDdlORYgKISKpqal0KxNpewDoQMa3O16h4hV49r2oTGKxGD1gV1hYCI/HA6fTiVgshra2NrS1taGpqYm2ST0LIlsPWn2Xz4MRkt/VSVwLImNEVyYqPbLBK65s+Fis466HP//5zyguLkZ7ezvKy8vppMO23ZEjR1JyKkIgEEBNTY3hMhKRRi2ljiXvPOFm2ytr8AE6twXWYMCOiTxMJhOysrIwceJEnHnmmZgwYQLS0tIQDoexYsUKvPbaa9i4cWOnOxfYdHklUyRLRUUF5s2bB7fbjfPOOw9ut1vYr6xWK0aPHo3s7GyUl5d3IkMulwtlZWUYN24cTcdsNmPUqFEoLCxETU1N3FYvVh6+DZEyIZZcGfQMW2xZsunwYXft2oX77rsPjzzyCI4//njazmKxGH788Ud89dVXh4VoAMZW2ruLrijYsnEw0bFKVVVs2rQJt956K/74xz/ihBNOoCTjlltuoR6lAGDy5MnIyMhAY2MjVcLZ9BwOByXLLS0t0oPWWuTLiDGpK3nk/w+FQti3bx8qKyvx/vvvQ1VVur2aGLcUpWOl8KabbsI999xDd3YQpKam4vbbb0dRURFuvvlm4ZkuUb54Wdra2nDXXXfhjTfewCmnnIKMjAw8/vjjWLduHTW2RaNRNDY24ssvv8Q111yD3NxcjB07Flu2bKGrr8SQaDKZkJubS/sR2RJeWFiIIUOGUKcSrMHUZrPB5XJRr6KxWIxuJ3O5XGhoaNAdD7qD5uZmfPjhhxgwYABuuOEG7N69GyUlJVi4cCFSUlJw5ZVXwuPxYMuWLfjss896hXGw2+5teYgsquR/UVi9AUmmnLHviSLI+lsmChqrNLBKs55FkMRDLNzBYJBOumx42QTS3t5Ot7SQDsm6IeXzwk4sMiufaELm5debFPnnvPIgUrJEJJEclCbeNhwOR9yhtkgkgvLycnqgitQTryjyChE/0ZJtQ/X19dQ6Qm4ON5vNqK2tpV5Whg4dipaWFmp1YPNLrLAkjVAoBJvNhvz8fOTn56Oqqop6t2DDk1UZco4jEomgtbUVsVgMLS0tcdssZMq4rM5k7pdJHOyWp3A4TJeGU1JSkJKSQhWc1tZWetCN37ohU27YPkDeiYhnIpOZ3iTe3QEvEZKhNa7IxhEtGcmEW15ejurqajoWkMmH7R+5ubmaE3t1dTVaWlp0yzVRxYKXhc+v3ngsg1aZK4qCgQMH4re//S2uuOIKeDyeuBXFIUOGUHeUa9euFbYRXiYZ4Q6FQtizZw+eeeYZ1NbW4rrrrkNqamonEqQoCvLz8zF8+PA45YIgEolg7969cemaTCb0798fRUVF2LhxI+1/kUgEmzZtQiAQoPvzST8hqzxbtmzBt99+q7ttyqiSrNUWI5EIVq9ejV/96leYMmUKpk+fjpSUFGzcuBFfffUVduzY0aWbmROFkX54MBQco3GazWbk5eVh7ty5GD16NFatWoV///vfdAtzV9MOBALYunUr/u///o9eYrl69Wrs3buXKs8mkwk5OTmw2Wzwer2d9uqrqooRI0YgJyeHKqlG2o7e854YX2XPidFPFs7pdOKWW27BfffdB5vNhg0bNuDpp5/Gxo0bEQwG0a9fP/znP//BpZdeipKSEjz++OPSPGvlg2xTuuWWWzBv3jyMGzcOf/rTn3D33XdjxYoVtF2SPt7a2or8/Hyce+65+Pjjj+lB9VAohEAgAIfDgcmTJ+Odd95Bc3Mz9u/fD6/Xi6KiIhQXF1O9Zs2aNaiurkZeXh7Gjh2LWCxGt3D6fD643W5MnToVbrcb69atw86dOxMtfsNQ1Y77Mp566im0tbXh7rvvRmZmJsaNGwdF6dhZsmHDBlx++eWaZ38OJbrsdUo0SbMDpGjCI2HIgCva8sO7JJVNrKxiSu62sNvtdDmLeE1iFSr+kC6fNz4vJH3WoifKD4mbsF729mRynoEcVuJdpvHxsP+LCABfvmRClNUDn3c+v6IJnf2G32pB6i0lJQUFBQXIysqi90s4HA6oqkqt/7m5ufQmdFZmNk3+8DhZQSCTP/DT4fuamhrYbDZkZ2ejsrISqampsFqt1BpELtEhroRZmUOhEFpbW+Nus7Xb7UhPT6fveTmIa2K2PMh9AcTrGNkKZ9RiqQXyHSEgbP2Sd83NzWhtbaVKDruFRUuJ4yHqWyKCKevHMtllzxNRbHk5jaQD/HSbdd++fTF8+HBkZ2dj165dWL16dadDwXxcRuuMlLfWd/v27ZN+r6oq/vOf/1DDhRZEZc9vO2QVPlmfJpBtWRUpK0brKz09HZdddhmuvvpqpKSkdPrO4XBg0qRJmDNnDn788cdOSr+oz2iVSzAYRElJCf7zn//AbDbj5ptvjrOcEtltNhsGDx5Mxwe2bNra2rB06VL8/ve/j5uLyLkvVp5oNIqVK1diy5YtGD58ODU8kC2y+/fvx5/+9Cc0NDTollWiyrmMcITDYZSWlqKmpgaff/45zGYz9ULHH2Q/XOiKDHx7T6TvE5jNZmRnZ2PFihVIS0ujzkHOOecc3H333TjuuONQVVUlXHHm0xX1BTKX79+/H/X19TCZTAgEAvSOBzIu79q1C21tbcjIyIDD4ehkSPvlL3+J0aNH48cff8T+/fuleoFRHMw614vbZDJh1KhRuOeeexCLxXDcccfRsxMkX2VlZZg2bRq2bNmCu+66C0899VSXzjMRo9vu3btx//33Y968eRg2bBjuv/9+XHnllXSl2GQyobW1FevWrUO/fv0wYMAAumqhKAqtw2g0igkTJlDDXUlJCZqamqAoP92fFY1GsWfPHpSVlWHgwIE455xz4jwQOhwO5ObmIisrCwsWLMDChQvj7hQ6GIhGoygvL8dTTz2FH374Affccw9Gjx6N/fv346mnnsI333xDd4L0BvTIigbfSbVIBqtAacUlsqzy7lDNZjMcDgfdu06+s9vtaG9vR11dHbxeb6fBV6bEsxMBP6ETssEeuGW/IQfEvV4v9TJFtt5EIhHqRlVrstFS/olM/MQsmqh5IkfAW9BlkG1TI7BYLHSZ0Gq1UosM6cisFxhWJlYZ5stBNKizeQuHw/B6vaiqqoLH40FmZiZUVYXH46Fbtdra2ugyNH+ZFPl+37592LRpEwYPHozs7Gx4PB66/5oliIQkBgIBeu8GWSYNhULwer30XAexchq1kPNb2XivaCKQNsjmhy0fvv2y8fNthW0f/DvR3R58Hek9M/qtDDxh5vMmCu9wOHD88cfj/vvvx4gRI2h9NTc346OPPsK9994bRzb4MUrWFhMlI6qq4vvvv0dVVRUKCgo6va+vr8eCBQsM3VirlyZLNLRIBt+mZCu6orDsM1HcEyZMwMyZM4Ukg3zrdDqRkZGh2bZF34mek62su3fvxqJFizB69GjMmDFDGCe7qsnC5/Nh3759aGhoQHZ2Nk0vPT29k0cnVVVRXV2Nbdu20QsbifEhEAhg6dKlWLNmja6imAjJEM2P/LekHESXJB7JkOkORknGgAED8M0339BVRdJWioqKkJ+fj2+//RbHHnusdGuLSJfhQeaAlpYWSjjtdjs1NEajUaxZswa1tbXo168fxo0bh127dsHr9cJqtaJ///4YMWIEnE4nPvzwQ2zcuLHLSrfW/zJo9X1+vDNicHC5XHjuuedgs9nwzDPPYMeOHZ3upCHemYAOt7JdBelHwWAQP/74I5555hn8+c9/xqRJk3D++efjrbfeot6oyD1cJpMJTU1NnVzer1mzBueeey5ycnKQnZ0Ns9kc5wGM3G0Si8Xo9ndFUdCnTx9qvIhEIrDb7UhLS0N9fT1WrlyJsrKyQ9IXY7EYmpqasHTpUqxfvx4OhwOhUIjunOGNYocTPbZ1SmRF70ocoi0dQPzkSBqR0+lEbm4uMjMz6d0C5L3NZoPb7e50noKXVwZy2IeXg6TNWtzJakZTUxN1j0gOGgaDQbS2tqKsrCxuadWINyb+mcjaxf7PK2RsGP78iihdFmw9isIRKyI5O+F0OqlVjQy2DQ0NnbacGZ1sRRNzKBRCY2Mj9u3bR7ekkQklHA6jubkZlZWVcQejWcIaCoVQX19PrZNjxoyBqqqUaBDCQNK12+2UjLC3cZNJpbW1Na6M+LYrIrO8RVmk9ImUW74vyJ6JvucVdy1llCc9IjkPxSDKl5NWmqmpqTjvvPPwyCOPIDc3N87C7fF4cNZZZ+Gzzz7D4sWLpXF0JU+swYNdVSovL8ftt9+Op556Cvn5+bRfHjhwAHfccQf27t0rnQBERFskK99W9foyC34FVEasjFiUU1NTdUkEudBQT5nSmjt4qzI5qP76669jwIAB6N+/f1x+6uvrsXnzZuFWQqIQfvbZZ7jyyitpvol3HL7/DBgwAKNGjUJmZibdMhGNRuHxeDB69Gh6p45MXhKPEbDjCE84ZErvzwVaZUjORn322WfIzc3Ftddei2+++QbhcBjhcBh2ux1vvvkmTjjhBNxwww148sknOxmjREZSGdkgc5rNZkNGRgbcbjd8Ph/dSdHS0oI//OEPeOaZZ/DAAw/gqquuwvLly9HY2IgzzjgDo0ePxptvvomFCxeiqanJkIGgK+XSE+H1YDKZUFhYiFgshm3btgkNu263Gx999BEA4IsvvuhWuyV9pL29HYsXL8aIESNw9dVX495770VtbS1++OEHBINBZGRkYNCgQTCbzfj000/jDE3EIUdVVRWysrLwi1/8Ajt27EBNTQ2qqqqooZi0h/T0dPTr1w9ut5tulXM6nbBarUhLS8PQoUORnp5Ot3LK2k1PgswDxDtnVwxjhwo9fkYDEFsFjBAQXrnlFWaiOJILl8j5AJfLRcOSw8gA6N0LvIXbiNy8DOQ9USzIfQrAT7dYBgIB6r0gNTWVEp2amhp6oZcRK4RssNObhHkLMB9GKw5eIRWRFYJYLEa3pRFlh7iRbG9vR319PYLBIKqqqmjZk/i1Bm4+PfYZGZiCwSDq6+upxbqtrQ1utxuxWAx1dXU0bf6ArqIo9JDYrl27sGPHDqSlpaGioiLulnMiK9lWRSxWDoeDbs0hRJacjzBaN+yWML4cWPKgV0daymUiRF/0PUue2TBdNR50F6QPyizCDocD06dPx6OPPio9G5Gfn49LLrkEn3/+uZCQ8W2O7/MyJYC934V4aiPneRYvXozq6mrMmjUL06ZNw65du/DGG29g/fr1Qi9MrBxGlEutMtECOxbzbYUvD5Exg09v27ZtWL9+PYYPH95pFTQWi6GsrAzvvPMOPvnkk4Rl1Wpz5MzbV199hYyMDNx22230Iru2tjYsXrwY27dvF640xGIxNDc3Y8GCBTj33HORmpoKoOOQfkVFRaf7dCZOnIihQ4dSBwxkLrFYLJgwYQLGjx+PAwcOSOujq4qgkZWNox1G85ufn4/FixcjLy8PY8aMiTszAXSMa3fddRdWrFiB2267Dc8884zmGQF+/hXJQsaAvn37YvTo0RgwYACqq6uxcuVK7Nq1Cxs2bMCzzz6Le+65ByNGjMCgQYPopbOvvPIKXnrpJZSUlCRsCD3UyqSesScQCOCf//wnHnnkEdx222346KOPEAwGYTabkZqaitNPPx333Xcf+vXrh7KyMtx5553dkpt8Szx6/b//9/9QUFCAs846C4899hi++eYbbN26FZMnT6b3ZS1btow6iCHf+3w+bNu2DX369MF5552HTz75BOnp6Rg4cCAsFgvKy8vp2ccZM2agf//+KC8vx/z587Fq1SooikK37F955ZX4xS9+gfHjx2PAgAHYtGmT4bLVmn8SKZPDMTYYJVRdIhpaW3CIEiXaDiJSsvl3rELKfstmyGq10v20ZKInh3vJRWbkkjV2+VzG+ESdWubhipCM1NRUejiQbNshB4zI8pXVaqXv2UvdRHmVERBSlnoXE/J/s4qEXkPgFQ9eAebjj8Vi9HB2bm4uzZvZbEZrayvdQka8OBmxurKElKTLKuSspY+QN1Xt8K9Pblf1er2UaLB5YT1J+f1+lJeXY8WKFaiqqkJTUxN27txJ/WUTMkuUSKvVSuuZXTEjYYyArRPSfgiIYsqWgaheALHLZz1iwdetXnvgz5scSmgpvTKMGDEC99xzj5RkkMlg8ODBhkg2/62sD5lMJrjdbgwdOhT9+vVDU1MT9u/fj3379lGX1qtWrcK2bdvwyiuv0O2T/JYCLchIBnnXE5O17J2IbIjKYd++ffjf//6HQYMGYcKECbBYLNRL2vLly/HRRx9h3bp11GuaEbmMtrtwOIy6ujq8//77aGlpwfTp0+F2u7FixQosWbIE9fX1nS4KJONIMBhETU0N/vvf/+Lcc89FfX09PvnkE0pOCMjlfi6Xq9PZMXKp5/jx4/Hxxx8LV0+0wI5vojN0LCkk+DkRD6N5M5lMWLp0KfLz83HmmWdi27Ztwvl0165dUFUVOTk5mluD2bS12j85qzhu3DhcdtllGDBgAFS1Y5//Sy+9hK+//hqffvopSkpKcPXVV2PmzJmw2+145pln8Pbbb6OsrMzweNATBLa7kM0doVAI8+fPx5VXXokRI0Zg3bp1CAQCdEuZ2+1Geno6Vq5cibvvvpuS8u6A9BniEeuRRx6Bqqo488wzccEFF2D27Nmw2+2oq6vDgw8+2GmlhayIkLM2AwcOxAsvvIBoNIrMzExUVVXhhx9+QGNjIxRFwfjx45GTk4PPP/8cmzZtog5oiOOLr7/+GhMnTsTYsWMxcOBAQ0SD3Md1/vnn49e//jVCoRD+97//4dVXX6WG3N4Oo/XY5RUNorTwqw28UiRT8gn4wuSJh0jRJS5VPR4PVR7D4TDdkkQURuIpiFXKtCYyXhljZSHPyfmE4cOHY9CgQWhra8O2bdtQXl5Oz2OQvXHESi7Kg55VQot8iNz4spZytlzZ8mfdn7Jxi2QTbe8iJENROva+VlRUoKmpid5SGY1G6cE4EbFi09DaviFSONk4iCJHvDCRrQyBQAA+ny/uXgNWbpKvhoYGrFmzBjt27EAgEIDX60V7e3vcQVWz2RxHXNn2TS4uFFmiZG2eEJOUlBR6oVYkEkFLSwv9jpArnozyZcHGKyo/vqxFz/UgIvi8PIcCsjYEdAzyhYWFGD16tGb+YrFY3CWTsnRE/UBEuogDimOOOQaXXXYZzjjjDADAa6+9htdeew11dXXUmUBDQwOampri8mIkz0QGUVmwYboL2Tgg6o8iohoMBvHVV19h79696Nu3L707oLGxEZWVldSld08cUhZ9H4lEUFtbi48++ghff/01FEWhXthYl5REfuKsAwD27NmD1157DT/88AOam5uxb98+1NfXdyLx/fr1o9tlReUk2vqilVey1WTmzJkYPXo01q1bhy+//BJ1dXVxbZQ3MInag6jOjgYYNTQAHXv+Bw8eDFVV8e2330qVcnLQX7SzQEsOGdFj65E4HohGoxg7dixuvfVW+P1+fPPNN9iwYQP27t2LJ554AiaTie5w6OoBcCPf8PMo/2138i/6trq6GpdddhleeeUVTJgwgYYFOi7/vOOOO7B8+XLs3r07IWOLnmxkbN+1axfuv/9+rF27FpdffjnS09OxZMkSvPHGG1i7di31FElAjCHLli2DzWbDWWedhSFDhsBsNqOsrAz/+te/sGbNGvj9fiiKgtTUVNhsNpSWlqK+vp66tidbxwsKCpCRkYG6urpOl4SKYDabUVRUhGuuuQY33HADPXM6YsQIjBw5Eg8++GDcWHSko0tEgzQgotgSRRP4qfLJ37xSxCstWko/SYOf9Mh2FmI98/l8cXc/kLBkz6RsYNFS0mRWXbvdjv79+2PatGmYOHEiXblob2+naZH8s+cSeO9K7EDAKpiicpBZVgm5ILfjEo9brHLGbgfilVi+DNj4+TJhy4HkhT2MSPapi24J5uPVqwuWPPF5ZgcLlmCyedXaokYISW1tLerq6uh3ovMVoVCI7u9lXZn6fD60trbSdseWt4hUkfJJS0tDUVER3G533MVBVVVV0tuVRS5wtRR/liTy7ZlfZdTqlwcTPbVSQm57F12mRqCqKlpaWvDRRx/p5osvD9mkSu5iGD16NC699FJkZmYCAG655RZs374dS5cujXMraMQyJVMK+DaplweTyUTHR/7CTCP516ob2bu2tjbs2LEDe/fupQo5b3Thx7/uyMGHjUQi8Hq9cZdWyYg6Szai0Si2bt2KsrIyxGIxtLa20kOe5LtwOIy9e/di8uTJwjIoKyvDkiVLDB/mVZQOd8D/+te/MGrUKLhcLlxyySVYt24d7r33XuzYsaPT2QE+v6Iy6A0g25rZi8zC4XDClllRnWnlsaioCIrS4UlI5u1HURTMnz8fJpMJf/zjHzsZiRIdk4jTmTPOOAOjRo1CY2MjbrvtNpSXl+O5557DscceiwsuuAB79uyhe//JYWgy58jGXC1Z9OpaUTpWcKdOnYrf/e53dCWX9JPq6mosWrQI8+fPj7vduruIxWLYsWMH5s6di6KiIvTt2xepqamorKxEaWkp9u3bh9bWVtoeetJQQsjG/v378eqrr2Lx4sUwmUz07jJ26zxJlxiod+3ahWAwiN27d2P48OEIBALYvHkz1q1bF7ciSm53T0tLg91ujxvPsrKycOyxxyInJwfvvfee7mqGyWRCdnY2rrzyStx4441obGzEe++9B6vVilNPPRWXXHIJYrEY7r33XmqIPNKRMNEggwix0FqtVqpkspZ80STJQsasZZZU9j0ZzFjvAiRtopiRC+PYeyu0BmmZ9ZAnOampqRgyZAjGjBmDY445Bm1tbdi/fz+2bduG2tpa6uZOa6WGn0hFW2JkYFccyAqLy+VCWloaUlJSqGtZVVXp6oLf76f7E8mdFnz+eZImqgs2D7zyoucT26iFSkvJ4wdmQip4wqg3ObOKD3nPpxsIBNDc3Ay32x23TYp4nGpqakJLS4s0Hr7dWCwWZGVl0f3gpA07nU6kpaVRN7myvfuydqHVT0RlIFLi9L4X1T8L4v3N7XYjEonQbYQyGG0LfPo8SNvXiicUCmHz5s14//33pXGLrH9a5WqxWJCTk4PLL78cWVlZtP/m5uZi2rRpWLt2bdzlj1rxkXcyGFW6FUVBZmYmLrjgApx33nnIycmBqnZ4Z6msrMTq1avxxRdfYPfu3YZdL5J+zq6UitoAUWLY8aO7ikQiZIOEF40FonDAT26KiTGKfcYiGo3i2Wefxemnn46srKw4mSorK/HXv/4VJSUlhvPrdDrxhz/8AVOmTKEXDqakpGDGjBm4/PLL8eyzz8ZtM9PrK72FZDidTkycOBF//vOfaTn5fD58/vnneOSRR6QX0vUEiOMVsp9ehNmzZ2PChAloa2vD66+/npCCLSvj1NRUzJgxA5mZmbj99tvxzTffoL29Ha+99hoeeughekZgz549ce3Z6HZio3IQmEwmFBUV4Ze//CV+/etfIy8vL84Io6oqhg4dimOPPRaXXHIJ3nnnHbzwwgtSI1ciIP1v9+7d2L9/P9auXQuLxUJdLrPnOXu6zZL4IpFI3AqyFpkDOuqhpaUFJSUlqKyspHfhkG3fpFxUVcX8+fMxZcoUnHHGGdi+fTt1cT9o0CBcf/31mDlzJpYsWYJPPvlE19W1yWTCmWeeiRtvvBGrVq3CX/7yFxw4cAAmkwmLFy/GrbfeitmzZ2P//v14/PHHe00f7w4SIhpkQjabzXC73dTbgsPhQDgcRktLC72IirUsy6ynWsokr4iz/weDQepBwOFw0G0uwE+KILmRk1guZAO1SDFkf7PykcPABQUF1NUhaw1ny4e1IpCy0CtbfjuRnnXRZrMhKysLubm5SE1NpTddkuU+so2svb2dlgchH3zetOpBRtBEyiv7N7/0nwjpYJU/PZJoxELKpkfkknlSInu46+rqYDabkZGRQQl1W1sbGhoa0NjY2OnQuSxtRelw8UnueSHWZqIYkXNGIgVQq454MiAqK7Y++PJmy6ArllJF6XD1d/755+OMM85AQUEBQqEQli1bhjfffBM7d+7UvDzMCEHSQltbG/bt2we/3w+Xy9XpfSgUwrp16/Dggw+iurpamJaIZOiBfNO/f3/avkkcRUVFyM7OpjfMsl7P2K2LXVnVkdWHyWSirn3HjBmDzMzMuBujw+Ewpk+fjrlz5+Ltt9/GO++8g/LycsMTmKj/8eRTZLzgxwS9MUWUrh5xEH1jNF4yT7HPRePg1q1b8dvf/hb33HMPhgwZglgshg0bNuDxxx/HypUr47ZK6OUtOzsbEyZMiCPIZHw4++yz8dZbb9GVVq189Qblg8iflZWFiy++GLfffjv69OkT55GwX79+GDRoEK677jrhXTZG09Aq19LSUqiqSi8yJVZgUq5PPvkkzjjjDMRiMVx44YX0fJ8oLaPlqigdOysyMjJgsViwa9cuaiyqqqpCMBiEy+VCbm4uxo8fTx0VHDhwgN7VQAyCPVGXiqKguLgY11xzDW688UYEg0G8+OKL+OSTT+D3+2G1WlFQUICZM2figgsuwKRJk5Cfn4/c3Fz8+c9/1jQMJQJiaJbFd7DaLasLGCGRLDkhu1HY7/mt53v37sVf//pX/OUvf8Htt9+Oa665BrFYDE6nE1lZWfj888/xwgsvCO8K4uFwOFBcXIzc3FxUVVVhy5YtNP0VK1Zg+PDhePjhhzF+/HhqOD7SkRDRICsYGRkZKC4uRnZ2Nr1jAOi4TKyqqgqVlZXw+XzSyUVmKZMpSOQ9eU7cx5HVDaK4kUPZ5FIz9pwAC1HceoSHyExWCMiKyb59+3DgwAFq3SaWXeLulb0kTmYN5PPIvlNV8dkX4tGhsLAQLpcLNpuNemJSVRUWiwVms5l6fyCX2VVVVXVSeFiFU7TtRgRZubLgy9VInDzBkKUlS1dLMWHrVHT4kleWfD4fKioq0NjYSBU3cmcHue2dj1f0N9nTTw5+p6am0m1XxJtVXV1d3NY2PSs36x1KFJYvSx4sCRQpgixEJBgABg4ciIceeginnnoqsrKyqPODQYMGYfDgwXjyySexcuXKhK2HIplFfTQcDmPdunV4/vnncdttt8UpOLW1tXjvvffwn//8Bz/++KNwhZE1DIhWk2Ttjmyzqaurw8CBA2nYaDSKVatWIRqNIiUlBQMGDEBqaiq9HKqysjJuHJDVm+iZVvsfNGgQ/vKXv2Dy5Mn0kikC0vddLheysrJw2223oU+fPnj22WexZ88eYVpapIH9m4wXIsLGE3d+5c8oDqZiwpMlQNzOAoEAPvvsM+zZswf5+fmIRCKoqqrC3r174y4DNIK8vDy6ksFCUTq2VGVmZsatLrOysv8fbpBySktLwznnnIP77rsP0WgUd9xxB9asWQNVVXHMMcfgz3/+M8466yzMmzcP11xzjabBLdH5gsDr9eKvf/0r7rvvPixZsgRPP/002tra8Otf/xpFRUXUxekFF1yAFStWGNo2ZUQOVf3prhZyB0s0GsXMmTORmZmJuro6zJkzh17mBgDl5eV444038Pnnn6O2tjZuFa079Zqamopzzz0Xv/71r7Fq1So8/PDDqKioQH19PR3rbTYbVqxYgXnz5mHChAm46667cNVVV0FRFDz00EPd3kalJX9XDCsHG0RemSGYzU84HMaqVavwyCOP4N5778XEiRNhsVgQCATw6quv4t///jdKSkoo2dRCamoqsrKyEI1G4ff749pja2srampqYDab6T1lPzuioSgd/pAHDBiAvLw86laWuHolCjCxnBMliLX6k0rgL+RjlSdy3oIFW+nkPoRgMIi0tDR6+yvZN89fViKaLPWUK/4ZCev1erFz506sXLkSbrcbBw4cwLZt2+hZjaKiIgwePBhZWVnw+/3YsmUL9uzZQ0lPogOtzPJitVrpHQ+E9RLrOLkNNRqNwul0UstJTk4OvF4vVZJFk52sPFhlR0uJN2Ipkg06PKnTghGFXOtbAl5RZ/NBBoJgMBjXNo0uAbMKGdk3r6oqXbmIRCJxWxC1yDb7nJBBrT7C5oldcWP/FpWhVl9h4XK5cMcdd+Ccc86hhywJMjIycNppp2HDhg3YvXu3YY9DMmiVdXV1NebNm4eysjKce+658Pv9WLFiBTZu3Ihdu3ahurq60y3cJP9kCyifluhv9ltyU/3rr7+OMWPGwOFwIBaLYdWqVVizZg1MJhNOPvlkXH/99cjPz0c4HMZnn32GJ554Aq2trV26nEsGs9mMm266CePGjetEMkRh8/LycMkll+Crr76iXm+MQKSQs+fDyP8kLHs2jG1vRwJEsra3t2Pz5s3YsWMHVFXtdNDcaN6Ki4vjvM6xsNvt1LtVoh6sDgesVivGjBmDhx56CM3Nzbjqqquwe/duehneli1b0NLSgnfeeQcnnngi+vTpQ731GIHIaCNCLBbD888/j6ysLFx//fX461//img0iqKiIthsNqxZswYPPPAAVqxYQcdeLXKhZ3Qk8sRiMaxduxbHHHMM7rnnHgwfPhxDhw7FtGnTaPmQW6cbGhpoeV177bVoaWnBsmXLqBGyO2OCoig49dRTcdttt2Hnzp145JFHsGHDhk7k3ufzwefzUZIciUQwb948nHLKKfB4PNJLDEXp6RkVjxRo6X88yOH+iooK5OXlwWw208s/a2pqDJ9HKigoQL9+/eDz+eD1euOMNKwTIXLejnXTfKQiIaJhNpvpLdzkQAxRoEgBu91u2rEAbYWQf8Za1UWKLvuMeP1pbW2NO3jG77M1qgzK/udl8Hq9+PHHH9Hc3AyXy4WWlhaUlpbC7/ejoKAAU6ZMwfjx4+F2u+ndGeRuDf4MBD+QigY40YoPOYhGLMjkYkFFUeDxeChRI1uoFEWhW0s8Hg/dwyhSNmXlxXYEvmOw741YaWUDt6idJDJ46a1m8AqPTDEnspBveIWCVdjZZ7I42XTZiYWsaLDESkQ2+OfsWSRZntnv2DD84XIZoeCJOF/Oxx57LCZOnNiJZJD3Ho+HWmgTJRqitGWyRCIRlJaW4q233sLSpUuhqioaGhqEBw/5+uCt8CRtPdnIpP3FF1/gmWeeQd++fekFcu3t7UhLS8Odd96JESNGUEcCaWlp+OSTT7p8C7AMHo8HJ554ou5ZFQJF6Ti8eMwxx8Dj8aCxsVH3G722QAgbSzTYtqpnpDhcYPOlV3aEXGgd1DYCLY9HivLTttsjAUVFRbjwwguRl5eHxYsXd1JuCTnbs2cP+vTpg4suughPPPGEND5ZuRgp55qaGvz973/Hd999h8ceewxutxuvvfYaPv/8c+zbtw/bt2/vkbMILFpbW7Fo0SLk5+djxowZ+N3vfgePx0PvYyGrV48//ji+/PJLKIqChx9+GOPGjcOoUaOwYcMGup1Mb/7VgtlspsorcanNO/5goaodDjJ27twJv9+P7OxsjB49Gt99953hNGX6XG/q34lAZnDjw7S3t2PLli3Yvn07NTrJzlbK4HQ66e3oZNs/GSPZbfdkPDgakDDRSElJoW7cyFYF4mEEQNzha74CSEWKPOmw73nwiigJTy7KI+jKAS896zrf+Ijv9ra2NrpUGgwG6S3So0aNwpgxY+B0OlFRUYHdu3dTQsArfXr55cOxDZDcSknCRCIR2igJC2ZXkex2e5xbOdnAxiu0rJIsUsxYhdfoICMa+PSUf5GMWmXJEwuR7FoTOlGQRERP1HZF9cWWYzAYpHtlSZsl26ZEBIBPk8+3SAZiCeWVFSNKu6wM+eekHE8++WQUFBRoliFxL90VyNq9qI3FYjE0NTWhublZStp5+flLE1lyyYaVgRgQXn75ZeTm5sLpdNLxoH///hg9ejTtn6z7Q7vdLt1u0xXiU1xcjKysrIQmJEXpONCud5eAnhyq+tMBbJYss97fDtYB0J6GUfm6m4/S0lLqI1/kulZkZOuNUJSOMwHnnXceqqqq8J///Ec4/5rNZmRnZyMSiaCysvKgylReXo6PPvoIe/bsgdlsRnl5eSdLsxFCqQV2FS8ajWLfvn14/fXXUVVVhWnTpiEtLQ1btmyBx+NBcXExDhw4gCVLluCHH36AyWTCzp07MXbsWOTm5tIdIaKxh8DIvJqZmYmioiK60koMjKK4ePCrkd0FK293jIa9GezB9q6grKwMu3fvxgknnIDMzEy6zZ41YrJG96MBCRENchja6XTGbSUhUFUVra2taGho6OTSkPwmhSea4EXWW5lSZWTyYhUlXvnTGnBYeUUDP/Gsw8ZFvAfl5+cjJycHiqIgHA6jsbGRKvi8dZUlAkZIBzsZpaSk0GV2dpuCz+ejbJmsahCf/mTpVCsNVsHjt7exYUWEhb17Qy9fBLLBVfZOq85FSqIWoeXbGMkDkV0P7MoCny6vHJPlUNYVMWuF1tqTbaStku/Yw8l65SEKx5eLjMCRs0EytLe3Y+vWrdSlY1cgI3pa4bUUeFl/5vumCGwc5JtwOIyKigrU1tbCbrcjNTUV0WgUHo+Hkgw2PGsYMEpo9PJ93HHHwePxSN+LEI1GUV1dLR0LjIAtM7bdseS6O5NxT4HvH4l+19PyV1RUoLq6Gn369OmkRMRiMUN7vHsDyJyXk5ODkpISbNy4sVMYm82Gfv36ITs7G5WVlVi+fHmnOPj66U55q6pKL8o0Ml4YNY6RcYOcd0pPT6fk3u/3Y8+ePZg/fz6WLFkCh8OBSCSCCy+8EOPHj0dDQwNaWlriXMwDP13UypJxWZ705BwxYgROPPFE1NXVYe/evULjrmjct9lscDgcNA+ifLNy8M/0cLj7fncgK/OeyFNtbS1KS0up4d5ut3cyWCqKQo3YRwMSIhqxWCzOzzhZiiQWg/r6elRVVdGORaAoStw9DyQudjKSLUmzHY3/bWSylt1PofUNkZffg0wmV3a5jFWwQ6EQPcxDlthYbxQysJZ3Pv9aMkejUbp1jeznC4fDdN81WXEiKxzkIiueVGhZu0VlL5OLrzcZcdTLlx54eRIhkez3ItIkU7pF+TICIgvZ6mc2m+m2QzKYNDc30zYiIny8HHz++PyL+oZe3Ynyyn7Lh9uxYwdaWlqQnp7e6Rufz4d33nkHX331ldDlJOlXJP9GFdJElT+2bbCHlkV3zYjKjIQlxD47OxsOhwPt7e2oq6ujB/ojkQgCgQACgQDMZjMqKyvjyltVVXr7vJ7bX7265UEOoSbSf6qrq1FZWak5iRktY74M+eeHE6KyNErw+DA9lZeWlhZ88MEHGDZsGL1/hRg2Nm7ciJqamh7dWncw4fV6UVJSgqysLMyYMYO6+TWbzSgsLMT111+PM844Aw0NDXjwwQfpFkpF6VhR69OnD/70pz8hOzsb4XAYW7duxbPPPouamppDdjBZa94l/d9qtcLpdOK0007DJZdcgpycHLrllaxqbty4Efv374eqqnC5XJg4cSKCwSBd7TSZTBg9ejTy8vJQX1+PHTt2oLGx0dDlgVrzE/DTZbDt7e1oaGgQGtd4pKen49hjj4WiKNQrpayMjMR3pMAouUw0bCIIBALYunUrtm7dikmTJuH888/H22+/DVVVMWTIEJxxxhlobW2llxseDUiIaIRCIdTU1NDlHuAnX8R+vx9VVVVobW2NKxz2vgByuyK5NC0UCiEQCNCDdawlmZ+oyW+ZRVZPyRRZ3USWY+J+1OFwwOPxwOPxUCtFMBhEe3s72tra4pZjVbXjgG9FRQVWrVpFL4PbsGED9u/fT90f8oo9a62VyUze8x2f+CVX1Q4PU+T+DlVV49x9kq06xF0r65KVlYktD3ZlQianyCrMQ7bsx6fLPpeREp5U8M9FMonikL03MpiKlBQtYkLas9lsRjgcpg4DSDhy2LympibuwLKISOvJowc9EsE/1wqnqioWLlyIk046CZmZmdSiHolEsGnTJixatAgff/wx9uzZE9eOTCYTUlNTMXXqVJx22mnIyMjA/v378cMPP2DDhg3Cm1DJ/yI3ySKwbUH0IyoX0ZiiKB0H+LOysjBixAhccMEFGDRoEKxWK6qqqrBw4UIsX74ctbW1tD8RpwF79uzB+vXrMW7cOMRiMezduxefffYZSktLE9onzudFlO+NGzfC7/cjPT3dkOIcCoXw9ttvY/v27Z0U2kSValmf6S3KiBZxO1wIhUJ49913UVBQgMsvvxyZmZkIhUJYvnw5Xn75ZZSVlfWa8tNCLBbD7t27MW/ePDz66KO47bbbMGvWLPj9fjidTmRkZGDo0KGIRCK444478Omnn8Y5LJkxYwbuuusuTJw4kTpTmDx5MiZNmoSVK1fij3/8Y4+fqdAbB/iwRG8ZPXo0fve732H06NEYOHAgbDZb3FybnZ2NRx55BCtXrqQeCb/77juceeaZOOaYY/D73/8efr8fOTk5yMzMxNKlS7FmzZpO9zB1Fbt27cLKlStx1VVXYcCAAZoKsqJ0OPSZNm0abrjhBpSWluKf//xnp7I+EtpgVyEqn64Y4boKVVWxcuVKvP/++7j55pvxu9/9DrNnz0YsFkNmZiZycnKwZMkSvPrqq0eFxykAUFQDJcjeiGi325GVlQW32033GxNvT+xNycBPl/u53W7k5eUhLy+P7iMnW3rInQT8hWWyPZUiS21chgTWbRk5YcMTQkS2QGRlZSEtLQ1Op5O67w0Gg2hubkZtbS3dEkXkJMtghYWFyMjIQFtbG2pra9HS0kK9YPEXWokUfVFeictaEpa4tu3fvz/S0tLoYfyUlBQoioJQKERXN8jFMvX19aipqel08y2blswDj9bAJYpHz4IuI4UioiEjJCxYhUzLYskSTNkWo0QGFJYYy1ZVCHEDOlaYnE4nXC4XrVNymSJ7i3JXICo3kVwErFWfh1bdAT9tGRs3bhwmTpyIfv36IRKJoLa2Fjt37sTOnTtRW1sbR55MJhMGDBiAK664Aueddx769esHu92O1tZWVFdXY8OGDXj77bexbNkyoStatm1qHfBm/xYpFmzZsKuTPKl3OByYMmUK5s6di5EjR2LgwIHweDxQFIVuNViwYAFefPHFTtsoU1JScPrpp+OUU05BMBjEvn37sHnzZmzYsAFtbW2drP9aBJnII9uKlJGRgfnz52PGjBmGbkh/7733MG/ePGzdurWTtexgWfAOJ3pKgejJcjGZTOjXrx/GjRuHrKws+Hw+7NixAzt37oTP5zNkZDjcIHN7VlYWrr76avzhD3+g3g+JYWXVqlX417/+hS+++IL2EbfbjYsvvhi33HILBg8ejPfeew/ff/89cnJycPHFF2PYsGFoamrCRx99hJtvvllKNrrSVmVEgy1vds51u90477zzcO2112LSpElQVRUffPABvvnmGwSDQQwYMAAXXHAB+vfvj9WrV+P//u//sH37dsRiMWRnZ+Piiy/GL3/5S/Tp0wcOhwMVFRVYvnw5PvnkE6xdu5Y6i0kUfL6tVivmzp2LRx99FGVlZXjmmWfw4Ycfxp0FcjgcKCoqwowZMzBjxgwcc8wxyMjIwJNPPok333yzx0hPb4eo3xsxPvR0f1QUBX379sUvf/lLXHPNNejTpw9UVUVTUxM++eQT/Otf/8LmzZupx9DeCtIPW1pa6GXEwnCJEg1i6SNbiti9huzBQOK3mexnTE9PR2ZmJsLhMLWYWywWeL1eHDhwAHV1dXF3E8i8JrDKHZtRUVheYdJSUMnAkp2djby8PGRkZNDVF5LnSCRCLwMsLy+H1+uNIwAWiwU2m426MQ2Hw3Tlg28wvFItko+31pNyJWllZmYiKyuL+ltOTU2lqx3hcBiBQAAtLS1ob29Ha2srJXfsdjLe4ixKVyQbC/asgp6SyudPlAb7PXvOg195ka1y6KXHQrRP2mhcRhR6XuFlt+SRVQ3SNkQKNBtnVydXPVe4orzx96nwCjrwE7lOSUmJI00ib0/Dhw/Hddddh4suugiFhYWdVihaW1vx0Ucf4YknnsDmzZulZcimL3ovu9eBDUviIP2SH09sNhumT5+OBx54AKNHj6YEg5U3Go1i06ZNuPbaa7Fly5Y4IwK55HHQoEGIxWJoaWmhN8knQibZ/LDnsPgwU6ZMwVVXXYWzzjoLubm5sFgs9JtgMIi9e/di9erV+PHHH/Htt99Sf++9eQLrKcjaAF+femVxMBQNcvcROUPH38vTm0HGLwDIzc3FzJkz0b9/fxQXF6OyshL79u3Dzp07sWnTJmrccrlcOP/88/Hggw8iNTUVv//977Fp0yZUVFTA5XJh6NCh9I4Xi8WC3/72t1iwYIEw/UTGQl5/0CIaBFarFRdeeCHuuOMODB8+HP/4xz+wdu1abN26FaWlpdT6PHHiRDzxxBPIz8/Htddei8WLF8Pn88FisaB///6YOXMmTj31VDidTqxZswbLly/H1q1b0djYSA8AG5WfJ0Ms+vbti9/+9re45ppr0NDQgJKSEjoOE/0lJSUFffv2RVFRESorK/GPf/wD//3vf1FdXX1EkNuegFFdgcfBKBtF6TjrOHr0aOTn58Nms6GxsRHbtm3Drl27DG2rO9wwSjQS2jpFMs36omYbKFuJhEVnZWUhJyeHnhcg1ncyGZIO0NzcHGdhkw0kMqs/nz7/v4h0sIoquWW7sLAQ2dnZSElJoYfzCJEi5Inc8MzLQbaEsemwjUVUTjLlSSs/RCltampCIBCgK01OpxOKolAPR+QAOCGB/ESmpSTzbmxZGdjvRR2XLVe2nEXkSjTo84SCfSf6RlQ+fHoykilKV+sZKwdfHrwMom+IwshemsjnTSZrVwYdNn4tEsiTNl4eUdmTbZPEFzgJx8vp8Xhw3nnnYc6cOSgsLBS2qZSUFJx44on44YcfsGXLFiEBF5EerYlDRuZFTg5YWfLz83HHHXdg8uTJUm9OJpMJ/fv3R25ubqd3sViM3rejKAo9NyVb/eLzKcoX25/4b1atWoX6+nosWrQI2dnZ1EkE6f91dXUoLy9HbW0tPSfS2yewQwG2PbHbYA8FVLVjq92RftgzFuu4HPPdd99Feno6UlNT4fV66Uo+KVeyonn33XcjJycHN954Iz788EM6DpJzT1arFR6PB/PmzcPtt9+Od955J6E60ZtfAPGWaT6NtLQ0/Pa3v8WIESPwl7/8BfPnz0dFRQWdQ00mE+rr67Fy5Uq0trZSkmWz2eicW11djSVLlmD37t0wmUyoqKig28sTWcnQMkYSlJWV4YUXXkBtbS0uueQSnHnmmZ3yHg6HsWfPHjz//PNYt24dvv76a9TW1v5sSEZvg6qq1DkEMd4TT41HW50kfBicVYxZyzhPMiwWC1JTU+FwOOhlZGTSJgMQ+Z7caM2DV2rZ30YGEK2KYicZRVHojd7sHnqz2QyHwwHgp8vVyKFvkfWJNA7enzzv5lc2cIiUIlb545XnSCSC9vZ2+Hy+Tgds2QsC+XhFqwQyaCmorOVYtvLAlzf/vUip1lJ6+bBsOYnKjv9ORoJkxFZGlkQep0Sy8bKQcjJCkHllX9a2tQgEG18i5EqLoIj6pZaVfuTIkbrucBVFQXZ2NoqKijSNDHxf4MOJCLKo/cjqjRCI4447Tjgmsd95vV7U1NQI44pGo9SrE9//2TzL5ODJPPsjynNJSQn27t1LnUOQNsq7mJVt2+qpSa2n4zsYYGUjYzXvCTEJfbB1HQwGUVtbSxVX8pwgPT0dt956K4YMGYKvv/4an3zyiXD/eSQSwdKlS6EoCoYNGyZNWzZ26dUdP76JjBcAMGbMGIwYMQLNzc34+OOPUVlZ2cnBDTnDRQx8tbW1cSQ+GAyipqYGTU1NccTyYCiSqqpi//79eP3117F+/Xr07ds37q6tYDBILzresWMH6uvr6TY9thy6I9OR0vf1dB7RNwcTspvJjyYkvKJhRPlnPTWw1iJeAScEBOisIIg6okwhE8nIvteKh71sipAIsu0I6HDRZzKZEAgEEI1G0d7eDq/XG2eJYtPkb8eV5YN/LlOG2f9FpEbUCWSkxohiQ8KJ6kFmURXlTaSYkucigqql/IgmFD4trQFEi0hoQesb0WRFZJPJwcstmvRYT2ay8tbqB4kMpHw/6Ep/00tLURSMGzcOgwcP1vUJzhJkI3Lz/YH8likP7DMZUSFyaMmgqh1uNN99913qaUYkI08qRW1cr0+SccRInYomLNl3fF0kqiRoEWXyrDcrHEDnVW3yTKvdJNEBtp/J9AIWHo8H55xzDnw+H9544w2pNx2TyYT8/HwA6PZhcKPjsCgcIQzsWT52jvd4PBg1ahR+9atfIT8/Hxs3bsT27dupXsC6sWV3FHSXZOiNF/X19fj666+p4ZFs42a3iIrGTTZ+0XOZLInK2BvQFbKRRPeQENEA5BM6+U1+iM9p4npVUToOUZJbEMkKQTAYpLf4kjh465/epMZPFjz4d7y8QMfA4vf74fF44qwONpsN4XAYLS0tCIVC8Hq9aGpqihsESTyEsLADiUih1lJe9SAiAbyiaWTgJ3GxlnleAWbjZOPTU0r1CKBoMheVj96AoKWEy0iKHmRlYETplsnHh2XbN6uMigiRrJxEcsueiSYWPfJmBKTNk+9FVnuTyYTc3FyhG1wWsViMniEwQjRk5JuF1oQsy2c0GsWBAwewatUqTJ8+vZNCHolEUFFRgUWLFuH111+PcxfNjn1ki6jRCVvPAKBFzLXAy8Y/l6Wvp4DoKXG9AUbGjt4k79EMs9mMtLQ0NDY2YvXq1cJyN5lMKCoqwgMPPIBwOIw//elPhupHL4xWW5b1vZKSEpSWlmLw4MH41a9+hQ8++ABerxc5OTmYPHky+vXrh4EDB2LChAkoLS3Fs88+i3379tGLjNl7rsgWRtFqdlegF4eqqpTYiAidEcOb3jjzc1LUeztxOhLQJaLBEgq2sxLFg23oAKgnCrJ8F4vFEA6H4fP50NDQgIaGhrhlVN7aJ1NI2Wc86eEVN5GiyD4LBoNoaWmBxWKhJIikEQwG0dbWRt3bBgKBOKWKvYSNvUCP5Em2LMamz+7fFpEttvz5/OuRC2KZ6YqyYtTaJ9pKJIpfpKhoyaOnEMkUZl5eLSIqaytahEukeIlk01JotLYeitqslpInIyp65cXLKjpHIKt/0t/Z9ioyEtTU1KC5uRkZGRnCPAWDQaxZswb/7//9P6xZs0YonygvepC1J616UVUVtbW1+Mc//oFgMIhhw4bB5XKhra0N27Ztw549e7B9+3Z8//332L17d1y5k62W5MJM1n03v+2CBalvETHhSW9XJjz+W6OETCtMb594ZX2Ef2/kLJrWs58rtMpC9C4UCmH37t0oLCzECSecgKqqKsRiMTidTvTp0wdjxozB+PHjqWekp59+Gq+++mq3ZNQj71p5aGxsxN///nf87W9/w6WXXoqxY8fC7/cjLS0NxxxzDHUn/fXXX+Ott97C559/jtbWVlgsFhQWFmLatGkYMmQIgI7b4Ldv346ysjI0NDRQpyxd9fLU3TaoN0cfChkON/T69s+JSB0KJEw0AGNbKMgqALHsKcpPZweINxRyJwU5syHyNMUqBjJFS08evUkHAN0WFYlE0NzcHHexIPEexbogJZMTcVmakpICp9NJ92aTe0LIVhCeMLF5Y2XkLdzsOxHxEuVLT6Hmy4l/zq/KGFF49SYekSz83yJFVvaNnsLMfiMioSJ5ZPmRkVVR2mz8fL3Jwonyp5Un2TO+7fDlqie31t8yGckqHpsnNkwsFsPXX3+N0aNH4/zzz0dGRgY9RE680+zatQvfffcdVq1aJbzgTySDVn70FAw9BINBLFu2DC0tLRg0aBCcTifa2tqwZ88eVFdXo6GhAe3t7fT8k6J07NcuKCjA2LFjUVxcjJqaGrS2tqKqqgqlpaVUuZAZTvSsjHrKAU+Iu5LvowVG2q0RZTMJMbQMHTI0NTXh2WefxaOPPorf//73mDp1KlRVhd1uR05ODgYMGIBBgwZBVVU89dRTeP755+H1eg2l3VUSriVzJBLBxx9/jNTUVFx33XU47rjj6G6MiooKfPHFFygpKcF3332HDRs2wOfzwWazYfDgwbj00ksxY8YMFBUVUUPLnj17sHHjRnz33XfYvn07mpubDXudOhhItvl46I2Z3TH0HM0wWh4JubcV3UDLKyZESSUemtxuNz1QTa5UJ4SDeHMiAsuUKZGllc2oljVKNAGLFHj2W37SF03yxIJJXMYNHDgQWVlZaG9vR2lpKWpra6lLWdZzFZtXfrWALwctKzwhbkDnsy+yrVB6JERWXvxzkSy87KLvZPWrRy5knVxkdReBdXkKQLhXlYTjSaERRYStSxFpMqrk6xFIvfCyNFn5RPv9Ex1E2TNXvDtn3l0s0LHiN2bMGEyYMAHp6enUTXRNTQ0qKytRWVlJtyNqKdFGFEgRujI5ECMC8TDHO1hgxyOz2Yzc3FxceeWVOPvss5GZmYmmpia0tbVh586d+OKLL7B161bU1NR0yiMZM4Gf7gcRjTt6snYnr0cjEi0TrTkkWaadQdzbytzQi8osIyMDv/nNb3DjjTdSpw9Ax2pHZWUlvv76a2zZsgULFiygF2GySMTKnGidyQiMy+XCjBkzMGjQINhsNsRiMVRVVWHDhg2oqKigHqYsFgv69u2L3/zmN5gzZw6cTidWr16NUCiEAQMGID09Ha2trdixYwfee+89rFixAvX19Qnfk6AXNkmcDw6S5aqNHnVvK1NQRISAvf2b9YakN5mKiAuxHOrJwyut/DM9JVvrb5Gl12azoaCgAMceeyy9AMfhcKC0tBRbtmxBdXU1mpubUVVVRS8s0vIuICNConA8kWBl0ypTPozoWyMrACJoycsq4jJiISIORicXGVERxSdqt4B8G4UMovywssjkYe+1kCnWbB3L8ir6zmg/EYUXESUjIPGwhI6VMRqN4scff8SWLVvi7g9hCZ8WweBl48McrAmAkCa2XYqUH5vNhrFjx+Lqq6/GMcccQ8NHo1GMGTMGgwYNwsaNG/HSSy9R7zUyIpuocssbGXoCRpX03mzlS6T9kvCA/jazJDogKhd+nOXDNDc341//+hdqamroXTqRSIR6Z1qzZg327dvX7UvKuvKtzJDj8/mwePFi6slNVX86WM1+Y7VaMWHCBJx++ulwOBx48cUX6W3ow4cPx+zZszFixAhMmTIFqampCAaD+Oabb+hdXD2Rn0TaexKJITkOdA8Jb52SWftFCgp7VkE2gMusrwA67f9mvzNCKEQKqxErM5uOKF0im9PpRG5uLgoKCugZlMLCQrjdbvh8PrhcLupPnBwwZ8uRjduo1Zz9Vo9EyQiHnlLHfq/lKcjoZM6TDFn8fNsQKTyyZ1rKN/+/SMnn2yMfpxGFlv1WC4m2Pa13slUK8o4npCJiJ/vGKPhyErUzVf3pAksjSIRoatVNdycILSJP2pLL5cK0adMwePDgOHktFgvy8vJw8sknY+zYsairq8PLL78Mv98fF39XFAS+HSeST702wIeVGSW0lEoRDvVk3R2FMwlt6LVbGRHxer14/fXXqeLOK+0yaBnLDiYIsdA6Z0ku+z3hhBOoB6q3334bu3btgqqq2LlzJxoaGjBs2DCMHj0aU6dOxfnnn48DBw5g27Zt3b6RO0kwugey/ReQuyJPonvo0hkNHrxCwVt5WYVSzxLCvieHyGXWaj0rFP+cJQkERpQUfmImg4vNZoPD4UAsFkNbWxsCgQBaW1vp2RNFUZCeno709HTU1dUJFVg9pTKRAVUv33y8bP5lSrKW8s8+5w82G504RBOWUYuqCFp1yQ4o7KF92UQnG8DZMuOfGYFWfRhJX+vbripXXbVOq2pnN848wUkUbNs00rd7cqKV1YOofMg4kJ6ejkmTJgnzq6o/7UO/6KKLsGDBAnpTsgx6ZcafiUnkpnG+j3d3VUI2HvBhutPGDhbY8bi3yHQ0QK8siRt5o0jE6EDCdXXc0TOk8nIoSscWy6ysLIwcORJ2ux3r1q2jl5iS7aX19fXYtm0bGhoaqLeq4uJibN++XShLInOJzBiQhD4sFgtGjx6NyZMnw2KxYMmSJdi/f3/yUtMeRpduBjfyXLYiIFKMZMo3e/BaFJbv8FrPeeWFn3RZZVNL6WQHD5fLRb1UkZvE6+vrsXfvXuzdu5d61RBd7ieLny8nEYkTrTJoKXbsOz0rlJ6100gb0GoPojqSERQZuWGhN6mweSL1Rs4VEAcAxMquNZnwaXSVAIrKWC8eIwSOV+75yVlLyesOyWAVXVn5ifIik4H9X6ucelJxFRkA+PesxYvAZDLBbrejuLgYffr06fR9NBpFc3MzAoEArFYrqqurhWNRonKKxiytb0Tfsu9F44JI+ZaNsXroTt85WCD3NQwePBh+vx/btm2Lc1WchDZ6muDLICMZRnSORNIg5y3JAW5yxpJ15sKD3FXh8Xhw3HHHobi4mN6UTnZxpKWlYerUqZg6dSqys7OhKAoyMjLg9XqlBgejfZoNn2y3icNqteLUU0/FFVdcgWnTpsFisWD8+PF48cUXsXnzZvj9/mS59hC6dEZDT2HWuiU6UaVNRlhkson+ZydYYtUmKxLEsk0Oa5P906z8rOxEuUhJSUFqaio9KEqsFvv27cP+/ftRV1dHBxuyfSoRK6aeksWHFQ38WkoFny+ZsiEqB600ZIoIm65WWD4dkRLIK5myNsX/b7PZkJGRAY/HA7PZjFAoBJPJBK/X2+lCI0Lo+JU4mQVZVK6isiLvtFb4RN+J8m4kvFYafDl2NW6tPMhIsV5bErWVniIWLKxWK1JSUpCbm0uVhNbW1k7bNUVt0mKxIDs7G6NGjYLL5YqTMRgMory8HKtXr0ZVVRWCwSCWL19OlVlZ3+T/5sOQdzIioNdW+HzI6sII+TXaztj0+G8P10ReXFyMW265BaNHj4bP58Nnn32Gd999F83Nzd2S6XDnqzegJ4hkom2rO+nYbDbMnDkTU6ZMQf/+/aGqKqqqqrBp0yZ8+eWXaGxs7HRuhOgQLpcLI0eOxNlnn420tDS0tLTA7XZj9OjRyMrKwjHHHINx48ahuLiYOsdpaWnBokWLsG/fPs07w4zi59zWugpFUTB27FjccsstGD9+PEpKSpCTk4M5c+bA7XbjiSeewObNm+nFzfy3LJLlr49ubZ0yYmnlJyRWoTFqFeGVOEIORLIQeUSWXWK5IL7u3W43rFYrIpEIfD4fvSNDdIsmIRk2mw0ejwcZGRlwuVwIBAKorKykXnSqqqrQ2NgIn89HvfCwbm67AqMKfyLxs4qzlmVVZIEX3ZnBQuQeV0uR4gkH+16mABslW2zcDoeD1lssFoPNZqPfeb3eThZiMpmw8pM9nPwqlUjBkJFkMrkpioJAIKBLvrSei8qAf6YV3mhY9r2ofti/RTKwhIPfaiVLn2+bWmWQSL4JnE4njj32WMyYMQMDBw5ENBrF/v378d1332H16tX0ll+WXLIH3rOzszFp0iQcf/zxiEQiaGxsRDAYxO7du1FXV4dNmzbhhx9+QHl5ObxeryGXlnqEXmubH2/c0SujRAwfsjBdGdN6QhHtDiwWCy677DLceOONcDgcUFUVo0ePRjgcxttvv92tbRNaBpWjHVoGo94Kq9WKM888E3feeScmTJhA689sNqOkpAQDBw7Eq6++ipqaGmqEJPOC2+3G8OHDMWfOHIwaNQqNjY3w+/2YMmUKJkyYgEGDBiE3N5c6h6moqEAkEsH+/fvx/fffo7KyUnj+1CiOhPLtrTCbzZg7dy4mT56MTz/9FO+++y5yc3Mxe/ZsnHbaafD7/fj73/+OXbt2xdWRzWZDeno67HY7FEWh2+STW6200SWiISIPQOdlelYBIc95pZl9z8YnUmR55djIRMmmR1YjyLmJlJQUuN1u6m6zqamJkgRWwSWKErF+ZmVlwePxIBKJoLq6GqWlpQiHw3GubAlZYT3MsBBZ7kVlISrzrgziemXFEwFeJi0ywiIR4mhENlF8IlllJIPNi9lspu5KY7EYzGYzUlNTEYvFKMEk8ZLbnV0uF6xWK30eDocRDAbpCpjMVa5MflKORoidVpyitsN+Y4SQdLdNsWnKSAafrpa8vMWefd9dGXlYrVaMGTMGd955J6ZPnw6PxwMA8Pl8+O677/DKK69g8eLFwpVIs9mMrKwsnHrqqTjrrLMwaNAgbN26FaWlpaisrMSmTZvQ3NyMyspK1NfX01uBtQ4aGik32bcyUno4Jj4twmfUsHSwYbVaMWfOHDgcDjrPDBgwADfffDNWrFiB3bt3d/rG4XBQF+/krqT29nbdOjEyV/VWdHd1xohB4HBCURQMGzYMd999N4YPH4533nkHDQ0NUBQFTqcTU6ZMwS233AKz2YxXXnkFtbW1iEajMJlMcLvdGDlyJC699FLMnDkTdXV19ObwcePGwW63o6GhAVu3bsXatWuxbt067NmzB/X19WhtbaWGyET7anLFrGegKAqmTp2KlJQUfPjhh1i2bBnC4TB27tyJAQMG4OKLL8a3335LjcikTZx++umYOHEi3G43FKVjt8qOHTvw3Xffoby8XNOrqFG5jsa67dYZDVGhaCkGiXYmnqwQhd/ohEueke/IUmd6ejpVIO12O70HgEwiPDkg26xcLhdycnKQlZUFVVXR0tJCBw7+5l/WikuskCzRMlIuWuFkkzafjig+PaupHki+ZGSBvWOAv/9EZnU3Yt0WxWNEMSfviCzE4wm5PJKsbrFKpclkQkpKCgoLC+FwOOht8X6/H83NzXSykCnXetZ4Ni1STkbJnIxk8OXDPjNCQGTgyzqRPk3eyzxjycLL4u6pgTglJQVXXXUVzjnnHJjNZvrc4/Hg1FNPRWZmJmpra7F27Vp6cFVROtxYZmVlYdasWbj00ksxZMgQVFZWYvHixfj+++9RXV0NAEhPT6cHxR0OB9rb2+Hz+aR5k7XhRBQLPaVWq93IwnUXRgwChwMulyvuf0VRMHLkSMyaNQt79uyJKwOXy4Vzzz0Xo0aNgtVqRSgUQmNjI3744QesX79eerBZNoYdbugZeQ5m/Rhtz4einSiKgptuugnjx4/H/Pnz8dBDD6GhoQGxWAx2ux3nnXceHnjgAdx8883wer14++230dLSAofDgbFjx2LOnDk4/fTT4ff7sXbtWhQVFSE7OxsbNmygF3aSbdZTp07F6NGj4fV6sXnzZvz444+or683dM6KR29pR0c6SBuz2+0AfnLDvmzZMvTp0wfnnHMOvv/+e7S1tcFms2HWrFm47777MHr06Lg75fbs2YMFCxZgwYIF2L17d7fIxtFat92+GVw2aBkpMC2rvp5lX7R9h1XuRIopcUnrcrlgMpnojeTkG6vVitTUVGrZDoVClMmmpqYiNTUVaWlpcDgcaGtro+46SThCRqxWK1VqQ6EQfD4fXVrjyZMsfzLIJm6jqw6JKGp6ijsbnxHyIlopIf/LyJFIbtGKiBaBIe2F1IXL5aKXL4XDYdou2G0xTqcTRUVFGDZsGICOlQxCRBsbG7F3715KSAkJIfe9iORk5WVv8ObLgy9PvfriiZaIaPKEjL3Hg60HrTSMhNXqs6I60/qWHQOMKB2JKOSK0nFIc/bs2XEkg7yzWCwYM2YMbrjhBjz00EM4cOAAVLVjlbVv37446aSTMGfOHIwZMwYAUFlZibVr12Lv3r0AgIKCAsyYMYO6vSbbK7/++mt6TwCbT5bIiaCVJy1l1mi70Qt7MHA4LXexWAxbt27F4MGD49qYxWLBaaedhhdffJHWh8lkwllnnYWHHnoIxxxzDA0bCoWwbNkyPPbYY1i5cmVcnbI4nPk0oqjLjBCiMamnZUtk3BG11e4SEZPJhEsvvRQWiwXPPPMM6urqqJIYCATw4YcforCwEPfccw9uvPFGbN68GZs3b0ZhYSEuu+wynHLKKaivr8fGjRtRW1uLgQMHorGxEZ9++inq6+tx8sknY+bMmSgsLKSKaSwWw8qVK/Hf//4XCxcuTMgKfrRauw8HYrEYSkpKMGzYMBx77LFYvnw5vUz6o48+wqxZs3DSSSchNzcXJSUlGD58OG666SaYzWa8//771Kuo2WzG+PHjcdVVVyESieD1119HRUVF0kUuhy7do8H/zw8IvJLDD2a8osWG48OwMGrBFsVLKp5smyFKYiwWg9VqpSslLpcL0WiUEgNilSwuLobL5YrbMkO2SJlMJrr/Py0tDXa7HdFoFGazmVrAm5ubOy2X8uWpp3yJyl8GmaW7J6BlaZa1D1G9JSKTqGyMDLxsmsFgEG1tbUhLS4PFYoHZbKb1Tv4mhNTj8aBv374oLCxEIBCg+/VtNhvS0tIQCAToNjmRIm2EILD5EOVTL05RP9BTHo0q7yLSzscvipf9m5evO5Ok0W+NtilSj7I47HY7zjrrLKxcuRIvvfQSotEoPB4PfvGLX+Dcc8+lykMoFEJ5eTkaGxsRjUZRUFCAyy+/HJdeeiklGgDQ1NSE999/H2+++SbWr18ft02PH+sS7R+JrjIlGq47EOUhkbo8GDJGo1F8/PHHOOuss+BwOOLSys/Pj2v3LpcLd955J4YOHRqXF6vVirPPPhuxWAw33HADampqOvWtnmj3XUUiY+vBXjnoyfwbId2JtC+yLbapqamTI5hQKIR///vfmDFjBqZNm4YLL7wQADBlyhSceOKJqKurw9dff42ysjIMGjQIxcXFaGxshNPpxJlnnolZs2ahpqYGGzZsQHt7O4COFdNJkybhd7/7HZxOJ9555x1UVFQYkjlJMnoW//vf/3DCCSdg9uzZ+M9//oOGhgaoqoqysjL4fD7YbDa6hfr888/HyJEj8cILL+CVV15BXV0dNUScf/75uPvuuzFnzhyUlJTg448/jrsrKYkuEA3eCk3+lllvRYMY7ypStAoh+06kIImIjczSxx5EjUajdGlTUZQ4ckGUSIfDgezsbBQXF8Nut6O+vj5O1mg0SrdT5OTk0H2/ZC+nw+GAw+GAxWKJO1AmU/S0Bn0tRVMWl8zKbQSyb7SIJA+ZtUxWBiIlVUt5linionjD4TDa29vh9/thtVqhKB2rUOFwmLYZMvmkpKQgPT0dbrcbDocDfr8fPp+PktI+ffqgrq6Obp8i9c2utCWi1IueaVkbZfHz35C/RX1HRggSRVe+O9yTphGC6vF4cMUVV2DBggUIBoM46aSTcOWVV6Jfv37USEHGk3A4DLfbjbPOOgs33ngj0tPTaTwAkJeXh9/85jfIzc3FXXfdhQMHDhiSJRHF6nCXKY/uKrAHKz/RaBTffPMNNm7ciEmTJsWtjLPb2xRFoV7FRFAUBWeeeSamTJmChQsXSleqDjV6mjh0x+DVEzBi3OiqPGzfYeMjqwwtLS148cUXMX78eJxzzjmwWCyYMmUKDhw4gE8//RQ7duyAqqoYPnw4srKyoCgKpkyZgqlTp6K+vh7PP/88PvvsM7pNKjs7G3PnzsV1112H6667DuXl5fj4448pEUni0EBVVXzzzTfYvn07pkyZgkmTJlGnHcQIRIyINpsNkyZNQmZmJnbt2oX6+nra16PRKN5//32MHj0aN910E84880xs2rSJtoskOiC/9lkAPSJAoKVAkw5t1BKt91wUH/+MDPqstyCLxQKbzQan00m3UzmdTlgsFtjtdjgcDlitVmRkZKBfv37o27cvcnNzkZubi+zsbLjdbroc6nQ6kZaWRpVXEj/52+l0IisrCykpKXFejPhy1SqLrkxasglCpqSK6oWXk7B4mZyi72Xx83En2qb0LL+8AkbuzWhqaqIKhcXSwbXJShVLNJxOJ20L7MFRssqVnZ1N65z8kFURUk78RKYls2g1SJQfvfJJdNJlZZMZEkQyiL7jv01Ujp6AXtqq2rH1pbm5WTOcyWTC4MGDkZ2djcLCQtx0000YPHgwbDYbrFYrvbCTWEXz8/Nx7rnnIi0tTVgGZrMZ559/Pi688MJOfUhU9omUR3JSMw5VVVFTU4N58+Zhz5499KxWQ0MDlixZEndGj/RxGcjBclGYw1UnsnS72i97Gt0lBbJ3euMrj1gsRucBskJJ4iJGhEgkgq+++gpNTU3IyMjA7Nmz0adPH7z22mt49913sX79emzbtg0tLS0wm81wOp2YPHky0tPTsXDhQnz55Zeorq6mq+IVFRV48skn8dZbbyEtLQ2/+MUvMGjQoC6VRxJdh6qqaG1txX//+1/U1NRg7ty5uOSSSzBr1iycffbZSE9Pxw8//ID6+nq4XC7Y7Xaoqkq3V7GIxWL49ttvsWPHDsycORMTJ048TLnqvUiIaLAKlegdgZaFNi5x5oZb0bcyKy4fl0wp4uOORqPUM5SqduzJJYSA/BCvQmQ7TUZGBvr374/8/HwUFBRgwIAByM7OhtlspoyXxMH72o5EItT7lN1uR2pqapxiqlW+vEKnBV6ZF72XQXbPAfktIx6ytqA3wIvqKZHv+XC8sisqBzbOYDCI+vp6NDQ0wOv1UrejLS0tcQfzrFYrbR/ElR1RMC0WC2KxGFJTU+MIJYGMjLHyiVzpyiZJPQImK1NZP9SLKxFLuVHDgVF0Ny699knQ2tqKpUuXSvfWExDPY3379sWECRPoFjuypG61WqnbWo/Hg8LCQs36slgsuOqqq6TKa6LkoifLvjfhYCvEwWAQCxcuxLx58/Dtt99i1apVePvtt/Hyyy/HlafT6dSVZfr06XC5XEKjTG+qo0TkOJgy6xmVZN/0dPhYLIZFixYhGo3iiiuuQE5ODjU8sfGEw2HqhjwzMxMmkwmbN29GXV0dmpqaUFdXR8/6qaoKj8cDk8mEuro6BAKBTmN9OBzG/PnzsWXLFupkoDcQwJ8TiLHpo48+wrvvvouCggI8/PDDeOqpp/CXv/wFTU1NeOqpp7B792465pPvRG1rzZo12LNnD/Ly8pCdnS01xv5c0eV7NMgKAasYaym77HuZkk3CGBmIZEoZnzb5n2zTIh4EyLYpctbCZrNRSwY55E0GGJ/Ph0gkguzsbLhcLgSDQWqhYO9TIOSE3M3B5k1RFHpvB7kERlZefFnKrJsiQiBbJWDLQatsWSWZPzQsAmkH5G9R3ZFn5If3RMXnR1YuRq28WqSXuKasqqpCc3MzLBYLQqEQvaWVWLJY/9jkPIfFYoHT6UQ4HKaukclWKtmqDU94tPJoZJWDjZf1/qVlySPtku+DvJxdWRVh09UiSj2lKBgZF4zI3tLSgueffx4jRozA+PHjOykYBMS67fP5sHv3bkyYMIFe5KiqHY4Adu3aRd2dsk4fZBg0aBDsdrvwMig2H0cy9MixXv4Odv5VtcNr4KuvvoqVK1fCbrdj+/btaGxsjEu7qakJgUCgk5cqFikpKcjIyEBTU9MRX2+JwGheRfV9qFbr9HSSBx54AEOHDsV1112HAwcO4J133qH778n35N4tk8lECceQIUNQUVGB9vZ2WK1WFBcXw2KxoKmpid4A7na7heOKqqp0m47VaqXGx59T2+kNiEaj8Hq9ePrppxGLxXDSSSchIyMDBw4cwHPPPUc9DgYCAeoMhux6CYfDAH5qX+w5TpfLRT0NJtGBhG8GZ394BYv9TSBTgPlnbBpaN4uTZ0YUCv7kfywWQzAYREtLC1RVRWpqKlXW/H4/jc/v96O9vR3t7e3Yv38/otEo6uvr0a9fP5jNZlRVVVH/+ORCvkAgQPfoE7JClEFi9SaudPUUfTaPMmi9N6qkieqB/Vt0e7WRejAqu176ov+1IJJH9CwajdJ7M4gCzm6XIO4rGxsbkZGRQZfUSR2TVa9oNIqUlBT4/f5OlnG+7WkRYq3VGB6yds+XeaL90khb0pOLl+NgWOmMtG1ZG2ARiUSwbds2/PWvf8WDDz6IsWPHUqWAbQebN29Gc3Mzamtr8fLLL8PhcOCYY46BzWaD3+/H5s2bsX79egSDQTQ1NaGiogLDhw/XzAPZstnS0tKlMjja0ZNKl9442dbWhvXr10NRlLiLWgnKy8uxfv16nHDCCTQ+9nvyOz8/H/v37z+ivM3oGTnYd12pD5mR5XBAln51dTUeeughPPPMM3jggQcQjUaxcOFC1NXVwWw2o1+/fjj22GORlpaGffv2oaysDLm5ubjmmmuQlZWFuro6pKSkYOLEiaiqqsK6deuQmZkJj8eDfv36SQlqKBSK28at5bY/iYOHSCSClpYWPPnkk1i4cCGKi4uxY8cOHDhwgO588fl8KC8vRzAYxLhx4+glrES/s1qt8Hg8aGxsRF1dHQoLC5Gfn4+9e/cmyeP/j4SJhugOBVlYLSuGlkKides0iUdLcWOt5vw3pOGQdIhFgRCGaDSKlpYWeL1eeqN3KBRCU1MT9uzZA6vVipaWFtTV1dH7M4g1k+zjI3t+SVkRRdXIKoVe2bD5EVmotQiYnjJpRIGVPdMLz8rMh9MiMrx8MsVYq82IlANCCMkAz35LBp+ysjK4XC54PB6kpKQgEonA7/cjFAqhra0NqqoiKysLLS0t9H/Zag1JW4sQJLJaY8Q9LXmu1WdFZcvKIyKBiRKOQwFeVvI/SzR5eQKBAJYuXQoAuOeeezBixAg4HA6EQiHU1NRg//79eO6551BbWwsA+PDDD+H3+3HRRRchJycHFRUV+OCDD7B//36EQiE0NDRgxYoVmD59uuZKoNFVl6MNWmP2wYLeWEuMDKI5A+jYYvePf/wDhYWFGDBgAID4fkDG/9TUVOr++khULrprHNCrW1H/7A2IRqP4+uuv8fTTT+O+++7D3//+d/Tr1w+bNm2Cw+HAOeecg1NOOQWlpaV4/vnnceDAAQwcOBBnnXUW/vjHP9KL20pLS/HWW2/hm2++gaIomDNnDiZNmoScnBzqCp0FPwf8HMeD3gDSh9va2rBx40Zs2bKFbnkndRSJRPDBBx9g8ODBuOiii1BfX48PP/yQktHMzEwUFRWhvLwcGzZsQEZGBjU8dPcCv6MFXVrR4L1GEWZHBhOjl9BoWZ9lkwOvrJO/+XhF4clvcig4Go0iHA5Tq0MwGITf70cgEKBbIAgxCQaDqK2tpR6lWIsEuZ8hJSWFLqnx6RPllOzZFMmqVUa8ZZ4te55siOIQvddbVuZXN9gy1KojLfCrGewzEcHi61m24sGTFb1VI1VV6WDCp0FWvsrLy2EymVBcXAxVVemKRktLC9324vP5EAgEhAqGVhvl8y57x8cnyotWWRiBXl/TeyaCUWtpTyJRskH69pIlS9Dc3Ixf/epXyM/PR1NTE5YvX47Vq1ejpKSEjgXhcBiLFi3C+vXrkZ+fj+bmZlRXV9PVLZ/Ph08//RSXXHIJRowYIc17Q0MD2tvbdfvrkYrutBvg4ORfNvbppRmNRvHZZ58hNzcXN9xwA4qLi+F2u6GqHashTU1N2LZtG701urdANrd2FaLyI67iU1NT0adPH5jNZlRXV9P7KPTIRlfTTuQ7I/FEo1HMnz8fmZmZuPLKK3HzzTfTle5AIICSkhI8/fTTWLp0KcLhMPUq9Mtf/hJDhgxBIBDA//73PyxatAg1NTX417/+hcGDB2Py5Mk4/vjjsXPnTtTX18fln2zDjkQiwgPGSRw6kDmfXFdAdALSVqLRKJYtW4bCwkLccMMNuPPOOzFkyBCsXr0aqqqiT58+GDZsGOx2O4LBILZv305d5SbRAUU1UBperxdpaWl0fxrZ/kMmX/ZOCqCzEixTuGSDPasciAYnPYuqkdUWljSxe67JD3ubtyhdVjZFUahnqZycHNjt9rhDozabDe3t7SgrK0NlZSXdZsOmZ0TZ07POycLorf7IwspWYAixFJWJKE6ZHDLZRX+LZGLTEj3n4xFBdmibrHTZ7Xbk5OQgMzMTitJxILy5uRl+vx8WiwUNDQ1oamqi2y5kddMVi54sT0bj1VqOl9WtnvWXXEZpNpuRmppKb1Rvbm6m51y00hPJ2dMQtWE+TZHS5PF44HQ6qdMIMvGQMiT9mXgjC4VCdIWLxGez2XDZZZfhD3/4A/r06RNnrVTVDq8lb7zxBm655ZZORomjBazhQwR2HDnUMomescYb2bjl8Xioz/3BgwcjHA7jwIED2Lt3L5YvX44dO3ZQV9e9RcEwMt4m8g0b3m6301WeUaNG4cILL4TD4cCSJUvw+eefY926dXTrCR//4ax3rfHJZrNh+vTp+P3vf4+UlBTEYjGUl5dj3rx52LFjB9rb26GqHc5fUlJSkJeXh4yMDPh8Phw4cACNjY10O+6cOXNw1113ISMjA3/729+wbNky1NXVQVEU5Obm4vTTT8f111+P9vZ23HXXXVi2bFmvaTc/V8jmCjI/uFwuXHPNNZg7dy6GDh1KbxSPxWLw+/2oqanBd999hzfffBOrVq2i48HPAS0tLUhNTZW+T4hoZGVlUXewZrMZkUgEbW1t9KwCe0cF+Vu0pUWkOPEDkN6eRXay4idzUXyisHz6fDwyEsBPlISoELKRkZFBvZWo6k9Lc+Xl5fD7/XEHyLXiJ3/zqwl8/oyQESNKqtY7LUKiJZuWDDIywYeX5VMrjB4pY9uAqN7JO0IYiccpRVHiVqWi0SgikQgURel0M7hIVv4daeeyOtOrx67k2wipkCE3Nxf5+fkoKirC2LFj0a9fP9TW1mL16tVYs2YNamtrhf02UZLVXWgpuyJFlzU8EPDGBvKe9TLHWsBIGJfLhblz5+L6669HUVER3G43IpEI6uvrsW3bNlx//fWoqak5Kvdky0geICd6hxKiMZ+AHfNF31ksFqSlpdFL/oLBIP1hCWlvUi6Mkg2tcKzRj6CgoAC/+c1vcNNNNyEjI4P2A6vVin379uHWW2/F0qVL6QFZPRl7Q5mR8d5ut8NmswHo2InA34/Cep0DQHdGkDagKB0u0n//+9/j17/+NQoKCrB06VKsWLECsVgMp512GiZPnoza2lrcd999+PTTTzUdQyRxaKClixAdz+Fw4LzzzsOFF16Ifv36wWQywe/3o6KiAjt37sSXX36JjRs30m31vaFdHwr0KNEYOnQoXC4XrFYrnE4nYrEYvF4vamtr0dbWRi10MsuQHuEQVbSWMipTQGU+6vmJhRaCjgVOpBCILMHE3aXb7YbH44HFYqFnP8iZD3b1R0am+PyTZVw2rJ61m704jrxnLXds2omSEP5COtE3Iku7ltLHy6E1AbJlbzQ9UTviyYZIJpYIkLAy0iki1nz+tMihrFxYGCVfWunK+pcesVFVFVdccQWuuuoqTJgwgV50qaoqqqqq8Pjjj+Ptt99GfX29VG6tvPU09OrXqBw80SB34RA/++x4R8La7XaMGjUKv/jFLzBkyBB4vV589dVXWLJkSZxXm6MNfJnzba035FtEhnhlWkY2iMLBfsMbjnoj9AiH3rd83o477ji89NJLMJvNaGxspKu6hYWF6NevH9ra2nD11Vfj+++/77VlIoJMP+ANlOz/7CW8JK/EOHX77bfjnHPOwdChQ+HxeKAoClpbW1FWVoaHH34Yn3322c/K8t2boUU0yHtyrpdc5Gy32+H1etHe3k7JZiQSQTQaPSoNSTL0KNGYMmUK3TpB3HoGg0F4vV4cOHCATroyy47e/4C2xbY7llhR/CKrvSh9lqjIZCL/s1uxiNLJlgnvCpZNQytv3cmzzOrNh9FS9EWkhd1XqmcZM6JMi6zyiXyjlT4fLwlLyIGs3lk5+O+0BiYZ0RHVBZ8X4Cc3xHrkW4+csaRSRuhZEq5Xvh9++CFOP/104T0Q69atw1133YXly5dret061JMqrxjoySAqA/JD+jUpK9GWOVbZIJZPEvZot3LJjDlA71LERWQDMEZCRd8mSl4PNXqaaAwdOhSXX345PvnkE2zatImuaGRnZ+Omm27Cfffdhx9++AGnnnqq5vmDrs5r3ZkP9eIFtMcA2VzBf0f6/6BBg3DLLbdg7NixAID169fj1VdfxZYtW6h3yiR6B4yQDfZv2ZzSm8a6QwE9opHQYXDiT9rn88FsNlMLvcPhgN1u77R83BViYOQbLYLCd3gjk4KIMOilK7ICk2eEWMiUedHAxCu0/G8RSRMpjiLlnP/GyKSjZZnn86L3XEZwtCZpmWLOlodMWZDd78KG5cudEA4jZJg/zK9Hhth0RGXBKqZ6dUji4okqXz56/cdIGxARJbJSJ8Lw4cNRWFjY61w1yvqt6Dcpf1kdispZNjmxrq6PZBglaEb6QW9BT8jWHeX9UMNon+ch+6asrAyvvPIKysvL4/p6Q0MDFi1ahAcffBC5ubmwWCxSotETxrODgUTi1lIoSf/fuXMnfve739HxnV0BSaJ3Qa+faOlESciRENGIxWIIBAKwWq0wm83U2w6/N92IsgbIt8WIoEUu9L6TNRyZAsx+KxsQZIour+TK8iBTgBPxJsXGqZdPLSWelV/rHf83m34ilgAReeC/FVns2Xe8TKyCzm/tMiqjbLXJyITIr0CwedX73kjbkcUhI2m8EqxFHEXlxZMxrfogMJvNdFuRFg6WNVILfN7ID1md4Ikqv0rBf8N62TvY+dFrt4cSRvKqNZ52Nd6DWQZ6xgj+uWzc6g31owV+HCToSvsNhUKor6/X3PrLbjPrjdCa52ThAePKJtsuepPhJQl9HI456mhGQqMAuaiMnWCtVitU9SdXoSILvGiAEynhWlZqEbSIgEiBYMPKFFg+XpHCx8sgkov/LVJcjMbHh1PVzrdCswqlEaVQBn4wNULARHWmVdddURpkbUr2nK1/0cTK5yNRoszHqXdvgiwffFxa7UmLrPHxyS7T1FKU2O9F5aaHUCiEUCgk3TZ1uC3AojajlXc9Us2HF8V3NEBvDDTyTXfCH652IzJo8JDNP70ZRg0IWuUuW6kzmUxwuVzUaGbEocvhhNGxTks3EOkKvSFvSXQg0fEjWXc9j4TNDVarFaFQiLr7IqfuyV5D1hWkHtnQAj8YJtJYujIxkYFCy8WhEeIjipOVSSsOo/nklVojE6BoBYAvW5ECJYpXlLZsnzr/rYj4iSY+GdnTy5eW1UnrO9GWP152o0qFlgIvghaRkREqPfLExytTsrVkSpQI7tu3D3V1dZpepw436eDJfywWowf3yN+y77QMEAcLh5ucEegRskTHRj6uww09+UQkX4uwHukw0k9FBoW0tDRMmzYN4XAY5eXlnfpTV40Yhwp6Y7GIYCTRO5AoWdaC1lybROJIaOsU2RZBLqhTFAXhcBiNjY30Pg0CVolhO6rMKitTavUshawlWqZMA2LPUaL02HT5AUbPEsymzZ7R4OVgZebT11L+2LhkaWt1EDZ//OFuvgxllndZObDkh5dPVI+kfLUGdl5uWV3rhdMqLxH02q1MVtHfom+JPCJiypNAPm98OjISxZ8R4tNib0SX9Ul+QtVql36/H++++y62bNnSKa/sT29QzNhy5stcFJb/nx3nWJfePQ22Her1+8MNI/1S71ut94ci71p5kIXl/z5SoDV3sX9rjSE8rFYrxo0bh/vvvx979+7FPffcoztuHE4kakjRQ2/unz8XiAx03UWyTruPhM9okDsDVFVFe3s76urq0Nra2qkytA5D60FEGFhlVkYIRGl1hcwYGVxFCpoWmTCSdyPvWeVDVMZsWJnsokPPWnnmO62WossrcOwzPQLFxy0jNlrfi/IjS0crLVlceu1F61s2HdH/enfOiNqTTAmTKankN0+ERfnUyxtBNBrFd999h2XLlqGhoaFT+uyPSP7DAb32yoZhZSTn0fj3PZkPWXs/nBNeIn3P6DsSr5F8Hcq8i0j90ahsaBmljMxFZrOZkm6z2YwhQ4bg3nvvhd/vxxdffIFt27ZpGviONsW8NxhRfs7ozaT2546EiIbFYkEsFoPdbkcsFkNLSwvq6uo6uWzUGkC03F6KwCsB/N8iQiGLh4dI2WSfi6ziWoqglsJnZBAiZEorT1qKt6wMeCVaRAp5WbXKlFfSREo6u8KhRVT4v0UHsmWQlb0sr1pxiuqtKyRTFlZEcIwqqDxpkLUlUT3xZa5FTmV5kZEdEl9ZWRleeukl/Pjjj3HWfkVRhAdCe9OELGvL/Hvyt6xtaZVRV8DX+ZGA3kSMegpHQx6MQDaOy/KvKB3nM4nhMT8/HxdccAGmTp2Kb7/9Fn/+85+FZziOFuJmdB5JIokkEiQaqqrC4XAgHA6jrq4O1dXV9PCnnrJvRDmTTaqiuFmlXEteNg6ZTLwSKFKEjVysJ0pLFkYkh14+RKRF6zuTydRpj6ys3GWQlT35m9SBSJnUsxAnQsLIe61ylinweisQImWcXT3TIkZa7dUIAZbFqfWdEYVOdg+HiAAalVlV488wRaNR1NXV4cknn8Q333zT6XZbnmgYJVaHAyKSwb4j4AmtCEYUNa1vehJdkUUrDh56fUoP3W0PsnE9icShRTL4MrXb7SgoKIDP50NGRgauuOIK3H777Vi9ejVuuOEGtLS0JGxUPFKRbG+9B3o6URKHBwkRjWg0ira2NjQ1NaGmpgY+n094EV00Go2zzJP3Ik9Qekqv1mAnUgBkioJMQRRZaPkL3IxayLXSkcEIEeHfGwnHrg5ohRFBZNliIVNW+Thkz2TWX5lFTa/uiELLWpxlafAEVSQ/f96EhSheLWVOa6VDViZa4WQy8/nktxmK4pQ9k1nTFUWhtwCbTCbs2rUL//znP7FkyRI0NjbGlT//I0u3N0HU5rXGHCPx6cHISlh3CFpPTbyidn046tNIXo6U9tabwY+PfFkOGTIE//znP1FUVISsrCxYLBasXLkS1157LUpLSxGJRAAc+eRCT/5kG0siCX0kRDT279+PcDiM9vb2uO1SvDIkcvXJu9s0YlWXTZJEiRaRC1bR6Yq1TbaCofUNr3yycegpEjKCpGWRlz0XKdVsWuw3WnkQySkjRHqERZQXXoliw/IKtRHFXUsR49NmCZgRpV4LsrYpswxqWV9FxDARZc6o7FrtSiQz/+7111/HRx99hPr6emzfvh11dXXUEYSROhD93xM4GIpvd+IzMsbwfx+scupuPEaJaU+lpydLIv0zqQgmBqPl5fF4MGzYMNhsNgQCAaxcuRLXX3893UptJI0jqW6MGnySOPxI1kvvg6IaqBWv14u0tDTY7XaqEPG3IwPiTqhl2eYtnuy3rLLOK6R6iqVoImeVSz2LFyFFqhp/0Y6IvBhVulVVhdlslsYnQyKrIqxMxKsQr/iy5ceWBX82glXKjaw0aMnKE0wtj0h8WkZXCLTahRHSKbLe8zCiPBqpT1G6pFy0VotE5SuSm32WCNmW1S/bntLS0hAIBKg7a97izhob+BVMMm7IXEh3FT05+Xc3Lr12ICP8RgwZvQ16RoueTkePTHfFsJSENmTtuU+fPrjooovg8/mwcuVK7N69m17gK/peFJdevZhMJlgslri5mP19KCCbF5JtKokkfkJLSwtSU1Ol7xMiGjabDQDilAst5QQQb40inZdVRvgL1ohPe95Syiv/WtBS0rWUYtE7PYWXt/xrpS0iQ6LyFK0kJGLNk5EEGbQUVlke+TS1SIIoT3y8RhR+VjatepK1RaNy6SmdIgKnRQa06kD2rUwOUXqiOuNJB0/6tMqavxNHURRYLBaEw2HNuzLIN7wRgVUStPolf67DyDc8uqoI9ATRSIRkGDUi9EboteeejjORuA+GbEn8BIvFArvdjkAgoKn4823eCMmw2WxIS0tDbm4upk6dCo/Hg4qKCpSWlqKyshLV1dXU0HGokSQaSSTRGXpEI+HD4Oxv8rdIOdabMEwmE8xmMywWC6xWK9xuN+x2O0wmEyKRCL2rIxgM0lvHRco4Lw8rByuPHlhLrExRk6XZFeu3KF5WoRNtuzJKMkj6MiVYVkfkGTuYsuH4czeyPMsUdqI0apUXfxBbi5TJ4hCVgR5EZETLgiqrQz6Mlnxa72XvZKRUK30ZKeHBhxG5kyZ90Ui6ovhldWc2m2G325GZmYn+/fujqKgIJpMJzc3NOHDgAEpLS+H3+3W3ZbAydEUZ6I4CYZRkaLXdRPr44YKWMQRIvAwTHdeMhjsSyvJwoav9gyAWiwlXMPg0CIzUh9lsRlpaGmbMmIFXX30VLperU5h9+/bh7LPPxt69ew2NRV2FnqEwiSSSMI6EVjTIhX0EMmWWvCPPaWJMWIvFApvNhvT0dHg8HmRnZ8PhcMBms0FVVQQCATQ3N6OqqgperxfBYFB4+7TWYKB1IDauEASWV1F8ome8xUa2/1+UJp8Xsj1FS26jKyVGLOO8dVsUn+hb0f9GBl+tlYXuKgVGlHg9giSCrDx5pV1W9lorHXrxi2SUtVORtZwPo5UHkbyy72TeZGS/2e9EKyE2mw1Dhw7FnDlzcMEFF2DQoEGwWq0AOhxQlJeX4+2338YLL7yAyspKw+3mUCoEiZJOHkbqprdAVr+A9pisFZfeMyOWcKPx99ZyPdToThsjK48ioiFr62x6IiNbcXExFixYgClTpiAYDCIajVIyQVY5rVYr2tvbccopp2DHjh2aZ8MOBhIxXCbbWfeQXD06ctCjKxqAeM8isVSLVgNECqrJZILNZkNhYSEGDBgAAHC5XPB4PLDb7bBYLAgEAsjJyUFqaiodUMigItpKIVKw9CZ+kWVYppjpDRysFVgkF6tsahEynmTw4fjfMss6n65IGSYrJ6K8iKyWRsiAiLyQiYLNu5bynShEcWpZ8LVIMB+vLF+istQjqDLrr1baRspea3VFL00RqU0kLbaPd0XpVxQFkydPxv3334/TTjutkyMJk8mEAQMG4MYbb4TD4cBDDz0Ev9+fUBoHG0aMConiSJxce3olQ9bnulM2R2K5Hiz05BjcXbjdbjz66KOYPHkyysrKcOmll2LTpk0IBAJUTofDgVtuuQWPPPIIvv32WwwcOBBer/eQntlIkoyDD5lRM1mmRy46u4fSAavAixQ5surBNg7e8m8ymeBwOJCbmwuz2QybzQabzYZYLAaXy4W0tDSkpKQgPT0dqampcDqdcDqdcLvdsFqtNA3RPnCaMc5FrSgfrNxsvtiBS8vizCuqbB7Z7/iBkHefyivBPNkxqpxqPePzJqo7UQc3qjzyeeZllxE4vp60LOl6Mohk4RVjlniJ4pGRCz1Z+Pj4M0cy2bqSv0TD8WXBe4ATtTe+n8vaFrE0ijzNieLmYbfbMW3aNJxyyinCOAjS0tIwYsQIFBQUdBpjejv4MuXL90iAqC2L8tJThgM2fpEsSciRSN84GG1QVm9aablcLsyZMwdtbW0YMWIEVq1aBb/fH3cA3Ofz4ZlnnkE0GoXH40FWVhb9vje1iSOpX/c29KZ6TKLn0KUzGiKQBsJbyMl2IHZvPmvhJqTDZrMhGAwiEAhQRYIsy9rtdpjNZkQiEVit1rgtGHy6ehZckVKrNUmKzhTwypMe4yYKGXvniJ4FXQZR3tjfso4q2pIlu7FZZD3UU8y1rDi8VZ73iCWDnmVdT4mVhTdiyZNNlDLSwivl7IV5Rs7b8G2Ij1OvfnkZ9fIiCqsVTiYzIS2kbcuImgxWqxUOhwMWi/ZQRCyaHo9HM9zhQleVC5nRoDdBRjIT6X8iiNpKd+LTS4OkczQrgr2pLenNHSzInB+JROJuFBeNOdFolIbvTasySXQfMsNCsn6PbCS8dYooiSxZAOSDiowQBINBGl8kEoHP50MoFIKiKAiFQggEAvD5fAgEAohEInH7NUl87CDDyqKnILPua9nnBF1p2Hq3oLLbvYiC35V0ZBMJHxdvsebTJL9F5aRHHhJ9zsvFKqUsAeyKldfIiosRJZ+krVW+bFgtsG2BdwMtU771/teSSSaXqE3I/tdbZTGiVHZlMvD7/WhsbITP54Pb7ZYS8Gg0Cq/Xi+bm5oTTOJjoiUnwUE+iicrM94ueIBmiNLoLI8Q2qbD0HHqyLEOhEEKhEKxWKzIyMtDQ0CAM53a7qZv4xsbGHks/iSSSOHhIiGgYsUzIlDVWoSHLoAcOHAAAOBwOqoj7/X5YLBa6XFpeXo7GxsY4CzhxfSuaAFkZ+AmRPSeg9S35XzZxiazNovT0ytCIpVlUniK59FYcWLD3ebAkhM+frIzYMGx6fDnoKb9aZSGKX2+FQ/aMryteTlE6Wgo3v0IjCwd0PrMjy6dIVvI/qSN225tMLj5evmxk6Yjesc9k5WukrLT6RSQSwSeffIKhQ4di7ty5sFqtneKLRCJYu3YtXnrpJVRXVxt2b30o0BsV10TGoe6sRPSWvGsZEnqLjAcbh3olI5H0ZAYfFm1tbbjvvvvw2GOP4cCBA1i6dCk+//xzlJaWIhwOIxAIYOjQoXjiiSdgMpnwzjvvoK2tTSjTz6XOk0jicIPdqaOFhLxOaW1vIASCVT60bsYm+7pdLhcyMjLoZYAWi4Uqwq2traivr6crHUTRIluqZKJrkQT+md5KhpbyJdomJksrESuiTJnkFXitFQStQd1o4+DTSnQClymhMgJA/hbd+i5SWvWUWBmRIIo7G7fsED5fHqJ8yL7j37OyiogqG46VizzTWzXTW+Fg3/Fb13hiwz9jZWPv1yAXahHir9V/RO9JmLy8PJxwwgk4/fTTMWrUKKSnp8NkMqGqqgpffPEFFi9ejB07diAUCmnK11twtCk9RoxMhwNGFN7eIuvBhJHxqidBxsueIv2KosDtduPOO+/EfffdJz2vFYvF8MILL+CBBx6Az+eT6gI/hzo/2nEwx5xE9LEk5CC6ZI9e2McTDV4BZa245H89a4aiKDCbzfRODYJoNCq9fZhX+vnzB0aUWzYPfFxGFDajz0WkQKZY8tCz/JvNZjrQJkoEeJm0Jireqm3EWkri5g++8+FE8Ynq2igJZN+J6iEajUoJipa1n4eW1V9EZmREQhaWV+hFZaS12sDmWWvVgZQHG6+ofbLps9shzWZzp295Gfi8ymQlYwDvRptsm+TPZonIUW+YPI42i/qhVmKNQKtv8u31cMt6KHColTKz2QxVNX55rtF0bDYb+vfvj1tvvRWzZ8+mFwUrioKGhgZceOGF2LBhQ5xuwKMrxr0kDj30+jA7T+vNH91JM9lGuo5DSjREEClCWiSADUuUfdEBU1H87N8s6TACkeInIxoyYqU3yGtZ8EXpiCzxemSEhBFNskasfnx8Mks7L5tWfZIf9nwICc9u3+LBuzGWESIZQZERCf5/GUEV1ZOI0PLtQY+IyeKTtQXynEzqsjYhqyu9fsC3bRGhF5FD1nd+on1Na7jRa6f8mCIiSOTvw4WDqfAdDhyMidmIgkHSkbUZfozWk/FIrwc9HMp2R4wCsntxuhMvGbdEnuXYc5pabUI2bx7tbeBIgaJ07FxJSUnBsGHDkJ+fTw1JVqsV+fn5mDRpEjweD1pbW1FSUoI333wTNTU1wntTZEZFUbosku2hA7wekUi5HDSiwSr0rHC8sKKMyJReLeWQvBeF5xuXSHHj45ZZlnnwShifFxH0CAi7tYx/zofnJ1vWU1Mi0CIEeiRE9K2WlYhXuMlkYTab4XA44HQ66UVsbBzEKk4mrmAwCL/fj3A4HHeInpdHNMmRdkDKjM0LX5+iMmbLRW+wSqRdsGnodblE6kw2uZI0Re6D2byypEHkj17Ul9lvRMTbSN66Cp5osGnz7eFwTCRHy2RmxLCRKEwmE5xOJ/r27YuhQ4ciMzMToVCIujHNzMxEYWEhTCYTWltbUVFRgR9++AEVFRWd2pyWjDJZj9S6MIKuKNRdJZFk23NPEw1epp6oryTR6F0g2+WffvppXHPNNQl9e/vtt+PFF1+kjoQIjOiNB8NgciSDJfVOpxMFBQVwu90oKyuD1+ulxM9IPKqq9uyFfawCJFPoRZZeVig+PlE4Pj0eIgu3TDmUbTuRpS+yoLMkRURuRPKLZExESRWRNyMkQySjCIl0MhFB06ob0j4URYHdbkdqairy8/M7kVVy9oZc0kjIRSAQQF1dHRobGxEIBKiSQSxdqqoKb6QFxKRNL696BNFIfDLrv+x/vq/oySpql7zMMoJP/jabzbBarbQOYrEYQqGQ4UFFT77DDa12ebjQG2XqKrqTD7PZjBEjRuD//u//cPHFF8Nut3eKlyeO0WgUe/bswa233oqvvvoKkUiEfsPOQTIL59FU9j0FVrlIT09HWloaQqEQ6uvr0dbWFufZUS8erWddKfdEjWhGkKz/3gNFUeDxeLB27VoMGjQIqqpSr6IWi4XOS4FAAK2trfSS5pSUFGRkZODJJ59EQ0MD3nvvPYRCobi4E9mu/3OHyWSC3W7HSSedhPnz58fdRxONRrFx40bMnj0bdXV1PXcGK9EVDfoht8wiGmSMKODkb/5wGb+iICIDLLQmGxKvyPoqswiTZzIyIiICfPo8ZIRHa7Ui0VUF8o2epVlWR7L61CIsbFos0SDLoNnZ2UhLS4PZbKaNXFEUhMNhRKNRSiCID/VwOIzW1lbU1NSgqamJrmyQO1cURaGkxAjhZNuqrJ66Un96A5mWIgT81NZFbqLZcIQUGFkNIeHZerBYLHC5XPB4PFAUhe55jkajCIVC8Hq9cW6kCdhBhi1T/rmoPYrK3wj0SKzoN5vm4bRi9wSpPxzQGgP5512ByWTC1KlT8eijj+L4449P6NtoNIodO3Zg7ty52LhxY1x/J94JeaMDP3f0VD56M/TqixgaBgwYgEsuuQQXX3wx+vfvTw08mzdvxquvvooPPvgAra2tmmVFyj4ajXYaC7RkMCp/V+NIonfD4XBg27Zt6NevH1auXIkZM2bQ1Ql2vlLVzpccDx8+HOvXr4fFYsFJJ52E9evXx22j4vVHI23n59i+TCYTCgoK8L///Q8TJ06kz3kDbWNjIyZOnIjy8nJNskHGWr0VjYRvBucTIMuoIustq9zxiiivOAOdJwX+DgJekeD/Fw10WoRC9D//TEsRNcqiZcomq6TxZcKH0wIvo6yzGmX4WuFEdSdSABVFQUpKCrKysuByueiezNTUVEpCyJYpYmkHQH+bTCa43W5KSoAOpcPv98d5GyFgy1hUxyKrKftelm++3cnqQ9QW9eLllXRZGrJ8icAO2IRUZGdnIycnh5Y/IWtmsxlOpxO5ublwOp1xB7t5uUWyGWmbRuXuLvT6cRKHD3l5eTj99NMxZcqUhL81mUwoLCzEL37xi06GLtHfgPEtjT8n2Gw2XHjhhXj77bfxhz/8ASNHjqTja3p6Ok488UT88Y9/xK9//WvYbDbd+JJ9K4lEoCgKrrzySvTr1w8NDQ045ZRTOm2BYsPy/XbXrl14++23oSgK5s+fT/UCPYNqEj/BZDKhT58+WL16NSZMmIDq6mr86le/Qm5uLlJTU5GWloY+ffrgiSeeQEZGBpYvXw6Xy9UjY2jCRIO1aorIBf+bbwQyAkD+Zq3AvBIua1QiIsO+EymeetYXNoxM0RNZc9iwRhs+CcsSAy3SwRMILfLExsffTM4qujJyJasnEWFkw1ksFqSnp9MwNpuNXroWDofR3NxM70yxWCx01SISidClfbfbTa3vBCQM621LVE6s/Hxd8oRMj6yK2pNeOLJ/WURSZBZHQg70OrasbfH9g1x+lZWVRbdMAaBL1TabDS6XC06nkxINo6smBwuJpC0bUxKNpydgpE9ofXu4YKStdTf+0aNH45JLLulyHG63GyeeeGKn7VZ6Y6xW3/45wWw249xzz8Xdd9+N8ePHx40z7E9xcTFOOukkDBw40FBZaZG9RJFUEo9umM1mPPXUU1BVFZdeemncNkgCRVFgtVphs9k6eR6MxWJ4/vnnEYvF0LdvXzqXyXTCn2tf10JeXh4+/PBDZGZm4s0338SQIUPw1ltv0S3qZMv6Y489hm3btqGgoABnn312Qg5fZEgoBt4VJiC3+Ios3az3IfItec4qvLJVEh6JWPsTsdKzeZN9yyubsvhkAyhR9kUemWQQufbk0xXJIAtHyA0pbzZvfHwiJY7v2Gw9s3VqsVgQCATQ0tICv98PAPSAuKJ0bIMKBAJx96QQIkHcnZKBR3YAnIWIIMnIAJGXJ1yiVSZZXfL1rdU2ZGC/49PVap+iH4LU1FSkpKQAiD9wT9wis5de2mw2Wm+8S+JElQ7Ru54c+PXaYm9UWmQkhH9/qGUSyaA3diUKu90uvfXdiIyKosDhcGi6yiYwQkCOZojy3bdvX5x11lkYNWoUALlxxmQyoW/fvhg5cmSPkgijkI1jSRz5UBSFGgrYc5rkHW+EExlPA4EA/Z9XfrWMrTx+ju3Lbrdj8uTJGDlyJHbs2IFbb70VgUBAWA7BYBCffPIJzGYzrr76akO6uB4SIhpagzv7N2vNJQ2INAz2N58B9pmWhVBPLr1v2AYtG1D5CuCJk2yw5i3WIsJFQMpJJIOIncuYpYzoEdLGhxXlQ8vyL6sHWb7It+wqBTlkSDxPud1uSkD8fj+CwSDa2toQjUYpuSDv2HsUROnoWbYTbR/st+xvLeIlqnMZsdZTOLVWrEQEiJdZUTosQy6XC1arFbFYDDabDXa7HS6XC3a7nf5YrVZK+Hjixcslk1eLHB0sJaU3KiRGZTlUiluidcZCj1Qnkof29nbU1tYaDs/D7/djzZo18Pl8cfIlLZgd0JvrJk+ejHHjxlFjjZZCz44H3em/P+f6+Lkg0TpuaWkBAIwdO1Zz9Z7oLeyqhqIoePzxx2EymbB582Z6cSvRN42Ovb1pvjiUSEtLw/3334+2tjY8/PDD1BEP2VHC/gBAnz59oCgK2traNMvMaBvoEtGQsUf2OX9+QaZ8C4ViGiFPPNj3rBLJKkciJVlLcRPlUZRXWV4I+DMlvCwiGBnMST5FcbFlxMsp+l/WsbXk04JMISUejcjhbr/fT9MJh8Noa2ujS3Y+n48eQCT5bGtrQ0NDA/WEwkLPE4KI+MjCiZRjvW+1GL6oDbJxiQ5S8//zqwqi+NnwfDxkFclut8PhcMBut8Nms1HyF41Gqfcus9lMPX2xB+lkBI3/X/ajJ3tXIFOODtVqhlFyakQGWb31JESGgkQINg8y+Sd6d8quXbuwePHiLnkwCYfD2Lp1K5599lnp91p56o2EtCehV5//H3vvHWZHcWYPn5vT5KDRjEajHBAKSEhIgBcJiWCCSAbbYIwxXhbbeBe89sLPrMNiG+O4YLy2wQQbDMaAsQEBJoMCIiMkoZw1mpzDnZvnfn/MV03dmreqq+9kqc/z6NGd7uqqt6qrq855K7lcLkycOBFlZWUAPnFusRFN3imYTCZx6NAhbN++fdBtG4hgsUXL6INVL3c6nca3vvUt9Pb24vOf/zwCgUC/Non1jw5H3wg7c5ZVVVXhiSeewFlnnYVoNIorr7zS8Mab8TMbfXC73ZgyZQqSySSqq6uN9ZmhUAj5+fkoKSlBWVkZ8vPzUVBQgE9/+tNIpVK46667BqU8LW1vy0BVMJ7Mq7aU5Z/nPe6MYImEWNyrW2y8ZENtosAQxYbMNjF9mbhS5UsGnkjrhJelI7tOlQH1nJg+FUb2jvhnqXU6TqfTmK7T09NjEF3gk3Ma2C5bbKQC6OsQI5EIwuEwwuEwWlpajEXf1Fa2IhGW1QNZnvnrzCYdkSETraItlG1io8rXMapey+Iw+/BZmN7eXkSjUbhcLvh8PmPKFFsvw7wX0WgUsViMJAY6aakwVI1+Nt/QYKWpupetPUPZOapEo9l3w4fnnUdW0NjYiNdffx1nn3224c2U2cn+JZNJ1NbW4o9//CMef/xx1NTUkN+RCqo+aKxDt56xdpaflsp292PTKD0eDxwOBw4fPozXX38d+/btG7SykvXXZs/wHm3Wlg3FuR02rIP1lbrnLAB9394TTzyBK664AmeccQb++c9/4hvf+AZ6enoQjUYRCoUwZ84cnHfeeVi0aBFKS0uRl5eXMaW3tbUVp556Kqqrq7M+M0m3Dh5t6O3tRVdXl7EBRF5eHkpKSjBu3DicddZZmDJlChoaGrBz505MnjwZ+fn5aGpqwq5duwalj7UkNGTecPG66mA5kZjzIxbigYBsDrl4kBp1eBMfN9WJigRPRgyp/OiWhZg/Fs6MmFLhqPCyuMTwfJnJ0hKfNyPG/AJy0eMtxpObm4t0Oo3W1lY0NDQgFoshJycHTqfTmGeZSqUQi8WMEY9EIoF4PG6c6yDu567jtVYJKNU7lZW9eJ2KQ7Y1rSwd/rcoNERxp9pZSxU3G7lgi76ZWHO73cjLyzPeZTqdRldXF+LxuLETmMPh6LfYXkbY+LomCiGVWDIrI5kYHEnodlDU96+6PxpgRWRYmabAnk0mk1i/fj2++tWv4itf+QrOOeccBINB42C+gwcPYvPmzTh48CCqq6vR1NSEpqYmNDc3IxwOG3WZxacjNEZjOQ8mREcFu0aFe++997Bp0yYsX74cvb29xghzLBaDx+OBz+dDLBbD5s2bsX37dmMtpqqdHapvktW13NxclJeXIz8/H6lUCuFwGA0NDejq6srY1tzG8ILv/62S+3Q6je985ztYtGgRTj75ZLz77rv9wlHfdm9vL/70pz/h1ltvRUNDQwY3MHMmmDnFRxMoRx/DQL+3cDiMhx9+GNdffz0+/elPo729HaeeeioqKytRVVWFdDqNWCyG008/HYWFhUgmk9i7dy98Pp/hGFbxU9O8pTVCUudokJFZ8IKyBoURnNzcXPj9fgB9u+LEYjHEYjGkUimjYWH/xClK4kJmVadIeeStkqGBghppMSNlKmEjVlDZgmkzr6tKcFECTRa33+83vJLpdNpYzM3v8iSe+C02HFb2w+bDUaJKFL6UIJGJaD4eWbqyei+SbVFYsPrPBDYLz09r4MtKlU8+TfYvPz8fpaWlyM/PN07+dLlcRnl0dXWho6MD4XAYnZ2dxnkasVjM8HpS5cGLEGreN2WfKE4ou10uFwoLCzFhwgTk5eUhFouhrq4OTU1NiMVi2hsBDAUG0jkNtH2xkraqLlLQiZfaKEL3WT5dNrLGFnYz0suELVXPxXfOO6ZEW6h2ZKzBSl2h+i7qmWAwiOXLl+Pqq6/Gpz71KRQWFhpbhbO57pFIBNXV1Xj99dfx9NNPY8+ePcY9yhY29VI220AGVZ5Ym1hWVoaLL74Yt99+uzEaHovF8I9//AM//OEPcfjwYe2DBW0MLnQ5Hh+WdyL39vaioKAA9913H8466yy43W6jfYnFYti/fz/effddbNiwAe+//z6am5uNtZp8fRRtsNoWjaa6w+q9z+dDYWEhFi1ahNWrV2Pu3Llwu9344IMP8Pvf/x47d+7MWmS7XC5MmzYNjz32GCZPnoxUKoXm5mY0NzejqKgI6XTaWJ+Vm5uLQCCAWCyGe+65B7/97W9RX1/fr/yZ7em0+TkaAxIaMs+x6m8+4w5H31y8cePGYfbs2SgvL4fb7UZHRwcOHz6MmpoadHV1GSSDERze08uEBT/qIXZOzAazOb4DqXx8HNTLMCMLMu85Hx/LIzvkjt0XCa0oYsS4GOFXiQ/xGZXaFgn7QDsc/r6YP6pxobznOpDZQL0rSnTx70XWIbNw4rojt9uNQCBgLM5mDW5vby8ikQg6Ozv7CW0xfpnoYza53W7k5ORg1qxZWLlyJUpLS1FTU4OmpiZD0AB9U9za29vR0tKC9vZ245tj350o+vjvT1wbJbOH3ZeRITaX/KqrrsJVV12F0tJSRKNRvPfee7j77rvx+uuvIxKJkN+2iNHUiQwGdNonq3WfQYfMDiQOVR3ln9UlCtQmIlQd1Y1zJMGL68mTJ6O8vBxFRUXIy8tDZ2cnPv74Y+zevRvd3d1Skc23t7Lvy+l0ori4GF/+8pfx9a9/HZWVlUin+zyY7Jti/XE4HMYbb7yBP/zhD/joo4/Q09NDxkkJDWaTGVTtbn5+Pi6//HL84he/gN/vRyKRMHbMS6VSeOWVV3DDDTfg8OHDGQe22RhaZMuR+D6Pnzrt9XqNTV9U64bMHGsMY7UesK38zz//fHz3u9/FjBkzjPLiyzwSieCll17Ctddei46ODstTCB0OB/Ly8nDhhRfirrvugt/vx5tvvolvf/vbOPHEE7FixQoUFhaivLwchYWFCIVCCIVCAID33nsP//Ef/4Fdu3b1O/tEV2hktUaDQSR61MumiBFf+Xw+H6ZPn44FCxagtLQUOTk5SKfTOHDgAN59913s2bPH8Hyxho1VWj5OnuSKa0RUxFu8r7pOxcdf49McyHkElGAQ0xbv8+9A/E3FzZ5nf7NypfIrI3Pie5fVA2rkSJZn/m9KXIjvW2UjlU8VZDaowoudu0x8s/+Z16CkpATjx49HMBhEOp02poawXbq6u7sNoS3mWYybnwrFh00mk4jH4wBgTEWIxWKIx+OIxWJwOp0oKCgwGoqamhpUV1cbdrB53LJ3wdLRJauy8nQ4HAiFQjjnnHNwzTXXYOLEiQCAnJwcnHXWWcjNzUUikcDatWsRj8fJTRfEujBcHc9wpzVY0CX2VFjqW7ZSBlbEBfUsIytiHDKRPxrhcDhQUFCAq666Ct/4xjdQUVHRb7QmkUjglVdewQ9+8ANs27aNXKvG4mL/y0aCk8kkvF5vxo5S7Cyd3t5ew9mRm5uLCy64AMXFxfjd736HtWvXIhwOD3reKRudTifGjx+PW2+9FQ6HA1/4whfwwgsvwOl0oqSkBBs2bMBZZ52Fm266Cf/93/+N9vZ2aZnYGFxk+x1Rzim2dtBK3GPp29aFy+VCWVkZrrvuOnzrW98yvs1UKoWuri4cOXIEra2tqKiowKRJk3DuuefigQcewBe/+EWEw2HLbW4qlUJ3d7ex2+e9996LPXv2IJlMoqysDNOmTUNdXR3q6upQU1ODU089FWeffTYWL16M3/72t7jmmmuwf//+rL45y0KDOuSMXRfJP8sg/5tvFNmhbpMmTUJhYSHKysqMU0m9Xi86OjrQ3NyMWCyWQSiow15kokA2mmClo+X/FvPAx8XKQEWoZOmK5cTHJYaRbZtK2U6JARYH3+HLSIyu95EiHmJauoRfjNesURGFDn+d2pGLsle8z6ev8xz1PE/ImBenqKgIxcXFKCwsRH5+PgKBAJxOJzo6OgwPD/ub7drFtvYV6x9LT6yPfPpsXUZPTw9aWlrg8/mMw/lCoRDKy8vhcDjQ2tpqCJx4PI6enh6t3YWsiDjVO8zJycHUqVMxYcKEjPhcLhcWLFiAK664AgcPHsT+/fvJ9iebujUQDKewsZI3SuDK7luJi4Juvgdqh/gM7xlVxTVaiYjT6cTixYtx5513YsGCBcYpxyI8Hg/OO+881NXV4Re/+AUOHjwozZNMzLM2yO/3o7i4GDk5OUYYNuoJIGMKSygUwoknnogLLrgAe/fuxd69e8n1YoMNj8eDJUuWoLCwEM3NzXj22WeNc5c6Oztx8cUXY+3atbjyyivxz3/+E+vWrcvKu2tjeCFrv0br9zkccLlcmDdvHr71rW/hsssuQ3V1NX7zm9/g4Ycf7rd1r9PpxPz58/HTn/4Up556Kr73ve/hv//7v0kebAa2m1d3dzdee+01RCIR1NbWYu/evQiFQli7di327NmDSCSCt956CzU1Nbjqqqtw/PHH44ILLsBvfvObrISG5e1t+X8iieOvUQSXCjtu3DhUVlZi4sSJKCoqMnYZcLlcyM/PN45GZ2s4WPz8/7xXmZ/nKw7H8XaotmrU9bzz5FlG9viw/H2RLInlI5sKoCLCokebj0dlE5Uv3iZqKFOVJ16QsHci1gmzkQLKa2oWnrpO5VcnrKxcxXuy5/lrDkffSEZxcTEqKysxbtw4w3vBFmAXFxcjFAoZ5ezxeBAIBAxiQO3IpioDZrfH40FFRQWKi4sB9E2TSiQSxnZ2hYWFGD9+vPGO2e5U1KigitCZvVfVPYfDgZycHBQUFPTbFhvoIz7z5s3DqlWrMH369H4HPh0LMPtmBnqfQee7o9612TNsdyPW0TFRbfU98m0K366PNqjytXjxYjz00ENYvHhxRp9G/XO5XPjMZz6D2bNnS9dIUv0I3/YwLyl14C57L+K5BmzaJX8auw50xKkMbrcbp512GgBg//79hshgbaHH4zGcJQ8++CB++tOfori42NJ2yzZGBrrtjxVY4QijDVOnTsXXvvY1XHbZZXj++eexevVq3HPPPWhra0N3dzfC4bBxkHFPTw8+/PBD/PrXv0Z+fj5OPfVUoz/XBSsrNiOAP6i5vLwcZ5xxBvbt24f3338fDQ0NiEajcDgcaGxsRGtrK1KplOW2gEfWU6cYEWFzNcVMiQScepbdZ/P1EokEurq6EIlEDE/F9OnTUVlZicbGRhw+fBhtbW1Ipz+ZaqJLhsSwFHEUw6iuWblvFo73QmXjHWVzbClxQo2MsGf49EV7eJtVNmX7ofOefvE6L3AoMSObF2w2oibe0xEcsniY7Tpiw+VyIScnBxUVFQiFQvB6vYao6OjoQDAYRDQaRU5OjkE8EokEQqEQAoGA8W2w+Kh3IhOt4XAYH3/8sbHlcF1dHQCgsrLS6KSbm5tRU1OD+vp6dHR0GNsKU4JqKMDyI5t7z9qB//qv/8KqVavwyCOP4Lnnnus3X3SkPGQj7ZkbrPbJyvu2kmfRucOIL5uaZxW8I0Pm4BnJd6JqE/1+P37yk59g8uTJWkLL4XCgsLAQU6dORTAYNA49EyErC/Y7Foth06ZN2LZtGxYuXIh0Om2s9WNrIBgSiQRqa2uxZcsWNDY2DmpZmvWB7Jvm27fCwkKsWLECS5cuRW1tLfLy8pCTk4OrrroK8+bNw/nnn4/W1tZBs9HG4GCw+g9WR5nQZls0j3S7my1cLhfOOeccXHnllXj++efxne98B/v27TPWHFFtAptO1dPTg4qKCnz605/Ggw8+aDntxsZG7Nq1CzNnzsTf/vY3bN26FZMmTUJZWRk2bNhgLFHIycnBggULcMYZZ6CsrAytra14/fXXs3bsZLW9LU8I+AZB9KKLZIh1NgzpdBptbW1oamrC+PHj0d3djcbGRjQ0NCAQCKCyshJTpkxBV1cXGhsbjcPFWAfFXsxAiL7Ox0ARcZXnFlCv0eC9+2LaOl5C0dsuTqWSxc2nwYflhYhqZEOMS+Zhp947ZQsLx+znR6lY58cvFKPW5VAQibhYXpTN1GgQT9hl+eGJvwiePAeDQSNPPp/PEMvRaBTJZDLDe8j+7+zshNfr1fIwy8olHo9j9+7d6OzshM/nQzKZxOTJk9HW1mZ0zi0tLThw4ADa2trQ1dVlLAaXNeZWxLBuuNbWVtTW1iIejxvTJ9l7ZwvmKisrMX78eFRVVcHhcOAf//jHqPVoDxdUbZrsPgXZlFiztEVSa9Yu8v+btY9utxt+vx8ej8fYklW2E5pZ+sMNmR0FBQWYOHGipVE5l8uFWbNmIS8vL0NoyNpjBr48IpEIXn/9dQSDQSxbtgxOpxPHHXccTjjhhIywiUQCR44cwauvvop169ahvb1deySM+k3ZRdkH9Amcf/7zn7juuuswa9YsLFy4ED09PViyZAlOPvlklJaWYtOmTfjLX/6Curo63HXXXVi8eDFuvvnmrKeS2Bh8DNYog9vtxuLFi3HvvfeirKzM6D87OztxzTXX4M033+zXHowF5OTkoKSkBB6PB+3t7Whubu4340Z0nrJNYtra2lBQUIATTzzRstCIxWI4cOAAfvGLX+DWW2/F4sWLMX/+fCQSCTQ0NKC5uRlOpxPBYBAnnngiPv/5z+PEE09Eb28vnn76aezYsSPr9tWS0GCEkDWSzCPjcDiMeeR850Mt2gQ+IWCpVAoNDQ1Yv3694ano6elBXl4eJk2ahAkTJhg7bpSXl6OtrQ21tbXo7OzsF6cIGflj6bMwKo+3LH7VOSEsDqoDZP+riCkVvzg6JAoMVT5E759M1FBQ2UkRc1W8FCnn/3e5XPD7/QgGg8YIF9C3iDESiaCnpwfxeJw8wE9FtGUiicqTaCd1n+pQZWUkjs709vais7PTWHTJFsTxW8T6/X4kk0n4/X74/f5+O6uIRE228QFDb28vwuEwDh8+DK/Xi8LCQgQCAQB93o1IJIKuri40NDSgtbXVOECJ7Xil+j4GE21tbXj66adRXFyMM844A0VFRQiFQsbUMpau1+vFnDlzcNFFF+H55583plcMN1Tty0ghG4ExUK+jTLiLYZgHnZWbuJ0tg9PpRF5eHlasWIF//dd/xaxZs+Dz+RAOh7F+/Xrceeed2LVrl/QQz9EO5lywaqvuFFjZtVQqhba2NrzwwgvYvHkzZs+ejYqKCoO8pdN9I8W1tbVYs2YN/v73v2PPnj3KMzVY28NPQ+adieJhgWZOgWQyaWzl+W//9m948cUXjS1P33zzTTzzzDOoq6vDoUOHEI1GcfjwYbzxxhv46le/iltvvdUWGqMA2bRBVByBQAB///vfsXTpUuMMLob8/Hz8/e9/xw9/+EP8/ve/z1hYPhbAzgxzOPpm8wQCAXR2dmZsG099cy6XC7m5uYjH42hubtZOj70T1gZs2LAB3/72t3Httddi/vz5KCgowJEjR/D2228jHo8jLy8Pq1atwkknnYRIJIKnn34af/zjH40d6LKBJaHB5tV6PB54PB7jfAQAxr77IhnkPeYiMe7t7UVPTw92796NmpoaBAIBHH/88Zg5cyaKioqM06FZA8YIKL/VrQiKdImVnyfpOpB56GVhWToU2afsFK+ppuSYjVbIbJalLxImFXGQea1UeZGF40k6W7Ccn59vHBDDyqC3t9eYn9vV1ZVx4J+KJKnKSJcgmgktPo+U2GF1H4AxHTAYDCKRSCAcDhvfj9frNU7tjkajhqcjmUwiHA4bIkX2Tqn02T1WhmyBGdtWNxqNIhqNor29HZ2dnejo6EBbW5shMGS714jbFFJrsvh/ukilUti6dStuu+02PPTQQ7jooovw1a9+1Rjd4PPm8XiMukIJjYGSZzGusUBgrXbwVGc2kHyqhJdIMpnooM7ImDFjBn74wx/izDPPNM59YXZOnDgRixYtwje/+U1s2LChn+2D+d4HAlX6HR0dWLNmDSorK1FQUKDVFvX29mLbtm3ktCmZY4SyJ5FIoK2tDclkEhMmTMhwFPb29qKtrQ1vvvkmnn/+eezbt0+5sw1rt/nteadNm4apU6eioKAA4XAYhw4dwgcffIDDhw8jHA4bzkgxHh6tra244447cOjQIdxyyy0YN24ccnNz8de//hVvv/22MQLc29uL7du3A4BRT2yMPGT9rY4zkiEUCmHdunU4/vjj0dnZieuuuw7r169HLBZDIBDAFVdcgZtuugm33norjhw5gqeeempMjWxEo1FUV1ejsbERixYtwvnnn49HHnkEPT09AOQOU7/fj7y8PHz88cd47LHHtNPj24h4PI6WlhZs3rwZv/3tb/Ef//Ef+NSnPmVMqR43bhy+8Y1v4LLLLkMikcCdd96JZ555BjU1NQPaTtqy0AgEAsbccbZ7DetIwuEwuru7jQUsQOaZD2LmWaPDnxDNtt9saWlBMplEbm4u3G43WltbEYvFjIZG9OxSIwCAfP2BygvOX6eGgWWKkyJ5MpHACzAqfgriiIDMfv4+NSVCtENlJ5U/1T1x4TcVjk/L5XIhLy8PhYWF8Hg8APrqGZtexBYt8fGzhUoidEYtxPciEymy98NsEOPgtwdmcbLn2bfBFl2yszNYZ822tO3s7EQwGDQEVVtbmyE0+DxQa1F42/iRFN62ZDKJnp4eHDlyxDior7GxES0tLUaajACKcbB88eIiGAyipKQEVVVVyMvLM7bPq6+vR1NTk7HWQ3aujYhEIoHGxkaEw2Fs27YNtbW1mD17NplHdoK8CoMhElREazRA57uVPTNYIsNKHPy6GxETJkzAv//7v2P16tX9dmJiXs65c+fiV7/6FS655BIcOXJkwDYPNxKJBH79619j3Lhx+MxnPoP8/Px+bSKPdDqNjz76CFu3bpVuM6szqsTuxeNxdHR0YOvWrdi0aRMWLVoEr9eLAwcO4Nlnn8WaNWtw4MABdHV1ZfSzYt1io7J+vx8nn3wyLrroIixatAglJSXGbIXu7m5s27YNTz75JDZs2ICamhrpwZsMvb29aGxsxGOPPYbt27fj/vvvR3FxMSZPnmyIFZZnfqTE3uZ29ELFaUS4XC489dRTmDdvHl5++WVce+21aGlpyViP9/Of/xzPPPMM1q5di7vvvhsffvghDhw4MGam0fb29uLvf/87ioqKcPPNN+MHP/gBLr30Urz77rvYt28f9u3bhyNHjhiO+3Q6jYULF+K73/0uotEotm/fjsOHD1tOl3GfRCKBzs5OHDx4EA899BDmzp2LM888E08++STKy8tRWlqKcDiMH/3oR/jnP/+J5uZmoy3IepQqrfEkO7BvwoQJyMnJQWFhoTHPDPhkj+TW1lZ0dHQYXtJIJNKPaFBEm/3z+XyoqqrCwoULUVZWZnh9kskkDhw4gLfeegvbt29He3t7vxMSdZW0asSBCsfDbARBDEONhJiRflmaqgP6ZDbqEA8qHsomSkSJz4jpU/f5/51OJ/x+P8rKygxB6XA4DA8/L0aTySQ6OjrQ1NSEzs7OfiRTNsJA5VOn7MQ8iWVOxSErSwDGYrZQKITCwkJ4vd6Mf8z+YDCIcDiMcDhsLM5mi9/EeGWCQxTafB3yer3Iyckx0oxEIsZ6DH53MVk5hkIhpFIpBINBHH/88Tj33HOxbNkyYxeMeDyO6upqvPzyy3j11Vdx6NChDHLBixYxP8xmt9uNqqoqXHfddfj6179uTPViz+3btw8///nP8ec//7nfgnCxPIbKuz1S3nOdDltHHA2n3aJopdoPj8eD0047DY8//rjS059O963r+973voff//73/dIZ6dEMHTgcDowbNw7Lly/HqaeeiunTp2PSpEkoKSkxduVyuVzo6enBc889h/vuuw8ffvih9tQFqv0Wd5Xyer2YNWuWsb1uTU0N9u3bh9bWVoTDYWN3GvauxGluubm5mDlzJmbOnIlLL70UJ5xwAoLBIGKxGLq6uhCPx+Hz+eDz+dDY2Ihnn30Wf//733H48OGM7epFu5kjw+12IxgM4qKLLsJvf/tbNDU14cILL8SWLVuQTCbh8Xjw/PPPY/ny5VizZg0uv/xysi2wQWOkvhWzdnPChAnYt28f3G43Jk+eLHUmeL1ePProo1i9ejVefPFFfPaznx2xabTZoqCgANdccw2++93vIhQKGc6zZDLZb/0xaxfWrl2LG2+8EYcOHbIkrkWnjcfjQW5uLgoLC3HJJZfg29/+tnFA5nvvvYc77rgDW7duRWtrq7EmWsb70ulBPrAvNzcXRUVFKCwsREVFBUpLS43GIR6PIycnB/X19QA+mUrFz/HkSQalPlOpFOrq6uBwODBlyhREIhHk5+cjEokYp6R2dHSQnkzZGRaqEQgVceTJJYOZcKHA3+cbfzOBwT9PjWCY7SEvxqFaV8I81RQJZPfYb8oW/hmqzMSwfJn4/X6D+PIeeDatiH1wTqfTmK+vSkcHZgJTJmCp+kGVC1V3GJFPpVLGtCmHw2Hkk/1mC1+j0ajhzTCzi/9bVQ7pdN/QKVvjxEY5WN3Q2Ss/GAwiNzcXJ510Es477zwsXrw44/ybdDqNSZMmoaqqCvn5+XjyySdx4MCBjLzI6iwrt2Qyierqajz44INIJpO44oorMGHCBADAgQMH8OCDD2LdunXKM2uGshMd6U5aBh2brDpLBgtmTqFAIIDp06cjLy/PNJ9erxeTJk0adBuHC+l0Go2NjVizZg1eeeUVeL1e48A8RrLdbrcxp7q9vd04eFM3ftk19n8sFsPevXvR1NSEYDBonKETiUSM/lU1Wpabm4sVK1bg7LPPxuzZsxGPx7FlyxZs3rwZNTU1iEQiCAQCWLRoEebOnYvVq1cjmUziL3/5CxobG/uNlvB2ptNpo518/vnn8YMf/AD/8z//g2eeeQZtbW1oa2tDRUUFxo8fjy1btuDnP//5mPFmjwaMZkF+8sknG9OkGZekwPqIdDqN4447bkxucdzR0YEHHngA27dvxxe+8AWsXLkSBQUFxpb2wCfcrb6+Hn/4wx9w7733oqamxnJ9F9834wHxeByPPfYYNm3ahJycHCQSCezbtw/19fVGWyATGVZgSWgUFRWhsrISZWVlhtBgjWM4HEYgEDDIFNsLWPRmip5hcRcqNn+ttbUV+/fvRyAQQDgcNqZ38EOnIgmjSKiMGPNp8vdEAmkWVuYdB9SLxlWih7KDIuxm4DsXlTBRecet5oPFwact5oOfZuRwOBCJRAyVzcqUebYAGIfWsTMgKNJiVi6qxlW34aXeAyVExTwysA82mUwaYfmDstLpdMaaJ977qxK5VH54m8Xf7BvixSXVcFEiZ/z48Vi4cCEuvPBCLFq0yDj7hk+TeaNWrFiBPXv2oLGxsd97M7M7kUhg9+7d+M1vfoPXXnsNxx13HADg8OHD2L17t7Ht5kiMLIxFkWGFXAx2mcrqLw/WZ+ggGo3inXfeIe+NZhLFI51OG/vkU32U2MfIHA466cieYYvSe3p64HA4DM8lcx5Si/UZioqKsGLFCsyaNQuNjY3Yt28f3nrrLezduxfNzc3o6upCMBhEd3c3PB4Pli5divPPPx+7du3CK6+8kjHfW2xX+XU5HR0dePTRR5FOp/GDH/wAZWVlSKVScLlcWL9+Pe644w7s2bNnTLzz0QJd5+RIlOnBgwcBwFgHLJse63Q6cf7558PlcuHee+8dU2s0GFj9fuONN7Bp0yaEQiFj5JF9E2wdVDweN2YMDWStBEuXOfSi0SgaGxvR1tZmzCLh12kOhsgALAqN/Px8jB8/HlOmTMHUqVNRVFRknGzMjjbv7u5Ge3u7sahXRnrEIV0GNgefzSMDkHHonuz8B7OCoESBFfJmFrfOfR2yYEZkzdJUNRAyjzLfGZmlx4+wmI3EqOxkaUYiEePsCAAZ4oLFwxZJM+Eqdr7pdOahgGblwN8Xw1PkVaeeyEivKK7Fd8DqNiUwKFtV790sryxdFhc/giFLT0RVVRWWL1+O+fPno6ioyFhXw55n37Pf70dVVRWmTZuGd99911jIKhOmvLBkjRvbdq+9vR2bNm2C1+s12ge2KYB4YKcsjbGIbNoi2fNWhbQs/aEq22g0ioMHD6KhoQEVFRXScIlEAlu3bsW6deukYcaK2ADoaajAwN+9mIZYJix+Ni2TGlVQtTV+vx+lpaVoaWnBs88+i127dqGmpsbYtY5Nmz506BB2796NZcuWYerUqViyZAleffVVabw+nw/5+fkoKioyuERLSwv+9Kc/Yf369Vi6dCmWLVuGTZs2YePGjdi+fTu6urrsEY1Bxkh9Pzt27EAikYDP58PEiRNJEelyuXDNNddgwoQJiEQieOyxx8ipxcDY6AtisRgaGxuNvymuJd4bKHj+wfpa8d5gCAwGy1On2CLwsrIylJaWGvucs/MwWBhqn3D+kD/muRB3kuJFBT9sQ02T4D3xIsxGNcR7qsZeRsTFdGTPi9eo7WtV4XnIFtfLbFLZLSs/Kk8iYRbDysiwSjAx9czEBlPwLJ/sGX53JL5O8PGKHkDx3YllSRFpme1iOZjdY/epOiimy3/wwCdTAM3SpN4PlQ8qT5ToFvPM1w2+wSsqKjKmRbFvnI+P/e90OhEKhVBSUoJgMCglTqwdyM/PR1lZGdxuN5qamozNINj+4dFoNMPTydJh8YrrS2x8gsEsk2xJvKy+MaRSKezfvx+PPPII/vM//5PcRSgej+Pdd9/FTTfdhPb29n528f/z6Y5F6DqnrMQnttv87n4sDPtnRtyZR7Surg6bNm3CkSNHEA6Hja1u2QGybPo0OwuHrfES3wvb1vjqq6/Gv/3bv8Hn8yEej+OVV17BT3/6UzQ1NeGDDz7Ajh078Le//c3YcIZfSzKWBOZwYjSVi5kdPT09+K//+i/ccccduPvuu3Huuecao35utxslJSX405/+hAULFqC3txcXXXQRampqsnK8jgaobON5mxlXyTZtsz5zRIQGS5hNlfL5fEgkEsZ+/3zjxISDjHB5vV7k5+ejoKAAgUAAyWQSXV1dxhabbKqFuJCcpW+2TZ5oM09KZCRNRrDFMNR9ETJ7ZARXBrOORkbkVd5dWfoyccaHEzt0Mw+omeBjWxz7fD54vV5DRLEFytFoFF1dXcYCRb4zFOuWyg6dMhAFimg/D2pqlGgTLyjFe7J0+G17ZfGK75p6hnpedZ2/bzaNjmqcqL+Zs0B2ZgLQRzAmT56Mz3zmMzj77LMRCASwefNmPPHEE9i4caMxvUN85/w/1iYMpgdGhuHsuAZCNq3aaaWdGajYkD3f2NiIhx9+GNOmTcOFF15oDOUnk0kcPnwY999/P5577jns2rWLHNnm2yeVrSNFPlR9wnDArA8Tp0nwRIQSBszpGAqFjHiDwSDGjRsHh8OBeDyOoqIilJWVwefzIZVKoba2tp/QYE6Jyy67DDfddBNKS0uNd1dWVoaZM2fi85//vLHRTHt7O+n0YjaMZmI5EhhL5ZFOp/HQQw/h8ssvx8knn4yNGzdiw4YNKCoqwpw5cxAKhTBp0iTEYjGcd955eOedd8g1RUcbBtvxYBUD/a4sCQ02zBqJRNDQ0IBYLIZgMGhs29nd3Z1xsJqs43c6ncjNzUVpaSkKCgoQi8WQm5uLvLw8+Hw+1NfXkzvtsAxT//P3KZLIX5Ndp8iSmSdOBrOXovvieHElPidrbFUdq5h3M9EjI8a8J0wWh6xs+S1r2ValbW1tiMfjCIVCcDgcxvQYJjioPdhlacoItAjKyycTReJ1MU8yAkX9Tb03Ppz4m5U1P9XJTMCJv1UEUSTqKjLY0dGB3bt3Y+LEicZoJouDt4dNfWxvb5fuBuNwOFBRUYEvfelL+NKXvoTS0lI4nU7Mnj0bM2bMwO9//3s89dRTGeuyxHyJZTHUGIlOW9Z2yWwabJFBxT0QsSFDKpXCrl278N3vfhcvvvgi5s6di6amJmzduhXV1dU4fPgw2tvbMw7+YzY5HI4M4c+TZJkDRNeuwcBAnElDAd4RQI1q8AKD6scdjr5pTlOmTMGnPvUppNN9881LSkowb948FBQUGE6JadOmwev1oqenB/v27evXjnu9Xpx++un4/ve/D5/Ph29+85s4dOgQKioq8L3vfQ+f+tSn8LOf/QzXX3+96e51NkYnZI4yCh0dHbjqqqvw/PPPY/78+Zg6dSpcLhcCgQAcDgf+9re/4Ze//CU2b96stTbjaBKfIucYSL5E55FuutnAktBobW1FXl4evF4vUqkUurq6jIPW2C4ZrBOgzhpgv71eL0pKSpCTk2OIlNzcXKOzYGdxWAVF1nQ7FNl1mSdYPFRPfEaVDkVSqYZcXHfAP8/bLCOt4oetImgimaG88SIJpQg9L4goDxkDLzbS6bQhKNiCUH4qHVWWOuSah1jesrioZ2T3ZXXLSh0T06DCiCMMYj2XCRaVnTLBzYen6mVtbS1ef/11uFwurFq1CmVlZca3wNcLtnitpaVFumOO2+3GypUr8dnPfhYVFRWGTXl5eVi6dCmqq6vxzjvvoLq6mnxeJEfHCmTvTbynG5cOqPZKJy0rBAPomx61Z88e1NbW4tlnnzUOt+SnyIjx8ydTy87oMMNIkxEzp4OqfcgGPGHnf4vfFPXe0um0cR7P3LlzcfLJJyMvLw/V1dVwu92oqKhAbm4uCgoKkEgkUFJSYixo7ejo6Ffn8vPz8Ytf/AIFBQW47rrr8OqrryIWi8HpdGLz5s14+eWXcfHFF+MnP/mJsViYKhuGkX6XYx2DXX5+vx8rV65EIBDAW2+9ZZzLoPpO9+7di4svvhhz5szB9ddfjz179uCFF17AkSNHUFdXZxwgJ9qdbZ7GYp0ZqL2UwBC542CkA1gUGg0NDcbuIB0dHSgrK8O4ceNQVVWF3t5edHZ2Gqoznf5kLQYPl8uFnJwcYyE5W9zLKo3f70cwGJRut8r/rVsAg6X6zLy9KmWosoHqPPn/deIXn6dEiOp5NqeWt0dFtGUCxev1wu/3AwB5UrxISPk4mIeNXZO9dz6fKnuoMuGvU2eTiJCNbMjKhRppMKu/InFjhEkUszr1mB2WpeNB1RElIsLhMHbt2oXOzk50dnbipJNOwrRp01BYWJixLktc3E7FW1RUhHnz5qGqqirDG+1w9B3ONm3aNMyYMQNHjhwhxRVFjIYSo6EzohwNDLptw2DATGw4HA4UFhZi6tSp8Pv92L9/P5qbm7V2H0ulUkb90rGDnVEjK5ts6vlgw6zt1qlXg1X3mC2icDNrbxkcDge6urqwadMmuFwuFBcXY+7cuZg5cyYSiQQOHTqE9evXY8qUKaisrEQoFDIEYCgUgtvtNtp5l8tlbC7T1taGf/7zn8Z7T6f7Ditcv349zjjjDFx99dX4n//5H6XDhtk3Gr7VsYrBLLdQKIS77roLp512GlwuFzo6OlBTU4N///d/R3V1tfLQ1W3btuHAgQPYvHkzenp60NzcLD2DRQUzgWHDvL0cKCwJDXYQT3d3Nzo7O5GTk4OJEydi2rRphnF1dXWor69HTk4Ouru7ja1J+RcaDAaNMwNisRgcjr6pFh6PB729vcaBRbxn3WrmdbxoqoaU3Vd5ekVCaeZ1EkmrbJ0JRarYfeo5Vf5UnmuRsFEkWZUHER6PB3l5ecbhe/F43Dh8TtwyTZaW7HBHHdEhih4xnOz9yeLSGSkR7RSv65I/agG4KBhU3wETJrKtiLP9hkSb8vPz0dbWhp07dyIajeLw4cO48sorUVxcnLGA1+fzoaKiAlOmTEFhYSFaW1v7jU7l5eWhuLjYmH4lorS0FFOmTMHrr7+eYQNFcsX3PNiN5WjqkLJp0wC511wnvOy+jMRPnjwZX/ziF3HxxRfD5XLh4MGDeP755/H888+T3kirEEcygE+88/yohiyfsnZB9cxAYRbvQIVINrZkGy87x6C9vR1FRUVYtmwZjjvuOPT09GDt2rV45plnMGHCBCxYsAAnnHACKioqEAwGcdJJJ+Htt982RqjcbjcWLlwIoM+J0d3dnVE3UqkU3n77bZx11llYvXo1fvCDH0jzAoyu73SkMFpEltfrxQ033IALL7wQ0WgUXq8XVVVVmD17Nv72t7/h8ccfxx133KE8I6anpwe7d+/O2gazchgN5TSSMGsfB+t7siQ0XC4Xurq6jF0A2E4RPp8PDocD5eXlmDZtGpqbm1FbW2ucOsz252YZ6O3tzdim1OfzIRQKIZ3u22aLHwkRyaFYENQ9HjLyR3n8xXBiPDJPtJgWf42fImQGityKcfE774j50SWYlJCSeeHNRmh4Uu/xeOB2u43tat1uN7xer7Gfend3tzFfn9p5S5eYy+wS4+NtGwgoYaljr1iHmV1U3OLfZqJPJYRUdUGWLn9dVZ/GjRtneJwPHz6MeDyO888/v19Zu91ulJWV4bTTTsPu3bvR1NSE5ubmjDQZSZTZwdZxyfKuEotDhdHQiWfjobcqMvhwVr8ht9uNxYsX4wtf+AKmTZsGAJg2bRrmzJmDZcuW4YEHHsDGjRuV3kwZWD1jdYe1reIW6FbekVm7O1xQOVZGG9gBqtFoFFu3bsW4ceOwePFi9PT0YMeOHTh06BAaGxtRW1uL2tpaFBYW4sQTT8SqVavwzjvv4KWXXjIIZjgczninPHp7e/Hhhx8CACorK5U22SKjD6Ol7oRCIVx77bXwer24+uqr0dHRgfz8fNx000045ZRTMH78eJSVleHmm28e8DkYOhzORnbgHTlm/EUGS0IjFAqhq6vLmD7Fn+4JADk5OaisrERTUxMaGxuRSqUQiUSMEwbZNneJRAKJRAJut9sY3QBgDIGzLU4pYSEjkDJCLRsd4MOIoApO5lHniZkZAaBGaMQRB9FucdE1E2rsObN8q0QG9Qw7LVqXtItkhHmnfT5fhshiB9Ox0yj5Z6kO1oycy0CJMCou2QgIBSuES9eDKooJPhxvj9mHzNdpnfyI10URzD/L4uPXW7FFno2Njeju7kZjY6Oxj70Yt9/vx9y5c3Huuefi4MGDeOeddzIWhvf09CAcDhsCWoTf70dubq4032a/jyboNOjZjnRYsUHHHq/Xi9LSUowfP97opPx+PyZPnozi4mIUFhYCADZs2ECO6qriZuKCP+iSbRwykMOlRovYYLaMdrCDdYuKiowzUFj/xk4yTyaTiMfjiEajCIVCyMvLw3HHHYcvf/nL2LhxI9ra2pBKpbB3714AfX2G2A709vbi0KFDAGBMybUxNuD3+1FZWYl4PI5NmzahqakJDocDR44cwfTp03Hvvffiqquuws6dO3HfffdlfRaKLTKGBk6nE8FgEMXFxXA4+qZLRiIRY8vqdDptzFwxg2WhAcDYH5t5KWfMmAGgr4MpLi7GlClT0NbWhu7ubtTX1xuNB2u82agFO0ODnSguLkAW/xdPt6Y6JZWXWeYB5uOUQeXpp0gjFU5nqhQVn2pUgSKVsryYiSxeCOnExXv12eLtdDpteBbZ6AubPw3AqKQUKZAJCmq7VdX7oogzX1a83TpEXlZWMoXPnqO2wLXieZa9L933y1+TCVL2j3koWWfPyJu4PS1rdFgD09XVhb1796KzszODCLB0c3NzsXTpUmzcuBFbt27NEBrhcBidnZ3K/JidGTNcIuNY7rhk7ZHs20kmkwiHw4hEIoZQZPUsLy8Py5cvR2dnJw4ePIjDhw/3e55/72L8/DkNwCebRgzGCbaqvuNYApsCW1hYCKfTia6uLoNksP4hHo/j8OHDBtk4dOgQwuEwAoEAJk+ejHQ6bTgiGxsbsWHDBkyYMAHz5883plK1tbWht7cXTU1NAECu6WTXgWP7GxyNMOMdbGtyl8uFsrIyw/m8detW7Nq1C1/5ylfw6KOP4uabb8bzzz+PI0eODNgGyg4b1sE2arnpppuMdddsGURrayvuuOMOfPzxx/B4PGhpaTGPz0ribJ49+93Q0ID9+/fj5JNPBtDXCRQWFmLatGloa2tDbW0tdu7cmdFRpdNpRKNRw2vO1mo4HH2nRDNPCKVuRW80Txhl4WReYwYzTzZPdnW83qp7VjoxPj6esKo6Q0qMiffZsxQBNhu1kcXLyiaRSCAWi8Hr9Rrvl5GGVCoFv9+PnJwcYyod/w4pO2TvSSxPyhvJQE1b40eVZOWkKhc+DlV5yUaVqPhUcVH3Zc/J7lH1hnmHXS4X8vLyUFBQgNzcXHi9XmPRbiQSQWdnJ3p6ehCLxeD3+42th1mYd999F2effTZKS0v7vQen04mSkhKMHz8egUAA7e3tRt66u7tRW1uLtrY2lJWV9ct/d3c32YjJxP7RDDNhPdT5l7U7VLuQSCSwb98+bNmyBatWrepXJ3Jzc7F8+XJ8/vOfxx133EFOm6DaHGYD38YxITxQkcHnk0//aK9XIvLz83H22Wfj8ssvR3FxMQAYO8h9+OGHeOWVV3Dw4EH4/X5ja/Lu7m40Nzfjo48+wsknn4wVK1bg97//vfFuotEoamtr8d5778HlciEUCiEYDALoa0eZiHG5XKisrMTu3buNd+3z+bBq1SoAfZvR6L6TY+29DTd0uEwkEsHzzz+P888/H9/85jfx1a9+FZFIBEAff3zhhRdw99134xvf+AbuvfderF692tJ0ymycxU6nEz6fzzgQknFau758ApfLhRUrVuBnP/sZ5s2bl3EeHuN5U6ZMQUtLCz788EN85zvfMY3TktBgJzOzxGpra/Hmm29i+vTpmDRpEoLBIHw+H3JycpCXl2dsecu8u6yRYNvcsTn8bGcitq0tm5bFQI1Y8F5qEaLXml0T4+L/pkgtRV51RYPOh6jTaFKEmM87JQaA/vPqeIHBCxLKFn49jcyjLPNkdnV1GQc4smfdbrfhlcrJyTHOx5CRCVn8lA3U6AUvcETvJz/ywuol5ennhYRYzrJ0RfFhtgUy/79ZveLTpOq9mfiUjWawdVZlZWUIhULGQv50Og2v14tYLIauri5jmpPP50NHRwcikYhRjnv27MGOHTswderUflOdmDOBquvxeBzr16/HKaecgksuucSYMgn0kdUtW7Zg7dq1x2wnMNqEFN/28m2wuLC7t7cXO3fuxCuvvIKTTjoJeXl5GfcdDgfGjRuHM844A0899VTGYk/KgcR/c3ya/P+q8nE6ncYBsT6fDz09PRlTOFV5PZbg9/tx5pln4pZbbsHs2bONXeTS6b5ZCEuXLsWqVauwY8cObN++Ha2trXC5XPjwww+RSqXwyiuvYMmSJZgxYwbmz5+Pjz76yGhzo9Eo6urqjLalra3NeGcdHR34/ve/j9tuuw0///nP8fWvfx0tLS0IBAJYsGAB/vVf/xXJZBI//vGPR7iEjk6wfoDvE1jfqBopNBtNiMfjuP3223HOOefgnHPOwcyZM7FlyxaDX0SjUdxzzz346le/ipUrV2LWrFnYvn27Vltn5dt0Op2YMmUKbrzxRlRVVRmbDTGh/OSTT2LNmjUZTrBjGePGjcNPfvITzJgxA9dddx0aGxsNbuPxePAv//IvuP766+F2uzFhwoTBFxodHR1GgslkEp2dndi+fTvWrFmD+fPnY8qUKYYXpLGxETU1Nejs7DQ6ItZoJZNJNDc3G+qyp6fHWM8RDofR3t6esS0mJQ4oNSvzUlMiQxQjuoKFAmWjSE6p66q4VWnLiKZMjLC/2T+2Foa/zjcslC2qEQDerkgkgq6uLmMKDltz43A4DFLg9/sztjjky0i3kaGEIT9/2+fzGQfKsXUjzLvGDpVkeaW2eVS9EyrfZvbK4qEEhxnBFMOKW+GaiTfx+VAoZJxpw+7zIi03NxehUAhFRUVoaWlBQ0NDxrkGLS0teOGFFzBhwgQsXrwYfr8/Iw+tra2oqalBT09Pv3LbtWsX/vSnPyE3Nxenn3463G432trasG7dOjz00EPYvn27sjyPVq+zbkc6EDLscrkM7x7fBsTjccP5I0uPbzPZbmf8e2hra8Prr7+OpUuX4oILLug3997j8WD69OlYtWoV9u7d22+3Od45xYNPx2zht8fjwaRJk/DZz34W8+bNM5xfiUQCDQ0NeOihh/DWW29JBYes/xkrsCpUp0yZgvPPPx/HH398xvtyOPpGFiorK1FWVob58+djy5YteO6553DgwAG0trYinU7jww8/xJtvvomFCxfiW9/6Fv7whz/gww8/RCwWQ35+PlasWAGn04nm5uaMkcpoNIq//vWvWLp0KVavXo17770XTU1NCAQCmDhxIiZPnow777wTzz77rNL+sfqeRhIulwvTp0/HjTfeiPHjx/fr65uamnDnnXdi586d0jUUsm+kt7cXH330EX7xi1/g5ptvxo9//GN87nOfQ09PjxF+//79ePPNN7F8+XL86Ec/wqWXXqp8jyqHGgW/348f/vCHWLhwIRYvXmyc18Y/N2vWLJxxxhm4/fbbsWfPnqw2qTha4Ha7cd111+GEE07Ak08+ib/97W/o6uoyytfpdGLTpk148803MWfOHBQVFenFa8UINkfT7XYbO0fV19fj7bffRldXF+rr65GXl4doNIp9+/bhwIED6Orq6neybzqdRjgcRlNTE1KpFDwej0FS2e5EfFiZ15fyNIuQVUAdj1U2Kp7qnHgb+Y9VJoAA86lafHhKAIijGOy33+83Dljkzz1wOByIxWLo7u42Fu8zO8zS5UdP2EGOfr8fXq834wA/1nkx8s9GNSiBJKYl/qZGFNjpocFgEH6/3xA7fKfJRE5PT48x/UeWLg/qUDpxpIA6+4USEGZijW/sxetm9V1XpLDfjEQEg0EEg0E4HA5DhDKvj9frNcTM7t27UV9fb0ybcjgc6Onpwfvvvw+Px4OGhgaccsopxlSolpYWvPTSS/jggw8QiUT62dTT04ONGzciEongjTfegN/vR21tLbZu3YqdO3f2Eyei7UcruRjqfAWDQZx99tlYuXIlysrKMrYTb2pqwssvv4y1a9caJJK3S6ddSqVS2LlzJ/72t79hxowZOP744/vVvZKSEixbtgx//vOfjYM6+XT4/8V6zf+jkJubi69//es4/fTTMXfuXJSWlma0A9FoFMcddxyeeuop3HvvvWhrayPjGctiQ+X8olBUVITKykrpKDbzaBYVFWHcuHFoaGjAnj17EI1G4XK5UFtbi+eee86YelFVVYXa2lrE43Hk5ORg5syZaG1txUMPPZTxXafTfes42KF9Z5xxBuLxuNH+/OpXv8K9996Ljo6OMfkeRivcbjfmz5+P22+/HSeffDJCoVC/76ynpwdlZWW44447sH79+gznA9/3AzSficfjuP/++/GFL3wBK1euxI033ohf/vKXxq6jyWQS9913H5YvX44zzzwTfr9f2ubLoBIZd9xxBy699FLk5ubiueeew4svvojOzk6DX02YMAHXX389LrroIpSVleGWW27B5s2bj1mx4XQ6ccopp8DhcKC7uztDFAJ9fLC6uhp1dXV4++23MX36dK14LQkNfhiNLQjv7u7GoUOHkEgkUF9fD4fDgXA4jNbWVtTX1yMajUrPCOju7jaIDNuJinnSVASXj0d2j7+vInhmoxFUvFSastELMzvNRj4oUSXLm6qDcDgcxons/ILeZDIJj8eDQCBgnI/S0tJinIEiCh+VMGC/4/E42tvb4fP5kE6nM3YWA/qEhtfrNRYdi6M8fB75NKmRAfY/Exm5ubkIBAKGmGFppNNpw2PPFqqz7ZqtbofJe3Nl9VElSKjn+Dzy+abiFuPgxZwOWP7ZdxiNRpFKpYwpbvzhjUws8kKD7TzHEI/HUVtbi5deegk7d+7ESy+9ZGxL29XVhe3bt2Pv3r3SsxO6urrwzjvvYPv27XC5XOjp6THELvUdsrLREW42+sPv9+O6667D5z//ecycOdM4IJXVvUgkgsWLF2P8+PF48skn0dDQYDwrEnxVG9vd3Y21a9di8uTJ+OY3v4mSkpJ+drBD3Xbu3Jlxz8z5oBIZwWAQN998M774xS9iwoQJZLsYCARw0kknoaKiAnl5efjxj3+MaDQqLbOxKjZ4mNnf0NCAffv2YcWKFdK2hI12RiIRfPzxx6ipqTFIWWdnJ9566y00NjZixYoV+MxnPoOTTjrJSLe+vh5/+ctf8I9//KPfupxkMonNmzfjf/7nf/Dcc89hxowZiEaj2LZtG1555RXU1taO+fIfTXA6nTj++OPx85//HCeccAL+/ve/48033zRGqh2OvkNTly5diksvvRTBYBC33XYb1q1bZ8nxkE6nUV1djW9/+9t46KGHcO211+K9997Da6+9ZvTL69atQzweRzAYxIwZM7BlyxbTd01xJh4ulws/+9nPcMUVV2Dbtm148MEH8fbbb2P37t0Zh/7l5+dj7969+NznPodPf/rTuP3223HjjTdix44dx2R9S6VSeOKJJ7Bq1SqceuqpxtEEIh9PpVJobGzMmO6sgiWhwQqeEbNUKmV4NmtqagyPQywWM6ao8J5xkVAyxRyLxTLCUR0ZIJ9eItpnZTqBlVEQWYdnNpxHiQ9V/BTR5MGIn5iGaAtPXNkJrkVFRcjNzYXL5TI8UT6fD4FAIOOAOH5qjMPh6EcSKWLBv7NIJGJ4CdmUJv5sDX60Q3yeKieVyABgbJUcCAT6HeLFwrFNB/hOju2koNuwsbhUu3OZNbyiXfw9JkrEd0mJaCp9s3JjcfMCr7293dh60OPxIBQKGYs9eRHDRi/YAjr2PNudqqenBy0tLdi7d69xAjBb7MkEnaxMYrFYxo5Uqveh+jbGIswE5WDj05/+NK688krMmzeP7ChycnJwwgkn4JprrsGRI0fw3HPP9fNkUjvBiUin02hoaMBTTz2FyspKfPnLX87YmczpdKKgoABVVVXYtWuXNO98XRf7DxFOpxNz587Fl7/8ZWMqCAV2feLEibj66qvx0ksvYd26dabpH82oqanByy+/jCVLlmD+/PnKHd/YbAZ+lJKtsWxqakJDQwNcLhfOPvts+Hw+tLS04K233sI//vEP1NbWkm1BMpnEu+++i+3bt2PcuHHGhjPxePyYJH1DicmTJ+P//b//h3nz5uFPf/oT7r//fuzfvz9jyrrH48H69euxf/9+3HLLLfjP//zPflMNqf5fRCqVwrPPPoubb74Zv/rVr3DLLbdg586dqKmpMfqf9vZ2jBs3Dqeccgq2bt2qbAtUfzPMmzcPn/3sZ+F2u/GLX/wCL774IjlS0t7ejueffx7V1dWYMGECTj31VFx66aX4/e9/b+yGdiwhlUphzZo1+NrXvoY5c+bgRz/6EX7yk5+gtbXVqBus/Xc4HNKRYBHqvSMlYESF37+ceTrY3G4evFdcrJhsFIPfPYQ9oxITKk8n9YwVQaHKt9l1vkMU06WuiXbrHO4nI6mUjSwM27KQzcVnh+uxBoW9U4/HYywIZs+L+VON+LB7bMSqq6sLsVgsY4cHVmdEss57qlUiTfyfrfVhIoMvEzY6xsfJFof6/X4EAoGMhXDi+5CVv4ocin9T0+V4UKMjsnTFv6n6JAp1qk7wToNwOIy6ujrU1dWho6PDmFbGgwlSfitRtrCevVO2s9jUqVNxyimn4KSTTkJVVZUxsiXaII5MyPJppYzGImTv0crzDLIyZXC5XDjnnHMwffp0pTfK5XLhuOOOw9SpU+H1eqX2im26mG4qlcL+/fvx17/+1fBiinGxvsMsj2YiA+gbgfvc5z6HsrIy07rC7o8fPx5XXXWVloPgaEYkEsH69evxv//7v3jttdeUi+V7e3uNUUc2uyESiaCnpweJRAIlJSU4/vjjkZOTg0AggMLCQsyYMQOTJk2SbmML9JVzV1cX9u/fj+rq6gzvM4WjsT0YDpSXl+O8885DQ0MDHnjgAezYscPon1m7Ho1GsWvXLjz11FPweDxYtGgRgsGglNcwUO15PB7HQw89hD/84Q9YtmwZ/vu//xuhUMjYUp31kWy92EDf6ze+8Q3k5+fjH//4B9atW6ecjsW23H344YfR0tKCyy+/HBMmTBhQ+mMZzc3N+P73v4+9e/fiqquuwi9/+UssXbq03wZDbD2fDixPnWIVgO8wfD4fSkpKUFZWZhzI197ebszPFIkeM5aPl12jppCYQUW8s4FqmNxsuoZoi4rkiffFER/xg+NHPGRp84SMt4UJQJ/PZ+z8wTz8bAQiHo8b93QFDyUUGNjWh/xaCXaIE/NSiSRLd/RHLCO25oSNZojlwEbMmLACrJ3aroJY1ma/+byJwpqv+2b1Xwwvs4lPh0+bgW3sIDYcrM6weiIejMbiZfF5vV6sWLECl112GWbOnGkc7Pfcc8/h2WefRU1NTT/RJQpzKxgIOT9aIBMZstEjl8tlbDVsBrfbDY/HQ4oAM/LH34/FYti6dSseeeQRlJeXY968ecb0m+rqamNazGCQRrfbjWXLlpkKF95WAFi0aJGy3T9W0NDQgGeffdY4dPe8885Dfn5+v3C9vb0ZHk6H45OR4oqKClx//fVYsmQJ2tvb0d3djVAohCVLlhjncrz44otku68jJkXY78063G43QqEQIpEIDhw4oAwrblXPIHNqst9i/9Pd3Y3/+7//w8qVK/HZz34W0WgUTz31FHJycpCbm4tUKoUtW7ZoOZXM3vdpp50Gr9eLp59+GuFwWBmWOSQ3bdqErq4uzJgxwzgz7lhEMpnEiy++CI/Hg69//eu47LLLUF5ejqeffhp33313xowQtt29GSwJDQa+EWD7YpeXlxsr0JPJpLHNZXd3d4ZXWRYfgIwOUkaY+fA8rHZSVFw6jZVuGJlIUNlBkW0xHF9GqvAigWe/2btIJpPGIW1stCGZTMLlciEej2ecdSGmR6UrIyOxWMzYNo7tRsS2t5WtjTAjMaqyZCcG8x57lodkMmkcEikeLmjFBjGMrPx5u/jfMsGhEhuUaFG9DzEt2T2e4LFtpdn7T6VSRoPL1xuxbNjflZWVuPDCC3HOOecY338ymURZWRk6OzvxzDPPoKury0ifH0kSRadZ+VsJmy0Gy3ExXOCFBrUTFNCXD35Njgpscw7qnAsxTlXdA/rm769duxaBQAAXX3wxZs6cifr6eqxZswY1NTXS7yIbyNYCqdDZ2Zl1ekcb2tvbsW7dOjQ3N+PgwYM477zzMGfOnIztbmUOB6/XixNOOAGnnnoqjhw5gp/85Cfo6elBMBjEnDlzcP311+P666/Hu+++i+bmZjJ9KwLDRnZgfSJzvLHzLXg4HH1rH0tKSgxHkw6pVKW5b98+/PCHP8TPf/5zfPnLXzZ2OPP5fHjrrbf6rdWSwUxcspEw3bqUTvftPhUMBo3lAMcyEokE1qxZg9bWVqxevRr/8R//galTp2LWrFlobm7Gxo0bkUwmMWHCBDz00EOm8VkWGszbzTcwwWAQoVDI2J0mlUohEAgYp0GKc7rZc4C8Mzfz/orhqLhFyNJXkTEqPor88Z2tajRDvM9fo65T6cquU/lj/ycSCeMsBP58CyBzzU08HkdnZ6fpQTbUOxEJMtDX6bPti9mOT2w+vszrKqbDiwZqYXU6/ckUPH5Ug2poeMKcTCZNGyRVgyarO0wMqrw/Yv0W3y1Vlrp2UeFU3xPwSR2IRCLGNIj29nbk5+dnTC9Tkc7KykpMnz49YwtBj8eDuXPnYsWKFfjwww+NAzzZP3EEit+yVCQyos3D0RmMtQ6HiQyZCEsmk1i/fr0xrU1G1pLJJN58801s2bJFawcW2XfAv7eGhgasWbMGBw4cwMyZM9HV1YW3337b8DhaIY6y+h+Px/H888/j5JNP7jeFV2Z3Op3GK6+8Mube9VAiEolg8+bNaGxsxKZNm7Bw4UJMmTIFVVVVcDqd2Lx5M7nJSyAQwLx58+BwOHDo0CE8+uijiMfjcDqdmDFjBi6++GKcfPLJ+NznPoff//73WYlCPj0b2aGpqQmvvfYajjvuOFx++eW4//77M/p7p9OJYDCIefPm4YYbbkA4HMajjz6asY5OhNiHUaMaqVTKGMW4+uqrsWTJEvT29uKdd97Bb37zG7S3t5PPUlA5nu+9915jO90NGzYYZ0HI4HK5cO6556KkpAT//Oc/0djYqEz7WADrK/bu3Yvm5mZce+21+Ld/+zeEw2GsWrUKqVQKLpdraISGjCyzSup0OhEKhQxvaElJCdra2voRFJmHliJdKjt4EiraJxMTumRFJTDE+ypPOxWXjFSa2UIRUiBzJyEKiUQCbW1tcDqdCAQCxnz7eDwOh6PvVHZ24nNbW1vGsDiVV+p/cQtY9hy/s5HH4zFIvkwYykSMWF7sN9tqubu721iv4fV6M+wSPXGJRMIYWbEKmTAV88Ds5AWS+KwqLmoNy1B2ruxdsU0ewuEw2trajDU9bLqLDGxangiPx4MlS5bg+OOPx969e43pWfw3z0aimNBgDgvqrAQzh8KxClUbw4d59tlnUVlZiSuuuAIVFRUZgri3txfNzc14++238ac//Qkff/yxlkNABt6G3t5etLa24u2338a2bdvgcrnQ0dHRz6GhIhDsvqqde/LJJ7FixQqsWrVKS2wcOXIETz31lF2fBCSTSRw5cgQNDQ1Yu3YtysvLUV5ebizuloGVOWtLgL53X19fj4cffhi33HILrrzyStx3330DEho25DAbjT18+DDuvfdefP/738cNN9yASZMm4fDhw2hra0NeXh7Ky8uNdTWnnHIK/vjHP+Kee+5Rvi/dviqRSOAvf/kLWlpacNJJJwEAPvroI6xduzYjfqvONB4PP/wwVqxYgRUrVuCWW24xzmSidkF1Op1YvHgxFi1aBKfTiSeeeAJ1dXWm6R4L6O3tRW1tLe666y5UV1dj8uTJqKqqwqc+9SlUVVXhww8/1Ion66lTvCHMa83m4ufk5BgEq6CgAMFg0DiDgyKPKo8yC8viU5FTkbSpxAaVFzEcf58XGDrlYgaZiAE+IcbiByEj3Dyh5cOJRJdtS5qTk2NMiWHhIpEIYrFYxmF2MuIijsLwZSMezsjA4uNJv6pcZGJOFFzs72QyiXA4jHQ6jVAolLH+gpFkNiSaSqWME6/58yB0vOZmooi6ruOppcqEr/di2fPPyMqTF8aqfFBxMPHGtjhmZFTl3e7u7iYXhzkcDkyePBnTp09HMBjMEBp8PWNrQtg7cjgc0oM7h4MUDjfxNCPYOhDFLL9DHcOhQ4fwwAMPoKamBkuWLEF5eTkcDgc6OzvR2NiIvXv34u2338bWrVstTSnSqefpdNrYFt3j8fRrs1gY3bSoen3gwAH89Kc/xb59+3DJJZegpKSEFBzpdN8J1XfddVfG6eQ2PkE63beQlx2yt23bNmN7cgrsDC2n04mcnJyMez09PXj55Zfx3e9+F5MmTcL48eNx8OBBst9maduwDvE7pNr/cDiMN954A6Wlpfj617+OG2+8EY2Njejo6EBubi5KSkrg8/nQ1NSEu+66Cw8//HDGuxLjdzgcxiJ/1lfwTiO+DWJ16rXXXsOmTZuMQ5t5J5aKI4j5o8K1trbiV7/6FZLJJL74xS9i0qRJ2LNnD6qrq/HCCy8YRzJ4vV6ceeaZ+OIXv4iysjL8+c9/xrvvvqt0qB1rSKf7dof9y1/+Aq/Xi4qKCixZsgSVlZU4fPiwVhyWhIasIwmHw4ZSZNtZsgWkOTk5yMnJMU4Vl4kKM+8w+19FNsTREF0yK96TiRKZbSpvOx+HKm7+t0poUKRTnMom/mZpsg4+Ho+jq6vLOC+BTSVi8/KpsuPTZPaxhoXd4+0VvZRsNEF24rCsbClQ5IKNmrDpUOzAQJ/PBwDGVqvMUx8Oh9HT06MUr2bg37WK7KsWpoqikKorVMMqpmdW982uU3E7HA6D8Ou8s7q6OrS3txujazwCgQCmTJmC0tJSYxts9o8fteBH5fh7oo0jgaEeURoMiHWJEprpdBp79uxBTU0NXnnlFWOHJnaGTltbm7E1uY4DiO1gx0QNa0dUIyHs3cqEsAoyBxIDG/Lfv38/du7ciRkzZuCEE07A/PnzEQwGAfR5VT/66CM888wz+OMf/2i6DsXGJ3VLVVaRSAS7d++G0+lEbm4uvF4vIpGI0c60t7cjHA7D7/dj5cqVeOCBBzLi1/WK27AGqixbWlrw+OOPo6OjAytXrsTSpUuRn5+PlpYWfPDBBzh48CD279+Pxx57zGjXRbB1nhMnTsQFF1yA4uJig4/09vYd/vn444/3m7qUTvetFWtpaYHf7zc2GjHrt2ScgMrfxo0bEY/HcfDgQVxzzTU499xz0dzcjJNOOgnV1dXGGWLLly/HcccdhyeeeAJ33nknjhw5onTgHatIp/vW3B44cAAHDhwwZo/oIKupU2Kn1dnZiXA4jEQiYRy4FQqFDK95KBQiyZaKxPMvWiRUQP+pUmaeZ1kaA4VuHCpSyhNMh6NvQZ24poUKy6ev8giKnmo2RUokuTLBxKfLzsFgW8My4cEOXGRz/Pn0WLxsJEFWdjqeLJXQZJ6SZDKJaDRqeN58Pl+GR56N3ogNn1navI3icyJhokSmeF2H9It/y8SHGEZMU6wzqnyI13TreENDA3bv3o1TTjkFhYWFGfecTicmT56MiooK7Nu3r5+YYPM9+Y0HZMJtJDCcnU62ackEKLUwPJ1OIxwOY8eOHeQCTDOB4XK5kJeXh+nTp2PevHkoLy83Npaor6/H9u3bsWvXLmMjCB78qCYvhszSpeyQ2ZtKpXD48GHcfffdKCoqwgknnIDFixejoKAATqcTPT09eOedd/D6668bp9/KHE82MsG+Waps2MG9bW1tKCgowMknn4w33ngDQN/76u7uxpYtW7B48WKcccYZGUKDxW2LjcEF/62JbUBLSwueeOIJbNy4EUuXLkVubi5aWlqwf/9+HDp0yNgghIrT5XKhqKgIV155JebOnYvVq1cbGwLx8U+dOhX/93//h/3792f0uczByZ+3NpA2n8rfe++9h4MHD6KxsRGVlZU466yzcOmll2ZsbNDS0oKHH34Yd9xxBw4ePJjV9K1jEWzWgw4sH9jHEyrW4ESjUTQ0NMDv96OgoMBY4Mkqlej5pgitSNj4exTMRhpY58rgXQAAcbxJREFUmIGQWcrLrJOmld+iTdToAJ8XcTG0LC7+Gf46L9Aooi2SZX7UxOv1Ii8vD/n5+cjLyzNGrdxut7FzVXd3N1pbW41pTDxhFIUj1QCqhIRZvWDh+VGaaDRqiAx+nYS4k5YZKOGgUwdZWIrsi3lj74T/xqh3KGv8ROEo2mCVSFF1QpXnSCSCF154ASeccAJOOeWUft4ONsokpsG/L5YGP+Q+kg19NgR4qNLV6fSotoGJDfF7pJ7RsYst+D399NOxdOlSzJ07F+PGjYPb7UYymURTUxO2bt2Kl156ydjWWGzfWZ8gtmlWSAULr3pHiUQCDQ0NePnll7F27VrjoNBEIpFxUKwqnaOZaGSTP779pO7V1dXhz3/+M6655hp87WtfQ2NjI3bv3o10us8junfvXixevFhr/YwN61D1NdT7TiQSOHjwIA4dOqTNcdxuNyoqKvD1r38dX/nKVxAKhbBp0yZ89NFHxu6VxcXFWLZsGb72ta8hGAzipz/9KQ4cOJDxrVPfn5X6SPWj4rWmpibccccdyMvLwwcffIDZs2cb7QCrr48++ijq6+uP6m99KKBbXlntOiV61dl++azhKCwsNKayxOPxjNNDAXknysdPKXAqY6L40SXeKluoZ8XnKc+h7G9KacueS6fTxhZyZjsXUWmycGJ5UI2P6p3wAgPoW+hbWFiIkpISFBQUIC8vz7jPbE6n08aBgLW1tRmHu6m8/VT+ZJ4NSgSpnuU7RfG0cBnM6pHV6+LZETJQ4ocvOz7v1O5bFFQCQyV+xbA6QqO3txdvvfUWHnroIfh8PpxwwgkIBAJIp/sO4dqxY4dxZoIYPxvV4AUXm343Uo3/SIkMWZqyNhHQm7dMCVWrefP5fDj11FPxla98Baeffrqx9SWPnJwcVFVVYebMmXA6nXjooYfQ3d2dkR473JVdY3VAV0zxeaHui2AOMeaBswnFJ8hWbMjagubmZvzud79DeXk5zjrrLITDYbz11luoq6tDVVUVjjvuOHR0dOD5558fMvtsyCErTysif9y4cfjmN7+Jf/3Xf8Ubb7yBLVu24M0338Rbb72FRCIBt9uNcePGYeXKlVi0aBGuvvpqJBIJ3HTTTcbheTKnmArZ1oNUKoW2tjY8/PDDhiOc9aFsgxgxjzL+ZsM6sloMzoO9hFgshsbGRjidTqRSKYTDYePAtp6enoy512IHblbZROIl27qUj8uKt5m3SUyPGm2RkXTZ37J0xTQpYiPmUdziVUaKVQ0J1UlTXnR2ze12GyIjLy/P2KaWncTNFg2zQ/OcTqfx/hl5FKHz8fLlIROIYv5UhIvywqlGGcTrKs++uEMUVT9E8WGlXPj3wYtAlfiUCVxKfKtEqewahXA4jGeeeQaJRALnn38+pk2bhmQyiZ07d+Kpp57CoUOHyLyx8mD1hVpEONSw0uGNlrR1203xGcrpoPM9zpgxA1/84hexevVq6aF/rM2YOXMmVq9ejQ0bNmDLli0ZbRZrx/gNAGQjrDrQFRyy6+I3mq0QG2ug+suBODCAvraturoat99+O7xeLz772c/inHPOweHDh1FeXg6/348nn3wSL774ok3ihghm7fVAnCjBYBDXXnstrrvuOmzYsAE/+tGP8P777/dbx9fe3o49e/Zg3LhxuOiii3Dttdfi5ZdfxtNPP62dbjb2qeoUExbUM/z/ZvHY6INu+WQ1dYpBfBGRSAS1tbXo7u421hnEYjG4XC5ykbHorZV5WHWECE+UVXZTREz10VH2ymyg/hfDiORQ1qHKhATfIYseTr7DUHk/VXmhxAcbzWACQxzydjgc8Pv9xhxttrNVa2srmbaKxKpEltXGUQwnyzNPtCiyLZYj1SnLiAplj8PhyKgHlIdZtFN1OrPqXVsRwapyVX1fYhwdHR145plnsH37dkydOhXJZBL79+/H4cOHpbt58PWaFxrHCuHLBmbfLyAn1awOsjDU2hjxWafTiWXLluGUU07ROlnc6XRiwoQJmDNnDrZs2ZKRFjttWExHFDxm7SOfH/5vWb5lbYBq5Phoh8oBxd+3gkQigT179uC2225DIpHAsmXLUFVVhcOHD2Pjxo247777jDMTbIwt5OTk4IYbbkA8Hsfvfvc7fPjhh8rNQtra2rBt2zb8y7/8C6677jo8/fTTGfepb3yg36CqH1a1D+Ioq43BQdZTp9hv/jobnmYH9LB1Gi6Xyzhpmn9O5SGmSKL4jMpGPk7RQ0/ZbkbIzASELB9UPKq0KU+3ijCLcfEdpopUy+yk8sEWgLtcLvj9fmNxNTv8z+HoW8Du8XgQi8UyPlgZKR+oR4OyU8f7KT7HiwwVKFFqxQutyjOLRzbKQdksPqvToKresUzwi9+NDtLpvoXGH3/8MXbs2GGMVPA7kakEO787nUp4DgXEMhuuNAc7HpXd/JRM9j8bVWDlT62NcTqdKC8vR1lZmbY9Xq/X2BSET59fj8OuqWw2+974eqoS6zJBr1rDcqyB+v6tlkk63bcxx44dO/C9730PF154IfLz8/Hxxx/jjTfeQGdnJ+LxOBn/sV7+w4ls3i3bUayjowNbt2413V0unf5kp7LS0lLTPn2ooOIKDkfmujG7Dg4uLG9vK3pi2f98I806K3afn2utIj88oZGRIrPOyAw6DZrMU2jm8aXyRcWr02HKrsm87MAnBMLKXGeAnoLD7vPEgx3cxjzObGcnRijYgnB2EKBqwaDONVk+ZZ5JKqyuIJA1QrL6R70TKh8ym3iIO6jJwqnsUYlKMzsocqYSGLrfjbjFqeo53gaR8A032c+m8x1omsMNvn3mT2dPp9PGgY3UM11dXQiHw/3EA4V0um9HlwMHDvS7zrbBZaOjOu9aVtd1HBisjvGCiqrjY53wDkbdFds2Vd9gFg/bXvS3v/2tUbdYmyCuXRuL5T1WoeNYk4VNpVKIRCJwuVyYPn06Dh48qGzLXC4X5s2bh3Q6jeeee25ghg8RqL5uOPufox3yDf4VEF8K9YL4U33FKRBWPcFmKlPXq60rUiiio1PZZOJCdV0k+bJtgHXyyO/0xTpz9pvvOMxIKfub/c8fbsfW3MRiMWM9BhMekUgEqVQK3d3d6OjoMN2HX8yPzKMoE5lUeJY/SgSohIEsbsoOs7hEG8R7OlClLbNPFYdMCJt9xzrfgGrEQ/ZOqTQph8VIN/JDJQZGUmSwcmWjTKytdjqdxtRI9l3zSKVS+OCDD/DBBx+YnjuRTqfR3t6O999/H1u3bpV+X7LT33XsF+uHeE6TGE5c80O1OyO9y9lowWCVAXvH8XjcmFY7ms7GOVph1TPP91lmbVNPTw/+9re/wev14ktf+hKOP/54w+EoPu/1evGZz3wGJSUlqK2txb333juobftg9RVU32Nj8JDV1CmRDIvigb0k6kAmmfdJRyCInldKvIhkWUwnmwo0EG+LaKPYAPDXVCMpVEetspMKr8oHVYYsfDweR1NTExwOB3Jzc5Gfnw+Xy2Wce+DxeJBIJBCPxxEOh1FXV4eurq5+pzpT70LlMVORYGpDAIqcm703VZnx92X1TgaK5Ot6za3cU3keqbCy74wqayvEbyDEWadzGy6Mhg5Gt15R7a6s7lDXGbHmnzXbcvSdd97Bgw8+iGAwiPnz5yM/P7/f+2MHdb388st48skn0dLSosyPzvekgk55ie3QYNmi8vyONagcEyJ02hEew7mpg41MyPgZg9W2t7u7G7fccgsKCwtx/vnnI5VK4eWXX0Y4HEZXVxc6OzsRCoWQn5+PgoIC/OpXv0JzczPuuece1NfXW7JbZp8VHiOLQ3xOdFDYGDw40hol2tnZifz8fMODzUgeRfbFFyYSaZ0GR6xgsg9Dh1gOpCOQeaRlU114G0RvmSw8H7/Ox6BLVtl12ZoNGXkWbWDvz+VyIRQKGedo+Hy+jBOBAaCjowPNzc1oa2szpk7xolPWCAwE2ZJcSvSx+PiRISujErKOmhJaqt8qyEikFcjSkolC8Te18I+qN2Z2s3D8tB1Gfoe7oVe956GwRcexMljxmcXPf+NMaPAjHSICgQBOPvlkXHjhhZg5cyaKioqMg/C6urrQ0tKC9957D48//ji2b9+ORCLRr0x5cTJQoZENzMiLDsk+FsiIqq+l+vNsHRbHQlmOJAYiNGR9TkVFBX7zm9/g9NNPR05ODiKRCOrq6lBXV4eysjJMnDgRfr8fu3fvxj/+8Q/86Ec/QiwWM01f11GSLWS8TZa2XTfN0dHRYRx5QMGS0GDDY6odcNhvimCLwkR2X+Y95sOJacoqK0XiZM/pEEkzocHHa9ZZ6XjiKI8lFQezy0w08P+z+FKpVIZ4lD3DtqJkO0yx/5PJZMaJ22xfapHEq8g7lUdZGYh54MtCRp5FsGu8TWJ948NSooS/LxMVlPCUgXrXqjKgntMBJYhk5Uc9K3MWiPVLN89i3oZbaKjsHMwOjkpTxEDT0qkLsnyKoo/6hhmcTieCwSDKysowefJkTJ48GW63G0eOHMGBAwdQW1uLrq6ufu9SJjRkJH8kBRmfxlgUF4NVd6l4dISGVYylsh1rUAlGHcjajOLiYvzgBz/A1KlTUVBQgGnTpiE3NxfxeBx1dXU4ePAgHnvsMTz22GPG4n8zZ9lw1IOBOGZs9MegCg02f1ckBwziFoli1OJ6BLZnPr9AD1ALDsNwCdHk7zFQxIqRKrMKLiNfVkgtBVknIBNX7O90Op1BBmTps3CyTp4Pz6dHTYsDPhkZYWSE/5vvcPiF/+xZK4vTKRvEdyZ7VsynSjiJaao8nGYiVhR/VH5VNonXeZvMBDYfv8pes/qm2xFlIzRUtoqQtR1DBTMCOVRCg0+bx3CJGlV+RWGtIxR1BCNVPyhhryM0si0nVfssa1PHIoZaGA2F0GAYq2U+mmHWvuu0+zK4XC7k5uZi2rRpuOiiizBp0iR0dXVhw4YNeO2119Da2ppxdsVwOnRU0HGq2dDDoAoNtsUpg7glIF9Z+K0sMxKUEHuKKOl4wKn7qgP9+HC63j+ZsJIJE8ouWdyycGZCwiwusw+X2jferHFhIoP9FtPiPaGi6FS9Q1U5qEi9+JwOAc9WWKruie9cLHuZ4LBiuxiW/0ZEYkhNbeSfV9lP2SCGU01/5OuESmjI0h1OoaHjRRuODlDHjsFOR5UW/+4oIaAbvyqcKKplNg122ei2+TbUMCOoAxE6dvkPD1TfVjZOEN4JKToqdHYfHG4Ml6PnWICZ0LC0GJzN4RUJJnXYk0h+eDBPCOW1ZfHw8VP3VV5T8XkKVGeqAhUnFT8VJy9WxLMSrJA/lSdcZgtF6mUnSlPpifngvfX8zjSiOFTFbYW8ycpbzLOV/KvECkXm+XAygcBf5wVytgSWj5fPq67Q5K/x6ZnFQ8WbjZeS+m5FO1S2DzVk34wYhv0/lB1QtmU80HRk+co2r3xdpYSErM1Wle9glbtNKgYf/Lcs1iv+nco4gI2RQzYON912kDmjeX5I/R5pjAYbjhVYFhrignDgk9GLZDJpLKTVPQGbQRy9oEiu2KCJBzBRDR7/wegIEPEDk53gzENGmnTSGchHR3mrzRpwkbTqloMYjpUL2wpTrA9i2ctGpyjBRzVwZjaqRIYoHnQaVlU5ikJXzIfsWRnJVtUDmaDRIedm5UrVa15AUgcI8qOF4vdGiTpZWcmeGW5YFV5DhZEuBxFWyoTVA75/AD45mI+fQjXcYlLEYJezFUfR0QSn02nMcKisrER5eblBMBOJBJqamnDo0CFjS1szhw8PWZtuY/Bh5uyy8r06HA4Eg0FMmTIFfr8f8Xgc3d3daG9vN7a+Z/+yscfG2IUloeHxeBAKhRAIBOD1eg2Fys5ViEajGXP0AXpaDUXIzMgZ/5uPT0WURVImpiNT7brknxJS1H3KS06RNKoMeMIn2sVfU3nORftE0i9Oo2JkkzUIlIcK6DsxPBQKGWtskslkhrAQT4LOphERhZsqbxRplJWprgiREW7xXYrXqfjFPFH55POqIzyoPOrWRSpeURiKYd1uN9xut7EQmG0SkUwm0dLSgoaGBnR3d/d7Xib6RRuHg2RQdUnnmdHaCQ6VbTpEgwmMQCCAvLw8eDweY9vrcDiMnp4eg2yKcVO/swHlXBqsuHXSpNI9mkDlze/3Y/r06Zg7dy4uu+wyfPrTn4bH40Fvby86Ozvxxhtv4P7778cHH3yA5uZmMl5Z/Tpay/FoBP/+fD4fZs6cicsvvxyTJ09Gc3Mztm7dip07d2LPnj3o7u42tsHnd6IT4xvM9z+anFrHMiwJjdLSUpSXl6OoqAher9cgYM3NzWhsbERrayt6enoA0Gs0RMJhpqZFb6+ZV8zsvor0ZVPBzewXbRHTYCM/Kjt1CaoZKVAJDoq0mm3hC/QdxjNu3Djk5+cjnU6jubkZHR0dSKfTSCQSGe9N9ISLcVMk08xjLisL0U7+bxnhFYWUmQChysyqfWbXrZ4VwkSRrE6JcVHvxywfhYWFmDJlCpYsWYKzzjoLs2bNQigUQiwWw/vvv4/nnnsO69evR3V1NWKxWIbdlODm0xsJsmb2XsdC5zQQG3XaYdWzLpcLPp8PkyZNwoIFC5Cbm4vOzk60traiuroa9fX12ifEW7VbZe9QvDeVuBjKdEcaVJ5KS0tx/fXX4wtf+ALi8TgOHDiA7u5uOJ1OhEIhnHXWWVi2bBl+/OMf44knnkBLS4upc0GWlo2hwWCVNWsHSkpKsHr1apx33nkoKipCOp3G9OnTsXv3brz66qv46KOP0NbWBgAZhzkPFmzROnphSWgcf/zxmDRpEpLJJGKxmDG6UVxcjNLSUuzfvx9HjhxBT08PSWIZAZIRJ4r8ySDzXItkVkzDKsyInQjKq07FJZI7M9Ktss/q8KZoDy/o+Dyo8sQ3LmeddRaCwSDeeecdfPzxxwa5YNvmMtGpMwrF2zhQYUnlJRsxkI0AVdU/sQ7J8sHXZVUcYrpW6wRgvsCbxXn66afjuuuuw4knnohAIJCRTlVVFVatWoVHHnkEd999N3bu3EnuNmL2PocDohNjpO0ZSWQjqBwOh3GSeH5+PpYsWYJrr70W06dPx549e7Bx40a89957xrQJWRpWCLrMATMU0Pl+VCL1aMeECRNw1llnYd++fdi4cSMeeeQRbN++HW63G3PmzDHaiB/84AeIx+N49NFHEYlEsha1NoYPuu0zaz/ZNLopU6bg6quvRl5eHt59913E43GMHz8eJ510EkKhEDo6OhAOhxGPx41RT7M0rNhs15/RC0tCY9KkSSgtLUVDQwOcTicCgQByc3MRCAQwbtw4BAIBJBIJVFdXG+s12Hx9BplAYPdk4MmOjJyZkUSRUPPXdMjoQAknD2p9ie6zPFh+rHaMOo2JajSD/Z40aRKWLVuGyZMnY9KkSXC5XMbQKJufzexTLZI2S4uCioCLwkYUUSoxIBOJYt7NhLDMVtW75e3mhblOnRe/EdXGAxRZEwUeld6FF16IxYsXw+/3k3nIz8/HNddcg9bWVtx9992ora3VKh/ZtcGGqi0aSJy6to9kh2hFkOvGx0Y0pk6dirlz5yIUCqGoqAhVVVVwu93YuXMnurq6MkY4zRwOKtuHQ2BQbbEZjlaSI6sXkUgEGzduxP33348NGzYYbXtvby/Wrl2Ld955BytXrsQDDzyAW2+9FXv37sW6devINI7Wshut0G3zKGcYFZfb7Ybf78fEiRMxbtw4dHd347LLLkNPTw9OOeUU/OEPf8CKFSuwb98+7N27F52dnYN+Urxdh0Y3+s+xUAX+/xf95uTkICcnB16vF8lkEjk5OSguLkZ5eTnKy8vh9/szdh5g4BcFykg/e0ZG5CgSmU6n+031kXVkVrzbvC2qMpHFr0rDbIEky5OOiFCRdp1yoCASY5HQsvvxeBxtbW0IhUI47bTTcMopp6CwsJAkExRZoMqL/6cDFWkWf/P28weS6ZSH7t9UPmUEhiK7vMDQFWRi+m63O0NcifZQ4NPjy4gfnWRrcmT2AX3zty+44AKccMIJ5PdBvf+R6igGI10rImMwwmQDK04L3fhYWHZgJ6vLTqcT5eXlOOWUUzB79mwEg8F+7QkPMwfTUIsM3jPLNkIYqvcwliC2Hzyam5vx4osvYufOnQCQUXbpdBqRSARvv/02/vSnP6GsrAy//OUvySmdNoYXZs4GnT6aD+9yueD1eo1/AIwNgVKpFDZu3IiXX34ZJSUlWLJkibGOJ9vRDPu7HJuw9OWzubculwuhUAgejwfhcNhY2OPxeFBcXIxAIEASDHE0QgS7R027Yvf5OKj4dL1P2RBa3g7eXlkDyn+4FBlUec5Yx6drH+Up5D3aIoGkhB4fl8zzyPLL8lxTU4MjR45g165dqKurM7Y/pp4T/2Z5lOXfaqOiKiuZqOXzJIuTPa8CtfiZWmRvZpc4EsFvISzGpfP+RLtUZUSVP/8+deMBgFmzZhlebVlax5IXSkWWRcfKYHamVr+jbEYZ4vE46uvrUVtb28/hw4hINoLSzGmkeka8JvvH2jJRZFix91iqxwypVAqxWAw5OTkIBALw+XzweDwZ5dje3o6//vWvcDqdKC4uzjiDy8bwQ9YOqPpGnTjZs7FYDF1dXXC73ViwYAHy8/NRWlqKXbt2weFwICcnR1oHdBx9Ku5oY3TD0tSpVCqFtrY25Ofno6ioCD6fD36/H729vcb8y2AwiNzcXDQ2NhrPqYiNuG5D7FzEysWTe5Fs8QRa1qHzaet0wLxdVOcjeoFl+ZWlx9ssS9/MC8HbxcfHE13eNsobb0aEGPhOOZ1Oo7W1FR999BEaGxsRCASwc+dO1NfXI5FIGM/KhklVjQZlp8x2s/jEMhbfl0j0deOj4uBFFt84iu+IB7VQVlXfxPui7el02lgbwR+wqCoX0S5xv3O2s1gsFkMikTAEiKxush3qPB4P4vF4xj0xrZHoPHQcFIPZsanq0lBBrJs6AlM3XhYn807u2LEDr7/+ukE8o9EoGhsbEY/HEQ6HM9LREQ5mNovhzNpIBkpMy75TEccayVH1PS6XC0VFRRg/fjw6OzuRSCQQi8WMsmT1gm0I4XQ6jS1PbQwvVAJjIEin08YW1pFIBG1tbdi7dy9mzZqFO++8E08++SRmz56NFStWoKOjA1u2bEE4HCYdVaq2VrctsDF6YUlouN1u5OTkwO/3w+v1wu12w+v1oq2tDS6XyxAdPBlSeeVZRRWvsWdFFasimTodDkWqqK1LZR5kKj6daxR0OjbKFvF5nWcogcXeC+Uxp+Lmw7LfbFvTd99914izs7MT7e3tGWdpUPaJ9YISAtR7p66pSLROeYnxiAKWT1f8LUIMp7KTIoKiUNGBWd6o/JjFLfsGWltbEY/H+y0Ep0DVrdEEnXIbalD1fjDA1y3qXQ4kPb5t9ng88Hg8aG1txXPPPYfdu3cjFAqhra0NBw8exKFDhxCJRDLSVn1LVgQob4dZOJUoF+3S/daPBcjyn5ubiwULFiASiWDHjh1IJpPG7mL8jAS+f7dHNIYfZnzISnhVHDk5OUin09i8eTNcLhcmTZqE733ve3C5XOjs7MSGDRvwxBNPGNzArB3g7TnWv8GjAZaERldXF8rKyuB0OtHY2IhQKITc3FzE43F4PB7D49nd3Q0gsxGnOlNRSACZi6T5cOKzlMeYItQy8ioSbh2IaQ4VzLyrfH5lYodqMPjrYicti18sU3bd4/EgNzcX6XQaLS0tiMfjRsfC9syXCUQzj6aOuDITi2JdoeqUrJx0GltVejrQEUGq+mbWSKvCm4VVfW+bNm3CsmXLkJubm7EOREQikTD2TRcxmsWHiOHwpg123LpOl4GmwZxLRUVFyMnJwcGDB7Fjxw5jvnY8HkdjY6OxfkPHZl37qLaeEgoyJ4rYfuima6MPoVAIy5Ytw/jx4/HBBx9g//79/Qgk2+oWgOH1tjE6oNP/6nyDLpcLOTk5mDFjBmbPno2cnBw0NTWhoaEBPp8PpaWlaG1txRNPPIHt27cjGo1mOKPFNK3YaWPswJLQqKurQ25uruHJZiSdbWMaDofR2NiIrq4uo9Gh5ogDmVNqKFLLPyMjwwD6xcFAbaXLIAoU/rr4jBinSPLT6bS2WKHIocrrz98XR3bEzpItwJIRUxn5EAWHSrSxKVNutxvFxcUoLi42zs1g3iz2zvn3ohJFvB2qcDJiofJoUiMFZnWML0tZXOKzKlv5vFH5MxtlEMWaqt6oBKpKjMjyRonMd999F2VlZbjsssswdepUeDyefnb39vZi7969OHLkCCk0RgN0vGlWMFDhOdSgSDgFne/U6XQaay8qKipw/PHHAwB27tyJxsZGYwoNv0hctIOPT2arLH3qOZXzQpb+YNeBYwnxeBzRaBSnn346fvrTn+L73/8+Dh48iM7OTqTTaXi9XlRWVuKiiy5CPB7H3r17M7a6tjG0yMaZw/pSxp34zVKosGzHuZkzZ+Kaa67B8uXLkZubi7a2Nrz22mt4+OGHUVZWhlQqhW3bthnHHpj1W8Ph3LExvLAkNHbu3IloNIpx48ahuLgYra2t8Pl8SKfT6O7uRn19PXbu3Enul02RZAaREPLhRfBzx0WSpkPKRI+4SKZ4qLzdvNeGf17Mn8xGETISzOdbtJuPS3YSM/stnsjO/vG7gzHRxDcwfBkxoeHxeHDCCSfglFNOwdtvv4133nkHiUTCeE4c0aDKlqXJLx6lxBT1jBnMGij+3bED7ng7qOl8IsHR9ciIYfm6K66DkL1bVZ7YO+PDmJFFWXyyZ3ib9uzZg1//+tf4+OOPcd1112HBggXIy8vLWMNRX1+PX//611i3bp2lchpLMMsH1a7ovBcxjsHobKm2T0yH/84pMkDZlp+fj1NPPRVXXnklxo8fjzVr1uC3v/0tjhw5Yml6hO59SmSYiRibrAwNDh48iHvuuQff+c53sHLlSpx00kl45pln8OCDD6KrqwvHH388/uu//gszZ87E5s2bce211/Y7Hd7G8EPVxrNNfoqKiuByuRAOh9HS0tLvFG8mRjweD4LBIEpLS7F8+XI4HA7s3LkTlZWVOPHEE/HPf/4Tu3fvBgA0NjZmHOKs+i7tb/bogyWh0dnZaewuxE6E9vl8iMViaG9vR2NjIzo6Ovp5sURyRpF8SgwwiJ57Pk4qfh4y77IoVmTEi/KYi7s5UWnowMwTT9kligWZd5wPw37zBNvh6NsC1efzGYfnsOlP1Htg5c4aGObJYN7rcDjc72A+mSBUbe1LCUYr5afjDRXTUW21ZzaSwBN96jkxDurEdbHuy87PkOWDike0RwWZaOZ/s3Si0SiSyST+8Y9/4M0338QFF1yASy65BFOmTEE8Hserr76Kxx9/HFu3bkV3d7eyfuraN5TQrS8DwUDiGQhZFuuPrH10u90oKCgwTnjv6Ogwpjio7PJ6vZgxYwbmzZsHn8+Hc845B4cOHcKf//xndHV1aTmOeFtVaanC6paPrC6OdB0ciwiHw3j66aexY8cOfP/738dJJ52EK6+8El/60pcA9JVpNBrFpk2bcPXVV6O+vt4u52GElW+PtQGFhYVYuXIlbrvtNuTn5+O1117D97//fezbt48cmXa5XCgtLcWECRPgcDiwZs0a3Hzzzbjwwgtxxx134NJLL8WvfvUrtLS0IBaLmY6Q6NhqY2zC8q5TkUgEiUQCLS0t8Pv9xrShZDJpVEbZ9rQMKo8U9YFQhJW/rxImYrqqkQPKo65L1GTCw0xMyPJIEVszAWLFI+hwOJCXl4dp06bB7Xajq6sLtbW16OjoMDxPok38CMihQ4fQ3t6OyZMnY9y4caitre0nbNiUOt5e6rwTGQGVvW/VdR2yTQlf/mwIPu/iO1G9azP7+fTF0QyZvbJ3albHZdep+qlD3Pj3xzqMuro63HfffXjkkUcQDAaN3efi8bjU2WCWr9ECK0R0MD3nojDIRqRQ7QhlH5sGOX36dFxxxRVYtmwZqqur8de//hVvvfWWIRZE+5xOJ3w+n7GrGPvuCgsLMXv2bEyYMAG7d+/W8mDrlt1ARbTudRt66O3tRXd3N959911cdtllOOmkk3Drrbdi5syZxqYgzz77LG677Ta0tbXZ06ZGALrfldvtRklJCc455xzcddddAPrW1JxxxhkIBoP45je/iX379vVb5J9KpZCXl4f58+cjkUggNzcXkUgEGzZsQDgcxvHHHw+/34+enh6ttsD+Jo9eWBIarCIkEgljTQZ/jx96F2F2EqTOaISYFkXCqU46m46M8jzrPqtLFEUSL8Yp+9tMdFHlwodnhy7OmDEDkydPRjweN056jkQiSKVSGWKD/fN4PPD7/cjPz0deXh7cbjdisZixwxRLlxFRRqjFPPDvT7RfvE7lUcyfTBSqRgL4e/zaG369jaz+yOrfYBBSmdilbJHZKQvLC0eKgKrEq6zOpVIphMNh9PT0GNdUAn2kOhNd50I2oMpysEZDsi0vs/aP1d8JEybgpptuwsUXX4zc3FykUilMmTIFP/zhD7Fu3TqSIDqdTuTl5WHChAnGKIjH40FHRwfq6uoMgaIrlFR5VNX7gcRrY2Bg7Xxvby96enqwbt06nHHGGcZZGqlUCvF4PGO6jI3RB6fTidzcXJx++un43//9X7S3t+P+++/Hli1bcOGFF+Kiiy7CrbfeiquvvprcmjgQCGDhwoXGmWplZWX44he/iPz8fGO9LptWrYJdR45uWBIaPFFhRJRfhKxL8sUOWaej50kXvzWrLF5Z2jJRICP2ZmRTlo4KIgEXr1O2mHXaFHmkxInL5YLL5cKECRNQXl5uEI5gMIiCggIEg0HEYjGDRDIw72dZWRmmTZuG3NxcbN++HYcOHUJjYyNcLlfGtDZeqOkIOJXHkoWlzgXhw8mum40E8ddV5c9sUAk9yg7quigiZKM6LKz4HBWWj5MSQ6LIUMUn5kkl5kZzJ6HrKJBhOEjtYIkSq2DTnU499VTk5OQA6KvfCxcuxLx58/D++++js7Oz33N+vx9VVVVYtmwZZs2ahXQ6jZqaGrz44ot48cUX0dzcnEEudESeDKO5bh3r4NuVVCqFZDJpnJshYqTquA01PB4PjjvuONxwww2IxWL4wx/+gDvvvBO9vb2or6/HZz7zGZx00knIzc1FS0uL8Rwbwfza176GGTNmIJlMYu7cufjZz36GM888E16vF++88470FHAbxxYsCw2eDLPhM4q8W5l6APTf0UllA4NOBVaNNvCQkXTqb1EQiKRRzINstIXyMIvpiHFQnnTKTip/bG1GYWEhKioqjO1J2ZQ3trirvb2dfD4/Px+LFi3CpZdeCoejb6vTjo4OOBwOQ4iYHcjEjxiIwlFnJMPsXjaedEqoiEKS/ebfOyWmZHWBetcymL1TK3Hwv9nCdz7f/LsQR3Oob3oghGG4SeNAyY3MXrN4RwupMhspqKqqwurVq1FVVZXRvvh8PpSUlCAUCvUTGg6HA8XFxVi9ejW+9KUvoaSkBLFYDDU1NWhoaEB7e7sxbY5yPFFtpo1jA9k65mwMDdjI5JIlS7Bw4UJ8/PHHeOihh5BIJOBwOBCNRhGJROD3+zFx4sR+QqO0tBSf+tSnkEgk8Ne//hVtbW1Yvnw5vF4vuru70dXVZfAC/jkdB6CNowuWp05RREo1aiESNqqSmREn6r7Kc50N2RRtNbNLtShd3O5WRqJFccPHqypXMe8ygcOHZ//cbjfGjx+P0tJSxONxY69ztl0hEx+ikHI6nSgsLMS8efOwdOlSFBUVoby8HMlkEq2trejq6tLyvIvkPZt3byZGGWmWxWPVyy0Tq1SclOjgnxHjEBd+y2wQw8jiVpWNWVqq8pF9W5SNFMZCR6J6X0ORxkjC7XZj6dKlmDx5cgYRAPrqSUlJiTHKwcDaj1AohIqKCpSUlBjCZNq0aZg7dy5eeukl6cFs4jdlezqPPYyGum+jD06nE1VVVbjiiivQ09OD9957D62trUb/ydbkso1fPvroI+NZr9eLBQsWICcnB5s3b8aNN96IdDqN6dOnY+PGjQgEAigsLEQoFDIcnCqOYuPohtM8iBoqYsHvMiDzGrP/RQ+YzLMq3te5ruthFL1uMpFklqZKeKmeZ3mVHWgjy4doNwXmWcjLy0N5ebmxmNPv98Pn8xl74/O7SzH7GCFg++KHw2Gk02ksXLgQS5YsQXFxsUEcxK1t+XyoNgmQvTezsqXKhRfAsnonXpeVr/h+KHFEnYRLESn+vmgPHzd1BgxVF0VhJysPMS6qvujUIRlEO8wE02iEFRt1HBajGQ5H39qMz372s5g6dSqZd4/H00+AMFFRUFCQIUIcDgf8fj9mzpyJuXPnwuv1KtPmt9C2Mfphtf+0MTYQCoVwwgknYOHChTh8+DB+85vfGFvZsm8zHo/D5XKhrKws41mXy4WKigrE4/GMk+EPHTqEZ555xhAiwWAQ8Xhc6lSw24BjA5aFBjWFQiRqInE2EwoqkiNuhaoihWIcYvpmDSHltZX9ptLjr8kIl0hSxXLTESRmoMqJ/a6oqMCECRPg9/sBfCIoXC6XMYVKHA0AYCz6A4CmpiZjwThbCMx2HRMJhDgqwuKnRoTM8sL/zZeLmI5KMOh2hmbhZelR6Zu9V0rYWkW2DTYlNrKtZ+J7per7aIWV74uFp36PFKzUG5fLhTPOOAMzZ87sJyaAvvzEYjEkk8l+9SMej6O6uprcrpQX97K2komMo3E0Q9UvHSuQ5d/q92VjaOFwODB16lR87WtfQyQSwYcffphxujvbxt7v9yOdTmdsb8u+49raWkQiEUyaNMm4l06nceTIEaTTacTjcdTU1CAajRoH+vKw68Oxg6wWg/O/ZUSC3aNIqxiO/81PO6K2R5WRIYowqdLShZg/UWiJ5FBGQCgyquvFt5oPGfnOycnJOM25oKDA6PRZWLaLlGhzKpVCd3c3qqur0drais2bN6O2thYvv/wyjhw5gs7OTiQSCemhPGJdkZWZVajqA/9uVGJAJ30+Htmp4TokQ3wnqhEbMQ983ZPVf5UtstEds3yJ12TXWXz8AYjD0ZlYFUi6cQ7kOxyIaMxGnKnaYhElJSW4+OKLMWnSJKlzp62tzRi5ZGBCsre3F83NzWhtbUVxcTGAvvNVWltb0dzc3O/8FD5fR6vIYDhWyRPFDWyMXrDpjgsWLMDmzZtx8803G2sz2OyGnJwcFBcXo62tDXv27Mnoj/Ly8lBSUoJEIoFZs2Zh5syZaGtrw7/8y7/gjDPOQEtLC1588UXU19dnrNkairbaxuhH1kJD9FDwC01VDQ3l7eXBTz0RzzYQ46F2CBI7eGoEwcy7TMVBhaXSVBEMSoRQZFIkyKqPksqfmBbQRxLGjx9vbEvr9/vh8XjQ2dlpjEj09vZm7BoixtHZ2Ynnn38eW7duRWFhIZqamlBXV4eOjg5jW1yVjSoBMlBk03BRI2tmZF7VWMrIP9UBU/WMhaXqHiU2rIB/BzJySV0TF+rrivjhIBuDJVZV8Q8kXit1W1VXrNii017Mnj0bZWVl0rNjotEompubjRFMht7eXiSTSTQ3N+PFF19EZWUl/uVf/gXxeBw7d+7EunXrsH//fumOeul0+qje7vRozJeq/rJ5/FRfNRKE0iax+pg8eTKuueYaJJNJNDY2or29PaNvcblcyM3NhcfjQSKRME74Bvraga6uLmzfvh1r167F6tWrsXnzZjgcDoTDYXz00Ud45ZVX8Pjjj6OnpydjloP9bo5NZL0YXHUf6E8CqAXSFKgOlydl4iJlMX1V3Gbp8sRTFFVmtoo7EKkIq8xmMa8UERbzL8YvEzPs5E82JMoEBTsLIxKJoKenJ+NEYDHtRCKBmpoaNDU1GbawIVFxyhQlQlXEXYdUyUh4Nt5fMxIovheWDz5d6jclnKk6LUuPEgTib3GHNln5ienwAsUsvFgHdcpKFMtD2anoCnEeOuUv3s9GbOiUlRhO5kwR/zZrS8zaHIfDgTPOOAOVlZXScI2Njaiuru4nNFg7l0qlsGPHDtx+++24++67EQqFEAgE0N7ejoaGBsMrSn0LNtEYO1DVY/aOxV3sRgq2yLCG0tJSnHbaacbIA99PsXO2Fi9ejHQ6jZ6eHjQ3N2eUbXd3Nz744AP4fD4UFhZi8eLF6O3txd69e7Fp0yY88cQTGaMZPOx3dOzBktAAMufZMsi8rHyF4g91o+KUPSdelz3PE0PeC8sIsQwi0aX+lqVt5jkUnxefpQ6HE3+rnqGECJWWw9F32F5ubi4cjr4zUDo7O+F0OtHT04NEIoF4PI6WlpaMkQmKiKTTaWMLW3ZPNU1GJMuycjQTdmbXxLyL5cSHU9VBagRBlh8qPTFuVUcsimmzezISKfvbzHbxnqwuqkSD7rsaKpg5AagwMrJvJf5sYCVdWdoDFRsul8s4B4cql2Qyiddeew1bt27NmJcNfCIU0uk0Ojs7jelSOTk5cDqdiEQiiMVicLlcpOPhaJ4ydayB8QD2W3SUAMPXDtgiwxqY4zEQCGD//v145ZVXAHwyNdLtdqOqqgrXXnst2tvbcffdd/fbtp5Nr9y4cSPa29uxYMECjBs3Dg0NDdi2bRv27duHeDxuiwwbACwKDXF7TGrqEgPvCaV20ZE1SGInqfKm8jbIOlixAaS8xDL7xbTEv/kwMo89FRd/j/Iaqzz8qusqDzbQd6J7IpEwRi9cLhfC4TAikQhaWlrQ1NRkkAsVeRXfJ9XJUBhII2NGzFTvVVVOqtETld0ikRXroepZsR6KdojiRCYCZHGZfQsUxHB8OqIgzrbMhgoDETuycs0WOvEMVNwMRGywTRyoetfb24v3338fTz31FA4ePCgt13Q6bZz8nEwm0dPTA4/HY+xax29nyZ6xRcbYhayusWk1I0kebZGRHdgsBH66tMvlgs/nQ1VVFa677joUFxdjy5YtuPfee8lp0WwK1e7du9HU1ITc3FwAQG1tLcLhsL3424YBS7tOsTm9FEkSyRUvMKgFgHxnKF63ooJluxeJ8fCdqazTk3m7qfs6HxGzwYoA4a9beV4ko2JHn0wm0dHRgd7eXnR2diKZTKKtrQ3d3d1oa2vDkSNHjKkSYvqMOPDp8P9UJJ8SkdQ9q8KPui+OslFlRl2jylscReCJGxW3lXzLrlPlSL1LivTz1/j3JdpEfXfUdyLmkz3jcrkGjZQPBLJvYyDxDXU8Zu3LYKTBh6HCMTHR1NSUEVdvby82bdqEX/7yl3jzzTf7jWZQcVPtPxMy7LrKFhujG6r35nK54PV6pVOiR9rRYEOOdDqNcDiMw4cPIycnB/PmzTO2u1+6dCnuu+8+XH755Thw4AAuueSSflMoWRzM4dDd3Y1wOIxkMonOzk50d3cjmUyOQM5sjFZYGtFwuVwZyla1WJu/riJhMrJM/S2LnwLltaZGNfiwovdYBO+15uM1I8kq+8088aJdOt5k8Vmn04lYLIbq6moUFhbC4/EYh/G0tLSgrq4OnZ2dhqdTzCObBqHjJVeVjUo0ifk0Ky8VZOFktsu28zXbMU1MU0yLSp8CJXjEuGV5osJS4oW/R9V7mY3iM26329gz/WiDSkBaITOydk8Mo6oPVHpm7aHZfYY//OEPOO6443DppZciJycHXV1dWLNmDe655x5s3rwZ0WjUNB1+mgUbyeDFKABju2t7NOPoBHM6jIS4YLBFRnb4+OOPceONN+LBBx/EI488gs7OTrhcLuTn58PhcGDnzp0499xzja1qKTDnXm9vL9xut3FmhsfjMUa7xHO1bBybcKQ1akBnZyfy8/ORl5dn7DzCe5BlZMcsakpYUPENdHhURpLNbFKRMp4kULvzMHJIzdGn7JClK+YD+GQqixlZYc+wDsHpdCI/Px8FBQVwOp3o6upCR0dHxvkXvBgQ88rIBPNk6BAimYASF8+LZUpBJszE90sRajENqoOkSLmq7pnVE538UOnyoASzKg7q21PFL6YlyxMr19zcXMRisX5zdo/GjkTlIMk2DjEeWR3RbQN1xCeFgoICzJ49G0VFRThy5AgOHTqE7u5urQXbrC1xu93w+XwIBAJwOp2IRqOIRqP9trm2cfSBEctIJGLwgYH20zaGF6FQCOeeey4eeugh45DNSCSCF198EVdffTU5/YkH6x/ZQcClpaWIxWJob29Hd3f3iE+rszF86OjoQF5envS+JaFRWFiIWCxmkA5qwZ8OweHn+MuSN/MGigvSxfDUPdWIicq7KxIu8TmeiKnyohJgqtER2TOU150PK055Ytf4PPHiQuW5YOSCT5u/LysflcjT9cCKdlDXeVBCzEzkUXnRTV9mi4yoUqLILA5ZJ66qcyqRbCZqxXrEbM3LyzM2ENCxYyDQFUhDhcEWGrJypqAjKGRx6Y4giELaav7Y83y6NrE4NuDxeBAIBNDT05MxEg4M3bdqtb+wYY5AIICZM2fi1FNPRU9PD1555RVjtyhd8COcjBfao5jHFsyEhqWpU7xCtSISKM+oDOJIAbtGCQlVJymzgSdNZqSSbzxV5J8/WJDKp0rgUDbrevipNKk8s98Oh8PYjlYkCOJzKqLNGhNx6pz4vxnMwqk8/pR9fLnrEjUxbhU5p8DKjglf1TsTBRgft2paHgsvE7q6nTxVh1U28nlk147lDmQkiY6ZyOW/Zyt2Wv1mxWdt4nf0Q+acMZs6Pdiw69rgIxqNYuvWrdi2bVvWAiGdThu8wn5HNihktb2tuNhPNrIgkiD+PuVxZRVVtsBbtIMi1uLogewZ8XkdgkaFoUYpVF58HcIgpikjzRQpVq0rEOMSiSwfF5Vf/h4v2FTQKQMdYqQi02b1i7KJ/83XX356GHuHsgaUlTc1MiF7RzojMnwcVP2ibBC/QTMhojOyQ+WHHeyoY/9AoOPBHwlYIfEDGZGhnqW+Uape6XqWzdqi4YTtrR5b6O3tzZiDP5QY6pGSYxms7xoMB5L9fmzIYEloUPPqxcPYqDAieGLGd54ycm7miaX+pkSOGVkVRx1kyMZbKCOtZl5lFeEQIe5rThEJWdqUB52/ZxYPe+8ul0uaNgUzwUe9PxVpFvMu1i9K9FBlQL0DmZ06owoye8R8UvVQ9k7YNeqwSFW6up5oKgwvNIZLYIy2DkxHQFgNo5Oeql5ZTVv3vg0bFNLpNDkHf6jqk11PbdgYu8hKaACZYoGJDX7NgBkpFj1xojiQkUgVqEPaZJ0z9besg5aRZpmYkpEliihSp2aLZJp5rQcCNjWHCQFdmJFsMZzM220mnvh4xKldMhFhZjNF5FXhRbvNBC0flg/PT6MShUI24ksGHZLJx8NvWKASUZQ9YpxD3fEf7cRiICMJZt+RWP9HQ1ma1enRYKMNGrI+dKhHM6w4RWzYsDF6YVloyDz/IrF3OBwZOxOZdX5mIwxUGP46C8+LHZ78qrzgYvwUyZV52mUdqBkhFr3zZkSYIob8KIkYjv1PrWWRCTerxMSsI9Al1qI91IF1oo2y32J9M7OFqssy2/h6JtZpSiRT9V6VpkpUyuqjmC/ZiAkjBuK3YVYXRAz1Go2xRCoGMpqhisuqCKHqgPg9jDRhG0vv1YY5qPo02O/YrjM2bBwdsLxGQ7dx4Qku7+GVCQqepFGixKzz5Yk3RU7FtM1ONZc9J6Yn8+4Ptveask1ciMxIquodmc2vVwkfKl5V+cjioeKSQawDqrQA+r2aCU5VemL8ZumL8cjipCAb9bEKlQCjbJZ5yFkdkx3KdbRD9m1Q96xgIO822/RGi+CwcfTArkc2bNjQgSWhofLgUYtRVVNXZKSKIpbiGRUM1K5UKmIrjiKIdlA2qECNMoi2y56jBAEVTjUSRJWVSviIi4ZV6esKJf4diGlSBJ+C2agPFVbmAVaVu45Ypf6mnqNEqNmICPtbZaO4zkZmp5kQpEZiZPkXbZOV53ATZMqGsQKr9lqtm9SzVh0fKoFMhTXLk078No4e2O/Xhg0bOshq6hTlFeY7MpFYysix7L5IxMX/GagwVokmRYJF22REk+98zcicmR0UqPNGVB53s9EDsVx0T7/m09E5aM+KgDJLk4pPZ2SAskcmzMzqjGyxNZ+OatROB7JvKVtQ9ZO/bmaHGA91bzigEtpDldZA0xgsG3XEhdmz1PtTOWWyFTyquGxCasOGDRvHLixPnQLQb6GrSNZlYoGaH64aFVB1ajxJ5J+ThTe7Z0bWVd5C/n9+OhMFiuTKvPRiHhlYeetM/xJ3BBPJsew56hr/DmXh+TC6Akg2uqMabZLdF+OmhJksPrNpZyJ5U4ll/rds1Ed8jv9bRg7FOi/+Vp2JIo5oqTBSoxejAbJ6ZSZKdWGFrFuJj/reZCJRR2yo2juVHVQaZm25DRs2bNg4OpGV0KBEAQNPZnjSrSJsut5t6lAzMX0KVAeo25lSpFLMA/tbxwsvG9HhhZvMFj6sjAhROwuJcVGEREZO+GeoszNEUQH0P1dFtEXXS60i/exvnbogy7cs/zrg67RKSInvQpZ3akRElhdeZIr1TrRFXFgvxsWuq+ou5TgYCmRLtIdzJGK4SLEVxwnloBB/DyS9oSxXW2TYsGHDxtGNrA7skxERgCYpKs+7SLzMvIniNfGeDtGkbB8MD64qHj4dHU+0yvttdiifmKbMHtFuleAR41ZdE9OQef5FO3ibVfmQ1T+KcMtGGvi4zIQzJQqpa2K8MnspyESUasSLh6544+/L8sALe0oA6RJYKwJgIN/fsUZWVe2dWX2m6qmZE4VKh7KJx7E8InYsYLD6TBs2bBz9GPCuU9Q1p9OZsZWmLLxZR2Y2NcaMcFMkTce7bOap1umAVYJHZgNFAnWIo469ItmQkXfVKIIZ2TDreKh6Ip69opNP6jRu3bybkS7VNdGrb1a3zASzSrCLdYUafeBFmWpURZcQyMRaNoRCjMeKh143XmB0iozBGmFRYaAjFap2XKxrVuKwYcOGDRs2eGQ1dYqHSE5E4qMi3ID8wDr+t1kcg9GxU52szKssjgBQZWCWhhWSqhJJVvOo8v6LkBFZGXk1IyaUoNMhMrL6RZFvWX4okSeGlYWh4jKLQ5ZnWd6o+HTE00BFBGWbuOnDQIQAZTMVfjjI+XBDd+SHgRLOVp63Uhd07lP2WxE4tsf76IX9bm3YsKGLrEY0BkJyqWu8pxqQb5nKwBNgGUQSKiPGfFiK/PNhZd5mMyFEddYqoqnywItp6hBbimSK8crCU6JIlld2locZedYhYGJe+b918shfkxFsh4PeUcrpdCpHJMR4RFtkaZnlVxRgVLx8OHHjAZWYkIkjcWMHszLNFjoiY6DxUfEPlXDRjXsgYoM9z64PNwaa5kiXvQ0bNmzYGHkMeERD5T2WDcWL92TX+b95qEiyzAbVfdmuWRTJY/+rvMriPSpvVr3msvuUSKDAwqq289V5X1R+ZYKNiluMQxSVIuFWQVb3ZHVIV6DqnPshEkJ+LQOfpoysq0Qt9Tz1js0El9moh3imio4YN4NueJmQlT2XDbEcajJKfaNmdXK4cDQT8aM5bzZs2LBxtCHrEQ2RAFEk04rXj8UtpkWFAzK3ahWJiugFp9KjwlBCgHm42X0Z4dMZkeBtF/NjRtBkhH8g3lKde2ZCDei/Gxi7rzpbQqfsKEI/GB52MzEis5OqbyIook/FbSZ2RDtV34JKeKjIsJVvVfU96cCsrRgLUAnGoUI237fZe7RhYzhhj0DZsHFsw/y0Ng4UuWcw69xEEUDFIYIRG5Hg8Gmx6TpifCrPPkV4ZCRSXHCu431V5UfMm+w+5RHXPQNBla4Z4bcyyiIrS3aP2SsbDWHPUzb19vZmvFsxPeq6aA+LhxpBsiK4qLpuFpes3oig6h6DuE0wT/Z1vyOz90nVycEcVVClZxa3KrwV0TNY4nS4oSoTWf5tQmdjMDEY9d6ukzZsHNuwNKIhEjbK0yzzVOtCJRBEW0QbeJJo5qnm71NeaCu2qqarUN566jwKnjxQBFP2t5l9Oid/86C83OIIEJA5KmPVJhEqUq4zoiIbMcmWgKtGIqhnqbQoASf7dsSwugcYykZ6dN5HNl5vK6TDyugFVd7i90nZZrXuDQS6zpGBYijjtz3LNqxiMJwLdp2zYePYRtYH9onEEzCfMiQjZNmOEljx6InpqGxnccu8xio7KTJIzfk3I52yuMXfuuFl12RkVfacSkjypFIk1rr2qcLI4lMJAd386dqmSp+vM7qnrov3xXI2E8oAvXObTjri7lJmNspGoCi7KBHOvz8dQS7Gky0Gk+jIvn2d0TIz6D6XbX5swmdjOGGLDBs2bABZjGjIvOsyMiHzaFoRKTIvr4zM8oRPNfqiyqfMTlVY3nYV8dDNhwr8+RMqW62MhoiiyIzsyuJUlb0KYn3SERW8fWa2yuJRCSYxnYGSQR2BSj3Liwl+VMnqSBwfXjzVXbbNtNW4ZaDquU7cqnowEkTGqkNEx0azNsKGjbGEoR75s2HDxtiBtXk1HCgyxl8TPaU8VIQqlUpJ01Jdl6UpTsPQaQApry3lmRUFja73XsdLrbJNnDIilrtqVEeVXjYjSrwN4t/8NrGyMuKfU3m1VXmSxcnfp+IXbVdBV9RSoxtiPCJ0BJbMHt52VuZmz8kgjrxR9SvbuPkwAw03GkiMlXyYgaqrA4nPhg0bNmzYGC2wJDR4csNfY6CuWyFNvJdVN20zLz4Vj4yYmsVN5VVGPsXf4rMieTMTATxkU7GoeFRQjbqI4XRIs87oj+xdsfeejaeYItqibU6nU1m3ZCJEVscYqOlHVPoqsDhU05/E8mFpys7ByFbom33jZhDLUjY6NliwMlo2FJB9F7pCxIYNGzZs2DiakfWIBk9IKHKnmn7CrouEhvLQUqMHYngRZqSCskk3bllerEIkhXx8KlvFtKnnhsvjqyM42d9mQob6zT+rqkf8Neo98ovvxZ2sVOAFBnuWT0eE2QgVNeLE123qPBcxf0wwiQKIJ/I69Un13ZnlywpU71YMpxrBGA2jGIMJWfun+6wNGyONwRjhtGHDxtEPS0KDIkn8/+JvHmZTV1RxmC10lY1S6Hp4xedURFnXc82TPZ5U6Nqhyi9li7hTFTXSQtkvuybaks1Ig8rbK9qqgioMteUvX/bi6AQ1+qFKhypXPi+y8qTqnaz+U3bLCKhsxIC/T9lD3VfVBfHbltWngYAShrqCw+qowVghPVbaqdGC0WSLDRs2bNgYXbB8jgZAT6/gYUa+s+lIVV5tmQ0ykmdGsFRTP3TsFsktOxNCjJ8P63A44HK5Msiv7vQVkZhSBwLy9yjSqDNCwo8OqPKvek8UWafKRxQr4nVetOmIPTPBY5YfPi3ZiJhZPGJZUFCJDLG+UOHE+idLgypjmc3iVsaDAZ1yoN67jU8wFgn+WLTZhnXY36sNGzYYspo6JRIQ8bpqCgYfhvLg8lNJVASSDyemaUaEVUSauk6RcNkoBxW3SIhV4kclAGTxU555ah2HGMasfCnbqMX6fBjKRnZNRVTFeiETgyrxwKclihIqLZU3XXwflHgTbValaSaGWBiZUFOJeuqbEv/mf1tZME7ZMxCyOBDRcCyRF7PvBNCrU0ONbEa6bLFxdMB+jzZs2NCB5alTsr+ZZ5oiOpSIUMXLw8zbKoYz8+TKrolCQNczTNlkdfSFpcXWD+iQO94+lfiQPSfaRgkoFXTeCeWNVy1kN0vP6rsV05CNFFBhxd8q0WnFFqvijx914K/xf/PrTsT6I45cmNmqkz+rGMxRiaNFbAzFSI3M+TGUGIvvwybINmzYsDF8yOrAPhlkowz839ScegZxagj7n/cmmxEh2ciAeJ3FTS1k58ma6E3mCYKZd5uPiyonMV2Zd5ASQTLIRgL4tKh8Uc/oiEKqbFiZytZPUCNYvH08dEa1zKAjcHVHHKjr/D2zkSIqTqrem9kgew/U9yezWQVRaOuWdTag4h2LBDZbyN6XKuxYhOo7zyZcthjLZTiaYJejDRs2dDBoQoMis+J9SiTw4cQDyCgySZE06jcfnlqXYEb0qZEFWd7MPNiiaBFHEFReZfY3u2a2Baq4jkb8LYLygFP5NRNOZn/LyDUfXkW4dEiYShjKwNtitjhcVif5tFW2yoQ4lQ8Wnv9fdp96nhLpoh2qOCjRM9hiQ0cwq8Td0YxsSJzOex1p6No1Wu23YcOGDRvWYHnqFE/cVeEYqOlUfFyy56h0ZemIZJ4HTyB1BIJIukWio+t1NBt5Ee/xHm2xvFgeKC8z/5zH45F61FX28OVnlhfRKy9bp8PHy2/HyudJTENWJ2TvQ2Unn08V+aJGGWTxyuwWy4DPC/+O+HhEwSLmMVtSz0+jkp3xQcHKqMJIkECd0aexDpmwPFpgiwwbNmzYOPZgeUTDjACJ93gvscp7Tj3LP0eF0e2YKe8si4vPj0xAyYimLE6ZF1nMg5m3ViYaZM8kEgkA/Uc9VKMgspEM2UgOs0nMo1Vbqfs6nn4VCZddN7NNNVJB2STGxwtZiuTLynMwQI3EUHaq3ik1omRFZAyHF/1YIZ+DlU8rwtGGjWxgNqJqw4YNG0AWu07JRg4YZN5ps4ZHp3GSESWdNGSEkRptMYuD+psnWyovspm4EL3fDOJ5DtRzqsPoZIKCSktVJrwY0xkBsQKxbslGA2R5MitzlYAR7VfVLzZKI16XxSnaSpUfJaD4ukSNOvF26I72yEazZNAdERHzowObjAw+dL8dGzaGElbaDRs2bBzdyPpkcAp8wyKSXpXwsOIBoTpOVaMm81Dzv2UkjrJdRirNBAQfjxkZpzzMsulflE0qskHZJLOB98ZTBJiPk9oxS/XOdcpLBhWJF6+L9sjCsf9lNvJ5U42qiAJEZ9SN3VO9YzFOPl5KhMr+F/PNr+mhwukIR9V3bgZbbAw+qDK1xYaNkYBd32zYsGFJaIgEh/KOU6RcJQxUDZHuQWEqgqkiMixORpJVxFD0Louk0Cw/jNTJiCxluyqvOgTWbARIBZ6E6sQlvlNZeVJ1hv8t8/gPpMOiiLCMQKtEp8xLTOWXr7uUgODrpvjNUHVERh5ldYXKn/je+Lip73YgXsnBes4mKoMLW9jZGG7Y37ANG8c2BnSOBiAnNDrCwIxUyDzi1DVdIq0zesHHx37LRJaMGMrInIzcis+LoMQanx8qLlkaZmGpMKKQtDrKI8anIzTF9MW0Bos06Y6u6Hj70+lPFu6L8Yt1RhQ8spEW2fekqgO8AKLs1gHlPLBSj6wSDKrO2MR4cDCcZM/MWWLj2IDOaKgNGzaOflge0RC91iqSa9bRUOSb8myz69TzLB0zT7UsfQpUJykjazK7ZN5mHVKmI9LMTnfm41GNKKlskwk/WTmL74y30awsxHetejey6zr1TTVioBIxVspONdJgRsJkhJ4alWG/VWtzZOmK+eFH9cTnxOvZlLNZeDGP1N/HAsyEbjbiTeUQGApQI342xi6svj+zttSGDRvHFiztOsWLC2qKi+6Ig+wAPjEd8ZrKJhGqURWzhk8kVdTfFJmkRJOqbNh1FTHVtVFMQ/UuxN9m1ygSbSUOXcg8+GajI9TzVq5biUsWnrpGfSPiff6eKqzMFkqAiFMOdTp9UbhQz6ryMVAyKzodzAj3QNIaTdD55qm6ORbyrmpHbdiwYcPGsYGsFoOLxELXe2lGInhRQnm4rXrKVF5pszAqO6l7sjKgRmfE6zJvvopY6ogTnjBSHnCz0QEzO/g4qVEpWdw6okFMSwfpdLrfehuKiMu8vFbtop5T1QOz+/zCbNmp6uy+TPBaJf1WhK7ZOxookRyoF9T2nmdiNJWFLTKOPoym+mXDho3Ri6y3txWv8b95wieGVREo8Teg7qAokSASSVl4M+8xFb8OmbJig+x56rfMPpFQU8PWlN1WPakqYcLCimVKvWuZl18laih7B4O4yIgtNSrFp0+dIE7B6sicWC5UmZuNpIhC3EzgUCJ3NBOIbEYAbAwf7LI/uqDTT9qwYcOGCpbXaPCw4vFn1yhSPBByo/LGitfFURjqvoyMZesttUIaRbtUz4jrH6h0qd2OZB5vFemnRl2ov6140vmyFt+BDrmm0hHttfq+qPrJd7Ri/aHIO3+uBZUHSmiJ5SC+IyocJeL4cqBGc2RhZWUh5lssHxtDC1UdHq2jN3bdODqhGqW1YcOGDRWy3nVKJJfUbyseXf4eT2h0OlOVZ58is9mCIsQUSVQ1wGKZyMKalZvufRVREW2iCD71LqlyELfCNSNCA50mw6dD5YnFqzMKw9dl2ciCrr1mU5fMyoQqY1naMlFm5oU0E9SiPYPxrgYDut/wWCRAZmJb5zkbNoYLY/Ebs2HDxsjA0mJwEWZeDhU5Vo148L8ZcVORNiueW7NnKBtUkJFK2RQh8RkZgRfTNxvt4OPin+PXafB2yuylvNZmZUBNNaLyoHqWem+qe5SX34zkyyAbWRDvy2xhz+rUFxnMRInsW9MRkvw1Wd1WfR8qG4YLqjow1jEU+TB7/zZsmOFo+b5s2LAxssh66hTrtGQngFMjHbK4xGviFBgdISGDGUk0I3OUp1E24iIKCPE3n46M8FPXdO2WiQ9KPIjpmYUR88f/TYkfKx5ZigDpjkSppv6YiU72m/qXDcT8UwJPZqtos2xETpUnWRnyv1Viw2z0Z6RwtBIelaDVhe6IqCqsDRs2bNiwMVTIetcpQE7iZcQ4G0+3GIcYRpz2YtV2kfBTJNQMVN5kcZo9r0NIeVDiYiCEwkzk6L5byh7dd0SFlYkzkZjLbBTjVgkUXfsogU3FkU2dUtljJo6psLJnxMMF+W9JNnI22nG0ChOrGAzxrAu7zI8+jIVv3YYNG6MfloWG2PgwokJ5T6kOTiRkZmHY32Y2qUgog7iOQJYnlchRjbaoflOjNbI8UISc8nbLbJVBZ6TE7HnZe1alpbJbVh7U+1fZKyt7la1ieZuRej4PvMCVpSmmoTuiRNnDhxHtEm1R2UPdH05Cmg1Go00DxWAQ89FSLmZOIxtjF6O1TbBhw8bYQVYjGqJAoAioztC9lWkg1POy+2YkVgYZodUhkzppWW2wqXTFMjcjsPz/qvyp7BeFoSotKl0VdEYBxPuqURWq7si88jojLGZ50Xnv2Qg68X9+dCHbzl+0VSbKxfo8GojGaLBhsCAbmVTlcbjFoJU6ezS9Gxs2bNiwMbiwvBhc5V3WGQkQw+uMCpiRUD4tMU6rRFAnLZG4qkB5nqn4qL/T6TScTicpZCjyz8dPEUWRsPI2mpW1jKhnA5nnXSS+ZqSaIsoqQSHLv6w8VIRcRcStjMZRtotlorovhqPejUpYytLiR0l4UTuSkAkjVbixACujTzyGUgSOtTK0YcOGDRujE5aEhoys6ZAvETISKKZFxacivRTZkpFlilRTcesKBCoesZyofKsgCyMjWiohqCL44rkcMvFjNrrD7vHTf6i4VKMOKvEh5keHEMmIOYtDJq50BJUO+bVK0imRIKtTfDizdMzqBJUmH7f4eyShIt+jHQMV6qMFg1kXRku9spEJnfbehg0bNlTISmiw34B8igtFrqlwIsllUI1yWPVm6pJ6GawIJz49/rqKuIvPUqRSJoJUdqrstloeYvqyg+lY3LI0VN5/8ZpMfIhhVSMAVPmrRKPZSJHMLjOCL444qPIk2sVGtfi/e3t7le9AlV8dki4rx9GOsWLnYGCk8zqY6Y90XqxC1S7Z5NyGDRs2PkFW29syj7TKo09N5RCJjI6nXuUllpFvXS81b4MqLtEe2TWVrbI86ZSBLjnV8WoPBGJ5yUaFzOxVjbrw183qGRVetEV8L7oiQxZeVeepa7JRAT5+mShV2SGKc5UY4m3h82g2AsMLdKsjJTbMkQ0RVb03G8MDse8Q7x0tsL95GzZsDAayPkeDgSckOo0P1UCbeYh1BIQOxDM/xHR07BXJr5XpKDKyKabHP2NFZFDxyt6NKBpUcYrxmHVAZsSfil8MJ8YlXqfil4kKUXDoilmdeMzi0iHpZu+Y1VszYcaeZ6MeVJyyETKZXTpCT7TBxuBA1lbqvhMbgwtV23c0CkC7jtmwYWMwYHnqlPhb5X1l28lSxFCcmiILx0PmNaaIk4rQywSTbLqIauqISD6p0RxZOmYjG+Izqt/iSIPseR5sSg5FdlXvRwUxLlXHrGunjsdfhMoGSijqCFgZmVC9R5W4pMpYZYNY12XfkyiMZGCnxovxU9+ADOJ3P1bIiVlbM1zp2zg6MFbqvQ0bNmwMN7La3laElSFWlWdZNlKg8hrLSBFFCvnDyURhoIqDumY2uiKKFiqcKAr4OPnRF4pwyuKh0tQZCaFskF2TiRkrRFPHO2/lHhXWzAMJqNfOqJ6ReZspG7K1ORshSsWn804oUWJV0I0VjLTI0IUtRkYnRnu9sWHDho3RBMtCQyRPZqSI8ixn21CbkWB+ugcFVbq6U5Qom8RpSLI8i4JG5XmmRmlkwoW/riLWIpFlNvGebTNCSwk1XUJrVkd0p4VYnToii9eKEFCVuSw+Km5d0i+SfHGbY5Ug5+tktvValYfBDD9SsMmiDRvmsL8TGzZsDBRZCw3ZVCXZdA2Zd15GTGQeVp5gybzsKu87Rfxl+ZPZSRE+8XlZGiqhZDZ9RmWz6m/gkxESFUk3G00RhZKMxPICRmaPjv064oeaLiTaoUN+dUYyWDiZ4FPFYyVPqvR1w1B1nnpGNjJjVhfHKkaDEBrMkTkbQw+7/PVhl5UNGzZEWD6wD+hrTPhpSDJSY+bdZc/q3OPJv2wEQGYr/5u3ld82lL9Heev5MDKySBFSRrZVBFVnWoxqegy7zm95KssT9bzqGrWFqkxkivdUHY74PqnwOlN3zEYRKFtUowGibbJy1xl1kZWRyh7qOeobUKUprr2g8sX/rarTOu/ALJ2RhlkdB4ZPRGVTx22MLMzagqMV2dTJY6l8bNiwoYes1mhQBG2wGhhVfLreEp0pOLqNqGwKCkUIKcEl82TLxJkohCh7zOyVQSXoVOVl5V3IvPyqsLJRHZm3nffymtUXnbyI96kRHR3PMi9cxWdVZcvipcJQdUAGsTyp+smHYYJEXLsky6vu+x5N0LVvOPMx2svMBo1jiUTbddSGDRuDhayEhs5UFt3pFzKSLRJ0NjJAhbWSpoosqgifGWnVFRKya1Q58PkRCS8fVhx1oeyj/qZg5Rkr9ygBoSLf1PsF+o+EiP90ofIs64hnnqCzf3wdVdVz/m9d8UcJHitiWTeMzG5V+Y5GUqISwlZHZwbTJiA7wnoskdyRhNVv61iGXUY2bNjQgSWhofJWmxEndp2RMzMPL/83e05GBikSRxFy/n8dqIiKqkOiSDbluRa95wMhjtmSJ7782NQrVUfLwpuJBCsjT+JzZmVsVsdkUNULBn5diXgWhViHRPFLCVVd26l0RPusiDVxaiP1WxRHVD6tiHQr+RxKDJbAMGvTrEJnZNAmuSMHVbtwrOFYz78NGzYGD1mv0WCEip+CAcgbKJmnlCdmVsiKFbJNea9VIwAimVaJGlm6FEmjnlORdh3w8YpijNnB2yRO7+GhuqdjhygEzUY8ZESOqg8sPnE6UjZkUCwHPh5G0GXrHPj8iTaJ98VrVB5lI1VUmuKzVL5YWF5A6IgbMexA6+VQQccuq8Kdj3ukQNWXgZb/aH2Howmi48eGDRs2bAwuLI9oiORK9JZSkHlerTTsjBzKnqOIHOUBNkufebJFYqeKi5q+I3pEZfaJIwoymJFXM8IqE08qWCXv/CiA2ftWEWede9TIl1neZAJGJgLEdMX3rBpRoPIiXldNB1Rdk9kluyaKMv7blZ0gTtmu60Q4WjCQUQ2dkQlKsOrUKV2II4Q2bNiwYcPGcCPrk8GZx1fWKcruiV5okQDLRg3YPV2yKj4n2kSlp/LKU951s3RldvCQkV7RZpmdZvmUxaeKR2UvZb9uWahGMEQBoSJ4Ztes5klW51Qimq+37H82SsLIuyg0RWHBn8yuY6usHot5F7cVpt6P7J2xuPnv2+l0Skd4xO+XimuwoRsvVa+sQFY2us+ajWrJ0uGfH8zyM3MIHYsYrrKw8u7N4hiJ90fVRVu82rChB4fDAbfbDbfbbfSnyWQSqVRqUJ1LoxWWhAZPAmVbw/LI1iMq66Qp8k2lQ8UtI6ciiVfZRKWtgsobrxuWT1M3Heq+bNtbPozK+87ybDa9ympnKJJfkZRT8Zm9U+pZXZEm5oO6Rgk5sVxcLhfcbjdcLpdRdolEgtzumEqDKhfKZl0hxt9jcbMGT4yTDyeKJQoy8S+mNxjg64jVeCk7h7KB13GiiIKPEswDsVH1bmwMLVg/ydoBp9OJeDxuCPls3+9QCXgrYPni82HDho1MMIFRWFiIiRMnYvz48fD5fIhEIqivr0d1dTU6OjqQTCaP6u/IktBwu/uCq0g+NSJAET4zD6MqrMrTzCAj05TNZtDxTA5klIMnc+JZGFRYVv6igBC97FZtYTaIz1kROZRwo8ghf41K24wsm9mjyr/u6Af1nKpcHA4HXC4XPB4PAoEA8vLyEAwGkUwmEQ6H0dXVhVgspmxUVMTTTHzKnqVEAyM7up5Kdo0JJ9k0PyqdkSRGKpE2GLAa90C+zYHC7LuSYTQQ28HAcOWDCQy/34/CwkJMmTIFxcXFcLvd2Lt3LxoaGtDe3m44Hqw4r0YL/H4/Kioq0NbWhs7OTiQSiTFlvw0bQw2n04lQKIQpU6bgrLPOwuWXX4758+fD4XAgHo/jrbfewh//+Eds2LABtbW1R/U3ZEloeL1e9Pb2IpVKwel0IpFIANCb263yiMpgRnZlXl8dgSESIv4a5Ym0YiuLU0XCVUSRilscTTDrnPj8sedE76bMwysSU9kzKuLC7FWtOxkoVB5iM/sYqLyaCQq+XvBCz+l0wuv1orS0FFVVVSgvLzdIeVtbG+rq6lBXV4dIJGIMm8rqLCXKKAFhBtW3R8UpQhypKS4uRjqdRmdnJ2KxGFKplDL9oSB3A41vqL38Vr8bq3VWTMeqY0MXMpE71jrD4RzJYd9aMBjE0qVLccEFF2DlypUoLy9HMpnE1q1b8cwzz+CFF15AdXU1YrFYho26InWoRZOZU2PixIm44YYbUFdXh9deew3btm1DR0fHkLb3NmyMFTCRsWjRItxwww0466yz0NPTgwMHDiCZTMLn82HhwoUoKyvDAw88gCeffBI1NTXGVKqjDZaERklJCdLpNFpbW5FIJOByufqdHWDWIZkRG1UHTE3bEee5q4iyyrtJkX8qThkBl3mGKXFhJoREMUGVB9URyEg3P12HileMR7zG/+bJsdk7VImVgXT+qg9R7IipOinWI6rc+LKiysDlcmUIOYejb4i0uLgYS5cuxZw5c5BIJHD48GF4PB6UlJQgPz8fiUQCjY2NxpQDWX1QCXOZSJUJB36UTKfs+TDsfbO/ly9fjuOPPx5bt27F22+/jbq6OsPhQD2vsnm4oOOE4GGV6I8mDMdoyVgZ4VA5IYYSLpcLCxcuxJ133olZs2bB5XIB6PsOly9fjhkzZiAYDOKRRx5BfX29QS7Yd6Yi6+J3PlQwaycKCwtx3nnnoaysDF/+8pdx22234e9//zva29ttsWHjmIfH48GUKVNwzTXXYNWqVdizZw/uv/9+PPXUUwiHw5gxYwauueYaXHLJJbjiiivQ1NSEZ599Fp2dnf342tEAS0Jj2rRpSKfT8Hg8aGhoIId9Ke8w33iqPOAiUaJEh4wUUsQG+GTRukxEyCAjIKqRCIrIi+VjhZxQxJHqaGRhxG2HzbzafHx8+fNpyraF1en8VFvGitAdjVA9L4aTddKUuJIJUnEUg113u90IBoOYNm0ali5dira2NrS0tCAcDiMQCCAQCGDKlCmIx+OIx+NIpVLGiIBKFPF2m5WxTCSK+Rb/l0EUhel0GpdffjnOOussAMDvfvc73H333YaXxiyekUQ2Xn9V/bIqMoZCvMjyNBhlrfttDRaGQiAN1KGRDRwOB0KhEK666ipMnz7dEBl8nZowYQJuuOEGHD58GGvWrEE4HM6w12wkWFZGw/md1dfX44knnsDixYsxffp0fO973wMAPProo+jp6Rnx792GjZECawPOOOMMfOpTn8Lu3btx2223Yc2aNXA6nfB4PNixYwf+93//F+FwGF/96lfxpS99Cfv27cP777+fwQWOlu/I0va2xcXFKC8vR2VlJUKhkLHAjf1TQSYcRI+uyoNPFTrl/eXj5Leq5TszivyLaVOEm8qLWX5lIyBUXqi/ReEmg2g/H1a1iFtVocX3pBJ8IpmVCZuBgO+MxesywUDd04HqMEWxLFwuF/Ly8lBVVYV0Oo28vDzk5eWhoKAAxcXFiMfjiEajmDx5MsaNG2f6vajILkVCqDrCfwO80JeJMJlg5ePKy8uD1+uFz+fDV7/6VVxyySUoKioi7T9aGkmGwcwP5YzRaRNUYQfbxpGIf7ChK6oHC06nEzNmzMD5558Pj8fTL232u7S0FGeeeSZyc3Mz2laqP9OFlf5JF7J4amtr8ZOf/ARnnnkmrrrqKuTl5eFb3/oW5syZMypH+mzYGC44nU7MmjXLmDL56quvYv369cZ36fF44Pf70dzcjPXr12P37t1YvHgxLrnkEgBDP7V3JGBJaKRSKWPBSklJibE4nEGXgPP/U9fNCLro/RUbWJnwUJEfKg7VGQNUXnTIgoxgUMRTHDGQ5Y8ScGIaAEwXmVN5UIkdmdhg+RE7eYr0WxUk4jkd1HuVCTY+HEWsxVEDsRwoQcpERiAQwMyZMzFz5kz4/X7Dc5Gfn2+s0ejs7ITH40FeXp5BQsTyofLPr7ERRYBor6ze8+kwx4CsruqSskAggAsvvBAzZsxQ1i2dEYJjCQPxVJm1Y7L0dB0jIylijga4XC586UtfQkFBgel7Li8vh8fj6VfebKqj7vcykO9K9qxZnMlkEl1dXUgkEti2bRvuueceTJ06FbfffrsximPDxrEIp9OJVatWYdmyZdi9ezfef/99dHR0wOHom14dCASQm5uL3NxcRKNR1NbWwuv1IhgMSp3dYx2WhEZLSwtaW1vh8/lQWFiIYDCo9MyJxDKdTvebmy42qGaFSnl8WDrU3DZdDxHl2eXjEkkmFY7qVGTXxOs681op0ihLg7dZF2LcMnJtRnREIk4JRp3yMiM2/H1q5IpPT2aLKk4Ksvzk5ORg3rx58Pv9qK2tRVdXFzo6OtDa2opwOAy/349kMomWlhZEIpGMukqduyHmQ2U79Z2ZeUVUgpQSLKKoYVi0aBHmzJmDQCBgmsZwYDC9ubK4B0rsKJE8lGWlE/9gtSHZYijLYDjrYSgUwvnnn5/hhKMEf29vL5qamoztbimbdcWGylmjqrM6TiwWP5Ume7atrQ2vvvoqHA4HKioqUFlZqbR3KL9RGzZGGk6nE6WlpSgoKMBrr72G9evXG45Hr9cLr9eLQCCA0tJSzJ07F9OmTUM0GkVHR8dR68yxJDQAGCLD7/ejoKDAaAz5DlQkTrwyUzViqs7GjGTxYcyEi9io6nZysgZS5kE3g1leRWHGP0cJAP5ZWfxmnYiZSFDFLRNCqvjE90dNiaL+lnnxzWwV6yIveFl8vG26eUmlUujp6UF3dzcCgQCamprQ1dUFh8OBvLw8TJw4EZMmTUJubm5GuiLxpEAJEKocKeJAfYti2cjEpJguZZ/X68Vpp51mSi6GGzpEZjjJjqoMGXS+16GEVdt4jFbiOBR2qdqcaDRq/JY5rFif2dTUpNwmmoXXgU54M+GhilfV3sfjcTQ2NmLfvn2YMGECvvOd72jFbcPG0Yre3l709vYiJycHeXl5cLvdhtBIp9OIRqOIRCLG7lQdHR1oaGgwnpf1xWMVloRGQUEBCgsLjSkh/IgGXxhs0a94mA9FhBhUnmxZJ6f7DHVPRaipPMnskBF3Kn6ZSFERWcqzzP9WEXOKYFOVluqk+CF9K/nWsceKeFHZqorHjLyLafDhdTprMY1oNIr9+/ejtbUV+/fvRzqdRm5uLkpKSjBp0iScd955OPHEE5GTk2Mc0CODrE7oikBZXKJDQPVdqb4fEcuXL0dVVZWpLcMBMb9mYUUMxqiFblpWbBouDLbTZKQwVF5zszgTiQTefPPNjJ3YWDvNO+V6e3uxdetWQ5hQbb3ZBioUxNETs7yYtXW66e3cuRO33HILQqEQTjjhBK3nbNg4GpFIJIyzcubNm4cFCxbA7/ejt7cXkUgELS0tOHLkiLG9dWFhIQ4fPowPP/xQGudY/14sCY1kMon29nYAfR5cn8+nnOttJPL/h+EJDvVbFY+KfFGEWMcbLTbKlFeYsldmqxg/ZYcZgRPzwHdO1JoRGTFg4alyk5Fp3tPPDpPid+2S5ZXPs9k7EEcUZPmR5U9Mg4LT6TTmCVMiko9DJuTE8HwYapQpkUjg0KFDaG5uhtvthtvtxoQJEzBjxgzMmzcPpaWl8Pv92LdvH1pbW5FMJqXb2OmIV9l7ZddkI2GioKLeK/UuqbJgCIVCGWtOjkbokrfBTItqm4aKQOvYQGE47BlI/MPdQSeTSfzqV79CXV1dv80k+O+qtrYW+/fvRyKRUH7vZu2vCmbvTQWr6SWTSbS2tsLhcPRbu2nFrqHCWPcI2xg7SKfT+Otf/4o1a9Zgzpw5WLVqFSoqKuBwONDT04NIJIJ4PA6/34/S0lI4nU4cOXIEhw8fHtZ+ZjhhSWjE43Ekk0k0NDT8f+2dS2sUTxfGn2QmxERzWQmK4oUIKvzRTXCdTyAIbhTUdXauXLnxEwiiuBMEQTcRoyKKBBQMBiSEgMlGEs0NjebiZMaZSTIz70Jq3srJOVXVnUkyM57fZpLu6qpTl+4+z6nqbmSz2Q2Omf1LnU3OYbGXdLii/TQNLVO6SHO4HKsQqEAJcXpp2pALPCdGOAFitrtmSrg6+/7nxEKIrfY2n/McCidGfDMZVAxEEaIu553aQCOUS0tLmJ2dBfD3xtvZ2Yn//vsPXV1dGB4exqtXrzA2NoZ0Or3ptbZcvV1jy3VBKpU2voLX10+c2A8dAybtTjnA2wU9tw1S/2+VKPlIgZntImr+Iel3SizQAFGlCbnej4+P4+HDh1hYWNgUTCiVSshms7h79y4mJiacM5uGODMbPkJEZAj2vVkfAleUv+fW7Ows+vv7MTo6ivPnz6O3txenT59GR0cHWlpa0N7ejgsXLuDatWsYHx/HwMAAFhcX61JkABG/o9HW1obGxkak02k0NTVhfX2djfpzUWKfQ0fhHB8pak7LkPKmIsF14eZElKsOtHzJHiqeJOc3alu6ZiiitD29qfmcXfrOd86xlxxdO43Jh7a5dAydlfClDyGKqLHtMKJjdXUVU1NTyGQy5TfKmK+ADg4OYnh4GD9+/EAul9vQzi5RwY1D217f7Ac3fnx14tqD22/IZDLiQ627TUgwwCVcfYSMk3omSttupwCgZe3EWJTGVi6Xw507d5DJZHD58mUcP34czc3NKBaLyGQy6O/vx9u3b7G8vIxCobDBdtd1IA6ue6Fre0i/JhKJslBqbm7GgQMHUCqVyn5BNV4PFGUnKBQKeP36Nfbv34/r16/j6tWruHjxIsbHx5FKpXDixAm0tbVhdnYWL1++xODgIHK5XN2eM5GERqFQQGNjI1pbW5FIJLCysoL19fVNzg11jkIbj3OMQ5x7l0NrtptjJUdMcszoNilvri5c+dxrX122+0QCdb5d+PolzmxPpW6AVKBEdf58+QHu8SGJO5ofFTj2zEljYyOWl5eRTqfx8+dPTE5O4sOHD8jlclhZWUEqlUImk/FGyX1j0RbL3PFSP7qcC0lguASL+XtwcLA8kyNRa47HbkTDOXbaea40IdelSlBtQm95eRn37t1DX18fenp6cPbsWXz+/Bnz8/P48uVLeX02wN+DQvp6K+eUL/AjpbPTJ5PJcoDh6NGjuHHjBlZWVjA0NBTLJkWpJ9bW1vD48WNkMhn09vbizJkzOHfuHBobG5HP5zE2NoYnT57g+fPnmJmZ2eBL1xuRhMba2hpaWlqQyWSwsLCAX79+bXrg2+By5F1RUy5abeM7niNkdsJsMw4jVxeKzwmgtkoiQ4JrB98Mg6t8n31Rj/fZY6dxCQeuj6PkI40VWxwYUUDLkQSGaybIFhxmJqZYLCKfz6NU+rs0Ip1OY35+vtzn6+vrKBQK5fJCxpo0bqlt3EyQJNwaGhrKAYOQ9qPb6fhNpVJ4+vQpJiYm8C9SbQ5upaikwHGJ4kqw033gu6YCKD/4+e3bNzx69Ah9fX1obm5GU1MT0ul0+evZ9hLYKPcGk65S/cRdW135JZNJtLe3o1QqIZFIoKurC6dOncLIyAhu3boV247tpNaCHUpt09DQgFwuh2fPnmFoaAjd3d3o6enBkSNHMDs7i3fv3mFwcBBzc3Nl36FeiSQ0ACCdTmNxcRFTU1Pl7wFQEWGf0KEREp+TS5088zeXB3XQXRdwuk/KW7KVEz2uyLhv5iKKHa78pLRR4PrV3k7zdQkyl9PKpYtqvz0upBuwS0jQGQu7P2jedv7mWYvV1dXysbagMSLAFhe2DbZI8NUxtF1c4tF+I1yIsKB5pNNp5PN5JJNJLCws4ObNm3jz5k05OsvZVc3OuC+QETc/KfAg7at3tmtmo9pmfOh1slAooFgsYm1trfxMl7lnNjT8/1m7kGc1fOVtdXxFOe7kyZO4ffs22tvbsW/fPhw7dgyjo6O4cuUKlpaWqqIvFGU3MX6ACTjMzMzgxYsXaGpqKi87zOfzsc/9WiKS0BgbG0MikcDi4mJ5nbnkLFKnj5uJsJ22EIfa5GfgnHIuQi1diM1vyJuzbOfMnpng6s05nL5ouWsWJ2QWwzdzJJUl/c+Va4vIkBu8JPhoOXFvkK4xYcP1F81DOlYSAXbaQqFQniXgRAX3K82+hP5Pv5Au9bd0HnL1cm03ZT548AADAwNYXl7Gp0+fMDk5ueHbARK75XhUQjTY+fjE7m6zHVHbWogEV5N93LXVCA56r6IfsI1TD+k+uJ10dHSgu7u7/OzJyMgILl26hK9fv5afO1GUfxXq+xkfYXV1tbyNm82sVyIJje/fvyORSGxaAmLjazCX48ZFF2m+klPsQoqmSQ4WLc/AvS7W5aRJUXxOeHHRdV903xWpl4SE1F6lUoldTiPZRo+VIsOhZXMOMLWdHmP2+8YNtcMnKFz2ubAf7JRslqL8nGiibedzcuMIVXqs6zwsFot4//49stks1tbWgh0kl6itBnxjw6SJmqcrv5B0IedCXLtCbItTTrX1bTUi3Te32nY72fbT09O4f/8+Ojs78fHjR/T19SGVSlX1OvNqtUupbyRfgFtVUK80lALOvlQqhY6Ojg3fzTDr0m3sKWEDFQjSzIGvwaXIvb3NdazrBkvFgs9hC6mDZF8c8eCqK21fSQz5HBnOmfY5S/Z2Tp3TPucib1z+vvHgEkV0W6gQdaWVxoUd6Y97E+P6xu5HV1oqKqX2dNWLO851/iaTyQ3fAAmpn1TudhHFmbZF/1ac+CjjbLuJI5aiBm/i2BB6jefShthXbY6kFFQAaj+KmUwmsXfvXmSz2fJsDVB9fWCoxgCHotQLv3//Rnt7u7g/0oyGvd4c2BzhD4nCAxsdSVvV0YivK8rKPVhtBJAd/fVFKjn7fI4xxY7quqLrtF6udK7ot6s+VCWHOB1SO9P6u54ncL2a1uRLt0vvh4/rtIVGkU3aUDESOpNA7ePEAjdGuPbhzinaT5L99nngspEri6ufncbMZoZSCzf3ODb6xJ29L24ZceyQcF1DpHN6K8TJx3eeRTm+GsaddD2tBtu2SqFQKH8PSFEUxUUkoWGme4CNkUCzz+doc4KCfljMzssuh7OF5mXyC3VCo94MXdF+u1zOOaTb7X2c08jNDoXaJvUFlz5k1ibEmZH2uZxczhG2o8shttH9kqgJsS3EVlOOKcMlHF39QMWCXT9XWqlNqPAOmfGJIsy4MqudEDtDBNhWy4iSLi6+/EPrWSt9WyvU+syFi1qqVy3Zqij1RuS3TgHR1h/baWyRwr1q1OTJOVP0w3CuGQ/bKYsboYsaobSdwWKxuOm1pa68aD5SfaT/pfzpzA79m7sJRhUY9nGuNYcu+12RdK5Orrq7Zobodq4P7TxCHHSfoKMCwe4XOvsmlUFtkcR7KCFOJ7cEr1aoFpurxQ5F2Q50fCuKEoLbG2aQHNOoy1+oEyyVYZwu7g1OrjxcNtvbXWVHxdgqvRvd5ZTadaG/XASdOpshyx840SelM+JOeiOXVHepXtRGyRZXdFUSR67+dW3nxmwUYcqlp2NSEiucSOZEIdd2Ut1cwtDV31L+9JwzYyGueFcUpX7wBdMURalvQn2BoBkNGlXlHEOfaJAcTSliSx1OurSGc7jpcpQoTqk0Q2ILBLOciS6TkvJ1OZlxljK4/qbixt5mp6ftaGZfOOfYTmvPRnGzS1Kd6VI7aQmQVC+uj7lypG3cdkn0Sc+McHbRdNz4pW0tYb+tyvzSV0dzeXBjkI5PV/18+XFltra2su/+dgnEEELFrHQcHV+u46LYF2fGyD4uFF/+rv0hInSrhMyi2rZsV7Sb5h+n7txYiWtvpUS3674UFSn4Z98bttI/DQ0NaG5uRiKRwJ8/fzaV6zvf7Hb39acPeo2kf9NADX1oPUr/78R5puwcoYHqKPnFYTfH0VavA3v27EE2m/XmE/TWqZmZGRw+fDi2QYqiKIqiKIqi1BfT09M4dOiQuD9IaBSLRczNzaGtrU2XTSiKoiiKoijKP0ypVMLKygoOHjzoXEoZJDQURVEURVEURVGioE9zKYqiKIqiKIpScVRoKIqiKIqiKIpScVRoKIqiKIqiKIpScVRoKIqiKIqiKIpScVRoKIqiKIqiKIpScVRoKIqiKIqiKIpScVRoKIqiKIqiKIpScf4Hyp0XPtILp9MAAAAASUVORK5CYII=",
-      "text/plain": [
-       "<Figure size 1000x1000 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "print(f\"The model '{model.name}' had the following properties and metadata\")\n",
-    "print()\n",
-    "print(f\" Description {model.description}\")\n",
-    "print()\n",
-    "print(f\" The authors of the model are {model.authors}\")\n",
-    "print(f\" and it is maintained by: {model.maintainers}\")\n",
-    "print(f\" License: {model.license}\")\n",
-    "print()\n",
+    "from devtools import pprint\n",
+    "from typing import Any\n",
     "\n",
-    "print(f\" If you use this model, you are expected to cite {model.cite}\")\n",
-    "print()\n",
-    "print(f\" Further documentation can be found here: {model.cite}\")\n",
-    "print()\n",
-    "print(f\" GitHub repository: {model.git_repo}\")\n",
-    "print()\n",
-    "print(f\"Covers of the model '{model.name}'\")\n",
+    "import matplotlib.pyplot as plt\n",
+    "import imageio.v3\n",
+    "from numpy.typing import NDArray\n",
+    "\n",
+    "from bioimageio.spec._internal.io import FileSource\n",
+    "from bioimageio.spec.utils import download\n",
     "\n",
-    "for cover in model.covers:\n",
-    "    cover_data = imread(download(cover).path)\n",
-    "    plt.figure(figsize=(10, 10))\n",
-    "    plt.imshow(cover_data)\n",
-    "    plt.xticks([])\n",
-    "    plt.yticks([])\n",
+    "def imread(src: FileSource) -> NDArray[Any]:\n",
+    "    \"\"\"typed `imageio.v3.imread`\"\"\"\n",
+    "    img: NDArray[Any] = imageio.v3.imread(download(src).path)\n",
+    "    return img\n",
+    "\n",
+    "print(f\"The model is named '{model.name}'\")\n",
+    "print(f\"Description:\\n{model.description}\")\n",
+    "print(f\"License: {model.license}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(\"\\nThe authors of the model are:\")\n",
+    "pprint(model.authors)\n",
+    "print(f\"\\nIn addition to the authors it is maintained by:\")\n",
+    "pprint(model.maintainers)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(\"\\nIf you use this model, you are expected to cite:\")\n",
+    "pprint(model.cite)\n",
+    "\n",
+    "print(f\"\\nFurther documentation can be found here: {model.documentation}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if model.git_repo is None:\n",
+    "    print(\"\\nThere is no associated GitHub repository.\")\n",
+    "else:\n",
+    "    print(f\"\\nThere is an associated GitHub repository: {model.git_repo}.\")\n",
+    "\n",
+    "for i, cover in enumerate(model.covers):\n",
+    "    downloaded_cover = download(cover)\n",
+    "    cover_data: NDArray[Any] = imread(downloaded_cover.path)\n",
+    "    _ = plt.figure(figsize=(10, 10))\n",
+    "    plt.imshow(cover_data)  # type: ignore\n",
+    "    plt.xticks([])  # type: ignore\n",
+    "    plt.yticks([])  # type: ignore\n",
+    "    plt.title(f\"cover image {downloaded_cover.original_file_name}\")  # type: ignore\n",
     "    plt.show()"
    ]
   },
@@ -418,172 +268,118 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### 4.1 Inspect the weights, expected inputs and outputs, and model architecture"
+    "### 4.1 Inspect Available weight formats of the model"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 120,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Available weight formats for this model:\n",
-      "----------------------------------------\n",
-      "PyTorch state dict\n",
-      "The model weights are stored in /Users/esti/Library/Caches/bioimageio/a480e11200e5367d895a74be06adf60f-weights.pt.\n",
-      "\n",
-      "Model architecture given by 'UNet2d' in unet.py\n",
-      "architecture key word arguments:\n",
-      "{'depth': 4,\n",
-      " 'final_activation': 'Sigmoid',\n",
-      " 'gain': 2,\n",
-      " 'in_channels': 1,\n",
-      " 'initial_features': 64,\n",
-      " 'out_channels': 2,\n",
-      " 'postprocessing': None,\n",
-      " 'return_side_outputs': False}\n",
-      "\n",
-      "source=RelativePath('weights.pt') sha256='608f52cd7f5119f7a7b8272395b0c169714e8be34536eaf159820f72a1d6a5b7' authors=None parent=None architecture=ArchitectureFromFileDescr(source=RelativePath('unet.py'), sha256='7f5b15948e8e2c91f78dcff34fbf30af517073e91ba487f3edb982b948d099b3', callable='UNet2d', kwargs={'depth': 4, 'final_activation': 'Sigmoid', 'gain': 2, 'in_channels': 1, 'initial_features': 64, 'out_channels': 2, 'postprocessing': None, 'return_side_outputs': False}) pytorch_version=Version(root='1.10') dependencies=EnvironmentFileDescr(source=RelativePath('environment.yaml'), sha256='e79043966078d1375f470dd4173eda70d1db66f70ceb568cf62a4fdc50d95c7f')\n",
-      "\n",
-      "Torchscript\n",
-      "The model weights are stored in /Users/esti/Library/Caches/bioimageio/6977b0cb8a1bedb09b5af24dd252f943-weights-torchscript.pt.\n",
-      "\n",
-      "source=RelativePath('weights-torchscript.pt') sha256='8410950508655a300793b389c815dc30b1334062fc1dadb1e15e55a93cbb99a0' authors=None parent=None pytorch_version=Version(root='1.10')\n",
-      "\n",
-      "ONNX\n",
-      "The model weights are stored in /Users/esti/Library/Caches/bioimageio/5a27845a16549a9bd1dfa6da29554c43-weights.onnx.\n",
-      "\n",
-      "source=RelativePath('weights.onnx') sha256='df913b85947f5132bcdaf81d91af0963f60d44f4caf8a4fec672d96a2f327b44' authors=None parent=None opset_version=12\n",
-      "\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "print(\"Available weight formats for this model:\")\n",
-    "print(\"----------------------------------------\")\n",
-    "if model.weights.keras_hdf5 is not None:\n",
-    "    print(\"Keras HDF5\")\n",
-    "    keras_weights_src = model.weights.keras_hdf5.download().path\n",
-    "    print(f\"The model weights are stored in {keras_weights_src}.\")\n",
-    "    print()\n",
-    "    print(model.weights.keras_hdf5)\n",
-    "    print()\n",
-    "if model.weights.pytorch_state_dict is not None:\n",
-    "    print(\"PyTorch state dict\")\n",
-    "    pytorch_state_dict_weights_src = model.weights.pytorch_state_dict.download().path\n",
-    "    print(f\"The model weights are stored in {pytorch_state_dict_weights_src}.\")\n",
-    "    print()\n",
-    "    if model.weights.pytorch_state_dict is not None:\n",
-    "        arch = model.weights.pytorch_state_dict.architecture\n",
-    "        if isinstance(arch, ArchitectureFromFileDescr):\n",
-    "            print(f\"Model architecture given by '{arch.callable}' in {arch.source}\")\n",
-    "            print(\"architecture key word arguments:\")\n",
-    "            pprint(arch.kwargs)\n",
-    "            arch_file_path = download(arch.source, sha256=arch.sha256).path\n",
-    "            arch_file_sha256 = arch.sha256\n",
-    "            arch_name = arch.callable\n",
-    "            arch_kwargs = arch.kwargs \n",
-    "    print()\n",
-    "    print(model.weights.pytorch_state_dict)\n",
-    "    print()\n",
-    "if model.weights.torchscript is not None:\n",
-    "    print(\"Torchscript\")\n",
-    "    pytorch_state_dict_weights_src = model.weights.torchscript.download().path\n",
-    "    print(f\"The model weights are stored in {pytorch_state_dict_weights_src}.\")\n",
-    "    print()\n",
-    "    print(model.weights.torchscript)\n",
-    "    print()\n",
-    "if model.weights.tensorflow_js is not None:\n",
-    "    print(\"TensorFlow Java script\")\n",
-    "    tfjs_weights_src = model.weights.keras_hdf5.download().path\n",
-    "    print(f\"The model weights are stored in {tfjs_weights_src}.\")\n",
-    "    print()\n",
-    "    print(model.weights.tensorflow_js)\n",
-    "    print()\n",
-    "if model.weights.tensorflow_saved_model_bundle is not None:\n",
-    "    print(\"TensorFlow saved model bundle\")\n",
-    "    tf_weights_src = model.weights.keras_hdf5.download().path\n",
-    "    print(f\"The model weights are stored in {tf_weights_src}.\")\n",
-    "    print()\n",
-    "    print(model.weights.tensorflow_saved_model_bundle)\n",
-    "    print()\n",
-    "if model.weights.onnx is not None:\n",
-    "    print(\"ONNX\")\n",
-    "    onnx_weights_src = model.weights.onnx.download().path\n",
-    "    print(f\"The model weights are stored in {onnx_weights_src}.\")\n",
-    "    print()\n",
-    "    print(model.weights.onnx)\n",
+    "for w in [(weights := model.weights).onnx, weights.keras_hdf5, weights.tensorflow_js, weights.tensorflow_saved_model_bundle, weights.torchscript,weights.pytorch_state_dict]:\n",
+    "    if w is  None:\n",
+    "        continue\n",
+    "\n",
+    "    print(w.weights_format_name)\n",
+    "    print(f\"weights are available at {w.source.absolute()}\")\n",
+    "    print(f\"and have a SHA-256 value of {w.sha256}\")\n",
+    "    details = {k: v for k, v in w.model_dump(mode=\"json\", exclude_none=True).items() if k not in (\"source\", \"sha256\")}\n",
+    "    if details:\n",
+    "        print(f\"additonal metadata for {w.weights_format_name}:\")\n",
+    "        pprint(details)\n",
+    "\n",
     "    print()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 4.2 Inspect expected inputs and outputs of the model"
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": 146,
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(f\"Model '{model.name}' requires {len(model.inputs)} input(s) with the following features:\")\n",
+    "for ipt in model.inputs:\n",
+    "    print(f\"\\ninput '{ipt.id}' with axes:\")\n",
+    "    pprint(ipt.axes)\n",
+    "    print(f\"Data description: {ipt.data}\")\n",
+    "    print(f\"Test tensor available at:  {ipt.test_tensor.source.absolute()}\")\n",
+    "    if len(ipt.preprocessing) > 1:\n",
+    "        print(\"This input is preprocessed with: \")\n",
+    "        for p in ipt.preprocessing:\n",
+    "            print(p)\n",
+    "\n",
+    "print(\"\\n-------------------------------------------------------------------------------\")\n",
+    "# # and what the model outputs are\n",
+    "print(f\"Model '{model.name}' requires {len(model.outputs)} output(s) with the following features:\")\n",
+    "for out in model.outputs:\n",
+    "    print(f\"\\noutput '{out.id}' with axes:\")\n",
+    "    pprint(out.axes)\n",
+    "    print(f\"Data description: {out.data}\")\n",
+    "    print(f\"Test tensor available at:  {out.test_tensor.source.absolute()}\")\n",
+    "    if len(out.postprocessing) > 1:\n",
+    "        print(\"This output is postprocessed with: \")\n",
+    "        for p in out.postprocessing:\n",
+    "            print(p)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "The model requires 1 input(s) with the following features:\n",
-      "\n",
-      "[BatchAxis(id='batch', description='', type='batch', size=None),\n",
-      " ChannelAxis(id='channel', description='', type='channel', channel_names=['channel0']),\n",
-      " SpaceInputAxis(size=ParameterizedSize(min=64, step=16), id='y', description='', type='space', unit=None, scale=1.0, concatenable=False),\n",
-      " SpaceInputAxis(size=ParameterizedSize(min=64, step=16), id='x', description='', type='space', unit=None, scale=1.0, concatenable=False)]\n",
-      "\n",
-      "Expected shape for the input image: (1, 1, 256, 256)\n",
-      "\n",
-      "It is expected to be processed with: \n",
-      "id='ensure_dtype' kwargs=EnsureDtypeKwargs(dtype='uint8')\n",
-      "id='zero_mean_unit_variance' kwargs=ZeroMeanUnitVarianceKwargs(axes=['channel', 'y', 'x'], eps=1e-06)\n",
-      "-------------------------------------------------------------------------------\n",
-      "The model requires 1 output(s) with the following features:\n",
-      "\n",
-      "[BatchAxis(id='batch', description='', type='batch', size=None),\n",
-      " ChannelAxis(id='channel', description='', type='channel', channel_names=['channel0', 'channel1']),\n",
-      " SpaceOutputAxisWithHalo(halo=16, size=SizeReference(tensor_id='input0', axis_id='y', offset=0), id='y', description='', type='space', unit=None, scale=1.0),\n",
-      " SpaceOutputAxisWithHalo(halo=16, size=SizeReference(tensor_id='input0', axis_id='x', offset=0), id='x', description='', type='space', unit=None, scale=1.0)]\n",
-      "\n",
-      "Expected shape for the input image: (1, 2, 256, 256)\n"
-     ]
-    }
-   ],
    "source": [
-    "# or what inputs the model expects\n",
-    "print(f\"The model requires {len(model.inputs)} input(s) with the following features:\")\n",
-    "print()\n",
-    "for inp in range(len(model.inputs)):\n",
-    "    pprint(model.inputs[inp].axes)\n",
-    "    test_input_path = model.inputs[inp].test_tensor.download().path\n",
-    "    test_input_array = np.load(test_input_path)\n",
-    "    print()\n",
-    "    print(f\"Expected shape for the input image: {test_input_array.shape}\")\n",
-    "    if len(model.inputs[inp].preprocessing)>1:\n",
-    "        print()\n",
-    "        print(f\"It is expected to be processed with: \")\n",
-    "        for i in range(len(model.inputs[inp].preprocessing)-1):\n",
-    "            print(f\"{model.inputs[inp].preprocessing[i]}\")\n",
+    "### 4.3 Inspect model architecture\n",
+    "\n",
+    "(inspection in this notebook only implemented for pytorch state dict weights)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from typing_extensions import assert_never\n",
+    "\n",
+    "from bioimageio.spec.model.v0_5 import ArchitectureFromLibraryDescr, ArchitectureFromFileDescr\n",
     "\n",
-    "print(\"-------------------------------------------------------------------------------\")\n",
-    "# and what the model outputs are\n",
-    "print(f\"The model requires {len(model.outputs)} output(s) with the following features:\")\n",
-    "print()\n",
-    "for out in range(len(model.outputs)):\n",
-    "    pprint(model.outputs[out].axes)\n",
-    "    test_output_path = model.outputs[out].test_tensor.download().path\n",
-    "    test_output_array = np.load(test_output_path)\n",
-    "    print()\n",
-    "    print(f\"Expected shape for the input image: {test_output_array.shape}\")\n",
+    "assert isinstance(model, ModelDescr)\n",
+    "if (w:=model.weights.pytorch_state_dict) is not None:\n",
+    "    arch = w.architecture\n",
+    "    print(f\"callable: {arch.callable}\")\n",
+    "    if isinstance(arch, ArchitectureFromFileDescr):\n",
+    "        print(f\"import from file: {arch.source.absolute()}\")\n",
+    "        if arch.sha256 is not None:\n",
+    "            print(f\"SHA-256: {arch.sha256}\")\n",
+    "    elif isinstance(arch, ArchitectureFromLibraryDescr):\n",
+    "        print(f\"import from module: {arch.import_from}\")\n",
+    "    else:\n",
+    "        assert_never(arch)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 4.4 Inspect it all!\n",
     "\n",
-    "    if len(model.outputs[out].postprocessing)>1:\n",
-    "        print()\n",
-    "        print(f\"It is expected to be postprocessed with: \")\n",
-    "        for i in range(len(model.outputs[out].postprocessing)-1):\n",
-    "            print(f\"{model.outputs[out].postprocessing[i]}\")"
+    "Of course we can also inspect the model description in full detail...\n",
+    "(which is a lot of text and the reason we have a `ModelDescr` object in the first place that keeps this metadata more organized)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pprint(model)"
    ]
   },
   {
@@ -594,60 +390,21 @@
     "\n",
     "Let's recreate a model based on parts of the loaded model description from above!\n",
     "\n",
-    "Creating a model description in Python means creating a `ModelDescr` object compatible with the BioImnageIO Model Spec. This allows sharing the model via the BioImage Model Zoo or deploy it in the community partner software.\n",
+    "Creating a model description with bioimageio.spec means creating a `bioimageio.spec.model.ModelDescr` object. This description object can be exportet and uploaded to the BioImage Model Zoo or deployed directly with community partner software.\n",
     "\n",
     "\n",
-    "Without any input data, the class `ModelDescr` will raise a `ValidationError` listing missing required fields:"
+    "Without any input data, initializing a `ModelDescr` will raise a `ValidationError` listing missing required fields:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 152,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "9 validation errors for bioimage.io model specification\n",
-      "name\n",
-      "  Field required [type=missing, input_value={'format_version': '0.5.0', 'type': 'model'}, input_type=dict]\n",
-      "    For further information visit https://errors.pydantic.dev/2.7/v/missing\n",
-      "description\n",
-      "  Field required [type=missing, input_value={'format_version': '0.5.0', 'type': 'model'}, input_type=dict]\n",
-      "    For further information visit https://errors.pydantic.dev/2.7/v/missing\n",
-      "authors\n",
-      "  Field required [type=missing, input_value={'format_version': '0.5.0', 'type': 'model'}, input_type=dict]\n",
-      "    For further information visit https://errors.pydantic.dev/2.7/v/missing\n",
-      "cite\n",
-      "  Field required [type=missing, input_value={'format_version': '0.5.0', 'type': 'model'}, input_type=dict]\n",
-      "    For further information visit https://errors.pydantic.dev/2.7/v/missing\n",
-      "license\n",
-      "  Field required [type=missing, input_value={'format_version': '0.5.0', 'type': 'model'}, input_type=dict]\n",
-      "    For further information visit https://errors.pydantic.dev/2.7/v/missing\n",
-      "documentation\n",
-      "  Field required [type=missing, input_value={'format_version': '0.5.0', 'type': 'model'}, input_type=dict]\n",
-      "    For further information visit https://errors.pydantic.dev/2.7/v/missing\n",
-      "inputs\n",
-      "  Field required [type=missing, input_value={'format_version': '0.5.0', 'type': 'model'}, input_type=dict]\n",
-      "    For further information visit https://errors.pydantic.dev/2.7/v/missing\n",
-      "outputs\n",
-      "  Field required [type=missing, input_value={'format_version': '0.5.0', 'type': 'model'}, input_type=dict]\n",
-      "    For further information visit https://errors.pydantic.dev/2.7/v/missing\n",
-      "weights\n",
-      "  Field required [type=missing, input_value={'format_version': '0.5.0', 'type': 'model'}, input_type=dict]\n",
-      "    For further information visit https://errors.pydantic.dev/2.7/v/missing\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "from bioimageio.spec.common import ValidationError\n",
     "from bioimageio.spec.model.v0_5 import ModelDescr\n",
     "\n",
-    "try:\n",
-    "    my_model_descr = ModelDescr()  # type: ignore\n",
-    "except ValidationError as e:\n",
-    "    print(e)"
+    "_ = ModelDescr()  # pyright: ignore[reportCallIssue]"
    ]
   },
   {
@@ -661,63 +418,46 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 175,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Input description loaded\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from bioimageio.spec.model.v0_5 import (\n",
-    "    Author,\n",
     "    AxisId,\n",
     "    BatchAxis,\n",
     "    ChannelAxis,\n",
-    "    CiteEntry,\n",
-    "    Doi,\n",
     "    FileDescr,\n",
     "    Identifier,\n",
     "    InputTensorDescr,\n",
     "    IntervalOrRatioDataDescr,\n",
-    "    ModelDescr,\n",
-    "    OutputTensorDescr,\n",
     "    ParameterizedSize,\n",
-    "    PytorchStateDictWeightsDescr,\n",
-    "    SizeReference,\n",
     "    SpaceInputAxis,\n",
     "    SpaceOutputAxis,\n",
     "    TensorId,\n",
-    "    TorchscriptWeightsDescr,\n",
     "    WeightsDescr,\n",
     ")\n",
     "\n",
     "input_axes = [\n",
     "    BatchAxis(),\n",
     "    ChannelAxis(channel_names=[Identifier(\"raw\")])]\n",
-    "if len(model.inputs[0].axes)==5: #example_model_id == \"impartial-shrimp\":\n",
+    "if len(model.inputs[0].axes)==5: # e.g. impartial-shrimp\n",
     "    input_axes += [\n",
     "        SpaceInputAxis(id=AxisId(\"z\"), size=ParameterizedSize(min=16, step=8)),\n",
     "        SpaceInputAxis(id=AxisId('y'), size=ParameterizedSize(min=144, step=72)),\n",
     "        SpaceInputAxis(id=AxisId('x'), size=ParameterizedSize(min=144, step=72)),\n",
     "    ]\n",
-    "    data_descr = IntervalOrRatioDataDescr(type=model.inputs[0].data.type)\n",
-    "elif len(model.inputs[0].axes)==4: #example_model_id == \"pioneering-rhino\":\n",
+    "    data_descr = IntervalOrRatioDataDescr(type=\"float32\")\n",
+    "elif len(model.inputs[0].axes)==4: # e.g. pioneering-rhino\n",
     "    input_axes += [\n",
     "        SpaceInputAxis(id=AxisId('y'), size=ParameterizedSize(min=256, step=8)),\n",
     "        SpaceInputAxis(id=AxisId('x'), size=ParameterizedSize(min=256, step=8)),\n",
     "    ]\n",
-    "    data_descr = IntervalOrRatioDataDescr(type=model.inputs[0].data.type)\n",
+    "    data_descr = IntervalOrRatioDataDescr(type=\"float32\")\n",
     "else:\n",
     "    raise NotImplementedError(f\"Recreating inputs for {example_model_id} is not implemented\")\n",
-    "    \n",
-    "test_input_path = model.inputs[inp].test_tensor.download().path\n",
-    "input_descr = InputTensorDescr(id=TensorId(\"raw\"), axes=input_axes, test_tensor=FileDescr(source=test_input_path), data=data_descr)\n",
-    "print(\"Input description loaded\")"
+    "\n",
+    "test_input_path = model.inputs[0].test_tensor.download().path\n",
+    "input_descr = InputTensorDescr(id=TensorId(\"raw\"), axes=input_axes, test_tensor=FileDescr(source=test_input_path), data=data_descr)"
    ]
   },
   {
@@ -729,38 +469,32 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 187,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Output description loaded\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
+    "from bioimageio.spec.model.v0_5 import OutputTensorDescr, SizeReference\n",
+    "\n",
+    "assert isinstance(model.outputs[0].axes[1], ChannelAxis)\n",
     "output_axes = [\n",
     "    BatchAxis(),\n",
     "    ChannelAxis(channel_names=[Identifier(n) for n in model.outputs[0].axes[1].channel_names])]\n",
-    "if len(model.outputs[0].axes) == 5: #example_model_id == \"impartial-shrimp\":\n",
+    "if len(model.outputs[0].axes) == 5: # e.g. impartial-shrimp\n",
     "    output_axes += [\n",
-    "        SpaceOutputAxis(id=AxisId(\"z\"), size=ParameterizedSize(min=16, step=8)),  # implicitly same size as raw.z as it is parametrized the same.\n",
-    "        SpaceOutputAxis(id=AxisId('y'), size=ParameterizedSize(min=144, step=72)),\n",
-    "        SpaceOutputAxis(id=AxisId('x'), size=ParameterizedSize(min=144, step=72))\n",
+    "        SpaceOutputAxis(id=AxisId(\"z\"), size=SizeReference(tensor_id=TensorId(\"raw\"), axis_id=AxisId(\"z\"))),\n",
+    "        SpaceOutputAxis(id=AxisId('y'), size=SizeReference(tensor_id=TensorId(\"raw\"), axis_id=AxisId(\"y\"))),\n",
+    "        SpaceOutputAxis(id=AxisId('x'), size=SizeReference(tensor_id=TensorId(\"raw\"), axis_id=AxisId(\"x\")))\n",
     "    ]\n",
-    "elif len(model.outputs[0].axes) == 4: #example_model_id == \"pioneering-rhino\":\n",
+    "elif len(model.outputs[0].axes) == 4: # e.g. pioneering-rhino\n",
     "    output_axes += [\n",
-    "        SpaceOutputAxis(id=AxisId(\"y\"), size=SizeReference(tensor_id=TensorId('raw'), axis_id=AxisId('y'))),  # explicitly same size as raw.y\n",
+    "        SpaceOutputAxis(id=AxisId(\"y\"), size=SizeReference(tensor_id=TensorId('raw'), axis_id=AxisId('y'))),\n",
     "        SpaceOutputAxis(id=AxisId(\"x\"), size=SizeReference(tensor_id=TensorId('raw'), axis_id=AxisId('x'))),\n",
     "    ]\n",
     "else:\n",
     "    raise NotImplementedError(f\"Recreating outputs for {example_model_id} is not implemented\")\n",
-    "    \n",
+    "\n",
     "test_output_path = model.outputs[0].test_tensor.download().path\n",
-    "output_descr = OutputTensorDescr(id=TensorId(\"prob\"), axes=output_axes, test_tensor=FileDescr(source=test_output_path))\n",
-    "print(\"Output description loaded\")"
+    "output_descr = OutputTensorDescr(id=TensorId(\"prob\"), axes=output_axes, test_tensor=FileDescr(source=test_output_path))"
    ]
   },
   {
@@ -773,7 +507,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 188,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -791,24 +525,29 @@
     "    pytorch_version = Version(torch.__version__)\n",
     "\n",
     "## Recover the architecture information from the original model\n",
-    "if model.weights.pytorch_state_dict is not None:\n",
-    "    arch = model.weights.pytorch_state_dict.architecture\n",
-    "    if isinstance(arch, ArchitectureFromFileDescr):\n",
-    "        arch_file_path = download(arch.source, sha256=arch.sha256).path\n",
-    "        arch_file_sha256 = arch.sha256\n",
-    "        arch_name = arch.callable\n",
-    "        arch_kwargs = arch.kwargs \n",
-    "\n",
-    "\n",
-    "pytorch_architecture = ArchitectureFromFileDescr(\n",
-    "    source=arch_file_path,\n",
-    "    sha256=arch_file_sha256,\n",
-    "    callable=arch_name,\n",
-    "    kwargs=arch_kwargs\n",
-    ")\n",
-    "# A model architecture published as a package may also be referenced\n",
-    "# Make sure to include the library referenced in `import_from` in the `depdendencies`\n",
-    "my_unused_arch = ArchitectureFromLibraryDescr(callable=Identifier(\"MyModel\"), import_from=\"my_library.subpackage\")\n"
+    "assert model.weights.pytorch_state_dict is not None\n",
+    "\n",
+    "arch = model.weights.pytorch_state_dict.architecture\n",
+    "if isinstance(arch, ArchitectureFromFileDescr):\n",
+    "    arch_file_path = download(arch.source, sha256=arch.sha256).path\n",
+    "    arch_file_sha256 = arch.sha256\n",
+    "    arch_name = arch.callable\n",
+    "    arch_kwargs = arch.kwargs\n",
+    "\n",
+    "    pytorch_architecture = ArchitectureFromFileDescr(\n",
+    "        source=arch_file_path,\n",
+    "        sha256=arch_file_sha256,\n",
+    "        callable=arch_name,\n",
+    "        kwargs=arch_kwargs\n",
+    "    )\n",
+    "else:\n",
+    "    # For a model architecture that is published in a Python package\n",
+    "    # Make sure to include the Python library referenced in `import_from` in the weights entry's `depdendencies`\n",
+    "    pytorch_architecture = ArchitectureFromLibraryDescr(\n",
+    "        callable=arch.callable,\n",
+    "        kwargs=arch.kwargs,\n",
+    "        import_from=arch.import_from,\n",
+    "    )\n"
    ]
   },
   {
@@ -820,28 +559,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 209,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\u001b[32m2024-05-07 17:17:47.661\u001b[0m | Level 30\u001b[0m | \u001b[36mbioimageio.spec._internal.field_warning\u001b[0m:\u001b[36missue_warning\u001b[0m:\u001b[36m149\u001b[0m - documentation: No '# Validation' (sub)section found in https://raw.githubusercontent.com/bioimage-io/spec-bioimage-io/main/README.md.\u001b[0m\n",
-      "\u001b[32m2024-05-07 17:17:47.673\u001b[0m | Level 30\u001b[0m | \u001b[36mbioimageio.spec._internal.field_warning\u001b[0m:\u001b[36missue_warning\u001b[0m:\u001b[36m149\u001b[0m - covers: Failed to generate cover image(s): Failed to construct cover image from shape (1, 2, 256, 256)\u001b[0m\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "created '{my_model_descr.name}'\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "from bioimageio.spec.model.v0_5 import LicenseId\n",
+    "from bioimageio.spec.model.v0_5 import  Author, CiteEntry, Doi, HttpUrl, LicenseId, PytorchStateDictWeightsDescr, TorchscriptWeightsDescr\n",
     "\n",
+    "assert model.weights.pytorch_state_dict is not None\n",
+    "assert model.weights.torchscript is not None\n",
     "my_model_descr = ModelDescr(\n",
     "    name=\"My cool model\",\n",
     "    description=\"A test model for demonstration purposes only\",\n",
@@ -850,23 +575,26 @@
     "    license=LicenseId(\"MIT\"),\n",
     "    documentation=HttpUrl(\"https://raw.githubusercontent.com/bioimage-io/spec-bioimage-io/main/README.md\"),\n",
     "    git_repo=HttpUrl(\"https://github.com/bioimage-io/spec-bioimage-io\"),  # change to repo where your model is developed\n",
-    "    inputs=[input_descr],\n",
-    "    outputs=[output_descr],\n",
-    "    #covers = [download(model.covers[0]).path],\n",
+    "    inputs=model.inputs,\n",
+    "    # inputs=[input_descr],  # try out our recreated input description\n",
+    "    outputs=model.outputs,\n",
+    "    # outputs=[output_descr],  # try out our recreated input description\n",
     "    weights=WeightsDescr(\n",
     "        pytorch_state_dict=PytorchStateDictWeightsDescr(\n",
-    "            source=pytorch_state_dict_weights_src,\n",
+    "            source=model.weights.pytorch_state_dict.source,\n",
+    "            sha256=model.weights.pytorch_state_dict.sha256,\n",
     "            architecture=pytorch_architecture,\n",
     "            pytorch_version=pytorch_version\n",
     "        ),\n",
     "        torchscript=TorchscriptWeightsDescr(\n",
-    "            source=torchscript_weights_src,\n",
+    "            source=model.weights.torchscript.source,\n",
+    "            sha256=model.weights.torchscript.sha256,\n",
     "            pytorch_version=pytorch_version,\n",
     "            parent=\"pytorch_state_dict\", # these weights were converted from the pytorch_state_dict weights ones.\n",
     "        ),\n",
     "    ),\n",
     "    )\n",
-    "print(\"created '{my_model_descr.name}'\")\n"
+    "print(f\"created '{my_model_descr.name}'\")\n"
    ]
   },
   {
@@ -874,37 +602,24 @@
    "metadata": {},
    "source": [
     "### 5.5. Covers\n",
-    "Some optional fields were filed with default values,e.g., `covers`, as we did not specify them. When possible, default visualization of the test inputs and test outputs was used. When the input or the output have more than one channel, the covers are empty and need to be generated and included.\n",
-    "\n",
-    "To reuse the cover from the previous model, one can raun the following code to get the path to it:\n",
-    "```python\n",
-    "from bioimageio.spec.utils import download\n",
+    "Some optional fields were filed with default values, e.g., we did not specify `covers`. \n",
+    "When possible, a default visualization of the test inputs and test outputs is generated.\n",
+    "When the input or the output have more than one channel, the current implementation cannot generate a cover image automatically.\n",
     "\n",
-    "cover_path = download(model.covers[0]).path\n",
-    "```"
+    "Automatically generated cover images:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 208,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "for cover in my_model_descr.covers:\n",
-    "    plt.imshow(imread(cover))\n",
-    "    plt.xticks([])\n",
-    "    plt.yticks([])\n",
+    "    img: NDArray[Any] = imread(download(cover).path)\n",
+    "    _ = plt.imshow(img)\n",
+    "    plt.xticks([])  # type: ignore\n",
+    "    plt.yticks([])  # type: ignore\n",
     "    plt.show()"
    ]
   },
@@ -919,39 +634,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 213,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "✔️ bioimageio validation: passed\n",
-       "\n",
-       "source: https://uk1s3.embassy.ebi.ac.uk/public-datasets/bioimage.io/affable-shark/1/files/bioimageio.yaml\n",
-       "|     package     |  version   |\n",
-       "|       ---       |    ---     |\n",
-       "| bioimageio.spec | 0.5.2post3 |\n",
-       "\n",
-       "\n",
-       "|  ❓  |                  location                 |                                                                       detail                                                                       |\n",
-       "| --- |                    ---                    |                                                                        ---                                                                         |\n",
-       "| ✔️  |                                           | initialized model 0.4.10                                                                                                                           |\n",
-       "| ✔️  |                                           | bioimageio.spec format validation model 0.4.10                                                                                                     |\n",
-       "| ⚠   | `weights.pytorch_state_dict.dependencies` | Custom dependencies (conda:environment.yaml) specified. Avoid this whenever possible to allow execution in a wider range of software environments. |\n",
-       "|     |                                           |                                                                                                                                                    |\n",
-       "| ✔️  |                                           | initialized model 0.5.0                                                                                                                            |\n",
-       "| ✔️  |                                           | bioimageio.spec format validation model 0.5.0                                                                                                      |\n",
-       "| ⚠   | `documentation`                           | No '# Validation' (sub)section found in documentation.md.                                                                                          |\n",
-       "|     |                                           |                                                                                                                                                    |\n"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "model.validation_summary.display()"
    ]
@@ -963,7 +648,7 @@
     "### 6.2 Dynamic validation\n",
     "\n",
     "If you have the `bioimageio.core` library installed, you can run the dynamic validation and test if the model is correct and properly producing the test output image from the test input image. \n",
-    "Otherwise, skip this cell."
+    "This extends the validation summary from above:"
    ]
   },
   {
@@ -973,6 +658,7 @@
    "outputs": [],
    "source": [
     "from bioimageio.core import test_model\n",
+    "\n",
     "summary = test_model(my_model_descr)\n",
     "summary.display()"
    ]
@@ -988,17 +674,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 214,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "package path: my_model.zip\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from pathlib import Path\n",
     "\n",
@@ -1024,7 +702,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.0"
+   "version": "3.8.17"
   }
  },
  "nbformat": 4,
diff --git a/setup.py b/setup.py
index 18b722ef2..3de60e498 100644
--- a/setup.py
+++ b/setup.py
@@ -60,6 +60,7 @@
             "pyright",
             "pytest-xdist",  # parallel pytest
             "pytest",
+            "python-devtools",
             "ruff",  # check line length in cases black cannot fix it
         ]
     },
diff --git a/tests/test_internal/test_io.py b/tests/test_internal/test_io.py
index 2335da45e..fe0cbf3fe 100644
--- a/tests/test_internal/test_io.py
+++ b/tests/test_internal/test_io.py
@@ -54,8 +54,8 @@ def test_interprete_file_source_from_str():
     with ValidationContext(root=Path(__file__).parent.parent):
         interpreted = interprete_file_source(src)
         assert isinstance(interpreted, RelativeFilePath)
-        assert isinstance(interpreted.absolute, Path)
-        assert interpreted.absolute.exists()
+        assert isinstance(interpreted.absolute(), Path)
+        assert interpreted.absolute().exists()
 
 
 def test_interprete_file_source_from_rel_path():
@@ -68,8 +68,8 @@ def test_interprete_file_source_from_rel_path():
 
     interpreted = interprete_file_source(src)
     assert isinstance(interpreted, RelativeFilePath)
-    assert isinstance(interpreted.absolute, Path)
-    assert interpreted.absolute.exists()
+    assert isinstance(interpreted.absolute(), Path)
+    assert interpreted.absolute().exists()
 
 
 def test_known_files(tmp_path: Path):