From b446b0413d57e0e7bd053b7a4acdbaaf4d55a938 Mon Sep 17 00:00:00 2001 From: d33bs Date: Wed, 1 Oct 2025 08:59:29 -0600 Subject: [PATCH 1/5] add ome-arrow mvp --- pyproject.toml | 8 ++ src/serpula_rasa/image.py | 258 ++++++++++++++++++++++++++++++++++++++ src/serpula_rasa/meta.py | 108 ++++++++++++++++ tests/test_image.py | 81 ++++++++++++ uv.lock | 46 ++++++- 5 files changed, 499 insertions(+), 2 deletions(-) create mode 100644 src/serpula_rasa/image.py create mode 100644 src/serpula_rasa/meta.py create mode 100644 tests/test_image.py diff --git a/pyproject.toml b/pyproject.toml index 512bae0..8443926 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -40,6 +40,9 @@ version_scheme = "no-guess-dev" local_scheme = "no-local-version" version_file = "src/serpula_rasa/_version.py" +[tool.setuptools.packages.find] +where = ["src"] + [tool.ruff] target-version = "py311" line-length = 88 @@ -88,3 +91,8 @@ formats = "ipynb,py:light" [tool.vulture] min_confidence = 90 paths = [ "src/serpula_rasa" ] + +[dependency-groups] +dev = [ + "pytest>=8.4.2", +] diff --git a/src/serpula_rasa/image.py b/src/serpula_rasa/image.py new file mode 100644 index 0000000..686f6d6 --- /dev/null +++ b/src/serpula_rasa/image.py @@ -0,0 +1,258 @@ +""" +Image utility functions. +""" + +from __future__ import annotations + +from dataclasses import dataclass +from datetime import datetime, timezone +from typing import Iterable, List, Mapping, Optional, Sequence, Tuple + +import numpy as np +from typing import Mapping, Any +import numpy as np +import pyarrow as pa +import pyarrow.parquet as pq + +from serpula_rasa.meta import OME_ARROW_SCHEMA, OME_DTYPE_MAP, OME_ARROW_TAG_TYPE, OME_ARROW_TAG_VERSION + +@dataclass +class ChannelMeta: + """Minimal, practical channel metadata for profiling workflows.""" + id: str + name: str + emission_um: Optional[float] = None + excitation_um: Optional[float] = None + illumination: Optional[str] = None + color_rgba: Optional[int] = None # preferred display color (packed RGBA) + +def _default_channels(C: int) -> List[ChannelMeta]: + return [ChannelMeta(id=f"C{c}", name=f"Channel-{c}") for c in range(C)] + +def _normalize_to_TCZYX(arr: np.ndarray) -> Tuple[int, int, int, int, int, np.ndarray]: + """ + Accept common shapes and normalize to (T, C, Z, Y, X). + Accepted: (Y,X), (C,Y,X), (Z,Y,X), (C,Z,Y,X), (T,C,Y,X), (T,C,Z,Y,X) + Heuristics: + • For 3D, small first dim (<=8) ⇒ channels; otherwise z-slices. + • For 4D, if last two look spatial and the 2nd dim small (<=8) ⇒ (T,C,Y,X). + """ + if arr.ndim == 2: # (Y, X) + Y, X = arr.shape + return (1, 1, 1, Y, X, arr[None, None, None, :, :]) + + if arr.ndim == 3: + a, b, c = arr.shape + if a <= 8: # (C, Y, X) + C, Y, X = a, b, c + return (1, C, 1, Y, X, arr[None, :, None, :, :]) + else: # (Z, Y, X) + Z, Y, X = a, b, c + return (1, 1, Z, Y, X, arr[None, None, :, :, :]) + + if arr.ndim == 4: + A, B, C_, D_ = arr.shape + if C_ > 16 and D_ > 16 and B <= 8: # (T, C, Y, X) + T, C, Y, X = A, B, C_, D_ + return (T, C, 1, Y, X, arr[:, :, None, :, :]) + # (C, Z, Y, X) + C, Z, Y, X = A, B, C_, D_ + return (1, C, Z, Y, X, arr[None, :, :, :, :]) + + if arr.ndim == 5: # (T, C, Z, Y, X) + T, C, Z, Y, X = arr.shape + return (T, C, Z, Y, X, arr) + + raise ValueError("Expected (Y,X),(C,Y,X),(Z,Y,X),(C,Z,Y,X),(T,C,Y,X),(T,C,Z,Y,X).") + +def _coerce_pixel_dtype(arr5: np.ndarray) -> Tuple[np.ndarray, str]: + """Keep numeric pixels in a widely-supported dtype; default to uint16.""" + dt = arr5.dtype + if dt not in OME_DTYPE_MAP: + if np.issubdtype(dt, np.floating): + arr5 = arr5.astype(np.uint16, copy=False) + dt = arr5.dtype + else: + arr5 = arr5.astype(np.uint16, copy=False) + dt = arr5.dtype + return arr5, OME_DTYPE_MAP[np.dtype(dt)] + + +def make_ome_arrow_row( + *, + image_id: str, + name: str, + pixels: np.ndarray, # XY or XYZ (+ optional C/T) + channel_meta: Optional[Sequence[ChannelMeta]] = None, + physical_size_xy_um: float = 0.108, # microscope pixel size (µm/px) + physical_size_z_um: float = 1.0, # z-step (µm) + physical_unit: str = "µm", + prefer_dimension_order_xyzct: bool = True, # if Z==1 and False → "XYCT" + acquisition_dt: Optional[datetime] = None, +) -> Mapping[str, object]: + """ + Build ONE 'ome_arrow' struct (ONE image per row). + - Pixels remain numeric (no PNG/JPEG), ready for analysis. + - Planes are 2D slices per (t,c,z), flattened to Y*X for compact storage. + """ + # Normalize to (T,C,Z,Y,X) and pick storage dtype + T, C, Z, Y, X, arr5 = _normalize_to_TCZYX(pixels) + arr5, pixel_type_str = _coerce_pixel_dtype(arr5) + + # Channels metadata (default label if none supplied) + channels = list(channel_meta or _default_channels(C)) + if len(channels) != C: + raise ValueError(f"channel_meta length {len(channels)} != C {C}") + channels_field = [ + { + "id": ch.id, + "name": ch.name, + "emission_um": ch.emission_um, + "excitation_um": ch.excitation_um, + "illumination": ch.illumination, + "color_rgba": ch.color_rgba, + } + for ch in channels + ] + + # Dimension order string (human hint) + dimension_order = "XYZCT" if (Z > 1 or prefer_dimension_order_xyzct) else "XYCT" + + # Assemble per-plane numeric pixels (one entry per (t,c,z)) + planes: List[Mapping[str, object]] = [] + for t in range(T): + for c in range(C): + for z in range(Z): + plane = arr5[t, c, z] # (Y, X) + planes.append({ + "z": z, + "t": t, + "c": c, + "pixels": plane.reshape(-1).astype(np.uint16).tolist(), + }) + + pixels_meta = { + "dimension_order": dimension_order, + "type": pixel_type_str, + "size_x": int(X), "size_y": int(Y), "size_z": int(Z), + "size_c": int(C), "size_t": int(T), + "physical_size_x": float(physical_size_xy_um), + "physical_size_y": float(physical_size_xy_um), + "physical_size_z": float(physical_size_z_um), + "physical_size_x_unit": physical_unit, + "physical_size_y_unit": physical_unit, + "physical_size_z_unit": physical_unit, + "channels": channels_field, + } + + return { + "ome_arrow": { + "type": OME_ARROW_TAG_TYPE, + "version": OME_ARROW_TAG_VERSION, + "id": image_id, + "name": name, + "acquisition_datetime": acquisition_dt or datetime.now(timezone.utc), + "pixels_meta": pixels_meta, + "planes": planes, + "masks": None, + } + } + + +def validate_ome_arrow_table(table: pa.Table) -> None: + """ + Validate the table matches OME_ARROW_SCHEMA and rows carry the correct tags. + Raises ValueError on mismatch. + """ + if table.schema.types != OME_ARROW_SCHEMA.types or table.schema.names != OME_ARROW_SCHEMA.names: + raise ValueError("Schema mismatch: table does not match OME_ARROW_SCHEMA.") + col = table["ome_arrow"] + for i in range(len(col)): + rec = col[i].as_py() + if rec.get("type") != OME_ARROW_TAG_TYPE: + raise ValueError(f"Row {i}: type tag != '{OME_ARROW_TAG_TYPE}'") + if rec.get("version") != OME_ARROW_TAG_VERSION: + raise ValueError(f"Row {i}: version tag != '{OME_ARROW_TAG_VERSION}'") + + +def write_ome_arrow_parquet( + rows: Iterable[Mapping[str, object]], + path: str, + row_group_size: int = 1, +) -> None: + """ + Write ome-arrow rows to Parquet with settings tuned for numeric arrays. + """ + table = pa.Table.from_pylist(list(rows), schema=OME_ARROW_SCHEMA) + pq.write_table( + table, + path, + compression="zstd", + use_dictionary=False, + data_page_version="2.0", + row_group_size=row_group_size, # often 1 row = 1 image; batch if desired + ) + + +def read_ome_arrow_first(path: str) -> Mapping[str, object]: + """Quick peek: load the first ome-arrow record (no reshaping).""" + tbl = pq.read_table(path, columns=["ome_arrow"]) + validate_ome_arrow_table(tbl) + return tbl["ome_arrow"][0].as_py() + + + +def reconstruct_tczyx_from_record(rec: Mapping[str, Any]) -> np.ndarray: + """ + Reconstruct a 5D NumPy array (T, C, Z, Y, X) from an in-memory ome_arrow record. + + The `ome_arrow` struct stores image pixel data as a list of per-plane + records (one per timepoint, channel, and z-slice), where each plane + contains a flattened list of Y*X numeric values. This helper function + reassembles those planes into a contiguous 5D NumPy array. + + Parameters + ---------- + rec : Mapping[str, Any] + A single `ome_arrow` record as returned by `.as_py()` from a PyArrow + Table column (i.e., `tbl["ome_arrow"][i].as_py()`). The record must + contain a valid `"pixels_meta"` dict and a list of `"planes"`. + + Returns + ------- + np.ndarray + A NumPy array with shape (T, C, Z, Y, X) and dtype ``np.uint16``. + - T = number of timepoints + - C = number of channels + - Z = number of z-slices (1 for 2D images) + - Y = image height (pixels) + - X = image width (pixels) + + Notes + ----- + • For 2D single-channel images, the returned shape will be (1, 1, 1, Y, X). + • The dtype is fixed to ``np.uint16`` because pixel values are stored that way + in ome-arrow by default. Adjust the coercion logic if you plan to allow + multiple numeric dtypes. + • This function is useful outside of testing, e.g.: + - Feeding the reconstructed array into scikit-image or napari + - Exporting back to OME-TIFF or Zarr + - Performing quantitative analysis with NumPy or PyTorch + + Examples + -------- + >>> tbl = pq.read_table("example_2d_ome_arrow.parquet") + >>> rec = tbl["ome_arrow"][0].as_py() + >>> arr = reconstruct_tczyx_from_record(rec) + >>> arr.shape + (1, 1, 1, 64, 96) + """ + pm = rec["pixels_meta"] + T, C, Z = pm["size_t"], pm["size_c"], pm["size_z"] + Y, X = pm["size_y"], pm["size_x"] + + out = np.empty((T, C, Z, Y, X), dtype=np.uint16) + for pl in rec["planes"]: + t, c, z = pl["t"], pl["c"], pl["z"] + out[t, c, z] = np.asarray(pl["pixels"], dtype=np.uint16).reshape(Y, X) + return out diff --git a/src/serpula_rasa/meta.py b/src/serpula_rasa/meta.py new file mode 100644 index 0000000..3ac1508 --- /dev/null +++ b/src/serpula_rasa/meta.py @@ -0,0 +1,108 @@ +import numpy as np +import pyarrow as pa + +# Column name: "ome_arrow" (single column table) +# Type tag: type="ome.arrow" (quick validation) +# Version tag: "0.0.1" (bump on schema changes) + +OME_ARROW_TAG_TYPE = "ome.arrow" +OME_ARROW_TAG_VERSION = "0.0.1" + +# GLOBAL Arrow types + +# OME_ARROW_STRUCT: ome-arrow record (describes one image/value). +# - type/version: quick identity & evolution. +# - id/name/acquisition_datetime: identity & provenance. +# - pixels_meta: pixels struct (sizes, units, channels). +# - planes: list of planes struct entries, one per (t,c,z). +# - masks: reserved for future labels/ROIs (placeholder). +OME_ARROW_STRUCT: pa.StructType = pa.struct( + [ + pa.field("type", pa.string()), # must be "ome.arrow" + pa.field("version", pa.string()), # e.g., "1.0.0" + pa.field("id", pa.string()), # stable image identifier + pa.field("name", pa.string()), # human label + pa.field("acquisition_datetime", pa.timestamp("us")), + # PIXELS: OME-like "Pixels" header summarizing shape & scale. + # - dimension_order: hint like "XYZCT" (or "XYCT" when Z==1). + # - type: numeric storage type (e.g., "uint16"). + # - size_*: axis lengths. + # - physical_size_* (+ *_unit): microscope scale in micrometers. + # - channels: list of channel struct entries (one per channel). + pa.field( + "pixels_meta", + pa.struct( + [ + pa.field("dimension_order", pa.string()), # "XYZCT" / "XYCT" + pa.field("type", pa.string()), # "uint8","uint16","float",... + pa.field("size_x", pa.int32()), # width (pixels) + pa.field("size_y", pa.int32()), # height (pixels) + pa.field("size_z", pa.int32()), # z-slices (1 for 2D) + pa.field("size_c", pa.int16()), # channels + pa.field("size_t", pa.int32()), # time points + pa.field("physical_size_x", pa.float32()), # µm per pixel (X) + pa.field("physical_size_y", pa.float32()), # µm per pixel (Y) + pa.field("physical_size_z", pa.float32()), # µm per z-step + pa.field("physical_size_x_unit", pa.string()), # usually "µm" + pa.field("physical_size_y_unit", pa.string()), + pa.field("physical_size_z_unit", pa.string()), + + pa.field( + "channels", + pa.list_( + # CHANNELS: one entry per channel (e.g., DNA, Mito, ER). + # - emission_um / excitation_um: wavelengths (micrometers) for context. + # - illumination: modality (e.g., "Epifluorescence"). + # - color_rgba: preferred display color (packed 0xRRGGBBAA). + pa.struct( + [ + pa.field("id", pa.string()), + pa.field("name", pa.string()), + pa.field("emission_um", pa.float32()), + pa.field("excitation_um", pa.float32()), + pa.field("illumination", pa.string()), + pa.field("color_rgba", pa.uint32()), + ] + ) + ), + ), + ] + ), + ), + # PLANES: one 2D image plane for a specific (t, c, z). + # - pixels: flattened numeric list (Y*X) for analysis-ready computation. + pa.field( + "planes", + pa.list_( + pa.struct( + [ + pa.field("z", pa.int32()), + pa.field("t", pa.int32()), + pa.field("c", pa.int16()), + pa.field( + "pixels", pa.list_(pa.uint16()) + ), # keep numeric (not PNG/JPEG) + ] + ) + ), + ), + pa.field("masks", pa.null()), # reserved for future annotations + ] +) + +# OME_ARROW_SCHEMA: a one-column table named 'ome_arrow' holding the struct. +OME_ARROW_SCHEMA: pa.Schema = pa.schema([pa.field("ome_arrow", OME_ARROW_STRUCT)]) + + +# ----------------------------------------------------------------------------- +# Builders & IO (unchanged behavior, now referencing the globals above) +# ----------------------------------------------------------------------------- + +OME_DTYPE_MAP = { + np.dtype("uint8"): "uint8", + np.dtype("uint16"): "uint16", + np.dtype("uint32"): "uint32", + np.dtype("int16"): "int16", + np.dtype("float32"): "float", + np.dtype("float64"): "double", +} diff --git a/tests/test_image.py b/tests/test_image.py new file mode 100644 index 0000000..9e144dd --- /dev/null +++ b/tests/test_image.py @@ -0,0 +1,81 @@ +""" +Tests for ome-arrow work +""" + +import numpy as np +import tifffile as tiff +import pyarrow.parquet as pq +import pytest + +# import your ome-arrow helpers/globals +from serpula_rasa.image import ( + make_ome_arrow_row, + write_ome_arrow_parquet, + validate_ome_arrow_table, + reconstruct_tczyx_from_record +) +from serpula_rasa.meta import OME_ARROW_TAG_TYPE, OME_ARROW_TAG_VERSION + +@pytest.mark.parametrize("shape,dtype", [((64, 96), np.uint16), ((32, 48), np.uint8)]) +def test_ome_arrow_roundtrip_from_2d_tiff(tmp_path, shape, dtype): + """ + End-to-end: + 1) write synthetic 2D TIFF + 2) build ome_arrow row (XY only) + 3) write Parquet + 4) read + validate + 5) reconstruct array and compare with source + """ + # 1) synthesize and save a 2D TIFF + src = (np.arange(shape[0] * shape[1], dtype=np.uint32) % np.iinfo(dtype).max).astype(dtype) + src = src.reshape(shape) # (Y, X) + tiff_path = tmp_path / "img.tif" + tiff.imwrite(tiff_path, src) + + # 2) load TIFF and build a single ome_arrow row + img = tiff.imread(tiff_path) # (Y, X), preserves dtype + assert img.shape == shape and img.dtype == dtype + + row = make_ome_arrow_row( + image_id="img_0001", + name="2D TIFF example", + pixels=img, # accepts (Y, X) + physical_size_xy_um=0.108, + physical_size_z_um=1.0, + physical_unit="µm", + prefer_dimension_order_xyzct=False, # use "XYCT" since Z==1 + ) + + # 3) write the row to a Parquet file + parquet_path = tmp_path / "example_2d_ome_arrow.parquet" + write_ome_arrow_parquet([row], parquet_path, row_group_size=1) + assert parquet_path.exists() + + # 4) read back and validate schema + tags + tbl = pq.read_table(parquet_path) + validate_ome_arrow_table(tbl) + col = tbl["ome_arrow"] + assert len(col) == 1 + + rec = col[0].as_py() + assert rec["type"] == OME_ARROW_TAG_TYPE + assert rec["version"] == OME_ARROW_TAG_VERSION + + pm = rec["pixels_meta"] + assert pm["size_z"] == 1 + assert pm["size_c"] == 1 + assert pm["size_t"] == 1 + assert pm["size_y"] == shape[0] + assert pm["size_x"] == shape[1] + # dimension order hint for Z==1 + assert pm["dimension_order"] in ("XYCT", "XYZCT") + + # 5) reconstruct and compare pixels + arr = reconstruct_tczyx_from_record(rec) # (T, C, Z, Y, X) + assert arr.shape == (1, 1, 1, shape[0], shape[1]) + recon = arr[0, 0, 0] # (Y, X) + np.testing.assert_array_equal(recon.astype(dtype), src) + + # quick numeric sanity checks + assert float(recon.mean()) == pytest.approx(float(src.mean())) + assert float(recon.max()) == float(src.max()) diff --git a/uv.lock b/uv.lock index 5649abf..ed64dcf 100644 --- a/uv.lock +++ b/uv.lock @@ -771,6 +771,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/cb/bd/b394387b598ed84d8d0fa90611a90bee0adc2021820ad5729f7ced74a8e2/imageio-2.37.0-py3-none-any.whl", hash = "sha256:11efa15b87bc7871b61590326b2d635439acc321cf7f8ce996f812543ce10eed", size = 315796, upload-time = "2025-01-20T02:42:34.931Z" }, ] +[[package]] +name = "iniconfig" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f2/97/ebf4da567aa6827c909642694d71c9fcf53e5b504f2d96afea02718862f3/iniconfig-2.1.0.tar.gz", hash = "sha256:3abbd2e30b36733fee78f9c7f7308f2d0050e88f0087fd25c2645f63c773e1c7", size = 4793, upload-time = "2025-03-19T20:09:59.721Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2c/e1/e6716421ea10d38022b952c159d5161ca1193197fb744506875fbb87ea7b/iniconfig-2.1.0-py3-none-any.whl", hash = "sha256:9deba5723312380e77435581c6bf4935c94cbfab9b1ed33ef8d238ea168eb760", size = 6050, upload-time = "2025-03-19T20:10:01.071Z" }, +] + [[package]] name = "ipykernel" version = "6.29.5" @@ -1897,6 +1906,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/fe/39/979e8e21520d4e47a0bbe349e2713c0aac6f3d853d0e5b34d76206c439aa/platformdirs-4.3.8-py3-none-any.whl", hash = "sha256:ff7059bb7eb1179e2685604f4aaf157cfd9535242bd23742eadc3c13542139b4", size = 18567, upload-time = "2025-05-07T22:47:40.376Z" }, ] +[[package]] +name = "pluggy" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" }, +] + [[package]] name = "prometheus-client" version = "0.22.0" @@ -2094,6 +2112,22 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/05/e7/df2285f3d08fee213f2d041540fa4fc9ca6c2d44cf36d3a035bf2a8d2bcc/pyparsing-3.2.3-py3-none-any.whl", hash = "sha256:a749938e02d6fd0b59b356ca504a24982314bb090c383e3cf201c95ef7e2bfcf", size = 111120, upload-time = "2025-03-25T05:01:24.908Z" }, ] +[[package]] +name = "pytest" +version = "8.4.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a3/5c/00a0e072241553e1a7496d638deababa67c5058571567b92a7eaa258397c/pytest-8.4.2.tar.gz", hash = "sha256:86c0d0b93306b961d58d62a4db4879f27fe25513d4b969df351abdddb3c30e01", size = 1519618, upload-time = "2025-09-04T14:34:22.711Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a8/a4/20da314d277121d6534b3a980b29035dcd51e6744bd79075a6ce8fa4eb8d/pytest-8.4.2-py3-none-any.whl", hash = "sha256:872f880de3fc3a5bdc88a11b39c9710c3497a547cfa9320bc3c5e62fbf272e79", size = 365750, upload-time = "2025-09-04T14:34:20.226Z" }, +] + [[package]] name = "python-dateutil" version = "2.9.0.post0" @@ -2538,6 +2572,11 @@ dependencies = [ { name = "scikit-image" }, ] +[package.dev-dependencies] +dev = [ + { name = "pytest" }, +] + [package.metadata] requires-dist = [ { name = "black", specifier = ">=25.1" }, @@ -2552,10 +2591,13 @@ requires-dist = [ { name = "numpy", specifier = ">=1.26.4" }, { name = "opencv-python-headless", specifier = ">=4.11.0.86" }, { name = "pandas", specifier = ">=2.2.3" }, - { name = "pyarrow", specifier = ">=21.0.0" }, - { name = "scikit-image", specifier = ">=0.24.0" }, + { name = "pyarrow", specifier = ">=21" }, + { name = "scikit-image", specifier = ">=0.24" }, ] +[package.metadata.requires-dev] +dev = [{ name = "pytest", specifier = ">=8.4.2" }] + [[package]] name = "setuptools" version = "80.8.0" From 9526f5f48110ba76de8d837c554d317ec21bc17c Mon Sep 17 00:00:00 2001 From: d33bs Date: Wed, 1 Oct 2025 09:25:30 -0600 Subject: [PATCH 2/5] add lance work --- src/serpula_rasa/image.py | 192 ++++++++++++++++++++++++++++++++++++++ tests/conftest.py | 12 +++ tests/test_image.py | 90 +++++++++++++++++- tests/utils.py | 14 +++ 4 files changed, 307 insertions(+), 1 deletion(-) create mode 100644 tests/conftest.py create mode 100644 tests/utils.py diff --git a/src/serpula_rasa/image.py b/src/serpula_rasa/image.py index 686f6d6..3ac062b 100644 --- a/src/serpula_rasa/image.py +++ b/src/serpula_rasa/image.py @@ -6,9 +6,13 @@ from dataclasses import dataclass from datetime import datetime, timezone +import pathlib from typing import Iterable, List, Mapping, Optional, Sequence, Tuple +from matplotlib import pyplot as plt +import tifffile as tiff import numpy as np +import lancedb from typing import Mapping, Any import numpy as np import pyarrow as pa @@ -256,3 +260,191 @@ def reconstruct_tczyx_from_record(rec: Mapping[str, Any]) -> np.ndarray: t, c, z = pl["t"], pl["c"], pl["z"] out[t, c, z] = np.asarray(pl["pixels"], dtype=np.uint16).reshape(Y, X) return out + +def list_images(root: pathlib.Path) -> list[pathlib.Path]: + """Find common image files recursively under `root`.""" + exts = (".tif", ".tiff", ".png", ".jpg", ".jpeg") + return sorted([p for p in pathlib.Path(root).rglob("*") if p.suffix.lower() in exts]) + + +def pa_table_from_ome_arrow_rows(rows: list[Mapping[str, Any]]) -> pa.Table: + """ + Build a PyArrow Table with the canonical one-column ome-arrow schema + from a list of py-dicts produced by `make_ome_arrow_row`. + """ + return pa.Table.from_pylist(rows, schema=OME_ARROW_SCHEMA) + +def _lance_get_or_create_arrow_table( + db: lancedb.db.LanceDBConnection, + table_name: str, + first_batch: pa.Table, +) -> lancedb.table.LanceTable: + """ + Create (empty) or open a Lance table using the batch schema. + NOTE: We do NOT write 'first_batch' here to avoid double-insert. + """ + names = set(db.table_names()) + if table_name not in names: + # Create EMPTY table with the schema of first_batch + return db.create_table(table_name, schema=first_batch.schema) + + tbl = db.open_table(table_name) + try: + # Probe compatibility + tbl.add(first_batch.slice(0, 0)) + return tbl + except Exception: + # Recreate EMPTY table with the schema + db.drop_table(table_name) + return db.create_table(table_name, schema=first_batch.schema) + +def ingest_ome_arrow_to_lance( + image_paths: Iterable[pathlib.Path], + db_path: pathlib.Path, + table_name: str = "ome_images", + *, + channel_meta: Optional[Sequence["ChannelMeta"]] = None, + physical_size_xy_um: float = 0.108, + physical_size_z_um: float = 1.0, + physical_unit: str = "µm", + prefer_dimension_order_xyzct: bool = False, + batch_size: int = 64, +) -> lancedb.table.LanceTable: + """ + Convert image files into `ome_arrow` structs and ingest into LanceDB. + + Parameters + ---------- + image_paths : Iterable[Path] + Paths to images (2D TIFFs, PNG, JPEG; multi-channel TIFFs ok). + db_path : Path + Directory where the LanceDB database lives (created if missing). + table_name : str + Lance table name to write to (default "ome_images"). + channel_meta : Optional[Sequence[ChannelMeta]] + Channel descriptors; defaults to autogenerated C0.. if None. + physical_size_xy_um, physical_size_z_um, physical_unit : + Microscopy scale metadata. + prefer_dimension_order_xyzct : bool + If False and Z==1, emit "XYCT" (more natural for 2D). + batch_size : int + How many images to buffer per Arrow batch write. + + Returns + ------- + lancedb.table.LanceTable + The opened Lance table for further queries. + """ + db = lancedb.connect(str(db_path)) + rows: list[Mapping[str, Any]] = [] + lance_tbl: Optional[lancedb.table.LanceTable] = None + + def _flush() -> None: + nonlocal rows, lance_tbl + if not rows: + return + batch = pa_table_from_ome_arrow_rows(rows) + if lance_tbl is None: + lance_tbl = _lance_get_or_create_arrow_table(db, table_name, batch) + # Write the batch ONCE + lance_tbl.add(batch) + rows = [] + + for p in image_paths: + img = tiff.imread(str(p)) # preserves dtype; supports many formats + + # Build one ome-arrow row (auto normalizes shapes to T,C,Z,Y,X) + row = make_ome_arrow_row( + image_id=p.stem, + name=p.name, + pixels=img, + channel_meta=channel_meta, + physical_size_xy_um=physical_size_xy_um, + physical_size_z_um=physical_size_z_um, + physical_unit=physical_unit, + prefer_dimension_order_xyzct=prefer_dimension_order_xyzct, + acquisition_dt=datetime.now(timezone.utc), + ) + rows.append(row) + + if len(rows) >= batch_size: + _flush() + + _flush() # final + assert lance_tbl is not None, "No images ingested; check `image_paths`." + return lance_tbl + +def show_images_from_lance( + db_path: Path, + table_name: str = "ome_images", + *, + max_images: int = 8, + pick: Literal["first", "center", "maxproj"] = "first", + cmap: str = "gray", +) -> None: + """ + Display images stored as `ome_arrow` records in a LanceDB table. + + Parameters + ---------- + db_path : Path + LanceDB directory containing the table. + table_name : str + Table name with ome-arrow rows (default "ome_images"). + max_images : int + Limit how many records to display. + pick : {"first","center","maxproj"} + How to select a 2D plane for Z-stacks: + - "first" : z=0 + - "center" : z=Z//2 + - "maxproj": max projection along Z + cmap : str + Matplotlib colormap for grayscale display. + """ + import math + from typing import Literal + + db = lancedb.connect(str(db_path)) + tbl = db.open_table(table_name) + + # Pull to Arrow (fast) then to Py-land recordss + # Note: select only the ome_arrow column + arr_tbl = tbl.to_arrow().select(["ome_arrow"]) + records = [arr_tbl["ome_arrow"][i].as_py() for i in range(len(arr_tbl))] + if not records: + print("(no images)") + return + + n = min(max_images, len(records)) + cols = min(4, n) + rows = math.ceil(n / cols) + fig, axes = plt.subplots(rows, cols, figsize=(4 * cols, 4 * rows), squeeze=False) + + for i, rec in enumerate(records[:n]): + ax = axes[i // cols][i % cols] + arr = reconstruct_tczyx_from_record(rec) # (T,C,Z,Y,X) + + # show: first timepoint, first channel + img = arr[0, 0] # (Z,Y,X) or (1,Y,X) for 2D + + if img.shape[0] == 1: # Z==1 → plain 2D + plane = img[0] + else: + Z = img.shape[0] + if pick == "center": + plane = img[Z // 2] + elif pick == "maxproj": + plane = np.max(img, axis=0) + else: + plane = img[0] + + ax.imshow(plane, cmap=cmap) + ax.set_title(rec.get("name", f"record {i}")) + ax.axis("off") + + # Hide any leftover axes + for j in range(n, rows * cols): + axes[j // cols][j % cols].axis("off") + + plt.tight_layout() + plt.show() \ No newline at end of file diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 0000000..b734810 --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,12 @@ +""" +Fixtures for image tests. +""" + +import pathlib +import pytest + +@pytest.fixture +def tmp_db(tmp_path: pathlib.Path) -> pathlib.Path: + db_dir = tmp_path / "lance_db" + db_dir.mkdir(parents=True, exist_ok=True) + return db_dir \ No newline at end of file diff --git a/tests/test_image.py b/tests/test_image.py index 9e144dd..312a25a 100644 --- a/tests/test_image.py +++ b/tests/test_image.py @@ -6,16 +6,24 @@ import tifffile as tiff import pyarrow.parquet as pq import pytest +import matplotlib + +import tifffile as tiff # import your ome-arrow helpers/globals from serpula_rasa.image import ( make_ome_arrow_row, write_ome_arrow_parquet, validate_ome_arrow_table, - reconstruct_tczyx_from_record + reconstruct_tczyx_from_record, + ingest_ome_arrow_to_lance, + show_images_from_lance, ) from serpula_rasa.meta import OME_ARROW_TAG_TYPE, OME_ARROW_TAG_VERSION +matplotlib.use("Agg") + + @pytest.mark.parametrize("shape,dtype", [((64, 96), np.uint16), ((32, 48), np.uint8)]) def test_ome_arrow_roundtrip_from_2d_tiff(tmp_path, shape, dtype): """ @@ -79,3 +87,83 @@ def test_ome_arrow_roundtrip_from_2d_tiff(tmp_path, shape, dtype): # quick numeric sanity checks assert float(recon.mean()) == pytest.approx(float(src.mean())) assert float(recon.max()) == float(src.max()) + +# test_ome_arrow_lance_ingest.py +import os +import sys +from pathlib import Path + +import numpy as np +import pytest + +from tests.utils import write_synth_tiff + + +def test_ingest_ome_arrow_to_lance_roundtrip(tmp_db: Path, tmp_path: Path): + # 1) Create a couple of synthetic TIFFs + img1 = write_synth_tiff(tmp_path / "a.tif", shape=(32, 48), dtype=np.uint16) + img2 = write_synth_tiff(tmp_path / "b.tif", shape=(40, 40), dtype=np.uint8) + + # 2) Ingest into LanceDB as ome-arrow structs (one row per image) + table = ingest_ome_arrow_to_lance( + image_paths=[tmp_path / "a.tif", tmp_path / "b.tif"], + db_path=tmp_db, + table_name="ome_images", + prefer_dimension_order_xyzct=False, # 2D → "XYCT" hint + batch_size=2, + ) + + # 3) Lance table exists and has 2 rows + assert table.count_rows() == 2 + + # 4) Pull back as Arrow, validate schema + type/version tags + arr_tbl = table.to_arrow().select(["ome_arrow"]) + validate_ome_arrow_table(arr_tbl) + + # 5) Reconstruct arrays and compare with the source TIFFs (bit-exact) + records = [arr_tbl["ome_arrow"][i].as_py() for i in range(len(arr_tbl))] + # map by id (stem) + rec_by_id = {rec["id"]: rec for rec in records} + + # a.tif + rec_a = rec_by_id["a"] + arr_a = reconstruct_tczyx_from_record(rec_a) # (T,C,Z,Y,X) + assert arr_a.shape == (1, 1, 1, 32, 48) + np.testing.assert_array_equal(arr_a[0, 0, 0], img1) + + # b.tif + rec_b = rec_by_id["b"] + arr_b = reconstruct_tczyx_from_record(rec_b) + assert arr_b.shape == (1, 1, 1, 40, 40) + # stored as uint16; values equal after dtype cast + np.testing.assert_array_equal(arr_b[0, 0, 0].astype(img2.dtype), img2) + + # 6) Type/version tags present + for rec in records: + assert rec["type"] == OME_ARROW_TAG_TYPE + assert rec["version"] == OME_ARROW_TAG_VERSION + +def test_show_images_from_lance_smoke(tmp_db: Path, tmp_path: Path): + """ + Smoke-test the visualization helper. We don't assert on plots; we just + ensure the function runs without raising (using Agg backend). + """ + # Ingest one tiny image + _ = write_synth_tiff(tmp_path / "c.tif", shape=(16, 16), dtype=np.uint16) + table = ingest_ome_arrow_to_lance( + image_paths=[tmp_path / "c.tif"], + db_path=tmp_db, + table_name="ome_images_show", + prefer_dimension_order_xyzct=False, + batch_size=1, + ) + assert table.count_rows() == 1 + + # Should not raise + show_images_from_lance( + db_path=tmp_db, + table_name="ome_images_show", + max_images=1, + pick="first", + cmap="gray", + ) diff --git a/tests/utils.py b/tests/utils.py new file mode 100644 index 0000000..c5e0d88 --- /dev/null +++ b/tests/utils.py @@ -0,0 +1,14 @@ +""" +Image test fixtures. +""" + +import pathlib +import numpy as np +import tifffile as tiff + +def write_synth_tiff(path: pathlib.Path, shape=(64, 96), dtype=np.uint16) -> np.ndarray: + """Create and save a simple ramp image; return the array used.""" + arr = (np.arange(shape[0] * shape[1], dtype=np.uint32) % np.iinfo(dtype).max).astype(dtype) + arr = arr.reshape(shape) + tiff.imwrite(str(path), arr) + return arr \ No newline at end of file From b3e80f61fa4b07f3f2ab6da11672f55e261cd94e Mon Sep 17 00:00:00 2001 From: d33bs Date: Wed, 1 Oct 2025 11:17:11 -0600 Subject: [PATCH 3/5] ome-arrow images in image table --- CITATION.cff | 9 ++ src/serpula_rasa/example.ipynb | 263 ++++++++++++--------------------- src/serpula_rasa/example.py | 157 ++++++-------------- src/serpula_rasa/image.py | 139 +++++++++++------ src/serpula_rasa/meta.py | 10 +- tests/test_image.py | 1 + 6 files changed, 256 insertions(+), 323 deletions(-) diff --git a/CITATION.cff b/CITATION.cff index b9012a0..5f14e24 100644 --- a/CITATION.cff +++ b/CITATION.cff @@ -11,6 +11,15 @@ authors: - given-names: Dave family-names: Bunten orcid: "https://orcid.org/0000-0001-6041-3665" + - given-names: Michael + family-names: Lippincott + orcid: 'https://orcid.org/0000-0002-8637-1448' + - given-names: Jenna + family-names: Tomkinson + orcid: 'https://orcid.org/0000-0003-2676-5813' + - given-names: Gregory + family-names: Way + orcid: 'https://orcid.org/0000-0002-0503-9348' repository-code: "https://github.com/d33bs/serpula_rasa" abstract: >- Blank snake implementation prototype for image-based single-cell profiling diff --git a/src/serpula_rasa/example.ipynb b/src/serpula_rasa/example.ipynb index 8ad9335..f1c599e 100644 --- a/src/serpula_rasa/example.ipynb +++ b/src/serpula_rasa/example.ipynb @@ -7,7 +7,7 @@ "source": [ "# Example Pythonic image-based single-cell profiling\n", "\n", - "The following is an example of performing image-based single-cell profiling using \n", + "The following is an example of performing image-based single-cell profiling using\n", "Python tools without leaving the kernel for GUI-based interaction.\n", "\n", "- load ExampleHuman images from the CellProfiler/examples repo\n", @@ -35,7 +35,7 @@ "Welcome to CellposeSAM, cellpose v\n", "cellpose version: \t4.0.6 \n", "platform: \tdarwin \n", - "python version: \t3.11.11 \n", + "python version: \t3.11.13 \n", "torch version: \t2.8.0! The neural network component of\n", "CPSAM is much larger than in previous versions and CPU excution is slow. \n", "We encourage users to use GPU/MPS if available. \n", @@ -63,6 +63,7 @@ "import numpy as np\n", "import pandas as pd\n", "from cellpose import models as cp_models\n", + "from serpula_rasa.image import ingest_ome_images_ome_arrow, show_images_from_lance\n", "\n", "try:\n", " from cellpose import version as CP_VERSION\n", @@ -80,7 +81,7 @@ "TABLE_FEATURES = \"compartment_nuclei\"\n", "TABLE_LOG = \"run_log\"\n", "TABLE_IMAGES = \"images\"\n", - "TABLE_MASKS = \"masks\"\n", + "TABLE_MASKS = \"images\"\n", "\n", "MODEL_TYPE = \"nuclei\" # Cellpose pretrained nuclei model\n", "GPU = True # set True if you have CUDA ready\n", @@ -137,32 +138,7 @@ }, { "cell_type": "code", - "execution_count": 15, - "id": "d587108c-9558-4fc9-bd67-92f3c1f910ad", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "lancedb.table.LanceTable" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "type(\n", - " lancedb.connect(LANCE_DIR).create_table(\n", - " \"something\", pd.DataFrame({\"sometiing\": [12]})\n", - " )\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "f0b781b1-06c8-4d73-80a4-7a955d5b1c0e", "metadata": {}, "outputs": [], @@ -305,153 +281,104 @@ " return masks, diam_scalar\n", "\n", "\n", - "def main() -> None: # noqa: PLR0915, C901\n", + "def gather_profiles() -> None: # noqa: PLR0915, C901\n", " # Connect LanceDB + ensure log table\n", " db = lancedb.connect(str(LANCE_DIR))\n", " ensure_log_table(db, TABLE_LOG)\n", " log_tbl = db.open_table(TABLE_LOG)\n", "\n", - " # Init Cellpose (v3 or v4)\n", + " # Init Cellpose (v3 or v4) + measurement funcs\n", " model = make_cellpose_model(MODEL_TYPE, GPU)\n", - "\n", - " # cp_measure measurement functions (intensity, size/shape,\n", - " # texture, zernike, granularity, radial, etc.)\n", " measurements = get_core_measurements()\n", "\n", " images = list_images(IMAGES_DIR)\n", " if not images:\n", " raise SystemExit(f\"No images found under: {IMAGES_DIR.resolve()}\")\n", "\n", + " ome_tbl = ingest_ome_images_ome_arrow(\n", + " db=db,\n", + " col_name=\"ome-arrow_original\",\n", + " table_name=TABLE_IMAGES, # reuse TABLE_IMAGES name\n", + " image_paths=images, # demo: first image only\n", + " prefer_dimension_order_xyzct=False, # 2D → \"XYCT\" hint\n", + " )\n", + " print(f\"[ome-arrow] stored {ome_tbl.count_rows()} image(s) in Lance\")\n", + "\n", " for img_path in [images[0]]:\n", " try:\n", - " # --- read & (optionally) select nuclei channel ---\n", " img = iio.imread(img_path)\n", - " file_shape = tuple(img.shape)\n", - " file_dtype = str(img.dtype)\n", - "\n", - " # If multichannel (H,W,C), pick the first channel\n", - " # for minimal demo storage/seg\n", - " dims = 3\n", - " if img.ndim == dims and img.shape[-1] in (2, 3, 4):\n", + " # match the ingestion’s channel handling\n", + " if img.ndim == 3 and img.shape[-1] in (2, 3, 4):\n", " nuc_img = img[..., 0]\n", - " stored_channels = 1\n", " else:\n", " nuc_img = img\n", - " stored_channels = 1 # demo stores single-channel images\n", - "\n", - " # --- store raw image as flattened list into images_raw ---\n", - " img_record = pd.DataFrame(\n", - " [\n", - " {\n", - " \"filename\": img_path.name,\n", - " \"height\": int(nuc_img.shape[0]),\n", - " \"width\": int(nuc_img.shape[1]),\n", - " \"channels\": int(stored_channels),\n", - " \"dtype\": str(nuc_img.dtype),\n", - " \"image\": ndarray_to_list(nuc_img), # <— list column\n", - " # provenance about original file before channel selection\n", - " \"file_shape\": str(file_shape),\n", - " \"file_dtype\": file_dtype,\n", - " }\n", - " ]\n", - " )\n", "\n", - " get_or_create_table(db, TABLE_IMAGES, img_record)\n", - "\n", - " # --- prepare float image for segmentation & features ---\n", " img_f = to_float01(nuc_img)\n", "\n", - " # --- segment ---\n", + " # segment\n", " masks, diams = cellpose_eval(model, img_f, channels=CHANNELS)\n", "\n", - " # --- store mask as flattened list with lineage into masks table ---\n", - " labels = np.unique(masks)\n", - " labels = labels[labels > 0]\n", + " # store masks (kept as flattened ints in existing table)\n", + " labels = np.unique(masks); labels = labels[labels > 0]\n", " n_obj = int(labels.size)\n", - "\n", - " mask_record = pd.DataFrame(\n", - " [\n", - " {\n", - " \"filename\": img_path.name,\n", - " \"algo_name\": \"cellpose\",\n", - " \"algo_version\": CP_VERSION,\n", - " \"model_type\": MODEL_TYPE,\n", - " \"channels\": str(CHANNELS),\n", - " \"n_objects\": n_obj,\n", - " \"height\": int(masks.shape[0]),\n", - " \"width\": int(masks.shape[1]),\n", - " \"dtype\": \"int32\",\n", - " \"image\": ndarray_to_list(\n", - " masks.astype(np.int32, copy=False)\n", - " ), # <— list column\n", - " }\n", - " ]\n", - " )\n", - "\n", + " mask_record = pd.DataFrame([{\n", + " \"filename\": img_path.name,\n", + " \"algo_name\": \"cellpose\",\n", + " \"algo_version\": CP_VERSION,\n", + " \"model_type\": MODEL_TYPE,\n", + " \"channels\": str(CHANNELS),\n", + " \"n_objects\": n_obj,\n", + " \"height\": int(masks.shape[0]),\n", + " \"width\": int(masks.shape[1]),\n", + " \"dtype\": \"int32\",\n", + " \"image\": masks.astype(np.int32, copy=False).ravel(order=\"C\").tolist(),\n", + " }])\n", " get_or_create_table(db, TABLE_MASKS, mask_record)\n", "\n", - " # --- compute cp_measure features ---\n", + " # features\n", " if n_obj < MIN_OBJECTS_TO_SAVE:\n", - " log_tbl.add(\n", - " [\n", - " {\n", - " \"image_filename\": str(img_path),\n", - " \"status\": \"no_objects\",\n", - " \"n_objects\": n_obj,\n", - " }\n", - " ]\n", - " )\n", + " log_tbl.add([{\n", + " \"image_filename\": str(img_path),\n", + " \"status\": \"no_objects\",\n", + " \"n_objects\": n_obj,\n", + " }])\n", " print(f\"- {img_path.name}: no objects\")\n", " continue\n", "\n", " feature_arrays: Dict[str, np.ndarray] = {}\n", " for _, fn in measurements.items():\n", - " res = fn(masks, img_f) # (mask, image) measurements\n", + " res = fn(masks, img_f)\n", " feature_arrays.update(res)\n", "\n", " rows = []\n", " for i, obj_id in enumerate(labels, start=0):\n", - " row = {\n", - " \"image_filename\": img_path.name,\n", - " \"nuclei_object_number\": int(obj_id),\n", - " }\n", + " row = {\"image_filename\": img_path.name, \"nuclei_object_number\": int(obj_id)}\n", " for feat_name, arr in feature_arrays.items():\n", " if i < len(arr):\n", " val = arr[i]\n", - " # ensure python scalar\n", " try:\n", - " row[feat_name] = (\n", - " float(val)\n", - " if np.ndim(val) == 0\n", - " else float(np.array(val).item())\n", - " )\n", + " row[feat_name] = float(val) if np.ndim(val) == 0 else float(np.array(val).item())\n", " except Exception:\n", " row[feat_name] = float(\"nan\")\n", " rows.append(row)\n", - "\n", " df_features = pd.DataFrame(rows)\n", - "\n", " get_or_create_table(db, TABLE_FEATURES, df_features)\n", "\n", " log_tbl.add([{\"image\": str(img_path), \"status\": \"ok\", \"n_objects\": n_obj}])\n", " print(f\"✓ {img_path.name}: {n_obj} objects\")\n", "\n", " except Exception as ex:\n", - " log_tbl.add(\n", - " [\n", - " {\n", - " \"image\": str(img_path),\n", - " \"status\": f\"error: {type(ex).__name__}: {ex}\",\n", - " \"n_objects\": 0,\n", - " }\n", - " ]\n", - " )\n", + " log_tbl.add([{\n", + " \"image\": str(img_path),\n", + " \"status\": f\"error: {type(ex).__name__}: {ex}\",\n", + " \"n_objects\": 0,\n", + " }])\n", " print(f\"✗ {img_path.name}: {ex}\")" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "98a713c1-9dbf-4945-9114-b3545298a50c", "metadata": {}, "outputs": [ @@ -460,7 +387,20 @@ "output_type": "stream", "text": [ "model_type argument is not used in v4.0.1+. Ignoring this argument...\n", - "channels deprecated in v4.0.1+. If data contain more than 3 channels, only the first 3 channels will be used\n", + "channels deprecated in v4.0.1+. If data contain more than 3 channels, only the first 3 channels will be used\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ome-arrow] stored 3 image(s) in Lance\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ "/Users/buntend/Documents/work/serpula_rasa/.venv/lib/python3.11/site-packages/cp_measure/core/measureobjectintensitydistribution.py:279: RuntimeWarning: invalid value encountered in divide\n", " radial_means = numpy.ma.masked_array(radial_values / pixel_count, mask)\n" ] @@ -470,30 +410,30 @@ "output_type": "stream", "text": [ "✓ AS_09125_050116030001_D03f00d0.tif: 329 objects\n", - "CPU times: user 3.65 s, sys: 898 ms, total: 4.55 s\n", - "Wall time: 7.34 s\n" + "CPU times: user 3.78 s, sys: 1.21 s, total: 5 s\n", + "Wall time: 8.1 s\n" ] } ], "source": [ "%%time\n", "# run the pipeline and show the time duration\n", - "main()" + "gather_profiles()" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "1c80deb6-b53a-4eb9-ba33-f6b30c3b9edf", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "['compartment_nuclei', 'images', 'masks', 'run_log']" + "['compartment_nuclei', 'images', 'masks', 'run_log', 'something']" ] }, - "execution_count": 5, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -505,7 +445,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "8b91158f-8e3e-4b2d-b52f-407546a94c18", "metadata": {}, "outputs": [ @@ -931,7 +871,7 @@ "[329 rows x 273 columns]" ] }, - "execution_count": 6, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -943,7 +883,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "e5cdd20c-0a03-4e8d-a4f0-3928e59d203f", "metadata": {}, "outputs": [ @@ -968,41 +908,34 @@ " \n", " \n", " \n", - " filename\n", - " height\n", - " width\n", - " channels\n", - " dtype\n", - " image\n", - " file_shape\n", - " file_dtype\n", + " ome-arrow_original\n", " \n", " \n", " \n", " \n", " 0\n", - " AS_09125_050116030001_D03f00d0.tif\n", - " 512\n", - " 512\n", - " 1\n", - " uint8\n", - " [8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 8, 8, 10, 8, 8,...\n", - " (512, 512)\n", - " uint8\n", + " {'type': 'ome.arrow', 'version': '0.0.1', 'id'...\n", + " \n", + " \n", + " 1\n", + " {'type': 'ome.arrow', 'version': '0.0.1', 'id'...\n", + " \n", + " \n", + " 2\n", + " {'type': 'ome.arrow', 'version': '0.0.1', 'id'...\n", " \n", " \n", "\n", "" ], "text/plain": [ - " filename height width channels dtype \\\n", - "0 AS_09125_050116030001_D03f00d0.tif 512 512 1 uint8 \n", - "\n", - " image file_shape file_dtype \n", - "0 [8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 8, 8, 10, 8, 8,... (512, 512) uint8 " + " ome-arrow_original\n", + "0 {'type': 'ome.arrow', 'version': '0.0.1', 'id'...\n", + "1 {'type': 'ome.arrow', 'version': '0.0.1', 'id'...\n", + "2 {'type': 'ome.arrow', 'version': '0.0.1', 'id'..." ] }, - "execution_count": 7, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -1014,7 +947,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "38a4b903-0151-4cdc-9e9b-cfabcb34680b", "metadata": {}, "outputs": [ @@ -1080,7 +1013,7 @@ "0 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ... " ] }, - "execution_count": 8, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -1092,15 +1025,15 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "id": "118dcf01-c4a4-46a6-88b0-0ec694d9efa9", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABJYAAAGXCAYAAADh89pxAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjUsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvWftoOwAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs/Qe4dVtV34+feyliQzpcepGiBoQoYkPUqCSGmKJGjVFRUjSJ6THW2FvURCUalRhjDEFN0fTEgjECGkpERVEQuMAFLlXFisI9v+e7/3zO//t+7xhzzrXf8xa5azzPPmfvtWYZc8wxR1tjznXN6enp6ckOO+ywww477LDDDjvssMMOO+ywww47bIRrt1bYYYcddthhhx122GGHHXbYYYcddthhB8EeWNphhx122GGHHXbYYYcddthhhx122OEo2ANLO+ywww477LDDDjvssMMOO+ywww47HAV7YGmHHXbYYYcddthhhx122GGHHXbYYYejYA8s7bDDDjvssMMOO+ywww477LDDDjvscBTsgaUddthhhx122GGHHXbYYYcddthhhx2Ogj2wtMMOO+ywww477LDDDjvssMMOO+yww1GwB5Z22GGHHXbYYYcddthhhx122GGHHXY4CvbA0g477LDDDjvssMMOO+ywww477LDDDkfBHljaYYcdrhi89rWvPfmET/iEkzvf+c4n11xzzck3f/M3X9b+/9W/+leHfq+//vpL3teXfdmXHfpyeOtb33ryeZ/3eSf3uc99Tq699tqTP/Nn/swlx2OHHXbY4Q8b3JJ0RdfXN3zDN5w88IEPPLnVrW518shHPvKS47HDDjvs8IcNdl1xckV1xRUNLH37t3/7gSCPecxjyvu/9Vu/dfKlX/qlJ3/kj/yRk3d913c9MIkI9Lf+1t86efWrX725v+/+7u8+ea/3eq+T293udicPfvCDT5785CeX5b7/+7//5I/+0T96KHfXu9715ElPetLJG97whpuV++f//J+ffOInfuLJfe9738M4nvjEJ5bt/fiP//jJZ33WZ5085CEPOXmXd3mXw2T/pb/0l05e85rX3Kzsh3/4hx/ays8f/+N//OQY+M//+T+fjUV4ip5yZivGrD433njjUW1qbJ//+Z9/8hEf8REn7/7u735o63//7/9d4vgjP/IjBxprnrUI7n//+w/H9JKXvOTkL/yFv3Byt7vd7eSd3/mdD3P5RV/0RTcr98IXvvBAt3d7t3c7udOd7nTyaZ/2aSevf/3rLygjPvqLf/Evnjz0oQ894HmHO9zh5AM+4ANOvvd7v/fk9PT0Zm2+6lWvOvnzf/7PH8rd/va3P/nTf/pPn7z0pS+9KH5bbXOV32YgAeRzfJvb3ObkLne5y8kHf/AHn3zhF37hySte8Yqy3k033XTyj//xPz55wAMecBjTIx7xiJOnPe1pNyv3lKc85eRxj3vcyd3vfveTd3qndzqU/8zP/MxSyP6dv/N3Tv7X//pfJ1/wBV9w8n3f931nfL7a1+o8b4Vj2/yd3/mdQwCp4/WEf/kv/+VBAUgJiudEjx1uDruu2HWFYNcVu664mnTFs5/97JO/9tf+2sn7vd/7HWiTDw5m8DVf8zUnP/zDP7xUVryvhxAf8iEfcvI93/M9h7o73Bx2XbHrCsGuK3ZdcbXoiptuuumwHj7u4z7u8BBZckd8+VVf9VUnv/d7v/eOpytOryB88Ad/8On9739/rbLTF7/4xRfc+/3f//3TRz3qUafv/M7vfPrZn/3Zp9/xHd9x+o3f+I2nn/mZn3l6l7vc5fQnfuInNvWl+urn4z/+40+/67u+6/TTPu3TDr+/7uu+7oJy3/7t3364/sf+2B87/bZv+7bTL/iCLzh9l3d5l9NHPOIRp7/7u797Qdn73e9+p3e6051O//gf/+Ont771rU8/4zM+o+z7/d7v/U4f8IAHnH7e533e6VOe8pRDm+/+7u9+eve73/30Na95zQVlH/e4x53e+973Pv2+7/u+Cz4//uM/froV/vt//++n11xzzelHfMRHHMb8uZ/7uafXXnvtgZ4O3/M933MY81d8xVfcrN8c82qbmh+1+eAHP/j0gz7ogw7fuzkT3W53u9sd+EFjF107+Nmf/dnT93iP9zh97/d+78PciZ5f8iVfcvrEJz7xgnKvfOUrD3zyoAc96PRbvuVbTr/6q7/69I53vOPp+77v+56+5S1vOSv3cz/3cweaf+EXfuGBR5785CefftzHfdwBX82Tw2/+5m8exnO3u93t9Ou//utP/8k/+Sen97nPfQ44v+ENbziK37a0ucpvM3jZy152wOVTPuVTDnP8vd/7vaff/M3ffPqpn/qph/Umfn/a0552s3qf//mff6j3l//yXz6M6U/+yT95+J1lP+dzPueAm9brd3/3d59+8Rd/8YHXNR+vetWrLiir6+r32L5W57kDeF80OY82X//61x/a+9Iv/dKb3fuDP/iDm62nT/qkTzq9173uNcXzlg67rth1hWDXFbuuuJp0heT8bW5zm8O6fchDHnK4vwXe9V3ftZybt771rYf1dNNNN51d+4f/8B8e1s8Krrdk2HXFrisEu67YdcXVoit+8zd/8/D7Az/wA0+/6qu+6tC3ZI54/MM//MMvkPPvCLriigWWXvrSlx4I/R//4388vetd73r6ZV/2ZRfc/8Ef/MHD/ac+9ak3qysi/sZv/MZyX7/zO79zeuc73/nARA5iPE3Wm970psNvTcId7nCH0w/7sA+7YJL+y3/5LwdcvvVbv/WC+tdff/1ZuW7SBT/5kz95+ra3ve1m19TmF33RF11wXcLofd7nfU7PAyQktRDk0ALqTwL8hS984c0WwXOe85xza/PNb37z6Rvf+MbD93/37/7dUAFIKEjhCzRHnQIQDf/IH/kjp495zGMOczoCCSEJs5e//OVn1370R3/0gMd3fud3Tsf5hCc84TCnWrSABLTqP/vZzz67pjHf6la3ukBZrPLblja38NuqAviGb/iGm91THzKQb3vb254+//nPP7t+ww03HAzov/7X//rZNeHy2Mc+9qCsnE4VPPe5zz30+bVf+7UXXBffeJtb+7rYea6chYtpcxRYqkCG1Hmt93dU2HXFriuAXVfsuuJq0hU33njjGX8Jh/MKLFUgR0Tld+hh1xW7rgB2XbHriqtFV7zlLW85feYzn3mzcl/+5V9+KKe235F0xRULLH3lV37lIQIogmsSFV11EKOI4GLIi4X/9t/+26Et/Xd41rOedbiu6Krgec973uG3nigkvNu7vdsh8t3BMQtSUeI/9+f+XKkAJGAV5TwWfvEXf7Eci4Strov+lQKQ4O4W85Y2HWYKwGGkAP7H//gfh3b0dEPw27/92y2uitR/4id+4s2uS7jpqdEM/sbf+BsH4eSK5tGPfvThk/AxH/Mxh8j2Vn7b0mbCpVIAjudf+At/4eya5lzXxAMO//bf/tvD9Z/6qZ8a9qmnJCqnSLrzXH629rVlnl/wghccAjl6iqUsIfGrnnyks3As70DX/BBk0n/G2JXd+sT0lgC7rth1RQW7rqjbTNh1xaXTFQ5bA0vVmJindEyqsiqzw4Ww64pdV1Sw64q6zYRdV1weXQH8/M//fBlc/sOuK67YGUtPfepTT/7cn/tzJ7e97W1PPuVTPuXkxS9+8clznvOcs/v3u9/9Dv//9b/+1+We1C3wsz/7s4f/7//+73/Bde2L14G53H/LW95y+K/9tQm6pnLaK3keoH3e+mgPasKLXvSiwx5M7c29xz3ucfIlX/IlJ3/wB39wLmO+5z3veXLve9/77L6D9i1rL672a2svqObkYts8T/ixH/uxw3/trxUOopFw/eRP/uSTN73pTRfsLX7d6153MzwF2udc4fm7v/u7h/3u2q+rfdDal/pBH/RBZ7ygef/5n//5tk3tz/7N3/zNTfy2pc3LCRr3gx70oJMf/dEfPbsmnEVv7e1OPLmf8MY3vvEwD8997nMPe6EFf+yP/bHD/w/7sA877H0WfPRHf/ThO79X+9oyz9rTL/5+/vOff9ij/7f/9t8+yJZv+ZZvuaDeMbwD6NwE7VcX/Nk/+2fPxiQ5V5XVvYc97GGHtUPZHPMOu67YdcV22HXF5YFbsq64WNAYxJ+Pfexjz8b0V//qX23LqpzKU1Z02eFC2HXFriu2wq4rLg/suuLmwFlj1Xr9w6wrbn1yBeB5z3veyS//8i+fHTr2oR/6oQcBIqXw6Ec/+nBNb0fSwWf/6B/9o8NhZZo8EesJT3jC4XC1LaAD33R4W9aT8tHBfRzYp4PQdOjYM5/5zDOGFfzKr/zK2aFdv/Zrv3aoc7GgU+p///d//+STPumTLriuhaexPvzhDz/57d/+7ZN//+///eGALymFH/iBH1hunwP8rrvuupvd0zU/pFBCVAe2oQA0P//kn/yTw6Fr/+///b/DYWNb27wUgELSgXQ6VE0Hs/3cz/3cydd+7deevPKVrzx5xjOecZi/GZ5SFlL2WniABIHaAySopAQA6nRtCjR+8ewqv21p83KDDpb7T//pP528+c1vPvCExqRD8/JwUscz4V73uteZUaVxf+u3futB2At00KQ+OhBPh0/qoENgta8t8/z1X//1hzX8f//v/z1TJJ/xGZ9xWPMOx/AOIKWlQ7g/53M+53AooI+pKqv7/+Jf/IsDr4zK3pJh1xW7rjgGdl1x+eCWqisuFjSOz/7szz6MbSb/dV8OsNbYritq2HXFriuOgV1XXD7YdcWFoIPERYc/8Sf+xMk7kq64IoElCXpNsASOQBMtQfhv/s2/Ofmmb/qmw+JRRFeT9dVf/dUnP/iDP3g4UV0fRWb1Fo5v/MZvLJ27ChQ11uKrQCfD6z5RQwkXRZYV1VTWgaKXn/u5n3s44V7RfcpeDPyf//N/Tr78y7/80NdHfuRHXnBPys5BC+Sv/JW/cjgRXyfdf+AHfuBSH+BZ0Uhj1sIGhIc+gJTv4x//+EOUU/T/ju/4js1tXgrQkxiBjATxiuDjP/7jDwpMwltvyfioj/qoKZ6Mxe/r6ZYi1BIS//W//tfD6yp9rlfb3MJvW9q83KA3IQj0ZEOCL+m1guf/+B//4/DGA71dQfMlg2YFVvvaMs///b//98PaQfiTNfSpn/qph7fIeN+rbe5w6WHXFbuuOAZ2XXH54JaqK3a4umDXFbuuOAZ2XXH5YNcV/3/Qm9oUAFI5vbnvHQku+1a4t73tbYfXbkr4v+xlLzv51V/91cNHrwbVotMiBt7jPd7jENFTGqE+Eo6Ksv6zf/bPTr7yK79yuU8pE0XxKxCDeorqd37nd5587Md+7Mnf//t//xDllxBUlP9P/ak/dcHCOBb0REWKRZFbZSuswN/7e3/vgpTNFWBMRHZHY65AT3s0J97nxbZ5sUD7EtYOekWo4FnPetYSnl7GU6SlPNS2DBRFhl2ZbGlzld+OwfNyAcpWadPgsRVPrXFF4v/u3/27J//u3/27g9GjtTuD1b620O/lL395+RQhn9pczXNyS4NdV+y64ljYdcXlg1uqrtjh6oFdV+y64ljYdcXlg11X/P9AWYJf/MVffPKkJz3psMPhHQ0ue2Dp6U9/+iHVTEpAE8KHyLYWXwVaoJ/1WZ91SCdVdK8rV4HS16R4tG/SQYtU+zW1l9eVjlL1xDA/+ZM/eVA82qMonBWJvJjIotIqP+ZjPubQhyKdLK4ZkDLq+31nQBofaX0OuuZjHvXrfZ5HmxcDtK+nUg6khiqdeAXPO93pTtOnUtrSpPnSUyABdbo2Hb9VftvS5uWGF7zgBQe66qkCY9J+4DyXYBVPGVOPetSjltbtal/nMc9V3+fd5g7Hwa4rdl1xLOy64vLBLVVX7HD1wK4rdl1xLOy64vLBritODmdMffqnf/rJn/yTf/Isa+8dDS57YEkMIMZSpDE/iur+0A/90DBN7453vOOBmapJ7+CRj3zk4b8O+3LQbx10xn2H+973voenClI8v/7rv37YH6xI87GghS/hryjo//pf/6vcv9nBS1/60sN/KaCLHbP2kd5www3lmKt+vc/zaPNiQIfUCZRGnP0LwFV7cPU98RQ8+9nPXsITHvyN3/iNw3+lSusJU9WmUqv1JAKFvspvW9q8nPDTP/3ThwP+xK+AcP6d3/mdQ/pp4sn9FZpCzxGs9rVlnrWO89BIzjlwuFjeyf3bOxwPu67YdcWxsOuKywO3ZF1xHrDri/OBXVfsuuJY2HXF5YFdV5wc+lJmobZHaivurW9963dMXXE5X0GnVyy++7u/++lnfdZnlfef+cxnHl6N9/3f//2nz3/+809f//rX36yMXhP6zu/8zqePeMQjNvWrV3A+4QlPuOD6X/yLf/H0Xd7lXU7f+MY3Dut/9md/9um11157+uxnP/uo1zT+1m/91ukHfMAHHMb+3Oc+t23jN37jN05/7/d+74JrN9100+knfdInHeii15ZugYc97GGn7/u+73vBqzO/+Iu/+PC6y1/6pV86u/a6173uZnV5teXf/Jt/86g2L8VrQV/zmtecvtM7vdPph37oh56+7W1vO7v+BV/wBYf2fX40Z+KTV7ziFWfXfuzHfuxQ7p//838+HLvgT/2pP3UY04tf/OKza1/3dV939vpU4Jd/+ZdPb3WrW5297nIrv622ebleC6r1pVdq3va2tz39uZ/7ubPrr3zlK09vc5vbHF6p7Lz52Mc+9vCKTfhBr7N905vedLN2/+///b+HMX3ap33aBdeFh7e5pa8t8/y3//bfPlwTHj737/Ee73Gz14Kutvn7v//7py984QtPX/3qV18w9yr3t/7W37oZDb70S7/0Zq+j5jXAO1wIu67YdcUMdl2x64orrSschMPIpJauePnLX37Btbvf/e6nf/pP/+mblc1XSAs0h5rLHS6EXVfsumIGu67YdcWV1hW/9Eu/dHrnO9/5YO9XY3lH0hWXNbAkwS4C/PAP/3B5X4v6rne962HxiTm1WD75kz/59Ju/+ZtP/8W/+BenX/iFX3h6j3vc4yCM/+N//I+b+v62b/u2Q9+f8AmfcPqUpzzl9NM//dMPv7/6q7/6gnJf+7Vfe/qpn/qpp9/6rd96+u3f/u2nH/MxH3Mo91Vf9VU3a/M//+f/fPqVX/mVh48WzKMe9aiz3754xAxqQ4rv+77v+y74/NAP/dBZOQlIje/v/J2/c8D3G7/xG08/5EM+5FD3r/yVv3K6Ff7Lf/kvByH2kR/5kaff9V3fdRDmot1f/st/+YJy7/me73n6iZ/4iadf//Vff/od3/Edh75ufetbn97nPvc5vfHGG49qUwAtNIeMn2sOohXXH/rQh57e4Q53OPstGjt8xVd8xaGtj/7ojz7QSLgKn0/5lE+5oJwEghbxgx70oMNcfs3XfM3pHe94x9OHP/zhFyhZBQDe//3f/6DENB4J5Ec/+tGHPj73cz/3gjbf/OY3H9q7293udvqP//E/Pv2n//SfHmh0z3ve82aKZJXftrS5ym+rCkA0Ew9+7/d+7+m3fMu3HBSUhKnW3Q/8wA/crN4/+Af/4IwXNSYpa/1+6lOfelbm137t1w4CTXP9Td/0TQd+kiBXm1KKL3rRi6YKYLWvLfOs4I/K6d6XfdmXHeTLgx/84IMhmUJ5tU3omIr4vd/7vQ/rWDzwtKc97fQXfuEXDtf3wNI67Lpi1xW7rth1xdWuK+QwQdfHPOYxh/v8/tf/+l/fDH/Je4eP/diPPdBA45eu+Jmf+Zmr1lm4WmHXFbuu2HXFriuuZl3x5je/+UB/8bR4Idfrs571rHcoXXFZA0sS7Le73e1Of/u3f7st88QnPvEQVVQE/h/9o390+oEf+IGHxSGBJOUgRnj6059+VP9a4BIwWjxiGC02RSwd/ut//a9nTwHEtOr/B3/wB8v2NHma0OqjyQYUKe/KeRT9pS996UEQ3//+9z/QSf2/3/u932ERJZ6rIAXzyEc+8hCRv/e9730QdMq0cPiiL/qiQxlFWUX7+973vqef8zmfczPhv6VNQTfmdK5ZGNUnnXbR4clPfvIh+i1ctVi7/l/wghccFLjoKKUixZ5j+pEf+ZHDEwAJXLWneZfSFU4VzRX1llC//e1vf/pu7/Zuh7r+9GErv21pc5XfVhUAH60tCWcZxnpKk5FyN9AkYMWzGpMCIv/m3/ybC8q85S1vOShVCVaNRzRV+Sc96Unlk95OAaz0tWWeBT//8z9/ENZaW3pCIcX53d/93eVT6JU2u8CSlITWrfDWfQWUBHtgaR12XbHril1X7LriatcVcto7OqdjUF1TFsGHfdiHHRwv5+Gr0Vm4WmHXFbuu2HXFriuuZl3xsqDNjB//sOuKa/TnSm/H22GHHXbYYYcddthhhx122GGHHXbY4Q8fXPbDu3fYYYcddthhhx122GGHHXbYYYcddnjHgPUjya9C0GsWZ6/K1Cs43/md3/nkHQX0usnXv/71wzLv9m7vdvjscMuCW+J62GGHFbglro1dV+zQwS1xPeywwwrcEtfGrit26OCWuB52uAUHlp71rGedfMRHfMSwzPd8z/ecPPGJTzx5R4FXvvKVJw94wAOGZb70S7/05Mu+7MsuG047XB1wS1wPO+ywArfEtbHrih06uCWuhx12WIFb4trYdcUOHdwS18MOFwd/qM9Y+rVf+7WT5z3vecMy7/M+73Ny3XXXnbyjwO/93u+dPOMZzxiWeeADH3j47HDLglviethhhxW4Ja6NXVfs0MEtcT3ssMMK3BLXxq4rdujglrgedrgFB5Z22GGHHXbYYYcddthhhx122GGHHXa4crAf3r3DDjvssMMOO+ywww477LDDDjvssMNRsAeWdthhhx122GGHHXbYYYcddthhhx12uLSHd1977bUnuWvummuuWe5IZW9zm9scTo+/053udPh+29ve9vA2gptuuunQtvZy6s0Eb33rW8/6vPWtb332NgKV1V7g3/qt3zqcVK86qzv5wJX/Xk/fu7F07au83+O3tzPDLfukvLet77e61a0OH11zelU4+Hjynj6iqdrSd7Wj9qBj1qM91clxqe5onCM6JG4zWC2/td2sk3NY0bHrZ9Z30mP0O8HxGPFpt0aP3e06G+eIfxPvqvwx/Xf3NXb+3+52tzu5xz3ucZAZuv+7v/u7J7/92799kC+SG8m7rA3H793f/d1P7n//+x9kldp885vffKirtSP4gz/4g5M3vOENJ2984xsP8kptgo/PhbfJ+kt6+e9KpnTjTp4Qbve6170Oe90lW3/kR37k5EqAZPYM745fZr9HPDGT4d0aWlmPlVwYfa/qVmN3vPL7iHZdH7Pxd1DpkREtOujGX42ho8esrRV+WNXDrPtu7a3MTdXmjEdHPLdiN6zi4e1X4P2uzssKHlv0jsvgEe+v/t4CPs6ZHp6NAdm+ZW46m+889XiFa45TduCVgHd6p3c6/Ed/Ol6ip/DC/mSO0MHS79J10u9vectbzmxafaSTvb78DdWVbpJ9QDu3v/3tD7ryXd7lXQ5tvuQlLzn4INLvqgtOtINeF953vOMdD+2pL9V3/S58hAd1dE/XqK976lfXsSsoo771EXjf0AkbR2OSXfI7v/M7h3J6K9cd7nCHA276rfYFal84ym/6zd/8zbO+9UFXi4b6UE+0VTu6n/RnroSz7COduwS+spse9rCHnTz/+c8/4PbiF7/45Prrrz/goDpqT7S6y13ucignfxC/Tu3+8i//8slrX/vaw9g0RvUhmgh32XDwrvOL84j7Rsy/Q/IXPlXaktiIKRuzHbf7qCfcRQ98Nmim3257zmSw9wWO/K5sQKeN84vj53ou5X1FP8fR+S91prc98gtyrImP451tJJ6sLcoy1pw/55fKJvf15byh+dIa0HyyDpALyBKtOX1UVjxObOKtb33r2bwLVFbt6DeyAVx93uibe6xz9atr+u58Xdkt9A1v8111wUX46p7+IwfgWV33MSCj9Fvf5UddsrfCbVXA7vzow0QJcQ3ImcZBxLjzne98EFgivISfQEILYbZqJOe9GVQLlzZH7Ww1qCoH078TTOI390cOQ9emt9Xh6ji5Ilkxlkc4VNdXDKYt9LwY8DGvGvmCSmCt8EpnyFbCb8XBq/rZ6qTk3I/aW2k7665c68CVY4ULwlmC+9WvfvVZ4FoC0QOyvu5SoQgknyTQ9UHxcF0fyR0MV1eSrixy/ChBjCWCumrLlXnSdhTQr/hVbWr85+WEHAuVvKzw5XeCz9GKs+ntZN+5ljqo+GmlXtfWTC5X7XdjHeFQ0aGSHzO51hl8Vb1OL3p51+lVmcS/4usKvxUZNJIr3k6OMfveKj87vDvems3JFvk4wyvvVetwi95bsYFm87DS54y+nR21At7/jM4d3Vbqdn2vyruuX8drpb9uvq8U4ASm7OmCdf4AST4EutMdOZxO9Kzrc+lG1+Gqw3cFZe52t7sdXq2uax4EAi+cUF1TGfkn7/qu73p2jzHgROLEMRYcP9dL3rYcWR+bl3d6qE0FY+QPUU7On3CSo6v/CsSoLoE3nFNopPKykdSu7gPCQWPSPXdy1R7OJ/6brv3qr/7qoR/dU9Do5S9/+SE4Jx9ND988GKHvCoS96lWvOjiojFe4aDzMhUDlBKILtHV+8eCC8xP1U//w3YM06eADlKWfmX3mfEv/jqe3l+uca4zN17rzSKVHuOf/fSyVTvc1Va07ArfVWqWsj2lmo3mALYNVOS5fQ7n+6DdxyLnwMk6HDH5RDjmR+KkMgRetZ+QIoHlWXAIZonXGOr7JZBpjJeANrsx3FQhLHqAMbbOWPXDq/TEeyrP+tN4IOPvcZMIK8gd8fb2twKbA0opSqpRcGrkQVUi7s1YxKPf1ITooIHIIMSq80nCpcMwFPBpfZawnjIzDXOxd+a7NFHxd/W4OVgzBbD8FcDemqr0VI/UYY3AFOidnZqRW12e83imdLNfhscVITWU0EuzHwEo7I3pWcz4aT0fX6onFbA25ctJ3shqr9S7wwJArUww7f3qi3whytaHfXEvDJfFE5unpqD6qJ8D401MOsp6cBr4GM6BW0U3X1RZPX68kON1TdnT8kGt2dq2rPyqTOFI2+Sr5dyR7RzIly1R8u7JmRuutMkQ62mSZTl9VtHEcunF1Y0hdvEUWr8LM8J7pgE5Gz2g1gwqnlTYqfl6l0YrOncnl5IFO7mT5agwjW6Gbk5W6K/jPYNVWWqHbyC7KtTSzG6r6I9yzvUpurcjRywnuSKOPPYMg5Qx62oM3OD/cpw0PlqisdK+u6Z50sP5L/8rZIjPm3ve+9yEL+YYbbijXrTvJAtXVBwePoA3ZSFwjOEJQQ/cpq9+MC5zJTIAO2B0EhKTn/QGS/pOVpDFRrnN0eeAGLRmb+pP94H4WATgyLbBVNAYFgxQg0jV9CFTJyVb/nk0E7dA/uk8ZnGUfLw/v3Pn2ABXj9oCMILNefB14dosHJpI+GaTwoEQGk6pr3lfi4PzUBVVS5sLXiVPKlBy/B02870oW0V7SN23aFdnmsqZKZOho5YGLKouxsgsrmZv2OPSFBzPo521SX/wnnlcwSeW0JrDFCbCyA0L8zkPia4qMMgLdnmkEuLzLoKDzIfIAWeAyJ/UJdX1cvo6Erz/gZrwqi2/j2VbcuySBJYdOKc0MGk2UhJG+k4ZJW6RDennSQiWweNpPNFufdEArRV0pcGc8JswXJJ/RWFbHXeHg+Pq9rp2LNbpX8ElcVnGYGWLngVsHW/pewadz3qr7M4fB743aTSUzcgzzuxs5WyAdxK6M41eNa8v1FXwE1bqrHO1R31UkP41sPv5Uwg0nnm76k0aB5JYUihu/lVHvIKWkpxtKMSewpPYk03yrXdLC5ZMrCJQNffNbMlFtXQ1OQzpiKw5qB93a6AyMmQxzg6Nan15/pGNWxuz3OlmwimuOuaqzIkeq+5WepM5I9nd107jK6yvjyTIjmMmEmf51ebhVv3ftjXBNg91xTF5ZsRGyfnW9u9fN/Wgd53hW13U6G1XGSiezV3VO9bvaqtaN5RhIHh85lpUTMbOvVmwTL7+il640eAYKzlJu+wJ8vbClinI4QgRCeOij32ylYnsXmcI4gtL7qiP9Kx19z3ve85BpozrpnEFPjvVAL6uedDlHdeDASh9jR+DPgJt+KwhEkItgjNNG5bBNcAAJ8FAPZ5NAWcqMXMvYPLnlh4xqMp7IwqCc8xT9YZuoPv6Z6hBgEt5swVE5bCzvX+Mh20NQZZ9V2SlVcMDXnq8H+qyCTpUd7m2ASwa1HDzzyftOG83re7DMoZIJXUaLB7T47tldPvf+O7fWuezyLaBO0/QXfCyVTOV+Zye7DgS3fIBa9emywe347NvnjvusoQwEsj6T/uJFbR/VWhOfws/EKlSWHRGO2zWFHoP/nS98TC6bWZd8J/jN/OCjeKAUOibvQQuCkyTx+M4LH7tvW2UtgveqblwOLK0YohWkgS5BqwFKEPtZP7pOpN0nXAPTJLI/WcpBTx4k1F/3utdd8LTiGICAalfpn/otRpJySEOzE9IzWqw4IlsNV/89MzhGRl9ldM+MYq+7WnYLbDF+VvEc9dUJzqrcrD+nx8gQd7wq5yHLjebumDWbfN3VH7Vb8VylFDtDPhW6C8EOl46mVZuztYnA1LqXTEF4ShZhkGKwYgx6UIcnht5+8hPjkbFGOi0ZmpJnnGdAGnvSk/Rb9nGjEPyJoIPk4a//+q8fZOaVgq3yYGWe0imsjMFqDVXyLfuq7o1wTD6teK3rt2rfja+UM1W/1Rqr+u7Wf1c+7yeNO3qM5qKrP8Jha9mV+kmHEY4jmuSYKxxXYaQTZnOztd3ueienq3KUmenIavuu31/lT+/X73XznbK3G6f33end0RyPcNhSP8vnGKt7lXyryq7CDM9LDVVmRG5L8XtcV1BJzpZn+Eg/8rDZnSn9lj78jd/4jYPf4Gcsud5U5g1noUgv55k4njVAMIdAFTgKHzKF/DtnPLkzqPIEaDyI45kIAraeUUe4yR7AfqAe/OHBDIEHRLA/2OZPZrZsEAJs2D6AB2RwoD2jivYowxEEnHslXLGf8PkIMAlH4S+fi7MwySxJyAf/vn6hP/PiMsgDWfCPBxaqdiqbLgMG0DSvOe3hoc7PgAfcnuhkS2Zm+XVdg25pmzgdcmzQy2kDdDLIg4y5NtKm8jbAy4MwKfdy7pweSecKzwwyZpC6squqdqij+9jmkiG+hc3XPWuJNm6KoCTtCDjPqJr/nANoShaRcMjx+TlK1cMT/46soW/402Wuy2DWucuWS5qxBGLVtUqB812DkoDnwDkGJiGUqZku8BWIYm8gGUwaNJNVCYRKSTueCDgdwqfD5BDeUlqaAAWXfBxVH0mLvLdqNGfZqp3R984J6GjQCbHOyBgZgN0YK+F8XrDF8BuVTYFzHnhtwTPxTf51gTO7njiM7ue8dDiu4J/KcnWsFc6jOlX5ztAeGdvc03pnexqp6whxySitfw4XpTyySgJemUEZ2Knw8nZRInxH3siokkzkCQEGm+7pjDlS51EcKq+Uff13RS3wcwquBIzWeho8M0Om+51t5W/HYcS/WbZqpys7wqmjQ+JV9V+NbbXtlTF281PRbETD0RrsxjLru2qnmoOq3xHfdTxS4TyaM2+jm7+tv4+1rap2ckvHrL9uLrKdi5Hto7L8n60V/93x8WhdZhv+v6M1bc10ZEJnH6Z+r8ZZ2XYj+2zr79n1KwE4aoLMTIFeHtThAG7flqYynDvCQxwyeAgqSF8LpDMJTMl/wCEkc5htLzxcBuAV8FUwhG11ZDTooQ5Zz2RE+ZN/6vKAHceNDITMtM5zUti5wVY1MhkIyGQ/4Aye+s55U37WCucZgQv1GRs2Mn4XGUlkU2TwDL8qHV/us/1f5YSTygontcVuFK9TrUN+e5CoCuYAfK+caKe5Q8oJ7w96cT+zbmg78QfH7LOTDb5GwIO2uObbmqhXBVmom21V/lCl2zKDz/nE61Z2UsrbTibm9byX2WrVvDluPjbKEWx0uZPj45pn9WRQTf9Zxz7u04Jf4XdvHztfvzkaCDz8QTLjphz90o5vXasy+GiPtnQ94y36j0xAhrHOPSPqkgeWKlgxKkdvNsuyAglspaZymJwzTCrfzlFJ3GBYtamglaenqg0Jbgk3X6ijcc76XDXSOsOsWnwrsMWIrRb36ng6w9DrzMa0BWb1RsYY10b9d0rpWDyr+U/6dIZ0hdeKUVz1Oyu/5d6oza6dpKmPoeP7bCcVY9fPiPdJS1W2EoYTe6BVjzeu6DuHc/IhOO5vmHNFUz0Z8e+ZCo5RlkpXeEk26Z7kkaep6jpPRF2h0P/VAE7/itf53d3L+w6VgdnxQtfWyGnsdNKov66frs9KRnXrvRvXihzOtip5M6PVqL3R/YSq74oHvP6M9h3NOvwqo3dFBmWZkV4bwej+FhndjW1WbwVGOrPDNele0blqf7SOVn+v2DlVnep7h+toPFX5qt9O1uVaXJENK2Ndpe2VgiqDoaMJ96V//a3QukcQR0Agh+3q7oSiM/XRAyXOT1E5HtJgC0jv6wGSZxARVEFXk7XMm5TYZuKZSQLOZGFMnEmEnldAhe1gtOdbpVy3e9azQLYB2VsKdqVNgENKRovbTvpOebWv+zjS1Hc8PRjmjjeHiUNflSf4x/ySmUQSAUFC4c4LmlRGvh70SUjcGU+XzeP2WAY9nDZuN62ucbdDPYMleVdQ9c11x9PXgP93PB1o1w+FdjpxLQNtuW3Oy1VBucTRrzH+zDhKXe1rOLdfOT3TNsq5yKyZyub3trhXZSDS78hOYO04fTLOQPs+jpsi+AWPUMbfxJa8UIG36Wdn5dll0I/1keua+1mO2AoJO7wJzoOGq/bEUYGlFaOzKlsZG2moVPU0KDlyTIQEqb8VDmHr0T8UUAqbZHQi8M4oRACJ3jtuI0asoDNGKkOmu1/9rqAz1EcORLbvDFrh2I19ZOQda9yeJ1RGcfV9dG21n1EbHf90tJ71U63FnP+qj6ru1nVNm/m9mv8t9JzhMUrHnM2r48RrRPUdAcoTBSkAvR3mxhtvPHtKyOt3OXDbn8R5u9V/spzUDoF1Vw6cm+Dt8KpRf1LBPdLXwcMD7an4rgTMnFDK+P2VeUxjpWqrWhtbHcFKHl4spJzPtisarMiAqm7e9/aqNeptuHEywqW6v7LOR081Z9ey74pPZrJn5DiMZHM3P7Mxb5GJXfZs10eHbzfGaiyVHhiNO9vKeiP6VrBF71Q4OK+6szerU+FQyfJuPPrtTlv2kXUqm6zjoVn9EYDXsTbM5QSnLba7wLcuCVyfcWgu28lx/Pj467ZpQx/PKsDJk073Q6MJWBFYuutd73r4rV0T7gT6+bBqSzaBAPzdSSSg485bvhJcGVS8zIOsAqcROp/MJn8duOrzgIzt8bqe23E8mADN9Jt2/FwkgnK8TU746b7++w4T9724RiBK9glzxdZ9ttnRP+ORfye/TjtHhINsJZxbDxx5lgZtCLKM04314DDzr/yBYa4lvme2S7aXc5CBQgFzUa1XxumHPmMv5EPEbMPHQx+drnRcK72c/WSyhc8H332tekAz10jS0tv0YGG1HtK+cxqkPvAzlOjb6zkNCEwnHj6P1PM1XeF3GnT27Yp+qL5vd/WxgI/359ti4XXkGeu2Gmv2mbzhssFfkkD/+tD3uQWWVpXayNDqDOHOyPEJ0oC19UMRbxEKwcrBu57eSQBK5UnxrAzl/Hh0b6vRnpAM1dFmi/J3uvjC6WiZdUd9+QLLT9JpZiSvjuk8nLVV6Oi1BVYM7Uqwr7RVtdkZnX7Pf2fbM5xnyvVY2MqDznsjvGb8Wz3xqXDgP0Ekf7tb0o6UdrbuulHoCjQVVLbFGQ+SW+qXABNvo/GnlQI/twDjzw0mDBQZxuy79jGPgm+XGkbzVBkIfr0yrqq1O5I/VV9V34nHbO3m/QoHn/eZTEx+yb79XrfeK1xnNE591LVR6ark66RH6qiq7RlvVvq/G3dH1+w/Db1VXVzJ6U5OdXh09asy3XqodG4HI91QlUmjuKu3Kte7ea/qbNXHM1tj1veovwwQzdoetdXRnP8zPuDaip1ZrcdObqzYHZcT3GFz3eXrwB05Pw8Gp9XftuZP9QlaOL15i5vucdA1H3f4FKjxQ77BTfqb7We+Td4P1+aTgR6uqQ8CJv7CEM5+El6erYNto3o8/AJPxi0bgFeJc86Uz7EHlQhgcY4UZdSGn31UbY1RPbUFTaA5GWIebIL+alcfAniefU1bwlkP8hSM0rY4aIDt4zqjenuaZ1NAa7cHfR14kM3v+X9/exh09DfcVX1AC357lgeOP5ByPgNZfi3tzMzWzyBbbg3saJM2a2cTVfoht8ul3cNvx73ampb08PpVNlVmbnmbKT/APfulTNKB8RAYdX6rbGvazkPhr4k5Hcl22nB+8aBOJrzgsyi7T+uEQC/rVwFw3hiJz0C7vMWRtipcWb9ON2iiNUr/lyRjqTIkgVRUMwOnM0or45LT16nHIeC87QHFgPAlNRMB5XjQPveYRI/me2pj1nXB4GOsjOZOyXe0nSn7FBIVbRNPrzcCFq6YkDdFoFxdUXs/idPVDCP8ZrQfzV/Ob8fr6Rx0fXbtjNZXhdsKz10MoDxm43BcRo5B4lzRoRuPC8rky2wbOcETAFK4OdQSWePGR8qLFXq74FbwSPUxSJFRyr7kTZk5Zhfs0M7p7QboTNZeaVjRDd06qtZOBxXPde25/EwDoKrnfVQ8NpP1Ff8nr4/olu128qFaPyu62mlSjavDKct1c9DN52w8VbluflZ4v9OXyWOrPDfCcYX2Vfsj2Z0G6kjeVVA5FKO+VsbuxvxsDtJuWZVXW+XajG87Ob5F74z0QMXnWT4DWv49ncJuG0g1Vu4nb8905OUEzhr07RyCzDJwG13gT96r7FyVpz46WzasnzXEGUwKIhGs4aG0dDUOGkEB5oKzD3nI5NkNbi84zvquNjgA2B8kkQ2ke7zSnMwed+B5kOTb4LC/oAVZ1W4bMFZw1z2CT/6WWt9O6JlgtMc9tiLSL4d1e0CKB/5OF85sYZcIwSiNW99FbyUD3P3udz+5z33uc/ZQDx7ILB0fG3Pu/XENnNLRr9Ym7TsdMpOH8eVarGyY7Df7ya1jVZ3EwXV7rgvG6+upo4/L6pFso57TZRQ08fnywFr+d5z9jWdd9pbLLR8b4/fMfcqszHkG6qo5rejHtjEynBjT20xW5Bw67X17Hf0zdtZczj0y4N73vvdBbvhxGHe4wx1O7na3ux2CS69//evPzoD1RBkPGHUBS5eZAgLC+s2LAs49sNQpwGOhMoSdcbyM94sQ1VsefLsIBNJv9vjm25a8HY/ew/BE9SsjxtPKNPm81Ung+6xRYiNDtbvm9MgxV/SY1a36cvqmIJRyu8c97nGm5Ehl5W1THuAb9XFesNLmqvE7a+M86q7OZ6WIRob26JrzRrVGOwena2cVVpVSd69a7zPnqDOgq3a9fPbhqfP+pI43UXq6eoXfiF9SqSAvZMRqbXG2w6te9aqzgyp9fMggf/uKp4WrjOQWrz3txnkloJuDdAAqGTQy+ChX1R/1XeGXZSu8vM9ubea66+qM9GZVtxpTNb+Vflnhz5HcqNZOluv6H/VbzUvOZ/afkPdmc9zRbGZEVvis6IcRT1VlOtnWya5Z2yOdkmWyrc42mcmSXBcrc9fZIl35Y2GEu98bZSvNaDBaL9nuDA9ku/5LX8h5IOihbH1/ALEK6Tx26+9KgDuq2N/glZlL7oxit6MrCY6QKcOh0zxhx/ETDdXWne50p8N/OWYKaJBRI8AG4EEQ29igm9qVbUyb8gE4BFzzpXIEpPBHmFMCEqqDn6B+/HXibLsns4q5oz7b9eAz6nL+keghpxLagLPTFwfYaYuMI7ima+BChjU0cR7Ks5AyKOMP7PVbNpDoJLpzuDq4KrCkvjQ/97vf/Q515SS7neN8AF3cUQY3xyPXamax4OR7ff+uemTIecDEeZd2K1sht31l/5Xu7XRUZjT5vezX31zmdKps2UpfuNyogjQVftXh6ZT1F9jknDA25+2Uq5nZRT2/Dw9XstfH6LI2x1/pXwcv51sVPcB6bWxN9PnPwJqXI5mD4Ctl/KB7rQ218cu//MtngV6tJa0dBZgUF3nFK15x9kIg6IDvTnzC+Rg+dVmA36Kyjs8lPbx71ejYqrySqao2mdBMRfMFJaiYxtsRobRFRcJTykL1fGvKaDxqW3uCFSWEWSQAOYNFSsyDWjODwBe7f7L/CqcZjAx671MKT0Kd/dH6iC4cdKh0Vd6c0eGxivMqX6zUX3F8LgaHES7d/UrBJF5bDOqubNV3NbZVI9vrH7t+E58VGPU1U7hpiFZtOxBQQtAiYPVb/K0gqhtQHU+PFCx8SJBba+i93uu9Tj78wz/8IG/Ux//8n//z8IQBAxTQd38rDTKM4DXp5R782uIAX0qY8W7SbDSvWd/Ljnhl1l7imcbMjBezncpQOwZyzXVjqYwvr9+NN9uvaF/NT9Vup0+qtis5ONLLo7FUfD4yiCt8q75GBuQqVHJha7sjPd2V8YBz4tG1Vcn3dDRWYIVG3VyM1ujWNbRlrqo1MGq3q5v1V3XuaN0SIJCDICdC93C+/dDqDs8VvqfcVv6+FOCOXpWVkvJY/3mhD/fY6qF72NwemONAaexZtrLxcImtV2QfuO5We/5mNPQvW7oEZC+Av593Irxok+84axqHPgSrpPPxIzzbwM82Ybye3QEe8jn0nQAX/EI9PyhY4/cAgL/pjcxqjhjRdTmpnI9EprefY4sfhjzC4eXN3dBTZUVv+V3QBdpp3K997WsPZbQbRdlLus8xAqwN5lMfz3pinJ7lAeSOFGjhGXPOj1nfD172bBPadl7ttm9B385mSF3p68DP5PS1m/ow8c+y2XanA1OO+HiZ4xy7B/xW7PMVm5X5TDpBE09y8LXhb410ujt+nQ2V2Tx+D6CMByV9Td4Uc582a2f/eMwAXJh7gr1aq7xciK2kjFv37nWvex3avP7668+O22DNevai70BK3mNHBzKSYP0lDyzNDPfZ/Sw3MjYqJUx00COgLjhwGkfGGVtUXvOa15xl6GiSZk+GmBjSWF1gI7RVRs6jR41Hxjntokg4i0XfhQ9vrRBkdN7rdkZ1Z0RwT3groMRBgH5QmJhXuMjQwSEfbYHKMVXjHEHyQmcAV30lXUZ4XUqoeLYS/v6beingK4dlVHZlbKNys3mtFFOOuzO+/bdfnxn7I6WX7eX/VOI8feNAT/hca19rNg2yTiFWdMnfkg8PfOADTx75yEeefOAHfuDJ4x73uIOh9MpXvvLkF3/xF09+5Vd+5SD4s57WnJSHjDAMWwy2TGW9mmBlDXbKOo0m7neK2ee14qX87313PNRt5cl1yLVqvKP1t1Vepgzs5EHSqJMfVV+jull+ZYyj8mlIVmPooLtf6beOztV8dWU7enVj9HojWndtZXvdvFV1ZvKzuz6zSWZ9rpQfzdsqrOq1Faj4esWWqerm9S30yP+SPXraLKcauxLDnoBI2n4jvCuHqXJurhRUMqGSQ/52MWjlDhh+ABk2XGO7l59XSFtkChMg4iE1uhdcyBrOg5Y90IC9TiaArhHoUt8cyE3ACb+AMeIw6jtvowYPAj0Cz06irr8WXIEpDhlnO1qeEeNb6vKNUtwXTYSP/stO0oetea4fVQY6QW/fBocPht0iUAaSb+3n4ZjoR1YGASnfeYKdpv/cY2wKqPFCp/T5qq1kLrsy+QB6px2QNonzQrWOCDL4dsLkb89egT8SR39oAJ3T9qlkMfj5OvIxug2Z2UwecACoS1ag40kdL5fyeiT/mYdqWxr3oFfKjJxr1rjze7WdsfrvY/Ygac6/j8nnsstcuzYCT3x3/FnDvtPJ2+INlLwISGtAsk1r03mV+kp4UZBWvgby0dcQa1VteyaSB03JqoSel/SMpWMhjdV0CjqHomrDD8RljzRCj6ASaWCVM+BApNwPtsq+EofKKIWhidznJIwUOIudiDyv3yRwJedS22YkPGfpaH7414rhAD1UT4zq5yt5RgdPX5R5QRpyl/I4G+8MRg7NH0boHIiR8zEzGH29pGNWXavqd/fBpSrf4T4y/CuHNZXgitM2osmobNIFw1QZeJxLgNHnZytVdJj1mb+1jh//+MeffPInf/JB2MtQetGLXnTy8pe//PDUtTvLTeDB84qOq3x1uaFT2jNDg7pZZpU/u/nJ/ym/va4bElWfnR5ZhWqtOuQayd8jGlZ0r/DujL+EkfzpxjKb15EcqeanklPVtfyeNFkZ16jNGT1m8qsbf9bvDN+sm/1slQkjXLt5GY01x5NwMbJqxqfHyLwVWbqK0xY95fX9v+pIFylLQzYtzq2cZoFvr1rh35ynysaucL+c4HhUDyp9DJnp4XLax4CzhHPENir8Atmw+u0Oluxs2bQZPPLsIt++ou9sk/NsAIJW2P8EaGRXyB/Jw8DBnwwLZanxAJlx0x4OPXQhy0c8g6/BOMjo4eE0WyvxcQSOJ33hvxDMkb8hfPyYAJVVPx6U8iAYgSt92L7JmOnfM8TBhe16zIt8O7YqCkRLMsh8uyNBPeGj/qAf68QdZc+6gadyreTLWTzgkbxZ8WClP/KcIw8geXseuOtkXm6FI0CQfXsZcKRdH4evK8bU2T6ZyNHpLb/Xtcd4s4+UbR5U7rYrZhAot/uNxtPZU9C1k7XON06Ta+y/ywzHhX4r2jvPJo/qvoLSHIOhtUF2oe5JfuDDQxvWC+PggYXLRD+s3sH9D86TuuKBpZHhktc65Zapnt62BivhIwJL0BGFZ3+0hEx1zlGHH9cqY7wqR0SPyYEBXPGtGivUk0DX9jptR0MpEclni54rplwUBKZcyWGQVHtyky4oSPaoMk7fqw3Ter1KSHZOx1YDbquRed4wMpZn9UZGnsOINiMedPz8u/e56twkLjmW0f2unQ5mvNApok5JVDjN1j3rIQ+ky3ojQ76ipwOK5f73v//hwD319WM/9mMn/+E//IdDptKrX/3qC7Kjsh1kihuuyD7PXJrhebmh4vlO1q84nNVcurOR97ye47KK+zH3u/W90n+nK7t1VxmxXVuzMeRTwkr/VQZjh3e1TlfXprc/6mel707GZvkOj1H2WtfuSr+5HpJnKhmetJ/RZss24cQrv3djyj5GzlDHS1nG269kxwruK7BlTqsxdDh1+n2L3SO7j8OcpS/k3POUOp9mz2yGtGc73K4UOG+ObAofQ2YGoGMJaPiWNEE+XObNbjxAxTHUd172g23gZ7WoXer425YEBHLow7NveDscOyEIgjB/4KC+2QJJWfDw14pTz19DztuwPfDEuLEbCC6RHQ0N/W1tBKjwrXwbG1vfcFSxS1QXXKEBwTT15WfWUscDZ/4wXgFV4aGPHGj8HWiQ50IRGCOAJlrqaAG2NnoGDuOqZLHzEjhxrwoMAJlJkzKUshmcGrWJz5XyLx94ZXZOJ3u5l9lmXM/g0yx442PLMXv72Zf78t1uh6Stl3e7vdP13p4HEjsZU9lmI/vH8fYANtmKlS1+UxyI7/PnfEwdeJQ15vOsfhTXEI8TaJW8ELCNlrNcPf5Bu34uHOPw4zQExFBc1zDuDASe6+HdW5WmMwaEdQb2cvnbF0wqVIQAQpiFQyBkNbBTGcwrIOJL+PFkwrfEoUh8wjqAHmQqXXfddWW0vIoYOk3VtxhKEUuUq+oLD1dUnZHI9iBlJJH+xljAhTL+5Czn04VgCi7ubzUEc7zH3KPvY/vdin8Ku9G6GRmpXXveRiUgu7GOnBz/PnISsv9O0Wydu5EDWo3d63Z06KAzzGeGuN9PJZJ4iPcl4J/xjGccsqO0/e3FL37xyS/8wi+cPW1AgLvi9vWEsalgM2n+MpxuvPHGs6fZFU2uFKRBUt0fOZ8jHsrxHbOuZ/13eCeOWW7kiHbrs8O/anfU58g4GuE0KjOSV97fqI/ZWGd8uiLrRrK5G0vXd85XZ2Rm/eTbzsmYrY3qnhue/E4advoDXdzxRrXmLmZNpc02G+tItl5KGTbj2SprYGYDzNbLSEe64c8ZlrLZ9F0OfmXPrs7PiDeupJ4Q5JN7QcpID+BU8oeghOxvzhbCWSIA5A9+VY5zSvyoCeYG58y3joALgSsesJLlLGC7m4AgDJkFPDzi+Az9J/iRW9/BUXU8SOYPmQQEyKq3wOELsdVfH3YZQGvo6tkuPCjnfCTKE2CjHNvzCergvBM0I0hHP37wL84tD8toX1tAldGt+7Jr1Ie3wfEkjEnjhP6aR2WG68M43O/w7A+Xo36f/6lTq+wi502g028uY70O5Vw+Z5CH/94OO0k8oOTlKtlV2R0VnlUwB7/Py3iAz9ek76bp5GFFS8q7v5t+o7fj/VZZR9Cokm8pa5xuHU7U88AkWXPwiOtbAetdwPpgvVGnOqqHNhxHzk6iD+10eNCDHnTwC7RWhIvkCmtIZeQf4KszTt9u58kmHujNLCrwoM4lCSytGmhJKP+ujyaEV3sj+PMtTFsM8MzIqYzAjpm3GPL+nYO/BXL6SLGVMPQU0hmNWAgSmGIMBakYE8oq26mYUf3zxgVXjKTCCvKplwNOsNpAUSd92X6YggZlwlMa6IDSrSLwM8N65GzN4BijKZVA12/VbtdfZbiv4r+1v87Q7MbTCfgOh5ExXq2VLDeaz5GzmPhUDtDM4F5xdGZzmPWq/vNpCkbYj/7oj548/elPP1O+GJW+jpCLGK0cUsmb5GQ0oXg5eNSDxa4ItjiFlwqSnqtrujN6sk7VVsWjWbYrM/peOTQzmV7RoCvXzVk3j1t4eUSDbiwj4zPLr5bbIgNHeq7Tx953p9dnOmfUbodfJd+r/n08Iz04Ss/n94pMrepvLU+Zlbnr9GdVLvtzuZX236iv2b1Vm2M0v7OxZp8dvSr9letQOkFZrAB212wMVf8jqGTClYIua0SAfenl3OHlN29D8iAHD5ihB+sKB4kMId2XnS27m2M1OASbPtk54IfosnXOt5MAZCmh/8GTnRX66Dtb78mU4ggKsqLyoTn0wEYQzu44kv2Dw+u+g5fz7TW07UeB+A4FAf4ZNIeuHiQh0CG82LLm9pBnf/l1MjHwO3j5kR+oDp090IZ/RAaWrslGuutd73p2DAqBKZeZlPVzj5w2lRxzmUwdAgTOi84H2Yb/Tn2ZNrlfc76HdvkQP21Qv5eBFNqurmegt5KDTh8/BN2zvKp6GVCr6O50dt71s+XAz3ElkJS6xGnusoV7GSDL4BH38igK/+4PhjMIea1lTPmbGT04Bx0oW9GPAKp+a5x6QK21z4u2yDbUd+2O0KHd0iO+DdgDytDA3zrpc5ry1wPQV3wrXLWw9CFVS5E1gjESInrVJIKgMgrz+8z4G+FS3e8M8GqR859zWiTIpAx0nTc95L7aqk//T+aTfpOqRjv6rz78rSBenychKD8WGYxKpgNPCyra8ZTsda973aGumBSlC2MrBU9lnGZkVGgLn79qUoE1tUX5SuisGGGdEdTVmd2rYNTPCswM1jT8joFUjFVbyeMzB2crTTplm+1WTlY1jlm/s7XjZVbmuCtXXVsx0CteTty1fnSIHoaI34OGyEStOa1jzlaTYiBgLOOW1/0KMFJ9S1w331cDVPzbrf3OIOvmsOL7zhjyfka4znDK/qtxrvRV9b0yf7O1n7yW7SZNcgxV/arfqv+qTHUt5Upl1Gf9NB5X7YAZn62umZFs21K3g04Wdb87fqnmcIU2W2g6w3NLnVW+p+zo+mxtz/pJWbPCzx1fVLIscXTHSvZSZxvNeHgFtpa/1ODOloBslszkwPFCj3p2jLLsCRL5mT6+fYrf/l/A2UfSpzrfCt3LeaZ+cK30tHSw2+Ic0u0ZJGQbcSC3HsbqPw+TyJbSg2QFsbTzQW2qfY1FH+l8d4j5rjIEnvAPyPwhuOZb2ATudPt2GRxG6KR6nu3F99zKJsiHywI/DJg3VWHf+DyAL0El/BPRQfTgAHM+AujAebrgxAe7SG2KrmQ4eYCrsmep4w6378jwax5M8iCAt5Nyw8sRqON6yoWKxhlw8HLZf2cD+U4ev+/ggSsPVjnvVDZZBoy4V2138wBH2sNezoPHHhghcJNBma7/KrPK62V2TvKJ183ACrzFfGW22anNE/NOkMbx9XWUW50dPOAlGfSSl7zkkJV0v/vd7xBLUbuKH0gm6PxWP2+MYDp4kUHofJ540ydbafMNfFf08G6fbCZAzpMIocUPM+u7Bqs3BvAkoAMmYWQUZ/m83ilXhKTfq5w2nwB9hDMBFO+zMj4qY4+F4ILehbsYWIySB/8l3pTn6YIYi0gpe8SJfFbtiO7qh0wJFqf6RWHnUwo9JdB8al59PzWBqZU5PQY6A3zFaEoheSnw2mKcj/ikK9Px86zcCIcZLSrHdYRj18/oWufUV+u4w2OG+yrevsYTn5W5dlmBgvY2WLdaK9oCy3kL+i8loes86cOo9LR93yu9xTG7lJBKFfz8Ht+r8hUfVmuhor3rhhmOXqe61jl3o6ySTqfM8B7hkdc65zTb6vih4sHRuB3fEW6d0V71M1uLVd9VvQ6nCo/ZmLNMfq9oWK3zlXGNrm2BFZm9tY9jcJm139F0lWar/XR21+xetp1zNBqX49nxSuqwDjfAnYC0VUa4rdAqy6xub7hUgG7DsepkqNNYwR8dGyEgWIN+9TcZCXDq1A/Z/NjaBCjYZSCdq6AOuyhkt+LYyi7GcaNP+vfteODBQyGBP/yRHe6ZTgKNicAOZ6Ky00C2gK77m6cVqKJNMm8IWPn2PBxefgPQEnoooOPnIfnB5h70yywXHGGCfH4WpPwHsoqch/O15bx9TjiK3mR4QducQ8bHHMET6lPjYEucyunBdrWN1O2E1An8z61RrBUvz7XcNlYFa8A/bT/o7Lh45kvKFupVgYxRhtVI9via84AQ/Xh/zg9OL+rkfb/nmXJVgoNn+OQ4qgfZHnBzeZl9ZRlvy3k65a2Pt5LhrGEPGJ7a2VWqw7ogMMkYCdr6WWDOKxWfUEb9siuKdcN61lpSYIl7yf9JJ3AVdNl2q3b1RQWWVoyZqpy+SwApVVGvrSc7hyCIFIV+K83Lo9s+oGSCTihUuHT4eR88ASG1TEJRASOEbkXsFeNyNDFMrujgTwxUVr+VFioByWsDR23AdP5kg2sZrU5jnd+co+RvkBBUBojoJUXs2+BoU+1JaWiu/Y0mI6jmZAusOCzVmDvj7WKM/lUjeOX+Kk55r1ofKRzz3mgt5fysyoIZzAzmxCFxX4WkYSrFbLeiZcqAUV85b9UTEa0brRHS4AkQU59gMAdZ8qpd30N+KebkPMDX8Sq9uzF04+r4tLpXrZ2VuazaGUGlF2b1klccp1WeO1ZP02clA7s10+m9ahwjWZJtu3xaGWund1fkfSUP8/uobe65XeLQjaujbzXmTqZ3dE08q3FkX6M+KlpW9OjGXo2xqte1keU7Xtsq97bonKqOy/NR/RHdEvy+O2gj27Ki88p4rgZdkdszOofVf/Mw8773ve/BJtZ5I36gtNrBFnVbWDqWLB8Bb1uWPiW4pIx8nDE+6GSCS+wg8C04PLSVvcth2CqnB0NkoAHen5+BJOChsOx93WMXgjv3nD2EPe5BF7dP2CLIWUie+YNvoPZ5YE19nEs/l8rPYEldzdyAH0eA8HY5gne+lQ0cOG9K3337G/TIrUt+sDDXwMvPk5FPovkmsyyTAxxy7cCPK9lNVRKCl/WAAPc92OS6w9dxBnR8HrLOTL5QJoNRWT/lmm+Hc76qbM1qC12W68bZ2bBVfxmAc3mRQb2UGz5Pnv24xZ6qdCLBTh/jTRGM0n8Ol3cfP7Omkg7+9jZw9UO9kUWSgfpNUojWkh/+n2NgHLmuU5/RD0Bm4SUJLG1RRKm42EtLwAOAISRocn8nfZI2SUoWwipx48mBl8s3Qzh+Xk+43ec+9zkoBNWXsNIWPaWcMQmVc1gp/sqwre7BYBzIC510TcwhplHWj789KtsUbmzH86cNvCkC3KoDzRKXajyVMBGIRgThSJtDgQiEs2jJgvK2cg58TBVtLxaqNnJRJz6r7XY8dUwblZFflUlccxwd7604I12ZbDP76wzgmVFd8dao7VQ+3k41zop2WX50rcOpGpf3082ll0FWYWAh18hU8m2tGM0CnlRUyv9KQkcPYEQzvqdyWx3XqOwMry3tVPM4470Rf2e9ytCYyaXsvzLwOlmwReZVBuls/qp71e/Ef9R3JXPTgPUxjmCVDtWYO9ndyUP/XfHSrJ+RvOlkV9d/V26rDsx2Rm2stj3igfxe8VFF54sdY2V4z8Yw0u2zul7nYul5XvXOE6BhOp0+Zn38ib+AzB4ewqi8v5nN/QKCPrJTeZGN6uZrzHmQSpaQ7vNQRzjgS6CrBarLG+b0nWwf/fZsJd0jUAXd2VrHWUvseKAcuwTwe2jfHzyTAcEYCEyBm59nS0AN34vxK5hGsMa33Tn/ebZUHuLL2LBRuMeWft+aRznOmRJeuqZMI15mAniwi+sZaMJf1HcezMsm6l50VCUmOK0qR5/73dYu7vs9fmeAyoNKlY3j/XudSscmLj6G1H25XazS4V4WXKiT5ekHGmR2UJWx1GUXVVvw6CeDYT4Gx80DcNU85JxTLrOwuJ/z0MknyiKLqrHf+u2BXYIy1Tzjs/t8etAyxwkQHBaI//0N104LD1A5PXxbYmeLUO6SHt7dwarh7wJa31EGnlmTQgvhqACFv/FM0TnfHoYA5ABrhKFSxngVX05eLnq1r0g3KaXgRKqo13FYMZb9Xt6HLpxJRLYUB9B1W+CoK0A5aQwaC+mz+vDq2kyJTbxWnJc0kvIgPw7v4+OKyfHdamBdDKSgyeuzelvLjGg5MzQ7R6JSXp2DxfcZ7SoFSp9b6V4J3gqvlfojSHzz3gz3ip6d8kxeRU6QTl/tX862KzyTJtA80/pZu5lezRuDUi7MnJDLCTmXM4czy+X3apwzJ69yKCv8Vnm9M+gq3s25qBR3xa+dflqRGR1U+mmmT6rrXb2VuV2RTRX9qjFUZSq+yXu5pitDu5K/Vb1KvmU/FW/MxrQFjlnnlXzv1saMP0cw4pURL4/66fim46WU6TPeXhlTNY7ZGDHcM6Nh1M/lkuFXUlcwToIc+QSdD/qV+9J/ylYisJLn7fj2Exw7lZEfIJ+BYxpwZnmlPTa0glDaQaGgi/rzs019qxgPgwQ8xNV1nDoCYO58exmyrziH0Z1e7AEeLkEvAcEmMpIYC+cKeZCI3+Cna9jonMNCm5nV4y8BEpA5ge3jMtPfigcN9ZsAE3NM0A1bRzTylwp5pg7tgbuf94JfqLb8iA7myWkPZNClkuU+LsfF3/DF/NEnQT3na+pT1s8XYp4zy8yvM5YMpjkf5Dj8k+06zvTjOI5sx7znQaeKb5zWVaDLv2dQxwMzKZe55/Lc5aqD82iOJQOCTnvmqRp38stoe+Bt3h7Qdn4nW5F1RMKF04h14hmELqsohx/CeUlZxs9E8vnx86AyA8zp7TwMvqv2yrkFlkYd+mQQUZYwdeEgINU0hSiZRDoBncif2iI7h4i7ykmYqW1STDnITW1Jqbjictz10eSrLAfuiaD6rv/+trMcUzf2VQPI6cSb5nyiu8Ve1eXAQVJQWUSkz7qSAJ/K4K1+V31y9pO/ic7PhRHdPG3X+7ycxlNneHaG86U0+DtnpWsjhdvI4cqIf45lVDfLHEOH0XgqfEY4jWjS4Z7OXuUQjsrm9wpXyR29eUEBaO1lJhU/FbQL7A4njEb9J8ju5yJoHclI4ymcQH1J5umTQd2OLpcTZk5cVX60BpPvZzIr61VroAPvq+o/63dG2Gj8FY5dexUvdrIzja2qTIfTiixOg5zvW8abc1jVrcZZ0TzxyDHP9HJHm87A7mg+Wt/ZNt/TeE68tqydrs5oHN14EqcVGnR1V+5t1f8V7p2s8P8zfFfs18RjNk6cCwUoZI8p850M05nOq/5ntoUgt2Aeo7OvpL6o1qzrTXfyfOzYu2QFqTzZL37grMoRfOBtYyrLYd8cEs2DWOlW6XcyhfTddbTTmq1e+DGuwzmLCadR9TwjSviAl2cDZNYGut3pIrzdafXDqX2rGcEyXkWuttiGg9OJbU5d305EWWwLbHoPkrn8TzyZN9EYP4wgGg/qOVNJPgTzmOuZwB9zmgdg8wCeIKKuc6ZrvgW70pEeAPFxeRkPAnm2y8gOAfDBoJ+Pk0+VLZOBhKqflIN+37d6MYakg/vaKWvAJddq4kMZeKrTv+AAPbKNSl/5/BC888DbyD6obCf6rjKqvG8PdnmAKufK62WA7NQCPZzLBg5at2RF+hvd9JFMEf/Kl5fOSB7OwKD3w/oc2YjQ3s9yHgWOtujSy/ZWOIABirgiFgfT+pMKRc7zVfZ8/E1JzvBy7kR4CSYRWmWI4pMWqkmTIhGoXEY36Uv4SPgRkdd1MYS/iSkZeTQR1fUVp6K6Xhkx1TXRTspTOPteaU9RXTXSRn3xm0PE9DYKFqv6VhvsI+eVqd34vM1KUBwLs3aqOdxq6FZtrjoko/ozoz9x5nclML2c/1+lcaWUR/OUSjnvVW3nvWrsXd3O6K+USgWJbxpMXk9rSjLnSU960smDH/zgk6c85SknP/3TP31YA4I0PitaJV20NiQTScGnvuSWFIxkIsqFJ3ycA9HJhivpLFzsOprxzYiWI37MchX/jNadl+3KdHh3fL7yO8dZyesZXlV72VdHk5V1vDKWbj2OjPLqWmWAdmOczWc1tpHc9f5X+GYkqzuDuGtvZTwjfFP+z3h4dTxd3xW/Zj8pH1d0Z/ab85D4Jy7prM3w7MbXgY9HNuUf/aN/9GDvvuAFLzg8iPA3H3t74D6jVVWvo1F1rsnVBOkk8qmyRnJu0ZdsJSdgQmYAWT2ivYDMHPkCsld5cxuHfXuAwbej83ZWgb8lzh/+uL8h/0Mf1SE447qaPnjbKwEu33mR9hNj9212bKHzrGnRRH2Dq3jNaUZwBiedYys4QBv68YIQnHDf+seDLw9+wFv0r3FpPB40UptaD/qth2I42769j8CRZ4D4uTX8p1yuB8ZDYM13nYB/2nmZSZS6xR15z073vvP8Xejt9Z1O/hDS+dkTFzJonNe9rypjxrNuUuf6mnO6dPrJv3uWlt/zM7nSnqZclTHWQfZTJYWkbKv8jtQx3bayys9x2uacOB6ZYSeAV/ycNrZoMiZ9v8c97nH4qD3kjNaQXubzqle96uT6668/e8OixyFoT5DbJcGFnVeCzKYEaKvSiazJkW667IGlSvlrwBI2r3jFKw7Ch7fBadA6R0hBEcrnh6g193laIAHLqegIFYShL2AJTl6/VxkwCGxwReCxhWxkzCaDz5yD1Ta6PjvjjvKePlstxG6e8toMX/UjptcWPr0ZjjNidI8DhzkQccaUlcDJRT7CJ8vNys5gNl+JezdXWwy6Smh1hmGWAY9Zn4lrjtHbyDLd3KSSq9qt6DlzUlJpVONLA6zqewTZr2/fTCWJQXPPe97z5H3e531OHvrQh5787M/+7GENVFl5K32TqanvPL3w7b5qm3IeIE75WinJKwEjGdk5SSNeqYyCWb9pTFVrp+KnyiDx69W1qny1Zkfjnq2pjo6z67PxjdZ30rQaa6XjZ/e7ddzNbSfTRjp2RvdujCNZuAojmvi1FV4ejb2TsyOY6f4RTimLZ/3M2qpw6OZpi1GbbY7W9AqvH2NHUIeHev7QshvLbC3MeKWSLZ3t4HUv1k66GHAnHceRIIbL6FwP2PUcoUFmkICAE3pU38lgka+gnQ881JYjJ9vVt0zpGgESBaBwmP0AbMcVW5dy/mpu/A2y9z0rGd+FTCu145kxrsMYk+wDgmmerUOADCeYjCjPziAg4z4Vb+lmxwFtCSfhDv4ezCC7wTMfPOhDoEttYb/outryrDJeRJJb7dz2wg6CNgTxOP/KA4r+djz8RQ9YERiCrzxI4MHLXE8uaz2jS9d9m1zafx4cpT3aSDla+X0ZqHBae13apG7aiN6248/9DEokVPo6AxGOd/JuZ8P72vcgFWUyUNbpBsfJy8KnHnTzdjJTzfvKea74wfmlGu+1b49DgB/BW/3mqAutO+1+ULD7TW960yGTDxmhutIZ8jX0QMIzHmnf8coApvdPNl/OvZfLN9c5fxCs5hy4KxJYGjkNEFUBJCGpoAMDzi1TlBf4/l2I5WmvEAmBBg607VFDcPJFp/vCR3hxXe3omra6eMZNNc7O2ci+Vmjn31eM6aybQsDHOcJvNo6qPLRTxoVoh9IjW4knEqtGYS7SlXGfJ6yMv4ItRi/tX0ydVEKdoV45EiOj3wV7da/Da/R7dv0YB6bj54sxlN3gEg9jcMkg4rXDPDWQAtC9937v9z570tcp/Y7OjicBWgwulIPLADc0RvS50s5CZygBI6eqcypnfD6ScZ1z4k+Z0ig6htc6p46yFf5pjFRGStX2Kqz02dGqksOzceeYu7lflSUd/rkOsk71uxv7SN5U+rfitZlRPuP/qg9BxZ85lqq95LtR327oj3BK3Cqcq35XaVA5UqPyHWzVq46/t7FVt1S0wbnWm5A5IiDLr9oCI9ttJv+2tHk5oZIjnUOePCV7U9sMfTsHR1aQzYIjJx2u7woq6YE2GT84SgQtBGTsKAuZnRJ5bk/qe/BVGwQQCVbpOkEljqjgMHF8knyxjQdrCKbgmIqPyLLCtiaAJprgJPr2Md+uRJBKfXGANtt1wIFsLtrBH6oebGVWBplS+Fr0hd9GJhlz7dvtfDsV2dskC1CHAJuuEbTyjC22R3p2h28Ryq2VgI/Lt5Cl3eX+ZmYv+TqE7rRRZfN4X5XOHfltXj6DWm7bMGZo4LK82m7HPGRWleuh5Psce2XHVHaDt1fZGz5HKSfTTqnsO//d2XhdVmeOy4NPLofyAc9NRnfqkbTimXTi5wc84AFnWXwElcTTZBppHh74wAce7pFxCS+xe8EDxjkm/wiQi3nuWK5V1p1vKd7ix1/SjCWgmiyPcINwt0WNJ/cSgJ6phFAitZjgFKmUTmwWSk6696U+9FY2bXXhbCAFlaRgcouLj2UElWOQ9zrjuMMzGX6lbmWQHguVQEZ587QnjYAcdwqBY4zBmZNT4Zu0XKmTOG/BZxU6OqRD0dVNwVgpMO8n+822qvsVLx8z3q7OFqM96XEefE0/Eq4yWJWeqieWepLwyle+8uy1wepL18T3khVSDFsdjgpnFE41zoo/Rg7esevpUsBsDGkYzHizMhRGfc8crqrNrJ84ZNr6MePvZFHXZ0WLCscOZmUq4+piYCSXsswM50qXpTzqaFT9z3GvQiV3Rjivtl/RqhvbjB9GuPm9To5vlTWzsZ6HXJ7BMXw7Gl9Fi5HeG+ltzu4h24RzfqpA3kymdXpwZGeO7JyrAbD99d9t9tw2wzVseelj2Zx62s9DGQInOEtk8ojunLVKn3qo7Q64yhCsIUAin0D11Adn9rieZoeDHxSOv8LWOO771i4ycQQ8+IanoAGBGvUhn0fnE3HmE9k+vk0tX2IEPf2tbGT6qB4P8vGf8J0ox2HZBN38nFkCTvpw9IX7Wj5O8b3wx6fyNniQBh0c/8zs4cMDf+YI/Mha8gAhdT1ry/nOgz3eX/Kdrzv3IWmHefY1Vq1vt8m7teC4QKcVXeJ2FH17QItghAdIciuq98H/KqMp24DeObYMWvn3DPx0dpEH3vz+SJ877nk/6eH1nIZpcyQN4eMMOF0TATWCt+JL3xqrdagHDtCJLbyq41tukTGOr67zMgJebMYaEJCtl7Z1ZlHluvXteuw+oj2yC69YYGmkwCql6EKjU4walFJWlTkgIa+nCGwhUeCH+rxRDSHoB4SzSLNt+hTx1Advm+B1n1VQaWX8M4Pa+68Ex8xhGBkTVbmqj4t1JCpjNqPnIwOsM+iyTGXUreI9Mgg7w/FYmDmEW+FY59FpNFNkKaArvqp4N7+fp3zo1k5nJI94rLrfPbXS9bvc5S4n7/me73kIKiFkeUUxRiBPyjwLkvYS727d5TV9d8FdjalaP/7EZUbfywHJT1t519vo2qvqVGtlZoR0/VRyIg2PxKEzfDr6ON6VQ+l8mpB4VnyRuHbj7/Ab6asKh6r/Cu+KBjkPWXZE0xl/5dpJ42+kTzq8Kr3V0aaCipdXYXX8I1zSgO76GK2PEe4jWs3w9d8r62fF3joWKl7J8XX8yXcchmqM3uZMPnnZLXCl9cEI8mwSH2/l6GNfkuUjf0B6WsGLDFLIR5DOlg5XppLucd4n2+A4I0kPiAhWkW2j37ov/0JBHc4OEg4KpnhWMfhhG6gNshR8Z4WALXUqQ1DHt6Ig8zmgW+MgKCmcORScoArBJj8PSfjwnUASeKosb4kWyN7hoTv+jh8u7IEFMi00FvrVfflhbO2jXtpZbO0RkAXlYwF8TXngxw9rZxuc+hM+nIOrsgSwCHTQpsB9QNplbjIwCa9l+Zxz3yZXjcH9oQy00H9na1T2Y2W7Vvatt5E4juQIOFXjSXmXazJ1YGbLjTJwvR/Aec/H4tu6GG/6O/owDtaH+//wl4A5yEBb9l3NlfOL0+hWbw/qaj0QFCLg42+Ek0whUwhfw89DgoegJ2OmjD6Sg7RDwNjnJM9icp5GTngmI0FbD3iNMprPJbA0M+QcZoZgMpaX8cgi7ShCJyKSjkjUnDqkkin45AvEUyUTP+/fI30z46lqx7+7Yswxdobpln62lO0MtK7NizF4ffyeMswcbG175Ax1uFcOQeI56+NiDbqZ8M6+Z4Z6xyPV2vH/FR9Uc98pKn53fXfzk/SbOZ+VMq36TcU74o+qv47eCHYZPxgs4mF/Xa6noSKPeFraPflJqIyIEX26e9X3qwFSvo94qSpX8WZeW6Ft4pN8Q/nOyR2tlZXf3bXVsSXvz2RSRcuRnBnRodLPVZlujSffdvK40v9VX9m+/670dIVHjrtqq9oW4HUrvl1Zi6O5q2g0amNkAySuK7plK1Q82dl5HY6J66yf0VhWdGLVRtpnIzy6tZhjyfnBuXCnwsuN1nc3jhms2pJXA7DOO72fa5wsF4I+r33ta8+erhN40T19F/DSC877JAihnQhqT2U5P0SOmfwG3eMIB+l3bFgyD8hEAlceLpFJJMcOm0F4cc6QxgEvYCsQXML2oC9952BvHooTsPItKf5gy89PAh8cSLIlODeJQA6ZSzxIxz6HV9lypjYJBuFvEbSSvcQWH7KryITCMfX2OFfXgxycgeV4qS8cXnwJjYPgFUE5zpNiqyFvqvZgFXLd3yjnfkrnG6ITuusZTMly2Q/14Ge/5nWq7Vn+PwOF3if0IvDSybnEJ6/72VqOKzhU+iztCcfBD9/OMfu4s023BfifL/ia+QiJOzzBdzIIPXBU2Y2OA9erQ8WvsfNY6Stx1odzppVxpOC26ujAbuige5JhHKZfjdODP2TvcVZazqPzg8saHxNbgXOeCZBfFVvhZsZBp5hdsIhACH2eIJCSmoTmiYHqq44zBulc3u+K4TczkKpFyX8mPvfpjmiwFSqjeYZvZ6Tm4h7RYGTkqg0JeS0MIrPKBOMpSdfmCLK/HE833tm1ri9vu3IoVqL/Xf8jp6irl+tnxVmpnIx0qCr8/H5VrxtP1eeW+ekM60pwr+JYQUcrlxOkofMdHPT7p37qpw5vhXv2s599SKn3cwJmSq7j42o8KSs6nLOfVTpcKuhkS1d2VLfi9arsypg7Wbulz1H5bkwdr1f6cGWtd79z7mdrtsJ3tGZnY0s5OSs3wpNyM109Gk+1FkbyNg3VmR3Q8dOIF0e8PAKXHckTnb4a4byyHjuaVv36vaxXOTednKzw6fjpGN1b1U05kk7jDPeqLXSJHAVl1egcSjJdslzHwyPen41/Ns9XA+RZH0l/P+uFMm5Xy9Z/9atffdi6rqCFZ6oQVPG3MxEcweFiK5fKSq+TXeD1yAYgA0n98FIf385DRo3u8xZq1ac8WVYEPPRfbbPVhbdeqxwZUhz1wVvjqAcdaNMPhXfnEt+D4AuBGsZPZgK//awkAnK+7Y154e10OLBkLxHkk3/GuZRsqxO9FPDRh7OilC0Fn3KMhp/BRLCKPhizfECyzThXigw1cPdjBTxAkjYY2S/8zqxxaOOyjfa688DgT77rem7D8+8ZeElZ7+14W742wCmzgjxoRvks2+nLmVzPM6e4zjxl0MvXfec/uR2TOpW5yDn1tr3fUdsjOdT5NaknRrbZaZzDlQFM1jTr7VGPetRZth0vIxPPS38Q63A8PSCkewS8ff1U9mBmE+Y5yOzUclrlQeaXJLB0MU7LigHPJJDCKiErIaSPBqgAhZSJDrSqGFeEkuAhDZZF7tH+kSNQKfqRweMfTbaEpj6kbWqSJEwzncwZsHKORoZfZXBUqYizetlGfu+MSfrjt9NCjCulKKUhha9ypB/rzX8cErgCHW06vEfljoHOydpq1DpUPDVqb4ujU9WtfldG7Ur9bjxVW6N5mxm9FT1Wrjm/jsaSOCNoJTvkAEjWcFgmBiBGodawXh395V/+5Qe+ljzieiXPOtlRjaNad9VYXTF0Y7ySsEL/iv+rOeJ7VW7miHW45DaMjlfzd8dro3WW9SqodOAI/6q9Dtfk81UajWRDZWzltey7anO2Jqs6szW2hTccx44Oo7GnAbyyfitjdYaTOw8jOszqV7QZ6foKVu5tpamgyhYb1e8M/VXALkw5WvHfsSB7VVk1sv/cYE98V9Yz5ZD9lX1XPfGvYKb3LydU9mS1taWSA/pIN+u/gnc80PS3t+X2F+7JN4BGBCKwU8lgIBNH8yc/hIdNXldAAIXta75Vzt+y5naCnw2LvyN7Q/24g6nACVlF0Ahn3s/f4TpZUQRMCC7ptwJeuk9mF/T0N1E5falLYI4glGdJkFWFr0UwzDOz8sG/+tcDOc0ZZ82Q/Y3DrN/gpcAeASoccjLEmEvNEbhxKDvy2QOKAnfyGSfj5xplMhPdodL78Jzzr9OU/lNeZTJC2iWubyp7wcvklq3E0cusyLuRH+Z9+Rr2t7KlznMapx3l4+90oAfUUs+AT75Mx3FMGne2XOr4ik5c87GcxtZRMi39TY3i5RtuuOHwNnVdE48/6EEPOvCudIZ85Ze85CVnb4Tz7Yy+G4ixEEhFvpHF6VlT8DrnxMHf4OsBLGRaxY+XJWNpq5KqFITAr2lAyna5+93vfhDKPElQWQlfpY1J8OThW4AIwWHS1f2RkV3hWBkteV84SylwNgtCnzdBcOBvJRQq43xmTPtCh9FgAmeWkaDIfkeGcuUkJOiexi4aSImRkgxeBNhmxlq3oCuajObtYgyorYZxBysGpN9PvhqV74zpFaMyeWo0vzM6d7iOcKjGM4NZH50xnmOr+AnBraC0BD5nN8i4IyCKYOYJnAvr2VhW5innolqf+d/rIF+27Ic+b5it1W5djcboY+rWRyc7V2VMNYZRf1171ZhGZUZlq+sdfau2RjLMy4zkTqV7VtdrhUuHj0Ml3zo5ukWPV2NZaafDr/ue67fTVUDK427eRnhnnzNcZ3opy4x0RodT9XvU1wiHrv9joeOFbkydLTTSZegH2T1el+8r/Wb/Vd0c16jNi7VnzhPcYeFpe8r61NGMCWdNtq90tJwi2dp6KMQ9/AYOnqUtHDXPztE16Xtlvvhb0Qhc8ZYyts954AanjoCT/uuBE1k1nLWkPshe8t+MiSwhf3M2uywAP9qD9vOBNTj5w3QCV2yzI3OKQ3pze5XLkgywgCvzQ2BJ19n25lk1PpeUEcgnEi76cNyAIDP7aMeDa5lZpLHx8F6/mROXj9WDfe7lg6Z8UAi/uJ3l9En6Z4CqsvVSNqd88OAMwUEfu68PDxRWeiP7h9Y+Tg+m+Xk+CT4uv+Y6KO9XY6zazTWfdoqPO3Grtgg6Pk7LbD9x9GzE5LXO/vDxve3tsolMSHCGzir3q7/6qwc5oTe/MSf6/YpXvOLw0ZnPBFG9b+QWQWTmiu2nAuST1hX4IBMIEvtuqtxZVdndlzWwdKyi6gxxfUQwBY8kcMj+QUCyjzcPlsu2vY80RDqGnBmM1Zj1XbhIoZGh48wjXPVfiqJ7ZV+2l9lAFY34LlqR1cUbIEg7RSl1BmQyUS7YLn2TOtU1UoFReCgef9XuFuiEZcV3Kw7LqIzfPy8DbGQEju6PjMJ0QKq6s76zrcQnHaKONhdLp05xzcp3Tlfi242jopG+a80okKSMSJ6S+atrs80qiDNzODonIZ0WPv62HF+bXdrulQYfb8fDFb7dGDqHrOPNTt53dJ+NYYRP4jJrs2ur01UdLtXYk+Zu3I0Mg4621e/Z/G0ZfzWXoznb0p8b9N62G/0dbqvrdyQrZzhmnar/TlZ1fDIbRwWd3Oz0y8wu6myvqsyKbebtrfJXZ2N1DsFIXo3GneOo1nDX5wi3Ud9d2U62zNq6kpAyybdiuW4FZwJG1PE3RhE80ke2sOxQ+Q/5RiOV9TeosVXMn9bjY8ghZDu8QO0pGKSH3rKvyb5XPQJRwh0Hj+CGrgknOY1s72K83CfTSg+2yPoh6EQfvKmNujid9AvOwo23DwrkH9z3vvc9ZEfIr2ILIedJqW0PfmBXkDFE//ngyrMv/Pwr6AJuZGQQxGI+1KZw0X8ODNd9P4OJs5ygGe2y7Y2AGW2oPNlLfiiz60TGQxnGlsEg1ppncrk+ze1NbgtyPf9Dv9wilTLXAz/g7X2pHLSlfPdA0eVRBrmwL/0MXA/QdHbDLCvK++5kltO60nWekcf2zqSX95f2cGZG+blbact7W45TZjb5dx+f43HN2+ns69O3p4ELLxDQR2+eRgbxxkuXd/SDL8CaZ6sq8wcOBFl5kQAy0t+WmPzq48kMrCo4esXOWOpgpLw9asp3EUeTIMGpQSNARopz1chLBqPcSJnnohPTKJjC1pmcGF7bOTIgMr0NHFzwJZ1IbyWzi/JkC8lB9nOlKqMNQYViYp+36vFEpaJd0ocPc0M7PFnJgwdHMDN4OgNti/F+TL/nCbMxbDEKXXh3jlkKbocVBZH9cW00jq3zNIJKqDteI+ev+t717WvOr4mXtaYwYtibrPp+KKvTJ/up7iWNfTwEZFmXKBqCx55a37V5JWE0r5VhUPG0f+942utk+9n2TB6srssOv2r9dTw4os3oOs6XG5mZHs6nk/sVDTqDqao7kiPVvDgdKiOy6mO2djvwsfu1HKP/zvJJiy2062Akk1ZkUzXONIxn/DWS1dV32q8M7JFNMBpHNfYtcmKGfyXTV/C8FPas41TJpNHYve6or9V2VvG+XOB8UG0lyS1LyXfJl2yVEiiQoYCK9KSuSX9iiyI7PXCDI49fwcHasu0VSNI1tSNdzEHRvDpcgG3LIeGcS4QtzHfd42wizj3yMXA2kQO2PsGkip/ohy104KgjKR796EefPPzhDz+zYZSNrWyIX/mVXzl8brzxxgveiObOu/fltPeMDg+CeABP9xiLZxOxk4EAE/d4o5y365lMapM64OlbHRm/68KUGdXDOPc5R7KjaiuDRl7fedeDQK77qsAUPOhBJeo5/Z3Wft1ljI83x0BgsAps5Zrz9sAx+dSDbl2QK/HrdH3qaz+XKXHjWmZfVXPo9MffhhZOT++74n8CRqmfrolALL40tjxj8WC3gskknqiOfAwOwfcAtYCga67R3FZIYIvtvD4/GaDMsfoc5FsRr+rAElAZUxBEe3AVIJFyYN8thPd0toppsv0UMv7f08pYrB4BrPpI4HA5lCGCwRVPKn7/jsDnbBdwIK3Uha+DBKloxALxdD+NTXXYglfRyBeY6KyMK4Jg6lsKSvPg29c6A517pNnpu/BTG/r4mxpWGHTFmNwKK87JFgfmYqByIrZAJcxmxn4nRGY4VOtnZX6OoWM3hhScq/11StXbrvrJdFkJ+3vc4x4Ho4wDKrU2dCYTwj/pUjmmqaCqces7b0DhIE+uqYzWppSRPlueJFwOyHF3NB9drwyPbLtrq3LgkndyzhOXrn/qc727131fmaeKLmnk82IEnBTOb0F3ppzdss5HuK7QLsfbGZArcrYr58beCj7dWlvBY3RvpAuruqO+0m5JvCu+W5mjqo8tfJiOZOI04pnZODrcOxma9ls6TVW/rh+pW/HNiA4zenXyYkaPLXJ7phc7fX416YYOOtngvJD2jvMldic8qgCQdDNZ/LxARuX8zBG1o/ts48Ihoy10Og93eLitsmQUySH0Iy+w+3O9CAfpcuZMILubt8Lhi7jO4r4HLtgJwH/GRzCLs4kIrn3QB33QySMf+cgzXAmsCV9twdE5tj/5kz95oJdnrFSZLZnt4+tLH85dAn+fQ338DCuccn9Ax+vXOadVv3mTnO4Lf+aN7CwOSuchOA+wwZm5BifPEnP+A3K3SK4hH5OvN+ilj/tg+Z/vIxywP2mLsl7XwTP3wMsDT906S5nlH19budaEA0HZSgekTPLMteqeB+XyAZkHcDxwRD+VvT7Tq2lj6zvZQz5eD8AkbtUuJ5V529u3pjleZNcRHMY+Y1xkBsK3bOEl8Ozz4sfsZNAJ4FrFFx4M9blyWvnYKv171QeWHBJxgjukpgqYfG1TYRK8ftduBb6FTYKLLXe0zwHgGcWs2klhwYTqutpwYe/1KCNmue666w5PFiQwX/Oa1xz652Bg/edNCC6gUIowv9NK9+UEq28CPZWhhpDWAXqiAUKJN1yIufV0Y3XhKoikxcoTIf1WcCvPV+qMoa7dNA5XYdWJqYzQywnnYWRW5fL+SNB2dFql3bFlKiWeSu9iDeRVwVg5K+JlGTD3ute9DqnkPIHU+iKV1YPdK7hUNPd1nee1+VZSfw0xAdt8EnelIANyCZXz4OVna70yjLxdvnt5f5LWtZ/zkM5NZYSN8K7WWzeW2Xw5XuI9HfL4hCc84TD3L33pSw/6QTJWvCndwZtEOtrP+qlwHY21ghxTNfbqezqSMzyrOanoWvFK9tXxq7eZ32e4du1lOz6GDp+qz5Ee6JygCrp+k5aVnN5ifG7VW9W10XzN6Deax6q/lbmdybmVdioZk/erfme8uzreKwVuu7rjw/e0rXE0R7wukGxUJo4eluoaTp0fKOwHT/PwmqAL2U36yIblwTFvkvOdCR7o4aGsv20J+1t2sdsJBIPYJsNhv2qX9hiTZz3gcEI/D2j5gdb3u9/9Th7zmMcctrw5zpz5JH3xnu/5noeHYzrThQwHf7Oe/4fmnoVDJhb9+7yCO1v4GA9+Cm1Ca+HGtjnahuaiHf4JdNLc6rr8Qg49Zithpac7p5p5BF/fkglvMXZvM3eReDk+GYzz9pyHve3EJ9tLe5l1wtENHkDzdURfHqzKNeRjc3x8bVX2j69l6npWjfOy08KDqdlejjH7Yi1V8tLHnDZLjoNz0Hg7JGV9u1/OWW4p87FeY2VpQzzKSwGw8QlGc34reMueg9f9/DL684ARfdGPb/+s/JHKHnaaOBDU8jbPPbC0YjScBzBR7EEkPZKnsVIYMqJdiB2jLBGw2ncsQYaiYV+1rimgIoHlB+wlrjCZRw49EskhfdVB487Y9773vU8++IM/+PBdY9Q2tuuvv/4wZv2XYnBngYlG0aBUXBjm2UadEBMTk56aNEKg56HbFc1RgJoforTCm8MVuzqVoKX/CkbGVAWVcJjhMPp9uWFkEM4cksr46sqvGO/JAylIzwtGBv+IRzphuTL3FZ1ZZ3xY22SNKACkp30dnbLNpFkqaNajAlm5rdSVin5zuLi35wbAlYBq3aS8q2he0a+6lzJsBlvXbjcvs7Yq4zOVf9VGGjszkDx/r/d6r5PHP/7xByNaWxn05hAFkxT41IGQ4kfdq3i5wz0NR4ecx1l72W5VZzTn/ru7PqLhiLe2yJXZmqoM4Aofv5Z9dbKnMoq7MjPIbUYdz63ojS1rZ5UuI+P2PGBFxpwXLtlG1/4It9k63QKVDLpawLMyGFsGmrp1nvLK6/MkXw9Vsec9o9jnxYMomVWA/S5Zih/gb13DJsAJ5FwU3mDtjirnm7h/0x1SzTa83PojIHBAO/zHaSUoojE/4AEPOPNjFGQjKCebXjjqYbLK6FXnz3jGM85s9AwkOc/lNhrsoyzvW4wSb338Vev4Kn72FG/YJiuXA9VpW7jrI/tHgTM9UJHe8zfe5UOuxJfvzmN+GLLzlT+48+w450HazW1K3lZuR0r5njT2Ol12In1TzteOfyjrQaec18TT10oGFjKTOmmUx9VQhmseIO627OV6BVLGdjI+s+8YJ2tf/EJQWR9kkWd8+dh9S6O363NwU5zX5WPEh/CANHOSgWStB3x4kmx87nyNuTzw9efrl++5Xh1yHnP85x5Y2qqYtiizink14YpAS8DKiRNIUShoIYHcGXveZod3OnDqE4HE0ws5jboug92fMlTKiawkf+0mTy7ULimcHc5E7KW8FIXXR08TdOCegkrKoPJFz/jAgVRfF1QclFcZpE4fAU9AdA2l6odvi/4KdlWCOudQ9SXsNUeMLQ2Bqo0Urp1R3s3pDCrjNg3hznAb9Xc5jLYUrKO57K5368Dbz3uVIO/amsGqU1JBZZj7nKXyhI+3GOIVL9O+eFhrWAamGzx873DMdjvHTeCGBApF1+gHY4Z1OXrqcDU5Ed36cJ4e8WYFuV5X1mBlgIxwo/2u3Rneec/LVzyR9zojS7JZ+kBPmEnl1kMJnaUhPcSLExzSGXDaJb+O8B5BNb5qHXT0yWuUT8PQ+8itBM4PHYzKVPqoWtdZphpr6t3qfmU0z/pMms/GMMLXy3bbyrLdFZnaycIK59EYtsjvUXtdG9l+PhX3+tXT/er3aHyr87plbB10+F1NgJPlD4mRVax7/0+dTobrv29DI3PIM3zoA8eMh7U8nKW+B5Z4qC35KnnLgdG6zrYVAUGkDDzQrr67M4jzio3BfbbdgZdnWlVbuuBN2d3CkVeNs12ah/HYEwo08TBd5d7//d//oDc828czsgj0OH8nr7vP4L4Ec+O+A/PumUO81Q9fTP85BoWD0tn6xuHsGseLX/zig58of6Pa+uWyOHkqs7zBhbLwVMpJ5i8P2PZAn8DnzOeOdv1/yoP0tUZ+LPUS17ST+F1t48pgYlfHaev9pbz2gKHrb8edQ9+pm3aK1/FgquPivJbnlTk9vR2AIC7rzmWHl02bmwe9npWY476mOOcp5Rn3yVhEFvn6gKbQkD61FrDzPJDJ+oUe0NXnqbIxoaXznsvJ3DVxWbbCVUrrWOcmU8Lk0DFgzwzqFPNIeaaR7CmwvGmOVwOqfwkw3gTRMSqTLVz1XeXZ9iamVRTdXwOYtIF2chSe+cxnnrzf+73f4cmzmEVKTAEmf6Ocj1uBKPXrT1s4/wVawWgJKaw8AER6K4uWrLGkvdMjnYJuC+HMkRld7xYE91bb6nhk1H7V16jPEYwCDFmu4/MVQ3HWjyuHLFcpLL/fzXteW4WOL2b0wViSsNdvzifje463asP7z3EjXLUGtUa1nnQuAcqGc468j44OyS/d/GDI+bZW/+9Pkypn5kpCGvojmuf3kZNZ9VO10eEzkt9d2VW8ve6o3ZV6WSbxFW//7M/+7EHPaOu0ZLP4QXpCvPkzP/MzZ683B/wJbRW46Pob4ZX4VzrN6+Ta2kLHDo+RLqque92Kr0a8OtMZ1VhW5XlnO83wqcrNZMFo7kd23MjeynFtbbPCb2Us2ceK/ul4ZFRnlVeynU5nZ7/nJb87/kqeP9ZuuRTgZ7UIwM8DJl3GXcqzdFJ5vTZHM+D04UCSfaQ6CkwQXBLkGae0KZubNnj441k51ANHttUxLgJVfgC1yhK48bOgfDwADh548Zs2oJGAsfs5jbSh79oCd8MNNxzuS59UzmcVGPH5yEwObDLq+C6LansVdGUMmhP5TAT93LlVMIlzaJWlpKASx6Lkg3vHN+0lD07kNiYfDxnj4IIf5w64Bw8YF235Yd0eSPOyCZ08qB7qO/08UFHJGQ8m5VqijVw/iVfKbedf/94FFL0taOzt5bgcNwKxzjusGedLaJz2FnXcFgI3T8rw84rZfkrbfs6xeIMMuszuutbmItc+eLM2nL9IBnEZyJFAAup7sDx9HKexrzef+0pf+zhyrqELAbBLHlhKJI9tY3TNX/fNvVF/lcGUwCJgUogQulOK4uE1oXlGUuLKgeNsTQHP3ALmjO77u9X3C1/4wsMWuIc97GEHYS+cJPh1rXpTFa9G13g4xBvGlQKcbUHjv8ryRIC3wSFY/XWWI7onbp3QvJh5G7XRXR8ZWiuQBrwvulUDtru30vcx91acN/+eCiMdgwpSCXSyYFU+VPU7Yx6cSEOXU43hxNZTOdecK9AZ8zPc/J7alRGjtmXUaN1qzUg2+EH/jl8quDTqqzlSO5wZgFxCoak8TzKRi5XiPi9H5Vio5m3GY7n2K9p5vdF6X13f2a/zyQynFRqs4jjTZw6ab+mZpz/96Scve9nLTh7xiEcc5LTWgBwFvba2OtCxa7P6njKzo0M3xpyr2Rrr2sgtF1Uf1dgqmb+CY46xkhEVz3Q8skXnZHurMvM8YWQnjPi1s2/y3sq8VHJhFe8V+2JlDKt9V3M9quNPjlfWxgxWdFrlZK7o98sBlax1Orqzm05Sfvf2+I997S85IPMgg0b+IBYnj4fNkkOypf3Aac4JIhBE4ADH1YMsnj2t//gSZD64Y+4PdHEgscNVhjq8Rhx8PBMCR1W+g+wTBZf04hHVEUhX6De2kuwklZH9j03hQT0cXMbJnDlvuZPv85vOLzYa/hX4A8KFAI7a1EM8ARkl0nFkj5N0ILzZKeEP0rs17I60054x8fZfxgQfEeCgrgetkp+Zdy+T2Xde3rO3/HrajcnzXMvgho/Pr1OWYIEgA2/Vdx8Xvz2Q5YFF7ycDe4kD9R28j7Rvfasa7Xmm2EhuO+95WdYPY+i2w8GDPlcEiTzI+05vP1aGrWtaO6x5lWVbLEksniXHekBWEah2vsP2d1o6D+fcecCw8+Pdp8rf+vDSgssSWOqU0qpBkOVXlG4qyS14ZX8cBo4CYSJhGJTHzGABLwS191HhSvsKBklwIhxRYM9//vMPwlVCVh8J0HReaVf4S9iSOqrfOLxyhGHojma6zitZBeoHXNjK55HakeGbAjHpM8LDyx57f1RnxJMpqLc4BF3bVb3O6NsCKw7pzPBPxesC3+uMfldtVf9zXY+UvpcZKQf/rnRvDntECHqqauVkVwpzBJTDGOWpZaf8qjbTqUl6O2j9KnVdINnEkxEUksakNZvbU2ftXi5YWUMjOeJ1ckyVfhiNN1O4s+1R38mvFQ4rbVbraBWnqi/OD9GDCPGAeJ/tx+gKb7dqY0UOVveqtvJaRadKVvg6TBmRT4JHDkLi0pWp7ItuPCMadeOeQTXOlMGr4ztGvs7GM7O7Znq/2mYxW2uruM1gNt4tbVX83PHfFh3era1jYXVNj9bvMfNyXuC8Ai1zmwuOk2cjeLYJ7TCmarsYh2Tz0Ni3o5EdTOAE+4EMGQIK4Cg5y8G74E4gB/wp71k37HrwjBgPmpE9Be4EXjj0F7z1H5w9A4agkXDWNf1+yUtecvKLv/iLh6M15GcQZNPZRPotH0HbyZ773Oce2pP/oP6cZ3zLnc+ZA2MhEJhBA59f5lP//ewrnHLPDJINxPhpwwN4+dY/gkvd7hAHAgy5fYp5x+n3/vxQd+hD+xlA8wBS2rQ+z8nDeTZRZuB0W734ndnJDiOZDC655ZK5r3SL8/pWfyH79zref9bnjDCVZU1DFx+Lt+W8mIExx4GxwPN+nlHWYQ5dPgi32799q6bqECSVTZbZVMgEsqXEbwSk4APiEcgI+ubAf3we8PDtth44c5mZ9qxnaTpv+HrwDKxLFlhaMaa2KquRsVIZoQkj5V4Zy0yUJkhOoibUM3v87Qp5aLX31TkHAg/E+D0mS0JcTw7YyuAprbwalGwIT4fLsek6mUuc88S4umylqg3V5Q1zOOUwIq/wzHF3wsONBFcm0P1ijZlVIzwhBXxl6I2M6vMyCC8GVsfY/U5nZqX9pFm3pka/XYmO6Nj13xk0fhYRfMbh+7zZsXLCKlw7WlZrvnLgZs7XiiMCrVm/GLfQD9nE646TblfSURBUymwGK0aJt9+Vqe6lkdk5jF6n4pOK52c0oC2vs9W5rMpBX55KVwc4etmOXtnmjHdX2urmsjIic4ydTJ/xx2gdV/Kuw2UmD7u1PlrTXd+VHlrBJ/FI3uzKdfiMxrt6L+emmi/+H6tDO15YwXsVVmX0xfab+FeZTInTKlzt9otDZZvkA0w/2Ntlem4t8jrO3xwL4Q4zZf0sJM428jc3kRkkkE2h67Ir0MfoYs/qB9DVAndUPUOJMxv5ZPYE43G7iXF5pgQ4et9ktup4jY/7uI87vCFOjq7O4tPDOAWW5Dfo0G5tn9Zv+SN6GM3DK+iA0+q0Azffhuf6h+v5QiFfX7SBkyz6E4gjM4SAHRlknHHlb8vlnh6y8GA//SXXMeo3Mzd42K92ODcT+jK33PeAg89tzgE85P3Sd5dp7jYTvzu7OfXEKKiX5eGrLmvJP4wjdVauVe/D2xrpwkqXJQ2zD2x8rsMnLg8c7wRvs8OXuskDqffhG3j+NuZDC0fOcPKxO/3hHfE7B/bTDoFvD0iBu68L/59H3yT9PeDJfQ8KMyZ8KmQRbZ9rYMkndVU5bTE+s92OUSlXGaX+vbpfKVxNjqLiCAzKiMgK+GiiJfw9lXWEz4qRofJqW0JcSirHjDLliQtZEtUiBciU8kj6yJD2PhkvbxESTihRtcuWum4vZzU+FpUENFuU1IbamtFoxajzBdYZ/rP2V/h4xSAbGXKzsqtG6YiHuz46J23rWKq2KLvFOe6cjZU2u354cugC3yPwVcpxJ3sq5VatHzd+u7XfGQA5xlRS2Yc/Hauct9m6vhKQ/Je0HdG+mqesT7mOJ/Pe6nqv6uT37KtzAju+yX46PLa07fzR4TzCv9JnFYz42+ep08dVSnwnE6p5rsZflRvxSzfmGf0q/JLXZvPe9dOVq6DqdxX37K+yo7boo6384/dW6nW60ttwx2PWZ7bR8cB5yNPV+ajGVLXVtVethy16+WoA4eoBHv5X24gAz1wC/LdvX+HNT7JF9SHwwINj9a9gBQdHY3OrLkEp3/LitgW2PG1m9gnzkVkmOHLutCro43UIXPkLgchUIqsIXMHPt8yovHTDS1/60pNnPetZJx/1UR91ct11152dN6XziX7hF37h5Cd+4icOWUuqp0wmPfD2bTi+zvTx16zrNxlDalNt+xmv+AIeHBR4EIqzYhTsUraHgkOegeZ2neZPfYCDfBWylThSpAo2VvLYM0/AUWNX+wL5fn6AOkEtleUt37nFDX7Sx4M8GRgAh277UrUdztcLtMutiVVwC8g2M1CUaytlSGYx8clMwsreo6zzUQbLvE3OCkt7AZoTTCTI64fmezZY9ukyMoNwnhHkbzD0unnOkz74yrqPr3tqgVWOtKh2G9EvdTQOD+7k2+gZG2tddZFbuS0vdQG08D7ph3kg81DrjPYEBNC744AuKmNpZMx3CrErO2tnpOC7+iNlmoIFYopgiuprIiTYOBjO30rH4byrRntnAPBffZNqSXolE+ZR+txbWfVTLf6tRhBtEVySgiOdVjSozojqxsj4NCbt4VYKrhaeyij7Sm/YUx8rxtYqzHjlYuqsGGhbeXEVUuCmUtpi8Kdxnfh1Dke2teI0JFROXjVGfndj7MadCgHjT2vKsw1ndEvlXuE2G9sKvlW5ToZU11bWzZV2LJyWlTNZ0Xa09qr2VvVS5XCt3FuRA6N1VvF7hfMMF28r12bSZoZvRa+KnjnGrs2UKyMYZSvO7ILEI+VT9p+09e85/tH8dDp/C/6Jh7dX8XW3JkayqeuzasehajvvXyx9Kn6atdnhmnZXpS8q2s5w6qBre1Z+1P+IbpWM7By9HIc7QkmHreO+XJDOluPsW0wEXWDG7U531L0s2S2cieT2Ns4UD1EJWrC1CkePIIPw8e31vlXE51z2PTYJZ7NQ3tvgyA1w5sEY7XrwQPgTSMrjKfQhMOY0VTm97EH296Me9aiDj6NAks7n421qnBepfhXcIXAFnuCa2WPMk2eP4fST9eRnzuCg+vwJdJ+AFk49c8o2IT2IZ4siPpLbd36cSOqaXAvJK6qnoJH8HgKRPkeMnWNR/Cwq6OxBrdzylPzpQUOXFx6Igicz+MFY/OBrz4DyufDx5tr3vhz3TkZUejTXWpalfaDKeqp0tB/+TTnop++sAXzp3M6VfVbj9jUHvcHLg2WOl7fB+qQvsnve9vbsI7IfM3BDcKqS3fCOv0Uy5wW+hHYEVWnH+SLLQjPwZz0jIwkm+VvwWGO5Q+JcAksjQ3V079iylUJ0BuZ7Ku/ZouC7lxPhFFxSpFwRUAkwleGMIiZ41EY3Bv/uzJQZSUQGldXjZx7luUpdHxU+qZCr+2lY6rcYyCOTM/rmnIhBFVBSyi1PFDgcUMpDW+6ODYBlfzOccpwdVMLtSkBlPFffu7F389TNfQrO8zI80zju1nOu64QZ3xJAYv1gVBEwJg0161Z4rdBsBCN6Vg5DtulKrbrezVm2eaVhKx9d7Bg6HqvanfFb1usMC78/ujcyuDqdkvxY4eMwwjH7FVSZQyu0qfg373fj7uqN5mHW34j+leHayaSqnTSwR7KgGne17kfl/H41xu73jG4j/bGyRlfXsY9tVmeUZTTTRyt4u/N1HjJqpCO6vkdlV/iqGvfK/OIkdbo221uZr0sJ4OZbLfz8I+5lAIUxpAPoDiPXOFaCzBie9nNOCefmKJjAOUie9UOgw3cNpFPtmQTqQ3YHgQiV9e1GHpzx8eDgY0OzFUUgvDiPyA8YdrnlzrjTQ+OUX/GiF73o8GIHgmuMR+MnO0d2umx2BZf8bBfa4jdjBwcCXfqQGUbmBG/P8kPRoRuOrB7q43MxBwQMFAjzrC1oy7lL0IbgkPNV0sI/ONaqJxqQeea7PpzvGBvb9XI7WwZD/A19rEvfBun3fB7TJvDABHWqg9K574GIDHbCi4zN+bc7K8oDLvk/1xvtuQzONer4pg72vr0ebWZQl+1ivLxEPjO8TWCEsXpfSZORbZeBIeYEWYKPDi9fYzKLLZsc18H696BeZpLBS047n0efZ9pgLRPk9TnKDCvqg5uvRQK2kgMeTK52TF2Sw7s743Fk3Ao6A6+qXylCFwge0SezJyO1nRJOnP2gLGXUcL1LX5u1WZVzIeL7QXkbGx8pwdw2tmokVTh1ddPA9rKrbSSQDosy4KlNpjkfa8zkAslxZxBuxKderyubtBnx9nnAyOjsyjmMjPE0NpMGKeQrYbuCVwrupJ+v5cpgrsbRzaGUCOeQ+ZNArR8PYDoelQzaSlenUTfOjmYra7mSGdV8pBFy7Lo6T0icK3oAOf+d3O7qV21V85y/R2vZ8V7FM3Ee4Te6Xs1n4rPSzsoarcbZzUHOQzU/Hc+v2AlV+yO53Y0/naBuzVbtzeTbbBzdOq3wH81B1XbX/8qan9lAFR45DyObbYbHiizvoOLPqp1OTo7WxMjO9HmqnvaP8D0GttCo4u1q/COdc+x8nDf4diScNr/nDlY3hsQ/y8pG0ANita9zhAgk+dYp2druO7gt6cEMfnPgLjYHASXPouDpPlt1HO98e5bjDG7IM4JLzDkv13GH1g85B0e3tT3TgEwfr8fLH/QwTr8V6OEt1wLPzmGMDrrH+TD6zzlIZG+AA04umUwqw9usNUfqj10SKqf7agvn1g9qFo1VxrcLMh4+SWc+lOM8JX3nuA/HMbe3qS+2+3EwO/NS8WP6ox5YFDh+uSY96OCBH+cV5xmv61lLuX78muObgRxwqgK83rdvW/SsNepWdElbzANAuf4o4/1QhqAiQR35nWTZKDiCnw1ujNGDat6eZ8p5QMXL+LiJGWQg7q2RdcexOplN2OlTn1d40XFwejvt/MxZ5teD3h78SlrAy+BJYJsdSL5d+ZId3t3BTEnNHKzOeBJAFFIWiYQLxEQEY/x1gCs4+/1k7hUjMa9lncqYFa7KkEJoEmXVR9fZnjfCvXMMjoHOMKsYfkYTaO+KjXRaCYJRBlYFvvhZEK7UWRzdE5tRm921dJZm467a6pTNpYSRwT/ioy2/K/5Ip9K/V8a+z6UrsIpmM8dHASQ3/EinrlJIK3yqsaWST+Uyeuq+IjuSvq7IR7SsaFLNw5WExGFVJ3QOYY49x921X813RVt+V7Kvut7RvJL7HQ1ma7HjAfi5Wwsz3VP13fHr6Hf3fVR/hG/qsM7gGvXnOmfLeuugu79F71ZlqzqpL2Y0G7Vb9b3KFzg03TpwnFbtjlyHI7y7e9X1lXVd0amT8StjGcGMr0djWumz45HEf8YXW8tdSsizS9GtAs/s8afzbpfllqd8+q/vnpWCfJDdjVPIf38rHE5UnvNEFgpAhpXqctaK+pV/gk1P9o58FLePPcjgNhBOOZlFsm/k15D9ROYSwTiB040thGn/YCMzLvry8cvv4OwaBeF4SCf8/Lwl5oesIZxR+lR97U4gm4J+mBfsd4I0ejj4hje84cx/gxbyF9S22mIcnENDhpeCCfhQ4MQ2PM/4IPBEQJHzcNj65rwI/Zy3BJpD6jnPVeUz2JPz4WU7e8f9WN8uVWUBcb3SD5UN421Bb2/Lx5j3uZfBn6RftkMd1zEj+877gqZ+X3PHumKbJNln+i1+4uU9eaSLZwI5XxJ4SX6t9LW/1MoDqbe2txuSFck6Sh7IDFv/XtkzOa8egGfbGusNvN0X9zmp+iIZREB8hfH4ywnOPbC0YtQf225nxJNWKiFChNsjamxh00HcvKKyMyBWlKlPdmXMjQy1ikH8Nwyg/c3Cm4OyeHIiBvQnBFtgdU5GdNhqbLhBKtAYpKA0RwSS9NETCSmQKi1yhCf/9RHTk47q+0WVZeb747eMb1Z2hZ5dufNcH97mljGs1F+pcx5rnvqsZz0Zk9DS3PFqTldKWbcah8qy3l3gVuWzbjfGrlyl5PNeJSf8/wwvPpnd5wo26eKfqwFGstLvC1LOdu0BlX4Y4TDqx3GsjLyZrB+tCzcKVtfrbG2lATKqO2qr0k3V+PJ39b3DZzSfo/6qOaFc9b2ai2xnhk+HW9VuRQfvr5Nb3ViyrxG9Z2Pu6uR6rOqt0KjDu3qKnuNagS36pbOvOpxzflJfVHhW87GCy8XwQNX27H7V90zPXw26AgcodV4nF9xRquxj38JG8IItUr4FjAwbAhK5JjwI4xkPBB/A2Z0xv0fb6lfXObeVc0ryoXE+hOVFQmpPdeQTyMblYF22fgkICrntoLoefCHDhrOUCGqR4cCYZYPp7dL6LX+K17rjcHuQiAwI1cFe42EvwSB9OMibrAecU/5rXG984xsPD9TTl4Amaoey+k2AL7e/5eHNaotAElv0OIBb/ZG95XwDHznPeWBR4yWLQ3UJLPh5Scm/lS7L+52/h73sPMOc6B5852unWvupr5lPcMgt8o43/FFt5UtcO1vOr1e6bGQT+pgzgYB550gM1iYvj9IY5XdqvjPYlzQjrkDWEVvdfH6dJ6ALGXP0/ftv5ymSXxwXsu58jXb0qPSGy5+0Nzh3DZzAVd+Fg3iWmIPwIyHHs6kYE+OgPw/CXdKtcBXMlNkxoDZFCAWUJGCIDCIoBTAMB8/5wXbVRPk4VoysbkGsGBMV6B5CSQzPGMBxhYbVJKchNOp/5dqsz8qY5E17YlZXqOx/rYy5Gc66JyWi+dV/lBILXIvFDzqvxlY5QZ0QTMN9xdieGaDV2hgJ4ll/q2VnfDpyMrNO5RBW+KeSqK5pLd/97nc/zKfmjqdWnDNW9d0prPyf9b1uda9z5DpaVzTs6N2NI+u7MYxs44kfio3DKb0t0Q7jbYb35YBuPaw4SFVbK2sw+17h4VnZbi13PDSru4r/jGbVuhr1nby/KmcqHGbj6uYryzheVX/Veu1kdEefjibZZvLrSMd3Y5ndW2k361R6sut3NP4ta7DCZeQIeNlVmVOtw05HjfTpsTLOHaVVO2mkz2d2y1a6j9rpcOzmZLWNKw04eDhEFR+4XMgtSvr4tiIeOrKVijeJqS6v9SYjpqINQRN/K5PPoW9zwXGUrcuuA+EnXY3zjtPLw1Z0OMEqgWcvgb/qEYzCP9D3O9zhDof+/AG6bxvEhvAAEM4udCKDx8+h1D39VqCHMfBad7Ix/PwatSl7jQAVNKYvAdv63FEHR+HPQ+EMVkB/nHEFupRYoP44cFw2pHxDPbRWnzqUnMCd2iFQIFqRmKDr6o+H3tDMM1qgaTroPv+0TfkuQwfZmPayn5HlAQ/njcqWyrXhdcA5bdpcS94m/zNDh2AC4Lj7texH9fzg/a4e4Jk1idtI/4Ovr3uyhKCtH8UinAjqwIO+HZQta9wn+Or0Zl4qnP1A8be85S1nQS59F+9lMNjnKumU8975JH7d24I2woWzjTN2wtZP1ovwTL7wgDI+yCUNLK0YRsfWTWIiGIjUswg87Y/fOGQXY0x1Btzo+8w58To5/nx958g4yHZmOKzePxYqIx3FonH5eVUpQGeGjs8/T3/I7nIFjJJEAXRG4KzPmSMzw3PU3sxByVTLUV+jdrr5WB2HK0DGUI1pta1uXZCymge+a33feOONZ0+TOryyveq74wKkM+GGqSt0V7Td/FU4ZNsrdKNvjDMpHzIwZfxw7oEHVTHuMIgUlJOiILX/Uqz1VRg5wDMaVoZFttnV9XL+v3rAkOU6Y2k0thH+Wd7XYdV3xSuzvqq6o/WRsrcyVDv8R7h1BmvVbqcDZ+ujujaT0yu6u8Kla6MaL/xVGetZx69X+Ix0xQifDlL+d/1n3xV+Vd2RnvD7M5nN7xU5W+HctTlq/zzoS/mZzTGCUd0tuKyU3SIzLif4WSA4tJUswYH0c3B83ARSPJigjGi2ZclxQk/SbjqPBGR4gU1mRvnWM9UnoMR/MqCwI8iUIUgi3HkI6ufCCtQeNqzaU/BEHw+AeDaC7AN/kKtx8UAdh5BMJgIt/GdroL6rjAItXlbfFawhKMeWNw+kaDz+giG3Y6Ah9opv12HOhKvsPMbntPZ1ShaVHjpqHvW2abbxCQcFwRRQkq+hT27ZghZkTEFXz25y3KCB86DzqNuFeYC64+79eyDCebWT0d5mtQ2r+p/rxunpGU/OD96mt+PrMoMo1XjcxoA3HD/WWsrhxNfXpbfr6853qsCrfs4R16Cxv/mxihWQTQQ/iSeZf9+W6ecmCVjPzrsul/7g7evJdx/h87i888CY07DTs5TtbCbmSONSAFp+g/vkAnaH5Py5X+EvCqh2aFySwBIDOAYq507QGYousGAs37MrYJ9zbiGb4bhiGK1AtVi21J1934J3x2z+vTPwZzhWDN0ZePmWhFwonZFbjYHIqxSVCzeP6s+csRxPlj9vA2vGB6tz3dWpjOQtbc4M84pHKkdzCyQP8NRLAl7C3ZWBP82rlHauuZGz0M0FPMCTORQFSsP33W8Z34iXKoWOIuBz3XXXndzvfvc7vMVF5aEPAh8goMo10n23zst5QsWjW9fZSHF6P1W5iqer/ldwGs1nV2d2vZOfbjDM9MkWJV/1f8zaqejc6YFOn2a5xK0qt0JnN0arNT6ax45fZrShfG5ZHdGywp17Wb/j6aqNiraVszIaR6UXV3X0jIey3Mp6Gq39an4Sh45vu7ZHvOaOz0p57s+gWgfVXPk8uANWOR/Z1uq6uRLgssjx4Vpm53LNf7sTqg/b3xR4IehDwIcMJd+6hQPozpV++2Hd/nIQ+ucsFzKRuEcghW1Wqo+e5jwYtqboP2XIqgA/6XKyCmhb19WuAi26zi4O2Qtk4eA8uh2j9vlO8Eog51LBmNzhITw9k0HjxOEki8gddmiBb0Zmg9pSIE3tqQ/hqGvQAp9N43MH1gMHogPb7VRPAS+NWd91/pQ+GoO/EAnA0eehHQ41Dy1xnFUnM32o79vgGK9nemCzVoGiDII6T3uAgzrVeq4eFPp9p1mud4IwVXv+u5OlHkjx8r7eXP/lNdYn/eXvtC8Av5bBXWiXGfvY8O43MDbeRkjGDmuNNyBKVojPFLxkjuALfJHqDCb4VsAZX9caPZy28l/9TYtsSXWeSPme813Nkc8PbWk9alwcZk42FbLMg0pcAzcPnnpAmt+XPLCUMFO0wGiR5HUmKSOOMIlPBAT0NyBUfcyU7VY8s+xqOcdlZvStGHEjw3U2jgr/yiDsDJ5RW939LbzC/xQOLE6Yf8WYW+n3PPj8vNrsHLGOtis0oE//7/VX10h3fUYj0tH9yQdPrkhf94Peu3Uyc5hm84SRR0Ykqao8TePJ1mqwZgstnLeFwz3vec+DMpChdN/73vcQWBKNeNuKvwWTNHbkn+ildjgg8EpCOn0puwTd9RUnOPtxGDlYFT6dknZFXrU/c1ozxbkqmzilkSDwVPTsYwQjnZq062idRm4n13N83kfVZ1fXr1FupLO7+pUR1tHlGP1VtTWTQdX4Rno8g1Uz3JO2XZ8jWOGJVcj1POqrg0rncb3DczaGkV7KgE21HkfjXaHZSBd09lVn+x07RyOZdLnBz9wB4H0coXTa0+mkPoEOgRxGztLRNWUqKSCB00kbmUXh23j8zCTOcgUPMh3IdmCrGTi4MwreHjhBf5Oh7EEblefQYT/7B6dRwEHbvLCIIJU+yvwmkMaDOw4w1neukw3lW9t8jH4WlfpgSx2BFT8rSQ4sthNbilQfWjIWaJrnPGmMGchjjvyIC/1XRrvG7vY/4/SAltNe//ENcaorXe8ZGlU2OUd7AJTPTKtsN+/TF5D6gHartZ8Z9Z08yQBQpccrPeM2R7bhdklmLflYKevlMjjka7DKQIQO2beDz62PDZ4AV+jGGmENEoziWBr4ybd8UlfAAfpOhwzsnYY8IfORoIy3QcwiM+E6+xMaZWYn4AfTSwZCC7b70Z+/zZDsTD+fOLM4oefqQ4iLCix1zsFW6JR3tg2BmGgWABFvV0Ijo3hlXPS56uB4vVm57GOGy6jezDBegSrSPTLku4W+YrB0xmJVzu/xhIAnH0SNEQBVal9l+I9os8or6RiMBN4IVg3XrQbkKt+u1B+NraLtCg1Zv3rKJINEAhCjwZVBGgbpZFU45ThyTDlvlJGw11tQ/ImH8FKQRwYp+48FI+G64swlDig5GYQ6c0pK4eEPf/hZOryeTvpZCtDHjcdVB+hyQeUAVfNRyZAsm/eP4TunTxpCHXR4V+1WOI7W94rc8FT0TgdsdZ59HeQ1bzvH1zm4K3J1ReZWuIy+V+1Uv6t5r+alczRm63mEf4d34jGieV7fYo9UtJnZEt06qYzYGe4jeo3G4Ub6bJwjndDVcTwq3h/ZNx2+KzBbk95e9dR6S7ujeqvb7i8H+CvMk+/d0fEtI8kfzFc6TwQ/2N7i5ynlFhafg8wQwufwl47kmsdpdBtVdXiLNXVpW2UA7jM+ZeMoEMYbzzzrSB85w5kpxVlH/uIc1eVV7J55ou+cQ+uHT0NLnwf8KQIyBIIIHqkPf8MadCQLS/aTQP/dmdU9cGMM7sz7eS8+x35OFvPja9kDXmSF8cCQDDLaymyRSlYzXrZN6cP5UX4Is39ySx80d78071c6nrIecCNwCZ+njKb/pB308Ewe2qv0kuMGZPCnC0r5mKFrZro4HzjfJJ1WbQF4jnnyrYYe4PVMRXhAa0HygW2y+JHcJ0vJ+/bAs69rx+0mC4gLN+aAIDWHv5O5p3p+8Hwloz2TyAOATkP4xfnbz3/jmuPGesp+Kh64JIGlkbF8LFTGWd5HUDmDQkQ/MI6zWTqjpsN7ZOw5886MsWPGPqJH12ZVb8XwTDrz8TZ9nH59ZMCkIKhwrfoajcHnQvOuQIR+k6mGgkGpVvuGu7F7+939GYzofaxBuAoXaxiO5mFkrM9+V+uius8TM61XBC3rW4Les5U6PGf0d8XFtQ4njEUUiD9dkIzhTSnV1riRs7ZCN5XlnCTRQQGmV73qVWdPCnnS6sYkdVDGohdvk8z1e7lhS9+dQdeV6wwM73e2rkb3K/ne8fLM8ev4Arwr+VONobt+nrKnM2pHbfoayzHO9Fo39m4+u/FvxSHxoexqOxX9K1qN5GJeq2RFZYeszPdsnkZ82OmEGZ9nnZEt4Ne3ro/E5RgZ181zVW50vbMPvY+E0ZhG7c9gZnP593wosjK3lxIqvgNnMnj8RS1cp15mMunjwQBdJ+Di/eAgoc/dSfZMJbaOeUAF55UzWRTIITMH28UdN/VNcINse7IjdE9BF472wEnVb7Z7+cNy7jlOfMc5ZLy+hc0dV+HEtkAP9viDDKd3OrHQmjdekfXBXOm+b6UTEOjjN+3yhme1RwYVWVTglXyB3e/+S5URhEMNbp557nyfTrxnzEEXtleCt3DkYbf352vJgxe+lbLbIuZrgPrVfHhShc+Hr6nqXBwPpDp/pq1TBQ/cbqeOZ1QxHur7uVuV/Q3OvpXQcaCdlI3d2KlDsG+W8Usdtaf1Ij+Et4o7j1KWc5vBwQOaVSbWNcU2XWRT8ilvOPc2MtsxdTT/PcjoMgLZojPmnL74VRykz4sBKhq5DF61rY8OLB2jhFaMvAp8QWjyXQghhH0fMIe3eaSwwiUnJ5k3GTDHXk30eULVZmUAVAZ3Z6zx37+7okTQeFpsld7Z4Vf12+GddUa84fd44kSGC3trOXgwHZMOv9G1FagcmouBGW1XYGSMr/Tr1zpHZIZf5QyN+hR/6dBJGTmaUzJwZGixBc3ntHJeLgZXx5nvGI3iJ4xFffxwy8rxGo0zoXIs1PbLX/7yg5EqntZebwWUeJIi2aeD+KjvxqK+q6zK+ZOTKwWr8r6aM8FMiXVrueKPqnzSp3MI02jJttwBcn1QtZH3Kr2SUK3nkXzr7q2sy2xr1GYl/zpd0+nWLXPi/zs8s48K7xUaOB5bMgGrfr2/GY/l99EcVLTzsvm/wmHU91YY4Tjiveqef0/HouK7lTmt5sHvdbZiBd18phPQ0aazJ0c45/hXoat/HnN+3oADw3foyLYVD7owBp83nHq2hSv7mDcfSS/Snu5Ll5JB4Nt51DZnHPn2LJxKbGW2wBEEEXjWAfgKCD7JLyEIwxuaOF+JMXHQNwEbtzvINkj9znjkF+mjDCJ9CCwJL97G7JA7OwTgngdLZ6BB1ziugBeNUBZfjaCLQPfYGkc2CHQnYYA3ZkF/fy2768/k38zsy61ZZK94UItgnZdz/mHuCNwROFM9p6vPtfORZ/Y4HxBwcb0O3u785xj47gEh2qAdv0cb1Od3laHldOR7RduUodUDVt+2lhmFORauZx3HnzH5evezlX2+aItAldO2CpQ5vcSvHHzvvEmbzh8ECT3A5XOdh/sD2OtkD9KeH+si4ND7zExymnpZ5KPPB7LCt7chOyQrOI8K39kDR0DORfpil/WMpQ5WkKmMVL8nIskJlXMl4rhzJedLzmgleB1gEFLbmAiEzmiLSzWW7CeNnouBmUHS3UscK9D4JSil3PxtewK9YUGK2NMBqz5X+6to4gKncjLSMAbIcmErnAfCVhne+x8Z6CMYOUCzfkcO0sVAZ5yvlK9wSAenmsNq7qiTc9zhQKYO2WisR+5XeFYOUWecV9+zLOnrMpB4WobQpy5p25kxWdEuabTyBIX0bwWWeFWpB0xREjLm2KPN3miePrqC2LIeLhWkPE96paPYyc8tDlby7aiM/3YjbcZLq2uvmouKBlUfI304w6HD3dur2q/o3tF6RCs3djtdtVI/13+F30gWV2utkmcdf+VTxAr/Ef06qMaW/Yz4YtRfxUMz/pnJjErmbqk/6t/H0m35TDy6tmf3uzKVbE7o9OAIj5Ecmc1/hWv1BH9FZnVy2O9dKcDmdmcunUvwzbI5J/qwBUzX5BNwtpA7g77dRDawgG1eKuvneHKNbBV/COvBmpxPyvgDcM5L1Hcyae5yl7uc6Xhe0MHb3NiGz6HUtOu0IFsZe0XtykdSpgJZ/n6mSmZQVJk0jKXLSPHgGsEgte9bAP0BNcE5+mVOsFegFYd/p7xxG4nffHLbVNoRLstxxCt/wR1pcGWLHxklssf4+JlPLj+SxtV8ZTaR69nOFklbkuueFZVl/X+li32+AecFr+N0TD85A1arQSWX+bl9kGuVD+jjqs7D8vH6/DofEweAb4kBZJ8+h9UZRGlX4Dvc+u07HzzJBX5HhqTe4Ywy32IJLr4dlwA4WZM+96xZjYk4B7LAzxjTd9/h4HR3nFIOrMRILnlgqVPCFcyMJIIKIgQTQGDB3wZQLUTaEqE1GVImciJhZgnmKpiyFd/ufjKq30+DLet5Hb/WOVDdQnahJIVw17ve9aCAiHgi/FEWen2nv+a0anMkpFbmvRv3iFZ8Mn2vwqfC0xdPV2YLrBjuXvaYp6Rb+++uCSqeqBRZ11alHPK7t13dQ1i70nPI+az6z76938TJ34LiSthTRxWcxoCgPE8P3FCqaNrRKw2Fqqzj74HyHJfuyUj0lH5/CufGTIfb5YRO/rnB0/HWit5Iw3NV4W3FN+91OIza7NqqeLiq0+HVtbkCXT/VPI3WdvZdGbdV2dGYunGOeLsbR4dnVWZUtmp7pm86OvG7aqcae2f4dXrT25nxQyf3K5xHNE69OhtTh8eofCUrkh5Zf8sYRrjN6szWyZb+unI5VyP+vZh+LidUW3Icr9y6kw65by3hvz5sveIMIfQ5ASYCRmqDTCEOm+YeRy4QaBKQvUQghLeV+RY3nEj95oEUDiE2hX5jaxOk4Awc3gaH/e0BHQ+u0SZOqvpUPeEg/0YOpV4GonJ+xgofz8r2jIyKnq6z8ROgjwJgZG+5TcI8EmzCocbnoA9eDc89bC135J0fPDvD8aNdrvPAUP95cI7D73anv8kL3uAIBPEFZzMxJ75Nr7LxuNadl5O2T6WLMxBCnZyj7DPXfhVggTYeZMUmr/DMB6peLoNqFQ0St84+zq17/psxeKZQ2ie04f0lXSkjIMBC1qCX9Tp+ZpefUeR0Sfl/Glv68q31ngnl9E4+dzplAIm4h4/Vg/HIJn18/XPPt3E6r8Eb3qdnMV6WwFJnXG9xEiqonBEBT+iz/87QcKJxQK4ErisInhLoHBVSMyvDzdsf4Q3TwTyeRjZyAF2Y+DiqCHtVf2R48V04KU1YhwSjRGF4BLxopPqvec1rbpZCO5ujTnh0eCXOM2PMBesqzIz1zggdQfLW6H5eO09jrhrHzCiftbVSL+evo92IBimIcxxePoVatS59/KwlXinK0zAUSZ4voO/K1mOtsi44XE8BnZRpK/TKlFkv52NOo9np4n25Ahzx9ZWGTv50672SCx3v5PXuaVzXh+NS/U+8vZ1j1n0ahH5tJP/SYKromTTL/1V7Po6RzMs11a3VmY7s9OmKTks8qrns+s1xd+VGvNfRttNfFU6ra7Tj/dSpHWRf1dxXY852O76s1s9sXLm+tkLK/k4ueF+jdT7Cv2sz++2+VzSo5MYxNBjpntk8nNdDrEsBHijJLVidvPF7rjextRXokI3vNHMnH7mnj9u32O2e0SDfgACKQA4a2cUe9CHgkBkUBJfIMvBtbwI/40TZSWQU+BvUsEfyAGSCXeAB3sIFOikj6kM/9ENP7n3vex/a0hb7G2644eSVr3zlycte9rIL3qpcOe3uuJLx4wdi+3mYPBjj1e7QwINpGcDxuchsGPih2wqZsoHv/h+6c7Czn9fFeD2DhAfvnLmJjUhmix907n1k9gnXoIvzO/Wcxj5ep7/zva/7DMJAo26NecChsy0zqOhte4aO9+PryXHtglUZzFoJMPub+jK7zttxHNJmcJr7Q2L/79lTzrveLwFc1raf9VX1fe3bx+/HaKQ8pl0CXamnnKedtj4OzlkjcK4PL/YR//vb7linjgN8DE8lL3F+mgfCLmlgaWaYHgudk8D/nJhcJGmYiSBE8YlGU54MBVLDcgF6PyMjGiZQ+9qywiF7KAlPha1olQJOkBlZXt4FizP3iAbCTanC+XYL6hBcwhH3vioYGewJlTG0pX62sQVm81b1MzIeZ05MdX/rWLdCZ/iOyq46F1W9hGpOV5y6mWE8M8rTEOU/afF3vOMdLzgvSWuKQzMx4jwjUnKAtZtveUkHc4ZT4t+t4YreXV8j+lTO1dUAM74Zrc+ubGVQZJnuWuWoreiykU6o5quTIbNxjtYMspz/6C9/InaMzKpo0+GWDl46f9WarOjS4ZHXR/QZ1e/Wygi3qnzHI5UergKdnb7rrjtdR/xU9VHRYsTjo/FXbVe4jOhc4dC1l/JwC14jmsxk6OqaX5VTeT8drMRjRa+O+pjx7+j6ldYVuSZxavI8JcrmFlXfWiT5J73OtrB0hpCZHILtwQzogO5nqwl1dB8bATvCs5ppx5/467oHXniYy4NtHEnORMEZ9DdOgbeP2cfiY/cAjP4/8pGPPPmrf/WvnjzgAQ84vBDk+c9//iGAdeONN5485znPOXnuc597wZvBMksI2vl5Q5ytJBuKB3QC911cBjJHlNF1n1sBWVDu6FfbrpIOHtDxYJHzBrSAlj4elWFbEWdgARqbeEnjJKjE3CQ+jq/rC8o4Dzu/dfIu/9NPddj8zJ7MB5YrOjZ/e4ac18+MHerm+PmObZKZTr6GkxZOUw+2erAs28q6ZOeAb3VGVLbnfML8sb48wMTa9+N1rolsH+iQB+F7MI8sy8Qh10Jlo/lLBnxLn+qIjwmOsx68vgecqvlznrjsW+EqQ2Zrfa9XGS2VcK3acIAhRXAOzEOheD0JFG0Nqw66G40zceNtDoro85v7OKna0oKjyj0UGU8DlMKqa1ICOluKw+JynJ3jlDTgPwKUpyvs0XShnNt+RgbezFgdGZJde9UYqrZXccl7o3LZRyeIR/WuBCSdtxjkqQir+z6XK2u2cvBWaDPCe8VIdvAnjpyRQOAUGaAzjVyQe+r8iCYzHCveqRTtipIfXbtanIMtkPySfFP9XuUfb6+DivYr8qaSu1UblazZyv9dWZ6eiX/RWfe6170OPK6n0NrCrMBoleWaY8rxjfDI9Z91Kjp0eqii0QzHkdE6wqeTRaNxjnCq2vD+Z/NcGc4VHol7jj9xGNFyJlMd/8pBOAZm/DXCJb9367Tj2/OQiZVs2tLm6phn5XJeunXpMLIFc3wXM8fnAQR5PLsDfHL7WzrtnTzirV3S/QRxfIsWdjB1adePgvCHvGSwyDbQkRkc2C3AafS3YGUGlQJP7ujhrPLQGIcSRzV3OrCNi6wDxup2itNJ/xVUe8xjHnPyGZ/xGYd7z372sw8ZStqVId2h4NAHfdAHHTKYfuEXfqG0V/it9gjUybdRXdGAh3I5j2R7c93pxPi8fXwy5sKda8bqmU4ZpOV+2gtsF9J34UxdxggP+DEg1JO/pfFpvjnr0oMiuQ49iOA4VudXOV9zzYMG+WDCv9O+l8/AUfq2Tj9w5b/TnT6ybGaxOT5VwLyyfRwXaOIBkAz+gpsHOzKo5ThQh6Cu81/277Ry+vtvHth5fV+XzvPg7z7zNXHOEvjnfNK3/vtWtfQhXC663EOecN0Dph7E8uw8cIePsr20wVezlI4OLI2U0Hkrp0wXo/9VfLwMgpGnBUQWCe7geCqjScJFAmWLEcBEwEwoNGdIlBR9K1gEo7FdR9lUEtwPetCDDh+VlbPwUz/1U+W2tM7g6gyLVB76rTZhMg4w1HX2aldjr9ofGTOd8V7dWzXKq3sjyIU6gkqAdrSucOvm4lLDioHaXV9Z11uM5ZVrK+10DkbHz0l7jLNKscrY8LTzTFn2PlfxrxRf3uscuBxvx3uzebwYh+q8YIRn5wCOaLwiZ0Z9Vw5IBxUfZVujdlbXTLfuunFhAEtHaCuzgkpyHvRUWlsefvEXf/HkqU996skv/dIvXaDDVmTQbC46+ldtV21UxlKFQ2VMd7qmWisdDtXvkT0x+j7Dr8NjJp+9/Kjsqv7Luan0r+M2wr8qvzKWma4ctZE8k+VTRo/w7myW0bgqHuva6PpbHWMHHT7nZYt3mVSXC8gm8YOy/UEnjhDXcpuKgzujvOyCAI5vu6KMZ+0TQFLwhPZFF9kIXCMIxMtjyIL2DBZ40rf8eKCBrVme/UJgKTMJ+O/ZHI5bdQYLPo6ytD/90z/9cKyFspRe/OIXH7JvwP1ud7vbQYc8+tGPPnnJS15ydoCxt+V0Vrt62K3/HGCNXeX/cZT9gTXt6LdoydYc3pLF9jr8DgJx6ajjODuNuVdlm0B79SN89Z23u+EH+vYhHt7rwT+BM/holKnhffpcQwvHv8o8yUBQBlmyryzvwQHadP/Z2/Agrb+pjjY9qOf0TZ7M8SY+uVa557w1uq//zo8uTzNLjTpOi8wOq4LT3qdnm+Xh2txXWT9CxwNLKctPi/VJPbICPQhU8e6KXeV0qjIGCbJ5ppVnDbrf4zI1da9nQp57YGlFEV4sjAxP7q/gk9dzEiXgnEFGhln22QETA/4IcQ4FVjscPu77yeUoPPjBDz552MMedhD4OgOJt1VImMth0JNoX5SJnzN0Rmm9vHAigMTbJPxQMlLnJFxd0eU4R85D9tvNXVeuG1+10EaGc2WUbjGgV5yLvDcyJiuajWBmmJ5H/YpPkl5Z1sv59YoXZnM2ur7ivFTl+E2wlExBDBMHUrrzKZFDKiPKbZ3PDt+R4h7xVuV8HYPPpYAZ383ke6X8q/U+kzMzqNpYcdi6Bx+dPKyupRyt8PB1JLmu7KTHPe5xB30hXtbDiPve976HwJLk+M/8zM8cnAjOtKjW70yHJZ4jedbNS96vyqcxnOU7PeM4ZdmufPZRjXl2req/G2uuxc4oHOmlFX3WrYFu7qq2qvvZViWTOn1erYOtUPFMN8auble2wyfXdP6ere0RHsnfnSyftXexdK3aPI92jgVsTv3PwAb/q3G7nQv+HlyQnatACuen+mu9Cb6QnST7HBuYs3Q825nAj2cIcc2Bw6P9bWfglzQmW8DPVCHTJ2WbZxb4WDMjwW0b+RH6vPCFLzx50YtedPLa1772YNPzEFt1NfaHPvShh2vYR+5MO80JLkmvKPjD2VFk+rADwg9H922InLtEeTLH1Yeu4QB7gItxeTCGrAtoktk6+p/BDoFnrHnWkvokA03tckg3b36jrusP58fMVMoMpayXgY7kk0qHVDI1M9S8PP2yppwvaMcDLX49bZMM8Hk7vn59TE5f+ki72/tkPN632+Mpg5MOSWvHv7Ols4zPA216UNtpBl9z+L3uif8Jpr6t2CoJfVxGeeJG0jSvZbmKx+g7+caDbMg/xoLM8iCYA7+Txy7LVrgVpbgFKoMlr/vvmZJH0WgiiYx7KiKZSxIwW89SSTy8vAQ3i5sUPRgYJaLvenKgA/bkIPgC1H0OFK8ET0WDynD3slIM2l6n68LP0/24r/RYCfhuTpgXxykN7JXFMaPnjIk7o2/FcVrBpRJCK2Or+lkxRLfgdYxRutLOar+dgE6+65Rl1fYM/xndk/c5yFNrSsYUTy9d8fqTiYomI94dPe3taOvfO8MhFXxe20K3KwmVI9bxj5fJOh1/pxExwwW5fx7OWbZRpQunkebXqrFVMsNBBsH7vu/7njzpSU866Cpt45QRzCup5Tz4G2u8n679lGuVEVuNo2pv1PaIdl373ZxX85cyZ9Zvls0+Ep9K/2UweqSXE/8cc0WDime8/wr3HGdF1+yjktWjMjPcVmC1fIfHSvnV9ru2u/XS0X7Ey96eP3EHugecK/PW4V9BzlunVy4XOL+5Y5cZOi6/u3Zye5HeriZ7ljNFOXNJASMyZyQ3FXBROd6iRL+yGcjS8W0tjhtvkvOAkPrzl4Pgc1CfB866lm8py2CZgF0Ono2Rzjv/dU1j1GHdsu81LukJHiLLJlIWlmhAVmueAZNBANplFwMBNuGgh+AC9cE8kQnkuz8411bt82ZbznH1t+FxxlTFp6wbfzMXNO10k+t7D2bpumxDHp4TWOT8TQ/k5Vrx695Pbhnjf2ajMMfcqx5SOXgGCu13tqcHWrwfx8txzjESGHMerPRqZ0N5Hc/acx53/kr68J95EjBH/CYDMfVUwsxOqMoytuQtpy9rjCNlPPjpgbrToGs+oFYdz6b0eU66+LXONvOttMgH2mce/Gge8PMsLOdHcCIY5cHZcw8sVZPSGXKXGzocdJ390QgzXkFJho4IpoBKdb5SxbxVX7qG4PX9jM4cmapHO2Q1SbnJURA+ylLS/mc5DN2Ejozf7FvfNW7RQd+VFUVqKAJf9/KMjmOMxm7xrrTVCa1uXCttpUJIXGftzWi7ZUwXCyPjc+V63u+cg3R6UoGMxpR8Nxv/jJYjgz1x8v8Yjvovg4rzCjKjqeqrok/nWHROWTWmLDsaW2UYVOPunnpdbTBa2zm27veInzqjq+KvnIeu3Og619ygWxl3ZRyM7uk6Dygkt7XVQW8x1JZqHcoqo1xb4J73vOddcAZItXad37oyFY06GM1FV38014mXt1f1XRm2jvtsTN26zXvePnzWQa7vbD8dlm58W8Y+Kl/JrE6OVfWreiO8zguq9VDJxGNslRW+rtbNyphHfDiay5HuyOudTVPJsplcu1LQrcW0mRPv0dYngIe3CiCwnY3Dtgl4+CvpacuPztA1ziQi6CFcyNLBxtdvAiY4eNRHTvBw28emwJXkOvfIOvCMHKcJesDp5lty3K/hTWjaMs0uCX4TbKM9dyQ9UAMOBND8jV74E749DSeVbYL+Ni3mkO845/otnUVAx/mgkiW5XSftJ9fH/pssM82309SzoHyO/b/zXIXTaJcI951HaTezYlK2Oe18vis6+XYlX0MpI9JWqWxan6tZADwzyhwvv18FQ7tMGccz8fGA1UxfV22n7vU59i1u0JMyJIfQBkkZ/nbpzFK8tjmfiv+Mg2CQ2uR4muQXf+HYyFbhOxlUrGPfcuxZWPwnbuHluUefBKYuWcbSbPK6csf0U8FIWeY1JlnGtwij7QP+ligFUmSgywHtnojMxsQ1TY6CM+pDTwVcQKM4/DA4gQJHcgiUuaTglrKUOOSbg7tdUM7G3zkIlBXj6gmD6OGKyw8Pmxkc3bxWRk1VpzLWR+124xvxQGW05L3KuF/p3+uu4FIZvx1tLiV0NK9gZqzP1uaW8Y14eGRcdw6QK1v2yWsdZVqwv0VrNMZU9olv8tEIUqlVY+ucD1cGAn9KshWPSw2pwEc8UK3TmYzxfjqZkPOVOGV7Wa4qn+10eFbjqfD3Njq9Aq++4AUvOPlP/+k/HfSLvut8DBnl0hk6h48U/ko/uwF1rH7vZFdFRze0KrmT9bfgkfU6OV7NYxrm1ThmPOXXKj7fqtMSKvnS6Y8c34ienXyoZOnKva79ke7o2ksZ0LXh4+3G4UZ95wyu2Dgr+M3oM8ps3YpTxwd5vVsnVxvkVpvk7cq5Z369bNKY7zw4lg3gWfi+XQ0d6kdluPzyPtkO5gcPs4UKn8J3J3iAiMCMz5OCXrywR74JmUVk1wjIFIAmZEpUdMHekS6QH3LdddcdypJBpXIKsikbS2X14Frl83Bzl5v6qC4ZX352lfwVHFWVUxl9NB71iaPs61HgZ1T51jPn5UoeZ7ANqN62RTnm03eOeDAs6Ud70CAz3VPvVDYY5TLA5ZA4OI18/Px3HLnmwQPG6DRwHB33Kguq0l20nVlWvkYZS54FluNyvKt1n/rM1z50ITDi7XW2iZep9EXSJOWKZ/D49jHGy3/NgW9ru9Xb+cVp5n04XsgctopSP3nM5z7XiAeKAA/wuezQfwJiBJOQNeBW8RHzsKpLzu2tcCNjoYKRsTVT1JXgq9r3/vVbAk5PeaVg9AQChUDKbOWg5e8R3uDC60XVNimguo5zyz5iGEUK4Kd/+qfPAlEoQoR9HrBVjTkX5oyuXVpb1W7XVgeVgp+VyzGM+lkxoGcww3/kcKw4kd39rs7M8dhi3M9gpZ1cY6t4dAZ/VSaVQudAVnWrcSRuriBcyVfKdESH7PdYuVWNwf+PBDeKgANGUV4YjNXrU68kVHM0W9sVr1XXR/05dPO9iv9ozisjs+JhNyhGeMwcX/jjhhtuOHnyk5980F8C3lKE0VzJoWr9juiQTnMF3XxU9VbWS6fXsm4lO/L6DMeRHOjmu+PjLmgxg9k4V8qn45G09O8r4xnxa1W3Mui3yp/KsB+1M8KrateN8ouRjyP6zdpckV0jO2u2Fqs+nJaz/o7h3/MCdwIFOEpVVgT3KeNt4HBWWRKenex9IlOdR/y6bHB9FIThrbL05QfmCjgEnHp+hgkfznZSW7L15QfI91BghYwitt352T8CrtFH9fYxxi3cpCd01t6HfMiHHIJLGrt2QNx4442HfvVgWWWf85znHPBVux4gYlzQUbpFeErv+EP5zH4g+0rXOLuKtsjggsbCg4PANbYqc5y5Yuugr2ufRw8qdfrV63kgALwZt8sNMsiYdw9WeXt5sHEncynv/Mz40v/0YGfa4x5oYQyVjeHz6fccl8yW6uxzXzveZuLt+HnQwucqgzqpU7F33c5yfssxpx6mvGfz5fgTdN/ngfL+1kqfD2xw8bXjfs3b23Ha0IYHquFDL9PZhZlh5DRnnDkPVYYYO5Toj+sEwpzvfE10QcNzDyyNFG11fYvyWlXUI2Orw08E1FMCCUmI6FHNWb+jPvw3WRIwksCNfx8DOHFooDvC/n8GI0HQ0XClDR/fSr1Rnyv1t0CH0wo+Xra75gJp1lYK9Vm5LXCsQVy1s0LrzhBPg3R1zTjkvFRGeodfzsXIwE/lWCnQqt9K6a7M2Yy3sz+EvwvsXOv0LWUgA5egEnWkKNjaOno6diVhpiu69bXq/IyMuK7PEfj8j3BIXu3uJy4rRlzyHG3JENFT4jRwU6c40P4KnXKsHe5VeR9LxfMVTbONpMUIx66NkQ7rfudcdfhXNkAn3ypjnP9VhsWKPK3mJWXXaHxV/918zvAYzUvSaMU+7NbdCCpe6fCqaLPKZ6v4bNWJq3RaxWFkn15Mu5cKnBa+tWyWzcAHPvYn9IIMCgB+hoyuE8jh4G7a0Ae7nDfD8SIeBWlc3vrh3q6b2UJGm5z16Mde0C9904f61JZnfyuZO9Xu/PqZKuAkm+BZz3rW4exWHm7rMG9lMum7zkZSUOlXf/VXL8hIwCZx2nvAiLOqoC33M2PKtw2xQ4Rx6qPjPuSD8QA9+8s51ce3DVW6hrIeAMo13WWRVLzlssjxoY4H80Z6wtv37Cna94w4/848Z9DTr2e72UbqVPpNfvI2cn0yRn94mZmDbi97UDcDZk4jbz9pRx9u02aw03FMvBmbj9eDeT6XFR4ANPEtn9W69vHcFOckEcjxDEfKeoJJRf+O3j7mKsjkySz85gNe0MdpDJ6V3bdFL59bxlIHI8PjPNqrmGrWZzpvWwyg6pr3pycPfmi3+nLFURk+zlxp8FVBpWpRdo5ARatujN1i9/pd+zNDc6X9rVAZhWlwbzG0ZvdH7ayMbUafLJP9rdRfgfMwOEc08Loj56zr47wM4pHjVN2rjA2+j3CaOUQdrTi7QU8vBdr6iqHl9JMywNDkDAMBCkHyxhXd1QQzed3JYa9fre1RH349A4OVfEjcsv8V/EdPczp57W1VxuNI/na87de9j25Mx/BLRTO/njK3o/nIwO/G09Gvwy/Ld2VmfY7kQTfWEZ6VfKzWQoVbyppRfxVPphM+k/OdnTEqt2JT+f1u7AlJy9zSUeGY63+ES9VGx685hlXDe8uT36220iqttzgJlwM8EJFOczXvVYYC5fXdM4p8zXCdLCLpVOlWjp7I7Bv60E4HtkNxGLefx+pbp1SXLCACVwoo+XiUpaM+OZ8F3Hj4rHvS68JPH3wItatMJpcZOL0eTFHwS7sgfviHf/jkwz/8ww+/VVcBHZXTFrgf+qEfOozLnVHw9zF50IKDx3lrdXVGDtkaaodtcdTVuBVQUuArM2x9exGBD7KcwIGdJe5o51m2VcDF+YRPBig8+4ff3lbKqcyIAZwHybSivdSVjrfzNfRIGQa+nIvrQThokW8low0fK+Uq+yP7862ACRn48QBJFeCDXk6DzsbLrDBw9GBR1s9spqRvjtFx5H6O088iY5yewcR8aL36DqNr7Ewif0siR84wJv1HDiS/jmhVzXE1Fv1nKx/093O4XCfQpwfhMhh6VQSWOjhGsa0YkZUBt9rXyIAaGavO/LxOk8MCxTC8TSGjrN5ubtfxMjOHpSrfMYALxyzjTL3FaJ/dmxn1x0A6NCn0O4N1ZR47WMF7xGujOakUzoy3LwWs4F/RqjPcq3mv1lbOlde/VOPuHETHqeq7c5pWeIh6+sjg0rlqHKL/ile84mDouRzAkCUFnT3dCHqV5eBQH9OVdhoq2rqDN+Mbv9eNZ0Trav46hTyar47P814le2fys+O9GVR8Vjm7HQ5dm7OyHd9XbRyzZr3d1FGdzFmRNyu4VrjPZFfV/0i/VLxT6eLkK3c2kg4jG6CjbUeTlfF1fDeSiQlbeL2yR1Z0+kqfs3U/+77Sx0rbqf8qGm5ZT5W9dd7213kB484tSK4v9OkyeStwPqm2SHFfelOZO9KjstF1oLUHetCzBDN0XXa9n0WqexlccKdS96TnCdrg1BF88nH5mlb7ZEHJYVVgigdQnkHEb+cjHj5pTE972tNOXvjCFx7sDOHDebI60/XlL3/5BUEKznriYHK247kTyjh5yKVrBE8YE+VxumWbcMaV6KUsMA/S+fk82Di6p3HrPnTSR/c5KwvZ6MEN+oWmZMyk7MgzZTp94JlYuX3N+c15rdJTuR0LPsngkQdGXO6Di+ML3Z23OtxybE6ntL2r7Y3g5Dzu69av0U+VHeZ2rdMjM7Wq9Q0N8w1rVbaWz7kHIit7otPh0NjL892zt3zc+Ua2rIvcyHlmDWZbTrfRAyEfv7/B0oNfus+6I5BfPZRxHGizyqa6qgJLI2Nvpd7IcM0F4tf5v8UwnOFYGV18eNuUBHPuHT4vAyZpkIb5iuL131sNjs7BOKZsN6auzGzsVVtplI/qd3isGHmXwnDbQuuL6WMEafhWTkaH5+r1al4rPFxhrs5JyodURtVYu7ZGkG1WbfPUD4NRv/WmL5254NlHGF8YXDJsPe0e43VkaF8pWFnTs/opm1IGjNY619OhcBjdn/Fr6pJsr9I350GXEX7ZV5arxuhjr4ziqq+OlhWsjnNVZ63gl2Ur+ld0GdHK203cOvnR4ZDtjHiiwq2TvSv2FcbjaFvIqP9cWyM65L0t9t8x6yPX52o/K3Pa1btYvTyz+5Lft9qlQJ4dcl5y6GIAnPJtVhWPgnNmd/qnsg0cfKzoVNe5njWjfjhMWzpauhd9zH0PcrgDRoDGHwThzGmcnKOa6wfHEDr41jIynIUHGVFkQDBe8BJoXPpcf/31F2T/cFYTdgXlhbOCOWofJ1SBKOHKgeXgowdgwsW33XiQhyATZ0Ay12qTcZPJJTsI3NU/9NQ1/fYAnNoj2JV46b5nizgP0b8HSqC5l/GsGw8YUm5kx2aAw+t7gLM6XiHldyefRQ/RnQw0ghJkFXkWnQeuPDAwWv+Mw2U944AnnVaJX27ZqtadB3+yfkXr1B35dra879tpc9y07XilHHf6VLsHfDucJ4ToP2etnb49wOtvWvNyjrvPhV/LIFwn06q58378wPM8W7mye7MP/+5n211VgaVjlHA1cAQa0Xki7FXUNtvojKgZgbu2nDk8ug4+VV+dEX2pDK4RdIt7hGtn7IwMx5Fx2THzyFBcMVQTr1VnobqfC/xiwNtYaetijddVnMCnm5sVnu0UVzeXozbzXtKtq7uFpiOHbdZu93vE28gvDvHk9cCelp/rz5UEbbBHupN5Vwo6g2WlfEW3Ti77/Fd1u++VkQUenVxLXFNWVut5Nv6ZblmBFV6f3e9kUUXPjh7VOq36H9F3RK9O/nbf+X2MrO4MzYTkhVH5EQ4dnx3DC1Vf+bvbRpT4VMZuh2/VzhY8R2ttS/spSzrecKie2roTNbItKrxH+rNrw8t268LnZBVGttnMdrockGNj/OhInKRO1qeTCDB36bziYPGQht0EnLNE5o47YJm1QlYTL9vhITJl8/BeAiq+XcnnHR+Gs5WUOcW2McbH1jn1JfwUkNGHrXN5lgz1cH79rXjqR+cesaUvg1q6LiAAJTuFQ7bVP/9FO7YUqg8FeqAtfYOTB7Doh90dfm4TdOajNqGPyqm8PmRyaUxOK1+v9Jdv2cozmuAj5xff7lTJkVxXVQDDeZF6VVDJeayyR8jk0ucOd7jDgUc0fm3d1DyQ0abthSrPQejwKm34OP1Aat33377GKlnt2+JcRvr4nXZpX/uD0JFM87WS86LvBGD9Hjaxy38fu/NGZrr5nDpOuR2StvjtZym7jDmN7DnHi0A6QWHfFlrZlpnRlTye5ZMPkUcEugjAEpBkXXhgOHnGr73DZCxRl48IpTRWCXeeHGih+euWHUb9rRp9I+eBSZeQQ/F4vzMjNduvDI4OpwrfzjAfjbsba1emokPXf9dnd6+ib/Y/M7yz3ErdSrh3uK1AZ2RudRq29LNi2B67DlfXVVdu5kS54q5gZd5GfD1yiqp+R47J6rzm0xeBZBZGkhujGHW0r0/KE5SlG5WV0rlS0NFptP5Gc+ff3Qio+phBt769/ZW1PsIzx9vJsI4e1b0Kr84QXZUt2c+onZFO6Wg/W2urOibrVt+rMrl2Z3O70ueKrTBKG0/a6v9oi3yOI/sa0WrUpsuL0XrYmgI/w6Gbv9Ha8Ov+u2tnpO9mbXl7K0Z0x98OHQ2dD0Z8PZrf1HvH2tVXEny7hiBl/Gwd55YV6mRQiexeD1AQ9MEZJGPG8SBjyDNvdF11FASSD6IAiHwQ3eMNb37mCtuVwNvPXFGQRw+VVF7tKXig9pRtREBI/bOlDFwUYABfeFVjVHs8sFLd17/+9WdBJeHHtnqNAfuBulzDyXR64LRDU7YIYocIOBfK3/LGOAl0cCwI86F2eAjvWV0AdbGVmD9oSdBKgS5/OZLuE4zRddHT3wbHmOjDbSu/7sEUt0E8eFJtz6KM86Xzln/3s5Gch+EjBY44x0dtKxAnXtG2QmigegRLfaeM6xi3P/13ZX/z3QN2zEVmDQHU87F4n3luV9avDqh3/LKPXO/eZ2V7ednqoYHrPJ/rCo8MRrp8uDYCnElXAjt80i7wfjMwWs0XUGWMkYAjyAC487G37XzBvLHuzj2w1BmCW2FkMDh0fSHQ73znO5+1R0RX3xHwyRSrfVQOTGUQdvinETUyFiscKiZKQ5/vvphGY1qZy5ETVSl6x82vO91XDK8VvuockYpWI1qs8ls33q1Q9XWsAbjaz4phmoJu1nZnyHdz5O1Wxv4Ipw5Ga21Ub9RvN35Xqh3vVf126yrXiQeRJLd4sugGFe3xRI6nDvpgiOkeb6mpxne1QDc/nS7YOtcoyBlfdd8Tl+5+59gk71fjHsn8EVQ4d3JlC3R09LFUY8r6szW7cq8zAqs6Mz6ooJLnI17o5nlE966PVfkyai/HPpKtHX4djUZ1q+BKp1+PlT1dGyO5e0xfI/4ayZuLhZFcqqDj75nNttWuuhR2yDHgb9dyxzJlO9/d8UvappPk2RFk+vB2Nuld3g6tNnjxDllMArdlfGsNelkf1fGXavBdelngQS8yo6ijzz3ucY/DdZX/tV/7tTNHUD4O+LDNCRwIMKmMttBzQLaCSre//e0PwSPKy0/Sod2cJaV+CDy4fOI8WIJenBPL1nvaEziNCTIooKS+hDvZSxlgEF5sj2PMuudvfMMWIrBFQEp+ndrmzCoP/oCrAi0e/FL966677jD3L33pSw/0ZdxkTuVb6Vy2Uq5y7pPH3Gd0vul8SA+u+MHQ9AUfiK6aZwJxBCs15rvc5S5ngTXRR/OsNp0GHrjN7abgn/ilLktZ4nVcR6S+8/N9wKMKtKeN4evabbtK91S+hreXdXw9V/YNQU/wIKjY+RF8x36/Ns5P8zeywbN+yDc4pOwCX5c7lcyGrrTBGvI5ow2nEdcZpwdDdd/nSuvID6I/18DSVsO1gi3Ke6QYGagzAgtMEXoJyFVja+aUVgZjpvNlIGt1AlacVSY5t/4Rfeyiv/yuHIOZsTYr73QgHRaB6E8lujF3feU4OkFSjbUTNN14u/HNDLJRG928d87CqM/Okb1UMDK8V/h5xPura/Fixrq6hcHLVr87Ab4K3Vx6XygA0py1XmRkERT3evoteUbg3J/8dS8GuBz80sHISa8coW7Nd0ZZ52ClrPZ7o++VfM/v1e9qfB0NOqj4bCbntrQ1gmpORnphZTzHrpkV+dzxULdeHe+Kpzp8R3O5MidZJmXLjEaz+6vtVXpwpd2OdzujtrIvZriN8Otk52hNVWtw5AyM+l/BfQtsXb9bZXe3BmZjOK/xXSw4L+MAZUZFvuo85y7fZOQ8if0sR1yBDxx0zqPBj2BrGw6i9K1vh8u3aHHItYCzj9Q3Z6vSluPvOxrImtJ16X4yd97whjcc2uIwbQWKwNcDI4xJB3OrHBk5Ov/oNa95zZlfhG2uNlSOt9FxXAd4+hYefQiMEVSq5CJ00viVGSR8tHOE9v08SJVjyxuOLFtzfDsR+NA+gSYBtPWzq/TRd42NABT2FbYVWxyrbVg5t9z3t66Bc6VLuuBAlvMy3ZpFnsJfCihpZw7bDcmwgy6c1alyCpYSZNPYZRv6XPu6cvs434zmfJsBHg+swjPOF+nzOS08sFLZHN6vZ/34x+v4tdRD0DADm5R3Psu+PYjovoTPXdIjd0nd9PbrHmxKvnO8nF+q8aWt6ryb+iLPUcLH4Fy2EU2zHcojMzuf/ujAUmXkXw7o+kJYIGD0m7c8kD5aPQ0UJAPyv2PerEcwhZRShF1ug/N6/n80zqouT1ikFFF+6lPRaX0yY2HmKFTggm/VCEVRCTf9RnALHyk5zYEvuJGBPjLYO8emMhwro3vmSFRQOTEzeqQC8bYqY2e0qP3abNyruPlvF0i+93irw7JybzTXM1nSCd6u7AiHysnocM06lbNz7LygkFA6MsR42qT/LvRRTlpTepsLawyjzA8QrMZwNUFHs+6e16vKbNFDIwWe+MycsQrnblydPOrkXNfOqGylu2ZQ9VWNp+p/hX5dvS0ytcOpwiPvpwHW4dHRrKNFp686Hq1wq4zEGe9Tr2t7xE8zWViVr+ReJV+7cY36n+HX2WCjhwUzuyGfknd4bdWtx8BofYxw6Xikepp/sfbd5QJ0mfN2ZZv4GN0ZxJYBdJ8sCWxnr89b3PKpPn4EASHOWaKu848HawRy6rku4HBp+QZc86f9OM1sG9N1D6yQkSRbwLd/KWCArwOOCjqpvGwDlWdcZFyxlcptBl+f1dYktgj6dp10VBm/xqiMKeEhkN2vgAYBJcrzIMzXIoEJPyfSaa3/nDfJhwPHCa74eU7UI4DhW8c0JyQbqIxv5cpAZvKX+5GOI+DlHHy9Mk7ayT78u8rKr2KLJIe1KxuL4KMHfmQ/apwqL1+MYKOy3HXukgKNvgXQ365GG+mj5JjAm7KezeLbBCv9WsmdSkfA/6lnfO24TexlnIYE3zLo4vhUNlnSInGAdtUcu7y6qbDHPfDtQTOnS9oDfr6U40JZgo1JM8ZBOQ+U8X10LqvzOWudPkYvIrvorXBbDEPqCbp6qwoUIO3LGRuohEIyDm0gsJn4fN2f440CQ5gqgHW3u93tLBIogaonDfpfbcNLAbJqjKJQ7nrXux6EDEpNfTIG9etvmBgZqtm3X9syr+qbpxQ82UFZogz9SUMKkKRtLpotOFcCqxvTFufEy4xo0/Ev9TqD+HIZeVUfKF0yZTq8thj+o2tZd+QgJb07JbDaZ+K85f5sHWUbiXdXX3SXMYgClNxQpiWGX9UWgWu/XimdEd6XGzqdkbIqDYDq/9Y+Epx/OkNwxicVnjPcqmsrvFKth2oNpCHU4VHJ0WOczS3j3sKHIxqs6LMRD6WBW+HXybmZ7K++VzqpKtdBNebUmVXbo35y7F2/WbbCY6Z3V6Di6Wyno2NVpxqr41u1041/ZT3M1s0It26MFS5dW7O1W635Y9b7pQQPIlRbijxoNJLx2JVVEIK3neka5xUpEILtjl2fzhYZMf5adgFnEGHnyj6XEy/HX/dkT6murpNVonbI/KFNgjMaOwdZc44SQRC2xnF2kgIkKs9DdPXBQ3QPYhEg85d94OsQfMrziPBbhIPAs1EIaLGFX/3qo6AS/fkZUJ5V5QEk3fe33vmH7CUCA+Cdzjxvo/M+/KBxcBZ9tM2Qh/C8QY6xpa/o65LvnsnkfAjPZT0P0Pk6yzFUwRyceI1BfhUBSwWHOG8rXxUvIAjJkQlss2Q7JHMHTh7gABffbsVadN6hnI/T6ZNlKj2T+jfXd5UR5frAA4DwcNp0o7mc2cppIzgNfCtZNVb/X/EQkHLYA04ebPJ6qbd9XTkf+HrlOnKInU7IO4KzOV7ojkxEZgCc1XRugaUtBkPCbFsK95zJ/HoCAsqFFP85vJv6leHnEWERXf1qYUqI87Sh6pv0RC16CSyeIDChHLCXDOiCwycvjZ8E6nFAIKmxAtJLFWwiBbYyytKISVpUBtfM4IEO6tv3lrswYGuiZ1Nlv3mgoT8ZmRmLjvNIUHSOyYoxlu11+Izuzwy/qr2uzcr4nq2rDjfR2QNKnQHf0bUaa6VMss6Kkh71OTIsLwZyHeTcrjhO1ZODDrReFUjS0yYBQaMqsL1C42pdXGkY8els7XRrNo0G/59tj3AYycYRXiswWr/+v+o7y1c4V3VmYxh9z7KdHqj0SuKFgSIYPcFNOqTur2Shj73i70o+Zt8ra3tVXndj62Rgheusj6pdx3e29rvvHS4VTVbkjV9PQ30Gq7Kqs5dGMrrDP++vrskObx/7yKbr6ieuo3ZmsnM2hqtBNzi4zPBr6Uxm1pmX4zsPW2WbKngkW112vmxo2eZk+ePE84CWwIeuKVjih1oDvq2FYIrqSYerb7Yd6T9b2bCFPfOH+fMsFrKKdJ0zkJgnP49J4yCoo/FRDhrgDPu5jfgd+k0WFcEj5wV3UJ2+4IqvI9rqw9YzBdR8t4af7+NtM5+65w/ICAjiLFc6L7fCEazDSQZH3VdA5V73utfJe7/3ex/o9brXve7g2+njjrj7HanDnCepA22ZsxFfgmvahOn/cU28QlCJQKjoKl5i5wd1/T9BOP1WAErzoLnhjYFqw9+WDi4eSKXt0VanpI1fT3qlXs81nLTPtpOX/TrlnOYe8Er7Q9d8K5rj7+UzoyjH4fT2ILj7qxkYOo1gkPNZJ+cdn7R1ve3E0dvxgKF4ia2R7HzIN0u7nNV3f8lBZZddNW+FmykyFlemwKaQoS0WjG9H03WEDsGhqm+Ifc973vPsTQyknKpvOXu+uJhoBJ8WrLKHJNQhPBPDEwPGlFlHqqt+eCLBtpekhV+jT188nKsCLZxRqgVa0ds/jBPmn80ZipAD8/KNEp6SOqovBc5Bf4yDg/389Ysdfbr71Rx0eCTMaFf1URm0Vf+VY5B9b8W3wiPLV+PxrLqRE1Hh52W78t08Veu5o9vs2irkuCrB3jklCaM5qgyibn1jXPEkyZVC1hu15fdHeF9JqHgsZU/OSSrUVNgj5zCfGlZ1st+V8tW4ujU8asOvrejGWRkvV627akzVPX47LaotRF6+MibTOO3okFtMHKrtMehaDDgyjLMvx7PDY7Z+ky+SVyre6frPdqvrHczk8UxXdLgmnjO9WvU7MqITlxXdMdITo2uVPM9xZvnEy22ni4FKryQPdf104x/JmFU8rlaoDut22zR5jewXB2x0HHN9ZN8rY0WBJdXjMF1tEbrvfe97qMNDHd6YRrCC83oIGOFfYB/Tv+rJUWPbHMEobGHVV3n5ChzaretsT9N/2buAfBn6RzbqPg9oyehh5wIPoniwrQfMmWXAmHTfzybCD8nMHTKwqEP72PryRXjLmgJ0bNvz7VWp47E18Q08A4y5I7sGmU57BOVcD4CrB3gImGluH//4x588/OEPP+ApuPHGG8+yul796leXdoLrMQ/+5GHTHihijBnYoF61hcvP7KItAobiE9pQkIgD1inLfFLfs6loVwFDcEr96vOS29cqvZjZRC7PXL5VWUqVv1Gtaa+b+t7lg69/lxMJ2AX45rntzPv19jIbK/t3Oepb1HIcld651oJauSZSPmcgDp7xbKSKHqz71BseIKdvrmVwzP12j3nAX0n/c8tYOm8F5UykxSWhJYGbAaJkaggrwS1hRMBG97QgFXSqglIQiqi/L3y2dum6hHhlDOmjMuqLiSRSj5JwZqM/4acMJ/XL5AtPHbDnGVYVbVxYCS+eRBB84aA8yma6X7X4wItUYXdyK2OI/9mWv5aUdFQWmR/4l32rX9HjwQ9+8EH4K5inpwkqr/Howz7tiudGzsHIMKsci8rArtpKh8B/V8I5g6THGM0zmLWZ+HnZbo6zXtdu5SiM+q3oPXKMqnuj8iM8KoVY4dk5R9U4jgVvN53q7klJB0lDNwRWFcClgsqhqsoIqic9CWmU+PXss5N5K9dSHnSGUnVtdcwrZVaz39I4qerMxjRbgx0e1b1c310bvta8Xjf32AjSvzhpZC132bpevwL0ZVUn9d5MxrmTkfJ+9iR4NHczSHpn/Ww7dWB13+9V/Or2mPc3W7+jOZ7RZoUGiWPXZlVvtF624pVzkeW36tkRfVd19NUKyWO5HpPPcISwYd1hlV2pt2RJRshJJ+tDdrlsZ8kK2feyORVgUnnZmtiu2PGeIcTZqdi42M2eFcRLg/whLza77iuooWCQgCANW0pUj+1j/pDJty+xBYpglOoQaCJYxK4L2sc55SVH2ORsmSKw4JkrHPOBX0SQzHHlTW74LSqHH+AZWMhW39GR+p55576/PQ9ZCl76TT/g5mXlY73Xe73XyROf+MSTRz3qUWdBNwJzD3nIQ862K8rXcFvL/SbnQc8MqngzZRrjpj23xzrbhTkiA0z4yffxN/D5XJFw4QeX0zb0J1GCB/dkn2T2jweenB4eCEnwrB3a8LXMuPyaz3eC+6veZmbuV3Ldg0P+f2SzQCeBZw/m3Ptvp5PrvwxYdQ/UTqPMyJ5wmedBbE8EYOzOR/yvvmdMgusVP3gAEzkI/22BzRlLFUE6A3kFMBh1MDWn36s9LSydHaSoOPtt0+ghxQ+BKujeRgZ+njrpr/6ESQhQeT3/QOw8IFCBIp5QOJ4qr7RMjc2fqkiIqO8bbrihDIIBvCVCZXiSoDFL+OgJhT6e3TNzWnSNNwlI8PghhRK4GkdFw1xsnM3jrySlnB9mnm2IVqLFAx7wgJOHPexhJw984AMPfb7kJS85CFWN9RWveMUFr2vM8Yz4rVusnUGZY6vKVg5V9ZuFyb5+BJ/GQibW5TT2KtyTjrP6F2tY8zu/j+agw3dWplI+qdArg2CLQ9H1WY29c/oS1xH+FT5eDp7zp5xdFsjlghxXBRVtKlrO2h7N9RZ8Ha8ZDivtrJSp5jWf/q3Qg//phGW5NCyShiP8R/KzKze6nnKgWyPwN+dO6IMjyFNz6a00XGfrqNKXFa2cTh3dRuMZ0TfnrirjAcYKttxbnd9uTDm+UX2vu7ImKxp0+K/q0JyDTm+N9FV1f0WHrsjxHHOHW8q8kf49VgZeKUhZ7k5b5dD7esjr2F16gCt5IRtZtiXBHX/qL3tMtityhKCK7qmen9vqWUAErNjKJRvYsx4U1PJrZOCoPOeP6re+c4QFNrMCH8LPD1X2zBP8E/3nyA0PemlMald9igYqS5YTZyDlwc+eieBBMujMGVE8eOcMKYH7HZ5R6m+s9jOmPKuCbYjMte6no84c+zlUbAMksIadLR/rMz/zM08++IM/+OBDvOpVrzq0oTHro/44F5dMK3iuylqpbCnHi9+ePZIBCAe/5+sTftVcaY7Sn/PsEXD1QKA/2PfsHvG7eEEBN4KrooEflJ7rjjGxLj045llcPmdpa/pDlNQBXPPfBLxyPtwW6mjo7TCW7DsTLViT2XbOb9oiCZ7p5/PvfV4btlyFO+07frl7K7OhvLyfm+Znl4Ej49V3ttgmD1Rltca03vVd68eDm+f+Vjj/71ARfqbcnEicW8SBev5EAoFYHYAlgEiuCEbK2nFCsHFuUcWwfo2sIS/D2waUYsm+ZeoJf41LQTMYQAEdjVcLn6evHoBJfPVb7atf4UmWFE8dcsvfzPkgY0tPdjgInKcUKCUpY9qs5lvX6N/5Qh+CXiixBPUj4a6UVWUtiR6iA4aA9kNzkHE3bx2MnIRReepUv1cMYuhKNpvmybdF6p7GRlbWCKctcEw7I8dvta1qbXj97n6FR+d85f8RVKm4s7GlgkeRdfzuuI7wqnivWtNV/1m/6weeE77iNxkPOkcCg1frV/x2NUHywExOVTTnd9dm1+4Ij7xe4bBSP8scS5NOjlf4VPyT66pqqxprh9PK2vXv2e8I52yra1uyVDqLLejSuWTbSp7KUaigGnd3b1S3479qjKN13NFmpGdyHeT/7H8kx0fjH+E70w2VvVVdy/ujJ9mra6/DrcJl1Xbt6o/wG9lfOf7UCyPaVvw14seZHql44DxskWOhynjgmm91SpkF/5BVQ2CJIyewT8lawTblYTR2vPSkbE3ZbpIv+u8OI4EWz/zQd86+4fBslfVtZ9i+bOXiPFiCTPgBbsP7odoCl3Fsz1P7HMztZzLi+HGwNtvqVJ8dAP4mtaQxQQdwJMuLQJL6xjcjOOQHCOP0O/74TKrjL/TRd59n9Z8ZGRlQ8blnrGRwCfSQ+rGPfewZLThHS3Mq+klviObaIilfTTaSv4ku7dQMSGQgwtdlbquiHX84n3THeVewi3NyOfwdngcPeJd2/GwkfA/9d7rjE/PWbgKRngXD/DAe1hPjhRco54HZSp+B70imelCHcrkdrrIlnBbVFj0fg8sS2q/8kJH+dBld4ZOHuoOX43gactuDc8ybjyH1RKU36NPPJ0Y25XjJqiSxga2mHitx+YoMk60lniEQ5Wv83ANLW2FmuFEGAUE0nzcpCDRACUheOdkZIZ1hmvdh7DxVH+KRjtoZEqqr4ICIDo4oJtIrHQ+NSYIDoYoyQOmMMpWcmQWk/PvYqsysyrBzEKNJyLKdT4Cg5x6pmCPg0D6ULwpT9VBI3VhYXH7onuik3+qbrLFc+JVhWRn1lbMya2PmZHmbLtxYmCxGgnQsfAQ1Bk8VbDvWsJvVW3GeVozbUf+zdVnhURnHK/KiAwRfpZRSEXqfM+h4rTLOK+gUQzoVq7T39jAiFaTVR+uWJ5PiRRlPVxIuZj47/hjRfZWHfB1XBpK319VPuZCyZXXsHS5V/zM9kb+zbe+vG7OXmUG1vqoyVfudbqrGg4ErO0DbV3AKcVJGfVXt+fo7dvxJz9y26G13dkjKImhYpa0nT1T8VhnH3e+ubuq4FXCDuRpb1/9oPadeGa31Y7MzO72V/VY2xAiqelw/Fseu7WNgRV9fTkgHrQom8BvnPOeesXCUha5zlAJBGWxcf2ubO+gKNLiswUdgexIPnzl+QsdY6DrHarDVjECK8FIdt3VVhgeusnc9W8OzlLCp5T/onvwf+uHcHcAzZAj04OOQwUDgy7dSQV/wpi0y6wnGYdfru3Y4EJzzLC5kQGZCuF3GOJkHD1r4dhuyrCjjZ7b6uHmAy9xfd911Z/f00FzzyW4QAm2ioTKbXvjCFx7m0AMpaQu4XMlzdjKLKdc6c+Bb6XyLIA+hhaeCSrxNjzp+/g1tAWlDMofOOz5vHDEj/9R9jzyHqPIlPfOGdl3eV7qLMqyvLNPZDKtyifXqtOC6t5O6NO+lLK3spk4HZJ/en9e51jKsukyu7Dt1fMVnJIQQ7CEATVAXnvb4Ams4d38xz/TP2cnIKdYt9tZlCSytGvMOlWJ0YUyUDcL4ZHSKNnHy/2mwEBwSAckYYqEoauxvdcs2yMa5/vrrz1JS2bvtk4hQUPsSHEyIrpF6y17lPKS6Gg/3q8Xf0aH6rQ9PdVC2MCPl2eo3CrAxDyghj9Tm9jWvRzkJdV7/SRmELQG+ak47qIy3mRE2M/w6vkphiDKU8OapjsqSfuuLGb5wQXwszAzuVVgxfEeG8qheZ2T7vZFi2DKGmeOy8r3qP9dm52hUdOhotUJrr1vRAsNVT+B45S9PFFTHD9a/0jCSTW4AVIo/jahsp5NRXd95bSQfugy2rv4Wns1xdriMeK7r09vs+ujo4vomjcEtczta89VY/HoCW+HQDfA4zo87o9lXtY4qnqoM28oA7eY+28o2VmhTtVXZIrO5q+RqBclXFZ6d4T0bT4Vfh0/SqKN3pRuqjJeZvTAqs6Ib8vtqGyP8RnzSQcWfIzhWVl1K8O02/gQ/7W7fGpc8CXBdNjoP8hT80YeX9LBlRA9i1K7KKODAG7VUV/c4t5V2aF9tvfKVrzyUJxCDzSz8OJ8V/cxWLdYSb+kicMRuBLahkZXkR1QoAMGLbQgS+dy7s0cmDIEw7QDQuMg28kPEoS3BG7bl5WG++D2cP+Xb7z3jiXZdDnlQBRoJH2xlHmBrvLKZ/YgR6iL78bMI+OFPaX50WDf12C3wxje+8XBffoV8OwWf8HvgG3f4q4wTD9pAE3ght0M5P/pWJgE7Q9S3+E27WAgqkR1GgJFEBPojYOdyOrdLeb/8Znul+EF9cRi9Zx+lPMvsf/dV8rxjt488+OU0cz+H/75lK32hXM+pgzwgWckKfnvQM3nRzwJLWQR/Mb+0nXrYx54PVq41nvIzklx/pu+XMi23/dEP2ZNaE5Qj6MMaISBE/x4I9aSatH3wIchu7Gh/yQNLM6Ozgiyr3xKWYnqEjQSFFpsCQLMtHZWy7Iw0FpWIL4FLeiTElCCqMnW8Pc504k0SlbHgzJ6pj6Toanwa8yiwVC38qlz2WeHPXPkBeZ4OywF9zvwjw9fpkQt9ZHDpgxD116EKfHtfPlmpjIjKaaho4jSr8Fs1/r28f/xQR8bCfn1w8/EmbquGZOKQY91qLG7tL5XnqFx+r3Cs+p+V7/p2Hq9kTIVnVaYz/nNNZH8Vj1Z95pru7nkf3hdleVKBcYVS4LXKs4zDSw0d/apySdPVLIRuDY0c7wq3Cg9BZexkWyPcVsawZc2OeLLiq47PVtv36zmelfnMa4lv4trJeQEH6aLD4Hn4pcJxZT3mb8fDv2f5Tj9U4+j4cYZTtf5HMriiZfU7IeV1rqtVOs7keVe2W5uV/uigWr9Vn1vt1a7vpNmx7c7aH/HRSJ4lLboyI3vtcoAHRVz+u2NdjRv71bcKyV/gkGzGJp+CgAprSA9iqE9gggwnyRgFIjjWQPeQOdKr6oOAdqWb2XnB297AR/4C/oz6UVvKNBYuOhOIh4/4CfmmOQWk0Onqk0AQYwVH1dO2ePWrh7dqjyCM6hHAwgH17CTapQ+B+wj4PNDEtyjyn4wj5sQzNgg+4diTeUFWGQ/bff59W48fKEzmFC808hcFMTbenscxFKKzwLeFQT/GOJI3OPGpaz2TDr5yecADPwKWPIQWPTlTKQPk7iv4PFQ2J3175hvZeqIPh4P7y7Cq7BnaSMggRK7FpBXzlbhWcrizoxkzY/Lsp5S93XYzD0hXmUOVruF+tz2PgJzXc9pU6+LU7MksSzlkUQbPqwAU7RDY5aig9DHhg6SbB8/om7FVdVZ18EUHliqDzDseGRoOIM0B1fovociewDe96U0XvKmMvmYGUpZLw4j0Us4jEZC5k21k20nkytimbwScBAlRWl7zqcAWTz22OCqJhzN2B46Xv6VBQodMIX6TUeU0HxmMaWCvjENKUlt19BpQnq6oX20pfNGLXnT4n1vGOgO/KpPzMjK8Vn/nNS1GMqxIKeXJAllhKH8UZnWY+eq8d/c6XI+BDp8Veq7gm05Ktda6NetlurZXYOQc5hobOVVbnMWuvy24VsDbWXhSypO9lYD8pYbOKezo1s17Gh4OW3gk28/2KgOo62ukA7LclrXphlHiParT4crHjcgRPYFuPWSZNFS6MqN1P6Il19i+on4IoPI0Vg9n8vzF0Rr3a938dHzb4ZfGZVd+xHuz+ZjZJV1bHZ9vgU42VzbAMXbaaKwVLiP+qcpVPOb3uszEGazSsuKZEczmenZttZ+u3uWEmbysnq5n4IG6Ag50lrzQR4EbzmWTj6EzT3mIKh2p+tqWprIcAeHBH7Kc/LxXxxWnV/XIJuDhrex+tc35OXpwrfZURt/9sGW2Qum+b6XT9l8PnPvWFAFBDfkVBML0cEmBBDKjyDiSrFS72PfqkwwoPh7ASD7E8SVQxZwQFMvMGgFzl+c6sZ0OmhEI8O1Z3PMgBWsV3LG3n/e85x3eCqcMbrWtoJ1A/uQLXvCCs0Pcdag3thE2OwEvxunzq09u6XI+BCfnZ+cNz7Ai0KXr4gmOYPFzdj1LjHl3/LwfgiYEBjyg5UkU7J4QLfx8sWqrmreb91PXJT2cV7iXvFrZel4uM8Kgia91Dx553z4n1Zg8oJJ0TL1AWW/LA9nJKwRG/Uy1t8Wh5Ekj/14Fs/Iec6ZrmkMPPLOefJug8yLt+fjdRvStrfAfcYLM1jvXwFISomMwnzCfhASfSJUToST4SUUV5OvqtxhFyShJaAzWUXSua9dpUPXJdy1oBZA0MZ5Oy1sL8sykFYP+WPDUVRatKyx9CLR5UGeGg9N1BQjq6S1wmmvteebtdKLVi1/84gsCijM8OjpVBnd3f2RcpVBwBYcRgWLkiboLRQWY/JwlAneZ5VUJZse1wrFak6vG5ArNRmWPdUpWHAvKdOMeQUXTrg1XZCkfKpw7Z7HCYYZ3tearNrrx6LfWkdaMxiDe4k2RCszydPFqgKTbyAFcdZCOcYgqB9mvb2mz4oNcgx2fVLojy63y/kguVGuo0zEVf6/SZetcjPRm4qKPbAP4XHqUN5yIzznnr2p3hQ5V/5XM69b/6P5sjrv6Kzh0BnU1PsdrJOMrmdTRdlTfx5h9r+jdTibmtZFumtmdI5qM+l+d00reZV9bdWul4zt8qkyfyq64GiBplXrOf/vZNVUgBDtXH96ypQeAbKeV7UUmh8rjtCkApDbILMK+8/NR0bmqo3v68OYkt6sFnP/DGys9+54PgS0CUeDkZwxhp7O9BTzwW8BP/+U3UYdXzivI5FlJ2K6eVQW4HKGcO8YcmeFb5nxsvlXZty76+S6+NS7PXPJ7PPQms4hzZHDWNa+aR7aV6XiSZzzjGScf8AEfcPAppCc03zoLS4El+WJ6mP1Lv/RLZ2/f8y1aGaDM7UwjO4zv/Oe605IsNAKUmh8ytTzLxM8Apr+UWfCZbx2FXzOjys/w8u1vvna8n5SJPMRxnnAc/KEOwLg9OOM0TjnE0TAeVKKOj91l2sjeclng/5O/K1vIxwgfc6i+B7+8bzIFedv7W94e9PHtdomT0wkeg87dePhNvCTPas5jaZIXAV9nBJMItvuxOE4np+W5BpbUsb/2EeEkYnrklYnSwLV4MtLqkMylNv3ViOypPRYq44brHuX18tVEOIyMyuyXLBze5KbrSk/VNdIxV5X7sUaALyie/HL4KWNnjkR7PdXwgNNsjFvxQClq/K94xSvO3sihe7q2cnD4CKfOOK+MsdH4unFSjpRcAU9bBBgKpDKDg8rzxEBKcWRgrhiOHT26cYzGNCs7cgBGxv/MWcs+qnqj/kdOT2VUz9runJ+Kh0a4VQ7ACn6VM5J4uWLXutWTT61b+I3DPSuFfzU4C90cjHi2MuRmPJxziQys2k28q3szfpqVT/xHOFdGT1c/7+f1Sibkeuuuj8bQrZEZXbwv7s9oq7LSS7winLRxty9GPNa1X9E6cXN8R314vQqfah5n9E28Ruuk080rsrvigwqfikY5Nr+ftlUFqatzrFt01Ur5mR6aZS+N1kb2Q/lKph87hu7eytiPtSEvJeS5Hdjl3RpJGYmzx4t39J+X/tAeGT2SH9KV9Ovn7fBCHtmfbBmSfcfb2/Sds5BoW7JIdh105VxDtcuboFWHa8qWYtsKNi4PJmUbItfon61T8hnIPnKHnkCZfqscL+VRO7TP+Ak8YCvwZjv8LF+vvoargABv5SR4h03vgQFvj3Om8EGYO94QR13OmBJwgDpb3dy+JjCo/6KBxiQ/4sd//McPwaMP/dAPPTys1llYP/ETP3F4WK0H+fotewlfE75J3koa+Hg82OUBR3wmrhEAhfc45gW9hc+c51l1usnf/AbfeyDPM3l9nWMLCof061LOe1aMB1Dy7WW+PhNv2vJxJB/5+CifgfCRbe7td1lIiSO84/h6AIZ7PmbOFGN7px9mzTpUWbIFkSXXvn3e+Q74GpnJuOp38hpj9gPoM2utsgVyfXNsi9MPmrL7hl0Ro3jOUYElXmeN4JbARXjqmpxlkJRw1iJeCQr5wD2S7fuJq/8rUBm3EJ7Xd3KQte9J5ayfbnJmuDDJGgcBFH9zGgw8okX33XGYGTeJL46nspJgGhhceClTyAVT52Ss9p1lXTAgwERvtiNmFk+Oo6LVjD9yDJ3RvEJT7omHxDdeB3ry9o6MAiOwdF/rY9VoXjVkOzqdF4zo2uEwoms3n5XjNnLCqrJ5DYFL0M8VM08WunEl/646CSsOQGfIJO5V2/4kkUCty6sr6UTM5q0r65DGwVb54+va+6r6cTxSJsxglSdG8zlq03/ntuk04HKMHT6d81zhWOGSdSpadXRhHF25lKkOPBSp7nXraoRXXq/Kr5Sb1e3kXyUfs63KDuj4Y6TbOjpQpuOJER27MSZfdrqi08vdvcow7mjVQUfnblwdrJbr5p02Kn2T91I2dfiM+H40hktlM6wCgRK3R93J9XKZ7Q2oDludFIhh25E+OvxavgpZLASzVEfBHuxi7STAFkbH6r/qUUa23T3ucY9DcEA6V36P6siXUNu6xoctYxy2+5CHPOQQAFFwg1d5+xlI4MtB47ovW5GAi5/lw8uD9J0zdOSjcRYUslJ9Ya+ydV7jwwnO7AufjyrQR3nPePLtN7mdh8CKBwAIdngiAhnW0BGZxDESaotMEI4xcf9KwSUOHVYg6bWvfe0ZL3CeLX5djiX1q6DaUpVj9TF69pO/scvXLod0s7NB9fxcHc+soX3a8SAUc+Rr3t8q57tTCAox936OVCU/oYP74mS45Nw6XTq7w6/79rpKX1VBKt+G5UGa/J398rvTrdDWA3vQ1b8TfBZfEpeA96CzZ4MR3L7WtnHmWsrgkmdIpe2e8t9tJ58TynjQtPItaMMP9WZcjAe/lTG4TFxN+lgOLCH0OBNHQozoMlt8WCiVITMCJ15uTdliNIzAJwdlowg/UUmEjvCXsvDXM44MnxxDMi8L2QM2CLUtuHeG2cxQyvLCh3MpFORAiUgw45xW7c8CYSNDuzKER0blCH+HmYOQ30fG6xZwwe9ChSdYgKfTMv+kw+ZWv86RGDkEIzocCyOHpsKjul/NUzcXadRUeKw4h9Vc8h1jTcYX0XeeTvIEszNWK0Gf7Vcwc6YqOnXlKsMulWbierHy8mIg5+JYXTBrd1RWkE9guzkdOX8j3Kr+V3h1FbJu9z1xnuHY8Uiu6ZkeTx7Mdjp8EueZLOkM1YSOJiM9UfXZte3j8u/d+FbkdkXzSleNxpO4ZT+dnhvpv5yPTl/P+KOiiTss1f2qjVG5jm9n8nfW9winlTU901PdPHPf/1d1q/5GUPHHFvvrUgIOcJ4BklkhnmWQPMRxBLLlZb9T/6UvfenZG97ksyibhUOUleEiu1d2gB5weiaJ6qdjyLma/jY3yoAfARd2dZAxIntbuOGw4hsQ6FHAhD7JnBK+8lXYGcIDcIIy0InAgsah7V/YOJzBeNe73vVsXVAOB9nXKTZrBjnSL3MnOd885dk6/PZtc+x+Acjih3b4YwIcXt8SiPPOuDlTUvN3ww03nM2nH1bttpPTzfnNtxGlLeVBIn47Hzrvej2+s/sG3BlPHl5frUXn+cxwSpw5nN3HBI4j+elzTfmkleOXAQ1wYd3kOq7kpZfxgNPIl+Qa68fLUC4fwDmf+Xy5T+v87eV9i6vkB1lnmk+VJfDCOUfgc1vb9kj7+UBNgP/ocgY6O8/lPCTeTtMsX/lcHlRy/tW4wJ3gNS8DyoPBzyWwhBBiISgSrgCFQAQnKCHkuO6O9Qw6hX9eSs8XjgS8nlTgZBJh5qBlgZSGhF1uKdlihAIplI8Zkwu1kUFYGXF5n7OUJHwRcN2B3ZUBUi3akRHV3a/w7aAa16pRf2yf9OP1WIyiF09WUHJ+iCOLEoUGfVe2KY0M1wwknDdsaTP5sOO9kXMw4uXu+gpt+K/1zNM8GZKeGq5rekrJa2lH/J2OS36vaJP3u3ZHNE9jpepnRIsrAbM55d5I5vv67ug9m4cRbSrezbZnTnR3v8LHZf9Kuaq/Cg9vYyYLZ7rB26uc0KzT8W6lB1brbbne6Rw3kLsxj3iz4yeupdE8w6Xrz/VJGoA5B6N2Kz04kr3uGHkbFX55P3mhm9sV+lbrO9vo+sv77vCsyNict0ped7AqWzue78a3uiVvVUcnT1Q23ZbxXApI+uvDi24cN+wo/Sdw4fRzRze3ZAk4xFigbBYyEXSfAER1mDF19Z0Hgn5Eh8qyDcYDB/6gnW1n6kffsRfxO3i4raCVrinLhuwclePgZw+qqJ7qsFVHOOncUvolE4p6TisFYdhG7PT3oFInTwTg4WUZq/uIbucydx5Y4nwhzktibv2YEA9U0A7zz3+2KJEBlr5MbltjLLl9zYMpzke5hapqJ6/7QcjuY7pPwPjoI4M1ntHlfJ4BCg9O+XlfDmxdBJ/qIG0H5wEP4GbfBHgYmwe6nK/8IGuna/JX2oB8El8PEuU4wCUz0PI+9HK8oKfzBuuN4IrzTm49dLxv/fZEHNVDhvg68ownl2vJh45bFbz0ICcATTLzzrc1Mg7f3klwl3nNxIhzDywpEAGzSfBBOJgfYQMTXew5H6tKfksb4Oyv30QQeSqbgHSwbI92Voz4yiDslHplAK6OsWtnVoc34XX3cyxpgKWh1BmqleFW4Tma70rwzGDmzFR4r7Sn8lLOLEqMEva9k2qN0kMo6LuCedW6SHolPhU/XUqDsDP2t8BWA7jqa8sYs05mKmmuOHQTBatgkweQqycXzif5lH0kp1Zwr5SSQ/XkKPGa4XEloVrzyUtpyHfOX37Pctn2bG4qOZf9zsbk/6v6x8i77nqOZ0aXrt3Ev5OLFd9119Mwzzpdvdl4R2VmdEpdkeNKvda1UenxxK+iTTXuCv+UKb4WOhw6GMnpbl5H5XOcoznt6Jn0HtkXK+Or/ntbifOo36rtvFbZMhWs8EyHo8MoqLQFZm1s5a1LBTg04OFbPAQpz/1tUY57ZjDBU5ktwHYWgjdef6ZzZC9zgDcPED0AQJ8Ex3w7kq6zDYq6HJ+gLCr5WGyxA2eyb7T9TuX8PBXvQ//1QF9tEqDiMGEyWNSO2pft6nYvuHlWS2cHMU4cZR8j9lHaS/oNDlzDTiYbwp3YxCn9B/1PXN2n8TIeZHB+Yp4ywO7lKvlcralcr86v/pY7D0xkoMT5z7e5ZWAggzz8drp7kIcgYxXU6uzsTn5lsEnfqwCPy3LnT2/T1zcxgwxmZPnkAdc1mbnIvQon54uULUmTzLpjLB6883PDdO3Wbw/gUZ8zqf2MJqdryh36dpz8jC0HP1g+A6EeTPO58nkk4Knf/tIuz8TkJVUE2c41sJQNVspopLgrBh7BqvGzApWhCcHYB8kbGbifkchuXKPrVTk3iFIggFfW7Qyglf4qOqwYi6O2O6NpZFBW9ar2OkOnM+5GY14Z7ww6Iet7mj2qqwXomTHUZ+vVMYe2rxrd5wmrxnRVNq9V10eGd3WfMjM65H1XMAS+PUIv8CdFuTe5Um45ng6vrXPmsoF+8mlEx9NXE4zkA787g7Urt+oAjeRUlqtwWCnr12aGSRpCW2FUrzKwVvVmJd8T/w6Xjh75veLnkUHrZb3ciP4dTfx33q/G37Xb0WPU7orsmvFCxV8VPvl9pCuqsjMcvM9V2T2rt6K/OxvE8c711UHXVuI3G/8MHK+uf33PJ9KXWo7PePpK6pFqXtI+cnxzm5bXw372DBTuVVkpOE5+0C7tVJkQAhwsAfU4ByjHhDPH9iQB5yVx7hKHbet8U2VPcz6Tn2mijGrZlBykC+5kxwvoQ+XIkOCspbvf/e4HXNSv3n6na5xHlDSudAp09POduM+DVfdnwIdjITwYQkBJoCCXgl2OR7cuM0Dncm603lJmwAsAuHVBRR4eV4GLxNm3WHGf4B/45rY5x0V09fOnwJ3MFugMX/k68O2V9OO+iSeB+Nidjp4VA47QnnHnWUs+X5455WuPOfGAUWbKeB2fw8w+4kMwyufAy1d6p7NxRr/Vr3g2s8Ach7Qp3vr22EFmrXmQ0enmdE3bn7n1sXv2X+JU8bDPj2csgVeuI5eTTkuVrRJuLiqwtGJkzJT7sXAxii8VkCZdTw0kgDOCyD1lMLDnd2R4bDHgfdL0EbPqjCcOeuZtASiVfMoyGlPVT4dHfp+NpVqcI6N0ZDRWzO7XV+d5S/mqzMj4B7dZfwh3nyMpbKVZ64mRni6hEAR6moQSXeGplXFVym1rvVUeXp3zVLrZTuLRGe+dUpjxuZclYKw1RRDZnxyRZel7o0eQRk+lpBy36qnrSj/ZTofH6vUrCal0/Rrfu7nO8pXMuFi8VtZUZbhW36t5HdVNQz5xWFnfFS07/Kp63Rirsp0h35XLeyNjbjSmhC1zX8mXzgCr+sggwFZ8O/6oeD7xzPtpQ3QysZKRnb1Q9VPhuiLTs73ORpzN3UzXVH2P+Gs21q7PqtwMZnYJBjrfK5xXaLqK58hWvFgb5DyArVusNUHltKHPBdVWG8q4I5T6ObfG0I/ue1+5Fcy/qxxvOfO3sXp79EmAgOCRfA6NVbYh59PqPCQFlOR35JlH4CnbUQdUK0CkumxXEbCtDBzYcgfeHIqtjCi1q37VBtv/cWoZt0MGAngY7weOc5A2jjGZSZw3Cn0JbKiuzkTSmPLMFqdzbtdK3u/szMo3zS1mzj++/c8DN45H+mF+reI/2gXc9vQ2HF8PclIWXoL+bLfUx7fWed++g8ITF3gplc+r13O6eiac083XlG9FZG1Wa7LKPkpa5fVZ9lG3lS95Jefd/2c2m8+Xb4UDH9Gew88JELnMcP671oJbvs0t5a7++4udKM+8EYxi7eC7sB3W28o58T6Sj/yQcL5nUNHHVb057twCS0640e+rGSCgny1E9B0nVNv8iOavjK0Tbl1ZfSRwldoqReGvEJWQVmBCQl9MPDJSVq53i3cEnRGWbXaGcDfuGd4zqAzfmUG10uZsHCuGogMHETJ/CAUCGFvodilgq4Mwq5d1U4iPDPbu90jGrDgcgNY3e/gx6BC+EtC8IZH9/W6Qbl13jgdCnqdzGH08jUrjMZ1G/1+VGzkXVwusOpAVVLSoHIZRP2lorOCxVU7O+HjLvao9N8pWcav4I9vuvlewRX9UzlziNgp/wzkAAQAASURBVMN1hlelf1bxnY0j9YFgtPW1k1sz3CuDuOJnby/vV/iMxlVB11c1pq39ZPlsP+e+GtcMRuVXdHblMOX9GV5ZpnJ4K5uso0FFu45GVXtVfzO4krrDt+m47swn5jykcxrx3Z2lSoZWfOjtugPpkHNN1rnsdM5VwvnmN/Y82dFql0AMh+Lqvux82R7yN3AuM0sKR5A3J8tOUYCIc4h0RqTKcOYTgSV2X3jATnjrgSfBH33nTCKnFeNOueeBAt5upiMGfPsWQTTmVPYP/UMP3t5GJgjZXmwv9K1GPv8jPyT1pwc8fC4zmOjZI/zu+uR6lUGePJNb0cjycFo63dnp4IEcth3BL54pxxi574ECxuPZXZ7hwppze8r5LbOaUt95FhPXPUhTzU01b6z1XOfeXmcfZBAr36ZWyd8MBjo+Lm/AiXUCPwv8jdK+W8UDcT63N709EJT45Vz5WDlvjZcN6Dv8o2Cs8yvBpmrszIdnY3LdMwQ9zuFvg6zmXOXOPWPpDyuk4GGylXoqIceTA/ZcV29KEFCX79m+Q6X8XWlKIEtBcN4TEVGYSUL/+uuvP3vy4HicBz1GMDL2u/opSGZG46yPGVTOxci48nqjsYyMuer7CNh3y8Fv1OkM7hzHqO8K10tlHK6OdwYdP1RjqvjFr3ftVw4YhpCCtTJoUA4cwpnrvXJ8RnzGd68n4av1rVccy/jj7SwyDnnzjGeuef2kVUWTjk8TlysJievMofTfXt6vdbK267+SE95OZ4iM2t66DkY8mzSq5t2vr85rjtN/uwG4gueI57J+9b0r6+1WMnBGi6qtDp9ufDN54n2PdEfydrWmZ7hW10cGejXGUVtV+Yr2W9uu5jHx7nhjxQ5YGUvXxlY7o8N/pU7Kuq7fFXxWZT5lLsa+ulhb7GKhyupNm8nnIzNLuOZtpKNY2RnpOKkMDiCOV6VDpLtvvPHGw8t/pOPJNOI+/WJnEACgfX1Xxo78Dx40dbzsY+boBfWHvyA/Qf95wxt0yzM8fRcEWUTCXf4Ob8HzfnO7TOLFm7PVv/wVfYQHmUtkJoGLP1TzI0hw2gkwERSrtqVhyznPcM3nPPmBtrrM02zL590DMbSdW9Aqe8T7IfADT3lAiXIe9PD6nk3lbdKuz1sVoBFd4WkFJQhAMg6CDl6HcXnWDf1SxwNJSQMCF57J5FlrPp4MSHmfPmeeWZS08zOGcm59PL6WKrnqWT1JC8ZB+2Tv+Fr3rZo3xW4j1jiH1XPfeZUAldaU4gNaG4oNKMtR8yh5wTrKDCvnV3+7JuUIFnrfjM9pTVvIqoQM1l6ywFLlFLhQn5UVrCJ6LKThw38EXQZvcpEl/pVxtgUXfUiNFSBgBTCeGEsM5ec+bTUAktad07BavpqvkcH3/7H3Zr3WPddZ7+smykEgBdtx+7edOAmOAxE9EQghBEJCggsEl3wGPgufhRvEHQik3ASUEEIa24kdN/+4TYBwkE465+jZen+vnjw8o6rm2mvv/ZpzhrS01pqzmlGjRo1ujqr5ngPjypVHo3XDZUeHFHYnBug0vqY0rkDyU8NjokHD5cTQ9T7usbYmAzsNWcp6vcRlNxdNUaXBnvXbPYErLILJnEnQ1rePK3Fuzvgkv1RWmVF6RTCHaHI2gta1lMS3v/3tN2+icRpPODVa7K7n09fnhmaU7uRnroUsP8mEExym/q46Vc5v7Qlz9p+4NHk24T4ZTCv5OOGaBtY0/hXNVjr7RN9MY971l/i1Ma1gWjMN15Qn2cdqvhvsZP9OR/r/Fa9Mc9n6TGiyeVqrK3wbnU7sgbbuJ1yzzhWcduW93gomfljRe8XLq/YF09a57OMU/1vLPgWkw4++5R5bQtKWwolyOeBP4xvN3LbgG6eLIIdnFQPUBw+2xEiX6+GRAjv65NvM2ELCwy1dU/BEgSV/mExAxYNCHhhz3HFSfezuqHr2luOPDaRv2SX6fOQjH3kIkk27M+iz6SLOcNL4OQSdDBpAZURftv6ROUXGB844GRoqowwu0WPi9QwE4W9OPif85Fkhvs3JadZsKF+LU7bSJAtS55IFQ5CPrW1kbTEmH6cAmvp5VtiyTgfezKdrHN6uaxzaTuDPx5Jjc97zdUX/kx0BtG1lTpuki89bC+QJPKjDGphsxRNfIa/ntjhoqv+aI51LJhqylZC+WOPUFW/D1+8Jm4LAqwewfO4or7FrbZJViEzjLY6+zpPvMphH+wS+G/2Tlk32ZibfkweWJoNwZ3hOZZ4SVgZiCuE0cLz8Sonvxki7CE5PZWPy/YT5KzRqxuEKr/zsDOBJwUzG52QYNxxXxlc6EFcMymyn9dEE0KqdXV+nBuSOH0/W0ClOJ+Wn9lfOTP5e9dvG2cpOfLJaW8158O80SCeDJfciU689KWlKDCUsA4kneZTlyQEHd/J2mMyO3I09DZsmJxjLS8IJ/03ycVduxWO7e2kYNRwmWe9lwGNVLnkUyCd+rUyukcbj7cnuNJaGV1uHrb2JzyZY0W3KmGplcxxT20m3le7Lttscrvqb8FrJ7MZ7Df/G540PvL9J/+bvxH/Cp9lEra2m51OOTTbWRNPk9dU4Vvq/tZ3tt/ut/dW6urV+K+vtJv1OxnkKV22DpwbG6IGgDChhE3udxuftddptuxNOOEENMmb0kQPJQdzI2LaNRvr7O9/5zkNdZSUTFCHohDOMM0hQR+BvbQMfXiJEAMqdeP/4lhb6IVAhe4MABTgzTl2jXXDSGa9kbftDNx+3H9bMHEBP2uGtV3Kedd0PG9ZvMprUlsauh+aCd9555+HeL/7iLz7QTqCHb6rD7hFfG84jfPtYc81lhsWJzcj43DH361mvPagEV+oTDGSbJH6fwDNMoB3fSX9vE35N2Sk6E1AiiEWGfGbJ+7fzN4EdH3fTkbmlruk6p7Vv0wNvz/LJzCTne89SzHbbddr0/zlPziMuZ/kmoCOafvKTn3xzRA5Zdaw/XVNGmL9l8j2vM5uSZ5E5nt3n64n22UZK0Fl9e8ZZ6lYfg8+ff0+2b/ufCULgl9mQz7YV7p5K8N7QDMGVITUZDyvjMMvkdU2W0kh1aB9tw1Ccw6PD/FRmZVi1sZ2AL0J/M4Xqk9Xh6bmuxDPFb2WYXsHx6nW/1wzuE9g5Aa2fZsjcaqRNRvSEW463wQqnFQ/t2jyFUwO68cyE85W+UzlQ3w3DVo83tcjI8cMPJdD1yQPXkyapRAEUP+nrlOXjT9oyLTjbn/pLwEiVAfc2wI5vmwyZjMFdP6uyTT48du223ytZ1nRKw7vRrBmvKa+yrUmOpCybYLUur8gFH/u0JWHCv42z4XHaZltLbXy3jrkZbqv2J3vkCh283KkMznWQOmgHO/l9RXfn9WlOmp3R1vPOntjpwt291TysaDm13fCaaHqrzHIc3jZoDo7LCX9DFk4P9fK8FZc106Hc+lZwQ0EMgR+QK+AMIX91Pfra517O3pe//OWHjJyPf/zjD2emysFUfX0UZBKQNSBQWX38hSF+GLb+q12A8SoIpDL6L9wIUqgPMoNweBkP+Mq+13ihK1ldwuPTn/70w39ttfGzJgVkWKSOIXAkHPwtczjE0Fq/ReNPfOITb7K1tYVQ+Hz2s5999ff//t9/mJ9/8S/+xauf/dmffZO1JVxli/lb45wvoAn/nXfAPbcaeV3XFR449PLJi86rbdtZ/qddD07gb+XDTf3WeKGtB+mclzX/Htggg0ZAMImyBBfwKT3AkDRJu4RPBpgS2uHefHMtM8lyneaWMcp4HQ+usd59DCv72B+w7uSD94ltroDnF77whYczkRVAZv6QSZy7RvZZ4vG91+vRg8VsFfV5yUPBOXSf7ap+flPbqtv4r9kWTqu0xZyWzU7zjNC7vhVup5TuofgSdsbCVUghOfW5MgzSMFq1430yWWIoPe0Q80hh4ATyRgcpJxRP7jtdGUfTNcCVhJhb+6y1ZQclJSb2oJbK+QGArgzvNR8TDVfCYmXEphPRFtSKTjtjceWkTPXbGCbjeqqzcqpO+74Cj13Lk8BvfTjtdw7LhGtrdzLSvU/xt9agUro5FwGel1EjxcIbTFrb3qZA64TX/HI4JkpKvzE6p6dAE+3amFO+sK5l4OrzNkCbv1zLJzK51d3109rc8VPDa+UQruSBz2eTw9nPhGOjl5c9wa21vaLFVG6lF1d6c1e3jcXbXH3nuL3PJje97ay7w9XLNUPyhF4rmPCb9FqjGd8rnZlt7eZwNa58KjuNZacPGp5N757Ix1W5aZ5OaLrCv61ptz1OZNv0f1r/01hPafTSkMEad2adL32LUGYv5JpNx9PnmYwBMmNUVg66v6lZdi4ZCASX0hkHd+lyHsjKlv7whz/80IbOdCSbCHuCw3hxEtlK4zYCWQ6MmYwm1SPTh0wnsiUEHO5M4IgteGQycfyGxkR/wkk4Qy/hzPEbzAVjBhi/ypANBY7qh8wrleNhue7JMf/MZz7zYGcpiCX667xJOes//dM//bAlT+fKyvcQkO1NEIW5zSyZ5BPwSh7ILVrOR/4/ZbqvO/+dbw7z686PvChGdOHsIQJMHITMGZwc4s19xgIt9FttiXb+Rj0yX+BlstBoW9c9GAFtkn7tIefKJm96o+kIvnP7XcqrDGJ60MvXgj+QTRybLPA59nIesJrGJrrJD9BbGTUPBKBZj8gTP0vqD+xti/BAow8BYA8QkpXEHPo2RNp33mU8Tisfe2bZOX18LTV9kQ+6fe7uFlhqhsnOIL4XXHE8TtuYDDg3tIDJQF8tuLyeBp+YRoJVgtT3NabQzP5WBtZkRKUA0EeKRkJewSWeMvAmMwSgBBgHBErR8rY6z1xaGaFX5mqaX79+aoi264/B70qbq/Kn66M5PRNOV+utoAmgW+vfuk5zDd06psnITgNBSlx8LmNQ/9mSqqd5BJo89bWtQ8dT31ojChyrLSkjyqodrSGeDDaF0Pgy8W8p2bQhvJViLoPtbYLVPF7RIVd44XSNTLhNc73CpfFZXk9d0OTECf+u8Gg6aDfevNdkwWrMjCe3B6xk9CTvvdxEl1bGy036fjXWaZw+VymjVrRs5dr4Jx5o+DU5O/WVY82+T2yIhvc0p9O1Cf9Vncfywk4HTeUn/uT/1G46Tt6uy/hTnTbNc9qaKxssMwYSp5cG56XMnvAyAPIlrzuoTBu3/nPmD066v4Jd+lr3sAVkn2emh/dPX7ILOINFtrOCNQQJCLiovuxo2QDY2R5AI+CgerLHPUuHbBd9cw6r+pLvQEaPvzWM4JRsd9Wnf8bKNinK6awllVFmhuyT3dtrwUntk9WdgTZwVR0FkhRUUh9f+cpXXv3yL//ym+ymv/bX/tpDn3oQpswPAizqX+WVpUMGuZ8/5fOfwca2/nzuUpZ7oIL/rsMIZvi851vRPCCaPAJvkdVCsEnjo23R0oMRtMGb9vzwb4KEnPNFAFP84AElAnu05dk+vqVpkiW51jyQ5uNLOcX/FkjiutfxjDFdJ0iTgSDa8P8ER/wtbfmGyMy+cfmQvJC8w5ySxSjgSAvetIifoLp+iL7AcZqyK9kmyn38AzIVBfAMGUtNf+e4WpA0bQqykDKQyDww17719u5b4VIZnSimyXA6gZ3hdktbq99X2znpwyc+09N8ok6cnckIvgX8laBSprx+XcJO/5XiqhRWtgdJyWoBvPvuuw+ZVakYrxp1p4bjymha9dMMwkmQXOWByWm6Yiyvxncrv0+4nPDWNKZsvzkjrc8ruO5wuhVWeLpRglGAwcYZSKS85j54n7d0XmlHxpTWCa8ZJmWWA/4mOjRozmCrL/z0xFTrl2Dx2wLNaFnxQFtbV9bFVL+10co9xhmcrq/WZPZ92m5re1d3ovGq7ClM48y5bddO+r56bWq36ZsJJr7d0abJ41Z3wqfxobc18eSOz9o4TmXtY2T01X5W62C1Vry+l1mt5YlvG90bPq2dlVPkjteE+2psWWayvx4jQ58DVvISfeq61e83XZjz7tvfOCBaziBON84T56MQwFE53hSd+jozOvRh67wynDPzmQ/nLwlwNv1AZrWn/qW/6Uf/yZLgmArogNMpW4Ptc9AD+0UPzYSX7HgPNGhLmjIuCE7ot7bF6bcOFycQRYAis3sEuubZ3Jzpk2cscU6MspIUVFIAi3Nmf/3Xf/1N4Ew+h9qTr6F2NGbhpfY1HpX3DDJ3iDMDaQpicM+/fV4FnnXkmXI469Tzc2gykEkZAh6MgfnX2KAVdT3jTLxCRgtzBk3Z+siY4VEegBK8JOOODBp/nXxuLcs142uM3xko4n/S3ddEyxrLNZoPbD3RYlrnHvB1nH3O2nykjAEfD/pQ3nF13PQbHoHm+NKUfV+c9ebJGKwLpyVvmqOu5I/a8wO84Y0m//XfD+H37C6fF18bXtbp5fxMNhxtr7ZG3hxYukVJ3WKY0n5ev5fzmQqe36dGdVPaXgcGdKZti283jrY/teE91c/220LzbzGyBL6YXBkPevLCPeEvp5U95Nn3Do9m6DV6TobSqv4peP3WRiqaneG+4+1dH4nX7lrreyq3chp25XfjmeZmByuje4XnKb2nPlc8IKUrnud8Ba1ZgkH+FHLVdvIlyo4ncK5AU4mvcE2YaEx7GoOMTRTc2wDTPK/m5Yosbkaj15/am2BaB1flQJO3+b8ZTFf68PsTpGxu/e1kyGPWX8PxRPeljpv0V+J3Wmdau4lfG/tUdjfuBtN8TDpy1ecJH67WzKTHGw9NPNHmYsJtpTdWuvNkPTddtbJZr9pTO1xpa3XvBPeJF1dldvxxars/B7Q5TYe0PU1vZ4DgPCd/EkxiS5icQd6yxKvCwQVnH4dKdWUD+BaxXCvuMJO1w1YngkH+AJkgj4DggTuoapsHWuh1gl1+3qN0vWx01VOGtDt+BG5kg5D5QpCBYIU+qi98eJkIRwIQrJD9QvAIn4b2/MBvAmAEy8g00sNp2lS2krYUKfgmvNQfWd0cCSJ8OKiYoBcZZMrIgR+gHfOmzxT4cF7wQESzSXxb76RLnB+9fOtfZcgo0vV8YMlcwPfp84mumksCF/TFNjrm0wOBohOHn3tgofGs02H1xkUP8NJWW7stSynp3PzaaQdMy2JMm87XZJMtDj4n2be34xloKYvE25zJ6nQmCzDbFXhAj/XjgUR9e/aZQP/ZXsoh7BxbQ4BpyuTz3U9N7ufv1NXc87c8ZtbeXTOWsuN7wlVD9/TeBJMxwfhcqbnQntoBSLfV0wK1IQeVNMXMWkr8c0zN2JsWWjPgJwOQQ+X0dAKlgZMtfPUUBKUjYC9pey2n49AgBcv0e2eE3YPnVvyRBlurexWHkzo7odlwPMXlyno4xTdx8d/THE+4TPzZ+rpap5VJhSje5wmd1iuHRsqg0se3rmXdNg7/v+LxaQ6bQzY5R7muZHzu1tJzQtJqcrQaHXZ8mMbILTopaXVL/YR0PijX1rgbpX7dy7V+VrRpNN/V2fW5m4cJ/5P6WcYN2VNIXJthu5JD01rZ6Qpvf6qzKzfpbS+34s/JOJzGs5ufSZ5PNkZrdzUf3sepLJjsoEaDE5jGsWuj0anZcE6rphdXOK3KtblrZ6Ws7MCpnZcCl1OpJzxLRMBTft965M5O8hnn0+ghKdvf2Lrl220cONcE54/DenH4khcBsp10DzvZ2yRghWNLQIs2aZfsJLKb1beyi/RQV2XUNltiyDTSweGcCSUAXzmi7C7I+Vd57T5Q2zpIW3gRzCFIRJaQ2vXX2/OyE3wGXVPwR/YTdojwIughHL797W+/ybzgATZBFvBVxpLrRQE7JtSW6OFznFuofN5TXjQZ4jzn5155/207VguCJO+mTCLzi2vQzbeotXmingeA/Nxbz2CBFswjkNs5W8adrzF+ezDEaZD0AVJP+Dy4Pvf2dv6Ot+11T2wOp6XLksxEav1Qh/ER3OV8NtYvB21z+La/IfH99jIA1rxnKkITyhFsZHcDa09rTWU54F1tcb6az1XO5aQPmGfGn5mzXscDVFf8ipszlq44AQ3hK/1MTkMzfB4LLByUCttYeGqRBm9T4qqjfctSaEQiVU7CvE3QRJfVuLl/CkkrjUfBI4D93Vok+uitdWI+ndei8WhxqDxnLCXeKVh9DN5/4r0a+0o5nM53Cq6V0eULMQXP5CCs6JxjvQKtHx/LPXn+Sjs+tmZc5+9G/5M5n/qY1oS3AaTRmONE0fA6VvG273vXf4yfHU1aP6lod/UafSYnKscDXXjqhbJ6CZhkW5u7ic9P+ljVS76b2ljNT1vDpzosy+ZcedsnuE74tD5PoLW1osWunQmXtn6zv9U8Yig1B3rCYWVo3lrP8c26Kxo0w/WkzVVbOUenc3AF79ant9f4ZGeoN3wavln2lC5e/3Rd79qeeBiDvI3RrzV7YOrzHjbD6tq97IWnAvSxO9F5P+nu9hCBG+lyf3MZ56Bw3APX/awZlyl+EK9nOFDGcXN8PRPB3y7rwSMCNP6qeHDAMdU9ZfXgOBLYIQuIM3voR/Y5mVgC30rk3wD4q00FfOTEKqjDW/J4kIZPoPI4w9DTs7943brqKDuJTC3RWtvadI2gk/wiHeSt7XCeeaT2ODeK/umXefD5YlzJAz4nnp3kPgv/PVDpZZy3/Lf31bYY0beXzW1uyeu+nc8/1PGAFLTy9luWUwZckyc8I2nFH80G9a2AWdf7zDZ826DfZ5wqNx2e3vrLdqbyK7+OOUhc+U+WmB+ozjZV5sWDhXnQ//tfB4rgbc+MzEAbc4u80NrRWiBAxUNjtqUKCEhmIKn5W5Necl5On4WxrPyRCR7lfTRFdaI4pzaaEZNt51OMq4bSChBkmkRF8snW4YmDJprXAE59qQ0imxzWpgATT0tcSEyGU16fjOEUqqcGJ7RDiMuB1oLRdSkZGPxrX/vag2LQAd8av5SQ6ngU8wo05rzKKwknRvmpQZWOzuRoNJwar96Kx9RPGt33XLOn7eZ406ifnLWT681BSN5f0dCFIcabK2IO1nPe5Zt7pGgjY3ZOWTqsVxyJdn9Xt61xFBNyytNpXwJyzqY142XdWcsx7xyuk3V6gmu7N+Hi/6f1Myn1VPyrvtNoXhkMu7HwncZUM/YauJG4k8UT37f+pvLJE9PYGw67e5NuzblMQ2yFR1vHk1GX459wXfFH/p/o1+yrE9294v9JZk28kfWne87vK7p4+Z2Mnsaz0yfeRvJCy2Q4sWWm31Mm+w6aPZhjbr/fFnCcWkBnonfjt8xsQud75gxn15AFQzDKMwmQkehR3wY3BR+YP9nKCqKormxlAlkEg7ArGId8BOxtDwThQKLbZZ9z7hOgnQW8XEffGptnVSX4evFxqB3hqSwj9QM99B/HmiwM5kX48Z+HczjiGr8CTQTD9M0RG2pT39oNQXCN7UPCX9njtKPrZH7pP7ZdHl7skAEl5x/3HeGRdp9+8qBif8Dh9bNP7juNfSsh+Pu8tCwi5+kce27TyoBM9u+/obf6ItPG15DTjnLgMOlBX4fQLm27XDP8TznM+J3+TtPEZyeLM6DVdD+/XRZw3jC8SD8kYLBOPXOI9fm91/LDMxQ9UOj8QNCIg+/Z2YT8wpcBd38bJGMhGwo6Of2cTvk2uQngN8rlmxbvFlg6NeYm42k1gOm/TzZReVLQeJ13M5xOIftSP2IgBZUkqOmb7CVNph/m1xykVBxsi5NARYAnU1A2F9dkWK2MpxX4ws9rwln01Z5oARlaWkB6DagYPFMsW/+r/5Ohuxtj3vPvFaRAazAp4MS3CcQ0gidH6YpBd8Vh2uF0pf0rsDJcTuomuEJ1h2Jynhqtuc/+fq05DuJEoGv9KVCar151HpkcmhzjyvnJ8qv5SIV7srZz/VBXa5TDQzXul4JmgHPdv5N+JzxL26fOYGtrJ1entpssaOtv1WYzolZ9tfGcOotNDjUcp34bjRKfFf9ONMnrE81O1o4b4XlvGuMVWOmqZve0MazabfhNbbV2V3PS2uP/iXF5Aqt+G37tnuM0jXeSjbeMxcuvtgFMdRPuQceVHPH7Pu7MmDoJ6t1D/z8V4IQh4ye7oNHEAwP+ITDEuUHY52znwknDCWQrCs5ZHl+RNggfAiDoXs658ewRztPxjGLOERI+OPm5ztnWpswf3kaFDcMZRZx/ipPr89zORsm3qKkd1VdwR/jrmuwlD4ixBc/HD830X77Cd7/73Td0cIeYwJna11g5C1L3hLPslm9961tvAnEC/D22L/q8gre/bcv5yAMv/E9HG7ycDsl/mS3bAjpNBnmQ0Odi5zvynfoRPqA9rmWGlMuFydaGv7MPD2R6u7n9zNeAy6DcXgUfOM08sJE86QG6JqumTKymC6FRtpn0a/RGDhFcYscRQR/nRR7ketDwj+08VdrkIG6yAHlDI7wmvkc25Nv78L0JxPo4fD747fhnllTaTM02hM76TXAXfE71x3FgaTLST+FWpcbkKjDDYWcIYIi+26oy9Z0LS20q2s7ZSBDS0wczfbYZbWI8CWUpAfBVffZmTocBU3/Cc2dgnxg4TgfhotRUKSwWEJlVLCR95IxrG5wvqGzv1Lia+CiFg49tV25Fl6y3w6kZL84nK2cm22tGyGPBx3Ri5J6M/er9Ww3piVdS+bb5aEI02xbvKjtQ/MyTQNasP7VMQ8Tx2hnmp2Pc1buVFxo9nI7KKtR6PX2y8BSQ62WCNIh2bXm9Fazur4JSp+2mLOD3LbjveKq1ceo8tnrNgb1VN7c1tJJ5qzV+Ik8T55WsS8NxZ794Wb/n42j0W7XZcDvVb422DW6VVyc63P83R8d/N7yz3hX8Wt2UE8lrjR+8n4ZjG0eTSxMtpv6a3fAYOLW5cj4es76fA3wbGDhOgRx0mjvAfj3rUl/gzpy/rt3L8NCYnQo4i74lzF/A4fhhfxBocQdR9QnQ+ENlPrJJCC7J+cxtM8JLOv2jH/3ow0NvlSOIpEAND9KEt/77mDxAAv6+vcWdSd9mx/ip43T1g7vl01CXoJYCROzWQHZ++ctffuNjKKuLOeOsJn9oL5yYA7bHabyeTQO921uyMnjgc+VvYfN1yjV8vaYPmkzIIBbX6d99SKc1uHhZv0ddAjHMoweNnIccvwwK5djgi9RtU1ZKo6fjm+P2LCjPQpyCYr4ePGOxBe2Sr+nPcUmbGN89dzmlTmMcfItXCX569qIHb33uvb33Gv6ejUhMgHUGz/ub/8AnkzjIcvJxZJYbmVWMh6wqn7eEtBczQM+ab1l8EzzZQRwrA3MFudAkYAjIcCo+rwSXEFYApxmZicvqOt9kO+TJ7ixoFMcKbxSBDv1VMEwf3tAgcKGe9a/gPpWZjK9sB9oi2HkDBGPXNSkrZ2Z/XWoaWjsjcDXGhF25NpapbjOG8/7U3+561r1qPE6OxmrOW5/Jx9MY0tBdjf2k76vQ5mZySFb1naf5aG1KHuhJGAc+ciaAyvo5Bw2f1v+JQd7ae4wxPzkNqVzTYAJ4qvK2wAn9XEGu6p+s1d162uGT7bT1kjIFJX4iX1bKfTJ4VrhOOLUx5Bh3dLiie1Ln3NLmap6aHZG/d7ov+2/0a2M50WNtTU4yJXHLeZ9k80pm5zy0/5NunGRNo980/pMx7+CqLnYc2xq7lc9X42xtn+jd076zvVt1blsnmeG0wv+5IJ3OtoZ83Tc5Tx0P6vh9xk1WEP8JNBHs8bdr8ZBVvgeZR7wN2fv1bH98Ev1XVpFvfePbx9xeE54HOeODKKNHPoWCS9CDM44UeFGwRh8O7M6H7bRHZtVE6/y0V8HjKEMn3VO/BBTYTUImGEkAqi96Cl8FyBi3rvMCFc8uIcOLN1H7/QyCZMDMHXCfL+Y6s3CYR9cjHpSDRhlEyeBI8q3zYPKzP+CEb/3cp+TtBNrxTB6XXbne6cNpxhxzP19Zn2st16vTgt/ej2eKJT6+rqEN8+h84GVTdvnc+DxDFw/sUSbrZICKteVvZGP7mnhe9/1tfs4v4PyemOPc7eRb4hw/5i1pwHXWhdPFA60efCQAzLZfp89kk3qWHu37YeOnuuLmwFIzOE6M4CugwXFInDMhCoSD7nbbsxqsjHtw9X2iML1PysrwUxBGTxmIerrQ8v5PjYZVuZ0x2/qEQT190QWUAk4wpO7xlGeF0y0G0A7/xDn7OTGgWx1v62QuXFh4nZWDMOGTxlIb745Wp+Wnsqf1VgZ7o0nDb7p3K78koAhktCArkBH6SLgSGPX09MQPnFZ4NmW6GmPDtRnKO5jWdSrUaQwvAZPMz+srvsl6u7azbjPyTvDcyRPvy8s3vsj2nVemMie4Nv7z6ytIxyLHc6t8aAG2K3I11+Jq/tIgm9rNsTWZ34zdvJ7teJlpjCs+X9074YeUxTnG1m7Df1fmVKbfKnNy7id7stHvsXLuqhxufU+yuY1p6vMeY2k8c9LuS+oK1rAgX/GdGSo729Dp7XQg64g+eKqfD2Hom6M2CC4pYIOD5m8zcwdO/fFQWs5inucIPtge1AE/wJ1bPwBcfSoTSIElHX6tzGzeNq22FKj50R/90Yc+v/nNb7559bzTid/Y+o4TeLgMd/o7r7sjLhCdhAtzie3F+D1gInwVdOOsVrbLeV/6z1lMstk4zDvxZz79rWmUm7b9TNkzntnj4HUcB+8/2/Mgj/N0BsV8PHw8QJY2quPE2LzflElOU6cH9xM8iOjjpQ9vB7x8zE2/+k6fyQ5qY4IG2abjATj/tPL89gyw1qe35wkt4kHxNzt4eHDt/rIHPb83nM3Kw21kQ2YbAdAsz5RqMsNlhdZL0q+dqYRMSUjbjx1ijMHPdrprYGll4DVoi/TEWPLfEIsB+lsVBETg76GUYQoXVPpwKJ5HHBPnZCSV135j/cbhneqvaHNlXCdlnZE9pQ8m1zUiolJmnp66MqR2kAbjSRsrI6k5Iie43WrATQLZaXJqpO7WwATNSH1uWBnIDa/m+DTHYaKrz/NOTkjg+9kF4mnxr554aSunAr0ESnPeVutvciJW85FtNgXAesunM/mkbaIpvzO1vdHzuaEpecd3Jwuma6n8gNXcreRqGmU7/XbS1mn9K2PJeyv6ruTmqt9Wd6ezc07SAN+Nx9uZxjrJDP43mjbDLvFpMmWi005OtHbad5NnK/lyQqcck/fT6LeTpTvZ0XA96eMKDU/1aet3t35O29vhd3p/pdtO25t4ZIfXhMdpe88BviZSL7f5TSdVv90PSHnMw13qCvKJPE6b98GDbXeM3ebEUaQ9Hr4SNGF7H8EPynlmFddUDjuAbAkeiIGTspZ+4zd+4yG4pLe4qR/5FoxNB2Lrm4Oz6asFXjxI4Ge3+Bpyp9lp44Ei2VeMk3H5WVYCHwNHgVCGOfCgi8ajQBnbhXCEfe5W8tX5ynkp7SQ/g6aV59O2D/JxPzHljgcfnOfI4nLezYyjxMd5l2sZzMrAGGMGF/rOTKS0yZK+lMEPbAeXOz8lb8MDueb9ugf8HL8ck/Nf0iHtSqevl/NssDz0ml1LCtyqPQ8kQ6fcCufnKjnO77MMIl9TTlu22sHr4A+PUJ8P7frahRbQE1wEJN4QTM+to/5mOZ9Lf5EB+PBQ/u6BpatG56ruBFObEBwh6EJmZ0ifgiZWkUkBCoUJ4s0GLiSbkegMxGF2vBFB31PEb2cc3wpTG+CnoJkHvvIwMdL/RBdPk2z4Nzrwe2cw+/VG1+xrBxMNd0blKS6TkZb/m8JZ9d/6SYdoau9Wvr835PrI60DSKA3ddOwmQDCiNDFexN8yspRC7sphorEbVw1HL5t1fYyAGwIYuFprehqHkCd1nSeMuwyMRmvB9HTrJWBFkxUP+P/H9JttTtD6vKLTmjGb67Xx1D2gGdM7uZr4rdr0azs8HgOJe7MxspyPua3L1RjavSaj8in91NZqXK1+k4utnUaXRqOd3NrVX+nmCYdJxqSunNaX02GiT4PJ5trZC1luwq39n/B4LOxo6X1NenD3n2vezorXXgrSTszAUeLnTnjqWC8jOwDHi6wl2bjKmMktHzxQpV3OWmIrDPilc+94s7WFA6h5yMWbnajv/boT5+1yzIdf483MX/jCFx6ykxRIUrBJdWXncCA2DqE7sinTWsaS94UD29Yp7foDZ2/bHV9oKfBsEfonGMcBxQToBLxy3W2iZpc7jhmoSLybjMxMFv47XzFG/aZsBoKmQE++gc7fPJhz0WyHtkZ8e6GPN9d5zo+vrczEmujqu1qcbnnWsJ+rBE4JzvsJ9OVZe0Bm6EA/9x2Sdnw329j5xenCg1/hwBE2BEJ9Tj3oSeA2t40Kco4cF4LZ+aIAD14RUALgP8+uzD48eORBNAGHcbN11dv1/lwmeXD3VPfdtBWuMe+9lFMqBxEgUwe550bmZMhdARFOwpyJ49A94aDrme0APlN/HqDJNELwbLS7h+HSIPviLVI6S4l7OOUwnn5LaWkP9MRYE747vphot2vvivG3Kz85CpOxujPmnCcnnFdG/gq/0zFfKd9477FreVqHq3lNSAHt1xsg/GWUkF3ob4HLtTc5d01Jtf5PnBj/zdsh9eGNk7qu/8JXBpSyqiaarejQ6P3SzsIK2ppMA7YZs0nTyYk6xSENkOxjgolvJhymNqcxt/qtz5N+kid241vpoqn93Ro94cudnrhSf5IdK3pnndO1dHWdTfpkpaem8WR7K5m04tnsizK+JppjMbU/reNp3be22vpPPJvz1RyxvNfocEL7U/3qNuoks5ojNNHhhD8mmPjjqWzMq5DbXnBwVnLLnaBmj7vz6vc5ksLtAewFd6R8CxsOJPTnDWXuvPEwS4EoruOcyWbmIGuCXTh0ZCbx0Iu3sRFkYTx807+ylmQ36E1wqq+6vl3HeUyf3GrntAFyixhzo2seWPCgEQ/O2TIE7oxNbRLEc36HvgTBoD9nvmIfyefgZSsrue9ywPFN/tA3bblP6QdMOz1y/XoAzseTgaHm52U2jR+ITl8ZLPI14ThMgQrvp53VlJlXyQM+psxEmtYfY5nokAGvzGDy8YNLzgV124Nh52/XV/mA1us3mer/CXCSWEFQSfecz5EjGUD8XtCcgLWfU0QAhxgD9cHBM9080Ib8St7jw/rzA9SbbcM4mD+nYcpCD3I9ScaSMxbfK4P4MQBxJViIYEOQJP49FKYTWcJQ/TqjtEOrp/78mjMZbZ0arafQjI6dIQQucmjffffdh9RaXoeohcU2ONHBX9Hexpx9TYLrCn5TuR29r9xbwSlu/r1qazIqd3WeEpoDcE+8TuZ44p2kVeMpV7oESXnK4K/vnMbRcDkd50725T2UCDiTAkvQWXKNAHY++fDxfj9A4yuHNFSAaZxtXq44ed5ukyVX5rHhNNVLfJuzewLNsKOdCb92fep3hc+OLif3nQaJV9JlRZNWN+nB/2mM07iaTm780WT5qr2V3G9jaf1PtFi10WCSKSc2zQlO2d7Uzun15Jsc7wqHhNUYT2TJRK8V/U5lRLbljlGO38vtbKyEK3LzuSBlAr+nrAYcH8/ubXMC4MD5Vjfal+51/evbxuiLc5jI3OdoCM9Q0Ee2szKRBQr6KNiiOjyQZjsKb6dljtWm/Bse2mIH+LYYfYMXh1l//vOff/BTFIgRsLXMM7OdHu5UJ42YA308EOCBAS8L6D5nK2nrGkEigiQewCOQwhjxtdjuJ5BNpPHonmw5fTzI57zh50e5fszsIMYETh4I8HWa59kwr5nA4DRI3qVN5w3f5uj4wpvUzYwcb1sfD1j6/CQNPODjtm9mCjneeQ5Urre2NS7X3aQfnB6073TyoJLTEfzbvCQ/pl7NjEaXlS3T0fskmcIP3s+sJoIt3q7T7b0WpCVrEfzIhuI67fv2SAJbrBvacpqlTcGYPTvQx+wyy7fYwVesSw8i0z+87Dg++VvhdkbhzlhclUfwSnhJWBPt91PRr6RnOb4rXFMQ+v0r40oBdNWYOYWrbaVBosARry3lCQiBJd7skPhP/d/beLm1rRMDcOpnVTcFXDqNU5utzCkPTY7YFViN/0p7V9fyVWh1UrE3HJAV+SaWK0a395X3rjpbrQ03cAGeUui61p+MxRz7RIfmWNzKH88Bq7mdvpvjsBtj3m/O2YRPQlvfV5zbqWzjj11bJ2VP1kpr3+mzkmleJ+XiTgau5Nj0v9H9dP5P+862c3yNl9r/5mQ0HbHq/x6yedI1jtfOKbi65hLXpENrw/FInJpsW9Gk0biNo8FqbFP/Db8c21T2xBa5ZRw7yPon6/ypoW0nyiftAv5nRoY7Uy7D/EwSfciIkV2LU5dOH0EmXgqk6549lFuk/MwTta3gkq4pIEL70ukKHBFkye1j2Nj6rcBKc+IdR5xIZfOoP46xwE5X1rNsefrwDAlwTkgae8DO6ep4M1f6aAwCBdZkv7gdJsAZdYfWaevnYEFjjSF9D/fNMlvG+Sgzeejb20lZ5fPqffg8N/vL6eXtJe2czi14MwW2vLz34edm5T0fp+PkwSfG41k0Ke99jJN8nWRVy75yyJdu+dpmPpjH3BLm9Gt0nv77bw+qeDvg4QfnEyDSvdwSl+2nzfrHdiA99zkTTUCGETuF/Ly3zFry4CPXBB7wok+Xic4n0A954/TzoJFvx0sd/SSBpanxeyon74OsJQ2SV3pKWHOYlO9/PoWVAeREXLW5M7odJwT8Yw2DK7AziJy+4McZS7uFebXfqdw9jKUVTAag35sMw1NcmwBe4dIU1FT+yvUV3o7nU8NkEK0M8Im2p86NK3j+N4V4aszndTem/HriuVK6pNTKECSd1Z+m8FST9poxMfFy0uqp19UpTPOchlmW3Y1hxQOtv5P6DSajaget36ZzTvvPa7uyKeNX7VOu0f8EvyyfMrfNSZa/ImcnPHe4rMY28VO2v+LJE9z994o27f+KBg2P/D05Dqu+qDNljzhMdEp82v2GU2t/ZdxOdD3Bu83dKR/u5OyOHxotdrJ8ki0nuJzqk+cEl7HuYKfsndZtu5fblgQ4jOhed8gIYKB78Tfgf5xLOWM4eTiMCvB86EMfeiijoJKCV94vB1IzFs+k1jUCLgpO+dvkfIw4nU4TdlXIJxKuCsZ85zvf+RMP1zwo4gGX/M/4JnuWb8/S0ofsDfUpGqgNPagWbtQjGYDdELSBg83b9ISD6uq+vglYrdaQZ5d54KTxlwcrnAa044EO3ypEmz4nniGSfJj9e2CkZdAj1/IwaT7+spccU9qJub59jDmfuU0t11yupbSDMuijex4A8bH7nFGOOXGa0n5mMnE/7aiGewaNUr57Wzkm+NQzleAtAk2ZzOKyy+fg/a8zgNiCyzrnTdVk3fkctK2DHlyiHX8gnXMIH4EDMsbXBwEseDh5zvm9ndl097fC7e6vDL8rCt/bZCIR9uwjRkitjLCGi/9noplAPxhrNeYVLd4GRd2MpdVYVgbfLQbuY3G9Ui/xmv57vfy9qzfhsOq3GdSt3oqOkxG9c0J27XqZE4P+FE7m4KS9dIh2jsOK33c8lsqq3d8Z8zteklzRtlN/uslTG7IyOaiy0anxedKm1XtJcDyb4UOZif4rulPXn3K1Miu8dnBFvqXsXPHDTiemUX+iO9v423q4Qqcdvm1dtfVwIqsoN/H5yRqlzqmdMsnRJr/b/aTDbrw7O2WlDyY821im35O+ymtNR073G76TTFzpkqls47cc00r+JS0aTafx7HRf67fZmPewFVfjuCrP3LF6aXCnk487q9CvbV8S4AC6U4de4ABeZfEQgMksD+iK7e+Ak09QRx9evIEDrZ0UCqiQbUzQyoNXtMODW+l/gXDzs1ZwtnmtuUO+2YqxC1RWfch+YCscdXzbVZMVfOP/6H+eacvvfHBHO8Jb/SqwJfpoLAoMsaXPMyE804xEAQJOsoHIePItOLn9y7OP3PEm68PH6YFKz2BLGZFZWlwH2tpz+yMDK95HC+75/+T97NffNpZBfq+f2UcTzoAfueBr0dsFhynY67yS63KlbyjbtsKBW+JM34mP3/N4wKRDpgCVZ0RlwBk50HZINb3yvtfygsOy/c2JuY6cRwSesUk8IjOW/L4HnJ0fUzb6nNMeWZo+d4w9de0VePRWuFOYDGju+SLjXi5yFEWWy34mw9HxQOBLyEsYkvqm9lEQ04KYDMyGB+VXhsG9YaJNllkZuVN7p3VOjaqV0XfVqDuF3UKZjNWmkE4W3arMSglM9SaeTjjBb0e3q3Q9ne+TtTApiEavySAQtLTVDEjktVRmE00mudZwlBCXkcsTRp6MYEi6ElvRE+X4tsNEm+a4pdPoCndai83RbP1cgatt7WRmwsrY2+ms/L1qn3ZzfTS9OhleEy6pXyYndVrjk34+oeWKFidz13TZZHg3fCZ+nWBFg1V5x7HhutPFE+6rtZfjmyDxOV0DK7vkxNZyWTzheYWvsv3VNdqeto2sbNKGX/vv7ZzYWtMcOm+eyM+XBHeywMffmuWvFec7tz0xVqcZdWXHk/2ic0QVAJLdz5lE0sFkFPj5RGSJ+Nk2ZBhwZMRHP/rRN2ccKagCTfWhTc5sAW/X7WQo4XgSTOItsdgC3i404IGUfnOWU56Fmmu96c0pc6OtM8bgZbgun0m2jcYjf0p0UVnP3lJZsiT8sHMFxMhyYgeKjwEHmbreHsEW5/cWqPBsjRbM5J7mHbp4oMUP+HaaZIZOy7hr9lrqzswq8nFn8KqtaaeX18+ApLcHZCZVk7f5pj9vwwN3Xt/bz21vyU9ZZxUUTRomeCZZyoOkJzShLbZmth0KqXM8EEVfBJPeb2dBI9PgLW/L6ZZ6gbmD7+EH8HU56Rlxjh/lwS/9HpJqkCPggezyOitdn/CePz4smRHM54Y0KFPg7ZQwZflosn7oh37o4RWdTAoRSaWzSthdObD7JcFp0AyNLNuY2K+taDnN/b1octXYmQz3p8DhhMdW5Zqx6/i/xLq6F5zw3pW2Jlg5FH5/13bSO6+3flZOYnM6Jhxd8DdF2cYw8aPjm7Iwn3o+F5CG67g0/BpMsjzrNifrsTLTr7e+s96E78m4Jv6aeOuk7dbHia5s7TlOE85X5vLWcbQ+T8Yy0XuClfzY4bRrf5IJK/1xbMBt5N6Kz3Ms05rajS3hSvnW56ktk3Xa/7aeU+5ONNrBRLMV7+3kDeVdV9zDtlnZNLqe2TrPBQoueDDAsy4mnN1xdN3rb1XK6wI5dgp6aDs6QScyY/Sfh9a0Lf+ALezufKsdBaneeeedhzr6yF/gbcpkOAlw1vQgiTOYCAipjK5TR+2oLwWp2M6WByvj6OlbtCM4w9EgjIcy+UY1fq8eHuxso0mmiy4aow7y1rjIyOaQdN9KpPvMgc6LItDnc97w8KCN358yOnxMfi0zh1I+t+1cKpOOe55zkzzZ6O50ZI7IavNx6tsDQ46zy7B8a5jPkeO70gXtQeUkJ33sHqxxXJweEw86HVL+rPT7Sh5mRlDrT9/QO7PHGIdnAUEf7Glvl/K+7e19r4M1bHdTeQLajJW1mgFMD+B5Zh5vpqQ95w+fXw8wIfuc/j5OAl2+rtob75LuGfy9S8bSiRH9FDA5FStnbMKZFFYpGDGCH8ylbykff3qRwu45YWUQJDS6nLTfyp8YNyfG+hU8XMCfQlN2J7isjMKpjWasTjw5zU/S9MThyv4d3yvQlO291vMpbVqZqw5lG9PJ+l+VmeRL3psUblPgE434vduO0Phlxce3rP+nghWvTsbsBE4Dv5ZztnJGTul0ssaSF063leR8Tv1OsnfqY+K7He7e72T4tbWZ+E7Q2kzw/lv70xgm52Pq70Qu7cawk0kneOV4T/XqqYzLNiaeW42l8eJUfmWbrOqscFrhk/Ro93f6JnHi3sk6XvV7Yiee2JNX19kJ7GyalwKn507HZeBJQHkCOe4g+WuzBbxRTQEc2f+y82X780p7zxBg6wt6OrMbPHDi21XAD1/Cz2OiLG+HE+g65zYp68gzl/VxpzCzKOSjCHenT8vyatC2uzE+p2sG7ADvy/0kBcUYHzTkbXruqIp20NkfgHlwpel45w8+vm2y8VbTMRmY9LF7X16fNrxM6i1vA/5wmvocOn0zO8cDNY479oafIeQ2yGRnTXIdnL1ujtvplxljXj4DdfB/jrfNj495ZcdQzvmz8Qf9EFjxOpnFlbTwvtmimu06kI2koCpt/8HrQKrzm2c4MW+OF9tCWRPggYygHmvL5z/nFjw88JlZceIhsqEIhhEU5+3aTuPMbHsrtsI57IzfVb0TQ3sFqiOloKcR+obAvv9ak+hnOTW8nwt2fe6MzZ3RdWLYTjRYGbs7Q/ieMBnxWQa8TtqZjOKpraYEuZ4GUxP2J7zcHLyG93R/GtstcOIUtXWeijrLTri28qlIJ0iDpBkgK3Cl7k8I3IjNse3miDI7o2WF55W6zw3pPDnPT04ZZYEdnzbj83Q9r+AKj6yc0WxnhWMaudn3JJNz3Td6TIbZbmwpn6Z2J1mZuLU+W98nsmVFlyZvV3OaxnBrb6XPJlq2Ma/wWY291Z/waLRd9dvWaRtPjnUqlzzT1mG7djrOacytzWl9Np15su5O6DDZSE6PW8Z6yqcTfs9pk51CWy++tSb5ivn0gE17ei/wp/bQh6APWQMf+9jHHra0EXCijL/JzPuTIybfgDexCVSPN5rRtv4r8OPnJpHVQFvgoLJkRjG/k7zXdx6y7UESaNS2COb8O985j3oWBX2tskCYK2irDCTP2MpglT5skZu2S3lZ6O/z6uPxcUzbitIe8Xu5HS3b9C1Hp7oEPLmW59h4cKE56/Th9zm3C770etk+OHimFf+hBzRnjI6X2wmJswcufV01Hsu1R5kMCOW8TPOU7eXc+zWno7fZssa8LmN12ZIBJ2hJ1qEC1Wxn/d7rwJ+XSR6gPfrh7FV9/ExpMpVSPzH/vjXOeRB54zzpATaArbrg4IeCO385/9w9sDQZoLfCpBxX0ATjrn4ykWcpNaaaGPxtU8wnuDw3zqc8kvN2K44rY3Bn5DXaNMV5wpPNMPX2rkAamitjsdVLyLHesu4apFG8wnOah9bmhNOVOWntphG7aiMFNW9/8UO3eRrHIZWutLyNnVzid/bpuK74mPon43pOSGOr8UcaGadrzf/n/ey/4bVaS6f0W/Fh8sAJ7qt+d2N2Gue69Pon+uCUhll2JQdbnSvy6JRWt/BRw2MlSyfZ1NZvm4sc0yQ3p/6ncezG3RyjJlemPlKv8t2cuMRtaiPHv5P7E06r+cr/K/5r95MWrV3HfScT2rWVXZt0Xo2zrd2J/94GwCHktzu2TpscvzuY/HdH3r/bdg6yAhQU4qm9O9JyFmlDD539zFWcMGUYsbOBoJHsAD+Im7MU6ROHjYOmOfhagS3PVHI+ygCF04NruR2J8nw82JT0z+Crr++kXQZZsryAN8W1OW4Ouuox9hYY4nqzEyb55Q6w07Nl50y61TNOoEMG7XxtOn+2QEv27W/bAnyukw8YUwZ8+M0a8Mw5wANUGehz/JyWjkcG3dLm8LXBfedJp6tfTz5P2vp2MKehj4v225a7lgHn6yD5PHmBDEPHw+mndaydT2QawcsCAtEql9vO/Jt+8Cfog4APZQkUCdoZ0CkPgZQb00Nx3oiHzFMZAltXMvNvyljaGR7TgnVo11fld/is/jehwUR6VN4jiIq6v3S20soQOKXTqv7JeFZlToynVT+TsTMZ2RP+U3+7MbZ+V0bjakyToXdiJLf1crJuWvkVX7iw3rXbDJDVGFaG+IRL/p6ckVPDutU9oWMqUK/rQlpnsSnLUUFpDE2B5IjSv/WUTgZiw/NkvSZfNcW+ooHT6BY5+lSQcz2trcZ3SZOmZ1p/bZ1M8mbCK+nZ6NsMlUmO7NbdBCueP+WvieY+robrRPuTPtq9iS47nm3rorU1zf0VG8bbnuT8bl5bXR/rbtzNZsn7k7xqOEz3cjw57tM11vCd1lP+PsF/1V8rv4Jb7LiV3Fj1k3Li1O66agPdcv9tAuxuH7tn5XANZ8nfhOTOKGP2c148K8OdWbYo8Xp7gZwoBZp0XXpeOt91Pfjwwh8Om/ZsG88iwBH0DKjcBqP2daar2gK3yWZsv8HJz1SatoVlcMn1V7bl9KRea8PnMGXaFFxpW5n032lEvQy0+Dy269AgAyuTvJ3sjsyo8Wt+vWUlQUMfr/fX7MMpUNeCop5N4rj7G8sS58TD2+N+rsGc91yDDZqMTxsqg8DOO8xHBmkcrzyYG9rTjgdVnOZ8ki+cJzxo5MFraO3ZgWQr8bBZMQM/C+n9r2UYD6IFBJn9TX+eoZTnvKXN6WdDUcfXOwkzwouxeKDL17TPDdd4mYCvJ5+7U51ytzOWmhHWDMJWrwnTe0EKPBFPjqAIrwO1eDJBxFD39PSADISXglOj5d5tT0bJZKisDJjJkNzhsXNebjEgV/Rqwm1VbtXf5Mjkvd387Yz7W+b/tM6OvqkorvR/ykM+1zve8flbtdX61Yf9/r432ukvOaEDKTn0UzKDQyn9acR3v/vd/+2py44e7b+fGeAKceLT5qi9LbDiOTdk25PM0zadDikj3PiYYDKUW732v9F+cgC8nF9Po7L1l87qii7TWkhcT2XC1F+OY6qXfNtk4a4NL9OuZT9tDpIujZey7Szb/jd6n9DWnZVGqwZN9q3Gu7vW2sy+Jhk80W+qN9GujS3r3VOurWyStqYnnti1ubOBpvq51lfr+AQmfK88hX4KSPt/ooHL6OmMlEbr5l+4U663memBkK8j3rgmX0BbXHQtA06qqwdNqo8N4GcGeZ9kRDnfqJzsCPXB29QcN8aRdPLtLL41yH/nNhanI06pb2dqGRwpLwlKEGTjfgsQtEBUjsmDB14PfKjndPNgIrhS3vHJjB6n60pXJA1adkyezQRejgtt5Pw4jzlNWqDDaef0pC3nIy+ftG20SNlLmTyIO+d44s/kL6fXiWz18i3jKe1dz9zKzBvaJLjo5Z0m3rdn+Hkb9E+QyO/Rtuoo0Kzgkg7wR05Qjrr+9jXqE9xOvvXtbwJ945/QTrMDuSe54us1+dnnwHHyDDrG61lw2d9dAkuTwbYzunftXVVqk2G5a8cZz19BKqdRygJFwl7nJoieGk6MD2BVrrWza3syBiej/9Sw2sFK0LRyu3neGYxebqq/wiPbbG2167cYb1OdEzrcCs0RyfsrZ2Oi/wn/OaSRODkfV+bRhTEfCU4Zj6SASgbIWGT9S8Dq6aTvPUbYenqrZAhyZIKJLv5bgl7tSFnRD1vtMCrzydKJbH5bIB0mru3Krq6f6COvs9NhkzN4Kt8mmebtpoLPsvk/aTXJnqzbaJB1p2y4xlMTTU/k8g5Oy+x0RJvfNv/NIN3Rc8K18clE79WYV7p34t+dzF3Jhqm/1TrI+hMuu37b+BLn1uYEt9o4jVYrPCeYdM1J3Vb/VGeu7J0mT07k4HPBCkdw8y0u6RRN27i8rdUWK3fknMcIwCibSP/BQd/f+MY3Hu79+I//+MMDJ5WRLcC5rLIXPAAhm0E6Xf958xvZSrxNLtfKbi2mc4uDmluHko+crlMGk9MM3DJDJjNs8r/Ph2edtCBQyssMnLS5bGVSfnidxKnJpnS8sccaj3kGj4/nRG62jCt/exc451Ypp1W2nYErcG80dR5w+mXGVeLetgA2OeV80DKbcj367qGGT2aKUQ/+acE+n6OkV/JyZuz5fLdApQe2sNX1kRxIOfO+CDqCL+ev+VxRj7H5Gs/17rxJPzz05m2LHkjLtTrRnmv+ZucT3XXXjKVUAH7tSjs72Bmwu7ZSmfBUQQpFTqQLS/9+bpiMgVvauVedUyPW72d7zSi8iuNVw6zh4vRtBmPDc2cYJu+dGMBTP8nnK+P7CtxqQK7GfI/587ng/3Rvh9Oqj/ZfAlhPHqUQeCsLwphzE1TWgzwCXectMqSdsjeZ/24MtfHyO8dLkOsDH/jAQ58qyzkMUlo608GVaI79ihPzlDCtQ3670m582fRKtrODZvBM7TRZ1cZxStdmzE797uTESvZOdb3cKR5eb5JhDR+/jvHk42/y9mSs7dpOBl+xPRqPnug1+kkjNvvf0TIN4Qn31fylvdAcmmabTTLoityY9Pskh27RJRNtpvFN93Ku3PFY2QDwc+Lf1uFqDV3ltVPa7dqdZN89bMx7gW8jm3g1Hb8sk4FxnzPG621z3zOTG4BXOnjS/7/1W7/1oPM/85nPvPr0pz/95o1ualuZzfStsmyR13X9lu2BfuftSwkt85nfOJGZHUK56UBmxt3eCJc0TxmRDrbLetqGxhlI8v7c1xId6Mu3L7rj68GFhp9nBE18stKhziu+hQq+dNnjh657X741a9JZmcnkPJl05du3JEFTt/+clhk8aHR1vtI1f2OdZylRzvFIevra8kwzl9ee/UT2VmY/eT3/9nsrHZWBx2mbm9OsZfNlEKrp5wZqT8kpqu+Zgu97HXBMPeP8Q7ueqeWBnlwz/p/gEWNT35IpWlPIG6eRz6vTh2wk/A8H+nRemHybmwNLTTE3RXDF+L/Sd4PJGNtBMv/q/krxXOn/ioE91b0H7Ay5hkMz4pIfvGwu5qa8su0dzqdjaHjvrjXjcjJkEoed0dfmOvs7Gc89efExcMUgTpgcotZGU9SNpivezPa4J4Pwwx/+8Js3Q7K1TcEbPU10wIgjnd3b4dWcCOcToTvJTH2kGPxtlW6UecDLx9yeVL00NAPrdG2srp/en3iilbs3vU7l+w6fJi/b/VXdlLsneOzmbAXe34TLNO7pf9oc0xiaYd7K+/r161Of0zhzzC6vslwGUFd6YzVnE72m+zkf+TvnatV3qz/RaKIH99rT8Owz7cm8135Pcn/iuRY0ujKWK2vav1c4+/V27ZRv0lnNNic58tyQ2SaCxh9tLeeWK3Tmztb06y0bAsgAFb95m9vXv/71h/qf+9znXr3zzjsPD6q//OUvv8l4dhx5ICUdL0dUsNsC5zRIXLjXsmko7/5Ns70mOeb/M+sl38rl9XOrkfO7BzPALwNIbsP4/1zT/mkZTWlX+bx7kIsHguCCPcfDPM9Wom5mNTm+vi2L8eaabwErp4HzgtM09VaTjdSD53wt5PrwjweofH49UzADfyu7wWnPljQPxDmtvB5lnaY+LrK6vA8fXwY6WzBy2tZHmw03n2fHT7yjh9PiI85l9pf4vPf1XPu2N/pgi9oU2PN59YCbB8X9OgeMq/88E26lp/O/Pv42OecJx/NJ3grXEL23gX4FnxNlvlLKK0jmv7XuifGxagdwYXMFv52xuruX97O9tiD8+mMMpVvuT3XAb2VYJc47HK/i0pTKbv5XBnL7f2I0rODW9bJq46S9nTGchkaWmdrwj7KCPFuJSL22wbENljb9zCUUC0LdX/npTyav0IePFIPS6oUTffsTEN4ugyHaxuntnj5ZeE5I2bXjbS9D/VWZxit5/zFyuOHfyrT2c/1NdRs9VvJiWv/pnLXyk0zebS1o8iSh8eROT01jz/ttzCtD92RNJu/4dxqvV/STG8itXhp/zV5YzVnea3w+8UjebzTwOjt9PfVxxeY4sdt2NMnrK7tlqrfCf6LfJD8muXFqP+zskAmnx9h6zwWZPZTr3/8nr6If/cl9yzbC+fI2MlDANX5Pa50yvLTj3Xffffj98Y9//NVHP/rRV5/85CcfXuTx27/922/ObmL7vHT4Bz/4wYetct/61rfeHByeW3NchvsWvDw42cfrY8nsFA/gUK+VycOK2zYg1w3Q1efNgwA+h96/X2t9pOzOIKkHW/xDeznfiRtbE8nw8PIcoOxn5TgurhOdZo3W0/rGhsz2kl9bllgCNqnTyXnUadpsQg/4Nf7zecbWTRvD7+da8n7TrqD8FKDMoJqPK7eBOs/4PLSAbJMvq/4E7FDw+eZsJf1ni6vP4e+/PmtNvz07z4Ggm89Dru/EEXr72yz9UPBcr239+rUMzru9k3WebCucT8jOEL9i1D8WJlxWOE7MtjMUgN04Tsd5hR7NyLoKO0PmFjhtrymPk/L3GuPp3HqZZqg3I2hqo+HWfrd+89qqram9vH4yV7syK3xOjPcmC6byXrYJ/dX/dBB0jbc4oJT1BBGhrqeIMhgR7lIOSnMnis+ZAyhVDvyXkdjeJHnCv+DElju1gxLzAzmzzcmZOOHLp4YTWXyFx9oanNZR8sjUzymOjd47fNv/xH26P7Xd2piM13ySezr27GM1zmk+8nprsxnek43Q5npFw2yjjWXlyEwyJoN10/inOV/JvB2ts/yq/YbTTra239lvzlGjqffdaOH4rcawWrNNF6/44CltmaRxo0Ea7Ff7S7m+06sTH+7k4UtB46PVthXuT8GL5mg2WeRtZh/+O3UrwAOlr3zlKw/nLilgpK1xyoZWkEkv85B9IKfSH2ApqMQ9cPFsF8czMwRynfgWGtpxvsytNW3NNMffy2bgh7L+4CvxFrSzcxotJ5pncC/nLutQFtvOx+mHGsvW0se3mBFsUhnNqew5ggUevPT5alkxmZGUa5BgFHg7f9J20h1ed3kCfZM/CTR4UMrp4/NNXaedz4VnEDWZwXzm+VA5hsaT9An96ccDwr5mXfd6ADTH1Wjn42zBE2iW7Thfc3g2ZYQDgUnOZ9Y3mUgAY+IcN+x774symeWWZyoxFrLqwJltd2QrtaBlBlwdWkCNAFfyz6nuuHx4t8NkNGS9K+Wnvk7az34mxdrq31vZrhT4ytjbGZFZ5hZoxs9j4da2dg6Ef2f7V4y1UwO34dHuNUN7N55TaDyQNLi6Ph7LMyscp/6SLm2unIarddH68L5W85g0aMYAe5RlHGpLHE8S9S0jgyeOvF4Y4SvjQ+V9m1qbs0l2prLMVymjiKWMXNAnDZ5iTd8TJuNxBckX6Sw0Y7+1v3MqJnzSQHBat3W+wjfHlXWnNhs9so1df6ewameSI43fcp6mJ14r3bvikYnGO1qmgbwqP9FhZQNN8r716/V3967gk21MY/Rrk46Z6NHKTb9X19pYpjXW5i/rXpF9TTac1k9cTsc7zfXK5st1MNEnx7Ubz622yb3BHaS2bWsF7cm+wLeIME6yLXKLUMvcSfnStu14eewE2QB6o7QyonWeksrzkEjX9K0HV5zH5C/6cH5yJx8ADw+Scc3rOO3cYW786mumBd9SrzkkXfJMp3wlvNsu7Ywn7BwPijidGy1yXeg3RxvQDm3yWngyv1We7G+3wXRP5TR/svsUAJSN1/gy6ej841lJZKVM2SJuxyTNU3dlJpbbgxkEmvSa32vyiLYycJs6g8CiZ0Z5Fr9n3OV4nO9Sx3kmmI83g8y+BjJg0mjqQUQPxCYfNz2kbw+k6ZtgEy/98nX4PdsKSzv6rTXvvOu4sEXO+89taLkdEN8FXpuywpJ+zFfSNOWL02CXrf+ojKWVkdNgp9y8zC0G8r3K3lvRrpTi7t5zKfxTI+xqWysDcQXNkWgKza+3RbDrY2UQTkZzEzqr/lZ1Jmekra0mkHdwupbuzWvTvLvicJzaPDTDuv3OticHyZUTIOEuI1CAQCZVVdlLbsigIGQQSujrqRZGCfuqM7qf41/95xpPOhDsbhjpns5twBBN3vff91zTt8LJemyG02TENj6d9FDrb5qTaY2s1trV9dfa2smCxHfSoUm7e4DTNcfg80WZU/mXbef4JxmR9Xbrqo1l1eaund34cqxZ74Re7frJfJ7qvDae1t9q7axoPum3ySbItid8dm3s2k9Y4bDiodX6vQKnc+/9+hP/rLfqZ/V0+TltzB3kVqp0zDzI4njn+DK7KfVhBpRSzrreTeB69ufbh3DucB61Hc5p7FtdwMttDHfo2HbjDvu0zchp0/Bt6zSd+WyDtr0/73O1dQlcgZYdk1lOvhXPaeDj8Hn0+fTx6sGgjjiQDUdQhMAe2UgE9DgPB9rLvvLD3PWAUddlJ5Jhwn3PMHIatkO8wTGDAYzJ1zb81La/+Tx40CptVV8bnhHE/7ZOpoBlsz18/ARBnMcpS4Bpsr18yyTrwufW+Z76vt1zkgnOX76W23lRKVfBo8nGDMAoAKlr2OVse2NnwR+9fhic/SVt2Mbm2Yv6+MNlX3uelUQ2JH0ljzgNm9zzOUvZK5ycnzOQ+yRvhcsJPamzU+T3UHQnRtAJjlfqPQWcGC7OICdG1WNgZRAnuBJoNGzKbtf3VLY5Gq2u82tzUibaTTza6jYeb8Z2w39yPla4rWg7zUvS69783eg5XaN/v9+ci4m+PtakYdbJPnj7myuLdvi2z6Pq8DrRNAyvOAyNZupXBowCVTzdcmUk5aWnZ/nkdEW7twUaHdq8TsaC31u1OZU9vZfQ+O5kvV3RazmPK2hrdreOd+2mI9Hqpgxr8qrVa9d34zuZ05VsS5wmWbTqO2WI39/R0std0U2ndJj69PZWY216ZUfzHMdpvV25qe5K3+3K7Npc8cLUfpO1V/qc5tnvNXxWfHjS/wQvadc2aHo95RI60stwf9peRdnsS9c8MybvpW3BvbalLB8CUS4dYM/MmvqkPw/OcI9MhawHeP/0mU5h4+8M2vHbHXwfB8Eff7sX40+bv/FvZtu0DAqnrd/3TI2cJznzyjLSGZUElXgoB93+5//8n/VsI17M4i9n4bqyzNQmwQMfS27v8syqaX15RlHjbZ+rps98njyw5gEep60HjNr2uWbvOl5+XfTx7YAZkPA3ATpdHM8cFzhC78nmcLo4Hzs9oSPlPZvQ22EeMnAGn3iAjbWQcoY2OSaDAKWfl/S9133nDgfwb9sMHW/Pfks605aAw8KT58An6ej/U0Z54Ata+JlSV/TupbfC5e9blNTOSLxq7E9t39rHY+tdhUbDEwMiF/5TwqSgV/1mmRR82e5E7xNn4wTvlQE+4e73V07JdK0Z5Cf10uCYeORe/d7bAF2t8el/UyiJ+8QLLVU6wWlJlhF1SUFVYEeKwvdJe70MPjXlnGM74RtwUuBKikJP16irgBOGTT41aX2taPBc0Ma9Wt8rHvFxTTy949UTeTr1P7WzkxsrvJrxtsOjtdUcqRXNV/cnOXGCw2n5XOuP4dk0jFY8cHq9ydupzIk8bvdPcJl4ozmHiXPjiVYn+97p3+Z0TL/9/zTXK36bZFuTBW2MbaxT3YQ0tk/q3AN243dcTnTzzm56TvtxBc3x87Hl2SO53qGXO4C5LYzyfg5M42fK5ba8pHU6m+6sZzaLt+9bswDqOC3YYuRbqHxrkffheLgz7OPxvnx8tJGZXNTzT5PrfHtbfIMvthWZHH7Pob3xC9rmoeI+D2pX2UUElVRGdhw2HG3qP9eguTvfvFXLnWmCSwpaabuTyntmudOhBdd8vMkvPufOA07jJteyjNfnf1sDzSfIbEHP9Mlgpc+n85T372tm5YM43jv56vg5v/o1n4f83bLzPLjoc6a5JRNpkgm0xY4FtQFPcJzGH75+cA0f+dsG4U/nabZgOk0I4jmPet/gwnY8aOiyaaUrPRCY/Oxz6bTm/90zlnZGZF7b1T8xlvPa1fLPCc3gO6mT8JKK/gRO8dvRI42JyaA+7Xsyclv/O4fmKi5TG+3/bgyTwTMpmFW/t66DU97d0UAw4bxTPq2PVua0TxQah+0pgEPARh+dj6C3ueTTl12fzXFq9dt43RDjzXIcPinI1xFPdJr6fJthMnqmdbNqZ7cupvbTuDmRL63e7ulfzvtqHidcV3RKWZHt+P9sLw3jK2Of8D1dJzt7YbqfT4yncjv9upqHZne0sbYxT+2s+M/naSf30qA+GUv26QZ4a9+h8VLrd+K9Fc2nPtt4p2tJ48bTbZ52/LizDU51eqs30aFBc5xulfPZx0vqC+/bnbd238EdX6cLshgHibbyXJ/MCmhZDALPRPF+W1AJPFwXZICKoBFteiZTy2DwYIgHKDK45N85Dn5TN7Nr2hpKunsmVaMP9XMd+rjAIbddMc6kI+Drmf842wSWOHSbQJY7xirPliFdJ8gF7ronkHOv3wpQEaSSjSibUHX8KALwkX1GUCCDAI5rBpecn/ifWSYpw1LPZZYa5XOOW5ac/3e8+O287DxH3TxXyYOCzq/JZ94X4891kvPu7XgGFFlm4OP85+vb6et8RDnwJ0iT89Por2sEljyARADyD14f1u3z7/R0ILDEWV7O/46HvzGOIKe+CYom7j6nToPMHHR+dpog3wi4XoGbtsL5xF9RSpORl4bWlfqn1+4JJ+N+SWX93HDFSHLFlYqGOv45MWBPjbwstyqfQrwZ/ytjckWHVteVbKPValwn/e+M9lvbdVyTNpOR0vpd0XPVjrd1uibZ1iahqSdSEpwK6Gi7GW8ByfG1/ideuEJT53E+BJMaDq2/RseXlj/OsxNObd22MidjuQcPT8bNhNOJ3GuyK+9N7Uzro+HU/k+0y/WyWnttrCs8ct1Pa3M3X7t5b33s8J7a8zZOZKW3nY5jk+snY5zqNZx2cnI3Bm93aqfJl5X+zTKrsbW+JjvuZP00nCYc89qJbvY2Jxm2u5bXk05NXiY+zmO7QPApXLFjnhIyWJJOs8Adpgys+EsvuAad2kHfDr6O6ccDUU23px3b2nKn2oNdTnN3mB1fxxnHNx1i73PCM+Vg45uUYR5wo20PeDQ96fVzPP6ddGbuJp3LGmXMnsUlh1rBAAWDZNNhN7G9Td8KDIEzWUtkfCggpQ/4KduEj64LVFbtMzafSw+aJV1b4M6vU8cDm8lH3lfOaZNhzj9ZN3mlBUm9HcfP+TbXXs6XX/MMp4ajX5/wdTw9e4aAouYKm1nfzDHj4r/zZq6NzN6hT89syrHStvwF4eAZhd+zbZjwKePOQ+1pi5f/ON+AhwdCNc4MMLHdrvFYzn172OK00TdrzGUxPPokgaUTQ+9e7QFXld7OIH1secHOaHts+99vcGo4upKDgSX4lWqqJwQCbftR5JZMkhR2U98rOjfjaWc8T4bxZIhl+YaLX2/GbsMncW6w47Em9CdD+RZIZbcrM5VrRuQk2Fe4ZButrhSCBLKCSeCWe/gTdoq69bkbQ/JDayNpN623xlNvC7jySmgGcf7OsiseOOGZZshMPLmTLVk357IZhm3+V+NY8dnEkw33hsNEI2/rih5rPHg6b2lYrXhg1Z4bRTt50eRytt3mM7PUGn7ezgk/TwbhiqZtHKu+Tvhq4uEJh1YvcTup32Bqs9Fh1dZObrZxNDqsZHyzI1bQbIwT+lyh14q33hY94Q5P2x6UW4dcXvC7yfZ8au9v6kp71GlNuzi1ZBrlel3pDB8XTqWXyXXhZwJlO3ngL7RwJ9Lp4q8qn7JkfKxezrOoHM9s1+V1jn/KPJt0fc5VZp254+78QCYSH9UBR982CG01j7L75G8QmGDbEePRR2cyCXQ0gjLZ/W1efu4MhxwDmREyZQuBk89l8l2+Icz53+mWB537b/57+5l95OAH0qc+zkOonb/Bza87L/m8Jg9kpiK0zTclC0RvMsp0TXOoN/jpt2x6zZuCNPADuwCgpcuL5D3PckraUtaDcZ61yAHcmX34ntcHbifv+7oi88nnl/JkZXkwyefU2xAOLm/SPnF5utJPThvO1mpn0N4lsDQZ51PZdv+KcbrCY9X3ibH8nLCi0duGKzAZTyflXQmtjFgx+Q/90A+9+uEf/uGHNznwZEGphHL2v/nNbz4IBYTMzploztJUZreYWnv+v/W1MvKbUvXreX8yDJ8TrvDjZCzsDLDdmK/InFO8m7I9rdvu7XBsfNDkItcfa+jv6P2SsKP1ju9P5jZ5bxU8OpW/bX3eMg8Tn6z6bs7stDbcoPAyjveJnFzhN8k1N764NtFh1d8kIydZvKLZ1O9VmTL1mddyHa/mu11f8f/JOKbrV/RO0+W7ttpcNznW5mTVnpfJOrfqp3atjTfXTn5Pa/ex8nsFbU23+9MY7qFf7g3uvOLYrbYwNvku8DqUa5k38Hhm3fCN85YHfOdhu65Xmr3XZEMGdCiLw5fZL228mdmUOs7bczoInBYZJPO2va7b3yvd4jj5WVbMTQaKBATrKJt4ZxtJA/kMZBb59i31T2YHW9VUljYUTNJvstRVhm1umgPdVx19dF3Bigx6+Vhza1HjQZ8feMrf/DXJbOjSgo7O+76Gmp2VWz0n26jxor+BLtdsk5melQfOUzaOBwp9PM579Mvb/RRUIiCoj+aRNtk6qo+Cjr69zWnjwUTHh7H7+s914XNNf2xH45D37xk/+tonk25qD/DzvqDF9PZp6KtynM+ah9Qz/kke5lz6Qe2NVnc/Y+m04clouaW/ZlRfweGxZU4gDY6r/d4Lj6uwo+dkDE/QDO3Wphbihz/84Vcf+MAH/sSZMvqv7UkKMElg7ByNneGbOJ3inu3tDMv2f2UcpbHndbzMrTx8Za0+BUx9NyNxxScO05y3dpyOk/Jufec8n4AL+sR1NweJ8wpWY3/JuX4MH/D7RH76vba2HJpxtXOwJhxyLU1youHXcGuyv5VPPHdrehrXJCezr7w/9ZHjm+q2stl3Gqareg0Pb2Oao4lXGj9M62mi/Yr3pn4Tr0mutb5X7UzydNI3eW1Hs1WdprdW4zrh08SnzdMpv5/Ykav/E882PFc4ZLtX7NndOpn6Szyv6LanhpZ9g0zRh4Nv23qZ1qM7gi2jievJu15Hvz2DgXKr4JcHYMDNnVk/t8TnLg/0bjzkGTvZTtqf0xr1zIcMcuXLTLw+fU1ZOfntgQD6b8GyzM7IDKl06jObBL/B55FtcbyKXY4+2984ywanW8ch+BvffK55+51+czyCz7HTM+c5aZ8ZOc7zjN3po3F55lBu1aK8812eeeT0XMmxCfye49b4m3ny4BX9e4DK11Pyu2f40KbTivY1fyqjeSMjSVllCqgQIGR+CSwpo0nl2KXg/WWGkc8H150ejrvLAj+c/o/DH4Cn86ylyb6BtzNbiG/PlvL1kGvfg2oEyxxnD1Z6fTL72GbnmUqnWUuXz1hawaTkb4XJUFy1ORmATw336vO5Ff/OADvBJQ2WyaD2a0SeYWyYWdfEzMpm+s53vnNkxK0gDdNm+OYYks8mwziNm2b4rfhx4u8V7SY82lh2NHkKWI0VgeZCzCP7K2N/1a7PRRPYEz1WToDXO5UpK8fnlOYnDk+2622/hOxLyPXqRsQEu7WQ19q8NP2QBpI/gZvqJLhxu1tXp/y6Gz/XJh7e0cf7mq6vYCUXr+inpkuurvOUyVdxX+E08czUx3TddUtrJ3Fp5Zp+OunX21+Va7re2z6lbRrO03gT71X/J303Hdd4sunfxm8TP+dcOK451hVdV+VOx9xg4qPss13b2XvPDTmPuc79uwU00ulN8HH7fKOXcJTcWcv5x2ZxpzAzUQB/SxOQwS3Xh9hFTU752PJ8Ew8ksFWPOh6IoF/K+Dax7NvpmEGCxJd+fR7c2U3nO4NGrfwkrzNjhPLyE/zAbmigNhRUIHtD38o6IhCl+npozcNrHG7w08dtBOgFLm5rtvGAIzQEJ+owDu+P8r7liDK0k2XaunE+84yoDNI1fcU4wJ/587mmfNKj8bnXd1xbOedlD35wT3PHIemac85Rgj6cUUQbapvACQeys12OYI0f8k4/DSeXP/CGj4NzlvQhKCggyOXr3enLfOL7UjYDSQRHfVwCl02sWz9s2/lLwPrP7YnOp7rOljqNy8d+6gc99PXqIuyU6K7eKWInjkSDnWH6GGjG4dRuc2JO+3hJuLX/nSGedCKFUItejCzgTQxaSL5f9LSvycicHI0sn4bMitcnxyjLJd82Pl6toVPePV2Hp3BLG60OwougoVKX3ShwxQ5MzlleS6W6c5DSUWjOD/9dIE9jm+Y8lfeKXlccnqzb8F0Zqs8JJ7pgKptrZdXeiV5xBSz+0xOufMJ4gutKB00819pqODcZke1PbbqR6Dw34bq73tZWG+uE02o+8wlblknZ28YyrY9c2w2P0zma7mXbkwyZ5H2br6TZxP87+TbJvBz/is+y7jS+VZkV/07ybTcvbjzv5GPToVOZHc3aeBofeFsn/LGD3dys9NsVm+mlIe0td5RaWYcMBgCrNeP9TEGfllHhjpU7d+jbrNO20Kzs0Gm8mSFAvQxsuQPrY9nZuStedTmRWTDAFCTLQNJk1/rcJS1znTke+vB2X17A4uU924JtbvTLG97IXvExA/m2P88ewhHPwGQCbxpznedzNdG+bQnzOed3zl/yhdPOeSPnPuVGyhCf12ZjUHYKiHHP377WAjrOD9TPLWEKdngd58k8w8wDR+pTgR8FGXVdNqDT2us5j2dmEGP19SA+kh8Dju+3LZ6MgQCX+hbv+Xw4zxMv8MCXH0De5iyDSNCLsi4b/OG+843vGmLcjttk6z06sLQyFm6tn3Bi0N4Cq3pXDK2r7TKBBFFan/zftfcScMXwnO5PDgALTEpBix2BwcLydMjTfhsdXYCm8Mz2VuNJI6XNX4OmVK/AVDcFfOvvlr4fg28zmPTR/GqLo7Y+SrgirDTnykpTSjKHI1KP9k5p24yhBs4HE7/kGBDUCF9/68Rk+DWl7/238it82xiTzsJRB+Hrc5Il9JSwkmmuGCnLtfaUdAUnvOrtYVCs6q4M/xNd4YZow7XNH/WmcU3rMvF03CajPunvhlP26eWnfh2/Ex0+ya7WfrbZ5q6VaXRZte/tTr+n/nYwrfHVPE28cGIfTY5cjimdi2xjcrqaTFrhOunaE72b9Fnhku1PeE16JdvajX/63tEs8ZnG3cBl5DS+1l/De9XPc4Hj4k/z9Y1T6Q5Uy1rKTCPq0i6yzbNwHCiXWTreXgs0Yd/nmUK+PQo+b+vL10CTWakLJ7mGw677HrRwZziDXE4fpxH2jusDb9P7bTjlti2vNwXCfBwpk7zt1FH+hjfO36F/PZhmCxvZH3qQSdaGAlJsgXN651lE4Or4QFu3WVJXJu81uedzlDR3nezzyfykDes84EGwlqU06TLHp+Hh/72ftg647gE0P7/M592zBR03bG54yc8NanxHOwR2yM4jgKhrnJ+lc33FA85DZL2prL9Jzmmg35TxB7ic8+RvGfzB1+cGOx30zZvsGINnInkgzvvMA+ldZnrQyPHzpBan75TlBN08W8rPrEpeuPtWuEkwT/dX1yeDamUktb6vGnuJ04mC3RlNDberBuDU766fxO8esKPJyvhJ483HCjNL0GtxK9igABMH7vnThtbHzmjzvhqtk2fSyJr4tLU/4eFKJNs5madb57Tx6K31G05O1xV/eDntcdYh7WSkEdmX4OVtCjpE0ZVlzl/iMK2/Znx5+V303fvlI4GrwJi2Zwp37e9WarV415VW4rDi3ZVc8P/Jt96u46iPAkoK3vlBlS8BJ3yXQUTBat5b+6t138Adgrw+tbubxwm/FZ+d6LzGx1dlR+LUylzhx6kfN5Z39F+Nvc3lRGe/3/ptqf+rftq4b7E9Tvhxd32lV3fXT2Vy4rGy4XZ0mOb+iu7OcTc6TPon1800jh2c2IAN95U9Msnuqa0T/FY6frdm/PttAT9LyZ/0+3YvxuUOWo4jtyMJvGyTBZllkdfBJev76+Fd/gn8TCgc3GmtTXPq/AI+LRtF4LZHvg3OnciJPvrvOtHPYHI9ltvb3On39nNucx7A08u6re/fzgOZHUVWh5x62ZY486oHzRVc8q1kKi+7jTdxOe6TjmC+M1BIPR8PtHGeyUBAbqWCT2jX6eh8kVlcfr9l2aT+a7akz0Gbc+crt5+mcfib3PzAe8bmmX9J6+RVz1RyvnP+cNrRLllRPgbKEFzk4HdeEIX8YUwuf9JmJPuJ87oITvFmtve/fpObrlHfg2l+gDcHzBNEZ/umj9k/+MW0TVvyoaEB/XlwLDPcCCLhb/uDc7/usgR87h5YWhk2p0bv1GYK0l2fV/B7irqnynnloKSh95i+HjP2e8OpY/Pf/tt/e/Wtb33rYYFrYQjYA/rd7373f3u94soJ8X58AblQy7IrZe/KY2VkT8bzlTWR+L+tsMOtGbmaTwUNeUWoBBPBJP2WIP2zf/bPPsy1skkyQu6/J8dlJZckUNUvgUv1kfvYU9H5b+GvpxvvvPPOQxu6pnYUWFIw7Ld/+7cfDBvHp+GYbZ/QLtNvc8xeR0pB+LGt9G1wHto6OHGOvO6uXYfJeGplJgOt1Wk4NzkwPdVNSLm0k28rOk14tjXTaLPSuRONJnwmuiXPNsNykueJ99R+cwa8/Rxzq5fjvNUmmHhuxbO7sbayU//5e1p77frU/omOmvpc0XFyMrKflfyY9P8EK1sscVrp99X427W2/q7M95Wszh2fvS3gDhf6FocLcDpldhBz3bYW8fEAiENmk6Tz5IGUJkvTmfctUm1N+b3El3nN4E9uRfG22vi5T718M5fXzywID0T5dcrjjCZd8rfjlFvKnAa+Vt2Rdz6HNrTr7WDfMSZlIOkaGds8qPbzpNgC5/RwfmsBy6RF4uTf/hYvD74k3rn+c302XgJXH3sLjOZ8tLeQ+e9ml/rcJG+l/eTzxHj9rDHnl0a7KfCr//ILedsavgFj9wwo5xvqEljJA6o5Z8m3qDl+vhZyneq/7OxPfepTD76L8FJwSjsvyIB73+sgEXj4WoSvCQxRh/ax3wlQ+SHa+C3Cn8PKeeOhAl26x8PulGUpj1TGt+z5XMLr0M9lrh9S/iSHdz/WCEs4aacZuo/td2f4PBZg7Cn75qT+rt5T4n8vSANJ9FDmx2/91m89ZIPoGk8fvvSlLz047V6e70kAeT9XDN8ruDcF4Hjl78TnSp8nY5gcmVsg6TbRcTLcV8axK1rqSqASJZdglDHgb3Robbf5m/rlaYeUhpQAryfVtjt9JIB9PI6rgwS3sq0U/NJvXj3LEwvVlVLJDLuVol45dl42jYpGa36jXFAOedjnS0Hy0b149WrZNh8NVnOTc9f+n8JkmDbnM3/v2mz4nYzZofFbo2UayKv67f/U5g6/03E0/K+MaVef6+4geBut3opP0unY1ZvKCnYBiBOemuZimtPk50aDbHuyJafxr3hlWq9Nb071pjJNt0+4TTg2/Ca+nObtxJ6Y+DN10EvDtD1N/zOzlPXlNMNpyyAR+lOQc5NvZcPBbJk67qD5uvK+HFfqOH65RchxSh5wXFvGAO25fs/tgtTJMj4mP9iZfn1LTXOwM1vBcc2AzJRZ5oGrtmagRQZkMrunBcU4wJlMeN9K6dvDvN3EdwoitgBfBgzI4kpaQmen30peutz2eW1lgNzamPPuQcMWmGpBn9ZnBqmglbfvD25b9lXyRK6z6Q1tOVbnT8cl9bEHVrnmax0+yayexnvaffGRj3zk4WG1+Ay7m+wn+Rbvfx0Q4lBxzvjyrYoEcPwtdbquoJGvcQI5vA1PoD7VLj6OH8oND086J2lMgMplqyAf8Of2xbsGltKQ3pW5CpMTkNCMwKttnJR77FhcAZymkJ3CzkB9adgZtNBEjvoXv/jFVx/72MceFogyQBRs8nOppnlohl3eXzlWK35eGfU73s8+3Xg4NQZXZSbebYp6JWBWfa/G2HCZQPc9JZP1oLkmBRS6eNrrNN4TGURfEsb6KCj0mc985kEYi9++/OUvv/rqV7/6gFf2kXPE2ygkxDkfiqcdKquAGGPZyZIJ3BicaDzhiKLyt6CgqF4apvEAOZduLE1rNQ2xqZ9VG6syWX53r+mfaf2dwCQn2vXkgxzPFXnX8Jhwm8a4GvtK9rUxNYO6yfuUt15uoluTz6txr/A84dVJd63waNeu2iMNv5y/lg1xajs5jm3ep3XZ8HS82jizjUkP7Wg2zfeJjFrhs7u+Kpc4rPhgZ/OsaP4Ye/apILNoMgCC8+d6DecpAyCN36mbmR20l9uznBfdIU965ivhcz3p49uk6Dvx9boeBPH/uTbcgU87gN8pHzNA5rRKfk9fJeWxBybcQfcx+u+m571dfrsdlPRuOEEj/Sag49t6ZA/BX7LZyFRJ3mjZccxbZiq1/gEFGGSHsS0JvOmbt2zlXPrYml5Jvmk0yowYp6evL8c/15vXbfI3cc1MpMQ/g61Ok6Qj+Dp9WI+cv+pjchq0zK48Y403yjl/e3AyXyDkPM9YxE86DuODH/zgg0/BfdVVYEnt/eqv/upDgImAUc63n4XWbBjueXmCUP4GOQ6gb7yYB8z7ucUpC12e0l9uQ57WwF0CS1eVUjNSdobLpCz9futj1//OYDkxeG+BXGS3BJfuYcDcw5jYzU3rt7XhADMr40Pb4gSZtdIMqlUfV8acC/pkTDuDbtX/CU4nPLpaUxN9rozzFE4cJ82lss8UgOENgCh6ge7zOlA/Z2nV38n80jcK8Sd+4iceFP+777776pvf/Ob/ZgimkkaQ8sYHbaFTOX+zRCrhhvvksPg1glfg7IeDnwI0Fd7+dONtgBV/uDG0gjTgTyHrpDJfOWrNCU3HJPE5kU8r/LKNbCtlkOPT2k1DNceU5bx8jnXCbRpXo0f+3zmFTf43HFu/adSd0nXFr47b1Gejsddb4ZHj9r4m+6fxcOu/8VnTCyd2GuUmXXiqZ1a08vsTbU/sud3YdnWmMnmvzcNOrrT1PNWb8NvRsPVzMq7nBs9AABqdkBupO1qmbjqcKQudJpl9Qn2+3dES+E6ExAvIIBmQbzHTp+HvmR+TPM7slUa/HLc7r45flmt0dNuJ7TTJf/kWOXf+25lVTlOfr5xnD6q5o81YdF82Gwcx41jLhuOA5ZXudPpOGUY+Z/AARxF86EMfevOgUf2BmzJZsHkzEOMBmszC8WupJ5P3k8cZp3Dwh7uZEeU6OA9Qn+jEOmA+MqhBQIQ6LXMt+dP74UGpbFnmzfulDcq3jDK1QVm2j1Ev8YHWuZacN0VH+THyVdS25lS4sZWO9v8f47U8y8vXXuIinmFMmi+2xQknzm+iH4JLbOuE75EheYi+0yVlGkFyAlh8PNvSzxB7kq1wTUnmACYj8ESB3aLkdn2srp0aQK3+ru7OAGuwM3BvwfMecIVOp4alK3T2mqaSau0142jC45RPJoO1GaKTkZt1J+O1zfFunlZ97RyBaRy3ggsnv9ba1nwqKPONb3zjQfAp0u8KLhXChDe4N8XZZA7lpAR+7Md+7OG3gpfCQ99uRLb+wEkCXeU5HJLgEsJfCqS99dFxnuiHAtUTEF6Zqy16Ulh66gEeU5uOPwEp0mNfMmOp8XpC8v2OL9MQbe2eyPmUySd64FSenZbzMa34vrW3klMnuu9UZ2XbE46tj7aeJ9zcyD/Ba3KaWx8uC1qdSa+s9MtKducc7GRzk22r66v2HJeVbprosCqfeqz1165P9Vc0afV2uno3pkk/8L+Nbzf2lYyfyu1g4gF3AFvbjT+n/63Pl4SUwwLPykgH2+t5WQ/yTHOmT3vDF+XSdnA7hTIe2HCnMB2uKaAEjrlFyzMLvC9B2lq0mWfHpF3W7CXfDuVtu5PuD8ySz3PrEf3qszrMewp2+Rpv68j9gZQHPETjYaU+np3hAQ4/o2bivRx/rjsv5/Oq/wQdZM/xxjnOfFIgIM+5msbkPM8YVw8/WzZdzl1mJCWv+Bx6meQvx9PnPwMZADzl85jrhfHBPxy87X1nVg30djo4vpRhZwE0dRw8GOl0Y0uZ8yt05m1yylrijYM8LJeP87u/+7sPn//1v/7Xm74IFoE/9POHv3kv6QKe7PDgWx/hwXlJBC49UNn4iDnOYGTOE3QTtPm9S2BpMnITVgZGK3tyf1XuRDG6osh+b1GsK0M1rxFRPDUwHoPXrXS+N0yGcbuf1yYeWzkJEw4r49u/J5yyrcmYbHzV+j35P/F7Go85jpWhe0/+aIpl6tMVm7agKViiw9rJ+vH0ZSlj3c9ASqP91Gczhojqf+ELX3j1+c9//qF/BYryYPj2G0Pld37ndx6EtgJAwp3Akq7rwxoHh4Zzo6G+FVDSGU5KpUVZSnF9/etff1BQnu664lEpGJWVcYMR9VLgNOT7RFdwbQo2tnXS6p9cmwznJn+aUeX38rr328ZwIsOaod36zn7ceFvV9X4eKxey3IT7lXZz/qb5zvV60m7q/yYDJrkwzcmu32w3xzfJ74kfs88Vj7b/iVuWbfpnmteT9QfeLXM7eTmvtbamNdfKOb2m9X7Kr6u5mnBNPCd7aCWLpvlo20BWuJ/YJ88J6Ti3TIJpG4ZncsBTvm2DbBoAfmi+gAd4nPa+rYS5dx72IJh/ZyCFueIefWb2go+34amP2y65RYh+fCyUBV+ntePo/eR5UzvIbWO+TsAzAyGOv/ftdE16+FxyhqZsSX8LFlvO8u180MkzU3byf9LXBCz0EZ/JfpMtp75lt/nZT9ACGvkRDIDPqd9b2b3T2vc541pbV96GzxtlvbzXz0z9XAPMQ153SB3mayHXKC/78bE4zVifBKAIDHmwxR+2qj3xDZlA7BCgTQ+y+vg9i4eMItnbBKMUXOLs2Pe9nmtwxg/xA7jBi2168DRBY/jU5Q2ZeMwTv30uGj/nGUk+n2qDQFnyavLUie360OarC7AyePz+aeeTEs77K2Poaj/Z36nxvGvvsTg+FdwyvlOA2SZ6pHCa8PPvVZmrMPFUOhV+vRm92VYq4ZXRuKL9yrCdnJkVLU6N4yv1WjsnuHifboRJuCqIlEZTPsmZcJvWbDOgeNPcr/zKrzz8V7aSlL4rqd38CTj0W20RWFLbbS91trky5nljHq8+hU56KvLhD3/4oV/SUicDA9pJoelpiSuml4ZGhxO+XmWwtfZXba6Mw2ne25y54ZUGbs7Hid5aOYB5f5KzE41aWys6TG3lmprG19Zs4r/CY8LL+2sGdzoAjW6TvEi53+R70jL7WtGrjanx24ovJ5x3Za/YJxPdpmur8XKtyfHUBdN4Tu61Pr1Oyp2G/0peNDwmfFZzvOOHxLVBG0vim7w80WIlL14KfE21gEbyU7PdpsyddlCz68zcZuXtC7L/Zv+lk91wO5EH2b8HQry+9804Hc/EPwO5GUAT5LaZnBsfV6O/l53ktAcDkl+TfpkNpPJksjguBAR0ny1xyiD3+cJBzweJrV8fTx6G3dYY/2UP6gVEAhx08JZtJxtPtpkH/BqveD+U82/Hyemb28q83dS30CP7arrWecznxnFxvm2613EF4EmCcxn0oB22MpJdJFvbzzIVbcEZvtJv6jH/4MKREwBBQM5wAjfa98CkPupbx3XoAbPKKDilNrWbQW3JR1D7/9frFwV5hhxBM7Xhu3OSJ8CZYB9BHw9uk4nFfPhZUeCan7bDJA/wZ/ysN5/LJufufnj3SgGv6rXrIN7aOB3EVVi1O+H6NsIJrk85lia4/N5Ufrr/nOCOd0sJPDXGTgxgh2n9ZBmvv3Ma2vVmiJ3Arfy/W+NZbvWd5U4cmgYEf772ta+92WefQZodzo4Pe/eljPxew3tHG4Q9SlM8KKWEYa23T0iJsSWuGQ3elurzpIxXtL4UrNbOCW9NxutU9qosOZFDXubE+Ut8roxzB2kIJv/vxjLJj50+T6fG72V7zahMOu9kqZd154B7fi2vr+TcbszTeKYxZxbENI4G6Xw1o++Kbkic2zh2czTRZrrvsJPPfGdGxWordZOrq/En7jvcnI8mvZPl2/fUb+LZyqVBn5D813BpdVr5tx18TnA6PXNI3y2LNWVAbrtKe24l45qscfo1px68vA/n9TxEt2VnpYyl7XyRCb/b2UhNNnndzNJJh9Lx9WwNfTyjKrOj9N+zzj2YB045bylXMmsr5SE0zbN/aEM2HQ/mvH2CC2SDyCYik8bpnDRIOiZNqUd5Zawow1w46IGp8AGEs64r8KCPn2XD+Bm7833qe+dlD4hmADad/+T5toacp50noHlmwDiuuS4mmZRtOS85r/r6V/CFl+ZwKDo2brN7RF9/MzN4sk1SbZA1xEHqvLEtAyusET+jiWwj7XhQGZ2lxYuBdE8vnRJuZEP94A/+4EPbPMhWe34Iua/5PFDeM6tYY4ynbS/k47ycAcDGCy4HwDHXsGeDnWQuPvqMpROFOgnzU0W86n9qd6qzMtZ2hulzww5f4NSAfWp4bD/TeJsAWRnofi/bQRHoW0KIqDKpkJNwXI1t4uMJz9ZeM2Kn+1dot1qHK/6a2royxzvHJGk9ZYlNuCVfrPCQMEdwp+yaZE4bbxqpra8J59U9cMBA40mHrvs+7Ea3BNFRgSjSbF8SGt4OzZjerZVW3/s65evp90oPnMrkST9O8o17zdhb1W3XT3Rc63OigTtKOzk4jStlQZuzVtb7d2O+GTdNFyRPZNu7uZx4s12b+KmNM9vKp82rNZHG/zQPyT8TX+90l5ffZREmr7b1vbo+8UfDs/HiqY5q8uWKrdnqrOpP4zjB9aRu6oWVXjyVYc8NrAV3ZICV3tN/d6b5ZICkyQMPsvh1nCp/Yj89pGlb5Agc5JY6x88DAT6uzGRxJ9Sve9lJVjZZoGseSPN2c5ua28s5Hq+Xsqg5stMYPGNDHwIv3HOaeV1oI5zk1CuTHLuej4AHgcKJjHAyihLvfPMVvOg0THpyPqYyzGV36UNAhPOWFHTimIPMkGM+oHMGmXLuWpadZ9gkrj4ep23ygtPbZUh7oOUZNsxbnjeGLUu5nGcCGM2WZiz4ZtjAmlP1I78teYF58mwxAidkufEWNcYEbyTvgxtjIMOJsStQpBcAKYj40Y9+9M3xHvCgn7/6e7/3e38iG4vDvdm5AU2czuyC4OwmAlyMSR+VoQ/OcBLwYBofAr5O2ZfrKmWfywC2FTKXGYC921a4STlNhpd/N+Gy6yvLrgyIFW6rfnbwHAp5Mqom2BlSJ4ZL9nsFmsI+qXParuPXwA3UFV+loNXCV7RZAl8LWmfkKDOE9MQJj904Gi6Jp9e9SruJBu3a5Nys1u89IA3bCb9Vfb6bYbIznFtbrsT5j4BEYLqAb/PU2jwd01TelbqnyEqQu2LI+if4XHmy8JSQtM97q2+gOQWr/ia9sao/rZfdNb838c2Ew2qN5HxPbbUxJb1a1lE6OKsxpcxY0Tfxn4xGx83/J/6N7ycaTP1k2218Pqak1Qome6fh0WRYwytxO9UTKz5otDgZ2zSWxK3p4qbHV2s8f0/rovFy07mrbSJtrKs5nOyCSS7n/4Z3Xp/68+s7SDk52R5vEziOvkUGZ7QFddKhzjH69jOuZeYFT+untecBkswCYv2SAeP13GH2c4fSBnF8PWDumSDQIfnD6bCyRaHvlMWVNG24+X3ffuNZSyv5lJkTlPXAkd9zWrWxEYBxe42sbg5XVj2yPXDU4RdtScsXBTkveWDCgyE+v/otZ1/ZKsosF6gftubpW30IFw4X50gDnwOnmfO/r4G0EwW5LZD7nCk26RrnSTJhWvtuG2QGldMpM/Ao43hnwMoDok0/gKc+ZPyQdURCAAEjDvkm+MT5Q75dTvXUBme4KkuJ7CPhQrBnWovwp76hl67LZ6Qftuh5cPAPX9vxjJc2PAuLg7cJNEF32uK8JqcXgSPGAA3B1d/G5zTOrDtv1/mBgBrjgKcygHn3jCVnhMYg92zvxOj9PwWujqXR/Baa3ErDlbG+6iOF6qSUTg371TUWER+2GOmwZFInJVh0/Tvf+c6IW+vjFrpNBsJkHK8MxWacT8p4Z4jsxnNlfZ8Ysyf0a0b4Sb+tDb/OQYukJpMaK4XDoY/uIJ1AU5IrOqBAJLylPHg1LcKewBLnN9Hmauze7ktDW9O36gmfw5M1t5KL05o5WXsnfa4c1Knc1N6qnYZ/G5t/Z1ttbiYnq62rW3lhcoxO5IHjPsnSLLOyFVbXTspnu1f4ZtKTK53YcEu5M7UFtOyznc72csnDK/mU8m/i/7YGd3RkbqcMNsc5jexJlzbbYTWeqf2GQ6NRo8GpXe3lE//dOr6HvX4vWMn23GblgWi/5of+ujPb5o+DdvXbD8J1G9Hpmjzmbfpa4tsze3BefQtWOmg+N76dLLfntLl25z0zpAhONBnFN789gJW2i9MytzJlAM7pk9lPufa9no8/HeDc+kcGEriBH1uklDmiM4304FiBHWUU6cUxBCgEOgsnz/LyYBn45mvtwZ9ghoIDbKfibCfnJ9VXAEL9tQyVxgP04eN2OnrQxj/toHrq5VinoBm84GsnbRHnUZ/vJrc8+Mi9PAw/14zbBOwk+fa3v/0QyJPvRjCPg7k9Wwq6UI+MNs2/PrLvFVxi/sQnZDF5pk/SH7nAWBiHglUul3ynwPdelyO4BA3kd2gsAn2LLwkSeaAIn4BAGkdcUJYx6qN+mX9fS76GMuNQ7RDkgpbOm85jGcR/0sDSFeNyV+fE0Ni1dVLnOcc6wc7gnMqunIerk34vSJpP9J8M2Z3Rn0Lv1Nhq/ZMayYFvnEMjwSIBoz2yGXiZ+pqM7sQheTrLr+43Y3Eqk7/zRH/uN4N7Gs8pNGO1/V6NdWqzXW+8lGNrRrdAglSHLEoxYZygXKQk9La4lrmWfSVk+dUa93scLs6TLQQ+96RYMiV6BW+Lw+Bzfsua9WvTen4Mz66cGfrf1fU2kscbz/u4djJ9xXOTHMgxpVE6yVjaTFl7lRbZ3oq+q3V05fqES5MHrfyV8U1zcOXeqf2ywy3X11R2J6tW89TGvtLFOeZJH+5k2QnfNhyz/krfrcZ0xTa78n/XRtKo6a8cI7+zrclOPMXrOcG3WaRTlNuFsp6XabKHzA53uFcPXggAZSAkt+A633l/fg37wh1f+p9kNf+z/3YQtWd+uNOYW9iyfWhGncxoddyp6317Foa3i8056bOW9aV7HgCDPomnX/PgkgcedV1OupxsBXP0oFjBJQWWZO/x9i6yQHKNQQ/6hZaJJ2XZ6saYuedZarLfPKOFLCrPKmnrfMq4o92sk7TyIFnKPV8/Ph8Cbz/nzuc6+Tfth5W9khlSSQPonFvoyAhTgEgPhjWnBGgIFPEGZfrxYBHfCuyQ4cTc5WHaTpfc2QBPcO5RjsHr/6EFuMBTPKG6nPmkscj38MAO9BHPkCXF2vDAD8EoxoKPSxu+HpNX4FXR0M+z8rYzOOzfdw8s7RTvqWJewamBlWVWDN3Ke7kT43XV7ilcqetlTw3H54SdkbIyRL3+NAfT+FpbiU9rh9RHMkN45b2ce55k5VMMN3KzrxSu/j0p2BzDjmfb/d28p3BscE/euWJE38L/zXHIMtlX8p7mVUoFheSCFaOArWiZ3rvqK/tcjcGVEN/iPQW0/EmUhLquSeG4opn6uSK/nhtyjZ9k0TXDadXG6t6KXv674ZBKtBn/jfeTb1dyLNs+0a+nZXOsDafm5CRM9JnGsRtr0r+Vybaa7ljxQsPrRLdMeK1wXo2l6bZTvbmi+05/tHlu7TRZuZK3bcy+DlZtrcY9yfVV3/z3a/ntkNt2pnlMmuzwP9F/K1jx6W7trdZbyqedHnkJwNbKa/m9s/Nph9+NL3Lu3XHyIBY62M+CacEUr+tZIPTjWQ9tfNT1cbWxeSaGIM+F8nFkdkJmKGL3MD4HL++0gh705Q8u2/a4tLvoU9czaJPj5iyglc5vZx8BZNKw5UmBCM450iff0gff5Ng9+OQZOvTv597wX2UJXOlb9wgaCAgmCDc/SzOBPjNY50EFtwud33y+28HaTc+3jLy23lZ85Xgnnjv56mvYeSiDY2wvY4scD4i5pnIKkLBFjqwfAlD0SaCPOqyF5NvkE4I8vo3M6yW9/zjWJwFF+iM4SiaS+5vQDRzZXdGy9eA78bevU8oxf9Tlm22arDlfa7kFD3xPdd3NGUsOK6P0RJHl9Z0B5m3t2lwtqPzfDMQdrs8BJ3g9tv2naLsZMqfGWTNuJwXdjO1pTES3CTKx3YiFoycRbJNDOfmhb20udvRbLcap7omBmdcbjU/mdpqXU76Y+tw5C6fy4oqh7eVdWSkzSWm0CHOUpJQSAUYpK99jnG36Wz0aDXY0ajiLv/R0TQaI8FDb4jue0EyGgdPixNF4CditRcF0P59Unsj81n/D52RLw8ohaPRu49i14WNM/HwNNZpdofO0DhOfJj8nuTzhcCLLWv1dH0nnE3viFpk24Z/1V+00/Fe6L9u9gmM6ACv56Pd3ZR2n1u9u7Kvf2XY6Ga3vVTuO0+7/hMPEo22+T2TslTqrMbVxZNnT7Y3e3tsE4NOyjzK47/dS5qDr/R5OXPJu6nB/IxK6HjvAcaDdtt2O//RLe749yst5MCbHmGOnvAeDHBenF+XyjCbnZd9W5e07jn4/t8i445pb6fJMFm83r3v7tOljdFnVdFLycgZXZFcpi0n2H7/9rKPko3SyHW8H3Sd4BO5sh8ujDph/2XfyL+R/EAxh+1TbxgYtyHSizaRX4gXOzrvMGbhlQNPnlvJ+DpnjxH3qwAOeieXzvtNptOXtJE95Fo0A3yyDfgKSB5gjrgk47gJa8tv5ofEstPKzr1JO6du3lb3XrjEflJd9L5zYqeDr2A9a93O70l50OpOVpSAVWVG+Hn2uwZ/2FJDSdQ4FZwxkBno7py8GOg4s7QyWe8OpYXGCx4mxe2UMO8PvtMwprIyfUzgxxHc4tOyCqzhcMf5TiLV2mtDLe/xG0PuWI2WMfPe7332TDvjJT37yTYSbfbTa46tyeWr+1FeDdm/lbKVhejJ3j+GNU5wTv1x7kzHdxrZa47txn4yHfjSverrBfuV8EoIwZlucUqnbGE7nPeuuHAOtKfEifabiz3abYlnh9xIwjd/x3c3xFUdu4rfV+sq+WlurNbdb72mYrsp4m7u+J3wSr6mNU3ym8ie6dOrzKs2cf1J+3KLLJvo2W2A1Fyu+zvpZ3ttsdsuKR3f8tMJhGsOK5lN7+ft0nWZ77Xs1F63+ROdG86luszVauys9Od07qdPqO2+l3eXlW0bKbh7eFj0hyG1vgPNBOztkys7JLWseAGpBIncAm33bHnD4ddpxm8LXVD7l57pnHzl/5RalXGdpc+Vv36qWtkJujXF6givXMsDjWTJOc6e9t5vZSyt97pkabR5Xus7pgbPsc0/7ylySDa96fnblxCvevgcrfTui7EqySOSMy36kHDYc5X27leopqKAjEORfECTJsRMg0YNuzSsHUGdgLHko5yZ/O396kMRp0rKNfD06jZLXV/I0A5Vcc9r6tiuXD36oP/zM9lXfkkhghaNPZN8zZ05n56kcn+PUeNeDvAS3ch18z/BM+UFQDDwdF886ctnlWZXiIQV5aNODT76GBRweT9BOQLCLABJvR/dDxPOcMV9Td89YmgyPVflmNKzaWSm+yUC6Cjv8V0bwydhPytzqQNwCj6l7C667ulcNscf0x38tEp2lJEEjYa1FomwROfW8ylL3JPAFqqMsF5VVPZUlZdFxTWPlFCf6mGAytK6M/THzPq1dx/8Uv+bIuJJzcGclHZdUgO1aa8v3RmNAsYcZI09KiCdbbQsa5abxT09XG05Oj2k7WPaTtHvbIQ2PvHaFt1dl0rg+0TFTm6f6zcfT2mrtuhPY1sDpvE60mNbCNCbHqc3Hbs1Pc7ia35UcbHJgNfYrOqmNZ2ojjfFG04nOTW41XK6Oq91rND7h252OWs1zyuNpbMlzV9eV4+R4+5qZxpYycxrrVGZnq+yyTbJO0vRUP09zutJ/t+iFl9YlvpXMD9dOneHlU36iR31OcnsWTmJm69B2ZngA6WB6n+3wau/D+cG3xjW522wiH3u+ZQ7AsfXtKx5UaXzqznPi5K+Lb/qK8fDJYAHlpmxcynpWCjaaZ4Q7X3A/x+BO+ZQ1pU9mkTjt/HB1yvhcZTYRZ+TQNtcEHLWgt88pkMXLWdgeB88QVJB/of4VDHEask1JoHL+kpdpPeQ85ZhyPvOAcPjG5RvjT/2UmYGOu8+X88QUnEheShnKPc9Gcx5PnoDGmgfOWBP9CP54uz7HmZ0j4IB/35rInKis2s318z4rB07+Bj6SGlRPAR34gfXgvJmZlO57wh8EzWiLbXO04S8R4Br46Bp82vpwvppkyaMCS82YaYLQYWX4nRiEO4V/0s5VvK7g9//DGUwGQpY5MQin8idltTC03enrX//6Q7BI17SoWHC83UGBJReCUiJ6k5zqSmE8JvW8GZiP4ccrdEh8T4za7Oex62LllHgZovK8tY/Iur+5IXFtzouukXasNGQUlH4jKGmXaL0/dUiDfXISJkfQ8cjf7Vo6R80xa09Q3yaY5kIwOYRZJtfGCd8lTW5ZU1fXWVsXadjt6rf/qzGczP2J87rD6VR3n+Dcyq7mdZI107hO57LN1QrP3bpejWWan8Sh8XvWP5W7V2TTFX3r9dJh3PXhtFnxSK6Vqc22vryvaT1muWncKxultTnp96y7kvvTOCdeaLZxo8mEwzSu5wYcMhw7/fdtHI2ffYsZjmRzhryPthZa4MMdRMfL+2ln1zRnFV1Nv+44ZhDF9TqOqGcLgK/7W5TNzClw8W1Cma2UwYLGw+7sU7YFKNpvgjW0w9j9fKQMbrUHtnn+Tc6p20I+py0LJ/t1mjn+4At4Ngzt6zdvhXN+kj/Bw2iONPAx+dZI2Zsqr3bYEgWNPLPez+ZpOPu4fI34WJym/tA0ZZjTwHnV58rH6zTKM6HoG//K+SkzpfwgauezxI0+PUMo164HTjyolDzAQ2bPZPLxpqzwbCd/yOyHhtP+H1qwkvp5KLnKsM0RYOwebHKa+PY9D3ZBG7XJWV5+lIavGd3zwBg+lfNFZj0yd7nt8EnOWFoZTo9RXidlJ8Pz+xlOHaKn6Pep+mwG1STw7wmTkaqFImHPflJXkor4atubnjoouKSyUg5tz/UO7xOnYOdcXRnnVdj1eeqo+b0ruEyGOQJUmUMf/vCH36QXaw40Z8ouU1oze4+ByVhHGCsoSDARhUYbbuRlmvFujOmk0HYaUG6cNkfH22/3muF77zVzL0icV7+nurfogmx318/KATkZ0wqfXZ1J/uVa2PXhsAoktPLJiye0nuZwNb872dDqTsGFx+iqqV467+lw3brO3JBu906DGxNPZJmVzmnrKvtP/tnJvwmXdm2nJyfHttkPE1yVKTsbZKXzr9Co0Wy3HiacEiZdclrupW3oPP9okknpKDfHOQMEOTZ/Q1sGNPxQXO837+/sNRxHAgiZ2YF948EN+qBMBtpSv3n/uY2I+gIP5HhgJJ1/6uccOC5JwyY7nL/auUs5r4mLZ1eAv2cdUTcdccc7g3BJN8fR3xiYtlfOBfgK5BNoB8OHPvShNwcvcw6ryinjnQwjzqmRs08WCed66hrBgMxqyflZ8TW08/IZuEka+fhS3zFWD0L5Ncpldt8UJE3bNwNK/j/f9Of0T/5JezjXrB/O3XiVQJHzjQetKU/GmW/Fczu/BXLfb+NwOiJ7mhwgYEU5XizkMiXH7DLNacAbC8GXOmRysT3OH9RTxoPoTpsrdtDNgaWdYcQEtvKn7bbrKVxTAZ30c6pMJ+X7GOO29TE5BFxz5TLVvZfBvTKY2nXHscHUzlXcbjHuG17OP/mERNf++3//76/efffdP3GNN8d55L2lYV6Z4zSWn8rAm+ZrV+cqPqdG/2SIO310mNzHPvaxh28EoIJCUsS6pi2JemsaTwpOjGkpewWl9IYQCVYCixyuSFYTRoEr9KRLk33wFAfA60P7Clj6G+cmWGUiTU7cPWXRvaHJlfwNTMbfCiaj1u9l+1N9b2fSW67Qp35OwftqMmC6PundCfcdDhNMdJjmZ+dopOG+wnFlSCfdVuNe8Vn2vaL3rn6j08pOSZ3d1saEu8M0jgmXxH9Hq6RNkzut7xXfeZ22jrLNVraVm8qvZMNEm2muboEJx1M513BrGWOr+m3dXZGzTw04QO7ApBPL+F3+NnnskHI93yaWdvUk63Ut387F79yeI0gcwQE8/Km/26GTfsr6fj95wrNMvH2cVmwUb9ft2UlmeZkcq5f1bUApB53ezQ5vtlHLSEkZ6bh4oCJpm/MNzXwboQcyVJazcJwnVF47F2TTKbikh9CyIWXneTaKfAbZk2yTE3Bwtz562Ml2Lfrgtx/4LFyo43PiGT6+XvyAb+dDH3e+EbBlJOX8Ov/5XGWWnH+3AFdm3kFvxpxBpXYweI7Z2yMTibXmvOPXCD5BQ/r3NUA5l6GsBeZDc0iAJoNm77HDsAk0Uoe2PQvOA6ue9eRzl/MB/1KPNxMm7wsPXhAk3mP7HLRhnBmkdp5oD8nuesaSw6SMs3xT3HlvZeBknZP/V6AZsSc43AKnbaQwnNqY2pvqrvq7cv0UJgPnMfhcnYfkv2ZwavF/85vffAg8KHNJC1HXFZRoAYfJOOY7jRWu34OHGqyclqttXCk/yQVwSWhOD8KVVGJP2VQ53uanTKZ8ZeuKr5gzZTpxlpaA/ciqLwHrb2PL+qtxOa3V9gc/+ME3b6HgSYP6Fg95ym0zHFt/E6/fsgaeC3J+Vwa8K7AcUxtj4+1pzeX96f8EKxnb9NhJG01OJDjd0mg7HUejY/t2vCacfL5OZPhKHqzamebvpN22brLdkzGt5NY0nlX5ZgNl/YnPvdyuvxXvT7y608unPDrh3PpZzcWEc/4+mZs2r5OOzjHlONvYG+z4KHXGtA5be81+2NFhdf9t0B0u/x1SvnvWw1X57k5wZsG0Nlt2TepsyuaBwydblRrv5zam9pDJt9HwH8jsh+SzLO86lD7aHNCO45cOfvJwBoMYX9KE35mZlcGIDFZ4G02GN7vMcfcsLO+T/gi6ZLDFxygbUbbi7/zO7zxc9+Mz9C17koeUHLHBw1GCS+CsftgSpboc1i3nn3NzCGQ4/TPgNcm7nAeHzPp3WiQ/Od3yfCznicZ3eX5Zs/88q8lx8wBa40EP+nLPM4za2Wktk4hy1CWbkmw0pwvfqsMh67lF9o9fB30IEDEegjvqKw/WTjlGOR6i047TnqCxnxGVfCxgey0ZdgS7cu03GzzX7ZNlLO0MwJNyE8JN2e6MsCtwD8I9pm/6yjTTCa7glWM7nad7Q1Ogj4U2b03BrIyulTEMaLEp1VWBAAS2pxSmAmttNIXr1x3ne8AprZ+CFyZn4QSnxIXD0yUEeZqDMCTYpDr6rSdCJ+3ym6dIUtgulF0J8Hvl+DTnQaC2lFHFK2U5HBwFgoLyrZUnMMnOndx8KdjJn3Y/763WSBqu3k7jwTTQE5qeSWNpou2J/jvNMEgjMNtvhuOurSzbvrPdhsc05ix7C/9lHxOv+LUm59v1XJ8Tbl5nciwnerd70xqYdMa0ThpPc8/bW62XaU3478km2o11NQ8Nn0lfT2PM36c2Z7uWOK36XPHwzn5ouE+2iH+f8teKz98G+X8r5KG36dyzNjNDwh8utTXh9PWsCPoEPHOF8r4GsRccr+naNBcuWzJo4fPZZHKW47rTx/H0DIr0Mxr/4JA7nelvFWyDdjlfzE/bapeBM8aRAQr69mDahFPyEG2CX+p372OSXS1Q51uTFFz61re+9eZBtPpXNr12PvAgmv5Vhq1InB3q25hkI3JuE0c+5Pk5yTfMs9On8YLznI87x+Q2MfTyc7pyvqnrtPVMGQ94sr4Yj/OF28S05wEh6tOfz0t7K57/zowpDwA6P/Jf7fnh6Z6NlGs8M5NU9/d+7/f+BG4+hvbmPB6Y05fPA4En+kn+9nZyW5zPsdrkzW8Eu5ru9nouI13+PklgaTIaVgptMi4mA3qq166vDJ3VGE76OWnvpD/6yIlsBl/D57SPe9TdGSXN+DwxZE7avcI/bVxtoUz3dgakPyFoY8h6rb1mGJ/CzthMWBnz3uZVPO4BJ8Y65dj/6woHZeyBvWYITOPLeVs5TSv8V2PRdfbS84RBZWRA8BpQ/dZTrFvgZJynaapPDTuny+9N89XkgRvACS1404z1JjMoO8mIFb7Tej8Z/y3lHNc2hlbmZBxTm1Pf2cZK1rkTMOF7CieOQRtr4ryyPXZjybadzxK8zISry6TJcZvKt3mbdOlU1v+vIOuveMhp3sq2th0ajdp97yvndiUzr6y3FZ7e/4T/qq8VjjmupGlrd7du3zZwJzSDLom3O5fMb251aTKGe21rUDu3yZ0xIAMjfDf+xgHzrI4sk+VzS087ILzxr/OI87y3kW//csfc67huXc1HG4NnR7isbbLK5aH3l9nnjoNf9wDgibxpayplhPfl24gyU4u51TV4SgEjfbPtTQ8U2RaXuk/XCUAQ5PR5Vht6+KnAkh+d4P06OI+2AGc+LM3MFOo5Dl6m8a/PbSZHOE197qCrgwcsHHcP8mTwsAVjHXfabEHqJmd9zRNQkq8B/XgYnLT24A5vjtN9f+PbeyNQhfzyOYGn2KbGm/88INwyEZEvvmZ9bPr4m+HgPQ9StXlva8izuk5ttpsylppxtbrujLgy2lLo3GLcrCBx8vqJ2ymc1pmMh1vaugI7g7fhSL2V4bLD9d4GzmRkcy+VxNTGZKhOeKYiOqm7asv/38ILz8U/V+dpNd9+3/83Y58taQhNhLKnteq+H6o+4TM5Ejm21b2TOacMxoIL/XzqAqyyFac1tpNRkyx+bmi8fgUmPcL/XR3/32jS5MRuXe30Thq4K7hV1+QY0vhPPE7olm2261Mbp/Payl2R1bfcp4/2O9s44amd/bLSlafQ5nHC3cu2MUzjbeVXdlHWTzrs9GK7dyIfVtenceV87uizu9bK7OTE1TVyak81Xmz3dv28jeBOmAOOlztZLXiUdab/tOFZBK0ctsnkj/i15L0MOqSTLkinP9t3B4+5TsfSDxLO8aXD6OPIjBWncVsPjls+HAAvH7MHoDyw4LTlGtc9oEO7TqvExe0pnyunX2a6TeWbPMvDzb3/pCf/OQMpA5j0SxCJLHxsXR5CEgQQ6Df/aT8DAYk7ZXz8uo496vZC0sjPxPIyXq7Rwcuu9GPOf+NB542cL3gks7JYy9z3PiZd4Nc9+OS00HyQXaR5yDfQJV87z/g2tR94nfHk64xgoY9LwA4N7cTwNnzdIzN8DVA3A8IeKKdf5ym+PdiXGUq0d3LcyF0CSyvjdTKC/Lu10+6v+p5g1capoXna3i1wS3v3xuGkzRMmuspsrd3TOb/CGyucdoZh/m7C9hSSv3eOTJaZFPKt0JyB9l/Qno7cAyZDGmUgZat966QKS2iyT12gbx3erSc7aVCsnA7uZ50GKyXZ5pT/LvTZR08Z38/cFF/23yBTxVeGzkuD06/Rc1V+ZdBz/xTc2Pa+WrmGg5f3Oct1OuF2olOSD1brP3HY4Tf12eAqXZu83enVFd+fyKXsfzJem3xJekyyqI2p0b+NqfXR+mn9r2TBio9OaOr3mt016apGjxU+jSdu1XdTee/rhI47XjuxGxK3iceyzqktMuG4+33FvrjFXntq8LcvJf6erdH4S5/VVjbf/pTbcHKrl7fJNdep/tp718POhxlQcN3jGUxeJgNltJ+yrQWpmr50pzC3NiW93BmdwMfG/xxP6uqWceL4+ryAqx9AnPWdVjlPTU5Tlg9t5Bk2BBKczl7e79NfzoGPL3HDflWwAHtW38yTgJe7+MHOnvVFm/52Pw+aZRAy6Z/rxYO07U2CPi+Nz6GJB/cyq8vXlR+67cGblNvJX46zz73zFO077k5jp4MH/WgveTBxnoJVtOPrRx/6eK8FWNmBobL+MDzpyoHb8AxnJjkPO525Tn1/8M7xG4xFbbego3Bz8IeU+uC/MOaUr0+SsbRTUCeG7BVD8Co0w28Fj+nr+0GB3wvSWH4srIyhNCRWTkaWb+2czDGLnYg1gptIc2YInLQ3ORYObhys2rnC0yucVv+nawmu2CZ8V47AVF57y//Mn/kzD598mwL713Ob4mPXXDo4k9OUDgbXeSog5aHtcG6IcnijPvmEJ9va4ee87rhRJu+9rZCG89X1uloHKQ+mp9OJw7RWp3bzdxpZbaztun+v+K99T7RJ43uSkW3MTc6s6Lwb3yT3TuRQa9PLn6771XzmeLP8JK/yd5t3rk881661etl3a+eEZ73PFf/lOJI+jQ5tjI3XdrTbOY0Nj4brpDNX/DLxeuKyuneFH1d0P4GTMb3tkDwPHVo2Qh70zHfaZdhw2X72IUiHMfXsar69TMvE8LotqJTttPa9vUmmcs/p4cEZ3941BX98fJ7NgRObtE7aZgZJBjf8DJi0pfNsqxVNwCEzafTfH+hRL+eX/xngcpzcdqAN56c2h15P3xqTbFi9jIZ74IGjrvs6l1N2LYd9Q3u3n50G7Tv7nuSy33f6Ow2o69k8jNXbaGf6NLwSv5yHSQdMNrnjr3seTPE3wvkY22HjPl58PX2TsYRND86t3cTXy7zHgro8VCb448HZzHhzXmEdEWzyNef13a9g5wRnKeXZXM6zvjPE8QOnNpdPmrHUhLXfSybLcrdcuwKpZJ4Tvp+V/EuMbWfondSd+DHLTnzqgkARb72W/od/+IcfDuTTE4V33333zSvuV4ts4uVmdK9gKpNC+qTsDq4YtafrKmmTynDVtuitN/N94AMfeIiq65qULm/J2CndyUBLvHe87AKe8m0croiVbSXwt4QIZwXL/DDHJhcnurrhONH3bYJcGytDeTKQV8Zlu9eg4ZDzOZXP65lW34xLxzvH19bY7n/Wu7JOvb2VPl6t01v7XY3BcWvXV7JlsjdW/WZbu/YnWuX1q/JyN57sYydnJ3ymMeT9pN9Eq3RYErc21ja+5MUJr6zrT+ebjm9jzzGljdDKZL8r3b7SIydzMdFkBSvZeKoXmpPw3LZxAm9McvnqDuCEX+rE5GuBn9OYTrFnL0wyiHte3529Bi3A5d9Zrzn3lM8MhZxnz4ZyvD1rxOs67vSVmRvOux54yiwZp8+Ef5ubZnNz3482yDOU+O1zmDTVdc+G8de1Z1DI8UkcvO+2hlMWOi8m7+pFLvIhBLJhyVwhsMGb4uRrcDYTHx6qsh0LXj5dEw4+F+Dp9OCaBxSTdtkOvOH3aA+eYTuYl/GMHg8Qqi4ZjPSd6yn5y7f66T9nGbXAo8sAPj42f8s0bfg5TbkGmGP6oa0feH3wN9c1300m+XzQv/wdDyzm8RqOS9KdTwaJ/Drzwxu3mQteLqTfwoOzwDx77oquuBRYagrsMYqpCfSmvCcD9LGG72Q4/v9wX5gM0ZO5u8JnqzKTYcY9ItJ6gvDOO++8+shHPvKgFIj86j6pjNOhcA3nZmBMY77K05NB1JyDpiBX/yeYxjrhtzN0WxneoMGrVhGSrigmY/p0DJNRjxCGH3iVKIYKnzTmAOGsNwrKGCAopqBSngnV+LHhnvcab71tsHN+rrZxyzindb4qv6q3MphXhtzU945nMVhO8fd23ehuOE4yZiW3rkLicVI28btV5rU2d/W5l+uxOUe7vrOvid472rixuuOXad6nsa/mZ+KZRpu2Rqc2Jzyy31buRH+u+DYdrqmfnb6axnjFxjmh3dTWbtw78PpTtvFzgmcvCDJjKLfR+Pw6rTIjh+v0QVu0kVkDlG8BHJfF7lQC3MuMiDz7hO9sKwNEfi/r5PzleD1o1Gy/XEceJMtMoibv8iFKzhPQbBrHyV+v7jR3hz3HmHPv85XrguvJN96OZ7/RbgtoeZ+0TXZJAuPhAbWCRm674jvw5jACTdiZKi+7Ub6H7ulhqj4c/ZC0cv5wPspxZXDe5z+v+XrxuaYtzovKQI1no2E/A4w7M+Fynl0OOM94UMTb83vJA3kIu6+xacuor9ncbsb4FYTBH3D84Z/3v35ztT6eiEBfvnYYX26ty/XAGUxkPjkvexnG6IFJxiXeAnfHRR+CSrSnvsDf5yJ937tmLE3QFNwVw7Qp36mNk3Z3xuaqjcl4uVf5x9b7foErRs9U78QA3xmVzaj2Ba6F98EPfvDVpz/96YegkkfOBUpX1cJsZ/vQpuOe13Jsre7KkF7RoQkq/591V+vgsQ6l123Gc+I40QNBeyrITtZV4pDlXLlIsStrTd+UZy+8tuLJGPAzlADhLGGszCV4iD3bqewdl9XcZvmJzm1Mbxs0x4D/bX4SVuNshufJWvO2VvWacX465ix7RUa1/yf12+8c34q/pvZ3OEx9T3y50smrcU14rsaR7bo88npuYE+w46F2r9Eo52Sai4brRN9pPa30ys4+ujLvifMO/9QLqWMnemYbUx+5ltq4Eu/VvVUbp3RsbTe+8DZ3dRpMY089/FLQgkLNTvDrAGUyoJLZNX6NdgRezh1K19cZSEp6c68FqBovt8yhJufYLkXbmUnS+D63o2HT+P2UAR6UYPyU8TZyDNNh1z6+dJYp53Uoxzgo61utvF/a9/G0rXctaOLnOLWgU+Ls43I+8SBKjo8Xzsh+VBkFhpw/9M3B0AQgZUu6cw+uymjyzKXk6ZW+zSxrvv2YBudHb9PHlAEk5xGfqxVO0CvxbzTPNdV4i3oEsAjmZEaR84AHdVx/JI9RluCgH4PC9jLAt9D50Rfvfx3kYd22DCWnP7zu2ZH58Jr2XF6Iz8QXBJ50nS2VzuPQyN9e52d6+Rpy2oj/OPR7lan5qMDSymByAjQBdArNwGr3VvVW+J/WuYr3yui/gtP/aXBi9Ez1Tmizq98MNecvFIH2QX/2s599CC4piMSC00JUQIHXxE/jaQZCMwzvTb+Gx+q/t9vu7dZ4a3uHY66LyUD2smmUpXJZrbVUHolvwx0FI+GstGTxA0oFg4Bov8ooK0mvhfUsJFd8GRRrNHUB/pg5TePppWXKSs6u+NHL7sq1tk54342kFW80Hp2cgAnP3ZgnXFvd1tauXFs3U1ve5g6/CYf29DidttZu63Pig8Zb0++JD09lZD6Fn3DM3+3JY9M9bU7SWcy2J5nrvNnGtHJAEse8n/M70WC6lrgltLFNuEztNdk3jetUD53qx6muj6dll1xpM+tMONHXid31NugKp5XLVr/u43PnJg/nzmwXygN+L523dOLAJc/+4boHFxw32nfnPXmSdpsu8XH7dhifVw/E5PhoI53ASQ5xL4M3bY4yEAZu7pgnzj5/rnszi8z7AVfPVqfN3N6U341/MjCSazNp53IcZ99x8THxm4CePrIPtf1N9iMHJ8NHOPNkMsnXcD4m2KTfqgsfOM4+79MZQm29OO09yMJ6aPqL8XOvbRP0IKk+nsnjfWRgNMcEeMCIsnlOELjoP2+N9qwhgjk5f6kjPQPL+04dIx/QZapn2xHUwVf4o9dvrmZbHm057/q687miDc4Kc/+DceCHiL/00e4OApD/43/8jwe+8TmAJhlUoozLTs/ESzo/WWDJmcL/g0RTUpOy97p+/YqimwzFU7i3Un1uJZ3K+Clh18dkFDZ87w3NUGzKsV1HOCiQoG1wylAhCszh0b/7u7/7sJ2JPdKrMUwG/WqdTEbViubN2TiFXfmG34TDKR/k9ROcJ7qlcJ5wWPWRykUgwaunTPpIUKci4qmIgLctSKh7m240JW4N1xPeaONy2k7y+KUhDcuTOb9F/k99tsDALXpmtR0h75/y3iQDrtaZymX50/Gelpt4OXFNeZa8mvprJR9Orq3kpxvOK75I+ZJ2Spvj/N308ilPnJRblc17kw3WxtrqpazMdT31v2tzkgnT2BpfNVjh6LRrvJj9Je473Tzx8onOWumLdn+1pvx/g4kHnhtyLtzBbfzrcjizkdrYWiZLm5eW8UQbWa/ptRVvNLuurSl9/C15KTvc6Wvy1cfc1snOFkt7p2VyZBZT2wLXcPT7Of5mMyUNPQOKPpJvPchGoCfXQr4dsG2H8+/cKsn1dtaR/svRJ6jEfOJP0Bbbo2RjepaYz58CE/pNIEGBDWiVWyaTto0nfE6b7evrxNdY8ovXzUy15A3mlW8euGaQDoDfeJOaZ/yQreX9icYEdWjbs24IcjqNPaDMvLLmuEYfZP149k/jR93n6AsPgH3Psh59vJMu0G/VJ7PIeZQgkPOYznHVf/mnJD/IH/EzaH1+yXpzHzbn0Ne79+nnMd01sNQMn7YgT4yM/O8M7vUmIbQyvBLX/5NhR3uHpzYgctHfE4+dobTjozSQG07+ikbOVdIC1ELVQdJf+tKXHn5nYGlnXLa+dtebQmjjmmBn/O7wPJmjZvS1+82AO53/nUGeSjEF96kMQKBKMegJEq+HlcLg8EFXThK47FeWQM+nP47rju/SMWhylt88EVO/PH3gMPNMDX9p+TcZiFPZq/ju1lG2ueLX6dppn1Mb09w3XCaZchXflTHf8Nmt42mcaQOc6iBvJ9tqY1kZyqvxCFYO5SmeV+7tcJvKertNbre5bNeBHV+tdEnKpGaz7cbW5iRx8n4aTZtz3Pgg+5tszCy/W+8ndutqbU980ug3tXOi+7LsSuYkLa6s3acEnH13BN3JSR3puHs5Xc/tTc4zme2QmTUtAyPB39wEgEe+Ej4dZ6e3b3FrNlGbR8968ezQ5EfHJ1/H7vc8YwH6UD/H7gGBSa8mPyX/Js5TVpXPgx9cDN5pb3l5cHJ7zW0iP48ns63IPpF9xVt8M5ML3H3O/Nudesp5kIE2fVsTfoba9oAUdGf7VWbVeTbdJCs80yS3hzn9MtvY/2d2nvOM8xVtejZVzq/PffKVQLSX/c08c1/XOdja55AxcUA2Z5nqGucEYR8zrpbZSN9k9vgZRb77IOWIrwE/z0jgZ0l5kKbJOvcrWd9suWMrWh4OrvJKeNBWS74JguWcCPyeIOVLC1jmet/ZNHd5K5zgxIACriqwVCh+fWrvFJd7wgqfl4Y0FK/W8//+nWP2PiaeuMfcNIPwVrpTTwtKizId9G9/+9uvvvrVr776yle+8mbbk4+jKfWG42P54mr9ycnwa/fq6xSP6fpqu8mOX9yQ2cmk1fwAKDDnaZ4e8JQpX8HZ2ms80dbLii6UceWpbDpl0ZECK9B5T6S/+thfWhZNsvkWHdDGNMmXxgOpYJtxPPWTfTUcTvl3MsrbvYSp3pW2Vpk6Xq+Nqzlq/n/CpeEz0TiNveyn4Zv9trV3QqOJNxJWuHu/zfFJvN1RmcY69ZV10ph0ek58eEoryux03Uq2tX5XNExatPo7/ZI82+Yp+5xo0uyhNp7VtVM8T+i56men//L/S9jMQHPw2ly0LczUzQdK6Ty1upmR0bZoJW7ZbvJQy8Bw2npWVL7hKcvmtiYPKmTWReNF8PDAhj+A8+0vp2dcJU6Nrxv/tTUF7v4Wt0YjOdV+ZtQU8Eve8Xny7BTsKc4v4gxNleG/bMDvfOc7D2+BzrcQg1sLXupDWdlnfh38FeyQDad7al9ZJgqGyH4TTjzY5LwctjU1veJb5LwfD2Q5H6pcO18p1xD1fc5bwNbrpc4RwFfeXvbNmOBjAkjQHXyZP82PB13AkTe6gUNmmvlaEBB0En/BEzxEJqhEuymTne58PNtKoGsEiDyI5PRJueO+JxlLrFPow5pQlpLOcRV/CF8FJn0LnMu83G7n85Hr1OfJZYjLmbsGlhrjNOXvsDMAVjANYDLQ2v3HwM7AnHB6KTil9SlzNGPnxGCZrp32m8ZUMySy3MpAXhmzgBaThPxv/dZvPZTVov3ud7/78F/fnpVyte2n4rlTWBm0Ew4nkLKAdnMMTRE3XCbHYofDVLcZPLuxSYhrrhVk5CkBCgglTx8yBvINDRMdprXZZFnep4wMFZ39JKMDxcPZYMJbwSV/ve7bAG0eT2V2ltvRshl52X6re8IvrqRTHp2M92QMEw2uyoOVPD7VDTtaJ+TaXsnFaUy3XFvRZ4Xz9KR8ZcekDmr85WVPbJIV/k7DNNxps+Gwo0/WmcbRxn1qN0x81NpsdX28zQlp7bYyp/ZKttFoNLXT8NnRvY3dy0zjm/D13y1L5mSMLwnuwPj69LNpPBCyc3a5xzV3ltyh8rJuoyR9uJfnIjlvTFkM3oe367oFaBnXmbmXayfH1nSZO5v0SR+iq78Jy8eGE0sdHy+4uQNP/Vy3KW+ddrm1pq2TJgPbHE/r38/Q4U2/sqM+/OEPP9hUvIVYtp6uKxtd24y+9a1vPTxcJhPEcXJ+pD8P1LHNjQwlcFTgSB/5FXoo6IErHnCrrHDgUG8/L6fxlvOg86v/dnolb+fcr3R0zu9q3WT7joPX4bpn4vg9ZAF2L2/U8zONchsca0Pt8VA4s53gB/0mqKSybG3zw62pn/T37XTqm3n7f177B4xXvOVZiqw9aJHb8FIPck1tct4T9eERp7nLVJerTaZBu6anm355ksO7TyCRmoyBK+1RfmfsTIviqpG+KnuLwf/UsDJQV/93kMyWfV5tbwU7wxYhQ7oiQsVfAZ+Ku+Gd1/UtQfDrv/7rr77xjW88XFOGkgeUVm1MdLhKn+YUXOHlvL5SEveAlSHsijYVUs5RkxO7sXk/bc4brGimb8235t3TrgUS5q68ZITwtKAJ2t06aQq8GQ7+X0+59PFXvQonKTIFl0gBXvHjc0PjRb/eHBw3KqY2pzIn9U9xbvLjFrqe4HFFj03Q5EW2sTMcHd+VoShwZ6EZ9UALKE9yo9Her2f701jS0ZjG6P+vyqL8n+s425v6m8rt5FrDL+dsRad0vhpk+bzu+K3w9f7b+my8tlrHK/5o/yebM/X6CR12tGjlT/BvNJj+Ox2znWkNrfp6SV3RxoBcybesNaeJb8/iYWwZtOGeb+NpmUv89vXjmTUuX8D3RLa67My+9JuzXnbyMOmUbU2HXGfflM0HUozH31DV8HCaO82gPTbT6iBvyjmejq9vF8usCcctA1dtC6D+K+NFASW9+fkDH/jAw0Nkxs/bvGRPKfijcgoAff7zn3948IwdmMELnydsXn2rPQUU8FXYrqWjNdQeGSbOH9Bd32QzEdzz4GHanXnIPO2lDGG+fe14wNXnKOnYdC91/YD53CaXPJRyivXLuUrUz0CYvrG5KeeBO9cZtOGZR4yXM5mYd4JVahs72rPUnNdcrpBV5jTXXP3AD/zAmy2Nzh9uL2UGlx+QrY/akW0Pj3CWq9MgZbjPj28hpF+XYfCZZwOCjwc6M9h/CpcCSysFdGKErRT8qp2d4dcMuxOcs+7VexO+J7Bq+yXbutrvBCsDrhmzO+MQYaQFK8EvBaHfWgQKBsjRJxDUFPeEI/dQgkSDW4bS7qlgCuUdrVZG/QpW4zm9lv3ewkPN8OWb4J/mSQKS16lKcHsQ0PtszkaDaV5P6DmV0TXhpb3KEqAK4kgouwLnyZaMAn1PPN2M9xN+nIxT4cPWNzdeOBSSs6Hg/7cR2tjT2Jh4Mum84ulTHnYDZ8U3Tc+kEZPXV+vzimyY8JjGkbhObTa9OeEzrc8VnRseKx3NtWa4ntAgy080brwzXc+22xi5d6scT7yndnfz1dqaeG3SWzm2lWw94fedzZbtNNymtZ9jbPw26aZWJvFbyewm83fyfCeTdnx/C+9M5W7l06cCd9RyC0/in5kX+u3ZHP4gq2UjeTnqA243+nU/7Jl2WqZMc/qdX6nnZR2nyU9KW9Pbz0wEH3Pb9pS0ZHwZlEmn0ucpdZ5vrVmtXy/r/N5o7mXd+U1+dxw9g8h5iWCdb1VSUElvf5a9RKY3QSfZU/IlZP/pJS4/+ZM/+dC2gksKQjE2p0dmm8jelT0m+0x1Oa9Tbcu+1DVlNIG3j5d2fE1w5icPNdUnWThJb6eTn9/l9rZncKVvNrWZ950Hcn7oT+ABJ+dTn3vd5xBu5z9vB5oQ9GjbAJ0Xkq+o60Ejdhzw5j4yjPJtaY47uDht6cfX2g++9k3JquLcXq7RpssXMtSgjdOAjDmXjz6n4JcZhD6PKR/o3+dk0qXQ3wOhT/ZWuCYUp+uT0ss2V/3u8EiYDItVu63uaZ0JGp5X21jBPds6NcpO4JaybSyeYiph/7GPfexBCQi0OD70oQ89CF+llkpw42C3tlbG9CqYNP13Ye5Rd9pDmDSaNIU/9dngihHq0OpMW9V27SRvkG4qxaq58gP3BAosSXErGEidK+t05/Q042Y3djeCJMDFR+ztF10k8PVfSp0U2QzgNCdikosntExwowm8qCf8ZMy4on0boc1Fc7wmHZH18ndzzk7kfnNOm7Gbztl0v+Hp/yfn9xbemHRwo0O2MxkT0zxN17KfVV/tXpaZxraqO9GR8nmuwIpXdmsx601j2BnpJ+NuT4tbHefZnX3m13ZjTkeytbeSqV4310/i0dbybhwn8jZ1jPc30W5Vro0jyze5lrDK5ptwaPSZyra6K9xfAjK4klkwHgQC/+nMnRz3lIWRsgpo9z1TgTYzUxOn1bNwaC+359Cujy2ziLwf3ybjY5wyV5yGeTC50yvp4Tjz8UO9ueY09Xrel8tZD6IxZndOc56wwdmel3I7eYc+fTufz0vT2Tj3ekDoAR214S/oIfPks5/97IMd+2u/9muvfvu3f/tNRonrFn2rvPwS7EUCODyw1Ef3ZRcLB2UkkfmOTak66hO7U3Y0b6xWHd4Apm+vx1yAC+1wVo/qyPZeBRWSj5xHfb353AoIjvia9TXpwZO21tNv8gCyb1WDd8CNsbt+hwaeceR8z9zrOoEk6JfBKr75eGYU9KM8H5X5g9dzr7njQTr083HDH4w1fVbnf5eDHjjLtxz6eB1HX5u+jrJP5wnXNVz3LaFPshVupfiboXSiyFaGzVQ+nYLTdm/B5Qpu94TWz8rYukd/0//TufSyWacp2davX4fRyc6QgGYR6fPRj370QWC/++67D/uimzE58edqrGnINQNfHy1u7cvWkxCyS7QYpTgIVGQmVeLSnIUVXJ2HW9pqhvWqHwk00UF713laxP5jKQfepiZaSLGmkdHw2s3XZMSf1PNyjNMPwXNF459sg7RTBThJX0a5UXblHKzwx5DRN4eLo6DcoDod+1NDyuVpDq+sw6neY3TDFUf2RA9N7eQaamOc2k1DflXWyzXjKHFbydtsdwcrOT71fYVHT8u2vgS+RiZH70q7We8qf694yX83uXFar/H2KqjRshRS/qXhPfXpbaSMnvRc07ETjVd0yXYar+94NMu19TvVndYCuKALZcNwnl/aKyt6TjRa2TxvM+T2onaekmfF+Lz771wvXBe47qZd/9+yYrzfbMvnZbVNpMkady69rfZ2Nq/T5tvbb+PP7Cwff15nLN5XZhjRZ24NyqCO4+bBp3y9eVujjl/SLec66SRoZ0YxR1pv2t7G8RlkMamcspd83mXHyZfQWtXD6x/90R99E5DKNU4d2f485OP17qqjftWe7pEdIztTMoCH5E4vfast9a36wtkPsNbr5hUE0wd7kwAZB4DLH1JZ9aNAFFvr9FCXQ6t9HTTeSl72NZkZPZ5x6Lw6rQFfP8LbfTr4xQNSHlTyFymBi8tXzalvIQQ8Q8/f6uy8m/w1PZTKoA24//HrIJX4UL6QAoocLp7BTj8jytc/gUEy3wh6ah45m6sFrXPOaJe588C9j9PlhAefqMOOE0+SuGvGUlNsDk7olcLP6yujqTF99tfgiuF6C5wa6k+Bxy0Gw1Vj/rHgC+4Epyas/b8Ynr2wWnC6xmFv/sYFCf6WJTSN3Y2Ods/rNp7WR3h86lOfeghwoVgkNPR2iS9+8YsPAabpsGc3JFxhe/8ruu3gMcbl5IDlvEIHCUApPc2FP6XiW2WkQPQUJgXVZGQkHiuaTHVSATTjvymJlbPhY1Z69cc//vGHffl6i6AOfpcC9+wmN/xO5s5xIVvK90wTVPWnUTu+eQ5oga7mfO2cu5U8OIVVncfIwh0+aYynLNz1PTkL2e5ufFOZ03U9OUENBx9jGjzpfCVOEz5+3+2EiXcmejjek5yfZMOOD0/KtLFO/LDSObeug6znss0N6Cy/4teJFjm21f3VnLX6q7LTush7Db9W/ooM3fGv6wrpCH1kq+iAYH3k9LncbDj4GtzxwFX8XxI8mwBH1e9pHNKjPKgSUN4zJfwhlW9NApznuO/nAHnGA86h1+O3Z0Akb+W2mWn+WuDEnb5ci3xTFx5I3Fb2zU4m5tk4qwehjj/bfVzuuw3ltHKgvPfp+i7r+e/c6uS4O62cHjygk38g4IBt4c7WMv2XbaosJV1TYEnfst/VhgIFChJhe8E7BJX0wc7Xdd7YJfuMbWyOG2PkLCbOz1F590vIoIfnecAuf0PlhZMCSbJBdY+AmNqWHSqbXB/9V9aVAlW67nZu8nHyEt+u27NuyxLLOU8+FvAgFlpqDKIFOBCky8y9XOMtO27SfU5/goyNZzPwBL/lNj/a+8PXfSJLxGeaHw8cEvTyN8bBi/rWvP7Ij/zImy2T8ikF4osvfelLr37jN37jYf5appPPofMn8k7A1ry2Vn0t0gYBqmbb330r3Mqw2F3LtrJ8M6pWOHk/txhej4WnVOKnjsRpOxOctJ/j3BmQJ3TZleE+qaBSDETzvYwWNBkxHrSYDL0dnpPz0toiY0UCkf3QEvzCQwKdvdUI1uyDRez7cclSyTrTmCZwYygdxDbmK23nmkNAohwQwBh9og3ZXRxgmPRY9d8MpmZ4rAz9ldPhhk0qP69P+5qrd95559Xf/Jt/8yFLS6AnWz/3cz/3sC+fQ/fyCeFEv7wOqB05HzztRvCLrlI2OCZujLw0uGHiOE0yw2kwzVnjj8c6UZPRu+PDSf+t9FHy16rP1sepfG4OaNPdO3yTn7xetpmOikMLWvjv6al/Gq5Jh8RjxSfJg41Op7LvVhtl9bvN2aqdCa/2e7VGJrmZNNzpoFzvO5nWxnJqX2QbyUO7sU//oX/jq+T9FT7Zh35L78lh+PEf//E32RPSFbr+m7/5m28cqWnrzwQrG3rih4kuLwU5d5kdwfXmJLojyCedpLa+GHs7I8bbS4c5gyeOVwY4Gl/udEtzVjPo5nhmwN7vZVZDrvVJT/g4cy15Gz5P+Zvy2Q73/S17SatVgC7plGPIzBAfE5nyskP1gJNzfWSjc+AyGSPKDOHoBtlZBANUjrNYGafKKwhAhpHuefAAOqhvtkpxjTqcmYkDz0NE7D7ojl+gawomyc9QkFrBsH/+z//5gxz5l//yXz4cEs65oIxJx4hwlg8HVfvZQJMOTZs4+S7nx+eg2QjOx2pPOCtQogPVBR5Ecj5y3vF+k4ehuR9GDc0JhHp9Pzg/7R0PCHlGFmMkKJVb437/93//wR/FJ9U18Y0fAu+7GqCp5vRzn/vcAz8pi07zpG/5TJpn3VPbX/7yl98EIP2Qe9pibv0oEvD3N0W6jOVaBg9pu9lodwksOXPcWn5X/8r9yRhuzOz3dtDqvjQ8FhcXwM3w2Cm7E0PwXkbLZJRqISkbRAuDp34CniKczO/KAZqgGd7URzAqeKTFT2CJLBL2TCOUm6ImEKOtdFJ4pL8Slc6+E7c0DCbDuNHWIRXyjh7tuisgUkI5yDuDHw3v1nYqu0kBTs7e1Xl2Az/x8HWkuVWmmoJLBDb1X28XxFmYzthaOZHJm1JGetKkazIkqCdFJQPIzwZo439OaLSfnM0dNB7xe6vyjT+mPlZj2PFaa2el8yb6tDI5n5Mh5e208U4O5gqvhKlsk6NNvzQcJ1p62enaal4b/bN8+78b7wrf7GvCpZU5WRvJCzv95fczQD7x5yRnr66hSUafzt/pOL3d3ZaLVR8r/X5yv5X19gXSgXKcJMtlG/h5hGzdmOyyK3K9zd1U7qUhnbg8ryeDy27juXPo2TXYU4Dfa3LH6zT7xOs0m8AziBufezZUy0rL33y70+p9THQEwJU1kW9+c/sscXEa5D2vnzR1+3aFm7eVayb7aLI/M2JaxoyDB68oI3uMDBLZb1p7Cvh++tOffvAnRCv5GHLmCfKovICgUY6bLCLwl92ne+ys4EG42mQbHPNJ9hxHaBAsVV1dU4BB5f1MI7Je2GalcnpQK5tT5WUXKiAFDTjeQT6Fv1k415T/zyw+z3BxXms63oMxlPNAadbBh9KYePisMRAMIvDDFjA/h0r3WzaNZwPRn9vi1PfgEzzVMvhybTudfH7e87qOrjEm+T4kDfjacVkn/tB/7X7QNfGg7HrNm+ZUu180f2zLlD+Af5Fyz3kzedXHSfkpW/HqQ45HBZYmWBkg0/Vm6LVBnCjUyVg6Mdpu6e/7EVKZvU30ODG2dU0C8+tf//rDkwQOwtMC5M1YPE1YtU1bJ4boZAB4WS1wne+EkpGQYE+sgkMIvuyTfrXAZXTqiYKCU7omJadxouCyT6/v+N/C71dg5XAIT3+NqgQpb8dAoakOTw08/dQVwy1yYGV8T/UmGTG1lY4M2y/Fc/qv9FWMOJ44ucF0uvZyHYg24idtm+BQRgFPQKD3iTP1XNCMEIeJX3drcGrP21z1m+16mTbvJ21d1XuJs9NCkE+Zs3zivxvnVH9XpuFwIjPTSVpdT14/wXMnGxpPTfzizskV3mn4rAxRb3sX6ElbyJ2nRoMJ72nMKznR8F7da7g5DZIe7b4/3W6QeExytOG9kr3NJpjok223dlod5lq6Qg6C7BfJcul7nkjjvLW37rT1tsNvqttwfEmA1k4ngTs27iylreF8k4GbBJzjzKjxuZuCFPnWMcpPQQx3PjMo1NaMfnv2CPZeOuaNZn4tx0K/nsEw8a87m2mLeQDEnVSv22QO42J+pjWTWVdZ1p3xFphwejsdct64zrlDnInE2PSAUPa3skFUT4Eb3uqmdaoynBnq2y09CIhtS6BIW+tkC3JYOEcX+BuoBX5UhtrFjtYDdNol84VxSpZgA2qL1M///M8/2KNsHYMv4Hs9hOSMWh5g55vIkpcyeJf3V/aJ85p+E0zPt7vRD+dQ+c4NAlzQlJ0hoqvGAm3IBBI9eIkTc+5tgIeuE1jyjB6fI98G5+vW8WKt5pp5z+tztlSPM7AIFKpsni9LYFJBTvWtMVBP+oKzwMQX4lHpD/nA8CNr3M9+Yi37Omhr2NdcZnp6VuiTZCydGslXrnu7K2NoZRjuYGcA/X8F3kbDApiUUn48MCHFoMXHPf12Qe0KsimihJNrE28K9FTjq1/96sM3b3FQUEkKRYLK0x59LAg81ZHQ4XWlRONJE70ybyfO365ejjuN5+YokGqssRB4YXugxqXxMWbNofaCS2jmoXA7fE+dqMRz+p11myPS/iOMmTeNScpb/5Verd87J3jCuaUaE0RqBu6JfH5O2Mn8Vm7lzGb5NEzTwJ3q73D2dpqjdkUPtTYaTDy262cqPxl9zXGeaJbte51pe8VVOAkCtGu79qY5mpz0W2Gic/bXeHg1R7u2p76a09jmu+F/Yoc1/CdcJyfS8cm5Ws3HJLfbuBxWeOb/JmcaDiue93rp+LMNRk4dToD+S1+SYZDgsi3XQxvbhNNjbOingpTZOLE4erkdxgMIgOvJpjN9rhst+dA3TqO36WsqeTb5MvujbRzR5A8cX8rmdro2Nsc3gynNZnUac1REygoc/uzL6enjc2fT54TfvnXJ9YUHCumXNj0jaKJrBkBoI3cs0L6XJSCk9aaHuHLOZZ9S91d+5Vce1qF+656/ccvPp5Gtx1Y35lZtk4nImAmAqD/9xm/h7WScwZl8Ce/w4h/5A/oIOMMVv8BfAAB++vBWZvkeflg5h0prd4SusT0P+kw85vyZr7RPvvM5VnnOwtV1Hrj6dreksa9L37qm/7KtdZaU5kc2Nmec6r/qawvgL/3SL7362te+9iY4x/Y/fA9fK75ljLOMdJ3AlB/4nXzu68DH/0e2ddVfBqTfvm3S5QIPp52e0F/lyWqV7mCnDvype/TL8SKOD9snKedBYmQCOPp4mAPPtHqSt8I1Y/IWxTQZ7if1dn22MldxfMzYnhNOjO3Htn/q9Dic4uPKLfkBA4OD7RAy/satXOT8nnhrxXPNWDudf3Dh7Q8ZAW+BkzSotbgRNgIFYyQ4ecqZBkTDwcfosHrKczqfKweUseq/aCDlqTOHNHcak5SiBL8+KAYdQKc6ysLxjK7VfK0M6ebUNAeiOTe7evkbAYwQl5ImiKhvUp2bg+fXpznbzUvi5e0+lSw4heb4rGgO5NrPa17O+/JrbS4nSBwbbrvf05pq9Mg2VnVW+DY4dRgnPpnoPI1lt/amdefBfucHr9fo7N8+b6d2xMSH0zhzLFOZ3JrR6DDJr0a3pPOuPS/b/u/46sRGyjlv63SHY1sn07gbTLRsdJhk5xWbrtU/1ZVTG9Jx0ody+LSlAWeOJ/ETHSaZfkV3pL7ZjfW5wDOWG6zmmPu+fWvFzx7owKFj7O405UHU9AMQ+MHZSnywTb39xNfH5vJo2tKX2U5A2r/0l2ek0CZvp/KyJ/KiZRA5jfxhrs+JH5LOtcR/srV8XjPQ5bRxunjmews4Ch/ZpX/5L//lh48eampXgLYZyWaTna3fZDNp25HmmQd6HgjGrpe9z3mvBJXYCse2LpVnyxT12MaUus1/6yMcyaDhxThqQ9mOBIWSdgQOZZeqX3wmAlpqS3a47vu5Tt7vFFzkus9ny0Zz/iaoxXYvAksCeIMsJQFvReOMUtpS4Ee+g86pU3BM8GM/9mOvfvqnf/rht/rRy3OYHx1JwUt0PEMIvgJ/ssEIvJAF5LztfJuyxMct8PXsdCFIpuvwDOV46KA2FTzS+NnmqPZ4ax7HpRCYg8cEjhNzlYFA+vU12dZhymXPwrt7xpJDGmdca3Wagboqn/dODKDW/mPgljZOnYR7wWOMgpUBtnKc7gmTc4Pi1iL6xCc+8SBQtZAUwVcggr3FK4eBdlo/fi/L8ns31sl4TuW94wcUvgSglB7ZPCmMc7vYhMuEd3MK2/zm2rxikAt484aEtIQ/WUuaT31rfzCGl/YJay7zEO+d87DDp5Vr9RrNdu0CBJak3KXAeKokw+RXf/VXH675FjVvI5+CrngteXHlHLykk7DCxel8IuNbvVZmpX/S0UynZOf0n4xr1e4OmvyYZNJKjtyil1v7070rOCc9ch2mY3ELnVZ0Xo0zHaPGS43+p2tqkk0TD690V/Il99sYV7w/yfNJd63mNvl8ghUvtb4n8DrTVrmV/ZD3kybpBKzqnIyr/fZrruPkGEhXyHHSthsFmiYHJSHxOF1TKQffBmgZLSve8+wBd4qaHFjNJ7IorzufZZvpSPsWEZ8DdzZbe42fPXCUZzIxFtrgnre1ylpKOrocdgfZec4zl3J8Prb2NjafI+8TXB0nPzTZ+wAHD6z5FqqmYzzY5zTwLT+yP//cn/tzr37qp37qIZNI/gRHVXgASTadrutbW5N44EsQRu2ReePbpbx/spOw7VVXASKyFQkIecCn6R8CUWpLH4FvmcxAJTRS8IgMF87g5FgKjYvMF8klBak4D8jnw3kfXAgAecBqJVMy28eDjhmgFM7IRoIh7NbAH9RxE/KT1N5nPvOZV//0n/7TBz9C2wB1TfU1Ts2bspc8YyczrTwwzDY81eUMJ8cz15Wv39U6/yPbqcL42QrpNKCOfAcFyjiTljdty5fSt2gj30JlyVzy9Ut2GGs4s9mYy5askLrL15e/lfNJMpZ2DsDKWN0ZFSdK76SNx8KkqE8dge8HuGpc3GKMnDptrZ4WkIIQ2vdMqjj7U/XbF+wKx8aTzWhJnE9gZ+xOOCUuGouEo8YpAcJp/wSpmvNx6lDtxrNbcyf3czwEl1C+XFfGEummGqsEpf6ncZlG/w6fNDZWNFmNYUeD5CUp4y9+8YsP33oSLUWhs7b0FIyDBgEUMm/LY26nFG4f2zTGLHM6nueEXHM5fydObuOxnOumHBNW8vqqw5tj2o0tdWSreys0nCZ8uN7KnayDk/+NP9MJyHKTQ5+/s83W3wnuK5wnx3bHu6uxTzhMeCWftP52eqvZZS7LdnV3PDHJ6Wk9T2PZybSVTt3Zpc3ZPpGhrZ+sf0XXS94rS1cOD68l10MyBZX8XEjazkCTj7PJkhPbu927xa67F2D7CAffEuW6lrHlliFvw2Gab8+moY1cF5kxNNGVax748P8eMOE+mRr8x+l0pz2Pb2g853h6PecRxinw4I/TYOojA00neCR96cvH2uZw0gn6eBCA4Epuo3O8WnaT48D2MGW8KNDyn/7Tf3oI1LAFSR/5HB6slJ+hMmTaw68EKphrcOLAZvDnEGo9PAUf2X8KGsjGJ4i1st/cPoTenkUDTf1waB5Mq23Z15I3BLDUr3DQt8bLljn5H37gta9D51XGoDb9pUkZHE7e9K100CfHxkuQVFZ+kL41Dg6xhtZqQzT8mZ/5mYczqCRHddi15uiTn/zkmwwxziXy9QJuvl4Ym29l5ND75pP4WvLMRcq8t7ysCfngY04ZpHvyHzQmHsrLh9JWP/nBmivRR4EltjzSvtOVpAS1p/mHBnwLPFlhstFdpuGzPMnh3ZNRszKwdgbMzoCc+r8XrIynyYA4qfu2wAr/qfw9+zrpO+uJ6RWd1lMFCTBS8FRGQkaLj+1G2c/KuPL7/rvhvaPbdP+qk4NwUWReTy8lVCQgRQMJbj9faTe27OOKI3MF99XaZzy8sYwnG7qmbB4CTjzF4UmK7xPO1NWVk3EKzVGcxpDXW1kUks6J0hMflK4HA13ZShFyOKTGLVqoHum+7Qnqbhy33H9OWMnPHR+udEqr72t5amcyklt7J7J9Jzey7St6ZIVbG/due8HVdnJsbtgmnln+1rk95ZXd2jiREc6bO/3vbe/qTDiteNmvrWTRCd7usK3qnei2nU23kqleLv/vaDFt3W54Zv2dvXlaptXxMZ7aOV5eug9dgZPlTsnU9rQtpfF7W49vq75wx2WSNRm08TJtHqnTtqJl/czAyXqZHdT0SHOqc0tW4u7OX5Mx7tDznU44bbvj7HTJbVaOd+JKW+3snMxMamVS9rdsJsBf5MKY3MnNIEZu5fF+PMDicq+9Ul7/sb8URJFzLvuaAARviHO8BBycLBuVjA99ezCYvnjjG/95s5kHIfBntM1O18j68W2Dznc+hsws04ezgdgVoOAIB42LDuCgIBKHQeue8CQTS9f0kFdtk8ni/MKc8uGlPLz1Dh5M/soMNec7sqd87vXRnDB/8oPAG9xkN0M/BVwEGr+Cf/KdFFjS+Uoc/s3aYF2nXPD+NdeMlcwygfsiPiaX2bkW/9gCM9Awt6r5wfaA5u4XfuEXHrb7aSwao76VpaVxf/7zn38InGmsqit65VvtaNODXqw9eMzXVJ4jtfJ3nvytcM3IXwlwh8ngvaLkbjEOGlwxPk6N/VvgXuPZtX+Ls3S1j1vA6aoPQp6FwOImen3FmEqBt+PTK47JreNs/zU2Rd41dn9N6D3o6r9dIHK9GR0nzkK7hxAS/ihmAcpYSkwKQm81kEBTJJ4UTikRDjjM+do5lM0Bbc5P8ktb3629rM84NUYMM4wUnhyhFKWo9LRaho3+61tzreymlWORjmLSejfml4QJjxV+kzE8wWr+Wl+TDN/NfWubOZtkR66lqb/TrSATLdzIbn236/lUstGjjX81H6f6f5qvTM3ewVUnOsu3MZ3o+JPrk92TsmzFr5NNsBrrJLNW89CMyVZ3ZaOsaHhFh/ia8Lr5VHglD1OOTmPf6ZNbZWmT4/zHuWv3nd67OZnaX5Vvfb0k5MMUcMqtYO60CVqQSYDj6Jk/XKecO+25znPbC9dzK1hmJPhrwx1/v8bHt595346nBx4dJy+f2Vv89gOnW3ACnNLhTjry7cc6OP7MC3Rj3C3AwNzyaQ/RnO55ZkyTJ3z7/ZRXmVElG1PBCTnjAj/TVM66sgfZLcC4OcdI9T2AQwaQ/utevonNA6M+NtmEakf9cd7R9Nr4lmmTOoaX4rAtCt+B8Qk4QFvlCTbIZmWLnOrrg83OwdU+Z96nyirgoX7UBlsH9VvX2hvVnDcIehDogL7IR33roTRZObKnhRMP2hVk+Sf/5J88ZJ+pnrbH/YN/8A/eHIr9y7/8y39iTTrPOk25T5CLjC4Fs1gb+J2syVwntJNbNwHPKCPzzumasokyOkhemVjauikayCdSWc3vX/gLf+GBDv/xP/7HNzsjoLHLED+KA/r6NtcMEqdcdfl2RV8cB5ZWCvox8Jj2dkbuY+HUcLpnf6ftXun/qebuSt/efzOmuO5KRoJFGUukbUpo6ZqeNPjJ9yn4drikoJ7KTAZ1+38VUlG4McQe6Ozvlj5dSSFI+O+H9rnim9rZ3WtzoHbVj+aPbWAKJklIah7ZUw0OKL583afj1vil3W+wm8cdH038zDzqqYmUHEaDFIM+7Kl2BaUnLlJoSm0VTVIx7HByg3U3zueEkznZOe8TP/mcT87iDreVo3VV1voc7PCZHMOGz0ouNdwaXVY09zZP2p3kYcrelY48MUxaW6fzdaIDGv5Zd8d3Ppbd2Fd8PI03y+zG0vDc9XHCr+gOfa+2nZ/QcNWXO4f0J7mowLsMfMlRZfr4lpErttLEjzueuqJXvP6q3Z2eTXxPaL1rK9f5U9rMVwFnyp2ufK29oNl5bRy5zc3L5hYtxyF5N4My7pj61ie+k8beJmPys2joo+GVQTFsIw/eUN/rgYcHU+grt5Gt5ESOxR3hHGPSoPEpsoNtO8iVxKPxtAfxpr4TN68DPch8kh3Gm3p1X/KFoxlw3gm2OO1w0Nnmxlhkz1KfgAj8S59qi/Jqh7dGK3tKdZTBSKAr5azLjbbVTHKSg55VV7iwBY/DoKEDNjgPqnkTmNpmOyBnJ/k5X74e9FHw5rOf/exDRo12jgh/4aCsGtFO/Wo8ojNbAH0eaJ9AHXa+nzGFD6S25QPqwxvAdTzKP/tn/+zV5z73uT+xvj71qU+9CZT8xb/4F1/9q3/1r97MJfwPH0JTtg/62oFP1Bc7R7Ddk0+ZX7/3PgvU0p9v921bUynr61rlREfRQcdtiF/Er5y3pHJ6s6GCoeDBTg/69GwpX6OaI14WRXDUs/ygA2PKLXNPmrEEXFG8QBNiV9u4pfwVaIbx6v494LS9x/S7M/Af45ReaXtlJIiJZUxKkCttlcUtYaXFNhm5re3pOosOgak2/G1zbgScOH7t2oQLQkaCVR8JZgkxjdGNaFfWp/PSjC1eMarMIAU/9F+ZMjrcDmXpfbhRNTmVOc5WBmWqbymHn/zJn3z15//8n39QEppXT3t24zKzLzzlufU90bk5OOmcJO4n9E2jSCDl/pf+0l96CCxJYIvWysr62Z/92Vdf/epXH8pL0fF0ScJc9fX0RQqUt2RM0PBO3nwbnIZmaPN9wsMruZtPL73d3bintZxlmgF31UFvsOLFlfzwMadcOnHgd3hMMOG2WoOrfnZ0n8ayCwDsYNX2VWh0mPBr9Dutn2Wv6J/sb+o/6wM82Zc843wOnJ/m+KxwO7HzEkfJRQXdP/3pTz84L9KJejKr7Q2t7xzrCr90VE90WRvHtO53crnpjqzTaNP6SHo2+ZZtu8P+0nqiOVPulKXT5bh74CAzdxJynGlbJD707f+Zu3TQ8qm/Z/L4di7GloHFtsXRy3i5nGPwabYR9qUHSHwcLWPIx+rBq7adyefF56llSKmeb/0TeLCqHQCO05+BRZ97fchoIWAyvfGO8rK/JNsky8iiF8hhl4xTBjlHbPiDXtrBliXDxoN99O0OufMIeKh9PUiU3Sc5p8CAbOHG9z52aOUBSLbogYNkpcpBC/XFQdR+vpLq+LY4PozP3wDmNjl+hD46AsKDabqmoI98CrWrvv/Lf/kvD7Y+ZfwcKLKo8gwg+lR9fED5DvKRZFP/7b/9tx9saOkDjVdzyllP6l90VTaP5hKb2ufCg0wEV/xYFTK22ObHGbBkNMGXHjD2IGKuIQHBRl8LE694AFtjVln5vWSiaXxsr2R7pp/Z6mvK5QDgx4wgn3wrHXgAHrQ6hePAUjOqV/d2Dt/UtrdzUrfhc3pvB6t6K5xP6me9laF4S/1d+aeCXdsnhib3eZsC0WMWdtsitcKjORUsSgksCSsBh91JwZBeuKNrc/Ampy/xkeDm1ZF+wJ6CDhLOenri2USNbisaCHgqoKcJf/fv/t2Hsao99am9uv/23/7bN9kyU7vNUD2hB3SWYFO/er2r3nagiLtorwCXAi8IU4SvaO+pwad9N/xXRnnjkclAb+0l3cnIEu6ir8apMho7Y0QJqh0pRzKZ3FDbwYomb4OzIJjkWa6NJrtWddv1W3Fq7Zz0cw9d05zIlGnNkM97WW8lF6/Saqfn89pkI+yc8FZnguSFK/Pm5VbO/FV8vO3W126uVn2u9Ev7f9WOSMdZMliyS09CZVhLbum/DHyd/+eZtLt128Dp3+pLB0onq3+dIYGB60/eVzSb7Ivsv9Wf5rLVmYLPJ30lnjs7wduZ+GenPyZdtrJTngOajGsBpXbQb8vAcccos2K4j60BJD+mDeBOZG5NauPx/jwby4NMu4Ooqet4+7aWJncZG+s4x5N8nmuf+uDpfRAU8qAGtPF+He90UH28LRPNz33xzAkfB2PzF6HwIbAi+923YXmAiPOH2CbEC4HkZ/zmb/7mm8whx63NOXhwOLQHFwC33eEDHpCrHwU+FDiXncir5X0d5LqgT4D+vSwZOt4WH4I4ZOzgb+ALgS//efGOv4SGTFLRTGMgsCHcZPfis3BQOm+kIytG/31c/lDZ6Qfd9Z83gMtX+qt/9a8+9P/rv/7rD+U0f7xZWkEkPYzQNjE9NCdY5P6IyxjoAF3z7WmMl/XqfM0YmQeyrdxneW+8SY8HycgzDy55RqLzu3xBzRm+sMarD/PF3GRA3r/BNW0fcPY1nAH+DCo9WcbSTnFdVVIrgy4X2C0K8DmV5j37uofD9DbBZISu+AYhR9Q50/FOnJvWJ5H+T3ziEw/phVq4LFAi1dq+hEDc8fyp4+nXOZiOPcHeBoEXCUdFqk/omXhxXwJFWUL/+B//4wdjXW0qe0ZCWv145NuNMqd3jndnvAMIb0XYlcnz1//6X3+zrVGBMw5OpB8O8pYAJdiyM95XkONxuTI5YCeCs827fmtceoqiMYiemjsClfCt+Epj4+mDfuuaK7VTPN52mJxqh6sOll9zOk11Vw5Vzt/UzlS2rfsT5zfHtcL/5P4JHW6BnLuVs539unM46fipr5Xub7xwDztlZ29MNN7JwqzX+KO13Zz+LLPjtV3dHIPmTHqBA26l/wjw8wrnSW6eQMPbceVBj/Syzu/QNT3N5/yOnUzM4MI0T5MOuCpDprGk3sl2Vut+kjWtrzY2vjPw1eBUjz8l4Izx28eYwZd0DKnj36nvuedj9K127nSyFcS3kDgdM1vUs9xzrtNBzqyqtG0S2jgyG4gxezCIIIqPnWt+PTMSoIE7mZkdnFt8nHczw52yPpc+F/TngSMc9aSbA4dGSz5JJrENjPExFl4M4/OrfiXTFCRXPQUjOCNIckYf1fHMqmafIKtkuxMQ8gAW4/YMD/Whstjb6kcBEbUhO5yHjJ6tBs5T9hxBHY2BA7cJuPmB4ODDfdWT3YmNje1NEIUgBHPjGU+8UEj96bqCR7Lv2X0g30kyXDav7Fo90OZFPQTBoAv4cJh7BuZ83TJvyvDSOaXKltJ/zSFbwVRe/cq/0T3fAueBZudP5I/KEpzUdY1Nc6I6Hoh0nNCHBMY8OPVeO7yeewTP6FPlNAckS3i2E3Mm/Sv+4BB2PYgXLXVNeloPX3SN4BHl8HGRT7wcib7pnzXCfDju6fulTfHkW+FW0BR6u78yIvk9GTFt8X8/wVPhnLR8TgNi6i+NmZUx5093uLZyZlaGtJfBgObwOS0gCRLV8acgeqKgRZwn4d/LiSOFV+D7stW+gl1SnurfldXkWDW6+JqRAP7VX/3VV//1v/7XB0HMXmwJFgWchAcHbXOInzKZPODhbZ6AyhHA01MECTc90fjFX/zFV7/2a7/2EHjxfdekcvLUJfu7xRBuRnybt3wC18qs6ICQ/spXvvKAO8EzjVF0xABS+xxySEqq6L5Kz/9+gyarV7RfXU+Y9MhU7gSXFV+tFKpfbw7fiYPXeO1EjzWHdrrfylzVlU0XT/+v9rdb3ys8aTezS1dyI3lixU8rmXs6jkavaWw5Z16m2VIndHUcprWQ/KqzMwiMS25zIKtkGE7LDlY80nCW3sFx0JNaOTByEHQWHy9zSGg80/Sf022qN7V5ondy/Sf/XVmLq7U88eoVXJ/bFtwBDnnLMMptXlkWoF4GIlpwoq2xPPeEa7rf3kiWshdcsSE9QOBnuAC+PSX1Sxu33/N16sEurmd73HO8aCvfBgXNkk4eoAA/7La0T8Er56TxcJ454/g6fZ1XJCcU0CAgg+0qeYFtz9vR2CIFrromR1wOuWxg2WEKUsgmJtDi+qTJDLI4eaU9NroHGj04yTXPctE14UJQRG2pHWzBZjc4X8CfHjzjQS4Pin0udV9t51vr2EKFHcr4mEPnJ8+SkT/BW8kIYsiP0FY0HXXxS7/0S6++8IUvvAmYKdijh66it9O07Qpxu815QPjJpuYMIbLPCAgLD823dIWuC3Kbm7eNPvFMSIIvCpBpjtla6AEhfhMgQz/Cm997Pc8+V/Cf8zj3eXjj8o81I/3LNkDRjzlXHQXRpKcZK4e3iwbgTMYZa4xD0AmG+lp3Wek0uWID3RxYmozgE0PYvyfFdmK8NaNxwm3V5mTUn+BxAleN93u22YyXe8JknKwM2FSuXJ/wawprNZ6TMaodLXDP1uGsI1I7dU1RePUvgchbIh4LaeT6kyKCPP6UwRc3uPs4dwan/kuAKIgjAYRiYe+1Ald/42/8jVc/8RM/8SBsOIhPZaTkRA8/9+d0Dfs8u5BWe//hP/yHVz/3cz/35omHP0kg7ZWD2XPeVn2eGMsTvZgDVyCMwZ/y5RjzP/h/6UtfesgMw2gSr0k58MRKNJXDJKMiU5ZPYOdM3lvmXIV7OjWT07VrxxXiqU5p7a7qnuLQ8Fnpmavz18rvZOVjwA3OaRzpgJ3gfMt6Xxk8V42iNu+OR/sNZEbC1M6E347vpnGkjnd+b/piN349eWY7A84QT0C1dVkfBcrZPt10feuz6fAcg+4hIwV64q1AvXRSnu8wyYWGg5eZ6jV5ns5NtjHZJonPDo9pHTV+OKHjDtpYXxpW2V3O0zhd7oj5/dy25OuSutNazPnO7B/KJY5+z+0Gfzub1825dtwzQ8vp41uV0mld2Sg5FrWbwRzKNdwcr+RdD/ZOPhkf75920pnN35n5Ktkg5x1bDbuZeeeNa7JtZW9KThFYIMNE8o0MSH0I6HigIV/TDv3IPGFLGYEHD7xBb6cL5+CoH/wO1QMPMomwD5MHkh+w7dlVoXueQUNwKbfoMR7PXvJtTtijZFX5mUI+Pslk+Uiy7fXRw2OdLaq3tCmTRodNCxS0072/83f+zqt/82/+zZs3RIsOHsAiOJLrinlFH+lhh/pWec2B2tE3b3HTvKucAlDQkYCO876fMQQOzJHaEnAkB3pJ3x6kgu5+6Dht/tHrrX+MgUAffXHGFT6QwM8IY9z6r21/OixdD1w4kB1dreNMxEOciUWdfFCt674O4GeXBfAl7efabpmZd3kr3M4gzoHsYGWonba5qjtdd6Ku6pw6GKf43sPpO63/2H5ae+msNANnZfCc8k8z6CYl7r/btcTBfyNYiepyYDaCwQ/UvjeoH/bLqh/f0yoBoOtSikSWd2Nv7QvUHqmrKED2Wiug9Lf+1t96UAgKdKDkiPpn+nJrf8XTqs8eaPavK6gkh0H1JMBRhrw5jgyxnLs0IK8YxyuHkTYxWHgLBHua2SKZc9AcDh8z6bMcdMhBiBgiGruU7NWgpfO50yPH9zZAruOVQzTRoD2ZvlUGsrYnuXEiR7I972c3jyu8V0ZkA9dfk2xujvQJLjtY0STxX+naqW3aWLV92n+jwaruiS3RHLnGC9lncyxXa/kErxWvrHRtq4dj4Sn/4CU5LUdCT6QlH2Xg+5kvO5yb7k+eZXuGZKicB7aCu+OzWydtbWfZFV1ObcnEPceYdPbv3Zq8yr8na6Ldfxt0BXo11xTOpG+/anVTnrcMJXh4mkPmhLJeJ7N5vE3q+j0PuntZ+miOmQctcDzzNeCJf9oxPiYflzvO+vYzjFZrCVo2XTLpcP9QNu2mzMrwMn6GleuN3GanD3KKgINvp6Ke7Gr64oNtydvf8sBvaATNfC4JFPr5QwRfcMadX/13ow9jwBZWIMIPtk58sN9pj/69L7bCeTmnIUEE5pbgR54N5BlbBJegg+5JNouGylJS4Ogf/sN/+OBPyGZWUEn2vmS4aKwgj47j0HlSqudbxDj3yrNgk8d8Teuh7X/+z//5YbeJHtjqQYfqaq6V7aqsHX3+9b/+1w/XfRsatnbTJ/AlgT0PdBHAVB/MM/hmGwSt3v866MicOI/Bv4BvNSSYBX30LT9QYxbPaczoXwJszCVz5oeyAwQH4Q2fY9fxfm6X84Dz6pNlLKVTdQJNcLXrWcf7nAyVnSF+xbD08qcOwyk0JfA2KPdTWCmVZly18Z0abie0n4ylyXhzQekOvb79TXMu2F1ArwzInWGXoLISIErLlbAgmiyhwJkSLjSynx19HB833hCASmNVFFzOggAlQFYTrw11pdzan2iMUNIYtAWPtzvoCQZPARDAKqdr+rjwOqHpal2fGNsIVKVP64PBAE9IKfprrulnkl9p1MlgwFhImk1PTx1y7tPwpc3MIHkbttY12jfa7cpNdfNebqVISGctadvwbk6HtzGNczfuSR/674m30slIedtotNOzJ3zY5sNhcnZa25Nun3Ce5E3DMcue6qBpnF4v+WbHayd9Nhyu1nH8dnVPbC6npQxNto7IoCWj6WQtJX5Z3stK/uuAcLVPVmc+afe5Xek+/27rdFUfWdLOmJj62+GS/We7kyyYxprXkp7uNDT9fTKu54AMcDhOHtTJLVs5P37Ys38LMgso5QRlmtxPByznyzMqBGTbteCW95Vb/+gzaZD6fGVr853ZMk0epqPrbfhcZAZ36pcmt6dtfI4X/TcatOCg402mB2fKYE/i/HNuqcpyQLUHDFRWMg1Zpv+Jz6SzeFMXr2cnqMUWKs+E8QCKAIee84x8PLy9jYOaoQO4ENDgjCno5ec7wVc8vHQ+5jcPrvMgeOp7Vj146NuzoZhfyWf5DZLZookOzpY/o10eysbnbXDCh2AI2TRkAKkfMs5yvaUNq//yH/SG0H/0j/7Rm3mkbW2PlJ76jd/4jYdgDG+/Y8sj4/ZArvNibg/067Slh8Sqq/b8UHPnn++99h+Tjh6odJkkWhCszMw36K/+OFYDWjDPLovgOV8/ngUoX4YsN59L1jjBLB4u4R/Bcydb4G9+K9xksJ3WnxRqqzMJ3mZAZvvebxPGj8X9sXCLobKCpzQSJqNoujc5RCs4MahWdRp+TQlqcSiLRoLIX1fqi1ELzpXWrv/T+XJaeHYLrxv16HNrNw3/FQ0mB1UR/b/yV/7Kw0fXdeaRv+5U+OQ5R82I8X7yHtckWCUQpWRQFrTrKb/+SVkzGZ6JhxuHE7+moUVWkZ52cA4SQUVSdvUbejQjva07XeOV3YybbDH9V7vsD3e8pj3nE2C4cGYWishTdl8K0iBtc3ta97Sv1u5kAO/aWMmtDBSu8GzXp7XZcF61M+Gf5af1w9reydrVGGizwbRWT/jA5duJfM3sBe+/4bQaT15v635VZ0eHFU4r3Ccn7wo+09jb+KQX9XRYmUoKtCstn7Pxmsyf2lvxpreDPlwFxxtfTPbGxA+retOYnOatbLM3cl6nslNfiVfDlbqTvr5iVz83uKPM+TL5BrgWLMEJ8vEIfPuZrw/Kpx1Ifb5zDlzOcw3bTeAOYmYcZZAr59O/Hf+2TS3HmfJ7GiPXcztUs+k8a6rphQzm0UfL0vLxtDqeoZ9ZabTV6vqWPrb/0A5BPR5W8jIAHpDyxknJF9mjeugnW1i2L5kiHvBrOkptqx19sLGwcwnOtGCZ23cZNCM45ZlQzIUHIuiXDBd2WRCsIdgg8BctELzx81IzywWcVJ/AHLjpPg+B4SPqCmR7KuDx7/7dv3sI1LGdmkwh6Q89XFYmE7Yq611zAf606fzka5+Azi/8wi88tPP3/t7fe7imcREo1Bmy//7f//uHdskw4oD1PCfMs5SYW5WBD8AjfUDseHxEz5wjwPge26rJffg09Tw8r7oecMOOZwy6jm6EVj4W1gx8JDqTBcUc8hZqz7byD/R0POFtz4R7tsO7Tx2AVnZn/J0YsKv2d31dhZ1TcEtbjt+tiv6xuGRbK8PwFpgMy6n/6UnSqvwKRxf0WmA6nFsLRQEm9uuiLLQIOQRuNSfNwMtrK2dC4Kf078Y59T217fcQ0npTg97SxhNoPV3QtwSOhIiUBG8ym54ercbrOLiQ3BnpLvSzj0aTkzGv5oP7ogMKmzdD8LYQ3tAnmogf8s0QKyPen3x41hJbPfxgdqfJbl5dcZFtJR4W7romPPXk6KWgjeNUVk5y3/9n+00eN4fuROdcwa/h2u5PMuIEp9Z/o03eOxmL02Vae6vxZ1s7nK+0dwu0fla47vo+oc2KB9v9Bq0P7zv5eCVv0+7x8m0deN1WXxmt2sYg2SiZwqufs/xO/15Zf6dPRVvd1TWXsyu8duMQrNb11NZOD52MqfWV87rjuRUezw0cgixcsT88syQ/jbc9EEAZD/gA+XS+6ZepH2/LMyoaH7RMAP/GpsqtKO5Ip93l66xlPPn1rNO2lHE/t1RPW/5pp2VweSaZ2yfed7YBnVR+ynDyOZI9xtEJ2Go537TD4cW+C4CAD2cKkZmjIIoeLCr7RgERz5p3HnI+a2+BywfBBEuEBwEixzEzMQkYqDxbkbwugQK2zGFTctQF7bidTWDHDxNPPvYxEazSb7blgTd4QE/PMNJ2OD2YVTaRxqFgF+0Jb21fg7YEzoRj2r9u1ybP+xpU+zpSQ5lSn/rUpx6ylIQrQS3Z7bSFLPHtb/RPQMmDeE4b6JIZPL4lkt/QjXH/6T/9p9/McWaHuZzxTEf4JbODPHPK+cbXFmvFt7x5xpwf3I5f53zCNdYK7TGelBVPHlhKQeLXIeaJo5Swcy6m/9nnSfnVuFZwD4O44bkz0k7g1LnY4TX93/W9w6cZpVM7mYkyGdeTI9eAg+C0cLRHWE8yEMBafBJQ+vjh1ZPBMRkoK8PuCq47aM5Nw9Ov8bYdHeyNgBctFEDRGUie5tm242XfO/xOnLjm2LQ+VvJiKr9yMvi4MkShii8EPPWQEk+joNFG13hzA+crCaQU1YaCedPb4FZ84eOUQpDjpw9BMVLB1cdLwU4urpzbVbnJGfDfqY92+iX7Xekyr+ftt0yZRod0XLKNCd+Ulc15bXjn/QmvlQ7f0f/0Xo43x7Pq+0TGuOGz4q8VX0zyJ39Tdtqusfo/jbnZSW2e/f6JbeVtpbxK+jaexkDVQxh9Vhm8kxxc3ef6CR+0/23cjV47nXgvmPTtSf8nZa7iflL+HnbsraDDfqWzcLrZsqIAJlsinW8dV8+wAVyu+Hky+XrxfEOTrycP2OQ9ygvc4fKgQdum1+aWdlummTt2nrkz4eb96bofWOz9+vVJdzntEi8egOp/yj/aaRlMTr+WFeTyO4FsHR1e7FknBECwXbHdsdXoU7+x4xWcITtEZfWtwKZ4UMEA2WW8bQx8ZQv729wE9Acuns1OGc47YnzYluDEAdaMG9w5c5XtV7wqXuXyjBxsSwICvGKeOdOHrVa6TlCKQIPG6XPJHOs6/eoewTbOwaMvlVFZ+RPCS2ceqT/5FCojH0NZrunLMSfQ0LeQgYuv39Qnwl/6SO37m7wJvEFP3pqnNsjioj/4nEAMOLnP59mTPCgmGEmGGFvLVIYx/WE5p9DlgssQ+CnXDPc51J2D6inj2xN9axt4wRNkLLm/kfamyxXH0fHJ5IC7b4VbGTO76yfGw1PAFaP4uRXtUxg6T2U4TbAzclvZ1ZwQJUe4qRwR1zxwL9tNXs2sJ88ckQEjwUfapB+g5orDxzQZrWmcnDpITruVQ7Sa06l+Km+NSXuQeZW0xu8Rbt6QsXJqVrCa9xMnSJBp7z6vp07m1LaXQeHwZItrKHV/GiVlKaUlmnkbje5uwHIeCamsKKJ2EN4K7+wLxU5GFcoVo1L8/FIwOYpp8KQheSp3nZ9X99IhWTlrif/qfhtnu7675u2v+NrlB+O413p0WZzlT2RRm+csm/dO/l/VXynnJmczZUnSlt85tpWDubNfErc25lv09SoDozmL2d9qfVJfT6ElwyS3OPMvnYSd/srrO91/otOn/23tTuuzrd9sZ4fLNNa2tiZ5MfFtG0Nr49QueG6b8AR0zqP0lZx7MoJ5iQdvHyRLLuenyS0PiMCfaf+he/hN+VxPXPPAUAuKeAaOB15am00m+przLJcMgLXMgcaTmZlCIIJtSJw/5IflZ7aGb0XK9TrpNsdd19phzO0gY583zwJyOpFh5I64+EL2GFvieNOWeMfnQ2UJhjhOag966JsAE4EStplBL/c7wBXcnV6ME/wzaOJ869mZBMgUuGC8tMF5UcLPz9bRf/Dzc8b8xUT6jz2rOk47znjy9UFbnunlgRcPxugNcKIb9dUPZ0hpPUt/OL2YI/guA6K5TpzfaMO3znkwhS12jIltgQT4CMxxPhZBFxIKyETj40FM1o8+mh9evkM5zQ0vSfr91z4q2+VYf/4iJs8iZO2oHr6H04v/Atr0twdSjkAltGRMyBXfqutjhIb+tkJwykPdT23Pmw7vdrjq6E1KdWWYnCjzHZ6r+vfqs8FJO5Ph87YaAw2u8sGkGBm3GF7ZIhJavo9aQt9fF5rZNK3P6T5tqg1llkxGy1S/GQc5rmxrqteefuc2qd3YdnNAe35oITRMujgddn2moeTXs83GA/xGWaGUXdi7Meh12tpaZQGlvFFZKQTxFXwG/xFsQwCj6HNME+0Yg5Q4xk6jufOA882Kt53u+kjZocwINL0UNIPgqoPm89QM2lY/HbBWZyo/4bCi/wqPW9pK+dGciOxzRcMrOuykXK7Xlc5u11f45Np0HrlFD676mcaTY8rfU11v92SOkAttq0ujx+r+NAcndF7RA+BMBjf2J5008f2VshP9p7q+ZpJvWltJiwbZznS/4bPqs23Pyv5W9JjKTzRuYz0p+5ygDBHJOF4XTmaBHFZlP8hx1humZK8IcPLaXKND3ebysqs5zayIVie3p7V6DTfucQ17wjMsuSZoeGbWUmY+UC9x8rZEVz/2QXaP2uIhKs72agxpd+B4etDHt8r5b+7x3bKlPKjkcwoNwIN2ZFupb8kptsqRmUE2jgcbyQAj2MTr6tmmxQNE2uENzbxQhwAD+GOrUj8D7x5oZEuSBwt9TB5k4Lwd3walh4jyiZSl42+wVsY6GUkKNogmbBdkzLqn/+CnMQuY+8xEY148sEB2kv5TR4FfBVhkf3KgtV54w1Ea1MU29eCN2+D5IN7lm2cXNdkp4HBzgn/CJXlZIDyZN/jdDykHqOtnd/mRFqIDZ0QRsCW4+X+/frO14+i40LevI8CznThbydeUBzm9PoEh/hMshO+gN9l8uc58HWZwl/Xma/FJD+/eKbIrhvDKsD01jh2nq3WulH8KSJr6Ajs1hNp1b/s54BZHKxW4PjIqdHaM709G2HMoGcIjjf4T3LzvKXCxq+8KhHRdN5A8TdLHnGuJoAXpnAKNk8yWyYho48nf7T+CaTVOh50z0WgytTfRUDRQeqkUJwEezjViT7eDP0khEk+5iTaTDOOVqAQzoRHfRO7zyU7SZWo/n8pkGd8/r/tkB+QrTXMMKHfa1YcnUXri9lKwkwEnazUN0qw7OQetr+n/NHdtPAI3uPIp+AqaYd7uT/i19tIRbf+ncWQbJ7rjiiO6ovmq7GoN+f0c6ykeu3LJP2l0TdDwSf2WMrBtI1nRuulKx/WEh3097er52Fe6ZaLB9H+au3attZF47+ZmZTOlI7xr51SG7eydEzwnmjf+b5mfq3G/TaDtLP5acOkz6ULe0qqtcgqAEARIXZi/09c4XVcOGfygLeeX5gj7f8aSODW+9UwaHF0fg2+Xogz3kFvenwetqEN2sxxrXcNJlr0juvqbHj2j3+1r71fgWTKNfz2TK+cFGkDL1K3ZjnAXX/gWNWxYtm3RlsbqL1txm1C8RhCC//CfgG1o4MGbwFTfD1Qm2EFAJzNQnA+oy7jINPGsNDKM3BeALvpo7GqHIyp4JT0PEoWj2tVaUX3ukz3D4dvYmiov4IFk224GL5CRo/oEtHhTmeOkoKXmQna7yoAHY6R9tqg5j/rc57pznNKWgt/hE42PByEcQM6cuY7P9eSBTtpi/jwgRGBHwSMCUgQyRSPxqQDaEEzEj/CsH/jTs4bY6uZrDP/DDz73B97O02oHv8HXp28Fhk7gAE3wb9IOQlac2FI3B5ZSmO+cphNleqLUGy47mNo/NTivwDTeK/00fFeO1YnB+9yQCjRxQGAQECD9050H3WOvrICFh+KUMFTgyV/leOpsJHi/7XobW84PQREdJCe8MBIkXPTqTTn5HiV2WhCQ0gF0PmYJR6WRKvLv0ecJ3xPD0pX5CU1WtNjBFf4UDWTg6KwrnqQIMBZ4+kEdfXw/NcJeStUPMjzFXW2TwaU5k0GrTDkB2y+Fg8rkk4hp3E1Rp6GLkJdCFt/wBhPO/+JpUGauuZGkc8BIeSYYKX4jQ+ol4FSer4INU+BmcuInemcf6RxODv7ktOQYWt3mhK6ur/CbAgC3rNGmoxpefn1Vv81f0mjHC82uyPYmHTiVnZy9qd0VDic6dKV/VvN7C0w0zXG3YEOrv1qDJ7hMeGSfea/Rv0G2cTI/TouVTer0mmgy0avp49ZOk9srmNZU0/0559O6XvV5q910L3BbBCeHV2tLD0oX63BgPTCRXsMRE+A8tYzrNreNF1Jfp1ObusTnwAMi7pCCGzarz4XrG6/r847Tl21iB7OtifOCoAFZFJkNyfYash/YAkc/age7wwMgTk+nE1kbTlOXOemge2DHdTu/J73GPPM2N/oUf6icn8/DK+3BRQEiD3o4jxAYwpbzbUD+Nl3fcqW2yGzioR/HZxC0SZoxBucd+Bd8MnuEuVMfvJ3NM6g4nNqzsHRN64X6Kqdxa80QfABH8BA99Vv1cvtT2l/4J7rG6+oz20fX5K/wsBe60AZ2tP7Dp5lZ5zyUfODnUWUgSOXZ+sah49kvQTXhRHCm2Sr69qwgAjIE//zNlYwFXmG74p/6U3/qDc1dNrB+PNvI5QC/aZ/gIryewUR4mzVHoNIzG+FveNz7IMDkL1dy+QWOyIlmTz86sORpfzCUC5dJie0MulOD+MRI3Rkz2e+JYXMKj1XOk5F265j5f4+xncLKKMogjAwGFrgMBqVE+6FpMDQLncXFOTJqgy1x9EO9lXPT+PNWOrEWJEj0pjUJX862Ec4EBTiMsjmDBBY4gFkflLvaI7XVAxrZhuOT48qyjTcm2p3SYBLQu3oIZ41ZTyY1pwhP0VRzzWHXnvWl8ipLdpgAZeIH1LW5n5wNzkPSnCmgI8ULrxFU8i0hDab+pnLwtuafvfLs/xb4K3Cbk0LQTWVEr3YG2UvAbj2tnNlpu4iDK+JpPnb9p5OW9VbXd7IinRA3mHysu/V6L72U7ezaTT3SIAN/6eDu+t055VlupwtX+nzneDeYnNGGd8OljXfCd0WbCd/Gj4nzJO8bNH3Q+t7Zb1kueWTVf6NFzv2ky3e4rMbVynqfq7GfyALv2/9nX40+jS7TWFt/O91+kq31lIAfQZYyulsOG7aV3jjFW6U440Tlpat5Vbw/eJr4gI/bB6lbfd7bdhFvJ2mb7afzS39+Fg71PaNDdoDGSNa720kEM9gmQ8aC7CTZDqKbHybsOJFpkYciqz89SMuDh6FR0hA9PW1Nopw7p1M20rSGcX6x9XjgSPYNvAAuZCmpDY1D9TQmleFho9tFHpTy32QLqR0PgDgduEZ2HePAdvXsDh76ycbzLB+CP9Ba80oAwO1MHpyqjOrypmqBb8PjbB+V961PBFt8uxvtq0890BSAS9NLysKhnDL7sbXVh/p1/gdfMpL8LWPwvNPP4wkZhGN9+BY0D1SSkUNdtkNCA088oD365iwo9zmhv8oS4KNtsskEqsM8+jrj+wdeBwPZVUOQjYAV53b5FrwM5kIH5099WNtkkVGuZSmS/cQDejLz/ABwvj0AntliGRy+a2CJvbmkCkpA+QFgLLoUuFyf7p8qtVNF7uXb71M4MRhOiDwZQlMbaUTBXNRngTTDLXF+SoNhN/6Giz5acD/yIz/yIKyIAktoaaFLaGEkaAH5Cf8CFCpK0Q9Xm4yyHQ1W9Gtl2pi0JrQ+UCIqT0qrxikFJ+WWGUteX2uL/b+65gaX1tpkrDecdgb85ECcCo1WpxnMK3BjSkE1gisaL08CebuZnoRwEJ+u8+Yzf0LFExl9ONywrS3acDz9N8EcyTY3MHdZXq2fk/WHUSfjiacNGFGkP4Mj4Epav3mK5Pdvmct7Qcq8lMXg17KSJkO1lbmiD7x88uzJeBpN29j8XnNIJ7xW7ba276U3V7LN+2pzuLq/gxO56+2vaNlok+Wu8lWCywL+r9b5yZh2kLJ66mdHk9X11fx7u/nd7u36aTJ5shUbeNkTXZjttfU5lZ34ZeKbZos1OeNlpqzM1k72P9HghGeey0Y8AZwrz2jgrBs/b1H6UQ9R/Am+9CaOor8CffIrsJ094NO2ljlvtAcdLgsy48b7yvXhGU6Oo/OJxqyHrtiTGhdZ7P5mKJw9rpHlzxt+OV9I1wnEeTIAQRSCFgQ2sLPcmWWMns2VPJfZEfThdEyd4c40NpwHi8BL/gFOPo51bqMi8MA5rAQGVF/04y25HhxQPR7i4awT0CQYQHYUOPthyAQqePDt275w/Mk84c1ymiNBHrZMv/A7fg4PpxVchWb4Pl6GYAHbAl0+gDPbpAi4kAmlB9icj0Rgkrnw84UImHCYvgd+vH1d90wYDyB58AZecHs2104LgJOZA+28XQJFmncPCvqB2syf10WmeP8EtDxDD3q2M5KYgz/4gz94sN1ZXwQCdY+gMX3DA24Ps87ADX6BTtCUtc8csGbEd6z/1D3wNmuIIC008DYJSPl8kL10t8CSggGcA0JkkJPJ3elKxQdBrzoBDW5xChyvbOsxMBmfzaBdGYQNJ2dYoqUELdjyk1vA7kHfFW630jPHQqDFo/riK2WsyEHmMEdSNBGoKFiUKhH6DNaA2zQHJ/cmQ2GiESnKRM85dI83OCAkcl0wbwhtynAdAXYCjrOn2jbD/XRuE99dnbb2JxwxVHjdqwBDwN92kPjyREmAcPTDqj3d18fQaJDG+ZQZdGV9uRE50cfH43Pse5nTgJvwcCWZY3wbYHJkT/mqQTPMk7dOcDnpw3H2NiZHszkUp7hke9NcTo7q1Habgwm3K3pkV3blQJ20nWNo/TU+mpz1x/BIw/20zdNyiYfLvlOareg09XNy7WqZts6n9Z78cSIXJrnS2ms4rORks12v4nplHfl6z75Wdse0Fm61kV8C0F9sQcIR17Z4zlfCSWL7BxkT+q8yqt/OFMwn7a6b01bBHuE7gx6Ob+M9dwwZB85us+uznoCzcji0nOAajqLjx/k1ZO7IH8PW5FXjaputOTj9qo/Dy1vRoD3b5fxgaOc/t8f87JkWQJpo7PxJO36+lNNWeJPQ4LYS7ROEwvGHR8i6kg8h21K0YYeDB8zyIGkPDIjvCNJho/u88R9aMw7ad7tOdPW54qBnzm7yc6P8iBDw1Hw4bXznENcIEvBNho0HHjwQqt9V91itAAEAAElEQVQc3i78/EEtwTTuEaxTPflvCiwxHrdJWceOv2cEeXaPn9/l6yLtnwwC+3rJ9Ul5leEcJ+bJMwI1Z2wjFfhboX2Nuw2OD54ZSswHc03g7g9eB5fYzsb4oQ240a8HZinD7oUM+kA/5pgtrGTPpQx0HoHuyS+06YFRHtaz1tjBcdfAEumI/oYugku+L7Up5ZyIySGYrjlMDslOmaZyeAnlOxl7uZhgNNH7Ix/5yMMTDF2DEb71rW+9+s53vvMngg73Hsep45dzPAHjkaIQOANjKGicUgbsl9UYJdAUXCJii9BQFgsC0KE5ZqcOHgLI2/L2J3ogxDhEjeASwkBnBEhJ6Ylb4io6yCjS1iutMfbBa9wKsqHcGs0bjaEpQsSfIJ0KhUa/xzhrfo99vTxBg9eFK5lGCD79Fw1QYLrHHmoB327skAbLtklPGUfh+0GgSVM3inbz3xwBDDfeEIHQ97RcL6trMnhQQgQYxduNv5uj7vNwOsdvA+ycNh9r1rvVmduVacZw6/dUz6zKZp2cu9NtKidlUi76OLOtqWy2N/Wzw7O1l3rkdNy5BaZ9e98rnNs8ZP1Gm+y/8TH/3dldXWt47+ZhGnuWo2yuv8bvjYfTnpvwyf6y3gmveLmJrq1O6zfLrWjX2lvhO+mSvLZq13mnZcg2W2cad6v7NuoIP2CWbF1lMGPz8SCVdYJjjlMmR1dBGNmNglyPQK6ndGo9AOX6P2WR/8amAHAAsWf8ftoTHhjB+fPDgX3bjgcvBAoC+CHKBJRwVrE/yIL3TA4fL5k9KkdmDFt4APWRGSb+zbhdhk38PQWQsrwH2sBHZfzV8NiRwp0zozxbh3K8yY0gFW+59Dniw1yojOjrZ5vm2D27xOeWa4wLn42tTwSR9F98Cy3IFGOuko/xA/Qf21K/CYaR0UXAgUwb9839TC38qNzyR3YND3zlk3AkhdrTNR37oXryW2ifcUN753XneV87HnjN7VfQ3Q+Hh7f4+BomgOr8lw/l8bd40O+8C82TNxlX+gQZkOEa6/f3X2dI+VvdCHj6GVDJ/56B6OvKtwl6hhjBJ2QBdHH/g/t+SLjvjHFZx2/fnie6+kup7hpYwmljEt3Z4zWGbX9uKtmVMlwZOQ5XnI0V3FJn19b03cbX2qC8mEJPbT7zmc+8mVCyw0R7Lep2cOEp/VYG4ITf1M9Jn6T4kgboPKE64i0JflJ9EXwyGHgVPItNQliCro19N6cr3oH+nv4JX+eYU4Ch+CW09R9jiJRtLcwMLAl4cqAACmX1REDBQ409D4CbDCZSHPW0S8aWDAUOs/bU4VuMyhWvtDabEwOOmn8ZjppvKUt9OKgQPidarjfG6Lyjdl4QTxCo42tB19SeaEmgibngSQBPXZIPU1ZNcmriI/GpgsEyjAlwKXCkIClz4X1onOILGRk8dVQ7Grdoc8V5m5TVS0PjkWZ8Npk5lWltrdr0ss2JbOVb3Qz2rPjjyhxMuO4gde2t5dp1H0fq7dRrjSYTbVe6fzeG1lfylhucDVbz7HxxUn/HL1NwYXdtVX/Hf9N1nxdkMY5pjo/yjTareUxecXynLMw2Ps8aSd5t/Ngc3kaLiXeuyNlpzK4/JtmysgFPZODUd7az2mZ8qx3wFOCBDM4blN3LMQjSozjA0ueyexkbQROCIum8MsYms3PuV/a4O81+nd8+554t7u1Mv31rDMEAP1OUh5YeeBBgJ5DBn1kdoh/OIMdL6LpvUSLzyR/ocTYRvtwK//Y/baeUOV4ngwr5kICzbGRTc3CyH0Ltb7yCBmkr4i/5+aw44xyCDh3oEz8rs918nnNMlPcH09Th7EzG6m9so56fweNHfJAxgt2IbwJd2K5EwCTtSz/Lh2MXNMcZXCNAx5m1skdlp3N2p/qQzaz6ug4evAEOGjKH8JvTtsUDPJMo17DLK8+8ShnJGw/xvcCNh9esDX/YTx/g7IGuxIWgndt/+fAeXiBj671Wx8/JyhdVAdTx8TNWP/7FzwmDno3urD3/+JZEnwP+59lr9IP8yAPqV3Bckug2WQA40xL87M8Vk+njxIMBJsG9UqY7Y/kq3KK4d9AMdibPUxF9D3gaGU1YSyko00ULm8WPIOJQulSQDa9Gg91YrhjBuz6dyT2Dg7N0PHpK1oanhqo8Z8icGAMr2DlVnIkkwSkgGOBPbHKcui58JXQV1NE3TwpYM8I/D+/231ovCiQpAMETE9/mtzMIoa9oqqcJesqgclISCs5w8OVJtHlycG81RMFN4xJPc0g3Qkt0UQCNPck8dVOgzc/ccsAAE7gDQtBRa4MUasebNcmTG9Hbn+g0gT85fX7Pr4l/eMMf/O5ZnuKndIZ07d13331Y1xgcvtXzFnhbHIcJVnSdnLKdTNsZvVk+jeCpbM7XDna6ZRrfVVgFABKXFpDIazm+9hR6kg+t/mpMSdeVXJ7ackfEx7Trp7XV6OFjOrUbWgBh6muFe14/4Y/ka6/b5t7Pv5jwnvTe1PdE36bHmrzlf/LliU5qNueOdqe6bWUPXaXRY3VszlfjncYLiccJzk8NPIDBkWHrjda2stI5Z5BtW/6GKF3XQxnpTz+81seemUiMN7O43cmiDN9el7JZ3h1TnNeVPcE64dxaHpy6HSQ7kDWKneIBDM90YusVWQzY0gRjcErBjYwe2iZxwLOAOM+o0anRxOmR4HoEm83fUsVY8qBi2YAERHghjmeKeBDGXzUPT+GnQkfK+tk5HljAT/G35oG/rzUPfnAdXHw9cR4oDzQ9c0wgG51MLDJV0rfDjwR/1gnZ7c7rzjPQlXO2CCqRoePZUWRTkXUDH0I/ssHwTZQk8LnPfe7VL//yLz/4/D7HHpRxfk9b1unpfmDKJ99aB12gHw9I9CFgxNqDju4jsOUPvuZYjdRHmbVIUNKzyXI9eFDzvZbR5kEft0X8jFiA+ScwxdZff3BOwJexepYVwTWCl56N5/h4kMnbzvmC9s4bdw0sScj7wboasBiVg5fVqSaNV3NPRkMq/MkISYLfA55SgbpAJfIv2uBUylHU5HjWwmT8INx8yw+LxfdaN4N/UmK30KAZ/qv5yrJZBuWHAGURwdgI2Knd9nuH/8qYcx4ULtqOprPEeEOGFulXv/rVhwDENHaByn79619/I3zZo+2vRU2BlHjkGwocUsi1dnRdARsFNhCypNqibE6CFDvHq+He7rvRS1BJ2XfCj7EQQBR9OUMLXuCVrh7Uc56nDQSjGxF+sGEqLJ7w8Aa+fN2rj2maK77TuCc9G6VPJqc+kgUKoPF01ftowVMvs6Nx4vO2wYpvV85Q0xEp005lwQmc0q7JwxM8Jpk/9bubz+neJH9z/Ux1Jt29w7X1NdHlhNYnPDPVabRd0WVFj6n8pE9aG6t7rd8THpv4Y4UD1/SbLIikQf7e9bfTrY7Lbp2s1lOjTfKary/vczVXUxm/d7q+c5wr2TXhc9rPtE4b76x0x0sCWdayu6S3v/GNbzzoTdkEcljJRlA52QSebaAx6MEUwQRBfk9bW1xnZ0aT2xSZqSRIm8L7ajrb7ZC0FTgnha0rKqesLD/vp80vdpIf6O02A04hB0b7eS607du/cHIJPqmO2mDLHZDOMTTIIFPSxrNWckuU+tIcY8P5+UaacwWXyJ4hOENZ6KZ2yfD282EcB37ja7BlkDnyB3n4bTyc5HB5z1DJeadt8BGuHMQuXubNa9iGvPjKtzDpm+1szKG/WQ170o8GYcyc5+MH2oM//gBzrP/Ci7fMiXZk8HPmkoBx6yP7lGwnXX/nnXcesvMJjiVNMmDofOMZZrmWUg66Twid4CGCsqwFgi3MI7EJXzNtfXq2EPNBgIf5ItBKkKlltDmfvef1Nd4Mx5x6pl7Ou8sJAN9Q1wjswJO85IogoGcZMgbw4KG9z1Me/ZJrHN8VOXl65u9xYIlULi16LQj9F1PlWwn0wRG/VXneYuA/t1M19UVQSYJQwpLF46+RF33SYU7QQtaC5emDn+Pjr193uMVQOKHbFbqmYQhTExEXTfy6PghY3v7VFGniujOqU6GsDHaB6CwDh6AMaabKWpLxkmNK3DQGBZcwIjJ40PBMhc11Pn6Qn6ddtrb0cYEHz3Ag487Ra7Diz6ls4kVQSUpI9PWxoKj1gcbZXuKQT9ndUCQYRaaQv0UQZUZdPxA/aZp0Wjkmfk/t8ITQU7Z5ipiOVrbjeGT/p/C2OAxXIXE+cVRX5U76czkw0W3nWO/6m5zME9iVP9V/TeZl+QnP07G1snnvhMaJ8wk/t352OK+CCdlulj0ZwwkOiUf+nupOuO7GsqPlah4c7xNotGo4tjab7J/6bU7u1H/DY8KvOQwT3syXOy3paDhOp+M/Gfc0xmkMznu7+s8B0o3S/crY/Zmf+ZlXP/VTP/Xq53/+5984/rwunSABOh1djt0A/XMbbNpYOHC+tYb6lHU7q2Uq4dj6fGemE+AOHuU8MIETywMuzvfxN19hL/m2IRw8z1RKnNQWjjVJAWqDzHj6dFr5W8mwZ3jg6ePMOXT5RUDEy2N3pc7FV9JDUd6Ypgx72dK8yU3OswIzH/3oR98EvHgIjbPN3BNwyXmGhrl1TdcUYBGd6IesdmxXfDeOlsBBT5vd+9M328agM76N+iKbzIOUtCXbXX4SgR716WeCwhu87Y9rXHceJNPNs508U0cP01VePMH5tgTr4DFfQ9BQ604BP87y4iEF9i7b68ig4RyszPzKNZM84msvg7yaGwJntKdrmk/tePB1TxuaY+ZWQSnkBg91cz1AT+jL+DIghs/h8D3bIufJIC6/4Bv6zjVJ+x4sI9joR7bwkJz/AvjUt7/ic6XN5OfBMS7wQT7lnNwlsKSUVQ1EzIcw51wcAdkaTvxJsV41sG9xRFbQlPKt9fM3AkVM644tEWSijH6uQS40leU162yrIgqvbDAtaD9YbmdYrIzOkzlxhmvXT+pqTBJeRFeJ3quuxiJloqdVfqYQbbenJN52w2FFl+ZUkSrKAkaZ6pqCSytA6K2CfSc0AhB62lKl9fX/UvcmP9c3x133lQFFkVhkR+zE8+x4dmxMbMeJhZDJKmbDiuFPQKz5H7KANSsihMCABEpChM0UWzYeHs+PZ8cGRSzYwAL0ZvKrz9HzufR1vVXdfc593ff1vC0dnXN+Q3d1dXV1VXVV9f99YcEDf9Wlty4ieXrexKS7kjg9MaRU3HfjAs0iMGBU4lu8eowrvETD0qRoVRy5wKfLK88ZH55MVeNRwpP15cmEtY/TOO3wCAzQcgpS5gSbdh+779UYdddOFMfHLNfCtZrbq1IX8cRrXuvo+xSenZEhS90Nf5Kymnfdzns+VxXKip9TODsFtdZV/9d3r+lrxfNuHfPZ6bndPKvGhenaVO+qP/XZrs6u/h2O/V3pvSrZXf21jxXv3fOVlrr+r3DYwbSSYaZ6JvhOxmKaR6f8OGWibmNi6kd9f3ct71VlY+pTzaEx1Vd3xh+jsC6qTLFuIu+YP1N5mvvoHHp3mPg4vSz4ZCiS/cu+ZtiaRfmyzitli8oX/d2FveQYuLGVnknpUaDRRoVU720NDRqLMkyNkp7ntJfGEts2VNA8Qgkvz2hsUtb1PTdU0wilvJUbvnWeZNhV4jeNXRU/4thTos2zSaoE3ic1hHjSo5vxxrhEnXh1aYjLvL4Z5uMJwuoY6RGinpphZ27iS3/SE9eAESMM7WK0qPqb/VYp5x1TUuhIYP/Nq2VuK6/l/BZn5iFNTxcNXfZLOqvGC71NzDOq15G6us9o6KKP0qR4NIzOeSgcet4zX00mrxyvbG7y+KSJPA0t8Ze6ZZ2/aQwUv0YcKPt4X9o2lFO4crwp6KH8NrQyc6PZPtcNv1V3516GYvLt3E7Po6xHnHktDeWZ7yy94TIBu3OZ4lxz7LyvPmNbybfS6yz5hzjROy9lSWlHT0hKZ1R+YsOSShiMgA+ThUHxqHAHMt32usXtRNGeSqc8VUFjJVROC/Kqra6OqeSEkoiTccmc6ySyvYQRPMJcYQISt0domvene69eu6bscJe/b1ES6AtGGmDPLPMwTpn1iTJyrTA0CdP+9pNMS7jqSV4rgXMnyGXbXT3CQfvk1yJfkrs4GBMNy+u8oTRGmuNJ5pXHgp7Qf4Vv6lcnnOdv6BU+gSCAEChNG6OddJx8Ir87gY7xcKH1GNo01lof/8VBVUpS+Jj60OFkNQf87WmGKZwyJggkHX13fd3hunv//y/llHd0RoV6r+Nzq/e81q0ZtZ4O7u73Dv4TfnpaOti9bp0TLd3Kr2q9aVSYcLKj51XJse3mXfds/j4dG+u9di3zvZ3B4WQsKg3Lm054sv87Oq7zY2U0PDFAJAzdtRP81b52v7v+dnS24wd5bQX3Do6T/qzmQba5q6v2o8JY514tOxx2z70Y1g3lAZV4ZUPlGGQyFXRDccxLhJeTO/DVwFPHx76qNFFyvqWRLXFfeUQ+o3GGUo1TepujICIH6VFgmFcqob7n75SJMkeK7QiTqQPqJiLPugHJRnTmcjG6RAXfT4ZSaeRgHJR/c7M18WpfO3qroX+JW08YY/OU3xgA9AbSaJBGKeVb7puqQvnRcD0VavGlt76hhok/catRhbZMo6DRj2cwnOQmJl73FPSVLrRI7zANUep/jpH9MjRKI1eedgzONW5pwEma0FtLIxBzIVOnaHChDv+bEiM94phXmUBcnGAMYo6ZyJsirDwjbjTsJX1JP3qBOUeYAxpojCygDuvsDGN8a5hK76mcO2l0paBXcM1UJLbjnBdfzgHvdXqHhh37YbsZDlZD/mzjz8N7Mr2bMu9y4ovfGkkTxxmmWnmStKWThrmm9CibZOGkw5wLybfS0y156YOHwgGIA2BWfbwo9EAxWTHAuuuQ7mWrhbTreFd2gubu3jUC0KlgnIROkRBlHpR0b0sPjQ6uXGRcdClOvKqI1wWl4qATdDqBeicoV2vlNUJlPgNN4ImVidVMcm2/OiFp187pmE3PSKOZPA/GU0/m6qy2DymgOel1DVa4wqXWhaEmx5e2YKY/+MEPLjt/Gu70MJzC6Gxzuj4JrN17dX66WAOX/eA3RhZgqnkBJkUp78ncZKbmVarzQqGDBU1c5G4J311i8Kmv2f5KYdQgybxF+HCRSE+zFe6neZXzvBN0qyL1YlAaTmGZ5veEq1Pe3L3bvb9Suif+ael2/VfK8JMos7t+rfqyKpNCO9U79W11LYXIXX92+Kxw1Hla18ZpjuTzta4OJ/nOBN+K5qe113e6zaIT/FS4Vjyl+518zU/nndzhY6pz1/dss8I8zZXOQNb1o+OPddx3dH46ptO7q7LidR3c03sTL6k4WMH62EXZWGMCshceznyzjiIvknJDDxaVJ+UdPQW6zbaOZjI8hVKNF+n90625XchbpwCq8GJgwAtHHQmdSc9yZRl+60Fhf7rQk1QA+WTCaZ9NmMEdG5F64ghXylF6sejtwXO0T26gTCyuZ0WnD3RrR82pk7ABA/W+7GUvu4w1YW/qOYw5MpthSmlwAAbkxowuUEeSlxi+kzqZY1HnlEq9RgZD3TTcaIxBn7VeD4bhHcYy85dmP8Wl1zOFA3V44I9jmrSVhtKk6/TMSXlSw4RGGPFP8bThHCPqMQ8oJSNIHC+9fcSd9EPREKyxKU9l5F31Xr2lNC4BB/e1JUhTlUY0KtmusFmP45zeemlsMpdx0msaevTCSi9Bx6UWeY26g88598Sz3kLe/4kYA20B9CdPahR2aTONvqnrayyVZ2SS9+qtBb7sVxrQM4w2c4tpLE4Dtmk8qCvzA6eBe1fOz4+LPEsUGsdAkEov17BAU1Ae8bLg+qmAWstKwHqa5UR48zlK7nqkC5sWVUN/YCQmKt616e9UhL1eBYe6+O36VvtR+1fHJRnxJLh1OOqEQI0BXX/r/2sEtU64XD1f/xuaxaKm0YHdHr1jsj8VrhO8n+AmSzJNXZtlStlmjoPePPTFGGMZzLUKbAoC3bvT9aRPaN3TNTL5fN0lyTonXGW/dXVNY2uFy50sF6TccXFHyp2uie4mJaMKe5VWhS9dnbv+VGVtwnMunPluLoqdUP3Y5Rre4LUqKPuO/Z5CE1Zlws+Orjtectre1OeOx+/4VZb0Bu740KqctJPw1ZCaDh8Vjo4/nfKRSZnu6p/ay3prf+q7Xlvh5JbxXrXXPVP7Xelih8OquHU0dk0fTte3a3jOai0/kUlOeGXC2j0z0c+OpmvdXX9XeF49t8LHqr6uHj4nYXCrep510buBVBvAg+xiLkb+Y0BgHXVTDYUIowdewZl3Judx5WEpp+e1+r8WZbCdXGpiZK6rQKKU4bGCbmSeGRVT5EoVatOHqEx3Hki24ca94Uvixw27DIGjKGsDp/KPp9LqCJDheRqaKObE1MMDeTJDFMVDDR9SCbY/GmMShyaORlfMjXY35ZDB2Vg1TFCPEPPO6lHDtyeVGSZpQm/ngrKYm/3A5HiowLtRqTePhhcNAuAs5xbtQq+MLXgxgbw0of5AXZmuQfrwv6FW4lHcSUu5EVr5lPi0XXUqDSgafwxV01suDYIZSkUxhYZ5lJmLFJO/Q8+069iCZ+X5hJMibj2luQuRTG+jNOqaE4hihEYmalentm7eYx5AG8LtpnHSqzSWjh62mSetJc05XtKour3GMXFqGKGefT+KNVy7QB4YpMeZY6yhL+d+ekNWvOgoIM8QbvCVkTZ8Ev966Dknpak0UstHxEf1SHxQw5KKqxNYxQ1rM5ZbiBdGoRWUgTWO9NZShdOnUXZC4Uqw6IoZ8yUgw3TMkVM9R6pQvRMKp+euwc9Oucs6nXz19xRONCkHXuvg93/Xj5Ww2cGfcCccSUtZr9+Mk55UTDxoW+HF9+vH97uY4Z2Q3SkNFpmNybcpLlRp4a8CZC72WWe3m9fBeyIcr8avPksfjOmu9U+eQjvcWUdnmMq2fdawOy38eT3jh7s+dXmZKt4nWCc8+Y4LzqrtnHPuICg4yovFRcKyU5afdqnz/GQ867MTHzhRuqrxqRuvlbLQKfs7+Lu16qTvnRK/KqtQqXptotNufDrluvKRrky4unbdvoYHTe9Pdfq7C3dZtXXKx3fXVvVM43PN3OjW2lxXErfdWryTgVZw31pW472i1ZM6K56SFic8rubDJFQn/qY5fwL79E7FyUpWrM90ZZLVHrPgzaMBgOLJVS996UvvjSHf//737/O6IldrZFEJy1Lnude653J+5Ht13DMMJu9p3MEQggIP7B7pzscUAMhAKnseEqPSnjmNKOkNwbuZ+4Wigq03FMq+RgNkmjQUqDwKj95JXEuDUuJCvQ6DCYaTyif8P3lXdrJt4twCvqgfTzRDujSyAJd5ak0f4Ca9fUgDjQfVeGJZlS15LhX4VPz11tEooDLv2GocSa+NzL2ENx3jaT6aNLTwLv1I7xxDzRgjDWDqUdKfurOntqUjQjd/xVE6NJhjVP3B+tVnuM84a9Aw8XeGSSpjM/fMcYVRlz5RH9cwkkrLlqSZNJhZxGVGieTcEpe5cazBRu8eHVYcE3UNjUoaLO138mf7nYabDKHMMUk8aDB1joMP69C4rMHrf//v/33fpjqlcIrfLum+9pN0BuhCBOvc4xlsDEn7aexLg5mhemnEkv9JA6lbiZfKix7EsAQSdU81Sa4DDEBYcGVoKpK7he6knArpt9b7kEV8wJTBj3GqeG9x/XRQrsFZJzR2968VGHOhkBg9hpJr9KsLy1q13wm1U5kWqq4PXX98R9jNU5U7NTl5tD7/4R/+4f1ET+WdujzpQPdgGAjvZCjfSan9ScZhaCDefrQDvnkORkVycxfAqa1KD1VQmnBYvX6s69bxyXsJx0qYrzDVfk0w1GdqG3mySVU2ujr9KBwqZBj77njX3bsJZukwwyxzwaxCWsJhLDxCGAsatAwM5m3S6yoXHuF9zJKLVbcIXlvX7nqnGHi90l1XzzUKbFcqjSc8q/kx9W+ldE+KdwdP106ls2vWiAnWqe6uVNxUGBOeVfjcKYx1zu/mxoqX1X50fattTjjb9ePaZzten/ysg7HDyYrXdmtJp0h2a/0Jjax4ejc/u3br70k+6taLWm+tsz7f9WlVb4V5t66d8qITmarD2zVtPI3CKXAaA1796ldfYCGXpHku2ewjlxJyFnknVawylL7j3/7O0LWOb6YM1vGlyn80MvHBoIB8oEFJhZuCfAzsJgdWiVMGQF/Se8j6aCeT+ur5kjle9KbB6IBRA3mAjTPkUnCCbJJJw7mO7MBv8JqGlypHikvgJZ2CoVDmes13pN+qhPpMxXnyczfJMm8v316jTQxm4FPvLhVbioabNJ5k4myVZkomfFcWrF7e6eWFvJ2ebF53/HgHuYv28ORh7IVbrxTwluFbnvDmKX0af/IkL8fd0xBpj/fc5K7J4i1pAIGekBXFtcYsDbHAkm1qiMwUN45ZevfzLQ3ThjmdeD+Nbrxn6J0GOw3Ahmopn6ZXUMez9UriOQ3MGbaYucEMWUwdO/mr/dUwogFQw690k8ZD5fs0UDHOaXCUxjQOVxr/8xfoLE9vywTyhpiKY3XUNDAJT3oO6akpnI6Zxi/rk6acf3oAJi2pf2j0lBbVgU1MnjrMgxqW/tt/+2/3RzLqeWNjMDlPfXIwdKvsBINa6jM7QexJym4xn4SCKphMiqQWf62rTr4uXGdq+9qyMwCcCB0VlpwkTEB2kLRWQ4AYOTDCaJntdgmqwrHq507x83vVjypIy/xx6wV2rczQcibfs6QV1/HOOsEDwg0CBTRv0nEEH8Z8Rb8nOLdvwIT12WSV7jTkyQureTX93ylo9blpHlaXSnDmLkE1lJzAslJAO8Uj6+1gnWitEz67911EGGfdwWGo8DToHaMfY9PtcHb9cjdDI5XMvxomuzHyOF4ELRc2Y7UpyVsME4AXd/Hiz6p0c79TPnMsJ0PDVDpcn/KVSRGtdU38Sn5X+9EpOCd9OfVMOi0TLNNasJpj+fxqXa5j7rWu3lr/NG9qHbfis6O9er/2ZQXHNWW3/nb43a1xFbasq/s/Xc/267y0rdX82Y11B+9KvjqhgwmX3fsruLpnOv7U3Z/WjK69eq3rY/fubn2c5uWprHey/j6L8q53veuylrI2vuENb7j7xje+cZ8fkXURYwhGDg0DJlP2KHphT8NQjmPnzdvJJZnLx+cy6S4l3wEeN3tsC/ksoxLSO8hxtk7Wc9brPCE6D1nR+8QExCp03GP99xAl5RLWfOrxkBBlDp5BbsD4lCkIsk/dhgx1IINyHfwr39W1TyXZ91OOSVk8P8o0yCjmGXLzL/MnKfvmeNFX6ALYNNCJF3PrZD4oP8r1mYvHOvXUSJkp89A4PnrRZFoHjX+ZyFs9grEDHjcTNaxU7yVluEyMzP+k8UrTdczsL+8It7jyeWkPGZHiWGnE1XCRDgN1vD2h0SIONQhSl84HpsLIsE/lV2nMMbGODJ1LbxlPVhTH4lSjniFzzve6gSv8aTxJA1IaW7t5kSfQySsyXFI6SyPNz7zgXenYmWs1dSieN2yRYh6qGtqYBm6NVho+U4a2D8nHfDa97dJoxv80hNln50o90fJBDUtY3wUylXFPPTD/kouC7mwni123QGfZCZQ7wbHWnUzuScrUJy2tGXdru5MQk/Ct6u7KDr/TvV37WolJsveqV73qwsR1O9VzwhxEK6HuZExWz50okF29MLjXvOY1l9PVmORMWmBnwQVmT6jLBajbIZeRYWSQ1mWSXNP9tTtO3vc7QXrqq4wO3Lq45DuTwnZaOiFrJYBXQx3CXcY7m1QR4UWar7tWE+wTDqrAvVO6qkJQn++UgyrI+47GcsYWAdD3ZM4umJ0xtYa38R+a0bDpQqMQBT4x0kqHKQy7O+lCbdLBFCY1kBpPTzgyz3gKymOVFW/pnlkpSZ0ytqOjnQI6tZ+/V7Q2/b9mHlYYEu4Vz1wpoBNN7xTf5Hs5dyfetRvPDp6TOrJUvrGCo/5OT7laTyor1aPuocq09tXrXR/qOlzHYUcb9b6CpSV5TFfnat2exmOSXToaWI3jJBfVcVzR2bQ+1nYrzBXX9Z2uXyuYKmxTvzt+ktcnr5ypzgmnE9yPWdiow3DhGoky7sY066yhQMoYPKNHSIaQVLrOeV6VLHGZeSyzDt/v5oZygGHpGXqTm+nZdn5c5+kL8jReR/RH76AMyzJBsuOkgunajmyAfOKpczxnPlflBa8ZBqYyqVJaQ4DEqd9soiHXpXySCcAp4nRSaK1X3LlBq4FFrxYjCkwUXY2HwqgHBx8NOKZcSGeGxH86Qvi+8rrPJz4cY/XdPAlNmGzbMbIe/xue6Cl2eoI4NirrNeyIQpvSRBoSxHe3nmmMtd+0iaFRo4g0yn09lTTW5EFTebqyfbX+Oj9sv+ZL0iCa3kJ6K2WC6sx9pWdSJtXOd7jmXNPI51yxX3oUZR1pXHJc1eEyVU8+43yT3rVv5BxwHhmaqmfc//NCnYZ25lhnQm9pWQ8+eBvPa4yzfuHPMfIwAO/l+uXHcUnDl0W6c3ydr2loch5UHvughqXJSGTDWsntSLrITeVEuMw2d8LlVFddGCRiJ5xxpxJo5043LeC1/m7hz4H23k5pWQkc17yzKiuh1w84QllFAdYjQlowyVwn5OyEyW5MVnis8HVtZH3gmkX7Fa94xQVOmQO/GW/6xK5H9RTpPAX8r6FNxqVHGgs7DLxLyt71vZZOgE2af8iSAupJ/T6v4QJhyBjxdLUEB+AOQ8ckBNd6V+NnWQnvHY2tcN0J2vk/GXMuLj6TC0221fUjFyDmjvwmhYPcdZEHVVrwGRddeSr0pxBO8dQNk16euqw+rVJxMyk6Kx43ee2saLYKuFnnigftSqWXyQA9rRcdnPncqbK3UgzrHFnBMI1Hfa+2t5pjHX47/l2fXY3zpECv4Ky8c6eop0JVcbIbk47eEraJR1UhfdfH+t3RTuKtw/GuX9P4Vrlg1c70/2ROXLPWVVrqaHknJ0z1TvOh41t1HCY4T+XIji9WvJ/wxNU6OV17jPL8889f1j5ktc9+9rP3nigYM9j4QzlPDyDDcTIBb45Z7sh3sqVzz7Xc6xoeLK7d3TxT9smTaTOkRNwaHpXhTqncGwqn54qKKWu7h7BwTe9k5U/kCDa9MFhg+KEu8IcX0B/90R9dPPL1/DD/EnUgrxouxzt6VKUBKOnCA4fSu6c+w+8Ma1IBlqf67bMm7gZecmflYT6G/Zm7BxrIPJjWZZ4bisabDDdM2dZwnsrnsy96KzneKTsZoWEamKxDI4y5clKm47kM1cwQLsYaeRlnDUoaBrKfvuvpXCmj6hXT0Xt6AmWOUz6evGjRY4YP94XZ8axjX+eIfRPH6QmjbGpCck8+lO7SoOlYUg/40YtHe4Kw5vzjmUxIrgHKxO7UW429zqOaOzUNabbjpq7zSIOuY+yz6UVliONPhleT4YfyCHBs/lz7h4GYyBqjVdKwJMzOae0t0m7KE8kP05jqhnYm6RaeSkPiIvXZxM9JOdY+qtXKgRJhMkyK+T+6HX3fz++pVIEmJ1bCclqcLFr6IUARSD0eAZkuqSeC/tS/LObnScNEZtOvAkjX7krwnN5ZwX3ShgqrnhLiJd0Hu7o6AaoTkiV82pDxmFguc9mcjke2ZZ0mOHT8HYt0m/a9Cn8KHrrZCqNMWMbaLc63lBMlKvta+76q95r5ks/qfi3eZMwusC4IGeNb66k0UPuRDPJaHApTnT/Jq7q51SkNMm69DvNAAg060m0KMfYj+yNTFzbfcVGBzhMH+S7fhtJiMPLUPwrvwWNr7L2uxsL8WGVSqOp8Wymdp4ps1+6JMtW1OymVJ/Wfrmu+3/HEHSyr+dGtkRPOVvdXa2zC0NXXwbGCteKk8opb+dWuTx0s3fNViTqlx4R/WtMr/df6VvOjG5+Kv+69qQ/Ts117te8r3O3WqokOOxpc0dMJHU/v1HancZ2e7/Ax9aH2p8NHbSfHcoXPrnRwVlp7UnnlSQoeSXruUFi7uMbaZg7B3N3HeKJS1ekTue4m/qvXXi2d52LO3WwDGQiDg0qiSnR6pOTBNsofqXDrnZSGCb3A/c7EyJkPRr1Lj3bTbpCjCu985N2vfe1r90Y54FB+o+ilklElKcsrRwBbHiVvSVpMvKYMl8/mmNA3xpprGI68nsqu72U4VtKxnt/Vm0ga8Z45mCy5IZjrWCrYGgcomXcmnRDy9K/qdJEJs8UxBWOa9IFO4knqeTKfm9+Z3Fr5Edm6JgFP+pfukoaTlsW9DgIaM3nH9qTHHNM0xCU9681i1ELmBjKflHRHe/Sf/2kQzrFxHuRJgOLQvuZJcMKTxrc0AuklVDdZqwxVPZqSVnxe24bX9JbK+/YtT3yjSIvqnAmD4XJcf/nLX35x2uAwtIr3zB+mV1+FOXkVRZiAVZ2t5lzK+Zr8Kj3EvC4+T8tVp8LV3xIjOws2CkGZrLouWNcIid3z0/s7AcJ3+TCxsPbr5khJVzEt3zvBqe5Yd799x0FFOXzlK195ISY8O8hRZAxs9ZLq6p36Pl07FapWOPNbQhfezMqfdU6C8FQ39bIQ/qW/9Jd+LMkZ91nUwFMmi+/q6AQ0YMTFGkMh9WsplyFInxMeunFgoXdRkInlDlSFqVOUKvyVljpBJsfAhSvD0MzpVRf0CVedMD/RjPNGJmi7zB9pAFysLNvdfEiX5NzlSIFwRUd1UTWRoruC5i7KNjV6pTGmjre0A61o1EnXaU9eMOGki2gaQBOnuqYDn4uJxfpdhCpdUBhbdiGpw3wOHimq4OgCYM4m+/BiKCs+U2m8/q7vd3yxUyQ7RaODq7bf8YOTNexa5axTEk/qnJTtDtYOnmvgXPGr+p33uzY6Pt2N60QHJ+vJCv5THp/XJvx1z61oouOtq3ey/q4fUx3dOryqd4InFeEdveR4n9JV4mWaf9Pc6J4/4RcTjNm/SY7q4K33d+1PPKziY4JjBX9ViFZzravnlrn1kMVd+m9961sXQ8MXvvCF+9N5lYvNTeiBKR6HXftTQ4WU61133RSsdJ2Ks9/dmKngowDy7Vqba7DP88nkybar8ml+FWUUjUX2k+eRW/VgSmWb91z77SP/wRtyNEo833gEUQwbpB09S/RESqNO0gLXGI/0tKhhben5JZ7zfi1cQ24ENr02xJGhem7U8myGDaUizX9kIfrlyVwZauZ4CKOymTRF0RginLalh5MeMXr/iMOUBTOsTLxqSBDuzONj/igMa3rxpLJfdRzpyE1bZf30VE/a9/kMTbMvyu75nh5xGRoGfIaYoe9o/Er53LngZrp4tk4NYHr8MF94Xj0uk8tLn+JMI6swKtemjuScyrxZmYw8PeDSi8y8Zeps6cmTbaYRxo1zx1qjZo5ZegFlXqufeIGG+WSCb43KhvlhDH7d61536Y+5otJTy3E0ZFTaThxIL0n70qJ8hevSYw0DFr+OI/BJn4nHp2pYshMUGoQAdUlzwnWKzU5ImoSl3cJ3sjA6QT0WlLqdGE58kK+yPPV5JyRPMMlQyVVkWBGTkMTPeexnxdct5SEEBRdsra8Z1+pE646ZzPd3wrNWc/PCpGskz2USujz9aoV7/0uXGKZgltSvpwmGT0/uy3dSUOnaAQ+ckMFvPd6ATQbsuyf0sLrf/Qbv0C2LkrsfwogBjT7BlHKXp5ZcbDuc5TP1vm6nGpaETUZO/2WKXb3ZD8YVw4whdYyD7t96Cp3QvvPRY189VYFrjAmClouN854+eNJIVRpSwAIOBKsUcvgPjOywslgCO/VhbEohLJUV/iPEAZsHHFCcT8DiDkQ3XjxHmx6R6qIvz8rnwL9H9D5mjqWOn68U9pM6Vsryqo6p7JT47n9XxzVKda1zpUye1DnBXfFmqUroqn8r/uH9bjw7mCaeUutY1Ze/d2PftTcp+RNdnfDrDtZTWSSfPzFAdHDucJfvrvpU66mwJY1P8tlqvp6sL1Ofu/ur+vKZDp8TH5r6UPu+wsNJ2cl4ndyRNNndy+un86f28bHKP/tn/+yyTnv4iUoa65yJeS2sl2xi60XjulyNTHyqLNkZT1yfq8cNJetLbwxkSWQXlW3XZGUGFdZUOLnnhqDrdj2FSlisR7lKWcn3ecacLtWAgiyCfAp+eAcZ1dy4GrB4l49hePYxjUGG4+iV4/2UNywV9x2O+WhMQOZDDkJWQS5SafU9ZCs+yFOpBKeMJg6qoSMNTxUmDT/pZe6x6zkGKVfbT+jQpOxGVdh3daHMu6o8ZpSHxlBxaXiWNJSncCV+0xMo5VBxluu5z2rM8bAYDWFurqMrZFJt2/I0wTSeKDMLq/mv7J/zJA2X4sSNaMZag3COcxeSmH1NLyHrtb0MMfS+4+g7yRecjzV8UA8o20z+6JjUhOp53/d8ztPm/uQFA7ZGnRzP1HMNaQVH4NrDsKrHXOKnOr0kvVX+Kd3rxZX0ksYzaSRD9qR7eYWRGqfl5kQcOfEyKVVev2XBnQSF1XudIF0FRL49Jt73cldE4qx5oWRoDlJaLPVqWBnR/DBIGiN020NhZMCY7OmtkfGp1+LxSUuF2wRwTACNM/SZBQvjzMozYiVoe13XTJ7VMOCY0JZW5kmRmdp1N+h73/vefQyrjOS73/3ufRjRTrDLIkwYA3k/jSr1OPuTUhfgie5lZBhPME4yDjIUdxwQeOiXBrg6D69VlOrztEOfFQ7SgOVpKAgKMvhOwNXFGqOMc8E555xAoMh6OpxlgV7MNyBsGm2Y7/zmPp6CzF9PTUlDpSUFTNp3Ac6FzsVAAUNXVpON1r4rKDJXTHpPmy7WedJfvpP8TGE0eUKn4MNPSATuiTOPWVbK30nJBXB6v86fJy2TMaJrN3fQVgpeV2cVuk8U/h3c0/xdraWnCv5K6e6en9rt1udK6xWeHfyVzupz0xh1+On6sONBE/9ePVuvT7BVWLpnax2rPq3Wg4rnSpsV9g6eLKnAdfLZqnRr8nR9wu+KX3Tr0/TODpfXPrd6tj5/MqYdDjq+uOIPz1K+rOW55567V+5MUaHCb94XNl/0kkYJQ/bMJMXpTVPXjErL8m77rvKXYVJZL8Xdeq4Lm2FDNdyKkl4EaRww1En5QplfpTCNTm6m6pXA5ityR4am8BsjDDhB+UOPADdcB4+ExlG4lpvXfDQY0H49cIVSr+1ozD5WvpHXlcO5Zv4kCjIb192w411PIXczO3WSPASFksq7/RSP+Un40jMm+5AGQf/rnc54KP/Rvsq2spayHR9+Kxe6KSut8Vvvcr14pA2Vew0vFV6NAI6DOKYtjBPUYU5PvYLSuAmOTelgvcit6VFHSa8i6rMvfANzetYwTtCTXmTco8/KxjkvnVfVA02dxvmkl59GO2GluBGdnljyC3FU9THlaL13km84B9Mg6X03dKW3NM4IU+ZHTf7z05EAW1xm+hQ+RL9QP6Gr6KoaW3MOOQcy7FYjpkYt6SQ3/uv6kScXarQXFyYPZwzVk73HXHW8T41LNxuWJkHQ72lB7QSRnXDWtTEtuKsFWCtjxm/KUNKK3AlVIJmJm3GSTAbjoFeKsMolRJNWSFzgeA/3X0PlqJeJawKvZ7HoV6Ex+w4MMHn6/ZKXvOSCO+AzjK8y7RNB0Pvmb8p4YRNi6+7I/epa2ykotT0nPQo9DNyjWRkrvUsm3HYKl9dkYHq81Lbr90n907UsMtHMbZQ7He5iuQtS52CnVEy/u77LVEgWme2K52xzJUxrWLVudyadY3xrvFwJx1kfY6uRRxy4UPP/pS996WXu8q4uunqvUWT+tR/uRuVCLg9Ixs5vBCONRJOR04SEdXFd4Uv+lEKfC5X8THjdtaRv17itPnSpimQniO7ofado2U5t80nKKYyTkpa881R5nMJgd32pz0xrT8X9CqaJL3TPTDDUdXnFn7Oerr4O9gm22lZ3bTU2HY52PHynbK1wPslP18yL6fmJPms73VrVjVsq3Cs8dQpcV2+Hp924d/3q+pZ1VtgmWLsy4a/W09Hn1OeuDxWvWX8a5xLmxFmtV+WlwjLJ6o9dzDEI/KmEAZ+yoEoORcXKdTNxX9NTUDpZ3pLKZBqP6vgIk5tfblz5281lvU/q3Er5NT0m1Du4p6eAJ4FZ3OhGz8CggQKP/IqhiegHvlnvv/GNb1yeNQejXk7I7HpoAx/16zVEf9Az2GzL09QyPE7cVPzWee4nldouxBD4zcPjqcqvfe1r7z74wQ/evfGNb7zvn5uXP/zhD+9lNWVEaUEZ3gTpyl6ZYkFc176Ic5/v5liGQaXnB/fAHzjOhN6p5OtBBb7R+8xnZWid8qmJuaULYa/GCkoaJDSiuFnrZqf6jX3wGfBqrh3HMtOZKIvmvLH/6h6G4/Ee/dCYpSHLEK+kF+F0vmbYKDDaH+dS5ifSQGuybz/CY5RRyueZc8s2va/hyt/pwKFu5Tx2HJ2faXjWoUBDTaWbn4qcSNZNcaM6+60RCT2Veeh4Sz/C7wZ80rz6Uhqv1Qtq7mt1D2HmmxPT4Q1GiTgXoGsdF3KzXh3mqXssrQThSTg+EUpqHZMysao3ryWjoPhtmAxFS2tNUMW7noZmpnkHDOR7lKSKcC5k9k2lHG8CLJQumjI+3eEkQJVgT9hKPO3KLQrWpIDYF/BCDDw7IirlJjXm+ST4a+DKhUym7yLtuBiLDAynJXHmDoGW1lTmJ+G3w00dh1ygEnen+J+Ene45ilZkFzndLS1pta792rWxardeM3nh6vluzuYnvW9yUdUSnwkM61zK3y6qKYymQYoC7TDn3E3J2Ho+zjtzcLnbkv1xEXSBcrExb5JCUlUEKt5dBCqeat8qDXWCLjwDnsQ9PeYy/n46ofBZlRPant6bFNidojkp0FOpa08di6muqd5b51inrHbtTHxlt0aewHWyznRtVJykImWeAIWkejzuhI8V7BUfK569q6ve69bBjr4m2p5wcg18O5qd+EW+UxW62nb3XWGbaK/em55Z3duNTa2/60/F8US/yU86HE7zvcJNyfCNrr0T+adbx6b2VvBO/enytEwy+ouhaMCARxi+oweBCiX3De+umz2J0zSG1DGvIW+UVLJTbsr/6X2AXA4MGBOUYZQlhDUV1zRsUJQr1DE0sKTHEveVg6Q1vZZY522fJL8YlfggsxjKYtiRsmLy3Qx3ooBr4Pa0vUnOktY7Q1GW+r/iVz1IBZvNODzJf/M3f/Pu9a9//aXfKLoYLD7wgQ9cvPP/7b/9txejWR6oZFiZeX7sa8Lh+KTin/mPxG8aJfikR5kbqIwhsl7mxQFu7hGayfMe+pThe8AobnOM6R91IHsmroRZeTLHQIOlRja95Bz3NDzkoVD2W295+y2NUTQ+iLfkF/ZH/KBL8RH+n//5n7/U4cFX0KZ1iQfrk941vNg+/3XQyFyxPuucsA6Tgef4OpbpCSjdZY4laSfl8PTM0viaeZVS/ldHrx5RefqjRR4ijLRNH9MzDcMuz9D/5DnpxZaGU/qXKXyUteQ38hedH3xOOtI4aiSSnokaGjFKUvRKo274hGNyGglxlWGpEzYmZrRaNKuAcCrM7uBZPcdHV0ZdKXUD1ahkeAwlY3eZQBiVHGAnoDGTWvJWQgoDiWHmy1/+8mUyeoQok1SjlcnVIL48Yeua8lDCQy7WwKQrp+5y5ohiQoA3CLE75S7rS9dTryVhy7wy7MiFr8PtJNRVxawzJOUiqZXX3RAFGZOwVSFlJYyflm4epbBalRvoB5dmYMVQku6e0C60xThMStsKht3zVSCenpkEjrymAOM4Owdzgch6su1OgZZu8kQWivjBAMN1E5z7HvehY7yZZL7QW7qb1h0cProxy08MhdSg0yk/1O/phHxz3ZxSzps6btn3Oj4IJvAQhErdhnkGOvjOd75zv1g9Zqn0mwL/jqd373Z1d3Oyw/9UT6X/FWxTvSu4Jtit43Tt6mDJedK13ymUk1Gg0t3U7w6OaU56UIU5SVgn8HbkO09ePaHTnAvdOHRwnMoG2f+cr7s6Ko36/gn9Td87GKfnJ7ys6tiVjg46A8+19FzhSbhWa/xKZpzod6L7VXtd8dns/8TfOnimuVqf7da+Dt4OB5bOYzbr6Pr1mEW4lL3AgWEaKprOfb0u9HBOmrSuLNVjJUuOS8e363xTPjRKQQXYcPvMp8RHD2p+682hcUePbWXqNK6lwpvhQMqAGlEwaHz2s5+9D4eDz2YeH36TvFvZQk+JDPujL3pfpzFNOUaZvc6TKpclPhOHNbSIoqxN2+gQf/Nv/s2LpxJyC/mhlGN5h9QPH/3oR+8+9rGP3X3961+/XFNZ1pMiw9YSzvQMT8NIPu8peR1fU8/jo2eRhgnDgvAG474GFZNhd+1AO+lt4oE38hX75jXf00tI+dLk7uqwjl/ShjmPKHp36c2ucUQ6qzwrw0ilYXOhYoigr9QJzSHP2n/D+jRaWH+G9TmHzJ2r7M97hkamzNvxPb2U0kPKje403lUeo/eUY0JJz6I8CS3zdaVeAdxpqElvw8Thj16458nPFHV7TwHUGyzh1kElk23L7zRI5cZ4Gg+tK/sp/qe5iuOKPEAaNF+2Yb7q/uJKenpQw1K3AHcLU13QV+9311fKxA6e1fsgC8alxZhi+FvmVkr4ZQJ5clyGAsl8dkK6xIbSx0SCaRirKyy6RWpd1qWtm2APWVYCbjIcdhDe+ta3/pg7JviEKRAuZ86lSYCtApgLrczCa7bpSRd8V3g6GLuiJTuZVfbbMCaMNRoQKTBRYl6rwaAKlJMSd02ZBNTaD/BAfifwnZZzDRs1eXSt39/d/U4A3Qmyp4K58LuQeISwjMpx0NLeufJXeIVHDypddnOxylMiXExzxxOhkCJj9eSKLqTNwj0EINr3PXfhMvFdwkrbCn+Omws2/WYO1dxuE23Z9zxpRqFbIzcw5px5jNIpuidz40RJnui54/kpKO1g3a1P3XzIMan8pcI3tbFS/jpYTnBUaaYrp7wqlbCun1UJY06/+93vvnvf+953OdEQuuR9Tj6Bd5FXBSNT5+7f4aHKE5NsUMejw8+kpK/K1H4d+xVOOxhOSyeXnMpIu3pPcbEa72ldmO53fVnBXnnfBOeKnlfr3rU8p/uf/eloceKBlX8lz8p2pnXZ/xP+djzgxVBUuJC5DH9jrdRo47Vc71Wssl9147Ly/oqnvO6zKo4VX+nZkkYLeVgaBVVAVaDNHco6Lwx5rDr/DaNLI4gykh4pRglQeBaF/r/+1/96CSUz5w8yiPzW/Dd6jqogq/irLPqd8HR02eEw8eh9r4mHTDbNfWQh7r35zW++e9e73nW/mY5uxLqALGX+GXSkX/mVX7lPbJw4N7eUuWodmxzPzEkkbKZPMLWH/eG3bahQI0sRaWIom4YbxpKNPT3F1e80MqozUlT0lVF9TrzlKWLSkkYEjSjc8znmBkXDj7SYRjTHVVnXcVO/zGTgSW/StrK57bvBT1Enpj7xrzFCY0t63agvSvf2kfrAXR5GwzPiIueiY6QnGLgQBvGWG8vi0HFXNk8eoaySvMJ+p/wvPOkppB7hXEw+8RMlQsN5pc7sfJAubFOdXxz70dagATG9wHLOyj9q5IT9Sn6b4XWJa2nE933G6KynYljalZWAUa+fLHTdInBS6gIsYYqw6vbZKYN+O9gpXCcjktl0/a5wSOC858LpZM6Jr9KbR7o/qzIJrzAw3FV/6Zd+6ccsrW95y1suBqUvfvGLd1/96lfvT1s7VSJhSjBp48dpz6MuZVjiOseqE+QnYbuDRfdH8lwRa6plWOaHZwlKEItKtjkJyt39KhR2703KQV3MpT+P/+wW+13dOaYVb6tyoqBOgn6dZ9COhhRP65Pu6Ze7gSdw8JvFCYHUuQrtpEuu3xqR9I5KDzVjz7kO/db2sj88gwCkKzfv2V4a9XKxpp/ZV4U8Crt2ej6taCsNpJ5Yh4DmLqouzhzfjOHrWfONWjoF/OTeCZ/vFPmdUpW820U1FbhdX6Zrda7WPtY53NXTzdMudKP+3rWbCm2+0+Fl1//a1jR+wAxd/tqv/dp9WybkfNOb3nShcxSCT33qU5cd9c6AO+E0+5xrdPK/SkupCF2zZtQ26+8Orzv8Tc9Oym5tr6Olrt7VnKgwd8rjCvbuXrfmrX5PsE5478atW5NW/LODo4O5402TPDf1LUtXR/e+19KAUdvq8L2CYTVuHWyPUVLBUfY1WTfrGnKY3kGsk8gO3K9GkNo3Sp0jnQzvGp3eRrk+pNypjJKeRD5HPWmgSQU8PRWs01yYwqXxQGVcjxTbUHZKedyNaqIg8LxOg5d5lfScsX96UWmcM9TJZ9LLqI5T4phPegklntMrpPJ3FWSMMm94wxsushfjiyxFX9hIRpYyYTRy2yte8YrLpraershojr15fiiZvyhpQvldryPWH+QxdA4+tK/xTjpjA5f2NHiagkLlHvyymU7b1JUHGWnsoe9GPuS81TNPejDXju/odYLu48E2afigPQ0yGtl4V7ky5cs0HDhWevMDg/SQeYUcW+DWiKWXvp733AcG+6dxSHqiCIc6le3rEWQ4YyZoT10rnRS8J1yMTRqjuJ+5W9P4wrd5V6VJN5Ltq4bA6kWYxqo0DGZ+rvr9oxdsDBrBnIPyFTfPbScNvNKvdJI2hpzHiSdDQtPZxecqXnNOJM9L76pqpJSO0lj3TA1Lp2UnAJ0oF1l2ykV9tluspzokDiduLk58dP3r4KhCSi5WelBolVZJTmFc4n2IxX9XRxVWE24nqscOwkw9ehJCw2UVAxOLgqetrUrCQR8x3qAom3CQAn50NdX45GKZylAndK76lviAQZIA0cTeniwG7l3Yso6pjSo0dovyBMP0e+qf9V8jQFc8rGj+5PepYN1dd0GBTqAnF00Zbg2RqXRbFQrj8j1Bxd0gaVBvIgUCPbtkxOn1I5P2ejLf7Dv1GDqrMOCztd8KMgoTFNvUaO0CkkJvh3+v0z6CDDt60K5CEfUqNOEq/5ilg31Snv19yvdXitl0vSroOwVvVW/tw+6dSXGt9+ozqz5Na92JUaEzUJyU2o+qbKQAxg6zhleN+ArQ73znOy/PILxPp4xkP6rxq+Ojk1Gk+z3Vsyodrk6vnfDiXbvXPD/BMtHhVG9Hh90zeW9Hs1OdE93u1rluLaty1wpHXV21rzu5spP7uuem9xPuCcZdPVM/qyxarz2pXPmkJddX11HgU/liba98JhW/1bit6Ld6LlS8KLMJnxtWKqCpQFNUDlUkfV8vbPM7ptKpcUp40iBAO6zjyBmGMAEf/JL/vM99fgMXnqEqh6lrmLumGtD4LWzy6MxBVPFavT1sI/Hr88o3GkvyXY0pyPbm51HW8tAW+s7mBEYfriOLk4JDgwh99oRik5BrhDEvjxtu6lgeBORGogmgzZ/raVyG6elNYv/UOxx3verQfTT4Kccpc6Z3Va6XRqQkPUpLOX7mm3IjVHjEQQ3xy3QsubmfdadxTLhMap2hp9IkdWLck06zjybxNlVJzhnxlqfLZVhnDfmjP+J5Wg+cV+I15Wbp18iH1J/N01u9n/jkBrPG3ow8ELfCah0ZhgddZX6mHwXf4ONJghhObS/D1aTRytfEUebu8lrybr6FO//bV+rU00gDYfJA9SVzKSUfzrEAP0/VsDQt4teWlcBd799aT/f/VBhzUGXslNwVcILXcLVO0Mjf5mXRcCGBOSFcKPLo+CcpKyGmw01tzx0XkuhBoOw0wNCdXDKOFY7rvVywuKbXBsoyC47HjsrcMGb94Ac/+P+clndCI53wCey0wWTSVVOmKuMyJKoaF64tK0UxixPZna50Jc5dgVpPnY87WPJ7B8/quZVwvWqbomt3Tba96ks3T52L1lX7h1GSuWTyd72NfMZ30zBUXVo745LzvwqgFTZPktHF1YXFtsz9VN9dKT+8C98hLwGF3Uq9H6mPvj62wmDpxrBT2E6MBZMSNdFM4rRTrHawdjB3z3aK7G7N6YrwrTypVvN3BedurfV6tr2a09P85IPQ/4lPfOISNs1/eDc07w5v9UjsDAO70ik0+d6unhVdXiOL1GevkVlWY137t4Pfd66VmVbGk+md6X+9bv8mBXQ3XtP4naxLHe3WvnZyQS27uT212b03wd/hZtXPHZ6m9zovzdP59rRK5Uuub1yveRdz19/n836tx76ptNXxSINH5XtVqdLIRcF7xiTZ1pEeCyiZhqMpQ+aJVJm8O3P56MHBb2QZZBdlYL/1qlBBFG5g0zuK4rcyih9xp7HCkDzxW8dGY4rjUj2aKi0ljaU+5G/69N3vfvdeFiMPX+JaY4HpA8A1MKKYW4+b3BotkLEw8qQyr9eXeoTGwEyq7m83CIHFvEvc57RuPdGVvf3GK5y6MSxJW3qdKYtm8mSu68lk2GImUhduw6Kow1A8ntX4wX29ani+GiYTB+oK1etOLyWf0agAbG70SI8aS6RX9RHlXz3jbVuvFpPxa8zyPb19zAnl854CmJu00nzyiRzLGt6Vybb1xjLVRt1wNqdSDQu1HueqBuDM6ZShjJnDTbj/+IVQQ3XXzDslX9Bwbn/ES4as1nzOyZsyl5djm/wvdRdpI99LPus7ejh2eem8hm3iqRiW6uJ6Ksic1n0qAO+Emg7m1TNT/SBbRc2J4s6EuwlT6Ne0gFMn3j1cMy+KTIuBQzDnmpM/67pFELhGwE5CywVBLxN2osEDITe6Q5qbRobXlSp45SIlA4FRk8hPo5ULLe1pZNGy7SR2EdvhJNsWFmN8ZTBa81mkv/3tb1/GKK23K2GxtjHhoD5fBV8TM4MD8cRzSRuGc3UeMpPQO8Fan1kpSjtld1eqQDK1dQ1957PdfNF1GrxRpBtwCD71+HHRyBh5LfjuEuZORu3HSb9zh8C49fTS6vo0FXe0vva1r10UdgQv+sG1E6/Bp1lWivmK9674+jTfdvNxUqBXbdVSabRTQK6tZ/XMiaK4wnH37gl/rIrAdD/b6tZsk8uiOOh1yhxkvrFuvPrVr76sI3UH7pq1vlNsuvuJgx2uTsezrgUTrN2avaOlVZvddx2Xa/BY509HT1P99bt7pyqr18ztDm+rtanWdbJuVbqYxqj7PfV/1a9OBurGs8N5haGb1xOf8N7q/mMX6SSVRYq4mHiF62riyt39OkYqblmvv1N56wwpKuXIuXoGG16vgqeRg2fN2+rGq8Yt4RdenldRNdxEz05hET++xzWjB8zfpExjol9xpveNfdXAVOls0jPcSO/orfKE6vWUtCoOWQf+w3/4D3ef//znL/1F3gdG8ImRhpIhXWxiI6NxXy8rCn1lfVEXy81tjAZsYFCfuNQQorFELxAiJTBKsSaR88lUH7SHAUyc6pljImNgZo3jdD7qoH8ahDTgpXcY9zTeAHcaHLkO7IZriefMJ+TpxhqtNGwor9qeuox0ngYa9TjW4QzxUvehn3re5Ma646dHnDmxEo4syKFpVLIfnoqWYVb21VPmuJaH2WRSba7pbeZGqh53jquGk8xhmqGp8oUMzcu5p4HHOZ1RQz6no0lGN2iote0/jXxbwAiNeFCY/Uj8ayj2nv1309n+5ZimB51zO43yjrH4S8/ENDiDCx0s0sAmH9NgKq6emsfSaiE9FbJP6pzquraNSeBb1ZXPQCR5nCT3VAirIWUS4JKJu0BRrwTmxMvkXJ1gcY0g0AkS19bh8046jC0wBxRa4qRNdm0St6ndSeCTaelBpFWfYqgdk04GYx1VAZgUzKpc5nMweMIx3D0A74wzCQS5J7O5RgHo+prwVgGy1gdzBQ8KDDJ3hRY+hAXqgXOiNK7GoBuLLCdK2U7BqriY4Mm+TIJw158KZ16XQacR0jmLEQahQmbK2INvmCy5t6Rt6ANvORaHlXBV++qCYPK7NKS6E4SgVT2mduOZtKNLMjSRAtxjKgw75W9Fe1XYrYrUSpk9UTxX7Wddte589tr6V+9WQb4r6Zac8KZSVRXVLCvcdaWbqye81msqOT/84Q/v3b8Ji+PbRKjw2Gdh/JzGVVhX92uZ7lfe2fHZnRfaRNcTDHWMdmPcwXZSf+13t37fipNu3aj4mPpwsk7VMvGJk/pPaaPivxuvCsMKnkl27ca6W4umemp/H6vYdpWzEuaJHyX/q55xNWyrhr4pU1ly02fVnht8/PfYcIqyaZ7Mm7CphKt8WjJcx5QYyiqZg0kZxZPAkLcN69cjuh4pn8a09K5ODyU301KuSVw6NtVTjHviLOku8Zp0ZfvA7KbeJz/5ybvf/M3fvBh02IDAqIOXknAhm2HoQB4zTUYevsJz1KPXiwoymxd6OIkL6kuFn3u8C26Q9fBWIpcT7XPtZS972aUOPJNMk6Hnjko3Mhcb0PZVRR/53Y1D2swTwczblBvD0gR1aDjyPTcd1b/qpnLyEulL/GfSbDdObSv5EMXQMp+lfT18uOZ7ejSl94/waVRU1uW6ffUQpKRpvYrUdSjgOes1761tZihqytdVhqzJtfVoq4a5DAk0FFDazkgiE6dDAx4+JNwatvTM+uMXvJScQznnrTPx5fyvvN256DjlvEzenXNVI2MmYZdPpXek93KuJu6sM6Oqqu7zoIala4Xpp1VOFmbLSojYteF3TdJ9iuS62Ofg6eo4PZuw3rL4P1Q9FC3+Kt9McCaiR2LqYbXDaxXm83mJN3NPgScXIxh5WpBlTqu+dcqY3/SDk9/w+HAhz+Pmp/GYlMEqCFGcvIZE6YaaJyLke7q8ypxluDIAFjut1BjyJiE8+97hortev1e0snqma7cT1E/psRvDWup87JShKixBU4TJYWDSxRz6QqiArj3FDSOeCbpz0TuhcXfWKAhJLibUh5GWtk+ZduedVwXyF2tZwTjxjJ3yeKoYrZSq+nuioYcqEw13/3fzMes5XQ/TwCH/TGFjmluTsjX1kXnC3Mpds9wNU1CrivfpmjrBO/HkSjeTwt615Tsn/H7CTRq2u3rrO1Xwv3ZdncrpXKvXU4Gp1xPevN/1scI8td3N89rPrv+JtxOZoKtjKhPNdO9NdXd0OD3f9T3fO107pzYyFOyxiv3TAFDvVbrzd3pqpAEnFa2kxZV3e7ZTDVW5809JbyRDybiWB2hYp0pdwuQzKrAUcyQq+7rJxHU9MjDMuwmGLKnir9KLvKJ8UUOfKPYr88UoWxtpUOeP+LYucV89nnLuC7+ljl3msMEj6Ld/+7fv/sE/+AcXgxAnieJtzQfZSKPI888/f/mm/2loUYZTsccohIGKzVk36vkNbtzAzzQatImcTSoBQ7GQ8ajDFCjWn31LwwVyHP+BFS8p9YocZ8ZH2VLPFGnM8dMo4ViZA0r8qWNl0nefTRp1k1ycZ7id9Ykv69YwV/NtmVhdQ0WeYpZ0Iu1Im+ouGZqWOpU0lPTp+3k6mjDme9IieBS3GZYmfHwYh5S5TSdiXRql9KTKhPb2V5phnE0cLk6oR69FDX+09X9fMKIJe57mlrK++p7vdvPOPGXyvLp+VM/M9PzUQKhxSC9I+VLKfTm/0xCozCbuT9eLB03evRN+nkY5Fai79yiTwts9OwndWXaCya6tqZ2ujWsUnxPlcyUsysiN0cXAAcOWgJlgWOq1qK92o3Mi+OF5vDc0WMkkDYlDAcf1tLrWp2V56ueEY/sjA+mE/gln3b066Zy09Mm4fPsKw4PxYXTIUyNkZO4MpFVbBuUOjm6l3dhN41oFtQrrNB8mWq33OoXAersFqbazKythfuq/1zo3exMQpoALszc8zp0FxisXiMTXTsFAUOI9c83wvqcepqDT4fYEF12/H4MXr8opr9opkRXn9b2Orz8kLnZ02s2HW9anW2DewSUMljS0TnzhBOZOaU4PPO5lOEblQyfr0uqZ5DPTeysFO9/teFmlpVSoOjx0/LL2YUXn03Pd/1V9Ff5raTHfn8Zgx/cnmWc1R1b9XfX/RL6axmFFG/lswt7x32vn7cTLOng6npbz6GQu7dp+1qXzEEpFeVpjUwn3O5Uq5Qs35pRhbaMaQDJ8KT0Dauic8ptGA2UHjQMmhDZ1gwpyvpsKot43wqTcLHzIC8geGEgM70F26OaL7el5ogHf3CkaK7xvYu+U1cWbOEhjeBpW8p5jJL4dOxXTHLv0pMID/OMf//jdhz70obu3v/3t9/lVkW2RcfFu/b3f+73LCaIYmgwFyxPB9Pw27AqvI6MP0Ec48Zk6wRvyF5vIyl7ii2fxrhVfXCNU26gFcWvSZfqhUULDBvA6zm7AY0xKQ1jiUXx4jTpM1K1OJX6lJWVFf1delAYAr+VY2tccOzfqNSrp6SKdauyhOD/MCWQ7ekaZh8i5kWOUHoFpAJI+3NTnt5ECPm+7aZBN3cd5lJusehKa38g2MsxO3KexUPk/82Ml3EbU6JUkbeh4kvrsn75gaEpjdI4dH+lWOsnwNPGsp1mGwuUY+04ap60DXOopmIai9GBMWhQmaSf7KKwvilPhblm8ToSeTpicFM1VXVXw7ITFrOe0LyshrPvfCYJdPbcKA7fAXfEh4bJz4A5JLp4ugOkOnP1Z1c1/vUJ0MdQyzIQwPrXiqRM8TvtYlZtrlN/p2dovkzm6sOdi6yJU42dlJLlzkB5V1jXhdqLhel/cyYRMdAcMyThXtD/Nr1S8XJShG3MKpEtwRxe5M9LBsOrjNN87xUPGnLTg4iWzNxY+Y42ndjsc0V+EGWOzc6GUgXf4q/VWXpV4vpVPPa2y4rt1DCd4q0t+VUqnPq7aXYUknZQTZXyaJxUn3ZpTn6t93rWd9a6ey/mZ/ZrWwFQepnWsKrv1/bom7PhJR9PTGr8rHc10c3cnT9R+Tv3IZyZPpa4PdVwq/F07K/4+lYm+an2na8n0bEdX3RhMvK1ru86X1f96/WSOVDi7+qZ5sJN5uv7UdvN/Ve6nPnbXpv5O8/ixSq5vzpcaepWlbkhZR6Xjym/ymWzLeir/so6EMfGY3hbClZENyDueTKbniPIeRVlOw49Ku8o8xgpz1aSXugmAM4xGg4CbsYaNaSyhmJuG96lHryu9dcwjNK2x3SZmxWfnQdbxWZVbQs3+5b/8l5fUGqYhQHlnkxkjEFEKnlimZ03Wp5Lub94lpI4+YVh6/etff/fyl7/8Pi8Vm3zUKW2YhF2PdWQ+PKm+/vWv35/olga1zKfjb+4Bn/l/Un5WvtXoZp6izmMnjawaJtQBxKNGGj2irD9x7bi4ielYdRvwyX/r/9QP/K2nXLbDNfGRRpo0qiXNZHiedGob6eGnsSgNQuJJXcpnnVvOA8Y0DTZ6SGffK12rAzlO6p2mrHEuq986Rqa6SH71k5FXTa+0DOEUd46n7ar76sEmLqvMlvOojhcfYM3T5rPv0oZ1pB4iD3KcxY/PPDWPpRMBtz5/y7unz64W/9X1qZ5VfScCrM91zDn75ABr6bXIrMy7Ut97yLIStKd++Z7wYTThukx4p3x3MPiMCdx0pZRpgxMWaRYFd76T6aWl+ESpOrl2K77rezINc0QJs5OWhdQdGD7s4sBc0sVSC779NKG8jLYaJiYFqdKl8IFb81vJRBA8wHcal2pdvr/Cu/HN7BZBK7rX0if6wGdyAz0Zi6oQdUruBH8n/DMGwET/FcJgzOYzcPxW86Yqh/YtT8OqC/r0bjeG/u9w9mJSFjo8Z/9287Wj17y3ancqia+dkemU73bKeHettnVC75WeH4KPr5TSbtxScToZp25ede3Xsd3N+9Xc6NbcOn4n9Xf1TmU3Nqf8rFNop/qmeTDdq7S04xOdzOLz07ztxrCbAx2M3dhP1yY6WdHdbg7v5mjXXsLYPfckPLjiUkG+mysdn+jqynWi46ePuWZUOpnmYO13ylATX+34QpYMGRPX6VVd6/MZ76vEWoeymAf66P2CHIH8owzEux5/nqdDZTgN/5GlqQv5MBNQ806GtahDaCRyXUOW5sNvebdRBtSBXGZSbO576Ec9OUpjkTgQl+lFUedfGhPsW72vQeZb3/rWBVfk3eMecijeQuYR1cgmfhx/67R+4XrXu951fwof1/B88jCJr371q5d63bClPmVfFfHnnnvukiIDHGsUzM1fjQA5XhqTNLBkqKJ0Y4Js01kobzPGmaRZfFdPnwyvStr3U6NEquFGeH3Wzes0wEpjjpvt20+jKzSCiUdxl33Icalz0nc0HtGOxhDzU6kLa6y1XfGSm7Tcc0zMaWUfhc2wxgwXlSY1Jtkn53kadbyWeEv9SGPTT4ShMz2U0vCWYyXM0rlwpTdXerCl15e41QtO+kxPKflUGuOcH9KpfEh9NTf1OyPugxmW6uL9NMu1bTxtmFaLcn1m966FgWNQWWy0UrqYaDjAy0Evnc7aPLVXhemd4DvVOfUzvUmcwL6vNfcWunLCZhx2MqWc4DJwSua+qTtxK8ViV5KZWHcurCuBJq9VnGWMbn2WRYYdFYUFLdfiBAbgqRK5IHT96/pex9ydHUO90lWWNmpOK/GQ9dfFKeunXhduXbllmHliR10UV/R4KoSeKmPpQktfELBgriSn162ZnTXj41dlaqtT1rrxSNf++k5VFCYl48VeOr4zjWn27URBXD3TKdkrXjrR16rtboxrP07qvLbUtnc8v+ORFdcd/5jou96rsEzrYKfk7uCvfKBrs4NvV193r/7vQq+n+qbxrvV3zz/JnD59dzV2Oxz7zmotrApgrSPfX+Fq4g/1fkdHHT6m8TmRfyYY8/1KA92a1JVKv90YdGO7kwdX/1fwPMvShbJNNJPKZJVJ0uCUGwcrz69JZqjrbYUr+UEds8zZgvzAhiFGHI0KyrvIF+bkUU5URkT+N1xND5iUWZBR0B3MB6kcbv4fPaE8dYx7eu5kSJCeS/UEOPuTJ5UlnhKnHQ1ZV6YOsI95PD2w2FdD/eyzeEnlN2HJeYZ8hnHKTehvfOMbl3sZZoUMSloK2vW0Od41uTOH+WDoQsYGfzzDu6Yt4H1zOGU4kYY9jSXK0ZWmDG10k5Vr5lt145y2xLvPanyqxjQNF3We+Fsa1aCQXlYai5JXU9Jg6HhlbqLUXTSCGraVz3bGLz157HsaLjW05Qlp1uuz4jaNHOm5Vw02NRRWI460aP3JGwwLTIcJ53mGdqaRyPxL5lT6UfF41ECZ89w60nDkJ3EmLeQ8zPelAQ2JmXjdMVGP1GiocU6aqGG40Ck0mbTmXH7UULhpAZyeXd1flSdVqCYhbBK6Vu/s4HOQtAqSbA6GpkFFS7gTng+xxZnobyX0dbCewtkJjF17yTj87w4IE+vEsJSLQhpu3IkxzMuTGExaB164xjGiTB6YLQt2uudNY9WN506gclchj533RIFOCO3qMwacxUEm5QkCxuhXJo4gAi0ghGh4keHwDn1Og08HSy6609hSn8nXjaPO4znpe41ldnGogkKlT5kh9XvChW6k7t54oom7IFWQE8Y6rrVfK0Wulq6NrItv4CHxsCdaeQKkC/IkSO3aq21lSZzpdut4Oy9SoD5RCh+rVMG0wlWF+RXMu77UenflRMmb5vKkPO/4yfTeSdkpjStamOrr6ulcnCudd0rYLe1197OdzhhRn1vNp8pLap+yvm69WMHd3T+lwWtkolomml21282zk3qn8Z3obbfG5lqxov2Jjqc2s/76u8NDhWuqv8LU0f1UurWla7/eO5VBd+tIrbv2YdffZ12q11AqMZZp3ah9SkWOkvSWGzY1JCZ5eFdSmaRkOoNal8pnekFlnhiNFcg/ei+lZ74GFAqykh7dGpVUAnPDTs8ElW0NEOaZMQcQz2C8yATP4giZA4MJMjX/9dDJvldeU8cpxyGV41SIxWcqqsi74ITCBp6nbytnKn+nLNjNG+57yI+blvRX3Kv0c++1r33t5ZAWdDBwjFcTn//+3//7JQxOryYP3DGNgXBpFFSGxUGAHFDAg2HI3J3SQR75ruxrAur0WDMXjvSg9whtpKFNuhIP6gcZPqZuAf4qv/S07TrnKl4z9FB68LryqWNjuhLHOukmja/Svnlk1YX5Nhm6Y5ZJxA1LExbrFUbxkG3zjpvZ9i29isRF0rU4TJpWP8qcS9Kc9M7HhO8/80J4YOJc+klPLQ3EtqNRy77btoa4bD+NS5nnyoO0knd13kbipNKo+n3m981+PKhh6Vpl5RoB62kpQjtEnCBqEgRWz01CRDJG3VB1gUtLrpM8Y08nBWAnrO2Unkn4nhZzfnuamUYwChOK3QKZxQ5XTkSt/MkMdeXjXScKDAcGwQkOHl0N/oDBZIaT8H2N4pXwwRw4ipQFg3Yw8hH3TR93CovXjIsHXgxFultqLDAMLt+BibI48psFy0TS4JrryThW4yrtyMCqMCC95fGdKaApFOTuEtfoA2PBc57YV/uQbeSxvN6XqaU7eS1pwEr62ymV+dwksHeKSdaXrs8TDa+E84kHdO/YT3AEbbPIsvBSoBMFTAyKLuRZ34kC+SzLjtecKINTvZ2ia92rZ1dwTTSwKxXfO166aqt7d0djt6yb09q72tF/6DZPnl/V032f1rMLf6R0sD6JvLIyKtRnOqPaBEs3l7p2J7g7RX1VJro9eX/ixxWvE63sYK9wTe919L+bY7s5UZ9NOW3iB3X92fHv1diu5NFOlnvs9SGLSuQEs4pshgT5fKWpNOZ0hnKfqf+n8Le8VmFTOU1+koqt7ziXlW/1FFD+y3CdDPHRG8bEzYZRmeBZhds6xVNufBnK5RHp6Y2envBuYiJ7IM8RBqYHRJUzE78pXyaO7EeVPVO+TFpEdzC1gzKzyrY6gmFMmU/KYk4YjFMk6v7iF794kdtf9apX3W/OoiNk+Bb9wyP9zW9+88WY9c1vfvPuBz/4weXbvE4aS/jGOJN4tD9cB2/oCMjqyPP0xY1I+6DyrxwMnt0wz9ClKkfTPmF81K13lZ5bljSaqjeJ9/RMEu+ejpYeeDl2yufSiN5ymbxZWnKM9W5RT0lDUraROBCv1Mk4UTLUzpxJ0kTiJT2tUnapcoHhic4X+y3dOAdqmBgwpoEp6U9DYBoZpWWe/5MXDI7q9c5LcZDGRXXc5GfpvKCxSBrK75x7Gp685jxxPMwFZV2+r4G0M+yrd1ZvyafqsTQJS3ltpWA8aVkpjbcISqdlEqQmRXUSpPjWep7WexcDJ3Qy5anfO4Hulj5O7+qqSHI98yFBdHh3YEBJhtLV5cRy0cQtFQ8k+k4dLDKGgGmlxqDDdXYYZK4uPPzHyGHM+UpQ3OGpCg8wu1e+8pUXRT9PcsObpfMcyXfzm354Mlh6otCnNBLlYsv9xAclhZFJ0JRZJG3pPpo7HPZVhiOjdDfJ3RZwAMz0m8UZvDNeLAj0gzFnp4f7HR5ZQDGidgJknqqSwkYdM2OPq0BWhZasu6PhnQJa36lCaFfXTtHYtW2/PfYW3GbidmAwoaX5n6ZTDGubL4ZScXYrP0rhpBvrDhedsjYpXB3cp7jsFMXVs6fK6i246uZPpY8JL6v2rsHHbh5Mba3GtlPIV/BPbazar7De2tfV2E7/63is5KsK69TvUzrz2bprXcs1+O3aW82ziocdzHUcE+5pHengqbjq5kUH06rO2m4He713zVzfzZ36zI7mH7N0tJqKj/kpUd5NEaF3Tr6X72bdeT89ZShVHqlGppyLNazGtqoy5v1q2OIayh/ru3Xr3eFGpYqkOWE0WtBX5KvMP6MsUJNJa4hSua0hLHpRqABzj3aQPfhm84rNU+XpxGV6HqXXh/0Tn6n81vt13aUeZFw9gnLMVcDtH/1RDnRemr8To5IeSMipGIu4zz2ucY+23cjHAGX+KeTs559//u5LX/rSRU7P0EQ+GmbsjyFxGiDyeupBSd/izIgPPcPEo8aWHE8KvxlvdQc9YTKSIDd9pd0aNqVOpYFIeT+NXl06CttwQ1z40uiicUY9JcPtHCfb0pDk+1w3HQxhiG60G+Eg/F0ur+QZGtrSgOY9jUn5bhqq80Q3w+T0JMoT8NQ9qq4lX6m5n/70BVxr9HG8KXoH5lypid95XrgNV1Vvtr/CkjmWaC91mNwk11inMVo9MfEhnmwLPOgwcrqG3GxY6gS5/H5IAbmr80SZy7o6IWBXOiHBa1peXVySkdcdla4uBopJlMeSOtF4FuYEk+piGq13p0SclJ0A2V3zlCtglEmk1bMruYtk2B9Hg+KSyqJAHewywNjNMwR+ZKosIIYNmu3f8ZAJn+DiRNjORcudCPvGbwxdGde8w5+TG5zRJ5+p41gF2zxhJOte4VjPKHZjtFaDQ/BpUkn7J1yJF9vkWfqKYEM9GvRYGKhbzzrGQmEvDVf2m/GkUA8Lo89oWKuhk7VvvINgAI0oiDD2Jv6uHjyrUoWa+r97fjfHphCiSVnslBC+9VSSxpPxa7RTAMsF/2kox09aOrx2xoFr6ut+d9dO14WHxNE0vrWdlVHhBCcrZb7unFfa6+A5ae+kH6dwdu8nXUzPdr9X7a3avga2LJ0X0YmBYJKTumcr31jBeI3Mtao34UuFevXsJEtV+juVxVbrcTU4dDivfTjFc/d+B28+N5XVWrKb26dyacX/6n5t9xYZ/FmU7Hd657P2Icdg8EAGMzcRm3oYDZBnkKfyOPikgcwh4v16rb43eT2sPKAqb8g5UPuo1wT3WNOFXaVU3UGjjjKAiqBeIchCKvd69xjuk4mjp/D5DLlTFke+4zlk22pU6vBrfdWAZN9VtqtxKXHq+7SHLoHs4ziZWJiSsj5yEjKop1Iji7761a++xxeyLhudhvwR2kbfeAYPJj5sZmNA+9znPnf3r//1v76cSGf4m/KkCr76huGHXAMuc5KqFzA26Gt8cuOz9lujFM9k2KH91agoXWhU5H3644nc1pE5Sn1PuJIuDadzfDTeqANUIyvfOg1As3UMpef0Eqzt6YVnv80XZUoRnrc/6EVuvtumYZ7SufKw7Zk3S3m55iISh3w8Fc561KvSgFdDwzSUiRu9fXhG4485sUxGzrM/80Lqj4yq0VBk3XrEZW6j6kFm373nO13S9ZzLruE195b1Z4irhibeE0d6eNXoFuF46jmWkgj9GDqTzCvdM29V/HbPXwPvKQyTouDR6XwyjMucP+mmWNuW2cIQWCAzCXW2q5tkEk8VxjvYT3DwpEKGxOkCkIvppMgkw+GD0QJDkiFVeXqGyftYIMQlEzeZlxZcjyKdhMdOEO1w1d0H/zANY6fraQI7RbkK7J3hrQogk5A9KYr1GU94y2MzWYz5ZicqaYpvcAezl5HpOg1TYgGWwYNn3tVDTAYrc+zGXzrRWOjRuRTzcdUT4aoi4ZG9GQdtzDHPMd98vyo0uUh087gqP1UZ6ca3Clc5Brt5OilrJtjUM4n+KUzJ6Olvnri4Ulit87FKxePqf75TFdNV/bfwupP1ouMXK2X6tP2kzY5eJn4+0WTXzgluV/WvyooXdUp81+ak9J7Acg2fXb1/0m4nA3QyQQfvanw6mFb/p76ezJUTuume3Y3b1PfVfOz4Yu1LN7863E+wd7z4lGZO73X8dqKdE/50ixw28f/KX07qWeHgWZWO1lSQMBq86U1vuqx7nlhGQR4zDyEGJr03XC8p6aHQ8YdKa/zW8JShXBXGbCPvJW+xD3Xe6PWNfIb8by4T1/XMe2PRuOE11nWf0QvEtlU6gR/84JWD/KoBQw8EDRK2zzfeIsCG4S6NIhVv2ddqNPI70yqkEms9NWeVx7Ej+1s0OCnn8zzfPIPXl2lEqJ9QMegF+OmL+oAe8dSNnEioG/QCXSEL8zzf3/nOdy54MpemRjHaY8w0rKi7QXd81H3cvM0cs9nfDGFSb6rX6Asbi7StR5q6jYYfjYn8x9AqXHr9p2OD9edHA5n5n/JEthrNoHHBMXa8q7HMe5nDp+oDjrnw2i/p19xflDRoCJ94NmROnZsxdUNbPUS9QKOKxknxJu5r+Jr9d04YHeE74kVHEGk2+QS/0bX+4l/8i/cOF0bepPFYfPC+99LrSb2q4jC9D/mf4YIZkmff05CWczHHRxirDcJxVj8zjK5z4ngww1LHlCVcJgeDzwAwyQiZMtnwbsG7doHrhL0nrXclZFIYAHOgqLg78DAbEM8kqQtEWv8ksEzKbdu+03kk3CKITH08rWtSmOsuSMKXQk5+nCziMONMnbAweONZ0/srj3V0shsuloJFXeArfms/pqK3DcY/YAUe6FlXzU7ITDxMAvpUqhCSfViVfAd8mhjS+Fj64clv0mW2idBBSeMS19wZ0tBhnTynh1m6VU7KnQzQJOyVhrKPOXYKKOnRp2CZC7zjUcc5aS4XhoozijshGXKYO1cV3+JaRq6wUGlvVxLGXPRdBMwvplGvSxzf9Zv3ELxeDCVxPfGdem2lbFLq7tpUunp3z1fFtgrPnTJW4VzRQDd2q/7vSvfcSiGeaOfWNbTyrOxTxVUH5wTb6rmp2ObKWLB7f9fWLTha4bajuayvW8Pq3JBv3yoDrdqY4Oj4fR37btynObRqZzcfOpruxnGaJ5VuqxzR9WPXh6md1XO7ejp4ujomfnTazrMuCavGDxU0892wyah3BusucggbXzz3/e9//16h3/V5mj+27XqcNOx3XXeqh0bl+1kP67YGDr2vTcacCZDNq6psnEpzykRpQBNn3OcddC5DVzTipBeLIToUvSuQo/DuyYN5su9d/xJ/Gb6YhpVUWFPeqrIfuEHu1Ku95vykII8ii/MNnODS9Ay/9Eu/dO/xAt1oPEOfoCjD4pGFLEydGpU8fTvH1v5obAIWk56bl5S6hVHvFfuXoVtp6IFObSs3yg2BZDzEid5oerdZj6dgu+FqPiDpJ40Jtg898BvdHPrLFBzpvWT/04CQia/tk/K4Y96diGbRQCUNZRhd5tcyoTl10Deepa/qGXxITfJrv/ZrlzH+2Mc+djn5L+HQUCXc6ud6kflcp5snz8/wvjR2Sc+e5J6Jt73+cz/3c/f6jXMc/Ns/7qXjjThJw2AaxvOauk7O4zzRsTrypOcaH+lLniDcGrAdl3QaESfynmdyKpwAAxQIxQvFOFiYv0yQyZtAntadZVrMV+VUQM82V4qb+V4kLK5leJHHVmLwSG+eSYie8LESiq4RUJ4UHx1MnRBW7/tRaYcWoAnjSsGhzD5dCt1xYKFLizr/wan1MEFhuCwUNQRrpwRN41v7Sf3f/va3L/UzrrTPot3lKpramur2mVOa7gTsim+9XvRuUSnWIl6ZIIW+gHfdbVWmZaiZ4K4KYS68jGlnJKrMuibgOxmvFGp8zgV+eke3ZT4mbqyGbet2F4SdMBYzeRXj7OJb4TTZJbjW5VzazSR3k9Bfi4Y3d8c8GTHr8kjezhuy0iFwITw9dun4RVc6nFw7r26FTzro5vI1vPVEUaxtT/Cs6KeGcnTKcVdnVyr/uKZMa0BeO+Fp17axw88pH83nO3hP+3Bi8NytFRP8nWGhwj7hfqoj4am/8/0OF9P92tZOblvJWBMuur7V/nV4P4Gv9muScyY46pp3UvetZcWjdriYeM5jl8z5wbqHR9JLXvKSyzWMHXqumOhYeQbDkkYCEk7rqdJ5FHU0l/JJJ1Ol4t/JtqnspfLmvfQa9r8h/Bo/Uq7S4EBb6V1gqJSe2soItpOeMuYq1cBgv9K7yY06YEBWUL5Ir6+U8youxVkajdyATE+PxJ2yn33S20hFG3iR8ZU300OduoATmkDH9CATvnlfefcXfuEXLt5LpmdAJoMmMkTIXJY8x6axybiTDvztpqtKuIq1J7R5j34CQ55YJuz2WRrgGeDKHFJGF+QGqB5FPIMhyM10c/DynM+4KUo9mZIkQ8T0EtJok7leladtX0NFGpQ0PGXycfukEcR+1jw9GoINrbONzGOkM4E5pICPNvTe0tDEPfJlve1tb7v71re+deEPjFMaK2nXvFgmn3b+qdPUMU+jrvhyk56Sc1WDk/8N+aMI/8/8zM/c54JTbk+vLnUF28wxq8YgcVvXI+ec42C/7UPW7fP+z8gbPRrVhyjyj+TR6pZPzbCUAoKDAkBMeo/ANJYUgBkgE5pVBTQRddru6fV676SdlfKTn8zWLtHIvLv+TW08qaJ0i2AwGa12Qmky3e6/1xJHjH2eaABDTyOGjCPjjl040iWXe+wwGF/sSXE1R89UTmNDs7jYYRU3PCmT5tWxS5dT36+hXrV0As/JmNZnxDXCQhrf3Mni+TRK5Ps1HjwNSi5ohtBpBHSnjcU5dz8qjFVg6/rfXZOBU3eejCITT3hzgVAwffnLX35ZjHgfodPdrORdGr8N+dOw5CKG0bIKlhqVjJ2muLCzgKQrdKeQdUVjlt5gtK8gpMsthi4XgKyv1pt4ejGUTiFN3Ozo/YTnV1zn9RV/zR3lW/pU28r7E+/s6rnFKNTB1D1/ujbeWqb2JliuxfU0PtfUszMMVNydyAjdOnky10/4f72fbexov1OCK0ydIWJqf+pXh69Jzpnm5Ypeu3dP5vctfGC1RnWwTmNS5aIVvU8Gj+5+/l/hroOlw0Ensz1WsW09NlBeCOEyQbHfmXg4ExizprPeI4dkSgTlhxoqZumupXLnMxVOv1OPqTK/16b5pteSepJKrrlYqseCSqXKr3KASh66VXrSVw9til7V6VVBSBhwiCMTK6uIJ1xJd8LGfZMlK0elHGT4jAaF9K5QtsQjzRySegeZIyrTOWAMAlb6jiynJ4seH9/97nfvfvmXf/lyj7A+66Qu+qVsxfcf/uEfXmR6oyM0OmRCeD02DK1SsaaOzJlD0RNFY5P4zETS5sfR6ObYaSzMMLc6V1OnMCrGujVI+Vs8+l/6krbNPZWGQL18cgNXmTZTZ1ifcrYboNKiYyGdaJzingZMDXkaZ/T+Sk85ZVcNh2kgwZD0u7/7u5cNf3RJ+uHGtnA7hqnzaODSQKjBSR4hDSQMyRsysXY1JNe8Tj8ZCbyNOOCe+hi/03jkO+pXztfEoXM/6UpnHo2D0kp++7x126b1Oc+dK8LiM8n/0jD21AxLyWhFrrv+DhZF19XO8p31PWnZCY/XtLMS9NNlrYa1cZ+Jo6ti975wVEFhKql8dQLFNQL2qRBb27adSdjpCuON8k08NMYOGAjEj+GR91SkXTS5Z14lF5s0GOnVoUunE7MLVToRmqqAPAmJjqsTtyZEy3mg0UHDjrHDukFWJWAa+yq81NLhXTdax8yY7xSSVkauxIOMz4VSYYYxy7pg7IxVDc+alLRKQ50RNnEADAhMLr4ZEsd1YMrx4B1ozWNmFU6gQZMg6larxyFjZcgf3zJP6DRdpCk8D03DzBUMktlrCKvjXPFQ5z8F2Fg0PeHEBVvvPT7pmrqaeykcP2bp+j8pm/W9SUnt/u/m0ZOUiTeseHCd4/ndjf1qPk7XpzkzwX1NST4w4XBSdOv4Tvd29Wcbta56b9fXk3nYrX1dW92zqza6ax191HdW/GNXEr/+7+i29mda3zv5o4N3gnM3P6c1scJ8DU5u4QlTO914de9VOtzR96pMc6STHXfy4K3y4rMo9oH1lDWXdZs11BAn5WjlPgu/DbvhXdZxFVHrTU+RxGcq0F7PXfwaipVwZn0dT8vnVchT96FuDWLIGx6oomKbYWRu6in/uKmnDGOO0fS6SZkxf6tcgjNPmzNtCdfBHbIHcobGhOxjx+ftVyrFOhTkASQ5P1RkNa5kmgllNIp5PfnWQwuDHPCxyZabd1wjf9Ib3/jGCw398Ic/vPfkUflWB4Gu8HQhBE5vJmnI3EPimII+q+ypsUEDUHqHKHMZocN12vUkaWDWiIV+iIynV7l4UfbUGOTHTUbuZV4djT96MnnP+gxPq5ECGkeADXmWcdc7yLbFuzqW71G3RiBhl75sO+eFHnbKo9KxY+sGtSengTfgqR5tntSHzvGVr3zlYljSI02c8a1sD37TsKORUprV81H6Fb81PIzrPutHvcj27Js4+4kXDGjmSdY7yXGpvKfmSqtroKGwiXO9uoTfuvVwTKNvzlVxpSFf/KYR1GeFWZpWZzopD6J91MVUS7KdyDwolVHfutDthIyTBf1E+KgMlf7A4NJNUEbEIGXOn52we9r36blrcXei1CV8q/+dslAnA8zcRUbXWycIDB6jC4xNQwG7Tuk2WNuYlMtdv4StLoydENvVn6FvXVvZXxaLZF586GcXjlXhy3pTAPL/SnmT2WiRd/fJd11gJuE5i+FxwC0jMfEkAgjM3WdqLrGKbz+de7owpIGp4oL6MV5R3PVQyKgGXO4xBp5AR6FdXKRZRPFA4uPuml5y7grojktJgYiiYJGnr+ROB8UFtIZmdopKXlcgdBFKvLtIpPFux7fkRS/W0uFmxcum/u7esa3T+rqSu0oJf1dybtU10fsnPHsHXwfTpPCftLGipxXMdW2cnpn4alU4VnjteExXd1d/d7+GFK5Kbb+rv+Kz1l/Xmqx7eqZb+zo+0t1PWLq2pn6u/k/rT4ejWkfHA1f/az9W62IHxwTbKd1P+DnhOV0duznU/T5tY1pfahvT+Nwqgz9EoX3kFE+HoiALsn6hYKrYqZzlTr+JmXmfU79YfzEq6AVvSVk95XL/V3j4uDme+YgsnRI4yZK5wZ6GK2A3iXd6VaT3gwan3FCjbr14+O3mVz6bcAlLvmu/kOU83UwZHZwbXZJ4UlHN/EHZln3SaKCulMptJhoWD8hg4MF8mdah4mufeBd4pQE9bKQHZESMRe94xzsutGQyaGRGQ7joK7KrObk0fKXxRHlUGuCa4296AsPNNIpIo3wbasY3/dJ4SH20bS4b9B5OxbZeD9ZR1kvjQI6lxgDzCLmZ7DglHbrpKj1lEnjqB0cemsTmq6ctM/6GeEqTGsXSAyo9CMVh5hDS4JKb29IyhXGC3hxr9SPwZx+do4aDSsd6SEkraTATT6YGMZeRRqbkO2l4kzYdS9sUnxkup67APWhJ70PK/33Bc1JaSq8o29ZjalrnnB/CZbuOo3PR8dQglnNP3Kcem+ORm+I6Johr201dJ/PQPrhhaRLUQSYTlm8IQ4OSx8bX8JVVWQkGD1lOhfCEi34w+SAKDSeZI6hTtH13pQSshIpbBJ0ThaB7Z6qrg+tUWHSXwvhkdyDYZVCYwCAnY61GuSpc7/pXYTd210UxXQ5TOVkpItkf30m3w7TOJ3zmkTLMbxJ8KdTjogSMeSJEttu9mzhzN4N7GitctFfKiHWDIww3hoUZqiWj1xU73aW7krHVWvBlbrXt6naZ/QV+DEKGnjrfKp3wjqcMWq87PhibKOBUN3DjuMWZ1n4XoVq3iRJ1I85jWmXQCiGVZrs5l7SQgmTdYap02tGrOzV69mGkfewy8Zmq6HT/r+FLt96b+PSk+O+enfjTpIyveHe+d8Lrap92a1sq56dK8NSX3RjvcNjVn+3UcNT6bFXqdqWjtfpeNXStaKKOVxd2fYKLWk7GvKMx3+3ofDcvTuSJyaBRr+/w141bJz/s4K+0diIvndBnXe+7Zzt81Xon+Ke1oZOzKkxdHV0/n4Yc/JBFJZGNHuYN63E95Yq1FkVcZdq1mOc0IpF/5wMf+MDdZz7zmYtHg57Uynqp6KXitaJpFcDKZxK3dVOso5H0RvI/8hjeQvRDIwd16dGRyZepU5yY56TOl+SV/k4vheqBxLepDMSJHivIbHmSVQ0XqvhIGSjD8eyzMmX1yFKGcwMW7yVPsTP5Nu+gIxDuaPhbGguyb4TDYax5y1vecp9Sww1Gw+4IgeO64VbqBHmUO4UxAc6kE+Uyo3C4p1ePsOohj3wpvtMgZdTGu9/97ru3vvWtl9/okf/kn/yT+0TjFGVd2s3k1Y6nnm/81gBrigo9bexb5u1xDPnQR4xd0CJ1mPfLejMptMY95X51Ff7noTc5rx2b9FKTNqEx2tRgIT06ThpMK61pqDGiRfjEl5EamcOKtuwbYy8chuNJR+Ja/SvzMPlfzx2NS9KGBj49sf7P//k/90a3PO3RPiRPynkm3uyT/Ev9NXmSIcK55lm/Y5TzL+e/BifnXobGyX+s2/nGc6e5W682LE1KAAAZ+yrQWjmr9TvLJDDWNq8R+Fdw31Jqn3XZTFdKiS8VwHz/GnhqP1fC1iRE7JSWrKvD60o4ORFawAXMHYHASafbbyY300iRBqVpR74KaztBz76xMOG14qLhgqoX0dTXiqsc21yg/bYuY2xd2D0yNXHdCcMwQCaujBqGr0Gn8/jJYi4evmWu6Sbqojx50lXcwmwx9knfKTx09F3Hgf7SFz2DMFQR+55J8HKREqd6toELBTCFxyoMVsFcZsy38d+ZGFRvLhMGUjQMK1i48wa+NC45phr9klZrsr1KL1PpFKCJR9Zr9T0X0BSiU0h51qUK66fvdHOje+ZEcdrx++n+Kcwn7Xf17vjMqo6d4nwK32r+d4rWab1Zrl1rT/h4CmLTOrXyfLqGTm+RFa5R5n3+GplmJS90vHB1v4NhRxe1/RW9TPM5d25rv7q2Or438cKTedT1YSpJY7Vvq+dXMu7Ed2rdk4xXYeranHhPV+eTyMUPUQwtIVQolXyKR5KbnNl1OJMEp1yFMv+Rj3zkorB++ctfvsgc1IUMkYq1ypl46OT2CSdpoEmZqJsjyavq5qD5Og2fST0qYaK/Hoak8qxRRTmvzqf0khJWvQ70TuBaHr9uGgCNJsg63s+cK13+pqzf9h0X6zPcyXw46cWi91GeZqs3unKsz9KOHi0pb+vp/fWvf/3uXe961+X0MAxNKsS0/0d/9Ec/RmeJJ40Eyn96fmjUoe0MZ9IQ4DVlfPoA/ZEnTLpDBuYaG5pcQy425xNpGxxnI1/MddOFUKlXSEcaiQxDVOatx9hnPY6RbSrv5sYtdXt6oc4U6R1EyZxO0mTKxm7oZ04lisYWaE5PPPVpimNe+VMm406eJj3Zn8zhS8nwNueSaTSSbpMe9ZazX0kzzhOvZe6i1K/++AU4zQeXc7HKLalnpK6ZXmvqG5kfShzk+ireNUhRpM8MV6yHM9nfzOElL9AQm5veDx4KNwkTNYSpe6crVdDZPfOYJYVbSuddUH/v6loJtythrru2EgSntrOtGu85GctWQpwfmBWeJgqTHqVOG+n2uWrn2v9VSKUtdobY0ZIR0LbMV7ffU5qs9WdxYupOyaRenVRiffx3UTXUiucxsFCXCfcmoxCFeceimfGwFD3pTIbelUmhUBDLayeCqTgngbbJDsGHHowVH9btexgBZYge0WuS8BRsOsUw3WXTlVRG6Zi7w6QXHfWT34trGPPyVEfnhgxYQ5QLjvStQLIaJ+HN9ya6n3hCNwbpPSU9PFbZ8epuQe2ud/VWw0JXd8c3H7p0fLjC0cE8vbdS7vPdJykrGus8mCbh5xpltK4xu3Wxzu0Ke35nboTaVj47wXpCp7tnJlg7WFZyzkqpPYVj9fwJDlbtdHwnaTLHY1VWeFjJOrXNnQFxWh9W8uXEiyp8Xd3X0Fr2Yye/dGtDB98E94ncfSKrPq2ikoTskjvsKROqiGWoP3IF8hIyhZ66eKMY5sQ15A+P+jZ3kKcNUzJ0R3ys1iZp3LGr9FBptPKm7Jf91FCWuXmUIVWIfQeZxBxA4qau+5UXdmF7Jks27IVnDOdJ+Ur4UmlOY4VtuFGcm5B83FDmd+bDyg0wf1NUhDOFgykY3GzU8KOMbf4ccfA//sf/uNCAJ5JrtEC2Q8bL8Dx1AE/Voz3lu9TzcoNYWhR3blrmOEFvyKzQNHBgZCJUkzaQfx3jz3/+83fPP//85V3zyvIxsTtwejIdz0ir9lV9Rno3J5n94h29iCq/1PigZ5h4qLRIe3kCHs9oCM36hMmNVq8lLdGGycfVCegr+DL/qc4oOa/kAcrMGkHS4GKfNPwwz8WRRkMNPXygMdpWD8jcqBq7pducX3qDJY07Rwyh+7MX4NNYlzzMfmcOYfvpvEodPOHN/tWQUscrN27kl9zPFB7UJ32lEU5ekPDIA7yv1+hTzbHUMeFkQlk6gXQSlpNYThe9nfD1EEJ5XUCm507LSoB0QHMRS0V/UsImIbtrw+f8eOqBjNeQI5hbWkin/uYiLOOVWXqqB8X47jQsVQFqJ+St8Jn9M57ZSaZln4nGzoETvBP8TgS6pFMTXKcxheswzi7hXcJtnHuOh1Z9CgtPul5WGGyHBNDsjNhnrnmi2AleJ0Uy2+lKMkFwi1CHkUg3S64Dlwau2o4LBe7QfChcoy7eAxeETq6MNunhpJutFnlDAl1EWewpGVeM8KFx3Fjy7HeG8zovFJ6qm23FdQpqjCmCkm64un4nXny29m9SpHP3YhrbxyidAlb5zzUK/NPm81nPiffLqRHh1nE5wU3CPPGnutbeQh+V7q6B7VShP4HNZ1PorzJDVdyvgbW2M72/kwG6uTrN3x1N30IHFQe7/kz/s67p3lTnBPe0Fta6u2ceYixX8Hbv1uvJj6Z+7OrNd3dy5TX9mu5X2Hey4rMqublSaS15sEquhhDWTOQc86mw7pNnh5JpD/QO0Zs7cxAaZWFe1BzX6l2XMKl4CdeKtqqHJcV8rIR4mUJBo4CJpMUD4Uqealv1qvT+zvbSQ8nQnfRgUJ63Td/XmJU5Xaw3vfBznGwncy+lR5LeEik/+b5eFHqGODY+q0wHDsyrkzmObNPTthhHDIycIgeNIFshOyN3Ugzr0eBgguVqUEr4HLdU+DVqaJAQh/xnM13c8kEWBT5kPo2hwMTpdMBltIFwMNY8a9ijsNV0EY6j9Kgs6/Pp6VXzXTnW1lnD2Azf43fKlvZbudp5It1Yj3TpfM3cYcBIuCByPf9Nbq78nKFYCbeedjlGeqRp0EpPMvDsHNYTR8OU80yjJG2LJ41b1q3xW1rOOc5164DH2G9K0qmnSKtXZJJ155C4Tvqyb/Y3jXb2lZK6rfWJH39bl0ZF5zl9p/h8ei1pKFWXPF2fHvTooJPFsQq6IiGTfekCuFJyH6PYdufh8iT1WXJBFSd5VGOe2NC9f027VZgwBClP3/JZT1Oox50n3F0bMlqPglWR1vUyvZVWQvA1Rbirok3R2OPk0dpcS6cM5L0qPGRfWQAp1ks/WUQmD5JK1/yW6aRgAA2kN06F1bpc2FicFCY6gaS+28FS73UCVMWVXkcwUq31Go0mfNuuC6SLGsXdDYyA7jhRqoDibxZqdq3MFSAM0B3XFSgR6sCpu5g1CWYd8/RIyh1UnjOZuG7eHQ1L357I4o6BJ9rwLnBk3gHmI9+6BrsodWPRtfViKJWeVorkqjw036/4qkriymiwU8im652yX++f1pVwdnxqV0eFodLsjud19d66Pp+Mf+WRyTMqT+n445PMh2msOhqqv0/rn4wpJ0aUid/UserGtK4fnaGig23i/1n/iVfRqj8Vrg7m0zLR89RmpfkKS8LfPbdqO691+K5w1OdXvF9Fr1vLT/r9rItKmeFvWVTYVVxZD13LVfL0QEI24L6KX27caKDIU5483MTjypHbUsFa0XX37e/0QrBkiJjKm8mTgcE0DcKKPGEKBHPepEIrjGnkyTFPgwHyBZtzNa9LbpopD5tfJj2Asr3uv3IqRdk0jRXiRIVXg5nKLeOr/KOsWDfQeRd8uFmqbmR4jsYL5SMMFSbDRhZ23MGDeYHcNPc0OmmtS3xtmymbp56WSr/PZB5eZEOSyuutowcdfdZbR080DSlGVtiWRhX7Yn9THhYn5ghNj/jU5+w/9aljppHUQ5b0YJIunYcZEqccLAzSk31ww9wxy7lF340OcLxN55ElN4iT/mxHI5ReT/bRZOTSpd5wGT7ofIG2fM+IBunA+WBfM8zQfsuLwOWf/Mmf3G/kO/f80Ja0nqGl4sU6EzbbzGTjfjLsNEPzqK+GD2faD+mO++aySp6lMTj5VnqCPZhhaSe8+swkjNQFzg8dZlDNxaOFmsmo5XCl8Fb4rim3CsK7cq3wk4tUMhKUaeLGdR9lErKAapQ5ERxW17Po0SMhOon5D+PXTa9aLWs/855jJwOtrrKpzD3JOFT8JQ2m5dXkcFrEczE4pa1ubHNhoa+0AbPUDXsXxuakTTfTZKKGa9XTOjq8uZCny2LiYzePqwKZY5R97XCWDCyZrszMnFadkYu6mO94DcnodWem6OWTp50JW8LDfby2TJKooRTBkV0RmS7tcJ06GbPcZRLuOuYwYhfUDO+sHkdVKfS/7rfuHMj8ueYcMwcAHlXMfXfWdK12Z3UaN+evi8JjlN18uoY/nvCu1TO7tjojRK139cw18HRr4kqR35WJd3bzvav/1HgxwVufuQVXu9Lxq9pWx5+uXYNPYFhd6/hwvV/Hoz63grm7nnxvgqeD64TOOhqu9NLReCcbrObRag5M7ezgr+1O8K36u6P5vH4qh3UwdDiu626GGFb81Doq3hLPq+cfq7BG6yWQ3g5+m1MHzx6ezZwxnvKETKwybR5EPXLSC1ylk7ZY9/Vmd/feTU9lqMSP15IW8pnufpbEf55ixWYXyi/wCLPGpMRFlceSNlJH8pQvi4YBjU3iIZVTN/4yFxLP6SWTsnqG64gD8YoM4zj4jvKW+krmA+K/xge9tjSmVP3A1APgyffSC8W+6jWCPKc3EPeBDbxoWMq8ScqIymXgXiOjm5PcU/dJb57Eg3BRpCXqNhm1tCJ+Uo7TgKrxQ09/E7vXvESG7vmeHw2UaRATj3q5+J1wq/+5cZoeMRqVpBFpyefdcM1N7xzXDI/zVDxkWe57qJB9o1+ZTNu5pW0g8V+dBdCPMlSNovFEj0ZDJ62b+c9Gr/Of9/hPXdCAuZjEgTJ7zmXaduPXnLI/+7M/ez8P0/sq50TlH5W2cvycj8KpUSnD3/LEO/+Le+kBXGtM1bhqybb47fvCy0e+9ExOhct7O2EuhT6NFihRmXPEk7RQBk87ckt5WgvqJIiuhE/xIbOCuH/xF3/x3lsJAnCBTYPbSkip1zsBLmHLxUsLqe/QtjGpk8CSdWd/KxPN9lcKWFeqYDwJSS42Mjf+p4ujCa07+CdYdsqr93XXnfrZCbG6rsqIZaYKIFUxmWCpApG/Mw68flZ9nv6vcAEzhnllTDC7cxp2pveAnecYJ5IvQvuJ2/R60kDouz7H2GroYUHXUKfBT/yAa5KJuzhmqOJkuKFuPfdcUKoXUVU4EmfuHio0ACP8L3d3uM5zCNHGn3MfLzDbE9aOn2gsOz294WmUFZ/L/yta7hS6a5SgTrHa/V71Jxf/XVkpr3m/tlvDuibFteMFU92n/HKCdXdtde8Et7uygq8bx6qMX0tHTwLzCvdTG3U8un7u4Dx9r8LVrW0Vj6ftVZqs9zqeUNusde/kla4okAtLhtvXeuuc6nBS+1S9gSbZauJtUz/yner10q3p+X81xyvvWsH2GMUdedY64dNQ4fpusmO9e1WSDBvi25OnM/GsOUE0Nrlj7wYgzxB2r+FFhb0a8yhdlECmqkilWlkhPWCyWId0iQKbYTu5edjRj0puJ1Ob2zM9N3KTWNnJdzUY8JweD8ocGil8N/FQi2FDPqf3TYZwufHId554DO6Rb9hIQ3ahkCfJ3KDKPOiDjKen6WWYmgYQT0BW0UeGRGdCn1Kv1FCTc8N+uQnK5iQ0kifQpUFG+nS8MsTKkEPa00CRUQh8KzcqI2sgcTw07vjRe800G8wFZWFlPvtEPW7AapywPQ2NSVsp9xr6xceE09K238wn2hMf6WVk//TGB16ez8TkGnKTth0vcZHebxkOJuwa4fTq14BUI530ABRnjgPjSjgeegb5r6ApjUHwlK997Wt3zz333MXTjKIxKg21aQDTswlae+Mb33ihHeohYbyGRL2VUg+lpEFIPce27HeGhqYzhPxAnlM3lB0vDVvq7zk3+c5cUuLcee197z0zw5IEUN0CK7PN930Hi6FJikUy73Jdq2+X2+dZlFMh81Q5OSkSApZPcCDz4pqEYNiOz5/Wv1L4dIVNl8j0YJJZVLdex7p6lnW/b8FHhbP7LzzubrnroBU9XUa1fHO/hvalEJmum+JnErrz/Sr4iT9Kh6d835w97kr4nHPpGiVQ5kPb5s5y18XTUqZ6dgrEpBjbLvV/73vfu89z5Ikdq0SZ1u0iyo4TcMPweZZFAUMrx8ni5ozRKMPDcgy01iskVcUmFz4NT8bj56Lb0Wy6jWe9nfKUxYXQ3ylApLDhvHOB8L67rHXsUnikDgRv8gsw3i/2ssLXpPxdU/epgSB3mrs5nHWe1rsz4iQP6OZCB4/j3Ckd05xcKfRPWiae17XfKe1VeVvRQKeET0aIbLfWkfe8v4K/g2nFh1c00l2fjAsT/7lm/Hb1VTh8rqsnv3dGoF1ZKds5JxLubu7UAq9kzSG0SO8GBHtD0XN96ODo/rtWsBYpD6RXxo7GV6XygPrOCa+Z7k/84Jpxehalhvar1KTns/fNhaRM43PIyh7brqKLEcINGL/1+jBkRlmXojd15UlpUEmjYuo5dR6kDOl9PxoTrJPS0XvyEuutfK/TrdLDKGVAr7kh57WU6VPZ1WumC73P+ajcYmgN8odzRg+LxJEylJtoeo2h5GPkw7jEs+bEYjMS73/ya3pyGHSAAm+Sa9vTiKPHjnIvdfK8/dabP72klCX1nNODJsPtNBjpAaIsmCkf3MSGnkz/oQ6iB0iGU/lfQ5EGCuFUB1Pe1GiWBhe9qoAR+VBjSjUCanBS/kzZMY18mSib+5msXZjtr0a3nDe040mOGsxMpJ7eevRD77z0CkrvugzrpIh3vYI8PZpnE2b7npE28hTWiLe85S2XdYL3DPl7wxvecPfa1772Avs3v/nNSz3QHmOpsVZ+Ja4yx9PrXve6u/e///13H/rQhy7PcyohBkoMVOTTMvSyenfZ12oszvnux/s5x6sR0jmZJ0V7Ldctv1PXTCO0IY9udpsD7EENS52A6sdJaNyybmnpRlbf9VuiS0KVmLWAV0Z2Ilhdo1hk/24Vlm4p3UJhAmNdPvUckumIsyqQ7soKb1x3cTD3Sx49qbVWpmLojkYA3RnTWrxTcCpsp/dqPekGi3DBAkIfgAmPFOBDsDSuXjyYULsKmXwziWA+GnioA3rW1XLqT9Kc46TFnqK3SxqJ8pvrLAzWo5Ua3Nb3qkDa4S2NlLp+uwiAk8m4JHNXcHMhyESBdU5aNOpkwsS0tnfCUi0876lsMH+YPcLBy172svtx4VhZ8ZHMLmHL3STbUShlESDBuLSNAoIxjHarsFvH1v/dLmaHz3ze/ufOKkUPutyNcO67E5d964Rf6nPX7zFD4Valw+Mpn61CqtemUp+d3pmUwdWatzIg2HbW3dXVtb3id7s538HfvbNq81ojywTTqs3sy6pM69uK5+W4nOCq46edAaXO9fp815+EZbq/6tdu/Kb+TbLMNYaKjg5W49UpxxM8Ve7ZvbMaI6/D11n/MaorE7gxoRdDl6em4qnC5+liHlMNX2UtRrbQS6biuMPVRO/TfKv11PdXNJfP72j0acu4u8IGUuaR1CCgzGGOwfQ6UIZBFmB8lY+QdVjXTaNB3RR1DPUMZFePT/dgmfSA7nDSGZW6Z5OnVCWxm8/KBTkfqhGr8qlpnuXmvPetTwNdhsClfKe8YegMH/BLcQM2YUg5RX1P/S1TITAmGjMcU+HgGvfZLNRT39QA5hQ19yswmOKAsUN+B36MUtCAynUaHJW7TSWgHJoGL0O5pK8M2zLXkKFeFD03NO7k2GrYMPVHynbyHo1eiTtpT2OJ9WZeJXHmePJuprugPdNuZBtJJ6YAESauZ3iXfDTpO8Og+GjIEy5TM2SSbepK3FMYX/BpSg/G0IOdcpNWPFZemqGHhjwy9hqSM6m7/cr5RKFdYHjXu9518VJC5qd9dEb0Ff5T9zve8Y6LrkH9rCl5mlzmm6JoeKHOD3/4wxd8fP7zn79co4/oLx/96EfvPv3pT9/9/u///v/HsJN6iXqHXlVuRIsX50zHH5J31eeFVR1SI6lFvd56NaYKmwZmdfyTcrX20S3oDBbGEC2Vhm3BwJnQnrxVF0sTreWCr8uWBDOFpVTB/EkXzBNBd/Xuk77nbxdWGZQKKMUFsCq+naC1Ejj8XxcuJ2hNqOik5hkU19e//vWX8WYSMSHJV8MnPUe6Nq/B+eqd7hq4YdcDJsF/6A9DDp4yCBjch0lo+GQnJOlOxsFkJjRTDx8Kv3mXd0wGmP3rCvNAJZ96NGwhkOZ8qMIkMDFn3O3gmrsonVC8Euj5zRwEFxk3D8PU6FvphjZ9J09089QzXcWneVkNSV5PwWRX8lkUBQxjLlrghjF+zWtec7+jNdFKFfB4jnqo833ve989bhknxhec6LW04icJ36QsVL4EDCxsndefXl6eMKKw4XPp5r0KgzMPleP8/4cyKd1d6RTj1XuTMj492ymwp3Cs2t61d/rOrqzw2PGGHe84KRMudsYPn5mMf767gqVT5CdDywRj4iuFtQmOqrBnm5OBouJk+t/d69rp4N+N3Sld1Gt1fZjqyPcqXN047eCq9yv/rf1lTXNNcHPGnWhz1SGrdLkpu36qxLDWsF6Yx4eQGhRZw6yqt2yHp2vkyhPeUtuY5n01SlT+dgt8D13Eo0oq+FWX8MQic4qowGYyXfGvxwobTm5qqyyprGrg0NvAepH5oB/eo+SGVOfNero2rMYo600lOGXyqf40CPh81qFXR3rcU5T3DCOUxtOYoKc+BbwwHsBqrp+EIfvnBijjpQdNLekpoxEHuZQ5xliwqafcnAYJ6gYO8lHpXWGbjBlwIPfwoW2NyIYA8Z+6pRf7qX6jvGX/dJJwfqv0qw9oOBMW9SNxaDSESroyXdKWYyDu1YX1DqkJmHP8hFkdjff0pJLeM0+PdQBz6o9Zr0bz6r1Sada0EdzXIJYbpplXSYOvRkDhV6/3VD5pQ7pND6ik8zQYMs7izBP19NJSrtCgKs1qUIV/o6/C04ETHdH1ATqjQFfQm9FTtkE9hiByT+MmxihgQef8n//zf957J9F3dI33vve9d1/4whfuc7l2+pFj4sa+OM7oGeko6S31m+T36SCQ/LPO38wbq5eZNOL7ky1mKk+0rS0wINa4S5AOQt0l0JLaLWYAz2Bahx4iTvRM1JuIO2HcJ6W+sxJepv7fqgxMgi7917WOokLpdzLAqS8rPFSYcyHz9AV+a4jIJHe061hr4XdX0Ez6KbitBJ7p9/T8SjHknvG87kpJUzAN6A9XRJgJsINDE6BnUQjFyGA7MkkmFgIP44Cbdd0VysLzCqAyBRNS642TJw/UeZHJDfN69+xOOfG40vR2cndQA5fPCjf91JCTMbguxjUMrMJVGV5VPLp3slg3Y4VQr7HEOQBsGP+Mf05+kG7dFWd6K735zW++7EjAe1wcaId+E2aXi1mFdYXv3XhkSKC7YbyjICxN6Vbu7oyCnQtW50IPzOahyFwHj11ODBaVDm7h5bWcKFsTLVYFbKeIXqsQ2v5DrzETzjrlfhqXqa2VQWXV7mldtQ/J8/PeCU/ctd/BuOOraQTu8gzsaFb+1RleVu/s6OykjxMNTX2+hXd08kcn801yzwRDzr+Ku7yf8qbPsGabhwPeqHKZ7azmIbyUdcG109QM6W06yV11fFdzJL0/VnTUwT7NxYq3LNN8eayi8qeSbOihnvCMo/hmnE3ArMLPfYyJes3wDN42jLleScoNFL1CkGmon//IatSpbNbJL5Zu/mocSJqY5kFeq/Sz48m17azXHJQalVRK7Yf4MiTQPvrtpqt1Vw8F60oeKGwqrep+jqtyZaYsMCTJ8QTnyGK0zziy+Wp0gIYH0wP4YWz1zNYThpIbbxo9hEtcpbFIryjnofoVcjDveFIv9zVUox9oVKnJjxNO5dU0mjjOmR806cccPOk5pde6BoKUAXUEyHw/aVjUcGWKDQx/GljFRRpflO+Fx7YzTE0ji/porofqGvBhvVyoV7iRfx0XcZ+wOjfVLy25OS9uPF08jUoZwVLnCtegFfQ3eYyb9tAdRh/SbfAfXdEE8HpKCqNjbZ04NJgP1TXif76QnJz/jCk0Q+QFeqj8LKO5NIKlrpLzPg2+0rd0nPmpk77Fm/X7bD6fNKLxST4mn9Dj7prN6psNS8kUNUTwcYCZ+Fyv7lxVMNRllW8UO71ymADp6meZhJ7dojy98yTlSZS3DhfJEI0B1/KfyePS4HbS51Ph1cnK5Ne4peVUpppWcZmVIXQ7RaD2d6dUeN/dAUpayLMerchalU027gKrt0fuSiVN8qGvLCj22Xhp26IuvX2gz0lx1YAh7dsP8z8xN7CW6zVVS4VrUpZ2Ao+wyLwNc9RQVPGvQAachl7ab+nQHaEUnDr4JxhXClV9Fth1eYXRazSRBtPjzEUD+Ci5+CVDdOFnN4J78imepZ2dUaZTIlbPVSVA3mby0KRDFQxgAT6+TZjPYsg7dddAAdtFzrF6rLx0Cdet/PFEGb2m/Srkd/NqBcdqnuW1+uyKxk958u65Cb7dO09ihFhd6+Ca1rpJ8Z1gXF3fKXFdybaTz3f43ynjddy7Pk91dYaC/F9pd9dm19ZqLZ5gnnB3jQI8KdBT3av2u/dyPrtpZAi2hbH1EJhODp2KoeMeDc47KpMeXd7JYjt+UXHRGSpr/3f0uDI+TO1P/OMxSoZ3uMGlp4PKs4YAlWzg5xlkKUOdVFIxCrD5xJpOUdFVWab4X0Vb5THXYkrlC5Weq6GlXu/e1wBQ54gyQYZZ5fyavAaU85QFMuwp61fRTMOGskPqH5mbJjeMrS+LcqZ4UwZ3zDKMKb17uM8YMdbIN8jmnqTM3OJ56lKuV7bRY8XwKq67OUd7RnxkUnbaS2NFhUvZTPwppyOrqYCrXGtozgTcaWg2akfYE2catBx/rqfnknJtZ/jxvUofbkSrI6U86bgataBXVIZV1Tyf6b2kvuUYS9fOxco7cgPbesWzfTE5vLKvdJveThrHND5xz3mrXI8ThKe8uYHu2KU3pDixXxrLeCf5D7jByEl+JT4YO918N3pDmnZM+eBxZ0hgeir99AvGK/VqeJEpftKjLL3oxLt9dRyTvpKWKg9wPHVQSZ5a81U5XtK1OcYS386ba8LgHsRjyQFJzwcXgxo76Tu16AYJY8icIpPSbTv12krQvXbxvFUpuqXk4qLxw8mSLnDgB2NEJkGuMN8i9OZvGVs9xSDdjY1pZjFPV7mVUpUTYiXY5eTRgm3Gfi3Z7irl4l+ZvIYUTySouOjoKI1QGlcytlrGb5xw7jTWPuhSWD1/dKnFgGOcfx2jhHUlUHbj2+HTsXPhcHzzGZmmeQ64pmEsLdbpLpsGvq5MNOp3FXqTh1DgKzD3DD3wVBjzVcmQEU6IZ9ZjLRcf8zW5CJsvy/xXeClpwMoY92vLpBR1itUUSugz7lwhcHHNnbTVHHOR0MD0Yiqnytz0jnNvV0fFc74/KdnXwNmNcQ2XOO3byqiw4uXd2pfvrHjEbh08we/q3mrOd9dWhoRr1u0Vf7xFsV7R0a50imTXt1UfJt6x69uqncm40ckE+U6FpT43vdvhrOKiG+/a5yo7dMX8IolvZQH+p4zawdz1wbXFNZ+CkYl1kjWJNQMZaAdb9q3De8VNhWH6v8J5fbaj92tl4qdRVF6Fh/ULHHtst6dypaLMMypsGJXYCE15Ro8Jc2wiGygTugNPUR7S4KACJa5U4MVbynuJu2o8yLEWZn9nnTkOqex7LxX5rL+WhCe9HqrnSfVwSMOK7aeBovNU6GhWo5wyluMD3qlTA4DzWC8iQ8pUYjUaIpsxX5ljeIPwfuLfaAC+TRKNJ4jti+c0wGQEiHjqxtPfaUhLz3HoA5rLsVE3MK2L11P+72RlDRRpUKiGyPRUUb7L+kwEnh5OjmfKsdKBpXo12XefS8OP7YBvPXLSQJh4VXdHTtdYZD3qs46THjLqHtKunjLmtnJ+2k/wrLHTUEr4s+Pp++Zygn40TLq57oaB+pgb1vDzL3/5y3df+tKX7tOFGKYrrabBNg2hOMiYXP5PX/CS45rhpMjywKJXnTTptxvnRobYH39LJ+K5GggdN95JI3POBSNyKCYmR8fS8UKe6Py3/eRnT82wVJVBBgiDh8QiURtytFJAva7SXYWIysSnxfRaBffa0gmHD1VnFvAA49Idk28VYfNV1dw4T6LwrgRpmXQaAJgcX/nKV+5e8pKXXP5DjIQkadmfhNyVwtAJtvxmotEORhjqdiFCoENoYFJI6DAB/uP15gRI909hW41fuj6ny2PihP7qybQq6caau0H2VSOOp5ZZOqHvRGFLHOZ1j7SnZEy5MbO1DgUNiiem8Tw4NL9UNUqdKD1JBzI++m8MfS4WPsf/b33rWxemDTOEz4BPDEHf+MY37j14DI2DTnJhdJHiv6dl0A5CCDiRhplP1G0+h7pbWQXFnA/XCPMTrupY+1x3+ltXJ0WBzF2/LsfBsyx1Tle+fkI3JwpbPr96dlIkO351Ul+t51rlv/Yz61j1oeY9yLpSUF4ZCVZ0+CTr27VjcFrfVDolZ+r3Cn8Tzrq1q/KDrL8zTJy83/Wrg6FbI6/FcaWxCZa6lnQ8ZwXHqu1Vm7t6p7ZYK/DyZP1ng8HNOQ+SyJ3rDoe1beYS6wvCtxsQ7up6us5qB7eTp1b93fHErnRyw/ScdN+tZY9ZMCAZzqJcgPyr/EZRyVRRUv5yjHIDO/vF+CCvImNhoEg5TF1Dbyg3LVOJSoNRR/+V32X76kA51/wv7JUf15xIyt/pDZRwVcOIp4hpyEpjj8a56iFh/zRYKDfYR/GU9JPtqmxnCE2mNlG+ylB/ZWPgRW8E/3geGcbKXFORR6bjGYyHvIccSC41vT+Ehf+mEOC/hgK9pFK2574bj4lHQ570fPdkQfHlM1wDLto0PQEljTtV2ddol2MsjjWapAEyx9lk3MKfdTln9ETTCKExzPsakTScOm45H6Q1DX+5gQxO6DNzM+mpGl8db41A3lMut++ZPBzYpVsNjBo+9bJCNhdeebD5lrxuOxgd+chT4C95uhs0pGeOHk+MZZ7oxymEGmTSIyw9uuQf0Anvm8/rp37qpy70Y2J5Cte///3v3+M511Xqsh8azPOkvDTEUtz8ds46puI7DXUauHhOLz94IYUxRRfKEzStx76pjwn36fp0k2EpK9dCycTXTZEOwUgyIe1JfZMw82IoTwrLJJB1Ao3hge6OeRymE3MluN9SqvCadeU1x/rb3/72fQZ9DYudW2QVpiYhblKUEOhgZjACJ5oGCQRIvU9UwsGZORVy18I2UvjohD0ZorHbycAMDevCwDoFR0NpWvJdNDJhXYeHW8axE1I1CHkErPhQkKv4MPmiC7MWe75hPjUJfyecdnTj9XQz9gQfd4IR/jEWJoNjLDiykzZ++Zd/+Z6ffOc737k86yJKcSG1TZMZAr/he+74GFZnbLS8CoOVBqhJ8c6yUramcZnoJudgRxcrJcJ3TaavUPXYZadI5XOVFrsyGVWunS+dASfHsrvewd8pGCs62CnKK55Sr614aGf4mHjvBMt0fzVu9dlrFNdrlWpLtj3R22TIWNXZ1ZfX6hri9So0TnN1anei8fpuwtj1r65zXds7OaujmxUuK946PHZtrvA9wVLfh8+zJrAGkEMPIxPXPLxDRaby3BWuWS9QHPWIZc1yTWczDWUl+UVXX8fzOr5fn62w1PvXzpfKNzr55zEKpymxpjNGKHSGp7Emaxg0hMN7eqkYUt7hSQWZazzD+q/3U85Rn6Nt1v6kk8rD8lpHS5aU9XI++17KF353Xkx1rFK+SV7heyau14NGWdn3lJfSyOR7lAwlqhur9jG9gPJ+Gg3Ek4mb9ZjKkDbnF3jX+y8PTkFm412UcfUL6AGjMafI0U+uIedpeFHu530NMdWzxj6mXG54kmGRvGMoU/YvjSje4z0Ve8dD40MaBFXQkzbqvNa4ZF2ZD0d51jHUWGR/09Ckp1C+Ly40Fhhu5ruJI/umV1N6yyTukjaFOb1tsh/8TiOdeM8IJQ289lMDjYY3r1uvJz3qxaMBRcM09cG3X/nKV96HuVknugfGI4010CD0A3199atfvafb7Fv1XrP/6BMcGvD+97//olv97M/+7KVdPKkMi3z++ed/LCesOHBOSEvqufKh6okpfpTxTWsibDkeafC0XdYz5pweZfzOCKj0aLT9NIQ/uGGpW9ySYZpszVw3Jt271rtm9ew1gmIVQm4RWh+y7BbwhE/jUiaI7vB+Kix3z50Ic1NbJktLeDtlbCW4TEJiCuoukLoWJoNhwWTimnxN4YD7XNdl0hNiOnzU6+5wyZyN44fh5JGTORG7umEALIZ6ClFcWNPgJdxViJjG4Jqx9h0YFUI2CzfXu6OXfUc3X/AGc1TAM/llN84poHUwV9j5BpZXvepVFy+jNHAxfhru0giGdxKGTK/ptSfjVwHIvFbUm4uQxbHBYMUzjC19zhj9jia7kovOpFRVfHRjJb2lC7N0lAkfJyXVevTMot/g+LHLCX+aDBCdQrxSrCYe3ymk01pQeezEoxKm/L1SfNMAcLKW7dbBrq0Opul+fWYFd8LZwTgZGab2OuX+2vW5g3M1Ztco0B2cU3217clQMPHN2u4pHnZjec27tVQ87t7v+u5zO3gSfyv629Wh9wqbDhgp3M11ragbIhXGjm74TZ2sDyqurKUmla6hyRWmioMVD6nloWVW2+o2gq6ZGw9dWPMJz0BmA6/gl2PllS9Nys5zmffTdbwagvhd8yTxjVKpQi5e3QhXdsyTj3wmN6xUYmteklpSkctvYeuMz8kDu3tZUgm0n6mLqVAaPo/SnN404iBlWj91Q7YavJJWDPUyHCjhZN55upkyXjUm6HnDeLOBzIf7GIOZdxnSxPsvf/nL7975znfejwFtmtYBRR75D/hMuGx/0nvdlAo5vobypdcVhc1raIz/jrf0oDErFXzHVfgsegslTSa/S0NP0hz33NQGxvSmT7kx20ovNPGtLqNRVlwIhwYL4UyP95RHNehqcEpY0yCmniFtcF364z0P+tKwYvviGNiEV77rvNGmIH83TYqyu6FztMk9dDDq4xv6cmOZ+ohYwGMSemOc4fPPPffcZYPC6AijKjzlLz36nF/Q+ic+8YnL91vf+ta7173udRf5W2+rj33sY3ef+tSn7iMinKfSgIa8NMhZv88615IWDL3UyKaOaVSJOaSkK/PNgkN1QHXmnJumE0ndRlpMWntQj6WOyUicxihXxHUC2k7Ar/d3v6uwkLB1AkvX3tMsU3874d5SF7mpzk44WpUVHCsFJxevqW91oerqOhVAc4fFd9zB0rik66Q0qDdOuqLuSuLeuFjdbmFaHjtq0m69X/L97BPvmntBF2yFUGOUPdp+VW4RLituFbgzeenKI0cXYdtOISNhSnpxgTNUkfsu+L6fNOHRsMlQYYLg2zEFDkMYPGWhClpJjzxLAd/Sh4u9uax8V88zlBAXLGGUsebuUKdcVuFvUq7r/45P6X5tDLqCC0zfHYxpjOucV+De0dazKBNPrTDn4pXPVGV8h9vVOKyUya7uCaZb+t2tZ1O9E4+c6p/aOi0rHK/WzFVRqD3xMLtVeZ7W/e53fa8zJOzm76mBI0vHG56kvyteU0snc61gnmSHlWEkn1nBsYOztmPpDPYdrPkfvslaUPu/g2UaF9dPNiJyB38lk2V9k1FganMah9MxqDQ74aC79xgFg48KL6EjhttoIFFRVN7it+Ht/Fb2MEmzG07KMCqn1MNaisInbzJUBJmRNVNcVKMD7eElw5HhbIghH+JJ88UvfvE+jITSeXJ0/3OsqgeQ14V7telSZdCuHuUIT0zWIJIydRojlI/SIUC8VjrJXI7pIZb16dHjvLFu5T8+GohMgMwHeBlT6AGZEA+Tt7zlLRcagT6Uy+2P3isq2yrsJqvW+y0NO4bqqYxXw0j1wBEmvZo0NJmzx75nYmb14QyJS48Ti+/w7T3lQd/Xa8ixkOaT1t2Mz5Aow+SkK/97zQ1050nSU9ah91ve15gj3qQr5WjnGf8Zc4uGJnFrNIo2BN/TyUKjiXBqLHR+6rkjb4ZnY7AGN3gm+T70gxFS4yW0xDcb1/zWKCVe6LM0Jt7lP85fCjzkD/7gDy5tvfGNb7xP3UG9n/nMZ+5zpXb6l+OYIapptK48TgOb8yV5ibqL+LcejWDiNPmc46yHY+bITuOznnhPxbC0WhhXCmtXOmE7J/5OKOmEIJGUQkkKA6vF/GmWlcCWz+wEohP8roTIlSKSC940Zrkg1Tpyocq42yT+zjDQKV4+ZxwtEz4TqLlIdrDmWE/96JSGvKZi7gkTMg8TtNW6q7LCpFRoYnFMt2Pz+WRugNp+/l8pCXX86jvedwwm+spnp53YakzKcTdZozsUJuE0nC6FNa357hQ5njB96wXHuKTWpNUJQ+6m0QYKBc9bj6czuOOVfbJOF0Xg0rClYUdX+2Tw+an0tiudUYl+YwxzV0YG7lGlxoknrjsenHOt7mK9mMtOQavXkk59f8dLu/XE9SGFYEpnRD1Zi1Zlx4+7dbA+M707tVV58gnOTvpx8s6q/o5HnfTtWnhXz9f5dEvp1ubpmV093XqasFYaWa1d3XivyoqGVtcSf6uNh0oLK1pe4aHj/92zKUPWOnZ1dbzVa9MmVcdfJn5UcbniXTs8dHVNbdfnq1zwLOTfqbA2swbXE/Y0NKjosS7rpcB/jQ7eZ81nLWW99Gh5x80+5olH8H3b1AONoszpO8gEH/nIR+7+xt/4G/f5WUz1Qf7Hf/gP/+HFo1rls1svct6mRwLF9afSRyb2zfcnnqphJ68pC5j8GHx5Ci7XPR7dECeuq7jyX9lDzw3lpUw6TdGYJ4waklT0zWUjfCZMBxbx4QagYw2eeQ9PNo6ARz6iPcKJ9E5BjmTsDLHiPfqIHGjfNbxk+J34oWg0gRY0QunVk3lu1HvyVOhqRJGHdQYXx6PKHFUmrSFuGgNSLk9PJI0J1mPdjhkyOe+CE+aa42K+pTyQR5lcI0ZuCHONzV3hSeNU9aqnHry9GIukTzee0YsMNTMUzN96lZmjiXdNni3uUgc1P1Hmc/Jbw7Ob+TxjHl7oShkfL0k9UVOn1LOK9xh388AqO8or/M99QuK+9rWv3dO8HlYaZaSDahjTmKhXkfxIGlbvddzEH0VDsWMpDkzILT3VPGrpTaYuorE4D++ypMfWU/NYWi2I3eKXC99O0F61O92TGedReVpvGYSq4D526QTBvHeC551Q2y1utdTx6ITYnZDk++4cMBkz0z4T1nC2CZ5sz/aZqCZ/N0FdCm/Vm0NhwSNm9dRxNyD70imb2V9dHD2dK3cpdoYE75njgf7XkzZOQuCEM78TR/V6J1DX/ytaOpljngKYuw1cB+96G2lx5znqyxP0ZK5pSddjh4XIXSjumX+pFpmsCe/0JtOYp7dYGqSql13ikQ8LMIKKDB+hRybqgmw/gZXfLhwKWx1dVKUpvzVm0a445Xl3+dzxyffr3Kvzxt8vFj43lR18naLUzd1JmZvmjddSIHRnClxDO8zXKqSf9ifn0TSfVkpxXqu8OZ/rvIEmvjC1s5rvE2+8pVTeO9Xnc1PfrikrGcT/T1rqOn0CSzUq1PdW45b92L234+eTp0RXujZrP6ZSYVgp3bt6TmDt+PyuroSzq/eE9k7mfMVDV/fE3zv+v3ree7trDzEPnqTk2o2spoKeR5KbgFYFnxAWQ1ng26yVhNWbYwjvFupEWVQhzXo0QrmhVE9ZVt5EBvjbf/tv3/2dv/N3LuFa5jvlOu3RDrLKb/3Wb93ngsxxTa/XumalMk5R4axF2OX5ufGeIfN1XHNjlwIegB/YNV7k0e58DAW0jjSU2Z5J7O2DcnHiL+GhPj0rhF8FWXnRfGgaSDTcZSgVcpK5MKmXdpWTgDvzOWnoSlme78xHYwoN8/qYxoViCgtpx+s8J/5MFK63ms9pUDCsa9IVMn9PnsCmHqtBVINJerAwbtKRhkPhk2714KJ/GFP0fjecNKOLTLmQxgTlI+Gkn+BeT65Mjp5GQ9+nDeVa26MuPHc8xdGxsQ2NLMAvXh2njDiwLZ0LzMckfZmkmmeR5UwK7/jxnqdACytFunEMPZ0QPHhitDStoSjXLTeC//QFA48GH/qQHtzWIR7TM0vDVc5tnjckWL1LA588zO88IVBPQD280psO/IAL8OCJqgkzRe84eYG0+eA5lk4Wo52CPNXVCRy7BT2fF3km5mLRMQHcN7/5zR/LcP6QZScQXfv+ztBwjZC1E5JkTiq5ujnK1DovlwkOiJaFAry7u+DCANMnMTIMZSWM1757agQujQocXucDk0rDEhOfsdf7g3Z537wzCXenrNp3JycFmjEcKxfZFW6zfhmnlvCunx2OTxWOKnCuhNvu+Vq6d6URxoCYZGKX+Q9uMeRkUnU9bWSa9eQ7rfLJiGV4aWXP3coqMMHkGWPq1pgMbbErY04Nmfck0GffZLLCLNPOXQfeg77ov8KFzJs2ad+dl2l8Kz4V9Hgud0JcBBV6pnGp9Z7wjmdVunF7SPgm5XD1fM5P6egd73jH3atf/eoLTSN8ffKTn7zsRKeyUd+9dhwmHl/Lav6vnu2MFCoCtf3TMZjW69PS8aHTPnV9m2A5XX93/Prkei27dezU+FLfXa2Rp/V2Y5b17kI9b62760+te3dv9861BqgOlzv56mTu1jl3Wq7hK9mn3bMd3a3W/BfDOmFfXDtVLPU8NuGwPFtlXQUIOcDj5z3m3sNdCEPB69kTxZQJ/K1sVpV/+SYhLX/37/7di1eDYTwerMO6D5zvfve7LyFyeNKoqIvvjo4mI1En79W1Mz1Iss5pYzHvG9KpQpubKuZdybyUvmO7ifdsLxX+jFTIRM8qpb6jbMM7hkC6oacijEylUcRrjIPGR5R+irIZ/z1Ry3rS84ZrjBfPZW4k2ndjMz3dPM1Lowbw8y0toGdQDzKwijm0ZLJpQ6fUOzM8TpwKG0XjQN7nW2W/npjsGCt7a6AAB8DAf4wqnPrl5jh4M++OdK+nkOPkhrCebN5Pr32fkxaFWXpT52OeIC/TpjmxNCKnYdX69KYCfpJoG9lBnYyN88+2rIN+4YFkPYyFtGDUgh5Z6qTwB/qYCeOV6esBQhrOxHGOj/MojUM/WU6TTAO5OLIudAr7Yl7l9Gxy7kuzmdvPOZbzMZOh5wmX4ly+It3zW31Mw2PyH2G1H6flplPhunLNIrUSzE/rqUqCLnEve9nLLsyeb5CMsglzgkB1jVsJ9qfKyUOWCR+ngsYtsFmHVlxPZjCmHQacuWl28HjSF4xEAkzLK94o1FddgWs9eZ+JoFEIGNPLxZ2SdC9lotAHmYrWcu5hhKq7RLXIMLQwa7GtuXbqO51SV5+5ZkxWCtkkVFQhpj47tVV/TzQFLgjZwsinpV+hjmR3FBPzwQQ1JvHfRdzFzOR50BxMTSEBBu3igzCop1DCRF2OsV5x7j6mK2n1COsEN4q7cMnMvefOmkwc+nbHQ2arUcqdt3ra3qoocKXbcQq+NYx0N6YdXTx2qf1I+DvPFMuO51xbcp66AYFBiYSgfKBtlAPc7qE9lJLKL04MGpOSkO+nK3UqGPWdVXveX/HS7v1bjAcJ64oHdn2+xTiQ7dfnqvK0Mrz4TPdsVdIrbldK/wr+FS5217p3cx7Ufq9wuOL5+d0pvx1eVutbvb9bd1Z02/G5ExqdSoW/Pl+vd893vGgap6nf3fjt+lrHZQdDwtu1vYL5sYrrpfKeuViQK5AllQ8M58rwK70DjE5QGUXWg0/wn7UdBRc9wJyNnh5lPW5qJW8Bho9+9KP3R3KrQ+hVwe/Xv/71l3Xjwx/+8N2/+Tf/5sdC+SjppePvpP+85vqYnkbJc5P3Zthbt3YkDfiuG2YaT8wVpFyWIV++l9+2W/M9Zh98BvlQY5H1aaywPr2FqI+xTj3DohcR101LoIJN3Rp5jIaQhtJ4x7uZG8c+8h8ZElmSzXAMDdTHBrjjrJEjDWsq79Cm9ZFvS31EXKDvqE/lGNEnI2nsr3oSzykLZ46i6sHEe5kw21A+ZWLwRK4fTzmkKIdT8sSz9Fo1EiDpqubQyjBIjVGZw8n3nNcaARmnNPaljigsnpZtGzoUqD9wP3NlSc/MTfR98p9xjfHLJOV6XmlY80RJDxxzIzkjUio9aqQRniwaSasX0x/HKXgazjICQd1UI1Dm4bUejUdJM+b2kn85To6d3mfOteRv0lPSXIbQyQvyOa6Lj9r3BzEsdcrrk5ZrhaPuPZVDsrG/5z3vubipOgE9VhxXVo8zXdVZlcsdPA+9MHcCrqUuOpPQc9qGi6ReGEx+LacyfU/pmuq3LuPPZQJ+9LpIIrUwGYzr1bqfrqUUdwlgAhn+lK6hCYvxqTJe4GLRcPE5ERI1UCQsVbGY3s1yMiY5xlWo7ATE7jmvVa+QKhTUdvN3VaJq27mgG6LmAqEh0vfFu/PPRcUdQo+RxcCk0AOdsRDrzm5yvTQ0JjPOUA4ZLXCZWK8bi05Q96QFit5PqfDnroi7UZ6C4vvuFOkqX3GabSaeTY6nt1QKotJ9dafOudv1Mdt6zLJTrncK5gr+lQK3e45r0NkHPvCByzG03CMunrWB3ygjKBI7xXGl7Kai0L2zMlJM/LyDp/s9wbgaj669nC+dUtv1ufKQWk4MIl2fVn3Y8cQVjAnT1H6l0VOau6XUdSC/rzFqrGhz8uLs3t8ZInZyRypPWUdX964Of+d76cFxstau6DONvXWsJ9o57c9qHmY9Fe/dHO/azusrOt3xlMcouY4rH2j4YG1FNkU2wDPEcDju5+lQKqsYM9jcMVePSaLf9ra3Xdbvr3zlK3ff/va3L7weGaNu5lBc+6mP96ifZ2lfWJU3PDFKbwmV5OT9aeSotKThxWuT7CVufCZzzHRzzH7Yrl5ByrTpicQzerHwrKkIfCbz+lQZKpVT5W1kMDf+9E7pjop3DA2X0qtf5ZvfwKVMp7xUEwsz1hTz4Gh8Mh+rMhu0o77hhqUeK9CDObuAh/FW9jTUkqJnEvc9cQzdAt0yZTXqoA+mdsjQPOlA3Svnq7Qj/aXHcSavNqICXGhwsJ/IzcjV6i6ZliQ90hzHNLqoq/GMoXQ59s4TPVv0GszcoNlPvsE1OKdt57SGMvsmH5BGGCtxI20KN22nHkl78AfGBNkNGlDXM/G7IWyMi7I2zxhloBEq4c85nHoGv03iXnNhpe75k8Wo6RzJeef81yhpe3o/WaxPfqIelnaKun5rOE55NNfLiv/sg8bTGlI6OVc8WChcvT49Ny1yD72gObFe85rXXFwUJUCua5WfGHYttypl17x3gstciGTY9JH/MleYmYvtqeCbsMr8mIxayGUUMnYZ7Eq41bBn8kSZgoJCGpV8j2tYpD3uVWt9hq3VRYydDYyEMj+y+MMcJH7DlmqsKPCwEKSr6zR2nWKXcJzgtuKnttHlBHNHwdPiUsjq4O3aOBE08r0UaGrd/vY9TxeRUTtuzj1D0GRO6U6a7tMyKJ5hvKUL81C5uCRTy745H1xgE2bG2dNCknF2SpTfjkF6PLkAGAbJbxdxDU+ZS6qjjW6OVzhoy3BODVMUd2lrrp8JD9ZX8fViLhOdUlIwWc3RKojXOus8kechDLIJgUJA4lVwzThkEswO3u73pPB16+KqznqtrqMncK2ur+pI/tb1s/KOjq7zmWljZlXH1IdJuT7BzWr+VZi6dytvrO1NeKuwrmDr6KbWd8rP8/cKpmmca9+meWRJV/2T/mXZ0XS3DqdAnGMz8Yl6bZrDPjPRxyT3TH2e+tK1c808rc9lm6t3HlrefsjikfTpjcG6jkKsvJuGBOWGVHZ4D5mJsHzzt+jdoPzPJgKRDPD8559//uLRkeFFWWhTWYI23HiS/pCDXEuAMz0TunXLd/O6imad5zVEztJtJFlH6jepN1g8ah0c2bcMo+E9NwtTEdaolnjSqKbcUxVUPWc02mhYEl8adJTRGTNowBOs1BcqT9JAo7cNuo9pFHJT0VApPdoMf7JPeqGLB57jdODvfe9793hSH7Jf5vKhLUOyoEENS54yliFThnLqdURRDnaTVm8avfvFQ85pT8E2PNRNf6+ZY0rZ1ZxAGrco5trRYCgcypB6ZWlMyvEyDYjGrsy543i6mZoyu+FhJudPmIUnDcquJeY2MvTU3JcmApcWpAveo894mEMD4ot7aRTkfeoURt7TsGRCfp0iNMik0ds+0y/qpU1o0DHgv3Pkz1/QZ6sBOL/Vk6Tr5Gf2TcOtNKtxzRxgjk3KwtlmeiHlmOXcMOVHznH1H95Nj6j0GH0ww5JEtFsAO4GiEwIm4SbrmRTeSTnO+EAZNIOPBdfF6GmVSUHq7q0E4cSVAwrjwtUPQ4xKOUSGMkT4Rj3WvRNeOvxljKcMusbV1oWj1uFHr6TqGqiRQEuuz8P4YMpOmDzxQxfOxIMJEz1hLd37zN2km7OW91S2naQn5ZSud4aDfN5v8WReABceJzl9ILSsetd1wugkoJ4oonybYE+XXpluHtmajNDTNrhmOJw7PcwzDCGJ42T86V2WDNQ+armXdoU/d21yjN150IPIXZcaB5xMd8KhLvgKTAoiLtTpFpwLagqC9sm6O4NQN5b0B1d9xl+6dcHIBSffpX53aM0nZqJ7E2W+mJWJaoioZWWUyDosKcyv1pR8F1phDpoHTKEJV3jGoxPuV7CulPLd2lbr68Z89exJ2T23Us6n8ag479avFS/d9eH0+gmtr3B+bekMOp0hpjO6dEaOVb1dP7o2p7q66zsjxDT+3fVb5bnKo3a0U3Gzm2Or66uyWkcTN1n3BKsw5Hd9/lqZNNvvYJremfr6NGXik5KnP6nYyo+5h2yHLJQJmnP338JvNw4pqUDibUQdr3jFKy5yNOsm6y1e07l5k7yX33rM6JmkJ4VeKcpueEmlUlm935QThJOiDKFhKOUUn5t4rP9TplzxYDeu6AO4EOd69vAMsoNyPM+BKz39Mf6wJqJHKZdonFBXyOTJwGCOzAwPc7PafmlEovA8xbQAhsiZd0YjjPJZeopQHCcP31BRZtzTE8e1n2ftt548wOAGEzIt+hZypoYmZAPeBxd64hjpIb0asgWtYMQ0ObLyooYc9S7zglEcE+FJ46iyoB72enWZlNu6NYKm/qUxzOviTz1NvY+iAc3IAvOgZiRKeuM4Dqm/8a0xyQ3+PJkNnGgYtD5PffSwJcbQMQJXGH+oWz1S45Ljz7glD6EOPdF0WtAZwY188yvRZh5KJP05j9xEpl74h++Kh9w4dz78KDy8zBHnfFQHFG+Oi7jLMEXbtx7nntecyz6b+E9eI551WOAZT2ZMz6vkH/xWL5JGTteLY8NSFXaT2eXvuuBOZRJCJsV9JaRqHcwjCY2jRBmGmOqJBw9VOoWm68ut9ekNZBw5DM9dG76NJ5cYVgpt1ivhWr/ufcaseyLaqRAvk3HnwzGR2XIdRs3CBkHrnijDtV6t9nmdTxqrtEhD7ODDYyJpizHX+ydpI2P5E8+1b9fSx0oQrc+JcxYqPOtMsme8ud4z3Ddp3WQQ6YSODq5J4TbHEfllMokbY4Mg4Tglw+Hjzgwu6oxnMhvDidxlEO/Oy4qbdKVWSMhncmfF6zwDfMAA/Bl6lsYpy248XXylORmuhjTpRtw4R1Ko8Z3Je6mjDX/n7oY7inmvG1ONzQguLpK8A09A6DGX2WOXTuGZlMdp7uwUp9M5W3GvoO0JQow/CgKhEqvw32l9Ws37WqohrNZTldfVPL+ldDi7tu7OoFDH9Za1dsWfr4Xv1vU3aVSYqiHkGqNKlhOYan2dMpnXu75eSzM7fO3uT/Cu6jhVnKvCf8oP6vv5vevDqkxyaUe7HY/r5t6K3mu9tb5b5BbrufXdhyquoxn6YhiHcruKuTK8667hQBS9WEyRoAJlaD0FmVa55Q1veMOlTQ5qMJwqaUNFjLUVGRNYhIF2ycvDdZ779Kc/fS8TWE/1dkgZ3WeqsYmSSl2VBTpvpFRGU7n0eb5Z35BlCBVSqVd5BtfKUEYqKKu/9a1vvQ8fQq74/Oc/fzlKHe8Q89OkEq1XSuaVUbbTsyK9VHIuJH/V0IAc7Ht6wPCNnGlYW+al4TlPaqtJyK1bI2ae7JaGL40g/jZNCPDQtp4pyMf01VQPGkbUeUwPYRiaCjq/9cYRN+kJz0cvK+DSm0i51rBBZBTDFtWx3KR3TDRaaIzQoEFfjTiwTg2nGsbsg3SaqUdcD3VCEO5K44atqbvalu1Bh4wl7fAstEYxjC+NU5nsHR1ETzrpX30j8yS5YayerPcSc1eDnvCgSzhX6FdN6A0MzAmes203otVFMwzuTyIvrzQvvtIwJK6qp5Hyu0YdYU99QTlWI1hugDuPND4lz7AOE7pLE37SgywjOjLZ/IMZlqrnyiQ05GKulctJk4mQLVmPiqZWfDvYKVh1cWUS4+LKOxAAEw8FFI8eCFFCSePLkwjqnQD6EKUTsJyInlIlMzJpm8kIMw4zjQHWUwUIF0qZk2FvxpSnl8lKcKZe6gHfKLsSp8fMAzsWZ908WaSdjDlJJGT6JZOTJnLREe9pTbU/ukQrrFBgWsbdrwSpFV10AvEkJFfc1Pp0s3ZBoU8yOPuRY9iVKoB3Ct5K2QUGBA29xijuTMgYEUYSLxRz/3gMKO/z25MnYOCeOKDrci7yFtqBJgxR9HSNpAUZsIuKxht3MvlGuNMAZhjhCgd1zlIHi5t06iIK/1CI4Hlgo03nmQZQd1KTx1R6STqYjBG20ymVqZDYNoYld3ZdsMAFuNLj7bFLpceVQpyKY96rylQtK6WoCuwUd7A/8YlP3L3lLW+50CD0wzXCIxCga+62Dp5dvx2riSfslOOsZ1pjVrx9osMTHpE8ZWqz1tc9szNGrPpU2zjBf6fkZ3+u9eSrBo2unWyro9nVnL4Gju7daX7t+ryip0mm6eSSqR/dfK9zYTWWEz4pJ/1Z/Z/grrzn9P0VvZ7SaOXxdby75+t3JxOv+EundD9GoW0VI3PcuDtfj/BWVvSEJ5XolBHTyxf501QDPOtmmZ7VyGCEyBEGpXxI4Zv1/jOf+czdm9/85suHOpBb9RBAOeWZj3/845eTRIW3W7O6eZh6iP/r726+VG+G9Biq9UkDhtx7Yp5KZcKsnuUmIzINsrxREqSg+Gt/7a9d5Ivf+Z3fufun//Sf3p+e6phgMNGTy7o1CniyW41cyDxTeuxoWIIekKv0etLoo06krqJBgWIahjy2XfnaevhAA25Ip9wmLlNvMH+s3uTm15LekJPz2HbHrnopZYSIPFF5U3hzc5LngdH8R0ZraNgzGiRpy3Gs7ftxA1sDCmNsOJdyf+a6mnQdjVUaVzRiOAa+pzE46cv3jNhAVmWc+YAf8yoJo/XqtCDe0POyz6nHpOFF+Z1nGEcNgjo8SK/q2XqD6c0n/eCtxHXTtYh3jbTpEfSTETFjH4Rbj7OU+dNzUVo0PY1tZZ1p0HJMUv/nWx1MPpGHUqVtJaONhMmP/9XdT+TfJz4Vrlug/W+ohlZBnnVQMh4xkeJRiSJZpS0nfm2HwrMQAUlXPSlAwmBiSlSTsH1LWdVxqoCs6vT93KmRILQoMyEzwfGqfzlWWlBlzDIHLeG6Hq+sk1WohWjZ8acdrd/8hnl4LLx40SNA5iQBS+y58FiMeU4GrJtsGj2pgz4ZQ5q7GJ2ANglgHTOdxmo1fvnbbxYFQ/akfYUpE1d3YVATPC5SXHMnh5KnDdRiniRdi3OnCViYuy7atR/OTQwYGlsyVtg4aZ+ttMmHhZhTuWD0PE+cO/VpmfekQj7Sp0eYyj9cXKlLnsHcdwdkCiWsArh0lIY9Pxbad1yM93aXlAUOmq67cCv6qWUyDIjDnLdpbFMQ0SBIOxrrXoxlwsPq+qTE1+dyx2zCpwbIz33ucxd6Q3DWaLjie7cYAqqieMu6sFLgT4xT+Vx9t8La3e/gPjWMTDzyGr67UqRrmRTznaFvB3MHS/2f69VqHajr2gqGaw1QHawTnmpbT/Jcfb7r/27sajun9ys+Uzhf8Yqu3qrse70zENSxXM31SXaY7p/MjaTn2lbFeS2ruf6siyFtKmYYbMw7qPcHJXfw84CNTH1g3hrlSNdG5StwY+JmZSXWUry2CXOC/7uGsg7883/+zy+5+N73vvfdvelNb7qcGGoBLoxK/+gf/aNLiNiEc+mi402W9ERS/lIurPJEVfZTlu9oww+yIGscuEMezzwq0rUGE2Q/DEnIUtRj2I9hV+CLfFWGFmlE0vvehNJ5gll6azg2iZPM/+JmqwYC9RIVdhOD0x/g0fM/Pd/sv7KdIWSplKt3eF1as32KhiPTE6hjgBt+01fTVoA321SRF8++J140gGVCeo0NlTaM8OAdc/vkJqxwuJFeozPcrBdP1KEexXMmMDcMTRrMqA/rygTUFdZc272fYZLCb64jDwLSq0bvJQ2g1GP+JGR8ca7XF7/FvYZN6TVzpRqSyDdjCa54RjwY9WOoJl5qeSI1sDAf+O9p1XoBaZCp4Zk/Ec4PjrfjqaHbZzWSJp/TeO67zlF5Za5D4pr/RgLpfZjpO+q8S905va/SIJuOH5lb7amFwq0EBABikBHa7STPaw2UmJOpMHieriACdYvNmNlOcRPZ1KlF2UFLxDxkWSkJK4F/VTph3pCcjC8GFxB4npSRSlUqV3Xcsh2ZIMo69VHy9K7uXetON1/rAv8s0FpRERKcHOkCCPFbfzLbXGgSf056kwE6rsYypxtyugoat13xsBubTqCuv+tzu+sJn3jKnFRcg2G5G+EcWCmWCZc7cBhqWEB09WXhT+Ojz+cJDS4AWurBpy6oncBtPT7bKWxp7Kuw0ybGD2DVLRhmrrcZC+Qb3/jGy6ks9MUdRWPuHVfaxWNK45QLDM8g7OnJ141H4lU6zAW5U4j0mPKEwsRBN18clyr8uRhMylblsx28OR66iztmum2/WEqFfVKUUnHzWq1j+r9SwvIdimNIjg1OdFHYzN2+qQ8npeMf3Tiu3q/hcl2pfHIqnVEg14fpecqJkW0a36lv1xgWJlqY6qrzqM7l5GU7I8YONyfjM/XlxEBzUmf33rROTbQ3wdNdy2cnOtj1oY7LCf66tbAz7Kza7trr5JtVyXm5G8eprx2vqmFRO9myq7v2Y8WHTvv7LIohMypD8uH0dnDNyw0wdQfe15tfjxzuG7qhEu7mojkaed/8OOTvpCgrsaY+99xzd3/v7/29u7e//e13v/7rv37xbmLdIAriU5/61GVzgs3UDDVRzu3wX+mgyk2d/JufNAZRqtdDvps6ge3QbzYLwRUyE33WuEHdKuYYjrjP++heX/rSly54caMRZR45DRwik6Wxjo+6nd4Zyld6mCnvC5f4EgceXsK76D7ODWBiUw+9B7hMHcBHuvEksDzZLpVs5TgTSVcDpGFbFGlHw4cbsNRhkmhDI+2rRgDuA2OmTVBR91ujl31Pw4TwmH+WdswHpR5Ux9s+8T9D58wjabiexj/wQV0afDL0TUOQ46FjQ9K2SdiT9lO2TXxbl3o6z5jLCoOc0Q0avEx8bihsOgvYV72RnM/oENCl7VIPesZHPvKRu9/4jd+4nAr5e7/3ez926JWRFjzvWBvGSJtcZxwxPrlRb190DNBBQh32z0Kf8n/OWw2xaWiV9tXNNBCpW2j8rLYMx756umk7kd5sWz5JMf+VNM0n8xe70e6Y5ongD2pYOhEyZBoQhoqOyquTx4mSE8gcPw6GxMl14ypVuCf4NDh0p4pdoxjcgotrnrkGFhVeFCCIW1ymQuvioZUzLddp9e8UWI02Ga7UCTc5vtTP+FLyVALrosi4bMN7ErAxvOmFJcOtQqKWYuO/MxY3LfcJcy6sXl8ZibrxyQVco5j9ycTmu/HuxhTmhsGExRIcmPw63TirEClstR+8D4M2HlyGIWPAWFU9Maxb11yNE1rTMxwvcVL7mwawLCsBGfhMoMlY0p6JMrmHsQjh5rWvfe19qKcLReZv0kCFcEORueqpuPK6q4pK4nvHY9yN8lqdJzJ3E0q6i2bCQcNOuxDBiU4TTk+hUAjSiKrA4Nx7sZRpblSayfk61VHpMRWyiqs6dxKHHd/r6u/6MNF7137Wt8JFxUuFeVozTvmOdH2iSK4UotXzdZ3t+kFZwTHNyd2ztY2EPeGUZjqZYNVW1pmGqYleEi9dHbs2VqXS1Ml7E72e9r+THbpnqzxY6XcF825e7ca81tXd72jqGllggv2kTPTSwdXRTicLTDBOdPmQcvBDFMNumFPIQHlwi4qVCo8lFVcVHvMFqYR5z4TAykkaIfTC8bp5I2kfw4nhVGw+YEj6d//u393Lqsrfykk5l/JwD+XypEX5jx5C9bnkWem9n94EFJ/PUKFc21Kx9b4Jk/WywVBmKJTyAv0nxI2NT/UojGfgC/2DYvgQMPG+G5K071gqS1bDjf0yvEvjTYYy8nHzmWIIF/kQuf7d7373Amcazuy/hiXzbeWR7hp/1A00UPCeHk9pONHwozylB1LqAY45xTbAp4Ys5Qs3cZMmxVmOm7iqa2TSbYZhST968GeyeQ1hqVdTzE1Fn400qPqhBofc+KdkMnblYY1QScsZuupczPBIk4obEmdqEOeU72vQk66MePJ0avQnc1hhcDSqQD2YujGgAhOpDqjD0Ds97OoJ8hra3JiWdjM8UDqgJH7lJT8ZoYHSseNhG9aduav45EmGziPxlrSbNJCGLn6nJ5/6trA67zRApcOKfDR13uRt6pQPZli6ZkHS9U4GJ1HYMRmT4Roan5JBSPxJWIaAZVkJc7uF+tZyrUBRyw6WKnQ4wdK6XeuQoaGQo6yDK5RrLP7mkOnaTSV6hyuNVyjyKP8SPAsO7aSLnkzFkDWK4+eircVbwpdmauij91ks3DnxWb1MEu5TYX/qb9KNVlot6BTdNtMIlO+dKGG69+p903mJdXSW95IRscAbAucCRn3QBMwXr7Q07OntRd+qC3K6RV4z7ydhOPvh4q47LDDA5MGFSTRZDHA9dYzBvW7PSccKAbnzlcKbMHXjmx53VZFdCenpddT12f6y8DFP3DngGv0ypj/dUlcKR+LNAv05B1KAtLjIv5jKNQaVU/6641e7NnOsd3win51o4xSu6b16P9vq+MI1uFq1NT070XiFsV7L310/VnB0ba3wONWV8KcskXjM7+qB27Xfzc1r5QvbqniqdZ2E73W0m2E/eW1laKg42xlaOlhX8O3WkNru1O9aX4f7bo7WZ6b/Hf5XeKlrcbcWdNc6PJ2UqQ+1zp2hqcLykLLxLcX8N3rN4GWtDKMCRHFNS8OL8msaUUwqncqgekOGk1NSBgUG2kcm0mvBHKQaAZJ/pCygbOD1/E56TLq2b5PMl/pQ8qeUsWv76SGdRTwoe6s4q3waEeEGL3qESjfyfRpCMqyGgi5gGFUaBnLTJuU05cwqOzsG1G2II3VznW9kXIxcGo00eKj75Gl34ka5VplIY5GGFeEwZEhF3WfUU72uQQyYhN/6xX/mUtLIoAwo3nw+Q0HTkOYYZjgh72fYlCXH34No/Ainm/gZkZIeZNJbGgWtO+dYzkmfNW+TMFcvrPSaSSMKdaM3JszOtzzwx2czTM/QPfBsv+yPOIMmPM0P/QfPO3ViQ+EyhE1+kEZp+6hOZKSHPCkNobStkbTjwzp+aExPgw2F34bzOp61/9JcRun4rTFQmnajOb1Bhd3ILsdWG4zjpSFUWJzfpxvWV+VYmpSevC9Rpnuj8aQCbzxoJsdyYktM/teopIWyGpYqXNOCuivXCulPs3SC0krId3J74oXMBGZsMj4U83S5O2nXuv022Rv1OgH0NDHRne/SPguSVmGu6UGl+6WujRQtoclUKkwaKDVWyWQ6uJMp1T52wnVeTzrGqEF/8whc2tR4h4LvCX2r+mtfhDvHZBqXKvDW/yYDz0VfBsscwrAkzm0XHOM2WvP1OFdrjqKp7IR6mXIyMS3rJuFmkWC3IU8hTAYmjRgSm4KZtGZySF1Z9VbqxmISxKeSQuM0R3LcddP1iFz5mAsehfsZ016VlGrwTRg1SroY5zv03eTqL6ZS58DKIHBSVxWqp/le37tFidqteau6Oz66w8GOD9wCq/hZhfLslPWpvRNDxEkfkn90CvnOo63Sg9e7HI217mnsOn7W0dqujvruCicdrdR6Vv2o68Oqva4fE+wTDqa+Jxwrupz60cGxm78dbmrbHY3Ue12fK3ynMJ3whSrvnPKqSdatsoz3u/XrMQsyK/CxZiFnYdgx5Ir1UkOH8oD5FVWaLdlHc6XoFZ9KPaWmX1BhU6mibtI40C6GDGSUPMgjxyp50ooe7E/KER1P0wBkfVW+7YxJFSb5fM7TlDWtR3nBupQdPeKe4kaw8pSyYZ7e7CnMej94mIs4U8bJU7szoTfFVCfC4YEur3jFKy4GAvNoYiDQgERdbvbqrWMomPVnCg5xa54hx0NZVA8mcZ+nmWlUoy96xOlVlR5ZyqB6d2jQcR6q8Gd0jUYL29ejpybCtr08rdniGJvwunrS1Q1+N55T3pZGNBIJZ9KauPFaRkdoxEuvr6RHN7o1cvh+brSqj2iccm5IO6k71FQiekTxnMYm5i7RPlyDr5AiQ8Mk18wBnZ6IafhzruT8lWaETXuG8P1JnAgnXqWPmqIicWRd4tw57Lxz3NPjqRrWcx7nc96zn84LPdbUF+23DhtpgFKPe6rJuzuh1JILgb95VmbvwNthB1RFTOQ4qCIv37lGkKjw3SK07wTop1VWAkYuaCblk/lJaJ6+xWSq8ZnTwty1wwemgKtpVZx1OcxjunXNJAzLPDrGy7qYAVPGLfOOOZNq6eCusE4C3IkQmLh0h8E8YRrRYOxa1DWoaRAznnqiuQn+uvuwGo8q/Po/BYJcLGXywEo/NOzxvokXDUtzMWFs0sttgq/iuAqwwqXBE3qhbpPtGTOtey9GLhcTcMl9Qx/dZdLDKWnM/rj7pECTz53A73cn8E0KSDe2jpOMOt1fc7HMXcIUAHJx6GjCtty1kU4VJqhP3L1YyzV8tOO7q7VnV9fu99TmDrYVX7lGmdspwZOyewuuVnXVPnT1VaNC1/6p8r2DYRqTynu6Z1IIv2YdzzorLzkxkORzKxpbwbSqtwq4te6HnDc51smndmOyo+cJtnptWmO6eVHxlPCu2r8GFx1Mq/a7edHR1C1y6qqOSZ477e/TLoZmeVKVJ2yxfiGXaBQ2hKlLkqtynrk8UwZRHnZNpqQHowYH61POQNbFczoNLJSOljrP/3w2n3fjr9KPcKjE+b/ST22bT4be1Pa70F/7TUklWHwqQ4gnDXx5YrNGpUxVwJipb+jVrw6YJ0/r/WA/hUG5h/sYkZBtNNCIZ/UPowkcG9rjGROQe7CMfctcMjwjzqUZaYR39PRwLMxLJc0Ir8Ye4dZbzmvCV3GtkSDpznHxer4rDpHlM3zN8RaHGv6Uh5XhNbI6H+y7baV+nZ5Ljok4SlxJA95PD/pq5FHm7XL0aMBz7okn5Wf1BA0+1JnGKPstTdP/tD+YP1gPxMwxZL81qmi4yo3/tEWoU6kraUyreYT/rESgiJfUEflOTyGeU1cQd87XDA0U9pzblZ9UeUfd0AiZNCoJh+0bTWS90sQ1stPVoXDTQpnFiZzeE1rqJNi0xslwTO4tgUmUMqX0oJgEhIrUx1CGHrLsFJYqvDnBwaWJjrWwd3WvBP9sw0XD+M8cO+6Z+M8x4j3G0PA1ihPNiWMS8jzxTUPBJDBOQlOnJE3C44ouFD4M1+JDfR4RKcM3aST44BkTCXZ1X0OHkwA61cV9DUbdbpzGDIyC0oRjAPzkD8gjQHk/47i7vqyUiYQLGIhvJpafhdy6EVowJGWetcyHxE4VcfSGH0JDLAoIGpmIHOaHcYzfjAH98ISLCf4KbzeH/D5V9uoYuaj4bO76uDuVu1gT/rqSzzOWJvDPY4JPvc2edpkUqvp/NT+6+Z9hjqtnu7p2c3GlBE7Pr8KV8v1rxre+0wkM+fyta920jk596wwTKdB0/Kq7Xuur7+yUqQmeE8U765vw0b2f79Y+7PBf3z2hhcqjqjGi8o6VXDY90+FveiYV12ncKlwTLLu+dyF8CeNuHLNMz3e0vCu1nqxrJY/Ue/W9aUw6eKc2s6zk49X/Z11YDzVMsC6yEYkxB8941nw9cFWCpMH0eLDYV3UOvYKVKVWklZPtexoQVK704qZ9DF381nOpKt51XCrfrmOhgprXc25NSuJUHyW9HCoe8r915CevCQu452MOTE/ryryOymB4dWlI4Hk2Ej11WDzyjsYAN7mVgdKwlPlo+A8MyJB4s3nasLIOMh/P61Wmx0tNtWAfM5Qn8x/Zb42Oyv+OpalblJ+JxEB+Va815YGGDuU7aVrPMNpJ7yb+54ajhi9/s1lv0u4MUQKnGXKVfXBcNNQ47hpX05CRsnce5pOyam5UZ33CLu1Yh3mbwL8RSWnAEW5h1E6g8TLpWmcJ2mEcNSA6/4yCyjlT+807nP7LGOXBUdJChkMKu0Ys6qmnv6UMT8kcVoai/VmEUuZYm0IlE2RL/zm3KRrSpSHnl8apLkyYe46D45Whlp3DRnr/SU/2J8PtnLunkRA3eSytFiOVWeMmk2HYwWSk3mPygAQJgCLytA7WHCsTU+/gvFXwXuHgoeu8pr3atguwJx34jMwkPSBWcHcCjwSqQUXXuHShc4KmsOXvquTmQqc3SlqfV3BVXFQhbCe0TbjtrslYFTBkOFp7jZlNZlbb7QS7ScHqBPZK45Wm+QCL3l9aputuXW0zBS2FtKyzU/Q6XNV+prDG4oKQKKMCNoxFzHEWCgQCk0QKCwWPpa9//esXJgx+PaHBpJrpokq/3d2k3wpEadjZjXnC7vUc++Rf1fV8qi93mii65lJcIOVllV6SFnJOdWMjXfq8dT5L3jSVTonp6PDa0r1zMs9XbVVekbDuaOhJcd3BXtterTcT/eyUyp2iXHEwjeeE91rnqv+1jys+M8FyTdnJCyel9q/jz6d1drLMBHMHx+o/5Zodx6SJDr4Kz278p+cr7k9kqgmmCb7p/sT/T8vqnW5eTH3r5ISOFqYxXrW/grtr6zFKKv0UNkbY7PK0Vw0byAR1d95PGnosKmP1edfhxEPu2qOzIEOj0GrMMjQOWDB8uVGaRio3HVNG8F7KFRSVwY4eHQ/1nomH+l8viawr8dThO+kjvWZSb0A+Qwb74Ac/eMm3xDMeigL+MHqADz1E8DTjPTa6wBGGwdxsNiQxdTuKHjhuxmWqFGF1g1IZkoTqlJe97GWXvn/mM5+5N0LyrdykoUQ8Ze5fn0mDTfUw57en5plny/GhLcPcgB/50zY1aACL+MxInAx7c4y4Z6oNN+t9T/qs3i7p7VTHOsdYWVN68r5zIQ1KSWvqjfWk9fTsErfSRxrvjObIFDcaapSvKebvElemesh6nEu2pzzO2OiFBL0xDsxdjcGmXuH9X/iFX7jvmx5fmZTcb38Lozqv/bbvVWfKnEw/ivmX8rywVyeMNKhm/ippKed51u8z4lT+k2Oahi7nnX1LnVYayTlqvxLeB/dYmgSF/M+HCYdFl8UhmaNGJUPfkpHp3cJviKNaxT0VbBK+dov4idByTVkJ3E+jrGCX+Dw1Tvw5SQwvmxaoipvJUJALdHU/nvDQKQK5eHYhR6vf+X7Ce63CNwl/qZyL10zmJrNjQXSBqYJDxWGFvYNFF0qt4ekSOgkVOa90+9XYlbtBhpq5M1jrOVFqVnjsijuGJtfTa06GCI3yH4MRQknlBSzKnJrnQpw5EBJm/uuxlWNXaX03R9MA5MmDwO/iBG/SjbRTSrPYBxd9hQj6qzcYdXXJhKUlYHAc3c3JU2h8PscuhdCH5HXXllN6mvhCKgMTb6rKRF2fnnQNmBS9a0uO6VSuuZf1dfN3p8B2109Kp6B3de7mRldfN867d0/Hd4L3Gt5Q18IVvBNOJvmp0n8HT12rVvDuxjlhX61Z0zM7uWtqb4J7h8upbxOdJfy7Z1dwr2h8VSZ87XiAz6xgXdHhasynuTK18yyLiqbrr5suyLJcR1lMg4FeIxQ9D7Ivmaw5lWHWCvPA5PqiMYBSNzVz4w1dBpkFuQC5xJD+9BqwpNKdCr/XqreTY9BFc/ie/1338rp9r/V3pdtg7uiHvmEgQu7BqKMxDfyZ8wjjUoZaqXgajqX8pALPhqK5kmzXMUxYxCnvk2MJ3JMbJ1OmmC/nNa95zd2rX/3qe5oxb2sN+dKolHjQKKFBMXML6W0jPJkTWHlO2jUZOrTqqcXSa9Jlyr+ZwNz/4kO53RAuNyS5n0aapCn7pP6QOUYzt6p11DxFhj1ah8+CM9NYONeSNinZF/VB8V3DwTKCCRxqVOrWSA01Oc+Uq/OT45R5e3OOQb/gExrkGoYrivwkD2JKfLtRzz3pSlyboF4DTUYq/FToxuIjdbkM2dVolV5JqctYXxoSk2dpRJJu7LNGUkqe3K4Thzqs8JiYPr0fMzw3+dqDGpbqToHIz+IkgvEaE5oWR5CnV0EVsozthQgy707GVlaYOjiTQDul5KHKbmF/lkUrr94bTCCIAaVdN8KpdDiZhE7HKXdJ0ntJl9D8ZBsdzipN1TY7uHJR7ZjdSqhKOKa+qvwzIc2Hk8+6mGrx3eFzwq8MgHh+Fl0NgiYFXwnX/lf4cWFltwgaoNAHGCqfZJi1vhPX7hM6z2eFzXxUhrzSP8MqEU5cQLMO5/zkBecYJJxVGPO7E+LqOFCAh11SBARzarlYIUyl19RunPWwdJdOzyL6ryCSRqKEg7YYQ8MvmWt6JJqYW9wmznYK1GOUOse9VmnpGgW1uz4pmNO1qb5VH/L/Sihf9eNUUe/gq8rpSbsnymz9f7JOdv0/XQdr/Sdt1nvVqJh5DZKfdfju+H6H34Svez/h6pS82k7Hm1Z4mWh7gqWDtdZ9Qg91La711Gsdba9wPLVb+zbVOc2l2gd/dzDX0ik2J7BMfev6X2WUWv+qVFqodNyt2105xeGzKrkhpIJG8XARvZw95Ri49WbJ8HlKKkkqormbn55JKkmG2qSCZiJeQ3HkK6zLeGBjaCEhMN7Wekyr31QaqvOp432W9HCo453ez0nTqfTV9jqPJUoHS8KtbIG884UvfOHur//1v3732te+9nJcuylLkNvMmVMTEqv8pyOASrThdI5FKsKOmSdEYzD6jd/4jQscX/nKV+6Vf2Rl2gSWL3/5y/eJm/X20AiSeZUoji2eTowbBkLedROU54ygMEomDULSDs+SsxTdynHhnieDZR6eDLfznvKg+NZDKuewRqvUoTJXWA3l87qpOUxrkYYYaUK9POnSZ+2LhguLhhG9d4QtZdjUA6Uz12Xr0OvMRO8a+yodaODI0NOcy9JrGpLFkZuw3NdgSMETkjnsuEDDepypc6gj1bbkTebbla5sy37Uje0/izxwzqtat+NrPzREOabiMOd5Rg3JB/xQhKfqS+k0YX+sN9+3TWnLdph7D2pY0vNAYFWqk7C8RzEWVcVKwjS7efeeHeaeOWNOBKhcYCUCByw9deqifiJAr8okIN5Sz5Mqg04M++wiXF3gdjBMfXFcZKQyKSaZiZW1eEqMJlJOi3nCa7sJQ97rYPRbZcKTsSgmBp9CjDqcdQKiOAR2d2p4zr5Jw75f839NpSocLjQsVBgSnF/OGeDInEJVcUkh02fMR+Aix+88TWCCq/uecHRCr7Tl2GfcNkVLvsJcupYmE6ywdDBWPGTJncQJ5hwLcKbByzHwyM6MO5aeV/Ne46CLkAYh50rnfSUcGBjNTyBu8thQBG4F8JUi+Vhlp5x39+XRSeOdEWB3Letb4eAUP1PdWc/U1jQeHS2u1rcT48auP9fQw8latKuvht/uFN8TZbhe63hiCmqTst/VeYKfFf9YwbZ6tq4Jp/Du6uvuT9frWlx56kSvOUfzu6PPE/g6fKz6tzKOVJhXckCHixWfOR3bqe6ujlQArsHdNAe6Pk/vPGZJuTDTZAAfG2uEVr30pS+9rMvIDIb8pyHFb2UmFWCV2FSu1Q1oB8USRcnTjCnu0iO7mJ6Dd9yY4zryGsYJQsQwtpDDRQNTldUo9X9649acO9145KZfNy/ruFavpsobJ75S66I/GF8+/vGPX4xLGHqee+65ezyaMyf5reOXEQ7+TpmPdlSkU/ah6MkCbj/3uc9dcE5+TcMh9SAjlxP/MfAYmuZ9dczEoYZIZGroQnle2PWQUW7MjU2VbGBj0x7aQbYDrkzzotytocoTo30/ZdJU8q0jPV6kZfHic9aTtK7uVcMIDYPKZOk1z5Q045joyZLpH3ye/5kYuzqbiANL6t/UjWHHZOwa8LJe27JecyplCha+ayJ96TxTl1hHnhDIeCQ+GUvH1YgpcV4TdUub5riS5pyTGnP+NPRd31cPMCzU+45N4oH/5u+V/4BTnRicP+Kv8gONlzm3q8GLIm0YTeEc4X7qoLa1ck652bAEAxZoB5YJqgdCXQA1IuVJSMkUV8rrtYJnEjlKGdZkkGJ8pdngM4dPhaFrbycsnDyTZVo4dgrh6eIvY5JgczFa9Xcl6GW9jCeMwX6DSyecidQwkDhZDcFiUZbBdgJf19f67W+ZIBMN5q7rqTCYYLHGu3Z9rm1UpVYvkUxgl+6NTky8WGqoYRUiKbmDxG9P2XNRqIsv9zVs1bHqxogijddEeKdl9fykyE80Dey4U5tMUfdYGSiFZ1IAOKWP+j9p2IXX3Yr0LvOd2gff0YAjs3WR9Xn6oSfZpFxRHIPctcu2Ox6Yu1FVQPQbmjCWXZidn7l47AzJj1m6+Vb/r5TLWk6V7qx7qqfS1wkM3fq2aj/7WxW/1bpYYboWT0+jdIrr9Fx9p1N0urJbt1zvav3VuLUru3FbKYv1+sQrpzo7HjIZMaayWtOyzfzOd+szu7Gt1042r076cHp/Nzf87vhMx/9Xclg3Pp1HiLy3o5Udf6jGg1N8rdbIlD12a+tjlNykyQN/VF5Za5HBkPVUfpDv6gEVhpbojeAajgECw4NGJovKmvIjRovMz2PIOsXQJr119LhAz3jrW99697rXve5y2AihWeb6yc2jjmaTTvJTZYPkBekd4/WaY8nvxGWlt2y3en4mjZpGgVxL9Olv/a2/dffe97737jvf+c69oY0+80zSWbabfbUN26vJsx1f5WrGHa8wDUuGHXGd8WIMyJujJ7yeSyYbt92U5xiXP/zDP7w/Fc7xdlxNd5BGpcQRz2kcwbjIfRwo+DYxtQaEPJzG+pIuMtdS5jtKOc7xrWNmiJY6icYkN0Md55qmJL1cHK/c5HQjtW7K0l6eNFyjCTJfEJ9MkSJ8hkGmR1HOf+tTBk9DI3iXLrzGO3p+Vdo2ZJOSYXwaTmoybnEl78nDdfiYvJ179dRp20uD90+/MI7owhhkoVPnqbTxrW9965IvzDbEYXoIOaZGCRlJk/Mt6UnYpUOey7Qq6bmW8167jt545JTjGeY5nl7QuFEXD2pY0oKlC10misokZZaTBawTojuBZ7Xg53VgY7KrrKPwQ1yEt4Agdj8ycd8k0K/aeZJyspCfCJI7BWQS1rt+VrgmQRSCBJ8QniE6TlQKzN6TDPhQeNZjQTX0pPC5U/K6a1p/IXx2sXIRdjJTWHg6AW/Vdt63HoUNJ2laiN3BchE7EdqzHyabo8gUqkuo9U11r2C3rQkHt9Dd6pkKo4IH34wXdOERwtCNc7Iufp0yMMGYbUqT8AEESviAOxiMI8nCXViyHpkw77mz4LfCiDtzVXnqlIa87g7TCk9V2HQXQ7rL2G13w4z5ht8hUNE3Dapdmy+mUhWo7v70zqR8Zzl9rl7v5m2387vrR45nNW5MCmu277VuPkw4yfomHO747cn65HM1RLVra3p3pWDv4DgZ0wrDCW+zvlVbWedq7VjBMimZq7HM51OYrTDu5KSuPxMeqmx0QosJQ77vR9gr7UxtrPh9hbF7pvZ7N1cqL6jw+F8B3J339MhwA3Mai9r+ik/t1upTWZlvQ8oyHH3VxrMqtJ+eRDXvCN/Iluav8SSw3HBRufJAFd9zXUeh1fiRsiLtIdOy+cl16rd9x5VnkB30WqI+8KjhiVNp+Y9xCQ8m1mE8lTGE8J3rRxqaqlGpyjn5WzkilUHvVQMAxU21ekKV7WRITK5PnaFL761vfOMbd7/1W791UZLxIEOGo38afpRPcjM3Da/WhxyFTmbOogxL1Gigl5k5bXheLxiumWKAcfnSl750jwOv1RPTMhxKw4HheHr5ICtqvEjvpppsGl2Sb/oOvbzqVa+6zwGmQSvz0giD+oMhe9JgGuJ0hvB64lAPMUPEMrF0GtEc75wf6huZ2yrlZT46CPBbL6H0YqKAR9tyjDIJtHXRppEs5u7BwKKBNj2v0pAsL8hE0m64e5qbvELZnDEwUb9GRWX+Kqvz3zHO3MPiWg8kDTjqAfaXb42X0om81Tmk8enP//zPL2GzH/rQhy56jyl+PMH5He94x92b3/zmu9/+7d++GG0oacgUr/YleZ1pRVK/TccHjeviyPc1bMlTzHur4e/1r3/9xTMRXuahS+Dnd37nd+7+1b/6Vxfj+YMbllLJETCVMXfQTxbBlTDYXd8tssloZVgSqxNCl8e6oO4UnFU5FVavLTshaaWkdkJJJ3SuykoIMwGau0fpMgoNQPAy8kxOZs4avWgmeE5gpE4WAevU9TUXymSSu752z3ldWq+u0k7+ZF7XeIjkwq27oQnssp7OCHpS6lybaHWnyHQwU2ReiYNuHvEf2oBxenStuxbQUibE9vmVMlH7lt/+didRV+Us0Gd3XCb9wdOO3TgWQHcmMYYBKztc7CzoHp+7cR3e6pidwu993e11x6WkEEA/4HXsgvz6r//65fk/+IM/uAh/6c77Yi0rOjtRFjOUYEXfJwaXTrk9UQqnOissqVhca8yYnjm9t3q29rEq+vW5awwpK35TYZnmToV7tZ5NMNa+dXhdeUzVsV/xy1UdCd9K/tnRwgo3yZ872E7lle7Z1Rw4eX8a4zo2XT9Oymr86zO1jUm+6uRV5Qs2Ld72trdd1jY2TihcYy03NCq9MbLdCTen49PJd6uxVhFhPQFG1jM8eDCmdDkXn3XJ8Te3IDjUqEFhzWYDijWdZ9y9R540obIKeFW6uY4xwJw8Kv3IkIZFqcBmTkMVbOUFc71QTO6sYs1v7qugubHKteq5I+1Vg07+r2OYzyc9+Z5GTeGmL+brTDyqjII3YLMe26Bk6FcmceZdxgBDHMYk2qAOFOZMC5H9tG43g5XZDYHTq4WiMm+xbWA1L1Mmbcdwl4mfzZ2jJ48bcxnupvFG2PQ8Y7ygkQz7qTwbuHkGuqHfXANG3mVeZR5bDRLMO+DXAyWNSGkQFF/V20v5T7ozV6khUen1lDmrNNykjuaYJh2ZN1ZjXBomxJd6tIZ0jTIemCOO3NS33Uwlwbs8Yw5g193M1ySdVbrW8Md7GoXEvekinH/5nnX5Oz2UaqocZTTqNEQy8x9pvBN202Ekv8580n/hL/yFCz3+6q/+6sXYTD42eC73uM67zz///CXx/Hve8567//yf//OPHbBlvfI5+Y25nMxrlgnf7YOhdhneliHC2j+kUWnqF3/xF+/+/t//+5dk+Xgo4k0lPjA4ffjDH77o/iY9fzDDkpNVq1/uDNARc/p05dqFqzKprq5uERZxDhDI81QJEM7OQk2IvBL0VmWlTDxEmeBaCaWdkHRt3yaFQOs9iwuEDoN14mkgAO8ILOap0WXTLP1d6ZS5SQlwgdL6TZEWNRpmaFVd6Pw9wdBdq14qq3pW9dV3XTTBqQKNLtway/SuORnDXdhHZ+TY0Uc3BuAb/Ot6C65hOLqmVyOT/xkXnoF+MuSLRWfK12abVTmrRhOf0UCEAKBw6S5Q7th0NMUC8MY3vvF+IYHZYrl3N4adMQxkNXSv1lfpOBe3aTwqXYAnBDjwnK6tmb/sLW95y93b3/72y0LgbhjvdPnrHrOsDBOnxpb6/KQMWnK3cmqrG6uu7mn8Vn1NmHbvrZT4TljvYL/GwLJrZ4en07amssNLvd6FG+3qTcNBDcHYrTNT6eCtxpCVsp/1rMa869Pq+k4emIwZ9Xpdhyf489mpTDSU41Lv5XsdbSXf362tK3hybereqTioXhfwY5I3w5Pht/IG1jD49Rve8IZ7AbzbMe9o4xpePfGtxHF6trBmsNFinhGeYc01GfZjb0CooJlSwI0mvSY0PmDA0CAE/lHUVEw1bKhI6dlhP7mXm0x6oSgfqDfQPut+VVwp4Mp1VXlCo1RVht3czNOypjWo0qb0luOZnkT5TK5z+bwKo4fP+Kz9Mgys5keiVOXcovxPXzCcCrc6YTV81X4mbvQUMhescKE3ZH95JtNMOBYaKtKo5QErnkSMoq68lF5owG8eJAq0RK4m2+I5jUAaJ7nHM2zkefoyc5320C/5CJtyMfUwBrynXCbtWW/2U6MMBkHaN8QLevdZPbf4DRzpfa/Bo/LTmvTdtg2/A4cafMSTRiHnlHXoPUTBmKbXj7K77deQNq4p/1ePtgzbS6OWOXu5D06gDbwD9RL1wCOum67E6IJqHM0DltILKMPHHLtOf8nT6cSpdGo96XFJwRjzl//yX75sSqvXaUxVt2Me4f0Hf8b4lDj0t2FvemRxDbxqbBUOoxw0Qolv5zt0k0410CZeSRiU8ELEU+mv/JW/csElbaOnAaN8l3nywQ9+8O7Tn/703YMalihaU2UkKlgAWV1Nq6ByKmj77KQ8TEYAYNK4kQPPZJQQ83i9nSv/LQaD+ux0r9bXCZkd3rp+d78n+Cb4O2F7es4FOLP157Hp7CR4YgTPQqjmuKpC3aTMTUK3i6ZWYdp34XSR4j+MiDoNU+vocIWzXNyqEHgiiHVKTIdLd9wyrNS+6HJZ51Rto7a7UpxOhO56LRVOd2hg6OBfDyB3QTPuuNaZeOM9GCrjxLxk3KATmVn1CKr965RgFzSNdLp5ZgLCzPeW7yEYIACoIPBu7kyxK23/rK8T6CdYO0NYloovxl/3e3ebdW+nfQUdxkLXaRZYwuIM9ztVmJ9W6RTuU6V5p2DuePaKn3Tt7WjtWsVvgn163jaqgjC9ew0+6zur/kzr0I7PXFN2701zo+PF0++J32edpzx6NQZ17CqcdTwrvDt+Le9YGTZP5nm2Uw0l3e+VrLGiy1vwWOGr878bo2kt79aFEzimNbLWxzd8Fp6csiZypUK/iVm7krjv1vQVfJOsVOFLxUmlWENHhonYh9PQhqdV8rRd4FIekg5UyviNMq3yrVGINdGkzhofVO58F1lK+YXnlUfxSAYP/KcOlTo+KrZ6fKkQusGeirGbgl5TLjZVg+1XI07+rqFL3lN2sX/KihOfcyPKzbqEi2+Vd+VoPU9S3l3pXrmpljpg9ifnsPpi5iX1HvNGnUxDjqFHjgcyl6ec6VWDUSc9VNKLRs+jTGGRm8MZTuX80AtILy4NOdITSjXyKrIV+HTuqKADg0p+5ubRc8SwxPQYkRfQN/qDjCddQi+GfOpBk3KhcGug05tGWslDtpKmulxMGttyDGwr1y5l34wGMjTVk9UcB9+VR4pLw/SkwUywnZ5alMxZpEGKdzXwcl2jFtdtX48d2tdY5vhzXa8ho2vEW3p6pXGp5ieSF0lPws21zEP8yle+8p4vaH/Q8YL+MA4mOmdTG70517s0xKY3Im2p13rfOSoejOARh5kfyrmHroBRCdr+lV/5lYvnlPodeePIjQuswEV9GJ/gu6dr/7FhSYYmsnQzlZhOjQMnZRIgu/85eczbolueuUi0FmcG9x1stwjv1z67Enq9vxOiVmUlIN5SctJ3eVz0XiJsiLFgEmPxRCl3Amc9JwJn/Z8J4ZxMMFt3ErD+Ov5MWiZGl/MgF+tU6hKuiqsaNjEJxFPf8lnD3zCmuECIWxPOJ9yndFDvd0J5VX53xb7p6mliPPDnLhHfWN0xOibjrTAxJjBdmJqLnbs+1IcRp6OVDt7aFxcCrfr8N+eFXnW1DoUsd0zxeDLUEzpmIcMttBr5sm/pbjzBfKJYJT0JjzsL7joDL9fAIXDaV5g+xrDqrfNYZVKkd6FHCkf5TBW2LSd9rO9V4Xni86u6r50/u1Jh2ym/+d60QVJ509TfyfixmmsTPLeU07WsloQ5laIVjYmnxNlqrHdzNoXAlULWrQPdmOye6/q/wl83XhVXuzXkBBcdzKvfu3u1zR08VWaq10/aWvXHehln1qlUtNw91gMIOaR6xnbtdzy/wlxhWOGA4kaEm24eAMJ6kYfXZIjMqv5nUdJjIPO4qARp3FGOR9lBpmS98/RWw7IsvKeimbwAmSo9LAjp0ruejZpMeM2zPsf7GQmh7Ci8yh0ZwgRNUC/feDobyuLmVsLqO1mSDjIkLT1Qkn/okc14u5kubuvJXyrJKtnmO8rwTcOeMsym8riEsVtfsz3gMb9M0qchbl5TRlPO5B11CeryRDe+00NNnUQvpjSq6iGix5U6K3MZOvJAlMQx38wlZC/kLBVtYaAf0I4GAo15bkxKQ46JuYlT9tc4kx5k1GUepzzRWY+UPCSIujzJWOOSie1zzBwHjWnJIxxno0s0oKb3UeY9MkUDsHnCmnmMjQ5wjtE2uMrxqDnBnFsafTRUAoc0bB/47Ria39Y5mvxNg3LSanpCgR/awutKrz4+zjNpSTtHhssJi/Wph4qnpIG/8EI4mvREf3SE0KOSscDI8+1vf/vec4ySG9jyQeeW9Kx3ll5JmYc1Pazsmzlk0RPI72QSenmVBjh4IfoZIcmOnfxiSnl0s2FJjyQa1gXUmEc9Fbpyq9B4bZEgYOIg0jASB5NBw8DRCdg7ReJplp1QuNutvAXu3XsrI8ZKaeY/k4oxgMHrxpzHK+4UutVv3oERYCxyMYL2UMA9dUCXZ4UnmF8Nf+yUpJ2iUQ1H9bqfaqxa4Vnrcyb0S9fLumB3uOn+Z5n6vRKwp91tF3eFAeNzva/wYCxyFewVzM15wLPmJDCcEXfXCkcdmwluDUi6gSucAld3ch9FYYTEdNaLMEG/MPoRb8y3TLeOiUlRXQhd4GXyp4aCOtfktVyH8cPsWRD4DZ0DIx+TRrpIPZTC/5ClGjlWPKZe29W3uz89d0L/p+3lc1M5UWhPFPJTuDqPyw6e3ZzK5+r1CnP+Py0J42qtq9fr+t19T6VTkGpfTvpRaWyHwwpvlt041LpWbXb1VMVvgqXOnYqT6bvW18E54XnqQ4XvWrll1bdr6rQe5hTKJTxf5Q9ezJoGD2Yd0Vt0Nd4d7Z1uYFW4ss8qqu7Ga+DI0BaVpdy9fsyiYmYfVFz0Kkm+wLrufTdUDPFD3tf7Io/KVuEz74nrs8ozModeU6zjjCtwGOZkwl3DTMS5Bg2NRyrBKnPABUzWyYYZHi/p4WM9KoJpMNIAWEN5vV/nsAYnE0xnaEwN/0mPrvTayT6qyIpTPS+UgVJmtk4NEJYM4eMeuKTezGWFTKPOljC40ar+4DyjIMtp5GDsTMPAf+Zn0o7tVsOg4WB6o2mE0jhLf/Xy0HPDuW1fkck8vS5zRdl36SHzP6mTSvu0gW5KnzQ6AKN0nTQs7GkABFbH0JQjefqxcz1zGXnPNBSGizkP0jvG562T6ybS14hF/zGosynr5iY4S8OsxjxlVOe9Y+J9YTNfVRqY01nEE980suT7Na+W46DhOD2mMmeTkTDSigavPPXQOqVtvjXYaFT70Y9+dDFE4gUEnOg36eGmEQ884q2Uxhvnu2OhcTjDSL3u8xkCCByOq23qwcXz8AbSaGBYMszNeazRFRi5z+mP5nvVs/PBk3d7ckK683kUeuex1JVTgS2fXylhlbmKRJADUnWRBRkiZafsP3a5RujshLuVAD5d29VR28tnunedlPneJExV4VLruhPJySvjNqeP1nIntgxWw4fWVSdo19/6u8J2KuRTYFYwEGDRi0rrdQ3tqguzQkDFVTdO3X/xJ95kImnc6N5fKSdVeXBc5QG6+FJ0u84FbIc7GZjCCwzMhKK219Fh9rl7xuTV7hoAF/QCr0qX6HyXe/AKjFompOQexiYWiIwPz/YYc3Y9iL13x0oDNnB0Me9+V/qewv/cEWdBoC3onAVJryrapT28xTxhb+UV9CzKxOdP59akOFdlatX+iuZP5nW+W9t9kvVj1X7lSalo1PmYRpiur96f2toZAyblfGpvevak39O6U+f4CU2txuYU3lvmTmdgWcHdtbcyrHX1rGSC/F/f3eFxtT6fwLKa5x3/XtFfPruqc4e3rh/TO93a4u9MyKziwdrAmsH6pWdErjO2O4XIrdbfbHuS03L9d22xuOngOqsCUT1kHqsoA6iwCFfmGMlwIxQ1cKwCqMEseWLmfOFbI4neGKnIGr5CMT8JBiHxqDGD/yYJ5neeEkXRMJFpDaAHDRzKqClHqRBaVHIr/03+YKljb5seioK8YKJgFeekxQxLyygADRQazui/eNHzKNeW9MigpNdWhvDYP0P8Keawgj6BW4eF9LagGImi54+KNkY7rpHHxrFU/qMNQ+c02GhcE1fccyPcUNE8oMr0Goy545xjACyMsYYi5eH0dtEbpuaEpfAeeXaEyT6bCFzPpgwT657VcGjYpm0m7fCtp5JzxhzE6R2TNKI8n/NFY6ceWPyW/9EmBjKNec4hjbwabsSj8yU98tKo5XeGw+px5dwRNum10i/39QTTmKXR0vQsics84U1a8JuS80m8C3PmnPrud797MSQDK+Fm0JE4sV96DGK01DPPsdFQxHN6xRluKa9KODKkOOdcrkN6OaE7GP7JdYzezAGiIhwLYObEQ412wKpx9UENS+lqaqnW9650gk4VLqayW3C7Z1QqdY+jpEKZC3Bt+1qF4URJWZVJwJv6XfE2CRrduysBfFKYJsE1YZ+Uvan+TmjMj66j7gi6YwHj0gKbyjOLEoKAOw8UFzsZfIeXTlju+rfCZTJOJiUWe2PXXYyZjCyKeQJLHa+TMZzGQ4GJ/nsSiIzJ/Fad0aIT4PNehwOFZt2ZKca261JahedsQ/dgPYDcKYHpwoTBUxqpO+WsU5BSCVC4kIknvaTwk+/SJ8ZJbydObNAoqNFPnmK7fDx62BxI0K3x8t/73vcufe36oZcTz+nyTNsy8Rwr7+mqzjvAzwLO4mWo53PPPXf3xS9+8T4GfVJinkWp/d3x1UkZ3tFsKhMuwvns1P4Onm69WsHSfU/97Prb4WHVZjVArPjY1L+JJ9bv1XO7a0+yXu76t3tnZyjo+Mj03km70zrZ1Vn5zzXt1LqmOqb5V5/txrqj5WldXPHlXV9yXFbvnNBChbWupyeyVqWTDj7G7oc//OFlw0ElxDWiblx0dXbwdv3s5LXavzo2ykoqFnpP5JrK+sF6wmZEPbnuMYqeEobAqTDlposyB/81FKnEu8HohovrYW52sSay3qJQ5QlV5rH0tCXDa8yjk0mWzZOCl7CpFjAquGHF2u/mknDrWWNuJ2REjVi8h0xrSWNNjmtd13zWNiqdISdgaEGWIoeUfTXvXRBhMAAAz5ZJREFUioqjsjJFecHNOOqgPzxnyBe/gZdPJjNOj6vqyaFBIeUu+q1MAz40gGmg1QCgEU4HAcPKKOYdsk/mlUE55h3oID19TI6toYFnGRuK8rJyl0ZXk1sbkUOfVPb1BFR2E6+OgW1lyF+eOuhGquG00pjzNE9Yy5Pwuk1b2/PbdnhGQ4WyqjBTD20jh9sv308jSRqz9AJzzD0RXhle2V7vHtvU0KPcq+eRdJxjVE+pzE1mDTyGmEmb6jrWoSxO0ZAmru2PfdSo5sayvFzYHL/Euzw/DXnmmjX30R//8R/fffOb37z79//+31/yFTF/nDN6FNnf//Jf/sslIXYaydU7bEfeIx05F7gvfoVLPUy60wCnATt5F7+BGX2HTeu/+lf/6o8Z097//vdf7mP85P2vfvWrP2bzebDk3Q76JFiuBGoHJhfqa4Qq28jvrh3v1wVei7EWWwncONapjx1sK8VgBd/u+dX7GdMpg3LBm4wntc5JYTuFdYX3mmei61snXCWjpA6P7zTESvdJ3q0nXjnRtYTLHMVHnoqROMg2uwW6wtjh0+JJZMDsEZB+cjfOEycqPqcxqfiucyaNG7SPUckYZZmH8fWetFLLjk4r7TAW9EPXaRicBlxjruv4ZF2OCYI5gq0x9e6uSEdpwEk8pMBJ6QxmLkJpSO6E/SzuDNmX9BSxrqwvx16BkmcVWo3Br8cNS6+eXMczvE8bMHpyPuQ77gYhJCo0mW+ANoiB1lMJRcfTR7q59qxLp+h1PKEKSqvrWW+uJ5TJkHbN2tI92ymenTJ+wltX/LPypEmZPl0vd+txfWZSdDs+NPVrtUbs+r6C/1p5o2tjKlO/5Rsn4XnXKOar/laYqhyyw+1EJ/V6/d3VfTImJ/BN8yXvdXLBtIas/u94RH1+Nw7T+LrJkGEB1UNp159raKfygo42KG6kZfgTcOk96266SbvruvjYxqU0gJk8u671Gi5Y51TSjEbwo8EojQkqdSh54MnTol37NRr423AbcKdBRO8QFWaf0UNC/AOfz2b4vcq4IYtuqiX+OzlDmUh6zrUuvT2kCcP7eQ7jTZ4Ile+4AZvypIZJSp6qptc09WC8y43EPA7dvmQC7Krr6YnmCcEY65SDHDcNjCrq4sbxB4fIPuLYY9A9tEXjogYCZUrD5qQLPYv8zzh7Tdqk2C+NXnpyafSkpHEKGMEZeoF903Cp51t6RmlM0EBgPbbtR8OH9KfBIqMjpFG/eS9DC2lbY50eURpQpL30HEyvI+nRnD0arpxjbug73hpRuOfpeRqjuC9u5E0a3qT/1M2TZvVacyNf464H3KgnaBRk3mci7pyThkXqgaqB2Ny3ttPlVtLArf5g2//rf/2vu09+8pMXuf1Nb3rTZcNZfix/I3frZz/72fs0Han7OLYahaRReaKhlebo0qNMvEnjjo9zQf7G+Ju6A73DMN1f/dVfveiSFMIaMYx97Wtfu/v93//9S2jcqaxzbFjqFrLT0i3mK4GkW0ivKZWZWY/xjhoAuGaoDAtI7uCcKAhVcLlGwJz6u8pxA9wwYSaJ9wwhEv6qbFc8PARsdaGoi10VHhOWqejaiguejIJ3M9wKY0THbHM8XCA0dHQLNb/TJdTJ1gm9O5hN8GcCvnxHwwMfj/bthIhT3CdcMlmYALHeCky5WwfudHlMZp9wrhTibl6CV0LGwK2hZi5q9UScTukGDhc1GSRz0gSE0LMLnkIE77m4mbeAa+4YdmF/CUNHj5X/CJttVXrp6MBTGDzpQkXUnYUqHJpTwJP1zM+g8JICsvBwDaZPn8Gbx82yGHFdg1J6Oz22okDp+OikeFJSgT9RHnf3dnB1MNQyrQPTXLkV7wmPNDTBXRX7+v7J+tX1Y1W/950Xle/m+7Wua40XlUedwH4r7iejQ13fJvg6GFdr76kM1Y3rbg5cOxdq3Y5vN7bTex2sO/ysxqqDKdvo6q/3O5rs6Kkb3xXs3VrWhRxXGuramuSjCT8ruqnwZK4Urrkmp0dIbpQ8duG0LeHUmyVzDqnwuYueOWNMpK5ymvmQ6kanB6Vksl0NLpkEOpV9T1z1ffGb3gSs4ypq1diokmwInsq0IX2eUJd0VNdBfytf1PmZIWNJG3pu0ybGJfNF1eS7yu4q7LavgUwjncY45S/qtn7kDz0rUgat3g0Ju8YEZHo3hjWGaCiRTh1Pi6eZaVxRydYAIOx6gbj5np7rwqB3msan9KhRqU+DDQWZG9pA9jLXK/UZ+pYeXdZDMQePxi3HSZjsY46nsJpfx3lhe85tYLDfetNoIJE3UMSFSbUzLFN8arxIQ5FzUWOoYYyGivIshkcKdemtl0m41eXcUKVODG/UYwij8xxcYcBUr3A8zZebnlmOmUY5DasaUI0ssI/JF5MuaribuMzE6xoy0zgrb/CZP3+BT2iABRfvfOc7L33VuMbBQBhqDLHUqJdGMcdD+kmDurzKU/mM5skxEw75ivYODFro2Rrh9UT8F//iX1yiIF772tdekneD63/8j//xxavKsVDPfVCPpVsF505QWi3Ep0LFSlCogiKDBIPVxTOPcZSxgLzJMPPQODkptQ8wNBh7jZGlTyjZHok+eVh0gtKt8GQdO+FyUsTyGSYWffNoxNzpycmW9fPNhHLxljHTd0+HMHTIpIDuXLnYaugAdzJuYfOTC3q2L1MTNmNha5xwwr5S3k7wn+3TDsycPioMVau8C27uNuTOmV46mX+s0oy7A9abu0jC09HCJLz7X5diPXgUILHyYzRRUNEoA31wggLzlWvQPeOGwJiL50RzCdeqn5nnS2HWQwDSIwtGi5HNhcsF0AXLev1W8BFOhUsKfad/5pmyDykQmxjRHdQ0iCffepo86aScGBDqvTomOccmRXelbFNqHqLKc7KeE8V8MjZkm7XOa9vY5T7ZGV1Ole68fzI+U7+7tbrre1d2+NkZONLw3PGdXdkZJKZ2VzB3z3V1ruCbDAmnME51nrQ7rem7ebOC56TtkzKN9Qq+Uzh286b2scOPO8QZwrJbh1Z98/0u9DWfzWt6gygjUlyPplyoTzouT1L0RqdoIHD9Ux5wbdeYpHKtfOfGHZ80AqSRyPAf5AVyIho+Qt/Nb6InhG1zz7ATFcrkO+oQtKtnPNc19qSXgOOl4QRZHtj1ZLfOavBT/rGkYcHnvZYhaXo/QAvIU2w+mtxaeThl0+y7incmPTb3JHKZIVV6NiD7eOKenicaCdNolpsmjo2eEyjdev7kaVp8qzQrn6fHipENwp7eScpWqXA7Rnry64GkDsg9++27yp96x6h3pEHCfFZu6kpznrSWKSMSx0nbjqHvVoOHz7p57vhlTjfly0xUbeihxhSNFSkzy7M0zHU0ZpsapuR5yO6EXZo0nmelBcIyyeGj8dV3qMvxZmPeea3HmQZNaC5zKeX8FF+ezKgnf+ZDtT31M2Vo9b3Et3NUOV4dm98eVJbeqvlOGggpGtI4vZmQMuiDdzEm8QzvkribZ7iWXnIU6cx5rC5ihIpzWd6ShsE0DmuoEw+GyppLDrybNoW68KD63d/93csz5j1Lh5vTDYmrDEsnivAkFK3qpNQQl2rgmd6r/6sS6z29A3QJTLc/kMuzKGo1LO6030+rpEKUSaph5DAMM7YzOekbk9h8WLcaMLp3rhXUT8fOvqVgJGPS/VI37lTqkwnoUuvuhK7fJtPWcmuCORZCDEvWpfVcpd4Y/swjlMnfE2Z3WWSWMnTblGF39HwrTSXDNI42EwXSnzRuJa6BF2aHxRomC4PBFRJGUmlfpi0jo4BrcJGGv6lPVRivO3PAoreVC7DJ+TTaWB/XzUukMOoiQZ8Z22o0OsGvY5ZJ8AyVhXaYV+yqgqNvfOMb9zsM9gdawyWbRRV4eA8+ooFXPPidu2Aa9XxO+krY+PAM85p6va4AU721HkqJe5LS0cW1PHylhK+U/smAVA0kneLY9ePkWkdrKwVuZZzqDBfd/RV+87lVKFfCVOs85U2dIlzr3cHo/2uMJSsauZb2rzH61FJ53Irucjx3fV3VWeudjDun8ybr2T03vXcCa9fn6VrtY70+ySZ1/k91Vbzlu9M8yzFU2VR5MyT+Na95zUVp4TRRFcdVG3l9wl/HWyp8Kfir2Hq9fh5zbajF8HmVuwwr0jCgXJKncrmxZA6V9AhKnpd4ADeeEsx6zTWUK5W39LLRQOEJZa7dmZxbg0GGQKlfKJumspgyLvViTPEUs2n800tU+ps2TDpeDJwal/BCQO7zkA/rooj3NFKohym3qVcAs+Fxeq4ot1GfuSXFqXCkgSyVXzeCkdd9RtlT7wzHV6OHirRGLmnAd/NkOT2caC/TiKSBzc1B5Dv6l0maNTopE3rKsN7mbjwqkzkG6XWVBqI0/tmORhP1hDxRrc51DSJ58p3eK6ZmcJNb3CqPJkxZp7wjc/0krUnHho05znyz2UuiZ/heerYwx6gT2lOHcyy5rqHNxOyeEO3cYn5Qv8Yl5WNxZz/gu+ZSS9kuDVGZHsWIGK4Bo8ZJ3jfHlzjxv+NkOKP0lB52abj/6Z/+6btXvOIVF08lxsVIDPqqzgi9YZDjHutFJhgX1/zOUD/0JUNH3exOvpeheak7aaikbfVgPhi3hA+a5ptUJc6B9KzTe/RBDUud4LASnlfXk0GqTOoeBwJNrJcMd4IlPSlysa7CjpbQTFqXmdQzbGinPHSCwUOWTsBxIoITvXC0fsvYMZbQJ9zs8ujK3TidKFC1v50wd1Imwcn+GVYlY+QeEzLD4BI+w4UyTl8rusfAc03GhbHCHQqZN7iDOSlIwNwo6e4IzmGaVVhMY0y1OnMfw0MaGTqB+FYackeK+pk/7sJRNGBkMj0+4AFXx1e/+tUXpgLMX/7yl+8XhDSGGHrpbpehXAgmGpg6Jf2UJhgDreYyaRdThZRkssBuPDH3dIXXNTsNV8Kyw608RO8/+suOJgIYCyYf6OE//af/dDEuSaP2ERybWF4YFHIqbjRQCpe5MFykwWkaL6tQomBN6TyUngYvepJyC398EuPCzjByqtTvjD+dwWYFy6Q4r547MXZM/ejqURjr1saO13dt1rW1e+5EMZ6eq33arTF1LDqcndDfDrd1jKZ703jkGKwMMBosdrCdwF/hmQwt17TV9bvj9zvarzg8KRPN1fZ3MKzoq/uuv32Ptdbchn5QhFjP+CCDpWyQcK1kgK6tUx6aMlG3s5xtXIv/p1XywA43AdNzXNnWsVVeQxYwDEeZMRPaqgCpvFPsM/pF5r7R80XZzdPJ5CuOo4YDlXc9I2ooU45xGqM0VgkDcgVyBpt6ddPUd+y3xoTKgycP1zpPkB2Qocn3Ap6RgzP/aHrHpPePbaWHi31105Tf5hPNcCNPe8uE5smr7acyU+aSsT4dAjwNMPVCDYx6kwifp7ulYUA8Js7MlaX8x3uZPkODEm0zvxl7cKiniO94ulieCpcb3SZ3Ft/STY5VGgXEV64ZfpvHs/IujW30lXnh6dSGGYp7cwprNMhoBmHXiGCpxqX0hqQNDYIYkHQIAI/007HTMcDcP7wv/ai/UAcysDqM71K/40KdGrcoepLBc4FFr0U3b2nLBPvmnJVfayhSh7A+x1N6Tq+gDCnL3F91Xv7cz/3c3bvf/e6LvsR/+pl9kAZpl41+kn3DC9U1M0m5uhjrDc9isEJfM9VKesoJs8a/TBqvfudhWNAyhwyJC8bBQ4TSO9NyalS6KXl3lpXA3N3Pa4bBGNrlBJcBZ3LB+j4fE+A5GbV+qvR1bTpIWuczFvsapf9WAfZJigTJxEmLZy42XjOxXMXfBONKWFy9fyJUnwqnLi4wEZmecfMwrPTsqIKRu3QKFwgNmfNIIYFx1+VSBqfQomsvbSvgCFfmSkrjC4XxINYag0TSIvBxzzjbEwPHCtdVqNYwASOgrzALxp57JlZ0PqSxyMSDfLvjZ16rhAF8UR/z08UJnPGeOwS6905hWCuFNYULmaHtGodePX4ymZ3GqLowdu2vjAS5ILN7QLK69773vfe7Ai4A8qeER0GGovusBj4FzxSSed7dDhh7xua7q5YCXIVboXTq46qvj1FuUSJPFOD6rL8TZ7v3bsXTyqBQhYtr6sv/VYnOduo7u7a6ObCDbTVf8v3TPq4MDSftTu8lvq+p66RU2jq5tzNgdPcTp9fCnM/v+O5D8IdUCisc0/+OlqsMUO93MO5o7vT6Nfxlqgd+zWYLnqxs5nmfdViBvir8u7Wo8q0c1xUvWJWTdk7relpFZdvQtuyrm43ydT56FLMeI+dlPkaVTTcYXUtViDzFSq92NpD0wlEmVB7Qc8PNLg0oKnCexqR8pWcLMqShY+Zdyo9ylt7O0BAKpZ5Lladl2FflE2mo7ug5DRDcpw/Iqmy6Imfroa8xL72FeD6TcdvHzMVE8T1kHcdHhVbFPY0YE29KhTvr4yOu9UxS3tQooNeSOT/FmzI+z5ubUtncceY3NEQbeq9oHKFeZWXawqODj7CJA41pfHi3jp/9TKNd9WTT+JNhao6F7diXPMmuek1KF5lXimc8zdDcs9KmuHCMnS+OX/IfroML/rspr+FWmR25Vj0rdfHUEaRz6UcaMbeSfdHLRyNLRoNo+KBO2tU4okOC+qDGSvEnLBqsM9dSGjR9LvMtpcdZGjLVAZK+f/7nf/7u7W9/+/3Jj/TDw3XkRybPdvPahPvmmUtdgm/qfN3rXnfRSzAI8QyGJmDDOC1tZ46tKpfatnRmeHDmsus2wJyjTy0Ubqc8TAthrUcLHEhykgq8bq5OjCp0ZBLfjNnVra6egpXePjI9Q1pMcOYgTwLaTuCdBIMnLVkP/YJA6bfueznQOUEnQfwUthOlfPfequ56X6WbGO7cidKCuhOgpRtpS4ORk53f4MwkyMYTq9jzjAunkzETPbrQeEypbYNvjEeMizsc0JfuslrLd/PhBLf1WeqlDa6Z0FqDE+1yr84fPbwIrdKolLG6Sc8a0zTAiWPD0qhH4SMX01V/8hmPPE2XZ9owd5Bj4Bw3fto4cg1rJv6z3luEcMbsDW94w9173vOey46AdACz//znP3/3H//jf7z3/sqxsK+Zt0s+Bv7lR2kUdSFLDyTvTcp7CmAr/nrCf59FWSnm3bMV3l0Il6WuO1N7ledU77b6TP098axOQbvFeDJdq3hMWCZDxg4XU7sn753gIevtDCZ1rl5DK7VM766MK/X91bN1Pp3WUetatT/Bt7tWedFUdyef7eDrrid/qrBXPEzjOLVR76lAXEsP/2977/Jz/XLc9T5x4KDzD0CMHF+yY8fxth3j2M7GJDZJCEqABAkGICYMUJgzQwyY8g/ADAmIQDDBEhcRcEJCINgb2/hub9s7vmwu8wOzk4Ozjz5L+/Pq6zpV3b2e93nfd6OzWlpaa/0u3dXV1dVV1VXVd4t2al2dvNr1qdbBuolRwk1RBXNTERAybTjQChenpdJWpbdr1rxnvS7UosLmeuvGXub2Sd3AE+3c1HLHXhlNuUB5JhVQPVn4bV4kvbw9mSnXnkzKyyePS1cu9HloAaXPI96Rj4AVeRZP59ws1WClhwFKpcmOJ5pdjfm0DqXRwc0rw30Mm0J2SiXZelX+hckN1vTQSkOHIWqm6+C+4Tb1pF2/q6eptJDGFb1sgFueoKyuTM81DQqORxoEkNvBMfUaVmWeIGUxE2DrCU8b5i61/fTmMA+sdKphSYNF0o3jbC6glKWlBftpn3PcM/ySokHN+/mMBtXMKatXD8YljXdGZyTNWZf4yXFJ2lOXdhyhXdNSYOzVwcE5l9FEKcNmm5nSQe8tvfSNlkiDW4azmSNNvVcjiZ5PenA5TtKrOVwzlCx15+yjcMp/hDflcu0Lb3jDGy5GSuaXxjbnnfSqQcvnsYUYYkp9GrC1gZgE3TQv5swCXuqkHfUT8WefpGFh5FNzRuXJ3JNMKF948FA4AVXhltg719uVsKXhyAH3udy1gFB1fawwaElOLwIHSWJLa2meOoFlU88LXcTwiEE46LydduUaIf6krAQbCAri84hBLdQ+5zhkqM5O4LhWsO/G9RolpHsmYYVJmeRNhlQNM5Og5bPG+OoSnTs+TmQt41rgO2ZnOxmOVOFwXJjowu29XFxWAvkOx1WIyGu0jfEC2rYvMk29ZXwH+MHvSy+9dMEPsbQsBMT3utPSjat16P7rbobM2kU8cZLvT+POe7hkAy/z2XwJzEXgp374gMZf4OCewgt9Ye52xrtTxTJh1mAGk6YdlIMvf/nLd5/73OcuO301TNb6DBH0SNGkIxeuFAyqMlPrq7/r2O+Ug2etPJwo4/X5k2tdSYG1zuMsK6PD9MyOL05K/47W8ncavnf1n/Lfqgzv3p+ePV2fTowIp8rvimauoaeEswsvW82l5P+rtX3qT1UIuzKNUW3zdA2d4DsZ/x0Odl5LE/3t2l29M83jrk91vE/LtKbu4DN1A7Kkh4Swdpmr0Bw2p/y6PtONTw2zWhkWpnpej0UvE+BXnlexzrwe0qOpDVzzTZKrp4GHuViUHaxP2VAvJA0oaZigpEeLip0eD16jfdrl3Xe84x2XDyGQbDCZf+dd73rX3b/6V//q7r//9/9+eVeYrUd5N406uani7wwj2/GQ5D/ISRhVPHlLRZK+o4OpoKdyrDEi5SLlSo1UafjVWKdBg6KRT1iqPOAn+1U91FORdfx8x2uetIb8pbwvPWn00sCg54eGAZ7V0MKzepEznowfsqD5Oxknc4umATPh5j1w6nPc13Dpc6nTpOFP2k76sA+Z3sL3qp5R5V83tqVd4DIFCLjKHLZ+km6M/nA+avzS+8d2wQ88D5pHl1A/Z3OWd/7Tf/pPj+axBuEMM03dLek4D+6RRiwZ3aAHnXzAkx49sU5+Qd0ajXheDyvf0+BCnTptmNxd3SO90qZ11c//9dpJa+JIxwR0BAo6m8nEjXQRf0a4qMcLF+3iqZRREDrDqL/psZdebdJTzte0l4ifNOyl7uu1083ey1w7euq1il1MU6GkIyDCQUorXyK8FonITOYy/zxZy/w0+b4eRybaTY8lCVgGkwsv9bPga7Ukv4yxm1yv8YOd8ndqVOGaVuHVu6t6JkEBPKPkUkxOnaE0EKwL1dTOysjRCbq7slIQqtA3/bZ07naTgNYJWE4yJyvFHQInky6AmchPZqNByjAyma2LUAdLCgWVWVbc5xis8LxSNKsQqgU8F9TER76jOzTzh6TT7gqm27N1mBjOOZmGVy3uK6VnRzvCjccXhhyZvjtQhBvAeI1Vp3iaBwYlrfY5dzsBvVN+c4wUEr7whS886i+LpbtUerglT0khUCFE4SDdnFnQmZOVL9Y5mLTR0c+Of1z73JMs1yjCta87Y0RXV1fvDr7TuicDQbe+rZ5dzef7wN/BUuupvHZV9zWwrPCWSvBJH+o6cQLjauwmw8MJ/Pc1UOxgqHy+uzf16dRok3Vf04duLaqwrvB5SrMrOKc+deOxa2vCdbe+dnKQ39UzNOtlLXj55Zcf7ULjlaIsbC6RVPSumUsdz5/W/by/kx9O8fAsirKy+VPAo3K+SpXrf4aEabxL+PVWSr2AovynnKOslAegWJfrd4YaqTdQMvyN51FE8WCjPuRxFHrkBkJcSN7LZvA/+2f/7Hu8YlTSNJJVZc7xqjB4X7lFI1w3jhpJVGrpZ54Oxm+Tb4uzVMTT4JTjxDXTByjDCYNyo55kdYwqf0oDQ+pM1chksR5zJ5kexLQofPQscrzFTXqvGZ2QbfCe+i3X0jNImNQXxIdwm9dGnGeOW57JfFbqvRlVYaqJxJfjrNdehiIKVxpZMu+TXjzSUHrxaNzRoJX8ynadd+mVQ8nTD5W7X3nllYtR5IUXXrh46hAChuyOPP2xj33sEW7SCy3ncho0dJbgo76RxjRxIL1ap4m7DWnMlCYa/81xpKdWOmBIu3mCnGMkv2Ceitc0xIkz8fLqq69ePFfZuCenmVEf6DgafjwYSFrTAKSnUoYapsOMnpqUPPmy0qNzPK9rRF55HVV9uuqTk13h3oYlJq5HQkoouQNgWEomP+uUa6+LQJGkMcnBNPY5O1uF+VT8KR6jzqceDS4DRCHFIGOOGa6bR+ZxFtkUlnLx6xTJVdkJE8ALgaP40hdPAKOYfCtdeDs4K8xV8OmUpsctO1g6ZfqaenMh1nPIpHKOiwudGfApxk+DU5M66p6aXkp6AXUw1mudwJpw5IL9EDheGSHq+DoPaoLAjl7AkS6T5iWbcD8JuBO8vmfbdbfQMLyMhU7XYYo7AllnrX8HgzhhzrDjjJHLBUu4ZOoVRy50GL/S8018ZRjfNKelC3mfrvaOkc/X/EorZeVU0XvSZeIpq+vTPHoS/GjC58R7pz5VGOu9lfJe79d2Kt1UQ0SHs90ztd36Xu3n1Ed/V2/PaYw6Q0J3rRuLKshNRoFOiVnhvsPH6bNZ6lqaeKj4qX2c6uzq767Xvtb+1LoThm78O/zn8x2N1zY7OWaijfp84rDW26053Vh0/d/B09FUhwPWBDxQ8LalpDKYn66PHZzTcyteeK0cNdHFQ/HT+5aU5VOB5JqKMiUTXydt8tF4YiiRY5TyuHNQpZv1mQ0fT66iuFmeeoNrszpPnhDFc55+hccGBiQPHjLkBRkF49Kv//qv/39oVh0EOdUNdA8HyY3QKitONF/pRlwY5uIpal43HE/jmjKYG4kaKzKUznfTsCY+jD4xzD+fT7jrRmz2gVI9VGofc03wtGcPf8JLhbAiDQF6sNkPZTrHU6OddMazGjhphzpp12cM+VMGNczM8L8Mc5PuPG08jRriwQTVmWNJebPzVuM954Jta1xRp9b4keFsmUPIvoArZVU30s1tVA1oGapWxwGa/8pXvnKp8+d//ucvThvUaX5ZDTZ5OI84rXRRvdzEmfilWI/3TBBP8dAf9RW9pHg3D9XRdsHvzOelHC7fUP8Az/Qzw9Mq/WYI4//8n//zYljCyEYxbQ91mPOKQ5TYlHjxxRcfpTQRJ2lYEq5qmMs57tiodwif3nLCp4He/krTyYurDJP8Mw8/exDDEsqTVm8nY7qupltaF1ZTEaGnE+8wsTLmT+ZevYgktExInKEm7ihQn6cHWJy06TZnnKwnRDiIVQioi3An4CVTrxbBU2G11lV/J+OVwCXIxG21nua7U3srJeVUwFkJjrtSn+mE3BNBTAZr0jTjpXnG3Q0TADKp00DKcywCCitar8E1eM5QqE54rfDLKIyDlWF5EoKMIpnshKuJJnb4TUZRFYbMJ5WM3frAl6Fquhq7MGR8buJkwkcHVx2/7J8LvcJlWuNpM8NgH6c4X3JxTmNQLvbd/M9QXPmfcDvOlR8kw06Bj8UHPHMP+nXnLU9VmQTLCb+vl5J0t1obdvdPeKm4qm1PfD2fyesdXU7vdHXWd7trE9+b/tc5vHt/Vbp+nuC38txuzVy9M7Xd9aE+V132J/7W1XcCw6oPJ+vbaq3K50/pYaprRWcTPur/qa/THMl7q7q76127VYCd+lfrnWhnqqPOl26Mun6u+FCmfzhd/yb8V+XkGhnrRGbr4Nj18WmVTDAMLBnukzvvubEF3HpfqFgavlJlmTRSpJFGHcO8mB6AoidT1pHheaZPMFTHUCw3dD0cht94LVCvbQifxdOL6RtGKfOomC+lbgDaZh3v6u2UnjjiKnOAqkzaH+uoHirViyV5beYXUie0XdsDL+qCKd8m3SU+6uZBzo80rmTfactIDY0X4Bw5So8Vx4hi4nVh0biU40MdPIPDAffwYkJvMEG4ciL31FfprxvZ6pWGWGUi+Trf1EOBE5ilTWk2E3L73YWBGfpknh3bSWOQRhb7ay5bDWMalwwXzDGv4Xd8NDJo0CICgtA3isY9Tp8GJrx1LMKdtJ3eR3yMStKLxygGQ8cMN+Rj/i03ZXk3w1/ttx/r89Q8rzv2jq0GGo1LeuFp9MkNI40v4v13f/d37z772c9eZHoOBOI+xiTmO4XfbE588pOfvHybh0zYnYtphM2wwORJqUskn6secI5j6pzZ506myjm60k/vbVhyR94BV/lLxs01j2XU5asrTkyUdYghmZz5kVCsaoZ9fxuWYnwzJeHQMlvDdWREhrfkcaOJcJ/NshM4s2+r+yuc7J6vgshK0doRQNfPTuA4ISSfv0ZIWSkWE1y7uqzPCW7i5HRnTKOk/ylegwkqIEjL0Av11J2srs8ySl1i9WbROOLOD/UhTJhD7FTYmwTJio9OaPUasACXRgyYWiZJT6Ot+ADejAc2hriGeN2ndLTgtbpjl8w78xmthO0JN3lNJl69DXd0bVilpxDK/D35zdNeaj3CAD5ZbNL4qFHTPFLQcXXLrv05VRqfVjnlS3XsK0+baOMaI8ZD4eSUxrpyosyucFYV8B3vzzlj+9cYLqZy33l+zfit2q7vTcaFk/GfDCAr3tH93vHknUGkqzNL7h4nnKfvT3B2RqLTsTl5V+F1unfaxrVw7dbP0zYnWFfy0e7/ru4dXCdyUcKW712TI+NpFdfd/Ahj7qSznuYhK76ngsq6WUNEfNeP71P0PvLEMWQc5L3Mp6LxxLXXvC3qLxoBNEbhtQSOUSZRpHkXY4P5GSl5JLiJrU3fkUfFC6cb9bzn6XF6geTan95NGnzUdZQ91ZmULTJ5szKr8mmG/adRJ+e0a4yyix7ahjU6ntO8qBt4uVEo3Vav/o6PaNhRHzUhuboduE1PFmGSptJAknoA+iFjqnHHzUxDofTuMY+RfLoaNXOs8r91ZTSDY8/1DGfSEypD1NKopIErw9ty7DSW2B4fwtU82ZCiXpyGlzqXcozSAGP/yQH0zW9+85HuxLuevsgYpeFSDzJLhnpqAJPm+K++rueQ81NYGTPznGqgTmOxbWSSdPEpLenZZr0anRx76MhoqNxkT+PY9702L/DY+vjHP36JhHjb2952ORgI2R5+8Fu/9VsXXDm/tXsYgeSY2nfpN41Ftb2cG9bBfyPDxDlFXdQ605DonJOPVGPmgxqWckdB5VKEOpAOQFo3HbBaABaEqnjpokcdKlOZxCwZi94Auim6W1EXgSrwSCjUT5I9mB/IZ2fBhWAnfFcrXsKXgmkncJ0u6rWuSaiY6puE7ccVWFbwZn2dIPbQpcNpp3hpuKmKawc7RSalx4g0v3vPNvhAj3jBaWzIsCgZsQYEmI4L1VRv7Xf2taO96VkK7cN8P/ShD10S7NEu84HFgI/hZXW+MU/Bh4tBhobdV1idaNsdPxeXNPrI+ChVUD6ZYyulrutLp4xWxU46QShkzMUpnxpCV5k/C7DJ+HX3lcfaPxfkXIT/dyidIj0pt/nOzkD20PxkopuO/yZ/P6lv4v0rPlnxM/V3ZVTq4E9D0wr2rq4O9t3Yreq4T+nm4jRuu9LxUa93dNtdm9qcDFQrBekEzrw2jUF9b3ct6+5ovcJe6Xlacyidh0Fts/s/4SnXudqvvL5aB7s2JhydPLNajzvcnvKQVZu70skEXV+ulUufRMnj4bO49lOUm5QFNBaYGDmND9UL3JJ4MAkvv9EzhMGkvCqkeoFoDDDMCG8M7rEucx+ZiHX8537u5x4dBISnN7lbkZs4HEVvIw0SFGQtdBDq81RqvT/M8YIciQFA7y3q5WMep3qSWM6bVI6VPzViKV/k++pb4lCdL5XMahjhnqFCenR4clX19M5Sw6CqwpryWBoY9MjK8XS8wDc49bl8n+f0Cjd5O+NXcwP7LHWh+L/xjW+8eJxwrDuFvqVuKazpZafHSXoeJazmPMpxyLxewKeRTOOChw3Zb1NDZGim45FGQb2zPKnatsx5xDU9/wwD0+gqzeT4adTQCcR70D9zA/xnknf6wGnLGOiYa+oTwKn3XBoBU8ZVdk6DKXXofSYcznv5iQavPB1S2IVfepY3aGBxjBIWeVHl2/7PMLXKU//H//gfd5/+9KfvvvjFL97963/9ry/9NeeStJF5kxgPN/w1HDoG/ta7Lo2xwqFRLHNNi1u97cxPZV8z6X3SaeIgI0Ye1LAkkTpxkilkg1X5mRYtESVzFNEiOSdHLSBKJdf41Mqo8pMDDnwwFJIvwjy4xkJAfR0T7ISh7jsZZOIgd2FOFvEqtHSLY/fcSX1TG7WshJFdHyZlqd5fCTr5eyXk7/rZ1VNh6K45frk4dbAm03X8mSMwUYw3uchkMnEZt4udyQ9X+FjhtKORqb88i7DCLoL5pNhV4xsjXBoxktZkdBXWab6slL6VYC7eWTw8+SXxSzHhpcnUK54eR1CutJF1p+uoTNeFCv4BTC50uvhPRqUUyNypxLDkDlinnCZMXX2dYvOsyjS3Ov5QPWtO653Kaf93z1Q6PcXpbg7UuhOW3Rie4qfitXt316dOUb8W/6s6Tuh1x/+nd1MW6OZL18/TvnTvV1xPME51Tbioc77DRccDJvyscDXhZJKBJppYyQ6rvk5w7Ma4K49DU127K/pfjW3S4VSyjU7uOeEnXZ334UNPu7g+ekAHvzOBr3JSDQNBkdUr3Pc09qSiTVEuUzFLgxTrtmkO0kNEeUclTo8C1njeR25TV6FOjEcYLf7iX/yLl7o+85nPXOrCOEGoS6V9dR/qMiTJZNopE+qFQX/RdZ577rmLsYNn0WEwZBkunyX1Hb7dcNcrKXNGKXPQD/Pz8L5GmNzkc8wcDxNm62mjoUYD2SQ7p/xcZbsa1pPGJdutcyq9S2o7jqnjp8FQLx8NA1mnRkZ0Q/TEN73pTXc/8AM/cHlXj6ic79KPuFXuTyOcRaMo+NUThWekY/GdtJhGHnGWxjjhUTeXbinpqcQzGrOYKymDanwypUylIR1HUp/lY+SQJ60pv1O8Ds3qLILxyVBJ7tfk3uJPXGrw0hCm3J3jL/wU9YI0hFajW3o/ptHEb8cradS65El1bUjj7quhy6RnpWl/pEHGxTkjz2HOESpHUR+r7SRdZz8Mv9QQnvqHMItT+az0n1Fm9i3TpeQJiw9mWMrjCUVcWs7sjEahREQtKeg5uasA2AlmXje2md0A2jSExHdkbB1Tsz5d0NwZyIUt4dgVkc6gepwgbadbKcSRCcZO6q3CVyc8Vvf47t3HKavxO1WypucnHNdxp+yEx2vG61oBc6KHTrDm2xA6J2GeZpCMKHcIquB/KsROnoHVmNH1GzdN3sW4xP/MWTThoFMqKlwVxpWyMBUFFGA0t1MarjWA5W5Ewt0pMFM5nSc8pyGbOe7xqYbsKgh0ebgqbMnLMhGoPMKFHH7kEcGrvnX4vmZ+PnSpi+upgjfxicTZ9G5tf/Vuwti1Ve/Xdldw7p5blcpfHqfs2j5dg6ZyCt9JHdPaNdHxjkfm9YkPrt6rdLB6PmGeeMkJrnbt1P4krKu2an9270/8Ot+d+PppX+q9U/zVNnf1d/cneaPjL7t1azeuO7nsRK7peF7X1wn26ffrpaisGdJTw4b4rTcBRXlJxcjQEVMeKFMZhuOz7szrLZTyk+2Yo8VNIYvKlDoDzyDj+Q51IAf82q/92iXPzC/8wi9cnv/yl798Mf6osKXcbvgLhd/UR8mIC94zNMkcSegYyJh4MeHphGGJU7n0fHd805hi//TEpw6e0yCEPKMxQw8Y8InsgfFDL3XHIj3IHA+9r9xoy3HMd/nOXJQW6TeNStJ1KtI5XpVv5IZcrVt8GPaTbdYwovQ+QiYjCTPhS+Di7W9/+8XAZAoE5FNTIegRUsMGM2xKg4YJ56Un9eD0bBMXhkVlkumU1fO386iGwlE8SR0YzEEM3NSb70uX4sC+ZC4e4eIbvBhOmrjOMDxTb+iFYzobDXtprEw9PPHKhzrEqe+lUcb/RkBRNOKYL8m5YJ80sCjj81569XBP46352ByvGqpYx+PV8PhzLjgWeinWlD3MO+ozXFWcJg3btrYWnmUc4A3YRRLHSZOZJ8y56Lc5dNNILS+iXp95UMOSR2Z7HHt6azhQIN8dg53gOi2e3TPZSYtGLPOPAJcEx6QxiVlauCn8hzjx2NDbiXoyLKnCN8GTcPE+nh94qzAIeXoVOyIsOLiwZv27ks9Ur5R0/z0RoE7b3D33OMrS4yj2J4JsVSJOlJQK4ySETwJlLoIuuMlcvG77uaPi/xPhsbYF40QYSeu5i4Lx2XXxpkA30CHtEA7qosACh5DShZ+eCvOUtPbn/K5jU4Xdel3hi37oViuDnsLwJgUocbtTiuqz2S/wjTDnEaHuPJAEfpXM1felhRTUWNThXZ4W4SKmZ6W7Yx0/6vD4elAcruVtlp3yfvrsSpk+bX/1zrW0M8GYdZ7y5mva6eZabf8Exl3bkyHipJ3Vmpq/d3Q/1bXjD4/DGxKu+4zfBHN3fQXXro5Vv3Z4nmSwjmevYM5nT9rp+pLPTfywwllh3MmcFSertbmDqb5f663Pdu/u4FvVPcE9zaH70u1DFT1/MpREw0N6JaTilvc0wOjxoMKWRW8G5QgNSKytFr0mUNDc4MnDSTSkKHvr7aFXj+Hv/+bf/JtLAmOu6U0knHpiUB/rvfKZRh1luDwp2/uG3SFzkJPRU3NJjszmILIJJ0VrYHOzK0NeVOKti/f0oqAAj2E6wK5hS31PuUWjnp4uPKMBLGXfVLwzrEZ6TKMHpfIZlelp3qTRI9/r5mnXps9Vr3jlzNyg1QMLmsGb5B3veMfFIMd98VzDMtP4Yp3iJPNkGRrmPEh4Mi+Y9TgG9iUNAr5rLina0SiSRhPpOj2A1J9zczPzKUsHOScMZ6MYYiot8Qw6MXPE0+KZW3rWaKSyL9WwLHzSTiZY93R6N+g1jtFXD8MR9xq37JPzWFx3XkjqMcCQeXjlEbQnHvWuyjXm98rJhxlqmobyKkdRF3OJfusNqLGthqYlnZsHl/lL3/N0yc4LqzPMia+cU/RVe4bj+qCGJZP4GqfqRHEwTM41ef1Mgk8t3QKdEz7f0bjkhM8s+RmOlvVAQDAETw2w0CcmAQw1T2GaYM46QTp1wnD4GMMrvBI6bcP8r014zHPJEJNhuch2sO5wfVKehfBRBbtOUe8EsBWsOwH09J2u/VwcHSuZUXraGLLphNfzxnpOhF0XEgyjHhfq4pOeg7jwmly71gvjUuDJ3AWZzHGHq/pbuGBs6anlzo4nTnS4rb9TCEir/DQuK8VqV05pm7kLj3CnqSb+rInPK60a7gaf0OWYMQIv8Bzwphsr18SXOMg5MCnZ9fezLitYVspo3p+U4U5x6upblTpG2f507aQ/XT+uqWfHw6qh4LTPJwaM03Jtv04MG129k8Jc+XAKhbW+ru3uf6fwd21WWLL9FW/qfnd11md2+J3Gr8NNN986Ou/gW43faj4mLF1fV3Ov9iWf6+rb4WcnL5zO+WmMJnx1NHhNG929Dg8VlqroTu89q+IuuJthKeNS3KxTmVY219NDhVKvDg1VrMl5uI9KOwYY2vEkKRNZA4MeN7TDemxIjXKV8KiEaYThOa57CApyl/BbF3DxHm0BZyYzZnPcA16M+DBBsMmE9ZDAeOUpeCq4yCUcXY5swea4J9RlhIQymv89fQ58VC8x8PaDP/iDF/gME8ywJPvFczWXJCU3wuoc68Lfqhzdea1VOTsNjTUkTAU85eLKy9J4U1Na+J1yaMJJTl5wQ94lkjIzbuAgT+2zHg0tNbyPj0YddQLngp7vjr36nnqFel8a8CzK9GnI8P3Mhey8So8h60qPKUPoLCnjSqvCDv1Bi+oCXEOnhk4Mg7OPPJen81m3RidKJvd2TDXweTiXsJqkW16g3m0b2gTS48p6c9x9xjmfeoi0Qp/wGKRu+Ig4cdy/W06jtw7h0uEkaS7Tawgr//MdjVka1TJpuwYpnoXXaPTWwMQ7fDLxt7hwDtnP9OT0naTVBzUsSewqijnhKGnh3S1ck6A2veMC4IBoTMlEXLm70QkLyagyMa7XYf4wWZnkJNR1ApqDkpPatsCZnlEQI0zJBSthm0rCIQFAOOxaSGwmNNsZl+5THkL4qMLOND7+3rVbmf8K1pUCtmtrEoanNjR0ymj5L2NLLxUTB+LpUuPQV4qe9IXXDIbRTGpo+y4a7EbBDPTcS1jTAp44SHfL2u6koFF0SQcmXSbpo/MVmDCemNSxLoQVt1XgWCm+wpbwdcpT1nuNIm3d7nRmewpvzu9cUBIO8MBixJjo7aQ7LfH7Gt6Sua/46MQzdkrg0yrdOKRwl9d3ymp3Pz1Qa1sTbmqb3f/6XLbjvQpjbWNVTsbktI6Tsd4p51XYzvZP5tGqD51SXXnxDs4VbUz96taSVR0nMHXwTf2eYFvhbIWvE1gqfndrSPd+vV/hqTukEx11dVU+Po3PtB6vZINdf7p6uufq745HTbQyyYpT+ys46vPX0NrJ+x2sz3KtML8qxXQUytAqVYnzPOhE5SjDfJSNc1OGwnWNOXqIeJ91G7nFiAvXeq5lzsPcsE5vJvuQp1grT5k/RY+p9LpwfeF9NpkM+xemVJqzLxqX6D9tssnoRjmyoTlo6xyusiLf4CrD8NV9wBfGJXQWckTpOU1RqaVvGp7qRj6fNG7IQ6pRRzpML4rqiZS/02PGa3XT3eey7/ZZ2TSv1dAlf1ufbaaMjfHwpZdeuvQd/OuhpkzuJnIaFqRV72mwU0YUt4lfcSItaFSoicEt0pljqUHDiB7oW3k28SV9S7fpnSeNZ6ikY2eoJTQKLUIvyLnIxLZDPw3ryrA76zA0Kz2a+G8/xUF62Jh/1f/C5OY2dG0SbL2lnPfOwzxZTvw6r9PTL3kQeKCfGG346LFUvfNeLQbPpP3Enzh07Gw350E6y2T0S+LQfnhinhEt4F0a0JDknHRT3HEXrky8roE7aeZBDUsS78o7ZlKArln8vW9xgdFbQGZVw+46JTSZQyoLurA5eFpv9SqaBJxap4MOLDn5tZym14bMJpNhSbgnxXZ5nxhfJrAMBNywU6H7633LiXC0E7JO27GcvjsJgh3MO7h2dLoSZFeF52CcCAkeIZ/GJCc3hkA+xjnvhLy8xhwwfE1BLHcl88QTE+d1uFsJ+53gP+HAhddEhPy3r+nuyn2NnzWMdqK7lWDcwZFuw/X5E7o+EbZ9zt0kXfE7paGGySZ/4VsjU+4WdTio45T8rOvrs1QUEpb7wJSCTq2jPlOfz2srxa/icmpngu0U7scpEyyruZkCx66s1ubud/d/V3fCNL0/KerXtLeDdeJx19DlijauxUttd/d7Z2A47fuqvol2Kl/Ld1dr8grux+FPE3+f7nf0NfGHCcaujx1cJ/zhZI3p6u1wO43FNevpqk9Pq5g7hsJ3etpkmIzwqyAiR6h8K2+Y35LCc3oVG+JWj9Wm6G2sjK5+YZ16d6eiZ7iKnjuZj8XrOXZuQumZYJ3CgaEiw3jw/lB+S2XXQ1ZU/j1pS49qn8MQlIYuSyqn9IHnMCDpWaPnh6H5GWaXR5YDB5tiiU/HsCZWrpv4yjxpGEkPHK9pmMnrOXaV9rOvKVell1SF1TKtp/4XxvSU4vONb3zjkn8JHEE3nvCb/UonCOHW8z2Pgrc97kGvOg44/jpXZBJlDRvWqZFGY6b18DE6gmfUgTN8L+dcxUMaXRInFtrLdA7p7GHYJLSUNON9568GXT1wnHN13XQOpO6k4QljkkY0jS3OR+deeih60qPeTxmtpLHP/vKf52mbZ6hHD0j5UJbfaw4eEleJX6+5QW2YZOLJ+a69IscjbSBp5JUmDIu0fzoVYDjnuuF2XQojacM81Kf2iqtOhatCxskiJVKrsJHuhZNyIEHq9qmlF0Q5CFrMrWunSOol4MkOmUgOAsvM6Dtc2JbhK1isPXI8iZjnTL6WO/d1Qle8Tcq3Fmja4hrf4ImdBRN33UdY2Alt9bnTNhL+HVPv+rsSwHaC5Ero7K7XRbiWSVBPWvCkQ2lWy7uTXitw9UzZlVw8KOkRlIKPC1guEJOguRNGu3fqeGiYzYSO6TKezNq5thK0d3DkIqOw5WkL7hK68FDS8NbB312v/01o6Q5AulyvlBaKgoA8TXd4x6kKRRUfnQJc+UO99jjK2+OWCbbTOT7h4aR0Y1nXlwmmFGC6Oib6qbyi8oYd/EnPK9qfnunw3fVzxX9X4zX1Z9W3iq/uvbq+VbgrjmpfTumi69P07jSXTsZwgm/X7sSTduvetI52PLXrW9dmLbU/9d2pb53sUmkg3+toot7vcDyVVTtdv1Y4WLVxMk7Z3nRvmr91vk9ju4K/kzVP19onXXIdFSaVSZVew3iA1dwjKth6EfuMOoJeE3ww2pBXMmX9zDdDnWk8Eueu93wy5EfFULnLE9w8GU0PBpVAPT3Se73L8+MJUYag0QdPjEsDRc2FwnvI/rwnTvCiyVyztpXhNhQ2pFW0gd8ExW6Yo9OgPJM7lvo1XGDQymTdWdLDRziVc9IjI+kwPTE0JmlMqXx4ktXyWvU2rnMsxzmNWrYvTNUTq8r6hitCY6Y70JCTkQvKjLyr94n1ZTJl6U15UYOk46MRViNDGhL0VpLGUv721HNPV7Pt9BhMfOlpVE/pq175FNqo+rShprSRidD1zJfGpAuNxc5B67Gv4ksvxcxX5NyifTe36S+6sHh1XmiIyZKeT8rojn2GBWZONOanfERvrLph/mpjSPV3TTjOdXEjfOoy0qd0kWG5Nbm3dOyp2jl2nsDH8/BF7mkYk5blV3q7iV+Nfnna4IMZlnaLUrfQyVxTudIqXhX3yjDcDTBheE4W66aYwHuCsS7QED3JtFX8KSDT2OT74IT2OcWKgkeRcdUOGgPN/XrC07SwT8I17zNh8FiiDRgDOGIRMtzK0/Ky/7v2unKtILJ75iGEuUnw756Z3t8JnVM5wYGTXBqvi12+n2OzazP/y3hzB0EGosuq1voTJS3x0s3pCmddyF1c9cBx8czf6VK5CrHo+j0peC46eAOZ2wmcKHjC/IWjK9fQMrBjkGYMTZruTmfuGHRFPmXcuTsHvr+DRXjEl89PQtZJfU+6JGwrOptoLr+z1P5mOymsPQT8+Ts3BCrcHUzd9akPeb1r/7RU3rbCbe3Dfdq9j0Ld9bGrJwWySkMV9mtwfFJWcO3eOX1v4mlZRze/VzDms1UJ6vB3Ct/p83XOd3O9g2FF99mHDr7a7+x7Vya4pnXvVKbpYKnjsdqo6vCR43atrLKD8/VSlGcyfUQqMmmQ0ajCf0+HUtnWI8KcIHp0YBhRDkhPAXPBVmWPgixhe9al8quhS7nC/KoatTQsqMhnnhu/U8kUHkpuUtEnUiV4Ci26SuY5Ue6gLfWLNEakl3ilF983KTi6ELgDp4YapkHHnFF8HJuEO2W4aYOFouyTHkh6AVlPbrTl/9w0rUa5bh1eyUb5bPIq36trT+1TfdZx5ttUKsiInqiXkQumYkla1xuPoseKHkUandR/9XjX80S8CZtGqOxHGoeEV7wnbtPQo+6Q+XbSUJa0ZBSFRl1TOzi+hvxRH/NTg7GeMrZr/9RjHReNndanvM1znhrnZrZheUYz8Txt6sGlfpb12L8MD9TAkjwjdS2dSRhnN/s1eL3ahG5Kh5X2nVPiwA/X0xBpPTW6IQ24OS/ryYfiUm866UePuDR08W1S9kyArmHqwUPhdoJAva5BCaZF7C+DwDV2D8w11J2KZZ010Zj3MwEXjDeP7pwE6vxvjCzMP2MfJ0V8hxe/Ycq4RVK32fC1EGP8QjGt7nIrAbj2w0kB8zJRlxbatAJrIJtwcK1gco1QMtXb0cxKWJp+T3XvBMBsd1XHqUK2a7sTpusCeDIGdbHUICH9OzdkPDIa45lXeKx1U2qs+uRVV+eTxkzmeJ4eoZFN4c9+axVPD6adApIw+4H+DQvUO8zdS4Wkbpela2camxT24F3MPU9K4J65o3JB6QQPT69Jt9Tq8dTBlgJI1ldzDXTj+SxLR/tV8KvP3afO7t707m7OTQrsSuHtFMkTvp7v7t7JNjtYpzlzgpPaxmr+nZaK6xU8KdzuYMnrnSJ+uhZ0bdQ14OSdFWzpkt49k/N26v+uva6fO9h29dSxqnhZzcEKxzSm07jWPqx4SNdGV2/F9WqOn479RGsruCd48vmONiqtr+qbYJ7afdblD//hP/w9m8J6T2RIv7l8gPlNb3rT5cPaxzHwyP4qq3opKBfodcF/1utMiKwniMqyMgm/qTPzIang6/3h+3lYkEorsLDpy7OkRDC0x/mtoYxS0wKkIUMZjvbwPEAhxPCjt7rwGoqvd4I5H4EtE4JTqDOTNfONbIZMQx3oaegs6Cka3kzzIezKl+b6EZZubuT8UK5Mg5owpCItnL5fvUAsWXd6s9Q2O+cFn/O9zFWasKTBM2G1jRriZ1uGNKYhCOOgOpk0rrKe+X6EzwgXQ7hMAyMtet+5kzlAMyG9Jx+mp1oajDQqaOxJo6fGU/UKca1nnu3SFrRpniVxwieNoeqqXHcOuBGux55RD46huoTGXIvXpEOfN0VO5kl2/oELjVGZumYyZkqLmV8rPe3MN22YWHpa1bUgjbm+k84z1Ysp8UtJONNbqcoZac9QP5HHUcyJhQ4jfeXYWhgrQwrTKHlajg1L0+K1EsYACIJ785vffDG0pBsXncB9M2M2a708o+XWTnucaI03XQmg9VrWP/Vl1++uUJ9uhzD6tL46ea4RCiZ8038MWG984xsv3lEUFU0MeIbarOo4Kbu+Twr4ffrlO6fw7YTJfO5EYMw6T5W3Si8d/J1Qd9rHWnSNRGBhnJMJuzDxgT5SOEhhdBLOnUd1Ryp3Tzpc+RuGTpseT5vGLop5A2xPD0EExlysdwJ3wpzCU3oFyS9yl69TArqyUlqs1x3CZNydt4x4BzeGRrrgKTTulEKFD3Md0GcTberq7kJ0Da96kuVkrnXKUzfGO16Rbea9rC/nwDWL4+75SpvX1F1hzvpW7U0wVaH+vqWbb9firdZ1UkcasE+MBVM7J9e7Z07nzyluV/VV40PHN7p1Z1ff9P4pvFOpc6mboxXGlYGlm6v1+q4Pk6x22reOvis/qr87WDu5dfrfKdwrHtCth9O9Ha9MGeD1VJAL9DoybEvFGlnCRL2s46x/yD2GtXAiF+9xT1kHpdI+e+ozbehBoQEI4wv1prdMHRMVNY1IhIPpgSEtmNwbOQbZ6S1vecuj0+gMs7MuiptLtpFKoQp4ejXwnLISMgRwYyQzNEqdg/fNJWNuHZ8zVC89J9Kgw/vgjfrf/e53X/IGYaDLPLamJDH9hpEY3Tqb65CfNCylF3ldO8VLGoWSttOD1XczrC3rzPqEoauz/vdZx6Rrr8oU9RrvaUAwtEqPfo1EGjZV9tMTzrxdhqpleBb1Ooa2DV2gC0qTejopZzJe6oji0X6mvJ4eNhoexUkacJyDmdrBE9vyRGwNr7zrRrfGT41ZysHpJZfGvkwnYn810HrCIqUmH8/xV0Z3LqchTSNieoMljdo2daWHkP3Mk6LTQ/HV12hDWOxTl6JEOd93xIn9T/is37ltyGjaSaRf9TnfSwcaxzYNs3p/uWFfD1rKvFMPGgrXlUnYcbLA2E00TKc8uQEF2QWhe58i01PxTSQkUU4wdQLK6vnp/kn/k5mmG2ztU/6/ViGUuGH8uLCyOwIRsPBItDB/FuW6Y3rffp32u/ZrVTphOmE9LSuc1j7s2ugUoU5hvI+Q1gmBp4pb3mfs8X5jbBUc9MzRGm4sc/Vo6fouM3E3LAUsaIm6jadPy36HExeujAPXoGSiuLTmc82EmglfV38n3Lso6rHkdRNj5ykLOQYneK7PJx7dwVEgmPDrOxqbzc9EwatRxp79rsU4aARqjPMKxVxnXNht9NSLHR09i7LCzaSMXlv/NGaUVQhb9z/L6fzs7q3erXyo4wnXtNXVfd9SBf3T9msfal8S/2lEmuq9Ft8TPPX3rpy0O+G4Kj+nsJ7CcMq/JppezZPs2+rdrHuavx29V+Wsa6ubm1N4a+3nRG8rnFVan+g32+ja3r03/d/dq+12Y9L1vz4/4bTD29MuyKkaL5TpVaBYIw0/4xqK80c+8pGLXMEm1re//e1HiqzJtlW4VLS4b/iHRg09CzRoKTdnKArPUZ9rq8YbcZYb2nqV0A7yOMmwzTHD5nnme1SpTWOX86AaSCg5VhoHzHVkrtn0gKJO6qF+vI882S6TIdd6VTKB9Y//8T9+6cunPvWpR4Y3vcszz4+6XNJU/s62so/iK9uvxps0ACVPzZAvn1PXSmVdGBznTkZI2PK9fD/rEQZpRRgSPo0zyrxGrFCkTevUkJc5fKTZNADmqYf2VTqy/7TBOPOOebLy0Bzz6DCfGNPMEZYhncrN6piZBzQ9mYwKMCm+Btw8ZS3rT8+gTJHhgVz8Bhcatqwnx8NE/M5hvRErjDyboXR6HWpgEbd56FF67SQ9ZAihRjLHWxjEk/qGc+UNsanu+46TnlsUcZN5t6QV2zMVUNJlGu9y/vF8HhCUObWkrZxv+a6OOo5tJvRPOnxww9JKMPFaXaR1jzMO0UkJ451K1g0i3IXAGOVkciA6A84KrlVbU59q6RbwTtBY1TUpOieF55lUxGCjXLKTwgLj7o6EVQWPDtb7wrB6d4eHCk9X58kzuVj5/I5GOwVmElqdmNKtAoYLfPV4mwTLqf1OMD2ZD/zHKMtCURfbGpK1EkoVwjxJgaIxOE8vdNfBna+p5HjISDGGiD+ZpgtOtpPvd7B28zTbU9BzXNyh6HB4onhNc9xrlf7yf71ueKouxxrfqlG8o03p0F0RT48wlxRjlyGP953HD1lOlbrp3UlJrMJw3uva7+6fKJr194rmVzxuem/qw6mCt1Jep+d2PL4q2af92PWhU5R2ba54+q7PFY6V4j3RSd6f1ofT0vVlBf8JrNN1FbKEe8XHunqntajCXsspvPX3CoYOX3XNn+SPScapfZ/gncasg7/y3ol3+DvX7Pp8B2/97mCYrnXP5GbINbT8JAoKpetgygJ5NDtrJhsrP/MzP3P3Uz/1U3df+MIXLhsqbK5q5PBEZDfK1Ak0+JgrKQ0grJ3IJ3gb6RlSPSPcEE+PAIxavAtMKGDoJ8o7PIMi/wf/4B+8hOp99atfvcCYngN8k1y7eml18yJDc5zX5qxEh0IGpF08mk0yTr16SGPo0iucMnmH8wGfn/jEJ+7e8Y53fM/zKQvWkDA+XehP5aeZYiHr0pjgM9P6kBuElS9nbpx8rzNGpRHKZ1K+SNznO9l+RtlkWCH/9fbgY50pO+sNo/xXw0A12tQ8YIyhMOgplHKhqR+gCeaCNImBiw90zgd688CrPMVN462GT64ZNmqermpcchyUtTWU2qfEb4bi8a76v5vC5k/jGT0U7as41tsvT3TL+u2LNOF45bxz89xnHUt5UPWOSvpN46HfCRdjbpqS775mwJK+6Sc8Q+NYzsX0/EsDn96ctMXcRIcwSkXDWuZfSt0tx0p4LNWoqvGN9jWSacBLw9JO/3vQULiV4OXkgFBMtifxszB0OWC6hVMrfSbO1fvBMJMTeFZltchPz07XTgSdWlYCQydkq5zCJDQKOCFcrKb2TpTshyjdOOza2gk8OzythOKT9pyITDZ3fLTIa9QBvxh2clE4LaeKbfd8LpjJvLrnT8ZUxq0rLMXwstw58ZnJWFMFCZm4u2kuPjJEiq7AKxqdlE6LcyCPC86dBL2sdjheXZ+upcCj8VFDtzspKcQBj7uYu1KFMndF0kCfi1YV2l4P5T6KaPe7vlOFwWwrn8m6d3BWmOrvqW+Uzvumq3t1r9Le7v8pn6t1rMo1dJN8aFdHXVdX8KlgTPXk/WmN3fVrhffu/sl7Xd+uMWKs4O3W/qlUA0T93fVl6nutb/Xeqt7OKFLv5bs7eXKCrT4/yTjdGKzo9iEL7ag0uPblBtWKV6Y8dy2Pq/W8ngpyvX0xxMw13HUOOeKtb33r3U/+5E/e/fAP//DlJDMMIChayGHppaS8kXliDEnK8HyNAuR4Qn7GQENRwTbpr+uvCimbuZ4KxXvCrkKHAvj1r3/9osybP8b0ACYFd4OJjXJlF5MpT6FaXkslVEVQLwngRWb10CDD17imDEFJY0v2F7n2a1/72gVOw/31qtbDyg3BmosmDWN5LY0wyZOyj52htZvfkyyXa5H1VTk1jVgU8a0uWXFu3WkESI+yhDv7IQ16z5P+Mo+XB/tkviNhSi8f4fM56jLHlrg1qsCxlRYcJ+ga+jNHl5EDegkKR3rJpJyqUSQ97qoHE8UE29BMzr30+EkvML0M08ijAStD2uoGtNEZwpbzOT1vHMf0gKy0qp4g3h1LDTQZ8pq6VqVZx0wPrv9VnA4y9E7jTI65bfI+xurnn3/+EuYLbzLMkJzU//bf/tu7l19++VG/queRuMyQPGlJL6o0FKcemXSc+WCtUz51or9cxuDuirISjqaFmg5xMoMIhmhhyibYOil2lnfcPaCIsHRR6xbfZCgy8VOh/3EW40kw9f+pMD+9C8PipDknEgsDBGhi7+n9hyyVEe/KCT5TEO0Utw4fvjcpF5MQW7+hEyYzXmC6l8ocDdmCjqE7Q9J8txMQdwp293zCPdXzEGMqg7Ne47iNldaSnc91dUwlrfvQqoKY81kXbRfqjpY6JckCvqF13WlTiMm8C8J57ZybeJr4cHcJWnn7299++Y9A+ZWvfOXuW9/61qNEhtYnzCuaqNfcwYH3ZdJBlZRMUpiLy+ul7BSgSXGeFPdJqfedpKPTcl9efC3vyzI9P9F+LZMR5lpYOmF6gqmDrZMHTvDSKf8Kq9373fNTfau5vsNN14+TZyb6neh7Khn6ld+r/nZr2+kc6NbOOodOcDu1N63Vq1IF+Kr4VTx3dSY9Wdc0tqt7tc6Kh+53fT55M54sP/IjP3IxiqDwf+c737nky8yw6Klv19JSpaPVnH1WxZCdHGs+bua5vvL98Y9//CLffvjDH754L7Hu4xWkHOZ6r0eHm8/oH3hr6BlhziDWUxV9T3dLJVOFWn3Bw36Ex1Am5UPWaJ5Bmec+7Wb+IxV+3sGohKLvgT4VBxoNko+kYt7RhPpQtgMc5mFFVlJBTOU8aQNc/s7v/M4jI5XRIhl2pqyoLJIeE+kRlEmP06DjtQxTSyNVtlf5kvNIXFVelQYR4a26IEUYHWt1xDSaTMX66vzROKCXjbRleCJ9z1xHwq6XnXXkGqChiGvK43oHcR9dWqNQ5kLVm0l6gBZ5zkO0uGee0MwPZEoVcaRRR6NZNdpoPE1jbdKTfRLP0p2egMJurjKNysq31COc4jDryJC9pAlpLaN3cvy1G6Q87rxTD8rncg7an4ye0pArvl4NbzfHPXEo/Yt36sZT8Gd/9mcvhxPYb/gD9b7nPe+5rB1/7+/9vYthPenCscpQNmlFXmA70r3RHfbLfpuIXIcK7S3wSr2xHtSwpFW7LqZVuEkLpcTNPQwgAJknNVVm0pVcDH2nHqXXCUISkeEixgua74RBm4S4FUzJ4HfPVngS5uzb9Gx9vuIDPEBkmUCQxWPlCVJhngTIk7ITUjph9wRvVaGo91awTu+e/ma3xkTJmRNHQ4JMgEXXI2W73ZTa75OyUw5WStyKjuozWX961nhdi7sMXobf4X5S9qxbfOVRuC5IGEw6vE1jX+uXqbNryUIrU8wdGZ/r5vaKziYFqvI26OCHfuiH7t7//vdfdlMR4shP8A//4T98tABkW0kvnfJZccpzzG92ShkHhF8FAV3pKcIC/fK7xow/7bLja5YqDJzUda1CeKqITTCd8JSuvUnhnWCv9yYazL52Cu6q3RV8KwW5g7O+M7XX1VH7Mq0Lq/5P+OpKXeOnuk/HeuKp3b1r+nIiD3TKVn1+gq9rpyoC3s/rk9ywWoe7dqZ2V/S4wuMK7/l+Pp9KYzfHa7+68VmNcYWBj57A8G/4M6FQGBdQItiJlr/XeqbS0XP3zO7aNfLekyiZDBdYVG5SIURmQDHG6PHSSy/d/ct/+S8v+OPwGpQx6vjSl770KBdknoJGcc11fdQbCeWJ3+REQl7IDVmV5dwYQ772GkVvZT1SVEIxLFEP46wRCk8m+sE91nP0ofTaTkNIyl7CnzSsDGL4TSZxTqOOBggTn/Ms/QSGlEWqbKLXiflaKepuhiDlhpa46OCdjA1Js5UGOnmtykTp3eXznaHJtrLt9A5LfpD6aOVNld/Wb+oAVyZXtx09gvTSSXkw4eOTRhXHQxk3eVZ6oejRYx7TzDdW+RdjhxHbHJ0UjTeZnoFiHiDnoXSvQaP2IQ2w6kriMKMfsh5D7tRBNAzns+LF501Qn88kvekY4D0NLplbKcdOY6CGF8NW02CsIcj+aFxKLy6N1XU9+260a8JzDXXSlLloyR8HX+MZxolNB+R7xgveA5/64Ac/eFkrzKErfBpGMxzQut2A1mFA2DVEZX/lK556baSJxr0HNyzROZhSnbiTQKB1FEWLdyF2kKV1byeIdQt5uiLmu50AwLO0i5UPw5IKp0noWKimUJnd/06oWZXs3+nA7IRlidYT6CT4arDbjdWqr6elU26mtleC0AksWY//6/18/xTfPKd7MpMqvW1kap5I6OI/4WCCZXqu63NdvFZw+y1jta46V7t5o7CQJ5xRjOF1wckE2yvcZp/hFyZ8dIHgOjiEbjMh+Em91YVb3OhuTsmdMZ+rdZ7QRqXn/Na19bnnnrvsPr/vfe+7fLugcR3jJMkwU0CoY9D97/ibhjLwhvAMX+M5cMi4sBChoBgmrOvqsyy7+bl6Z3p2d99nOuF1emZVz+p+Ny9X9dYxrYLq1FatoxrhTnCWQtSuX6s6TuBf1Zv3K31cW88kK+zobqKpbp5PcK3qP13faunooMJT174OjqneCTedPDM928G3gmGSWzoelzBO86are8cj6rXaRvb9GtloBWOFCZ6MwmBOHw9XQcGHb2PwQFnoZJudHLSbIylzndT7tEv2QYVNhUePC09cM7SL9f6VV1653Et5TcXH3CQoQ8ourIfqIxp/uI6Bx41ElWzqQKZmfXW9V2ln/U1ZRuVYrxTlRZU580zSvt4g/K7e1J2Ro3oTVXxRDPFT+VY51Djkxp4h9MgO4Id+GIqkDEUxDIZr9AGaNecNhXvm6ameU+npk6FSNWVD9SS0T3rlpBeb1ycvXd+fPBPFa9aR62HWn9e7fuU8quOicUBa1KBnmJphXYYkpeeU42d9bgxmSJV4zP4kfmiHsYKOHS/leetWxpf+zNNpCBf3zA2l/C8OM2xPODLUTbxk1IB9yPld1+pso4YW8q0OYhvpiVPbU/YVTnmJRbk4nQVs2/mdocpp2Kp0nMY+23a+vdpEYIiv6hFlXwl7g0/Im9gsz1BF2/vxH//xy8Z1eqqlkdX+pvONY2tf0ovKKAj4iBvzbn6gc2hsdOwePHm3iM+TDLIkwfCBwIkTxGKfkwjgYeZ6K3RK5fS7JsDTeymtliJQF1p2NZy4TmgTXWfyr07geZblVIhL18BT4eih+tkpyztBcPXMNaUTsr1e70+CdL7DR28PfkMnMKFM0uYugYy8C33b9XHX926sd0oSMJrsTfhhGjKGrl0XJN1fneMuoDJs8wmku+mqeN8dCAy45iqQ6UqzXUhqp8h4SoEGKvmQAlAusitPnWvorgpyVTkBFo7mxSUfPqPVn9xxL7744sWFdad4dbBJi9m2v11kFHi5BhwsSgjHLqRef1blVKHc3ZsE6spL0mBywsuvNRrk9YnndXTbjemq7qm+qe+1ZL8nfE4w+M4JPk5gqW1O9ZzAtLtW70kTU8jISinP8Z3wsYJnVefpvantFT6mNla0XnGxwmutczVX6/8Otk7OSwWljlFXf9f/Dt5aVuNf61jxkUrbHU9QFoVHu74qO/BNcmdTRdQ2V3i/Br4JP9esT0+6OGczrEQllt8Z7cA6aJ4aN6fcZVehRv8QxyhqKtiun3o38Z81G+OenguspchSKmc8i86CEUsFTAVNHmOOFcc9w1TSuKQ81o2b61iGiOX1Oh/Mu2i7elaIJxXiTArNN/2gv4YxKVt4wEjmchTfXPd0b/DhqXB1fnbzNg04GeJn/9PYk/JbyrcVR2lsyHbrmpt11GtJe9lewpXXO/5l/6SB9AjROGGfUtdMA5zeLho1KCkbZ27SVPLVTUzmrkHAEE+85Ey6nEYIjbQaC/PEw/TcEbZ0WPB9YdPTRVxkzir7nZ5YwpveMhTwls/Y/8S9bWpc0khT54yGOcfaPlQjVkb2GPHAvNAQ48l96lMZ9ZRj6CmP1v3dGPNJFhTP2iDYYPCatgpD/eRpzM/3vve9F72DEGCTq2eooR5GtX5Kl5s1PRz9Rg/mHWw0ni6fCb4f1LCUxG3pFlKvycwy9EMPIgYL5pVlJZwlQzAJWS42dF5DVU4QFhcZqjsLep8Ys1kZ/GqhftxyrSIzvZO4rgJIJ5B0dXYwPG6/nyTuLJ1it3pu+l+Lxpkq8JoUMeOIzfe1M4w+bv9WtJJCB8wQYcgYX11GgRGBSE/DZHL5cVdQQ1o+l27PKwG2UxSsW6ZX+9f1rQom4J4Fk7mcp7romu7xqXUsOkUy2zmhn5Vi5OIkHwHH//k//+fLiTXf/OY3L7AlPBN91PGcBKNs1/u68YIfd5qk2ddLKFzF3WpcurJSglYK2AquHR3ncxPtdIpuJ2R3Sl0d45OyU4Sz3/l9okTnO7ZVcVCf6d65Zm2b6sy6Kj4rTJNifNLnE1hXdHUNn+/60dXfXasK21T3xFc6HO3arXTZ0fA0bidtTWXFt0/qnHBQ31nxlO7dDver/6u2NAaYX9DTfnbr/g4nq9LN52vreFKlm6vVS4OCzK8sYp4gw3SUd7zONb2UlF1cjzXsqTCqozAeGmQ8LctUCMBgPiXg4D3f93qGo1A0fNk+egsyGkZEFcXsZw13yzLRBv/ts8nFKRo1vJdGJZVaDxxBJ9PrmW/kmPT+MnyG+xjHeE9lVcOf8HFNRd9rddMnDQDZl2qgkC66axU3FWduKnT3OjkkYaxe8d1YZP1p6NJDn5IhcBo5VOSNClCGdENQWsyQpGzLojFGvAgz7XMPfUAPPI2E0qttqQdrnLCkp473DemznznmGRbqvdT5dSaxbenPuauBh98aoKjbCCONLGnEzHkjvWXd6QWWzifST41m8BRJPsx5DK9pKK4412Drt7+lY0ql38x95PMa/SgmyhcnjlmG3FLwbNUb0b4Am56c6qk+L78Tt25u6BnoO/bLvHKZA1tcJX97UMNSFXAmoVlrF4umMcB0TgW9q2Mn1AmD1nbakDHyIamfIWHWKQOUwF18zO/SWRWvEYTuU65d0CfBMetbCSLXwvU45T51dP1aCe1VYN7B0SkkXZHpKyCkxZuiWye0gzdKDeN6EiVpeYLbOH4WEulXRobBgT4RgtrlM0olOfMhTfO7g6/CWq93/6drta+MA4KcwpxeQcmk4Sm4jXqCw0RLp3S2Up6FW96CIQm+Q54HGPFnP/vZC23IY6YwvBMFdcUnkk9lTgqKLtjPupzy9KTBVakCqvXlQtcpTStaXIWGdZ6s07MrmuloYMJLJ/R2z69wvTICTNe7slNuT+51/2v/uudXylUNU7i2PNQ7E82u8FP5286gkXVObez4RL23moO7fkxtpFxY68r/E51PfZ3q6a5N63xHc119J2vXqm8dnoSDtZV8e24CsM6yJusxU0NeVnU/Tqnj0PX3aRfaVwmiZCicxjfWWj2y08sCvKELZOQBz6gEITegfxACp3LFM6zRGRajZ45yk/lIDDNjzKiLevjowWRaBGVG3ue3eQ/VL/SG8Gh1lfRq0AA29ZW6NqWynp40piqgb7SrYi0OU/HVm8H29RLJMC9+gzPg1VCgbMx95B37nbQqHmo4XBqMdh7G/q/8wWsZzuZ18WZJ5wffE0/CZJtdiFvSZd6ra3rlexowMGBqqNC4lPmcMumzeqmeO+JZmvQZ15rOQ0ejDO+aYkKvJujWKAx0ceeOxh/nlrJ1ermlblyNfn6kiexH4qN6VSm7a1SipGErPZU0fGZIq/BkjqKki8zrBB/gGQ3KwqWhV5idK445cGZYMt8mGvf9zBlFSc+gHK9Xw4tLOV36UUdwPE2Sb84sN41tT2822hQ+x4b6rFs8i1ffMZWGXofprShNWJcnXmqwd0zSG+3BDEvVUulAZBHR7gCwePIMxiAHkuvVg0JLWBVCUnGX+LG4OXFFKPfM4+SEMB5azyWe0XUW19hMvDwpDU9y0Z2EsEkwz+dXAlknPDyp0sGza7fDbb02CcRVObtG8aq/6zsajtJSruugDAP6cYcxLfOrvuYCvHpuh7dOoJX58OF3CljMC+YAQgI7ZVrHp3YmRelEEVspj7X/0nguVF1dLiCelkERfoUHLfXmYjhVSq6dG5X2XJRxR8WNnlNU+K/3VO4CrJTP/EzwrRRVikJwJvLz6NdnVSZFtZYdbrp6Ky2lkHbtOF8D0+r9kzni89OznRLf4XDCywTrCW/xmVQupr5Na9DUzinfvgaHWe9q/VnV2fWhg3VqP2mxKkZ13V7VdbI2rK6t3q/jununG6cqk3Xjnv287xzZ0emKn091TWOU/yt+prq7ek7hNdwK3mx4iqc6ybtO8ZXwrtaJHW1dIz89yVLni7hQKc8EyHnSlUmz1SuQA9xs4j8y/x/9o3/0kv/Q/LBcRyn7jd/4jbvPf/7zjxRt9QwTA6NjGJL3h/7QH7ps3HEqE4Xx0wuE9oXfI+ZV6tOjRRmN/7yHnFDXrYlmrcPvupHixxAs5SBzVJmk3P6lLGu9bvibDFzYNU7x22Pq00BR503ScaXpDE1OuFMGciyrIYqSSYlTrhZvndFJOLrIlMpPEr6sI41jSa/V8Jd0VGH3usY3SoYn5innaZhLg57hSNV4kSFlerbwvEZG5wVjbF8yf5IwpvwsXs05xPtp/Bb3GSLle+kxpOxOW3gBMl9MdG+4WXfam4YYvWc0kqjX6I0k/NINRRrWwCyu0kCaCbydt46BTjH2JT3YNM4mPad+KP5/9zVjXc6NDHOrcwOYMHbriaQxKHkH/zFuw7/YSE8Y9EwUF/IuI7MwvlNSP+loFRyZWw4cpqEzk8U/uGFppSwlonwey5cnOsjkMOroWZS7EyBOo1BmMa8xtyYc47fE6aKTCyTvyQR14fTYRS38yeCsf9e/hyyVAWU/KUnUK+XB+6fWxBNl4+TdlRI3CV/XKG71/gnMu/YmAZ8PwgeTUGaTcafQDIZKTwbZCdLXKpK1jkkpyPfzo8tpTnzfo08wdneqTktd/Ls+1uenZ5zrxoCnu7oGsW7sHAOZaC4E7oTUmP0dnKv72d9O8BYm7xuPngJOXTyy5GKTgkAaoyZ4Embb0lCP8KyAe83pDU+iTHST91cGiu4d3XczeSQ0wA6yp2FWPpFjWHcmVwpkB9cE69T/7pnJ2NDVu1MMJ5gmOGrd9ZmO7uszO2V26keF5UTBn+Df9TX7sKKzrlTjQTf/V3Sxe363Rl4z3h2Mqzk1wd/Vv+Lj9fmss6OdKlOt8LeTS+qzHYyr+xNvrTLfNAcm3tT1N2FwncjEyBM83e+p3g62U1qa2n3aJQ0Afucx4+odKptvectbLnIYax5yfUZSqPggX/zlv/yXL6e0futb37p7+eWXL2vHj/7oj9594AMfuBy08bf/9t++eBh7upKKoQYMjTQq1+SLRY7CKIUOo2EwT8DS0JUGGw07HuzBJnue3KxckwaQxId1ZS4U36nGjpQ5pDc9E9SBNJ5lWBzFHD+G75lWwd8Y177xjW98zwFOSd+T92/Xn4R5erbyhKqM1zlaPVnrmpVzTnjr837XSJbOS9bn81mNGubF0UNHY460LJ0pxyoD16gJZTkPa6FNw5McY56D3k1YzzOOsZvJ0oq5he2PBlqeUWatOXe8prdKDeNzvmYSbXGj91MaATMZtYanupElXWrktB/OyRquKO717DE/mAbcWjIk0fbSWKpOkXmexIPjb5/tr5+6kf79r6VYyeelC9viP044X/7yly88yqT6prfgm/nH9U984hOP7CppOLOvtGVidttj7kMf8qj0cpOGhZl7boLQrnYV6eq0HBuW0hvIAagliUOruPHJ2QmJks567KqnJnBfAxSfVDgdCF0608qaSpmDzH3qZIHKU64qo1n16WmWyiiTuSaxJkHVdycl4CHKtXWePNsJyCtlZEd3HcwnsCjIcJKXiRwpJjM0kZv13McTqfZter+O+0SjWqtdIHJHK11u0wpeBe4dHKdjuOoHc49FjXkOHCm0wOiwwJs4MtvUcMK7lHSZdS7rztvBfYrvE6Uk69R4pMBQd5ZqfR2uDOsl5xzv0H92LTLZXtbTKRN8PNnGky91GU5Pr6ddJoW5KmedQtnRqDvQLLp8446PcgEtvetd77ooDigQlQ4o1TNuUuq6MsF08uzJ/M53VwaITqnt6u9otT7bKdH5PfGE7rnVPOnw1r17qgCf0lDCv8LPSbsTHa8U+NXYTvxgwukJbLv2a91de91cmDxKK9zd/W4Nrx4LK9448brumW59X9FvfbbDU9ePCb5K9xNeck2b+rYqq2d2Mk6lwdM2n0bJ485VtFXQPKAj8wdhpMHIg7LECUk/8RM/8ejZf/AP/sHdpz/96btf/MVfvCS55TfKGvdUkt785jffvf/977/783/+z18UKPIhqlhpGNAjwlwjKH2/+Zu/efeTP/mTFxhQsPiY2Fa5RC8NDQMqZ6xTrO0of1WnSTwo1ztW1fumyjJZh/hLpdv76lXgzM14Q930GEkPffHAh/4bCmTKAcenKu0dr0+Pn7yWPDj7nAbG6jmUm72+rwyW+Elvkm4OVOOWMkY1flWcd2t8NTqZyNnNRmUXQy8Nk7QOZWDbRtZVlrcN7jkHuJ8e+8wHZL80hGZuJ0+A45rRPnrPqNfwrkbc1KnTezANrhp6pfn03Km5mHMDOXMb8a0eIOy+q76ircBnK19PI5fGEnOvOp+oz0T80o7JzakvPZ8yiXmlH5/PDc7qyUUbuXHw+1/Ld2uorR/rk575hpf8u3/37y6yPKk1OOwB3UD6Bn+/+qu/eved73zne5Kip+eRtJhJ0CmMPzToiY68A37zEILkJXqYSXM65ThPHtSwpOJ3siitFH0BA2DcTF944YULEu20xE5Muq6XtpsTP+MpTZRXJ3+6wVWlbwXzrn+7hfxxSk5qFwrjy514DLqL2gRb/p+EnO7d+/RpJWSetDEJ7p2A2gn7K2VxUtI62KETkzimgJMMrtZ3SgsrQfjauvK+R9DLxISz4qVTTLPN0/ZOFR+f5WNycXM+yZxlcNTvzqHviWv5gacu6NJLv3kHvlSNMSsFdkX7HW4qbdX5mTsmJsYDNnhZ7hrUdtyF8PQaiu8k7HwysWP1huI3CymemBiqXAzq4QhPu3RK2Uoh91ouiBbomp3qX/qlX7rg7etf//pFQDdu3U0IFIWJb1Q46u8Ojmv72/2e+p/P1XdTQa3/63N5rQth6967pi8V/umZOrYV5tM6q/B+Uiqupv50Bosdr6j1rta5+l6l/w6Ga/nptWWag4nfrk+TrDS9O+F4wm+3Dk/36rXVGO9gmNro3u3W+ipjTs9O7U0bUpXWdnVfUyZ55/VSUmETVtZ8FTU9CHiGdY5185d/+ZcvCpgJblHC/sJf+AsX/OKR9JnPfObROuEmFkoZ4eso4j/2Yz929/zzz18MPqyfGpPMh0RxzUW++spXvnJZn5VjlDlUEBN+vUwM42FdAm4T9DoGnWeM864bsxqulbSYCl8aZaQ3w2B+4Ad+4Hu8O4AHuSVPflMZpm5+I6OghxkilO3n3Or4i/KLtN95I/mdMFeDTX3G9zIZuM+m4arTLRKvfPKUs2m9TXzXUL3kh/wHd8gpJuXX4GiKAhV/82EqI6vsq/A75olDjTGMCTTGaWIYDCnQsScepqc/7+mJppwKHaNDMh+YQxo/0pOuO+EtceScsf9pZFJmzeetO/HlXNNzX28jntMolvflCZmap8sHpXHX8FhPiqNoEDJySU+ynMu+m7hQH8wcZvAXdcYMM/t9r4XymbZHWBNHVRYEHkJ0X3nllctp9vAZ5Xu9NKsOWudPpgVRdzU0T1wkv8iwy5xrNcG5NNB5gD2WYen0uPEsTgwzrUPQIMd4Z7yV3vrWtz5SLiF2CZCJxoAxcCLOHDcOtIm9mEy6/FmE9RTeKjRMgsfu3rWlE3ZTeWVCEe4BbiwsjOyiuBOxEmquGa/ds6v7p+1Mgs01AtX07qpMwmRdfFz8TvOJTe2cPpfPV6a7gt93YFpYuZkzCFfuJGSSPF0j7zt+9xFyfQc4oFc9pqoHovO2o1d5AUw1T2mABxjaVxOf1pAn66ljUvuRuK1u3fV+xQnCGHyMfioUIEgSD11PV/BddzJ5h5IhvtkGPBPeSRv0mXornwOHLEbgSZdXkwE+i1KFtHo9/ydduyOHoKRxjMUWIQplAYUCHLEbzXVoCxwrIIubU1rulN4K604B7upeKb67daMKtdNaU3F3wrt3dN+V2qcqqGcdK+X+hCeelA4vJzx3h8dpfejaXZWOblZjVPtxAnc37vVap/B0Y9L1u3vnmvW960vW1RlXJvnrpB8rXNUy0cx96XOaU93/aV4n/V0jr+3gqrCseMCzKhnaw2/WL+X5PGlJJZ218Od//ufv3v72t19Cs9yQIuyNa3/tr/21ixcSHqysDRpjVILxbmUjm/94PvEfnOjBQdEjQ49wPaTJpYjczX3gydOuVOzS80fdBMOSngK5dqeXTNJIbprXsctE0HWMk57qHLMvePuiT+gRYl9MpcBmvzIFzyu7oYepIGebtV3xkDD5TuZJclw7eVecdrjJ9lLu6/hhNWKlx1PKHOI6les0zGT4WHpeZUmF20TtJod3Y9r2TPXCf34j82BIgLYN+8KYAG27UajnjaFVGj+M4NFg5alwyIoUTwzmmnA4nyiZ/4v6zRGmQSK9arKf4qwm56Yv1GP4Xhoj7b8GEKNCMpeXNKJnV9KKnl3ijueENU/Uk6ZsSz3a59PAonHJZ6QH+qAxyjDc9AiyDpPm59z4P1/z9hMWcZjOIvIc+5y6J3IsBu88YdGQ3MzRlZFLRoUAt15oGr5N7yI/TS/CDNf0VHDx4PxSd3ScHtSwtPL2qcWBFUis5MQ2Yxz5b//tv10AtfMwLCZUnmDAOx6fnguux6KDIE9Cgvi1GFquFYKmPpz08z6LcmdM6BQW++0OggRptni9Nk4FhU4Af1JCxareScDevbcS/rtFdifI795dKcUVnjqGJ2WnzEzPVVwxHzC2KAjAYFyMuKeHm33qBMxJSDntQ60nSy7iuVgp7MADqqeOdcrwZKxeqyGt7jAYz+z8yPCoqd+dktp9d32nTfgbAhnz1LA9EwgiyGH4S5dbje0upuBBj6ysm76wI+XCAA9wJ7fiV1d16OBZl0lp64wRFl1uMY6+853vvIw5eOMZcMXijWAPfsGXp/QoxLE7ne2vQlWv5XsJ/6RoTwpr19fpelWi81qnlFa67fq4MpZ2z61gX/GGCaZpXTsdmx2ed3y+wjxdr79XsNY+dcaCSfHq8NqVjhZqvdmXul7t6OGE/ieeN43p9E6Ft+56rtbkidZO+lif38G54wur9TL7sarnVFbraPtEVtjV2/HG0zqfRJEeWNtMb6ECWWFl3WOt/fCHP3xZ51DAkB1Y99ArCHFjg4fnVYbQDdic0YjBOuuJ1Z7gykaGp0e50ZXhW6lbUB9wsInDs24mZVi8Ch1rdXpiZ84W+1b/U1JGq7jKOTTxqOQJXlepBS/g64d+6IcehdhorAC3bN4AJ8YwCv0ATxqWqjfQtetgnUPC1fU5PZfEb53j4jANHukpk57lOad8JnFePciEKRX/1fpj1IAGHj6MvydyZVvSIt/gHFnGflIy95Hjxj31QA1K1A1N1ud9JkOxlJsN4zT8DF1b7yme47eGHevLsUgazP5rtMlwvaRvjUbIcxi8MlwtD99yU1QDB/1Tfk7aS7hyzPI69ekVZaifcjtFA6u/uacxSZoQRue1cOvcAuw5z//Aa15lPq+xLuGzLxqpMiLG3+lBJkzCaxvyRfskrYkvdSbTApl/K2nN+m1TI5kphJKvnabYODYsTQvqarHTyspOAjvOdFLPGxjzl770pYuLKYwd5o8CpRKhR04inI8ufSmc1GdqWQm7+cw15drnV++u6jJTOzjSA4UPxjhP3rOOSaCZFoHH6cOTKJPQmv93QtD03kq4nBSK/O7auQaO1XMn9UyCsDAqyMCcmUPMJz05WETyRLhVm9cKmbs+uvPhSQUprJkQHbhzN68uwN7LxSX7Yhy7uzMySuYN9btgTcJO0kFVDDqBJ5/LEyiSCcOAmaM8Y5633KFjMTJxY+aHy0UYY5UCRworFa5c2E/p7kmWae7UPlYhBXwR3sDuM6HQ5gXQQEd4A2sEOGCHD5yauBtFodJNLSm853O7+bDDZxWGa986/jIpvzset1rfOsPBal3o4J+unfKhrs2Jp3d9mODr8NPx+vq7u3Y6P6pCMrXTjfPO67FTUPK5VamK1WlZ4bfW2/2eFMlr+M3J+9O4Vpi6Zyoeu/ldefq05k9zqv7ulMxrcbGiMctkHD6Ri1b85VmuF6zbFDeWc9NEZSk9U5577rnL/xdffPHRRgpGENZh1vqf/umfvoRNs25q/DFcJzedePerX/3qJRSIyAn0EvMgUVTUWZ+FQ2+kTMWB7MIalUXl3BAoj/fu+IlrnyWVzvSWkY4Ns3JTTq8jxzAT8XZ8yueBj3VWw5I6BWutcgnGJDyhWV/5LXyZ2DnlkTQCZV+q4Sj7n8aK/J0GIfE9rSk5x6vRuuMX6T2U76bxpFv/NBxRz5TfVwOEsppGCOk6Q6Q0wCC3QmvIidBTJvn3WfFqom89lKBXZCLlT+rR80586X2jHM47tKMcTp/1MjKPrMaFahRxHDKJvPKq/XUe+xF3euUzN8175Iax/VYeNpTOsLccL0teT14vnNKROZ7Ai/loxZkyoTBqSDJ3q31PmDxBMT2UzG8qr/luhNdJ2ykbasPI68Lrb3Nm1b4Ikw4Ewi6fqXxEI1HyQenRaxaNx9KXXmVugmdI5IMYljomVa9P70lgOTG1rqEw5ETzGE8WBXYkakeq8pllWnSn/7Ufj7PAdkLYtXV2CwL9h6kzEfg42OAPS3eeiLQS2p90Oe3rJEjW+5OwNCkSU1t+Kr3keHUW3FUbUz93ykHte2WGU33dgtrBKeNx8cgFs9LHtTSxUspW48Dz0GcuEgo27v7JNFfztyo24s0dFz7mOBIHMkdz76SAat2JYz8KkR0Trcoj/Mq4eMMPTTjKIt+5jyoo5emXebCAAiQLsDHa6b5b+UTiLXcAn3XZ8YSq+Jk00KNy9QKjP1wnR4a8jx1q3c35kHS/44ErXtPBU5/p+FDH67s+rxS4HVwVN9P9TljPUsMSVry1w0fHm7t1syrwHVxTfV2fVzB2+J1wXedIN2ZTfas1aHW98qnuncp7Jhqa8LZSnk5kkQ7+icY6nKzq2sk+Hfwn8uQJzZ4+P+HQssJ/fW83B1fz5qT91bWJhk6fe9brhHKLeoIhJ17zf57aRIgbBg/kBwxEeLaqVLEm/Jk/82fuPvjBD17WVQxHeVAGMgLy9Ne+9rW7l1566fI+77LWoCDqHZ25kPjkaV4ZjqbCpkGGZ3nXjSM+hiXZ3443VPnUuZyhM26+GyruwR16E1UjTiqk2RZyBv3GuwsvJfrgaVLUSf3UiaGN+vPUsKwrDUEU+1A3/VMG72SXunZUmaz2S7zkfNOwYv/SaMS1PLlMY0/iLGmxesBYD/oW4ZP8ZkPfE8ZtF9pBb+W/JwGm14ltZdqD9KDjW8NRevxoTMzE3MqXhjJy31Pf9DShLTdwDcHTc0kZPHOYKcuaTkFc5unsaTgSr/bL/FxuIhtRo3HJTdjMAyRMhv5lSJcGNuXi9OzR06fSn55tXBM/qV+40W3YbRovmafAKRzSQCbLVj+wz6kDaFD8vRL+mPMuxzXniXSakQ2Z4Nv/maQ/k76bb1R4q2ehY56J33Ne5PokDaWXUobRPRHDUgovK+HYSZoE7JHY/GZiovAZS6hSRlHZykzyKyFpB3cVuCbB5pp6V/2u36d1d8KnEwSGJZ4kZPDJYqlF1ndO4H1IgeJx65sErPuMyaQIrhSBUyts1tctiNe8X+Ho7nfKx4mCUHfFTvC3EoqTQa3q6+pwZ41FWGFAASW9lFZj3QnufMvUzRmQbqUyVlzVzdVWPXqyb76bQm2nNNRxz9/mXMhFIxlxMnmNJ9bnHBa2PDFDQdajQiuOKu5WYWBPu9T5PN1TAOOau8SuAfyG/+Va4XiaxyAX2amNk3vXKJzTsxMdd/O6+z/B1rW9W9M6JbLrU50Xp8aBymdW4z2VFW/p4LoG17Webv6vyu6dTq6Y6Grisav719BJh/v87taDiSY6PEzXunGZ+jj1ZUVr05yrMmm91sFzn352MFwr79R3Vmv5NW2t5k1dx6b+Pcu1IhPNCieGDdZHcZQb0uYl5Bk3XNzUoQ7zL5rDlXWU51H0MQywTmCY+vVf//WL/kEdKLWGtJgwl/ZN6q0CpvzimqOiT9FQoAGMNZ52UV75pi7Xp1QuJ76S40a7wId3lwYG6jRdiBsyXZhanf/SBXig/+DIvmCgoN8Yk5CZUnHv4FzN//pOwkZJA056ClVDlP1PL6OJD1a5R2OTpXpH+U4+n5uA+Rx4xghHCCHPQX8Y58jnhSyiMg8OwaVJ0pUJxbFtGKKm44AhTBo9Mq8RY6VurKFFnGno0cBkPlVTMmTOJA0SGlcsGiyoR+OHCbT50L7yFe853wytsz/mFXJe6CWkwVjv84w6MsRL5xOegc6pL3MFaSjLsU+vqaQDcWbfk9fmPNAbSANwbuJKa3oouQmsR5UeWJmk3JDY/zuiQ2rbGnfkaxliJ066tVocZGSEdJBGs0wS7ke9wjatW++nLhRVQ5S4Wsk2j2VYqgO4E5ZcLECW8Zxc45sjQD/72c9eGJuMOK3EiajKHPM74eja914lqu7dlYC6EyIm4bripxMcpvryfQbY0y1gGO6GmBgZpas7prwr1whFp0rCrr5usTmtazUmHd4T151yNcFVr63gO1FIst5J8bpmLCaFq8NBJ8DW0rXdwWfuInPbaCReCaj1ngyv68+k8Ozq9B4LladpaH1XCE1XVZMVdoUFxTBcFxIEwTyFoRs32zDZorsgzEl3PawvBT0+8ESFDnc1E6+63Gtk5zpCX8W9wk8t1yo+D10mmlvND/kceaUQMAx1I38Shkk9u3jeOPzc4ZnKao2a5nF37xqcnirY/j/hBfdVAFdzva5P3Zre8a+6RlWFo4O15gWZYJzW6B0fr32r/ezg3pUTXj/BvYJzkp0qTN0u/wqGhPkErgk3FT8Jb1fviYzVXeva6N47WS9qO1PulgmW7tpKtpzgr/B1MmD3bl7byS67MsHY9fO+fOUhCm0rt7qGm4yYNZSiMo5hiHWA9RWPpC9+8YuPcIQMwH3Cu1g3/v7f//uX8f/RH/3Ry/PUi75B6o3f+I3fuPv0pz/9SGb2EBw3azEaGFKf6y1wmajXnCoqhXqZqJCp4GOo+sEf/MHLf6Izai5Jf9vPTNyd+pA5qFz3UBbZUCMROXVj4DBHjnLbpA8ot+D1i6eWOXZUQD0EgzX4zW9+80W/YF2m/smLO/tQc/FQOu8M+1t5R+VDHS/MUDlpqDMyJFxeEzY/ebKc16xP+Rdck/uRsTRvEvgBfx4y4nv8x8AJPdak1BpYwLl0ohFE7yGLHiuMi8YbjTKmCVA2dPz0aNLYpdFIL/xMziy9ih8NWN7TWGRIV9J7boryMdcldajvm//Y+Wtop/2WpqlHQw3ftKkMz3zMSIc0pChbdyFnGSJW6cuT55KOmKdu5mp043lgog+e2Mw1vcDUwc2rVZPU/14xpmr81pimUasalaoHkf3yOxOV181pcS2upKHMvVWNUckXhJuSnnPd/wcxLOkqaadz8na/c2BgTHgoMUDsFrAgwOTTopixwbmgXrOwds92sOZ3trUTYE/a7trIZ3Z1d0KbCxzEnLmWZFRYeM1HtSo74WaC5SFKh+O6iFzze1VyMk9KVcJyTan1TgJhV383Vyp8K0G7e7eWTknIeyscVvhkzCyQ0B3/oTNdgKsHUIXf/9nuKe1VmKf/MtcacsYzKWh5rbbpKRos0i648rjqRdTBppDhMxiW3IXiHt+dMYh3dA3mOfCaiyOFZzSaaXTJI1snhekh5+19yk5p7PivC7YJWcEhvwlXwFOprjt1Qdwp4xPddzg8xV8KVicK7PRu/t/N0V3pFNIVD+ngyn5U+Go7u7pW873jnVMfajvTuFVlZOLXE9xdm6uxmObhCS1060O3LlbYVmMy9aN7f+rvNfWt+tgpjKvnr4Uv/3f0UutTsPaesmcH8w6u6dkdzCeyxzXzv87VSd59WnLefYvrrjKHu/mGBnEPPYKT4D73uc/dvfDCC49Oi0X5RAbGmwQPfq5/4hOfuHjeEAJnXj48TPi4CaS8rLcOMLDm0pYhOx55nmE1FGGyZKiQ+owHaug9RXt6SeW6l2t+DSfzW28JnkUm0LgFvvCOIRQ8T9iz5Nj7Ld3zPuvru9/97kdGCYwCJjynMA7mXmIdVs+g3hp6Jryr9afygzxxLWEWzqxPGslcTjXsX2NDtkt9+WyFsRqdap4l5DRpCwMDOiwf8ActpQOEH56DJqFN75tEW8WfokdPletU/vNkOZV654bGEw90Yezy+Rx3+5J5OvVK4l4dPw/CoR09kfJkwzRsmJ5AeVe6lB41Omks0uNH3OtcYiid4wgN8rzGLT2yhNc2NfLKO9yUzbBaccozGnU0BjkXpHUM0W5ukteTfJ+Ghmm8yVxK5m2yzv8jNrk1GIl/jUJpHKOIg5pv1TGpHns5t/3OUMlKx659+a79N6da0oFjk8Y+DXgPaljSndNdhN2C7zOeWAWjpyMMkIm6tIDm8/X9rnSC125xzEXWwc9j9nIidsx4V3cnNNWBv1ZgyHq0hCeD0QKdRxuuYE4Yr1GCHresFpksVaGYFL7u/qRQdO+vxmGCqSpa2ea0cPo/362TvDK9Cst9lcxOYe36l8pYpYlMig2z5renoCDI5ImE09zdtZ/XVuPdzS0XNeBLF095i4tvCpG1Dt4zHt6Fj8XD/3kijO+kwAMOMIDoPsziZ54gvjtBkkIbvCcPSo9DBQrqcLcBAXVlPH4cWnkapY5h0h3FfiGYfOpTn3okNICDTkha9bPOVces4wn3nXMdH9spzR1/Trimubm7dg3ctY5ujVr1ddVeV+cEc8erK06790/XrRV8tV8Jb4eHWtfqma6tDgafr7uaHXz5XrfedH3L91Y8d8LLjiZX63itY4X3U3i7ervSwe2ai9cBHgYaJJBLa3LaCdb839Hj48DctZN88aS/XR2766+H4hpsMb9R5ioRfq6znv7jf/yPL/mBOAUOo8q3v/3ty9rLBhgeJSTlZmxZS/hWFsiTj+rYqavwHOusOWGrt4Lv5btpqNCbwzWfb+iNZ9/1rndd2sZAoyJpSZkiYVLWN7wJuSRzBJlLU2OB8GWp4f22oyGJD/gz8sGTe2kz89+i/1mXhrRKm9XIVOdGNQRVfFrnJIdnfqvKkzuPJn93a1MaHTqDmHhlUxWDg2GCGJU8iCbf42P/M9eR8mh6ySgrGv5Wxz+NSemtk15ZGi88pMZ6kr41xnFNb0DpQGOCuEgP+/T4UbZWV9Zo4z0NVJ6yqMFRj3w9k5I2nWvCCx70yAJv4pL6TDSu9356kxlBkbSVvNnnvebY6MWlx5xGMLzS/tyf+3MXQyKFfG3Mj3/6T//p3W/91m9dxl4jE+9paPF9Dcvf/1pqDXlOOs7oGOI8FlfqGhp7bMP/aTDKvMBuiItrdRjhyO86NzJvlbCn4UtdJHNpPahhSYtVukM6uGm5rsxXwpcg83pnVJoEmiwdY9oVCU4PBd1d9S5gAUoXuFMhfXpuEqpW/Vu1yXVwjzKKImw4HKVau1d1TQz7SZcT4cvn6rXTelI58Fmfr7uTJ8pJrWe6X+Gq1/1ofGDszLYvY0zX6lrPyZyo7a6Ug/pOVZT8Zn4wT3QRNUEciyxCRsZ7r3A3CdYrZXMnjINLYPOIYWHAJVwXawqLkvl4uvbdVaJ//HaHQcEy8ZO4TCZNG7iV64XEvfRWqnnifN+dqmpc4Lcn5elKLL6z/aQtr13Du55kWfGjlSLtDrX/J0V2RR+dgNrR4YlhYFL4drR7Ukf3O4XbTnmdjAC7+1P7E75OlOF8ZzXfJ5h2z1U4Kn7qM3VHburTxKd9pobs7fiw71zTtxR0J7xO107W9hWdd/VPY9jNoToXV/Bfs86u6pva7+5X/sJvjA4/8zM/c1nLUA7YHceAjdyX3rdZT/3dwVtxNJWVLNPxt66t3XtdmxXWbq15lsX2WYM9Pt0jsdOTxN8oeZ/85Cfv/vpf/+t3f+Nv/I1L6BvPGobOc+gb6imZ+LZbd3Idp2T+JJ7NNVpYuvFh3Ye2TOadG7164nKf0DINVdWzIGk7jTJ8a1hARlG+MM0I8lhV/FYeOV7jWfD0O7/zOxcPDY1VJobWuKRBJDfvhK0q80ljymETLxHODF9K2BKHabDKflpnbsr5XhrTqpzUGac645KGJfqO8cZE2HoiGZpIPans88FwJG8Br8rTynV6w6WjgEmgq9dV0gHfho5RPzxMI1F1kMicO+Iwv61b+V66V+ZkThnGph4gbDwvHuyPBpscO/tj7iE9eTROacjUmKYXkiGGhmA5Bzq5reZa6wzBtl3DMvkAG0bqX/zFX7x73/ved2n7C1/4wt3nP//5S10f/ehHL4bhX/mVX7l4+VmHhin7qLHq1aD56uElruVL0rqhhL6bOWP1RsqcTuJQeuZ957T8U88z6SvnocYr89l5LeecOOMZPbEe1LBkkjgbBXCITpdRicsY5Bz4SuwS2yQk5qDXa7WcKFDJBEGyrp1OFgow4hVwbSLnSWDI7/rcJDh0wkLe1whGWCE7bwyyCuzkcbXCx0MonydClX2rfZqE42vrrMJTxgjLNJLJVDhOy6S8TX3JNgxZdL7o8mnCOOaNO2UngnP+72BY0dEKTukiXTozebRGMfrBQlvbXwnC/u6UrAm+aX4ZokesOgs21wwVRdhiUWR3U4Nxpfc0MuvKK8N3IdjxnxTc4H0pJLhIpkFrUtJSMBKH8lMXmo6HXoOzp1lWCnzen96rRsB8vhNMHwcPnSKapbZbYTl9777wdu1O9Ux43vGsyj8rLDmW05h2fVjxgxW89dmKg46Xd/9re5130E65ruM2rdEdXZyM2ap06+B0rcK6aq+DK7+zrh1MFScrOq/rVgfnjia6dmo/aoEn49WaeWL4fsc73nFRDFEUPFm3tjPJVBMMJzi79v1aV9bR4e6U714r/zyJYl5DYDMcq5NzXBO5zrpISNzf+lt/62Is/CN/5I9cZHrkJ8LkyKFkGLxr50rmrXM6T4Sdxj9hU6bjvuFzKtjptYBB05xGnj6nnOC6l0pvwpX9oKjgcS1zTKZBohrJM9qBojIM7SPLabSiHvGXx6uzoW0S8vRqmOjQNrI/GfI4jUUajdLI1NWXJb15Op6ROM3ffrqxFu/wCT565GRupOqNI9yOsTg1ukQaUVeuhjXf972kA8czDVfKt26K5lhX2k5Ps5pOQD5p2hvg4wO8nnqYeZw0bvFMRiFp8LDP1K1RRNpyvGw312Y9r+xbehrWOUgd5kbTMFZTStj/6j0kXUu/eLSySY3egLGVXNDo2qwb4PrP/tk/e2nnb/7Nv3nRK1JWT7x/NzzM7HvODQ06wso1dcLkO+KM+3kKnsY/50Ue5uWYZBiitCUvEk51Jp/VKJZFfuKYnK4Zx4YlkXV56ff9vktIDAMhg6NBlDrjcGtuks5gs1tQH0IQy3sg1yS9EoRWV2M4K/FeU6qAZZtaiyfvjoSx9qPCAhFA+MBqNv0MSdqVTuG7b39X764E4NUzU507OkhaAS/EQ7NQgm8YA0bDlcv7qtSxpOTCOsHhu0xY6I6PzCAXSwqMm7qNcc/Fui6KwpEu0dm3Ckdd+Kc+Zh/86Kaq5Zzi4lIFtU6JyrnQtSfThDm6iJr4rwqE+Q6L33PPPXfBqYky+WbMWeQQ4nBbrrkQcjw1kmkkdxHUk3FSWmo/E/ed12aH69Wcs69VcKttr8bzceb0Q5VOmD+Zx10dJ8929ybF2nudAaA+29HvaV92yt7Uv7yeAvPuvcozdn3q1pmKl/rMNJe7PnS4WF2r73bC/q7eqXRjvaKPrL+uzSt+NtU9KTsTrF1fkyZ2/KkqUFN/T2Ga5vFqDtV1oKO9Cmf9ntrunq/9BU+sCYRImaPOXCEkPkbRx9s084ec0P5ED6s5Od2/T+lwfp+6r5WFHrqwfgODKTZSz1DWoaQHhDmRvvSlL13yn/zqr/7qpR7Kyy+/fJH19Hp1PDMcLJXO9HTJxNmGDlnUF7iXz5mMGZlBbxaNTNabJ3ch26EnqawKSxpQavJe61HRNkwfOOg3RjW8LXKDOT2XhD/7njKL+Xk8bU9c6IXC8/QRWYk2Mj2AMk/KxY5VKvYWZbGqpCa86XGe7+S1nE/Vu8v6U26sBjbfqfOyPm8aAo0t6rWpCyu3CnsNaRR28Ivhhmvm7dJAY1hbhUUZ2Dw+yvyMTR7s4vNpxBA36aUknOn9A72+8Y1vvBjaoS1z6tAGc0x9JNu2TfqQ3kriVyOnXm6ZEyrH0X5bt3KvIZnV2z/5gXMN2d355caB8zVpI/Egr5d2gZP1ADjwVGKzgfa1Z4BnDhz78R//8UcJ3J0HGaaWHkfffY2Xpb4njZgzzZxR/IbGNLRrPEpeMMkE/IcPmMuK981z5SaKfU+Dlyk40hMqaT/nKv8Z59NybFgyOzoNADwdQTFLxgJQMCZKEkUt911cO8HnGqESxEOEEqquacJPv/TKmgTaE2HQIuOnXtqAeRvyRBGGSbiv1yRKFyjKZAhbKR75uwpID1FO66z9rXheKV3d+xa90kxAyBhncuRr+6Cnm4urjI/x1BtqggkayNC3XPiy/hrvOyVi1AjDrhe0BT1hQNHYM+G3+599TMEjDUju0HDPvDfmSTvB5aRoiTPqZLF1R8QdDQQY8Dt5EPI+eEUxwNDKczBlBTmZaLdY21e9FfntcaMmU6xwdkqQ/xUmVkbjim/r6Or3f96npDCUi2wuAidwPOnS8eROAarP1Xl0wpNWyvpq3Gqbk4JV4Tnt7+r6BG+9Ps2dFby1Tz4/9aPWkXV3fHxqe3Wtzr2pHysYO9qY2j5dR7r1o6Oh+5aKR0v1TMjS4bej6co7pve69qc2O1yt5K0JT5080+GlvlfvTe3Wazs+Ab4NUfZkLnNauGNd4Ulam2S0CvcES51Tu7qmcs3cu+b+syyuVSo4lVeodKYHhp4+ru/ICiravJOnWLk+pwHJ+rs1t46fITYUvTGUud3cM1TEtdcw+tQz8pv3kE95zjCUNJzl74TPDUWTQFOQSTFY/NRP/dSlzxjW9ISgmAC9eipVelXWUwH1Y7+pD5hRqoHbUH1lJ+up3je2V0PUupOz7GMaeKtBUPmuruvpMZKGnU7Wqvit456GLT2D9DRSNjfvjOOsB0q37vIMerGOGMjQJoO3vjRaVsNqyn3Sv/of/zP0MvmXzzsPOp5mHlVOT1Q3lrbw3kHG/o//8T9+z4arzgyG36kD8cm5mm1mdFDSi3hwLglfGmStj/bVv/QG9L8pFKrXl3TMf2FKDzNzFDlGeOSx0YAHn15p6ux4MGHAfe9733v3X/7Lf3mko+k4kp583/caH0oeoGeWp8rl2Ekz2lakA41P0mVdqzWsGaYofl3vhEFYEz5xbG6tlCs643bOswczLDG50nLpJ70KZB5mZZ8MS5ZJ2M+yW3wnIbRrK4lcgsqTo0yCNblbTkpL9iX/w/RhJhoVGGxirWtummQmq77bRhcqkszsPorltUJOV5Lop3v+nt6vsHR1ToKV1/NkAHcsGQstzCeCtt+OoyFXLiTGtGLUyFCrSos8n67S0p3CgRNfhqf1fMqnw5zjhBHigAkFYzeFkwsQmHfhpZPyZdt1JytPNUl3ddxATSS/w2EKBvU+HxYu8Gv+pjzulPdqiILF/ALAYmx6wl/ncK3DPuWcoj+Mle7h9WjgboxTGNnRtb+rYlHHp9blwuSC4e6ErrOG/qWX1+uh7BTUTiE+UUazjql0CmK2m9dO1pj6e6XkdfB2sHZ8LuFOw+EKlyveuIOrvlfHoirvHc665/P6ThHucFp5+qpPq/6c0EjX1xW8OzqssFfe0dFOh+tOlunwftLXqS+rfnSwTHha1TvxuY7mV+tX12Ztu8o/3HP3W4ODa4ye95kQeAV3h5epdDztGhlrki8nGWkl9z6EbPekCrJZHqHOuPidBgTXdpUnvUc89lvjR+KnyjgW76WxI5Uq5TZkEza9fN/NO2Uf5ReeNewpT4VLDwnlKz+macixy7665ie8mWdFL23e/ZEf+ZG7P/Wn/tTdX/krf+XuH/2jf3T327/92xcDE8qxz9TiPEl86eWQ+FEvwQDGXEGxpq94iqVxqcOn7diXKhOmF0fKPpVPVO+rnN/Zdp705frZrScJa52bHT24iayMmHXnOKVyboE+kNeQ1fWuN8xMowr16XmUinvSvPMBWDK1R+InjXF5Pw15iWcKdWIsRL/BOwe9xBOS6Ssbt0R/eOqguUj1SHIM0/iReYSoR7oFduleOgamDPcSbvUm6oYu9fiybWhP45ZzS5ipIw3LFuHVUOUz6mSMFePk+GggNtUPfcO4Ck9Iw0sm8K5z6tXXxjQ9hdJjSJq0Hb2uTHiuB5J5ptJ4lonV+WioVqd0s144NYaKA8c/8ZShtDWUUaP2gxqWMgGug5Fxd3WgJk+arpwufpOw1dVX/6dbmINFcZKmS+F9Sp3ouo96qhaDxDfE60kMLlDJnGtdUzuTIjsJ7fcp1wolJ3B3dU5K5fTcBJ99z4lLgWkwDhhJVvClACJD4F2Mg7wvc8+FMZO+d0XmqnFRppCnnmRen2rwqONJPZxYwG4CCxXMI3fsdl5LFZcagk1QyHzIY0th3oSV5W5FPUmnG5MKfydkZx6sTBonP6FvmVgu+0Q/iX8GDyTERIjyNDYTae8M295zJ9KdbPrmEa7dnOyUqCr4T5b9TuGYnvdZPeZY9Ph4CmQmAMSwyCddkp91mZQgr3WKcRUq6/tdmRTfDpb6e1dn9/zK8NDRf72+UqaT7zDW7iSbBLSjxxRyK5wVH6drRp2zO+PFCU47uDp81Pq6Pkzj3F3f0V8H/67+6f5UV+1blWW6/q1498m6PPXpBHerMdnVs1rjp7qnOrq2prqnb/g6az8KFMoJCpSbCOw8s3ZUPGTd3ThVuFYwnco7td/12rS2Zl0db5na6Pr7tAuyB5uthpGlspUGBOWt9PJQSasbQBnClrvzyvzWX40D4sX1FmUbucgT2bhnnh1+G3aT8p8Ks+2pYNuebaSOVMcrYU4+qaKZ3i1ve9vb7v7En/gTj2QDDEx8Ixt9/OMfv+SKEQ9Zbxpr0uBlCFx6euuFZeheldcq/WTIT64jdUzSs2VFo5X2a70Vb3kt529+0oNLHNQ6vGdqBvQ5Tyw0l81kUMq+wmeQ1alXj3+NlOkZxn0NTRmWxLcGBMMhEw91vbaujIpwXCruTE6OfgNfBE6SVPMs/+nz888//8jTM/PDSgPOQWVm+ovO5EanhrGcHxkuqk5lug0Nmsw5r9OOOggyvni0uOnK854sJ/5zjtck9EmzeCTRV3Q67oMT+ZH5WGn761//+qM55FxMT8Y3lHDW9GCq40ABn4bT2n/1L8MS7Xs6IqTuYii3eV41sOapcPZb7y5hchzyd11D03j34DmWbAjgTeJmrK9Mnw7WZNKWE2HsRIm4pmS9Hv0JrOZZksGZo6VawxPuaxZjB4GFgA+EyckLH/zgBy/4+drXvnYhUI/TpnTGuI7B1t+PU1b9eBICx1TnSVuTsFWLzMBkhNJpVd4nJUS64ANz46O7pMzexbYmO0v4XCAUJGQc0poTXjfaTqGbYPU/tMWOAkwPhniCn3xGwxmWeJO78Y0grgCV7pi2XYV+68vvbGf6reejC2jN3TQpQOALpcBkg8wpDGDMb3bTNLCsFnwXPhmz7cvD6skcU1/y20XTnE3A4Ukxia/dPPBZhVzGmI+Jxim5g4EQ7C7Lqv6nUSZlpiuTALlSkCpdd7+7Z6qgtSo75Szv7eqrz6Ww220QQEMoDCSlRbgj1PU73/nOo/DTOr5VWOxgqnjuhMwdLqYyKc6npfK76f2kj5UnZFUoOr5Zr1VYJvrq2ulgnEoHWycn3Wd9P+H3J/Nw4rkrmvKZvFev1fq79iY4uvqm9rsxYa2ARxrKg/zKfGKtqB4AK7x0z528e/rOjm/vxqmj6w4f0ztPuzAGjEUWDTMZXpShNentX+UQ76cy2fHfji9QVOZU9PQq4T7rOnISvzGy8Jzh+hkOk0l3ka+EQ1nRdbuu1TlerledDoKsB96A5z3vec/lP/Iass8Xv/jFyzebbZxw9S/+xb+45ItJDx1xkh49eo7TL4qeVpT0LEKh1yBSdSVxkO/4e8J/jl/K1is6z2TPwlDD2/K9qjfVta9rp8LMWGlccLNHea+ux7Ve8WYInZtEGqYSZ9lH9YM8Qj5lUmFLD6X6u8rZGSVhPciNGi2RO1544YVLW3i9OabQMTIxz6sLqbtwLb2BmCPMHWQX5er0uqJUA4myd9IRH73ouKfnkl45dXNbrxrgq3mHU95KWJWlufbpT3/6oqMzD5hDtMOagaGW9xl7TolDb9e4PSXo/r5CA2k/qTxHmE3Fo1Ep55hyv7SbhnXxpJEbHPO8dMlv9Rr4VW6YOw/Mw5S8SiOXcAMj4/qghqUcJIBkMUBh0mhCMfZy8v7ZLXAPVSbBKD0wNPhoeaYvHu1dGf01sCZx6YrmJGK3zJ0FjRUIPMABTHkq3UqA6oSs+8I7wf+4Y7MSqh5amKp1ufDlIpLJ41btJbNmfGAmGj5kjFV42cGjESPhkHl6P/uXTKgKTjCdV1555bLL4O5J7qJNeOuKXnXmjpKxmWDQY0y7flblpxPW8loKJ7kgpAFa47T3xFmla/8DH4n2wAdzjfnL4gc+TjwQjXVXgPUa8zANvl2pi4jGak990Y2UOtiRJWRS/mI/aumuUY+Lm3H+uTini/O0+/d6K1WhTsGyo7NUiDsF1+uUWm9e69rM+13dKxqaYMkyKc0rZZTxJeQAmmbMGX/oCxqCH2Fo8lSS2ka2k4JqFeBXsJ8YS7r1qPaxq6OOZwd3bWNSDLtSx3nqQ9enk7kz8bfu/o4/nsBS1z7H0fG9dp2+5vkVjebvOrbdOlSfr7+zvSqDTAriRB+1fXiwa8W3v/3tRyeHsgvfebbu5mmOQwdX7U8dq/uO2cl7O550Kkc9rZIydyr7rmt6EJuDJT2906MnvQSSxzhWqahTbC/DQtzVN9xchY0CnahcIh/xbXoQFTV5N9/IVHnirzv9tpd5dNLo021+VNpyoxTPdfQIve6gbT4e7AOcH/rQhy5hTHrr17polzr+5J/8k3c/9mM/dvFyYtPbPuXmOO/SDp/c5Khw2qdch5T1pn75W4NWxxtynH02x9nnfD89Nnw3c08lDtLbpM7V3Ax2fK3Pflh3wmGYkSGShrFl4mx/V0OWkQwq+BToyFLDDoXB3+kNpt7ixnEaDPiGD0Kv0BMfaBvaRa6GbyJvmMOHepBLEie0wZwxV5Qe/+KGj5406j7q3T6fHk3Cm3ljucZ/51QeyqPTgKfiySukuaS1pEs/jikwI2P96T/9py+/0SUwkjEvqJPNvX/yT/7Jow18+VDqLDVn3+814Yl6YalzuHmcxmmNVv7ONC5ek096MmHm+GKMnLOG9pkuQz6YEWg5Z6W9XCvcMD8tx4Yli42pvOsGmgNVGc5uMatMZCU4Tu9WYTXzwtSJZMgQi4II3XkLXVucHLqn8Z+JSrt40qAs4CnCRGYB+MQnPnGxmKYy2wlYneDa4foEZ10fT3Gww82qntW7HS3k90kfXcxZMGF4MtWdMFXx7PuU9KqRyeVu1gRTukTKUGtitGRQurpOhedYCJjkCAvAxa4rTONEEah9NFSP6y6MXIOhUjCK6K20G5tOaDBWWs9GCmOjwcrjTBO3ztEa/pMw8DHEgb4rgLpYdR6TVWHgWd7NUxH0xqxCqu9UZZECzCzG7IajtGj8cSGFjiiMUz3Fo8Nrjo/4sz4XXndaKO5+5kJ1X771EGWlZCUPm+imwl4V10norO91eKgKe+VLtc6pb/V3LR1MnYdNbUthk7VCg7T52DiRhJMQP/WpT10+6eWYOK543PV1V/L9U0X6RLnt6u7aWME1PTvVW3lA8pxVmXBZ253gnuh1N0/reyvcT3zkxGuv8qTa1+5e19+T/kzzt/7vcNTVP/H5hJE5hYLELrqew64vExy1zqm9Hb/dyb3XyEO7MrV1n3n/NIqyMTwuD85xQ1Y5PkO/M/lvGoeqR3rd9MnkwIbUVc8clDHWcL4x0Jg+w3aRDTwll2vKLlVJVrFDx9DAkEaa9LCpY5JGj7zPNWUxYPzABz5waR9DD8Yj1gyjLlQg8UBBLuGZzIdrvcBBXZwI9va3v/0iW9JHUzzwjmkcTDFgCGCl4bpp1nmV1Xxm+c2nKuCOj9crH9ago2wpL0+6kA7ScJlGp3yv48nKitADzgE+zydxkfpmGtOU2ex7wlRhqDxPmvREy86LLfFokdarvMX1zLsFLIwptPMLv/ALl3o+97nPXfqKbM43nkuGDqOrUtzMrnl7+JiLWa+uuole07+Ir8zpk/K3+DPvkEa6nBv2Sa8ynkuc1VxB4ku68YCnj33sY3cvvvji3Tvf+c6LQYnxJVKAOfHv//2/v8jw2j1qFELyke+GY4M0zP+k0xwfeUSOfcKZdhbpR89Hi205Juodbpabl61u8uccE6akaXXENAA+EY+lTjDqBJPd4niyaO4W3fz2NxPRk7hM2OgkyMGrQsXjloRDRpJujExeBhh3O4xKTACT4aXr3koZqoxkEtBW/VkJalUA2Qmqk1C3anNVJni69ieYmTwwFWhAa26exteVWm8KI7mouRjznbH+FQa/dW2EDnxXhpGulFql09I/4ZHnECTYdcVAyWLn7lnXr0kJSGFAQ7FCEf/ZxTCJdWd4rXVWpc1dM7xtkmlB9wj4Lk4uAOJbj8h02axjLc5dLDJUb4Ivx8XrCkoKrcbTT56LnQIL0+WoUua0cd7p4urJdyZ6r8pdN2/9706Bu6cKM+A0dxw0hkEL6Wb9rMrE73fPrN5ZrSPd/8mQs2p74n+TAaFTRrs2O8W0W79clzDo8s3YsxHhbmHu1NV3E+aqsPp/4p+TkpPvrXBW667t1/onxWmCoxuPXf8muDvDQwdrba/DeS0nivsJvZy8u8JXB/MkK3T1rtpO+srnU3mb5k1X56TMneKyG8vud+6m1znS4WMni3TXE56VnJXXVutqPtMZsK7B89TGsyyGlAGLmyW5o5+8XNk9E+FmWFSHCxUj852aTFgFTNkbvoq8aL4ZZQo3wFx31SdUvvSiQqbJMBY3/VyjlQPS0GBOy+T7K1lFmcp+kQtHJZP1gjalZeQ2nmXjGrmkW6uog/5yGAzHyn/rW9+6rDfoJMgryJMYY91syxQn1RMjvcc6vuz/mgO049kdzftMleGlAZ/J+76f16sXb31WWvN3XmdsoZHMq5N1VrkuN4zTU8hP4tJx9be4NVF7RiQk3n1fOLxmviINMtWLy7HwNzm5CJmEXhhr9AuMi8isPmeUjZvqfNzUtF69pOxbGkSc02kMNOE272h0Nbw0caxukie3i3dxLN7Rr41cSIcSinJ+ekTmgUHwo6985SsXzz9yLjF38Aikr+AndaGKf9eYN8QmOd/Vm8hP2gjSQaFuiueJbpU+7b90YyhcHhDmieg+o+E5vThzHvrf5+Vd6mZPzGPpmkV3V9f07n0WykzUnAmvtLZCaCrKpwvyfQv1O/GccExMFFAYObDBuInXhHBxs5sMH8CYSaMlvsqE8/u+5b7C1er+iZC1e+dUWHVyskOjQMHzGDLqrvQkjHs9LdApfKbHW9bZCfl6rFEYc3PvUBcMmoWbia/BQc+e9FyqYwJ9s7tEHD3HhEILeDCwECQDq32pjJDvPK0hj+508ctTB6ax7YQhvqnT3T/bc7F0l8/TVPz2fWHolJeVkL4qVbDK0xwSZ52XVO2zRUMcBp08pcEYdHlNJjC0ja7Utlw0xZ1u1brgs6vEb+gcgdB+dUbGp1U6RT7vTcrXSvldGQJ89z4K+4nhoIPh2nUj29m1xbxBsPcUFJQWPS4Q/vmcGskrvN2aUftWYa68pLa1W78nXHXKTi2VXjr4OvqydDu8tV/Xwjn9XuGg69cpDk7anMbomvV4Gsvuuams5kcK1t38zX50ME3ySDc+tc7a/qqcrC+rdWhV/w7H2afpvR1OTsoJzT2NglzmseGeuktxDVXxcXNY4w0ljQ4rmoKPKocYXsy76APITMha/KYdFEm+3eFXXpLfup6ngqrngMehC6MyukYDNxdVjBNGn03vyTonlBvAmbKt4fwej86z9FG9A/nAECrf16jlxjZ1YUigPk9JfOMb3/hILsJjxZy6CVsqycJeSyeL1pJhXd1mf7aVnh+Vt6f8ppdMVfL5ZLqRunZkezkWqfAzjm7y1fCgNHhmeBd1ZmhXei5lWFJG2lA3H08+lua7NaPjrRoFbI86Mpm8/TIq45Of/OTlhGmuoZMwB9BZiV7QC58+mCha7ycjMTKPUoZyCTOwOI/TU0jjiik4rD/ng/pJjmXHk5kDpJVRbk7aq16Ntp2GPNvDToAhiXYJocZryTbFZdJq0u/vvaY32cf0YEu4jUYwIsFcrIkz37MvGeaXNCzNeLoc3+bOynxMyXeqQTRxzjd0kadt56FND25YqozidIHaCSPXCO2T4qLxxuPdUykGOTBOXf+q29muzd0CXt+HELCa0q5Z3zkWFGsq/1kc8GCCYWNU8vSrrEuCoU8wfP5D8FpiOwXhIUu3WF9b6phOdZ0ITpPg2AnTTAJ2ccAXRY+wa4XK9FiSScMYdRWdQgu8Bi3iVQTTrO7Y0CiLO3RCnVrkq8U65xswcBIatIRhiXpr8kvblu49yUEjUnpZuWunYOeJIO7qVWFnGrtubFzYkvFREp8m58uFMfMW5JidCPwVru5/J4xmG7XdXd0ei8rzjp+Lq7jMPvn+1J+sm3egD/mZY0Z90jbCMLmdeM/xm5LKP+2yWiM6JbF7pq41lW9P9UxtViG3U0Z2cK1KCqUd/8prnYAIv3jve997EegYS+PjEZrYhDg1Gq5wU0v1huhwUteDac2s/an9nNb6jo93fenqmepY1XnSztTHExzs+Mc19yt/nRSL7rvWW+Hunulgm/A+/Z7ar7y1G6MV3BNsK/4x4Xq3vtxH/lnJkis4VvS2quP0nWcdIt0VQ0r0gPD0LPGhksM9T51K5Tx33ZWJ04jAusn6yLce4chMfPQwxiijQcuE3RoBKn2I68yrUr11KJ5oJc5TF/FEK+WrDJXJPEQZukVxTQE2Q/hZ91Gk7T8yFfKIz9M3vE5S9qI+8IzxCHkFnHBdzwZgBz88p0FJ74cVXOK+8/rJ78RljnEacWr9NXSt5muqBrlcgzP3ZOVV4j/rSRhrm8rtynXCn8e613W/1ikMGZ7Vebnw2w1X6dD+5BjkXBH3fud8mHidhlvoUh0HmcNj76XPpFm97xI/wKmMKn7zeeEzrIqPCbk17mTS6cxDZn/sf+YjyjHnWnoLZnhqNXyKP41i6bQhDI4zvz0VTuNP9RTL9fG70W7+zoTn/qft1M1yXohLx1xDpl5M9tv76eXmwT4auatBLutOOtKIyO/Uw67RKe6dY8mBfohSmYzupVzP2GVLIiEZBR3XI0RPEZ7TMknBwOOOwski2wlCqz74HIQCgdMWk0VYvP7bv/3bj5KfoSCme6/98sQuFg/gprAIcIRoNUQ9KYFhV++u7TrhTtvs3umUpEkR1MJajTQnuPIZhRgZGcXxwmhlLHEHC3Ssh5rx9tKxOR54x+T30obGqnr0YzIBaAFmhHGSD/T0zW9+83vibZ1L7NT98A//8MUwCezsTBErbyw+37yfC4Qu33mCxVQ0hrnrkXMrhQXv5a5ANx7pIjwthCvFY0cv+azt1TLRVS3OU3co+CCc0T9px5MYwLuea6d8M/kFv02aqJcSeDdHmycgpqv+66FUJfc+CvdK6aq84lQ5yzIZgVb8ZaVA13drHUn7naALPMxX+AdeSiRTdWOhSzbc0XVen+7XPnT1dfNvpzjv8D8ZEiaFeaKd1dhMcEx9vmYNPaWJqZ36u/Kujg6vgfO0Lzu6qfcmxbDDdR3Tk3nfeSskDNNa29HNtHZ0/7s2Vs9O/VBZWD3zUDLStfU+Lo98UsVxBy4VVxUbQzYyoa2yHSVxbb/SU4T1EvkH2cQUA244YjCBpyJf47Wj4ad6iHRGAkN5qqHF9ZcCzObozJQKeqfbrxyflCfqfFHOSoPDb/7mb979pb/0ly5rP5uNyhfoDZ7i9Y1vfOORYUnlkH6/5S1vueAEWcK66Tsw69kCfMCrrJgKehotqsfR5FWTfel4Wo5rVdKtOw1Wes3kXE/cpWHP+4ZiJY/QsGJ7CXONDAHvmXga3Og4gBGvzjlTGUiDGWZk+xoY0ujgf42pSR+Vt1aDUhoZ7K/wqM8Ig33Xw4e+QU/c1xuJe1xXpuW6G8b21TylmXvZ+ahHot726jYm/vY3+ON/Rkykl41zjrahU97LPJO05YFc5hiCvn1GHU64+c+4aBNw/qbTRoaTqZtVT6U0XqaR6X+9ZjCkaIPIfLb+T30vZTvnhPBk3lbnueOUvDDbrrmgcr7lHANnhrxJN5mrlmelgyfqsfSQzzrQundiGTT20vA1mVutu2PMWSQmJ3ANSVmVSdDLe93z/jZZli6phCsxaVEU3WXwpIDq+WKsMx8WRyaJSiu4caG8Ftf3KSsB8XHbrELg7tlr2szF6tp6HL/cGXAhgQHWBM+1ME6erpAukT6bsciJB41Dk/GB+xiGoAmeFxYMTMlAFBaef/75i/GBAsOGkXoyovBAm8RYm2SbAt26a5FwVzxSH8KZYXQmOTTkNOO4fUcvDA1Q7grI0LoT3U7n6knZzd1OoZ6Ece7TV3MaJL0gKHuqBvdTAK5117bzGcYcYbjzbIGfmGhUw8ProXRzrApt1yi0nZI0tVmvTfXWdldK8CQk18V6pRDXZ7u6oR/m81e/+tXLf+iH9YKPQtsEQ4ffKoR2JZ+pdL6CucPnZGCY8J73pn5M9Sgc5/8VjXSwdm3dZy1d8acd7+qeq/TUySAn7+9ot6PZ6flVn1Y8daKROu+mZ+r9arzZ1VfpaprfHQw5Nzp6rXPntKxg6cruue7+NIcqrE9KbjwpuZkqHBkqls9YUpFO2SwT4yKXeJIqslH1NJGX8hvPUPSOmjNGOUpY5L3Jh1M5T4NL1q9HBv/VZTIsKvuVhpDEAe/TF9/hG32CVAh8PvrRj969+93vviQe9gQ7nmFTwtBBjQbIjsgmhra4kaiXtV5MynKZkkF5LfWtNBT5jNfSq2xa/3039bI0KHTzPOdOzvvEX8r/6a1SDTEZIlXbyk0njTXSUYZbGbaW4ULqm8jV6RVTQ7JSB8j3wLvpNio8ietubUg9IHM5+b5wp6eMBlMNjFx3s1QPPEr2kTpSdtfwIG7S6AFdGbqZXnrAqf6gISjbkS7NHZQn1CU+7Y99qIYb4dI4Y9iYqTicE9J40nUXmZK0Ucfx1aBR+6fTix6aSQPyMOet/dawlcZAbRimTUnZMb2jMql6hlLm3NAzSWOdRlMNWllHGmAf3LCUZbeQngi1yZxAPEqqE5ECI6RzKGeTEGSRSaZrl885qafcLSewXoMLidPBRlmAcLUAJ6FXlz4+eCHgqYRxggHPHZyu748D9+7dx23nRKnJ390itBM+V7TY0cwEU94H1y6wjhuKnqeFTIYBPoyXzFKGJ91lLiG+oXEEjmTWE/y8ixEomT40n55FzifmEuFyxsq6K+WpH2kNNyFfLrC5q9KV9J6iTeo2Dhp4gJV2tIZbF20h7GViPxeT9NSacPAQZaXsTwpKR5N8mNd4jDFnTZRI/53zU/Lzrs2pv7loOb5edyclT9V5lsrCNXPckoJi5c3X1L8ay26s8x2fqzB2LtQdDKtnVspnVTDhOSgEzkHGWCPsZHDu6p6Eza79CmP3bCfAdn2dePdkYOje3a3HE4/Y4WDq++56R7+r96dyCuOKH3T4vS8ctS+TMufvCa56b0dL9Zlax269r7BN9DLhelUm2Wqqa4J1J/eu+lLLavxP+3UC19Mu0pyKXBpoaohJp1hT8lk9FZCdkU/My5R1uGktP3UzxkM8Kr+nCEeNKvCaypcKsJ40yjrmV0LOE6Zaf55e7H0VYDeQlCVpi82HX/mVX7n75V/+5bsPfehDl9ytbBgSDUGfyJeDp7T4MvWCMFu/6RmU0Qi35oMMwylxeTBKroednF7X0fSeyaTnNeF26mzpdZT11XCmXJ/rmCSdVy+mpJk6vul5ZX8yTI2iYs+19OAhD48Hz6SnhwYR+88nk2unl34q+3nIwDRns+8pYwpb4mkyippjTNrXOKOxCHo1b5feSBmeZ35Y8wo5TuoE6uTcVx6uOE841QccA2FRx0kDn3MlN9U1yKQRRDxpvFEf4lnmJN59pqtIeplkwVyzkj79/4bXcKDu40ejUtJ8nlDp2HgvDwAwF5XtOF/T8KOzSr4v7u1XGqs0eMr/vGZ0iYnFhfF07XisULiHKhIXC4IMNF3GPOVLy3unLFDcEXDi6rWRRhwmUI2dFoZr+jgpP5NQkESdE6jC4QKjVdawKZiVsdmG1a0YzincrwchowpXO2F2J4DWeldtdeNn/eAZoSAZsbSTRqBKOzKVVP5tx2RqCh7UA81joIHGc0w72DSOsuALp4wiYaFtjwY1RNR5xvGzGEKko+xHrWfCj0zLT8Ji+/zH8JVhXOYb0sDrWOT7tf8TDKtxP72fi3unBE31JGy6yrpTmNd3xrlOqVr1Jds1z5KLlknSodFn7blUeWtHU5MBYRq/1bjW+lPgXOFQOFYw5PhNinLOi6lM71SYFP4qLdX38v1J0ZyMAZNi29VX21nhtOLgdLw6WqiwrfA60cYK59OzE+5O+jX1s9LHKZ9Zwbnq14o2uvp2OK84WdH7aq7V310fuvsdrUz0cm3dq3cqDB1fW71zUq6F6xpaWfHh+9T30CW9joQlFeQ6bt6ru/1+e7Jbhi3xX0/opB03ZZRfMil4yme2nSHmwl0T9KbiZj16SKmwVSODyp/Js/VQpl3kf+BXITXlgGEunF71d//u373IqaRdIDzus5/97MUwxGa88hiyAXWbf0nDTq4rGgEwRukBnbJl4tqx8bp5JXPT3mfEj0VF2OfS64LnM8rENrPOxHXC0cGWcngaYaqnR0dL3ZpnighKHnhD38E/eauIKACHJvjm/TyFy5K5hoTDU8oyJ6ewpIycMKXhS8NQ1um7nUeN9THeGh3ZDKagj3Ad/SQ9bQxnU38QT4lr4ZHO0yHCTXrb9iQz36/hZmk41gNK/TiNLmn4si4NVBkWqMGHd+grsnI1KknT9itxmIazpBsNP5T0UnTT1zxy8oI8xKlGvyR/SR3FxOeZm8mUOsmLpBF5S/LTTJguTtMjKkPgDE/O+h7UsHSNoFLf60qtQ9cuJiqLg0qonh9dh6pCoMcSRhjqAnHJFLXMpmGpY4IdnKfCaL02KQ+79uy/DF6XRSZCVcp3dd1H2HmoMgnBXemE7Q5/tZ6VoL3r++oZJhM0k3Xm5F8VaVHDCyXdNa1PY5WWYxetCc4UdvJaJ7hDP8BvqJrhbQgXuH+7gNT3Vr87mIy9tW8p+PHf0LgUGrMPaXyZxnilEHZwJXxTybonOpsUiSpg+jufq8/u+tLBO/WZ5+Bl8DoET4U6DXcIla+XcqpI7hSf07XEa1VpWb3XuTqfKnzXKoUd7+5gTNrqaK9T/nfrVcdjax/qtW6NrGPV9aWj/+757t4p366w1XerEH3CQ1KuWNHiqs7V2tRdv4a/TTyiwrSDrcP5Ct6JT3ZzuOvbjr+txr+j28l777Tt2u8ql63wOpXkO/VaDbepcFIy/KKD89pyjaz+LEp6IPk/5ZyOJvK+CpFKmHmI3F3nkJP3v//9FyUZ4wsH5eDx7aEhPGfoDzqDxieNLLarwqjCleFdKt0qtMKcxhtzFlmHnh3mk3Iz3fAdc6qaiNcDe6gHA5Eb78hzbDJ+7GMfu/zniHT6l6F2wINxgA9tmt5A7ygVbT7gSY+KTsa0vzlW9bdjVOdPGozyXnqopUdRtmU/6rouTNXQ6DU+1pFeHIb+SQOOTcKq8p9JlW0PA5+HKmGQ8WRllXBPgNbby9yIyQvSCCJceo9o5KgGtGpYzfsZvlSNZRqbNFRYlBnNteWBOl6X9jV4Qac8Z4hp5g11/E1w7YliGt/sW46Zc0H9xD4lbeTGdea8TS8g8WfduTknPqxPLyLmiB6E9QS59OirobbSR9K+79ned18bW096y3qrh149tc3xrNcN8XOMPXgpHRXsd85FjWF8axfxumNnP6R19dK6wfnghqUk0muEoNM6nVQSrhMfRDD4XW6JTkhSoXdQZS415Mx2s46p/kkYPlnsJyV1V1DGM9SId2H65NpIXHQCVxWQunun8D9u6RSWCe87mlopRJMw6r2dojUJsjKqvD4pNBaZB/RnQrRkTunyyLOe+pSnhnUCfIVvJVhTP/SiG6Meb86P3LHp+jC1W+/7TBrLtIYrwHRzN9tLb6Gp3W7sp7JSglbPrebGShGc6K6+v5pvdSx27SgQsTsGr9C4ZAieRww/y1Lh7hS0qsTt5nHWfTL3a5snsE74rmVSQBOmjv9PfZ/gXz2X9a3m824uZx9SwHpcHl1xUOGp836a5934dWtAh4/HkVXqGtLNzRP+kXXVPky8ZcVjJlzUtqb17Vq6Wa0N09ya5sJU125+Vr664hldu/XZFT/eyQXT2rvC50oeO1mnvD8ZnzrYVzjd3X8ahfarx7B9U1YSxvSG4Bm9HExiK17QF9AjPvCBD9z91b/6Vy85iKif6xyp/s//+T9/dACOXgAYAcjJpGeTRgKNLG4wqlyrqOsJkfzBMVKh1JPYuswPg0e56QnM8cK3EQt6JOtpkd4N5FfUa4Nr3/rWty7Pkag70xqYoBijEu2ZQoFnNX5QrIuS3hPKmTlOOQfSIOQ4VSU9DQUdv0uPjGqs8j2fs1TYKi0Lk+PqOIgvc1aJi0xXoLeJuOB5aIWNWI0q1KfMyyae4W8U5WwjBWyzevNLNxpLNO6pp3b8p57gld9plKuGbPFuW5UH6l1l/zVsmTsq+6KHDO9mzmLqyMTcFPRX20pPGXHuHNZYIo3n+MoHKOpSaTTVc8cxyxCz9N4xhyzfHqzjuGQEShr08pN0JV2ndyLvZqjb/xM0VeUReYrONFyruZbTuGgd5rEyvFI8p9E2Q04zHxr1ZL41jXbiyL7n/Eu86JDwoIalbhG8T6nvakFEMSJGFUKUAEEcg6+CTNktqN3ifyrk1esrQT5/r4SQ/H2iIFgPBIA7rLGvqzjHSdjdlZ0Qc3p9V9epUtbVu6o/70+l1tMJzbvx6+5PY5ntMOlZ6JmQfDSepps19I2xcEpOX9tb4aLCzmKHSzR1GWbKNwskSb+TaZzQ51QU7tId0wSQ1/RjUmRP+lv7vvrvtdN+nj430UcuLN0iU3lOpxB188WFxgTu7pxKW8+qdPDX0tHaiv5WfHka78qn836H/0mJ7OrezZUdzdZx7PjIKY5WfLnWN+G2448Vzq7ujjfWdzpBuINjguGk7PBR4ZroodaVv6snSvfMqh8dHirMKzhWa/spjzxdL7s6p3k99ePaOXIf3l/n8W4NOV1/pnrus3bs5veu5HM7o1KWfHbVn2dZgMkNt27TN0v14OAbOQMji6fuGnqGnPORj3zkciKuHuG8Sx6in/u5n7u8j3FJpQp5WxkJwwEGHWDCaKAsp66SyqJ94JPeE6mIprLtKVS0w3WTGauoqxCqWFavAgr94x71cB35EZlOhb+G63gyHTIo3+bVceNe7w09OLLNarBIHpD0letY5e8+W9/NfllPKsJ1blfekx4e+SwfDUAowm9729suvw35MWolDRaMvZ5u6a0h7eihpPGNNsChhrwMM9MgSX2esJbhRTVcLWnFMLga1dCtBXzSKy69SdKjruIrjQfWl2GMetzoKUQ/0c9NreFpgtIiJQ1EFMM9nTOeHK0RyBO1c/yT9it/8L6eVP7W6KWnorTvfErvOuic8aBwX4OvXmPO8TSeVhoVP/Y9vX2s67ubU62lM+lU43J6DOUc6d5PnqE3mQbFxGHCrsFNDz15gafW228N2enhZp63JxIK1/2/ZnFKJpCTCQZJ3heOwEw3VoiXZHSZ56YTdHfw3mcBrzBn253SVhXHVb1JtJOiICOqCXnronbaj9rWSki9T53TvUnpqLialI363lT3buycwHqAgVcW0WQECVeFe8L5JEin+6xJ27XWM6EdY5h0PXntdEwSD/U9hSWFpze96U2PQvPIr5SGpQr/pERW3NYdpkw+mSGEib9ugZzanOZGtj/RRX1+wt3u3k6ZqHB3dSacXT25A2Id6enVjbHP+pzC0DW086TKBEOnuHU0UetxHu941qTE1Wc6WFe8qnu/8oaOf1V4rlFM69zawbTiz7X9hD+Fl7xex2pqewXX6XMVrhVNZJ8q3pMn7OZB1z/r3r0zrVUTbXV96WhlqudxSreOTW1VPOzwUvn3bg2f6lrx+92cWsHW9b+DvcLf8f6JP9SwnGtkqoqTbm3s4Fy9V/vWyaT3hfFJFfmcvKgmF64eM75jKBnGA8KRMBoh57AOEv6PpxKhYYaN6WnEgSa/9Eu/dPFcwjCAnIbiTB2GyWTICs+k7K+8aO6kVMYN/1HJxZijdwKKGac8Ez6Fl7EHr2RqDjcdNfho3Ej5gA/XTC+ALKf3VdKEMmd6gvDbsCcPfaHf9AVdi83sDEnq6CbDg3L90IMj6auGX3W5aSp9Ji14r8u91OV0sk5wzWnIHkvvcfHUiwcTG3EYDTWoOV4aKzQ6ZD4b8GRooid+6/FltIH6q0aVevpXZyTN8TbXT+q7dc3Ia+IiQ0K5Vj2Tcjwz90+GH9quBgrpGh2FOUBCfGnLE970zJFO06NKHQt9x/vCrLyacGVy75qXVsOZ8yDDGhkDjTOZ/N75ZdiphkHGm/ku7HygBxxY1LfTmJV0a9tVD9fxI2nx94qBKr/1JLRPfIxMyncqv0vvTq/bZ8Pikl/mPPS6fEq49ZTLQw7qpoSGryly7EFOhVsJn7VUJpJxr/424Z7WRBPhMvH56Fq4Uj4nGFewdc92BOBio9trxiD7XBUEdov37l6H44qDxykTfPep/1Sx6d5b1beqtxMcO8HPCYvwwYLisZmMH7s8JNlzx+FEgartd4zbkjsSMlKZbQrkOd6n+O8E+Spsm5zy5ZdfvggM9B3GTb/TQ6rWVXHf0bWMSsu/1nNx4KLT4UxcdcpBN2+nnczHUcBOaCv/p1BVx8zS7Sx19SW+xRmLjK7xmZcqT9CodSaj7+j+WZYT5eVavtEplfnsxM/qYm9d+cyu3IeP5Tur9+v9nGMna2xXVw0j6GCuCnOn3HYwdrBOz051neBkgn/1zrQu1Ge6EIoJnmvx38F5zdjl8xWmiU92c6Dyn2vXlo7ndDDV9ypcE4y1X90cngTz7E8aHGq9qz5O1zp87/q7Gpda6vWT+TPVN82/bswfSnZ8yJKeFamIub6ll4XKpLKDqSJQLN/+9rff/ezP/uzdH/tjf+wi57COkk/pP/yH/3AJF8cowDOekIuixHqLPIRy5wEq1ImSSXvUYfiUBpdMOpzpBPw2p6aKsF4owIhnFe2j0yCDufmWyXMNlQMenjexMMXE3RTlVZ81KXiub4b9GDaDAcqTtFJ+AB7kRIwHaaDqDCIdjafCmiFtPpteSFlHlTutq7aTclfdpEvPp9QnMeDhrQaO8eii7yr/4AzZCrw6BjVsyrpog3vm+VXm1YhQcwxpLNEIRv01x1Ole9vjWccw7yd/8/0aMlif9ZrPp76aMmPN32OolOFoJh03siINIdkv5VTxoH5gyJkeSgm/NMq3Rp/aF0s9rZG5yvwwwol7zOd3vOMddx/84AcvMDHmnmaHnseHfGQekgRMwOYc1yiTHlEpJ2jE0UhW9YCU276/hCxmP/RazLBH4NBLTDrL09kyd62/M5RQ2rNt4Uk6SB3X0/7UPTKRvNFi2ml4X+OT+ZmeSCjciUBfBQwJUUsdVnu+GdxEMMX8NOnNUevsymrhvHZRlbGwIOkm6aCaw6TCVRnfpLyshKsO7sdR0KbykELGrq4TBaITHndCXb474YmJR4glu1QuDi4wGJtYYFwcOqF86mNdFCk59tXI0BkHs4/XjsdOyU2mp7t1LsJ5f1JMsp8dfDJEj/hlHtOOc3cyhGqsNVbdhVrGtlpEV2N9TTkR+Gv7K0H/BJ6pTQRDdloxrpswErz+1//6Xx/tqHYu45OnXcL+rMrEyyYl94RHTMrt9N7JGOf7Oz46tblTtFd9q/P1Ghimfu7WlwpTnW+T4tvBWP/v8FOfq/2ZFOSTssJDLbWvEzwVhhNa6fjCqeyywkfHnyov7Oipq3eizan97trU/w7G3TvX8qtKn/Xeqr0dLHnvBPau7RV9TPxn9dyqrh2P2bXzLAtrn/KJfcwNk4lfm/MFA8L73ve+ixEBPsapaM8///zdO9/5zosHEx8MTBhPkFPe9a53XTxZ2GxDUUZRwrMJ2RCFEyOUXj4qkobvsNnj6VYqX6lMoqhplFJBQy5CAfZkN+CgHr1alJEyITE6B/3C68p6Vd7BlRuhygXqJvQnD/ZBeUX2NbWISqKKtKfHClOeQpbeEfav86BNPqMy7nXHaVp3qgydSnx6Anbzr+PRerCxgYy8Dy49TRx5ygTb9NVNXsdSI0h6EaUyDq51fOAZDTAaTNJ7SmOMfeK+BkaKRpjsX9JC4jZhWa3lKReu1uj8rptPSc/+zjxQwAdN2YaJpKFJabEaBjXAZd/Eg+2YYyhhrd776TnGPXU6dQfuMa9feOGFS+gjsrMGRD20MObyLHPRPGSOhwYf+5uJ1R1zwyBTHhfGurlByXHjA+1pxKGktyKF9z0hL72zbE9vuRxvvmv4aPKUjHxIoyPPgQPxLu3znp5TmcMOXkt99cCnB/VYWi1Udi6JIC3BDCoEQegbSEZx4hQDmKL5Z2AGXIdJV9euzkWyE3i7SXjaH/ugJ1UStXmOtHR7ih1FpTpjLE8E6+5/fW9VTvt38vxOsblvWQnYkzIy0RUlmVgngFkXzA8mpBur45KLbHrPnChuU1srAXEloE5KxY5Wdu/Ybk3iNuH3RBCu7UHzMBsWbhlZde/uFn94wFvf+tbLf1ywyQVlXLseir5jewpIGgZzsTpR4HbzqS7gMlUXpmyz8pxVvSvc0h+FSIVY49EVUsyfkHVMhktx7CL4ei2d8r3DZ17vBMs6z6Z5Mo1VFQwSthV/6ATu+v7EV1Ywdcr8TgldtbGru+NLVaBdvX/St4rHSXle4burf9p8qm3v1r6unK4JCpi1zhVtZB98v6PlVZ+6ek/6Nl1bjXvSWVVq6v2uTGO+G+NV32q9icusp6uvwnMiQ2Zd3Tq6KtM7WZ+wT212be3my+u1ZLiXBfhT+XRN0+DDO3gncLw7p76hS7B+4qGALoEsgkGJZz784Q8/8kxHNsfzCJn+q1/96qVNPJzYYMTYwFHxyIlf+9rXHuUToV3eQ2n99re/fZFT9ObwFLfMlZSyv3mNMCyZC9GEwcqv1K8C62YbbWvoUtGkfpN7+9HbAPzQV77pvzhTV/G0O9rXSKXiaghQPSk7jTzSYTUapUfZincnTWc96Z2S/MR7Ez+yb9WDDfxh+DAfEH1FrySVimFCPGeOqvQ+q21kriXlMupOA4onn+mRxhjpocS4ZHSOsjHP41SRXk96KaWRoa4l1XggXtJQYEmjnHXl2iIO86Q7r6d+pSMF99Qh9KhLnV6jgyGCvi98lae6yZ30kGu4MNQ+g1Oe0eMHvBne+d73vvcy1wl9/bVf+7VHtgPg1xiGsQn8s4kLfWgUc/z1fjIptro8bXOPb+duPUkwjTmvFh5uMv5M+q487zs51hp5MrG/RtDanvjr5ms+n3M6n+cD7/OQqUyAzn9sG3zgW3xO15arDEudUFAnvJMKZgqT5j9WQ6ziPM+k4h7fAM5vGD8MwElJR2GCKpgyDd4B2SA6dzkSmfV3wr0S8rIPtmey43S9ra6mLGjG2UIQMGkt4ru8UJXx1uem/ydjs7u+Kp2QdoK7+k69372z+2894B5moBGP8a8ebZ3AZry0dGNiMncQunCtE9insaxwrHC/Ekp3uO7+T+93c/ak1LGv76UbbeKxzsFcHMA788p8CHoFwjhZDCjGPQuDc42dKN5lzHFphdFVRjox1w53q34LJ0IKNORBAu505Al+k/JzohgqlLiwuPOlQIPRCVzAVyqtphBW56y7a8+qTPyiw1ml2w6fVaCqpRoiTxS+07nQwZpt1PE+UUx3ME34OYHxPs9VIXTF9yqvW/G+XXudEpLvZ6n1rXhTV5Iv1Ha7Nr2+MhxmHSm8dTB362Pen+SECtuEhxVsHRzdWO1khRV/7drNftW5k7Szkitr+xNeOr7RzVGf7db607W7u79beyb5aBqPqfh+pbUOB13718gAT7qYdxJ4DPnKdU5ZjWeQ/QztcuefZzEcGApm0mD0DeRFnvuJn/iJuxdffPEiL7KOfvzjH7976aWXLkYpPJ3waOIeOWRQTinf+MY3Lus8CiX1sA7zYUMM4xKeTcig4JI2/Z34FU5PFMvNocxxYwLi9CQATiMjNGxQ0kvJNs1/wrce+dSPHqIhSThdJ6t3kHD7rVHBdzPXVT5fjUOrDa/8XY0fnYeSeEql2zar4Uk4hBf9MU8qk5YqLP7XgJBGIEoezc4YmhaFokEOukQ3pX6NJuBd73NPXKMuQyh5Jz2pEucJq3jN/FLZz46XZMhdepr5sW5z81hXGkqV65M+0pmC/hq9Y5v0TzoThzVCw29pQHxL+859vXbEh0ZenpEPaBDCIMxcxqj0mc985jL2Gmb09GEu6Fkl30nayuvqiya3Fi8ameEtGn8yvKxuKn1/RGhJMxrnchOz5lLVwGxoridsa2DKMaxra73e5Wmtc4ai4coxoX1w4Al6eWLlU/NY8tsjNNlBwGCkxxIAAZxxribZklD4MPC6WZn4WKTQUQw4zz333KUN6uNZrPMZD+kk6JjlidCU/cpjANPTRddUCpPLwTdBoNZJDWOTMHsCU0cMq2dP+rUSNFdtTAtE136nEEzPdwJkhQv8ouCzsGsdh9ChGWhAK3nXX5mCjDN3HNz56TwVpr6cKomTwLrC76RMToJ2vb5SLia4s6zgnOquAkJtk+vJ7Jgf7iopEDGmGEJYpPIYUZmsSdfZoTSpIu0i4KUBynbrgrtSxOpccKE1xwGLmAKiuwd4U05u4avSjXEu9vynDQVD+Qr48bSWqrykMJZ1ga/XQ6mCo+WU71lHHdMqxJ7MsVNYJziyrJS6lULc9WMFw650/Dzv5feqXyueVudH17a/V/Oiq2/qi89PPOu+inFdW6b2r6HVXT/uC/NuXVxd7/haPnNCd9O4Tev4NG5dmwnfRL8dPnZyRtfv1VrcyUG7UmGY6LKuSav3aj9X16cx7OruaHHFf552cb1COWStz9yCKuMmudWbwLwtnsKGF5JyIGs2z7BG4xHNO8gV6Aus3Z///OcvBoGPfvSjdz/90z9998UvfvGRB4KeSB/4wAcudSBfeLIvhifkfRRY6uUaxicMTMiiaahRhjBvCbqAqQFUzNI4otEgUzXoBW4OKO6xsYYsQF+VpVJe8tQtN9yVI6oclLSYXkcJfw19U69KeS5PDpOO0gBlm7aTcFTDSMoxPlPnZ8JblXj7C870UFLx14jgpp35bHgnjWVuNGuAQ/Yzr5XJ0g1n0uOJut1s7DarpVmPlncslX3FS+JUPGZfu3HIvlc+n6GMFI1c9tm6qmFHA04aQbPOPAWOucYz0Dd9pE/QJ2158p71pqd/pS/hsm7bdEykOU8y03vI0/PYmAYG5iNjTz08Y3vmmtX2oDxNMc+W3k+869jYZz3VNAil4U64kh6/7zW9k/fSESI9xKqeojeb+g5znb57cBn6CHB5Il/qPYZ4pieg42v90kN6gSUtyQMt/NczzQ11npt07QcxLNXF04Fn0LHoY/nXcKTiiLGJQWRAIQKPB9RAYDb8ZHoSHc/i3YDLqrsUItmB0H1NbyaZQ07IE2HA/4bdGG/ogkabelalUcnnPPHLeMl08Z0Eryzd9dPFf1VvV/eJIHXfZyZYJoGqE1i9Bm4xWLoD5cRl3BVCpmz1MldoQ1px8XBHqNLcaVmNSyd8nyh417STi7EGTXc96klztd1svy7gnQB/Kux2RcbmouUuEPOoJo5TuNOTCSEOozLXfJ/+6Wo8KauTQjrhs9Kbczt3JDQy4V3pIlHxVQX5ToBPWN31oa/uDthXF30XtEnR7hLPV8HraZdJ+Z3wkO90Y1rHrBNeH1dxr3XV+yf3vN/Np5P53imF9ffUl0p7O+Fzgn9aH7vrHb1Pz034yeurubm7dk2Z1qDp3mrd2l3b0fmq/pMyyRUTHCteXcd6oqeuvlPaXq2DO/hX8Hbvrd7JdzuD6Aqf0xiu4O3k5mvkjV3p5tXUzuPMnYcsyGHmZMRwg0KFjGbuxkxVoIJDQWZg3UTxMhk3z7A2f+UrX7msD2xekQbh7/ydv3MJbzNZ73ve857LqXDc49Rc5QqNWh/5yEcetUf9rMkYcwjZRwehsFaTm0nDQtU3kCF4hjbzYJP0PFIhzfxKbsSrDxlyRB30NxX/Gm6kd5Ub+dVbpEuwnXSROlKdV91a1IWaUvR6SceBqn91m0IaATRO1dCt7EtVou0beNMbSBhsy3AtDW4Zfpa/fdaxSo917rtZzbdhjEapGGZoyCZ1GVapUcKTykzP4RhXPGtwEdY0OuVc1wgrDr3Px3mR45IlcZNJn9PjSNwKP22oazNnNd7yH9y7OZqnjDlWjp36AHV5oJBGOa7VkxD1huIZI6EyvQ6GXgzMzjU+wCPu9aLiOs/qLQbf0aCUcyqNktKd+bSkhzTMJO7f8NqcZv4DK204ttad+EhvOeDFhmKSf51surBFvjW8Ob4Jf877NOTat0pr0ocRGXrnaaSd9MnHNix1TCYJESKD8UpcaRUGwdyH8XPcOYTIc4bJ1XAa69ViyPsao6iPQaMtvBh0FWXgMVrRBkQmIVQlZFpUO2E4XeQMv/K4PpV5J8gFoa8xFBeJWn8V4Ct+J2FjGtBOOK9jVdteCXi7korDJLT5zDV90OjD7ww18p4hbbkjYn4r3V5rP520Gh0zgz6TRUY0hdJNpRvHnQCe79Z6UvjrlKuV4pB40LBEf5hX7szsxrpTDieBubt3olzkM8n8NBQzv/FIZExeeeWVS19IwkluA49hZe5pEGQhqoLQRHerUgWvpDd3F4FPHLuzoHHZ/la339r3Dg/Cq2Hden3eY1AZy5VXXdbtwu1i9izLxAMqDiiTAFnv1zlyoqxaThS5TtitimjXTs7f+p1heqv1Z4Ll9JkdHk6Uy/rsbt3s+tS9M9VbYZ3g7fjefct9aKPjhxNuTnhhhWcF2wr2Exqt7e7qn2Ds+L7P7tb7k7l3As/EE7r3kh+u+MWEj2tkmNPS8b7dc7v7u7Wv0khe9/1nVTAkEdbOGqcSpdcD667hFyqHCTvPIi9g4NGQoOxIPhX0DD7f+ta3HiXlpj3C3dioxlhkHiRzrQAHYXIYojAkKWdQP88ia2qcQWYhpJ/yhS984dHazQddpx4fr7xDUbn2OvIG9ank5tgot9o3DVRpbFD508vGk4etJw0Ptl29rLKk10PdwPM755Z1d2uMBglKHjmvfK4clfNUpwQNDNYtLDVUL71GxIm6W+azyQ1OaShPNMtcSLbFcxqSDGXS8MS7jDHPaUxIXmUdNfG3xkI98uoBLbapp5Fjn+ORxknfyVPFxFH9XXGuMSQTkIsPxykNTXq3IGNyzxPODA0UTt/TwGS9tm3f+NZgbDSTsOoJRTEdBno/ug3zDZh9HxxxTS8h7QbiW9rAPgDsGI31ZMp8Wz7nf+lG2MWx4a3ScY7773/NKGPetRy3mu9WPGEUxnMTeMjnpv7Gf/mg8yhD0pK/p36cxsykKZ9N+0TmtZI+9N7ykLX6zqp836uPu1Leyq3cyq3cyq3cyq3cyq3cyq3cyq3cyq3cyv8vy7ONl7iVW7mVW7mVW7mVW7mVW7mVW7mVW7mVW7mV/23LzbB0K7dyK7dyK7dyK7dyK7dyK7dyK7dyK7dyK/cqN8PSrdzKrdzKrdzKrdzKrdzKrdzKrdzKrdzKrdyr3AxLt3Irt3Irt3Irt3Irt3Irt3Irt3Irt3Irt3KvcjMs3cqt3Mqt3Mqt3Mqt3Mqt3Mqt3Mqt3Mqt3Mq9ys2wdCu3ciu3ciu3ciu3ciu3ciu3ciu3ciu3civ3KjfD0q3cyq3cyq3cyq3cyq3cyq3cyq3cyq3cyq3cq9wMS7dyK7dyK7dyK7dyK7dyK7dyK7dyK7dyK7dyr3IzLN3KrdzKrdzKrdzKrdzKrdzKrdzKrdzKrdzK3X3K/wst3PyaS68s+QAAAABJRU5ErkJggg==", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -1108,20 +1041,12 @@ } ], "source": [ - "# Iterate through the records and display the images\n", - "for index, row in db.open_table(\"images\").to_pandas().iterrows():\n", - " img_array = np.array(row[\"image\"], dtype=row[\"dtype\"]).reshape(\n", - " row[\"height\"], row[\"width\"], row[\"channels\"]\n", - " )\n", - " plt.imshow(img_array.squeeze(), cmap=\"gray\")\n", - " plt.title(f\"Image: {row['filename']}\")\n", - " plt.axis(\"off\")\n", - " plt.show()" + "show_images_from_lance(db_path=LANCE_DIR, table_name=\"images\", col_name=\"ome-arrow_original\", max_images=4, pick=\"first\", cmap=\"gray\")" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "id": "b8892f7b-3c1f-44e2-8745-2f1136c1a47c", "metadata": {}, "outputs": [ @@ -1162,7 +1087,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.11" + "version": "3.11.13" } }, "nbformat": 4, diff --git a/src/serpula_rasa/example.py b/src/serpula_rasa/example.py index e98d51a..de8126b 100644 --- a/src/serpula_rasa/example.py +++ b/src/serpula_rasa/example.py @@ -45,6 +45,7 @@ import numpy as np import pandas as pd from cellpose import models as cp_models +from serpula_rasa.image import ingest_ome_images_ome_arrow, show_images_from_lance try: from cellpose import version as CP_VERSION @@ -62,7 +63,7 @@ TABLE_FEATURES = "compartment_nuclei" TABLE_LOG = "run_log" TABLE_IMAGES = "images" -TABLE_MASKS = "masks" +TABLE_MASKS = "images" MODEL_TYPE = "nuclei" # Cellpose pretrained nuclei model GPU = True # set True if you have CUDA ready @@ -95,13 +96,6 @@ copy2(entry, target) pp(list(pathlib.Path(DEST_DIR).rglob("*"))) -# - - -type( - lancedb.connect(LANCE_DIR).create_table( - "something", pd.DataFrame({"sometiing": [12]}) - ) -) # + # create functions which can help us run the pipeline @@ -242,147 +236,98 @@ def cellpose_eval( return masks, diam_scalar -def main() -> None: # noqa: PLR0915, C901 +def gather_profiles() -> None: # noqa: PLR0915, C901 # Connect LanceDB + ensure log table db = lancedb.connect(str(LANCE_DIR)) ensure_log_table(db, TABLE_LOG) log_tbl = db.open_table(TABLE_LOG) - # Init Cellpose (v3 or v4) + # Init Cellpose (v3 or v4) + measurement funcs model = make_cellpose_model(MODEL_TYPE, GPU) - - # cp_measure measurement functions (intensity, size/shape, - # texture, zernike, granularity, radial, etc.) measurements = get_core_measurements() images = list_images(IMAGES_DIR) if not images: raise SystemExit(f"No images found under: {IMAGES_DIR.resolve()}") + ome_tbl = ingest_ome_images_ome_arrow( + db=db, + col_name="ome-arrow_original", + table_name=TABLE_IMAGES, # reuse TABLE_IMAGES name + image_paths=images, # demo: first image only + prefer_dimension_order_xyzct=False, # 2D → "XYCT" hint + ) + print(f"[ome-arrow] stored {ome_tbl.count_rows()} image(s) in Lance") + for img_path in [images[0]]: try: - # --- read & (optionally) select nuclei channel --- img = iio.imread(img_path) - file_shape = tuple(img.shape) - file_dtype = str(img.dtype) - - # If multichannel (H,W,C), pick the first channel - # for minimal demo storage/seg - dims = 3 - if img.ndim == dims and img.shape[-1] in (2, 3, 4): + # match the ingestion’s channel handling + if img.ndim == 3 and img.shape[-1] in (2, 3, 4): nuc_img = img[..., 0] - stored_channels = 1 else: nuc_img = img - stored_channels = 1 # demo stores single-channel images - - # --- store raw image as flattened list into images_raw --- - img_record = pd.DataFrame( - [ - { - "filename": img_path.name, - "height": int(nuc_img.shape[0]), - "width": int(nuc_img.shape[1]), - "channels": int(stored_channels), - "dtype": str(nuc_img.dtype), - "image": ndarray_to_list(nuc_img), # <— list column - # provenance about original file before channel selection - "file_shape": str(file_shape), - "file_dtype": file_dtype, - } - ] - ) - - get_or_create_table(db, TABLE_IMAGES, img_record) - - # --- prepare float image for segmentation & features --- + img_f = to_float01(nuc_img) - # --- segment --- + # segment masks, diams = cellpose_eval(model, img_f, channels=CHANNELS) - # --- store mask as flattened list with lineage into masks table --- - labels = np.unique(masks) - labels = labels[labels > 0] + # store masks (kept as flattened ints in existing table) + labels = np.unique(masks); labels = labels[labels > 0] n_obj = int(labels.size) - - mask_record = pd.DataFrame( - [ - { - "filename": img_path.name, - "algo_name": "cellpose", - "algo_version": CP_VERSION, - "model_type": MODEL_TYPE, - "channels": str(CHANNELS), - "n_objects": n_obj, - "height": int(masks.shape[0]), - "width": int(masks.shape[1]), - "dtype": "int32", - "image": ndarray_to_list( - masks.astype(np.int32, copy=False) - ), # <— list column - } - ] - ) - + mask_record = pd.DataFrame([{ + "filename": img_path.name, + "algo_name": "cellpose", + "algo_version": CP_VERSION, + "model_type": MODEL_TYPE, + "channels": str(CHANNELS), + "n_objects": n_obj, + "height": int(masks.shape[0]), + "width": int(masks.shape[1]), + "dtype": "int32", + "image": masks.astype(np.int32, copy=False).ravel(order="C").tolist(), + }]) get_or_create_table(db, TABLE_MASKS, mask_record) - # --- compute cp_measure features --- + # features if n_obj < MIN_OBJECTS_TO_SAVE: - log_tbl.add( - [ - { - "image_filename": str(img_path), - "status": "no_objects", - "n_objects": n_obj, - } - ] - ) + log_tbl.add([{ + "image_filename": str(img_path), + "status": "no_objects", + "n_objects": n_obj, + }]) print(f"- {img_path.name}: no objects") continue feature_arrays: Dict[str, np.ndarray] = {} for _, fn in measurements.items(): - res = fn(masks, img_f) # (mask, image) measurements + res = fn(masks, img_f) feature_arrays.update(res) rows = [] for i, obj_id in enumerate(labels, start=0): - row = { - "image_filename": img_path.name, - "nuclei_object_number": int(obj_id), - } + row = {"image_filename": img_path.name, "nuclei_object_number": int(obj_id)} for feat_name, arr in feature_arrays.items(): if i < len(arr): val = arr[i] - # ensure python scalar try: - row[feat_name] = ( - float(val) - if np.ndim(val) == 0 - else float(np.array(val).item()) - ) + row[feat_name] = float(val) if np.ndim(val) == 0 else float(np.array(val).item()) except Exception: row[feat_name] = float("nan") rows.append(row) - df_features = pd.DataFrame(rows) - get_or_create_table(db, TABLE_FEATURES, df_features) log_tbl.add([{"image": str(img_path), "status": "ok", "n_objects": n_obj}]) print(f"✓ {img_path.name}: {n_obj} objects") except Exception as ex: - log_tbl.add( - [ - { - "image": str(img_path), - "status": f"error: {type(ex).__name__}: {ex}", - "n_objects": 0, - } - ] - ) + log_tbl.add([{ + "image": str(img_path), + "status": f"error: {type(ex).__name__}: {ex}", + "n_objects": 0, + }]) print(f"✗ {img_path.name}: {ex}") @@ -390,7 +335,7 @@ def main() -> None: # noqa: PLR0915, C901 # %%time # run the pipeline and show the time duration -main() +gather_profiles() db = lancedb.connect(LANCE_DIR) db.table_names() @@ -404,15 +349,7 @@ def main() -> None: # noqa: PLR0915, C901 # show the images table db.open_table("masks").to_pandas() -# Iterate through the records and display the images -for index, row in db.open_table("images").to_pandas().iterrows(): - img_array = np.array(row["image"], dtype=row["dtype"]).reshape( - row["height"], row["width"], row["channels"] - ) - plt.imshow(img_array.squeeze(), cmap="gray") - plt.title(f"Image: {row['filename']}") - plt.axis("off") - plt.show() +show_images_from_lance(db_path=LANCE_DIR, table_name="images", col_name="ome-arrow_original", max_images=4, pick="first", cmap="gray") for _, row in db.open_table("masks").to_pandas().iterrows(): mask = np.array(row["image"], dtype=np.int32).reshape(row["height"], row["width"]) diff --git a/src/serpula_rasa/image.py b/src/serpula_rasa/image.py index 3ac062b..b9b65ef 100644 --- a/src/serpula_rasa/image.py +++ b/src/serpula_rasa/image.py @@ -3,7 +3,8 @@ """ from __future__ import annotations - +import imageio.v3 as iio +from typing import Literal from dataclasses import dataclass from datetime import datetime, timezone import pathlib @@ -18,7 +19,7 @@ import pyarrow as pa import pyarrow.parquet as pq -from serpula_rasa.meta import OME_ARROW_SCHEMA, OME_DTYPE_MAP, OME_ARROW_TAG_TYPE, OME_ARROW_TAG_VERSION +from serpula_rasa.meta import OME_ARROW_SCHEMA, OME_DTYPE_MAP, OME_ARROW_TAG_TYPE, OME_ARROW_TAG_VERSION, ome_arrow_schema @dataclass class ChannelMeta: @@ -85,6 +86,7 @@ def _coerce_pixel_dtype(arr5: np.ndarray) -> Tuple[np.ndarray, str]: def make_ome_arrow_row( *, image_id: str, + col_name: str = "ome_arrow", name: str, pixels: np.ndarray, # XY or XYZ (+ optional C/T) channel_meta: Optional[Sequence[ChannelMeta]] = None, @@ -150,7 +152,7 @@ def make_ome_arrow_row( } return { - "ome_arrow": { + col_name: { "type": OME_ARROW_TAG_TYPE, "version": OME_ARROW_TAG_VERSION, "id": image_id, @@ -163,14 +165,12 @@ def make_ome_arrow_row( } -def validate_ome_arrow_table(table: pa.Table) -> None: - """ - Validate the table matches OME_ARROW_SCHEMA and rows carry the correct tags. - Raises ValueError on mismatch. - """ - if table.schema.types != OME_ARROW_SCHEMA.types or table.schema.names != OME_ARROW_SCHEMA.names: - raise ValueError("Schema mismatch: table does not match OME_ARROW_SCHEMA.") - col = table["ome_arrow"] +def validate_ome_arrow_table(table: pa.Table, *, col_name: str = "ome_arrow") -> None: + """Validate schema + tags for the chosen column name.""" + expected = ome_arrow_schema(col_name) + if table.schema.types != expected.types or table.schema.names != expected.names: + raise ValueError(f"Schema mismatch: table does not match ome_arrow_schema({col_name!r}).") + col = table[col_name] for i in range(len(col)): rec = col[i].as_py() if rec.get("type") != OME_ARROW_TAG_TYPE: @@ -182,27 +182,25 @@ def validate_ome_arrow_table(table: pa.Table) -> None: def write_ome_arrow_parquet( rows: Iterable[Mapping[str, object]], path: str, + *, + col_name: str = "ome_arrow", row_group_size: int = 1, ) -> None: - """ - Write ome-arrow rows to Parquet with settings tuned for numeric arrays. - """ - table = pa.Table.from_pylist(list(rows), schema=OME_ARROW_SCHEMA) + table = pa.Table.from_pylist(list(rows), schema=ome_arrow_schema(col_name)) pq.write_table( table, path, compression="zstd", use_dictionary=False, data_page_version="2.0", - row_group_size=row_group_size, # often 1 row = 1 image; batch if desired + row_group_size=row_group_size, ) -def read_ome_arrow_first(path: str) -> Mapping[str, object]: - """Quick peek: load the first ome-arrow record (no reshaping).""" - tbl = pq.read_table(path, columns=["ome_arrow"]) - validate_ome_arrow_table(tbl) - return tbl["ome_arrow"][0].as_py() +def read_ome_arrow_first(path: str, *, col_name: str = "ome_arrow") -> Mapping[str, object]: + tbl = pq.read_table(path, columns=[col_name]) + validate_ome_arrow_table(tbl, col_name=col_name) + return tbl[col_name][0].as_py() @@ -267,34 +265,24 @@ def list_images(root: pathlib.Path) -> list[pathlib.Path]: return sorted([p for p in pathlib.Path(root).rglob("*") if p.suffix.lower() in exts]) -def pa_table_from_ome_arrow_rows(rows: list[Mapping[str, Any]]) -> pa.Table: - """ - Build a PyArrow Table with the canonical one-column ome-arrow schema - from a list of py-dicts produced by `make_ome_arrow_row`. - """ - return pa.Table.from_pylist(rows, schema=OME_ARROW_SCHEMA) +def pa_table_from_ome_arrow_rows(rows: list[Mapping[str, Any]], *, col_name: str = "ome_arrow") -> pa.Table: + """Create a PyArrow table for ome-arrow rows under a custom column name.""" + return pa.Table.from_pylist(rows, schema=ome_arrow_schema(col_name)) def _lance_get_or_create_arrow_table( db: lancedb.db.LanceDBConnection, table_name: str, first_batch: pa.Table, ) -> lancedb.table.LanceTable: - """ - Create (empty) or open a Lance table using the batch schema. - NOTE: We do NOT write 'first_batch' here to avoid double-insert. - """ + # unchanged logic; first_batch already has the custom schema/col_name names = set(db.table_names()) if table_name not in names: - # Create EMPTY table with the schema of first_batch return db.create_table(table_name, schema=first_batch.schema) - tbl = db.open_table(table_name) try: - # Probe compatibility tbl.add(first_batch.slice(0, 0)) return tbl except Exception: - # Recreate EMPTY table with the schema db.drop_table(table_name) return db.create_table(table_name, schema=first_batch.schema) @@ -302,6 +290,7 @@ def ingest_ome_arrow_to_lance( image_paths: Iterable[pathlib.Path], db_path: pathlib.Path, table_name: str = "ome_images", + col_name: str = "ome_arrow", *, channel_meta: Optional[Sequence["ChannelMeta"]] = None, physical_size_xy_um: float = 0.108, @@ -343,10 +332,9 @@ def _flush() -> None: nonlocal rows, lance_tbl if not rows: return - batch = pa_table_from_ome_arrow_rows(rows) + batch = pa_table_from_ome_arrow_rows(rows, col_name=col_name) if lance_tbl is None: lance_tbl = _lance_get_or_create_arrow_table(db, table_name, batch) - # Write the batch ONCE lance_tbl.add(batch) rows = [] @@ -356,6 +344,7 @@ def _flush() -> None: # Build one ome-arrow row (auto normalizes shapes to T,C,Z,Y,X) row = make_ome_arrow_row( image_id=p.stem, + col_name=col_name, name=p.name, pixels=img, channel_meta=channel_meta, @@ -375,8 +364,9 @@ def _flush() -> None: return lance_tbl def show_images_from_lance( - db_path: Path, + db_path: pathlib.Path, table_name: str = "ome_images", + col_name: str = "ome_arrow", *, max_images: int = 8, pick: Literal["first", "center", "maxproj"] = "first", @@ -406,11 +396,9 @@ def show_images_from_lance( db = lancedb.connect(str(db_path)) tbl = db.open_table(table_name) + arr_tbl = tbl.to_arrow().select([col_name]) # <-- select by your name + records = [arr_tbl[col_name][i].as_py() for i in range(len(arr_tbl))] - # Pull to Arrow (fast) then to Py-land recordss - # Note: select only the ome_arrow column - arr_tbl = tbl.to_arrow().select(["ome_arrow"]) - records = [arr_tbl["ome_arrow"][i].as_py() for i in range(len(arr_tbl))] if not records: print("(no images)") return @@ -447,4 +435,69 @@ def show_images_from_lance( axes[j // cols][j % cols].axis("off") plt.tight_layout() - plt.show() \ No newline at end of file + plt.show() + +def pa_table_from_ome_rows(rows: List[Mapping[str, Any]], col_name: str = "ome_arrow") -> pa.Table: + """Build a PyArrow Table from ome-arrow rows using the canonical schema.""" + return pa.Table.from_pylist(list(rows), schema=ome_arrow_schema(col_name)) + +def ingest_ome_images_ome_arrow( + db: lancedb.db.LanceDBConnection, + table_name: str, + image_paths: Sequence[pathlib.Path], + *, + col_name: str = "ome_arrow", + physical_size_xy_um: float = 0.108, + physical_size_z_um: float = 1.0, + physical_unit: str = "µm", + prefer_dimension_order_xyzct: bool = False, # 2D → "XYCT" hint + batch_size: int = 64, + channel_meta: Optional[Sequence["ChannelMeta"]] = None, # optional +) -> lancedb.table.LanceTable: + """ + Convert file images into `ome_arrow` structs and write to a Lance table + (one struct per row) using the canonical Arrow schema. + """ + rows: List[Mapping[str, Any]] = [] + lance_tbl: Optional[lancedb.table.LanceTable] = None + + def _flush() -> None: + nonlocal rows, lance_tbl + if not rows: + return + batch = pa_table_from_ome_rows(rows=rows, col_name=col_name) + if lance_tbl is None: + lance_tbl = _lance_get_or_create_arrow_table(db, table_name, batch) + lance_tbl.add(batch) # write the batch once + rows = [] + + for p in image_paths: + arr = iio.imread(p) # keeps dtype; supports many formats + + # If multichannel (H,W,C), pick first channel for nuclei (demo parity) + if arr.ndim == 3 and arr.shape[-1] in (2, 3, 4): + arr = arr[..., 0] + + row = make_ome_arrow_row( + image_id=p.stem, + col_name=col_name, + name=p.name, + pixels=arr, + channel_meta=channel_meta, + physical_size_xy_um=physical_size_xy_um, + physical_size_z_um=physical_size_z_um, + physical_unit=physical_unit, + prefer_dimension_order_xyzct=prefer_dimension_order_xyzct, + acquisition_dt=datetime.now(timezone.utc), + ) + rows.append(row) + + if len(rows) >= batch_size: + _flush() + + _flush() + + if lance_tbl is None: + raise("No images ingested; check `image_paths`.") + + return lance_tbl \ No newline at end of file diff --git a/src/serpula_rasa/meta.py b/src/serpula_rasa/meta.py index 3ac1508..6e4264c 100644 --- a/src/serpula_rasa/meta.py +++ b/src/serpula_rasa/meta.py @@ -90,7 +90,15 @@ ] ) -# OME_ARROW_SCHEMA: a one-column table named 'ome_arrow' holding the struct. +def ome_arrow_schema(col_name: str = "ome_arrow") -> pa.Schema: + """ + Build a one-column Arrow schema for ome-arrow with a custom column name. + Reuses the struct type from the canonical OME_ARROW_SCHEMA. + """ + struct_type = OME_ARROW_SCHEMA.field(0).type # reuse the canonical struct + + return pa.schema([pa.field(col_name, struct_type)]) + OME_ARROW_SCHEMA: pa.Schema = pa.schema([pa.field("ome_arrow", OME_ARROW_STRUCT)]) diff --git a/tests/test_image.py b/tests/test_image.py index 312a25a..806e116 100644 --- a/tests/test_image.py +++ b/tests/test_image.py @@ -46,6 +46,7 @@ def test_ome_arrow_roundtrip_from_2d_tiff(tmp_path, shape, dtype): row = make_ome_arrow_row( image_id="img_0001", + col_name="ome_arrow", name="2D TIFF example", pixels=img, # accepts (Y, X) physical_size_xy_um=0.108, From 29a16e4bd9586d275db7e943b00bf6ccca174b6e Mon Sep 17 00:00:00 2001 From: d33bs Date: Wed, 1 Oct 2025 11:56:06 -0600 Subject: [PATCH 4/5] with masks --- src/serpula_rasa/example.ipynb | 639 +++++++++++++++++++++++++-------- src/serpula_rasa/example.py | 203 ++++++++--- src/serpula_rasa/image.py | 16 +- 3 files changed, 662 insertions(+), 196 deletions(-) diff --git a/src/serpula_rasa/example.ipynb b/src/serpula_rasa/example.ipynb index f1c599e..b734451 100644 --- a/src/serpula_rasa/example.ipynb +++ b/src/serpula_rasa/example.ipynb @@ -51,6 +51,7 @@ "import shutil\n", "import subprocess\n", "import tempfile\n", + "from datetime import datetime, timezone\n", "from pathlib import Path\n", "from pprint import pp\n", "from shutil import copy2, copytree\n", @@ -62,8 +63,16 @@ "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import pandas as pd\n", + "import pyarrow as pa\n", "from cellpose import models as cp_models\n", - "from serpula_rasa.image import ingest_ome_images_ome_arrow, show_images_from_lance\n", + "\n", + "from serpula_rasa.image import (\n", + " ensure_ome_arrow_column,\n", + " ingest_ome_images_ome_arrow,\n", + " make_ome_arrow_row,\n", + " show_images_from_lance,\n", + ")\n", + "from serpula_rasa.meta import OME_ARROW_SCHEMA\n", "\n", "try:\n", " from cellpose import version as CP_VERSION\n", @@ -138,7 +147,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "f0b781b1-06c8-4d73-80a4-7a955d5b1c0e", "metadata": {}, "outputs": [], @@ -295,53 +304,92 @@ " if not images:\n", " raise SystemExit(f\"No images found under: {IMAGES_DIR.resolve()}\")\n", "\n", - " ome_tbl = ingest_ome_images_ome_arrow(\n", - " db=db,\n", - " col_name=\"ome-arrow_original\",\n", - " table_name=TABLE_IMAGES, # reuse TABLE_IMAGES name\n", - " image_paths=images, # demo: first image only\n", - " prefer_dimension_order_xyzct=False, # 2D → \"XYCT\" hint\n", - " )\n", - " print(f\"[ome-arrow] stored {ome_tbl.count_rows()} image(s) in Lance\")\n", + " # --- We will build both struct columns in the same index order ---\n", + " rows_combined = (\n", + " []\n", + " ) # each item will be {\"ome-arrow_original\": {...}, \"ome-arrow_mask\": {...}|None}\n", "\n", - " for img_path in [images[0]]:\n", + " for img_path in images:\n", " try:\n", + " # Load image (keep dtype); if multichannel HWC, pick channel 0 for demo parity\n", " img = iio.imread(img_path)\n", - " # match the ingestion’s channel handling\n", " if img.ndim == 3 and img.shape[-1] in (2, 3, 4):\n", " nuc_img = img[..., 0]\n", " else:\n", " nuc_img = img\n", "\n", - " img_f = to_float01(nuc_img)\n", + " # ---------- Build original image struct ----------\n", + " img_struct = make_ome_arrow_row(\n", + " image_id=img_path.stem,\n", + " col_name=\"ome-arrow_original\",\n", + " name=img_path.name,\n", + " pixels=nuc_img,\n", + " physical_size_xy_um=0.108,\n", + " physical_size_z_um=1.0,\n", + " physical_unit=\"µm\",\n", + " prefer_dimension_order_xyzct=False, # 2D → \"XYCT\" hint\n", + " acquisition_dt=datetime.now(timezone.utc),\n", + " )\n", "\n", - " # segment\n", + " # ---------- Segment + build mask struct (same index as image) ----------\n", + " img_f = to_float01(nuc_img)\n", " masks, diams = cellpose_eval(model, img_f, channels=CHANNELS)\n", "\n", - " # store masks (kept as flattened ints in existing table)\n", - " labels = np.unique(masks); labels = labels[labels > 0]\n", + " mask_struct = make_ome_arrow_row(\n", + " image_id=img_path.stem,\n", + " col_name=\"ome-arrow_mask\",\n", + " name=f\"{img_path.name} (mask)\",\n", + " pixels=masks.astype(np.uint16, copy=False),\n", + " physical_size_xy_um=0.108,\n", + " physical_size_z_um=1.0,\n", + " physical_unit=\"µm\",\n", + " prefer_dimension_order_xyzct=False,\n", + " acquisition_dt=datetime.now(timezone.utc),\n", + " )\n", + "\n", + " # Collect a single row with both structs (aligned by index)\n", + " rows_combined.append(\n", + " {\n", + " \"ome-arrow_original\": img_struct[\"ome-arrow_original\"],\n", + " \"ome-arrow_mask\": mask_struct[\"ome-arrow_mask\"],\n", + " }\n", + " )\n", + "\n", + " # ---------- Optional: keep your legacy masks/features tables ----------\n", + " labels = np.unique(masks)\n", + " labels = labels[labels > 0]\n", " n_obj = int(labels.size)\n", - " mask_record = pd.DataFrame([{\n", - " \"filename\": img_path.name,\n", - " \"algo_name\": \"cellpose\",\n", - " \"algo_version\": CP_VERSION,\n", - " \"model_type\": MODEL_TYPE,\n", - " \"channels\": str(CHANNELS),\n", - " \"n_objects\": n_obj,\n", - " \"height\": int(masks.shape[0]),\n", - " \"width\": int(masks.shape[1]),\n", - " \"dtype\": \"int32\",\n", - " \"image\": masks.astype(np.int32, copy=False).ravel(order=\"C\").tolist(),\n", - " }])\n", + "\n", + " mask_record = pd.DataFrame(\n", + " [\n", + " {\n", + " \"filename\": img_path.name,\n", + " \"algo_name\": \"cellpose\",\n", + " \"algo_version\": CP_VERSION,\n", + " \"model_type\": MODEL_TYPE,\n", + " \"channels\": str(CHANNELS),\n", + " \"n_objects\": n_obj,\n", + " \"height\": int(masks.shape[0]),\n", + " \"width\": int(masks.shape[1]),\n", + " \"dtype\": \"int32\",\n", + " \"image\": masks.astype(np.int32, copy=False)\n", + " .ravel(order=\"C\")\n", + " .tolist(),\n", + " }\n", + " ]\n", + " )\n", " get_or_create_table(db, TABLE_MASKS, mask_record)\n", "\n", - " # features\n", " if n_obj < MIN_OBJECTS_TO_SAVE:\n", - " log_tbl.add([{\n", - " \"image_filename\": str(img_path),\n", - " \"status\": \"no_objects\",\n", - " \"n_objects\": n_obj,\n", - " }])\n", + " log_tbl.add(\n", + " [\n", + " {\n", + " \"image_filename\": str(img_path),\n", + " \"status\": \"no_objects\",\n", + " \"n_objects\": n_obj,\n", + " }\n", + " ]\n", + " )\n", " print(f\"- {img_path.name}: no objects\")\n", " continue\n", "\n", @@ -352,12 +400,19 @@ "\n", " rows = []\n", " for i, obj_id in enumerate(labels, start=0):\n", - " row = {\"image_filename\": img_path.name, \"nuclei_object_number\": int(obj_id)}\n", + " row = {\n", + " \"image_filename\": img_path.name,\n", + " \"nuclei_object_number\": int(obj_id),\n", + " }\n", " for feat_name, arr in feature_arrays.items():\n", " if i < len(arr):\n", " val = arr[i]\n", " try:\n", - " row[feat_name] = float(val) if np.ndim(val) == 0 else float(np.array(val).item())\n", + " row[feat_name] = (\n", + " float(val)\n", + " if np.ndim(val) == 0\n", + " else float(np.array(val).item())\n", + " )\n", " except Exception:\n", " row[feat_name] = float(\"nan\")\n", " rows.append(row)\n", @@ -368,17 +423,50 @@ " print(f\"✓ {img_path.name}: {n_obj} objects\")\n", "\n", " except Exception as ex:\n", - " log_tbl.add([{\n", - " \"image\": str(img_path),\n", - " \"status\": f\"error: {type(ex).__name__}: {ex}\",\n", - " \"n_objects\": 0,\n", - " }])\n", - " print(f\"✗ {img_path.name}: {ex}\")" + " # If segmentation or anything else fails, still store original image row with mask=None\n", + " try:\n", + " if \"img_struct\" in locals():\n", + " rows_combined.append(\n", + " {\n", + " \"ome-arrow_original\": img_struct[\"ome-arrow_original\"],\n", + " \"ome-arrow_mask\": None, # nullable struct column will accept None\n", + " }\n", + " )\n", + " except Exception:\n", + " pass\n", + "\n", + " log_tbl.add(\n", + " [\n", + " {\n", + " \"image\": str(img_path),\n", + " \"status\": f\"error: {type(ex).__name__}: {ex}\",\n", + " \"n_objects\": 0,\n", + " }\n", + " ]\n", + " )\n", + " print(f\"✗ {img_path.name}: {ex}\")\n", + "\n", + " # ---------- Materialize a two-column Arrow table (index-aligned) ----------\n", + " # Reuse the canonical ome-arrow struct type for both columns.\n", + " struct_type = OME_ARROW_SCHEMA.field(0).type\n", + " schema_two_cols = pa.schema(\n", + " [\n", + " pa.field(\"ome-arrow_original\", struct_type), # nullable defaults to True\n", + " pa.field(\"ome-arrow_mask\", struct_type),\n", + " ]\n", + " )\n", + " arrow_tbl = pa.Table.from_pylist(rows_combined, schema=schema_two_cols)\n", + "\n", + " # ---------- Create/replace Lance table with both columns ----------\n", + " if TABLE_IMAGES in set(db.table_names()):\n", + " db.drop_table(TABLE_IMAGES)\n", + " img_tbl = db.create_table(TABLE_IMAGES, data=arrow_tbl)\n", + " print(f\"[ome-arrow] stored {img_tbl.count_rows()} row(s) in Lance (images + masks)\")" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "98a713c1-9dbf-4945-9114-b3545298a50c", "metadata": {}, "outputs": [ @@ -387,6 +475,9 @@ "output_type": "stream", "text": [ "model_type argument is not used in v4.0.1+. Ignoring this argument...\n", + "channels deprecated in v4.0.1+. If data contain more than 3 channels, only the first 3 channels will be used\n", + "/Users/buntend/Documents/work/serpula_rasa/.venv/lib/python3.11/site-packages/cp_measure/core/measureobjectintensitydistribution.py:279: RuntimeWarning: invalid value encountered in divide\n", + " radial_means = numpy.ma.masked_array(radial_values / pixel_count, mask)\n", "channels deprecated in v4.0.1+. If data contain more than 3 channels, only the first 3 channels will be used\n" ] }, @@ -394,24 +485,27 @@ "name": "stdout", "output_type": "stream", "text": [ - "[ome-arrow] stored 3 image(s) in Lance\n" + "✓ AS_09125_050116030001_D03f00d0.tif: 329 objects\n", + "[lancedb] Recreating table 'images' with current schema.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/Users/buntend/Documents/work/serpula_rasa/.venv/lib/python3.11/site-packages/cp_measure/core/measureobjectintensitydistribution.py:279: RuntimeWarning: invalid value encountered in divide\n", - " radial_means = numpy.ma.masked_array(radial_values / pixel_count, mask)\n" + "channels deprecated in v4.0.1+. If data contain more than 3 channels, only the first 3 channels will be used\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "✓ AS_09125_050116030001_D03f00d0.tif: 329 objects\n", - "CPU times: user 3.78 s, sys: 1.21 s, total: 5 s\n", - "Wall time: 8.1 s\n" + "✓ AS_09125_050116030001_D03f00d1.tif: 22 objects\n", + "[lancedb] Recreating table 'images' with current schema.\n", + "✓ AS_09125_050116030001_D03f00d2.tif: 307 objects\n", + "[ome-arrow] stored 3 row(s) in Lance (images + masks)\n", + "CPU times: user 8.08 s, sys: 1.94 s, total: 10 s\n", + "Wall time: 18.3 s\n" ] } ], @@ -423,17 +517,17 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "1c80deb6-b53a-4eb9-ba33-f6b30c3b9edf", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "['compartment_nuclei', 'images', 'masks', 'run_log', 'something']" + "['compartment_nuclei', 'images', 'run_log']" ] }, - "execution_count": 6, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -443,6 +537,30 @@ "db.table_names()" ] }, + { + "cell_type": "code", + "execution_count": 6, + "id": "3f0e7ba9-354f-4b59-8e27-b63b8d458bb3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'image': 'data/ExampleHuman/images/AS_09125_050116030001_D03f00d0.tif',\n", + " 'status': 'ok',\n", + " 'n_objects': 329}" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# show nuclei features\n", + "db.open_table(\"run_log\").to_pandas().iloc[0].to_dict()" + ] + }, { "cell_type": "code", "execution_count": 7, @@ -883,72 +1001,301 @@ }, { "cell_type": "code", - "execution_count": 8, - "id": "e5cdd20c-0a03-4e8d-a4f0-3928e59d203f", + "execution_count": 13, + "id": "9d684b77-902f-4f74-a065-4fb7a3646ab0", "metadata": {}, "outputs": [ { "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
ome-arrow_original
0{'type': 'ome.arrow', 'version': '0.0.1', 'id'...
1{'type': 'ome.arrow', 'version': '0.0.1', 'id'...
2{'type': 'ome.arrow', 'version': '0.0.1', 'id'...
\n", - "
" - ], "text/plain": [ - " ome-arrow_original\n", - "0 {'type': 'ome.arrow', 'version': '0.0.1', 'id'...\n", - "1 {'type': 'ome.arrow', 'version': '0.0.1', 'id'...\n", - "2 {'type': 'ome.arrow', 'version': '0.0.1', 'id'..." + "{'image_filename': 'AS_09125_050116030001_D03f00d0.tif',\n", + " 'nuclei_object_number': 1,\n", + " 'RadialDistribution_FracAtD_1of4': 0.06695069372653961,\n", + " 'RadialDistribution_MeanFrac_1of4': 1.1214241199195343,\n", + " 'RadialDistribution_RadialCV_1of4': 0.014845391354877498,\n", + " 'RadialDistribution_FracAtD_2of4': 0.2513694167137146,\n", + " 'RadialDistribution_MeanFrac_2of4': 1.1227833946545906,\n", + " 'RadialDistribution_RadialCV_2of4': 0.06571046148222312,\n", + " 'RadialDistribution_FracAtD_3of4': 0.3551430404186249,\n", + " 'RadialDistribution_MeanFrac_3of4': 1.0815719867294478,\n", + " 'RadialDistribution_RadialCV_3of4': 0.04375997205831381,\n", + " 'RadialDistribution_FracAtD_4of4': 0.3265368342399597,\n", + " 'RadialDistribution_MeanFrac_4of4': 0.8414603036183572,\n", + " 'RadialDistribution_RadialCV_4of4': 0.08206160591378724,\n", + " 'RadialDistribution_ZernikeMagnitude_0_0': 0.1923324583626505,\n", + " 'RadialDistribution_ZernikePhase_0_0': 1.5707963267948966,\n", + " 'RadialDistribution_ZernikeMagnitude_1_1': 0.012710919436019171,\n", + " 'RadialDistribution_ZernikePhase_1_1': 1.6738472431016886,\n", + " 'RadialDistribution_ZernikeMagnitude_2_0': 0.03921126875784057,\n", + " 'RadialDistribution_ZernikePhase_2_0': -1.5707963267948966,\n", + " 'RadialDistribution_ZernikeMagnitude_2_2': 0.021367212204621656,\n", + " 'RadialDistribution_ZernikePhase_2_2': -1.7968203888307215,\n", + " 'RadialDistribution_ZernikeMagnitude_3_1': 0.001838356307222254,\n", + " 'RadialDistribution_ZernikePhase_3_1': -1.0177882118086117,\n", + " 'RadialDistribution_ZernikeMagnitude_3_3': 0.003958387645755281,\n", + " 'RadialDistribution_ZernikePhase_3_3': 1.6682324062429792,\n", + " 'RadialDistribution_ZernikeMagnitude_4_0': 0.003033062350649712,\n", + " 'RadialDistribution_ZernikePhase_4_0': -1.5707963267948966,\n", + " 'RadialDistribution_ZernikeMagnitude_4_2': 0.0052313049291743755,\n", + " 'RadialDistribution_ZernikePhase_4_2': 3.1362711979406352,\n", + " 'RadialDistribution_ZernikeMagnitude_4_4': 0.003932429008325735,\n", + " 'RadialDistribution_ZernikePhase_4_4': -0.12310362129175532,\n", + " 'RadialDistribution_ZernikeMagnitude_5_1': 0.0054204313543666635,\n", + " 'RadialDistribution_ZernikePhase_5_1': -1.6765144306086568,\n", + " 'RadialDistribution_ZernikeMagnitude_5_3': 0.0035340323334669284,\n", + " 'RadialDistribution_ZernikePhase_5_3': -2.052629685900433,\n", + " 'RadialDistribution_ZernikeMagnitude_5_5': 0.0020836794301104917,\n", + " 'RadialDistribution_ZernikePhase_5_5': -1.5868913282604633,\n", + " 'RadialDistribution_ZernikeMagnitude_6_0': 0.001385507275128227,\n", + " 'RadialDistribution_ZernikePhase_6_0': 1.5707963267948966,\n", + " 'RadialDistribution_ZernikeMagnitude_6_2': 0.005491586850404265,\n", + " 'RadialDistribution_ZernikePhase_6_2': 2.201077433541965,\n", + " 'RadialDistribution_ZernikeMagnitude_6_4': 0.0036085512913913657,\n", + " 'RadialDistribution_ZernikePhase_6_4': 0.2214689916624646,\n", + " 'RadialDistribution_ZernikeMagnitude_6_6': 0.005747255882206648,\n", + " 'RadialDistribution_ZernikePhase_6_6': 1.4277378359300132,\n", + " 'RadialDistribution_ZernikeMagnitude_7_1': 0.0009375924308202778,\n", + " 'RadialDistribution_ZernikePhase_7_1': -0.7529966882026068,\n", + " 'RadialDistribution_ZernikeMagnitude_7_3': 0.0002218182164961902,\n", + " 'RadialDistribution_ZernikePhase_7_3': -0.20403280290494366,\n", + " 'RadialDistribution_ZernikeMagnitude_7_5': 0.0005925047543621243,\n", + " 'RadialDistribution_ZernikePhase_7_5': -0.9307695398145165,\n", + " 'RadialDistribution_ZernikeMagnitude_7_7': 0.0018588126711148367,\n", + " 'RadialDistribution_ZernikePhase_7_7': 0.2832711677983217,\n", + " 'RadialDistribution_ZernikeMagnitude_8_0': 0.0008527682036573247,\n", + " 'RadialDistribution_ZernikePhase_8_0': -1.5707963267948966,\n", + " 'RadialDistribution_ZernikeMagnitude_8_2': 0.003849759799115769,\n", + " 'RadialDistribution_ZernikePhase_8_2': -3.0348094640147933,\n", + " 'RadialDistribution_ZernikeMagnitude_8_4': 0.006303111698169151,\n", + " 'RadialDistribution_ZernikePhase_8_4': -0.9421189397950538,\n", + " 'RadialDistribution_ZernikeMagnitude_8_6': 0.0025616333232286502,\n", + " 'RadialDistribution_ZernikePhase_8_6': 1.497974914859852,\n", + " 'RadialDistribution_ZernikeMagnitude_8_8': 0.003776997051549525,\n", + " 'RadialDistribution_ZernikePhase_8_8': -2.5121700003691703,\n", + " 'RadialDistribution_ZernikeMagnitude_9_1': 0.0022611754416345803,\n", + " 'RadialDistribution_ZernikePhase_9_1': 0.8411774061462731,\n", + " 'RadialDistribution_ZernikeMagnitude_9_3': 0.002471113405283529,\n", + " 'RadialDistribution_ZernikePhase_9_3': 1.5452326898185875,\n", + " 'RadialDistribution_ZernikeMagnitude_9_5': 0.0015248674586351724,\n", + " 'RadialDistribution_ZernikePhase_9_5': 2.3721537092690315,\n", + " 'RadialDistribution_ZernikeMagnitude_9_7': 0.0015615157569373382,\n", + " 'RadialDistribution_ZernikePhase_9_7': 0.884984882503327,\n", + " 'RadialDistribution_ZernikeMagnitude_9_9': 0.002886473828727781,\n", + " 'RadialDistribution_ZernikePhase_9_9': 1.849176431727321,\n", + " 'Intensity_IntegratedIntensity': 12.886274710297585,\n", + " 'Intensity_MeanIntensity': 0.1923324583626505,\n", + " 'Intensity_StdIntensity': 0.03206316775740464,\n", + " 'Intensity_MinIntensity': 0.0941176488995552,\n", + " 'Intensity_MaxIntensity': 0.24705882370471954,\n", + " 'Intensity_IntegratedIntensityEdge': 2.9333334118127823,\n", + " 'Intensity_MeanIntensityEdge': 0.15438596904277802,\n", + " 'Intensity_StdIntensityEdge': 0.02663418674171586,\n", + " 'Intensity_MinIntensityEdge': 0.0941176488995552,\n", + " 'Intensity_MaxIntensityEdge': 0.1921568661928177,\n", + " 'Intensity_MassDisplacement': 0.16251187319410354,\n", + " 'Intensity_LowerQuartileIntensity': 0.1725490242242813,\n", + " 'Intensity_MedianIntensity': 0.19607843458652496,\n", + " 'Intensity_MADIntensity': 0.019607841968536377,\n", + " 'Intensity_UpperQuartileIntensity': 0.21274510025978088,\n", + " 'Location_CenterMassIntensity_X': 30.4650030464223,\n", + " 'Location_CenterMassIntensity_Y': 2.8384053606856545,\n", + " 'Location_CenterMassIntensity_Z': 0.0,\n", + " 'Location_MaxIntensity_X': 31.0,\n", + " 'Location_MaxIntensity_Y': 4.0,\n", + " 'Location_MaxIntensity_Z': 0.0,\n", + " 'Area': 67.0,\n", + " 'BoundingBoxArea': 80.0,\n", + " 'ConvexArea': 69.0,\n", + " 'EquivalentDiameter': 9.23618154310838,\n", + " 'Perimeter': 28.48528137423857,\n", + " 'MajorAxisLength': 10.812622747736366,\n", + " 'MinorAxisLength': 7.984982463349238,\n", + " 'Eccentricity': 0.6742676002273413,\n", + " 'Orientation': -81.37547433621928,\n", + " 'Center_X': 30.44776119402985,\n", + " 'Center_Y': 3.0,\n", + " 'BoundingBoxMinimum_X': 26.0,\n", + " 'BoundingBoxMaximum_X': 36.0,\n", + " 'BoundingBoxMinimum_Y': 0.0,\n", + " 'BoundingBoxMaximum_Y': 8.0,\n", + " 'FormFactor': 1.0376326751761262,\n", + " 'Extent': 0.8375,\n", + " 'Solidity': 0.9710144927536232,\n", + " 'Compactness': 0.9637321799164251,\n", + " 'EulerNumber': 1.0,\n", + " 'MaximumRadius': 4.0,\n", + " 'MeanRadius': 1.8721985134555739,\n", + " 'MedianRadius': 2.0,\n", + " 'FilledArea': 67.0,\n", + " 'SpatialMoment_0_0': 67.0,\n", + " 'SpatialMoment_0_1': 298.0,\n", + " 'SpatialMoment_0_2': 1810.0,\n", + " 'SpatialMoment_0_3': 12394.0,\n", + " 'SpatialMoment_1_0': 201.0,\n", + " 'SpatialMoment_1_1': 861.0,\n", + " 'SpatialMoment_1_2': 4997.0,\n", + " 'SpatialMoment_1_3': 32757.0,\n", + " 'SpatialMoment_2_0': 875.0,\n", + " 'SpatialMoment_2_1': 3699.0,\n", + " 'SpatialMoment_2_2': 20699.0,\n", + " 'SpatialMoment_2_3': 130635.0,\n", + " 'CentralMoment_0_0': 67.0,\n", + " 'CentralMoment_0_1': -2.6645352591003757e-15,\n", + " 'CentralMoment_0_2': 484.56716417910457,\n", + " 'CentralMoment_0_3': 33.07418133214526,\n", + " 'CentralMoment_1_0': 0.0,\n", + " 'CentralMoment_1_1': -33.0,\n", + " 'CentralMoment_1_2': -139.44776119402985,\n", + " 'CentralMoment_1_3': -605.8335932278903,\n", + " 'CentralMoment_2_0': 272.0,\n", + " 'CentralMoment_2_1': 5.208955223880593,\n", + " 'CentralMoment_2_2': 1579.801960347516,\n", + " 'CentralMoment_2_3': 317.32703490788424,\n", + " 'NormalizedMoment_0_0': nan,\n", + " 'NormalizedMoment_0_1': nan,\n", + " 'NormalizedMoment_0_2': 0.10794545871666397,\n", + " 'NormalizedMoment_0_3': 0.0009001234920668009,\n", + " 'NormalizedMoment_1_0': nan,\n", + " 'NormalizedMoment_1_1': -0.007351303185564714,\n", + " 'NormalizedMoment_1_2': -0.0037951114951671576,\n", + " 'NormalizedMoment_1_3': -0.002014322217918728,\n", + " 'NormalizedMoment_2_0': 0.06059255959010915,\n", + " 'NormalizedMoment_2_1': 0.00014176323577152274,\n", + " 'NormalizedMoment_2_2': 0.005252647301521517,\n", + " 'NormalizedMoment_2_3': 0.00012889772855680416,\n", + " 'NormalizedMoment_3_0': 0.0017962092509503553,\n", + " 'NormalizedMoment_3_1': -0.0008264056376813975,\n", + " 'NormalizedMoment_3_2': -0.00041986624857065264,\n", + " 'NormalizedMoment_3_3': -0.0002236573054902451,\n", + " 'HuMoment_0': 0.16853801830677312,\n", + " 'HuMoment_1': 0.002458463689794052,\n", + " 'HuMoment_2': 0.00017397856239913457,\n", + " 'HuMoment_3': 5.0811381355806185e-06,\n", + " 'HuMoment_4': -2.486544707014142e-11,\n", + " 'HuMoment_5': -7.656066027044657e-08,\n", + " 'HuMoment_6': -1.4901350790510987e-10,\n", + " 'InertiaTensor_0_0': 7.232345734016486,\n", + " 'InertiaTensor_0_1': 0.4925373134328358,\n", + " 'InertiaTensor_1_0': 0.4925373134328358,\n", + " 'InertiaTensor_1_1': 4.059701492537314,\n", + " 'InertiaTensorEigenvalues_0': 7.307050667804121,\n", + " 'InertiaTensorEigenvalues_1': 3.984996558749679,\n", + " 'PerimeterCrofton': 29.68725722470835,\n", + " 'Zernike_0_0': 0.8047834858231687,\n", + " 'Zernike_1_1': 0.07859294567727422,\n", + " 'Zernike_2_0': 0.10357252971590757,\n", + " 'Zernike_2_2': 0.09426112239369118,\n", + " 'Zernike_3_1': 0.006369960556240697,\n", + " 'Zernike_3_3': 0.01623671065645129,\n", + " 'Zernike_4_0': 0.01839170349317207,\n", + " 'Zernike_4_2': 0.028945327583356772,\n", + " 'Zernike_4_4': 0.021565363485149504,\n", + " 'Zernike_5_1': 0.027504908646509528,\n", + " 'Zernike_5_3': 0.02115092872161993,\n", + " 'Zernike_5_5': 0.00891394341624542,\n", + " 'Zernike_6_0': 0.0027437527064452967,\n", + " 'Zernike_6_2': 0.02624280085981392,\n", + " 'Zernike_6_4': 0.02192144768776064,\n", + " 'Zernike_6_6': 0.03439788893524723,\n", + " 'Zernike_7_1': 0.005194540482196825,\n", + " 'Zernike_7_3': 0.0056451257446250135,\n", + " 'Zernike_7_5': 0.0034909496903208683,\n", + " 'Zernike_7_7': 0.011190208525527691,\n", + " 'Zernike_8_0': 0.002181539232060978,\n", + " 'Zernike_8_2': 0.020158154688774976,\n", + " 'Zernike_8_4': 0.03731167927710452,\n", + " 'Zernike_8_6': 0.016793489759696374,\n", + " 'Zernike_8_8': 0.02117319802226603,\n", + " 'Zernike_9_1': 0.007615647847177336,\n", + " 'Zernike_9_3': 0.0045800564257302764,\n", + " 'Zernike_9_5': 0.0016030454771965594,\n", + " 'Zernike_9_7': 0.004545190441797106,\n", + " 'Zernike_9_9': 0.013909796226327613,\n", + " 'MinFeretDiameter': 7.0,\n", + " 'MaxFeretDiameter': 10.295630140987,\n", + " 'AngularSecondMoment_3_00_256': 0.014204545454545442,\n", + " 'Contrast_3_00_256': 91.8409090909091,\n", + " 'Correlation_3_00_256': 0.0709738096792914,\n", + " 'Variance_3_00_256': 49.42858987603222,\n", + " 'InverseDifferenceMoment_3_00_256': 0.1243163038356934,\n", + " 'SumAverage_3_00_256': 102.38636363636365,\n", + " 'SumVariance_3_00_256': 105.87345041322078,\n", + " 'SumEntropy_3_00_256': 4.37137927816168,\n", + " 'Entropy_3_00_256': 6.237729629951767,\n", + " 'DifferenceVariance_3_00_256': 0.0011601723915289257,\n", + " 'DifferenceEntropy_3_00_256': 3.7591419842479024,\n", + " 'InfoMeas1_3_00_256': -0.5420221749233054,\n", + " 'InfoMeas2_3_00_256': 0.9951493023787886,\n", + " 'AngularSecondMoment_3_01_256': 0.019230769230769235,\n", + " 'Contrast_3_01_256': 126.23076923076924,\n", + " 'Correlation_3_01_256': -0.05878849542148152,\n", + " 'Variance_3_01_256': 59.610946745562615,\n", + " 'InverseDifferenceMoment_3_01_256': 0.06820697080582802,\n", + " 'SumAverage_3_01_256': 101.30769230769232,\n", + " 'SumVariance_3_01_256': 112.21301775147731,\n", + " 'SumEntropy_3_01_256': 4.209867121904035,\n", + " 'Entropy_3_01_256': 5.700439718141092,\n", + " 'DifferenceVariance_3_01_256': 0.000957782451923077,\n", + " 'DifferenceEntropy_3_01_256': 3.8441065448145375,\n", + " 'InfoMeas1_3_01_256': -0.6414090005358515,\n", + " 'InfoMeas2_3_01_256': 0.9976992127888944,\n", + " 'AngularSecondMoment_3_02_256': 0.016800584368151943,\n", + " 'Contrast_3_02_256': 148.4864864864865,\n", + " 'Correlation_3_02_256': -0.09997727297324675,\n", + " 'Variance_3_02_256': 67.49525200876496,\n", + " 'InverseDifferenceMoment_3_02_256': 0.1597853274210485,\n", + " 'SumAverage_3_02_256': 100.27027027027029,\n", + " 'SumVariance_3_02_256': 121.49452154857318,\n", + " 'SumEntropy_3_02_256': 4.499597622210291,\n", + " 'Entropy_3_02_256': 5.966210122385705,\n", + " 'DifferenceVariance_3_02_256': 0.000999924385956903,\n", + " 'DifferenceEntropy_3_02_256': 3.841096866085959,\n", + " 'InfoMeas1_3_02_256': -0.6279322068987813,\n", + " 'InfoMeas2_3_02_256': 0.9978729133307551,\n", + " 'AngularSecondMoment_3_03_256': 0.019619500594530312,\n", + " 'Contrast_3_03_256': 190.9310344827586,\n", + " 'Correlation_3_03_256': -0.3061671052470948,\n", + " 'Variance_3_03_256': 73.08828775267602,\n", + " 'InverseDifferenceMoment_3_03_256': 0.0707941830046325,\n", + " 'SumAverage_3_03_256': 99.48275862068965,\n", + " 'SumVariance_3_03_256': 101.42211652794322,\n", + " 'SumEntropy_3_03_256': 4.28022625367366,\n", + " 'Entropy_3_03_256': 5.720049960644815,\n", + " 'DifferenceVariance_3_03_256': 0.0007777083642984543,\n", + " 'DifferenceEntropy_3_03_256': 4.090234012145144,\n", + " 'InfoMeas1_3_03_256': -0.6658470534053287,\n", + " 'InfoMeas2_3_03_256': 0.9983414731315025,\n", + " 'Granularity_1': 1.1564210938463995,\n", + " 'Granularity_2': 3.590991817733586,\n", + " 'Granularity_3': 6.482044552349607,\n", + " 'Granularity_4': 13.20754617708793,\n", + " 'Granularity_5': 51.065124576064726,\n", + " 'Granularity_6': 71.45465632552134,\n", + " 'Granularity_7': 77.57151526928787,\n", + " 'Granularity_8': 79.61046825054338,\n", + " 'Granularity_9': 79.61046825054338,\n", + " 'Granularity_10': 79.61046825054338,\n", + " 'Granularity_11': 79.61046825054338,\n", + " 'Granularity_12': 79.61046825054338,\n", + " 'Granularity_13': 79.61046825054338,\n", + " 'Granularity_14': 79.61046825054338,\n", + " 'Granularity_15': 79.61046825054338,\n", + " 'Granularity_16': 81.6494212317989}" ] }, - "execution_count": 8, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# show the images table\n", - "db.open_table(\"images\").to_pandas()" + "db.open_table(\"compartment_nuclei\").to_pandas().iloc[0].to_dict()" ] }, { "cell_type": "code", - "execution_count": 9, - "id": "38a4b903-0151-4cdc-9e9b-cfabcb34680b", + "execution_count": 8, + "id": "e5cdd20c-0a03-4e8d-a4f0-3928e59d203f", "metadata": {}, "outputs": [ { @@ -972,60 +1319,55 @@ " \n", " \n", " \n", - " filename\n", - " algo_name\n", - " algo_version\n", - " model_type\n", - " channels\n", - " n_objects\n", - " height\n", - " width\n", - " dtype\n", - " image\n", + " ome-arrow_original\n", + " ome-arrow_mask\n", " \n", " \n", " \n", " \n", " 0\n", - " AS_09125_050116030001_D03f00d0.tif\n", - " cellpose\n", - " 4.0.6\n", - " nuclei\n", - " (0, 0)\n", - " 329\n", - " 512\n", - " 512\n", - " int32\n", - " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...\n", + " {'type': 'ome.arrow', 'version': '0.0.1', 'id'...\n", + " {'type': 'ome.arrow', 'version': '0.0.1', 'id'...\n", + " \n", + " \n", + " 1\n", + " {'type': 'ome.arrow', 'version': '0.0.1', 'id'...\n", + " {'type': 'ome.arrow', 'version': '0.0.1', 'id'...\n", + " \n", + " \n", + " 2\n", + " {'type': 'ome.arrow', 'version': '0.0.1', 'id'...\n", + " {'type': 'ome.arrow', 'version': '0.0.1', 'id'...\n", " \n", " \n", "\n", "" ], "text/plain": [ - " filename algo_name algo_version model_type \\\n", - "0 AS_09125_050116030001_D03f00d0.tif cellpose 4.0.6 nuclei \n", - "\n", - " channels n_objects height width dtype \\\n", - "0 (0, 0) 329 512 512 int32 \n", + " ome-arrow_original \\\n", + "0 {'type': 'ome.arrow', 'version': '0.0.1', 'id'... \n", + "1 {'type': 'ome.arrow', 'version': '0.0.1', 'id'... \n", + "2 {'type': 'ome.arrow', 'version': '0.0.1', 'id'... \n", "\n", - " image \n", - "0 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ... " + " ome-arrow_mask \n", + "0 {'type': 'ome.arrow', 'version': '0.0.1', 'id'... \n", + "1 {'type': 'ome.arrow', 'version': '0.0.1', 'id'... \n", + "2 {'type': 'ome.arrow', 'version': '0.0.1', 'id'... " ] }, - "execution_count": 9, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# show the images table\n", - "db.open_table(\"masks\").to_pandas()" + "db.open_table(\"images\").to_pandas()" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "id": "118dcf01-c4a4-46a6-88b0-0ec694d9efa9", "metadata": {}, "outputs": [ @@ -1041,20 +1383,27 @@ } ], "source": [ - "show_images_from_lance(db_path=LANCE_DIR, table_name=\"images\", col_name=\"ome-arrow_original\", max_images=4, pick=\"first\", cmap=\"gray\")" + "show_images_from_lance(\n", + " db_path=LANCE_DIR,\n", + " table_name=\"images\",\n", + " col_name=\"ome-arrow_original\",\n", + " max_images=4,\n", + " pick=\"first\",\n", + " cmap=\"gray\",\n", + ")" ] }, { "cell_type": "code", - "execution_count": 11, - "id": "b8892f7b-3c1f-44e2-8745-2f1136c1a47c", + "execution_count": 10, + "id": "d059d02c-9789-440e-8708-7eb04dbe3b38", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -1062,12 +1411,16 @@ } ], "source": [ - "for _, row in db.open_table(\"masks\").to_pandas().iterrows():\n", - " mask = np.array(row[\"image\"], dtype=np.int32).reshape(row[\"height\"], row[\"width\"])\n", - " plt.imshow(mask, cmap=\"gray\", vmin=0, vmax=1)\n", - " plt.title(f\"Mask ({row['algo_name']} {row['algo_version']}): {row['filename']}\")\n", - " plt.axis(\"off\")\n", - " plt.show()" + "show_images_from_lance(\n", + " db_path=LANCE_DIR,\n", + " table_name=\"images\",\n", + " col_name=\"ome-arrow_mask\",\n", + " max_images=4,\n", + " pick=\"first\",\n", + " cmap=\"gray\",\n", + " vmin=0,\n", + " vmax=1,\n", + ")" ] } ], diff --git a/src/serpula_rasa/example.py b/src/serpula_rasa/example.py index de8126b..a035b55 100644 --- a/src/serpula_rasa/example.py +++ b/src/serpula_rasa/example.py @@ -33,6 +33,7 @@ import shutil import subprocess import tempfile +from datetime import datetime, timezone from pathlib import Path from pprint import pp from shutil import copy2, copytree @@ -44,8 +45,16 @@ import matplotlib.pyplot as plt import numpy as np import pandas as pd +import pyarrow as pa from cellpose import models as cp_models -from serpula_rasa.image import ingest_ome_images_ome_arrow, show_images_from_lance + +from serpula_rasa.image import ( + ensure_ome_arrow_column, + ingest_ome_images_ome_arrow, + make_ome_arrow_row, + show_images_from_lance, +) +from serpula_rasa.meta import OME_ARROW_SCHEMA try: from cellpose import version as CP_VERSION @@ -250,53 +259,92 @@ def gather_profiles() -> None: # noqa: PLR0915, C901 if not images: raise SystemExit(f"No images found under: {IMAGES_DIR.resolve()}") - ome_tbl = ingest_ome_images_ome_arrow( - db=db, - col_name="ome-arrow_original", - table_name=TABLE_IMAGES, # reuse TABLE_IMAGES name - image_paths=images, # demo: first image only - prefer_dimension_order_xyzct=False, # 2D → "XYCT" hint - ) - print(f"[ome-arrow] stored {ome_tbl.count_rows()} image(s) in Lance") + # --- We will build both struct columns in the same index order --- + rows_combined = ( + [] + ) # each item will be {"ome-arrow_original": {...}, "ome-arrow_mask": {...}|None} - for img_path in [images[0]]: + for img_path in images: try: + # Load image (keep dtype); if multichannel HWC, pick channel 0 for demo parity img = iio.imread(img_path) - # match the ingestion’s channel handling if img.ndim == 3 and img.shape[-1] in (2, 3, 4): nuc_img = img[..., 0] else: nuc_img = img + # ---------- Build original image struct ---------- + img_struct = make_ome_arrow_row( + image_id=img_path.stem, + col_name="ome-arrow_original", + name=img_path.name, + pixels=nuc_img, + physical_size_xy_um=0.108, + physical_size_z_um=1.0, + physical_unit="µm", + prefer_dimension_order_xyzct=False, # 2D → "XYCT" hint + acquisition_dt=datetime.now(timezone.utc), + ) + + # ---------- Segment + build mask struct (same index as image) ---------- img_f = to_float01(nuc_img) - - # segment masks, diams = cellpose_eval(model, img_f, channels=CHANNELS) - # store masks (kept as flattened ints in existing table) - labels = np.unique(masks); labels = labels[labels > 0] + mask_struct = make_ome_arrow_row( + image_id=img_path.stem, + col_name="ome-arrow_mask", + name=f"{img_path.name} (mask)", + pixels=masks.astype(np.uint16, copy=False), + physical_size_xy_um=0.108, + physical_size_z_um=1.0, + physical_unit="µm", + prefer_dimension_order_xyzct=False, + acquisition_dt=datetime.now(timezone.utc), + ) + + # Collect a single row with both structs (aligned by index) + rows_combined.append( + { + "ome-arrow_original": img_struct["ome-arrow_original"], + "ome-arrow_mask": mask_struct["ome-arrow_mask"], + } + ) + + # ---------- Optional: keep your legacy masks/features tables ---------- + labels = np.unique(masks) + labels = labels[labels > 0] n_obj = int(labels.size) - mask_record = pd.DataFrame([{ - "filename": img_path.name, - "algo_name": "cellpose", - "algo_version": CP_VERSION, - "model_type": MODEL_TYPE, - "channels": str(CHANNELS), - "n_objects": n_obj, - "height": int(masks.shape[0]), - "width": int(masks.shape[1]), - "dtype": "int32", - "image": masks.astype(np.int32, copy=False).ravel(order="C").tolist(), - }]) + + mask_record = pd.DataFrame( + [ + { + "filename": img_path.name, + "algo_name": "cellpose", + "algo_version": CP_VERSION, + "model_type": MODEL_TYPE, + "channels": str(CHANNELS), + "n_objects": n_obj, + "height": int(masks.shape[0]), + "width": int(masks.shape[1]), + "dtype": "int32", + "image": masks.astype(np.int32, copy=False) + .ravel(order="C") + .tolist(), + } + ] + ) get_or_create_table(db, TABLE_MASKS, mask_record) - # features if n_obj < MIN_OBJECTS_TO_SAVE: - log_tbl.add([{ - "image_filename": str(img_path), - "status": "no_objects", - "n_objects": n_obj, - }]) + log_tbl.add( + [ + { + "image_filename": str(img_path), + "status": "no_objects", + "n_objects": n_obj, + } + ] + ) print(f"- {img_path.name}: no objects") continue @@ -307,12 +355,19 @@ def gather_profiles() -> None: # noqa: PLR0915, C901 rows = [] for i, obj_id in enumerate(labels, start=0): - row = {"image_filename": img_path.name, "nuclei_object_number": int(obj_id)} + row = { + "image_filename": img_path.name, + "nuclei_object_number": int(obj_id), + } for feat_name, arr in feature_arrays.items(): if i < len(arr): val = arr[i] try: - row[feat_name] = float(val) if np.ndim(val) == 0 else float(np.array(val).item()) + row[feat_name] = ( + float(val) + if np.ndim(val) == 0 + else float(np.array(val).item()) + ) except Exception: row[feat_name] = float("nan") rows.append(row) @@ -323,13 +378,46 @@ def gather_profiles() -> None: # noqa: PLR0915, C901 print(f"✓ {img_path.name}: {n_obj} objects") except Exception as ex: - log_tbl.add([{ - "image": str(img_path), - "status": f"error: {type(ex).__name__}: {ex}", - "n_objects": 0, - }]) + # If segmentation or anything else fails, still store original image row with mask=None + try: + if "img_struct" in locals(): + rows_combined.append( + { + "ome-arrow_original": img_struct["ome-arrow_original"], + "ome-arrow_mask": None, # nullable struct column will accept None + } + ) + except Exception: + pass + + log_tbl.add( + [ + { + "image": str(img_path), + "status": f"error: {type(ex).__name__}: {ex}", + "n_objects": 0, + } + ] + ) print(f"✗ {img_path.name}: {ex}") + # ---------- Materialize a two-column Arrow table (index-aligned) ---------- + # Reuse the canonical ome-arrow struct type for both columns. + struct_type = OME_ARROW_SCHEMA.field(0).type + schema_two_cols = pa.schema( + [ + pa.field("ome-arrow_original", struct_type), # nullable defaults to True + pa.field("ome-arrow_mask", struct_type), + ] + ) + arrow_tbl = pa.Table.from_pylist(rows_combined, schema=schema_two_cols) + + # ---------- Create/replace Lance table with both columns ---------- + if TABLE_IMAGES in set(db.table_names()): + db.drop_table(TABLE_IMAGES) + img_tbl = db.create_table(TABLE_IMAGES, data=arrow_tbl) + print(f"[ome-arrow] stored {img_tbl.count_rows()} row(s) in Lance (images + masks)") + # - @@ -340,20 +428,33 @@ def gather_profiles() -> None: # noqa: PLR0915, C901 db = lancedb.connect(LANCE_DIR) db.table_names() +# show nuclei features +db.open_table("run_log").to_pandas().iloc[0].to_dict() + # show nuclei features db.open_table("compartment_nuclei").to_pandas() -# show the images table -db.open_table("images").to_pandas() +db.open_table("compartment_nuclei").to_pandas().iloc[0].to_dict() # show the images table -db.open_table("masks").to_pandas() - -show_images_from_lance(db_path=LANCE_DIR, table_name="images", col_name="ome-arrow_original", max_images=4, pick="first", cmap="gray") +db.open_table("images").to_pandas() -for _, row in db.open_table("masks").to_pandas().iterrows(): - mask = np.array(row["image"], dtype=np.int32).reshape(row["height"], row["width"]) - plt.imshow(mask, cmap="gray", vmin=0, vmax=1) - plt.title(f"Mask ({row['algo_name']} {row['algo_version']}): {row['filename']}") - plt.axis("off") - plt.show() +show_images_from_lance( + db_path=LANCE_DIR, + table_name="images", + col_name="ome-arrow_original", + max_images=4, + pick="first", + cmap="gray", +) + +show_images_from_lance( + db_path=LANCE_DIR, + table_name="images", + col_name="ome-arrow_mask", + max_images=4, + pick="first", + cmap="gray", + vmin=0, + vmax=1, +) diff --git a/src/serpula_rasa/image.py b/src/serpula_rasa/image.py index b9b65ef..03d7c23 100644 --- a/src/serpula_rasa/image.py +++ b/src/serpula_rasa/image.py @@ -371,6 +371,8 @@ def show_images_from_lance( max_images: int = 8, pick: Literal["first", "center", "maxproj"] = "first", cmap: str = "gray", + vmin: Optional[float] = None, + vmax: Optional[float] = None, ) -> None: """ Display images stored as `ome_arrow` records in a LanceDB table. @@ -426,7 +428,7 @@ def show_images_from_lance( else: plane = img[0] - ax.imshow(plane, cmap=cmap) + ax.imshow(plane, cmap=cmap, vmin=vmin, vmax=vmax) ax.set_title(rec.get("name", f"record {i}")) ax.axis("off") @@ -500,4 +502,14 @@ def _flush() -> None: if lance_tbl is None: raise("No images ingested; check `image_paths`.") - return lance_tbl \ No newline at end of file + return lance_tbl + +# --- small helper to declare a new ome-arrow column schema on the table --- +def ensure_ome_arrow_column(tbl: lancedb.table.LanceTable, col_name: str) -> None: + # Reuse the struct type from your canonical OME_ARROW_SCHEMA + struct_type = OME_ARROW_SCHEMA.field(0).type + empty = pa.Table.from_pylist([], schema=pa.schema([pa.field(col_name, struct_type)])) + try: + tbl.add(empty) # extends schema without adding rows + except Exception: + pass # column probably exists already \ No newline at end of file From 3db35af072bd41f149d4d87cc873a84135910fbe Mon Sep 17 00:00:00 2001 From: d33bs Date: Wed, 1 Oct 2025 14:42:49 -0600 Subject: [PATCH 5/5] add crops and linting --- pyproject.toml | 18 +- src/serpula_rasa/example.ipynb | 647 ++++++++++++++------------------- src/serpula_rasa/example.py | 197 +++++++++- src/serpula_rasa/image.py | 175 +++++---- src/serpula_rasa/meta.py | 10 +- tests/conftest.py | 4 +- tests/test_image.py | 31 +- tests/utils.py | 8 +- 8 files changed, 609 insertions(+), 481 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 8443926..f93d1e0 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -34,15 +34,20 @@ dependencies = [ "scikit-image>=0.24", ] +[dependency-groups] +dev = [ + "pytest>=8.4.2", +] + +[tool.setuptools.packages.find] +where = [ "src" ] + [tool.setuptools_scm] root = "." version_scheme = "no-guess-dev" local_scheme = "no-local-version" version_file = "src/serpula_rasa/_version.py" -[tool.setuptools.packages.find] -where = ["src"] - [tool.ruff] target-version = "py311" line-length = 88 @@ -72,6 +77,8 @@ lint.select = [ ] lint.per-file-ignores."src/serpula_rasa/example.ipynb" = [ "PLR2004", "RUF059" ] lint.per-file-ignores."src/serpula_rasa/example.py" = [ "PLR2004", "RUF059" ] +lint.per-file-ignores."src/serpula_rasa/image.py" = [ "PLR2004", "RUF059" ] +lint.per-file-ignores."tests/*" = [ "ANN001", "ANN201", "PLR2004" ] [tool.pytest.ini_options] pythonpath = [ "." ] @@ -91,8 +98,3 @@ formats = "ipynb,py:light" [tool.vulture] min_confidence = 90 paths = [ "src/serpula_rasa" ] - -[dependency-groups] -dev = [ - "pytest>=8.4.2", -] diff --git a/src/serpula_rasa/example.ipynb b/src/serpula_rasa/example.ipynb index b734451..eb99ff1 100644 --- a/src/serpula_rasa/example.ipynb +++ b/src/serpula_rasa/example.ipynb @@ -55,21 +55,19 @@ "from pathlib import Path\n", "from pprint import pp\n", "from shutil import copy2, copytree\n", - "from typing import Dict, List, Tuple\n", + "from typing import Any, Dict, List, Optional, Tuple\n", "\n", "import cellpose\n", "import imageio.v3 as iio\n", "import lancedb\n", - "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import pandas as pd\n", "import pyarrow as pa\n", "from cellpose import models as cp_models\n", "\n", "from serpula_rasa.image import (\n", - " ensure_ome_arrow_column,\n", - " ingest_ome_images_ome_arrow,\n", " make_ome_arrow_row,\n", + " reconstruct_tczyx_from_record,\n", " show_images_from_lance,\n", ")\n", "from serpula_rasa.meta import OME_ARROW_SCHEMA\n", @@ -290,7 +288,7 @@ " return masks, diam_scalar\n", "\n", "\n", - "def gather_profiles() -> None: # noqa: PLR0915, C901\n", + "def gather_profiles() -> None: # noqa: PLR0915, C901, PLR0912\n", " # Connect LanceDB + ensure log table\n", " db = lancedb.connect(str(LANCE_DIR))\n", " ensure_log_table(db, TABLE_LOG)\n", @@ -305,13 +303,13 @@ " raise SystemExit(f\"No images found under: {IMAGES_DIR.resolve()}\")\n", "\n", " # --- We will build both struct columns in the same index order ---\n", - " rows_combined = (\n", - " []\n", - " ) # each item will be {\"ome-arrow_original\": {...}, \"ome-arrow_mask\": {...}|None}\n", + " rows_combined = [] # each item will be:\n", + " # {\"ome-arrow_original\": {...}, \"ome-arrow_mask\": {...}|None}\n", "\n", " for img_path in images:\n", " try:\n", - " # Load image (keep dtype); if multichannel HWC, pick channel 0 for demo parity\n", + " # Load image (keep dtype);\n", + " # if multichannel HWC, pick channel 0 for demo parity\n", " img = iio.imread(img_path)\n", " if img.ndim == 3 and img.shape[-1] in (2, 3, 4):\n", " nuc_img = img[..., 0]\n", @@ -350,6 +348,7 @@ " # Collect a single row with both structs (aligned by index)\n", " rows_combined.append(\n", " {\n", + " \"image_filename\": img_path.name,\n", " \"ome-arrow_original\": img_struct[\"ome-arrow_original\"],\n", " \"ome-arrow_mask\": mask_struct[\"ome-arrow_mask\"],\n", " }\n", @@ -423,13 +422,15 @@ " print(f\"✓ {img_path.name}: {n_obj} objects\")\n", "\n", " except Exception as ex:\n", - " # If segmentation or anything else fails, still store original image row with mask=None\n", + " # If segmentation or anything else fails,\n", + " # still store original image row with mask=None\n", " try:\n", " if \"img_struct\" in locals():\n", " rows_combined.append(\n", " {\n", " \"ome-arrow_original\": img_struct[\"ome-arrow_original\"],\n", - " \"ome-arrow_mask\": None, # nullable struct column will accept None\n", + " # nullable struct column will accept None\n", + " \"ome-arrow_mask\": None,\n", " }\n", " )\n", " except Exception:\n", @@ -446,22 +447,154 @@ " )\n", " print(f\"✗ {img_path.name}: {ex}\")\n", "\n", - " # ---------- Materialize a two-column Arrow table (index-aligned) ----------\n", - " # Reuse the canonical ome-arrow struct type for both columns.\n", + " # ---------- Materialize a table with both structs + filename ----------\n", " struct_type = OME_ARROW_SCHEMA.field(0).type\n", - " schema_two_cols = pa.schema(\n", + " schema_three_cols = pa.schema(\n", " [\n", - " pa.field(\"ome-arrow_original\", struct_type), # nullable defaults to True\n", + " pa.field(\"image_filename\", pa.string()), # top-level column\n", + " pa.field(\"ome-arrow_original\", struct_type),\n", " pa.field(\"ome-arrow_mask\", struct_type),\n", " ]\n", " )\n", - " arrow_tbl = pa.Table.from_pylist(rows_combined, schema=schema_two_cols)\n", "\n", - " # ---------- Create/replace Lance table with both columns ----------\n", + " # Each row now carries filename + both struct values\n", + " arrow_tbl = pa.Table.from_pylist(rows_combined, schema=schema_three_cols)\n", + "\n", + " # ---------- Create/replace Lance table ----------\n", " if TABLE_IMAGES in set(db.table_names()):\n", " db.drop_table(TABLE_IMAGES)\n", " img_tbl = db.create_table(TABLE_IMAGES, data=arrow_tbl)\n", - " print(f\"[ome-arrow] stored {img_tbl.count_rows()} row(s) in Lance (images + masks)\")" + " print(f\"[ome-arrow] stored {img_tbl.count_rows()} row(s) in Lance (images + masks)\")\n", + "\n", + "\n", + "def add_ome_crops_to_nuclei_table( # noqa: PLR0913\n", + " *,\n", + " db_path: Path,\n", + " images_table: str = \"images\",\n", + " nuclei_table: str = \"compartment_nuclei\",\n", + " image_struct_col: str = \"ome-arrow_original\", # where the full image sits\n", + " out_crop_col: str = \"ome-arrow_crop\", # new struct column to add\n", + " image_col: str = \"filename\", # top-level filename in images table\n", + " nuclei_col: str = \"image_filename\", # column in nuclei table\n", + " bbox_min_x: str = \"BoundingBoxMinimum_X\",\n", + " bbox_max_x: str = \"BoundingBoxMaximum_X\",\n", + " bbox_min_y: str = \"BoundingBoxMinimum_Y\",\n", + " bbox_max_y: str = \"BoundingBoxMaximum_Y\",\n", + " pad: int = 0, # optional padding (pixels) around the bbox\n", + " clamp_to_image: bool = True,\n", + " prefer_dimension_order_xyzct: bool = False, # 2D → \"XYCT\" hint\n", + ") -> lancedb.table.LanceTable:\n", + " \"\"\"\n", + " For each nucleus row with a bounding box, create an ome-arrow crop from the\n", + " corresponding source image and add it as a new struct column to the nuclei table.\n", + " Re-creates the nuclei table with an appended column in one shot.\n", + "\n", + " Requirements:\n", + " - The images table has one row per image and includes:\n", + " • a top-level string column `image_col` (e.g., 'filename')\n", + " • a struct column `image_struct_col` (e.g., 'ome-arrow_original')\n", + " - The nuclei table has per-object rows with:\n", + " • `nuclei_col` pointing to the source image filename\n", + " • bounding box columns (min/max X/Y) in pixel coordinates\n", + "\n", + " Returns\n", + " -------\n", + " LanceTable\n", + " The (re)created nuclei table with an extra ome-arrow crop column.\n", + " \"\"\"\n", + " db = lancedb.connect(str(db_path))\n", + "\n", + " # ---------- 1) Load images table: build a lookup by filename ----------\n", + " img_tbl = db.open_table(images_table)\n", + " imgs_arrow = img_tbl.to_arrow() # whole table\n", + " # Select only what we need\n", + " imgs_arrow = imgs_arrow.select([image_col, image_struct_col])\n", + "\n", + " # Build filename -> ome-arrow record mapping\n", + " image_by_name: Dict[str, Dict[str, Any]] = {}\n", + " for i in range(len(imgs_arrow)):\n", + " fname = imgs_arrow[image_col][i].as_py()\n", + " rec = imgs_arrow[image_struct_col][i].as_py()\n", + " image_by_name[fname] = rec\n", + "\n", + " # ---------- 2) Load nuclei table ----------\n", + " nuc_tbl = db.open_table(nuclei_table)\n", + " nuc_arrow = nuc_tbl.to_arrow() # keep all columns (we'll append one)\n", + "\n", + " # ---------- 3) Create crop structs aligned by row index ----------\n", + " struct_type = OME_ARROW_SCHEMA.field(0).type # reuse canonical struct type\n", + " crops: List[Optional[Dict[str, Any]]] = []\n", + "\n", + " for i in range(len(nuc_arrow)):\n", + " row = nuc_arrow.slice(i, 1)\n", + " # Read filename & bbox for this nucleus\n", + " fname = row[nuclei_col][0].as_py()\n", + " xmin = row[bbox_min_x][0].as_py()\n", + " xmax = row[bbox_max_x][0].as_py()\n", + " ymin = row[bbox_min_y][0].as_py()\n", + " ymax = row[bbox_max_y][0].as_py()\n", + "\n", + " # Missing filename or image? → no crop\n", + " src = image_by_name.get(fname)\n", + " if src is None:\n", + " crops.append(None)\n", + " continue\n", + "\n", + " # Reconstruct (T,C,Z,Y,X).\n", + " # Our images are typically 2D single-channel → (1,1,1,Y,X)\n", + " arr = reconstruct_tczyx_from_record(src)\n", + " slab = arr[0, 0] # (Z, Y, X) or (1, Y, X)\n", + "\n", + " # If you have Z-stacks, pick a policy; here take z=0\n", + " plane = slab[0]\n", + "\n", + " H, W = plane.shape[0], plane.shape[1]\n", + "\n", + " # Convert bbox to ints and pad\n", + " x0 = int(np.floor(xmin)) - pad\n", + " x1 = int(np.ceil(xmax)) + pad\n", + " y0 = int(np.floor(ymin)) - pad\n", + " y1 = int(np.ceil(ymax)) + pad\n", + "\n", + " if clamp_to_image:\n", + " x0 = max(0, x0)\n", + " y0 = max(0, y0)\n", + " x1 = min(W, x1)\n", + " y1 = min(H, y1)\n", + "\n", + " # Validate bbox\n", + " if x1 <= x0 or y1 <= y0:\n", + " crops.append(None)\n", + " continue\n", + "\n", + " crop = plane[y0:y1, x0:x1] # (h, w), numeric\n", + "\n", + " # Build the ome-arrow struct for the crop\n", + " # Use the nucleus row index or a composite for uniqueness\n", + " crop_id = f\"{fname}__row{i}\"\n", + " crop_struct = make_ome_arrow_row(\n", + " image_id=crop_id,\n", + " col_name=out_crop_col,\n", + " name=f\"{fname} [y{x0}:{x1}, x{y0}:{y1}]\",\n", + " pixels=crop,\n", + " physical_size_xy_um=src[\"pixels_meta\"][\"physical_size_x\"],\n", + " physical_size_z_um=src[\"pixels_meta\"][\"physical_size_z\"],\n", + " physical_unit=src[\"pixels_meta\"][\"physical_size_x_unit\"],\n", + " prefer_dimension_order_xyzct=prefer_dimension_order_xyzct,\n", + " acquisition_dt=datetime.now(timezone.utc),\n", + " )\n", + " crops.append(crop_struct[out_crop_col])\n", + "\n", + " # ---------- 4) Append the new struct column and (re)create Lance table ----------\n", + " crop_array = pa.array(crops, type=struct_type) # nullable ok\n", + " new_nuc_arrow = nuc_arrow.append_column(out_crop_col, crop_array)\n", + "\n", + " # Recreate the table atomically (simple & robust)\n", + " if nuclei_table in set(db.table_names()):\n", + " db.drop_table(nuclei_table)\n", + " new_tbl = db.create_table(nuclei_table, data=new_nuc_arrow)\n", + "\n", + " return new_tbl" ] }, { @@ -504,8 +637,8 @@ "[lancedb] Recreating table 'images' with current schema.\n", "✓ AS_09125_050116030001_D03f00d2.tif: 307 objects\n", "[ome-arrow] stored 3 row(s) in Lance (images + masks)\n", - "CPU times: user 8.08 s, sys: 1.94 s, total: 10 s\n", - "Wall time: 18.3 s\n" + "CPU times: user 8.06 s, sys: 1.9 s, total: 9.95 s\n", + "Wall time: 18.1 s\n" ] } ], @@ -518,6 +651,35 @@ { "cell_type": "code", "execution_count": 5, + "id": "97484a31-e9e8-40c0-9fb0-a70ff114037f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 1.32 s, sys: 66.2 ms, total: 1.38 s\n", + "Wall time: 1.35 s\n" + ] + } + ], + "source": [ + "%%time\n", + "# add nuclei object image crops as ome-arrow images\n", + "_ = add_ome_crops_to_nuclei_table(\n", + " db_path=LANCE_DIR,\n", + " images_table=TABLE_IMAGES, # your images table\n", + " nuclei_table=TABLE_FEATURES, # if your nuclei/objects live here\n", + " image_struct_col=\"ome-arrow_original\", # the source image struct\n", + " out_crop_col=\"ome-arrow_crop\", # new column to add\n", + " image_col=\"image_filename\", # in images table\n", + " nuclei_col=\"image_filename\", # in nuclei table\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, "id": "1c80deb6-b53a-4eb9-ba33-f6b30c3b9edf", "metadata": {}, "outputs": [ @@ -527,7 +689,7 @@ "['compartment_nuclei', 'images', 'run_log']" ] }, - "execution_count": 5, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -539,7 +701,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "3f0e7ba9-354f-4b59-8e27-b63b8d458bb3", "metadata": {}, "outputs": [ @@ -551,7 +713,7 @@ " 'n_objects': 329}" ] }, - "execution_count": 6, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -563,7 +725,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "8b91158f-8e3e-4b2d-b52f-407546a94c18", "metadata": {}, "outputs": [ @@ -599,7 +761,6 @@ " RadialDistribution_FracAtD_3of4\n", " RadialDistribution_MeanFrac_3of4\n", " ...\n", - " Granularity_7\n", " Granularity_8\n", " Granularity_9\n", " Granularity_10\n", @@ -609,6 +770,7 @@ " Granularity_14\n", " Granularity_15\n", " Granularity_16\n", + " ome-arrow_crop\n", " \n", " \n", " \n", @@ -625,7 +787,6 @@ " 0.355143\n", " 1.081572\n", " ...\n", - " 77.571515\n", " 79.610468\n", " 79.610468\n", " 79.610468\n", @@ -635,6 +796,7 @@ " 79.610468\n", " 79.610468\n", " 81.649421\n", + " {'type': 'ome.arrow', 'version': '0.0.1', 'id'...\n", " \n", " \n", " 1\n", @@ -649,7 +811,6 @@ " 0.382765\n", " 1.059279\n", " ...\n", - " 59.562322\n", " 70.884871\n", " 74.119885\n", " 75.737394\n", @@ -659,6 +820,7 @@ " 77.354901\n", " 77.354901\n", " 77.354901\n", + " {'type': 'ome.arrow', 'version': '0.0.1', 'id'...\n", " \n", " \n", " 2\n", @@ -676,13 +838,13 @@ " 73.443983\n", " 73.443983\n", " 73.443983\n", - " 73.443983\n", " 75.103735\n", " 75.103735\n", " 75.103735\n", " 75.103735\n", " 76.763486\n", " 76.763486\n", + " {'type': 'ome.arrow', 'version': '0.0.1', 'id'...\n", " \n", " \n", " 3\n", @@ -700,13 +862,13 @@ " 82.297598\n", " 82.297598\n", " 82.297598\n", - " 82.297598\n", " 83.906908\n", " 83.906908\n", " 83.906908\n", " 83.906908\n", " 83.906908\n", " 85.516217\n", + " {'type': 'ome.arrow', 'version': '0.0.1', 'id'...\n", " \n", " \n", " 4\n", @@ -721,7 +883,6 @@ " 0.374818\n", " 1.041160\n", " ...\n", - " 67.201165\n", " 69.023322\n", " 69.023322\n", " 70.845480\n", @@ -731,6 +892,7 @@ " 72.667639\n", " 74.489796\n", " 74.489796\n", + " {'type': 'ome.arrow', 'version': '0.0.1', 'id'...\n", " \n", " \n", " ...\n", @@ -769,7 +931,6 @@ " 0.346612\n", " 1.064595\n", " ...\n", - " 78.743820\n", " 83.745275\n", " 84.995638\n", " 87.496365\n", @@ -779,6 +940,7 @@ " 88.746729\n", " 88.746729\n", " 88.746729\n", + " {'type': 'ome.arrow', 'version': '0.0.1', 'id'...\n", " \n", " \n", " 325\n", @@ -793,7 +955,6 @@ " 0.416237\n", " 1.040593\n", " ...\n", - " 84.536083\n", " 85.824742\n", " 85.824742\n", " 87.113402\n", @@ -803,6 +964,7 @@ " 88.402062\n", " 88.402062\n", " 88.402062\n", + " {'type': 'ome.arrow', 'version': '0.0.1', 'id'...\n", " \n", " \n", " 326\n", @@ -818,7 +980,6 @@ " 1.006676\n", " ...\n", " 83.615137\n", - " 83.615137\n", " 85.104670\n", " 85.104670\n", " 85.104670\n", @@ -827,6 +988,7 @@ " 85.104670\n", " 85.104670\n", " 85.104670\n", + " {'type': 'ome.arrow', 'version': '0.0.1', 'id'...\n", " \n", " \n", " 327\n", @@ -841,7 +1003,6 @@ " 0.402435\n", " 1.034833\n", " ...\n", - " 74.433547\n", " 79.303347\n", " 82.955699\n", " 84.173149\n", @@ -851,6 +1012,7 @@ " 86.608049\n", " 86.608049\n", " 86.608049\n", + " {'type': 'ome.arrow', 'version': '0.0.1', 'id'...\n", " \n", " \n", " 328\n", @@ -865,7 +1027,6 @@ " 0.345004\n", " 1.058012\n", " ...\n", - " 72.856019\n", " 76.475217\n", " 78.284815\n", " 78.284815\n", @@ -875,10 +1036,11 @@ " 78.284815\n", " 78.284815\n", " 78.284815\n", + " {'type': 'ome.arrow', 'version': '0.0.1', 'id'...\n", " \n", " \n", "\n", - "

329 rows × 273 columns

\n", + "

329 rows × 274 columns

\n", "" ], "text/plain": [ @@ -947,49 +1109,49 @@ "327 0.402435 1.034833 ... \n", "328 0.345004 1.058012 ... \n", "\n", - " Granularity_7 Granularity_8 Granularity_9 Granularity_10 \\\n", - "0 77.571515 79.610468 79.610468 79.610468 \n", - "1 59.562322 70.884871 74.119885 75.737394 \n", - "2 73.443983 73.443983 73.443983 73.443983 \n", - "3 82.297598 82.297598 82.297598 82.297598 \n", - "4 67.201165 69.023322 69.023322 70.845480 \n", - ".. ... ... ... ... \n", - "324 78.743820 83.745275 84.995638 87.496365 \n", - "325 84.536083 85.824742 85.824742 87.113402 \n", - "326 83.615137 83.615137 85.104670 85.104670 \n", - "327 74.433547 79.303347 82.955699 84.173149 \n", - "328 72.856019 76.475217 78.284815 78.284815 \n", + " Granularity_8 Granularity_9 Granularity_10 Granularity_11 \\\n", + "0 79.610468 79.610468 79.610468 79.610468 \n", + "1 70.884871 74.119885 75.737394 77.354901 \n", + "2 73.443983 73.443983 73.443983 75.103735 \n", + "3 82.297598 82.297598 82.297598 83.906908 \n", + "4 69.023322 69.023322 70.845480 72.667639 \n", + ".. ... ... ... ... \n", + "324 83.745275 84.995638 87.496365 88.746729 \n", + "325 85.824742 85.824742 87.113402 88.402062 \n", + "326 83.615137 85.104670 85.104670 85.104670 \n", + "327 79.303347 82.955699 84.173149 85.390599 \n", + "328 76.475217 78.284815 78.284815 78.284815 \n", "\n", - " Granularity_11 Granularity_12 Granularity_13 Granularity_14 \\\n", + " Granularity_12 Granularity_13 Granularity_14 Granularity_15 \\\n", "0 79.610468 79.610468 79.610468 79.610468 \n", "1 77.354901 77.354901 77.354901 77.354901 \n", - "2 75.103735 75.103735 75.103735 75.103735 \n", + "2 75.103735 75.103735 75.103735 76.763486 \n", "3 83.906908 83.906908 83.906908 83.906908 \n", - "4 72.667639 72.667639 72.667639 72.667639 \n", + "4 72.667639 72.667639 72.667639 74.489796 \n", ".. ... ... ... ... \n", "324 88.746729 88.746729 88.746729 88.746729 \n", "325 88.402062 88.402062 88.402062 88.402062 \n", "326 85.104670 85.104670 85.104670 85.104670 \n", - "327 85.390599 85.390599 86.608049 86.608049 \n", + "327 85.390599 86.608049 86.608049 86.608049 \n", "328 78.284815 78.284815 78.284815 78.284815 \n", "\n", - " Granularity_15 Granularity_16 \n", - "0 79.610468 81.649421 \n", - "1 77.354901 77.354901 \n", - "2 76.763486 76.763486 \n", - "3 83.906908 85.516217 \n", - "4 74.489796 74.489796 \n", - ".. ... ... \n", - "324 88.746729 88.746729 \n", - "325 88.402062 88.402062 \n", - "326 85.104670 85.104670 \n", - "327 86.608049 86.608049 \n", - "328 78.284815 78.284815 \n", + " Granularity_16 ome-arrow_crop \n", + "0 81.649421 {'type': 'ome.arrow', 'version': '0.0.1', 'id'... \n", + "1 77.354901 {'type': 'ome.arrow', 'version': '0.0.1', 'id'... \n", + "2 76.763486 {'type': 'ome.arrow', 'version': '0.0.1', 'id'... \n", + "3 85.516217 {'type': 'ome.arrow', 'version': '0.0.1', 'id'... \n", + "4 74.489796 {'type': 'ome.arrow', 'version': '0.0.1', 'id'... \n", + ".. ... ... \n", + "324 88.746729 {'type': 'ome.arrow', 'version': '0.0.1', 'id'... \n", + "325 88.402062 {'type': 'ome.arrow', 'version': '0.0.1', 'id'... \n", + "326 85.104670 {'type': 'ome.arrow', 'version': '0.0.1', 'id'... \n", + "327 86.608049 {'type': 'ome.arrow', 'version': '0.0.1', 'id'... \n", + "328 78.284815 {'type': 'ome.arrow', 'version': '0.0.1', 'id'... \n", "\n", - "[329 rows x 273 columns]" + "[329 rows x 274 columns]" ] }, - "execution_count": 7, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -1001,300 +1163,7 @@ }, { "cell_type": "code", - "execution_count": 13, - "id": "9d684b77-902f-4f74-a065-4fb7a3646ab0", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'image_filename': 'AS_09125_050116030001_D03f00d0.tif',\n", - " 'nuclei_object_number': 1,\n", - " 'RadialDistribution_FracAtD_1of4': 0.06695069372653961,\n", - " 'RadialDistribution_MeanFrac_1of4': 1.1214241199195343,\n", - " 'RadialDistribution_RadialCV_1of4': 0.014845391354877498,\n", - " 'RadialDistribution_FracAtD_2of4': 0.2513694167137146,\n", - " 'RadialDistribution_MeanFrac_2of4': 1.1227833946545906,\n", - " 'RadialDistribution_RadialCV_2of4': 0.06571046148222312,\n", - " 'RadialDistribution_FracAtD_3of4': 0.3551430404186249,\n", - " 'RadialDistribution_MeanFrac_3of4': 1.0815719867294478,\n", - " 'RadialDistribution_RadialCV_3of4': 0.04375997205831381,\n", - " 'RadialDistribution_FracAtD_4of4': 0.3265368342399597,\n", - " 'RadialDistribution_MeanFrac_4of4': 0.8414603036183572,\n", - " 'RadialDistribution_RadialCV_4of4': 0.08206160591378724,\n", - " 'RadialDistribution_ZernikeMagnitude_0_0': 0.1923324583626505,\n", - " 'RadialDistribution_ZernikePhase_0_0': 1.5707963267948966,\n", - " 'RadialDistribution_ZernikeMagnitude_1_1': 0.012710919436019171,\n", - " 'RadialDistribution_ZernikePhase_1_1': 1.6738472431016886,\n", - " 'RadialDistribution_ZernikeMagnitude_2_0': 0.03921126875784057,\n", - " 'RadialDistribution_ZernikePhase_2_0': -1.5707963267948966,\n", - " 'RadialDistribution_ZernikeMagnitude_2_2': 0.021367212204621656,\n", - " 'RadialDistribution_ZernikePhase_2_2': -1.7968203888307215,\n", - " 'RadialDistribution_ZernikeMagnitude_3_1': 0.001838356307222254,\n", - " 'RadialDistribution_ZernikePhase_3_1': -1.0177882118086117,\n", - " 'RadialDistribution_ZernikeMagnitude_3_3': 0.003958387645755281,\n", - " 'RadialDistribution_ZernikePhase_3_3': 1.6682324062429792,\n", - " 'RadialDistribution_ZernikeMagnitude_4_0': 0.003033062350649712,\n", - " 'RadialDistribution_ZernikePhase_4_0': -1.5707963267948966,\n", - " 'RadialDistribution_ZernikeMagnitude_4_2': 0.0052313049291743755,\n", - " 'RadialDistribution_ZernikePhase_4_2': 3.1362711979406352,\n", - " 'RadialDistribution_ZernikeMagnitude_4_4': 0.003932429008325735,\n", - " 'RadialDistribution_ZernikePhase_4_4': -0.12310362129175532,\n", - " 'RadialDistribution_ZernikeMagnitude_5_1': 0.0054204313543666635,\n", - " 'RadialDistribution_ZernikePhase_5_1': -1.6765144306086568,\n", - " 'RadialDistribution_ZernikeMagnitude_5_3': 0.0035340323334669284,\n", - " 'RadialDistribution_ZernikePhase_5_3': -2.052629685900433,\n", - " 'RadialDistribution_ZernikeMagnitude_5_5': 0.0020836794301104917,\n", - " 'RadialDistribution_ZernikePhase_5_5': -1.5868913282604633,\n", - " 'RadialDistribution_ZernikeMagnitude_6_0': 0.001385507275128227,\n", - " 'RadialDistribution_ZernikePhase_6_0': 1.5707963267948966,\n", - " 'RadialDistribution_ZernikeMagnitude_6_2': 0.005491586850404265,\n", - " 'RadialDistribution_ZernikePhase_6_2': 2.201077433541965,\n", - " 'RadialDistribution_ZernikeMagnitude_6_4': 0.0036085512913913657,\n", - " 'RadialDistribution_ZernikePhase_6_4': 0.2214689916624646,\n", - " 'RadialDistribution_ZernikeMagnitude_6_6': 0.005747255882206648,\n", - " 'RadialDistribution_ZernikePhase_6_6': 1.4277378359300132,\n", - " 'RadialDistribution_ZernikeMagnitude_7_1': 0.0009375924308202778,\n", - " 'RadialDistribution_ZernikePhase_7_1': -0.7529966882026068,\n", - " 'RadialDistribution_ZernikeMagnitude_7_3': 0.0002218182164961902,\n", - " 'RadialDistribution_ZernikePhase_7_3': -0.20403280290494366,\n", - " 'RadialDistribution_ZernikeMagnitude_7_5': 0.0005925047543621243,\n", - " 'RadialDistribution_ZernikePhase_7_5': -0.9307695398145165,\n", - " 'RadialDistribution_ZernikeMagnitude_7_7': 0.0018588126711148367,\n", - " 'RadialDistribution_ZernikePhase_7_7': 0.2832711677983217,\n", - " 'RadialDistribution_ZernikeMagnitude_8_0': 0.0008527682036573247,\n", - " 'RadialDistribution_ZernikePhase_8_0': -1.5707963267948966,\n", - " 'RadialDistribution_ZernikeMagnitude_8_2': 0.003849759799115769,\n", - " 'RadialDistribution_ZernikePhase_8_2': -3.0348094640147933,\n", - " 'RadialDistribution_ZernikeMagnitude_8_4': 0.006303111698169151,\n", - " 'RadialDistribution_ZernikePhase_8_4': -0.9421189397950538,\n", - " 'RadialDistribution_ZernikeMagnitude_8_6': 0.0025616333232286502,\n", - " 'RadialDistribution_ZernikePhase_8_6': 1.497974914859852,\n", - " 'RadialDistribution_ZernikeMagnitude_8_8': 0.003776997051549525,\n", - " 'RadialDistribution_ZernikePhase_8_8': -2.5121700003691703,\n", - " 'RadialDistribution_ZernikeMagnitude_9_1': 0.0022611754416345803,\n", - " 'RadialDistribution_ZernikePhase_9_1': 0.8411774061462731,\n", - " 'RadialDistribution_ZernikeMagnitude_9_3': 0.002471113405283529,\n", - " 'RadialDistribution_ZernikePhase_9_3': 1.5452326898185875,\n", - " 'RadialDistribution_ZernikeMagnitude_9_5': 0.0015248674586351724,\n", - " 'RadialDistribution_ZernikePhase_9_5': 2.3721537092690315,\n", - " 'RadialDistribution_ZernikeMagnitude_9_7': 0.0015615157569373382,\n", - " 'RadialDistribution_ZernikePhase_9_7': 0.884984882503327,\n", - " 'RadialDistribution_ZernikeMagnitude_9_9': 0.002886473828727781,\n", - " 'RadialDistribution_ZernikePhase_9_9': 1.849176431727321,\n", - " 'Intensity_IntegratedIntensity': 12.886274710297585,\n", - " 'Intensity_MeanIntensity': 0.1923324583626505,\n", - " 'Intensity_StdIntensity': 0.03206316775740464,\n", - " 'Intensity_MinIntensity': 0.0941176488995552,\n", - " 'Intensity_MaxIntensity': 0.24705882370471954,\n", - " 'Intensity_IntegratedIntensityEdge': 2.9333334118127823,\n", - " 'Intensity_MeanIntensityEdge': 0.15438596904277802,\n", - " 'Intensity_StdIntensityEdge': 0.02663418674171586,\n", - " 'Intensity_MinIntensityEdge': 0.0941176488995552,\n", - " 'Intensity_MaxIntensityEdge': 0.1921568661928177,\n", - " 'Intensity_MassDisplacement': 0.16251187319410354,\n", - " 'Intensity_LowerQuartileIntensity': 0.1725490242242813,\n", - " 'Intensity_MedianIntensity': 0.19607843458652496,\n", - " 'Intensity_MADIntensity': 0.019607841968536377,\n", - " 'Intensity_UpperQuartileIntensity': 0.21274510025978088,\n", - " 'Location_CenterMassIntensity_X': 30.4650030464223,\n", - " 'Location_CenterMassIntensity_Y': 2.8384053606856545,\n", - " 'Location_CenterMassIntensity_Z': 0.0,\n", - " 'Location_MaxIntensity_X': 31.0,\n", - " 'Location_MaxIntensity_Y': 4.0,\n", - " 'Location_MaxIntensity_Z': 0.0,\n", - " 'Area': 67.0,\n", - " 'BoundingBoxArea': 80.0,\n", - " 'ConvexArea': 69.0,\n", - " 'EquivalentDiameter': 9.23618154310838,\n", - " 'Perimeter': 28.48528137423857,\n", - " 'MajorAxisLength': 10.812622747736366,\n", - " 'MinorAxisLength': 7.984982463349238,\n", - " 'Eccentricity': 0.6742676002273413,\n", - " 'Orientation': -81.37547433621928,\n", - " 'Center_X': 30.44776119402985,\n", - " 'Center_Y': 3.0,\n", - " 'BoundingBoxMinimum_X': 26.0,\n", - " 'BoundingBoxMaximum_X': 36.0,\n", - " 'BoundingBoxMinimum_Y': 0.0,\n", - " 'BoundingBoxMaximum_Y': 8.0,\n", - " 'FormFactor': 1.0376326751761262,\n", - " 'Extent': 0.8375,\n", - " 'Solidity': 0.9710144927536232,\n", - " 'Compactness': 0.9637321799164251,\n", - " 'EulerNumber': 1.0,\n", - " 'MaximumRadius': 4.0,\n", - " 'MeanRadius': 1.8721985134555739,\n", - " 'MedianRadius': 2.0,\n", - " 'FilledArea': 67.0,\n", - " 'SpatialMoment_0_0': 67.0,\n", - " 'SpatialMoment_0_1': 298.0,\n", - " 'SpatialMoment_0_2': 1810.0,\n", - " 'SpatialMoment_0_3': 12394.0,\n", - " 'SpatialMoment_1_0': 201.0,\n", - " 'SpatialMoment_1_1': 861.0,\n", - " 'SpatialMoment_1_2': 4997.0,\n", - " 'SpatialMoment_1_3': 32757.0,\n", - " 'SpatialMoment_2_0': 875.0,\n", - " 'SpatialMoment_2_1': 3699.0,\n", - " 'SpatialMoment_2_2': 20699.0,\n", - " 'SpatialMoment_2_3': 130635.0,\n", - " 'CentralMoment_0_0': 67.0,\n", - " 'CentralMoment_0_1': -2.6645352591003757e-15,\n", - " 'CentralMoment_0_2': 484.56716417910457,\n", - " 'CentralMoment_0_3': 33.07418133214526,\n", - " 'CentralMoment_1_0': 0.0,\n", - " 'CentralMoment_1_1': -33.0,\n", - " 'CentralMoment_1_2': -139.44776119402985,\n", - " 'CentralMoment_1_3': -605.8335932278903,\n", - " 'CentralMoment_2_0': 272.0,\n", - " 'CentralMoment_2_1': 5.208955223880593,\n", - " 'CentralMoment_2_2': 1579.801960347516,\n", - " 'CentralMoment_2_3': 317.32703490788424,\n", - " 'NormalizedMoment_0_0': nan,\n", - " 'NormalizedMoment_0_1': nan,\n", - " 'NormalizedMoment_0_2': 0.10794545871666397,\n", - " 'NormalizedMoment_0_3': 0.0009001234920668009,\n", - " 'NormalizedMoment_1_0': nan,\n", - " 'NormalizedMoment_1_1': -0.007351303185564714,\n", - " 'NormalizedMoment_1_2': -0.0037951114951671576,\n", - " 'NormalizedMoment_1_3': -0.002014322217918728,\n", - " 'NormalizedMoment_2_0': 0.06059255959010915,\n", - " 'NormalizedMoment_2_1': 0.00014176323577152274,\n", - " 'NormalizedMoment_2_2': 0.005252647301521517,\n", - " 'NormalizedMoment_2_3': 0.00012889772855680416,\n", - " 'NormalizedMoment_3_0': 0.0017962092509503553,\n", - " 'NormalizedMoment_3_1': -0.0008264056376813975,\n", - " 'NormalizedMoment_3_2': -0.00041986624857065264,\n", - " 'NormalizedMoment_3_3': -0.0002236573054902451,\n", - " 'HuMoment_0': 0.16853801830677312,\n", - " 'HuMoment_1': 0.002458463689794052,\n", - " 'HuMoment_2': 0.00017397856239913457,\n", - " 'HuMoment_3': 5.0811381355806185e-06,\n", - " 'HuMoment_4': -2.486544707014142e-11,\n", - " 'HuMoment_5': -7.656066027044657e-08,\n", - " 'HuMoment_6': -1.4901350790510987e-10,\n", - " 'InertiaTensor_0_0': 7.232345734016486,\n", - " 'InertiaTensor_0_1': 0.4925373134328358,\n", - " 'InertiaTensor_1_0': 0.4925373134328358,\n", - " 'InertiaTensor_1_1': 4.059701492537314,\n", - " 'InertiaTensorEigenvalues_0': 7.307050667804121,\n", - " 'InertiaTensorEigenvalues_1': 3.984996558749679,\n", - " 'PerimeterCrofton': 29.68725722470835,\n", - " 'Zernike_0_0': 0.8047834858231687,\n", - " 'Zernike_1_1': 0.07859294567727422,\n", - " 'Zernike_2_0': 0.10357252971590757,\n", - " 'Zernike_2_2': 0.09426112239369118,\n", - " 'Zernike_3_1': 0.006369960556240697,\n", - " 'Zernike_3_3': 0.01623671065645129,\n", - " 'Zernike_4_0': 0.01839170349317207,\n", - " 'Zernike_4_2': 0.028945327583356772,\n", - " 'Zernike_4_4': 0.021565363485149504,\n", - " 'Zernike_5_1': 0.027504908646509528,\n", - " 'Zernike_5_3': 0.02115092872161993,\n", - " 'Zernike_5_5': 0.00891394341624542,\n", - " 'Zernike_6_0': 0.0027437527064452967,\n", - " 'Zernike_6_2': 0.02624280085981392,\n", - " 'Zernike_6_4': 0.02192144768776064,\n", - " 'Zernike_6_6': 0.03439788893524723,\n", - " 'Zernike_7_1': 0.005194540482196825,\n", - " 'Zernike_7_3': 0.0056451257446250135,\n", - " 'Zernike_7_5': 0.0034909496903208683,\n", - " 'Zernike_7_7': 0.011190208525527691,\n", - " 'Zernike_8_0': 0.002181539232060978,\n", - " 'Zernike_8_2': 0.020158154688774976,\n", - " 'Zernike_8_4': 0.03731167927710452,\n", - " 'Zernike_8_6': 0.016793489759696374,\n", - " 'Zernike_8_8': 0.02117319802226603,\n", - " 'Zernike_9_1': 0.007615647847177336,\n", - " 'Zernike_9_3': 0.0045800564257302764,\n", - " 'Zernike_9_5': 0.0016030454771965594,\n", - " 'Zernike_9_7': 0.004545190441797106,\n", - " 'Zernike_9_9': 0.013909796226327613,\n", - " 'MinFeretDiameter': 7.0,\n", - " 'MaxFeretDiameter': 10.295630140987,\n", - " 'AngularSecondMoment_3_00_256': 0.014204545454545442,\n", - " 'Contrast_3_00_256': 91.8409090909091,\n", - " 'Correlation_3_00_256': 0.0709738096792914,\n", - " 'Variance_3_00_256': 49.42858987603222,\n", - " 'InverseDifferenceMoment_3_00_256': 0.1243163038356934,\n", - " 'SumAverage_3_00_256': 102.38636363636365,\n", - " 'SumVariance_3_00_256': 105.87345041322078,\n", - " 'SumEntropy_3_00_256': 4.37137927816168,\n", - " 'Entropy_3_00_256': 6.237729629951767,\n", - " 'DifferenceVariance_3_00_256': 0.0011601723915289257,\n", - " 'DifferenceEntropy_3_00_256': 3.7591419842479024,\n", - " 'InfoMeas1_3_00_256': -0.5420221749233054,\n", - " 'InfoMeas2_3_00_256': 0.9951493023787886,\n", - " 'AngularSecondMoment_3_01_256': 0.019230769230769235,\n", - " 'Contrast_3_01_256': 126.23076923076924,\n", - " 'Correlation_3_01_256': -0.05878849542148152,\n", - " 'Variance_3_01_256': 59.610946745562615,\n", - " 'InverseDifferenceMoment_3_01_256': 0.06820697080582802,\n", - " 'SumAverage_3_01_256': 101.30769230769232,\n", - " 'SumVariance_3_01_256': 112.21301775147731,\n", - " 'SumEntropy_3_01_256': 4.209867121904035,\n", - " 'Entropy_3_01_256': 5.700439718141092,\n", - " 'DifferenceVariance_3_01_256': 0.000957782451923077,\n", - " 'DifferenceEntropy_3_01_256': 3.8441065448145375,\n", - " 'InfoMeas1_3_01_256': -0.6414090005358515,\n", - " 'InfoMeas2_3_01_256': 0.9976992127888944,\n", - " 'AngularSecondMoment_3_02_256': 0.016800584368151943,\n", - " 'Contrast_3_02_256': 148.4864864864865,\n", - " 'Correlation_3_02_256': -0.09997727297324675,\n", - " 'Variance_3_02_256': 67.49525200876496,\n", - " 'InverseDifferenceMoment_3_02_256': 0.1597853274210485,\n", - " 'SumAverage_3_02_256': 100.27027027027029,\n", - " 'SumVariance_3_02_256': 121.49452154857318,\n", - " 'SumEntropy_3_02_256': 4.499597622210291,\n", - " 'Entropy_3_02_256': 5.966210122385705,\n", - " 'DifferenceVariance_3_02_256': 0.000999924385956903,\n", - " 'DifferenceEntropy_3_02_256': 3.841096866085959,\n", - " 'InfoMeas1_3_02_256': -0.6279322068987813,\n", - " 'InfoMeas2_3_02_256': 0.9978729133307551,\n", - " 'AngularSecondMoment_3_03_256': 0.019619500594530312,\n", - " 'Contrast_3_03_256': 190.9310344827586,\n", - " 'Correlation_3_03_256': -0.3061671052470948,\n", - " 'Variance_3_03_256': 73.08828775267602,\n", - " 'InverseDifferenceMoment_3_03_256': 0.0707941830046325,\n", - " 'SumAverage_3_03_256': 99.48275862068965,\n", - " 'SumVariance_3_03_256': 101.42211652794322,\n", - " 'SumEntropy_3_03_256': 4.28022625367366,\n", - " 'Entropy_3_03_256': 5.720049960644815,\n", - " 'DifferenceVariance_3_03_256': 0.0007777083642984543,\n", - " 'DifferenceEntropy_3_03_256': 4.090234012145144,\n", - " 'InfoMeas1_3_03_256': -0.6658470534053287,\n", - " 'InfoMeas2_3_03_256': 0.9983414731315025,\n", - " 'Granularity_1': 1.1564210938463995,\n", - " 'Granularity_2': 3.590991817733586,\n", - " 'Granularity_3': 6.482044552349607,\n", - " 'Granularity_4': 13.20754617708793,\n", - " 'Granularity_5': 51.065124576064726,\n", - " 'Granularity_6': 71.45465632552134,\n", - " 'Granularity_7': 77.57151526928787,\n", - " 'Granularity_8': 79.61046825054338,\n", - " 'Granularity_9': 79.61046825054338,\n", - " 'Granularity_10': 79.61046825054338,\n", - " 'Granularity_11': 79.61046825054338,\n", - " 'Granularity_12': 79.61046825054338,\n", - " 'Granularity_13': 79.61046825054338,\n", - " 'Granularity_14': 79.61046825054338,\n", - " 'Granularity_15': 79.61046825054338,\n", - " 'Granularity_16': 81.6494212317989}" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "db.open_table(\"compartment_nuclei\").to_pandas().iloc[0].to_dict()" - ] - }, - { - "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "e5cdd20c-0a03-4e8d-a4f0-3928e59d203f", "metadata": {}, "outputs": [ @@ -1319,6 +1188,7 @@ " \n", " \n", " \n", + " image_filename\n", " ome-arrow_original\n", " ome-arrow_mask\n", " \n", @@ -1326,16 +1196,19 @@ " \n", " \n", " 0\n", + " AS_09125_050116030001_D03f00d0.tif\n", " {'type': 'ome.arrow', 'version': '0.0.1', 'id'...\n", " {'type': 'ome.arrow', 'version': '0.0.1', 'id'...\n", " \n", " \n", " 1\n", + " AS_09125_050116030001_D03f00d1.tif\n", " {'type': 'ome.arrow', 'version': '0.0.1', 'id'...\n", " {'type': 'ome.arrow', 'version': '0.0.1', 'id'...\n", " \n", " \n", " 2\n", + " AS_09125_050116030001_D03f00d2.tif\n", " {'type': 'ome.arrow', 'version': '0.0.1', 'id'...\n", " {'type': 'ome.arrow', 'version': '0.0.1', 'id'...\n", " \n", @@ -1344,6 +1217,11 @@ "" ], "text/plain": [ + " image_filename \\\n", + "0 AS_09125_050116030001_D03f00d0.tif \n", + "1 AS_09125_050116030001_D03f00d1.tif \n", + "2 AS_09125_050116030001_D03f00d2.tif \n", + "\n", " ome-arrow_original \\\n", "0 {'type': 'ome.arrow', 'version': '0.0.1', 'id'... \n", "1 {'type': 'ome.arrow', 'version': '0.0.1', 'id'... \n", @@ -1355,7 +1233,7 @@ "2 {'type': 'ome.arrow', 'version': '0.0.1', 'id'... " ] }, - "execution_count": 8, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -1367,15 +1245,15 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "id": "118dcf01-c4a4-46a6-88b0-0ec694d9efa9", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABJYAAAGXCAYAAADh89pxAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjUsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvWftoOwAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs/Qe4dVtV34+feyliQzpcepGiBoQoYkPUqCSGmKJGjVFRUjSJ6THW2FvURCUalRhjDEFN0fTEgjECGkpERVEQuMAFLlXFisI9v+e7/3zO//t+7xhzzrXf8xa5azzPPmfvtWYZc8wxR1tjznXN6enp6ckOO+ywww477LDDDjvssMMOO+ywww47bIRrt1bYYYcddthhhx122GGHHXbYYYcddthhB8EeWNphhx122GGHHXbYYYcddthhhx122OEo2ANLO+ywww477LDDDjvssMMOO+ywww47HAV7YGmHHXbYYYcddthhhx122GGHHXbYYYejYA8s7bDDDjvssMMOO+ywww477LDDDjvscBTsgaUddthhhx122GGHHXbYYYcddthhhx2Ogj2wtMMOO+ywww477LDDDjvssMMOO+yww1GwB5Z22GGHHXbYYYcddthhhx122GGHHXY4CvbA0g477LDDDjvssMMOO+ywww477LDDDkfBHljaYYcdrhi89rWvPfmET/iEkzvf+c4n11xzzck3f/M3X9b+/9W/+leHfq+//vpL3teXfdmXHfpyeOtb33ryeZ/3eSf3uc99Tq699tqTP/Nn/swlx2OHHXbY4Q8b3JJ0RdfXN3zDN5w88IEPPLnVrW518shHPvKS47HDDjvs8IcNdl1xckV1xRUNLH37t3/7gSCPecxjyvu/9Vu/dfKlX/qlJ3/kj/yRk3d913c9MIkI9Lf+1t86efWrX725v+/+7u8+ea/3eq+T293udicPfvCDT5785CeX5b7/+7//5I/+0T96KHfXu9715ElPetLJG97whpuV++f//J+ffOInfuLJfe9738M4nvjEJ5bt/fiP//jJZ33WZ5085CEPOXmXd3mXw2T/pb/0l05e85rX3Kzsh3/4hx/ays8f/+N//OQY+M//+T+fjUV4ip5yZivGrD433njjUW1qbJ//+Z9/8hEf8REn7/7u735o63//7/9d4vgjP/IjBxprnrUI7n//+w/H9JKXvOTkL/yFv3Byt7vd7eSd3/mdD3P5RV/0RTcr98IXvvBAt3d7t3c7udOd7nTyaZ/2aSevf/3rLygjPvqLf/Evnjz0oQ894HmHO9zh5AM+4ANOvvd7v/fk9PT0Zm2+6lWvOvnzf/7PH8rd/va3P/nTf/pPn7z0pS+9KH5bbXOV32YgAeRzfJvb3ObkLne5y8kHf/AHn3zhF37hySte8Yqy3k033XTyj//xPz55wAMecBjTIx7xiJOnPe1pNyv3lKc85eRxj3vcyd3vfveTd3qndzqU/8zP/MxSyP6dv/N3Tv7X//pfJ1/wBV9w8n3f931nfL7a1+o8b4Vj2/yd3/mdQwCp4/WEf/kv/+VBAUgJiudEjx1uDruu2HWFYNcVu664mnTFs5/97JO/9tf+2sn7vd/7HWiTDw5m8DVf8zUnP/zDP7xUVryvhxAf8iEfcvI93/M9h7o73Bx2XbHrCsGuK3ZdcbXoiptuuumwHj7u4z7u8BBZckd8+VVf9VUnv/d7v/eOpytOryB88Ad/8On9739/rbLTF7/4xRfc+/3f//3TRz3qUafv/M7vfPrZn/3Zp9/xHd9x+o3f+I2nn/mZn3l6l7vc5fQnfuInNvWl+urn4z/+40+/67u+6/TTPu3TDr+/7uu+7oJy3/7t3364/sf+2B87/bZv+7bTL/iCLzh9l3d5l9NHPOIRp7/7u797Qdn73e9+p3e6051O//gf/+Ont771rU8/4zM+o+z7/d7v/U4f8IAHnH7e533e6VOe8pRDm+/+7u9+eve73/30Na95zQVlH/e4x53e+973Pv2+7/u+Cz4//uM/froV/vt//++n11xzzelHfMRHHMb8uZ/7uafXXnvtgZ4O3/M933MY81d8xVfcrN8c82qbmh+1+eAHP/j0gz7ogw7fuzkT3W53u9sd+EFjF107+Nmf/dnT93iP9zh97/d+78PciZ5f8iVfcvrEJz7xgnKvfOUrD3zyoAc96PRbvuVbTr/6q7/69I53vOPp+77v+56+5S1vOSv3cz/3cweaf+EXfuGBR5785CefftzHfdwBX82Tw2/+5m8exnO3u93t9Ou//utP/8k/+Sen97nPfQ44v+ENbziK37a0ucpvM3jZy152wOVTPuVTDnP8vd/7vaff/M3ffPqpn/qph/Umfn/a0552s3qf//mff6j3l//yXz6M6U/+yT95+J1lP+dzPueAm9brd3/3d59+8Rd/8YHXNR+vetWrLiir6+r32L5W57kDeF80OY82X//61x/a+9Iv/dKb3fuDP/iDm62nT/qkTzq9173uNcXzlg67rth1hWDXFbuuuJp0heT8bW5zm8O6fchDHnK4vwXe9V3ftZybt771rYf1dNNNN51d+4f/8B8e1s8Krrdk2HXFrisEu67YdcXVoit+8zd/8/D7Az/wA0+/6qu+6tC3ZI54/MM//MMvkPPvCLriigWWXvrSlx4I/R//4388vetd73r6ZV/2ZRfc/8Ef/MHD/ac+9ak3qysi/sZv/MZyX7/zO79zeuc73/nARA5iPE3Wm970psNvTcId7nCH0w/7sA+7YJL+y3/5LwdcvvVbv/WC+tdff/1ZuW7SBT/5kz95+ra3ve1m19TmF33RF11wXcLofd7nfU7PAyQktRDk0ALqTwL8hS984c0WwXOe85xza/PNb37z6Rvf+MbD93/37/7dUAFIKEjhCzRHnQIQDf/IH/kjp495zGMOczoCCSEJs5e//OVn1370R3/0gMd3fud3Tsf5hCc84TCnWrSABLTqP/vZzz67pjHf6la3ukBZrPLblja38NuqAviGb/iGm91THzKQb3vb254+//nPP7t+ww03HAzov/7X//rZNeHy2Mc+9qCsnE4VPPe5zz30+bVf+7UXXBffeJtb+7rYea6chYtpcxRYqkCG1Hmt93dU2HXFriuAXVfsuuJq0hU33njjGX8Jh/MKLFUgR0Tld+hh1xW7rgB2XbHriqtFV7zlLW85feYzn3mzcl/+5V9+KKe235F0xRULLH3lV37lIQIogmsSFV11EKOI4GLIi4X/9t/+26Et/Xd41rOedbiu6Krgec973uG3nigkvNu7vdsh8t3BMQtSUeI/9+f+XKkAJGAV5TwWfvEXf7Eci4Strov+lQKQ4O4W85Y2HWYKwGGkAP7H//gfh3b0dEPw27/92y2uitR/4id+4s2uS7jpqdEM/sbf+BsH4eSK5tGPfvThk/AxH/Mxh8j2Vn7b0mbCpVIAjudf+At/4eya5lzXxAMO//bf/tvD9Z/6qZ8a9qmnJCqnSLrzXH629rVlnl/wghccAjl6iqUsIfGrnnyks3As70DX/BBk0n/G2JXd+sT0lgC7rth1RQW7rqjbTNh1xaXTFQ5bA0vVmJindEyqsiqzw4Ww64pdV1Sw64q6zYRdV1weXQH8/M//fBlc/sOuK67YGUtPfepTT/7cn/tzJ7e97W1PPuVTPuXkxS9+8clznvOcs/v3u9/9Dv//9b/+1+We1C3wsz/7s4f/7//+73/Bde2L14G53H/LW95y+K/9tQm6pnLaK3keoH3e+mgPasKLXvSiwx5M7c29xz3ucfIlX/IlJ3/wB39wLmO+5z3veXLve9/77L6D9i1rL672a2svqObkYts8T/ixH/uxw3/trxUOopFw/eRP/uSTN73pTRfsLX7d6153MzwF2udc4fm7v/u7h/3u2q+rfdDal/pBH/RBZ7ygef/5n//5tk3tz/7N3/zNTfy2pc3LCRr3gx70oJMf/dEfPbsmnEVv7e1OPLmf8MY3vvEwD8997nMPe6EFf+yP/bHD/w/7sA877H0WfPRHf/ThO79X+9oyz9rTL/5+/vOff9ij/7f/9t8+yJZv+ZZvuaDeMbwD6NwE7VcX/Nk/+2fPxiQ5V5XVvYc97GGHtUPZHPMOu67YdcV22HXF5YFbsq64WNAYxJ+Pfexjz8b0V//qX23LqpzKU1Z02eFC2HXFriu2wq4rLg/suuLmwFlj1Xr9w6wrbn1yBeB5z3veyS//8i+fHTr2oR/6oQcBIqXw6Ec/+nBNb0fSwWf/6B/9o8NhZZo8EesJT3jC4XC1LaAD33R4W9aT8tHBfRzYp4PQdOjYM5/5zDOGFfzKr/zK2aFdv/Zrv3aoc7GgU+p///d//+STPumTLriuhaexPvzhDz/57d/+7ZN//+///eGALymFH/iBH1hunwP8rrvuupvd0zU/pFBCVAe2oQA0P//kn/yTw6Fr/+///b/DYWNb27wUgELSgXQ6VE0Hs/3cz/3cydd+7deevPKVrzx5xjOecZi/GZ5SFlL2WniABIHaAySopAQA6nRtCjR+8ewqv21p83KDDpb7T//pP528+c1vPvCExqRD8/JwUscz4V73uteZUaVxf+u3futB2At00KQ+OhBPh0/qoENgta8t8/z1X//1hzX8f//v/z1TJJ/xGZ9xWPMOx/AOIKWlQ7g/53M+53AooI+pKqv7/+Jf/IsDr4zK3pJh1xW7rjgGdl1x+eCWqisuFjSOz/7szz6MbSb/dV8OsNbYritq2HXFriuOgV1XXD7YdcWFoIPERYc/8Sf+xMk7kq64IoElCXpNsASOQBMtQfhv/s2/Ofmmb/qmw+JRRFeT9dVf/dUnP/iDP3g4UV0fRWb1Fo5v/MZvLJ27ChQ11uKrQCfD6z5RQwkXRZYV1VTWgaKXn/u5n3s44V7RfcpeDPyf//N/Tr78y7/80NdHfuRHXnBPys5BC+Sv/JW/cjgRXyfdf+AHfuBSH+BZ0Uhj1sIGhIc+gJTv4x//+EOUU/T/ju/4js1tXgrQkxiBjATxiuDjP/7jDwpMwltvyfioj/qoKZ6Mxe/r6ZYi1BIS//W//tfD6yp9rlfb3MJvW9q83KA3IQj0ZEOCL+m1guf/+B//4/DGA71dQfMlg2YFVvvaMs///b//98PaQfiTNfSpn/qph7fIeN+rbe5w6WHXFbuuOAZ2XXH54JaqK3a4umDXFbuuOAZ2XXH5YNcV/3/Qm9oUAFI5vbnvHQku+1a4t73tbYfXbkr4v+xlLzv51V/91cNHrwbVotMiBt7jPd7jENFTGqE+Eo6Ksv6zf/bPTr7yK79yuU8pE0XxKxCDeorqd37nd5587Md+7Mnf//t//xDllxBUlP9P/ak/dcHCOBb0REWKRZFbZSuswN/7e3/vgpTNFWBMRHZHY65AT3s0J97nxbZ5sUD7EtYOekWo4FnPetYSnl7GU6SlPNS2DBRFhl2ZbGlzld+OwfNyAcpWadPgsRVPrXFF4v/u3/27J//u3/27g9GjtTuD1b620O/lL395+RQhn9pczXNyS4NdV+y64ljYdcXlg1uqrtjh6oFdV+y64ljYdcXlg11X/P9AWYJf/MVffPKkJz3psMPhHQ0ue2Dp6U9/+iHVTEpAE8KHyLYWXwVaoJ/1WZ91SCdVdK8rV4HS16R4tG/SQYtU+zW1l9eVjlL1xDA/+ZM/eVA82qMonBWJvJjIotIqP+ZjPubQhyKdLK4ZkDLq+31nQBofaX0OuuZjHvXrfZ5HmxcDtK+nUg6khiqdeAXPO93pTtOnUtrSpPnSUyABdbo2Hb9VftvS5uWGF7zgBQe66qkCY9J+4DyXYBVPGVOPetSjltbtal/nMc9V3+fd5g7Hwa4rdl1xLOy64vLBLVVX7HD1wK4rdl1xLOy64vLBritODmdMffqnf/rJn/yTf/Isa+8dDS57YEkMIMZSpDE/iur+0A/90DBN7453vOOBmapJ7+CRj3zk4b8O+3LQbx10xn2H+973voenClI8v/7rv37YH6xI87GghS/hryjo//pf/6vcv9nBS1/60sN/KaCLHbP2kd5www3lmKt+vc/zaPNiQIfUCZRGnP0LwFV7cPU98RQ8+9nPXsITHvyN3/iNw3+lSusJU9WmUqv1JAKFvspvW9q8nPDTP/3ThwP+xK+AcP6d3/mdQ/pp4sn9FZpCzxGs9rVlnrWO89BIzjlwuFjeyf3bOxwPu67YdcWxsOuKywO3ZF1xHrDri/OBXVfsuuJY2HXF5YFdV5wc+lJmobZHaivurW9963dMXXE5X0GnVyy++7u/++lnfdZnlfef+cxnHl6N9/3f//2nz3/+809f//rX36yMXhP6zu/8zqePeMQjNvWrV3A+4QlPuOD6X/yLf/H0Xd7lXU7f+MY3Dut/9md/9um11157+uxnP/uo1zT+1m/91ukHfMAHHMb+3Oc+t23jN37jN05/7/d+74JrN9100+knfdInHeii15ZugYc97GGn7/u+73vBqzO/+Iu/+PC6y1/6pV86u/a6173uZnV5teXf/Jt/86g2L8VrQV/zmtecvtM7vdPph37oh56+7W1vO7v+BV/wBYf2fX40Z+KTV7ziFWfXfuzHfuxQ7p//838+HLvgT/2pP3UY04tf/OKza1/3dV939vpU4Jd/+ZdPb3WrW5297nIrv622ebleC6r1pVdq3va2tz39uZ/7ubPrr3zlK09vc5vbHF6p7Lz52Mc+9vCKTfhBr7N905vedLN2/+///b+HMX3ap33aBdeFh7e5pa8t8/y3//bfPlwTHj737/Ee73Gz14Kutvn7v//7py984QtPX/3qV18w9yr3t/7W37oZDb70S7/0Zq+j5jXAO1wIu67YdcUMdl2x64orrSschMPIpJauePnLX37Btbvf/e6nf/pP/+mblc1XSAs0h5rLHS6EXVfsumIGu67YdcWV1hW/9Eu/dHrnO9/5YO9XY3lH0hWXNbAkwS4C/PAP/3B5X4v6rne962HxiTm1WD75kz/59Ju/+ZtP/8W/+BenX/iFX3h6j3vc4yCM/+N//I+b+v62b/u2Q9+f8AmfcPqUpzzl9NM//dMPv7/6q7/6gnJf+7Vfe/qpn/qpp9/6rd96+u3f/u2nH/MxH3Mo91Vf9VU3a/M//+f/fPqVX/mVh48WzKMe9aiz3754xAxqQ4rv+77v+y74/NAP/dBZOQlIje/v/J2/c8D3G7/xG08/5EM+5FD3r/yVv3K6Ff7Lf/kvByH2kR/5kaff9V3fdRDmot1f/st/+YJy7/me73n6iZ/4iadf//Vff/od3/Edh75ufetbn97nPvc5vfHGG49qUwAtNIeMn2sOohXXH/rQh57e4Q53OPstGjt8xVd8xaGtj/7ojz7QSLgKn0/5lE+5oJwEghbxgx70oMNcfs3XfM3pHe94x9OHP/zhFyhZBQDe//3f/6DENB4J5Ec/+tGHPj73cz/3gjbf/OY3H9q7293udvqP//E/Pv2n//SfHmh0z3ve82aKZJXftrS5ym+rCkA0Ew9+7/d+7+m3fMu3HBSUhKnW3Q/8wA/crN4/+Af/4IwXNSYpa/1+6lOfelbm137t1w4CTXP9Td/0TQd+kiBXm1KKL3rRi6YKYLWvLfOs4I/K6d6XfdmXHeTLgx/84IMhmUJ5tU3omIr4vd/7vQ/rWDzwtKc97fQXfuEXDtf3wNI67Lpi1xW7rth1xdWuK+QwQdfHPOYxh/v8/tf/+l/fDH/Je4eP/diPPdBA45eu+Jmf+Zmr1lm4WmHXFbuu2HXFriuuZl3x5je/+UB/8bR4Idfrs571rHcoXXFZA0sS7Le73e1Of/u3f7st88QnPvEQVVQE/h/9o390+oEf+IGHxSGBJOUgRnj6059+VP9a4BIwWjxiGC02RSwd/ut//a9nTwHEtOr/B3/wB8v2NHma0OqjyQYUKe/KeRT9pS996UEQ3//+9z/QSf2/3/u932ERJZ6rIAXzyEc+8hCRv/e9730QdMq0cPiiL/qiQxlFWUX7+973vqef8zmfczPhv6VNQTfmdK5ZGNUnnXbR4clPfvIh+i1ctVi7/l/wghccFLjoKKUixZ5j+pEf+ZHDEwAJXLWneZfSFU4VzRX1llC//e1vf/pu7/Zuh7r+9GErv21pc5XfVhUAH60tCWcZxnpKk5FyN9AkYMWzGpMCIv/m3/ybC8q85S1vOShVCVaNRzRV+Sc96Unlk95OAaz0tWWeBT//8z9/ENZaW3pCIcX53d/93eVT6JU2u8CSlITWrfDWfQWUBHtgaR12XbHril1X7LriatcVcto7OqdjUF1TFsGHfdiHHRwv5+Gr0Vm4WmHXFbuu2HXFriuuZl3xsqDNjB//sOuKa/TnSm/H22GHHXbYYYcddthhhx122GGHHXbY4Q8fXPbDu3fYYYcddthhhx122GGHHXbYYYcddnjHgPUjya9C0GsWZ6/K1Cs43/md3/nkHQX0usnXv/71wzLv9m7vdvjscMuCW+J62GGHFbglro1dV+zQwS1xPeywwwrcEtfGrit26OCWuB52uAUHlp71rGedfMRHfMSwzPd8z/ecPPGJTzx5R4FXvvKVJw94wAOGZb70S7/05Mu+7MsuG047XB1wS1wPO+ywArfEtbHrih06uCWuhx12WIFb4trYdcUOHdwS18MOFwd/qM9Y+rVf+7WT5z3vecMy7/M+73Ny3XXXnbyjwO/93u+dPOMZzxiWeeADH3j47HDLglviethhhxW4Ja6NXVfs0MEtcT3ssMMK3BLXxq4rdujglrgedrgFB5Z22GGHHXbYYYcddthhhx122GGHHXa4crAf3r3DDjvssMMOO+ywww477LDDDjvssMNRsAeWdthhhx122GGHHXbYYYcddthhhx12uLSHd1977bUnuWvummuuWe5IZW9zm9scTo+/053udPh+29ve9vA2gptuuunQtvZy6s0Eb33rW8/6vPWtb332NgKV1V7g3/qt3zqcVK86qzv5wJX/Xk/fu7F07au83+O3tzPDLfukvLet77e61a0OH11zelU4+Hjynj6iqdrSd7Wj9qBj1qM91clxqe5onCM6JG4zWC2/td2sk3NY0bHrZ9Z30mP0O8HxGPFpt0aP3e06G+eIfxPvqvwx/Xf3NXb+3+52tzu5xz3ucZAZuv+7v/u7J7/92799kC+SG8m7rA3H793f/d1P7n//+x9kldp885vffKirtSP4gz/4g5M3vOENJ2984xsP8kptgo/PhbfJ+kt6+e9KpnTjTp4Qbve6170Oe90lW3/kR37k5EqAZPYM745fZr9HPDGT4d0aWlmPlVwYfa/qVmN3vPL7iHZdH7Pxd1DpkREtOujGX42ho8esrRV+WNXDrPtu7a3MTdXmjEdHPLdiN6zi4e1X4P2uzssKHlv0jsvgEe+v/t4CPs6ZHp6NAdm+ZW46m+889XiFa45TduCVgHd6p3c6/Ed/Ol6ip/DC/mSO0MHS79J10u9vectbzmxafaSTvb78DdWVbpJ9QDu3v/3tD7ryXd7lXQ5tvuQlLzn4INLvqgtOtINeF953vOMdD+2pL9V3/S58hAd1dE/XqK976lfXsSsoo771EXjf0AkbR2OSXfI7v/M7h3J6K9cd7nCHA276rfYFal84ym/6zd/8zbO+9UFXi4b6UE+0VTu6n/RnroSz7COduwS+spse9rCHnTz/+c8/4PbiF7/45Prrrz/goDpqT7S6y13ucignfxC/Tu3+8i//8slrX/vaw9g0RvUhmgh32XDwrvOL84j7Rsy/Q/IXPlXaktiIKRuzHbf7qCfcRQ98Nmim3257zmSw9wWO/K5sQKeN84vj53ou5X1FP8fR+S91prc98gtyrImP451tJJ6sLcoy1pw/55fKJvf15byh+dIa0HyyDpALyBKtOX1UVjxObOKtb33r2bwLVFbt6DeyAVx93uibe6xz9atr+u58Xdkt9A1v8111wUX46p7+IwfgWV33MSCj9Fvf5UddsrfCbVXA7vzow0QJcQ3ImcZBxLjzne98EFgivISfQEILYbZqJOe9GVQLlzZH7Ww1qCoH078TTOI390cOQ9emt9Xh6ji5Ilkxlkc4VNdXDKYt9LwY8DGvGvmCSmCt8EpnyFbCb8XBq/rZ6qTk3I/aW2k7665c68CVY4ULwlmC+9WvfvVZ4FoC0QOyvu5SoQgknyTQ9UHxcF0fyR0MV1eSrixy/ChBjCWCumrLlXnSdhTQr/hVbWr85+WEHAuVvKzw5XeCz9GKs+ntZN+5ljqo+GmlXtfWTC5X7XdjHeFQ0aGSHzO51hl8Vb1OL3p51+lVmcS/4usKvxUZNJIr3k6OMfveKj87vDvems3JFvk4wyvvVetwi95bsYFm87DS54y+nR21At7/jM4d3Vbqdn2vyruuX8drpb9uvq8U4ASm7OmCdf4AST4EutMdOZxO9Kzrc+lG1+Gqw3cFZe52t7sdXq2uax4EAi+cUF1TGfkn7/qu73p2jzHgROLEMRYcP9dL3rYcWR+bl3d6qE0FY+QPUU7On3CSo6v/CsSoLoE3nFNopPKykdSu7gPCQWPSPXdy1R7OJ/6brv3qr/7qoR/dU9Do5S9/+SE4Jx9ND988GKHvCoS96lWvOjiojFe4aDzMhUDlBKILtHV+8eCC8xP1U//w3YM06eADlKWfmX3mfEv/jqe3l+uca4zN17rzSKVHuOf/fSyVTvc1Va07ArfVWqWsj2lmo3mALYNVOS5fQ7n+6DdxyLnwMk6HDH5RDjmR+KkMgRetZ+QIoHlWXAIZonXGOr7JZBpjJeANrsx3FQhLHqAMbbOWPXDq/TEeyrP+tN4IOPvcZMIK8gd8fb2twKbA0opSqpRcGrkQVUi7s1YxKPf1ITooIHIIMSq80nCpcMwFPBpfZawnjIzDXOxd+a7NFHxd/W4OVgzBbD8FcDemqr0VI/UYY3AFOidnZqRW12e83imdLNfhscVITWU0EuzHwEo7I3pWcz4aT0fX6onFbA25ctJ3shqr9S7wwJArUww7f3qi3whytaHfXEvDJfFE5unpqD6qJ8D401MOsp6cBr4GM6BW0U3X1RZPX68kON1TdnT8kGt2dq2rPyqTOFI2+Sr5dyR7RzIly1R8u7JmRuutMkQ62mSZTl9VtHEcunF1Y0hdvEUWr8LM8J7pgE5Gz2g1gwqnlTYqfl6l0YrOncnl5IFO7mT5agwjW6Gbk5W6K/jPYNVWWqHbyC7KtTSzG6r6I9yzvUpurcjRywnuSKOPPYMg5Qx62oM3OD/cpw0PlqisdK+u6Z50sP5L/8rZIjPm3ve+9yEL+YYbbijXrTvJAtXVBwePoA3ZSFwjOEJQQ/cpq9+MC5zJTIAO2B0EhKTn/QGS/pOVpDFRrnN0eeAGLRmb+pP94H4WATgyLbBVNAYFgxQg0jV9CFTJyVb/nk0E7dA/uk8ZnGUfLw/v3Pn2ABXj9oCMILNefB14dosHJpI+GaTwoEQGk6pr3lfi4PzUBVVS5sLXiVPKlBy/B02870oW0V7SN23aFdnmsqZKZOho5YGLKouxsgsrmZv2OPSFBzPo521SX/wnnlcwSeW0JrDFCbCyA0L8zkPia4qMMgLdnmkEuLzLoKDzIfIAWeAyJ/UJdX1cvo6Erz/gZrwqi2/j2VbcuySBJYdOKc0MGk2UhJG+k4ZJW6RDennSQiWweNpPNFufdEArRV0pcGc8JswXJJ/RWFbHXeHg+Pq9rp2LNbpX8ElcVnGYGWLngVsHW/pewadz3qr7M4fB743aTSUzcgzzuxs5WyAdxK6M41eNa8v1FXwE1bqrHO1R31UkP41sPv5Uwg0nnm76k0aB5JYUihu/lVHvIKWkpxtKMSewpPYk03yrXdLC5ZMrCJQNffNbMlFtXQ1OQzpiKw5qB93a6AyMmQxzg6Nan15/pGNWxuz3OlmwimuOuaqzIkeq+5WepM5I9nd107jK6yvjyTIjmMmEmf51ebhVv3ftjXBNg91xTF5ZsRGyfnW9u9fN/Wgd53hW13U6G1XGSiezV3VO9bvaqtaN5RhIHh85lpUTMbOvVmwTL7+il640eAYKzlJu+wJ8vbClinI4QgRCeOij32ylYnsXmcI4gtL7qiP9Kx19z3ve85BpozrpnEFPjvVAL6uedDlHdeDASh9jR+DPgJt+KwhEkItgjNNG5bBNcAAJ8FAPZ5NAWcqMXMvYPLnlh4xqMp7IwqCc8xT9YZuoPv6Z6hBgEt5swVE5bCzvX+Mh20NQZZ9V2SlVcMDXnq8H+qyCTpUd7m2ASwa1HDzzyftOG83re7DMoZIJXUaLB7T47tldPvf+O7fWuezyLaBO0/QXfCyVTOV+Zye7DgS3fIBa9emywe347NvnjvusoQwEsj6T/uJFbR/VWhOfws/EKlSWHRGO2zWFHoP/nS98TC6bWZd8J/jN/OCjeKAUOibvQQuCkyTx+M4LH7tvW2UtgveqblwOLK0YohWkgS5BqwFKEPtZP7pOpN0nXAPTJLI/WcpBTx4k1F/3utdd8LTiGICAalfpn/otRpJySEOzE9IzWqw4IlsNV/89MzhGRl9ldM+MYq+7WnYLbDF+VvEc9dUJzqrcrD+nx8gQd7wq5yHLjebumDWbfN3VH7Vb8VylFDtDPhW6C8EOl46mVZuztYnA1LqXTEF4ShZhkGKwYgx6UIcnht5+8hPjkbFGOi0ZmpJnnGdAGnvSk/Rb9nGjEPyJoIPk4a//+q8fZOaVgq3yYGWe0imsjMFqDVXyLfuq7o1wTD6teK3rt2rfja+UM1W/1Rqr+u7Wf1c+7yeNO3qM5qKrP8Jha9mV+kmHEY4jmuSYKxxXYaQTZnOztd3ueienq3KUmenIavuu31/lT+/X73XznbK3G6f33end0RyPcNhSP8vnGKt7lXyryq7CDM9LDVVmRG5L8XtcV1BJzpZn+Eg/8rDZnSn9lj78jd/4jYPf4Gcsud5U5g1noUgv55k4njVAMIdAFTgKHzKF/DtnPLkzqPIEaDyI45kIAraeUUe4yR7AfqAe/OHBDIEHRLA/2OZPZrZsEAJs2D6AB2RwoD2jivYowxEEnHslXLGf8PkIMAlH4S+fi7MwySxJyAf/vn6hP/PiMsgDWfCPBxaqdiqbLgMG0DSvOe3hoc7PgAfcnuhkS2Zm+XVdg25pmzgdcmzQy2kDdDLIg4y5NtKm8jbAy4MwKfdy7pweSecKzwwyZpC6squqdqij+9jmkiG+hc3XPWuJNm6KoCTtCDjPqJr/nANoShaRcMjx+TlK1cMT/46soW/402Wuy2DWucuWS5qxBGLVtUqB812DkoDnwDkGJiGUqZku8BWIYm8gGUwaNJNVCYRKSTueCDgdwqfD5BDeUlqaAAWXfBxVH0mLvLdqNGfZqp3R984J6GjQCbHOyBgZgN0YK+F8XrDF8BuVTYFzHnhtwTPxTf51gTO7njiM7ue8dDiu4J/KcnWsFc6jOlX5ztAeGdvc03pnexqp6whxySitfw4XpTyySgJemUEZ2Knw8nZRInxH3siokkzkCQEGm+7pjDlS51EcKq+Uff13RS3wcwquBIzWeho8M0Om+51t5W/HYcS/WbZqpys7wqmjQ+JV9V+NbbXtlTF281PRbETD0RrsxjLru2qnmoOq3xHfdTxS4TyaM2+jm7+tv4+1rap2ckvHrL9uLrKdi5Hto7L8n60V/93x8WhdZhv+v6M1bc10ZEJnH6Z+r8ZZ2XYj+2zr79n1KwE4aoLMTIFeHtThAG7flqYynDvCQxwyeAgqSF8LpDMJTMl/wCEkc5htLzxcBuAV8FUwhG11ZDTooQ5Zz2RE+ZN/6vKAHceNDITMtM5zUti5wVY1MhkIyGQ/4Aye+s55U37WCucZgQv1GRs2Mn4XGUlkU2TwDL8qHV/us/1f5YSTygontcVuFK9TrUN+e5CoCuYAfK+caKe5Q8oJ7w96cT+zbmg78QfH7LOTDb5GwIO2uObbmqhXBVmom21V/lCl2zKDz/nE61Z2UsrbTibm9byX2WrVvDluPjbKEWx0uZPj45pn9WRQTf9Zxz7u04Jf4XdvHztfvzkaCDz8QTLjphz90o5vXasy+GiPtnQ94y36j0xAhrHOPSPqkgeWKlgxKkdvNsuyAglspaZymJwzTCrfzlFJ3GBYtamglaenqg0Jbgk3X6ijcc76XDXSOsOsWnwrsMWIrRb36ng6w9DrzMa0BWb1RsYY10b9d0rpWDyr+U/6dIZ0hdeKUVz1Oyu/5d6oza6dpKmPoeP7bCcVY9fPiPdJS1W2EoYTe6BVjzeu6DuHc/IhOO5vmHNFUz0Z8e+ZCo5RlkpXeEk26Z7kkaep6jpPRF2h0P/VAE7/itf53d3L+w6VgdnxQtfWyGnsdNKov66frs9KRnXrvRvXihzOtip5M6PVqL3R/YSq74oHvP6M9h3NOvwqo3dFBmWZkV4bwej+FhndjW1WbwVGOrPDNele0blqf7SOVn+v2DlVnep7h+toPFX5qt9O1uVaXJENK2Ndpe2VgiqDoaMJ96V//a3QukcQR0Agh+3q7oSiM/XRAyXOT1E5HtJgC0jv6wGSZxARVEFXk7XMm5TYZuKZSQLOZGFMnEmEnldAhe1gtOdbpVy3e9azQLYB2VsKdqVNgENKRovbTvpOebWv+zjS1Hc8PRjmjjeHiUNflSf4x/ySmUQSAUFC4c4LmlRGvh70SUjcGU+XzeP2WAY9nDZuN62ucbdDPYMleVdQ9c11x9PXgP93PB1o1w+FdjpxLQNtuW3Oy1VBucTRrzH+zDhKXe1rOLdfOT3TNsq5yKyZyub3trhXZSDS78hOYO04fTLOQPs+jpsi+AWPUMbfxJa8UIG36Wdn5dll0I/1keua+1mO2AoJO7wJzoOGq/bEUYGlFaOzKlsZG2moVPU0KDlyTIQEqb8VDmHr0T8UUAqbZHQi8M4oRACJ3jtuI0asoDNGKkOmu1/9rqAz1EcORLbvDFrh2I19ZOQda9yeJ1RGcfV9dG21n1EbHf90tJ71U63FnP+qj6ru1nVNm/m9mv8t9JzhMUrHnM2r48RrRPUdAcoTBSkAvR3mxhtvPHtKyOt3OXDbn8R5u9V/spzUDoF1Vw6cm+Dt8KpRf1LBPdLXwcMD7an4rgTMnFDK+P2VeUxjpWqrWhtbHcFKHl4spJzPtisarMiAqm7e9/aqNeptuHEywqW6v7LOR081Z9ey74pPZrJn5DiMZHM3P7Mxb5GJXfZs10eHbzfGaiyVHhiNO9vKeiP6VrBF71Q4OK+6szerU+FQyfJuPPrtTlv2kXUqm6zjoVn9EYDXsTbM5QSnLba7wLcuCVyfcWgu28lx/Pj467ZpQx/PKsDJk073Q6MJWBFYuutd73r4rV0T7gT6+bBqSzaBAPzdSSSg485bvhJcGVS8zIOsAqcROp/MJn8duOrzgIzt8bqe23E8mADN9Jt2/FwkgnK8TU746b7++w4T9724RiBK9glzxdZ9ttnRP+ORfye/TjtHhINsJZxbDxx5lgZtCLKM04314DDzr/yBYa4lvme2S7aXc5CBQgFzUa1XxumHPmMv5EPEbMPHQx+drnRcK72c/WSyhc8H332tekAz10jS0tv0YGG1HtK+cxqkPvAzlOjb6zkNCEwnHj6P1PM1XeF3GnT27Yp+qL5vd/WxgI/359ti4XXkGeu2Gmv2mbzhssFfkkD/+tD3uQWWVpXayNDqDOHOyPEJ0oC19UMRbxEKwcrBu57eSQBK5UnxrAzl/Hh0b6vRnpAM1dFmi/J3uvjC6WiZdUd9+QLLT9JpZiSvjuk8nLVV6Oi1BVYM7Uqwr7RVtdkZnX7Pf2fbM5xnyvVY2MqDznsjvGb8Wz3xqXDgP0Ekf7tb0o6UdrbuulHoCjQVVLbFGQ+SW+qXABNvo/GnlQI/twDjzw0mDBQZxuy79jGPgm+XGkbzVBkIfr0yrqq1O5I/VV9V34nHbO3m/QoHn/eZTEx+yb79XrfeK1xnNE591LVR6ark66RH6qiq7RlvVvq/G3dH1+w/Db1VXVzJ6U5OdXh09asy3XqodG4HI91QlUmjuKu3Kte7ea/qbNXHM1tj1veovwwQzdoetdXRnP8zPuDaip1ZrcdObqzYHZcT3GFz3eXrwB05Pw8Gp9XftuZP9QlaOL15i5vucdA1H3f4FKjxQ77BTfqb7We+Td4P1+aTgR6uqQ8CJv7CEM5+El6erYNto3o8/AJPxi0bgFeJc86Uz7EHlQhgcY4UZdSGn31UbY1RPbUFTaA5GWIebIL+alcfAniefU1bwlkP8hSM0rY4aIDt4zqjenuaZ1NAa7cHfR14kM3v+X9/exh09DfcVX1AC357lgeOP5ByPgNZfi3tzMzWzyBbbg3saJM2a2cTVfoht8ul3cNvx73ampb08PpVNlVmbnmbKT/APfulTNKB8RAYdX6rbGvazkPhr4k5Hcl22nB+8aBOJrzgsyi7T+uEQC/rVwFw3hiJz0C7vMWRtipcWb9ON2iiNUr/lyRjqTIkgVRUMwOnM0or45LT16nHIeC87QHFgPAlNRMB5XjQPveYRI/me2pj1nXB4GOsjOZOyXe0nSn7FBIVbRNPrzcCFq6YkDdFoFxdUXs/idPVDCP8ZrQfzV/Ob8fr6Rx0fXbtjNZXhdsKz10MoDxm43BcRo5B4lzRoRuPC8rky2wbOcETAFK4OdQSWePGR8qLFXq74FbwSPUxSJFRyr7kTZk5Zhfs0M7p7QboTNZeaVjRDd06qtZOBxXPde25/EwDoKrnfVQ8NpP1Ff8nr4/olu128qFaPyu62mlSjavDKct1c9DN52w8VbluflZ4v9OXyWOrPDfCcYX2Vfsj2Z0G6kjeVVA5FKO+VsbuxvxsDtJuWZVXW+XajG87Ob5F74z0QMXnWT4DWv49ncJuG0g1Vu4nb8905OUEzhr07RyCzDJwG13gT96r7FyVpz46WzasnzXEGUwKIhGs4aG0dDUOGkEB5oKzD3nI5NkNbi84zvquNjgA2B8kkQ2ke7zSnMwed+B5kOTb4LC/oAVZ1W4bMFZw1z2CT/6WWt9O6JlgtMc9tiLSL4d1e0CKB/5OF85sYZcIwSiNW99FbyUD3P3udz+5z33uc/ZQDx7ILB0fG3Pu/XENnNLRr9Ym7TsdMpOH8eVarGyY7Df7ya1jVZ3EwXV7rgvG6+upo4/L6pFso57TZRQ08fnywFr+d5z9jWdd9pbLLR8b4/fMfcqszHkG6qo5rejHtjEynBjT20xW5Bw67X17Hf0zdtZczj0y4N73vvdBbvhxGHe4wx1O7na3ux2CS69//evPzoD1RBkPGHUBS5eZAgLC+s2LAs49sNQpwGOhMoSdcbyM94sQ1VsefLsIBNJv9vjm25a8HY/ew/BE9SsjxtPKNPm81Ung+6xRYiNDtbvm9MgxV/SY1a36cvqmIJRyu8c97nGm5Ehl5W1THuAb9XFesNLmqvE7a+M86q7OZ6WIRob26JrzRrVGOwena2cVVpVSd69a7zPnqDOgq3a9fPbhqfP+pI43UXq6eoXfiF9SqSAvZMRqbXG2w6te9aqzgyp9fMggf/uKp4WrjOQWrz3txnkloJuDdAAqGTQy+ChX1R/1XeGXZSu8vM9ubea66+qM9GZVtxpTNb+Vflnhz5HcqNZOluv6H/VbzUvOZ/afkPdmc9zRbGZEVvis6IcRT1VlOtnWya5Z2yOdkmWyrc42mcmSXBcrc9fZIl35Y2GEu98bZSvNaDBaL9nuDA9ku/5LX8h5IOihbH1/ALEK6Tx26+9KgDuq2N/glZlL7oxit6MrCY6QKcOh0zxhx/ETDdXWne50p8N/OWYKaJBRI8AG4EEQ29igm9qVbUyb8gE4BFzzpXIEpPBHmFMCEqqDn6B+/HXibLsns4q5oz7b9eAz6nL+keghpxLagLPTFwfYaYuMI7ima+BChjU0cR7Ks5AyKOMP7PVbNpDoJLpzuDq4KrCkvjQ/97vf/Q515SS7neN8AF3cUQY3xyPXamax4OR7ff+uemTIecDEeZd2K1sht31l/5Xu7XRUZjT5vezX31zmdKps2UpfuNyogjQVftXh6ZT1F9jknDA25+2Uq5nZRT2/Dw9XstfH6LI2x1/pXwcv51sVPcB6bWxN9PnPwJqXI5mD4Ctl/KB7rQ218cu//MtngV6tJa0dBZgUF3nFK15x9kIg6IDvTnzC+Rg+dVmA36Kyjs8lPbx71ejYqrySqao2mdBMRfMFJaiYxtsRobRFRcJTykL1fGvKaDxqW3uCFSWEWSQAOYNFSsyDWjODwBe7f7L/CqcZjAx671MKT0Kd/dH6iC4cdKh0Vd6c0eGxivMqX6zUX3F8LgaHES7d/UrBJF5bDOqubNV3NbZVI9vrH7t+E58VGPU1U7hpiFZtOxBQQtAiYPVb/K0gqhtQHU+PFCx8SJBba+i93uu9Tj78wz/8IG/Ux//8n//z8IQBAxTQd38rDTKM4DXp5R782uIAX0qY8W7SbDSvWd/Ljnhl1l7imcbMjBezncpQOwZyzXVjqYwvr9+NN9uvaF/NT9Vup0+qtis5ONLLo7FUfD4yiCt8q75GBuQqVHJha7sjPd2V8YBz4tG1Vcn3dDRWYIVG3VyM1ujWNbRlrqo1MGq3q5v1V3XuaN0SIJCDICdC93C+/dDqDs8VvqfcVv6+FOCOXpWVkvJY/3mhD/fY6qF72NwemONAaexZtrLxcImtV2QfuO5We/5mNPQvW7oEZC+Av593Irxok+84axqHPgSrpPPxIzzbwM82Ybye3QEe8jn0nQAX/EI9PyhY4/cAgL/pjcxqjhjRdTmpnI9EprefY4sfhjzC4eXN3dBTZUVv+V3QBdpp3K997WsPZbQbRdlLus8xAqwN5lMfz3pinJ7lAeSOFGjhGXPOj1nfD172bBPadl7ttm9B385mSF3p68DP5PS1m/ow8c+y2XanA1OO+HiZ4xy7B/xW7PMVm5X5TDpBE09y8LXhb410ujt+nQ2V2Tx+D6CMByV9Td4Uc582a2f/eMwAXJh7gr1aq7xciK2kjFv37nWvex3avP7668+O22DNevai70BK3mNHBzKSYP0lDyzNDPfZ/Sw3MjYqJUx00COgLjhwGkfGGVtUXvOa15xl6GiSZk+GmBjSWF1gI7RVRs6jR41Hxjntokg4i0XfhQ9vrRBkdN7rdkZ1Z0RwT3groMRBgH5QmJhXuMjQwSEfbYHKMVXjHEHyQmcAV30lXUZ4XUqoeLYS/v6beingK4dlVHZlbKNys3mtFFOOuzO+/bdfnxn7I6WX7eX/VOI8feNAT/hca19rNg2yTiFWdMnfkg8PfOADTx75yEeefOAHfuDJ4x73uIOh9MpXvvLkF3/xF09+5Vd+5SD4s57WnJSHjDAMWwy2TGW9mmBlDXbKOo0m7neK2ee14qX87313PNRt5cl1yLVqvKP1t1Vepgzs5EHSqJMfVV+jull+ZYyj8mlIVmPooLtf6beOztV8dWU7enVj9HojWndtZXvdvFV1ZvKzuz6zSWZ9rpQfzdsqrOq1Faj4esWWqerm9S30yP+SPXraLKcauxLDnoBI2n4jvCuHqXJurhRUMqGSQ/52MWjlDhh+ABk2XGO7l59XSFtkChMg4iE1uhdcyBrOg5Y90IC9TiaArhHoUt8cyE3ACb+AMeIw6jtvowYPAj0Cz06irr8WXIEpDhlnO1qeEeNb6vKNUtwXTYSP/stO0oetea4fVQY6QW/fBocPht0iUAaSb+3n4ZjoR1YGASnfeYKdpv/cY2wKqPFCp/T5qq1kLrsy+QB6px2QNonzQrWOCDL4dsLkb89egT8SR39oAJ3T9qlkMfj5OvIxug2Z2UwecACoS1ag40kdL5fyeiT/mYdqWxr3oFfKjJxr1rjze7WdsfrvY/Ygac6/j8nnsstcuzYCT3x3/FnDvtPJ2+INlLwISGtAsk1r03mV+kp4UZBWvgby0dcQa1VteyaSB03JqoSel/SMpWMhjdV0CjqHomrDD8RljzRCj6ASaWCVM+BApNwPtsq+EofKKIWhidznJIwUOIudiDyv3yRwJedS22YkPGfpaH7414rhAD1UT4zq5yt5RgdPX5R5QRpyl/I4G+8MRg7NH0boHIiR8zEzGH29pGNWXavqd/fBpSrf4T4y/CuHNZXgitM2osmobNIFw1QZeJxLgNHnZytVdJj1mb+1jh//+MeffPInf/JB2MtQetGLXnTy8pe//PDUtTvLTeDB84qOq3x1uaFT2jNDg7pZZpU/u/nJ/ym/va4bElWfnR5ZhWqtOuQayd8jGlZ0r/DujL+EkfzpxjKb15EcqeanklPVtfyeNFkZ16jNGT1m8qsbf9bvDN+sm/1slQkjXLt5GY01x5NwMbJqxqfHyLwVWbqK0xY95fX9v+pIFylLQzYtzq2cZoFvr1rh35ynysaucL+c4HhUDyp9DJnp4XLax4CzhHPENir8Atmw+u0Oluxs2bQZPPLsIt++ou9sk/NsAIJW2P8EaGRXyB/Jw8DBnwwLZanxAJlx0x4OPXQhy0c8g6/BOMjo4eE0WyvxcQSOJ33hvxDMkb8hfPyYAJVVPx6U8iAYgSt92L7JmOnfM8TBhe16zIt8O7YqCkRLMsh8uyNBPeGj/qAf68QdZc+6gadyreTLWTzgkbxZ8WClP/KcIw8geXseuOtkXm6FI0CQfXsZcKRdH4evK8bU2T6ZyNHpLb/Xtcd4s4+UbR5U7rYrZhAot/uNxtPZU9C1k7XON06Ta+y/ywzHhX4r2jvPJo/qvoLSHIOhtUF2oe5JfuDDQxvWC+PggYXLRD+s3sH9D86TuuKBpZHhktc65Zapnt62BivhIwJL0BGFZ3+0hEx1zlGHH9cqY7wqR0SPyYEBXPGtGivUk0DX9jptR0MpEclni54rplwUBKZcyWGQVHtyky4oSPaoMk7fqw3Ter1KSHZOx1YDbquRed4wMpZn9UZGnsOINiMedPz8u/e56twkLjmW0f2unQ5mvNApok5JVDjN1j3rIQ+ky3ojQ76ipwOK5f73v//hwD319WM/9mMn/+E//IdDptKrX/3qC7Kjsh1kihuuyD7PXJrhebmh4vlO1q84nNVcurOR97ye47KK+zH3u/W90n+nK7t1VxmxXVuzMeRTwkr/VQZjh3e1TlfXprc/6mel707GZvkOj1H2WtfuSr+5HpJnKhmetJ/RZss24cQrv3djyj5GzlDHS1nG269kxwruK7BlTqsxdDh1+n2L3SO7j8OcpS/k3POUOp9mz2yGtGc73K4UOG+ObAofQ2YGoGMJaPiWNEE+XObNbjxAxTHUd172g23gZ7WoXer425YEBHLow7NveDscOyEIgjB/4KC+2QJJWfDw14pTz19DztuwPfDEuLEbCC6RHQ0N/W1tBKjwrXwbG1vfcFSxS1QXXKEBwTT15WfWUscDZ/4wXgFV4aGPHGj8HWiQ50IRGCOAJlrqaAG2NnoGDuOqZLHzEjhxrwoMAJlJkzKUshmcGrWJz5XyLx94ZXZOJ3u5l9lmXM/g0yx442PLMXv72Zf78t1uh6Stl3e7vdP13p4HEjsZU9lmI/vH8fYANtmKlS1+UxyI7/PnfEwdeJQ15vOsfhTXEI8TaJW8ELCNlrNcPf5Bu34uHOPw4zQExFBc1zDuDASe6+HdW5WmMwaEdQb2cvnbF0wqVIQAQpiFQyBkNbBTGcwrIOJL+PFkwrfEoUh8wjqAHmQqXXfddWW0vIoYOk3VtxhKEUuUq+oLD1dUnZHI9iBlJJH+xljAhTL+5Czn04VgCi7ubzUEc7zH3KPvY/vdin8Ku9G6GRmpXXveRiUgu7GOnBz/PnISsv9O0Wydu5EDWo3d63Z06KAzzGeGuN9PJZJ4iPcl4J/xjGccsqO0/e3FL37xyS/8wi+cPW1AgLvi9vWEsalgM2n+MpxuvPHGs6fZFU2uFKRBUt0fOZ8jHsrxHbOuZ/13eCeOWW7kiHbrs8O/anfU58g4GuE0KjOSV97fqI/ZWGd8uiLrRrK5G0vXd85XZ2Rm/eTbzsmYrY3qnhue/E4advoDXdzxRrXmLmZNpc02G+tItl5KGTbj2SprYGYDzNbLSEe64c8ZlrLZ9F0OfmXPrs7PiDeupJ4Q5JN7QcpID+BU8oeghOxvzhbCWSIA5A9+VY5zSvyoCeYG58y3joALgSsesJLlLGC7m4AgDJkFPDzi+Az9J/iRW9/BUXU8SOYPmQQEyKq3wOELsdVfH3YZQGvo6tkuPCjnfCTKE2CjHNvzCergvBM0I0hHP37wL84tD8toX1tAldGt+7Jr1Ie3wfEkjEnjhP6aR2WG68M43O/w7A+Xo36f/6lTq+wi502g028uY70O5Vw+Z5CH/94OO0k8oOTlKtlV2R0VnlUwB7/Py3iAz9ek76bp5GFFS8q7v5t+o7fj/VZZR9Cokm8pa5xuHU7U88AkWXPwiOtbAetdwPpgvVGnOqqHNhxHzk6iD+10eNCDHnTwC7RWhIvkCmtIZeQf4KszTt9u58kmHujNLCrwoM4lCSytGmhJKP+ujyaEV3sj+PMtTFsM8MzIqYzAjpm3GPL+nYO/BXL6SLGVMPQU0hmNWAgSmGIMBakYE8oq26mYUf3zxgVXjKTCCvKplwNOsNpAUSd92X6YggZlwlMa6IDSrSLwM8N65GzN4BijKZVA12/VbtdfZbiv4r+1v87Q7MbTCfgOh5ExXq2VLDeaz5GzmPhUDtDM4F5xdGZzmPWq/vNpCkbYj/7oj548/elPP1O+GJW+jpCLGK0cUsmb5GQ0oXg5eNSDxa4ItjiFlwqSnqtrujN6sk7VVsWjWbYrM/peOTQzmV7RoCvXzVk3j1t4eUSDbiwj4zPLr5bbIgNHeq7Tx953p9dnOmfUbodfJd+r/n08Iz04Ss/n94pMrepvLU+Zlbnr9GdVLvtzuZX236iv2b1Vm2M0v7OxZp8dvSr9letQOkFZrAB212wMVf8jqGTClYIua0SAfenl3OHlN29D8iAHD5ihB+sKB4kMId2XnS27m2M1OASbPtk54IfosnXOt5MAZCmh/8GTnRX66Dtb78mU4ggKsqLyoTn0wEYQzu44kv2Dw+u+g5fz7TW07UeB+A4FAf4ZNIeuHiQh0CG82LLm9pBnf/l1MjHwO3j5kR+oDp090IZ/RAaWrslGuutd73p2DAqBKZeZlPVzj5w2lRxzmUwdAgTOi84H2Yb/Tn2ZNrlfc76HdvkQP21Qv5eBFNqurmegt5KDTh8/BN2zvKp6GVCr6O50dt71s+XAz3ElkJS6xGnusoV7GSDL4BH38igK/+4PhjMIea1lTPmbGT04Bx0oW9GPAKp+a5x6QK21z4u2yDbUd+2O0KHd0iO+DdgDytDA3zrpc5ry1wPQV3wrXLWw9CFVS5E1gjESInrVJIKgMgrz+8z4G+FS3e8M8GqR859zWiTIpAx0nTc95L7aqk//T+aTfpOqRjv6rz78rSBenychKD8WGYxKpgNPCyra8ZTsda973aGumBSlC2MrBU9lnGZkVGgLn79qUoE1tUX5SuisGGGdEdTVmd2rYNTPCswM1jT8joFUjFVbyeMzB2crTTplm+1WTlY1jlm/s7XjZVbmuCtXXVsx0CteTty1fnSIHoaI34OGyEStOa1jzlaTYiBgLOOW1/0KMFJ9S1w331cDVPzbrf3OIOvmsOL7zhjyfka4znDK/qtxrvRV9b0yf7O1n7yW7SZNcgxV/arfqv+qTHUt5Upl1Gf9NB5X7YAZn62umZFs21K3g04Wdb87fqnmcIU2W2g6w3NLnVW+p+zo+mxtz/pJWbPCzx1fVLIscXTHSvZSZxvNeHgFtpa/1ODOloBslszkwPFCj3p2jLLsCRL5mT6+fYrf/l/A2UfSpzrfCt3LeaZ+cK30tHSw2+Ic0u0ZJGQbcSC3HsbqPw+TyJbSg2QFsbTzQW2qfY1FH+l8d4j5rjIEnvAPyPwhuOZb2ATudPt2GRxG6KR6nu3F99zKJsiHywI/DJg3VWHf+DyAL0El/BPRQfTgAHM+AujAebrgxAe7SG2KrmQ4eYCrsmep4w6378jwax5M8iCAt5Nyw8sRqON6yoWKxhlw8HLZf2cD+U4ev+/ggSsPVjnvVDZZBoy4V2138wBH2sNezoPHHhghcJNBma7/KrPK62V2TvKJ183ACrzFfGW22anNE/NOkMbx9XWUW50dPOAlGfSSl7zkkJV0v/vd7xBLUbuKH0gm6PxWP2+MYDp4kUHofJ540ydbafMNfFf08G6fbCZAzpMIocUPM+u7Bqs3BvAkoAMmYWQUZ/m83ilXhKTfq5w2nwB9hDMBFO+zMj4qY4+F4ILehbsYWIySB/8l3pTn6YIYi0gpe8SJfFbtiO7qh0wJFqf6RWHnUwo9JdB8al59PzWBqZU5PQY6A3zFaEoheSnw2mKcj/ikK9Px86zcCIcZLSrHdYRj18/oWufUV+u4w2OG+yrevsYTn5W5dlmBgvY2WLdaK9oCy3kL+i8loes86cOo9LR93yu9xTG7lJBKFfz8Ht+r8hUfVmuhor3rhhmOXqe61jl3o6ySTqfM8B7hkdc65zTb6vih4sHRuB3fEW6d0V71M1uLVd9VvQ6nCo/ZmLNMfq9oWK3zlXGNrm2BFZm9tY9jcJm139F0lWar/XR21+xetp1zNBqX49nxSuqwDjfAnYC0VUa4rdAqy6xub7hUgG7DsepkqNNYwR8dGyEgWIN+9TcZCXDq1A/Z/NjaBCjYZSCdq6AOuyhkt+LYyi7GcaNP+vfteODBQyGBP/yRHe6ZTgKNicAOZ6Ky00C2gK77m6cVqKJNMm8IWPn2PBxefgPQEnoooOPnIfnB5h70yywXHGGCfH4WpPwHsoqch/O15bx9TjiK3mR4QducQ8bHHMET6lPjYEucyunBdrWN1O2E1An8z61RrBUvz7XcNlYFa8A/bT/o7Lh45kvKFupVgYxRhtVI9via84AQ/Xh/zg9OL+rkfb/nmXJVgoNn+OQ4qgfZHnBzeZl9ZRlvy3k65a2Pt5LhrGEPGJ7a2VWqw7ogMMkYCdr6WWDOKxWfUEb9siuKdcN61lpSYIl7yf9JJ3AVdNl2q3b1RQWWVoyZqpy+SwApVVGvrSc7hyCIFIV+K83Lo9s+oGSCTihUuHT4eR88ASG1TEJRASOEbkXsFeNyNDFMrujgTwxUVr+VFioByWsDR23AdP5kg2sZrU5jnd+co+RvkBBUBojoJUXs2+BoU+1JaWiu/Y0mI6jmZAusOCzVmDvj7WKM/lUjeOX+Kk55r1ofKRzz3mgt5fysyoIZzAzmxCFxX4WkYSrFbLeiZcqAUV85b9UTEa0brRHS4AkQU59gMAdZ8qpd30N+KebkPMDX8Sq9uzF04+r4tLpXrZ2VuazaGUGlF2b1klccp1WeO1ZP02clA7s10+m9ahwjWZJtu3xaGWund1fkfSUP8/uobe65XeLQjaujbzXmTqZ3dE08q3FkX6M+KlpW9OjGXo2xqte1keU7Xtsq97bonKqOy/NR/RHdEvy+O2gj27Ki88p4rgZdkdszOofVf/Mw8773ve/BJtZ5I36gtNrBFnVbWDqWLB8Bb1uWPiW4pIx8nDE+6GSCS+wg8C04PLSVvcth2CqnB0NkoAHen5+BJOChsOx93WMXgjv3nD2EPe5BF7dP2CLIWUie+YNvoPZ5YE19nEs/l8rPYEldzdyAH0eA8HY5gne+lQ0cOG9K3337G/TIrUt+sDDXwMvPk5FPovkmsyyTAxxy7cCPK9lNVRKCl/WAAPc92OS6w9dxBnR8HrLOTL5QJoNRWT/lmm+Hc76qbM1qC12W68bZ2bBVfxmAc3mRQb2UGz5Pnv24xZ6qdCLBTh/jTRGM0n8Ol3cfP7Omkg7+9jZw9UO9kUWSgfpNUojWkh/+n2NgHLmuU5/RD0Bm4SUJLG1RRKm42EtLwAOAISRocn8nfZI2SUoWwipx48mBl8s3Qzh+Xk+43ec+9zkoBNWXsNIWPaWcMQmVc1gp/sqwre7BYBzIC510TcwhplHWj789KtsUbmzH86cNvCkC3KoDzRKXajyVMBGIRgThSJtDgQiEs2jJgvK2cg58TBVtLxaqNnJRJz6r7XY8dUwblZFflUlccxwd7604I12ZbDP76wzgmVFd8dao7VQ+3k41zop2WX50rcOpGpf3082ll0FWYWAh18hU8m2tGM0CnlRUyv9KQkcPYEQzvqdyWx3XqOwMry3tVPM4470Rf2e9ytCYyaXsvzLwOlmwReZVBuls/qp71e/Ef9R3JXPTgPUxjmCVDtWYO9ndyUP/XfHSrJ+RvOlkV9d/V26rDsx2Rm2stj3igfxe8VFF54sdY2V4z8Yw0u2zul7nYul5XvXOE6BhOp0+Zn38ib+AzB4ewqi8v5nN/QKCPrJTeZGN6uZrzHmQSpaQ7vNQRzjgS6CrBarLG+b0nWwf/fZsJd0jUAXd2VrHWUvseKAcuwTwe2jfHzyTAcEYCEyBm59nS0AN34vxK5hGsMa33Tn/ebZUHuLL2LBRuMeWft+aRznOmRJeuqZMI15mAniwi+sZaMJf1HcezMsm6l50VCUmOK0qR5/73dYu7vs9fmeAyoNKlY3j/XudSscmLj6G1H25XazS4V4WXKiT5ekHGmR2UJWx1GUXVVvw6CeDYT4Gx80DcNU85JxTLrOwuJ/z0MknyiKLqrHf+u2BXYIy1Tzjs/t8etAyxwkQHBaI//0N104LD1A5PXxbYmeLUO6SHt7dwarh7wJa31EGnlmTQgvhqACFv/FM0TnfHoYA5ABrhKFSxngVX05eLnq1r0g3KaXgRKqo13FYMZb9Xt6HLpxJRLYUB9B1W+CoK0A5aQwaC+mz+vDq2kyJTbxWnJc0kvIgPw7v4+OKyfHdamBdDKSgyeuzelvLjGg5MzQ7R6JSXp2DxfcZ7SoFSp9b6V4J3gqvlfojSHzz3gz3ip6d8kxeRU6QTl/tX862KzyTJtA80/pZu5lezRuDUi7MnJDLCTmXM4czy+X3apwzJ69yKCv8Vnm9M+gq3s25qBR3xa+dflqRGR1U+mmmT6rrXb2VuV2RTRX9qjFUZSq+yXu5pitDu5K/Vb1KvmU/FW/MxrQFjlnnlXzv1saMP0cw4pURL4/66fim46WU6TPeXhlTNY7ZGDHcM6Nh1M/lkuFXUlcwToIc+QSdD/qV+9J/ylYisJLn7fj2Exw7lZEfIJ+BYxpwZnmlPTa0glDaQaGgi/rzs019qxgPgwQ8xNV1nDoCYO58exmyrziH0Z1e7AEeLkEvAcEmMpIYC+cKeZCI3+Cna9jonMNCm5nV4y8BEpA5ge3jMtPfigcN9ZsAE3NM0A1bRzTylwp5pg7tgbuf94JfqLb8iA7myWkPZNClkuU+LsfF3/DF/NEnQT3na+pT1s8XYp4zy8yvM5YMpjkf5Dj8k+06zvTjOI5sx7znQaeKb5zWVaDLv2dQxwMzKZe55/Lc5aqD82iOJQOCTnvmqRp38stoe+Bt3h7Qdn4nW5F1RMKF04h14hmELqsohx/CeUlZxs9E8vnx86AyA8zp7TwMvqv2yrkFlkYd+mQQUZYwdeEgINU0hSiZRDoBncif2iI7h4i7ykmYqW1STDnITW1Jqbjictz10eSrLAfuiaD6rv/+trMcUzf2VQPI6cSb5nyiu8Ve1eXAQVJQWUSkz7qSAJ/K4K1+V31y9pO/ic7PhRHdPG3X+7ycxlNneHaG86U0+DtnpWsjhdvI4cqIf45lVDfLHEOH0XgqfEY4jWjS4Z7OXuUQjsrm9wpXyR29eUEBaO1lJhU/FbQL7A4njEb9J8ju5yJoHclI4ymcQH1J5umTQd2OLpcTZk5cVX60BpPvZzIr61VroAPvq+o/63dG2Gj8FY5dexUvdrIzja2qTIfTiixOg5zvW8abc1jVrcZZ0TzxyDHP9HJHm87A7mg+Wt/ZNt/TeE68tqydrs5oHN14EqcVGnR1V+5t1f8V7p2s8P8zfFfs18RjNk6cCwUoZI8p850M05nOq/5ntoUgt2Aeo7OvpL6o1qzrTXfyfOzYu2QFqTzZL37grMoRfOBtYyrLYd8cEs2DWOlW6XcyhfTddbTTmq1e+DGuwzmLCadR9TwjSviAl2cDZNYGut3pIrzdafXDqX2rGcEyXkWuttiGg9OJbU5d305EWWwLbHoPkrn8TzyZN9EYP4wgGg/qOVNJPgTzmOuZwB9zmgdg8wCeIKKuc6ZrvgW70pEeAPFxeRkPAnm2y8gOAfDBoJ+Pk0+VLZOBhKqflIN+37d6MYakg/vaKWvAJddq4kMZeKrTv+AAPbKNSl/5/BC888DbyD6obCf6rjKqvG8PdnmAKufK62WA7NQCPZzLBg5at2RF+hvd9JFMEf/Kl5fOSB7OwKD3w/oc2YjQ3s9yHgWOtujSy/ZWOIABirgiFgfT+pMKRc7zVfZ8/E1JzvBy7kR4CSYRWmWI4pMWqkmTIhGoXEY36Uv4SPgRkdd1MYS/iSkZeTQR1fUVp6K6Xhkx1TXRTspTOPteaU9RXTXSRn3xm0PE9DYKFqv6VhvsI+eVqd34vM1KUBwLs3aqOdxq6FZtrjoko/ozoz9x5nclML2c/1+lcaWUR/OUSjnvVW3nvWrsXd3O6K+USgWJbxpMXk9rSjLnSU960smDH/zgk6c85SknP/3TP31YA4I0PitaJV20NiQTScGnvuSWFIxkIsqFJ3ycA9HJhivpLFzsOprxzYiWI37MchX/jNadl+3KdHh3fL7yO8dZyesZXlV72VdHk5V1vDKWbj2OjPLqWmWAdmOczWc1tpHc9f5X+GYkqzuDuGtvZTwjfFP+z3h4dTxd3xW/Zj8pH1d0Z/ab85D4Jy7prM3w7MbXgY9HNuUf/aN/9GDvvuAFLzg8iPA3H3t74D6jVVWvo1F1rsnVBOkk8qmyRnJu0ZdsJSdgQmYAWT2ivYDMHPkCsld5cxuHfXuAwbej83ZWgb8lzh/+uL8h/0Mf1SE447qaPnjbKwEu33mR9hNj9212bKHzrGnRRH2Dq3jNaUZwBiedYys4QBv68YIQnHDf+seDLw9+wFv0r3FpPB40UptaD/qth2I42769j8CRZ4D4uTX8p1yuB8ZDYM13nYB/2nmZSZS6xR15z073vvP8Xejt9Z1O/hDS+dkTFzJonNe9rypjxrNuUuf6mnO6dPrJv3uWlt/zM7nSnqZclTHWQfZTJYWkbKv8jtQx3bayys9x2uacOB6ZYSeAV/ycNrZoMiZ9v8c97nH4qD3kjNaQXubzqle96uT6668/e8OixyFoT5DbJcGFnVeCzKYEaKvSiazJkW667IGlSvlrwBI2r3jFKw7Ch7fBadA6R0hBEcrnh6g193laIAHLqegIFYShL2AJTl6/VxkwCGxwReCxhWxkzCaDz5yD1Ta6PjvjjvKePlstxG6e8toMX/UjptcWPr0ZjjNidI8DhzkQccaUlcDJRT7CJ8vNys5gNl+JezdXWwy6Smh1hmGWAY9Zn4lrjtHbyDLd3KSSq9qt6DlzUlJpVONLA6zqewTZr2/fTCWJQXPPe97z5H3e531OHvrQh5787M/+7GENVFl5K32TqanvPL3w7b5qm3IeIE75WinJKwEjGdk5SSNeqYyCWb9pTFVrp+KnyiDx69W1qny1Zkfjnq2pjo6z67PxjdZ30rQaa6XjZ/e7ddzNbSfTRjp2RvdujCNZuAojmvi1FV4ejb2TsyOY6f4RTimLZ/3M2qpw6OZpi1GbbY7W9AqvH2NHUIeHev7QshvLbC3MeKWSLZ3t4HUv1k66GHAnHceRIIbL6FwP2PUcoUFmkICAE3pU38lgka+gnQ881JYjJ9vVt0zpGgESBaBwmP0AbMcVW5dy/mpu/A2y9z0rGd+FTCu145kxrsMYk+wDgmmerUOADCeYjCjPziAg4z4Vb+lmxwFtCSfhDv4ezCC7wTMfPOhDoEttYb/outryrDJeRJJb7dz2wg6CNgTxOP/KA4r+djz8RQ9YERiCrzxI4MHLXE8uaz2jS9d9m1zafx4cpT3aSDla+X0ZqHBae13apG7aiN6248/9DEokVPo6AxGOd/JuZ8P72vcgFWUyUNbpBsfJy8KnHnTzdjJTzfvKea74wfmlGu+1b49DgB/BW/3mqAutO+1+ULD7TW960yGTDxmhutIZ8jX0QMIzHmnf8coApvdPNl/OvZfLN9c5fxCs5hy4KxJYGjkNEFUBJCGpoAMDzi1TlBf4/l2I5WmvEAmBBg607VFDcPJFp/vCR3hxXe3omra6eMZNNc7O2ci+Vmjn31eM6aybQsDHOcJvNo6qPLRTxoVoh9IjW4knEqtGYS7SlXGfJ6yMv4ItRi/tX0ydVEKdoV45EiOj3wV7da/Da/R7dv0YB6bj54sxlN3gEg9jcMkg4rXDPDWQAtC9937v9z570tcp/Y7OjicBWgwulIPLADc0RvS50s5CZygBI6eqcypnfD6ScZ1z4k+Z0ig6htc6p46yFf5pjFRGStX2Kqz02dGqksOzceeYu7lflSUd/rkOsk71uxv7SN5U+rfitZlRPuP/qg9BxZ85lqq95LtR327oj3BK3Cqcq35XaVA5UqPyHWzVq46/t7FVt1S0wbnWm5A5IiDLr9oCI9ttJv+2tHk5oZIjnUOePCV7U9sMfTsHR1aQzYIjJx2u7woq6YE2GT84SgQtBGTsKAuZnRJ5bk/qe/BVGwQQCVbpOkEljqjgMHF8knyxjQdrCKbgmIqPyLLCtiaAJprgJPr2Md+uRJBKfXGANtt1wIFsLtrBH6oebGVWBplS+Fr0hd9GJhlz7dvtfDsV2dskC1CHAJuuEbTyjC22R3p2h28Ryq2VgI/Lt5Cl3eX+ZmYv+TqE7rRRZfN4X5XOHfltXj6DWm7bMGZo4LK82m7HPGRWleuh5Psce2XHVHaDt1fZGz5HKSfTTqnsO//d2XhdVmeOy4NPLofyAc9NRnfqkbTimXTi5wc84AFnWXwElcTTZBppHh74wAce7pFxCS+xe8EDxjkm/wiQi3nuWK5V1p1vKd7ix1/SjCWgmiyPcINwt0WNJ/cSgJ6phFAitZjgFKmUTmwWSk6696U+9FY2bXXhbCAFlaRgcouLj2UElWOQ9zrjuMMzGX6lbmWQHguVQEZ587QnjYAcdwqBY4zBmZNT4Zu0XKmTOG/BZxU6OqRD0dVNwVgpMO8n+822qvsVLx8z3q7OFqM96XEefE0/Eq4yWJWeqieWepLwyle+8uy1wepL18T3khVSDFsdjgpnFE41zoo/Rg7esevpUsBsDGkYzHizMhRGfc8crqrNrJ84ZNr6MePvZFHXZ0WLCscOZmUq4+piYCSXsswM50qXpTzqaFT9z3GvQiV3Rjivtl/RqhvbjB9GuPm9To5vlTWzsZ6HXJ7BMXw7Gl9Fi5HeG+ltzu4h24RzfqpA3kymdXpwZGeO7JyrAbD99d9t9tw2wzVseelj2Zx62s9DGQInOEtk8ojunLVKn3qo7Q64yhCsIUAin0D11Adn9rieZoeDHxSOv8LWOO771i4ycQQ8+IanoAGBGvUhn0fnE3HmE9k+vk0tX2IEPf2tbGT6qB4P8vGf8J0ox2HZBN38nFkCTvpw9IX7Wj5O8b3wx6fyNniQBh0c/8zs4cMDf+YI/Mha8gAhdT1ry/nOgz3eX/Kdrzv3IWmHefY1Vq1vt8m7teC4QKcVXeJ2FH17QItghAdIciuq98H/KqMp24DeObYMWvn3DPx0dpEH3vz+SJ877nk/6eH1nIZpcyQN4eMMOF0TATWCt+JL3xqrdagHDtCJLbyq41tukTGOr67zMgJebMYaEJCtl7Z1ZlHluvXteuw+oj2yC69YYGmkwCql6EKjU4walFJWlTkgIa+nCGwhUeCH+rxRDSHoB4SzSLNt+hTx1Advm+B1n1VQaWX8M4Pa+68Ex8xhGBkTVbmqj4t1JCpjNqPnIwOsM+iyTGXUreI9Mgg7w/FYmDmEW+FY59FpNFNkKaArvqp4N7+fp3zo1k5nJI94rLrfPbXS9bvc5S4n7/me73kIKiFkeUUxRiBPyjwLkvYS727d5TV9d8FdjalaP/7EZUbfywHJT1t519vo2qvqVGtlZoR0/VRyIg2PxKEzfDr6ON6VQ+l8mpB4VnyRuHbj7/Ab6asKh6r/Cu+KBjkPWXZE0xl/5dpJ42+kTzq8Kr3V0aaCipdXYXX8I1zSgO76GK2PEe4jWs3w9d8r62fF3joWKl7J8XX8yXcchmqM3uZMPnnZLXCl9cEI8mwSH2/l6GNfkuUjf0B6WsGLDFLIR5DOlg5XppLucd4n2+A4I0kPiAhWkW2j37ov/0JBHc4OEg4KpnhWMfhhG6gNshR8Z4WALXUqQ1DHt6Ig8zmgW+MgKCmcORScoArBJj8PSfjwnUASeKosb4kWyN7hoTv+jh8u7IEFMi00FvrVfflhbO2jXtpZbO0RkAXlYwF8TXngxw9rZxuc+hM+nIOrsgSwCHTQpsB9QNplbjIwCa9l+Zxz3yZXjcH9oQy00H9na1T2Y2W7Vvatt5E4juQIOFXjSXmXazJ1YGbLjTJwvR/Aec/H4tu6GG/6O/owDtaH+//wl4A5yEBb9l3NlfOL0+hWbw/qaj0QFCLg42+Ek0whUwhfw89DgoegJ2OmjD6Sg7RDwNjnJM9icp5GTngmI0FbD3iNMprPJbA0M+QcZoZgMpaX8cgi7ShCJyKSjkjUnDqkkin45AvEUyUTP+/fI30z46lqx7+7Yswxdobpln62lO0MtK7NizF4ffyeMswcbG175Ax1uFcOQeI56+NiDbqZ8M6+Z4Z6xyPV2vH/FR9Uc98pKn53fXfzk/SbOZ+VMq36TcU74o+qv47eCHYZPxgs4mF/Xa6noSKPeFraPflJqIyIEX26e9X3qwFSvo94qSpX8WZeW6Ft4pN8Q/nOyR2tlZXf3bXVsSXvz2RSRcuRnBnRodLPVZlujSffdvK40v9VX9m+/670dIVHjrtqq9oW4HUrvl1Zi6O5q2g0amNkAySuK7plK1Q82dl5HY6J66yf0VhWdGLVRtpnIzy6tZhjyfnBuXCnwsuN1nc3jhms2pJXA7DOO72fa5wsF4I+r33ta8+erhN40T19F/DSC877JAihnQhqT2U5P0SOmfwG3eMIB+l3bFgyD8hEAlceLpFJJMcOm0F4cc6QxgEvYCsQXML2oC9952BvHooTsPItKf5gy89PAh8cSLIlODeJQA6ZSzxIxz6HV9lypjYJBuFvEbSSvcQWH7KryITCMfX2OFfXgxycgeV4qS8cXnwJjYPgFUE5zpNiqyFvqvZgFXLd3yjnfkrnG6ITuusZTMly2Q/14Ge/5nWq7Vn+PwOF3if0IvDSybnEJ6/72VqOKzhU+iztCcfBD9/OMfu4s023BfifL/ia+QiJOzzBdzIIPXBU2Y2OA9erQ8WvsfNY6Stx1odzppVxpOC26ujAbuige5JhHKZfjdODP2TvcVZazqPzg8saHxNbgXOeCZBfFVvhZsZBp5hdsIhACH2eIJCSmoTmiYHqq44zBulc3u+K4TczkKpFyX8mPvfpjmiwFSqjeYZvZ6Tm4h7RYGTkqg0JeS0MIrPKBOMpSdfmCLK/HE833tm1ri9vu3IoVqL/Xf8jp6irl+tnxVmpnIx0qCr8/H5VrxtP1eeW+ekM60pwr+JYQUcrlxOkofMdHPT7p37qpw5vhXv2s599SKn3cwJmSq7j42o8KSs6nLOfVTpcKuhkS1d2VLfi9arsypg7Wbulz1H5bkwdr1f6cGWtd79z7mdrtsJ3tGZnY0s5OSs3wpNyM109Gk+1FkbyNg3VmR3Q8dOIF0e8PAKXHckTnb4a4byyHjuaVv36vaxXOTednKzw6fjpGN1b1U05kk7jDPeqLXSJHAVl1egcSjJdslzHwyPen41/Ns9XA+RZH0l/P+uFMm5Xy9Z/9atffdi6rqCFZ6oQVPG3MxEcweFiK5fKSq+TXeD1yAYgA0n98FIf385DRo3u8xZq1ac8WVYEPPRfbbPVhbdeqxwZUhz1wVvjqAcdaNMPhXfnEt+D4AuBGsZPZgK//awkAnK+7Y154e10OLBkLxHkk3/GuZRsqxO9FPDRh7OilC0Fn3KMhp/BRLCKPhizfECyzThXigw1cPdjBTxAkjYY2S/8zqxxaOOyjfa688DgT77rem7D8+8ZeElZ7+14W742wCmzgjxoRvks2+nLmVzPM6e4zjxl0MvXfec/uR2TOpW5yDn1tr3fUdsjOdT5NaknRrbZaZzDlQFM1jTr7VGPetRZth0vIxPPS38Q63A8PSCkewS8ff1U9mBmE+Y5yOzUclrlQeaXJLB0MU7LigHPJJDCKiErIaSPBqgAhZSJDrSqGFeEkuAhDZZF7tH+kSNQKfqRweMfTbaEpj6kbWqSJEwzncwZsHKORoZfZXBUqYizetlGfu+MSfrjt9NCjCulKKUhha9ypB/rzX8cErgCHW06vEfljoHOydpq1DpUPDVqb4ujU9WtfldG7Ur9bjxVW6N5mxm9FT1Wrjm/jsaSOCNoJTvkAEjWcFgmBiBGodawXh395V/+5Qe+ljzieiXPOtlRjaNad9VYXTF0Y7ySsEL/iv+rOeJ7VW7miHW45DaMjlfzd8dro3WW9SqodOAI/6q9Dtfk81UajWRDZWzltey7anO2Jqs6szW2hTccx44Oo7GnAbyyfitjdYaTOw8jOszqV7QZ6foKVu5tpamgyhYb1e8M/VXALkw5WvHfsSB7VVk1sv/cYE98V9Yz5ZD9lX1XPfGvYKb3LydU9mS1taWSA/pIN+u/gnc80PS3t+X2F+7JN4BGBCKwU8lgIBNH8yc/hIdNXldAAIXta75Vzt+y5naCnw2LvyN7Q/24g6nACVlF0Ahn3s/f4TpZUQRMCC7ptwJeuk9mF/T0N1E5falLYI4glGdJkFWFr0UwzDOz8sG/+tcDOc0ZZ82Q/Y3DrN/gpcAeASoccjLEmEvNEbhxKDvy2QOKAnfyGSfj5xplMhPdodL78Jzzr9OU/lNeZTJC2iWubyp7wcvklq3E0cusyLuRH+Z9+Rr2t7KlznMapx3l4+90oAfUUs+AT75Mx3FMGne2XOr4ik5c87GcxtZRMi39TY3i5RtuuOHwNnVdE48/6EEPOvCudIZ85Ze85CVnb4Tz7Yy+G4ixEEhFvpHF6VlT8DrnxMHf4OsBLGRaxY+XJWNpq5KqFITAr2lAyna5+93vfhDKPElQWQlfpY1J8OThW4AIwWHS1f2RkV3hWBkteV84SylwNgtCnzdBcOBvJRQq43xmTPtCh9FgAmeWkaDIfkeGcuUkJOiexi4aSImRkgxeBNhmxlq3oCuajObtYgyorYZxBysGpN9PvhqV74zpFaMyeWo0vzM6d7iOcKjGM4NZH50xnmOr+AnBraC0BD5nN8i4IyCKYOYJnAvr2VhW5innolqf+d/rIF+27Ic+b5it1W5djcboY+rWRyc7V2VMNYZRf1171ZhGZUZlq+sdfau2RjLMy4zkTqV7VtdrhUuHj0Ml3zo5ukWPV2NZaafDr/ue67fTVUDK427eRnhnnzNcZ3opy4x0RodT9XvU1wiHrv9joeOFbkydLTTSZegH2T1el+8r/Wb/Vd0c16jNi7VnzhPcYeFpe8r61NGMCWdNtq90tJwi2dp6KMQ9/AYOnqUtHDXPztE16Xtlvvhb0Qhc8ZYyts954AanjoCT/uuBE1k1nLWkPshe8t+MiSwhf3M2uywAP9qD9vOBNTj5w3QCV2yzI3OKQ3pze5XLkgywgCvzQ2BJ19n25lk1PpeUEcgnEi76cNyAIDP7aMeDa5lZpLHx8F6/mROXj9WDfe7lg6Z8UAi/uJ3l9En6Z4CqsvVSNqd88OAMwUEfu68PDxRWeiP7h9Y+Tg+m+Xk+CT4uv+Y6KO9XY6zazTWfdoqPO3Grtgg6Pk7LbD9x9GzE5LXO/vDxve3tsolMSHCGzir3q7/6qwc5oTe/MSf6/YpXvOLw0ZnPBFG9b+QWQWTmiu2nAuST1hX4IBMIEvtuqtxZVdndlzWwdKyi6gxxfUQwBY8kcMj+QUCyjzcPlsu2vY80RDqGnBmM1Zj1XbhIoZGh48wjXPVfiqJ7ZV+2l9lAFY34LlqR1cUbIEg7RSl1BmQyUS7YLn2TOtU1UoFReCgef9XuFuiEZcV3Kw7LqIzfPy8DbGQEju6PjMJ0QKq6s76zrcQnHaKONhdLp05xzcp3Tlfi242jopG+a80okKSMSJ6S+atrs80qiDNzODonIZ0WPv62HF+bXdrulQYfb8fDFb7dGDqHrOPNTt53dJ+NYYRP4jJrs2ur01UdLtXYk+Zu3I0Mg4621e/Z/G0ZfzWXoznb0p8b9N62G/0dbqvrdyQrZzhmnar/TlZ1fDIbRwWd3Oz0y8wu6myvqsyKbebtrfJXZ2N1DsFIXo3GneOo1nDX5wi3Ud9d2U62zNq6kpAyybdiuW4FZwJG1PE3RhE80ke2sOxQ+Q/5RiOV9TeosVXMn9bjY8ghZDu8QO0pGKSH3rKvyb5XPQJRwh0Hj+CGrgknOY1s72K83CfTSg+2yPoh6EQfvKmNujid9AvOwo23DwrkH9z3vvc9ZEfIr2ILIedJqW0PfmBXkDFE//ngyrMv/Pwr6AJuZGQQxGI+1KZw0X8ODNd9P4OJs5ygGe2y7Y2AGW2oPNlLfiiz60TGQxnGlsEg1ppncrk+ze1NbgtyPf9Dv9wilTLXAz/g7X2pHLSlfPdA0eVRBrmwL/0MXA/QdHbDLCvK++5kltO60nWekcf2zqSX95f2cGZG+blbact7W45TZjb5dx+f43HN2+ns69O3p4ELLxDQR2+eRgbxxkuXd/SDL8CaZ6sq8wcOBFl5kQAy0t+WmPzq48kMrCo4esXOWOpgpLw9asp3EUeTIMGpQSNARopz1chLBqPcSJnnohPTKJjC1pmcGF7bOTIgMr0NHFzwJZ1IbyWzi/JkC8lB9nOlKqMNQYViYp+36vFEpaJd0ocPc0M7PFnJgwdHMDN4OgNti/F+TL/nCbMxbDEKXXh3jlkKbocVBZH9cW00jq3zNIJKqDteI+ev+t717WvOr4mXtaYwYtibrPp+KKvTJ/up7iWNfTwEZFmXKBqCx55a37V5JWE0r5VhUPG0f+942utk+9n2TB6srssOv2r9dTw4os3oOs6XG5mZHs6nk/sVDTqDqao7kiPVvDgdKiOy6mO2djvwsfu1HKP/zvJJiy2062Akk1ZkUzXONIxn/DWS1dV32q8M7JFNMBpHNfYtcmKGfyXTV/C8FPas41TJpNHYve6or9V2VvG+XOB8UG0lyS1LyXfJl2yVEiiQoYCK9KSuSX9iiyI7PXCDI49fwcHasu0VSNI1tSNdzEHRvDpcgG3LIeGcS4QtzHfd42wizj3yMXA2kQO2PsGkip/ohy104KgjKR796EefPPzhDz+zYZSNrWyIX/mVXzl8brzxxgveiObOu/fltPeMDg+CeABP9xiLZxOxk4EAE/d4o5y365lMapM64OlbHRm/68KUGdXDOPc5R7KjaiuDRl7fedeDQK77qsAUPOhBJeo5/Z3Wft1ljI83x0BgsAps5Zrz9sAx+dSDbl2QK/HrdH3qaz+XKXHjWmZfVXPo9MffhhZOT++74n8CRqmfrolALL40tjxj8WC3gskknqiOfAwOwfcAtYCga67R3FZIYIvtvD4/GaDMsfoc5FsRr+rAElAZUxBEe3AVIJFyYN8thPd0toppsv0UMv7f08pYrB4BrPpI4HA5lCGCwRVPKn7/jsDnbBdwIK3Uha+DBKloxALxdD+NTXXYglfRyBeY6KyMK4Jg6lsKSvPg29c6A517pNnpu/BTG/r4mxpWGHTFmNwKK87JFgfmYqByIrZAJcxmxn4nRGY4VOtnZX6OoWM3hhScq/11StXbrvrJdFkJ+3vc4x4Ho4wDKrU2dCYTwj/pUjmmqaCqces7b0DhIE+uqYzWppSRPlueJFwOyHF3NB9drwyPbLtrq3LgkndyzhOXrn/qc727131fmaeKLmnk82IEnBTOb0F3ppzdss5HuK7QLsfbGZArcrYr58beCj7dWlvBY3RvpAuruqO+0m5JvCu+W5mjqo8tfJiOZOI04pnZODrcOxma9ls6TVW/rh+pW/HNiA4zenXyYkaPLXJ7phc7fX416YYOOtngvJD2jvMldic8qgCQdDNZ/LxARuX8zBG1o/ts48Ihoy10Og93eLitsmQUySH0Iy+w+3O9CAfpcuZMILubt8Lhi7jO4r4HLtgJwH/GRzCLs4kIrn3QB33QySMf+cgzXAmsCV9twdE5tj/5kz95oJdnrFSZLZnt4+tLH85dAn+fQ338DCuccn9Ax+vXOadVv3mTnO4Lf+aN7CwOSuchOA+wwZm5BifPEnP+A3K3SK4hH5OvN+ilj/tg+Z/vIxywP2mLsl7XwTP3wMsDT906S5nlH19budaEA0HZSgekTPLMteqeB+XyAZkHcDxwRD+VvT7Tq2lj6zvZQz5eD8AkbtUuJ5V529u3pjleZNcRHMY+Y1xkBsK3bOEl8Ozz4sfsZNAJ4FrFFx4M9blyWvnYKv171QeWHBJxgjukpgqYfG1TYRK8ftduBb6FTYKLLXe0zwHgGcWs2klhwYTqutpwYe/1KCNmue666w5PFiQwX/Oa1xz652Bg/edNCC6gUIowv9NK9+UEq28CPZWhhpDWAXqiAUKJN1yIufV0Y3XhKoikxcoTIf1WcCvPV+qMoa7dNA5XYdWJqYzQywnnYWRW5fL+SNB2dFql3bFlKiWeSu9iDeRVwVg5K+JlGTD3ute9DqnkPIHU+iKV1YPdK7hUNPd1nee1+VZSfw0xAdt8EnelIANyCZXz4OVna70yjLxdvnt5f5LWtZ/zkM5NZYSN8K7WWzeW2Xw5XuI9HfL4hCc84TD3L33pSw/6QTJWvCndwZtEOtrP+qlwHY21ghxTNfbqezqSMzyrOanoWvFK9tXxq7eZ32e4du1lOz6GDp+qz5Ee6JygCrp+k5aVnN5ifG7VW9W10XzN6Deax6q/lbmdybmVdioZk/erfme8uzreKwVuu7rjw/e0rXE0R7wukGxUJo4eluoaTp0fKOwHT/PwmqAL2U36yIblwTFvkvOdCR7o4aGsv20J+1t2sdsJBIPYJsNhv2qX9hiTZz3gcEI/D2j5gdb3u9/9Th7zmMcctrw5zpz5JH3xnu/5noeHYzrThQwHf7Oe/4fmnoVDJhb9+7yCO1v4GA9+Cm1Ca+HGtjnahuaiHf4JdNLc6rr8Qg49Zithpac7p5p5BF/fkglvMXZvM3eReDk+GYzz9pyHve3EJ9tLe5l1wtENHkDzdURfHqzKNeRjc3x8bVX2j69l6npWjfOy08KDqdlejjH7Yi1V8tLHnDZLjoNz0Hg7JGV9u1/OWW4p87FeY2VpQzzKSwGw8QlGc34reMueg9f9/DL684ARfdGPb/+s/JHKHnaaOBDU8jbPPbC0YjScBzBR7EEkPZKnsVIYMqJdiB2jLBGw2ncsQYaiYV+1rimgIoHlB+wlrjCZRw49EskhfdVB487Y9773vU8++IM/+PBdY9Q2tuuvv/4wZv2XYnBngYlG0aBUXBjm2UadEBMTk56aNEKg56HbFc1RgJoforTCm8MVuzqVoKX/CkbGVAWVcJjhMPp9uWFkEM4cksr46sqvGO/JAylIzwtGBv+IRzphuTL3FZ1ZZ3xY22SNKACkp30dnbLNpFkqaNajAlm5rdSVin5zuLi35wbAlYBq3aS8q2he0a+6lzJsBlvXbjcvs7Yq4zOVf9VGGjszkDx/r/d6r5PHP/7xByNaWxn05hAFkxT41IGQ4kfdq3i5wz0NR4ecx1l72W5VZzTn/ru7PqLhiLe2yJXZmqoM4Aofv5Z9dbKnMoq7MjPIbUYdz63ojS1rZ5UuI+P2PGBFxpwXLtlG1/4It9k63QKVDLpawLMyGFsGmrp1nvLK6/MkXw9Vsec9o9jnxYMomVWA/S5Zih/gb13DJsAJ5FwU3mDtjirnm7h/0x1SzTa83PojIHBAO/zHaSUoojE/4AEPOPNjFGQjKCebXjjqYbLK6FXnz3jGM85s9AwkOc/lNhrsoyzvW4wSb338Vev4Kn72FG/YJiuXA9VpW7jrI/tHgTM9UJHe8zfe5UOuxJfvzmN+GLLzlT+48+w450HazW1K3lZuR0r5njT2Ol12In1TzteOfyjrQaec18TT10oGFjKTOmmUx9VQhmseIO627OV6BVLGdjI+s+8YJ2tf/EJQWR9kkWd8+dh9S6O363NwU5zX5WPEh/CANHOSgWStB3x4kmx87nyNuTzw9efrl++5Xh1yHnP85x5Y2qqYtiizink14YpAS8DKiRNIUShoIYHcGXveZod3OnDqE4HE0ws5jboug92fMlTKiawkf+0mTy7ULimcHc5E7KW8FIXXR08TdOCegkrKoPJFz/jAgVRfF1QclFcZpE4fAU9AdA2l6odvi/4KdlWCOudQ9SXsNUeMLQ2Bqo0Urp1R3s3pDCrjNg3hznAb9Xc5jLYUrKO57K5368Dbz3uVIO/amsGqU1JBZZj7nKXyhI+3GOIVL9O+eFhrWAamGzx873DMdjvHTeCGBApF1+gHY4Z1OXrqcDU5Ed36cJ4e8WYFuV5X1mBlgIxwo/2u3Rneec/LVzyR9zojS7JZ+kBPmEnl1kMJnaUhPcSLExzSGXDaJb+O8B5BNb5qHXT0yWuUT8PQ+8itBM4PHYzKVPqoWtdZphpr6t3qfmU0z/pMms/GMMLXy3bbyrLdFZnaycIK59EYtsjvUXtdG9l+PhX3+tXT/er3aHyr87plbB10+F1NgJPlD4mRVax7/0+dTobrv29DI3PIM3zoA8eMh7U8nKW+B5Z4qC35KnnLgdG6zrYVAUGkDDzQrr67M4jzio3BfbbdgZdnWlVbuuBN2d3CkVeNs12ah/HYEwo08TBd5d7//d//oDc828czsgj0OH8nr7vP4L4Ec+O+A/PumUO81Q9fTP85BoWD0tn6xuHsGseLX/zig58of6Pa+uWyOHkqs7zBhbLwVMpJ5i8P2PZAn8DnzOeOdv1/yoP0tUZ+LPUS17ST+F1t48pgYlfHaev9pbz2gKHrb8edQ9+pm3aK1/FgquPivJbnlTk9vR2AIC7rzmWHl02bmwe9npWY476mOOcp5Rn3yVhEFvn6gKbQkD61FrDzPJDJ+oUe0NXnqbIxoaXznsvJ3DVxWbbCVUrrWOcmU8Lk0DFgzwzqFPNIeaaR7CmwvGmOVwOqfwkw3gTRMSqTLVz1XeXZ9iamVRTdXwOYtIF2chSe+cxnnrzf+73f4cmzmEVKTAEmf6Ocj1uBKPXrT1s4/wVawWgJKaw8AER6K4uWrLGkvdMjnYJuC+HMkRld7xYE91bb6nhk1H7V16jPEYwCDFmu4/MVQ3HWjyuHLFcpLL/fzXteW4WOL2b0wViSsNdvzifje463asP7z3EjXLUGtUa1nnQuAcqGc468j44OyS/d/GDI+bZW/+9Pkypn5kpCGvojmuf3kZNZ9VO10eEzkt9d2VW8ve6o3ZV6WSbxFW//7M/+7EHPaOu0ZLP4QXpCvPkzP/MzZ683B/wJbRW46Pob4ZX4VzrN6+Ta2kLHDo+RLqque92Kr0a8OtMZ1VhW5XlnO83wqcrNZMFo7kd23MjeynFtbbPCb2Us2ceK/ul4ZFRnlVeynU5nZ7/nJb87/kqeP9ZuuRTgZ7UIwM8DJl3GXcqzdFJ5vTZHM+D04UCSfaQ6CkwQXBLkGae0KZubNnj441k51ANHttUxLgJVfgC1yhK48bOgfDwADh548Zs2oJGAsfs5jbSh79oCd8MNNxzuS59UzmcVGPH5yEwObDLq+C6LansVdGUMmhP5TAT93LlVMIlzaJWlpKASx6Lkg3vHN+0lD07kNiYfDxnj4IIf5w64Bw8YF235Yd0eSPOyCZ08qB7qO/08UFHJGQ8m5VqijVw/iVfKbedf/94FFL0taOzt5bgcNwKxzjusGedLaJz2FnXcFgI3T8rw84rZfkrbfs6xeIMMuszuutbmItc+eLM2nL9IBnEZyJFAAup7sDx9HKexrzef+0pf+zhyrqELAbBLHlhKJI9tY3TNX/fNvVF/lcGUwCJgUogQulOK4uE1oXlGUuLKgeNsTQHP3ALmjO77u9X3C1/4wsMWuIc97GEHYS+cJPh1rXpTFa9G13g4xBvGlQKcbUHjv8ryRIC3wSFY/XWWI7onbp3QvJh5G7XRXR8ZWiuQBrwvulUDtru30vcx91acN/+eCiMdgwpSCXSyYFU+VPU7Yx6cSEOXU43hxNZTOdecK9AZ8zPc/J7alRGjtmXUaN1qzUg2+EH/jl8quDTqqzlSO5wZgFxCoak8TzKRi5XiPi9H5Vio5m3GY7n2K9p5vdF6X13f2a/zyQynFRqs4jjTZw6ab+mZpz/96Scve9nLTh7xiEcc5LTWgBwFvba2OtCxa7P6njKzo0M3xpyr2Rrr2sgtF1Uf1dgqmb+CY46xkhEVz3Q8skXnZHurMvM8YWQnjPi1s2/y3sq8VHJhFe8V+2JlDKt9V3M9quNPjlfWxgxWdFrlZK7o98sBlax1Orqzm05Sfvf2+I997S85IPMgg0b+IBYnj4fNkkOypf3Aac4JIhBE4ADH1YMsnj2t//gSZD64Y+4PdHEgscNVhjq8Rhx8PBMCR1W+g+wTBZf04hHVEUhX6De2kuwklZH9j03hQT0cXMbJnDlvuZPv85vOLzYa/hX4A8KFAI7a1EM8ARkl0nFkj5N0ILzZKeEP0rs17I60054x8fZfxgQfEeCgrgetkp+Zdy+T2Xde3rO3/HrajcnzXMvgho/Pr1OWYIEgA2/Vdx8Xvz2Q5YFF7ycDe4kD9R28j7Rvfasa7Xmm2EhuO+95WdYPY+i2w8GDPlcEiTzI+05vP1aGrWtaO6x5lWVbLEksniXHekBWEah2vsP2d1o6D+fcecCw8+Pdp8rf+vDSgssSWOqU0qpBkOVXlG4qyS14ZX8cBo4CYSJhGJTHzGABLwS191HhSvsKBklwIhxRYM9//vMPwlVCVh8J0HReaVf4S9iSOqrfOLxyhGHojma6zitZBeoHXNjK55HakeGbAjHpM8LDyx57f1RnxJMpqLc4BF3bVb3O6NsCKw7pzPBPxesC3+uMfldtVf9zXY+UvpcZKQf/rnRvDntECHqqauVkVwpzBJTDGOWpZaf8qjbTqUl6O2j9KnVdINnEkxEUksakNZvbU2ftXi5YWUMjOeJ1ckyVfhiNN1O4s+1R38mvFQ4rbVbraBWnqi/OD9GDCPGAeJ/tx+gKb7dqY0UOVveqtvJaRadKVvg6TBmRT4JHDkLi0pWp7ItuPCMadeOeQTXOlMGr4ztGvs7GM7O7Znq/2mYxW2uruM1gNt4tbVX83PHfFh3era1jYXVNj9bvMfNyXuC8Ai1zmwuOk2cjeLYJ7TCmarsYh2Tz0Ni3o5EdTOAE+4EMGQIK4Cg5y8G74E4gB/wp71k37HrwjBgPmpE9Be4EXjj0F7z1H5w9A4agkXDWNf1+yUtecvKLv/iLh6M15GcQZNPZRPotH0HbyZ773Oce2pP/oP6cZ3zLnc+ZA2MhEJhBA59f5lP//ewrnHLPDJINxPhpwwN4+dY/gkvd7hAHAgy5fYp5x+n3/vxQd+hD+xlA8wBS2rQ+z8nDeTZRZuB0W734ndnJDiOZDC655ZK5r3SL8/pWfyH79zref9bnjDCVZU1DFx+Lt+W8mIExx4GxwPN+nlHWYQ5dPgi32799q6bqECSVTZbZVMgEsqXEbwSk4APiEcgI+ubAf3we8PDtth44c5mZ9qxnaTpv+HrwDKxLFlhaMaa2KquRsVIZoQkj5V4Zy0yUJkhOoibUM3v87Qp5aLX31TkHAg/E+D0mS0JcTw7YyuAprbwalGwIT4fLsek6mUuc88S4umylqg3V5Q1zOOUwIq/wzHF3wsONBFcm0P1ijZlVIzwhBXxl6I2M6vMyCC8GVsfY/U5nZqX9pFm3pka/XYmO6Nj13xk0fhYRfMbh+7zZsXLCKlw7WlZrvnLgZs7XiiMCrVm/GLfQD9nE646TblfSURBUymwGK0aJt9+Vqe6lkdk5jF6n4pOK52c0oC2vs9W5rMpBX55KVwc4etmOXtnmjHdX2urmsjIic4ydTJ/xx2gdV/Kuw2UmD7u1PlrTXd+VHlrBJ/FI3uzKdfiMxrt6L+emmi/+H6tDO15YwXsVVmX0xfab+FeZTInTKlzt9otDZZvkA0w/2Ntlem4t8jrO3xwL4Q4zZf0sJM428jc3kRkkkE2h67Ir0MfoYs/qB9DVAndUPUOJMxv5ZPYE43G7iXF5pgQ4et9ktup4jY/7uI87vCFOjq7O4tPDOAWW5Dfo0G5tn9Zv+SN6GM3DK+iA0+q0Azffhuf6h+v5QiFfX7SBkyz6E4gjM4SAHRlknHHlb8vlnh6y8GA//SXXMeo3Mzd42K92ODcT+jK33PeAg89tzgE85P3Sd5dp7jYTvzu7OfXEKKiX5eGrLmvJP4wjdVauVe/D2xrpwkqXJQ2zD2x8rsMnLg8c7wRvs8OXuskDqffhG3j+NuZDC0fOcPKxO/3hHfE7B/bTDoFvD0iBu68L/59H3yT9PeDJfQ8KMyZ8KmQRbZ9rYMkndVU5bTE+s92OUSlXGaX+vbpfKVxNjqLiCAzKiMgK+GiiJfw9lXWEz4qRofJqW0JcSirHjDLliQtZEtUiBciU8kj6yJD2PhkvbxESTihRtcuWum4vZzU+FpUENFuU1IbamtFoxajzBdYZ/rP2V/h4xSAbGXKzsqtG6YiHuz46J23rWKq2KLvFOe6cjZU2u354cugC3yPwVcpxJ3sq5VatHzd+u7XfGQA5xlRS2Yc/Hauct9m6vhKQ/Je0HdG+mqesT7mOJ/Pe6nqv6uT37KtzAju+yX46PLa07fzR4TzCv9JnFYz42+ep08dVSnwnE6p5rsZflRvxSzfmGf0q/JLXZvPe9dOVq6DqdxX37K+yo7boo6384/dW6nW60ttwx2PWZ7bR8cB5yNPV+ajGVLXVtVethy16+WoA4eoBHv5X24gAz1wC/LdvX+HNT7JF9SHwwINj9a9gBQdHY3OrLkEp3/LitgW2PG1m9gnzkVkmOHLutCro43UIXPkLgchUIqsIXMHPt8yovHTDS1/60pNnPetZJx/1UR91ct11152dN6XziX7hF37h5Cd+4icOWUuqp0wmPfD2bTi+zvTx16zrNxlDalNt+xmv+AIeHBR4EIqzYhTsUraHgkOegeZ2neZPfYCDfBWylThSpAo2VvLYM0/AUWNX+wL5fn6AOkEtleUt37nFDX7Sx4M8GRgAh277UrUdztcLtMutiVVwC8g2M1CUaytlSGYx8clMwsreo6zzUQbLvE3OCkt7AZoTTCTI64fmezZY9ukyMoNwnhHkbzD0unnOkz74yrqPr3tqgVWOtKh2G9EvdTQOD+7k2+gZG2tddZFbuS0vdQG08D7ph3kg81DrjPYEBNC744AuKmNpZMx3CrErO2tnpOC7+iNlmoIFYopgiuprIiTYOBjO30rH4byrRntnAPBffZNqSXolE+ZR+txbWfVTLf6tRhBtEVySgiOdVjSozojqxsj4NCbt4VYKrhaeyij7Sm/YUx8rxtYqzHjlYuqsGGhbeXEVUuCmUtpi8Kdxnfh1Dke2teI0JFROXjVGfndj7MadCgHjT2vKsw1ndEvlXuE2G9sKvlW5ToZU11bWzZV2LJyWlTNZ0Xa09qr2VvVS5XCt3FuRA6N1VvF7hfMMF28r12bSZoZvRa+KnjnGrs2UKyMYZSvO7ILEI+VT9p+09e85/tH8dDp/C/6Jh7dX8XW3JkayqeuzasehajvvXyx9Kn6atdnhmnZXpS8q2s5w6qBre1Z+1P+IbpWM7By9HIc7QkmHreO+XJDOluPsW0wEXWDG7U531L0s2S2cieT2Ns4UD1EJWrC1CkePIIPw8e31vlXE51z2PTYJZ7NQ3tvgyA1w5sEY7XrwQPgTSMrjKfQhMOY0VTm97EH296Me9aiDj6NAks7n421qnBepfhXcIXAFnuCa2WPMk2eP4fST9eRnzuCg+vwJdJ+AFk49c8o2IT2IZ4siPpLbd36cSOqaXAvJK6qnoJH8HgKRPkeMnWNR/Cwq6OxBrdzylPzpQUOXFx6Igicz+MFY/OBrz4DyufDx5tr3vhz3TkZUejTXWpalfaDKeqp0tB/+TTnop++sAXzp3M6VfVbj9jUHvcHLg2WOl7fB+qQvsnve9vbsI7IfM3BDcKqS3fCOv0Uy5wW+hHYEVWnH+SLLQjPwZz0jIwkm+VvwWGO5Q+JcAksjQ3V079iylUJ0BuZ7Ku/ZouC7lxPhFFxSpFwRUAkwleGMIiZ41EY3Bv/uzJQZSUQGldXjZx7luUpdHxU+qZCr+2lY6rcYyCOTM/rmnIhBFVBSyi1PFDgcUMpDW+6ODYBlfzOccpwdVMLtSkBlPFffu7F389TNfQrO8zI80zju1nOu64QZ3xJAYv1gVBEwJg0161Z4rdBsBCN6Vg5DtulKrbrezVm2eaVhKx9d7Bg6HqvanfFb1usMC78/ujcyuDqdkvxY4eMwwjH7FVSZQyu0qfg373fj7uqN5mHW34j+leHayaSqnTSwR7KgGne17kfl/H41xu73jG4j/bGyRlfXsY9tVmeUZTTTRyt4u/N1HjJqpCO6vkdlV/iqGvfK/OIkdbo221uZr0sJ4OZbLfz8I+5lAIUxpAPoDiPXOFaCzBie9nNOCefmKJjAOUie9UOgw3cNpFPtmQTqQ3YHgQiV9e1GHpzx8eDgY0OzFUUgvDiPyA8YdrnlzrjTQ+OUX/GiF73o8GIHgmuMR+MnO0d2umx2BZf8bBfa4jdjBwcCXfqQGUbmBG/P8kPRoRuOrB7q43MxBwQMFAjzrC1oy7lL0IbgkPNV0sI/ONaqJxqQeea7PpzvGBvb9XI7WwZD/A19rEvfBun3fB7TJvDABHWqg9K574GIDHbCi4zN+bc7K8oDLvk/1xvtuQzONer4pg72vr0ebWZQl+1ivLxEPjO8TWCEsXpfSZORbZeBIeYEWYKPDi9fYzKLLZsc18H696BeZpLBS047n0efZ9pgLRPk9TnKDCvqg5uvRQK2kgMeTK52TF2Sw7s743Fk3Ao6A6+qXylCFwge0SezJyO1nRJOnP2gLGXUcL1LX5u1WZVzIeL7QXkbGx8pwdw2tmokVTh1ddPA9rKrbSSQDosy4KlNpjkfa8zkAslxZxBuxKderyubtBnx9nnAyOjsyjmMjPE0NpMGKeQrYbuCVwrupJ+v5cpgrsbRzaGUCOeQ+ZNArR8PYDoelQzaSlenUTfOjmYra7mSGdV8pBFy7Lo6T0icK3oAOf+d3O7qV21V85y/R2vZ8V7FM3Ee4Te6Xs1n4rPSzsoarcbZzUHOQzU/Hc+v2AlV+yO53Y0/naBuzVbtzeTbbBzdOq3wH81B1XbX/8qan9lAFR45DyObbYbHiizvoOLPqp1OTo7WxMjO9HmqnvaP8D0GttCo4u1q/COdc+x8nDf4diScNr/nDlY3hsQ/y8pG0ANita9zhAgk+dYp2druO7gt6cEMfnPgLjYHASXPouDpPlt1HO98e5bjDG7IM4JLzDkv13GH1g85B0e3tT3TgEwfr8fLH/QwTr8V6OEt1wLPzmGMDrrH+TD6zzlIZG+AA04umUwqw9usNUfqj10SKqf7agvn1g9qFo1VxrcLMh4+SWc+lOM8JX3nuA/HMbe3qS+2+3EwO/NS8WP6ox5YFDh+uSY96OCBH+cV5xmv61lLuX78muObgRxwqgK83rdvW/SsNepWdElbzANAuf4o4/1QhqAiQR35nWTZKDiCnw1ujNGDat6eZ8p5QMXL+LiJGWQg7q2RdcexOplN2OlTn1d40XFwejvt/MxZ5teD3h78SlrAy+BJYJsdSL5d+ZId3t3BTEnNHKzOeBJAFFIWiYQLxEQEY/x1gCs4+/1k7hUjMa9lncqYFa7KkEJoEmXVR9fZnjfCvXMMjoHOMKsYfkYTaO+KjXRaCYJRBlYFvvhZEK7UWRzdE5tRm921dJZm467a6pTNpYSRwT/ioy2/K/5Ip9K/V8a+z6UrsIpmM8dHASQ3/EinrlJIK3yqsaWST+Uyeuq+IjuSvq7IR7SsaFLNw5WExGFVJ3QOYY49x921X813RVt+V7Kvut7RvJL7HQ1ma7HjAfi5Wwsz3VP13fHr6Hf3fVR/hG/qsM7gGvXnOmfLeuugu79F71ZlqzqpL2Y0G7Vb9b3KFzg03TpwnFbtjlyHI7y7e9X1lXVd0amT8StjGcGMr0djWumz45HEf8YXW8tdSsizS9GtAs/s8afzbpfllqd8+q/vnpWCfJDdjVPIf38rHE5UnvNEFgpAhpXqctaK+pV/gk1P9o58FLePPcjgNhBOOZlFsm/k15D9ROYSwTiB040thGn/YCMzLvry8cvv4OwaBeF4SCf8/Lwl5oesIZxR+lR97U4gm4J+mBfsd4I0ejj4hje84cx/gxbyF9S22mIcnENDhpeCCfhQ4MQ2PM/4IPBEQJHzcNj65rwI/Zy3BJpD6jnPVeUz2JPz4WU7e8f9WN8uVWUBcb3SD5UN421Bb2/Lx5j3uZfBn6RftkMd1zEj+877gqZ+X3PHumKbJNln+i1+4uU9eaSLZwI5XxJ4SX6t9LW/1MoDqbe2txuSFck6Sh7IDFv/XtkzOa8egGfbGusNvN0X9zmp+iIZREB8hfH4ywnOPbC0YtQf225nxJNWKiFChNsjamxh00HcvKKyMyBWlKlPdmXMjQy1ikH8Nwyg/c3Cm4OyeHIiBvQnBFtgdU5GdNhqbLhBKtAYpKA0RwSS9NETCSmQKi1yhCf/9RHTk47q+0WVZeb747eMb1Z2hZ5dufNcH97mljGs1F+pcx5rnvqsZz0Zk9DS3PFqTldKWbcah8qy3l3gVuWzbjfGrlyl5PNeJSf8/wwvPpnd5wo26eKfqwFGstLvC1LOdu0BlX4Y4TDqx3GsjLyZrB+tCzcKVtfrbG2lATKqO2qr0k3V+PJ39b3DZzSfo/6qOaFc9b2ai2xnhk+HW9VuRQfvr5Nb3ViyrxG9Z2Pu6uR6rOqt0KjDu3qKnuNagS36pbOvOpxzflJfVHhW87GCy8XwQNX27H7V90zPXw26AgcodV4nF9xRquxj38JG8IItUr4FjAwbAhK5JjwI4xkPBB/A2Z0xv0fb6lfXObeVc0ryoXE+hOVFQmpPdeQTyMblYF22fgkICrntoLoefCHDhrOUCGqR4cCYZYPp7dL6LX+K17rjcHuQiAwI1cFe42EvwSB9OMibrAecU/5rXG984xsPD9TTl4Amaoey+k2AL7e/5eHNaotAElv0OIBb/ZG95XwDHznPeWBR4yWLQ3UJLPh5Scm/lS7L+52/h73sPMOc6B5852unWvupr5lPcMgt8o43/FFt5UtcO1vOr1e6bGQT+pgzgYB550gM1iYvj9IY5XdqvjPYlzQjrkDWEVvdfH6dJ6ALGXP0/ftv5ymSXxwXsu58jXb0qPSGy5+0Nzh3DZzAVd+Fg3iWmIPwIyHHs6kYE+OgPw/CXdKtcBXMlNkxoDZFCAWUJGCIDCIoBTAMB8/5wXbVRPk4VoysbkGsGBMV6B5CSQzPGMBxhYbVJKchNOp/5dqsz8qY5E17YlZXqOx/rYy5Gc66JyWi+dV/lBILXIvFDzqvxlY5QZ0QTMN9xdieGaDV2hgJ4ll/q2VnfDpyMrNO5RBW+KeSqK5pLd/97nc/zKfmjqdWnDNW9d0prPyf9b1uda9z5DpaVzTs6N2NI+u7MYxs44kfio3DKb0t0Q7jbYb35YBuPaw4SFVbK2sw+17h4VnZbi13PDSru4r/jGbVuhr1nby/KmcqHGbj6uYryzheVX/Veu1kdEefjibZZvLrSMd3Y5ndW2k361R6sut3NP4ta7DCZeQIeNlVmVOtw05HjfTpsTLOHaVVO2mkz2d2y1a6j9rpcOzmZLWNKw04eDhEFR+4XMgtSvr4tiIeOrKVijeJqS6v9SYjpqINQRN/K5PPoW9zwXGUrcuuA+EnXY3zjtPLw1Z0OMEqgWcvgb/qEYzCP9D3O9zhDof+/AG6bxvEhvAAEM4udCKDx8+h1D39VqCHMfBad7Ix/PwatSl7jQAVNKYvAdv63FEHR+HPQ+EMVkB/nHEFupRYoP44cFw2pHxDPbRWnzqUnMCd2iFQIFqRmKDr6o+H3tDMM1qgaTroPv+0TfkuQwfZmPayn5HlAQ/njcqWyrXhdcA5bdpcS94m/zNDh2AC4Lj7texH9fzg/a4e4Jk1idtI/4Ovr3uyhKCtH8UinAjqwIO+HZQta9wn+Or0Zl4qnP1A8be85S1nQS59F+9lMNjnKumU8975JH7d24I2woWzjTN2wtZP1ovwTL7wgDI+yCUNLK0YRsfWTWIiGIjUswg87Y/fOGQXY0x1Btzo+8w58To5/nx958g4yHZmOKzePxYqIx3FonH5eVUpQGeGjs8/T3/I7nIFjJJEAXRG4KzPmSMzw3PU3sxByVTLUV+jdrr5WB2HK0DGUI1pta1uXZCymge+a33feOONZ0+TOryyveq74wKkM+GGqSt0V7Td/FU4ZNsrdKNvjDMpHzIwZfxw7oEHVTHuMIgUlJOiILX/Uqz1VRg5wDMaVoZFttnV9XL+v3rAkOU6Y2k0thH+Wd7XYdV3xSuzvqq6o/WRsrcyVDv8R7h1BmvVbqcDZ+ujujaT0yu6u8Kla6MaL/xVGetZx69X+Ix0xQifDlL+d/1n3xV+Vd2RnvD7M5nN7xU5W+HctTlq/zzoS/mZzTGCUd0tuKyU3SIzLif4WSA4tJUswYH0c3B83ARSPJigjGi2ZclxQk/SbjqPBGR4gU1mRvnWM9UnoMR/MqCwI8iUIUgi3HkI6ufCCtQeNqzaU/BEHw+AeDaC7AN/kKtx8UAdh5BMJgIt/GdroL6rjAItXlbfFawhKMeWNw+kaDz+giG3Y6Ah9opv12HOhKvsPMbntPZ1ShaVHjpqHvW2abbxCQcFwRRQkq+hT27ZghZkTEFXz25y3KCB86DzqNuFeYC64+79eyDCebWT0d5mtQ2r+p/rxunpGU/OD96mt+PrMoMo1XjcxoA3HD/WWsrhxNfXpbfr6853qsCrfs4R16Cxv/mxihWQTQQ/iSeZf9+W6ecmCVjPzrsul/7g7evJdx/h87i888CY07DTs5TtbCbmSONSAFp+g/vkAnaH5Py5X+EvCqh2aFySwBIDOAYq507QGYousGAs37MrYJ9zbiGb4bhiGK1AtVi21J1934J3x2z+vTPwZzhWDN0ZePmWhFwonZFbjYHIqxSVCzeP6s+csRxPlj9vA2vGB6tz3dWpjOQtbc4M84pHKkdzCyQP8NRLAl7C3ZWBP82rlHauuZGz0M0FPMCTORQFSsP33W8Z34iXKoWOIuBz3XXXndzvfvc7vMVF5aEPAh8goMo10n23zst5QsWjW9fZSHF6P1W5iqer/ldwGs1nV2d2vZOfbjDM9MkWJV/1f8zaqejc6YFOn2a5xK0qt0JnN0arNT6ax45fZrShfG5ZHdGywp17Wb/j6aqNiraVszIaR6UXV3X0jIey3Mp6Gq39an4Sh45vu7ZHvOaOz0p57s+gWgfVXPk8uANWOR/Z1uq6uRLgssjx4Vpm53LNf7sTqg/b3xR4IehDwIcMJd+6hQPozpV++2Hd/nIQ+ucsFzKRuEcghW1Wqo+e5jwYtqboP2XIqgA/6XKyCmhb19WuAi26zi4O2Qtk4eA8uh2j9vlO8Eog51LBmNzhITw9k0HjxOEki8gddmiBb0Zmg9pSIE3tqQ/hqGvQAp9N43MH1gMHogPb7VRPAS+NWd91/pQ+GoO/EAnA0eehHQ41Dy1xnFUnM32o79vgGK9nemCzVoGiDII6T3uAgzrVeq4eFPp9p1mud4IwVXv+u5OlHkjx8r7eXP/lNdYn/eXvtC8Av5bBXWiXGfvY8O43MDbeRkjGDmuNNyBKVojPFLxkjuALfJHqDCb4VsAZX9caPZy28l/9TYtsSXWeSPme813Nkc8PbWk9alwcZk42FbLMg0pcAzcPnnpAmt+XPLCUMFO0wGiR5HUmKSOOMIlPBAT0NyBUfcyU7VY8s+xqOcdlZvStGHEjw3U2jgr/yiDsDJ5RW939LbzC/xQOLE6Yf8WYW+n3PPj8vNrsHLGOtis0oE//7/VX10h3fUYj0tH9yQdPrkhf94Peu3Uyc5hm84SRR0Ykqao8TePJ1mqwZgstnLeFwz3vec+DMpChdN/73vcQWBKNeNuKvwWTNHbkn+ildjgg8EpCOn0puwTd9RUnOPtxGDlYFT6dknZFXrU/c1ozxbkqmzilkSDwVPTsYwQjnZq062idRm4n13N83kfVZ1fXr1FupLO7+pUR1tHlGP1VtTWTQdX4Rno8g1Uz3JO2XZ8jWOGJVcj1POqrg0rncb3DczaGkV7KgE21HkfjXaHZSBd09lVn+x07RyOZdLnBz9wB4H0coXTa0+mkPoEOgRxGztLRNWUqKSCB00kbmUXh23j8zCTOcgUPMh3IdmCrGTi4MwreHjhBf5Oh7EEblefQYT/7B6dRwEHbvLCIIJU+yvwmkMaDOw4w1neukw3lW9t8jH4WlfpgSx2BFT8rSQ4sthNbilQfWjIWaJrnPGmMGchjjvyIC/1XRrvG7vY/4/SAltNe//ENcaorXe8ZGlU2OUd7AJTPTKtsN+/TF5D6gHartZ8Z9Z08yQBQpccrPeM2R7bhdklmLflYKevlMjjka7DKQIQO2beDz62PDZ4AV+jGGmENEoziWBr4ybd8UlfAAfpOhwzsnYY8IfORoIy3QcwiM+E6+xMaZWYn4AfTSwZCC7b70Z+/zZDsTD+fOLM4oefqQ4iLCix1zsFW6JR3tg2BmGgWABFvV0Ijo3hlXPS56uB4vVm57GOGy6jezDBegSrSPTLku4W+YrB0xmJVzu/xhIAnH0SNEQBVal9l+I9os8or6RiMBN4IVg3XrQbkKt+u1B+NraLtCg1Zv3rKJINEAhCjwZVBGgbpZFU45ThyTDlvlJGw11tQ/ImH8FKQRwYp+48FI+G64swlDig5GYQ6c0pK4eEPf/hZOryeTvpZCtDHjcdVB+hyQeUAVfNRyZAsm/eP4TunTxpCHXR4V+1WOI7W94rc8FT0TgdsdZ59HeQ1bzvH1zm4K3J1ReZWuIy+V+1Uv6t5r+alczRm63mEf4d34jGieV7fYo9UtJnZEt06qYzYGe4jeo3G4Ub6bJwjndDVcTwq3h/ZNx2+KzBbk95e9dR6S7ujeqvb7i8H+CvMk+/d0fEtI8kfzFc6TwQ/2N7i5ynlFhafg8wQwufwl47kmsdpdBtVdXiLNXVpW2UA7jM+ZeMoEMYbzzzrSB85w5kpxVlH/uIc1eVV7J55ou+cQ+uHT0NLnwf8KQIyBIIIHqkPf8MadCQLS/aTQP/dmdU9cGMM7sz7eS8+x35OFvPja9kDXmSF8cCQDDLaymyRSlYzXrZN6cP5UX4Is39ySx80d78071c6nrIecCNwCZ+njKb/pB308Ewe2qv0kuMGZPCnC0r5mKFrZro4HzjfJJ1WbQF4jnnyrYYe4PVMRXhAa0HygW2y+JHcJ0vJ+/bAs69rx+0mC4gLN+aAIDWHv5O5p3p+8Hwloz2TyAOATkP4xfnbz3/jmuPGesp+Kh64JIGlkbF8LFTGWd5HUDmDQkQ/MI6zWTqjpsN7ZOw5886MsWPGPqJH12ZVb8XwTDrz8TZ9nH59ZMCkIKhwrfoajcHnQvOuQIR+k6mGgkGpVvuGu7F7+939GYzofaxBuAoXaxiO5mFkrM9+V+uius8TM61XBC3rW4Les5U6PGf0d8XFtQ4njEUUiD9dkIzhTSnV1riRs7ZCN5XlnCTRQQGmV73qVWdPCnnS6sYkdVDGohdvk8z1e7lhS9+dQdeV6wwM73e2rkb3K/ne8fLM8ev4Arwr+VONobt+nrKnM2pHbfoayzHO9Fo39m4+u/FvxSHxoexqOxX9K1qN5GJeq2RFZYeszPdsnkZ82OmEGZ9nnZEt4Ne3ro/E5RgZ181zVW50vbMPvY+E0ZhG7c9gZnP593wosjK3lxIqvgNnMnj8RS1cp15mMunjwQBdJ+Di/eAgoc/dSfZMJbaOeUAF55UzWRTIITMH28UdN/VNcINse7IjdE9BF472wEnVb7Z7+cNy7jlOfMc5ZLy+hc0dV+HEtkAP9viDDKd3OrHQmjdekfXBXOm+b6UTEOjjN+3yhme1RwYVWVTglXyB3e/+S5URhEMNbp557nyfTrxnzEEXtleCt3DkYbf352vJgxe+lbLbIuZrgPrVfHhShc+Hr6nqXBwPpDp/pq1TBQ/cbqeOZ1QxHur7uVuV/Q3OvpXQcaCdlI3d2KlDsG+W8Usdtaf1Ij+Et4o7j1KWc5vBwQOaVSbWNcU2XWRT8ilvOPc2MtsxdTT/PcjoMgLZojPmnL74VRykz4sBKhq5DF61rY8OLB2jhFaMvAp8QWjyXQghhH0fMIe3eaSwwiUnJ5k3GTDHXk30eULVZmUAVAZ3Z6zx37+7okTQeFpsld7Z4Vf12+GddUa84fd44kSGC3trOXgwHZMOv9G1FagcmouBGW1XYGSMr/Tr1zpHZIZf5QyN+hR/6dBJGTmaUzJwZGixBc3ntHJeLgZXx5nvGI3iJ4xFffxwy8rxGo0zoXIs1PbLX/7yg5EqntZebwWUeJIi2aeD+KjvxqK+q6zK+ZOTKwWr8r6aM8FMiXVrueKPqnzSp3MI02jJttwBcn1QtZH3Kr2SUK3nkXzr7q2sy2xr1GYl/zpd0+nWLXPi/zs8s48K7xUaOB5bMgGrfr2/GY/l99EcVLTzsvm/wmHU91YY4Tjiveqef0/HouK7lTmt5sHvdbZiBd18phPQ0aazJ0c45/hXoat/HnN+3oADw3foyLYVD7owBp83nHq2hSv7mDcfSS/Snu5Ll5JB4Nt51DZnHPn2LJxKbGW2wBEEEXjWAfgKCD7JLyEIwxuaOF+JMXHQNwEbtzvINkj9znjkF+mjDCJ9CCwJL97G7JA7OwTgngdLZ6BB1ziugBeNUBZfjaCLQPfYGkc2CHQnYYA3ZkF/fy2768/k38zsy61ZZK94UItgnZdz/mHuCNwROFM9p6vPtfORZ/Y4HxBwcb0O3u785xj47gEh2qAdv0cb1Od3laHldOR7RduUodUDVt+2lhmFORauZx3HnzH5evezlX2+aItAldO2CpQ5vcSvHHzvvEmbzh8ECT3A5XOdh/sD2OtkD9KeH+si4ND7zExymnpZ5KPPB7LCt7chOyQrOI8K39kDR0DORfpil/WMpQ5WkKmMVL8nIskJlXMl4rhzJedLzmgleB1gEFLbmAiEzmiLSzWW7CeNnouBmUHS3UscK9D4JSil3PxtewK9YUGK2NMBqz5X+6to4gKncjLSMAbIcmErnAfCVhne+x8Z6CMYOUCzfkcO0sVAZ5yvlK9wSAenmsNq7qiTc9zhQKYO2WisR+5XeFYOUWecV9+zLOnrMpB4WobQpy5p25kxWdEuabTyBIX0bwWWeFWpB0xREjLm2KPN3miePrqC2LIeLhWkPE96paPYyc8tDlby7aiM/3YjbcZLq2uvmouKBlUfI304w6HD3dur2q/o3tF6RCs3djtdtVI/13+F30gWV2utkmcdf+VTxAr/Ef06qMaW/Yz4YtRfxUMz/pnJjErmbqk/6t/H0m35TDy6tmf3uzKVbE7o9OAIj5Ecmc1/hWv1BH9FZnVy2O9dKcDmdmcunUvwzbI5J/qwBUzX5BNwtpA7g77dRDawgG1eKuvneHKNbBV/COvBmpxPyvgDcM5L1Hcyae5yl7uc6Xhe0MHb3NiGz6HUtOu0IFsZe0XtykdSpgJZ/n6mSmZQVJk0jKXLSPHgGsEgte9bAP0BNcE5+mVOsFegFYd/p7xxG4nffHLbVNoRLstxxCt/wR1pcGWLHxklssf4+JlPLj+SxtV8ZTaR69nOFklbkuueFZVl/X+li32+AecFr+N0TD85A1arQSWX+bl9kGuVD+jjqs7D8vH6/DofEweAb4kBZJ8+h9UZRGlX4Dvc+u07HzzJBX5HhqTe4Ywy32IJLr4dlwA4WZM+96xZjYk4B7LAzxjTd9/h4HR3nFIOrMRILnlgqVPCFcyMJIIKIgQTQGDB3wZQLUTaEqE1GVImciJhZgnmKpiyFd/ufjKq30+DLet5Hb/WOVDdQnahJIVw17ve9aCAiHgi/FEWen2nv+a0anMkpFbmvRv3iFZ8Mn2vwqfC0xdPV2YLrBjuXvaYp6Rb+++uCSqeqBRZ11alHPK7t13dQ1i70nPI+az6z76938TJ34LiSthTRxWcxoCgPE8P3FCqaNrRKw2Fqqzj74HyHJfuyUj0lH5/CufGTIfb5YRO/rnB0/HWit5Iw3NV4W3FN+91OIza7NqqeLiq0+HVtbkCXT/VPI3WdvZdGbdV2dGYunGOeLsbR4dnVWZUtmp7pm86OvG7aqcae2f4dXrT25nxQyf3K5xHNE69OhtTh8eofCUrkh5Zf8sYRrjN6szWyZb+unI5VyP+vZh+LidUW3Icr9y6kw65by3hvz5sveIMIfQ5ASYCRmqDTCEOm+YeRy4QaBKQvUQghLeV+RY3nEj95oEUDiE2hX5jaxOk4Awc3gaH/e0BHQ+u0SZOqvpUPeEg/0YOpV4GonJ+xgofz8r2jIyKnq6z8ROgjwJgZG+5TcI8EmzCocbnoA9eDc89bC135J0fPDvD8aNdrvPAUP95cI7D73anv8kL3uAIBPEFZzMxJ75Nr7LxuNadl5O2T6WLMxBCnZyj7DPXfhVggTYeZMUmr/DMB6peLoNqFQ0St84+zq17/psxeKZQ2ie04f0lXSkjIMBC1qCX9Tp+ZpefUeR0Sfl/Glv68q31ngnl9E4+dzplAIm4h4/Vg/HIJn18/XPPt3E6r8Eb3qdnMV6WwFJnXG9xEiqonBEBT+iz/87QcKJxQK4ErisInhLoHBVSMyvDzdsf4Q3TwTyeRjZyAF2Y+DiqCHtVf2R48V04KU1YhwSjRGF4BLxopPqvec1rbpZCO5ujTnh0eCXOM2PMBesqzIz1zggdQfLW6H5eO09jrhrHzCiftbVSL+evo92IBimIcxxePoVatS59/KwlXinK0zAUSZ4voO/K1mOtsi44XE8BnZRpK/TKlFkv52NOo9np4n25Ahzx9ZWGTv50672SCx3v5PXuaVzXh+NS/U+8vZ1j1n0ahH5tJP/SYKromTTL/1V7Po6RzMs11a3VmY7s9OmKTks8qrns+s1xd+VGvNfRttNfFU6ra7Tj/dSpHWRf1dxXY852O76s1s9sXLm+tkLK/k4ueF+jdT7Cv2sz++2+VzSo5MYxNBjpntk8nNdDrEsBHijJLVidvPF7rjextRXokI3vNHMnH7mnj9u32O2e0SDfgACKQA4a2cUe9CHgkBkUBJfIMvBtbwI/40TZSWQU+BvUsEfyAGSCXeAB3sIFOikj6kM/9ENP7n3vex/a0hb7G2644eSVr3zlycte9rIL3qpcOe3uuJLx4wdi+3mYPBjj1e7QwINpGcDxuchsGPih2wqZsoHv/h+6c7Czn9fFeD2DhAfvnLmJjUhmix907n1k9gnXoIvzO/Wcxj5ep7/zva/7DMJAo26NecChsy0zqOhte4aO9+PryXHtglUZzFoJMPub+jK7zttxHNJmcJr7Q2L/79lTzrveLwFc1raf9VX1fe3bx+/HaKQ8pl0CXamnnKedtj4OzlkjcK4PL/YR//vb7linjgN8DE8lL3F+mgfCLmlgaWaYHgudk8D/nJhcJGmYiSBE8YlGU54MBVLDcgF6PyMjGiZQ+9qywiF7KAlPha1olQJOkBlZXt4FizP3iAbCTanC+XYL6hBcwhH3vioYGewJlTG0pX62sQVm81b1MzIeZ05MdX/rWLdCZ/iOyq46F1W9hGpOV5y6mWE8M8rTEOU/afF3vOMdLzgvSWuKQzMx4jwjUnKAtZtveUkHc4ZT4t+t4YreXV8j+lTO1dUAM74Zrc+ubGVQZJnuWuWoreiykU6o5quTIbNxjtYMspz/6C9/InaMzKpo0+GWDl46f9WarOjS4ZHXR/QZ1e/Wygi3qnzHI5UergKdnb7rrjtdR/xU9VHRYsTjo/FXbVe4jOhc4dC1l/JwC14jmsxk6OqaX5VTeT8drMRjRa+O+pjx7+j6ldYVuSZxavI8JcrmFlXfWiT5J73OtrB0hpCZHILtwQzogO5nqwl1dB8bATvCs5ppx5/467oHXniYy4NtHEnORMEZ9DdOgbeP2cfiY/cAjP4/8pGPPPmrf/WvnjzgAQ84vBDk+c9//iGAdeONN5485znPOXnuc597wZvBMksI2vl5Q5ytJBuKB3QC911cBjJHlNF1n1sBWVDu6FfbrpIOHtDxYJHzBrSAlj4elWFbEWdgARqbeEnjJKjE3CQ+jq/rC8o4Dzu/dfIu/9NPddj8zJ7MB5YrOjZ/e4ac18+MHerm+PmObZKZTr6GkxZOUw+2erAs28q6ZOeAb3VGVLbnfML8sb48wMTa9+N1rolsH+iQB+F7MI8sy8Qh10Jlo/lLBnxLn+qIjwmOsx68vgecqvlznrjsW+EqQ2Zrfa9XGS2VcK3acIAhRXAOzEOheD0JFG0Nqw66G40zceNtDoro85v7OKna0oKjyj0UGU8DlMKqa1ICOluKw+JynJ3jlDTgPwKUpyvs0XShnNt+RgbezFgdGZJde9UYqrZXccl7o3LZRyeIR/WuBCSdtxjkqQir+z6XK2u2cvBWaDPCe8VIdvAnjpyRQOAUGaAzjVyQe+r8iCYzHCveqRTtipIfXbtanIMtkPySfFP9XuUfb6+DivYr8qaSu1UblazZyv9dWZ6eiX/RWfe6170OPK6n0NrCrMBoleWaY8rxjfDI9Z91Kjp0eqii0QzHkdE6wqeTRaNxjnCq2vD+Z/NcGc4VHol7jj9xGNFyJlMd/8pBOAZm/DXCJb9367Tj2/OQiZVs2tLm6phn5XJeunXpMLIFc3wXM8fnAQR5PLsDfHL7WzrtnTzirV3S/QRxfIsWdjB1adePgvCHvGSwyDbQkRkc2C3AafS3YGUGlQJP7ujhrPLQGIcSRzV3OrCNi6wDxup2itNJ/xVUe8xjHnPyGZ/xGYd7z372sw8ZStqVId2h4NAHfdAHHTKYfuEXfqG0V/it9gjUybdRXdGAh3I5j2R7c93pxPi8fXwy5sKda8bqmU4ZpOV+2gtsF9J34UxdxggP+DEg1JO/pfFpvjnr0oMiuQ49iOA4VudXOV9zzYMG+WDCv9O+l8/AUfq2Tj9w5b/TnT6ybGaxOT5VwLyyfRwXaOIBkAz+gpsHOzKo5ThQh6Cu81/277Ry+vtvHth5fV+XzvPg7z7zNXHOEvjnfNK3/vtWtfQhXC663EOecN0Dph7E8uw8cIePsr20wVezlI4OLI2U0Hkrp0wXo/9VfLwMgpGnBUQWCe7geCqjScJFAmWLEcBEwEwoNGdIlBR9K1gEo7FdR9lUEtwPetCDDh+VlbPwUz/1U+W2tM7g6gyLVB76rTZhMg4w1HX2aldjr9ofGTOd8V7dWzXKq3sjyIU6gkqAdrSucOvm4lLDioHaXV9Z11uM5ZVrK+10DkbHz0l7jLNKscrY8LTzTFn2PlfxrxRf3uscuBxvx3uzebwYh+q8YIRn5wCOaLwiZ0Z9Vw5IBxUfZVujdlbXTLfuunFhAEtHaCuzgkpyHvRUWlsefvEXf/HkqU996skv/dIvXaDDVmTQbC46+ldtV21UxlKFQ2VMd7qmWisdDtXvkT0x+j7Dr8NjJp+9/Kjsqv7Luan0r+M2wr8qvzKWma4ctZE8k+VTRo/w7myW0bgqHuva6PpbHWMHHT7nZYt3mVSXC8gm8YOy/UEnjhDXcpuKgzujvOyCAI5vu6KMZ+0TQFLwhPZFF9kIXCMIxMtjyIL2DBZ40rf8eKCBrVme/UJgKTMJ+O/ZHI5bdQYLPo6ytD/90z/9cKyFspRe/OIXH7JvwP1ud7vbQYc8+tGPPnnJS15ydoCxt+V0Vrt62K3/HGCNXeX/cZT9gTXt6LdoydYc3pLF9jr8DgJx6ajjODuNuVdlm0B79SN89Z23u+EH+vYhHt7rwT+BM/holKnhffpcQwvHv8o8yUBQBlmyryzvwQHadP/Z2/Agrb+pjjY9qOf0TZ7M8SY+uVa557w1uq//zo8uTzNLjTpOi8wOq4LT3qdnm+Xh2txXWT9CxwNLKctPi/VJPbICPQhU8e6KXeV0qjIGCbJ5ppVnDbrf4zI1da9nQp57YGlFEV4sjAxP7q/gk9dzEiXgnEFGhln22QETA/4IcQ4FVjscPu77yeUoPPjBDz552MMedhD4OgOJt1VImMth0JNoX5SJnzN0Rmm9vHAigMTbJPxQMlLnJFxd0eU4R85D9tvNXVeuG1+10EaGc2WUbjGgV5yLvDcyJiuajWBmmJ5H/YpPkl5Z1sv59YoXZnM2ur7ivFTl+E2wlExBDBMHUrrzKZFDKiPKbZ3PDt+R4h7xVuV8HYPPpYAZ383ke6X8q/U+kzMzqNpYcdi6Bx+dPKyupRyt8PB1JLmu7KTHPe5xB30hXtbDiPve976HwJLk+M/8zM8cnAjOtKjW70yHJZ4jedbNS96vyqcxnOU7PeM4ZdmufPZRjXl2req/G2uuxc4oHOmlFX3WrYFu7qq2qvvZViWTOn1erYOtUPFMN8auble2wyfXdP6ere0RHsnfnSyftXexdK3aPI92jgVsTv3PwAb/q3G7nQv+HlyQnatACuen+mu9Cb6QnST7HBuYs3Q825nAj2cIcc2Bw6P9bWfglzQmW8DPVCHTJ2WbZxb4WDMjwW0b+RH6vPCFLzx50YtedPLa1772YNPzEFt1NfaHPvShh2vYR+5MO80JLkmvKPjD2VFk+rADwg9H922InLtEeTLH1Yeu4QB7gItxeTCGrAtoktk6+p/BDoFnrHnWkvokA03tckg3b36jrusP58fMVMoMpayXgY7kk0qHVDI1M9S8PP2yppwvaMcDLX49bZMM8Hk7vn59TE5f+ki72/tkPN632+Mpg5MOSWvHv7Ols4zPA216UNtpBl9z+L3uif8Jpr6t2CoJfVxGeeJG0jSvZbmKx+g7+caDbMg/xoLM8iCYA7+Txy7LVrgVpbgFKoMlr/vvmZJH0WgiiYx7KiKZSxIwW89SSTy8vAQ3i5sUPRgYJaLvenKgA/bkIPgC1H0OFK8ET0WDynD3slIM2l6n68LP0/24r/RYCfhuTpgXxykN7JXFMaPnjIk7o2/FcVrBpRJCK2Or+lkxRLfgdYxRutLOar+dgE6+65Rl1fYM/xndk/c5yFNrSsYUTy9d8fqTiYomI94dPe3taOvfO8MhFXxe20K3KwmVI9bxj5fJOh1/pxExwwW5fx7OWbZRpQunkebXqrFVMsNBBsH7vu/7njzpSU866Cpt45QRzCup5Tz4G2u8n679lGuVEVuNo2pv1PaIdl373ZxX85cyZ9Zvls0+Ep9K/2UweqSXE/8cc0WDime8/wr3HGdF1+yjktWjMjPcVmC1fIfHSvnV9ru2u/XS0X7Ey96eP3EHugecK/PW4V9BzlunVy4XOL+5Y5cZOi6/u3Zye5HeriZ7ljNFOXNJASMyZyQ3FXBROd6iRL+yGcjS8W0tjhtvkvOAkPrzl4Pgc1CfB866lm8py2CZgF0Ono2Rzjv/dU1j1GHdsu81LukJHiLLJlIWlmhAVmueAZNBANplFwMBNuGgh+AC9cE8kQnkuz8411bt82ZbznH1t+FxxlTFp6wbfzMXNO10k+t7D2bpumxDHp4TWOT8TQ/k5Vrx695Pbhnjf2ajMMfcqx5SOXgGCu13tqcHWrwfx8txzjESGHMerPRqZ0N5Hc/acx53/kr68J95EjBH/CYDMfVUwsxOqMoytuQtpy9rjCNlPPjpgbrToGs+oFYdz6b0eU66+LXONvOttMgH2mce/Gge8PMsLOdHcCIY5cHZcw8sVZPSGXKXGzocdJ390QgzXkFJho4IpoBKdb5SxbxVX7qG4PX9jM4cmapHO2Q1SbnJURA+ylLS/mc5DN2Ejozf7FvfNW7RQd+VFUVqKAJf9/KMjmOMxm7xrrTVCa1uXCttpUJIXGftzWi7ZUwXCyPjc+V63u+cg3R6UoGMxpR8Nxv/jJYjgz1x8v8Yjvovg4rzCjKjqeqrok/nWHROWTWmLDsaW2UYVOPunnpdbTBa2zm27veInzqjq+KvnIeu3Og619ygWxl3ZRyM7uk6Dygkt7XVQW8x1JZqHcoqo1xb4J73vOddcAZItXad37oyFY06GM1FV38014mXt1f1XRm2jvtsTN26zXvePnzWQa7vbD8dlm58W8Y+Kl/JrE6OVfWreiO8zguq9VDJxGNslRW+rtbNyphHfDiay5HuyOudTVPJsplcu1LQrcW0mRPv0dYngIe3CiCwnY3Dtgl4+CvpacuPztA1ziQi6CFcyNLBxtdvAiY4eNRHTvBw28emwJXkOvfIOvCMHKcJesDp5lty3K/hTWjaMs0uCX4TbKM9dyQ9UAMOBND8jV74E749DSeVbYL+Ni3mkO845/otnUVAx/mgkiW5XSftJ9fH/pssM82309SzoHyO/b/zXIXTaJcI951HaTezYlK2Oe18vis6+XYlX0MpI9JWqWxan6tZADwzyhwvv18FQ7tMGccz8fGA1UxfV22n7vU59i1u0JMyJIfQBkkZ/nbpzFK8tjmfiv+Mg2CQ2uR4muQXf+HYyFbhOxlUrGPfcuxZWPwnbuHluUefBKYuWcbSbPK6csf0U8FIWeY1JlnGtwij7QP+ligFUmSgywHtnojMxsQ1TY6CM+pDTwVcQKM4/DA4gQJHcgiUuaTglrKUOOSbg7tdUM7G3zkIlBXj6gmD6OGKyw8Pmxkc3bxWRk1VpzLWR+124xvxQGW05L3KuF/p3+uu4FIZvx1tLiV0NK9gZqzP1uaW8Y14eGRcdw6QK1v2yWsdZVqwv0VrNMZU9olv8tEIUqlVY+ucD1cGAn9KshWPSw2pwEc8UK3TmYzxfjqZkPOVOGV7Wa4qn+10eFbjqfD3Njq9Aq++4AUvOPlP/+k/HfSLvut8DBnl0hk6h48U/ko/uwF1rH7vZFdFRze0KrmT9bfgkfU6OV7NYxrm1ThmPOXXKj7fqtMSKvnS6Y8c34ienXyoZOnKva79ke7o2ksZ0LXh4+3G4UZ95wyu2Dgr+M3oM8ps3YpTxwd5vVsnVxvkVpvk7cq5Z369bNKY7zw4lg3gWfi+XQ0d6kdluPzyPtkO5gcPs4UKn8J3J3iAiMCMz5OCXrywR74JmUVk1wjIFIAmZEpUdMHekS6QH3LdddcdypJBpXIKsikbS2X14Frl83Bzl5v6qC4ZX352lfwVHFWVUxl9NB71iaPs61HgZ1T51jPn5UoeZ7ANqN62RTnm03eOeDAs6Ud70CAz3VPvVDYY5TLA5ZA4OI18/Px3HLnmwQPG6DRwHB33Kguq0l20nVlWvkYZS54FluNyvKt1n/rM1z50ITDi7XW2iZep9EXSJOWKZ/D49jHGy3/NgW9ru9Xb+cVp5n04XsgctopSP3nM5z7XiAeKAA/wuezQfwJiBJOQNeBW8RHzsKpLzu2tcCNjoYKRsTVT1JXgq9r3/vVbAk5PeaVg9AQChUDKbOWg5e8R3uDC60XVNimguo5zyz5iGEUK4Kd/+qfPAlEoQoR9HrBVjTkX5oyuXVpb1W7XVgeVgp+VyzGM+lkxoGcww3/kcKw4kd39rs7M8dhi3M9gpZ1cY6t4dAZ/VSaVQudAVnWrcSRuriBcyVfKdESH7PdYuVWNwf+PBDeKgANGUV4YjNXrU68kVHM0W9sVr1XXR/05dPO9iv9ozisjs+JhNyhGeMwcX/jjhhtuOHnyk5980F8C3lKE0VzJoWr9juiQTnMF3XxU9VbWS6fXsm4lO/L6DMeRHOjmu+PjLmgxg9k4V8qn45G09O8r4xnxa1W3Mui3yp/KsB+1M8KrateN8ouRjyP6zdpckV0jO2u2Fqs+nJaz/o7h3/MCdwIFOEpVVgT3KeNt4HBWWRKenex9IlOdR/y6bHB9FIThrbL05QfmCjgEnHp+hgkfznZSW7L15QfI91BghYwitt352T8CrtFH9fYxxi3cpCd01t6HfMiHHIJLGrt2QNx4442HfvVgWWWf85znHPBVux4gYlzQUbpFeErv+EP5zH4g+0rXOLuKtsjggsbCg4PANbYqc5y5Yuugr2ufRw8qdfrV63kgALwZt8sNMsiYdw9WeXt5sHEncynv/Mz40v/0YGfa4x5oYQyVjeHz6fccl8yW6uxzXzveZuLt+HnQwucqgzqpU7F33c5yfssxpx6mvGfz5fgTdN/ngfL+1kqfD2xw8bXjfs3b23Ha0IYHquFDL9PZhZlh5DRnnDkPVYYYO5Toj+sEwpzvfE10QcNzDyyNFG11fYvyWlXUI2Orw08E1FMCCUmI6FHNWb+jPvw3WRIwksCNfx8DOHFooDvC/n8GI0HQ0XClDR/fSr1Rnyv1t0CH0wo+Xra75gJp1lYK9Vm5LXCsQVy1s0LrzhBPg3R1zTjkvFRGeodfzsXIwE/lWCnQqt9K6a7M2Yy3sz+EvwvsXOv0LWUgA5egEnWkKNjaOno6diVhpiu69bXq/IyMuK7PEfj8j3BIXu3uJy4rRlzyHG3JENFT4jRwU6c40P4KnXKsHe5VeR9LxfMVTbONpMUIx66NkQ7rfudcdfhXNkAn3ypjnP9VhsWKPK3mJWXXaHxV/918zvAYzUvSaMU+7NbdCCpe6fCqaLPKZ6v4bNWJq3RaxWFkn15Mu5cKnBa+tWyWzcAHPvYn9IIMCgB+hoyuE8jh4G7a0Ae7nDfD8SIeBWlc3vrh3q6b2UJGm5z16Mde0C9904f61JZnfyuZO9Xu/PqZKuAkm+BZz3rW4exWHm7rMG9lMum7zkZSUOlXf/VXL8hIwCZx2nvAiLOqoC33M2PKtw2xQ4Rx6qPjPuSD8QA9+8s51ce3DVW6hrIeAMo13WWRVLzlssjxoY4H80Z6wtv37Cna94w4/848Z9DTr2e72UbqVPpNfvI2cn0yRn94mZmDbi97UDcDZk4jbz9pRx9u02aw03FMvBmbj9eDeT6XFR4ANPEtn9W69vHcFOckEcjxDEfKeoJJRf+O3j7mKsjkySz85gNe0MdpDJ6V3bdFL59bxlIHI8PjPNqrmGrWZzpvWwyg6pr3pycPfmi3+nLFURk+zlxp8FVBpWpRdo5ARatujN1i9/pd+zNDc6X9rVAZhWlwbzG0ZvdH7ayMbUafLJP9rdRfgfMwOEc08Loj56zr47wM4pHjVN2rjA2+j3CaOUQdrTi7QU8vBdr6iqHl9JMywNDkDAMBCkHyxhXd1QQzed3JYa9fre1RH349A4OVfEjcsv8V/EdPczp57W1VxuNI/na87de9j25Mx/BLRTO/njK3o/nIwO/G09Gvwy/Ld2VmfY7kQTfWEZ6VfKzWQoVbyppRfxVPphM+k/OdnTEqt2JT+f1u7AlJy9zSUeGY63+ES9VGx685hlXDe8uT36220iqttzgJlwM8EJFOczXvVYYC5fXdM4p8zXCdLCLpVOlWjp7I7Bv60E4HtkNxGLefx+pbp1SXLCACVwoo+XiUpaM+OZ8F3Hj4rHvS68JPH3wItatMJpcZOL0eTFHwS7sgfviHf/jkwz/8ww+/VVcBHZXTFrgf+qEfOozLnVHw9zF50IKDx3lrdXVGDtkaaodtcdTVuBVQUuArM2x9exGBD7KcwIGdJe5o51m2VcDF+YRPBig8+4ff3lbKqcyIAZwHybSivdSVjrfzNfRIGQa+nIvrQThokW8low0fK+Uq+yP7862ACRn48QBJFeCDXk6DzsbLrDBw9GBR1s9spqRvjtFx5H6O088iY5yewcR8aL36DqNr7Ewif0siR84wJv1HDiS/jmhVzXE1Fv1nKx/093O4XCfQpwfhMhh6VQSWOjhGsa0YkZUBt9rXyIAaGavO/LxOk8MCxTC8TSGjrN5ubtfxMjOHpSrfMYALxyzjTL3FaJ/dmxn1x0A6NCn0O4N1ZR47WMF7xGujOakUzoy3LwWs4F/RqjPcq3mv1lbOlde/VOPuHETHqeq7c5pWeIh6+sjg0rlqHKL/ile84mDouRzAkCUFnT3dCHqV5eBQH9OVdhoq2rqDN+Mbv9eNZ0Trav46hTyar47P814le2fys+O9GVR8Vjm7HQ5dm7OyHd9XbRyzZr3d1FGdzFmRNyu4VrjPZFfV/0i/VLxT6eLkK3c2kg4jG6CjbUeTlfF1fDeSiQlbeL2yR1Z0+kqfs3U/+77Sx0rbqf8qGm5ZT5W9dd7213kB484tSK4v9OkyeStwPqm2SHFfelOZO9KjstF1oLUHetCzBDN0XXa9n0WqexlccKdS96TnCdrg1BF88nH5mlb7ZEHJYVVgigdQnkHEb+cjHj5pTE972tNOXvjCFx7sDOHDebI60/XlL3/5BUEKznriYHK247kTyjh5yKVrBE8YE+VxumWbcMaV6KUsMA/S+fk82Di6p3HrPnTSR/c5KwvZ6MEN+oWmZMyk7MgzZTp94JlYuX3N+c15rdJTuR0LPsngkQdGXO6Di+ML3Z23OtxybE6ntL2r7Y3g5Dzu69av0U+VHeZ2rdMjM7Wq9Q0N8w1rVbaWz7kHIit7otPh0NjL892zt3zc+Ua2rIvcyHlmDWZbTrfRAyEfv7/B0oNfus+6I5BfPZRxHGizyqa6qgJLI2Nvpd7IcM0F4tf5v8UwnOFYGV18eNuUBHPuHT4vAyZpkIb5iuL131sNjs7BOKZsN6auzGzsVVtplI/qd3isGHmXwnDbQuuL6WMEafhWTkaH5+r1al4rPFxhrs5JyodURtVYu7ZGkG1WbfPUD4NRv/WmL5254NlHGF8YXDJsPe0e43VkaF8pWFnTs/opm1IGjNY619OhcBjdn/Fr6pJsr9I350GXEX7ZV5arxuhjr4ziqq+OlhWsjnNVZ63gl2Ur+ld0GdHK203cOvnR4ZDtjHiiwq2TvSv2FcbjaFvIqP9cWyM65L0t9t8x6yPX52o/K3Pa1btYvTyz+5Lft9qlQJ4dcl5y6GIAnPJtVhWPgnNmd/qnsg0cfKzoVNe5njWjfjhMWzpauhd9zH0PcrgDRoDGHwThzGmcnKOa6wfHEDr41jIynIUHGVFkQDBe8BJoXPpcf/31F2T/cFYTdgXlhbOCOWofJ1SBKOHKgeXgowdgwsW33XiQhyATZ0Ay12qTcZPJJTsI3NU/9NQ1/fYAnNoj2JV46b5nizgP0b8HSqC5l/GsGw8YUm5kx2aAw+t7gLM6XiHldyefRQ/RnQw0ghJkFXkWnQeuPDAwWv+Mw2U944AnnVaJX27ZqtadB3+yfkXr1B35dra879tpc9y07XilHHf6VLsHfDucJ4ToP2etnb49wOtvWvNyjrvPhV/LIFwn06q58378wPM8W7mye7MP/+5n211VgaVjlHA1cAQa0Xki7FXUNtvojKgZgbu2nDk8ug4+VV+dEX2pDK4RdIt7hGtn7IwMx5Fx2THzyFBcMVQTr1VnobqfC/xiwNtYaetijddVnMCnm5sVnu0UVzeXozbzXtKtq7uFpiOHbdZu93vE28gvDvHk9cCelp/rz5UEbbBHupN5Vwo6g2WlfEW3Ti77/Fd1u++VkQUenVxLXFNWVut5Nv6ZblmBFV6f3e9kUUXPjh7VOq36H9F3RK9O/nbf+X2MrO4MzYTkhVH5EQ4dnx3DC1Vf+bvbRpT4VMZuh2/VzhY8R2ttS/spSzrecKie2roTNbItKrxH+rNrw8t268LnZBVGttnMdrockGNj/OhInKRO1qeTCDB36bziYPGQht0EnLNE5o47YJm1QlYTL9vhITJl8/BeAiq+XcnnHR+Gs5WUOcW2McbH1jn1JfwUkNGHrXN5lgz1cH79rXjqR+cesaUvg1q6LiAAJTuFQ7bVP/9FO7YUqg8FeqAtfYOTB7Doh90dfm4TdOajNqGPyqm8PmRyaUxOK1+v9Jdv2cozmuAj5xff7lTJkVxXVQDDeZF6VVDJeayyR8jk0ucOd7jDgUc0fm3d1DyQ0abthSrPQejwKm34OP1Aat33377GKlnt2+JcRvr4nXZpX/uD0JFM87WS86LvBGD9Hjaxy38fu/NGZrr5nDpOuR2StvjtZym7jDmN7DnHi0A6QWHfFlrZlpnRlTye5ZMPkUcEugjAEpBkXXhgOHnGr73DZCxRl48IpTRWCXeeHGih+euWHUb9rRp9I+eBSZeQQ/F4vzMjNduvDI4OpwrfzjAfjbsba1emokPXf9dnd6+ib/Y/M7yz3ErdSrh3uK1AZ2RudRq29LNi2B67DlfXVVdu5kS54q5gZd5GfD1yiqp+R47J6rzm0xeBZBZGkhujGHW0r0/KE5SlG5WV0rlS0NFptP5Gc+ff3Qio+phBt769/ZW1PsIzx9vJsI4e1b0Kr84QXZUt2c+onZFO6Wg/W2urOibrVt+rMrl2Z3O70ueKrTBKG0/a6v9oi3yOI/sa0WrUpsuL0XrYmgI/w6Gbv9Ha8Ov+u2tnpO9mbXl7K0Z0x98OHQ2dD0Z8PZrf1HvH2tVXEny7hiBl/Gwd55YV6mRQiexeD1AQ9MEZJGPG8SBjyDNvdF11FASSD6IAiHwQ3eMNb37mCtuVwNvPXFGQRw+VVF7tKXig9pRtREBI/bOlDFwUYABfeFVjVHs8sFLd17/+9WdBJeHHtnqNAfuBulzDyXR64LRDU7YIYocIOBfK3/LGOAl0cCwI86F2eAjvWV0AdbGVmD9oSdBKgS5/OZLuE4zRddHT3wbHmOjDbSu/7sEUt0E8eFJtz6KM86Xzln/3s5Gch+EjBY44x0dtKxAnXtG2QmigegRLfaeM6xi3P/13ZX/z3QN2zEVmDQHU87F4n3luV9avDqh3/LKPXO/eZ2V7ednqoYHrPJ/rCo8MRrp8uDYCnElXAjt80i7wfjMwWs0XUGWMkYAjyAC487G37XzBvLHuzj2w1BmCW2FkMDh0fSHQ73znO5+1R0RX3xHwyRSrfVQOTGUQdvinETUyFiscKiZKQ5/vvphGY1qZy5ETVSl6x82vO91XDK8VvuockYpWI1qs8ls33q1Q9XWsAbjaz4phmoJu1nZnyHdz5O1Wxv4Ipw5Ga21Ub9RvN35Xqh3vVf126yrXiQeRJLd4sugGFe3xRI6nDvpgiOkeb6mpxne1QDc/nS7YOtcoyBlfdd8Tl+5+59gk71fjHsn8EVQ4d3JlC3R09LFUY8r6szW7cq8zAqs6Mz6ooJLnI17o5nlE966PVfkyai/HPpKtHX4djUZ1q+BKp1+PlT1dGyO5e0xfI/4ayZuLhZFcqqDj75nNttWuuhR2yDHgb9dyxzJlO9/d8UvappPk2RFk+vB2Nuld3g6tNnjxDllMArdlfGsNelkf1fGXavBdelngQS8yo6ijzz3ucY/DdZX/tV/7tTNHUD4O+LDNCRwIMKmMttBzQLaCSre//e0PwSPKy0/Sod2cJaV+CDy4fOI8WIJenBPL1nvaEziNCTIooKS+hDvZSxlgEF5sj2PMuudvfMMWIrBFQEp+ndrmzCoP/oCrAi0e/FL966677jD3L33pSw/0ZdxkTuVb6Vy2Uq5y7pPH3Gd0vul8SA+u+MHQ9AUfiK6aZwJxBCs15rvc5S5ngTXRR/OsNp0GHrjN7abgn/ilLktZ4nVcR6S+8/N9wKMKtKeN4evabbtK91S+hreXdXw9V/YNQU/wIKjY+RF8x36/Ns5P8zeywbN+yDc4pOwCX5c7lcyGrrTBGvI5ow2nEdcZpwdDdd/nSuvID6I/18DSVsO1gi3Ke6QYGagzAgtMEXoJyFVja+aUVgZjpvNlIGt1AlacVSY5t/4Rfeyiv/yuHIOZsTYr73QgHRaB6E8lujF3feU4OkFSjbUTNN14u/HNDLJRG928d87CqM/Okb1UMDK8V/h5xPura/Fixrq6hcHLVr87Ab4K3Vx6XygA0py1XmRkERT3evoteUbg3J/8dS8GuBz80sHISa8coW7Nd0ZZ52ClrPZ7o++VfM/v1e9qfB0NOqj4bCbntrQ1gmpORnphZTzHrpkV+dzxULdeHe+Kpzp8R3O5MidZJmXLjEaz+6vtVXpwpd2OdzujtrIvZriN8Otk52hNVWtw5AyM+l/BfQtsXb9bZXe3BmZjOK/xXSw4L+MAZUZFvuo85y7fZOQ8if0sR1yBDxx0zqPBj2BrGw6i9K1vh8u3aHHItYCzj9Q3Z6vSluPvOxrImtJ16X4yd97whjcc2uIwbQWKwNcDI4xJB3OrHBk5Ov/oNa95zZlfhG2uNlSOt9FxXAd4+hYefQiMEVSq5CJ00viVGSR8tHOE9v08SJVjyxuOLFtzfDsR+NA+gSYBtPWzq/TRd42NABT2FbYVWxyrbVg5t9z3t66Bc6VLuuBAlvMy3ZpFnsJfCihpZw7bDcmwgy6c1alyCpYSZNPYZRv6XPu6cvs434zmfJsBHg+swjPOF+nzOS08sFLZHN6vZ/34x+v4tdRD0DADm5R3Psu+PYjovoTPXdIjd0nd9PbrHmxKvnO8nF+q8aWt6ryb+iLPUcLH4Fy2EU2zHcojMzuf/ujAUmXkXw7o+kJYIGD0m7c8kD5aPQ0UJAPyv2PerEcwhZRShF1ug/N6/n80zqouT1ikFFF+6lPRaX0yY2HmKFTggm/VCEVRCTf9RnALHyk5zYEvuJGBPjLYO8emMhwro3vmSFRQOTEzeqQC8bYqY2e0qP3abNyruPlvF0i+93irw7JybzTXM1nSCd6u7AiHysnocM06lbNz7LygkFA6MsR42qT/LvRRTlpTepsLawyjzA8QrMZwNUFHs+6e16vKbNFDIwWe+MycsQrnblydPOrkXNfOqGylu2ZQ9VWNp+p/hX5dvS0ytcOpwiPvpwHW4dHRrKNFp686Hq1wq4zEGe9Tr2t7xE8zWViVr+ReJV+7cY36n+HX2WCjhwUzuyGfknd4bdWtx8BofYxw6Xikepp/sfbd5QJ0mfN2ZZv4GN0ZxJYBdJ8sCWxnr89b3PKpPn4EASHOWaKu848HawRy6rku4HBp+QZc86f9OM1sG9N1D6yQkSRbwLd/KWCArwOOCjqpvGwDlWdcZFyxlcptBl+f1dYktgj6dp10VBm/xqiMKeEhkN2vgAYBJcrzIMzXIoEJPyfSaa3/nDfJhwPHCa74eU7UI4DhW8c0JyQbqIxv5cpAZvKX+5GOI+DlHHy9Mk7ayT78u8rKr2KLJIe1KxuL4KMHfmQ/apwqL1+MYKOy3HXukgKNvgXQ365GG+mj5JjAm7KezeLbBCv9WsmdSkfA/6lnfO24TexlnIYE3zLo4vhUNlnSInGAdtUcu7y6qbDHPfDtQTOnS9oDfr6U40JZgo1JM8ZBOQ+U8X10LqvzOWudPkYvIrvorXBbDEPqCbp6qwoUIO3LGRuohEIyDm0gsJn4fN2f440CQ5gqgHW3u93tLBIogaonDfpfbcNLAbJqjKJQ7nrXux6EDEpNfTIG9etvmBgZqtm3X9syr+qbpxQ82UFZogz9SUMKkKRtLpotOFcCqxvTFufEy4xo0/Ev9TqD+HIZeVUfKF0yZTq8thj+o2tZd+QgJb07JbDaZ+K85f5sHWUbiXdXX3SXMYgClNxQpiWGX9UWgWu/XimdEd6XGzqdkbIqDYDq/9Y+Epx/OkNwxicVnjPcqmsrvFKth2oNpCHU4VHJ0WOczS3j3sKHIxqs6LMRD6WBW+HXybmZ7K++VzqpKtdBNebUmVXbo35y7F2/WbbCY6Z3V6Di6Wyno2NVpxqr41u1041/ZT3M1s0It26MFS5dW7O1W635Y9b7pQQPIlRbijxoNJLx2JVVEIK3neka5xUpEILtjl2fzhYZMf5adgFnEGHnyj6XEy/HX/dkT6murpNVonbI/KFNgjMaOwdZc44SQRC2xnF2kgIkKs9DdPXBQ3QPYhEg85d94OsQfMrziPBbhIPAs1EIaLGFX/3qo6AS/fkZUJ5V5QEk3fe33vmH7CUCA+Cdzjxvo/M+/KBxcBZ9tM2Qh/C8QY6xpa/o65LvnsnkfAjPZT0P0Pk6yzFUwRyceI1BfhUBSwWHOG8rXxUvIAjJkQlss2Q7JHMHTh7gABffbsVadN6hnI/T6ZNlKj2T+jfXd5UR5frAA4DwcNp0o7mc2cppIzgNfCtZNVb/X/EQkHLYA04ebPJ6qbd9XTkf+HrlOnKInU7IO4KzOV7ojkxEZgCc1XRugaUtBkPCbFsK95zJ/HoCAsqFFP85vJv6leHnEWERXf1qYUqI87Sh6pv0RC16CSyeIDChHLCXDOiCwycvjZ8E6nFAIKmxAtJLFWwiBbYyytKISVpUBtfM4IEO6tv3lrswYGuiZ1Nlv3mgoT8ZmRmLjvNIUHSOyYoxlu11+Izuzwy/qr2uzcr4nq2rDjfR2QNKnQHf0bUaa6VMss6Kkh71OTIsLwZyHeTcrjhO1ZODDrReFUjS0yYBQaMqsL1C42pdXGkY8els7XRrNo0G/59tj3AYycYRXiswWr/+v+o7y1c4V3VmYxh9z7KdHqj0SuKFgSIYPcFNOqTur2Shj73i70o+Zt8ra3tVXndj62Rgheusj6pdx3e29rvvHS4VTVbkjV9PQ30Gq7Kqs5dGMrrDP++vrskObx/7yKbr6ieuo3ZmsnM2hqtBNzi4zPBr6Uxm1pmX4zsPW2WbKngkW112vmxo2eZk+ePE84CWwIeuKVjih1oDvq2FYIrqSYerb7Yd6T9b2bCFPfOH+fMsFrKKdJ0zkJgnP49J4yCoo/FRDhrgDPu5jfgd+k0WFcEj5wV3UJ2+4IqvI9rqw9YzBdR8t4af7+NtM5+65w/ICAjiLFc6L7fCEazDSQZH3VdA5V73utfJe7/3ex/o9brXve7g2+njjrj7HanDnCepA22ZsxFfgmvahOn/cU28QlCJQKjoKl5i5wd1/T9BOP1WAErzoLnhjYFqw9+WDi4eSKXt0VanpI1fT3qlXs81nLTPtpOX/TrlnOYe8Er7Q9d8K5rj7+UzoyjH4fT2ILj7qxkYOo1gkPNZJ+cdn7R1ve3E0dvxgKF4ia2R7HzIN0u7nNV3f8lBZZddNW+FmykyFlemwKaQoS0WjG9H03WEDsGhqm+Ifc973vPsTQyknKpvOXu+uJhoBJ8WrLKHJNQhPBPDEwPGlFlHqqt+eCLBtpekhV+jT188nKsCLZxRqgVa0ds/jBPmn80ZipAD8/KNEp6SOqovBc5Bf4yDg/389Ysdfbr71Rx0eCTMaFf1URm0Vf+VY5B9b8W3wiPLV+PxrLqRE1Hh52W78t08Veu5o9vs2irkuCrB3jklCaM5qgyibn1jXPEkyZVC1hu15fdHeF9JqHgsZU/OSSrUVNgj5zCfGlZ1st+V8tW4ujU8asOvrejGWRkvV627akzVPX47LaotRF6+MibTOO3okFtMHKrtMehaDDgyjLMvx7PDY7Z+ky+SVyre6frPdqvrHczk8UxXdLgmnjO9WvU7MqITlxXdMdITo2uVPM9xZvnEy22ni4FKryQPdf104x/JmFU8rlaoDut22zR5jewXB2x0HHN9ZN8rY0WBJdXjMF1tEbrvfe97qMNDHd6YRrCC83oIGOFfYB/Tv+rJUWPbHMEobGHVV3n5ChzaretsT9N/2buAfBn6RzbqPg9oyehh5wIPoniwrQfMmWXAmHTfzybCD8nMHTKwqEP72PryRXjLmgJ0bNvz7VWp47E18Q08A4y5I7sGmU57BOVcD4CrB3gImGluH//4x588/OEPP+ApuPHGG8+yul796leXdoLrMQ/+5GHTHihijBnYoF61hcvP7KItAobiE9pQkIgD1inLfFLfs6loVwFDcEr96vOS29cqvZjZRC7PXL5VWUqVv1Gtaa+b+t7lg69/lxMJ2AX45rntzPv19jIbK/t3Oepb1HIcld651oJauSZSPmcgDp7xbKSKHqz71BseIKdvrmVwzP12j3nAX0n/c8tYOm8F5UykxSWhJYGbAaJkaggrwS1hRMBG97QgFXSqglIQiqi/L3y2dum6hHhlDOmjMuqLiSRSj5JwZqM/4acMJ/XL5AtPHbDnGVYVbVxYCS+eRBB84aA8yma6X7X4wItUYXdyK2OI/9mWv5aUdFQWmR/4l32rX9HjwQ9+8EH4K5inpwkqr/Howz7tiudGzsHIMKsci8rArtpKh8B/V8I5g6THGM0zmLWZ+HnZbo6zXtdu5SiM+q3oPXKMqnuj8iM8KoVY4dk5R9U4jgVvN53q7klJB0lDNwRWFcClgsqhqsoIqic9CWmU+PXss5N5K9dSHnSGUnVtdcwrZVaz39I4qerMxjRbgx0e1b1c310bvta8Xjf32AjSvzhpZC132bpevwL0ZVUn9d5MxrmTkfJ+9iR4NHczSHpn/Ww7dWB13+9V/Or2mPc3W7+jOZ7RZoUGiWPXZlVvtF624pVzkeW36tkRfVd19NUKyWO5HpPPcISwYd1hlV2pt2RJRshJJ+tDdrlsZ8kK2feyORVgUnnZmtiu2PGeIcTZqdi42M2eFcRLg/whLza77iuooWCQgCANW0pUj+1j/pDJty+xBYpglOoQaCJYxK4L2sc55SVH2ORsmSKw4JkrHPOBX0SQzHHlTW74LSqHH+AZWMhW39GR+p55576/PQ9ZCl76TT/g5mXlY73Xe73XyROf+MSTRz3qUWdBNwJzD3nIQ862K8rXcFvL/SbnQc8MqngzZRrjpj23xzrbhTkiA0z4yffxN/D5XJFw4QeX0zb0J1GCB/dkn2T2jweenB4eCEnwrB3a8LXMuPyaz3eC+6veZmbuV3Ldg0P+f2SzQCeBZw/m3Ptvp5PrvwxYdQ/UTqPMyJ5wmedBbE8EYOzOR/yvvmdMgusVP3gAEzkI/22BzRlLFUE6A3kFMBh1MDWn36s9LSydHaSoOPtt0+ghxQ+BKujeRgZ+njrpr/6ESQhQeT3/QOw8IFCBIp5QOJ4qr7RMjc2fqkiIqO8bbrihDIIBvCVCZXiSoDFL+OgJhT6e3TNzWnSNNwlI8PghhRK4GkdFw1xsnM3jrySlnB9mnm2IVqLFAx7wgJOHPexhJw984AMPfb7kJS85CFWN9RWveMUFr2vM8Yz4rVusnUGZY6vKVg5V9ZuFyb5+BJ/GQibW5TT2KtyTjrP6F2tY8zu/j+agw3dWplI+qdArg2CLQ9H1WY29c/oS1xH+FT5eDp7zp5xdFsjlghxXBRVtKlrO2h7N9RZ8Ha8ZDivtrJSp5jWf/q3Qg//phGW5NCyShiP8R/KzKze6nnKgWyPwN+dO6IMjyFNz6a00XGfrqNKXFa2cTh3dRuMZ0TfnrirjAcYKttxbnd9uTDm+UX2vu7ImKxp0+K/q0JyDTm+N9FV1f0WHrsjxHHOHW8q8kf49VgZeKUhZ7k5b5dD7esjr2F16gCt5IRtZtiXBHX/qL3tMtityhKCK7qmen9vqWUAErNjKJRvYsx4U1PJrZOCoPOeP6re+c4QFNrMCH8LPD1X2zBP8E/3nyA0PemlMald9igYqS5YTZyDlwc+eieBBMujMGVE8eOcMKYH7HZ5R6m+s9jOmPKuCbYjMte6no84c+zlUbAMksIadLR/rMz/zM08++IM/+OBDvOpVrzq0oTHro/44F5dMK3iuylqpbCnHi9+ePZIBCAe/5+sTftVcaY7Sn/PsEXD1QKA/2PfsHvG7eEEBN4KrooEflJ7rjjGxLj045llcPmdpa/pDlNQBXPPfBLxyPtwW6mjo7TCW7DsTLViT2XbOb9oiCZ7p5/PvfV4btlyFO+07frl7K7OhvLyfm+Znl4Ej49V3ttgmD1Rltca03vVd68eDm+f+Vjj/71ARfqbcnEicW8SBev5EAoFYHYAlgEiuCEbK2nFCsHFuUcWwfo2sIS/D2waUYsm+ZeoJf41LQTMYQAEdjVcLn6evHoBJfPVb7atf4UmWFE8dcsvfzPkgY0tPdjgInKcUKCUpY9qs5lvX6N/5Qh+CXiixBPUj4a6UVWUtiR6iA4aA9kNzkHE3bx2MnIRReepUv1cMYuhKNpvmybdF6p7GRlbWCKctcEw7I8dvta1qbXj97n6FR+d85f8RVKm4s7GlgkeRdfzuuI7wqnivWtNV/1m/6weeE77iNxkPOkcCg1frV/x2NUHywExOVTTnd9dm1+4Ij7xe4bBSP8scS5NOjlf4VPyT66pqqxprh9PK2vXv2e8I52yra1uyVDqLLejSuWTbSp7KUaigGnd3b1S3479qjKN13NFmpGdyHeT/7H8kx0fjH+E70w2VvVVdy/ujJ9mra6/DrcJl1Xbt6o/wG9lfOf7UCyPaVvw14seZHql44DxskWOhynjgmm91SpkF/5BVQ2CJIyewT8lawTblYTR2vPSkbE3ZbpIv+u8OI4EWz/zQd86+4fBslfVtZ9i+bOXiPFiCTPgBbsP7odoCl3Fsz1P7HMztZzLi+HGwNtvqVJ8dAP4mtaQxQQdwJMuLQJL6xjcjOOQHCOP0O/74TKrjL/TRd59n9Z8ZGRlQ8blnrGRwCfSQ+rGPfewZLThHS3Mq+klviObaIilfTTaSv4ku7dQMSGQgwtdlbquiHX84n3THeVewi3NyOfwdngcPeJd2/GwkfA/9d7rjE/PWbgKRngXD/DAe1hPjhRco54HZSp+B70imelCHcrkdrrIlnBbVFj0fg8sS2q/8kJH+dBld4ZOHuoOX43gactuDc8ybjyH1RKU36NPPJ0Y25XjJqiSxga2mHitx+YoMk60lniEQ5Wv83ANLW2FmuFEGAUE0nzcpCDRACUheOdkZIZ1hmvdh7DxVH+KRjtoZEqqr4ICIDo4oJtIrHQ+NSYIDoYoyQOmMMpWcmQWk/PvYqsysyrBzEKNJyLKdT4Cg5x6pmCPg0D6ULwpT9VBI3VhYXH7onuik3+qbrLFc+JVhWRn1lbMya2PmZHmbLtxYmCxGgnQsfAQ1Bk8VbDvWsJvVW3GeVozbUf+zdVnhURnHK/KiAwRfpZRSEXqfM+h4rTLOK+gUQzoVq7T39jAiFaTVR+uWJ5PiRRlPVxIuZj47/hjRfZWHfB1XBpK319VPuZCyZXXsHS5V/zM9kb+zbe+vG7OXmUG1vqoyVfudbqrGg4ErO0DbV3AKcVJGfVXt+fo7dvxJz9y26G13dkjKImhYpa0nT1T8VhnH3e+ubuq4FXCDuRpb1/9oPadeGa31Y7MzO72V/VY2xAiqelw/Fseu7WNgRV9fTkgHrQom8BvnPOeesXCUha5zlAJBGWxcf2ubO+gKNLiswUdgexIPnzl+QsdY6DrHarDVjECK8FIdt3VVhgeusnc9W8OzlLCp5T/onvwf+uHcHcAzZAj04OOQwUDgy7dSQV/wpi0y6wnGYdfru3Y4EJzzLC5kQGZCuF3GOJkHD1r4dhuyrCjjZ7b6uHmAy9xfd911Z/f00FzzyW4QAm2ioTKbXvjCFx7m0AMpaQu4XMlzdjKLKdc6c+Bb6XyLIA+hhaeCSrxNjzp+/g1tAWlDMofOOz5vHDEj/9R9jzyHqPIlPfOGdl3eV7qLMqyvLNPZDKtyifXqtOC6t5O6NO+lLK3spk4HZJ/en9e51jKsukyu7Dt1fMVnJIQQ7CEATVAXnvb4Ams4d38xz/TP2cnIKdYt9tZlCSytGvMOlWJ0YUyUDcL4ZHSKNnHy/2mwEBwSAckYYqEoauxvdcs2yMa5/vrrz1JS2bvtk4hQUPsSHEyIrpF6y17lPKS6Gg/3q8Xf0aH6rQ9PdVC2MCPl2eo3CrAxDyghj9Tm9jWvRzkJdV7/SRmELQG+ak47qIy3mRE2M/w6vkphiDKU8OapjsqSfuuLGb5wQXwszAzuVVgxfEeG8qheZ2T7vZFi2DKGmeOy8r3qP9dm52hUdOhotUJrr1vRAsNVT+B45S9PFFTHD9a/0jCSTW4AVIo/jahsp5NRXd95bSQfugy2rv4Wns1xdriMeK7r09vs+ujo4vomjcEtczta89VY/HoCW+HQDfA4zo87o9lXtY4qnqoM28oA7eY+28o2VmhTtVXZIrO5q+RqBclXFZ6d4T0bT4Vfh0/SqKN3pRuqjJeZvTAqs6Ib8vtqGyP8RnzSQcWfIzhWVl1K8O02/gQ/7W7fGpc8CXBdNjoP8hT80YeX9LBlRA9i1K7KKODAG7VUV/c4t5V2aF9tvfKVrzyUJxCDzSz8OJ8V/cxWLdYSb+kicMRuBLahkZXkR1QoAMGLbQgS+dy7s0cmDIEw7QDQuMg28kPEoS3BG7bl5WG++D2cP+Xb7z3jiXZdDnlQBRoJH2xlHmBrvLKZ/YgR6iL78bMI+OFPaX50WDf12C3wxje+8XBffoV8OwWf8HvgG3f4q4wTD9pAE3ght0M5P/pWJgE7Q9S3+E27WAgqkR1GgJFEBPojYOdyOrdLeb/8Znul+EF9cRi9Zx+lPMvsf/dV8rxjt488+OU0cz+H/75lK32hXM+pgzwgWckKfnvQM3nRzwJLWQR/Mb+0nXrYx54PVq41nvIzklx/pu+XMi23/dEP2ZNaE5Qj6MMaISBE/x4I9aSatH3wIchu7Gh/yQNLM6Ozgiyr3xKWYnqEjQSFFpsCQLMtHZWy7Iw0FpWIL4FLeiTElCCqMnW8Pc504k0SlbHgzJ6pj6Toanwa8yiwVC38qlz2WeHPXPkBeZ4OywF9zvwjw9fpkQt9ZHDpgxD116EKfHtfPlmpjIjKaaho4jSr8Fs1/r28f/xQR8bCfn1w8/EmbquGZOKQY91qLG7tL5XnqFx+r3Cs+p+V7/p2Hq9kTIVnVaYz/nNNZH8Vj1Z95pru7nkf3hdleVKBcYVS4LXKs4zDSw0d/apySdPVLIRuDY0c7wq3Cg9BZexkWyPcVsawZc2OeLLiq47PVtv36zmelfnMa4lv4trJeQEH6aLD4Hn4pcJxZT3mb8fDv2f5Tj9U4+j4cYZTtf5HMriiZfU7IeV1rqtVOs7keVe2W5uV/uigWr9Vn1vt1a7vpNmx7c7aH/HRSJ4lLboyI3vtcoAHRVz+u2NdjRv71bcKyV/gkGzGJp+CgAprSA9iqE9gggwnyRgFIjjWQPeQOdKr6oOAdqWb2XnB297AR/4C/oz6UVvKNBYuOhOIh4/4CfmmOQWk0Onqk0AQYwVH1dO2ePWrh7dqjyCM6hHAwgH17CTapQ+B+wj4PNDEtyjyn4wj5sQzNgg+4diTeUFWGQ/bff59W48fKEzmFC808hcFMTbenscxFKKzwLeFQT/GOJI3OPGpaz2TDr5yecADPwKWPIQWPTlTKQPk7iv4PFQ2J3175hvZeqIPh4P7y7Cq7BnaSMggRK7FpBXzlbhWcrizoxkzY/Lsp5S93XYzD0hXmUOVruF+tz2PgJzXc9pU6+LU7MksSzlkUQbPqwAU7RDY5aig9DHhg6SbB8/om7FVdVZ18EUHliqDzDseGRoOIM0B1fovociewDe96U0XvKmMvmYGUpZLw4j0Us4jEZC5k21k20nkytimbwScBAlRWl7zqcAWTz22OCqJhzN2B46Xv6VBQodMIX6TUeU0HxmMaWCvjENKUlt19BpQnq6oX20pfNGLXnT4n1vGOgO/KpPzMjK8Vn/nNS1GMqxIKeXJAllhKH8UZnWY+eq8d/c6XI+BDp8Veq7gm05Ktda6NetlurZXYOQc5hobOVVbnMWuvy24VsDbWXhSypO9lYD8pYbOKezo1s17Gh4OW3gk28/2KgOo62ukA7LclrXphlHiParT4crHjcgRPYFuPWSZNFS6MqN1P6Il19i+on4IoPI0Vg9n8vzF0Rr3a938dHzb4ZfGZVd+xHuz+ZjZJV1bHZ9vgU42VzbAMXbaaKwVLiP+qcpVPOb3uszEGazSsuKZEczmenZttZ+u3uWEmbysnq5n4IG6Ag50lrzQR4EbzmWTj6EzT3mIKh2p+tqWprIcAeHBH7Kc/LxXxxWnV/XIJuDhrex+tc35OXpwrfZURt/9sGW2Qum+b6XT9l8PnPvWFAFBDfkVBML0cEmBBDKjyDiSrFS72PfqkwwoPh7ASD7E8SVQxZwQFMvMGgFzl+c6sZ0OmhEI8O1Z3PMgBWsV3LG3n/e85x3eCqcMbrWtoJ1A/uQLXvCCs0Pcdag3thE2OwEvxunzq09u6XI+BCfnZ+cNz7Ai0KXr4gmOYPFzdj1LjHl3/LwfgiYEBjyg5UkU7J4QLfx8sWqrmreb91PXJT2cV7iXvFrZel4uM8Kgia91Dx553z4n1Zg8oJJ0TL1AWW/LA9nJKwRG/Uy1t8Wh5Ekj/14Fs/Iec6ZrmkMPPLOefJug8yLt+fjdRvStrfAfcYLM1jvXwFISomMwnzCfhASfSJUToST4SUUV5OvqtxhFyShJaAzWUXSua9dpUPXJdy1oBZA0MZ5Oy1sL8sykFYP+WPDUVRatKyx9CLR5UGeGg9N1BQjq6S1wmmvteebtdKLVi1/84gsCijM8OjpVBnd3f2RcpVBwBYcRgWLkiboLRQWY/JwlAneZ5VUJZse1wrFak6vG5ArNRmWPdUpWHAvKdOMeQUXTrg1XZCkfKpw7Z7HCYYZ3tearNrrx6LfWkdaMxiDe4k2RCszydPFqgKTbyAFcdZCOcYgqB9mvb2mz4oNcgx2fVLojy63y/kguVGuo0zEVf6/SZetcjPRm4qKPbAP4XHqUN5yIzznnr2p3hQ5V/5XM69b/6P5sjrv6Kzh0BnU1PsdrJOMrmdTRdlTfx5h9r+jdTibmtZFumtmdI5qM+l+d00reZV9bdWul4zt8qkyfyq64GiBplXrOf/vZNVUgBDtXH96ypQeAbKeV7UUmh8rjtCkApDbILMK+8/NR0bmqo3v68OYkt6sFnP/DGys9+54PgS0CUeDkZwxhp7O9BTzwW8BP/+U3UYdXzivI5FlJ2K6eVQW4HKGcO8YcmeFb5nxsvlXZty76+S6+NS7PXPJ7PPQms4hzZHDWNa+aR7aV6XiSZzzjGScf8AEfcPAppCc03zoLS4El+WJ6mP1Lv/RLZ2/f8y1aGaDM7UwjO4zv/Oe605IsNAKUmh8ytTzLxM8Apr+UWfCZbx2FXzOjys/w8u1vvna8n5SJPMRxnnAc/KEOwLg9OOM0TjnE0TAeVKKOj91l2sjeclng/5O/K1vIxwgfc6i+B7+8bzIFedv7W94e9PHtdomT0wkeg87dePhNvCTPas5jaZIXAV9nBJMItvuxOE4np+W5BpbUsb/2EeEkYnrklYnSwLV4MtLqkMylNv3ViOypPRYq44brHuX18tVEOIyMyuyXLBze5KbrSk/VNdIxV5X7sUaALyie/HL4KWNnjkR7PdXwgNNsjFvxQClq/K94xSvO3sihe7q2cnD4CKfOOK+MsdH4unFSjpRcAU9bBBgKpDKDg8rzxEBKcWRgrhiOHT26cYzGNCs7cgBGxv/MWcs+qnqj/kdOT2VUz9runJ+Kh0a4VQ7ACn6VM5J4uWLXutWTT61b+I3DPSuFfzU4C90cjHi2MuRmPJxziQys2k28q3szfpqVT/xHOFdGT1c/7+f1Sibkeuuuj8bQrZEZXbwv7s9oq7LSS7winLRxty9GPNa1X9E6cXN8R314vQqfah5n9E28Ruuk080rsrvigwqfikY5Nr+ftlUFqatzrFt01Ur5mR6aZS+N1kb2Q/lKph87hu7eytiPtSEvJeS5Hdjl3RpJGYmzx4t39J+X/tAeGT2SH9KV9Ovn7fBCHtmfbBmSfcfb2/Sds5BoW7JIdh105VxDtcuboFWHa8qWYtsKNi4PJmUbItfon61T8hnIPnKHnkCZfqscL+VRO7TP+Ak8YCvwZjv8LF+vvoargABv5SR4h03vgQFvj3Om8EGYO94QR13OmBJwgDpb3dy+JjCo/6KBxiQ/4sd//McPwaMP/dAPPTys1llYP/ETP3F4WK0H+fotewlfE75J3koa+Hg82OUBR3wmrhEAhfc45gW9hc+c51l1usnf/AbfeyDPM3l9nWMLCof061LOe1aMB1Dy7WW+PhNv2vJxJB/5+CifgfCRbe7td1lIiSO84/h6AIZ7PmbOFGN7px9mzTpUWbIFkSXXvn3e+Q74GpnJuOp38hpj9gPoM2utsgVyfXNsi9MPmrL7hl0Ro3jOUYElXmeN4JbARXjqmpxlkJRw1iJeCQr5wD2S7fuJq/8rUBm3EJ7Xd3KQte9J5ayfbnJmuDDJGgcBFH9zGgw8okX33XGYGTeJL46nspJgGhhceClTyAVT52Ss9p1lXTAgwERvtiNmFk+Oo6LVjD9yDJ3RvEJT7omHxDdeB3ry9o6MAiOwdF/rY9VoXjVkOzqdF4zo2uEwoms3n5XjNnLCqrJ5DYFL0M8VM08WunEl/646CSsOQGfIJO5V2/4kkUCty6sr6UTM5q0r65DGwVb54+va+6r6cTxSJsxglSdG8zlq03/ntuk04HKMHT6d81zhWOGSdSpadXRhHF25lKkOPBSp7nXraoRXXq/Kr5Sb1e3kXyUfs63KDuj4Y6TbOjpQpuOJER27MSZfdrqi08vdvcow7mjVQUfnblwdrJbr5p02Kn2T91I2dfiM+H40hktlM6wCgRK3R93J9XKZ7Q2oDludFIhh25E+OvxavgpZLASzVEfBHuxi7STAFkbH6r/qUUa23T3ucY9DcEA6V36P6siXUNu6xoctYxy2+5CHPOQQAFFwg1d5+xlI4MtB47ovW5GAi5/lw8uD9J0zdOSjcRYUslJ9Ya+ydV7jwwnO7AufjyrQR3nPePLtN7mdh8CKBwAIdngiAhnW0BGZxDESaotMEI4xcf9KwSUOHVYg6bWvfe0ZL3CeLX5djiX1q6DaUpVj9TF69pO/scvXLod0s7NB9fxcHc+soX3a8SAUc+Rr3t8q57tTCAox936OVCU/oYP74mS45Nw6XTq7w6/79rpKX1VBKt+G5UGa/J398rvTrdDWA3vQ1b8TfBZfEpeA96CzZ4MR3L7WtnHmWsrgkmdIpe2e8t9tJ58TynjQtPItaMMP9WZcjAe/lTG4TFxN+lgOLCH0OBNHQozoMlt8WCiVITMCJ15uTdliNIzAJwdlowg/UUmEjvCXsvDXM44MnxxDMi8L2QM2CLUtuHeG2cxQyvLCh3MpFORAiUgw45xW7c8CYSNDuzKER0blCH+HmYOQ30fG6xZwwe9ChSdYgKfTMv+kw+ZWv86RGDkEIzocCyOHpsKjul/NUzcXadRUeKw4h9Vc8h1jTcYX0XeeTvIEszNWK0Gf7Vcwc6YqOnXlKsMulWbierHy8mIg5+JYXTBrd1RWkE9guzkdOX8j3Kr+V3h1FbJu9z1xnuHY8Uiu6ZkeTx7Mdjp8EueZLOkM1YSOJiM9UfXZte3j8u/d+FbkdkXzSleNxpO4ZT+dnhvpv5yPTl/P+KOiiTss1f2qjVG5jm9n8nfW9winlTU901PdPHPf/1d1q/5GUPHHFvvrUgIOcJ4BklkhnmWQPMRxBLLlZb9T/6UvfenZG97ksyibhUOUleEiu1d2gB5weiaJ6qdjyLma/jY3yoAfARd2dZAxIntbuOGw4hsQ6FHAhD7JnBK+8lXYGcIDcIIy0InAgsah7V/YOJzBeNe73vVsXVAOB9nXKTZrBjnSL3MnOd885dk6/PZtc+x+Acjih3b4YwIcXt8SiPPOuDlTUvN3ww03nM2nH1bttpPTzfnNtxGlLeVBIn47Hzrvej2+s/sG3BlPHl5frUXn+cxwSpw5nN3HBI4j+elzTfmkleOXAQ1wYd3kOq7kpZfxgNPIl+Qa68fLUC4fwDmf+Xy5T+v87eV9i6vkB1lnmk+VJfDCOUfgc1vb9kj7+UBNgP/ocgY6O8/lPCTeTtMsX/lcHlRy/tW4wJ3gNS8DyoPBzyWwhBBiISgSrgCFQAQnKCHkuO6O9Qw6hX9eSs8XjgS8nlTgZBJh5qBlgZSGhF1uKdlihAIplI8Zkwu1kUFYGXF5n7OUJHwRcN2B3ZUBUi3akRHV3a/w7aAa16pRf2yf9OP1WIyiF09WUHJ+iCOLEoUGfVe2KY0M1wwknDdsaTP5sOO9kXMw4uXu+gpt+K/1zNM8GZKeGq5rekrJa2lH/J2OS36vaJP3u3ZHNE9jpepnRIsrAbM55d5I5vv67ug9m4cRbSrezbZnTnR3v8LHZf9Kuaq/Cg9vYyYLZ7rB26uc0KzT8W6lB1brbbne6Rw3kLsxj3iz4yeupdE8w6Xrz/VJGoA5B6N2Kz04kr3uGHkbFX55P3mhm9sV+lbrO9vo+sv77vCsyNict0ped7AqWzue78a3uiVvVUcnT1Q23ZbxXApI+uvDi24cN+wo/Sdw4fRzRze3ZAk4xFigbBYyEXSfAER1mDF19Z0Hgn5Eh8qyDcYDB/6gnW1n6kffsRfxO3i4raCVrinLhuwclePgZw+qqJ7qsFVHOOncUvolE4p6TisFYdhG7PT3oFInTwTg4WUZq/uIbucydx5Y4nwhzktibv2YEA9U0A7zz3+2KJEBlr5MbltjLLl9zYMpzke5hapqJ6/7QcjuY7pPwPjoI4M1ntHlfJ4BCg9O+XlfDmxdBJ/qIG0H5wEP4GbfBHgYmwe6nK/8IGuna/JX2oB8El8PEuU4wCUz0PI+9HK8oKfzBuuN4IrzTm49dLxv/fZEHNVDhvg68ownl2vJh45bFbz0ICcATTLzzrc1Mg7f3klwl3nNxIhzDywpEAGzSfBBOJgfYQMTXew5H6tKfksb4Oyv30QQeSqbgHSwbI92Voz4yiDslHplAK6OsWtnVoc34XX3cyxpgKWh1BmqleFW4Tma70rwzGDmzFR4r7Sn8lLOLEqMEva9k2qN0kMo6LuCedW6SHolPhU/XUqDsDP2t8BWA7jqa8sYs05mKmmuOHQTBatgkweQqycXzif5lH0kp1Zwr5SSQ/XkKPGa4XEloVrzyUtpyHfOX37Pctn2bG4qOZf9zsbk/6v6x8i77nqOZ0aXrt3Ev5OLFd9119Mwzzpdvdl4R2VmdEpdkeNKvda1UenxxK+iTTXuCv+UKb4WOhw6GMnpbl5H5XOcoznt6Jn0HtkXK+Or/ntbifOo36rtvFbZMhWs8EyHo8MoqLQFZm1s5a1LBTg04OFbPAQpz/1tUY57ZjDBU5ktwHYWgjdef6ZzZC9zgDcPED0AQJ8Ex3w7kq6zDYq6HJ+gLCr5WGyxA2eyb7T9TuX8PBXvQ//1QF9tEqDiMGEyWNSO2pft6nYvuHlWS2cHMU4cZR8j9lHaS/oNDlzDTiYbwp3YxCn9B/1PXN2n8TIeZHB+Yp4ywO7lKvlcralcr86v/pY7D0xkoMT5z7e5ZWAggzz8drp7kIcgYxXU6uzsTn5lsEnfqwCPy3LnT2/T1zcxgwxmZPnkAdc1mbnIvQon54uULUmTzLpjLB6883PDdO3Wbw/gUZ8zqf2MJqdryh36dpz8jC0HP1g+A6EeTPO58nkk4Knf/tIuz8TkJVUE2c41sJQNVspopLgrBh7BqvGzApWhCcHYB8kbGbifkchuXKPrVTk3iFIggFfW7Qyglf4qOqwYi6O2O6NpZFBW9ar2OkOnM+5GY14Z7ww6Iet7mj2qqwXomTHUZ+vVMYe2rxrd5wmrxnRVNq9V10eGd3WfMjM65H1XMAS+PUIv8CdFuTe5Um45ng6vrXPmsoF+8mlEx9NXE4zkA787g7Urt+oAjeRUlqtwWCnr12aGSRpCW2FUrzKwVvVmJd8T/w6Xjh75veLnkUHrZb3ciP4dTfx33q/G37Xb0WPU7orsmvFCxV8VPvl9pCuqsjMcvM9V2T2rt6K/OxvE8c711UHXVuI3G/8MHK+uf33PJ9KXWo7PePpK6pFqXtI+cnxzm5bXw372DBTuVVkpOE5+0C7tVJkQAhwsAfU4ByjHhDPH9iQB5yVx7hKHbet8U2VPcz6Tn2mijGrZlBykC+5kxwvoQ+XIkOCspbvf/e4HXNSv3n6na5xHlDSudAp09POduM+DVfdnwIdjITwYQkBJoCCXgl2OR7cuM0Dncm603lJmwAsAuHVBRR4eV4GLxNm3WHGf4B/45rY5x0V09fOnwJ3MFugMX/k68O2V9OO+iSeB+Nidjp4VA47QnnHnWUs+X5455WuPOfGAUWbKeB2fw8w+4kMwyufAy1d6p7NxRr/Vr3g2s8Ach7Qp3vr22EFmrXmQ0enmdE3bn7n1sXv2X+JU8bDPj2csgVeuI5eTTkuVrRJuLiqwtGJkzJT7sXAxii8VkCZdTw0kgDOCyD1lMLDnd2R4bDHgfdL0EbPqjCcOeuZtASiVfMoyGlPVT4dHfp+NpVqcI6N0ZDRWzO7XV+d5S/mqzMj4B7dZfwh3nyMpbKVZ64mRni6hEAR6moQSXeGplXFVym1rvVUeXp3zVLrZTuLRGe+dUpjxuZclYKw1RRDZnxyRZel7o0eQRk+lpBy36qnrSj/ZTofH6vUrCal0/Rrfu7nO8pXMuFi8VtZUZbhW36t5HdVNQz5xWFnfFS07/Kp63Rirsp0h35XLeyNjbjSmhC1zX8mXzgCr+sggwFZ8O/6oeD7xzPtpQ3QysZKRnb1Q9VPhuiLTs73ORpzN3UzXVH2P+Gs21q7PqtwMZnYJBjrfK5xXaLqK58hWvFgb5DyArVusNUHltKHPBdVWG8q4I5T6ObfG0I/ue1+5Fcy/qxxvOfO3sXp79EmAgOCRfA6NVbYh59PqPCQFlOR35JlH4CnbUQdUK0CkumxXEbCtDBzYcgfeHIqtjCi1q37VBtv/cWoZt0MGAngY7weOc5A2jjGZSZw3Cn0JbKiuzkTSmPLMFqdzbtdK3u/szMo3zS1mzj++/c8DN45H+mF+reI/2gXc9vQ2HF8PclIWXoL+bLfUx7fWed++g8ITF3gplc+r13O6eiac083XlG9FZG1Wa7LKPkpa5fVZ9lG3lS95Jefd/2c2m8+Xb4UDH9Gew88JELnMcP671oJbvs0t5a7++4udKM+8EYxi7eC7sB3W28o58T6Sj/yQcL5nUNHHVb057twCS0640e+rGSCgny1E9B0nVNv8iOavjK0Tbl1ZfSRwldoqReGvEJWQVmBCQl9MPDJSVq53i3cEnRGWbXaGcDfuGd4zqAzfmUG10uZsHCuGogMHETJ/CAUCGFvodilgq4Mwq5d1U4iPDPbu90jGrDgcgNY3e/gx6BC+EtC8IZH9/W6Qbl13jgdCnqdzGH08jUrjMZ1G/1+VGzkXVwusOpAVVLSoHIZRP2lorOCxVU7O+HjLvao9N8pWcav4I9vuvlewRX9UzlziNgp/wzkAAQAASURBVMN1hlelf1bxnY0j9YFgtPW1k1sz3CuDuOJnby/vV/iMxlVB11c1pq39ZPlsP+e+GtcMRuVXdHblMOX9GV5ZpnJ4K5uso0FFu45GVXtVfzO4krrDt+m47swn5jykcxrx3Z2lSoZWfOjtugPpkHNN1rnsdM5VwvnmN/Y82dFql0AMh+Lqvux82R7yN3AuM0sKR5A3J8tOUYCIc4h0RqTKcOYTgSV2X3jATnjrgSfBH33nTCKnFeNOueeBAt5upiMGfPsWQTTmVPYP/UMP3t5GJgjZXmwv9K1GPv8jPyT1pwc8fC4zmOjZI/zu+uR6lUGePJNb0cjycFo63dnp4IEcth3BL54pxxi574ECxuPZXZ7hwppze8r5LbOaUt95FhPXPUhTzU01b6z1XOfeXmcfZBAr36ZWyd8MBjo+Lm/AiXUCPwv8jdK+W8UDcT63N709EJT45Vz5WDlvjZcN6Dv8o2Cs8yvBpmrszIdnY3LdMwQ9zuFvg6zmXOXOPWPpDyuk4GGylXoqIceTA/ZcV29KEFCX79m+Q6X8XWlKIEtBcN4TEVGYSUL/+uuvP3vy4HicBz1GMDL2u/opSGZG46yPGVTOxci48nqjsYyMuer7CNh3y8Fv1OkM7hzHqO8K10tlHK6OdwYdP1RjqvjFr3ftVw4YhpCCtTJoUA4cwpnrvXJ8RnzGd68n4av1rVccy/jj7SwyDnnzjGeuef2kVUWTjk8TlysJievMofTfXt6vdbK267+SE95OZ4iM2t66DkY8mzSq5t2vr85rjtN/uwG4gueI57J+9b0r6+1WMnBGi6qtDp9ufDN54n2PdEfydrWmZ7hW10cGejXGUVtV+Yr2W9uu5jHx7nhjxQ5YGUvXxlY7o8N/pU7Kuq7fFXxWZT5lLsa+ulhb7GKhyupNm8nnIzNLuOZtpKNY2RnpOKkMDiCOV6VDpLtvvPHGw8t/pOPJNOI+/WJnEACgfX1Xxo78Dx40dbzsY+boBfWHvyA/Qf95wxt0yzM8fRcEWUTCXf4Ob8HzfnO7TOLFm7PVv/wVfYQHmUtkJoGLP1TzI0hw2gkwERSrtqVhyznPcM3nPPmBtrrM02zL590DMbSdW9Aqe8T7IfADT3lAiXIe9PD6nk3lbdKuz1sVoBFd4WkFJQhAMg6CDl6HcXnWDf1SxwNJSQMCF57J5FlrPp4MSHmfPmeeWZS08zOGcm59PL6WKrnqWT1JC8ZB+2Tv+Fr3rZo3xW4j1jiH1XPfeZUAldaU4gNaG4oNKMtR8yh5wTrKDCvnV3+7JuUIFnrfjM9pTVvIqoQM1l6ywFLlFLhQn5UVrCJ6LKThw38EXQZvcpEl/pVxtgUXfUiNFSBgBTCeGEsM5ec+bTUAktad07BavpqvkcH3/7H3Zr3WPddZ7+smykEgBdtx+7edOAmOAxE9EQghBEJCggsEl3wGPgufhRvEHQik3ASUEEIa24kdN/+4TYBwkE465+jZen+vnjw8o6rm2mvv/ZpzhrS01pqzmlGjRo1ujqr5ngPjypVHo3XDZUeHFHYnBug0vqY0rkDyU8NjokHD5cTQ9T7usbYmAzsNWcp6vcRlNxdNUaXBnvXbPYErLILJnEnQ1rePK3Fuzvgkv1RWmVF6RTCHaHI2gta1lMS3v/3tN2+icRpPODVa7K7n09fnhmaU7uRnroUsP8mEExym/q46Vc5v7Qlz9p+4NHk24T4ZTCv5OOGaBtY0/hXNVjr7RN9MY971l/i1Ma1gWjMN15Qn2cdqvhvsZP9OR/r/Fa9Mc9n6TGiyeVqrK3wbnU7sgbbuJ1yzzhWcduW93gomfljRe8XLq/YF09a57OMU/1vLPgWkw4++5R5bQtKWwolyOeBP4xvN3LbgG6eLIIdnFQPUBw+2xEiX6+GRAjv65NvM2ELCwy1dU/BEgSV/mExAxYNCHhhz3HFSfezuqHr2luOPDaRv2SX6fOQjH3kIkk27M+iz6SLOcNL4OQSdDBpAZURftv6ROUXGB844GRoqowwu0WPi9QwE4W9OPif85Fkhvs3JadZsKF+LU7bSJAtS55IFQ5CPrW1kbTEmH6cAmvp5VtiyTgfezKdrHN6uaxzaTuDPx5Jjc97zdUX/kx0BtG1lTpuki89bC+QJPKjDGphsxRNfIa/ntjhoqv+aI51LJhqylZC+WOPUFW/D1+8Jm4LAqwewfO4or7FrbZJViEzjLY6+zpPvMphH+wS+G/2Tlk32ZibfkweWJoNwZ3hOZZ4SVgZiCuE0cLz8Sonvxki7CE5PZWPy/YT5KzRqxuEKr/zsDOBJwUzG52QYNxxXxlc6EFcMymyn9dEE0KqdXV+nBuSOH0/W0ClOJ+Wn9lfOTP5e9dvG2cpOfLJaW8158O80SCeDJfciU689KWlKDCUsA4kneZTlyQEHd/J2mMyO3I09DZsmJxjLS8IJ/03ycVduxWO7e2kYNRwmWe9lwGNVLnkUyCd+rUyukcbj7cnuNJaGV1uHrb2JzyZY0W3KmGplcxxT20m3le7Lttscrvqb8FrJ7MZ7Df/G540PvL9J/+bvxH/Cp9lEra2m51OOTTbWRNPk9dU4Vvq/tZ3tt/ut/dW6urV+K+vtJv1OxnkKV22DpwbG6IGgDChhE3udxuftddptuxNOOEENMmb0kQPJQdzI2LaNRvr7O9/5zkNdZSUTFCHohDOMM0hQR+BvbQMfXiJEAMqdeP/4lhb6IVAhe4MABTgzTl2jXXDSGa9kbftDNx+3H9bMHEBP2uGtV3Kedd0PG9ZvMprUlsauh+aCd9555+HeL/7iLz7QTqCHb6rD7hFfG84jfPtYc81lhsWJzcj43DH361mvPagEV+oTDGSbJH6fwDNMoB3fSX9vE35N2Sk6E1AiiEWGfGbJ+7fzN4EdH3fTkbmlruk6p7Vv0wNvz/LJzCTne89SzHbbddr0/zlPziMuZ/kmoCOafvKTn3xzRA5Zdaw/XVNGmL9l8j2vM5uSZ5E5nt3n64n22UZK0Fl9e8ZZ6lYfg8+ff0+2b/ufCULgl9mQz7YV7p5K8N7QDMGVITUZDyvjMMvkdU2W0kh1aB9tw1Ccw6PD/FRmZVi1sZ2AL0J/M4Xqk9Xh6bmuxDPFb2WYXsHx6nW/1wzuE9g5Aa2fZsjcaqRNRvSEW463wQqnFQ/t2jyFUwO68cyE85W+UzlQ3w3DVo83tcjI8cMPJdD1yQPXkyapRAEUP+nrlOXjT9oyLTjbn/pLwEiVAfc2wI5vmwyZjMFdP6uyTT48du223ytZ1nRKw7vRrBmvKa+yrUmOpCybYLUur8gFH/u0JWHCv42z4XHaZltLbXy3jrkZbqv2J3vkCh283KkMznWQOmgHO/l9RXfn9WlOmp3R1vPOntjpwt291TysaDm13fCaaHqrzHIc3jZoDo7LCX9DFk4P9fK8FZc106Hc+lZwQ0EMgR+QK+AMIX91Pfra517O3pe//OWHjJyPf/zjD2emysFUfX0UZBKQNSBQWX38hSF+GLb+q12A8SoIpDL6L9wIUqgPMoNweBkP+Mq+13ihK1ldwuPTn/70w39ttfGzJgVkWKSOIXAkHPwtczjE0Fq/ReNPfOITb7K1tYVQ+Hz2s5999ff//t9/mJ9/8S/+xauf/dmffZO1JVxli/lb45wvoAn/nXfAPbcaeV3XFR449PLJi86rbdtZ/qddD07gb+XDTf3WeKGtB+mclzX/Htggg0ZAMImyBBfwKT3AkDRJu4RPBpgS2uHefHMtM8lyneaWMcp4HQ+usd59DCv72B+w7uSD94ltroDnF77whYczkRVAZv6QSZy7RvZZ4vG91+vRg8VsFfV5yUPBOXSf7ap+flPbqtv4r9kWTqu0xZyWzU7zjNC7vhVup5TuofgSdsbCVUghOfW5MgzSMFq1430yWWIoPe0Q80hh4ATyRgcpJxRP7jtdGUfTNcCVhJhb+6y1ZQclJSb2oJbK+QGArgzvNR8TDVfCYmXEphPRFtSKTjtjceWkTPXbGCbjeqqzcqpO+74Cj13Lk8BvfTjtdw7LhGtrdzLSvU/xt9agUro5FwGel1EjxcIbTFrb3qZA64TX/HI4JkpKvzE6p6dAE+3amFO+sK5l4OrzNkCbv1zLJzK51d3109rc8VPDa+UQruSBz2eTw9nPhGOjl5c9wa21vaLFVG6lF1d6c1e3jcXbXH3nuL3PJje97ay7w9XLNUPyhF4rmPCb9FqjGd8rnZlt7eZwNa58KjuNZacPGp5N757Ix1W5aZ5OaLrCv61ptz1OZNv0f1r/01hPafTSkMEad2adL32LUGYv5JpNx9PnmYwBMmNUVg66v6lZdi4ZCASX0hkHd+lyHsjKlv7whz/80IbOdCSbCHuCw3hxEtlK4zYCWQ6MmYwm1SPTh0wnsiUEHO5M4IgteGQycfyGxkR/wkk4Qy/hzPEbzAVjBhi/ypANBY7qh8wrleNhue7JMf/MZz7zYGcpiCX667xJOes//dM//bAlT+fKyvcQkO1NEIW5zSyZ5BPwSh7ILVrOR/4/ZbqvO/+dbw7z686PvChGdOHsIQJMHITMGZwc4s19xgIt9FttiXb+Rj0yX+BlstBoW9c9GAFtkn7tIefKJm96o+kIvnP7XcqrDGJ60MvXgj+QTRybLPA59nIesJrGJrrJD9BbGTUPBKBZj8gTP0vqD+xti/BAow8BYA8QkpXEHPo2RNp33mU8Tisfe2bZOX18LTV9kQ+6fe7uFlhqhsnOIL4XXHE8TtuYDDg3tIDJQF8tuLyeBp+YRoJVgtT3NabQzP5WBtZkRKUA0EeKRkJewSWeMvAmMwSgBBgHBErR8rY6z1xaGaFX5mqaX79+aoi264/B70qbq/Kn66M5PRNOV+utoAmgW+vfuk5zDd06psnITgNBSlx8LmNQ/9mSqqd5BJo89bWtQ8dT31ojChyrLSkjyqodrSGeDDaF0Pgy8W8p2bQhvJViLoPtbYLVPF7RIVd44XSNTLhNc73CpfFZXk9d0OTECf+u8Gg6aDfevNdkwWrMjCe3B6xk9CTvvdxEl1bGy036fjXWaZw+VymjVrRs5dr4Jx5o+DU5O/WVY82+T2yIhvc0p9O1Cf9Vncfywk4HTeUn/uT/1G46Tt6uy/hTnTbNc9qaKxssMwYSp5cG56XMnvAyAPIlrzuoTBu3/nPmD066v4Jd+lr3sAVkn2emh/dPX7ILOINFtrOCNQQJCLiovuxo2QDY2R5AI+CgerLHPUuHbBd9cw6r+pLvQEaPvzWM4JRsd9Wnf8bKNinK6awllVFmhuyT3dtrwUntk9WdgTZwVR0FkhRUUh9f+cpXXv3yL//ym+ymv/bX/tpDn3oQpswPAizqX+WVpUMGuZ8/5fOfwca2/nzuUpZ7oIL/rsMIZvi851vRPCCaPAJvkdVCsEnjo23R0oMRtMGb9vzwb4KEnPNFAFP84AElAnu05dk+vqVpkiW51jyQ5uNLOcX/FkjiutfxjDFdJ0iTgSDa8P8ER/wtbfmGyMy+cfmQvJC8w5ySxSjgSAvetIifoLp+iL7AcZqyK9kmyn38AzIVBfAMGUtNf+e4WpA0bQqykDKQyDww17719u5b4VIZnSimyXA6gZ3hdktbq99X2znpwyc+09N8ok6cnckIvgX8laBSprx+XcJO/5XiqhRWtgdJyWoBvPvuuw+ZVakYrxp1p4bjymha9dMMwkmQXOWByWm6Yiyvxncrv0+4nPDWNKZsvzkjrc8ruO5wuhVWeLpRglGAwcYZSKS85j54n7d0XmlHxpTWCa8ZJmWWA/4mOjRozmCrL/z0xFTrl2Dx2wLNaFnxQFtbV9bFVL+10co9xhmcrq/WZPZ92m5re1d3ovGq7ClM48y5bddO+r56bWq36ZsJJr7d0abJ41Z3wqfxobc18eSOz9o4TmXtY2T01X5W62C1Vry+l1mt5YlvG90bPq2dlVPkjteE+2psWWayvx4jQ58DVvISfeq61e83XZjz7tvfOCBaziBON84T56MQwFE53hSd+jozOvRh67wynDPzmQ/nLwlwNv1AZrWn/qW/6Uf/yZLgmArogNMpW4Ptc9AD+0UPzYSX7HgPNGhLmjIuCE7ot7bF6bcOFycQRYAis3sEuubZ3Jzpk2cscU6MspIUVFIAi3Nmf/3Xf/1N4Ew+h9qTr6F2NGbhpfY1HpX3DDJ3iDMDaQpicM+/fV4FnnXkmXI469Tzc2gykEkZAh6MgfnX2KAVdT3jTLxCRgtzBk3Z+siY4VEegBK8JOOODBp/nXxuLcs142uM3xko4n/S3ddEyxrLNZoPbD3RYlrnHvB1nH3O2nykjAEfD/pQ3nF13PQbHoHm+NKUfV+c9ebJGKwLpyVvmqOu5I/a8wO84Y0m//XfD+H37C6fF18bXtbp5fxMNhxtr7ZG3hxYukVJ3WKY0n5ev5fzmQqe36dGdVPaXgcGdKZti283jrY/teE91c/220LzbzGyBL6YXBkPevLCPeEvp5U95Nn3Do9m6DV6TobSqv4peP3WRiqaneG+4+1dH4nX7lrreyq3chp25XfjmeZmByuje4XnKb2nPlc8IKUrnud8Ba1ZgkH+FHLVdvIlyo4ncK5AU4mvcE2YaEx7GoOMTRTc2wDTPK/m5Yosbkaj15/am2BaB1flQJO3+b8ZTFf68PsTpGxu/e1kyGPWX8PxRPeljpv0V+J3Wmdau4lfG/tUdjfuBtN8TDpy1ecJH67WzKTHGw9NPNHmYsJtpTdWuvNkPTddtbJZr9pTO1xpa3XvBPeJF1dldvxxars/B7Q5TYe0PU1vZ4DgPCd/EkxiS5icQd6yxKvCwQVnH4dKdWUD+BaxXCvuMJO1w1YngkH+AJkgj4DggTuoapsHWuh1gl1+3qN0vWx01VOGtDt+BG5kg5D5QpCBYIU+qi98eJkIRwIQrJD9QvAIn4b2/MBvAmAEy8g00sNp2lS2krYUKfgmvNQfWd0cCSJ8OKiYoBcZZMrIgR+gHfOmzxT4cF7wQESzSXxb76RLnB+9fOtfZcgo0vV8YMlcwPfp84mumksCF/TFNjrm0wOBohOHn3tgofGs02H1xkUP8NJWW7stSynp3PzaaQdMy2JMm87XZJMtDj4n2be34xloKYvE25zJ6nQmCzDbFXhAj/XjgUR9e/aZQP/ZXsoh7BxbQ4BpyuTz3U9N7ufv1NXc87c8ZtbeXTOWsuN7wlVD9/TeBJMxwfhcqbnQntoBSLfV0wK1IQeVNMXMWkr8c0zN2JsWWjPgJwOQQ+X0dAKlgZMtfPUUBKUjYC9pey2n49AgBcv0e2eE3YPnVvyRBlurexWHkzo7odlwPMXlyno4xTdx8d/THE+4TPzZ+rpap5VJhSje5wmd1iuHRsqg0se3rmXdNg7/v+LxaQ6bQzY5R7muZHzu1tJzQtJqcrQaHXZ8mMbILTopaXVL/YR0PijX1rgbpX7dy7V+VrRpNN/V2fW5m4cJ/5P6WcYN2VNIXJthu5JD01rZ6Qpvf6qzKzfpbS+34s/JOJzGs5ufSZ5PNkZrdzUf3sepLJjsoEaDE5jGsWuj0anZcE6rphdXOK3KtblrZ6Ws7MCpnZcCl1OpJzxLRMBTft965M5O8hnn0+ghKdvf2Lrl220cONcE54/DenH4khcBsp10DzvZ2yRghWNLQIs2aZfsJLKb1beyi/RQV2XUNltiyDTSweGcCSUAXzmi7C7I+Vd57T5Q2zpIW3gRzCFIRJaQ2vXX2/OyE3wGXVPwR/YTdojwIughHL797W+/ybzgATZBFvBVxpLrRQE7JtSW6OFznFuofN5TXjQZ4jzn5155/207VguCJO+mTCLzi2vQzbeotXmingeA/Nxbz2CBFswjkNs5W8adrzF+ezDEaZD0AVJP+Dy4Pvf2dv6Ot+11T2wOp6XLksxEav1Qh/ER3OV8NtYvB21z+La/IfH99jIA1rxnKkITyhFsZHcDa09rTWU54F1tcb6az1XO5aQPmGfGn5mzXscDVFf8ipszlq44AQ3hK/1MTkMzfB4LLByUCttYeGqRBm9T4qqjfctSaEQiVU7CvE3QRJfVuLl/CkkrjUfBI4D93Vok+uitdWI+ndei8WhxqDxnLCXeKVh9DN5/4r0a+0o5nM53Cq6V0eULMQXP5CCs6JxjvQKtHx/LPXn+Sjs+tmZc5+9G/5M5n/qY1oS3AaTRmONE0fA6VvG273vXf4yfHU1aP6lod/UafSYnKscDXXjqhbJ6CZhkW5u7ic9P+ljVS76b2ljNT1vDpzosy+ZcedsnuE74tD5PoLW1osWunQmXtn6zv9U8Yig1B3rCYWVo3lrP8c26Kxo0w/WkzVVbOUenc3AF79ant9f4ZGeoN3wavln2lC5e/3Rd79qeeBiDvI3RrzV7YOrzHjbD6tq97IWnAvSxO9F5P+nu9hCBG+lyf3MZ56Bw3APX/awZlyl+EK9nOFDGcXN8PRPB3y7rwSMCNP6qeHDAMdU9ZfXgOBLYIQuIM3voR/Y5mVgC30rk3wD4q00FfOTEKqjDW/J4kIZPoPI4w9DTs7943brqKDuJTC3RWtvadI2gk/wiHeSt7XCeeaT2ODeK/umXefD5YlzJAz4nnp3kPgv/PVDpZZy3/Lf31bYY0beXzW1uyeu+nc8/1PGAFLTy9luWUwZckyc8I2nFH80G9a2AWdf7zDZ826DfZ5wqNx2e3vrLdqbyK7+OOUhc+U+WmB+ozjZV5sWDhXnQ//tfB4rgbc+MzEAbc4u80NrRWiBAxUNjtqUKCEhmIKn5W5Necl5On4WxrPyRCR7lfTRFdaI4pzaaEZNt51OMq4bSChBkmkRF8snW4YmDJprXAE59qQ0imxzWpgATT0tcSEyGU16fjOEUqqcGJ7RDiMuB1oLRdSkZGPxrX/vag2LQAd8av5SQ6ngU8wo05rzKKwknRvmpQZWOzuRoNJwar96Kx9RPGt33XLOn7eZ406ifnLWT681BSN5f0dCFIcabK2IO1nPe5Zt7pGgjY3ZOWTqsVxyJdn9Xt61xFBNyytNpXwJyzqY142XdWcsx7xyuk3V6gmu7N+Hi/6f1Myn1VPyrvtNoXhkMu7HwncZUM/YauJG4k8UT37f+pvLJE9PYGw67e5NuzblMQ2yFR1vHk1GX459wXfFH/p/o1+yrE9294v9JZk28kfWne87vK7p4+Z2Mnsaz0yfeRvJCy2Q4sWWm31Mm+w6aPZhjbr/fFnCcWkBnonfjt8xsQud75gxn15AFQzDKMwmQkehR3wY3BR+YP9nKCqKormxlAlkEg7ArGId8BOxtDwThQKLbZZ9z7hOgnQW8XEffGptnVSX4evFxqB3hqSwj9QM99B/HmiwM5kX48Z+HczjiGr8CTQTD9M0RG2pT39oNQXCN7UPCX9njtKPrZH7pP7ZdHl7skAEl5x/3HeGRdp9+8qBif8Dh9bNP7juNfSsh+Pu8tCwi5+kce27TyoBM9u+/obf6ItPG15DTjnLgMOlBX4fQLm27XDP8TznM+J3+TtPEZyeLM6DVdD+/XRZw3jC8SD8kYLBOPXOI9fm91/LDMxQ9UOj8QNCIg+/Z2YT8wpcBd38bJGMhGwo6Of2cTvk2uQngN8rlmxbvFlg6NeYm42k1gOm/TzZReVLQeJ13M5xOIftSP2IgBZUkqOmb7CVNph/m1xykVBxsi5NARYAnU1A2F9dkWK2MpxX4ws9rwln01Z5oARlaWkB6DagYPFMsW/+r/5Ohuxtj3vPvFaRAazAp4MS3CcQ0gidH6YpBd8Vh2uF0pf0rsDJcTuomuEJ1h2Jynhqtuc/+fq05DuJEoGv9KVCar151HpkcmhzjyvnJ8qv5SIV7srZz/VBXa5TDQzXul4JmgHPdv5N+JzxL26fOYGtrJ1entpssaOtv1WYzolZ9tfGcOotNDjUcp34bjRKfFf9ONMnrE81O1o4b4XlvGuMVWOmqZve0MazabfhNbbV2V3PS2uP/iXF5Aqt+G37tnuM0jXeSjbeMxcuvtgFMdRPuQceVHPH7Pu7MmDoJ6t1D/z8V4IQh4ye7oNHEAwP+ITDEuUHY52znwknDCWQrCs5ZHl+RNggfAiDoXs658ewRztPxjGLOERI+OPm5ztnWpswf3kaFDcMZRZx/ipPr89zORsm3qKkd1VdwR/jrmuwlD4ixBc/HD830X77Cd7/73Td0cIeYwJna11g5C1L3hLPslm9961tvAnEC/D22L/q8gre/bcv5yAMv/E9HG7ycDsl/mS3bAjpNBnmQ0Odi5zvynfoRPqA9rmWGlMuFydaGv7MPD2R6u7n9zNeAy6DcXgUfOM08sJE86QG6JqumTKymC6FRtpn0a/RGDhFcYscRQR/nRR7ketDwj+08VdrkIG6yAHlDI7wmvkc25Nv78L0JxPo4fD747fhnllTaTM02hM76TXAXfE71x3FgaTLST+FWpcbkKjDDYWcIYIi+26oy9Z0LS20q2s7ZSBDS0wczfbYZbWI8CWUpAfBVffZmTocBU3/Cc2dgnxg4TgfhotRUKSwWEJlVLCR95IxrG5wvqGzv1Lia+CiFg49tV25Fl6y3w6kZL84nK2cm22tGyGPBx3Ri5J6M/er9Ww3piVdS+bb5aEI02xbvKjtQ/MyTQNasP7VMQ8Tx2hnmp2Pc1buVFxo9nI7KKtR6PX2y8BSQ62WCNIh2bXm9Fazur4JSp+2mLOD3LbjveKq1ceo8tnrNgb1VN7c1tJJ5qzV+Ik8T55WsS8NxZ794Wb/n42j0W7XZcDvVb422DW6VVyc63P83R8d/N7yz3hX8Wt2UE8lrjR+8n4ZjG0eTSxMtpv6a3fAYOLW5cj4es76fA3wbGDhOgRx0mjvAfj3rUl/gzpy/rt3L8NCYnQo4i74lzF/A4fhhfxBocQdR9QnQ+ENlPrJJCC7J+cxtM8JLOv2jH/3ow0NvlSOIpEAND9KEt/77mDxAAv6+vcWdSd9mx/ip43T1g7vl01CXoJYCROzWQHZ++ctffuNjKKuLOeOsJn9oL5yYA7bHabyeTQO921uyMnjgc+VvYfN1yjV8vaYPmkzIIBbX6d99SKc1uHhZv0ddAjHMoweNnIccvwwK5djgi9RtU1ZKo6fjm+P2LCjPQpyCYr4ePGOxBe2Sr+nPcUmbGN89dzmlTmMcfItXCX569qIHb33uvb33Gv6ejUhMgHUGz/ub/8AnkzjIcvJxZJYbmVWMh6wqn7eEtBczQM+ab1l8EzzZQRwrA3MFudAkYAjIcCo+rwSXEFYApxmZicvqOt9kO+TJ7ixoFMcKbxSBDv1VMEwf3tAgcKGe9a/gPpWZjK9sB9oi2HkDBGPXNSkrZ2Z/XWoaWjsjcDXGhF25NpapbjOG8/7U3+561r1qPE6OxmrOW5/Jx9MY0tBdjf2k76vQ5mZySFb1naf5aG1KHuhJGAc+ciaAyvo5Bw2f1v+JQd7ae4wxPzkNqVzTYAJ4qvK2wAn9XEGu6p+s1d162uGT7bT1kjIFJX4iX1bKfTJ4VrhOOLUx5Bh3dLiie1Ln3NLmap6aHZG/d7ov+2/0a2M50WNtTU4yJXHLeZ9k80pm5zy0/5NunGRNo980/pMx7+CqLnYc2xq7lc9X42xtn+jd076zvVt1blsnmeG0wv+5IJ3OtoZ83Tc5Tx0P6vh9xk1WEP8JNBHs8bdr8ZBVvgeZR7wN2fv1bH98Ev1XVpFvfePbx9xeE54HOeODKKNHPoWCS9CDM44UeFGwRh8O7M6H7bRHZtVE6/y0V8HjKEMn3VO/BBTYTUImGEkAqi96Cl8FyBi3rvMCFc8uIcOLN1H7/QyCZMDMHXCfL+Y6s3CYR9cjHpSDRhlEyeBI8q3zYPKzP+CEb/3cp+TtBNrxTB6XXbne6cNpxhxzP19Zn2st16vTgt/ej2eKJT6+rqEN8+h84GVTdvnc+DxDFw/sUSbrZICKteVvZGP7mnhe9/1tfs4v4PyemOPc7eRb4hw/5i1pwHXWhdPFA60efCQAzLZfp89kk3qWHu37YeOnuuLmwFIzOE6M4CugwXFInDMhCoSD7nbbsxqsjHtw9X2iML1PysrwUxBGTxmIerrQ8v5PjYZVuZ0x2/qEQT190QWUAk4wpO7xlGeF0y0G0A7/xDn7OTGgWx1v62QuXFh4nZWDMOGTxlIb745Wp+Wnsqf1VgZ7o0nDb7p3K78koAhktCArkBH6SLgSGPX09MQPnFZ4NmW6GmPDtRnKO5jWdSrUaQwvAZPMz+srvsl6u7azbjPyTvDcyRPvy8s3vsj2nVemMie4Nv7z6ytIxyLHc6t8aAG2K3I11+Jq/tIgm9rNsTWZ34zdvJ7teJlpjCs+X9074YeUxTnG1m7Df1fmVKbfKnNy7id7stHvsXLuqhxufU+yuY1p6vMeY2k8c9LuS+oK1rAgX/GdGSo729Dp7XQg64g+eKqfD2Hom6M2CC4pYIOD5m8zcwdO/fFQWs5inucIPtge1AE/wJ1bPwBcfSoTSIElHX6tzGzeNq22FKj50R/90Yc+v/nNb7559bzTid/Y+o4TeLgMd/o7r7sjLhCdhAtzie3F+D1gInwVdOOsVrbLeV/6z1lMstk4zDvxZz79rWmUm7b9TNkzntnj4HUcB+8/2/Mgj/N0BsV8PHw8QJY2quPE2LzflElOU6cH9xM8iOjjpQ9vB7x8zE2/+k6fyQ5qY4IG2abjATj/tPL89gyw1qe35wkt4kHxNzt4eHDt/rIHPb83nM3Kw21kQ2YbAdAsz5RqMsNlhdZL0q+dqYRMSUjbjx1ijMHPdrprYGll4DVoi/TEWPLfEIsB+lsVBETg76GUYQoXVPpwKJ5HHBPnZCSV135j/cbhneqvaHNlXCdlnZE9pQ8m1zUiolJmnp66MqR2kAbjSRsrI6k5Iie43WrATQLZaXJqpO7WwATNSH1uWBnIDa/m+DTHYaKrz/NOTkjg+9kF4mnxr554aSunAr0ESnPeVutvciJW85FtNgXAesunM/mkbaIpvzO1vdHzuaEpecd3Jwuma6n8gNXcreRqGmU7/XbS1mn9K2PJeyv6ruTmqt9Wd6ezc07SAN+Nx9uZxjrJDP43mjbDLvFpMmWi005OtHbad5NnK/lyQqcck/fT6LeTpTvZ0XA96eMKDU/1aet3t35O29vhd3p/pdtO25t4ZIfXhMdpe88BviZSL7f5TSdVv90PSHnMw13qCvKJPE6b98GDbXeM3ebEUaQ9Hr4SNGF7H8EPynlmFddUDjuAbAkeiIGTspZ+4zd+4yG4pLe4qR/5FoxNB2Lrm4Oz6asFXjxI4Ge3+Bpyp9lp44Ei2VeMk3H5WVYCHwNHgVCGOfCgi8ajQBnbhXCEfe5W8tX5ynkp7SQ/g6aV59O2D/JxPzHljgcfnOfI4nLezYyjxMd5l2sZzMrAGGMGF/rOTKS0yZK+lMEPbAeXOz8lb8MDueb9ugf8HL8ck/Nf0iHtSqevl/NssDz0ml1LCtyqPQ8kQ6fcCufnKjnO77MMIl9TTlu22sHr4A+PUJ8P7frahRbQE1wEJN4QTM+to/5mOZ9Lf5EB+PBQ/u6BpatG56ruBFObEBwh6EJmZ0ifgiZWkUkBCoUJ4s0GLiSbkegMxGF2vBFB31PEb2cc3wpTG+CnoJkHvvIwMdL/RBdPk2z4Nzrwe2cw+/VG1+xrBxMNd0blKS6TkZb/m8JZ9d/6SYdoau9Wvr835PrI60DSKA3ddOwmQDCiNDFexN8yspRC7sphorEbVw1HL5t1fYyAGwIYuFprehqHkCd1nSeMuwyMRmvB9HTrJWBFkxUP+P/H9JttTtD6vKLTmjGb67Xx1D2gGdM7uZr4rdr0azs8HgOJe7MxspyPua3L1RjavSaj8in91NZqXK1+k4utnUaXRqOd3NrVX+nmCYdJxqSunNaX02GiT4PJ5trZC1luwq39n/B4LOxo6X1NenD3n2vezorXXgrSTszAUeLnTnjqWC8jOwDHi6wl2bjKmMktHzxQpV3OWmIrDPilc+94s7WFA6h5yMWbnajv/boT5+1yzIdf483MX/jCFx6ykxRIUrBJdWXncCA2DqE7sinTWsaS94UD29Yp7foDZ2/bHV9oKfBsEfonGMcBxQToBLxy3W2iZpc7jhmoSLybjMxMFv47XzFG/aZsBoKmQE++gc7fPJhz0WyHtkZ8e6GPN9d5zo+vrczEmujqu1qcbnnWsJ+rBE4JzvsJ9OVZe0Bm6EA/9x2Sdnw329j5xenCg1/hwBE2BEJ9Tj3oSeA2t40Kco4cF4LZ+aIAD14RUALgP8+uzD48eORBNAGHcbN11dv1/lwmeXD3VPfdtBWuMe+9lFMqBxEgUwe550bmZMhdARFOwpyJ49A94aDrme0APlN/HqDJNELwbLS7h+HSIPviLVI6S4l7OOUwnn5LaWkP9MRYE747vphot2vvivG3Kz85CpOxujPmnCcnnFdG/gq/0zFfKd9477FreVqHq3lNSAHt1xsg/GWUkF3ob4HLtTc5d01Jtf5PnBj/zdsh9eGNk7qu/8JXBpSyqiaarejQ6P3SzsIK2ppMA7YZs0nTyYk6xSENkOxjgolvJhymNqcxt/qtz5N+kid241vpoqn93Ro94cudnrhSf5IdK3pnndO1dHWdTfpkpaem8WR7K5m04tnsizK+JppjMbU/reNp3be22vpPPJvz1RyxvNfocEL7U/3qNuoks5ojNNHhhD8mmPjjqWzMq5DbXnBwVnLLnaBmj7vz6vc5ksLtAewFd6R8CxsOJPTnDWXuvPEwS4EoruOcyWbmIGuCXTh0ZCbx0Iu3sRFkYTx807+ylmQ36E1wqq+6vl3HeUyf3GrntAFyixhzo2seWPCgEQ/O2TIE7oxNbRLEc36HvgTBoD9nvmIfyefgZSsrue9ywPFN/tA3bblP6QdMOz1y/XoAzseTgaHm52U2jR+ITl8ZLPI14ThMgQrvp53VlJlXyQM+psxEmtYfY5nokAGvzGDy8YNLzgV124Nh52/XV/mA1us3mer/CXCSWEFQSfecz5EjGUD8XtCcgLWfU0QAhxgD9cHBM9080Ib8St7jw/rzA9SbbcM4mD+nYcpCD3I9ScaSMxbfK4P4MQBxJViIYEOQJP49FKYTWcJQ/TqjtEOrp/78mjMZbZ0arafQjI6dIQQucmjffffdh9RaXoeohcU2ONHBX9Hexpx9TYLrCn5TuR29r9xbwSlu/r1qazIqd3WeEpoDcE+8TuZ44p2kVeMpV7oESXnK4K/vnMbRcDkd50725T2UCDiTAkvQWXKNAHY++fDxfj9A4yuHNFSAaZxtXq44ed5ukyVX5rHhNNVLfJuzewLNsKOdCb92fep3hc+OLif3nQaJV9JlRZNWN+nB/2mM07iaTm780WT5qr2V3G9jaf1PtFi10WCSKSc2zQlO2d7Uzun15Jsc7wqHhNUYT2TJRK8V/U5lRLbljlGO38vtbKyEK3LzuSBlAr+nrAYcH8/ubXMC4MD5Vjfal+51/evbxuiLc5jI3OdoCM9Q0Ee2szKRBQr6KNiiOjyQZjsKb6dljtWm/Bse2mIH+LYYfYMXh1l//vOff/BTFIgRsLXMM7OdHu5UJ42YA308EOCBAS8L6D5nK2nrGkEigiQewCOQwhjxtdjuJ5BNpPHonmw5fTzI57zh50e5fszsIMYETh4I8HWa59kwr5nA4DRI3qVN5w3f5uj4wpvUzYwcb1sfD1j6/CQNPODjtm9mCjneeQ5Urre2NS7X3aQfnB6073TyoJLTEfzbvCQ/pl7NjEaXlS3T0fskmcIP3s+sJoIt3q7T7b0WpCVrEfzIhuI67fv2SAJbrBvacpqlTcGYPTvQx+wyy7fYwVesSw8i0z+87Dg++VvhdkbhzlhclUfwSnhJWBPt91PRr6RnOb4rXFMQ+v0r40oBdNWYOYWrbaVBosARry3lCQiBJd7skPhP/d/beLm1rRMDcOpnVTcFXDqNU5utzCkPTY7YFViN/0p7V9fyVWh1UrE3HJAV+SaWK0a395X3rjpbrQ03cAGeUui61p+MxRz7RIfmWNzKH88Bq7mdvpvjsBtj3m/O2YRPQlvfV5zbqWzjj11bJ2VP1kpr3+mzkmleJ+XiTgau5Nj0v9H9dP5P+862c3yNl9r/5mQ0HbHq/x6yedI1jtfOKbi65hLXpENrw/FInJpsW9Gk0biNo8FqbFP/Db8c21T2xBa5ZRw7yPon6/ypoW0nyiftAv5nRoY7Uy7D/EwSfciIkV2LU5dOH0EmXgqk6549lFuk/MwTta3gkq4pIEL70ukKHBFkye1j2Nj6rcBKc+IdR5xIZfOoP46xwE5X1rNsefrwDAlwTkgae8DO6ep4M1f6aAwCBdZkv7gdJsAZdYfWaevnYEFjjSF9D/fNMlvG+Sgzeejb20lZ5fPqffg8N/vL6eXtJe2czi14MwW2vLz34edm5T0fp+PkwSfG41k0Ke99jJN8nWRVy75yyJdu+dpmPpjH3BLm9Gt0nv77bw+qeDvg4QfnEyDSvdwSl+2nzfrHdiA99zkTTUCGETuF/Ly3zFry4CPXBB7wok+Xic4n0A954/TzoJFvx0sd/SSBpanxeyon74OsJQ2SV3pKWHOYlO9/PoWVAeREXLW5M7odJwT8Yw2DK7AziJy+4McZS7uFebXfqdw9jKUVTAag35sMw1NcmwBe4dIU1FT+yvUV3o7nU8NkEK0M8Im2p86NK3j+N4V4aszndTem/HriuVK6pNTKECSd1Z+m8FST9poxMfFy0uqp19UpTPOchlmW3Y1hxQOtv5P6DSajaget36ZzTvvPa7uyKeNX7VOu0f8EvyyfMrfNSZa/ImcnPHe4rMY28VO2v+LJE9z994o27f+KBg2P/D05Dqu+qDNljzhMdEp82v2GU2t/ZdxOdD3Bu83dKR/u5OyOHxotdrJ8ki0nuJzqk+cEl7HuYKfsndZtu5fblgQ4jOhed8gIYKB78Tfgf5xLOWM4eTiMCvB86EMfeiijoJKCV94vB1IzFs+k1jUCLgpO+dvkfIw4nU4TdlXIJxKuCsZ85zvf+RMP1zwo4gGX/M/4JnuWb8/S0ofsDfUpGqgNPagWbtQjGYDdELSBg83b9ISD6uq+vglYrdaQZ5d54KTxlwcrnAa044EO3ypEmz4nniGSfJj9e2CkZdAj1/IwaT7+spccU9qJub59jDmfuU0t11yupbSDMuijex4A8bH7nFGOOXGa0n5mMnE/7aiGewaNUr57Wzkm+NQzleAtAk2ZzOKyy+fg/a8zgNiCyzrnTdVk3fkctK2DHlyiHX8gnXMIH4EDMsbXBwEseDh5zvm9ndl097fC7e6vDL8rCt/bZCIR9uwjRkitjLCGi/9noplAPxhrNeYVLd4GRd2MpdVYVgbfLQbuY3G9Ui/xmv57vfy9qzfhsOq3GdSt3oqOkxG9c0J27XqZE4P+FE7m4KS9dIh2jsOK33c8lsqq3d8Z8zteklzRtlN/uslTG7IyOaiy0anxedKm1XtJcDyb4UOZif4rulPXn3K1Miu8dnBFvqXsXPHDTiemUX+iO9v423q4Qqcdvm1dtfVwIqsoN/H5yRqlzqmdMsnRJr/b/aTDbrw7O2WlDyY821im35O+ymtNR073G76TTFzpkqls47cc00r+JS0aTafx7HRf67fZmPewFVfjuCrP3LF6aXCnk487q9CvbV8S4AC6U4de4ABeZfEQgMksD+iK7e+Ak09QRx9evIEDrZ0UCqiQbUzQyoNXtMODW+l/gXDzs1ZwtnmtuUO+2YqxC1RWfch+YCscdXzbVZMVfOP/6H+eacvvfHBHO8Jb/SqwJfpoLAoMsaXPMyE804xEAQJOsoHIePItOLn9y7OP3PEm68PH6YFKz2BLGZFZWlwH2tpz+yMDK95HC+75/+T97NffNpZBfq+f2UcTzoAfueBr0dsFhynY67yS63KlbyjbtsKBW+JM34mP3/N4wKRDpgCVZ0RlwBk50HZINb3yvtfygsOy/c2JuY6cRwSesUk8IjOW/L4HnJ0fUzb6nNMeWZo+d4w9de0VePRWuFOYDGju+SLjXi5yFEWWy34mw9HxQOBLyEsYkvqm9lEQ04KYDMyGB+VXhsG9YaJNllkZuVN7p3VOjaqV0XfVqDuF3UKZjNWmkE4W3arMSglM9SaeTjjBb0e3q3Q9ne+TtTApiEavySAQtLTVDEjktVRmE00mudZwlBCXkcsTRp6MYEi6ElvRE+X4tsNEm+a4pdPoCndai83RbP1cgatt7WRmwsrY2+ms/L1qn3ZzfTS9OhleEy6pXyYndVrjk34+oeWKFidz13TZZHg3fCZ+nWBFg1V5x7HhutPFE+6rtZfjmyDxOV0DK7vkxNZyWTzheYWvsv3VNdqeto2sbNKGX/vv7ZzYWtMcOm+eyM+XBHeywMffmuWvFec7tz0xVqcZdWXHk/2ic0QVAJLdz5lE0sFkFPj5RGSJ+Nk2ZBhwZMRHP/rRN2ccKagCTfWhTc5sAW/X7WQo4XgSTOItsdgC3i404IGUfnOWU56Fmmu96c0pc6OtM8bgZbgun0m2jcYjf0p0UVnP3lJZsiT8sHMFxMhyYgeKjwEHmbreHsEW5/cWqPBsjRbM5J7mHbp4oMUP+HaaZIZOy7hr9lrqzswq8nFn8KqtaaeX18+ApLcHZCZVk7f5pj9vwwN3Xt/bz21vyU9ZZxUUTRomeCZZyoOkJzShLbZmth0KqXM8EEVfBJPeb2dBI9PgLW/L6ZZ6gbmD7+EH8HU56Rlxjh/lwS/9HpJqkCPggezyOitdn/CePz4smRHM54Y0KFPg7ZQwZflosn7oh37o4RWdTAoRSaWzSthdObD7JcFp0AyNLNuY2K+taDnN/b1octXYmQz3p8DhhMdW5Zqx6/i/xLq6F5zw3pW2Jlg5FH5/13bSO6+3flZOYnM6Jhxd8DdF2cYw8aPjm7Iwn3o+F5CG67g0/BpMsjzrNifrsTLTr7e+s96E78m4Jv6aeOuk7dbHia5s7TlOE85X5vLWcbQ+T8Yy0XuClfzY4bRrf5IJK/1xbMBt5N6Kz3Ms05rajS3hSvnW56ktk3Xa/7aeU+5ONNrBRLMV7+3kDeVdV9zDtlnZNLqe2TrPBQoueDDAsy4mnN1xdN3rb1XK6wI5dgp6aDs6QScyY/Sfh9a0Lf+ALezufKsdBaneeeedhzr6yF/gbcpkOAlw1vQgiTOYCAipjK5TR+2oLwWp2M6WByvj6OlbtCM4w9EgjIcy+UY1fq8eHuxso0mmiy4aow7y1rjIyOaQdN9KpPvMgc6LItDnc97w8KCN358yOnxMfi0zh1I+t+1cKpOOe55zkzzZ6O50ZI7IavNx6tsDQ46zy7B8a5jPkeO70gXtQeUkJ33sHqxxXJweEw86HVL+rPT7Sh5mRlDrT9/QO7PHGIdnAUEf7Glvl/K+7e19r4M1bHdTeQLajJW1mgFMD+B5Zh5vpqQ95w+fXw8wIfuc/j5OAl2+rtob75LuGfy9S8bSiRH9FDA5FStnbMKZFFYpGDGCH8ylbykff3qRwu45YWUQJDS6nLTfyp8YNyfG+hU8XMCfQlN2J7isjMKpjWasTjw5zU/S9MThyv4d3yvQlO291vMpbVqZqw5lG9PJ+l+VmeRL3psUblPgE434vduO0Phlxce3rP+nghWvTsbsBE4Dv5ZztnJGTul0ssaSF063leR8Tv1OsnfqY+K7He7e72T4tbWZ+E7Q2kzw/lv70xgm52Pq70Qu7cawk0kneOV4T/XqqYzLNiaeW42l8eJUfmWbrOqscFrhk/Ro93f6JnHi3sk6XvV7Yiee2JNX19kJ7GyalwKn507HZeBJQHkCOe4g+WuzBbxRTQEc2f+y82X780p7zxBg6wt6OrMbPHDi21XAD1/Cz2OiLG+HE+g65zYp68gzl/VxpzCzKOSjCHenT8vyatC2uzE+p2sG7ADvy/0kBcUYHzTkbXruqIp20NkfgHlwpel45w8+vm2y8VbTMRmY9LF7X16fNrxM6i1vA/5wmvocOn0zO8cDNY479oafIeQ2yGRnTXIdnL1ujtvplxljXj4DdfB/jrfNj495ZcdQzvmz8Qf9EFjxOpnFlbTwvtmimu06kI2koCpt/8HrQKrzm2c4MW+OF9tCWRPggYygHmvL5z/nFjw88JlZceIhsqEIhhEU5+3aTuPMbHsrtsI57IzfVb0TQ3sFqiOloKcR+obAvv9ak+hnOTW8nwt2fe6MzZ3RdWLYTjRYGbs7Q/ieMBnxWQa8TtqZjOKpraYEuZ4GUxP2J7zcHLyG93R/GtstcOIUtXWeijrLTri28qlIJ0iDpBkgK3Cl7k8I3IjNse3miDI7o2WF55W6zw3pPDnPT04ZZYEdnzbj83Q9r+AKj6yc0WxnhWMaudn3JJNz3Td6TIbZbmwpn6Z2J1mZuLU+W98nsmVFlyZvV3OaxnBrb6XPJlq2Ma/wWY291Z/waLRd9dvWaRtPjnUqlzzT1mG7djrOacytzWl9Np15su5O6DDZSE6PW8Z6yqcTfs9pk51CWy++tSb5ivn0gE17ei/wp/bQh6APWQMf+9jHHra0EXCijL/JzPuTIybfgDexCVSPN5rRtv4r8OPnJpHVQFvgoLJkRjG/k7zXdx6y7UESaNS2COb8O985j3oWBX2tskCYK2irDCTP2MpglT5skZu2S3lZ6O/z6uPxcUzbitIe8Xu5HS3b9C1Hp7oEPLmW59h4cKE56/Th9zm3C770etk+OHimFf+hBzRnjI6X2wmJswcufV01Hsu1R5kMCOW8TPOU7eXc+zWno7fZssa8LmN12ZIBJ2hJ1qEC1Wxn/d7rwJ+XSR6gPfrh7FV9/ExpMpVSPzH/vjXOeRB54zzpATaArbrg4IeCO385/9w9sDQZoLfCpBxX0ATjrn4ykWcpNaaaGPxtU8wnuDw3zqc8kvN2K44rY3Bn5DXaNMV5wpPNMPX2rkAamitjsdVLyLHesu4apFG8wnOah9bmhNOVOWntphG7aiMFNW9/8UO3eRrHIZWutLyNnVzid/bpuK74mPon43pOSGOr8UcaGadrzf/n/ey/4bVaS6f0W/Fh8sAJ7qt+d2N2Gue69Pon+uCUhll2JQdbnSvy6JRWt/BRw2MlSyfZ1NZvm4sc0yQ3p/6ncezG3RyjJlemPlKv8t2cuMRtaiPHv5P7E06r+cr/K/5r95MWrV3HfScT2rWVXZt0Xo2zrd2J/94GwCHktzu2TpscvzuY/HdH3r/bdg6yAhQU4qm9O9JyFmlDD539zFWcMGUYsbOBoJHsAD+Im7MU6ROHjYOmOfhagS3PVHI+ygCF04NruR2J8nw82JT0z+Crr++kXQZZsryAN8W1OW4Ouuox9hYY4nqzEyb55Q6w07Nl50y61TNOoEMG7XxtOn+2QEv27W/bAnyukw8YUwZ8+M0a8Mw5wANUGehz/JyWjkcG3dLm8LXBfedJp6tfTz5P2vp2MKehj4v225a7lgHn6yD5PHmBDEPHw+mndaydT2QawcsCAtEql9vO/Jt+8Cfog4APZQkUCdoZ0CkPgZQb00Nx3oiHzFMZAltXMvNvyljaGR7TgnVo11fld/is/jehwUR6VN4jiIq6v3S20soQOKXTqv7JeFZlToynVT+TsTMZ2RP+U3+7MbZ+V0bjakyToXdiJLf1crJuWvkVX7iw3rXbDJDVGFaG+IRL/p6ckVPDutU9oWMqUK/rQlpnsSnLUUFpDE2B5IjSv/WUTgZiw/NkvSZfNcW+ooHT6BY5+lSQcz2trcZ3SZOmZ1p/bZ1M8mbCK+nZ6NsMlUmO7NbdBCueP+WvieY+robrRPuTPtq9iS47nm3rorU1zf0VG8bbnuT8bl5bXR/rbtzNZsn7k7xqOEz3cjw57tM11vCd1lP+PsF/1V8rv4Jb7LiV3Fj1k3Li1O66agPdcv9tAuxuH7tn5XANZ8nfhOTOKGP2c148K8OdWbYo8Xp7gZwoBZp0XXpeOt91Pfjwwh8Om/ZsG88iwBH0DKjcBqP2daar2gK3yWZsv8HJz1SatoVlcMn1V7bl9KRea8PnMGXaFFxpW5n032lEvQy0+Dy269AgAyuTvJ3sjsyo8Wt+vWUlQUMfr/fX7MMpUNeCop5N4rj7G8sS58TD2+N+rsGc91yDDZqMTxsqg8DOO8xHBmkcrzyYG9rTjgdVnOZ8ki+cJzxo5MFraO3ZgWQr8bBZMQM/C+n9r2UYD6IFBJn9TX+eoZTnvKXN6WdDUcfXOwkzwouxeKDL17TPDdd4mYCvJ5+7U51ytzOWmhHWDMJWrwnTe0EKPBFPjqAIrwO1eDJBxFD39PSADISXglOj5d5tT0bJZKisDJjJkNzhsXNebjEgV/Rqwm1VbtXf5Mjkvd387Yz7W+b/tM6OvqkorvR/ykM+1zve8flbtdX61Yf9/r432ukvOaEDKTn0UzKDQyn9acR3v/vd/+2py44e7b+fGeAKceLT5qi9LbDiOTdk25PM0zadDikj3PiYYDKUW732v9F+cgC8nF9Po7L1l87qii7TWkhcT2XC1F+OY6qXfNtk4a4NL9OuZT9tDpIujZey7Szb/jd6n9DWnZVGqwZN9q3Gu7vW2sy+Jhk80W+qN9GujS3r3VOurWyStqYnnti1ubOBpvq51lfr+AQmfK88hX4KSPt/ooHL6OmMlEbr5l+4U663memBkK8j3rgmX0BbXHQtA06qqwdNqo8N4GcGeZ9kRDnfqJzsCPXB29QcN8aRdPLtLL41yH/nNhanI06pb2dqGRwpLwlKEGTjfgsQtEBUjsmDB14PfKjndPNgIrhS3vHJjB6n60pXJA1adkyezQRejgtt5Pw4jzlNWqDDaef0pC3nIy+ftG20SNlLmTyIO+d44s/kL6fXiWz18i3jKe1dz9zKzBvaJLjo5Z0m3rdn+Hkb9E+QyO/Rtuoo0Kzgkg7wR05Qjrr+9jXqE9xOvvXtbwJ945/QTrMDuSe54us1+dnnwHHyDDrG61lw2d9dAkuTwbYzunftXVVqk2G5a8cZz19BKqdRygJFwl7nJoieGk6MD2BVrrWza3syBiej/9Sw2sFK0LRyu3neGYxebqq/wiPbbG2167cYb1OdEzrcCs0RyfsrZ2Oi/wn/OaSRODkfV+bRhTEfCU4Zj6SASgbIWGT9S8Dq6aTvPUbYenqrZAhyZIKJLv5bgl7tSFnRD1vtMCrzydKJbH5bIB0mru3Krq6f6COvs9NhkzN4Kt8mmebtpoLPsvk/aTXJnqzbaJB1p2y4xlMTTU/k8g5Oy+x0RJvfNv/NIN3Rc8K18clE79WYV7p34t+dzF3Jhqm/1TrI+hMuu37b+BLn1uYEt9o4jVYrPCeYdM1J3Vb/VGeu7J0mT07k4HPBCkdw8y0u6RRN27i8rdUWK3fknMcIwCibSP/BQd/f+MY3Hu79+I//+MMDJ5WRLcC5rLIXPAAhm0E6Xf958xvZSrxNLtfKbi2mc4uDmluHko+crlMGk9MM3DJDJjNs8r/Ph2edtCBQyssMnLS5bGVSfnidxKnJpnS8sccaj3kGj4/nRG62jCt/exc451Ypp1W2nYErcG80dR5w+mXGVeLetgA2OeV80DKbcj367qGGT2aKUQ/+acE+n6OkV/JyZuz5fLdApQe2sNX1kRxIOfO+CDqCL+ev+VxRj7H5Gs/17rxJPzz05m2LHkjLtTrRnmv+ZucT3XXXjKVUAH7tSjs72Bmwu7ZSmfBUQQpFTqQLS/9+bpiMgVvauVedUyPW72d7zSi8iuNVw6zh4vRtBmPDc2cYJu+dGMBTP8nnK+P7CtxqQK7GfI/587ng/3Rvh9Oqj/ZfAlhPHqUQeCsLwphzE1TWgzwCXectMqSdsjeZ/24MtfHyO8dLkOsDH/jAQ58qyzkMUlo608GVaI79ihPzlDCtQ3670m582fRKtrODZvBM7TRZ1cZxStdmzE797uTESvZOdb3cKR5eb5JhDR+/jvHk42/y9mSs7dpOBl+xPRqPnug1+kkjNvvf0TIN4Qn31fylvdAcmmabTTLoityY9Pskh27RJRNtpvFN93Ku3PFY2QDwc+Lf1uFqDV3ltVPa7dqdZN89bMx7gW8jm3g1Hb8sk4FxnzPG621z3zOTG4BXOnjS/7/1W7/1oPM/85nPvPr0pz/95o1ualuZzfStsmyR13X9lu2BfuftSwkt85nfOJGZHUK56UBmxt3eCJc0TxmRDrbLetqGxhlI8v7c1xId6Mu3L7rj68GFhp9nBE18stKhziu+hQq+dNnjh657X741a9JZmcnkPJl05du3JEFTt/+clhk8aHR1vtI1f2OdZylRzvFIevra8kwzl9ee/UT2VmY/eT3/9nsrHZWBx2mbm9OsZfNlEKrp5wZqT8kpqu+Zgu97HXBMPeP8Q7ueqeWBnlwz/p/gEWNT35IpWlPIG6eRz6vTh2wk/A8H+nRemHybmwNLTTE3RXDF+L/Sd4PJGNtBMv/q/krxXOn/ioE91b0H7Ay5hkMz4pIfvGwu5qa8su0dzqdjaHjvrjXjcjJkEoed0dfmOvs7Gc89efExcMUgTpgcotZGU9SNpivezPa4J4Pwwx/+8Js3Q7K1TcEbPU10wIgjnd3b4dWcCOcToTvJTH2kGPxtlW6UecDLx9yeVL00NAPrdG2srp/en3iilbs3vU7l+w6fJi/b/VXdlLsneOzmbAXe34TLNO7pf9oc0xiaYd7K+/r161Of0zhzzC6vslwGUFd6YzVnE72m+zkf+TvnatV3qz/RaKIH99rT8Owz7cm8135Pcn/iuRY0ujKWK2vav1c4+/V27ZRv0lnNNic58tyQ2SaCxh9tLeeWK3Tmztb06y0bAsgAFb95m9vXv/71h/qf+9znXr3zzjsPD6q//OUvv8l4dhx5ICUdL0dUsNsC5zRIXLjXsmko7/5Ns70mOeb/M+sl38rl9XOrkfO7BzPALwNIbsP4/1zT/mkZTWlX+bx7kIsHguCCPcfDPM9Wom5mNTm+vi2L8eaabwErp4HzgtM09VaTjdSD53wt5PrwjweofH49UzADfyu7wWnPljQPxDmtvB5lnaY+LrK6vA8fXwY6WzBy2tZHmw03n2fHT7yjh9PiI85l9pf4vPf1XPu2N/pgi9oU2PN59YCbB8X9OgeMq/88E26lp/O/Pv42OecJx/NJ3grXEL23gX4FnxNlvlLKK0jmv7XuifGxagdwYXMFv52xuruX97O9tiD8+mMMpVvuT3XAb2VYJc47HK/i0pTKbv5XBnL7f2I0rODW9bJq46S9nTGchkaWmdrwj7KCPFuJSL22wbENljb9zCUUC0LdX/npTyav0IePFIPS6oUTffsTEN4ugyHaxuntnj5ZeE5I2bXjbS9D/VWZxit5/zFyuOHfyrT2c/1NdRs9VvJiWv/pnLXyk0zebS1o8iSh8eROT01jz/ttzCtD92RNJu/4dxqvV/STG8itXhp/zV5YzVnea3w+8UjebzTwOjt9PfVxxeY4sdt2NMnrK7tlqrfCf6LfJD8muXFqP+zskAmnx9h6zwWZPZTr3/8nr6If/cl9yzbC+fI2MlDANX5Pa50yvLTj3Xffffj98Y9//NVHP/rRV5/85CcfXuTx27/922/ObmL7vHT4Bz/4wYetct/61rfeHByeW3NchvsWvDw42cfrY8nsFA/gUK+VycOK2zYg1w3Q1efNgwA+h96/X2t9pOzOIKkHW/xDeznfiRtbE8nw8PIcoOxn5TgurhOdZo3W0/rGhsz2kl9bllgCNqnTyXnUadpsQg/4Nf7zecbWTRvD7+da8n7TrqD8FKDMoJqPK7eBOs/4PLSAbJMvq/4E7FDw+eZsJf1ni6vP4e+/PmtNvz07z4Ggm89Dru/EEXr72yz9UPBcr239+rUMzru9k3WebCucT8jOEL9i1D8WJlxWOE7MtjMUgN04Tsd5hR7NyLoKO0PmFjhtrymPk/L3GuPp3HqZZqg3I2hqo+HWfrd+89qqram9vH4yV7syK3xOjPcmC6byXrYJ/dX/dBB0jbc4oJT1BBGhrqeIMhgR7lIOSnMnis+ZAyhVDvyXkdjeJHnCv+DElju1gxLzAzmzzcmZOOHLp4YTWXyFx9oanNZR8sjUzymOjd47fNv/xH26P7Xd2piM13ySezr27GM1zmk+8nprsxnek43Q5npFw2yjjWXlyEwyJoN10/inOV/JvB2ts/yq/YbTTra239lvzlGjqffdaOH4rcawWrNNF6/44CltmaRxo0Ea7Ff7S7m+06sTH+7k4UtB46PVthXuT8GL5mg2WeRtZh/+O3UrwAOlr3zlKw/nLilgpK1xyoZWkEkv85B9IKfSH2ApqMQ9cPFsF8czMwRynfgWGtpxvsytNW3NNMffy2bgh7L+4CvxFrSzcxotJ5pncC/nLutQFtvOx+mHGsvW0se3mBFsUhnNqew5ggUevPT5alkxmZGUa5BgFHg7f9J20h1ed3kCfZM/CTR4UMrp4/NNXaedz4VnEDWZwXzm+VA5hsaT9An96ccDwr5mXfd6ADTH1Wjn42zBE2iW7Thfc3g2ZYQDgUnOZ9Y3mUgAY+IcN+x774symeWWZyoxFrLqwJltd2QrtaBlBlwdWkCNAFfyz6nuuHx4t8NkNGS9K+Wnvk7az34mxdrq31vZrhT4ytjbGZFZ5hZoxs9j4da2dg6Ef2f7V4y1UwO34dHuNUN7N55TaDyQNLi6Ph7LMyscp/6SLm2unIarddH68L5W85g0aMYAe5RlHGpLHE8S9S0jgyeOvF4Y4SvjQ+V9m1qbs0l2prLMVymjiKWMXNAnDZ5iTd8TJuNxBckX6Sw0Y7+1v3MqJnzSQHBat3W+wjfHlXWnNhs9so1df6ewameSI43fcp6mJ14r3bvikYnGO1qmgbwqP9FhZQNN8r716/V3967gk21MY/Rrk46Z6NHKTb9X19pYpjXW5i/rXpF9TTac1k9cTsc7zfXK5st1MNEnx7Ubz622yb3BHaS2bWsF7cm+wLeIME6yLXKLUMvcSfnStu14eewE2QB6o7QyonWeksrzkEjX9K0HV5zH5C/6cH5yJx8ADw+Scc3rOO3cYW786mumBd9SrzkkXfJMp3wlvNsu7Ywn7BwPijidGy1yXeg3RxvQDm3yWngyv1We7G+3wXRP5TR/svsUAJSN1/gy6ej841lJZKVM2SJuxyTNU3dlJpbbgxkEmvSa32vyiLYycJs6g8CiZ0Z5Fr9n3OV4nO9Sx3kmmI83g8y+BjJg0mjqQUQPxCYfNz2kbw+k6ZtgEy/98nX4PdsKSzv6rTXvvOu4sEXO+89taLkdEN8FXpuywpJ+zFfSNOWL02CXrf+ojKWVkdNgp9y8zC0G8r3K3lvRrpTi7t5zKfxTI+xqWysDcQXNkWgKza+3RbDrY2UQTkZzEzqr/lZ1Jmekra0mkHdwupbuzWvTvLvicJzaPDTDuv3OticHyZUTIOEuI1CAQCZVVdlLbsigIGQQSujrqRZGCfuqM7qf41/95xpPOhDsbhjpns5twBBN3vff91zTt8LJemyG02TENj6d9FDrb5qTaY2s1trV9dfa2smCxHfSoUm7e4DTNcfg80WZU/mXbef4JxmR9Xbrqo1l1eaund34cqxZ74Re7frJfJ7qvDae1t9q7axoPum3ySbItid8dm3s2k9Y4bDiodX6vQKnc+/9+hP/rLfqZ/V0+TltzB3kVqp0zDzI4njn+DK7KfVhBpRSzrreTeB69ufbh3DucB61Hc5p7FtdwMttDHfo2HbjDvu0zchp0/Bt6zSd+WyDtr0/73O1dQlcgZYdk1lOvhXPaeDj8Hn0+fTx6sGgjjiQDUdQhMAe2UgE9DgPB9rLvvLD3PWAUddlJ5Jhwn3PMHIatkO8wTGDAYzJ1zb81La/+Tx40CptVV8bnhHE/7ZOpoBlsz18/ARBnMcpS4Bpsr18yyTrwufW+Z76vt1zkgnOX76W23lRKVfBo8nGDMAoAKlr2OVse2NnwR+9fhic/SVt2Mbm2Yv6+MNlX3uelUQ2JH0ljzgNm9zzOUvZK5ycnzOQ+yRvhcsJPamzU+T3UHQnRtAJjlfqPQWcGC7OICdG1WNgZRAnuBJoNGzKbtf3VLY5Gq2u82tzUibaTTza6jYeb8Z2w39yPla4rWg7zUvS69783eg5XaN/v9+ci4m+PtakYdbJPnj7myuLdvi2z6Pq8DrRNAyvOAyNZupXBowCVTzdcmUk5aWnZ/nkdEW7twUaHdq8TsaC31u1OZU9vZfQ+O5kvV3RazmPK2hrdreOd+2mI9Hqpgxr8qrVa9d34zuZ05VsS5wmWbTqO2WI39/R0std0U2ndJj69PZWY216ZUfzHMdpvV25qe5K3+3K7Npc8cLUfpO1V/qc5tnvNXxWfHjS/wQvadc2aHo95RI60stwf9peRdnsS9c8MybvpW3BvbalLB8CUS4dYM/MmvqkPw/OcI9MhawHeP/0mU5h4+8M2vHbHXwfB8Eff7sX40+bv/FvZtu0DAqnrd/3TI2cJznzyjLSGZUElXgoB93+5//8n/VsI17M4i9n4bqyzNQmwQMfS27v8syqaX15RlHjbZ+rps98njyw5gEep60HjNr2uWbvOl5+XfTx7YAZkPA3ATpdHM8cFzhC78nmcLo4Hzs9oSPlPZvQ22EeMnAGn3iAjbWQcoY2OSaDAKWfl/S9133nDgfwb9sMHW/Pfks605aAw8KT58An6ej/U0Z54Ata+JlSV/TupbfC5e9blNTOSLxq7E9t39rHY+tdhUbDEwMiF/5TwqSgV/1mmRR82e5E7xNn4wTvlQE+4e73V07JdK0Z5Cf10uCYeORe/d7bAF2t8el/UyiJ+8QLLVU6wWlJlhF1SUFVYEeKwvdJe70MPjXlnGM74RtwUuBKikJP16irgBOGTT41aX2taPBc0Ma9Wt8rHvFxTTy949UTeTr1P7WzkxsrvJrxtsOjtdUcqRXNV/cnOXGCw2n5XOuP4dk0jFY8cHq9ydupzIk8bvdPcJl4ozmHiXPjiVYn+97p3+Z0TL/9/zTXK36bZFuTBW2MbaxT3YQ0tk/q3AN243dcTnTzzm56TvtxBc3x87Hl2SO53qGXO4C5LYzyfg5M42fK5ba8pHU6m+6sZzaLt+9bswDqOC3YYuRbqHxrkffheLgz7OPxvnx8tJGZXNTzT5PrfHtbfIMvthWZHH7Pob3xC9rmoeI+D2pX2UUElVRGdhw2HG3qP9eguTvfvFXLnWmCSwpaabuTyntmudOhBdd8vMkvPufOA07jJteyjNfnf1sDzSfIbEHP9Mlgpc+n85T372tm5YM43jv56vg5v/o1n4f83bLzPLjoc6a5JRNpkgm0xY4FtQFPcJzGH75+cA0f+dsG4U/nabZgOk0I4jmPet/gwnY8aOiyaaUrPRCY/Oxz6bTm/90zlnZGZF7b1T8xlvPa1fLPCc3gO6mT8JKK/gRO8dvRI42JyaA+7Xsyclv/O4fmKi5TG+3/bgyTwTMpmFW/t66DU97d0UAw4bxTPq2PVua0TxQah+0pgEPARh+dj6C3ueTTl12fzXFq9dt43RDjzXIcPinI1xFPdJr6fJthMnqmdbNqZ7cupvbTuDmRL63e7ulfzvtqHidcV3RKWZHt+P9sLw3jK2Of8D1dJzt7YbqfT4yncjv9upqHZne0sbYxT+2s+M/naSf30qA+GUv26QZ4a9+h8VLrd+K9Fc2nPtt4p2tJ48bTbZ52/LizDU51eqs30aFBc5xulfPZx0vqC+/bnbd238EdX6cLshgHibbyXJ/MCmhZDALPRPF+W1AJPFwXZICKoBFteiZTy2DwYIgHKDK45N85Dn5TN7Nr2hpKunsmVaMP9XMd+rjAIbddMc6kI+Drmf842wSWOHSbQJY7xirPliFdJ8gF7ronkHOv3wpQEaSSjSibUHX8KALwkX1GUCCDAI5rBpecn/ifWSYpw1LPZZYa5XOOW5ac/3e8+O287DxH3TxXyYOCzq/JZ94X4891kvPu7XgGFFlm4OP85+vb6et8RDnwJ0iT89Por2sEljyARADyD14f1u3z7/R0ILDEWV7O/46HvzGOIKe+CYom7j6nToPMHHR+dpog3wi4XoGbtsL5xF9RSpORl4bWlfqn1+4JJ+N+SWX93HDFSHLFlYqGOv45MWBPjbwstyqfQrwZ/ytjckWHVteVbKPValwn/e+M9lvbdVyTNpOR0vpd0XPVjrd1uibZ1iahqSdSEpwK6Gi7GW8ByfG1/ideuEJT53E+BJMaDq2/RseXlj/OsxNObd22MidjuQcPT8bNhNOJ3GuyK+9N7Uzro+HU/k+0y/WyWnttrCs8ct1Pa3M3X7t5b33s8J7a8zZOZKW3nY5jk+snY5zqNZx2cnI3Bm93aqfJl5X+zTKrsbW+JjvuZP00nCYc89qJbvY2Jxm2u5bXk05NXiY+zmO7QPApXLFjnhIyWJJOs8Adpgys+EsvuAad2kHfDr6O6ccDUU23px3b2nKn2oNdTnN3mB1fxxnHNx1i73PCM+Vg45uUYR5wo20PeDQ96fVzPP6ddGbuJp3LGmXMnsUlh1rBAAWDZNNhN7G9Td8KDIEzWUtkfCggpQ/4KduEj64LVFbtMzafSw+aJV1b4M6vU8cDm8lH3lfOaZNhzj9ZN3mlBUm9HcfP+TbXXs6XX/MMp4ajX5/wdTw9e4aAouYKm1nfzDHj4r/zZq6NzN6hT89syrHStvwF4eAZhd+zbZjwKePOQ+1pi5f/ON+AhwdCNc4MMLHdrvFYzn172OK00TdrzGUxPPokgaUTQ+9e7QFXld7OIH1secHOaHts+99vcGo4upKDgSX4lWqqJwQCbftR5JZMkhR2U98rOjfjaWc8T4bxZIhl+YaLX2/GbsMncW6w47Em9CdD+RZIZbcrM5VrRuQk2Fe4ZButrhSCBLKCSeCWe/gTdoq69bkbQ/JDayNpN623xlNvC7jySmgGcf7OsiseOOGZZshMPLmTLVk357IZhm3+V+NY8dnEkw33hsNEI2/rih5rPHg6b2lYrXhg1Z4bRTt50eRytt3mM7PUGn7ezgk/TwbhiqZtHKu+Tvhq4uEJh1YvcTup32Bqs9Fh1dZObrZxNDqsZHyzI1bQbIwT+lyh14q33hY94Q5P2x6UW4dcXvC7yfZ8au9v6kp71GlNuzi1ZBrlel3pDB8XTqWXyXXhZwJlO3ngL7RwJ9Lp4q8qn7JkfKxezrOoHM9s1+V1jn/KPJt0fc5VZp254+78QCYSH9UBR982CG01j7L75G8QmGDbEePRR2cyCXQ0gjLZ/W1efu4MhxwDmREyZQuBk89l8l2+Icz53+mWB537b/57+5l95OAH0qc+zkOonb/Bza87L/m8Jg9kpiK0zTclC0RvMsp0TXOoN/jpt2x6zZuCNPADuwCgpcuL5D3PckraUtaDcZ61yAHcmX34ntcHbifv+7oi88nnl/JkZXkwyefU2xAOLm/SPnF5utJPThvO1mpn0N4lsDQZ51PZdv+KcbrCY9X3ibH8nLCi0duGKzAZTyflXQmtjFgx+Q/90A+9+uEf/uGHNznwZEGphHL2v/nNbz4IBYTMzploztJUZreYWnv+v/W1MvKbUvXreX8yDJ8TrvDjZCzsDLDdmK/InFO8m7I9rdvu7XBsfNDkItcfa+jv6P2SsKP1ju9P5jZ5bxU8OpW/bX3eMg8Tn6z6bs7stDbcoPAyjveJnFzhN8k1N764NtFh1d8kIydZvKLZ1O9VmTL1mddyHa/mu11f8f/JOKbrV/RO0+W7ttpcNznW5mTVnpfJOrfqp3atjTfXTn5Pa/ex8nsFbU23+9MY7qFf7g3uvOLYrbYwNvku8DqUa5k38Hhm3fCN85YHfOdhu65Xmr3XZEMGdCiLw5fZL228mdmUOs7bczoInBYZJPO2va7b3yvd4jj5WVbMTQaKBATrKJt4ZxtJA/kMZBb59i31T2YHW9VUljYUTNJvstRVhm1umgPdVx19dF3Bigx6+Vhza1HjQZ8feMrf/DXJbOjSgo7O+76Gmp2VWz0n26jxor+BLtdsk5melQfOUzaOBwp9PM579Mvb/RRUIiCoj+aRNtk6qo+Cjr69zWnjwUTHh7H7+s914XNNf2xH45D37xk/+tonk25qD/DzvqDF9PZp6KtynM+ah9Qz/kke5lz6Qe2NVnc/Y+m04clouaW/ZlRfweGxZU4gDY6r/d4Lj6uwo+dkDE/QDO3Wphbihz/84Vcf+MAH/sSZMvqv7UkKMElg7ByNneGbOJ3inu3tDMv2f2UcpbHndbzMrTx8Za0+BUx9NyNxxScO05y3dpyOk/Jufec8n4AL+sR1NweJ8wpWY3/JuX4MH/D7RH76vba2HJpxtXOwJhxyLU1youHXcGuyv5VPPHdrehrXJCezr7w/9ZHjm+q2stl3Gqareg0Pb2Oao4lXGj9M62mi/Yr3pn4Tr0mutb5X7UzydNI3eW1Hs1WdprdW4zrh08SnzdMpv5/Ykav/E882PFc4ZLtX7NndOpn6Szyv6LanhpZ9g0zRh4Nv23qZ1qM7gi2jievJu15Hvz2DgXKr4JcHYMDNnVk/t8TnLg/0bjzkGTvZTtqf0xr1zIcMcuXLTLw+fU1ZOfntgQD6b8GyzM7IDKl06jObBL/B55FtcbyKXY4+2984ywanW8ch+BvffK55+51+czyCz7HTM+c5aZ8ZOc7zjN3po3F55lBu1aK8812eeeT0XMmxCfye49b4m3ny4BX9e4DK11Pyu2f40KbTivY1fyqjeSMjSVllCqgQIGR+CSwpo0nl2KXg/WWGkc8H150ejrvLAj+c/o/DH4Cn86ylyb6BtzNbiG/PlvL1kGvfg2oEyxxnD1Z6fTL72GbnmUqnWUuXz1hawaTkb4XJUFy1ORmATw336vO5Ff/OADvBJQ2WyaD2a0SeYWyYWdfEzMpm+s53vnNkxK0gDdNm+OYYks8mwziNm2b4rfhx4u8V7SY82lh2NHkKWI0VgeZCzCP7K2N/1a7PRRPYEz1WToDXO5UpK8fnlOYnDk+2622/hOxLyPXqRsQEu7WQ19q8NP2QBpI/gZvqJLhxu1tXp/y6Gz/XJh7e0cf7mq6vYCUXr+inpkuurvOUyVdxX+E08czUx3TddUtrJ3Fp5Zp+OunX21+Va7re2z6lbRrO03gT71X/J303Hdd4sunfxm8TP+dcOK451hVdV+VOx9xg4qPss13b2XvPDTmPuc79uwU00ulN8HH7fKOXcJTcWcv5x2ZxpzAzUQB/SxOQwS3Xh9hFTU752PJ8Ew8ksFWPOh6IoF/K+Dax7NvpmEGCxJd+fR7c2U3nO4NGrfwkrzNjhPLyE/zAbmigNhRUIHtD38o6IhCl+npozcNrHG7w08dtBOgFLm5rtvGAIzQEJ+owDu+P8r7liDK0k2XaunE+84yoDNI1fcU4wJ/587mmfNKj8bnXd1xbOedlD35wT3PHIemac85Rgj6cUUQbapvACQeys12OYI0f8k4/DSeXP/CGj4NzlvQhKCggyOXr3enLfOL7UjYDSQRHfVwCl02sWz9s2/lLwPrP7YnOp7rOljqNy8d+6gc99PXqIuyU6K7eKWInjkSDnWH6GGjG4dRuc2JO+3hJuLX/nSGedCKFUItejCzgTQxaSL5f9LSvycicHI0sn4bMitcnxyjLJd82Pl6toVPePV2Hp3BLG60OwougoVKX3ShwxQ5MzlleS6W6c5DSUWjOD/9dIE9jm+Y8lfeKXlccnqzb8F0Zqs8JJ7pgKptrZdXeiV5xBSz+0xOufMJ4gutKB00819pqODcZke1PbbqR6Dw34bq73tZWG+uE02o+8wlblknZ28YyrY9c2w2P0zma7mXbkwyZ5H2br6TZxP87+TbJvBz/is+y7jS+VZkV/07ybTcvbjzv5GPToVOZHc3aeBofeFsn/LGD3dys9NsVm+mlIe0td5RaWYcMBgCrNeP9TEGfllHhjpU7d+jbrNO20Kzs0Gm8mSFAvQxsuQPrY9nZuStedTmRWTDAFCTLQNJk1/rcJS1znTke+vB2X17A4uU924JtbvTLG97IXvExA/m2P88ewhHPwGQCbxpznedzNdG+bQnzOed3zl/yhdPOeSPnPuVGyhCf12ZjUHYKiHHP377WAjrOD9TPLWEKdngd58k8w8wDR+pTgR8FGXVdNqDT2us5j2dmEGP19SA+kh8Dju+3LZ6MgQCX+hbv+Xw4zxMv8MCXH0De5iyDSNCLsi4b/OG+843vGmLcjttk6z06sLQyFm6tn3Bi0N4Cq3pXDK2r7TKBBFFan/zftfcScMXwnO5PDgALTEpBix2BwcLydMjTfhsdXYCm8Mz2VuNJI6XNX4OmVK/AVDcFfOvvlr4fg28zmPTR/GqLo7Y+SrgirDTnykpTSjKHI1KP9k5p24yhBs4HE7/kGBDUCF9/68Rk+DWl7/238it82xiTzsJRB+Hrc5Il9JSwkmmuGCnLtfaUdAUnvOrtYVCs6q4M/xNd4YZow7XNH/WmcU3rMvF03CajPunvhlP26eWnfh2/Ex0+ya7WfrbZ5q6VaXRZte/tTr+n/nYwrfHVPE28cGIfTY5cjimdi2xjcrqaTFrhOunaE72b9Fnhku1PeE16JdvajX/63tEs8ZnG3cBl5DS+1l/De9XPc4Hj4k/z9Y1T6Q5Uy1rKTCPq0i6yzbNwHCiXWTreXgs0Yd/nmUK+PQo+b+vL10CTWakLJ7mGw677HrRwZziDXE4fpxH2jusDb9P7bTjlti2vNwXCfBwpk7zt1FH+hjfO36F/PZhmCxvZH3qQSdaGAlJsgXN651lE4Or4QFu3WVJXJu81uedzlDR3nezzyfykDes84EGwlqU06TLHp+Hh/72ftg647gE0P7/M592zBR03bG54yc8NanxHOwR2yM4jgKhrnJ+lc33FA85DZL2prL9Jzmmg35TxB7ic8+RvGfzB1+cGOx30zZvsGINnInkgzvvMA+ldZnrQyPHzpBan75TlBN08W8rPrEpeuPtWuEkwT/dX1yeDamUktb6vGnuJ04mC3RlNDberBuDU766fxO8esKPJyvhJ483HCjNL0GtxK9igABMH7vnThtbHzmjzvhqtk2fSyJr4tLU/4eFKJNs5madb57Tx6K31G05O1xV/eDntcdYh7WSkEdmX4OVtCjpE0ZVlzl/iMK2/Znx5+V303fvlI4GrwJi2Zwp37e9WarV415VW4rDi3ZVc8P/Jt96u46iPAkoK3vlBlS8BJ3yXQUTBat5b+6t138Adgrw+tbubxwm/FZ+d6LzGx1dlR+LUylzhx6kfN5Z39F+Nvc3lRGe/3/ptqf+rftq4b7E9Tvhxd32lV3fXT2Vy4rGy4XZ0mOb+iu7OcTc6TPon1800jh2c2IAN95U9Msnuqa0T/FY6frdm/PttAT9LyZ/0+3YvxuUOWo4jtyMJvGyTBZllkdfBJev76+Fd/gn8TCgc3GmtTXPq/AI+LRtF4LZHvg3OnciJPvrvOtHPYHI9ltvb3On39nNucx7A08u6re/fzgOZHUVWh5x62ZY486oHzRVc8q1kKi+7jTdxOe6TjmC+M1BIPR8PtHGeyUBAbqWCT2jX6eh8kVlcfr9l2aT+a7akz0Gbc+crt5+mcfib3PzAe8bmmX9J6+RVz1RyvnP+cNrRLllRPgbKEFzk4HdeEIX8YUwuf9JmJPuJ87oITvFmtve/fpObrlHfg2l+gDcHzBNEZ/umj9k/+MW0TVvyoaEB/XlwLDPcCCLhb/uDc7/usgR87h5YWhk2p0bv1GYK0l2fV/B7irqnynnloKSh95i+HjP2e8OpY/Pf/tt/e/Wtb33rYYFrYQjYA/rd7373f3u94soJ8X58AblQy7IrZe/KY2VkT8bzlTWR+L+tsMOtGbmaTwUNeUWoBBPBJP2WIP2zf/bPPsy1skkyQu6/J8dlJZckUNUvgUv1kfvYU9H5b+GvpxvvvPPOQxu6pnYUWFIw7Ld/+7cfDBvHp+GYbZ/QLtNvc8xeR0pB+LGt9G1wHto6OHGOvO6uXYfJeGplJgOt1Wk4NzkwPdVNSLm0k28rOk14tjXTaLPSuRONJnwmuiXPNsNykueJ99R+cwa8/Rxzq5fjvNUmmHhuxbO7sbayU//5e1p77frU/omOmvpc0XFyMrKflfyY9P8EK1sscVrp99X427W2/q7M95Wszh2fvS3gDhf6FocLcDpldhBz3bYW8fEAiENmk6Tz5IGUJkvTmfctUm1N+b3El3nN4E9uRfG22vi5T718M5fXzywID0T5dcrjjCZd8rfjlFvKnAa+Vt2Rdz6HNrTr7WDfMSZlIOkaGds8qPbzpNgC5/RwfmsBy6RF4uTf/hYvD74k3rn+c302XgJXH3sLjOZ8tLeQ+e9ml/rcJG+l/eTzxHj9rDHnl0a7KfCr//ILedsavgFj9wwo5xvqEljJA6o5Z8m3qDl+vhZyneq/7OxPfepTD76L8FJwSjsvyIB73+sgEXj4WoSvCQxRh/ax3wlQ+SHa+C3Cn8PKeeOhAl26x8PulGUpj1TGt+z5XMLr0M9lrh9S/iSHdz/WCEs4aacZuo/td2f4PBZg7Cn75qT+rt5T4n8vSANJ9FDmx2/91m89ZIPoGk8fvvSlLz047V6e70kAeT9XDN8ruDcF4Hjl78TnSp8nY5gcmVsg6TbRcTLcV8axK1rqSqASJZdglDHgb3Robbf5m/rlaYeUhpQAryfVtjt9JIB9PI6rgwS3sq0U/NJvXj3LEwvVlVLJDLuVol45dl42jYpGa36jXFAOedjnS0Hy0b149WrZNh8NVnOTc9f+n8JkmDbnM3/v2mz4nYzZofFbo2UayKv67f/U5g6/03E0/K+MaVef6+4geBut3opP0unY1ZvKCnYBiBOemuZimtPk50aDbHuyJafxr3hlWq9Nb071pjJNt0+4TTg2/Ca+nObtxJ6Y+DN10EvDtD1N/zOzlPXlNMNpyyAR+lOQc5NvZcPBbJk67qD5uvK+HFfqOH65RchxSh5wXFvGAO25fs/tgtTJMj4mP9iZfn1LTXOwM1vBcc2AzJRZ5oGrtmagRQZkMrunBcU4wJlMeN9K6dvDvN3EdwoitgBfBgzI4kpaQmen30peutz2eW1lgNzamPPuQcMWmGpBn9ZnBqmglbfvD25b9lXyRK6z6Q1tOVbnT8cl9bEHVrnmax0+yayexnvaffGRj3zk4WG1+Ay7m+wn+Rbvfx0Q4lBxzvjyrYoEcPwtdbquoJGvcQI5vA1PoD7VLj6OH8oND086J2lMgMplqyAf8Of2xbsGltKQ3pW5CpMTkNCMwKttnJR77FhcAZymkJ3CzkB9adgZtNBEjvoXv/jFVx/72MceFogyQBRs8nOppnlohl3eXzlWK35eGfU73s8+3Xg4NQZXZSbebYp6JWBWfa/G2HCZQPc9JZP1oLkmBRS6eNrrNN4TGURfEsb6KCj0mc985kEYi9++/OUvv/rqV7/6gFf2kXPE2ygkxDkfiqcdKquAGGPZyZIJ3BicaDzhiKLyt6CgqF4apvEAOZduLE1rNQ2xqZ9VG6syWX53r+mfaf2dwCQn2vXkgxzPFXnX8Jhwm8a4GvtK9rUxNYO6yfuUt15uoluTz6txr/A84dVJd63waNeu2iMNv5y/lg1xajs5jm3ep3XZ8HS82jizjUkP7Wg2zfeJjFrhs7u+Kpc4rPhgZ/OsaP4Ye/apILNoMgCC8+d6DecpAyCN36mbmR20l9uznBfdIU965ivhcz3p49uk6Dvx9boeBPH/uTbcgU87gN8pHzNA5rRKfk9fJeWxBybcQfcx+u+m571dfrsdlPRuOEEj/Sag49t6ZA/BX7LZyFRJ3mjZccxbZiq1/gEFGGSHsS0JvOmbt2zlXPrYml5Jvmk0yowYp6evL8c/15vXbfI3cc1MpMQ/g61Ok6Qj+Dp9WI+cv+pjchq0zK48Y403yjl/e3AyXyDkPM9YxE86DuODH/zgg0/BfdVVYEnt/eqv/upDgImAUc63n4XWbBjueXmCUP4GOQ6gb7yYB8z7ucUpC12e0l9uQ57WwF0CS1eVUjNSdobLpCz9futj1//OYDkxeG+BXGS3BJfuYcDcw5jYzU3rt7XhADMr40Pb4gSZtdIMqlUfV8acC/pkTDuDbtX/CU4nPLpaUxN9rozzFE4cJ82lss8UgOENgCh6ge7zOlA/Z2nV38n80jcK8Sd+4iceFP+777776pvf/Ob/ZgimkkaQ8sYHbaFTOX+zRCrhhvvksPg1glfg7IeDnwI0Fd7+dONtgBV/uDG0gjTgTyHrpDJfOWrNCU3HJPE5kU8r/LKNbCtlkOPT2k1DNceU5bx8jnXCbRpXo0f+3zmFTf43HFu/adSd0nXFr47b1Gejsddb4ZHj9r4m+6fxcOu/8VnTCyd2GuUmXXiqZ1a08vsTbU/sud3YdnWmMnmvzcNOrrT1PNWb8NvRsPVzMq7nBs9AABqdkBupO1qmbjqcKQudJpl9Qn2+3dES+E6ExAvIIBmQbzHTp+HvmR+TPM7slUa/HLc7r45flmt0dNuJ7TTJf/kWOXf+25lVTlOfr5xnD6q5o81YdF82Gwcx41jLhuOA5ZXudPpOGUY+Z/AARxF86EMfevOgUf2BmzJZsHkzEOMBmszC8WupJ5P3k8cZp3Dwh7uZEeU6OA9Qn+jEOmA+MqhBQIQ6LXMt+dP74UGpbFnmzfulDcq3jDK1QVm2j1Ev8YHWuZacN0VH+THyVdS25lS4sZWO9v8f47U8y8vXXuIinmFMmi+2xQknzm+iH4JLbOuE75EheYi+0yVlGkFyAlh8PNvSzxB7kq1wTUnmACYj8ESB3aLkdn2srp0aQK3+ru7OAGuwM3BvwfMecIVOp4alK3T2mqaSau0142jC45RPJoO1GaKTkZt1J+O1zfFunlZ97RyBaRy3ggsnv9ba1nwqKPONb3zjQfAp0u8KLhXChDe4N8XZZA7lpAR+7Md+7OG3gpfCQ99uRLb+wEkCXeU5HJLgEsJfCqS99dFxnuiHAtUTEF6Zqy16Ulh66gEeU5uOPwEp0mNfMmOp8XpC8v2OL9MQbe2eyPmUySd64FSenZbzMa34vrW3klMnuu9UZ2XbE46tj7aeJ9zcyD/Ba3KaWx8uC1qdSa+s9MtKducc7GRzk22r66v2HJeVbprosCqfeqz1165P9Vc0afV2uno3pkk/8L+Nbzf2lYyfyu1g4gF3AFvbjT+n/63Pl4SUwwLPykgH2+t5WQ/yTHOmT3vDF+XSdnA7hTIe2HCnMB2uKaAEjrlFyzMLvC9B2lq0mWfHpF3W7CXfDuVtu5PuD8ySz3PrEf3qszrMewp2+Rpv68j9gZQHPETjYaU+np3hAQ4/o2bivRx/rjsv5/Oq/wQdZM/xxjnOfFIgIM+5msbkPM8YVw8/WzZdzl1mJCWv+Bx6meQvx9PnPwMZADzl85jrhfHBPxy87X1nVg30djo4vpRhZwE0dRw8GOl0Y0uZ8yt05m1yylrijYM8LJeP87u/+7sPn//1v/7Xm74IFoE/9POHv3kv6QKe7PDgWx/hwXlJBC49UNn4iDnOYGTOE3QTtPm9S2BpMnITVgZGK3tyf1XuRDG6osh+b1GsK0M1rxFRPDUwHoPXrXS+N0yGcbuf1yYeWzkJEw4r49u/J5yyrcmYbHzV+j35P/F7Go85jpWhe0/+aIpl6tMVm7agKViiw9rJ+vH0ZSlj3c9ASqP91Gczhojqf+ELX3j1+c9//qF/BYryYPj2G0Pld37ndx6EtgJAwp3Akq7rwxoHh4Zzo6G+FVDSGU5KpUVZSnF9/etff1BQnu664lEpGJWVcYMR9VLgNOT7RFdwbQo2tnXS6p9cmwznJn+aUeX38rr328ZwIsOaod36zn7ceFvV9X4eKxey3IT7lXZz/qb5zvV60m7q/yYDJrkwzcmu32w3xzfJ74kfs88Vj7b/iVuWbfpnmteT9QfeLXM7eTmvtbamNdfKOb2m9X7Kr6u5mnBNPCd7aCWLpvlo20BWuJ/YJ88J6Ti3TIJpG4ZncsBTvm2DbBoAfmi+gAd4nPa+rYS5dx72IJh/ZyCFueIefWb2go+34amP2y65RYh+fCyUBV+ntePo/eR5UzvIbWO+TsAzAyGOv/ftdE16+FxyhqZsSX8LFlvO8u180MkzU3byf9LXBCz0EZ/JfpMtp75lt/nZT9ACGvkRDIDPqd9b2b3T2vc541pbV96GzxtlvbzXz0z9XAPMQ153SB3mayHXKC/78bE4zVifBKAIDHmwxR+2qj3xDZlA7BCgTQ+y+vg9i4eMItnbBKMUXOLs2Pe9nmtwxg/xA7jBi2168DRBY/jU5Q2ZeMwTv30uGj/nGUk+n2qDQFnyavLUie360OarC7AyePz+aeeTEs77K2Poaj/Z36nxvGvvsTg+FdwyvlOA2SZ6pHCa8PPvVZmrMPFUOhV+vRm92VYq4ZXRuKL9yrCdnJkVLU6N4yv1WjsnuHifboRJuCqIlEZTPsmZcJvWbDOgeNPcr/zKrzz8V7aSlL4rqd38CTj0W20RWFLbbS91trky5nljHq8+hU56KvLhD3/4oV/SUicDA9pJoelpiSuml4ZGhxO+XmWwtfZXba6Mw2ne25y54ZUGbs7Hid5aOYB5f5KzE41aWys6TG3lmprG19Zs4r/CY8LL+2sGdzoAjW6TvEi53+R70jL7WtGrjanx24ovJ5x3Za/YJxPdpmur8XKtyfHUBdN4Tu61Pr1Oyp2G/0peNDwmfFZzvOOHxLVBG0vim7w80WIlL14KfE21gEbyU7PdpsyddlCz68zcZuXtC7L/Zv+lk91wO5EH2b8HQry+9804Hc/EPwO5GUAT5LaZnBsfV6O/l53ktAcDkl+TfpkNpPJksjguBAR0ny1xyiD3+cJBzweJrV8fTx6G3dYY/2UP6gVEAhx08JZtJxtPtpkH/BqveD+U82/Hyemb28q83dS30CP7arrWecznxnFxvm2613EF4EmCcxn0oB22MpJdJFvbzzIVbcEZvtJv6jH/4MKREwBBQM5wAjfa98CkPupbx3XoAbPKKDilNrWbQW3JR1D7/9frFwV5hhxBM7Xhu3OSJ8CZYB9BHw9uk4nFfPhZUeCan7bDJA/wZ/ysN5/LJufufnj3SgGv6rXrIN7aOB3EVVi1O+H6NsIJrk85lia4/N5Ufrr/nOCOd0sJPDXGTgxgh2n9ZBmvv3Ma2vVmiJ3Arfy/W+NZbvWd5U4cmgYEf772ta+92WefQZodzo4Pe/eljPxew3tHG4Q9SlM8KKWEYa23T0iJsSWuGQ3elurzpIxXtL4UrNbOCW9NxutU9qosOZFDXubE+Ut8roxzB2kIJv/vxjLJj50+T6fG72V7zahMOu9kqZd154B7fi2vr+TcbszTeKYxZxbENI4G6Xw1o++Kbkic2zh2czTRZrrvsJPPfGdGxWordZOrq/En7jvcnI8mvZPl2/fUb+LZyqVBn5D813BpdVr5tx18TnA6PXNI3y2LNWVAbrtKe24l45qscfo1px68vA/n9TxEt2VnpYyl7XyRCb/b2UhNNnndzNJJh9Lx9WwNfTyjKrOj9N+zzj2YB045bylXMmsr5SE0zbN/aEM2HQ/mvH2CC2SDyCYik8bpnDRIOiZNqUd5Zawow1w46IGp8AGEs64r8KCPn2XD+Bm7833qe+dlD4hmADad/+T5toacp50noHlmwDiuuS4mmZRtOS85r/r6V/CFl+ZwKDo2brN7RF9/MzN4sk1SbZA1xEHqvLEtAyusET+jiWwj7XhQGZ2lxYuBdE8vnRJuZEP94A/+4EPbPMhWe34Iua/5PFDeM6tYY4ynbS/k47ycAcDGCy4HwDHXsGeDnWQuPvqMpROFOgnzU0W86n9qd6qzMtZ2hulzww5f4NSAfWp4bD/TeJsAWRnofi/bQRHoW0KIqDKpkJNwXI1t4uMJz9ZeM2Kn+1dot1qHK/6a2royxzvHJGk9ZYlNuCVfrPCQMEdwp+yaZE4bbxqpra8J59U9cMBA40mHrvs+7Ea3BNFRgSjSbF8SGt4OzZjerZVW3/s65evp90oPnMrkST9O8o17zdhb1W3XT3Rc63OigTtKOzk4jStlQZuzVtb7d2O+GTdNFyRPZNu7uZx4s12b+KmNM9vKp82rNZHG/zQPyT8TX+90l5ffZREmr7b1vbo+8UfDs/HiqY5q8uWKrdnqrOpP4zjB9aRu6oWVXjyVYc8NrAV3ZICV3tN/d6b5ZICkyQMPsvh1nCp/Yj89pGlb5Agc5JY6x88DAT6uzGRxJ9Sve9lJVjZZoGseSPN2c5ua28s5Hq+Xsqg5stMYPGNDHwIv3HOaeV1oI5zk1CuTHLuej4AHgcKJjHAyihLvfPMVvOg0THpyPqYyzGV36UNAhPOWFHTimIPMkGM+oHMGmXLuWpadZ9gkrj4ep23ygtPbZUh7oOUZNsxbnjeGLUu5nGcCGM2WZiz4ZtjAmlP1I78teYF58mwxAidkufEWNcYEbyTvgxtjIMOJsStQpBcAKYj40Y9+9M3xHvCgn7/6e7/3e38iG4vDvdm5AU2czuyC4OwmAlyMSR+VoQ/OcBLwYBofAr5O2ZfrKmWfywC2FTKXGYC921a4STlNhpd/N+Gy6yvLrgyIFW6rfnbwHAp5Mqom2BlSJ4ZL9nsFmsI+qXParuPXwA3UFV+loNXCV7RZAl8LWmfkKDOE9MQJj904Gi6Jp9e9SruJBu3a5Nys1u89IA3bCb9Vfb6bYbIznFtbrsT5j4BEYLqAb/PU2jwd01TelbqnyEqQu2LI+if4XHmy8JSQtM97q2+gOQWr/ia9sao/rZfdNb838c2Ew2qN5HxPbbUxJb1a1lE6OKsxpcxY0Tfxn4xGx83/J/6N7ycaTP1k2218Pqak1Qome6fh0WRYwytxO9UTKz5otDgZ2zSWxK3p4qbHV2s8f0/rovFy07mrbSJtrKs5nOyCSS7n/4Z3Xp/68+s7SDk52R5vEziOvkUGZ7QFddKhzjH69jOuZeYFT+untecBkswCYv2SAeP13GH2c4fSBnF8PWDumSDQIfnD6bCyRaHvlMWVNG24+X3ffuNZSyv5lJkTlPXAkd9zWrWxEYBxe42sbg5XVj2yPXDU4RdtScsXBTkveWDCgyE+v/otZ1/ZKsosF6gftubpW30IFw4X50gDnwOnmfO/r4G0EwW5LZD7nCk26RrnSTJhWvtuG2QGldMpM/Ao43hnwMoDok0/gKc+ZPyQdURCAAEjDvkm+MT5Q75dTvXUBme4KkuJ7CPhQrBnWovwp76hl67LZ6Qftuh5cPAPX9vxjJc2PAuLg7cJNEF32uK8JqcXgSPGAA3B1d/G5zTOrDtv1/mBgBrjgKcygHn3jCVnhMYg92zvxOj9PwWujqXR/Baa3ErDlbG+6iOF6qSUTg371TUWER+2GOmwZFInJVh0/Tvf+c6IW+vjFrpNBsJkHK8MxWacT8p4Z4jsxnNlfZ8Ysyf0a0b4Sb+tDb/OQYukJpMaK4XDoY/uIJ1AU5IrOqBAJLylPHg1LcKewBLnN9Hmauze7ktDW9O36gmfw5M1t5KL05o5WXsnfa4c1Knc1N6qnYZ/G5t/Z1ttbiYnq62rW3lhcoxO5IHjPsnSLLOyFVbXTspnu1f4ZtKTK53YcEu5M7UFtOyznc72csnDK/mU8m/i/7YGd3RkbqcMNsc5jexJlzbbYTWeqf2GQ6NRo8GpXe3lE//dOr6HvX4vWMn23GblgWi/5of+ujPb5o+DdvXbD8J1G9Hpmjzmbfpa4tsze3BefQtWOmg+N76dLLfntLl25z0zpAhONBnFN789gJW2i9MytzJlAM7pk9lPufa9no8/HeDc+kcGEriBH1uklDmiM4304FiBHWUU6cUxBCgEOgsnz/LyYBn45mvtwZ9ghoIDbKfibCfnJ9VXAEL9tQyVxgP04eN2OnrQxj/toHrq5VinoBm84GsnbRHnUZ/vJrc8+Mi9PAw/14zbBOwk+fa3v/0QyJPvRjCPg7k9Wwq6UI+MNs2/PrLvFVxi/sQnZDF5pk/SH7nAWBiHglUul3ynwPdelyO4BA3kd2gsAn2LLwkSeaAIn4BAGkdcUJYx6qN+mX9fS76GMuNQ7RDkgpbOm85jGcR/0sDSFeNyV+fE0Ni1dVLnOcc6wc7gnMqunIerk34vSJpP9J8M2Z3Rn0Lv1Nhq/ZMayYFvnEMjwSIBoz2yGXiZ+pqM7sQheTrLr+43Y3Eqk7/zRH/uN4N7Gs8pNGO1/V6NdWqzXW+8lGNrRrdAglSHLEoxYZygXKQk9La4lrmWfSVk+dUa93scLs6TLQQ+96RYMiV6BW+Lw+Bzfsua9WvTen4Mz66cGfrf1fU2kscbz/u4djJ9xXOTHMgxpVE6yVjaTFl7lRbZ3oq+q3V05fqES5MHrfyV8U1zcOXeqf2ywy3X11R2J6tW89TGvtLFOeZJH+5k2QnfNhyz/krfrcZ0xTa78n/XRtKo6a8cI7+zrclOPMXrOcG3WaRTlNuFsp6XabKHzA53uFcPXggAZSAkt+A633l/fg37wh1f+p9kNf+z/3YQtWd+uNOYW9iyfWhGncxoddyp6317Foa3i8056bOW9aV7HgCDPomnX/PgkgcedV1OupxsBXP0oFjBJQWWZO/x9i6yQHKNQQ/6hZaJJ2XZ6saYuedZarLfPKOFLCrPKmnrfMq4o92sk7TyIFnKPV8/Ph8Cbz/nzuc6+Tfth5W9khlSSQPonFvoyAhTgEgPhjWnBGgIFPEGZfrxYBHfCuyQ4cTc5WHaTpfc2QBPcO5RjsHr/6EFuMBTPKG6nPmkscj38MAO9BHPkCXF2vDAD8EoxoKPSxu+HpNX4FXR0M+z8rYzOOzfdw8s7RTvqWJewamBlWVWDN3Ke7kT43XV7ilcqetlTw3H54SdkbIyRL3+NAfT+FpbiU9rh9RHMkN45b2ce55k5VMMN3KzrxSu/j0p2BzDjmfb/d28p3BscE/euWJE38L/zXHIMtlX8p7mVUoFheSCFaOArWiZ3rvqK/tcjcGVEN/iPQW0/EmUhLquSeG4opn6uSK/nhtyjZ9k0TXDadXG6t6KXv674ZBKtBn/jfeTb1dyLNs+0a+nZXOsDafm5CRM9JnGsRtr0r+Vybaa7ljxQsPrRLdMeK1wXo2l6bZTvbmi+05/tHlu7TRZuZK3bcy+DlZtrcY9yfVV3/z3a/ntkNt2pnlMmuzwP9F/K1jx6W7trdZbyqedHnkJwNbKa/m9s/Nph9+NL3Lu3XHyIBY62M+CacEUr+tZIPTjWQ9tfNT1cbWxeSaGIM+F8nFkdkJmKGL3MD4HL++0gh705Q8u2/a4tLvoU9czaJPj5iyglc5vZx8BZNKw5UmBCM450iff0gff5Ng9+OQZOvTv597wX2UJXOlb9wgaCAgmCDc/SzOBPjNY50EFtwud33y+28HaTc+3jLy23lZ85Xgnnjv56mvYeSiDY2wvY4scD4i5pnIKkLBFjqwfAlD0SaCPOqyF5NvkE4I8vo3M6yW9/zjWJwFF+iM4SiaS+5vQDRzZXdGy9eA78bevU8oxf9Tlm22arDlfa7kFD3xPdd3NGUsOK6P0RJHl9Z0B5m3t2lwtqPzfDMQdrs8BJ3g9tv2naLsZMqfGWTNuJwXdjO1pTES3CTKx3YiFoycRbJNDOfmhb20udvRbLcap7omBmdcbjU/mdpqXU76Y+tw5C6fy4oqh7eVdWSkzSWm0CHOUpJQSAUYpK99jnG36Wz0aDXY0ajiLv/R0TQaI8FDb4jue0EyGgdPixNF4CditRcF0P59Unsj81n/D52RLw8ohaPRu49i14WNM/HwNNZpdofO0DhOfJj8nuTzhcCLLWv1dH0nnE3viFpk24Z/1V+00/Fe6L9u9gmM6ACv56Pd3ZR2n1u9u7Kvf2XY6Ga3vVTuO0+7/hMPEo22+T2TslTqrMbVxZNnT7Y3e3tsE4NOyjzK47/dS5qDr/R5OXPJu6nB/IxK6HjvAcaDdtt2O//RLe749yst5MCbHmGOnvAeDHBenF+XyjCbnZd9W5e07jn4/t8i445pb6fJMFm83r3v7tOljdFnVdFLycgZXZFcpi0n2H7/9rKPko3SyHW8H3Sd4BO5sh8ujDph/2XfyL+R/EAxh+1TbxgYtyHSizaRX4gXOzrvMGbhlQNPnlvJ+DpnjxH3qwAOeieXzvtNptOXtJE95Fo0A3yyDfgKSB5gjrgk47gJa8tv5ofEstPKzr1JO6du3lb3XrjEflJd9L5zYqeDr2A9a93O70l50OpOVpSAVWVG+Hn2uwZ/2FJDSdQ4FZwxkBno7py8GOg4s7QyWe8OpYXGCx4mxe2UMO8PvtMwprIyfUzgxxHc4tOyCqzhcMf5TiLV2mtDLe/xG0PuWI2WMfPe7332TDvjJT37yTYSbfbTa46tyeWr+1FeDdm/lbKVhejJ3j+GNU5wTv1x7kzHdxrZa47txn4yHfjSverrBfuV8EoIwZlucUqnbGE7nPeuuHAOtKfEifabiz3abYlnh9xIwjd/x3c3xFUdu4rfV+sq+WlurNbdb72mYrsp4m7u+J3wSr6mNU3ym8ie6dOrzKs2cf1J+3KLLJvo2W2A1Fyu+zvpZ3ttsdsuKR3f8tMJhGsOK5lN7+ft0nWZ77Xs1F63+ROdG86luszVauys9Od07qdPqO2+l3eXlW0bKbh7eFj0hyG1vgPNBOztkys7JLWseAGpBIncAm33bHnD4ddpxm8LXVD7l57pnHzl/5RalXGdpc+Vv36qWtkJujXF6givXMsDjWTJOc6e9t5vZSyt97pkabR5Xus7pgbPsc0/7ylySDa96fnblxCvevgcrfTui7EqySOSMy36kHDYc5X27leopqKAjEORfECTJsRMg0YNuzSsHUGdgLHko5yZ/O396kMRp0rKNfD06jZLXV/I0A5Vcc9r6tiuXD36oP/zM9lXfkkhghaNPZN8zZ05n56kcn+PUeNeDvAS3ch18z/BM+UFQDDwdF886ctnlWZXiIQV5aNODT76GBRweT9BOQLCLABJvR/dDxPOcMV9Td89YmgyPVflmNKzaWSm+yUC6Cjv8V0bwydhPytzqQNwCj6l7C667ulcNscf0x38tEp2lJEEjYa1FomwROfW8ylL3JPAFqqMsF5VVPZUlZdFxTWPlFCf6mGAytK6M/THzPq1dx/8Uv+bIuJJzcGclHZdUgO1aa8v3RmNAsYcZI09KiCdbbQsa5abxT09XG05Oj2k7WPaTtHvbIQ2PvHaFt1dl0rg+0TFTm6f6zcfT2mrtuhPY1sDpvE60mNbCNCbHqc3Hbs1Pc7ia35UcbHJgNfYrOqmNZ2ojjfFG04nOTW41XK6Oq91rND7h252OWs1zyuNpbMlzV9eV4+R4+5qZxpYycxrrVGZnq+yyTbJO0vRUP09zutJ/t+iFl9YlvpXMD9dOneHlU36iR31OcnsWTmJm69B2ZngA6WB6n+3wau/D+cG3xjW522wiH3u+ZQ7AsfXtKx5UaXzqznPi5K+Lb/qK8fDJYAHlpmxcynpWCjaaZ4Q7X3A/x+BO+ZQ1pU9mkTjt/HB1yvhcZTYRZ+TQNtcEHLWgt88pkMXLWdgeB88QVJB/of4VDHEask1JoHL+kpdpPeQ85ZhyPvOAcPjG5RvjT/2UmYGOu8+X88QUnEheShnKPc9Gcx5PnoDGmgfOWBP9CP54uz7HmZ0j4IB/35rInKis2s318z4rB07+Bj6SGlRPAR34gfXgvJmZlO57wh8EzWiLbXO04S8R4Br46Bp82vpwvppkyaMCS82YaYLQYWX4nRiEO4V/0s5VvK7g9//DGUwGQpY5MQin8idltTC03enrX//6Q7BI17SoWHC83UGBJReCUiJ6k5zqSmE8JvW8GZiP4ccrdEh8T4za7Oex62LllHgZovK8tY/Iur+5IXFtzouukXasNGQUlH4jKGmXaL0/dUiDfXISJkfQ8cjf7Vo6R80xa09Q3yaY5kIwOYRZJtfGCd8lTW5ZU1fXWVsXadjt6rf/qzGczP2J87rD6VR3n+Dcyq7mdZI107hO57LN1QrP3bpejWWan8Sh8XvWP5W7V2TTFX3r9dJh3PXhtFnxSK6Vqc22vryvaT1muWncKxultTnp96y7kvvTOCdeaLZxo8mEwzSu5wYcMhw7/fdtHI2ffYsZjmRzhryPthZa4MMdRMfL+2ln1zRnFV1Nv+44ZhDF9TqOqGcLgK/7W5TNzClw8W1Cma2UwYLGw+7sU7YFKNpvgjW0w9j9fKQMbrUHtnn+Tc6p20I+py0LJ/t1mjn+4At4Ngzt6zdvhXN+kj/Bw2iONPAx+dZI2Zsqr3bYEgWNPLPez+ZpOPu4fI34WJym/tA0ZZjTwHnV58rH6zTKM6HoG//K+SkzpfwgauezxI0+PUMo164HTjyolDzAQ2bPZPLxpqzwbCd/yOyHhtP+H1qwkvp5KLnKsM0RYOwebHKa+PY9D3ZBG7XJWV5+lIavGd3zwBg+lfNFZj0yd7nt8EnOWFoZTo9RXidlJ8Pz+xlOHaKn6Pep+mwG1STw7wmTkaqFImHPflJXkor4atubnjoouKSyUg5tz/UO7xOnYOdcXRnnVdj1eeqo+b0ruEyGOQJUmUMf/vCH36QXaw40Z8ouU1oze4+ByVhHGCsoSDARhUYbbuRlmvFujOmk0HYaUG6cNkfH22/3muF77zVzL0icV7+nurfogmx318/KATkZ0wqfXZ1J/uVa2PXhsAoktPLJiye0nuZwNb872dDqTsGFx+iqqV467+lw3brO3JBu906DGxNPZJmVzmnrKvtP/tnJvwmXdm2nJyfHttkPE1yVKTsbZKXzr9Co0Wy3HiacEiZdclrupW3oPP9okknpKDfHOQMEOTZ/Q1sGNPxQXO837+/sNRxHAgiZ2YF948EN+qBMBtpSv3n/uY2I+gIP5HhgJJ1/6uccOC5JwyY7nL/auUs5r4mLZ1eAv2cdUTcdccc7g3BJN8fR3xiYtlfOBfgK5BNoB8OHPvShNwcvcw6ryinjnQwjzqmRs08WCed66hrBgMxqyflZ8TW08/IZuEka+fhS3zFWD0L5Ncpldt8UJE3bNwNK/j/f9Of0T/5JezjXrB/O3XiVQJHzjQetKU/GmW/Fczu/BXLfb+NwOiJ7mhwgYEU5XizkMiXH7DLNacAbC8GXOmRysT3OH9RTxoPoTpsrdtDNgaWdYcQEtvKn7bbrKVxTAZ30c6pMJ+X7GOO29TE5BFxz5TLVvZfBvTKY2nXHscHUzlXcbjHuG17OP/mERNf++3//76/efffdP3GNN8d55L2lYV6Z4zSWn8rAm+ZrV+cqPqdG/2SIO310mNzHPvaxh28EoIJCUsS6pi2JemsaTwpOjGkpewWl9IYQCVYCixyuSFYTRoEr9KRLk33wFAfA60P7Clj6G+cmWGUiTU7cPWXRvaHJlfwNTMbfCiaj1u9l+1N9b2fSW67Qp35OwftqMmC6PundCfcdDhNMdJjmZ+dopOG+wnFlSCfdVuNe8Vn2vaL3rn6j08pOSZ3d1saEu8M0jgmXxH9Hq6RNkzut7xXfeZ22jrLNVraVm8qvZMNEm2muboEJx1M513BrGWOr+m3dXZGzTw04QO7ApBPL+F3+NnnskHI93yaWdvUk63Ut387F79yeI0gcwQE8/Km/26GTfsr6fj95wrNMvH2cVmwUb9ft2UlmeZkcq5f1bUApB53ezQ5vtlHLSEkZ6bh4oCJpm/MNzXwboQcyVJazcJwnVF47F2TTKbikh9CyIWXneTaKfAbZk2yTE3Bwtz562Ml2Lfrgtx/4LFyo43PiGT6+XvyAb+dDH3e+EbBlJOX8Ov/5XGWWnH+3AFdm3kFvxpxBpXYweI7Z2yMTibXmvOPXCD5BQ/r3NUA5l6GsBeZDc0iAJoNm77HDsAk0Uoe2PQvOA6ue9eRzl/MB/1KPNxMm7wsPXhAk3mP7HLRhnBmkdp5oD8nuesaSw6SMs3xT3HlvZeBknZP/V6AZsSc43AKnbaQwnNqY2pvqrvq7cv0UJgPnMfhcnYfkv2ZwavF/85vffAg8KHNJC1HXFZRoAYfJOOY7jRWu34OHGqyclqttXCk/yQVwSWhOD8KVVGJP2VQ53uanTKZ8ZeuKr5gzZTpxlpaA/ciqLwHrb2PL+qtxOa3V9gc/+ME3b6HgSYP6Fg95ym0zHFt/E6/fsgaeC3J+Vwa8K7AcUxtj4+1pzeX96f8EKxnb9NhJG01OJDjd0mg7HUejY/t2vCacfL5OZPhKHqzamebvpN22brLdkzGt5NY0nlX5ZgNl/YnPvdyuvxXvT7y608unPDrh3PpZzcWEc/4+mZs2r5OOzjHlONvYG+z4KHXGtA5be81+2NFhdf9t0B0u/x1SvnvWw1X57k5wZsG0Nlt2TepsyuaBwydblRrv5zam9pDJt9HwH8jsh+SzLO86lD7aHNCO45cOfvJwBoMYX9KE35mZlcGIDFZ4G02GN7vMcfcsLO+T/gi6ZLDFxygbUbbi7/zO7zxc9+Mz9C17koeUHLHBw1GCS+CsftgSpboc1i3nn3NzCGQ4/TPgNcm7nAeHzPp3WiQ/Od3yfCznicZ3eX5Zs/88q8lx8wBa40EP+nLPM4za2Wktk4hy1CWbkmw0pwvfqsMh67lF9o9fB30IEDEegjvqKw/WTjlGOR6i047TnqCxnxGVfCxgey0ZdgS7cu03GzzX7ZNlLO0MwJNyE8JN2e6MsCtwD8I9pm/6yjTTCa7glWM7nad7Q1Ogj4U2b03BrIyulTEMaLEp1VWBAAS2pxSmAmttNIXr1x3ne8AprZ+CFyZn4QSnxIXD0yUEeZqDMCTYpDr6rSdCJ+3ym6dIUtgulF0J8Hvl+DTnQaC2lFHFK2U5HBwFgoLyrZUnMMnOndx8KdjJn3Y/763WSBqu3k7jwTTQE5qeSWNpou2J/jvNMEgjMNtvhuOurSzbvrPdhsc05ix7C/9lHxOv+LUm59v1XJ8Tbl5nciwnerd70xqYdMa0ThpPc8/bW62XaU3478km2o11NQ8Nn0lfT2PM36c2Z7uWOK36XPHwzn5ouE+2iH+f8teKz98G+X8r5KG36dyzNjNDwh8utTXh9PWsCPoEPHOF8r4GsRccr+naNBcuWzJo4fPZZHKW47rTx/H0DIr0Mxr/4JA7nelvFWyDdjlfzE/bapeBM8aRAQr69mDahFPyEG2CX+p372OSXS1Q51uTFFz61re+9eZBtPpXNr12PvAgmv5Vhq1InB3q25hkI3JuE0c+5Pk5yTfMs9On8YLznI87x+Q2MfTyc7pyvqnrtPVMGQ94sr4Yj/OF28S05wEh6tOfz0t7K57/zowpDwA6P/Jf7fnh6Z6NlGs8M5NU9/d+7/f+BG4+hvbmPB6Y05fPA4En+kn+9nZyW5zPsdrkzW8Eu5ru9nouI13+PklgaTIaVgptMi4mA3qq166vDJ3VGE76OWnvpD/6yIlsBl/D57SPe9TdGSXN+DwxZE7avcI/bVxtoUz3dgakPyFoY8h6rb1mGJ/CzthMWBnz3uZVPO4BJ8Y65dj/6woHZeyBvWYITOPLeVs5TSv8V2PRdfbS84RBZWRA8BpQ/dZTrFvgZJynaapPDTuny+9N89XkgRvACS1404z1JjMoO8mIFb7Tej8Z/y3lHNc2hlbmZBxTm1Pf2cZK1rkTMOF7CieOQRtr4ryyPXZjybadzxK8zISry6TJcZvKt3mbdOlU1v+vIOuveMhp3sq2th0ajdp97yvndiUzr6y3FZ7e/4T/qq8VjjmupGlrd7du3zZwJzSDLom3O5fMb251aTKGe21rUDu3yZ0xIAMjfDf+xgHzrI4sk+VzS087ILzxr/OI87y3kW//csfc67huXc1HG4NnR7isbbLK5aH3l9nnjoNf9wDgibxpayplhPfl24gyU4u51TV4SgEjfbPtTQ8U2RaXuk/XCUAQ5PR5Vht6+KnAkh+d4P06OI+2AGc+LM3MFOo5Dl6m8a/PbSZHOE197qCrgwcsHHcP8mTwsAVjHXfabEHqJmd9zRNQkq8B/XgYnLT24A5vjtN9f+PbeyNQhfzyOYGn2KbGm/88INwyEZEvvmZ9bPr4m+HgPQ9StXlva8izuk5ttpsylppxtbrujLgy2lLo3GLcrCBx8vqJ2ymc1pmMh1vaugI7g7fhSL2V4bLD9d4GzmRkcy+VxNTGZKhOeKYiOqm7asv/38ILz8U/V+dpNd9+3/83Y58taQhNhLKnteq+H6o+4TM5Ejm21b2TOacMxoIL/XzqAqyyFac1tpNRkyx+bmi8fgUmPcL/XR3/32jS5MRuXe30Thq4K7hV1+QY0vhPPE7olm2261Mbp/Payl2R1bfcp4/2O9s44amd/bLSlafQ5nHC3cu2MUzjbeVXdlHWTzrs9GK7dyIfVtenceV87uizu9bK7OTE1TVyak81Xmz3dv28jeBOmAOOlztZLXiUdab/tOFZBK0ctsnkj/i15L0MOqSTLkinP9t3B4+5TsfSDxLO8aXD6OPIjBWncVsPjls+HAAvH7MHoDyw4LTlGtc9oEO7TqvExe0pnyunX2a6TeWbPMvDzb3/pCf/OQMpA5j0SxCJLHxsXR5CEgQQ6Df/aT8DAYk7ZXz8uo496vZC0sjPxPIyXq7Rwcuu9GPOf+NB542cL3gks7JYy9z3PiZd4Nc9+OS00HyQXaR5yDfQJV87z/g2tR94nfHk64xgoY9LwA4N7cTwNnzdIzN8DVA3A8IeKKdf5ym+PdiXGUq0d3LcyF0CSyvjdTKC/Lu10+6v+p5g1capoXna3i1wS3v3xuGkzRMmuspsrd3TOb/CGyucdoZh/m7C9hSSv3eOTJaZFPKt0JyB9l/Qno7cAyZDGmUgZat966QKS2iyT12gbx3erSc7aVCsnA7uZ50GKyXZ5pT/LvTZR08Z38/cFF/23yBTxVeGzkuD06/Rc1V+ZdBz/xTc2Pa+WrmGg5f3Oct1OuF2olOSD1brP3HY4Tf12eAqXZu83enVFd+fyKXsfzJem3xJekyyqI2p0b+NqfXR+mn9r2TBio9OaOr3mt016apGjxU+jSdu1XdTee/rhI47XjuxGxK3iceyzqktMuG4+33FvrjFXntq8LcvJf6erdH4S5/VVjbf/pTbcHKrl7fJNdep/tp718POhxlQcN3jGUxeJgNltJ+yrQWpmr50pzC3NiW93BmdwMfG/xxP6uqWceL4+ryAqx9AnPWdVjlPTU5Tlg9t5Bk2BBKczl7e79NfzoGPL3HDflWwAHtW38yTgJe7+MHOnvVFm/52Pw+aZRAy6Z/rxYO07U2CPi+Nz6GJB/cyq8vXlR+67cGblNvJX46zz73zFO077k5jp4MH/WgveTBxnoJVtOPrRx/6eK8FWNmBobL+MDzpyoHb8AxnJjkPO525Tn1/8M7xG4xFbbego3Bz8IeU+uC/MOaUr0+SsbRTUCeG7BVD8Co0w28Fj+nr+0GB3wvSWH4srIyhNCRWTkaWb+2czDGLnYg1gptIc2YInLQ3ORYObhys2rnC0yucVv+nawmu2CZ8V47AVF57y//Mn/kzD598mwL713Ob4mPXXDo4k9OUDgbXeSog5aHtcG6IcnijPvmEJ9va4ee87rhRJu+9rZCG89X1uloHKQ+mp9OJw7RWp3bzdxpZbaztun+v+K99T7RJ43uSkW3MTc6s6Lwb3yT3TuRQa9PLn6771XzmeLP8JK/yd5t3rk881661etl3a+eEZ73PFf/lOJI+jQ5tjI3XdrTbOY0Nj4brpDNX/DLxeuKyuneFH1d0P4GTMb3tkDwPHVo2Qh70zHfaZdhw2X72IUiHMfXsar69TMvE8LotqJTttPa9vUmmcs/p4cEZ3941BX98fJ7NgRObtE7aZgZJBjf8DJi0pfNsqxVNwCEzafTfH+hRL+eX/xngcpzcdqAN56c2h15P3xqTbFi9jIZ74IGjrvs6l1N2LYd9Q3u3n50G7Tv7nuSy33f6Ow2o69k8jNXbaGf6NLwSv5yHSQdMNrnjr3seTPE3wvkY22HjPl58PX2TsYRND86t3cTXy7zHgro8VCb448HZzHhzXmEdEWzyNef13a9g5wRnKeXZXM6zvjPE8QOnNpdPmrHUhLXfSybLcrdcuwKpZJ4Tvp+V/EuMbWfondSd+DHLTnzqgkARb72W/od/+IcfDuTTE4V33333zSvuV4ts4uVmdK9gKpNC+qTsDq4YtafrKmmTynDVtuitN/N94AMfeIiq65qULm/J2CndyUBLvHe87AKe8m0croiVbSXwt4QIZwXL/DDHJhcnurrhONH3bYJcGytDeTKQV8Zlu9eg4ZDzOZXP65lW34xLxzvH19bY7n/Wu7JOvb2VPl6t01v7XY3BcWvXV7JlsjdW/WZbu/YnWuX1q/JyN57sYydnJ3ymMeT9pN9Eq3RYErc21ja+5MUJr6zrT+ebjm9jzzGljdDKZL8r3b7SIydzMdFkBSvZeKoXmpPw3LZxAm9McvnqDuCEX+rE5GuBn9OYTrFnL0wyiHte3529Bi3A5d9Zrzn3lM8MhZxnz4ZyvD1rxOs67vSVmRvOux54yiwZp8+Ef5ubZnNz3482yDOU+O1zmDTVdc+G8de1Z1DI8UkcvO+2hlMWOi8m7+pFLvIhBLJhyVwhsMGb4uRrcDYTHx6qsh0LXj5dEw4+F+Dp9OCaBxSTdtkOvOH3aA+eYTuYl/GMHg8Qqi4ZjPSd6yn5y7f66T9nGbXAo8sAPj42f8s0bfg5TbkGmGP6oa0feH3wN9c1300m+XzQv/wdDyzm8RqOS9KdTwaJ/Drzwxu3mQteLqTfwoOzwDx77oquuBRYagrsMYqpCfSmvCcD9LGG72Q4/v9wX5gM0ZO5u8JnqzKTYcY9ItJ6gvDOO++8+shHPvKgFIj86j6pjNOhcA3nZmBMY77K05NB1JyDpiBX/yeYxjrhtzN0WxneoMGrVhGSrigmY/p0DJNRjxCGH3iVKIYKnzTmAOGsNwrKGCAopqBSngnV+LHhnvcab71tsHN+rrZxyzindb4qv6q3MphXhtzU945nMVhO8fd23ehuOE4yZiW3rkLicVI28btV5rU2d/W5l+uxOUe7vrOvid472rixuuOXad6nsa/mZ+KZRpu2Rqc2Jzyy31buRH+u+DYdrqmfnb6axnjFxjmh3dTWbtw78PpTtvFzgmcvCDJjKLfR+Pw6rTIjh+v0QVu0kVkDlG8BHJfF7lQC3MuMiDz7hO9sKwNEfi/r5PzleD1o1Gy/XEceJMtMoibv8iFKzhPQbBrHyV+v7jR3hz3HmHPv85XrguvJN96OZ7/RbgtoeZ+0TXZJAuPhAbWCRm674jvw5jACTdiZKi+7Ub6H7ulhqj4c/ZC0cv5wPspxZXDe5z+v+XrxuaYtzovKQI1no2E/A4w7M+Fynl0OOM94UMTb83vJA3kIu6+xacuor9ncbsb4FYTBH3D84Z/3v35ztT6eiEBfvnYYX26ty/XAGUxkPjkvexnG6IFJxiXeAnfHRR+CSrSnvsDf5yJ937tmLE3QFNwVw7Qp36mNk3Z3xuaqjcl4uVf5x9b7foErRs9U78QA3xmVzaj2Ba6F98EPfvDVpz/96YegkkfOBUpX1cJsZ/vQpuOe13Jsre7KkF7RoQkq/591V+vgsQ6l123Gc+I40QNBeyrITtZV4pDlXLlIsStrTd+UZy+8tuLJGPAzlADhLGGszCV4iD3bqewdl9XcZvmJzm1Mbxs0x4D/bX4SVuNshufJWvO2VvWacX465ix7RUa1/yf12+8c34q/pvZ3OEx9T3y50smrcU14rsaR7bo88npuYE+w46F2r9Eo52Sai4brRN9pPa30ys4+ujLvifMO/9QLqWMnemYbUx+5ltq4Eu/VvVUbp3RsbTe+8DZ3dRpMY089/FLQgkLNTvDrAGUyoJLZNX6NdgRezh1K19cZSEp6c68FqBovt8yhJufYLkXbmUnS+D63o2HT+P2UAR6UYPyU8TZyDNNh1z6+dJYp53Uoxzgo61utvF/a9/G0rXctaOLnOLWgU+Ls43I+8SBKjo8Xzsh+VBkFhpw/9M3B0AQgZUu6cw+uymjyzKXk6ZW+zSxrvv2YBudHb9PHlAEk5xGfqxVO0CvxbzTPNdV4i3oEsAjmZEaR84AHdVx/JI9RluCgH4PC9jLAt9D50Rfvfx3kYd22DCWnP7zu2ZH58Jr2XF6Iz8QXBJ50nS2VzuPQyN9e52d6+Rpy2oj/OPR7lan5qMDSymByAjQBdArNwGr3VvVW+J/WuYr3yui/gtP/aXBi9Ez1Tmizq98MNecvFIH2QX/2s599CC4piMSC00JUQIHXxE/jaQZCMwzvTb+Gx+q/t9vu7dZ4a3uHY66LyUD2smmUpXJZrbVUHolvwx0FI+GstGTxA0oFg4Bov8ooK0mvhfUsJFd8GRRrNHUB/pg5TePppWXKSs6u+NHL7sq1tk54342kFW80Hp2cgAnP3ZgnXFvd1tauXFs3U1ve5g6/CYf29DidttZu63Pig8Zb0++JD09lZD6Fn3DM3+3JY9M9bU7SWcy2J5nrvNnGtHJAEse8n/M70WC6lrgltLFNuEztNdk3jetUD53qx6muj6dll1xpM+tMONHXid31NugKp5XLVr/u43PnJg/nzmwXygN+L523dOLAJc/+4boHFxw32nfnPXmSdpsu8XH7dhifVw/E5PhoI53ASQ5xL4M3bY4yEAZu7pgnzj5/rnszi8z7AVfPVqfN3N6U341/MjCSazNp53IcZ99x8THxm4CePrIPtf1N9iMHJ8NHOPNkMsnXcD4m2KTfqgsfOM4+79MZQm29OO09yMJ6aPqL8XOvbRP0IKk+nsnjfWRgNMcEeMCIsnlOELjoP2+N9qwhgjk5f6kjPQPL+04dIx/QZapn2xHUwVf4o9dvrmZbHm057/q687miDc4Kc/+DceCHiL/00e4OApD/43/8jwe+8TmAJhlUoozLTs/ESzo/WWDJmcL/g0RTUpOy97p+/YqimwzFU7i3Un1uJZ3K+Clh18dkFDZ87w3NUGzKsV1HOCiQoG1wylAhCszh0b/7u7/7sJ2JPdKrMUwG/WqdTEbViubN2TiFXfmG34TDKR/k9ROcJ7qlcJ5wWPWRykUgwaunTPpIUKci4qmIgLctSKh7m240JW4N1xPeaONy2k7y+KUhDcuTOb9F/k99tsDALXpmtR0h75/y3iQDrtaZymX50/Gelpt4OXFNeZa8mvprJR9Orq3kpxvOK75I+ZJ2Spvj/N308ilPnJRblc17kw3WxtrqpazMdT31v2tzkgnT2BpfNVjh6LRrvJj9Je473Tzx8onOWumLdn+1pvx/g4kHnhtyLtzBbfzrcjizkdrYWiZLm5eW8UQbWa/ptRVvNLuurSl9/C15KTvc6Wvy1cfc1snOFkt7p2VyZBZT2wLXcPT7Of5mMyUNPQOKPpJvPchGoCfXQr4dsG2H8+/cKsn1dtaR/svRJ6jEfOJP0Bbbo2RjepaYz58CE/pNIEGBDWiVWyaTto0nfE6b7evrxNdY8ovXzUy15A3mlW8euGaQDoDfeJOaZ/yQreX9icYEdWjbs24IcjqNPaDMvLLmuEYfZP149k/jR93n6AsPgH3Psh59vJMu0G/VJ7PIeZQgkPOYznHVf/mnJD/IH/EzaH1+yXpzHzbn0Ne79+nnMd01sNQMn7YgT4yM/O8M7vUmIbQyvBLX/5NhR3uHpzYgctHfE4+dobTjozSQG07+ikbOVdIC1ELVQdJf+tKXHn5nYGlnXLa+dtebQmjjmmBn/O7wPJmjZvS1+82AO53/nUGeSjEF96kMQKBKMegJEq+HlcLg8EFXThK47FeWQM+nP47rju/SMWhylt88EVO/PH3gMPNMDX9p+TcZiFPZq/ju1lG2ueLX6dppn1Mb09w3XCaZchXflTHf8Nmt42mcaQOc6iBvJ9tqY1kZyqvxCFYO5SmeV+7tcJvKertNbre5bNeBHV+tdEnKpGaz7cbW5iRx8n4aTZtz3Pgg+5tszCy/W+8ndutqbU980ug3tXOi+7LsSuYkLa6s3acEnH13BN3JSR3puHs5Xc/tTc4zme2QmTUtAyPB39wEgEe+Ej4dZ6e3b3FrNlGbR8968ezQ5EfHJ1/H7vc8YwH6UD/H7gGBSa8mPyX/Js5TVpXPgx9cDN5pb3l5cHJ7zW0iP48ns63IPpF9xVt8M5ML3H3O/Nudesp5kIE2fVsTfoba9oAUdGf7VWbVeTbdJCs80yS3hzn9MtvY/2d2nvOM8xVtejZVzq/PffKVQLSX/c08c1/XOdja55AxcUA2Z5nqGucEYR8zrpbZSN9k9vgZRb77IOWIrwE/z0jgZ0l5kKbJOvcrWd9suWMrWh4OrvJKeNBWS74JguWcCPyeIOVLC1jmet/ZNHd5K5zgxIACriqwVCh+fWrvFJd7wgqfl4Y0FK/W8//+nWP2PiaeuMfcNIPwVrpTTwtKizId9G9/+9uvvvrVr776yle+8mbbk4+jKfWG42P54mr9ycnwa/fq6xSP6fpqu8mOX9yQ2cmk1fwAKDDnaZ4e8JQpX8HZ2ms80dbLii6UceWpbDpl0ZECK9B5T6S/+thfWhZNsvkWHdDGNMmXxgOpYJtxPPWTfTUcTvl3MsrbvYSp3pW2Vpk6Xq+Nqzlq/n/CpeEz0TiNveyn4Zv9trV3QqOJNxJWuHu/zfFJvN1RmcY69ZV10ph0ek58eEoryux03Uq2tX5XNExatPo7/ZI82+Yp+5xo0uyhNp7VtVM8T+i56men//L/S9jMQHPw2ly0LczUzQdK6Ty1upmR0bZoJW7ZbvJQy8Bw2npWVL7hKcvmtiYPKmTWReNF8PDAhj+A8+0vp2dcJU6Nrxv/tTUF7v4Wt0YjOdV+ZtQU8Eve8Xny7BTsKc4v4gxNleG/bMDvfOc7D2+BzrcQg1sLXupDWdlnfh38FeyQDad7al9ZJgqGyH4TTjzY5LwctjU1veJb5LwfD2Q5H6pcO18p1xD1fc5bwNbrpc4RwFfeXvbNmOBjAkjQHXyZP82PB13AkTe6gUNmmvlaEBB0En/BEzxEJqhEuymTne58PNtKoGsEiDyI5PRJueO+JxlLrFPow5pQlpLOcRV/CF8FJn0LnMu83G7n85Hr1OfJZYjLmbsGlhrjNOXvsDMAVjANYDLQ2v3HwM7AnHB6KTil9SlzNGPnxGCZrp32m8ZUMySy3MpAXhmzgBaThPxv/dZvPZTVov3ud7/78F/fnpVyte2n4rlTWBm0Ew4nkLKAdnMMTRE3XCbHYofDVLcZPLuxSYhrrhVk5CkBCgglTx8yBvINDRMdprXZZFnep4wMFZ39JKMDxcPZYMJbwSV/ve7bAG0eT2V2ltvRshl52X6re8IvrqRTHp2M92QMEw2uyoOVPD7VDTtaJ+TaXsnFaUy3XFvRZ4Xz9KR8ZcekDmr85WVPbJIV/k7DNNxps+Gwo0/WmcbRxn1qN0x81NpsdX28zQlp7bYyp/ZKttFoNLXT8NnRvY3dy0zjm/D13y1L5mSMLwnuwPj69LNpPBCyc3a5xzV3ltyh8rJuoyR9uJfnIjlvTFkM3oe367oFaBnXmbmXayfH1nSZO5v0SR+iq78Jy8eGE0sdHy+4uQNP/Vy3KW+ddrm1pq2TJgPbHE/r38/Q4U2/sqM+/OEPP9hUvIVYtp6uKxtd24y+9a1vPTxcJhPEcXJ+pD8P1LHNjQwlcFTgSB/5FXoo6IErHnCrrHDgUG8/L6fxlvOg86v/dnolb+fcr3R0zu9q3WT7joPX4bpn4vg9ZAF2L2/U8zONchsca0Pt8VA4s53gB/0mqKSybG3zw62pn/T37XTqm3n7f177B4xXvOVZiqw9aJHb8FIPck1tct4T9eERp7nLVJerTaZBu6anm355ksO7TyCRmoyBK+1RfmfsTIviqpG+KnuLwf/UsDJQV/93kMyWfV5tbwU7wxYhQ7oiQsVfAZ+Ku+Gd1/UtQfDrv/7rr77xjW88XFOGkgeUVm1MdLhKn+YUXOHlvL5SEveAlSHsijYVUs5RkxO7sXk/bc4brGimb8235t3TrgUS5q68ZITwtKAJ2t06aQq8GQ7+X0+59PFXvQonKTIFl0gBXvHjc0PjRb/eHBw3KqY2pzIn9U9xbvLjFrqe4HFFj03Q5EW2sTMcHd+VoShwZ6EZ9UALKE9yo9Her2f701jS0ZjG6P+vyqL8n+s425v6m8rt5FrDL+dsRad0vhpk+bzu+K3w9f7b+my8tlrHK/5o/yebM/X6CR12tGjlT/BvNJj+Ox2znWkNrfp6SV3RxoBcybesNaeJb8/iYWwZtOGeb+NpmUv89vXjmTUuX8D3RLa67My+9JuzXnbyMOmUbU2HXGfflM0HUozH31DV8HCaO82gPTbT6iBvyjmejq9vF8usCcctA1dtC6D+K+NFASW9+fkDH/jAw0Nkxs/bvGRPKfijcgoAff7zn3948IwdmMELnydsXn2rPQUU8FXYrqWjNdQeGSbOH9Bd32QzEdzz4GHanXnIPO2lDGG+fe14wNXnKOnYdC91/YD53CaXPJRyivXLuUrUz0CYvrG5KeeBO9cZtOGZR4yXM5mYd4JVahs72rPUnNdcrpBV5jTXXP3AD/zAmy2Nzh9uL2UGlx+QrY/akW0Pj3CWq9MgZbjPj28hpF+XYfCZZwOCjwc6M9h/CpcCSysFdGKErRT8qp2d4dcMuxOcs+7VexO+J7Bq+yXbutrvBCsDrhmzO+MQYaQFK8EvBaHfWgQKBsjRJxDUFPeEI/dQgkSDW4bS7qlgCuUdrVZG/QpW4zm9lv3ewkPN8OWb4J/mSQKS16lKcHsQ0PtszkaDaV5P6DmV0TXhpb3KEqAK4kgouwLnyZaMAn1PPN2M9xN+nIxT4cPWNzdeOBSSs6Hg/7cR2tjT2Jh4Mum84ulTHnYDZ8U3Tc+kEZPXV+vzimyY8JjGkbhObTa9OeEzrc8VnRseKx3NtWa4ntAgy080brwzXc+22xi5d6scT7yndnfz1dqaeG3SWzm2lWw94fedzZbtNNymtZ9jbPw26aZWJvFbyewm83fyfCeTdnx/C+9M5W7l06cCd9RyC0/in5kX+u3ZHP4gq2UjeTnqA243+nU/7Jl2WqZMc/qdX6nnZR2nyU9KW9Pbz0wEH3Pb9pS0ZHwZlEmn0ucpdZ5vrVmtXy/r/N5o7mXd+U1+dxw9g8h5iWCdb1VSUElvf5a9RKY3QSfZU/IlZP/pJS4/+ZM/+dC2gksKQjE2p0dmm8jelT0m+0x1Oa9Tbcu+1DVlNIG3j5d2fE1w5icPNdUnWThJb6eTn9/l9rZncKVvNrWZ950Hcn7oT+ABJ+dTn3vd5xBu5z9vB5oQ9GjbAJ0Xkq+o60Ejdhzw5j4yjPJtaY47uDht6cfX2g++9k3JquLcXq7RpssXMtSgjdOAjDmXjz6n4JcZhD6PKR/o3+dk0qXQ3wOhT/ZWuCYUp+uT0ss2V/3u8EiYDItVu63uaZ0JGp5X21jBPds6NcpO4JaybSyeYiph/7GPfexBCQi0OD70oQ89CF+llkpw42C3tlbG9CqYNP13Ye5Rd9pDmDSaNIU/9dngihHq0OpMW9V27SRvkG4qxaq58gP3BAosSXErGEidK+t05/Q042Y3djeCJMDFR+ztF10k8PVfSp0U2QzgNCdikosntExwowm8qCf8ZMy4on0boc1Fc7wmHZH18ndzzk7kfnNOm7Gbztl0v+Hp/yfn9xbemHRwo0O2MxkT0zxN17KfVV/tXpaZxraqO9GR8nmuwIpXdmsx601j2BnpJ+NuT4tbHefZnX3m13ZjTkeytbeSqV4310/i0dbybhwn8jZ1jPc30W5Vro0jyze5lrDK5ptwaPSZyra6K9xfAjK4klkwHgQC/+nMnRz3lIWRsgpo9z1TgTYzUxOn1bNwaC+359Cujy2ziLwf3ybjY5wyV5yGeTC50yvp4Tjz8UO9ueY09Xrel8tZD6IxZndOc56wwdmel3I7eYc+fTufz0vT2Tj3ekDoAR214S/oIfPks5/97IMd+2u/9muvfvu3f/tNRonrFn2rvPwS7EUCODyw1Ef3ZRcLB2UkkfmOTak66hO7U3Y0b6xWHd4Apm+vx1yAC+1wVo/qyPZeBRWSj5xHfb353AoIjvia9TXpwZO21tNv8gCyb1WDd8CNsbt+hwaeceR8z9zrOoEk6JfBKr75eGYU9KM8H5X5g9dzr7njQTr083HDH4w1fVbnf5eDHjjLtxz6eB1HX5u+jrJP5wnXNVz3LaFPshVupfiboXSiyFaGzVQ+nYLTdm/B5Qpu94TWz8rYukd/0//TufSyWacp2davX4fRyc6QgGYR6fPRj370QWC/++67D/uimzE58edqrGnINQNfHy1u7cvWkxCyS7QYpTgIVGQmVeLSnIUVXJ2HW9pqhvWqHwk00UF713laxP5jKQfepiZaSLGmkdHw2s3XZMSf1PNyjNMPwXNF459sg7RTBThJX0a5UXblHKzwx5DRN4eLo6DcoDod+1NDyuVpDq+sw6neY3TDFUf2RA9N7eQaamOc2k1DflXWyzXjKHFbydtsdwcrOT71fYVHT8u2vgS+RiZH70q7We8qf694yX83uXFar/H2KqjRshRS/qXhPfXpbaSMnvRc07ETjVd0yXYar+94NMu19TvVndYCuKALZcNwnl/aKyt6TjRa2TxvM+T2onaekmfF+Lz771wvXBe47qZd/9+yYrzfbMvnZbVNpMkady69rfZ2Nq/T5tvbb+PP7Cwff15nLN5XZhjRZ24NyqCO4+bBp3y9eVujjl/SLec66SRoZ0YxR1pv2t7G8RlkMamcspd83mXHyZfQWtXD6x/90R99E5DKNU4d2f485OP17qqjftWe7pEdIztTMoCH5E4vfast9a36wtkPsNbr5hUE0wd7kwAZB4DLH1JZ9aNAFFvr9FCXQ6t9HTTeSl72NZkZPZ5x6Lw6rQFfP8LbfTr4xQNSHlTyFymBi8tXzalvIQQ8Q8/f6uy8m/w1PZTKoA24//HrIJX4UL6QAoocLp7BTj8jytc/gUEy3wh6ah45m6sFrXPOaJe588C9j9PlhAefqMOOE0+SuGvGUlNsDk7olcLP6yujqTF99tfgiuF6C5wa6k+Bxy0Gw1Vj/rHgC+4Epyas/b8Ynr2wWnC6xmFv/sYFCf6WJTSN3Y2Ods/rNp7WR3h86lOfeghwoVgkNPR2iS9+8YsPAabpsGc3JFxhe/8ruu3gMcbl5IDlvEIHCUApPc2FP6XiW2WkQPQUJgXVZGQkHiuaTHVSATTjvymJlbPhY1Z69cc//vGHffl6i6AOfpcC9+wmN/xO5s5xIVvK90wTVPWnUTu+eQ5oga7mfO2cu5U8OIVVncfIwh0+aYynLNz1PTkL2e5ufFOZ03U9OUENBx9jGjzpfCVOEz5+3+2EiXcmejjek5yfZMOOD0/KtLFO/LDSObeug6znss0N6Cy/4teJFjm21f3VnLX6q7LTush7Db9W/ooM3fGv6wrpCH1kq+iAYH3k9LncbDj4GtzxwFX8XxI8mwBH1e9pHNKjPKgSUN4zJfwhlW9NApznuO/nAHnGA86h1+O3Z0Akb+W2mWn+WuDEnb5ci3xTFx5I3Fb2zU4m5tk4qwehjj/bfVzuuw3ltHKgvPfp+i7r+e/c6uS4O62cHjygk38g4IBt4c7WMv2XbaosJV1TYEnfst/VhgIFChJhe8E7BJX0wc7Xdd7YJfuMbWyOG2PkLCbOz1F590vIoIfnecAuf0PlhZMCSbJBdY+AmNqWHSqbXB/9V9aVAlW67nZu8nHyEt+u27NuyxLLOU8+FvAgFlpqDKIFOBCky8y9XOMtO27SfU5/goyNZzPwBL/lNj/a+8PXfSJLxGeaHw8cEvTyN8bBi/rWvP7Ij/zImy2T8ikF4osvfelLr37jN37jYf5appPPofMn8k7A1ry2Vn0t0gYBqmbb330r3Mqw2F3LtrJ8M6pWOHk/txhej4WnVOKnjsRpOxOctJ/j3BmQJ3TZleE+qaBSDETzvYwWNBkxHrSYDL0dnpPz0toiY0UCkf3QEvzCQwKdvdUI1uyDRez7cclSyTrTmCZwYygdxDbmK23nmkNAohwQwBh9og3ZXRxgmPRY9d8MpmZ4rAz9ldPhhk0qP69P+5qrd95559Xf/Jt/8yFLS6AnWz/3cz/3sC+fQ/fyCeFEv7wOqB05HzztRvCLrlI2OCZujLw0uGHiOE0yw2kwzVnjj8c6UZPRu+PDSf+t9FHy16rP1sepfG4OaNPdO3yTn7xetpmOikMLWvjv6al/Gq5Jh8RjxSfJg41Op7LvVhtl9bvN2aqdCa/2e7VGJrmZNNzpoFzvO5nWxnJqX2QbyUO7sU//oX/jq+T9FT7Zh35L78lh+PEf//E32RPSFbr+m7/5m28cqWnrzwQrG3rih4kuLwU5d5kdwfXmJLojyCedpLa+GHs7I8bbS4c5gyeOVwY4Gl/udEtzVjPo5nhmwN7vZVZDrvVJT/g4cy15Gz5P+Zvy2Q73/S17SatVgC7plGPIzBAfE5nyskP1gJNzfWSjc+AyGSPKDOHoBtlZBANUjrNYGafKKwhAhpHuefAAOqhvtkpxjTqcmYkDz0NE7D7ojl+gawomyc9QkFrBsH/+z//5gxz5l//yXz4cEs65oIxJx4hwlg8HVfvZQJMOTZs4+S7nx+eg2QjOx2pPOCtQogPVBR5Ecj5y3vF+k4ehuR9GDc0JhHp9Pzg/7R0PCHlGFmMkKJVb437/93//wR/FJ9U18Y0fAu+7GqCp5vRzn/vcAz8pi07zpG/5TJpn3VPbX/7yl98EIP2Qe9pibv0oEvD3N0W6jOVaBg9pu9lodwksOXPcWn5X/8r9yRhuzOz3dtDqvjQ8FhcXwM3w2Cm7E0PwXkbLZJRqISkbRAuDp34CniKczO/KAZqgGd7URzAqeKTFT2CJLBL2TCOUm6ImEKOtdFJ4pL8Slc6+E7c0DCbDuNHWIRXyjh7tuisgUkI5yDuDHw3v1nYqu0kBTs7e1Xl2Az/x8HWkuVWmmoJLBDb1X28XxFmYzthaOZHJm1JGetKkazIkqCdFJQPIzwZo439OaLSfnM0dNB7xe6vyjT+mPlZj2PFaa2el8yb6tDI5n5Mh5e208U4O5gqvhKlsk6NNvzQcJ1p62enaal4b/bN8+78b7wrf7GvCpZU5WRvJCzv95fczQD7x5yRnr66hSUafzt/pOL3d3ZaLVR8r/X5yv5X19gXSgXKcJMtlG/h5hGzdmOyyK3K9zd1U7qUhnbg8ryeDy27juXPo2TXYU4Dfa3LH6zT7xOs0m8AziBufezZUy0rL33y70+p9THQEwJU1kW9+c/sscXEa5D2vnzR1+3aFm7eVayb7aLI/M2JaxoyDB68oI3uMDBLZb1p7Cvh++tOffvAnRCv5GHLmCfKovICgUY6bLCLwl92ne+ys4EG42mQbHPNJ9hxHaBAsVV1dU4BB5f1MI7Je2GalcnpQK5tT5WUXKiAFDTjeQT6Fv1k415T/zyw+z3BxXms63oMxlPNAadbBh9KYePisMRAMIvDDFjA/h0r3WzaNZwPRn9vi1PfgEzzVMvhybTudfH7e87qOrjEm+T4kDfjacVkn/tB/7X7QNfGg7HrNm+ZUu180f2zLlD+Af5Fyz3kzedXHSfkpW/HqQ45HBZYmWBkg0/Vm6LVBnCjUyVg6Mdpu6e/7EVKZvU30ODG2dU0C8+tf//rDkwQOwtMC5M1YPE1YtU1bJ4boZAB4WS1wne+EkpGQYE+sgkMIvuyTfrXAZXTqiYKCU7omJadxouCyT6/v+N/C71dg5XAIT3+NqgQpb8dAoakOTw08/dQVwy1yYGV8T/UmGTG1lY4M2y/Fc/qv9FWMOJ44ucF0uvZyHYg24idtm+BQRgFPQKD3iTP1XNCMEIeJX3drcGrP21z1m+16mTbvJ21d1XuJs9NCkE+Zs3zivxvnVH9XpuFwIjPTSVpdT14/wXMnGxpPTfzizskV3mn4rAxRb3sX6ElbyJ2nRoMJ72nMKznR8F7da7g5DZIe7b4/3W6QeExytOG9kr3NJpjok223dlod5lq6Qg6C7BfJcul7nkjjvLW37rT1tsNvqttwfEmA1k4ngTs27iylreF8k4GbBJzjzKjxuZuCFPnWMcpPQQx3PjMo1NaMfnv2CPZeOuaNZn4tx0K/nsEw8a87m2mLeQDEnVSv22QO42J+pjWTWVdZ1p3xFphwejsdct64zrlDnInE2PSAUPa3skFUT4Eb3uqmdaoynBnq2y09CIhtS6BIW+tkC3JYOEcX+BuoBX5UhtrFjtYDdNol84VxSpZgA2qL1M///M8/2KNsHYMv4Hs9hOSMWh5g55vIkpcyeJf3V/aJ85p+E0zPt7vRD+dQ+c4NAlzQlJ0hoqvGAm3IBBI9eIkTc+5tgIeuE1jyjB6fI98G5+vW8WKt5pp5z+tztlSPM7AIFKpsni9LYFJBTvWtMVBP+oKzwMQX4lHpD/nA8CNr3M9+Yi37Omhr2NdcZnp6VuiTZCydGslXrnu7K2NoZRjuYGcA/X8F3kbDApiUUn48MCHFoMXHPf12Qe0KsimihJNrE28K9FTjq1/96sM3b3FQUEkKRYLK0x59LAg81ZHQ4XWlRONJE70ybyfO365ejjuN5+YokGqssRB4YXugxqXxMWbNofaCS2jmoXA7fE+dqMRz+p11myPS/iOMmTeNScpb/5Verd87J3jCuaUaE0RqBu6JfH5O2Mn8Vm7lzGb5NEzTwJ3q73D2dpqjdkUPtTYaTDy262cqPxl9zXGeaJbte51pe8VVOAkCtGu79qY5mpz0W2Gic/bXeHg1R7u2p76a09jmu+F/Yoc1/CdcJyfS8cm5Ws3HJLfbuBxWeOb/JmcaDiue93rp+LMNRk4dToD+S1+SYZDgsi3XQxvbhNNjbOingpTZOLE4erkdxgMIgOvJpjN9rhst+dA3TqO36WsqeTb5MvujbRzR5A8cX8rmdro2Nsc3gynNZnUac1REygoc/uzL6enjc2fT54TfvnXJ9YUHCumXNj0jaKJrBkBoI3cs0L6XJSCk9aaHuHLOZZ9S91d+5Vce1qF+656/ccvPp5Gtx1Y35lZtk4nImAmAqD/9xm/h7WScwZl8Ce/w4h/5A/oIOMMVv8BfAAB++vBWZvkeflg5h0prd4SusT0P+kw85vyZr7RPvvM5VnnOwtV1Hrj6dreksa9L37qm/7KtdZaU5kc2Nmec6r/qawvgL/3SL7362te+9iY4x/Y/fA9fK75ljLOMdJ3AlB/4nXzu68DH/0e2ddVfBqTfvm3S5QIPp52e0F/lyWqV7mCnDvype/TL8SKOD9snKedBYmQCOPp4mAPPtHqSt8I1Y/IWxTQZ7if1dn22MldxfMzYnhNOjO3Htn/q9Dic4uPKLfkBA4OD7RAy/satXOT8nnhrxXPNWDudf3Dh7Q8ZAW+BkzSotbgRNgIFYyQ4ecqZBkTDwcfosHrKczqfKweUseq/aCDlqTOHNHcak5SiBL8+KAYdQKc6ysLxjK7VfK0M6ebUNAeiOTe7evkbAYwQl5ImiKhvUp2bg+fXpznbzUvi5e0+lSw4heb4rGgO5NrPa17O+/JrbS4nSBwbbrvf05pq9Mg2VnVW+DY4dRgnPpnoPI1lt/amdefBfucHr9fo7N8+b6d2xMSH0zhzLFOZ3JrR6DDJr0a3pPOuPS/b/u/46sRGyjlv63SHY1sn07gbTLRsdJhk5xWbrtU/1ZVTG9Jx0ody+LSlAWeOJ/ETHSaZfkV3pL7ZjfW5wDOWG6zmmPu+fWvFzx7owKFj7O405UHU9AMQ+MHZSnywTb39xNfH5vJo2tKX2U5A2r/0l2ek0CZvp/KyJ/KiZRA5jfxhrs+JH5LOtcR/srV8XjPQ5bRxunjmews4Ch/ZpX/5L//lh48eampXgLYZyWaTna3fZDNp25HmmQd6HgjGrpe9z3mvBJXYCse2LpVnyxT12MaUus1/6yMcyaDhxThqQ9mOBIWSdgQOZZeqX3wmAlpqS3a47vu5Tt7vFFzkus9ny0Zz/iaoxXYvAksCeIMsJQFvReOMUtpS4Ee+g86pU3BM8GM/9mOvfvqnf/rht/rRy3OYHx1JwUt0PEMIvgJ/ssEIvJAF5LztfJuyxMct8PXsdCFIpuvwDOV46KA2FTzS+NnmqPZ4ax7HpRCYg8cEjhNzlYFA+vU12dZhymXPwrt7xpJDGmdca3Wagboqn/dODKDW/mPgljZOnYR7wWOMgpUBtnKc7gmTc4Pi1iL6xCc+8SBQtZAUwVcggr3FK4eBdlo/fi/L8ns31sl4TuW94wcUvgSglB7ZPCmMc7vYhMuEd3MK2/zm2rxikAt484aEtIQ/WUuaT31rfzCGl/YJay7zEO+d87DDp5Vr9RrNdu0CBJak3KXAeKokw+RXf/VXH675FjVvI5+CrngteXHlHLykk7DCxel8IuNbvVZmpX/S0UynZOf0n4xr1e4OmvyYZNJKjtyil1v7070rOCc9ch2mY3ELnVZ0Xo0zHaPGS43+p2tqkk0TD690V/Il99sYV7w/yfNJd63mNvl8ghUvtb4n8DrTVrmV/ZD3kybpBKzqnIyr/fZrruPkGEhXyHHSthsFmiYHJSHxOF1TKQffBmgZLSve8+wBd4qaHFjNJ7IorzufZZvpSPsWEZ8DdzZbe42fPXCUZzIxFtrgnre1ylpKOrocdgfZec4zl3J8Prb2NjafI+8TXB0nPzTZ+wAHD6z5FqqmYzzY5zTwLT+yP//cn/tzr37qp37qIZNI/gRHVXgASTadrutbW5N44EsQRu2ReePbpbx/spOw7VVXASKyFQkIecCn6R8CUWpLH4FvmcxAJTRS8IgMF87g5FgKjYvMF8klBak4D8jnw3kfXAgAecBqJVMy28eDjhmgFM7IRoIh7NbAH9RxE/KT1N5nPvOZV//0n/7TBz9C2wB1TfU1Ts2bspc8YyczrTwwzDY81eUMJ8cz15Wv39U6/yPbqcL42QrpNKCOfAcFyjiTljdty5fSt2gj30JlyVzy9Ut2GGs4s9mYy5askLrL15e/lfNJMpZ2DsDKWN0ZFSdK76SNx8KkqE8dge8HuGpc3GKMnDptrZ4WkIIQ2vdMqjj7U/XbF+wKx8aTzWhJnE9gZ+xOOCUuGouEo8YpAcJp/wSpmvNx6lDtxrNbcyf3czwEl1C+XFfGEummGqsEpf6ncZlG/w6fNDZWNFmNYUeD5CUp4y9+8YsP33oSLUWhs7b0FIyDBgEUMm/LY26nFG4f2zTGLHM6nueEXHM5fydObuOxnOumHBNW8vqqw5tj2o0tdWSreys0nCZ8uN7KnayDk/+NP9MJyHKTQ5+/s83W3wnuK5wnx3bHu6uxTzhMeCWftP52eqvZZS7LdnV3PDHJ6Wk9T2PZybSVTt3Zpc3ZPpGhrZ+sf0XXS94rS1cOD68l10MyBZX8XEjazkCTj7PJkhPbu927xa67F2D7CAffEuW6lrHlliFvw2Gab8+moY1cF5kxNNGVax748P8eMOE+mRr8x+l0pz2Pb2g853h6PecRxinw4I/TYOojA00neCR96cvH2uZw0gn6eBCA4Epuo3O8WnaT48D2MGW8KNDyn/7Tf3oI1LAFSR/5HB6slJ+hMmTaw68EKphrcOLAZvDnEGo9PAUf2X8KGsjGJ4i1st/cPoTenkUDTf1waB5Mq23Z15I3BLDUr3DQt8bLljn5H37gta9D51XGoDb9pUkZHE7e9K100CfHxkuQVFZ+kL41Dg6xhtZqQzT8mZ/5mYczqCRHddi15uiTn/zkmwwxziXy9QJuvl4Ym29l5ND75pP4WvLMRcq8t7ysCfngY04ZpHvyHzQmHsrLh9JWP/nBmivRR4EltjzSvtOVpAS1p/mHBnwLPFlhstFdpuGzPMnh3ZNRszKwdgbMzoCc+r8XrIynyYA4qfu2wAr/qfw9+zrpO+uJ6RWd1lMFCTBS8FRGQkaLj+1G2c/KuPL7/rvhvaPbdP+qk4NwUWReTy8lVCQgRQMJbj9faTe27OOKI3MF99XaZzy8sYwnG7qmbB4CTjzF4UmK7xPO1NWVk3EKzVGcxpDXW1kUks6J0hMflK4HA13ZShFyOKTGLVqoHum+7Qnqbhy33H9OWMnPHR+udEqr72t5amcyklt7J7J9Jzey7St6ZIVbG/due8HVdnJsbtgmnln+1rk95ZXd2jiREc6bO/3vbe/qTDiteNmvrWTRCd7usK3qnei2nU23kqleLv/vaDFt3W54Zv2dvXlaptXxMZ7aOV5eug9dgZPlTsnU9rQtpfF7W49vq75wx2WSNRm08TJtHqnTtqJl/czAyXqZHdT0SHOqc0tW4u7OX5Mx7tDznU44bbvj7HTJbVaOd+JKW+3snMxMamVS9rdsJsBf5MKY3MnNIEZu5fF+PMDicq+9Ul7/sb8URJFzLvuaAARviHO8BBycLBuVjA99ezCYvnjjG/95s5kHIfBntM1O18j68W2Dznc+hsws04ezgdgVoOAIB42LDuCgIBKHQeue8CQTS9f0kFdtk8ni/MKc8uGlPLz1Dh5M/soMNec7sqd87vXRnDB/8oPAG9xkN0M/BVwEGr+Cf/KdFFjS+Uoc/s3aYF2nXPD+NdeMlcwygfsiPiaX2bkW/9gCM9Awt6r5wfaA5u4XfuEXHrb7aSwao76VpaVxf/7zn38InGmsqit65VvtaNODXqw9eMzXVJ4jtfJ3nvytcM3IXwlwh8ngvaLkbjEOGlwxPk6N/VvgXuPZtX+Ls3S1j1vA6aoPQp6FwOImen3FmEqBt+PTK47JreNs/zU2Rd41dn9N6D3o6r9dIHK9GR0nzkK7hxAS/ihmAcpYSkwKQm81kEBTJJ4UTikRDjjM+do5lM0Bbc5P8ktb3629rM84NUYMM4wUnhyhFKWo9LRaho3+61tzreymlWORjmLSejfml4QJjxV+kzE8wWr+Wl+TDN/NfWubOZtkR66lqb/TrSATLdzIbn236/lUstGjjX81H6f6f5qvTM3ewVUnOsu3MZ3o+JPrk92TsmzFr5NNsBrrJLNW89CMyVZ3ZaOsaHhFh/ia8Lr5VHglD1OOTmPf6ZNbZWmT4/zHuWv3nd67OZnaX5Vvfb0k5MMUcMqtYO60CVqQSYDj6Jk/XKecO+25znPbC9dzK1hmJPhrwx1/v8bHt595346nBx4dJy+f2Vv89gOnW3ACnNLhTjry7cc6OP7MC3Rj3C3AwNzyaQ/RnO55ZkyTJ3z7/ZRXmVElG1PBCTnjAj/TVM66sgfZLcC4OcdI9T2AQwaQ/utevonNA6M+NtmEakf9cd7R9Nr4lmmTOoaX4rAtCt+B8Qk4QFvlCTbIZmWLnOrrg83OwdU+Z96nyirgoX7UBlsH9VvX2hvVnDcIehDogL7IR33roTRZObKnhRMP2hVk+Sf/5J88ZJ+pnrbH/YN/8A/eHIr9y7/8y39iTTrPOk25T5CLjC4Fs1gb+J2syVwntJNbNwHPKCPzzumasokyOkhemVjauikayCdSWc3vX/gLf+GBDv/xP/7HNzsjoLHLED+KA/r6NtcMEqdcdfl2RV8cB5ZWCvox8Jj2dkbuY+HUcLpnf6ftXun/qebuSt/efzOmuO5KRoJFGUukbUpo6ZqeNPjJ9yn4drikoJ7KTAZ1+38VUlG4McQe6Ozvlj5dSSFI+O+H9rnim9rZ3WtzoHbVj+aPbWAKJklIah7ZUw0OKL583afj1vil3W+wm8cdH038zDzqqYmUHEaDFIM+7Kl2BaUnLlJoSm0VTVIx7HByg3U3zueEkznZOe8TP/mcT87iDreVo3VV1voc7PCZHMOGz0ouNdwaXVY09zZP2p3kYcrelY48MUxaW6fzdaIDGv5Zd8d3Ppbd2Fd8PI03y+zG0vDc9XHCr+gOfa+2nZ/QcNWXO4f0J7mowLsMfMlRZfr4lpErttLEjzueuqJXvP6q3Z2eTXxPaL1rK9f5U9rMVwFnyp2ufK29oNl5bRy5zc3L5hYtxyF5N4My7pj61ie+k8beJmPys2joo+GVQTFsIw/eUN/rgYcHU+grt5Gt5ESOxR3hHGPSoPEpsoNtO8iVxKPxtAfxpr4TN68DPch8kh3Gm3p1X/KFoxlw3gm2OO1w0Nnmxlhkz1KfgAj8S59qi/Jqh7dGK3tKdZTBSKAr5azLjbbVTHKSg55VV7iwBY/DoKEDNjgPqnkTmNpmOyBnJ/k5X74e9FHw5rOf/exDRo12jgh/4aCsGtFO/Wo8ojNbAH0eaJ9AHXa+nzGFD6S25QPqwxvAdTzKP/tn/+zV5z73uT+xvj71qU+9CZT8xb/4F1/9q3/1r97MJfwPH0JTtg/62oFP1Bc7R7Ddk0+ZX7/3PgvU0p9v921bUynr61rlREfRQcdtiF/Er5y3pHJ6s6GCoeDBTg/69GwpX6OaI14WRXDUs/ygA2PKLXNPmrEEXFG8QBNiV9u4pfwVaIbx6v494LS9x/S7M/Af45ReaXtlJIiJZUxKkCttlcUtYaXFNhm5re3pOosOgak2/G1zbgScOH7t2oQLQkaCVR8JZgkxjdGNaFfWp/PSjC1eMarMIAU/9F+ZMjrcDmXpfbhRNTmVOc5WBmWqbymHn/zJn3z15//8n39QEppXT3t24zKzLzzlufU90bk5OOmcJO4n9E2jSCDl/pf+0l96CCxJYIvWysr62Z/92Vdf/epXH8pL0fF0ScJc9fX0RQqUt2RM0PBO3nwbnIZmaPN9wsMruZtPL73d3bintZxlmgF31UFvsOLFlfzwMadcOnHgd3hMMOG2WoOrfnZ0n8ayCwDsYNX2VWh0mPBr9Dutn2Wv6J/sb+o/6wM82Zc843wOnJ/m+KxwO7HzEkfJRQXdP/3pTz84L9KJejKr7Q2t7xzrCr90VE90WRvHtO53crnpjqzTaNP6SHo2+ZZtu8P+0nqiOVPulKXT5bh74CAzdxJynGlbJD707f+Zu3TQ8qm/Z/L4di7GloHFtsXRy3i5nGPwabYR9qUHSHwcLWPIx+rBq7adyefF56llSKmeb/0TeLCqHQCO05+BRZ97fchoIWAyvfGO8rK/JNsky8iiF8hhl4xTBjlHbPiDXtrBliXDxoN99O0OufMIeKh9PUiU3Sc5p8CAbOHG9z52aOUBSLbogYNkpcpBC/XFQdR+vpLq+LY4PozP3wDmNjl+hD46AsKDabqmoI98CrWrvv/Lf/kvD7Y+ZfwcKLKo8gwg+lR9fED5DvKRZFP/7b/9tx9saOkDjVdzyllP6l90VTaP5hKb2ufCg0wEV/xYFTK22ObHGbBkNMGXHjD2IGKuIQHBRl8LE694AFtjVln5vWSiaXxsr2R7pp/Z6mvK5QDgx4wgn3wrHXgAHrQ6hePAUjOqV/d2Dt/UtrdzUrfhc3pvB6t6K5xP6me9laF4S/1d+aeCXdsnhib3eZsC0WMWdtsitcKjORUsSgksCSsBh91JwZBeuKNrc/Ampy/xkeDm1ZF+wJ6CDhLOenri2USNbisaCHgqoKcJf/fv/t2Hsao99am9uv/23/7bN9kyU7vNUD2hB3SWYFO/er2r3nagiLtorwCXAi8IU4SvaO+pwad9N/xXRnnjkclAb+0l3cnIEu6ir8apMho7Y0QJqh0pRzKZ3FDbwYomb4OzIJjkWa6NJrtWddv1W3Fq7Zz0cw9d05zIlGnNkM97WW8lF6/Saqfn89pkI+yc8FZnguSFK/Pm5VbO/FV8vO3W126uVn2u9Ev7f9WOSMdZMliyS09CZVhLbum/DHyd/+eZtLt128Dp3+pLB0onq3+dIYGB60/eVzSb7Ivsv9Wf5rLVmYLPJ30lnjs7wduZ+GenPyZdtrJTngOajGsBpXbQb8vAcccos2K4j60BJD+mDeBOZG5NauPx/jwby4NMu4Ooqet4+7aWJncZG+s4x5N8nmuf+uDpfRAU8qAGtPF+He90UH28LRPNz33xzAkfB2PzF6HwIbAi+923YXmAiPOH2CbEC4HkZ/zmb/7mm8whx63NOXhwOLQHFwC33eEDHpCrHwU+FDiXncir5X0d5LqgT4D+vSwZOt4WH4I4ZOzgb+ALgS//efGOv4SGTFLRTGMgsCHcZPfis3BQOm+kIytG/31c/lDZ6Qfd9Z83gMtX+qt/9a8+9P/rv/7rD+U0f7xZWkEkPYzQNjE9NCdY5P6IyxjoAF3z7WmMl/XqfM0YmQeyrdxneW+8SY8HycgzDy55RqLzu3xBzRm+sMarD/PF3GRA3r/BNW0fcPY1nAH+DCo9WcbSTnFdVVIrgy4X2C0K8DmV5j37uofD9DbBZISu+AYhR9Q50/FOnJvWJ5H+T3ziEw/phVq4LFAi1dq+hEDc8fyp4+nXOZiOPcHeBoEXCUdFqk/omXhxXwJFWUL/+B//4wdjXW0qe0ZCWv145NuNMqd3jndnvAMIb0XYlcnz1//6X3+zrVGBMw5OpB8O8pYAJdiyM95XkONxuTI5YCeCs827fmtceoqiMYiemjsClfCt+Epj4+mDfuuaK7VTPN52mJxqh6sOll9zOk11Vw5Vzt/UzlS2rfsT5zfHtcL/5P4JHW6BnLuVs539unM46fipr5Xub7xwDztlZ29MNN7JwqzX+KO13Zz+LLPjtV3dHIPmTHqBA26l/wjw8wrnSW6eQMPbceVBj/Syzu/QNT3N5/yOnUzM4MI0T5MOuCpDprGk3sl2Vut+kjWtrzY2vjPw1eBUjz8l4Izx28eYwZd0DKnj36nvuedj9K127nSyFcS3kDgdM1vUs9xzrtNBzqyqtG0S2jgyG4gxezCIIIqPnWt+PTMSoIE7mZkdnFt8nHczw52yPpc+F/TngSMc9aSbA4dGSz5JJrENjPExFl4M4/OrfiXTFCRXPQUjOCNIckYf1fHMqmafIKtkuxMQ8gAW4/YMD/Whstjb6kcBEbUhO5yHjJ6tBs5T9hxBHY2BA7cJuPmB4ODDfdWT3YmNje1NEIUgBHPjGU+8UEj96bqCR7Lv2X0g30kyXDav7Fo90OZFPQTBoAv4cJh7BuZ83TJvyvDSOaXKltJ/zSFbwVRe/cq/0T3fAueBZudP5I/KEpzUdY1Nc6I6Hoh0nNCHBMY8OPVeO7yeewTP6FPlNAckS3i2E3Mm/Sv+4BB2PYgXLXVNeloPX3SN4BHl8HGRT7wcib7pnzXCfDju6fulTfHkW+FW0BR6u78yIvk9GTFt8X8/wVPhnLR8TgNi6i+NmZUx5093uLZyZlaGtJfBgObwOS0gCRLV8acgeqKgRZwn4d/LiSOFV+D7stW+gl1SnurfldXkWDW6+JqRAP7VX/3VV//1v/7XB0HMXmwJFgWchAcHbXOInzKZPODhbZ6AyhHA01MECTc90fjFX/zFV7/2a7/2EHjxfdekcvLUJfu7xRBuRnybt3wC18qs6ICQ/spXvvKAO8EzjVF0xABS+xxySEqq6L5Kz/9+gyarV7RfXU+Y9MhU7gSXFV+tFKpfbw7fiYPXeO1EjzWHdrrfylzVlU0XT/+v9rdb3ys8aTezS1dyI3lixU8rmXs6jkavaWw5Z16m2VIndHUcprWQ/KqzMwiMS25zIKtkGE7LDlY80nCW3sFx0JNaOTByEHQWHy9zSGg80/Sf022qN7V5ondy/Sf/XVmLq7U88eoVXJ/bFtwBDnnLMMptXlkWoF4GIlpwoq2xPPeEa7rf3kiWshdcsSE9QOBnuAC+PSX1Sxu33/N16sEurmd73HO8aCvfBgXNkk4eoAA/7La0T8Er56TxcJ454/g6fZ1XJCcU0CAgg+0qeYFtz9vR2CIFrromR1wOuWxg2WEKUsgmJtDi+qTJDLI4eaU9NroHGj04yTXPctE14UJQRG2pHWzBZjc4X8CfHjzjQS4Pin0udV9t51vr2EKFHcr4mEPnJ8+SkT/BW8kIYsiP0FY0HXXxS7/0S6++8IUvvAmYKdijh66it9O07Qpxu815QPjJpuYMIbLPCAgLD823dIWuC3Kbm7eNPvFMSIIvCpBpjtla6AEhfhMgQz/Cm997Pc8+V/Cf8zj3eXjj8o81I/3LNkDRjzlXHQXRpKcZK4e3iwbgTMYZa4xD0AmG+lp3Wek0uWID3RxYmozgE0PYvyfFdmK8NaNxwm3V5mTUn+BxAleN93u22YyXe8JknKwM2FSuXJ/wawprNZ6TMaodLXDP1uGsI1I7dU1RePUvgchbIh4LaeT6kyKCPP6UwRc3uPs4dwan/kuAKIgjAYRiYe+1Ald/42/8jVc/8RM/8SBsOIhPZaTkRA8/9+d0Dfs8u5BWe//hP/yHVz/3cz/35omHP0kg7ZWD2XPeVn2eGMsTvZgDVyCMwZ/y5RjzP/h/6UtfesgMw2gSr0k58MRKNJXDJKMiU5ZPYOdM3lvmXIV7OjWT07VrxxXiqU5p7a7qnuLQ8Fnpmavz18rvZOVjwA3OaRzpgJ3gfMt6Xxk8V42iNu+OR/sNZEbC1M6E347vpnGkjnd+b/piN349eWY7A84QT0C1dVkfBcrZPt10feuz6fAcg+4hIwV64q1AvXRSnu8wyYWGg5eZ6jV5ns5NtjHZJonPDo9pHTV+OKHjDtpYXxpW2V3O0zhd7oj5/dy25OuSutNazPnO7B/KJY5+z+0Gfzub1825dtwzQ8vp41uV0mld2Sg5FrWbwRzKNdwcr+RdD/ZOPhkf75920pnN35n5Ktkg5x1bDbuZeeeNa7JtZW9KThFYIMNE8o0MSH0I6HigIV/TDv3IPGFLGYEHD7xBb6cL5+CoH/wO1QMPMomwD5MHkh+w7dlVoXueQUNwKbfoMR7PXvJtTtijZFX5mUI+Pslk+Uiy7fXRw2OdLaq3tCmTRodNCxS0072/83f+zqt/82/+zZs3RIsOHsAiOJLrinlFH+lhh/pWec2B2tE3b3HTvKucAlDQkYCO876fMQQOzJHaEnAkB3pJ3x6kgu5+6Dht/tHrrX+MgUAffXHGFT6QwM8IY9z6r21/OixdD1w4kB1dreNMxEOciUWdfFCt674O4GeXBfAl7efabpmZd3kr3M4gzoHsYGWonba5qjtdd6Ku6pw6GKf43sPpO63/2H5ae+msNANnZfCc8k8z6CYl7r/btcTBfyNYiepyYDaCwQ/UvjeoH/bLqh/f0yoBoOtSikSWd2Nv7QvUHqmrKED2Wiug9Lf+1t96UAgKdKDkiPpn+nJrf8XTqs8eaPavK6gkh0H1JMBRhrw5jgyxnLs0IK8YxyuHkTYxWHgLBHua2SKZc9AcDh8z6bMcdMhBiBgiGruU7NWgpfO50yPH9zZAruOVQzTRoD2ZvlUGsrYnuXEiR7I972c3jyu8V0ZkA9dfk2xujvQJLjtY0STxX+naqW3aWLV92n+jwaruiS3RHLnGC9lncyxXa/kErxWvrHRtq4dj4Sn/4CU5LUdCT6QlH2Xg+5kvO5yb7k+eZXuGZKicB7aCu+OzWydtbWfZFV1ObcnEPceYdPbv3Zq8yr8na6Ldfxt0BXo11xTOpG+/anVTnrcMJXh4mkPmhLJeJ7N5vE3q+j0PuntZ+miOmQctcDzzNeCJf9oxPiYflzvO+vYzjFZrCVo2XTLpcP9QNu2mzMrwMn6GleuN3GanD3KKgINvp6Ke7Gr64oNtydvf8sBvaATNfC4JFPr5QwRfcMadX/13ow9jwBZWIMIPtk58sN9pj/69L7bCeTmnIUEE5pbgR54N5BlbBJegg+5JNouGylJS4Ogf/sN/+OBPyGZWUEn2vmS4aKwgj47j0HlSqudbxDj3yrNgk8d8Teuh7X/+z//5YbeJHtjqQYfqaq6V7aqsHX3+9b/+1w/XfRsatnbTJ/AlgT0PdBHAVB/MM/hmGwSt3v866MicOI/Bv4BvNSSYBX30LT9QYxbPaczoXwJszCVz5oeyAwQH4Q2fY9fxfm6X84Dz6pNlLKVTdQJNcLXrWcf7nAyVnSF+xbD08qcOwyk0JfA2KPdTWCmVZly18Z0abie0n4ylyXhzQekOvb79TXMu2F1ArwzInWGXoLISIErLlbAgmiyhwJkSLjSynx19HB833hCASmNVFFzOggAlQFYTrw11pdzan2iMUNIYtAWPtzvoCQZPARDAKqdr+rjwOqHpal2fGNsIVKVP64PBAE9IKfprrulnkl9p1MlgwFhImk1PTx1y7tPwpc3MIHkbttY12jfa7cpNdfNebqVISGctadvwbk6HtzGNczfuSR/674m30slIedtotNOzJ3zY5sNhcnZa25Nun3Ce5E3DMcue6qBpnF4v+WbHayd9Nhyu1nH8dnVPbC6npQxNto7IoCWj6WQtJX5Z3stK/uuAcLVPVmc+afe5Xek+/27rdFUfWdLOmJj62+GS/We7kyyYxprXkp7uNDT9fTKu54AMcDhOHtTJLVs5P37Ys38LMgso5QRlmtxPByznyzMqBGTbteCW95Vb/+gzaZD6fGVr853ZMk0epqPrbfhcZAZ36pcmt6dtfI4X/TcatOCg402mB2fKYE/i/HNuqcpyQLUHDFRWMg1Zpv+Jz6SzeFMXr2cnqMUWKs+E8QCKAIee84x8PLy9jYOaoQO4ENDgjCno5ec7wVc8vHQ+5jcPrvMgeOp7Vj146NuzoZhfyWf5DZLZookOzpY/o10eysbnbXDCh2AI2TRkAKkfMs5yvaUNq//yH/SG0H/0j/7Rm3mkbW2PlJ76jd/4jYdgDG+/Y8sj4/ZArvNibg/067Slh8Sqq/b8UHPnn++99h+Tjh6odJkkWhCszMw36K/+OFYDWjDPLovgOV8/ngUoX4YsN59L1jjBLB4u4R/Bcydb4G9+K9xksJ3WnxRqqzMJ3mZAZvvebxPGj8X9sXCLobKCpzQSJqNoujc5RCs4MahWdRp+TQlqcSiLRoLIX1fqi1ELzpXWrv/T+XJaeHYLrxv16HNrNw3/FQ0mB1UR/b/yV/7Kw0fXdeaRv+5U+OQ5R82I8X7yHtckWCUQpWRQFrTrKb/+SVkzGZ6JhxuHE7+moUVWkZ52cA4SQUVSdvUbejQjva07XeOV3YybbDH9V7vsD3e8pj3nE2C4cGYWishTdl8K0iBtc3ta97Sv1u5kAO/aWMmtDBSu8GzXp7XZcF61M+Gf5af1w9reydrVGGizwbRWT/jA5duJfM3sBe+/4bQaT15v635VZ0eHFU4r3Ccn7wo+09jb+KQX9XRYmUoKtCstn7Pxmsyf2lvxpreDPlwFxxtfTPbGxA+retOYnOatbLM3cl6nslNfiVfDlbqTvr5iVz83uKPM+TL5BrgWLMEJ8vEIfPuZrw/Kpx1Ifb5zDlzOcw3bTeAOYmYcZZAr59O/Hf+2TS3HmfJ7GiPXcztUs+k8a6rphQzm0UfL0vLxtDqeoZ9ZabTV6vqWPrb/0A5BPR5W8jIAHpDyxknJF9mjeugnW1i2L5kiHvBrOkptqx19sLGwcwnOtGCZ23cZNCM45ZlQzIUHIuiXDBd2WRCsIdgg8BctELzx81IzywWcVJ/AHLjpPg+B4SPqCmR7KuDx7/7dv3sI1LGdmkwh6Q89XFYmE7Yq611zAf606fzka5+Azi/8wi88tPP3/t7fe7imcREo1Bmy//7f//uHdskw4oD1PCfMs5SYW5WBD8AjfUDseHxEz5wjwPge26rJffg09Tw8r7oecMOOZwy6jm6EVj4W1gx8JDqTBcUc8hZqz7byD/R0POFtz4R7tsO7Tx2AVnZn/J0YsKv2d31dhZ1TcEtbjt+tiv6xuGRbK8PwFpgMy6n/6UnSqvwKRxf0WmA6nFsLRQEm9uuiLLQIOQRuNSfNwMtrK2dC4Kf078Y59T217fcQ0npTg97SxhNoPV3QtwSOhIiUBG8ym54ercbrOLiQ3BnpLvSzj0aTkzGv5oP7ogMKmzdD8LYQ3tAnmogf8s0QKyPen3x41hJbPfxgdqfJbl5dcZFtJR4W7romPPXk6KWgjeNUVk5y3/9n+00eN4fuROdcwa/h2u5PMuIEp9Z/o03eOxmL02Vae6vxZ1s7nK+0dwu0fla47vo+oc2KB9v9Bq0P7zv5eCVv0+7x8m0deN1WXxmt2sYg2SiZwqufs/xO/15Zf6dPRVvd1TWXsyu8duMQrNb11NZOD52MqfWV87rjuRUezw0cgixcsT88syQ/jbc9EEAZD/gA+XS+6ZepH2/LMyoaH7RMAP/GpsqtKO5Ip93l66xlPPn1rNO2lHE/t1RPW/5pp2VweSaZ2yfed7YBnVR+ynDyOZI9xtEJ2Go537TD4cW+C4CAD2cKkZmjIIoeLCr7RgERz5p3HnI+a2+BywfBBEuEBwEixzEzMQkYqDxbkbwugQK2zGFTctQF7bidTWDHDxNPPvYxEazSb7blgTd4QE/PMNJ2OD2YVTaRxqFgF+0Jb21fg7YEzoRj2r9u1ybP+xpU+zpSQ5lSn/rUpx6ylIQrQS3Z7bSFLPHtb/RPQMmDeE4b6JIZPL4lkt/QjXH/6T/9p9/McWaHuZzxTEf4JbODPHPK+cbXFmvFt7x5xpwf3I5f53zCNdYK7TGelBVPHlhKQeLXIeaJo5Swcy6m/9nnSfnVuFZwD4O44bkz0k7g1LnY4TX93/W9w6cZpVM7mYkyGdeTI9eAg+C0cLRHWE8yEMBafBJQ+vjh1ZPBMRkoK8PuCq47aM5Nw9Ov8bYdHeyNgBctFEDRGUie5tm242XfO/xOnLjm2LQ+VvJiKr9yMvi4MkShii8EPPWQEk+joNFG13hzA+crCaQU1YaCedPb4FZ84eOUQpDjpw9BMVLB1cdLwU4urpzbVbnJGfDfqY92+iX7Xekyr+ftt0yZRod0XLKNCd+Ulc15bXjn/QmvlQ7f0f/0Xo43x7Pq+0TGuOGz4q8VX0zyJ39Tdtqusfo/jbnZSW2e/f6JbeVtpbxK+jaexkDVQxh9Vhm8kxxc3ef6CR+0/23cjV47nXgvmPTtSf8nZa7iflL+HnbsraDDfqWzcLrZsqIAJlsinW8dV8+wAVyu+Hky+XrxfEOTrycP2OQ9ygvc4fKgQdum1+aWdlummTt2nrkz4eb96bofWOz9+vVJdzntEi8egOp/yj/aaRlMTr+WFeTyO4FsHR1e7FknBECwXbHdsdXoU7+x4xWcITtEZfWtwKZ4UMEA2WW8bQx8ZQv729wE9Acuns1OGc47YnzYluDEAdaMG9w5c5XtV7wqXuXyjBxsSwICvGKeOdOHrVa6TlCKQIPG6XPJHOs6/eoewTbOwaMvlVFZ+RPCS2ceqT/5FCojH0NZrunLMSfQ0LeQgYuv39Qnwl/6SO37m7wJvEFP3pqnNsjioj/4nEAMOLnP59mTPCgmGEmGGFvLVIYx/WE5p9DlgssQ+CnXDPc51J2D6inj2xN9axt4wRNkLLm/kfamyxXH0fHJ5IC7b4VbGTO76yfGw1PAFaP4uRXtUxg6T2U4TbAzclvZ1ZwQJUe4qRwR1zxwL9tNXs2sJ88ckQEjwUfapB+g5orDxzQZrWmcnDpITruVQ7Sa06l+Km+NSXuQeZW0xu8Rbt6QsXJqVrCa9xMnSJBp7z6vp07m1LaXQeHwZItrKHV/GiVlKaUlmnkbje5uwHIeCamsKKJ2EN4K7+wLxU5GFcoVo1L8/FIwOYpp8KQheSp3nZ9X99IhWTlrif/qfhtnu7675u2v+NrlB+O413p0WZzlT2RRm+csm/dO/l/VXynnJmczZUnSlt85tpWDubNfErc25lv09SoDozmL2d9qfVJfT6ElwyS3OPMvnYSd/srrO91/otOn/23tTuuzrd9sZ4fLNNa2tiZ5MfFtG0Nr49QueG6b8AR0zqP0lZx7MoJ5iQdvHyRLLuenyS0PiMCfaf+he/hN+VxPXPPAUAuKeAaOB15am00m+przLJcMgLXMgcaTmZlCIIJtSJw/5IflZ7aGb0XK9TrpNsdd19phzO0gY583zwJyOpFh5I64+EL2GFvieNOWeMfnQ2UJhjhOag966JsAE4EStplBL/c7wBXcnV6ME/wzaOJ869mZBMgUuGC8tMF5UcLPz9bRf/Dzc8b8xUT6jz2rOk47znjy9UFbnunlgRcPxugNcKIb9dUPZ0hpPUt/OL2YI/guA6K5TpzfaMO3znkwhS12jIltgQT4CMxxPhZBFxIKyETj40FM1o8+mh9evkM5zQ0vSfr91z4q2+VYf/4iJs8iZO2oHr6H04v/Atr0twdSjkAltGRMyBXfqutjhIb+tkJwykPdT23Pmw7vdrjq6E1KdWWYnCjzHZ6r+vfqs8FJO5Ph87YaAw2u8sGkGBm3GF7ZIhJavo9aQt9fF5rZNK3P6T5tqg1llkxGy1S/GQc5rmxrqteefuc2qd3YdnNAe35oITRMujgddn2moeTXs83GA/xGWaGUXdi7Meh12tpaZQGlvFFZKQTxFXwG/xFsQwCj6HNME+0Yg5Q4xk6jufOA882Kt53u+kjZocwINL0UNIPgqoPm89QM2lY/HbBWZyo/4bCi/wqPW9pK+dGciOxzRcMrOuykXK7Xlc5u11f45Np0HrlFD676mcaTY8rfU11v92SOkAttq0ujx+r+NAcndF7RA+BMBjf2J5008f2VshP9p7q+ZpJvWltJiwbZznS/4bPqs23Pyv5W9JjKTzRuYz0p+5ygDBHJOF4XTmaBHFZlP8hx1humZK8IcPLaXKND3ebysqs5zayIVie3p7V6DTfucQ17wjMsuSZoeGbWUmY+UC9x8rZEVz/2QXaP2uIhKs72agxpd+B4etDHt8r5b+7x3bKlPKjkcwoNwIN2ZFupb8kptsqRmUE2jgcbyQAj2MTr6tmmxQNE2uENzbxQhwAD+GOrUj8D7x5oZEuSBwt9TB5k4Lwd3walh4jyiZSl42+wVsY6GUkKNogmbBdkzLqn/+CnMQuY+8xEY148sEB2kv5TR4FfBVhkf3KgtV54w1Ea1MU29eCN2+D5IN7lm2cXNdkp4HBzgn/CJXlZIDyZN/jdDykHqOtnd/mRFqIDZ0QRsCW4+X+/frO14+i40LevI8CznThbydeUBzm9PoEh/hMshO+gN9l8uc58HWZwl/Xma/FJD+/eKbIrhvDKsD01jh2nq3WulH8KSJr6Ajs1hNp1b/s54BZHKxW4PjIqdHaM709G2HMoGcIjjf4T3LzvKXCxq+8KhHRdN5A8TdLHnGuJoAXpnAKNk8yWyYho48nf7T+CaTVOh50z0WgytTfRUDRQeqkUJwEezjViT7eDP0khEk+5iTaTDOOVqAQzoRHfRO7zyU7SZWo/n8pkGd8/r/tkB+QrTXMMKHfa1YcnUXri9lKwkwEnazUN0qw7OQetr+n/NHdtPAI3uPIp+AqaYd7uT/i19tIRbf+ncWQbJ7rjiiO6ovmq7GoN+f0c6ykeu3LJP2l0TdDwSf2WMrBtI1nRuulKx/WEh3097er52Fe6ZaLB9H+au3attZF47+ZmZTOlI7xr51SG7eydEzwnmjf+b5mfq3G/TaDtLP5acOkz6ULe0qqtcgqAEARIXZi/09c4XVcOGfygLeeX5gj7f8aSODW+9UwaHF0fg2+Xogz3kFvenwetqEN2sxxrXcNJlr0juvqbHj2j3+1r71fgWTKNfz2TK+cFGkDL1K3ZjnAXX/gWNWxYtm3RlsbqL1txm1C8RhCC//CfgG1o4MGbwFTfD1Qm2EFAJzNQnA+oy7jINPGsNDKM3BeALvpo7GqHIyp4JT0PEoWj2tVaUX3ukz3D4dvYmiov4IFk224GL5CRo/oEtHhTmeOkoKXmQna7yoAHY6R9tqg5j/rc57pznNKWgt/hE42PByEcQM6cuY7P9eSBTtpi/jwgRGBHwSMCUgQyRSPxqQDaEEzEj/CsH/jTs4bY6uZrDP/DDz73B97O02oHv8HXp28Fhk7gAE3wb9IOQlac2FI3B5ZSmO+cphNleqLUGy47mNo/NTivwDTeK/00fFeO1YnB+9yQCjRxQGAQECD9050H3WOvrICFh+KUMFTgyV/leOpsJHi/7XobW84PQREdJCe8MBIkXPTqTTn5HiV2WhCQ0gF0PmYJR6WRKvLv0ecJ3xPD0pX5CU1WtNjBFf4UDWTg6KwrnqQIMBZ4+kEdfXw/NcJeStUPMjzFXW2TwaU5k0GrTDkB2y+Fg8rkk4hp3E1Rp6GLkJdCFt/wBhPO/+JpUGauuZGkc8BIeSYYKX4jQ+ol4FSer4INU+BmcuInemcf6RxODv7ktOQYWt3mhK6ur/CbAgC3rNGmoxpefn1Vv81f0mjHC82uyPYmHTiVnZy9qd0VDic6dKV/VvN7C0w0zXG3YEOrv1qDJ7hMeGSfea/Rv0G2cTI/TouVTer0mmgy0avp49ZOk9srmNZU0/0559O6XvV5q910L3BbBCeHV2tLD0oX63BgPTCRXsMRE+A8tYzrNreNF1Jfp1ObusTnwAMi7pCCGzarz4XrG6/r847Tl21iB7OtifOCoAFZFJkNyfYash/YAkc/age7wwMgTk+nE1kbTlOXOemge2DHdTu/J73GPPM2N/oUf6icn8/DK+3BRQEiD3o4jxAYwpbzbUD+Nl3fcqW2yGzioR/HZxC0SZoxBucd+Bd8MnuEuVMfvJ3NM6g4nNqzsHRN64X6Kqdxa80QfABH8BA99Vv1cvtT2l/4J7rG6+oz20fX5K/wsBe60AZ2tP7Dp5lZ5zyUfODnUWUgSOXZ+sah49kvQTXhRHCm2Sr69qwgAjIE//zNlYwFXmG74p/6U3/qDc1dNrB+PNvI5QC/aZ/gIryewUR4mzVHoNIzG+FveNz7IMDkL1dy+QWOyIlmTz86sORpfzCUC5dJie0MulOD+MRI3Rkz2e+JYXMKj1XOk5F265j5f4+xncLKKMogjAwGFrgMBqVE+6FpMDQLncXFOTJqgy1x9EO9lXPT+PNWOrEWJEj0pjUJX862Ec4EBTiMsjmDBBY4gFkflLvaI7XVAxrZhuOT48qyjTcm2p3SYBLQu3oIZ41ZTyY1pwhP0VRzzWHXnvWl8ipLdpgAZeIH1LW5n5wNzkPSnCmgI8ULrxFU8i0hDab+pnLwtuafvfLs/xb4K3Cbk0LQTWVEr3YG2UvAbj2tnNlpu4iDK+JpPnb9p5OW9VbXd7IinRA3mHysu/V6L72U7ezaTT3SIAN/6eDu+t055VlupwtX+nzneDeYnNGGd8OljXfCd0WbCd/Gj4nzJO8bNH3Q+t7Zb1kueWTVf6NFzv2ky3e4rMbVynqfq7GfyALv2/9nX40+jS7TWFt/O91+kq31lIAfQZYyulsOG7aV3jjFW6U440Tlpat5Vbw/eJr4gI/bB6lbfd7bdhFvJ2mb7afzS39+Fg71PaNDdoDGSNa720kEM9gmQ8aC7CTZDqKbHybsOJFpkYciqz89SMuDh6FR0hA9PW1Nopw7p1M20rSGcX6x9XjgSPYNvAAuZCmpDY1D9TQmleFho9tFHpTy32QLqR0PgDgduEZ2HePAdvXsDh76ycbzLB+CP9Ba80oAwO1MHpyqjOrypmqBb8PjbB+V961PBFt8uxvtq0890BSAS9NLysKhnDL7sbXVh/p1/gdfMpL8LWPwvNPP4wkZhGN9+BY0D1SSkUNdtkNCA088oD365iwo9zmhv8oS4KNtsskEqsM8+jrj+wdeBwPZVUOQjYAV53b5FrwM5kIH5099WNtkkVGuZSmS/cQDejLz/ABwvj0AntliGRy+a2CJvbmkCkpA+QFgLLoUuFyf7p8qtVNF7uXb71M4MRhOiDwZQlMbaUTBXNRngTTDLXF+SoNhN/6Giz5acD/yIz/yIKyIAktoaaFLaGEkaAH5Cf8CFCpK0Q9Xm4yyHQ1W9Gtl2pi0JrQ+UCIqT0qrxikFJ+WWGUteX2uL/b+65gaX1tpkrDecdgb85ECcCo1WpxnMK3BjSkE1gisaL08CebuZnoRwEJ+u8+Yzf0LFExl9ONywrS3acDz9N8EcyTY3MHdZXq2fk/WHUSfjiacNGFGkP4Mj4Epav3mK5Pdvmct7Qcq8lMXg17KSJkO1lbmiD7x88uzJeBpN29j8XnNIJ7xW7ba276U3V7LN+2pzuLq/gxO56+2vaNlok+Wu8lWCywL+r9b5yZh2kLJ66mdHk9X11fx7u/nd7u36aTJ5shUbeNkTXZjttfU5lZ34ZeKbZos1OeNlpqzM1k72P9HghGeey0Y8AZwrz2jgrBs/b1H6UQ9R/Am+9CaOor8CffIrsJ094NO2ljlvtAcdLgsy48b7yvXhGU6Oo/OJxqyHrtiTGhdZ7P5mKJw9rpHlzxt+OV9I1wnEeTIAQRSCFgQ2sLPcmWWMns2VPJfZEfThdEyd4c40NpwHi8BL/gFOPo51bqMi8MA5rAQGVF/04y25HhxQPR7i4awT0CQYQHYUOPthyAQqePDt275w/Mk84c1ymiNBHrZMv/A7fg4PpxVchWb4Pl6GYAHbAl0+gDPbpAi4kAmlB9icj0Rgkrnw84UImHCYvgd+vH1d90wYDyB58AZecHs2104LgJOZA+28XQJFmncPCvqB2syf10WmeP8EtDxDD3q2M5KYgz/4gz94sN1ZXwQCdY+gMX3DA24Ps87ADX6BTtCUtc8csGbEd6z/1D3wNmuIIC008DYJSPl8kL10t8CSggGcA0JkkJPJ3elKxQdBrzoBDW5xChyvbOsxMBmfzaBdGYQNJ2dYoqUELdjyk1vA7kHfFW630jPHQqDFo/riK2WsyEHmMEdSNBGoKFiUKhH6DNaA2zQHJ/cmQ2GiESnKRM85dI83OCAkcl0wbwhtynAdAXYCjrOn2jbD/XRuE99dnbb2JxwxVHjdqwBDwN92kPjyREmAcPTDqj3d18fQaJDG+ZQZdGV9uRE50cfH43Pse5nTgJvwcCWZY3wbYHJkT/mqQTPMk7dOcDnpw3H2NiZHszkUp7hke9NcTo7q1Habgwm3K3pkV3blQJ20nWNo/TU+mpz1x/BIw/20zdNyiYfLvlOareg09XNy7WqZts6n9Z78cSIXJrnS2ms4rORks12v4nplHfl6z75Wdse0Fm61kV8C0F9sQcIR17Z4zlfCSWL7BxkT+q8yqt/OFMwn7a6b01bBHuE7gx6Ob+M9dwwZB85us+uznoCzcji0nOAajqLjx/k1ZO7IH8PW5FXjaputOTj9qo/Dy1vRoD3b5fxgaOc/t8f87JkWQJpo7PxJO36+lNNWeJPQ4LYS7ROEwvGHR8i6kg8h21K0YYeDB8zyIGkPDIjvCNJho/u88R9aMw7ad7tOdPW54qBnzm7yc6P8iBDw1Hw4bXznENcIEvBNho0HHjwQqt9V91itAAEAAElEQVQc3i78/EEtwTTuEaxTPflvCiwxHrdJWceOv2cEeXaPn9/l6yLtnwwC+3rJ9Ul5leEcJ+bJMwI1Z2wjFfhboX2Nuw2OD54ZSswHc03g7g9eB5fYzsb4oQ240a8HZinD7oUM+kA/5pgtrGTPpQx0HoHuyS+06YFRHtaz1tjBcdfAEumI/oYugku+L7Up5ZyIySGYrjlMDslOmaZyeAnlOxl7uZhgNNH7Ix/5yMMTDF2DEb71rW+9+s53vvMngg73Hsep45dzPAHjkaIQOANjKGicUgbsl9UYJdAUXCJii9BQFgsC0KE5ZqcOHgLI2/L2J3ogxDhEjeASwkBnBEhJ6Ylb4io6yCjS1iutMfbBa9wKsqHcGs0bjaEpQsSfIJ0KhUa/xzhrfo99vTxBg9eFK5lGCD79Fw1QYLrHHmoB327skAbLtklPGUfh+0GgSVM3inbz3xwBDDfeEIHQ97RcL6trMnhQQgQYxduNv5uj7vNwOsdvA+ycNh9r1rvVmduVacZw6/dUz6zKZp2cu9NtKidlUi76OLOtqWy2N/Wzw7O1l3rkdNy5BaZ9e98rnNs8ZP1Gm+y/8TH/3dldXWt47+ZhGnuWo2yuv8bvjYfTnpvwyf6y3gmveLmJrq1O6zfLrWjX2lvhO+mSvLZq13mnZcg2W2cad6v7NuoIP2CWbF1lMGPz8SCVdYJjjlMmR1dBGNmNglyPQK6ndGo9AOX6P2WR/8amAHAAsWf8ftoTHhjB+fPDgX3bjgcvBAoC+CHKBJRwVrE/yIL3TA4fL5k9KkdmDFt4APWRGSb+zbhdhk38PQWQsrwH2sBHZfzV8NiRwp0zozxbh3K8yY0gFW+59Dniw1yojOjrZ5vm2D27xOeWa4wLn42tTwSR9F98Cy3IFGOuko/xA/Qf21K/CYaR0UXAgUwb9839TC38qNzyR3YND3zlk3AkhdrTNR37oXryW2ifcUN753XneV87HnjN7VfQ3Q+Hh7f4+BomgOr8lw/l8bd40O+8C82TNxlX+gQZkOEa6/f3X2dI+VvdCHj6GVDJ/56B6OvKtwl6hhjBJ2QBdHH/g/t+SLjvjHFZx2/fnie6+kup7hpYwmljEt3Z4zWGbX9uKtmVMlwZOQ5XnI0V3FJn19b03cbX2qC8mEJPbT7zmc+8mVCyw0R7Lep2cOEp/VYG4ITf1M9Jn6T4kgboPKE64i0JflJ9EXwyGHgVPItNQliCro19N6cr3oH+nv4JX+eYU4Ch+CW09R9jiJRtLcwMLAl4cqAACmX1REDBQ409D4CbDCZSHPW0S8aWDAUOs/bU4VuMyhWvtDabEwOOmn8ZjppvKUt9OKgQPidarjfG6Lyjdl4QTxCo42tB19SeaEmgibngSQBPXZIPU1ZNcmriI/GpgsEyjAlwKXCkIClz4X1onOILGRk8dVQ7Grdoc8V5m5TVS0PjkWZ8Npk5lWltrdr0ss2JbOVb3Qz2rPjjyhxMuO4gde2t5dp1H0fq7dRrjSYTbVe6fzeG1lfylhucDVbz7HxxUn/HL1NwYXdtVX/Hf9N1nxdkMY5pjo/yjTareUxecXynLMw2Ps8aSd5t/Ngc3kaLiXeuyNlpzK4/JtmysgFPZODUd7az2mZ8qx3wFOCBDM4blN3LMQjSozjA0ueyexkbQROCIum8MsYms3PuV/a4O81+nd8+554t7u1Mv31rDMEAP1OUh5YeeBBgJ5DBn1kdoh/OIMdL6LpvUSLzyR/ocTYRvtwK//Y/baeUOV4ngwr5kICzbGRTc3CyH0Ltb7yCBmkr4i/5+aw44xyCDh3oEz8rs918nnNMlPcH09Th7EzG6m9so56fweNHfJAxgt2IbwJd2K5EwCTtSz/Lh2MXNMcZXCNAx5m1skdlp3N2p/qQzaz6ug4evAEOGjKH8JvTtsUDPJMo17DLK8+8ShnJGw/xvcCNh9esDX/YTx/g7IGuxIWgndt/+fAeXiBj671Wx8/JyhdVAdTx8TNWP/7FzwmDno3urD3/+JZEnwP+59lr9IP8yAPqV3Bckug2WQA40xL87M8Vk+njxIMBJsG9UqY7Y/kq3KK4d9AMdibPUxF9D3gaGU1YSyko00ULm8WPIOJQulSQDa9Gg91YrhjBuz6dyT2Dg7N0PHpK1oanhqo8Z8icGAMr2DlVnIkkwSkgGOBPbHKcui58JXQV1NE3TwpYM8I/D+/231ovCiQpAMETE9/mtzMIoa9oqqcJesqgclISCs5w8OVJtHlycG81RMFN4xJPc0g3Qkt0UQCNPck8dVOgzc/ccsAAE7gDQtBRa4MUasebNcmTG9Hbn+g0gT85fX7Pr4l/eMMf/O5ZnuKndIZ07d13331Y1xgcvtXzFnhbHIcJVnSdnLKdTNsZvVk+jeCpbM7XDna6ZRrfVVgFABKXFpDIazm+9hR6kg+t/mpMSdeVXJ7ackfEx7Trp7XV6OFjOrUbWgBh6muFe14/4Y/ka6/b5t7Pv5jwnvTe1PdE36bHmrzlf/LliU5qNueOdqe6bWUPXaXRY3VszlfjncYLiccJzk8NPIDBkWHrjda2stI5Z5BtW/6GKF3XQxnpTz+81seemUiMN7O43cmiDN9el7JZ3h1TnNeVPcE64dxaHpy6HSQ7kDWKneIBDM90YusVWQzY0gRjcErBjYwe2iZxwLOAOM+o0anRxOmR4HoEm83fUsVY8qBi2YAERHghjmeKeBDGXzUPT+GnQkfK+tk5HljAT/G35oG/rzUPfnAdXHw9cR4oDzQ9c0wgG51MLDJV0rfDjwR/1gnZ7c7rzjPQlXO2CCqRoePZUWRTkXUDH0I/ssHwTZQk8LnPfe7VL//yLz/4/D7HHpRxfk9b1unpfmDKJ99aB12gHw9I9CFgxNqDju4jsOUPvuZYjdRHmbVIUNKzyXI9eFDzvZbR5kEft0X8jFiA+ScwxdZff3BOwJexepYVwTWCl56N5/h4kMnbzvmC9s4bdw0sScj7wboasBiVg5fVqSaNV3NPRkMq/MkISYLfA55SgbpAJfIv2uBUylHU5HjWwmT8INx8yw+LxfdaN4N/UmK30KAZ/qv5yrJZBuWHAGURwdgI2Knd9nuH/8qYcx4ULtqOprPEeEOGFulXv/rVhwDENHaByn79619/I3zZo+2vRU2BlHjkGwocUsi1dnRdARsFNhCypNqibE6CFDvHq+He7rvRS1BJ2XfCj7EQQBR9OUMLXuCVrh7Uc56nDQSjGxF+sGEqLJ7w8Aa+fN2rj2maK77TuCc9G6VPJqc+kgUKoPF01ftowVMvs6Nx4vO2wYpvV85Q0xEp005lwQmc0q7JwxM8Jpk/9bubz+neJH9z/Ux1Jt29w7X1NdHlhNYnPDPVabRd0WVFj6n8pE9aG6t7rd8THpv4Y4UD1/SbLIikQf7e9bfTrY7Lbp2s1lOjTfKary/vczVXUxm/d7q+c5wr2TXhc9rPtE4b76x0x0sCWdayu6S3v/GNbzzoTdkEcljJRlA52QSebaAx6MEUwQRBfk9bW1xnZ0aT2xSZqSRIm8L7ajrb7ZC0FTgnha0rKqesLD/vp80vdpIf6O02A04hB0b7eS607du/cHIJPqmO2mDLHZDOMTTIIFPSxrNWckuU+tIcY8P5+UaacwWXyJ4hOENZ6KZ2yfD282EcB37ja7BlkDnyB3n4bTyc5HB5z1DJeadt8BGuHMQuXubNa9iGvPjKtzDpm+1szKG/WQ170o8GYcyc5+MH2oM//gBzrP/Ci7fMiXZk8HPmkoBx6yP7lGwnXX/nnXcesvMJjiVNMmDofOMZZrmWUg66Twid4CGCsqwFgi3MI7EJXzNtfXq2EPNBgIf5ItBKkKlltDmfvef1Nd4Mx5x6pl7Ou8sJAN9Q1wjswJO85IogoGcZMgbw4KG9z1Me/ZJrHN8VOXl65u9xYIlULi16LQj9F1PlWwn0wRG/VXneYuA/t1M19UVQSYJQwpLF46+RF33SYU7QQtaC5emDn+Pjr193uMVQOKHbFbqmYQhTExEXTfy6PghY3v7VFGniujOqU6GsDHaB6CwDh6AMaabKWpLxkmNK3DQGBZcwIjJ40PBMhc11Pn6Qn6ddtrb0cYEHz3Ag487Ra7Diz6ls4kVQSUpI9PWxoKj1gcbZXuKQT9ndUCQYRaaQv0UQZUZdPxA/aZp0Wjkmfk/t8ITQU7Z5ipiOVrbjeGT/p/C2OAxXIXE+cVRX5U76czkw0W3nWO/6m5zME9iVP9V/TeZl+QnP07G1snnvhMaJ8wk/t352OK+CCdlulj0ZwwkOiUf+nupOuO7GsqPlah4c7xNotGo4tjab7J/6bU7u1H/DY8KvOQwT3syXOy3paDhOp+M/Gfc0xmkMznu7+s8B0o3S/crY/Zmf+ZlXP/VTP/Xq53/+5984/rwunSABOh1djt0A/XMbbNpYOHC+tYb6lHU7q2Uq4dj6fGemE+AOHuU8MIETywMuzvfxN19hL/m2IRw8z1RKnNQWjjVJAWqDzHj6dFr5W8mwZ3jg6ePMOXT5RUDEy2N3pc7FV9JDUd6Ypgx72dK8yU3OswIzH/3oR98EvHgIjbPN3BNwyXmGhrl1TdcUYBGd6IesdmxXfDeOlsBBT5vd+9M328agM76N+iKbzIOUtCXbXX4SgR716WeCwhu87Y9rXHceJNPNs508U0cP01VePMH5tgTr4DFfQ9BQ604BP87y4iEF9i7b68ig4RyszPzKNZM84msvg7yaGwJntKdrmk/tePB1TxuaY+ZWQSnkBg91cz1AT+jL+DIghs/h8D3bIufJIC6/4Bv6zjVJ+x4sI9joR7bwkJz/AvjUt7/ic6XN5OfBMS7wQT7lnNwlsKSUVQ1EzIcw51wcAdkaTvxJsV41sG9xRFbQlPKt9fM3AkVM644tEWSijH6uQS40leU162yrIgqvbDAtaD9YbmdYrIzOkzlxhmvXT+pqTBJeRFeJ3quuxiJloqdVfqYQbbenJN52w2FFl+ZUkSrKAkaZ6pqCSytA6K2CfSc0AhB62lKl9fX/UvcmP9c3x133lQFFkVhkR+zE8+x4dmxMbMeJhZDJKmbDiuFPQKz5H7KANSsihMCABEpChM0UWzYeHs+PZ8cGRSzYwAL0ZvKrz9HzufR1vVXdfc593ff1vC0dnXN+Q3d1dXV1VXVV9f99YcEDf9Wlty4ieXrexKS7kjg9MaRU3HfjAs0iMGBU4lu8eowrvETD0qRoVRy5wKfLK88ZH55MVeNRwpP15cmEtY/TOO3wCAzQcgpS5gSbdh+779UYdddOFMfHLNfCtZrbq1IX8cRrXuvo+xSenZEhS90Nf5Kymnfdzns+VxXKip9TODsFtdZV/9d3r+lrxfNuHfPZ6bndPKvGhenaVO+qP/XZrs6u/h2O/V3pvSrZXf21jxXv3fOVlrr+r3DYwbSSYaZ6JvhOxmKaR6f8OGWibmNi6kd9f3ct71VlY+pTzaEx1Vd3xh+jsC6qTLFuIu+YP1N5mvvoHHp3mPg4vSz4ZCiS/cu+ZtiaRfmyzitli8oX/d2FveQYuLGVnknpUaDRRoVU720NDRqLMkyNkp7ntJfGEts2VNA8Qgkvz2hsUtb1PTdU0wilvJUbvnWeZNhV4jeNXRU/4thTos2zSaoE3ic1hHjSo5vxxrhEnXh1aYjLvL4Z5uMJwuoY6RGinpphZ27iS3/SE9eAESMM7WK0qPqb/VYp5x1TUuhIYP/Nq2VuK6/l/BZn5iFNTxcNXfZLOqvGC71NzDOq15G6us9o6KKP0qR4NIzOeSgcet4zX00mrxyvbG7y+KSJPA0t8Ze6ZZ2/aQwUv0YcKPt4X9o2lFO4crwp6KH8NrQyc6PZPtcNv1V3516GYvLt3E7Po6xHnHktDeWZ7yy94TIBu3OZ4lxz7LyvPmNbybfS6yz5hzjROy9lSWlHT0hKZ1R+YsOSShiMgA+ThUHxqHAHMt32usXtRNGeSqc8VUFjJVROC/Kqra6OqeSEkoiTccmc6ySyvYQRPMJcYQISt0domvene69eu6bscJe/b1ES6AtGGmDPLPMwTpn1iTJyrTA0CdP+9pNMS7jqSV4rgXMnyGXbXT3CQfvk1yJfkrs4GBMNy+u8oTRGmuNJ5pXHgp7Qf4Vv6lcnnOdv6BU+gSCAEChNG6OddJx8Ir87gY7xcKH1GNo01lof/8VBVUpS+Jj60OFkNQf87WmGKZwyJggkHX13fd3hunv//y/llHd0RoV6r+Nzq/e81q0ZtZ4O7u73Dv4TfnpaOti9bp0TLd3Kr2q9aVSYcLKj51XJse3mXfds/j4dG+u9di3zvZ3B4WQsKg3Lm054sv87Oq7zY2U0PDFAJAzdtRP81b52v7v+dnS24wd5bQX3Do6T/qzmQba5q6v2o8JY514tOxx2z70Y1g3lAZV4ZUPlGGQyFXRDccxLhJeTO/DVwFPHx76qNFFyvqWRLXFfeUQ+o3GGUo1TepujICIH6VFgmFcqob7n75SJMkeK7QiTqQPqJiLPugHJRnTmcjG6RAXfT4ZSaeRgHJR/c7M18WpfO3qroX+JW08YY/OU3xgA9AbSaJBGKeVb7puqQvnRcD0VavGlt76hhok/catRhbZMo6DRj2cwnOQmJl73FPSVLrRI7zANUep/jpH9MjRKI1eedgzONW5pwEma0FtLIxBzIVOnaHChDv+bEiM94phXmUBcnGAMYo6ZyJsirDwjbjTsJX1JP3qBOUeYAxpojCygDuvsDGN8a5hK76mcO2l0paBXcM1UJLbjnBdfzgHvdXqHhh37YbsZDlZD/mzjz8N7Mr2bMu9y4ovfGkkTxxmmWnmStKWThrmm9CibZOGkw5wLybfS0y156YOHwgGIA2BWfbwo9EAxWTHAuuuQ7mWrhbTreFd2gubu3jUC0KlgnIROkRBlHpR0b0sPjQ6uXGRcdClOvKqI1wWl4qATdDqBeicoV2vlNUJlPgNN4ImVidVMcm2/OiFp187pmE3PSKOZPA/GU0/m6qy2DymgOel1DVa4wqXWhaEmx5e2YKY/+MEPLjt/Gu70MJzC6Gxzuj4JrN17dX66WAOX/eA3RhZgqnkBJkUp78ncZKbmVarzQqGDBU1c5G4J311i8Kmv2f5KYdQgybxF+HCRSE+zFe6neZXzvBN0qyL1YlAaTmGZ5veEq1Pe3L3bvb9Suif+ael2/VfK8JMos7t+rfqyKpNCO9U79W11LYXIXX92+Kxw1Hla18ZpjuTzta4OJ/nOBN+K5qe113e6zaIT/FS4Vjyl+518zU/nndzhY6pz1/dss8I8zZXOQNb1o+OPddx3dH46ptO7q7LidR3c03sTL6k4WMH62EXZWGMCshceznyzjiIvknJDDxaVJ+UdPQW6zbaOZjI8hVKNF+n90625XchbpwCq8GJgwAtHHQmdSc9yZRl+60Fhf7rQk1QA+WTCaZ9NmMEdG5F64ghXylF6sejtwXO0T26gTCyuZ0WnD3RrR82pk7ABA/W+7GUvu4w1YW/qOYw5MpthSmlwAAbkxowuUEeSlxi+kzqZY1HnlEq9RgZD3TTcaIxBn7VeD4bhHcYy85dmP8Wl1zOFA3V44I9jmrSVhtKk6/TMSXlSw4RGGPFP8bThHCPqMQ8oJSNIHC+9fcSd9EPREKyxKU9l5F31Xr2lNC4BB/e1JUhTlUY0KtmusFmP45zeemlsMpdx0msaevTCSi9Bx6UWeY26g88598Sz3kLe/4kYA20B9CdPahR2aTONvqnrayyVZ2SS9+qtBb7sVxrQM4w2c4tpLE4Dtmk8qCvzA6eBe1fOz4+LPEsUGsdAkEov17BAU1Ae8bLg+qmAWstKwHqa5UR48zlK7nqkC5sWVUN/YCQmKt616e9UhL1eBYe6+O36VvtR+1fHJRnxJLh1OOqEQI0BXX/r/2sEtU64XD1f/xuaxaKm0YHdHr1jsj8VrhO8n+AmSzJNXZtlStlmjoPePPTFGGMZzLUKbAoC3bvT9aRPaN3TNTL5fN0lyTonXGW/dXVNY2uFy50sF6TccXFHyp2uie4mJaMKe5VWhS9dnbv+VGVtwnMunPluLoqdUP3Y5Rre4LUqKPuO/Z5CE1Zlws+Orjtectre1OeOx+/4VZb0Bu740KqctJPw1ZCaDh8Vjo4/nfKRSZnu6p/ay3prf+q7Xlvh5JbxXrXXPVP7Xelih8OquHU0dk0fTte3a3jOai0/kUlOeGXC2j0z0c+OpmvdXX9XeF49t8LHqr6uHj4nYXCrep510buBVBvAg+xiLkb+Y0BgHXVTDYUIowdewZl3Judx5WEpp+e1+r8WZbCdXGpiZK6rQKKU4bGCbmSeGRVT5EoVatOHqEx3Hki24ca94Uvixw27DIGjKGsDp/KPp9LqCJDheRqaKObE1MMDeTJDFMVDDR9SCbY/GmMShyaORlfMjXY35ZDB2Vg1TFCPEPPO6lHDtyeVGSZpQm/ngrKYm/3A5HiowLtRqTePhhcNAuAs5xbtQq+MLXgxgbw0of5AXZmuQfrwv6FW4lHcSUu5EVr5lPi0XXUqDSgafwxV01suDYIZSkUxhYZ5lJmLFJO/Q8+069iCZ+X5hJMibj2luQuRTG+jNOqaE4hihEYmalentm7eYx5AG8LtpnHSqzSWjh62mSetJc05XtKour3GMXFqGKGefT+KNVy7QB4YpMeZY6yhL+d+ekNWvOgoIM8QbvCVkTZ8Ev966Dknpak0UstHxEf1SHxQw5KKqxNYxQ1rM5ZbiBdGoRWUgTWO9NZShdOnUXZC4Uqw6IoZ8yUgw3TMkVM9R6pQvRMKp+euwc9Oucs6nXz19xRONCkHXuvg93/Xj5Ww2cGfcCccSUtZr9+Mk55UTDxoW+HF9+vH97uY4Z2Q3SkNFpmNybcpLlRp4a8CZC72WWe3m9fBeyIcr8avPksfjOmu9U+eQjvcWUdnmMq2fdawOy38eT3jh7s+dXmZKt4nWCc8+Y4LzqrtnHPuICg4yovFRcKyU5afdqnz/GQ867MTHzhRuqrxqRuvlbLQKfs7+Lu16qTvnRK/KqtQqXptotNufDrluvKRrky4unbdvoYHTe9Pdfq7C3dZtXXKx3fXVvVM43PN3OjW2lxXErfdWryTgVZw31pW472i1ZM6K56SFic8rubDJFQn/qY5fwL79E7FyUpWrM90ZZLVHrPgzaMBgOLJVS996UvvjSHf//737/O6IldrZFEJy1Lnude653J+5Ht13DMMJu9p3MEQggIP7B7pzscUAMhAKnseEqPSnjmNKOkNwbuZ+4Wigq03FMq+RgNkmjQUqDwKj95JXEuDUuJCvQ6DCYaTyif8P3lXdrJt4twCvqgfTzRDujSyAJd5ak0f4Ca9fUgDjQfVeGJZlS15LhX4VPz11tEooDLv2GocSa+NzL2ENx3jaT6aNLTwLv1I7xxDzRgjDWDqUdKfurOntqUjQjd/xVE6NJhjVP3B+tVnuM84a9Aw8XeGSSpjM/fMcYVRlz5RH9cwkkrLlqSZNJhZxGVGieTcEpe5cazBRu8eHVYcE3UNjUoaLO138mf7nYabDKHMMUk8aDB1joMP69C4rMHrf//v/33fpjqlcIrfLum+9pN0BuhCBOvc4xlsDEn7aexLg5mhemnEkv9JA6lbiZfKix7EsAQSdU81Sa4DDEBYcGVoKpK7he6knArpt9b7kEV8wJTBj3GqeG9x/XRQrsFZJzR2968VGHOhkBg9hpJr9KsLy1q13wm1U5kWqq4PXX98R9jNU5U7NTl5tD7/4R/+4f1ET+WdujzpQPdgGAjvZCjfSan9ScZhaCDefrQDvnkORkVycxfAqa1KD1VQmnBYvX6s69bxyXsJx0qYrzDVfk0w1GdqG3mySVU2ujr9KBwqZBj77njX3bsJZukwwyxzwaxCWsJhLDxCGAsatAwM5m3S6yoXHuF9zJKLVbcIXlvX7nqnGHi90l1XzzUKbFcqjSc8q/kx9W+ldE+KdwdP106ls2vWiAnWqe6uVNxUGBOeVfjcKYx1zu/mxoqX1X50fattTjjb9ePaZzten/ysg7HDyYrXdmtJp0h2a/0Jjax4ejc/u3br70k+6taLWm+tsz7f9WlVb4V5t66d8qITmarD2zVtPI3CKXAaA1796ldfYCGXpHku2ewjlxJyFnknVawylL7j3/7O0LWOb6YM1vGlyn80MvHBoIB8oEFJhZuCfAzsJgdWiVMGQF/Se8j6aCeT+ur5kjle9KbB6IBRA3mAjTPkUnCCbJJJw7mO7MBv8JqGlypHikvgJZ2CoVDmes13pN+qhPpMxXnyczfJMm8v316jTQxm4FPvLhVbioabNJ5k4myVZkomfFcWrF7e6eWFvJ2ebF53/HgHuYv28ORh7IVbrxTwluFbnvDmKX0af/IkL8fd0xBpj/fc5K7J4i1pAIGekBXFtcYsDbHAkm1qiMwUN45ZevfzLQ3ThjmdeD+Nbrxn6J0GOw3Ahmopn6ZXUMez9UriOQ3MGbaYucEMWUwdO/mr/dUwogFQw690k8ZD5fs0UDHOaXCUxjQOVxr/8xfoLE9vywTyhpiKY3XUNDAJT3oO6akpnI6Zxi/rk6acf3oAJi2pf2j0lBbVgU1MnjrMgxqW/tt/+2/3RzLqeWNjMDlPfXIwdKvsBINa6jM7QexJym4xn4SCKphMiqQWf62rTr4uXGdq+9qyMwCcCB0VlpwkTEB2kLRWQ4AYOTDCaJntdgmqwrHq507x83vVjypIy/xx6wV2rczQcibfs6QV1/HOOsEDwg0CBTRv0nEEH8Z8Rb8nOLdvwIT12WSV7jTkyQureTX93ylo9blpHlaXSnDmLkE1lJzAslJAO8Uj6+1gnWitEz67911EGGfdwWGo8DToHaMfY9PtcHb9cjdDI5XMvxomuzHyOF4ELRc2Y7UpyVsME4AXd/Hiz6p0c79TPnMsJ0PDVDpcn/KVSRGtdU38Sn5X+9EpOCd9OfVMOi0TLNNasJpj+fxqXa5j7rWu3lr/NG9qHbfis6O9er/2ZQXHNWW3/nb43a1xFbasq/s/Xc/267y0rdX82Y11B+9KvjqhgwmX3fsruLpnOv7U3Z/WjK69eq3rY/fubn2c5uWprHey/j6L8q53veuylrI2vuENb7j7xje+cZ8fkXURYwhGDg0DJlP2KHphT8NQjmPnzdvJJZnLx+cy6S4l3wEeN3tsC/ksoxLSO8hxtk7Wc9brPCE6D1nR+8QExCp03GP99xAl5RLWfOrxkBBlDp5BbsD4lCkIsk/dhgx1IINyHfwr39W1TyXZ91OOSVk8P8o0yCjmGXLzL/MnKfvmeNFX6ALYNNCJF3PrZD4oP8r1mYvHOvXUSJkp89A4PnrRZFoHjX+ZyFs9grEDHjcTNaxU7yVluEyMzP+k8UrTdczsL+8It7jyeWkPGZHiWGnE1XCRDgN1vD2h0SIONQhSl84HpsLIsE/lV2nMMbGODJ1LbxlPVhTH4lSjniFzzve6gSv8aTxJA1IaW7t5kSfQySsyXFI6SyPNz7zgXenYmWs1dSieN2yRYh6qGtqYBm6NVho+U4a2D8nHfDa97dJoxv80hNln50o90fJBDUtY3wUylXFPPTD/kouC7mwni123QGfZCZQ7wbHWnUzuScrUJy2tGXdru5MQk/Ct6u7KDr/TvV37WolJsveqV73qwsR1O9VzwhxEK6HuZExWz50okF29MLjXvOY1l9PVmORMWmBnwQVmT6jLBajbIZeRYWSQ1mWSXNP9tTtO3vc7QXrqq4wO3Lq45DuTwnZaOiFrJYBXQx3CXcY7m1QR4UWar7tWE+wTDqrAvVO6qkJQn++UgyrI+47GcsYWAdD3ZM4umJ0xtYa38R+a0bDpQqMQBT4x0kqHKQy7O+lCbdLBFCY1kBpPTzgyz3gKymOVFW/pnlkpSZ0ytqOjnQI6tZ+/V7Q2/b9mHlYYEu4Vz1wpoBNN7xTf5Hs5dyfetRvPDp6TOrJUvrGCo/5OT7laTyor1aPuocq09tXrXR/qOlzHYUcb9b6CpSV5TFfnat2exmOSXToaWI3jJBfVcVzR2bQ+1nYrzBXX9Z2uXyuYKmxTvzt+ktcnr5ypzgmnE9yPWdiow3DhGoky7sY066yhQMoYPKNHSIaQVLrOeV6VLHGZeSyzDt/v5oZygGHpGXqTm+nZdn5c5+kL8jReR/RH76AMyzJBsuOkgunajmyAfOKpczxnPlflBa8ZBqYyqVJaQ4DEqd9soiHXpXySCcAp4nRSaK1X3LlBq4FFrxYjCkwUXY2HwqgHBx8NOKZcSGeGxH86Qvi+8rrPJz4cY/XdPAlNmGzbMbIe/xue6Cl2eoI4NirrNeyIQpvSRBoSxHe3nmmMtd+0iaFRo4g0yn09lTTW5EFTebqyfbX+Oj9sv+ZL0iCa3kJ6K2WC6sx9pWdSJtXOd7jmXNPI51yxX3oUZR1pXHJc1eEyVU8+43yT3rVv5BxwHhmaqmfc//NCnYZ25lhnQm9pWQ8+eBvPa4yzfuHPMfIwAO/l+uXHcUnDl0W6c3ydr2loch5UHvughqXJSGTDWsntSLrITeVEuMw2d8LlVFddGCRiJ5xxpxJo5043LeC1/m7hz4H23k5pWQkc17yzKiuh1w84QllFAdYjQlowyVwn5OyEyW5MVnis8HVtZH3gmkX7Fa94xQVOmQO/GW/6xK5H9RTpPAX8r6FNxqVHGgs7DLxLyt71vZZOgE2af8iSAupJ/T6v4QJhyBjxdLUEB+AOQ8ckBNd6V+NnWQnvHY2tcN0J2vk/GXMuLj6TC0221fUjFyDmjvwmhYPcdZEHVVrwGRddeSr0pxBO8dQNk16euqw+rVJxMyk6Kx43ee2saLYKuFnnigftSqWXyQA9rRcdnPncqbK3UgzrHFnBMI1Hfa+2t5pjHX47/l2fXY3zpECv4Ky8c6eop0JVcbIbk47eEraJR1UhfdfH+t3RTuKtw/GuX9P4Vrlg1c70/2ROXLPWVVrqaHknJ0z1TvOh41t1HCY4T+XIji9WvJ/wxNU6OV17jPL8889f1j5ktc9+9rP3nigYM9j4QzlPDyDDcTIBb45Z7sh3sqVzz7Xc6xoeLK7d3TxT9smTaTOkRNwaHpXhTqncGwqn54qKKWu7h7BwTe9k5U/kCDa9MFhg+KEu8IcX0B/90R9dPPL1/DD/EnUgrxouxzt6VKUBKOnCA4fSu6c+w+8Ma1IBlqf67bMm7gZecmflYT6G/Zm7BxrIPJjWZZ4bisabDDdM2dZwnsrnsy96KzneKTsZoWEamKxDI4y5clKm47kM1cwQLsYaeRlnDUoaBrKfvuvpXCmj6hXT0Xt6AmWOUz6evGjRY4YP94XZ8axjX+eIfRPH6QmjbGpCck8+lO7SoOlYUg/40YtHe4Kw5vzjmUxIrgHKxO7UW429zqOaOzUNabbjpq7zSIOuY+yz6UVliONPhleT4YfyCHBs/lz7h4GYyBqjVdKwJMzOae0t0m7KE8kP05jqhnYm6RaeSkPiIvXZxM9JOdY+qtXKgRJhMkyK+T+6HX3fz++pVIEmJ1bCclqcLFr6IUARSD0eAZkuqSeC/tS/LObnScNEZtOvAkjX7krwnN5ZwX3ShgqrnhLiJd0Hu7o6AaoTkiV82pDxmFguc9mcjke2ZZ0mOHT8HYt0m/a9Cn8KHrrZCqNMWMbaLc63lBMlKvta+76q95r5ks/qfi3eZMwusC4IGeNb66k0UPuRDPJaHApTnT/Jq7q51SkNMm69DvNAAg060m0KMfYj+yNTFzbfcVGBzhMH+S7fhtJiMPLUPwrvwWNr7L2uxsL8WGVSqOp8Wymdp4ps1+6JMtW1OymVJ/Wfrmu+3/HEHSyr+dGtkRPOVvdXa2zC0NXXwbGCteKk8opb+dWuTx0s3fNViTqlx4R/WtMr/df6VvOjG5+Kv+69qQ/Ts117te8r3O3WqokOOxpc0dMJHU/v1HancZ2e7/Ax9aH2p8NHbSfHcoXPrnRwVlp7UnnlSQoeSXruUFi7uMbaZg7B3N3HeKJS1ekTue4m/qvXXi2d52LO3WwDGQiDg0qiSnR6pOTBNsofqXDrnZSGCb3A/c7EyJkPRr1Lj3bTbpCjCu985N2vfe1r90Y54FB+o+ilklElKcsrRwBbHiVvSVpMvKYMl8/mmNA3xpprGI68nsqu72U4VtKxnt/Vm0ga8Z45mCy5IZjrWCrYGgcomXcmnRDy9K/qdJEJs8UxBWOa9IFO4knqeTKfm9+Z3Fr5Edm6JgFP+pfukoaTlsW9DgIaM3nH9qTHHNM0xCU9681i1ELmBjKflHRHe/Sf/2kQzrFxHuRJgOLQvuZJcMKTxrc0AuklVDdZqwxVPZqSVnxe24bX9JbK+/YtT3yjSIvqnAmD4XJcf/nLX35x2uAwtIr3zB+mV1+FOXkVRZiAVZ2t5lzK+Zr8Kj3EvC4+T8tVp8LV3xIjOws2CkGZrLouWNcIid3z0/s7AcJ3+TCxsPbr5khJVzEt3zvBqe5Yd799x0FFOXzlK195ISY8O8hRZAxs9ZLq6p36Pl07FapWOPNbQhfezMqfdU6C8FQ39bIQ/qW/9Jd+LMkZ91nUwFMmi+/q6AQ0YMTFGkMh9WsplyFInxMeunFgoXdRkInlDlSFqVOUKvyVljpBJsfAhSvD0MzpVRf0CVedMD/RjPNGJmi7zB9pAFysLNvdfEiX5NzlSIFwRUd1UTWRoruC5i7KNjV6pTGmjre0A61o1EnXaU9eMOGki2gaQBOnuqYDn4uJxfpdhCpdUBhbdiGpw3wOHimq4OgCYM4m+/BiKCs+U2m8/q7vd3yxUyQ7RaODq7bf8YOTNexa5axTEk/qnJTtDtYOnmvgXPGr+p33uzY6Pt2N60QHJ+vJCv5THp/XJvx1z61oouOtq3ey/q4fUx3dOryqd4InFeEdveR4n9JV4mWaf9Pc6J4/4RcTjNm/SY7q4K33d+1PPKziY4JjBX9ViFZzravnlrn1kMVd+m9961sXQ8MXvvCF+9N5lYvNTeiBKR6HXftTQ4WU61133RSsdJ2Ks9/dmKngowDy7Vqba7DP88nkybar8ml+FWUUjUX2k+eRW/VgSmWb91z77SP/wRtyNEo833gEUQwbpB09S/RESqNO0gLXGI/0tKhhben5JZ7zfi1cQ24ENr02xJGhem7U8myGDaUizX9kIfrlyVwZauZ4CKOymTRF0RginLalh5MeMXr/iMOUBTOsTLxqSBDuzONj/igMa3rxpLJfdRzpyE1bZf30VE/a9/kMTbMvyu75nh5xGRoGfIaYoe9o/Er53LngZrp4tk4NYHr8MF94Xj0uk8tLn+JMI6swKtemjuScyrxZmYw8PeDSi8y8Zeps6cmTbaYRxo1zx1qjZo5ZegFlXqufeIGG+WSCb43KhvlhDH7d61536Y+5otJTy3E0ZFTaThxIL0n70qJ8hevSYw0DFr+OI/BJn4nHp2pYshMUGoQAdUlzwnWKzU5ImoSl3cJ3sjA6QT0WlLqdGE58kK+yPPV5JyRPMMlQyVVkWBGTkMTPeexnxdct5SEEBRdsra8Z1+pE646ZzPd3wrNWc/PCpGskz2USujz9aoV7/0uXGKZgltSvpwmGT0/uy3dSUOnaAQ+ckMFvPd6ATQbsuyf0sLrf/Qbv0C2LkrsfwogBjT7BlHKXp5ZcbDuc5TP1vm6nGpaETUZO/2WKXb3ZD8YVw4whdYyD7t96Cp3QvvPRY189VYFrjAmClouN854+eNJIVRpSwAIOBKsUcvgPjOywslgCO/VhbEohLJUV/iPEAZsHHFCcT8DiDkQ3XjxHmx6R6qIvz8rnwL9H9D5mjqWOn68U9pM6Vsryqo6p7JT47n9XxzVKda1zpUye1DnBXfFmqUroqn8r/uH9bjw7mCaeUutY1Ze/d2PftTcp+RNdnfDrDtZTWSSfPzFAdHDucJfvrvpU66mwJY1P8tlqvp6sL1Ofu/ur+vKZDp8TH5r6UPu+wsNJ2cl4ndyRNNndy+un86f28bHKP/tn/+yyTnv4iUoa65yJeS2sl2xi60XjulyNTHyqLNkZT1yfq8cNJetLbwxkSWQXlW3XZGUGFdZUOLnnhqDrdj2FSlisR7lKWcn3ecacLtWAgiyCfAp+eAcZ1dy4GrB4l49hePYxjUGG4+iV4/2UNywV9x2O+WhMQOZDDkJWQS5SafU9ZCs+yFOpBKeMJg6qoSMNTxUmDT/pZe6x6zkGKVfbT+jQpOxGVdh3daHMu6o8ZpSHxlBxaXiWNJSncCV+0xMo5VBxluu5z2rM8bAYDWFurqMrZFJt2/I0wTSeKDMLq/mv7J/zJA2X4sSNaMZag3COcxeSmH1NLyHrtb0MMfS+4+g7yRecjzV8UA8o20z+6JjUhOp53/d8ztPm/uQFA7ZGnRzP1HMNaQVH4NrDsKrHXOKnOr0kvVX+Kd3rxZX0ksYzaSRD9qR7eYWRGqfl5kQcOfEyKVVev2XBnQSF1XudIF0FRL49Jt73cldE4qx5oWRoDlJaLPVqWBnR/DBIGiN020NhZMCY7OmtkfGp1+LxSUuF2wRwTACNM/SZBQvjzMozYiVoe13XTJ7VMOCY0JZW5kmRmdp1N+h73/vefQyrjOS73/3ufRjRTrDLIkwYA3k/jSr1OPuTUhfgie5lZBhPME4yDjIUdxwQeOiXBrg6D69VlOrztEOfFQ7SgOVpKAgKMvhOwNXFGqOMc8E555xAoMh6OpxlgV7MNyBsGm2Y7/zmPp6CzF9PTUlDpSUFTNp3Ac6FzsVAAUNXVpON1r4rKDJXTHpPmy7WedJfvpP8TGE0eUKn4MNPSATuiTOPWVbK30nJBXB6v86fJy2TMaJrN3fQVgpeV2cVuk8U/h3c0/xdraWnCv5K6e6en9rt1udK6xWeHfyVzupz0xh1+On6sONBE/9ePVuvT7BVWLpnax2rPq3Wg4rnSpsV9g6eLKnAdfLZqnRr8nR9wu+KX3Tr0/TODpfXPrd6tj5/MqYdDjq+uOIPz1K+rOW55567V+5MUaHCb94XNl/0kkYJQ/bMJMXpTVPXjErL8m77rvKXYVJZL8Xdeq4Lm2FDNdyKkl4EaRww1En5QplfpTCNTm6m6pXA5ityR4am8BsjDDhB+UOPADdcB4+ExlG4lpvXfDQY0H49cIVSr+1ozD5WvpHXlcO5Zv4kCjIb192w411PIXczO3WSPASFksq7/RSP+Un40jMm+5AGQf/rnc54KP/Rvsq2spayHR9+Kxe6KSut8Vvvcr14pA2Vew0vFV6NAI6DOKYtjBPUYU5PvYLSuAmOTelgvcit6VFHSa8i6rMvfANzetYwTtCTXmTco8/KxjkvnVfVA02dxvmkl59GO2GluBGdnljyC3FU9THlaL13km84B9Mg6X03dKW3NM4IU+ZHTf7z05EAW1xm+hQ+RL9QP6Gr6KoaW3MOOQcy7FYjpkYt6SQ3/uv6kScXarQXFyYPZwzVk73HXHW8T41LNxuWJkHQ72lB7QSRnXDWtTEtuKsFWCtjxm/KUNKK3AlVIJmJm3GSTAbjoFeKsMolRJNWSFzgeA/3X0PlqJeJawKvZ7HoV6Ex+w4MMHn6/ZKXvOSCO+AzjK8y7RNB0Pvmb8p4YRNi6+7I/epa2ykotT0nPQo9DNyjWRkrvUsm3HYKl9dkYHq81Lbr90n907UsMtHMbZQ7He5iuQtS52CnVEy/u77LVEgWme2K52xzJUxrWLVudyadY3xrvFwJx1kfY6uRRxy4UPP/pS996WXu8q4uunqvUWT+tR/uRuVCLg9Ixs5vBCONRJOR04SEdXFd4Uv+lEKfC5X8THjdtaRv17itPnSpimQniO7ofado2U5t80nKKYyTkpa881R5nMJgd32pz0xrT8X9CqaJL3TPTDDUdXnFn7Oerr4O9gm22lZ3bTU2HY52PHynbK1wPslP18yL6fmJPms73VrVjVsq3Cs8dQpcV2+Hp924d/3q+pZ1VtgmWLsy4a/W09Hn1OeuDxWvWX8a5xLmxFmtV+WlwjLJ6o9dzDEI/KmEAZ+yoEoORcXKdTNxX9NTUDpZ3pLKZBqP6vgIk5tfblz5281lvU/q3Er5NT0m1Du4p6eAJ4FZ3OhGz8CggQKP/IqhiegHvlnvv/GNb1yeNQejXk7I7HpoAx/16zVEf9Az2GzL09QyPE7cVPzWee4nldouxBD4zcPjqcqvfe1r7z74wQ/evfGNb7zvn5uXP/zhD+9lNWVEaUEZ3gTpyl6ZYkFc176Ic5/v5liGQaXnB/fAHzjOhN6p5OtBBb7R+8xnZWid8qmJuaULYa/GCkoaJDSiuFnrZqf6jX3wGfBqrh3HMtOZKIvmvLH/6h6G4/Ee/dCYpSHLEK+kF+F0vmbYKDDaH+dS5ifSQGuybz/CY5RRyueZc8s2va/hyt/pwKFu5Tx2HJ2faXjWoUBDTaWbn4qcSNZNcaM6+60RCT2Veeh4Sz/C7wZ80rz6Uhqv1Qtq7mt1D2HmmxPT4Q1GiTgXoGsdF3KzXh3mqXssrQThSTg+EUpqHZMysao3ryWjoPhtmAxFS2tNUMW7noZmpnkHDOR7lKSKcC5k9k2lHG8CLJQumjI+3eEkQJVgT9hKPO3KLQrWpIDYF/BCDDw7IirlJjXm+ST4a+DKhUym7yLtuBiLDAynJXHmDoGW1lTmJ+G3w00dh1ygEnen+J+Ene45ilZkFzndLS1pta792rWxardeM3nh6vluzuYnvW9yUdUSnwkM61zK3y6qKYymQYoC7TDn3E3J2Ho+zjtzcLnbkv1xEXSBcrExb5JCUlUEKt5dBCqeat8qDXWCLjwDnsQ9PeYy/n46ofBZlRPant6bFNidojkp0FOpa08di6muqd5b51inrHbtTHxlt0aewHWyznRtVJykImWeAIWkejzuhI8V7BUfK569q6ve69bBjr4m2p5wcg18O5qd+EW+UxW62nb3XWGbaK/em55Z3duNTa2/60/F8US/yU86HE7zvcJNyfCNrr0T+adbx6b2VvBO/enytEwy+ouhaMCARxi+oweBCiX3De+umz2J0zSG1DGvIW+UVLJTbsr/6X2AXA4MGBOUYZQlhDUV1zRsUJQr1DE0sKTHEveVg6Q1vZZY522fJL8YlfggsxjKYtiRsmLy3Qx3ooBr4Pa0vUnOktY7Q1GW+r/iVz1IBZvNODzJf/M3f/Pu9a9//aXfKLoYLD7wgQ9cvPP/7b/9txejWR6oZFiZeX7sa8Lh+KTin/mPxG8aJfikR5kbqIwhsl7mxQFu7hGayfMe+pThe8AobnOM6R91IHsmroRZeTLHQIOlRja95Bz3NDzkoVD2W295+y2NUTQ+iLfkF/ZH/KBL8RH+n//5n7/U4cFX0KZ1iQfrk941vNg+/3XQyFyxPuucsA6Tgef4OpbpCSjdZY4laSfl8PTM0viaeZVS/ldHrx5RefqjRR4ijLRNH9MzDcMuz9D/5DnpxZaGU/qXKXyUteQ38hedH3xOOtI4aiSSnokaGjFKUvRKo274hGNyGglxlWGpEzYmZrRaNKuAcCrM7uBZPcdHV0ZdKXUD1ahkeAwlY3eZQBiVHGAnoDGTWvJWQgoDiWHmy1/+8mUyeoQok1SjlcnVIL48Yeua8lDCQy7WwKQrp+5y5ohiQoA3CLE75S7rS9dTryVhy7wy7MiFr8PtJNRVxawzJOUiqZXX3RAFGZOwVSFlJYyflm4epbBalRvoB5dmYMVQku6e0C60xThMStsKht3zVSCenpkEjrymAOM4Owdzgch6su1OgZZu8kQWivjBAMN1E5z7HvehY7yZZL7QW7qb1h0cProxy08MhdSg0yk/1O/phHxz3ZxSzps6btn3Oj4IJvAQhErdhnkGOvjOd75zv1g9Zqn0mwL/jqd373Z1d3Oyw/9UT6X/FWxTvSu4Jtit43Tt6mDJedK13ymUk1Gg0t3U7w6OaU56UIU5SVgn8HbkO09ePaHTnAvdOHRwnMoG2f+cr7s6Ko36/gn9Td87GKfnJ7ys6tiVjg46A8+19FzhSbhWa/xKZpzod6L7VXtd8dns/8TfOnimuVqf7da+Dt4OB5bOYzbr6Pr1mEW4lL3AgWEaKprOfb0u9HBOmrSuLNVjJUuOS8e363xTPjRKQQXYcPvMp8RHD2p+682hcUePbWXqNK6lwpvhQMqAGlEwaHz2s5+9D4eDz2YeH36TvFvZQk+JDPujL3pfpzFNOUaZvc6TKpclPhOHNbSIoqxN2+gQf/Nv/s2LpxJyC/mhlGN5h9QPH/3oR+8+9rGP3X3961+/XFNZ1pMiw9YSzvQMT8NIPu8peR1fU8/jo2eRhgnDgvAG474GFZNhd+1AO+lt4oE38hX75jXf00tI+dLk7uqwjl/ShjmPKHp36c2ucUQ6qzwrw0ilYXOhYoigr9QJzSHP2n/D+jRaWH+G9TmHzJ2r7M97hkamzNvxPb2U0kPKje403lUeo/eUY0JJz6I8CS3zdaVeAdxpqElvw8Thj16458nPFHV7TwHUGyzh1kElk23L7zRI5cZ4Gg+tK/sp/qe5iuOKPEAaNF+2Yb7q/uJKenpQw1K3AHcLU13QV+9311fKxA6e1fsgC8alxZhi+FvmVkr4ZQJ5clyGAsl8dkK6xIbSx0SCaRirKyy6RWpd1qWtm2APWVYCbjIcdhDe+ta3/pg7JviEKRAuZ86lSYCtApgLrczCa7bpSRd8V3g6GLuiJTuZVfbbMCaMNRoQKTBRYl6rwaAKlJMSd02ZBNTaD/BAfifwnZZzDRs1eXSt39/d/U4A3Qmyp4K58LuQeISwjMpx0NLeufJXeIVHDypddnOxylMiXExzxxOhkCJj9eSKLqTNwj0EINr3PXfhMvFdwkrbCn+Omws2/WYO1dxuE23Z9zxpRqFbIzcw5px5jNIpuidz40RJnui54/kpKO1g3a1P3XzIMan8pcI3tbFS/jpYTnBUaaYrp7wqlbCun1UJY06/+93vvnvf+953OdEQuuR9Tj6Bd5FXBSNT5+7f4aHKE5NsUMejw8+kpK/K1H4d+xVOOxhOSyeXnMpIu3pPcbEa72ldmO53fVnBXnnfBOeKnlfr3rU8p/uf/eloceKBlX8lz8p2pnXZ/xP+djzgxVBUuJC5DH9jrdRo47Vc71Wssl9147Ly/oqnvO6zKo4VX+nZkkYLeVgaBVVAVaDNHco6Lwx5rDr/DaNLI4gykh4pRglQeBaF/r/+1/96CSUz5w8yiPzW/Dd6jqogq/irLPqd8HR02eEw8eh9r4mHTDbNfWQh7r35zW++e9e73nW/mY5uxLqALGX+GXSkX/mVX7lPbJw4N7eUuWodmxzPzEkkbKZPMLWH/eG3bahQI0sRaWIom4YbxpKNPT3F1e80MqozUlT0lVF9TrzlKWLSkkYEjSjc8znmBkXDj7SYRjTHVVnXcVO/zGTgSW/StrK57bvBT1Enpj7xrzFCY0t63agvSvf2kfrAXR5GwzPiIueiY6QnGLgQBvGWG8vi0HFXNk8eoaySvMJ+p/wvPOkppB7hXEw+8RMlQsN5pc7sfJAubFOdXxz70dagATG9wHLOyj9q5IT9Sn6b4XWJa2nE933G6KynYljalZWAUa+fLHTdInBS6gIsYYqw6vbZKYN+O9gpXCcjktl0/a5wSOC858LpZM6Jr9KbR7o/qzIJrzAw3FV/6Zd+6ccsrW95y1suBqUvfvGLd1/96lfvT1s7VSJhSjBp48dpz6MuZVjiOseqE+QnYbuDRfdH8lwRa6plWOaHZwlKEItKtjkJyt39KhR2703KQV3MpT+P/+wW+13dOaYVb6tyoqBOgn6dZ9COhhRP65Pu6Ze7gSdw8JvFCYHUuQrtpEuu3xqR9I5KDzVjz7kO/db2sj88gwCkKzfv2V4a9XKxpp/ZV4U8Crt2ej6taCsNpJ5Yh4DmLqouzhzfjOHrWfONWjoF/OTeCZ/vFPmdUpW820U1FbhdX6Zrda7WPtY53NXTzdMudKP+3rWbCm2+0+Fl1//a1jR+wAxd/tqv/dp9WybkfNOb3nShcxSCT33qU5cd9c6AO+E0+5xrdPK/SkupCF2zZtQ26+8Orzv8Tc9Oym5tr6Olrt7VnKgwd8rjCvbuXrfmrX5PsE5478atW5NW/LODo4O5402TPDf1LUtXR/e+19KAUdvq8L2CYTVuHWyPUVLBUfY1WTfrGnKY3kGsk8gO3K9GkNo3Sp0jnQzvGp3eRrk+pNypjJKeRD5HPWmgSQU8PRWs01yYwqXxQGVcjxTbUHZKedyNaqIg8LxOg5d5lfScsX96UWmcM9TJZ9LLqI5T4phPegklntMrpPJ3FWSMMm94wxsushfjiyxFX9hIRpYyYTRy2yte8YrLpraershojr15fiiZvyhpQvldryPWH+QxdA4+tK/xTjpjA5f2NHiagkLlHvyymU7b1JUHGWnsoe9GPuS81TNPejDXju/odYLu48E2afigPQ0yGtl4V7ky5cs0HDhWevMDg/SQeYUcW+DWiKWXvp733AcG+6dxSHqiCIc6le3rEWQ4YyZoT10rnRS8J1yMTRqjuJ+5W9P4wrd5V6VJN5Ltq4bA6kWYxqo0DGZ+rvr9oxdsDBrBnIPyFTfPbScNvNKvdJI2hpzHiSdDQtPZxecqXnNOJM9L76pqpJSO0lj3TA1Lp2UnAJ0oF1l2ykV9tluspzokDiduLk58dP3r4KhCSi5WelBolVZJTmFc4n2IxX9XRxVWE24nqscOwkw9ehJCw2UVAxOLgqetrUrCQR8x3qAom3CQAn50NdX45GKZylAndK76lviAQZIA0cTeniwG7l3Yso6pjSo0dovyBMP0e+qf9V8jQFc8rGj+5PepYN1dd0GBTqAnF00Zbg2RqXRbFQrj8j1Bxd0gaVBvIgUCPbtkxOn1I5P2ejLf7Dv1GDqrMOCztd8KMgoTFNvUaO0CkkJvh3+v0z6CDDt60K5CEfUqNOEq/5ilg31Snv19yvdXitl0vSroOwVvVW/tw+6dSXGt9+ozqz5Na92JUaEzUJyU2o+qbKQAxg6zhleN+ArQ73znOy/PILxPp4xkP6rxq+Ojk1Gk+z3Vsyodrk6vnfDiXbvXPD/BMtHhVG9Hh90zeW9Hs1OdE93u1rluLaty1wpHXV21rzu5spP7uuem9xPuCcZdPVM/qyxarz2pXPmkJddX11HgU/liba98JhW/1bit6Ld6LlS8KLMJnxtWKqCpQFNUDlUkfV8vbPM7ptKpcUp40iBAO6zjyBmGMAEf/JL/vM99fgMXnqEqh6lrmLumGtD4LWzy6MxBVPFavT1sI/Hr88o3GkvyXY0pyPbm51HW8tAW+s7mBEYfriOLk4JDgwh99oRik5BrhDEvjxtu6lgeBORGogmgzZ/raVyG6elNYv/UOxx3verQfTT4Kccpc6Z3Va6XRqQkPUpLOX7mm3IjVHjEQQ3xy3QsubmfdadxTLhMap2hp9IkdWLck06zjybxNlVJzhnxlqfLZVhnDfmjP+J5Wg+cV+I15Wbp18iH1J/N01u9n/jkBrPG3ow8ELfCah0ZhgddZX6mHwXf4ONJghhObS/D1aTRytfEUebu8lrybr6FO//bV+rU00gDYfJA9SVzKSUfzrEAP0/VsDQt4teWlcBd799aT/f/VBhzUGXslNwVcILXcLVO0Mjf5mXRcCGBOSFcKPLo+CcpKyGmw01tzx0XkuhBoOw0wNCdXDKOFY7rvVywuKbXBsoyC47HjsrcMGb94Ac/+P+clndCI53wCey0wWTSVVOmKuMyJKoaF64tK0UxixPZna50Jc5dgVpPnY87WPJ7B8/quZVwvWqbomt3Tba96ks3T52L1lX7h1GSuWTyd72NfMZ30zBUXVo745LzvwqgFTZPktHF1YXFtsz9VN9dKT+8C98hLwGF3Uq9H6mPvj62wmDpxrBT2E6MBZMSNdFM4rRTrHawdjB3z3aK7G7N6YrwrTypVvN3BedurfV6tr2a09P85IPQ/4lPfOISNs1/eDc07w5v9UjsDAO70ik0+d6unhVdXiOL1GevkVlWY137t4Pfd66VmVbGk+md6X+9bv8mBXQ3XtP4naxLHe3WvnZyQS27uT212b03wd/hZtXPHZ6m9zovzdP59rRK5Uuub1yveRdz19/n836tx76ptNXxSINH5XtVqdLIRcF7xiTZ1pEeCyiZhqMpQ+aJVJm8O3P56MHBb2QZZBdlYL/1qlBBFG5g0zuK4rcyih9xp7HCkDzxW8dGY4rjUj2aKi0ljaU+5G/69N3vfvdeFiMPX+JaY4HpA8A1MKKYW4+b3BotkLEw8qQyr9eXeoTGwEyq7m83CIHFvEvc57RuPdGVvf3GK5y6MSxJW3qdKYtm8mSu68lk2GImUhduw6Kow1A8ntX4wX29ani+GiYTB+oK1etOLyWf0agAbG70SI8aS6RX9RHlXz3jbVuvFpPxa8zyPb19zAnl854CmJu00nzyiRzLGt6Vybb1xjLVRt1wNqdSDQu1HueqBuDM6ZShjJnDTbj/+IVQQ3XXzDslX9Bwbn/ES4as1nzOyZsyl5djm/wvdRdpI99LPus7ejh2eem8hm3iqRiW6uJ6Ksic1n0qAO+Emg7m1TNT/SBbRc2J4s6EuwlT6Ne0gFMn3j1cMy+KTIuBQzDnmpM/67pFELhGwE5CywVBLxN2osEDITe6Q5qbRobXlSp45SIlA4FRk8hPo5ULLe1pZNGy7SR2EdvhJNsWFmN8ZTBa81mkv/3tb1/GKK23K2GxtjHhoD5fBV8TM4MD8cRzSRuGc3UeMpPQO8Fan1kpSjtld1eqQDK1dQ1957PdfNF1GrxRpBtwCD71+HHRyBh5LfjuEuZORu3HSb9zh8C49fTS6vo0FXe0vva1r10UdgQv+sG1E6/Bp1lWivmK9674+jTfdvNxUqBXbdVSabRTQK6tZ/XMiaK4wnH37gl/rIrAdD/b6tZsk8uiOOh1yhxkvrFuvPrVr76sI3UH7pq1vlNsuvuJgx2uTsezrgUTrN2avaOlVZvddx2Xa/BY509HT1P99bt7pyqr18ztDm+rtanWdbJuVbqYxqj7PfV/1a9OBurGs8N5haGb1xOf8N7q/mMX6SSVRYq4mHiF62riyt39OkYqblmvv1N56wwpKuXIuXoGG16vgqeRg2fN2+rGq8Yt4RdenldRNdxEz05hET++xzWjB8zfpExjol9xpveNfdXAVOls0jPcSO/orfKE6vWUtCoOWQf+w3/4D3ef//znL/1F3gdG8ImRhpIhXWxiI6NxXy8rCn1lfVEXy81tjAZsYFCfuNQQorFELxAiJTBKsSaR88lUH7SHAUyc6pljImNgZo3jdD7qoH8ahDTgpXcY9zTeAHcaHLkO7IZriefMJ+TpxhqtNGwor9qeuox0ngYa9TjW4QzxUvehn3re5Ma646dHnDmxEo4syKFpVLIfnoqWYVb21VPmuJaH2WRSba7pbeZGqh53jquGk8xhmqGp8oUMzcu5p4HHOZ1RQz6no0lGN2iote0/jXxbwAiNeFCY/Uj8ayj2nv1309n+5ZimB51zO43yjrH4S8/ENDiDCx0s0sAmH9NgKq6emsfSaiE9FbJP6pzquraNSeBb1ZXPQCR5nCT3VAirIWUS4JKJu0BRrwTmxMvkXJ1gcY0g0AkS19bh8046jC0wBxRa4qRNdm0St6ndSeCTaelBpFWfYqgdk04GYx1VAZgUzKpc5nMweMIx3D0A74wzCQS5J7O5RgHo+prwVgGy1gdzBQ8KDDJ3hRY+hAXqgXOiNK7GoBuLLCdK2U7BqriY4Mm+TIJw158KZ16XQacR0jmLEQahQmbK2INvmCy5t6Rt6ANvORaHlXBV++qCYPK7NKS6E4SgVT2mduOZtKNLMjSRAtxjKgw75W9Fe1XYrYrUSpk9UTxX7Wddte589tr6V+9WQb4r6Zac8KZSVRXVLCvcdaWbqye81msqOT/84Q/v3b8Ji+PbRKjw2Gdh/JzGVVhX92uZ7lfe2fHZnRfaRNcTDHWMdmPcwXZSf+13t37fipNu3aj4mPpwsk7VMvGJk/pPaaPivxuvCsMKnkl27ca6W4umemp/H6vYdpWzEuaJHyX/q55xNWyrhr4pU1ly02fVnht8/PfYcIqyaZ7Mm7CphKt8WjJcx5QYyiqZg0kZxZPAkLcN69cjuh4pn8a09K5ODyU301KuSVw6NtVTjHviLOku8Zp0ZfvA7KbeJz/5ybvf/M3fvBh02IDAqIOXknAhm2HoQB4zTUYevsJz1KPXiwoymxd6OIkL6kuFn3u8C26Q9fBWIpcT7XPtZS972aUOPJNMk6Hnjko3Mhcb0PZVRR/53Y1D2swTwczblBvD0gR1aDjyPTcd1b/qpnLyEulL/GfSbDdObSv5EMXQMp+lfT18uOZ7ejSl94/waVRU1uW6ffUQpKRpvYrUdSjgOes1761tZihqytdVhqzJtfVoq4a5DAk0FFDazkgiE6dDAx4+JNwatvTM+uMXvJScQznnrTPx5fyvvN256DjlvEzenXNVI2MmYZdPpXek93KuJu6sM6Oqqu7zoIala4Xpp1VOFmbLSojYteF3TdJ9iuS62Ofg6eo4PZuw3rL4P1Q9FC3+Kt9McCaiR2LqYbXDaxXm83mJN3NPgScXIxh5WpBlTqu+dcqY3/SDk9/w+HAhz+Pmp/GYlMEqCFGcvIZE6YaaJyLke7q8ypxluDIAFjut1BjyJiE8+97hortev1e0snqma7cT1E/psRvDWup87JShKixBU4TJYWDSxRz6QqiArj3FDSOeCbpz0TuhcXfWKAhJLibUh5GWtk+ZduedVwXyF2tZwTjxjJ3yeKoYrZSq+nuioYcqEw13/3fzMes5XQ/TwCH/TGFjmluTsjX1kXnC3Mpds9wNU1CrivfpmjrBO/HkSjeTwt615Tsn/H7CTRq2u3rrO1Xwv3ZdncrpXKvXU4Gp1xPevN/1scI8td3N89rPrv+JtxOZoKtjKhPNdO9NdXd0OD3f9T3fO107pzYyFOyxiv3TAFDvVbrzd3pqpAEnFa2kxZV3e7ZTDVW5809JbyRDybiWB2hYp0pdwuQzKrAUcyQq+7rJxHU9MjDMuwmGLKnir9KLvKJ8UUOfKPYr88UoWxtpUOeP+LYucV89nnLuC7+ljl3msMEj6Ld/+7fv/sE/+AcXgxAnieJtzQfZSKPI888/f/mm/2loUYZTsccohIGKzVk36vkNbtzAzzQatImcTSoBQ7GQ8ajDFCjWn31LwwVyHP+BFS8p9YocZ8ZH2VLPFGnM8dMo4ViZA0r8qWNl0nefTRp1k1ycZ7id9Ykv69YwV/NtmVhdQ0WeYpZ0Iu1Im+ouGZqWOpU0lPTp+3k6mjDme9IieBS3GZYmfHwYh5S5TSdiXRql9KTKhPb2V5phnE0cLk6oR69FDX+09X9fMKIJe57mlrK++p7vdvPOPGXyvLp+VM/M9PzUQKhxSC9I+VLKfTm/0xCozCbuT9eLB03evRN+nkY5Fai79yiTwts9OwndWXaCya6tqZ2ujWsUnxPlcyUsysiN0cXAAcOWgJlgWOq1qK92o3Mi+OF5vDc0WMkkDYlDAcf1tLrWp2V56ueEY/sjA+mE/gln3b066Zy09Mm4fPsKw4PxYXTIUyNkZO4MpFVbBuUOjm6l3dhN41oFtQrrNB8mWq33OoXAersFqbazKythfuq/1zo3exMQpoALszc8zp0FxisXiMTXTsFAUOI9c83wvqcepqDT4fYEF12/H4MXr8opr9opkRXn9b2Orz8kLnZ02s2HW9anW2DewSUMljS0TnzhBOZOaU4PPO5lOEblQyfr0uqZ5DPTeysFO9/teFmlpVSoOjx0/LL2YUXn03Pd/1V9Ff5raTHfn8Zgx/cnmWc1R1b9XfX/RL6axmFFG/lswt7x32vn7cTLOng6npbz6GQu7dp+1qXzEEpFeVpjUwn3O5Uq5Qs35pRhbaMaQDJ8KT0Dauic8ptGA2UHjQMmhDZ1gwpyvpsKot43wqTcLHzIC8geGEgM70F26OaL7el5ogHf3CkaK7xvYu+U1cWbOEhjeBpW8p5jJL4dOxXTHLv0pMID/OMf//jdhz70obu3v/3t9/lVkW2RcfFu/b3f+73LCaIYmgwFyxPB9Pw27AqvI6MP0Ec48Zk6wRvyF5vIyl7ii2fxrhVfXCNU26gFcWvSZfqhUULDBvA6zm7AY0xKQ1jiUXx4jTpM1K1OJX6lJWVFf1delAYAr+VY2tccOzfqNSrp6SKdauyhOD/MCWQ7ekaZh8i5kWOUHoFpAJI+3NTnt5ECPm+7aZBN3cd5lJusehKa38g2MsxO3KexUPk/82Ml3EbU6JUkbeh4kvrsn75gaEpjdI4dH+lWOsnwNPGsp1mGwuUY+04ap60DXOopmIai9GBMWhQmaSf7KKwvilPhblm8ToSeTpicFM1VXVXw7ITFrOe0LyshrPvfCYJdPbcKA7fAXfEh4bJz4A5JLp4ugOkOnP1Z1c1/vUJ0MdQyzIQwPrXiqRM8TvtYlZtrlN/p2dovkzm6sOdi6yJU42dlJLlzkB5V1jXhdqLhel/cyYRMdAcMyThXtD/Nr1S8XJShG3MKpEtwRxe5M9LBsOrjNN87xUPGnLTg4iWzNxY+Y42ndjsc0V+EGWOzc6GUgXf4q/VWXpV4vpVPPa2y4rt1DCd4q0t+VUqnPq7aXYUknZQTZXyaJxUn3ZpTn6t93rWd9a6ey/mZ/ZrWwFQepnWsKrv1/bom7PhJR9PTGr8rHc10c3cnT9R+Tv3IZyZPpa4PdVwq/F07K/4+lYm+an2na8n0bEdX3RhMvK1ru86X1f96/WSOVDi7+qZ5sJN5uv7UdvN/Ve6nPnbXpv5O8/ixSq5vzpcaepWlbkhZR6Xjym/ymWzLeir/so6EMfGY3hbClZENyDueTKbniPIeRVlOw49Ku8o8xgpz1aSXugmAM4xGg4CbsYaNaSyhmJuG96lHryu9dcwjNK2x3SZmxWfnQdbxWZVbQs3+5b/8l5fUGqYhQHlnkxkjEFEKnlimZ03Wp5Lub94lpI4+YVh6/etff/fyl7/8Pi8Vm3zUKW2YhF2PdWQ+PKm+/vWv35/olga1zKfjb+4Bn/l/Un5WvtXoZp6izmMnjawaJtQBxKNGGj2irD9x7bi4ielYdRvwyX/r/9QP/K2nXLbDNfGRRpo0qiXNZHiedGob6eGnsSgNQuJJXcpnnVvOA8Y0DTZ6SGffK12rAzlO6p2mrHEuq986Rqa6SH71k5FXTa+0DOEUd46n7ar76sEmLqvMlvOojhcfYM3T5rPv0oZ1pB4iD3KcxY/PPDWPpRMBtz5/y7unz64W/9X1qZ5VfScCrM91zDn75ABr6bXIrMy7Ut97yLIStKd++Z7wYTThukx4p3x3MPiMCdx0pZRpgxMWaRYFd76T6aWl+ESpOrl2K77rezINc0QJs5OWhdQdGD7s4sBc0sVSC779NKG8jLYaJiYFqdKl8IFb81vJRBA8wHcal2pdvr/Cu/HN7BZBK7rX0if6wGdyAz0Zi6oQdUruBH8n/DMGwET/FcJgzOYzcPxW86Yqh/YtT8OqC/r0bjeG/u9w9mJSFjo8Z/9287Wj17y3ancqia+dkemU73bKeHettnVC75WeH4KPr5TSbtxScToZp25ede3Xsd3N+9Xc6NbcOn4n9Xf1TmU3Nqf8rFNop/qmeTDdq7S04xOdzOLz07ztxrCbAx2M3dhP1yY6WdHdbg7v5mjXXsLYPfckPLjiUkG+mysdn+jqynWi46ePuWZUOpnmYO13ylATX+34QpYMGRPX6VVd6/MZ76vEWoeymAf66P2CHIH8owzEux5/nqdDZTgN/5GlqQv5MBNQ806GtahDaCRyXUOW5sNvebdRBtSBXGZSbO576Ec9OUpjkTgQl+lFUedfGhPsW72vQeZb3/rWBVfk3eMecijeQuYR1cgmfhx/67R+4XrXu951fwof1/B88jCJr371q5d63bClPmVfFfHnnnvukiIDHGsUzM1fjQA5XhqTNLBkqKJ0Y4Js01kobzPGmaRZfFdPnwyvStr3U6NEquFGeH3Wzes0wEpjjpvt20+jKzSCiUdxl33Icalz0nc0HtGOxhDzU6kLa6y1XfGSm7Tcc0zMaWUfhc2wxgwXlSY1Jtkn53kadbyWeEv9SGPTT4ShMz2U0vCWYyXM0rlwpTdXerCl15e41QtO+kxPKflUGuOcH9KpfEh9NTf1OyPugxmW6uL9NMu1bTxtmFaLcn1m966FgWNQWWy0UrqYaDjAy0Evnc7aPLVXhemd4DvVOfUzvUmcwL6vNfcWunLCZhx2MqWc4DJwSua+qTtxK8ViV5KZWHcurCuBJq9VnGWMbn2WRYYdFYUFLdfiBAbgqRK5IHT96/pex9ydHUO90lWWNmpOK/GQ9dfFKeunXhduXbllmHliR10UV/R4KoSeKmPpQktfELBgriSn162ZnTXj41dlaqtT1rrxSNf++k5VFCYl48VeOr4zjWn27URBXD3TKdkrXjrR16rtboxrP07qvLbUtnc8v+ORFdcd/5jou96rsEzrYKfk7uCvfKBrs4NvV193r/7vQq+n+qbxrvV3zz/JnD59dzV2Oxz7zmotrApgrSPfX+Fq4g/1fkdHHT6m8TmRfyYY8/1KA92a1JVKv90YdGO7kwdX/1fwPMvShbJNNJPKZJVJ0uCUGwcrz69JZqjrbYUr+UEds8zZgvzAhiFGHI0KyrvIF+bkUU5URkT+N1xND5iUWZBR0B3MB6kcbv4fPaE8dYx7eu5kSJCeS/UEOPuTJ5UlnhKnHQ1ZV6YOsI95PD2w2FdD/eyzeEnlN2HJeYZ8hnHKTehvfOMbl3sZZoUMSloK2vW0Od41uTOH+WDoQsYGfzzDu6Yt4H1zOGU4kYY9jSXK0ZWmDG10k5Vr5lt145y2xLvPanyqxjQNF3We+Fsa1aCQXlYai5JXU9Jg6HhlbqLUXTSCGraVz3bGLz157HsaLjW05Qlp1uuz4jaNHOm5Vw02NRRWI460aP3JGwwLTIcJ53mGdqaRyPxL5lT6UfF41ECZ89w60nDkJ3EmLeQ8zPelAQ2JmXjdMVGP1GiocU6aqGG40Ck0mbTmXH7UULhpAZyeXd1flSdVqCYhbBK6Vu/s4HOQtAqSbA6GpkFFS7gTng+xxZnobyX0dbCewtkJjF17yTj87w4IE+vEsJSLQhpu3IkxzMuTGExaB164xjGiTB6YLQt2uudNY9WN506gclchj533RIFOCO3qMwacxUEm5QkCxuhXJo4gAi0ghGh4keHwDn1Og08HSy6609hSn8nXjaPO4znpe41ldnGogkKlT5kh9XvChW6k7t54oom7IFWQE8Y6rrVfK0Wulq6NrItv4CHxsCdaeQKkC/IkSO3aq21lSZzpdut4Oy9SoD5RCh+rVMG0wlWF+RXMu77UenflRMmb5vKkPO/4yfTeSdkpjStamOrr6ulcnCudd0rYLe1197OdzhhRn1vNp8pLap+yvm69WMHd3T+lwWtkolomml21282zk3qn8Z3obbfG5lqxov2Jjqc2s/76u8NDhWuqv8LU0f1UurWla7/eO5VBd+tIrbv2YdffZ12q11AqMZZp3ah9SkWOkvSWGzY1JCZ5eFdSmaRkOoNal8pnekFlnhiNFcg/ei+lZ74GFAqykh7dGpVUAnPDTs8ElW0NEOaZMQcQz2C8yATP4giZA4MJMjX/9dDJvldeU8cpxyGV41SIxWcqqsi74ITCBp6nbytnKn+nLNjNG+57yI+blvRX3Kv0c++1r33t5ZAWdDBwjFcTn//+3//7JQxOryYP3DGNgXBpFFSGxUGAHFDAg2HI3J3SQR75ruxrAur0WDMXjvSg9whtpKFNuhIP6gcZPqZuAf4qv/S07TrnKl4z9FB68LryqWNjuhLHOukmja/Svnlk1YX5Nhm6Y5ZJxA1LExbrFUbxkG3zjpvZ9i29isRF0rU4TJpWP8qcS9Kc9M7HhO8/80J4YOJc+klPLQ3EtqNRy77btoa4bD+NS5nnyoO0knd13kbipNKo+n3m981+PKhh6Vpl5RoB62kpQjtEnCBqEgRWz01CRDJG3VB1gUtLrpM8Y08nBWAnrO2Unkn4nhZzfnuamUYwChOK3QKZxQ5XTkSt/MkMdeXjXScKDAcGwQkOHl0N/oDBZIaT8H2N4pXwwRw4ipQFg3Yw8hH3TR93CovXjIsHXgxFultqLDAMLt+BibI48psFy0TS4JrryThW4yrtyMCqMCC95fGdKaApFOTuEtfoA2PBc57YV/uQbeSxvN6XqaU7eS1pwEr62ymV+dwksHeKSdaXrs8TDa+E84kHdO/YT3AEbbPIsvBSoBMFTAyKLuRZ34kC+SzLjtecKINTvZ2ia92rZ1dwTTSwKxXfO166aqt7d0djt6yb09q72tF/6DZPnl/V032f1rMLf6R0sD6JvLIyKtRnOqPaBEs3l7p2J7g7RX1VJro9eX/ixxWvE63sYK9wTe919L+bY7s5UZ9NOW3iB3X92fHv1diu5NFOlnvs9SGLSuQEs4pshgT5fKWpNOZ0hnKfqf+n8Le8VmFTOU1+koqt7ziXlW/1FFD+y3CdDPHRG8bEzYZRmeBZhds6xVNufBnK5RHp6Y2envBuYiJ7IM8RBqYHRJUzE78pXyaO7EeVPVO+TFpEdzC1gzKzyrY6gmFMmU/KYk4YjFMk6v7iF794kdtf9apX3W/OoiNk+Bb9wyP9zW9+88WY9c1vfvPuBz/4weXbvE4aS/jGOJN4tD9cB2/oCMjqyPP0xY1I+6DyrxwMnt0wz9ClKkfTPmF81K13lZ5bljSaqjeJ9/RMEu+ejpYeeDl2yufSiN5ymbxZWnKM9W5RT0lDUraROBCv1Mk4UTLUzpxJ0kTiJT2tUnapcoHhic4X+y3dOAdqmBgwpoEp6U9DYBoZpWWe/5MXDI7q9c5LcZDGRXXc5GfpvKCxSBrK75x7Gp685jxxPMwFZV2+r4G0M+yrd1ZvyafqsTQJS3ltpWA8aVkpjbcISqdlEqQmRXUSpPjWep7WexcDJ3Qy5anfO4Hulj5O7+qqSHI98yFBdHh3YEBJhtLV5cRy0cQtFQ8k+k4dLDKGgGmlxqDDdXYYZK4uPPzHyGHM+UpQ3OGpCg8wu1e+8pUXRT9PcsObpfMcyXfzm354Mlh6otCnNBLlYsv9xAclhZFJ0JRZJG3pPpo7HPZVhiOjdDfJ3RZwAMz0m8UZvDNeLAj0gzFnp4f7HR5ZQDGidgJknqqSwkYdM2OPq0BWhZasu6PhnQJa36lCaFfXTtHYtW2/PfYW3GbidmAwoaX5n6ZTDGubL4ZScXYrP0rhpBvrDhedsjYpXB3cp7jsFMXVs6fK6i246uZPpY8JL6v2rsHHbh5Mba3GtlPIV/BPbazar7De2tfV2E7/63is5KsK69TvUzrz2bprXcs1+O3aW82ziocdzHUcE+5pHengqbjq5kUH06rO2m4He713zVzfzZ36zI7mH7N0tJqKj/kpUd5NEaF3Tr6X72bdeT89ZShVHqlGppyLNazGtqoy5v1q2OIayh/ru3Xr3eFGpYqkOWE0WtBX5KvMP6MsUJNJa4hSua0hLHpRqABzj3aQPfhm84rNU+XpxGV6HqXXh/0Tn6n81vt13aUeZFw9gnLMVcDtH/1RDnRemr8To5IeSMipGIu4zz2ucY+23cjHAGX+KeTs559//u5LX/rSRU7P0EQ+GmbsjyFxGiDyeupBSd/izIgPPcPEo8aWHE8KvxlvdQc9YTKSIDd9pd0aNqVOpYFIeT+NXl06CttwQ1z40uiicUY9JcPtHCfb0pDk+1w3HQxhiG60G+Eg/F0ur+QZGtrSgOY9jUn5bhqq80Q3w+T0JMoT8NQ9qq4lX6m5n/70BVxr9HG8KXoH5lypid95XrgNV1Vvtr/CkjmWaC91mNwk11inMVo9MfEhnmwLPOgwcrqG3GxY6gS5/H5IAbmr80SZy7o6IWBXOiHBa1peXVySkdcdla4uBopJlMeSOtF4FuYEk+piGq13p0SclJ0A2V3zlCtglEmk1bMruYtk2B9Hg+KSyqJAHewywNjNMwR+ZKosIIYNmu3f8ZAJn+DiRNjORcudCPvGbwxdGde8w5+TG5zRJ5+p41gF2zxhJOte4VjPKHZjtFaDQ/BpUkn7J1yJF9vkWfqKYEM9GvRYGKhbzzrGQmEvDVf2m/GkUA8Lo89oWKuhk7VvvINgAI0oiDD2Jv6uHjyrUoWa+r97fjfHphCiSVnslBC+9VSSxpPxa7RTAMsF/2kox09aOrx2xoFr6ut+d9dO14WHxNE0vrWdlVHhBCcrZb7unFfa6+A5ae+kH6dwdu8nXUzPdr9X7a3avga2LJ0X0YmBYJKTumcr31jBeI3Mtao34UuFevXsJEtV+juVxVbrcTU4dDivfTjFc/d+B28+N5XVWrKb26dyacX/6n5t9xYZ/FmU7Hd657P2Icdg8EAGMzcRm3oYDZBnkKfyOPikgcwh4v16rb43eT2sPKAqb8g5UPuo1wT3WNOFXaVU3UGjjjKAiqBeIchCKvd69xjuk4mjp/D5DLlTFke+4zlk22pU6vBrfdWAZN9VtqtxKXHq+7SHLoHs4ziZWJiSsj5yEjKop1Iji7761a++xxeyLhudhvwR2kbfeAYPJj5sZmNA+9znPnf3r//1v76cSGf4m/KkCr76huGHXAMuc5KqFzA26Gt8cuOz9lujFM9k2KH91agoXWhU5H3644nc1pE5Sn1PuJIuDadzfDTeqANUIyvfOg1As3UMpef0Eqzt6YVnv80XZUoRnrc/6EVuvtumYZ7SufKw7Zk3S3m55iISh3w8Fc561KvSgFdDwzSUiRu9fXhG4485sUxGzrM/80Lqj4yq0VBk3XrEZW6j6kFm373nO13S9ZzLruE195b1Z4irhibeE0d6eNXoFuF46jmWkgj9GDqTzCvdM29V/HbPXwPvKQyTouDR6XwyjMucP+mmWNuW2cIQWCAzCXW2q5tkEk8VxjvYT3DwpEKGxOkCkIvppMgkw+GD0QJDkiFVeXqGyftYIMQlEzeZlxZcjyKdhMdOEO1w1d0H/zANY6fraQI7RbkK7J3hrQogk5A9KYr1GU94y2MzWYz5ZicqaYpvcAezl5HpOg1TYgGWwYNn3tVDTAYrc+zGXzrRWOjRuRTzcdUT4aoi4ZG9GQdtzDHPMd98vyo0uUh087gqP1UZ6ca3Clc5Brt5OilrJtjUM4n+KUzJ6Olvnri4Ulit87FKxePqf75TFdNV/bfwupP1ouMXK2X6tP2kzY5eJn4+0WTXzgluV/WvyooXdUp81+ak9J7Acg2fXb1/0m4nA3QyQQfvanw6mFb/p76ezJUTuume3Y3b1PfVfOz4Yu1LN7863E+wd7z4lGZO73X8dqKdE/50ixw28f/KX07qWeHgWZWO1lSQMBq86U1vuqx7nlhGQR4zDyEGJr03XC8p6aHQ8YdKa/zW8JShXBXGbCPvJW+xD3Xe6PWNfIb8by4T1/XMe2PRuOE11nWf0QvEtlU6gR/84JWD/KoBQw8EDRK2zzfeIsCG4S6NIhVv2ddqNPI70yqkEms9NWeVx7Ej+1s0OCnn8zzfPIPXl2lEqJ9QMegF+OmL+oAe8dSNnEioG/QCXSEL8zzf3/nOdy54MpemRjHaY8w0rKi7QXd81H3cvM0cs9nfDGFSb6rX6Asbi7StR5q6jYYfjYn8x9AqXHr9p2OD9edHA5n5n/JEthrNoHHBMXa8q7HMe5nDp+oDjrnw2i/p19xflDRoCJ94NmROnZsxdUNbPUS9QKOKxknxJu5r+Jr9d04YHeE74kVHEGk2+QS/0bX+4l/8i/cOF0bepPFYfPC+99LrSb2q4jC9D/mf4YIZkmff05CWczHHRxirDcJxVj8zjK5z4ngww1LHlCVcJgeDzwAwyQiZMtnwbsG7doHrhL0nrXclZFIYAHOgqLg78DAbEM8kqQtEWv8ksEzKbdu+03kk3CKITH08rWtSmOsuSMKXQk5+nCziMONMnbAweONZ0/srj3V0shsuloJFXeArfms/pqK3DcY/YAUe6FlXzU7ITDxMAvpUqhCSfViVfAd8mhjS+Fj64clv0mW2idBBSeMS19wZ0tBhnTynh1m6VU7KnQzQJOyVhrKPOXYKKOnRp2CZC7zjUcc5aS4XhoozijshGXKYO1cV3+JaRq6wUGlvVxLGXPRdBMwvplGvSxzf9Zv3ELxeDCVxPfGdem2lbFLq7tpUunp3z1fFtgrPnTJW4VzRQDd2q/7vSvfcSiGeaOfWNbTyrOxTxVUH5wTb6rmp2ObKWLB7f9fWLTha4bajuayvW8Pq3JBv3yoDrdqY4Oj4fR37btynObRqZzcfOpruxnGaJ5VuqxzR9WPXh6md1XO7ejp4ujomfnTazrMuCavGDxU0892wyah3BusucggbXzz3/e9//16h3/V5mj+27XqcNOx3XXeqh0bl+1kP67YGDr2vTcacCZDNq6psnEpzykRpQBNn3OcddC5DVzTipBeLIToUvSuQo/DuyYN5su9d/xJ/Gb6YhpVUWFPeqrIfuEHu1Ku95vykII8ii/MNnODS9Ay/9Eu/dO/xAt1oPEOfoCjD4pGFLEydGpU8fTvH1v5obAIWk56bl5S6hVHvFfuXoVtp6IFObSs3yg2BZDzEid5oerdZj6dgu+FqPiDpJ40Jtg898BvdHPrLFBzpvWT/04CQia/tk/K4Y96diGbRQCUNZRhd5tcyoTl10Deepa/qGXxITfJrv/ZrlzH+2Mc+djn5L+HQUCXc6ud6kflcp5snz8/wvjR2Sc+e5J6Jt73+cz/3c/f6jXMc/Ns/7qXjjThJw2AaxvOauk7O4zzRsTrypOcaH+lLniDcGrAdl3QaESfynmdyKpwAAxQIxQvFOFiYv0yQyZtAntadZVrMV+VUQM82V4qb+V4kLK5leJHHVmLwSG+eSYie8LESiq4RUJ4UHx1MnRBW7/tRaYcWoAnjSsGhzD5dCt1xYKFLizr/wan1MEFhuCwUNQRrpwRN41v7Sf3f/va3L/UzrrTPot3lKpramur2mVOa7gTsim+9XvRuUSnWIl6ZIIW+gHfdbVWmZaiZ4K4KYS68jGlnJKrMuibgOxmvFGp8zgV+eke3ZT4mbqyGbet2F4SdMBYzeRXj7OJb4TTZJbjW5VzazSR3k9Bfi4Y3d8c8GTHr8kjezhuy0iFwITw9dun4RVc6nFw7r26FTzro5vI1vPVEUaxtT/Cs6KeGcnTKcVdnVyr/uKZMa0BeO+Fp17axw88pH83nO3hP+3Bi8NytFRP8nWGhwj7hfqoj4am/8/0OF9P92tZOblvJWBMuur7V/nV4P4Gv9muScyY46pp3UvetZcWjdriYeM5jl8z5wbqHR9JLXvKSyzWMHXqumOhYeQbDkkYCEk7rqdJ5FHU0l/JJJ1Ol4t/JtqnspfLmvfQa9r8h/Bo/Uq7S4EBb6V1gqJSe2soItpOeMuYq1cBgv9K7yY06YEBWUL5Ir6+U8youxVkajdyATE+PxJ2yn33S20hFG3iR8ZU300OduoATmkDH9CATvnlfefcXfuEXLt5LpmdAJoMmMkTIXJY8x6axybiTDvztpqtKuIq1J7R5j34CQ55YJuz2WRrgGeDKHFJGF+QGqB5FPIMhyM10c/DynM+4KUo9mZIkQ8T0EtJok7leladtX0NFGpQ0PGXycfukEcR+1jw9GoINrbONzGOkM4E5pICPNvTe0tDEPfJlve1tb7v71re+deEPjFMaK2nXvFgmn3b+qdPUMU+jrvhyk56Sc1WDk/8N+aMI/8/8zM/c54JTbk+vLnUF28wxq8YgcVvXI+ec42C/7UPW7fP+z8gbPRrVhyjyj+TR6pZPzbCUAoKDAkBMeo/ANJYUgBkgE5pVBTQRddru6fV676SdlfKTn8zWLtHIvLv+TW08qaJ0i2AwGa12Qmky3e6/1xJHjH2eaABDTyOGjCPjjl040iWXe+wwGF/sSXE1R89UTmNDs7jYYRU3PCmT5tWxS5dT36+hXrV0As/JmNZnxDXCQhrf3Mni+TRK5Ps1HjwNSi5ohtBpBHSnjcU5dz8qjFVg6/rfXZOBU3eejCITT3hzgVAwffnLX35ZjHgfodPdrORdGr8N+dOw5CKG0bIKlhqVjJ2muLCzgKQrdKeQdUVjlt5gtK8gpMsthi4XgKyv1pt4ejGUTiFN3Ozo/YTnV1zn9RV/zR3lW/pU28r7E+/s6rnFKNTB1D1/ujbeWqb2JliuxfU0PtfUszMMVNydyAjdOnky10/4f72fbexov1OCK0ydIWJqf+pXh69Jzpnm5Ypeu3dP5vctfGC1RnWwTmNS5aIVvU8Gj+5+/l/hroOlw0Ensz1WsW09NlBeCOEyQbHfmXg4ExizprPeI4dkSgTlhxoqZumupXLnMxVOv1OPqTK/16b5pteSepJKrrlYqseCSqXKr3KASh66VXrSVw9til7V6VVBSBhwiCMTK6uIJ1xJd8LGfZMlK0elHGT4jAaF9K5QtsQjzRySegeZIyrTOWAMAlb6jiynJ4seH9/97nfvfvmXf/lyj7A+66Qu+qVsxfcf/uEfXmR6oyM0OmRCeD02DK1SsaaOzJlD0RNFY5P4zETS5sfR6ObYaSzMMLc6V1OnMCrGujVI+Vs8+l/6krbNPZWGQL18cgNXmTZTZ1ifcrYboNKiYyGdaJzingZMDXkaZ/T+Sk85ZVcNh2kgwZD0u7/7u5cNf3RJ+uHGtnA7hqnzaODSQKjBSR4hDSQMyRsysXY1JNe8Tj8ZCbyNOOCe+hi/03jkO+pXztfEoXM/6UpnHo2D0kp++7x126b1Oc+dK8LiM8n/0jD21AxLyWhFrrv+DhZF19XO8p31PWnZCY/XtLMS9NNlrYa1cZ+Jo6ti975wVEFhKql8dQLFNQL2qRBb27adSdjpCuON8k08NMYOGAjEj+GR91SkXTS5Z14lF5s0GOnVoUunE7MLVToRmqqAPAmJjqsTtyZEy3mg0UHDjrHDukFWJWAa+yq81NLhXTdax8yY7xSSVkauxIOMz4VSYYYxy7pg7IxVDc+alLRKQ50RNnEADAhMLr4ZEsd1YMrx4B1ozWNmFU6gQZMg6larxyFjZcgf3zJP6DRdpCk8D03DzBUMktlrCKvjXPFQ5z8F2Fg0PeHEBVvvPT7pmrqaeykcP2bp+j8pm/W9SUnt/u/m0ZOUiTeseHCd4/ndjf1qPk7XpzkzwX1NST4w4XBSdOv4Tvd29Wcbta56b9fXk3nYrX1dW92zqza6ax191HdW/GNXEr/+7+i29mda3zv5o4N3gnM3P6c1scJ8DU5u4QlTO914de9VOtzR96pMc6STHXfy4K3y4rMo9oH1lDWXdZs11BAn5WjlPgu/DbvhXdZxFVHrTU+RxGcq0F7PXfwaipVwZn0dT8vnVchT96FuDWLIGx6oomKbYWRu6in/uKmnDGOO0fS6SZkxf6tcgjNPmzNtCdfBHbIHcobGhOxjx+ftVyrFOhTkASQ5P1RkNa5kmgllNIp5PfnWQwuDHPCxyZabd1wjf9Ib3/jGCw398Ic/vPfkUflWB4Gu8HQhBE5vJmnI3EPimII+q+ypsUEDUHqHKHMZocN12vUkaWDWiIV+iIynV7l4UfbUGOTHTUbuZV4djT96MnnP+gxPq5ECGkeADXmWcdc7yLbFuzqW71G3RiBhl75sO+eFHnbKo9KxY+sGtSengTfgqR5tntSHzvGVr3zlYljSI02c8a1sD37TsKORUprV81H6Fb81PIzrPutHvcj27Js4+4kXDGjmSdY7yXGpvKfmSqtroKGwiXO9uoTfuvVwTKNvzlVxpSFf/KYR1GeFWZpWZzopD6J91MVUS7KdyDwolVHfutDthIyTBf1E+KgMlf7A4NJNUEbEIGXOn52we9r36blrcXei1CV8q/+dslAnA8zcRUbXWycIDB6jC4xNQwG7Tuk2WNuYlMtdv4StLoydENvVn6FvXVvZXxaLZF586GcXjlXhy3pTAPL/SnmT2WiRd/fJd11gJuE5i+FxwC0jMfEkAgjM3WdqLrGKbz+de7owpIGp4oL6MV5R3PVQyKgGXO4xBp5AR6FdXKRZRPFA4uPuml5y7grojktJgYiiYJGnr+ROB8UFtIZmdopKXlcgdBFKvLtIpPFux7fkRS/W0uFmxcum/u7esa3T+rqSu0oJf1dybtU10fsnPHsHXwfTpPCftLGipxXMdW2cnpn4alU4VnjteExXd1d/d7+GFK5Kbb+rv+Kz1l/Xmqx7eqZb+zo+0t1PWLq2pn6u/k/rT4ejWkfHA1f/az9W62IHxwTbKd1P+DnhOV0duznU/T5tY1pfahvT+Nwqgz9EoX3kFE+HoiALsn6hYKrYqZzlTr+JmXmfU79YfzEq6AVvSVk95XL/V3j4uDme+YgsnRI4yZK5wZ6GK2A3iXd6VaT3gwan3FCjbr14+O3mVz6bcAlLvmu/kOU83UwZHZwbXZJ4UlHN/EHZln3SaKCulMptJhoWD8hg4MF8mdah4mufeBd4pQE9bKQHZESMRe94xzsutGQyaGRGQ7joK7KrObk0fKXxRHlUGuCa4296AsPNNIpIo3wbasY3/dJ4SH20bS4b9B5OxbZeD9ZR1kvjQI6lxgDzCLmZ7DglHbrpKj1lEnjqB0cemsTmq6ctM/6GeEqTGsXSAyo9CMVh5hDS4JKb29IyhXGC3hxr9SPwZx+do4aDSsd6SEkraTATT6YGMZeRRqbkO2l4kzYdS9sUnxkup67APWhJ70PK/33Bc1JaSq8o29ZjalrnnB/CZbuOo3PR8dQglnNP3Kcem+ORm+I6Johr201dJ/PQPrhhaRLUQSYTlm8IQ4OSx8bX8JVVWQkGD1lOhfCEi34w+SAKDSeZI6hTtH13pQSshIpbBJ0ThaB7Z6qrg+tUWHSXwvhkdyDYZVCYwCAnY61GuSpc7/pXYTd210UxXQ5TOVkpItkf30m3w7TOJ3zmkTLMbxJ8KdTjogSMeSJEttu9mzhzN4N7GitctFfKiHWDIww3hoUZqiWj1xU73aW7krHVWvBlbrXt6naZ/QV+DEKGnjrfKp3wjqcMWq87PhibKOBUN3DjuMWZ1n4XoVq3iRJ1I85jWmXQCiGVZrs5l7SQgmTdYap02tGrOzV69mGkfewy8Zmq6HT/r+FLt96b+PSk+O+enfjTpIyveHe+d8Lrap92a1sq56dK8NSX3RjvcNjVn+3UcNT6bFXqdqWjtfpeNXStaKKOVxd2fYKLWk7GvKMx3+3ofDcvTuSJyaBRr+/w141bJz/s4K+0diIvndBnXe+7Zzt81Xon+Ke1oZOzKkxdHV0/n4Yc/JBFJZGNHuYN63E95Yq1FkVcZdq1mOc0IpF/5wMf+MDdZz7zmYtHg57Uynqp6KXitaJpFcDKZxK3dVOso5H0RvI/8hjeQvRDIwd16dGRyZepU5yY56TOl+SV/k4vheqBxLepDMSJHivIbHmSVQ0XqvhIGSjD8eyzMmX1yFKGcwMW7yVPsTP5Nu+gIxDuaPhbGguyb4TDYax5y1vecp9Sww1Gw+4IgeO64VbqBHmUO4UxAc6kE+Uyo3C4p1ePsOohj3wpvtMgZdTGu9/97ru3vvWtl9/okf/kn/yT+0TjFGVd2s3k1Y6nnm/81gBrigo9bexb5u1xDPnQR4xd0CJ1mPfLejMptMY95X51Ff7noTc5rx2b9FKTNqEx2tRgIT06ThpMK61pqDGiRfjEl5EamcOKtuwbYy8chuNJR+Ja/SvzMPlfzx2NS9KGBj49sf7P//k/90a3PO3RPiRPynkm3uyT/Ev9NXmSIcK55lm/Y5TzL+e/BifnXobGyX+s2/nGc6e5W682LE1KAAAZ+yrQWjmr9TvLJDDWNq8R+Fdw31Jqn3XZTFdKiS8VwHz/GnhqP1fC1iRE7JSWrKvD60o4ORFawAXMHYHASafbbyY300iRBqVpR74KaztBz76xMOG14qLhgqoX0dTXiqsc21yg/bYuY2xd2D0yNXHdCcMwQCaujBqGr0Gn8/jJYi4evmWu6Sbqojx50lXcwmwx9knfKTx09F3Hgf7SFz2DMFQR+55J8HKREqd6toELBTCFxyoMVsFcZsy38d+ZGFRvLhMGUjQMK1i48wa+NC45phr9klZrsr1KL1PpFKCJR9Zr9T0X0BSiU0h51qUK66fvdHOje+ZEcdrx++n+Kcwn7Xf17vjMqo6d4nwK32r+d4rWab1Zrl1rT/h4CmLTOrXyfLqGTm+RFa5R5n3+GplmJS90vHB1v4NhRxe1/RW9TPM5d25rv7q2Or438cKTedT1YSpJY7Vvq+dXMu7Ed2rdk4xXYeranHhPV+eTyMUPUQwtIVQolXyKR5KbnNl1OJMEp1yFMv+Rj3zkorB++ctfvsgc1IUMkYq1ypl46OT2CSdpoEmZqJsjyavq5qD5Og2fST0qYaK/Hoak8qxRRTmvzqf0khJWvQ70TuBaHr9uGgCNJsg63s+cK13+pqzf9h0X6zPcyXw46cWi91GeZqs3unKsz9KOHi0pb+vp/fWvf/3uXe961+X0MAxNKsS0/0d/9Ec/RmeJJ40Eyn96fmjUoe0MZ9IQ4DVlfPoA/ZEnTLpDBuYaG5pcQy425xNpGxxnI1/MddOFUKlXSEcaiQxDVOatx9hnPY6RbSrv5sYtdXt6oc4U6R1EyZxO0mTKxm7oZ04lisYWaE5PPPVpimNe+VMm406eJj3Zn8zhS8nwNueSaTSSbpMe9ZazX0kzzhOvZe6i1K/++AU4zQeXc7HKLalnpK6ZXmvqG5kfShzk+ireNUhRpM8MV6yHM9nfzOElL9AQm5veDx4KNwkTNYSpe6crVdDZPfOYJYVbSuddUH/v6loJtythrru2EgSntrOtGu85GctWQpwfmBWeJgqTHqVOG+n2uWrn2v9VSKUtdobY0ZIR0LbMV7ffU5qs9WdxYupOyaRenVRiffx3UTXUiucxsFCXCfcmoxCFeceimfGwFD3pTIbelUmhUBDLayeCqTgngbbJDsGHHowVH9btexgBZYge0WuS8BRsOsUw3WXTlVRG6Zi7w6QXHfWT34trGPPyVEfnhgxYQ5QLjvStQLIaJ+HN9ya6n3hCNwbpPSU9PFbZ8epuQe2ud/VWw0JXd8c3H7p0fLjC0cE8vbdS7vPdJykrGus8mCbh5xpltK4xu3Wxzu0Ke35nboTaVj47wXpCp7tnJlg7WFZyzkqpPYVj9fwJDlbtdHwnaTLHY1VWeFjJOrXNnQFxWh9W8uXEiyp8Xd3X0Fr2Yye/dGtDB98E94ncfSKrPq2ikoTskjvsKROqiGWoP3IF8hIyhZ66eKMY5sQ15A+P+jZ3kKcNUzJ0R3ys1iZp3LGr9FBptPKm7Jf91FCWuXmUIVWIfQeZxBxA4qau+5UXdmF7Jks27IVnDOdJ+Ur4UmlOY4VtuFGcm5B83FDmd+bDyg0wf1NUhDOFgykY3GzU8KOMbf4ccfA//sf/uNCAJ5JrtEC2Q8bL8Dx1AE/Voz3lu9TzcoNYWhR3blrmOEFvyKzQNHBgZCJUkzaQfx3jz3/+83fPP//85V3zyvIxsTtwejIdz0ir9lV9Rno3J5n94h29iCq/1PigZ5h4qLRIe3kCHs9oCM36hMmNVq8lLdGGycfVCegr+DL/qc4oOa/kAcrMGkHS4GKfNPwwz8WRRkMNPXygMdpWD8jcqBq7pducX3qDJY07Rwyh+7MX4NNYlzzMfmcOYfvpvEodPOHN/tWQUscrN27kl9zPFB7UJ32lEU5ekPDIA7yv1+hTzbHUMeFkQlk6gXQSlpNYThe9nfD1EEJ5XUCm507LSoB0QHMRS0V/UsImIbtrw+f8eOqBjNeQI5hbWkin/uYiLOOVWXqqB8X47jQsVQFqJ+St8Jn9M57ZSaZln4nGzoETvBP8TgS6pFMTXKcxheswzi7hXcJtnHuOh1Z9CgtPul5WGGyHBNDsjNhnrnmi2AleJ0Uy2+lKMkFwi1CHkUg3S64Dlwau2o4LBe7QfChcoy7eAxeETq6MNunhpJutFnlDAl1EWewpGVeM8KFx3Fjy7HeG8zovFJ6qm23FdQpqjCmCkm64un4nXny29m9SpHP3YhrbxyidAlb5zzUK/NPm81nPiffLqRHh1nE5wU3CPPGnutbeQh+V7q6B7VShP4HNZ1PorzJDVdyvgbW2M72/kwG6uTrN3x1N30IHFQe7/kz/s67p3lTnBPe0Fta6u2ceYixX8Hbv1uvJj6Z+7OrNd3dy5TX9mu5X2Hey4rMqublSaS15sEquhhDWTOQc86mw7pNnh5JpD/QO0Zs7cxAaZWFe1BzX6l2XMKl4CdeKtqqHJcV8rIR4mUJBo4CJpMUD4Uqealv1qvT+zvbSQ8nQnfRgUJ63Td/XmJU5Xaw3vfBznGwncy+lR5LeEik/+b5eFHqGODY+q0wHDsyrkzmObNPTthhHDIycIgeNIFshOyN3Ugzr0eBgguVqUEr4HLdU+DVqaJAQh/xnM13c8kEWBT5kPo2hwMTpdMBltIFwMNY8a9ijsNV0EY6j9Kgs6/Pp6VXzXTnW1lnD2Azf43fKlvZbudp5It1Yj3TpfM3cYcBIuCByPf9Nbq78nKFYCbeedjlGeqRp0EpPMvDsHNYTR8OU80yjJG2LJ41b1q3xW1rOOc5164DH2G9K0qmnSKtXZJJ155C4Tvqyb/Y3jXb2lZK6rfWJH39bl0ZF5zl9p/h8ei1pKFWXPF2fHvTooJPFsQq6IiGTfekCuFJyH6PYdufh8iT1WXJBFSd5VGOe2NC9f027VZgwBClP3/JZT1Oox50n3F0bMlqPglWR1vUyvZVWQvA1Rbirok3R2OPk0dpcS6cM5L0qPGRfWQAp1ks/WUQmD5JK1/yW6aRgAA2kN06F1bpc2FicFCY6gaS+28FS73UCVMWVXkcwUq31Go0mfNuuC6SLGsXdDYyA7jhRqoDibxZqdq3MFSAM0B3XFSgR6sCpu5g1CWYd8/RIyh1UnjOZuG7eHQ1L357I4o6BJ9rwLnBk3gHmI9+6BrsodWPRtfViKJWeVorkqjw036/4qkriymiwU8im652yX++f1pVwdnxqV0eFodLsjud19d66Pp+Mf+WRyTMqT+n445PMh2msOhqqv0/rn4wpJ0aUid/UserGtK4fnaGig23i/1n/iVfRqj8Vrg7m0zLR89RmpfkKS8LfPbdqO691+K5w1OdXvF9Fr1vLT/r9rItKmeFvWVTYVVxZD13LVfL0QEI24L6KX27caKDIU5483MTjypHbUsFa0XX37e/0QrBkiJjKm8mTgcE0DcKKPGEKBHPepEIrjGnkyTFPgwHyBZtzNa9LbpopD5tfJj2Asr3uv3IqRdk0jRXiRIVXg5nKLeOr/KOsWDfQeRd8uFmqbmR4jsYL5SMMFSbDRhZ23MGDeYHcNPc0OmmtS3xtmymbp56WSr/PZB5eZEOSyuutowcdfdZbR080DSlGVtiWRhX7Yn9THhYn5ghNj/jU5+w/9aljppHUQ5b0YJIunYcZEqccLAzSk31ww9wxy7lF340OcLxN55ElN4iT/mxHI5ReT/bRZOTSpd5wGT7ofIG2fM+IBunA+WBfM8zQfsuLwOWf/Mmf3G/kO/f80Ja0nqGl4sU6EzbbzGTjfjLsNEPzqK+GD2faD+mO++aySp6lMTj5VnqCPZhhaSe8+swkjNQFzg8dZlDNxaOFmsmo5XCl8Fb4rim3CsK7cq3wk4tUMhKUaeLGdR9lErKAapQ5ERxW17Po0SMhOon5D+PXTa9aLWs/855jJwOtrrKpzD3JOFT8JQ2m5dXkcFrEczE4pa1ubHNhoa+0AbPUDXsXxuakTTfTZKKGa9XTOjq8uZCny2LiYzePqwKZY5R97XCWDCyZrszMnFadkYu6mO94DcnodWem6OWTp50JW8LDfby2TJKooRTBkV0RmS7tcJ06GbPcZRLuOuYwYhfUDO+sHkdVKfS/7rfuHMj8ueYcMwcAHlXMfXfWdK12Z3UaN+evi8JjlN18uoY/nvCu1TO7tjojRK139cw18HRr4kqR35WJd3bzvav/1HgxwVufuQVXu9Lxq9pWx5+uXYNPYFhd6/hwvV/Hoz63grm7nnxvgqeD64TOOhqu9NLReCcbrObRag5M7ezgr+1O8K36u6P5vH4qh3UwdDiu626GGFb81Doq3hLPq+cfq7BG6yWQ3g5+m1MHzx6ezZwxnvKETKwybR5EPXLSC1ylk7ZY9/Vmd/feTU9lqMSP15IW8pnufpbEf55ixWYXyi/wCLPGpMRFlceSNlJH8pQvi4YBjU3iIZVTN/4yFxLP6SWTsnqG64gD8YoM4zj4jvKW+krmA+K/xge9tjSmVP3A1APgyffSC8W+6jWCPKc3EPeBDbxoWMq8ScqIymXgXiOjm5PcU/dJb57Eg3BRpCXqNhm1tCJ+Uo7TgKrxQ09/E7vXvESG7vmeHw2UaRATj3q5+J1wq/+5cZoeMRqVpBFpyefdcM1N7xzXDI/zVDxkWe57qJB9o1+ZTNu5pW0g8V+dBdCPMlSNovFEj0ZDJ62b+c9Gr/Of9/hPXdCAuZjEgTJ7zmXaduPXnLI/+7M/ez8P0/sq50TlH5W2cvycj8KpUSnD3/LEO/+Le+kBXGtM1bhqybb47fvCy0e+9ExOhct7O2EuhT6NFihRmXPEk7RQBk87ckt5WgvqJIiuhE/xIbOCuH/xF3/x3lsJAnCBTYPbSkip1zsBLmHLxUsLqe/QtjGpk8CSdWd/KxPN9lcKWFeqYDwJSS42Mjf+p4ujCa07+CdYdsqr93XXnfrZCbG6rsqIZaYKIFUxmWCpApG/Mw68flZ9nv6vcAEzhnllTDC7cxp2pveAnecYJ5IvQvuJ2/R60kDouz7H2GroYUHXUKfBT/yAa5KJuzhmqOJkuKFuPfdcUKoXUVU4EmfuHio0ACP8L3d3uM5zCNHGn3MfLzDbE9aOn2gsOz294WmUFZ/L/yta7hS6a5SgTrHa/V71Jxf/XVkpr3m/tlvDuibFteMFU92n/HKCdXdtde8Et7uygq8bx6qMX0tHTwLzCvdTG3U8un7u4Dx9r8LVrW0Vj6ftVZqs9zqeUNusde/kla4okAtLhtvXeuuc6nBS+1S9gSbZauJtUz/yner10q3p+X81xyvvWsH2GMUdedY64dNQ4fpusmO9e1WSDBvi25OnM/GsOUE0Nrlj7wYgzxB2r+FFhb0a8yhdlECmqkilWlkhPWCyWId0iQKbYTu5edjRj0puJ1Ob2zM9N3KTWNnJdzUY8JweD8ocGil8N/FQi2FDPqf3TYZwufHId554DO6Rb9hIQ3ahkCfJ3KDKPOiDjKen6WWYmgYQT0BW0UeGRGdCn1Kv1FCTc8N+uQnK5iQ0kifQpUFG+nS8MsTKkEPa00CRUQh8KzcqI2sgcTw07vjRe800G8wFZWFlPvtEPW7AapywPQ2NSVsp9xr6xceE09K238wn2hMf6WVk//TGB16ez8TkGnKTth0vcZHebxkOJuwa4fTq14BUI530ABRnjgPjSjgeegb5r6ApjUHwlK997Wt3zz333MXTjKIxKg21aQDTswlae+Mb33ihHeohYbyGRL2VUg+lpEFIPce27HeGhqYzhPxAnlM3lB0vDVvq7zk3+c5cUuLcee197z0zw5IEUN0CK7PN930Hi6FJikUy73Jdq2+X2+dZlFMh81Q5OSkSApZPcCDz4pqEYNiOz5/Wv1L4dIVNl8j0YJJZVLdex7p6lnW/b8FHhbP7LzzubrnroBU9XUa1fHO/hvalEJmum+JnErrz/Sr4iT9Kh6d835w97kr4nHPpGiVQ5kPb5s5y18XTUqZ6dgrEpBjbLvV/73vfu89z5Ikdq0SZ1u0iyo4TcMPweZZFAUMrx8ni5ozRKMPDcgy01iskVcUmFz4NT8bj56Lb0Wy6jWe9nfKUxYXQ3ylApLDhvHOB8L67rHXsUnikDgRv8gsw3i/2ssLXpPxdU/epgSB3mrs5nHWe1rsz4iQP6OZCB4/j3Ckd05xcKfRPWiae17XfKe1VeVvRQKeET0aIbLfWkfe8v4K/g2nFh1c00l2fjAsT/7lm/Hb1VTh8rqsnv3dGoF1ZKds5JxLubu7UAq9kzSG0SO8GBHtD0XN96ODo/rtWsBYpD6RXxo7GV6XygPrOCa+Z7k/84Jpxehalhvar1KTns/fNhaRM43PIyh7brqKLEcINGL/1+jBkRlmXojd15UlpUEmjYuo5dR6kDOl9PxoTrJPS0XvyEuutfK/TrdLDKGVAr7kh57WU6VPZ1WumC73P+ajcYmgN8odzRg+LxJEylJtoeo2h5GPkw7jEs+bEYjMS73/ya3pyGHSAAm+Sa9vTiKPHjnIvdfK8/dabP72klCX1nNODJsPtNBjpAaIsmCkf3MSGnkz/oQ6iB0iGU/lfQ5EGCuFUB1Pe1GiWBhe9qoAR+VBjSjUCanBS/kzZMY18mSib+5msXZjtr0a3nDe040mOGsxMpJ7eevRD77z0CkrvugzrpIh3vYI8PZpnE2b7npE28hTWiLe85S2XdYL3DPl7wxvecPfa1772Avs3v/nNSz3QHmOpsVZ+Ja4yx9PrXve6u/e///13H/rQhy7PcyohBkoMVOTTMvSyenfZ12oszvnux/s5x6sR0jmZJ0V7Ldctv1PXTCO0IY9udpsD7EENS52A6sdJaNyybmnpRlbf9VuiS0KVmLWAV0Z2Ilhdo1hk/24Vlm4p3UJhAmNdPvUckumIsyqQ7soKb1x3cTD3Sx49qbVWpmLojkYA3RnTWrxTcCpsp/dqPekGi3DBAkIfgAmPFOBDsDSuXjyYULsKmXwziWA+GnioA3rW1XLqT9Kc46TFnqK3SxqJ8pvrLAzWo5Ua3Nb3qkDa4S2NlLp+uwiAk8m4JHNXcHMhyESBdU5aNOpkwsS0tnfCUi0876lsMH+YPcLBy172svtx4VhZ8ZHMLmHL3STbUShlESDBuLSNAoIxjHarsFvH1v/dLmaHz3ze/ufOKkUPutyNcO67E5d964Rf6nPX7zFD4Valw+Mpn61CqtemUp+d3pmUwdWatzIg2HbW3dXVtb3id7s538HfvbNq81ojywTTqs3sy6pM69uK5+W4nOCq46edAaXO9fp815+EZbq/6tdu/Kb+TbLMNYaKjg5W49UpxxM8Ve7ZvbMaI6/D11n/MaorE7gxoRdDl6em4qnC5+liHlMNX2UtRrbQS6biuMPVRO/TfKv11PdXNJfP72j0acu4u8IGUuaR1CCgzGGOwfQ6UIZBFmB8lY+QdVjXTaNB3RR1DPUMZFePT/dgmfSA7nDSGZW6Z5OnVCWxm8/KBTkfqhGr8qlpnuXmvPetTwNdhsClfKe8YegMH/BLcQM2YUg5RX1P/S1TITAmGjMcU+HgGvfZLNRT39QA5hQ19yswmOKAsUN+B36MUtCAynUaHJW7TSWgHJoGL0O5pK8M2zLXkKFeFD03NO7k2GrYMPVHynbyHo1eiTtpT2OJ9WZeJXHmePJuprugPdNuZBtJJ6YAESauZ3iXfDTpO8Og+GjIEy5TM2SSbepK3FMYX/BpSg/G0IOdcpNWPFZemqGHhjwy9hqSM6m7/cr5RKFdYHjXu9518VJC5qd9dEb0Ff5T9zve8Y6LrkH9rCl5mlzmm6JoeKHOD3/4wxd8fP7zn79co4/oLx/96EfvPv3pT9/9/u///v/HsJN6iXqHXlVuRIsX50zHH5J31eeFVR1SI6lFvd56NaYKmwZmdfyTcrX20S3oDBbGEC2Vhm3BwJnQnrxVF0sTreWCr8uWBDOFpVTB/EkXzBNBd/Xuk77nbxdWGZQKKMUFsCq+naC1Ejj8XxcuJ2hNqOik5hkU19e//vWX8WYSMSHJV8MnPUe6Nq/B+eqd7hq4YdcDJsF/6A9DDp4yCBjch0lo+GQnJOlOxsFkJjRTDx8Kv3mXd0wGmP3rCvNAJZ96NGwhkOZ8qMIkMDFn3O3gmrsonVC8Euj5zRwEFxk3D8PU6FvphjZ9J09089QzXcWneVkNSV5PwWRX8lkUBQxjLlrghjF+zWtec7+jNdFKFfB4jnqo833ve989bhknxhec6LW04icJ36QsVL4EDCxsndefXl6eMKKw4XPp5r0KgzMPleP8/4cyKd1d6RTj1XuTMj492ymwp3Cs2t61d/rOrqzw2PGGHe84KRMudsYPn5mMf767gqVT5CdDywRj4iuFtQmOqrBnm5OBouJk+t/d69rp4N+N3Sld1Gt1fZjqyPcqXN047eCq9yv/rf1lTXNNcHPGnWhz1SGrdLkpu36qxLDWsF6Yx4eQGhRZw6yqt2yHp2vkyhPeUtuY5n01SlT+dgt8D13Eo0oq+FWX8MQic4qowGYyXfGvxwobTm5qqyyprGrg0NvAepH5oB/eo+SGVOfNero2rMYo600lOGXyqf40CPh81qFXR3rcU5T3DCOUxtOYoKc+BbwwHsBqrp+EIfvnBijjpQdNLekpoxEHuZQ5xliwqafcnAYJ6gYO8lHpXWGbjBlwIPfwoW2NyIYA8Z+6pRf7qX6jvGX/dJJwfqv0qw9oOBMW9SNxaDSESroyXdKWYyDu1YX1DqkJmHP8hFkdjff0pJLeM0+PdQBz6o9Zr0bz6r1Sada0EdzXIJYbpplXSYOvRkDhV6/3VD5pQ7pND6ik8zQYMs7izBP19NJSrtCgKs1qUIV/o6/C04ETHdH1ATqjQFfQm9FTtkE9hiByT+MmxihgQef8n//zf957J9F3dI33vve9d1/4whfuc7l2+pFj4sa+OM7oGeko6S31m+T36SCQ/LPO38wbq5eZNOL7ky1mKk+0rS0wINa4S5AOQt0l0JLaLWYAz2Bahx4iTvRM1JuIO2HcJ6W+sxJepv7fqgxMgi7917WOokLpdzLAqS8rPFSYcyHz9AV+a4jIJHe061hr4XdX0Ez6KbitBJ7p9/T8SjHknvG87kpJUzAN6A9XRJgJsINDE6BnUQjFyGA7MkkmFgIP44Cbdd0VysLzCqAyBRNS642TJw/UeZHJDfN69+xOOfG40vR2cndQA5fPCjf91JCTMbguxjUMrMJVGV5VPLp3slg3Y4VQr7HEOQBsGP+Mf05+kG7dFWd6K735zW++7EjAe1wcaId+E2aXi1mFdYXv3XhkSKC7YbyjICxN6Vbu7oyCnQtW50IPzOahyFwHj11ODBaVDm7h5bWcKFsTLVYFbKeIXqsQ2v5DrzETzjrlfhqXqa2VQWXV7mldtQ/J8/PeCU/ctd/BuOOraQTu8gzsaFb+1RleVu/s6OykjxMNTX2+hXd08kcn801yzwRDzr+Ku7yf8qbPsGabhwPeqHKZ7azmIbyUdcG109QM6W06yV11fFdzJL0/VnTUwT7NxYq3LNN8eayi8qeSbOihnvCMo/hmnE3ArMLPfYyJes3wDN42jLleScoNFL1CkGmon//IatSpbNbJL5Zu/mocSJqY5kFeq/Sz48m17azXHJQalVRK7Yf4MiTQPvrtpqt1Vw8F60oeKGwqrep+jqtyZaYsMCTJ8QTnyGK0zziy+Wp0gIYH0wP4YWz1zNYThpIbbxo9hEtcpbFIryjnofoVcjDveFIv9zVUox9oVKnJjxNO5dU0mjjOmR806cccPOk5pde6BoKUAXUEyHw/aVjUcGWKDQx/GljFRRpflO+Fx7YzTE0ji/porofqGvBhvVyoV7iRfx0XcZ+wOjfVLy25OS9uPF08jUoZwVLnCtegFfQ3eYyb9tAdRh/SbfAfXdEE8HpKCqNjbZ04NJgP1TXif76QnJz/jCk0Q+QFeqj8LKO5NIKlrpLzPg2+0rd0nPmpk77Fm/X7bD6fNKLxST4mn9Dj7prN6psNS8kUNUTwcYCZ+Fyv7lxVMNRllW8UO71ymADp6meZhJ7dojy98yTlSZS3DhfJEI0B1/KfyePS4HbS51Ph1cnK5Ne4peVUpppWcZmVIXQ7RaD2d6dUeN/dAUpayLMerchalU027gKrt0fuSiVN8qGvLCj22Xhp26IuvX2gz0lx1YAh7dsP8z8xN7CW6zVVS4VrUpZ2Ao+wyLwNc9RQVPGvQAachl7ab+nQHaEUnDr4JxhXClV9Fth1eYXRazSRBtPjzEUD+Ci5+CVDdOFnN4J78imepZ2dUaZTIlbPVSVA3mby0KRDFQxgAT6+TZjPYsg7dddAAdtFzrF6rLx0Cdet/PFEGb2m/Srkd/NqBcdqnuW1+uyKxk958u65Cb7dO09ihFhd6+Ca1rpJ8Z1gXF3fKXFdybaTz3f43ynjddy7Pk91dYaC/F9pd9dm19ZqLZ5gnnB3jQI8KdBT3av2u/dyPrtpZAi2hbH1EJhODp2KoeMeDc47KpMeXd7JYjt+UXHRGSpr/3f0uDI+TO1P/OMxSoZ3uMGlp4PKs4YAlWzg5xlkKUOdVFIxCrD5xJpOUdFVWab4X0Vb5THXYkrlC5Weq6GlXu/e1wBQ54gyQYZZ5fyavAaU85QFMuwp61fRTMOGskPqH5mbJjeMrS+LcqZ4UwZ3zDKMKb17uM8YMdbIN8jmnqTM3OJ56lKuV7bRY8XwKq67OUd7RnxkUnbaS2NFhUvZTPwppyOrqYCrXGtozgTcaWg2akfYE2catBx/rqfnknJtZ/jxvUofbkSrI6U86bgataBXVIZV1Tyf6b2kvuUYS9fOxco7cgPbesWzfTE5vLKvdJveThrHND5xz3mrXI8ThKe8uYHu2KU3pDixXxrLeCf5D7jByEl+JT4YO918N3pDmnZM+eBxZ0hgeir99AvGK/VqeJEpftKjLL3oxLt9dRyTvpKWKg9wPHVQSZ5a81U5XtK1OcYS386ba8LgHsRjyQFJzwcXgxo76Tu16AYJY8icIpPSbTv12krQvXbxvFUpuqXk4qLxw8mSLnDgB2NEJkGuMN8i9OZvGVs9xSDdjY1pZjFPV7mVUpUTYiXY5eTRgm3Gfi3Z7irl4l+ZvIYUTySouOjoKI1QGlcytlrGb5xw7jTWPuhSWD1/dKnFgGOcfx2jhHUlUHbj2+HTsXPhcHzzGZmmeQ64pmEsLdbpLpsGvq5MNOp3FXqTh1DgKzD3DD3wVBjzVcmQEU6IZ9ZjLRcf8zW5CJsvy/xXeClpwMoY92vLpBR1itUUSugz7lwhcHHNnbTVHHOR0MD0Yiqnytz0jnNvV0fFc74/KdnXwNmNcQ2XOO3byqiw4uXd2pfvrHjEbh08we/q3mrOd9dWhoRr1u0Vf7xFsV7R0a50imTXt1UfJt6x69uqncm40ckE+U6FpT43vdvhrOKiG+/a5yo7dMX8IolvZQH+p4zawdz1wbXFNZ+CkYl1kjWJNQMZaAdb9q3De8VNhWH6v8J5fbaj92tl4qdRVF6Fh/ULHHtst6dypaLMMypsGJXYCE15Ro8Jc2wiGygTugNPUR7S4KACJa5U4MVbynuJu2o8yLEWZn9nnTkOqex7LxX5rL+WhCe9HqrnSfVwSMOK7aeBovNU6GhWo5wyluMD3qlTA4DzWC8iQ8pUYjUaIpsxX5ljeIPwfuLfaAC+TRKNJ4jti+c0wGQEiHjqxtPfaUhLz3HoA5rLsVE3MK2L11P+72RlDRRpUKiGyPRUUb7L+kwEnh5OjmfKsdKBpXo12XefS8OP7YBvPXLSQJh4VXdHTtdYZD3qs46THjLqHtKunjLmtnJ+2k/wrLHTUEr4s+Pp++Zygn40TLq57oaB+pgb1vDzL3/5y3df+tKX7tOFGKYrrabBNg2hOMiYXP5PX/CS45rhpMjywKJXnTTptxvnRobYH39LJ+K5GggdN95JI3POBSNyKCYmR8fS8UKe6Py3/eRnT82wVJVBBgiDh8QiURtytFJAva7SXYWIysSnxfRaBffa0gmHD1VnFvAA49Idk28VYfNV1dw4T6LwrgRpmXQaAJgcX/nKV+5e8pKXXP5DjIQkadmfhNyVwtAJtvxmotEORhjqdiFCoENoYFJI6DAB/uP15gRI909hW41fuj6ny2PihP7qybQq6caau0H2VSOOp5ZZOqHvRGFLHOZ1j7SnZEy5MbO1DgUNiiem8Tw4NL9UNUqdKD1JBzI++m8MfS4WPsf/b33rWxemDTOEz4BPDEHf+MY37j14DI2DTnJhdJHiv6dl0A5CCDiRhplP1G0+h7pbWQXFnA/XCPMTrupY+1x3+ltXJ0WBzF2/LsfBsyx1Tle+fkI3JwpbPr96dlIkO351Ul+t51rlv/Yz61j1oeY9yLpSUF4ZCVZ0+CTr27VjcFrfVDolZ+r3Cn8Tzrq1q/KDrL8zTJy83/Wrg6FbI6/FcaWxCZa6lnQ8ZwXHqu1Vm7t6p7ZYK/DyZP1ng8HNOQ+SyJ3rDoe1beYS6wvCtxsQ7up6us5qB7eTp1b93fHErnRyw/ScdN+tZY9ZMCAZzqJcgPyr/EZRyVRRUv5yjHIDO/vF+CCvImNhoEg5TF1Dbyg3LVOJSoNRR/+V32X76kA51/wv7JUf15xIyt/pDZRwVcOIp4hpyEpjj8a56iFh/zRYKDfYR/GU9JPtqmxnCE2mNlG+ylB/ZWPgRW8E/3geGcbKXFORR6bjGYyHvIccSC41vT+Ehf+mEOC/hgK9pFK2574bj4lHQ570fPdkQfHlM1wDLto0PQEljTtV2ddol2MsjjWapAEyx9lk3MKfdTln9ETTCKExzPsakTScOm45H6Q1DX+5gQxO6DNzM+mpGl8db41A3lMut++ZPBzYpVsNjBo+9bJCNhdeebD5lrxuOxgd+chT4C95uhs0pGeOHk+MZZ7oxymEGmTSIyw9uuQf0Anvm8/rp37qpy70Y2J5Cte///3v3+M511Xqsh8azPOkvDTEUtz8ds46puI7DXUauHhOLz94IYUxRRfKEzStx76pjwn36fp0k2EpK9dCycTXTZEOwUgyIe1JfZMw82IoTwrLJJB1Ao3hge6OeRymE3MluN9SqvCadeU1x/rb3/72fQZ9DYudW2QVpiYhblKUEOhgZjACJ5oGCQRIvU9UwsGZORVy18I2UvjohD0ZorHbycAMDevCwDoFR0NpWvJdNDJhXYeHW8axE1I1CHkErPhQkKv4MPmiC7MWe75hPjUJfyecdnTj9XQz9gQfd4IR/jEWJoNjLDiykzZ++Zd/+Z6ffOc737k86yJKcSG1TZMZAr/he+74GFZnbLS8CoOVBqhJ8c6yUramcZnoJudgRxcrJcJ3TaavUPXYZadI5XOVFrsyGVWunS+dASfHsrvewd8pGCs62CnKK55Sr614aGf4mHjvBMt0fzVu9dlrFNdrlWpLtj3R22TIWNXZ1ZfX6hri9So0TnN1anei8fpuwtj1r65zXds7OaujmxUuK946PHZtrvA9wVLfh8+zJrAGkEMPIxPXPLxDRaby3BWuWS9QHPWIZc1yTWczDWUl+UVXX8fzOr5fn62w1PvXzpfKNzr55zEKpymxpjNGKHSGp7Emaxg0hMN7eqkYUt7hSQWZazzD+q/3U85Rn6Nt1v6kk8rD8lpHS5aU9XI++17KF353Xkx1rFK+SV7heyau14NGWdn3lJfSyOR7lAwlqhur9jG9gPJ+Gg3Ek4mb9ZjKkDbnF3jX+y8PTkFm412UcfUL6AGjMafI0U+uIedpeFHu530NMdWzxj6mXG54kmGRvGMoU/YvjSje4z0Ve8dD40MaBFXQkzbqvNa4ZF2ZD0d51jHUWGR/09Ckp1C+Ly40Fhhu5ruJI/umV1N6yyTukjaFOb1tsh/8TiOdeM8IJQ289lMDjYY3r1uvJz3qxaMBRcM09cG3X/nKV96HuVknugfGI4010CD0A3199atfvafb7Fv1XrP/6BMcGvD+97//olv97M/+7KVdPKkMi3z++ed/LCesOHBOSEvqufKh6okpfpTxTWsibDkeafC0XdYz5pweZfzOCKj0aLT9NIQ/uGGpW9ySYZpszVw3Jt271rtm9ew1gmIVQm4RWh+y7BbwhE/jUiaI7vB+Kix3z50Ic1NbJktLeDtlbCW4TEJiCuoukLoWJoNhwWTimnxN4YD7XNdl0hNiOnzU6+5wyZyN44fh5JGTORG7umEALIZ6ClFcWNPgJdxViJjG4Jqx9h0YFUI2CzfXu6OXfUc3X/AGc1TAM/llN84poHUwV9j5BpZXvepVFy+jNHAxfhru0giGdxKGTK/ptSfjVwHIvFbUm4uQxbHBYMUzjC19zhj9jia7kovOpFRVfHRjJb2lC7N0lAkfJyXVevTMot/g+LHLCX+aDBCdQrxSrCYe3ymk01pQeezEoxKm/L1SfNMAcLKW7dbBrq0Opul+fWYFd8LZwTgZGab2OuX+2vW5g3M1Ztco0B2cU3217clQMPHN2u4pHnZjec27tVQ87t7v+u5zO3gSfyv629Wh9wqbDhgp3M11ragbIhXGjm74TZ2sDyqurKUmla6hyRWmioMVD6nloWVW2+o2gq6ZGw9dWPMJz0BmA6/gl2PllS9Nys5zmffTdbwagvhd8yTxjVKpQi5e3QhXdsyTj3wmN6xUYmteklpSkctvYeuMz8kDu3tZUgm0n6mLqVAaPo/SnN404iBlWj91Q7YavJJWDPUyHCjhZN55upkyXjUm6HnDeLOBzIf7GIOZdxnSxPsvf/nL7975znfejwFtmtYBRR75D/hMuGx/0nvdlAo5vobypdcVhc1raIz/jrf0oDErFXzHVfgsegslTSa/S0NP0hz33NQGxvSmT7kx20ovNPGtLqNRVlwIhwYL4UyP95RHNehqcEpY0yCmniFtcF364z0P+tKwYvviGNiEV77rvNGmIH83TYqyu6FztMk9dDDq4xv6cmOZ+ohYwGMSemOc4fPPPffcZYPC6AijKjzlLz36nF/Q+ic+8YnL91vf+ta7173udRf5W2+rj33sY3ef+tSn7iMinKfSgIa8NMhZv88615IWDL3UyKaOaVSJOaSkK/PNgkN1QHXmnJumE0ndRlpMWntQj6WOyUicxihXxHUC2k7Ar/d3v6uwkLB1AkvX3tMsU3874d5SF7mpzk44WpUVHCsFJxevqW91oerqOhVAc4fFd9zB0rik66Q0qDdOuqLuSuLeuFjdbmFaHjtq0m69X/L97BPvmntBF2yFUGOUPdp+VW4RLituFbgzeenKI0cXYdtOISNhSnpxgTNUkfsu+L6fNOHRsMlQYYLg2zEFDkMYPGWhClpJjzxLAd/Sh4u9uax8V88zlBAXLGGUsebuUKdcVuFvUq7r/45P6X5tDLqCC0zfHYxpjOucV+De0dazKBNPrTDn4pXPVGV8h9vVOKyUya7uCaZb+t2tZ1O9E4+c6p/aOi0rHK/WzFVRqD3xMLtVeZ7W/e53fa8zJOzm76mBI0vHG56kvyteU0snc61gnmSHlWEkn1nBsYOztmPpDPYdrPkfvslaUPu/g2UaF9dPNiJyB38lk2V9k1FganMah9MxqDQ74aC79xgFg48KL6EjhttoIFFRVN7it+Ht/Fb2MEmzG07KMCqn1MNaisInbzJUBJmRNVNcVKMD7eElw5HhbIghH+JJ88UvfvE+jITSeXJ0/3OsqgeQ14V7telSZdCuHuUIT0zWIJIydRojlI/SIUC8VjrJXI7pIZb16dHjvLFu5T8+GohMgMwHeBlT6AGZEA+Tt7zlLRcagT6Uy+2P3isq2yrsJqvW+y0NO4bqqYxXw0j1wBEmvZo0NJmzx75nYmb14QyJS48Ti+/w7T3lQd/Xa8ixkOaT1t2Mz5Aow+SkK/97zQ1050nSU9ah91ve15gj3qQr5WjnGf8Zc4uGJnFrNIo2BN/TyUKjiXBqLHR+6rkjb4ZnY7AGN3gm+T70gxFS4yW0xDcb1/zWKCVe6LM0Jt7lP85fCjzkD/7gDy5tvfGNb7xP3UG9n/nMZ+5zpXb6l+OYIapptK48TgOb8yV5ibqL+LcejWDiNPmc46yHY+bITuOznnhPxbC0WhhXCmtXOmE7J/5OKOmEIJGUQkkKA6vF/GmWlcCWz+wEohP8roTIlSKSC940Zrkg1Tpyocq42yT+zjDQKV4+ZxwtEz4TqLlIdrDmWE/96JSGvKZi7gkTMg8TtNW6q7LCpFRoYnFMt2Pz+WRugNp+/l8pCXX86jvedwwm+spnp53YakzKcTdZozsUJuE0nC6FNa357hQ5njB96wXHuKTWpNUJQ+6m0QYKBc9bj6czuOOVfbJOF0Xg0rClYUdX+2Tw+an0tiudUYl+YwxzV0YG7lGlxoknrjsenHOt7mK9mMtOQavXkk59f8dLu/XE9SGFYEpnRD1Zi1Zlx4+7dbA+M707tVV58gnOTvpx8s6q/o5HnfTtWnhXz9f5dEvp1ubpmV093XqasFYaWa1d3XivyoqGVtcSf6uNh0oLK1pe4aHj/92zKUPWOnZ1dbzVa9MmVcdfJn5UcbniXTs8dHVNbdfnq1zwLOTfqbA2swbXE/Y0NKjosS7rpcB/jQ7eZ81nLWW99Gh5x80+5olH8H3b1AONoszpO8gEH/nIR+7+xt/4G/f5WUz1Qf7Hf/gP/+HFo1rls1svct6mRwLF9afSRyb2zfcnnqphJ68pC5j8GHx5Ci7XPR7dECeuq7jyX9lDzw3lpUw6TdGYJ4waklT0zWUjfCZMBxbx4QagYw2eeQ9PNo6ARz6iPcKJ9E5BjmTsDLHiPfqIHGjfNbxk+J34oWg0gRY0QunVk3lu1HvyVOhqRJGHdQYXx6PKHFUmrSFuGgNSLk9PJI0J1mPdjhkyOe+CE+aa42K+pTyQR5lcI0ZuCHONzV3hSeNU9aqnHry9GIukTzee0YsMNTMUzN96lZmjiXdNni3uUgc1P1Hmc/Jbw7Ob+TxjHl7oShkfL0k9UVOn1LOK9xh388AqO8or/M99QuK+9rWv3dO8HlYaZaSDahjTmKhXkfxIGlbvddzEH0VDsWMpDkzILT3VPGrpTaYuorE4D++ypMfWU/NYWi2I3eKXC99O0F61O92TGedReVpvGYSq4D526QTBvHeC551Q2y1utdTx6ITYnZDk++4cMBkz0z4T1nC2CZ5sz/aZqCZ/N0FdCm/Vm0NhwSNm9dRxNyD70imb2V9dHD2dK3cpdoYE75njgf7XkzZOQuCEM78TR/V6J1DX/ytaOpljngKYuw1cB+96G2lx5znqyxP0ZK5pSddjh4XIXSjumX+pFpmsCe/0JtOYp7dYGqSql13ikQ8LMIKKDB+hRybqgmw/gZXfLhwKWx1dVKUpvzVm0a445Xl3+dzxyffr3Kvzxt8vFj43lR18naLUzd1JmZvmjddSIHRnClxDO8zXKqSf9ifn0TSfVkpxXqu8OZ/rvIEmvjC1s5rvE2+8pVTeO9Xnc1PfrikrGcT/T1rqOn0CSzUq1PdW45b92L234+eTp0RXujZrP6ZSYVgp3bt6TmDt+PyuroSzq/eE9k7mfMVDV/fE3zv+v3ree7trDzEPnqTk2o2spoKeR5KbgFYFnxAWQ1ng26yVhNWbYwjvFupEWVQhzXo0QrmhVE9ZVt5EBvjbf/tv3/2dv/N3LuFa5jvlOu3RDrLKb/3Wb93ngsxxTa/XumalMk5R4axF2OX5ufGeIfN1XHNjlwIegB/YNV7k0e58DAW0jjSU2Z5J7O2DcnHiL+GhPj0rhF8FWXnRfGgaSDTcZSgVcpK5MKmXdpWTgDvzOWnoSlme78xHYwoN8/qYxoViCgtpx+s8J/5MFK63ms9pUDCsa9IVMn9PnsCmHqtBVINJerAwbtKRhkPhk2714KJ/GFP0fjecNKOLTLmQxgTlI+Gkn+BeT65Mjp5GQ9+nDeVa26MuPHc8xdGxsQ2NLMAvXh2njDiwLZ0LzMckfZmkmmeR5UwK7/jxnqdACytFunEMPZ0QPHhitDStoSjXLTeC//QFA48GH/qQHtzWIR7TM0vDVc5tnjckWL1LA588zO88IVBPQD280psO/IAL8OCJqgkzRe84eYG0+eA5lk4Wo52CPNXVCRy7BT2fF3km5mLRMQHcN7/5zR/LcP6QZScQXfv+ztBwjZC1E5JkTiq5ujnK1DovlwkOiJaFAry7u+DCANMnMTIMZSWM1757agQujQocXucDk0rDEhOfsdf7g3Z537wzCXenrNp3JycFmjEcKxfZFW6zfhmnlvCunx2OTxWOKnCuhNvu+Vq6d6URxoCYZGKX+Q9uMeRkUnU9bWSa9eQ7rfLJiGV4aWXP3coqMMHkGWPq1pgMbbErY04Nmfck0GffZLLCLNPOXQfeg77ov8KFzJs2ad+dl2l8Kz4V9Hgud0JcBBV6pnGp9Z7wjmdVunF7SPgm5XD1fM5P6egd73jH3atf/eoLTSN8ffKTn7zsRKeyUd+9dhwmHl/Lav6vnu2MFCoCtf3TMZjW69PS8aHTPnV9m2A5XX93/Prkei27dezU+FLfXa2Rp/V2Y5b17kI9b62760+te3dv9861BqgOlzv56mTu1jl3Wq7hK9mn3bMd3a3W/BfDOmFfXDtVLPU8NuGwPFtlXQUIOcDj5z3m3sNdCEPB69kTxZQJ/K1sVpV/+SYhLX/37/7di1eDYTwerMO6D5zvfve7LyFyeNKoqIvvjo4mI1En79W1Mz1Iss5pYzHvG9KpQpubKuZdybyUvmO7ifdsLxX+jFTIRM8qpb6jbMM7hkC6oacijEylUcRrjIPGR5R+irIZ/z1Ry3rS84ZrjBfPZW4k2ndjMz3dPM1Lowbw8y0toGdQDzKwijm0ZLJpQ6fUOzM8TpwKG0XjQN7nW2W/npjsGCt7a6AAB8DAf4wqnPrl5jh4M++OdK+nkOPkhrCebN5Pr32fkxaFWXpT52OeIC/TpjmxNCKnYdX69KYCfpJoG9lBnYyN88+2rIN+4YFkPYyFtGDUgh5Z6qTwB/qYCeOV6esBQhrOxHGOj/MojUM/WU6TTAO5OLIudAr7Yl7l9Gxy7kuzmdvPOZbzMZOh5wmX4ly+It3zW31Mw2PyH2G1H6flplPhunLNIrUSzE/rqUqCLnEve9nLLsyeb5CMsglzgkB1jVsJ9qfKyUOWCR+ngsYtsFmHVlxPZjCmHQacuWl28HjSF4xEAkzLK94o1FddgWs9eZ+JoFEIGNPLxZ2SdC9lotAHmYrWcu5hhKq7RLXIMLQwa7GtuXbqO51SV5+5ZkxWCtkkVFQhpj47tVV/TzQFLgjZwsinpV+hjmR3FBPzwQQ1JvHfRdzFzOR50BxMTSEBBu3igzCop1DCRF2OsV5x7j6mK2n1COsEN4q7cMnMvefOmkwc+nbHQ2arUcqdt3ra3qoocKXbcQq+NYx0N6YdXTx2qf1I+DvPFMuO51xbcp66AYFBiYSgfKBtlAPc7qE9lJLKL04MGpOSkO+nK3UqGPWdVXveX/HS7v1bjAcJ64oHdn2+xTiQ7dfnqvK0Mrz4TPdsVdIrbldK/wr+FS5217p3cx7Ufq9wuOL5+d0pvx1eVutbvb9bd1Z02/G5ExqdSoW/Pl+vd893vGgap6nf3fjt+lrHZQdDwtu1vYL5sYrrpfKeuViQK5AllQ8M58rwK70DjE5QGUXWg0/wn7UdBRc9wJyNnh5lPW5qJW8Bho9+9KP3R3KrQ+hVwe/Xv/71l3Xjwx/+8N2/+Tf/5sdC+SjppePvpP+85vqYnkbJc5P3Zthbt3YkDfiuG2YaT8wVpFyWIV++l9+2W/M9Zh98BvlQY5H1aaywPr2FqI+xTj3DohcR101LoIJN3Rp5jIaQhtJ4x7uZG8c+8h8ZElmSzXAMDdTHBrjjrJEjDWsq79Cm9ZFvS31EXKDvqE/lGNEnI2nsr3oSzykLZ46i6sHEe5kw21A+ZWLwRK4fTzmkKIdT8sSz9Fo1EiDpqubQyjBIjVGZw8n3nNcaARmnNPaljigsnpZtGzoUqD9wP3NlSc/MTfR98p9xjfHLJOV6XmlY80RJDxxzIzkjUio9aqQRniwaSasX0x/HKXgazjICQd1UI1Dm4bUejUdJM+b2kn85To6d3mfOteRv0lPSXIbQyQvyOa6Lj9r3BzEsdcrrk5ZrhaPuPZVDsrG/5z3vubipOgE9VhxXVo8zXdVZlcsdPA+9MHcCrqUuOpPQc9qGi6ReGEx+LacyfU/pmuq3LuPPZQJ+9LpIIrUwGYzr1bqfrqUUdwlgAhn+lK6hCYvxqTJe4GLRcPE5ERI1UCQsVbGY3s1yMiY5xlWo7ATE7jmvVa+QKhTUdvN3VaJq27mgG6LmAqEh0vfFu/PPRcUdQo+RxcCk0AOdsRDrzm5yvTQ0JjPOUA4ZLXCZWK8bi05Q96QFit5PqfDnroi7UZ6C4vvuFOkqX3GabSaeTY6nt1QKotJ9dafOudv1Mdt6zLJTrncK5gr+lQK3e45r0NkHPvCByzG03CMunrWB3ygjKBI7xXGl7Kai0L2zMlJM/LyDp/s9wbgaj669nC+dUtv1ufKQWk4MIl2fVn3Y8cQVjAnT1H6l0VOau6XUdSC/rzFqrGhz8uLs3t8ZInZyRypPWUdX964Of+d76cFxstau6DONvXWsJ9o57c9qHmY9Fe/dHO/azusrOt3xlMcouY4rH2j4YG1FNkU2wDPEcDju5+lQKqsYM9jcMVePSaLf9ra3Xdbvr3zlK3ff/va3L7weGaNu5lBc+6mP96ifZ2lfWJU3PDFKbwmV5OT9aeSotKThxWuT7CVufCZzzHRzzH7Yrl5ByrTpicQzerHwrKkIfCbz+lQZKpVT5W1kMDf+9E7pjop3DA2X0qtf5ZvfwKVMp7xUEwsz1hTz4Gh8Mh+rMhu0o77hhqUeK9CDObuAh/FW9jTUkqJnEvc9cQzdAt0yZTXqoA+mdsjQPOlA3Svnq7Qj/aXHcSavNqICXGhwsJ/IzcjV6i6ZliQ90hzHNLqoq/GMoXQ59s4TPVv0GszcoNlPvsE1OKdt57SGMvsmH5BGGCtxI20KN22nHkl78AfGBNkNGlDXM/G7IWyMi7I2zxhloBEq4c85nHoGv03iXnNhpe75k8Wo6RzJeef81yhpe3o/WaxPfqIelnaKun5rOE55NNfLiv/sg8bTGlI6OVc8WChcvT49Ny1yD72gObFe85rXXFwUJUCua5WfGHYttypl17x3gstciGTY9JH/MleYmYvtqeCbsMr8mIxayGUUMnYZ7Eq41bBn8kSZgoJCGpV8j2tYpD3uVWt9hq3VRYydDYyEMj+y+MMcJH7DlmqsKPCwEKSr6zR2nWKXcJzgtuKnttHlBHNHwdPiUsjq4O3aOBE08r0UaGrd/vY9TxeRUTtuzj1D0GRO6U6a7tMyKJ5hvKUL81C5uCRTy745H1xgE2bG2dNCknF2SpTfjkF6PLkAGAbJbxdxDU+ZS6qjjW6OVzhoy3BODVMUd2lrrp8JD9ZX8fViLhOdUlIwWc3RKojXOus8kechDLIJgUJA4lVwzThkEswO3u73pPB16+KqznqtrqMncK2ur+pI/tb1s/KOjq7zmWljZlXH1IdJuT7BzWr+VZi6dytvrO1NeKuwrmDr6KbWd8rP8/cKpmmca9+meWRJV/2T/mXZ0XS3DqdAnGMz8Yl6bZrDPjPRxyT3TH2e+tK1c808rc9lm6t3HlrefsjikfTpjcG6jkKsvJuGBOWGVHZ4D5mJsHzzt+jdoPzPJgKRDPD8559//uLRkeFFWWhTWYI23HiS/pCDXEuAMz0TunXLd/O6imad5zVEztJtJFlH6jepN1g8ah0c2bcMo+E9NwtTEdaolnjSqKbcUxVUPWc02mhYEl8adJTRGTNowBOs1BcqT9JAo7cNuo9pFHJT0VApPdoMf7JPeqGLB57jdODvfe9793hSH7Jf5vKhLUOyoEENS54yliFThnLqdURRDnaTVm8avfvFQ85pT8E2PNRNf6+ZY0rZ1ZxAGrco5trRYCgcypB6ZWlMyvEyDYjGrsy543i6mZoyu+FhJudPmIUnDcquJeY2MvTU3JcmApcWpAveo894mEMD4ot7aRTkfeoURt7TsGRCfp0iNMik0ds+0y/qpU1o0DHgv3Pkz1/QZ6sBOL/Vk6Tr5Gf2TcOtNKtxzRxgjk3KwtlmeiHlmOXcMOVHznH1H95Nj6j0GH0ww5JEtFsAO4GiEwIm4SbrmRTeSTnO+EAZNIOPBdfF6GmVSUHq7q0E4cSVAwrjwtUPQ4xKOUSGMkT4Rj3WvRNeOvxljKcMusbV1oWj1uFHr6TqGqiRQEuuz8P4YMpOmDzxQxfOxIMJEz1hLd37zN2km7OW91S2naQn5ZSud4aDfN5v8WReABceJzl9ILSsetd1wugkoJ4oonybYE+XXpluHtmajNDTNrhmOJw7PcwzDCGJ42T86V2WDNQ+armXdoU/d21yjN150IPIXZcaB5xMd8KhLvgKTAoiLtTpFpwLagqC9sm6O4NQN5b0B1d9xl+6dcHIBSffpX53aM0nZqJ7E2W+mJWJaoioZWWUyDosKcyv1pR8F1phDpoHTKEJV3jGoxPuV7CulPLd2lbr68Z89exJ2T23Us6n8ag479avFS/d9eH0+gmtr3B+bekMOp0hpjO6dEaOVb1dP7o2p7q66zsjxDT+3fVb5bnKo3a0U3Gzm2Or66uyWkcTN1n3BKsw5Hd9/lqZNNvvYJremfr6NGXik5KnP6nYyo+5h2yHLJQJmnP338JvNw4pqUDibUQdr3jFKy5yNOsm6y1e07l5k7yX33rM6JmkJ4VeKcpueEmlUlm935QThJOiDKFhKOUUn5t4rP9TplzxYDeu6AO4EOd69vAMsoNyPM+BKz39Mf6wJqJHKZdonFBXyOTJwGCOzAwPc7PafmlEovA8xbQAhsiZd0YjjPJZeopQHCcP31BRZtzTE8e1n2ftt548wOAGEzIt+hZypoYmZAPeBxd64hjpIb0asgWtYMQ0ObLyooYc9S7zglEcE+FJ46iyoB72enWZlNu6NYKm/qUxzOviTz1NvY+iAc3IAvOgZiRKeuM4Dqm/8a0xyQ3+PJkNnGgYtD5PffSwJcbQMQJXGH+oWz1S45Ljz7glD6EOPdF0WtAZwY188yvRZh5KJP05j9xEpl74h++Kh9w4dz78KDy8zBHnfFQHFG+Oi7jLMEXbtx7nntecyz6b+E9eI551WOAZT2ZMz6vkH/xWL5JGTteLY8NSFXaT2eXvuuBOZRJCJsV9JaRqHcwjCY2jRBmGmOqJBw9VOoWm68ut9ekNZBw5DM9dG76NJ5cYVgpt1ivhWr/ufcaseyLaqRAvk3HnwzGR2XIdRs3CBkHrnijDtV6t9nmdTxqrtEhD7ODDYyJpizHX+ydpI2P5E8+1b9fSx0oQrc+JcxYqPOtMsme8ud4z3Ddp3WQQ6YSODq5J4TbHEfllMokbY4Mg4Tglw+Hjzgwu6oxnMhvDidxlEO/Oy4qbdKVWSMhncmfF6zwDfMAA/Bl6lsYpy248XXylORmuhjTpRtw4R1Ko8Z3Je6mjDX/n7oY7inmvG1ONzQguLpK8A09A6DGX2WOXTuGZlMdp7uwUp9M5W3GvoO0JQow/CgKhEqvw32l9Ws37WqohrNZTldfVPL+ldDi7tu7OoFDH9Za1dsWfr4Xv1vU3aVSYqiHkGqNKlhOYan2dMpnXu75eSzM7fO3uT/Cu6jhVnKvCf8oP6vv5vevDqkxyaUe7HY/r5t6K3mu9tb5b5BbrufXdhyquoxn6YhiHcruKuTK8667hQBS9WEyRoAJlaD0FmVa55Q1veMOlTQ5qMJwqaUNFjLUVGRNYhIF2ycvDdZ779Kc/fS8TWE/1dkgZ3WeqsYmSSl2VBTpvpFRGU7n0eb5Z35BlCBVSqVd5BtfKUEYqKKu/9a1vvQ8fQq74/Oc/fzlKHe8Q89OkEq1XSuaVUbbTsyK9VHIuJH/V0IAc7Ht6wPCNnGlYW+al4TlPaqtJyK1bI2ae7JaGL40g/jZNCPDQtp4pyMf01VQPGkbUeUwPYRiaCjq/9cYRN+kJz0cvK+DSm0i51rBBZBTDFtWx3KR3TDRaaIzQoEFfjTiwTg2nGsbsg3SaqUdcD3VCEO5K44atqbvalu1Bh4wl7fAstEYxjC+NU5nsHR1ETzrpX30j8yS5YayerPcSc1eDnvCgSzhX6FdN6A0MzAmes203otVFMwzuTyIvrzQvvtIwJK6qp5Hyu0YdYU99QTlWI1hugDuPND4lz7AOE7pLE37SgywjOjLZ/IMZlqrnyiQ05GKulctJk4mQLVmPiqZWfDvYKVh1cWUS4+LKOxAAEw8FFI8eCFFCSePLkwjqnQD6EKUTsJyInlIlMzJpm8kIMw4zjQHWUwUIF0qZk2FvxpSnl8lKcKZe6gHfKLsSp8fMAzsWZ908WaSdjDlJJGT6JZOTJnLREe9pTbU/ukQrrFBgWsbdrwSpFV10AvEkJFfc1Pp0s3ZBoU8yOPuRY9iVKoB3Ct5K2QUGBA29xijuTMgYEUYSLxRz/3gMKO/z25MnYOCeOKDrci7yFtqBJgxR9HSNpAUZsIuKxht3MvlGuNMAZhjhCgd1zlIHi5t06iIK/1CI4Hlgo03nmQZQd1KTx1R6STqYjBG20ymVqZDYNoYld3ZdsMAFuNLj7bFLpceVQpyKY96rylQtK6WoCuwUd7A/8YlP3L3lLW+50CD0wzXCIxCga+62Dp5dvx2riSfslOOsZ1pjVrx9osMTHpE8ZWqz1tc9szNGrPpU2zjBf6fkZ3+u9eSrBo2unWyro9nVnL4Gju7daX7t+ryip0mm6eSSqR/dfK9zYTWWEz4pJ/1Z/Z/grrzn9P0VvZ7SaOXxdby75+t3JxOv+EundD9GoW0VI3PcuDtfj/BWVvSEJ5XolBHTyxf501QDPOtmmZ7VyGCEyBEGpXxI4Zv1/jOf+czdm9/85suHOpBb9RBAOeWZj3/845eTRIW3W7O6eZh6iP/r726+VG+G9Biq9UkDhtx7Yp5KZcKsnuUmIzINsrxREqSg+Gt/7a9d5Ivf+Z3fufun//Sf3p+e6phgMNGTy7o1CniyW41cyDxTeuxoWIIekKv0etLoo06krqJBgWIahjy2XfnaevhAA25Ip9wmLlNvMH+s3uTm15LekJPz2HbHrnopZYSIPFF5U3hzc5LngdH8R0ZraNgzGiRpy3Gs7ftxA1sDCmNsOJdyf+a6mnQdjVUaVzRiOAa+pzE46cv3jNhAVmWc+YAf8yoJo/XqtCDe0POyz6nHpOFF+Z1nGEcNgjo8SK/q2XqD6c0n/eCtxHXTtYh3jbTpEfSTETFjH4Rbj7OU+dNzUVo0PY1tZZ1p0HJMUv/nWx1MPpGHUqVtJaONhMmP/9XdT+TfJz4Vrlug/W+ohlZBnnVQMh4xkeJRiSJZpS0nfm2HwrMQAUlXPSlAwmBiSlSTsH1LWdVxqoCs6vT93KmRILQoMyEzwfGqfzlWWlBlzDIHLeG6Hq+sk1WohWjZ8acdrd/8hnl4LLx40SNA5iQBS+y58FiMeU4GrJtsGj2pgz4ZQ5q7GJ2ANglgHTOdxmo1fvnbbxYFQ/akfYUpE1d3YVATPC5SXHMnh5KnDdRiniRdi3OnCViYuy7atR/OTQwYGlsyVtg4aZ+ttMmHhZhTuWD0PE+cO/VpmfekQj7Sp0eYyj9cXKlLnsHcdwdkCiWsArh0lIY9Pxbad1yM93aXlAUOmq67cCv6qWUyDIjDnLdpbFMQ0SBIOxrrXoxlwsPq+qTE1+dyx2zCpwbIz33ucxd6Q3DWaLjie7cYAqqieMu6sFLgT4xT+Vx9t8La3e/gPjWMTDzyGr67UqRrmRTznaFvB3MHS/2f69VqHajr2gqGaw1QHawTnmpbT/Jcfb7r/27sajun9ys+Uzhf8Yqu3qrse70zENSxXM31SXaY7p/MjaTn2lbFeS2ruf6siyFtKmYYbMw7qPcHJXfw84CNTH1g3hrlSNdG5StwY+JmZSXWUry2CXOC/7uGsg7883/+zy+5+N73vvfdvelNb7qcGGoBLoxK/+gf/aNLiNiEc+mi402W9ERS/lIurPJEVfZTlu9oww+yIGscuEMezzwq0rUGE2Q/DEnIUtRj2I9hV+CLfFWGFmlE0vvehNJ5gll6azg2iZPM/+JmqwYC9RIVdhOD0x/g0fM/Pd/sv7KdIWSplKt3eF1as32KhiPTE6hjgBt+01fTVoA321SRF8++J140gGVCeo0NlTaM8OAdc/vkJqxwuJFeozPcrBdP1KEexXMmMDcMTRrMqA/rygTUFdZc272fYZLCb64jDwLSq0bvJQ2g1GP+JGR8ca7XF7/FvYZN6TVzpRqSyDdjCa54RjwY9WOoJl5qeSI1sDAf+O9p1XoBaZCp4Zk/Ec4PjrfjqaHbZzWSJp/TeO67zlF5Za5D4pr/RgLpfZjpO+q8S905va/SIJuOH5lb7amFwq0EBABikBHa7STPaw2UmJOpMHieriACdYvNmNlOcRPZ1KlF2UFLxDxkWSkJK4F/VTph3pCcjC8GFxB4npSRSlUqV3Xcsh2ZIMo69VHy9K7uXetON1/rAv8s0FpRERKcHOkCCPFbfzLbXGgSf056kwE6rsYypxtyugoat13xsBubTqCuv+tzu+sJn3jKnFRcg2G5G+EcWCmWCZc7cBhqWEB09WXhT+Ojz+cJDS4AWurBpy6oncBtPT7bKWxp7Kuw0ybGD2DVLRhmrrcZC+Qb3/jGy6ks9MUdRWPuHVfaxWNK45QLDM8g7OnJ141H4lU6zAW5U4j0mPKEwsRBN18clyr8uRhMylblsx28OR66iztmum2/WEqFfVKUUnHzWq1j+r9SwvIdimNIjg1OdFHYzN2+qQ8npeMf3Tiu3q/hcl2pfHIqnVEg14fpecqJkW0a36lv1xgWJlqY6qrzqM7l5GU7I8YONyfjM/XlxEBzUmf33rROTbQ3wdNdy2cnOtj1oY7LCf66tbAz7Kza7trr5JtVyXm5G8eprx2vqmFRO9myq7v2Y8WHTvv7LIohMypD8uH0dnDNyw0wdQfe15tfjxzuG7qhEu7mojkaed/8OOTvpCgrsaY+99xzd3/v7/29u7e//e13v/7rv37xbmLdIAriU5/61GVzgs3UDDVRzu3wX+mgyk2d/JufNAZRqtdDvps6ge3QbzYLwRUyE33WuEHdKuYYjrjP++heX/rSly54caMRZR45DRwik6Wxjo+6nd4Zyld6mCnvC5f4EgceXsK76D7ODWBiUw+9B7hMHcBHuvEksDzZLpVs5TgTSVcDpGFbFGlHw4cbsNRhkmhDI+2rRgDuA2OmTVBR91ujl31Pw4TwmH+WdswHpR5Ux9s+8T9D58wjabiexj/wQV0afDL0TUOQ46FjQ9K2SdiT9lO2TXxbl3o6z5jLCoOc0Q0avEx8bihsOgvYV72RnM/oENCl7VIPesZHPvKRu9/4jd+4nAr5e7/3ez926JWRFjzvWBvGSJtcZxwxPrlRb190DNBBQh32z0Kf8n/OWw2xaWiV9tXNNBCpW2j8rLYMx756umk7kd5sWz5JMf+VNM0n8xe70e6Y5ongD2pYOhEyZBoQhoqOyquTx4mSE8gcPw6GxMl14ypVuCf4NDh0p4pdoxjcgotrnrkGFhVeFCCIW1ymQuvioZUzLddp9e8UWI02Ga7UCTc5vtTP+FLyVALrosi4bMN7ErAxvOmFJcOtQqKWYuO/MxY3LfcJcy6sXl8ZibrxyQVco5j9ycTmu/HuxhTmhsGExRIcmPw63TirEClstR+8D4M2HlyGIWPAWFU9Maxb11yNE1rTMxwvcVL7mwawLCsBGfhMoMlY0p6JMrmHsQjh5rWvfe19qKcLReZv0kCFcEORueqpuPK6q4pK4nvHY9yN8lqdJzJ3E0q6i2bCQcNOuxDBiU4TTk+hUAjSiKrA4Nx7sZRpblSayfk61VHpMRWyiqs6dxKHHd/r6u/6MNF7137Wt8JFxUuFeVozTvmOdH2iSK4UotXzdZ3t+kFZwTHNyd2ztY2EPeGUZjqZYNVW1pmGqYleEi9dHbs2VqXS1Ml7E72e9r+THbpnqzxY6XcF825e7ca81tXd72jqGllggv2kTPTSwdXRTicLTDBOdPmQcvBDFMNumFPIQHlwi4qVCo8lFVcVHvMFqYR5z4TAykkaIfTC8bp5I2kfw4nhVGw+YEj6d//u393Lqsrfykk5l/JwD+XypEX5jx5C9bnkWem9n94EFJ/PUKFc21Kx9b4Jk/WywVBmKJTyAv0nxI2NT/UojGfgC/2DYvgQMPG+G5K071gqS1bDjf0yvEvjTYYy8nHzmWIIF/kQuf7d7373Amcazuy/hiXzbeWR7hp/1A00UPCeHk9pONHwozylB1LqAY45xTbAp4Ys5Qs3cZMmxVmOm7iqa2TSbYZhST968GeyeQ1hqVdTzE1Fn400qPqhBofc+KdkMnblYY1QScsZuupczPBIk4obEmdqEOeU72vQk66MePJ0avQnc1hhcDSqQD2YujGgAhOpDqjD0Ds97OoJ8hra3JiWdjM8UDqgJH7lJT8ZoYHSseNhG9aduav45EmGziPxlrSbNJCGLn6nJ5/6trA67zRApcOKfDR13uRt6pQPZli6ZkHS9U4GJ1HYMRmT4Roan5JBSPxJWIaAZVkJc7uF+tZyrUBRyw6WKnQ4wdK6XeuQoaGQo6yDK5RrLP7mkOnaTSV6hyuNVyjyKP8SPAsO7aSLnkzFkDWK4+eircVbwpdmauij91ks3DnxWb1MEu5TYX/qb9KNVlot6BTdNtMIlO+dKGG69+p903mJdXSW95IRscAbAucCRn3QBMwXr7Q07OntRd+qC3K6RV4z7ydhOPvh4q47LDDA5MGFSTRZDHA9dYzBvW7PSccKAbnzlcKbMHXjmx53VZFdCenpddT12f6y8DFP3DngGv0ypj/dUlcKR+LNAv05B1KAtLjIv5jKNQaVU/6641e7NnOsd3win51o4xSu6b16P9vq+MI1uFq1NT070XiFsV7L310/VnB0ba3wONWV8KcskXjM7+qB27Xfzc1r5QvbqniqdZ2E73W0m2E/eW1laKg42xlaOlhX8O3WkNru1O9aX4f7bo7WZ6b/Hf5XeKlrcbcWdNc6PJ2UqQ+1zp2hqcLykLLxLcX8N3rN4GWtDKMCRHFNS8OL8msaUUwqncqgekOGk1NSBgUG2kcm0mvBHKQaAZJ/pCygbOD1/E56TLq2b5PMl/pQ8qeUsWv76SGdRTwoe6s4q3waEeEGL3qESjfyfRpCMqyGgi5gGFUaBnLTJuU05cwqOzsG1G2II3VznW9kXIxcGo00eKj75Gl34ka5VplIY5GGFeEwZEhF3WfUU72uQQyYhN/6xX/mUtLIoAwo3nw+Q0HTkOYYZjgh72fYlCXH34No/Ainm/gZkZIeZNJbGgWtO+dYzkmfNW+TMFcvrPSaSSMKdaM3JszOtzzwx2czTM/QPfBsv+yPOIMmPM0P/QfPO3ViQ+EyhE1+kEZp+6hOZKSHPCkNobStkbTjwzp+aExPgw2F34bzOp61/9JcRun4rTFQmnajOb1Bhd3ILsdWG4zjpSFUWJzfpxvWV+VYmpSevC9Rpnuj8aQCbzxoJsdyYktM/teopIWyGpYqXNOCuivXCulPs3SC0krId3J74oXMBGZsMj4U83S5O2nXuv022Rv1OgH0NDHRne/SPguSVmGu6UGl+6WujRQtoclUKkwaKDVWyWQ6uJMp1T52wnVeTzrGqEF/8whc2tR4h4LvCX2r+mtfhDvHZBqXKvDW/yYDz0VfBsscwrAkzm0XHOM2WvP1OFdrjqKp7IR6mXIyMS3rJuFmkWC3IU8hTAYmjRgSm4KZtGZySF1Z9VbqxmISxKeSQuM0R3LcddP1iFz5mAsehfsZ016VlGrwTRg1SroY5zv03eTqL6ZS58DKIHBSVxWqp/le37tFidqteau6Oz66w8GOD9wCq/hZhfLslPWpvRNDxEkfkn90CvnOo63Sg9e7HI217mnsOn7W0dqujvruCicdrdR6Vv2o68Oqva4fE+wTDqa+Jxwrupz60cGxm78dbmrbHY3Ue12fK3ynMJ3whSrvnPKqSdatsoz3u/XrMQsyK/CxZiFnYdgx5Ir1UkOH8oD5FVWaLdlHc6XoFZ9KPaWmX1BhU6mibtI40C6GDGSUPMgjxyp50ooe7E/KER1P0wBkfVW+7YxJFSb5fM7TlDWtR3nBupQdPeKe4kaw8pSyYZ7e7CnMej94mIs4U8bJU7szoTfFVCfC4YEur3jFKy4GAvNoYiDQgERdbvbqrWMomPVnCg5xa54hx0NZVA8mcZ+nmWlUoy96xOlVlR5ZyqB6d2jQcR6q8Gd0jUYL29ejpybCtr08rdniGJvwunrS1Q1+N55T3pZGNBIJZ9KauPFaRkdoxEuvr6RHN7o1cvh+brSqj2iccm5IO6k71FQiekTxnMYm5i7RPlyDr5AiQ8Mk18wBnZ6IafhzruT8lWaETXuG8P1JnAgnXqWPmqIicWRd4tw57Lxz3NPjqRrWcx7nc96zn84LPdbUF+23DhtpgFKPe6rJuzuh1JILgb95VmbvwNthB1RFTOQ4qCIv37lGkKjw3SK07wTop1VWAkYuaCblk/lJaJ6+xWSq8ZnTwty1wwemgKtpVZx1OcxjunXNJAzLPDrGy7qYAVPGLfOOOZNq6eCusE4C3IkQmLh0h8E8YRrRYOxa1DWoaRAznnqiuQn+uvuwGo8q/Po/BYJcLGXywEo/NOzxvokXDUtzMWFs0sttgq/iuAqwwqXBE3qhbpPtGTOtey9GLhcTcMl9Qx/dZdLDKWnM/rj7pECTz53A73cn8E0KSDe2jpOMOt1fc7HMXcIUAHJx6GjCtty1kU4VJqhP3L1YyzV8tOO7q7VnV9fu99TmDrYVX7lGmdspwZOyewuuVnXVPnT1VaNC1/6p8r2DYRqTynu6Z1IIv2YdzzorLzkxkORzKxpbwbSqtwq4te6HnDc51smndmOyo+cJtnptWmO6eVHxlPCu2r8GFx1Mq/a7edHR1C1y6qqOSZ477e/TLoZmeVKVJ2yxfiGXaBQ2hKlLkqtynrk8UwZRHnZNpqQHowYH61POQNbFczoNLJSOljrP/3w2n3fjr9KPcKjE+b/ST22bT4be1Pa70F/7TUklWHwqQ4gnDXx5YrNGpUxVwJipb+jVrw6YJ0/r/WA/hUG5h/sYkZBtNNCIZ/UPowkcG9rjGROQe7CMfctcMjwjzqUZaYR39PRwLMxLJc0Ir8Ye4dZbzmvCV3GtkSDpznHxer4rDpHlM3zN8RaHGv6Uh5XhNbI6H+y7baV+nZ5Ljok4SlxJA95PD/pq5FHm7XL0aMBz7okn5Wf1BA0+1JnGKPstTdP/tD+YP1gPxMwxZL81qmi4yo3/tEWoU6kraUyreYT/rESgiJfUEflOTyGeU1cQd87XDA0U9pzblZ9UeUfd0AiZNCoJh+0bTWS90sQ1stPVoXDTQpnFiZzeE1rqJNi0xslwTO4tgUmUMqX0oJgEhIrUx1CGHrLsFJYqvDnBwaWJjrWwd3WvBP9sw0XD+M8cO+6Z+M8x4j3G0PA1ihPNiWMS8jzxTUPBJDBOQlOnJE3C44ouFD4M1+JDfR4RKcM3aST44BkTCXZ1X0OHkwA61cV9DUbdbpzGDIyC0oRjAPzkD8gjQHk/47i7vqyUiYQLGIhvJpafhdy6EVowJGWetcyHxE4VcfSGH0JDLAoIGpmIHOaHcYzfjAH98ISLCf4KbzeH/D5V9uoYuaj4bO76uDuVu1gT/rqSzzOWJvDPY4JPvc2edpkUqvp/NT+6+Z9hjqtnu7p2c3GlBE7Pr8KV8v1rxre+0wkM+fyta920jk596wwTKdB0/Kq7Xuur7+yUqQmeE8U765vw0b2f79Y+7PBf3z2hhcqjqjGi8o6VXDY90+FveiYV12ncKlwTLLu+dyF8CeNuHLNMz3e0vCu1nqxrJY/Ue/W9aUw6eKc2s6zk49X/Z11YDzVMsC6yEYkxB8941nw9cFWCpMH0eLDYV3UOvYKVKVWklZPtexoQVK704qZ9DF381nOpKt51XCrfrmOhgprXc25NSuJUHyW9HCoe8r915CevCQu452MOTE/ryryOymB4dWlI4Hk2Ej11WDzyjsYAN7mVgdKwlPlo+A8MyJB4s3nasLIOMh/P61Wmx0tNtWAfM5Qn8x/Zb42Oyv+OpalblJ+JxEB+Va815YGGDuU7aVrPMNpJ7yb+54ajhi9/s1lv0u4MUQKnGXKVfXBcNNQ47hpX05CRsnce5pOyam5UZ33CLu1Yh3mbwL8RSWnAEW5h1E6g8TLpWmcJ2mEcNSA6/4yCyjlT+807nP7LGOXBUdJChkMKu0Ys6qmnv6UMT8kcVoai/VmEUuZYm0IlE2RL/zm3KRrSpSHnl8apLkyYe46D45Whlp3DRnr/SU/2J8PtnLunkRA3eSytFiOVWeMmk2HYwWSk3mPygAQJgCLytA7WHCsTU+/gvFXwXuHgoeu8pr3atguwJx34jMwkPSBWcHcCjwSqQUXXuHShc4KmsOXvquTmQqc3SlqfV3BVXFQhbCe0TbjtrslYFTBkOFp7jZlNZlbb7QS7ScHqBPZK45Wm+QCL3l9aputuXW0zBS2FtKyzU/Q6XNV+prDG4oKQKKMCNoxFzHEWCgQCk0QKCwWPpa9//esXJgx+PaHBpJrpokq/3d2k3wpEadjZjXnC7vUc++Rf1fV8qi93mii65lJcIOVllV6SFnJOdWMjXfq8dT5L3jSVTonp6PDa0r1zMs9XbVVekbDuaOhJcd3BXtterTcT/eyUyp2iXHEwjeeE91rnqv+1jys+M8FyTdnJCyel9q/jz6d1drLMBHMHx+o/5Zodx6SJDr4Kz278p+cr7k9kqgmmCb7p/sT/T8vqnW5eTH3r5ISOFqYxXrW/grtr6zFKKv0UNkbY7PK0Vw0byAR1d95PGnosKmP1edfhxEPu2qOzIEOj0GrMMjQOWDB8uVGaRio3HVNG8F7KFRSVwY4eHQ/1nomH+l8viawr8dThO+kjvWZSb0A+Qwb74Ac/eMm3xDMeigL+MHqADz1E8DTjPTa6wBGGwdxsNiQxdTuKHjhuxmWqFGF1g1IZkoTqlJe97GWXvn/mM5+5N0LyrdykoUQ8Ze5fn0mDTfUw57en5plny/GhLcPcgB/50zY1aACL+MxInAx7c4y4Z6oNN+t9T/qs3i7p7VTHOsdYWVN68r5zIQ1KSWvqjfWk9fTsErfSRxrvjObIFDcaapSvKebvElemesh6nEu2pzzO2OiFBL0xDsxdjcGmXuH9X/iFX7jvmx5fmZTcb38Lozqv/bbvVWfKnEw/ivmX8rywVyeMNKhm/ippKed51u8z4lT+k2Oahi7nnX1LnVYayTlqvxLeB/dYmgSF/M+HCYdFl8UhmaNGJUPfkpHp3cJviKNaxT0VbBK+dov4idByTVkJ3E+jrGCX+Dw1Tvw5SQwvmxaoipvJUJALdHU/nvDQKQK5eHYhR6vf+X7Ce63CNwl/qZyL10zmJrNjQXSBqYJDxWGFvYNFF0qt4ekSOgkVOa90+9XYlbtBhpq5M1jrOVFqVnjsijuGJtfTa06GCI3yH4MRQknlBSzKnJrnQpw5EBJm/uuxlWNXaX03R9MA5MmDwO/iBG/SjbRTSrPYBxd9hQj6qzcYdXXJhKUlYHAc3c3JU2h8PscuhdCH5HXXllN6mvhCKgMTb6rKRF2fnnQNmBS9a0uO6VSuuZf1dfN3p8B2109Kp6B3de7mRldfN867d0/Hd4L3Gt5Q18IVvBNOJvmp0n8HT12rVvDuxjlhX61Z0zM7uWtqb4J7h8upbxOdJfy7Z1dwr2h8VSZ87XiAz6xgXdHhasynuTK18yyLiqbrr5suyLJcR1lMg4FeIxQ9D7Ivmaw5lWHWCvPA5PqiMYBSNzVz4w1dBpkFuQC5xJD+9BqwpNKdCr/XqreTY9BFc/ie/1338rp9r/V3pdtg7uiHvmEgQu7BqKMxDfyZ8wjjUoZaqXgajqX8pALPhqK5kmzXMUxYxCnvk2MJ3JMbJ1OmmC/nNa95zd2rX/3qe5oxb2sN+dKolHjQKKFBMXML6W0jPJkTWHlO2jUZOrTqqcXSa9Jlyr+ZwNz/4kO53RAuNyS5n0aapCn7pP6QOUYzt6p11DxFhj1ah8+CM9NYONeSNinZF/VB8V3DwTKCCRxqVOrWSA01Oc+Uq/OT45R5e3OOQb/gExrkGoYrivwkD2JKfLtRzz3pSlyboF4DTUYq/FToxuIjdbkM2dVolV5JqctYXxoSk2dpRJJu7LNGUkqe3K4Thzqs8JiYPr0fMzw3+dqDGpbqToHIz+IkgvEaE5oWR5CnV0EVsozthQgy707GVlaYOjiTQDul5KHKbmF/lkUrr94bTCCIAaVdN8KpdDiZhE7HKXdJ0ntJl9D8ZBsdzipN1TY7uHJR7ZjdSqhKOKa+qvwzIc2Hk8+6mGrx3eFzwq8MgHh+Fl0NgiYFXwnX/lf4cWFltwgaoNAHGCqfZJi1vhPX7hM6z2eFzXxUhrzSP8MqEU5cQLMO5/zkBecYJJxVGPO7E+LqOFCAh11SBARzarlYIUyl19RunPWwdJdOzyL6ryCSRqKEg7YYQ8MvmWt6JJqYW9wmznYK1GOUOse9VmnpGgW1uz4pmNO1qb5VH/L/Sihf9eNUUe/gq8rpSbsnymz9f7JOdv0/XQdr/Sdt1nvVqJh5DZKfdfju+H6H34Svez/h6pS82k7Hm1Z4mWh7gqWDtdZ9Qg91La711Gsdba9wPLVb+zbVOc2l2gd/dzDX0ik2J7BMfev6X2WUWv+qVFqodNyt2105xeGzKrkhpIJG8XARvZw95Ri49WbJ8HlKKkkqormbn55JKkmG2qSCZiJeQ3HkK6zLeGBjaCEhMN7Wekyr31QaqvOp432W9HCo453ez0nTqfTV9jqPJUoHS8KtbIG884UvfOHur//1v3732te+9nJcuylLkNvMmVMTEqv8pyOASrThdI5FKsKOmSdEYzD6jd/4jQscX/nKV+6Vf2Rl2gSWL3/5y/eJm/X20AiSeZUoji2eTowbBkLedROU54ygMEomDULSDs+SsxTdynHhnieDZR6eDLfznvKg+NZDKuewRqvUoTJXWA3l87qpOUxrkYYYaUK9POnSZ+2LhguLhhG9d4QtZdjUA6Uz12Xr0OvMRO8a+yodaODI0NOcy9JrGpLFkZuw3NdgSMETkjnsuEDDepypc6gj1bbkTebbla5sy37Uje0/izxwzqtat+NrPzREOabiMOd5Rg3JB/xQhKfqS+k0YX+sN9+3TWnLdph7D2pY0vNAYFWqk7C8RzEWVcVKwjS7efeeHeaeOWNOBKhcYCUCByw9deqifiJAr8okIN5Sz5Mqg04M++wiXF3gdjBMfXFcZKQyKSaZiZW1eEqMJlJOi3nCa7sJQ97rYPRbZcKTsSgmBp9CjDqcdQKiOAR2d2p4zr5Jw75f839NpSocLjQsVBgSnF/OGeDInEJVcUkh02fMR+Aix+88TWCCq/uecHRCr7Tl2GfcNkVLvsJcupYmE6ywdDBWPGTJncQJ5hwLcKbByzHwyM6MO5aeV/Ne46CLkAYh50rnfSUcGBjNTyBu8thQBG4F8JUi+Vhlp5x39+XRSeOdEWB3Letb4eAUP1PdWc/U1jQeHS2u1rcT48auP9fQw8latKuvht/uFN8TZbhe63hiCmqTst/VeYKfFf9YwbZ6tq4Jp/Du6uvuT9frWlx56kSvOUfzu6PPE/g6fKz6tzKOVJhXckCHixWfOR3bqe6ujlQArsHdNAe6Pk/vPGZJuTDTZAAfG2uEVr30pS+9rMvIDIb8pyHFb2UmFWCV2FSu1Q1oB8USRcnTjCnu0iO7mJ6Dd9yY4zryGsYJQsQwtpDDRQNTldUo9X9649acO9145KZfNy/ruFavpsobJ75S66I/GF8+/vGPX4xLGHqee+65ezyaMyf5reOXEQ7+TpmPdlSkU/ah6MkCbj/3uc9dcE5+TcMh9SAjlxP/MfAYmuZ9dczEoYZIZGroQnle2PWQUW7MjU2VbGBj0x7aQbYDrkzzotytocoTo30/ZdJU8q0jPV6kZfHic9aTtK7uVcMIDYPKZOk1z5Q045joyZLpH3ye/5kYuzqbiANL6t/UjWHHZOwa8LJe27JecyplCha+ayJ96TxTl1hHnhDIeCQ+GUvH1YgpcV4TdUub5riS5pyTGnP+NPRd31cPMCzU+45N4oH/5u+V/4BTnRicP+Kv8gONlzm3q8GLIm0YTeEc4X7qoLa1ck652bAEAxZoB5YJqgdCXQA1IuVJSMkUV8rrtYJnEjlKGdZkkGJ8pdngM4dPhaFrbycsnDyTZVo4dgrh6eIvY5JgczFa9Xcl6GW9jCeMwX6DSyecidQwkDhZDcFiUZbBdgJf19f67W+ZIBMN5q7rqTCYYLHGu3Z9rm1UpVYvkUxgl+6NTky8WGqoYRUiKbmDxG9P2XNRqIsv9zVs1bHqxogijddEeKdl9fykyE80Dey4U5tMUfdYGSiFZ1IAOKWP+j9p2IXX3Yr0LvOd2gff0YAjs3WR9Xn6oSfZpFxRHIPctcu2Ox6Yu1FVQPQbmjCWXZidn7l47AzJj1m6+Vb/r5TLWk6V7qx7qqfS1wkM3fq2aj/7WxW/1bpYYboWT0+jdIrr9Fx9p1N0urJbt1zvav3VuLUru3FbKYv1+sQrpzo7HjIZMaayWtOyzfzOd+szu7Gt1042r076cHp/Nzf87vhMx/9Xclg3Pp1HiLy3o5Udf6jGg1N8rdbIlD12a+tjlNykyQN/VF5Za5HBkPVUfpDv6gEVhpbojeAajgECw4NGJovKmvIjRovMz2PIOsXQJr119LhAz3jrW99697rXve5y2AihWeb6yc2jjmaTTvJTZYPkBekd4/WaY8nvxGWlt2y3en4mjZpGgVxL9Olv/a2/dffe97737jvf+c69oY0+80zSWbabfbUN26vJsx1f5WrGHa8wDUuGHXGd8WIMyJujJ7yeSyYbt92U5xiXP/zDP7w/Fc7xdlxNd5BGpcQRz2kcwbjIfRwo+DYxtQaEPJzG+pIuMtdS5jtKOc7xrWNmiJY6icYkN0Md55qmJL1cHK/c5HQjtW7K0l6eNFyjCTJfEJ9MkSJ8hkGmR1HOf+tTBk9DI3iXLrzGO3p+Vdo2ZJOSYXwaTmoybnEl78nDdfiYvJ179dRp20uD90+/MI7owhhkoVPnqbTxrW9965IvzDbEYXoIOaZGCRlJk/Mt6UnYpUOey7Qq6bmW8167jt545JTjGeY5nl7QuFEXD2pY0oKlC10misokZZaTBawTojuBZ7Xg53VgY7KrrKPwQ1yEt4Agdj8ycd8k0K/aeZJyspCfCJI7BWQS1rt+VrgmQRSCBJ8QniE6TlQKzN6TDPhQeNZjQTX0pPC5U/K6a1p/IXx2sXIRdjJTWHg6AW/Vdt63HoUNJ2laiN3BchE7EdqzHyabo8gUqkuo9U11r2C3rQkHt9Dd6pkKo4IH34wXdOERwtCNc7Iufp0yMMGYbUqT8AEESviAOxiMI8nCXViyHpkw77mz4LfCiDtzVXnqlIa87g7TCk9V2HQXQ7rL2G13w4z5ht8hUNE3Dapdmy+mUhWo7v70zqR8Zzl9rl7v5m2387vrR45nNW5MCmu277VuPkw4yfomHO747cn65HM1RLVra3p3pWDv4DgZ0wrDCW+zvlVbWedq7VjBMimZq7HM51OYrTDu5KSuPxMeqmx0QosJQ77vR9gr7UxtrPh9hbF7pvZ7N1cqL6jw+F8B3J339MhwA3Mai9r+ik/t1upTWZlvQ8oyHH3VxrMqtJ+eRDXvCN/Iluav8SSw3HBRufJAFd9zXUeh1fiRsiLtIdOy+cl16rd9x5VnkB30WqI+8KjhiVNp+Y9xCQ8m1mE8lTGE8J3rRxqaqlGpyjn5WzkilUHvVQMAxU21ekKV7WRITK5PnaFL761vfOMbd7/1W791UZLxIEOGo38afpRPcjM3Da/WhxyFTmbOogxL1Gigl5k5bXheLxiumWKAcfnSl750jwOv1RPTMhxKw4HheHr5ICtqvEjvpppsGl2Sb/oOvbzqVa+6zwGmQSvz0giD+oMhe9JgGuJ0hvB64lAPMUPEMrF0GtEc75wf6huZ2yrlZT46CPBbL6H0YqKAR9tyjDIJtHXRppEs5u7BwKKBNj2v0pAsL8hE0m64e5qbvELZnDEwUb9GRWX+Kqvz3zHO3MPiWg8kDTjqAfaXb42X0om81Tmk8enP//zPL2GzH/rQhy56jyl+PMH5He94x92b3/zmu9/+7d++GG0oacgUr/YleZ1pRVK/TccHjeviyPc1bMlTzHur4e/1r3/9xTMRXuahS+Dnd37nd+7+1b/6Vxfj+YMbllLJETCVMXfQTxbBlTDYXd8tssloZVgSqxNCl8e6oO4UnFU5FVavLTshaaWkdkJJJ3SuykoIMwGau0fpMgoNQPAy8kxOZs4avWgmeE5gpE4WAevU9TUXymSSu752z3ldWq+u0k7+ZF7XeIjkwq27oQnssp7OCHpS6lybaHWnyHQwU2ReiYNuHvEf2oBxenStuxbQUibE9vmVMlH7lt/+didRV+Us0Gd3XCb9wdOO3TgWQHcmMYYBKztc7CzoHp+7cR3e6pidwu993e11x6WkEEA/4HXsgvz6r//65fk/+IM/uAh/6c77Yi0rOjtRFjOUYEXfJwaXTrk9UQqnOissqVhca8yYnjm9t3q29rEq+vW5awwpK35TYZnmToV7tZ5NMNa+dXhdeUzVsV/xy1UdCd9K/tnRwgo3yZ872E7lle7Z1Rw4eX8a4zo2XT9Oymr86zO1jUm+6uRV5Qs2Ld72trdd1jY2TihcYy03NCq9MbLdCTen49PJd6uxVhFhPQFG1jM8eDCmdDkXn3XJ8Te3IDjUqEFhzWYDijWdZ9y9R540obIKeFW6uY4xwJw8Kv3IkIZFqcBmTkMVbOUFc71QTO6sYs1v7qugubHKteq5I+1Vg07+r2OYzyc9+Z5GTeGmL+brTDyqjII3YLMe26Bk6FcmceZdxgBDHMYk2qAOFOZMC5H9tG43g5XZDYHTq4WiMm+xbWA1L1Mmbcdwl4mfzZ2jJ48bcxnupvFG2PQ8Y7ygkQz7qTwbuHkGuqHfXANG3mVeZR5bDRLMO+DXAyWNSGkQFF/V20v5T7ozV6khUen1lDmrNNykjuaYJh2ZN1ZjXBomxJd6tIZ0jTIemCOO3NS33Uwlwbs8Yw5g193M1ySdVbrW8Md7GoXEvekinH/5nnX5Oz2UaqocZTTqNEQy8x9pvBN202Ekv8580n/hL/yFCz3+6q/+6sXYTD42eC73uM67zz///CXx/Hve8567//yf//OPHbBlvfI5+Y25nMxrlgnf7YOhdhneliHC2j+kUWnqF3/xF+/+/t//+5dk+Xgo4k0lPjA4ffjDH77o/iY9fzDDkpNVq1/uDNARc/p05dqFqzKprq5uERZxDhDI81QJEM7OQk2IvBL0VmWlTDxEmeBaCaWdkHRt3yaFQOs9iwuEDoN14mkgAO8ILOap0WXTLP1d6ZS5SQlwgdL6TZEWNRpmaFVd6Pw9wdBdq14qq3pW9dV3XTTBqQKNLtway/SuORnDXdhHZ+TY0Uc3BuAb/Ot6C65hOLqmVyOT/xkXnoF+MuSLRWfK12abVTmrRhOf0UCEAKBw6S5Q7th0NMUC8MY3vvF+IYHZYrl3N4adMQxkNXSv1lfpOBe3aTwqXYAnBDjwnK6tmb/sLW95y93b3/72y0LgbhjvdPnrHrOsDBOnxpb6/KQMWnK3cmqrG6uu7mn8Vn1NmHbvrZT4TljvYL/GwLJrZ4en07amssNLvd6FG+3qTcNBDcHYrTNT6eCtxpCVsp/1rMa869Pq+k4emIwZ9Xpdhyf489mpTDSU41Lv5XsdbSXf362tK3hybereqTioXhfwY5I3w5Pht/IG1jD49Rve8IZ7AbzbMe9o4xpePfGtxHF6trBmsNFinhGeYc01GfZjb0CooJlSwI0mvSY0PmDA0CAE/lHUVEw1bKhI6dlhP7mXm0x6oSgfqDfQPut+VVwp4Mp1VXlCo1RVht3czNOypjWo0qb0luOZnkT5TK5z+bwKo4fP+Kz9Mgys5keiVOXcovxPXzCcCrc6YTV81X4mbvQUMhescKE3ZH95JtNMOBYaKtKo5QErnkSMoq68lF5owG8eJAq0RK4m2+I5jUAaJ7nHM2zkefoyc5320C/5CJtyMfUwBrynXCbtWW/2U6MMBkHaN8QLevdZPbf4DRzpfa/Bo/LTmvTdtg2/A4cafMSTRiHnlHXoPUTBmKbXj7K77deQNq4p/1ePtgzbS6OWOXu5D06gDbwD9RL1wCOum67E6IJqHM0DltILKMPHHLtOf8nT6cSpdGo96XFJwRjzl//yX75sSqvXaUxVt2Me4f0Hf8b4lDj0t2FvemRxDbxqbBUOoxw0Qolv5zt0k0410CZeSRiU8ELEU+mv/JW/csElbaOnAaN8l3nywQ9+8O7Tn/703YMalihaU2UkKlgAWV1Nq6ByKmj77KQ8TEYAYNK4kQPPZJQQ83i9nSv/LQaD+ux0r9bXCZkd3rp+d78n+Cb4O2F7es4FOLP157Hp7CR4YgTPQqjmuKpC3aTMTUK3i6ZWYdp34XSR4j+MiDoNU+vocIWzXNyqEHgiiHVKTIdLd9wyrNS+6HJZ51Rto7a7UpxOhO56LRVOd2hg6OBfDyB3QTPuuNaZeOM9GCrjxLxk3KATmVn1CKr965RgFzSNdLp5ZgLCzPeW7yEYIACoIPBu7kyxK23/rK8T6CdYO0NYloovxl/3e3ebdW+nfQUdxkLXaRZYwuIM9ztVmJ9W6RTuU6V5p2DuePaKn3Tt7WjtWsVvgn163jaqgjC9ew0+6zur/kzr0I7PXFN2701zo+PF0++J32edpzx6NQZ17CqcdTwrvDt+Le9YGTZP5nm2Uw0l3e+VrLGiy1vwWOGr878bo2kt79aFEzimNbLWxzd8Fp6csiZypUK/iVm7krjv1vQVfJOsVOFLxUmlWENHhonYh9PQhqdV8rRd4FIekg5UyviNMq3yrVGINdGkzhofVO58F1lK+YXnlUfxSAYP/KcOlTo+KrZ6fKkQusGeirGbgl5TLjZVg+1XI07+rqFL3lN2sX/KihOfcyPKzbqEi2+Vd+VoPU9S3l3pXrmpljpg9ifnsPpi5iX1HvNGnUxDjqFHjgcyl6ec6VWDUSc9VNKLRs+jTGGRm8MZTuX80AtILy4NOdITSjXyKrIV+HTuqKADg0p+5ubRc8SwxPQYkRfQN/qDjCddQi+GfOpBk3KhcGug05tGWslDtpKmulxMGttyDGwr1y5l34wGMjTVk9UcB9+VR4pLw/SkwUywnZ5alMxZpEGKdzXwcl2jFtdtX48d2tdY5vhzXa8ho2vEW3p6pXGp5ieSF0lPws21zEP8yle+8p4vaH/Q8YL+MA4mOmdTG70517s0xKY3Im2p13rfOSoejOARh5kfyrmHroBRCdr+lV/5lYvnlPodeePIjQuswEV9GJ/gu6dr/7FhSYYmsnQzlZhOjQMnZRIgu/85eczbolueuUi0FmcG9x1stwjv1z67Enq9vxOiVmUlIN5SctJ3eVz0XiJsiLFgEmPxRCl3Amc9JwJn/Z8J4ZxMMFt3ErD+Ov5MWiZGl/MgF+tU6hKuiqsaNjEJxFPf8lnD3zCmuECIWxPOJ9yndFDvd0J5VX53xb7p6mliPPDnLhHfWN0xOibjrTAxJjBdmJqLnbs+1IcRp6OVDt7aFxcCrfr8N+eFXnW1DoUsd0zxeDLUEzpmIcMttBr5sm/pbjzBfKJYJT0JjzsL7joDL9fAIXDaV5g+xrDqrfNYZVKkd6FHCkf5TBW2LSd9rO9V4Xni86u6r50/u1Jh2ym/+d60QVJ509TfyfixmmsTPLeU07WsloQ5laIVjYmnxNlqrHdzNoXAlULWrQPdmOye6/q/wl83XhVXuzXkBBcdzKvfu3u1zR08VWaq10/aWvXHehln1qlUtNw91gMIOaR6xnbtdzy/wlxhWOGA4kaEm24eAMJ6kYfXZIjMqv5nUdJjIPO4qARp3FGOR9lBpmS98/RWw7IsvKeimbwAmSo9LAjp0ruejZpMeM2zPsf7GQmh7Ci8yh0ZwgRNUC/feDobyuLmVsLqO1mSDjIkLT1Qkn/okc14u5kubuvJXyrJKtnmO8rwTcOeMsym8riEsVtfsz3gMb9M0qchbl5TRlPO5B11CeryRDe+00NNnUQvpjSq6iGix5U6K3MZOvJAlMQx38wlZC/kLBVtYaAf0I4GAo15bkxKQ46JuYlT9tc4kx5k1GUepzzRWY+UPCSIujzJWOOSie1zzBwHjWnJIxxno0s0oKb3UeY9MkUDsHnCmnmMjQ5wjtE2uMrxqDnBnFsafTRUAoc0bB/47Ria39Y5mvxNg3LSanpCgR/awutKrz4+zjNpSTtHhssJi/Wph4qnpIG/8EI4mvREf3SE0KOSscDI8+1vf/vec4ySG9jyQeeW9Kx3ll5JmYc1Pazsmzlk0RPI72QSenmVBjh4IfoZIcmOnfxiSnl0s2FJjyQa1gXUmEc9Fbpyq9B4bZEgYOIg0jASB5NBw8DRCdg7ReJplp1QuNutvAXu3XsrI8ZKaeY/k4oxgMHrxpzHK+4UutVv3oERYCxyMYL2UMA9dUCXZ4UnmF8Nf+yUpJ2iUQ1H9bqfaqxa4Vnrcyb0S9fLumB3uOn+Z5n6vRKwp91tF3eFAeNzva/wYCxyFewVzM15wLPmJDCcEXfXCkcdmwluDUi6gSucAld3ch9FYYTEdNaLMEG/MPoRb8y3TLeOiUlRXQhd4GXyp4aCOtfktVyH8cPsWRD4DZ0DIx+TRrpIPZTC/5ClGjlWPKZe29W3uz89d0L/p+3lc1M5UWhPFPJTuDqPyw6e3ZzK5+r1CnP+Py0J42qtq9fr+t19T6VTkGpfTvpRaWyHwwpvlt041LpWbXb1VMVvgqXOnYqT6bvW18E54XnqQ4XvWrll1bdr6rQe5hTKJTxf5Q9ezJoGD2Yd0Vt0Nd4d7Z1uYFW4ss8qqu7Ga+DI0BaVpdy9fsyiYmYfVFz0Kkm+wLrufTdUDPFD3tf7Io/KVuEz74nrs8ozModeU6zjjCtwGOZkwl3DTMS5Bg2NRyrBKnPABUzWyYYZHi/p4WM9KoJpMNIAWEN5vV/nsAYnE0xnaEwN/0mPrvTayT6qyIpTPS+UgVJmtk4NEJYM4eMeuKTezGWFTKPOljC40ar+4DyjIMtp5GDsTMPAf+Zn0o7tVsOg4WB6o2mE0jhLf/Xy0HPDuW1fkck8vS5zRdl36SHzP6mTSvu0gW5KnzQ6AKN0nTQs7GkABFbH0JQjefqxcz1zGXnPNBSGizkP0jvG562T6ybS14hF/zGosynr5iY4S8OsxjxlVOe9Y+J9YTNfVRqY01nEE980suT7Na+W46DhOD2mMmeTkTDSigavPPXQOqVtvjXYaFT70Y9+dDFE4gUEnOg36eGmEQ884q2Uxhvnu2OhcTjDSL3u8xkCCByOq23qwcXz8AbSaGBYMszNeazRFRi5z+mP5nvVs/PBk3d7ckK683kUeuex1JVTgS2fXylhlbmKRJADUnWRBRkiZafsP3a5RujshLuVAD5d29VR28tnunedlPneJExV4VLruhPJySvjNqeP1nIntgxWw4fWVSdo19/6u8J2KuRTYFYwEGDRi0rrdQ3tqguzQkDFVTdO3X/xJ95kImnc6N5fKSdVeXBc5QG6+FJ0u84FbIc7GZjCCwzMhKK219Fh9rl7xuTV7hoAF/QCr0qX6HyXe/AKjFompOQexiYWiIwPz/YYc3Y9iL13x0oDNnB0Me9+V/qewv/cEWdBoC3onAVJryrapT28xTxhb+UV9CzKxOdP59akOFdlatX+iuZP5nW+W9t9kvVj1X7lSalo1PmYRpiur96f2toZAyblfGpvevak39O6U+f4CU2txuYU3lvmTmdgWcHdtbcyrHX1rGSC/F/f3eFxtT6fwLKa5x3/XtFfPruqc4e3rh/TO93a4u9MyKziwdrAmsH6pWdErjO2O4XIrdbfbHuS03L9d22xuOngOqsCUT1kHqsoA6iwCFfmGMlwIxQ1cKwCqMEseWLmfOFbI4neGKnIGr5CMT8JBiHxqDGD/yYJ5neeEkXRMJFpDaAHDRzKqClHqRBaVHIr/03+YKljb5seioK8YKJgFeekxQxLyygADRQazui/eNHzKNeW9MigpNdWhvDYP0P8Keawgj6BW4eF9LagGImi54+KNkY7rpHHxrFU/qMNQ+c02GhcE1fccyPcUNE8oMr0Goy545xjACyMsYYi5eH0dtEbpuaEpfAeeXaEyT6bCFzPpgwT657VcGjYpm0m7fCtp5JzxhzE6R2TNKI8n/NFY6ceWPyW/9EmBjKNec4hjbwabsSj8yU98tKo5XeGw+px5dwRNum10i/39QTTmKXR0vQsics84U1a8JuS80m8C3PmnPrud797MSQDK+Fm0JE4sV96DGK01DPPsdFQxHN6xRluKa9KODKkOOdcrkN6OaE7GP7JdYzezAGiIhwLYObEQ412wKpx9UENS+lqaqnW9650gk4VLqayW3C7Z1QqdY+jpEKZC3Bt+1qF4URJWZVJwJv6XfE2CRrduysBfFKYJsE1YZ+Uvan+TmjMj66j7gi6YwHj0gKbyjOLEoKAOw8UFzsZfIeXTlju+rfCZTJOJiUWe2PXXYyZjCyKeQJLHa+TMZzGQ4GJ/nsSiIzJ/Fad0aIT4PNehwOFZt2ZKca261JahedsQ/dgPYDcKYHpwoTBUxqpO+WsU5BSCVC4kIknvaTwk+/SJ8ZJbydObNAoqNFPnmK7fDx62BxI0K3x8t/73vcufe36oZcTz+nyTNsy8Rwr7+mqzjvAzwLO4mWo53PPPXf3xS9+8T4GfVJinkWp/d3x1UkZ3tFsKhMuwvns1P4Onm69WsHSfU/97Prb4WHVZjVArPjY1L+JJ9bv1XO7a0+yXu76t3tnZyjo+Mj03km70zrZ1Vn5zzXt1LqmOqb5V5/txrqj5WldXPHlXV9yXFbvnNBChbWupyeyVqWTDj7G7oc//OFlw0ElxDWiblx0dXbwdv3s5LXavzo2ykoqFnpP5JrK+sF6wmZEPbnuMYqeEobAqTDlposyB/81FKnEu8HohovrYW52sSay3qJQ5QlV5rH0tCXDa8yjk0mWzZOCl7CpFjAquGHF2u/mknDrWWNuJ2REjVi8h0xrSWNNjmtd13zWNiqdISdgaEGWIoeUfTXvXRBhMAAAz5ZJREFUioqjsjJFecHNOOqgPzxnyBe/gZdPJjNOj6vqyaFBIeUu+q1MAz40gGmg1QCgEU4HAcPKKOYdsk/mlUE55h3oID19TI6toYFnGRuK8rJyl0ZXk1sbkUOfVPb1BFR2E6+OgW1lyF+eOuhGquG00pjzNE9Yy5Pwuk1b2/PbdnhGQ4WyqjBTD20jh9sv308jSRqz9AJzzD0RXhle2V7vHtvU0KPcq+eRdJxjVE+pzE1mDTyGmEmb6jrWoSxO0ZAmru2PfdSo5sayvFzYHL/Euzw/DXnmmjX30R//8R/fffOb37z79//+31/yFTF/nDN6FNnf//Jf/sslIXYaydU7bEfeIx05F7gvfoVLPUy60wCnATt5F7+BGX2HTeu/+lf/6o8Z097//vdf7mP85P2vfvWrP2bzebDk3Q76JFiuBGoHJhfqa4Qq28jvrh3v1wVei7EWWwncONapjx1sK8VgBd/u+dX7GdMpg3LBm4wntc5JYTuFdYX3mmei61snXCWjpA6P7zTESvdJ3q0nXjnRtYTLHMVHnoqROMg2uwW6wtjh0+JJZMDsEZB+cjfOEycqPqcxqfiucyaNG7SPUckYZZmH8fWetFLLjk4r7TAW9EPXaRicBlxjruv4ZF2OCYI5gq0x9e6uSEdpwEk8pMBJ6QxmLkJpSO6E/SzuDNmX9BSxrqwvx16BkmcVWo3Br8cNS6+eXMczvE8bMHpyPuQ77gYhJCo0mW+ANoiB1lMJRcfTR7q59qxLp+h1PKEKSqvrWW+uJ5TJkHbN2tI92ymenTJ+wltX/LPypEmZPl0vd+txfWZSdDs+NPVrtUbs+r6C/1p5o2tjKlO/5Rsn4XnXKOar/laYqhyyw+1EJ/V6/d3VfTImJ/BN8yXvdXLBtIas/u94RH1+Nw7T+LrJkGEB1UNp159raKfygo42KG6kZfgTcOk96266SbvruvjYxqU0gJk8u671Gi5Y51TSjEbwo8EojQkqdSh54MnTol37NRr423AbcKdBRO8QFWaf0UNC/AOfz2b4vcq4IYtuqiX+OzlDmUh6zrUuvT2kCcP7eQ7jTZ4Ile+4AZvypIZJSp6qptc09WC8y43EPA7dvmQC7Krr6YnmCcEY65SDHDcNjCrq4sbxB4fIPuLYY9A9tEXjogYCZUrD5qQLPYv8zzh7Tdqk2C+NXnpyafSkpHEKGMEZeoF903Cp51t6RmlM0EBgPbbtR8OH9KfBIqMjpFG/eS9DC2lbY50eURpQpL30HEyvI+nRnD0arpxjbug73hpRuOfpeRqjuC9u5E0a3qT/1M2TZvVacyNf464H3KgnaBRk3mci7pyThkXqgaqB2Ny3ttPlVtLArf5g2//rf/2vu09+8pMXuf1Nb3rTZcNZfix/I3frZz/72fs0Han7OLYahaRReaKhlebo0qNMvEnjjo9zQf7G+Ju6A73DMN1f/dVfveiSFMIaMYx97Wtfu/v93//9S2jcqaxzbFjqFrLT0i3mK4GkW0ivKZWZWY/xjhoAuGaoDAtI7uCcKAhVcLlGwJz6u8pxA9wwYSaJ9wwhEv6qbFc8PARsdaGoi10VHhOWqejaiguejIJ3M9wKY0THbHM8XCA0dHQLNb/TJdTJ1gm9O5hN8GcCvnxHwwMfj/bthIhT3CdcMlmYALHeCky5WwfudHlMZp9wrhTibl6CV0LGwK2hZi5q9UScTukGDhc1GSRz0gSE0LMLnkIE77m4mbeAa+4YdmF/CUNHj5X/CJttVXrp6MBTGDzpQkXUnYUqHJpTwJP1zM+g8JICsvBwDaZPn8Gbx82yGHFdg1J6Oz22okDp+OikeFJSgT9RHnf3dnB1MNQyrQPTXLkV7wmPNDTBXRX7+v7J+tX1Y1W/950Xle/m+7Wua40XlUedwH4r7iejQ13fJvg6GFdr76kM1Y3rbg5cOxdq3Y5vN7bTex2sO/ysxqqDKdvo6q/3O5rs6Kkb3xXs3VrWhRxXGuramuSjCT8ruqnwZK4Urrkmp0dIbpQ8duG0LeHUmyVzDqnwuYueOWNMpK5ymvmQ6kanB6Vksl0NLpkEOpV9T1z1ffGb3gSs4ypq1diokmwInsq0IX2eUJd0VNdBfytf1PmZIWNJG3pu0ybGJfNF1eS7yu4q7LavgUwjncY45S/qtn7kDz0rUgat3g0Ju8YEZHo3hjWGaCiRTh1Pi6eZaVxRydYAIOx6gbj5np7rwqB3msan9KhRqU+DDQWZG9pA9jLXK/UZ+pYeXdZDMQePxi3HSZjsY46nsJpfx3lhe85tYLDfetNoIJE3UMSFSbUzLFN8arxIQ5FzUWOoYYyGivIshkcKdemtl0m41eXcUKVODG/UYwij8xxcYcBUr3A8zZebnlmOmUY5DasaUI0ssI/JF5MuaribuMzE6xoy0zgrb/CZP3+BT2iABRfvfOc7L33VuMbBQBhqDLHUqJdGMcdD+kmDurzKU/mM5skxEw75ivYODFro2Rrh9UT8F//iX1yiIF772tdekneD63/8j//xxavKsVDPfVCPpVsF505QWi3Ep0LFSlCogiKDBIPVxTOPcZSxgLzJMPPQODkptQ8wNBh7jZGlTyjZHok+eVh0gtKt8GQdO+FyUsTyGSYWffNoxNzpycmW9fPNhHLxljHTd0+HMHTIpIDuXLnYaugAdzJuYfOTC3q2L1MTNmNha5xwwr5S3k7wn+3TDsycPioMVau8C27uNuTOmV46mX+s0oy7A9abu0jC09HCJLz7X5diPXgUILHyYzRRUNEoA31wggLzlWvQPeOGwJiL50RzCdeqn5nnS2HWQwDSIwtGi5HNhcsF0AXLev1W8BFOhUsKfad/5pmyDykQmxjRHdQ0iCffepo86aScGBDqvTomOccmRXelbFNqHqLKc7KeE8V8MjZkm7XOa9vY5T7ZGV1Ole68fzI+U7+7tbrre1d2+NkZONLw3PGdXdkZJKZ2VzB3z3V1ruCbDAmnME51nrQ7rem7ebOC56TtkzKN9Qq+Uzh286b2scOPO8QZwrJbh1Z98/0u9DWfzWt6gygjUlyPplyoTzouT1L0RqdoIHD9Ux5wbdeYpHKtfOfGHZ80AqSRyPAf5AVyIho+Qt/Nb6InhG1zz7ATFcrkO+oQtKtnPNc19qSXgOOl4QRZHtj1ZLfOavBT/rGkYcHnvZYhaXo/QAvIU2w+mtxaeThl0+y7incmPTb3JHKZIVV6NiD7eOKenicaCdNolpsmjo2eEyjdev7kaVp8qzQrn6fHipENwp7eScpWqXA7Rnry64GkDsg9++27yp96x6h3pEHCfFZu6kpznrSWKSMSx0nbjqHvVoOHz7p57vhlTjfly0xUbeihxhSNFSkzy7M0zHU0ZpsapuR5yO6EXZo0nmelBcIyyeGj8dV3qMvxZmPeea3HmQZNaC5zKeX8FF+ezKgnf+ZDtT31M2Vo9b3Et3NUOV4dm98eVJbeqvlOGggpGtI4vZmQMuiDdzEm8QzvkribZ7iWXnIU6cx5rC5ihIpzWd6ShsE0DmuoEw+GyppLDrybNoW68KD63d/93csz5j1Lh5vTDYmrDEsnivAkFK3qpNQQl2rgmd6r/6sS6z29A3QJTLc/kMuzKGo1LO6030+rpEKUSaph5DAMM7YzOekbk9h8WLcaMLp3rhXUT8fOvqVgJGPS/VI37lTqkwnoUuvuhK7fJtPWcmuCORZCDEvWpfVcpd4Y/swjlMnfE2Z3WWSWMnTblGF39HwrTSXDNI42EwXSnzRuJa6BF2aHxRomC4PBFRJGUmlfpi0jo4BrcJGGv6lPVRivO3PAoreVC7DJ+TTaWB/XzUukMOoiQZ8Z22o0OsGvY5ZJ8AyVhXaYV+yqgqNvfOMb9zsM9gdawyWbRRV4eA8+ooFXPPidu2Aa9XxO+krY+PAM85p6va4AU721HkqJe5LS0cW1PHylhK+U/smAVA0kneLY9ePkWkdrKwVuZZzqDBfd/RV+87lVKFfCVOs85U2dIlzr3cHo/2uMJSsauZb2rzH61FJ53Irucjx3fV3VWeudjDun8ybr2T03vXcCa9fn6VrtY70+ySZ1/k91Vbzlu9M8yzFU2VR5MyT+Na95zUVp4TRRFcdVG3l9wl/HWyp8Kfir2Hq9fh5zbajF8HmVuwwr0jCgXJKncrmxZA6V9AhKnpd4ADeeEsx6zTWUK5W39LLRQOEJZa7dmZxbg0GGQKlfKJumspgyLvViTPEUs2n800tU+ps2TDpeDJwal/BCQO7zkA/rooj3NFKohym3qVcAs+Fxeq4ot1GfuSXFqXCkgSyVXzeCkdd9RtlT7wzHV6OHirRGLmnAd/NkOT2caC/TiKSBzc1B5Dv6l0maNTopE3rKsN7mbjwqkzkG6XWVBqI0/tmORhP1hDxRrc51DSJ58p3eK6ZmcJNb3CqPJkxZp7wjc/0krUnHho05znyz2UuiZ/heerYwx6gT2lOHcyy5rqHNxOyeEO3cYn5Qv8Yl5WNxZz/gu+ZSS9kuDVGZHsWIGK4Bo8ZJ3jfHlzjxv+NkOKP0lB52abj/6Z/+6btXvOIVF08lxsVIDPqqzgi9YZDjHutFJhgX1/zOUD/0JUNH3exOvpeheak7aaikbfVgPhi3hA+a5ptUJc6B9KzTe/RBDUud4LASnlfXk0GqTOoeBwJNrJcMd4IlPSlysa7CjpbQTFqXmdQzbGinPHSCwUOWTsBxIoITvXC0fsvYMZbQJ9zs8ujK3TidKFC1v50wd1Imwcn+GVYlY+QeEzLD4BI+w4UyTl8rusfAc03GhbHCHQqZN7iDOSlIwNwo6e4IzmGaVVhMY0y1OnMfw0MaGTqB+FYackeK+pk/7sJRNGBkMj0+4AFXx1e/+tUXpgLMX/7yl+8XhDSGGHrpbpehXAgmGpg6Jf2UJhgDreYyaRdThZRkssBuPDH3dIXXNTsNV8Kyw608RO8/+suOJgIYCyYf6OE//af/dDEuSaP2ERybWF4YFHIqbjRQCpe5MFykwWkaL6tQomBN6TyUngYvepJyC398EuPCzjByqtTvjD+dwWYFy6Q4r547MXZM/ejqURjr1saO13dt1rW1e+5EMZ6eq33arTF1LDqcndDfDrd1jKZ703jkGKwMMBosdrCdwF/hmQwt17TV9bvj9zvarzg8KRPN1fZ3MKzoq/uuv32Ptdbchn5QhFjP+CCDpWyQcK1kgK6tUx6aMlG3s5xtXIv/p1XywA43AdNzXNnWsVVeQxYwDEeZMRPaqgCpvFPsM/pF5r7R80XZzdPJ5CuOo4YDlXc9I2ooU45xGqM0VgkDcgVyBpt6ddPUd+y3xoTKgycP1zpPkB2Qocn3Ap6RgzP/aHrHpPePbaWHi31105Tf5hPNcCNPe8uE5smr7acyU+aSsT4dAjwNMPVCDYx6kwifp7ulYUA8Js7MlaX8x3uZPkODEm0zvxl7cKiniO94ulieCpcb3SZ3Ft/STY5VGgXEV64ZfpvHs/IujW30lXnh6dSGGYp7cwprNMhoBmHXiGCpxqX0hqQNDYIYkHQIAI/007HTMcDcP7wv/ai/UAcysDqM71K/40KdGrcoepLBc4FFr0U3b2nLBPvmnJVfayhSh7A+x1N6Tq+gDCnL3F91Xv7cz/3c3bvf/e6LvsR/+pl9kAZpl41+kn3DC9U1M0m5uhjrDc9isEJfM9VKesoJs8a/TBqvfudhWNAyhwyJC8bBQ4TSO9NyalS6KXl3lpXA3N3Pa4bBGNrlBJcBZ3LB+j4fE+A5GbV+qvR1bTpIWuczFvsapf9WAfZJigTJxEmLZy42XjOxXMXfBONKWFy9fyJUnwqnLi4wEZmecfMwrPTsqIKRu3QKFwgNmfNIIYFx1+VSBqfQomsvbSvgCFfmSkrjC4XxINYag0TSIvBxzzjbEwPHCtdVqNYwASOgrzALxp57JlZ0PqSxyMSDfLvjZ16rhAF8UR/z08UJnPGeOwS6905hWCuFNYULmaHtGodePX4ymZ3GqLowdu2vjAS5ILN7QLK69773vfe7Ai4A8qeER0GGovusBj4FzxSSed7dDhh7xua7q5YCXIVboXTq46qvj1FuUSJPFOD6rL8TZ7v3bsXTyqBQhYtr6sv/VYnOduo7u7a6ObCDbTVf8v3TPq4MDSftTu8lvq+p66RU2jq5tzNgdPcTp9fCnM/v+O5D8IdUCisc0/+OlqsMUO93MO5o7vT6Nfxlqgd+zWYLnqxs5nmfdViBvir8u7Wo8q0c1xUvWJWTdk7relpFZdvQtuyrm43ydT56FLMeI+dlPkaVTTcYXUtViDzFSq92NpD0wlEmVB7Qc8PNLg0oKnCexqR8pWcLMqShY+Zdyo9ylt7O0BAKpZ5Lladl2FflE2mo7ug5DRDcpw/Iqmy6Imfroa8xL72FeD6TcdvHzMVE8T1kHcdHhVbFPY0YE29KhTvr4yOu9UxS3tQooNeSOT/FmzI+z5ubUtncceY3NEQbeq9oHKFeZWXawqODj7CJA41pfHi3jp/9TKNd9WTT+JNhao6F7diXPMmuek1KF5lXimc8zdDcs9KmuHCMnS+OX/IfroML/rspr+FWmR25Vj0rdfHUEaRz6UcaMbeSfdHLRyNLRoNo+KBO2tU4okOC+qDGSvEnLBqsM9dSGjR9LvMtpcdZGjLVAZK+f/7nf/7u7W9/+/3Jj/TDw3XkRybPdvPahPvmmUtdgm/qfN3rXnfRSzAI8QyGJmDDOC1tZ46tKpfatnRmeHDmsus2wJyjTy0Ubqc8TAthrUcLHEhykgq8bq5OjCp0ZBLfjNnVra6egpXePjI9Q1pMcOYgTwLaTuCdBIMnLVkP/YJA6bfueznQOUEnQfwUthOlfPfequ56X6WbGO7cidKCuhOgpRtpS4ORk53f4MwkyMYTq9jzjAunkzETPbrQeEypbYNvjEeMizsc0JfuslrLd/PhBLf1WeqlDa6Z0FqDE+1yr84fPbwIrdKolLG6Sc8a0zTAiWPD0qhH4SMX01V/8hmPPE2XZ9owd5Bj4Bw3fto4cg1rJv6z3luEcMbsDW94w9173vOey46AdACz//znP3/3H//jf7z3/sqxsK+Zt0s+Bv7lR2kUdSFLDyTvTcp7CmAr/nrCf59FWSnm3bMV3l0Il6WuO1N7ledU77b6TP098axOQbvFeDJdq3hMWCZDxg4XU7sn753gIevtDCZ1rl5DK7VM766MK/X91bN1Pp3WUetatT/Bt7tWedFUdyef7eDrrid/qrBXPEzjOLVR76lAXEsP/2977/Jz/XLc9T5x4KDzD0CMHF+yY8fxth3j2M7GJDZJCEqABAkGICYMUJgzQwyY8g/ADAmIQDDBEhcRcEJCINgb2/hub9s7vmwu8wOzk4Ozjz5L+/Pq6zpV3b2e93nfd6OzWlpaa/0u3dXV1dVV1VXVd4t2al2dvNr1qdbBuolRwk1RBXNTERAybTjQChenpdJWpbdr1rxnvS7UosLmeuvGXub2Sd3AE+3c1HLHXhlNuUB5JhVQPVn4bV4kvbw9mSnXnkzKyyePS1cu9HloAaXPI96Rj4AVeRZP59ws1WClhwFKpcmOJ5pdjfm0DqXRwc0rw30Mm0J2SiXZelX+hckN1vTQSkOHIWqm6+C+4Tb1pF2/q6eptJDGFb1sgFueoKyuTM81DQqORxoEkNvBMfUaVmWeIGUxE2DrCU8b5i61/fTmMA+sdKphSYNF0o3jbC6glKWlBftpn3PcM/ySokHN+/mMBtXMKatXD8YljXdGZyTNWZf4yXFJ2lOXdhyhXdNSYOzVwcE5l9FEKcNmm5nSQe8tvfSNlkiDW4azmSNNvVcjiZ5PenA5TtKrOVwzlCx15+yjcMp/hDflcu0Lb3jDGy5GSuaXxjbnnfSqQcvnsYUYYkp9GrC1gZgE3TQv5swCXuqkHfUT8WefpGFh5FNzRuXJ3JNMKF948FA4AVXhltg719uVsKXhyAH3udy1gFB1fawwaElOLwIHSWJLa2meOoFlU88LXcTwiEE46LydduUaIf6krAQbCAri84hBLdQ+5zhkqM5O4LhWsO/G9RolpHsmYYVJmeRNhlQNM5Og5bPG+OoSnTs+TmQt41rgO2ZnOxmOVOFwXJjowu29XFxWAvkOx1WIyGu0jfEC2rYvMk29ZXwH+MHvSy+9dMEPsbQsBMT3utPSjat16P7rbobM2kU8cZLvT+POe7hkAy/z2XwJzEXgp374gMZf4OCewgt9Ye52xrtTxTJh1mAGk6YdlIMvf/nLd5/73OcuO301TNb6DBH0SNGkIxeuFAyqMlPrq7/r2O+Ug2etPJwo4/X5k2tdSYG1zuMsK6PD9MyOL05K/47W8ncavnf1n/Lfqgzv3p+ePV2fTowIp8rvimauoaeEswsvW82l5P+rtX3qT1UIuzKNUW3zdA2d4DsZ/x0Odl5LE/3t2l29M83jrk91vE/LtKbu4DN1A7Kkh4Swdpmr0Bw2p/y6PtONTw2zWhkWpnpej0UvE+BXnlexzrwe0qOpDVzzTZKrp4GHuViUHaxP2VAvJA0oaZigpEeLip0eD16jfdrl3Xe84x2XDyGQbDCZf+dd73rX3b/6V//q7r//9/9+eVeYrUd5N406uani7wwj2/GQ5D/ISRhVPHlLRZK+o4OpoKdyrDEi5SLlSo1UafjVWKdBg6KRT1iqPOAn+1U91FORdfx8x2uetIb8pbwvPWn00sCg54eGAZ7V0MKzepEznowfsqD5Oxknc4umATPh5j1w6nPc13Dpc6nTpOFP2k76sA+Z3sL3qp5R5V83tqVd4DIFCLjKHLZ+km6M/nA+avzS+8d2wQ88D5pHl1A/Z3OWd/7Tf/pPj+axBuEMM03dLek4D+6RRiwZ3aAHnXzAkx49sU5+Qd0ajXheDyvf0+BCnTptmNxd3SO90qZ11c//9dpJa+JIxwR0BAo6m8nEjXQRf0a4qMcLF+3iqZRREDrDqL/psZdebdJTzte0l4ifNOyl7uu1083ey1w7euq1il1MU6GkIyDCQUorXyK8FonITOYy/zxZy/w0+b4eRybaTY8lCVgGkwsv9bPga7Ukv4yxm1yv8YOd8ndqVOGaVuHVu6t6JkEBPKPkUkxOnaE0EKwL1dTOysjRCbq7slIQqtA3/bZ07naTgNYJWE4yJyvFHQInky6AmchPZqNByjAyma2LUAdLCgWVWVbc5xis8LxSNKsQqgU8F9TER76jOzTzh6TT7gqm27N1mBjOOZmGVy3uK6VnRzvCjccXhhyZvjtQhBvAeI1Vp3iaBwYlrfY5dzsBvVN+c4wUEr7whS886i+LpbtUerglT0khUCFE4SDdnFnQmZOVL9Y5mLTR0c+Of1z73JMs1yjCta87Y0RXV1fvDr7TuicDQbe+rZ5dzef7wN/BUuupvHZV9zWwrPCWSvBJH+o6cQLjauwmw8MJ/Pc1UOxgqHy+uzf16dRok3Vf04duLaqwrvB5SrMrOKc+deOxa2vCdbe+dnKQ39UzNOtlLXj55Zcf7ULjlaIsbC6RVPSumUsdz5/W/by/kx9O8fAsirKy+VPAo3K+SpXrf4aEabxL+PVWSr2AovynnKOslAegWJfrd4YaqTdQMvyN51FE8WCjPuRxFHrkBkJcSN7LZvA/+2f/7Hu8YlTSNJJVZc7xqjB4X7lFI1w3jhpJVGrpZ54Oxm+Tb4uzVMTT4JTjxDXTByjDCYNyo55kdYwqf0oDQ+pM1chksR5zJ5kexLQofPQscrzFTXqvGZ2QbfCe+i3X0jNImNQXxIdwm9dGnGeOW57JfFbqvRlVYaqJxJfjrNdehiIKVxpZMu+TXjzSUHrxaNzRoJX8ynadd+mVQ8nTD5W7X3nllYtR5IUXXrh46hAChuyOPP2xj33sEW7SCy3ncho0dJbgo76RxjRxIL1ap4m7DWnMlCYa/81xpKdWOmBIu3mCnGMkv2Ceitc0xIkz8fLqq69ePFfZuCenmVEf6DgafjwYSFrTAKSnUoYapsOMnpqUPPmy0qNzPK9rRF55HVV9uuqTk13h3oYlJq5HQkoouQNgWEomP+uUa6+LQJGkMcnBNPY5O1uF+VT8KR6jzqceDS4DRCHFIGOOGa6bR+ZxFtkUlnLx6xTJVdkJE8ALgaP40hdPAKOYfCtdeDs4K8xV8OmUpsctO1g6ZfqaenMh1nPIpHKOiwudGfApxk+DU5M66p6aXkp6AXUw1mudwJpw5IL9EDheGSHq+DoPaoLAjl7AkS6T5iWbcD8JuBO8vmfbdbfQMLyMhU7XYYo7AllnrX8HgzhhzrDjjJHLBUu4ZOoVRy50GL/S8018ZRjfNKelC3mfrvaOkc/X/EorZeVU0XvSZeIpq+vTPHoS/GjC58R7pz5VGOu9lfJe79d2Kt1UQ0SHs90ztd36Xu3n1Ed/V2/PaYw6Q0J3rRuLKshNRoFOiVnhvsPH6bNZ6lqaeKj4qX2c6uzq767Xvtb+1LoThm78O/zn8x2N1zY7OWaijfp84rDW26053Vh0/d/B09FUhwPWBDxQ8LalpDKYn66PHZzTcyteeK0cNdHFQ/HT+5aU5VOB5JqKMiUTXydt8tF4YiiRY5TyuHNQpZv1mQ0fT66iuFmeeoNrszpPnhDFc55+hccGBiQPHjLkBRkF49Kv//qv/39oVh0EOdUNdA8HyY3QKitONF/pRlwY5uIpal43HE/jmjKYG4kaKzKUznfTsCY+jD4xzD+fT7jrRmz2gVI9VGofc03wtGcPf8JLhbAiDQF6sNkPZTrHU6OddMazGjhphzpp12cM+VMGNczM8L8Mc5PuPG08jRriwQTVmWNJebPzVuM954Jta1xRp9b4keFsmUPIvoArZVU30s1tVA1oGapWxwGa/8pXvnKp8+d//ucvThvUaX5ZDTZ5OI84rXRRvdzEmfilWI/3TBBP8dAf9RW9pHg3D9XRdsHvzOelHC7fUP8Az/Qzw9Mq/WYI4//8n//zYljCyEYxbQ91mPOKQ5TYlHjxxRcfpTQRJ2lYEq5qmMs57tiodwif3nLCp4He/krTyYurDJP8Mw8/exDDEsqTVm8nY7qupltaF1ZTEaGnE+8wsTLmT+ZevYgktExInKEm7ihQn6cHWJy06TZnnKwnRDiIVQioi3An4CVTrxbBU2G11lV/J+OVwCXIxG21nua7U3srJeVUwFkJjrtSn+mE3BNBTAZr0jTjpXnG3Q0TADKp00DKcywCCitar8E1eM5QqE54rfDLKIyDlWF5EoKMIpnshKuJJnb4TUZRFYbMJ5WM3frAl6Fquhq7MGR8buJkwkcHVx2/7J8LvcJlWuNpM8NgH6c4X3JxTmNQLvbd/M9QXPmfcDvOlR8kw06Bj8UHPHMP+nXnLU9VmQTLCb+vl5J0t1obdvdPeKm4qm1PfD2fyesdXU7vdHXWd7trE9+b/tc5vHt/Vbp+nuC38txuzVy9M7Xd9aE+V132J/7W1XcCw6oPJ+vbaq3K50/pYaprRWcTPur/qa/THMl7q7q76127VYCd+lfrnWhnqqPOl26Mun6u+FCmfzhd/yb8V+XkGhnrRGbr4Nj18WmVTDAMLBnukzvvubEF3HpfqFgavlJlmTRSpJFGHcO8mB6AoidT1pHheaZPMFTHUCw3dD0cht94LVCvbQifxdOL6RtGKfOomC+lbgDaZh3v6u2UnjjiKnOAqkzaH+uoHirViyV5beYXUie0XdsDL+qCKd8m3SU+6uZBzo80rmTfactIDY0X4Bw5So8Vx4hi4nVh0biU40MdPIPDAffwYkJvMEG4ciL31FfprxvZ6pWGWGUi+Trf1EOBE5ilTWk2E3L73YWBGfpknh3bSWOQRhb7ay5bDWMalwwXzDGv4Xd8NDJo0CICgtA3isY9Tp8GJrx1LMKdtJ3eR3yMStKLxygGQ8cMN+Rj/i03ZXk3w1/ttx/r89Q8rzv2jq0GGo1LeuFp9MkNI40v4v13f/d37z772c9eZHoOBOI+xiTmO4XfbE588pOfvHybh0zYnYtphM2wwORJqUskn6secI5j6pzZ506myjm60k/vbVhyR94BV/lLxs01j2XU5asrTkyUdYghmZz5kVCsaoZ9fxuWYnwzJeHQMlvDdWREhrfkcaOJcJ/NshM4s2+r+yuc7J6vgshK0doRQNfPTuA4ISSfv0ZIWSkWE1y7uqzPCW7i5HRnTKOk/ylegwkqIEjL0Av11J2srs8ySl1i9WbROOLOD/UhTJhD7FTYmwTJio9OaPUasACXRgyYWiZJT6Ot+ADejAc2hriGeN2ndLTgtbpjl8w78xmthO0JN3lNJl69DXd0bVilpxDK/D35zdNeaj3CAD5ZbNL4qFHTPFLQcXXLrv05VRqfVjnlS3XsK0+baOMaI8ZD4eSUxrpyosyucFYV8B3vzzlj+9cYLqZy33l+zfit2q7vTcaFk/GfDCAr3tH93vHknUGkqzNL7h4nnKfvT3B2RqLTsTl5V+F1unfaxrVw7dbP0zYnWFfy0e7/ru4dXCdyUcKW712TI+NpFdfd/Ahj7qSznuYhK76ngsq6WUNEfNeP71P0PvLEMWQc5L3Mp6LxxLXXvC3qLxoBNEbhtQSOUSZRpHkXY4P5GSl5JLiJrU3fkUfFC6cb9bzn6XF6geTan95NGnzUdZQ91ZmULTJ5szKr8mmG/adRJ+e0a4yyix7ahjU6ntO8qBt4uVEo3Vav/o6PaNhRHzUhuboduE1PFmGSptJAknoA+iFjqnHHzUxDofTuMY+RfLoaNXOs8r91ZTSDY8/1DGfSEypD1NKopIErw9ty7DSW2B4fwtU82ZCiXpyGlzqXcozSAGP/yQH0zW9+85HuxLuevsgYpeFSDzJLhnpqAJPm+K++rueQ81NYGTPznGqgTmOxbWSSdPEpLenZZr0anRx76MhoqNxkT+PY9702L/DY+vjHP36JhHjb2952ORgI2R5+8Fu/9VsXXDm/tXsYgeSY2nfpN41Ftb2cG9bBfyPDxDlFXdQ605DonJOPVGPmgxqWckdB5VKEOpAOQFo3HbBaABaEqnjpokcdKlOZxCwZi94Auim6W1EXgSrwSCjUT5I9mB/IZ2fBhWAnfFcrXsKXgmkncJ0u6rWuSaiY6puE7ccVWFbwZn2dIPbQpcNpp3hpuKmKawc7RSalx4g0v3vPNvhAj3jBaWzIsCgZsQYEmI4L1VRv7Xf2taO96VkK7cN8P/ShD10S7NEu84HFgI/hZXW+MU/Bh4tBhobdV1idaNsdPxeXNPrI+ChVUD6ZYyulrutLp4xWxU46QShkzMUpnxpCV5k/C7DJ+HX3lcfaPxfkXIT/dyidIj0pt/nOzkD20PxkopuO/yZ/P6lv4v0rPlnxM/V3ZVTq4E9D0wr2rq4O9t3Yreq4T+nm4jRuu9LxUa93dNtdm9qcDFQrBekEzrw2jUF9b3ct6+5ovcJe6Xlacyidh0Fts/s/4SnXudqvvL5aB7s2JhydPLNajzvcnvKQVZu70skEXV+ulUufRMnj4bO49lOUm5QFNBaYGDmND9UL3JJ4MAkvv9EzhMGkvCqkeoFoDDDMCG8M7rEucx+ZiHX8537u5x4dBISnN7lbkZs4HEVvIw0SFGQtdBDq81RqvT/M8YIciQFA7y3q5WMep3qSWM6bVI6VPzViKV/k++pb4lCdL5XMahjhnqFCenR4clX19M5Sw6CqwpryWBoY9MjK8XS8wDc49bl8n+f0Cjd5O+NXcwP7LHWh+L/xjW+8eJxwrDuFvqVuKazpZafHSXoeJazmPMpxyLxewKeRTOOChw3Zb1NDZGim45FGQb2zPKnatsx5xDU9/wwD0+gqzeT4adTQCcR70D9zA/xnknf6wGnLGOiYa+oTwKn3XBoBU8ZVdk6DKXXofSYcznv5iQavPB1S2IVfepY3aGBxjBIWeVHl2/7PMLXKU//H//gfd5/+9KfvvvjFL97963/9ry/9NeeStJF5kxgPN/w1HDoG/ta7Lo2xwqFRLHNNi1u97cxPZV8z6X3SaeIgI0Ye1LAkkTpxkilkg1X5mRYtESVzFNEiOSdHLSBKJdf41Mqo8pMDDnwwFJIvwjy4xkJAfR0T7ISh7jsZZOIgd2FOFvEqtHSLY/fcSX1TG7WshJFdHyZlqd5fCTr5eyXk7/rZ1VNh6K45frk4dbAm03X8mSMwUYw3uchkMnEZt4udyQ9X+FjhtKORqb88i7DCLoL5pNhV4xsjXBoxktZkdBXWab6slL6VYC7eWTw8+SXxSzHhpcnUK54eR1CutJF1p+uoTNeFCv4BTC50uvhPRqUUyNypxLDkDlinnCZMXX2dYvOsyjS3Ov5QPWtO653Kaf93z1Q6PcXpbg7UuhOW3Rie4qfitXt316dOUb8W/6s6Tuh1x/+nd1MW6OZL18/TvnTvV1xPME51Tbioc77DRccDJvyscDXhZJKBJppYyQ6rvk5w7Ma4K49DU127K/pfjW3S4VSyjU7uOeEnXZ334UNPu7g+ekAHvzOBr3JSDQNBkdUr3Pc09qSiTVEuUzFLgxTrtmkO0kNEeUclTo8C1njeR25TV6FOjEcYLf7iX/yLl7o+85nPXOrCOEGoS6V9dR/qMiTJZNopE+qFQX/RdZ577rmLsYNn0WEwZBkunyX1Hb7dcNcrKXNGKXPQD/Pz8L5GmNzkc8wcDxNm62mjoUYD2SQ7p/xcZbsa1pPGJdutcyq9S2o7jqnjp8FQLx8NA1mnRkZ0Q/TEN73pTXc/8AM/cHlXj6ic79KPuFXuTyOcRaMo+NUThWekY/GdtJhGHnGWxjjhUTeXbinpqcQzGrOYKymDanwypUylIR1HUp/lY+SQJ60pv1O8Ds3qLILxyVBJ7tfk3uJPXGrw0hCm3J3jL/wU9YI0hFajW3o/ptHEb8cradS65El1bUjj7quhy6RnpWl/pEHGxTkjz2HOESpHUR+r7SRdZz8Mv9QQnvqHMItT+az0n1Fm9i3TpeQJiw9mWMrjCUVcWs7sjEahREQtKeg5uasA2AlmXje2md0A2jSExHdkbB1Tsz5d0NwZyIUt4dgVkc6gepwgbadbKcSRCcZO6q3CVyc8Vvf47t3HKavxO1WypucnHNdxp+yEx2vG61oBc6KHTrDm2xA6J2GeZpCMKHcIquB/KsROnoHVmNH1GzdN3sW4xP/MWTThoFMqKlwVxpWyMBUFFGA0t1MarjWA5W5Ewt0pMFM5nSc8pyGbOe7xqYbsKgh0ebgqbMnLMhGoPMKFHH7kEcGrvnX4vmZ+PnSpi+upgjfxicTZ9G5tf/Vuwti1Ve/Xdldw7p5blcpfHqfs2j5dg6ZyCt9JHdPaNdHxjkfm9YkPrt6rdLB6PmGeeMkJrnbt1P4krKu2an9270/8Ot+d+PppX+q9U/zVNnf1d/cneaPjL7t1azeuO7nsRK7peF7X1wn26ffrpaisGdJTw4b4rTcBRXlJxcjQEVMeKFMZhuOz7szrLZTyk+2Yo8VNIYvKlDoDzyDj+Q51IAf82q/92iXPzC/8wi9cnv/yl798Mf6osKXcbvgLhd/UR8mIC94zNMkcSegYyJh4MeHphGGJU7n0fHd805hi//TEpw6e0yCEPKMxQw8Y8InsgfFDL3XHIj3IHA+9r9xoy3HMd/nOXJQW6TeNStJ1KtI5XpVv5IZcrVt8GPaTbdYwovQ+QiYjCTPhS+Di7W9/+8XAZAoE5FNTIegRUsMGM2xKg4YJ56Un9eD0bBMXhkVlkumU1fO386iGwlE8SR0YzEEM3NSb70uX4sC+ZC4e4eIbvBhOmrjOMDxTb+iFYzobDXtprEw9PPHKhzrEqe+lUcb/RkBRNOKYL8m5YJ80sCjj81569XBP46352ByvGqpYx+PV8PhzLjgWeinWlD3MO+ozXFWcJg3btrYWnmUc4A3YRRLHSZOZJ8y56Lc5dNNILS+iXp95UMOSR2Z7HHt6azhQIN8dg53gOi2e3TPZSYtGLPOPAJcEx6QxiVlauCn8hzjx2NDbiXoyLKnCN8GTcPE+nh94qzAIeXoVOyIsOLiwZv27ks9Ur5R0/z0RoE7b3D33OMrS4yj2J4JsVSJOlJQK4ySETwJlLoIuuMlcvG77uaPi/xPhsbYF40QYSeu5i4Lx2XXxpkA30CHtEA7qosACh5DShZ+eCvOUtPbn/K5jU4Xdel3hi37oViuDnsLwJgUocbtTiuqz2S/wjTDnEaHuPJAEfpXM1felhRTUWNThXZ4W4SKmZ6W7Yx0/6vD4elAcruVtlp3yfvrsSpk+bX/1zrW0M8GYdZ7y5mva6eZabf8Exl3bkyHipJ3Vmpq/d3Q/1bXjD4/DGxKu+4zfBHN3fQXXro5Vv3Z4nmSwjmevYM5nT9rp+pLPTfywwllh3MmcFSertbmDqb5f663Pdu/u4FvVPcE9zaH70u1DFT1/MpREw0N6JaTilvc0wOjxoMKWRW8G5QgNSKytFr0mUNDc4MnDSTSkKHvr7aFXj+Hv/+bf/JtLAmOu6U0knHpiUB/rvfKZRh1luDwp2/uG3SFzkJPRU3NJjszmILIJJ0VrYHOzK0NeVOKti/f0oqAAj2E6wK5hS31PuUWjnp4uPKMBLGXfVLwzrEZ6TKMHpfIZlelp3qTRI9/r5mnXps9Vr3jlzNyg1QMLmsGb5B3veMfFIMd98VzDMtP4Yp3iJPNkGRrmPEh4Mi+Y9TgG9iUNAr5rLina0SiSRhPpOj2A1J9zczPzKUsHOScMZ6MYYiot8Qw6MXPE0+KZW3rWaKSyL9WwLHzSTiZY93R6N+g1jtFXD8MR9xq37JPzWFx3XkjqMcCQeXjlEbQnHvWuyjXm98rJhxlqmobyKkdRF3OJfusNqLGthqYlnZsHl/lL3/N0yc4LqzPMia+cU/RVe4bj+qCGJZP4GqfqRHEwTM41ef1Mgk8t3QKdEz7f0bjkhM8s+RmOlvVAQDAETw2w0CcmAQw1T2GaYM46QTp1wnD4GMMrvBI6bcP8r014zHPJEJNhuch2sO5wfVKehfBRBbtOUe8EsBWsOwH09J2u/VwcHSuZUXraGLLphNfzxnpOhF0XEgyjHhfq4pOeg7jwmly71gvjUuDJ3AWZzHGHq/pbuGBs6anlzo4nTnS4rb9TCEir/DQuK8VqV05pm7kLj3CnqSb+rInPK60a7gaf0OWYMQIv8Bzwphsr18SXOMg5MCnZ9fezLitYVspo3p+U4U5x6upblTpG2f507aQ/XT+uqWfHw6qh4LTPJwaM03Jtv04MG129k8Jc+XAKhbW+ru3uf6fwd21WWLL9FW/qfnd11md2+J3Gr8NNN986Ou/gW43faj4mLF1fV3Ov9iWf6+rb4WcnL5zO+WmMJnx1NHhNG929Dg8VlqroTu89q+IuuJthKeNS3KxTmVY219NDhVKvDg1VrMl5uI9KOwYY2vEkKRNZA4MeN7TDemxIjXKV8KiEaYThOa57CApyl/BbF3DxHm0BZyYzZnPcA16M+DBBsMmE9ZDAeOUpeCq4yCUcXY5swea4J9RlhIQymv89fQ58VC8x8PaDP/iDF/gME8ywJPvFczWXJCU3wuoc68Lfqhzdea1VOTsNjTUkTAU85eLKy9J4U1Na+J1yaMJJTl5wQ94lkjIzbuAgT+2zHg0tNbyPj0YddQLngp7vjr36nnqFel8a8CzK9GnI8P3Mhey8So8h60qPKUPoLCnjSqvCDv1Bi+oCXEOnhk4Mg7OPPJen81m3RidKJvd2TDXweTiXsJqkW16g3m0b2gTS48p6c9x9xjmfeoi0Qp/wGKRu+Ig4cdy/W06jtw7h0uEkaS7Tawgr//MdjVka1TJpuwYpnoXXaPTWwMQ7fDLxt7hwDtnP9OT0naTVBzUsSewqijnhKGnh3S1ck6A2veMC4IBoTMlEXLm70QkLyagyMa7XYf4wWZnkJNR1ApqDkpPatsCZnlEQI0zJBSthm0rCIQFAOOxaSGwmNNsZl+5THkL4qMLOND7+3rVbmf8K1pUCtmtrEoanNjR0ymj5L2NLLxUTB+LpUuPQV4qe9IXXDIbRTGpo+y4a7EbBDPTcS1jTAp44SHfL2u6koFF0SQcmXSbpo/MVmDCemNSxLoQVt1XgWCm+wpbwdcpT1nuNIm3d7nRmewpvzu9cUBIO8MBixJjo7aQ7LfH7Gt6Sua/46MQzdkrg0yrdOKRwl9d3ymp3Pz1Qa1sTbmqb3f/6XLbjvQpjbWNVTsbktI6Tsd4p51XYzvZP5tGqD51SXXnxDs4VbUz96taSVR0nMHXwTf2eYFvhbIWvE1gqfndrSPd+vV/hqTukEx11dVU+Po3PtB6vZINdf7p6uufq745HTbQyyYpT+ys46vPX0NrJ+x2sz3KtML8qxXQUytAqVYnzPOhE5SjDfJSNc1OGwnWNOXqIeJ91G7nFiAvXeq5lzsPcsE5vJvuQp1grT5k/RY+p9LpwfeF9NpkM+xemVJqzLxqX6D9tssnoRjmyoTlo6xyusiLf4CrD8NV9wBfGJXQWckTpOU1RqaVvGp7qRj6fNG7IQ6pRRzpML4rqiZS/02PGa3XT3eey7/ZZ2TSv1dAlf1ufbaaMjfHwpZdeuvQd/OuhpkzuJnIaFqRV72mwU0YUt4lfcSItaFSoicEt0pljqUHDiB7oW3k28SV9S7fpnSeNZ6ikY2eoJTQKLUIvyLnIxLZDPw3ryrA76zA0Kz2a+G8/xUF62Jh/1f/C5OY2dG0SbL2lnPfOwzxZTvw6r9PTL3kQeKCfGG346LFUvfNeLQbPpP3Enzh07Gw350E6y2T0S+LQfnhinhEt4F0a0JDknHRT3HEXrky8roE7aeZBDUsS78o7ZlKArln8vW9xgdFbQGZVw+46JTSZQyoLurA5eFpv9SqaBJxap4MOLDn5tZym14bMJpNhSbgnxXZ5nxhfJrAMBNywU6H7633LiXC0E7JO27GcvjsJgh3MO7h2dLoSZFeF52CcCAkeIZ/GJCc3hkA+xjnvhLy8xhwwfE1BLHcl88QTE+d1uFsJ+53gP+HAhddEhPy3r+nuyn2NnzWMdqK7lWDcwZFuw/X5E7o+EbZ9zt0kXfE7paGGySZ/4VsjU+4WdTio45T8rOvrs1QUEpb7wJSCTq2jPlOfz2srxa/icmpngu0U7scpEyyruZkCx66s1ubud/d/V3fCNL0/KerXtLeDdeJx19DlijauxUttd/d7Z2A47fuqvol2Kl/Ld1dr8grux+FPE3+f7nf0NfGHCcaujx1cJ/zhZI3p6u1wO43FNevpqk9Pq5g7hsJ3etpkmIzwqyAiR6h8K2+Y35LCc3oVG+JWj9Wm6G2sjK5+YZ16d6eiZ7iKnjuZj8XrOXZuQumZYJ3CgaEiw3jw/lB+S2XXQ1ZU/j1pS49qn8MQlIYuSyqn9IHnMCDpWaPnh6H5GWaXR5YDB5tiiU/HsCZWrpv4yjxpGEkPHK9pmMnrOXaV9rOvKVell1SF1TKtp/4XxvSU4vONb3zjkn8JHEE3nvCb/UonCOHW8z2Pgrc97kGvOg44/jpXZBJlDRvWqZFGY6b18DE6gmfUgTN8L+dcxUMaXRInFtrLdA7p7GHYJLSUNON9568GXT1wnHN13XQOpO6k4QljkkY0jS3OR+deeih60qPeTxmtpLHP/vKf52mbZ6hHD0j5UJbfaw4eEleJX6+5QW2YZOLJ+a69IscjbSBp5JUmDIu0fzoVYDjnuuF2XQojacM81Kf2iqtOhatCxskiJVKrsJHuhZNyIEHq9qmlF0Q5CFrMrWunSOol4MkOmUgOAsvM6Dtc2JbhK1isPXI8iZjnTL6WO/d1Qle8Tcq3Fmja4hrf4ImdBRN33UdY2Alt9bnTNhL+HVPv+rsSwHaC5Ero7K7XRbiWSVBPWvCkQ2lWy7uTXitw9UzZlVw8KOkRlIKPC1guEJOguRNGu3fqeGiYzYSO6TKezNq5thK0d3DkIqOw5WkL7hK68FDS8NbB312v/01o6Q5AulyvlBaKgoA8TXd4x6kKRRUfnQJc+UO99jjK2+OWCbbTOT7h4aR0Y1nXlwmmFGC6Oib6qbyi8oYd/EnPK9qfnunw3fVzxX9X4zX1Z9W3iq/uvbq+VbgrjmpfTumi69P07jSXTsZwgm/X7sSTduvetI52PLXrW9dmLbU/9d2pb53sUmkg3+toot7vcDyVVTtdv1Y4WLVxMk7Z3nRvmr91vk9ju4K/kzVP19onXXIdFSaVSZVew3iA1dwjKth6EfuMOoJeE3ww2pBXMmX9zDdDnWk8Eueu93wy5EfFULnLE9w8GU0PBpVAPT3Se73L8+MJUYag0QdPjEsDRc2FwnvI/rwnTvCiyVyztpXhNhQ2pFW0gd8ExW6Yo9OgPJM7lvo1XGDQymTdWdLDRziVc9IjI+kwPTE0JmlMqXx4ktXyWvU2rnMsxzmNWrYvTNUTq8r6hitCY6Y70JCTkQvKjLyr94n1ZTJl6U15UYOk46MRViNDGhL0VpLGUv721HNPV7Pt9BhMfOlpVE/pq175FNqo+rShprSRidD1zJfGpAuNxc5B67Gv4ksvxcxX5NyifTe36S+6sHh1XmiIyZKeT8rojn2GBWZONOanfERvrLph/mpjSPV3TTjOdXEjfOoy0qd0kWG5Nbm3dOyp2jl2nsDH8/BF7mkYk5blV3q7iV+Nfnna4IMZlnaLUrfQyVxTudIqXhX3yjDcDTBheE4W66aYwHuCsS7QED3JtFX8KSDT2OT74IT2OcWKgkeRcdUOGgPN/XrC07SwT8I17zNh8FiiDRgDOGIRMtzK0/Ky/7v2unKtILJ75iGEuUnw756Z3t8JnVM5wYGTXBqvi12+n2OzazP/y3hzB0EGosuq1voTJS3x0s3pCmddyF1c9cBx8czf6VK5CrHo+j0peC46eAOZ2wmcKHjC/IWjK9fQMrBjkGYMTZruTmfuGHRFPmXcuTsHvr+DRXjEl89PQtZJfU+6JGwrOptoLr+z1P5mOymsPQT8+Ts3BCrcHUzd9akPeb1r/7RU3rbCbe3Dfdq9j0Ld9bGrJwWySkMV9mtwfFJWcO3eOX1v4mlZRze/VzDms1UJ6vB3Ct/p83XOd3O9g2FF99mHDr7a7+x7Vya4pnXvVKbpYKnjsdqo6vCR43atrLKD8/VSlGcyfUQqMmmQ0ajCf0+HUtnWI8KcIHp0YBhRDkhPAXPBVmWPgixhe9al8quhS7nC/KoatTQsqMhnnhu/U8kUHkpuUtEnUiV4Ci26SuY5Ue6gLfWLNEakl3ilF983KTi6ELgDp4YapkHHnFF8HJuEO2W4aYOFouyTHkh6AVlPbrTl/9w0rUa5bh1eyUb5bPIq36trT+1TfdZx5ttUKsiInqiXkQumYkla1xuPoseKHkUandR/9XjX80S8CZtGqOxHGoeEV7wnbtPQo+6Q+XbSUJa0ZBSFRl1TOzi+hvxRH/NTg7GeMrZr/9RjHReNndanvM1znhrnZrZheUYz8Txt6sGlfpb12L8MD9TAkjwjdS2dSRhnN/s1eL3ahG5Kh5X2nVPiwA/X0xBpPTW6IQ24OS/ryYfiUm866UePuDR08W1S9kyArmHqwUPhdoJAva5BCaZF7C+DwDV2D8w11J2KZZ010Zj3MwEXjDeP7pwE6vxvjCzMP2MfJ0V8hxe/Ycq4RVK32fC1EGP8QjGt7nIrAbj2w0kB8zJRlxbatAJrIJtwcK1gco1QMtXb0cxKWJp+T3XvBMBsd1XHqUK2a7sTpusCeDIGdbHUICH9OzdkPDIa45lXeKx1U2qs+uRVV+eTxkzmeJ4eoZFN4c9+axVPD6adApIw+4H+DQvUO8zdS4Wkbpela2camxT24F3MPU9K4J65o3JB6QQPT69Jt9Tq8dTBlgJI1ldzDXTj+SxLR/tV8KvP3afO7t707m7OTQrsSuHtFMkTvp7v7t7JNjtYpzlzgpPaxmr+nZaK6xU8KdzuYMnrnSJ+uhZ0bdQ14OSdFWzpkt49k/N26v+uva6fO9h29dSxqnhZzcEKxzSm07jWPqx4SNdGV2/F9WqOn479RGsruCd48vmONiqtr+qbYJ7afdblD//hP/w9m8J6T2RIv7l8gPlNb3rT5cPaxzHwyP4qq3opKBfodcF/1utMiKwniMqyMgm/qTPzIang6/3h+3lYkEorsLDpy7OkRDC0x/mtoYxS0wKkIUMZjvbwPEAhxPCjt7rwGoqvd4I5H4EtE4JTqDOTNfONbIZMQx3oaegs6Cka3kzzIezKl+b6EZZubuT8UK5Mg5owpCItnL5fvUAsWXd6s9Q2O+cFn/O9zFWasKTBM2G1jRriZ1uGNKYhCOOgOpk0rrKe+X6EzwgXQ7hMAyMtet+5kzlAMyG9Jx+mp1oajDQqaOxJo6fGU/UKca1nnu3SFrRpniVxwieNoeqqXHcOuBGux55RD46huoTGXIvXpEOfN0VO5kl2/oELjVGZumYyZkqLmV8rPe3MN22YWHpa1bUgjbm+k84z1Ysp8UtJONNbqcoZac9QP5HHUcyJhQ4jfeXYWhgrQwrTKHlajg1L0+K1EsYACIJ785vffDG0pBsXncB9M2M2a708o+XWTnucaI03XQmg9VrWP/Vl1++uUJ9uhzD6tL46ea4RCiZ8038MWG984xsv3lEUFU0MeIbarOo4Kbu+Twr4ffrlO6fw7YTJfO5EYMw6T5W3Si8d/J1Qd9rHWnSNRGBhnJMJuzDxgT5SOEhhdBLOnUd1Ryp3Tzpc+RuGTpseT5vGLop5A2xPD0EExlysdwJ3wpzCU3oFyS9yl69TArqyUlqs1x3CZNydt4x4BzeGRrrgKTTulEKFD3Md0GcTberq7kJ0Da96kuVkrnXKUzfGO16Rbea9rC/nwDWL4+75SpvX1F1hzvpW7U0wVaH+vqWbb9firdZ1UkcasE+MBVM7J9e7Z07nzyluV/VV40PHN7p1Z1ff9P4pvFOpc6mboxXGlYGlm6v1+q4Pk6x22reOvis/qr87WDu5dfrfKdwrHtCth9O9Ha9MGeD1VJAL9DoybEvFGlnCRL2s46x/yD2GtXAiF+9xT1kHpdI+e+ozbehBoQEI4wv1prdMHRMVNY1IhIPpgSEtmNwbOQbZ6S1vecuj0+gMs7MuiptLtpFKoQp4ejXwnLISMgRwYyQzNEqdg/fNJWNuHZ8zVC89J9Kgw/vgjfrf/e53X/IGYaDLPLamJDH9hpEY3Tqb65CfNCylF3ldO8VLGoWSttOD1XczrC3rzPqEoauz/vdZx6Rrr8oU9RrvaUAwtEqPfo1EGjZV9tMTzrxdhqpleBb1Ooa2DV2gC0qTejopZzJe6oji0X6mvJ4eNhoexUkacJyDmdrBE9vyRGwNr7zrRrfGT41ZysHpJZfGvkwnYn810HrCIqUmH8/xV0Z3LqchTSNieoMljdo2daWHkP3Mk6LTQ/HV12hDWOxTl6JEOd93xIn9T/is37ltyGjaSaRf9TnfSwcaxzYNs3p/uWFfD1rKvFMPGgrXlUnYcbLA2E00TKc8uQEF2QWhe58i01PxTSQkUU4wdQLK6vnp/kn/k5mmG2ztU/6/ViGUuGH8uLCyOwIRsPBItDB/FuW6Y3rffp32u/ZrVTphOmE9LSuc1j7s2ugUoU5hvI+Q1gmBp4pb3mfs8X5jbBUc9MzRGm4sc/Vo6fouM3E3LAUsaIm6jadPy36HExeujAPXoGSiuLTmc82EmglfV38n3Lso6rHkdRNj5ykLOQYneK7PJx7dwVEgmPDrOxqbzc9EwatRxp79rsU4aARqjPMKxVxnXNht9NSLHR09i7LCzaSMXlv/NGaUVQhb9z/L6fzs7q3erXyo4wnXtNXVfd9SBf3T9msfal8S/2lEmuq9Ft8TPPX3rpy0O+G4Kj+nsJ7CcMq/JppezZPs2+rdrHuavx29V+Wsa6ubm1N4a+3nRG8rnFVan+g32+ja3r03/d/dq+12Y9L1vz4/4bTD29MuyKkaL5TpVaBYIw0/4xqK80c+8pGLXMEm1re//e1HiqzJtlW4VLS4b/iHRg09CzRoKTdnKArPUZ9rq8YbcZYb2nqV0A7yOMmwzTHD5nnme1SpTWOX86AaSCg5VhoHzHVkrtn0gKJO6qF+vI882S6TIdd6VTKB9Y//8T9+6cunPvWpR4Y3vcszz4+6XNJU/s62so/iK9uvxps0ACVPzZAvn1PXSmVdGBznTkZI2PK9fD/rEQZpRRgSPo0zyrxGrFCkTevUkJc5fKTZNADmqYf2VTqy/7TBOPOOebLy0Bzz6DCfGNPMEZYhncrN6piZBzQ9mYwKMCm+Btw8ZS3rT8+gTJHhgVz8Bhcatqwnx8NE/M5hvRErjDyboXR6HWpgEbd56FF67SQ9ZAihRjLHWxjEk/qGc+UNsanu+46TnlsUcZN5t6QV2zMVUNJlGu9y/vF8HhCUObWkrZxv+a6OOo5tJvRPOnxww9JKMPFaXaR1jzMO0UkJ451K1g0i3IXAGOVkciA6A84KrlVbU59q6RbwTtBY1TUpOieF55lUxGCjXLKTwgLj7o6EVQWPDtb7wrB6d4eHCk9X58kzuVj5/I5GOwVmElqdmNKtAoYLfPV4mwTLqf1OMD2ZD/zHKMtCURfbGpK1EkoVwjxJgaIxOE8vdNfBna+p5HjISDGGiD+ZpgtOtpPvd7B28zTbU9BzXNyh6HB4onhNc9xrlf7yf71ueKouxxrfqlG8o03p0F0RT48wlxRjlyGP953HD1lOlbrp3UlJrMJw3uva7+6fKJr194rmVzxuem/qw6mCt1Jep+d2PL4q2af92PWhU5R2ba54+q7PFY6V4j3RSd6f1ofT0vVlBf8JrNN1FbKEe8XHunqntajCXsspvPX3CoYOX3XNn+SPScapfZ/gncasg7/y3ol3+DvX7Pp8B2/97mCYrnXP5GbINbT8JAoKpetgygJ5NDtrJhsrP/MzP3P3Uz/1U3df+MIXLhsqbK5q5PBEZDfK1Ak0+JgrKQ0grJ3IJ3gb6RlSPSPcEE+PAIxavAtMKGDoJ8o7PIMi/wf/4B+8hOp99atfvcCYngN8k1y7eml18yJDc5zX5qxEh0IGpF08mk0yTr16SGPo0iucMnmH8wGfn/jEJ+7e8Y53fM/zKQvWkDA+XehP5aeZYiHr0pjgM9P6kBuElS9nbpx8rzNGpRHKZ1K+SNznO9l+RtlkWCH/9fbgY50pO+sNo/xXw0A12tQ8YIyhMOgplHKhqR+gCeaCNImBiw90zgd688CrPMVN462GT64ZNmqermpcchyUtTWU2qfEb4bi8a76v5vC5k/jGT0U7as41tsvT3TL+u2LNOF45bxz89xnHUt5UPWOSvpN46HfCRdjbpqS775mwJK+6Sc8Q+NYzsX0/EsDn96ctMXcRIcwSkXDWuZfSt0tx0p4LNWoqvGN9jWSacBLw9JO/3vQULiV4OXkgFBMtifxszB0OWC6hVMrfSbO1fvBMJMTeFZltchPz07XTgSdWlYCQydkq5zCJDQKOCFcrKb2TpTshyjdOOza2gk8OzythOKT9pyITDZ3fLTIa9QBvxh2clE4LaeKbfd8LpjJvLrnT8ZUxq0rLMXwstw58ZnJWFMFCZm4u2kuPjJEiq7AKxqdlE6LcyCPC86dBL2sdjheXZ+upcCj8VFDtzspKcQBj7uYu1KFMndF0kCfi1YV2l4P5T6KaPe7vlOFwWwrn8m6d3BWmOrvqW+Uzvumq3t1r9Le7v8pn6t1rMo1dJN8aFdHXVdX8KlgTPXk/WmN3fVrhffu/sl7Xd+uMWKs4O3W/qlUA0T93fVl6nutb/Xeqt7OKFLv5bs7eXKCrT4/yTjdGKzo9iEL7ag0uPblBtWKV6Y8dy2Pq/W8ngpyvX0xxMw13HUOOeKtb33r3U/+5E/e/fAP//DlJDMMIChayGHppaS8kXliDEnK8HyNAuR4Qn7GQENRwTbpr+uvCimbuZ4KxXvCrkKHAvj1r3/9osybP8b0ACYFd4OJjXJlF5MpT6FaXkslVEVQLwngRWb10CDD17imDEFJY0v2F7n2a1/72gVOw/31qtbDyg3BmosmDWN5LY0wyZOyj52htZvfkyyXa5H1VTk1jVgU8a0uWXFu3WkESI+yhDv7IQ16z5P+Mo+XB/tkviNhSi8f4fM56jLHlrg1qsCxlRYcJ+ga+jNHl5EDegkKR3rJpJyqUSQ97qoHE8UE29BMzr30+EkvML0M08ijAStD2uoGtNEZwpbzOT1vHMf0gKy0qp4g3h1LDTQZ8pq6VqVZx0wPrv9VnA4y9E7jTI65bfI+xurnn3/+EuYLbzLMkJzU//bf/tu7l19++VG/queRuMyQPGlJL6o0FKcemXSc+WCtUz51or9cxuDuirISjqaFmg5xMoMIhmhhyibYOil2lnfcPaCIsHRR6xbfZCgy8VOh/3EW40kw9f+pMD+9C8PipDknEgsDBGhi7+n9hyyVEe/KCT5TEO0Utw4fvjcpF5MQW7+hEyYzXmC6l8ocDdmCjqE7Q9J8txMQdwp293zCPdXzEGMqg7Ne47iNldaSnc91dUwlrfvQqoKY81kXbRfqjpY6JckCvqF13WlTiMm8C8J57ZybeJr4cHcJWnn7299++Y9A+ZWvfOXuW9/61qNEhtYnzCuaqNfcwYH3ZdJBlZRMUpiLy+ul7BSgSXGeFPdJqfedpKPTcl9efC3vyzI9P9F+LZMR5lpYOmF6gqmDrZMHTvDSKf8Kq9373fNTfau5vsNN14+TZyb6neh7Khn6ld+r/nZr2+kc6NbOOodOcDu1N63Vq1IF+Kr4VTx3dSY9Wdc0tqt7tc6Kh+53fT55M54sP/IjP3IxiqDwf+c737nky8yw6Klv19JSpaPVnH1WxZCdHGs+bua5vvL98Y9//CLffvjDH754L7Hu4xWkHOZ6r0eHm8/oH3hr6BlhziDWUxV9T3dLJVOFWn3Bw36Ex1Am5UPWaJ5Bmec+7Wb+IxV+3sGohKLvgT4VBxoNko+kYt7RhPpQtgMc5mFFVlJBTOU8aQNc/s7v/M4jI5XRIhl2pqyoLJIeE+kRlEmP06DjtQxTSyNVtlf5kvNIXFVelQYR4a26IEUYHWt1xDSaTMX66vzROKCXjbRleCJ9z1xHwq6XnXXkGqChiGvK43oHcR9dWqNQ5kLVm0l6gBZ5zkO0uGee0MwPZEoVcaRRR6NZNdpoPE1jbdKTfRLP0p2egMJurjKNysq31COc4jDryJC9pAlpLaN3cvy1G6Q87rxTD8rncg7an4ye0pArvl4NbzfHPXEo/Yt36sZT8Gd/9mcvhxPYb/gD9b7nPe+5rB1/7+/9vYthPenCscpQNmlFXmA70r3RHfbLfpuIXIcK7S3wSr2xHtSwpFW7LqZVuEkLpcTNPQwgAJknNVVm0pVcDH2nHqXXCUISkeEixgua74RBm4S4FUzJ4HfPVngS5uzb9Gx9vuIDPEBkmUCQxWPlCVJhngTIk7ITUjph9wRvVaGo91awTu+e/ma3xkTJmRNHQ4JMgEXXI2W73ZTa75OyUw5WStyKjuozWX961nhdi7sMXobf4X5S9qxbfOVRuC5IGEw6vE1jX+uXqbNryUIrU8wdGZ/r5vaKziYFqvI26OCHfuiH7t7//vdfdlMR4shP8A//4T98tABkW0kvnfJZccpzzG92ShkHhF8FAV3pKcIC/fK7xow/7bLja5YqDJzUda1CeKqITTCd8JSuvUnhnWCv9yYazL52Cu6q3RV8KwW5g7O+M7XX1VH7Mq0Lq/5P+OpKXeOnuk/HeuKp3b1r+nIiD3TKVn1+gq9rpyoC3s/rk9ywWoe7dqZ2V/S4wuMK7/l+Pp9KYzfHa7+68VmNcYWBj57A8G/4M6FQGBdQItiJlr/XeqbS0XP3zO7aNfLekyiZDBdYVG5SIURmQDHG6PHSSy/d/ct/+S8v+OPwGpQx6vjSl770KBdknoJGcc11fdQbCeWJ3+REQl7IDVmV5dwYQ772GkVvZT1SVEIxLFEP46wRCk8m+sE91nP0ofTaTkNIyl7CnzSsDGL4TSZxTqOOBggTn/Ms/QSGlEWqbKLXiflaKepuhiDlhpa46OCdjA1Js5UGOnmtykTp3eXznaHJtrLt9A5LfpD6aOVNld/Wb+oAVyZXtx09gvTSSXkw4eOTRhXHQxk3eVZ6oejRYx7TzDdW+RdjhxHbHJ0UjTeZnoFiHiDnoXSvQaP2IQ2w6kriMKMfsh5D7tRBNAzns+LF501Qn88kvekY4D0NLplbKcdOY6CGF8NW02CsIcj+aFxKLy6N1XU9+260a8JzDXXSlLloyR8HX+MZxolNB+R7xgveA5/64Ac/eFkrzKErfBpGMxzQut2A1mFA2DVEZX/lK556baSJxr0HNyzROZhSnbiTQKB1FEWLdyF2kKV1byeIdQt5uiLmu50AwLO0i5UPw5IKp0noWKimUJnd/06oWZXs3+nA7IRlidYT6CT4arDbjdWqr6elU26mtleC0AksWY//6/18/xTfPKd7MpMqvW1kap5I6OI/4WCCZXqu63NdvFZw+y1jta46V7t5o7CQJ5xRjOF1wckE2yvcZp/hFyZ8dIHgOjiEbjMh+Em91YVb3OhuTsmdMZ+rdZ7QRqXn/Na19bnnnrvsPr/vfe+7fLugcR3jJMkwU0CoY9D97/ibhjLwhvAMX+M5cMi4sBChoBgmrOvqsyy7+bl6Z3p2d99nOuF1emZVz+p+Ny9X9dYxrYLq1FatoxrhTnCWQtSuX6s6TuBf1Zv3K31cW88kK+zobqKpbp5PcK3qP13faunooMJT174OjqneCTedPDM928G3gmGSWzoelzBO86are8cj6rXaRvb9GtloBWOFCZ6MwmBOHw9XQcGHb2PwQFnoZJudHLSbIylzndT7tEv2QYVNhUePC09cM7SL9f6VV1653Et5TcXH3CQoQ8ourIfqIxp/uI6Bx41ElWzqQKZmfXW9V2ln/U1ZRuVYrxTlRZU580zSvt4g/K7e1J2Ro3oTVXxRDPFT+VY51Djkxp4h9MgO4Id+GIqkDEUxDIZr9AGaNecNhXvm6ameU+npk6FSNWVD9SS0T3rlpBeb1ycvXd+fPBPFa9aR62HWn9e7fuU8quOicUBa1KBnmJphXYYkpeeU42d9bgxmSJV4zP4kfmiHsYKOHS/leetWxpf+zNNpCBf3zA2l/C8OM2xPODLUTbxk1IB9yPld1+pso4YW8q0OYhvpiVPbU/YVTnmJRbk4nQVs2/mdocpp2Kp0nMY+23a+vdpEYIiv6hFlXwl7g0/Im9gsz1BF2/vxH//xy8Z1eqqlkdX+pvONY2tf0ovKKAj4iBvzbn6gc2hsdOwePHm3iM+TDLIkwfCBwIkTxGKfkwjgYeZ6K3RK5fS7JsDTeymtliJQF1p2NZy4TmgTXWfyr07geZblVIhL18BT4eih+tkpyztBcPXMNaUTsr1e70+CdL7DR28PfkMnMKFM0uYugYy8C33b9XHX926sd0oSMJrsTfhhGjKGrl0XJN1fneMuoDJs8wmku+mqeN8dCAy45iqQ6UqzXUhqp8h4SoEGKvmQAlAusitPnWvorgpyVTkBFo7mxSUfPqPVn9xxL7744sWFdad4dbBJi9m2v11kFHi5BhwsSgjHLqRef1blVKHc3ZsE6spL0mBywsuvNRrk9YnndXTbjemq7qm+qe+1ZL8nfE4w+M4JPk5gqW1O9ZzAtLtW70kTU8jISinP8Z3wsYJnVefpvantFT6mNla0XnGxwmutczVX6/8Otk7OSwWljlFXf9f/Dt5aVuNf61jxkUrbHU9QFoVHu74qO/BNcmdTRdQ2V3i/Br4JP9esT0+6OGczrEQllt8Z7cA6aJ4aN6fcZVehRv8QxyhqKtiun3o38Z81G+OenguspchSKmc8i86CEUsFTAVNHmOOFcc9w1TSuKQ81o2b61iGiOX1Oh/Mu2i7elaIJxXiTArNN/2gv4YxKVt4wEjmchTfXPd0b/DhqXB1fnbzNg04GeJn/9PYk/JbyrcVR2lsyHbrmpt11GtJe9lewpXXO/5l/6SB9AjROGGfUtdMA5zeLho1KCkbZ27SVPLVTUzmrkHAEE+85Ey6nEYIjbQaC/PEw/TcEbZ0WPB9YdPTRVxkzir7nZ5YwpveMhTwls/Y/8S9bWpc0khT54yGOcfaPlQjVkb2GPHAvNAQ48l96lMZ9ZRj6CmP1v3dGPNJFhTP2iDYYPCatgpD/eRpzM/3vve9F72DEGCTq2eooR5GtX5Kl5s1PRz9Rg/mHWw0ni6fCb4f1LCUxG3pFlKvycwy9EMPIgYL5pVlJZwlQzAJWS42dF5DVU4QFhcZqjsLep8Ys1kZ/GqhftxyrSIzvZO4rgJIJ5B0dXYwPG6/nyTuLJ1it3pu+l+Lxpkq8JoUMeOIzfe1M4w+bv9WtJJCB8wQYcgYX11GgRGBSE/DZHL5cVdQQ1o+l27PKwG2UxSsW6ZX+9f1rQom4J4Fk7mcp7romu7xqXUsOkUy2zmhn5Vi5OIkHwHH//k//+fLiTXf/OY3L7AlPBN91PGcBKNs1/u68YIfd5qk2ddLKFzF3WpcurJSglYK2AquHR3ncxPtdIpuJ2R3Sl0d45OyU4Sz3/l9okTnO7ZVcVCf6d65Zm2b6sy6Kj4rTJNifNLnE1hXdHUNn+/60dXfXasK21T3xFc6HO3arXTZ0fA0bidtTWXFt0/qnHBQ31nxlO7dDver/6u2NAaYX9DTfnbr/g4nq9LN52vreFKlm6vVS4OCzK8sYp4gw3SUd7zONb2UlF1cjzXsqTCqozAeGmQ8LctUCMBgPiXg4D3f93qGo1A0fNk+egsyGkZEFcXsZw13yzLRBv/ts8nFKRo1vJdGJZVaDxxBJ9PrmW/kmPT+MnyG+xjHeE9lVcOf8HFNRd9rddMnDQDZl2qgkC66axU3FWduKnT3OjkkYaxe8d1YZP1p6NJDn5IhcBo5VOSNClCGdENQWsyQpGzLojFGvAgz7XMPfUAPPI2E0qttqQdrnLCkp473DemznznmGRbqvdT5dSaxbenPuauBh98aoKjbCCONLGnEzHkjvWXd6QWWzifST41m8BRJPsx5DK9pKK4412Drt7+lY0ql38x95PMa/SgmyhcnjlmG3FLwbNUb0b4Am56c6qk+L78Tt25u6BnoO/bLvHKZA1tcJX97UMNSFXAmoVlrF4umMcB0TgW9q2Mn1AmD1nbakDHyIamfIWHWKQOUwF18zO/SWRWvEYTuU65d0CfBMetbCSLXwvU45T51dP1aCe1VYN7B0SkkXZHpKyCkxZuiWye0gzdKDeN6EiVpeYLbOH4WEulXRobBgT4RgtrlM0olOfMhTfO7g6/CWq93/6drta+MA4KcwpxeQcmk4Sm4jXqCw0RLp3S2Up6FW96CIQm+Q54HGPFnP/vZC23IY6YwvBMFdcUnkk9lTgqKLtjPupzy9KTBVakCqvXlQtcpTStaXIWGdZ6s07MrmuloYMJLJ/R2z69wvTICTNe7slNuT+51/2v/uudXylUNU7i2PNQ7E82u8FP5286gkXVObez4RL23moO7fkxtpFxY68r/E51PfZ3q6a5N63xHc119J2vXqm8dnoSDtZV8e24CsM6yJusxU0NeVnU/Tqnj0PX3aRfaVwmiZCicxjfWWj2y08sCvKELZOQBz6gEITegfxACp3LFM6zRGRajZ45yk/lIDDNjzKiLevjowWRaBGVG3ue3eQ/VL/SG8Gh1lfRq0AA29ZW6NqWynp40piqgb7SrYi0OU/HVm8H29RLJMC9+gzPg1VCgbMx95B37nbQqHmo4XBqMdh7G/q/8wWsZzuZ18WZJ5wffE0/CZJtdiFvSZd6ra3rlexowMGBqqNC4lPmcMumzeqmeO+JZmvQZ15rOQ0ejDO+aYkKvJujWKAx0ceeOxh/nlrJ1ermlblyNfn6kiexH4qN6VSm7a1SipGErPZU0fGZIq/BkjqKki8zrBB/gGQ3KwqWhV5idK445cGZYMt8mGvf9zBlFSc+gHK9Xw4tLOV36UUdwPE2Sb84sN41tT2822hQ+x4b6rFs8i1ffMZWGXofprShNWJcnXmqwd0zSG+3BDEvVUulAZBHR7gCwePIMxiAHkuvVg0JLWBVCUnGX+LG4OXFFKPfM4+SEMB5azyWe0XUW19hMvDwpDU9y0Z2EsEkwz+dXAlknPDyp0sGza7fDbb02CcRVObtG8aq/6zsajtJSruugDAP6cYcxLfOrvuYCvHpuh7dOoJX58OF3CljMC+YAQgI7ZVrHp3YmRelEEVspj7X/0nguVF1dLiCelkERfoUHLfXmYjhVSq6dG5X2XJRxR8WNnlNU+K/3VO4CrJTP/EzwrRRVikJwJvLz6NdnVSZFtZYdbrp6Ky2lkHbtOF8D0+r9kzni89OznRLf4XDCywTrCW/xmVQupr5Na9DUzinfvgaHWe9q/VnV2fWhg3VqP2mxKkZ13V7VdbI2rK6t3q/jununG6cqk3Xjnv287xzZ0emKn091TWOU/yt+prq7ek7hNdwK3mx4iqc6ybtO8ZXwrtaJHW1dIz89yVLni7hQKc8EyHnSlUmz1SuQA9xs4j8y/x/9o3/0kv/Q/LBcRyn7jd/4jbvPf/7zjxRt9QwTA6NjGJL3h/7QH7ps3HEqE4Xx0wuE9oXfI+ZV6tOjRRmN/7yHnFDXrYlmrcPvupHixxAs5SBzVJmk3P6lLGu9bvibDFzYNU7x22Pq00BR503ScaXpDE1OuFMGciyrIYqSSYlTrhZvndFJOLrIlMpPEr6sI41jSa/V8Jd0VGH3usY3SoYn5innaZhLg57hSNV4kSFlerbwvEZG5wVjbF8yf5IwpvwsXs05xPtp/Bb3GSLle+kxpOxOW3gBMl9MdG+4WXfam4YYvWc0kqjX6I0k/NINRRrWwCyu0kCaCbydt46BTjH2JT3YNM4mPad+KP5/9zVjXc6NDHOrcwOYMHbriaQxKHkH/zFuw7/YSE8Y9EwUF/IuI7MwvlNSP+loFRyZWw4cpqEzk8U/uGFppSwlonwey5cnOsjkMOroWZS7EyBOo1BmMa8xtyYc47fE6aKTCyTvyQR14fTYRS38yeCsf9e/hyyVAWU/KUnUK+XB+6fWxBNl4+TdlRI3CV/XKG71/gnMu/YmAZ8PwgeTUGaTcafQDIZKTwbZCdLXKpK1jkkpyPfzo8tpTnzfo08wdneqTktd/Ls+1uenZ5zrxoCnu7oGsW7sHAOZaC4E7oTUmP0dnKv72d9O8BYm7xuPngJOXTyy5GKTgkAaoyZ4Embb0lCP8KyAe83pDU+iTHST91cGiu4d3XczeSQ0wA6yp2FWPpFjWHcmVwpkB9cE69T/7pnJ2NDVu1MMJ5gmOGrd9ZmO7uszO2V26keF5UTBn+Df9TX7sKKzrlTjQTf/V3Sxe363Rl4z3h2Mqzk1wd/Vv+Lj9fmss6OdKlOt8LeTS+qzHYyr+xNvrTLfNAcm3tT1N2FwncjEyBM83e+p3g62U1qa2n3aJQ0Afucx4+odKptvectbLnIYax5yfUZSqPggX/zlv/yXL6e0futb37p7+eWXL2vHj/7oj9594AMfuBy08bf/9t++eBh7upKKoQYMjTQq1+SLRY7CKIUOo2EwT8DS0JUGGw07HuzBJnue3KxckwaQxId1ZS4U36nGjpQ5pDc9E9SBNJ5lWBzFHD+G75lWwd8Y177xjW98zwFOSd+T92/Xn4R5erbyhKqM1zlaPVnrmpVzTnjr837XSJbOS9bn81mNGubF0UNHY460LJ0pxyoD16gJZTkPa6FNw5McY56D3k1YzzOOsZvJ0oq5he2PBlqeUWatOXe8prdKDeNzvmYSbXGj91MaATMZtYanupElXWrktB/OyRquKO717DE/mAbcWjIk0fbSWKpOkXmexIPjb5/tr5+6kf79r6VYyeelC9viP044X/7yly88yqT6prfgm/nH9U984hOP7CppOLOvtGVidttj7kMf8qj0cpOGhZl7boLQrnYV6eq0HBuW0hvIAagliUOruPHJ2QmJks567KqnJnBfAxSfVDgdCF0608qaSpmDzH3qZIHKU64qo1n16WmWyiiTuSaxJkHVdycl4CHKtXWePNsJyCtlZEd3HcwnsCjIcJKXiRwpJjM0kZv13McTqfZter+O+0SjWqtdIHJHK11u0wpeBe4dHKdjuOoHc49FjXkOHCm0wOiwwJs4MtvUcMK7lHSZdS7rztvBfYrvE6Uk69R4pMBQd5ZqfR2uDOsl5xzv0H92LTLZXtbTKRN8PNnGky91GU5Pr6ddJoW5KmedQtnRqDvQLLp8446PcgEtvetd77ooDigQlQ4o1TNuUuq6MsF08uzJ/M53VwaITqnt6u9otT7bKdH5PfGE7rnVPOnw1r17qgCf0lDCv8LPSbsTHa8U+NXYTvxgwukJbLv2a91de91cmDxKK9zd/W4Nrx4LK9448brumW59X9FvfbbDU9ePCb5K9xNeck2b+rYqq2d2Mk6lwdM2n0bJ485VtFXQPKAj8wdhpMHIg7LECUk/8RM/8ejZf/AP/sHdpz/96btf/MVfvCS55TfKGvdUkt785jffvf/977/783/+z18UKPIhqlhpGNAjwlwjKH2/+Zu/efeTP/mTFxhQsPiY2Fa5RC8NDQMqZ6xTrO0of1WnSTwo1ztW1fumyjJZh/hLpdv76lXgzM14Q930GEkPffHAh/4bCmTKAcenKu0dr0+Pn7yWPDj7nAbG6jmUm72+rwyW+Elvkm4OVOOWMkY1flWcd2t8NTqZyNnNRmUXQy8Nk7QOZWDbRtZVlrcN7jkHuJ8e+8wHZL80hGZuJ0+A45rRPnrPqNfwrkbc1KnTezANrhp6pfn03Km5mHMDOXMb8a0eIOy+q76ircBnK19PI5fGEnOvOp+oz0T80o7JzakvPZ8yiXmlH5/PDc7qyUUbuXHw+1/Ld2uorR/rk575hpf8u3/37y6yPKk1OOwB3UD6Bn+/+qu/eved73zne5Kip+eRtJhJ0CmMPzToiY68A37zEILkJXqYSXM65ThPHtSwpOJ3siitFH0BA2DcTF944YULEu20xE5Muq6XtpsTP+MpTZRXJ3+6wVWlbwXzrn+7hfxxSk5qFwrjy514DLqL2gRb/p+EnO7d+/RpJWSetDEJ7p2A2gn7K2VxUtI62KETkzimgJMMrtZ3SgsrQfjauvK+R9DLxISz4qVTTLPN0/ZOFR+f5WNycXM+yZxlcNTvzqHviWv5gacu6NJLv3kHvlSNMSsFdkX7HW4qbdX5mTsmJsYDNnhZ7hrUdtyF8PQaiu8k7HwysWP1huI3CymemBiqXAzq4QhPu3RK2Uoh91ouiBbomp3qX/qlX7rg7etf//pFQDdu3U0IFIWJb1Q46u8Ojmv72/2e+p/P1XdTQa3/63N5rQth6967pi8V/umZOrYV5tM6q/B+Uiqupv50Bosdr6j1rta5+l6l/w6Ga/nptWWag4nfrk+TrDS9O+F4wm+3Dk/36rXVGO9gmNro3u3W+ipjTs9O7U0bUpXWdnVfUyZ55/VSUmETVtZ8FTU9CHiGdY5185d/+ZcvCpgJblHC/sJf+AsX/OKR9JnPfObROuEmFkoZ4eso4j/2Yz929/zzz18MPqyfGpPMh0RxzUW++spXvnJZn5VjlDlUEBN+vUwM42FdAm4T9DoGnWeM864bsxqulbSYCl8aZaQ3w2B+4Ad+4Hu8O4AHuSVPflMZpm5+I6OghxkilO3n3Or4i/KLtN95I/mdMFeDTX3G9zIZuM+m4arTLRKvfPKUs2m9TXzXUL3kh/wHd8gpJuXX4GiKAhV/82EqI6vsq/A75olDjTGMCTTGaWIYDCnQsScepqc/7+mJppwKHaNDMh+YQxo/0pOuO+EtceScsf9pZFJmzeetO/HlXNNzX28jntMolvflCZmap8sHpXHX8FhPiqNoEDJySU+ynMu+m7hQH8wcZvAXdcYMM/t9r4XymbZHWBNHVRYEHkJ0X3nllctp9vAZ5Xu9NKsOWudPpgVRdzU0T1wkv8iwy5xrNcG5NNB5gD2WYen0uPEsTgwzrUPQIMd4Z7yV3vrWtz5SLiF2CZCJxoAxcCLOHDcOtIm9mEy6/FmE9RTeKjRMgsfu3rWlE3ZTeWVCEe4BbiwsjOyiuBOxEmquGa/ds6v7p+1Mgs01AtX07qpMwmRdfFz8TvOJTe2cPpfPV6a7gt93YFpYuZkzCFfuJGSSPF0j7zt+9xFyfQc4oFc9pqoHovO2o1d5AUw1T2mABxjaVxOf1pAn66ljUvuRuK1u3fV+xQnCGHyMfioUIEgSD11PV/BddzJ5h5IhvtkGPBPeSRv0mXornwOHLEbgSZdXkwE+i1KFtHo9/ydduyOHoKRxjMUWIQplAYUCHLEbzXVoCxwrIIubU1rulN4K604B7upeKb67daMKtdNaU3F3wrt3dN+V2qcqqGcdK+X+hCeelA4vJzx3h8dpfejaXZWOblZjVPtxAnc37vVap/B0Y9L1u3vnmvW960vW1RlXJvnrpB8rXNUy0cx96XOaU93/aV4n/V0jr+3gqrCseMCzKhnaw2/WL+X5PGlJJZ218Od//ufv3v72t19Cs9yQIuyNa3/tr/21ixcSHqysDRpjVILxbmUjm/94PvEfnOjBQdEjQ49wPaTJpYjczX3gydOuVOzS80fdBMOSngK5dqeXTNJIbprXsctE0HWMk57qHLMvePuiT+gRYl9MpcBmvzIFzyu7oYepIGebtV3xkDD5TuZJclw7eVecdrjJ9lLu6/hhNWKlx1PKHOI6les0zGT4WHpeZUmF20TtJod3Y9r2TPXCf34j82BIgLYN+8KYAG27UajnjaFVGj+M4NFg5alwyIoUTwzmmnA4nyiZ/4v6zRGmQSK9arKf4qwm56Yv1GP4Xhoj7b8GEKNCMpeXNKJnV9KKnl3ijueENU/Uk6ZsSz3a59PAonHJZ6QH+qAxyjDc9AiyDpPm59z4P1/z9hMWcZjOIvIc+5y6J3IsBu88YdGQ3MzRlZFLRoUAt15oGr5N7yI/TS/CDNf0VHDx4PxSd3ScHtSwtPL2qcWBFUis5MQ2Yxz5b//tv10AtfMwLCZUnmDAOx6fnguux6KDIE9Cgvi1GFquFYKmPpz08z6LcmdM6BQW++0OggRptni9Nk4FhU4Af1JCxareScDevbcS/rtFdifI795dKcUVnjqGJ2WnzEzPVVwxHzC2KAjAYFyMuKeHm33qBMxJSDntQ60nSy7iuVgp7MADqqeOdcrwZKxeqyGt7jAYz+z8yPCoqd+dktp9d32nTfgbAhnz1LA9EwgiyGH4S5dbje0upuBBj6ysm76wI+XCAA9wJ7fiV1d16OBZl0lp64wRFl1uMY6+853vvIw5eOMZcMXijWAPfsGXp/QoxLE7ne2vQlWv5XsJ/6RoTwpr19fpelWi81qnlFa67fq4MpZ2z61gX/GGCaZpXTsdmx2ed3y+wjxdr79XsNY+dcaCSfHq8NqVjhZqvdmXul7t6OGE/ieeN43p9E6Ft+56rtbkidZO+lif38G54wur9TL7sarnVFbraPtEVtjV2/HG0zqfRJEeWNtMb6ECWWFl3WOt/fCHP3xZ51DAkB1Y99ArCHFjg4fnVYbQDdic0YjBOuuJ1Z7gykaGp0e50ZXhW6lbUB9wsInDs24mZVi8Ch1rdXpiZ84W+1b/U1JGq7jKOTTxqOQJXlepBS/g64d+6IcehdhorAC3bN4AJ8YwCv0ATxqWqjfQtetgnUPC1fU5PZfEb53j4jANHukpk57lOad8JnFePciEKRX/1fpj1IAGHj6MvydyZVvSIt/gHFnGflIy95Hjxj31QA1K1A1N1ud9JkOxlJsN4zT8DF1b7yme47eGHevLsUgazP5rtMlwvaRvjUbIcxi8MlwtD99yU1QDB/1Tfk7aS7hyzPI69ekVZaifcjtFA6u/uacxSZoQRue1cOvcAuw5z//Aa15lPq+xLuGzLxqpMiLG3+lBJkzCaxvyRfskrYkvdSbTApl/K2nN+m1TI5kphJKvnabYODYsTQvqarHTyspOAjvOdFLPGxjzl770pYuLKYwd5o8CpRKhR04inI8ufSmc1GdqWQm7+cw15drnV++u6jJTOzjSA4UPxjhP3rOOSaCZFoHH6cOTKJPQmv93QtD03kq4nBSK/O7auQaO1XMn9UyCsDAqyMCcmUPMJz05WETyRLhVm9cKmbs+uvPhSQUprJkQHbhzN68uwN7LxSX7Yhy7uzMySuYN9btgTcJO0kFVDDqBJ5/LEyiSCcOAmaM8Y5633KFjMTJxY+aHy0UYY5UCRworFa5c2E/p7kmWae7UPlYhBXwR3sDuM6HQ5gXQQEd4A2sEOGCHD5yauBtFodJNLSm853O7+bDDZxWGa986/jIpvzset1rfOsPBal3o4J+unfKhrs2Jp3d9mODr8NPx+vq7u3Y6P6pCMrXTjfPO67FTUPK5VamK1WlZ4bfW2/2eFMlr+M3J+9O4Vpi6Zyoeu/ldefq05k9zqv7ulMxrcbGiMctkHD6Ri1b85VmuF6zbFDeWc9NEZSk9U5577rnL/xdffPHRRgpGENZh1vqf/umfvoRNs25q/DFcJzedePerX/3qJRSIyAn0EvMgUVTUWZ+FQ2+kTMWB7MIalUXl3BAoj/fu+IlrnyWVzvSWkY4Ns3JTTq8jxzAT8XZ8yueBj3VWw5I6BWutcgnGJDyhWV/5LXyZ2DnlkTQCZV+q4Sj7n8aK/J0GIfE9rSk5x6vRuuMX6T2U76bxpFv/NBxRz5TfVwOEsppGCOk6Q6Q0wCC3QmvIidBTJvn3WfFqom89lKBXZCLlT+rR80586X2jHM47tKMcTp/1MjKPrMaFahRxHDKJvPKq/XUe+xF3euUzN8175Iax/VYeNpTOsLccL0teT14vnNKROZ7Ai/loxZkyoTBqSDJ3q31PmDxBMT2UzG8qr/luhNdJ2ykbasPI68Lrb3Nm1b4Ikw4Ewi6fqXxEI1HyQenRaxaNx9KXXmVugmdI5IMYljomVa9P70lgOTG1rqEw5ETzGE8WBXYkakeq8pllWnSn/7Ufj7PAdkLYtXV2CwL9h6kzEfg42OAPS3eeiLQS2p90Oe3rJEjW+5OwNCkSU1t+Kr3keHUW3FUbUz93ykHte2WGU33dgtrBKeNx8cgFs9LHtTSxUspW48Dz0GcuEgo27v7JNFfztyo24s0dFz7mOBIHMkdz76SAat2JYz8KkR0Trcoj/Mq4eMMPTTjKIt+5jyoo5emXebCAAiQLsDHa6b5b+UTiLXcAn3XZ8YSq+Jk00KNy9QKjP1wnR4a8jx1q3c35kHS/44ErXtPBU5/p+FDH67s+rxS4HVwVN9P9TljPUsMSVry1w0fHm7t1syrwHVxTfV2fVzB2+J1wXedIN2ZTfas1aHW98qnuncp7Jhqa8LZSnk5kkQ7+icY6nKzq2sk+Hfwn8uQJzZ4+P+HQssJ/fW83B1fz5qT91bWJhk6fe9brhHKLeoIhJ17zf57aRIgbBg/kBwxEeLaqVLEm/Jk/82fuPvjBD17WVQxHeVAGMgLy9Ne+9rW7l1566fI+77LWoCDqHZ25kPjkaV4ZjqbCpkGGZ3nXjSM+hiXZ3443VPnUuZyhM26+GyruwR16E1UjTiqk2RZyBv3GuwsvJfrgaVLUSf3UiaGN+vPUsKwrDUEU+1A3/VMG72SXunZUmaz2S7zkfNOwYv/SaMS1PLlMY0/iLGmxesBYD/oW4ZP8ZkPfE8ZtF9pBb+W/JwGm14ltZdqD9KDjW8NRevxoTMzE3MqXhjJy31Pf9DShLTdwDcHTc0kZPHOYKcuaTkFc5unsaTgSr/bL/FxuIhtRo3HJTdjMAyRMhv5lSJcGNuXi9OzR06fSn55tXBM/qV+40W3YbRovmafAKRzSQCbLVj+wz6kDaFD8vRL+mPMuxzXniXSakQ2Z4Nv/maQ/k76bb1R4q2ehY56J33Ne5PokDaWXUobRPRHDUgovK+HYSZoE7JHY/GZiovAZS6hSRlHZykzyKyFpB3cVuCbB5pp6V/2u36d1d8KnEwSGJZ4kZPDJYqlF1ndO4H1IgeJx65sErPuMyaQIrhSBUyts1tctiNe8X+Ho7nfKx4mCUHfFTvC3EoqTQa3q6+pwZ41FWGFAASW9lFZj3QnufMvUzRmQbqUyVlzVzdVWPXqyb76bQm2nNNRxz9/mXMhFIxlxMnmNJ9bnHBa2PDFDQdajQiuOKu5WYWBPu9T5PN1TAOOau8SuAfyG/+Va4XiaxyAX2amNk3vXKJzTsxMdd/O6+z/B1rW9W9M6JbLrU50Xp8aBymdW4z2VFW/p4LoG17Webv6vyu6dTq6Y6Grisav719BJh/v87taDiSY6PEzXunGZ+jj1ZUVr05yrMmm91sFzn352MFwr79R3Vmv5NW2t5k1dx6b+Pcu1IhPNCieGDdZHcZQb0uYl5Bk3XNzUoQ7zL5rDlXWU51H0MQywTmCY+vVf//WL/kEdKLWGtJgwl/ZN6q0CpvzimqOiT9FQoAGMNZ52UV75pi7Xp1QuJ76S40a7wId3lwYG6jRdiBsyXZhanf/SBXig/+DIvmCgoN8Yk5CZUnHv4FzN//pOwkZJA056ClVDlP1PL6OJD1a5R2OTpXpH+U4+n5uA+Rx4xghHCCHPQX8Y58jnhSyiMg8OwaVJ0pUJxbFtGKKm44AhTBo9Mq8RY6VurKFFnGno0cBkPlVTMmTOJA0SGlcsGiyoR+OHCbT50L7yFe853wytsz/mFXJe6CWkwVjv84w6MsRL5xOegc6pL3MFaSjLsU+vqaQDcWbfk9fmPNAbSANwbuJKa3oouQmsR5UeWJmk3JDY/zuiQ2rbGnfkaxliJ066tVocZGSEdJBGs0wS7ke9wjatW++nLhRVQ5S4Wsk2j2VYqgO4E5ZcLECW8Zxc45sjQD/72c9eGJuMOK3EiajKHPM74eja914lqu7dlYC6EyIm4bripxMcpvryfQbY0y1gGO6GmBgZpas7prwr1whFp0rCrr5usTmtazUmHd4T151yNcFVr63gO1FIst5J8bpmLCaFq8NBJ8DW0rXdwWfuInPbaCReCaj1ngyv68+k8Ozq9B4LladpaH1XCE1XVZMVdoUFxTBcFxIEwTyFoRs32zDZorsgzEl3PawvBT0+8ESFDnc1E6+63Gtk5zpCX8W9wk8t1yo+D10mmlvND/kceaUQMAx1I38Shkk9u3jeOPzc4ZnKao2a5nF37xqcnirY/j/hBfdVAFdzva5P3Zre8a+6RlWFo4O15gWZYJzW6B0fr32r/ezg3pUTXj/BvYJzkp0qTN0u/wqGhPkErgk3FT8Jb1fviYzVXeva6N47WS9qO1PulgmW7tpKtpzgr/B1MmD3bl7byS67MsHY9fO+fOUhCm0rt7qGm4yYNZSiMo5hiHWA9RWPpC9+8YuPcIQMwH3Cu1g3/v7f//uX8f/RH/3Ry/PUi75B6o3f+I3fuPv0pz/9SGb2EBw3azEaGFKf6y1wmajXnCoqhXqZqJCp4GOo+sEf/MHLf6Izai5Jf9vPTNyd+pA5qFz3UBbZUCMROXVj4DBHjnLbpA8ot+D1i6eWOXZUQD0EgzX4zW9+80W/YF2m/smLO/tQc/FQOu8M+1t5R+VDHS/MUDlpqDMyJFxeEzY/ebKc16xP+Rdck/uRsTRvEvgBfx4y4nv8x8AJPdak1BpYwLl0ohFE7yGLHiuMi8YbjTKmCVA2dPz0aNLYpdFIL/xMziy9ih8NWN7TWGRIV9J7boryMdcldajvm//Y+Wtop/2WpqlHQw3ftKkMz3zMSIc0pChbdyFnGSJW6cuT55KOmKdu5mp043lgog+e2Mw1vcDUwc2rVZPU/14xpmr81pimUasalaoHkf3yOxOV181pcS2upKHMvVWNUckXhJuSnnPd/wcxLOkqaadz8na/c2BgTHgoMUDsFrAgwOTTopixwbmgXrOwds92sOZ3trUTYE/a7trIZ3Z1d0KbCxzEnLmWZFRYeM1HtSo74WaC5SFKh+O6iFzze1VyMk9KVcJyTan1TgJhV383Vyp8K0G7e7eWTknIeyscVvhkzCyQ0B3/oTNdgKsHUIXf/9nuKe1VmKf/MtcacsYzKWh5rbbpKRos0i648rjqRdTBppDhMxiW3IXiHt+dMYh3dA3mOfCaiyOFZzSaaXTJI1snhekh5+19yk5p7PivC7YJWcEhvwlXwFOprjt1Qdwp4xPddzg8xV8KVicK7PRu/t/N0V3pFNIVD+ngyn5U+Go7u7pW873jnVMfajvTuFVlZOLXE9xdm6uxmObhCS1060O3LlbYVmMy9aN7f+rvNfWt+tgpjKvnr4Uv/3f0UutTsPaesmcH8w6u6dkdzCeyxzXzv87VSd59WnLefYvrrjKHu/mGBnEPPYKT4D73uc/dvfDCC49Oi0X5RAbGmwQPfq5/4hOfuHjeEAJnXj48TPi4CaS8rLcOMLDm0pYhOx55nmE1FGGyZKiQ+owHaug9RXt6SeW6l2t+DSfzW28JnkUm0LgFvvCOIRQ8T9iz5Nj7Ld3zPuvru9/97kdGCYwCJjynMA7mXmIdVs+g3hp6Jryr9afygzxxLWEWzqxPGslcTjXsX2NDtkt9+WyFsRqdap4l5DRpCwMDOiwf8ActpQOEH56DJqFN75tEW8WfokdPletU/vNkOZV654bGEw90Yezy+Rx3+5J5OvVK4l4dPw/CoR09kfJkwzRsmJ5AeVe6lB41Omks0uNH3OtcYiid4wgN8rzGLT2yhNc2NfLKO9yUzbBaccozGnU0BjkXpHUM0W5ukteTfJ+Ghmm8yVxK5m2yzv8jNrk1GIl/jUJpHKOIg5pv1TGpHns5t/3OUMlKx659+a79N6da0oFjk8Y+DXgPaljSndNdhN2C7zOeWAWjpyMMkIm6tIDm8/X9rnSC125xzEXWwc9j9nIidsx4V3cnNNWBv1ZgyHq0hCeD0QKdRxuuYE4Yr1GCHresFpksVaGYFL7u/qRQdO+vxmGCqSpa2ea0cPo/362TvDK9Cst9lcxOYe36l8pYpYlMig2z5renoCDI5ImE09zdtZ/XVuPdzS0XNeBLF095i4tvCpG1Dt4zHt6Fj8XD/3kijO+kwAMOMIDoPsziZ54gvjtBkkIbvCcPSo9DBQrqcLcBAXVlPH4cWnkapY5h0h3FfiGYfOpTn3okNICDTkha9bPOVces4wn3nXMdH9spzR1/Trimubm7dg3ctY5ujVr1ddVeV+cEc8erK06790/XrRV8tV8Jb4eHWtfqma6tDgafr7uaHXz5XrfedH3L91Y8d8LLjiZX63itY4X3U3i7ervSwe2ai9cBHgYaJJBLa3LaCdb839Hj48DctZN88aS/XR2766+H4hpsMb9R5ioRfq6znv7jf/yPL/mBOAUOo8q3v/3ty9rLBhgeJSTlZmxZS/hWFsiTj+rYqavwHOusOWGrt4Lv5btpqNCbwzWfb+iNZ9/1rndd2sZAoyJpSZkiYVLWN7wJuSRzBJlLU2OB8GWp4f22oyGJD/gz8sGTe2kz89+i/1mXhrRKm9XIVOdGNQRVfFrnJIdnfqvKkzuPJn93a1MaHTqDmHhlUxWDg2GCGJU8iCbf42P/M9eR8mh6ySgrGv5Wxz+NSemtk15ZGi88pMZ6kr41xnFNb0DpQGOCuEgP+/T4UbZWV9Zo4z0NVJ6yqMFRj3w9k5I2nWvCCx70yAJv4pL6TDSu9356kxlBkbSVvNnnvebY6MWlx5xGMLzS/tyf+3MXQyKFfG3Mj3/6T//p3W/91m9dxl4jE+9paPF9Dcvf/1pqDXlOOs7oGOI8FlfqGhp7bMP/aTDKvMBuiItrdRjhyO86NzJvlbCn4UtdJHNpPahhSYtVukM6uGm5rsxXwpcg83pnVJoEmiwdY9oVCU4PBd1d9S5gAUoXuFMhfXpuEqpW/Vu1yXVwjzKKImw4HKVau1d1TQz7SZcT4cvn6rXTelI58Fmfr7uTJ8pJrWe6X+Gq1/1ofGDszLYvY0zX6lrPyZyo7a6Ug/pOVZT8Zn4wT3QRNUEciyxCRsZ7r3A3CdYrZXMnjINLYPOIYWHAJVwXawqLkvl4uvbdVaJ//HaHQcEy8ZO4TCZNG7iV64XEvfRWqnnifN+dqmpc4Lcn5elKLL6z/aQtr13Du55kWfGjlSLtDrX/J0V2RR+dgNrR4YlhYFL4drR7Ukf3O4XbTnmdjAC7+1P7E75OlOF8ZzXfJ5h2z1U4Kn7qM3VHburTxKd9pobs7fiw71zTtxR0J7xO107W9hWdd/VPY9jNoToXV/Bfs86u6pva7+5X/sJvjA4/8zM/c1nLUA7YHceAjdyX3rdZT/3dwVtxNJWVLNPxt66t3XtdmxXWbq15lsX2WYM9Pt0jsdOTxN8oeZ/85Cfv/vpf/+t3f+Nv/I1L6BvPGobOc+gb6imZ+LZbd3Idp2T+JJ7NNVpYuvFh3Ye2TOadG7164nKf0DINVdWzIGk7jTJ8a1hARlG+MM0I8lhV/FYeOV7jWfD0O7/zOxcPDY1VJobWuKRBJDfvhK0q80ljymETLxHODF9K2BKHabDKflpnbsr5XhrTqpzUGac645KGJfqO8cZE2HoiGZpIPans88FwJG8Br8rTynV6w6WjgEmgq9dV0gHfho5RPzxMI1F1kMicO+Iwv61b+V66V+ZkThnGph4gbDwvHuyPBpscO/tj7iE9eTROacjUmKYXkiGGhmA5Bzq5reZa6wzBtl3DMvkAG0bqX/zFX7x73/ved2n7C1/4wt3nP//5S10f/ehHL4bhX/mVX7l4+VmHhin7qLHq1aD56uElruVL0rqhhL6bOWP1RsqcTuJQeuZ957T8U88z6SvnocYr89l5LeecOOMZPbEe1LBkkjgbBXCITpdRicsY5Bz4SuwS2yQk5qDXa7WcKFDJBEGyrp1OFgow4hVwbSLnSWDI7/rcJDh0wkLe1whGWCE7bwyyCuzkcbXCx0MonydClX2rfZqE42vrrMJTxgjLNJLJVDhOy6S8TX3JNgxZdL7o8mnCOOaNO2UngnP+72BY0dEKTukiXTozebRGMfrBQlvbXwnC/u6UrAm+aX4ZokesOgs21wwVRdhiUWR3U4Nxpfc0MuvKK8N3IdjxnxTc4H0pJLhIpkFrUtJSMBKH8lMXmo6HXoOzp1lWCnzen96rRsB8vhNMHwcPnSKapbZbYTl9777wdu1O9Ux43vGsyj8rLDmW05h2fVjxgxW89dmKg46Xd/9re5130E65ruM2rdEdXZyM2ap06+B0rcK6aq+DK7+zrh1MFScrOq/rVgfnjia6dmo/aoEn49WaeWL4fsc73nFRDFEUPFm3tjPJVBMMJzi79v1aV9bR4e6U714r/zyJYl5DYDMcq5NzXBO5zrpISNzf+lt/62Is/CN/5I9cZHrkJ8LkyKFkGLxr50rmrXM6T4Sdxj9hU6bjvuFzKtjptYBB05xGnj6nnOC6l0pvwpX9oKjgcS1zTKZBohrJM9qBojIM7SPLabSiHvGXx6uzoW0S8vRqmOjQNrI/GfI4jUUajdLI1NWXJb15Op6ROM3ffrqxFu/wCT565GRupOqNI9yOsTg1ukQaUVeuhjXf972kA8czDVfKt26K5lhX2k5Ps5pOQD5p2hvg4wO8nnqYeZw0bvFMRiFp8LDP1K1RRNpyvGw312Y9r+xbehrWOUgd5kbTMFZTStj/6j0kXUu/eLSySY3egLGVXNDo2qwb4PrP/tk/e2nnb/7Nv3nRK1JWT7x/NzzM7HvODQ06wso1dcLkO+KM+3kKnsY/50Ue5uWYZBiitCUvEk51Jp/VKJZFfuKYnK4Zx4YlkXV56ff9vktIDAMhg6NBlDrjcGtuks5gs1tQH0IQy3sg1yS9EoRWV2M4K/FeU6qAZZtaiyfvjoSx9qPCAhFA+MBqNv0MSdqVTuG7b39X764E4NUzU507OkhaAS/EQ7NQgm8YA0bDlcv7qtSxpOTCOsHhu0xY6I6PzCAXSwqMm7qNcc/Fui6KwpEu0dm3Ckdd+Kc+Zh/86Kaq5Zzi4lIFtU6JyrnQtSfThDm6iJr4rwqE+Q6L33PPPXfBqYky+WbMWeQQ4nBbrrkQcjw1kmkkdxHUk3FSWmo/E/ed12aH69Wcs69VcKttr8bzceb0Q5VOmD+Zx10dJ8929ybF2nudAaA+29HvaV92yt7Uv7yeAvPuvcozdn3q1pmKl/rMNJe7PnS4WF2r73bC/q7eqXRjvaKPrL+uzSt+NtU9KTsTrF1fkyZ2/KkqUFN/T2Ga5vFqDtV1oKO9Cmf9ntrunq/9BU+sCYRImaPOXCEkPkbRx9s084ec0P5ED6s5Od2/T+lwfp+6r5WFHrqwfgODKTZSz1DWoaQHhDmRvvSlL13yn/zqr/7qpR7Kyy+/fJH19Hp1PDMcLJXO9HTJxNmGDlnUF7iXz5mMGZlBbxaNTNabJ3ch26EnqawKSxpQavJe61HRNkwfOOg3RjW8LXKDOT2XhD/7njKL+Xk8bU9c6IXC8/QRWYk2Mj2AMk/KxY5VKvYWZbGqpCa86XGe7+S1nE/Vu8v6U26sBjbfqfOyPm8aAo0t6rWpCyu3CnsNaRR28Ivhhmvm7dJAY1hbhUUZ2Dw+yvyMTR7s4vNpxBA36aUknOn9A72+8Y1vvBjaoS1z6tAGc0x9JNu2TfqQ3kriVyOnXm6ZEyrH0X5bt3KvIZnV2z/5gXMN2d355caB8zVpI/Egr5d2gZP1ADjwVGKzgfa1Z4BnDhz78R//8UcJ3J0HGaaWHkfffY2Xpb4njZgzzZxR/IbGNLRrPEpeMMkE/IcPmMuK981z5SaKfU+Dlyk40hMqaT/nKv8Z59NybFgyOzoNADwdQTFLxgJQMCZKEkUt911cO8HnGqESxEOEEqquacJPv/TKmgTaE2HQIuOnXtqAeRvyRBGGSbiv1yRKFyjKZAhbKR75uwpID1FO66z9rXheKV3d+xa90kxAyBhncuRr+6Cnm4urjI/x1BtqggkayNC3XPiy/hrvOyVi1AjDrhe0BT1hQNHYM+G3+599TMEjDUju0HDPvDfmSTvB5aRoiTPqZLF1R8QdDQQY8Dt5EPI+eEUxwNDKczBlBTmZaLdY21e9FfntcaMmU6xwdkqQ/xUmVkbjim/r6Or3f96npDCUi2wuAidwPOnS8eROAarP1Xl0wpNWyvpq3Gqbk4JV4Tnt7+r6BG+9Ps2dFby1Tz4/9aPWkXV3fHxqe3Wtzr2pHysYO9qY2j5dR7r1o6Oh+5aKR0v1TMjS4bej6co7pve69qc2O1yt5K0JT5080+GlvlfvTe3Wazs+Ab4NUfZkLnNauGNd4Ulam2S0CvcES51Tu7qmcs3cu+b+syyuVSo4lVeodKYHhp4+ru/ICiravJOnWLk+pwHJ+rs1t46fITYUvTGUud3cM1TEtdcw+tQz8pv3kE95zjCUNJzl74TPDUWTQFOQSTFY/NRP/dSlzxjW9ISgmAC9eipVelXWUwH1Y7+pD5hRqoHbUH1lJ+up3je2V0PUupOz7GMaeKtBUPmuruvpMZKGnU7Wqvit456GLT2D9DRSNjfvjOOsB0q37vIMerGOGMjQJoO3vjRaVsNqyn3Sv/of/zP0MvmXzzsPOp5mHlVOT1Q3lrbw3kHG/o//8T9+z4arzgyG36kD8cm5mm1mdFDSi3hwLglfGmStj/bVv/QG9L8pFKrXl3TMf2FKDzNzFDlGeOSx0YAHn15p6ux4MGHAfe9733v3X/7Lf3mko+k4kp583/caH0oeoGeWp8rl2Ekz2lakA41P0mVdqzWsGaYofl3vhEFYEz5xbG6tlCs643bOswczLDG50nLpJ70KZB5mZZ8MS5ZJ2M+yW3wnIbRrK4lcgsqTo0yCNblbTkpL9iX/w/RhJhoVGGxirWtummQmq77bRhcqkszsPorltUJOV5Lop3v+nt6vsHR1ToKV1/NkAHcsGQstzCeCtt+OoyFXLiTGtGLUyFCrSos8n67S0p3CgRNfhqf1fMqnw5zjhBHigAkFYzeFkwsQmHfhpZPyZdt1JytPNUl3ddxATSS/w2EKBvU+HxYu8Gv+pjzulPdqiILF/ALAYmx6wl/ncK3DPuWcoj+Mle7h9WjgboxTGNnRtb+rYlHHp9blwuSC4e6ErrOG/qWX1+uh7BTUTiE+UUazjql0CmK2m9dO1pj6e6XkdfB2sHZ8LuFOw+EKlyveuIOrvlfHoirvHc665/P6ThHucFp5+qpPq/6c0EjX1xW8OzqssFfe0dFOh+tOlunwftLXqS+rfnSwTHha1TvxuY7mV+tX12Ztu8o/3HP3W4ODa4ye95kQeAV3h5epdDztGhlrki8nGWkl9z6EbPekCrJZHqHOuPidBgTXdpUnvUc89lvjR+KnyjgW76WxI5Uq5TZkEza9fN/NO2Uf5ReeNewpT4VLDwnlKz+macixy7665ie8mWdFL23e/ZEf+ZG7P/Wn/tTdX/krf+XuH/2jf3T327/92xcDE8qxz9TiPEl86eWQ+FEvwQDGXEGxpq94iqVxqcOn7diXKhOmF0fKPpVPVO+rnN/Zdp705frZrScJa52bHT24iayMmHXnOKVyboE+kNeQ1fWuN8xMowr16XmUinvSvPMBWDK1R+InjXF5Pw15iWcKdWIsRL/BOwe9xBOS6Ssbt0R/eOqguUj1SHIM0/iReYSoR7oFduleOgamDPcSbvUm6oYu9fiybWhP45ZzS5ipIw3LFuHVUOUz6mSMFePk+GggNtUPfcO4Ck9Iw0sm8K5z6tXXxjQ9hdJjSJq0Hb2uTHiuB5J5ptJ4lonV+WioVqd0s144NYaKA8c/8ZShtDWUUaP2gxqWMgGug5Fxd3WgJk+arpwufpOw1dVX/6dbmINFcZKmS+F9Sp3ouo96qhaDxDfE60kMLlDJnGtdUzuTIjsJ7fcp1wolJ3B3dU5K5fTcBJ99z4lLgWkwDhhJVvClACJD4F2Mg7wvc8+FMZO+d0XmqnFRppCnnmRen2rwqONJPZxYwG4CCxXMI3fsdl5LFZcagk1QyHzIY0th3oSV5W5FPUmnG5MKfydkZx6sTBonP6FvmVgu+0Q/iX8GDyTERIjyNDYTae8M295zJ9KdbPrmEa7dnOyUqCr4T5b9TuGYnvdZPeZY9Ph4CmQmAMSwyCddkp91mZQgr3WKcRUq6/tdmRTfDpb6e1dn9/zK8NDRf72+UqaT7zDW7iSbBLSjxxRyK5wVH6drRp2zO+PFCU47uDp81Pq6Pkzj3F3f0V8H/67+6f5UV+1blWW6/q1498m6PPXpBHerMdnVs1rjp7qnOrq2prqnb/g6az8KFMoJCpSbCOw8s3ZUPGTd3ThVuFYwnco7td/12rS2Zl0db5na6Pr7tAuyB5uthpGlspUGBOWt9PJQSasbQBnClrvzyvzWX40D4sX1FmUbucgT2bhnnh1+G3aT8p8Ks+2pYNuebaSOVMcrYU4+qaKZ3i1ve9vb7v7En/gTj2QDDEx8Ixt9/OMfv+SKEQ9Zbxpr0uBlCFx6euuFZeheldcq/WTIT64jdUzSs2VFo5X2a70Vb3kt529+0oNLHNQ6vGdqBvQ5Tyw0l81kUMq+wmeQ1alXj3+NlOkZxn0NTRmWxLcGBMMhEw91vbaujIpwXCruTE6OfgNfBE6SVPMs/+nz888//8jTM/PDSgPOQWVm+ovO5EanhrGcHxkuqk5lug0Nmsw5r9OOOggyvni0uOnK854sJ/5zjtck9EmzeCTRV3Q67oMT+ZH5WGn761//+qM55FxMT8Y3lHDW9GCq40ABn4bT2n/1L8MS7Xs6IqTuYii3eV41sOapcPZb7y5hchzyd11D03j34DmWbAjgTeJmrK9Mnw7WZNKWE2HsRIm4pmS9Hv0JrOZZksGZo6VawxPuaxZjB4GFgA+EyckLH/zgBy/4+drXvnYhUI/TpnTGuI7B1t+PU1b9eBICx1TnSVuTsFWLzMBkhNJpVd4nJUS64ANz46O7pMzexbYmO0v4XCAUJGQc0poTXjfaTqGbYPU/tMWOAkwPhniCn3xGwxmWeJO78Y0grgCV7pi2XYV+68vvbGf6reejC2jN3TQpQOALpcBkg8wpDGDMb3bTNLCsFnwXPhmz7cvD6skcU1/y20XTnE3A4Ukxia/dPPBZhVzGmI+Jxim5g4EQ7C7Lqv6nUSZlpiuTALlSkCpdd7+7Z6qgtSo75Szv7eqrz6Ww220QQEMoDCSlRbgj1PU73/nOo/DTOr5VWOxgqnjuhMwdLqYyKc6npfK76f2kj5UnZFUoOr5Zr1VYJvrq2ulgnEoHWycn3Wd9P+H3J/Nw4rkrmvKZvFev1fq79iY4uvqm9rsxYa2ARxrKg/zKfGKtqB4AK7x0z528e/rOjm/vxqmj6w4f0ztPuzAGjEUWDTMZXpShNentX+UQ76cy2fHfji9QVOZU9PQq4T7rOnISvzGy8Jzh+hkOk0l3ka+EQ1nRdbuu1TlerledDoKsB96A5z3vec/lP/Iass8Xv/jFyzebbZxw9S/+xb+45ItJDx1xkh49eo7TL4qeVpT0LEKh1yBSdSVxkO/4e8J/jl/K1is6z2TPwlDD2/K9qjfVta9rp8LMWGlccLNHea+ux7Ve8WYInZtEGqYSZ9lH9YM8Qj5lUmFLD6X6u8rZGSVhPciNGi2RO1544YVLW3i9OabQMTIxz6sLqbtwLb2BmCPMHWQX5er0uqJUA4myd9IRH73ouKfnkl45dXNbrxrgq3mHU95KWJWlufbpT3/6oqMzD5hDtMOagaGW9xl7TolDb9e4PSXo/r5CA2k/qTxHmE3Fo1Ep55hyv7SbhnXxpJEbHPO8dMlv9Rr4VW6YOw/Mw5S8SiOXcAMj4/qghqUcJIBkMUBh0mhCMfZy8v7ZLXAPVSbBKD0wNPhoeaYvHu1dGf01sCZx6YrmJGK3zJ0FjRUIPMABTHkq3UqA6oSs+8I7wf+4Y7MSqh5amKp1ufDlIpLJ41btJbNmfGAmGj5kjFV42cGjESPhkHl6P/uXTKgKTjCdV1555bLL4O5J7qJNeOuKXnXmjpKxmWDQY0y7flblpxPW8loKJ7kgpAFa47T3xFmla/8DH4n2wAdzjfnL4gc+TjwQjXVXgPUa8zANvl2pi4jGak990Y2UOtiRJWRS/mI/aumuUY+Lm3H+uTini/O0+/d6K1WhTsGyo7NUiDsF1+uUWm9e69rM+13dKxqaYMkyKc0rZZTxJeQAmmbMGX/oCxqCH2Fo8lSS2ka2k4JqFeBXsJ8YS7r1qPaxq6OOZwd3bWNSDLtSx3nqQ9enk7kz8bfu/o4/nsBS1z7H0fG9dp2+5vkVjebvOrbdOlSfr7+zvSqDTAriRB+1fXiwa8W3v/3tRyeHsgvfebbu5mmOQwdX7U8dq/uO2cl7O550Kkc9rZIydyr7rmt6EJuDJT2906MnvQSSxzhWqahTbC/DQtzVN9xchY0CnahcIh/xbXoQFTV5N9/IVHnirzv9tpd5dNLo021+VNpyoxTPdfQIve6gbT4e7AOcH/rQhy5hTHrr17polzr+5J/8k3c/9mM/dvFyYtPbPuXmOO/SDp/c5Khw2qdch5T1pn75W4NWxxtynH02x9nnfD89Nnw3c08lDtLbpM7V3Ax2fK3Pflh3wmGYkSGShrFl4mx/V0OWkQwq+BToyFLDDoXB3+kNpt7ixnEaDPiGD0Kv0BMfaBvaRa6GbyJvmMOHepBLEie0wZwxV5Qe/+KGj5406j7q3T6fHk3Cm3ljucZ/51QeyqPTgKfiySukuaS1pEs/jikwI2P96T/9py+/0SUwkjEvqJPNvX/yT/7Jow18+VDqLDVn3+814Yl6YalzuHmcxmmNVv7ONC5ek096MmHm+GKMnLOG9pkuQz6YEWg5Z6W9XCvcMD8tx4Yli42pvOsGmgNVGc5uMatMZCU4Tu9WYTXzwtSJZMgQi4II3XkLXVucHLqn8Z+JSrt40qAs4CnCRGYB+MQnPnGxmKYy2wlYneDa4foEZ10fT3Gww82qntW7HS3k90kfXcxZMGF4MtWdMFXx7PuU9KqRyeVu1gRTukTKUGtitGRQurpOhedYCJjkCAvAxa4rTONEEah9NFSP6y6MXIOhUjCK6K20G5tOaDBWWs9GCmOjwcrjTBO3ztEa/pMw8DHEgb4rgLpYdR6TVWHgWd7NUxH0xqxCqu9UZZECzCzG7IajtGj8cSGFjiiMUz3Fo8Nrjo/4sz4XXndaKO5+5kJ1X771EGWlZCUPm+imwl4V10norO91eKgKe+VLtc6pb/V3LR1MnYdNbUthk7VCg7T52DiRhJMQP/WpT10+6eWYOK543PV1V/L9U0X6RLnt6u7aWME1PTvVW3lA8pxVmXBZ253gnuh1N0/reyvcT3zkxGuv8qTa1+5e19+T/kzzt/7vcNTVP/H5hJE5hYLELrqew64vExy1zqm9Hb/dyb3XyEO7MrV1n3n/NIqyMTwuD85xQ1Y5PkO/M/lvGoeqR3rd9MnkwIbUVc8clDHWcL4x0Jg+w3aRDTwll2vKLlVJVrFDx9DAkEaa9LCpY5JGj7zPNWUxYPzABz5waR9DD8Yj1gyjLlQg8UBBLuGZzIdrvcBBXZwI9va3v/0iW9JHUzzwjmkcTDFgCGCl4bpp1nmV1Xxm+c2nKuCOj9crH9ago2wpL0+6kA7ScJlGp3yv48nKitADzgE+zydxkfpmGtOU2ex7wlRhqDxPmvREy86LLfFokdarvMX1zLsFLIwptPMLv/ALl3o+97nPXfqKbM43nkuGDqOrUtzMrnl7+JiLWa+uuole07+Ir8zpk/K3+DPvkEa6nBv2Sa8ynkuc1VxB4ku68YCnj33sY3cvvvji3Tvf+c6LQYnxJVKAOfHv//2/v8jw2j1qFELyke+GY4M0zP+k0xwfeUSOfcKZdhbpR89Hi205Juodbpabl61u8uccE6akaXXENAA+EY+lTjDqBJPd4niyaO4W3fz2NxPRk7hM2OgkyMGrQsXjloRDRpJujExeBhh3O4xKTACT4aXr3koZqoxkEtBW/VkJalUA2Qmqk1C3anNVJni69ieYmTwwFWhAa26exteVWm8KI7mouRjznbH+FQa/dW2EDnxXhpGulFql09I/4ZHnECTYdcVAyWLn7lnXr0kJSGFAQ7FCEf/ZxTCJdWd4rXVWpc1dM7xtkmlB9wj4Lk4uAOJbj8h02axjLc5dLDJUb4Ivx8XrCkoKrcbTT56LnQIL0+WoUua0cd7p4urJdyZ6r8pdN2/9706Bu6cKM+A0dxw0hkEL6Wb9rMrE73fPrN5ZrSPd/8mQs2p74n+TAaFTRrs2O8W0W79clzDo8s3YsxHhbmHu1NV3E+aqsPp/4p+TkpPvrXBW667t1/onxWmCoxuPXf8muDvDQwdrba/DeS0nivsJvZy8u8JXB/MkK3T1rtpO+srnU3mb5k1X56TMneKyG8vud+6m1znS4WMni3TXE56VnJXXVutqPtMZsK7B89TGsyyGlAGLmyW5o5+8XNk9E+FmWFSHCxUj852aTFgFTNkbvoq8aL4ZZQo3wFx31SdUvvSiQqbJMBY3/VyjlQPS0GBOy+T7K1lFmcp+kQtHJZP1gjalZeQ2nmXjGrmkW6uog/5yGAzHyn/rW9+6rDfoJMgryJMYY91syxQn1RMjvcc6vuz/mgO049kdzftMleGlAZ/J+76f16sXb31WWvN3XmdsoZHMq5N1VrkuN4zTU8hP4tJx9be4NVF7RiQk3n1fOLxmviINMtWLy7HwNzm5CJmEXhhr9AuMi8isPmeUjZvqfNzUtF69pOxbGkSc02kMNOE272h0Nbw0caxukie3i3dxLN7Rr41cSIcSinJ+ekTmgUHwo6985SsXzz9yLjF38Aikr+AndaGKf9eYN8QmOd/Vm8hP2gjSQaFuiueJbpU+7b90YyhcHhDmieg+o+E5vThzHvrf5+Vd6mZPzGPpmkV3V9f07n0WykzUnAmvtLZCaCrKpwvyfQv1O/GccExMFFAYObDBuInXhHBxs5sMH8CYSaMlvsqE8/u+5b7C1er+iZC1e+dUWHVyskOjQMHzGDLqrvQkjHs9LdApfKbHW9bZCfl6rFEYc3PvUBcMmoWbia/BQc+e9FyqYwJ9s7tEHD3HhEILeDCwECQDq32pjJDvPK0hj+508ctTB6ax7YQhvqnT3T/bc7F0l8/TVPz2fWHolJeVkL4qVbDK0xwSZ52XVO2zRUMcBp08pcEYdHlNJjC0ja7Utlw0xZ1u1brgs6vEb+gcgdB+dUbGp1U6RT7vTcrXSvldGQJ89z4K+4nhoIPh2nUj29m1xbxBsPcUFJQWPS4Q/vmcGskrvN2aUftWYa68pLa1W78nXHXKTi2VXjr4OvqydDu8tV/Xwjn9XuGg69cpDk7anMbomvV4Gsvuuams5kcK1t38zX50ME3ySDc+tc7a/qqcrC+rdWhV/w7H2afpvR1OTsoJzT2NglzmseGeuktxDVXxcXNY4w0ljQ4rmoKPKocYXsy76APITMha/KYdFEm+3eFXXpLfup6ngqrngMehC6MyukYDNxdVjBNGn03vyTonlBvAmbKt4fwej86z9FG9A/nAECrf16jlxjZ1YUigPk9JfOMb3/hILsJjxZy6CVsqycJeSyeL1pJhXd1mf7aVnh+Vt6f8ppdMVfL5ZLqRunZkezkWqfAzjm7y1fCgNHhmeBd1ZmhXei5lWFJG2lA3H08+lua7NaPjrRoFbI86Mpm8/TIq45Of/OTlhGmuoZMwB9BZiV7QC58+mCha7ycjMTKPUoZyCTOwOI/TU0jjiik4rD/ng/pJjmXHk5kDpJVRbk7aq16Ntp2GPNvDToAhiXYJocZryTbFZdJq0u/vvaY32cf0YEu4jUYwIsFcrIkz37MvGeaXNCzNeLoc3+bOynxMyXeqQTRxzjd0kadt56FND25YqozidIHaCSPXCO2T4qLxxuPdUykGOTBOXf+q29muzd0CXt+HELCa0q5Z3zkWFGsq/1kc8GCCYWNU8vSrrEuCoU8wfP5D8FpiOwXhIUu3WF9b6phOdZ0ITpPg2AnTTAJ2ccAXRY+wa4XK9FiSScMYdRWdQgu8Bi3iVQTTrO7Y0CiLO3RCnVrkq8U65xswcBIatIRhiXpr8kvblu49yUEjUnpZuWunYOeJIO7qVWFnGrtubFzYkvFREp8m58uFMfMW5JidCPwVru5/J4xmG7XdXd0ei8rzjp+Lq7jMPvn+1J+sm3egD/mZY0Z90jbCMLmdeM/xm5LKP+2yWiM6JbF7pq41lW9P9UxtViG3U0Z2cK1KCqUd/8prnYAIv3jve997EegYS+PjEZrYhDg1Gq5wU0v1huhwUteDac2s/an9nNb6jo93fenqmepY1XnSztTHExzs+Mc19yt/nRSL7rvWW+Hunulgm/A+/Z7ar7y1G6MV3BNsK/4x4Xq3vtxH/lnJkis4VvS2quP0nWcdIt0VQ0r0gPD0LPGhksM9T51K5Tx33ZWJ04jAusn6yLce4chMfPQwxiijQcuE3RoBKn2I68yrUr11KJ5oJc5TF/FEK+WrDJXJPEQZukVxTQE2Q/hZ91Gk7T8yFfKIz9M3vE5S9qI+8IzxCHkFnHBdzwZgBz88p0FJ74cVXOK+8/rJ78RljnEacWr9NXSt5muqBrlcgzP3ZOVV4j/rSRhrm8rtynXCn8e613W/1ikMGZ7Vebnw2w1X6dD+5BjkXBH3fud8mHidhlvoUh0HmcNj76XPpFm97xI/wKmMKn7zeeEzrIqPCbk17mTS6cxDZn/sf+YjyjHnWnoLZnhqNXyKP41i6bQhDI4zvz0VTuNP9RTL9fG70W7+zoTn/qft1M1yXohLx1xDpl5M9tv76eXmwT4auatBLutOOtKIyO/Uw67RKe6dY8mBfohSmYzupVzP2GVLIiEZBR3XI0RPEZ7TMknBwOOOwski2wlCqz74HIQCgdMWk0VYvP7bv/3bj5KfoSCme6/98sQuFg/gprAIcIRoNUQ9KYFhV++u7TrhTtvs3umUpEkR1MJajTQnuPIZhRgZGcXxwmhlLHEHC3Ssh5rx9tKxOR54x+T30obGqnr0YzIBaAFmhHGSD/T0zW9+83vibZ1L7NT98A//8MUwCezsTBErbyw+37yfC4Qu33mCxVQ0hrnrkXMrhQXv5a5ANx7pIjwthCvFY0cv+azt1TLRVS3OU3co+CCc0T9px5MYwLuea6d8M/kFv02aqJcSeDdHmycgpqv+66FUJfc+CvdK6aq84lQ5yzIZgVb8ZaVA13drHUn7naALPMxX+AdeSiRTdWOhSzbc0XVen+7XPnT1dfNvpzjv8D8ZEiaFeaKd1dhMcEx9vmYNPaWJqZ36u/Kujg6vgfO0Lzu6qfcmxbDDdR3Tk3nfeSskDNNa29HNtHZ0/7s2Vs9O/VBZWD3zUDLStfU+Lo98UsVxBy4VVxUbQzYyoa2yHSVxbb/SU4T1EvkH2cQUA244YjCBpyJf47Wj4ad6iHRGAkN5qqHF9ZcCzObozJQKeqfbrxyflCfqfFHOSoPDb/7mb979pb/0ly5rP5uNyhfoDZ7i9Y1vfOORYUnlkH6/5S1vueAEWcK66Tsw69kCfMCrrJgKehotqsfR5FWTfel4Wo5rVdKtOw1Wes3kXE/cpWHP+4ZiJY/QsGJ7CXONDAHvmXga3Og4gBGvzjlTGUiDGWZk+xoY0ujgf42pSR+Vt1aDUhoZ7K/wqM8Ig33Xw4e+QU/c1xuJe1xXpuW6G8b21TylmXvZ+ahHot726jYm/vY3+ON/Rkykl41zjrahU97LPJO05YFc5hiCvn1GHU64+c+4aBNw/qbTRoaTqZtVT6U0XqaR6X+9ZjCkaIPIfLb+T30vZTvnhPBk3lbnueOUvDDbrrmgcr7lHANnhrxJN5mrlmelgyfqsfSQzzrQundiGTT20vA1mVutu2PMWSQmJ3ANSVmVSdDLe93z/jZZli6phCsxaVEU3WXwpIDq+WKsMx8WRyaJSiu4caG8Ftf3KSsB8XHbrELg7tlr2szF6tp6HL/cGXAhgQHWBM+1ME6erpAukT6bsciJB41Dk/GB+xiGoAmeFxYMTMlAFBaef/75i/GBAsOGkXoyovBAm8RYm2SbAt26a5FwVzxSH8KZYXQmOTTkNOO4fUcvDA1Q7grI0LoT3U7n6knZzd1OoZ6Ece7TV3MaJL0gKHuqBvdTAK5117bzGcYcYbjzbIGfmGhUw8ProXRzrApt1yi0nZI0tVmvTfXWdldK8CQk18V6pRDXZ7u6oR/m81e/+tXLf+iH9YKPQtsEQ4ffKoR2JZ+pdL6CucPnZGCY8J73pn5M9Sgc5/8VjXSwdm3dZy1d8acd7+qeq/TUySAn7+9ot6PZ6flVn1Y8daKROu+mZ+r9arzZ1VfpaprfHQw5Nzp6rXPntKxg6cruue7+NIcqrE9KbjwpuZkqHBkqls9YUpFO2SwT4yKXeJIqslH1NJGX8hvPUPSOmjNGOUpY5L3Jh1M5T4NL1q9HBv/VZTIsKvuVhpDEAe/TF9/hG32CVAh8PvrRj969+93vviQe9gQ7nmFTwtBBjQbIjsgmhra4kaiXtV5MynKZkkF5LfWtNBT5jNfSq2xa/3039bI0KHTzPOdOzvvEX8r/6a1SDTEZIlXbyk0njTXSUYZbGbaW4ULqm8jV6RVTQ7JSB8j3wLvpNio8ietubUg9IHM5+b5wp6eMBlMNjFx3s1QPPEr2kTpSdtfwIG7S6AFdGbqZXnrAqf6gISjbkS7NHZQn1CU+7Y99qIYb4dI4Y9iYqTicE9J40nUXmZK0Ucfx1aBR+6fTix6aSQPyMOet/dawlcZAbRimTUnZMb2jMql6hlLm3NAzSWOdRlMNWllHGmAf3LCUZbeQngi1yZxAPEqqE5ECI6RzKGeTEGSRSaZrl885qafcLSewXoMLidPBRlmAcLUAJ6FXlz4+eCHgqYRxggHPHZyu748D9+7dx23nRKnJ390itBM+V7TY0cwEU94H1y6wjhuKnqeFTIYBPoyXzFKGJ91lLiG+oXEEjmTWE/y8ixEomT40n55FzifmEuFyxsq6K+WpH2kNNyFfLrC5q9KV9J6iTeo2Dhp4gJV2tIZbF20h7GViPxeT9NSacPAQZaXsTwpKR5N8mNd4jDFnTZRI/53zU/Lzrs2pv7loOb5edyclT9V5lsrCNXPckoJi5c3X1L8ay26s8x2fqzB2LtQdDKtnVspnVTDhOSgEzkHGWCPsZHDu6p6Eza79CmP3bCfAdn2dePdkYOje3a3HE4/Y4WDq++56R7+r96dyCuOKH3T4vS8ctS+TMufvCa56b0dL9Zlax269r7BN9DLhelUm2Wqqa4J1J/eu+lLLavxP+3UC19Mu0pyKXBpoaohJp1hT8lk9FZCdkU/My5R1uGktP3UzxkM8Kr+nCEeNKvCaypcKsJ40yjrmV0LOE6Zaf55e7H0VYDeQlCVpi82HX/mVX7n75V/+5bsPfehDl9ytbBgSDUGfyJeDp7T4MvWCMFu/6RmU0Qi35oMMwylxeTBKroednF7X0fSeyaTnNeF26mzpdZT11XCmXJ/rmCSdVy+mpJk6vul5ZX8yTI2iYs+19OAhD48Hz6SnhwYR+88nk2unl34q+3nIwDRns+8pYwpb4mkyippjTNrXOKOxCHo1b5feSBmeZ35Y8wo5TuoE6uTcVx6uOE841QccA2FRx0kDn3MlN9U1yKQRRDxpvFEf4lnmJN59pqtIeplkwVyzkj79/4bXcKDu40ejUtJ8nlDp2HgvDwAwF5XtOF/T8KOzSr4v7u1XGqs0eMr/vGZ0iYnFhfF07XisULiHKhIXC4IMNF3GPOVLy3unLFDcEXDi6rWRRhwmUI2dFoZr+jgpP5NQkESdE6jC4QKjVdawKZiVsdmG1a0YzincrwchowpXO2F2J4DWeldtdeNn/eAZoSAZsbSTRqBKOzKVVP5tx2RqCh7UA81joIHGc0w72DSOsuALp4wiYaFtjwY1RNR5xvGzGEKko+xHrWfCj0zLT8Ji+/zH8JVhXOYb0sDrWOT7tf8TDKtxP72fi3unBE31JGy6yrpTmNd3xrlOqVr1Jds1z5KLlknSodFn7blUeWtHU5MBYRq/1bjW+lPgXOFQOFYw5PhNinLOi6lM71SYFP4qLdX38v1J0ZyMAZNi29VX21nhtOLgdLw6WqiwrfA60cYK59OzE+5O+jX1s9LHKZ9Zwbnq14o2uvp2OK84WdH7aq7V310fuvsdrUz0cm3dq3cqDB1fW71zUq6F6xpaWfHh+9T30CW9joQlFeQ6bt6ru/1+e7Jbhi3xX0/opB03ZZRfMil4yme2nSHmwl0T9KbiZj16SKmwVSODyp/Js/VQpl3kf+BXITXlgGEunF71d//u373IqaRdIDzus5/97MUwxGa88hiyAXWbf0nDTq4rGgEwRukBnbJl4tqx8bp5JXPT3mfEj0VF2OfS64LnM8rENrPOxHXC0cGWcngaYaqnR0dL3ZpnighKHnhD38E/eauIKACHJvjm/TyFy5K5hoTDU8oyJ6ewpIycMKXhS8NQ1um7nUeN9THeGh3ZDKagj3Ad/SQ9bQxnU38QT4lr4ZHO0yHCTXrb9iQz36/hZmk41gNK/TiNLmn4si4NVBkWqMGHd+grsnI1KknT9itxmIazpBsNP5T0UnTT1zxy8oI8xKlGvyR/SR3FxOeZm8mUOsmLpBF5S/LTTJguTtMjKkPgDE/O+h7UsHSNoFLf60qtQ9cuJiqLg0qonh9dh6pCoMcSRhjqAnHJFLXMpmGpY4IdnKfCaL02KQ+79uy/DF6XRSZCVcp3dd1H2HmoMgnBXemE7Q5/tZ6VoL3r++oZJhM0k3Xm5F8VaVHDCyXdNa1PY5WWYxetCc4UdvJaJ7hDP8BvqJrhbQgXuH+7gNT3Vr87mIy9tW8p+PHf0LgUGrMPaXyZxnilEHZwJXxTybonOpsUiSpg+jufq8/u+tLBO/WZ5+Bl8DoET4U6DXcIla+XcqpI7hSf07XEa1VpWb3XuTqfKnzXKoUd7+5gTNrqaK9T/nfrVcdjax/qtW6NrGPV9aWj/+757t4p366w1XerEH3CQ1KuWNHiqs7V2tRdv4a/TTyiwrSDrcP5Ct6JT3ZzuOvbjr+txr+j28l777Tt2u8ql63wOpXkO/VaDbepcFIy/KKD89pyjaz+LEp6IPk/5ZyOJvK+CpFKmHmI3F3nkJP3v//9FyUZ4wsH5eDx7aEhPGfoDzqDxieNLLarwqjCleFdKt0qtMKcxhtzFlmHnh3mk3Iz3fAdc6qaiNcDe6gHA5Eb78hzbDJ+7GMfu/zniHT6l6F2wINxgA9tmt5A7ygVbT7gSY+KTsa0vzlW9bdjVOdPGozyXnqopUdRtmU/6rouTNXQ6DU+1pFeHIb+SQOOTcKq8p9JlW0PA5+HKmGQ8WRllXBPgNbby9yIyQvSCCJceo9o5KgGtGpYzfsZvlSNZRqbNFRYlBnNteWBOl6X9jV4Qac8Z4hp5g11/E1w7YliGt/sW46Zc0H9xD4lbeTGdea8TS8g8WfduTknPqxPLyLmiB6E9QS59OirobbSR9K+79ned18bW096y3qrh149tc3xrNcN8XOMPXgpHRXsd85FjWF8axfxumNnP6R19dK6wfnghqUk0muEoNM6nVQSrhMfRDD4XW6JTkhSoXdQZS415Mx2s46p/kkYPlnsJyV1V1DGM9SId2H65NpIXHQCVxWQunun8D9u6RSWCe87mlopRJMw6r2dojUJsjKqvD4pNBaZB/RnQrRkTunyyLOe+pSnhnUCfIVvJVhTP/SiG6Meb86P3LHp+jC1W+/7TBrLtIYrwHRzN9tLb6Gp3W7sp7JSglbPrebGShGc6K6+v5pvdSx27SgQsTsGr9C4ZAieRww/y1Lh7hS0qsTt5nHWfTL3a5snsE74rmVSQBOmjv9PfZ/gXz2X9a3m824uZx9SwHpcHl1xUOGp836a5934dWtAh4/HkVXqGtLNzRP+kXXVPky8ZcVjJlzUtqb17Vq6Wa0N09ya5sJU125+Vr664hldu/XZFT/eyQXT2rvC50oeO1mnvD8ZnzrYVzjd3X8ahfarx7B9U1YSxvSG4Bm9HExiK17QF9AjPvCBD9z91b/6Vy85iKif6xyp/s//+T9/dACOXgAYAcjJpGeTRgKNLG4wqlyrqOsJkfzBMVKh1JPYuswPg0e56QnM8cK3EQt6JOtpkd4N5FfUa4Nr3/rWty7Pkag70xqYoBijEu2ZQoFnNX5QrIuS3hPKmTlOOQfSIOQ4VSU9DQUdv0uPjGqs8j2fs1TYKi0Lk+PqOIgvc1aJi0xXoLeJuOB5aIWNWI0q1KfMyyae4W8U5WwjBWyzevNLNxpLNO6pp3b8p57gld9plKuGbPFuW5UH6l1l/zVsmTsq+6KHDO9mzmLqyMTcFPRX20pPGXHuHNZYIo3n+MoHKOpSaTTVc8cxyxCz9N4xhyzfHqzjuGQEShr08pN0JV2ndyLvZqjb/xM0VeUReYrONFyruZbTuGgd5rEyvFI8p9E2Q04zHxr1ZL41jXbiyL7n/Eu86JDwoIalbhG8T6nvakFEMSJGFUKUAEEcg6+CTNktqN3ifyrk1esrQT5/r4SQ/H2iIFgPBIA7rLGvqzjHSdjdlZ0Qc3p9V9epUtbVu6o/70+l1tMJzbvx6+5PY5ntMOlZ6JmQfDSepps19I2xcEpOX9tb4aLCzmKHSzR1GWbKNwskSb+TaZzQ51QU7tId0wSQ1/RjUmRP+lv7vvrvtdN+nj430UcuLN0iU3lOpxB188WFxgTu7pxKW8+qdPDX0tHaiv5WfHka78qn836H/0mJ7OrezZUdzdZx7PjIKY5WfLnWN+G2448Vzq7ujjfWdzpBuINjguGk7PBR4ZroodaVv6snSvfMqh8dHirMKzhWa/spjzxdL7s6p3k99ePaOXIf3l/n8W4NOV1/pnrus3bs5veu5HM7o1KWfHbVn2dZgMkNt27TN0v14OAbOQMji6fuGnqGnPORj3zkciKuHuG8Sx6in/u5n7u8j3FJpQp5WxkJwwEGHWDCaKAsp66SyqJ94JPeE6mIprLtKVS0w3WTGauoqxCqWFavAgr94x71cB35EZlOhb+G63gyHTIo3+bVceNe7w09OLLNarBIHpD0letY5e8+W9/NfllPKsJ1blfekx4e+SwfDUAowm9729suvw35MWolDRaMvZ5u6a0h7eihpPGNNsChhrwMM9MgSX2esJbhRTVcLWnFMLga1dCtBXzSKy69SdKjruIrjQfWl2GMetzoKUQ/0c9NreFpgtIiJQ1EFMM9nTOeHK0RyBO1c/yT9it/8L6eVP7W6KWnorTvfErvOuic8aBwX4OvXmPO8TSeVhoVP/Y9vX2s67ubU62lM+lU43J6DOUc6d5PnqE3mQbFxGHCrsFNDz15gafW228N2enhZp63JxIK1/2/ZnFKJpCTCQZJ3heOwEw3VoiXZHSZ56YTdHfw3mcBrzBn253SVhXHVb1JtJOiICOqCXnronbaj9rWSki9T53TvUnpqLialI363lT3buycwHqAgVcW0WQECVeFe8L5JEin+6xJ27XWM6EdY5h0PXntdEwSD/U9hSWFpze96U2PQvPIr5SGpQr/pERW3NYdpkw+mSGEib9ugZzanOZGtj/RRX1+wt3u3k6ZqHB3dSacXT25A2Id6enVjbHP+pzC0DW086TKBEOnuHU0UetxHu941qTE1Wc6WFe8qnu/8oaOf1V4rlFM69zawbTiz7X9hD+Fl7xex2pqewXX6XMVrhVNZJ8q3pMn7OZB1z/r3r0zrVUTbXV96WhlqudxSreOTW1VPOzwUvn3bg2f6lrx+92cWsHW9b+DvcLf8f6JP9SwnGtkqoqTbm3s4Fy9V/vWyaT3hfFJFfmcvKgmF64eM75jKBnGA8KRMBoh57AOEv6PpxKhYYaN6WnEgSa/9Eu/dPFcwjCAnIbiTB2GyWTICs+k7K+8aO6kVMYN/1HJxZijdwKKGac8Ez6Fl7EHr2RqDjcdNfho3Ej5gA/XTC+ALKf3VdKEMmd6gvDbsCcPfaHf9AVdi83sDEnq6CbDg3L90IMj6auGX3W5aSp9Ji14r8u91OV0sk5wzWnIHkvvcfHUiwcTG3EYDTWoOV4aKzQ6ZD4b8GRooid+6/FltIH6q0aVevpXZyTN8TbXT+q7dc3Ia+IiQ0K5Vj2Tcjwz90+GH9quBgrpGh2FOUBCfGnLE970zJFO06NKHQt9x/vCrLyacGVy75qXVsOZ8yDDGhkDjTOZ/N75ZdiphkHGm/ku7HygBxxY1LfTmJV0a9tVD9fxI2nx94qBKr/1JLRPfIxMyncqv0vvTq/bZ8Pikl/mPPS6fEq49ZTLQw7qpoSGryly7EFOhVsJn7VUJpJxr/424Z7WRBPhMvH56Fq4Uj4nGFewdc92BOBio9trxiD7XBUEdov37l6H44qDxykTfPep/1Sx6d5b1beqtxMcO8HPCYvwwYLisZmMH7s8JNlzx+FEgartd4zbkjsSMlKZbQrkOd6n+O8E+Spsm5zy5ZdfvggM9B3GTb/TQ6rWVXHf0bWMSsu/1nNx4KLT4UxcdcpBN2+nnczHUcBOaCv/p1BVx8zS7Sx19SW+xRmLjK7xmZcqT9CodSaj7+j+WZYT5eVavtEplfnsxM/qYm9d+cyu3IeP5Tur9+v9nGMna2xXVw0j6GCuCnOn3HYwdrBOz051neBkgn/1zrQu1Ge6EIoJnmvx38F5zdjl8xWmiU92c6Dyn2vXlo7ndDDV9ypcE4y1X90cngTz7E8aHGq9qz5O1zp87/q7Gpda6vWT+TPVN82/bswfSnZ8yJKeFamIub6ll4XKpLKDqSJQLN/+9rff/ezP/uzdH/tjf+wi57COkk/pP/yH/3AJF8cowDOekIuixHqLPIRy5wEq1ImSSXvUYfiUBpdMOpzpBPw2p6aKsF4owIhnFe2j0yCDufmWyXMNlQMenjexMMXE3RTlVZ81KXiub4b9GDaDAcqTtFJ+AB7kRIwHaaDqDCIdjafCmiFtPpteSFlHlTutq7aTclfdpEvPp9QnMeDhrQaO8eii7yr/4AzZCrw6BjVsyrpog3vm+VXm1YhQcwxpLNEIRv01x1Ole9vjWccw7yd/8/0aMlif9ZrPp76aMmPN32OolOFoJh03siINIdkv5VTxoH5gyJkeSgm/NMq3Rp/aF0s9rZG5yvwwwol7zOd3vOMddx/84AcvMDHmnmaHnseHfGQekgRMwOYc1yiTHlEpJ2jE0UhW9YCU276/hCxmP/RazLBH4NBLTDrL09kyd62/M5RQ2rNt4Uk6SB3X0/7UPTKRvNFi2ml4X+OT+ZmeSCjciUBfBQwJUUsdVnu+GdxEMMX8NOnNUevsymrhvHZRlbGwIOkm6aCaw6TCVRnfpLyshKsO7sdR0KbykELGrq4TBaITHndCXb474YmJR4glu1QuDi4wGJtYYFwcOqF86mNdFCk59tXI0BkHs4/XjsdOyU2mp7t1LsJ5f1JMsp8dfDJEj/hlHtOOc3cyhGqsNVbdhVrGtlpEV2N9TTkR+Gv7K0H/BJ6pTQRDdloxrpswErz+1//6Xx/tqHYu45OnXcL+rMrEyyYl94RHTMrt9N7JGOf7Oz46tblTtFd9q/P1Ghimfu7WlwpTnW+T4tvBWP/v8FOfq/2ZFOSTssJDLbWvEzwVhhNa6fjCqeyywkfHnyov7Oipq3eizan97trU/w7G3TvX8qtKn/Xeqr0dLHnvBPau7RV9TPxn9dyqrh2P2bXzLAtrn/KJfcwNk4lfm/MFA8L73ve+ixEBPsapaM8///zdO9/5zosHEx8MTBhPkFPe9a53XTxZ2GxDUUZRwrMJ2RCFEyOUXj4qkobvsNnj6VYqX6lMoqhplFJBQy5CAfZkN+CgHr1alJEyITE6B/3C68p6Vd7BlRuhygXqJvQnD/ZBeUX2NbWISqKKtKfHClOeQpbeEfav86BNPqMy7nXHaVp3qgydSnx6Anbzr+PRerCxgYy8Dy49TRx5ygTb9NVNXsdSI0h6EaUyDq51fOAZDTAaTNJ7SmOMfeK+BkaKRpjsX9JC4jZhWa3lKReu1uj8rptPSc/+zjxQwAdN2YaJpKFJabEaBjXAZd/Eg+2YYyhhrd776TnGPXU6dQfuMa9feOGFS+gjsrMGRD20MObyLHPRPGSOhwYf+5uJ1R1zwyBTHhfGurlByXHjA+1pxKGktyKF9z0hL72zbE9vuRxvvmv4aPKUjHxIoyPPgQPxLu3znp5TmcMOXkt99cCnB/VYWi1Udi6JIC3BDCoEQegbSEZx4hQDmKL5Z2AGXIdJV9euzkWyE3i7SXjaH/ugJ1UStXmOtHR7ih1FpTpjLE8E6+5/fW9VTvt38vxOsblvWQnYkzIy0RUlmVgngFkXzA8mpBur45KLbHrPnChuU1srAXEloE5KxY5Wdu/Ybk3iNuH3RBCu7UHzMBsWbhlZde/uFn94wFvf+tbLf1ywyQVlXLseir5jewpIGgZzsTpR4HbzqS7gMlUXpmyz8pxVvSvc0h+FSIVY49EVUsyfkHVMhktx7CL4ei2d8r3DZ17vBMs6z6Z5Mo1VFQwSthV/6ATu+v7EV1Ywdcr8TgldtbGru+NLVaBdvX/St4rHSXle4burf9p8qm3v1r6unK4JCpi1zhVtZB98v6PlVZ+6ek/6Nl1bjXvSWVVq6v2uTGO+G+NV32q9icusp6uvwnMiQ2Zd3Tq6KtM7WZ+wT212be3my+u1ZLiXBfhT+XRN0+DDO3gncLw7p76hS7B+4qGALoEsgkGJZz784Q8/8kxHNsfzCJn+q1/96qVNPJzYYMTYwFHxyIlf+9rXHuUToV3eQ2n99re/fZFT9ObwFLfMlZSyv3mNMCyZC9GEwcqv1K8C62YbbWvoUtGkfpN7+9HbAPzQV77pvzhTV/G0O9rXSKXiaghQPSk7jTzSYTUapUfZincnTWc96Z2S/MR7Ez+yb9WDDfxh+DAfEH1FrySVimFCPGeOqvQ+q21kriXlMupOA4onn+mRxhjpocS4ZHSOsjHP41SRXk96KaWRoa4l1XggXtJQYEmjnHXl2iIO86Q7r6d+pSMF99Qh9KhLnV6jgyGCvi98lae6yZ30kGu4MNQ+g1Oe0eMHvBne+d73vvcy1wl9/bVf+7VHtgPg1xiGsQn8s4kLfWgUc/z1fjIptro8bXOPb+duPUkwjTmvFh5uMv5M+q487zs51hp5MrG/RtDanvjr5ms+n3M6n+cD7/OQqUyAzn9sG3zgW3xO15arDEudUFAnvJMKZgqT5j9WQ6ziPM+k4h7fAM5vGD8MwElJR2GCKpgyDd4B2SA6dzkSmfV3wr0S8rIPtmey43S9ra6mLGjG2UIQMGkt4ru8UJXx1uem/ydjs7u+Kp2QdoK7+k69372z+2894B5moBGP8a8ebZ3AZry0dGNiMncQunCtE9insaxwrHC/Ekp3uO7+T+93c/ak1LGv76UbbeKxzsFcHMA788p8CHoFwjhZDCjGPQuDc42dKN5lzHFphdFVRjox1w53q34LJ0IKNORBAu505Al+k/JzohgqlLiwuPOlQIPRCVzAVyqtphBW56y7a8+qTPyiw1ml2w6fVaCqpRoiTxS+07nQwZpt1PE+UUx3ME34OYHxPs9VIXTF9yqvW/G+XXudEpLvZ6n1rXhTV5Iv1Ha7Nr2+MhxmHSm8dTB362Pen+SECtuEhxVsHRzdWO1khRV/7drNftW5k7Szkitr+xNeOr7RzVGf7db607W7u79beyb5aBqPqfh+pbUOB13718gAT7qYdxJ4DPnKdU5ZjWeQ/QztcuefZzEcGApm0mD0DeRFnvuJn/iJuxdffPEiL7KOfvzjH7976aWXLkYpPJ3waOIeOWRQTinf+MY3Lus8CiX1sA7zYUMM4xKeTcig4JI2/Z34FU5PFMvNocxxYwLi9CQATiMjNGxQ0kvJNs1/wrce+dSPHqIhSThdJ6t3kHD7rVHBdzPXVT5fjUOrDa/8XY0fnYeSeEql2zar4Uk4hBf9MU8qk5YqLP7XgJBGIEoezc4YmhaFokEOukQ3pX6NJuBd73NPXKMuQyh5Jz2pEucJq3jN/FLZz46XZMhdepr5sW5z81hXGkqV65M+0pmC/hq9Y5v0TzoThzVCw29pQHxL+859vXbEh0ZenpEPaBDCIMxcxqj0mc985jL2Gmb09GEu6Fkl30nayuvqiya3Fi8ameEtGn8yvKxuKn1/RGhJMxrnchOz5lLVwGxoridsa2DKMaxra73e5Wmtc4ai4coxoX1w4Al6eWLlU/NY8tsjNNlBwGCkxxIAAZxxribZklD4MPC6WZn4WKTQUQw4zz333KUN6uNZrPMZD+kk6JjlidCU/cpjANPTRddUCpPLwTdBoNZJDWOTMHsCU0cMq2dP+rUSNFdtTAtE136nEEzPdwJkhQv8ouCzsGsdh9ChGWhAK3nXX5mCjDN3HNz56TwVpr6cKomTwLrC76RMToJ2vb5SLia4s6zgnOquAkJtk+vJ7Jgf7iopEDGmGEJYpPIYUZmsSdfZoTSpIu0i4KUBynbrgrtSxOpccKE1xwGLmAKiuwd4U05u4avSjXEu9vynDQVD+Qr48bSWqrykMJZ1ga/XQ6mCo+WU71lHHdMqxJ7MsVNYJziyrJS6lULc9WMFw650/Dzv5feqXyueVudH17a/V/Oiq2/qi89PPOu+inFdW6b2r6HVXT/uC/NuXVxd7/haPnNCd9O4Tev4NG5dmwnfRL8dPnZyRtfv1VrcyUG7UmGY6LKuSav3aj9X16cx7OruaHHFf552cb1COWStz9yCKuMmudWbwLwtnsKGF5JyIGs2z7BG4xHNO8gV6Aus3Z///OcvBoGPfvSjdz/90z9998UvfvGRB4KeSB/4wAcudSBfeLIvhifkfRRY6uUaxicMTMiiaahRhjBvCbqAqQFUzNI4otEgUzXoBW4OKO6xsYYsQF+VpVJe8tQtN9yVI6oclLSYXkcJfw19U69KeS5PDpOO0gBlm7aTcFTDSMoxPlPnZ8JblXj7C870UFLx14jgpp35bHgnjWVuNGuAQ/Yzr5XJ0g1n0uOJut1s7DarpVmPlncslX3FS+JUPGZfu3HIvlc+n6GMFI1c9tm6qmFHA04aQbPOPAWOucYz0Dd9pE/QJ2158p71pqd/pS/hsm7bdEykOU8y03vI0/PYmAYG5iNjTz08Y3vmmtX2oDxNMc+W3k+869jYZz3VNAil4U64kh6/7zW9k/fSESI9xKqeojeb+g5znb57cBn6CHB5Il/qPYZ4pieg42v90kN6gSUtyQMt/NczzQ11npt07QcxLNXF04Fn0LHoY/nXcKTiiLGJQWRAIQKPB9RAYDb8ZHoSHc/i3YDLqrsUItmB0H1NbyaZQ07IE2HA/4bdGG/ogkabelalUcnnPPHLeMl08Z0Eryzd9dPFf1VvV/eJIHXfZyZYJoGqE1i9Bm4xWLoD5cRl3BVCpmz1MldoQ1px8XBHqNLcaVmNSyd8nyh417STi7EGTXc96klztd1svy7gnQB/Kux2RcbmouUuEPOoJo5TuNOTCSEOozLXfJ/+6Wo8KauTQjrhs9Kbczt3JDQy4V3pIlHxVQX5ToBPWN31oa/uDthXF30XtEnR7hLPV8HraZdJ+Z3wkO90Y1rHrBNeH1dxr3XV+yf3vN/Np5P53imF9ffUl0p7O+Fzgn9aH7vrHb1Pz034yeurubm7dk2Z1qDp3mrd2l3b0fmq/pMyyRUTHCteXcd6oqeuvlPaXq2DO/hX8Hbvrd7JdzuD6Aqf0xiu4O3k5mvkjV3p5tXUzuPMnYcsyGHmZMRwg0KFjGbuxkxVoIJDQWZg3UTxMhk3z7A2f+UrX7msD2xekQbh7/ydv3MJbzNZ73ve857LqXDc49Rc5QqNWh/5yEcetUf9rMkYcwjZRwehsFaTm0nDQtU3kCF4hjbzYJP0PFIhzfxKbsSrDxlyRB30NxX/Gm6kd5Ub+dVbpEuwnXSROlKdV91a1IWaUvR6SceBqn91m0IaATRO1dCt7EtVou0beNMbSBhsy3AtDW4Zfpa/fdaxSo917rtZzbdhjEapGGZoyCZ1GVapUcKTykzP4RhXPGtwEdY0OuVc1wgrDr3Px3mR45IlcZNJn9PjSNwKP22oazNnNd7yH9y7OZqnjDlWjp36AHV5oJBGOa7VkxD1huIZI6EyvQ6GXgzMzjU+wCPu9aLiOs/qLQbf0aCUcyqNktKd+bSkhzTMJO7f8NqcZv4DK204ttad+EhvOeDFhmKSf51surBFvjW8Ob4Jf877NOTat0pr0ocRGXrnaaSd9MnHNix1TCYJESKD8UpcaRUGwdyH8XPcOYTIc4bJ1XAa69ViyPsao6iPQaMtvBh0FWXgMVrRBkQmIVQlZFpUO2E4XeQMv/K4PpV5J8gFoa8xFBeJWn8V4Ct+J2FjGtBOOK9jVdteCXi7korDJLT5zDV90OjD7ww18p4hbbkjYn4r3V5rP520Gh0zgz6TRUY0hdJNpRvHnQCe79Z6UvjrlKuV4pB40LBEf5hX7szsxrpTDieBubt3olzkM8n8NBQzv/FIZExeeeWVS19IwkluA49hZe5pEGQhqoLQRHerUgWvpDd3F4FPHLuzoHHZ/la339r3Dg/Cq2Hden3eY1AZy5VXXdbtwu1i9izLxAMqDiiTAFnv1zlyoqxaThS5TtitimjXTs7f+p1heqv1Z4Ll9JkdHk6Uy/rsbt3s+tS9M9VbYZ3g7fjefct9aKPjhxNuTnhhhWcF2wr2Exqt7e7qn2Ds+L7P7tb7k7l3As/EE7r3kh+u+MWEj2tkmNPS8b7dc7v7u7Wv0khe9/1nVTAkEdbOGqcSpdcD667hFyqHCTvPIi9g4NGQoOxIPhX0DD7f+ta3HiXlpj3C3dioxlhkHiRzrQAHYXIYojAkKWdQP88ia2qcQWYhpJ/yhS984dHazQddpx4fr7xDUbn2OvIG9ank5tgot9o3DVRpbFD508vGk4etJw0Ptl29rLKk10PdwPM755Z1d2uMBglKHjmvfK4clfNUpwQNDNYtLDVUL71GxIm6W+azyQ1OaShPNMtcSLbFcxqSDGXS8MS7jDHPaUxIXmUdNfG3xkI98uoBLbapp5Fjn+ORxknfyVPFxFH9XXGuMSQTkIsPxykNTXq3IGNyzxPODA0UTt/TwGS9tm3f+NZgbDSTsOoJRTEdBno/ug3zDZh9HxxxTS8h7QbiW9rAPgDsGI31ZMp8Wz7nf+lG2MWx4a3ScY7773/NKGPetRy3mu9WPGEUxnMTeMjnpv7Gf/mg8yhD0pK/p36cxsykKZ9N+0TmtZI+9N7ykLX6zqp836uPu1Leyq3cyq3cyq3cyq3cyq3cyq3cyq3cyq3cyv8vy7ONl7iVW7mVW7mVW7mVW7mVW7mVW7mVW7mVW7mV/23LzbB0K7dyK7dyK7dyK7dyK7dyK7dyK7dyK7dyK/cqN8PSrdzKrdzKrdzKrdzKrdzKrdzKrdzKrdzKrdyr3AxLt3Irt3Irt3Irt3Irt3Irt3Irt3Irt3Irt3KvcjMs3cqt3Mqt3Mqt3Mqt3Mqt3Mqt3Mqt3Mqt3Mq9ys2wdCu3ciu3ciu3ciu3ciu3ciu3ciu3ciu3civ3KjfD0q3cyq3cyq3cyq3cyq3cyq3cyq3cyq3cyq3cq9wMS7dyK7dyK7dyK7dyK7dyK7dyK7dyK7dyK7dyr3IzLN3KrdzKrdzKrdzKrdzKrdzKrdzKrdzKrdzK3X3K/wst3PyaS68s+QAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -1383,6 +1261,7 @@ } ], "source": [ + "# show the originals\n", "show_images_from_lance(\n", " db_path=LANCE_DIR,\n", " table_name=\"images\",\n", @@ -1390,20 +1269,21 @@ " max_images=4,\n", " pick=\"first\",\n", " cmap=\"gray\",\n", + " cols=1,\n", ")" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "id": "d059d02c-9789-440e-8708-7eb04dbe3b38", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -1411,6 +1291,7 @@ } ], "source": [ + "# show the masks\n", "show_images_from_lance(\n", " db_path=LANCE_DIR,\n", " table_name=\"images\",\n", @@ -1420,6 +1301,38 @@ " cmap=\"gray\",\n", " vmin=0,\n", " vmax=1,\n", + " cols=1,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "fd8301f6-289e-4f7f-8163-c6b0c7eeaa8b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# show the crops\n", + "show_images_from_lance(\n", + " db_path=LANCE_DIR,\n", + " table_name=\"compartment_nuclei\",\n", + " col_name=\"ome-arrow_crop\",\n", + " max_images=20,\n", + " pick=\"first\",\n", + " cmap=\"gray\",\n", + " base_size=1,\n", + " cols=1,\n", ")" ] } diff --git a/src/serpula_rasa/example.py b/src/serpula_rasa/example.py index a035b55..4835a04 100644 --- a/src/serpula_rasa/example.py +++ b/src/serpula_rasa/example.py @@ -37,21 +37,19 @@ from pathlib import Path from pprint import pp from shutil import copy2, copytree -from typing import Dict, List, Tuple +from typing import Any, Dict, List, Optional, Tuple import cellpose import imageio.v3 as iio import lancedb -import matplotlib.pyplot as plt import numpy as np import pandas as pd import pyarrow as pa from cellpose import models as cp_models from serpula_rasa.image import ( - ensure_ome_arrow_column, - ingest_ome_images_ome_arrow, make_ome_arrow_row, + reconstruct_tczyx_from_record, show_images_from_lance, ) from serpula_rasa.meta import OME_ARROW_SCHEMA @@ -245,7 +243,7 @@ def cellpose_eval( return masks, diam_scalar -def gather_profiles() -> None: # noqa: PLR0915, C901 +def gather_profiles() -> None: # noqa: PLR0915, C901, PLR0912 # Connect LanceDB + ensure log table db = lancedb.connect(str(LANCE_DIR)) ensure_log_table(db, TABLE_LOG) @@ -260,13 +258,13 @@ def gather_profiles() -> None: # noqa: PLR0915, C901 raise SystemExit(f"No images found under: {IMAGES_DIR.resolve()}") # --- We will build both struct columns in the same index order --- - rows_combined = ( - [] - ) # each item will be {"ome-arrow_original": {...}, "ome-arrow_mask": {...}|None} + rows_combined = [] # each item will be: + # {"ome-arrow_original": {...}, "ome-arrow_mask": {...}|None} for img_path in images: try: - # Load image (keep dtype); if multichannel HWC, pick channel 0 for demo parity + # Load image (keep dtype); + # if multichannel HWC, pick channel 0 for demo parity img = iio.imread(img_path) if img.ndim == 3 and img.shape[-1] in (2, 3, 4): nuc_img = img[..., 0] @@ -305,6 +303,7 @@ def gather_profiles() -> None: # noqa: PLR0915, C901 # Collect a single row with both structs (aligned by index) rows_combined.append( { + "image_filename": img_path.name, "ome-arrow_original": img_struct["ome-arrow_original"], "ome-arrow_mask": mask_struct["ome-arrow_mask"], } @@ -378,13 +377,15 @@ def gather_profiles() -> None: # noqa: PLR0915, C901 print(f"✓ {img_path.name}: {n_obj} objects") except Exception as ex: - # If segmentation or anything else fails, still store original image row with mask=None + # If segmentation or anything else fails, + # still store original image row with mask=None try: if "img_struct" in locals(): rows_combined.append( { "ome-arrow_original": img_struct["ome-arrow_original"], - "ome-arrow_mask": None, # nullable struct column will accept None + # nullable struct column will accept None + "ome-arrow_mask": None, } ) except Exception: @@ -401,30 +402,174 @@ def gather_profiles() -> None: # noqa: PLR0915, C901 ) print(f"✗ {img_path.name}: {ex}") - # ---------- Materialize a two-column Arrow table (index-aligned) ---------- - # Reuse the canonical ome-arrow struct type for both columns. + # ---------- Materialize a table with both structs + filename ---------- struct_type = OME_ARROW_SCHEMA.field(0).type - schema_two_cols = pa.schema( + schema_three_cols = pa.schema( [ - pa.field("ome-arrow_original", struct_type), # nullable defaults to True + pa.field("image_filename", pa.string()), # top-level column + pa.field("ome-arrow_original", struct_type), pa.field("ome-arrow_mask", struct_type), ] ) - arrow_tbl = pa.Table.from_pylist(rows_combined, schema=schema_two_cols) - # ---------- Create/replace Lance table with both columns ---------- + # Each row now carries filename + both struct values + arrow_tbl = pa.Table.from_pylist(rows_combined, schema=schema_three_cols) + + # ---------- Create/replace Lance table ---------- if TABLE_IMAGES in set(db.table_names()): db.drop_table(TABLE_IMAGES) img_tbl = db.create_table(TABLE_IMAGES, data=arrow_tbl) print(f"[ome-arrow] stored {img_tbl.count_rows()} row(s) in Lance (images + masks)") +def add_ome_crops_to_nuclei_table( # noqa: PLR0913 + *, + db_path: Path, + images_table: str = "images", + nuclei_table: str = "compartment_nuclei", + image_struct_col: str = "ome-arrow_original", # where the full image sits + out_crop_col: str = "ome-arrow_crop", # new struct column to add + image_col: str = "filename", # top-level filename in images table + nuclei_col: str = "image_filename", # column in nuclei table + bbox_min_x: str = "BoundingBoxMinimum_X", + bbox_max_x: str = "BoundingBoxMaximum_X", + bbox_min_y: str = "BoundingBoxMinimum_Y", + bbox_max_y: str = "BoundingBoxMaximum_Y", + pad: int = 0, # optional padding (pixels) around the bbox + clamp_to_image: bool = True, + prefer_dimension_order_xyzct: bool = False, # 2D → "XYCT" hint +) -> lancedb.table.LanceTable: + """ + For each nucleus row with a bounding box, create an ome-arrow crop from the + corresponding source image and add it as a new struct column to the nuclei table. + Re-creates the nuclei table with an appended column in one shot. + + Requirements: + - The images table has one row per image and includes: + • a top-level string column `image_col` (e.g., 'filename') + • a struct column `image_struct_col` (e.g., 'ome-arrow_original') + - The nuclei table has per-object rows with: + • `nuclei_col` pointing to the source image filename + • bounding box columns (min/max X/Y) in pixel coordinates + + Returns + ------- + LanceTable + The (re)created nuclei table with an extra ome-arrow crop column. + """ + db = lancedb.connect(str(db_path)) + + # ---------- 1) Load images table: build a lookup by filename ---------- + img_tbl = db.open_table(images_table) + imgs_arrow = img_tbl.to_arrow() # whole table + # Select only what we need + imgs_arrow = imgs_arrow.select([image_col, image_struct_col]) + + # Build filename -> ome-arrow record mapping + image_by_name: Dict[str, Dict[str, Any]] = {} + for i in range(len(imgs_arrow)): + fname = imgs_arrow[image_col][i].as_py() + rec = imgs_arrow[image_struct_col][i].as_py() + image_by_name[fname] = rec + + # ---------- 2) Load nuclei table ---------- + nuc_tbl = db.open_table(nuclei_table) + nuc_arrow = nuc_tbl.to_arrow() # keep all columns (we'll append one) + + # ---------- 3) Create crop structs aligned by row index ---------- + struct_type = OME_ARROW_SCHEMA.field(0).type # reuse canonical struct type + crops: List[Optional[Dict[str, Any]]] = [] + + for i in range(len(nuc_arrow)): + row = nuc_arrow.slice(i, 1) + # Read filename & bbox for this nucleus + fname = row[nuclei_col][0].as_py() + xmin = row[bbox_min_x][0].as_py() + xmax = row[bbox_max_x][0].as_py() + ymin = row[bbox_min_y][0].as_py() + ymax = row[bbox_max_y][0].as_py() + + # Missing filename or image? → no crop + src = image_by_name.get(fname) + if src is None: + crops.append(None) + continue + + # Reconstruct (T,C,Z,Y,X). + # Our images are typically 2D single-channel → (1,1,1,Y,X) + arr = reconstruct_tczyx_from_record(src) + slab = arr[0, 0] # (Z, Y, X) or (1, Y, X) + + # If you have Z-stacks, pick a policy; here take z=0 + plane = slab[0] + + H, W = plane.shape[0], plane.shape[1] + + # Convert bbox to ints and pad + x0 = int(np.floor(xmin)) - pad + x1 = int(np.ceil(xmax)) + pad + y0 = int(np.floor(ymin)) - pad + y1 = int(np.ceil(ymax)) + pad + + if clamp_to_image: + x0 = max(0, x0) + y0 = max(0, y0) + x1 = min(W, x1) + y1 = min(H, y1) + + # Validate bbox + if x1 <= x0 or y1 <= y0: + crops.append(None) + continue + + crop = plane[y0:y1, x0:x1] # (h, w), numeric + + # Build the ome-arrow struct for the crop + # Use the nucleus row index or a composite for uniqueness + crop_id = f"{fname}__row{i}" + crop_struct = make_ome_arrow_row( + image_id=crop_id, + col_name=out_crop_col, + name=f"{fname} [y{x0}:{x1}, x{y0}:{y1}]", + pixels=crop, + physical_size_xy_um=src["pixels_meta"]["physical_size_x"], + physical_size_z_um=src["pixels_meta"]["physical_size_z"], + physical_unit=src["pixels_meta"]["physical_size_x_unit"], + prefer_dimension_order_xyzct=prefer_dimension_order_xyzct, + acquisition_dt=datetime.now(timezone.utc), + ) + crops.append(crop_struct[out_crop_col]) + + # ---------- 4) Append the new struct column and (re)create Lance table ---------- + crop_array = pa.array(crops, type=struct_type) # nullable ok + new_nuc_arrow = nuc_arrow.append_column(out_crop_col, crop_array) + + # Recreate the table atomically (simple & robust) + if nuclei_table in set(db.table_names()): + db.drop_table(nuclei_table) + new_tbl = db.create_table(nuclei_table, data=new_nuc_arrow) + + return new_tbl + + # - # %%time # run the pipeline and show the time duration gather_profiles() +# %%time +# add nuclei object image crops as ome-arrow images +_ = add_ome_crops_to_nuclei_table( + db_path=LANCE_DIR, + images_table=TABLE_IMAGES, # your images table + nuclei_table=TABLE_FEATURES, # if your nuclei/objects live here + image_struct_col="ome-arrow_original", # the source image struct + out_crop_col="ome-arrow_crop", # new column to add + image_col="image_filename", # in images table + nuclei_col="image_filename", # in nuclei table +) + db = lancedb.connect(LANCE_DIR) db.table_names() @@ -434,11 +579,10 @@ def gather_profiles() -> None: # noqa: PLR0915, C901 # show nuclei features db.open_table("compartment_nuclei").to_pandas() -db.open_table("compartment_nuclei").to_pandas().iloc[0].to_dict() - # show the images table db.open_table("images").to_pandas() +# show the originals show_images_from_lance( db_path=LANCE_DIR, table_name="images", @@ -446,8 +590,10 @@ def gather_profiles() -> None: # noqa: PLR0915, C901 max_images=4, pick="first", cmap="gray", + cols=1, ) +# show the masks show_images_from_lance( db_path=LANCE_DIR, table_name="images", @@ -457,4 +603,17 @@ def gather_profiles() -> None: # noqa: PLR0915, C901 cmap="gray", vmin=0, vmax=1, + cols=1, +) + +# show the crops +show_images_from_lance( + db_path=LANCE_DIR, + table_name="compartment_nuclei", + col_name="ome-arrow_crop", + max_images=20, + pick="first", + cmap="gray", + base_size=1, + cols=1, ) diff --git a/src/serpula_rasa/image.py b/src/serpula_rasa/image.py index 03d7c23..b0c50b0 100644 --- a/src/serpula_rasa/image.py +++ b/src/serpula_rasa/image.py @@ -3,27 +3,35 @@ """ from __future__ import annotations -import imageio.v3 as iio -from typing import Literal + +import contextlib +import math +import pathlib from dataclasses import dataclass from datetime import datetime, timezone -import pathlib -from typing import Iterable, List, Mapping, Optional, Sequence, Tuple +from typing import Any, Iterable, List, Literal, Mapping, Optional, Sequence, Tuple -from matplotlib import pyplot as plt -import tifffile as tiff -import numpy as np +import imageio.v3 as iio import lancedb -from typing import Mapping, Any import numpy as np import pyarrow as pa import pyarrow.parquet as pq +import tifffile as tiff +from matplotlib import pyplot as plt + +from serpula_rasa.meta import ( + OME_ARROW_SCHEMA, + OME_ARROW_TAG_TYPE, + OME_ARROW_TAG_VERSION, + OME_DTYPE_MAP, + ome_arrow_schema, +) -from serpula_rasa.meta import OME_ARROW_SCHEMA, OME_DTYPE_MAP, OME_ARROW_TAG_TYPE, OME_ARROW_TAG_VERSION, ome_arrow_schema @dataclass class ChannelMeta: """Minimal, practical channel metadata for profiling workflows.""" + id: str name: str emission_um: Optional[float] = None @@ -31,9 +39,11 @@ class ChannelMeta: illumination: Optional[str] = None color_rgba: Optional[int] = None # preferred display color (packed RGBA) + def _default_channels(C: int) -> List[ChannelMeta]: return [ChannelMeta(id=f"C{c}", name=f"Channel-{c}") for c in range(C)] + def _normalize_to_TCZYX(arr: np.ndarray) -> Tuple[int, int, int, int, int, np.ndarray]: """ Accept common shapes and normalize to (T, C, Z, Y, X). @@ -42,34 +52,40 @@ def _normalize_to_TCZYX(arr: np.ndarray) -> Tuple[int, int, int, int, int, np.nd • For 3D, small first dim (<=8) ⇒ channels; otherwise z-slices. • For 4D, if last two look spatial and the 2nd dim small (<=8) ⇒ (T,C,Y,X). """ - if arr.ndim == 2: # (Y, X) + # (Y, X) + if arr.ndim == 2: Y, X = arr.shape return (1, 1, 1, Y, X, arr[None, None, None, :, :]) if arr.ndim == 3: a, b, c = arr.shape - if a <= 8: # (C, Y, X) + # (C, Y, X) + if a <= 8: C, Y, X = a, b, c return (1, C, 1, Y, X, arr[None, :, None, :, :]) - else: # (Z, Y, X) + # (Z, Y, X) + else: Z, Y, X = a, b, c return (1, 1, Z, Y, X, arr[None, None, :, :, :]) if arr.ndim == 4: A, B, C_, D_ = arr.shape - if C_ > 16 and D_ > 16 and B <= 8: # (T, C, Y, X) + # (T, C, Y, X) + if C_ > 16 and D_ > 16 and B <= 8: T, C, Y, X = A, B, C_, D_ return (T, C, 1, Y, X, arr[:, :, None, :, :]) # (C, Z, Y, X) C, Z, Y, X = A, B, C_, D_ return (1, C, Z, Y, X, arr[None, :, :, :, :]) - if arr.ndim == 5: # (T, C, Z, Y, X) + # (T, C, Z, Y, X) + if arr.ndim == 5: T, C, Z, Y, X = arr.shape return (T, C, Z, Y, X, arr) raise ValueError("Expected (Y,X),(C,Y,X),(Z,Y,X),(C,Z,Y,X),(T,C,Y,X),(T,C,Z,Y,X).") + def _coerce_pixel_dtype(arr5: np.ndarray) -> Tuple[np.ndarray, str]: """Keep numeric pixels in a widely-supported dtype; default to uint16.""" dt = arr5.dtype @@ -83,15 +99,15 @@ def _coerce_pixel_dtype(arr5: np.ndarray) -> Tuple[np.ndarray, str]: return arr5, OME_DTYPE_MAP[np.dtype(dt)] -def make_ome_arrow_row( +def make_ome_arrow_row( # noqa: PLR0913 *, image_id: str, col_name: str = "ome_arrow", name: str, - pixels: np.ndarray, # XY or XYZ (+ optional C/T) + pixels: np.ndarray, # XY or XYZ (+ optional C/T) channel_meta: Optional[Sequence[ChannelMeta]] = None, - physical_size_xy_um: float = 0.108, # microscope pixel size (µm/px) - physical_size_z_um: float = 1.0, # z-step (µm) + physical_size_xy_um: float = 0.108, # microscope pixel size (µm/px) + physical_size_z_um: float = 1.0, # z-step (µm) physical_unit: str = "µm", prefer_dimension_order_xyzct: bool = True, # if Z==1 and False → "XYCT" acquisition_dt: Optional[datetime] = None, @@ -130,18 +146,23 @@ def make_ome_arrow_row( for c in range(C): for z in range(Z): plane = arr5[t, c, z] # (Y, X) - planes.append({ - "z": z, - "t": t, - "c": c, - "pixels": plane.reshape(-1).astype(np.uint16).tolist(), - }) + planes.append( + { + "z": z, + "t": t, + "c": c, + "pixels": plane.reshape(-1).astype(np.uint16).tolist(), + } + ) pixels_meta = { "dimension_order": dimension_order, "type": pixel_type_str, - "size_x": int(X), "size_y": int(Y), "size_z": int(Z), - "size_c": int(C), "size_t": int(T), + "size_x": int(X), + "size_y": int(Y), + "size_z": int(Z), + "size_c": int(C), + "size_t": int(T), "physical_size_x": float(physical_size_xy_um), "physical_size_y": float(physical_size_xy_um), "physical_size_z": float(physical_size_z_um), @@ -169,7 +190,9 @@ def validate_ome_arrow_table(table: pa.Table, *, col_name: str = "ome_arrow") -> """Validate schema + tags for the chosen column name.""" expected = ome_arrow_schema(col_name) if table.schema.types != expected.types or table.schema.names != expected.names: - raise ValueError(f"Schema mismatch: table does not match ome_arrow_schema({col_name!r}).") + raise ValueError( + f"Schema mismatch: table does not match ome_arrow_schema({col_name!r})." + ) col = table[col_name] for i in range(len(col)): rec = col[i].as_py() @@ -197,13 +220,14 @@ def write_ome_arrow_parquet( ) -def read_ome_arrow_first(path: str, *, col_name: str = "ome_arrow") -> Mapping[str, object]: +def read_ome_arrow_first( + path: str, *, col_name: str = "ome_arrow" +) -> Mapping[str, object]: tbl = pq.read_table(path, columns=[col_name]) validate_ome_arrow_table(tbl, col_name=col_name) return tbl[col_name][0].as_py() - def reconstruct_tczyx_from_record(rec: Mapping[str, Any]) -> np.ndarray: """ Reconstruct a 5D NumPy array (T, C, Z, Y, X) from an in-memory ome_arrow record. @@ -232,10 +256,10 @@ def reconstruct_tczyx_from_record(rec: Mapping[str, Any]) -> np.ndarray: Notes ----- - • For 2D single-channel images, the returned shape will be (1, 1, 1, Y, X). + • For 2D single-channel images, the returned shape will be (1, 1, 1, Y, X). • The dtype is fixed to ``np.uint16`` because pixel values are stored that way in ome-arrow by default. Adjust the coercion logic if you plan to allow - multiple numeric dtypes. + multiple numeric dtypes. • This function is useful outside of testing, e.g.: - Feeding the reconstructed array into scikit-image or napari - Exporting back to OME-TIFF or Zarr @@ -259,16 +283,22 @@ def reconstruct_tczyx_from_record(rec: Mapping[str, Any]) -> np.ndarray: out[t, c, z] = np.asarray(pl["pixels"], dtype=np.uint16).reshape(Y, X) return out + def list_images(root: pathlib.Path) -> list[pathlib.Path]: """Find common image files recursively under `root`.""" exts = (".tif", ".tiff", ".png", ".jpg", ".jpeg") - return sorted([p for p in pathlib.Path(root).rglob("*") if p.suffix.lower() in exts]) + return sorted( + [p for p in pathlib.Path(root).rglob("*") if p.suffix.lower() in exts] + ) -def pa_table_from_ome_arrow_rows(rows: list[Mapping[str, Any]], *, col_name: str = "ome_arrow") -> pa.Table: +def pa_table_from_ome_arrow_rows( + rows: list[Mapping[str, Any]], *, col_name: str = "ome_arrow" +) -> pa.Table: """Create a PyArrow table for ome-arrow rows under a custom column name.""" return pa.Table.from_pylist(rows, schema=ome_arrow_schema(col_name)) + def _lance_get_or_create_arrow_table( db: lancedb.db.LanceDBConnection, table_name: str, @@ -285,8 +315,9 @@ def _lance_get_or_create_arrow_table( except Exception: db.drop_table(table_name) return db.create_table(table_name, schema=first_batch.schema) - -def ingest_ome_arrow_to_lance( + + +def ingest_ome_arrow_to_lance( # noqa: PLR0913 image_paths: Iterable[pathlib.Path], db_path: pathlib.Path, table_name: str = "ome_images", @@ -363,7 +394,8 @@ def _flush() -> None: assert lance_tbl is not None, "No images ingested; check `image_paths`." return lance_tbl -def show_images_from_lance( + +def show_images_from_lance( # noqa: PLR0913 db_path: pathlib.Path, table_name: str = "ome_images", col_name: str = "ome_arrow", @@ -373,6 +405,10 @@ def show_images_from_lance( cmap: str = "gray", vmin: Optional[float] = None, vmax: Optional[float] = None, + cols: int = 4, + base_size: float = 3.0, + row_scale: float = 1.0, + col_scale: float = 1.0, ) -> None: """ Display images stored as `ome_arrow` records in a LanceDB table. @@ -386,19 +422,24 @@ def show_images_from_lance( max_images : int Limit how many records to display. pick : {"first","center","maxproj"} - How to select a 2D plane for Z-stacks: - - "first" : z=0 - - "center" : z=Z//2 - - "maxproj": max projection along Z + How to select a 2D plane for Z-stacks. cmap : str Matplotlib colormap for grayscale display. + vmin, vmax : float, optional + Intensity scaling for display. + cols : int, default 4 + Number of subplot columns. + base_size : float, default 3.0 + Base scaling factor for each subplot. + row_scale : float, default 1.0 + Vertical scaling multiplier. + col_scale : float, default 1.0 + Horizontal scaling multiplier. """ - import math - from typing import Literal db = lancedb.connect(str(db_path)) tbl = db.open_table(table_name) - arr_tbl = tbl.to_arrow().select([col_name]) # <-- select by your name + arr_tbl = tbl.to_arrow().select([col_name]) records = [arr_tbl[col_name][i].as_py() for i in range(len(arr_tbl))] if not records: @@ -406,18 +447,21 @@ def show_images_from_lance( return n = min(max_images, len(records)) - cols = min(4, n) + cols = min(cols, n) rows = math.ceil(n / cols) - fig, axes = plt.subplots(rows, cols, figsize=(4 * cols, 4 * rows), squeeze=False) + + _, axes = plt.subplots( + rows, + cols, + figsize=(base_size * col_scale * cols, base_size * row_scale * rows), + squeeze=False, + ) for i, rec in enumerate(records[:n]): ax = axes[i // cols][i % cols] - arr = reconstruct_tczyx_from_record(rec) # (T,C,Z,Y,X) - - # show: first timepoint, first channel - img = arr[0, 0] # (Z,Y,X) or (1,Y,X) for 2D - - if img.shape[0] == 1: # Z==1 → plain 2D + arr = reconstruct_tczyx_from_record(rec) + img = arr[0, 0] + if img.shape[0] == 1: plane = img[0] else: Z = img.shape[0] @@ -427,23 +471,26 @@ def show_images_from_lance( plane = np.max(img, axis=0) else: plane = img[0] - ax.imshow(plane, cmap=cmap, vmin=vmin, vmax=vmax) ax.set_title(rec.get("name", f"record {i}")) ax.axis("off") - # Hide any leftover axes + # Hide unused axes for j in range(n, rows * cols): axes[j // cols][j % cols].axis("off") plt.tight_layout() plt.show() -def pa_table_from_ome_rows(rows: List[Mapping[str, Any]], col_name: str = "ome_arrow") -> pa.Table: + +def pa_table_from_ome_rows( + rows: List[Mapping[str, Any]], col_name: str = "ome_arrow" +) -> pa.Table: """Build a PyArrow Table from ome-arrow rows using the canonical schema.""" - return pa.Table.from_pylist(list(rows), schema=ome_arrow_schema(col_name)) + return pa.Table.from_pylist(list(rows), schema=ome_arrow_schema(col_name)) + -def ingest_ome_images_ome_arrow( +def ingest_ome_images_ome_arrow( # noqa: PLR0913 db: lancedb.db.LanceDBConnection, table_name: str, image_paths: Sequence[pathlib.Path], @@ -470,7 +517,7 @@ def _flush() -> None: batch = pa_table_from_ome_rows(rows=rows, col_name=col_name) if lance_tbl is None: lance_tbl = _lance_get_or_create_arrow_table(db, table_name, batch) - lance_tbl.add(batch) # write the batch once + lance_tbl.add(batch) # write the batch once rows = [] for p in image_paths: @@ -500,16 +547,18 @@ def _flush() -> None: _flush() if lance_tbl is None: - raise("No images ingested; check `image_paths`.") - + raise ("No images ingested; check `image_paths`.") + return lance_tbl + # --- small helper to declare a new ome-arrow column schema on the table --- def ensure_ome_arrow_column(tbl: lancedb.table.LanceTable, col_name: str) -> None: # Reuse the struct type from your canonical OME_ARROW_SCHEMA struct_type = OME_ARROW_SCHEMA.field(0).type - empty = pa.Table.from_pylist([], schema=pa.schema([pa.field(col_name, struct_type)])) - try: + empty = pa.Table.from_pylist( + [], schema=pa.schema([pa.field(col_name, struct_type)]) + ) + + with contextlib.suppress(Exception): tbl.add(empty) # extends schema without adding rows - except Exception: - pass # column probably exists already \ No newline at end of file diff --git a/src/serpula_rasa/meta.py b/src/serpula_rasa/meta.py index 6e4264c..1ddb2ac 100644 --- a/src/serpula_rasa/meta.py +++ b/src/serpula_rasa/meta.py @@ -46,14 +46,14 @@ pa.field("physical_size_x_unit", pa.string()), # usually "µm" pa.field("physical_size_y_unit", pa.string()), pa.field("physical_size_z_unit", pa.string()), - pa.field( "channels", pa.list_( # CHANNELS: one entry per channel (e.g., DNA, Mito, ER). - # - emission_um / excitation_um: wavelengths (micrometers) for context. + # - emission_um / excitation_um: wavelengths (micrometers). # - illumination: modality (e.g., "Epifluorescence"). - # - color_rgba: preferred display color (packed 0xRRGGBBAA). + # - color_rgba: preferred display color + # (packed 0xRRGGBBAA). pa.struct( [ pa.field("id", pa.string()), @@ -90,15 +90,17 @@ ] ) + def ome_arrow_schema(col_name: str = "ome_arrow") -> pa.Schema: """ Build a one-column Arrow schema for ome-arrow with a custom column name. Reuses the struct type from the canonical OME_ARROW_SCHEMA. """ struct_type = OME_ARROW_SCHEMA.field(0).type # reuse the canonical struct - + return pa.schema([pa.field(col_name, struct_type)]) + OME_ARROW_SCHEMA: pa.Schema = pa.schema([pa.field("ome_arrow", OME_ARROW_STRUCT)]) diff --git a/tests/conftest.py b/tests/conftest.py index b734810..77e6165 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -3,10 +3,12 @@ """ import pathlib + import pytest + @pytest.fixture def tmp_db(tmp_path: pathlib.Path) -> pathlib.Path: db_dir = tmp_path / "lance_db" db_dir.mkdir(parents=True, exist_ok=True) - return db_dir \ No newline at end of file + return db_dir diff --git a/tests/test_image.py b/tests/test_image.py index 806e116..e679480 100644 --- a/tests/test_image.py +++ b/tests/test_image.py @@ -2,24 +2,25 @@ Tests for ome-arrow work """ +from pathlib import Path + +import matplotlib import numpy as np -import tifffile as tiff import pyarrow.parquet as pq import pytest -import matplotlib - import tifffile as tiff # import your ome-arrow helpers/globals from serpula_rasa.image import ( + ingest_ome_arrow_to_lance, make_ome_arrow_row, - write_ome_arrow_parquet, - validate_ome_arrow_table, reconstruct_tczyx_from_record, - ingest_ome_arrow_to_lance, show_images_from_lance, + validate_ome_arrow_table, + write_ome_arrow_parquet, ) from serpula_rasa.meta import OME_ARROW_TAG_TYPE, OME_ARROW_TAG_VERSION +from tests.utils import write_synth_tiff matplotlib.use("Agg") @@ -35,7 +36,9 @@ def test_ome_arrow_roundtrip_from_2d_tiff(tmp_path, shape, dtype): 5) reconstruct array and compare with source """ # 1) synthesize and save a 2D TIFF - src = (np.arange(shape[0] * shape[1], dtype=np.uint32) % np.iinfo(dtype).max).astype(dtype) + src = ( + np.arange(shape[0] * shape[1], dtype=np.uint32) % np.iinfo(dtype).max + ).astype(dtype) src = src.reshape(shape) # (Y, X) tiff_path = tmp_path / "img.tif" tiff.imwrite(tiff_path, src) @@ -48,7 +51,7 @@ def test_ome_arrow_roundtrip_from_2d_tiff(tmp_path, shape, dtype): image_id="img_0001", col_name="ome_arrow", name="2D TIFF example", - pixels=img, # accepts (Y, X) + pixels=img, # accepts (Y, X) physical_size_xy_um=0.108, physical_size_z_um=1.0, physical_unit="µm", @@ -89,15 +92,8 @@ def test_ome_arrow_roundtrip_from_2d_tiff(tmp_path, shape, dtype): assert float(recon.mean()) == pytest.approx(float(src.mean())) assert float(recon.max()) == float(src.max()) -# test_ome_arrow_lance_ingest.py -import os -import sys -from pathlib import Path - -import numpy as np -import pytest -from tests.utils import write_synth_tiff +# test_ome_arrow_lance_ingest.py def test_ingest_ome_arrow_to_lance_roundtrip(tmp_db: Path, tmp_path: Path): @@ -110,7 +106,7 @@ def test_ingest_ome_arrow_to_lance_roundtrip(tmp_db: Path, tmp_path: Path): image_paths=[tmp_path / "a.tif", tmp_path / "b.tif"], db_path=tmp_db, table_name="ome_images", - prefer_dimension_order_xyzct=False, # 2D → "XYCT" hint + prefer_dimension_order_xyzct=False, # 2D → "XYCT" hint batch_size=2, ) @@ -144,6 +140,7 @@ def test_ingest_ome_arrow_to_lance_roundtrip(tmp_db: Path, tmp_path: Path): assert rec["type"] == OME_ARROW_TAG_TYPE assert rec["version"] == OME_ARROW_TAG_VERSION + def test_show_images_from_lance_smoke(tmp_db: Path, tmp_path: Path): """ Smoke-test the visualization helper. We don't assert on plots; we just diff --git a/tests/utils.py b/tests/utils.py index c5e0d88..247ff20 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -3,12 +3,16 @@ """ import pathlib + import numpy as np import tifffile as tiff + def write_synth_tiff(path: pathlib.Path, shape=(64, 96), dtype=np.uint16) -> np.ndarray: """Create and save a simple ramp image; return the array used.""" - arr = (np.arange(shape[0] * shape[1], dtype=np.uint32) % np.iinfo(dtype).max).astype(dtype) + arr = ( + np.arange(shape[0] * shape[1], dtype=np.uint32) % np.iinfo(dtype).max + ).astype(dtype) arr = arr.reshape(shape) tiff.imwrite(str(path), arr) - return arr \ No newline at end of file + return arr