diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 7f3f6c9..cde8d0d 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -16,7 +16,7 @@ jobs: strategy: fail-fast: false matrix: - python-version: ["3.10", "3.11", "3.12"] + python-version: ["3.12", "3.13", "3.14"] steps: - uses: actions/checkout@v3 diff --git a/.gitignore b/.gitignore index 0d9f2d4..1a0e4b6 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,6 @@ testdata/ site/ +examples/outputs/ # Byte-compiled / optimized / DLL files __pycache__/ @@ -162,5 +163,8 @@ cython_debug/ # option (not recommended) you can uncomment the following to ignore the entire idea folder. .idea/ +# Visual Studio Code +.vscode/ + # Downloaded assets docs/assets/downloaded/ diff --git a/CHANGES.md b/CHANGES.md index 9ec8be5..5d7f5d6 100644 --- a/CHANGES.md +++ b/CHANGES.md @@ -1,5 +1,7 @@ ## Version 0.8.1 (in development) +* Migrated to the Zarr v3 Python API. Supports writing Zarr v2 and v3 stores, + with Zarr v2 as the default. (#111) * Replaced dev tools black and flake8 by isort and ruff. * Reformatted code and fixed linter issues. * Added `environment.yml` to setup a conda/mamba development environment. diff --git a/README.md b/README.md index a918380..db04ba2 100644 --- a/README.md +++ b/README.md @@ -28,7 +28,8 @@ awesome Python packages [xarray](https://docs.xarray.dev/) and [zarr](https://za The objective of `zappend` is enabling geodata scientists and developers to robustly create large data cubes. The tool performs transaction-based dataset appends to existing data cubes in the -[Zarr format](https://zarr.readthedocs.io/en/stable/spec/v2.html). If an error +[Zarr format](https://zarr.readthedocs.io/en/stable/). Targets use Zarr v2 by +default and may opt into Zarr v3. If an error occurs during an append step — typically due to I/O problems or out-of-memory conditions — `zappend` will automatically roll back the operation, ensuring that the existing data cube maintains its structural integrity. The design drivers diff --git a/docs/config.md b/docs/config.md index c1f6baa..39472d3 100644 --- a/docs/config.md +++ b/docs/config.md @@ -76,6 +76,10 @@ Variable metadata. Its value is `null`. - Disable chunking in all dimensions. Its value is `null`. + - `shards`: + Zarr v3 shard sizes for each dimension of the variable. Each shard size + must be a multiple of the corresponding chunk size. The items of the + list are positive integers. - `fill_value`: Must be one of the following: - Type _number_. @@ -134,8 +138,7 @@ Defaults to `"keep"`. ### `zarr_version` -The Zarr version to be used. -Its value is `2`. +The Zarr version to be used. Allowed values are `2` and `3`. Defaults to `2`. ## Data I/O - Target diff --git a/docs/guide.md b/docs/guide.md index 96ee3e0..c8a5fcf 100644 --- a/docs/guide.md +++ b/docs/guide.md @@ -31,10 +31,11 @@ one, if their paths are given as URIs prefixed with a filesystem protocol such a dedicated configuration settings. More on this is given in section [_Data I/O_](#data-io) below. -!!! note "Zarr Format v2" +!!! note "Zarr formats" By default, `zappend` uses the [Zarr storage specification 2](https://zarr.readthedocs.io/en/stable/spec/v2.html) - and has only been tested with this version. The `zarr_version` setting can be used - to change it, e,g, to `3`, but any other value than `2` is currently unsupported. + for compatibility with existing clients. Set `zarr_version` to `3` to write + Zarr v3. The target's format is fixed when it is created; use the same + setting for all later appends. The tool takes care of generating the target dataset from slice datasets, but doesn't care how the slice datasets are created. Hence, when using the Python `zappend()` @@ -336,6 +337,26 @@ using the `chunks` setting in the encoding of each variable. The value of `chunks` can also be `null`, which means no chunking is desired and the variable's data array will be persisted as one block. +For Zarr v3, `shards` may additionally be configured for a variable. A shard +contains an integer number of regular chunks, reducing object counts while +retaining smaller read/write chunks. Each shard size must be at least its +corresponding chunk size and an exact multiple of it. Shards are not available +for Zarr v2. + +```json +{ + "zarr_version": 3, + "variables": { + "chl": { + "encoding": { + "chunks": [1, 512, 512], + "shards": [8, 2048, 2048] + } + } + } +} +``` + By default, the chunking of the coordinate variable corresponding to the append dimension will be its dimension size in the first slice dataset. Often, the size will be `1` or another small number. Since `xarray` loads coordinates eagerly diff --git a/docs/index.md b/docs/index.md index a996720..76c0c03 100644 --- a/docs/index.md +++ b/docs/index.md @@ -11,7 +11,8 @@ awesome Python packages [xarray](https://docs.xarray.dev/) and [zarr](https://za The objective of `zappend` is enabling geodata scientists and developers to robustly create large data cubes. The tool performs transaction-based dataset appends to existing data cubes in the -[Zarr format](https://zarr.readthedocs.io/en/stable/spec/v2.html). If an error +[Zarr format](https://zarr.readthedocs.io/en/stable/). Targets use Zarr v2 by +default and may opt into Zarr v3. If an error occurs during an append step — typically due to I/O problems or out-of-memory conditions — `zappend` will automatically roll back the operation, ensuring that the existing data cube maintains its structural integrity. The design drivers diff --git a/environment.yml b/environment.yml index c37f86e..1d18372 100644 --- a/environment.yml +++ b/environment.yml @@ -11,8 +11,8 @@ dependencies: - numcodecs - numpy - pyyaml - - xarray <2026.4 # constrain to <2026.4 to retain compatibility with zarr 2. - - zarr >=2.18,<3 + - xarray <2026.4 + - zarr >=3,<4 # Dev Dependencies - isort - pytest @@ -32,3 +32,6 @@ dependencies: - h5netcdf - s3fs - scipy + # Development Dependencies - Demos + - jupyterlab + - matplotlib diff --git a/examples/create_inputs.py b/examples/create_inputs.py new file mode 100644 index 0000000..3809ed3 --- /dev/null +++ b/examples/create_inputs.py @@ -0,0 +1,92 @@ +# Copyright © 2024-2026 Brockmann Consult and contributors +# Permissions are hereby granted under the terms of the MIT License: +# https://opensource.org/licenses/MIT. + +from pathlib import Path + +import numpy as np +import xarray as xr + +INPUT_DIR = Path(__file__).parent / "inputs" +START_TIME = np.datetime64("2024-01-01", "D") + + +def make_slice(time: np.datetime64, index: int) -> xr.Dataset: + """Return one small daily slice with a predictable value pattern.""" + lon = np.arange(-179.95, 180, 0.1, dtype="float32") + lat = np.arange(-89.95, 90, 0.1, dtype="float32") + data = np.full((1, len(lat), len(lon)), index, dtype="uint8") + return xr.Dataset( + data_vars={ + "temperature": ( + ("time", "lat", "lon"), + data.astype("float32"), + {"units": "degC", "long_name": "example sea temperature"}, + ), + "quality_flag": ( + ("time", "lat", "lon"), + data, + {"long_name": "example quality flag"}, + ), + }, + coords={"time": [time], "lat": lat, "lon": lon}, + attrs={"title": "Zappend example slice"}, + ).chunk({"time": 1, "lat": 450, "lon": 450}) + + +def make_zarr_v2_slices(n_slices: int) -> None: + """Create *n_slices* daily Zarr v2 inputs from :func:`make_slice`.""" + times = START_TIME + np.arange(n_slices) * np.timedelta64(1, "D") + directory = INPUT_DIR / "zarr-v2" + directory.mkdir(parents=True, exist_ok=True) + for index, time in enumerate(times): + dataset = make_slice(time, index) + dataset.to_zarr( + directory / f"slice-{time!s}.zarr", + mode="w", + zarr_format=2, + consolidated=True, + ) + + +def make_zarr_v3_slices(n_slices: int) -> None: + """Create *n_slices* daily, sharded Zarr v3 inputs from :func:`make_slice`.""" + times = START_TIME + np.arange(n_slices) * np.timedelta64(1, "D") + directory = INPUT_DIR / "zarr-v3" + directory.mkdir(parents=True, exist_ok=True) + + for index, time in enumerate(times): + # Xarray requires Dask write chunks to align with the outer Zarr v3 + # shard grid. The encoding below still defines 450 by 450 inner + # chunks inside each 1800 by 3600 shard. + dataset = make_slice(time, index).chunk({"time": 1, "lat": 1800, "lon": 3600}) + encoding = { + name: { + "chunks": (1, 450, 450), + "shards": (1, 1800, 3600), + } + for name in dataset.data_vars + } + dataset.to_zarr( + directory / f"slice-{time!s}.zarr", + mode="w", + encoding=encoding, + zarr_format=3, + consolidated=False, + ) + + +def make_netcdf_slices(n_slices: int) -> None: + """Create *n_slices* daily NetCDF from :func:`make_slice`.""" + times = START_TIME + np.arange(n_slices) * np.timedelta64(1, "D") + directory = INPUT_DIR / "netcdf" + directory.mkdir(parents=True, exist_ok=True) + + for index, time in enumerate(times): + dataset = make_slice(time, index) + encoding = {name: {"chunksizes": (1, 450, 450)} for name in dataset.data_vars} + dataset.to_netcdf( + directory / f"slice-{time!s}.nc", + engine="h5netcdf", + encoding=encoding, + ) diff --git a/examples/demo.ipynb b/examples/demo.ipynb new file mode 100644 index 0000000..14bc346 --- /dev/null +++ b/examples/demo.ipynb @@ -0,0 +1,8154 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b7504525-e666-4892-9996-e505fa62d297", + "metadata": {}, + "source": [ + "# zappend Demo\n", + "\n", + "This Notebook demonstrates the two user interfaces of the `zappend` tool, namely the CLI and API with some local NetCDF inputs." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "1296da3d-6d09-495b-99e7-d192b2e3d2c7", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:40:51.102752179Z", + "start_time": "2026-10-29T16:40:50.763734412Z" + } + }, + "outputs": [], + "source": [ + "import glob\n", + "import os\n", + "import os.path\n", + "import shutil\n", + "from pathlib import Path\n", + "\n", + "import xarray as xr" + ] + }, + { + "cell_type": "markdown", + "id": "18b11fec-a0a8-425d-be96-bd13b94df1db", + "metadata": { + "tags": [] + }, + "source": [ + "First let's define a utility to remove directories:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "a440d7a3-71c3-4519-9193-c340e04d4de9", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:40:51.111843230Z", + "start_time": "2026-10-29T16:40:51.103614928Z" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "def rmdir(path: str):\n", + " if os.path.exists(path):\n", + " shutil.rmtree(path)" + ] + }, + { + "cell_type": "markdown", + "id": "319d85ca-e244-4b2e-ab66-67dee4af7a41", + "metadata": {}, + "source": [ + "## Define the inputs\n", + "\n", + "We use Ocean Colour data produced by the [EU HIGHROC Project](https://www.highroc.eu/) as input." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "934b1455-eb8c-4c88-a48c-aa7d490e176b", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:40:51.123643865Z", + "start_time": "2026-10-29T16:40:51.112845622Z" + } + }, + "outputs": [], + "source": [ + "slice_pattern = \"inputs/demo/*.nc\"" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "41d912eb-153f-41f9-930f-662f346a3b8f", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:40:51.144944403Z", + "start_time": "2026-10-29T16:40:51.125227184Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['inputs/demo/20230601_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc',\n", + " 'inputs/demo/20230603_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc',\n", + " 'inputs/demo/20230605_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc']" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "slice_paths = sorted(glob.glob(slice_pattern))[:3]\n", + "slice_paths" + ] + }, + { + "cell_type": "markdown", + "id": "6f1cccd0-262c-4fda-b853-2941f8e6cfc0", + "metadata": {}, + "source": [ + "This is how a single slice looks like:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "befb37f4-9a28-41e1-b7ab-468584323f5a", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:40:51.403834487Z", + "start_time": "2026-10-29T16:40:51.145838611Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 475MB\n",
+       "Dimensions:  (time: 1, lat: 8640, lon: 3435)\n",
+       "Coordinates:\n",
+       "  * time     (time) datetime64[ns] 8B 2023-06-01\n",
+       "  * lat      (lat) float64 69kB 64.0 64.0 64.0 64.0 64.0 ... 56.0 56.0 56.0 56.0\n",
+       "  * lon      (lon) float64 27kB 6.0 6.002 6.004 6.005 ... 11.99 12.0 12.0 12.0\n",
+       "Data variables:\n",
+       "    SPM      (time, lat, lon) float32 119MB ...\n",
+       "    TUR      (time, lat, lon) float32 119MB ...\n",
+       "    SPM_QI   (time, lat, lon) float32 119MB ...\n",
+       "    TUR_QI   (time, lat, lon) float32 119MB ...\n",
+       "    crs      int32 4B ...\n",
+       "Attributes: (12/46)\n",
+       "    TileSize:                   540:286\n",
+       "    id:                         20230601_P1D_CMEMS_HROC_L3_transp_BAL_32V_100...\n",
+       "    title:                      CMEMS HR-OC Baltic Sea transparency (spm, tur...\n",
+       "    region:                     BAL\n",
+       "    tile:                       32V\n",
+       "    cmems_product_id:           OCEANCOLOUR_BAL_BGC_HR_L3_NRT_009_202\n",
+       "    ...                         ...\n",
+       "    time_coverage_duration:     P1D\n",
+       "    time_coverage_resolution:   P1D\n",
+       "    platform:                   Sentinel-2\n",
+       "    sensor:                     MSI\n",
+       "    start_date:                 01-JUN-2023 00:00:00.000000\n",
+       "    stop_date:                  01-JUN-2023 00:00:00.000000
" + ], + "text/plain": [ + " Size: 475MB\n", + "Dimensions: (time: 1, lat: 8640, lon: 3435)\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 8B 2023-06-01\n", + " * lat (lat) float64 69kB 64.0 64.0 64.0 64.0 64.0 ... 56.0 56.0 56.0 56.0\n", + " * lon (lon) float64 27kB 6.0 6.002 6.004 6.005 ... 11.99 12.0 12.0 12.0\n", + "Data variables:\n", + " SPM (time, lat, lon) float32 119MB ...\n", + " TUR (time, lat, lon) float32 119MB ...\n", + " SPM_QI (time, lat, lon) float32 119MB ...\n", + " TUR_QI (time, lat, lon) float32 119MB ...\n", + " crs int32 4B ...\n", + "Attributes: (12/46)\n", + " TileSize: 540:286\n", + " id: 20230601_P1D_CMEMS_HROC_L3_transp_BAL_32V_100...\n", + " title: CMEMS HR-OC Baltic Sea transparency (spm, tur...\n", + " region: BAL\n", + " tile: 32V\n", + " cmems_product_id: OCEANCOLOUR_BAL_BGC_HR_L3_NRT_009_202\n", + " ... ...\n", + " time_coverage_duration: P1D\n", + " time_coverage_resolution: P1D\n", + " platform: Sentinel-2\n", + " sensor: MSI\n", + " start_date: 01-JUN-2023 00:00:00.000000\n", + " stop_date: 01-JUN-2023 00:00:00.000000" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "slice_ds = xr.open_dataset(slice_paths[0])\n", + "slice_ds" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "337c10f5-a2a8-4258-9331-1b513a95e92d", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:40:52.683462489Z", + "start_time": "2026-10-29T16:40:51.407752243Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmEAAAHGCAYAAAA8BFyAAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjIsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvgI3uAAAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsXQd8HOX1nN29qi65d1zAYHrvvUPohN57IDTZmN6rwRIkJIFAgD+EnhACJITeSejNGNwbNrZxU7+6u//fvG9XOsnqxZKsb5Ll7vb29vaKtXPz5s0zALjQ0NDQ0NDQ0NBYpzDX7dNpaGhoaGhoaGgQmoRpaGhoaGhoaHQDNAnT0NDQ0NDQ0OgGaBKmoaGhoaGhodEN0CRMQ0NDQ0NDQ6MboEmYhoaGhoaGhkY3QJMwDQ0NDQ0NDY1ugCZhGhoaGhoaGhrdAE3CNDQycOaZZ+KAAw7Q74mGhoaGRpfD0In5Gn0N55xzDhYuXIg333xzrfvmz5+Pjz76CKeeeirWVwwePBjbb789Bg0aJO/D//73P1RVVTW5/ZZbbontttsO6XQaH3zwgbxHHd1vdnY2dt55Z4wePRqrVq3Cl19+KY9pK1p7bIRlWdh9992x4YYbYtmyZXj33Xebfd0dfT4+z3777YdQKIT7778fjuO06bk0NDT6Bji2SC/6Pegz34GlS5e6jz32WKP3XX/99e7JJ5/c7cfYFUthYaH70ksvuclk0n377bfdP//5z+63337rLl++3D3ppJPW2t40TfeJJ55wKysr3ccff9x9/vnn3VgsJu9RR/bLx8+fP9/997//7T744IPuW2+95aZSKXmOUCjUqtfS2mPzl5122smdPXu2O23aNHnOp556yp05c6a71157dfrzHXPMMe5XX33lzpgxw50zZ45LhMPhbv/89aLfA/0dQE98D7r9APSi34MeQ8LW52X8+PFCfnbeeefadYZhuI8++qibTqfdLbfcst7211xzjZCj7bffvnbdiSeeKKTiiCOOaPd+DznkkLXI1qmnnir7nTx5cqteS2uPjcuGG24o5On222+vt75fv37u1ltv3enPd8ABB7hbbbWVXP/rX/+qSVgP+O7rRb8H6LnvQbcfgF70e7BOvgNUMy699FK3vLzc/fTTT+U6l+OOO652mzPPPFNOopmPu+CCC9y9995brpNonHvuue5uu+22ltJy3nnnuQcddFCzx8DtzjnnHPfss892N9tss3X63S8qKnIHDx681noSEeLGG2+s914tW7ZM1KqG21Pdef/999u136aWSCQi21Khas3n2Npj4/LPf/5TVC8Sw/Z+b9ryfJmLJmH67/u6/DeuF/S69yDQ3bVQDY11BcMwsMEGG4g3KCcnR643xA033CCesDfeeKN23Z133olnn30WJ510kvidKioq8Lvf/Q6PPvooLr74Yjz22GPo378/1qxZg6OPPhqvvfYajjnmmHr7HTFiBP7+979jzJgxeOutt2TdvffeixdffBFnnXUWbNtu8rh/9atfYezYsS2+vmQyiQceeKDJ+1evXt3o+ry8PLk0zbo+nQkTJshr5XvREB9++CFOPvlk8TrxOduy36aw0047yeWnn37a4rZtOTZ+zoceeijuu+8+DBgwAPvuuy/y8/Mxe/Zs8YS1xqfVlufT0NDQaCu6nQnqRb8HPaUcybIa1YvMdWvWrHGXLFkiXp+G5bOHH37YPeGEE9YqUe2xxx71lBR6pOgRGjBgQO36TTfdVHxFV111VbPH++KLL7qtAUtu7Xk/Xn75ZXn8DjvsULvusMMOk3V8nQ23v+WWW+S+cePGtXm/tb/+AgFRIYuLi90//vGP7qJFi9wpU6a4lmW1eLxtObYdd9xRbtOrVlFRIaoYP99Vq1a53333nTtq1KhOfb6Gi1bC9N82fX7T3wE08x5oJUxDoxVYvnw5Xnjhhdrbzz//PJ544gnsuOOOOPfcc2vXU+168sknsffee0v3HHHwwQdjiy22wPHHH48VK1bUbjt9+nTZz3nnnYe77rqryed+5ZVXsGDBghaPMZFItPmzvOSSS3DYYYfh8ccfx2effVave5GIxWJrPcZf52/Tlv02VCWpIG288caIRqNwXVfW+zjooIMwfvz42tt8755++uk2HVtBQYFc7rPPPjjyyCPx0ksvyW12ZX7zzTeyv1133bXTnk9DQ0OjLdAkTEOjFSBhakh4ysrK1lqfSqWkPDds2LDaddtuu61cbrrpprjooouEaPhkgyUyEoLmylkse3YFjjvuOJSWlkpJ7Te/+U2j5CIcDq/1OH9dY6Skpf1mvk+XX3557e1DDjkEL7/8srwPxcXFsu7000/HCSecULuNT5racmzxeFwu+Tn5BIxgtATJ8oUXXijvP293xvNpaGhotAWahGlotAKN5UkxK6qp9cFgsPa2f505Wr5PysfMmTNlac431VmesEwcfvjhQkLowSIBakgifvrpJ7kcOnToWo/lOnqpFi9e3Ob9NoVXX31VSA8JnE/CuI55Xj6WLFnS5mPzs8cay/Py1w0fPlyud8bzaWhoaLQFmoRp9Dms69DMH374QS6feeYZvPfee21+/Nlnny2ltJZAQtgaEsayG8ugDEjl9caI5LRp01BeXo4ddtihURP9119/jZqamjbvt6XPJbMc+de//lWWjhwby7iLFi3CkCFD1trWX8dSc2c9n4aGhkZboEmYRp/DL7/8gn79+q2z5/vnP/8pROCWW27B/vvvX8+7RQWMfjGqQOvCE0av2j/+8Q8hDhzPVFlZ2WS5kGVQlhOpws2dO1fWs7tw8803F2LYnv0WFhZKx6KvLvnYbbfdsNVWW+GRRx5p8TW09dj+8Ic/iOeOJMr3p7FDkt2uPN5Zs2Z16vNpaGhotBaahGn0OTAW4uqrr8bdd98tJaelS5eKgtNVYEmOMQkkYyw9kqyQCNKLtNdee8lzN0fCOssTRiM8fVEkfiy9MRqjoWKXOcrp+uuvlxE9bDB4+OGHkZWVhfPPP18aEhjL0Z790sDOCA++D/Rp0bO12WabSaQHozsmT57cqtfS2mMj6E/jOCUeA99LEkQSMJLWE088sdOfb5NNNqmdP8qmA+K3v/2tlKn5fWPzhoaGhgahSZhGn8Ott96K77//Httssw1GjRpV7z6epOfNm1dvHUt8X3311Vr7efDBB6VU1RAPPfQQZsyYUW8dn48nZPqktt56a1GDqMrcdttta6lCXQlfaSoqKpIlEySGmaiurhaSSJ8XCQhLbkcccUSjJdXW7pfeKZIuqkhsWOC2fB9KSkrwxRdftPp1tOXYmMFGrxnVuj333FPM9DfddJN0u7bWs9aW58vMoGO2GBf6zgg9P1JDQyMTeoC3hoaGhoaGhkY3oOUoaw0NDQ0NDQ0NjU6HJmEaGhoaGhoaGt0ATcI0NDQ0NDQ0NLoBmoRpaGhoaGhoaHQDNAnT0NDQ0NDQ0OgGaBKmoaGhoaGhodEN0DlhzYBz4ZpK/tbQ0NDQ0PCRm5uLn3/+uVvfEGbUlf90AcID7pNwYI2eD03CmiFg/gBfDQ0NDQ2NljBs2LBuJWLlP98OM/cSJFZGYBXc1m3HodF66LDWZn7VVFRUyD8qrYZpaGhoaDR3vuCP9ry8vG47X3Ae7opfFgCxfwCRA5CVM1rGgmn0bGglrAXwH5QmYRoaGhoaPRkrFt4FpL6CW3k7jNB2qF5+I6z8q7v7sDRagDbma2hoaGho9HL7DLJOhltZCsCVSyPnfFHoNHo2NAnT0NDQ0NDoxVg8eyoQfxdI/6BWJD8A0nNRtkT7wno6NAnT0NDQ0NDopRg7diwQPRpu1e/qrRc1LPss8Ypp9FxoEqahoaGhodFLMXtaKRB7GbDn178j9QWQ+hIrFk7prkPTaAU0CdPQ0NDQ0OiF2HzzzaUT0q36Q6P3i0cs6yTp8tfomdAkTENDQ0NDoxfi289KgZpnAWdp4xukfxSv2E+zpq7rQ9NoJTQJ09DQ0NDQ6GXYaaedgNDOcKsfbHY7t+o+IHqU8o5p9DhoEqahobHOMO62klZtN/LPd3f5sWho9Gb89717gZr/A5zVzW9oM8D1Zcyedu+6OjSNNkCTMA0NjXWGOddNbNV2i86f3OXHoqHRW7HvvvsCwY3hVj/aqu3dqvuByP7YYostuvzYNNoGTcI0NDQ0NDR6Ed58tRRu9cN03rfuAc4yoOYZfPOpVsN6GjQJ09DQ0NDQ6CU48sgjAWswUP3XNj3OrXoQCO2AnXfeucuOTaPt0CRMQ0NDQ0OjF8A0Tfzj+bvhVv0JQBuHc7trxEP2Mb1kGj0GmoRpaGhoaGj0Apx88smAEQFif2vX48VDFtgI+++/f6cfm0b7oEmYhoaGhoZGD0cwGMTjj94Ot+r3jMNv307cKrhVD+H1f7euS1mj66FJmIaGhoaGRg/HwQcfrK7EX+nYjmqeAqwR2HHHHTvluDQ6Bk3CNDQ01hlGPqzn2GlotAeRSARwfmGrYwffwDjglKv9aXQ7At19ABoaGn0Hi869srsPQUOjV8PpMAkDrE45Eo3OgCZhGhoaGhoavQAuXNhuZ5Awt1OOR6Pj0OVIDQ0NDQ0NDY2+poRx9MJWW21Vb93KlSvx+OOP11s3aNAg7LPPPigsLMSiRYvw+uuvI5VKdXi/GhoaGhoavQXUr5xOULG0DtZz0K1K2LHHHotzzz0XgwcPrl369etXb5ujjz4a8+fPl3yUCRMm4M4778TMmTMxbNiwDu1XQ0Oje7Dlhbo9XkOjI56wjv5Po+eg2z1h06ZNwxVXXNHk/TfddBOeeuopIVVEOBzG3Llzcf755+OGG25o9341NDS6B6lcQ7/1GhrtVLBsV+tY6xO6nYQNHToUv/nNb1BeXo5PPvkE8+bNq3d/IpFAdXV17W2WIZPJJGKxWIf2q6Gh0T34YUqxfus1NDQ0urscSdDnRf/WSSedhB9++AFXXXVVvfupeO2xxx546KGHcO211+K1117DF198gfvvv79D+22IUCiE3NzceouGhoaGhkbPgSuesI4uWkvrOehWJeyBBx4QtcrHcccdh2eeeQbvvvsuPv30U1lnWZYsI0eOFBWM/q6ysjIZZNqR/TbE1VdfLaVPDQ0NDQ2NHluO1BRqvUK3KmHfffddvdvPP/88li9fLt2NBMnXiy++KOrXQQcdhIsuugjbbLMNNtlkE0yZMqXd+20MNPzn5eXVLs0Z/zU0NDQ0NLoDnaGE6f7InoNu94Q1RDqdFhJEDBkyRMjQW2+9Ve/+Dz/8EDvssEO799sY6DPjoqGhoaGhoaGxXithLCeOHz++3joqVSNGjMAHH3wgt3/++WfU1NSsNWh0u+22w5w5c2pv77///jj99NNbvV8NDQ0NDY3eBjZGsjuyo4v2hPUcdJsSZhgGnn76aSFT06dPF88XTfQPPvggXn31VdnGcRyJmSgtLcXYsWOlw3G//faT6z7p8j1fO+20k4Sxtma/GhoaPRubX1KKab/XXZQaGg2hU77WL3SbEmbbtihaTz75pNz+9ttvseuuu9Yz1BN/+tOfxAf2zTffIBgM4oknnsCYMWPw448/1m7DBP3HHnusTfvV0NDoedjiolK51ARMQ0Ojr8B36ekl4z3Izc11CV7q90Z/N/R3oOu/AxtfU1p7fcLkuuuZy6aT1PoJV6rLTa5qfDsuo5++XX9u+t/uenO+OO6449x4/FN30eLBHV6SqXnunnvuqf99oPvPbd2eE6ahoaFBzLhDlR83nVQKM63ek42vVcqYj+lT1TaGd/+PdxVjzN0lGDNl7VFI80+6tlvf2K3PLcHW5619XDsfew+2O02t3+Hkqd1wZBq9FTxr227HF42eA03CNDQ0uhVjp5QI2Rp/nSJchgOkstV9M25v3Bc2vUSt3/DWEsybPBFWEhh1/z3oSfj64Yn4+qGJa63/39+vwBdPTMROx90DK+Fi+1MVEdvjoLu64Sg1eqMnrKOLRs9Bj4uo0NDQ6FuYe6UiKhOuLMVmlysiNvPWYky4ohTJAhdzrl2byPjIWqouZ1/f9DY9FXbIQCDhwrCB3X81BR/868ruPiQNDY11DE3CNDQ0etRMyU0neiVIAwiVGbXrqH417Jr89k+9j3wR251egs8fr3/se+17J957++puOyaNng8XBmz+w+jwftoOjvI7+OCDUVVV1eakAT5u4MCBeO655xCPx9vx7OsvdDlSQ0OjR8EvNVpx4Id7irHZZYqAESRg42+o7xPzsdGNja/vifgig4DtdtjdcpnOtrrxiDR6Cxy340tbWBgn13AU4IwZM2RSzfXXX9+m4+W0m7///e/4v//7P+Tn57f9Ba/n0CRMQ0OjR8JXvL6/r74vbOYtxRh/fX3CRWI26+belSu20/FTsfOv74EdMYSIffTy5O4+JI3eYMz31LCOLG0BSRgjojbaaCP861//atNjOev5oYce0nOZm4EuR2poaPQ60DPmY5OrSvHjLb2LgBGfPDepuw9BQ6NFcJzfn//85za/UwxOZ14nw9Yzcz016kMrYRoaGr0ajKnoydj2zJLaSApixxN0LIVG9yph9JYx/Jw+r8wlFAp12kdzzTXXyNSb++67T3/czUArYRoaGhpdiC8fq2/A1+mMGh2B43bcmE+cfPLJePPNN+utu+mmm3DzzTd3eN8777wzLr74Ymy99dYd3tf6Dk3CNDQ0NLpwDNN3f6yv1H32tC5DanQ/nnrqKVxyySX11iUSiU7ZN8uX7777Lg444AC5vfnmm8vl8ccfj48//hhffvllpzzP+gBNwjQ0NDS6CD4B2+qCEnzzYO+M09BYPyMqUqkUKisr0RWgwlZUVIS99tpLbg8bNkwud9llFyxbtkyTsAxoEqahoaHRxcgkYEzK/+T5Kzplv/vtfAve+t8NnbIvjd7iCet5Vm56yU488UR88MEHmD9/PiZOrP+D48ADD8T++++PSy+9FMuXL++24+yJ6HmfpoaGhsZ6jEwCtssxHRu1RAJ2wJbXdcJRafQKSM6X0eGlrTjyyCNx+umnY+ONN8aAAQPkOhfTVBSCpn7mgFHp0mgbtBKmoaGh0U347wtXdEgFMxI23viq40ZqDY3msMMOO2DIkCFYvHixLH6Zkb4ydkAyBZ8kbO7cuY0+fsmSJXJ/LBbTb3QDaBKmoaGh0UvgjzbaZ/fbhIAZto39t7kRb2oi1qk4sPBsvL7mEfTUiIrO2E9b4yaaQ3V1Nc4888wm7//++++bvb8vQ5MwDQ0NjV6AfXe7DW9nzJZ887Mbsffed8BIO41uf8BW18MNWoDr4s0vbsb+O9wsj9GojwMHnA+k00A4rC4DAby+7E8915jfKRknnRNzodFxaBKmoaGh0c3Y/tSp+PyvTUdX7L/djUgHTVHAnJAF0q699rsTsF0Yjov9drwZb31aR7D23/4muK7SO0jA5HIdELADoqcApok3qp/ouufIOR1mbg5eW/rHju0n70zAceAmknL5Rg9UvhqDo63c6xU0CdPQ0NBYx9jxxKmwgwbSUeCbP08UArb1eSX4+qGJtd2TJGaGrXLFaoZnw0y5gGHBTDgw07wOmCxJuq4oXvvueiuS+SEEYjbstAPDduGGzLU6KLuqo3L/yMlC/N7sQgJGvFH1OA5wTxMSZWRFYYRCeG3Rfc2Stlq4bi1BfKPisS49Tg2N1kCTMA0NDY11hG3OLoHhAORQhBM0akkXCRiRyDcl5NWt4kaudFA6hto2UOPADZhIh7zbQRMWiVjKEUUsWJmC4ZKcpTm8D9bPq+EU5mLfXW7F2/+9XpS0tz7svG7KA/PPgmvbcNNpGJbVpQpYJvg8JFduZRVer34CB/Y/j22DgG0D0UhtOZHbkLStL+jMnDCNngFNwjQ0NDTWEb56ZCK2+G2pjC6iysXLig0sIV2sMlG9MmNc78KxgEilp3ilXaV+8abjwki7CNS4ePfda7DngXfBNAw4IVM9PmHLc9mRAN5ccC+wANh7nzukRPnmh9eJEkbCQuLWYUO/aQijfDP+FLoSVNk4EPqN2JNK2WKp1Su3Slkxlcbr5Y/K7QPNsxU5dF0Y1vqXwtQ5njCNngJNwjQ0NDQ6CRMmlyKV62L29ROxydWlMChIOYBrAWZS+aGTUSBYpdZxia5wkSgwYCVcUbecpKvUrDSQzDURrHHksSRebsCAYxgwHAPvvnmlGPORUsZ8KmKOZcpjScBI1ny8+05ddxuN/EY8jTem3Sa3WcYMrKnB6z/ciQPHX4nXZ05p9jUeWHQu4DqAYcJNJjtd/do/dJJcvpl8unZdJsnzla0Dsk9TKxwHsKx6x8Yy5etL/6gImoZGD4YmYRoaGhrtwPgbFMkKVQDf/UGNJ0pnA8FKA1tcXCqNdk7Q+0PrxSORaHF7rrdDhhCtVI66dIVcAYkiA8Eql/52gRMwYAZcpEOWECvHMhCqtKVMaS5P4O2PrsPuh0wR8vXBf66s7aR0gqaY96mOcXnng2vV/tgxGbJw4KbXwM6LwEjacCIhHLjZtXj9+9ubfc0HDblISo9g4Kfjdkmpj+RrP+t4IVnNETz/vloyBuD11Q+rdTmnK8+YsX51AZJWO53S2bh+vS+9GZqEaWhoaLQDwQrATKnzGRUwKwHY1Ur5SuQDlqd8UcWyI1SgVPkulQ0hTKKQcVVClRipcpHbkIDZYQPRlbYQMK5L5pgIVXkP4MmY51AXiPcPYfdDp8BMOrJvqlpcT2JGImZbFoKra2DnRiRjzIql4YRp7rfhRINCzthh2ZqyJFUmN5WS0p+UIT31qbOxf/AEuCR4rVTYfH9Yw65H6XzE+gXlCet4OXJ9e196MzQJ09DQ0GgDNr+kVJX8AkAyS6lcJGAkVTy72WFVZhQVzAVSeS7MpEGfvJCxQI3aD609gWoXqVxD3U+OZfKxBrKXOYj1MxGuUKdL+sdSWSZCFQwoUOXKQA3DWhlR4R2Y4yKdo6Q3KmBu2sF7b12Nffa4HVZNEmZSecWsyoTKDwuYElvBeIumcOCEq2GUVcJN08DmPVE4jNd/eaDTvzN+GZLP85b9XJseS3WOipjBjC/PG+YTMlHK6CdbTwz62hO2fkE7/DQ0NDTaAJIsJ6BIF0kVla50Fv1bgB1V6hjLi7yf5Cyygl2NgGkDVtwjWqbaB0uRgWr1l1h8Y1LedKVUGaz2qn6WIfdxf6kcU/nGLFVOSmdbSOVasKOmMvunXbz/+lVSinznvWvFM5bODkhWGPPFuL9U/yw40YDcJjLzxRjw6oPlSdgOEAnDCIckyNSNxeHG413yfWEZMtMH1qbH0jNG5SuZrC1PSmYZuyXJfl1X3dbQ6GHQSpiGhoZGK7FZcSlsC0h55vrwGiCdo+4T0lWtSBrvIzGjR4xlSDHhkyR5YhKVLZYquT4RVmqaqFsxF3YQsFL0jLGkaSBUreInmBNGNcw1ScrUYibp4BejkMC0HSk72iawx0F3wU27sOI29tnrdoAlS26TtGUf3OcBW98g+6mF7SryReUrbcOIJYR8vfbzH+qN9Ons8iPxZurZDu2HnZM+hHBllkuNriufrutyZGeEtepyZM+BJmEaGhoazWCTq0pF8aKhngivUSVEX80iqHAl8+jRcpG1zED1UBrwlZ/LdIBkoYvQGgN2lKTIEFVMOiddtQ8+Hhn7c3m/dEi64gcLxD1LNq1OAbWe+5Zt4g7SWUzRN8WrRZWMga0805Jg0RPmZIXgWibscBAmM8UYZZFMS1lSyFxNUpLujWRaqV9UkIKBRkNQWzNTkcZ6gmVFXjeCgXodjj7xYoelb8TvLDK2FiGjMkaPWDAo5Czzvl4HsfBpU/36BE3CNDQ0+jy2vLBESoEMTN3qghIk80hkICZ6lhR5X6JAkSWJk4irdVSzhDiRENlAqFyl4EdWMrerzrjPjsl0jotAlSGEjqCewUwwBJUiJuoYz7Ne6ZG3SbYsJuVDmfO5PyvpimE/nWUiWG0L+bISjpQi1V91ozbOIlEYQKAyKJEVzBRjXhhN+xz6baRsOFlKVXHDwdqxRrsedTc+fnFyh74TJF8kVfvheOXv8l6bj0yiJYSNfjOLCbSu3G6rJ6xF475fmuzlapga4K1nR65P0CRMQ0Ojz2Lja0qldBjrB8y6sVjIGMcJEfEi1eFIksUSY7hMlRRJynyiJOGpJkmWV3qkgT4bcKlWsTvShJAy3m/Yipj5uWG2R9x8YuWb+2P9VWYY17FLkqVDdkayVGlyFJGhPGIURKQ0KWGuQCrfgpV0YMUcpHIDYtyPrEzV83wxL2y3w+/Gmy9PrjeX0p8vSXSUgDUECZ/7zQ94y/lbo/fXEq6usZoJfPWLqhgXMz+vXolVQ6O7oI35GhoafY54+f4ukioSLHqqGK4qpncp93lkiwTHBiKr3DpPl6HM87wuhns/D4xVvBDEUM/H8q9rMpflR/W83E5CV0nCyPP43CH/cUYG2SMhU/tnaZHerXTYED9YIo/lQ1VmDFXZcp2lRx63r4YJUYxTSlMJ/DLoOwMfZRAwjjNqLeyl41q9rV+OFEyb2SQBW9eQ2AvHgb16DXonDDiu2eHFGzag0QOglTANDY0+4+2i6mTEgE0nlkpph8Z6lgephpEA1eZ58b4yV1Qp8X6R5MSU2T4Qp9qlSpJUtrjeLzH6ZUVRuoJAZLWBdMQz5pN4GV6J0q3zg3Gf9JuxBOob90nuQlWuPI6lPG4bjKk7OT/SCdX5gpL56s+4G1IKmikufY4vUqZ9M+1g919NwYf/UkGumUPEjXnV9VSw5mANmdPs/b6nixlf9UqODUqRPQGcc+mb93tTdEXnlSM1egr0p6mhodEn8ONdxZheUiwkyfdcJfO9TK+QIlfBSlfKfiRiLAVyHdUqNQrIi5KgD4x+L9uV0iOv83FZy5lMXxdGzvXkQyRdLElSLSPp8kf/cT9+ZhghBFFiLVzYESpfhheHYdQa8VkqTUd5ENzeldIjr/MyXJauTcdnRyRjKliutDnkO66IGD1he+6vlLHsJYl6pcr2KmAyKsgjXSRgLC92pqerq0qTckmfmIZGN0IrYRoaGn0K036vRgxtdnmp6lIkUUoyg4trqXC5SBQpdYxDsjmnkeD1dLZSxsS/ZSviRqJkpgzU5KmoCSpbJFQynihEhctFuIwGLo/Mhb00femqJGkyhFBR+Uqy61LUsrp6EdU4O6SYmzQDyOghEjRTPGC8bsiDTDX6KMFuzBAs6ZA0ULFBSEJfw6tTCFQmJR+MQ7ydVtakGlPAqHqRdLHsaJdXyKUZCvaezkPHUUqYacolh32r9W67s8rWWWJ+J3RH6mpkz4EmYRoaGn0S39+ryBhLk8Ea5nAZYq53cgyEyhWRopLEsUJiqGe2lkeCrBiJmoEgvWF02Ms6pXb5JUU+Xror48rv5ZMzmvSpqolXjJ2T1S7SEQOJPI9k0SsWUcSMXjGWRRnqSoUskWsIUQtV8j4gukrtW0l06onZFRmoVgoPiVreopSKpXBcpPLCeO9tlaJvMIqiBRyYf1ZtAr0f77Cf+WtFwMxfy3viq1/w5mP2CrBL0iNevYY4euiMnDA9O7LnQJMwDQ2NPg+qTRKYKmZ7VQ4k1BghL8uLZMwjTyRnlBOojHF7UaBcpZpJdheN+agLbZVIi5Qic1yqx6aQP02NGCKpIsHyQZVMQlvpN0u4teOPSMg45khCXulTC3EOpQnHAiLlDtIRKmM05hvSKSljjTiTUuZXOrAjFqyatIS5Ggkbb3+s0vG3P3UqPv/rJOyz+21I9Avh439OxkGjiyUvrF5OWDAoRMs32ctlyzyuR6I3+cDW8oT59WyN9QL609TQ0OjT8GMiCBIfkh0qXqo8WVe7oS9LVDHvp6vf6UjPFscVpbPqOhx5m34zKmtC5DwvGNUyErIB/w3UKmZUukis/IgK+sfEaxbkflREBf9Sk9ypId+GmPi5v0ShIdtRSQtVcuA3Xwv9YSkpVfKYfbCj8u3/Xo9gZRJmIi2dkRxTVDC9UlLy3/nwOkRWJrH/Djer0mZNjRqG7eGNisfW0SeiodF3oJUwDQ2NPg96u2hol/KjF8JK07xSnBQxCtSwRAikg56Rv8ZVoa5+7IT3kzZU5opK5XvHZHwRB3fHFBljtyBvkyCRAJJEkSCRsFFZko5IT4WjZ4zkjuSNxyTdmdXqMZHVHHHE7DEVEFs1xOuStIJCyPxuSI4s4uuiCkYv2Jv/u6He533gptcAqTQO3GgysLoaRlUMbjyB11c+1Oe/Fz0PHFukPWHrEzQJ09DQ6NP4/r5ibHFxqfiu2OVIUkM/luOVJINV7Jg04ISVakZFiuRIZXN5XYoJFVvB8UJUp6iSSTmRpUvDU8xI3oLKE8aGAJYca4dzp10EaxQ5A3PHmHrvB+BXq8wwPocM9TbrjP0kcrZFkz6JmitlSRlXZBrYd7fbRDlzLBOGyZ0ZeOvD62pf9wGbX4c3pt2G16ff0S3vu0bbocuR6x80CdPQ0OjzYOlRqVb0hrlIR+syu8QkT4+X6xEil6VKzzNmAMkCT6kymbJvINHfQdYSjhJSpUk/O4xKmFmuSB7jJyTOgvlf7LqMmEhHSMTUSCJ6u6RTkp2PbHKU0UhsHlDkjWKIn+xP35ccIxU8yR4zEKx2kI5aKoqDuV2GSsvPBAmYRu+CdEdqY/56Be0J09DQ6PP48c7iuvwuptSLmuT7uJQ5XqlfXm4YDfzVXrK9V77kJUuY0eU0yHvRF1wXUwZ9KmZUpnx1jURP/GNBlQPG52QyvuSBhevGIpF08bl8RU0M+nFGWqhUfFm4PkyTv6lIWZizKi04XrRFQwKmoaHRM6BJmIaGhoYXKUH16rv7i6UsSSJFn9a3D0yUkiUvWUb0s7oYUSE5Yx5RktiJJKWoOjO+jEQCUDPMVaOQvCBY/uWVDDIvNd8nV0LmvLFGKk+MgbCKFPJ4uD5U7SBFAhcyEFljyzELGfSIo58hJipbZUoGd2usJ+D3xTU6vOicsJ4DTcI0NDQ0GOL6u2I5yW11QYkQHJKx3IXqdLXV+SVyyS7Erx+eKPf9cHcxvn5ooqyXjkoa7rMUMSMhY3QEU/qpYuXNVo+loZ/kTNStuIvIGlWCJEGTtHvPO0bQeC+KW8ytTc/3w2UJlh2Znk+Fjfug/4yBr9wv10VWJPD2R3UeMI3eD39sUUcXjZ4D/WloaGhoePjuj8W1l1teWCLdj5tfWiqlQ4GhkvYzQXVKSpmSx+VFXiRUaZLkTaXqG1KC5P2+IZ/7jPUzEC9U8yW5HX1gEnURUjEUVMnUQHG3dsRRIs9Upn1vQLffLBegGiYdnkzrT9fmgPnY7fC7sffed0i3pIaGRs+ANuZraGhoeBh/fSnsCmCzy0rhSmK+5+ViVhd5TxowHVeGgUvivUfCqE5Nn1qMCVd6BE0ULCA20EBkFb1gQCqXXZN1xn6m3vNxVLn4c5jNAVTQJBoj4KXtJxjQKs/i+c6Ul0xKp0mVqB+kUZ8KCbs1mQvGKIuoVW9oNwnYRy9Prv2cOT8yULM2UdPo6WA5UWsn6xM0CdPQ0NDw/yDG6joW2XFIkvTtnybWjjcyq7wRQl4CPhWzCZOplAEbX1MKpFTJkCSMypfyd6nMMD/c1TfTk2TF+6tgWEZPJHO9CArvr3K4zAuGZWZZxkggkjRJxrcMWCSKvhIW52giRdQY1PreW1fL+p2PvQcf/f2Kep/x+2+q+zR6YzmyM3LCOr4Pjc6BJmEaGhoaHmReZMALTHWB7/6gMsRIosIrXCQKVEK95YWsblZcKgOzSaRkNmTaywKrYoei2if3R6O/lBkZmhp3YWerod/smlTP6yK8hh2N3nijYF2ZU41OUuVMg+Z8Twih54xXSfIszpkMmwjElGHMTKjZkcT/GhCw/Xa8GXZWcJ0a9u2l4xodBK7RdhKmlbD1C1rX1NDQ0PBgeB2MyXzVqbjFb0vFhE/TfmyAioZglyLJFgdvf19ajEShUsR+uKdYFDGSKJI1P7uLBIulSJYhffM9lTSWHyX8VYibIWQtTKM+y5Qeh6Kqxu5H8ZFJiVJliBFU64JVnBmpOiXFP8ZcMYfRGXUkzAfHFO154F1wQhasuNfi2cXEy4cmYBoajUOTMA0NDQ1AyooyHzIFhFe5tUoYsfU5JUKc2A1J4iXzGqMGJlxRilk3FYsiRj8Y/V8kUFnL1eN9gsRSpD/smsSMShtLj1TPlMFe3UeSxYWEioTO8Lb1g1mJZA6N/KZkgqVyTDHkM6IiWOPIc0lKfsAUH1gmODcyUJmCVZ3CWw1GF3UFNPHqCjCsteOLRs+BLkdqaGhoABI5QbLFsUM8T4UqlOJEcuVUurWdk7V5TcG6uAgSM3ZNslQoQ7g58shQw7ll2LalcsF4mcg31HV2PWbMnczswPTVNnkqy5shGVVm/tpOTHq/EipHjN2Wnz9Zv+y4x8FT6l3/4D9XChHj/EiCg7p9P5lrmXKfRt8oR7p9OChsp512gm3b+Pzzz9EToJUwDQ0NDQ9+CVFCTy3FUH6YUizrN7q5VPxhBBWs6SXFstCwT3x/bzFSHuHy50wycoI5YVLGTNXNhLSj9JYp1YpeMZn9mATC5ZxT6ZUp/eHeMkTckPKj71VjuTPW35Tl879OwudPTpJj2O60EuxyzD1ynaRrj4Pukut8rn12v026Iu1IQGIq7KyAkK9MArbvrrfW+sY0eiBcA7ZrdnipzTXpgzj00ENxwAEHoKdAK2EaGhoaHvzyYyZYcrQtYNaN6r7x15Vixm2qBMl8r+l3FGPzS0pRMd5GaJoa5s1oCpIoqmksK0rCBD1bNOt7A8BF8UpAKW9EWoW+sksyVA6k8vl4pYTxvCnJ+d7gb3rUtj6vpDYs1scXT9S/ncyzsPuhU+CQyIUt2BEL77+ioipIxFL5ISFre+9zh4w24jb7b38TjOTanjINDY3OhyZhGhoaGhkQckWDfRJitqdH7Pt7VLmRaheVsvE3lMJOATPuKJZMMRKrgu9NIUquqcz13I63WUJkICs3kgHgTMVnB6ZJBcybC0kfl6d60YyfylXhrdzOzw7jc2eiIQHb/tSpoopRCeMMSr/sxM5KLuyepOK265F3SxnTTqtaKgmYmXSkTEnq9ebnN2Hf3fRw7x5bjuzDKtb6CE3CNDQ0NDww68vxs7e8cx3nRsqlR4I4isgnZD5InliylHmPCSpWTMWn30spYTKayNsvvWAsPbI7UvLGpOyoDP0kZsEKV+ZUtgSOV1KPV00ALHnudNw9SHF4d9hApMyR+3xjv2uY4iMj0lmmRwhdBFfH8MY3twrx8gd9t3bckY6e6IacsM7whKHv4pFHHoHjeGbOHgBNwjQ0NDQ8KEIEzLxt7bJkJkjANrqxFJHVQCrihayailyx1MiORfrB5GxHD1iYXY9KXSMxokLGiAtRvXLUnEqOR2KZcYuL6o9FIqi2+WSQYPnTiCmCF4j7Kpryo0m5M8Ukfo43UuROuj6FkLFz0iOJQXYRALFhOdir/51It0Ng0R2QfQOWZeGwww7Dcccdh0WLFuGqq65q8TETJkzAiSeeiNGjR8tjHn30UcyZ0/1ZcQsWLJDLQCCAc889F6lUCn/5y1+67Xi0MV9DQ0PDA0349GmRYDVUyOgFy4yzoIHe75CU8iI9Xl6yfaLAFPLjkzOm2NPLJaSIXY+GMu3bHOjNeZSXlcq+Nrm6FMn8tT8OEjCqbyRqbASwo2oMEtU3fwQSA1upvnGMEbPEmKDPIFcSPWk2MJRCZiUcKUcyVZ8DwAk7Ysrr2P2Quo5KjZ46tqjjS1sQDocxd+5cnH766Rg8eDD23HPPFh9z1lln4emnn0YsFsO///1v9OvXD9OnT8fee++NdYmsrCxceOGFKCkpwQUXXIBIJCLrSSh/+OEHTJ06FatWrUJ3QithGhoaGhlgxyOVJh8kP1aZK+OLNr5WkaUfbvJM+tfXkTH6ttg1yaBXlh4DroE0lFFfRUpQnQKSBYYY9mnCZ6ekRFUkVIyYEwVm3qr2TUL2453F2OgmlUUmg7wZ3hr3Ev25fYjuewi5klwxzqWMGghXqMwwn5gxV0zS9A1GZFhy/aNXrpLoCpYmOdPSjpowE44Y+amcUS3zRx9p9KSxReu2HEmlaJdddsHPP/+M+++/H9ttt12LjyHxovLl45lnnsHAgQNx7bXX4t133231cx9wwAFYuHAhZs6cifaod5988gk22WQTLF++HIMGDcKvfvUrWXfTTTfJ8d14441YunQpuhOahGloaGg0wLTfF9crPW54a4lcn3F73fqRj9yF1EpXiFBkhYF0tgpklYwviaPgVobcT68Yg1xJxJgRxswv3k+1jBljHAhOYkUCxlwyihUkYFS9nLhqBOBAcXZQimk/5qf7A6k8IJ3N7DGWO1XXZazIFMImsyQdEj5eqlmYiowpNYSdkTTyf+R3TO5+m54r2cPRViWrcbR+H/RPkYC1BSQ9DbFkyRLsuOOObdrP8ccfjw8++KBdJIxqV05ODkaNGiXHz8v//ve/khO266674tNPP0VPQLeWIx944AG4rltvmTZtWr1tCgsL8fDDD8sHWFNTgxkzZuCyyy5rcd/chrVfyqGfffaZvOkaGhoa7UKDE58oYKuDQrhIsmiyp+KUzFcGfJIuer4I+r1Ilki6GF1BTxa9X9yGpUSCBMr3W7Mkyn0wk4zEjuoayRq7JKVrU0qLJF7MG+NcSi/CIldFXPhDvzkuSRFBT4Xz0vi5DUnZDidNrX09VL+YIfbOh60z5Gv0fgSDQeTm5tZbQiFKq50PqmAnnHACXnvttTY9btq0adh+++3b9ZwbbbQR/va3v9USSCpqf//73/HUU0/1GALWI5Qwvim//vWvm7yfBGz8+PHYd999hVQddNBBeO6557BixQp5M5uqR99+++1iIvzf//6HyZMny4dPo+BPP/3Uha9GQ0NjfcK420sw59qJmH1DfaN+stCBmaAny5sDSfKVoN/KQKIAmHVz/e2Zts+yJpU0+skYg5HiYO6A8pdNu7sY4+4okW1IulyWGL18MUZeMKyVJUshfRwgzpR9i3lirvjCuJ5Q3ZmqEYBqm5Q7Pf5IYkf4yfsEidh/n1ZBrxo9Hy6V1U7STk4++WS8+eab9daxTHfzzZ0b1BuNRvHiiy+KOZ/n5bbgjTfewBVXXCFiCo+1vLy83v00+jfl6SKprKioqLeOt+PxOHoSup2EtYRtttkGjz/+uChgxD//+U/8+OOP2HbbbZskYfzQ2O3AujTBTg5+4X7zm9/gmmtUC7aGhoZGSyABy8SYKSUYuNVyLJ1Ng70iRuLVSjD93oWRUB2RDHhVZEiVBEmApnmRFhyPRLIVqlT7ZNckS5AoU4oXH6eGcXvEyWNRJF0Mh6XZ3yd/iSIDkZWuKGo09IsvjeOPDBXqypIlj0GiL6rd2uPh/Z8+M6meGqbRC8BO204oR5KC8/x5ySWX1FufSNDA2HmgEf7ll19Gfn6+mPLbSoCuvvpqDB06FJMmTZKlIU455ZQmeQCx9dZbS0OBjy222EI8bpnrvvrqq7UqcH2KhFHZqq6uFob74YcfimpF2TDT0HfMMcfIJdfTqMeWVypojYHly4033ngtsvXee++JuVBDQ0OjvZh35US4pVOBAUnYCMIJczi3gXTIEc9VMk95suwkCZHyg9FU3xBc7/vGGMqqYixU6dGfGUnflyhhlleOZNo+/FJjHcGL91NKGNP1ZR/Zyk/WEAxz/fLP9U9kn2kVrBfOjuycsFaSkcpK75dAF4BdlS+99JKQKBIwVq/airPPPlu6GptCS6SO3IFLY+t9XHfddd1KwrrVE0YpkTkibHvdZ599hC2TiOXl5dVuc/311+P7778XYx7fcNZ4yd5psGsM3BfR8AP/5Zdfau9rDKyFN6yPa2hoaDQEg1XdmgCMlAE3yLwtF/MnTlJhrAEm4NMAT2VMbct4i4aQuZBWHaHK9ElT4WIZ0SdmHGFE9YuZZHwcy5QSjWEr/xiJGD1pvE3ylUnA2OW53emqqYBp+hoaXQEa4Fly3GOPPWrPpyRgw4YNEwLG8297kEwmRaRpauEg7qZA7mAYRotLW0uk65USxuwOHyw3shOC7aK8pBeMeOKJJ8TLtfnmm0tWCZUw5o9UVVXhhRdeaPVz8c2m8b852ZP1cA0NDY3GsOUr16JsUYF4tMiSnChbDV1YlQGMvauE2QFCxki6ZmR4wnib5UaJljA9pSumFCs/1oKEjIoYiRQN9n7JkKXJZF4dWZMw2YBXAs3wegkBtNTIJYbFivn/98VC1r54vOX0fY3eAuZ8dYJ20sbIfEZTDB8+XMp5BQUFQrgI+rnT6bSoXkceeWRthYoWoAMPPBAff/wx/vznP9fzZGWWAlsD0zRx9NFHY8stt5TnZflwww03FJ/Y4sWL0dvR7eXITLAkyTeVbzDBgDd6uSgdUg0jyK5Jvi699NJGSdiyZcvkcsCAAfXW83ZjbbM+7rzzTpSW1v1ipRLGjkwNDQ0N4tvDbq8XT7HovCuxwe+mSonSB0Ne02F1hmO4K5P37agLxAy4WSRcyilPQiYxE7YrSlc6ouIj6PWSMmVQxV3AUvMpSeT4GIL3sZzJfXH993eoiAuCihk9Ycw6I/zLlrDzr+9BMsfEl49pwtbzc8I6wxPWtn2Q/DRWHfKVKJIrkrAvvvhCbpOMffvtt2tt31bPmWVZeOeddzBu3DgRUijWkISRG0yZMqVVwbE9HT2KhLEcSbbtt5T6H3BDBYsfRlMy5Jo1a+SDogTqs3Vir732wl//+tdmZU8uGhoaGi3BSFgY+fAULDh3kqhgVKFo0g+U8++WIaGuM7zRR8FKNVOSJnn6xGjp8RUtGuYlKyxjJBGJldwfqrtNlYzK1kY3l8roI95nxdWYIhlp5M2zZBxGe/C/v12hP3SNJkEi1JK/jAKJD6bRc+kozjjjDFHCxo4di4ceeqh2PQNXqchttdVW+Oabbxp97HnnnYczzzyzxed48MEHpfmvz3nCWDP+xz/+IRkgHC1AMz2jJ2gU9LsdysrKJF2XqbabbrqptLoeccQROPbYY+WxPli6zDTWcRQBYyoOOeQQMerfdddd8oHxzdbQ0NDoKBZeeAUWnXulXGcsBUuUVLz8MqJfGiRBCpep1Hx/gLeEt3KJKM+XEwY2nVSnwlP5otcrf66D6C8uspe68jgm6JPoMRcstKbOmM9yJpE5UFxj/cW6HlvUndjWS0GgH7yhGEN7kl81awysfLGC5i8smXJeZOY6Lu1pGOgWJayt0f5Dhgxp9n6qToyRIGFiGykVLJrymaib+abQH8ZSIXO+KEGyQ5KjD1ijbm5KOs39DIPlqAISNHZhMqdEQ0NDozMx68ZiyRMLr+YcR/XTlqVD+rz4K7dmIPPDFAGjH4ydjCRhPuEiqHBlYoeTp+LTpyZh2zNK8OX/qRIhidr0qfUVM3rKMlU0jT6QE9YZnrBegmQyKRWyxsBxRCtXrmzysVTmMtW5W2+9Vchcdxvx203C2FnITI7W4Mknn2zVdq+++qoszYGE7Jxzzml2G05Cb4h7771XFg0NDY11lSdGosQsL79DkeOGghWe2d5WpEsULabeWyofjKoXt2FoKzPEiM+eUp2MPgEjMgkYkbfA0RETfRBOJ3jCegteeeUVEWsYUeUrYVS07rjjDqlyMYy9q8AKHZ+jtWCzYMMw2U73hDUXitYeEqahoaGxPsEnSiRaVMO+v0Xd3uKiUknNJ3yCxm1ovmfZ8vtWGuj9fXEw92cPTcQ2Z5fgq0e0mV5j/cTbb78taQiMs2I3JL3e7LbkPEt2THZl+v2pp57aJgsTt2UgfJeRMJrhu2JbDQ0NjfUNmVldLBsmLC+369JSmRvZcJu2wCdzhCZgfQtuJybm9xZce+21QsQOPvhgFBUVyehBJiO0N3usLXj22WdbFV1F21RLFqxe0R2poaGhsb7B931R+Zp2Z7GUKGfeUixxFg1nTGpotIS+5AmbMmWKeMX/9a9/Yfr06U3e1xjYOclsseZGFjU3togkjzEbDIpvCXx8e9MV2k3CyEj5AnnZEG0JUdXQ0Og5GPng3TBzU3DLQ1IqW/jbKzDm7hLV8Tc8BveXiCTF23lpmNUWFlyuvEsb3Du19vrokqmwmItFY3oamH29LpdlKl9M0Rf/lyZgGu0y5ndGpal3VKuGDh3apDF/5MiR4ttqCswX5UiixtZnoqmxRZkRVy2hLdt2CgljTAR9XxzOSTNaQ2gSpqHRMzHujhKV2u4FgqYKbSDoILw4JOGfTtIVAmYWJGEsjmDDW0vguIBVY2DWifX/oLGjj4GkHM8TUBnJgvBqEzNu1wpPU8gkpZKu7yllGhoaCoysYrIBF3ZBNgxlZVLC7rvv3mzzHccWcenpaBcJu/vuu6U7gZfNzW7S0NDoPmx1QQkci0nsLmIDDZk9mKxSQaEkYTIOZ42FyMoAqkc4CK80ERtmq3E5CyISucAsqtnX15GEDW8pxewbioXMwQu/zhxQzVmF025XwaF8ju/+UCw+KDPl4ts/KfKx7ZklfT6Z3e+EJAHTZUmNdd0d6fYCH9gpXhrD/vvvL7czwQxR5op+9tlnXX4sDIvlbGtmjDEqi5730047TeK0mFVGQz7nWK5TEkaJ8He/+50mYBoaPQjslCNpYqI6B0AHKl3E+hlCurKWu2p9miGhhgyBZsZUsMqQ5Pa82aaQsoLvA0gUQTxLPja6qVRG6zAMNPtn9ec7utyQrCvmXzGWIbzGFZM4Yxi2Or8E39xbLF1/RLBK3edDj8aBEDAS2TnXTBRfGP1i7TXqa/Qd8F9fbwpbbS9OO+00Sctn1ic7JP2ZlASjKtgdua7AVIgTTjhBrrMzk9lkl19+uUwE4FjFo446Crvtttu6JWFMmd1oo42aHBegoaHR9WAae6jCRSCuiBHnQofLXaV+uS7SYUMUKP7NZkBoOttAdIUjniTXMBAvUgRN/qaTtMVUijujFUighGQlge9vqptNyFLmDidNRSKpZh4y/T0RNpDMM9bq3Pu+VF3XHXyNgwTMhyZgGhqoR7RYZWOIO1WmxipuLRnzOwOc1MPJOzT5cy7166+/LnOoeXv27NlSLv38888lDJ4qWZeSMB6MjyeeeELYISVC5nc0HCfQsItBQ0Oj49jt8LuRzDUR628iUOMi/LMNO6zID5WvyBoH8ULVOWU4BoI1rtxPckW1iwSMg6ITBYYQN1HLavhv15DcKZroUzkG+k1P4cN/X1lL9FhiTBuq1GjG3NqA0C0vLJES45a/KYETqvt1vsXF7Z9hqKGh0Qxk7FDf6Y4c2gFjfmdg8803F+LlDyNnCZSjlEjA/NFInEm93XbbdT0Jo/rV2o4AnROmodF52P6UqaJYxcIGUtmGlBRZBkxlmwiXO0jmqD/KJFgkXvECQwgVjfeijAUMuZ7MoUIGmWVIBStQ7YraJfflGghVAtNLirH1eSVCvsTTdV8xtj63BNN+v3aHo08Av32g/n2NETDxiv1eEzMNjR5RjnTXf2N+Z4ABsZki0+rVq9eaNcnyZHszwto8tkhDQ2PdgCoTyZLEPKQUwWLJj6SKRnuWEwMxEiwgVOWIQsbLQLUDJ2DBDnJbpXylsgykswxEVlHtcuGanCIN2FGuZzejK9vxBzYN9ahyEazmdpDZheyOJIli6ZMDo6mkkVDR/+UjMxG+MWgCpqHROdDGfLTJmD9ixAhRzRp9Lx1HSp6zZs1q1Gf28ccf45577oFlWVISfeONN/Dpp5+uRRhZFu1yEkbZzQdroNtvv32j2zV3n4aGRvPY6bh7KCXDrnRF/UpkGwjQiBoCoqscIUFW0kWskDlcBkJVLqoHm0KQSK5iAwJCnlherBgRgGm7CFW6CMYUqeLjacC3Q4ZES5BIJQoNRFeq7RJ57IhkKJh6HvF6GTT2O/j02UlSaqTPzCdWfgJ8cwRMQ0NDo7uM+eedd16jeWEN+Q1HDjWs7lHlevTRR7HvvvsKAZs/f369+6mA7bLLLrjkkkvQXniW3LaBb0JjJUe2ciYSCQSDQfR25ObmoqKiAnl5eaisrOzuw9FYj7HjiVOF2KSjSt2SS89sn8w2RQ2jMsVSYiJXlRR5m0SKJEtKj5byhVUPMpG9zBEiZXv/DLle1LSoMtqTiLGLkmoYr8cHGDJEml2NyXxVyqQ6RtWMCpr/XPxLkTlQWqN3gBEYTshFsr+NRedP7u7DWS+xLs4Xxx13HG56+A5cM001yXQEf9rmJpx48K/x/vvvY31HTk6OqFfPP/+8+NlJuFjZO+ecc3DooYfKDEqOHbrqqqswYcIELF68uNX7ZlYq+U5HPvM2dUfSkNbYdZ+A7bzzzli0aFG7D0ZDoy9hu9NKkL08heqQgVC5jVRWoJYoxQtMRFc7iJTbUlp0goaUGkOGImX0htH/ZSVcKUVStSIiqxVhClY7QLbyioUqHTHzi9KVz9wwqDJnEkjlcr/KTG8k2PHoCmGjQZ+Gfm5DBU3HSvReMAJj1P33wKrqO4bu9Rl9IaKiM/GrX/0KX3/9NW6++ebadfPmzcM111yD8ePHi/meuae77rqreM/YdNgS2CGZnZ2NBQsWdHiIeJtI2BdffNHodR80rF188cUdOiANjfUdux55t5jqkXYRLwwIkUrlmMpIz7KiQaWLBMhFosAU0hQutxEvsKREyQgKErBQhY2agQFEymzUDLAkj4vqlShdIUOImXi9PMIl5KwGiBcaypwfUJEU/aalUD04IM+vzPYuslY4UprU8RLrB9yog/kXq45Xjd4LV7oj1/+w1kwceeSRksRA7xVVrUww0LUl0jRmzJi1zPSZ8yF5P0FfWGFhIVoDqmeMqWAJs6NoEwkrKCiorZP279+/3n0cjFlTU9PhA9LQWF/BfC2WBhFzpNzIv6UkSVJ6pPXK9m7HlJpFhYsGfJKjWFEAwZjj+bG4HijfIIisFTbsELsklTcssspR5nvLkD+0JGSpLKWUUU3j46OrXFQNMyUPjEvVsID8VWbMBPfDjkkSsK8f1qXH3oixd5bAjrpwAwzoNTC/eBIWnaMJmEbvw3bbbYfHH38cN9xwAw477DARf5hSTw8WDfVvvfVWi/tgZNbDDz+M//u//6uNmiB22GEHKUOeeOKJtbdbo4J1NtpEwsrLy+XyggsuqL2uoaHRNLY7vURIkXi+AiqPS0hRyhXSRf+Vj3CFI+RLyJIY6lXXoyoNqu0ZR6E8Xar7kcpYOqw6JPMWObJvbkMjPkuSvM59skOSZI9RFMkCQyIuiOylNmL9TBVH0SBaYvtTp0rZ85sHNRnrVWA4b8KAmzAw78qJGDOlRC411g/0pXLkUUcdhT/96U8yoYeEjFFZnFvNzsgff/xRSoIt4aWXXpL9fPXVVzKom54wGuqZffqXv/xFcsCosr355puNVvi6Gu0yCfBNoQdMQ0Oj6S5HjhESAkaiZajyIA30PEnG85W3S3IXPUWMPjCqXiwzUgFjKZL3qTIj1SlFrkjOWMKUTsdsUx4b62dJdyTJnkRVxFlOVATM94ux01FM/uyWrHaF2JGAUTX7+i/qJL31OSVyyWiK2ABTjPoNMf6G5o3BIx+e0mO/FqP+cE+Lx98bMe72Emzwu6kYe1eJlJn5vSLx4jpNwNaznDAYHV56C4YPHy5ki6D53a/GsQmCZvutt966Vfthp+VOO+0k5vyZM2fimWeekRSH888/X+6fMWMGbrrpplYf1yeffNJkTmpb0S4mxTeltS9eQ6MvgeSFiwSpViiyRJLETkWeGCOrbURWpZG10q4zzfczZTuSJ5XDZUkWGH1fKnTVEPKm/F70kVkIl9kICBFTURZi0M9WKlg6qi6pehGSom+qsURU00jwGPj6zZ8nwg2wG9KVYd/bnFUi+yLYBclt2TXZEJwrSXWF4OXokqn1NzB7puNky1euRXiVhXTUlZJdb8aGt9Y/fsaNLLh0koykkpq3CyFkXKeh0VthmmbtyCKm1B944IFyPRqNYosttpC8sNaC8Vk04LOUeeedd4oy1l6wrMnIis5Au2ZHsr5KJsluAw6xTCaT9e7XY4s0+mLMBEmPEVfp835QqsDL3JLYiKgpCfZyn3AVB9nLbCFfVLNI3GQtU+4D7GQkOXOlQzKQUOXGYI2DNKMrDCjSlKY6ZgvxU7EVQCpqIGslg1u9MmSO8pZJRIXtCoHjfEirypWSI4dzMymf8yaphtUMNeB4Fs/x15di5q2KjJFwzZ84qVZdaUxlWXT2VRj557slAsNMmFhwWfcQAR5DZiRDxcwi2APTsGpMmGkD424rwZzrek+ZbtTvp8KKGwhWGEhmOdjo5lI4lvITmjWGEGKSa1FLwm63ve8aXYu+VI4sKyuT1HqC44GuuOIK6WzkuCKa6j/44INW74vlx1GjRq0VoUUO448hagmjR4/GuHHjEAqF6q1fuHBho1OFuoyE/eEPf5BL1mYbgx5bpNGXzPYkRU6KcRHKyyWmeNNQA7BTKsOLyhTJUU1/QzogCdnWIGlTgjQJWNVQC7mLvTOpYcj9/nggEjAqY3wcOyTTWaYQLO6fBExImwshbFTRZBuPCDLslfvk0O4f7ypWcyCTwNcPTZTAVapgCa9c+d39E7HxNaWYPlURr2R+nbJFAtYQPjHzL4nOyKNirMLCi69o9fYb3DsVCy6vO77MYxhdOhUWlUDXEqIiMOuOvadi9NQ6xcuq5BB2F8lCF1aM6qjKjiO5TkUdGBzwyfiRkItQmbaLrJ/oW92RF2ekLbAhkB2JzPaiOvbCCy9IQ2BLIOniXMd99tlHCF3DYeC33HKLpOK3BPKdk08+WZ6z4T4oTLU3sLVdJEyPMNLo62Z7/h2Uqo/tBZky5Z5zGGm+TzChniZ7Gt7rG/BpiOdJkyVAqlU55TYM10RKSogGrBhT6y1RzqhYiVE/wGR8mvD5GBNuWCleJH88DlHKwoY8p8RX2A7SYbM2E4weITH15xnIWu5i00mlmDa1WEqQvA7GV4RVJyWJ16YTS5G2vE67KSWYO2kixt1RgjnXKNVog6duR2BBBHbEFQLjkxj/sjEj+Kg/3oOFF13Rol9r4W+vwMi/TJFuPp+AkUCxw68lZBKwTPB4jZ8NRUT5GSQNpHIdmAmqSj2TrFB9TOe4cExX1C8er+HQv+ciUG3CznJh1Sh1M53lwIqbUu5mOZKf46yb9ASD9RGdNzuyd6ppv/zyCx577LE2PYYdkPSWbbTRRq1WvBpiv/32ExJHEpjZYdkZaBcJyxxhpKHRV7DzsfeI4b2KCldS+bDU8Gvl6ZK0e4mYUKqVD6piqWzlCZMuR2/ihowlyrekBChZXmmIgqWCVT3ixlJmSgWyKlVMPY7XqX7xuWL9gEBc7Z+PkdyxLJV8LyOMEjxR06Dv+8oMUb+qBrqIrKib67jJ1cqwziHexJi7SzB38kSM+tM9cCsh5Ts3CARmGKLIUHlpjHA1vM2y4MLzr6in7syfVH+bDe6bigW/VSTKiNcnRoZtrOWHmn1968uI1uIInIA63kDM8IiMISSMxGzDW0ox+4aeRVriA22Jl5DokAAQLDfV0PUaU8iZGVcEjN8bllcl3Y2NHgEXC9qgHmpo9ETsvffeQppaAkcazZkzp9lthg0bJqpZewkYMXToUInD6GwC1m4SlpmazwnnLD+yrvrll1923pFpaPQQMKqB3YTVA+jHMkVVojLFEyQJFrO6SIgYgur7uATMY42qkiI9WFSvuIiCxo7IbANOnEGsKpqCqBms4iKqhxgIr1H7Z6AqwUueaKl2yAlaVB01kiiVo5QsIWIpNe+R1zmgW8z4JjDztmKMv65UTNwsRQYrDXx/nyIfXP/jbcXiM6Jxfd7kiTLqhiqUUWlg7pWKjC288ArpxKM646stY+4pgZlQx2fn2Fh0wWSMevxOLDz96kZLkw0JGJHpX6IaVg8ZY+JIDJ36lYBmIQZ8ztuM+2VZFVIrxDRHEWJf4etJYANBspAD2T2yxWDdqINgpSkKmP8Z2h5599VOqmQa6zFIynupitUWnHXWWaJgcQxiczj77LNbJGH0qHMWZUfA6IpJkyZJo0Bb5lZ2GQljUOuzzz4rQy39mUmcnUVWesIJJ0jtVkNjXWDXo+5GsMKGEzKlJMeTqj9g2v9blcyzZPh0W7DLMfdItyFh819JtiI8qvznSJwEVS2ieiDLh5AUeprnY4XK/2XQrkDCxZJR2DPMM/OrRs2HNFiSzOXAbEsUquqhHF+kypXyvBFDxhgphUORr1SOCzfsIFDBDkog5ZWg/K7zQKVSqXjy9h9nZzkIr7Sw8bU0cpMYughI+dSVuYIM9px5VbF4quLRNALlqhZJ5cgnTELOqlylQl07sVbRIgFI5dpYdMVkIWn+cZCAMarCCNtYeNo1rXrP2c0396q1CVGmskZy2FqMe/4WOPMVSVUvSL2mgEdcGVTrm2PogZtxR89Rw0hwWQpmyZdKoK+GpfIdUcN4/PzcePwk2n7Y77we7G/T6DhcLzV/fcecOXPEd8UORA7Q/s9//tNu8sMoC3ZDMoLi5ZdfRnV1db37maa/evXqZvdBkemVV16R42FGGSMyGh5ve0WodpEwBqexRXSzzTar7YRk5wHNabyP5jUNjfZgt8Pvru0AVP4q7x+eCor3lKYMosXw01yPNMhAapUMz4WeKypJvpolSgH9WhVpVIwOiUGbuVt+mCof45cKSZp4YmOEBLsHuZ7eK64n2eNJkOoSs7zS2UCgSpG06iGmzF+UDC8a3Q3vWFlKZPq957VK5nE0kSJZJodvO6pMxlwuqjVKKVOvm/4fucxxYMZMIGUgne+ZzFiq88QPnqxTBWrb5AD1QoykATdIr5iJxFAaxLz3MWKIohIfxQGSagdU6KhiMVuK8AkY1adZk9cmKDzeuZPUSX/kI3dh4dkNFCwDrSZgREMC1lovWJOYky1pGVLqTanyLJHOUiVZITIhCDmVgeY9DFQfWSol2VLfbX4PlSpJwqpKzapkydcUWtOzVbDRz9yG+Sde192H0cvROTlfPd2Yf/PNN0uQKhWx+++/X7oRmZxPQsbE/LaAhnlyFS433njjWvdfd911uP3221sc1H3QQQdhm222kdDYhg0BTONvLwlTg+La0TbKg2GraCY4g4kH0tr5Sz0ZVPbIdvPy8jo0IV2j+RmKJEl+YGmAxItp8Qw1laHWaaSz2c1GBciS24miICKrUkLGGPdgJpiTpe634o50Jsp9HMFTlhaCRrO6lKCS3rzFQUEVGcHSoO21+Kc9n1UO1wGJQqVYETwm/1+JTdKUYscgEFpDFUh1rBGBKlUmEpAIFTgIr1YBrELavKBWduklilwpB7LkpLxJLuxcZfYKlFmwsx0EKukDYrcl4OSlhXAF1gSQzqfMxrqEASM7DVQE4ZpKMXGjtmxnpE0gNwXTcmGaDuxlUfELcZF/9dw+YcKlkds2pMw48qEpsKosIT7i0fJKhCMfuBuLfqNKir5pPhNbvHwdvjv8ttqT7Nhnb8XcE65v9qvf1fEQPObI8gBSeY6UbvkezrtCkRqfQPuXUroNALNu7DlKWCZG/t+dCC0OyTHKd0h8hl5N26ttixdMR1Ks1+eL4447Dtf9eQou+vKPHd7X0ztfiVMOORbvv/8+egP2339/KT0eccQREpTKrsnWRkLws+Hn0hQ4/aeqqqrZffB5SQbpVWsrCewSJYwtn40dNGW+hvkZGho+9tr3TtgRldAu/ihTeZ44XsdwfTLkSgYWFadkbkhKf25IJccn8zns2kGiICAkyoo5yjMV5hxER4hYIKYUIO4n3i8g5ylJkheypRLlCRrXSbZI9mTfOWo7HofLrK2UMrNTKZHRQPQ7ZblCtARUH7KVr4hlPXqO4kNsBKpMKQWmWBKsIVEkWVJkjcoR86kY+SAnf98bluvAzWb7It8QIF3IkmBAno+PIdmSclNckTKRd0i0UgbcpDJlByotpAd6eX3cTcCGuTIkShjLlU5hWu0/4MAIOXBrAmrfLB2SgDHXC66ULonME7pPwOR6IzMIScAIX+UgAYv/PBpBw2MM9K4NqfNtbPi3mzH7111HwPZ553Is/EyFsgqBZWTDalNKqSz3JgrU58DyIz1jc6+eKKW/nopFZyhvHYkxv7Mk6Pye8HOharng0p7naWvt5/TOPvd292H0ze7IXoY333xTQuKXLl2Kyy67TIJaW0vCSIo7SoyphL333nudTsDaTcIYkFZaWiozJH0yRrZ53333tSk8TWP9B0NMldpkwK6264JIg4aoUiRQPFGmwxaClcxyUH9pWH5hSZKwko74ughRunhipdpVYCFUzVR6RcZ46Stpom4wr0uInVLIZOj1mFCtL8vJUrlKBJUtIp2jFC4qXlSsUnkqkymVqzKZqEbEChxZl/BKfiREqQIbVrUlhExIT9iFbfNYeJxpIVDBMhOpQkeIkcx/JOEhYaJ65ROkavVP0i9Jih8owvWWUrqoZHlwo3Scu1JuhGHKY0UhCbEWasLJthGoDogiZ9RwrBHlORMuS5gGFTBV2qS6FS2swUYDVuCVPTr+K5uIDJ0Pe+m4WvK119vFeG9f1X05+9drlwRo7udr7oyE90WfDJfPie8xPXKMpPBVJCHD9NcZKjU/WGVgo5tKke6hKf+ZUGrXFRLlwY5Iorcm4jMD7p19dBdne9AXPGGZgg9VKJYlqUIx74uDvF999VU0B86GZEfjkiVLpHGQ15sCt1m2bFmz+/vmm2+klBkIBJBOZwz87S4Sdumll4pR7ueff66d68QuSRrcDj744E49QI3eOTfRj1Hg+d5iJS2synp+dpbEKGSbtWVBUIEKcNA0Te2uxDIQQqoka0v5YpQfSw2nJoETr1XIJ3IsO9V1J3I8Dz1XhshhQLy/ImL0btEQT2M2S4VOmKVQxgIowkWlit4bJ0910rk53gmaHCaPhI4kyRGDPMlMcGVQhnPbRTQZcdgjlQoDgRVBpFli5DrHQLKfDYQduCxv8u8o15NUUc1i0GbaEgWOBE6yWj21y6CKlQ7CybGFTEkZkh4yclpKaraBdI6N6MAaJGJBuCRXVMKCDpLSmsk8Mb4H6jqJm5CxoItgfhzFW76FizZ5HzM76fO/7Kvj0C9YDWvIv2vX+QSsMbDbcs4VnaPmsFnATSkCRr9UKofvtyoVC7zIh0gZB5lTdXXF/M51PR1uyJHX5ziqe7U3oy0hvBp9D+PHjxeR55RTTpFGP3rBOP+ROWGtwYUXXiheLy5UsXjZFFrjCXNdF/F4XMq3NOazhJkJzqNkmbQ9aNefnlmzZgnp+vWvfy2GfB7g73//e/ztb39ba4SRRh9Tvag+cKxOVHmzSMaYccVkd5+ASRcj1TEvQ4vEieuZsUUC5WdgMTOLt5mlJSqU+HhcIW5cx0vl6WFJ04YdpBJFhUmdcLlfRjdwm5zFKjSVJ2RmdjFfq2oE96XIjknPWI3yaIn6RILlpY/DV7SyScBcBMstpEioGAXBcuiwOFhbFSUqi3kBBoygo7xbPLysNAIFaaTKw7CiadjxAIyYBXDmYwUVKs/aY6rymRAvT/WiT0z4E9Utlh+pmvGty03DKAsCeSR2rhCueHVILvPzq7BmVQ5sPgdT1ekF43MEbFHBormq7Xu/DWbi90M/r1cq7CjGPHMbXluQwoyjbxazPkcY1d53d8la5IEG8zmeIZ/KlCLaiii3JzqCnysJlXxeIVUSJsGV74mjDOxsiKDCqVrNIOny0mHaw2FVBFQ5Oj/V8aYFjd6JPhJRcd111+Hoo4+WfK+PP/5Y1h111FGtzgm77bbbMHXqVEnIpxLG603BH4vUHDjse8CAAXKdo5MagiOV1ikJI0i2nnrqqfY+XGM9AYdVhytZDgQMhpcGODDaEjVLOguzmKulyJR4oMgLqH6xgzFArxVnIiqSQMImcxXDKiGe6fAc+yNij5QwWaJUHYkqeV4NxlaeLuX/IsFjy76M92FwKX8TuEDlSK+r0lPlSM7YbQiWddhRme95uLLoT6NixvKj57siOaK5PqEIYyrPRjA3gdTqiBAsJ8m5RGxV807kFLr4GDIrlhtrAojmxeA4phAwUPXKTYmfK51lw4h7pdYsGwGqaiRevsleKrmKmIpnjs8Xk3oazH5J2Ak+t4VgVgxJ20AkkkJVdQTWqiDsfikYlgMzwLFKym82dMgafLzFP+T5SL7+2MFZhqLchVyZEUkmOe/EDC9ZBgEjGlNv6JnzyRm9WT4ZIwFTfqdJ9WZANhxN1LCkybdWPuMIO14VIQvVKBFQlSS9hoa0+oFAJYyJ871hzI/frUo1TJo4NPokOqMc6XZCh2VXorq6WjgGS49cmsJ5553XKAljvlhmxljDvDHGbJFUzZgxQ0SklkCu01V8p90krKioCFtuuaVcNgTZq8b6DeZoyVDpclsULpYTnbDya0kpkQbziCJa5CIkVPx3z/tl3mHAQLiy7rFSkvRG9fC+mv5qTiLX+/4e7ouGej4vn4BqG7O6eFsUJJ5fyWfMjPBSnnyDQHxQWp142dLvganjNlWktNo22d/rOoykYVSwTun5sUjEAvSQqVJeMDsJO8UnVATPDNtCcsycFNzVdPJD8rHM7DQCQRvJ1RFUVUbgkDDBI1IkRX4SPI+Tie4xS5UvQzTP23A9cifOM6/MSQJmRtOwLAcpRvfzeMM2EtUhhLOTQtjkOYbXwPVmDw0uqsBeg2fjtoHThHjV2eU7htwFJr4vbb6j0J/NyK5EvkaSq8zEfKqPVCiZ08UyMDPBfDLm+51IwHzlpykCtsNrV2Ilw6wDDLJVgbokeCRi8f4OQuVUYQ1EVqqmCSk3ew0VXEjaegPY9cm8pM6YzanR+0Dy1Dlji9CjccEFF8jSWeDcR2aFMVJr1113lbwvDgFn9tfhhx+O7kS7SBiNcnxRrLU21iWpSdj6je1PmSqVOCFa4OBo5m951R2WFhOOEKNknqkM8OL1UinlzOVKZnPOoYuyMQGEKqnyKKO+ynNS3i/J+cpVnq1glVLQeGJV3jEgybBTKXWqRHkxscvjUGuiZ8I4s5Ok9CTREF4eFlkNy17sngs7okSxdGhEbKCKhiEbJjsRaXwPOjBplh8Sh10RktuhkI2aX6JAxBGiZJAU5akyPEkbyZuUAukDkxfgwKli7Dkd645SzuTNUl41l4+h8sWDplKTNuCk1OO4vfjOshNI87ksF07cgpP27qciFrSF7AUCNhKJAKLRJAKWjeKN3sbJuavwZSKJbcOhdpUdz/n8VLz13y2RtUTNJuR798Pdini1RMAy50lmjgUiAWP4KyMhSLjoCWspKLWl0tuazwfCoNIlXrq6siPf4vAqeuZIyAzhsiRgJN9UPv1GB5/49XSwI5Kmdo3mkdkUotG3ccABByA/P7820/Tqq6/GH/7wBzz00EN4/fXXsddee0nnY68iYXfffTfuuOMOuWw4TVxj/cXW55XI+B7f3M4SIxUuxkEkc7xyDj3f2UyvV/4cPwfMz8kS0hRiyVApXH6nIrfnbapbVKYYCcFSJEFViyZ6chR5nEQwSEOgEEAZ68J17BQkkfNsUyRdVFf4QLPGFFImZnfvK0sFxIkwIkKtcEmceFKOBaTcQyKGmPJsOSRgYdVtUPMzD0jtw6y24AQcWPRseSqUbJc2hdRJKZGPpS8pLyX7C/WLI1kRhlVlis/MqlS5YPL4oCMeMIMlRJYd5UVbcML0c5liOpfICo+ARQtjSKdNhEJpOFzvGth84FKMjK4WArbSrsYOGyxt1+dNxerDlw0suLUYE64oxY93tT1HiwSLZGfG7fUfm5nJNcdL4G8vWIaE12TBsiK/GzLdQLpoVVk5WOFnxalyNBeZf+mppb0FoiJe3DsIo0bXoBXVM40MbL311rUzHy3Lwp577olzzjlHOiKZoL/55pt3KwlrlxGC7Z5MxtcErO+Qr+1O57xAdVuIlddsx+7DeKEiXXKf5c0rFBO0MsGzhMjhw+xIrBmoFC5GQJDcMDk+XqT8Xiwliv+LUXOe0iYjfKhqRYDYQHazqXyuWuLljfPhHD0+BxUOGrKpgvB4XapbkkivyIsElnrzF5nPJcnpSVMRLpKfhCnkiKTNz9HiYySpnt6tuKmM85QCqViRfLHMuCwMZ3UYRsqEUeP9tqkMwuF11/OolQXluZJlYRjcHz1n3EfYVSqcbw4vD8ItD8Eqt8RUTyJGQz39XaKUCdkCrKw0wsE0xgxchcF5ldh31Cy8uPODeGbnv2DKVv8QJWDQ8LYTMD8zi4oV1csJV5a2+JeCMQ/jb1i7A5IEiwSMyldXYPTTt6tyrgWEyhVBl+8DVa+QF2DLdSFVlub3ht8Rwv8uNBw43pPR2NzNvgR/yHxLWF9VMMkJ81LzO7K0Z040E+wZSPvhhx+26jHDhw/Hiy++KOHuzPe69957uyVHtLy8HBtuuKFc56jFRYsW1UZS0E7VsNOxVyhhDEnjhHNmZ2is/wSMEGUqASRJqCwDAfFgKbO7JMKzWZAqVa3ny+tOzFV5W2Kij/jDptVJkEpEeJUpERG+L4op8uIdk+gJT03jbVqt0nUdb3weNdDa21eOipewoMb/KBUEMBnpQB6TNkAOIz4vGslTimRxn0IoLS9BXroQTRGgmO3FYFTpSCPCDqzVAeUnosKS9kNUFZGix8zhrD8O13a82AlbeZEIeY60AYPxEMwTsxwYNPvzNS0NIc3uS0ZYsERqG2KsJ9EjsSMpk8eTSIZtBHOSKMqrwXEjv8Kxed9hZCCnw0Z7Yvz1pZh5pTfU+/pS/HBr69Qvqoszm9nW8ZsWOhnGkoj6LgiBd2sVTq5jBpif80bwfhJ4HqsoZWmjwyqcxrrFj3fWfcdGPni3jNnKBAfRc1D9egvaF9axdEvv1IMPPigLOw0nTJjQ4mOoODHGioSHShNN8CRktDD95je/wbrESy+9hHvuuUd8YDwWZpwSJIS77LILrrmm9aPVegwJe+KJJ6RT4Nprr5XOhIbdBX7tVaN3Y7PiUsTDLPGwg0x1CapIBzXjkCCpUuVDps0r4sQU+trxKkb9AcPyGK8kGIipEpH4ufxcLI4M6qdOnKKURZV5WiXfqxMrVTRROTxyxedP5NkwZCg2IzJIFF2kBqhRP/KcaavWByRxECRqjIAIeaSJx8oSn0e6WMrk/TwOPgfLhWaZR8D4GImn8AgivWerLRmuTMWM8RZCDlm29cqgEh7LjkmqanGlvDGnSw3ZdpHqn5YMMBIu2ZbdmYy84L68Lkk2ALAEO6CoAocOm44T87/A2GAOapz2+b0aUxncjBm50lnqYcLk0lovWGOgBytzCDaN+Jk+sOZGFI27Q3VDthX0RrlJRaQ5pYCfJa/zOyDvK6u25XXfS9Xdqt5v3ukruxq9B4d9cBFWxrJRGQ9jSN4S5L50PaYfcWvt/c0RsCu/ORpfrRmBeDqID/dvOrJAoz5qamokooHYaqutWvX2HHLIITKrkbmhixcvxk8//YTrr79e1DSSnjVr1qyzt3np0qXYaaedcOyxx+KZZ56ROY8EGwtpqWLeaUtgQj9HJzUG8h+qaZ999hmmTZu2bkjYn/70J7kks20MZMsavRec6ydqE0t8QSpWKvZBdSNy8LQKW00UGLA8s7aUDT31SilNilDVKlLsQCQniiqfjp2tCBWvM9GcJ1Ai3h8IVTDfS51QpRQZpWfMGw3UX+2LkLmAcY8gUbXyzO6SjF6gRrvUzljkiTnHQYrJ+CQ1VLtIeHjS9gI8GbMgZnwpc3odnlmqK1LKWiFmman7TZdGdW8QdJUlqh5JnE2FTNzfSt0jpOTIx5FIMcpCxjWpcUZiyuc2JH1ZXvaYKGamkC/mirEUSTN/Tm4cuw6bj5sGv42BVjYSbrhTyy6+ykAFTAz4GT6uTALGsuPMW4rrkbcfr65/8vNVKR8b3Viq1LJGTpLtIWD7v3sp5n3iNVp4RvxQmdekQaLldcsKSfbK3LNuLsaYKSUqrDefn2mbn1ajm3DrtEPxQ9UQbJk3B1dt+rqs2++r4/Dm3r/DXdMPxCE532OLUUua3QdL9OsDOqM7sqttZexAnD17thCwzEwvJuDvsMMOYohvLUzTlMwwkiZyjq+++krKi8z3ytx/c6Aw1FAc+vzzz2VpDcaOHYvLL78cw4YNw6pVq4S49evXT6xZq1evlrFII0aMwCOPPCKxGV1OwgYPHtyeh2n0AlDNcBOqvOib6en3CpUp/xW7HOkJY3mQxINlRqbNsyNRGfBVmruKfqgrw5FImBkqC/07Yoo2mWqviJhfsmKSOT1ejA3gfWF2OBZ4WWQcEVRo1+Z32SxtkgRy9qIQKgMYlhBjPOMdzIqAKE70f4kqxWywODsavVFB3AfnO/I4vU5JXtqcI0mSlp9SmV/VAaXU8TlIyDj4WkqFhhA3IWRSzvRCQEniqKCR1HmhoEK+6PsijyNplJgML7qDBIzvF8uhJJJRWzxgNNwPKyzHBSPex/aRn6XsCGR3uueFxJufAY+NZUV+DxpTwaTck0HAGpaI/MHcvvIl5c1bi4UAdSYWfjAKNpXHlIqYoILH7yDBkjavz7xhohBGknVuQ9+aY6vGEs6S7Oxj0ugabPvq1fiirAwRK41liXw8MWtHnLbRpxifpXw9JGVXeSoZx25x4Lk/b3P8CzdJ1/BWg5bgqZ0e7fUfkfwp6SQGRULEcYOZYJ5WZwSuc2xQw3R7/3Zb+INlWXjnnXcwbtw4EXeY60USRgI0ZcoUMdm3BJKjkSNHNnn/woULWyRznF3J7LKTTjoJzz77bG31b7fddpOkCKpkOTk5eOuttyQdok0kE+3A8uXLm118/O9//2vP7jW6sfyoSJcrSlSiUKlWinApEz7JGdUsKg88sZFI0Xfj52+ROIni5V1KCY5m+4iL+EAHiUKndo4f9yENhWLwd2U/freajJOhopbkjEY+KWRsj52fFqJComQVJJEzqAp5QytROLhCbpuFCRTlV2P00JUYOnw1jMFx2dYsSsIuTCNYEIeRTVlOlQalPJjLmqrqSDTykpLxJd6r7DRcL+RU+bu80qbMIlTHRhIn3jISOoIvKEfNipRSIkuOJIgkVZwZmTCEDMpzc8ZklqOyyLzAVsLKTmHEsFXYcPgvOHrct3hzk1dwTE4FRo9YpnK+OomAcSC0D5Im5mf5SlVmZIRPwDadqPw2/J4QJGokNpnwydemk9T65nxiRGNm/pbAx/B7xU5I/lDgZ8fSIkuS/E5SteXIIm5HMh9eqT7DRD9bkbakoQlYD4+XeGGOKnvt/uYklFdF8dLuD+CzT8bjvm2ex6M/7SrE7NH5u9R7nBCwx+6qJWDEzGNuQlVZ1npBwDobJ598shjtMxfGN3Q12lIpO+OMM0QJoxJFguOD6fQFBQWtKo9Smfroo4+aXE4//fQW90Hv2A8//CDlzEz7FR/P8uaRRx6Jr7/+Gg8//DB23nlntAVdOjGNdViN3gEOcY6tcJHOYbaWPyzblRObkKOUgVS+K2GXPgEjUWLYppCmXEWaqFrJ7EUayyUsk4O1vQRzEjV+gT1FTGV6MaFejeohWCbyfVMSkErSxdJhrrosGljBSUEMuZcE+oKsGEKmjepUCNVWGKMHrELKsUSyjwTSkpk1dNBKrKzJQqUVgcVSXzitfk2G0xK66nhxEm6MHiw169FgnASVtEgaTnUQFklcJdvrgDQHcqfUqBsZb8TsLipZXgmOCpZ0TXqlSNfxCZryjzEWw+D2FapzUlQ97idsY8DACmxUuAIFwRhuHfwuUnBhDWlfxERLWHDZJCkTcsA3Q1Cb6xKkGjb9bhVV8f09axO1hpg+tbieMtYUGqpqLWHn1ydj5WfeXFEp/Xrds1Hl9xNVlUZ8t+4Hg192jPyiysZzvTFJGj2LeBFzU1WocZI4Ztw3mP/TYJzyo4GxA1ci79/XIG2XYafXJ+O9fe9ucj+Lzqw/pWHjf9yIGUd3PbFYdzA6zZhPX/cll1xSb13DZPn2gmJMw/O/P/YnU6hpTVcmj5NzGxt6z+fOnStlyZYaBG+66SYZY5QJKoAcu3j22Wc3O9LIB9W7aDTa6H1c7yuK7ARl80Fb0AvG1mp0NTgWJmteQE5kykiu1B1pUYQ3d5AlNI4KYiK+qA3KwM4THNdJ+TLpETMansWQ7yIkZUPlB/NPxsx1smmA5wBpdrCxpEjCV8NSY93MRqpapuFKMnx+fo0QrlgqiKJoDQZFK5EbiGNWxUAETAcFVgybFi1F2ExjTHQFCqwaTKsejrwBcUTMFL6uGIFxI1aIMTeWDmJlVbY8Lh02EQqkUVaWDWSpsmkgKy35XpG8GJLJAGyWU70ZkLyfMKl20TzPEwhHEdF7H3ARiKS8JHuoLkjPNyYbypxLr8OJyleOKokGBsQxZtBK9I9UY+/CGTgsZ654vqwhLRtG24PMxPqGJTmODGosuNRXw37wCFhr0RwBaw+WfzsIjhe8KuQ9oci+lKS972atmsrPkzPLEwYCaaPFQFiN7gPV3e8WDsMWo1SJsXLJSOz21amIJ4NYmsyHnTYRzU7gu8ObJmCNBbVyhun6hs4iYalUSrxMXYH//ve/mDhxopQlaYwn9tlnH6TTaTGwtxbJZFKCVhsD51dzuHdLYJRWwzgtks0HHngAe++9t5QS//WvfzW7D8ZyMNyVSuEf//hHUQ3ZXXncccfht7/9rRA64sADD5SGxbag5w9M0+hyAkYFJ1nIRZXPSIZIqKSrLKK6GKmCpYocJPo5taoDlS2SMJ+AEcrLpYzu4p3iyTDHEdWLpmiGd9YqFSRtUY/IZTlIDU4iwGwsPi5sw/bCSrP71WBQbiUKwzXYqPAXbF+0EEPC5XBcU4hLxEqJEjYgVIVfErn4sXoIPqscg5RrYXrlEHy8eixGZa3GnOoBGBKtwJCsCsnV4j6joRQiwTSGDChHVk5CRv/0L6xEOJLCkNxK+YPH6xz906+oCoMGlcsAbNNip6IjKpoZsmEymDXgIFXt5eAEHSlnMtZCSqeFCSAnJaXUYGEC4aIYonlxFA4tx66j5+GW0f/Ekxu8h/M2/ghDhi/t0pyj5rKmMglYY6XC1pYPqZxtcVHnZoNxBBJJFkcQ8TspUw8iSo31Yyl8HyMh308SNad51U6je0ClKxOZxvrNn78EZatzpJzIf4MLT70GNauy5Dvgg6VwzhL1c+18PFtZiPV9gHdHl85OKGbeFkndiSeeKLdJambNmiVNfFTASJhuvvlmSVagsb21eOWVV2R8ET1dvhIWDodRUlKCwsLCDlueSBBZ6mwJ8+fPx6mnnoqLL75YOiG5sDGARO7WW2/Fq6++KmrZn//8ZyGgbYFWwvowZBAwzVZpA+n8tCg3LD/SOxOoZsIlJP9KOhWThoSYUr2SWAdv3iLVBm7rD+D2TfckazRI1ypqVCSqVZ4W87Coosnj2LnGWYniuaIa50cyGFIKJEiUQpbaeVGoBmtSWaKQVdshBE0bVakwhmWXY0FNP+QGEliTzJLL78uHyGPi6QAqEhHUpIKoSSiSZJmOBJ1SVatMhmV/VNoS6QDClg0zGsfisnwU5VUjkQqgrCaKrHASlbGwzG20bRPhcAoxx4TJIdmmi1QyIN2MhF0TEGLmskEg4CCdsCRVv6h/OcoqsrDNsMW4aMjb2DViCuF6Aj0PjZUK1+qKzDDlZ6K5OIv24Pj/nouv3lLzRMVLyDGfjvqBIEG9DO/1SRi/bt4PiNnX69JjTwU9jo2BxvoFZ9SNqZp/kqcseIPXR/3pHkSWWph5U+PfsZM3al3Hm0brweiFjTfeWPxZXEi4iOzsbFGr6PMKBAJyH0HFizEVJCmMp2A5kYb2yy67rE1v+9tvv42nn35aorBIeqhckehwfio7JrnflsByIbPOMsFjZZI+jfYkV63B3/72NyGFO+64o3RJrlixAl988UVt3AYDYPka2wpNwvooNnjqdoQilYityIKR4xnQGcZaqOIYUkVpGSjNkx4JE2MgSNJ4dmOGFr1bJFEkVW5CRUgoUuUiUaS61uTHlgp8l/U090vgKEt6vJ2lypBiVLfqOhzp/aKClJ9Xg3FFK+WXW2EoJoTLgoOw5aA67UX0AzhpyCf4+y/bIWA4WB7PxfzVRTLCJyucEu9YdiglRKw6rggYyRdLiUNzKrCsOle8YxUMRMu4r7wmitxoAsm0hZRtIREPCnGjD43slKQrHgshFE7JL/VgwEYqZSE7KyHbpaIWqisjCGUlUZATk3UnjfwcFxX8JKRrLoDn0L3w5ze2BJrsSbJJrDKzwJoiYF2BL9/dWAXchpXCRbIlEShekwe/cyxtMyCYYGmyNa9No+eBxnoSLZaa/YHtVLtcL9g8uNqUho/Omg+5w0lT8dnTzc8mXR+7I9sCxkM0Zqj3y3xUt0hsMst+VI8OOuigDj/3tddeK0SMmWNU3Ejq2IHYsPuyKTCX7Lrrrmv02BlA+9prr7X6WEj63n//fXQmNAnrQxj73C0ylzAVC8IwHCEWEomAupE+EvFQkADiAUXA2OXIkEtvkLQY7iOKcPEkGKwwlQ8sZiBZaNd2DjLvSlLsE4bMZvSN9jyB8vEqskEZ/oXIcWwPyRkDYXPSUhIcnluGgeEqDA6XY3hoNf5XMRb9gtVYlcpGv1AVEvECLKnJxz9WbIufq/KRdkzEkkEhYFSrEpy56NDzZcP2LvOjcUQCKVG+coIJDM1xMCFvGVYkcxA0HFHXbNdAVSIsnrGVZTnIz60BGBDLRoCcGqRJytIWAgFDSpnllVFRxtiVSaLHl7bn8Lk4sd//sMfoebXv/ycA6ttguxetJSm+yZ6m/B+6oawnI4/YlxF21WgiEi9WqiXiRJ2Z2BDiky9deuy9GPXEHSJlLjz9itp1jDmxUy7sXFc6XanMb3JVKbaQKmTL38dNXrwRPx51s3hR512hlNEtLyzBt3+aiG3PKMFn/1dfLd3xxKn49JlJ67UnrK08jspTS+iKMYZTpkwRPxbLmw1zvjLvaw4c1v33v/+93joqeUzzr6qqavJxZ511liTsMx+sJbRl2y4hYWTITJRdsmRJPaMcuxI0egZ2eO1KrCozaLNHVl4ccRIwpoaT/PAfkAyPphPSkG5A6fhj5pUXuEpVrPakZygVy+IcRXIz8ifOP5TEe54kHcnjourFTkD6vNIFKqKBJ0+JdSDhi6bhJCw16NoxEMhJIhBwMKSgQlSvjXJ+waZZS7A6nYNqJ4yd8+bK9S2zF2Fxsh+2zV2AcVlZyLHiSOQHsTyVJwpZzA5iXmU/VCdDGJxTiaWVeThq5LdIuAEMC63B0mSBzE/bIXsuIkYKv1u8P/bqNwtzYgPF7D+zfBCyQ0kMzKoUQjY6bzWiVgqzywcoPwX9YBwKzpJogmpYWkqZewyaUxsIyT8XD6D3Y7PLSvH9fe0z5XcGtnj5OlT/qMqPDAommCdHwz9JoTQ58PspsSjA7DZ2W2r0HIz64z1AmfL3jfr9VCy8ZJJ4wFJpNVlCOrRz3DbP+iQBo/c1sMyQeJXIKhe2F4X15f9NxG6H342PXq4bf9STCVhndkf2BgwdOrRJYz59Yg3LjI2hYXRWW3LUWII94ogjWtx2u+22a3dIfaC9abinnXYazj//fLnNFFseKGu2v/rVryRcjaART6N7wZPYiIIyLFgTEnN5dTIo5bXc7DhqvPIcCYVDAsVLU7majWoabLyAUaas0tvFGYZBZloxmEmVFpWqpTrSqIIJcZPZjTSUGTBCDtL82UXFjfEMFLt4v/dTzMxOS0kvGk7CMl1sN/AnrExk49iBX6DArEG2mRCD/YjgKiFMC4wBiDtBjI8sxYp0LvbLmY5tw3VDYVme8NvdG8NKuxrz0iEsS+fjzfLNML1sCO4a8wK+iY/Eaf0+xuexMfhN//fxQsU2+KpsBD47aAp2+eo4IVyHDl2OhfF+WJ3Mwl6FM/HPZVvh84Pvqt33+piK5xOw7kL6wyKYMvDdhZU2pAzFkUgcKi6D3l2VRcaGAY5Jok+NeXaZI5M0ej74b3bcUybsvDQcWiFWhsV0T+JlZzlSiuaPuIUX1ylkrcXIR+5CYJX6uxaooacV+Prhidj+lKmwwwY+ekT7BnsaNt54YwwaNEgWmvobhrIyrHX33XeXoeBdBaplDGPl0hpwJNM6I2GUAYuL1R85mtt4kOPHj5f6LzsFfBKm0b3ky8eMnwdJ6vvPNWFEIspQGU9asNOWqDjxirAiWCRfNJZXURJTo3vkNrsUvdR3SYX3RvA4/W24NZynSL7lwslW8xIJI+jA5BifyqCEowYjaSkRMvJhwrBlWFKRh/FFK5B0LOlc3Dx7MZan8jEoWI7tByxElmHjZzsLFlz8nCyUyAkSwmGBNdgsVImgYSLfrIA1ZNFar731PpHv5L87yH/9/cz3LuviIRgQ2RB/k/92rjdAoz5YhkoFvXgUGu4Daj4lx2n9MKVYypQBr5pAJYwQhTZm1POuafSsv0vfHV4/s4kY8+L5EvESXB2AsTIgirs0AUUdIV4c1i1Zeg3AnLtQJfB9ad1nTYLOmJxpv/PWpdWkjHmTFYFjlzYR72fWbdOL0A2WsHWOa6+9FqeccopcZ4REw9gH5nE999xzbYq7aCseffRRWboannW6bWAdlUyUWRtXXHGFBKYxlZZdCJT98vLy0NvB8DVmgfC1dFWWSldh+/9cJWWynEhCOvuqqiNCwrIiSTGax6rDyM6Ni3cqVhVGIGQjnQhIyKgEipKEUblKmkLCSLRkDA9Lll45kqN/aJ5nzEJsDaP0WbpUo36M/KTsw8pLwk5Y6D+gEgF2HBqudDlGAynkheJS4ts5fy72ypqNaYkhGBwoQ4GZwKahulC8H5M12CRUJzkvTVdhSCCnSyMcNLofo0unYn7xJIkhmHVTsUSbUGn1c818JYwlSo7VmnF7sZA2Qjp2Y3Xm/c7u1NToXGzwu6kIVKlYHMkoVP0/0oVNY75MdnBRa9InRv3hHrE+LLi08dLhmLtLVNhz0G1UPdv8klJM+33T34tdj7wbH/9zMvbd5Va8/d/re8T5gplUk/84FSe+rwZQdwRvHngRTv/V0Z1uMu8sGIYhnZbsrmSHZKani1EVrfGo9Ra0KyeMLZlUvgiWIX3lq3///ut0OrpG4+b7ipqIGMWJAOcPhpVMwIiFAbnVcj07nBTTenZeHKMGrpasq0hWEk7KlNE+Fkf3MLSU3Yt5KRmlw1+qJHPBaErULT4mQZN/yEYoJylEjQGr/QqrkDe4UlS3fTaZiQHZVeKr2rjgF+w/aAZ26zcXxUNfx+TBr2OD4AqkXBO7RH5GpRMVBYxEi+RrUboKg73Mp5Sr1g/3RvdorN9g9teGt5ZIuZuqFn1CnLzAdb4Bn2VI5tGRgLGDM1ipSFd4jcoMk/w5Jepq9FCIdYBKuucoIHFmtI1MQ3CBUfffI2O96hGw309F9k8WIsvrTl806mdi3uSJQuLNRP1TnE/UMwnYTsfdIwsN+bscfY+sIwEjWkPANDofruuK0Z/iDhUvP3CVy/pEwNpdjuQYAbZ1cko6B2v++9//lvWHHnooXn755c4+Ro1W4ORPzsK88v4IWuUSavpLTS5WVWaL14r+K0YqVMXDInsylJQKWVaEifSQ9HiO96FSlZ0fRzIRQFZ2HLGaMIKhtBCtosIaVNaoGIdg0BaClRVKCeFLpyzkZceR168MYSuNrEASaxJZGJe3QtQurhsQqhQjfBA2tgmXYbUDRAwXB2SlYA1ZIn+Mc81ylDlArhlALmdnD+uaxHiNng82atDXxXKT6xEuqmK1uV++B9a7TOXy5O0NnPc6JqmQ8X4SN4YLr8tIDY3WYeyzF3i+Uzb7qFzC8GrV4MMSIj1hCy+4QiY5yGQE5oxarpSjM1Ez0pbviq+U0gcWXBGUxiKWH0nMJdIkpWagslwZrPHGXyXVpZly8d9/rK2a7b/DzXjzsxt7zkfaF+qR6wCM1Dj33HPF+9VeP1enHEd7HsTofg6zHDVqlLwIX34dOHDgWjOaNLoeB753CaavzBFClR1MYvaqAdh04DKJbGCsAkNEI9EkEsmAdB8y/NRmKTIREgI1sLASK8pzEAjY4tvKzYlJtlY4YEsUQ+GAGgk5zc1KyIgfy3AxPKcMq+LZGJO/CjXpkIwC2jBvhRzPiMhq1Dgh7Jo9C7OTg/FLKg/5VgwDrErMSw7EzFQC24VthA0lU/hG+hwzgvxhdSpXZ+UAafQucN6kHXRFtaDiRU8YEV4NMeVLVEqNSuVP5LtCzugNY5QGy5QSCC4Dux1V0rxZhcryvoYnb43uLTlT8aJaJXE4ARIhb/JBGrBWWkLEWYrmjFmWFxddUNfFSNArxnU58yxEVtaxk6y5IZl5GyxXUxN+vKu4NpoiHTXw3R9b9z1gOfLNHqaG9aXuSILDsekJo1k/JycHmaBvjKJQU2D3JIeAMxWfohGHbTPr67DDDpPUfYau+t6z7kK7PGF9Ab3FE8aBxoxRCJoOgpaNfpFqLKooRMo2EaTHC0B+OC5hocurciQri/+I2QlJMkVUxsMYkleBeDoooaUDsqvFMM+Ih8JIDAk7gNF5q1CdDiE7kJTn44igowu/wIzEUAwOliHbSKLCieDw7BrMT1VhkBVClhmqLSUGDa+umAG/k1ETLQ0fDOWkyV6djL3xWDTli1EbMuaK62i6JwnjiVvGaFUrpYPql8SmcKRRVGWhsXOSSf8bX6siLbRhv/txxIe/wdfTR8OI2rCWq1mrMsqMM2avUWonYyXYCCRl5cKUhLjKuqw0AovD4vuTsWnJuvgUftYkcfFByoKRM0/pDH5Zmt+lhh7Bbc8swZePqagKM+ngg9euwt773IF337mm1a9nXXrCjn/n8Q7v6+2DL8Tph/VcT1hm9AM9YTfccIMQJybUc3A3B4/T+sSZjU3FT1iWha+//lq6K7kNOy1ff/11fPLJJxKfRdP9jTfeWDvbsjmw+XDEiBF45pln0Nlod04Y5zbxTRkzZkxtHhgnnvNFr281256KMc/chqRdjVTawrCilVhWnSdlyPLqqISKsrxIclaRDAuZIvnqF61BVTIseVdFkRqUJyPon6N8Yhvmr8CKcA4Cpq1S6sM1EmRalsrCguoiDMsqw9BwObbMWoQjs9mWZmLDoBo2rVAj/x0drPu10pBg+aqXv14TMY16Cf5XFkv5iCdjv/RIspUscMW8zVR8/nagT4x/ZXjCZTckPUUyM9IF0pwn6Z2gCRK18dcphUyexzP7a3Qfvv5+tAQ4c6KFb6BnCbJghoGRj90lETnhpZbkgpF0O4mQmhG5BjB/sWo/y2S+i1CZIeVKErnE8BgWnHIttjm7BGUbecQ9y8WcaxuPodj6nBKYCfVjNB018YmXF9YWAqbRdTjqqKNk/uTvfvc7IWTff/89nnzySfGJ/fjjjzI2qSmQn1A5Y8Xu559/lkvOddxpp50kZuvTTz9t9XGQ5+y11149h4QxGfbNN9+UIZYbbbRRLQljbtjHH3+Mxx/vOFPXaB5bvnItDMMjWgEbs1YNQF4kociVZ74fkatKhn5C/ODcShl0TcVsULQS2YEExuaswPKE6mYtClXLuspUBJXpMLbNX4RfkrkYGi7D1jkLcVjOXKyyDYwL0myjlK06ArZ2TlcmwfIvG1O9tBKmkZngz1T8VG6dQC9m7Qp2zpFwAaEyF1UjvLmRKc/UzRgLL6aC8wWlkTetypfchtdFTeNX1/uNOPauEsy9Sp2cSdJ4EmfoMINgNboOIx+4W31OgxJAzFIePuYQxkys3MlG8JegkCwqnPzsWIq0OLuWxJqfI5u3K5TqyYaNRJErQ+lZvg59H8W4O0pQwbjCpCJpNOn7IAEPlQPf36u+a1//pe6+T57rySGtfbMcOXz4cFHCCCqMBQUFcp2qI0kUI7LmzaubSpIJchPOeyQBIxYuXFjbZdkWAuZvz/FHHB7OVIhuJ2GlpaW4//77cfvtt9dONif++Mc/CgFrLQk79thjhZFmgtLg3Xerf6TEXXfdJS+8ITg9/fnnn2/3fnszxr9wE3YbOlOS3Zn8TuN7yEwLeVpemYMhuZVIuybmrukvA6o5nic3mMDi6gJskLsa/UNVmF05UAgb0+W5LR+/R+4MfFE9BptnLcas+GAJSR0WLsNu2TMx1EogbFjYJCM+oiGBItHKJF0+GdMlR40Wv9PXlyrz/Y2lmHFzsSSbkxixIzKZ7fnCGE9nAd/8eaJ0w3FcFmMNqHixQ5JKGk+wqSx18mU5c/7ESWLM5/gsGRZvugjEDSlNpiVFGPXKlSRgmQZvntD98phGxyHlxGgagXAa6VVRLLrwCllHSERFwEB6SALmipCY8mnaV5M4vB2YnIzgIj4kjeCqgJBtdlPSR5j2pnzISCvpjCWJq09YAhTrm+AwOx0/FVbCkc7Ivfe+A+++2wPVMMlr7DskzDTN2nFI9HQdeOCBMoaIcVic0kPO0VKJOBO83Zqh3w1BnsNpQCxlUg1rWAKdOXOm3LfOSNj2228vE8yJzNIj3ySa51qLfffdV6RBmuV8ZI498tlrKFSXiD548GBcddVVmDVrVof221ux6xvs3qnGrIqB4vMam7MasysGYFzuClm32YBlGJOthl4vTeSLf4sdiuWpqIwCIoaEypFfGAPjWSNmCqvT2SgKVGNFOg975/6AAjOO/bPn4B+Vm2FwoBy5RgrDA/UNkT4aptPrMqNGe0ACJiGacQgZ+v52RcSYBSZqF/9Seb4hpuL7nY4kY1TIaLp3EixFAjNvU4PG3YChSo/Xq215nerJ7OuL5XE8QVMNm3lVsYzHmTGxWM3H9AgYoQlYJ4PzYk0XqZqQELANnrodTtxBYFVQSHNotYVUmnEkKjeMypfMlmV+IcNcqw0EKjl+LSCkeu7kiUKUa8dX2SxNO2q8Wn4K809TRIrlSqqh6TRqCXZD+ErYbofdjXdfUWXJg8ZMxGvzVCzK+jTAu7cYwcvKymQSD/HXv/5VckmpfNFwzwHeH3zwQbOPp1J2+umn194mcWM3ZOa6r776CtOmTWuR87CcSVx88cVr3c9jW6ckjMSLtdiGBkTKf23NCZszZ47Ue5sCw9oyQQJWU1PTbEdEa/bbG3HYBxfBQQwbZK9CjpXA4niBzEgcma3e843yfsEuubNloPUWuUswLFKG/sFKbBBaiaGBNXBcE29VbYqiQBXCThgDAhWYFR8iBGxocI3MZ+RooDHyrQjgssIF3jO3PJ+rsbKif7uhD0xDoyGELF1Z/+SYmYJOpYwRFJwPyU43EjWZ1MBOuoRSPvjXjIoYPWQcNE5ilsxz1QBwL1XfL03JCZuJB44qWboxVxSxH25RURjaM9b5YGwEIyOcyiDMPDW5w10TEm7N0UThlRYSRepShUKrQe3schTi5ZnrU57KybIzP7vEwBTMSn6g6jEk1+yKHT21jjzNvbp5NXPzS0sRLnOFxH/057ptexIB64u4OIPwUEjZaqutJAqL6tgLL7wghKo5HHPMMbI0tt7Hdddd1yIJI99oiXO0F+0iYa+++qp0K1x00UW15UjWbkmYWppo3hBsHWVZk/4yTkRnmbGlaeUsQzaUGTu6394AdixukLMaP8fyMTRajqDhYLuiRRgdXoGV6VyMCy/HzPgQGQPE8T8sKe4UnYu5qYGoccKYkRiCIcEyzE8MwAn5n2NmaiCu7vcDFqRrMLbWTM+/dEFUOfFWz2NsCZp8aTQFUayYA+YZ5WUoN71bNNwnlQJGovTDrd79k0uFVFF/l6ynKjXfUoz63kmaeVNUy3jCp5rC/dFvRnLFUFdGWZCs+eCJnISMJUmB4TUJeB41jc75AfntHCCYl0T6lyjcVWFRIZnRRaXLqjERH5lEaGlQjSvKUqVEevTMhIF0jiJdvgI68qEpCKwJIFlkwyoLiLl/wWWTRBWjCsbEfO6nNdjmrBI4CRdfPK7I1+6HTsGH/75Srh+46TV4ffodPesr0FtkrC7AL7/8gscee6xV215//fWy9HS0i4RNnDhRUvIXL14sbaCU8yZMmCDlSCpVrQUJ3OrVq6VG63dZMjSN7aeNgUM8OSKJuR+duV+CJc9M7xnryT0JB7/PXwQuAoaNpBMQJWxgqBIrUzmYERuCgaEK7B5dKrMVf7Fz8VOqH7LMJOJuUIZf/5wqFEWMateArAr8p2ozHJzzPT5OZGHHcBjTkzFsFAzVRkkws8tHUwSsoQlfQ6M98FPxqXKhiuNq6u7zM8JIvgjGC1CxkuBN8Qep8E3OmGRUgcoW45BmL5yT47ZcVXY0KxVBY5kzNlB1W9L8Pfva+mSL5Es68TQ6BfwbMfq1EbW3abDn+54q4AcEBMsspPMcBFYEhWyxnGgmTaS9WZEuI0cYP5Jji/eLvj1GVzDMleRt3hUTRWUb+ehdSKZsWFVmq31TW/y2FBVDXWT/pDLEvv3TRKSy61L2exwBg9FJxvye6yubMGEChgwZ0qpt2S3ZVERFV4BNiYcffjhGjhwpz/vuu+/Kss5JGJ+ctVb6wtg2SvMczfpUqJLJZKv3Q9P9okV1A5ifffZZeUEvvfRSbUdEJs4++2wJiWWbaWfu1w+g9bs8expO+/RMrEq4yAkkxPdVFK7BjMpB2KPfbNTYIWwcVd0f81IRLEoXYZ/oz/gIppQbg0Ya2UYKX6QK8V3NCOybNx0pNyBKWbbpYBM54QWxaSiIGifZaJ5XQ2Qa7zX50mgvSLwE/tB3L+crWK0Iln+bXh47yIRziJJllqlSYqKgrqyoVA9D1DNektj5viLGHLDjkkoZt01z1GlKeccagsGgjDSYe3nnmfEZKBostzD3yr5p8B/zwvkyAYFjzdJVARghV3Wr8kPmZIMsJe3YuR7j5mrLhUsyVmPJd0E8XpYrpUka+c1qQ9al85TPddHZV9XOlCQ5W3T+5NpB3T4yu2F9WHFFwDiDNOBFVXzyfP3UfCpjyTwLnz7TO7onezuuvvrqVgeothTWmimyNMZN8vPzRbRpqbLmly3JEehHp1edkVzsmGQH5kknnVSvSbFXh7XyxTFE7eabb663niF47HBkcu59993XafttTglbsmRJjwhrPebj87Fn0Sy8smwL9I9U4zeD38F/KrbEyPAqWHCwOFmEPXNmYFp8BA7M+QEWXAQNIMswsDgdQBImBlsJvFezAY7I+Qn/qh6Ok3NXodyJIctQ6td3yTi2CNWpX61RvJoy5WtotITNLi9FKkedXFlSlLgB/2+kC0wvKa4lalTDSJrS7JL0oiZIyFR4q/fdi6uoCulyJLmjn8hUhn+qYzLyht2VJHMVRm03Jbsla0chdTJICCSANGFKhEJfxF3TD8QD7+8Hs8ZUHr6gCyfLQWilJZ+f63U0UtFiWdLJTcNIWEBuCm41I/SZNeHCiFtwqYzZdOirsVZuxK4lX5nxF3KfpdL1pRvTNrDwwrXHEbUGW59Xgq8fmthjwlqvuL8Ev37jrx3e17tHXIAzDjuqx4e1dkbaPjsoGdT65Zdfisfss88+q73/1ltvlYoZrUvNgRW4b775RpIX/vOf/9Su33TTTfHGG29IlY0etXU2wNsPaz3ttNPqqUdkhlTFOgKSoWBw7am7ZJrc9xNPPNGp+/VBlsx/PJlLTylDhkwb31UNx6ic1Vgey8X7VZvIfbtG56JfoAo7Zs+V27tkzcZwK4iwAQyzlJmeBKzMzsIyO4yDshfi03geNg4txaxUNfLNKNY4cVHAco005qaqZGh2c+iIN0xDwwdnPRJUski4eEKW9Puwus0SI833gXidIiYnXyonEYZ7er4xki+WHGVnXmK6l64v4a0kaJwtX2VIGYuDwXm/RBpEGidg/pDwjiJYYcKK910CRvzpk72BNE31rlK0gi4CFeqDsYcklJLJ+0fG4GTZijxHbLhx78PzTicLL7oCgeyUKFzBojiQl1qLgBGLfjNZtvXHG7FsSQLYGOg/ZFr+1ufWfd47/1oN8PbRGgK2rsFyZEeXniW9dA2GDh0qKhmDXclVVqxYId2ULCe2FTvvvLPMy84kYMT06dPx4IMPrhWJ1SvCWukl44FntpieeOKJEkFBZtlYKfLFF18Ur1djvxA22GADyQFr6357+miPLfMXYnrlEBSZaZSlohgQqcLw0CoZOfRezUYosGoQRxDbR35CkWkiy8yScUG/2NUSpLo4nZCB2bkyQiiE7cPlSMFFvjdSiOD2o73bCTe11pihhiqY9oFpdATi74qpsUKcDUjlylTDFmpBVYsZYVKGyjiHUhFjSCtPIlRWeL+MOOIJnsIJYyqyXRnYTN8X1a5ESJ1x+DyJfAfBSlMIWWa5ih4wnpvYPdkWZYz7mJdRZpR9egPEU9nKs9SXMPLhKVh0rjK1S9mwwhTli74uRAAzZiKdn4aRMiULzM5WJUjr5wgMRlHAgZWbgl0eQqR/TGbbZmUlJMrCThliyE9V881t/n2lIiaE7JJJ9cg1P1uWnKPLDUzzRh352Om4e/C/BqXIHok+QKB8bLnlltL01xQ4occPY22IQw45REhTcbH6nJ9++mlMmjRJbFMnnHAC/vnPf6K1oFrmB8U2Jki1J3us28Na+TjWU++8805hkzS67bHHHlJ3bZj9wWwPes8mT64/vNXH/vvvL7lgJGFt2W9Pxq//ex7yg1VYk87C6GxVdhwTXYE5NYOwMp0nkRJEP6sKQwPlWJDOxyozjs2MpJAqP8l+XNBFjpmNH5M1Euw6yHIRhIGf0wk4SKDaDWCgBSxOVyHbMGHDRbnjZnRLrt0dqcuOGu0FuxZ/8DrcarshU8pgLyZ8788JTfZcR6+OhKwGvHVhFUPB/ch8yJAfzEllzIUJA6EKQwz4Ut5KqXgCds3R68XoAqplhE+eSJya8mttcO9ULLh8UpNer7SVlm14jDzhs7RG0sES2qJzFBnpS/AJ2Dmfn4o3vnPg0hfBz5Qev6QBJ9tWyljYUeompc2kMtkbERvBcBqpWFDmQyZqVOWiujoClyXF066RkUaLzqxTwEj0qI6thQyOxqgKRiTO9j7jpkYY+V6wPQ66C+GVMbz5RePWFY11h0suuUSqYA2rWqyKsXrFvC96vhtDv3791soTnTp1qpSN+RiKM60FGxEfeeQR3HbbbWKHYlwGY7pOPvlkXHjhhTLSqL3otrBWPu6ggw4Sgz8XMlaqXfRhrXWQgQB++9vfNtmFwDf0vffea/N+eyp+88XJ+IVt2Y6FIdGVCJspBA1bjPYTCpcgBQuDrQocE1oJh56wdBo/pPMwOFyFLLN+on2Zk0aOCRSYDoZkBK4Gjbh0QH6TSGClXY1c05LyJH1iY4P190Fo4qXRUTCJ3vB+MG5+SakQJZ6f/dwvppnzxCwdjmlFtlg2pNIlqpiEcSpFi0Z9qmIyrNtWZcl0tjLfi9PVAcKrTBn4LSXKhArpVI9168VTpAPqbxhjDTJH3IiRuxmDfnCNhdTglHiOFlw+EaPuvwdOwJHyGhJ9SwFriDc/28IbpG6oEmPYgUvCHDelJCmhrfR5BR2E+8cw+9c3YtTjd2LuCddj7HO3YO7xN6y1T65PVQGbvHgjqtdEseisqxonYCSDGevZITt30qQmuyO/+4P6UbDjCVPx6bOTZIB3z0bP7WzsbJx99tmyZIJBrRdccAEOOOCAJgmY3zl53nnnrbX+oYceEp7A5Hsqaa2J1SLpoh/s4YcfFl86A2SZ2s9q4GWXXdbuoNZ2G/NZEmQb6bJlyyQ0jSVAgkFqJD2tbS/tyVgXRsvGcManZ2BIpFyuj4sshwlHlK89s2fAhoERVgJxF4i7pqdsOaJc8b5ldjb2aOCtJ6kiuWoOJGFZRlAUtMagCZhGZ4A+L+lk9NLvJWg1pTxbVL14m/eTcNFwT0LF635WmPIPqW5JrqO6QSLnj6iR6AMqavIc6nbDDkgmp3PMzYw7VNQFjfwkh36W2Jh7SiTyoCWwfJnKs6XktcF9U1VIaMJQsQmFCdhrwu02g/d2jPrTPdLwYNJcTyM9TzL0eNG7R4LqGqJ0uWnVHUky5ZcxN3jydhnA3Rz8bRqqYg0h45AMV/LE+P1pKbC1I1iXxvxj/9Px0ND3jjoPZxzeu435H3/8sWSV0jDfGCjesBrGSllmWkJm5igJ2Y033tiiMd8Hm/coQo0YMUIyy2j2Z6p/R2B2JKzVMIwOh7Vq1GH7/1yF0VkrkR+owZBQGfaMzpOxQvvl/IDZyUHYIRxk5QajgznYJJSFTUNR9LeypXRYYAI7huvSg20xYaBFAkZwH5qAaXS1D4wkSrogE16Xo0fCuI63CfqymJQfWeUKuZKOOpb4QsqQz8cwK0zM9/ztR7UlzQ5Lo3aAN8kUS04kY1TYqH5RXSN4IiYBEwUsS6lkVMhYymTZqjUETPZz5USYcVPIgxNx4BYmlYqWNpCuCPVZAnb+F6cAOSkECxJwagJwbVMWI+zAoOJoKJVq4anXCIEK5yYw+pnbhIDxcvCAclHE6AFrCuOGrpDL/gObjxXg89B7ppQ3CMHu9XA7aVkPsHr16tpRQo0hnU5Ld2RmtS4TTEtgGfEf//hHq56PpI77+uijj0RFq6qqkuT9YcOGtfs1yH67M6xVo36i9MjshZL7tV3WfPxt5fbYMLQMm4eWCuEaai0GkI2RTcxw9D1gPiyjbfxaq10aXYUtLioVAYSkiXEUjKYgYaLfywkDP0xRMxu5LpWrzhCJQlWC5MLgVVHHslQAq4wsSgOxQQ7Cq03VMRmqU87qJfH7Kfhcd21pbVI+y5ezb6gjXDTqNwVfpRGFJysNoyoANycNJ+EgmJuE45iwk6ZEUrjZ6WbVmfUd//lyCyBsi68LQQc5BTHUVIVVV15VANmDq0XBIiEjEWMZ0sf8E6/D/FY8x1v7qIiirw5tRZCqN8aIpHmD301d6+7NLuOQeBffPtDzuiA1gIEDB64VnE5PGIPbqXD5pvum8OOPPzZ7f1tULDb20VvOnNK9995bmhOphtEnxqiKxpoGu0wJ88NaScZKSkrEj3XOOedIRMWqVavadSB9GYd+8FsMzSqXQdtVdhiLUv1wWL9vUOOGMYABha4tahXB650FEi9/8Y33fgirhkZnwY+KIOli+ZBhrCwnSniqrcz64uVyOVx7ogzX9kuQ/uN5W0z6Xuch12UtM1WQa0jdpqfMJ1k08pOAcV8kX0TmqCKqYQ1LXD5Eicm4TQI27vlbRN1adMbVWPhbpXKFi1T3nrs8DMQs8YYFf2k6Bmd9x8i/TJFLk4pXSpUdqysjcJIWrIAjpdsfj7pZSKpB5twERj3R/pR6KUF6nyHBwFe/6WLBpWv7wjjyqikCttX5PVQ5k4iJDi69BCUlJTIHOnNhYDsD2ck/KPx0BMcff3ytv7057LLLLlL584PimQTBVAjGYHBdw+aBLlfCXn75ZcnaoCmuOWOcRsvY+fXJWB0DhkSVD2yz7CXYKrJQ5jzuFF1YS758tCbRvjE0DFltGMDq368VMY3OhJQB1VdbyJPv8QqVe34ukqhc5ngp4kRlwk0rAubfL6Z8T0njehIoMeynDWXO936XSLedZ7a3GfLpmf4bA31cnDXoI9OHtPD0q2uvb/Pva7ByWR7mHKfUrQ3/djMSVWGMGrYSKyqz4SZNuOyG5P9z0lhwad9UwahuqQ/NglsRQnhADdKpAJyUKZ4vnxT5Pq7mfF/sgmwvfEO+G7MkzqKpDlU/rqI5fJMxyLsnoZ3B7L0Sl112mahPmUgkEuJHX5cYN24cFixYUHubSpg/l5KpC6NHj273vtulhPEA2Bmg0TEc/99zURStwR6D5uCAgukoClQj4QThuCaOzlmMjYL1CVh7kJnt1ZjK1VwCvoZGRzDqj/cIQSKZsrxcML97kdcphpBERZe7Ko6CKfjhuh/qVLL8sFYf3J7KWfQXA7NuUt4w+R4n1H30eDF7jOVFP4qCXY4NwaiEUX+9QzrtMrHxP9Rtrh/77K1YU5EFM2xjq39dgy1evg6JlVEY1RYWfzcYscW5kuDO7CsrZjYaHtoX8PzsbcQLl1tYo8z4QQd2WnVZmCFbiGsgnJbuxmBWUrxfXQ2GtTKold/B0aWqDMnnJ+gNyyRgW1xciu1PnYqdj60f1KrR/Vi1apVMu8lc1jUBI3766ScJbI1EItKVyVwwX4VjRmljxv8uVcJYC6Uh7cknn2z3E/d1MAm/IgVsmr8USxP5iGcFkWPFsW1kAXaKWLA7STJujnQ1VL20CqbRmcheYImhXtLrmRPl5XqFPRuGZHmxlGgqz5ck49PXlaojYr76RbAbkvtiWXLa71XcRDrsIlRpiArGTkiWH31wZqQMfPbmBTLAM1BpwR6cgOsoTxJBkuB7k2YcfTO2fOVaDM1bjbxgHN8uG4pIKCWepopKDp3kgQN2no3g6gBSYQNWnNEYfUieaIAr/vtrWDkpBEy2sAKBnBTslAnDdOE6BlK2gXA0Bds2Mee4G+qVepsCiRo9Yh3BwovrN0fYy9QUEYIEnWqsmXIRWenI98wJGtj+lKkyQzJQ7cBMOXj/zTpVtMegj33VLrroIpnPSP+Vj912202EIHKRdQFarugfoxWLROyKKzxLQjiMgw8+GPvss8+6JWFMqH3sscdwxBFHSH224WDM1rZ79kXs/uYkbNtvEX6sMOSP1vDQGsyuHCDzH7eMLkI+I7+R1WZjfUto6PvShEujK8EAUyzN8HSFWIJ0kco2agkYuxw5kLuWoHmBrfwnkCz0yorsojRUxpdPsL6/t1hmTzJLjIoXTf0kYAxk/fGaYoz6/VSlxjgO0gV1nVFUaaJDKzH9iFtrFS+CBGy/dy7Dsspc9M+pRr/ISryw65/lh9Lg/EqsqYkiGkqhyuLJ2oXLYFHLQWqAilxIFdpN5lWt76C65Dg2nLSJNStyYVgu7LIACjdYg7KybCktklDNPKZuvF1LERRERwlYY/A9YWzKkDI4u3IdA7H+6jsZWe0IAaNR/8NXe2rQbid5unoJkfvVr34lyhOD4DPx7bffSkPgDjvsgDVrVHB5QzAyi4n7zYFB8JmzJJsCUyDYDLD77rvL8zGawm8cYIZpU6n9XUbCaMD/4osvJJaisZECmoQ1PYZoQGQ5ylJZGBStxJ4FM/FjbChuH/kSfrZzsUGgvF5SfWeSr0zipQmYRleCCfSBckO8XxwhRKWIChi7G0m42B1JNYtlIHZNsozIkwKJGtfTLM1ICz7ezwxjCfLHO4tl5AwR7+cKAWPG1w831/d9SY6YZcCN2ojkqQgEntQzT/41K7PESG5lp2BXBjHnO0puQKWZhwVpQ4jcD9NdGAlDiGFZ0COI9KaFHLjM43MMKXk1VFz6Cvg3Zdsv46iqicCuCooCJuhnCwHLyklISTcQ9LJDOqGD/JU96p+M2wrmu5GWByu9sjiVWqqzqxUrsYP8rhrY6fip+OS5xgNeuxUc19VLCFRn4KCDDsLrr7++1npmsbHzkSVCRmY1BlbrGvrJGkNrSBjBTFTmqqVS6nu+4447YrPNNpOZkh1Bu0gYX7hG2zDhnzdgdbwG/cI1CJg28gJxfFE5GvsVTMdqJ4J9ozS+dC4B86FJl8a6RLBaETD6u3jGE5LF84cJ8Xj53YxUHCxmDXJb5gR7gawTrlTp+SRrXM9uSqpkPIEGKgwhZHYKQsiSOU6tyXrONRMl68suSCGrICalxZH/d6coB6Ofvh12TQBmtSWKCPOj6OcKF9WgJhaAE1WKGf1dKoXfgCOmNSU8SF5Zlo3QygBSZGIstcW9O/soRr9yLoyoLd2QJGCObUgmWG5BDb4/4lbZZrOXrq+93lF0lIAxQsROs7VWxVakaLnl984AkvmGGPHZGMIfAdudXoJdj7obsSJLvrdfP9wzTfrrOxKJhASjNgaOJCQxago0zvvm+c5Aj4qo0GgbNvr7zRhbtAp54TgGhSuwJpmFDaPLcUDBNNiuidnJwTJwu73I7G5sbp2GRleDhEhS8Onx8oZtU8mSkmMaSObVkTKWJq2kK7fJZfiY6VOLhYzJY3zyQ7XCUgGpjJmgL4x5YhL2mjRqTdYsgZJM0Qxumq7EShDsxpt/0rUIZKcQGlYthMwoSCI6vBKpZAA5RTWS4G5E03Dy03AGJBEdVw435EoKPvonZL+cbZgclILZLwlUMzPDrTcguq/9TbNyWCtWY1ci0aSUJJmMX7GqrqEoFmt8Ckd3gNEi/L5YCaXIBmtUaTK8RpXKtzmrBJE1LnY4aSoiq218/OJkhKpc+UHBrLstL+whkRV9KKz1X//6l5T79ttvv3qhqQyLJwljav66QI+LqLj33nubZa7z5s3Diy++iBUrVLJxXwXLICMGrMGWRT9iZSIHG+csQ9wJYvfCOdg4/DMiRgoTgrbMcGQQa2vRcKC27mrU6CkQ0uLleMnCk7SjOh+pZgnh8v7q8ERIBaJu9qMKWXU8Ez7P7mLW58xBt47kcRgE77fDrswFZPdjOtuRMqGVy8wKV/KpaLyn12v3T85C3A7ihV2vwxOzdsRbaybgk582QCIRRCiURk11GEMGliGWDKKyKoqsrAQqK1T3d7p/CoZrwMzmCB5TOiX5mtyw3We7Ifn3Zuw7AQwoqsTq8mzJAEsmA5KhxoyvQKhOneAsSIKdqH4jRHeAcz0D1SbSOQ4iSy0UHLgU5a8NQbDalTK5EzAQrHJhSwKQgZqBFnY67h4kc4zaHDHmhh2w1fV445vOUfbajT6kvr777rviB6PqxPnP5BTsRiQRO+GEEyS1vrdHVLSLhG2yySY48MADRYrjbCaa1jbffHMMGDBAaqZkhVOmTBETG4do9kVs++rVGJyzDDmBBPoHq7BX3gz8lOyHnbNnY0ygXEYPrbSTyDHbH0PRkIxpaHQnxl9XKoSLXYksSdpUG6oUiaIRX1QTzycvI4k8kkWVy/VGF/H0IvvIU8SNyph0QWa5UqaMh5QphqOMqFChLCQEjBERdh7VGJbELOQU1kgpbP4vIUSHpvDPDV8H5N/KKsyJr8KagVmYvbI/siNJ9M+tRlGkBsmwheH55Zg2ZziQNBEsjKMgN4aK6ggcx0BOfo0Y9MtroohJHatvYvyHpyEQtLGqLAfzTrxOuktTCXUqieYkpAzcEF1NwKh6MhYjKzuOyjVZ6rsVcOAkLGkWcJMOUG0isswSP9jqd4cgyPw5lpbdOmWW5D5RRHXMlfuiq2wpSxIf95TcsF6kZHUGrrrqKhkTRM5RUFAgcREcNcROxe6IqNhjjz3WiqjIJGjrhIT5ybWXX355rUmNowTuu+8+qdGyXfMPf/iDpN3yjetr4B//oTmrkRNMSAr+6PAKjAisRtBIi/cr5UYxN1WFIrN91eCGYas+dPlRo7tAhSpQ5s2GTKpf6pL7FVQKmJQnScBobGcavv9jniOHIsDMW1WnJJUyenWojHHZrLiUiRASzEpyx5NkqsCBVWVi3inXisLBfaYL00IA2IVHNWZoXgUs08E2G/yE2wZOq5eXd+OAH/BZ3reYah2E8kQUQcvGoGgFfqouxO79ZsNxDayKZSFs2bKP8qooopGUpLwn0wFRwhac3HKH3/oI5qf9eNQNQnpC3qxaP96Dvtc4xxV1EOxcbYzINQfHNqXkzPm7lRyRlDSkNGrWmAhVmIgPSSHgzRdlRh2/Z2lacF3+UHCRKFBfyFAFEF7lIhjjDwkHCQ7ldYHPn5yEXY6+B//9R99swuhufPvtt7J0F3pcRAWjKdj66RMwgjEVlOe+/vprXHzxxbj11lsxbdo09EWwzZ0ErCIVwea5S7AinYsCq1rKjz8mazAqEMAGgboYiunJmAzj5tDt1kZTNKWA6fgJje6AFTOETMmvdPq4guJdF3WLZEwkLi9slSRM+bm8kqMDIWCSJyaGfbVtMt9TyvhXypsPye2FgE2eiJEP3o2FF6g/hmMyYhBGDlmN3FAck4a9Lpl7jf27GBNI4vTBH+Pl1VvjqKKvsH80hquWb4u3lm+CnyvyULVSKdSFgypEYXFCaWxYtBJr4ln46lA1u7Cvge/hHtOUwlhVZUnmVyZ+OFJ58DqKhgSMHj4SrOZARY6p/MsXWgj3iyFREVZfwJgpkSehFQGEy4F4fyCywp/a4CLez5BypD/TlP7DVI4Bu9JQUxoCBga8t0SegwRs90OnIFiZxjsfXIv9d7gZb35WP+y3y9HLPF3twYQJEzBkyBCpovXr10+uNwVusy4UsR4XUVFYWIhBgwat1Q0wePBguY8gQYvFYuiLyA4mkXZNbJG/BHvn/IBp8RFYlc7B4EA5ZqYGImQsw9hgCPNTVVKWJAEjGhIwzolsOKaoqRKkjp/Q6C6wW5EnOknGjyvPF035JE2WR8hYPhSi5iXik5ixO1JiKyzP98VtSc48ssZ9cb0dcZHqn5YZjn7o6uiSqXAcV80rTBmwAjEpi+VlxxFPu1hcWSAErLGGFf774TgwNsUMDldg72gV/lQ2Dt+tGYZ9Bs7EZqN+wnsVm+B/v4xGeSwiJa69hs9BzA7h86Wj0Fex7ZfHyWVOJCFl2aioYm1TrNqDTALGMW//O1CVBxvmL364/9WiosVjIQSzU0jVBKULMjbMRvRnC8lcReoThd73iwPik0A6UudRZENIKs9Foh8QrzZlKkPm8PcP/12XH7bOCZiP9ZyEXX311TjllFNkYUQFL5sC73vqqafanRNGMG+sNYIR/e5vvfXWWmVKLh2B0Z6PlC+aIWeU5JgXxq4BZodNnTpVJMOTTz4Z5557rrwBZIm9EZzcXlFRgby8PMkkaQvO+fxUVKfDmJCzFA4MpFwLh+d9jSIzCcsAfk5HsXXYwdcJE+NpTCCxtbJqSVlj8E8emWWVhus0NNY1xt5ZgsgqFUnhD9OWZHuSKfqzXW8GpONFUARURhPJmN8lKTMfGV9R7a1Pq+5Hg7Mh00BssC1ZXBxBY1WrHyrc39yrJtYObA4VxqUkRa/SrGPVybF8yXCv6aX5EV2+Ev1NIoEKN4wb5x6BE4d/Lv9un/tpO1wz9lWYcPBB1ca4c8sX0RfBKQLVsTCyIkkkUgEkvLJjJCvZ5tJhW7HX28VY+EsR+hdUoSoeRjweRDicQiploSivBr+syEMomkKimoydeROMGWEHpItAlQXbix+hbzBYaUh2XXSZIZ26bPjg7dAaT8llxArnmJoqO6x6hIFZNxavFXXBTsvffHEyHtjuqQ6fL1qL4447DlfcV4pjX3ymw/t67+SzccYRR4mHu7XIysrCNttsI+IKK16OUxeE3BToE99www2lUsZcr+rq9qcAtBWsxrUmJ4zbtCbb1DRNnHPOOaKGffrpp2K5Yocm/fD//ve/sU6VsAsuuAC///3v8corr0iXApFOp2WM0SWXXCK32cnw9NNPoy9i57y5GBpYgxQsrEjnyfVxQRtfJPLFExYxqhE2sjEmWI1CKxtL01WocZJNEjCiYdp9Q+VLkzGNdQ3O5LNYtqGxntYZEq+U1w1J07OlSjxSdvSS82WWJOdGMoYi2+uWtFRIqySYuypJf6OblMmfJ8jaMFTbgD0kAbcqIASNBIzRErl5MYlCyMutwTe/ugN7vDURI3LW4MKfgCdGfVB7vI39G+EPHxsBPFHRX7omV8ZzsMfAObj3+30xdsBKFERi+F/1ONw8YDoOHts3Cdj3C4filGmulB/9LkeSsm8PWzeTUZaV50rYbtGrV6+lvNlP3o5IdhKxsghCuUkka4JCtpwI40VMBKoNZC2xEBvkwgm7iA9w5LvDkiOJv22R7Hudu0mvKSRHldG//kt9Iz4zxAhzpgoafmC7Ymx9bsm6zxDrhu7IQw89FH/9619F9WG1q6amBocccogkITQFesQpxlBpIjklYaFVqS3jDqdMmYIPP/xQoiracl9X5IT9/e9/F8K1dOnS2q5MzrH8z3/+g2+++UY4T3vQLmc4mf6ZZ54p9dCddtpJkmN5nev8XwFMsV2XrLcnYZ+sedg8tAbDrHLslzUPe0ZrkG9GsXM4Jr+6qx1XcsEGWtlYaVdjSCBnrbJjaxLw9Rgije5EoEqZljnv0Ve9BIY6kfFS1C56a5g4zyiKpDdsO12nw7PcSGLmT2RhlyVhR10kh9T5Ts3+CUSzEwgWJmAUJWVUEJWY0YWrscOohSjKislUiupkCIcUTcOx/b9o8th9MsYfPluEIjgtb6UQtmtH/QuH5n2DZ7b7C44a9DVe3vA1IWB9WW0+9stzhdwSgVBaSn6xRKg2h60zwXJjQ/hK28oFRXLJ5+XCNP5+RVXiBQysDiK1IgrElPIVLONQddXMUbFxWqIpGMDLLxgbR6jIpiMu3KD3veVdgbomkg2erz8kmiOzkgVqmoMVU4GvJGLdEeLKHyodXdpS/yoqKpLqFxvtWN1iHAMHVv/f//1fk4/Za6+9cOmll8rIISpHfFxpaSkefvhhMbO3FkOHDkV+fn6j95HUUZ1bF9huu+2w9dZby+vIJJFU+Jjoz+rfOlXCfNCgRllOoz6GWVlw4KLSjaPIDCFsKOk+ywxh0wad7YWm8oO1hoRlql96DJFGZ6MtaurIR+6CvdJFIE5nvVeG9JPxPdUrlevlg3kjf0iqpGuNwa0+aaPRPk5ztCvBrvSOMWvMCXCIsoG0lzlF1Ssru1KGQKfiARkOvcFTt2OjAT/XS1K/8pujsXPRPJy80ee1r6kpNOav3DVi4r41YzBxAr0fP+E89G0waufLQ27OGHRe34zf2Wjo92Ip8r19FSlfeOEV0oAxtGgN4ukAkmlLSqOcimD+DJjlJqwaNWYqnaOUL5bJA+UWglWGfP/ku8Yg4CxXlC/+AAgkTDWAnX+CJVTYwOuz6h+Hr5RxnFZ1FsQr5itj67sx/6ijjqpNPyCYgHDPPfdIgvyYMWMaVcN84vTdd9/VrqNaFAwGZfA2/VXNYeONNxbfORdGYtEUnwka9knumsssJRhpwePNLBEzaJXkkETyzjvvrDcYvCnwGJgHRgWQJv1MUAEjIVznJIzy5Nlnny0fAg1wxMSJE/Hoo482OVCzr+CTBLBZKImNgtlSZmwOjXVDNjw5NDwx6tKjRlegLWqPwfwl2rxYzpE8MEPM+YpsqfFEMg/S84ol891aP06oQp0I/XmRYtQnmWMzSp6D0BpT1sdGxhGwHGzw5O0YMmClmORrKiIIZaXEm1ReliUEbNc3rsDHB9wjj5+y1T+wdPEQXNGgbN8UGWv8Nfdd1ashvjzkztrr/fOqEVgHZvwtXr5OOsxXVmUjYFR5RPBOSenvl1uBD/YrEULIqQjxn7NhOmz4UCdGEny5ZGk8YcDOphPfQrJAlSF5d3i1gWQhB3XTc2gIuWIOnPw4SEGGwXP8FbsrqaalN4hj1snFEsPCHDrfrE9VrDeDhIhetkyQHFHdyQTP74ykyqxs0RNGUBlqjITRI8Vq2HPPPYdHHnkEOTk5uPLKKyXpnlEPLeHaa6+tNeTvv//+cjsT3Af33dLcx3feeQennnqq5JkSxcXFougx5X777beXfbPE2JBYNQSfzx+f1HBbpul/8sknaC/aVY7km0NJjmFlmd0H7IhksFpfR8oNSPmxI/BPII2dJPpyaUSj+8EoANdw1YmPf0FcAz9MKRa1wA9lZccZPV9+BAUJGEuW7FaTLkp2U+aoP2ZUIbivrO1WwrVcJEYkcfC+XyAnP4YBhZUoKqyWjuNQIC1zCiPhlGR5LTxNBYD6BMzHkOFL691u6KPUaL9K5RMwZoJ1Fujhy0QklMKyilx8d/htmLe8PyKBtMRiDC8qw5Kf+okallgdRWwlv0hqdJXMH40ofxcJmJS5qXxVWqKqhleboowRqXw1KovNHyRnNRsmRInl9rNuLpbvy5yTHwCGxOGOrQFWqPIZx2Px/vUFLKGxmSBzYWdiY2pSwySEVatWyaWfhtAQ9Ig/++yzQnAoznBhwGnD7sKmcNppp4nfnOVLJuPzur9YliXPS296c2BJlAn7PgEj6EmjCX/XXXeVKIzs7OxWZXy9/fbbooZRRWNOmN90wH3RG/e3v/0N61QJI6M99thj5cAmT66r4dOoT8mO9/dl7BV1xOvFNniWIH1QFcu83RgyVTB90tDoaTjj0zPw7gzKCY6MF0qGgUCFhY1uLAUSXqyE56uhsiChmJ5tQw3qVn6aVD8gslIpY/SL0Su28+CF2G/jVzE++AvO/OE07DhkEc4e8AHKnCy8sGo76TSurI4gbZsYmFe1ljncV0x8aPLVdeisTDCCytbB71+MikQEi5cVwnUrkE5b2PSl6xGPuViyogBueQjVBerkly4Pwaoi+6KUqsZekXzxupJnFSFjOCvVrmSBi9gQGwajTOLsinRh8TFcBsaBWEDKkpwDymaT0S85sPKTwNII0ixnxg1pFPEVsO6GP8Kro6DPy2+k89FYmZDKGEuImfC9WA1VMx+HHXaYKGC77bZbrVrFcHeSMHZLtpTt5bqulBFphl+4cGGzg7qbAjs52RTgg8n2XB5//HG5TXM91ToeD7lMc2AZkvmozz//PEaNGiWCE0kgiStFqY4k5pvtnaPkD87MbFNduXKlsMO+DnZckYA1BAnYGpvJlfXB7siGXi9NwDR6Ij5cMEbGwcjJTjrLVBmRMxwJX/2SbkmzjoAJGctWPi/x4cQ4HsaVUiRHHJGI/fv7zXBAdDU2CWXhk63+jodHfCxZXwdlJeT6O/vci0u3eFdGDW1SsHyt7jyfgOkfMR3H+Bduwtjnbuk0daslE/5/9rxfFM3+/SsxMLsK/XKrMaZwNcYMWolwJAWzIAm7OgAjQd+XKWVGO9uRSyqtJFs03vN7xHK3DIvvbyM+0BZCRqM+76fiFSpn6VyVH+3KIEJLg1JOF3hEzlwUFeWMKhujUBojYMyq6xbwH01HF0YnpVLilcpcGiNVJBjDhw+vt86/3RT5oOeKClRmuZBWJZY/qUK1Fscff7w0/7UHJG6Z5VaOHaKC548b8hU7P+GhJfC1kPtQOWNUxeGHHy4lyhdeeAEdQbtIGNsyx48fv1Z9lPXV+fPno69jaCAsShjxXZLmGAUSK+aBZZYauQwfsUyHrWr0eDCh3nFMMcUzi4l/zF2WEnMd6UKTiAnPcC9xFF4nFgkaVTDxFNM/VqE8X0y9Z3caS0LsaLNWB3Ha/ENqn6/Kia/1Y+SSTd4VsvXn7eq3uWd2DOsfMR0Hie7c41XJcfQzt8klS4IcW9RadSuTbNFgn4l93rlcypvH//dcnPzJWRK2uv+7l8p9HBk1MKsSy6pzUZkMIz87huzsOIykCZPxE/1SMFImAmWWxFFI+TuqSoz0d9UMpyzG76L6fgYq1ffNzrXVD4McV5RXlsgjS4LiCxv+ThJj7vaOWQKGXSmNz5/UNJnkd3zDW0ox6vfdRMbWEV577TXpUtxhhx1q1x1zzDH1GvNIZDiikIHtPkfgY2jo9zF27Nja+1qLadOmiXerPaAK9utf/1qIEzsyzzvvPBkEngmWGNsy35qkjUPFn3jiCan8UQnrKNpVjvzLX/4iC4NYScLYGcBk2zvuuAO33ab+wfZlsBsybKmOSLa/Z0IrXBq9EexEXHDyZOmKFLXAcmFG03CSFlwKY8lAbQ6YJOb7lxzKbaqyI39/i4/MU8rG3FMiJzy/Y40m/q++GYuDUmG8tvG/JWjVV7WoIDencPWkf1e9uXFmm39fg+p4COVVpvi+OFfz28NU4OX3R9wqJd+2ojIexv+OUN2GLCEz3mLe0gBO/N85WFBRKGSMJI2EKzuUlIiRpdV5sB0TAdNBZSyC6mXZKmLCcBFcEvKmLCgBgCRKku/zHIlNYT5YqMyEUw0ki+za72J0SQDJfEe6dWVoPAd7W5AyZPJ3U+HkqfZegwGvuaxV1r2GkQ9NERLIkFaCXZI/XFZHLLcsuR/rDOu4O/Lzzz8XEzw9XgxA7d+/v+RvZc6OZjckyZqfYP/YY4/hsssuE6JCrkBFin7xjz76qE0m9jfeeENC4RkQSwJVXl5e7342DPj+tIZghhgrdlS+eJxcqIb5oIrF8iQtVK0B/WRsSOBryNwHS7r+LMl1poSRbDFplwsZMGu2TI/lG++3sWrUj5RorMNRQ6O3gAOr+at/0dlXwYibUhZyUiaC0RSsrDSMgQmkqIjlcgC3Ilr0h/kgGWN8gPKFqROgEDTbUx2CytbAk9zMGcPk38tpC/fAU5X9ZKYqFWRm7NFX2TAnr6ehtxIwEqSaRBC7j5wLiyTbcKXky9Kkj0zPXUN1qyGY2abmTNb9EOUQ9AF5VYhEk3hm57+gf7RatvHxS0UOsoIprKnMQkV1BNGgl3vCzsV+CSl/JwekkSpK15YQWWJkV2NkuSXEjEorS94sR/I6VVp+37gdv5dUwOT753JYtymzKRdcOgmLzrwKRsySDDr+0IguDGKD302VTkkj7EhpcqObVSwFS+lUhn3Mu0k1iazTmIqOLG0EyRVzvn71q19JMx4VpgcffLD2fpYxScL8GYq83GyzzYRwcVua5Bnwvt9++7Uqad8HGwWoqE2aNEnyuLi/zIXiT3OgYsckh4suukiaBDIjMxgge8YZZ7TqeOgbowfMt2H5YHgtiRz9Yut0bJEPsl++MMb5UzZcn6IpOjKGorl4CQ2N3orx15dK4jhPYnOunSjREablYuJWSuJ/YNYeqJlVICNgJJzVG+bNrjMpAdWoMURyX9oLxwy7WHD5JBkFw9IRQYJHdWLkY3dJ2dPKS6IwrwZfHXoH3pg3HgeMmdnN78T6CapgbHogmMFlWQ6mH3FrvW2ohNmOgUgwjdWV2bUjohoDYyRCIVUa7Jddg5BpozwREc9XLM1qQRoFoRjmVxShIhaRbVKOiZRtobwqilQiAHNFCKHV7PBQZWvamej/ourF71Z4lSXr0tkOzOE1MOZke8PhVS4Yv4vqO0tPmDouO8tFsNxAor+D+cWTmjx+kq/McuQG901VsSqFKSw6o74iuM7GFt1biuOee67D+3rnzLNwxpFHtmlsUXcgFApJlEZTYMdle0z77SGhLLcy7qIhSBAZVp/ZpLjOwlopDWZKcxp10ORLY33ChCtL8cOtxaIE8KTHLjK70kGgXxwXFKhxHRfs8Ax+O2xHvPb+1ioSgD4wz9wcqPJOnowNSDDJ3EGg2pQTJT01zBiT36PiGXblBGin09LRRvP0VyeqxPamCFhvLgH2BNC3FUsBwYANy3SQH43j51UqcJN+LWZ2MZ7CV8KoXjVHwIjZv76xduD2Vv9SSlFuOInF5fkYnFuJJeX5qIqGUVYdRShgY1X1/7N3HeB1FfT33PH2zh5tultKoUDZIHsPUWQooiAgKH/FAWWDKHsVUVScqCgiAiIIMlRElD2E0lK6m7TZ8+157/t/53f70jR0pDtp7vn6viRv5eXlNfe88zu/c7xIRj2irhaZ22XwdaMiPbYA/zLdyvFi/yh7RqPsh7S8YAz5FZI13y9j73zQkM5I+sP4tatXlespq0k/X3d8AzD2hQKMX90u6i4hPaQuo59gBaf1yBhSC+Rhdruw4uuzpSt1xSACtj3Rn3i/pfeDkYFcLrfeDcyNgUrcjBkzNno9qmPstdwQGNFBwWldoDL40UdcGce2JWEbS6YdCM6KbdiwsfOAOWCT7piDRVdeikm3zxFFgFtqwYYM7usdh6+Gl0nrw2RvO9wT4zCjITFKm6q1DSmdkRwbURljr1/BGgkRpQojjiJJ7szVURb04BQ9nFdahwwqbyu+cK0kpPNAefv84/CpwFwJRbY7VDcfJFltfT4Ui4r0Q1LBYhhuXXkUdX+fjZaeIJxOQ5SydM6B8WU96M1sOPG8BBKwo1/8FlrjmqhnZe6keL5IwOj54ueZlBPBihi6egPQ3XlgiQ+FsVk4Wp2y1EFllEsfsuBBcuYz4G7RZXuRI8lSQCvHjnzduNt0OONWVp2UchdZDr9663F1YwOx4jQFWp+Ghl/cAd2fh9OVRKrDh/Hfpz+sgN5VKpouvmKtbch8eE2N1g5DceT5ynYEPvvZz261Am+a8Znef//99+PGG2+U/kiqnhxRUqGcOXPmtidhnHuWwMwQSnOMpOAYkiBLpGGPc9vRDvsduY2dEcxdmniHtUHG0FWOfegh+sXig/BH9944f9yreGzlLIS9aUw/eQVefmGm+L/4B1+IFgkYv1aLMgYi4eJl/Ly0YSY5YtYGvfjE+lWKX96BFV+4UhYDVIc1frhqxvPYdelumOpYewPZVsU2DT0pDwLeLHpjXlGuumIQ8/y6Crq51diR9K/lDdsYsoZujRoNDR+sqofTlRfCF/GnkMo6oWhFxFJuGAUVxbwOB31bK13yepPRta+I9Bg2vStQsgocvZo13s5YShgXO6SM22fC3aqJ+pXVuAxi+bikwSFlVWHJ60oDchFTFksMnpdRUYg7UBGJI5sMYPlls8UH53Hl0DTg5+D5wwKjgEANxKc//WlJzGeVEZP3B6K0CLAucAuTuWfMAmNmGU3+6/J/DWWcycUA1jcxt4zEi2NQhrZy9Exf2cKFC7evJ4wmfM5puRVQCnfjCiiNd5QOuUUw0rE9Zvw2bIw0cEwoafdUtZjLVJlDpDyOnvYgHL689DrW1fbi3HGv47b/ngQtqomZujRCyYcMqz4ma3l0qG5Q0aAKRhO0bKw5ilAzKvTalCgzX37ri5js7cBvFx0gIzH6kso8KRxasQTX7/6M3O9gk779Rmho2PfZq2T8SDJUHYijI+EXAkYCUulL4h9H3tsfgssRJDckNwesHJpQ0Y3GnggOa1iKt9obEI17JO7E58kiuiRiVQjlV/c5JhVkawtwtuvIh0zxfglMi9CTfJGIicLF1xVJVUYR36GMvSUyxTLp83VG0mW6Tbg6NUm+L40efaEM0kmnKKwbAq/Pwvj1YXt5wq645x6c+fBW8IRdcD7OPXX4e8L22WcfCVJl3REDYN9++20sXbpUuAc96DT9byj4lckNrFckUSJYOs4Fws0NV6VHjZ2V9fX1MqLkZuWWxlRsFgnjRgD7pAavhrJUkyucW1JmOVxgkzAbNtZg2nX3yMGR4x2alXlQzaYdcHnyyOd0mH1OFJkf5jThCWVQ5k9hVsVK/O3fe4saIWGtntVKF68nYa4WkVNyipjzG+6/E1pS6zdDs4zbq+VQ5YjholDLWsRquJOukaDGcbuxN+WRjUUqU4mkWwrSQ8EUcgXd+tyXRjTpkY8kvvRzDTbrDxXMBOvLecSczwNPR29AtiRzc8PIlZtQ0woMknSnAb3VJUoWyVe2woCWUEXBYsivtCw4i3KZbOJKZlcRRWcROrchKwtwtulCzLSkanVDrs6wY1BrcgqbuxXUNXSjrTMEjy+3Vh/muAdvRbGgoun8oVfwbU8S9tk/bDkJ++eXRwYJu+WWW2Txj1uSv/vd72TSxspEPs/0cZEQrau7cjAURZHpHUNWuS1JLzvVtY11T24PbFZEBbukSqFsA8Hz1tclZcOGjZGDEsmhD2zyzXMkVJV/LUyXKaPDbNKJKfUd8rHY6ZKDoB7KyWhpt5pW6Xr8x4ppGLdHizUSKsVSGBxrMjFTQdNXr7Dc+OpqU7TTlOtwC40KzUzvSuzmWYVjvIuE0MxrrJPH9OMFh8nHbRH7srViL4Y7ASO4nehx5vHeybcilXFCdxiYUtchBIxwOgoSFcE87qmRDrTFA5tNwIhHDvoFWmNBUd2SWSfGVfVIDpg5JSULGATDUzl25Oiw6DSFgBGFsGEpsKtJF8lVpj4vLnUjVBAy7+rQhKh5Vjjk9erk5qRWRH51GDCx4LZLhVwdvceHeP24O2EmHR8rJGcn6aYQsBGXli+J+SMDY8aM6TfNk9ySexAkvAyK3WuvvYZ0P8wzZYQGOympqh122GESLr+poO2K5O1nP/uZeMOOOOII7BAS9pe//EXC20444QTxgbGqiJ+zV+nPf/7zFj8oGzZs7DhQ5Zr4wgXi2aKKoJj05ljjHX5OUoW4jnJ3ElqHU4gVD4rFZqtfbn57DZZ3lmGXqnasmFtn5YBx7OjmLMk6BohHjH+AVo8lCSWlySiSmWNXTXkOR3tXYWGmFvGijsaVNXg+uStunXcC9nRbTp1FTTUfI0+bkh+2ruuNBPK0NbDfc1cilXdil3CH+J+Cvoyk5NMwTySjbskJqyuLor4siocOeGCdHrFNBUu5p5R3CumjF623K4BCVofp5LiwiExNAUVZ2gC0mA4E8kKknF0aipOTMPwGUJOVrVo1zsRVBXqPLtVXpTEmR48cV8pyB5VWdkamVKkfKuGB/X4rbyY2NGIcttgBOWE7Cqqq9nu2GLpKNavkS6cZvq+vb0j3w+qjn//852Kop6LIceZ9921awC4N/Jz0sfic0z4WdzNA9uGHHxalbbuSsIsvvhivvfYannzySWkp7+jokM8ZZMbLbNiwMXLB6IHGc6+2wlU1K4MpHzRh+E2r8Fgp4vzD/i35TpKbxNV/nwmzOgvVYSKf1+ByFfD+O5PEn1My8ssBkQGtJDsZxapBclkqBX1iRZI0AKdOfw+5ooZUsYjGTDleTU3Cq5l6hLUUQloKGZHlgEkO/1q1YJuK0UK41kU+Q64M4lkn5vfUYHx5j5yfLWgyluR4sr62Fz5XDp1xPzKrlbGthccP/hmMVV7E55XDtcoB1wqX1UOaUxCujQEFVV43RrgArZ1rkUCuNg+POy+hqWhzwdOuwvSYMIIFKOOTyJYbyFflRTmT1ymjLLTVW7amVZE1GMyiszG80dfXJ6Z4guPIvffeW8aPrEdkqfaG0u4pEF166aXSYfn000/L/XB8yRokBs1uipeLYa0cidKXtuuuu4roRL8a4ykOPfRQfOYzn9nsn3Gz/nexffzCCy+UqP6pU6fKeYsWLRoyK7Vhw8bwh2ooWHTdpdKpp5ZlMXPsKvxvwXjU7daB13smoGNhJeAqougrQEnq0MMF5PvcMOCAkaGHh8WRFgkT5SJrqWj56jyUJFUMMiFIDABHkEVdQWR8LxbHq8QLtouzHZXOOOKmG+3pELxaFgE1Azfj0XnDddSCbWlg8mgo//704uPQHg8gnbXILAkZ/V6dpg/JnI5Z9avQk/WiO+XDnjXNkmy/tVEKSZW8uWABeq8uZLyvLQBHjyaEiq8pqqj0CRpuE7EeH/ROB8z6DFJBq4zUX5lEakXQkhMKDBKDhPvq7V7kIgaKfgNq39YlkTsaWyMnbKRgzpw5kphfVlYmaQz0otPTRXWMxdml2qR14Zvf/CauvPJKPPPMM7jjjjtkiZBdkTxtak4Y6444znz22WfXOp8Ej4SOpeSbW+Stb0o6/uDeJpKudRnb1nVdGzZsDG+M+/FdMrZZdvllEkqZdxTFq6X0AoWMhv8tbYCzQ8cB+6zAK+0TZYTE8SQPfvTv5KMua/OxLAuz4LJM0XlrlKmlV+czMa4pxVkToMcYbW59X5VxBB4glXEh49PxxPKZqJoaQ3fOjwZ/N/KmjpCWRtZ0YBzd2Vh7VX1rYWcmX8Sh/7gMTi0BXTMRCaRQMDSYUJAv6BKYGgjH8VF3FSZGurFHfTPu3vOxbfp4JKrk7jkohAvwlKWR7vDCHJ+G0uWytmcrcjATOpytDuRq8ihEClA7XVBXT3/SKet6VMXA6qu8BiPhgFGTh6NXh96pYeGNG65XGnEYJSTs97//vYz+CBIodlWzh5LbjUMFUxwYccHTluSEMZKi5EcbDPrgefk2H0duisplK2I2bIw8MBi1RMDor+GWom+FLiPEQHkSSkKHMSmNJz7YCx0dISheHv0ARzhjjRqzlvpldrpF9eIYiGNMZj0x0oIjy0KAdTMK1JSlWvD6jBYoVObFu5Nt92JpW6WMxZ7vnIG2TACvRifDoRbQlQ/AoRSwuLBtCNjODqp8PUkvPuyokaLsvoQX3d1+dMSt55NmeabWMy3/iU/8dJsTsBL4Omu68EpkWnziEQwFUnB3alb+V68T/tqEFHFL2GpKkxG2UpmV7Vq2KRheawtSyVieQs2fhyOUFTVtpyNgowSf+cxnZORHI/3++++Pu+66Cz/4wQ9kxDhUsGScXq2NnTZGwIgXX3wR++23H26++eb+x+Dz+XDRRRfh//7v//DUU09t9s+6STotSzBt2LCx84Gp4U3nXynbkFSteACUWAodWHLdZZj0x5vkQOcZm0WiJwglnIPKg2AQyMdcVngrux+1onRLMuGcRmimjFOp4AhFZU2Rm/HlNPmb4gHiQZcHVXZEWqXKioR2phIu9Hi8qPHFkF2tgh3sX4rHonvjRP9CZIsuuJT1d8qNtLiI7YEJz1yI8eM7kMi6JBvM4SggUJGRvkj6w1y6AadewMtHW4G82xuNl1wuH8fddxdQYVovmmBB1C4GtLqmJ5BMBqCFc9aYe7UaRjWW/jE1pqPI11dREVWWMRQ7HbZSbdFwV9MOOuggaemhD4zgxO2oo44SDxZzw7Y3OAo9/fTT8Ytf/EK2I+kv43IAJ37f+ta3pEx8m5MwdiNRDhzqdW3YsDFyQCWCoOpFMNfro1svxbTv3CMjyaWfu0LqbBhRwPFhMepEsKFX4g2YZi8HB8YMGJqoXlrOStdX05CIAGX1WJJbkVTMzNK2ZN46aJKQMSG/6DaAhA54DfSlPDCKiozMwo409nQ3ImU6cV/XIbir5n9rPf5VhQTG6NtfIRtI8IYz2WPlUzgcRXR1UXY040bQnZUNSL83i7yp4cUjh15Ntz3I2ISHb4bXm0W80w+jvABzWRDFoAEj6QD4WvMXJBKlmNGsMXd1RnyMRlaTyisGAO+UGOYEamugqqpKNhEHgiGtrA7aUWBGGQ36NPaPHTtWFhLfeeedLZ78DZmEDTaz2bBhY+fC9KvvwYJr1x7fZCoNUcBKhcw0UtdNaUc840I05pPzlbQqYavjfnSXfG36DChRXUaUVNF4G3rFuLUmG/IagzlV6BIxADmQml5DiCA3JiUvLKci2emFs7aAZNqFV1omYKKnE2V6EnHDjfm5NKY6nNJXSWyIgG0pMRpqlMVwJWCZlgk48aMuIV5eRw6pvAOGqci2IT9//vAfYjhi+Vlrev8Yo5FN+4VckdBzS9eIWQHBrnDGCgwuqPAFMrLdOf+8zc8zG/YYBSRMURR4vV7xlw/0d3EEOPC8ZDKJQmH1O8dtCNYjsRD8qquukqDXrYnNiqiwYcPGzgOOHUtBliVMvsUaSRVdppinSY44JjIiBeRNFfGkW1LyeX5JuSiVbbPvkaoX/WVyPnv9/CYa/+9yOYl5P6dIbADPl4OKw1xdJWN5xmSUpADRqFcOqm5nHi93T8HKTBliBTd+1nVoPwG7tWvaVnsuBhKujWWObUj52lqhr1sDx8w/DT49B68jj4Kpons1eabyxcDSkYCFp30XK745W14/9CFWRuKobuiR/keXswCvLwtVKyKb1ZFJs6DUxkjHz3/+c1GZSicWcq/rvO0BGu8H9mdvTexcu7s2bNjYZCy8eW31i76wCfs1QeiFoWDcb29D47lWqCWJ0pvH32F9/pvboMQc1gZlXkHjBRYZYwfkikusCAIp5i5CDp7cgpNKouKa3KbGr11ujTOzHCkV0XTeVXJ/WigHo88JheH6eR3V3gRWxkLImRq8eg4BRxbvZHPY2+XEGKdVn1b6enCZ92CytD6CxOsMHC2uDxsrCS9dNhzGk2e8ehHzxeXzaF9E+iFfO2NkEK/1gaprqfmPI8t0xiGqns+XQS6vY9Hp38HOCum2HwVK2Pe//30py94Y2CW5PUAf2q233ipq2Lx587bqfdskzIYNG/04+IXL8cqxlyHw9DWY/KcbseTMNeSL6eIDE8abvnQ1Gn5+B5ousvxk/Jza+oovzxbyxTBMRleIf4eKmG4dPQZ7dZq+bN2eGPeTu9D4lcsx4Q+3AI4izF4n1EgOC9qq4XVzlObE9GAbliYq8auuQ/GqtxWH+RaitVDAijxrjbr6idhgIjUUdWoo18m1TNwguSpdtqMJGH+W51KvIKCmceiEjffrjUQMHFna2Hnw7rvvymlrg6NMXV+b9nCkubGICfrATNMUn9pbb731sdJwZoixymhzYI8jbdgYpRD/1SC8cqzl6zqlYR6WnPkdTH/iBvm6RL4mPnyzNTZcDRIwBq2WPi8RqlIaOfshS+PKFd+a3a+UTbrdGneWfGQs75bb/d/laPj17TByqnVf/gKcrjz83oyM0lh105oJIV1wiJl8RaYcP2g7Gh/kIjjNHxMC9lzKhS4jOSRf18DTUEeIiWJ2vfc5nMCf6aRJ83daAjZqMYpqi7YW2PPY29srI0xuOg48XXbZx9sUBoNEjRVFDGalGX/VqlVrnXjfmwtbCbNhY5Rhyk1z4Ng9ig8/fYWQIEefKgb6S979HO6b9Uf5+HKnVZY9sNyYo59lA5QHibW48Eox4g8E73Og2kVjfikhnaCZOh+xKopK12Nqfr+qRgK2mvSxBqmQ12A6VLgdBXgceaxKhFHhScjlQT0Dv56FT83ihZQLx3rzON5LkmT5nm7onIHvVc7/2HMwcOxoFE1oiorl+QQmOPzIFvNrxV/8KRHCmf5oP1Erq2/ewt+ADRs2thdOOeUUqVNkXyQT7ktdlCWwT3JjYCUjT9sCm03CWB1wwQUXYOLEiVIlQJBRPvDAA1vECm3YsLFtkfcXsfjTNwqJarxwDVkiAZvx5PW4b9ZNUuLNWANNN2GaKpZ//lorGmAdsRalj+vS1zmWXP4Ny9jPNH6SMZr9ueVWUsCktuj7d2PFRRZRUzwFNPzqdiuJv5hHPuWA4suga2UYwdo4aoMxRHNWWXihqOLU8ncwPztGiNh72Ra8lx2LM/2r4FWd/QTs9YyBA9zax0aE/PrBRfvjOG+TEDDCW9fYr3I1FRI407+2D2w0VBvZ2MlzwkYRdt99d0nZL2WObSkmTJiAMWPGSEQFYzO2dDtT3dx1TVYKsNWc4WklsMeJK5w2bAzExrbMbGx/Y/NA8rTLn62RI8EcMDHaK0WYeQ1LP3e9EDC5/upRY8MDt6/3vsf97lZrg201SmNJyRAzFQlvZZ2MfF1SwH5xhzwmfpTbnHONdWOXAaerANVlIJ11Qg3kkU47Ec26Jd+q3JXCJG8nFmTqMS9ZjynONiFgXjWLH/dNx7da98FP++rxTMqNgycsF9J01/xjcen/zsDV75+Kn3/0CVz53mcQ1pJYVdBxb+945IsGeprr+8eZ1ZprrZ9vIAGzX9c2dgjsceQmgUSJ/ZNbCvZD0hPGAnEWhzMPlfd95plnbtH98i/hJvPqDz74QFJiuTFQLBYl06PEEPngGGQ20hEIBKRlPRgMIh6P7+iHs1Ngc0uVbWxb3DrvBFyz29rFtCWQcDWdf5VsMA400G9o/Li+MSR9YKa+uuevuDrSgnVHVLwcJrS4BiNgWGXObqbnW5lj/MQVzCLb64bqK8DjzaFQUDG+oge6aiKZd2JqqAPRvAedaT/yhoZVi6uw316L8ehBP1/rMZ308tdR7Y5DVUxUOhOodsTQmgthkrsDq3JlmOxux1+79sDMQDOu3/0ZPLFkJk6dPBdvrmjAfuObMLexHjPHrRlHdq2qQ8WYli149m3sDNgexwse7K+86/v4/AOPbPF9Pf+N83DuZz6Nf//739jZ4XA48NJLL+HJJ5/E008/Lf6ugeDkjr+7DYEhsRSdHnnkEalPampqkvqis846CzfccAMOP/xwvPrqq9tPCZs8eXL/fJQbAyXQ5FZZWblZD8TG8CNLW/ud/kAT9ODvta1gK3AbR4mAMRG/RJ5KIAGTj+shYMR6k8mLkDEjQfN+wWdKSj7HkqXKGVYYMfeJKhkJm5JXYZCkCQOjvK4AeRXZPjfcZRmYOQ3JqFtuGs+5kMixzLmI/zRNwlvLx6Ev7UbQlUHt5E4s7KoSHxtx5Ivfxn7PXSkELG04kDN1NKUjYux3qAaihhduNY/2fAgVziRWZSNyuyXZGvlIAkblrNOwvGYl2ATMxohUwobxSPMnP/kJOjs7h3Q67bTTNnp/FIlYL3THHXeIJ2zFihVrnS655JKN3sfRRx+N999/HxdeeKFEVJC0URFj7ySzy0499dTt6wlra2vDtGnT5EFRCSvhmGOOwfLlyzf7wdgYHtjaK/Ybykva1pUvtuKGDY4OK8rjyOZ1zPvUTZKITwxUr7YEyy9bcz+lzcgSxAt2wdrWBW5Nmu6CFIWzvqhI25ehiEmfilymxw3FZYpZP5dywhmJSeE0Ow9djgIySSdica9UKU165EY4nYZEGNDn9uKRVoK66++zpTfR58jJhmV7KogpwU6oziKmuVsR0NK4fMYLuOmDk+T6/PyppbvBAQMnTNq6Sdk2bGwOdnZP2AMPPNDfD6lpGn74wx/K6O/xxx9HT0+PhKbSj85RIDslN4bPfe5z2GuvvaQUfF3G/O5uK2dwQ+BWJXnPukBj/0AetF1I2C9/+Us5sUuS37yhoQHHH3+8hJmxZdzGzoMtIUeDDcwbMjRvDbJ0/KTZeG7pGhXHxobR+MVr0LgdnySqYSUyRi/YYDARnan89JFRQWMhOE8cdypxBaZ0BZpQG90wIgaau8JyOyb8sLBZ9eX7tzeXftYK7GTWmWka4nsLeLLIGkXptzSLCqq9cRxfPg8HeZZjjOaACRN/ToyR23EUWcIpk7ZuOKMNG5uNYa5ibQ28/fbb/SGs559/voz5SKAGq2XvvffekO6vvr4ev/3tb/HEE09s9mPiY/jRj34kY0eONgdOBc877zwp996uJIxkKxKJyDyZwWeNjY1iyues9N57793sB2Nj+ICE6cSjzsBJ+ybxyZcNJK+txYv/uW5Itzth8kFQI2GceKgLZmMzjvUcAMXjwYm7GCjKJsmSrU78jh/zDZuAbQZmPXMN3j3pVmwPDFbD1gVmilmKmNkfU0ESxlgLKmdcGjDDBhRvwdqadJhA3AF4DKjN1piyBF6XYbNM9g9EUgi5MpK4P9bfi8PCi3CAZzkm6Bq86poR43nTXh8WSfc2bNgA9t57b8nnGgz6uEjCuBi4cuXKDT5VCxcu3GLzPMNac7kc/vWvf8k4kt+zvLwcs2bNEhsWfWGbG9y6Wcb8gemzXP9UVVXM+jtTNMVoN+aXVKsTjv0coKsoBFxI1Tjh6i3g33+/+mPX3e/qi1E2LwatpRuFtnZou0zG3/75qBzMZp0/B8HGHNwrumG2tOHZZa/L7ewDnY2NYeKdc8QjpmVUGD5TxpT8q6X16DBdllKm5BQUnUVrbLk68mIwGVP9eYyt6oVbz2NqsAM1zhhSphMhPYWrZjxv/yJsjAxj/p3fxxd+seXG/Oe+fR7OOW34G/Nvu+02zJw5UyKxBqKqqgpz587FGWecgf/85z8bvA9uRvI6jKh46qmnPmbMp7eMY86NbUZyrDkU8Hv96U9/wnYJa6XZbWs3itvYMRicgXTiXsfC7Iui9f/KUPvfOLJlDriiBrTsmkUM4vi6r+OEaUmUm3Pl66KmQa+vwzOrCRjx7gNrJxIf3/A5KLqOs147HL8fv0ba3fe6i/HurzaeXmxj+2LSH2+SqIoNYdyP75IeyK2FUk1SIWCRrtUh9UBWlXUiblFqCY4V0U/EiBIBG1inxPthDRKLx/9zxA/A99XTHv8uPK4cwh4OM20SZmMEYScfRw7E/fffL6NJVgX95S9/EaFn3LhxEpNFRWoo/INBrcwzpVo1ULEq4brrrhOD/bAPa2Wh5lDx7W9/e3Mfj43tjF2uuQeK8KqfyNccJSpeD4qJGNov2Bvz7rkU4U/eiVf+Yh3cjvWfi+MqLkLXydNQ/uj7SM4ai5d+8Yu1Va0oVa71f8+/5/8I5AEcCDw8QHWzCdjwxMYIGCEdkas3LEsG/y1BaRSppVWJtTB8BpSCYv3Fkm+lwHQUoeYVqEkVS69am7yXCBjBGqTln78K5u+ssSuDYDUtJQZ+GzZGHEYRCWtqapKRI/NHuQnJESDPu/POO4WgDcUQz+uybmhDYtKOxJDHkQNNbR6PB8cdd5zMQjmGJDiWZG7G888/Lyb9oY4z/X4rpboEesuYRFtCbW2tjDsHg5IiNxY2lg9CeXgo2w/DfRx5XOh8PB99YK3zjt7/e9A7YyhUh/CP1ywjconQTP3NxVh69WX9hvVn/vsX8Xhlxobw4m9+ieM+/UX84421D5aMJuCBzr9SgZYtwt1rIrA4hhfeuwkHnn4XXnts6ykdNmysTwFzRjLI9bqtNTCSu6wmxEtI2OoicD2hoRApQI1r/eGzBP1kYvCnj0wrrlHGfnObFI4zssIufbYxoseRP9sK48jLRsY4cjRgyErYwBwMbgnQjM8upmzWmhO4XC5ZJaV5bai4/fbbcc4556w1j+UqKqMuSqARzudbY5wlIeOMd86cOZg9e/Z6c0HuuusukSGZY0amy01OypkjFYMJmDU+tEiU8cpkTP3tHCgTk5jwvAOeZS6Em9Zwa24MHvp/d6Kwhwq1UMTB3/oqsnso2HfK3Xjr97NxwJl34bE5c3D4aylUP+xGzq+i4FLw2qOXY/+z7gbeg03ARjkkCf+Lq5PstyFKChjBaIl4rxeKwXmkRb6YI0ZyRgLG6iM9WQocs0ACNvmWOSjki2vllykxq3LJLGxWNKING8MCfF+ys0dUrAs87jMMnoLKxsSX9SEcDmP//fcX/tDc3IzXX399oyGt2wOb5Qn71Kc+JX2RJQJG8PNrrrlGYv2HEn5Wwt/+9jcx160Pu+yyy1pf06DH1Ns//OEP670NOyy5NnrQQQeJeY8EjEm3lDVJ8oYbNmUbq6R0HXH+hTjgs5qMag76NlDJ5oK3PfIf9NXHL8Whx1vVMhNXly5nAxpUo4ieaRoKuyVxw6yncaSnEQfvdzde/8ZsjPkTsM+5Pvj//ZFsMCrVFTjykJvx4sNbJzNqZ8LOsj1X8l0NBduDgJVer0anWwz48z91peSDFb0FoGiRLb1PQ558Si2iqJtYct3l/R2VpYqkJdd+3FdYumx7/Rw2bGwzbA0SNoKI3EUXXSSiClVGesEeeughSarn9I2cYyj40pe+hHvuuUembxRl+JH+MgpJG+IS2wPq5jLKmhorSXogeB6jKzYVvA1Hh0PBl7/8Zbz77rtyWh++9rWvSY5ZKUz2vvvukzkyf5nDEYNztDZ2XZ5efvZKvP7IbLz50GzMmv0/+dz/9Ht49XHroPTyc1fhWN85mHyHRZTffvAyuW7ta1nkY04c423CZy+5tP/gJNf57WV4vucXeCH2azy/+C6JpLAT57fs9zWcMVQCRrDQezBIfEiaiGP+9c2t8pj4hoGvyX5Pl6lA1dck6BfGZC1lLK+u5fsa+DouYWDyvw0bNkYeDjroIMke/eIXv4g///nP/ec/+uijQsSG0tCz6667SmTEd7/7XbE/lZWVyfiYm5cs9p40adJ6b8sICopO5DzDioRxrEdl6YQTThAfGJ8Ifs61zIFP1FDHnEzZTyQSsn3AZNv1gWupVMJ+8YtfrPc6fCxM1B28ycAtiv322w/DGZurrty/z0Py8e8Z62MJLyQfFD/XQLg+aMIusz/CubseD/+ry3Fc5Vfk/OOmrn1APm6G9Q5jZ1B8thVG0nMz9Xv3WB+/a31cH+idGgiOBMc9eCsyMavImh2SA4lPKRz170f8QD6WaoK2FliXtOIL14qfizlhh01dDCWcW23O3zC2VvK/DRvDCjtxZdFgnHLKKZI/OjhaolAoSPo9SdrGQG5CtYt2qXQ6LeelUimxNNHrTn/7+jBjxgzhO/S/c0uTJn963gdapHYICaPX6rXXXpNCTGZs0EjPz0l8eNlQwR9qn332EZZJ8sQuJgazsSxzXTj33HPFc7Yh+bDEjPmkDcTGei2dTqew44Gnna2k+aiDbsLf3v87Ws7fHc8u/A9q/5rG3+Za9RB/+7dFnmnAP67m//D8fHtzbGfCohsutT5+91I0/PRO+fzit8/uv5xjP4JkZyCyWQcaz7kGqtPoJ0UcY8ptfnEHdv2LtRBSQsn0ftxL31jr/JJitqV4cP9fW6RsHYn7NmyMJl/YlpxGCsrLy/uP5YM3Ib1e75C2I3lsX5/3i+fTz74+MFuMfOTss8+WmAySwmeffVZGmeQ7VOmOPPJIuN1rB0VvcxJG1YpFllSmaHTjiZ9z3EeGOVT86le/6q8e4JPB++QTsr4KAFYYUG3bkJmuVCjOJP+B4LhzcGfUQFx99dVyv6UTjXs7W0nzP1+1ogbKFjIfAlhy8679l5cywrgB+XybFVdhY+fClJvmyMemr16BBU21OCXy7lpF3awK4lZhKWeLZnxuKTIAlcSHtUNCwExrC7HpwisRkpwt4IxXL5KKoBKeP/yHa33vkmJmw4aNLcQoUsLeffddnHzyyfL5QMLFqdaBBx7YX2+0IXAKxgXAAw44YK3zWUHEANaNhb1SZOLkjwITPeo09tNj9uGHH8rt2XNJv9nmYotWhbilwAJNnjZ3Y2EgMpmMlGFynLiuxFo+ARsaRRIl8jTYs0Y2uyFixfkwjX+lE/umdkaU/GT86GlO4sSZR8n5x025HCccP7REYBtDA0ntxnxjxwbP67/utsbi69cY1qc3tOK15JS1LmfUA0d9VLgUjyEmdsVtWB6sUu0Q/w4q1hYi8dpxlir26EE/x5Iz11bFSuA404YNGzY2Fb/97W9lK/KFF14QIz5HixRvXn75Zcn+amlp2eh9kGTR+0XlisTpxRdflAW9f/zjH/jxj388JCI3GCSEpRNjtdZX7r3NtiM3Fty6uWGtJE5Mw+VYcjDYms4ZMMegg8FxJiVHMlZmtHBDkzEXpeoANrEfddRRYtBfHzjm3JR4jZGIk17+Or5c9zKunnsq5h/4ELRay2y97xfuRjxVxKt/tnPAtrdnjEsQpetu763LB+fuD+Cptc4rRp3w18eR6PKJ6lXMAE2rox5K25RMxycOeP4KvH7cnRsNaOU404aNnRUctXdetMYruU0xwsaJW4pUKiUCDFPtScA4+mNv46WXXiol3kMFr//73/8exx57rChZzDPlWJHpCRsDp3xUzXg64ogjJH2fxI0Za0xeILnjdHC7kjA2hw/O8OB5U6dOXWfZ5rpA0sQ2cq6eklw1NDSIGrVq1Sp5sgaCGw2MseAvYl3gfVBqJFMmbrrpJpEPOcMlaSvliTFhdzRjerAN33zxbHhWOjCp8aswWq0U4V1/rGLhzZZnyMaOw9YkYBPungNXr4KPbrn0Y12My664DHv/7WpMDDdixerzZcyom2i84HLxjAVr40imXDCSjn5DftOXLR9WqZ6IBIwoETBWAy3//LVb7WewYWMkIBxMwf3T726/b7iDSBgN7CQhNLc/9thjctzeGLiJ+NnPflamWxwtUhgZio9rIBgpcfnll8tpc8AtSqpVfMwbSlVYF7iV+Zvf/EZ4BDNLSbpeffXVfoP/1sBmjSM/+clPrnXixuK0adOERJU8XhsDVSfOWOn/4vbB9773PZmtsjV9cOIwtxFoznvwwQfXeV8Mex0oB3LjgXkiNPLzc44XDzvssI+Z9Ucb7t7zMWhxDb7mooyeSnEXNgEb2Zh0m+X1GnefpVARy2dfhoLv43/sSMDo+3rnxNtkhFiCryop24clz1gy6YYRc4oRf/zvb4Gy2pg/GPs+a91mlz/fIARs0iM32uNHG6MGB79wOTJ5HcramcE7nSeMW4FciKOvmlYdkhma1DeEfffdFwsXLhSOwCkVp1McL25vNDQ0bDB1YUOgzYomfMZcUOThiVyHgfDbvbZoqHlfHAWuy9M10jDcaos2BwN9RiRbsy6YY/czDjNsjRGkjAcVQE2xEQEw3EWp+CERo6rFZHnGSbBDkab6Etma+dR1qPAn0Zf24PC6xXLe00t3w4SKbrTGgph7ys1CqBStiBVnWwoX76PpvKvW/1h+dyuKzPA6f/3XsWFjZwJjWXyqCx+cOXub1xZddfv3cc59W15b9Mw15+Gc04dWW0QvNlUvGuQ5wiMY78DpFO1D61K2OOlatGiR+K6Y7VkCr8+2nQ3hJz/5yQYD3Afiq1/9Kh5//PGNkkHmhNHMz2iLzQGD3kvjyEMPPVTOoy+N0zyeSpmkm4Ot2uFBEsYkWhvDAwMP7jzYv3Xz6B7HDkdsLgGbfKulfhFqWRaN/3c5jIqcFFnTQG+6TFHGqGpBLwoZI3kiAaPxnijzpVDticOlF3DPXo/KedfN/JtsNkb7vDJepJ/LzGj930tJWp9Pe/y7on4Nzgajmd8mYDZGExjLojs37+C+ucrJlp42BVSyOG167rnn1opuGDt2rEyu1gUSNhIuWoMGYmMEjHjggQeEXPHE4HWqbySBN954I771rW/h3nvvFaLLqRuXAjcGJi6w75o911T0rrzyyrVO3LLcGEiymFf26U9/WmIzjj76aDH8Uw2k8MQMsu3qCfvKV6yAz8EEjOM/Gt5sDB+UDN+lz23sHFhyjbXpOOuZa5AtZDH9iRuw4NSrhRzllgew/JI1m5AkaAQjJkjQGC1BdMT96Er4MO9TN+Hwf16Ke/Zas2at6sV+f1dJOZP7+vrl4g8rFjNYeNp3+w9CjKdY33akDRs7O5aecysQu2pE1RYxtmlwHibrBwcvqE2ZMkXI00Clp7Q8x8vWtV1IckZ/NwnUtddeKyTonXfeEXvQxvD222/33ydjqejB+sxnPvMxtWyo1qfddtut3zhPJWswOCpd18Lf+ggdSRvvh6dSAPzAINntQsLWVZzNuSl7IMlWbQxfImZj5wDJVibhQiKdw6LT12wmpru8aJp9WX/WFwwFiqmImb6orfkjSvUqlzPhdBawx1+vxUtH3SJE7KWjLCI22GBP9axE3nifmrZ2ZH2JgDFTzA5StWFj+IMBpIMX6VjtQ3/2QJBADR6xlr5mYOq6wLEsR5K8f44LSeyoFnE0SQ/5ULH33nuvc9mPfIMkjGNCbkuuSxQiaaSni1EWPG0OSFS59EfCxXEkCRiDWdnyQ6P+z3/+c4m8GEpUxlYlYXww68vcommP2ww2hhdsFWznwDlvnCep8VShxv32NiFgrBpS1KIVBeEaYKAvKlCKCop6EeN+cle/IlZSr3Z78npRwU749yV4HxACVoqb+Na7Z+LeWVbEC9FPwDbQOUlimI6vPxDZhg0bwyeigkXYLLAerIQNBlWkwd2Jpa/XF5xOksZoB24mkqQQJGPz5s2TmAjmfg0FsVhMRpuDkw1KQfF33333eiMpmDt6yy23yFiTPxezwjYVVOJI4Ej06P3iMiHJ11DGqtuUhFFmXN92wIYus2HDxubjoUX74terQjKC7I364HDmRO1q+tKVYqCf9MebkI+r/dlFy866QrYV831uFNUixj90C4qrg1dVhwnDzOOQv8/G8m4fDnz+CiSzTgTcCZQ/fwXe613b48Lb0pxP4z19X+tCaTxpw4aNbYitRMIY2zCUJQL6sT7/+c+LKsTbENOnT5ePDD9dF0i2CPqlBt4PydCmLO7df//9Mppk3BRTFKiA0WvG9AN+D6bhrwsUgsaMGdMvDJGQbQ5or+LIdcmSbWfl2arGfMqWm1JbZMOGjaHj6e49cHT1AnStCqNoAm5nHjUNPWKQV3qdqIrEAbUoxKyQst5fGQUNWiAvBn2nqyBqmcubh64byGQc+M8xdyPiS6OlPSzbkK8ce5fkf63sjEg0xdTHrNEElTYx6g8iYMwbo6Jmw8a6cOg/1ngTbYzMiAqSH3qhmJlVAg3zJEGlrDCOJRmGzi5o4plnnpFR4MBybE7QeD8DidnG0NTUJCNH+sJOO+00MdKztJsG+xNPPHG9G4kcYVIBI0nj2JU1QzxvXScSzPVhxYoV25SAbbISNnDTYfDWAwNbZ82aNWSznA0bNoaOp5buhvtXefCLDz6BiZPbkMw5kTdUtLWFgawGV13S+tuaV6EG8nC581Ku/eGnr5Uso+Us7z79Bsn1yhtZ1AbiWNJRISSrYKbFiD8Qfl8GBdN6j0Y1belnrxMVjGpbeTiBN4+3NiydmiGZYzZ2bpz6368iYzgQdqYRy7uxtKsc5f6UkPZP/edipApOeS3sFmzBu71j8fcjfiCvu5ePXpNdZ2NkgtMtbiWSZNHPVVFRIWZ3JtgPFGAYZPr666+LckUlii03HAGSPFFB45blrbfeKqrWpqC1tRXf/OY3N+k23Gakl4sZoxxnckFgffVEG/NzsXHnvPPOE/WPBPLhhx9eq4eabTxU57jVuc1zwjgLLTFazkcHgk8yWSPT6xcvtjKHRjJ2hpwwGzsHLv3fGcgXNTz59l7wVyWRSrigOQzkU05MG9+KJW2Vcj2Gq0bqophc1gVVKaIv60F3yoegO4NYxo1cQUOeyphmolhUkM04YJoKzLQuClqgPIkxoSg6k36YRSBX0JFJO6V8mypYRSSO9uYIXKEMIoEUUlmneMo40qSiZmNkK1YBZxa6YmBpTwV2r2pFT9aLrKGj1hvDot5KHFKzFK93joffYW3PRdwpqCiizJnCG+3jsH91I+b21GF8sBtvrhyH2kgM4wM94mHc2bE9jhfMCbv6tu/jS9/f8pywp75zHs45Y2g5YSVMmjRJMrKYFs8xHUeDJVDhoumeXq+Bx//a2lohKaZpCglidtj2xrnnniv8hGGzmwMm7ZNwUhEjEWNQLQllZ2dnf1rEnnvuKX6xba6EldY7H3300SGHqdmwYWPL8MyyGfC4clKqnWj3Q/XlYZoqfOE0lrVXIODLwCwqmDJ2FWYEWzHB1YmwlsKKXAVe75uInKEhb2iIxj1Y+rnrxd9l5lVUV0fR3hqGM5iV7UaqXEuzFXA4DChKUYgc36HxfCgG3jrh9v7NSpI4Xm4TsJHZIcvXxIxQK15qmSyq6HhfG+b11qLGF4OuGVgRK8P0SDt6cx75fHyoBy+umoqTxs3H3Gi9KGGuigKcagF1rj68e9JDYCHMWa99Ge2pIMaW9yGRcyKed+3oH3fnwmYm3m8NLF26VE7rAr1eLMNel4o1uIZwU6AoiiQunHPOOeLtoio1EPSGccFgQ9iSlP6ZM2dKX+WMGTNEZGKZOCsRKULx/Pb2duwQY75NwGzY2D7gQe21pQ4U8hpqq/pwbO1HWJEux0vvTUdeM8Xn5dANTAx348TyufhLx17IBzTs6WuEV83hkxXvw6dm8VjnPuhOeLHn09cgFi/CLKjoiXmhOKyYihlPXg8FOXhdOXR0BREKpWCYKurKo4hnXEgk3TKWNPIaIsEkEhkXaMewFbDhDzYjpLMO+T1z9NEcM1DpS6In78OkSDcSeRcWxyrhd2ZR4UyixRmCR88ja2qY4OuW0+J4FSaVdeG9vjFCvILeDBq8vTCh4KNkNS5++2y8112P5qQh2XMffvpGfPLlr+GJT2xeNICN9WM0FXife+65uOiiiyQ2gwobFbV1LQBsK3DsypYAEjCC0RSsQKRPjpNBErHtRsLYC0lcffXV/Z+vD7yODRs2thyvfDQZDk8eHk9OOuqea5kOTSniyD0/RIUrgTe7xsGpGuLJaS+EsGuwDbXOPsxNNWBetA7Tgu2Y4VkFj5bHqZPm4s9L9oDbk0NWKQqhouLFAybVLSpbsW6fvNN+/5O3yAgyk3XA783A482K+lZ0GIgl3XYw6wjAaa98BQs6q1Hhj0P1FxFwZrC4uxJHj1mE5clyLO6ziFfYlRb/X87UsSRegbA7Db+exRh3H97otjbZpofa0ZPzynUq3Ql5vWVNXZSy3YMteK17AvYsb8bbnWNxQF0juDP310M/rozYsLEp2H///XHHHXdIOOuOAEeug+M5OI5lUj6JGOM3qIxtFxJW2noY/LkNGza2DZ5dOh1feRlistdUU0aKQXcWPkcO8YILy+Ll2D1imUoPCizB33p2x/yuGlE3DitbhFZXCM3pMP66dDdRLuIhF8aX92Csrxf/WjZFRopUvBp+dTvMXBGqqyCVQ6WNSIIKXDTmg9OVFw+Zx5uzCdgwN9D3Zr1wCDE3UReMYVKwS8z0S/oqUBOIY360FtXu1WGbek7Ur2WJcvgdWfF46atJPceOAUcWTq2ASmdcrjM92IaE4ULe1BDNu2UM/kbPeBxYvhz/bJuGeNoFn/7xrCkbwy8xfySgtbV1h37/V155RWIy/H5/f+p+afzKCiM2AFx33XX45S9/ue1JGBvQS+C654bCWm3YsLHlqNHjePjwn6FMy+C9bB3+0HqAHDR5kHynZSyOGb8Q491deLV3Ep7K7mn9/wvGMM7bg/fiDVjYV4VYxiVGfPq5Ai9+G6m8g5ZqaEzPdxgyZuRIktuRJFz0fy06/XpRxjyeLBJdPjR9+UpRxTj6pJHfxvDCkS9+G2N8fXhj1Tgs78vBqRsYF0ygLRlEpqDjxeVTkM/qqK/qw8xIMz7oq8P/OuqhayaW9FQgGXChJ+2FN5ST8WK5y6pg6c764NYKWB4rE5W01hNDZ86Pqb4OJAsuZAwdLYkQJoa6ESu44dAMiTvha3KkgZucHVE/ciknGs+9eqcfR46U/8V/+MMfhOhQdSpVJW1PcNmCXZX0w//1r39d67ISEfvVr361ztT+ocIOa7VhYxhizodH44NsHKf72+BSfJjqiOK4SX+BV3Fifq6Ac9q/hKfmzURFRRxeRx6XjH8Rv1h1iNz2362TZXTJHDCa7HmwZSr+s4d9X4JemzMhMfpHs14UWWl0zjVSS6R6CjAMVYgY/V7JuLs/CT+fKyKbHP4HqNEIGuDnZ2oQ8VsZjdxaXdhVBXW1erpnfbOoXf9qmowFrhq0xoKiiHG7sT0VkAJ3mvGpapHkd2b8ooSJUurrw4RgDxb2VGFSpEuUso8SNViVCIvCFiprk7Ekx5v7l69ASE/jpa5pAP4xIpY2+P+BP38840Qhr8MbzEgPKkfw7518645+eKMeF154ocQ/cKuSRGdw6Orll1+Op59++mPPE/PJWLI9FNDzVUr1XxdIwtYH1jENzE/bbiRsfbDDWm3Y2HKw5/Oy1jIkHG5c2DMDuwea0ZyN4JPh/yGgZvBGaio+N/FdvNk7HoWiiqa+MO5eegx6416E/Wn4nDmE3BloQRPN0ZDEUvRmPKJuASnxeRFMwGcgK+uPFK0gZv2mL1kki+eRoOm+PHKrr7+eXEQb2xlfeuNLCDgyeKuzAeWelBS48/dL8mUUFYkVKQslxe83LtQrm5D0ao2N9ImpPuTJSPQEVSx6wki+SLhak0HMLG+By1UQpSttOFDmTMKr5TDF14GmdBnaMwFrhOlJYEWiDLPKVmJurzX9WJSosjxjrgTOePUiJPJZyRB78pC1K2eGA2QT+HPXI51zIFvQoKsmfL6M/N/IZ3T0Zvwylh/YyzpsMIr+H/7973+XwNb1YeHChes8n1lmu+yyS//XDHwdO3YsPvjgA7S1taGurk42Hlk/tKm5ZYPBsNddd91VxpKbAzus1YaNYYZ7eiaKstCuB8Vf85/uKWhLBOSgS9WLfp9jqz7EJWP+gY+ydUAVsDhdjdeL4yXAtScaRsCfRiLlRmUogXRel23GinAC7SsjUFwmPIGM9ERmkypcvhyyMReaLrhKyJeoXVEHmr4xGw0P3C4+MSplitOUg5fDWcBHn1m75NfGtgdJ9KTqLmTNBFb11ciCRjLvlG3EKeWdol6t7AsjHEyhoyOEKWPbsSoeFj9hyJVBZ9KHTC4MtspVBhLymiBpo1rW1R3ArAlNWJmMiGeQZCtdcMjIsSvtF7P+tEC7+BBJ2kjuXY4C7tnrUdmCdOt5zO+owYyqNvxm/9/IVu+zh903bNoUSrVbJZCAsdrL5UghnXUiazjgcllNEkvO+Y5sC2ezDnmTQt8kF1VGe0TFjsA//vEPOW0qGFtRiq5grAQjJfbdd9+1AltZxs3gVabxb2lGXHl5+WbffpNI2Cc+8Yl1fj44rNWGDRubh7NfPx9vRzUUihqak17ZfOS4JOJOI+RKozkRQltnBZZ2VAjBqvAk5WDJSIGDqy3PRHs2CJdawFttY9HaGRJFy+EuoGCocIaz8nUq5obmNOV8qiAwFTHoK7ohB/vlZ80WQqa7c2j42Z1iROGoJp1ywlytjNnYfpAO0JgDuUoNH3ZVY2p5J1o6auDUrd8ridKEYLcE7RLlFXH4HJZBviPhl9ePz5kXZYyREwtiNeg2vZgU6kJP1ofJ4S60poKo9CRkk5bbkvQP6oopfjCOIVszIUTTbngCecyqWSUZYA3//SrqPD1YEK1B0JPp96jN7/QJOWtPWcGuOxrcCJY3Hb1uRGpjQqpMQ7ECiVNORCIJaGoRiYKVa5ZKuuU29NLF4l4hZfM/tXZLzI7CaIqoGNjIQzLV3d0tdUibAhaG//nPf/5YYv5rr72G5557TmImHnzwQewo2GGtNmwMozHkpxd7sLy3TDK6eIDlSCmTY3GuBo87bx0QtSLcrjzaukPodvpkTGgaKnI1mhis6/xROJwGyn0pOXHU0hoNItnhgzOSQSiQRsrpEMN+OuUSPxBozneY0hFpZDUhZMXVzRzsnuRffj4GqgkkBCUzM2trbGw78LmeUNmDpp4inBUpJLIueW10Z3zy+/BzW9Zpkaal0Qok0i7URaKibpVUsHHhXhlbc4RIoz1T72Npt2xOcsGjMpDE8u4yjCvrRTTrEUM/Q1vLXCl5vXVlfNbmpGIKUWmLB9Ce8KPan8Ci1iosD5QJkeep4FPRk/LI929JBHd4pRWV3GB5EvM+9T0pqX/tjBtQ9vQ14nNceNq1OPyfl8LwpUTd42JBMuOUPtSePsgbFb7xoE+S/4fG/eguNH798h3684xGXHTRRSLusI2gFM561llnYffdd8c116zdZbsuRCIRVFVVrfMyns/LdyQ2q8DbDmu1YWPr4/iPTkJ7ylIyclkdvS0h9LSGkGr3oZBxIJl0I550yzSCdUH0sLDEm2TK582K4Zp4v2mMHJBdWgF9KQ+6k17ZamSlkaoW0RfzIp/TkUy4oaimhL3qLgNmVpPqIxiKjCad/hwgB1dg+VnXSTQF1YSln/2OmJdJwEQls7FNMP2JGxAOWApoZTAhXi+PIy+XtcUCQno4UqSvi2opVSqno4B41iXjQ5IKmuojrhT2jTRikr8LY729qPdHMTbcJ6oXtxnH+PtQE4pLLyTN+rwvKrDt6YAQr3pvVCIu3m0diymRTnljkM07sCoaktddmTeNKn9CRqIkh3tWtsh1djQBI7j5G496pOSeb1q45RtPeLDwtO8KEXvpqHvk/wdfyxMD3UK4OpsiWP75a2UsTyLG554bpxUTe+R3MtoKvHckDjroINx8881ifqeaVQJbe0jEKiutyrYNgcZ9chYGvlJNo3d94sSJ0mPJEvC//e1v2JHYImM+f6CGhgbo+tp3889//nNLH5cNG6MKNDKbxYyUIOdcGSyKVkML5mD0OaGlVRRzKpZ/c7YoVCRIBFUQHoS9rjxSWYcoGhwh+f0ZNHeEhVR5I2mEfWm5PhUUh6MgpI0qG7+OxzyIZ3XZkCx5Z4KBNPSHb8aSMy2jKX0xDb+8Q/54Lz7jSrnOkjMtfw0fIy9f8YU1fhsbWw4Wrbv1JD5RtVQCdvepbxJyREWzOhhHWzSA6nAcZe6UKKdUvAgqV1W+BKb4OzDRr2JXbwvmJsYioGXg1bLQUETS5UKdJyom+inhTtS7+6QnkiSM+V8JzSUErNydxLJohSirfRkPQt40GuMRTCuz/GedaZ/0TVJdCzrToqpJoG9RkdfmjlQP9xm7Em83NaC+oltIFkeJJF18bHyDQzKm69YmZLkvJmX3zak+eN05KBXW89/d58eys67GmBcul3YJXTeR7vLuUMO+giKUUbQhc8opp+AHP/gBnnrqKZx++un95xcKBcyfP19I2pNPPrnB+2CqPknY97//fXznO9/pP58J/IyY2FDXNcnfnXdu+I0mSR29ZduVhHFllKWW6wttZd+TDRs2ho5HD/q5EJ2xDV2iTNRV98lBt9PrQ6LPipIY/4O7UcwWZSyCQAEtLQqcvpyoYjTMN7WWQXcaYpwPh5PiZSHau0PSFcnRiseZh1k0ZITFDKmMqyD5YLIhqZti2qZSUBa2ggl5v6pWAFwF5DIOjHvwVok+aPjNbUBBhRFToHgLmHjXHCy7/DL7V74V8LV3zsJ/WzScUP8hbpz5FL70RkjCeUPONPqcHiHaVLBYJ0WQ8IwL9EqDApE2nKhxRbEyU4aU6cTFlS9hcb4SATWNd9PjMdO/ElHDg309y7GHM4EX0zUo05MIaVbExZvKBNS4YnirZxyOql2I9/vGyCgzY1jqV7seEA8iNzPdWh5Le8sxNsi/+0BZIImOmF+Upu0FqlxcFCHJYihxMlvAu81jsE9Dk2ScieeRG3OBpCiEzxz6I8vvqJpw+9NojwZEQaSSPPcUbhBDPGAsrmflk6pk4HbnkUq54CpLizJ89Ivfwj+OXH90wTbD1lKyRgiPKy8vl6ogojiIfHq93o+dtz6QqFERmzp1qpSKt7S0SOzF4BqkwZg7d+4GIypK+N///oftSsL4oLjqyRwOmuTcbjf2228//PSnPxXWasOGjU3Hv4/7Pl5MTUTc8CBV2AXJglMOFCRHNM4Xw3kgoUMpKCgmdKh5vqtX0XD/nTAKeegMUzU0pKIepFU3VKeBQkETUqZ7DfhcOVHaOL5K5Z1i6DYKGsKhpBiUOb6i/4wjy3jKLeqAaVrZYRxfujx5ZKIuuR3vm8QOLgPFtAalAEz93j1YdMOl9q9+C8BIhw96vfhE3TL8ZcVMAE/hjZZxqPAnhSxMr25DT8aHeNaJCZFuCVuliZxRC5paKYro9Kp2vG+Mxcnl76NGj+KDbB0q9RjG6jHU+OchpBpgDXKmCARVL07zx5AtdmNh3sDr6Yk4MLgUC9J1GO/vEaM6a4oWRyuFiFX6k0LAWuMBzKhok7E30dgXEYWpPR2SUd6WgK87VmltCOxAZTMECeDMyiZ8tPr8XEGTNxr0u83vrMG4iDV+PeitL2JutyrbpBPm3I0Dpn6EBk8PPopX46N0NfarbcJrzePlTUc+5UAmbY19y3wpGVke8PwVQsL4f4NY0rrxMZiNLce7776Lk08+GT/72c/WIlzkG9xupEdsqDAMAwsWLJDTUPH+++/Ladh5wrgZSUNcNBrtlwb/85//yBMye/bsrf0YbdgYFWjQ/TjTvwrtecvbxSyoExs+xOTaTnj9WTHON37tcpjhPIpO6x2cYijQUirMlC5eraIJqA5DjPT0cUnWl2457DmmosrGjCgSLvpc6ir6RBWjWsBQV6piDZFe8fQQJF+EphswDAWKXoTDm4OZ0QCm7vOPSEqD6Rg5766HK4576Rsy5nv56DloSpaJuZ2bhhPLu0X94ii5IxXAqq6wkGbWEzGmorIshoZQnyxY1IVjWNpTgUm+TrTkI2grhHC0dxVW5svxfGJXfJSrxpJ8EKkiMMHhh6ZYhwCX4sBMpxsXhVrgVvLoy3sQ0DOSkE9TP183HDtmC7oQmdpAHG83W5EpLANnuTdfcyT8W4r1EbCB/kN6I1fGwxKouqivEt+Ze4q8ZvlYDFPByt4wAu4sYlk3Qo4M2tNBuDRD/HJjZrbh7VVjpYzcLKryJqM5FcKB9SuwS107KqpjsrxCQtyT9Mq4nWN/+t+sANu0vHHZUf4w/tfc0tNIwW9/+1uxPb3wwgtixD/hhBMkof7ll18W0YeK1lDA/kd2ULJ0+4ILLpDz9txzTxlH7mhsFgljEEezxtgAAJJWSURBVBoDz4iuri5UV1f3B6fRI2bDho1Nh1a7BF7ViZOD7+G7DU9hSqBTzqdZ+siGRRhT2SseFs1lQPfngYostLIsjIAB6EXxiwkUQNGK4t0iuAHJTTpmSPXlrM219rgfYwJ96Iz50Zd2i6eou9cv25G8Xi6nywGHX4uHjKpaTofmNEQ9A1Uww4q2KGpFORmuIqbcNMf+1W8G2GjArcPlneVCxprjIRn7Mg2f8RBUukicS74vKqQ8UalpawujJ+NFpTcp9UU03XOEWOfoxavxyfhO21FCrI70fYSV+TKE1TQyRQ0vpdf95/9zgV7cWfci9vYtx6xgE3b1t6De04emeKT/e7cnAtilqh19aY+M8Zb3lclrZFt6pZq+cgVmv2f5gviGg+G0HBtyLMqxLUeSHBGyuouv3dKyQms6KDEunXEf9qpcJZuki8+4QeI82pIB+DxZLGmvwAP7/VZGlSRxbJxY0F6D+lBU3gBRBYv1euWNSCzllpE9u1R3CEaRMT+VSuHggw8WNcrlckmcxG677YZLL70U3/72t4d0H06nUzog9957b4m6qKmpkfPpBSMxKysrw4gjYQPxzjvvyJNBIsaPpfmtDRs2Ng97W1YfTHJ3IKSncGTZR3AoBqaF27F/wwpEgil4vZbxmduNjJCQTUYVknpvpi31ijlHKjcnfRmpL2JPJEM2kzmOW5ySLTWpsku22+grCgVTYvbmwaUyEhfiJhEZaScKBRWqbq7pjtSLQEGB3u2w1LiMAsUEDCfQ8PM77F/9JoLBphFvGiF/Gk29ERn5MgusYGhigE8lXDIqrvLGMbW2Q8gBCVBjRxkmN3QgkXViSWcFlsfKhWTQKH/XomPwTtdYSb5flq3CY9G9ES14UacXMMPpweGe9fthQqoHZ/qjQtzOCr6PY4MfyJLAtHAHZoabZUuSKhLbGbyuHFIZFxacuvUDfBn6OhCvtE+Uj19+64ui5B7X8BG6016JmiiNMhnTcui4JbLtyNfvopZqUcYYLsvnggG1rFS6YOIreH3Px/DuPo/A58mJ8kUyvGtFu4x/qSAvaquU3wtf93z905zPkWQhx4Eu5E2RjW2LaDQq9UQkX0y633///fGTn/xkyLen2kWxiPapf//73/3nJ5NJyQ775Cc/iR2JzfKE/f73v+//nGNJrnhyDBmPx2Vt1IYNG5uvhhGLmmow3tEpgaovxHbHFE87wloK/4ruggnhbtlu68gEkDM1GWExtwnejKR/8+BB9Yt+MKpWHCl6vDmUhxNw6wUx5DNRn8pAt+oVr1iNL46cS5MQWI5dWIHE23q8WWTjLuQMBR5/FumkS9QvlSGvaaf1oJlT5ipCySswPEWoaesAZWPTOgwzhQL64h7ZMKyuimPuqnp4PDkhEodPWYwX39sVS7UK7FHdjMV9lULUSJY1xURw9TbiF8e+jl8s/4T4uagIUUWjt/BfnVNxROUiuc6rmWqUaQkcalWDbhAcURK1Wh5j9dfgVYp4I1Mnr6WHug4UhYkl8VtbASPJerdjLN5vtw5R3FZkCT1Bf9b7XSrqA1FR5pjxNTnYCf3FbyFnJjHW3ytj2uZUUJ4XkjV6xUhq6WGr9iZkxPp0x0x8bXrpoHwzAi9cLn43Kn4kavSWMYC2O+FFWTiJ7h4/asMxtPYFV4cco5+MbU+MpHHi1kJ9fb34wDiFY40Rx5HptLX1vTFMmTJF7FLEYCM/ydlQYi6GnRI2sLCSxrkxY8ZITxO3Dp555pmt+fhs2BiVmNrQhmO9eeSLOk4IzpWPXjWLvfxNOCC8XIqS9wo1Yf/Icuxb1iixARzBTKzoxifql0t1Df1gY6t6xEBPNSua9KCxsVKiKRi6yW02jh3jaRf6sh4ZM3H0SMWA7/Z5O/pl3MGsmP5JwDierK62EquLzqIY8l29KrSUAtUAtLQC02mKSd/G0PHuSbdyiiyYUN2Nlt4QqiJxUWFInD/srRbFk72PK2Llct6e1c1CQujVolGfBPyHC4+Qy97uGItaT1QIGD1R04Id+GfHNImqWJGrgIYNb4UNfmPgrFuGqQ4fxuh+MfJTRbu85gWcM+Y1UY62Nn657+8wvbxN/GHsyuRrlpuKbIBwqCbGh3rkNfuPVVPlOVgWr0BLLCiEsDkZRkfGj1pPTJYJKrxJ7F29Ch92VstzQ+LIkTwDahk4zE1JjjXbeoJY1RcSIsbr0e/WE/fh+PELUOlLyFhyeXOFKMV8g1LI6vJ/bMLd23kEP4rGkcTtt9+OpUuX4g9/+ANuvPFG4RjLli0bsp+rvb1dtiIHkzCOJg877DBp+tkQOK4sWa4GgwGyVOd2eIE3jfnrK9K0YcPGlqlihNFaOmhaMQJEl5HEY/GpSBkuMfEzHZ+RAaeVvSXer3Z3QII6VzrL4HRZRdyOQFY26Ei0SLB44oGEWUot3SFouilkzShY5/M2rHdhSn8xr0J1G2hrLAeP4VwIyFcUoLTrMEuimAqoWRUFzwj7S7+DQEP5k427W0b7JFATiYsPzMMRX86xmjCbQhpUzcD+lSvwzLIZErC7YkUVwlVxzOsJCnHbp3qlFG8v6q3EITVLpX5oXGUPGjNl2MvfKN+v2tGH8Y4uTHPQQO8ZcpPDx1+Pk4WUTXV045ypv9wmz81DBzwgH9mfyiR7KrxLj/r1Wo+FjyNqptFumJigu+FQNCzPJ2TpgOg1UmgzgMdjszDPVSPGfPq9+H+FCllX3CfRLTOrWjG3o1Z8d43dEexa0yZLEF53Fm90jpfQ4wCLzzMO+b+U6vLCX5VEcmUAy2dfJv2B2wUjzFi/pTj77LPxla98RXK+/vrXv/ZHU9ATRlI2adIktLa2bvA+GPLKYNavf/3rCIVCMrFjvNa1114rytrGhKNHHnlEAmNJ5gaDj4W9lByV5nK5bUvCbrtt6OnHV1999WY9GBs2bAwdFZoPXw03o8NYhEdiu6LSmRDPS3M+ggPDyzDPUYfXW8ajpjwqmVKyAakbqAnG0RH3ywEmYbpF9SIZo8oV8GZEWeAIzAiq6OoKQHOYQsQcvhzyMcuwpmZUWQBQkxqK9CcrEq4PrF7hV/PAISfdgf88c6X9K90AaCif8eQe4vFa2l6BpNMhafQchbGCiI0IybQLDRW9WNkdlsLsmU9NE/N9Q/0yzO+rkd9VOu/Av1dMxsy6Flm4yJoO1Lv6sCJTjkXRKoQdaUz3tcBHNdWpwqEMjYCtj4wNJGTbGj/ee0AQ5urHkGoZJxudJGD0r4VUYEEuhXvaj0FTImK9fouqjGOpbEVzbunPpNobz7mQzDmRTFnKbsiXxAcdtXKZQzPl/8nKWETI2mFjluKFJbvItiRHmhzjxxIeGcmnVgTR+C07DWBb4rDDDpOw1BIBk999KiWk6JhjjpGYioFJ+utCT0+P+L5+97vfyWiSuP766yUnjPEXGxprUkGjkX+gl2wguKD45ptviir3pz/9aduSsPUFs9qwYWPbY+A7/8HoNFRcEmlEwszAr7pl6y2jx0X1IJpTYTnA0AvGgxMJGMdaJGbcDKPhO+JPiRqTL2ioDcZkQzKddsqWJWMHaEymKbnAaAy+FacfjNuRVMi4JOkoijGfBydeXtSA1oN1wHYnbBB7/PVa7FLehs6MH5NrOrHknQZEpnfLeLJkNK+NxEQdIzn47KsX4pGDbsZJ75+Kp1bshnhLAFooDy2UxIENK4SAMNfqrvnHYmGqWszz+5Q3CTmvd/RilrMLDsW/Sa+7db3mtjX4PY2iiT8mKvFGfKIQsVP/+1Uct8DyqPF1TAM+fXEEiSrBBZRdKtuxuLsSNYG4jB45YiSZZevA4niV/D/gZiXHvT0Jr3we7/MiXJZAmcfqkczmdfFKduV8QrzCnjSae0Myvme3KrtWtd4d5H0cRUpYS0vLegNVeX5zc/OQ7ueNN97AtGnTJOaCpKqjo0M2LjcW9kqF68MPP9zgdZjcP2PGDGwuhkzCyDpt2LCxY8CD0vrUB266ESRgHUYS76Z3l3gCGvmn+1ox078KTdlyORB3ZANoSYSs9f2iGx5ujGWtWWK2oMmYhgc3bkaGAikkUm458HDrsugqiNKldDthukw4U5rwMGdUQS4EFAIGlKICZ7cqY0lj9ZanjXWDPZw1gW5RYaZXtsv4i6Ot0NPX9NfvJOO6+KK4zUe/3pK+CjGmv9ZVEGIdrItLY0Llc1cKAeNGoPmPy9BTWCa+qlvnnSD9j5V6XJQhhly8kjERUHOY7nDI+G5jr7uB2B4K2GmvfAUHvBeRYGEqfLWBGI751zexuDso41nWJ0VTHonwEFJU0OBy56WKix66gCMr1+NGJMe27MVkBdOLzVOkRWJ6fRviabcQsFKavtObk/EkM/TYrao7DCF4b7RNhOYuyO14XSOnAiRhjMm4evs3RPDRjqZx5COPPILnnntO1CZmfBEOhwNf+9rXJPuLnvSheNg5dmS1EBPweRoqOGbOZDIbvE42m90ic/8WR1TYsGFj22OoikSV5sOlZcsk6+l4bxaHexfieN8CXFD2Co4OzcchkcUSNTAl2Indq1rFb1QeSMq7f/6BT2RdkknloYesoMM0VInD8PiyyCWcli8sr0DjGJKRGJ4ismWmHBjUnAo1o2Dx9ZehqI+ug8XmgM8xI0PoQ6JykzdVyQhjEj0N4y5XAbqzgJNe/jq6Ej7xI9X5Y5Zyk3X1l2YznsHvzEmtETOxpofbsSRZibNfP18I2KcCc7GrqxlHetrQbjjRVgjL1uPGCNhQlditjccP/pkQTGZ8UfFiBAWzyGI9Prm8oycozwU3IKl8kYDNrG4R31ws48arjROQ7PDJVvCMyjYJmG1LBiVGo7oshg+ba4SwMXYl7E9JBhjvh9+LzzNfuPw84MnCG0oL2asqi8n39oUy4odkZtkOA9WbrXEaAfjSl74kxvgXX3wRvb29YshnZAV7IKlokVCVUvA5WlwXEokEvvWtb2HlypV4/vnnhZT5fNZraWPgQgD7KTdUxcjw+iVLluxYY74NGza2PdZ1IGwqJHB7+9G4qOLfCKl5vJ+rweJstZj1b6j8EHu6KEe5xKA81ZfCO9k+dDt96DH8aMxVyEE6lvOgK+3DhEiPfE2ljKQMBYgi4HYU0Jf2QvMUYMScKNJD5jNRZLE4vTcRA2aSCfqWV2zinXOsv/Or/WHrw8Q75mDZlZaawE7KUon4aAGDVttjARn71pVH5TmnCkliRl8e4xHonV/eU4bKQAJ9mkdCWekHY6E2y7af+MRP5b44qiNxefKQ+3HTByf1f4+rZjyP6PunosIRR8rdJFuN+41/d5PJ1PYgX2wHKI38XjvuOtw+/zj8bsl+kkWWyTqE/OxW3Yq3lo8TVXD3qhbM66yVTd9Y3i3Plyww8HWnm9Ly8May8SiL8E0GkMvo0kbBNxW9zSE4Ihn0xHzyGicRLhWP71OzEh9018pjKven0NIVlt8NyViy12P5IW1sF/z973+XSIqhYH3LgU888YSc6C+j0Z/Vivfff7/0STJui2n8rDRaF15//XUJe+VW5g033PCx0ejnPvc5HH/88WL631yQ3o0MSrydQRkyFovJCiq3KWzYGOp4cHti8MHxoXg5XotNFi9LztAkvuAPEywZfyBxo5d+WcGLj7J1aM2H0ZYNyWWl25EEMMy1zJ2UehwqZDSKZ1MOIOqQvxx63DLnG+6ixFVQBaNKRn8YPWFqVkGhMg9kVDiimrVJmVGl+9L0G2j68ug27TP7iiM3qpEE64r2/tvVEo/A8zhSI+jdi64MwVmVksw2VyArie8MMn34wF+KeuZUDXj1nGzJEhw9c1HDgIqvlL+M3ca14E+LZ8GhFHCKb82GLZEt5sXkPlRs69c9M9PoiSsVc7Mnkr5F1mrl8pZuwKUSBtly/NjWF8DU6k4saK5BMGB5GzneZa8kr0MCR9Im6plmoiyURMiVQTTrlqgLRlckE27J0iPRYk5bMurGtHFt6Ej4xR8m+Xh8Y1FQ0XT+VTvkeHHmmWfi2hvvwVe+98ctvq9H7zkfX/jcqes1nO/McDqdOPHEE4WQ0VD/ne98Z4OLh7RicTGAahdHo1TUGFlBBeyQQw4RAvbjH/94sx+PTelt2NgMDAcCNnBTrfR4PufvxNcq/yUp+35HFi3JEI6Y/ykc+P5pSJk5PJ4IwqsoqNX9ONit4oJQG74aeQf7BJbLyaflUOeJYYKvG7tG2sTYXelJYGzQ6pN0efPyV6PoKEowK4kViZeSVbD80tnyjo4fFQMo6kU0nXeVXL8QNIWAsfNyxbdmQ3Gu+53naEJnd0Aqo7ip19YXFJM+jeFsNOAojuoLCTHJxyf2XiAKz/iGTjHqM919ecyqW6FyZkKRWBKHYqLOFUW1Ky5Eery7C29kxuPXCw/AQe4WVGlrCELpdTNUAra9tiKpWpGgchzIKi4qsT53TjZIywJJ6dCkj5HdkHyevO4cGnsjGF/dLT2o3PQlAZtS1oVpFR2yfMLzuGDCbUgqhiRXeUOV/kmqYGyLyGQcQsAYRVFT0ycjUKps2awDbhI0vp7XQcC2O0ZZTtjFF1/cn9NFc/2rr76KefPm4VOf+tRm3R/HmLwfnnRd7+/A3pAax5EkR5Nf/epXce+99+KyyywF/6STTtoiAkbY40gbNnYisJB5utOL6c4WHO5djNfT4/C75gNlPf+u7j1xTvhNtBg6KgbYgRbmPcgVdXTlA/hk+XvoM7zydY3eh1f0qejJ+bCgt1oOZPSF0R6hxTVrGzKpwdRXb0by77texKTb5qCw+rwJ99yN5V+ZjfE/uBum24SSVSUcs/EcO8ZmxReule3HUiQIs9syBYcsQ9CjNCYURXMsKGrOq8sniopDozpJRGsyKOoQa3aa+tCvXnZk/aKCHVf2gQT8njP1Dfm9LGiqhUNRcPCE5ZvsQxw4Bt8eJIwxEV29Aew6phUVk5PQFROLuyoQT7lRF4miJ+8TIkbyxOesJ+ZFwGcpgEy35yYvi7wJKoRUFCOBlHQ+VgXj6E15xHTvdZnoS3okC48EjvcVdGbRmfRJ9ROXVNqjAQT9adm+XP75a7f5z27j4yoUvV4cHxIkQMzroiL1m9/8BuPHj98oiSIikYhkjVH9ooLF3siHHnpIiNxQqha5AFAifcwGY0zG1oJNwnbiUZWN0W3et8I0u3BOcE3Gzp8S9ViSqcGPM2VwqQV8IrhIyp3DWhLzkvXoLXixMF6NjqQfu5e3SuI6q5HC7jQ6+vxQ4zrUnALDbVqjR48BJacisFjDxLvmoIgiCiHTerdtKDDdRYz74d2yTbkhM3PDz+7csWbnHQT6kDyOPNr7wkJySRaY5UZvEuMV4kmLkHFMRsWnzh+VLUpu9zGKYVU8LGTh70f8QHxhJGIcSS7K1OKG3Z/u/z7vZsYgoDEPqXWTth8Hvqa219801hPt99yVaI0HRRWbFOkWVYxkq7G9XCIjuPXIjcdu+CS5PqW5hHhNqugWvxyfh3p3H97rHSPkiqpjKGQdOPncJjIu6Bo3JzOW0uvpldc9yRejLRjR0twdklgWqm783QwXlN7wjAYcf/zxUotYIj/0dbGhh9lf/JxVRlSqNoQLL7wQ9913nxj7//jHP4qKxc7ITQVHzcwlq6qqEuLHjU3mhG0phs8rayfDjsjWsTF6IblKq8n/e1mrR3AgluYT8nFvVzP29y3BWeVv4LDgQsQND1KmC8uzVahxxtCeDUjAJb1KVL8a4xFRXUjKCu1eqSRiVZG4SdkhmdLgXaUhVVPEsssvg8nJVhFo/NrlMIMFNP7f5UAk10+wGn5jeS8mPnyz9fWvrD7A0UjACNZJNbaUwx3Kwu/NSGcnCQfVG+a57TmmGZWBJMZV9mJCpBsL2mtE9WqI9AoB6+gKIuDMYrcnrxdyxiqfnKnL73AguHBBsv3ainH955VeL4NH2oOxvcNZCRrmSU5rA3Es7KqS6qGyYEoiIqgaVvkS+LC9BiFnBmNqesUjtnu4BU61YPU/9kbwascEIWMc8bJyiNVFQVcGp9R/IEsRR9UuwrRQh3y/pOFCLOvGjFCrxFTsVbNKvl9FICnbw8vPug7DAsXRNY50Op1wyXIRcOihh0omFwlYqYCbl28MNPafcsop0j/57W9/e5MJGDcjacpnZhkVuAcffFBM/atWrcKvfvUrIYdbApuEbQPsd83F2+JubdhYLwYeKC9begaO+vAUnLL4eBy34GT5uDhfjl9Fa3BD88l4vGdf/LztMLwanwy3mheFZH/vUkQNDxo8vVJ1VOOLybiHZIyEoCfqQ9FjSAwFCZhiKDD8hpjsF9x+KQoBE+N+dBeKLlMIGMmW6rJ8X41fvAYTVpOupi9ZY0hupMnXFwwDj80OBEdcVZUxqYliUj6T8fl8UwFKZxyY316DjphfaqUaoxFZjKBpn0pN+4oyBIJptCUCiPV6hXwQ7E1cmlo7t+isKe/g2IkLceB4q76IGM5q/ZIzrTFtIueSjx+1VAuZKquISyk3PWBUDOc314qHblZVs6hejKJgOXdtKIZaXwztcb8k5DNrbZynG88c+iM0ZspR74vitj2ewARPp4w76acjQXuhaRcpA1/QbTURdET9aO2yllaGCxj9sqWnkYL//Oc/+MY3viFq1i233IK//OUvcr6maZg5c+aQCBVjKbgBub7Q142BlUdUz+bMmSPKGzuy99hjD3zzm9/Ecccdh0cffRRbAnscuQ0QWrrhcDcbNrYVOJJ64hMfL89mcD0DP0muFscqZZV/cW8l7j3pT/jky19DpTshqe1/PfTHEpbZmfaL4tId8yGXcqJo0HyvylixWFYAYg4ZQzJclNArMjIWajp3tdeL4a4DonUGKwmLTr9hxL4IGBzK8d/WQntLGDX1vaL+aIopfiUZt4WS4lGi6b6xMwJNKyIcSaKzNyD+MD2cQ6zTj0h1TMjJ0rZKjKnslXFcXVWj5IuRdIxUZA0NyaxTRFe2CbTFA9L0IDEUSlFqhyrCCbnOux31Mo6s8sYlc42Xx50unD3pbfyrcyq+8vYXsDKj4FcLD8K7CQPHls3DyYv2xavxMuweaMYzLbtJfh4VxLnddTi4dhla0iHJX3vxyO/v6Kdi1OLRRx8VwnPJJZdIJtg999zTHw3BuqJ19TkSRx11FA4//HAZVTLclZ+vD7zOyy+/vM7LuBDA700VbmAwLMeQfDx8fO+99x6OOOKI/jDZTYVNwrYBnM29mPGj/wNw6ba4exs21otSbtS68J9j7l7rayavEzQ9f5irgc+bxYHPX4HHD75TDOM0ODPw0uHJI9fjRtFfgMNdsMq9qXB9Y01v3tLPXS/kraSzlOInOHZcdtZ1ooQNm5HOFkCKq18ul5+LfZo0128pqAYqv7sV1ZVRLGuvkMwwl1YQTxi/ZlAog1vpS+rr80HVTeSiLkRqYuCuI5UzZo2ZeRWdcR+C3gxWpcJCokcy3jz+Dkz+042SiL+w1wvdZcDrzKOjN4Dd6luQC+uilAVcWal14sbjHlUtOGTMMvyvq15CbV/pmYT2eAD7l6/AwkQ1Hmg8GEfULJLx+/vReuwRakbccOOkunm4Zrdn8fDiveWyRclqJPKu4UnAtkbQ6ghRw4rFohRt8zQQNNXztD6MGzdODPjMDuPIkp9var4YwdsxxmN9yfysP+KCgE3ChhlyYyOomEvjjA0bwxccNRJVwYRkVA0Exzfjf3+LeGkS7X5RvdSEhnyQMfnsKrKk/fPfPBcP7Pfb/qTzgTjj1Yvw6EEW8drRBKyUqUVM+uNNQho3B5Nf+pKMwXy+lCSwT33sexICuqVkjCNb/ZEbMXNMM+auqofTVRDfl9HjQkuqDBU1MRiaIlENflcWbY6g5FcVUjqSqyXHIrcCA0k0tZahfFxKFLGRDo4lS0GuHLfSt3XwhGV4p20MKv1JGc1yY5Rq2PhIL+Z31/S/rpmW354OSKhrynCiyhUXYsr6plpnDyb5XSjTk/jWrv/EE0tm4ucffQJnTfkvvvzWF+HR8jil+n08j+GHkTRO3FF44IEH5DTw680BzfgbM9/z8okTJ2JzYXvCtgHyfh1jr1m0Le7aho2tghlPXt9PvPiRPYUDQeXKzGtI9HmgeApS1G2EC5YZ359H04WW0lUiYIPB1PZHD/o5Mi0ThsVvrETAiFJfIEFD+1BBUsrGgGzCJf4txiSwY9NM6aLYbCmWfvY7mNtcJ1lWXlcOS9orEBnXK6PKcm8S8YRHKqWau8LIdHsQ9qXhK0tLMnwklESgLCm1O2weePaw+2TLcGcAFduJgS4hUFT63m4dK79DbjVyNEmvWHUggZmhZiFgbT1BCbzVVUMUxY96qrEyHUFbJohk3oUxzh5EDS8aXD1YlYvg3g+PwpPds/DPnuny/SZ7O3D/Pg/ha9OHaZDpKDLm/+QnP0FnZ+d6T6eddtpG7+Oss87C6aefvlnfn8Gse++99wavw8t5vc2FPY7cBjCcKn4//iU8vC3u3IaNDWDcT+6yNhLXgXPeOA8P7v9r+Xz+p276GAEYiJJyNe53t8r4S6tMI+jLSPH3a8fdudFYlut3pwsNcNcNPZdqe4Hj0RK4JTcU8Oeb/koBmZw14iP5ymdciJQlEIMXuaRTiCsrcQY/t5uCfNyFyro+GaUxnLW3149iVkOmKg4jp8HpTwtB6+p0S5J+OumEqhXR1RqS23E053/2KtksHKxujlS8ftydeH315wypHePtQ1PSCqr1OnLQmQwMBxKGC6mcQxLxSdCI3owHXkdePI7HVi/A/EQtlmaqsDxZLhli0/zt6Cn4UO2yuiGJf3dNpZ17h/ysNtbGb3/724+l+rNL8txzz5WGgrfeegsbQ0NDgyhajz32GDZnMYCRFNdff70sBgw295Pcscnge9/7HjYXdm3RemDXFtkYTbl16/NscYy3T2gFdnevRLmaQrWWx5ixW56NM9Iw7fHvyrZcqnf1iE8rSg4alUFnKItc3AlPOIN01A2HLyceLo50NxdUJmsicdnYW9FjEY5UwgV/MC2+qO65ldAnJeBkenzGgZA/I6O5k8fMwzPNM+T6nT3BUR0wyrHiL/f9naTvk5T2pTxSeM5tyDJnCi41LwpZlSuB+X01W0Rat1dt0XXfvQf/d82Wv71/+CcX4AtnjdzaIrfbjQ8++EAM862ta2ffDca+++6Ln/3sZ7LZWChsuk2IqfhcAmBiPjPLqHqRmPF70zN2xRVX4K677trsn8VWwrYB7LBWG8MFHKFptdaBuHVVLWrHrPsP1kACRp8TtxcfX7InPu17acC1XNBqN192H6mghyybVqFoxTVEy5NHniqUpwDTUKE4TKR7PPCUpaWAmoGgpQ7EzUE+7UDS50BzZxh+f0bUL9bq8L4ZzloIGxgTjsk4jsb8VNaBunAMv/ngQIyr7pbKI34cfjrk9gMJGFEay7K6KWr40JoL4Y49/9y/NDLisDWM+SMcmUxGSNisWbPwzDOW6r4+MGfM4/HI9dkB2d3dvdbl3Ix87bXX1nt73v/BBx8sHZOsLfL5fMjn83jjjTckf4z3uSWwSZgNGzsxBhrG10fABqMmHMOJ756JT/veHdZZUtvrDdXklxRoDkNIV45+MlNBOJBG1p2XfC612Ql9fBKqJ49s2oGGmh7xZiWbglI+/d7Jm07EmKdW9/wVMOMOTBjbgveXjRGvWK7XhUwghYmT2ySGgflhIW8aDtWU72lkLFI2eBPWBnDetNJQ08KIJGA2BOXl5aJwff/7G99e3W233ZBIWONpbjGua8NxQySMYB4ZCRfBcNZ0Oi2bm1sDNgnbBhjtBy4b219VnXD3nP7Mri0FgyzHu9d+tzhaMeGZCwHdRNGhQPMUYKR1OPw5dNOrVVBRX9uLDndAlCuXL4cZDa34YPEYuY5elUZPa2iziRi9UOzZnLeqTnx5igpoFWl09/mBcEK6I126gc4+P8ZW9Ek9z+Tx7aKOMfvto/YqLD5j5Oax2Rg+25HsXmRoKUkMCQjrf+68884hERGOaF988UXJ3Nprr73Q1dU15O973XXXSSDqQDByYtddd8X7778vZd4bw09/+lM5bS1szd5IwiZhNmzsBIR+axEw4r22ejEyXxJZk64+GtHw8ztkzFjMqdA8eRh5DTqJWKsHqMzKSLK1MwQz4UC4LoZo1It5jXWyzdgd9cHhLMBXbVVI0ZcUTXo2OaS2cXX4bcMv7xBi5/NkoWsmZpa34OXGyeJTY78hVTH2I3apVvH1wg6LgLHgm5VT75xo1UXZ2AmwA0gYR3IkXF/84hdRWVkphvlwOIyrr14dzrwB/PznPxfiws5HJt1vCubPn/+x22SzWdxxxx1SHWQYVhzJSIZNwmzYGEUY/9AtWHH2hs3aqZgbK/Ia9n33TJz9ehseOmDzMnZGugI54S8KinlVmgIK3R7AAArOIsDy8k4XcpG8BIgyNo0EjGSNkRFUqiTQ1lSlB5KmcEYldPX5pc6pVN20KWD47YQ/3ILezgDGje3Cgt4aOb86FMeqzgjaYgHUV/VJZtbijkrZ3jz6xW+hN+O0CdjOhK1VO7QJ93HMMcdIcfWUKVOwZMmSfoXq3nvvFXVsQ4sIX/7ylzF27FjZLDzkkEM2+WE+8cQTctpSlAgjzfm///3vpfNxzz33xPjx4/urkHYU7JwwGzZGEQYTsMH5YITqMCVyoTfmxVur1hQ+jyZM+NuXoXgNOAJZFLUiig4TWtr6c8nezCLfnNN/1emW89QOJ1S3IQSWGVZm0iHHOQaqNrWXSaWQw2HAH05jlz/f0F9kvingpmNFdQytvUHp9Wwo6xUF7BMTlyLiTSOadmNssBeZXjdCgZR0KNb7o3LbPf56rYxFS9+XyhyxOY/DxujCYYcdhuXLl/cTMIJF1txQJKlZH6ZPn46bbroJX/jCF7aaYrXrrrvinHPOET/YUMHx5SuvvCJ5XqqqoqbGegOzePFiUdQYebEjYZMwGzZGMQbngxGqasqojTU4mzo+4wbmSAdHf0pGE8nBaPOK8qVFdRT1ojQFFN0mir4CwFGl1yoxN8oKEtqKmI5C3AFnJCPBrn09Pku9UE1k271I9Hqlfoig34uEbFPAbcv79n4YrX1BNPVEEM+68FrTePidWXx24rvImTp2n7ZSiCAN+qUWg9jiiPjSSiocNwaZAecL2T23IwtFSLv7lp6YrOZwSLTGwBMJy2BwjDg4Nb70dX19/Xo3Eh955BFceeWVQuA2B4899pjUDw0MXaUPjKPQN99882NVRuvDpz/9afGhHX300WtFciSTSTHcf/KTn8SOhE3CbNiwgYYH1qSr8wBe6PAAUccmPzND3cAcrmDSP434TFAsZjSYXgNqny7F5WpOkc/VuAYlpUHvcUDJqELEnL4cFLcBd10SbC4v5DVogbyVJdblQr7PDa0sC0Uz4XIWEIykpGYo3ezH+B/cjfH3Dn2b8YRJC7DwtO9KiXdXd0Dub2VfGH9ZORPdaS9W9Ebkd9iT8vT3gy6/dE3PJ6MZDv/npQgE01hw6uaHTNoY2Yn5Z599tmSbDTyty+NF9Whwvlbp6/V5vFi0vWDBAjz44IOb9SMeffTREivR2LjGl3r33XdLXySVK4ak8rEORcXiGJWhq8TgRQKSM3rcdiRsErad8eaKBvGb2LCxqdiWr5um869a8316XRJG2njJupP3d2b88qXDoSR0FN2rxyckUSRkehH5kAEzYMjnekqF6Syi6DOgRnXkszqKKR3pmFvGlWZGQ2VZDOHKBFxjE6KgsV6IiLUFEI96oLlZBwWYTovglQjTUEECJZ2TmiEeMFYa5Qoa6oIxTIh0I5t1IJrySFYck+ZLUDUTK7vCmLcFyf42dqwnbItPq0uwubk48HTbbR8fT7MeqKKiYq3zSl/zsnWBcQ7cpGSwKU+/+52V2cYi7KEoWEceeaRsVJYwc+ZM1NXV4ZprrkFvby8ef/xxvPfee9h99903el/t7e2YOnXqx0gYySVHrStWrMCOhG3M3w6Ydf4cRKcBhdosvvB2HgsOtl6QNmwMy+iTQF4O7qMNVKTE/+W13uWraR1mKA+T6fhFQO/TYXhNIJyHUVaUrUgloUGrTSEfc0HJKyiCylgB3mAGnb0BmDTop3T4qxNIp1zwh9JwlRuIp1zI9rktk7UC+HfpletPveEeLPrepZv0uEvxF1S4UqYLvd0BUdyKhgqvO4esVsTy3nJMuOduOBqSyOfVHV6obmPHg4GjQ0n35+jvG9/4hhCvUrwETfas8OE4b13YZ599oOtr6MXhhx8uhnimzy9btmyj37OsrAxNTU39Xx9wwAEy1mxpaek/j0n5Q1HCmHbPBYKvf/3rCIVC8jPz8ZEM8mfaWNjrtoZNwrYBJsy5W0YSHGE4a1LoTmcRjiRRMFW4meXzr/MAjN46ERvDG6ORgH321Qvx2gcm9KgGM+8A6wiLKqBGrc+NgIFCeR7gtiRtNVlNSFdkQi96OoLWiCeYh0LVzFCQTrrkfrkx6a1MwuPMCwlj6n3adIlHLFiVQCLuhtbshlmnIB9zojA5M6QN1nWhFD5Kr5eZ0RGsTMDnyok6lkw7YXhMeB0FGFT3bIxcbOfE/KeeekoID03sF198sShm7FIkuSl5w7h9yET6Sy65RLYNqT4NRIm88X449twYlixZghNOOKE/34vK2ksvDWzvACZMmDAkv1lPT4/4vqjGcTRJ8PEvWrQIJ598suSe7UjYJGwbwDEuiQzf5ToNGMv9aLziMjSuLld2vqdi7MrCqK4TsWFjuOHNV3eB4jVlxMjRIEzLq1HwmkLGFKcJpc+BoqMoChNyqpCuvqgPSloTEibGfVOBO5yR8SA3F/3hJGJxL1JRDwJlSZgm/TVFqTpij+EytRx9poL4yiC08iyMuEP8XMwoGzehc7OS7weSaC4ZeMtSsplZObFLglzjvd6t/OzZ2F5QdkBYK0kKyQr9XX19faJwsUPxwgsv7L8OvWE08LPSZ2vgwQcflJqg//73v1JRdNRRR0lPYwkcTVLVIvEbClgxNG3aNBlfcjuSKfk0+W+t1PsRS8L4Szz22GPXOo8S5GWXrR08ydntZz/7WZkTM/Tt17/+tcyDt/R+txXWt1HW+H+XCxmzYWNrw+4r3XyM+9FdMFUTStZSiEjEtIwC01GUzUd6vJQ2JwrlBYucOQ2YPK979SZZRQ7oc0iiPhXwTLcHWjAnW5DprHUd+r9IwJJtPjjLM5Ij9v7KMVAaPfBOiyGZ0RD0p9GbcMBflUCyOYC2vsAWvy6YL9b/c/7uVhTTGpouWnOeDRtDwdy5cyVXi8n5DEsdnBpPtYkkjB/XhX/9619yOcnPUNDR0SF9jZdffrmobCwvZ8xECSRkjL/YlOgLEi7+HDwNJ+xQEsbyTa64zpmzpr0+GrVybUrgyixntlxV/eEPfyi//B/96Ef42te+Jkx2c+/Xho2dCXZV1haCf8tVQE8oKPiLQsBIxsRkX56F1uqCklNlBMnLuLhQdBWBgiKeL8ZYGBldFDKGuxp9TmihPLItPqkvKmR5nTzGTe5Ac1cYGquQuEXpN1GIuaGmNPT1+KHFNCSdDIZVoKpFTHj45q3m3xqNY+adEts5rHUgaIpf590Vi2hubl7v7XK53AYvXxeocjETbF3405/+hA2BVUfcsBwKnn322bWWAEbdOJK/GG46rA/MGWHfFEPaSiyaOSEbkz03dr82bNiwMf77d0PJAlpageG1jkxqRrHGjppFwtQOlzUH4sgxnBfipcZ0IW1FlY59E2pcR7EsJ8Z86EUoeSbmA0WXiXzCKVEWKbixKuOA251HoaAKySo4nEBWhVqdQTGnQR2TghF3AW4Dum4g0+pDw8/uRNNXNm1z0sbOC2UYjNCGOyoqKrDLLrv0f73HHntIcj+JHX1sHGfOmDFDIjDeeuutHfpYdzgJY8M5SRWVKmZ5PProo2tdfsEFF8hWxUAZkxLkxsx9G7tfGzZsjG5MvGsOijTga0Xkg4ydsOIotKyCgl6Ep1WH4S4iV26IYb9IX1hMF/M9r5srM6AG8lA6XTDdJlBQ4ejRkK/OI1ielBgKRlNwfFl0qBKAaxQ0+N1ZxNMuK7RVK0JlH2XMCcVbQCGnC2FTIjnrQa4+3jbcfyeaLraJ2KgHXw/mqH8WNgrGb/BUMvDT1M+U/YHbnKxievjhh4dUAr7T5oQx8I2GOT5BJFk/+clPZOOiBM6COYbkE/fNb35TzHq33367EKwtud91gWPPwenBNmzY2Dlx1/xjZaxIAqblFLg7VPmapnyqW6wlKniKKPiKcLXrMprUe3ToSRVaUhVyJgSsw4VieU7+klIdMx2Aw5dDPOaB7irAE8xIkTcJWC5F0z2QyjmQSTsR9GVERWPUhbs8Db3ZBbXTKY9BX+5GYmVQcshIAF0VO3aDy4aNkYpjjz1Wjv+D4zRee+01qV+i13zUKmFcE+W2RQlPP/003nnnHVlH5VpsaeTIjA/Obf/+979j//33l8A3XodP4Obc77rA9N3vfve7W/1ntGHDxvDDj/55rLVlxpGiAiFVzj7V2oQsrh5PeorWaFK6I4tQMooEtiqmIuerrW4UQgUoCQf0uIpCRV76I6mUodeJvEdDwWVAIakrKoiUJ+DUDSFhTlcBAVcWxco4ursCcDgKyNTkgKwGRziDXNQlCfzIaSiOTYuCxo1J21Rvwx5Hbhq4TFBVVbXOy3g+Lx+1SthAokRw45Ez2lI5Z+lykq6vfOUrkvPBwDWyWra4b+79rgtMCh6YHLy+TiwbNmyM/DEk1SYzxG1GFnIDKg32ukXAHHEFal6BI6ZCz1gbk+42DYWAKR4xjixNd1GCW50duhAw01WUKiOqWrkeNxDJwR3JSBm6011AXVUfFKUoY8iAOyuki72PLNyOlMcR7/SjvrYXZfW8HuAI5qAy8qKgSLwEU+7rx3Xv6KfOxk5UWzRa8PTTT+OMM87A9773PRlNsg5p4sSJIu6ceOKJErexIzHsaos4BiytnbJgc+nSpRKqNhBsP6+trd3s+13f9gaTdAeebNiwsfPBt0rB8tmXwbPMKduQJGESR8FQVncRBY8VxqRlgIJ79WjSVxSyJXEVWRK2IhyVaZiT0siXFSTSgn9NlZwCLaVKXlgm7hKvl2laRI5J9qwS6or65aPPmcPSngpkcg5ALaKlPYywJyOGfT9Hla0uuS/2UBorvWjpCGPXv3y8cN3GKALn2VvjNIqY2Lx584SEffGLX5S0fiYskFewf5Ll3uQTo5KEMfDt85///FrnMceLNQR//etf+8/7zW9+I1UHXq8VMOh2uyU4bqCZjipZKY5iqPdrw4aN0YkPfmDVAjnjgKtXEZO94QJyYVNywej/khJuf1GWIknQOJokGeNospSYmet1o5DSofnzyJcX5LbFgFV5xNR85C3ylYs70d4TlCohnkNS5fNk0RHzI+JNI9XrgZ+Bqu6ChKlSJRsTikJvSMKszMHjzcI90XpTSDXNhg0bm4Ynn3xS0vKZssDg1+nTp8v25PosTaPCE0ZVijkeDFxbuHChrI9S3eI2JP1bJdx5553S80S2yrEiizxXrVqFSy9d06/Gy9kttSn3a8OGjdGNEhnb5Zp7oJI7KZbCJWSK0RPWP6u+SLxhsJSpsgIUh4liRpPbM+Ve9RVQzFgGMyNihboypsJXH0eizyPjRI3qmcNAMuZGNOaVOzf9KQQrksjldbmsN+WBrpqY9/44ua+ivyDELZ10opjQkYgFJVZjxbdnY2fCw4v3xllT7L/PQ8FW4eGjkMsbhoEFCxbIaThhh5Ewhrudf/75UiFAYsUQuPnz538siZdjQkqG3IjkpiST7wdXFdx///145JFHNul+bdiwYYP46FaLjE24ew406Yy0tiJlU5KkjGTJVRSfWH9vTNQh8RMcOwpZ6nUCIWaIqdC7HWLS522TKwOA10C+0yP3m3WbCJcnoGsmogk32noDmFzdhQWL6+GvTAph8wSycls1mJOssFiPT7xhekxDIWygSMP+TgYSsO/MPQU3znwKl7z7Odw36487+iENX9g5YTsVdnhOGIPTSiWgG5vr8rQu0Li/ufdrw4aN0Y0jD78FqSonXp99Gcb98G5Rxej9ovJF8kX1y/SaKLgob62+kVaEuyItHZFmQUWRxd4s+w7lhWwpSU3iJZxlWWQTLhR9BRk3sq6or8uPcWO70BULwRHIwSwqYuJnwbfuMpBp86F6Yjd6oj5UhRNoTpVJd2V4t250dQasdc6dECRghE3AbIwm7HASZsOGDRs7Ei++dG3/5yRg9GEpPU7hOiRjhTDPVKB4DLj9WSFJVKoyXR4Ea+OItQSgpVWYOiQbLF++hiRle93wVqSkNzKX0aEwnNVlYFVnBJqvgLJQEq2xIMoDSbR2hmAknbKpaZiqmPO74z7xkhXTOmJJN1y+HLJd3BywMRpBEVaxw1p3Kgy77UgbNmzY2FFYfuls6YlkThjrh0yqX6tjKTgFyud08Xkx3Z49ksklIfGQGQFDxpdGmxd65+pi79W3S8fdUupNxczMaTDTOiKhJLy+DLJ5HYmEW8gWr6t4Cpix1wqksg709fqEnE2o75K7K5oKsnEXqsevuyTZxijBVtmOtDFcYJMwGzZs2BiAZVdcBoMesJQKNbu6C9JbgNZlxU0kOn0oZjVRv7hZSfLF8aQRyUMpAIbPFMXLE86IglZMadCYrp/ShUjR1J8taMhkHEgk3ZItVhYgKctCc5hY2lUunrHa6j4Jdl3ZFYanIgWj1SMVSImMa6f4fc1+7/Qd/RBGJuycsJ0KNgmzYcOGjXWA6pYc8Jh4n9ZgBAuSft904ZVo+vKVElfBTLHll82GN5y2NiPDBSvGIupANuNYc19pDc7KlJWeX1Dg0g0ZUXLkqAVzaFlegVTCJZ4xnp9KueS83m6/5IZlkk44xiShakWkmv0j/vd174dHYXG8Er9eaG2127AxWmF7wmzYsGFjEOi7YfCq1BWl6dC38sTMmI4Jc+6WtPxiIIsVX7gWh/7jMnTELMOOw5+DkdegOQzk4y6o/jz8/oyk5McyLmR7PEK6emNeCXLNOAxEginkvFloqolY3IuacAzN3SHZvtScJqpCCajhIlq6QzDyKkIN0RH7+zr/zXMx2duBxekwnjzkfpS/eS6A13HI32ejzhfFIwf9Ykc/xGEPu7Zo54KthNmwYcPGaux65T3ykepW4yWXo/Frl1u5YQ5TRpQSV+G2AlsZSzHux3dhxZJqpGJuGUku/ex3MLGuS6qHqJbxYzrjQPPKciTjbumF9HhycLk4ulTEY2YWAZejgL4+H8ZVdwsBY2ZYsDwpj6W1O4R41imqGcecc0+5ecT+vqpdMVyz27P48d4Pixp2SGihnP+fY+7GVfXP7uiHN4pS83f0D2GjBJuE2bBhw8ZqfHjHpR//I5lVoDALTLf6IsEA1ZwKBAtAIA81kJetRWaENfz6dumEZCo+4y7I2irDCQQqE+IHY+QEw1o5Ygw39KG4etPNMBWEQil0Jnzwe7PIZpyItQVg5FRUl8UQjXsRjXoRDlnEbKTitj2ekI+n/ver+Nau/8R5017vv2yvcavWuu6ipprt/viGPUiezK1wsjFsYJMwGzZsjGrMuMxSvwZj4h1WFRqJl5ZUAQbkm5CkfAamsprI5c1D5+gxp8MZzIpxvqMjBI83B6U8i6A/jc4+P/J5Hf5QGm09QVRVxqSuKOjOorI8jtRqoz0riQxDlXiKikhczPgOTx77VDbB6SzA7c3hvZNvxUgHR5JPfOKnG73e1AY759HGzg+bhNmwYWNUY/6cj6tfxLIrL5OPHEsSRZdhbUsqRajegiTjZ9u9Mlqk70uuYyoYU9uDXSrbUR6xkvGpehE03E+o7kY8bZGuprYytK+KQFVN1AdjqAvG4NQNq08y50DEb+WLPbNwN6R7PdA0c8RUEG0ID+z324+RMhtDBUfiW+FkP+HDBjYJs2HDho11oOGnd1of778TJmMqkrpsSPKvJo33/mm9cFSmkejzIt7n7SdbnTE/3vlgIrp7/OiLe0TFYlBryJtGU1cExaKClcsroTsLCFQlkE66ML+pFs3RkHjDGORa5k0jnnHBzKtwe3JwhzOY/6mbRsTvaVM7IAeTMhsbgZ0TtlPBJmE2bNgY9Zh2nTWSHPeju/qfCy2hySakYiowgwUUGdzqNOEIZKFpRfS1BVDIaZKSz1R7vyeLSCQhMRPBujgcroLEVmhKEV5/Fq1tEYT8aQS9GdSM68bYij7Eu3xwuvNiuHc78+hLeIR0tfYG4XYU4AtmxEO26PQbhu3vaNrj35WP3HAkrpv7KRz30jdw9Ivf2sGPzIaN4Q+bhNmwYWPUYsZsi3wtvPlSTL51jmwsjv/B3XLe8tmXoVidRdFrQI3r0KOaBK4aLV5kYi54ytMIh5NCujjfiadcMk50OAtIJt0yPgz40wh703BohhA19kG2t4ShKkX0pd0S6LprTRvc7jw6FlSKmiZCh6mgqzOIZFNw2HdFHj5uCS793xmYFm6Xjcf/9Y2FUzWQzDuFmF389tkS4zEQd80/tv9zXp5pmbADHvlIDWrdGon59nrkcIFNwmzYsDFqMf/uNX6wfMBE0Wmt75eIWNFQgYIC02PCqM6JMV9PK/CEMjJWjM8vl+u43HkYBQ1tLREhX6ahoCqYkOu0RwNIZZzwBzJCrryRNPKGJiddN7CgvUbS8z3j4ygUVBQKGiojcfhCaTH3N557NYYzfrbP75Evavjlvr/Dikw5yl1JjPH24fi6D/Hp+vfgUvN4+WhryYEgIXMoRv/X9+/zENx1y/Hs0uk76CcYYdga25E2Bxs2sEmYDRs2Rj2ogtGAr8VVCWgthvPynJAAKVkVWkJFMW9dlqvOI7c8IGpYoSYntURpdkOaipRzV/qT0HRTSBZribj1uN/YRkwq6xKyxrFjIu1CQ7hPjPe8nL4xhrUyV4wZYX1Jq6R7xdlrysWHM+6b9Uf5eO+sP8Gj5YVYkWhdtus/kDUd+NIbXxID/vc+OBn7VTTilb5J/bf91cKDcMm7n8MJkxZ87H5v+uCk7fpzjARsDWO+jeEDOzHfhg0box5LrrkMU26ag7y7iKJndV3RajR+/XLxPaWjbisfrKBZ1URZVa7mqkjDNFTkE05JzF/WWCUJ+22wRonphAvvto6VGiNGT3R0BSUTrDfjQSbthKYbqAwlpMSb40iSMZ4aQn34cIR1Qd6952OijBEMZeV4EmiTTLAS6BmrcsXxnbmnIKBlcMG0F/Dw4ixCcz+FjOmQ+yB4+fW7P7XDfh4bNrYHbCXMhg0bO73n68Az1hjuB2Lad9ZkhBkuwPQYaDr/Kqi9DjT85jaM++1tchmVLn9ZCkWnKaGtVMSc5RmE62PIZ3XJ91IyKgodHjh8OTHvS5dkzAFvIItcVheyJeXbCtDbEkJLcxlMjjo58uQ4NKejLhKF352F15nHXw/9MYY7bp13Qv/nJfI0ECRfC1K1a53X4OyWxPx9fMtw+YwX8NTS3fDf2FQsTlQhbTjwrXfPxNmvn48PYnU45l/fxFmvfVm+trG10vJtJWw4wSZhNmzY2GlRtiCPT5xyJ1571Mr62vtLczDr/DX+pIU3Wp6wybfMwbIrLkPTRVfK1yu+PVvKtjmObPjZnXI+VStvWQqusjQ8dVYCfjLthJnVJMler0zDUZNCIauj0O2BkdKlyojHvFAgLZ6xRI8XZeEk9GAOkco4nJ68GPlZa2TEHVi2pAaprBPNLWUYDjj4Bet5Wx+odg0Gla6SMnble5/Bh701eHDR/tjjr9eKgf+iXf4rl7+fGocfLjgCf+7aR0iZrho4KLAEEUcKYUcaE3zdyBQcyBg6HjrggW30E45A2CRsp4JNwmzYsLHT4j/PWKTq4E9bmV/v/OYyFDVIJAWT8ifcPQe7XHsPlly79vbepD/eJLERVMOavnKFnLfsrOuEiC0+4wZRvsLBlIwP6QPL5h0yjowEUqioiMNbm4ArlEG4Oi45YLGkG0ZOw7ixXejp9cnWZG9nALlOr0RWcK5ZObZXyFk2r8sywHDAK8eurSCe8epF67zenA+P7v/85plPyscGVzeypi7m/DfiE7F39SqkDaf4v/65bCoqHHGkTKdch+oXidbZU9/CZFc7FkarsTBejdPq/zekdP1RBZuE7VSwSZgNGzZ2Gkx8eE259ZGH3yIf//vUFTAdFqmZdcEcmDrgSAFFFdBTCj66xVLDJt45R7ofGdK69HPXixLmcBfWun8a5Zl/Jeb5mBcBb1YywLjd6ApmxWRPPxePkyRofd1+uZyfO705dLEbMpARwz7Hlloki7yhIliVQDzlhtOVl43JuoZuDEc8etDP13k+DfiD0ZyNoDUTwut9E1Hv6sOXKv+DSmccHZkAPsiMxfG+RXilezKCjgx68j4x71M542jyorEvy30M9JLZsLEzwiZhNmzY2GlAterIQ2/BkYfcDDVdwBFH3IpDTroDWqYoo0gmIxS8CkwNKOqAMwpMumMOJt1mjSNJvJq+egXGPXirjBNJxgZi0iM3oiPhh8eZh8+bRZknJarY1NoO2XDM5Bzo7vNL8n0u68C4MV2oDsYxpqwP5UGrfJuOnLGVvfB5cjh04hL0dAWgawYMQ5Hi7upAAumcY4c8f/RfbS5opB+IkJ7GIwf9AjMDzWjNhfCXvr3RnffJ9mRPwYevLz8dn6t5E305j5zn0gqiivH065aDkS3Ye2PrhF3gvVPBJmE2bNjYKbDnVyyv14svX4uiQ0U+7MK//nWNjCRzARV6tohcyFLEXNEiFDYQ5a0s1HzEkHR8xHTxgMmZHEf++nbMfOq6/u9RE4ljVvUqTAx3o8qfQGN3BOPLe7CkrRIBdxYV/qQQsnJfCl5fRpLv41kXzKICp2Ygl9MkJT+WccPryuH15nFwevNIpl1CytgjubI7jPc/aal425N8nfPGedjF3yZeLkZD0L+1KbhxprXJ+OW3vriWX2xxqgpdWb88BzXOGMZ4elHtiMKr5/B09x4SXLs4VokyRxIJw4UlsQq57B9H3rsNftIRjqIdUbGzwSZhNmzY2Cnw3s8uw6En3CGfG04VpqZg/7Puxl5fnoNMuYpMWBElLO8HkrUKMpVFFLyAu1uBu12H6SpaBd2aNTp0+3NyXyQPxH7PXSmEYVUyjMZYBNGsW9QtXu7x5KSeqCflEQKRyjskqLU2EkNh9fZjX8qD8lAS7lAWPmcOLU3l8LlzMn5kwKtDNyQ3jGGt2xOn/vermBVsQlMign91TEWy4MJ7sTFYnixfa/txXfj5R5/oN+ITrCtiaCtx/0eHCiFLFpxC7tKmUyIpliYr8cdV+2K6vw0VroScxvt7ZHRpFlVRxB4/+Gfb/Oe2YWM4wCZhNmzsRDiu7EKMZrz87JU45OQ78PJzVyFZqyMTUWA6gbn3XQrDoyBVU4Srz1LAtKwVS5GNFGEwKZ9cSylKOGu2y4NCXsOB05bKqJAErC/hle/BcSTN8yRfJF4V7qQQrY6oH73dATnfoZoYF+kVfxhHkz5HTkgWx5VUuzIFHYrbkILvVIdPzPv0mFE9W37WGuVtW2JRUw1Oe+UrknC/LF2JQyuXoNydRNJwIlVwCuH8X2ysXIfG+1JMBE30JTTlyvuN+BxHPn/4D/sv+0vbnpjs7cAB4eWS/xXQMxLSSg/Y+Q3/lXoj+sNI+ugVixdcWJkMi2JoY33YShEVdkrFsIE9dLdhYyfC8z2/wGjF4Uffhpf+YVX8UAFLuxWohnW04QZkTrd8YJmKItS8IieOJLWsIhuTRV1FwW+IEqb6ClKkPbe9To5Z7IRk1teqzoicPybch/Z4QDohielV7VjWW47xFT2Y11oLl7OArKFhl0gH3m0bg5U5B3TNFEM+A1u9DiuRn8qXI8LtSEWqil4/ztri3B64bMVpQsCaU2EcVLYMr/ZMtFL+8y5MD7bhuNAH/Sn20+d+SrYXf7zgMHxt+p/wlbe/IKGsy1PleGjRvliWrcIs71IhbEeXL0BXPgBNWYx9Pcvxl75ZcKkFvNw2CQVDQ6CyGfPTYzAt2A4NpnjACH5fEtztPYodcTC3BoOyWdhwga2E2bBhY8ThuF2uwmHH3IbDj7LCVD/xyTv7CVgmrCFdoULPFGG4FOR9ihjwvW0cPxZhOoCCr4hc2JSP2bIi0tUmFHP1X0TawVa5kVoRRDrplBDVzp6gVA75fBnsWtWGeM4lClcmr2NptBzjvD3YrbIVyzvLEfRlsHtVqzyWj3qrhMCRgHkcefh9GUwI9mBVdxhTx7RjQrW1BckS8N7VStt2ef5e+gZ6Ml7M8Leg0p3A31pmoMyVRMCZwUHly2Sb8W/RPcQfRrzcMRkvLJuGxelqUcKoXHFUWe2KY0GmDu9Gx+Kp3r2QM3Q0ZcvxUbJa4ifeSE3C250NWBirxsUT/o1ZVSvxbkc9+vIevNk1Dn0FLwyoWJKslJGkTcC2V4G3jeECm4TZsGFjxMGIeKGnDTi7U0LE/vvXK7D/56zS7bd+P1tiKLIRRfz1HD3mQlTAFDj7VGhpxdIBTMUiZa4iHHEFhrsILZCHmtSQr8rD9Bsw4w5JwWfaPceTsU4/Yjk3cgUdh9UugUMzUelN4l/NU+R7e905zChvw4pYGQxTxV4VzeiN+oSA9aY8Eu7aFI9gUlWXKGndSS/c7rxkki087bvb5bn77KsXYqK/G0FXBgtT1YjnXZhZ3oJdfO3IGA6wjInn50xdlKoDn79CfFpvpybiHyunYZa/Ea92TUTccGNpogIL4jXig/tv8wQJVv0wVoP2VBCduYAY8A+uXoYGXw+6CkG0p4MYG4yi3JFENO3Ggr5qvNExDvPaauX2NmyMNtgkzIYNGyMCM79+Dw483QoP/cdr30FRV5Ae40fBp0n8xBt/nI29z7M2JGnAJ9NKV3MjEsgF+bEo52fLTRieIkyvCcVQoMcV5CoMmKE8zLwKM1SA3uGAklahBvMoBgpCrjg65KiSm5DJjBPv99aLwZ6YXNaFd1rGYr/aRjGi1/mjctlLjZMRCiaFgNUE4yjkdCGATb0RJFMu8YjRira9fGBElTuO+X01SOad8GtZ1LjjSBScyBZ11Hv78N/uSQjqGXRk/PBqOYTdafGHdeQCOLh+ORak6zA91IZFiSok8y4E9CxWxMpxwrgF+GTNXFHWqKitSJTh+x8dJZuRyxIV+POqPVHnjeKTVe/j7827IOJNQ1dNaQg4evxCzP/UTdvtORjRsJWwnQo2CbNhw8aIwNwfXQpPe7b/6xdfuhb/efpKpMs1OFKmRFRkwwp2vfIeIV403S+92krIJ6h2mex8jNIPBjj6VOhpCCHTo5qoUcWMhuD7ThQiBTiq0+L/qqntFQWLqKvrkTwwmuyzhi5ZVq3xIN5tGou6cAyLolV4v7kePj0nKteetc2YVtaJseE+ePQ8yssS6OgJSjwFE/cZ7jpvO5KPT778NRwZ/FAeyx5lzdLXGNTTUjDenfNjrLsXY329qGKUhLcPvXkv0gWHjApfbp0sPzMXD0jKeKr2xsRQf2ztAvy3fSL+1T0N0bwHBVPDJ8qXYkZlG6J5NzqSfkwLd+B/XfW4e94xGBvsFWK6vK1CngvWFtkY3iRMURRMnjwZ9fX1Q76Ny+WS23g8HvvXux7YxnwbNmwMS+z25PXwPhLCm3+Y3X/ei/+5DkcceSuKKs30CjIRHcw1zflVScUn4dJT1ilTDky8aw4MswjDZ6JQaUDvdHABUkaQpqcI70oNalZBemIOSswBRQFiM/JQUxpyigvBuijiabf0Qap6UQjUmMpe5AxNMsCYmF/pSwiZirhS+LCjBj5PVsz4DHHllmFn2odY2i2RFdyMVDUTUyOdKHMmtzv5WNZbhsec+6DeG0WFI4G0x4FXOyfilAkf4KN4tRRo54sq/rh8b3m8dcEYZpWtxOJ4FQ6tXYL2bBCxgkeux7GlQzFR5onio0QNditrRWfGygObEujA0lQlcqYmXzNXrTkVkkWFRQrP12Wk63Ln0NUb2K7PwYgGCdTWMOZv4l0cdNBBePjhh4VU+Xw+vPfeezj99NPR3t6+zuuTeN1yyy044YQT0NrairFjx+KRRx7BxRdfjEwms+WPfyeCrYTZsGFjWIIK0UACVtqAzJQ7EJ3gRC5gSVyOZFFM9dkwkBxjIllfRC7AZHwesFbXE8VV6F3W6K/gM1H0GChqReT2TCDdkIca1+Fu1eBZpcHZqcN0m9D9efQsKZOYCbcvh0goKbVCTtVAZ59fDPhMzF/SXiGq0PK+ciFj0v0ISGL+B011ErmQjHpQKKhw6Qb83gwePvCX252AXf3+qdizuhlBPSvRESRJVKx2jbRJkv2UQCd6c5aKNSnSLYsGfRkPInpKvF6dOT/qPX1C0hZHK7Gkr0LIGMeNjJ1g1ES5KwW3lkdXzi8K2Kp4GNGcByFHWqI8mEXGDcywM41ZtSsR9qWl5cDG8IXf78cTTzyBxx9/HDU1NaiqqoKu6/j1r3+93tvstddeePTRRxEOhzFt2jRMnz4dRx99NG67zVqksbEGNgmzYcPGiEEuaBEctQC89tjlyHsVZEMKsmUKnDHADOdRqM+K/4sjR44a1Syg5RTZeuQ4UonkoGQ1wGmi2OQTg77pM5CuL8h18mOzcPRpMHpdcNZbVUMs2SYZGxvpQ1NPBE6ngf2qmmBCEWN9LOWGYSqoCiREAYtHPVLYXVMZRXNXGOUVcZiGiu6uAN47+dYd8twdHZgv9UD/666X3C5+zlHiwmiVKFqL45XwO7KI5d2IZj2i4pFkzo3XI1NwoNYdw8pUBAt6a2Scycsa4xG0pwOoc/VBVUzZmny/vR6vNY0Xs/6MsjYhXZXOBHqyXlR6EvI8Leiuwlurxm3XSI6dBkVzy0+bgFNPPVXI1Pe+9z35Op1OC5miykWFa10gAXvsscdgmtb3amxslK+POOKIrfAE7FywSZgNGzaGJY6bcrl8POy422Xzkdlf2ZCK1x69XNQt4t0HLkM+oIgKFp1RgNrrQDGpo1BWEAJGhYwfufno7LWS79VWN7SECmezA4WgIaMZR4BMzTLvqx1O5CvJ4IDCUj9iHX4hWV19fgk4ZQ9kZSCBrpxPEvLHR3plc/K8Sa+jPRaQxHvdVUBdTS+6on7ke1lbBOmabDzXitHYEfhvcir+1zkGp415T7YWSb50xZTTxZUviZo3wdsNp1pALOcSBYueN5IxjhSZ88Vx48yyFvGCTQ12oN4fxZRgJ+bF62TESC/ZPjUrcd701+VrqmZl7hSeXTkdeVNDmTOFgCsHTS2iLGARXBs7whM29Hnk3nvvjcWLFyMajfaf99prr/UrXkPFzJkzhYzZWBu2J8yGjRGIXS+/Bx/edSl2Zjy/2NqEzAU1iZxg9EQJ7/7qMvl40Gfuwqt3XIrdvn0PCvSFuS2TfSFsoFiVlYgJxVeQzmOYLomokOqiQBEFfxHObg2Gq4hC3gsE8yhU5qEkNKguQxLti1k3FJeBTLMfRX8BrkAWXQkfDqxbgRcW7yIqGANPj568EL9cfBBSMTeqqqIyliSpYW1R3ZiVUmS9I8FeyDHOhTikZimeadtNiFeDv1cuGx/oxuf+dwH2qG7BwkQ1erNeTAl3wq/nUO2M4YNYHaZH2iRwdUm8UshnSyIEvzOLWZGVMpIMORTZtHyxaxcZYVJhI3mbFuiTENb6YEwM/vN6auV28awT75xoq2A7Eg6HA4HA2n68bDaLXM7a+C2hvLwc3d1Wnl0Jpa8rKiqG9L3OP/98HHrooTj88MO3+HHvbLCVMBs2hgkOOs0iHUPBzkbAjvV84WPnMYB11vlzRM0iAWMMRQmTbrc+f/XPllqWjQDeFhV6TEXRUYSjV4PS5pYuyGJah9LthOG1wlo5ytQTikRRGE7AdFo5YVqPQ4z7vD2jKphsP26vZkTKEtCr0vBF0mLcj/Z58ew7M2HEHUglXFgeK8c/lk6Fx5lHpDyOZNYpyfDtfQHpkNzRBIzgyPC3Kw/EynQEx9fMx77ljUK2WCVEdYxREQ2eHtS7+3B8zYdCnHTFwHRPc/990PNFIuXTckjnHULAliUr0JP34eDgYrlvErAaXwzTA20yjqSJv1DU0NgbkQ1Lo6ggkXPtsJHsyMdqY/6WngCcffbZiMVia52uvvrjSm0+nxdD/kA4nc7+yzaGk08+GT/5yU9wySWX4JVXXtlqz8TOAlsJs2FjmODVxy/HfmffjTcfWtuMPhrwQvr3a319/Phv47m/XtH/NUeR8UoF0667R1QsjiMn3jEHelqRDkg1ZmWCEXpSQT5YhJZSkA+Y8DbqSE3IQ0lrMppMuYrQUyRdOoyyPJxtDrmd4TegxXTxhTncBfQlPGiPRoCCAl91EmW+lHQ++j1Z1AZimNdYh6KhSBRFXVkMLT1B5JNOOP055POaeMDeOXF4GJGrPXEhYhN83XihfVccVLEMe4VXwqEYmBzuEh/Yi61TMTHUjeZMWPK/enI+PN29BzpSVh9myJmRbkmOGIPujKTck5DRF/entn2xb6RRyFtTLCKhrxP9XejJeTHe1y0krD0TEH9YV8KOK9jixPytgIceegjf+MY3PqaEDcbKlStx1FFHrXVeKaaCl20IJ554ovjDZs+ejZ/+9Kdb5XHvbLCVMBs2hhHC8y3fxX6ft9LfRyueW/H9tb5+4+HZ/XVDekaBqVvGe6pYLODW0oCzT4Grm1lgkE5IEi4a7HPhIpScCqhMxzdRLM9JhyQ7I5WEDjWnyGhSKahCxNSMinzagXyzDxW11u+D48WVyyvRuSqM2Pvl+GDxGLi9OcBQkM3qSOac0v9IAsYcsYpgclht/S3uqxRlqjUThEM1EC148Kcle+GpVbujL+eR7Uaa6AmOEcf4+jDe242DQktx/rhXxB+2NFohhKw1FZLrzQw0ozPrx6uNE9Cd9uL9aL18j4ZgL2o9USFuvK+5PfUIeTJCxBhyu+TM7+zgZ2OEYyvlhFHFisfja50GjyKJF198EQ0NDZgxY8Za6lYikcAbb7whX6uqij322EMM/CUcf/zxslF5xRVX4Ec/+tF2eWpGImwSZsPGMMIL71nBnYOjGYZrf+O2BseRDGElqH5xlLjohkuhZVgzxEBWy3SfGF/ER7dcigW3XwpvC8mYapGsPFAoz6Ook2RZxnwZTxYsQhca34e8vyj1RjTrc2OS8RRUycxgAd2NEUnV59iRUDIa8kETyKkwTQWq20A+4USuoEn/I9UvqmA0tA8nsKLofyvGoiMdkMDVl5snSTxEjS8ukRsMl6XCJblmKZ+UajMTrD0fwnPdu6EnafVaTgp1SYURv/5nxzTJS9u9rkVS76me8fb0izHm4t+rJgt5I0GlgjiprAsffcbasLMxcvDvf/8bL7zwAv7whz/IRuQXv/hF3Hjjjbj11ltlU5KIRCKSHXbSSSfJ1/R+Mdbid7/7HV5++WUhaDwNJHI2LNgkzIYNG5uF5z+6fZvXFFHVIvmaMfseLLz5Uiy+/jIJYC34TRgRkitIAj59Y+PvtdTDVH0RH916qWSEicKV1AHdhFqdQbguJmQsV5OH6TSRWBARNY2me4563E1O6H2a9EvSH0YUScySDtmepPrGv5payPLC0DsWqEji0xPmwuXJCzFjWGvBUHHI34cPkX7+8B9iYl2XeL/iWRfKfSmkcw44tYJ0Ry6JVYhaRs+XWy9InMTKZBgvdUxBb8aLgDuLRNYp/rfmaEhULpaQU/ni5ywsb4sHJCNsVsVK6KrRX2LO0WWNP45jKz7c0U/DzoGtoYRt4kTzM5/5DP7617/iuuuuw7nnnovLLrtsrcyvQqEgJKynp0e+3nPPPfHRRx9h3333xW9+85v+03333be1n40Rj+H1ds2GjVEEqjys1nn/fmvTz8bHa4pmfu0eLjXKQWPyzXOw5LrLJFZCyarQux1C0Gi2pzKmFxRMvHMOHH0KdrnmHhSMovi76P9S4g7kylWklnmAQBEaw1oTOozaLNQuJ9DjgBEwoTE/jKXfBQVaDihq3LgEEMoLySqyhzLjQE15FJ1Rvyhi8W4fHuw6ENMntUgnJOMXUhmHVBsNFbfOOwHX7PbsWufd9MFJWJ6uwEz/Kvy9azpOrpqLqc42vJdpQNZ0iJ+L2VxmUUV7PojGVJlEQIT1FObF6rBbsEXUrGXxcnym7j38ZpkHU8q60JQPY0wgg7xbQ2faL14vkiaqVhF3Cm3JoKhjURaVG5qcDqhcIffF76cFi1iVDMP0W8ois8Xebm6QDLXF3ZUS2Lqwr0qiLFIFBxp8vXhy7h545lB7JLV1EvM3LedrayCZTAoBWx8YXzEwruLee++Vk42NwyZhNmzsAOz+zXvw7g8u7S+cHgokjuHPl4tJPVWlIjbJRNFlwrdCx4LbrJiGed+/FEcdfBP++cr167yPA8+4C+6uPFI1TrQeaaDpwisxHEESRRTyEJXL5BajC9j1inuQ6VuT/yUR+PS3BE1oaVXGjjyTCtn/t3ce4FHVWdh/p9f0DiEJvRcVAcXeXXdVVsWyxbV96qd+66JY1l5WXBfRte6uFXtdy+oq6oqggiICinRIAUJITybT2/2e99xMTCCBUBOS/+957pMpd+6d+8+dO++cc/7vMWj6LEirhz5iGhybzdIrktGxeMwAe7UR0YBNRBqFnKXahFBGDKkrjfAWamLsavYaEckNSyQsYtJgsUYxfkAZlm3S2xKZ3FHEQia40/0ors5AqjuAukYXbPYIgs3O+TtjYWkh7ts4ANcumYqHD34Dz6w5HCWhLNw2+r1Wa/0Pk5afBhPiWOvPxRCnXr9lN0TwWvmh+POADzHfMAwmQxzZFg+WxPphpLNcbCWWVfdBDAakOwMS1SpIbRDhVelPgtMSwfi0MnxYPrKlgJ/eZ3TRZ8H9poZUseNY05SDaNyIZGtQjr1PRqOkJUmqJYAjCzagKWIXEZdvr0epOR0NEYdE3pbU9MPGP3SdP1qPY68U5u+d4n7FnsNLmPpvtAP9UzhlNzk5WQoWFYq9DS0Xog7ozu52Q0v0J8FB/+dBLP3XddvZNvBTa4hq+PK/N+KgSx+UlJ2jjjP+4rA2RvD5/FsO+H8WBWU4WR8bI/1UDXpaUoxXrfrjFGacGcloojyXHJXienexCYEsDRavQRdqcbrghwGPGcaIXi9GU1b2kzREDDKbkpGvYH4Y9k1WqRWL5YaAJgs0ewyOlKD4hBmzgshN96AouU5a9jANx0J91pEZzXFocQMG5lejvD4FQV9zob4zLOatLNYPem1tzFpfWDsRScYAFvkGYsbYd1CzuQ/+6++H3w/5Fk+uPgrJxgB+CuTLc39bcRKmj/xEXnfjsl/DaWINlwkppgCWe/si0+pFIGaFyxzCt9VFGJxSLf5dJZ50mAwa+rgbJUq2cEuRNBMnrP1iLZvDEsXWumSM6luBlVtyMa7fZqypyUYwZMHQ3CqU1qdJOjIWN4qoqmpwozCrXm8/ZAtICrORfmo0e02uk6iaJ+zA+tpMHNNvPeasG96tJikcqN8XU6dOxe3X3YfrT+/8D7eOeGbhnbjgoqlS76XoWlQkTKHoIijASDjFAFMQ+PHxtt5fFBgJDv3tTGlQHYposAQ0xO0GHHb232Coj4v4ipuZPot3KMBO6T8NH5fo0aXWnDz0RsxZ81fsC2IVg2DKW79Lr2HtF0UlE3mMRIWHBBFnY21nDKYqqwgnPmmpNOnjw9RhBAjkRWH06anECPtGpsYAI01e6QFmlLCYRMkyQ/CnmPU6sZhBivApLmK5QdjXOSTCphl113w2+TZY4gg02AFXVJpvV9SkoLw8Xf/pGtVLat2pASnGZy3Y+vW5sKUF5X24U/zwNjgBrxlrrtJFyMj3bsPEvI14dsJsEVvkjXX6ZTgzfwsALsDCxoH4W9+PsSWShv8VD8Ebddm4ftnZUjCfba1BkbUGS/2FkpI8OGkj+ljqJQpWHMrGZYVfoi7qRlPMjqhmxPKteVLPNSyjCtlur3h5EZsphhynF+tqMjEotxp2cwQGziDVDCK62KZpxcY8TB60ARub0uEN2sSmY0huNap8blhMMSRbA9jkSUEgZBURtjqSLX/pip/iDGBxdb8eL8D2O3vJokLRPVCRsA5QkTDFvoDCiT0PGcFa+vR1GHeFbkZKEcZPIyM6jPpQiEjqzAks+8d1OPiSB+WL3+qj2aiGuIn1SnpBOm8nokWmCCNFBrF06Ap4XJzBGMgyiKHswBkPYsPNu1fzVvDUXzFyyGZ8MKRtrdSv15+IFfMGSfSKPmCETvlsyG1uMunmq55mq4rm8aGgojmrkT5gABwVRol4MZpmaTQgmBWHa7MRwSxNLCtCeRGpO9OctNc3YsjgLSipykB6ig+1DW7Eq+ziQ2Yd5oGv3gGLMwJNM0iT7+otqSL6+vWrRa3XiYGZtZhZ9DaGF+iF6oQeY6MKdcHVGka5/jru3y33mZpMMgYlnRjRzJJ+LA5noTyUhjNTl2BDmH0fo1gRyJf0X7I5iAJbHYKaGd81FKGfo158v+jfNTKlAulmH1b7cuGLWjHIVY2PNw0X0WQxsbbMgCRbSExV6fa/YHMRzKY48pI9yHY0YUHxQFmXqdYhmVXo4/BIH8qt1SkYWVAhtWPpNj+WV+XB2+CQnpwbL973M2h7XSTstM6bOnfEM4vuVpGwboKaHalQ7CdOHH+HRK0mnTtTolmTz3wAjto4zAENi1+4DoYYPbA0mMIarF5dbFmbNLFo0Bjk0YCYBQi7jIg4qdb0+3yObX2iDvpnGUR0jL1ST1kce9x9OPR3M3HE6XvWIoZ1Zp3BWwg0FRpg8eq/1ndHgPG9U7xlfmPGR0c/KtG01hE1Fn7TniKUHUOc6Ubq1wgVLKRon9GtUFZMF7XNNWOcESntiMIGsZ7wDQvJkxyrUGYcjiqjpDU505KCmMauvDrSkoLpzPVbssQ7rKo6GYZSPZKUPq4a4ZAZjhKr9I6MeqyoKU2HsckEV3oAW37KQagkCWu+7N9GgJH2BBihAHtn/ZiW+5cMXYB5nqFINgaxzFcg0a61vlz8KnUplgf7oSKSipJQNk5KXi6u9RRSFGz+mE0EWF9bA7JtTSLA1nhykGLyI8USkAL6lZ48iY7R3b8opU5E5KaaVCRZgvi2ogBprgACAaukGst9qRiUV4WCbH32W0l9Bj78cTQyHH70y6lHU9gmBfrsLSlCzRXGoKLKXf7fKxS9DZWOVCj2AyeP/DPmLNY9kiZPoSAyIpxkhGY0YPFsXaiwNQ8bVTOSJMLKwhSj3maHdVB6hMyg1z9ZDRLFYSrOFNIQcRtg9v9cL8WZfXTfn9vKff/I0/6KLz/cvUL8jgr9E1YS6atD8Gdb0OQzwD+CYT1OKdw9Opot+su1p+KGgo9wTsYibDw4DSWL+unRv5ABkZS4XivnjEKjMWuMBqxxEV+0m2C/SAoUjo2j2Ipgbkz3GEuOitgK8OeoxrGj/5g+2zKarjf3NjeYYawzIZwZg2bT4BjRAE+1WyJi0YAZcGswW2KIe61wDPTA57EjFLRAywmh9De7Xp83ZdCPLbff3zAKpw98FY8DeHJ1BsZat2KdKwfPVR6JKZlLYDNGcEFSMf7VMALFgSwc5C5DDEZ8XDsSh2WUYJUvD/Vhh1hJnJL1E771DJDtMi3JwvstvhQMz6pEcUMGClPqUIZ0fLB6NNJTvWjw62IzGLZIZIxNywc4a/Chd6TUg50wahVSLX5UWpPwTVkRiorqUFyfAZs5hvyURrHFUOxlNA2athdmR6qMZrdBpSM7QKUjFfsazlSMmwz49rW2qUPWf4kgO3+miAwKLqbVBINeS0ZRQXEmdWWsPbcYJFJmCmoSWeNtRsUYKWN0ja+310VhCsUxd+6fd+l9Mor21ft6C6FLv/sdnj70xR2u3/+Vv6Dkglv2en3Zuz43PDE7nig+BpXlaSK0bJVmmRlJF3w00MuLYlWDNSMoEZlI2Ayt0SoF9s7UAIIbkxBnijFG9dYcRXPEAI9FrxnjOFWZRaDpTwLRvBDcKQE01TthssWkyJ5RI0bBnK6QiC5ThU3q0EzJYVgsMTFuHdanElf3/R9OHbhqj4798VVH46rhbQuoGS37rHGkiKMie41YVgy3l4uAe3v9OHzWMBKHJa9HhsmLhb5BWNrQTwxkU2wBJJlDIp4aIk6pMVtRnYvxuZtkJiWbczNyttaTLaauSdYQfBErRqZWoNibKY8xXcl0JtsgsTcm68o21GVI78xGrwNuZxChiAWrpvQeY9b9lo6c9hdcd+qe13A+u/gvuOBiVZjfHVCRMIViP9G6OJ7RMPbR3VaAEQqwSVP/hm+a67oY0YraDSLImMZk5Eda+Nh1IaY7yXN2JCQiJhGdZosqsXKwcfYfZxYaRZwdd9RfdmkGZUKAkYqA3rKmNSNunKU70Dv197L2gr3bXLzg+RkY+1eb2E74+sYRT40CEYOIJe6XDbedK+zwFUX1ht3uGKJbnNBowsqZi2EDTD4LAj4TjNkhmMvtUrDPGjHWe1k22mSGJAnkxmVCQCQlJiKN7Y7s6+zw5lh0N32/GQEzc8D6+vZUH4KWOIz9fUiyRWQmYkOdS2ZLrl7QH6fetGcCjLYVVw3XbSuWeAvx+CGvyuPV0WRpjM0ar3H2jXi34WD441Zc+t1YLPL6kGtrlJmXS/xF8MesSLX6sTGULrVh2TaviLfakEu8wOhnRrPW6iY3nLYwNptSZRYkXfY58zHFGkBVKAlbPMkitOg7lmQJIcvhxajsLfhg8ygUptWLieuFw7/FK+vH9yoBtt9Rhfk9ClUTplDsJxIC7JjjZ0ga0hzsOK3wzRvTJTVJYhaD1IgxosWoGMUXhZZmNsAY1qNiUsfExxgJ4sQ/+moxChbSm10bI5pExqIO2jNYpFas6OW/7PQ9H3XK/botRjPtGm7G9ebZTOOZg8Dgu2dh6G3bz8Q89KPdK9IWjykDsGLmNGkhxCjWxitvgK0WsNdqsFWZpPUQU4/WeiMcZVZYmihaNVhqzTD38SOaGYGjr1c8vTjDknVjtKMwN5pkfBICjIX4rBMzxA0SIbNkBxAe4dcL9Dns5jgM9pikPU1JEVjNUSlUp2cYCUXMcCSFUPrbW7Dhpj034aVvGK0sZLaj/OOB2388Xewp8m31LeuNc20Uu4qhzkpJR/L5zz0j8O6mMSjxZYg9xf8tmgt/xIrxSSVY5clFTcCFg9M3Id3hl4jXuNxy9HF7kOnwycxHGZOIRZp+W41RDEirxbDUKomKUZxlWn1YUDtAZlEyPUm7i8UNBUqAKRS7gIqEKRT7iVP6XI2PtzwGYyQOsy+G+R/vWJQwukV08QVEbXr0RVrnyF82r2YhuSa/pmIyY/LnejFrgy7apIBfomGa1KFZfBpCqRYUPRtFafO+CmfPQPqXViSVR+FYXAz/hAEwBeOIWo2S6uQsznCyAd7+URFAraElhK1ej9QF0/XWPhSZ2+L/LBsD739wt8QJTWhJyfXXtdSh+XM0JJU1RwM5UzRmkNRkybTr0X8mZ50aEHXFYSp1weCKwx90SXNuRsjAaJdLkygaBRkMJinKjwfMel9KN6AFTTA6Igg3mWGpsYjIZFG/2RZFpNGGpNwmqeegdYXTGULAb0OSO4DcpCaswd4jYWVBbv3xDKSYfci1NEpfx58a+2ClJxdTcxZjrKMMG8I5UhtWFk5Hrt2Do/PWozKUhGxLE+Y3DpPo1uxNh2FsejlKDRkY7KgUp31GvhglYxujNKtfPMYo3JItbnhjNqytz5bi/SGuSmwKpiPH6cEaT7Y0+pYUZVItPGEb3jvyyb145Ip955ivisK6C0qEKRT7CQowsqNUIIvnY3Z95qPWnIoUSyqHLnLCqQYxGk0qgUTBjDI70oCoRY98WT165Iv2FkxNWvx6c+oYHeRjRlj8cRg0Ro3oT2aWKBdnZWpvGRCz6X5jnmMGYeGb08UsNmO5D7WjXAgn6TMeU1abJf248q/TMPxmPdqlBfV9S0QuzAeYLtWkhRCFDRtr0+le0qfh7cXZ7kBT24J/PoB6lxGl1163XTeC5ddPkx6Ttlp9IoM/RYMlJYR4uQOGgBGm+ubwV8gAYz2FF133NRnrYG60ObpGXzYnLOlBWNMD4pG1aVMGTCYNcXdU0o5+p1VqxNiLsTpmlEjYvipI11sbvYcpX12BKncyMi1epNn8klKcUz8KebZGfFU1EENTqzA5dQN+8vWB0xLGSHeFzIpcVF+ENVuzcfyAtVLf5TaH8Piao3HuwCX4qmYgqrxuHNt3HX5q6IPT835AaTBT2g4VOWsxPmsTjk1ZhfWhHHxfk48LC7/BBls2fDEbzIY41nuyUFOftE+OW7ENKh3Zo1DpSIWim8EoGSNYiTQixQ1nPjLiQ7HgqOQMPi56KpCRMM6QtNUzuqMX6PN5ri+z+4L662jBEEw1ImY1Iphmkn2Ek42IOo0tFhi8nYi4RZwGfLbwdix96jqxyvjhieuw/O/TEHEBQ+6YJdummJMm2yYgnKz7btGTixTfoIujor/PlEhezKqnLCnI9pRzF1yGnII6mfnI6Fpr+B6J1Ha5NUkzsim3VuaE2WeU6BdnQeqTF4BQelzWY+uimJMDSs8xyExIS2YA0SqHFPlvKstEWnYTQj4rMtOaMKSgUhzlORNyS10yTKY4Vv9679RCnfHllXhw5QltHmNvyZO/+H8YllQpVhZMOVJ4sTdjJG5CqT8DE7NKMTllHT7YOhqnpf0gzvp1URfeqTgIwZgZhxeWyLaKXLWYnLZe3PO3hFLl9RcN/Abf1RRKrZc3Zpeife4rz9ogt0fbKvCDJx8XFCzGixsnYl1TNjwRuxT7+8JWZcq6P+CPs3h8jxcVCOs+qEiYQrGfOcnxW3wSeKnd52ghIdGpOCNaBj21aP65tsvSxJ6GzbVfRs6a1BBjlMyot/GRurDmYBPXYb5M7C1oe8UoFaNprYr3Kdq4D1phsPaM27Y1xsUcNh7UWtKHNF8dc40uvLRaIJihb8vfhz5n+nukWSr9uliPxajS0NtnIeLUxBhVZncaDBKhYyRvxPRZIhITacZd5fXDn9rpOnw/casBrnKj9I4UywrNCFu1EZEkOunTvgII2jmGGqwNRklnspF31KEX9UeCZonmeatcIs4aStJgzfOhcksqmtICyEryyTp2dxjBgBV7C6b1WneOTMAo25zm23TLL7DVYnbZJNw6+ENYEMPbdeMlTTkmrRwvVR4mjbjZymhc+masaMzD2KRNWNxYJIaq0b4mpFoD2BpIQo3XhVX+PGQ6vNjsTUWFPxl9XQ0Y7KhCkbUaPxrysSDQX1KUa/y5OCt/GT6qHCnCbmxaOd6e/M+9duwKRW9CiTCFYj/TngA79tj7xDri6BNnIErBFG3uiWgCAtkGuDcnaq309TWDLpxaZkOyTszwcxukQLaGeHYIxiob4ra4CAwxIg0wVakh6tKFG6Ns3A9nX1Ig8bFQilEiabaGOBxbjRg1bRbg1X+Fi/jihSOgR8HYn5GiL5oSgyGs12UFs+O6f1eAfRrZVwiIuiggm139TbpfVzh152NV+MJ9KPv9zi01hrx1F9aefYfcHvjXBxF1xmGvNumCVGMBvwEhCrBaCkTAUd08RpxBaaZ4NIr5a/PgwpgbhFZvg6nWjHAa/caMMCcHEbPHEKpzALYYgn4rao0aXOwtGbDudVuOndtW6L0kgXn4dMl54oPGwvz/VIxGUVIdDk0thdMY1v3DnGXSgPuz6uEivCbkbYTLFMJ39QVSUE+vsK/L+8vsyH5JDci0+aQurDHmwBee4eLEP69hKIa5tkpNGAUgG3gPTaoUcafYX/BXkKrn6kmodKRC0Q1IeHfFLUZ8/e4NUgzPdCCL8jkDkGJL0oy25lY8Nj2VJtEteZ3enofX6FCGJgXsxSc+izUXPI6/nfIqnOPqxN7B169ZgBk4o5F1YLowkhoypjJpadFsh0ExRhGYsTwk2w+lAWvvmiYCUW86rgstmQRQY4K13qQbxQY5WcCApy98rLnZOGCr0983JwVk/hjV05YskN8JnRFgBf94QARY/wdnihiLpEdh8TDNqiHYJypRLwoupkIlJZsdRSitedKD3wAkRRBzxQB3RBa65dP93uinSmVaMg5j0ACUOKHVW2EMGGFglC1oht9rQzhskoJ8cticG7ZLI+4LEr5hv//2Ivn7i5QfRCitD2Tj1gEfSJryppFz8KM3H3URl9SMsbH31NzvMDGlRFoSVQRT9NmdbODtS8ZFgxfioMxyEXNLqvNFhJUFMiQVmWIOYGJyMb5rKJR+kHOqR4jNBb3G2NVAsR+ht82eLopugxJhCkU34sv/6o7237x+vYiWROsiNqum8SqFGDHyPmc+8prMeDavrVZI78OvfjNTzE2JyWDE4fYt8kWbO6IKL533CPLOKoVnaExeR3HHlB09vowxTaJoLNSX9CRFVgioPsjW0suSxfisn+KMyERaNGH5zBosFt7Tc8tWZ8Blz14tz3PbiWbl3N/WiSasfGAa7FUGFD62533wNl6hz9Y09AnCbtVFVCQtLvu21ppgpK8a69FccYQ4ezNolL6TjIDxWCybbXIltJbZoIVMIsQotGDUEM2KwOSKwpTvRyQvDNcmk55apTFsxACtwYpYhRMT8sow6r3bsPDkByTaRFi/NeHjnzsU3PzDlE75grWGPSZ3xAsTn5O/NISlIPrn+Jdw06qzxDOMdXPRuAmZVi+mZHyP4/PW4J+lR+HdirEIBa3S3PvM/B8wILVW0pBf1Q1CTciF+pATDksEp2T8hJX1OSLCjNDwSc0IBGMWHJy1WQRYhs0nLY4UCsXuo9KRCkU3hcX2TBPSVZ+CR4SY4edUJWu6JJLFvpHNAo2C47A3r0M8LYKHjngdZ7q8yDO7xdV8+cY+uDLyGzQ0umDODCBotsPkM0o0i7VQSSUm2UfC0oJig2lECijZtxTd69EjibxJob0uCCkACZti8/0Fc+OwV+jpQGmzREEXbk5jxg0YdN+DiPiBsqun75WxYhTMsNGAwsMq8IMlGY5yhgkZ3dMQGRoUQ1Z4TQhnR6UxN2dAMqVorLcgkqoXKvO9s+k0rSlY/xV3xmG0xmDcZEc4LSrGrb5+MWjuqPRGDNXbxex12MyN+DRtBNIymjD5k+mwm5pw4tw/IsfhEbFC8cWi+bVeE/7w7R9Q7k9Bpt2HHJtHfMBak7h/z/LTcNvoD6XH5KnzrsGV+XNx+sCfOjz+aUvPwayDXpbbS067D0uaReDrxzwlsynj2jCkWfwoTKqXVkXjCjbhu5JCLIoVwZkUQjRqRL+MBpTXpyA72SvRsOW+fPR1N4qT/le1AyWNyZ6RfK4+6MDqimxsOPf2vfL/U+wCe6NtkarM7zZ0aSRswIABmDx5cptl3Lhx7a5rNBoxcuRI9O/fv9Pbz8/PxyGHHCItJRSKA41EzRajUnLN5B+6VzR/apl+ZH2XXuf1c0G+rd4Ie4kNf/rfBRjw1uUYMvtKbPKkoCivFoFvM2Fd64BplVtSiBQdFGFpK/SNUlxRgDF6JdGt5hQnt03RZ21oriOjZ5ZVb4+kWfS0KAv0GQFzjqqHu5gzB5h+1FOXfE3EydSkPsGA2+X2hv15Vkvt154QS43KEC1f2l+c7dfcOw1r7p6GvvOiMNRY5f1GkzQYfRRY+jFZN1t1zzCmIGMGxDPDsNRJ3yOJkpk8ZhiMGiKZEblNwarZ4zDVWhDe6oSpSRdr+e/Uw+oMozClHn3cjVhZmYvKpiTMWzsY66sy8fK3k1AXcqK0MR1NUZt4crGgfYM3C/evOFne/xvrDm5zPBRgCZjuowBLRDc/2jBcZk9SnCXgTEly+eLftini/760n4gm7svNKbKAeIU1he1IT/VhXP9NGJZVibQkP7LsXuSlepDr8sBtDYl/2KTUEjREHNLEe4CrBoMzquEJ2VHncSkB1lW9I+N7YVEZyW5Dl0bCpk+fjrPPPhurV69ueay4uBgXXnhhm/WmTJmCxx9/HH6/X5atW7fi/PPPR21tbbvbtdlsePnll3HqqaeirKwMhYWFuPHGG/HYY+24fSsU3RS2LyITLpgpIobCiD5eUtAe/7klEYUT4X1Gmxgdo9BwbzDr3mGNQKgxEyUjgrCOaUKoyQZLtUWEU8q65sJ8h+6+LylGzsb0/7zNYH4EtgqLlJIYaDWRaHDNxtUszDdTVDX7kTkAyyfpMHImp4g1Fu/rwpHRMtahcdsslJdoXkQXYtratsdOjzHOXmQPR6YWy67qOGJW+OjfYC03ieDzFcRhrrFg1J90cVft0IWjTA6gcLQxHclJCXrTb7rssxWROPE3WRDlYyF9EkMoKwZDnQ1wRRFzx2BwRYGACVpuCNZiO0J9IjA1mPHlxoFwOUJYVtoPDlcIwQoXxhy8Dkm5ISyvzYMrvRGrN+ViTGE5BrmqJSqWafMiELPik8oRKHr5KDxTXskYltR4JZmD0pLoqOQ1yDJ7cDx7W/JfmrdehJgpj62QVsm6Fy+6EBWBZNSEAjhnwf/B1+U5uH7Z2fiqcgDyXB58HViDcNyMZEsQn9cMw6aGVPE7Y1F9jrsJjWEHLMaYNOn2Rm1oCtmkTdHqjbkwWeIi4DY3pSI/qQHvbBgjPTONRg3rp6oI2IEdCVN0F7o8HfnFF1/gnHPO6fD5I488Em+++SYuu+wyPPecXv9w9NFHIycnp0MRdscdd2DChAkYOHCgCLYzzjgD7777LhYtWiSLQnEgMOlcvW1RiEX5Mb3A3RTVbRcomJgqNPn0miyxiKDQaRZQEXdzJE2Emh6Jci+zI5xqgyNsEMFC81QW2/M2I1PsvMP1xP8rzsJ8YOVVT8h7OH7l6ahoSBaBwYgQGCkK6saxTE9SiBnYQontGN3NgjDUHAXTaIuhR8zs1fQT+/m98S8L6LkNeo+FU+N6I20/RORR2Nm3mlD4yExojhhcmX5piyOO+M3RwXicNWpxseqgODUHDfD30T2/zE1GEXP0AovRoiKitz2iSz7rvrS0CBA0IXNQLRo8TkRr7fKeKRjtW80I9o1IypEijfViJq8JaDLJ88NnebDuVqeMia0gipQUv4gWY0YIi5YNRmZRHao3pgG2OFypAazamoPVldkIeWzom1+H6kY3zOYYLNYoNlRl4vyFl2LJ1jxJYVIo/VDbB5OySnG8YwmWhZgn1jnu8z9JO6EvN6QgFjZKmyRup6nSjdyCOnxUNlzaDi3f0gdLiguk+XhOkhdbGpLh99gxLqccP1bniaCymmMtbYdK6tKlGXkkakJqmg8NZalYac5FZrIPpQ3pMhvU7gxLhwCFQtFDCvPtdjsOOuggSU0aDNu7ad9555347LPPWgQYmTdvHlauXNnhNi+66CI8/fTTIsDIe++9h+XLl8vjCkV35uiT72+5bfHpERA61Yswak4hiCCLMQqlixBxzg8zDalJWpI1WfzLRfogNltYUChROPH5cJIeIaNtBGvPuA97HV+vpxi9+ZoIMEZf/tHQV3oMhsNm6aUYywuJ8EuIJ4oti0cXhhKJay7oT6Q0Kcoo9NxlbLOkvw9rk26SSqElIrLZcZ9F/fYq5ir120xv0sOLMxRdGyzwl7tR9PBMxJKjLZMBxCqjyYhockz+hlPiiOWGYKk3ijdY4tiZOuSsSRlLCjFGtxossNSbULMhXQSYo5x1cQZEMqIShWP6UlKYjDz6TRJJk96cdg1l91jQN7MBtlw/mnx2iSalOIKw2SIYMnwzqjenSmrUnhQS8ROPGRGNmGFLDqExYBfj1GjUBIslJr0nV9bkSEo10+1DMGpGRVUqPtk4DC83ZaAq5hbHfPKbvt9ia10y4pypaYkj6LOKAKONRuX6TMTjRtSXpSFcZ5exjUTMKK3MgNkUh9kWw6LyAtRVJ6MgpQGVpemorEuG2x6S/WoxI5q8DmS7vTCkhRGudKK8JBPhqBlmq27LseKMe7rmw6FoNmvd83SkovvQ5ZGwk08+GQUFBcjNzUUoFMLll1+Ojz76SJ6zWq044ogjMG3aNLjdbgwZMgRbtmxpEVftkZeXJ9v6/vvv2zzOCBjFXkdwX0xjJkjUkal6MsX+JAlGnHzOQy11sxGHCd+9fQvGXnSfLmyaBU4wQ4+Osa5KS/SXdOt9JCUqRh8xFn406qlGutzTOV+CR4yWeQEDRUb0Z3EHpx6ZasoHqu/4M1Lv1c//LZECLK4eiD5pMTQ2OmGNWmBgD8pGI3WNlFglrDM4WS5C0efW3yf3FUoCzExZpgJOC+Cs1ODLB1Lo6G+iQGtOTYZZN6bJ+7BaNVj9RkRyNJjNGtzZYcSDDiTDLD/W4my1lB/RU2YspveYYGXzzHSAhv+WrTZEBobg3GoH+gAuNuzeYteNa2MaoukhoNEOc5R5Uz3DYwwC4QExuOtMiPusiKdqsG81iuO+jBGtPLysl+O4GaDF4mhscKEw3YPC5EosrchHjhNoqElGo9+CfgV6DVaGww8PTWA1I1zWkES6/GErVlYNhttsRCxih8towIDURvrZojHoRijgRJqL6tSJd6uOElF2ZNZ6fB+24drxy1n9Jtvu98RdMIRMMHuNYjBroF6ss8h5FLfHYGyyw1BvgJVGutUGuCUyqsFtj6HGm4vMPlGEKpIQtprhTvbDbbHCYIhja3U+huY1oCFVg89rgynuQJIrilWX3K+uie19bvdT3bHRbIQzyb7n2zF1efxF0R1E2Jw5c3D77bejurpaCu9nzJghqccxY8ZIbVhmZqaII95fs2aNiK9BgwZh4cKFuOCCC1BXV7fdNtPT0+XvtqlK3k881x4333yzRN22pby8fK8cq0Kx2zz3cwH2fuNPV7e9P3r/v4UDlsn7dvMez77d/o53vv8MaQ9E+B3T1NS0T7a9adMmDBk/AO81zN7jbQWDwR0GMxT7j2aHn+4BhRjF0l133YWHH34YWVlZqKqqQklJCSZOnChijSc5RdjXX3+Niy++eLttMFpGwXbsscdKvVmCRx55BMcddxxGjRrVqUgY4b7aE3rd7RcYhWLfvn332Yf/QEWNjRobdd6oz9T+vNYkJyfv0+uw0+mU78k9JRaLIRDQDYYVvTwd2Zp4PC4ijIKC1NTUwOv14t///rcIMEJRxGjZueee2+GvBZ5giW0k4P2NGzd2uO9wOCxLaw4kUcP3eiC93/2JGhs1Nuq8UZ+pngDdARQ9C2NXF+W3hqlG2kn89JNuSqhpGj799NPtBBX9vxKijHAWZMJfjOp+wYIFOP3009v8ejjhhBNkWwqFQqFQKBTdBa0rFovFoq1YsUL705/+pJ100knapZdeqhUXF2vffvutZmVVbvN6o0aN0hobG7U777xTO/HEE7Vbb71VC4fD2plnntmyzlNPPaUtX7685f5RRx2lhUIh7b777tN+9atfaZ988om2bt06zeWiJTZ61JKUlKQR/u3q99LdFjU2amzUeaM+U+pa0/XXYrWgwzHoskhYJBLB8ccfL8X31157rdRwPfDAA+Ka3zotyKjY4YcfLtGvG264QRzz6RNG368E69atw5IlbNShM3/+fNkeo2p//OMfsWLFCpll6fPRVKlnwRmlnFDAvwo1Nuq8UZ8pdb1R12HFgUO3KsxXKBQKhUKh6C0osxCFQqFQKBSKLkCJMIVCoVAoFIouQIkwhUKhUCgUit7uE6ZoHzYr58QEmtbuzDw2IyMDw4YN2+7xb775RvzTDnRoRcK2NUuXLm33eZPJhJEjRyIaje6wv+ievqa7QQPH8ePHw+PxYPXq1R1awowYMQKNjY3YsGHDDrfHdQ855JDtHmcPVu7jQCLRn5Zmmh15BXZmnW1JSUkRWx06jx+onTXS0tLknFi7dm0b259dXScB7YSKioraPMbrDq8/Bxp9+vSRiWA//PCD+FW295kbOnSoTCQrLS3t9PWVbfpoRE5T8fa2q+h9qOmj3XQMsrKytDlz5mj19fXakiVLNI/Hoz3wwAM7fM25554rFh5ffvllmyU5ObnLj2dPlquvvlosTerq6rRVq1a1u86kSZO0TZs2aWVlZdrWrVu1lStXaoMHD97hdnfnNd1psdvt2m233aaVlpaKlcs777zT7npnnXWWnEdr1qzRGhoatPnz52tpaWkdbnfo0KFifULLmNbn0SGHHNLlx7wrn59Zs2Zp5eXlmt/v12bMmLFb67S3XHfddbI+z0mfz6e9+uqrYrvT1cfc2WXQoEHas88+K8dNLrzwwt1aZ9vlxhtvlOtU63OG17CuPt5dWSZMmCCfo6qqKjnuiRMntnneYDBot99+u1wv+P/nZ48LrZZ2tF2Hw6G9//77mtfrlesM/1522WVdfrxqQVePQZe/AbV0MAavv/66tnTp0hYB1a9fP/ng7+hiSBFWXV3d48b0wQcf1IYPH67dc8897YowipHNmzdrjz32mNw3Go3aBx98oC1evLjDbe7Oa7rbkpeXp911111afn6+9uabb7YrwnjeBAIBEbK873a7tR9//FF7+eWXdyrC+vbt2+XHuLvL+PHjxYeQYpM+gu0JrM6ss+1CH8JYLCa+ha0/lxTDXX3MnV3on3jRRRfJZyASibR7TenMOu2JsO+++67Lj29PlksuuUR8KBOfgW1FGMfjjjvu0FJSUloeoyclxWd6enqH26XYpxcmhX/iWs3zaOzYsV1+zGpBV46B+gd01zGoqanRrr/++jaPPf3009rXX3/d4Wv4webrKFhGjhzZxvi2JywdiTBeNHlBy83NbXns8MMPl4toRxe53XlNd146EmE33XSTCHOKzMRjF198sRgad2Tym/gCOuKII7Rx48aJcOvq49uTpTMCq7Mi7Pnnn9cWLFjQ5jFGqEtKSrr8OHdn6YzA2hURxh+OY8aMkXPIbDZ3+fHt7jJw4MB2RVh7S0FBgax77LHHtvs8o2e1tbXaDTfc0OZxRqYfeuihLj9WtaDLxkAV5ndjWP/VXg9M1q7srC7svffek4XboMltT4djsmXLFqnPSbBo0aKW5/bWaw5EeCzLli2T3qytj5NN61kLtyNeffVVvPTSS9LT9cknn5TX9HY4nt9//32bxzierIVKTU1Fb2f06NF45ZVX8Nlnn6GyshK///3v0dM59NBD5W9HtZY8N9LT07c7b7777rseda1R7DqqML8b8/DDD+PBBx8UocAvUfa/nDBhAhwOh/TDbK+ZK4v3x44dix9//FHus4cmG6Cz2Pi1115DT4UXOAqF1rDQnkXkfG5vveZApL3jTNzv6DhZMHzaaafhv//9r9wfM2YM5s6dK0X9N910E3ozOxvPhoYG9FbYuYSTFVioTq666io8++yzWL9+vfT07akTp3itnj17doeTOhKfs/bOG362FL0XFQnrxjzxxBOYOnWqiCpGs9jqiS2KGNEIBoPtvoa/yBMCjLz//vv46KOPcN5556Enw7HZtiE84WOt22Dt6WsORNo7Tgp50tFxcrZfQoARnlM8H3v6ebSvxrO38Omnn7YIMPL4449j1apVch3riXDm6Jw5c1BcXIwrr7xyh+cMae+86e3nTG9HRcK6Of/5z39kSfDPf/5TLAhap5Z2BlMCFHI9mbKyMuTm5op9haYx1Q6ZBs70WUe/TnfnNQciPE7aV7QmkebelePkebRterw3wvFsr0yAX6atU9uKnn3eMPXMlGtTUxN+8YtfIBAI7PCcIe2dNz3pWqPYdVQkrBuz7a8m1nqdc845eOGFF1oeYwN0Nj2n1xVhmrI1FBRHHXWUNELv6b/A6dt0zDHHtDx2xhlnSGNzNnRPwLGi8NqV1xzo8DhZd9L6C4DHyS8Gej8lfpFzbJKTk9s9j8iJJ57Y48+jjlJJHBuLxdIynieddFKb+jiO5xdffCHp7N4E/QsnTZrUcn/b84Zjd/DBB/e48yYhwFgScsopp8Dn8223zuDBg1tSjUzjs/6L5SEJ+FnjtYfnk6J3o2ZGdNMxOOWUU8R/iFPFOevxhx9+0L744os2fkS/+c1vZFZORkaG3P/3v/8t06V/+ctfameffbY2d+5cmRlHz5+uPp49WUaPHq1NnjxZZqbRk4e3ubSefTV79mx57vzzz5dp5vTFuvPOO1ueN5lMMlZXXXVVp19zICycvcWx+Pzzz7V58+bJ7dYzujgrkrP5aB0wZcoUbfr06eIlx2NOrMOZtOT444+X+5wl+K9//UvOIZ5LL7zwghYMBrWTTz65y4+3swvPjcR5smHDBu3FF1+U2zyXdmUdeqy1tutITU2Vc4Z2JhybmTNnyth0ZhZdd1loe5M4bs58vPfee+V26+tEZ9a55ZZbtKamppb7PM/42KmnnirXpmXLlmnr169vuT4dCEtOTo4c59SpU+X/Ti8v3k/8/202m/jn0d6Gn4fEGHHJzMxs2Q7PpdZ2HSeccIJ87mgpc/rpp8u1mTO9aXnR1cesFnTZGBiabyi6KfyFfeGFF8JsNuPjjz/GU0891VJfkIhO3H777VJEzYJym82Gyy+/vCW6w1qeRx55ZKdO+92df/zjH+3O5OMvy/r6ernNMbr66qtx8sknS0Ti7bffxvPPP9/G4XrevHmYNWsW3nnnnU695kCAtVtJSUltHkukSBLw+enTp+Owww6TX+XPPfccPvzwwzazt1588UVce+21LTO4zj//fPzqV7+SX+x092Z9D2tfDqR6HdZEbsuKFStwxRVXdHqdo48+Gvfeey+mTJmCmpqaFjf1G2+8Uc7JiooKPProoy0zaw+UzhN8z+2dSzNmzOj0Or/73e/w29/+Vj4/hJFlFuPzPGN6jtEfnjftTSLqrvCaws/KtnB2MGd9MvuQuH5sy913390S2br11ltRWFiIyy67rOV5ZiVYO8ayB062uv/++1vOKUXvRIkwhUKhUCgUii5A1YQpFAqFQqFQdAFKhCkUCoVCoVB0AUqEKRQKhUKhUHQBSoQpFAqFQqFQdAFKhCkUCoVCoVB0AUqEKRQKhUKhUHQBSoQpFAqFQqFQdAGqd6SiRzJq1CgxRJw7d26P2vewYcOk/dD//ve/3d7GhAkT0L9/f7nNVjvs7bev9qXYOccff7wYgBL2iT2QjE0VCsWeoSJhih7JueeeK50EusO+R48eLa7re6uDAt3b9wQ6dtOp+8wzz0ROTs4+3ZeiLaeeeioGDRrU5jGeG3Sdf+2110S8KxSK3oOKhCkUexm2igqHwy33L7jgAowfP15aJnUXvvrqK2k5o9i/sGXWY489hvXr17c8RsE+cOBA/PKXv1T/DoWil6FEmKJXceihhyI/Px8lJSXSu6017JXndrul3x1vp6amyu1t+25aLBYceeSRMBgMsg1GL1qn7VatWtXSD27IkCEYPny4RJwYIUsIIL4HTdPa9BvkeuxJ2Dr9x96W3Bf7Xm77frdNHQ4dOhRbtmzB0qVLpQ/mrrK39rWz8UmMM3tUHn744XL7vffek+dMJhMmTZqE9PR0rF69GuvWrdtu/51ZZ8yYMdK3b8OGDVi5cmWnx2Bn22bUKjc3V/53TOPy+NmztTP7P+6446SH58EHH9xyLrz++uudfm8KhaLnoUSYolfAxsJsPMxG1RQGrIuiAGJT5kTUio3S2RCdX7AUGGzuzAgFH1uyZImsk6j14pcpmzwz1cgvWjZOT4gMfsEeccQRst7gwYNl4Zc603+EApBNwyleWouwX//61xINSWyHr/n888/l708//dSyr9Zwvy+99BImT56MxYsXS60X3z8bb5eVlXV6fPbWvjozPhznk046SUTa5s2bZTwowiju2EybjZ9LS0sxceJEzJkzB3/4wx9kP2Rn61BEcVsUehTQFEL8X3LsdyZMO7N/HjuPie+d2+b/9rzzzsNnn30mz+9o/xSmHJexY8fC6XTK+m+88UbLthUKRe+EVwC1qDHoUefAPffco82dO7fl/qxZs7SVK1dqKSkpcj8vL0+rqKjQpk+f3rLOQw89pIXDYe2QQw5peeztt9/W3nrrrZb7jz32mLZ06VLN6XTK/aKiIs3j8WgLFy7scN8zZszQPv300zbv78UXX9See+65No/dcsstbbbz97//Xfblcrnk/oABA7SmpqY269x///3a/PnzNbvd3vLYM888o/3nP//pcGy4X+6/9WN7a1+dGR+OcywW04444oiWxwwGg7ZixQoZg8Rj/F8VFxdrl1xySafXOeqoozSfz6clJye3rHPSSSdpDodjh+dLZ7bd3nLNNdfIOon7O9v/qlWrtKuuumq77QwcOFAjhYWFXf7ZUYsaA3UOYL+NgSrMV/QKGK144okn0NjYKPcrKirw3HPPyeOtYfSCabIErONi6i3B2WefjSeffLJlBhsjJm+99dY+ec9Tp06Vffl8PrlfXFyMt99+u806F110EZYvX47TTjtN3ts555yDrVu34phjjumSfXV2fBiNZFo2AVOAI0aMkMjYWWedJdthtIy1U8cee2yn12EUi2lVrpfgk08+kcd3RGe2nYApY0ZHOWaMYjEimJjduLv7VygUvROVjlT0eKxWK/Ly8kRYtIZpMqaLWrNt/VcoFILdbm/ZDmu7KCxaw/us59rb75m1R9vui6m7hCh0OBzIzs6WL3ymEVvzwQcfyDZaTxDY1/sinR0fiuDWME0ci8VwyimntHm8tra2paaqM+tQRHNG54cffij/S6ZYn3rqKUmf7ojObJvMmDED11xzjeynurpa6t8Ix4Z1gLu7f4VC0TtRIkzR46EQYQRsW/HA+4kC+s5up6mpSQr2W8PasV0lHo9LAXxrEmIvsS8WfG+77db3g8GgiMRXXnlFvuh3l725r86Oz7Z1UNw/66n++Mc/oqqqqt1td2Ydcs899+C+++7DQQcdJNGqhQsX4rDDDtuhEOrMtln/ddNNN0nRPSOCZOTIkVLvxRqxPdm/QqHonah0pKJX8PXXX0vhe2uYdmqdEusMCxYsEP+sBBRSTM/tCK/X20ZgkfLy8u38orZNIfI9J4r5CdNcLIJvLWQ+/fRTXHbZZdsJOqbMdoW9ta/dGR/C/wPH6fLLL2/zOMVNwsusM+swIkUxxagWRc8NN9wgY81ZsXu6f0YLud3WMyaZtmzNzvbf3rmgUCh6LyoSpugVMIJBgcDZfXSJP/300zFgwIDtvkR3Bj2d5s+fLzVPnNnIuihGfnYUUeOX8Z///GdJYzHKwi98RpSuv/56PProo1IfxVmRtLNonTK97bbbZN1nn31WoimsX+PsutaRmmuvvVbq1hLbpOihjQK/7DkLsbPsrX3tzvgQRippIvvMM89IjRVFIVPInL1KY9k333yzU+sw+jRz5ky5zTQoLTC4f9Zl7en+WSvImY6scWO9HK0mtq0p3Nn+eS7Qn42pTEYWlUWFQtG7UZEwRY81TGU9TgKmj2gbsHHjRrEKoOUE77MQOwEfo4BoDQuzWfOUgMKCX6xMz9FqgKLl+eeflzRcR/umzcGll17akrqiZxZtILgdRky4ndmzZ0sUhtGmBPzSZ8E4i+W5DtOA3E7rdVjXxjZJtDqgKGBtE9/PzgQYa+FopZGI8uytfXVmfNobZ0KBzO2yXoz/I0bjKFgoaDq7DseawokRLEYWuR7fx7Z2G+2xs21TWDKtyP8vt00hRSsSOt03NDR0av833ngjXn31VSn2T6Qx2baoM9FChULR82AhQ9viDIVC0SFMJTE1xyiGfIAMBjHspAcZo10HAldccUVLGyUWmlNU7C16wvjsb+6++26pNyOMlu5KnaJCoTiwUSJModgFaEbKmW+MjjC6w8JrziCk+Strf3o73XV8GPHbkW2HSgsqFIquQIkwhWIXoahgw2UWaq9ZswZPP/10SzpK0T3HhzMab7755g6fP//88/fr+1EoFAqiRJhCoVAoFApFF6AK8xUKhUKhUCi6ACXCFAqFQqFQKLoAJcIUCoVCoVAougAlwhQKhUKhUCi6ACXCFAqFQqFQKLoAJcIUCoVCoVAougAlwhQKhUKhUCi6ACXCFAqFQqFQKLoAJcIUCoVCoVAosP/5/wrrk1YZQuUmAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "jetTransient": { + "display_id": null + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "slice_ds.SPM.isel(time=0).sel(lon=slice(9.2, 12), lat=slice(58.7, 56)).plot.imshow(\n", + " vmax=1.5\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "8fc231d4-fddb-4348-ae7f-32f0f0f6d8e1", + "metadata": {}, + "source": [ + "## Define the output" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "4dc12e8b-9ab3-4845-ad8b-1f528c6d2d08", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:40:52.702353750Z", + "start_time": "2026-10-29T16:40:52.684942183Z" + } + }, + "outputs": [], + "source": [ + "output_dir = Path(\"outputs\")\n", + "output_dir.mkdir(exist_ok=True)\n", + "target_path = f\"{output_dir}/target.zarr\"" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "ef6ceb2b-8300-46c1-97c4-945aa1c3ea5f", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:40:52.729349278Z", + "start_time": "2026-10-29T16:40:52.703928562Z" + } + }, + "outputs": [], + "source": [ + "rmdir(target_path)" + ] + }, + { + "cell_type": "markdown", + "id": "507848e1-0f4c-4ec2-ba93-c33567c6e302", + "metadata": { + "tags": [] + }, + "source": [ + "## Use the zappend CLI" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "e3b9b255-1d6e-4efa-b17d-df8ab4af0cbf", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:40:53.282226959Z", + "start_time": "2026-10-29T16:40:52.731137964Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Usage: zappend [OPTIONS] [SLICES]...\r\n", + "\r\n", + " Create or update a Zarr datacube TARGET from slice datasets SLICES.\r\n", + "\r\n", + " The zappend command concatenates the dataset SLICES along a given append\r\n", + " dimension, e.g., \"time\" (the default) for geospatial satellite observations.\r\n", + " Each append step is atomic, that is, the append operation is a transaction\r\n", + " that can be rolled back, in case the append operation fails. This ensures\r\n", + " integrity of the target data cube given by TARGET or in CONFIG.\r\n", + "\r\n", + "Options:\r\n", + " -c, --config CONFIG Configuration JSON or YAML file. If multiple are\r\n", + " passed, subsequent configurations are incremental to\r\n", + " the previous ones.\r\n", + " -t, --target TARGET Target Zarr dataset path or URI. Overrides the\r\n", + " 'target_dir' configuration field.\r\n", + " --force-new Force creation of a new target dataset. An existing\r\n", + " target dataset (and its lock) will be permanently\r\n", + " deleted before appending of slice datasets begins.\r\n", + " WARNING: the deletion cannot be rolled back.\r\n", + " --dry-run Run the tool without creating, changing, or deleting\r\n", + " any files.\r\n", + " --traceback Show Python traceback on error.\r\n", + " --version Show version and exit.\r\n", + " --help-config json|md Show configuration help and exit.\r\n", + " --help Show this message and exit.\r\n" + ] + } + ], + "source": [ + "!zappend --help" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "27bc91ef-c0eb-42ab-8c1e-5eae4b98a72e", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:40:53.789470508Z", + "start_time": "2026-10-29T16:40:53.284652137Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8.1.dev0\r\n" + ] + } + ], + "source": [ + "!zappend --version" + ] + }, + { + "cell_type": "markdown", + "id": "731ce132-a500-489d-b746-54af7a834d67", + "metadata": {}, + "source": [ + "Run the tool without any additional configuration:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "fae51e0d-c50d-47dc-8275-56676e76000d", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:41:02.479722437Z", + "start_time": "2026-10-29T16:40:53.797029046Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3 slice datasets processed.\r\n" + ] + } + ], + "source": [ + "!zappend -t {target_path} {\" \".join(slice_paths)}" + ] + }, + { + "cell_type": "markdown", + "id": "894ec17a-8995-4938-b1f3-1e64361e35eb", + "metadata": {}, + "source": [ + "Check the target dataset just generated:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "991cd43b-9797-4ef8-aa29-48a098a44938", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:41:02.625426206Z", + "start_time": "2026-10-29T16:41:02.483978581Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 1GB\n",
+       "Dimensions:  (time: 3, lat: 8640, lon: 3435)\n",
+       "Coordinates:\n",
+       "  * time     (time) datetime64[ns] 24B 2023-06-01 2023-06-03 2023-06-05\n",
+       "  * lat      (lat) float64 69kB 64.0 64.0 64.0 64.0 64.0 ... 56.0 56.0 56.0 56.0\n",
+       "  * lon      (lon) float64 27kB 6.0 6.002 6.004 6.005 ... 11.99 12.0 12.0 12.0\n",
+       "Data variables:\n",
+       "    crs      int32 4B ...\n",
+       "    SPM      (time, lat, lon) float32 356MB dask.array<chunksize=(1, 540, 286), meta=np.ndarray>\n",
+       "    SPM_QI   (time, lat, lon) float32 356MB dask.array<chunksize=(1, 540, 286), meta=np.ndarray>\n",
+       "    TUR      (time, lat, lon) float32 356MB dask.array<chunksize=(1, 540, 286), meta=np.ndarray>\n",
+       "    TUR_QI   (time, lat, lon) float32 356MB dask.array<chunksize=(1, 540, 286), meta=np.ndarray>\n",
+       "Attributes: (12/46)\n",
+       "    TileSize:                   540:286\n",
+       "    id:                         20230601_P1D_CMEMS_HROC_L3_transp_BAL_32V_100...\n",
+       "    title:                      CMEMS HR-OC Baltic Sea transparency (spm, tur...\n",
+       "    region:                     BAL\n",
+       "    tile:                       32V\n",
+       "    cmems_product_id:           OCEANCOLOUR_BAL_BGC_HR_L3_NRT_009_202\n",
+       "    ...                         ...\n",
+       "    time_coverage_duration:     P1D\n",
+       "    time_coverage_resolution:   P1D\n",
+       "    platform:                   Sentinel-2\n",
+       "    sensor:                     MSI\n",
+       "    start_date:                 01-JUN-2023 00:00:00.000000\n",
+       "    stop_date:                  01-JUN-2023 00:00:00.000000
" + ], + "text/plain": [ + " Size: 1GB\n", + "Dimensions: (time: 3, lat: 8640, lon: 3435)\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 24B 2023-06-01 2023-06-03 2023-06-05\n", + " * lat (lat) float64 69kB 64.0 64.0 64.0 64.0 64.0 ... 56.0 56.0 56.0 56.0\n", + " * lon (lon) float64 27kB 6.0 6.002 6.004 6.005 ... 11.99 12.0 12.0 12.0\n", + "Data variables:\n", + " crs int32 4B ...\n", + " SPM (time, lat, lon) float32 356MB dask.array\n", + " SPM_QI (time, lat, lon) float32 356MB dask.array\n", + " TUR (time, lat, lon) float32 356MB dask.array\n", + " TUR_QI (time, lat, lon) float32 356MB dask.array\n", + "Attributes: (12/46)\n", + " TileSize: 540:286\n", + " id: 20230601_P1D_CMEMS_HROC_L3_transp_BAL_32V_100...\n", + " title: CMEMS HR-OC Baltic Sea transparency (spm, tur...\n", + " region: BAL\n", + " tile: 32V\n", + " cmems_product_id: OCEANCOLOUR_BAL_BGC_HR_L3_NRT_009_202\n", + " ... ...\n", + " time_coverage_duration: P1D\n", + " time_coverage_resolution: P1D\n", + " platform: Sentinel-2\n", + " sensor: MSI\n", + " start_date: 01-JUN-2023 00:00:00.000000\n", + " stop_date: 01-JUN-2023 00:00:00.000000" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "target_ds = xr.open_zarr(target_path)\n", + "target_ds" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "7de6335c-dc17-464c-b9cf-8ed1777713bc", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:41:03.866935764Z", + "start_time": "2026-10-29T16:41:02.630399884Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "jetTransient": { + "display_id": null + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "target_ds.SPM.mean(\"time\").sel(lon=slice(9.2, 12), lat=slice(58.7, 56)).plot.imshow(\n", + " vmax=1.5\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "2040bf76-2fbc-42dc-b47d-7d461925b703", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:41:04.991462659Z", + "start_time": "2026-10-29T16:41:03.870692715Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/konstantin/micromamba/envs/zappend/lib/python3.15/site-packages/dask/array/reductions.py:327: RuntimeWarning: All-NaN slice encountered\n", + " return np.nanmax(x_chunk, axis=axis, keepdims=keepdims)\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "jetTransient": { + "display_id": null + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "target_ds.SPM_QI.max(\"time\").sel(lon=slice(9.2, 12), lat=slice(58.7, 56)).plot.imshow(\n", + " vmax=100.0\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "d9ef1ec7-f584-4147-a9b0-6dd67325fed9", + "metadata": {}, + "source": [ + "## Use the zappend API" + ] + }, + { + "cell_type": "markdown", + "id": "ded727aa-30df-4183-babb-cb6b85149e33", + "metadata": {}, + "source": [ + "Now the same using the API:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "f7d3b8d8-8134-49dd-b494-fb4645ff76fc", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:41:05.042635706Z", + "start_time": "2026-10-29T16:41:04.994927790Z" + } + }, + "outputs": [], + "source": [ + "from zappend.api import zappend" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "cc831cbd-0b93-40ab-b4f5-c348140974df", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:41:05.052910271Z", + "start_time": "2026-10-29T16:41:05.043319287Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Help on function zappend in module zappend.api:\n", + "\n", + "zappend(slices: Iterable[Any], config: ConfigLike = None, **kwargs: Any) -> int\n", + " Robustly create or update a Zarr dataset from dataset slices.\n", + "\n", + " The `zappend` function concatenates the dataset slices from given\n", + " `slices` along a given append dimension, e.g., `\"time\"` (the default)\n", + " for geospatial satellite observations.\n", + " Each append step is atomic, that is, the append operation is a transaction\n", + " that can be rolled back, in case the append operation fails.\n", + " This ensures integrity of the target data cube `target_dir` given\n", + " in `config` or `kwargs`.\n", + "\n", + " Each slice item in `slices` provides a slice dataset to be appended.\n", + " The interpretation of a given slice item depends on whether a slice source\n", + " is configured or not (setting `slice_source`).\n", + "\n", + " If no slice source is configured, a slice item must be an object of type\n", + " `str`, `FileObj`, `xarray.Dataset`, or `SliceSource`.\n", + " If `str` or `FileObj` are used, they are interpreted as local dataset path or\n", + " dataset URI. If a URI is used, protocol-specific parameters apply, given by the\n", + " configuration parameter `slice_storage_options`.\n", + "\n", + " If a slice source is configured, a slice item represents the argument(s) passed\n", + " to that slice source. Multiple positional arguments can be passed as `list`,\n", + " multiple keyword arguments as `dict`, and both as a `tuple` of `list` and `dict`.\n", + "\n", + " Args:\n", + " slices: An iterable that yields slice items.\n", + " config: Processor configuration.\n", + " Can be a file path or URI, a `dict`, `None`, or a sequence of\n", + " the aforementioned. If a sequence is used, subsequent\n", + " configurations are incremental to the previous ones.\n", + " kwargs: Additional configuration parameters.\n", + " Can be used to pass or override configuration values in *config*.\n", + "\n", + " Returns:\n", + " The number of slices processed. The value can be useful if the number of items in `slices` is unknown.\n", + "\n" + ] + } + ], + "source": [ + "help(zappend)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "0295de2a-674e-4a88-994f-2c1e45df3b64", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:41:05.069715293Z", + "start_time": "2026-10-29T16:41:05.053544398Z" + } + }, + "outputs": [], + "source": [ + "# Remove existing target datacube\n", + "rmdir(target_path)" + ] + }, + { + "cell_type": "markdown", + "id": "5d221b56-9940-45ce-9b3e-210f855bf1ec", + "metadata": {}, + "source": [ + "Run the tool without any additional configuration:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "d584f7e1-f60e-41e6-b817-a92f11f0266a", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:41:11.051620747Z", + "start_time": "2026-10-29T16:41:05.070421116Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "zappend(slice_paths, target_dir=target_path)" + ] + }, + { + "cell_type": "markdown", + "id": "7efbe444-2342-4b51-8876-454dea176be7", + "metadata": {}, + "source": [ + "Check the target dataset just generated:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "b8714516-337b-4c06-aead-086fb3d44a04", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:41:11.079458836Z", + "start_time": "2026-10-29T16:41:11.052384098Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 1GB\n",
+       "Dimensions:  (time: 3, lat: 8640, lon: 3435)\n",
+       "Coordinates:\n",
+       "  * time     (time) datetime64[ns] 24B 2023-06-01 2023-06-03 2023-06-05\n",
+       "  * lat      (lat) float64 69kB 64.0 64.0 64.0 64.0 64.0 ... 56.0 56.0 56.0 56.0\n",
+       "  * lon      (lon) float64 27kB 6.0 6.002 6.004 6.005 ... 11.99 12.0 12.0 12.0\n",
+       "Data variables:\n",
+       "    crs      int32 4B ...\n",
+       "    SPM      (time, lat, lon) float32 356MB dask.array<chunksize=(1, 540, 286), meta=np.ndarray>\n",
+       "    SPM_QI   (time, lat, lon) float32 356MB dask.array<chunksize=(1, 540, 286), meta=np.ndarray>\n",
+       "    TUR      (time, lat, lon) float32 356MB dask.array<chunksize=(1, 540, 286), meta=np.ndarray>\n",
+       "    TUR_QI   (time, lat, lon) float32 356MB dask.array<chunksize=(1, 540, 286), meta=np.ndarray>\n",
+       "Attributes: (12/46)\n",
+       "    TileSize:                   540:286\n",
+       "    id:                         20230601_P1D_CMEMS_HROC_L3_transp_BAL_32V_100...\n",
+       "    title:                      CMEMS HR-OC Baltic Sea transparency (spm, tur...\n",
+       "    region:                     BAL\n",
+       "    tile:                       32V\n",
+       "    cmems_product_id:           OCEANCOLOUR_BAL_BGC_HR_L3_NRT_009_202\n",
+       "    ...                         ...\n",
+       "    time_coverage_duration:     P1D\n",
+       "    time_coverage_resolution:   P1D\n",
+       "    platform:                   Sentinel-2\n",
+       "    sensor:                     MSI\n",
+       "    start_date:                 01-JUN-2023 00:00:00.000000\n",
+       "    stop_date:                  01-JUN-2023 00:00:00.000000
" + ], + "text/plain": [ + " Size: 1GB\n", + "Dimensions: (time: 3, lat: 8640, lon: 3435)\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 24B 2023-06-01 2023-06-03 2023-06-05\n", + " * lat (lat) float64 69kB 64.0 64.0 64.0 64.0 64.0 ... 56.0 56.0 56.0 56.0\n", + " * lon (lon) float64 27kB 6.0 6.002 6.004 6.005 ... 11.99 12.0 12.0 12.0\n", + "Data variables:\n", + " crs int32 4B ...\n", + " SPM (time, lat, lon) float32 356MB dask.array\n", + " SPM_QI (time, lat, lon) float32 356MB dask.array\n", + " TUR (time, lat, lon) float32 356MB dask.array\n", + " TUR_QI (time, lat, lon) float32 356MB dask.array\n", + "Attributes: (12/46)\n", + " TileSize: 540:286\n", + " id: 20230601_P1D_CMEMS_HROC_L3_transp_BAL_32V_100...\n", + " title: CMEMS HR-OC Baltic Sea transparency (spm, tur...\n", + " region: BAL\n", + " tile: 32V\n", + " cmems_product_id: OCEANCOLOUR_BAL_BGC_HR_L3_NRT_009_202\n", + " ... ...\n", + " time_coverage_duration: P1D\n", + " time_coverage_resolution: P1D\n", + " platform: Sentinel-2\n", + " sensor: MSI\n", + " start_date: 01-JUN-2023 00:00:00.000000\n", + " stop_date: 01-JUN-2023 00:00:00.000000" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "xr.open_zarr(target_path)" + ] + }, + { + "cell_type": "markdown", + "id": "68609d51-1d48-4ed0-ac70-7cc3f0faae86", + "metadata": {}, + "source": [ + "Check that time is monotonically increasing:" + ] + }, + { + "cell_type": "markdown", + "id": "70cad7dd-25ec-4ab9-9e9b-1c0080877cbc", + "metadata": {}, + "source": [ + "## zappend Configuration" + ] + }, + { + "cell_type": "markdown", + "id": "0eb98711-17bc-416f-831c-36337f4f2944", + "metadata": {}, + "source": [ + "Now we'll add some configuration. \n", + "You can run `zappend --help-config md` to get configuration help, or do that programmatically:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "bfc8fe5d-0c67-4865-ab13-0b37855d96bb", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:41:11.086635884Z", + "start_time": "2026-10-29T16:41:11.080962435Z" + } + }, + "outputs": [], + "source": [ + "# Uncomment to show configuration reference\n", + "# Markdown(get_config_schema(format=\"md\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "5ab01409-7ddc-4250-860e-a4607a132a0e", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:41:11.093519158Z", + "start_time": "2026-10-29T16:41:11.087301320Z" + } + }, + "outputs": [], + "source": [ + "config = {\n", + " \"target_dir\": target_path,\n", + " \"variables\": {\n", + " # We want the time coordinate variable to use a larger chunk size\n", + " # than the default (= 1 here)\n", + " \"time\": {\"encoding\": {\"chunks\": [100]}}\n", + " },\n", + " # Log to the console.\n", + " # Note you could also configure the log output for dask here.\n", + " \"logging\": {\n", + " \"version\": 1,\n", + " \"formatters\": {\n", + " \"normal\": {\"format\": \"%(asctime)s %(levelname)s %(message)s\", \"style\": \"%\"}\n", + " },\n", + " \"handlers\": {\n", + " \"console\": {\"class\": \"logging.StreamHandler\", \"formatter\": \"normal\"}\n", + " },\n", + " \"loggers\": {\n", + " \"zappend\": {\"level\": \"INFO\", \"handlers\": [\"console\"]},\n", + " \"notebook\": {\n", + " # Will use this one later below\n", + " \"level\": \"INFO\",\n", + " \"handlers\": [\"console\"],\n", + " },\n", + " },\n", + " },\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "891bef11-c580-498a-a0db-8b2fac1da38f", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:41:11.100128684Z", + "start_time": "2026-10-29T16:41:11.094250919Z" + } + }, + "outputs": [], + "source": [ + "config_path = \"zappend-config.yaml\"" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "ffe8aa85-8c5a-4a9c-a3b8-a5f3a7c50aa2", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:41:11.108981966Z", + "start_time": "2026-10-29T16:41:11.101115457Z" + } + }, + "outputs": [], + "source": [ + "import yaml\n", + "\n", + "with open(config_path, mode=\"w\") as f:\n", + " yaml.dump(config, f)" + ] + }, + { + "cell_type": "markdown", + "id": "795a2ab7-e23c-4094-bd51-7f73f311c2fa", + "metadata": {}, + "source": [ + "## zappend CLI with Configuration" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "7439b20d-ce84-43e0-be54-3a5f573a8800", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:41:11.129250737Z", + "start_time": "2026-10-29T16:41:11.109778179Z" + } + }, + "outputs": [], + "source": [ + "rmdir(target_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "8fb20c46-2f62-4a6b-b9db-db2d168d9647", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:41:19.217651567Z", + "start_time": "2026-10-29T16:41:11.130008217Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-10-29 17:41:12,507 INFO Opening slice dataset from inputs/demo/20230601_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc\r\n", + "2026-10-29 17:41:12,537 INFO Creating target dataset outputs/target.zarr\r\n", + "2026-10-29 17:41:14,649 INFO Transaction completed.\r\n", + "2026-10-29 17:41:14,667 INFO Slice dataset inputs/demo/20230601_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc closed\r\n", + "2026-10-29 17:41:14,676 INFO Opening slice dataset from inputs/demo/20230603_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc\r\n", + "2026-10-29 17:41:14,689 INFO Updating target dataset outputs/target.zarr\r\n", + "2026-10-29 17:41:16,816 INFO Transaction completed.\r\n", + "2026-10-29 17:41:16,833 INFO Slice dataset inputs/demo/20230603_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc closed\r\n", + "2026-10-29 17:41:16,843 INFO Opening slice dataset from inputs/demo/20230605_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc\r\n", + "2026-10-29 17:41:16,851 INFO Updating target dataset outputs/target.zarr\r\n", + "2026-10-29 17:41:18,822 INFO Transaction completed.\r\n", + "2026-10-29 17:41:18,835 INFO Slice dataset inputs/demo/20230605_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc closed\r\n", + "3 slice datasets processed.\r\n" + ] + } + ], + "source": [ + "!zappend -c {config_path} {\" \".join(slice_paths)}" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "758675d7-505a-4357-b097-d3cf8e116c65", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:41:19.237284467Z", + "start_time": "2026-10-29T16:41:19.218802640Z" + } + }, + "outputs": [], + "source": [ + "rmdir(target_path)" + ] + }, + { + "cell_type": "markdown", + "id": "6df50041-c09c-40d9-afa3-b6f6a24a430d", + "metadata": {}, + "source": [ + "## zappend API with Configuration" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "ae8783d1-541f-482a-a3f5-9631c8359363", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:41:19.242232688Z", + "start_time": "2026-10-29T16:41:19.238014626Z" + } + }, + "outputs": [], + "source": [ + "from zappend.api import zappend" + ] + }, + { + "cell_type": "markdown", + "id": "b08fe2d9-dd05-48d3-8b13-9f116b751477", + "metadata": {}, + "source": [ + "The `zappend` function can process slice paths or URIs, e.g., `s3://...` or slice datasets of type `xr.Dataset`:" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "1aade08b-7636-4a33-9f39-98ae5ad18867", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:41:25.299452451Z", + "start_time": "2026-10-29T16:41:19.242840165Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-10-29 17:41:19,277 INFO Opening slice dataset from inputs/demo/20230601_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc\n", + "2026-10-29 17:41:19,292 INFO Creating target dataset outputs/target.zarr\n", + "2026-10-29 17:41:21,157 INFO Transaction completed.\n", + "2026-10-29 17:41:21,158 INFO Slice dataset inputs/demo/20230601_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc closed\n", + "2026-10-29 17:41:21,169 INFO Opening slice dataset from inputs/demo/20230603_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc\n", + "2026-10-29 17:41:21,179 INFO Updating target dataset outputs/target.zarr\n", + "2026-10-29 17:41:23,340 INFO Transaction completed.\n", + "2026-10-29 17:41:23,341 INFO Slice dataset inputs/demo/20230603_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc closed\n", + "2026-10-29 17:41:23,352 INFO Opening slice dataset from inputs/demo/20230605_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc\n", + "2026-10-29 17:41:23,361 INFO Updating target dataset outputs/target.zarr\n", + "2026-10-29 17:41:25,290 INFO Transaction completed.\n", + "2026-10-29 17:41:25,292 INFO Slice dataset inputs/demo/20230605_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc closed\n" + ] + }, + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "zappend(slice_paths, config=config)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "e629de62-3bb3-4cab-9507-4026f74fde38", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:41:25.331935518Z", + "start_time": "2026-10-29T16:41:25.303984486Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 1GB\n",
+       "Dimensions:  (time: 3, lat: 8640, lon: 3435)\n",
+       "Coordinates:\n",
+       "  * time     (time) datetime64[ns] 24B 2023-06-01 2023-06-03 2023-06-05\n",
+       "  * lat      (lat) float64 69kB 64.0 64.0 64.0 64.0 64.0 ... 56.0 56.0 56.0 56.0\n",
+       "  * lon      (lon) float64 27kB 6.0 6.002 6.004 6.005 ... 11.99 12.0 12.0 12.0\n",
+       "Data variables:\n",
+       "    crs      int32 4B ...\n",
+       "    SPM      (time, lat, lon) float32 356MB dask.array<chunksize=(1, 540, 286), meta=np.ndarray>\n",
+       "    SPM_QI   (time, lat, lon) float32 356MB dask.array<chunksize=(1, 540, 286), meta=np.ndarray>\n",
+       "    TUR      (time, lat, lon) float32 356MB dask.array<chunksize=(1, 540, 286), meta=np.ndarray>\n",
+       "    TUR_QI   (time, lat, lon) float32 356MB dask.array<chunksize=(1, 540, 286), meta=np.ndarray>\n",
+       "Attributes: (12/46)\n",
+       "    TileSize:                   540:286\n",
+       "    id:                         20230601_P1D_CMEMS_HROC_L3_transp_BAL_32V_100...\n",
+       "    title:                      CMEMS HR-OC Baltic Sea transparency (spm, tur...\n",
+       "    region:                     BAL\n",
+       "    tile:                       32V\n",
+       "    cmems_product_id:           OCEANCOLOUR_BAL_BGC_HR_L3_NRT_009_202\n",
+       "    ...                         ...\n",
+       "    time_coverage_duration:     P1D\n",
+       "    time_coverage_resolution:   P1D\n",
+       "    platform:                   Sentinel-2\n",
+       "    sensor:                     MSI\n",
+       "    start_date:                 01-JUN-2023 00:00:00.000000\n",
+       "    stop_date:                  01-JUN-2023 00:00:00.000000
" + ], + "text/plain": [ + " Size: 1GB\n", + "Dimensions: (time: 3, lat: 8640, lon: 3435)\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 24B 2023-06-01 2023-06-03 2023-06-05\n", + " * lat (lat) float64 69kB 64.0 64.0 64.0 64.0 64.0 ... 56.0 56.0 56.0 56.0\n", + " * lon (lon) float64 27kB 6.0 6.002 6.004 6.005 ... 11.99 12.0 12.0 12.0\n", + "Data variables:\n", + " crs int32 4B ...\n", + " SPM (time, lat, lon) float32 356MB dask.array\n", + " SPM_QI (time, lat, lon) float32 356MB dask.array\n", + " TUR (time, lat, lon) float32 356MB dask.array\n", + " TUR_QI (time, lat, lon) float32 356MB dask.array\n", + "Attributes: (12/46)\n", + " TileSize: 540:286\n", + " id: 20230601_P1D_CMEMS_HROC_L3_transp_BAL_32V_100...\n", + " title: CMEMS HR-OC Baltic Sea transparency (spm, tur...\n", + " region: BAL\n", + " tile: 32V\n", + " cmems_product_id: OCEANCOLOUR_BAL_BGC_HR_L3_NRT_009_202\n", + " ... ...\n", + " time_coverage_duration: P1D\n", + " time_coverage_resolution: P1D\n", + " platform: Sentinel-2\n", + " sensor: MSI\n", + " start_date: 01-JUN-2023 00:00:00.000000\n", + " stop_date: 01-JUN-2023 00:00:00.000000" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "xr.open_zarr(target_path)" + ] + }, + { + "cell_type": "markdown", + "id": "10fc19b8-6234-4f6e-a673-89900740dccc", + "metadata": { + "tags": [] + }, + "source": [ + "## Other slice types" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "e51edf82-be14-4065-9aec-399481d8b5f0", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:41:25.353825429Z", + "start_time": "2026-10-29T16:41:25.333372651Z" + } + }, + "outputs": [], + "source": [ + "rmdir(target_path)" + ] + }, + { + "cell_type": "markdown", + "id": "fe4b4d73-492b-431a-b0b5-43c8a1ccec84", + "metadata": {}, + "source": [ + "Get the configured logger: " + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "f98b5d70-8a9d-4865-8a89-d00f6a27962b", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:41:25.361660810Z", + "start_time": "2026-10-29T16:41:25.354787556Z" + } + }, + "outputs": [], + "source": [ + "from logging import getLogger\n", + "\n", + "LOG = getLogger(\"notebook\")" + ] + }, + { + "cell_type": "markdown", + "id": "55cc48d3-7276-48f4-acda-d27fb7bc6cc3", + "metadata": {}, + "source": [ + "The `zappend` function can also process in-memory slice datasets of type `xr.Dataset`:" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "4a79a16b-9c0a-4a04-8774-04b1871b767d", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:41:25.373036564Z", + "start_time": "2026-10-29T16:41:25.362842491Z" + } + }, + "outputs": [], + "source": [ + "log = getLogger(\"notebook\")\n", + "\n", + "\n", + "def process_slice(slice_path: str) -> xr.Dataset:\n", + " LOG.info(f\"Processing slice {slice_path}\")\n", + " slice_ds = xr.open_dataset(slice_path)\n", + " return slice_ds.drop_vars([\"SPM_QI\", \"TUR_QI\", \"crs\"])\n", + "\n", + "\n", + "slice_generator = (process_slice(slice_path) for slice_path in slice_paths)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "3eb9fcda-b166-4139-9ad2-11af13f1e116", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:41:28.672001062Z", + "start_time": "2026-10-29T16:41:25.373927726Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-10-29 17:41:25,431 INFO Processing slice inputs/demo/20230601_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc\n", + "2026-10-29 17:41:25,443 INFO Processing in-memory slice dataset #0\n", + "2026-10-29 17:41:25,445 INFO Creating target dataset outputs/target.zarr\n", + "2026-10-29 17:41:26,531 INFO Transaction completed.\n", + "2026-10-29 17:41:26,531 INFO Slice dataset #0 processed\n", + "2026-10-29 17:41:26,532 INFO Processing slice inputs/demo/20230603_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc\n", + "2026-10-29 17:41:26,550 INFO Processing in-memory slice dataset #1\n", + "2026-10-29 17:41:26,551 INFO Updating target dataset outputs/target.zarr\n", + "2026-10-29 17:41:27,536 INFO Transaction completed.\n", + "2026-10-29 17:41:27,537 INFO Slice dataset #1 processed\n", + "2026-10-29 17:41:27,537 INFO Processing slice inputs/demo/20230605_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc\n", + "2026-10-29 17:41:27,566 INFO Processing in-memory slice dataset #2\n", + "2026-10-29 17:41:27,568 INFO Updating target dataset outputs/target.zarr\n", + "2026-10-29 17:41:28,665 INFO Transaction completed.\n", + "2026-10-29 17:41:28,666 INFO Slice dataset #2 processed\n" + ] + }, + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "zappend(slice_generator, config=config)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "784bdfeb-6572-483e-89db-a8eadb1681bc", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:41:28.704029993Z", + "start_time": "2026-10-29T16:41:28.677692526Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 712MB\n",
+       "Dimensions:  (time: 3, lat: 8640, lon: 3435)\n",
+       "Coordinates:\n",
+       "  * time     (time) datetime64[ns] 24B 2023-06-01 2023-06-03 2023-06-05\n",
+       "  * lat      (lat) float64 69kB 64.0 64.0 64.0 64.0 64.0 ... 56.0 56.0 56.0 56.0\n",
+       "  * lon      (lon) float64 27kB 6.0 6.002 6.004 6.005 ... 11.99 12.0 12.0 12.0\n",
+       "Data variables:\n",
+       "    SPM      (time, lat, lon) float32 356MB dask.array<chunksize=(1, 540, 286), meta=np.ndarray>\n",
+       "    TUR      (time, lat, lon) float32 356MB dask.array<chunksize=(1, 540, 286), meta=np.ndarray>\n",
+       "Attributes: (12/46)\n",
+       "    TileSize:                   540:286\n",
+       "    id:                         20230601_P1D_CMEMS_HROC_L3_transp_BAL_32V_100...\n",
+       "    title:                      CMEMS HR-OC Baltic Sea transparency (spm, tur...\n",
+       "    region:                     BAL\n",
+       "    tile:                       32V\n",
+       "    cmems_product_id:           OCEANCOLOUR_BAL_BGC_HR_L3_NRT_009_202\n",
+       "    ...                         ...\n",
+       "    time_coverage_duration:     P1D\n",
+       "    time_coverage_resolution:   P1D\n",
+       "    platform:                   Sentinel-2\n",
+       "    sensor:                     MSI\n",
+       "    start_date:                 01-JUN-2023 00:00:00.000000\n",
+       "    stop_date:                  01-JUN-2023 00:00:00.000000
" + ], + "text/plain": [ + " Size: 712MB\n", + "Dimensions: (time: 3, lat: 8640, lon: 3435)\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 24B 2023-06-01 2023-06-03 2023-06-05\n", + " * lat (lat) float64 69kB 64.0 64.0 64.0 64.0 64.0 ... 56.0 56.0 56.0 56.0\n", + " * lon (lon) float64 27kB 6.0 6.002 6.004 6.005 ... 11.99 12.0 12.0 12.0\n", + "Data variables:\n", + " SPM (time, lat, lon) float32 356MB dask.array\n", + " TUR (time, lat, lon) float32 356MB dask.array\n", + "Attributes: (12/46)\n", + " TileSize: 540:286\n", + " id: 20230601_P1D_CMEMS_HROC_L3_transp_BAL_32V_100...\n", + " title: CMEMS HR-OC Baltic Sea transparency (spm, tur...\n", + " region: BAL\n", + " tile: 32V\n", + " cmems_product_id: OCEANCOLOUR_BAL_BGC_HR_L3_NRT_009_202\n", + " ... ...\n", + " time_coverage_duration: P1D\n", + " time_coverage_resolution: P1D\n", + " platform: Sentinel-2\n", + " sensor: MSI\n", + " start_date: 01-JUN-2023 00:00:00.000000\n", + " stop_date: 01-JUN-2023 00:00:00.000000" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "xr.open_zarr(target_path)" + ] + }, + { + "cell_type": "markdown", + "id": "0a1cd73a-5a76-4e8f-a687-bfe1ca56d0c0", + "metadata": {}, + "source": [ + "In the case that you need make sure the dataset is really closed after slice processing \n", + "or in order to clean up temporary resource you can write a `SliceSource`:" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "3b82aebf-a596-4ad4-8002-e052d986e1a7", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:41:28.717995054Z", + "start_time": "2026-10-29T16:41:28.705515617Z" + } + }, + "outputs": [], + "source": [ + "rmdir(target_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "e0b8b933-e135-4981-9145-3ca64b9ce1bd", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:41:28.725296477Z", + "start_time": "2026-10-29T16:41:28.718653056Z" + } + }, + "outputs": [], + "source": [ + "from zappend.api import SliceSource\n", + "\n", + "\n", + "class MySliceSource(SliceSource):\n", + " def __init__(self, slice_path):\n", + " self.slice_path = slice_path\n", + " self.slice_ds = None\n", + "\n", + " def get_dataset(self) -> xr.Dataset:\n", + " LOG.info(f\"Processing slice {self.slice_path}\")\n", + " self.slice_ds = xr.open_dataset(self.slice_path)\n", + " return self.slice_ds.drop_vars([\"SPM_QI\", \"TUR_QI\", \"crs\"])\n", + "\n", + " def dispose(self):\n", + " self.slice_ds.close()\n", + " self.slice_ds = None\n", + " LOG.info(\"Slice processed\")" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "41ca765c-0f28-4616-a55f-a598327b52c4", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:41:32.928447178Z", + "start_time": "2026-10-29T16:41:28.725983664Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-10-29 17:41:28,767 INFO Processing slice inputs/demo/20230601_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc\n", + "2026-10-29 17:41:28,777 INFO Creating target dataset outputs/target.zarr\n", + "2026-10-29 17:41:29,802 INFO Transaction completed.\n", + "2026-10-29 17:41:29,802 INFO Slice processed\n", + "2026-10-29 17:41:29,812 INFO Processing slice inputs/demo/20230603_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc\n", + "2026-10-29 17:41:29,821 INFO Updating target dataset outputs/target.zarr\n", + "2026-10-29 17:41:30,794 INFO Transaction completed.\n", + "2026-10-29 17:41:30,796 INFO Slice processed\n", + "2026-10-29 17:41:30,806 INFO Processing slice inputs/demo/20230605_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc\n", + "2026-10-29 17:41:30,814 INFO Updating target dataset outputs/target.zarr\n", + "2026-10-29 17:41:32,907 INFO Transaction completed.\n", + "2026-10-29 17:41:32,910 INFO Slice processed\n" + ] + }, + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "zappend(slice_paths, config=config, slice_source=MySliceSource)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "db79b8bc-3b14-46f8-b15e-2786d2bc97a8", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:41:32.986242898Z", + "start_time": "2026-10-29T16:41:32.934109877Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 712MB\n",
+       "Dimensions:  (time: 3, lat: 8640, lon: 3435)\n",
+       "Coordinates:\n",
+       "  * time     (time) datetime64[ns] 24B 2023-06-01 2023-06-03 2023-06-05\n",
+       "  * lat      (lat) float64 69kB 64.0 64.0 64.0 64.0 64.0 ... 56.0 56.0 56.0 56.0\n",
+       "  * lon      (lon) float64 27kB 6.0 6.002 6.004 6.005 ... 11.99 12.0 12.0 12.0\n",
+       "Data variables:\n",
+       "    SPM      (time, lat, lon) float32 356MB dask.array<chunksize=(1, 540, 286), meta=np.ndarray>\n",
+       "    TUR      (time, lat, lon) float32 356MB dask.array<chunksize=(1, 540, 286), meta=np.ndarray>\n",
+       "Attributes: (12/46)\n",
+       "    TileSize:                   540:286\n",
+       "    id:                         20230601_P1D_CMEMS_HROC_L3_transp_BAL_32V_100...\n",
+       "    title:                      CMEMS HR-OC Baltic Sea transparency (spm, tur...\n",
+       "    region:                     BAL\n",
+       "    tile:                       32V\n",
+       "    cmems_product_id:           OCEANCOLOUR_BAL_BGC_HR_L3_NRT_009_202\n",
+       "    ...                         ...\n",
+       "    time_coverage_duration:     P1D\n",
+       "    time_coverage_resolution:   P1D\n",
+       "    platform:                   Sentinel-2\n",
+       "    sensor:                     MSI\n",
+       "    start_date:                 01-JUN-2023 00:00:00.000000\n",
+       "    stop_date:                  01-JUN-2023 00:00:00.000000
" + ], + "text/plain": [ + " Size: 712MB\n", + "Dimensions: (time: 3, lat: 8640, lon: 3435)\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 24B 2023-06-01 2023-06-03 2023-06-05\n", + " * lat (lat) float64 69kB 64.0 64.0 64.0 64.0 64.0 ... 56.0 56.0 56.0 56.0\n", + " * lon (lon) float64 27kB 6.0 6.002 6.004 6.005 ... 11.99 12.0 12.0 12.0\n", + "Data variables:\n", + " SPM (time, lat, lon) float32 356MB dask.array\n", + " TUR (time, lat, lon) float32 356MB dask.array\n", + "Attributes: (12/46)\n", + " TileSize: 540:286\n", + " id: 20230601_P1D_CMEMS_HROC_L3_transp_BAL_32V_100...\n", + " title: CMEMS HR-OC Baltic Sea transparency (spm, tur...\n", + " region: BAL\n", + " tile: 32V\n", + " cmems_product_id: OCEANCOLOUR_BAL_BGC_HR_L3_NRT_009_202\n", + " ... ...\n", + " time_coverage_duration: P1D\n", + " time_coverage_resolution: P1D\n", + " platform: Sentinel-2\n", + " sensor: MSI\n", + " start_date: 01-JUN-2023 00:00:00.000000\n", + " stop_date: 01-JUN-2023 00:00:00.000000" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "xr.open_zarr(target_path)" + ] + }, + { + "cell_type": "markdown", + "id": "d2b3c74b-a0be-420b-98b9-f319b5831368", + "metadata": {}, + "source": [ + "## Enforce Transaction Rollback\n", + "\n", + "Demonstrate that appending a slice is a transaction, that is rolled back on error.\n", + "\n", + "To simulate a failure that occurs on a random data chunk, we define the following \n", + "slice source `MyGrottySliceSource` that will fail when computing the 12th \n", + "chunk of a newly computed (useless) variable `SPM_05`." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "0c25f1ce-9adf-43ad-b07c-3462ba143268", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:41:32.998547295Z", + "start_time": "2026-10-29T16:41:32.988482576Z" + } + }, + "outputs": [], + "source": [ + "from zappend.api import SliceSource\n", + "\n", + "\n", + "class MyGrottySliceSource(SliceSource):\n", + " def __init__(self, slice_path):\n", + " self.slice_path = slice_path\n", + " self.slice_ds = None\n", + " self.is_bad = \"20230605\" in slice_path\n", + " self.num_chunks_seen = 0\n", + "\n", + " def half_spm(self, spm):\n", + " if self.is_bad:\n", + " self.num_chunks_seen += 1\n", + " if self.num_chunks_seen == 12:\n", + " raise ValueError(\"Bad chunk detected!\")\n", + " return 0.5 * spm\n", + "\n", + " def get_dataset(self) -> xr.Dataset:\n", + " LOG.info(f\"Processing slice {self.slice_path}\")\n", + " slice_ds = xr.open_dataset(self.slice_path)\n", + " slice_ds = slice_ds.drop_vars([\"SPM_QI\", \"TUR_QI\", \"crs\"])\n", + " slice_ds = slice_ds.chunk({\"lon\": 2000, \"lat\": 1000})\n", + " for v in slice_ds.data_vars.values():\n", + " v.encoding = {}\n", + " slice_ds[\"SPM_05\"] = slice_ds[\"SPM\"].map_blocks(\n", + " self.half_spm, template=slice_ds[\"SPM\"]\n", + " )\n", + " self.slice_ds = slice_ds\n", + " return slice_ds\n", + "\n", + " def dispose(self):\n", + " self.slice_ds.close()\n", + " self.slice_ds = None\n", + " LOG.info(\"Slice processed\")" + ] + }, + { + "cell_type": "markdown", + "id": "2a1ee2db-544d-4b6c-8d09-cf624e128ccc", + "metadata": {}, + "source": [ + "The following `zappend` call will fail on third slice, but changes will be rolled back so that \n", + "the target dataset is still ok, rather than in an invalid state." + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "ffb3a76efbce5ec2", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:41:33.019005674Z", + "start_time": "2026-10-29T16:41:32.999748562Z" + } + }, + "outputs": [], + "source": [ + "rmdir(target_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "0e87ae12-7cfb-44a3-9d53-098fce933293", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:41:37.410125313Z", + "start_time": "2026-10-29T16:41:33.020593661Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-10-29 17:41:33,090 INFO Processing slice inputs/demo/20230601_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc\n", + "2026-10-29 17:41:33,126 INFO Creating target dataset outputs/target.zarr\n", + "2026-10-29 17:41:34,465 INFO Transaction completed.\n", + "2026-10-29 17:41:34,466 INFO Slice processed\n", + "2026-10-29 17:41:34,490 INFO Processing slice inputs/demo/20230603_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc\n", + "2026-10-29 17:41:34,519 INFO Updating target dataset outputs/target.zarr\n", + "2026-10-29 17:41:35,929 INFO Transaction completed.\n", + "2026-10-29 17:41:35,930 INFO Slice processed\n", + "2026-10-29 17:41:35,949 INFO Processing slice inputs/demo/20230605_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc\n", + "2026-10-29 17:41:35,972 INFO Updating target dataset outputs/target.zarr\n", + "2026-10-29 17:41:36,426 ERROR Error in transaction\n", + "Traceback (most recent call last):\n", + " File \"/home/konstantin/micromamba/envs/zappend/lib/python3.15/site-packages/zappend/processor.py\", line 122, in process_slice\n", + " update_target_from_slice(ctx, slice_dataset, rollback_callback)\n", + " ~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/konstantin/micromamba/envs/zappend/lib/python3.15/site-packages/zappend/processor.py\", line 179, in update_target_from_slice\n", + " slice_ds.to_zarr(\n", + " ~~~~~~~~~~~~~~~~^\n", + " store=target_store,\n", + " ^^^^^^^^^^^^^^^^^^^\n", + " ...<4 lines>...\n", + " zarr_format=ctx.config.zarr_version,\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " )\n", + " ^\n", + " File \"/home/konstantin/micromamba/envs/zappend/lib/python3.15/site-packages/xarray/core/dataset.py\", line 2390, in to_zarr\n", + " return to_zarr( # type: ignore[call-overload,misc]\n", + " self,\n", + " ...<16 lines>...\n", + " chunkmanager_store_kwargs=chunkmanager_store_kwargs,\n", + " )\n", + " File \"/home/konstantin/micromamba/envs/zappend/lib/python3.15/site-packages/xarray/backends/writers.py\", line 798, in to_zarr\n", + " writes = writer.sync(\n", + " compute=compute, chunkmanager_store_kwargs=chunkmanager_store_kwargs\n", + " )\n", + " File \"/home/konstantin/micromamba/envs/zappend/lib/python3.15/site-packages/xarray/backends/common.py\", line 416, in sync\n", + " delayed_store = chunkmanager.store(\n", + " self.sources,\n", + " ...<5 lines>...\n", + " **chunkmanager_store_kwargs,\n", + " )\n", + " File \"/home/konstantin/micromamba/envs/zappend/lib/python3.15/site-packages/xarray/namedarray/daskmanager.py\", line 247, in store\n", + " return store(\n", + " sources=sources,\n", + " targets=targets,\n", + " **kwargs,\n", + " )\n", + " File \"/home/konstantin/micromamba/envs/zappend/lib/python3.15/site-packages/dask/array/core.py\", line 1220, in store\n", + " dask.compute(arrays, **kwargs)\n", + " ~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^\n", + " File \"/home/konstantin/micromamba/envs/zappend/lib/python3.15/site-packages/dask/base.py\", line 769, in compute\n", + " results = schedule(expr, keys, **kwargs)\n", + " File \"/home/konstantin/micromamba/envs/zappend/lib/python3.15/site-packages/xarray/core/parallel.py\", line 351, in _wrapper\n", + " result = func(*converted_args, **kwargs)\n", + " File \"/tmp/ipykernel_88459/2662605035.py\", line 15, in half_spm\n", + " raise ValueError(\"Bad chunk detected!\")\n", + "ValueError: Bad chunk detected!\n", + "2026-10-29 17:41:36,434 INFO Rolling back 34 action(s)\n", + "2026-10-29 17:41:36,439 INFO Transaction completed.\n", + "2026-10-29 17:41:36,440 INFO Slice processed\n" + ] + }, + { + "ename": "ValueError", + "evalue": "Bad chunk detected!", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mValueError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[41]\u001b[39m\u001b[32m, line 2\u001b[39m\n\u001b[32m 1\u001b[39m rmdir(target_path)\n\u001b[32m----> \u001b[39m\u001b[32m2\u001b[39m zappend(slice_paths, target_dir=target_path, slice_source=MyGrottySliceSource)\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/micromamba/envs/zappend/lib/python3.15/site-packages/zappend/api.py:72\u001b[39m, in \u001b[36mzappend\u001b[39m\u001b[34m(slices, config, **kwargs)\u001b[39m\n\u001b[32m 33\u001b[39m \u001b[38;5;250m\u001b[39m\u001b[33;03m\"\"\"Robustly create or update a Zarr dataset from dataset slices.\u001b[39;00m\n\u001b[32m 34\u001b[39m \n\u001b[32m 35\u001b[39m \u001b[33;03mThe `zappend` function concatenates the dataset slices from given\u001b[39;00m\n\u001b[32m (...)\u001b[39m\u001b[32m 69\u001b[39m \n\u001b[32m 70\u001b[39m \u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m 71\u001b[39m processor = Processor(config, **kwargs)\n\u001b[32m---> \u001b[39m\u001b[32m72\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[30;43mprocessor\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43mprocess_slices\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43mslices\u001b[39;49m\u001b[30;43m)\u001b[39;49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/micromamba/envs/zappend/lib/python3.15/site-packages/zappend/processor.py:72\u001b[39m, in \u001b[36mProcessor.process_slices\u001b[39m\u001b[34m(self, slices)\u001b[39m\n\u001b[32m 70\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m._profiler:\n\u001b[32m 71\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m slice_item \u001b[38;5;129;01min\u001b[39;00m slices:\n\u001b[32m---> \u001b[39m\u001b[32m72\u001b[39m \u001b[30;43mself\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43mprocess_slice\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43mslice_item\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43mslice_index\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mslice_index\u001b[39;49m\u001b[30;43m)\u001b[39;49m\n\u001b[32m 73\u001b[39m slice_index += \u001b[32m1\u001b[39m\n\u001b[32m 74\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m slice_index\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/micromamba/envs/zappend/lib/python3.15/site-packages/zappend/processor.py:122\u001b[39m, in \u001b[36mProcessor.process_slice\u001b[39m\u001b[34m(self, slice_item, slice_index)\u001b[39m\n\u001b[32m 120\u001b[39m create_target_from_slice(ctx, slice_dataset, rollback_callback)\n\u001b[32m 121\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m--> \u001b[39m\u001b[32m122\u001b[39m \u001b[30;43mupdate_target_from_slice\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43mctx\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43mslice_dataset\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43mrollback_callback\u001b[39;49m\u001b[30;43m)\u001b[39;49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/micromamba/envs/zappend/lib/python3.15/site-packages/zappend/processor.py:179\u001b[39m, in \u001b[36mupdate_target_from_slice\u001b[39m\u001b[34m(ctx, slice_ds, rollback_cb)\u001b[39m\n\u001b[32m 174\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m\n\u001b[32m 176\u001b[39m target_store = make_rollback_store(\n\u001b[32m 177\u001b[39m target_dir.fs.get_mapper(root=target_dir.path), rollback_cb\n\u001b[32m 178\u001b[39m )\n\u001b[32m--> \u001b[39m\u001b[32m179\u001b[39m \u001b[30;43mslice_ds\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43mto_zarr\u001b[39;49m\u001b[30;43m(\u001b[39;49m\n\u001b[32m 180\u001b[39m \u001b[30;43m \u001b[39;49m\u001b[30;43mstore\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mtarget_store\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m 181\u001b[39m \u001b[30;43m \u001b[39;49m\u001b[30;43mwrite_empty_chunks\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43;01mFalse\u001b[39;49;00m\u001b[30;43m,\u001b[39;49m\n\u001b[32m 182\u001b[39m \u001b[30;43m \u001b[39;49m\u001b[30;43mconsolidated\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43m_consolidated_option\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43mctx\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43mconfig\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43mzarr_version\u001b[39;49m\u001b[30;43m)\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m 183\u001b[39m \u001b[30;43m \u001b[39;49m\u001b[30;43mmode\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43m\"\u001b[39;49m\u001b[30;43ma\u001b[39;49m\u001b[30;43m\"\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m 184\u001b[39m \u001b[30;43m \u001b[39;49m\u001b[30;43mappend_dim\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mctx\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43mconfig\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43mappend_dim\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m 185\u001b[39m \u001b[30;43m \u001b[39;49m\u001b[30;43mzarr_format\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mctx\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43mconfig\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43mzarr_version\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m 186\u001b[39m \u001b[30;43m\u001b[39;49m\u001b[30;43m)\u001b[39;49m\n\u001b[32m 188\u001b[39m post_update_target(ctx, target_store, slice_ds)\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/micromamba/envs/zappend/lib/python3.15/site-packages/xarray/core/dataset.py:2390\u001b[39m, in \u001b[36mDataset.to_zarr\u001b[39m\u001b[34m(self, store, chunk_store, mode, synchronizer, group, encoding, compute, consolidated, append_dim, region, safe_chunks, align_chunks, storage_options, zarr_version, zarr_format, write_empty_chunks, chunkmanager_store_kwargs)\u001b[39m\n\u001b[32m 2386\u001b[39m The I/O user guide, \u001b[38;5;28;01mwith\u001b[39;00m more details \u001b[38;5;28;01mand\u001b[39;00m examples.\n\u001b[32m 2387\u001b[39m \"\"\"\n\u001b[32m 2388\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m xarray.backends.writers \u001b[38;5;28;01mimport\u001b[39;00m to_zarr\n\u001b[32m 2389\u001b[39m \n\u001b[32m-> \u001b[39m\u001b[32m2390\u001b[39m return to_zarr( # type: ignore[call-overload,misc]\n\u001b[32m 2391\u001b[39m self,\n\u001b[32m 2392\u001b[39m store=store,\n\u001b[32m 2393\u001b[39m chunk_store=chunk_store,\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/micromamba/envs/zappend/lib/python3.15/site-packages/xarray/backends/writers.py:798\u001b[39m, in \u001b[36mto_zarr\u001b[39m\u001b[34m(dataset, store, chunk_store, mode, synchronizer, group, encoding, compute, consolidated, append_dim, region, safe_chunks, align_chunks, storage_options, zarr_version, zarr_format, write_empty_chunks, chunkmanager_store_kwargs)\u001b[39m\n\u001b[32m 796\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m 797\u001b[39m dump_to_store(dataset, zstore, writer, encoding=encoding)\n\u001b[32m--> \u001b[39m\u001b[32m798\u001b[39m writes = \u001b[30;43mwriter\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43msync\u001b[39;49m\u001b[30;43m(\u001b[39;49m\n\u001b[32m 799\u001b[39m \u001b[30;43m \u001b[39;49m\u001b[30;43mcompute\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mcompute\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43mchunkmanager_store_kwargs\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mchunkmanager_store_kwargs\u001b[39;49m\n\u001b[32m 800\u001b[39m \u001b[30;43m \u001b[39;49m\u001b[30;43m)\u001b[39;49m\n\u001b[32m 801\u001b[39m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[32m 802\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m compute:\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/micromamba/envs/zappend/lib/python3.15/site-packages/xarray/backends/common.py:416\u001b[39m, in \u001b[36mArrayWriter.sync\u001b[39m\u001b[34m(self, compute, chunkmanager_store_kwargs)\u001b[39m\n\u001b[32m 413\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m chunkmanager_store_kwargs \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m 414\u001b[39m chunkmanager_store_kwargs = {}\n\u001b[32m--> \u001b[39m\u001b[32m416\u001b[39m delayed_store = \u001b[30;43mchunkmanager\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43mstore\u001b[39;49m\u001b[30;43m(\u001b[39;49m\n\u001b[32m 417\u001b[39m \u001b[30;43m \u001b[39;49m\u001b[30;43mself\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43msources\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m 418\u001b[39m \u001b[30;43m \u001b[39;49m\u001b[30;43mself\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43mtargets\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m 419\u001b[39m \u001b[30;43m \u001b[39;49m\u001b[30;43mlock\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mself\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43mlock\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m 420\u001b[39m \u001b[30;43m \u001b[39;49m\u001b[30;43mcompute\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mcompute\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m 421\u001b[39m \u001b[30;43m \u001b[39;49m\u001b[30;43mflush\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43;01mTrue\u001b[39;49;00m\u001b[30;43m,\u001b[39;49m\n\u001b[32m 422\u001b[39m \u001b[30;43m \u001b[39;49m\u001b[30;43mregions\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mself\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43mregions\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m 423\u001b[39m \u001b[30;43m \u001b[39;49m\u001b[30;43m*\u001b[39;49m\u001b[30;43m*\u001b[39;49m\u001b[30;43mchunkmanager_store_kwargs\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m 424\u001b[39m \u001b[30;43m\u001b[39;49m\u001b[30;43m)\u001b[39;49m\n\u001b[32m 425\u001b[39m \u001b[38;5;28mself\u001b[39m.sources = []\n\u001b[32m 426\u001b[39m \u001b[38;5;28mself\u001b[39m.targets = []\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/micromamba/envs/zappend/lib/python3.15/site-packages/xarray/namedarray/daskmanager.py:247\u001b[39m, in \u001b[36mDaskManager.store\u001b[39m\u001b[34m(self, sources, targets, **kwargs)\u001b[39m\n\u001b[32m 239\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mstore\u001b[39m(\n\u001b[32m 240\u001b[39m \u001b[38;5;28mself\u001b[39m,\n\u001b[32m 241\u001b[39m sources: Any | Sequence[Any],\n\u001b[32m 242\u001b[39m targets: Any,\n\u001b[32m 243\u001b[39m **kwargs: Any,\n\u001b[32m 244\u001b[39m ) -> Any:\n\u001b[32m 245\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mdask\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01marray\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m store\n\u001b[32m--> \u001b[39m\u001b[32m247\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[30;43mstore\u001b[39;49m\u001b[30;43m(\u001b[39;49m\n\u001b[32m 248\u001b[39m \u001b[30;43m \u001b[39;49m\u001b[30;43msources\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43msources\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m 249\u001b[39m \u001b[30;43m \u001b[39;49m\u001b[30;43mtargets\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mtargets\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m 250\u001b[39m \u001b[30;43m \u001b[39;49m\u001b[30;43m*\u001b[39;49m\u001b[30;43m*\u001b[39;49m\u001b[30;43mkwargs\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m 251\u001b[39m \u001b[30;43m \u001b[39;49m\u001b[30;43m)\u001b[39;49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/micromamba/envs/zappend/lib/python3.15/site-packages/dask/array/core.py:1220\u001b[39m, in \u001b[36mstore\u001b[39m\u001b[34m(***failed resolving arguments***)\u001b[39m\n\u001b[32m 1217\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m return_stored:\n\u001b[32m 1218\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mdask\u001b[39;00m\n\u001b[32m-> \u001b[39m\u001b[32m1220\u001b[39m \u001b[30;43mdask\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43mcompute\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43marrays\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43m*\u001b[39;49m\u001b[30;43m*\u001b[39;49m\u001b[30;43mkwargs\u001b[39;49m\u001b[30;43m)\u001b[39;49m\n\u001b[32m 1221\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m 1222\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/micromamba/envs/zappend/lib/python3.15/site-packages/dask/base.py:769\u001b[39m, in \u001b[36mcompute\u001b[39m\u001b[34m(traverse, optimize_graph, scheduler, get, *args, **kwargs)\u001b[39m\n\u001b[32m 766\u001b[39m expr = expr.optimize()\n\u001b[32m 767\u001b[39m keys = \u001b[38;5;28mlist\u001b[39m(flatten(expr.__dask_keys__()))\n\u001b[32m--> \u001b[39m\u001b[32m769\u001b[39m results = \u001b[30;43mschedule\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43mexpr\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43mkeys\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43m*\u001b[39;49m\u001b[30;43m*\u001b[39;49m\u001b[30;43mkwargs\u001b[39;49m\u001b[30;43m)\u001b[39;49m\n\u001b[32m 771\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m repack(results)\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/micromamba/envs/zappend/lib/python3.15/site-packages/xarray/core/parallel.py:351\u001b[39m, in \u001b[36mmap_blocks.._wrapper\u001b[39m\u001b[34m(func, args, kwargs, arg_is_array, expected, expected_indexes)\u001b[39m\n\u001b[32m 341\u001b[39m \u001b[38;5;250m\u001b[39m\u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m 342\u001b[39m \u001b[33;03mWrapper function that receives datasets in args; converts to dataarrays when necessary;\u001b[39;00m\n\u001b[32m 343\u001b[39m \u001b[33;03mpasses these to the user function `func` and checks returned objects for expected shapes/sizes/etc.\u001b[39;00m\n\u001b[32m 344\u001b[39m \u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m 346\u001b[39m converted_args = [\n\u001b[32m 347\u001b[39m dataset_to_dataarray(arg) \u001b[38;5;28;01mif\u001b[39;00m is_array \u001b[38;5;28;01melse\u001b[39;00m arg\n\u001b[32m 348\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m is_array, arg \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mzip\u001b[39m(arg_is_array, args, strict=\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[32m 349\u001b[39m ]\n\u001b[32m--> \u001b[39m\u001b[32m351\u001b[39m result = \u001b[30;43mfunc\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43m*\u001b[39;49m\u001b[30;43mconverted_args\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43m*\u001b[39;49m\u001b[30;43m*\u001b[39;49m\u001b[30;43mkwargs\u001b[39;49m\u001b[30;43m)\u001b[39;49m\n\u001b[32m 353\u001b[39m merged_coordinates = merge(\n\u001b[32m 354\u001b[39m [arg.coords \u001b[38;5;28;01mfor\u001b[39;00m arg \u001b[38;5;129;01min\u001b[39;00m args \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(arg, Dataset | DataArray)],\n\u001b[32m 355\u001b[39m join=\u001b[33m\"\u001b[39m\u001b[33mexact\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m 356\u001b[39m compat=\u001b[33m\"\u001b[39m\u001b[33moverride\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m 357\u001b[39m ).coords\n\u001b[32m 359\u001b[39m \u001b[38;5;66;03m# check all dims are present\u001b[39;00m\n", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[39]\u001b[39m\u001b[32m, line 15\u001b[39m, in \u001b[36mMyGrottySliceSource.half_spm\u001b[39m\u001b[34m(self, spm)\u001b[39m\n\u001b[32m 11\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m half_spm(self, spm):\n\u001b[32m 12\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m self.is_bad:\n\u001b[32m 13\u001b[39m self.num_chunks_seen += \u001b[32m1\u001b[39m\n\u001b[32m 14\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m self.num_chunks_seen == \u001b[32m12\u001b[39m:\n\u001b[32m---> \u001b[39m\u001b[32m15\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m ValueError(\u001b[33m\"Bad chunk detected!\"\u001b[39m)\n\u001b[32m 16\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[32m0.5\u001b[39m * spm\n", + "\u001b[31mValueError\u001b[39m: Bad chunk detected!" + ] + } + ], + "source": [ + "rmdir(target_path)\n", + "zappend(slice_paths, target_dir=target_path, slice_source=MyGrottySliceSource)" + ] + }, + { + "cell_type": "markdown", + "id": "63ab479d-1ce5-4440-b56a-1ee9f1688328", + "metadata": {}, + "source": "Verify that the target dataset can be opened but has only two of three time steps:" + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "912ac28d-f9dd-4518-be8f-24eea57cd3fa", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:41:59.318430484Z", + "start_time": "2026-10-29T16:41:59.277102469Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 712MB\n",
+       "Dimensions:  (time: 2, lat: 8640, lon: 3435)\n",
+       "Coordinates:\n",
+       "  * time     (time) datetime64[ns] 16B 2023-06-01 2023-06-03\n",
+       "  * lat      (lat) float64 69kB 64.0 64.0 64.0 64.0 64.0 ... 56.0 56.0 56.0 56.0\n",
+       "  * lon      (lon) float64 27kB 6.0 6.002 6.004 6.005 ... 11.99 12.0 12.0 12.0\n",
+       "Data variables:\n",
+       "    SPM      (time, lat, lon) float32 237MB dask.array<chunksize=(1, 1000, 2000), meta=np.ndarray>\n",
+       "    SPM_05   (time, lat, lon) float32 237MB dask.array<chunksize=(1, 1000, 2000), meta=np.ndarray>\n",
+       "    TUR      (time, lat, lon) float32 237MB dask.array<chunksize=(1, 1000, 2000), meta=np.ndarray>\n",
+       "Attributes: (12/46)\n",
+       "    TileSize:                   540:286\n",
+       "    id:                         20230601_P1D_CMEMS_HROC_L3_transp_BAL_32V_100...\n",
+       "    title:                      CMEMS HR-OC Baltic Sea transparency (spm, tur...\n",
+       "    region:                     BAL\n",
+       "    tile:                       32V\n",
+       "    cmems_product_id:           OCEANCOLOUR_BAL_BGC_HR_L3_NRT_009_202\n",
+       "    ...                         ...\n",
+       "    time_coverage_duration:     P1D\n",
+       "    time_coverage_resolution:   P1D\n",
+       "    platform:                   Sentinel-2\n",
+       "    sensor:                     MSI\n",
+       "    start_date:                 01-JUN-2023 00:00:00.000000\n",
+       "    stop_date:                  01-JUN-2023 00:00:00.000000
" + ], + "text/plain": [ + " Size: 712MB\n", + "Dimensions: (time: 2, lat: 8640, lon: 3435)\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 16B 2023-06-01 2023-06-03\n", + " * lat (lat) float64 69kB 64.0 64.0 64.0 64.0 64.0 ... 56.0 56.0 56.0 56.0\n", + " * lon (lon) float64 27kB 6.0 6.002 6.004 6.005 ... 11.99 12.0 12.0 12.0\n", + "Data variables:\n", + " SPM (time, lat, lon) float32 237MB dask.array\n", + " SPM_05 (time, lat, lon) float32 237MB dask.array\n", + " TUR (time, lat, lon) float32 237MB dask.array\n", + "Attributes: (12/46)\n", + " TileSize: 540:286\n", + " id: 20230601_P1D_CMEMS_HROC_L3_transp_BAL_32V_100...\n", + " title: CMEMS HR-OC Baltic Sea transparency (spm, tur...\n", + " region: BAL\n", + " tile: 32V\n", + " cmems_product_id: OCEANCOLOUR_BAL_BGC_HR_L3_NRT_009_202\n", + " ... ...\n", + " time_coverage_duration: P1D\n", + " time_coverage_resolution: P1D\n", + " platform: Sentinel-2\n", + " sensor: MSI\n", + " start_date: 01-JUN-2023 00:00:00.000000\n", + " stop_date: 01-JUN-2023 00:00:00.000000" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "xr.open_zarr(target_path)" + ] + }, + { + "cell_type": "markdown", + "id": "e3920732-c82a-4695-abbf-73f7f895a91e", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "1ed243f1-388e-4dca-8040-08a2c63a167e", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:42:03.610055912Z", + "start_time": "2026-10-29T16:42:03.592590393Z" + } + }, + "outputs": [], + "source": [ + "rmdir(target_path)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/inputs/20230601_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc b/examples/inputs/demo/20230601_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc similarity index 100% rename from examples/inputs/20230601_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc rename to examples/inputs/demo/20230601_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc diff --git a/examples/inputs/20230603_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc b/examples/inputs/demo/20230603_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc similarity index 100% rename from examples/inputs/20230603_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc rename to examples/inputs/demo/20230603_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc diff --git a/examples/inputs/20230605_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc b/examples/inputs/demo/20230605_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc similarity index 100% rename from examples/inputs/20230605_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc rename to examples/inputs/demo/20230605_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc diff --git a/examples/netcdf.ipynb b/examples/netcdf.ipynb new file mode 100644 index 0000000..60a98a4 --- /dev/null +++ b/examples/netcdf.ipynb @@ -0,0 +1,2290 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "919aab99364a9853", + "metadata": {}, + "source": [ + "# Appending generated NetCDF slices\n", + "\n", + "This example uses the same daily synthetic data as `zarr_v2.ipynb`, but writes the input slices as NetCDF files. The two `zappend` calls deliberately match the v2 example so the input format is the only difference." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "58720f111366a78", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:49:44.992480542Z", + "start_time": "2026-10-29T16:49:44.984326018Z" + } + }, + "outputs": [], + "source": [ + "import os\n", + "import shutil\n", + "from pathlib import Path\n", + "\n", + "import xarray as xr\n", + "from create_inputs import make_netcdf_slices\n", + "\n", + "from zappend.api import zappend" + ] + }, + { + "cell_type": "markdown", + "id": "16d23d68febd7eb6", + "metadata": {}, + "source": [ + "## Generate and collect the NetCDF inputs\n", + "\n", + "`make_netcdf_slices` uses the shared `make_slice` data factory and writes compressed NetCDF files to `inputs/netcdf`." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "a3d9f5c63a761a1d", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:44:28.938772051Z", + "start_time": "2026-10-29T16:44:23.682722940Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 4.15 s, sys: 725 ms, total: 4.87 s\n", + "Wall time: 5.23 s\n" + ] + } + ], + "source": [ + "%%time\n", + "make_netcdf_slices(31)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "9e3b730ce7184ffe", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:49:47.046904247Z", + "start_time": "2026-10-29T16:49:46.981117547Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['inputs/netcdf/slice-2024-01-01.nc',\n", + " 'inputs/netcdf/slice-2024-01-02.nc',\n", + " 'inputs/netcdf/slice-2024-01-03.nc']" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "input_dir = Path('inputs/netcdf')\n", + "output_dir = Path('outputs')\n", + "output_dir.mkdir(exist_ok=True)\n", + "slices = sorted(str(path) for path in input_dir.glob('*.nc'))\n", + "assert len(slices) == 31\n", + "slices[:3]" + ] + }, + { + "cell_type": "markdown", + "id": "78272a3e25c7a9df", + "metadata": {}, + "source": [ + "## Default layout: favor spatial access\n", + "\n", + "This call is identical to the first v2 Zarr example. With no target format specified, zappend writes a Zarr v2 target and obtains its initial metadata and encoding from the first NetCDF slice." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "9666be286d1c471", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:44:35.209468779Z", + "start_time": "2026-10-29T16:44:29.009517273Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-10-29 17:44:29,055 WARNING Setting 'force_new' is enabled. This will permanently delete existing targets (no rollback).\n", + "2026-10-29 17:44:29,056 WARNING Permanently deleting outputs/netcdf_example_space_opt.zarr\n", + "2026-10-29 17:44:29,131 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-01.nc\n", + "2026-10-29 17:44:29,166 INFO Creating target dataset outputs/netcdf_example_space_opt.zarr\n", + "2026-10-29 17:44:29,308 INFO Transaction completed.\n", + "2026-10-29 17:44:29,309 INFO Slice dataset inputs/netcdf/slice-2024-01-01.nc closed\n", + "2026-10-29 17:44:29,319 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-02.nc\n", + "2026-10-29 17:44:29,329 INFO Updating target dataset outputs/netcdf_example_space_opt.zarr\n", + "2026-10-29 17:44:29,500 INFO Transaction completed.\n", + "2026-10-29 17:44:29,501 INFO Slice dataset inputs/netcdf/slice-2024-01-02.nc closed\n", + "2026-10-29 17:44:29,512 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-03.nc\n", + "2026-10-29 17:44:29,521 INFO Updating target dataset outputs/netcdf_example_space_opt.zarr\n", + "2026-10-29 17:44:29,718 INFO Transaction completed.\n", + "2026-10-29 17:44:29,721 INFO Slice dataset inputs/netcdf/slice-2024-01-03.nc closed\n", + "2026-10-29 17:44:29,742 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-04.nc\n", + "2026-10-29 17:44:29,757 INFO Updating target dataset outputs/netcdf_example_space_opt.zarr\n", + "2026-10-29 17:44:29,969 INFO Transaction completed.\n", + "2026-10-29 17:44:29,970 INFO Slice dataset inputs/netcdf/slice-2024-01-04.nc closed\n", + "2026-10-29 17:44:29,985 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-05.nc\n", + "2026-10-29 17:44:29,996 INFO Updating target dataset outputs/netcdf_example_space_opt.zarr\n", + "2026-10-29 17:44:30,201 INFO Transaction completed.\n", + "2026-10-29 17:44:30,202 INFO Slice dataset inputs/netcdf/slice-2024-01-05.nc closed\n", + "2026-10-29 17:44:30,213 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-06.nc\n", + "2026-10-29 17:44:30,222 INFO Updating target dataset outputs/netcdf_example_space_opt.zarr\n", + "2026-10-29 17:44:30,442 INFO Transaction completed.\n", + "2026-10-29 17:44:30,443 INFO Slice dataset inputs/netcdf/slice-2024-01-06.nc closed\n", + "2026-10-29 17:44:30,459 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-07.nc\n", + "2026-10-29 17:44:30,470 INFO Updating target dataset outputs/netcdf_example_space_opt.zarr\n", + "2026-10-29 17:44:30,643 INFO Transaction completed.\n", + "2026-10-29 17:44:30,644 INFO Slice dataset inputs/netcdf/slice-2024-01-07.nc closed\n", + "2026-10-29 17:44:30,656 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-08.nc\n", + "2026-10-29 17:44:30,665 INFO Updating target dataset outputs/netcdf_example_space_opt.zarr\n", + "2026-10-29 17:44:30,816 INFO Transaction completed.\n", + "2026-10-29 17:44:30,818 INFO Slice dataset inputs/netcdf/slice-2024-01-08.nc closed\n", + "2026-10-29 17:44:30,832 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-09.nc\n", + "2026-10-29 17:44:30,843 INFO Updating target dataset outputs/netcdf_example_space_opt.zarr\n", + "2026-10-29 17:44:31,067 INFO Transaction completed.\n", + "2026-10-29 17:44:31,069 INFO Slice dataset inputs/netcdf/slice-2024-01-09.nc closed\n", + "2026-10-29 17:44:31,086 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-10.nc\n", + "2026-10-29 17:44:31,098 INFO Updating target dataset outputs/netcdf_example_space_opt.zarr\n", + "2026-10-29 17:44:31,277 INFO Transaction completed.\n", + "2026-10-29 17:44:31,278 INFO Slice dataset inputs/netcdf/slice-2024-01-10.nc closed\n", + "2026-10-29 17:44:31,292 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-11.nc\n", + "2026-10-29 17:44:31,300 INFO Updating target dataset outputs/netcdf_example_space_opt.zarr\n", + "2026-10-29 17:44:31,456 INFO Transaction completed.\n", + "2026-10-29 17:44:31,457 INFO Slice dataset inputs/netcdf/slice-2024-01-11.nc closed\n", + "2026-10-29 17:44:31,472 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-12.nc\n", + "2026-10-29 17:44:31,480 INFO Updating target dataset outputs/netcdf_example_space_opt.zarr\n", + "2026-10-29 17:44:31,662 INFO Transaction completed.\n", + "2026-10-29 17:44:31,663 INFO Slice dataset inputs/netcdf/slice-2024-01-12.nc closed\n", + "2026-10-29 17:44:31,681 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-13.nc\n", + "2026-10-29 17:44:31,692 INFO Updating target dataset outputs/netcdf_example_space_opt.zarr\n", + "2026-10-29 17:44:31,879 INFO Transaction completed.\n", + "2026-10-29 17:44:31,880 INFO Slice dataset inputs/netcdf/slice-2024-01-13.nc closed\n", + "2026-10-29 17:44:31,894 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-14.nc\n", + "2026-10-29 17:44:31,903 INFO Updating target dataset outputs/netcdf_example_space_opt.zarr\n", + "2026-10-29 17:44:32,072 INFO Transaction completed.\n", + "2026-10-29 17:44:32,073 INFO Slice dataset inputs/netcdf/slice-2024-01-14.nc closed\n", + "2026-10-29 17:44:32,088 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-15.nc\n", + "2026-10-29 17:44:32,097 INFO Updating target dataset outputs/netcdf_example_space_opt.zarr\n", + "2026-10-29 17:44:32,245 INFO Transaction completed.\n", + "2026-10-29 17:44:32,246 INFO Slice dataset inputs/netcdf/slice-2024-01-15.nc closed\n", + "2026-10-29 17:44:32,261 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-16.nc\n", + "2026-10-29 17:44:32,271 INFO Updating target dataset outputs/netcdf_example_space_opt.zarr\n", + "2026-10-29 17:44:32,418 INFO Transaction completed.\n", + "2026-10-29 17:44:32,419 INFO Slice dataset inputs/netcdf/slice-2024-01-16.nc closed\n", + "2026-10-29 17:44:32,435 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-17.nc\n", + "2026-10-29 17:44:32,444 INFO Updating target dataset outputs/netcdf_example_space_opt.zarr\n", + "2026-10-29 17:44:32,605 INFO Transaction completed.\n", + "2026-10-29 17:44:32,606 INFO Slice dataset inputs/netcdf/slice-2024-01-17.nc closed\n", + "2026-10-29 17:44:32,623 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-18.nc\n", + "2026-10-29 17:44:32,632 INFO Updating target dataset outputs/netcdf_example_space_opt.zarr\n", + "2026-10-29 17:44:32,791 INFO Transaction completed.\n", + "2026-10-29 17:44:32,792 INFO Slice dataset inputs/netcdf/slice-2024-01-18.nc closed\n", + "2026-10-29 17:44:32,809 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-19.nc\n", + "2026-10-29 17:44:32,819 INFO Updating target dataset outputs/netcdf_example_space_opt.zarr\n", + "2026-10-29 17:44:32,979 INFO Transaction completed.\n", + "2026-10-29 17:44:32,980 INFO Slice dataset inputs/netcdf/slice-2024-01-19.nc closed\n", + "2026-10-29 17:44:32,998 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-20.nc\n", + "2026-10-29 17:44:33,008 INFO Updating target dataset outputs/netcdf_example_space_opt.zarr\n", + "2026-10-29 17:44:33,169 INFO Transaction completed.\n", + "2026-10-29 17:44:33,170 INFO Slice dataset inputs/netcdf/slice-2024-01-20.nc closed\n", + "2026-10-29 17:44:33,186 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-21.nc\n", + "2026-10-29 17:44:33,195 INFO Updating target dataset outputs/netcdf_example_space_opt.zarr\n", + "2026-10-29 17:44:33,343 INFO Transaction completed.\n", + "2026-10-29 17:44:33,344 INFO Slice dataset inputs/netcdf/slice-2024-01-21.nc closed\n", + "2026-10-29 17:44:33,361 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-22.nc\n", + "2026-10-29 17:44:33,371 INFO Updating target dataset outputs/netcdf_example_space_opt.zarr\n", + "2026-10-29 17:44:33,537 INFO Transaction completed.\n", + "2026-10-29 17:44:33,538 INFO Slice dataset inputs/netcdf/slice-2024-01-22.nc closed\n", + "2026-10-29 17:44:33,556 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-23.nc\n", + "2026-10-29 17:44:33,564 INFO Updating target dataset outputs/netcdf_example_space_opt.zarr\n", + "2026-10-29 17:44:33,724 INFO Transaction completed.\n", + "2026-10-29 17:44:33,725 INFO Slice dataset inputs/netcdf/slice-2024-01-23.nc closed\n", + "2026-10-29 17:44:33,742 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-24.nc\n", + "2026-10-29 17:44:33,751 INFO Updating target dataset outputs/netcdf_example_space_opt.zarr\n", + "2026-10-29 17:44:33,894 INFO Transaction completed.\n", + "2026-10-29 17:44:33,895 INFO Slice dataset inputs/netcdf/slice-2024-01-24.nc closed\n", + "2026-10-29 17:44:33,914 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-25.nc\n", + "2026-10-29 17:44:33,924 INFO Updating target dataset outputs/netcdf_example_space_opt.zarr\n", + "2026-10-29 17:44:34,082 INFO Transaction completed.\n", + "2026-10-29 17:44:34,083 INFO Slice dataset inputs/netcdf/slice-2024-01-25.nc closed\n", + "2026-10-29 17:44:34,101 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-26.nc\n", + "2026-10-29 17:44:34,110 INFO Updating target dataset outputs/netcdf_example_space_opt.zarr\n", + "2026-10-29 17:44:34,261 INFO Transaction completed.\n", + "2026-10-29 17:44:34,262 INFO Slice dataset inputs/netcdf/slice-2024-01-26.nc closed\n", + "2026-10-29 17:44:34,279 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-27.nc\n", + "2026-10-29 17:44:34,288 INFO Updating target dataset outputs/netcdf_example_space_opt.zarr\n", + "2026-10-29 17:44:34,437 INFO Transaction completed.\n", + "2026-10-29 17:44:34,438 INFO Slice dataset inputs/netcdf/slice-2024-01-27.nc closed\n", + "2026-10-29 17:44:34,459 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-28.nc\n", + "2026-10-29 17:44:34,469 INFO Updating target dataset outputs/netcdf_example_space_opt.zarr\n", + "2026-10-29 17:44:34,621 INFO Transaction completed.\n", + "2026-10-29 17:44:34,622 INFO Slice dataset inputs/netcdf/slice-2024-01-28.nc closed\n", + "2026-10-29 17:44:34,643 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-29.nc\n", + "2026-10-29 17:44:34,653 INFO Updating target dataset outputs/netcdf_example_space_opt.zarr\n", + "2026-10-29 17:44:34,803 INFO Transaction completed.\n", + "2026-10-29 17:44:34,804 INFO Slice dataset inputs/netcdf/slice-2024-01-29.nc closed\n", + "2026-10-29 17:44:34,823 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-30.nc\n", + "2026-10-29 17:44:34,832 INFO Updating target dataset outputs/netcdf_example_space_opt.zarr\n", + "2026-10-29 17:44:34,994 INFO Transaction completed.\n", + "2026-10-29 17:44:34,995 INFO Slice dataset inputs/netcdf/slice-2024-01-30.nc closed\n", + "2026-10-29 17:44:35,014 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-31.nc\n", + "2026-10-29 17:44:35,025 INFO Updating target dataset outputs/netcdf_example_space_opt.zarr\n", + "2026-10-29 17:44:35,178 INFO Transaction completed.\n", + "2026-10-29 17:44:35,179 INFO Slice dataset inputs/netcdf/slice-2024-01-31.nc closed\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 6.7 s, sys: 1.7 s, total: 8.4 s\n", + "Wall time: 6.17 s\n" + ] + } + ], + "source": [ + "%%time\n", + "target = output_dir / 'netcdf_example_space_opt.zarr'\n", + "count = zappend(\n", + " slices,\n", + " target_dir=str(target),\n", + " force_new=True,\n", + " logging='INFO',\n", + ")\n", + "assert count == len(slices)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "1b3bae51e706b7bb", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:44:35.258007063Z", + "start_time": "2026-10-29T16:44:35.211305504Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 21.3 ms, sys: 6.13 ms, total: 27.4 ms\n", + "Wall time: 22.1 ms\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 1GB\n",
+       "Dimensions:       (time: 31, lat: 1800, lon: 3600)\n",
+       "Coordinates:\n",
+       "  * time          (time) datetime64[ns] 248B 2024-01-01 ... 2024-01-31\n",
+       "  * lat           (lat) float32 7kB -89.95 -89.85 -89.75 ... 89.75 89.85 89.95\n",
+       "  * lon           (lon) float32 14kB -179.9 -179.9 -179.8 ... 179.7 179.8 179.9\n",
+       "Data variables:\n",
+       "    quality_flag  (time, lat, lon) uint8 201MB dask.array<chunksize=(1, 450, 450), meta=np.ndarray>\n",
+       "    temperature   (time, lat, lon) float32 804MB dask.array<chunksize=(1, 450, 450), meta=np.ndarray>\n",
+       "Attributes:\n",
+       "    title:    Zappend example slice
" + ], + "text/plain": [ + " Size: 1GB\n", + "Dimensions: (time: 31, lat: 1800, lon: 3600)\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 248B 2024-01-01 ... 2024-01-31\n", + " * lat (lat) float32 7kB -89.95 -89.85 -89.75 ... 89.75 89.85 89.95\n", + " * lon (lon) float32 14kB -179.9 -179.9 -179.8 ... 179.7 179.8 179.9\n", + "Data variables:\n", + " quality_flag (time, lat, lon) uint8 201MB dask.array\n", + " temperature (time, lat, lon) float32 804MB dask.array\n", + "Attributes:\n", + " title: Zappend example slice" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "ds = xr.open_zarr(target)\n", + "ds" + ] + }, + { + "cell_type": "markdown", + "id": "b9e51864180c3f49", + "metadata": {}, + "source": [ + "## Time-series layout\n", + "\n", + "This is the same second call as the v2 Zarr example. The target has 31 time values in each data chunk, so extracting a point time series reads one temporal chunk per 90 by 90 spatial tile. As in the other examples, choose this temporal size from the expected append horizon because existing Zarr chunks cannot expand." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "8b42897e7e6c5fca", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:46:43.807876107Z", + "start_time": "2026-10-29T16:44:35.259952640Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-10-29 17:44:35,304 WARNING Setting 'force_new' is enabled. This will permanently delete existing targets (no rollback).\n", + "2026-10-29 17:44:35,305 WARNING Permanently deleting outputs/netcdf_example_time_opt.zarr\n", + "2026-10-29 17:44:35,358 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-01.nc\n", + "2026-10-29 17:44:35,368 INFO Creating target dataset outputs/netcdf_example_time_opt.zarr\n", + "2026-10-29 17:44:38,003 INFO Transaction completed.\n", + "2026-10-29 17:44:38,004 INFO Slice dataset inputs/netcdf/slice-2024-01-01.nc closed\n", + "2026-10-29 17:44:38,014 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-02.nc\n", + "2026-10-29 17:44:38,024 INFO Updating target dataset outputs/netcdf_example_time_opt.zarr\n", + "2026-10-29 17:44:41,837 INFO Transaction completed.\n", + "2026-10-29 17:44:41,838 INFO Slice dataset inputs/netcdf/slice-2024-01-02.nc closed\n", + "2026-10-29 17:44:41,848 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-03.nc\n", + "2026-10-29 17:44:41,857 INFO Updating target dataset outputs/netcdf_example_time_opt.zarr\n", + "2026-10-29 17:44:45,526 INFO Transaction completed.\n", + "2026-10-29 17:44:45,527 INFO Slice dataset inputs/netcdf/slice-2024-01-03.nc closed\n", + "2026-10-29 17:44:45,539 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-04.nc\n", + "2026-10-29 17:44:45,552 INFO Updating target dataset outputs/netcdf_example_time_opt.zarr\n", + "2026-10-29 17:44:50,192 INFO Transaction completed.\n", + "2026-10-29 17:44:50,194 INFO Slice dataset inputs/netcdf/slice-2024-01-04.nc closed\n", + "2026-10-29 17:44:50,217 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-05.nc\n", + "2026-10-29 17:44:50,230 INFO Updating target dataset outputs/netcdf_example_time_opt.zarr\n", + "2026-10-29 17:44:54,330 INFO Transaction completed.\n", + "2026-10-29 17:44:54,331 INFO Slice dataset inputs/netcdf/slice-2024-01-05.nc closed\n", + "2026-10-29 17:44:54,341 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-06.nc\n", + "2026-10-29 17:44:54,350 INFO Updating target dataset outputs/netcdf_example_time_opt.zarr\n", + "2026-10-29 17:44:57,946 INFO Transaction completed.\n", + "2026-10-29 17:44:57,948 INFO Slice dataset inputs/netcdf/slice-2024-01-06.nc closed\n", + "2026-10-29 17:44:57,962 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-07.nc\n", + "2026-10-29 17:44:57,972 INFO Updating target dataset outputs/netcdf_example_time_opt.zarr\n", + "2026-10-29 17:45:01,703 INFO Transaction completed.\n", + "2026-10-29 17:45:01,704 INFO Slice dataset inputs/netcdf/slice-2024-01-07.nc closed\n", + "2026-10-29 17:45:01,717 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-08.nc\n", + "2026-10-29 17:45:01,726 INFO Updating target dataset outputs/netcdf_example_time_opt.zarr\n", + "2026-10-29 17:45:05,629 INFO Transaction completed.\n", + "2026-10-29 17:45:05,631 INFO Slice dataset inputs/netcdf/slice-2024-01-08.nc closed\n", + "2026-10-29 17:45:05,645 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-09.nc\n", + "2026-10-29 17:45:05,655 INFO Updating target dataset outputs/netcdf_example_time_opt.zarr\n", + "2026-10-29 17:45:09,981 INFO Transaction completed.\n", + "2026-10-29 17:45:09,982 INFO Slice dataset inputs/netcdf/slice-2024-01-09.nc closed\n", + "2026-10-29 17:45:09,995 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-10.nc\n", + "2026-10-29 17:45:10,004 INFO Updating target dataset outputs/netcdf_example_time_opt.zarr\n", + "2026-10-29 17:45:14,688 INFO Transaction completed.\n", + "2026-10-29 17:45:14,689 INFO Slice dataset inputs/netcdf/slice-2024-01-10.nc closed\n", + "2026-10-29 17:45:14,707 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-11.nc\n", + "2026-10-29 17:45:14,718 INFO Updating target dataset outputs/netcdf_example_time_opt.zarr\n", + "2026-10-29 17:45:19,116 INFO Transaction completed.\n", + "2026-10-29 17:45:19,117 INFO Slice dataset inputs/netcdf/slice-2024-01-11.nc closed\n", + "2026-10-29 17:45:19,133 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-12.nc\n", + "2026-10-29 17:45:19,142 INFO Updating target dataset outputs/netcdf_example_time_opt.zarr\n", + "2026-10-29 17:45:23,521 INFO Transaction completed.\n", + "2026-10-29 17:45:23,522 INFO Slice dataset inputs/netcdf/slice-2024-01-12.nc closed\n", + "2026-10-29 17:45:23,536 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-13.nc\n", + "2026-10-29 17:45:23,546 INFO Updating target dataset outputs/netcdf_example_time_opt.zarr\n", + "2026-10-29 17:45:27,494 INFO Transaction completed.\n", + "2026-10-29 17:45:27,495 INFO Slice dataset inputs/netcdf/slice-2024-01-13.nc closed\n", + "2026-10-29 17:45:27,511 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-14.nc\n", + "2026-10-29 17:45:27,521 INFO Updating target dataset outputs/netcdf_example_time_opt.zarr\n", + "2026-10-29 17:45:32,877 INFO Transaction completed.\n", + "2026-10-29 17:45:32,878 INFO Slice dataset inputs/netcdf/slice-2024-01-14.nc closed\n", + "2026-10-29 17:45:32,895 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-15.nc\n", + "2026-10-29 17:45:32,904 INFO Updating target dataset outputs/netcdf_example_time_opt.zarr\n", + "2026-10-29 17:45:37,223 INFO Transaction completed.\n", + "2026-10-29 17:45:37,224 INFO Slice dataset inputs/netcdf/slice-2024-01-15.nc closed\n", + "2026-10-29 17:45:37,244 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-16.nc\n", + "2026-10-29 17:45:37,254 INFO Updating target dataset outputs/netcdf_example_time_opt.zarr\n", + "2026-10-29 17:45:42,079 INFO Transaction completed.\n", + "2026-10-29 17:45:42,080 INFO Slice dataset inputs/netcdf/slice-2024-01-16.nc closed\n", + "2026-10-29 17:45:42,098 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-17.nc\n", + "2026-10-29 17:45:42,108 INFO Updating target dataset outputs/netcdf_example_time_opt.zarr\n", + "2026-10-29 17:45:47,007 INFO Transaction completed.\n", + "2026-10-29 17:45:47,010 INFO Slice dataset inputs/netcdf/slice-2024-01-17.nc closed\n", + "2026-10-29 17:45:47,042 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-18.nc\n", + "2026-10-29 17:45:47,056 INFO Updating target dataset outputs/netcdf_example_time_opt.zarr\n", + "2026-10-29 17:45:52,968 INFO Transaction completed.\n", + "2026-10-29 17:45:52,969 INFO Slice dataset inputs/netcdf/slice-2024-01-18.nc closed\n", + "2026-10-29 17:45:52,987 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-19.nc\n", + "2026-10-29 17:45:52,997 INFO Updating target dataset outputs/netcdf_example_time_opt.zarr\n", + "2026-10-29 17:45:57,240 INFO Transaction completed.\n", + "2026-10-29 17:45:57,242 INFO Slice dataset inputs/netcdf/slice-2024-01-19.nc closed\n", + "2026-10-29 17:45:57,264 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-20.nc\n", + "2026-10-29 17:45:57,275 INFO Updating target dataset outputs/netcdf_example_time_opt.zarr\n", + "2026-10-29 17:46:02,308 INFO Transaction completed.\n", + "2026-10-29 17:46:02,310 INFO Slice dataset inputs/netcdf/slice-2024-01-20.nc closed\n", + "2026-10-29 17:46:02,326 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-21.nc\n", + "2026-10-29 17:46:02,334 INFO Updating target dataset outputs/netcdf_example_time_opt.zarr\n", + "2026-10-29 17:46:05,979 INFO Transaction completed.\n", + "2026-10-29 17:46:05,981 INFO Slice dataset inputs/netcdf/slice-2024-01-21.nc closed\n", + "2026-10-29 17:46:05,996 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-22.nc\n", + "2026-10-29 17:46:06,004 INFO Updating target dataset outputs/netcdf_example_time_opt.zarr\n", + "2026-10-29 17:46:09,531 INFO Transaction completed.\n", + "2026-10-29 17:46:09,532 INFO Slice dataset inputs/netcdf/slice-2024-01-22.nc closed\n", + "2026-10-29 17:46:09,550 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-23.nc\n", + "2026-10-29 17:46:09,559 INFO Updating target dataset outputs/netcdf_example_time_opt.zarr\n", + "2026-10-29 17:46:13,272 INFO Transaction completed.\n", + "2026-10-29 17:46:13,274 INFO Slice dataset inputs/netcdf/slice-2024-01-23.nc closed\n", + "2026-10-29 17:46:13,289 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-24.nc\n", + "2026-10-29 17:46:13,297 INFO Updating target dataset outputs/netcdf_example_time_opt.zarr\n", + "2026-10-29 17:46:16,757 INFO Transaction completed.\n", + "2026-10-29 17:46:16,758 INFO Slice dataset inputs/netcdf/slice-2024-01-24.nc closed\n", + "2026-10-29 17:46:16,775 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-25.nc\n", + "2026-10-29 17:46:16,783 INFO Updating target dataset outputs/netcdf_example_time_opt.zarr\n", + "2026-10-29 17:46:21,067 INFO Transaction completed.\n", + "2026-10-29 17:46:21,068 INFO Slice dataset inputs/netcdf/slice-2024-01-25.nc closed\n", + "2026-10-29 17:46:21,084 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-26.nc\n", + "2026-10-29 17:46:21,093 INFO Updating target dataset outputs/netcdf_example_time_opt.zarr\n", + "2026-10-29 17:46:24,506 INFO Transaction completed.\n", + "2026-10-29 17:46:24,507 INFO Slice dataset inputs/netcdf/slice-2024-01-26.nc closed\n", + "2026-10-29 17:46:24,524 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-27.nc\n", + "2026-10-29 17:46:24,532 INFO Updating target dataset outputs/netcdf_example_time_opt.zarr\n", + "2026-10-29 17:46:28,116 INFO Transaction completed.\n", + "2026-10-29 17:46:28,117 INFO Slice dataset inputs/netcdf/slice-2024-01-27.nc closed\n", + "2026-10-29 17:46:28,138 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-28.nc\n", + "2026-10-29 17:46:28,149 INFO Updating target dataset outputs/netcdf_example_time_opt.zarr\n", + "2026-10-29 17:46:31,925 INFO Transaction completed.\n", + "2026-10-29 17:46:31,926 INFO Slice dataset inputs/netcdf/slice-2024-01-28.nc closed\n", + "2026-10-29 17:46:31,944 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-29.nc\n", + "2026-10-29 17:46:31,952 INFO Updating target dataset outputs/netcdf_example_time_opt.zarr\n", + "2026-10-29 17:46:35,544 INFO Transaction completed.\n", + "2026-10-29 17:46:35,546 INFO Slice dataset inputs/netcdf/slice-2024-01-29.nc closed\n", + "2026-10-29 17:46:35,573 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-30.nc\n", + "2026-10-29 17:46:35,584 INFO Updating target dataset outputs/netcdf_example_time_opt.zarr\n", + "2026-10-29 17:46:40,145 INFO Transaction completed.\n", + "2026-10-29 17:46:40,147 INFO Slice dataset inputs/netcdf/slice-2024-01-30.nc closed\n", + "2026-10-29 17:46:40,165 INFO Opening slice dataset from inputs/netcdf/slice-2024-01-31.nc\n", + "2026-10-29 17:46:40,173 INFO Updating target dataset outputs/netcdf_example_time_opt.zarr\n", + "2026-10-29 17:46:43,799 INFO Transaction completed.\n", + "2026-10-29 17:46:43,800 INFO Slice dataset inputs/netcdf/slice-2024-01-31.nc closed\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 2min 32s, sys: 44.9 s, total: 3min 17s\n", + "Wall time: 2min 8s\n" + ] + } + ], + "source": [ + "%%time\n", + "full_time_chunk = len(slices)\n", + "target = output_dir / 'netcdf_example_time_opt.zarr'\n", + "count = zappend(\n", + " slices,\n", + " target_dir=str(target),\n", + " force_new=True,\n", + " variables={\n", + " 'temperature': {'encoding': {'chunks': [full_time_chunk, 90, 90]}},\n", + " 'quality_flag': {'encoding': {'chunks': [full_time_chunk, 90, 90]}},\n", + " },\n", + " logging='INFO',\n", + ")\n", + "assert count == full_time_chunk" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "4c2f42a39c44a1f1", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:46:43.841995199Z", + "start_time": "2026-10-29T16:46:43.808887272Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 21.9 ms, sys: 661 μs, total: 22.6 ms\n", + "Wall time: 18.6 ms\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 1GB\n",
+       "Dimensions:       (time: 31, lat: 1800, lon: 3600)\n",
+       "Coordinates:\n",
+       "  * time          (time) datetime64[ns] 248B 2024-01-01 ... 2024-01-31\n",
+       "  * lat           (lat) float32 7kB -89.95 -89.85 -89.75 ... 89.75 89.85 89.95\n",
+       "  * lon           (lon) float32 14kB -179.9 -179.9 -179.8 ... 179.7 179.8 179.9\n",
+       "Data variables:\n",
+       "    quality_flag  (time, lat, lon) uint8 201MB dask.array<chunksize=(31, 90, 90), meta=np.ndarray>\n",
+       "    temperature   (time, lat, lon) float32 804MB dask.array<chunksize=(31, 90, 90), meta=np.ndarray>\n",
+       "Attributes:\n",
+       "    title:    Zappend example slice
" + ], + "text/plain": [ + " Size: 1GB\n", + "Dimensions: (time: 31, lat: 1800, lon: 3600)\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 248B 2024-01-01 ... 2024-01-31\n", + " * lat (lat) float32 7kB -89.95 -89.85 -89.75 ... 89.75 89.85 89.95\n", + " * lon (lon) float32 14kB -179.9 -179.9 -179.8 ... 179.7 179.8 179.9\n", + "Data variables:\n", + " quality_flag (time, lat, lon) uint8 201MB dask.array\n", + " temperature (time, lat, lon) float32 804MB dask.array\n", + "Attributes:\n", + " title: Zappend example slice" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "ds = xr.open_zarr(target)\n", + "ds" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "6a4bd3775434594d", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:49:51.304398781Z", + "start_time": "2026-10-29T16:49:51.201554924Z" + } + }, + "outputs": [], + "source": [ + "if os.path.exists(input_dir):\n", + " shutil.rmtree(input_dir)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python (zappend)", + "language": "python", + "name": "zappend" + }, + "language_info": { + "name": "python", + "version": "3.14" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/zappend-demo.ipynb b/examples/zappend-demo.ipynb deleted file mode 100644 index 152b614..0000000 --- a/examples/zappend-demo.ipynb +++ /dev/null @@ -1,6744 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "b7504525-e666-4892-9996-e505fa62d297", - "metadata": {}, - "source": [ - "# zappend Demo\n", - "\n", - "This Notebook demonstrates the two user interfaces of the `zappend` tool, namely the CLI and API with some local NetCDF inputs." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "1296da3d-6d09-495b-99e7-d192b2e3d2c7", - "metadata": {}, - "outputs": [], - "source": [ - "import glob\n", - "import os\n", - "import os.path\n", - "import shutil\n", - "\n", - "import xarray as xr" - ] - }, - { - "cell_type": "markdown", - "id": "18b11fec-a0a8-425d-be96-bd13b94df1db", - "metadata": { - "tags": [] - }, - "source": [ - "First let's define a utility to remove directories:" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "a440d7a3-71c3-4519-9193-c340e04d4de9", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "def rmdir(path: str):\n", - " if os.path.exists(path):\n", - " shutil.rmtree(path)" - ] - }, - { - "cell_type": "markdown", - "id": "319d85ca-e244-4b2e-ab66-67dee4af7a41", - "metadata": {}, - "source": [ - "## Define the inputs\n", - "\n", - "We use Ocean Colour data produced by the [EU HIGHROC Project](https://www.highroc.eu/) as input." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "934b1455-eb8c-4c88-a48c-aa7d490e176b", - "metadata": {}, - "outputs": [], - "source": [ - "slice_pattern = \"inputs/*.nc\"" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "41d912eb-153f-41f9-930f-662f346a3b8f", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['inputs\\\\20230601_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc',\n", - " 'inputs\\\\20230603_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc',\n", - " 'inputs\\\\20230605_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc']" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "slice_paths = sorted(glob.glob(slice_pattern))[:3]\n", - "slice_paths" - ] - }, - { - "cell_type": "markdown", - "id": "6f1cccd0-262c-4fda-b853-2941f8e6cfc0", - "metadata": {}, - "source": [ - "This is how a single slice looks like:" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "befb37f4-9a28-41e1-b7ab-468584323f5a", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.Dataset>\n",
-       "Dimensions:  (time: 1, lat: 8640, lon: 3435)\n",
-       "Coordinates:\n",
-       "  * time     (time) datetime64[ns] 2023-06-01\n",
-       "  * lat      (lat) float64 64.0 64.0 64.0 64.0 64.0 ... 56.0 56.0 56.0 56.0 56.0\n",
-       "  * lon      (lon) float64 6.0 6.002 6.004 6.005 6.007 ... 11.99 12.0 12.0 12.0\n",
-       "Data variables:\n",
-       "    SPM      (time, lat, lon) float32 ...\n",
-       "    TUR      (time, lat, lon) float32 ...\n",
-       "    SPM_QI   (time, lat, lon) float32 ...\n",
-       "    TUR_QI   (time, lat, lon) float32 ...\n",
-       "    crs      int32 ...\n",
-       "Attributes: (12/46)\n",
-       "    TileSize:                   540:286\n",
-       "    id:                         20230601_P1D_CMEMS_HROC_L3_transp_BAL_32V_100...\n",
-       "    title:                      CMEMS HR-OC Baltic Sea transparency (spm, tur...\n",
-       "    region:                     BAL\n",
-       "    tile:                       32V\n",
-       "    cmems_product_id:           OCEANCOLOUR_BAL_BGC_HR_L3_NRT_009_202\n",
-       "    ...                         ...\n",
-       "    time_coverage_duration:     P1D\n",
-       "    time_coverage_resolution:   P1D\n",
-       "    platform:                   Sentinel-2\n",
-       "    sensor:                     MSI\n",
-       "    start_date:                 01-JUN-2023 00:00:00.000000\n",
-       "    stop_date:                  01-JUN-2023 00:00:00.000000
" - ], - "text/plain": [ - "\n", - "Dimensions: (time: 1, lat: 8640, lon: 3435)\n", - "Coordinates:\n", - " * time (time) datetime64[ns] 2023-06-01\n", - " * lat (lat) float64 64.0 64.0 64.0 64.0 64.0 ... 56.0 56.0 56.0 56.0 56.0\n", - " * lon (lon) float64 6.0 6.002 6.004 6.005 6.007 ... 11.99 12.0 12.0 12.0\n", - "Data variables:\n", - " SPM (time, lat, lon) float32 ...\n", - " TUR (time, lat, lon) float32 ...\n", - " SPM_QI (time, lat, lon) float32 ...\n", - " TUR_QI (time, lat, lon) float32 ...\n", - " crs int32 ...\n", - "Attributes: (12/46)\n", - " TileSize: 540:286\n", - " id: 20230601_P1D_CMEMS_HROC_L3_transp_BAL_32V_100...\n", - " title: CMEMS HR-OC Baltic Sea transparency (spm, tur...\n", - " region: BAL\n", - " tile: 32V\n", - " cmems_product_id: OCEANCOLOUR_BAL_BGC_HR_L3_NRT_009_202\n", - " ... ...\n", - " time_coverage_duration: P1D\n", - " time_coverage_resolution: P1D\n", - " platform: Sentinel-2\n", - " sensor: MSI\n", - " start_date: 01-JUN-2023 00:00:00.000000\n", - " stop_date: 01-JUN-2023 00:00:00.000000" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "slice_ds = xr.open_dataset(slice_paths[0])\n", - "slice_ds" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "337c10f5-a2a8-4258-9331-1b513a95e92d", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlwAAAHFCAYAAAAnnSemAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd5xU1fn/3+e2mdnZRhVQ6QiCiGhs2KMIRk1ioiaaRI0txhKzS7fQpJcdJWpM1FhiYvkmakzyU7GgRCUxFizYEAHRgEjbOuWW8/vj3JllYYFddpdd8Lx9zYudO7ecubvufPYpn0dIKSUajUaj0Wg0mhbDaO0FaDQajUaj0ezraMGl0Wg0Go1G08JowaXRaDQajUbTwmjBpdFoNBqNRtPCaMGl0Wg0Go1G08JowaXRaDQajUbTwmjBpdFoNBqNRtPCaMGl0Wg0Go1G08JowaXRaDQajUbTwmjBpflG8tprrzF58mS2bNmy3Wsnn3wyJ5988h5f057gk08+YfTo0RxxxBEUFxfTvn17jjvuOP7yl7/Uu//69eu55JJL6NixI3l5eRx77LG88MILdfapqKhg+vTpnHzyyXTp0oX8/HwGDx7M7NmzSaVSdfZds2YN55xzDr179yYej1NUVMTQoUO5/fbb8Tyvwe+jIevKUl1dzcSJEznooIOIRCJ06NCBU045heXLlzf4er/5zW8YMGAAkUiEXr16MWXKFFzXrbPPF198wa9//WtOOukkiouLEUJw//33N/gaGo1m30YLLs03ktdee40pU6bUK7juvPNO7rzzzj2/qD3AwoUL+ec//8kPf/hD/u///o8//elP9OvXj/POO4+pU6fW2TedTnPqqafywgsvcNttt/G3v/2N/fbbj5EjR/Lyyy/n9vv888+59dZbOfzww/n973/PU089xbnnnsvkyZM566yz2Hp6WHV1NYWFhdx888089dRTPPLIIxx//PFcd911XHXVVQ16Dw1dF0BVVRUnn3wy9957L9dddx0LFy7kvvvu4+ijj6ampqZB15s+fTrXX389P/jBD3j22We5+uqrmTFjBtdcc02d/T799FP+9Kc/4TgO3/nOdxp0bo1G8w1CajTfQObOnSsBuXLlytZeyh7l66+/lkEQbLf9zDPPlHl5eTKVSuW23XHHHRKQr732Wm6b67py4MCB8qijjsptq6qqklVVVdudM3uP//Wvf+1yXeeff760LKvO9XdEQ9clpZTXX3+9jMfjcsWKFbs8b31s2LBBRqNReeWVV9bZPn36dCmEkMuWLctt830/9/V///tfCcj77rtvt66r0Wj2PXSES/ONY/LkyYwZMwaAXr16IYRACMFLL70EbJ9SXLVqFUII5s6dy+zZs+nZsyexWIyTTz6ZTz75BNd1GT9+PN26daOoqIhzzjmH9evXb3fdRx99lGOPPZZ4PE5+fj4jRozg7bff3hNvOUfHjh0RQmy3/aijjqKmpoZNmzbltj3xxBP079+fY489NrfNsix++tOf8vrrr/Pll18CEI/Hicfj9Z4TVBpxV3Tq1AnDMDBNc5f7NnRdNTU13HPPPZx33nn07t17l+etj2eeeYZUKsXPf/7zOtt//vOfI6XkySefzG0zDP3rVKPR7Bj9G0LzjePyyy/nuuuuA+Dxxx9nyZIlLFmyhMMPP3ynx91xxx28+uqr3HHHHdxzzz189NFHnH322Vx22WV8/fXX/OEPf2DOnDk8//zzXH755XWOnTFjBhdccAEDBw7kscce449//COVlZWccMIJfPDBB7tcs+d5DXrIrdJ3jWHRokV06tSJzp0757a9//77HHroodvtm922bNmynZ7zxRdfBGDQoEHbvSalxPM8Nm/ezKOPPsr999/PqFGjsCxrl2tt6LrefPNNqqur6devH7/85S9p164djuPwrW99i3/+85+7vE72WgCDBw+us71r16507Ngx97pGo9Hsil3/dtNo9jEOOOAAunfvDsDQoUPp2bNng44rLi7mySefzEUyNmzYwK9//WsGDBjA3/72t9x+H330EbfeeisVFRUUFhayZs0aJk2axLXXXsuCBQty+w0fPpx+/foxZcoUHn300R1ed9WqVfTq1atBa1y0aFGjC/7vueceXnrpJW677bY6EaaNGzfSvn377fbPbtu4ceMOz/nuu+8yZ84czjnnnHrF0ezZs5kwYQIAQghuuOEGpk2b1qD1NnRd2UjX7NmzGTx4MA8++CCGYTB//nzOPvtsnn76aUaMGLHLa0UikXojeO3bt9/pPdBoNJqt0YJLo2kg3/nOd+qkjQ4++GAAzjzzzDr7Zbd//vnnHHLIITz77LN4nsdFF11UpxMvGo1y0kknsWjRop1et1u3bvz3v/9t0Br79+/foP2yPP3001xzzTWce+65uajf1tSXftzVa6tWreKss87iwAMP5J577ql3n0suuYTTTjuNTZs28eKLLzJ37lzKy8v5zW9+A6gImO/7dY7ZOvrVkHUFQQCA4zg8/fTTFBQUAHDKKafQr18/brnllpzg2rZD0jTN3Hl25x5oNBrNtmjBpdE0kG2jKo7j7HR71hLhq6++AuDII4+s97y7qv1xHIfDDjusQWtsSA1UlmeffZYf/OAHDB8+nD/96U/biYcOHTrUG8HJ1nnVF2VavXo1p5xyCpZl8cILL9S7D0CXLl3o0qULAKeffjrt2rVj/PjxXHrppQwdOpQHHnhgu7qpbLq0oevq0KEDAMOGDcuJLYC8vDxOOumkOvVXtm3XOdd9993HJZdcQocOHUilUtTU1JCXl7fd9Y444oh6359Go9FsixZcGk0L07FjRwD+8pe/0KNHj0Yf3xIpxWeffZbvf//7nHTSSfz1r3/NicStGTx4MO+9995227PbDjnkkDrbV69ezcknn4yUkpdeeokDDjigQWuG2gL7Tz75hKFDh3L22WfvMKrX0HXVl8rMIqWsI3S3vVb2fmdrt9577z2OPvro3Ovr1q1jw4YN290DjUaj2RFacGm+kUQiEQCSyWSLX2vEiBFYlsWKFSv44Q9/2OjjmzuluHDhQr7//e9z/PHH8+STT+buxbacc845XH311fznP//JiQ3P83jooYc4+uij6datW27fzz//nJNPPhnf93nppZcaLSyzadW+ffsCKjqVjVDt7rq6du3Ksccey6uvvpqrpwPVvfjyyy9zzDHH5M75rW99q95rjRw5kmg0yv33319HcN1///0IIfj+97/fqPep0Wi+uWjBpflGko1c3HbbbVx88cXYtk3//v3rpJ6ai549ezJ16lRuvPFGPvvsM0aOHEm7du346quveP3114nH40yZMmWHx2c765qDV155he9///t06dKFG264gaVLl9Z5feDAgTlhcumll3LHHXdw3nnnMWvWLDp37sydd97Jxx9/zPPPP587Zv369ZxyyimsXbuWe++9l/Xr19exxTjggANy0a5Jkybx1VdfceKJJ7L//vuzZcsWnnnmGe6++27OO++8BqXoGrougHnz5nHKKacwYsQIxo0bhxCC+fPns2HDBm655ZZdXqt9+/bcdNNN3HzzzbRv357TTz+d//73v0yePJnLL7+cgQMH1tk/69j/2WefAfDGG2+Qn58PwLnnnrvL62k0mn2YVvQA02halQkTJshu3bpJwzAkIBctWiSllPKkk06SJ510Um6/lStXSkDOnTu3zvGLFi2SgPy///u/Otvvu+8+Ccj//ve/dbY/+eST8pRTTpGFhYUyEonIHj16yHPPPVc+//zzLfL+6mPSpEkS2OEjew+yrFu3Tl500UWyffv2MhqNymOOOUY+99xzdfbJ3ocdPSZNmpTb96mnnpKnnXaa3G+//aRlWTI/P18eddRRcsGCBdJ13Qa/j4asK8u//vUvedJJJ8m8vDyZl5cnv/3tb8tXX321wdeSUsrbbrtNHnTQQdJxHNm9e3c5adIkmclktttvZ/dBo9F8sxFS7qZxj0aj0Wg0Go2mQWjjU41Go9FoNJoWRgsujUaj0Wg0mhZGCy6NRqPRaDSaFkYLLo1Go9FoNJoWRgsujUaj0Wg0mhZGCy6NRqPRaDSaFkYbn9ZDEAT873//o6CgQA+n1Wg0Gs1OkVJSWVlJt27ddjkbtSVZv349H//7CE747ppWW4Nmx2gfrnr44osvOPDAA1t7GRqNRqPZi1izZk2jZog2Nxf+oJBHnqzkvffeZ9CgQa22Dk39aMFVD+Xl5RQXF7NmzZrcmBONRqPRaOqjoqKCAw88kC1btlBUVNQqa3j33Xc5+ujDOOPbeQQBPPl0VausQ7NjdEqxHrJpxMLCQi24NBqNRtMgWrME5cYxw7jyp0WMu64d/Y5Zxeuvv85RRx3VauvRbI8umtdoNBqNZi9myZIlvPRqDROub0eXzha/uryYG8ac3NrL0myDFlwajUaj0eylSCm5YfSpXH9FOzp3VEmr0Ve3442laV588cVWXp1ma7Tg0mg0Go1mL+X555/nnQ/SlF5VnNvWrthkzNXtuGHMmegy7baDFlwajUaj0eyFSCm5YczZjLu2HcVFZp3XfnVFMSs/d3nqqadaaXWabdGCS6PRaDSavZAnnniCL9d5XPPz4u1ei+cZ3Pjr9tw0/nx839/zi9NshxZcGo1Go9HsZfi+z03jL+DGkvbk5dX/UX7FTwuprAp45JFH9vDqNPWhBZdGo9FoNHsZD96xP6l0wGUX7Nj3KxIxmDi6AxNv/DmZTGYPrk5TH1pwaTQajUazF5FOp5kydyOTRnfAcXbu/fXTHxbg2HBPovUc8DUKLbg0Go1Go9mL+P38A8mPG1z4g4Jd7mtZgqnjOjAtsYmampo9sDrNjtCCS6PRaDSavYTq6mqm37qJqeM6YJoNc7b/wZn5dNvP4vZZPVp4dZqdoQWXRqPRaDR7CQtm9KDHARbfGxlv8DFCCG4Z34HZt2+ivLy8BVen2RlacGk0Go1GsxewefNm5tyxmWkTOjZ6buPpJ+cxeECEeVN6t9DqNLtCCy6NRqPRaPYC5k7uw+GDI5x6Ql6jjxVCMG1CB279/WbWr1/fAqvT7AotuDQaTZuix/2zW3sJGk2bY926dSy4ZwvTJnTc7XMMOzLGScPymHFT/2ZcmaahaMGl0WjaFKsvGdfaS9Bo2hx33303JxwT4+jDo006z+TR7fntA+Ukk8lmWpmmoWjBpdFoNBpNG6eyspI+Pe0mn6dPT5tMRuK6bjOsStMYrNZegEaj0Wg0ml0jkQQETTpHU4/X7D5acGk0Go1GsxcgJfiyaYLJl7KZVqNpLDqlqNFoNK3MiMMntfYSNBpNC6MjXBqNRtPKPPvWlNZegmYvQKUUmxahaurxmt2nVSNckydPRghR59GlS5fc61VVVVx77bUccMABxGIxDj74YH7729/u9Jz333//ducUQpBKpVr67Wg0Go1G02Jka7ia+p+mdWj1CNegQYN4/vnnc89N08x9XVJSwqJFi3jooYfo2bMnCxcu5Oqrr6Zbt25873vf2+E5CwsL+fjjj+tsi0ab1kqr0Wg0Gk1rIml6DZau4Wo9Wl1wWZZVJ6q1NUuWLOHiiy/m5JNPBuDKK6/kd7/7HW+88cZOBde2kTKNRqPRaDSa1qTVi+aXL19Ot27d6NWrFz/+8Y/57LPPcq8df/zxPPXUU3z55ZdIKVm0aBGffPIJI0aM2Ok5q6qq6NGjBwcccABnnXUWb7/99k73T6fTVFRU1HloNBqNRtOWyNZwNfWhaR1aVXAdffTRPPjggzz77LPcfffdrFu3jmHDhrFx40YAFixYwMCBAznggANwHIeRI0dy5513cvzxx+/wnAMGDOD+++/nqaee4uGHHyYajXLcccexfPnyHR4zc+ZMioqKco8DDzyw2d+rRqPRaDRNQQI+skkPLbhaDyFl20noVldX06dPH8aOHUtpaSnz5s3j7rvvZt68efTo0YPFixczYcIEnnjiCU477bQGnTMIAg4//HBOPPFEFixYUO8+6XSadDqde15RUcGBBx5IeXk5hYWFzfLeNBqNRrNvUlFRQVFRUYt+ZowdO5bNG+5k1rTiJp2noiKg98Fr9edbK9DqNVxbE4/HGTx4MMuXLyeZTHLDDTfwxBNPcOaZZwJw6KGHsnTpUubNm9dgwWUYBkceeeROI1yRSIRIJNIs70Gj0Wg0mpZA0nRbBx3haj1avYZra9LpNB9++CFdu3bFdV1c18Uw6i7RNE2CoOFtrVJKli5dSteuXZt7uRqNRqPR7DGklPjN8NC0Dq0a4Ro9ejRnn3023bt3Z/369UybNo2KigouvvhiCgsLOemkkxgzZgyxWIwePXrw8ssv8+CDD1JWVpY7x0UXXcT+++/PzJkzAZgyZQrHHHMM/fr1o6KiggULFrB06VLuuOOO1nqbGo1Go9E0GRXhahrahav1aNUI1xdffMEFF1xA//79+cEPfoDjOPz73/+mR48eADzyyCMceeSR/OQnP2HgwIHMmjWL6dOnc9VVV+XO8fnnn7N27drc8y1btnDllVdy8MEHc/rpp/Pll1+yePFijjrqqD3+/jQaTf0cfGNiu6+H/lL9ITVobKLeY3ZGz9/Oa56FaTQaTQvRporm2wp7ogBSo9HUzyFjErw/tyT3vO/sMj4dV1rvvv2mlyEtdvi6RrMn2FNF819/fQdTpzXt/BUVAYcMXK8/31qBNlU0r9Fovrn0m1nG8gmldcRWv+llfHqjElODRyV4b34J/ackcMpBBLD8VvVaj9/Pxaw0+WxUKT3vmMeqa0a3ynvYmiHXJbCSkjfvqSsGjzt3HsKXvPLEmFZamWZvJQD8JoZImnq8ZvfRgkuj0bQqB9+UAAl5laLu9hsTLJ9eK1bem1/CIWMSeJ0lH0/aJqIVgB0e3xbEFsA7vympd/urfxnNURfN5+ifzsd3BG/8QUfnNA2jOWq4tN5qPdpUl6JGo/nm8eG0Ej6cXkIQ/vl30C2qhuvD6SUM+VWCgRMSDC5V296fW8KKMUqgDBpfW+sV+dri48n1C5y2yOsPjsK3BWZGcsJ353L8OXNbe0kajaaF0REujUbTJnivTAkmpwIGTEzw0dQS3llQV0QNGptg2ZwSBo9KsGx+7Wuf3Lz3iK0sb9xXN7J18sjZvPTMuFZajWZvQDnNi13utzOaerxm99ERLo1G06Z4f24JH02tK6AGlyQYeEOC7GeFm1/7Wv+pKgq2t+M7+texZudIIJBNfzSWxYsXc/bZZ9OtWzeEEDz55JMNPvbVV1/FsiwOO+ywxl94H0P/H67RaNokW1tHvJco4YMZJSybrYTYR1NqBVlgSj6YufdFuI47dx7Dzp+X+/pfT+kiek3bpLq6miFDhnD77bc36rjy8nIuuugiTj311BZa2d6FTilqNJo2yYfTGyailt+4dxad+47g338eBahCeo1mV0hEq6QUzzjjDM4444xGH/eLX/yCCy+8ENM0GxUV21fRES6NRrPX0OvW+XUiX3szWbGl0TSUbA1XUx+gvMO2fqTT6WZd63333ceKFSuYNGlSs553b0YLLo1Gs9ew8tejGhz5aoscc8H81l6CZi9GSgikaPID4MADD6SoqCj3yI7Haw6WL1/O+PHj+dOf/oRl6URaFi24NBqNpgX51s9rZ7/+++GGRbWO/4G2idC0LGvWrKG8vDz3mDBhQrOc1/d9LrzwQqZMmcJBBx3ULOfcV9DSU6PRaFoQaTb+mOj65k3vaPYNmrOGq7CwsEVG+1RWVvLGG2/w9ttvc+211wIQBAFSSizLYuHChXz7299u9uvuDWjBpdFoNC3ItqN9GsLzr9zUbNcfcfgknn1rSrOdT9N6BAj8JiammupUvysKCwt577336my78847efHFF/nLX/5Cr169WngFbRctuDQajWYfRoutfQflw9W0CNfuHF9VVcWnn36ae75y5UqWLl1K+/bt6d69OxMmTODLL7/kwQcfxDAMDjnkkDrHd+7cmWg0ut32bxq6hkuj0Wj2QoYfM7W1l6D5hvDGG28wdOhQhg4dCkBpaSlDhw5l4sSJAKxdu5bPP/+8NZe4VyCklHqW5TZUVFRQVFREeXl5i+S4NRqNpiEc98N5vPpX5dH17VNn4sVMFv9jLKcfFUathMAtcFj0/PhWXKVmT3xmjB07ls/W/47SKR2adJ6qioARh67Wn2+tgE4pajQaTRslK7aO/dE8lrygushOO34aRCwCx0B4sl6xNeLwSfh5NkbaY+F/J+/JJTMi72c8W/PHPXrNpjCy6zWQcZGeB8Cz5X9o5RXtGCnBl01LTPk6xtJqaMGl0Wg0bZy8dRlOGT4LAMMQeHELq9oDITj1pBm88PINuX1PPWUGphCYVWmeXXrLHlvjiPyLebbqgRYRWyPyL1ZfmCbCNHhm0z1NPufI9pcjfVVCLoRo00JLs2+gBZdGo9G0IY47dx5eRPCfP43iuHPnYVf5EDGQloHwAqRtYFV7GF6A8CV4dfvOjLRPkGdjpGD4sFt47rWbc68NP2Yqz/17YousW7pei5wX4NmqB3Jfn3Hg9YwouhQAIz/O01/+ZqfHZvcFwPdz52oO0bankQiCJncp6ghXa6EFl0aj0exBDv9FGWYKvDxAguHCm/eWMvSqMgwPKDaQJhz90/kQERgZg8AWSAPsavAtMCWIapcgZiEjJqeeNAMRSKQhwDIQvsT8aguyKJ/TTpjO8/+6kdOOm4bhNr8pwOmxn6ovjKZ1zzWUp9fclot4BRWVue0ju14DngeGCTIAz+OZTffsU5Gr1pqlqGketODSaDSaPYjvCMhGGYR6HHFZGV6RwK6SSENt821BtNwncASBJbBqAvyowHAlQkoynWLqFJ7EcAO8mInhS4x0gOH6eN3a56JZpx85mef/O5nTjpvG6UdPBSlZ+HrTZtyNLL4MgIXJh5p0noaQFXULkw8psRUEYCpH2ZHtL0fEYjyz9o7adRkCxL7XhC9peg1XoGu4Wo197ydSo9FoWolB49Vg7W0HbA+5LsHhvyjj0F8nCCxIFwu8PPVItxP4ETDTksBSzvTCAxGAFzFAgpkOkBaYKUnl/ha+raJYANKAIEwzSiFAglsUIYjV/j2dLZw3vEBVXovdj3KMLL6Mke0vV9f2/d0+z4443bmA0yM/qbMtK+pG5P2sNr3o+yAl0vWQmQwjO1+lthsCEY/zzMbfN/vaNJqmoG0h6kHbQmg0ml0x5LoE7/xGDdIePCqBmweGr1KEbn64kwQzDVaNemq4oUiyBMKTSFPgR8P9MipaFTiCyBYJMhRfAdg1AVYyQAqBmfIx0wEvvHwD3/72TIy0T6bYYfE/x3LyyNkEpsBK+ggp8SMmUsDLT4/Lrfu046ZhpDwWvjmZ4cdMRUgQGY9n3965r9cZ+18HhoFMpcD3kRm3Tm1VczDc+jHPeY806pgRRZdulzbM1m3tqXTinrKF+Pire7h6cpcmnae6wueHh32iP99aAR3h0mg0mt3gnd+UMLgkweDSBH4EPrpFiS/hKdGFACsFQioB5kfBjwj8mBJbfiyMMoV1XF4UAltgpiSZfIHpSsyMJFLhI4V6LXAEXtzELbT49qkz8aMm6Y4RpCU48cw5vPTMOBb/cyxmjUtgGrz0zDjsSldZSQDf/vZMhK8K708/cjLCDRCuv0uxBSAzGWR1NbieSueZuzEkchcIQ2wX3doV24mtgktUypGtuhv3EbKjfZr60LQOuoZLo9FoGskhYxJkCiFiQGCBXQWDxiYQBqQ7SJCCyCZItwcrqSJfgQ1GBpDgR5XYCmwVAZNm+G9Yv2V4EjcmsJOSmg4mTrXEMwROlY8fMTCqfQLbACkxk4GKUgVSFc/7AW67CGY64NSTZoAhMFMew4+Zyov/nsjwYbcgvICFYU2X4e28kH7kflermqhAKpFlCZ5Zf1ez3s8ReT/L+WAtTP+p0cefHvupsnao+SPPVt6vzll0KQiRs6vYF5BSNN2HS3cpthpacGk0Gs1uYNWAUy5x8wVeTIkpaYKREZgZCBwlxPyoinpJU20D8CMQWy/xI+pYEWoep0LiVEq8mMBMSwxXEqlQqUcEeFEDKxngxU0MT71u+BLhBmAKrM1JZMzGTAcYGR9pG0hh4MdtzGqX4cNuIbBNjEBy+lFTeH4HhfMjDrsZkXIRGRcRcVQKUQY883XLWClkvbuy9VuNFV3CssD365quui4YSpyMyPsZGMY+I7w0eydacGk0Gk0DOOzqMvyYCNN7KnKVai8QARieimKlilWkCgleDJyKsPg9BmZKPdwCdawXrxVbEnVculggwjr0wFJRMGmo8/uOQPiSTKGJlVQKLTAFBAJDGiCgpmchZibAcAP8qKWsIkwBAUhD4EctjLSPtAxVYE8ornxJELMRKa+20EQIVZSeSuUiWiOLL+OZLfc22z093bmAhZmH626UjbeukBm3jkirk0oUokXSn62BBO3DtRejBZdGo9HUQ7YofnCJ6jg0ASRYKYmHILBUxMqqUf9mCpWQEtn0oQfp9hK7SuRqugJHCazADtOHYf2W8FWXYl65xIuI3PGGD76p0oV2jYpm4YbF9oZASImZATffygkt4atieeEFGJmAwDJzXYlG2ieImrwYjgk6/agpYJuqOD/jIYIA3ADhekjb4umVZY2+bw0pfD/duQAZSETo3XW6c0Hute0EWAPYWmxlLSSEZYWzcHwwzVyqcW9GIvBlE324mni8ZvfRgkuj0Wi2YdDYBIaj7B0slPiRZhiR8kWu1spMKeHkO+pfMwlePLR1EBA4gnSxVClDCWZa4MUl0Q0CP5tedMh1JbpxgZEBu0bi2wJfZgWawPAgECpSZVf5SFN5cklTCa9cRExSK7yiJk55hoX/mci3vz0TAKsyw/Bht0AgkRELI+Wqwvl3b+H0IyYjgoBnPpxZ731pSHQrK7aGWz+u8zxLVmxtvT0rsrYWXrvLtr5gI/J+ptKN+RcjLKtZI3QaTWPQgkuj0XyjGFyS4L2E6igcND6BmYR3byvhsGvKlODxIYiqDkPDVFEmEShB5MfASql6KuGruiyEqtXKRrbMFLhxJZSMDFjVAmmCFOAWqHROpkhiJlWtl5lU6zJc1dEYOGCE24Svzi+F8uIKbBFGsFRaSQQSKVQa0s03lJeXUGLPqXbxixzS7SOcctosFr2oolrf+nkZb9xXCqgh19IUPPuumrm48M3JzXKPs2JLhKm8rVOHuxPBagrZmq4RBZcgM5m9brj21siwS7Ep6JRi66H7QzUazTeKIKK6DIf8KqEiUT4MuDmBGxdIS3UdOuHEmEi5xMtT9VOBI7CqhfLbclFGpGkVzfJiqjhemqpGy0yHwimDSiXaSkyZGYFVJTDSKm0IqOiULRCyNs3oO4JIZaDqu0RYBxY1MFPKKkIaYGYCvKhB4KiIm7PFw0wHEITCLWJipXz8mIFbWFvDlBVbtTekAfdsXb/du9kyYLh5foNFVkuKsWcr70dKydbWkyMPntBi12sJJIJAGk186JRia6EjXBqNZp9n6FVleLGwwN2sLWIXvopaRTaH0apQKPkRJX4yBaLW1iH8bWnXqHorw1Ou7tnfoirKVBvpEp76FwF+VGKmVbowK6AMT81TNDJKfHkxdT67JusgL0i1U/Vfdo3EqfTx8lQUy0opYWVX+aqIPrSJsFI+gWUSWAKzRqUUzWSgLCRCBo1NsGxOCSePnI1jipwL/Y4I1vXD6LJ8p/ucHvsp0vUQhkAGoaCRAQszjzX+m9WCLEw+xIi8n3F67KcsTD60w9RpW0VCkyNc2oer9dCCS6PR7PO8fZeK6gyYmMCPSJxKJW7S7SGyqTYyZWSUuJKGKoDPjtrJ5IFVHY7RMcEvVOlAArBqpBoq7Qjy1kkyxWEEwQdkVoCpWi67UmB6Yb1XWrnLI9RzaSqB5ofCK1MosJKqWN5OBgSOwPBUajOTb2KlAqRpYCXDGjEBXp6JkQ4w3YAgoqJaLz89jhPPmsMpw2chfEknS3DqSTOwXX+XYgvYqdgakX8xYv8uLEw+pGqzfJ/n/LYlsuqjzqigvTS9qNn70FJXo9F8Y/hoagnLbyzFrpR4cbCrCYWKet0IRZLhhgdIJboCS6UinUrVlWim1VzDwFZjelSKT+LlCTXGJ6zfMjIq9Wi4EP+fipZlo2cVB7tYNRLhQ3SDxExJnC0Sq1qqYnwT0kWC6q4GNZ1MajqaZOKG8ujKSKQh8KJCibn2lkotCgGGQBqCwDaQlsFJZ8xm8T/GIk3Biy9OUEX2geS5125u8v0MUmmClZ8z3PoxCzMP7xViC1REbkTez3Jf7y0EUnUpNvWhaR204NJoNN84lt5RyrLZJTnPK8NThe9eVIkk31FfC1n7WjbChVBiyMtTdVfCV0almUJlFeE7teN8AltFxKykKqT3wkiZVQMd/mupDkQHMkWqEN/w1fXMtMQplzgVyvYhUyBw42rYdaq9QVU3E99RH5yv/nU0hivxouFA60DZQhiZusVZZtrn1FNmqEHYW33mNrQ+a9uRO8OtHytbB2E0ev5ha/JszR9VMb9t82zNH7framzLSAQBRpMfmtZBpxQ1Gs03lvfnljBofEKJrKiKYMlsZ6KvRJJTSShoBBhqu/AAIyvOBFaNxI8K5bPlKcd431FF+FbYcWglyRXKB3YYNbMFRhrsaokbFwhLKgsKQ9V5+VHlOB+YqnsyW+dlZsL9Azj2x/ORMUNFvUwBLsqw1Mh2McKpJ07Hj5pYNR5ChGN6QowuyxlcmuC9spLctjN6lIDr8vT/bgfUeJ9t3d/3JpG1LXur47zy4WpiDVcTj9fsPvrOazSabzRmKixid1U0Kmv5YKYkTjlq0HRE+WBlbRoACJTwETI8JggtHqRyjLeyRfkRJebc0J/Lj6hrWikltAInNEr1ldjyI7VpTDOthFvWGkKGgs+Lqoia70C6UIkyEahHduxPYBtIocRi4JhYSb/WANX1Of3Iybl70OXfVYw4fBJn9B6lNngeMpUClKXDM1/duYe+GxrNvouOcGk0mm802QHSvgNmmM4TgUoZWkkVIbJqVMTIN9Von2xhfbbzMbDVdmmFRqgxJb6kEZ4/Uxs5i32tBFxgKpFmV8qchUS6WHUlikDtI8N9rKQMuyAFQSQUfpJQCEpqOhvKMDWpuhkDSxDZmMItjmCmfRXRMgTC9TEyPoFj8ty/J3FGr1LIuJj5ebjdirCTGc7oVYpMJnP3Z0/7Zml2jBrt07QarKYer9l9tODSaDTfaLIF8kroKPGUjVipLkWVxsum5wQgXIm0Q0NTUx1r+KpoPiuuzLQa92NXKeFlhwLMjwqcCkmqvdgqlSlzwsrLExiuSkeaSakMWD018ieyOYyIhetS9WIqwhUtD+crWgLTB6/AwcgE+BETM+3z/L9urPO+Tz9iMgu3Gd0zsus1PL32jj1x2zW7gZRNTykGOqXYaug7r9FovtG8e2sJhivBCGcd+jLXSeg7Ai9raBpXRfJGRqoaL6lSgoabdZEXdYrRvdBt3o0TenGpY60aSaZAYKZUCjBrnhrYSriZKYnhSuxKVZPlxgXpIvWrWpoqHelUhF2NFRIjo7olfSc7WFuEo4CC3LifrWu2AEYcenO9rvLPaLGl0bQYOsKl0Wi+8ciwAD6wVNrOSgGBGvHjVKiCeKdS1VO5BUKJJF95ZZlJMH21D2HNlIiq6BWoc2YHVPsRAUIiwnotMwO+owScHwXpqw7GTKEa12NXSeykJF0g8KOCyJYgnOsITpXEzVPbhSdxYwIzTFsarsTNtzBciZH2ef7Vm+q83+woH83eRXOM9tHGp62HvvMajeYbz9I7SlV0S8KyOSVkCuCd20uwq5TlQ9YvK7YhYNnsEqxkOFvRUYapb/+2VM1WDH+jGmkVsbJqlKeWkVFRKzOtImJ1DE8NZUFh1YDphqOFKlTEzYuponinSmIl1YDqXDG9LXAqA6KbVCpRmqGgQ7nUI+GlZ8bxwss3tNJd1TQ3EuXF1dSHpnXQgkuj0WhQ9VJ2leSoi+bjVMCQ6xK8fVcpdo3krd+X8tbvS6npYjDk2gS+rYrVlQEqHHZ1GU6FEmW+I5SRqlSF935MjQPyYqEYMkOvLq92xI/hhSOFHCXGcqnLMNXo5qkuSacqyHVJRipUcbw0VLTLzICVUmN/DFey+B9jW+9malqEbISrqQ9N66DvvEaj0QBL7yzFiwm8WG0xPMBbvyvl0OsTALw3v4QgogxM3XzB+/PU86V3lpLqqI7zo6FjvVCRLjMJyU6q+zASmpkarhJYWVGmRJhQjwhk8kXOZDWwalOVfkStz4sK3LihCvyl2seuDrCSEqvK519Pjan3PR7/g7l75F5qNJrt0YJLo9FoQgxPEphK3BgZyZBfKaElTThkTILDryjDrpS5rsIh1yaQAgbekFCGqIHaVxqwbFZJbRdjRnU5JjsaOUNUZFhQD7UmpWFaUFrKfd6Nq1ouKQitJASxjUHOZd5wJYjQDywAISVBpPbX+iGj1fpPOmM2J541h1ceV0Js+DBdw7U3IqUgkEYTHzql2FpowaXRaDQhIpyGs/SOUpbeWYqbD4der8SUmQ7H8BQq01FQfltZV/jIZokfBbsSPphRwoBJiVw0SxmRipyjfGALAkuQKRIIX+Lmi1ohFo4OspLqXyFVulCdQ0XCzDDdaLqyNi3pSuxKHykEpx0/DYD355Uw7Px5vPz0OBb/YyynHzEZoFnmKGr2PBLwEU1+aFoHLbg0Go0mxLfV4OfBoxIMHpXArgqjXa7M2URkTUeFr+qrPpxeotzl26nB1V4cjry4DDOtit7VQ+TMS+3QRDWIhIaohggFncSLqhmMVo3Ei4EV2k74UeUun42eZT8zpVB1WyKQCCnxYiaGG/D8K7Vdia89Njr39cI3J9dxmNfsXUiaI8KlP/ZbC20LodFoNMDQX5YhBEQqVOrPrpRkigR+vsCuIDfDEJRQWnpHKQAH35jgw9m1cwgP/XWCZKewtsoRRMplbmRQuljkZjASWmMFjhJYgSmIblLXTLcT2JXgxwSeUIaoRiY7fkhgJwN8W2C6YaejgMV/H8tJZ8zm5afHbffeTj1xem70D7aZ2376UVNY+PqklrqlGo1mK7TU1Wg0GpQIcgsE6UKhzEQdZWz6wYwSMJQbvDQES+8sRQqRq4+KbJYMHpXgkNGJXHF9ZHOY8kuFcxh9yBSI0CNLmasKX40CMtJhmjAtER7YFWE0LaIiXJEtMiymF/hRtT1bhhNYKjomJJzw3bkEjsGpJ83Y7r29sPhGpGnw3Gs310knarG1dxE0QzpRj/ZpPXSES6PRaCA3z9CLK8d2Mw3v3qYiV+8sKKm7s6HE0tBflqmvDXh/bgmHjE4gpBJuTnk4CshTgslMQaQ8INnZwEB1I5pJVSyPIcKxQBK3QGBXhV5bUYFPWHifVCExp1Li5hkEtkpPZgoM/nt/aW5pJ4+cXe/7e+HlGzjltFksen48AMOPmUoQsUBKjIzPc/+e2Pw3VdPsNDUlqFOKrYe+8xqNRoOqwQJlPApKUAEMnJDgkDEJBo1X0avBpQneWVCC8FSK0C1Qlg9Df1mGmVERKt8Jo1CGmnloV8vceCAzVTsQG1Q3oh9RtViZQuVinx2MLU013FoaKjJmpVSkLHDUcy8q6ogtUGanWU747tycFcRJZ8xm0fPj+fa3Z3La8dOQloHwA8xql+f+PZFThs9qwbur0Wi04NJoNBpUREta8MHMEpbNKeG9+Sqq9cHMkpzNAwASBkxMqBE7Yf3Uu7eW4MZFbq6hXS3xY9lImepMNNNKOEU3S6yUcqpHqK5Gq0aqEUBe1p1epRyFp6JlhClGNzRUfet3pWQKBW/eU7rD9wNgZgKsmoATz5oDQgnKF1+cgB+z8PIsvHw7N1Nx0XPjOf3oqQw/ZmoL3WFNUwnC4dVNfWhaB51S1Gg0GpSgsSth0NgEy+bUTSEu26ooPnDgo6m1zw8Zk6DfjDLyq5RXlhGmELODrRHK0iFTIBABJDuKnH9WENpAmClU+jACRkYV3Lv55GY65sTeVmTTnVmO/dE8pClywg0JotjCzARKCFqCk0fOxncMiJkYnsQuz3DaCdORlgBfImwD4QXNeFc1zYlshhqsb1oN18MPP8x3v/td4vF4ay9FCy6NRqMB5Z015FdKbA0al6gjsrIMuDmBuc024UF0gyBTFM5DTIXpxDCC5TvhcGxX4sUFsa9V16IfCUf4pFVhfWCDXaWE1gczt7/2thxxWRnSADupBJ6IGtjJAFDCLivqhA9enhGux0D44fZAIh2DFxapWYu6Y7HtI6HJEapvWoTrF7/4BUcffTS9e/du7aXolKJGo9FkyRbHG279r390S0nOHBVg0LiE6jpUOgfhK1FlJVWXo3J/B7tapSwjmyS+XTtXUXjqdWmpKJoUSmwNuS6x03UOLk3kXO2zfmCGH3Yz2moskJASLyJIFZs58RdYAj9iIA31r5tnceJZczhl+Cy8fKcZ7qBG07aQUrb2EnJowaXRaDQh/aaXMbg0QWDXjsXJMuBm9dyL1W5LdZC5MT0EhB2GqkDeTIXDqNOqMF65xqsZjNJSxfSGL1V3YlKlJv3w3O/8pm6Ea/Aode1B4xMMLkkgDUh1UMX6mXzVAenGhDJBlVLNWoypX++Gr9KJrz02WrnZG2AmfYQvCSICIxOw6LnxBI7BKafpwvm2jBrt0/RHY1m8eDFnn3023bp1QwjBk08+udP9H3/8cYYPH06nTp0oLCzk2GOP5dlnn93Nd73voAWXRqPRhCy/sZT3ykpYNruE9+eVcMgYJXT6zSjLRbY+mlrCQbckOPimBNGNAi8GqU4qTae6C9V+fkR1JWbTiYGltoFKORquGvdDAO/crroel81S6UyoK/gCWwkyAmUFYXgqspVuJ7DSqrtRSEgXGrnonOHXXsvMSI798XwgnPdoGfgRA6smwMs3OfGsObz0zDj8qMGJZ87hpDNm8+1TZ7bszdY0GonAx2jSI9iNj/3q6mqGDBnC7bff3qD9Fy9ezPDhw/l//+//8eabb3LKKadw9tln8/bbbzf62k3l6aefZv/99889r6mp2eNryKJruDQajWYbhvwqkUsvHnxjguXTSzloWlnu9U9uLqH/ZDW4Ws1RVB2JqmZLKG8tlDhSQkvw7q0lHHZ1GU6lJNVBkLGFKm4PCRzoPzWBEf5Wfn9eCQdNK0N4ApkvEZ7AriY30DpwlBDzYsq/K2tnYdcQFu6DF1HXSBUr01UrpYRhpsDASkq8mIHwYPE/xgJgplW0S9M2kdDk4dO7c/wZZ5zBGWec0eD9b7311jrPZ8yYwd/+9jf+/ve/M3To0EZfvykcf/zxAKRSKe644w7mzp3LunXr9ugasugIl0aj0WxD9f5KML0/t4QgLG2SAvrMUaLr4JsSSBOCiBIwyU5SdRi6Km3oRQV+VODFVNfgu7eWcOivE0rsFAqWzVbWE4EF75WVMLhEFekbaRWZGlyinOvNlEpFghpmnZ3haHgSwwenAlLtVRQtcARuviBdoAZhGx5YaWVTIY1af7FUsYGQkClUUa6s39hJZ8zWYusbREVFRZ1HOp1usWsFQUBlZSXt27ff5b5SSlavXk0ymWz0dTKZDDfeeCNHHnkkw4YNy6U+77vvPnr37k1ZWRnXX399o8/bXLSq4Jo8eTJCiDqPLl265F6vqqri2muv5YADDiAWi3HwwQfz29/+dpfn/etf/8rAgQOJRCIMHDiQJ554oiXfhkaj2cf4dFytv9XHk1Ska/mNpawYq7ZnCiXSUCJLmmBmVJdhulilDd9LlPBeWQnv3lrC0jtLGXJtAi8GUgjcuPLxOvimBIGjImh+VNVpZX29vHiYfpSqc9GuVFYRfjR8zRFKnHnKeiLVPizCD4v3A0vt48bVdsNX3mBeRIkzaaji+iWPjOKVx8cA1DuDUdO2ULYQRhMf6mfiwAMPpKioKPeYObPlUsjz58+nurqa888/f9fvUUr69evHF1980ejrTJ48mdtvv50ePXqwcuVKzjvvPH7xi18wa9YsZs6cyapVq5gwYcLuvIVmodVTioMGDeL555/PPTfN2qbrkpISFi1axEMPPUTPnj1ZuHAhV199Nd26deN73/tevedbsmQJP/rRj7jllls455xzeOKJJzj//PN55ZVXOProo1v8/Wg0mn2b3o9Mx/RiuO0CREYgjTCdaEnsKoFVo8STkYFMoepQfPf2EgZOSOAWqMHXCAhMcCrVOb0YICFSrrYbnhJv0lL7e7Gwc1IqQSZNMGtqzVMR4OWprkcvplKOmXyVQgwsFRXLFIhcV6MXEbxxXynDzp/Ha4+NbqU7qWksUoLfxJRi9vg1a9ZQWFiY2x6JRJp03h3x8MMPM3nyZP72t7/RuXPnXe5vGAb9+vVj48aN9OvXr1HXeuyxx7j//vs555xzeOeddxg6dCgVFRUsW7YMy2p1udP6KUXLsujSpUvu0alTp9xrS5Ys4eKLL+bkk0+mZ8+eXHnllQwZMoQ33nhjh+e79dZbGT58OBMmTGDAgAFMmDCBU089dbucskaj0ewOYk0MtzCAQJmUZtoF+DGlhNLtJcn9JO/NL8EtUMalXp4qeLerwamQLJtdgu8oz65MgRJYyFB0hREqLw6mW9vp6EclXp4SXYanXk91UGnL7LbAzAo0iZmROXf6t+8Ko3US3v5tKW/9vpT/PqC2abH1zaWwsLDOoyUE16OPPspll13GY489xmmnndbg4+bMmcOYMWN4//33G3W9NWvWcOSRRwIwZMgQHMdh3LhxbUJsQRsQXMuXL6dbt2706tWLH//4x3z22We5144//nieeuopvvzyS6SULFq0iE8++YQRI0bs8HxLlizh9NNPr7NtxIgRvPbaazs8Jp1Ob5fP1mg0mm3p+dt5eO08ZJ6P8AWBI4lsUIXnIgCrSiACQf/JCQJL1U65+ZL355bwzoIS1ZWIqseSZugkD6ERqdqWi3ZtUnVkIgCrWtVkeXlqX6taCazAUoXzSPhwegnLZpXg5gve+n0p7ywoQRqCw64uw/Alb9298zFAmraPpHVsIXaHhx9+mEsuuYQ///nPnHnmmY069qc//Smvv/46Q4YMIRaL0b59+zqPHeG6Lo5T6ydn2zZFRUW7/R6am1aVfUcffTQPPvggBx10EF999RXTpk1j2LBhLFu2jA4dOrBgwQKuuOIKDjjgACzLwjAM7rnnnlzXQX2sW7eO/fbbr862/fbbb6ddCTNnzmTKlCnN9r40Gs2+R99HpyFFJGwVEyBg5fWjAOgztwyEsowYMDFRZ/TPwTcp7yy3EMwIytQ0rP3CB0OqyFWmMBRXYVTLy1OpQTMNfkxd0vRC5/o8+HiiusbAGxKYaTj0+gTv3lbC+3OVnYUIwPIkRgb+89CoVrhjmuZGCa6mxUl25/iqqio+/fTT3POVK1eydOlS2rdvT/fu3ZkwYQJffvklDz74IKDE1kUXXcRtt93GMccck/v8jcViDRJATclITZw4kby8PEAV0U+bNm27a5aVldV3aIvTqoJr6zbTwYMHc+yxx9KnTx8eeOABSktLWbBgAf/+97956qmn6NGjB4sXL+bqq6+ma9euOw1PClFXwUspt9u2NRMmTKC0tPavv4qKCg488MAmvDONRrOv8emPbgKg54OzWHXReHrdOp8e98xh9eVjWTGm9veH3Gb2z4fTShgwKYFdQZ35iaBSfmZGbXMqUDMUC8hFs6QAL19tt2rUfh9NLaH/FOXRNWBiAkzAAWHDob9O8O6tSnQBHHZ1GW/eq9Z29E/m858/1S+8Dr+iTEfA9gIk4DdxFuLuHP/GG29wyimn5J5nPy8vvvhi7r//ftauXcvnn3+ee/13v/sdnudxzTXXcM011+S2Z/ffFRdffHGj1whw4okn8vHHH+eeDxs2rE7WDLbXB3sSIduS7z0wfPhw+vbtS1lZGUVFRTzxxBN1wpGXX345X3zxBc8880y9x3fv3p2SkhJKSmr/wkwkEtx6662sXr26QWuoqKigqKiI8vLyOkWFGo1GA9Dzjnk4m43cPETho2q6fIGRASNDbgD2oHGqC9FwVfrPTEKmWOKUq45Bu1IZn4ISTMnOErtS1Wa5BWH60FaRLgC3EAJbYlWF8xeryQksTeuwJz4zxo4dy9Of/40Txh7ZpPOkKzP84eT/a/OfbytWrOC+++5jxYoV3HbbbXTu3JlnnnmGAw88kEGDBrX28naLVq/h2pp0Os2HH35I165dcV0X13UxjLpLNE2TINjxNPtjjz2W5557rs62hQsXMmzYsBZZs0aj+eax6prRyubBVIOoVWehQLiqbsuPKLuHg29UY4JENhUY1mplH2aaOr+F3721BGeL4IOZJUS2SJwtqhBeBGDVSLwYxL6SLJ+gIgyGV+uvpdn3aZbRPk2MkO0JXn75ZQYPHsx//vMfHn/8caqqqgB49913mTRp7x2w3qr/q44ePZqzzz6b7t27s379eqZNm0ZFRQUXX3wxhYWFnHTSSYwZM4ZYLEaPHj14+eWXefDBB+vkXy+66CL233//nIfI9ddfz4knnsjs2bP53ve+x9/+9jeef/55XnnlldZ6mxqNZh/ks1FK9PS8fR7OFgMRgB+TGJ7yyDIzSmBtHZ3KftaZSRXden9uCYPGK2H24XQVpcpGxiIVAWZGIIXgvw+UMuRXCT66pTaSld1/dxhybSIXVduabB2Ypm2inOabFieRTTx+TzB+/HimTZtGaWkpBQUFue2nnHIKt9122w6P27o0aGd8I2u4vvjiCy644AI2bNhAp06dOOaYY/j3v/9Njx49AHjkkUeYMGECP/nJT9i0aRM9evRg+vTpXHXVVblzfP7553WiYMOGDeORRx7hpptu4uabb6ZPnz48+uij2oNLo9G0CKuurbVWGHhDAj+ixNCgscpZ3o+G3luoVGO2IzE71mfZrBKG/Cqx3Xm3tWzIjhraliHXJbYbdr0jskJrW7E1aJxyutdiq63T9AjV3hDheu+99/jzn/+83fZOnTqxcePGHR637azGV155hSOOOIJYrHbifGvWcLWq4HrkkUd2+nqXLl247777drrPSy+9tN22c889l3PPPbcpS9NoNJpG88EMJVgOGZ1g2by64uXgGxN16rrem1/C4FEJfAc+2IGYqo9jfzQP3xG8/kdVAN9QsQXUG9UC6sx01Gham+LiYtauXUuvXr3qbH/77bfrDKLelkWLFtV5XlBQwJ///Gd69+7dIutsLA0SXIcffnijTiqE4KmnntrpjdFoNJp9lffn1Q6+zkW3tupeXDZbvf7e/MZHlJY82vxmpbuzDs2eJ2hGp/m2zIUXXsi4ceP4v//7P4QQBEHAq6++yujRo7noootae3m7TYME19KlSxk1ahT5+fm73FdKyaxZs1p0EKZGo9HsDWTrrAaNTRCYysbBcOGDmVrgaBpPa/lw7WmmT5/OJZdcwv7774+UkoEDB+L7PhdeeCE33XRTi1yzIYO1t0YIwVtvvZUrgWoIDU4pjhkzpkFzkEANqtRoNHs3PR+ayaqfqkGvPR6YhaiwMTKCIBLUqVvqXTYfEQhWjFYFq33mlOWGPGsU2VQiKNE1cEJCiy6NZgfYts2f/vQnbrnlFt566y2CIGDo0KGNnq3YGLZs2cKtt97aIGNWKSVXX301vu836hoNElwrV66sM+NwV3zwwQd069atUQvRaDR7hv5TE6S6uoi0gVljYFcJ0h0DNZ6mWwpzeR5uUUDByii9188niErsCgdpUsfg86BblMP5Z9NG0W+66vrpN7MMp1rQf2oi54Se5bBrylh6hxZiWaPTLAMnqPv4XlnzCbDBpYlmPZ+mjdAMo3n21GifpjB16lRGjx5N796969RfJZNJ5s6dy8SJE+s97t13363zXErJRx99lLOVyHLooYfWe/yPf/zjBgeWrrvuugbttzVtzvi0LaCNTzX7AodfWUa6ncDNV6abXr5UdgSmxKoWpDtIousFmXYSLy4JYn5oFCURnkHkaxMvKnEqhHrdhhWjSxlwc117giHXJZAGvHtbCYeMru3SG1ySwPAaV9T9TWHQ2NoC+m1HAWn2PvaU8enfVv6Tb41umqdkpirDX057sE1/vpmmydq1a7cTPxs3bqRz5847jCwZhoEQgvpkTXa7EKLRkanmYre6FLds2cLrr7/O+vXrtzMh3ZsL2jSavZmjfzqfwBQIKTEzYMQEeeskfjSMqGwEpMRMQ3I/iK5Xf+nalYL4Gki3s3Nu6B9OL2HQuARGRvDhtLpiILK5rsgyUxIvTzC4JIGVlrw/T0WxpAlGSv89Vx9bpxhNXe6qaSDKh2vfj3DtaBzfO++8s9Naq5UrV7bksppMowXX3//+d37yk59QXV1NQUFBnZsihNCCS6PZQxx6fQLDk5gpsJMSKy1JtRMIX4AtcQsE0Y0BMiOIbAlIFxuYaXDzILpB4sYFZlriFgqkKbBq1Pw+K6lsDYKIGisDMGh8ArtCsvTOUoSUyPD/+yHXJnAy8NbdJQz9ZRlv/7Y2ZZjt1GuMT9Q3hezMQ6jtWNRovum0a9cOIQRCCA466KA6+sL3faqqqur4cG5LYwrYd4SUklWrVnHggQdiWRaZTIYnnniCdDrNd77zHTp27Ljb52604Bo1ahSXXnopM2bMyE3k1mg0e4YjLisjcNTsPsdT/0oDvKjAi6jZetEqFVWyKyWBLTB8SbrYUFEuCZFyiTTUcYYLskadO9VJkvc/wTu3KyPO9+eVcNjVqjZr2awShl5VxtBfliFQmUfDlWSKBO/cXqpqhn5bf32WFlvbkxVbGk1jaJ4uxbYb4br11luRUnLppZcyZcqUOgXsjuPQs2dPjj322Ba7/scff8yIESNYs2YNvXv3ZuHChZx33nl89NFHSCnJy8vjtdde2+3i/UYLri+//JJf/epXWmxpNHuIw39RhpkOBVIARg0YnhJVbr7AqQzTdhKslEofWikltqQJwlMDlc2UmueXKRC5Y0UQ7p+EvP8J8r72VeTMV+dcemcpR1xWxpv3liIkvHVXaZ36oyzvlZUw5Do1N1AXa2vqI1jXD6PL8tZexl6NbIaiedmGBdfFF18MQK9evTjuuOOwrD3rzT5u3DiGDBnC3//+d/7whz9w1lln0a9fP5YsWYKUkvPPP5+pU6fyxz/+cbfO32ipPGLECN54443duphGo2kYR1xexuFXlnH0T+bnIlJ2TfhvMsDNExg+EICVChABRMp9MgUCLyrU6y7ENgYENlhpVfROeB63QGAlJYYLToVEBJJ3bi+hooeJ4UmED4dfUcbhV5QhzTB9mYFvXVpGdJNkyLVqFM3AG9S/g0tV2nBrsTVwwvbjajTfXLTYajoSNZqnqY+2zre//W02bdq03faNGzdimmY9RzQPr732GlOmTGHw4MFMmzaNDz/8kNGjR2PbNo7jMG7cOBYvXrzb52+QfHzqqadyX5955pmMGTOGDz74gMGDB2Pbdp19v/vd7+72YjSabzpH/2S+ElWeKl6XBqTjgkiFxHfAqQzwI4JoeYAXFdhJSWAKUsWCwDJVitBA/WYW4EUE8fUByXYG0fKAVJFBJl9gV0kCS3UwmmmBU6FEVCSjxJaqBzNyhfFHXFaGCOC/D5QqERb+5nDKJYNLEryX2D6qpX2mNBrN7rAj84R0Oo3jOC123aqqqlxRfjweJx6P07Vr19zrBxxwAF999dVun79Bguv73//+dtumTp263bbWbLfUaPZWDr+ijLyNPm7MAKEiUF5UkC40iG4OiFRIDFfmRBRS1WzZNUo0AUS3SMxMgNvJxIsJnHXqebrYwPCVeKvqaiItJZL8CIhAEt0A0lIdhSJQ1whs+M+9ozj8F2W4eYJv/byMN+8r5eifKENjKy15625Vr1Wfr9bBNyW262zUtA79JydIdwgQUtXdrbpuVGsvSdMEVA3XvtuluGDBAkBpiXvuuafOdBvf91m8eDEDBgxoset369aNzz//nO7duwMwZ86cOtYUX3/9Ne3atdvt8zdIcG1r/aDRaJrOMRfOx8xIIpYgVWwiwv/Nku0Fsc0BeV/7eDEDPwLSUPVWTlWA4UkCIRC+xJDgRwRSQKa9iV0tkWFkS0hlOeDGBE6VxI2DWRkW2gtVw+VHIf6/gFQ7kRNmdrWymDAcFfnKZiD+8yf1Yf36gzv+0D5kTIIP52qx1Rboddt8aI/6udJia99A7tu2EImEKkOQUnLXXXfVSR9mi+bvuuuuXZ5n6NCh9dpKCCGIRqP07duXSy65hFNOOaXO66eddhofffQRxx9/PAC//OUv67y+cOHCRs+W3ppG13A9+OCD9c5JzGQyPPjgg7u9EI3mm8JRP5vPURfNx0oFGBmphJMrsZIBVjLAdMHNEyAEZkZiJSVOZYCZkUhDIA2h0oFxAzdP4DuCTKGyeDAzkrwNAZFKH8MFKxngVAX4tiqcN1ypuhUFEHYpJjsYOJVKqEXKlcBy44I3/lAKAvVvA3lfi602g1UjIICV14/CTLbdD1mNJsvKlStZuXIlJ510Eu+8807u+cqVK/n444959tlnOfroo3d5npEjR/LZZ58Rj8c55ZRTOPnkk8nPz2fFihUceeSRrF27ltNOO42//e1vdY676667uPzyy3d43h/96Efcc889u/3+Gu00v7sOsHsT2mle0xIMO38eIlARJ8NT3YHSFNjVKuWTbG9gpZTHVWyThxczQKp9IOxSDLsTfVsJLadK1XSJQKUZzbTETgZk4gYiUNGvwAa7SuZquqSlBJXwIbYhINlJXUcEEDjgbJG8ea8ewbO30m9GmfrZsiXCFwSOZOWvdHSrJdlTTvP/t+IZDvn1SU06j1uV5tnv3L1Pf75dccUVdO/enZtvvrnO9mnTprF69WruvvtuJk2axD//+c9dNgF+8cUXdOvWDcNo+tDvRvdc7sgB9osvvmjQ0EeN5pvGMRfOz6V1glAkAfiOwHeUUEKA4REKLkmqnZlzfQ9MVRxvJQNSxSrEbvgSpzrA8CW+FAQWKsLlStKFJoYrkaYSaflfelR3sVTdlq/WgAS7WpIJuxWVsIN3frNzoTVobAIvDz6erCNZbZEBExME+SAtSWBLTF9osbUP0Ry2EG05pbg1X3zxBU899RSff/45mUymzmtlZWU7Pfaxxx7jzTff3G77j3/8Y4444gjuvvtuLrjggl2eB2DgwIEsXbq0zkzH3aXBgiubExVCcOqpp9bxx/B9n5UrVzJy5MgmL0ij2Rc47tx5SIFKzxUYxDb5ZPINzIwSREIqSwYzI5Gmikz5jqrVCkyQQokxw5PY6YDAElg+xDb5SqCBKqKXYPjgWQLTl/i2IFLuI3zwYsoiorynjeFLIuWSTL7ATEpMlJjLdjWaGfjv/aV1BkwPvCGBFGrMD6gPc79IIoKd/8Luefs8Vl07uuVubhPotWD+PilA+k0vY/mNpXw0tYRet87HrjT4pLSEg27R1hz7EllbiKawN9hCvPDCC3z3u9+lV69efPzxxxxyyCGsWrUKKWWDaqii0SivvfYaffv2rbP9tddeIxqNAqo2PRKJ7PJczTluusGCK9upuHTpUkaMGFGneyBbzPbDH/6w2Ram0eyNDDt/HqkiAytPpfns6oDYZp9UsUl0i09gqWiUXQMIlcaTpqrZEkHYiCip3dcWeDEDw5MkO5rY1Up8xb52qejhEN0SIA3VOYhUYsiNK2EX2CptaGbULwwvqry5vLjgnQVKRA0uTYTF+pLDryjDKxYcen2Cd28r4YMZJQwurf3A/mhqCf1mlPHJzTuPbrVVsdVnXhmmL+g3s4zlE/atlKkfk/SdU0ZggjDU895l8/ns5n1PXGr2fSZMmMCoUaOYOnUqBQUF/PWvf6Vz58785Cc/aVBg57rrruOqq67izTff5Mgjj0QIweuvv84999zDDTfcAMCzzz7L0KFDW/qt1KFRNVy+7/PHP/6RESNG1PGm2NfQNVyaxnLE5WXYNSrCBEpEOZUBmXyDSIXyzFJdg+p/NzMT4EcMUsXqdaRKMQqpolpeVCCFUGIqpZ471QHSENhVPplCU6kzVIQqsFWaUBpgusqby0oFeFFDGZ6iIl5mShItD9jczySyWUXX3AIQnupofPe2kpzgOvjGRC661VC2jm71vHMeq65uG+Kr9yPTMVfGAMLIIXw6bu8TXQfdksCPSVaMLqX3/DLMVN3Xvbiq2/ps1N733vZm9lQN1yOfLuTg609u0nncqjSLzrqrTX++FRQUsHTpUvr06UO7du145ZVXGDRoEO+88w7f+973WLVq1S7P8ac//Ynbb7+djz/+GID+/ftz3XXXceGFFwKQTCZzXYs7Y+bMmfzyl7+kuLi4qW+rcV2Kpmly1VVXkUqldr2zRrOPc8L35nLURfM59kfzlKiRtX5WVlJFmAJbCSnC2YPpIgNpQrrQJNneUMOjYwaZfFXk7lT6SENFouJrMyo6JVTEy0oGmJmATIGKdElDXc8I+1TMTFjX5WY7DY1wPeDlCSLlqjjfiwpiGySGr8SdUy5xKpSL/WFXl+HFa99jvxm1NQ79ZtZf79B/soqC9Vown1XXjqbXrcqvqznEVp+5tdfsce+c3T6PX+Go+Y8ZFfULrLrnbqsMHpWg9/wyepfNVxEsWyIClUK0qwSBAxgQRJSfmpkRSFsyYJJOJe6LSFQNVlMebXm0T5Z4PJ5zQ+jWrRsrVqzIvbZhw4YGneMnP/kJS5YsYdOmTWzatIklS5bkxBZALBbbpdgCFW1rDrEFu1E0P3jwYD777DN69erVLAvQaPY2jvrZfAJLEAlNRzMFBsJXnX+GC4ElEEEYlaqUuXSh7wicyoDAFmHtVq0Ys1LKriHZwUKEcwzdQguEiopZyQA3biICNaKnpqOJ4akxP0hVDO9HBEGg6sAMT10X1LqcCokXE7z1u1IO/XWCd28t4fArynj7d6UcdnUZmUIVXVuaqI2MfDhd1QD1nVXGp+NLYRs7vuz2jyeruqGVv1bpq+y/WXrdNp+V1+9eamvFmNr1rL5sbO7rfjPLQMLyG3Ydyek7uwwbU4nNPHVvDZfdMMXZc/SdU4ZdLkjvH2B4Ai9PYqZFbui4H5cYHrk6PuGp4/yIRLiCj6bopoZ9km9I0fwxxxzDq6++ysCBAznzzDMZNWoU7733Ho8//jjHHHNMg8+TyWRYv379dl6iWWPTHSGl5C9/+QuLFi2q9/jHH3+84W9mKxr9K2f69OmMHj2af/zjH6xdu5aKioo6D41mX+WYC+dzzIXzVbrPVGm8wFJdfmYmG21SUSY3T9kvIFRNll0T5LoTzbQk2VH9r5etr1IdiwLfhkyhOq8XFTkn+XSxRbrQINXOVJYOgRJbVnWA72T3h1Q7Q3lthVYSwlfiws0X+LZg0NgEVlIy5LoEb91dypBrE+q1CLgF279nPyqV2EJZRvSZp6JCfWeV4eUH9JlXRp85ZduJrCw9/jCboEipgWzka1f0WlB3v163bX+c7zRMbPV5ZHpOlPhRGVprqPtiVbXdD57AlmTaKXt435HY5SpaGVgQOFJF6gKQpmT5DaVIK2yC8HQ6UbP3U1ZWlvPbmjx5MsOHD+fRRx+lR48e3Hvvvbs8fvny5ZxwwgnEYjF69OhBr1696NWrFz179mxQsOj666/nZz/7GStXriQ/P5+ioqI6j92l0T5cW3tRbG0PkbWL0D5cmn2No386P+cCL3yJ7ygfLRFI/IgSSlKoTr9MkcCqkeHYndCGwRIIKXNfZ/20pCkwXBV5ynYKposFkc2STKGqycr+SSQN5Q7vxZWwM1Pkxvz4DjgVah8RKIHnxZSw8KKhf5cPdgW8c7uqzbJS4ObT6EhI3zllucJ+KWDF2FL6T02QKQxyoqvH7+ey+sox9Lh7DquvUFGpnr+ZX6/TeY/fzWX1L8Zst73XrfMxMoIVY+uKh/5TEnw8qeFr7jO3DD8vwMgI7ApDRYCkSi2aKVXzZCZFo2vVWpo+c8oIIpIgFmCkjFwEC5SoygpIMxV+HVNpZKtSsPxGLbj2NHuqhuvPy5+j33XfbtJ5vKo0r3zvjn368+24447DsizGjx9P165dt7OyGjJkyE6Pb9++PQ899BDf+c53mnVdjU4pLlq0qFkXoNG0VU48aw5VXS1E2N2XLU43XPAjqsjct1WkISuMIpsD3HgowgwwUCN1rKTAjwMSMsWC+JdKkHlRkTMoTauZqSQ7KzGQ6qhEWK7oPS5xC33MahPZXuJsNpRgSEOyizq3U6Gu6ztKFAW2cpAnI8gUqXorv0jix+CTm0rrpOb6zlY1QtKkTgqwd2I+RlpF9UBFzJbfWMpB08rotWA+sqNk1dWj6fG7uYiYz+orx9PnkemsvuLG3Dm2Flu9y+bzWal6vvoXY+hxzxxWX16bLoS6ack+c8pywqsxYqvn7fOwPQOqs/MkZRjxE0hL4uare2S0wb8RV4wtpe+sMgzXDGsDVQeqNCR+VEJQO6T80/GqgN7w0GJrH0dKmlyDtTfUcDWVpUuX8uabb+723MWioqJm8d3alkZHuL4J6AhX63Pi2apA2kgH+FFTdeEJMFMq1CR8CUKE0Z4AP6rqqESgBjqr5yoa5UUNpAF2UiICSfzzGjYdkq8MPwXh+BxVjG5mJG5MGY1mfy9l6628iBG6uqvCZcODmo5GrvNQBEpMGWly+6g1qZSe4cmcK7wUtT5Yfoxcx2HggBeTBBGJ8ATSVF9bVSo6E8QCFcmoMPHyfbAlRrVJEPcRSQNpSSXITEkQV0rC3mwR2BICEUZMwlqgiESkwzdpwMpfjaLHXXMRrgFC1rF3yFop9JlThjThs1GldYTTzuhx11xWX7V9FGtrshGwnr8JC+6vG0WP383FLjf5dGzjRUTf2WXKOT+8xwQggrBg3pFYNYIPp5UwYFKCwJZ8clPbFCp9Z5UpYWWAV+gj0qq5QlqSVdeMpsddczGTalJAQ74XmpZhT0W4/vTJc/S77tQmncerSvPq929vk59vDRU5n3322U5fP/LII0kkErmZiI3lgQce4JlnnuEPf/gDsVhst85RH42OcAFs2bKFe++9lw8//BAhBAMHDuTSSy/VTvOaRnPyyNmki62cM7qyRDAwHSNMwxk5kSJ8SabQzHXyZQls9YGTKTCwq1QRuZkK/01L3DxDWSoIcCp8qnrGsVISKyURUtU7pYpNIuUBmULlYZVsp8bs+I7AiyszUrdARbWEr4Y+C1+JJeGrmXV+TBJYksgWgRcT2FVKlElD7ZvOF7nxOXYlpNurlJAfU+LMjyp3cLtchcuygkFaqvaI0EgVO8ArVNe1vjZxi33wVdRG+AK/YwYCAZ5QkbcAgo4ZZMqEQCDNUHA5AfhGTlj1uHsOq68aq8xBr6vbYZj1rfK7pln1swnqvndS7s99H53Gpz+6iR5/mI1wAqQvWH3x+NyxOxNb2eiWU66+n2ZasGK0ulZ9qcaGIvywps5F3WNHglD3B6nua/8pCYKISin2n5rg44ltK60IKnrVd04ZMgCrXIUYlWiE3vPLEHkCgn2nbmvmsu8wYdD/a+1ltFkkYp82Pl21ahU9evTgwgsv3G58YGOYPXs2Y8eOZcaMGQwePBjbtuu8viuhed555/Hwww/TuXNnevbsud3xb7311m6tq9ERrjfeeIMRI0YQi8U46qijkFLyxhtvkEwmmzxJu62gI1wtw7E/mper/TE8JYoyRSqqZKZVhInQh8rwlRAyMzLswpNIS2DV+AS2katX8iPKpT2wBWbSx4ubYSTJUI7thiBdJIhUSAxP8vVhBsWfKEPSTIGR87hSnYTKKsGNKzsHM63EUtanKlsbZYWmpZnisC7LBjOpuvzcfNVVFtgSq1rkipztKoNUFw8jaSDNMGIVk0pM5flhYbfALDeVGLIk0gmjXJEAI+YhN0bAUNuCIg9SBmZS3QsAs2sNlhWQqopgrXNwi32swgxeuQNOgKgxwQBphSE2KwBTIqotZES9Lgs8Vl8yjt6PTOezH9+4s2/nDjnx+TH0KdzAvd1fweiyPLf9qGcm8PrImbs8vu/ssiZ5ZPWdpaJbSGWVIAXYlWGjQxjdUulhJV4wIDBlm07H9S6br96LJcEXmEmBXxCw6pdtw+fsm86einA99Mnz9L72tCadx6tO85/vL2iTn2+PPfYY9913Hy+99BJnnHEGl156Kd/5zncaPccwu/+2tVsNrTU///zzWbRoEeeeey777bffdueZNGlSo9aTpdERrpKSEr773e9y991358b7eJ7H5Zdfzq9//WsWL168WwvR7Jsc+6N56gsRDluuDlSazZd4eQZWUhmACl8ZdfqOkRvQbNUE+DH1P05NJ5O8rwNq9rNzAksEYKaDnL2C8AzVrRdTkS4/38gVrlupgMhml/w1Uaq7Csy0mbNyEIGqaZKmimSB+jD24iBcVftjBGrUjh8J3dwLVCG2my+xq0SuGBsBbqFK9YEZ+iYJ3Lhq1xeeSutJE4JCD3yhhBBAIPDzA4ykuh/S8iFtITIGgWFiBKi28FiASJq5dKNwBUGeT1ARwYv6UG3hxQOEL/CqbHACyBjIfA9RbSE8dU+lBaRNZMwnWpimR59NLDz5VoDdFlvBun4sPm15va/tTGz1m6FSlZ+OK8WP7H6Vw7CF4xD+fkgLrBpBIFUEK1OkhBZAplBZLGQbIXxHYrht969+UOnC3vPL6owl6nn7vFZckaY1kDTdR6st13Cdf/75nH/++Xz55Zfcf//9lJSUcOWVV3LRRRdx2WWX0a9fvwadp6m15v/85z959tlndzsluSMaLbjeeOONOmILwLIsxo4dy7e+9a1mXZxm7+TYH83Dd8LoVOiW7ttqaLObZ4RWCGFqxxJYNQFuvhIB2eiUmVZ1WVa1j1tgEt1Ua6lg+DLna5VqZ2LXqNqs6i5WzmU9sAwVIXMlpgvpApPN/SyMDNjVqnvPEGDWhF2HLlR3krkUoOGGospVkavAUelCaYBrSwJH4hd7iKRJpl0QCizAFYg8H+NrB2mq9n2VCpRIWxLIAJER+LEAXENFmcJuQ6tG4FmhY3x7V4kxCdIH0oaq38run7bAlEhDIiOqPgtTIn0BeR54Bka1ibQBQ0IkFF2mROR5yKT6/zfeuZrDu67hvu4vYXddwZ6k75wyvAJ1P1beoIREz9/MZ9UOLCYawrr39kPG1c9HYInc/XfKBV5cCSszCdJWTQh2pUrpysb9Ad0qGL6y5fDaeay+bGybHaG0Nf3/OpWPfzhxu+1DfpXIjZfSaLZl//3358Ybb+TGG2/k5ZdfZvLkycydO5cNGzbQrl27XR5/0kknNen6Bx54YItE/xotuAoLC/n888+3q/5fs2YNBQX1GPlovjEc/dP5ygPKEjl7AjcqsGuCXOG5mZaYaRXdMjMBUgi8PCNnj+BUZg0+IZMvkIZKEVo1KuUoJBhpiZenxJRdE+BHlGdVttA9iEE6buBHwK5WAqbqQIlAEtkk8CzlZ2R4YYQrjC7blQIvX6UJ3QIl8KQBXoGvIk5RHzIGZo0BhS6ENVHYKs0j0gbSCZA1JkE0QMZ8hBNgWgG+Z0CNBUUulNuYKQMvooSRtKQqgo8HGEmhbAy22Mg8nyBP1Wdhqc40PAMMlYY0oh6ywlEF4cUZhCnxq2ywJE5hmgwRVcclDUTMBxOkb+DEXOzCFMd0W829R97frD8Dh7/xI5ae1bB9zaTg07F1RUN91hENpf9fpyJkPkZaYKZVWldKgVkTCmxXNSEIvzbl68YlTrmBmx/s+gKtjBTk6tt6J+ZjuGK3Ggr2JPWJLUCLrd1EyqYbl+4NxqcAqVSKv/zlL/zhD3/gP//5D+eddx55eXk73P/dd9/lkEMOwTAM3n333Z2e+9BDD93p6/Pnz2fs2LHcdddd9OzZc3eWXy+NFlw/+tGPuOyyy5g3bx7Dhg1DCMErr7zCmDFjuOCCC5ptYZq9gxO+NxcvZiACCXatIWe6UKXJDE9FD4SnolxmRo23Uc7qgkzcIFru48YMNXuwwMS3VYTKTkpSRYYai1OgzicNENlomCvxC5SwMlxIFwr8mPpamqEtggXRjRKnXOSeZ6MZmSKVkpOWxKpU1wHw8sPIFKozjABEWiBcC2lJ/HwfUWmr2YidUng1YbTJlIiUAQUessbEzPPwq238QCAlOO1SZKocyPORHdM4ZoC7Lg9pB/idVVF7YICQgiCqIlmRohSZr/PA8ZBpE6wAYQVQZRP4topmBQLTlNiOR+EBVXz1v2K8TLivDdIXWLZSlcWFlfx+4EMcFonUqa9qCj3um42ossLOxmnbvV5fTVa/GWUsn7RrsZDthGxIp6O3Ih8zo7oR3fwAu9LIjfGRVtZWAdwClV4MLKl+VkTobdXGkUatb9lnJW23I7HHfbNZ/fNxrb2MfZampxSbaSEtxH/+8x/uvfdeHn30Ufr06cOll17KX//6111Gtg477DDWrVtH586dOeywwxBCUF+JekNquH76059SU1NDnz59yMvL265oftOmTY1/Y+yG4Jo3bx5CCC666CI8T7nx2bbNL3/5S2bNmrVbi9DsfRxzoYpmyZiBFxE5LyMvJrBryEW67GSgBjqLcKZfVOTc1QNTWSVk4gZW2E3oR5TruVUjyOQrkYQMDUWrJX4ElY0UArtaubKbaUm6ncil5tzQHBSh/LKS+ykfIzOpollefmjrkFHixi0M8AoDZMTHqLIIilyClAmRAFFtqlRgsYcwJNI1wA2jXYHAz5gYFVbOgkFGA1UnVeASuIaKTkUkpE0yFRGMmEeQtJC+IFMexZAgMgZmuzRu0oR8D5lUalGkDLw8C/Jd1WEY+i7JQKUNDSsgcE3sPBeEJFkRJZ20EWkTkedhGgGRaIao43JW92VM6bSMmiBDfrfPm/z9H3hDgg9mqCjFrj5cPx1XmusCPOiWBJ/cXIKZVB8aB00r26klQ86vqx6x1Tsxn89KRtXOeDRDg1hTNSkElkSYKpKW3W6mQlsPD7CV/9hB08rafKQIlBVHz9vnNWlU0p5Ai62WQ+7jo30GDRrE+vXrufDCC/nXv/61y0jU1qxcuZJOnTrlvm4Kt956a5OO3xGNFlyO43Dbbbcxc+ZMVqxYgZSSvn377jTUp9m3OPZH8wgcgV0lETLAjVngqxTd1jP8hAw9sRyB64RjZjwlgoLQmsDwIV2kHNf9qHJpNzJKSHl5qiPQywOrWrXCq+NVx1m6fTgrMDskOqIiGX5Ufcj6UeWzRdiUl+ngqw7BclXMjgV+fqA6AS0lAqUtMTfZBFGJzBg5WwWj3CKIBBgFLoFlgGcgIj4yYyLjPkbcI6iyMWIuMrSpkK6ByAhkRNlGYIBhSAIgqLHCwniJjHsEmyNgSaSnarGMmEdgmwS+UPVWToAwJIbjE3gG0gsjcp7A9w0s28eKehhmgNWlCsfy6d9xPY/0ehGA8iCJ0eUL8nfj+91nblmdmYYH35hQQngrDr4xsVO39qzlwic3q3+9uDrBJzeV0m962S47BPtPTvDx5Lrnz0Z5ZJ9qxIq4SiOGNg+GC0GeSiVCKLRCsZ11Zhe+oM+cMvx2bT+dmMWqMXKebRrNvsaHH35IPB7nwQcf5I9//OMO96svwtSjR496v94dLr744iYdvyN2y4cLIC8vj8GDBzfnWjRtnKMumo+ZVkXmpgup9iZOZYCVzhqMhu7rjhJCfiSMIgUqpSgtcB1VS2P4KmqlbCAg3U7gVKoIWVCsrufGVbegUwF+FDxT1Gn1V/MMQ68roVJFZlqNvZGWxEqqwndpAxLszQbSAi9fjUsBMGrUjDoRgEhaSFMiO6eRlXZuH1noqzC+EyB9A1FlIW2JYQdIQxKkLIK0qboFq2xVpG6qh8xXkTB8FX7zN0Yg38PcZCNNJfBI10avhCWRKYOgxlICLGVCxFe1W2aAISS+ZyCM0C4j6iN9QVG7JDVph/2Lyumev5nbD3iJiLBzacNdl5nWz8E3JlgxvZRB4xMID96fV1KvsNqZ2KrP4yo7nxEa5o6+rdjK0m9mGWYmHy8uEUIqR/zcvESBXQl1bIdCbWWEprJ2tYBGtpy3JntDJK4tEKzr12wp87ZGU1OCbTmleN999zXLeR544AE6duzImWeeCShLjd///vcMHDiQhx9+uMmCbHdptOCqrq5m1qxZvPDCC/VO0d6VA6xm7+PwK8ow3dphzWZa5hzdkx0NjOzgZk85qmdrpLJDk0UQphhtgRdX0SovT9XWmBklpqSpZvsFVniuTO2Q3kyh2p71VjL8cAZeWuTG16hCabZq9YdMZxdRY2KmVOQj140WppeMjEBIgQwkfjtfzQisMZVoAoJIoKwcKi0wJGaeh/gihh9XUbFgQ0RdzJHgKpNRkRFIBwiE8tyyJUbSwC/yECkDGQkgZeLHlf1DFuELZCyAKgshav2WRMRXES4rQJgSt8pR4i3qY5iSgvwa8hyXwzp8iWX43NT5ZTqacYwuq5rley8kHDImwbK5tYJn8KgE783fedHzwTcmkCZ8NLWkRQ1FvTyJ46qIluGqKJaRydbqqa5EPyoxUN2IZo3ALZL4eQFWtcCLyVwhumbfYZ8VWzTduFS2YePT5ooszZgxg9/+9rcALFmyhNtvv51bb72Vf/zjH5SUlPD44483y3UaS6MF1+WXX87LL7/Mz372s3qHQmr2LQ67ugw7E84RdMIxKQLcPEO5oBu1rt5uJIwUhQ8vpuqqpKHSgF6YdU51Ut2E0gaq1D5WjTIVzY7DAbCqRGhKqT48CV3CvYjqMPPylOjy40p0ZVOIzhY11kekDFW/Yyv7BNNV43HsLYZKM5rKgymI+9hf23gxlY7CgMCS6l9HiS5pS1gbVYXWKeXuLS01akeE1gNGysBv5yqPLFt92Aco4UagzmtWqCgaoXErrlA1WmlT2TZYUlk/hO+VchshBWSEEmOGRLTPYNk+Qkj6tt/ApV1eYWReulk+ZLLpQuGh1ijh/bl1BVNWbA0an1AbAiWaP5pau9+2Ea9B4xIsm71r4dUY09P+f52KCOLhrEHwDVWbJc1sQbwIpw0IMkUBn5Wqei8jDYZv4OXJ3M+aRqPZMYsXL2bu3Lm8+eabrF27lieeeILvf//7Oz3m5ZdfprS0lGXLltGtWzfGjh3LVVddtUfWu2bNGvr27QvAk08+ybnnnsuVV17Jcccdx8knn7xH1lAfjRZcTz/9NP/85z857rjjWmI9mjbCkOsSSkRIVU9lV6uIlpdXK6D8SDaiJHHjQommbMF6OD4l2xno5qv0jZuvOsSEgIAwLRaoWpvskGYRDho2M+GgaBF27tlqfyupohWBg7qAVMc45UZunyCqOg+D0K3dyohc52KmvXJ2tytCYVRt4nbwMKpN/JjMiUppS+zQ+d2oNHPO8IEjMavCuYWVJoGj0oeBIzGqLDXyx5SqwxElxPBBuCKclowat2OHNWaVtnKMN2V4XaHG7thqTI6qrFciNa9DDaYZMKDjeqYc8HcOdpSKbQ6x1X9KAlOSK4YfNL5WJG1dJJ/Fd2pF1oCJiR2ed8CkBDIU2wfflFA1fI6sV1g1VGz1m16GtPIJ8qT62aoU4cxKGdYSqnRyZJNBICCyyaDPnDJMTw2ADsKavaY42mtal55/nInl+Hz6o5s46C9T+eTc+i0osvxrVR9O6LmCc1+7ir8Mu2sPrbJ5kbJ1jE+rq6sZMmQIP//5z/nhD3+4y/1XrlzJd77zHa644goeeughXn31Va6++mo6derUoOObSn5+Phs3bqR79+4sXLiQkhL1eyoajZJMJlv8+jui0YKrXbt2tG/fviXWomkjDC5NEOSF9gpCEDgQhOagKpqhXNez9gtenipa98KUoB9RjuxmBoyMCOuwlCDzIyp6ZPgiNBeVWCn1IWhkBDIchYNQswWlUTvsGVT9lpenollmSq1NCTYVrTB8SPXIQMpA+EY4BDo8Vqj5gUZKiSWvIAAvFGI1aqyQjAYYNSa+KTErDTXfMM9XY3eqDWQotrIO79KWYSF/OBcxL8g5yptJA6+9p8xJhQQTEIIg5iNSJkZG4Bd7kFGRMXyBUWMi454yRXWzuVmJGffo23U9x3ZYyZXtXqerlQ/kNVvqZMCkBIanxNbAGxKIAJbNqhVY24otUGJr4IQEH8wsqRPdynLImATvzy3hoylbRb6mNU96UVrqZ8uwlNealxXyEEa8wgijo6YFSBNWjFXdklKo43Uqce/gx0uupGOkig3pfE5t/yHPbRrIY8f+juMP+hQ7rCHYWmz95qNvc90A1SxyyFMTef+7UwE4oacy9t1bxRaEKcVW6FI844wzOOOMMxq8/1133UX37t1z3X4HH3wwb7zxBvPmzdsjgmv48OFcfvnlDB06lE8++SRXy7Vs2bJm9dVqLI0WXLfccgsTJ07kgQce0J2J+yADJyQI8sPUoVRpRN9RtVbKniEsYo+oh1sgcSrU/8CZIhVNQoRRhoyqnxG+minoFihBZtWEkauYSgmC+kCUFuH+YTF8WomzbNG7287H3mzitlNCyc8P80GGcloXnsBZa+J2BgyU+Mmm6UAVTNsBgUDVRFVbiA7p3IzCIE+l8lT0LACparBAFdcHURmKNfXepEHolyURaQM/L8gNmJa2xDcClTIUYY2WLcEF4RkICX48dJs3s+lSNbYnW4wvA0GkOEOHwmqO6bSKizu8xqFOFMhvFqHV8455SEuy+hdjEJ76Xg+YmOCjesQV1J8W/GBm/fsOnJDgg7klym/rhlph029mWW4QdpZeC+bXGVmzK4YtHAdiP4QEK6nSzWYqnHfpqlpCXKFquWzAVqnjfjPLEGFzgi4+3zsI1vWja/RwDoxuop1dwyY/zmPH/o4/fHIcDx39ar3HZMVWlqOfHc9/Ruw7lkXNVTRfUVFRZ3skEiESiTTt5CFLlizh9NNPr7NtxIgR3Hvvvbiuu52vVXNzxx13cNNNN7FmzRr++te/0qFDBwDefPPNBvmFnnPOOfWWSwkhiEaj9O3blwsvvJD+/fs3al2NFlzz589nxYoV7Lfffs06RVvT+gyYqCJb2XEybn744SVUkXu6vRJU6fZS1W+JsIA9TxWjZ5+DwPRUYXtgg5mSeHnha2HQRlpKyAmpIhN+HPxIgJlSESdpSPwwfRlE1F+xwhXQqxqZVD9zphPgZwzsqApheRkTr2OSmBWQqnaQnoFRlMGyfNLlUSXMwvPIwEAWeLDJQdqBsl1IZecTqucyHo7AkWpNEAosiRKWRiikTJBhWhErQDrKBkI6IKpUB6KRFgSSXGF9VoThC3V9A4j4GFZAXjxNl8JKusc3c91+L3BY+EvQ6LKmWb7P49/5IbOG/JVV14ymx+/nAjvvMsySvQcH35TYZaQqK8SyYit7zLYzC/tPTbByYuM8pb56Zz/MtIqKIpWwygpdp1KlvY10aEOC+lkz06quy0yJZouyaVqGrTsM+//rInp12shr63vRNV7BhmQ+/7f6BjrHj+APq8fyyvA5dY7p+dt5dQZ6V31RSFW+1yrvo61z4IEH1nk+adIkJk+e3CznXrduHfvtt1+dbfvttx+e57Fhwwa6du3aoPNkMhlWrlxJnz596owT3BXFxcXcfvvt222fMmVKg44vKiriySefpLi4mCOOOAIpJW+//TZbtmzh9NNP59FHH2X27Nm88MILjSqvarTg2lWhnGbvpN/MMoKCcOCvLZFCfaBJX31AGmlwNoeF70IghMT01IeY8MMPv9DF2/DBo9YOQgSqBd9ICYKwYNy31WxBPyKRwiCIhsOgiwPMKiMX7ZGhiBGWxIq6+J5JcftqvMAg5rikXQvPN/A8k/MOfYs3Nnbn66o4HTtWYghJxjNJuxZmnkfHdpVs3JKPWZAmk7IRhlTRPEfVdAVCfR1U2Yhs/ZSQKkoW80OhZSiB5G8lHJyAaEGaVGUojCqUZ5cIhBJ1SRM/L0xBZqNtQrnXZ0WMiPpgSDp1qKR30UZObf8hlxWtA7Jiq/m6rmYN+Wvu69VX7ty9fWuyacVtBUtDWvCzx2zbsdjYDsY+c8tycxGlUBYghGI/cGSYN1biPlMgiWxR6W+3UNXmabHVNgnW9ePfKZ8vvXYcaLscg4pMdW3nk2+n+bK8iGonQr6TzomsrTlkwdV8MIM6Ygtg1dWj6XHP9vvvtTRjDdeaNWvqzAtsruhWlm0jRFnX94Y02tXU1HDdddfxwAMPAPDJJ5/Qu3dvfvWrX9GtWzfGjx+/0+MXL16809dPPPHEnb7epUsXLrzwQm6//XaM0DYmCAKuv/56CgoKeOSRR7jqqqsYN24cr7zyyi7fT5ZGC65JkyY1aL+HH36Y7373u8Tj8cZeQrOH6TunDMMTGKh6J2GqdJ9VI/AdleKTMQgitd1fXr7ErlA1Ml48wK4SGCmBjCrj0mxhtKrhknw2qpReC+bnngeWijSZnsCPK2ElDVUs7hVKcNSw5Uj7JJ5rYZg++XlpDum0lnwrw6qq9uRZGSwj4IvKYmzTZ1MmzuB2/yPSwaOjXUk3ewvPbhpExPD5KlVAxjex2gdkfJO84krKk1EAqpMObtJGWAGm7SPjAifq4jgelRvjSFPNRBRCIn3lHi/zfIQVKLd3zyCTsiAAM6ZSlllTU5ImIhC5CAyAzFMzGWWeKoY38z167LeRAjvNcR0+ZUx7VWvSGq3tWSf4rRk0NsGyOSU5O4jBJQmCSG2NV3adAyYm6q3lGjQ+UaceLLuv8BsWWcvS97FbMNNxvLzwF3cYMZWhqayZFFhJ1THpO+qPh2Rn5cdmV4hGXUuzZ6kJMvSwMgzrqWyFvv/K1Wzc0o1oLMP6inySFVE+WZfP6l/U/wdCfTWGWVZfPrZF1twaSJpjtI86vrCwsEUGNIMSLOvWrauzbf369ViWlUvv7YwJEybwzjvv8NJLLzFy5Mjc9tNOO41JkybtUnDV14m4tdDb1Wife++9l1dffTUntgAMw+C6665j2LBhzJgxg2uvvZYTTjhhl+9la3bb+HRX/OIXv+Doo4+md+/eLXUJTTPQ8455iKhQxZgRmbN58KMBIjAITDADyLQLsCqM0GNLjcYJQnuGIBKOVDGkSkcKVQMmUgZuYYCZFvT8zXzsqrDuyQKvyMcqVyk8ALPGUK7vKQOZ52PmeciowPdM2hVVE7NdIpbHVzWFtC9ex0GF66l0o6yo6EhhJEXv/I0YIsAkoNKLsiGdz+ZInE5OFRVejJ7xjcRMFy8w+M/XPXED9T+SEBLTlAQRn1gsg2N5EAdDgGN5BO0MRGirbghJzHFJZmxczyRV4wCEkTCBcALlDG+HtVyGBFvVYgnHVynOiI8QYORlMAyJ43h0iNdwfY/n6WNvZHD3L1r8e95nXhkEqoh8a/pPSfDJpO0/uJbNUdvem1+iHOUT9X+41Se2+k9N8PGs7bdvu29D6rjMj/JVAMtQqUEzHfqxZZRFCJaKpvpR1cFqlwucLarpYke1Zpq2QX631XWmILz3xf6Ylk91ZRQpBasvUeOCGjKVYF9mbxlefeyxx/L3v/+9zraFCxfyrW99q0H1W08++SSPPvooxxxzTB2hNHDgQFasWLHL4zdv3lznueu6vP3229x8881Mnz59l8d7nsdHH33EQQcdVGf7Rx99lBNr0Wi00bZYLSa46hsaqWlb9LhrrjL+tKRKeflCpWVQH1yBFXYLRsIfqtCXKbDDCA6EXYAq9ZZNj2GQq8WyqkSuhkZa5DoGrQpTjbUJo0F+fuhYWqi69oKMicwYmAUZ4k6GXoUb6ehUkWdmiAiPcj9GJdC9YBMx0yViuKyo6kS7SA2b03kYImBjOs6XlUUAmEaAaQT4gUH7WA2BFNhGQMdYFeWZGAaS8nQUx/TJ+CZ+YFCViuBYHqahUpPt4zWs3VyIZQUEgYqCeZ6Jk6dSnUJIJbgsWes2DwhTIkzlfxHPT6m3GU1zW/9HOCLi7PFIVrY7r++ssjqO7x/XI7a2JWss21AamjLcldjqO6dMDeIWoW2IIzE8gV0pcPMJJxYo8W8mBXYVZAplnYJ9Tdth9gcjGTfwmXpfU8Ovb9xue88752GZBn1nlRFbL6js7WPVGA1ugOj5m/msuq7tzqBsy1RVVfHpp5/mnq9cuZKlS5fSvn17unfvzoQJE/jyyy958MEHAbjqqqu4/fbbKS0t5YorrmDJkiXce++9PPzwww263tdff03nzp23215dXd0gkVNUVLTdtuHDhxOJRCgpKeHNN9/c6fE/+9nPuOyyy7jhhhs48sgjEULw+uuvM2PGDC666CJA+YwNGjSoQe8ny94z00LTbPT840x6PzwDbIlol8l11UlHEkRCXytPeVnJUGQZYdGx+qBTNgjSlqCa9PBiyukbEUaw4lJFHQzVeWikQ5PR8LVszY10wo5ARzmvy6QJgSASz1C8XyWd21XSq3Aj3WOb6OxU8EWyHevdAjZl4nydzmd9soB8M02VH2FddQEryjvyv6pC1lS0Y/mGjgQSYraLaQRsqY6R8UzWVhSyJRWjxrVZvrETX1Xm83V1nLiTwQ0MTCMg45l4vvrfoyoZoaYmwoaqOEEgiNguUiovsXhemrxohkg0g+14WI6Pme/iFGSwIj5mxMdwfHp33cClh73G+b3f5t2jHua102dzZI/VreqIvbXYOvjGuj5ag0fVPj9kTO3XrREpGvzURFUYH5riCql+1gJbiaqs7xaELvMRZZarxVbb5a+fD93ha9sOv842djibDNxiH6tG8F5ZCdH1ZqO6TRsjtk4/cnKD993TSNn0R2N54403GDp0KEOHqu9baWkpQ4cOZeJEZcexdu1aPv/889z+vXr14v/9v//HSy+9xGGHHcYtt9zCggULGmwJceSRR/LPf/4z9zwrsu6++26OPfbYxr+BkE6dOvHxxx/vcr9EIsGvf/1r5syZw4knnsgJJ5zAnDlzKCkpoaysDIDTTz+dRx55pFHXF7KFQlEFBQW88847e2VKsaKigqKiIsrLy1ssx90a9PrzDDWDDwg8A8MK8NNK4OAJVTeVVGEq4SmbAkJndT8vwEgbofO6oTyQXJQbu62EmeEKZeUQCQVbREW9RLYzzZC5r4OIrC0gl+EoG1OCJYm3S9Ixv5p8J03P+Ca6RbbwfmU3OkaqaGfXcFB0Hf+t6kW5G6PSVYWeKd9mzZZiHMunOuVgWT7FsRQZ38Q0AiqSURzLwxCQH0mzf7ycQAoK7BTvb+pK13gFKd+m2Eny6ZaObK7Mo31hNVuq8nBsj4jtIaXAMn0qaqLkRVxq0jZCQCZjIgODgnxlqOcHBvsXlfPjrq9zUeGGNjtmZMDNCT66pXkEVNaPqyUYcHOCVGc1ikcESlxlI6V+RHm6QZjK9qjj+6XZ+1ARLiW6ev5mPmZS+atJQzVJRDarLuD3dpDaznL8c2NZt6kQwwzwP8vfLoV+5CVlBCa8eW/Thfme+MwYO3Ysd7//Ml2u+E6TzuNXp1j+s1lt+vPttddeY+TIkfzkJz/h/vvv5xe/+AXLli1jyZIlvPzyyxxxxBE7Pf7dd9+t81xKydq1a5k1axau6/Lqq/VbitRH1j6jOe5Vi6UUNW2Hw/5xE1U1EQ7sXMEXG4qxLB/XF0hfYFgBkZirbBRcAyJh/VGViXSUj1UQVUJIehKr0lQO6YbEi6tUoZkSZDp7iAqTzH4+RpVJkB9gZJR7ulUtyLT3VddeaAwqHQnZbr9wNqAd9Yjnpdm/qJx8O80xxZ9hC5/1biG94xvoHtlIlR/lf24x+0c280VNMQfkbaHaixDIFMl8m+qMQzyaQQhJZSqC65sc1uVLCjuksITP4fmr+TDZjSIzyXq3AJOArvEKDspfz0eV++FJg6jlMWT/L/k6mU+fThtY8XVHCqJpYrbLV5X5WGaAHwg6FVRTnXHwPIO8vCQHdfiax479XWt/uxtMc4ktaLnI14CJCVWPVSUwkyK0GVGvBbayqrDKVaH8x/XUkGn2Hnr8bi7RryxWTxxH78R8JbDSoYWKC1ZKTarIFNWmqodcl+Cd39T/fc92M/ZaMJ+VW4mtIy8py42Dag6xpWl+hg0bxquvvsq8efPo06cPCxcu5PDDD2fJkiUMHjx4l8cfdthhCCG2K2065phj+MMf/tCotTSnKNURrnrYlyJcJz4/hk01MQSqjintWhTE0hRFUqzZXEyq2sGwA/wKp/YgEY6siUpkJEA4PsbXjnKBjwYIX2AkVU2WNFTtFx3TyAoHkRbKQNQKiBSmSW+IqciZFBhRjyBlYUQ9TNvHTdoq5SYk3TqUEzE9IpZHoZ3irA7vANDN3szydBeihstXrsrL+wg2u3H6RNfzo4JVvJNxOC66fXbclT62MHPPP/eqeKmmJzVBhJogwpDYam5ZcTY39P4ni6sGcHz+J6z3CliZ7syirw7ifxuLOK3vx/hSEDE8AmngSoNX1vTmw3Mm84NXf8njx/22Rb9/rUW2M7E1GfzURGo+LsZK1kawPrm5JOfpNeDmRG6+Z3acFKJhtWiatkWPe+fUGgC7akqDVS1yM1z9WIBZY7BiTK1AasgQ9Z6/mQ9FLs7nDrF1gnduV/sffmUZb/2+lKMums/rDza9rmtPRrj2u/zMJp3Hr07x6UUz94nPtx2xevXqOs8Nw6BTp05Eo9EdHnP44Yfzwgsv0K5duwZd4/jjj+fRRx9l//33b/C6WkxwHXLIITz99NPbmavtDewLgmvky9fz6VcdiUVdDCExjADTkNSkHVzXJFMRIVKUIpOykRnldi5MCZW26hwMTTjlFidncSDzVHeGqDKRsQCj2qzjKyWtsKLaCSBtYsRdTCvArbax8lQOSAiJ7XhEHRfH8sl3Mpgi4NgOK/k82Z79IhX8uN3rxIXH136MjUEcXxo4W00Z7mdvZJ2fx3FRY7fSddv6RgXr+nHXlv3p7azn9DyX19Mux/RYtXs3XtNsDJyQCE13JUZa5Py2QKUOpaiN0g2YmMBwlUGvldy5TYCm9ej98Aw+u+CG7beXzQfCbmcT1QxRqLzs6muo6DunrE79Vo/7ZmNtsFkxpnQ7e5Ied8/BqDHJW6u6rLM/G8POn8drj43e7ty7w54UXJ2bQXCtaOOCyzRN1q5du13h/MaNG+ncufMubR12B8MwePHFFxs8unDYsGG8++67jQoqNTqluGbNGoQQHHDAAQC8/vrr/PnPf2bgwIFceeWVuf3ef//9xp5a00wc8tREgqAdnYur2FwdwzAkhhRUVqt2XMfxoTBNJqnMP638DF7aUvVdhRlkygLPUK7ppoQCD+kJRLWJjATIuK/+Eu2QBt9AekLVgQUCszBD4Bnkda4mnbJxIh5OxKM4L0nE8rBEQMxy6Zm/kX6xr+jnrOOzTGd6O+s5Om5wbHQLG3wfH8EBVpL+Ik21DOhkRogItX6jy1r6NeH+bCvSjC7LubpL7fNjmnBuTfPQf0oCImEXrK+iHFv7g/WbXoZdJXJzHz+aVUK/6WXK1T8jOPjGBH6U7TzFNK3LzsSW8MKaUU+NAjMygs9K648+WdWCHr+bi1ltYKYFqyfUFtpnxVbv+WWqWzhPsPL6uuc57OoyltYjts7oUcLTq3c8iL21kbTO8Oo9zY7iQOl0Gsdx6n2tOTj11FMb7LDQWEsI2A3BdeGFF3LllVfys5/9jHXr1jF8+HAGDRrEQw89xLp163JdC5rWoecfZ+LELGIRl5qMTTrl0LFdpTLtBKK2R0V1VHlAxVxs28f3DcBTBeDVjvolJSBekKJKCqRrYMZ8ZMRXAkuSG5MjXQPh+CDAcjwsK8DK86ncFKd39/WkPYu4nSHtW9iGz4HxLRxW8DmBNBgU+ZKUtDk8tgqHAFsERIVFHzvGh5kaNgQWxbbkAFPN7FzvV9Nl//+12r3V7Bl63j4P2zFUVAtVn2WmJANvSKjh2hMSLJ9ZmnsOanRQtFrgx9S8z8gWVeM1YFJCF9G3YXreMQ8ccLYYCE8gAoFbKMPxXtA7MR8/FuBsNlk+oZR+M5WHnOWJHZqgAvR8cBay0GD1FWMZMEkJqP5TExhpZba79M7a6NgxF84HCXZNwL9WJzj+nLm88kTDJzBomo8FCxYASszcc8895OfXurP5vs/ixYsZMGBAi1x75cqVjT4mG3hqKI0WXO+//z5HHXUUAI899hiHHHIIr776KgsXLuSqq67SgquV+MGrv+Sjr/ejoCggYnv4gSBme1jFVVTURIlFMkgp2FIZw7ICTFN5SQkh6VxYhRsYrF1fjDADrIiH4/hUbs6juH015ZvjICSFhSmSaRvLCnBdk8J4imTGJmK7VNVEicfSDOz4FVVuhOqCKrrmlVNsJ+nsVLLZzWNI/HPiRob9rc10MpP0tPIwRYDRZRXBOhWzWulW0cn0GdT9S9Z/2Y3CbrUCq8uO3rxmnyK63sSLSz6eHBqtTi/Jiau+s8r4dKb6sAzMrdztJbiFyhZC+Oo1q0aJtebsxtQ0H//36REI/0KkgEwH1Uyz8lejVPTpzlJ63jGPldeoKFSfuWX0LpuPjNd6tm09GH1r8Q0gM0psAWSKAgbekMDyVb3fkGsTWCmJmVHTLUyprGzcuKoD3VZsuWv7YHfdtdnmHkGGj6aeo42SSChxLKXkrrvuwjRra3Adx6Fnz57cddddLXLtHj16tMh5t6bRgst13dzMpeeff57vfve7AAwYMIC1a9c27+o0DeKUF0dRYJt0b7eZpGfTKVbFsq+6UJ2M4GYsiouqqU5GiEVcAtsn6rikXZuo4xIEBptrYgDYEY9IxCUeyQBQEEtRmYxSUFxDx/xq0p5FIAV5kQyFRWnidpqvagroGq/AaCfpFiunT/Rryv0YNb5DkZXElwZRw6Vv/lcAmCIgGvb0myKcURXWVKXX9qbPgbU/Q511NOubiYBPx5Wq6FR2HE/4IZH1DhtyXQLZgZwoExLMGkh1UKN8ls0pydWAiQAOmlbGJzfpjrS2xJhnLmDVr0apjsRARTN73TYfs3vYJGHWKgNluCuUZ19IVmz1n5qAbWqhV18+lv5TEljVELGNnBgbelUZXkzgCTVjc+tI19Yc/4O5vPK4El5tRmyFNDmlSNtNKWajTKeccgqPP/54gwvY9xYaLbgGDRrEXXfdxZlnnslzzz3HLbfcAsD//ve/Bs1I0jQvI1++nk3VhcSLVdquPBkl6do4lk88nqQyFaE6GcFxPDrnV5H0bMqTUfKjaZIZm7xIBkNIkhmbnh03kfRsNlXncUDxFmpch0P3+x+ZwCSQgoxlcXC7rwikIOnb9I5voFO0ikIrxRHxVRSYSQ60tmAiMZAcaBl86goKDJeOpkll4LOfGcOVgjyjNlScramKdP2stW6jpo3Qf3ICt1B90PpO7QeuNOvu985vShgwMaFmMgpUhCs/9GiSquDej6qI14fT1b79pyR0B2Mb4aBbEpgRg163zUc6qiki25zjFQbKfytj0nt+GdKUmAhWjCmlx91z6PG7udibTT4dX0qfOWWsmBhGPNf145AFV+NHwBxSTmAXIgKBmYHDrinDjQsoEiybvf3PwHHnzsNMByz+u4qKZcVWW2N3jUu3PUdbZ9GiRS1y3rfeeouJEyfyj3/8o0XOvysaLbhmz57NOeecw9y5c7n44osZMmQIAE899VQu1ajZM/z89Z9jiAJSGZu1lYVELI/e7Tby8YbODO68lrf/dwDd2pWzoSqOY/nELJekZ9O5oIrKdIRvdVlDte/wVU0BdlSNvgEozlMGnu2jNWQCkx55mwCIGB7t7GrOyn+PYiMgzzApMmLbrKrun5qHRcDo8jnBun4Uhc4NWauGtmoIqmkdDr4pQRCXOBXqL/DIZsGg8QncOGQbYA+6JYGRUd2JhqvqtCD8V5Cr/fEjSmxZSThkdELNx3R1TVdL0uN3c3daV5Vl5MvXk+nRFbHZRvhgVxq4+WrovRpg77P68rH0LpuvPAAB34A+c8qwsHDKlR9b/6kJbF9w2DVlVPYAxC+hWOYMTvt9UIZbCIElSbeH5RO2/74fcXkZVkpCRIA0OPGsOSz+x74z7Hpv5osvvuCpp57i888/J5PJ1Hkt6/ZeH8899xwLFy7Etm0uv/xyevfuzUcffcT48eP5+9//zvDhw1t66Ttkt2whfN+noqKiTrhv1apV5OXl1Tv/aG9jb7CFGPjkZPKjaQIp6ByvYnMqxsB2X/Hh5v3Id9IYQmIZAeurVSQpu58hJF/XxIlaHoaQ9C7YiG34xIwMVX6EbpFyVtR0JN9SP+Dt7Wq6RzYCcFh0Nf/z2vH9eNV26zG6LM/VYWWfb0uwrh8b/OpcqnBbewbNN5eDb0ogTeUSP2BignT7gJW/HlXndSuphFUQRrukSR0jVD8WRkoCNe1AiuxYKnJizEyrfb08cgXUmj1Lj9/NVdYxrqH+DW1pCEC4Bma1gVUj8OKSwJZYNQLD/f/snXd4FOXah+93ZrZvKgRCTULvWFAUC2LB9om9Kyqox670JkjvJFiOBRVBj3o8emzHhtgFsQsivSShhRLSt+/MfH+8ySYhCSShCntf117Jzk7bzWbnt0/5PQK9dOxY2cSBUKwZWU+EAQEXX/wriz7rgWGVo8P2tZToMjQDU4NV0wfRZWgGf80+NH//I2UL8cKf39Pwrv87qP0YXj9ZAyYf09e3L7/8kn79+pGWlsa6devo0qULWVlZmKbJKaecwldffVXtdgsXLuSuu+4iMTGRvLw8GjZsSHp6Og888ADXXnstQ4YMoUuXLvs9tq7rLFmyhG7duh3ylGa9nOZN0+S3335j06ZN3HLLLcTExGC1WnE6nYf05KJUT+8vh9I41qSB3cNOTywhXV6B/spLRjcU3JYA20viaOIqItHhxW0J0MhWQlHYxmmx2WzwNSIv6MIbtrDLH0OqSwqqFHseG7yNaG4vIMHioTDs5Fz3WuxKiFStBN2E06sRW2Xs622173IleQONalg/yolLu0kZrJ8sL3ydR2SwtjTl02VoBrpNWkIoJoScpf5bmvTmshQJVL3Uu0mTQ6vLUAKg6FJ0GRaweGDlHFl8H4w3Ix5OZRfdTqMzMNTK7vttZqaj+kQ0DXkISX1tGkqMSeYto0l7YyqZt4wmZd4slGIVw27IMWJuA1CkiLJKga2E5LgwzSv/xqFYaRcSdpo4dwg8TWVn42df9MCsRmy1np3OpqGDESboGnQemcGqUrF12p3p/LJgMGfcMgdLiYHFE8awKHzz2YhqnsFRxqTcjK7e+zh2a7jKGDVqFEOGDGHixInExMTw3//+l0aNGnHrrbdyySWX1LhdRkYGU6dOZeTIkfznP//hpptuIiMjgz/++IPWrVvX6tiqqnLxxRezZs2aQy646jy8Ojs7m65du3LllVfy4IMPsmfPHgBmzpzJ0KF1M5EbP348QohKt+Tk8l60fR8ru82aNavGfS5YsKDabfx+f12f6jFJj09HU+SXTQuFAQfJriJOTdzCaUlbiLUGaOouojDoINYawBOykWjzkmwvwqNb8esWNvgaETZVFGHQt+FqusVtp4U9j9PcmVwZu5z/S1yBRdFRMfm/2OWowsBvWGioWEmzuKs9p32jW2XLKv6MEqUm1IAcnt3hiQwq+NuWzueUESxhyPQgyC5ES5GszTFVGcXSvPIx3V5unhmMlfYmSlh2oYG81pSJrbZT0zGs5cvXTpJdkCBrwDYOHxwVW4cYU1cwgiop82aRectoUl+dDlZDCimLie42sOaqqAH5d1YCAs0rMCwmqb224muqE4oxI00UwpC1e5q/dEarxUR3GpgCUp6X14nWs9JRArJbNRgHYZfJqunlf9dfFsj3w49vDOH7D4cdu2LrBGLNmjXccccdAGiahs/nw+12M3HiRGbMmFHjdps2beLGG28E4LrrrkNVVdLT02sttsro2rUrmzcf+priOguuRx99lB49epCfn4/DUV6/c/XVV/Pll1/W+QQ6d+5MTk5O5LZy5crIYxWX5+TkMH/+fIQQB5w4HhsbW2Xb/Vn6/1048/MRdG6wk/OabgTg/5JXkmwvQkfBInROTdzCyfFbubTxKpq7CjgnaSN9EtbSwp5H95itXNhgDa0ce9CETjvXbkKmRmNLEV7dRivrbpb6WtPBuotxDVfSw7mZM+wqFzh0+jpDOJWazeaqc26HmiNeUaJUZM3kQSg6YIJaoVRj1cxBKOFS0RWUkS41INcvE0prJw6SKURNRrLWj5XblA25NoUUYcE4eYWumEJUwvIi3X5iBqE4kw7jMgjHymKxwzUb8kQm5cWZWBwhFKsux4EBWf1HouZpYIItR8OSpxKMNyI1eUoYdLuJEhRsXNkczaOg2010h0nYaUIbD77GBqEYA9NiYthNVK9MUWbfV1pPJmDDmMEYNpN14waxYVTVzsTT7kynx4B0TrknvZLYuiTpH0fipakTZYXzB3M71nG5XAQCMv/ftGlTNm0q7xTNzc2tcTuPx4PL5QKkc7zdbq/XtJspU6YwdOhQPvroI3JycigqKqp0qy91TikuWbKEpUuXVnF7TUlJYfv27XU/AU2rFNWqyL7LP/jgA/r06XNAK/19I2XHA9csvZ928QFaOvIIGSqaMNjkT6KVYw8WoWMROoYp2BJoQENLiESrh5Cp4jVs5IZi6OzYRjNLPh7DxhmOTWwPJ9BALSFJ9dDZ6kA3VVppGzCAIsPPufbapYfLolsVRVbFiFc00hVlf3QYK53i10yXNg66Tc7IMzQZ2Vr5pLR9KBNiIbec86gJKbI6jcqIiLKQW943FRkdKZutKEcDye3bTklnwxh5wS0bgNxucro0WRVg261WOreKKcb246VHkO4w2Tii6kW79az0SrP+opSTsnA6orQA3iiyIMKCVulz0ON0iAVLsYVQrIESFFiKBKFEA61IIeyS430Mm4lSGsVSwrKeSwmBudmFGadDUMVw6FgKVAyriX1n+d9x01D5N9mfLUhZlOusa2cDcF7f6dj2eFm0Rw6jv7TZw3y6/elD/8LUh+PYh6uMM844g6VLl9KpUycuv/xyhgwZwsqVK3n33Xc544z9zwJZtGgRcXFy7q5hGHz55ZdVJt+U2VnVRFnasl+/fpUc5U3TRAhR79FCdRZchmFUe7Bt27YRExNT5xPYsGEDTZs2xWaz0bNnT6ZOnVqtoNq1axcff/wxCxcuPOA+S0pKSElJQdd1TjrpJCZNmsTJJ59c4/qBQCCipoGDUrCHiwY2D9u98WjCIGwqnNEwkzXFyVwSt5KfPK1pYi1AR6GZLZ/8sAuL0Okbs5ICw0ljSwF5YTdLStoTo/rBBs20fOwijIJJwAxhExYaqq46n1dNhe9RgRXlQHQck4Fiytl2HcdkIIC/Zg2S9TXT5bIysWVoRNJMhrXU4LQ0nbR+7CA6j8gg5DaxlEhbCMMq19Vt8oLbdkppV5Oo6slV04V4X7PUdeP3H/WKiq3qMXa2xWK/g1ChjZBPQ+hC1lK5DSx7NHS7Schtovpk96EeY2I6wxh+C5pXIRxjYGvugRWxqAEIxpgIXRB2mhh2g+z7hpHy4syI0WnKvFkEhXSp3zxo/4OpTx2Yjr+BiAxq98crcsbi5yMrrXesiC0ZoTr+R/ukp6dTUiLrhcePH09JSQlvvfUWbdq0iZij1kRZKrKMf/yjcpSyNoLpcNlS1LlL8cYbbyQuLo558+YRExPDn3/+SVJSEldeeSUtW7bklVdeqfW+Pv30U7xeL+3atWPXrl1MnjyZtWvXsmrVqiqeXjNnzmT69Ons2LFjv+nBH3/8kY0bN9K1a1eKiop48skn+eSTT1ixYgVt21af1ho/fjwTJkyosvxY6eK459f+2JQwnrCN/KCDZEcxDiVIwLAQq/lwqwF6ujYSo/gxTIUCw8nOcBxJWhF2EeJXbyt0U2aPH0xcDsC2MOgI2mgKTsUaEV0Horp6rYrLo0IrSm1oOyUdi0fOzNNt0gpi1QwpnIQBulUKKlHqrL1qxiDp3eSXacH24+WwamFKUbXuiTLRBaYmL96URsGEIeu6ytKRZYOPO47JQHfIdcNOE1u+wN9IFtRXjITVhpR5s8i+t3pLhLQn51SZ5XcikfLKDIRXRfUpGBYT02oiAgLDKf/Aik/FsBoofgXDboDNgIAiOxYDAt1lIIKlnYouWVhvKmDEhsm+awQpr8wg+67yNGBF8QXy9dc8ImKUWpEeA9IxNLB4TLSAydJ3yuuQz756FkrYRPUZFLSx8sfzNb8fjlSX4vPLv6fBHfuPzhwIw+tny70Tj5nr24lEnQXXjh076NOnD6qqsmHDBnr06MGGDRto2LAh33333UHZQng8Hlq3bs3w4cMZPLjym7tDhw5cdNFFPP103b5pGIbBKaecwrnnnhuZ07Qv1UW4WrRocUy8IW9Y9g+CusoFDddSGHbiNaxs9jSkkb0YFYOCkJPO7h0U6g66ObbSybqTBqqJU6h84GnGKbatAHzlbc+NMWt5q7gD17jXEKdYUYXAb4bZpRvYhUkT1RHxyNqXMiFVU3F8lCj1oeMY6QZfVrTeeaQUUmG7FFYdx8j7kXoea2k9lyq7EMN2aQEh7QIg7Cottg+XF90H46R9wLonpNhSvaJStKrdpIzDMuS61Zx0DKusP9o85MSMfqU8PwslqGAqJkpAQfXL6GM4Rqb/hAlhh4lpK7WFSAhi+GRNl7AamMHSMmMB6ALhDGN6NURQYDp1sgeMoNWbUysNxW41Jz3yeredlo5e2rWY9XBl0dt1cAYr0wdxyj/S+f2Fqn+fUwem89vLtfu7HVHB1f8QCK5/RAXXgSgoKODll19mzZo1CCHo1KkTAwYMiKQr60OdU4pNmzZl+fLlvPnmm/z+++8YhsHAgQO59dZbKxXR1weXy0XXrl3ZsKHyRfz7779n3bp1vPXWW3Xep6IonHbaaVX2WRGbzRYZV3QscdOye9GEide08n1+WxRMEq1eTo/PJGBYyPY3oLN7B90d2cQrPraH47ELA92EX4NOGqglbAg1xEDhNMdm/KbJZa41FJuCJqVRrTxdJ0934DcttCxzl9wP+wqvsqhWNLoVpS50Gp2BbgVFyAiV5pNzERUFwg7AhC7DMhBaqcu8gHDpp1XZ48F4E80jUIKysDrsFgi9VHi55bJggonqFeiOCmNizMr1WevHDiJt7pxKvl8HYn8ireIFH2GyeciJGd363+auoPTHiAkjfCpKGELxBqpPQQkohJsGEfmWyAgf02JCoRWcYQio0gtEgLDpmGFZCG8GFURQkPVQeSSqotgC0GPK00WGRo1i11TglH+kI8KyaF4NmPz4ZvnfqrZi64hiiuM2pZiQkFCpXmp/5OXl7fdxwzBQlKo9gYZhsG3bNlq2bLnf7X/99VcuvvhiHA4Hp59+OqZpkp6ezpQpU/j888855ZRTanWe+1IvHy6Hw8GAAQMYMGBAvQ5aE4FAgDVr1nDOOedUWv7yyy9z6qmnRlzt64JpmixfvpyuXbseqtM8IoxdeRWXNNjFen8TsrwNMExBXsBJI3sxTiVIU0s+caqX0xyZbAol0dZSSLyyG7sAixAkqR4UTDpaZfF7oRGm0IBduoMk1UdOuIRE1UZzzUFLTQBhQMFrBKvtSKxYBL+vx1ZUbEWpLZ1GSesHwwaavzRiFSit0QqCXprV1gLyMaXUZ0u3ymiVYZWCylSl75ZhlcX1qk+aYZqq7ErElILLkaMQTJBpwvbjM9g4fnAkpVhG22npZI6qnShKfXoOWQ8PiYitVulzEIZg09DBtJ6djmExMWIM6ZJuMysJgxONhxfdIdPCLh1DQNgAxa9I2wabgSi0YGpSVOEKQ1iQda9MDabMm4VZoqHFB1FUgw23jZWF9xoQFwIg9V/TyLptVJXjlqV2U5+ZTdaw8te/zcx0tBIho58C1uxjenrGLXMOzwtxqDlOi+bnzp170PsoKiri7rvv5n//+x+xsbHcd999jBs3LjIEe8+ePaSlpR2whmvQoEH069ePF198EU2TMikcDnP33Xfz2GOP8d1339Xr/OoluF577TVeeOEFNm/ezLJly0hJSSEjI4NWrVpx5ZVX1no/Q4cO5YorrqBly5bs3r2byZMnU1RUVKnoraioiLfffps5c6r/Z+jfvz/NmjVj2rRpAEyYMIEzzjiDtm3bUlRUxFNPPcXy5cv55z//WZ+netRYUdCcbbYE0py5JFo9bCxOomv8Dto6dtHNtpUfvG1RhMGnxd24Oe5XFKC1xV2hAB62hWXR4Zqgl45WJyp+NphWzrBUTRtuC5ewQ7dxuq1m+4eKoqqm36NE2R/ClKKoYkF6Wd1WyCUL0zuNKu0GtINR6r9VZg1RNrZHLY1qKWEhI2CmfCzsMtFKZETLkaMQdsmRMe0nZrBu/CBS5s3CGpbv/7Li+Q2jSmfyDT9wRKNiWqr1rHRQ5ZDlNqXbp8ybhepR0F0GlsLq0/MnAinzZCrRsBkoO+2oiin/dgkhGbXyqVJ4Ow2UEhVTMaH075IyfwbCbmIGFDbdNCayT9WmoxdZI4KqOrEVOf7LM8l+SNZxldVwKQYgZIq5ui7TH98YwrmXz0SY8O0n0fE+R5p9i93rw9ixY1mxYgWvvfYaBQUFTJ48md9++41333034qxQmyqqX3/9tZLYAumoMHz4cHr06FHv86uzD9dzzz3H4MGDufTSS8nPz48oxYSEhDor1G3btnHzzTfTvn17rrnmGqxWKz/++CMpKSmRdf79739jmiY333xztfvYsmULOTk5kfsFBQXce++9dOzYkb59+7J9+3a+++67v82cx7c3nspNy+6lU2wONlV2EcZqfjrG7uSmhJ/obNtGoupHEQa9nBvo416NAuzSrawPeSg2yo2MmmvSqLQsyuVW7HS3FqGbBvm6N7Len0FpCnu6rfqi+ZqsHqJEqQudR0rLBlORka4uw0q7EEs9iS0lMlVnKrJb0Voo3cXL6rVCblkAXxYRU3SZQiwb8SNMwCi1gQjKwuqw08QU0gKiwxMZOLZqKCFBh7EZke7EtlOkWGo9q+b5bNWhJwdQwiLSCZf21BxEUN4XIVEpinYi8U1WW1BMjPgQSkDB1EwMm4nhMMCQXaSmamImhlCdYdRkH4pmgGqS+to0zuy4iaz+I8FqkDJvFmlvTJU7NoUcBYSMbu0PEZCXttSnpdjSSytG1k4YVK3YgnJLCBE+cGnF0UUcgtuxzZYtW/Z7q4n333+fF154geuuu467776b3377jdzcXK644opInXZt0paxsbHVHmfr1q31cmMoo85F8506dWLq1KlcddVVxMTEsGLFClq1asVff/3Feeedt19Tsr8LR2uWYu8vh9I9cTuesI14i5ebEn6i2LCTqHrJ053EKH5OsmqE0dFQea04mQudmyPCqoxc3YOKIDusclJpbdq2cElkvcxQCWkWd+Rnvu4lQd2/71ZUZEU5GNpNTi91DJciCmRh+6oZpYXyATnfEEqjV1ZZNN9hnPTZWj1VdiGaqhRgpiYjX0akrsuUAiwkBVjZYOt9i+OFLh9bM2VQFZ+tupAybxZaocqmYYMjQ5ZVr4JuMzGtRq2GOB+vpCycDj4VYQiZMlRMlBJVGtQ2DGH6VdSYELpPRbHpZN46OpKqTX1tGlm3j6LHp6P59dKpdHh3AmuveYLUV6dj+lWsCX42XD9WpgsPkK5NmTcLxa/IdHOYKl2nPQakE4wV/Dn34BsmjljR/O9LSLy99lmk6jC8frY+MP6YLppXFGW/wqimlKDL5eKvv/4iLS0tsqy4uDhSj/XSSy/Rpk2bA6YUH3nkEd577z1mz55Nr169EEKwZMkShg0bxrXXXlvv9GedU4qZmZnVelrZbDY8Hk+9TiKKLJBvExvEE7aR5silRLfxiy+NTvbttNEUCpUi7ELhfU9DTrHtIM3i5jr3FrLDKs2pLKjK/LQSKmQ0KoqyshE9ZT9rEltRkRXlULH+8cF0Hp6BEKVRqqBMDXYemUHYDmqFWLthkbfOIzJQK34dNKVYwpS1XiGXFG0YSIuJCqnK9uMzMGwmHcdkRIruFUD1SQf7dpPTWT9JXoDbzEivMepREyIk0J0GaW9MxXBZwK4TdgEBFe0ETyViqqjxQXSfBiEFYTWIb1tI3vZ48Kk4krysveYJ2vxnEuGARqt/TyHr4TGkLJhB9p0yTVhRbAFYHCE29C/3xtKSDjyqLfveYaS8NJPMR4bT4Ymq3k2/zj8xI5B/B/74449K90OhEH/88UekcL0mWrRowZo1ayoJrpiYGD7//HP69u3L1VdfXavjz549GyEE/fv3JxyW3xAtFgv3338/06dPr8czktQ5pZiWlsby5curLP/000/p1KlTvU/kROaOn2XzgUMN4tJk2LNv7F/0cm4iVgRwKlaaaG4SVCe97DsiQsmt2OlslZ2h+0a56kJZyrDi71GxFeVQ0XlEBp1GZZSPawnJKJUwZLTLWixNStWAfEwJyvthh1w/7JY1WLpNRrRMVaYIhS5TRGWjfUyNyIV13fhBaB6BYSsd/xMu3Wept+/6xwfTfoJctyaxlfqMTDGlvT618vLXpqE19ENMGKHICA6GQLPpqCXKCWuAeubnIxDOMMKhY4QUhMUAzUCx6uTlyjSM4g7h98hamrDfglBNNpfWaWXfWXl+YZnYAthw/dhKj2288fEazyNlXvmsXbVYpc2MdNZOqDmKdeZNf5Ni+TLMQ3A7xunevXulW48ePbjnnnuYPXt2jfZOAH379q3WC9TtdrNo0aJaj/izWq08+eST5Ofns3z5cv744w/y8vLIyMg4KEeDOke4hg0bxoMPPojf78c0TX7++WfefPNNpk2bxksvvVTvEzmRySpOpF3cbrZ54zk7cRPdHdnoCLyGBXtZ/qWUJgchrPZlX1EV7TiMcqjpOCYDTTaVYaqlN0VGmboOzpCO8KUiy7CWem3ZZM2W4pc+W0qg3AQ17ARLsdyfEpZjfkKJJmpQsG7coMj4HZAmpx3GyfsVZyi2n5jBunGDahxMnTJ/BtkDRkRSVpm3jqbVm1MRwmTTTWMwfRohQ0BAxRXvpajEgppnQbepZA0+MS0gAHJ2x2N6NVlnJSD7jpGkPD+LzQPGSHPSfYxhs/qPrGFPB0fZcdJen4rms0fmblZH90cyWPHvv9PfrNS07mD4GwiummjXrh2//PJLjY9PmDCBHTt2VPtYTEwMX3zxBb/99lutj+d0OiMm6p9//jnt27enY8eOdT7vMuosuO666y7C4TDDhw/H6/Vyyy230KxZM5588kluuummep/IicpFXw8iwRagvXMXZ8VuIDccS8jUONdeXGrPcGjSE/sTUVEvrSiHCzVAZLahKcrFU7dHMzBLR/QgZApx1YxBdB4ujU5NBSwlJn/NGhxJCxqqtITQbaUzFE25nRoUmIpJ26npbBg/mI6Py2iatRDWpg+i7ZR0VL9At5tsGDM4MkOxjDKB1eHdCRiGIHvAuCrPo8zrqe3bk2jc0ktugRth0ynaGYMIKOjx4Uih9olIykszQVNwNPTiL7FhGoKUhdNxJftJfW0a6KUdiAunk33HoRdabd+eVCkK1ip9DpmDy/25apoEsOKpyu+Fc/rN4vsPh9XJ9PRIciiGT/8dhlfvO17PNE1ycnIYP358jRNjQDbvJSQk1Ph4fn4+CxcupHfv3vs9/g033MC5557LQw89hM/no0ePHmRlZWGaJv/+97+59tpr6/aESqnTJ0Q4HGbhwoVcccUVZGdns3v3bnbu3MnWrVsZOHBgvU7gRKbnopE0dRVySvxWFGGwJdiQhloRp9jyqvXCqi8VB0xXHDQd7TqMcjjp8ISMYIWdpR2EAIqMcoWdUoCpfjPyhb3boxnojtJCeBP+eK5UbJU6x5elhTQPrJ42SDqIW+S6SqDq6JaV6XL9DWMGE4qTYivtycrpo5SXZ5I9QKaymsQXYRiVowc9F42kw7sT6LloJO3/OxGrNczuPbEYe+yEi0rbzGNDoJhkPXBiem6lvDwTe4IfwgJfrhOhGrgTvGAKvMU2VItB9t3DSXt9Ktl3jOTkj8cceKd1ZN+U4+bSSGOrdPn3rmnsUufhMgLa63qZPv7+Q7nesSi2TiTi4+Mj4ikhIYHExEQ6derEsmXLeO655+q937y8vFrNY/7uu+8ifqDvvfcepmlSUFDAU089xeTJk+t9/DpFuDRN4/7772fNmjUANGzYsN4HPpHpuWgkreP2YtfiaGIrRMGkrW0nyWoRO/VYGtVjiPT+qO04nqjwinKoSHt9KnbdIcWUKeuxykbtKGFkLVcQDIuQo3ycMqVIqXnp6mml3YsApZ2HXYdksGqO7C7sME5GwnQbWItg5ZzySMWayXLuYuvZ6egug6z7h7JpqPTIyn5UXlBT5s3C3sBH9sBxnP7ZKH6+ZBpxVh+BeI2TPnocq6bjDVrweWPQLDq7dschVBP/XgdCF6h+QdhuStXoV0/YrkRjZ1uEZSCmCa6GXryl0a2SfCfZd46g3TsT0Uv9tZo1KgDgj8trLno+1GzeJ8Xbdlo6SkCKaosHnLtNet46B6yCnrfO4afX/wbpxePU+LQiX331VaUuRUVRSEpKok2bNpW8sQ4XhYWFJCYmAvDZZ59x7bXX4nQ6ufzyyxk2rP7/63WOgffs2bNKB0GU2pP62jQsikFRyE5jZzEhUyVG9dPJkkuMEqKtZe9hO/a+Y3miAivK4cK+xiEjTzpYvPLipvlKzUw1IgXwIMWWEpb3NZ9MP3YeUSqoLLIYXugQLLW/WTtpUMR/a934QYSrqYPVbaacxxesELEyyv2bbIk+GsR4OPWTMTgsssjsr+1NaejwEOfwE9IVTmq8ncaJRQhhYnOGMAIqtkQfptVAdxtoMSEUn4JWfOJ2JaZ9ejdmWBD0W/AW21A0A3ecj6ZN8+j1+QgMQ2CxyjrUrdsbHNVzTX16jrQl0cGwmARjIRgnCLkFuk1ExFbvy2Ye1fPcLyZS5B/s7RjnvPPOo3fv3pHbOeecQ4cOHY6I2ALZ7bhs2TI8Hg+fffYZffv2BWRKsraF99VRZ8H1wAMPMGTIEJ555hmWLVvGn3/+WekWpWZO/ngMnVJyaO4uwK6G6BaznTPcm2hsKaCpZqOdxUU7y6GNbkFloRXtQIxyuGk1Jz0ipkIuGd0yNCIdigg5jqfMrsEiByJEIlarp8lolRKU439MIUVXmadW5+GlqUqXrNvSHfInyPEtqc/ORnca6E0CWJpJq5ru/xuLJdFP1m2jSP3XNAJ7HeTkxuGwhPAErdz200BaNc7FQNAubjclXjs53ji8QQt+j5XADhcEFQKFdjlEOSgIezUMu8GmoSdm+qnnopE44vyoTtmtaYYUTF2g6wo7c+P4oe8MNt4wFptFCq59uxDL6Pph1Zq5inR6f3y9zi9lwYxK97MeHiKFugU0n8CWXyr+LXIsVI+70ul527HdsSiQ6fmDvR3rTJs2jfnz51dZPn/+fGbMmFHNFoeWxx57jFtvvZXmzZvTtGlTzjvvPECmGg9mTGCdjU+rGwgphMA0TYQQBzQU+ztwOEzszv1iGIl2D8UhO61icmnv3EVuyM0FsavYHkrgOveOQ1q3BdEIVpQjT/uJGVBq1C10IrMOldKieTUgo1llI3osxSahGDmeR/XLmixTLS2w10sL5b2l8xGFHFit+gSGxUQJCdY9MYi209Ij43nCjYMQVsgeOJw+Xw3h6/PnkDJ/BrbYAHpYRc+3ybSlVbqeq3FBdK8GYTkUWQkJDJuJJV8hHGPK0TQ+BWESKbzXnYaMnumCrAdPzLotY2dbWn0xADOsoFh0VM3A5Qzg8VnZeMNYOrw7gWBQQ1EMwgGNrNtrHsNzuGmVMScyDSD1mdlYihQ5XigssBaWprhNUIMmlhITa4lBMEbh51drn148Ysanvy4l8earDmo/htfH1seeOKaNT1NTU3njjTfo1atXpeU//fQTN910E5mZmdVud8011+x3vwUFBXz77be10im//vorW7du5aKLLsLtlu4AH3/8MfHx8Zx11lm1fCaVqZfxaZS60fvLoYQNlZaufJxKEKcaxKaEaGnbi0sEuTlmF4VGCIupYhGHvysxSpTDheaVVg4IoLTY3VSRdVhWGe1Sg6VDpq1gaAKLR0bChFHa0RgGVYdgnOxqNFUIJpjSSysEhtVEhAUI6R6vl/r2bho+mJQFM4hvVEzXD8dRlNuILh+OQ7HZWX/dONLemErW/UNJfXU6AtmtpXs1hGaCNQxhC7rLQDjCBK0qhAXCEBhOA6wGhmZAgQU0E2ExUPYc2i9Ifyfaf98fmyOEwxZECJP8PDcFPnckirX2mido985E1l+3/+jVkaBMbLWemY4zXyWYYOLcIacehF3SZsRaaKIFTHSrwFQEIafgrOtms/SdoZx8fzqGRYABK545eFf6g+Jv4qN1sOzcuZMmTZpUWZ6UlFRplN++xMXF7Xe/cXFx9O/fv1bn0KNHj8jcRF3XWblyJb169dpvF+SBqLPgqjjnMMr+GbniWj7d0on2DYtxqUFUDArCTprZ8km17qGtZS/tLC5ydU/EHT5KlL8rrWelY1PkOBdhCHSrHC4twlJMlUUSyqJZZeN8wg6ZVgy7StOHilx/3TjpoyWFl8BSDP6GphRrCWGse1VCcQZZDw2VY1y8CsTCiism0fbtSTgTfCQ6fcQ7/Jz7xTAyb5GGmHZ3AMMQxDgD5Be6SIwvocRnw5VYQu6uWBSLARYDI6xgBlTQBYQEzvgAXhM0i0HYr7F5yImZSmz79iRU1cBXaCdk1xBCNg8oVp1Wb05l882j6fjeeNZfN77SNvt2Eh5JWs9MBwUCCSb2PEEgERy7TCzFEIwXhJ3lQ9ADcQqGVRC2Cbo9msGfz5X/nS88ezJfLKnZdPXwcyh8uI79Gq4WLVqwdOnSSo7xAEuXLqVp06Y1bled6Wl9eOyxx+jatSsDBw5E13V69+7NDz/8gNPp5KOPPoqkGOtKnQXXhx9+WO1yIQR2u502bdpUeZFORM5ePBzDbEPXRju4MGE1OaEEmljyiVe99HPJwdG5pVHN+oqtigOlKy6LEuVoYC0QMm3okw7vql9GoZQwhGJkQXzZ4GlTlBqd6uXCy1JCxOpBt8muRGEHS0DeD7vl+oQAVEKxJkIXpLwwi+x/DCNlwQyEZpAyfwYNk/3YtDDN3QU0thUxp8nvGDvfZ1u4hPNTLuCnXSkUlthJblCIN2ihUWwJbmuA3N2xciRNaXdlQuMiikoc6H6ZHnPF+vH7rNjcgaP7Yh8l1m5tit12N4YpsMcGWHdteQSrzVuTUVSDTu+PZ83V4yttd6TEVvf/jWXFFZNI/dc0TJ8KVgMl34KRqOPMsmApASUo09LBOIHqlzYjQpfRLQTgN3HuNjBU+PPJQZx17WyW/lemjo+u2DpxuPvuu3nssccIhUKcf/75AHz55ZcMHz6cIUMOfyfpO++8w2233QbA//73PzIzM1m7di2vvvoqY8aMYenSpfXab50F11VXXRWp2apIxTqus88+m/fff/+gQm9/Z/p9/xDJrjCNbLIauJkln5Ps24gRYZprDraFfTTX3BGhFTBD2ISlzsepKLaqE19RohwpOg/PwHCVjuUxpIgCKbB0OzINYpRGsNTS+i2PTB+GXeWFvLpNFsqHXFJ8mRoEYkwsxQLdYZZ2Hwo2D5GeWpmPyg/flIXTwa+Cy8DiDlJY7CClUR7/Sv2m0peQ5jvbMqTRl8ziQr7ytiVsKDSNLaKlK5+8oJM2KbvI3NWAWLcPhzWEAAp1J/ENSrBoOmFdQXEGWNlv4hF9fY8VrvjxfkwTNt4wltM/K6/Lavv2JDbeWC6qDpfBaXV0+XAcfr+FGJefwgI3bd6aDMV2qZl1geYVBGNNNB9yDqdNyM7XsIyuKhZACLTS5g3Nb6JbQAuY9LxtDj/99xir0zsBbCGGDx9OXl4eDzzwAMFgEAC73c6IESMYNerw1wPm5uaSnJwMwCeffML1119Pu3btGDhw4H5HCx2IOncpLl68mNNOO43FixdTWFhIYWEhixcv5vTTT+ejjz7iu+++Y+/evQwdeoy9SY8Ql333CDtKYomz+EmyFtPKsQe7CLEzHEOiqpKr+0gsLY4PmTo54RJswkKuXnXwd8AMVXuMA/loRYVXlCNJ65npCFNGqMyyr3Ci3GVeDUhBZVhkVEvzlXcfhl1yXaO0pkvRZdpH9UuhpgTBsJmEYkxCbnml0GP0yJxDgJTnZ+GM9eNK9pB1+yhMQ6FD010s7vg/oOr/Q5rFzSXxf3JFm7+4tNlq7m/+NQomDa0eGjuKSUooprjEwc7cOAp9djq22ElDt4dLm6+meVzhCSu2ylKJMS4/J388ht17yguu941gHYzYavdO3V5fT4kdQ1cpLHaCgFCxFSU+iOJVEGGZKnRkW9GtoAbke0jzmKhB+b7UPBUiriETX5JCMFbgTVJQQiYnPZjOaXekHxszFw/FHMW/geASQjBjxgz27NnDjz/+yIoVK8jLy2PcuCNTE9i4cWNWr16Nrut89tlnXHjhhQB4vV5Utf511nWOcD366KPMmzevUvfABRdcgN1u595772XVqlXMnTuXAQMG1Puk/s60idmDIky6ubeR5W+AgeAHb1va23L4yR9LA9VDoirI171kh1XiSiVvdWnFmqJeNaURo6N5ohwN7LlCpglLjU3LPLKCcbIgOWyXy4RZPpDaLLWIWDWj1OC0bGSoAZZi2aav+eR9a4GCP0lH8yhsHDGYVhlzUH1yHQA0E1U1+KvfRM78fAQtG4X56Jyn9/v/cLmzhPf2urm18Y+kaDrNGn7H6/lnsKawMU5LiIvarmV1fjJFfhtZeYkkxZTw9c525BafuLWWqmqgaTr5+W40i45pHJ5aoAMV2pfViQF0eHcCifFBmsQU8dE5TwOQ8sIsdL8KCSGET0UYUvSHHeBtImRa21Ya0TLl+xQho6qGJgjGm2he+f5a/s9jMHBwAkS4ynC73Zx22mlH/Lh33XUXN9xwA02aNEEIwUUXXQTILskOHTrUe791toVwOBz88ssvdOnSpdLylStXcvrpp+Pz+cjOzqZjx454vd56n9jR5GBafK9Zej9OLYgqTE6J2YJNCWEXQaxCp611F8WGNE3rZC0mTrFWElX5upcE1Vmr40SFVZRjgc4jMyJF7kInMgdRt8nHywqR1dI6rDJLiDKn+TLxZSkx8SfJTjA1KOu81kyRw6j9KUGy7xpB2pNzpE2DXyHzsSGkPTUHwyH9JhKaFhJrD9A2bg+esJU9fjcPt/wyUi9ZU/T35cJkkrQi+rm8vO9xo5sKGwONaagV08G2gxaaF92ENwtP5cf8tMhF/UTj5I/HUOK1o+sKmAKHM0DAbyGt0V4W98k48A7qyblfDOO7C2dF7rf5zyTczgDL/698vEqbtyajagaKYhDwW1E1nfAOJ6YqmzesBQphp4mlUFp+KCEpukyBfP+VjpsSYWk7Yi2QQrLRHyH2dLcQijGrjI3al16XTGTZosNrtTB8+HCe//kHEm+46qD2Y/h8bB067pizhbjmmmtYsGABsbGxB7R3ePfddw/7+bzzzjts3bqV66+/nubNmwOwcOFC4uPjufLKK+u1zzpHuE499VSGDRvGq6++SlJSEgB79uxh+PDhESW6YcOGyAmeaHSN3UFzax6trbspKhVXsYqfLtZiig0TpwiTrEKBYVJgBGmshrELjR3hACEECSeuaXWUvxkpC6fjVKWyEoYsfC8bLm2qUoCFHSa2fEHILVOOhhXZqViWTiztXtRtMkpmLYRQrLSX6Do4A3/XIIQFqc/NJuvRoaTNnYOpSoNTI0HHEhsk5NcoyHex/PbJ9PlqCD0bZJEXcEbEFlQ1/S0TXrfFbuW5grYM3Nuc/KCDdXsa4fdaUS06VquOris0iPFg08J8ff4xkFI6CnT5cBwx9jAxCUV8d+EsOn/wBMGgxsYbHyftjamH9djfXTiLHp+OplX8Xv5z5gtsvGEsKfNn0PrfU9DD0mg1qZGXPTvjsLpljjBYaEMo0ifNVCAUY6B6pdgyNGkrYmgCW4FMX4uwHC+leUEadAEmfPvJ8Crnc/J96Vi8JkoI/AmC5c9KIRaIP0If3GVO8we1j/pt/+yzzzJr1ixycnLo3Lkzc+fOjcwbrI7XX3+dmTNnsmHDBuLi4rjkkkuYPXs2DRpUP3EgLi4uMs4nNja20mif2lJTU9++9OvX74DrXHfddQD4/f7IsjvuuKPO51SROguul19+mSuvvJLmzZvTokULhBBs2bKFVq1a8cEHHwBQUlLC2LFHrwX4aHK2ex3xio94JUgT1c+aEDRWg+zSVeIUnZaanTA6IYI0Ul1sCZcQpzlIs9SvaD4a6YpytHBstslIgSprt8p+txZDoNQOx1os0O2g22VkocwaAgBdLhemIBRTJtBKvbeEtIDIvkv6OqXMm0XKC7MgxoSQIBRjIHwqJ7XYxu9bWnB6SnbpTMQ53PNrfx5o8TXf+BTOcxiR863u/8UmLDyWkAUJWQD8n3Ep/TqtIGSqPBi/FZDRsR+zU4ETT3AZO9vi896JgEjtmq4r2GyyvjTzltGH9fjnfjGMXy+dRdu3J0WiXfFJJRQVO4iJ9aEqBoUlDoRXhZ0uVAOETb6HDAtYiwSBBga6XaaoDUvplAPNxF86CthSBL7GJqYq0HwQSDTZMKpyRKvN9HQsxYI1z8vl3R7NkNFb4LQ70vl63sPEvXVkOhgP1im+Ptu/9dZbPPbYYzz77LOcddZZvPDCC1x66aWsXr2ali1bVll/yZIl9O/fn4yMDK644gq2b9/Offfdx9133817771X7TEqWjosWLCg7ieJbOo7ELUxaNd1nalTp/L888+za9cu1q9fT6tWrRg7diypqakMHDiwXudX56L59u3bs2bNGj744AMeeeQRHnroIT788ENWrVpFu3btAPmkb7/99nqd0N+dGMVPkhqktcWNU7HSVA3SXHNTYNgwAFUo2IQlMqC6peau8zHKOhKjYivK0aL17HTCTpOQW17EQF7IymphRGkaEVOmbGz55d9WIwX0Fun2HXKb6A4TUzMxSwvrA4kmoRYBUp+bTet/T0Fxh7Am+nEk+FDjQrgTvJgWg3d6PY+qGiRavRR57YxdeRXtnbs4ybabtYGqxollVPzfqdic8lG7T1Ex+LUotVJE7IyUrEP58v1tUJI3sOmmMawsrY/r8uE41l7zBH7f4TN97f6/sXR8bzwgI1xlHl7fXTiLa5beT5zDj9vtx+u1UeK1Ed7hRAkKlKA0M1VCYJSmtENuE61EQRgQijUxrCYIsBZK0a6ViMgsz5DbxJ8kxVbaU5XFteqXxfddhmbQbpIcLWWUvgS/LDzCfmxHoWg+PT2dgQMHcvfdd9OxY0fmzp1LixYteO6556pd/8cffyQ1NZVHHnmEtLQ0zj77bP7xj3/w66+/1up4559/PgUFBVWWFxUVRWwiqsMwjAPeauMyP2XKFBYsWMDMmTOxWsvf6127duWll16q1XOojnpNghRCcMkll3Deeedhs9nqFfo7XokRIRoq1kg9VpNSQXWWXQGqF1deI1hprE9Fi4fqCuKjYivK0eTMz0dgWBuhlchUzJopg+g8PCNiaBpIKC2eN6X4shTLn0pIph0NizQvtRRJqwclJNBtJlpI1nAZFjk+x+oIobiCmKYg6NdQVQMhTDRLGKsWRnHISvug18Kzp/4LToWblt3LG2lfoyTn8ECFc67uf6bsvmOfx+9JhnuOxAt5jNP5gydYdeUEzl48HEWYLOtbXku18cbDE80p89Hq89UQOr0/HqsWxmZTuOTbR8n3O4A49ha4MU1Bo8QicjYmgdVEK1AQ4VLhFGdg36USdpoIg4jIUvylzRgeIW0fSpRIgbwtXxBIMCNfDERIkPbkHGx5CqofrEFYmTGIjmMyUAPSV27duKPsOn+ECAaD/Pbbb4wcWbnztG/fvvzwww/VbtOrVy/GjBnDJ598wqWXXsru3bt55513uPzyy2t1zG+++SZiB1ERv9/P999/X/cnUUdeffVV5s2bxwUXXMB9990XWd6tWzfWrl1b7/3WWXAZhsGUKVMOeajteKGjVRa9OykXUCWGH7diRzcNVFEeVCz7gHdWEFfGzrb7vTjs+3uUKEeanF3xssxFk9YNHcZmoCpgKIAmUzd6qXmpUloAr4RAd5hYSgRmQBBymXJ7KwhDLve1DKEWqRgOk8atciny2jEMBUUxaJBYgmkKir02LBadvJ1xZA+UNTZ2d5A7fh5AccjGu2fNq/acD/Q/E/2fqsqqKycAsC0nkaz+R8ZTC+CCrweTtbMhzZIKsKg6Di1EUcDO3gI34b12cIdBMcnZmYAICuy5CsFYEz3BQPUJFL9CoIGBUirgRag06qWBEhJ4W4axFKiEEnQUv0LYlMXyCFg1YjDGzrYsv9lPr1/voqSBA2WXjc1DBtN5ZAZrph8/IquoqKjSfZvNhs1mq7Jebm4uuq7TuHHjSssbN27Mzp07q913r169eP3117nxxhvx+/2Ew2H69evH00/vv+nkzz//jPy+evXqSvsvs2ho1qxZjdtv3LiRwsJCTj311MiyL7/8ksmTJ+PxeLjqqqsYPfrAafDt27fTpk2bKssNwyAUqt6uqTbUWXBNnjyZhQsXMnPmTO65p/x7YNeuXcnIyDjhBde+6KaBW5HF8xXFFlQ1Li37GfXRinKskvbGVDAVjJgwZR8fpgbaXpnOEab01FJ0wCztWlTlcqELQq5yX66Qy0QNCAyrSdhpsujiuXzvbY1dCTFjTV86N97JLY1/IlEtYXOwEQPaLY1EOlYNnBA5p3XXjmPgL3fy7lnl6Y19I8RR6s/hFFuXfPsoezwy8u+yBrFbVQp8DjCh0GenUUwJuV4Xu7YlgGaCQ8e61Uoo3pADyBsGCRjWSDcslA5KN2S9YNhpYrpNTIuBdY+G0MGeoxGKMREBBcMdxrArWHNVNowezLlfDCM7+x7UIrV0gLpA0aHt1HRCKUbNT+QIIcxDV8PVokWLSsufeOIJxo8fX/N2+2SyyozOq2P16tU88sgjjBs3josvvpicnByGDRvGfffdx8svv1zjMU466SSEEAghqk0dOhyO/Yq2YcOG0aVLl4jgyszM5IorruCcc86hW7duTJs2DafTyWOPPVbjPgA6d+7M999/X2WU4dtvv83JJ5+83233R50F1+EKtR0vbAmX4BQCp7BgUC62KlJTpCt6kYhyLPPAb7eRecu/SP3XNIQwMRw6pqqgehQMa6n/llL+gS70cpd53VE6V9EoLZTXBYouVzQsJkpQMGtnX15sIUdm3Hr6m5HjPl/QjM/2dOHzvffiDcXx08XTq5zby6ctiPwe/T86OE7+eAx/XD4FgJM+erySBcOhoqwAPtfroqDIScOEYimw3CUUBuy4YvwowqSlK58lua1wJ3koKXAgVJNQSgAzqIBqSj8wXYorURp4KPOBMzRQAwItT0G3Klg88v3naySjX3qMgQioaMUK1iIpHLYvbwINQuhxYYRPxbSZbL6/3Isr9bnZqCUKm4YNpsMTGRgarB/794x6bd26tZItRHXRLYCGDRuiqmqVaNbu3burRL3KmDZtGmeddRbDhg0DpD5wuVycc845TJ48udrB1CAFkmmatGrVip9//jnihABgtVpp1KjRfo1Hf/31V4YPL+8uff3112nXrh2LFi2KnMfTTz99QMH1xBNPcPvtt7N9+3YMw+Ddd99l3bp1vPrqq3z00Uf73XZ/1Llo/nCF2o4XCgyNhqqLXXoQv6lTYvirrFMmtqpLG0YvElGOVT5e0ZWUl2fKQnifBlYDFDAtMkJlaIBApndKZx+aqkwxmgoYWqkSM2VUC1PW3BgWCLtMvs9uVe1xH+jwDR+e8wxvpH3NN13eZ9WWmlMKcGz8H1WMUv+dItYvrjuHPy6fQtu3JwGw/P8m0/rfUw5qnz0+lcOsz15cfiH87sJZ9Fw0ErsW5tJ2q+jZKJuTGm9nZ3EMewvckVTydm8cSXEluO0BCCqYPg2RZ4WwgnWHFWO7g3CcjqGWNWrISGs4XsfUTMIOk0CiQahFEE+bIN6mBppXoPoE1lwV1aNg3yMoaR8k9dnZWIoEokRDKdJQGgTIur+y8WnW/UPZNEwWya+dMEg2hhxpTHHwN6T1QsVbTYLLarVy6qmnsnjx4krLFy9eXMkAvSJerxdFqSwvyoTS/qw/U1JSaNasGf379ycxMZGUlJTIrUmTJgd0ec/Nza1kSfX1119zxRVXRO6fd955ZGVl7XcfAFdccQVvvfUWn3zyCUIIxo0bx5o1a/jf//4XMUGtD3UWXGWhtn052FDb8UI3q4xopVnkrMSKEa6KacOKv0eJcqzTemY6hBWEtdRh3KaDLjDtuiyCL/0kkaN8RMQl3tBMgnGwceRglKCQ0S677AQLxRqEXCaaR6AGBMHdTjr9cFuVY5fVNZbRueX2A65zNPk7N7XMWnkRvT4fgSgNU/ZcNJJNN42p4rfV5cPaj1hpl7AHgAKfna4Vtrui2V8U+21sLE4iN+Dmh+w0ABomFNM4tpjCIhe7imPYU+hm95ok0AUioCBCAmHXCTtkHaDiU6STvFOOgDIFoBnoMXK8geoTmAEFLdeCc5uC0KVVRBnNP8iBoIJWpBBoaGA6dJRkP5tvGkPK87NIe2MqbWamk/bUHNLmlncvtpmeTjDuCNu2H6XRPoMHD+all15i/vz5rFmzhkGDBrFly5ZIlmvUqFH0798/sv4VV1zBu+++y3PPPcfmzZtZunQpjzzyCKeffjpNmzbd77EsFkvEYqquJCYmkpOTA8gg0K+//krPnj0jjweDwf0KvopcfPHFfPvtt5SUlOD1elmyZAl9+/at13mVUeeU4uEKtZ0o/F0/iKOc2GwaPpi0uXMwbKXfkP0KanxQXpTmzSIUZ6AGVDmKp0iO81GDALKdvu3UdBSltAPMgFbpc8Aho2PognCsjtAFvkI7SvIGVm1pFmlAWR4IsFOPpY9Dzh2tLmV4LP1f7a/h5Vhm9J/XoKrdKPLbWH/duNIuRZm+zbxldKX04l8HmCfZ5j+TpEnpwulk3/EiADcs+webC8pNL3/MT8NlC1IStLHH4yYproTcIhc+vwUlvgTdoxG0qwQLbAiLLGrXfKU1Q3stGFZp+RBKDBMWKiIkI6eWIgU9VuDYZiHslJYjWqEGAvxJpnSgNwEBm4YOJiV2Foo7REgzUUpU0AX6XhtpT81BCAWz0EooTkcrVDEtJq1npSN0+SXiqHAURvvceOON7N27l4kTJ5KTk0OXLl345JNPIjVOOTk5bNmyJbL+nXfeSXFxMc888wxDhgwhPj6e888/nxkzZtTqeFdddRXvv/8+gwfX7TXu3bs3kyZN4tlnn+Xtt9/GMAz69OkTeXz16tWkpqYecD+//PILhmFUEmsgR/uoqkqPHj3qdF5l1Hm0D8CiRYuYOnUqv/32G4ZhcMoppzBu3LiDVn/HCgcz2idaPxLleCZl3iy0QhXR0kvIa0Gx6pzXdgM/57TEvyEOS7FA9cm2eUsx6A7QbbI9v6ywWXeYWAoVdIeJbjNlWlIxyXpoKKlPzyHr4SGkvDQT4VNJaJXHH5dP4fl1vbmv/bdkbWvC2mACfZ2yfCH6f3bo6PzBE/i8NgxdoKgmyQ0KSXYV8VdOkwPON6yJUz8Zgz+k0SimBIDigA2XNYg/rJFf7KRLkxzW5TYCwGULYpiCQEjD67WhhxTUHJv0Z9OkjUggSUcEFSzF0lLEsJSP7wmUdilaCwXBONmQIUz5/rMUi1LvN7kvw2KiOwyy7xsWOdeUF2dKo3mrgRlSQBdk31v+eJsZ6egOE1dqIYFV8ZXMUQ/mmlFbhg8fzgvLfqDBAcbeHAjD5yN7zOPH3GifikyZMoXZs2dzwQUXcOqpp+JyVZ5h+sgjj1S7XWZmJhdddBGZmZkoisJTTz3F/fffH3n8qquuIi0tjYyM/Y+jOv300xk+fHjEbb6Md999lxkzZvDTTz/V63nVS3Ad70QFV5Qolek8IoNVMwbRdko6hg3CsTJd8/BZXzI4cTMA3/gUBn5wL9YCBVMtn5toWE2UgBytsmHUYFkrU6gQdpkofoFpkWkg02qS9cBQUl6ZgVIsg++Zjwwh9dXpZPUfSZcPxx0wshKlfnR6fzwWVcdmCWOU1vj8eulUWr05FVXT2XD9WLp+OC7iNl/m0bU/Lvh6MLuK3bSML2DTnoaYJjjtQXRDwTAFDVxevCHpmuvxW0mOK8YbsuAJWCne68K23YJhBUuhIOwyCTaUUSZhQthpYC1QUAKCYIKB5lEwbJUvZWXD1JXSTlglLNDtJiYy+hq3AfIv8xIf68UXtOApdOCI8bPm6vEApCyYgWLRybx1NCnzZlUSX/tyxATXDz/Q8BAIrqzHj23BlZaWVuNjQgg2b95c4+OhUIjVq1eTlJRUJX25YsUKmjdvXuN4oTLcbjd//vknrVpVrivNzMykW7duFBcX1+JZVKVexqdR9k9UbEU53lg1Q3ZiGVZZl2UpUAm7DJxKgMxQCc01B+c5oGfPdSxb0RZbrirnJxYLDBX0GBPVX1oLFiOtI0QYwnE6IiRAgawHhpL6z9kouhZxqAcwdSkAysRW7y+H0jF+F5cnLKevw4NFqMfs/9zfoZ6r0/vj0XUFtz1AjC3A7mI3Tps0nYyL9fDH5VNo859JtGlcGNkmHD7w7MAv+6TT+YMnyPW6SGmQR8hQKfLb0dQwCXYfOcUxBIMapikIB1U2FzbCneClZI8L624NzSsIWk18zXSZTixSUQPS9d1SqGKqEHabWIpLm5AC5VYQqk+geSGYIEWYbjcRHoHQweIRrJk8SA4/L7SRG9BwxvqxuYJ4d7to985EgrucoCpYtklBmH3vMDnPc58i+qPCUUgpHmkyMzPrva3FYqF79+7VPlbT8n2x2Wzs2rWriuDKyclB0+ovm2q1ZUJCQq3d5PPy8up9MlGiRDm2UQOlFg8lguYn72aDrzEf7e5Gos3DjUk/81NmKi1a72FXXjKaT5TOSpSf8WGXSeZjQ2gzPZ2wS5qdIhR0l0H2vcNkSscGaoEma2vmzZI1QHdJH6iUBTPIvnME314wG4CRK66lt/1nLOLYnfh+rIstY2dbGrqvYk+xi0KPgzibn5X9JkaK28vsIWy2MJ/1fpJzvxhGQFdZd21Va47qWHXlBLp+OA67FsYf1vAFLRhG+bXEYQtRWOjE9MpLUWBNHKqtzC6kVES1CGLstaIE5f2wy0TociwUJgQSDWz5CqZiSiNdHXSnSShO2o0A2PYq6Ha5jW6TfnKGzSLfd/Nn4PNaMUIKlnyV9f+oPn26r9hqPTudTUOPQh3XCSC46svEibWLgI8bt/8U+UUXXcSoUaP44IMPiIuTg2ELCgoYPXr0QXUp1kpwzZ07N/L73r17mTx5MhdffDFnnnkmAMuWLWPRokUn7MDqihzrH7BRotSHdpPTWf/4YAwNLEUKIbfJ1swktu5IxBXnZ30wie9XtSOhUTG3tPiZ09plcvObj2Iq5canhtWkVfocNo8cQuozs9GtQvp2hUsvwAIwBIbFJGXeLIQzTJNGBdzy4z28ccaLWJxB2r0zkfXXjeP/vn+Yj875L0Cl6QzRlH7daPPNnaQ0ykNTDRJjS9hRFEuvz0ewst8M7vr5Lv7Y3QyHNYQipGWAP6zx8yXT6nQMmyVMyFBo5CqhodOD2xJgzZ7GFOfKuhzNGUa366i7rIQahFF8amQwtGEz0TY60O0moXiDUEyppYNHEIw3sRQJQvE6IZfASAqi7rSi6KVCLSAIxhsoQYGvsY41VyXYUMe0GNhtYQJhhdRXp2OPC6KHlSqDuMtS2TWhO46+EerxzLZt2/jwww/ZsmVLlTE/6enp1W4zfvx4mjZtSqNGjWrsRiyzedgfc+bM4dxzzyUlJSXivrB8+XIaN27Ma6+9Vo9nU3rsutZwXXvttfTp04eHHnqo0vJnnnmGL774gvfff7/eJ3OscCTy8VGiHOtUlw5rMyMdJShwnJSHx2vDYg3jK7Zj+lWEM4zp1eh7ykpS7Hm89MdZaDk2dLuJ6pWRCc0rZMonIDAVOVPRtJZ+BOkgDIGpmSgJQXq33sArp7/C+5u6c1XrFYAswr6y5Z/cHPcrbVvkVLGCqI3Q+juk+Y4EPT6VAiOv0MXmm8bQ9u1JhIMqimoS4/ZRXOKgSYNCnBY5z3Jxn4xSobv/8SzV0e/7hygM2tlVGMOFqev4eG0XWjTKZ1dhDMHtLgyHjuJVUf1yCHWgZQBtl3SQV0Klw86tMmJlKSkdeJ4YgpA03tVjdZRiFc0ri+kxpMmpqYDhNBAhgaVI0HreFj7dMpe0N6ZGBFba61PJvLWy2EqZP0MWz/tVsu8eXt1TqsQRq+Fa+gNJVx1cDZfu85H1xLFdw/Xll1/Sr18/0tLSWLduHV26dCErKwvTNDnllFP46quvqt3usssu4+uvv+biiy9mwIABXH755Qf07qoJj8fD66+/zooVK3A4HHTr1o2bb74Zi8VS7+dVZ8HldrtZvnx5FfPTDRs2cPLJJ1NSUlLvkzlWiAquKFEkbaany8G/ITn3ECCcFAIBqk3HyLeiehTCiXKQtLuhh3Oab2aHN47CoJ3tvzRFCQmUIPib6KUDhAWmKjvMlJCQBfMW2a2IDqZT576e33KyI4s83c217lwsQuWerWexx+/mw3OeqdFzKyqkak/nD57AouoAhA0Fr8dOUmIRpinYtSuO1Oa57PU40XUFXVdoFFfCkotm1vt4J330OKYpCOkqQpi47QF2ZjUAxUSEFQjLGixTlV2rSkigu3XUknIh5m8eQi3QIrVcvuZhFK+s4bLlKYRiTNSAdJnX7SaqX6a13VsUfI3MiJVD2htTMTwa9kQ/ui4Ieaxk3zWi3s/tyAmuZSRdeQgE1/gxx/T17fTTT+eSSy5h4sSJxMTEsGLFCho1asStt97KJZdcUqnzcF9ycnJYsGABCxYsoKioiP79+zNgwADat29/BJ9B9dTZ+LRBgwa89957VZa///77B6z8jxIlyrFP6nOzSXllBq0y5kQugIZVRhh0l4Eo0WjaNI+kxCIsBYpspQ8ooBnEOfx8ldmW9XuSsCp6qR2ESTDBwFSkl5ItT6A7jEhkSwmV+nOFBAjIHjCCi91/0cGaz55wLH8GdbaES2hqL6ClKy8itv4MVp3iUFeOJcPUI0mfr4bgsIZIcPrQVAObpiOEiWkKvEEL2XeMZK/HSZLbg9MWomGs56DEFkjX+ninjyZxRfh8VgIh2RxhiQugeBU0j0wDmhYTW66KEhRohRqmCrbOBYRdcpCgHhvGVMCfZKC4pPgXZtn71MRaKC0glKAglKhjWk2KW+kRsdXq31PIvGU02fcMJxxS2XjD2IMSW1EOPWvWrOGOO+4AQNM0fD4fbrebiRMnHtDLq0mTJowaNYp169bx1ltvsXv3bk477TTOOussfD5frc9h06ZNPPzww1x44YVcdNFFPPLII2zatOmgnledBdeECRMYOXIkl19+OZMnT2by5Mn83//9H6NGjWLChP23CZ9InIgf4lGOD5T4INl3jZAO3aU+p0IvTc2EZadXid/Gzh0JhF0m4Vgd06kjVJM9hW6CPguJbi+ZP7VAd8i0oe400ErkQGBfIwMspmzx14WMjpnI2Yw2gydWXolN6HzvS2GNtwlOEWZDKI6QoWIROptCMore3lI1VVDX/7tjYQzQkeakjx4nENbQDUGc1YfHL0OXzRoWYJgCXVfo89UQvF4bOQWxJDq8/NC3doaVB+LbC2bzZZ90dI+F/B2yGNnY7pRCymESSpBdq6EOXkxF2o+IpACekgozaTWTcKyB0jCAEVARMkhHKMYAE4rbhDFsBrrLwLpXxbpXpWNG+RzAzTeNify+qcLvfwuOgsv80cDlchEIyLlJTZs2rSR0cnNza72f0047jT59+tCxY0f++OOPWo8fXLRoEZ06deLnn3+mW7dudOnShZ9++onOnTtXGXFUF+osuO68805++OEH4uPjeffdd/nvf/9LXFwcS5cu5c4776z3iRxvnGgf4lGOD1IWTsfcJQukTQ0MGxh2g2DjEM1SczFVkzbdt5Hg9KHmyVoGoQuUQg3ToxH0WjB1hR0bktDtpSlDFSwFKrrTkIXxQPbA4TLKpZpo+Rqm3QBTcFqnzewJxrAh1JDWlt00tRUAsCGQTMDQ6OTcgV66E5uovpaiTHTV50vP8f5FydjZFpsljDdoId7hJ8cTS7zLR1hX2JYbj24ITm4iRyc5HEEaxxWzuM/+TSLrQ/bA4WgFKpYiFSMpiNBl7R52HcOlo/s1dIeBfYeGXmhBKCbhGGkPkZRciOnU5ftUNXFtVSo1XigBBSUoMO0GwQSd9WMH8emm2Yf8ORwNBDKad7C3Y50zzjiDpUvlIPvLL7+cIUOGMGXKFAYMGMAZZ5xxwO2XLVvGPffcQ3JyMk8//TR33HEHO3bsqHUKdeTIkQwaNIiffvqJ9PR0MjIy+Omnn3jssccYMaL+0dCo8Wk1RGu4opyIpD01R6Z0NBMRlnVWpgoI6H7KJpYvbyVdvZt5CAU1jLBMAZoeLSKkyrZTvUokRSi7D+VPJQwhd2ltjdPAtJhoRSqGZmI2DNIyOY94m4/TE7JoY9/JnnAszSz5rPM3Ic22m5CpcZN7T2QA/LZwCc01936fV/TLTzlt/jOJVo32kr03kZQGeQR0Dd1QyPM4URSDJLeHkK4Sa/PTMXYnc076z2E9n/YTMgg7TWxti/BudyN0AQ0CGH4NEVBQS+REAjQTxScwNWSUJimAWWgFdwhKpPDWihRCjUNouRZMxZTR0zh9v4alh4ojVcM17/tlJPU7yBouv4/Micd2DdfmzZspKSmhW7dueL1ehg4dypIlS2jTpg0ZGRmRkUL7MnPmTF555RX27t3LrbfeyoABA+jatWudj2+321m5ciVt21b+ArZ+/Xq6deuG31+/coZa2UIUFRXV6Q9TXFxMTExMvU4oSpQoR56U52dh9aiEWgTQdthkQXtAoHkEgQ4+Gti8qD6FpbfM5uyl96MHFUSxBrFhsBkQEigeFRoFoMAqZ9r5RKk5pSFj6WGBXvr12lRlobwISRsIBFBsYQuJ7HYG8YStLFFa47YE6BizkyaWAqxC5zzHDlRRPubjQGIrSjkd3p1Ao3gvO4pisVjCZO5pgKbptE/ajdMSZI/HRZKjBIcaYuHp84/IOa17Qhrqps2dA4khDJ+K0GUBPTEhwjYVpURFxAfRVQuWfJWw08T0agh3CAotMoqqQCgxjLbHIps6ggqKK0T2Pt2HUY59iouL2bRpE6FQiKZNm9KwYUOeffbZWm07cuRIWrZsyQ033IAQgldeeaXa9WqylSgjKSmJ5cuXVxFcy5cvp1GjRrV7ItVQa+PTnJycWh+oWbNmLF++vIpLa5QoUY49Tv1kDMJIIJioY91iQxiglSiybssCzRoV8OUvXdBSPJzx9cNQYMHSyEcoLOfNYQiy7xkuh1sXWVADsqPMKP10UT0KRlnHmFUOrzaspoxeuGSUS+gyMoZXIyBM9lqdNHB52ZjXEJcWpDDsINlSyFN7z+DBxGU0qaXQOtTRrb+rpYSxsy0tEy/HLB3bU+y3Eef2UeKzsXZ3Y+xWWdvy+5YWbLzx8SN+fpmPDQGg1Zx0DF2geRUMvwKKrB+0WMOYPhuilQenRcc0wbvHBVYT3WIinGEwhEw7hgUiKMBvO+LP40hwsCnBYzml+Oeff3LppZeyc+dOTNMkNjaWd955hwsvvLBW25977rkIIVi1alWN69TGxP2ee+7h3nvvZfPmzfTq1QshBEuWLGHGjBkMGTKk1s9nX2oluEzT5KWXXsLtrt2HXG0L06JEiXL0+e2yKZHfO4zLYO3EQXQYlxHpTNy6tQHCALs9RMkuJ8QHEQJUp7SCMPZaSXl+FkITqB4VU5UF0CKMLLy3yA5E3W5i2AxZLK9IjyRhCJl6NEFQOlfRFBQUuPAHLbRquJf8gJPuMVvRTQVVGKwINuArn5tbY/Ye8LkdaoG0777+LgLslsw+tIrZy3dbW9M4thjFYWKYAkUx6dk0mxxfLJ/1fvJonyabh8hOwpQXZ4IC1t0aYZeJv9AGLp1giRV2WAg20FGCCpamHgIeK6rFQNV0DLtCqMQq53LeewyM4TkcHMdO82URqrfffhu73c6ECRN46KGHWLt2ba22/+abbw7JeYwdO5aYmBjmzJnDqFGjAFm8P378+BoHZ9eGWgmuli1b8uKLL9Z6p8nJyQdlDhYlSpQjR/uJGawbJ1M7Sul3pbUT5f32/51I9rXjSJk/g7/6TST16TmYYQXTBNMA05S+WuiQ9dBQUp+djVasyM5Go3QMULisb19Gu8JJIYRHRfUpGBCpEyvD1AUEFQy7YEtBPKow2ehsjN0VojDsYEuoAZe51gO1+wJ4KERRdU72+xbYV1znWBJhp382Cl8wmeSYYsJhhZCuUuy30SN5K+tEI145vfq0y9Ek+x5pNpry8kxQTRSrjmkI2ZjRTKYMjdgwoaCGajUI+zWEw8TlDKC4fZGRRMcdh6LT8BgWXL/++iuffPIJPXr0AGD+/Pk0atSIkpKSWgd8DpZwOMzrr7/OzTffzKBBgyKDqg9FmVStBFdWVtZBHyhKlCjHJuvGDaLTqAxWTxsUabGPPHatHIGRPWAErdLnQFKQ2DjZ1aaHVbJuld/+Uv85m7Sn5pD1yFDS5s4h87EhpD49B9UnCLvkCJSsB4fKkT0+FRRkOlEzUbwKhrN0nuLzsxCi1CHcEBTvcSNsOn85mqAp8uRCpsrzeWcyudFKQqZOju6jZTUpxvqInopiqTpBte9+qzvGsSS2jJ1tibdfjlXV2VEUS0KMFwBFMXj5tAVH9+RqQfbAcpf3i74eROaeRMJBDbOsFjCsEN+gmPzMBCxxPuzWEDuzo36Qf1dyc3Np2bJl5H6DBg1wOp3s2bPniAkuTdO4//77WbNmDXBohFYZdbaFiBIlyvFFx8czCLnLBwa3mZlOm7cmV1lv8+AhmGGFlf0msubq8WTeMpqUhXKIcdaDQ2VbP+X1OFkPD8G0mKg+hawHZXon+95hqCUKIigw7TooJkZsGLVEIWX+DFDA9Et/rVCRDWHTsdjCCGGyMr8pAMsKWnND/C9sCZfwcmFLWmpu8nVvpXMtizTVZGxacXnF32sSW9Vtvy/VbXu0bSYuWN2PHUWxXJC8jpSEfBRhsuSimX/LCNDiPhlsvGEsWbeNIvuOkdhcQeITSwiELNibejBNgT9oOSJdiUeL490WQghBcXExRUVFFBUVUVhYWGVZUVHRYT+Pnj178scffxzy/dYqwhUlSpTjlzWTB0V+9zXRyXpIiqNWGXPYPEiKp5T5M8geMILsu0aQsmAG2XeWetEEys1Hsx4YKlOOdj2SEirbviKbhg8m9bnZqIVa+f5fnikL8Evd6AkJhCuMGVLQNYWdBbEkxxfhCdsoCtl5fs95NLUV8HjDtfwWCHKqzVnJIqKi0Kku/VdGTWKsJqpLGe57/0ARsCPF8+t607NBQ3a5Y1lTkswn5z511M7lcLD+uvIBxCd99Dgen40V10w6imcU5WAxTZN27dpVWVY2QNo0TYQQ6Lpe3eaHjAceeIAhQ4awbds2Tj31VFwuV6XHu3XrVq/9RgVXlCgnOGUpwPb/nUj6pe9x3Q8beafX85XEUvaAEbT5zyRCPou0nkcWNmffO7z893uGgzAjYgsg9dnZ5R5ciUF0r0b2wOFk3T+UlJcqjIpRTbIHjiD1X9MQiomhqmhWHcNiIABVNdi2J4GSgI1mMYUs25HKgDbLWFDUCKcSoKNlD6EavrkfSEDVZr2K6+TqHir2ax9LKcQyjJ1tMcxmTO/+36N9KkeE5f9XNSIb5e/H119/fbRPAYAbb7wRoFKBvBDioAVfVHBFiXICUhalaj0rncxhQ0h5cSajzv2Sa1r/wTWtIWXerCqpGT2s4orzs/qq8QCVhFX2PcNJeX4W2Q8NI+WlmWTfLR/LeqDmTrGyddq8NZnsO6UVQdZto2SHmpBWAIGABdMUGIYgxu2jWUwhYVOhRXwBa7xNGNjwO/5b0INVvuZ0dmzDpeygkVr+bTRk6lhEeRSuusL3fSNgATNUycW+7H7Zeo2a7ajTa300UJI38EDy0T6LKIec47xovnfv3odsX36/nz///JPdu3djGEalx/r167ffbTMzMw/ZeVQkKriiRDnBSFk4new7RwJI3yLKxNNwen85lAsar6Nj+1a0enMqerGsiZECTJpIlomxVm9OZfPN5caS2fdJgVYmpKoj9bnZkY7GMsp8n1JenIkIKaDJ1KJhKLJmRTFQVYMSj50Cu4OQodC3yVpWFTfhjbwz6B27lmStEL9pYW3IhVsECZhhGjTbjqU0IhWn2LEItVL676vM9uio2LNac07qJvZub0aC6qwyMqhMbEFVwQbVF9NHiXK4OJ59uA4Vn332Gf3796927mJtIlQ1OdkfLPUqmv/++++57bbbOPPMM9m+Xc7deu2111iyZMkhPbkof3+OdtFwlKpk3zGy/I5DZ8bqSyJ3t++NY1yX/7E2u4lMD5ZGubLvHSbFUunvALqn6ve1lPnlQ45bz6zs5pyyYAYYcvxP6j9nkzJvFqnPlM+4y75nOKZFditmDxyOP8+OHlQJBzRKcl2EfBZ2FsRQ4HGwxZdIt9jtONQQP3ta83HRSdhFiBW+FL72x7Ii6Gbsyqt4uTCZjSE7tiabUZI38HpxeQfbx4XdWRtoisew8Ut2Cou8zfAawUrnnFk6KLuMmjoVo2IryhHhUAyvPgEE10MPPcT1119PTk4OhmFUutU2Hbhu3ToeeughLrjgAi688EIeeugh1q1bd1DnVecI13//+19uv/12br31Vv7444/IRO/i4mKmTp3KJ598clAnFOX4Yt90TfTCdGyRfcdIBlXoxgn7LaT+axpZ/UdVWTfr/srpwbJIVuo/Z0vLhwVSbKX+axpir5XM4eU1YK3S56CompzTaIJpCLJLjSlTn56DaZMh/+x7h8u6r5gQWoxB2KehWHWcsX68RXYMQ2CzGmzxJBAwNBKtHrZ541FKv7avKmrC+4HuOLQQTRxFTOr6fqVz/mDPSby2/TE+P28uTayF2EWIX72taG/PIUb18XPATmO1hGJTRrmSVfme3bS1Ca1b5KAkb2D7tibYtzejQbPtB/PSR4kS5TCxe/duBg8eTOPGjeu1/TvvvMPNN99Mjx49OPPMMwH48ccf6dKlC2+88QbXX399vfZb5wjX5MmTef7553nxxRcrmZv26tWL33//vV4nEeXYpKaW+rpSFgGoa4FylCNDxslvRX7P6j+SrNuk2Or0/ngA0p6cE3k8Zd6sqjso/cacfecIsgeMIOu2UZiW8q/RrWelI3SB4TAi9hBZDw8h9RkZ5UKTMxW1IpW0J+dIe4kiC5tuGiMNLv0afp8VFBPTUCgucOILWcgqSmTJjlaETZVtxfF8tKUz24rj2ZzZmFyvq1qfKcMUfH7eXPp9/xBZ/gZ8W9COQt3BjyWt+cObytpAE34PtODt/NM5IyWL1OY5vL+pO61b5PDJ5i4ANGueQ4Nm26Pv4ShHh2iE64Bcd911B+U6P3z4cEaNGsWyZctIT08nPT2dH374gdGjRzNixIh671eYplmnl9/pdLJ69WpSU1OJiYlhxYoVtGrVis2bN9OpU6d6T9E+ljgSk9+jRDkWuGnZvfz7zHmHbf+tZ6ezaagc19JmejobRw6OPJb6z9loHoVwjFHetWgILAUq4RgDU5Hu9CiguEMYfhXhVzFdYVxxfgxDoOsKIb9GXLwXj9dGOKgSn+DB67dGbAO6/28sK66QdgF9vhpCjCVAc2cBuwNuDFMQNlTOarCRppYCbm/7IwCP/HEzT538ZuRc3910Mte0lpHArzLbc35a1dTCseYwH+XIcSSuGcOHD+fFb5aRfMk1B7Uf3e9jw6wxx/X1zev1cv3115OUlETXrl2rTL450Hgep9PJn3/+SZs2bSot37BhA927d8fr9daw5f6pc0qxSZMmbNy4kdTU1ErLlyxZEh1W/TflcF0oohegY5vOHzzBqisPn9gCImILiIitMk+vsmhXGSKokPXAUFJemEX2P4ZFuhUJCwyPJuPxMSEIKXgKHNhjAhi6Aqag2GNHL7GQffdwWv97ioyOIUcTrbt2El0+HIfLFuSni+fQ56sh/JnXlNTYvbRz7aZYt2OYCss9Lbm99FzKxNaL687hnvbfR8QWUK3Ygmi6PMoR4DjuUrzmmtoLyXfffXe/j7/xxhssWrQIh8PBN998U2lgtRDigILrvPPO4/vvv68iuJYsWcI555xT6/PclzoLrn/84x88+uijzJ8/HyEEO3bsYNmyZQwdOpRx48YdeAdRjjmqu1CkvjaNzRfN5/KzrkTflsPngddrvb+LnbcjrFZM8xww7kSoKiIhDiOvgEWF8w/lqUc5CFZdOeGw7LeSMWo1ZA+o/rEyC4nsf8iifBFSQBeYNoPse4bTZkY6pqIRjpNFrwGvBTOoyo7GXBvYZR1YmdiSwm4cXT8cRziskhdwcdHXg3BoOp3jc7g4fiWdLLmkWWoeGXJP++/r/gJEiRKlzsTFxUV+N02T9957j7i4uMhcxd9++42CgoJaCbPHH3+ciRMnMnLkSBSl7r2B/fr1Y8SIEfz222+cccYZgKzhevvtt5kwYQIffvhhpXVrS51TigBjxowhIyMjkj602WwMHTqUSZOOD5ffEz2lWLE25ZSJ99PopV/IvfM01CD8smBwpXUvjrkTo3MrtJx8jLx89JPa8vnbCwDoc9fd2Pb6UQo8CI8P0+Ml57Yu/PH4s9FoQJT9kvbkHAyHgeIKYRZawR1G5FswbAYoIEIC06VLR/qQghIQmCpkPlLqXL9gBopVx/BqKM4w8XEeklwemjkLuafRt8QoQbq23AZUjcQeq0Oooxy7HKmU4ktfLyP54oNPKa6fc2ynFEeMGEFeXh7PP/88qip99HRd54EHHiA2NpZZs6qpJa1AYmIiv/zyC61bt67X8Wsr0upqglovW4gpU6aQm5vLzz//zI8//siePXuOG7F1olMmttotuJ/Lel+DxQufB9/k93mDSVhdTN+eEyutrzROQsvJxywsnW9lmFzW/SIAvn7lJT7/+Qk+Wz+TT7c/zSdrv6Pxi79WmnNX3bGjnNikPjubzEeHkH3vMDJvHY2pmog8C6ZqgkNH8cqPLVGiIkIKptVg86AhGHGh8p0YkHnLaFBNMm8ZjT9oYY/Hxcq9TeiVupnb/7yT6364j1t+vKeKqKrouRUlyjHFCWILMX/+fIYOHRoRWwCqqjJ48GDmzz9wluSOO+7grbfeOuB6NbGvlURNt7o6ztfb+NTpdEZCfVH+vlxw7hQW/2cBHZfeTqsRxZh5vTE8Plqrf7Cr/8nYisr/Oz//+QkALnbfgWjehF19GtHYomFs3cFn2T8DoCQvqPFYSvIGPg9Uvr/v41EOD21mprNx+OADr3gQVCxOPxhEvPTCSn12NqbVACGklYQAAipGQgg1z4JhMzEtBkqJ/FCu6C9WlrbMvkv+XHP1+Mhjbd6azMYbo6NgokQ5VgmHw6xZs4b27dtXWr5mzZoqrvHVoes6M2fOZNGiRXTr1q1K0Xx6enoNWx5eaiW4DmUxW5RDh7GzLWcMu48fZz0fWXbhrQNQggb+hlaWvDeMS5s+RKBjM754vfpvBYv/I4XOumshpWAmHWcqKCKfnFs6EpcZwrkxj0saPwCmgXC7+HTzHBaVLDzoc4+KqyOLoR54nYPlUIgt6ekl3etNzST77uGkPjcb3WUgQgIRUBBeBd1poBWpmIrC5iGVhWTKC7NQAkokvdjqzakYYUHW7aOkx9htjx/0eUaJctQ4TovmK3LXXXcxYMAANm7cWKmGavr06dx1110H3H7lypWRgdd//fVXpccqFtAfaWoluA5lMVuUg+fcy2fyzcsvoiRv4MdZletNvni9LZefdhmWLOhz4XS+3vEMlzS4l8s6nAuKAKGAaYBh8lnBy5x542ysxTMpaaLhbmhhW79kNE9jrEUmzk355FzYmBXPTD/aTznKQbKvKDkQRyIiVi2KFF22ZC/Z944j5ZUZoCooXgXTZoJpYsTrCK+KYTMjoqoi2f8od8UH2HzzaFJekDUfZR5jUaIcSnr8b9qROZB5Yoz2mT17NsnJyWRkZJCTkwNIh4Thw4czZEjV//l9OVaGYO9LnYvmD7aYrSLjx49nwoTKnVKNGzdm586d8uRqUKIzZ85k2LBh1T4G0g1/7NixbNq0idatWzNlyhSuvvrqWp/XsVw0X3G0yJk3zsZUBbpF4G0iiDt/J0u6vUvaB/dGOr1OuyOdXxYOpscAGULVbeBrJNC7lDDp5A+4qc2vkX33vmwmhkXgTVJJWOulpIWDH9888Jv7ROF4KaJuNzmd9Y/XXkxJ+4iqHY2pz8yuNBPxYJEWDuWdzinzZqG4Q5j51tLaE9mxiE1HKbQgQmK/QjL16TlkPVz+/q1oFxElyqGi1b+n4FbzWXnDnMNfNP/lMppcdJBF8wEf6+Ye20XzFSkqkvXB9T3Xbdu2IYSgWbNmh/K06kWdi+YPtphtXzp37kxOTk7ktnLlyshjFZfn5ORErCiuvfbaGve3bNkybrzxRm6//XZWrFjB7bffzg033MBPP/1U53M71NSlKLymdS+4bSCXXXA9l7Z8jGVvDeXiUd/RcGkOq6YP4oe+M1CSN0TEVt/TxvPLQnlB+nX+YJK+yyFxtZ8Gf+m0eF7jlRsux9jZlhmrL+GSpH9g+3IF338wjN9eGoyW78XiNaKF7BU4HsQWUCexlTJ/RkRs7esyn/XQUNJenxq5f/LHBydmysRW2pNzSFk4HcUlzU5Ni4np1kE1Ec6wdJ+3G/sVWynzZiH2KfWIiq0oh4PNN42hIK9ma5Eo9SMcDvPFF1/w5ptvRoIvO3bsoKSk5ABbyqL3iRMnEhcXR0pKCi1btiQ+Pp5JkybVqgbscFHnovmDLWarcgKaRnJycrWP7bv8gw8+oE+fPvs1WJ07dy4XXXQRo0bJ1MGoUaP49ttvmTt3Lm+++WaN2x0J6nLBrmndr78YWen+hK4fwMbq91HcOqbSfcNtx7J+O5YcF6Em8QhfkEvbn8OiwvmM2FN5W2PzFpxbdhw3IuNEpfPIDFZNHxS533pmOpuGD+ah32/hmVPeOOD2zgQfbd+exIbrx4JSORie8uJMsu8ZHbn/x+VTDsk5Zz5aOara6s2pJMaXoCoGO3ckgIDse2qOcEP5gO0oUQ43PReN5K+bRxN33+HxtavCCVDDlZ2dzSWXXMKWLVsIBAJcdNFFxMTEMHPmTPx+P88///x+tx8zZgwvv/wy06dP56yzzsI0TZYuXcr48ePx+/1MmVL9Z9XZZ5/N+eefz3nnnUevXr2w2+2H9HnVWXAdbDHbvmzYsIGmTZtis9no2bMnU6dOrVZQ7dq1i48//piFC/dfsL1s2TIGDRpUadnFF1/M3Llza9wmEAhEhnBDeQjz786yf1e+cC1aPqlKxKo6QXVx3AA+y/wpKrZqybGcaqwotjqMzWDTpMGM/vManmpaHklOeWVGpJuvIh3fG0/Ab5U1UPNmkX1v6bDqZ2fLgvbS+6d+MobfLptClw/H8Ve/iVX2c7Bsvnn0gVeKEuUo8dPF04/YNUOcIDVcjz76KD169GDFihU0aNAgsvzqq6/m7rvvPuD2Cxcu5KWXXqpkStq9e3eaNWvGAw88UKPgat++PW+88QaTJ0+OaJLzzz+fPn36cMYZZ1TpdqwrdRZcB1vMVpGePXvy6quv0q5dO3bt2sXkyZPp1asXq1atqvQig3wBY2JiDliYv3PnzioTwivWhVXHtGnTqtSSHa9cfvrlfPzzxwD0GHs/v79Y+fGOj2ewJuoGXyeOJbHVfmIG68aVi6x2kzJYP1beXztJ/jTMyrWR1YmtlAUzEKoNTEHKSzPJvnc4KfNnQFiRnxqqSfv/TiQptgRNVbhqyQP81e/Zw/fEokSJIjkBIlxLlixh6dKlWK3WSstTUlLYvn37AbfPy8ujQ4cOVZZ36NCBvLy8Grd7+eWXAVn39dVXX/Htt9+ycOFCxo8fj8PhoFevXpx//vmRDFpdqXMNl6IoDB8+nO3bt1NQUEBBQQHbt29n+PDhleq6asOll17KtddeS9euXbnwwgv5+GMpBKqLYs2fP59bb721ViG+fYvtTdPcbyvoqFGjKCwsjNy2bt1ap+fxd+LTLXMBWQvWaNle+jpuq/T4msmDqtkqyuHg4pg7uThuAJfED4wsO9iauYpiC2D92EG0mV7Zc2Z69//yfEHVAtKO740vv2OAUEyy+o8k+24ZycoeMILse4fJ28DhWC1hllw0k/xiJ++fXVls9fq85tE+UaJEibI/ajIV3bZtGzExMdVsUZnu3bvzzDPPVFn+zDPP0L179wNu37x5c/r378/LL7/Mpk2byM7OZtCgQfz88888/nj9bWXqbXwK9e8aqAmXy0XXrl3ZsKFyxOD7779n3bp1tXKOTU5OrhLN2r17d5WoV0VsNhs2m61+J/03I+X5WWReVbkW7JR70vn9xaNgAXAcU5s046LiBVWWHY5o2caRg2k/MYNgrEHmYzIKPfuPvjzQQYqsMlNQb4Gj/DxsOmahNTJouozU52ajJATQNJ31102k+//Gsv466b/V6s2p6AEVUaKS9dCMQ/48okQ54TlBUooXXXQRc+fOZd68eYAMopSUlPDEE09w2WWXHXD7mTNncvnll/PFF19w5plnIoTghx9+YOvWrXzyySe1OodNmzbxzTffRG4FBQWceeaZ9O7du97Pq86CKy0tbb/Ros2bN9f7ZAKBAGvWrKkyjfvll1/m1FNPrZUyPfPMM1m8eHGlOq7PP/+cXr161fu8jgeMnW3pt+EStOI0Lljdjy+RkZTWX92F2d16gK2j1JWjlWZsMyOdjSOqiuew3YyILZB1UTctuxddbx5Zln3XiIgHluG3I2JDZJf6VqU+N5us+4eSdX9lG4gVV0yK1HBtvnk0aa9PJfOhaHQryolDm7cm8/uljxy5A54AKcWMjAz69OlDp06d8Pv93HLLLWzYsIGGDRvWqvmtd+/erF+/nn/+85+sXbsW0zS55ppreOCBB2jatGmN273yyit8/fXXfPPNNxQWFnLWWWfRu3dvHnzwQXr06IGmHVSMqu6C67HHHqt0PxQK8ccff/DZZ5/t1xurOoYOHcoVV1xBy5Yt2b17N5MnT6aoqIg77rgjsk5RURFvv/02c+bMqXYf/fv3p1mzZkybJo3nHn30Uc4991xmzJjBlVdeyQcffMAXX3zBkiVL6vZEjzPm5qey8YtW4DLJXN2ENivuI2azwqYx0UHSf3dSXpiFVqiyafjgiNhKe2oOmY8MiRiYbho+mDYz0tEdJkZsmDPbbyK7OAFVlZ3FaW9MRSgmpmpF1wXxjYorOcfvK7TKkON8ygtQM2+NFrhHObHQwwrd36m9/+TflWeffZZZs2aRk5ND586dmTt3bpXgSEUCgQATJ07kX//6Fzt37qR58+aMGTOGAQMGHPBYTZs2Zfny5bz55pv8/vvvGIbBwIEDufXWW3E4HPvdNhQK0bdvX1544YUai+NrYuDAgbRs2TJyngdbJL8vdTY+rYl//vOf/Prrr7zyyiu13uamm27iu+++Izc3l6SkJM444wwmTZpEp06dIuvMmzePxx57jJycnEqO92Wcd955pKamsmDBgsiyd955h8cff5zNmzdHjE/r4oJ/LBuf1oWKJqlRjm3q0+lYJqqAiJiqznm9IvumCDu9P552DXfz/tnPkvraNHq13cwbZ7wYsYJIWTgdISCrf2U7kh6fjsaq6vzQtzx1mPraNDAFWf1HVjlOlCjHI6lPz0FJ8rP8socP+zVj+PDhvLx4GU37HLzx6Zpn62Z8+tZbb3H77bfz7LPPctZZZ/HCCy/w0ksvsXr1alq2bFntNldeeWWkGa5Nmzbs3r2bcDh8RLJNSUlJ/PDDD7RtW7ea2Oeee45vv/2Wb7/9Fr/fz9lnn815551H7969OfXUUw96LNAhE1ybN2/mpJNOOi4sFY43wVVGVHgdv3QYl4E/WSfrgaGkvDBLjrfZx2m93M5hGG3+M4mbO/7Gh1ldsWg6N6X8xvmuNQzZdD27i914iuwIxYxErKQtxDBSFk6PDIk+6aPHWf5/VYdAt3pzatTKIcoJRYt/TmDbQ+MPu+Caf4gE1+o6Cq6ePXtyyimn8Nxzz0WWdezYkauuuiqSXarIZ599xk033cTmzZtJTEys1TE+/PDD2j0BqGT3UB1DhgzBYrEwfXr9x9KtXr2ab7/9lm+++SYiwM466yz69OnD0KH1m7BxcAnJCrzzzju1fmGjHBnKZixGOf4oE0BlrJ1YXrOo+BRSnp+FGpJNyGlPziHz0SFkPVD+IbHxhrH0+/4hrk1bzrgu/wNg8l//x9fnV07dt/r3FDbfNIbse4eR+to0su8YRcrC6bjjfay6cnKkfqsiRqjOzc9RovytWXX7IOIeGn/4D2RyyGq49g2O1NQ8FgwG+e233xg5snKUu2/fvvzwww/VHuLDDz+kR48ezJw5k9deew2Xy0W/fv2YNGlSjSnBq666qtJ9IQT7xoPKIkzVdTDue84vvfQSixcvpkePHrhcrkqPp6en17BlOZ06daJTp07cf//97Nixg2effZann36azz77rN6Cq86fjCeffDKnnHJK5HbyySfTpEkTRo8ezejR0W+1xxplUa1odOv4oe3bk+SIG6DLh3IcTqf3xwPSxDTzsSGIsGDzYBndKnNuT31mdqX9/JnZPCK2Bv5yJ493+QiAC74uL7pXlPLpEVm3j5JC746ReD3ygzkQVun43nhS/1X+LXff9GOUKFGOPVq0aEFcXFzkVl2kCiA3Nxdd1+vkb7l582aWLFnCX3/9xXvvvcfcuXN55513ePDBB2s8H8MwIrfPP/+ck046iU8//ZSCggIKCwv59NNPOeWUU/jss88O+Nz++usvTjnlFGJjY1m/fj1//PFH5LZ8+fIDbr9r1y7eeust7r//fjp27EiLFi2YM2cOJ598MuPGjTvg9jVR5wjXlVdeWSmPqSgKSUlJnHfeedUajUU5+kTF1vFDx/fGY+gWskq7Bz0l0pdu9VXj5QohhdRnZOowZd4shC4whQkCcBpyILQrhFBNGjT00vebx7ip6S+8fNpSAO74eQBf9pkfGVi98YaxlY6ffe8wWv97Cpm3yLmEZc7y7d459A7zUaJEqcqhsoXYunVrpZTigayR6uJvaRgGQghef/31SO11eno61113Hf/85z8PWPj+2GOP8fzzz3P22WdHll188cU4nU7uvfde1qxZU2WbP//8ky5duqAoCl9//fV+918TDz74IF9//TXr1q1D0zROO+00rrvuOvr06XNIRv3UWXCNHz/+oA4YJUqU+vHQ77fQNTmGv3Y1IWXBDLLvHEHmLaNJeXkm2QOHy9mGpeN20p6ag2E1wB2CsEL2XSOkZUNpIXubtybz22VTOPnjMfwnpwc/F99OVkkin/Wez5mfj8CiWmjz1mQ23vh4pbotkEOg9x3js/66caS9MZXMW6JR7ihRDhuHMKUYGxtbqxquhg0boqpqnfwtmzRpQrNmzSo1unXs2BHTNNm2bdsBi9k3bdpUbZNcXFwcWVlZ1W5z8sknk5OTQ6NGjWjVqhW//PJLlYk1B+L333/nqquuok+fPpx11lk4nc46bX8g6pxSVFWV3bt3V1m+d+/eOjvNR4kSpfb8sqclv29tjhAmmj1Mz0VSBGUPHM7JH8uIU8q8WaS8PJPMR4YgXGEwBUIrTwu2+c8kUhbIzsLeXw7llEbb2VoQz/Onvkau18XJH49hWd8ZBEIaG298nI7vjSf7jpGkvjo9sn2rN6fyV7+JVdzko2IrSpQjgHkIbnXAarVy6qmnsnjx4krLFy9eXGPH4VlnncWOHTsoKSmJLFu/fj2KotC8efNqt6nIaaedFnEnKGPnzp0MGTKE008/vdpt4uPjyczMBCArKwvDMKpdb38sW7aMqVOnctFFFx1ysQX1iHDV1NQYCASqzD2KEiXKoeGOnwfQ2OlkT34MniI7DncAuxam7zePsS6rCY5YK9n3DCft9akYXo2016ei2XQsFh1dV2j/34kIVSUx1osWX0IgrLFlVyK5JS4UYdL1w3GEwjbWXvMEAGuuHk+7dyZiGCppr08lq/9ounw4DqtVwWbxAxBv93HR14PYWSxHbaw8DIOro/w9GP3nNfyyN4WTErfx696WkeaLvt88xufnzT26JxfloBk8eDC33347PXr04Mwzz2TevHls2bKF++67D5Dj8bZv386rr74KwC233MKkSZO46667mDBhArm5uQwbNowBAwYcMJ0IcpTf1VdfTUpKSsR2YsuWLbRr147333+/2m2uvfZaevfuTZMmTRBC0KNHjxqDQAcyaDcMA0WpGo8yDINt27bVaIVxIGotuJ566ilA5nFfeukl3G535DFd1/nuu++iNVxRohwG3thwOr/tvARPsR3TEJzSagu5PjdWRWddZhOExcDvsdLq31OwOcI44j1YVIOfL5nG2YuHo5sCwxQEwyqegJVVV06g9b+nYLWFUYRJcYETM6SQkrKHy757hOz8BFZdOQGnPUhhoZPMW0eT8soMsu+aSJv/TMI0peGp0+ZgWd8Z9Fw0kp8urn/7dZRjhx6fjsYXtJAcW0xJ0IpuKPRKzsSnW9gbcBE2VHxhC0mOEjq4d/Jrfgo7PTF0TIwn1+vEF2fh6/PncMOyf/CfM1+Iiq1DzVEa7XPjjTeyd+9eJk6cSE5ODl26dOGTTz4hJSUFgJycHLZs2RJZ3+12s3jxYh5++GF69OhBgwYNuOGGG5g8uaqNTHW0adOGP//8k8WLF0ec4jt16sSFF15YY93YvHnzuOaaa9i4cSOPPPII99xzT63mLlakqKiIu+++m//973/ExsZy3333MW7cuIhw27NnD2lpaQfskqyJWvtwpaWlAZCdnU3z5s0rKUer1UpqaioTJ06kZ8+e9TqRY4njxYcryvFBykszSUndQ/bmRiiuEIkJHnxBC1YtTDBc/p2pS+Mc/nPmC4xccS1NrIX8UpTCLm8sYVMhpMv/1zyPE7/PSotGeWzdnYgRlh9eimbicvlRFQNNNQiFVYpLHKiazobrZeF85w+ewOuxkXnLaHouGoluKCQ6vNGL6t+Q+367nbygkz0+N10TdvDrnpa4rQEAdpe4sWo6ZzTOYk1BMqcmbuGvoqaEDYU9HjdhXaFxTDEAVlVeeGItfhRhsCo3mY4NdvPGGS9y0deDWNwn46g9xyPJkbhmDB8+nPmfLaP5uQfvw/XXS3Xz4fq7cdddd/HUU0/VWXA9+uijfPbZZ0yZMoWCggImT55Mly5dePfdd7FarezatYsmTZrUK10J9TA+7dOnD++++y4JCQn1OuDfgajginKs0PbtSQS9FvCpOBt75IBpE1BNXHF+ggGN5MQiGjpKSLKXcG7cegD8hoUVnhZcFv8n/9p9Jqv2JKObAr/PSqjECqpJTKIHv88KnF7W1wAAsTNJREFUwmTjDWPlsYqtZA8YwUkfPU6Sy0NWbiKhgIapCzAEjjg/miYvss3jCvms95NH8dWJUlvavj2JhBgvpyRtY8XepqTF5hE2FWK0ABuLGmJVdBxaiO3FccTa/TR2FBM2FRKsXopDdhRhcmb8Jn4tSmVvwEWsxU9RyE5QV/n8vLn0XDSS1nF76R67lRf/OguHPcTKfhMZtuJ6ZnV/+2g//cNOVHAder788ku+/PJLdu/eXUXgzJ8//7AcMyUlhYULF3LeeecBsjb98ssvJy4ujg8//JCCggKaNm1a7whXnWu46ttuGSVKlLoxZPkNBIt6oLpCqM4QsU4/yXHFpLrz2OaRKZxwWCHR7qWlK5/W9j3khd18vbcdSfYSLohfzZn2ArYkrMemhPk5pyWaRUfEBgh6LRTnurDHBVh37TjavDUZw1TIHjCCdu9MJBx2sPz/JtP9f2MJajqGoaDrgrXXPEGrf08hLsYbFVvHONcsvZ/MgkQSnT6s1hhUxWBDURIJdh+7fDGowsAftqAIk90lbmLsAbo0zGGXL4ZEqxdN0dnhiyPO4scTtjJv/dm0bbAHTeg0tJXg0gL8ubcpZ34+ghYxhQC8v617JSuRVYVNjtbTPy4RHJ2U4pFmwoQJTJw4kR49ekRqso4Eubm5kTQpQIMGDVi8eDEXX3wxl112GS+99NJB7b9Wgmvw4MFMmjQJl8vF4MGD97tubRxco0SJcmB+yU1BeFXSWsl27JzCWJq5C9nujSNsKpyZnI1NCREyVXIDbrZ543FqQXrEb6GTYzurfc34z67TsCry21j3xjuIt/hYtKEjqk3H1AX+Ium9E/JZICRI/dc0sm6TFg9pb0ylQYIeGWLd6t9TaPXmVISAPy6v21DYKEeGp9eez69FqbR27iE/0I5Ye4A8r4NwWEUAeV4HSS4PqjDIyk2kYayHhg4PBYr0F/KErRQG7AScGpqiY5gCmxKmGBtnNcvkr7wmNHcXsCKvGZ6glVbxe/nPmS9w5ucjcFuCJDk8lc7nk3OfOgqvwnHMIbSFOJZ5/vnnWbBgAbfffvsRPW6LFi1Ys2ZNpIQKICYmhs8//5y+ffty9dVXH9T+ayW4/vjjD0KhECB9Ko6U2owS5URl/vqzGN0qn5+TW/NXcVMAFEzyA04a2D0k2+VYjj1BNwVBJ23du9kTdLPLG0tB0MnjXT7iyS+HsqswhpaJ+Wze3YCTmm9nhy+W1MZ7+bKP/GLU6s2pct8WHdVhoFmkOFMU+am8Z3csrd6cimmCwxkqN1iNckxxzdL7CRoaBf4e+MMaW0oSCOkqhilIictnlyUG3RRYVIMWrgLW5DfGaQ/SyFlMZn4DYuwBUmP3kubcS4LVy7qCxoQMhWbuQpJthbSw57E0rzWpsXsJGyrXNF3Ot3ltWb69GdNWXUYDR2tiLX5iLX56fDqaXy+derRfklrT6s2pOF1+gkGN9dfV30X8SHEiRLiCweARGXK9L3379uWVV17hsssuq7Tc7XazaNEiLrroooPaf60EV8U04jfffHNQB4wSJcr+2bm9KZ1sVk61qvR1roWGa/EaQTaGDQZtvIHMggas9DXl/1r/Rc+4TDb4GrOmKJkWrnxclgBWVaf3l0P59oLZtHtnIqYpSEvKwzAFf25tTvOkfE766HFCukpCnBwRZLWHWXetvNikvjYNTBXNHsIdH5TdkQGVoFa/uoUoh4+7fr6L7d44svc2wWELohsKCU4fuSUuTKCBy0t+wIldk39nT9DKhsIk3NYAzWMKCOoqcQ4/TV2FbPfEs9sXQ0O7h2RXEQomYVNhbUkyLR15WJUwnd05bPUn8n5Od05J3IqzRZCN3ka4tQC5fhdBQ6Vdwp6j+6LUg7/6TaTVm1Np/e8pxMd6q8wHjXJkufvuu3njjTcYO3bsgVc+hEyYMIEdO3ZU+1hMTAxffPEFv/32W733X+cargEDBvDkk09Wqf73eDw8/PDDh62YLUqUE4WJO88n3uLlv6ZK39iVXODQcSpWklUPbWL30KpxLlv9iawrbszHmzvjdgQI6wrbCuNw2YLEWgPY1LC0brCb5Pmc+EMaioghIc7D7iI3pikI+jW82Eh9bRoWu4xap7w0E8VpEh9Xgtdvw1PowOYKElJNwsFDNus+ykHS7/uHCBoqTs3O5l0NiYvx4bIGKfLbUBUDhzVEsc9GnsdJj+St7PLHUBK0sTs3lrSmuQR0DW/YyvaiWOyWMNnFCTRweCMia6cnlt6NN5DpbcCq3GTik30EDY2f8lMpDDpIsHnJC7pobCvm25w2tIzNx6kFWZvbiC5JO+nz1RC+Pn8O1yy9n3fPeu5ov1zVctfPd/Hj9hRM00rqa9NonlxAbrGLwmIHnd4ff2xGc0+QlKLf72fevHl88cUXdOvWDYvFUunx6kqXPvzww1rvv1+/ftUuT0hI2G9DYH5+PgsXLqR37961PlZF6tylqKpqxD6/Irm5uSQnJxMOh+t1IscS0S7FKEeLVVuaMWbLlVhVnUa2YrZ4Etmcn4imGNgsYa5o9hcAqjCIU71kBpJoZ9/J4rxOrN7TGJumEwyrpCXkAbAhtyE2i7SPCIeVSC2P0xkgENQIeq2YAQUEZN89nFZvTsUICzmoesEMMEB16DicAUoKHAjFJOv2UUfxFTqxOf2zUcTZ/AQNlSK/jRhbkC07EzEDKg2bFNI6IZd1uY2wWcLohoKqGOwtcBPj9tGp4S52+WLYXeymUUwJxQEbya5ifGELBoIYix9FmBQGHTR3FVAcstE5NodtvgT2BKTvYqzFj0XR+XNPExKdPjrH57B8b3O6JW7HrQaY3v2/nPTR4yz/v8lc8u2jNLSX8K+eLx/lV60qbf4ziY03jOX0z0ZR4rcRDKqYhoLVFkJVDbweO7pHAxOy7xl+wP0dqS7FVz5ZRouzDrJLMejjzwXHdpdinz59anxMCMFXX31VZfm+RqVCiEpG7RVLoerbZbhixQpOOeWUw9+lWFRUhGmamKZJcXFxpSGOuq7zySefVBFhUaJEqRvpuy5iR0kc8XYfhinQFJ2TGm+nKOhgj8/F+1u74bIGMU2B0xKkiaOIglAarZy5XNLhL77K70DYUFmxsymhoIZhKDhtsvaq43vjMU1BKKBRlOdCseiYIQVrfIBgnp2UF2eCRSX7zhGk/msa2XdKYZXy/Cw8IQWLIwRmtH7zaHDm5yPYW+TCZrXgCVhJS8zDpobJ3ptIXJyXOIeffK+DgoB08S722Yh3+Yiz+enaIIccXyy5fhcAMfYALV35rA42piDgoKGjBMMUxFn9+HQZSdhSkoAnaJUdjN4Y3NYAmpCt+Q41xElJO9jlj2FVQRMCusrvuS1QhMk1S+8nOcZa6jB/7HSxtntnIuuvG8fpn43i50umYbHonP7ZKLxBC6piYLVCMCAIhVTiXT58XhsYAlSTlPkzyB4w4sAHOQKIo2R8eqSpjxtCReuIL774ghEjRjB16lTOPPNMhBD88MMPPP7440ydevTqC2s9SzE+Pp7ExESEELRr1y4SektISKBhw4YMGDCABx988HCea5QoxzXDVlxPji8WIUyZ/vHGsGFvEn7dwv+zd95hdpRl//9Mn9PP9t0kW9ILCb2FKi2AigK+KvIiwouiP/RFiFSRFumQYEUsVAugwouoSBEx9GBCgCSEkLabZLN99/Q5039/TLIQEkglm8B8rmuunDMzzzPPMzl75j73c9/f2/KkwEvlimQNna5sglUDFbzQNoqX17bwcu9IHu+dgia6lByVYekc+zetQlYcPD8oVm2WVZZ+8UpSqRJqzAIBpKiD64qICRs5YQfG1m9vRBB8xv05KNUjxBwQfRxTxvMFxjy0ZWrRITuGPf5yNTlDp6W6n7KpUCpqrOirYvVAGtcVcLzgM9GQzJFUy0ys7mJkVT9xJYjpWparZlUmTdlRsF2JvavaWZ6rRhJ8NCmoNtBVSrC4v46CrVGlF7FdCcNSyJoRbC8Qzm3LVLAyV8mcziZWFYNlF0nwGJnspyUZeFQfOfQXeL5ATzG2Ua3Nnc1nn/9fDnwi+NGwPhheEHwmPHItnieSNzQEgpJUkuhRX5nD90Q6utJ4noCSMkH0EUrSYC3RkJ3LsmXLePLJJzEMA/jg0oLv54ILLuDHP/4xxx9/PMlkkkQiwfHHH8+sWbM4//zzP8ohfyhb7OF69tln8X2fo48+mocffpjKysrBY6qq0tzczLBhwz6SQYaEfNx5fMVkFmWPZvGaevSIhW1LeJ6I7wnMzTYjyj6iFOhh6bqN6wos+cI1TH7sKkpFHceR6C3EqIgGnjHHE4MMtaoB1mRSDKvK0p2LM/L3NyCIgYK8JAW/CF1HZOV/f5+W395I869vQdCEQIFeCzwDCAqtZ1zO6Aevx3VEkD0mPXoNxUyEtrN2jV/+H0emPnVpkCWYjGK7EllTJx4tU7YUFMnFdiUUxWV0ZR+9RoyCpdGVT6DILr4vUBcP1OATaplxqW6Kjka/GSVjRyg7MpWREp35xGCixfBkP4roklIMxse7mJ9pxPFExqV7MF2ZnKVhWAqC4CPi012Ms0dVJ31mjLwVxIsd9ORlSIJGXbwwZDptU5+6lJen3UyNVuBvh/+UlvtvIlVRJDsQY1JLiTnH38S0f1/A8s4apjQH5WgKBZ2EbuI6Iq1fvTyoPSr42CiIVRaabnHIU5fy0rSbh2ROG/AJiOHq6+vjS1/6Es8++yyCILB06VJGjRrF17/+ddLpNDNnzvzQ9suXLyeVSm20P5VK0dra+hGNevNsdQxXW1sbjY2Nmyzs+HEhjOEK2dl8Y+6ZdBlJMmaEnnwM3xcwuqMInoBgCXhRD0QfvaKMqjhYtowg+FimQnNdH3lTw3FFDFPFsSUE0SOdMHA9Ac8TkSUPywlkAsqGiqI6OLaEY0mIso+q2ZQLWhAgbwdxXr4vUF2Rp7snuUHcVvN9N4EdxH3hB7FfITuWE2Z/l45cksZ0hs5Cgt6+BHrUYlR1H12FBLLkElctRIKkCNMJSjdFVZv6WJ6spTMq0ce4WBcdVopeM05EskkrJTJ2lEq1yJyeFnTZpjneT9aOEJFsespxRMFHFlzKrkJcMSnYGj3FOJLokTc0ahJFsoZOc3qAxZ11tFT3U7BVGmI5lvTWkoyUeXmIDZPme2/m0AnLmN8xnMWnBMvpRl4PMm+jQQmjgY4kYsxBj1jIkkcqUsawFeZ9+voNqi5MfuwqBKCwrpbppmIYd1YM171/f4mmqdsfw/X6b3+wSz/fzjzzTLq7u/nNb37DxIkTeeONNxg1ahRPPfUUF154IYsWLfrQ9kcccQSKovC73/2OhoZAfLezs5OvfvWrWJbF7NmzN9nu1FM//N5mMhlmz569zTFcW201NTc3I4oipVKJt99+mzfffHODLSQkZOv59f7383ZXLaOTvajrvE+R2hK4Al7KAc0FT2DJF66iVNIwiypmWcGzRVo7qzBtGdOW8X0QJQ9Z9siXdPKFCEVDxfUEVNlFFHz0iEVMt5BkD98WEUUPWXaJp0uIoseK067AtUU8W6SrM42oeIz8/Q2DS4ltX7sMMeIg6g5S3Kb5nl3gV//HiHP+cxad+QRjq3pIqyXKtszeLat5+9Sr6cgniKnBUmH7QIq6aKDHVizoTB3WSkuqn2HRLFOrVzIu1sUYrYujk28xrXIhSdlguDbAwcnlpCSDL46Yx9SqlewTX8WnKpawV2I1ccWkTs8TV0ziismAGaWnGB801hsrMgiCjyx5qJJDdaqAh4BhKbRlK7HtYClyZ3LC7O8Ovv6vl77FmD/+kMqaHH84+NdoisOMhSex+JRriCTK2HmNTCZG2VKYOK4dz5ApZSIs+NwM4qpJX9+65IBYmbb/uZSpT12K40jks0FsXCpdYtKj1+zU+X0Seeqpp7j55psZMWLEBvvHjh1LW1vbZtvffffddHd309zczJgxYxgzZgxNTU10dHRw110fnMSRSqU+dGtububMM8/c5nltdZ53T08PZ599Nv/4xz82eXxbLb+QkE8qXudYHsxXcMs+wS/vkdFeVpaqeW7FGMSaMtGoSb4njmAJtPziNnxBBcAXJJB9EH1MS8bMayCAFg/6KWd0pKiDpltAEL+iKQ4jEhn6yzGyBZ2ahiz92RhGSaO2MsfL025mymNXIco6rAuSXnHaFYx+8HoU1aH5npuRIg6eFWRw4QU1FsfcPItll354FYqQzbPf41dQGamgJlZkdT6NJPgYJY2BWJRp/76AmlhQMHptf5JRtX0s7GlgVEUfsuQyYEVpL6Roruuny0zSovey0BhBQirTrPZyfGoBPW6SRqWPsVonLXKBtU6Eg3WJXrfIv4xh7JNcTclTGbCjoBhBTFe0yBMT/s7Br/8XuuSwJpOmpbKfVbkKRiQydBST2K5E0ZCJR8s7pQrBetmJ9cH5xzw7nZRq0FlMMaaul65CnP3/8X3imsP9bx3IVZPBtmSm7bWQZ5ePw/cFPF9ATZoc0LiK/R6/gmyhGt8WmfLYVSz4XDCHhliOnKGjRmw01aFUVlEUl5b7b6L1zMs+8nluxCdEFqJYLBKNRjfa39vbi6Zpm20/ZswY3nzzTZ5++mnefvttfN9n0qRJHHvssR8q3H7PPfds17g3x1Z7uC644AIGBgZ45ZVXiEQiPPHEE9x3332MHTt2q3QwQkJCAsT6pbQovcwvtXB/5yEM2FE0yeHkCW9wYHMbRklDjtmQsmn9fxeB5EPERc5JYAv4hoRjy4iqCx6YeQ0jr4HsEY2VB1XjE5qJIgVLRQCqGni8FMVFUR1Kpsoef7ka05JRVAdNs1FVhwmPXAuAkdeJVRh4lgSOEHx7rFvyjHQLjL4tLOu1PfzXS9+ityuJJHp05hNokossehzQ3EZbRxWr+isoWBqZcoSDm1sBGFfVw1td9dREi5RdhXxZo6OcZFysiz211RyfWEBUNOlz46SlEgfrbRyhw16qQZ2kMV4JjPNqKcZnoz3UKVlEfJJyGdOT12XKenx6yadJaCZtmQrSUQPDUdbJU8hBLJnkYpflnVbySRFdjnv2QmwvWEp95qhZqKLLQDFCa18lCc1i7ok3IAo++zau4chnLmJkbR+/3v9+Pj1uEXsNa2dKei2HNK/kpaWjcFwRSfJRExaGoTL2Tz9k9IPXs7y/GkVyiWg2piWTjJUp5XRSFcXNjPCjYX0txe3ZdgeD64gjjuD+++8ffC8IAp7nceutt36oZMR7EQSBadOmce6553L++edz3HHHDXmVnK02uP71r39x++23c8ABByCKIs3NzZxxxhnccsst3HjjjR/FGENCPvYc0rKCa6f8hT+P/iejIj2I+Giig+VJDK/OoEcsFD0QM5XiDoLk4zcaoHqIJQm3JCOrLqLuIkUcRMULjCFAVxxU2SUi24xO9WI4CmnNIBUNZAMUxeHtU6/GciSGJXNIkocoeoEXwBPwfQFJdvF9MEoqvi2CGni/pLyE4AqU6n18cTf4Jt+FyVk6w4b343oiDckcZScweF5+awzxpIEkeSiSy5qOSlZkq+k3oizsamBUdR99RpS4bFKXKNBtJFhhVPN/2f3o82KsNGv4VHQpD2cOYIFVz6umjYKEJihUSO96EaKiylnJbqbGlrJndBXNej/7V65ifKIL25PoK0YZXdnL2HQPni8wUI6wsr+Ssi1jOTJ+aecI40779wV05RM8fdTtAFy54GQmPHItD079Fbpq8/apV/Pcsbey11+vJGvolB0FVXSRRI8jn7mIsZEueow4T7RNxHRl6mqzNKcHWPKFqxhb18OeI9qpSRWIx8qYtkyuEMG0ZRJRk941afYetYp8UWfyY0NQBsjfQdsuzq233sovf/lLTjzxRCzL4pJLLmHy5Mk899xz3Hzz5kMYPM/jhz/8IcOHDycej7Ny5UoArrzyyg9dUvyo2WqDq1gsDuptVVZW0tMTlHGYMmUKr7322o4dXUjIJ5DjYm/zuYrX8HyBwyqXMa1+MdOa3mZifRea4hCJmkTjJm5ZBgH8SgtkD9sMHngCIIg+etKkVNIomQo9fQm6CglWZKvpzsVpy1RQF81jujKK5LL/P75PImJSsFVE0SemW5hlBXudurznCUiaCz6IemDwCQUJT/dQsyKiA57mh16ubeDIZy7iyGcuwvVFerNx9qxoRxY9ciUdUfCprM8S0ywKmQiWKzGioZ+YYtGS6ueAYauIyhZVkRKvLB1FxoiQtzTeydayKNvAi/lxpCSDxwt7MDGylrRYotWupuTbDLilTY5nWtTmS/EsR8ff4tjEIqbE1rBHuoMD6lfRV46xuL8O1xOJKjYxzcLzRMyyQts3L/7I7tFefw1KvOz9tx8AIEseBz15GaLg88Mpj/L2qVez3+NXoMouLb+9kSOfuQjHE2lOD7Aqm8byJGTRI2voPNaxF6MSfQxPZfnDyGcRBZ9V2TRfevmbdBfjdBST5MoaIyv6MMsKw6qyGDkdy5EQ4zbzlzXjuwJaWOrqI2PSpEm8+eabHHjggRx33HEUi0VOPfVU5s+fz+jRozfb/rrrruPee+/llltuQVXVwf1TpkzhN7/5zUc59A9lqw2u8ePHs2TJEgD23ntvfvnLX9Le3s6dd945mA0QEhKybYj1S0mLkPGiNGl9HB59B4DhWoZJyQ4Or1/OPvVraEjlqK7NUV2XI5UuoegOqVQJRQ0qPYiCj+sKwQ9aXwABXE/AsGWimk2prLI6V0FUsZhY1c2IRAbbFenuTwaGliMhSR6CAOW8hmtL4AfeLlkNDC/JEFGyImaliy+A4Aj4Umh0bS39xShr+1MYtoLvwxNtE1mVSTOupoe1/UkcVyJTiJKoKJEzAsHp9myKBR3D6CnHeau7ntWZNMPqB9Bkh8mVHWRKEer0PC/3jqTTSmJ6CmusSl4zWjhYb6daim3g3doUB+sSn4p4fDa2kuNSCzm7+gU+3bCQ05rnMrmyg+pIAVVy0RSb5addscPvy6efC/SSTn7hPEZW9HHQk5cxLJmjrxQjHTGYc/xNiOvcNd+YeyZ18Tx5Q6d5WB9VerDkt7aQRJY8XE8kU44giT6S6LEiX4XvC6y0C7w87WYqogYiPrWxYE4NiTzdpQQN1Vn6i1HSVYVg2VF2EdVAdqOvL07zXbfs8Hlvju1dUtwdhE8B6uvrufbaa/nb3/7G448/znXXXbfFNsb999/Pr371K/77v/8bSZIG9++55568/fbbH9WQN8tW+4AvuOACOjo6ALj66qs5/vjj+f3vf4+qqtx77707enwhIZ846oev5ZSOUSy2u+h0EqTkEi1qD2WvmUq5QK2aY4SeYZVRiSY6mJ5MpVpkVbGSsiuzoqsaWXGxLBlJ8rDWBbhns1EiMYvhqSwAjivSU4yzsreKfYatoVTWECUPUfQRRQ9R8vA8EQQfz5IQJB9Zc1j6xStpvvdmnKSLYInIBRHJEnBSHlgCwu5f3WunMfH/rmHxKTOY/NhVtCT76R5IYFkysYjJGytGEE8bRFQbyw6qBkyq7aTHiDOqqg9ZcOk14miKjST6dPUn0XSbxUI9oyt7GbAizD7mNk5/5RsYrspnKt8g40Z53mjmS/FuPDw0YfMZhdVSjM9Ey4DEwfpyBtwSs9VeXi6MoUI1WJL5aCqMFCyNSY9ewxdGr+Xx1XuQ1MsUbZV8SWPP6rVM/L9rKBs1TH3qUgYKo6lL5VEkl7ponqX91VREDfoKUXTVpmCqvP7Z6zju2QvJmYHRWvRETn/raxReuxrLSpOPa/i+QGWkREozcHyRoqVSl8zj+QIFU6MEeG7wt+C5AngfPocdzickaB6CuoV33XUXixcvRhAEJk6cyNlnn72BBugH0d7ezpgxYzba73ketm1/FMPdIrZah+v9rJeHaGpqorq6ekeNa0gJdbhCdgW8zrEAlDyLV02dqbrJCtum39N5qP8gJsfaWWrUkbGjpJUSbw4MJ6GWGRHN0FlOEpFsXu8ajuOJlIoanimhJ03G13bTlqkgl4/gOyKRRJmaRJGBUgTPFzBNGUkKPGSOKeO7IoLsEYmZeJ5IOach5mXkQhCAaid8lLyAp4Cn+IiWgJN0afvWR7fE9HHiwCcupyk5wGurgvI4dlZDjNns1byGjmISy5HQlSCpQVMcciWdclFl75Greae3Fk2xKVsKI9JZCrZKQjWZkOrC8mQMV2HfxCryro4iOhwQWUnRV7F9mZNjhS0eo1i/dPD1+s8lwFMlhRNGvbVD78f7OWH2dwPh1bKOKjsookd7b5qJwzv52+E/5Yw553B6zRzSYgldcFAEj043ji7Y9Llx8l6Ee9ccgiR49JViNCRymI7M2lySiGpj2nKwdBsrUaUX6Swmae9J43sCTfX9DItlmbuqCVkJ5FqKeR188A0Z0RBZ+d3v7TQdrvsee4mWA7dPh8uxDF57aNfW4Zo9ezaf//znSSaT7L///gDMmzePTCbDY489ttni0fvvvz8XXHABZ5xxBolEYlDH69prr+Wf//wnzz///CbbzZs3j4suuoi//OUvG92bbDbLySefzI9+9CP22muvbZrXdkc5RqNR9t133+3tJiQk5H2sf8hFO8fyqYgHKOzR1ArAoXrw0Junt1L2ZX7Z9Sk8BAq2Rt7W6THilGwFw1SoShbxPAFbktFVm7ZMBbpqU9YUIkkL05bpyiaoSRbIGDqq6lIdL1J2ZDKFCK4j4QOmqeBmVZB9RFPA1QPjSjIEfAl82UfwwI15aL3SpicVMsjpr3yDLiNBRBHJWTpuXkFMWjSO7KEnF8QSOa6E40oYvkBlrMSK1TUoukO6osjirnqqEkUypQhT6jsoOSoxxWRkrA9R8KlQS5Q8FU20WV6u4bSKOaREk3GKjiRsXTSJ1zl28PO4/l+vc+xHbmwBGynWv9fg8zrHcn/z+ncSIPFUScFDZLVdxZ0rjkCVXAxboTnVT1lVcDyR3lIUWfTI5KIIoo8g+HQ6CbpyCdJRg3SqyL617SzN1tBlJGiu7SdjROjPxAJjy5JA9Vh5bvij4qPg29/+Nl/60pf4xS9+Mbgk6Lou5513Ht/+9rdZuHDhh7a/+uqr+epXv0p7ezue5/HII4+wZMkS7r//fv72t799YLuZM2dy9NFHb9IQTaVSHHfccdx666387ne/26Z5bZHBNX36luvrzJoVxm+EhOxIPsi7ALCfFgSEHtr8HKZvM9uIMt9oYUK8g147QVsycL8LgBMRSWgmni+QK+tIkodpy8iSh6Q4DJQiJCNlerOBqnjX2jRKLHC/u6YEZQnBE0B1wJeDmC0RfIl1MV3Be7kk8M4PQk2uzbE8W8VAPooggCR51Df1UzJVIrJNTbJA0VIoGoHI7UHjVrK4p46a2hy1sQK9pRivf/aqIHBc9FjUXc+izwfyHWe/ejYjIgPkHB3TU1AFh5RskPGiHKxvuyH8XqMLNvxcfhS897Mu1i/lwWX7M684km7zcGTBw/FFTFemLV9BXLEwHIWipdCYzKJKDj1GnDHpXnrLMSKyTa8Rx3QlegsVmGWFvRrXsNipIxktE1VsSrZCV3cKUfTQZJfXe4YjSy75QoxU1CBX1PHySvDHpHhgDVG1lU/AkuLy5ct5+OGHN4i/kiSJ6dOnbyAX8UGcdNJJPPTQQ9xwww0IgsBVV13Fvvvuy1//+leOO+64D2w3Z84cLrvsg/XVTjrppO0Kut8ig2v+/Plb1NlQa1yEhHyceb+x9V6eMSSOiQQZZkdG3qLsO8w14/zF3RdFcBkoR6nSi3SUkrT3pYhFLGoSBfqLUSJqYFRJ62QddM2mOx8HR0QQfXw3yFD0JD9Qpu9TETxwYj5ySUAsA+K7712dUAh1CyhbChPquqnSirSXgrpvuuzQkU+w8HMzmPDItQgCCJJPW64CTXHwfYG32hqIxE2O+tf3SGku2WKE2mSwPHj2q2cDsLacJq2UaI70stgYxgVVL/AfsxbTt7cobmtTfNQGFrwrAvxMZhIdxomIgk9PKUbu5WsYXT0VzxdYsraOSNTEdUXSMYNCWSNbigx+jtvzKfIljeGVWXqMODlL46DaNgxXYW5XI4eOWMG/lo1nUWcDzVX9uL64rgh3Hl126C9GkUSP6miRlX2V1CSKrO6qQI9axIZnGehKIpSlQBNvJ7Mjgt53h6D5fffdl8WLFzN+/PgN9i9evJi99957i/o4/vjjOf7447fquu3t7SQSiQ88Ho/HB2PYt4UtMrieffbZbb5ASEjI9vNhxhbAMZF3U9Q1QUETFKZqBpnkEqZoHTypT6LLTuL4IsObspTdQOOp7Mi4nogkepRtmWJZpTIeyAUkW8oMFKLIsottyXiegCAHUcK+BL7i4ckSggROwkXOS+BDcjkMTPYYdftMVlz4vY/upuzmvHHSDzljzjks6GsgpZd55qhZTPv3BSR1k73+eiWpmE2upKNHg1I+c0+8gSOfuYi65jy9pVggjlv/OkvTdczuGMNpL59LRIJKtcjMvf/IZW98gb30VeydyvCbgf2YFGlnseWx9+aFuoeEU1/8f+Stz9JTjBHXLCxXQhI9dNlBiZfoKcVwPTGoIWrJ2KZMjy0xvCpL0VIZk+6ly0hQshWaqwboN6JEFJux6R6eXT2WPWo6AVjY34CiOsQjJrLoUbYUWlL9rC6mKTsyhqFSXielomgOvYUYsupSyumYmguyR+s5Yf3Qj5Lzzz+f7373uyxbtoyDDz4YgFdeeYWf//zn3HTTTRuUEdxzzz03an/22WdzxhlncPTRR2+VI6impoYlS5YwcuTITR5/++23tytWfeco1YWEhGwX742bWU/WMwDocj2W2lVI+PS5cf470QcEQpZfiOeAGJXJt7h87TQmJjpZXqwhpZRZmq2hLlogb2tEZJsJFd3M7WikaKrI0vr4Fg9J8rHLMomKEvmOBCg+ruYjmiJexMOPuIg5GV+Apd+fHshCeMJusXQx1Ly6upnhlVkKlsrZr56N61fQl48BoKs2FTED05GRxMDQ7comiOkWxXKwlPyt8bPZ7/ErmPfp6/nc89/hwam/4tPPnc85/zkL00vzojiOl4s+Jybf4EBNYY1jI9av2qwBvynWt/moPF2PHPoLJj16DW+dfA0jf38D9TVZyrZMztBRJBdVdsnkI7iuGGTQOiLDazP0FmKMrOynLV9B2ZZJ6iYruqpJxA06BxJkDR3Llnm7r5ZCUSdSkSemW2RygScrW4zQtqoaQfGorclRlS7g+wK1sQLLe6sAUBQXR5Fw8wpq2vxI5r/FbF+e2/a33wl85StfAYJEgU0dEwQB3/cRBGGT5QT7+vr4zGc+Q1VVFaeddhpnnHEG++yzz2ave+yxx3L99ddzwgknbHTM931uuOEGjj322G2YUcB2Zyl+HAmzFEPey/tjV4ZyHB9Gh1Pgqo7jKToqEcmmKdLP1TWbDmp+uJDk1eIo2o00Y2Pd9FgJ1hpJPF8kY0aIqyYD5QgJ1aQrn8B2JSxLwumOIHgCXsxFLEoItoDgg5N2EEwxULdf9/3nxYOC21JRRHAFnLiLVBLxZfBSNm1fC2IlAmmEa3bkrdot2PtvP0AQfHTFQRJ8oooViHAOVBDXTQpljbpknlXdlTimRHVNHlV28HyBOcffNNjPMc9OJyIHy2mOJ5JUy+QsnRNrFzFJX8NxI9/mkeX7cOro+RsYTdtidO2Mv4PxD89gyRcCFfeRf7iB2qocvQMJaitz9OVi2JZMQ3WWXFljRCpLTzFOY3KANfk0mXwE3xNxCgp1IwYYk+7lldYWPFtE0R0kKaigkIiW6e1NICkeqmYHxbhll7hmkjV0BMGnMmqQNzU8X6A/G8N3BUTJ36Tm2M7KUrz/0ZcYuf8p29WPYxnMffjKXfr5tiUFqtfT3Ny8yf2ZTIY//vGP/OEPf+D5559n/PjxnHHGGZx++um0tLRsss3y5cvZb7/9GD9+PN/73vcYP348giCwePFiZs6cyTvvvMPcuXM3KTmxJYQG1yYIDa6Q3Yn1D84Bt8RrVoLHM3vRXk7TY8Tx1omV/nvyoxu1e9W0+Y8xioKrUy3nWWnWkLGjFN3AYHN9gS4jSdbSqdKLtGUr6e1KIhQlJEPEqXQQLBHREPBUn9bvXMToW2aBuE4ewhZwIx6CK+ArPr4WGGBtXw+XYwCaf3Ur8boCiuSSipSp0EqUXQXTlcmbGgfWrmJuTyPdPUmqq/M4rkhUtekeSHD4yOX8e9lYGmsHcDyRl6bdzH+99C0aIwPE5cAD88Mpj/KHpQeywqzls8k3yHsqzXKJEXJ8q8e6M39wHPjE5fQOJKipzDGQj2JmdPAEkvV5CnmdSMxCkVwKRZ26yhy9uRiy7FEdf7e+4eSKDub1jsByJJpTA7zVWY9lKMiqi+uIxBJl1i80uZ6IIrlkB2KMbuxmVW8F+41YzcKeegq5CFWVBQZyUVKJ0gfWitypBtd+O8DgemTXNrh2NGvWrOGBBx7g7rvvZunSpTjOB4sFzp07l7POOou33nprcDlyffHre+65hwMOOGCbxzFEaRYhISE7ivUPwwopyjERl5kNr3Fb42McU7uEUYk+dNnmsDdP5VXTxvWDpamSZ3GgpnBSfDGHxZaQkAxGaj0cmFjOXonVjIt2MjHWwbBolonpLrpLCXrXpIFA/sGNeOCBYAX6W63fuYgxN8/Cl4JsRS/i4ck+vubhaR6+4IMtItgizffdtNEcRv7+hp12v3YVahoHMEpaIGzqSvQacZ448se0dlQRUy1e6mhBlVyah/VRGSkxIpUlX9ZY9uUfML97OLF4mahi0ZLs55CnLqVezyGLHprgMFwdAOD0sa/yg8l/4y2zgYRo0TSiA7F+6QbblrAt3rCtZfzDMwBI6wZ7N62mUNaoThbRK8q0jO4iotpE4ybDU1mq40VUzaZoqlQkSlimTFSxKNkKguDzXPsoGmI5amJBUW9FcYnETTQ90DczTYWxVUFZurpkHkHwmdDcQd7UGF3by8uLR6NILnrUYiAbQxT8nVaYOwTuu+8+/v73vw++v+SSS0in0xxyyCFb5f0CsG2buXPnMmfOHFpbW6mrq/vQ8/fff38WLlzIvHnzePDBB3nggQd47bXXWLhw4XYZWxAaXDucnfHFFBKyOUbIcb5fvYS7ml7giQl/55LRT/BCcTw/HhjDXdl65lpBDFCTHKfoabxTbmB2ZhzPZ8fTblbQWq4m60RZU0qzNFeDIgXlfDCDwtWiKQalfsTAwGr+1a0su3Q6ggtWlYtYFgNdLkMKauxpHlJRhJhD29cuo/nXQUmU0Q8GD7GV//39obpVQ8bcE2+gripLbzaO5chYrsT+//g+DTVZEqqJ44ms7U2zpqeC7kKcnKlTGSsx/uEZvP7Z61j4uRksbm3gja5h+MDibD0vdo1CER1sf0P5h331NSTeVwLA6xy70ffV1hhhO5r1y4hPfepHpJQyAIYtB/pwpQgAiuTyzqo6RsQyiKKPvG6JMJUwyJk6Kb2MKPhMHdaKLHos66yhM5+gVAwyBSxLZuVAFU3VA3QWk1TGSqRUg4qogSx6tKT6MV2ZyrocI9P9OLaEW5CRlV2jbqLgg+Bt/7arc8MNNxCJBP/nL7/8Mj/72c+45ZZbqK6u5sILL9yiPp599lm+8Y1vUFdXx9e+9jUSiQR//etfWb169Ra132effTjqqKM45phjtjgzcnOEQfMfAbtKzE/IJ4P1n7f36xY9sWIS06JBbM/nYiWykUXcn51A1o2yoNzIW+Xgm9dFJC6VGRfr5tWBFpblqrFciahiU6GV6DOi5AwdwRZQciJONChWrayVsZMe9XM81h4pMvbGWSy//F0piJE/msnKC4IsRUHxoMGk9SuBYdX2jWBZ8aOowbc7sXZtJUrUoq8/DlkFIW1RU5VnZX8ljiNRmS6QL+nYrsSIeIYuI4EkeUz8v2uoT+Wpq1OJqRYJJVhGrNELeL7I/0741+A1Hly2PzCMz8d6N7j2+s/Mpr6r3p+ksbO/z2KySVw3UUQPy5WojhfpzCWQRY/6+gyvdw2nVNRIVZfxga7ONAeMW0nZVWiKDjCnq5m6eB5J8qiIGpi2THPlAGuyKdJRA01yOKCyjee6xtBdShBXTaKyheOJJBQT25VY2lfDmPoeFpcbePvUq3fq/D+UT0AQ0OrVqwfjpB599FH+67/+i3PPPZdDDz2UT33qU5ttP2LECPr6+jj++OP55S9/yUknnYSu61t07UwmwxVXXMFDDz3EwEDgKa6oqOC0007juuuuI51Ob+u0QoNrR3PY+d/khZ/8cqiHEfIJ4r0K4Fcv+DzXTvkLAG+Um1hY9jkstoQW2eI/ZhVR0WSNVUlUNNlbX4UoePw9tzea4NBtJVBFhzHJPK91D8ewFPqKUYqGhm0oIIGd9JDKInaFixMTkEsiLz78rvTDqFkzWTE9eK835xn7px/iOhKtZ3yflvs3Xkr8xOMKCALU1WTpLFTRUJPFcmSSkTIdnRVUJoocP2oxz68dRY8RZ8XaaqoqC8RUi4hs01OIkSvp9CsOmuLQlBxgQX74BpdQBZdTR29aS3FzhtRQ/XB8sWMke1R38nrXcHQlkGYwTRmTQL8sFTMY1dDL2kySibVduPUiawspRMEnqZSpjJRYsraOo8csYXWxgmS0zMn1r/O4OAVdthkoRzE9mRGJDAVbY1S8F1HwmdvTRFo3qNRLSKKH4SiDyR27BJ8QHa54PE5fXx9NTU089dRTg14tXdcxDGOz7a+66iq++MUvUlFRsVXX7e/vZ+rUqbS3t/Pf//3fTJw4Ed/3Wbx4Mffeey/PPPMML7300lb3u57Q4NrBxNYYjPn3WSz7VOjlCtn5zOlvGXx96aQn2OMvV3PR55/kp28fTYeVpr2cBuDpjgk8EZlMjV5gZKSXkqfi+SLDIll6zTiK5CEIPmVLwXVFfEcAyUe0RZwKB0Hx8CWRZd/ZUPxxvbHVfM/NtJ19zQbHWs/c+MHV8rsbaT3j8h16D3Yn2s65hJaf30ZBdRg/oZ2CpZEt6HieiBazGChEWSAPA6CnGCMSC0oxZQsRBMHHc0WcHh2npgxR+PMhd3LGnHP40svf5I9Tgx9+H2Rs7ars9/gVzP/M9Zz8wnmUDRVFcolqwbxhnSp/LM9bHXUMr8qyqLOBKQ1ryVk6vi+wppAmb6qMru+hSimyxK4jqZosL9dyct181loVRNMm75TqcTyRvdNrWFasoceIE1MCL1efGUWTXLqyHyyCGfLRcdxxx/H1r3+dffbZh3feeYfPfOYzACxatOgDMwzfy7nnnrtN150xYwaqqrJ8+fKNYr1mzJjBtGnTmDFjBrfffvs29R/GcO1gpKzByF+Eivs7m+OkLw31EHYJ3l93bn25l/+d8C+e6RjHfQfezX0H3k3JUugqxbnrgHu5e+FU/rJyCosy9Ty7eiwPTv0Vr55wIyVTxfFEfE9AzMkItoCXdNBSZRB82taJP0596tLB6+3xl2Dppe3sSwcD4dcHQ2+K3c3Yav7NLYx68PrBGLQdgWALGIZKvxHF9QVq0wX2HNGOIPjIssvqngrSkTLDkjkAiiUt0EWLmvi+gFxTRpI9UpEyn3v+O0iCzzt9NTtsfDubeZ++ntNePpdHD7sDVXMoWwp9uRiK7NJS1Y8o+CzurKOxOhMUnU4UWVtIcVBVK/tVrqJkK2SyMVYPpGktVVGpF/lcwxu0lSr5Y8f+mL7M9IlPY3sSExJdFFyNjBlhYqqLumiOTDmIHSrZymBc2S6F72//tovz85//nKlTp9LT08PDDz9MVVWghzZv3rxBja73c+qpp5LL5QZff9j2QTz66KPcdtttmwysr6+v55ZbbuH//u//tnleocG1g8lPqETpLQz1MD5xPO3+caiHsMvzXu2m1z97HSUzCJxfcdoVLPr8tcw+5jaMksaYh65jwiPXYpQVFn3+WjxTwtd8fNVDkDzM/gi+8a5z/OVpNw++Xm/gAURiFsCu+dACDnoy8LiN/MOWZUh6nWNBgIpkiYqGHKMe3DFZa+vj3CojJRpiOYqmyrL+aoysTrmsIIg+3fk4qzJpJNFDll20qE3JVHBtEceWSMdL5E2Vxw7/Ga+2N/H6Z68bNH53Rx6c+isAPE9AUxyskkplrMTSjlpsR2LKsLV0ZhOsWF5HthQJkgby9awoVeP7ApLsUpMoUq0VqFANuu0ko6K91EXy2J7E1179Hw5OLmec3kGT1s9Tn/oR+ydWkpRNDq5r5Yj65cw9cdfLnF1f2md7t12ddDrNz372M/7yl79sIEJ67bXXcsUVm477TKVSgzIOqVTqQ7cPoqOjgz322OMDj0+ePJnOzs5tnFW4pLjDMVMisag61MMICdksCz73ruep5bc3ggCq7vDOf121wX7BUIKMQ81DUjxcwdmkZ+qnbx+9QbD2Wydf85GOf2sZ/eD1LD/tCvb665W8cdIP6VwbxGGsPH3LMiSnzDkdPOjPxPDKEqLmMuah60glDOZ9evuMrxWnXUHLL26jomkAy5Eo9cTQqwxG1/Sysq8SWfTIrkoRb8wFXi3ZpdgfAQGiaQNJ8BlYWbFONPQaYEPjd3dlfbD6lMeuwnYlvjb5Fe5+7VDyFUEAdGNLL3tXreHN/uH0GHFWdVUSjZns27iGsqMgCj6Gq7AgO4yyq3BI1QriUpn/9DdjJyUe7tyXAyrb+PHiY/nuxBfpeesE3inWY4nho3Eoee655z70+BFHHLHRvnvuuQcINLOuueYaampqiEajW3Xd6upqWltbGTFixCaPr1y5ctDbti2En6odjGz4GMNiYfxWyC7HMc9O55mjZm3yWOtXNzSgmu+6BUHxaD3zckY9eD2q6gyWlFl+2saek8LaZr6d3vV+aHz6ufN5/IifAO9mRL5x0g/Z+28/YPhwmymPXUU+F6H1jMuZ8Mi1H5iN1nzXLUQqRJSkheeJCIaEEHHxPJGBbIyW392IKHus2I6sy9b/dxEjfzyT5KgMakOOoqGyNpdEFH0y/TG0uhJR1aZU1LFNmbphGQplDWldJl+iKbfN196VOezpS1jwuVs45z9ncf+igxjR0E9vKcr4mm50yWFSdC1LsnUUbJWayjwJzcRyJRa1N7AqnqYqVkISPBpjGarlPGusShTR5eGOfbmi5e8sMofzer4JgP9kWvjzIXcO8Yw3w/Z6qHYDD9emMhHfWxNxU+V81uP7PmPHjmXRokWMHbt1Mk0nnHACV1xxBU8//TSquuH3mWmaXHnllZss+7OlhErzm2B7VIM/dcLN/Ove34QGV8huz+THriKq2uiyw2G1y5kcWUPR0/jG+Oc3OG93l0EZ+6cfsvSLVwIM1iV8L0c+cxEFUwuEX30QyyJeykGQPHxLQtBcIjEzqPXXE2ePMe2DRt620HzXLWipMoIAUd0koVn05GOosovrC5imgiy7JKNlBvJRIprN8FSWtbkkw5I53lrYROt5F23+Qrs5p7/yDf5w8K8/8Pi35n2VTiNB0dY4uHol/+lvZmKyE9NTiEgWywvVHFa5nHYzzdhIF+dN+Pc2j2VnKc3/7s8vMXqvk7erH8c2eOXvV+3SSvPZbHaD97ZtM3/+fK688kquv/56jjnmmA9tv8cee3DXXXcNFr7eUtasWcP++++Ppml8+9vfZsKECQC89dZb3HHHHZimydy5c2lsbNy6Ca0jNLg2wfb88Rx38AyefPS3u/UDKGT3peWO2zb7sL3sjS9w014Pb9ju/ps2yiJ8vnU0h+obhnnu7p/rc/5zFncdcO9WtWn56UzUhiKOLeMWZZB8BNmDvIKvuwiqR3VVnkw+gucFgrDVFXlePeHGbR5n8y9vpboxQ19vAgQf3xPQ49a6WoBQ6o4xbtxaHF9kdW+a4VVZIrJNY2yALiPJqmya1z973TZf/+PEN+aeya/3v59p/76AvKWRX1eD8f0JJtvDzjO4XmT0nidvVz+ObfDK41fv0gbXB/Hcc89x4YUXMm/evA897+9//zs33XQTv/jFL5g8efJWXWPlypWcd955PPXUU6w3jwRB4LjjjuNnP/vZNtdRhHBJcYfz5KO/HeohhOzmbI/H6IOMrVEPXj+43PV+YwtAidgbvF+wagSH6kG21u5uZL2X9cbWlspRtNx/E1T42JYMPkgxB9cS0WMWSsrAdiSMnE4mF0UQfdy8QqTKoGQp7PP3K7a5HEzbNy+m5We3IVabuDkVZUDCt1Ui+/bh+dA8YQ2mK9NfjNJYnaFkK6zqqiRXrTO1diXv9Oy+WYo7ml/vfz8AE1Jd/GSfB4Z4NCHbQ01NDUuWLNnseWeccQalUom99toLVVUHVevX09/f/4FtR44cyT/+8Q8GBgZYujT47hszZgyVlZXbN3hCg2uH83F6OIUMDTv6M9R87820nfVubNF7l9DW8/73RV/+WH+Wt1SOIpIISsyU+qPo6TJmUUXSXIzeKGVLIDK8gKw72IaCGrOIVpdIxwx6BhKUgXF/nrFBEsJWjfE7F9F81y2MGtNJxgjU5geyMXwfMpkY+41cRV0kT5eRwHElIlGLvnyM15URyPKuUYpmV+K9xtZBT162Qdbu7sQnQfj0zTff3OC97/t0dHRw0003sddee222/Y9+9KPtHkNFRQUHHnjgdvfzXsIlxU2wM9zDISG7Inv99UqimsUBNav4UcPcj7XRtTla7r8J3xFQYjYIfqC274jgAZJPJF3GyOoIRQm5poyqOVimjCD62KaMKHskYmVsV+LQESsGPS1bS/Odt6JWlRlb18Oy7mpEMfjKliSP8dXdtBdSuJ5Ib0+ScU2dVGolVmSrKJS1XS5T9OPKTltS/NOLjJly8nb149gGLz+x9UuKd9xxB7feeuugdMKPfvQjDj/88M22e/HFFznyyCOZPHkyr7/++hZdSxRFBEHg/ebJwQcfzN133z0YW7W7EepwhYR8whn7px8OipNm+mP0DCR4rn30EI9qaBn7px8iaw5CUcbp13HKgbEVqTAQjaAwtOOIQcZXKliOLfZESSWCsiPRuEllqghAdbzIU4smDQrBbi1t37oYWXZZm0uiqg57N7QzrqYHy5Jpy1bStbwagGH1AzTGMpRdma7ONJb1bgHr94rThuy+CAyNDtdDDz3EBRdcwBVXXMH8+fM5/PDDOfHEE1m1atWHtstms5x55pmbDXJ/PytXrmTFihWsXLmSlStX0tbWRqlU4qWXXtpiY2v58uX84Ac/4Ctf+Qrd3d0APPHEEyxatGirxrIjCQ2ukJBPOEu/eOWgOKmketgFlaKhseerX+HIZz7+2W6bwjZlbEPBj7j4oo9flpCyElZbHC/igidg5zWwRBTdwS4qqGmT3vYUjiVRKmj09iXQVZuipVJdkyeVKjHqwesZ+eOZWz2exadcw0BvAs8T+U9bM1HZIhU3cFyRutG9KJKLLHo81zo6UF0fvwJVfXdZ8eVpN3PC7O9y4BO7l7J/yK7BrFmzOOecc/j617/OxIkT+dGPfkRjYyO/+MUvPrTdN7/5TU4//XSmTp26Vddrbm7eYGtsbNzi4tMAs2fPZsqUKcyZM4dHHnmEQiEQI3/zzTe5+uqhEwQODa6QkJBBXEtE1B1sUybfG2P2MbdtVXuvc+t0b3ZFmn9zC74lBq4AaZ07QPXwdB+5sYhgioglCbEogQDuqhhyn4KV01DTJl5BwbdFfFOiuy9Jb3eSXFEnl49SkSwh1JqMeuAGmu+9+cMH8j7azrqUsqHi2iJv99UiCj5717XTEMuRLUWoj+WYMmwtw+JZYpLFuOpuDnnqUiY9eg2jHriBJ478MV2daU6Y/V3G/umHTHjkWg4JPV+7Fz7g+du/ESyDvnczTXOTl7Qsi3nz5jFt2rQN9k+bNo2XXnrpA4d6zz33sHz58q0ycObMmcM//vGPDfbdf//9jBw5ktraWs4999wPHOd7ueyyy7juuus20tM66qijePnll7d4PDua0OAKCQkZpO1rl+GVZXxDou1/tv5hfF771une7Go033szUl5CMCXwBLBEpIKE3K0gFUSsjhiCI4AHftpG8AR8ycfVfcSihCR5CK6AqLqBwdatIcgeVkajpjJHsaziWiKeK6B2KIz78wxG37ppMdpNseIr36f1q5eTy0fpXl7Fi60j6SgmOb55MTlLp72QQhY9FvXXMyySI7cujmvFVwI1/WjKQBVdln7xSiriJV6atnVGX8gugL8DNqCxsXGDcjc33rhpGZPe3l5c192ovmBdXd0HlrlZunQpl112Gb///e+R5S3Pzbvmmms2CJhfsGAB55xzDsceeyyXXXYZf/3rXz9wnO9lwYIFnHLKKRvtr6mpoa+vb4vHs6MJDa4h4OPgBQjZueysz0zL/TchlNYZG9vAnfvt3rIoouLiVjj4qoeouaB6IPi4MQ8n7eIrHr7qgwjCgIJgCygjivjRYOmx3BUowldWFMEX8GIuviEhJWw611bgLUqCLSIrLnbKwxzQETxo/tWtWzXOFV/5Pq3fvgjPlZAEnyfbJpI1dSTBp8eIc2jdCp5YOpGF68o3rY/hWnzKNby1tp6RP5m5QQ3M93PY05ds+00M2S1YvXo12Wx2cLv88g9fbn6v0jsEmYPv3weBCvzpp5/Otddey7hx47ZqTK+//voG8V4PPvggBx10EL/+9a+ZPn06P/nJT/jjHzdfNzedTtPR0bHR/vnz5zN8+PCtGtOOJDS4dhLNv7mFlt/duMMK3oZ8sthZ2YKtZ16GH3Fp++bFO+V6W8Lki27fKddpueM2/KyKYEhgC3glGblHQXAF/LiDnJFA9YK6krVlfBF80ccyFHAESNkISYtyTqO3PQWOgJywiVaXWP9YskcbSHGbSMSChA0C2GkXvcqg+Z6t9zat+Mr38QFR9OjorMB0ZFxP5OnV40nGDcb9eQYjf38D+bLGmD/+kOZ7b8axJVae/70P7feF427Z+hsY8tGzA4tXJ5PJDTZN0zZ5yerqaiRJ2sib1d3dvZHXCyCfzzN37ly+853vIMsysiwzY8YM3njjDWRZ5l//+tdGbdYzMDCwQZ+zZ8/eoJTOAQccwOrVqzd7m04//XQuvfRSOjs7EQQBz/N48cUXueiiizjzzDM32/6jItTh2sGcOOw7WGOH4csC7UfolBstsEXSw/LENItMKbL5TkJCdjLNd92CUJJo/d/v7XK11hbeduFHfo09/nI1kMCPusg9Cp7i40U93LgXnOAKOGkXHBHBFBEAP+ISqTQwBiIg+fiuiF8W0CrKWGUFUfJxyjKy4iKIHoIhIUVtRtb2sbK7CkHyoSyCCHvUd7DAG0bzPTcH/w/f3vJkhfd6qvb5+xW096SJxkwyAzEoKBC3yXcm2GNC8KBatGzofuGHbC8+bK+S01Y2V1WV/fbbj6effnqDZbqnn36az3/+8xudn0wmWbBgwQb77rjjDv71r3/x5z//mZEjR37gterq6li5ciWNjY1YlsVrr73Gtde+W4Q9n8+jKMpmx3z99ddz1llnMXz4cHzfZ9KkSYOetx/84AdbMu2PhNDg2sG0/ryasgGeKYJnc/Tkt7mr6QVG/u0bZIC2r1+C1/n7oR5mSMgGtJ3z7hJS2zc+ectJpdYkqD5yb2BsSZaArwngCgguKFkFO+VB3MHXXJyighh1MLqjwbKj7NM4rJ+1fSlcR0LVbey1MaTaMp4nIMseqZYBsgWdrKkTi5oUSxq27iHHbeYtHkmk0gBLxFd8Wn46MzB+t5L1yvZj/vhD1IiNacgoqouTV2jPpsj0xsEKFzZ2V7ZV1uH9fWwt06dP56tf/Sr7778/U6dO5Ve/+hWrVq3iW9/6FgCXX3457e3t3H///YiiuFE5ndraWnRd32yZnRNOOIHLLruMm2++mUcffZRoNLqB1tebb77J6NGbl6xRFIXf//73zJgxg/nz5+N5Hvvss89WF7Pe0YQG1w7m2QN/Ra0UY9T/fZP4Col7zrkHgLavD/HAQkJCNsmo22ciOgJiUcCXQbQFPAnEkojggqf62Il1xpYhBbUUbRFPFhEcAV8HWXNZ01UBgG+JuIqINryIvSqGP7yE5wnryv949GXi+ICuB/pddkYjPSxHpj+GVJBw4y5+zOGIf17Mc8duXWzXepZ96d3KAaMfvB6SNpmOJELUofXsMDMxZOv48pe/TF9fHzNmzKCjo4PJkyfz+OOP09zcDEBHR8dmNbm2hOuuu45TTz2VI488kng8zn333bdBluHdd9+9UbbkhzF69OgtMtB2FkOqNH/NNdds4C6EjTMfFi9ezKWXXsrs2bPxPI899tiDP/7xjzQ1NW2yz3vvvZezzz57o/2GYWyxjkeoNB8S8slg0qPXUF6RCAwtS0BwwJfBSTnoaxV8ycdTCOQfVB9f8/EVDxQPIS/jRzxE3cEzJYSyBD6IlRaeI4AfRG7Juo2u2yR1k4FiBLOsUleVpbs/iecJeJaErDsAiMsjWDUuYtwmErUo9kQ/kR7H3Y2dpTT/hwdfYOyEjZfxtgbHLvPCv6/ZpZ9v2WyWeDyOJEkb7O/v7ycej29ghK1n+vTpW9z/rFlbnhm8IxlyD9cee+zBP//5z8H3773By5cv57DDDuOcc87h2muvJZVKsXjx4s0aTslkcqMCl1sjmhYSEvLJoLwigaeAZAqIJrhRH18ArUvGTnh4qg8SiGUBL+Ug9yqItogvgpPywANZdbEKCnJVGbcjgluSEbQgO1Esi3i1LuWyQrGgI8ku0ViZfFlDED18RwZHwO3XaD3vIpp/cwtqt4yXkzBkDSrszU8i5JODD8J2+kiEXS1IcxOkUqlN7v+wAtLz58/f4P28efNwXZfx48cD8M477yBJEvvtt9+OG+hWMuQGlyzL1NfXb/LYFVdcwac//WluueXdjJlRo0Zttk9BED6wz5CQkBCAkT+eiSCAUhDwBfAlUPIivgBO3MMXQSqLOHEX0RIRehR82cdZ5/HyJR8p7uAvj0GVg7cmCg1lxF4NXw0kJcSkhdur4cZccAQ8SULXbSTBx+2MIjrgVjiIhsjoB69H0ETsJhdR9vBtEVyRMX/84QZLhCGfcLwhbr+L8uyzzw6+njVrFolEgvvuu4+KimCpf2BggLPPPnuL6j9+VAx59OTSpUsZNmwYI0eO5LTTTmPFihUAeJ7H3//+d8aNG8fxxx9PbW0tBx10EI8++uhm+ywUCjQ3NzNixAg++9nPbmT5vh/TNDdS3Q0JCfn4MvWpS8EHTwbBBckS8NRAwBRAzayLz5J85JyEp/j4io/oCEhlAU/zQPbwu9el0rsCXtTD71ehysR3RIRC4K2PNeYRZI94bREtaZIfiJLLR9BGFJCbiki6i6d7OBmV9foRni0i9KkIoo9jyrTcsXWK/yEhn2RmzpzJjTfeOGhsAVRUVHDdddcxc+bWl9baUQypwXXQQQdx//338+STT/LrX/+azs5ODjnkEPr6+uju7qZQKHDTTTdxwgkn8NRTT3HKKadw6qmnMnv27A/sc8KECdx777089thjPPDAA+i6zqGHHsrSpR+sY3TjjTduoLjb2Nj4UUw3JCRkF6FjaQ1e1EO014VaeaAUREQLBC+I15LKIJUEBC8IpJcMASfq4UZ8tF4pyGB0BOwaB8EXIOaABF5JRkuYqPUlolETQfBJpAyK2UASZljDAMmEgSK7SJIXZPmnbBAJgvJ9EGUfvTmP74PQp+LLu/4yUMhHj+D7O2T7uJPL5ejq6tpof3d3N/l8fghGFDCkQfPvp1gsMnr0aC655BJOO+00hg8fzle+8hX+8Ic/DJ7zuc99jlgsxgMPPLBFfXqex7777ssRRxzBT37yk02eY5rmBvWZcrkcjY2Nu3RQYUhIyLbR8vPbEFwhiIdxBNSMgGQDPtgJH3wB0QEn5uNEfKRyIA3hS+BpPl7KRijKgQCqKyAVRNzIOkHUmIPviGAHtRgF3cX3BGTNpaWuj75ilLKlENEsSmUNSfKojJUomCqS6JMt6NgZHTFm4zkiuAJK3MLtiBJtybHo89dudn4hO5+dFTT/wB+eZ9zYz21XP45T5rkXZnysn29nnnkms2fPZubMmRx8cFBu7JVXXuHiiy/miCOO4L777huScQ15DNd7icViTJkyhaVLl1JdXY0sy0yaNGmDcyZOnMgLL7ywxX2KosgBBxzwoR4uTdM+UGU3JCTk48PYG2cRKUiYVV4QryWCG/FxoyAXBZS8gKsHxpVUDrIWhXUxL3Y0WFaUu1TceguxXwERnFoLMaugVpewOqMQ8RB0l6rqPH39cdSojZXRWG7XEE8ZNKRzdGYTyLKLKPi0v1WH3pRHlV1cW0JJl/E8EUoiYszBzugQdXHdIY8ACQnZLbjzzju56KKLOOOMM7DtIPFElmXOOeccbr1126RWdgS71F+waZosXryYhoYGVFXlgAMO2Cjb8J133hnU/tgSfN/n9ddfp6GhYUcPNyQkZDdj6eXT0QZ8oh0iUhkQfHwxiOPyZLCSPoIbnOtJfiDsLYGngGgKKP0iTjLIQPRlH08PrDG/0sLMaUGNRc2FgkzJVBB6g/R1KWEjaw75njgZQ0cQoGyoFIs6VeP6aKzIULYUaqtzxKMmqUSJmhEZjhizDDwQixKuK9Lyu80X7g35GOMTKM1v7/YxJxqNcscdd9DX18f8+fN57bXX6O/v54477iAWiw3ZuIbUw3XRRRdx0kkn0dTURHd3N9dddx25XI6vfe1rAFx88cV8+ctf5ogjjuCoo47iiSee4K9//Sv//ve/B/s488wzGT58+GAF8WuvvZaDDz6YsWPHksvl+MlPfsLrr7/Oz3/+86GYYkhIyC7G63e8q9cz+eLbsWNgVXhIBsiGgB33EdfpcUEgfOqLQVaiGwHRFPHWZR0K+jrrLK8gpqxgGbAkI7gCZUOlanwfA9kYni2ixW1sHwxTxchraDELq6SSyUeIqRa2LeG4EoapYpaC8iVLJRe1qoyV1bAKG2sPhXzyGAql+d2VWCzGnnvuOdTDGGRIPVxr1qzhK1/5CuPHj+fUU09FVVVeeeWVQQ/WKaecwp133sktt9zClClT+M1vfsPDDz/MYYcdNtjHqlWrNqgKnslkOPfcc5k4cSLTpk2jvb2d5557jgMPPHCnzy8kJGTXRvBAdGDld7+HE/Px5MDA8tQgmN5JeuAF2YqCI+Ar6zxiqocfc/FtEUHyEA0BL6cgWEFsmL/OEOttrcTJqQiSjyj6xKpLlEsq2CKxiIms22iaQ1tHFaLgU7ZlytkgvEGL2qztrMAuy0h5CaVHCWLDPiZc/MYXh3oIux+hh2u3ZpcKmt9VCJXmQ0I+eYy+ZRa+FHiyRCcwnNxoYFhRFhHcwPBC9sEVQPMQShK+5q17EAZLh64RuMbkPgWhsRQYTH0KwrAyouRh5TQEJdDZqm7I0rsqTU3zAACK5JItRSgORNASJs1VA6zoqkYQfGJRk0xvnLawNM8ux04Lmv/d84wf89nt6sdxysx++brw+TYEfHx+LoWEhIRsB4JPIBWxTn/LjQWGlFAM9LT8qIsQcxDWFasWZA8hbYEjoPTKSAUJr1dDVF20hIlTZaOoDkJJJjE2g5NRsQZ0hjX2oURskD1iqkXzmG5iqsVANkZ3fxLbltCTJoIAWTOokOH5ArYrgSWyz9+vGMrbFDLECN72byFDQ2hwhYSEhADLLp1O6/+7CF/0SS4VgpqJ4nsMLclHEH18V0BQXfySjNymB+V7NB99ZB5f8/CKCmZ/BKEgU+qPotWWyBciVDZmEOM2nb0pXFdkXFMXa/uTtPemMWyFeKyM5wpIkkc5r2GujdH/Zg1uj44keZhlBTSPohFmVH9i2RHLieGi1pARGlwhISEh70FwBLLjfKScHMRuGRJ+UQbBD4LiAb8ceL3W12HEB6OkIlgiyB5SXsLXXZS4RbkngluQcVwJfyBQj/cckRVd1XiuREWqiCq5ZAdiNNYNYGR1Iskye+69EnFUgciIPJ4r4nkCgiEhy6GL4hONvwO2kCEhNLhCQkJC1jHxittZfsl0pLKAGw/qISKA4Am0fvVy6p5RiC5X0SvLiDEbV/dwR5SRGkt4eQVSdhBQ31AGT8A2FARPQMrJGIaKr3lomo0etXCKCm5WYSAbo+zIyHqgF6QnTZLRMgvbG5BlD6OgoWo2XkHBVzzeOvmaob1J28F1C7cv/igkZHcmNLhCQkJC1rH4+gsZP+N2fAlEQ0QwJHABAUbfNoveE02Sh3ex5AtXsfK/v49QaSGKfiDZoHnoUQvfFvFdAbWyDIBcbaCNyuF2RMCHUk7HXBMHH5LD8niuQM+aNI4l07ayhnJeo7s3SXNtP5YlkUqXMPI6sdoijc29Q3uDtpOSp3LC7O8CcMLs7/Lp584fPPad104fqmHtNgj+9pf3CZcUh47Q4AoJCQl5D0uuupDlF0/HV4IHk2gJCLaAk3DxuzS6llbTfO/NNN95K74jsvy0K8AHWXeIR0zazr4UZY2GlVeRNBfPE7EtGaHOZMqE1aQriyjDisRrilTHi6RSJdL1eRJJAyVlUlefoam+n4hsU5MukFuRBmB4KktvfuhEG3cEN+z5CBOTncxafBxjEj08fsS75dZ+tu8fPqRlSEAYw7U7s0uV9gkJCQnZVWj99kWDr1t+cRvoLr4rACDkZXzVwy9LNN9zM4nqIvneGP3EaPntjejjLRKyS74njpYq43kCiurQnktSKgcCppYlYzoypbJKY1WGkq1QNhW6VlUiJS1E0QtK/ASXZOnqusFlx92VJ1ZMol5rYvrEp4d6KCEhO53Q4AoJCQn5AFp+OhPRAWQBpVPFSXpB9qInIEQcAETFQ5NdipqLKHqoMQfLknGcIIDetmRi8TKK5GLaCqoaHBdFn+6BBIm4wfL2Go4ZvwQz1Ut/XYxl3dV4nkB1ukC/6OF0R5BrDZZ96cqhvSHbwHnzzuCMqpc4pGUFJ4x6ixOAs189m3sOvGeoh7b74QPbmzMR5lwMGeGSYkhISMj7GD/jdiAoaO3GPERLwK528KNOoPreH2Qu+mUJRXExHQlVd4hHTWxLxvcERNFHkHz0iIVR0ihbCrYtIQg+dm+E5qp+FNVhYCBOU30/C/vrmdvexFutw5AkD9eRyJWCuovplgz2blra5479fschLSs22BcaW9vO9sZwCeGS4pARGlwhISGfaMb9MDCuxt4wa3CfJ/uMvm0Wdtql7dyLcRNu4F0wJLwaC31SBiHuEKspYZVlymUFs6RQGy+gqA6RqIWqOqi6jWUqTBnRjix5pOIGAH7UYVV/BYIAzQ19dAwkGchHsUyFRLqEpjh4ZYm6VB5J8hjoTNL2P7umwnwY7L4T2SHxW6HBNVSEBldISMgnmneuvDB4Iby7b+n3p+PGPNq+dTEjfzwTJV0mUmmA6uFbIqYZFJcu5XS8ooKu2+gxi6XttXiegCR65HviOE6gs7VgzXDqE3lKporvC2gxi8p4CcuS6MnHcazAUyYrDqlIGd8XwBXoLcSQZZe2r18yBHdmyzBclYvf+CKzFh+3wf7L3vgCABfO//LgvtNePnenji0kZFciNLhCQkI+8Uy84nasSpdRt88c3CdVmIz8yUyEujLu2ijljhhK3ALJx7El/JJMRVUeMWZjlDSS0TII4HkCud4YWqpMXWWOsi1TW5lj2doaAHxfQFUdenMxJg/rQBQ90ukiVbESZlZn9coacivTRKoMCh1xFn5uxlDdli0ia+s4nsg/eyby6efO5+xXz+bqBZ/n7XwdMxaexO37PMT5878CwINTfzXY7t53pgLw07eP5juvnc7d7xw6JOPf7QizFHdbwqD5kJCQTzx20kc0RFZc+D2a77wV0RJZef4VNN97MzLBEiOAbSjBsqIrgAelsoYg+dRW5ujPxzh09HK6SknaxAocWyZTjCAIULZltIhNsS9KvLqIIrkIKsx/pxlsETFuk1d0Ro3soiuXIKLaGJaCmNz1sxJV0aVKKSILHiOiGQBScomoHIz9jDnnYHkbF0k+a9zLAPzvhH9tst8L53+Z2/d56KMZ9O5KGDS/WxN6uEJCQj7xLLt0Or7m0/LTmQi+wMrzv0fzfTeBLeD2awiOACJIvSqSISJHHVA9yhmdWNQkU4ygKA4vvDOGpQtH4DgSrilhFDRsW8J2JRTZJVFToFTUcFwJxxVJ1xSI1xeIJ8rous2KlXWIokc2H6FU0Fh5+veH+tZslj8c/Gsq5QKPHf4z7tjvd+wTb2OFUcNh6aVcNfmv/O6gu1iTT/O1V/9nsM2PFx/7gf2t93y939j63PPf+WgmsBuxI4RPw6D5oSM0uEJCQj4R7H3erA89LhrrClav8wAkK0rBN6QAvubjyx5uwsWtcHByQcagUJLI9ccoZSNosovYreFHA3kIQfKCgteCT7msUJ/IoysO6VSRveraqU0WKBoqRkkj1xNHk12UhIkiuTTWDNB6xuUf8R3Zds75z1kbvD9vwr8HX39j/PM4voTty5wx5xwue+MLVEZKNGhZAL7/5qn8J9fMdQs/y93vHMrzraM36Gu95+v9PHb4z3boHEJCdjahwRUSEvKxZuqXbwPg9TumAzD54tsHj028Ing94crbWTH9e4FxFXEZ+ZOZLPjcDETdwZc95CoDsSSB6CPrDvggFGUEl8BA8yBX1IMaiq6AJPn4pkQ6VcQyFOy8xsqeSiTRI5OJMbe9idZVNSiKSzJRQlA8IopNIlamvydJfzG6s2/TVnHXAfd+6PE79/st3534T5oiA9y018P87fCfctNeDwOB2vyXa16l5Kn8z7gXeaE4nisXnMxlb3yBy974Alcv+Pxg5uOUx65i7J9++FFPZzciVJrfnQljuEJCQj62HPKl23j5j4Fi/L7fnIUvwMI7pw8eX3x9kKH49g+Df9u+eTHNv7oVL+bS8rPbaP3Ohkt6zffcjCB6CDEHooDoU5EqUTQ0nPYoQn0ZJV3GLCnEqkv09yQRVRctXcYyZfqyMXxPwMjpNDf2srY/iSx5qFELAMNUUaIWlbHSTrg7Hy1BdqLC6a98gz8c/GvO+c9Z3HXAvVz2xhdYUz4QTXS57I0vcNNejwMwY+FJvJVvoN+MMirRx4Xzv8zhwxUikjW0E9nV2F6DKTS4hozQwxUSEvKxJdJlcdgptwLw2i+nI5eDpcUp029nzC2zGH/N7YyaNXODNoLuAtD6nYto+d2N7P23HwCw999+EBhPmkMqVUIQgweX44lEdQtESMTK2AWVRMqgVNCors2hqEGNRVlxObRlJXrMQola9BWjKIqLpjiYRZX+YhTTULANhbauqp14lzbmuGcv/NDjDy7bf7N9uIh0lFO8M1DDOf85i5Or5jFj4UlUKEUOSS3n8NQSAG5763gArpr8VzTJYVrtYu7c77fcvs9DjIl2MXPvP27/hEJCdgFCgyskJORjxX7nzOJTJ9wMwDOzv49o+Rz41ZkceOZMHB0QQHAh0iGw5JoLUQoiI38SGF0tv70RufNdRffWMy7H9USaf30Lr3/2OqoqC6iyg+cLVFUWqK3OAaDILsqwIqWyiqi7FEsaguCTL2kkY2VkycX3BF5YMRrfF0jEyhQyESTJI1uIEE8bFLM6w2sziLIXREcPEQc9eRlPH3X7h55z2pi5G7z/07L9Bl93tg/j4je+iITHgemVHFi7ikNTS3mj1Mwpyfn02gme6JlM3ovQYaYQBY+73zmUi9/4IvsmVtFhpTjinxdz4BOXhzUX38+OWE4MPVxDRmhwhYSEfGw48sSbmXfXdOSCzbGHXw/Ac3+/BNGBV+//HoILr/98Om/++EKcKIy5ZRaO7rPy/O8B0PrVy3GGmbSd867Q6ILPzUDQgkj63t4EMdVmbFUPricQVy1k0aM6WmRSfSexiElLfR+q6hBLlNFUh3xJJ1fSqanIc1BLK7pqUyprtIzoxXVFRtb0YdsSABlDp6Yqz4rTrtjJdy7IHLxywcnMOf6mrW77xTHzBl/XD19LW6mSnBOh4OrUa1lWmjW0lSt5IHMgI9QBmmL9PNs3nqmp5YxSu7m77VA8X+Af3Xvw1KoJxFWT05rnfsgVP6Gsl4XY3i1kSAhjuEJCQj42zP7HpUzb7xoETeLpl37AESfdghMREYGpp83EbhCZ8r3b8SSIZH2cOLiR4Bd/yy9uw1c8pJhPy29vBF+gtjZLdbTIuCaRSY9eQ+tXr2H/f3yftmwlSd1ExCeq2qzsrUJXbWrjBdqzKXxfID8QZXjDAAOuyIh0Fg+BOa0tSLKL60j0FaPEdItMOYJZVNFiFgndpGcgMST3rrVcRVw2t7n9+fO/wk/2eYArF5xMY0Rl5t5/HNw3Y+FJjIl2syA/nLfzddTreUZEM7xeaAKaSGplFufqiSsmE2u66DHioXfrA9heWYdQFmLoCD1cISEhHwsO+WKQjfjUvGtwYgqHnXIrz/31EsppkWKthFEl4EuAD24ErISA1i8g2kKgv5WywBOQ5CCGS4tZdHenWLK2jqc+9SOiWhC8PZCN0ZzqD0ry+CL5skZNsgBAvxGlLpmnLpWnri6L44mIok/BVskYESYO78Qc0InHyriuiGnLZAoREhUlrJLK2rWV2CVlp963773+Je59Zyqy6LHKqOS3Sw/mjDnncPor39iqfn6yzwMA/HDKo4NxV6P1HgBWlyvotROUHBVdcohIFhVyiU+lFqOKDqPivURlC12yqdXyPHv0zA+8TkjI7kpocIWEhOx27PndjWOMXvrTRRx99I0AlOoU7JjIIV+8jdd+NR1PASciIDqwYNaFOBEfs9LHjgdt1YyIl1OQcxLWgA6+QDmjI+s2guDTfPfNGJbCXn+9kqp0AVn0UGUHUfCpjhexXAlNccgWdIbHMvSXIni+QESxaa4YIGfomI7EotUNRKtL1CXyyJKHJHqI64Lv9bhJRXWetrN3XpHqTz93PtVKgQWlRjxfoOioLCvXkZRNHP+DHw/r6yQCfGPumRsd/9a8rwLw3Yn/BKBGLTBO7+SzNW/SEu1jeaGatWaKZeV6WvReVhUrsVyZGrXA/vGVO3iWHyPCGK7dmnBJMSQkZLfjzR9vOovOSstM/fJtuFERXwQ7JjBl+u14KjhRUPKwxyW3o0oCngpSOfB2mTUOgisgOIDsIes2jiCjqi7F3ihaukxEtdmnZg3/6WxCFR0mVXcxr72R5qp+DEtBEj2GV2XpKKVwHIlxtR1oosNbA3WUDZVE3CCdKlI0NHqKMarjRdYOpBBFj1JJIxEr8/pnr9tp9/Czz/8vtivz6Jo9OWHYYlqNKkbG+hipdbOkUIflSoNLggDnzTuDei3LWjPNnfsFmloPLtufX47IbtDvN+aeya/3/y03Lvo0iwoNOJ7Eytw4JlSk6TNjnFr3GlHRYo1ZwcL8MBJKGV226SvHmNPTEpbz2RzedhpMYQzXkBEaXCEhIbslxx52Hf984QccddxNPPv0ZQC88MjFHPC1WQjrHiqOFni1fCnITLQT64wsHZxI4OESLdB6pWBf3EMwJJxSBLHaRFNsEo39iIJPR1eaN4ThRFSbV1c3M66uh7pUnpKtkoqUKTsybe3V7DlyDYrs0mUkMGwFTXKprsjTO5Bg6sgVzFvbyEB/nMoRBr4PZUOlMl3c7ufo1vC1V/8HVdSwBInh8SxryhUclFzBnNwoomIttXqe1/tG0FF8twbiqEgPF016EoDvvHY6muiwvHAgf1NMajq+TM6J4Pgih6VW8v03T8VwE1ieTEyymFzZSU85zsRkJw+0H0hMMSk5KvtWrEYRXVrzVVRoJZ456s6ddxN2R3xCHa7dmNDgCgkJ2a044rO3IFoe6+pJDxpb67FjILpgxwVEC5wIg1IQvgRW2g8MMCcwsHxZQLQE3JgXPNBcAT/hkIwb9HemEDSXSMzENyUk0WOgEGVSfSdrCymObFjGq73N2K5EQjNJNXbTVYoT1Sw8X6C/EKUyXiJv6LiOyNz2JhrSOarqOlnY2UAsYpJzJNIRg2eO+vDSQzuKb837KiIyh1UuA0AXbN42GnirNAzbk1hlVAJwZN1SFufrufiNL3LrXn/i333jWPDq/9CgZVEEmaX5WkbHe8g5Ef61Zhy6anNU/VJ+vfIwmpID7J1cQ8aOMjLay9uFepKqQb8Vo0Ivsai7nmOa3uG1gUaWd9ZQlS7QFB/YKfMPCRkqwhiukJCQ3YI9Lg3itp772yWoWQtPlzj20Os46L+DAOtDv3Db4Lmv/XI6jh54tDwFXA08FTzVD4Lmox52hYveI4En4DUbkLDxNQ8/7iCUJAa6kkjRQN7BLKsoCYtCWcMYiLC0rwaAuX1NiILP1NqVKKJLRLYZmeynMZFhVXclLVX9VEeKnDzqTSY0dtJS1Y/tSizuqUNXbRxXwoedZmwd+cxF1Kk58o7Ga7kmTE/hbaOBCrnEqEgPE+KdjIt18XamloKjkZBNOspJpj51KU3RASKSzcLcMAxPZVg0S8HVyDsatfECUcUm40SJqRY5S+el/lEUXZU2o4oeI05HKcWyXDWVaglVdnittxFdckgmSvTnopstFxQCYWmf3ZvQ4AoJ2U04/HO3DvUQhpRFN78bt/XUnKv41zOXUxquI1k+B3xtFoVhEntecDuuLjDhyttZfP2FWEkfO+njRnzspIcngav7yHkRwRYwRtj49WXcrIrSpiEPyAiGBAkbMeLglgN9LLcoYxdUcv0x6oYPUOiNAdBbiLF2IMXDb+5LRy7J6kyaNYU07YUUU0a0MyW9lowZAaCnGKczn6AnFyemWZQtBduRdqrm1qhEH29khzMy1kdctvhn9wQUwcX0ZN4p1fNWvoF52SaGx7NEJJtKtUhctmiI5ei1Yrw1UI8u2awtpTBdmT4zRluugiq9SEyxqFHzTK1eyQl1ixAFn+UD1SzN1lCwVbryccYke3lmxTgmVnWzti9FVLYYX9nDsi9dudPuwW7N+iXF0ODaLQkNrpCQ3YTnH7t4qIcw5Bxz5A0AfGpaIM4pOj4v/ekijFoByfRxdRBtkCwYP+N2XN3H1X2ciI/gCADIhoAT81CyInqHgtyqA2CnPNxaC8EW8A0Zr6AgSD6+L4DoI0YctLhJphBh4ph2ciWdhG5SkyygxSxEwSeqWaR1A4CSo/LGwHCKlsqcvhaSehnHE0lEywiCj2XJvH3q1Tvt3p396tnIoosseuQdnWFaBk1yMFwVTXRYU0ozf+0IDki3ooouBVdjca6eJdlaLE8mIZvEVZMKtURUDiQyCrZGXbRAWjWYmOyk4Gi8na/jub6xJJUyk6s72LOyHc8XEABNdBhd28uyTDVj6nt4+a0xvNk1bKfdg5Bt54477mDkyJHous5+++3H888//4HnPvLIIxx33HHU1NSQTCaZOnUqTz755E4c7a5JaHCFhITsspxQde4G75+ZHRST9lSRQ//rNop1EvufPQvBAbNSAD9YOnQiQXA8AoiWgOCBU2vhVDjYI0yksojoCJRrHey0B7IPvoCyWsVLOUgJGySfaDIwjka1dCMrLrLs0VLdz7KuajTFwfFELFdir2HtjKzoI65YLO2uoTcbp9+IsrwzWHrMmxr9xeigKr1pyztdTX5crIsBK8rhFctwfYHne8ZwQEUbGTvCS72j6CnFaK7q5+X+UbzRNYzXehuJyhbT6hZToxXwfIEDKtpYkqmj7MqsyFexoruKtkwFnUYCRXDpt2McVrmMKq3EQamVNGhZTE+mOTnA8FSWfyyZxKqBCiQxyGqIVpZ46+Rrdup92L3xgyzF7dm2wcP10EMPccEFF3DFFVcwf/58Dj/8cE488URWrVq1yfOfe+45jjvuOB5//HHmzZvHUUcdxUknncT8+fO39wbs1gi+H/oX308ulyOVSpHNZkkmk5tvEBISssM5+pgb+dczl2+w76hjb6JUrzDnd99jn2/NwokK+CIsvO1CJlx9O3bMRykI2HEfYV0bf/0LAfDBSbnggWSI+BL4FRa+KxJZqeJEfJyEh1gWSU3oo2hoxCImZUshqtlMru7gxdaRNNcMsKY/jWXKVFUUiKkW7b1pFNWhJlHE8wXW9qYRRQ9RCowL25TxPYHWr244p53BrMXH8UL/GIZFsiTlMjlHZ7iW4cX+0QA0RQdYU0pTdFRa4v1ookO/FcXxRVqzlTQlB1iTT3NkwzIcT+Sl7pHkSjr7DVvNlEQ7JVdjcaGeMbEenu0cy37Vq8nYEQq2xr7p1byVb6CjlKQhmqOjlKS/GEVTHOaeeMNOvxcfBTvjmXHJJZfw0J1PM6nqqO3qx/ZMnll1x1aN9aCDDmLfffflF7/4xeC+iRMncvLJJ3PjjTduUR977LEHX/7yl7nqqqu2adwfB0IPV0hIyC7DCXXnDb5eb2wdcdItABxz1A24msic3wV1D+ffOR0nEkg87PndYPkQEYyRFm7MQzIEfCFYQvRUH7ko4Ck+Ul5CHZBwI16gu5VTEBUXVwuMLV/z8GoscourcNriDPTHMU2FkqnQZ8ZIJwyWrahndE0vleki1dFA+HR4dQZVdlnbnyRr6KSSRTTdBkCSPLSIPSTGFkDB1YnKFvVqjjl9LUQkmxf7RxOXTer0PBk7QlI1sF2JvKNRdFXKrkzJUamP58lbOlOqOug14xRcjaRq8pWx8xgd7eWdYj2/f+sAErJJxo4yId2NJjos7qtnSmotf1m1J5rkYLsSbfkKsoZOdbz4sTG2di47P2jesizmzZvHtGnTNtg/bdo0XnrppS3qw/M88vk8lZWVW3XtjxuhwRUSErLL8ETXHRu8P6Hy6/iiwKH/dRv5Ro3n/n7JBscXX38hggu5MR520sOJu+AKIEK5wcFJO5SbTSRTwKrwkEtBOR876SF4AgjgSz6+J+BqoGREBFuErBLIRADKGg3fFahJFFm0qoGYarHP+Fbe6agFoK2/ggnpbrpzcYqGiqK4RFSbhGZRKmiYBY3Fp1yzU+O13k/WiRCRbJ7umkBCKdNrBkueK3OVrMhXkbN1MlaUEfEMjicSkWyqtBID5QiOJ3JI9QqKjkre0QCIyDZPdUxkfqaR1cU0J41bwLyuEWiiTVc5wfJCNVXRIs90jKcyUmJNMY0PjE71oikOK1prh+xehATkcrkNNtPcdB3N3t5eXNelrq5ug/11dXV0dnZu0bVmzpxJsVjkS1/60naPe3cmNLhCQnYRDjvlk52F+F4O/3xwL57o/w3P/+ViXvzzRbx6//c2ea4T89H6RFq/fRFKRkLpkxEsIQiSl3wwJZZdMn1Qh8tOBAH0Yjk4R85JyGs13LiL3WRS0TSAH3cASI7vx240qaossGptFV5eQRY93u6uC4LpgXTM4JX2ZkTRR1VdzLIKwEApQjRu0nbWzivV80F0mQk6jBR7pDtRJZdVxQqOaVjCySPe5KCqVvZMteN4IiVHISpbRMRARyyllcmaOquMSnrKcQbMKANWFMuTqNRLjE92MSW9li4zGchd5OoZk+gha0UwXZlTR7xOTaRATLboy8V4o2s4liPR9j9Df092S3y2P4ZrncJuY2MjqVRqcNvc0qAgCBu8931/o32b4oEHHuCaa67hoYceorb2k21oh8KnISG7AEecdAueHv7+Wc/zfwkyMg879VbMhMR/7pvOlAtvx0oTxA0rPqIrIJrgx0HwYPw1tyP7AlbawxdBNAWkrIJcFGi+52ZkVxkUPBU8QAA3EmQr2pUeeoeME5foNyUE3SVVXUAQfCIxk2HxHCMSGbJWhLbuSlTNoboiT6GsMZCLUp0ukCvpmIaCpLh4vkBCN3lp2s1DeRsHqVRLHJJazj/7JlKlFVlbSPFMx3h8YL/q1cE5Wol+M8qy/momVHdzQLoVUfAZHs2ysL+elFYmqQaZltV6gbhsYbjKYJZjbaKA64ksGBjGHukOOstJFhWGUbA1io5KbapAU2KAjlIYF7vN7AhZh3XtV69evUEMl6Zpmzy9uroaSZI28mZ1d3dv5PV6Pw899BDnnHMOf/rTnzj22GO3b9wfA8Jv+JCQXQAnIuLJwa/F9UKen1TWx2xBUKrnP/dNZ8r023ED9QZkI8hEtGP+oGGlDkDt/MAr5UsgOuDJwWuj3kUakPFkH6+hjC+CZKzzgPkCTszHl3zSU7twqm0QfYR+lZhmkS9ESEbLLGpvYE0+zYql9dgZDc8TqIqUGJbMIa0Lii8XVSoritSkCwC7jLEF0G9FmfXmMVSoBpYnE5FtmhIDTKroouhoNOr9HFHxDg2RHJ9rWUhMtmgzqpkY62DxQB2nN82lZKu8uXYYKweq6C3HeXltC54vknc0lueq0SSHEbEMiuiyqlhJtVbkP51BpqPjiUQVC010ePboT/bne7vZQTFcyWRyg+2DDC5VVdlvv/14+umnN9j/9NNPc8ghh3zgMB944AHOOuss/vCHP/CZz3xmx81/NyY0uEJCdgFe+uNFvPJAsGQ25/ebXjr7pPDcX9+N0zrga+8qsAs+LLn6QopNLrIRaGNZlR52wmfB7RciGS7lWhc1I6IOiCAGqvK+7EODGcRr+QKe7uPJgeq8r3iBgVYS6epKI2ZlsEU8zWPtOzXYZZnO9gpcR6S3L4FSUQYBGisyvNU6jOXzRyC/EcdyJCJxE8NSKJnqLhcQ3lVKcnBzKwv6Gpjb0ciwWBZZdOkqJ2gtVLK6XMm/+oP4rn+uHU+lUsT2RZYZtciix29bD2REPEMsYpLpSuD5AmOreug240GJo7qlyKJHg56lOd7P5NRa5nQ2EdMsFvXUs3/VKnTJ4Z4D7xnqWxGyDUyfPp3f/OY33H333SxevJgLL7yQVatW8a1vfQuAyy+/nDPPPHPw/AceeIAzzzyTmTNncvDBB9PZ2UlnZyfZbPaDLvGJIDS4QkJCdkn2/cYsEGCv82/HjsGimy6k+de30Prti7ATHp4clOgRHWi5/yb+/dRltH77IgQ3aK8OiNhVTiD/0K3hRTzIKsA6Y0v2QfbXGW8g9qjIJQFUD6kgITgCkuqBK6C2apBR8FbHkHMSbS824tsi0TFZhP2z5AoRLFOhbKjkizpTHtu1Ut/7jSiWJ6PLDjHNYmFvAyVHpU7Ps3fFGl7vG0FCNllTSjOxsotF2QZe625ExCeqWLiegOVJWI7MifssYEyil+ZoPxVqCVHwmTfQxKGVywFIKwavZ0ZgmCqH1a1gdGUvj6+cNCiWGrI97PwsRYAvf/nL/OhHP2LGjBnsvffePPfcczz++OM0NzcD0NHRsYEm1y9/+Uscx+Hb3/42DQ0Ng9t3v/vdHXYndkfCGK6QkI8hJw77DkQj/GPZjg3EP2Hi5TyxeMt0d7aHg86YCREBKy5gvSfkJ7JaYdTtM4Pnju4iOCKSKSC1ajTffTP6ahVP93HVQG1eysqoWQFX97HifvCsEUGuMhCWx7DqXexaG8oiRH3EPhkxJ+NLPl7MRVml49bZ+OOLYMrU1GTp6k7h5hQEQ6QpHXi6fEtE0F1iiTKy6DGyom+b537xG1+k3UijiQ6Hp9/h8d4p6JJNU2Rg8Jx9om2ssGpIiGXqlSw/bTuaY2qX8OpAC6fVv8rpY1/doM/G5AAZM8g4bEn101lMUqUVWdjfwIR0N32FKFqlw4qBKkxb5vo9/8Kty6exolDF8GiW5d3VrPCrOGT4Shb2N6DJDoroMi7ZTXWkgCj4vNg/mn4jiunI9HYl2WN0Oxk7StlVGF3dx4NTf7XN9yRkHT7gedvXxza2P++88zjvvPM2eezee+/d4P2///3vbbrGx51Q+HQThMKnIR81B351Jka1yILbL9z8yQSFmSXTI9ui8MbPtqzNptjrf2/njZ9ue/udzT7/bxZmhYCd8FGzAoVRDoIr0Pr/LmLMTbMQfIJi1BEfPIH4aoHiMB81J1Aaa6KuVfHW/awUHbAqXdBdhEJgVIllES/iIeclnKRLtE3GrA6C7pW8gDncRihK6MOK2JaMa0mkKopkB4JaivuPaWXAjLKioxpBgETcCLL9ChqS7LHsyz/Yqvl+Y+6Z/Hr/+zfa//iKybRa1URFk14nCEY/PP0Or+ZHcXBiGc9mJq5bBpRYU0ozLJLDcBWW56ppSvTzwpKxHDfpLVrzVRiOQm00z8pMJc2pAdYWUlRG3i3Xk7UiVOmBeGtrthLXExhf2UNbvoKoYmO7Erps05VPMLqyl75yjAqtRJVWYk5HE5NquhiuZ3gzM5yJqU7+vWYMCz83Y7s+B7s6O0349OdPMCl5+Hb1Y3smz3TfFT7fhoDQwxUSshM57JRbMVMS//ltEKe11/m346qBUvqH8eLDF3HIF28jvdzi8M/fSq5Jxo4DAig5cCNQtchm9uOXcPw+V/Hk/E0/4NYbW9MOvBbB8XjytWt36Py2l0O+dBsv/fEigCBQvkLAk0EqC1hJH7VPwhdg3HWz8GI+Sl7ETni4MQ+xJGLHBOSygKeCUJDBW2doVTtIORk5J+EXRTzVR8lJgcMg5eEkIbJGplzjIVoC6pg89rIEQklCrDZxHJGGqiyuLzA61csKrZpcWeOt7npcV8R3Baqq8/T2JJFUl2TSIJuJDs7roCcvY87xN33gvPvah1M1vJ0jUu9w81sncOmkJwA4Y845fKf+GT49qpU7lxxJvxtnsr6a8fpaRsn97Kuv4o+ZA+gyEtRqeaqk4rpi1Aoj1nnE0kqJE/ZYRKeRYGyyh2FahqWlWhTJGzS2OvMJRlX04XgSbT0VrHCqmTpqJaLgkzN0Xl48mvGjOmjtraQ6WUSVXIqGStaKMDHdxeJMHZYnM66qh4Kt0eZV4vkCb/YPRxa30yMT8i47MEsxZOcTxnCFhOxEXvi/i/nPvdMH34uWj2TCPt+axfF7XrnBuQd/ZcNsLl8SsFIyriqQWmFT8Y5L5WKH9AqbiiUOsx+/hE9Nu4kn589g2oGBIXVC7bc2OY6nXr0aT991fm/tfV4QHL/e2Bp74yzsWGBMCh7gBf+6WuC9Ek0BJS/iiz6iKSBnJURHwGhwseOBgrxUFHGjPlaFi5STERuLODU2+AKRTglX95HLAoIRxGvJBqg5ESft4r6dgCYDX/dgrY5tKPTk4tiuxILuYfRk49TEi5TLCoriIEg+PV0pJNXFtUUy7UkE0Wfcn2cw5bGrqPzWh8cvzTErmLHwJL469hUunfQEv116MJe98QVOr5nDXT1H8OjyvVhlVmF6ChkvSp8T58aOEzjrza8xp6+FccluOspJZveMBSAiWSwt1PJa1whk0eOE9Jv0GnFWlSqY3TOWoqNSH8ujSi6NsQGyuSidxSSq5JBOGESigQ5XV1eKCXXdyFEHWfQ4tGkle1R20JFPMqmhi4RSprscx/VEcqbOG6tHkDN1yq7CqEQfZUfm9c9e95F+dj5xDEEMV8iOIVxS3AThkmLIR8l+58xCsn1EG+yYgC/Ba7+cvsE5e51/O1LZ57VfTeeAs2YFXh4z+FNVC4HHwFPWFWtWBCTLxxdAG3B49p+X7bS5HHPUDTzz7Pc3eewPSw/cKJZoS5h4xe3YKR9hZBHXFamvzCGLHic2LGJBfjgv/WcCaibwUgke4INV44ArIBUlRBfspIvgBjIbYpWJN6DhR1zErIxUFpALAr4CVjrQ4bLSHkpunUSE6uNrHoIlIqYtRMnF90Q8T6C+Okvn27VBfFefTNVe3eRKOqXuGEpFGdeWkGQPu6gwcfRaXE/k6aNuH5zb66sa2btp9QfOfdGq4ezR1A7A2a+eTZ2W46a9HubBZfvzZqmJdwq1jIt3U6fkaFT7UASHF/PjMD2ZA+IreSk/hr1iq5lfaEYTbWTRY0FmGBc0Ps1DvQfRVU5QqRUpuwprCymGxbMs669mTGUvr7U1MWlEB0VbpTsfpzGdISpbrBioIq5ZjE93E5NN1hopclag0TEu2c3sNWOojJVQRRfDURgWzzJ/zQgkyRtSdf2dyU5bUvzp40yKH7Zd/dieyTP994bPtyFg1/mJGxLyMebEMReTn1ILAuiigBUTcXRw1UBXCmDfc2chGz6uKiBJwb79zpnFvHuns9/XAw+QLwq4qoATERGdQPZANn1cRUB0fUTL3anzeq+xtdf5t2NWQHy1z9y7p/ODv32Zy2O30nbuxVvV5+LrP3h51escy5SuYRQiMQRTRDTX6Wl5AnLawksI+Gt1BEdA65XwJXBMHT/qoXYoeBI4SQ+30cLLKSD72KwLwM/KaANBQWsrKeArfpDd6ILcVMR3JDo6K/CTDkJehpYiXe/UgOijVJdxygoUZJyEDY6IKrq81VW9wfg/zNgCBo0tgMPT7/A/417ktreOZ3FxMsdVLKRBzRATTUap3aywajkl3sYKM8saq4Il5QZMTyYtlTgqtZhXCqPxfIGWeD93tB9NXSSH5wusyleSK2tURA1WZqooWwrthRT/M+Ul5maayBg6guCztKOWA5rbqIgGNRZf7Wgiqlk4roTpSDSlMyzL19CQzJE1dWTVQ5FcFvfUMaIqQ8bQt+r/PSTk4064pBgSshP4x7JbeeH/LuaFRy7GkwABRNdHz/jMvSfwbkX6vCAmywi8X6ITaE/td86sYDlN/f/tnXd8FVX6/98zc/tNclNJAwJECEUs2GhS1oK6q6jrAroruLr6dS20FV2/NuyIFMsWy8/Fta26C7iWlfaVsigiIiAC0gyEkhBSb3LrlPP7Y5KrEUIRQhTO+/WaF5kzM2fOOfeQfO7zPOc5CqbHtmgJBYRq/2y6FFRDEMlQCXb0ArZ4a6T/lU8y4OeT99eso8bAi59gzTPjiOQb7O1ncNot0/DuUQ9bbDVy6uhvrUJ/WD2Mlzf14dPtHQhbcTqmV9n7HSYbWHaWB5S4ihFxJPZGVEwFPWARy9HxlqtoERVLAzPJsq1WO21R5k2PoMYU3HscWC47g70WBctngQpaTEGxFIztSajbvIiwhuKwULOi6NUeFAGu7DBGzIFS7URNjyFiGlqyTkXET+7rP0x0vLP1VK7v8jFzvunOHd3n8tJZL1Nj+vkmkkWVkcSblb3Jc1Tzr7qOhC0XHd17CRoeBge+ZnGwiBrTR8ARId9dzaqKfACW7e6Aaal2ElKXTr6/Bk21OCmrgsE5m9EUO6ZLCIVQvQefL8aasjx0U8PnjHNq9i5y/UFyk4PEYk7KQ0lYQkEIBbdmUl6XRJo7TLvUGupiblb9/NEf1HfJgRAIYR3hIZ1arYUUXBLJMWLQhXbQtCMqcIYte4n3d373CQ0UExxRC2fYQosJLCdYTrvc8CtgQSzFDgo33LbwigUUDI+Ct9LCEbU459dTcURFwiq2dNYELLfC4PObD9o+UhZ/aO+Nt/2mCWy/4U5W/2U86yb98NWQa5759tkkLca53m2c6oJiw6Qu7gYLnLtc4BBYHoF/l/2rTJgKZpKF5TdxtAuh+g2imba71cgwEH4DM6ahAGgQCXowAiZqTMHwW1hO2+rorNHAAj1Lx2wTxwwY6JkGaoqOy6OTmVqP4jNQ20RxuQyoc+DIC2OGnKAKHE6D3ZuyElsUHS6XF64B4KJO6xNlHZx76eTdi6pY1BsuPg93os7y4FPt+LCY5WRjNJfO3nJmlvWiPJ5MreFDCIUBGZvJSgqR4QlxSsZuaiMeUp0RMn0h2vuq8ag6C/d2YU9JOg7NIiU5QmZSiLPzS4gaDtr5a3AqFj6HjoqgsE0Fye4Yqe4Iya4oTs0kJ7mOL3flUVqX/KNL/HrccDT2UpSCq9WQLkWJ5BixaJ4dW/Xff0/g3MuexHQpiezy8G3AeCOn3zwNZ0igGmB4FLSoQIsDDfvFWi4wvXYcl9BsIWa6QY3b51q8wU0ZFbgaYr3O7/cICz4+9FQFgy6chOnR+O+7tnC4YOG4JjFJ36XrfdMxvYLN/zt+v9d/KH38m/nZgrG4k2PEKr0k5dQjXBaKoaHVqQiHINQ9BjEV6l3gN0ATxOrdOH1xDI+Fs04lngQYKs4KB3pOHGIa3pQo+tZkojkmCDCSLVRdtS2ILguH18AIulAjtqCzTIW47iLeIY6IahhxjXpdBQX0qANfehjTVNFjDrbddseBO3aYXNRpPRc1/HzLyt/wVV0enfwVPHbKLJ79+mekOsOELRcFWgWdkirp4KkkoIW5OH89C/Z25ec5X7G0qpC27moyk0JUxJIwLBULhdnbT6EgUI2WrNMptZKyUAqWUNham4lTM9kSzKQ24kE3Nc7OLWHZzg5E692YeSpRw06oGjUcdGpTiarIP+gthkCuUvwJIwWXRHIM+dl5j/PR/92NYgmWv3bgLXw81RaKANOp4IgK4g4FodrWLssJznp71R6A7iMhxBSrwVrWkBJB9ylYmoanFoTqSrThQPS+ZiqeCp1F8/5Iz/HfCqz9ia0ef5yO4QVFtfcv7PDnKWy79eiIjV43TiOceyNqhoVZ6URrGyG0IxlfqYYjDPUFAs9elXCShmuvRjzDBEMFAxRDwQz6EAEdM8NCqXCDKjDyY2RnBqlYn0k0loSqCbSQiqtWwUiy92c0fRbOSgemz0Cr0+w4rfYh4jH7V2b1rgC4LPxpEaIRF2277GHHnjTCNV48KTGKf73/hQSHw1Wf3ExZKIVL878koEWwhELYcnOSu4wCby5XpRfz6t6+jFs1nIiVz9yvu9GjfSkbg9k4VBNdqBiWRnXcS6+0HXRylxNNdbIzloZDtcj31rClJpMBmVvw5sX5siafzLQ6dtalckneOip1P+tqczknYxub69sghMIp6buoivvJTQ1S7fJiCYW4odEzo5Ra3cOWqky5KlEiaQbpUpRIjiWi0Wp08P96y96yRYumC3s1o8OO6VJNW3SZbjDdtghTdbtM1UFPVhLb21gNbkp30EL3qVhu2yJ27mVNM9AXPTidM26Yxhk3TOO8AY/y6Rt/wHKr9Bk+BW+FRcdn9t1w+KRJ0+h273Qs7dvAf8UC726Noof2FWZd79+/ZexAfPHieCwnFI/5A1vvGI//Mx/bbruDDY+OI54KvjJ7HH3bHQgHuKo13OUaalgFCyy3hVblxKxzokUUhMciOSVC+d4UVEPBWafgrFcxAiaxTMsWbIot1owUC2GqKPkRnO1DRKs9CEPFCjvIbFeDOzmGqlp4fTFKStPRHFYTF/GR8q++z7H0gsnc1X0OOY4abum6iDu6z2VluCN5zhper+jDnmgyu6KpAAzpuoGTU3azqy5AnreWJC0GwOCMTTgVk43RXBbv7YxDMcn21vGf4u5c3HY95Xoyc7Z1I9tbh9ep43fG+aoujwsC68j31ZLmCBHUPQzM3sxHJV3YUpOJaal0SK3C69BxaBYl9Wl8XdFGiq2WRgg7U/yRHpJWQVq4JJJjiCOkYznVhHtxf/QZPgWw826ZPhWELWQUy7ZkOSK20NLiAsUSoNjnjV+f1Lj9Vz8WUPBU2yIglqKimoJYisbSWbZL87zBj6H7HQQLHGgBBW+VrdKEU6X/FU+ip9hLJQ2PQvoaO12DYsH6x+34KtX41tpmYQecC9XO+i40EqJr4/3jOGXsdKyMIx+/tdPsd/e6aRrRM+32br9pAp0fnYaerbP9OjuWrMcfpxPOsdAiKkayCaod6+UudRCuTsUTtK1Zpkfg2qOgxFUUQ8G1V0NPsxLB90Q1TFVgVrpxZkZJ8kdxOUwicSfxiJN42EVGZh31uoqhgOox2fjLI9tHcdqGCxjfbX6TssaYrhtWXAekYgqVAm8lt7b5iLdrzqLedFPkK+P/KroypO0GkrUo7+3qyQW5X/N/FV3ZtDeLQQVbyPPXsjOcSmFSBTuTU3mn+BQyk0IUZZWzsz6VFHeUbillfFHVjq9judTqHt7ZdRqX5X3JlkgbRndbyMq6AnaFU0lzRQjpbvbuCWBmKWT4w0fUb8mhIBOf/pSRFi6J5Bgyb/n9LFi6bwzVoAsnce5lT9L/yidRTUBRUKyGAPuIHcwdzlGIZNuHIgSGV0GLgWhY8eisE6hxgdIQ06UIiCcpWA47ZUQ8yfY59h02BculEMpxY3pUUkoMMtfqGF4Vy6FQ08nN0tkTWP76H4imq0TaKMTSFJz1JNyWPe6cbqdc8NuiJR4QmB5w1itsund8YjudjfePo+ih6bYIVARFEw/fyrXpvn2D7794YTwpGx1sv2kCPcdPZ/M949l+3V1c8+mNgL3RtXDZqz2dtRoY9oIDPUlgOQR6ksB0CVzVKrE0gXBZGAETPdVC+EzwGzhTo6Tl1SJiGkntguhBF3X1XhRFkOaL4PQYODw6Ud2BMymOogqKrzlyV+L4bvP526Z++5TP2no647Pn89JZL2MJhQo9iV4FJayuaUsbVx1OxWRAxuaExUsA6+py6Zexhe7ZZfi1GB28lbT3VxMy3RSmVPDbzsvI8IQoTKogajiojPjYXJdFe381FXoyI3M+4Zf5qyiJpdPDv4u3dp3JjlAaKc4oG2vaUJhSwaWnrKG6MpnF50054r5LJMczUnBJJMeQi3Jv3W+5FrP477vfpo1w1xhYDoj7FXSvbeXy7Rb4dwnc1XbqAhQ7cSqKbWmKB2xxpRg0uBntb7KGFwyvgiMKphOiabawMjwKsWSVcKaDWIqGFhfoPhVFwCljpnPardNQTDto33JCLN0Wd0UPTieWIXAGFZxBWxgCOMIKeoqg07SpqHE7vqzT9KnofkEkR8FVY2dzL3poOl0emUafEfu6KQ/EL/57e+LnAQsmwEB765pGqxfAG71fBKDDq4/jrFYRKugBE0+ZA3eVase16XayWctn2as9kyxclRqKx0SNqmgeA+od6DUearalgiJwqBZ9Tt6CEAp7ygOE4i7itW665+4hyRND0wT+pOhh9edAXN/lY8C2dgE8vu4SOjgqear8PABUReBUTG5Z+RsubLOeTaE2zNnbg2tS1rE7FKA8nkyX1L2kucIs2NON8zM20MYVJFmL0t5dRbYryNrKXGZs7oOqCD6vbM9lbddiWiouzeTrmjboQmNBbQ+iwsHOcCobwzkUBcpJcsbwO+K0T65mY20bDKGxbeSxS7Z7IiOEQFjWER+S1kFmmt8PMtO8pLXof+WTmC4VhEBoCqEcFXeNsFMVhO3/qqZLQfcrtiVLsV2NhrfBxdeQed102z9HsxqEUb1tLXOEBaE8FW+5wHLZ7/xuDJjltAPfDb+Cs16w6q/2isPud0/HWQ96csO74mB6BDQEyhsBEzWsouq2AFNM8OxVMHxgehrTXQCW/a+rVlA+SGf7b+866mPYadpU3JUq4QLDFlKGYufWcoK7GkLtBKbfwrNbQzhsYSgcYKSY4LRAtwUubouktDDhkBtR5YIUw35ByEFSfpBQvQenyyA1KYKiiAPulXioWGWdUXM2H/S+xr0Zn95wPmO6LWDahgvwqXH+sfMsFp83hZc39cGj6rxfeSo/S/uad/acTshwkeurpaOvkldW9OH23h/xt019cDkMhhas5cNd3emVtZNBgQ0ArKjvRL67mlQtzBDfNzy65zxO9u9EFw7eLTsFvyNOxHCS5a1PCN0TlWOVaf7N6e/SzXX2EdWjizgLI2/Jv2+tgIzhkkh+JAz4+WTMZA0tbge4A7hr7FxcKGBptjXL8NmB8pZmiyz4NsbLckD4jAhbBs9gWlUnnl16PoGeNUQXZyIctlBz1gli6QrOoLDdl6LBUoa9fZAjaoskw6tw8gTbBagZEEu136VFG1dBKlhO223nqtDsZKPJ9ubPllcQOieCe60PZ51dnxq3DxSIpSpHRWwVTpmGkalDVMWTFSFa5UFVNWIZFlqdhuG149yEQ8FVbY+bUMC7UyOeJnDUK+ipJrgs1DoHSkjFalic4MqMEN6WguW1cNWp6DgQXoukvDrqqn04PQaxOjd7d/spHn3gFaeHyqGILYDlQyZx0eIx3Nx2Lw99dSk7orlUxvxclf8FAGtC7ens3cP5aeuZV3Uyeb5a/FqMHZE0krQoZ3UtZubO00j2Rsn1B1lV044uaeUALKrtxmlJJbRxBfmooivdUsqYV9mDXE8tX4XaEjTcBFwRHKrFjmCg2TQhkhagMQ/XEdUhbSythXQpSiTHmCGn3bff8iUf3IlqCKIBzU7t0OAqdEQElmZnmTfd2BHqKrYr0YJ4yreWqWim4Jur/xc1ZzPj07+h+LIX6JhayYQb3qbzlZuo62QSS1MwXaAnKVhO22KlxW2Ll+FT0H0KzpAdAG85GoScyxZ3aoMVrDGQX40pqHH7MD3C3qcwquCqVnFt8NlpLCzbsmR6bAtZqJ0gmgknPTFtv+NwOGy9w47dcqTGSXk3iczlDoTD/oNiuQRq3N76x3QLTK/9fjPVQA8IrLwopk+ghVWUsIaVqqOYCp4KOw9XtNaNcAqUuNIwDgr+rU6iGwOo1U70WjeK0yK1sCrRntu+uAaAy5fewmnvH3q+s8Plt5/9ljkDn2a3nsb9J7/HKUk7uarNSt4oOYthy/6HL2vyWVDZjb+V9CdsOAnqHnZFUtldHyBZjdItuYwsb4h2yTVUx3y4NAOvplMT97K+Ood5Fd35YHdPMtwh2rps123Q8OJ3xHCrJoMzNhJwRmQ2eYnkMJCCSyI5xsxd/XCz1z7+1x1EshXq2qoNwfP2/onuoIXS4DIUjgYXoPGtIHLWN7gGDdstZZV1BqDcDHFN9nIe/PxSVu9oS/dTSnjot69hnlmHd0i5Lb68CrF0BUdYoOq2RS2eoiTyeBleO/s6QCxdYLkFwmm7FA2/heUS6CkWjpCCI6ygxmyxg7BXLNrWMtAidhu33DkeVbfvKZxy5KKr8MlpbB1xD3vPi7Py/423E44q9rY8KGCkmmgRBcNnB8tjKBhegaPYY4tKt0CLqjhLXTjqFSIFcZw5YdBVhNdEOAVGiokzL0S4nYmRHSdpu4oaUXF7dfwvpXL6B/dw8rv381l5ATevvJYcbx0nZ5Vy3sLxzPmmO//75ZXct/byA/Zjf4Hyz20cuN97Z5w9gynrh/DSN/Yzt3f9iEoziVs6LsahWOT6apnV769s35VBmitCB18lHXyVeB06L27tx4LSInbXp+BQrMR2PyHDTWk4BcOy/yx4HDrDMz/jleJzSHVFqI57qYr7WV+dzdy9PdhYk31kH5zk8BEChHXkh6RVkIJLIvmRsW7SOLx7BYbHzpllaXby0sYVgs56gRazVyMibPHVaOUSCvT40y10fO9Gurzye27bfhnP7RhI57xylBIvX39ewJ2f/ZJYmY+9GzOJpQnqOpkohh23JbRG16Jdd2O8VqOb0VWjoEXsFX8IW9RYDnCE7GB70y2YcdPTaFE7MN0RtrcfQgE9xRZwp4ydjqMhg4DpP/Jf/kaGTsELT5KaXs+IZTfZhZbS4PoUuCo14m0MLJfACJho9RqOkEI8y8TMjuHNq8f0WOhpJrE2Ju7dToy4Bgpk59bYlkSfARuSwQSl3kGwyMBK1dn4y/uJ3lhNfkoQvztORU0SayrzqDdcbK3NREWwLNSZr+uy2RtPTljAAC5ZMrpJP7bHmm50DXBz0eIm539c88vEz3d0n8vKS761MN3e9SOu7fwpQd3Da+e8BEB6Zh1d/HsYnLweVRFUhH2k+yLsLs6kZ0Yp2+vScDsMwoaLoO7hguyv8TvjJDtj7KxJ5YXdA+iX+w0f7+pIeTiZhVs741QtiqvSWXJ+01xukmOBQFhHfkhah1YVXBMnTkRRlCZHTk5Ok3s2bNjAZZddRiAQIDk5md69e1NSUnLAemfOnEn37t1xu910796d2bNnt2Q3JJIj5uL825ucfz5jPFpcoDXk1FLMhuB0r0I82Y5FQgANmecbN7rWYrbA8W1zYjkFK1d0puSjAjbvboPVNgp5UbQdHjxlGr5SFc9ehZTNmp1QVedbN2Wy/bPlsl1x8YC9MtJ022XCYefaMl32e4XDtmg5Qwr/M2UMWtRulxYFV53ddjVuW8jiyWD4wFuq4qhT6TR1XytX1/unU/D8of1BV+sdaClxQmvT+fy/Xek0fSpXnPcp8QwLR0jFVaPg3em0A+XLHHY/fLarUEQcREqTUNLs/QiT2wbRUwRZGXU4U6NUr8wCVUCdk3i6iWIqaGEVR1BDqXdw3sLxVFYnUVqXQl3EQ7usahTg813tqY+62fRNLq+uO5tNlVl8uPZkanQvhW8+yoAFEzgtdSeXL72FcauGc+GisWQ7a/fbv0aLpVXWGROVZ7/+GQDDlv0PAH3m3cVVn9zML/57O5csGc375z5L//l38tzGgVxfuIwZG3rz7+pexCwHhWmVZHvr6NZ1J6vK83GqFhHdyaad2Wwsa8N/dvfAQmFNeR4BX4Sw4WLF3vbkJNdRG/GQnR6krCaZdUMfPKTPRnKUkRaunzStbuHq0aMHpaWliWPt2rWJa1u3bqV///507dqVRYsWsWbNGu677z48Hk+z9S1btozhw4dz7bXXsmbNGq699lqGDRvG8uXLj0V3JJIfxIe7nt2nbPlrf0AR9upC06sg1IYM8g2B84bftmhZTtsipZj2/omOqB1z5apR8e9QcdaBb40XK+TAqnRjegWaDvUdDISjwRUZx86p2JBOQjUhngr/O+yfeM6qxPDZrkZ7FaSd/kGLKolgfXeV3bbGbYXC+VYi+7xQ7HZBg6hrEItaHHy7FPw7batapzcfpcNfp1Dw4mS0uB2IX/TgtwHZHV7ZdxVgwXNPokYV1BIvlsPWoIqh8O6HvVHiCpvuG4ee3CAGqzTiqRZ6qoXlshBJ9qpERVdwbfWCAnUlKVgei6qgD219km1FtBRbYPpNyIxhZOmgQNH/C7L1q3wUVaAognjMwZ7aZHaVZGBZCgFvFFdKjK55e2zjpAVhw4XXF6M24uHL2nxKQyl8WZPPzppUZpeeTv/5d3La+/fSd95dXLJkNP/cckair2rOZgYkf83nwQ5c9t/b2FSZxUlvP0yyK8beSBLrduSyYUcOp71/L2VVKUxZcz7z93ZnYIctrNjbnve2nMyqknZ8sbst9XE3AW+UTG89e6pSyMyoo1vOHlLcUZyqSftADWUVAbZVpBNwR9FUix5ZZVTUJqHH5VorieSH0KppISZOnMg777zD6tWr93t9xIgROJ1OXn311UOuc/jw4QSDQT788MNE2UUXXURaWhr/+Mc/DqkOmRZC0hoM+PlklnxwZ+K8/xVPsnT2BM787TTbooUtZkyPHeyuGLY4ssWYLZoaRVjC3WjYIkco9jXLabv9knbYm1krpi2yGvcbthz2O0JtLbYOfy7Rlo7/+R1YClgKSlzBUW+ngDDd9obajfV6y9VE+gVLIyGuGldaGh7b4mV4GoLxnQ0rHhu2K4pmWQi3wFmj4qhX2PDoOE566xEMXUPb7cZTqRDOs9BiCobfFkvePSqhjgaOWttS566ws+5HMwTePQp13eMoIQciycC7zYV5cj3CUmCbDz3NxJ0ewdyWhBqz3aZazI6TM3wWWljFTLbQ6lRM37cWs0i2ha9jkIA3itthUBXyEdMdRMMuBnbZzOel7VAVQX2dB39ylHjcQazWgzMpTpI/SjTuJBp24fLonJa/i4AzwldVuewuziSnQyXhmAuXwyTDF2JO1w9YGYtzhtvFiOKfEYx72LAtt2FCKCj1GmhAso7TbVDYpoJv9mZgGhrKNi/JPSsJRdzEKr14MiMUZlVQXJmOaapYlkJeepDKkA9d1+xnVIt2mTXsqEjFiDlweXUyU0Ls3pOK02Ow+Vf7X/RxInOs0kL848nZdFV7HVE9hoizSLwj/761Aq1u4dq8eTN5eXl07NiRESNG8M033wBgWRYffPABXbp0YciQIbRp04ZzzjmHd95554D1LVu2jAsvvLBJ2ZAhQ/jkk09aqgsSyVGhUWz1/dUUBlw6GcOj0mfEVBQBzohokmer0dIlNAU1brvuFGH/q5rgDH4bh2U5GlYZNrgM/btta5kjYrsstZh9eCssXLUC0w1bhz+XSFHwi00Xk9+2CmdyHF9WyFZv2PFRtivS3pMwabuaCIwXip0olYYcYY2C0HIKDI9t3bJctquycUsgRYB/l4q73N6E2vAJOjw7FYp9eL/2YLmEnVcsP4TSMQQqiIw4epLAvcc2b3nKFWJnhFg3aRxbJ4zHdIMadOAIK7h3OYllWJglftjus7vhtNB3+THdDXnJVLv/eoqJs07F8gg7Xq19BJFkopgQKjBoswK8Lp09VSlU1PtRVYtoyEXb7GrWVebgd8ftJKIeg3iDRSivXSWKKojpDrpk7SUQCGMaGjvqUllR1p6o7gCXRdzQMEyVYMjD1rIsLt88hOfKB/NuyMfbfZ6nuCIDh9tEqXOgukzUjDiZHaoQYQfxWjfFizoQq/LSs+0u9DY64agb9ctkAGLlPtZtbEss6iK+x4dpaFTU+1EUQazKi1HnxO+N0zNtNy6XiS85hmUplFUGSA5EpNhqdY6GS1HGcLUWrWobPuecc3jllVfo0qULe/bs4ZFHHqFv376sW7cOXdepr69n0qRJPPLIIzzxxBPMmTOHK6+8koULFzJw4P5X75SVlZGd3XT1THZ2NmVlZc22IxaLEYvFEue1tXYsRTAYPAq9lEgOD6UmjInA0myLjSUUdFdDDikLRNSO5VLjjXFbAj1JQYsILKeCiIGpgxIVKIDlsFNKADiCYDQkRvWGhG3hctgCTjcFhqWw/M7bqOcGCAb5cI8TMxzDbRh4EIRrXCg1MYQBxG3hZZqg6WDGIJYGahjigFoJYX9DwlPA0MAKg2GC7gDiYEUFWlDBEbTzfAm3wHQKnNtU4qlxRMRur2KoiLCFoYG6wmmvgMyLsO7XY+jxylOgK6gxlfp00L7UaL/rERz1KooKIiywdIV4soVar9guyIhCPM1CVAmImFg+CyWqooUbtktKE8SdcbRqBcsjiAsTJQxKtUWbz012D7LwVAocaj1+K0x9xI1TCVKg7SLHH+SbcCbFRgaaYmEpCinuKOGQE79i0i1QxmfF7RGmQHPWU17qICetll0VqWCGqNmjEkipJ1rnxe+PsaPcjTNQz3/19iRH2rPigq8Sc6XHa9Nx7nWyJ8WLqsdRdIWYU8cKW6xclYPmrydc6kRJDqGVq5heC29eCGGB7nVglrpJKaymtDyAqI/hzIhQtdPFv8s643DpuN0GsT1JYJnUOB3yd2IzNI5LSzqM2rRpw062sksUH2FNgkAggNPpPCrtkhw6P6pM86FQiMLCQu68805GjBhBfn4+V199NW+88Ubinssuuwy/39+se9DlcvH3v/+dq6++OlH2+uuvc8MNNxCN7n/rjYkTJ/LggzIIVCKRSCQ/nK1bt9KpU6cWqduyLIqLj1Rs2QQCATIz910VK2lZflTRj36/n549e7J582YyMzNxOBx07969yT3dunVj6dKlzdaRk5OzjzWrvLx8H6vXd7n77rsZP3584tyyLKqqqsjIyEBRlB/Ym2NDMBikXbt27NixQ/rjv4ccm+aRY7N/5Lg0jxyb5qmtraV9+/akp6e32DtUVaWwsLDF6pe0PD8qwRWLxdiwYQPnnnsuLpeLs846i40bNza5Z9OmTRQUFDRbR58+fZg/fz7jxn27oe28efPo27dvs8+43W7cbneTstTU1B/WiVYiJSVF/hJsBjk2zSPHZv/IcWkeOTbNo6qtHhYt+RHTqoLrjjvu4NJLL6V9+/aUl5fzyCOPEAwGGTVqFAATJkxg+PDhDBgwgMGDBzNnzhzee+89Fi1alKhj5MiR5Ofn8/jjjwMwZswYBgwYwBNPPMHQoUP597//zYIFCw5oFZNIJBKJRCJpSVpVcO3cuZOrr76aiooKsrKy6N27N59++mnCgnXFFVfw3HPP8fjjjzN69GiKioqYOXMm/fv3T9RRUlLS5FtF3759efPNN7n33nu57777KCws5K233uKcc8455v2TSCQSiUQigVYWXG+++eZB77n++uu5/vrrm73+XWtXI1dddRVXXXXVkTTtJ4Pb7eaBBx7YxyUqkWNzIOTY7B85Ls0jx6Z55NhIDoUf1SpFiUQikUgkkuMRGeEnkUgkEolE0sJIwSWRSCQSiUTSwkjBJZFIJBKJRNLCSMElkUgkEolE0sJIwfUjp66ujrFjx1JQUIDX66Vv376sWLGi2fsXLVqEoij7HF9//fUxbPXRZ8mSJVx66aXk5eWhKMo+m5gLIZg4cSJ5eXl4vV4GDRrEunXrDlrvzJkz6d69O263m+7duzN79uwW6kHL0RJj8/LLL+93HjW3PdaPlYONzaxZsxgyZAiZmZkoisLq1asPqd6f+rxpiXE5EeaMruvcdddd9OzZE7/fT15eHiNHjmT37t0HrfenPmckR44UXD9yfve73zF//nxeffVV1q5dy4UXXsj555/Prl27Dvjcxo0bKS0tTRydO3c+Ri1uGUKhEKeeeip/+tOf9nt98uTJTJs2jT/96U+sWLGCnJwcLrjgAurq6pqtc9myZQwfPpxrr72WNWvWcO211zJs2DCWL1/eUt1oEVpibMDOKP7dOVRaWorH42mJLrQYBxubUChEv379mDRp0iHXeTzMm5YYFzj+50w4HOaLL77gvvvu44svvmDWrFls2rSJyy677IB1Hg9zRnIUEJIfLeFwWGiaJt5///0m5aeeeqq455579vvMwoULBSCqq6uPQQtbB0DMnj07cW5ZlsjJyRGTJk1KlEWjUREIBMRzzz3XbD3Dhg0TF110UZOyIUOGiBEjRhz1Nh8rjtbYzJgxQwQCgRZs6bHn+2PzXYqLiwUgVq1addB6jrd5c7TG5USbM4189tlnAhDbt29v9p7jbc5IfhjSwvUjxjAMTNPc5xui1+s96FZFp59+Orm5uZx33nksXLiwJZvZ6hQXF1NWVsaFF16YKHO73QwcOJBPPvmk2eeWLVvW5BmAIUOGHPCZnxo/dGwA6uvrKSgooG3btvziF79g1apVLd3cnwQnwrz5oZyIc6a2thZFUQ64/66cMxKQLsUfNcnJyfTp04eHH36Y3bt3Y5omr732GsuXL6e0tHS/z+Tm5vLCCy8wc+ZMZs2aRVFREeeddx5Lliw5xq0/dpSVlQGQnZ3dpDw7OztxrbnnDveZnxo/dGy6du3Kyy+/zLvvvss//vEPPB4P/fr1Y/PmzS3a3p8CJ8K8+SGciHMmGo3yxz/+kWuuueaAG3rLOSOBVt7aR3JwXn31Va6//nry8/PRNI1evXpxzTXX8MUXX+z3/qKiIoqKihLnffr0YceOHUyZMoUBAwYcq2a3CoqiNDkXQuxTdjSe+SlyuP3s3bs3vXv3Tpz369ePXr168eyzz/LMM8+0WDt/Kpwo8+ZwONHmjK7rjBgxAsuy+Mtf/nLQ++WckUgL14+cwsJCFi9eTH19PTt27OCzzz5D13U6dux4yHX07t37uP6WmZOTA7DPt8Xy8vJ9vlV+/7nDfeanxg8dm++jqipnnXXWcT2PDpUTYd4cDY7nOaPrOsOGDaO4uJj58+cf0LoFcs5IbKTg+ong9/vJzc2lurqauXPnMnTo0EN+dtWqVeTm5rZg61qXjh07kpOTw/z58xNl8XicxYsX07dv32af69OnT5NnAObNm3fAZ35q/NCx+T5CCFavXn1cz6ND5USYN0eD43XONIqtzZs3s2DBAjIyMg76jJwzEpAuxR89c+fORQhBUVERW7ZsYcKECRQVFfHb3/4WgLvvvptdu3bxyiuvAPDUU0/RoUMHevToQTwe57XXXmPmzJnMnDmzNbtxxNTX17Nly5bEeXFxMatXryY9PZ327dszduxYHnvsMTp37kznzp157LHH8Pl8XHPNNYlnRo4cSX5+Po8//jgAY8aMYcCAATzxxBMMHTqUf//73yxYsOCgCxJ+bLTE2Dz44IP07t2bzp07EwwGeeaZZ1i9ejV//vOfj3n/joSDjU1VVRUlJSWJPEobN24EbItEo3XweJw3LTEuJ8KcycvL46qrruKLL77g/fffxzTNhOUqPT0dl8sFHJ9zRnIUaL0FkpJD4a233hKdOnUSLpdL5OTkiFtvvVXU1NQkro8aNUoMHDgwcf7EE0+IwsJC4fF4RFpamujfv7/44IMPWqHlR5fGdBffP0aNGiWEsNMfPPDAAyInJ0e43W4xYMAAsXbt2iZ1DBw4MHF/I//85z9FUVGRcDqdomvXrmLmzJnHqEdHj5YYm7Fjx4r27dsLl8slsrKyxIUXXig++eSTY9iro8PBxmbGjBn7vf7AAw8k6jge501LjMuJMGca02Ts71i4cGGijuNxzkiOHEUIIVpMzUkkEolEIpFIZAyXRCKRSCQSSUsjBZdEIpFIJBJJCyMFl0QikUgkEkkLIwWXRCKRSCQSSQsjBZdEIpFIJBJJCyMFl0QikUgkEkkLIwWXRCKRSCQSSQsjBZfkuGXQoEGMHTv2uHrvddddx+WXX35EdXTo0AFFUVAUhZqammbve/nll0lNTT2id0ma57rrrkt8Du+8805rN0cikbQwUnBJJEeZWbNm8fDDDyfOO3TowFNPPdV6DdoPDz30EKWlpQQCgdZuynHPokWL9itun376aUpLS1unURKJ5Jgj91KUSI4y6enprd2Eg5KcnJzYE6+10XUdp9PZ2s045gQCASl4JZITCGnhkpwwVFdXM3LkSNLS0vD5fFx88cVs3rw5cb3RhTZ37ly6detGUlISF110URMrhGEYjB49mtTUVDIyMrjrrrsYNWpUEzffd12KgwYNYvv27YwbNy7hPgKYOHEip512WpP2NW483ohpmowfPz7xrjvvvJPv78QlhGDy5Ml06tQJr9fLqaeeyr/+9a8fND4vv/wy7du3x+fzccUVV1BZWbnPPe+99x5nnHEGHo+HTp068eCDD2IYRuL6119/Tf/+/fF4PHTv3p0FCxY0cZlt27YNRVF4++23GTRoEB6Ph9deew2AGTNm0K1bNzweD127duUvf/lLk3fv2rWL4cOHk5aWRkZGBkOHDmXbtm2J64sWLeLss8/G7/eTmppKv3792L59+yH1/WD9mjZtGj179sTv99OuXTtuueUW6uvrE9e3b9/OpZdeSlpaGn6/nx49evCf//yHbdu2MXjwYADS0tJQFIXrrrvukNokkUiOL6TgkpwwXHfddXz++ee8++67LFu2DCEEl1xyCbquJ+4Jh8NMmTKFV199lSVLllBSUsIdd9yRuP7EE0/w+uuvM2PGDD7++GOCweAB429mzZpF27ZtEy68w3EhTZ06lb/97W+89NJLLF26lKqqKmbPnt3knnvvvZcZM2bw17/+lXXr1jFu3Dh+85vfsHjx4kMfGGD58uVcf/313HLLLaxevZrBgwfzyCOPNLln7ty5/OY3v2H06NGsX7+e559/npdffplHH30UAMuyuPzyy/H5fCxfvpwXXniBe+65Z7/vu+uuuxg9ejQbNmxgyJAhvPjii9xzzz08+uijbNiwgccee4z77ruPv//974D9uQwePJikpCSWLFnC0qVLE4I4Ho9jGAaXX345AwcO5Msvv2TZsmXcdNNNCYF7IA7WLwBVVXnmmWf46quv+Pvf/85HH33EnXfembh+6623EovFWLJkCWvXruWJJ54gKSmJdu3aMXPmTAA2btxIaWkpTz/99GF9NhKJ5DihVbfOlkhakIEDB4oxY8YIIYTYtGmTAMTHH3+cuF5RUSG8Xq94++23hRBCzJgxQwBiy5YtiXv+/Oc/i+zs7MR5dna2ePLJJxPnhmGI9u3bi6FDh+73vUIIUVBQIKZPn96kbQ888IA49dRTm5RNnz5dFBQUJM5zc3PFpEmTEue6rou2bdsm3lVfXy88Ho/45JNPmtRzww03iKuvvrrZcdlfe66++mpx0UUXNSkbPny4CAQCifNzzz1XPPbYY03uefXVV0Vubq4QQogPP/xQOBwOUVpamrg+f/58AYjZs2cLIYQoLi4WgHjqqaea1NOuXTvxxhtvNCl7+OGHRZ8+fYQQQrz00kuiqKhIWJaVuB6LxYTX6xVz584VlZWVAhCLFi1qtt/NcbB+7Y+3335bZGRkJM579uwpJk6cuN97Fy5cKABRXV293+vfHR+JRHL8ImO4JCcEGzZswOFwcM455yTKMjIyKCoqYsOGDYkyn89HYWFh4jw3N5fy8nIAamtr2bNnD2effXbiuqZpnHHGGViWdVTbW1tbS2lpKX369EmUORwOzjzzzIRbcf369USjUS644IImz8bjcU4//fTDet+GDRu44oormpT16dOHOXPmJM5XrlzJihUrmlh+TNMkGo0SDofZuHEj7dq1axIb9t2x+i5nnnlm4ue9e/eyY8cObrjhBm688cZEuWEYiRinlStXsmXLFpKTk5vUE41G2bp1KxdeeCHXXXcdQ4YM4YILLuD8889n2LBh5ObmHrTvB+uXz+dj4cKFPPbYY6xfv55gMIhhGESjUUKhEH6/n9GjR/P73/+eefPmcf755/PLX/6SU0455aDvlkgkJw5ScElOCMT3Yp++W/5dt9P3g7cVRdnn2e+7qZqr+0CoqrrPc991bR4KjSLvgw8+ID8/v8k1t9t9WHUdSh8sy+LBBx/kyiuv3Oeax+PZZywPhN/vb1IvwIsvvthEEIMtaBvvOeOMM3j99df3qSsrKwuwY8BGjx7NnDlzeOutt7j33nuZP38+vXv3PqJ+bd++nUsuuYSbb76Zhx9+mPT0dJYuXcoNN9yQ+Mx+97vfMWTIED744APmzZvH448/ztSpU7n99tsPaTwkEsnxjxRckhOC7t27YxgGy5cvp2/fvgBUVlayadMmunXrdkh1BAIBsrOz+eyzzzj33HMB2xKyatWqfQLgv4vL5cI0zSZlWVlZlJWVNREpq1evbvKu3NxcPv30UwYMGADYFp+VK1fSq1evRJ/cbjclJSUMHDjwkPrQHN27d+fTTz9tUvb98169erFx40ZOOumk/dbRtWtXSkpK2LNnD9nZ2QCsWLHioO/Ozs4mPz+fb775hl//+tf7vadXr1689dZbtGnThpSUlGbrOv300zn99NO5++676dOnD2+88cZBBdfB+vX5559jGAZTp05FVe2w17fffnuf+9q1a8fNN9/MzTffzN13382LL77I7bffjsvlAthnDkgkkhMLKbgkJwSdO3dm6NCh3HjjjTz//PMkJyfzxz/+kfz8fIYOHXrI9dx+++08/vjjnHTSSXTt2pVnn32W6urqA1p2OnTowJIlSxgxYgRut5vMzEwGDRrE3r17mTx5MldddRVz5szhww8/bCImxowZw6RJk+jcuTPdunVj2rRpTXI5JScnc8cddzBu3Dgsy6J///4Eg0E++eQTkpKSGDVq1CH3a/To0fTt25fJkydz+eWXM2/evCbuRID777+fX/ziF7Rr145f/epXqKrKl19+ydq1a3nkkUe44IILKCwsZNSoUUyePJm6urpE0PzBLF8TJ05k9OjRpKSkcPHFFxOLxfj888+prq5m/Pjx/PrXv+bJJ59k6NChPPTQQ7Rt25aSkhJmzZrFhAkT0HWdF154gcsuu4y8vDw2btzIpk2bGDly5EH7frB+FRYWYhgGzz77LJdeeikff/wxzz33XJM6xo4dy8UXX0yXLl2orq7mo48+Sgj5goICFEXh/fff55JLLsHr9ZKUlHTIn41EIjlOaLXoMYmkhfl+8HpVVZW49tprRSAQEF6vVwwZMkRs2rQpcX3GjBlNgsSFEGL27Nniu/9NdF0Xt912m0hJSRFpaWnirrvuEr/61a/EiBEjmn3vsmXLxCmnnCLcbneTuv7617+Kdu3aCb/fL0aOHCkeffTRJkHzuq6LMWPGiJSUFJGamirGjx8vRo4c2SRA37Is8fTTT4uioiLhdDpFVlaWGDJkiFi8eHGz47K/oHkh7MD0tm3bCq/XKy699FIxZcqUfcZjzpw5om/fvsLr9YqUlBRx9tlnixdeeCFxfcOGDaJfv37C5XKJrl27ivfee08AYs6cOUKIb4PmV61atc/7X3/9dXHaaacJl8sl0tLSxIABA8SsWbMS10tLS8XIkSNFZmamcLvdolOnTuLGG28UtbW1oqysTFx++eUiNzdXuFwuUVBQIO6//35hmmaz43A4/Zo2bZrIzc1NzJtXXnmlSSD8bbfdJgoLC4Xb7RZZWVni2muvFRUVFYnnH3roIZGTkyMURRGjRo1q8m5k0LxEckKgCPEDAlAkEglgx/9069aNYcOGNcku/2OmQ4cOjB079phse/Txxx/Tv39/tmzZ0mQxguRbFEVh9uzZR7xlk0Qi+XEj83BJJIfB9u3befHFF9m0aRNr167l97//PcXFxVxzzTWt3bTD4q677iIpKYna2tqjWu/s2bOZP38+27ZtY8GCBdx0003069dPiq39cPPNN0vXokRyAiEtXBLJYbBjxw5GjBjBV199hRCCk08+mUmTJiUC238KbN++PbG6rlOnTolA8KPBK6+8wsMPP8yOHTvIzMzk/PPPZ+rUqWRkZBy1dxwuPXr0aDbj/PPPP99soH5LU15eTjAYBOz0I99duSmRSI4/pOCSSCTHNd8VmN8nOzt7n9xeEolE0hJIwSWRSCQSiUTSwsgYLolEIpFIJJIWRgouiUQikUgkkhZGCi6JRCKRSCSSFkYKLolEIpFIJJIWRgouiUQikUgkkhZGCi6JRCKRSCSSFkYKLolEIpFIJJIWRgouiUQikUgkkhbm/wPxaj+0NV+XvgAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "slice_ds.SPM.isel(time=0).sel(lon=slice(9.2, 12), lat=slice(58.7, 56)).plot.imshow(\n", - " vmax=1.5\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "8fc231d4-fddb-4348-ae7f-32f0f0f6d8e1", - "metadata": {}, - "source": [ - "## Define the output" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "4dc12e8b-9ab3-4845-ad8b-1f528c6d2d08", - "metadata": {}, - "outputs": [], - "source": [ - "target_path = \"target.zarr\"" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "ef6ceb2b-8300-46c1-97c4-945aa1c3ea5f", - "metadata": {}, - "outputs": [], - "source": [ - "rmdir(target_path)" - ] - }, - { - "cell_type": "markdown", - "id": "507848e1-0f4c-4ec2-ba93-c33567c6e302", - "metadata": { - "tags": [] - }, - "source": [ - "## Use the zappend CLI" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "e3b9b255-1d6e-4efa-b17d-df8ab4af0cbf", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Usage: zappend [OPTIONS] [SLICES]...\n", - "\n", - " Create or update a Zarr datacube TARGET from slice datasets SLICES.\n", - "\n", - " The zappend command concatenates the dataset SLICES along a given append\n", - " dimension, e.g., \"time\" (the default) for geospatial satellite observations.\n", - " Each append step is atomic, that is, the append operation is a transaction\n", - " that can be rolled back, in case the append operation fails. This ensures\n", - " integrity of the target data cube given by TARGET or in CONFIG.\n", - "\n", - "Options:\n", - " -c, --config CONFIG Configuration JSON or YAML file. If multiple are\n", - " passed, subsequent configurations are incremental to\n", - " the previous ones.\n", - " -t, --target TARGET Target Zarr dataset path or URI. Overrides the\n", - " 'target_dir' configuration field.\n", - " --force-new Force creation of a new target dataset. An existing\n", - " target dataset (and its lock) will be permanently\n", - " deleted before appending of slice datasets begins.\n", - " WARNING: the deletion cannot be rolled back.\n", - " --dry-run Run the tool without creating, changing, or deleting\n", - " any files.\n", - " --traceback Show Python traceback on error.\n", - " --version Show version and exit.\n", - " --help-config json|md Show configuration help and exit.\n", - " --help Show this message and exit.\n" - ] - } - ], - "source": [ - "!zappend --help" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "27bc91ef-c0eb-42ab-8c1e-5eae4b98a72e", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.6.0\n" - ] - } - ], - "source": [ - "!zappend --version" - ] - }, - { - "cell_type": "markdown", - "id": "731ce132-a500-489d-b746-54af7a834d67", - "metadata": {}, - "source": [ - "Run the tool without any additional configuration:" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "fae51e0d-c50d-47dc-8275-56676e76000d", - "metadata": {}, - "outputs": [], - "source": [ - "!zappend -t {target_path} {\" \".join(slice_paths)}" - ] - }, - { - "cell_type": "markdown", - "id": "894ec17a-8995-4938-b1f3-1e64361e35eb", - "metadata": {}, - "source": [ - "Check the target dataset just generated:" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "991cd43b-9797-4ef8-aa29-48a098a44938", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.Dataset>\n",
-       "Dimensions:  (time: 3, lat: 8640, lon: 3435)\n",
-       "Coordinates:\n",
-       "  * lat      (lat) float64 64.0 64.0 64.0 64.0 64.0 ... 56.0 56.0 56.0 56.0 56.0\n",
-       "  * lon      (lon) float64 6.0 6.002 6.004 6.005 6.007 ... 11.99 12.0 12.0 12.0\n",
-       "  * time     (time) datetime64[ns] 2023-06-01 2023-06-03 2023-06-05\n",
-       "Data variables:\n",
-       "    SPM      (time, lat, lon) float32 dask.array<chunksize=(1, 540, 286), meta=np.ndarray>\n",
-       "    SPM_QI   (time, lat, lon) float32 dask.array<chunksize=(1, 540, 286), meta=np.ndarray>\n",
-       "    TUR      (time, lat, lon) float32 dask.array<chunksize=(1, 540, 286), meta=np.ndarray>\n",
-       "    TUR_QI   (time, lat, lon) float32 dask.array<chunksize=(1, 540, 286), meta=np.ndarray>\n",
-       "    crs      int32 ...\n",
-       "Attributes: (12/46)\n",
-       "    Conventions:                CF-1.7\n",
-       "    TileSize:                   540:286\n",
-       "    cmd_data_type:              Grid\n",
-       "    cmems_dataset:              cmems_obs_oc_bal_bgc_transp_nrt_l3-hr_P1D-m\n",
-       "    cmems_product_id:           OCEANCOLOUR_BAL_BGC_HR_L3_NRT_009_202\n",
-       "    contact:                    https://marine.copernicus.eu/\n",
-       "    ...                         ...\n",
-       "    time_coverage_duration:     P1D\n",
-       "    time_coverage_resolution:   P1D\n",
-       "    time_coverage_start:        20230601T000000Z\n",
-       "    time_coverage_stop:         20230601T235959Z\n",
-       "    title:                      CMEMS HR-OC Baltic Sea transparency (spm, tur...\n",
-       "    tracking_id:                62bdb787-8671-4098-b693-6e3aa1b7d660
" - ], - "text/plain": [ - "\n", - "Dimensions: (time: 3, lat: 8640, lon: 3435)\n", - "Coordinates:\n", - " * lat (lat) float64 64.0 64.0 64.0 64.0 64.0 ... 56.0 56.0 56.0 56.0 56.0\n", - " * lon (lon) float64 6.0 6.002 6.004 6.005 6.007 ... 11.99 12.0 12.0 12.0\n", - " * time (time) datetime64[ns] 2023-06-01 2023-06-03 2023-06-05\n", - "Data variables:\n", - " SPM (time, lat, lon) float32 dask.array\n", - " SPM_QI (time, lat, lon) float32 dask.array\n", - " TUR (time, lat, lon) float32 dask.array\n", - " TUR_QI (time, lat, lon) float32 dask.array\n", - " crs int32 ...\n", - "Attributes: (12/46)\n", - " Conventions: CF-1.7\n", - " TileSize: 540:286\n", - " cmd_data_type: Grid\n", - " cmems_dataset: cmems_obs_oc_bal_bgc_transp_nrt_l3-hr_P1D-m\n", - " cmems_product_id: OCEANCOLOUR_BAL_BGC_HR_L3_NRT_009_202\n", - " contact: https://marine.copernicus.eu/\n", - " ... ...\n", - " time_coverage_duration: P1D\n", - " time_coverage_resolution: P1D\n", - " time_coverage_start: 20230601T000000Z\n", - " time_coverage_stop: 20230601T235959Z\n", - " title: CMEMS HR-OC Baltic Sea transparency (spm, tur...\n", - " tracking_id: 62bdb787-8671-4098-b693-6e3aa1b7d660" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "target_ds = xr.open_zarr(target_path)\n", - "target_ds" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "7de6335c-dc17-464c-b9cf-8ed1777713bc", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\norma\\mamba\\envs\\xcube\\Lib\\site-packages\\dask\\array\\reductions.py:654: RuntimeWarning: All-NaN slice encountered\n", - " return np.nanmax(x_chunk, axis=axis, keepdims=keepdims)\n", - "C:\\Users\\norma\\mamba\\envs\\xcube\\Lib\\site-packages\\dask\\array\\reductions.py:654: RuntimeWarning: All-NaN slice encountered\n", - " return np.nanmax(x_chunk, axis=axis, keepdims=keepdims)\n" - ] - } - ], - "source": [ - "target_ds.SPM.mean(\"time\").sel(lon=slice(9.2, 12), lat=slice(58.7, 56)).plot.imshow(\n", - " vmax=1.5\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "2040bf76-2fbc-42dc-b47d-7d461925b703", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "target_ds.SPM_QI.max(\"time\").sel(lon=slice(9.2, 12), lat=slice(58.7, 56)).plot.imshow(\n", - " vmax=100.0\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "d9ef1ec7-f584-4147-a9b0-6dd67325fed9", - "metadata": {}, - "source": [ - "## Use the zappend API" - ] - }, - { - "cell_type": "markdown", - "id": "ded727aa-30df-4183-babb-cb6b85149e33", - "metadata": {}, - "source": [ - "Now the same using the API:" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "f7d3b8d8-8134-49dd-b494-fb4645ff76fc", - "metadata": {}, - "outputs": [], - "source": [ - "from zappend.api import zappend" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "cc831cbd-0b93-40ab-b4f5-c348140974df", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Help on function zappend in module zappend.api:\n", - "\n", - "zappend(slices: Iterable[Any], config: zappend.fsutil.fileobj.FileObj | str | dict[str, typing.Any] | list[zappend.fsutil.fileobj.FileObj | str | dict[str, typing.Any]] | tuple[zappend.fsutil.fileobj.FileObj | str | dict[str, typing.Any]] | None = None, **kwargs: Any)\n", - " Robustly create or update a Zarr dataset from dataset slices.\n", - " \n", - " The `zappend` function concatenates the dataset slices from given\n", - " `slices` along a given append dimension, e.g., `\"time\"` (the default)\n", - " for geospatial satellite observations.\n", - " Each append step is atomic, that is, the append operation is a transaction\n", - " that can be rolled back, in case the append operation fails.\n", - " This ensures integrity of the target data cube `target_dir` given\n", - " in `config` or `kwargs`.\n", - " \n", - " Args:\n", - " slices: An iterable that yields slice items. A slice item is\n", - " either a `str`, `FileObj`, `xarray.Dataset`, `SliceSource`,\n", - " or represents arguments passed to a configured `slice_source`.\n", - " If `str` or `FileObj` are used, they are interpreted as\n", - " local dataset path or dataset URI.\n", - " If a URI is used, protocol-specific parameters apply, given by\n", - " configuration parameter `slice_storage_options`.\n", - " config: Processor configuration.\n", - " May be a file path or URI, a `dict`, `None`, or a sequence of\n", - " the aforementioned. If a sequence is used, subsequent\n", - " configurations are incremental to the previous ones.\n", - " kwargs: Additional configuration parameters.\n", - " Can be used to pass or override configuration values in *config*.\n", - "\n" - ] - } - ], - "source": [ - "help(zappend)" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "0295de2a-674e-4a88-994f-2c1e45df3b64", - "metadata": {}, - "outputs": [], - "source": [ - "# Remove existing target datacube\n", - "rmdir(target_path)" - ] - }, - { - "cell_type": "markdown", - "id": "5d221b56-9940-45ce-9b3e-210f855bf1ec", - "metadata": {}, - "source": [ - "Run the tool without any additional configuration:" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "d584f7e1-f60e-41e6-b817-a92f11f0266a", - "metadata": {}, - "outputs": [], - "source": [ - "zappend(slice_paths, target_dir=target_path)" - ] - }, - { - "cell_type": "markdown", - "id": "7efbe444-2342-4b51-8876-454dea176be7", - "metadata": {}, - "source": [ - "Check the target dataset just generated:" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "b8714516-337b-4c06-aead-086fb3d44a04", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.Dataset>\n",
-       "Dimensions:  (time: 3, lat: 8640, lon: 3435)\n",
-       "Coordinates:\n",
-       "  * lat      (lat) float64 64.0 64.0 64.0 64.0 64.0 ... 56.0 56.0 56.0 56.0 56.0\n",
-       "  * lon      (lon) float64 6.0 6.002 6.004 6.005 6.007 ... 11.99 12.0 12.0 12.0\n",
-       "  * time     (time) datetime64[ns] 2023-06-01 2023-06-03 2023-06-05\n",
-       "Data variables:\n",
-       "    SPM      (time, lat, lon) float32 dask.array<chunksize=(1, 540, 286), meta=np.ndarray>\n",
-       "    SPM_QI   (time, lat, lon) float32 dask.array<chunksize=(1, 540, 286), meta=np.ndarray>\n",
-       "    TUR      (time, lat, lon) float32 dask.array<chunksize=(1, 540, 286), meta=np.ndarray>\n",
-       "    TUR_QI   (time, lat, lon) float32 dask.array<chunksize=(1, 540, 286), meta=np.ndarray>\n",
-       "    crs      int32 ...\n",
-       "Attributes: (12/46)\n",
-       "    Conventions:                CF-1.7\n",
-       "    TileSize:                   540:286\n",
-       "    cmd_data_type:              Grid\n",
-       "    cmems_dataset:              cmems_obs_oc_bal_bgc_transp_nrt_l3-hr_P1D-m\n",
-       "    cmems_product_id:           OCEANCOLOUR_BAL_BGC_HR_L3_NRT_009_202\n",
-       "    contact:                    https://marine.copernicus.eu/\n",
-       "    ...                         ...\n",
-       "    time_coverage_duration:     P1D\n",
-       "    time_coverage_resolution:   P1D\n",
-       "    time_coverage_start:        20230601T000000Z\n",
-       "    time_coverage_stop:         20230601T235959Z\n",
-       "    title:                      CMEMS HR-OC Baltic Sea transparency (spm, tur...\n",
-       "    tracking_id:                62bdb787-8671-4098-b693-6e3aa1b7d660
" - ], - "text/plain": [ - "\n", - "Dimensions: (time: 3, lat: 8640, lon: 3435)\n", - "Coordinates:\n", - " * lat (lat) float64 64.0 64.0 64.0 64.0 64.0 ... 56.0 56.0 56.0 56.0 56.0\n", - " * lon (lon) float64 6.0 6.002 6.004 6.005 6.007 ... 11.99 12.0 12.0 12.0\n", - " * time (time) datetime64[ns] 2023-06-01 2023-06-03 2023-06-05\n", - "Data variables:\n", - " SPM (time, lat, lon) float32 dask.array\n", - " SPM_QI (time, lat, lon) float32 dask.array\n", - " TUR (time, lat, lon) float32 dask.array\n", - " TUR_QI (time, lat, lon) float32 dask.array\n", - " crs int32 ...\n", - "Attributes: (12/46)\n", - " Conventions: CF-1.7\n", - " TileSize: 540:286\n", - " cmd_data_type: Grid\n", - " cmems_dataset: cmems_obs_oc_bal_bgc_transp_nrt_l3-hr_P1D-m\n", - " cmems_product_id: OCEANCOLOUR_BAL_BGC_HR_L3_NRT_009_202\n", - " contact: https://marine.copernicus.eu/\n", - " ... ...\n", - " time_coverage_duration: P1D\n", - " time_coverage_resolution: P1D\n", - " time_coverage_start: 20230601T000000Z\n", - " time_coverage_stop: 20230601T235959Z\n", - " title: CMEMS HR-OC Baltic Sea transparency (spm, tur...\n", - " tracking_id: 62bdb787-8671-4098-b693-6e3aa1b7d660" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "xr.open_zarr(target_path)" - ] - }, - { - "cell_type": "markdown", - "id": "68609d51-1d48-4ed0-ac70-7cc3f0faae86", - "metadata": {}, - "source": [ - "Check that time is monotonically increasing:" - ] - }, - { - "cell_type": "markdown", - "id": "70cad7dd-25ec-4ab9-9e9b-1c0080877cbc", - "metadata": {}, - "source": [ - "## zappend Configuration" - ] - }, - { - "cell_type": "markdown", - "id": "0eb98711-17bc-416f-831c-36337f4f2944", - "metadata": {}, - "source": [ - "Now we'll add some configuration. \n", - "You can run `zappend --help-config md` to get configuration help, or do that programmatically:" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "e3b5f156-88c7-4ce1-908e-88ddc7b7e18c", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "bfc8fe5d-0c67-4865-ab13-0b37855d96bb", - "metadata": {}, - "outputs": [], - "source": [ - "# Uncomment to show configuration refernce\n", - "# Markdown(get_config_schema(format=\"md\"))" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "5ab01409-7ddc-4250-860e-a4607a132a0e", - "metadata": {}, - "outputs": [], - "source": [ - "config = {\n", - " \"target_dir\": target_path,\n", - " \"variables\": {\n", - " # We want the time coordinate variable to use a larger chunk size\n", - " # than the default (= 1 here)\n", - " \"time\": {\"encoding\": {\"chunks\": [100]}}\n", - " },\n", - " # Log to the console.\n", - " # Note you could also configure the log output for dask here.\n", - " \"logging\": {\n", - " \"version\": 1,\n", - " \"formatters\": {\n", - " \"normal\": {\"format\": \"%(asctime)s %(levelname)s %(message)s\", \"style\": \"%\"}\n", - " },\n", - " \"handlers\": {\n", - " \"console\": {\"class\": \"logging.StreamHandler\", \"formatter\": \"normal\"}\n", - " },\n", - " \"loggers\": {\n", - " \"zappend\": {\"level\": \"INFO\", \"handlers\": [\"console\"]},\n", - " \"notebook\": {\n", - " # Will use this one later below\n", - " \"level\": \"INFO\",\n", - " \"handlers\": [\"console\"],\n", - " },\n", - " },\n", - " },\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "891bef11-c580-498a-a0db-8b2fac1da38f", - "metadata": {}, - "outputs": [], - "source": [ - "config_path = \"zappend-config.yaml\"" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "ffe8aa85-8c5a-4a9c-a3b8-a5f3a7c50aa2", - "metadata": {}, - "outputs": [], - "source": [ - "import yaml\n", - "\n", - "with open(config_path, mode=\"w\") as f:\n", - " yaml.dump(config, f)" - ] - }, - { - "cell_type": "markdown", - "id": "795a2ab7-e23c-4094-bd51-7f73f311c2fa", - "metadata": {}, - "source": [ - "## zappend CLI with Configuration" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "7439b20d-ce84-43e0-be54-3a5f573a8800", - "metadata": {}, - "outputs": [], - "source": [ - "rmdir(target_path)" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "id": "8fb20c46-2f62-4a6b-b9db-db2d168d9647", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-03-12 13:18:37,165 INFO Opening slice dataset from inputs\\20230601_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc\n", - "2024-03-12 13:18:37,181 INFO Creating target dataset target.zarr\n", - "2024-03-12 13:18:38,931 INFO Transaction completed.\n", - "2024-03-12 13:18:38,935 INFO Slice dataset inputs\\20230601_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc closed\n", - "2024-03-12 13:18:38,943 INFO Opening slice dataset from inputs\\20230603_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc\n", - "2024-03-12 13:18:38,952 INFO Updating target dataset target.zarr\n", - "2024-03-12 13:18:40,511 INFO Transaction completed.\n", - "2024-03-12 13:18:40,514 INFO Slice dataset inputs\\20230603_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc closed\n", - "2024-03-12 13:18:40,521 INFO Opening slice dataset from inputs\\20230605_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc\n", - "2024-03-12 13:18:40,529 INFO Updating target dataset target.zarr\n", - "2024-03-12 13:18:42,100 INFO Transaction completed.\n", - "2024-03-12 13:18:42,104 INFO Slice dataset inputs\\20230605_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc closed\n" - ] - } - ], - "source": [ - "!zappend -c {config_path} {\" \".join(slice_paths)}" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "758675d7-505a-4357-b097-d3cf8e116c65", - "metadata": {}, - "outputs": [], - "source": [ - "rmdir(target_path)" - ] - }, - { - "cell_type": "markdown", - "id": "6df50041-c09c-40d9-afa3-b6f6a24a430d", - "metadata": {}, - "source": [ - "## zappend API with Configuration" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "ae8783d1-541f-482a-a3f5-9631c8359363", - "metadata": {}, - "outputs": [], - "source": [ - "from zappend.api import zappend" - ] - }, - { - "cell_type": "markdown", - "id": "b08fe2d9-dd05-48d3-8b13-9f116b751477", - "metadata": {}, - "source": [ - "The `zappend` function can process slice paths or URIs, e.g., `s3://...` or slice datasets of type `xr.Dataset`:" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "1aade08b-7636-4a33-9f39-98ae5ad18867", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-03-12 13:18:42,378 INFO Opening slice dataset from inputs\\20230601_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc\n", - "2024-03-12 13:18:42,386 INFO Creating target dataset target.zarr\n", - "2024-03-12 13:18:43,812 INFO Transaction completed.\n", - "2024-03-12 13:18:43,813 INFO Slice dataset inputs\\20230601_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc closed\n", - "2024-03-12 13:18:43,821 INFO Opening slice dataset from inputs\\20230603_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc\n", - "2024-03-12 13:18:43,831 INFO Updating target dataset target.zarr\n", - "2024-03-12 13:18:45,363 INFO Transaction completed.\n", - "2024-03-12 13:18:45,368 INFO Slice dataset inputs\\20230603_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc closed\n", - "2024-03-12 13:18:45,375 INFO Opening slice dataset from inputs\\20230605_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc\n", - "2024-03-12 13:18:45,385 INFO Updating target dataset target.zarr\n", - "2024-03-12 13:18:46,898 INFO Transaction completed.\n", - "2024-03-12 13:18:46,903 INFO Slice dataset inputs\\20230605_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc closed\n" - ] - } - ], - "source": [ - "zappend(slice_paths, config=config)" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "e629de62-3bb3-4cab-9507-4026f74fde38", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.Dataset>\n",
-       "Dimensions:  (time: 3, lat: 8640, lon: 3435)\n",
-       "Coordinates:\n",
-       "  * lat      (lat) float64 64.0 64.0 64.0 64.0 64.0 ... 56.0 56.0 56.0 56.0 56.0\n",
-       "  * lon      (lon) float64 6.0 6.002 6.004 6.005 6.007 ... 11.99 12.0 12.0 12.0\n",
-       "  * time     (time) datetime64[ns] 2023-06-01 2023-06-03 2023-06-05\n",
-       "Data variables:\n",
-       "    SPM      (time, lat, lon) float32 dask.array<chunksize=(1, 540, 286), meta=np.ndarray>\n",
-       "    SPM_QI   (time, lat, lon) float32 dask.array<chunksize=(1, 540, 286), meta=np.ndarray>\n",
-       "    TUR      (time, lat, lon) float32 dask.array<chunksize=(1, 540, 286), meta=np.ndarray>\n",
-       "    TUR_QI   (time, lat, lon) float32 dask.array<chunksize=(1, 540, 286), meta=np.ndarray>\n",
-       "    crs      int32 ...\n",
-       "Attributes: (12/46)\n",
-       "    Conventions:                CF-1.7\n",
-       "    TileSize:                   540:286\n",
-       "    cmd_data_type:              Grid\n",
-       "    cmems_dataset:              cmems_obs_oc_bal_bgc_transp_nrt_l3-hr_P1D-m\n",
-       "    cmems_product_id:           OCEANCOLOUR_BAL_BGC_HR_L3_NRT_009_202\n",
-       "    contact:                    https://marine.copernicus.eu/\n",
-       "    ...                         ...\n",
-       "    time_coverage_duration:     P1D\n",
-       "    time_coverage_resolution:   P1D\n",
-       "    time_coverage_start:        20230601T000000Z\n",
-       "    time_coverage_stop:         20230601T235959Z\n",
-       "    title:                      CMEMS HR-OC Baltic Sea transparency (spm, tur...\n",
-       "    tracking_id:                62bdb787-8671-4098-b693-6e3aa1b7d660
" - ], - "text/plain": [ - "\n", - "Dimensions: (time: 3, lat: 8640, lon: 3435)\n", - "Coordinates:\n", - " * lat (lat) float64 64.0 64.0 64.0 64.0 64.0 ... 56.0 56.0 56.0 56.0 56.0\n", - " * lon (lon) float64 6.0 6.002 6.004 6.005 6.007 ... 11.99 12.0 12.0 12.0\n", - " * time (time) datetime64[ns] 2023-06-01 2023-06-03 2023-06-05\n", - "Data variables:\n", - " SPM (time, lat, lon) float32 dask.array\n", - " SPM_QI (time, lat, lon) float32 dask.array\n", - " TUR (time, lat, lon) float32 dask.array\n", - " TUR_QI (time, lat, lon) float32 dask.array\n", - " crs int32 ...\n", - "Attributes: (12/46)\n", - " Conventions: CF-1.7\n", - " TileSize: 540:286\n", - " cmd_data_type: Grid\n", - " cmems_dataset: cmems_obs_oc_bal_bgc_transp_nrt_l3-hr_P1D-m\n", - " cmems_product_id: OCEANCOLOUR_BAL_BGC_HR_L3_NRT_009_202\n", - " contact: https://marine.copernicus.eu/\n", - " ... ...\n", - " time_coverage_duration: P1D\n", - " time_coverage_resolution: P1D\n", - " time_coverage_start: 20230601T000000Z\n", - " time_coverage_stop: 20230601T235959Z\n", - " title: CMEMS HR-OC Baltic Sea transparency (spm, tur...\n", - " tracking_id: 62bdb787-8671-4098-b693-6e3aa1b7d660" - ] - }, - "execution_count": 30, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "xr.open_zarr(target_path)" - ] - }, - { - "cell_type": "markdown", - "id": "10fc19b8-6234-4f6e-a673-89900740dccc", - "metadata": { - "tags": [] - }, - "source": [ - "## Other slice types" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "e51edf82-be14-4065-9aec-399481d8b5f0", - "metadata": {}, - "outputs": [], - "source": [ - "rmdir(target_path)" - ] - }, - { - "cell_type": "markdown", - "id": "fe4b4d73-492b-431a-b0b5-43c8a1ccec84", - "metadata": {}, - "source": [ - "Get the configured logger: " - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "f98b5d70-8a9d-4865-8a89-d00f6a27962b", - "metadata": {}, - "outputs": [], - "source": [ - "from logging import getLogger\n", - "\n", - "LOG = getLogger(\"notebook\")" - ] - }, - { - "cell_type": "markdown", - "id": "55cc48d3-7276-48f4-acda-d27fb7bc6cc3", - "metadata": {}, - "source": [ - "The `zappend` function can also process in-memory slice datasets of type `xr.Dataset`:" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "4a79a16b-9c0a-4a04-8774-04b1871b767d", - "metadata": {}, - "outputs": [], - "source": [ - "log = getLogger(\"notebook\")\n", - "\n", - "\n", - "def process_slice(slice_path: str) -> xr.Dataset:\n", - " LOG.info(f\"Processing slice {slice_path}\")\n", - " slice_ds = xr.open_dataset(slice_path)\n", - " return slice_ds.drop_vars([\"SPM_QI\", \"TUR_QI\", \"crs\"])\n", - "\n", - "\n", - "slice_generator = (process_slice(slice_path) for slice_path in slice_paths)" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "id": "3eb9fcda-b166-4139-9ad2-11af13f1e116", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-03-12 13:18:47,024 INFO Processing slice inputs\\20230601_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc\n", - "2024-03-12 13:18:47,030 INFO Processing in-memory slice dataset #0\n", - "2024-03-12 13:18:47,032 INFO Creating target dataset target.zarr\n", - "2024-03-12 13:18:47,830 INFO Transaction completed.\n", - "2024-03-12 13:18:47,830 INFO Slice dataset #0 processed\n", - "2024-03-12 13:18:47,831 INFO Processing slice inputs\\20230603_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc\n", - "2024-03-12 13:18:47,846 INFO Processing in-memory slice dataset #1\n", - "2024-03-12 13:18:47,848 INFO Updating target dataset target.zarr\n", - "2024-03-12 13:18:48,641 INFO Transaction completed.\n", - "2024-03-12 13:18:48,641 INFO Slice dataset #1 processed\n", - "2024-03-12 13:18:48,642 INFO Processing slice inputs\\20230605_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc\n", - "2024-03-12 13:18:48,658 INFO Processing in-memory slice dataset #2\n", - "2024-03-12 13:18:48,659 INFO Updating target dataset target.zarr\n", - "2024-03-12 13:18:49,427 INFO Transaction completed.\n", - "2024-03-12 13:18:49,428 INFO Slice dataset #2 processed\n" - ] - } - ], - "source": [ - "zappend(slice_generator, config=config)" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "id": "784bdfeb-6572-483e-89db-a8eadb1681bc", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.Dataset>\n",
-       "Dimensions:  (time: 3, lat: 8640, lon: 3435)\n",
-       "Coordinates:\n",
-       "  * lat      (lat) float64 64.0 64.0 64.0 64.0 64.0 ... 56.0 56.0 56.0 56.0 56.0\n",
-       "  * lon      (lon) float64 6.0 6.002 6.004 6.005 6.007 ... 11.99 12.0 12.0 12.0\n",
-       "  * time     (time) datetime64[ns] 2023-06-01 2023-06-03 2023-06-05\n",
-       "Data variables:\n",
-       "    SPM      (time, lat, lon) float32 dask.array<chunksize=(1, 540, 286), meta=np.ndarray>\n",
-       "    TUR      (time, lat, lon) float32 dask.array<chunksize=(1, 540, 286), meta=np.ndarray>\n",
-       "Attributes: (12/46)\n",
-       "    Conventions:                CF-1.7\n",
-       "    TileSize:                   540:286\n",
-       "    cmd_data_type:              Grid\n",
-       "    cmems_dataset:              cmems_obs_oc_bal_bgc_transp_nrt_l3-hr_P1D-m\n",
-       "    cmems_product_id:           OCEANCOLOUR_BAL_BGC_HR_L3_NRT_009_202\n",
-       "    contact:                    https://marine.copernicus.eu/\n",
-       "    ...                         ...\n",
-       "    time_coverage_duration:     P1D\n",
-       "    time_coverage_resolution:   P1D\n",
-       "    time_coverage_start:        20230601T000000Z\n",
-       "    time_coverage_stop:         20230601T235959Z\n",
-       "    title:                      CMEMS HR-OC Baltic Sea transparency (spm, tur...\n",
-       "    tracking_id:                62bdb787-8671-4098-b693-6e3aa1b7d660
" - ], - "text/plain": [ - "\n", - "Dimensions: (time: 3, lat: 8640, lon: 3435)\n", - "Coordinates:\n", - " * lat (lat) float64 64.0 64.0 64.0 64.0 64.0 ... 56.0 56.0 56.0 56.0 56.0\n", - " * lon (lon) float64 6.0 6.002 6.004 6.005 6.007 ... 11.99 12.0 12.0 12.0\n", - " * time (time) datetime64[ns] 2023-06-01 2023-06-03 2023-06-05\n", - "Data variables:\n", - " SPM (time, lat, lon) float32 dask.array\n", - " TUR (time, lat, lon) float32 dask.array\n", - "Attributes: (12/46)\n", - " Conventions: CF-1.7\n", - " TileSize: 540:286\n", - " cmd_data_type: Grid\n", - " cmems_dataset: cmems_obs_oc_bal_bgc_transp_nrt_l3-hr_P1D-m\n", - " cmems_product_id: OCEANCOLOUR_BAL_BGC_HR_L3_NRT_009_202\n", - " contact: https://marine.copernicus.eu/\n", - " ... ...\n", - " time_coverage_duration: P1D\n", - " time_coverage_resolution: P1D\n", - " time_coverage_start: 20230601T000000Z\n", - " time_coverage_stop: 20230601T235959Z\n", - " title: CMEMS HR-OC Baltic Sea transparency (spm, tur...\n", - " tracking_id: 62bdb787-8671-4098-b693-6e3aa1b7d660" - ] - }, - "execution_count": 35, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "xr.open_zarr(target_path)" - ] - }, - { - "cell_type": "markdown", - "id": "0a1cd73a-5a76-4e8f-a687-bfe1ca56d0c0", - "metadata": {}, - "source": [ - "In the case that you need make sure the dataset is really closed after slice processing \n", - "or in order to cleanup temporary resource you can write a `SliceSource`:" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "id": "3b82aebf-a596-4ad4-8002-e052d986e1a7", - "metadata": {}, - "outputs": [], - "source": [ - "rmdir(target_path)" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "id": "e0b8b933-e135-4981-9145-3ca64b9ce1bd", - "metadata": {}, - "outputs": [], - "source": [ - "from zappend.api import SliceSource\n", - "\n", - "\n", - "class MySliceSource(SliceSource):\n", - " def __init__(self, slice_path):\n", - " self.slice_path = slice_path\n", - " self.slice_ds = None\n", - "\n", - " def get_dataset(self) -> xr.Dataset:\n", - " LOG.info(f\"Processing slice {self.slice_path}\")\n", - " self.slice_ds = xr.open_dataset(self.slice_path)\n", - " return self.slice_ds.drop_vars([\"SPM_QI\", \"TUR_QI\", \"crs\"])\n", - "\n", - " def dispose(self):\n", - " self.slice_ds.close()\n", - " self.slice_ds = None\n", - " LOG.info(\"Slice processed\")" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "id": "41ca765c-0f28-4616-a55f-a598327b52c4", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-03-12 13:18:49,523 INFO Processing slice inputs\\20230601_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc\n", - "2024-03-12 13:18:49,531 INFO Creating target dataset target.zarr\n", - "2024-03-12 13:18:50,243 INFO Transaction completed.\n", - "2024-03-12 13:18:50,244 INFO Slice processed\n", - "2024-03-12 13:18:50,251 INFO Processing slice inputs\\20230603_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc\n", - "2024-03-12 13:18:50,261 INFO Updating target dataset target.zarr\n", - "2024-03-12 13:18:51,036 INFO Transaction completed.\n", - "2024-03-12 13:18:51,038 INFO Slice processed\n", - "2024-03-12 13:18:51,046 INFO Processing slice inputs\\20230605_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc\n", - "2024-03-12 13:18:51,065 INFO Updating target dataset target.zarr\n", - "2024-03-12 13:18:51,836 INFO Transaction completed.\n", - "2024-03-12 13:18:51,839 INFO Slice processed\n" - ] - } - ], - "source": [ - "zappend(slice_paths, config=config, slice_source=MySliceSource)" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "id": "db79b8bc-3b14-46f8-b15e-2786d2bc97a8", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.Dataset>\n",
-       "Dimensions:  (time: 3, lat: 8640, lon: 3435)\n",
-       "Coordinates:\n",
-       "  * lat      (lat) float64 64.0 64.0 64.0 64.0 64.0 ... 56.0 56.0 56.0 56.0 56.0\n",
-       "  * lon      (lon) float64 6.0 6.002 6.004 6.005 6.007 ... 11.99 12.0 12.0 12.0\n",
-       "  * time     (time) datetime64[ns] 2023-06-01 2023-06-03 2023-06-05\n",
-       "Data variables:\n",
-       "    SPM      (time, lat, lon) float32 dask.array<chunksize=(1, 540, 286), meta=np.ndarray>\n",
-       "    TUR      (time, lat, lon) float32 dask.array<chunksize=(1, 540, 286), meta=np.ndarray>\n",
-       "Attributes: (12/46)\n",
-       "    Conventions:                CF-1.7\n",
-       "    TileSize:                   540:286\n",
-       "    cmd_data_type:              Grid\n",
-       "    cmems_dataset:              cmems_obs_oc_bal_bgc_transp_nrt_l3-hr_P1D-m\n",
-       "    cmems_product_id:           OCEANCOLOUR_BAL_BGC_HR_L3_NRT_009_202\n",
-       "    contact:                    https://marine.copernicus.eu/\n",
-       "    ...                         ...\n",
-       "    time_coverage_duration:     P1D\n",
-       "    time_coverage_resolution:   P1D\n",
-       "    time_coverage_start:        20230601T000000Z\n",
-       "    time_coverage_stop:         20230601T235959Z\n",
-       "    title:                      CMEMS HR-OC Baltic Sea transparency (spm, tur...\n",
-       "    tracking_id:                62bdb787-8671-4098-b693-6e3aa1b7d660
" - ], - "text/plain": [ - "\n", - "Dimensions: (time: 3, lat: 8640, lon: 3435)\n", - "Coordinates:\n", - " * lat (lat) float64 64.0 64.0 64.0 64.0 64.0 ... 56.0 56.0 56.0 56.0 56.0\n", - " * lon (lon) float64 6.0 6.002 6.004 6.005 6.007 ... 11.99 12.0 12.0 12.0\n", - " * time (time) datetime64[ns] 2023-06-01 2023-06-03 2023-06-05\n", - "Data variables:\n", - " SPM (time, lat, lon) float32 dask.array\n", - " TUR (time, lat, lon) float32 dask.array\n", - "Attributes: (12/46)\n", - " Conventions: CF-1.7\n", - " TileSize: 540:286\n", - " cmd_data_type: Grid\n", - " cmems_dataset: cmems_obs_oc_bal_bgc_transp_nrt_l3-hr_P1D-m\n", - " cmems_product_id: OCEANCOLOUR_BAL_BGC_HR_L3_NRT_009_202\n", - " contact: https://marine.copernicus.eu/\n", - " ... ...\n", - " time_coverage_duration: P1D\n", - " time_coverage_resolution: P1D\n", - " time_coverage_start: 20230601T000000Z\n", - " time_coverage_stop: 20230601T235959Z\n", - " title: CMEMS HR-OC Baltic Sea transparency (spm, tur...\n", - " tracking_id: 62bdb787-8671-4098-b693-6e3aa1b7d660" - ] - }, - "execution_count": 39, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "xr.open_zarr(target_path)" - ] - }, - { - "cell_type": "markdown", - "id": "d2b3c74b-a0be-420b-98b9-f319b5831368", - "metadata": {}, - "source": [ - "## Enforce Transaction Rollback\n", - "\n", - "Demonstrate that appending a slice is a transaction, that is rolled back on error.\n", - "\n", - "To simulate a failure that occurs on a random data chunk, we define the following \n", - "slice source `MyGrottySliceSource` that will fail when computing the 12th \n", - "chunk of a newly computed (useless) variable `SPM_05`." - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "id": "0c25f1ce-9adf-43ad-b07c-3462ba143268", - "metadata": {}, - "outputs": [], - "source": [ - "from zappend.api import SliceSource\n", - "\n", - "\n", - "class MyGrottySliceSource(SliceSource):\n", - " def __init__(self, slice_path):\n", - " self.slice_path = slice_path\n", - " self.slice_ds = None\n", - " self.is_bad = \"20230605\" in slice_path\n", - " self.num_chunks_seen = 0\n", - "\n", - " def half_spm(self, spm):\n", - " if self.is_bad:\n", - " self.num_chunks_seen += 1\n", - " if self.num_chunks_seen == 12:\n", - " raise ValueError(\"Bad chunk detected!\")\n", - " return 0.5 * spm\n", - "\n", - " def get_dataset(self) -> xr.Dataset:\n", - " LOG.info(f\"Processing slice {self.slice_path}\")\n", - " slice_ds = xr.open_dataset(self.slice_path)\n", - " slice_ds = slice_ds.drop_vars([\"SPM_QI\", \"TUR_QI\", \"crs\"])\n", - " slice_ds = slice_ds.chunk({\"lon\": 2000, \"lat\": 1000})\n", - " for v in slice_ds.data_vars.values():\n", - " v.encoding = {}\n", - " slice_ds[\"SPM_05\"] = slice_ds[\"SPM\"].map_blocks(\n", - " self.half_spm, template=slice_ds[\"SPM\"]\n", - " )\n", - " self.slice_ds = slice_ds\n", - " return slice_ds\n", - "\n", - " def dispose(self):\n", - " self.slice_ds.close()\n", - " self.slice_ds = None\n", - " LOG.info(\"Slice processed\")" - ] - }, - { - "cell_type": "markdown", - "id": "2a1ee2db-544d-4b6c-8d09-cf624e128ccc", - "metadata": {}, - "source": [ - "The following `zappend` call will fail on third slice, but changes will be rolled back so that \n", - "the target dataset is still ok, rather than in an invalid state." - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "id": "0e87ae12-7cfb-44a3-9d53-098fce933293", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-03-12 13:18:51,929 INFO Processing slice inputs\\20230601_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc\n", - "2024-03-12 13:18:51,950 INFO Creating target dataset target.zarr\n", - "2024-03-12 13:18:52,589 INFO Transaction completed.\n", - "2024-03-12 13:18:52,589 INFO Slice processed\n", - "2024-03-12 13:18:52,596 INFO Processing slice inputs\\20230603_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc\n", - "2024-03-12 13:18:52,619 INFO Updating target dataset target.zarr\n", - "2024-03-12 13:18:53,307 INFO Transaction completed.\n", - "2024-03-12 13:18:53,308 INFO Slice processed\n", - "2024-03-12 13:18:53,317 INFO Processing slice inputs\\20230605_P1D_CMEMS_HROC_L3-transp_BAL_32V_100m-v01.4.nc\n", - "2024-03-12 13:18:53,342 INFO Updating target dataset target.zarr\n", - "2024-03-12 13:18:53,629 ERROR Error in transaction\n", - "Traceback (most recent call last):\n", - " File \"C:\\Users\\norma\\Projects\\zappend\\zappend\\processor.py\", line 118, in process_slice\n", - " update_target_from_slice(ctx, slice_dataset, rollback_callback)\n", - " File \"C:\\Users\\norma\\Projects\\zappend\\zappend\\processor.py\", line 175, in update_target_from_slice\n", - " slice_ds.to_zarr(\n", - " File \"C:\\Users\\norma\\mamba\\envs\\xcube\\Lib\\site-packages\\xarray\\core\\dataset.py\", line 2461, in to_zarr\n", - " return to_zarr( # type: ignore[call-overload,misc]\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"C:\\Users\\norma\\mamba\\envs\\xcube\\Lib\\site-packages\\xarray\\backends\\api.py\", line 1692, in to_zarr\n", - " writes = writer.sync(\n", - " ^^^^^^^^^^^^\n", - " File \"C:\\Users\\norma\\mamba\\envs\\xcube\\Lib\\site-packages\\xarray\\backends\\common.py\", line 256, in sync\n", - " delayed_store = chunkmanager.store(\n", - " ^^^^^^^^^^^^^^^^^^^\n", - " File \"C:\\Users\\norma\\mamba\\envs\\xcube\\Lib\\site-packages\\xarray\\core\\daskmanager.py\", line 211, in store\n", - " return store(\n", - " ^^^^^^\n", - " File \"C:\\Users\\norma\\mamba\\envs\\xcube\\Lib\\site-packages\\dask\\array\\core.py\", line 1236, in store\n", - " compute_as_if_collection(Array, store_dsk, map_keys, **kwargs)\n", - " File \"C:\\Users\\norma\\mamba\\envs\\xcube\\Lib\\site-packages\\dask\\base.py\", line 404, in compute_as_if_collection\n", - " return schedule(dsk2, keys, **kwargs)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"C:\\Users\\norma\\mamba\\envs\\xcube\\Lib\\site-packages\\dask\\threaded.py\", line 90, in get\n", - " results = get_async(\n", - " ^^^^^^^^^^\n", - " File \"C:\\Users\\norma\\mamba\\envs\\xcube\\Lib\\site-packages\\dask\\local.py\", line 512, in get_async\n", - " raise_exception(exc, tb)\n", - " File \"C:\\Users\\norma\\mamba\\envs\\xcube\\Lib\\site-packages\\dask\\local.py\", line 320, in reraise\n", - " raise exc\n", - " File \"C:\\Users\\norma\\mamba\\envs\\xcube\\Lib\\site-packages\\dask\\local.py\", line 225, in execute_task\n", - " result = _execute_task(task, data)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"C:\\Users\\norma\\mamba\\envs\\xcube\\Lib\\site-packages\\dask\\core.py\", line 127, in _execute_task\n", - " return func(*(_execute_task(a, cache) for a in args))\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"C:\\Users\\norma\\mamba\\envs\\xcube\\Lib\\site-packages\\dask\\core.py\", line 127, in \n", - " return func(*(_execute_task(a, cache) for a in args))\n", - " ^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"C:\\Users\\norma\\mamba\\envs\\xcube\\Lib\\site-packages\\dask\\core.py\", line 127, in _execute_task\n", - " return func(*(_execute_task(a, cache) for a in args))\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"C:\\Users\\norma\\mamba\\envs\\xcube\\Lib\\site-packages\\dask\\core.py\", line 127, in \n", - " return func(*(_execute_task(a, cache) for a in args))\n", - " ^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"C:\\Users\\norma\\mamba\\envs\\xcube\\Lib\\site-packages\\dask\\core.py\", line 127, in _execute_task\n", - " return func(*(_execute_task(a, cache) for a in args))\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"C:\\Users\\norma\\mamba\\envs\\xcube\\Lib\\site-packages\\xarray\\core\\parallel.py\", line 268, in _wrapper\n", - " result = func(*converted_args, **kwargs)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"C:\\Users\\norma\\AppData\\Local\\Temp\\ipykernel_23264\\2206992638.py\", line 14, in half_spm\n", - " raise ValueError(\"Bad chunk detected!\")\n", - "ValueError: Bad chunk detected!\n", - "2024-03-12 13:18:53,640 INFO Rolling back 7 action(s)\n", - "2024-03-12 13:18:53,652 INFO Transaction completed.\n", - "2024-03-12 13:18:53,653 INFO Slice processed\n" - ] - }, - { - "ename": "ValueError", - "evalue": "Bad chunk detected!", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[1;32mIn[41], line 2\u001b[0m\n\u001b[0;32m 1\u001b[0m rmdir(target_path)\n\u001b[1;32m----> 2\u001b[0m \u001b[43mzappend\u001b[49m\u001b[43m(\u001b[49m\u001b[43mslice_paths\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtarget_dir\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtarget_path\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mslice_source\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mMyGrottySliceSource\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[1;32m~\\Projects\\zappend\\zappend\\api.py:64\u001b[0m, in \u001b[0;36mzappend\u001b[1;34m(slices, config, **kwargs)\u001b[0m\n\u001b[0;32m 38\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Robustly create or update a Zarr dataset from dataset slices.\u001b[39;00m\n\u001b[0;32m 39\u001b[0m \n\u001b[0;32m 40\u001b[0m \u001b[38;5;124;03mThe `zappend` function concatenates the dataset slices from given\u001b[39;00m\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 61\u001b[0m \u001b[38;5;124;03m Can be used to pass or override configuration values in *config*.\u001b[39;00m\n\u001b[0;32m 62\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 63\u001b[0m processor \u001b[38;5;241m=\u001b[39m Processor(config, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m---> 64\u001b[0m \u001b[43mprocessor\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mprocess_slices\u001b[49m\u001b[43m(\u001b[49m\u001b[43mslices\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[1;32m~\\Projects\\zappend\\zappend\\processor.py:70\u001b[0m, in \u001b[0;36mProcessor.process_slices\u001b[1;34m(self, slices)\u001b[0m\n\u001b[0;32m 68\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_profiler:\n\u001b[0;32m 69\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m slice_index, slice_item \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(slices):\n\u001b[1;32m---> 70\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mprocess_slice\u001b[49m\u001b[43m(\u001b[49m\u001b[43mslice_item\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mslice_index\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mslice_index\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[1;32m~\\Projects\\zappend\\zappend\\processor.py:118\u001b[0m, in \u001b[0;36mProcessor.process_slice\u001b[1;34m(self, slice_item, slice_index)\u001b[0m\n\u001b[0;32m 116\u001b[0m create_target_from_slice(ctx, slice_dataset, rollback_callback)\n\u001b[0;32m 117\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m--> 118\u001b[0m \u001b[43mupdate_target_from_slice\u001b[49m\u001b[43m(\u001b[49m\u001b[43mctx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mslice_dataset\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrollback_callback\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[1;32m~\\Projects\\zappend\\zappend\\processor.py:175\u001b[0m, in \u001b[0;36mupdate_target_from_slice\u001b[1;34m(ctx, slice_ds, rollback_cb)\u001b[0m\n\u001b[0;32m 170\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m\n\u001b[0;32m 172\u001b[0m target_store \u001b[38;5;241m=\u001b[39m RollbackStore(\n\u001b[0;32m 173\u001b[0m target_dir\u001b[38;5;241m.\u001b[39mfs\u001b[38;5;241m.\u001b[39mget_mapper(root\u001b[38;5;241m=\u001b[39mtarget_dir\u001b[38;5;241m.\u001b[39mpath), rollback_cb\n\u001b[0;32m 174\u001b[0m )\n\u001b[1;32m--> 175\u001b[0m \u001b[43mslice_ds\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto_zarr\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 176\u001b[0m \u001b[43m \u001b[49m\u001b[43mstore\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtarget_store\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 177\u001b[0m \u001b[43m \u001b[49m\u001b[43mwrite_empty_chunks\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[0;32m 178\u001b[0m \u001b[43m \u001b[49m\u001b[43mconsolidated\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[0;32m 179\u001b[0m \u001b[43m \u001b[49m\u001b[43mmode\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43ma\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m 180\u001b[0m \u001b[43m \u001b[49m\u001b[43mappend_dim\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mctx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mconfig\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mappend_dim\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 181\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 183\u001b[0m post_update_target(ctx, target_store, slice_ds)\n", - "File \u001b[1;32m~\\mamba\\envs\\xcube\\Lib\\site-packages\\xarray\\core\\dataset.py:2461\u001b[0m, in \u001b[0;36mDataset.to_zarr\u001b[1;34m(self, store, chunk_store, mode, synchronizer, group, encoding, compute, consolidated, append_dim, region, safe_chunks, storage_options, zarr_version, write_empty_chunks, chunkmanager_store_kwargs)\u001b[0m\n\u001b[0;32m 2329\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Write dataset contents to a zarr group.\u001b[39;00m\n\u001b[0;32m 2330\u001b[0m \n\u001b[0;32m 2331\u001b[0m \u001b[38;5;124;03mZarr chunks are determined in the following way:\u001b[39;00m\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 2457\u001b[0m \u001b[38;5;124;03m The I/O user guide, with more details and examples.\u001b[39;00m\n\u001b[0;32m 2458\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 2459\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mxarray\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mbackends\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mapi\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m to_zarr\n\u001b[1;32m-> 2461\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mto_zarr\u001b[49m\u001b[43m(\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# type: ignore[call-overload,misc]\u001b[39;49;00m\n\u001b[0;32m 2462\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m 2463\u001b[0m \u001b[43m \u001b[49m\u001b[43mstore\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstore\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 2464\u001b[0m \u001b[43m \u001b[49m\u001b[43mchunk_store\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mchunk_store\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 2465\u001b[0m \u001b[43m \u001b[49m\u001b[43mstorage_options\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstorage_options\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 2466\u001b[0m \u001b[43m \u001b[49m\u001b[43mmode\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmode\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 2467\u001b[0m \u001b[43m \u001b[49m\u001b[43msynchronizer\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msynchronizer\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 2468\u001b[0m \u001b[43m \u001b[49m\u001b[43mgroup\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgroup\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 2469\u001b[0m \u001b[43m \u001b[49m\u001b[43mencoding\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mencoding\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 2470\u001b[0m \u001b[43m \u001b[49m\u001b[43mcompute\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcompute\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 2471\u001b[0m \u001b[43m \u001b[49m\u001b[43mconsolidated\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mconsolidated\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 2472\u001b[0m \u001b[43m \u001b[49m\u001b[43mappend_dim\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mappend_dim\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 2473\u001b[0m \u001b[43m \u001b[49m\u001b[43mregion\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mregion\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 2474\u001b[0m \u001b[43m \u001b[49m\u001b[43msafe_chunks\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msafe_chunks\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 2475\u001b[0m \u001b[43m \u001b[49m\u001b[43mzarr_version\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mzarr_version\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 2476\u001b[0m \u001b[43m \u001b[49m\u001b[43mwrite_empty_chunks\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mwrite_empty_chunks\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 2477\u001b[0m \u001b[43m \u001b[49m\u001b[43mchunkmanager_store_kwargs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mchunkmanager_store_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 2478\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[1;32m~\\mamba\\envs\\xcube\\Lib\\site-packages\\xarray\\backends\\api.py:1692\u001b[0m, in \u001b[0;36mto_zarr\u001b[1;34m(dataset, store, chunk_store, mode, synchronizer, group, encoding, compute, consolidated, append_dim, region, safe_chunks, storage_options, zarr_version, write_empty_chunks, chunkmanager_store_kwargs)\u001b[0m\n\u001b[0;32m 1690\u001b[0m \u001b[38;5;66;03m# TODO: figure out how to properly handle unlimited_dims\u001b[39;00m\n\u001b[0;32m 1691\u001b[0m dump_to_store(dataset, zstore, writer, encoding\u001b[38;5;241m=\u001b[39mencoding)\n\u001b[1;32m-> 1692\u001b[0m writes \u001b[38;5;241m=\u001b[39m \u001b[43mwriter\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msync\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 1693\u001b[0m \u001b[43m \u001b[49m\u001b[43mcompute\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcompute\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mchunkmanager_store_kwargs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mchunkmanager_store_kwargs\u001b[49m\n\u001b[0;32m 1694\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 1696\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m compute:\n\u001b[0;32m 1697\u001b[0m _finalize_store(writes, zstore)\n", - "File \u001b[1;32m~\\mamba\\envs\\xcube\\Lib\\site-packages\\xarray\\backends\\common.py:256\u001b[0m, in \u001b[0;36mArrayWriter.sync\u001b[1;34m(self, compute, chunkmanager_store_kwargs)\u001b[0m\n\u001b[0;32m 253\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m chunkmanager_store_kwargs \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m 254\u001b[0m chunkmanager_store_kwargs \u001b[38;5;241m=\u001b[39m {}\n\u001b[1;32m--> 256\u001b[0m delayed_store \u001b[38;5;241m=\u001b[39m \u001b[43mchunkmanager\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstore\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 257\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msources\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 258\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtargets\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 259\u001b[0m \u001b[43m \u001b[49m\u001b[43mlock\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlock\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 260\u001b[0m \u001b[43m \u001b[49m\u001b[43mcompute\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcompute\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 261\u001b[0m \u001b[43m \u001b[49m\u001b[43mflush\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[0;32m 262\u001b[0m \u001b[43m \u001b[49m\u001b[43mregions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mregions\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 263\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mchunkmanager_store_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 264\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 265\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msources \u001b[38;5;241m=\u001b[39m []\n\u001b[0;32m 266\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtargets \u001b[38;5;241m=\u001b[39m []\n", - "File \u001b[1;32m~\\mamba\\envs\\xcube\\Lib\\site-packages\\xarray\\core\\daskmanager.py:211\u001b[0m, in \u001b[0;36mDaskManager.store\u001b[1;34m(self, sources, targets, **kwargs)\u001b[0m\n\u001b[0;32m 203\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mstore\u001b[39m(\n\u001b[0;32m 204\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[0;32m 205\u001b[0m sources: DaskArray \u001b[38;5;241m|\u001b[39m Sequence[DaskArray],\n\u001b[0;32m 206\u001b[0m targets: Any,\n\u001b[0;32m 207\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs,\n\u001b[0;32m 208\u001b[0m ):\n\u001b[0;32m 209\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mdask\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01marray\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m store\n\u001b[1;32m--> 211\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mstore\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 212\u001b[0m \u001b[43m \u001b[49m\u001b[43msources\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msources\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 213\u001b[0m \u001b[43m \u001b[49m\u001b[43mtargets\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtargets\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 214\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 215\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[1;32m~\\mamba\\envs\\xcube\\Lib\\site-packages\\dask\\array\\core.py:1236\u001b[0m, in \u001b[0;36mstore\u001b[1;34m(***failed resolving arguments***)\u001b[0m\n\u001b[0;32m 1234\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m compute:\n\u001b[0;32m 1235\u001b[0m store_dsk \u001b[38;5;241m=\u001b[39m HighLevelGraph(layers, dependencies)\n\u001b[1;32m-> 1236\u001b[0m \u001b[43mcompute_as_if_collection\u001b[49m\u001b[43m(\u001b[49m\u001b[43mArray\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstore_dsk\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmap_keys\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 1237\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m 1239\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", - "File \u001b[1;32m~\\mamba\\envs\\xcube\\Lib\\site-packages\\dask\\base.py:404\u001b[0m, in \u001b[0;36mcompute_as_if_collection\u001b[1;34m(cls, dsk, keys, scheduler, get, **kwargs)\u001b[0m\n\u001b[0;32m 402\u001b[0m schedule \u001b[38;5;241m=\u001b[39m get_scheduler(scheduler\u001b[38;5;241m=\u001b[39mscheduler, \u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mcls\u001b[39m, get\u001b[38;5;241m=\u001b[39mget)\n\u001b[0;32m 403\u001b[0m dsk2 \u001b[38;5;241m=\u001b[39m optimization_function(\u001b[38;5;28mcls\u001b[39m)(dsk, keys, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m--> 404\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mschedule\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdsk2\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkeys\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[1;32m~\\mamba\\envs\\xcube\\Lib\\site-packages\\dask\\threaded.py:90\u001b[0m, in \u001b[0;36mget\u001b[1;34m(dsk, keys, cache, num_workers, pool, **kwargs)\u001b[0m\n\u001b[0;32m 87\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(pool, multiprocessing\u001b[38;5;241m.\u001b[39mpool\u001b[38;5;241m.\u001b[39mPool):\n\u001b[0;32m 88\u001b[0m pool \u001b[38;5;241m=\u001b[39m MultiprocessingPoolExecutor(pool)\n\u001b[1;32m---> 90\u001b[0m results \u001b[38;5;241m=\u001b[39m \u001b[43mget_async\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 91\u001b[0m \u001b[43m \u001b[49m\u001b[43mpool\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msubmit\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 92\u001b[0m \u001b[43m \u001b[49m\u001b[43mpool\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_max_workers\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 93\u001b[0m \u001b[43m \u001b[49m\u001b[43mdsk\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 94\u001b[0m \u001b[43m \u001b[49m\u001b[43mkeys\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 95\u001b[0m \u001b[43m \u001b[49m\u001b[43mcache\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcache\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 96\u001b[0m \u001b[43m \u001b[49m\u001b[43mget_id\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m_thread_get_id\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 97\u001b[0m \u001b[43m \u001b[49m\u001b[43mpack_exception\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpack_exception\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 98\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 99\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 101\u001b[0m \u001b[38;5;66;03m# Cleanup pools associated to dead threads\u001b[39;00m\n\u001b[0;32m 102\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m pools_lock:\n", - "File \u001b[1;32m~\\mamba\\envs\\xcube\\Lib\\site-packages\\dask\\local.py:512\u001b[0m, in \u001b[0;36mget_async\u001b[1;34m(submit, num_workers, dsk, result, cache, get_id, rerun_exceptions_locally, pack_exception, raise_exception, callbacks, dumps, loads, chunksize, **kwargs)\u001b[0m\n\u001b[0;32m 510\u001b[0m _execute_task(task, data) \u001b[38;5;66;03m# Re-execute locally\u001b[39;00m\n\u001b[0;32m 511\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m--> 512\u001b[0m \u001b[43mraise_exception\u001b[49m\u001b[43m(\u001b[49m\u001b[43mexc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtb\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 513\u001b[0m res, worker_id \u001b[38;5;241m=\u001b[39m loads(res_info)\n\u001b[0;32m 514\u001b[0m state[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcache\u001b[39m\u001b[38;5;124m\"\u001b[39m][key] \u001b[38;5;241m=\u001b[39m res\n", - "File \u001b[1;32m~\\mamba\\envs\\xcube\\Lib\\site-packages\\dask\\local.py:320\u001b[0m, in \u001b[0;36mreraise\u001b[1;34m(exc, tb)\u001b[0m\n\u001b[0;32m 318\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m exc\u001b[38;5;241m.\u001b[39m__traceback__ \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m tb:\n\u001b[0;32m 319\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m exc\u001b[38;5;241m.\u001b[39mwith_traceback(tb)\n\u001b[1;32m--> 320\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m exc\n", - "File \u001b[1;32m~\\mamba\\envs\\xcube\\Lib\\site-packages\\dask\\local.py:225\u001b[0m, in \u001b[0;36mexecute_task\u001b[1;34m(key, task_info, dumps, loads, get_id, pack_exception)\u001b[0m\n\u001b[0;32m 223\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m 224\u001b[0m task, data \u001b[38;5;241m=\u001b[39m loads(task_info)\n\u001b[1;32m--> 225\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[43m_execute_task\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtask\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdata\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 226\u001b[0m \u001b[38;5;28mid\u001b[39m \u001b[38;5;241m=\u001b[39m get_id()\n\u001b[0;32m 227\u001b[0m result \u001b[38;5;241m=\u001b[39m dumps((result, \u001b[38;5;28mid\u001b[39m))\n", - "File \u001b[1;32m~\\mamba\\envs\\xcube\\Lib\\site-packages\\dask\\core.py:127\u001b[0m, in \u001b[0;36m_execute_task\u001b[1;34m(arg, cache, dsk)\u001b[0m\n\u001b[0;32m 123\u001b[0m func, args \u001b[38;5;241m=\u001b[39m arg[\u001b[38;5;241m0\u001b[39m], arg[\u001b[38;5;241m1\u001b[39m:]\n\u001b[0;32m 124\u001b[0m \u001b[38;5;66;03m# Note: Don't assign the subtask results to a variable. numpy detects\u001b[39;00m\n\u001b[0;32m 125\u001b[0m \u001b[38;5;66;03m# temporaries by their reference count and can execute certain\u001b[39;00m\n\u001b[0;32m 126\u001b[0m \u001b[38;5;66;03m# operations in-place.\u001b[39;00m\n\u001b[1;32m--> 127\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m_execute_task\u001b[49m\u001b[43m(\u001b[49m\u001b[43ma\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcache\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43ma\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 128\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m ishashable(arg):\n\u001b[0;32m 129\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m arg\n", - "File \u001b[1;32m~\\mamba\\envs\\xcube\\Lib\\site-packages\\dask\\core.py:127\u001b[0m, in \u001b[0;36m\u001b[1;34m(.0)\u001b[0m\n\u001b[0;32m 123\u001b[0m func, args \u001b[38;5;241m=\u001b[39m arg[\u001b[38;5;241m0\u001b[39m], arg[\u001b[38;5;241m1\u001b[39m:]\n\u001b[0;32m 124\u001b[0m \u001b[38;5;66;03m# Note: Don't assign the subtask results to a variable. numpy detects\u001b[39;00m\n\u001b[0;32m 125\u001b[0m \u001b[38;5;66;03m# temporaries by their reference count and can execute certain\u001b[39;00m\n\u001b[0;32m 126\u001b[0m \u001b[38;5;66;03m# operations in-place.\u001b[39;00m\n\u001b[1;32m--> 127\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m func(\u001b[38;5;241m*\u001b[39m(\u001b[43m_execute_task\u001b[49m\u001b[43m(\u001b[49m\u001b[43ma\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcache\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mfor\u001b[39;00m a \u001b[38;5;129;01min\u001b[39;00m args))\n\u001b[0;32m 128\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m ishashable(arg):\n\u001b[0;32m 129\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m arg\n", - "File \u001b[1;32m~\\mamba\\envs\\xcube\\Lib\\site-packages\\dask\\core.py:127\u001b[0m, in \u001b[0;36m_execute_task\u001b[1;34m(arg, cache, dsk)\u001b[0m\n\u001b[0;32m 123\u001b[0m func, args \u001b[38;5;241m=\u001b[39m arg[\u001b[38;5;241m0\u001b[39m], arg[\u001b[38;5;241m1\u001b[39m:]\n\u001b[0;32m 124\u001b[0m \u001b[38;5;66;03m# Note: Don't assign the subtask results to a variable. numpy detects\u001b[39;00m\n\u001b[0;32m 125\u001b[0m \u001b[38;5;66;03m# temporaries by their reference count and can execute certain\u001b[39;00m\n\u001b[0;32m 126\u001b[0m \u001b[38;5;66;03m# operations in-place.\u001b[39;00m\n\u001b[1;32m--> 127\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m_execute_task\u001b[49m\u001b[43m(\u001b[49m\u001b[43ma\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcache\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43ma\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 128\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m ishashable(arg):\n\u001b[0;32m 129\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m arg\n", - "File \u001b[1;32m~\\mamba\\envs\\xcube\\Lib\\site-packages\\dask\\core.py:127\u001b[0m, in \u001b[0;36m\u001b[1;34m(.0)\u001b[0m\n\u001b[0;32m 123\u001b[0m func, args \u001b[38;5;241m=\u001b[39m arg[\u001b[38;5;241m0\u001b[39m], arg[\u001b[38;5;241m1\u001b[39m:]\n\u001b[0;32m 124\u001b[0m \u001b[38;5;66;03m# Note: Don't assign the subtask results to a variable. numpy detects\u001b[39;00m\n\u001b[0;32m 125\u001b[0m \u001b[38;5;66;03m# temporaries by their reference count and can execute certain\u001b[39;00m\n\u001b[0;32m 126\u001b[0m \u001b[38;5;66;03m# operations in-place.\u001b[39;00m\n\u001b[1;32m--> 127\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m func(\u001b[38;5;241m*\u001b[39m(\u001b[43m_execute_task\u001b[49m\u001b[43m(\u001b[49m\u001b[43ma\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcache\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mfor\u001b[39;00m a \u001b[38;5;129;01min\u001b[39;00m args))\n\u001b[0;32m 128\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m ishashable(arg):\n\u001b[0;32m 129\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m arg\n", - "File \u001b[1;32m~\\mamba\\envs\\xcube\\Lib\\site-packages\\dask\\core.py:127\u001b[0m, in \u001b[0;36m_execute_task\u001b[1;34m(arg, cache, dsk)\u001b[0m\n\u001b[0;32m 123\u001b[0m func, args \u001b[38;5;241m=\u001b[39m arg[\u001b[38;5;241m0\u001b[39m], arg[\u001b[38;5;241m1\u001b[39m:]\n\u001b[0;32m 124\u001b[0m \u001b[38;5;66;03m# Note: Don't assign the subtask results to a variable. numpy detects\u001b[39;00m\n\u001b[0;32m 125\u001b[0m \u001b[38;5;66;03m# temporaries by their reference count and can execute certain\u001b[39;00m\n\u001b[0;32m 126\u001b[0m \u001b[38;5;66;03m# operations in-place.\u001b[39;00m\n\u001b[1;32m--> 127\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m_execute_task\u001b[49m\u001b[43m(\u001b[49m\u001b[43ma\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcache\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43ma\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 128\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m ishashable(arg):\n\u001b[0;32m 129\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m arg\n", - "File \u001b[1;32m~\\mamba\\envs\\xcube\\Lib\\site-packages\\xarray\\core\\parallel.py:268\u001b[0m, in \u001b[0;36mmap_blocks.._wrapper\u001b[1;34m(func, args, kwargs, arg_is_array, expected)\u001b[0m\n\u001b[0;32m 258\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 259\u001b[0m \u001b[38;5;124;03mWrapper function that receives datasets in args; converts to dataarrays when necessary;\u001b[39;00m\n\u001b[0;32m 260\u001b[0m \u001b[38;5;124;03mpasses these to the user function `func` and checks returned objects for expected shapes/sizes/etc.\u001b[39;00m\n\u001b[0;32m 261\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 263\u001b[0m converted_args \u001b[38;5;241m=\u001b[39m [\n\u001b[0;32m 264\u001b[0m dataset_to_dataarray(arg) \u001b[38;5;28;01mif\u001b[39;00m is_array \u001b[38;5;28;01melse\u001b[39;00m arg\n\u001b[0;32m 265\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m is_array, arg \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mzip\u001b[39m(arg_is_array, args)\n\u001b[0;32m 266\u001b[0m ]\n\u001b[1;32m--> 268\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mconverted_args\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 270\u001b[0m \u001b[38;5;66;03m# check all dims are present\u001b[39;00m\n\u001b[0;32m 271\u001b[0m missing_dimensions \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m(expected[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mshapes\u001b[39m\u001b[38;5;124m\"\u001b[39m]) \u001b[38;5;241m-\u001b[39m \u001b[38;5;28mset\u001b[39m(result\u001b[38;5;241m.\u001b[39msizes)\n", - "Cell \u001b[1;32mIn[40], line 14\u001b[0m, in \u001b[0;36mMyGrottySliceSource.half_spm\u001b[1;34m(self, spm)\u001b[0m\n\u001b[0;32m 12\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnum_chunks_seen \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[0;32m 13\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnum_chunks_seen \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m12\u001b[39m:\n\u001b[1;32m---> 14\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mBad chunk detected!\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m 15\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;241m0.5\u001b[39m \u001b[38;5;241m*\u001b[39m spm\n", - "\u001b[1;31mValueError\u001b[0m: Bad chunk detected!" - ] - } - ], - "source": [ - "rmdir(target_path)\n", - "zappend(slice_paths, target_dir=target_path, slice_source=MyGrottySliceSource)" - ] - }, - { - "cell_type": "markdown", - "id": "63ab479d-1ce5-4440-b56a-1ee9f1688328", - "metadata": {}, - "source": [ - "Verify target dataset can be opened but has only has two of three time steps:" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "id": "912ac28d-f9dd-4518-be8f-24eea57cd3fa", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.Dataset>\n",
-       "Dimensions:  (time: 2, lat: 8640, lon: 3435)\n",
-       "Coordinates:\n",
-       "  * lat      (lat) float64 64.0 64.0 64.0 64.0 64.0 ... 56.0 56.0 56.0 56.0 56.0\n",
-       "  * lon      (lon) float64 6.0 6.002 6.004 6.005 6.007 ... 11.99 12.0 12.0 12.0\n",
-       "  * time     (time) datetime64[ns] 2023-06-01 2023-06-03\n",
-       "Data variables:\n",
-       "    SPM      (time, lat, lon) float32 dask.array<chunksize=(1, 1000, 2000), meta=np.ndarray>\n",
-       "    SPM_05   (time, lat, lon) float32 dask.array<chunksize=(1, 1000, 2000), meta=np.ndarray>\n",
-       "    TUR      (time, lat, lon) float32 dask.array<chunksize=(1, 1000, 2000), meta=np.ndarray>\n",
-       "Attributes: (12/46)\n",
-       "    Conventions:                CF-1.7\n",
-       "    TileSize:                   540:286\n",
-       "    cmd_data_type:              Grid\n",
-       "    cmems_dataset:              cmems_obs_oc_bal_bgc_transp_nrt_l3-hr_P1D-m\n",
-       "    cmems_product_id:           OCEANCOLOUR_BAL_BGC_HR_L3_NRT_009_202\n",
-       "    contact:                    https://marine.copernicus.eu/\n",
-       "    ...                         ...\n",
-       "    time_coverage_duration:     P1D\n",
-       "    time_coverage_resolution:   P1D\n",
-       "    time_coverage_start:        20230601T000000Z\n",
-       "    time_coverage_stop:         20230601T235959Z\n",
-       "    title:                      CMEMS HR-OC Baltic Sea transparency (spm, tur...\n",
-       "    tracking_id:                62bdb787-8671-4098-b693-6e3aa1b7d660
" - ], - "text/plain": [ - "\n", - "Dimensions: (time: 2, lat: 8640, lon: 3435)\n", - "Coordinates:\n", - " * lat (lat) float64 64.0 64.0 64.0 64.0 64.0 ... 56.0 56.0 56.0 56.0 56.0\n", - " * lon (lon) float64 6.0 6.002 6.004 6.005 6.007 ... 11.99 12.0 12.0 12.0\n", - " * time (time) datetime64[ns] 2023-06-01 2023-06-03\n", - "Data variables:\n", - " SPM (time, lat, lon) float32 dask.array\n", - " SPM_05 (time, lat, lon) float32 dask.array\n", - " TUR (time, lat, lon) float32 dask.array\n", - "Attributes: (12/46)\n", - " Conventions: CF-1.7\n", - " TileSize: 540:286\n", - " cmd_data_type: Grid\n", - " cmems_dataset: cmems_obs_oc_bal_bgc_transp_nrt_l3-hr_P1D-m\n", - " cmems_product_id: OCEANCOLOUR_BAL_BGC_HR_L3_NRT_009_202\n", - " contact: https://marine.copernicus.eu/\n", - " ... ...\n", - " time_coverage_duration: P1D\n", - " time_coverage_resolution: P1D\n", - " time_coverage_start: 20230601T000000Z\n", - " time_coverage_stop: 20230601T235959Z\n", - " title: CMEMS HR-OC Baltic Sea transparency (spm, tur...\n", - " tracking_id: 62bdb787-8671-4098-b693-6e3aa1b7d660" - ] - }, - "execution_count": 42, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "xr.open_zarr(target_path)" - ] - }, - { - "cell_type": "markdown", - "id": "e3920732-c82a-4695-abbf-73f7f895a91e", - "metadata": {}, - "source": [ - "---" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "id": "1ed243f1-388e-4dca-8040-08a2c63a167e", - "metadata": {}, - "outputs": [], - "source": [ - "rmdir(target_path)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.8" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/examples/zarr_v2.ipynb b/examples/zarr_v2.ipynb new file mode 100644 index 0000000..67908bd --- /dev/null +++ b/examples/zarr_v2.ipynb @@ -0,0 +1,2334 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "ddaea86a0d0fc107", + "metadata": {}, + "source": [ + "# Appending Zarr v2 slices with time-series-friendly chunks\n", + "\n", + "This notebook generates and appends 31 daily Zarr v2 slices in `inputs/zarr-v2`. Zarr v2 is the default target format, so `zarr_version` is deliberately omitted. The output is written below `outputs`, which is ignored by Git." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d99f4dffe7fe25d", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:48:24.521480988Z", + "start_time": "2026-10-29T16:48:23.716226098Z" + } + }, + "outputs": [], + "source": [ + "import os\n", + "import shutil\n", + "from pathlib import Path\n", + "\n", + "import xarray as xr\n", + "from create_inputs import make_zarr_v2_slices\n", + "\n", + "from zappend.api import zappend" + ] + }, + { + "cell_type": "markdown", + "id": "65071a2275149806", + "metadata": {}, + "source": [ + "## Generate daily input slices\n", + "\n", + "The helper creates deterministic daily slices with dimensions `(time=1, lat=1800, lon=3600)`. Each day has a distinct constant value, which makes it easy to check that all inputs were appended in order." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "71319447e8a5d252", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T15:20:01.335166595Z", + "start_time": "2026-10-29T15:19:57.167629108Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 5.16 s, sys: 880 ms, total: 6.04 s\n", + "Wall time: 4.15 s\n" + ] + } + ], + "source": [ + "%%time\n", + "make_zarr_v2_slices(31)" + ] + }, + { + "cell_type": "markdown", + "id": "690f59a8b08a9bfa", + "metadata": {}, + "source": [ + "## Collect the inputs\n", + "\n", + "`zappend` accepts paths directly. Sorting the paths puts the daily slices in chronological order. The same list is used for both target layouts below." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "774cb2499ba70f69", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:48:29.942312857Z", + "start_time": "2026-10-29T16:48:29.919537061Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['inputs/zarr-v2/slice-2024-01-01.zarr',\n", + " 'inputs/zarr-v2/slice-2024-01-02.zarr',\n", + " 'inputs/zarr-v2/slice-2024-01-03.zarr',\n", + " 'inputs/zarr-v2/slice-2024-01-04.zarr',\n", + " 'inputs/zarr-v2/slice-2024-01-05.zarr',\n", + " 'inputs/zarr-v2/slice-2024-01-06.zarr',\n", + " 'inputs/zarr-v2/slice-2024-01-07.zarr',\n", + " 'inputs/zarr-v2/slice-2024-01-08.zarr',\n", + " 'inputs/zarr-v2/slice-2024-01-09.zarr',\n", + " 'inputs/zarr-v2/slice-2024-01-10.zarr',\n", + " 'inputs/zarr-v2/slice-2024-01-11.zarr',\n", + " 'inputs/zarr-v2/slice-2024-01-12.zarr',\n", + " 'inputs/zarr-v2/slice-2024-01-13.zarr',\n", + " 'inputs/zarr-v2/slice-2024-01-14.zarr',\n", + " 'inputs/zarr-v2/slice-2024-01-15.zarr',\n", + " 'inputs/zarr-v2/slice-2024-01-16.zarr',\n", + " 'inputs/zarr-v2/slice-2024-01-17.zarr',\n", + " 'inputs/zarr-v2/slice-2024-01-18.zarr',\n", + " 'inputs/zarr-v2/slice-2024-01-19.zarr',\n", + " 'inputs/zarr-v2/slice-2024-01-20.zarr',\n", + " 'inputs/zarr-v2/slice-2024-01-21.zarr',\n", + " 'inputs/zarr-v2/slice-2024-01-22.zarr',\n", + " 'inputs/zarr-v2/slice-2024-01-23.zarr',\n", + " 'inputs/zarr-v2/slice-2024-01-24.zarr',\n", + " 'inputs/zarr-v2/slice-2024-01-25.zarr',\n", + " 'inputs/zarr-v2/slice-2024-01-26.zarr',\n", + " 'inputs/zarr-v2/slice-2024-01-27.zarr',\n", + " 'inputs/zarr-v2/slice-2024-01-28.zarr',\n", + " 'inputs/zarr-v2/slice-2024-01-29.zarr',\n", + " 'inputs/zarr-v2/slice-2024-01-30.zarr',\n", + " 'inputs/zarr-v2/slice-2024-01-31.zarr']" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "input_dir = Path(\"inputs/zarr-v2\")\n", + "output_dir =Path(\"outputs\")\n", + "output_dir.mkdir(exist_ok=True)\n", + "slices = sorted(str(path) for path in input_dir.glob('*.zarr'))\n", + "slices" + ] + }, + { + "cell_type": "markdown", + "id": "e3b2ec4e6b8392da", + "metadata": {}, + "source": [ + "## Default layout: favor spatial access\n", + "\n", + "This first call keeps the input encoding. The source data use one day per time chunk and 450 by 450 spatial chunks, a sensible layout when maps or single days are the common access pattern. `force_new=True` makes the notebook repeatable by replacing only this example target." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "d32f9acc0f43d8f2", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T15:20:07.052761309Z", + "start_time": "2026-10-29T15:20:01.387486659Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-10-29 16:20:01,418 WARNING Setting 'force_new' is enabled. This will permanently delete existing targets (no rollback).\n", + "2026-10-29 16:20:01,421 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-01.zarr\n", + "2026-10-29 16:20:01,431 INFO Creating target dataset outputs/v2_example_space_opt.zarr\n", + "2026-10-29 16:20:01,561 INFO Transaction completed.\n", + "2026-10-29 16:20:01,562 INFO Slice dataset inputs/zarr-v2/slice-2024-01-01.zarr closed\n", + "2026-10-29 16:20:01,572 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-02.zarr\n", + "2026-10-29 16:20:01,580 INFO Updating target dataset outputs/v2_example_space_opt.zarr\n", + "2026-10-29 16:20:01,722 INFO Transaction completed.\n", + "2026-10-29 16:20:01,723 INFO Slice dataset inputs/zarr-v2/slice-2024-01-02.zarr closed\n", + "2026-10-29 16:20:01,730 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-03.zarr\n", + "2026-10-29 16:20:01,738 INFO Updating target dataset outputs/v2_example_space_opt.zarr\n", + "2026-10-29 16:20:01,882 INFO Transaction completed.\n", + "2026-10-29 16:20:01,883 INFO Slice dataset inputs/zarr-v2/slice-2024-01-03.zarr closed\n", + "2026-10-29 16:20:01,891 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-04.zarr\n", + "2026-10-29 16:20:01,898 INFO Updating target dataset outputs/v2_example_space_opt.zarr\n", + "2026-10-29 16:20:02,030 INFO Transaction completed.\n", + "2026-10-29 16:20:02,030 INFO Slice dataset inputs/zarr-v2/slice-2024-01-04.zarr closed\n", + "2026-10-29 16:20:02,039 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-05.zarr\n", + "2026-10-29 16:20:02,047 INFO Updating target dataset outputs/v2_example_space_opt.zarr\n", + "2026-10-29 16:20:02,192 INFO Transaction completed.\n", + "2026-10-29 16:20:02,193 INFO Slice dataset inputs/zarr-v2/slice-2024-01-05.zarr closed\n", + "2026-10-29 16:20:02,202 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-06.zarr\n", + "2026-10-29 16:20:02,209 INFO Updating target dataset outputs/v2_example_space_opt.zarr\n", + "2026-10-29 16:20:02,398 INFO Transaction completed.\n", + "2026-10-29 16:20:02,398 INFO Slice dataset inputs/zarr-v2/slice-2024-01-06.zarr closed\n", + "2026-10-29 16:20:02,411 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-07.zarr\n", + "2026-10-29 16:20:02,422 INFO Updating target dataset outputs/v2_example_space_opt.zarr\n", + "2026-10-29 16:20:02,597 INFO Transaction completed.\n", + "2026-10-29 16:20:02,598 INFO Slice dataset inputs/zarr-v2/slice-2024-01-07.zarr closed\n", + "2026-10-29 16:20:02,608 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-08.zarr\n", + "2026-10-29 16:20:02,617 INFO Updating target dataset outputs/v2_example_space_opt.zarr\n", + "2026-10-29 16:20:02,789 INFO Transaction completed.\n", + "2026-10-29 16:20:02,789 INFO Slice dataset inputs/zarr-v2/slice-2024-01-08.zarr closed\n", + "2026-10-29 16:20:02,802 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-09.zarr\n", + "2026-10-29 16:20:02,812 INFO Updating target dataset outputs/v2_example_space_opt.zarr\n", + "2026-10-29 16:20:02,991 INFO Transaction completed.\n", + "2026-10-29 16:20:02,991 INFO Slice dataset inputs/zarr-v2/slice-2024-01-09.zarr closed\n", + "2026-10-29 16:20:03,002 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-10.zarr\n", + "2026-10-29 16:20:03,012 INFO Updating target dataset outputs/v2_example_space_opt.zarr\n", + "2026-10-29 16:20:03,157 INFO Transaction completed.\n", + "2026-10-29 16:20:03,157 INFO Slice dataset inputs/zarr-v2/slice-2024-01-10.zarr closed\n", + "2026-10-29 16:20:03,168 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-11.zarr\n", + "2026-10-29 16:20:03,178 INFO Updating target dataset outputs/v2_example_space_opt.zarr\n", + "2026-10-29 16:20:03,312 INFO Transaction completed.\n", + "2026-10-29 16:20:03,312 INFO Slice dataset inputs/zarr-v2/slice-2024-01-11.zarr closed\n", + "2026-10-29 16:20:03,323 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-12.zarr\n", + "2026-10-29 16:20:03,332 INFO Updating target dataset outputs/v2_example_space_opt.zarr\n", + "2026-10-29 16:20:03,472 INFO Transaction completed.\n", + "2026-10-29 16:20:03,472 INFO Slice dataset inputs/zarr-v2/slice-2024-01-12.zarr closed\n", + "2026-10-29 16:20:03,485 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-13.zarr\n", + "2026-10-29 16:20:03,495 INFO Updating target dataset outputs/v2_example_space_opt.zarr\n", + "2026-10-29 16:20:03,662 INFO Transaction completed.\n", + "2026-10-29 16:20:03,663 INFO Slice dataset inputs/zarr-v2/slice-2024-01-13.zarr closed\n", + "2026-10-29 16:20:03,677 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-14.zarr\n", + "2026-10-29 16:20:03,686 INFO Updating target dataset outputs/v2_example_space_opt.zarr\n", + "2026-10-29 16:20:03,829 INFO Transaction completed.\n", + "2026-10-29 16:20:03,830 INFO Slice dataset inputs/zarr-v2/slice-2024-01-14.zarr closed\n", + "2026-10-29 16:20:03,844 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-15.zarr\n", + "2026-10-29 16:20:03,853 INFO Updating target dataset outputs/v2_example_space_opt.zarr\n", + "2026-10-29 16:20:03,992 INFO Transaction completed.\n", + "2026-10-29 16:20:03,993 INFO Slice dataset inputs/zarr-v2/slice-2024-01-15.zarr closed\n", + "2026-10-29 16:20:04,005 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-16.zarr\n", + "2026-10-29 16:20:04,014 INFO Updating target dataset outputs/v2_example_space_opt.zarr\n", + "2026-10-29 16:20:04,203 INFO Transaction completed.\n", + "2026-10-29 16:20:04,204 INFO Slice dataset inputs/zarr-v2/slice-2024-01-16.zarr closed\n", + "2026-10-29 16:20:04,220 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-17.zarr\n", + "2026-10-29 16:20:04,230 INFO Updating target dataset outputs/v2_example_space_opt.zarr\n", + "2026-10-29 16:20:04,389 INFO Transaction completed.\n", + "2026-10-29 16:20:04,389 INFO Slice dataset inputs/zarr-v2/slice-2024-01-17.zarr closed\n", + "2026-10-29 16:20:04,402 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-18.zarr\n", + "2026-10-29 16:20:04,411 INFO Updating target dataset outputs/v2_example_space_opt.zarr\n", + "2026-10-29 16:20:04,555 INFO Transaction completed.\n", + "2026-10-29 16:20:04,555 INFO Slice dataset inputs/zarr-v2/slice-2024-01-18.zarr closed\n", + "2026-10-29 16:20:04,570 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-19.zarr\n", + "2026-10-29 16:20:04,581 INFO Updating target dataset outputs/v2_example_space_opt.zarr\n", + "2026-10-29 16:20:04,785 INFO Transaction completed.\n", + "2026-10-29 16:20:04,786 INFO Slice dataset inputs/zarr-v2/slice-2024-01-19.zarr closed\n", + "2026-10-29 16:20:04,801 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-20.zarr\n", + "2026-10-29 16:20:04,810 INFO Updating target dataset outputs/v2_example_space_opt.zarr\n", + "2026-10-29 16:20:04,981 INFO Transaction completed.\n", + "2026-10-29 16:20:04,981 INFO Slice dataset inputs/zarr-v2/slice-2024-01-20.zarr closed\n", + "2026-10-29 16:20:05,013 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-21.zarr\n", + "2026-10-29 16:20:05,023 INFO Updating target dataset outputs/v2_example_space_opt.zarr\n", + "2026-10-29 16:20:05,167 INFO Transaction completed.\n", + "2026-10-29 16:20:05,168 INFO Slice dataset inputs/zarr-v2/slice-2024-01-21.zarr closed\n", + "2026-10-29 16:20:05,181 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-22.zarr\n", + "2026-10-29 16:20:05,190 INFO Updating target dataset outputs/v2_example_space_opt.zarr\n", + "2026-10-29 16:20:05,349 INFO Transaction completed.\n", + "2026-10-29 16:20:05,350 INFO Slice dataset inputs/zarr-v2/slice-2024-01-22.zarr closed\n", + "2026-10-29 16:20:05,366 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-23.zarr\n", + "2026-10-29 16:20:05,376 INFO Updating target dataset outputs/v2_example_space_opt.zarr\n", + "2026-10-29 16:20:05,532 INFO Transaction completed.\n", + "2026-10-29 16:20:05,533 INFO Slice dataset inputs/zarr-v2/slice-2024-01-23.zarr closed\n", + "2026-10-29 16:20:05,549 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-24.zarr\n", + "2026-10-29 16:20:05,559 INFO Updating target dataset outputs/v2_example_space_opt.zarr\n", + "2026-10-29 16:20:05,724 INFO Transaction completed.\n", + "2026-10-29 16:20:05,724 INFO Slice dataset inputs/zarr-v2/slice-2024-01-24.zarr closed\n", + "2026-10-29 16:20:05,740 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-25.zarr\n", + "2026-10-29 16:20:05,748 INFO Updating target dataset outputs/v2_example_space_opt.zarr\n", + "2026-10-29 16:20:05,919 INFO Transaction completed.\n", + "2026-10-29 16:20:05,919 INFO Slice dataset inputs/zarr-v2/slice-2024-01-25.zarr closed\n", + "2026-10-29 16:20:05,938 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-26.zarr\n", + "2026-10-29 16:20:05,948 INFO Updating target dataset outputs/v2_example_space_opt.zarr\n", + "2026-10-29 16:20:06,110 INFO Transaction completed.\n", + "2026-10-29 16:20:06,110 INFO Slice dataset inputs/zarr-v2/slice-2024-01-26.zarr closed\n", + "2026-10-29 16:20:06,131 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-27.zarr\n", + "2026-10-29 16:20:06,141 INFO Updating target dataset outputs/v2_example_space_opt.zarr\n", + "2026-10-29 16:20:06,281 INFO Transaction completed.\n", + "2026-10-29 16:20:06,282 INFO Slice dataset inputs/zarr-v2/slice-2024-01-27.zarr closed\n", + "2026-10-29 16:20:06,296 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-28.zarr\n", + "2026-10-29 16:20:06,305 INFO Updating target dataset outputs/v2_example_space_opt.zarr\n", + "2026-10-29 16:20:06,539 INFO Transaction completed.\n", + "2026-10-29 16:20:06,539 INFO Slice dataset inputs/zarr-v2/slice-2024-01-28.zarr closed\n", + "2026-10-29 16:20:06,555 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-29.zarr\n", + "2026-10-29 16:20:06,564 INFO Updating target dataset outputs/v2_example_space_opt.zarr\n", + "2026-10-29 16:20:06,703 INFO Transaction completed.\n", + "2026-10-29 16:20:06,704 INFO Slice dataset inputs/zarr-v2/slice-2024-01-29.zarr closed\n", + "2026-10-29 16:20:06,720 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-30.zarr\n", + "2026-10-29 16:20:06,729 INFO Updating target dataset outputs/v2_example_space_opt.zarr\n", + "2026-10-29 16:20:06,869 INFO Transaction completed.\n", + "2026-10-29 16:20:06,870 INFO Slice dataset inputs/zarr-v2/slice-2024-01-30.zarr closed\n", + "2026-10-29 16:20:06,885 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-31.zarr\n", + "2026-10-29 16:20:06,894 INFO Updating target dataset outputs/v2_example_space_opt.zarr\n", + "2026-10-29 16:20:07,032 INFO Transaction completed.\n", + "2026-10-29 16:20:07,032 INFO Slice dataset inputs/zarr-v2/slice-2024-01-31.zarr closed\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 6.65 s, sys: 1.07 s, total: 7.72 s\n", + "Wall time: 5.64 s\n" + ] + } + ], + "source": [ + "%%time\n", + "full_time_chunk = len(slices)\n", + "target = f\"{output_dir}/v2_example_space_opt.zarr\"\n", + "count = zappend(\n", + " slices,\n", + " target_dir=target,\n", + " force_new=True,\n", + " logging=\"INFO\",\n", + ")\n", + "assert count == full_time_chunk" + ] + }, + { + "cell_type": "markdown", + "id": "96700f077099ddb0", + "metadata": {}, + "source": [ + "Opening the target shows its dimensions and the chunks inherited from the first slice. Compare this with the second target below." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "c23451ff8aae4011", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T15:20:07.103455118Z", + "start_time": "2026-10-29T15:20:07.054570241Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 21.2 ms, sys: 3.18 ms, total: 24.4 ms\n", + "Wall time: 20 ms\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 1GB\n",
+       "Dimensions:       (time: 31, lat: 1800, lon: 3600)\n",
+       "Coordinates:\n",
+       "  * time          (time) datetime64[ns] 248B 2024-01-01 ... 2024-01-31\n",
+       "  * lat           (lat) float32 7kB -89.95 -89.85 -89.75 ... 89.75 89.85 89.95\n",
+       "  * lon           (lon) float32 14kB -179.9 -179.9 -179.8 ... 179.7 179.8 179.9\n",
+       "Data variables:\n",
+       "    quality_flag  (time, lat, lon) uint8 201MB dask.array<chunksize=(1, 450, 450), meta=np.ndarray>\n",
+       "    temperature   (time, lat, lon) float32 804MB dask.array<chunksize=(1, 450, 450), meta=np.ndarray>\n",
+       "Attributes:\n",
+       "    title:    Zappend example slice
" + ], + "text/plain": [ + " Size: 1GB\n", + "Dimensions: (time: 31, lat: 1800, lon: 3600)\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 248B 2024-01-01 ... 2024-01-31\n", + " * lat (lat) float32 7kB -89.95 -89.85 -89.75 ... 89.75 89.85 89.95\n", + " * lon (lon) float32 14kB -179.9 -179.9 -179.8 ... 179.7 179.8 179.9\n", + "Data variables:\n", + " quality_flag (time, lat, lon) uint8 201MB dask.array\n", + " temperature (time, lat, lon) float32 804MB dask.array\n", + "Attributes:\n", + " title: Zappend example slice" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "ds = xr.open_zarr(target)\n", + "ds" + ] + }, + { + "cell_type": "markdown", + "id": "eda4671024861157", + "metadata": {}, + "source": [ + "## Time-series layout\n", + "\n", + "Here the data variables are written with one 31-day time chunk. A request for a point time series therefore reads one temporal chunk instead of 31 daily chunks. This trades more data read for map requests against fewer reads for time-series requests." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "476b751be0901fd2", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T15:21:36.348284595Z", + "start_time": "2026-10-29T15:20:07.123950579Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-10-29 16:20:07,169 WARNING Setting 'force_new' is enabled. This will permanently delete existing targets (no rollback).\n", + "2026-10-29 16:20:07,170 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-01.zarr\n", + "2026-10-29 16:20:07,182 INFO Creating target dataset outputs/v2_example_time_opt.zarr\n", + "2026-10-29 16:20:08,898 INFO Transaction completed.\n", + "2026-10-29 16:20:08,898 INFO Slice dataset inputs/zarr-v2/slice-2024-01-01.zarr closed\n", + "2026-10-29 16:20:08,906 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-02.zarr\n", + "2026-10-29 16:20:08,913 INFO Updating target dataset outputs/v2_example_time_opt.zarr\n", + "2026-10-29 16:20:11,707 INFO Transaction completed.\n", + "2026-10-29 16:20:11,707 INFO Slice dataset inputs/zarr-v2/slice-2024-01-02.zarr closed\n", + "2026-10-29 16:20:11,716 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-03.zarr\n", + "2026-10-29 16:20:11,726 INFO Updating target dataset outputs/v2_example_time_opt.zarr\n", + "2026-10-29 16:20:14,530 INFO Transaction completed.\n", + "2026-10-29 16:20:14,531 INFO Slice dataset inputs/zarr-v2/slice-2024-01-03.zarr closed\n", + "2026-10-29 16:20:14,554 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-04.zarr\n", + "2026-10-29 16:20:14,569 INFO Updating target dataset outputs/v2_example_time_opt.zarr\n", + "2026-10-29 16:20:17,331 INFO Transaction completed.\n", + "2026-10-29 16:20:17,332 INFO Slice dataset inputs/zarr-v2/slice-2024-01-04.zarr closed\n", + "2026-10-29 16:20:17,344 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-05.zarr\n", + "2026-10-29 16:20:17,354 INFO Updating target dataset outputs/v2_example_time_opt.zarr\n", + "2026-10-29 16:20:20,011 INFO Transaction completed.\n", + "2026-10-29 16:20:20,011 INFO Slice dataset inputs/zarr-v2/slice-2024-01-05.zarr closed\n", + "2026-10-29 16:20:20,022 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-06.zarr\n", + "2026-10-29 16:20:20,032 INFO Updating target dataset outputs/v2_example_time_opt.zarr\n", + "2026-10-29 16:20:22,841 INFO Transaction completed.\n", + "2026-10-29 16:20:22,842 INFO Slice dataset inputs/zarr-v2/slice-2024-01-06.zarr closed\n", + "2026-10-29 16:20:22,853 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-07.zarr\n", + "2026-10-29 16:20:22,862 INFO Updating target dataset outputs/v2_example_time_opt.zarr\n", + "2026-10-29 16:20:25,878 INFO Transaction completed.\n", + "2026-10-29 16:20:25,878 INFO Slice dataset inputs/zarr-v2/slice-2024-01-07.zarr closed\n", + "2026-10-29 16:20:25,892 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-08.zarr\n", + "2026-10-29 16:20:25,904 INFO Updating target dataset outputs/v2_example_time_opt.zarr\n", + "2026-10-29 16:20:28,621 INFO Transaction completed.\n", + "2026-10-29 16:20:28,621 INFO Slice dataset inputs/zarr-v2/slice-2024-01-08.zarr closed\n", + "2026-10-29 16:20:28,650 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-09.zarr\n", + "2026-10-29 16:20:28,659 INFO Updating target dataset outputs/v2_example_time_opt.zarr\n", + "2026-10-29 16:20:31,714 INFO Transaction completed.\n", + "2026-10-29 16:20:31,714 INFO Slice dataset inputs/zarr-v2/slice-2024-01-09.zarr closed\n", + "2026-10-29 16:20:31,743 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-10.zarr\n", + "2026-10-29 16:20:31,753 INFO Updating target dataset outputs/v2_example_time_opt.zarr\n", + "2026-10-29 16:20:34,496 INFO Transaction completed.\n", + "2026-10-29 16:20:34,496 INFO Slice dataset inputs/zarr-v2/slice-2024-01-10.zarr closed\n", + "2026-10-29 16:20:34,508 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-11.zarr\n", + "2026-10-29 16:20:34,517 INFO Updating target dataset outputs/v2_example_time_opt.zarr\n", + "2026-10-29 16:20:37,315 INFO Transaction completed.\n", + "2026-10-29 16:20:37,316 INFO Slice dataset inputs/zarr-v2/slice-2024-01-11.zarr closed\n", + "2026-10-29 16:20:37,349 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-12.zarr\n", + "2026-10-29 16:20:37,362 INFO Updating target dataset outputs/v2_example_time_opt.zarr\n", + "2026-10-29 16:20:40,870 INFO Transaction completed.\n", + "2026-10-29 16:20:40,871 INFO Slice dataset inputs/zarr-v2/slice-2024-01-12.zarr closed\n", + "2026-10-29 16:20:40,881 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-13.zarr\n", + "2026-10-29 16:20:40,888 INFO Updating target dataset outputs/v2_example_time_opt.zarr\n", + "2026-10-29 16:20:43,553 INFO Transaction completed.\n", + "2026-10-29 16:20:43,553 INFO Slice dataset inputs/zarr-v2/slice-2024-01-13.zarr closed\n", + "2026-10-29 16:20:43,565 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-14.zarr\n", + "2026-10-29 16:20:43,573 INFO Updating target dataset outputs/v2_example_time_opt.zarr\n", + "2026-10-29 16:20:46,291 INFO Transaction completed.\n", + "2026-10-29 16:20:46,292 INFO Slice dataset inputs/zarr-v2/slice-2024-01-14.zarr closed\n", + "2026-10-29 16:20:46,303 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-15.zarr\n", + "2026-10-29 16:20:46,309 INFO Updating target dataset outputs/v2_example_time_opt.zarr\n", + "2026-10-29 16:20:49,711 INFO Transaction completed.\n", + "2026-10-29 16:20:49,712 INFO Slice dataset inputs/zarr-v2/slice-2024-01-15.zarr closed\n", + "2026-10-29 16:20:49,742 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-16.zarr\n", + "2026-10-29 16:20:49,753 INFO Updating target dataset outputs/v2_example_time_opt.zarr\n", + "2026-10-29 16:20:52,584 INFO Transaction completed.\n", + "2026-10-29 16:20:52,585 INFO Slice dataset inputs/zarr-v2/slice-2024-01-16.zarr closed\n", + "2026-10-29 16:20:52,598 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-17.zarr\n", + "2026-10-29 16:20:52,606 INFO Updating target dataset outputs/v2_example_time_opt.zarr\n", + "2026-10-29 16:20:55,389 INFO Transaction completed.\n", + "2026-10-29 16:20:55,389 INFO Slice dataset inputs/zarr-v2/slice-2024-01-17.zarr closed\n", + "2026-10-29 16:20:55,402 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-18.zarr\n", + "2026-10-29 16:20:55,409 INFO Updating target dataset outputs/v2_example_time_opt.zarr\n", + "2026-10-29 16:20:58,754 INFO Transaction completed.\n", + "2026-10-29 16:20:58,755 INFO Slice dataset inputs/zarr-v2/slice-2024-01-18.zarr closed\n", + "2026-10-29 16:20:58,768 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-19.zarr\n", + "2026-10-29 16:20:58,778 INFO Updating target dataset outputs/v2_example_time_opt.zarr\n", + "2026-10-29 16:21:01,445 INFO Transaction completed.\n", + "2026-10-29 16:21:01,445 INFO Slice dataset inputs/zarr-v2/slice-2024-01-19.zarr closed\n", + "2026-10-29 16:21:01,460 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-20.zarr\n", + "2026-10-29 16:21:01,467 INFO Updating target dataset outputs/v2_example_time_opt.zarr\n", + "2026-10-29 16:21:04,923 INFO Transaction completed.\n", + "2026-10-29 16:21:04,924 INFO Slice dataset inputs/zarr-v2/slice-2024-01-20.zarr closed\n", + "2026-10-29 16:21:04,939 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-21.zarr\n", + "2026-10-29 16:21:04,949 INFO Updating target dataset outputs/v2_example_time_opt.zarr\n", + "2026-10-29 16:21:07,730 INFO Transaction completed.\n", + "2026-10-29 16:21:07,730 INFO Slice dataset inputs/zarr-v2/slice-2024-01-21.zarr closed\n", + "2026-10-29 16:21:07,763 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-22.zarr\n", + "2026-10-29 16:21:07,771 INFO Updating target dataset outputs/v2_example_time_opt.zarr\n", + "2026-10-29 16:21:10,526 INFO Transaction completed.\n", + "2026-10-29 16:21:10,526 INFO Slice dataset inputs/zarr-v2/slice-2024-01-22.zarr closed\n", + "2026-10-29 16:21:10,541 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-23.zarr\n", + "2026-10-29 16:21:10,550 INFO Updating target dataset outputs/v2_example_time_opt.zarr\n", + "2026-10-29 16:21:13,303 INFO Transaction completed.\n", + "2026-10-29 16:21:13,303 INFO Slice dataset inputs/zarr-v2/slice-2024-01-23.zarr closed\n", + "2026-10-29 16:21:13,318 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-24.zarr\n", + "2026-10-29 16:21:13,326 INFO Updating target dataset outputs/v2_example_time_opt.zarr\n", + "2026-10-29 16:21:16,290 INFO Transaction completed.\n", + "2026-10-29 16:21:16,291 INFO Slice dataset inputs/zarr-v2/slice-2024-01-24.zarr closed\n", + "2026-10-29 16:21:16,306 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-25.zarr\n", + "2026-10-29 16:21:16,316 INFO Updating target dataset outputs/v2_example_time_opt.zarr\n", + "2026-10-29 16:21:19,152 INFO Transaction completed.\n", + "2026-10-29 16:21:19,153 INFO Slice dataset inputs/zarr-v2/slice-2024-01-25.zarr closed\n", + "2026-10-29 16:21:19,171 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-26.zarr\n", + "2026-10-29 16:21:19,180 INFO Updating target dataset outputs/v2_example_time_opt.zarr\n", + "2026-10-29 16:21:21,890 INFO Transaction completed.\n", + "2026-10-29 16:21:21,891 INFO Slice dataset inputs/zarr-v2/slice-2024-01-26.zarr closed\n", + "2026-10-29 16:21:21,906 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-27.zarr\n", + "2026-10-29 16:21:21,915 INFO Updating target dataset outputs/v2_example_time_opt.zarr\n", + "2026-10-29 16:21:24,704 INFO Transaction completed.\n", + "2026-10-29 16:21:24,705 INFO Slice dataset inputs/zarr-v2/slice-2024-01-27.zarr closed\n", + "2026-10-29 16:21:24,740 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-28.zarr\n", + "2026-10-29 16:21:24,748 INFO Updating target dataset outputs/v2_example_time_opt.zarr\n", + "2026-10-29 16:21:27,583 INFO Transaction completed.\n", + "2026-10-29 16:21:27,584 INFO Slice dataset inputs/zarr-v2/slice-2024-01-28.zarr closed\n", + "2026-10-29 16:21:27,616 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-29.zarr\n", + "2026-10-29 16:21:27,625 INFO Updating target dataset outputs/v2_example_time_opt.zarr\n", + "2026-10-29 16:21:30,217 INFO Transaction completed.\n", + "2026-10-29 16:21:30,218 INFO Slice dataset inputs/zarr-v2/slice-2024-01-29.zarr closed\n", + "2026-10-29 16:21:30,233 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-30.zarr\n", + "2026-10-29 16:21:30,242 INFO Updating target dataset outputs/v2_example_time_opt.zarr\n", + "2026-10-29 16:21:33,511 INFO Transaction completed.\n", + "2026-10-29 16:21:33,511 INFO Slice dataset inputs/zarr-v2/slice-2024-01-30.zarr closed\n", + "2026-10-29 16:21:33,547 INFO Opening slice dataset from inputs/zarr-v2/slice-2024-01-31.zarr\n", + "2026-10-29 16:21:33,555 INFO Updating target dataset outputs/v2_example_time_opt.zarr\n", + "2026-10-29 16:21:36,317 INFO Transaction completed.\n", + "2026-10-29 16:21:36,318 INFO Slice dataset inputs/zarr-v2/slice-2024-01-31.zarr closed\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 1min 54s, sys: 27.8 s, total: 2min 22s\n", + "Wall time: 1min 29s\n" + ] + } + ], + "source": [ + "%%time\n", + "full_time_chunk = len(slices)\n", + "target = f\"{output_dir}/v2_example_time_opt.zarr\"\n", + "count = zappend(\n", + " slices,\n", + " target_dir=target,\n", + " force_new=True,\n", + " variables={\n", + " 'temperature': {'encoding': {'chunks': [full_time_chunk, 90, 90]}},\n", + " 'quality_flag': {'encoding': {'chunks': [full_time_chunk, 90, 90]}},\n", + " },\n", + " logging=\"INFO\",\n", + ")\n", + "assert count == full_time_chunk" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "a19cf31cf39d8fcd", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T15:21:36.395316376Z", + "start_time": "2026-10-29T15:21:36.349748699Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 18.3 ms, sys: 3.11 ms, total: 21.4 ms\n", + "Wall time: 17 ms\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 1GB\n",
+       "Dimensions:       (time: 31, lat: 1800, lon: 3600)\n",
+       "Coordinates:\n",
+       "  * time          (time) datetime64[ns] 248B 2024-01-01 ... 2024-01-31\n",
+       "  * lat           (lat) float32 7kB -89.95 -89.85 -89.75 ... 89.75 89.85 89.95\n",
+       "  * lon           (lon) float32 14kB -179.9 -179.9 -179.8 ... 179.7 179.8 179.9\n",
+       "Data variables:\n",
+       "    quality_flag  (time, lat, lon) uint8 201MB dask.array<chunksize=(31, 90, 90), meta=np.ndarray>\n",
+       "    temperature   (time, lat, lon) float32 804MB dask.array<chunksize=(31, 90, 90), meta=np.ndarray>\n",
+       "Attributes:\n",
+       "    title:    Zappend example slice
" + ], + "text/plain": [ + " Size: 1GB\n", + "Dimensions: (time: 31, lat: 1800, lon: 3600)\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 248B 2024-01-01 ... 2024-01-31\n", + " * lat (lat) float32 7kB -89.95 -89.85 -89.75 ... 89.75 89.85 89.95\n", + " * lon (lon) float32 14kB -179.9 -179.9 -179.8 ... 179.7 179.8 179.9\n", + "Data variables:\n", + " quality_flag (time, lat, lon) uint8 201MB dask.array\n", + " temperature (time, lat, lon) float32 804MB dask.array\n", + "Attributes:\n", + " title: Zappend example slice" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "ds = xr.open_zarr(target)\n", + "ds" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f06f95f0785803ef", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:48:36.874776334Z", + "start_time": "2026-10-29T16:48:36.802364670Z" + } + }, + "outputs": [], + "source": [ + "if os.path.exists(input_dir):\n", + " shutil.rmtree(input_dir)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python (zappend)", + "language": "python", + "name": "zappend" + }, + "language_info": { + "name": "python", + "version": "3.14" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/zarr_v3.ipynb b/examples/zarr_v3.ipynb new file mode 100644 index 0000000..d23d5b0 --- /dev/null +++ b/examples/zarr_v3.ipynb @@ -0,0 +1,2307 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1e0571ba39c71e74", + "metadata": {}, + "source": [ + "# Appending sharded Zarr v3 slices\n", + "\n", + "This is the Zarr v3 counterpart of `zarr_v2.ipynb`. It generates 31 daily v3 inputs and creates two v3 targets: one for spatial access and one with a full-month time chunk for time-series access." + ] + }, + { + "cell_type": "markdown", + "id": "5e41d36aa7597afb", + "metadata": {}, + "source": [ + "## Inner chunks and outer shards\n", + "\n", + "Zarr v3 shards group several inner chunks into one storage object. The inner chunk shape controls the data read for a selection; the shard shape controls the object stored and updated. Each shard size must be a multiple of its matching chunk size." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "bf3353b04ca98a19", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:49:16.529374854Z", + "start_time": "2026-10-29T16:49:15.741780807Z" + } + }, + "outputs": [], + "source": [ + "import os\n", + "import shutil\n", + "from pathlib import Path\n", + "\n", + "import xarray as xr\n", + "from create_inputs import make_zarr_v3_slices\n", + "\n", + "from zappend.api import zappend" + ] + }, + { + "cell_type": "markdown", + "id": "64c11cb250b260ad", + "metadata": {}, + "source": [ + "## Generate and collect the input slices\n", + "\n", + "The generator uses exactly the same synthetic data as the v2 notebook. Only the input storage format changes: the data variables are written as Zarr v3 arrays with 450 by 450 inner chunks and 1800 by 3600 spatial shards." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8104609c62195087", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T15:39:07.880984482Z", + "start_time": "2026-10-29T15:39:04.904282551Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 4.29 s, sys: 339 ms, total: 4.63 s\n", + "Wall time: 2.96 s\n" + ] + } + ], + "source": [ + "%%time\n", + "make_zarr_v3_slices(31)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "65eb3ccb869f5b1b", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:49:16.567009957Z", + "start_time": "2026-10-29T16:49:16.530877674Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['inputs/zarr-v3/slice-2024-01-01.zarr',\n", + " 'inputs/zarr-v3/slice-2024-01-02.zarr',\n", + " 'inputs/zarr-v3/slice-2024-01-03.zarr']" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "input_dir = Path('inputs/zarr-v3')\n", + "output_dir = Path('outputs')\n", + "output_dir.mkdir(exist_ok=True)\n", + "slices = sorted(str(path) for path in input_dir.glob('*.zarr'))\n", + "assert len(slices) == 31\n", + "slices[:3]" + ] + }, + { + "cell_type": "markdown", + "id": "3b5c97ebfca3c8dd", + "metadata": {}, + "source": [ + "## Default v3 layout: favor spatial access\n", + "\n", + "The first call sets `zarr_version=3` and otherwise retains the first slice's encoding, including its shard layout. It is appropriate when accessing a day or a map is more common than reading a complete point time series." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e0b76f1a95090c55", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T15:39:13.318391725Z", + "start_time": "2026-10-29T15:39:07.936444561Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-10-29 16:39:07,968 WARNING Setting 'force_new' is enabled. This will permanently delete existing targets (no rollback).\n", + "2026-10-29 16:39:07,969 WARNING Permanently deleting outputs/v3_example_space_opt.zarr\n", + "2026-10-29 16:39:07,979 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-01.zarr\n", + "2026-10-29 16:39:07,995 INFO Creating target dataset outputs/v3_example_space_opt.zarr\n", + "2026-10-29 16:39:08,140 INFO Transaction completed.\n", + "2026-10-29 16:39:08,141 INFO Slice dataset inputs/zarr-v3/slice-2024-01-01.zarr closed\n", + "2026-10-29 16:39:08,151 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-02.zarr\n", + "2026-10-29 16:39:08,161 INFO Updating target dataset outputs/v3_example_space_opt.zarr\n", + "2026-10-29 16:39:08,311 INFO Transaction completed.\n", + "2026-10-29 16:39:08,312 INFO Slice dataset inputs/zarr-v3/slice-2024-01-02.zarr closed\n", + "2026-10-29 16:39:08,321 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-03.zarr\n", + "2026-10-29 16:39:08,332 INFO Updating target dataset outputs/v3_example_space_opt.zarr\n", + "2026-10-29 16:39:08,608 INFO Transaction completed.\n", + "2026-10-29 16:39:08,609 INFO Slice dataset inputs/zarr-v3/slice-2024-01-03.zarr closed\n", + "2026-10-29 16:39:08,621 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-04.zarr\n", + "2026-10-29 16:39:08,633 INFO Updating target dataset outputs/v3_example_space_opt.zarr\n", + "2026-10-29 16:39:08,783 INFO Transaction completed.\n", + "2026-10-29 16:39:08,783 INFO Slice dataset inputs/zarr-v3/slice-2024-01-04.zarr closed\n", + "2026-10-29 16:39:08,811 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-05.zarr\n", + "2026-10-29 16:39:08,823 INFO Updating target dataset outputs/v3_example_space_opt.zarr\n", + "2026-10-29 16:39:08,953 INFO Transaction completed.\n", + "2026-10-29 16:39:08,954 INFO Slice dataset inputs/zarr-v3/slice-2024-01-05.zarr closed\n", + "2026-10-29 16:39:08,983 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-06.zarr\n", + "2026-10-29 16:39:08,995 INFO Updating target dataset outputs/v3_example_space_opt.zarr\n", + "2026-10-29 16:39:09,128 INFO Transaction completed.\n", + "2026-10-29 16:39:09,129 INFO Slice dataset inputs/zarr-v3/slice-2024-01-06.zarr closed\n", + "2026-10-29 16:39:09,158 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-07.zarr\n", + "2026-10-29 16:39:09,169 INFO Updating target dataset outputs/v3_example_space_opt.zarr\n", + "2026-10-29 16:39:09,310 INFO Transaction completed.\n", + "2026-10-29 16:39:09,311 INFO Slice dataset inputs/zarr-v3/slice-2024-01-07.zarr closed\n", + "2026-10-29 16:39:09,341 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-08.zarr\n", + "2026-10-29 16:39:09,351 INFO Updating target dataset outputs/v3_example_space_opt.zarr\n", + "2026-10-29 16:39:09,486 INFO Transaction completed.\n", + "2026-10-29 16:39:09,487 INFO Slice dataset inputs/zarr-v3/slice-2024-01-08.zarr closed\n", + "2026-10-29 16:39:09,500 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-09.zarr\n", + "2026-10-29 16:39:09,510 INFO Updating target dataset outputs/v3_example_space_opt.zarr\n", + "2026-10-29 16:39:09,648 INFO Transaction completed.\n", + "2026-10-29 16:39:09,648 INFO Slice dataset inputs/zarr-v3/slice-2024-01-09.zarr closed\n", + "2026-10-29 16:39:09,661 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-10.zarr\n", + "2026-10-29 16:39:09,670 INFO Updating target dataset outputs/v3_example_space_opt.zarr\n", + "2026-10-29 16:39:09,809 INFO Transaction completed.\n", + "2026-10-29 16:39:09,809 INFO Slice dataset inputs/zarr-v3/slice-2024-01-10.zarr closed\n", + "2026-10-29 16:39:09,822 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-11.zarr\n", + "2026-10-29 16:39:09,832 INFO Updating target dataset outputs/v3_example_space_opt.zarr\n", + "2026-10-29 16:39:09,971 INFO Transaction completed.\n", + "2026-10-29 16:39:09,971 INFO Slice dataset inputs/zarr-v3/slice-2024-01-11.zarr closed\n", + "2026-10-29 16:39:09,986 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-12.zarr\n", + "2026-10-29 16:39:09,997 INFO Updating target dataset outputs/v3_example_space_opt.zarr\n", + "2026-10-29 16:39:10,140 INFO Transaction completed.\n", + "2026-10-29 16:39:10,140 INFO Slice dataset inputs/zarr-v3/slice-2024-01-12.zarr closed\n", + "2026-10-29 16:39:10,154 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-13.zarr\n", + "2026-10-29 16:39:10,164 INFO Updating target dataset outputs/v3_example_space_opt.zarr\n", + "2026-10-29 16:39:10,297 INFO Transaction completed.\n", + "2026-10-29 16:39:10,297 INFO Slice dataset inputs/zarr-v3/slice-2024-01-13.zarr closed\n", + "2026-10-29 16:39:10,310 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-14.zarr\n", + "2026-10-29 16:39:10,320 INFO Updating target dataset outputs/v3_example_space_opt.zarr\n", + "2026-10-29 16:39:10,457 INFO Transaction completed.\n", + "2026-10-29 16:39:10,457 INFO Slice dataset inputs/zarr-v3/slice-2024-01-14.zarr closed\n", + "2026-10-29 16:39:10,471 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-15.zarr\n", + "2026-10-29 16:39:10,483 INFO Updating target dataset outputs/v3_example_space_opt.zarr\n", + "2026-10-29 16:39:10,627 INFO Transaction completed.\n", + "2026-10-29 16:39:10,627 INFO Slice dataset inputs/zarr-v3/slice-2024-01-15.zarr closed\n", + "2026-10-29 16:39:10,641 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-16.zarr\n", + "2026-10-29 16:39:10,652 INFO Updating target dataset outputs/v3_example_space_opt.zarr\n", + "2026-10-29 16:39:10,803 INFO Transaction completed.\n", + "2026-10-29 16:39:10,803 INFO Slice dataset inputs/zarr-v3/slice-2024-01-16.zarr closed\n", + "2026-10-29 16:39:10,818 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-17.zarr\n", + "2026-10-29 16:39:10,828 INFO Updating target dataset outputs/v3_example_space_opt.zarr\n", + "2026-10-29 16:39:10,966 INFO Transaction completed.\n", + "2026-10-29 16:39:10,967 INFO Slice dataset inputs/zarr-v3/slice-2024-01-17.zarr closed\n", + "2026-10-29 16:39:10,984 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-18.zarr\n", + "2026-10-29 16:39:10,995 INFO Updating target dataset outputs/v3_example_space_opt.zarr\n", + "2026-10-29 16:39:11,132 INFO Transaction completed.\n", + "2026-10-29 16:39:11,133 INFO Slice dataset inputs/zarr-v3/slice-2024-01-18.zarr closed\n", + "2026-10-29 16:39:11,147 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-19.zarr\n", + "2026-10-29 16:39:11,158 INFO Updating target dataset outputs/v3_example_space_opt.zarr\n", + "2026-10-29 16:39:11,295 INFO Transaction completed.\n", + "2026-10-29 16:39:11,295 INFO Slice dataset inputs/zarr-v3/slice-2024-01-19.zarr closed\n", + "2026-10-29 16:39:11,310 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-20.zarr\n", + "2026-10-29 16:39:11,320 INFO Updating target dataset outputs/v3_example_space_opt.zarr\n", + "2026-10-29 16:39:11,454 INFO Transaction completed.\n", + "2026-10-29 16:39:11,454 INFO Slice dataset inputs/zarr-v3/slice-2024-01-20.zarr closed\n", + "2026-10-29 16:39:11,469 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-21.zarr\n", + "2026-10-29 16:39:11,479 INFO Updating target dataset outputs/v3_example_space_opt.zarr\n", + "2026-10-29 16:39:11,622 INFO Transaction completed.\n", + "2026-10-29 16:39:11,622 INFO Slice dataset inputs/zarr-v3/slice-2024-01-21.zarr closed\n", + "2026-10-29 16:39:11,638 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-22.zarr\n", + "2026-10-29 16:39:11,648 INFO Updating target dataset outputs/v3_example_space_opt.zarr\n", + "2026-10-29 16:39:11,786 INFO Transaction completed.\n", + "2026-10-29 16:39:11,786 INFO Slice dataset inputs/zarr-v3/slice-2024-01-22.zarr closed\n", + "2026-10-29 16:39:11,801 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-23.zarr\n", + "2026-10-29 16:39:11,812 INFO Updating target dataset outputs/v3_example_space_opt.zarr\n", + "2026-10-29 16:39:11,940 INFO Transaction completed.\n", + "2026-10-29 16:39:11,941 INFO Slice dataset inputs/zarr-v3/slice-2024-01-23.zarr closed\n", + "2026-10-29 16:39:11,955 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-24.zarr\n", + "2026-10-29 16:39:11,965 INFO Updating target dataset outputs/v3_example_space_opt.zarr\n", + "2026-10-29 16:39:12,105 INFO Transaction completed.\n", + "2026-10-29 16:39:12,105 INFO Slice dataset inputs/zarr-v3/slice-2024-01-24.zarr closed\n", + "2026-10-29 16:39:12,121 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-25.zarr\n", + "2026-10-29 16:39:12,130 INFO Updating target dataset outputs/v3_example_space_opt.zarr\n", + "2026-10-29 16:39:12,265 INFO Transaction completed.\n", + "2026-10-29 16:39:12,266 INFO Slice dataset inputs/zarr-v3/slice-2024-01-25.zarr closed\n", + "2026-10-29 16:39:12,282 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-26.zarr\n", + "2026-10-29 16:39:12,293 INFO Updating target dataset outputs/v3_example_space_opt.zarr\n", + "2026-10-29 16:39:12,429 INFO Transaction completed.\n", + "2026-10-29 16:39:12,429 INFO Slice dataset inputs/zarr-v3/slice-2024-01-26.zarr closed\n", + "2026-10-29 16:39:12,463 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-27.zarr\n", + "2026-10-29 16:39:12,474 INFO Updating target dataset outputs/v3_example_space_opt.zarr\n", + "2026-10-29 16:39:12,611 INFO Transaction completed.\n", + "2026-10-29 16:39:12,611 INFO Slice dataset inputs/zarr-v3/slice-2024-01-27.zarr closed\n", + "2026-10-29 16:39:12,628 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-28.zarr\n", + "2026-10-29 16:39:12,638 INFO Updating target dataset outputs/v3_example_space_opt.zarr\n", + "2026-10-29 16:39:12,771 INFO Transaction completed.\n", + "2026-10-29 16:39:12,772 INFO Slice dataset inputs/zarr-v3/slice-2024-01-28.zarr closed\n", + "2026-10-29 16:39:12,789 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-29.zarr\n", + "2026-10-29 16:39:12,799 INFO Updating target dataset outputs/v3_example_space_opt.zarr\n", + "2026-10-29 16:39:12,935 INFO Transaction completed.\n", + "2026-10-29 16:39:12,935 INFO Slice dataset inputs/zarr-v3/slice-2024-01-29.zarr closed\n", + "2026-10-29 16:39:12,953 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-30.zarr\n", + "2026-10-29 16:39:12,963 INFO Updating target dataset outputs/v3_example_space_opt.zarr\n", + "2026-10-29 16:39:13,110 INFO Transaction completed.\n", + "2026-10-29 16:39:13,111 INFO Slice dataset inputs/zarr-v3/slice-2024-01-30.zarr closed\n", + "2026-10-29 16:39:13,128 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-31.zarr\n", + "2026-10-29 16:39:13,139 INFO Updating target dataset outputs/v3_example_space_opt.zarr\n", + "2026-10-29 16:39:13,301 INFO Transaction completed.\n", + "2026-10-29 16:39:13,301 INFO Slice dataset inputs/zarr-v3/slice-2024-01-31.zarr closed\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 6.96 s, sys: 862 ms, total: 7.82 s\n", + "Wall time: 5.36 s\n" + ] + } + ], + "source": [ + "%%time\n", + "target = output_dir / 'v3_example_space_opt.zarr'\n", + "count = zappend(\n", + " slices,\n", + " target_dir=str(target),\n", + " zarr_version=3,\n", + " force_new=True,\n", + " logging='INFO',\n", + ")\n", + "assert count == len(slices)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "1f6d036c7f5ef3d2", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T15:39:50.951622461Z", + "start_time": "2026-10-29T15:39:50.867767194Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 21.4 ms, sys: 4.17 ms, total: 25.6 ms\n", + "Wall time: 21.1 ms\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 1GB\n",
+       "Dimensions:       (time: 31, lat: 1800, lon: 3600)\n",
+       "Coordinates:\n",
+       "  * time          (time) datetime64[ns] 248B 2024-01-01 ... 2024-01-31\n",
+       "  * lat           (lat) float32 7kB -89.95 -89.85 -89.75 ... 89.75 89.85 89.95\n",
+       "  * lon           (lon) float32 14kB -179.9 -179.9 -179.8 ... 179.7 179.8 179.9\n",
+       "Data variables:\n",
+       "    temperature   (time, lat, lon) float32 804MB dask.array<chunksize=(1, 450, 450), meta=np.ndarray>\n",
+       "    quality_flag  (time, lat, lon) uint8 201MB dask.array<chunksize=(1, 450, 450), meta=np.ndarray>\n",
+       "Attributes:\n",
+       "    title:    Zappend example slice
" + ], + "text/plain": [ + " Size: 1GB\n", + "Dimensions: (time: 31, lat: 1800, lon: 3600)\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 248B 2024-01-01 ... 2024-01-31\n", + " * lat (lat) float32 7kB -89.95 -89.85 -89.75 ... 89.75 89.85 89.95\n", + " * lon (lon) float32 14kB -179.9 -179.9 -179.8 ... 179.7 179.8 179.9\n", + "Data variables:\n", + " temperature (time, lat, lon) float32 804MB dask.array\n", + " quality_flag (time, lat, lon) uint8 201MB dask.array\n", + "Attributes:\n", + " title: Zappend example slice" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "ds = xr.open_zarr(target, consolidated=False)\n", + "ds" + ] + }, + { + "cell_type": "markdown", + "id": "722a50ce5ac51fea", + "metadata": {}, + "source": [ + "## Sharded time-series layout\n", + "\n", + "The second target has `(31, 90, 90)` inner chunks, so one chunk contains a full monthly point time series. The `(31, 450, 450)` shards hold 25 spatial inner chunks in each spatial direction. This reduces the number of stored objects while preserving small inner chunks for selections. For a continuing stream, choose a planned time horizon; existing Zarr chunks and shards cannot grow." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "75ba66a201197c6d", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T15:41:52.228522389Z", + "start_time": "2026-10-29T15:41:13.821517033Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-10-29 16:41:13,855 WARNING Setting 'force_new' is enabled. This will permanently delete existing targets (no rollback).\n", + "2026-10-29 16:41:13,857 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-01.zarr\n", + "2026-10-29 16:41:13,868 INFO Creating target dataset outputs/v3_example_time_opt.zarr\n", + "2026-10-29 16:41:14,741 INFO Transaction completed.\n", + "2026-10-29 16:41:14,742 INFO Slice dataset inputs/zarr-v3/slice-2024-01-01.zarr closed\n", + "2026-10-29 16:41:14,752 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-02.zarr\n", + "2026-10-29 16:41:14,781 INFO Updating target dataset outputs/v3_example_time_opt.zarr\n", + "2026-10-29 16:41:15,991 INFO Transaction completed.\n", + "2026-10-29 16:41:15,991 INFO Slice dataset inputs/zarr-v3/slice-2024-01-02.zarr closed\n", + "2026-10-29 16:41:16,023 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-03.zarr\n", + "2026-10-29 16:41:16,044 INFO Updating target dataset outputs/v3_example_time_opt.zarr\n", + "2026-10-29 16:41:17,316 INFO Transaction completed.\n", + "2026-10-29 16:41:17,317 INFO Slice dataset inputs/zarr-v3/slice-2024-01-03.zarr closed\n", + "2026-10-29 16:41:17,328 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-04.zarr\n", + "2026-10-29 16:41:17,339 INFO Updating target dataset outputs/v3_example_time_opt.zarr\n", + "2026-10-29 16:41:18,517 INFO Transaction completed.\n", + "2026-10-29 16:41:18,518 INFO Slice dataset inputs/zarr-v3/slice-2024-01-04.zarr closed\n", + "2026-10-29 16:41:18,546 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-05.zarr\n", + "2026-10-29 16:41:18,559 INFO Updating target dataset outputs/v3_example_time_opt.zarr\n", + "2026-10-29 16:41:19,799 INFO Transaction completed.\n", + "2026-10-29 16:41:19,800 INFO Slice dataset inputs/zarr-v3/slice-2024-01-05.zarr closed\n", + "2026-10-29 16:41:19,827 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-06.zarr\n", + "2026-10-29 16:41:19,838 INFO Updating target dataset outputs/v3_example_time_opt.zarr\n", + "2026-10-29 16:41:20,941 INFO Transaction completed.\n", + "2026-10-29 16:41:20,941 INFO Slice dataset inputs/zarr-v3/slice-2024-01-06.zarr closed\n", + "2026-10-29 16:41:20,968 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-07.zarr\n", + "2026-10-29 16:41:20,979 INFO Updating target dataset outputs/v3_example_time_opt.zarr\n", + "2026-10-29 16:41:22,215 INFO Transaction completed.\n", + "2026-10-29 16:41:22,216 INFO Slice dataset inputs/zarr-v3/slice-2024-01-07.zarr closed\n", + "2026-10-29 16:41:22,228 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-08.zarr\n", + "2026-10-29 16:41:22,239 INFO Updating target dataset outputs/v3_example_time_opt.zarr\n", + "2026-10-29 16:41:23,376 INFO Transaction completed.\n", + "2026-10-29 16:41:23,376 INFO Slice dataset inputs/zarr-v3/slice-2024-01-08.zarr closed\n", + "2026-10-29 16:41:23,388 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-09.zarr\n", + "2026-10-29 16:41:23,398 INFO Updating target dataset outputs/v3_example_time_opt.zarr\n", + "2026-10-29 16:41:24,665 INFO Transaction completed.\n", + "2026-10-29 16:41:24,666 INFO Slice dataset inputs/zarr-v3/slice-2024-01-09.zarr closed\n", + "2026-10-29 16:41:24,678 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-10.zarr\n", + "2026-10-29 16:41:24,689 INFO Updating target dataset outputs/v3_example_time_opt.zarr\n", + "2026-10-29 16:41:25,866 INFO Transaction completed.\n", + "2026-10-29 16:41:25,867 INFO Slice dataset inputs/zarr-v3/slice-2024-01-10.zarr closed\n", + "2026-10-29 16:41:25,878 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-11.zarr\n", + "2026-10-29 16:41:25,888 INFO Updating target dataset outputs/v3_example_time_opt.zarr\n", + "2026-10-29 16:41:27,138 INFO Transaction completed.\n", + "2026-10-29 16:41:27,139 INFO Slice dataset inputs/zarr-v3/slice-2024-01-11.zarr closed\n", + "2026-10-29 16:41:27,167 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-12.zarr\n", + "2026-10-29 16:41:27,179 INFO Updating target dataset outputs/v3_example_time_opt.zarr\n", + "2026-10-29 16:41:28,327 INFO Transaction completed.\n", + "2026-10-29 16:41:28,327 INFO Slice dataset inputs/zarr-v3/slice-2024-01-12.zarr closed\n", + "2026-10-29 16:41:28,356 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-13.zarr\n", + "2026-10-29 16:41:28,366 INFO Updating target dataset outputs/v3_example_time_opt.zarr\n", + "2026-10-29 16:41:29,578 INFO Transaction completed.\n", + "2026-10-29 16:41:29,578 INFO Slice dataset inputs/zarr-v3/slice-2024-01-13.zarr closed\n", + "2026-10-29 16:41:29,608 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-14.zarr\n", + "2026-10-29 16:41:29,619 INFO Updating target dataset outputs/v3_example_time_opt.zarr\n", + "2026-10-29 16:41:30,711 INFO Transaction completed.\n", + "2026-10-29 16:41:30,712 INFO Slice dataset inputs/zarr-v3/slice-2024-01-14.zarr closed\n", + "2026-10-29 16:41:30,724 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-15.zarr\n", + "2026-10-29 16:41:30,735 INFO Updating target dataset outputs/v3_example_time_opt.zarr\n", + "2026-10-29 16:41:31,941 INFO Transaction completed.\n", + "2026-10-29 16:41:31,941 INFO Slice dataset inputs/zarr-v3/slice-2024-01-15.zarr closed\n", + "2026-10-29 16:41:31,968 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-16.zarr\n", + "2026-10-29 16:41:31,979 INFO Updating target dataset outputs/v3_example_time_opt.zarr\n", + "2026-10-29 16:41:33,061 INFO Transaction completed.\n", + "2026-10-29 16:41:33,062 INFO Slice dataset inputs/zarr-v3/slice-2024-01-16.zarr closed\n", + "2026-10-29 16:41:33,073 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-17.zarr\n", + "2026-10-29 16:41:33,083 INFO Updating target dataset outputs/v3_example_time_opt.zarr\n", + "2026-10-29 16:41:34,299 INFO Transaction completed.\n", + "2026-10-29 16:41:34,300 INFO Slice dataset inputs/zarr-v3/slice-2024-01-17.zarr closed\n", + "2026-10-29 16:41:34,331 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-18.zarr\n", + "2026-10-29 16:41:34,343 INFO Updating target dataset outputs/v3_example_time_opt.zarr\n", + "2026-10-29 16:41:35,453 INFO Transaction completed.\n", + "2026-10-29 16:41:35,453 INFO Slice dataset inputs/zarr-v3/slice-2024-01-18.zarr closed\n", + "2026-10-29 16:41:35,482 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-19.zarr\n", + "2026-10-29 16:41:35,493 INFO Updating target dataset outputs/v3_example_time_opt.zarr\n", + "2026-10-29 16:41:36,697 INFO Transaction completed.\n", + "2026-10-29 16:41:36,698 INFO Slice dataset inputs/zarr-v3/slice-2024-01-19.zarr closed\n", + "2026-10-29 16:41:36,726 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-20.zarr\n", + "2026-10-29 16:41:36,738 INFO Updating target dataset outputs/v3_example_time_opt.zarr\n", + "2026-10-29 16:41:37,845 INFO Transaction completed.\n", + "2026-10-29 16:41:37,845 INFO Slice dataset inputs/zarr-v3/slice-2024-01-20.zarr closed\n", + "2026-10-29 16:41:37,873 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-21.zarr\n", + "2026-10-29 16:41:37,884 INFO Updating target dataset outputs/v3_example_time_opt.zarr\n", + "2026-10-29 16:41:39,094 INFO Transaction completed.\n", + "2026-10-29 16:41:39,094 INFO Slice dataset inputs/zarr-v3/slice-2024-01-21.zarr closed\n", + "2026-10-29 16:41:39,105 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-22.zarr\n", + "2026-10-29 16:41:39,116 INFO Updating target dataset outputs/v3_example_time_opt.zarr\n", + "2026-10-29 16:41:40,237 INFO Transaction completed.\n", + "2026-10-29 16:41:40,238 INFO Slice dataset inputs/zarr-v3/slice-2024-01-22.zarr closed\n", + "2026-10-29 16:41:40,267 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-23.zarr\n", + "2026-10-29 16:41:40,278 INFO Updating target dataset outputs/v3_example_time_opt.zarr\n", + "2026-10-29 16:41:41,482 INFO Transaction completed.\n", + "2026-10-29 16:41:41,483 INFO Slice dataset inputs/zarr-v3/slice-2024-01-23.zarr closed\n", + "2026-10-29 16:41:41,511 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-24.zarr\n", + "2026-10-29 16:41:41,523 INFO Updating target dataset outputs/v3_example_time_opt.zarr\n", + "2026-10-29 16:41:42,816 INFO Transaction completed.\n", + "2026-10-29 16:41:42,817 INFO Slice dataset inputs/zarr-v3/slice-2024-01-24.zarr closed\n", + "2026-10-29 16:41:42,829 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-25.zarr\n", + "2026-10-29 16:41:42,840 INFO Updating target dataset outputs/v3_example_time_opt.zarr\n", + "2026-10-29 16:41:44,121 INFO Transaction completed.\n", + "2026-10-29 16:41:44,121 INFO Slice dataset inputs/zarr-v3/slice-2024-01-25.zarr closed\n", + "2026-10-29 16:41:44,133 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-26.zarr\n", + "2026-10-29 16:41:44,145 INFO Updating target dataset outputs/v3_example_time_opt.zarr\n", + "2026-10-29 16:41:45,291 INFO Transaction completed.\n", + "2026-10-29 16:41:45,292 INFO Slice dataset inputs/zarr-v3/slice-2024-01-26.zarr closed\n", + "2026-10-29 16:41:45,320 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-27.zarr\n", + "2026-10-29 16:41:45,332 INFO Updating target dataset outputs/v3_example_time_opt.zarr\n", + "2026-10-29 16:41:46,743 INFO Transaction completed.\n", + "2026-10-29 16:41:46,744 INFO Slice dataset inputs/zarr-v3/slice-2024-01-27.zarr closed\n", + "2026-10-29 16:41:46,757 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-28.zarr\n", + "2026-10-29 16:41:46,770 INFO Updating target dataset outputs/v3_example_time_opt.zarr\n", + "2026-10-29 16:41:48,153 INFO Transaction completed.\n", + "2026-10-29 16:41:48,153 INFO Slice dataset inputs/zarr-v3/slice-2024-01-28.zarr closed\n", + "2026-10-29 16:41:48,165 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-29.zarr\n", + "2026-10-29 16:41:48,175 INFO Updating target dataset outputs/v3_example_time_opt.zarr\n", + "2026-10-29 16:41:49,611 INFO Transaction completed.\n", + "2026-10-29 16:41:49,611 INFO Slice dataset inputs/zarr-v3/slice-2024-01-29.zarr closed\n", + "2026-10-29 16:41:49,631 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-30.zarr\n", + "2026-10-29 16:41:49,645 INFO Updating target dataset outputs/v3_example_time_opt.zarr\n", + "2026-10-29 16:41:50,794 INFO Transaction completed.\n", + "2026-10-29 16:41:50,795 INFO Slice dataset inputs/zarr-v3/slice-2024-01-30.zarr closed\n", + "2026-10-29 16:41:50,823 INFO Opening slice dataset from inputs/zarr-v3/slice-2024-01-31.zarr\n", + "2026-10-29 16:41:50,842 INFO Updating target dataset outputs/v3_example_time_opt.zarr\n", + "2026-10-29 16:41:52,216 INFO Transaction completed.\n", + "2026-10-29 16:41:52,217 INFO Slice dataset inputs/zarr-v3/slice-2024-01-31.zarr closed\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 1min 32s, sys: 6.84 s, total: 1min 39s\n", + "Wall time: 38.4 s\n" + ] + } + ], + "source": [ + "%%time\n", + "full_time_chunk = len(slices)\n", + "chunks = [full_time_chunk, 90, 90]\n", + "shards = [full_time_chunk, 450, 450]\n", + "target = output_dir / 'v3_example_time_opt.zarr'\n", + "\n", + "count = zappend(\n", + " slices,\n", + " target_dir=str(target),\n", + " zarr_version=3,\n", + " force_new=True,\n", + " variables={\n", + " 'temperature': {'encoding': {'chunks': chunks, 'shards': shards}},\n", + " 'quality_flag': {'encoding': {'chunks': chunks, 'shards': shards}},\n", + " 'time': {\n", + " 'encoding': {'chunks': [full_time_chunk], 'shards': [full_time_chunk]}\n", + " },\n", + " },\n", + " logging='INFO',\n", + ")\n", + "assert count == full_time_chunk" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "686c76040f6b2ea9", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T15:42:05.307945623Z", + "start_time": "2026-10-29T15:42:05.258625089Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 16.9 ms, sys: 126 μs, total: 17 ms\n", + "Wall time: 14.6 ms\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 1GB\n",
+       "Dimensions:       (time: 31, lat: 1800, lon: 3600)\n",
+       "Coordinates:\n",
+       "  * time          (time) datetime64[ns] 248B 2024-01-01 ... 2024-01-31\n",
+       "  * lat           (lat) float32 7kB -89.95 -89.85 -89.75 ... 89.75 89.85 89.95\n",
+       "  * lon           (lon) float32 14kB -179.9 -179.9 -179.8 ... 179.7 179.8 179.9\n",
+       "Data variables:\n",
+       "    quality_flag  (time, lat, lon) uint8 201MB dask.array<chunksize=(31, 90, 90), meta=np.ndarray>\n",
+       "    temperature   (time, lat, lon) float32 804MB dask.array<chunksize=(31, 90, 90), meta=np.ndarray>\n",
+       "Attributes:\n",
+       "    title:    Zappend example slice
" + ], + "text/plain": [ + " Size: 1GB\n", + "Dimensions: (time: 31, lat: 1800, lon: 3600)\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 248B 2024-01-01 ... 2024-01-31\n", + " * lat (lat) float32 7kB -89.95 -89.85 -89.75 ... 89.75 89.85 89.95\n", + " * lon (lon) float32 14kB -179.9 -179.9 -179.8 ... 179.7 179.8 179.9\n", + "Data variables:\n", + " quality_flag (time, lat, lon) uint8 201MB dask.array\n", + " temperature (time, lat, lon) float32 804MB dask.array\n", + "Attributes:\n", + " title: Zappend example slice" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "ds = xr.open_zarr(target, consolidated=False)\n", + "ds" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d98bd327967ff8b4", + "metadata": { + "ExecuteTime": { + "end_time": "2026-10-29T16:49:19.890894799Z", + "start_time": "2026-10-29T16:49:19.852680348Z" + } + }, + "outputs": [], + "source": [ + "if os.path.exists(input_dir):\n", + " shutil.rmtree(input_dir)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python (zappend)", + "language": "python", + "name": "zappend" + }, + "language_info": { + "name": "python", + "version": "3.14" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pyproject.toml b/pyproject.toml index 0c07c97..67a1f3c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -27,8 +27,8 @@ dependencies = [ "numcodecs", "numpy", "pyyaml", - "xarray <2026.4", # constrain to <2026.4 to retain compatibility with zarr 2. - "zarr >=2,<3" + "xarray <2026.4", + "zarr >=3,<4" ] [tool.setuptools.dynamic] diff --git a/tests/config/__init__.py b/tests/config/__init__.py index 072757f..e700455 100644 --- a/tests/config/__init__.py +++ b/tests/config/__init__.py @@ -1,4 +1,3 @@ # Copyright © 2024-2026 Brockmann Consult and contributors # Permissions are hereby granted under the terms of the MIT License: # https://opensource.org/licenses/MIT. - diff --git a/tests/config/test_validate.py b/tests/config/test_validate.py index d39be9f..91321bd 100644 --- a/tests/config/test_validate.py +++ b/tests/config/test_validate.py @@ -23,10 +23,21 @@ def test_validate_versions_fail(self): config = {"zarr_version": 1} with pytest.raises( ValueError, - match="Invalid configuration: 2 was expected for zarr_version", + match="Invalid configuration: 1 is not one of \\[2, 3\\] for zarr_version", ): validate_config(config) + def test_validate_zarr_v3_ok(self): + config = {"zarr_version": 3} + self.assertIs(config, validate_config(config)) + + def test_validate_shards(self): + config = { + "zarr_version": 3, + "variables": {"v": {"encoding": {"shards": [2, 4]}}}, + } + self.assertIs(config, validate_config(config)) + # noinspection PyMethodMayBeStatic def test_validate_variable_fail(self): config = { diff --git a/tests/fsutil/test_transaction.py b/tests/fsutil/test_transaction.py index 61ee45c..edc33b0 100644 --- a/tests/fsutil/test_transaction.py +++ b/tests/fsutil/test_transaction.py @@ -214,6 +214,50 @@ def _delete(): self.assertEqual(True, delete_called) self.assertTrue(transaction.lock_file.exists()) + def test_restores_file_from_create_action(self): + test_root = FileObj("memory://test") + test_root.mkdir() + transaction = Transaction(test_root, FileObj("memory://temp")) + transaction.rollback_dir.mkdir() + (transaction.rollback_dir / "backup").write(b"original") + + transaction._create_file("restored.txt", "backup") + + self.assertEqual(b"original", (test_root / "restored.txt").read()) + + def test_renames_file_during_rollback(self): + test_root = FileObj("memory://test") + test_root.mkdir() + source = test_root / "new.txt" + target = test_root / "old.txt" + source.write(b"data") + transaction = Transaction(test_root, FileObj("memory://temp")) + + transaction._rename_file(source.filename, target.filename) + + self.assertFalse(source.exists()) + self.assertEqual(b"data", target.read()) + + def test_rollback_continues_after_a_new_file_was_not_written(self): + test_root = FileObj("memory://test") + test_root.mkdir() + metadata_file = test_root / "metadata" + metadata_file.write(b"before") + + with ( + pytest.raises(ValueError, match="simulated write failure"), + Transaction(test_root, FileObj("memory://temp")) as rollback_cb, + ): + rollback_cb("replace_file", "metadata", b"before") + metadata_file.write(b"changed") + # A failed asynchronous write may have recorded this action + # but never created the file. + rollback_cb("delete_file", "chunk-not-written", None) + raise ValueError("simulated write failure") + + self.assertEqual(b"before", metadata_file.read()) + self.assertFalse((test_root / "chunk-not-written").exists()) + # noinspection PyMethodMayBeStatic def test_it_raises_on_illegal_callback_calls(self): test_root = FileObj("memory://test") @@ -270,8 +314,8 @@ def test_it_raises_on_illegal_callback_calls(self): pytest.raises( ValueError, match="Value of 'action' argument must be one of" - " 'delete_dir'," - " 'delete_file', 'replace_file'," + " 'create_file', 'delete_dir'," + " 'delete_file', 'rename_file', 'replace_file'," " but was 'replace_ifle'", ), Transaction(test_root, rollback_dir) as callback, diff --git a/tests/helpers.py b/tests/helpers.py index e8ff75a..117ddd2 100644 --- a/tests/helpers.py +++ b/tests/helpers.py @@ -138,7 +138,7 @@ def make_test_dataset( if fs.exists(path): fs.rm(path, recursive=True) ds.to_zarr( - uri, storage_options=storage_options, zarr_version=2, write_empty_chunks=False + uri, storage_options=storage_options, zarr_format=2, write_empty_chunks=False ) return xr.open_zarr(uri, storage_options=storage_options) diff --git a/tests/slice/__init__.py b/tests/slice/__init__.py index 072757f..e700455 100644 --- a/tests/slice/__init__.py +++ b/tests/slice/__init__.py @@ -1,4 +1,3 @@ # Copyright © 2024-2026 Brockmann Consult and contributors # Permissions are hereby granted under the terms of the MIT License: # https://opensource.org/licenses/MIT. - diff --git a/tests/test_cli.py b/tests/test_cli.py index 9f61b78..90b1e8c 100644 --- a/tests/test_cli.py +++ b/tests/test_cli.py @@ -2,8 +2,10 @@ # Permissions are hereby granted under the terms of the MIT License: # https://opensource.org/licenses/MIT. +import runpy import unittest +import pytest from click.testing import CliRunner from zappend import __version__ @@ -24,6 +26,14 @@ def test_version(self): self.assertEqual(0, result.exit_code) self.assertEqual(f"{__version__}\n", result.output) + def test_module_entry_point(self): + with pytest.MonkeyPatch.context() as monkeypatch: + monkeypatch.setattr("sys.argv", ["zappend", "--version"]) + with pytest.raises(SystemExit) as error: + runpy.run_module("zappend.cli", run_name="__main__") + + self.assertEqual(0, error.value.code) + def test_help(self): runner = CliRunner() # noinspection PyTypeChecker diff --git a/tests/test_metadata.py b/tests/test_metadata.py index 3818bd2..d944c16 100644 --- a/tests/test_metadata.py +++ b/tests/test_metadata.py @@ -88,6 +88,44 @@ def test_it_raises_on_wrong_size_found_in_ds(self): class DatasetMetadataVariablesTest(unittest.TestCase): + def test_it_rejects_shards_for_zarr_v2(self): + dataset = xr.Dataset({"a": xr.DataArray(np.zeros((2, 3)), dims=("time", "x"))}) + with pytest.raises(ValueError, match="supported only for Zarr version 3"): + DatasetMetadata.from_dataset( + dataset, + make_config({"variables": {"a": {"encoding": {"shards": [2, 3]}}}}), + ) + + def test_it_validates_zarr_v3_shards(self): + dataset = xr.Dataset({"a": xr.DataArray(np.zeros((2, 3)), dims=("time", "x"))}) + + metadata = DatasetMetadata.from_dataset( + dataset, + make_config( + { + "zarr_version": 3, + "variables": {"a": {"encoding": {"shards": [2, 3]}}}, + } + ), + ) + self.assertEqual((2, 3), metadata.variables["a"].encoding.shards) + + for encoding, message in [ + ({"shards": [2]}, "Wrong number of shard sizes"), + ({"chunks": [1], "shards": [2, 3]}, "Wrong number of chunk sizes"), + ({"chunks": [1, 2], "shards": [1, 3]}, "must be multiples"), + ]: + with ( + self.subTest(encoding=encoding), + pytest.raises(ValueError, match=message), + ): + DatasetMetadata.from_dataset( + dataset, + make_config( + {"zarr_version": 3, "variables": {"a": {"encoding": encoding}}} + ), + ) + def test_add_missing_variables(self): self.assertEqual( { diff --git a/tests/test_rollbackstore.py b/tests/test_rollbackstore.py index fc5b599..bf6ac2f 100644 --- a/tests/test_rollbackstore.py +++ b/tests/test_rollbackstore.py @@ -2,302 +2,65 @@ # Permissions are hereby granted under the terms of the MIT License: # https://opensource.org/licenses/MIT. -import copy +import asyncio import unittest -import pytest -import xarray as xr -import zarr.storage +from zarr.core.buffer import default_buffer_prototype +from zarr.storage import MemoryStore -from zappend.fsutil.fileobj import FileObj from zappend.rollbackstore import RollbackStore -from .helpers import clear_memory_fs, make_test_dataset - -class RollbackStoreImplTest(unittest.TestCase): - def setUp(self): - self.mem_store = zarr.storage.MemoryStore() - self.rb_records = [] - self.rb_store = RollbackStore(self.mem_store, self.add_rb_record) - - def add_rb_record(self, *args): - self.rb_records.append(args) - - def test_getitem(self): - with pytest.raises(KeyError): - # noinspection PyUnusedLocal - _v1 = self.rb_store["k1"] - self.assertIsNone(self.rb_store.get("k1")) - self.mem_store["k1"] = b"v1" - self.assertEqual(b"v1", self.rb_store["k1"]) - self.assertEqual(b"v1", self.rb_store.get("k1")) - - def test_setitem(self): - self.rb_store["k1"] = b"v1" - self.assertEqual(b"v1", self.rb_store["k1"]) - self.assertEqual(b"v1", self.rb_store.get("k1")) - self.assertEqual(b"v1", self.mem_store["k1"]) - self.rb_store["k1"] = b"v2" - self.assertEqual(b"v2", self.rb_store["k1"]) - self.assertEqual(b"v2", self.rb_store.get("k1")) - self.assertEqual(b"v2", self.mem_store["k1"]) - self.assertEqual( - [("delete_file", "k1", None), ("replace_file", "k1", b"v1")], - self.rb_records, - ) - - def test_delitem(self): - with pytest.raises(KeyError): - del self.rb_store["k1"] - self.rb_store["k1"] = b"v1" - del self.rb_store["k1"] - with pytest.raises(KeyError): - del self.rb_store["k1"] - self.rb_store["k1"] = b"v1" - v1 = self.rb_store.pop("k1") - self.assertEqual(b"v1", v1) - self.assertNotIn("k1", self.rb_store) - self.assertEqual( - [ - ("delete_file", "k1", None), - ("create_file", "k1", b"v1"), - ("delete_file", "k1", None), - ("create_file", "k1", b"v1"), - ], - self.rb_records, - ) - - def test_contains(self): - self.assertFalse("k1" in self.rb_store) - self.rb_store["k1"] = b"v1" - self.assertTrue("k1" in self.rb_store) - - def test_len(self): - self.assertEqual(0, len(self.rb_store)) - self.rb_store["k1"] = b"v1" - self.assertEqual(1, len(self.rb_store)) - self.rb_store["k2"] = b"v2" - self.assertEqual(2, len(self.rb_store)) - self.rb_store["k2"] = b"v3" - self.assertEqual(2, len(self.rb_store)) - - def test_iter(self): - self.rb_store["k1"] = b"v1" - self.rb_store["k2"] = b"v2" - self.assertEqual({"k1", "k2"}, set(iter(self.rb_store))) - - def test_eq(self): - self.rb_store["k1"] = b"v1" - self.rb_store["k2"] = b"v2" - self.assertTrue(self.rb_store == self.rb_store) - self.assertFalse(self.rb_store == {}) - self.assertFalse(self.rb_store == {"k1": b"v1", "k2": b"v2"}) - self.assertTrue(self.rb_store == copy.copy(self.rb_store)) - - def test_rename(self): - self.rb_store["k1"] = b"v1" - self.rb_store.rename("k1", "k2") - self.assertEqual(b"v1", self.rb_store.get("k2")) - self.assertEqual( - [("delete_file", "k1", None), ("rename_file", "k2", "k1")], self.rb_records - ) - - def test_close(self): - # Just a smoke test, we have no criteria whether this was successful - self.rb_store.close() - - def test_rmdir(self): - self.rb_store["a/k1"] = b"v1" - self.rb_store["a/k2"] = b"v2" - self.rb_store.rmdir("a") - self.assertFalse("a/k1" in self.rb_store) - self.assertFalse("a/k2" in self.rb_store) - self.assertEqual(0, len(self.rb_store)) - self.assertEqual( - [ - ("delete_file", "a/k1", None), - ("delete_file", "a/k2", None), - ("delete_dir", "a"), - ], - self.rb_records, - ) - - -class RollbackStoreZarrTest(unittest.TestCase): - target_dir = FileObj("memory://target.zarr") - - def setUp(self): - clear_memory_fs() - self.records = [] - - def handle_rollback_action(self, *args): - self.records.append(args) - - def test_to_zarr(self): - ds = make_test_dataset(shape=(1, 50, 100), chunks=(2, 50, 50), crs="epsg:4326") - ds.time.encoding.update(chunks=(10,)) - ds.chl.encoding.update(chunks=(2, 50, 50)) - ds.tsm.encoding.update(chunks=(2, 50, 50)) - # ds.time.encoding.update(chunks=(10,)) - ds.to_zarr( - RollbackStore( - self.target_dir.fs.get_mapper( - root=self.target_dir.path.strip("/"), create=True - ), - self.handle_rollback_action, +class RollbackStoreTest(unittest.TestCase): + def test_records_only_the_initial_value_of_a_changed_key(self): + async def run_test(): + records = [] + store = MemoryStore() + prototype = default_buffer_prototype() + await store.set("existing", prototype.buffer.from_bytes(b"before")) + rollback_store = RollbackStore(store, lambda *args: records.append(args)) + + await rollback_store.set("existing", prototype.buffer.from_bytes(b"one")) + await rollback_store.set("existing", prototype.buffer.from_bytes(b"two")) + await rollback_store.set("new", prototype.buffer.from_bytes(b"new")) + + self.assertEqual( + [ + ("replace_file", "existing", b"before"), + ("delete_file", "new", None), + ], + records, ) - ) - self.assert_dataset_ok( - {"x": 100, "y": 50, "time": 1}, - { - "crs": (), - "x": (100,), - "y": (50,), - "time": (10,), - "chl": (2, 50, 50), - "tsm": (2, 50, 50), - }, - ) - - self.assertEqual( - { - ("delete_file", ".zmetadata"), - ("delete_file", ".zgroup"), - ("delete_file", ".zattrs"), - ("delete_file", "x/.zarray"), - ("delete_file", "x/.zattrs"), - ("delete_file", "x/0"), - ("delete_file", "y/.zarray"), - ("delete_file", "y/.zattrs"), - ("delete_file", "y/0"), - ("delete_file", "time/.zarray"), - ("delete_file", "time/.zattrs"), - ("delete_file", "time/0"), - ("delete_file", "crs/.zarray"), - ("delete_file", "crs/.zattrs"), - ("delete_file", "crs/0"), - ("delete_file", "chl/.zarray"), - ("delete_file", "chl/.zattrs"), - ("delete_file", "chl/0.0.0"), - ("delete_file", "chl/0.0.1"), - ("delete_file", "tsm/.zarray"), - ("delete_file", "tsm/.zattrs"), - ("delete_file", "tsm/0.0.0"), - ("delete_file", "tsm/0.0.1"), - }, - {r[:2] for r in self.records}, - ) - ##################################################################### - # Add slice 1 + asyncio.run(run_test()) - self.records = [] - slice_1 = make_test_dataset(shape=(1, 50, 100), chunks=(1, 50, 50)) - # drop variables w.o. "time" dim - slice_1 = slice_1.drop_vars( - [k for k, v in slice_1.variables.items() if "time" not in v.sizes] - ) - slice_1.attrs = {} - for v in slice_1.variables.values(): - v.encoding = {} - v.attrs = {} + def test_records_batch_sets_and_deletions(self): + async def run_test(): + records = [] + store = MemoryStore() + prototype = default_buffer_prototype() + await store.set("existing", prototype.buffer.from_bytes(b"before")) + await store.set("dir/a", prototype.buffer.from_bytes(b"a")) + await store.set("dir/b", prototype.buffer.from_bytes(b"b")) + rollback_store = RollbackStore(store, lambda *args: records.append(args)) - slice_1.to_zarr( - RollbackStore( - self.target_dir.fs.get_mapper( - root=self.target_dir.path.strip("/"), create=False - ), - self.handle_rollback_action, - ), - mode="a", - append_dim="time", - ) - self.assert_dataset_ok( - {"x": 100, "y": 50, "time": 2}, - { - "crs": (), - "x": (100,), - "y": (50,), - "time": (10,), - "chl": (2, 50, 50), - "tsm": (2, 50, 50), - }, - ) - self.assertEqual( - { - ("replace_file", ".zmetadata"), - ("replace_file", ".zattrs"), - ("replace_file", "time/.zarray"), - ("replace_file", "time/0"), - ("replace_file", "chl/.zarray"), - ("replace_file", "chl/0.0.0"), - ("replace_file", "chl/0.0.1"), - ("replace_file", "tsm/.zarray"), - ("replace_file", "tsm/0.0.0"), - ("replace_file", "tsm/0.0.1"), - }, - {r[:2] for r in self.records}, - ) - - ##################################################################### - # Add slice 2 - - self.records = [] - slice_2 = make_test_dataset(shape=(1, 50, 100), chunks=(1, 50, 50)) - # drop variables w.o. "time" dim - slice_2 = slice_2.drop_vars( - [k for k, v in slice_2.variables.items() if "time" not in v.sizes] - ) - for v in slice_2.variables.values(): - v.encoding = {} - v.attrs = {} - - slice_2.to_zarr( - RollbackStore( - self.target_dir.fs.get_mapper( - root=self.target_dir.path.strip("/"), create=False - ), - self.handle_rollback_action, - ), - mode="a", - append_dim="time", - ) - self.assert_dataset_ok( - {"x": 100, "y": 50, "time": 3}, - { - "crs": (), - "x": (100,), - "y": (50,), - "time": (10,), - "chl": (2, 50, 50), - "tsm": (2, 50, 50), - }, - ) - self.assertEqual( - { - ("replace_file", ".zmetadata"), - ("replace_file", ".zattrs"), - ("replace_file", "time/.zarray"), - ("replace_file", "time/0"), - ("replace_file", "chl/.zarray"), - ("delete_file", "chl/1.0.0"), - ("delete_file", "chl/1.0.1"), - ("replace_file", "tsm/.zarray"), - ("delete_file", "tsm/1.0.0"), - ("delete_file", "tsm/1.0.1"), - }, - {r[:2] for r in self.records}, - ) + await rollback_store.set_if_not_exists( + "existing", prototype.buffer.from_bytes(b"ignored") + ) + await rollback_store._set_many( + [("batch", prototype.buffer.from_bytes(b"batch"))] + ) + await rollback_store.delete("existing") + await rollback_store.delete_dir("dir") + + self.assertEqual( + [ + ("replace_file", "existing", b"before"), + ("delete_file", "batch", None), + ("replace_file", "dir/a", b"a"), + ("replace_file", "dir/b", b"b"), + ], + records, + ) - def assert_dataset_ok( - self, - expected_sizes: dict[str, int], - expected_chunks: dict[str, tuple[int, ...]], - ): - ds = xr.open_zarr(self.target_dir.uri) - self.assertEqual(expected_sizes, ds.sizes) - self.assertEqual( - expected_chunks, - {k: ds[k].encoding.get("chunks") for k in ds.variables}, - ) + asyncio.run(run_test()) diff --git a/tests/test_tailoring.py b/tests/test_tailoring.py index a842ce6..85715b3 100644 --- a/tests/test_tailoring.py +++ b/tests/test_tailoring.py @@ -17,7 +17,7 @@ def make_context(config: dict, target_ds: xr.Dataset, write: bool = False) -> Context: target_dir = "memory://target.zarr" if write: - target_ds.to_zarr(target_dir, mode="w") + target_ds.to_zarr(target_dir, mode="w", zarr_format=2) ctx = Context({"target_dir": target_dir, **config}) ctx.target_metadata = ctx.get_dataset_metadata(target_ds) return ctx diff --git a/tests/test_xrencoding.py b/tests/test_xrencoding.py index b2fc7c0..db3849e 100644 --- a/tests/test_xrencoding.py +++ b/tests/test_xrencoding.py @@ -43,6 +43,14 @@ def setUp(self): clear_memory_fs() self.assertFalse(FileObj(TEST_ZARR).exists()) + self._dataset_to_zarr = xr.Dataset.to_zarr + + def to_zarr_v2(dataset, *args, **kwargs): + kwargs.setdefault("zarr_format", 2) + return self._dataset_to_zarr(dataset, *args, **kwargs) + + xr.Dataset.to_zarr = to_zarr_v2 + self.ds = xr.Dataset( data_vars={"v": xr.DataArray(np.ones(100, dtype=np.float64), dims="x")}, coords={ @@ -80,6 +88,9 @@ def setUp(self): }, ) + def tearDown(self): + xr.Dataset.to_zarr = self._dataset_to_zarr + def test_no_encoding_given(self): self.ds.to_zarr(TEST_ZARR) self.assertEqual(self.ds_v_attrs, get_v_attrs()) diff --git a/tests/test_zarrv3.py b/tests/test_zarrv3.py new file mode 100644 index 0000000..5df89bf --- /dev/null +++ b/tests/test_zarrv3.py @@ -0,0 +1,59 @@ +# Copyright © 2024-2026 Brockmann Consult and contributors +# Permissions are hereby granted under the terms of the MIT License: +# https://opensource.org/licenses/MIT. + +import unittest +from tempfile import TemporaryDirectory + +import xarray as xr +import zarr + +from zappend.api import zappend + +from .helpers import clear_memory_fs, make_test_dataset + + +class ZarrV3Test(unittest.TestCase): + def setUp(self): + clear_memory_fs() + + def test_append_sharded_v3_target(self): + target_dir = "memory://target.zarr" + slices = [ + make_test_dataset(shape=(1, 10, 20), chunks=(1, 5, 10)), + make_test_dataset(shape=(1, 10, 20), chunks=(1, 5, 10)), + ] + + zappend( + slices, + target_dir=target_dir, + zarr_version=3, + variables={ + "chl": {"encoding": {"chunks": [1, 5, 10], "shards": [2, 10, 20]}}, + "tsm": {"encoding": {"chunks": [1, 5, 10], "shards": [2, 10, 20]}}, + }, + ) + + with xr.open_zarr(target_dir, zarr_format=3, consolidated=False) as dataset: + self.assertEqual({"time": 2, "y": 10, "x": 20}, dataset.sizes) + + group = zarr.open_group(target_dir, zarr_format=3) + self.assertTrue( + any( + type(codec).__name__ == "ShardingCodec" + for codec in group["chl"].metadata.codecs + ) + ) + + def test_append_v3_target_on_local_filesystem(self): + with TemporaryDirectory() as temp_dir: + target_dir = f"{temp_dir}/target.zarr" + slices = [ + make_test_dataset(shape=(1, 2, 3), chunks=(1, 1, 1), index=0), + make_test_dataset(shape=(1, 2, 3), chunks=(1, 1, 1), index=1), + ] + + zappend(slices, target_dir=target_dir, zarr_version=3) + + with xr.open_zarr(target_dir, zarr_format=3, consolidated=False) as dataset: + self.assertEqual({"time": 2, "y": 2, "x": 3}, dataset.sizes) diff --git a/zappend/config/schema.py b/zappend/config/schema.py index c358f16..e714460 100644 --- a/zappend/config/schema.py +++ b/zappend/config/schema.py @@ -94,6 +94,14 @@ {"description": "Disable chunking in all dimensions.", "const": None}, ], }, + "shards": { + "description": ( + "Zarr v3 shard sizes for each dimension of the variable. " + "Each shard size must be a multiple of the corresponding chunk size." + ), + "type": "array", + "items": {"type": "integer", "minimum": 1}, + }, "fill_value": { "description": "Storage fill value.", "oneOf": [ @@ -603,7 +611,7 @@ "zarr_version": { "category": "Target Outline", "description": "The Zarr version to be used.", - "const": DEFAULT_ZARR_VERSION, + "enum": [2, 3], "default": DEFAULT_ZARR_VERSION, }, "target_dir": { diff --git a/zappend/context.py b/zappend/context.py index b4be151..b771383 100644 --- a/zappend/context.py +++ b/zappend/context.py @@ -27,6 +27,8 @@ def __init__(self, config: dict[str, Any] | Config): with xr.open_zarr( _config.target_dir.uri, storage_options=_config.target_dir.storage_options, + zarr_format=_config.zarr_version, + consolidated=_config.zarr_version == 2, ) as target_dataset: if _config.append_step is not None: append_var = target_dataset.get(_config.append_dim) diff --git a/zappend/fsutil/transaction.py b/zappend/fsutil/transaction.py index ce2dbec..ec4f595 100644 --- a/zappend/fsutil/transaction.py +++ b/zappend/fsutil/transaction.py @@ -9,7 +9,9 @@ from zappend.fsutil.fileobj import FileObj from zappend.log import logger -RollbackAction = Literal["delete_dir", "delete_file", "replace_file"] +RollbackAction = Literal[ + "create_file", "delete_dir", "delete_file", "rename_file", "replace_file" +] RollbackCallback = Callable[ [ @@ -24,7 +26,13 @@ ROLLBACK_FILE = "__rollback__.txt" ROLLBACK_CSV_SEP = ";" -ROLLBACK_ACTIONS = "delete_dir", "delete_file", "replace_file" +ROLLBACK_ACTIONS = ( + "create_file", + "delete_dir", + "delete_file", + "rename_file", + "replace_file", +) class Transaction: @@ -151,7 +159,9 @@ def __exit__(self, exc_type, exc_val, exc_tb): if rollback_records: logger.info(f"Rolling back {len(rollback_records)} action(s)") - for record in rollback_records: + # Undo the most recent mutation first. This matters when a + # transaction changes related paths more than once. + for record in reversed(rollback_records): logger.debug(f"Running rollback {record}") action = record[0] args = record[1:] @@ -175,7 +185,22 @@ def _delete_dir(self, target_path): def _delete_file(self, target_path): _file = self._target_dir / target_path - _file.delete() + # A rollback action is recorded before a Zarr store write. With + # asynchronous stores, another Dask task can fail before that write + # creates its key. Deleting a missing prospective file is therefore + # a successful rollback no-op, not a rollback failure. + if _file.exists(): + _file.delete() + + def _create_file(self, target_path, rollback_filename): + _file = self._target_dir / target_path + data = (self._rollback_dir / rollback_filename).read() + _file.write(data) + + def _rename_file(self, target_path, rollback_target_path): + target_file = self._target_dir / target_path + rollback_file = self._target_dir / rollback_target_path + target_file.fs.mv(target_file.path, rollback_file.path) def _replace_file(self, target_path, rollback_filename): _file = self._target_dir / target_path @@ -200,7 +225,7 @@ def _add_rollback_action( raise TypeError( f"Type of 'path' argument must be {str}, but was {type(path)}" ) - if action == "replace_file": + if action in ("create_file", "replace_file"): if not isinstance(data, bytes): raise TypeError( f"Type of 'data' argument must be {bytes}, but was {type(data)}" diff --git a/zappend/metadata.py b/zappend/metadata.py index df57480..a289463 100644 --- a/zappend/metadata.py +++ b/zappend/metadata.py @@ -40,6 +40,7 @@ def __init__( self, dtype: np.dtype | Undefined = UNDEFINED, chunks: tuple[int] | None | Undefined = UNDEFINED, + shards: tuple[int, ...] | Undefined = UNDEFINED, fill_value: float | None | Undefined = UNDEFINED, scale_factor: float | Undefined = UNDEFINED, add_offset: float | Undefined = UNDEFINED, @@ -51,6 +52,7 @@ def __init__( ): self.dtype = dtype self.chunks = chunks + self.shards = shards self.fill_value = fill_value self.scale_factor = scale_factor self.add_offset = add_offset @@ -64,7 +66,7 @@ def __init__( ", ".join(unknown_settings.keys()), ) - def to_dict(self): + def to_dict(self, zarr_version: int = 2): """Convert this object into a dictionary. Includes attributes with value `None`, but excludes attributes with value `UNDEFINED`. @@ -76,6 +78,12 @@ def to_dict(self): } if "fill_value" in d: d["_FillValue"] = d.pop("fill_value") + if zarr_version == 3: + # Zarr v3 uses an ordered codec pipeline instead of v2's + # compressor/filters fields. Xarray cannot safely translate + # arbitrary numcodecs v2 codecs, so let it select v3 defaults. + d.pop("compressor", None) + d.pop("filters", None) return d @@ -218,6 +226,7 @@ def from_dataset(cls, dataset: xr.Dataset, config: Config): config.included_variables, config.excluded_variables, config.variables, + config.zarr_version, ) attrs = merge_configs(dataset.attrs, config.attrs) @@ -256,6 +265,7 @@ def _get_effective_variables( config_included_variables: list[str] | None, config_excluded_variables: list[str] | None, config_variables: dict[str, dict[str, Any]] | None, + zarr_version: int, ) -> dict[str, VariableMetadata]: config_variables = dict(config_variables or {}) # Get and remove defaults for all variables @@ -348,6 +358,42 @@ def _get_effective_variables( if "chunks" not in encoding: encoding["chunks"] = chunk_sizes + if encoding.get("shards") is not None: + if zarr_version != 3: + raise ValueError( + f"Variable {var_name!r} configures 'shards', " + "which is supported only for Zarr version 3" + ) + encoding["shards"] = _normalize_chunks(encoding["shards"]) + + shards = encoding["shards"] + assert shards is not None + if len(shards) != len(dims): + raise ValueError( + f"Wrong number of shard sizes for variable {var_name!r}: " + f"expected {len(dims)}, found {len(shards)}" + ) + chunks = encoding.get("chunks") + if chunks is None: + chunks = shape + if len(chunks) != len(dims): + raise ValueError( + f"Wrong number of chunk sizes for variable {var_name!r}: " + f"expected {len(dims)}, found {len(chunks)}" + ) + if any( + shard < chunk or shard % chunk for shard, chunk in zip(shards, chunks) + ): + raise ValueError( + f"Shard sizes for variable {var_name!r} must be multiples " + "of, and no smaller than, chunk sizes" + ) + else: + # Xarray running with Zarr-Python v3 reports ``shards: None`` for + # unsharded source arrays, including Zarr v2 targets. It is not a + # request to write shards and must not leak into v2 encoding. + encoding.pop("shards", None) + # Handle case where a chunk size in None to indicate # dimension is not chunked. # See https://github.com/bcdev/zappend/issues/77 @@ -411,6 +457,7 @@ def _normalize_codec(value: Any) -> Codec: _ENCODING_PROPS: dict[str, Callable[[Any], Any]] = { "dtype": _normalize_dtype, "chunks": _normalize_chunks, + "shards": _normalize_chunks, "fill_value": _normalize_number, "_FillValue": _normalize_number, "scale_factor": _normalize_number, diff --git a/zappend/processor.py b/zappend/processor.py index d230064..87dcd0c 100644 --- a/zappend/processor.py +++ b/zappend/processor.py @@ -8,8 +8,7 @@ import numpy as np import xarray as xr -import zarr.attrs -import zarr.convenience +import zarr from .config import ( Config, @@ -25,7 +24,7 @@ from .fsutil.transaction import RollbackCallback, Transaction from .log import configure_logging, logger from .profiler import Profiler -from .rollbackstore import RollbackStore +from .rollbackstore import make_rollback_store, make_zarr_store from .slice import SliceItem, open_slice_dataset from .tailoring import tailor_slice_dataset, tailor_target_dataset @@ -151,9 +150,9 @@ def create_target_from_slice( target_ds.to_zarr( store=target_dir.uri, storage_options=target_dir.storage_options, - zarr_version=ctx.config.zarr_version, + zarr_format=ctx.config.zarr_version, write_empty_chunks=False, - consolidated=True, + consolidated=ctx.config.zarr_version == 2, ) post_create_target(ctx, target_ds) @@ -174,15 +173,16 @@ def update_target_from_slice( if ctx.config.dry_run: return - target_store = RollbackStore( + target_store = make_rollback_store( target_dir.fs.get_mapper(root=target_dir.path), rollback_cb ) slice_ds.to_zarr( store=target_store, write_empty_chunks=False, - consolidated=True, + consolidated=ctx.config.zarr_version == 2, mode="a", append_dim=ctx.config.append_dim, + zarr_format=ctx.config.zarr_version, ) post_update_target(ctx, target_store, slice_ds) @@ -201,10 +201,15 @@ def post_create_target(ctx: Context, target_ds: xr.Dataset): target_store = ctx.config.target_dir.fs.get_mapper( root=ctx.config.target_dir.path ) - resolve_target_attrs(target_store, target_ds, target_attrs) + resolve_target_attrs( + make_zarr_store(target_store), + target_ds, + target_attrs, + ctx.config.zarr_version, + ) -def post_update_target(ctx: Context, target_store: RollbackStore, slice_ds: xr.Dataset): +def post_update_target(ctx: Context, target_store: Any, slice_ds: xr.Dataset): """Post-process the target dataset given by `target_store` that has just been updated by `slice_ds`. @@ -215,22 +220,30 @@ def post_update_target(ctx: Context, target_store: RollbackStore, slice_ds: xr.D """ target_attrs = slice_ds.attrs if ctx.config.permit_eval and has_dyn_config_attrs(target_attrs): - with xr.open_zarr(target_store) as target_ds: - resolve_target_attrs(target_store, target_ds, target_attrs) + with xr.open_zarr( + target_store, zarr_format=ctx.config.zarr_version + ) as target_ds: + resolve_target_attrs( + target_store, target_ds, target_attrs, ctx.config.zarr_version + ) def resolve_target_attrs( target_store: collections.abc.MutableMapping, target_ds: xr.Dataset, target_attrs: dict[str, Any], + zarr_version: int, ): resolved_attrs = eval_dyn_config_attrs( target_attrs, get_dyn_config_attrs_env(target_ds), ) - zarr.attrs.Attributes(target_store).update(resolved_attrs) - # noinspection PyTypeChecker - zarr.convenience.consolidate_metadata(target_store) + target_group = zarr.open_group( + store=target_store, mode="a", zarr_format=zarr_version + ) + target_group.attrs.update(resolved_attrs) + if zarr_version == 2: + zarr.consolidate_metadata(target_store) def verify_append_labels(ctx: Context, slice_ds: xr.Dataset): diff --git a/zappend/rollbackstore.py b/zappend/rollbackstore.py index 5986916..911ac0b 100644 --- a/zappend/rollbackstore.py +++ b/zappend/rollbackstore.py @@ -2,90 +2,80 @@ # Permissions are hereby granted under the terms of the MIT License: # https://opensource.org/licenses/MIT. -from collections.abc import Mapping, MutableMapping, Sequence -from typing import Any +"""Transactional wrapper for Zarr-Python v3 stores.""" -import zarr.context -import zarr.storage +from collections.abc import MutableMapping -from zappend.fsutil.transaction import RollbackCallback - - -class RollbackStore(zarr.storage.Store): - def __init__(self, store: MutableMapping, rollback_cb: RollbackCallback): - self._store = store - self._rollback_cb = rollback_cb - - def _delegate_call(self, fn_name, *args, **kwargs) -> Any: - if hasattr(self._store, fn_name): - return getattr(self._store, fn_name)(*args, **kwargs) - else: - return getattr(super(), fn_name)(*args, **kwargs) - - ########################################################################### - # collections.abc.Mapping implementations - - def __getitem__(self, key: str): - return self._store[key] +import fsspec.implementations.local +from zarr.abc.store import Store +from zarr.core.buffer import default_buffer_prototype +from zarr.storage import FsspecStore, WrapperStore - def __len__(self): - return len(self._store) +from zappend.fsutil.transaction import RollbackCallback - def __iter__(self): - return iter(self._store) - ########################################################################### - # collections.abc.Mapping overrides +class RollbackStore(WrapperStore[Store]): + """Record each key's pre-transaction bytes before it is changed. - def __contains__(self, key: str): - return key in self._store + This is a Zarr-Python v3 ``Store`` wrapper. The configured Zarr format + (v2 or v3) is intentionally unrelated to this API implementation. + """ - def __eq__(self, other: object): - return self is other or ( - isinstance(other, RollbackStore) - and self._rollback_cb is other._rollback_cb - and self._store == other._store - ) + def __init__(self, store: Store, rollback_cb: RollbackCallback): + super().__init__(store) + self._rollback_cb = rollback_cb + self._recorded_keys: set[str] = set() - ########################################################################### - # collections.abc.MutableMapping implementations + def _with_store(self, store: Store): + return type(self)(store, self._rollback_cb) - def __setitem__(self, key: str, value: bytes): - old_value = self._store.get(key) - self._store[key] = value - if old_value is not None: - self._rollback_cb("replace_file", key, old_value) - else: + async def _record_before_change(self, key: str) -> None: + if key in self._recorded_keys: + return + self._recorded_keys.add(key) + old_value = await self._store.get(key, default_buffer_prototype()) + if old_value is None: self._rollback_cb("delete_file", key, None) - - def __delitem__(self, key: str): - old_value = self._store.get(key) - del self._store[key] - if old_value is not None: - self._rollback_cb("create_file", key, old_value) - - ########################################################################### - # zarr.storage.BaseStore overrides - - # noinspection SpellCheckingInspection - def getitems( - self, keys: Sequence[str], *, contexts: Mapping[str, zarr.context.Context] - ) -> Mapping[str, Any]: - return self._delegate_call("getitems", keys, contexts) - - def rename(self, src_path: str, dst_path: str) -> None: - self._delegate_call("rename", src_path, dst_path) - self._rollback_cb("rename_file", dst_path, src_path) - - def close(self) -> None: - self._delegate_call("close") - - ########################################################################### - # zarr.storage.Store overrides - - def listdir(self, path: str = "") -> list[str]: - return self._delegate_call("listdir", path) - - def rmdir(self, path: str = "") -> None: - self._delegate_call("rmdir", path) - self._rollback_cb("delete_dir", path) + else: + self._rollback_cb("replace_file", key, old_value.to_bytes()) + + async def set(self, key: str, value) -> None: + await self._record_before_change(key) + await self._store.set(key, value) + + async def set_if_not_exists(self, key: str, value) -> None: + await self._record_before_change(key) + await self._store.set_if_not_exists(key, value) + + async def _set_many(self, values) -> None: + # Zarr batches metadata and chunk writes through this method. + values = list(values) + for key, _value in values: + await self._record_before_change(key) + await self._store._set_many(values) + + async def delete(self, key: str) -> None: + await self._record_before_change(key) + await self._store.delete(key) + + async def delete_dir(self, prefix: str) -> None: + keys = [key async for key in self._store.list_prefix(prefix)] + for key in keys: + await self._record_before_change(key) + await self._store.delete_dir(prefix) + + +def make_zarr_store(store: MutableMapping) -> Store: + """Adapt an fsspec mapper to Zarr-Python v3's asynchronous Store API.""" + # Zarr v3 chunk keys are nested paths (for example ``time/c/1``). The + # FsspecStore adapter writes them through LocalFileSystem.pipe_file(), + # which only creates intermediate directories when auto_mkdir is enabled. + # The mapper obtained from FileObj has it disabled by default. + if isinstance(store.fs, fsspec.implementations.local.LocalFileSystem): + store.fs.auto_mkdir = True + return FsspecStore.from_mapper(store) + + +def make_rollback_store(store: MutableMapping, rollback_cb: RollbackCallback): + """Return a transaction-recording wrapper around an fsspec mapper.""" + return RollbackStore(make_zarr_store(store), rollback_cb) diff --git a/zappend/slice/source.py b/zappend/slice/source.py index 67eb055..b07de3c 100644 --- a/zappend/slice/source.py +++ b/zappend/slice/source.py @@ -6,6 +6,7 @@ from abc import ABC, abstractmethod from collections.abc import Callable from contextlib import AbstractContextManager +from typing import TypeAlias import xarray as xr @@ -68,9 +69,10 @@ def dispose(self): """ -SliceItem = ( +SliceItem: TypeAlias = ( str | FileObj | xr.Dataset | AbstractContextManager[xr.Dataset] | SliceSource ) + """The possible types that can represent a slice dataset.""" SliceCallable = type[SliceSource] | Callable[[...], SliceItem] diff --git a/zappend/slice/sources/persistent.py b/zappend/slice/sources/persistent.py index 0c54ff8..9400666 100644 --- a/zappend/slice/sources/persistent.py +++ b/zappend/slice/sources/persistent.py @@ -68,7 +68,11 @@ def _open_slice_dataset(self) -> xr.Dataset: engine = "zarr" if engine == "zarr": storage_options = self._config.slice_storage_options - return xr.open_zarr(self._slice_file.uri, storage_options=storage_options) + return xr.open_zarr( + self._slice_file.uri, + storage_options=storage_options, + consolidated=self._config.zarr_version == 2, + ) fs = self._slice_file.fs if isinstance(fs, fsspec.implementations.local.LocalFileSystem): diff --git a/zappend/slice/sources/temporary.py b/zappend/slice/sources/temporary.py index 4328de5..8cd99fc 100644 --- a/zappend/slice/sources/temporary.py +++ b/zappend/slice/sources/temporary.py @@ -31,15 +31,19 @@ def get_dataset(self) -> xr.Dataset: slice_index = self._slice_index temp_slice_dir = self._config.temp_dir / f"slice-{slice_index}.zarr" self._temp_slice_dir = temp_slice_dir - temp_slice_store = temp_slice_dir.fs.get_mapper( - temp_slice_dir.path, create=True - ) logger.info( f"Persisting in-memory slice dataset #{slice_index} to {temp_slice_dir.uri}" ) - self._slice_ds.to_zarr(temp_slice_store) + self._slice_ds.to_zarr( + temp_slice_dir.uri, + zarr_format=self._config.zarr_version, + ) self._slice_ds = None - self._temp_slice_ds = xr.open_zarr(temp_slice_store) + self._temp_slice_ds = xr.open_zarr( + temp_slice_dir.uri, + zarr_format=self._config.zarr_version, + consolidated=self._config.zarr_version == 2, + ) return self._temp_slice_ds def close(self): diff --git a/zappend/tailoring.py b/zappend/tailoring.py index d2e68c8..ee451a2 100644 --- a/zappend/tailoring.py +++ b/zappend/tailoring.py @@ -17,7 +17,7 @@ def tailor_target_dataset(ctx: Context, slice_ds: xr.Dataset) -> xr.Dataset: attrs = ctx.config.attrs target_ds = _strip_dataset(slice_ds, target_metadata) - target_ds = _complete_dataset(target_ds, target_metadata) + target_ds = _complete_dataset(target_ds, target_metadata, ctx.config.zarr_version) # Set initial dataset attributes if attrs_update_mode == "ignore": @@ -32,7 +32,7 @@ def tailor_target_dataset(ctx: Context, slice_ds: xr.Dataset) -> xr.Dataset: # Set variable encoding and attributes for var_name, var_metadata in target_metadata.variables.items(): variable = target_ds.variables[var_name] - variable.encoding = var_metadata.encoding.to_dict() + variable.encoding = var_metadata.encoding.to_dict(ctx.config.zarr_version) variable.attrs = var_metadata.attrs return target_ds @@ -45,7 +45,7 @@ def tailor_slice_dataset(ctx: Context, slice_ds: xr.Dataset) -> xr.Dataset: attrs = ctx.config.attrs slice_ds = _strip_dataset(slice_ds, target_metadata) - slice_ds = _complete_dataset(slice_ds, target_metadata) + slice_ds = _complete_dataset(slice_ds, target_metadata, ctx.config.zarr_version) const_variables = [ k for k, v in slice_ds.variables.items() if append_dim not in v.dims @@ -91,7 +91,7 @@ def _strip_dataset(dataset: xr.Dataset, target_metadata: DatasetMetadata) -> xr. def _complete_dataset( - dataset: xr.Dataset, target_metadata: DatasetMetadata + dataset: xr.Dataset, target_metadata: DatasetMetadata, zarr_version: int ) -> xr.Dataset: undefined = object() """Chunk existing variables according to chunks in encoding or @@ -99,14 +99,18 @@ def _complete_dataset( """ for var_name, var_metadata in target_metadata.variables.items(): var = dataset.variables.get(var_name) - encoding = var_metadata.encoding.to_dict() + encoding = var_metadata.encoding.to_dict(zarr_version) chunks = encoding.get("chunks", undefined) if var is not None: if chunks is None: # May emit warning for large shapes chunks = var_metadata.shape if chunks is not undefined: - var = var.chunk(chunks=chunks) + # Xarray validates Dask chunks against outer shard boundaries + # for Zarr v3 writes. Rechunk to shards when requested, while + # retaining ``chunks`` as the Zarr array's inner chunk shape. + write_chunks = encoding.get("shards") or chunks + var = var.chunk(chunks=write_chunks) else: logger.warning( f"Variable {var_name!r} not found in slice dataset; creating it."