From 16ed57c91d25f3fd2157650153c4a0e9e2e76923 Mon Sep 17 00:00:00 2001 From: Brendan Collins Date: Wed, 24 Jun 2026 09:49:21 -0700 Subject: [PATCH 1/5] Accept GeoDataFrame input + .xrs accessor with coregister for interpolation (#3480) --- xrspatial/accessor.py | 147 ++++++++++++++++++++++++++++++ xrspatial/interpolate/_idw.py | 13 ++- xrspatial/interpolate/_kriging.py | 13 ++- xrspatial/interpolate/_spline.py | 12 ++- xrspatial/interpolate/_vector.py | 117 ++++++++++++++++++++++++ xrspatial/kde.py | 38 +++++++- 6 files changed, 330 insertions(+), 10 deletions(-) create mode 100644 xrspatial/interpolate/_vector.py diff --git a/xrspatial/accessor.py b/xrspatial/accessor.py index 44a80eb59..9e1273867 100644 --- a/xrspatial/accessor.py +++ b/xrspatial/accessor.py @@ -761,6 +761,56 @@ def _wrap_accessor_attr(accessor, name): return _AccessorTool(attr) +def _check_point_crs_match(src, target): + """Raise if point CRS and caller CRS disagree. + + Both arguments are already-normalized ``pyproj.CRS`` instances (or + ``None``). A ``None`` on either side is a no-op, mirroring how + ``rasterize`` treats a missing CRS. + """ + if src is None or target is None: + return + if not src.equals(target): + def _label(crs): + epsg = crs.to_epsg() + return f"EPSG:{epsg}" if epsg is not None else crs.name + raise ValueError( + f"CRS mismatch: points are in {_label(src)} but the caller is " + f"in {_label(target)}. Pass coregister=True to reproject the " + f"points into the caller CRS." + ) + + +def _interp_on_accessor(obj, func, data, *, coregister, **kwargs): + """Run interpolation *func* against caller raster *obj* as the template. + + *obj* supplies the output grid, chunks, CRS, and attrs (passed as + ``template``). When *data* is a GeoDataFrame and ``coregister=True``, + its geometries are reprojected into the caller's CRS before + interpolation; otherwise a genuine CRS mismatch raises (matching + ``rasterize``'s default). ``coregister`` needs a CRS on both sides. + """ + from xrspatial.interpolate._vector import is_geodataframe + + target = _to_pyproj_crs(obj.attrs.get('crs')) + if is_geodataframe(data): + src = _to_pyproj_crs(data.crs) + if coregister: + if src is None or target is None: + raise ValueError( + "coregister=True needs a CRS on both the points " + "(GeoDataFrame.crs) and the caller (attrs['crs'])" + ) + data = data.to_crs(target) + else: + _check_point_crs_match(src, target) + elif coregister: + raise ValueError( + "coregister=True requires a GeoDataFrame input carrying a CRS" + ) + return func(data, template=obj, **kwargs) + + @xr.register_dataarray_accessor("xrs") class XrsSpatialDataArrayAccessor: """DataArray accessor exposing xarray-spatial operations.""" @@ -1305,6 +1355,53 @@ def rasterize(self, geometries, **kwargs): from .rasterize import rasterize return rasterize(geometries, like=self._obj, **kwargs) + # ---- Interpolation ---- + + def kde(self, points, *, coregister=False, **kwargs): + """Kernel density of *points* onto this DataArray's grid. + + *points* may be a GeoDataFrame (``column`` selects per-point + weights) or raw ``x``/``y`` passed through ``**kwargs``. With + ``coregister=True`` the points are reprojected from their CRS into + this array's CRS first. See :func:`xrspatial.kde`. + """ + from .kde import kde + return _interp_on_accessor(self._obj, kde, points, + coregister=coregister, **kwargs) + + def idw(self, points, *, coregister=False, **kwargs): + """Inverse-distance-weighted interpolation onto this grid. + + See :func:`xrspatial.idw`. ``column`` selects the value to + interpolate from a GeoDataFrame; ``coregister=True`` reprojects the + points into this array's CRS first. + """ + from .interpolate import idw + return _interp_on_accessor(self._obj, idw, points, + coregister=coregister, **kwargs) + + def spline(self, points, *, coregister=False, **kwargs): + """Thin-plate-spline interpolation onto this grid. + + See :func:`xrspatial.spline`. ``column`` selects the value to + interpolate from a GeoDataFrame; ``coregister=True`` reprojects the + points into this array's CRS first. + """ + from .interpolate import spline + return _interp_on_accessor(self._obj, spline, points, + coregister=coregister, **kwargs) + + def kriging(self, points, *, coregister=False, **kwargs): + """Ordinary-kriging interpolation onto this grid. + + See :func:`xrspatial.kriging`. ``column`` selects the value to + interpolate from a GeoDataFrame; ``coregister=True`` reprojects the + points into this array's CRS first. + """ + from .interpolate import kriging + return _interp_on_accessor(self._obj, kriging, points, + coregister=coregister, **kwargs) + # ---- GeoTIFF I/O ---- def to_geotiff(self, path, **kwargs): @@ -1858,6 +1955,56 @@ def rasterize(self, geometries, **kwargs): "to use as rasterize template" ) + # ---- Interpolation ---- + + def _interp_template(self): + """First 2-D y/x variable to use as an interpolation template.""" + ds = self._obj + for var in ds.data_vars: + da = ds[var] + if da.ndim == 2 and 'y' in da.dims and 'x' in da.dims: + return da + raise ValueError( + "Dataset has no 2D variable with 'y' and 'x' dimensions " + "to use as an interpolation template" + ) + + def kde(self, points, *, coregister=False, **kwargs): + """Kernel density of *points* onto a 2-D variable's grid. + + See :meth:`XrsSpatialDataArrayAccessor.kde`. + """ + from .kde import kde + return _interp_on_accessor(self._interp_template(), kde, points, + coregister=coregister, **kwargs) + + def idw(self, points, *, coregister=False, **kwargs): + """Inverse-distance-weighted interpolation onto a 2-D variable's grid. + + See :meth:`XrsSpatialDataArrayAccessor.idw`. + """ + from .interpolate import idw + return _interp_on_accessor(self._interp_template(), idw, points, + coregister=coregister, **kwargs) + + def spline(self, points, *, coregister=False, **kwargs): + """Thin-plate-spline interpolation onto a 2-D variable's grid. + + See :meth:`XrsSpatialDataArrayAccessor.spline`. + """ + from .interpolate import spline + return _interp_on_accessor(self._interp_template(), spline, points, + coregister=coregister, **kwargs) + + def kriging(self, points, *, coregister=False, **kwargs): + """Ordinary-kriging interpolation onto a 2-D variable's grid. + + See :meth:`XrsSpatialDataArrayAccessor.kriging`. + """ + from .interpolate import kriging + return _interp_on_accessor(self._interp_template(), kriging, points, + coregister=coregister, **kwargs) + # ---- GeoTIFF I/O ---- def to_geotiff(self, path, var=None, **kwargs): diff --git a/xrspatial/interpolate/_idw.py b/xrspatial/interpolate/_idw.py index 92c3cb060..9cb0acc8f 100644 --- a/xrspatial/interpolate/_idw.py +++ b/xrspatial/interpolate/_idw.py @@ -10,6 +10,7 @@ _validate_scalar, cuda_args, ngjit) from ._validation import extract_grid_coords, validate_points +from ._vector import resolve_xyz try: import cupy @@ -281,14 +282,16 @@ def _check_idw_memory(grid_pixels, k): ) -def idw(x, y, z, template, power=2.0, k=None, - fill_value=np.nan, name='idw'): +def idw(x, y=None, z=None, template=None, power=2.0, k=None, + fill_value=np.nan, name='idw', *, column=None): """Inverse Distance Weighting interpolation. Parameters ---------- x, y, z : array-like - Coordinates and values of scattered input points. + Coordinates and values of scattered input points. Alternatively, + pass a GeoDataFrame of Point geometries as the first argument and + leave *y*/*z* unset; *template* and *column* must then be keywords. template : xr.DataArray 2-D DataArray whose grid defines the output raster. power : float, default 2.0 @@ -301,6 +304,9 @@ def idw(x, y, z, template, power=2.0, k=None, Value for pixels with zero total weight. name : str, default 'idw' Name of the output DataArray. + column : str, optional + When the first argument is a GeoDataFrame, the column whose values + are interpolated. Defaults to the first numeric column. Returns ------- @@ -313,6 +319,7 @@ def idw(x, y, z, template, power=2.0, k=None, ``(grid_pixels, k)`` distance and index arrays from the ``cKDTree`` query would exceed 80% of available memory. """ + x, y, z = resolve_xyz(x, y, z, column=column, func_name='idw') _validate_raster(template, func_name='idw', name='template') x_arr, y_arr, z_arr = validate_points(x, y, z, func_name='idw') _validate_scalar(power, func_name='idw', name='power', diff --git a/xrspatial/interpolate/_kriging.py b/xrspatial/interpolate/_kriging.py index 80d9fc5f1..3bdd285fb 100644 --- a/xrspatial/interpolate/_kriging.py +++ b/xrspatial/interpolate/_kriging.py @@ -11,6 +11,7 @@ _validate_scalar) from ._validation import extract_grid_coords, validate_points +from ._vector import resolve_xyz try: import cupy @@ -479,14 +480,16 @@ def _check_kriging_memory(n_points, grid_pixels, is_dask=False): ) -def kriging(x, y, z, template, variogram_model='spherical', nlags=15, - return_variance=False, name='kriging'): +def kriging(x, y=None, z=None, template=None, variogram_model='spherical', + nlags=15, return_variance=False, name='kriging', *, column=None): """Ordinary Kriging interpolation. Parameters ---------- x, y, z : array-like - Coordinates and values of scattered input points. + Coordinates and values of scattered input points. Alternatively, + pass a GeoDataFrame of Point geometries as the first argument and + leave *y*/*z* unset; *template* and *column* must then be keywords. template : xr.DataArray 2-D DataArray whose grid defines the output raster. variogram_model : str, default 'spherical' @@ -498,6 +501,9 @@ def kriging(x, y, z, template, variogram_model='spherical', nlags=15, If True, return ``(prediction, variance)`` tuple. name : str, default 'kriging' Name of the output DataArray. + column : str, optional + When the first argument is a GeoDataFrame, the column whose values + are interpolated. Defaults to the first numeric column. Returns ------- @@ -512,6 +518,7 @@ def kriging(x, y, z, template, variogram_model='spherical', nlags=15, matrix, or prediction matrix) would exceed 80% of available memory. """ + x, y, z = resolve_xyz(x, y, z, column=column, func_name='kriging') _validate_raster(template, func_name='kriging', name='template') x_arr, y_arr, z_arr = validate_points(x, y, z, func_name='kriging') diff --git a/xrspatial/interpolate/_spline.py b/xrspatial/interpolate/_spline.py index c4f5af456..5c39e2a82 100644 --- a/xrspatial/interpolate/_spline.py +++ b/xrspatial/interpolate/_spline.py @@ -12,6 +12,7 @@ _validate_scalar, cuda_args, ngjit) from ._validation import extract_grid_coords, validate_points +from ._vector import resolve_xyz try: import cupy @@ -300,13 +301,16 @@ def _check_spline_memory(n_points, grid_pixels): ) -def spline(x, y, z, template, smoothing=0.0, name='spline'): +def spline(x, y=None, z=None, template=None, smoothing=0.0, name='spline', + *, column=None): """Thin Plate Spline interpolation. Parameters ---------- x, y, z : array-like - Coordinates and values of scattered input points. + Coordinates and values of scattered input points. Alternatively, + pass a GeoDataFrame of Point geometries as the first argument and + leave *y*/*z* unset; *template* and *column* must then be keywords. template : xr.DataArray 2-D DataArray whose grid defines the output raster. smoothing : float, default 0.0 @@ -314,6 +318,9 @@ def spline(x, y, z, template, smoothing=0.0, name='spline'): the data points. name : str, default 'spline' Name of the output DataArray. + column : str, optional + When the first argument is a GeoDataFrame, the column whose values + are interpolated. Defaults to the first numeric column. Returns ------- @@ -325,6 +332,7 @@ def spline(x, y, z, template, smoothing=0.0, name='spline'): If the worst-case allocation (kernel block K or augmented system A) would exceed 80% of available memory. """ + x, y, z = resolve_xyz(x, y, z, column=column, func_name='spline') _validate_raster(template, func_name='spline', name='template') x_arr, y_arr, z_arr = validate_points(x, y, z, func_name='spline') _validate_scalar(smoothing, func_name='spline', name='smoothing', diff --git a/xrspatial/interpolate/_vector.py b/xrspatial/interpolate/_vector.py new file mode 100644 index 000000000..3f256dade --- /dev/null +++ b/xrspatial/interpolate/_vector.py @@ -0,0 +1,117 @@ +"""Extract interpolation point inputs from geospatial vector data. + +The interpolation functions (``idw``/``kriging``/``spline`` and ``kde``) +historically only accept raw ``x, y, z`` array-likes. These helpers let +them also accept a GeoDataFrame of Point geometries, mirroring how +``rasterize`` reads a burn value from a ``column``. geopandas stays an +optional dependency: it is imported lazily and a guarded ImportError keeps +the array path working without it. +""" + +from __future__ import annotations + +import numpy as np + + +def is_geodataframe(obj): + """True if *obj* is a geopandas GeoDataFrame (geopandas optional).""" + try: + import geopandas as gpd + except ImportError: + return False + return isinstance(obj, gpd.GeoDataFrame) + + +def _resolve_value_column(gdf, *, column, value_required, func_name): + """Resolve the per-point value array from a GeoDataFrame. + + Mirrors ``rasterize._parse_input``: an explicit *column* wins, else the + first numeric column is used when a value is required, else ``None``. + """ + if column is not None: + if column not in gdf.columns: + raise ValueError( + f"{func_name}(): column {column!r} is not in the GeoDataFrame" + ) + return np.asarray(gdf[column].values, dtype=np.float64) + + if not value_required: + return None + + numeric_cols = gdf.select_dtypes(include='number').columns + if len(numeric_cols) == 0: + raise ValueError( + f"{func_name}(): GeoDataFrame has no numeric column to " + f"interpolate. Pass a 'column' name explicitly." + ) + return np.asarray(gdf[numeric_cols[0]].values, dtype=np.float64) + + +def points_from_geodataframe(gdf, *, column, value_required, func_name): + """Return ``(x, y, value, crs)`` from a GeoDataFrame of Point geometries. + + Parameters + ---------- + gdf : geopandas.GeoDataFrame + Input points. Only single-part ``Point`` geometries are accepted; + any other geometry type raises (interpolation is point-based, unlike + ``rasterize`` which fills polygons and lines). + column : str or None + Column holding the per-point value. When ``None`` and + *value_required*, the first numeric column is used; when ``None`` and + not required, *value* is ``None``. + value_required : bool + Whether a per-point value must be resolved (``z`` for + idw/kriging/spline; optional weights for kde). + func_name : str + Caller name, used in error messages. + + Returns + ------- + x, y : numpy.ndarray + Float64 point coordinates. + value : numpy.ndarray or None + Per-point values, or ``None`` when not required and no column given. + crs : object or None + ``gdf.crs``, passed through as-is. + """ + geom = gdf.geometry + geom_types = set(geom.geom_type.dropna().unique()) + other = geom_types - {'Point'} + if other: + raise ValueError( + f"{func_name}(): interpolation needs single Point geometries, " + f"got {sorted(other)}" + ) + + x = np.asarray(geom.x.values, dtype=np.float64) + y = np.asarray(geom.y.values, dtype=np.float64) + value = _resolve_value_column( + gdf, column=column, value_required=value_required, func_name=func_name + ) + return x, y, value, gdf.crs + + +def resolve_xyz(x, y, z, *, column, func_name): + """Resolve ``(x, y, z)`` for the value-interpolation functions. + + If *x* is a GeoDataFrame, pull coordinates and the value column from it + (*y*/*z* must be unset); otherwise pass the arrays through unchanged. + ``column`` is only meaningful for the GeoDataFrame form. + """ + if is_geodataframe(x): + if y is not None or z is not None: + raise ValueError( + f"{func_name}(): when the first argument is a GeoDataFrame, " + f"pass template and column as keywords, not positional y/z" + ) + gx, gy, value, _crs = points_from_geodataframe( + x, column=column, value_required=True, func_name=func_name + ) + return gx, gy, value + if column is not None: + raise ValueError( + f"{func_name}(): 'column' is only valid when the first argument " + f"is a GeoDataFrame" + ) + return x, y, z diff --git a/xrspatial/kde.py b/xrspatial/kde.py index 8a5fc5ef6..ce95ac3ad 100644 --- a/xrspatial/kde.py +++ b/xrspatial/kde.py @@ -17,6 +17,9 @@ import xarray as xr from xrspatial.utils import ngjit, has_cuda_and_cupy, has_dask_array +from xrspatial.interpolate._vector import ( + is_geodataframe, points_from_geodataframe, +) try: import cupy @@ -493,7 +496,7 @@ def _split_sizes(total, chunk): def kde( x: Union[np.ndarray, list], - y: Union[np.ndarray, list], + y: Optional[Union[np.ndarray, list]] = None, *, weights: Optional[Union[np.ndarray, list]] = None, bandwidth: Union[float, str] = 'silverman', @@ -504,6 +507,7 @@ def kde( width: int = 256, height: int = 256, name: str = 'kde', + column: Optional[str] = None, ) -> xr.DataArray: """Compute 2-D kernel density estimation from point data. @@ -513,9 +517,14 @@ def kde( Parameters ---------- x, y : array-like - 1-D arrays of point coordinates. + 1-D arrays of point coordinates. Alternatively, pass a GeoDataFrame + of Point geometries as the first argument and leave *y* unset. weights : array-like, optional Per-point weights. Defaults to uniform weights of 1. + column : str, optional + When the first argument is a GeoDataFrame, the column used as + per-point weights. Omit for a pure (uniform-weight) point density. + Mutually exclusive with *weights*. bandwidth : float or ``'silverman'`` Kernel bandwidth in the same units as *x*/*y*. ``'silverman'`` (default) uses Silverman's rule of thumb. @@ -539,6 +548,31 @@ def kde( xr.DataArray 2-D density surface. """ + # -- Resolve GeoDataFrame input ---------------------------------------- + if is_geodataframe(x): + if y is not None: + raise ValueError( + "kde(): when the first argument is a GeoDataFrame, pass " + "weights via 'column' or 'weights' as keywords, not y" + ) + if weights is not None and column is not None: + raise ValueError( + "kde(): pass either 'weights' or 'column', not both" + ) + x, y, col_weights, _crs = points_from_geodataframe( + x, column=column, value_required=False, func_name='kde' + ) + if col_weights is not None: + weights = col_weights + else: + if column is not None: + raise ValueError( + "kde(): 'column' is only valid when the first argument is a " + "GeoDataFrame" + ) + if y is None: + raise ValueError("kde(): y is required when x is not a GeoDataFrame") + # -- Validate and coerce inputs ---------------------------------------- x_arr = np.asarray(x, dtype=np.float64).ravel() y_arr = np.asarray(y, dtype=np.float64).ravel() From 84fb591a955d001b1eda55abaa5e0f8f05a5f5e8 Mon Sep 17 00:00:00 2001 From: Brendan Collins Date: Wed, 24 Jun 2026 09:54:46 -0700 Subject: [PATCH 2/5] Add GeoDataFrame/coregister tests; replace array-only accessor methods (#3480) --- xrspatial/accessor.py | 137 +++++------ xrspatial/tests/test_interpolate_vector.py | 263 +++++++++++++++++++++ 2 files changed, 328 insertions(+), 72 deletions(-) create mode 100644 xrspatial/tests/test_interpolate_vector.py diff --git a/xrspatial/accessor.py b/xrspatial/accessor.py index 9e1273867..c7013e9cd 100644 --- a/xrspatial/accessor.py +++ b/xrspatial/accessor.py @@ -781,34 +781,37 @@ def _label(crs): ) -def _interp_on_accessor(obj, func, data, *, coregister, **kwargs): +def _interp_on_accessor(obj, func, points, rest, *, coregister, **kwargs): """Run interpolation *func* against caller raster *obj* as the template. *obj* supplies the output grid, chunks, CRS, and attrs (passed as - ``template``). When *data* is a GeoDataFrame and ``coregister=True``, - its geometries are reprojected into the caller's CRS before - interpolation; otherwise a genuine CRS mismatch raises (matching - ``rasterize``'s default). ``coregister`` needs a CRS on both sides. + ``template``). *points* is the first argument to *func*: a GeoDataFrame, + or raw ``x`` for the legacy array form, in which case *rest* carries the + remaining positional coordinates (``y``, ``z``). When *points* is a + GeoDataFrame and ``coregister=True``, its geometries are reprojected into + the caller's CRS before interpolation; otherwise a genuine CRS mismatch + raises (matching ``rasterize``'s default). ``coregister`` needs a CRS on + both sides and only applies to GeoDataFrame input. """ from xrspatial.interpolate._vector import is_geodataframe - target = _to_pyproj_crs(obj.attrs.get('crs')) - if is_geodataframe(data): - src = _to_pyproj_crs(data.crs) + if is_geodataframe(points): + target = _to_pyproj_crs(obj.attrs.get('crs')) + src = _to_pyproj_crs(points.crs) if coregister: if src is None or target is None: raise ValueError( "coregister=True needs a CRS on both the points " "(GeoDataFrame.crs) and the caller (attrs['crs'])" ) - data = data.to_crs(target) + points = points.to_crs(target) else: _check_point_crs_match(src, target) elif coregister: raise ValueError( "coregister=True requires a GeoDataFrame input carrying a CRS" ) - return func(data, template=obj, **kwargs) + return func(points, *rest, template=obj, **kwargs) @xr.register_dataarray_accessor("xrs") @@ -1239,17 +1242,54 @@ def mahalanobis(self, other_bands, **kwargs): # ---- Interpolation ---- - def idw(self, x, y, z, **kwargs): + def kde(self, x, y=None, *, coregister=False, **kwargs): + """Kernel density of points onto this DataArray's grid. + + Pass a GeoDataFrame of Point geometries as the first argument + (``column`` selects per-point weights), or raw ``x``/``y`` arrays. + With ``coregister=True`` a GeoDataFrame's points are reprojected + from their CRS into this array's CRS first. See + :func:`xrspatial.kde`. + """ + from .kde import kde + return _interp_on_accessor(self._obj, kde, x, (y,), + coregister=coregister, **kwargs) + + def idw(self, x, y=None, z=None, *, coregister=False, **kwargs): + """Inverse-distance-weighted interpolation onto this grid. + + Pass a GeoDataFrame (``column`` selects the value to interpolate) + or raw ``x``/``y``/``z`` arrays. ``coregister=True`` reprojects a + GeoDataFrame's points into this array's CRS first. See + :func:`xrspatial.idw`. + """ from .interpolate import idw - return idw(x, y, z, self._obj, **kwargs) + return _interp_on_accessor(self._obj, idw, x, (y, z), + coregister=coregister, **kwargs) + + def kriging(self, x, y=None, z=None, *, coregister=False, **kwargs): + """Ordinary-kriging interpolation onto this grid. - def kriging(self, x, y, z, **kwargs): + Pass a GeoDataFrame (``column`` selects the value to interpolate) + or raw ``x``/``y``/``z`` arrays. ``coregister=True`` reprojects a + GeoDataFrame's points into this array's CRS first. See + :func:`xrspatial.kriging`. + """ from .interpolate import kriging - return kriging(x, y, z, self._obj, **kwargs) + return _interp_on_accessor(self._obj, kriging, x, (y, z), + coregister=coregister, **kwargs) - def spline(self, x, y, z, **kwargs): + def spline(self, x, y=None, z=None, *, coregister=False, **kwargs): + """Thin-plate-spline interpolation onto this grid. + + Pass a GeoDataFrame (``column`` selects the value to interpolate) + or raw ``x``/``y``/``z`` arrays. ``coregister=True`` reprojects a + GeoDataFrame's points into this array's CRS first. See + :func:`xrspatial.spline`. + """ from .interpolate import spline - return spline(x, y, z, self._obj, **kwargs) + return _interp_on_accessor(self._obj, spline, x, (y, z), + coregister=coregister, **kwargs) # ---- Preview ---- @@ -1355,53 +1395,6 @@ def rasterize(self, geometries, **kwargs): from .rasterize import rasterize return rasterize(geometries, like=self._obj, **kwargs) - # ---- Interpolation ---- - - def kde(self, points, *, coregister=False, **kwargs): - """Kernel density of *points* onto this DataArray's grid. - - *points* may be a GeoDataFrame (``column`` selects per-point - weights) or raw ``x``/``y`` passed through ``**kwargs``. With - ``coregister=True`` the points are reprojected from their CRS into - this array's CRS first. See :func:`xrspatial.kde`. - """ - from .kde import kde - return _interp_on_accessor(self._obj, kde, points, - coregister=coregister, **kwargs) - - def idw(self, points, *, coregister=False, **kwargs): - """Inverse-distance-weighted interpolation onto this grid. - - See :func:`xrspatial.idw`. ``column`` selects the value to - interpolate from a GeoDataFrame; ``coregister=True`` reprojects the - points into this array's CRS first. - """ - from .interpolate import idw - return _interp_on_accessor(self._obj, idw, points, - coregister=coregister, **kwargs) - - def spline(self, points, *, coregister=False, **kwargs): - """Thin-plate-spline interpolation onto this grid. - - See :func:`xrspatial.spline`. ``column`` selects the value to - interpolate from a GeoDataFrame; ``coregister=True`` reprojects the - points into this array's CRS first. - """ - from .interpolate import spline - return _interp_on_accessor(self._obj, spline, points, - coregister=coregister, **kwargs) - - def kriging(self, points, *, coregister=False, **kwargs): - """Ordinary-kriging interpolation onto this grid. - - See :func:`xrspatial.kriging`. ``column`` selects the value to - interpolate from a GeoDataFrame; ``coregister=True`` reprojects the - points into this array's CRS first. - """ - from .interpolate import kriging - return _interp_on_accessor(self._obj, kriging, points, - coregister=coregister, **kwargs) - # ---- GeoTIFF I/O ---- def to_geotiff(self, path, **kwargs): @@ -1969,40 +1962,40 @@ def _interp_template(self): "to use as an interpolation template" ) - def kde(self, points, *, coregister=False, **kwargs): - """Kernel density of *points* onto a 2-D variable's grid. + def kde(self, x, y=None, *, coregister=False, **kwargs): + """Kernel density of points onto a 2-D variable's grid. See :meth:`XrsSpatialDataArrayAccessor.kde`. """ from .kde import kde - return _interp_on_accessor(self._interp_template(), kde, points, + return _interp_on_accessor(self._interp_template(), kde, x, (y,), coregister=coregister, **kwargs) - def idw(self, points, *, coregister=False, **kwargs): + def idw(self, x, y=None, z=None, *, coregister=False, **kwargs): """Inverse-distance-weighted interpolation onto a 2-D variable's grid. See :meth:`XrsSpatialDataArrayAccessor.idw`. """ from .interpolate import idw - return _interp_on_accessor(self._interp_template(), idw, points, + return _interp_on_accessor(self._interp_template(), idw, x, (y, z), coregister=coregister, **kwargs) - def spline(self, points, *, coregister=False, **kwargs): + def spline(self, x, y=None, z=None, *, coregister=False, **kwargs): """Thin-plate-spline interpolation onto a 2-D variable's grid. See :meth:`XrsSpatialDataArrayAccessor.spline`. """ from .interpolate import spline - return _interp_on_accessor(self._interp_template(), spline, points, + return _interp_on_accessor(self._interp_template(), spline, x, (y, z), coregister=coregister, **kwargs) - def kriging(self, points, *, coregister=False, **kwargs): + def kriging(self, x, y=None, z=None, *, coregister=False, **kwargs): """Ordinary-kriging interpolation onto a 2-D variable's grid. See :meth:`XrsSpatialDataArrayAccessor.kriging`. """ from .interpolate import kriging - return _interp_on_accessor(self._interp_template(), kriging, points, + return _interp_on_accessor(self._interp_template(), kriging, x, (y, z), coregister=coregister, **kwargs) # ---- GeoTIFF I/O ---- diff --git a/xrspatial/tests/test_interpolate_vector.py b/xrspatial/tests/test_interpolate_vector.py new file mode 100644 index 000000000..0fc957d1b --- /dev/null +++ b/xrspatial/tests/test_interpolate_vector.py @@ -0,0 +1,263 @@ +"""GeoDataFrame input + ``.xrs`` accessor + coregister for interpolation (#3480).""" + +from __future__ import annotations + +import numpy as np +import pytest +import xarray as xr + +import xrspatial # noqa: F401 (registers the .xrs accessor) +from xrspatial import idw, kde, kriging, spline + +gpd = pytest.importorskip("geopandas") +shapely_geometry = pytest.importorskip("shapely.geometry") +Point = shapely_geometry.Point +LineString = shapely_geometry.LineString + + +# --------------------------------------------------------------------------- +# Fixtures / helpers +# --------------------------------------------------------------------------- + +PX = np.array([1.0, 5.0, 8.0, 3.0, 6.0]) +PY = np.array([2.0, 6.0, 4.0, 9.0, 1.0]) +PZ = np.array([10.0, 20.0, 15.0, 5.0, 12.0]) + + +def _template(backend="numpy", crs="EPSG:3857"): + xs = np.linspace(0.0, 10.0, 12) + ys = np.linspace(10.0, 0.0, 11) + data = np.zeros((11, 12), dtype=np.float64) + if backend == "dask": + import dask.array as da + data = da.from_array(data, chunks=(6, 6)) + t = xr.DataArray(data, coords={"y": ys, "x": xs}, dims=["y", "x"]) + if crs is not None: + t.attrs["crs"] = crs + return t + + +def _gdf(crs="EPSG:3857", value_col="z"): + geom = [Point(a, b) for a, b in zip(PX, PY)] + return gpd.GeoDataFrame({value_col: PZ}, geometry=geom, crs=crs) + + +def _np(arr): + data = arr.data + if hasattr(data, "compute"): + data = data.compute() + return np.asarray(data) + + +# --------------------------------------------------------------------------- +# 1. GeoDataFrame parity with the array form (standalone functions) +# --------------------------------------------------------------------------- + +@pytest.mark.parametrize("backend", ["numpy", "dask"]) +def test_idw_geodataframe_parity(backend): + t = _template(backend) + arr = idw(PX, PY, PZ, t) + gdf = idw(_gdf(), template=t, column="z") + np.testing.assert_allclose(_np(arr), _np(gdf), equal_nan=True) + + +@pytest.mark.parametrize("backend", ["numpy", "dask"]) +def test_spline_geodataframe_parity(backend): + t = _template(backend) + arr = spline(PX, PY, PZ, t) + gdf = spline(_gdf(), template=t, column="z") + np.testing.assert_allclose(_np(arr), _np(gdf), equal_nan=True) + + +@pytest.mark.parametrize("backend", ["numpy", "dask"]) +def test_kriging_geodataframe_parity(backend): + t = _template(backend) + arr = kriging(PX, PY, PZ, t) + gdf = kriging(_gdf(), template=t, column="z") + np.testing.assert_allclose(_np(arr), _np(gdf), equal_nan=True) + + +@pytest.mark.parametrize("backend", ["numpy", "dask"]) +def test_kde_geodataframe_parity(backend): + t = _template(backend) + # uniform-weight density + arr = kde(PX, PY, template=t) + gdf = kde(_gdf(), template=t) + np.testing.assert_allclose(_np(arr), _np(gdf), equal_nan=True) + # column maps to per-point weights + arr_w = kde(PX, PY, weights=PZ, template=t) + gdf_w = kde(_gdf(), template=t, column="z") + np.testing.assert_allclose(_np(arr_w), _np(gdf_w), equal_nan=True) + + +def test_column_autopick_first_numeric(): + t = _template() + gdf = _gdf(value_col="elevation") + auto = kriging(gdf, template=t) + named = kriging(gdf, template=t, column="elevation") + np.testing.assert_allclose(_np(auto), _np(named), equal_nan=True) + + +# --------------------------------------------------------------------------- +# 2. Accessor wiring +# --------------------------------------------------------------------------- + +@pytest.mark.parametrize("name", ["idw", "spline", "kriging"]) +def test_accessor_matches_standalone(name): + t = _template() + func = globals()[name] + direct = func(_gdf(), template=t, column="z") + via = getattr(t.xrs, name)(_gdf(), column="z") + np.testing.assert_allclose(_np(direct), _np(via), equal_nan=True) + assert via.attrs.get("crs") == "EPSG:3857" + assert via.shape == t.shape + + +def test_accessor_kde(): + t = _template() + via = t.xrs.kde(_gdf()) + np.testing.assert_allclose(_np(via), _np(kde(_gdf(), template=t)), + equal_nan=True) + + +@pytest.mark.parametrize("backend", ["numpy", "dask"]) +def test_accessor_inherits_chunks(backend): + t = _template(backend) + out = t.xrs.idw(_gdf(), column="z") + if backend == "dask": + assert out.data.chunksize == (6, 6) + else: + assert not hasattr(out.data, "chunks") + + +def test_accessor_array_form_backward_compatible(): + # the legacy x/y/z array signature on the accessor still works + t = _template() + out = t.xrs.idw(PX, PY, PZ) + np.testing.assert_allclose(_np(out), _np(idw(PX, PY, PZ, t)), + equal_nan=True) + out_k = t.xrs.kde(PX, PY) + np.testing.assert_allclose(_np(out_k), _np(kde(PX, PY, template=t)), + equal_nan=True) + + +def test_accessor_dataset(): + t = _template() + ds = t.to_dataset(name="band") + out = ds.xrs.idw(_gdf(), column="z") + np.testing.assert_allclose(_np(out), _np(t.xrs.idw(_gdf(), column="z")), + equal_nan=True) + + +# --------------------------------------------------------------------------- +# 3. Coregister +# --------------------------------------------------------------------------- + +def test_coregister_matches_manual_reprojection(): + t = _template(crs="EPSG:3857") + gdf_3857 = _gdf(crs="EPSG:3857") + gdf_4326 = gdf_3857.to_crs("EPSG:4326") + coreg = t.xrs.idw(gdf_4326, column="z", coregister=True) + direct = t.xrs.idw(gdf_3857, column="z") + np.testing.assert_allclose(_np(coreg), _np(direct), equal_nan=True, + atol=1e-6) + + +def test_coregister_kde_headline_call(): + t = _template(crs="EPSG:3857") + gdf_4326 = _gdf(crs="EPSG:3857").to_crs("EPSG:4326") + out = t.xrs.kde(gdf_4326, coregister=True) + assert out.shape == t.shape + assert np.isfinite(_np(out)).all() + assert out.attrs.get("crs") == "EPSG:3857" + + +# --------------------------------------------------------------------------- +# 4. CRS-mismatch guard +# --------------------------------------------------------------------------- + +def test_crs_mismatch_raises_without_coregister(): + t = _template(crs="EPSG:3857") + gdf_4326 = _gdf(crs="EPSG:3857").to_crs("EPSG:4326") + with pytest.raises(ValueError, match="CRS mismatch"): + t.xrs.idw(gdf_4326, column="z") + + +def test_matching_crs_passes(): + t = _template(crs="EPSG:3857") + out = t.xrs.idw(_gdf(crs="EPSG:3857"), column="z") + assert out.shape == t.shape + + +def test_missing_crs_either_side_passes(): + # caller has no CRS -> no-op check, like rasterize + t = _template(crs=None) + out = t.xrs.idw(_gdf(crs="EPSG:3857"), column="z") + assert out.shape == t.shape + + +def test_coregister_needs_crs_both_sides(): + t = _template(crs="EPSG:3857") + with pytest.raises(ValueError, match="coregister=True needs a CRS"): + t.xrs.idw(_gdf(crs=None), column="z", coregister=True) + + +def test_coregister_requires_geodataframe(): + t = _template(crs="EPSG:3857") + with pytest.raises(ValueError, match="requires a GeoDataFrame"): + t.xrs.kde(PX, y=PY, coregister=True) + + +# --------------------------------------------------------------------------- +# 5. Edge cases +# --------------------------------------------------------------------------- + +def test_non_point_geometry_raises(): + t = _template() + gdf = gpd.GeoDataFrame( + {"z": [1.0, 2.0]}, + geometry=[LineString([(0, 0), (1, 1)]), LineString([(1, 1), (2, 2)])], + crs="EPSG:3857", + ) + with pytest.raises(ValueError, match="Point geometries"): + idw(gdf, template=t, column="z") + + +def test_missing_column_no_numeric_raises(): + t = _template() + gdf = gpd.GeoDataFrame( + {"label": ["a", "b", "c", "d", "e"]}, + geometry=[Point(a, b) for a, b in zip(PX, PY)], crs="EPSG:3857", + ) + with pytest.raises(ValueError, match="no numeric column"): + kriging(gdf, template=t) + + +def test_unknown_column_raises(): + t = _template() + with pytest.raises(ValueError, match="not in the GeoDataFrame"): + idw(_gdf(), template=t, column="nope") + + +def test_positional_yz_with_geodataframe_raises(): + t = _template() + with pytest.raises(ValueError, match="pass template and column as keywords"): + idw(_gdf(), PY, PZ, t) + + +def test_kde_weights_and_column_conflict_raises(): + t = _template() + with pytest.raises(ValueError, match="either 'weights' or 'column'"): + kde(_gdf(), template=t, column="z", weights=PZ) + + +def test_column_without_geodataframe_raises(): + t = _template() + with pytest.raises(ValueError, match="only valid"): + idw(PX, PY, PZ, t, column="z") + + +def test_kde_array_requires_y(): + t = _template() + with pytest.raises(ValueError, match="y is required"): + kde(PX, template=t) From 54a2df1f77feed8207a946faead5178829941379 Mon Sep 17 00:00:00 2001 From: Brendan Collins Date: Wed, 24 Jun 2026 09:55:56 -0700 Subject: [PATCH 3/5] Document GeoDataFrame + accessor coregister forms (#3480) --- README.md | 8 ++++---- docs/source/reference/interpolation.rst | 14 ++++++++++++++ docs/source/reference/kde.rst | 10 ++++++++++ 3 files changed, 28 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 5ab744b09..1183870ea 100644 --- a/README.md +++ b/README.md @@ -445,9 +445,9 @@ For a broader catalog of spectral indices and sensor-specific band combinations, | Name | Description | Source | NumPy xr.DataArray | Dask xr.DataArray | CuPy GPU xr.DataArray | Dask GPU xr.DataArray | |:----------:|:------------|:------:|:----------------------:|:--------------------:|:-------------------:|:------:| -| [IDW](xrspatial/interpolate/_idw.py) | Inverse Distance Weighting from scattered points to a raster grid | Standard (IDW) | โœ… | ๐Ÿ”ผ | ๐Ÿ”ผ | ๐Ÿ”ผ | -| [Kriging](xrspatial/interpolate/_kriging.py) | Ordinary Kriging with automatic variogram fitting (spherical, exponential, gaussian) | Standard (ordinary kriging) | ๐Ÿ”ผ | ๐Ÿ”ผ | ๐Ÿ”ผ | ๐Ÿ”ผ | -| [Spline](xrspatial/interpolate/_spline.py) | Thin Plate Spline interpolation with optional smoothing | Standard (TPS) | ๐Ÿ”ผ | ๐Ÿ”ผ | ๐Ÿ”ผ | ๐Ÿ”ผ | +| [IDW](xrspatial/interpolate/_idw.py) | Inverse Distance Weighting from scattered points (arrays or a GeoDataFrame) to a raster grid | Standard (IDW) | โœ… | ๐Ÿ”ผ | ๐Ÿ”ผ | ๐Ÿ”ผ | +| [Kriging](xrspatial/interpolate/_kriging.py) | Ordinary Kriging with automatic variogram fitting (spherical, exponential, gaussian); accepts arrays or a GeoDataFrame | Standard (ordinary kriging) | ๐Ÿ”ผ | ๐Ÿ”ผ | ๐Ÿ”ผ | ๐Ÿ”ผ | +| [Spline](xrspatial/interpolate/_spline.py) | Thin Plate Spline interpolation with optional smoothing; accepts arrays or a GeoDataFrame | Standard (TPS) | ๐Ÿ”ผ | ๐Ÿ”ผ | ๐Ÿ”ผ | ๐Ÿ”ผ | ----------- @@ -494,7 +494,7 @@ For a broader catalog of spectral indices and sensor-specific band combinations, | Name | Description | Source | NumPy xr.DataArray | Dask xr.DataArray | CuPy GPU xr.DataArray | Dask GPU xr.DataArray | |:-----|:------------|:------:|:------------------:|:-----------------:|:---------------------:|:---------------------:| -| [KDE](xrspatial/kde.py) | Point-to-raster kernel density estimation (Gaussian, Epanechnikov, quartic) | Silverman 1986 | ๐Ÿ”ผ | ๐Ÿ”ผ | ๐Ÿ”ผ | ๐Ÿ”ผ | +| [KDE](xrspatial/kde.py) | Point-to-raster kernel density estimation (Gaussian, Epanechnikov, quartic); accepts arrays or a GeoDataFrame | Silverman 1986 | ๐Ÿ”ผ | ๐Ÿ”ผ | ๐Ÿ”ผ | ๐Ÿ”ผ | | [Line Density](xrspatial/kde.py) | Line-segment-to-raster density estimation | Standard | ๐Ÿ”ผ | | | | -------- diff --git a/docs/source/reference/interpolation.rst b/docs/source/reference/interpolation.rst index ed63feb2c..4f05054f6 100644 --- a/docs/source/reference/interpolation.rst +++ b/docs/source/reference/interpolation.rst @@ -4,6 +4,20 @@ Interpolation ************* +.. note:: + + Each function accepts either raw ``x``, ``y``, ``z`` arrays or a + GeoDataFrame of Point geometries (``column`` selects the value to + interpolate, defaulting to the first numeric column). The same + operations are available on the ``.xrs`` accessor, where the caller + raster supplies the output grid, chunks, and CRS:: + + dem.xrs.kriging(points_gdf, column="elevation") + dem.xrs.spline(points_gdf, coregister=True) + + ``coregister=True`` reprojects a GeoDataFrame's points from their CRS + into the caller's CRS before interpolation. + Inverse Distance Weighting (IDW) ================================= .. autosummary:: diff --git a/docs/source/reference/kde.rst b/docs/source/reference/kde.rst index 0f832d6fc..f73a7164a 100644 --- a/docs/source/reference/kde.rst +++ b/docs/source/reference/kde.rst @@ -9,6 +9,16 @@ KDE Kernel density estimation converts point or line data into continuous density surfaces on a raster grid. + ``kde`` accepts either raw ``x``, ``y`` arrays or a GeoDataFrame of + Point geometries (``column`` selects per-point weights). It is also + available on the ``.xrs`` accessor, where the caller raster supplies the + output grid and CRS:: + + grid.xrs.kde(points_gdf, coregister=True) + + ``coregister=True`` reprojects the points from their CRS into the + caller's CRS first. + KDE === .. autosummary:: From feee29b2b01bb1723aaffd87d03eeaf9f0d0892c Mon Sep 17 00:00:00 2001 From: Brendan Collins Date: Wed, 24 Jun 2026 09:58:52 -0700 Subject: [PATCH 4/5] Add vector interpolation user guide notebook (#3480) --- .../user_guide/56_Vector_Interpolation.ipynb | 515 ++++++++++++++++++ .../images/vector_interpolation_preview.png | Bin 0 -> 63961 bytes 2 files changed, 515 insertions(+) create mode 100644 examples/user_guide/56_Vector_Interpolation.ipynb create mode 100644 examples/user_guide/images/vector_interpolation_preview.png diff --git a/examples/user_guide/56_Vector_Interpolation.ipynb b/examples/user_guide/56_Vector_Interpolation.ipynb new file mode 100644 index 000000000..ab5f10cf5 --- /dev/null +++ b/examples/user_guide/56_Vector_Interpolation.ipynb @@ -0,0 +1,515 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "8ad387c8", + "metadata": {}, + "source": [ + "# Xarray-Spatial Interpolation: GeoDataFrames, the `.xrs` accessor, and coregistration\n", + "\n", + "Field measurements rarely arrive as a tidy grid. You get a GeoDataFrame of\n", + "sample points, each with a value and a coordinate reference system, and you\n", + "want a continuous surface that lines up with a raster you already have. This\n", + "notebook turns a GeoDataFrame of points straight into an interpolated surface,\n", + "calls the interpolators on the `.xrs` accessor so the output inherits the\n", + "caller raster's grid and CRS, and reprojects points across coordinate systems\n", + "with `coregister=True`." + ] + }, + { + "cell_type": "markdown", + "id": "57b15802", + "metadata": {}, + "source": [ + "### What you'll build\n", + "\n", + "1. Build a GeoDataFrame of sample points with a value column\n", + "2. Interpolate it onto a target grid with `idw`, passing the GeoDataFrame directly\n", + "3. Run `kriging` and `spline` from the `.xrs` accessor so the output matches the caller raster\n", + "4. Map point density with `kde`\n", + "5. Reproject points from EPSG:4326 into the grid's EPSG:3857 with `coregister=True`\n", + "\n", + "![Vector interpolation preview](images/vector_interpolation_preview.png)\n", + "\n", + "[IDW from a GeoDataFrame](#IDW-from-a-GeoDataFrame) ยท\n", + "[The .xrs accessor](#The-.xrs-accessor:-kriging-and-spline) ยท\n", + "[Point density with KDE](#Point-density-with-KDE) ยท\n", + "[Coregistration across CRSs](#Coregistration-across-CRSs)" + ] + }, + { + "cell_type": "markdown", + "id": "b6101461", + "metadata": {}, + "source": [ + "Standard imports plus geopandas for the point data and the xrspatial interpolators. Importing `xrspatial` registers the `.xrs` accessor." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "566bc965", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T16:58:14.924559Z", + "iopub.status.busy": "2026-06-24T16:58:14.924438Z", + "iopub.status.idle": "2026-06-24T16:58:16.476844Z", + "shell.execute_reply": "2026-06-24T16:58:16.476208Z" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import xarray as xr\n", + "import geopandas as gpd\n", + "from shapely.geometry import Point\n", + "\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.patches import Patch\n", + "\n", + "import xrspatial # registers the .xrs accessor\n", + "from xrspatial import idw" + ] + }, + { + "cell_type": "markdown", + "id": "a65d28cf", + "metadata": {}, + "source": [ + "## Sample points as a GeoDataFrame\n", + "\n", + "We scatter sixty measurement points across a small area near San Francisco and\n", + "give each one a value that follows a smooth gradient with a warm pocket in the\n", + "middle, the kind of pattern a temperature or pollutant survey might show. The\n", + "points start in longitude/latitude (EPSG:4326)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "a4f619d6", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T16:58:16.478305Z", + "iopub.status.busy": "2026-06-24T16:58:16.478018Z", + "iopub.status.idle": "2026-06-24T16:58:16.499974Z", + "shell.execute_reply": "2026-06-24T16:58:16.499534Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
temperaturegeometry
019.455742POINT (-122.3726 37.79347)
124.637321POINT (-122.40611 37.77769)
219.570392POINT (-122.36414 37.78522)
318.705330POINT (-122.38026 37.8012)
413.011563POINT (-122.44058 37.79078)
\n", + "
" + ], + "text/plain": [ + " temperature geometry\n", + "0 19.455742 POINT (-122.3726 37.79347)\n", + "1 24.637321 POINT (-122.40611 37.77769)\n", + "2 19.570392 POINT (-122.36414 37.78522)\n", + "3 18.705330 POINT (-122.38026 37.8012)\n", + "4 13.011563 POINT (-122.44058 37.79078)" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rng = np.random.default_rng(42)\n", + "\n", + "# Random points in a lon/lat box near San Francisco\n", + "lon = rng.uniform(-122.45, -122.35, 60)\n", + "lat = rng.uniform(37.74, 37.82, 60)\n", + "\n", + "# Smooth field: west-to-east gradient plus a warm bump in the centre\n", + "xc = (lon + 122.45) / 0.10\n", + "yc = (lat - 37.74) / 0.08\n", + "value = (12 + 8 * xc\n", + " + 10 * np.exp(-(((xc - 0.5) ** 2 + (yc - 0.5) ** 2) / 0.05)))\n", + "\n", + "points = gpd.GeoDataFrame(\n", + " {\"temperature\": value},\n", + " geometry=[Point(a, b) for a, b in zip(lon, lat)],\n", + " crs=\"EPSG:4326\",\n", + ")\n", + "\n", + "# A projected copy (Web Mercator, metres) for the same-CRS examples\n", + "points_3857 = points.to_crs(\"EPSG:3857\")\n", + "points.head()" + ] + }, + { + "cell_type": "markdown", + "id": "e43092bf", + "metadata": {}, + "source": [ + "## A target grid\n", + "\n", + "The output surface needs a grid to land on. We build an empty raster in\n", + "EPSG:3857 (metres) that covers the points, with `y` descending and a `crs`\n", + "attribute. This is the \"caller\" raster the accessor reads its grid and CRS\n", + "from." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c2fef542", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T16:58:16.501105Z", + "iopub.status.busy": "2026-06-24T16:58:16.500985Z", + "iopub.status.idle": "2026-06-24T16:58:16.565393Z", + "shell.execute_reply": "2026-06-24T16:58:16.564850Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "xmin, ymin, xmax, ymax = points_3857.total_bounds\n", + "pad_x, pad_y = 0.05 * (xmax - xmin), 0.05 * (ymax - ymin)\n", + "\n", + "xs = np.linspace(xmin - pad_x, xmax + pad_x, 160)\n", + "ys = np.linspace(ymax + pad_y, ymin - pad_y, 130) # descending\n", + "grid = xr.DataArray(\n", + " np.zeros((ys.size, xs.size)),\n", + " coords={\"y\": ys, \"x\": xs}, dims=[\"y\", \"x\"],\n", + " attrs={\"crs\": \"EPSG:3857\"},\n", + ")\n", + "\n", + "fig, ax = plt.subplots(figsize=(10, 7.5))\n", + "sc = ax.scatter(points_3857.geometry.x, points_3857.geometry.y,\n", + " c=points_3857[\"temperature\"], cmap=\"inferno\", s=40,\n", + " edgecolor=\"white\", linewidth=0.5)\n", + "fig.colorbar(sc, ax=ax, shrink=0.8, label=\"temperature\")\n", + "ax.set_title(\"Sample points (EPSG:3857)\")\n", + "ax.set_axis_off()" + ] + }, + { + "cell_type": "markdown", + "id": "99e952b6", + "metadata": {}, + "source": [ + "## IDW from a GeoDataFrame\n", + "\n", + "Every interpolator now accepts a GeoDataFrame as its first argument. The\n", + "`column` argument picks the value to interpolate, exactly like `rasterize`. Pass\n", + "the grid as `template` and the result lands on that grid. Inverse distance\n", + "weighting fills each cell from a distance-weighted average of nearby points." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c8a476d9", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T16:58:16.566501Z", + "iopub.status.busy": "2026-06-24T16:58:16.566394Z", + "iopub.status.idle": "2026-06-24T16:58:16.819931Z", + "shell.execute_reply": "2026-06-24T16:58:16.819409Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAuwAAAJrCAYAAAC7lcacAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAA0BRJREFUeJzsnXmcJEWB/V/W1T3DTM8BDAhz9RyAHB4LrFwCciP3falcHqsjrCC6gCvgxaECy28XdVdlcFXUVUQRFVC55FJnEOVymGF6DoZjYO67uqry90czPZkvuiMqKrOO7n5fP/ORrIiMjIzMqo7Kei9eEIZhCCGEEEIIIURLkml2B4QQQgghhBD9owm7EEIIIYQQLYwm7EIIIYQQQrQwmrALIYQQQgjRwmjCLoQQQgghRAujCbsQQgghhBAtjCbsQgghhBBCtDCasAshhBBCCNHCaMIuhBBCCCFEC6MJuxCDhK997WuYMmUKstks3vWudzW7Owavv/46Tj31VGy99dYIggD/8R//0ewuCSGEEAMCTdjFgOb2229HEASYNWtW72vXXHMNgiDo/Td8+HBMnDgRxx13HGbOnIlNmzbF2vjEJz6BTCaD5cuXx15fvnw5MpkM2trasHHjxljZ/PnzEQQBrrzyyvqdnAf3338/PvvZz2L//ffHzJkzce211za7SwaXXHIJ7rvvPlxxxRX4/ve/j6OOOqrZXao7v/rVr3Dcccdhu+22Q6FQwNixY3HggQfixhtvxOrVq+t6bN/3gQ+/+c1vcM011yTq3+TJk2P9i/7j95sQQgx1cs3ugBD14pvf/CZGjBiBTZs2YcmSJbjvvvtwwQUX4D/+4z9wzz33YMKECQCAAw44AN/85jfx2GOP4bjjjuvd//HHH0cmk0F3dzdmzZqFAw44oLfsscce6923FXjggQeQyWTw3e9+F4VCodnd6ZMHHngAJ5xwAi677LJmd6XuVCoVXHjhhbj99tuxxx574BOf+AQmTJiANWvW4IknnsC///u/4ze/+Q3+8Ic/1L0v1b4PfPjNb36DW2+9NfGk/V3vehc+/elPG6+36j0shBDNQhN2MWg59dRTsc022/RuX3XVVfjhD3+ID33oQzjttNPw5JNPAtgy6X700UdjE/bHHnsM73jHO7BhwwY8+uijscn5o48+ikwmg/32269BZ9M369evx/Dhw7F06VIMGzaspSc6S5cuxejRo5311q1bh6222qr+HaojX/3qV3H77bfjkksuwY033oggCHrL/vVf/xWvvvoq/vd//7chfan2fdAMdtxxR3zgAx+ouv7m+10IIYYaksSIIcU555yDD3/4w/jTn/6E3/3udwCAiRMnYsKECb1PzTfz2GOPYf/998d+++3XZ9luu+3mnID+7ne/wwEHHIDRo0djxIgR2HnnnWMyms2SngULFsT2e+ihhxAEAR566KHe1w4++GDsvvvumD17Ng488EAMHz4cV155JYIgwMyZM7Fu3bpeScHtt98OAJg5cyYOOeQQjBs3Dm1tbdh1113xzW9+s8++/va3v8VBBx2EkSNHoqOjA3vvvTfuuOOOWJ0//elPOOqoozBq1CgMHz4cBx10kDE2zOZzDMMQt956a28fo2UPP/wwPvGJT2DcuHEYP358777f+MY3sNtuu6GtrQ077LADZsyYgZUrV8ba3zwuf//733HQQQdh+PDhmDZtGn72s58BAB5++GG85z3vwbBhw7Dzzjvj97//vbW/AFAsFnHVVVdhzz33xKhRo7DVVlvhve99Lx588EHnvuvXr8cNN9yA3XbbDV/72tdik/XNvO1tb8O//du/Ga//4Ac/wJ577olhw4Zh7NixOPPMM7F48WKj3k9/+tPeettssw0+8IEPYMmSJc6+baav9wEA/PGPf8Rpp52GiRMnoq2tDRMmTMAll1yCDRs29NY577zzcOuttwJATMayma9//evYb7/9sPXWW2PYsGHYc889e6+FD/3d7wDwy1/+Escccwx22GEHtLW1YerUqfjSl76EcrncZxtJ7o0lS5bgggsuwHbbbYe2tjbstttuuO2227zPRwghkqAJuxhyfPCDHwTQo/vezAEHHIBZs2b16nqLxSL+8pe/YL/99sN+++2Hxx9/HGEYAgBWrFiB559/3imHee6553Dsscdi06ZN+OIXv4gbb7wRxx9/vHOCa2PZsmU4+uij8a53vQv/8R//gfe97334/ve/j/e+971oa2vD97//fXz/+9/HgQceCKBHDjFp0iRceeWVuPHGGzFhwgR84hOf6J1wbeb222/HMcccg+XLl+OKK67A9ddfj3e961249957e+s88MADOPDAA7F69WpcffXVuPbaa7Fy5Uoccsgh+POf/9xvnw888EB8//vfBwAcfvjhvX2M8olPfALPP/88rrrqKlx++eUAejTYM2bMwA477IAbb7wRp5xyCv77v/8bRxxxBLq7u2P7r1ixAsceeyze85734Ktf/Sra2tpw5pln4ic/+QnOPPNMvP/978f111+PdevW4dRTT8WaNWus47x69Wp85zvfwcEHH4wbbrgB11xzDd544w0ceeSRePrpp637Pvroo1i5ciXOOussZLNZa90oX/nKV/ChD30I06dPx0033YRPfepT+MMf/oADDzww9iXl9ttvx+mnn45sNovrrrsOH/nIR/Dzn/8cBxxwgPFlxkZf74Of/vSnWL9+PT7+8Y/jP//zP3HkkUfiP//zP/GhD32ot87HPvYxHH744QDQey2j1/OWW27Bu9/9bnzxi1/Etddei1wuh9NOOw2//vWvjT50d3fjzTffjP1bv359b3lf9/vmMRgxYgQuvfRS3HLLLdhzzz1j906UJPfG66+/jn322Qe///3v8clPfhK33HILpk2bhgsvvFCmaSFEYwmFGMDMnDkzBBD+5S9/6X3t6quvDgGEb7zxRp/7rFixIgQQnnTSSb2v3XrrrSGA8I9//GMYhmH4xBNPhADChQsXhs8//3wIIHzuuefCMAzDe+65JwQQ/vCHP7T27eabb7b2I9r/rq6u2OsPPvhgCCB88MEHe1876KCDQgDht771LaOdc889N9xqq62M19evX2+8duSRR4ZTpkzp3V65cmU4cuTI8D3veU+4YcOGWN1KpdL7/9OnTw+PPPLI3tc2t9/Z2Rkefvjh/Z7jZgCEM2bMiL22+fwPOOCAsFQq9b6+dOnSsFAohEcccURYLpd7X/+v//qvEEB422239b62eVzuuOOO3tf+8Y9/hADCTCYTPvnkk72v33fffSGAcObMmda+lkqlcNOmTbHXVqxYEW633XbhBRdcYN33lltuCQGEv/jFL4w233jjjdi/zWO5YMGCMJvNhl/5yldi+zzzzDNhLpfrfb1YLIbjxo0Ld99999i12nxPXnXVVb2v1fI+6Ot+ue6668IgCMKFCxf2vjZjxoywvz8f3EaxWAx333338JBDDom9PmnSpBCA8e/qq68Ow9B+v/fVz4997GPh8OHDw40bN/a+lvTeuPDCC8O3ve1t4Ztvvhk71plnnhmOGjWqz34IIUQ90BN2MeQYMWIEAMSepEV17ECP5GXHHXfExIkTscsuu2Ds2LG9T8arNZxulsv88pe/RKVSSaXvbW1tOP/886uuP2zYsN7/XrVqFd58800cdNBBmD9/PlatWgWgR7azZs0aXH755Whvb4/tv1nq8PTTT2Pu3Lk4++yzsWzZst6noevWrcOhhx6KRx55JNE5fuQjH4k9jf7973+PYrGIT33qU8hkMrF6HR0dxtPaESNG4Mwzz+zd3nnnnTF69Gi8/e1vx3ve857e1zf/9/z58639yWazvX6ASqWC5cuXo1QqYa+99sJTTz1l3Xfz6i+b77PNPPPMM9h2221j/5YtWwYA+PnPf45KpYLTTz899rR5++23x/Tp03ulOLNmzcLSpUvxiU98InatjjnmGOyyyy59PsXuj77eB9H7Zd26dXjzzTex3377IQxD/PWvf62q3WgbK1aswKpVq/De9763z3F7z3veg9/97nexf9Gn+f3d79FjrFmzBm+++Sbe+973Yv369fjHP/5hnGct90YYhrjzzjtx3HHHIQzD2HU58sgjsWrVKue9IIQQaSHTqRhyrF27FgAwcuTI3td23313jB49OjYp33///QH0TFr33XdfPPbYY/jIRz6Cxx57DBMmTMDEiROtxznjjDPwne98Bx/+8Idx+eWX49BDD8XJJ5+MU089NTYJ9WHHHXf0MpY+9thjuPrqq/HEE0/EpAZAzwR+1KhReOmllwD0jEF/zJ07FwBw7rnn9ltn1apVGDNmTNV9i9LZ2RnbXrhwIYCeyVWUQqGAKVOm9JZvZvz48YZWfNSoUcYKKKNGjQLQM5F08b3vfQ833ngj/vGPf8QkONxXZvN9tfk+28y0adN69eL/+7//G5ORzJ07F2EYYvr06X22mc/nAfQ/LgCwyy679H7hrIa+3geLFi3CVVddhbvvvtsYo81f8Fzcc889+PKXv4ynn346tnRkX1r+bbbZBocddli/bfV3vz/33HP493//dzzwwAPG8pjcz1rvjTfeeAMrV67E//zP/+B//ud/+uzf0qVL++27EEKkiSbsYsjx7LPPAuiZQG0mk8lg33337dWqP/bYYzFz6H777YfbbrutV9t+4oknOo8zbNgwPPLII3jwwQfx61//Gvfeey9+8pOf4JBDDsH999+PbDbb5yQGgGGei7ZZLS+99BIOPfRQ7LLLLrjpppswYcIEFAoF/OY3v8HNN9/s9UR8c92vfe1r/YYy8RNlH3zOqy/604r393r4lh+hP37wgx/gvPPOw4knnojPfOYzGDduXK9mfPMXnP7YZZddAPTcZyeccELv6yNGjOidnPLEulKpIAgC/Pa3v+2zz0nGtj/4fVAul3H44Ydj+fLl+Ld/+zfssssu2GqrrbBkyRKcd955Vd0vf/zjH3H88cfjwAMPxDe+8Q287W1vQz6fx8yZMw0DczX0dV+sXLkSBx10EDo6OvDFL34RU6dORXt7O5566in827/9m9HPWu+Nze184AMf6PeL6jve8Y6qz0UIIZKgCbsYcmx+snnkkUfGXj/ggAPw29/+FnfffTeWLl3a+4Qd6Jmwf+5zn8NvfvMbbNiwoer11zOZDA499FAceuihuOmmm3Dttdfic5/7HB588EEcdthhvU+k2SzIT5Br4Ve/+hU2bdqEu+++O/ZrAK90MnXqVAA9E7jol5i+6nR0dFifiKbFpEmTAABz5szBlClTel8vFovo6uqqex9+9rOfYcqUKfj5z38e+1J19dVXO/d973vfi1GjRuHHP/4xrrjiiqp+TZk6dSrCMERnZyd22mmnfutFx+WQQw6Jlc2ZM6e3vBr4ffDMM8/gxRdfxPe+972YLCW6isxm+vuieeedd6K9vR333Xcf2trael+fOXNm1f1y8dBDD2HZsmX4+c9/3muuBoCurq7UjgEA2267LUaOHIlyudyQe14IIWxIwy6GFHfccQe+853vYN9998Whhx4aK9s8Cb/hhhswfPjw2JPkf/7nf0Yul8NXv/rVWF0bnJwKoLfNzVKBzRPhRx55pLdOuVzu9yd4HzY/QYw+TV61apUxeTriiCMwcuRIXHfddUbC5OZ999xzT0ydOhVf//rXDakH0CMfSJPDDjsMhUIB/+///b9Y/7/73e9i1apVOOaYY1I9HtPX2P3pT3/CE0884dx3+PDh+OxnP4tnn30Wl19+eZ9P8/m1k08+GdlsFl/4wheMsjAMe7Xue+21F8aNG4dvfetbMbnJb3/7W7zwwgtVj0tf74O+zjkMQ9xyyy3G/pvXyecvmpt/NYr+QrRgwQL84he/qKpf1dBXP4vFIr7xjW+kdozNxznllFNw55139v4aESXte14IIWzoCbsYtPzsZz/DiBEjUCwWexMeH3vsMbzzne/ET3/6U6P+P//zP6NQKOCJJ57AwQcfjFxuy9tj+PDheOc734knnngCo0ePtuq9N/PFL34RjzzyCI455hhMmjQJS5cuxTe+8Q2MHz++d8K/2267YZ999sEVV1yB5cuXY+zYsfjxj3+MUqmU+PyPOOIIFAoFHHfccfjYxz6GtWvX4tvf/jbGjRuHV199tbdeR0cHbr75Znz4wx/G3nvvjbPPPhtjxozB3/72N6xfvx7f+973kMlk8J3vfAdHH300dtttN5x//vnYcccdsWTJEjz44IPo6OjAr371q8R93sy2226LK664Al/4whdw1FFH4fjjj8ecOXPwjW98A3vvvbdX2E4tHHvssfj5z3+Ok046Cccccwy6urrwrW99C7vuumufX1iYyy+/HC+88AK+9rWv4f7778cpp5yC8ePHY8WKFXjqqafw05/+FOPGjes1jk6dOhVf/vKXccUVV2DBggU48cQTMXLkSHR1deGuu+7CRz/6UVx22WXI5/O44YYbcP755+Oggw7CWWedhddffx233HILJk+ejEsuucToS7Xvg1122QVTp07FZZddhiVLlqCjowN33nlnn3r/PffcEwBw8cUX48gjj0Q2m8WZZ56JY445BjfddBOOOuoonH322Vi6dCluvfVWTJs2DX//+99rvRwx9ttvP4wZMwbnnnsuLr74YgRBgO9///tOmVMtXH/99XjwwQfxnve8Bx/5yEew6667Yvny5Xjqqafw+9//vs8v5UIIURcauyiNEOliW9Zx87/29vZw/Pjx4bHHHhvedtttsWXfmH333TcEEF555ZVG2cUXXxwCCI8++uiq+vaHP/whPOGEE8IddtghLBQK4Q477BCeddZZ4Ysvvhir99JLL4WHHXZY2NbWFm633XbhlVdeGf7ud7/rc1nH3Xbbrc9j9bes49133x2+4x3vCNvb28PJkyeHN9xwQ3jbbbf1uZTk3XffHe63337hsGHDwo6OjvCf//mfwx/96EexOn/961/Dk08+Odx6663Dtra2cNKkSeHpp58e/uEPf3COByzLOkavX5T/+q//CnfZZZcwn8+H2223Xfjxj388XLFiRaxOf+MyadKk8JhjjqmqH0ylUgmvvfbacNKkSWFbW1v47ne/O7znnnvCc889N5w0aZL9RCPcdddd4fvf//5w2223DXO5XDh69OjwgAMOCL/2ta+FK1euNOrfeeed4QEHHBButdVW4VZbbRXusssu4YwZM8I5c+bE6v3kJz8J3/3ud4dtbW3h2LFjw3POOSd8+eWXY3VqeR88//zz4WGHHRaOGDEi3GabbcKPfOQj4d/+9jdjucNSqRRedNFF4bbbbhsGQRBb4vG73/1uOH369LCtrS3cZZddwpkzZ/b2JUp/12cztvv9scceC/fZZ59w2LBh4Q477BB+9rOf7V2WsZr3jM+98frrr4czZswIJ0yYEObz+XD77bcPDz300PB//ud/+u27EEKkTRCGdXgsIYQQQgghhEgFadiFEEIIIYRoYTRhF0IIIYQQooXRhF0IIYQQQogWRhN2IYQQQgghWhhN2IUQQgghhGhhNGEXQgghhBCihdGEXQghhBBCiBam6qTTz46/2Fpe8VjN3bXyewVBomPZinlfV7ddx7KVp73APR8rYx8mK65dXW37HDtBN/vE5/q6rrd3Obdv6QvD344DGpisYzuX6b88H8Q7lrXU7dkOvcpzlvoBlfF5ZjP2ctf+GSoPbGVGPz3bdtS31+W27MdieH/X8XzarieVMO13eP+4zpPH3NjfuEZ0DY17rfoxdx7bca8Z9S3Hdu3rKjeO5VG/nm3X0n6ax7ZhuxcajWuM/vmhXzeoJ6KR6Am7EEIIIYQQLYwm7EIIIYQQQrQwVUtiGKcsxVJeT8kL7+8reUnz2Gnu2xdlS32XZMX1I3aSvqYpp3Edi8t9JS9l0rSwxMXcP+y3nO9510/kWapQpvp5+jodcuci5QFfUep4QG1lqD6fF6sc+D0b/Xk4w5Xp59qQyissQ3CVo3Zcx+YT5WOl2ZeBTBLZC1+DRP1wlLtkSXwfZ/jzn9uLSr9aSBKRlMEigUlbCtbIa5ym9EcMDYbq3x8hhBBCCCEGBJqwCyGEEEII0cJowi6EEEIIIUQLowm7EEIIIYQQLUzVptNGmkyTmjOjxUlNpUn65l5vvn6wIdX1zYzNWa7z5CsaNWf5rl3vMqEmud4uk2mJKpTpovE15PpRs6bvebnWXTdGmS5iEDkXw1Qa2E2lfO/xobO0bZybZWfjvjb2tRtBzWOTUTAI+y/jfR1ti77xMZm6TKWuz38vjOttv69dJtSBQtrrric9XpSBZDKtp6lUJlJRb/SEXQghhBBCiBZGE3YhhBBCCCFaGE3YhRBCCCGEaGGq1rC79dj9iwPTDiNy6cyT7OvTNmCOS1RD6QrdYXyDk2ywfrpM5Ry0w9/cXBp4m+bdpm/vCz4WV08SlOWrWee+uMorkXKXdpvJBbztOnMKL4pcFA6AyTq8G4Zm3chdCqictcJbylkX6gpC4tPiY/uEHflqWp0hTl6t1ZdW1cQaY+j0KJGfIsFpGW8Rtnm4gpBY804N8v4cAlZPuG+ptp3ieQwVzXoz339pB0KJwUEr/X0SQgghhBBCEJqwCyGEEEII0cJowi6EEEIIIUQLowm7EEIIIYQQLUzVplPGNwwpirex01E/ybGc5Q4Tk81YmrStNGHjpytQhOvz9eZvetFzc4UwubJLjGMnCcoy6tqDkVwm05JRHr3e1DYd27CUGoNOo1rpPzCo59hbytlkysc2jH4Oo6cxTpaLZtzXhhHQYfRMUk5lhuGZtr1Dmqi8kSZEG2mb0lxBSa5wJFtb5uee37Fi5j/XZyq9p3L0CcCfB2ymZqLn4qrL1NM42MigpEaaTH2PlzQIqZ7GUhlHRdroCbsQQgghhBAtjCbsQgghhBBCtDCasAshhBBCCNHCVK1hb2XNuq1+PTXqgBnM4xOc5DoPhjXSNjKk5WQ5HevEA9buUjnrN42eRI7nDC9xyGGT3B/G9XRtO45t06zzdik0opNi8DXhEwmobVeYUehxnzuNA57E2jfCZzicBlQef6HkCF7iGypa7go+cgVAGdpsl6Y52pa1ppt6BuXUE/5b4KtZN4OXHESDsrgv/DnFn7F0bC53eTvSxFcvXc/AoVYK5RoomnVp0kWz0RN2IYQQQgghWhhN2IUQQgghhGhhNGEXQgghhBCihdGEXQghhBBCiBam9uAkD8NkI02mXO5rMmVToWv/ksVYyqE7bBo1Qn0c5UlMp/zNLOCAEYf3zggkYUNkZIesEV5CdY2+xrdb2dpjXsO+e9sdbsSYvYro3Hk8uua8jOWz8ihgWKwOj1MS6uiVA9BHoFDkepsG12QmVDaS8g7R6mz8LNF2zmEy5WO5gpdsbdU7VKmepjdu2xWk5IPLZOoVyuQI1WJjf9I3Rl3HPMVPurT76WUErWOglK/JtJGhTb60ktFXDExqnrALIfpnzF5F/OwPt6NQKKBYLOLUQ8/D2tnD3DsKIYQQQhCSxAhRBzp3Ho9CoQAAKBQKmLzT+Cb3SAghhBADFU3YhagDXXNeRrFYBAAUi0UsePHlJvdICCGEEAOV6oOTvEN++i+rp2ady5Nq1k0dun3/6LbRtuvYRrAShxV5aP8MzTHriuPbZSpnfTUfmbezMbGoPY3EV9OeBJc+nq8v1+cQKB7H2CWKFK2a3YbTDjsPk6ePx4K5L2PV7Da0BfHvx06fAfgaUnnQf1maY+jC+X7m8zD2Zx25/d6Lv8LBOHzsODwsHKTEuIKX0kQa1x7Wljbi+c4Kxk0Zj6XzX8auXRmMyLXX5Vgp2kgSY7v+Se8N1/6tolkH/HTr9e5LmscWIinSsAtRB/JBO9bNbsdzs9cAGIV8C00MhGhlnu+s4Oa7v9fr/7jk+HPxz4ub3SshhGguksQIIYRoGcZNifs/xk2R/0MIITRhF0II0TIsnR/3fyydL/+HEEJIEiOEEKJl2LUrg0uOPzemYddfKiHEUKfqj8GBYjIF4kbApCZTd/3+TaclLgPXjfeuROVsxqvQ2fQX2gMAGTb6hfEfU7L040qWzHU5MkiG7M7KmNbBLfQfsgMAJT4WteRrQo2WG/s6DJBsIjRNho5jW9q21e1pO14/n+FrYK+ftZhOuSfG5fPU1Jvm7dpF+Xxfl6kt9nJx+FH02Fk2rDrGwbhrjeAdoonGMj8jYLJj8fU1gpSiZXZPOco0pmzOcwVljci192jWFy/HZAxHkA+x+cqYAXD268/hRK4xtRkJeV/zPcXldOwUQ4CSnIcvQ9VkmrapVCZVkRRJYoQQQgghhGhhNGEXQgghhBCihdGEXQghhBBCiBamZiuPTbMOxLWgrrpJsYUjufTyrmAkl2a926phjyuqu0lhXUY5tl1ylLPWkzXtUTL0XYx1o1mKmCnQrRDyoHIkTYWOHdG0s5y2TFWzGT4Pe/iND6zNNjTtxh72pCQeN9bvRrX/rtvcDO2xa9YLWda4o99t1tqz7tulWffVV9p8Ii5Y42zqkulYVG67PzKOC26GU1HbA0RnmnbgjzHmFk27yydiDDLtUDHecmw8qD5AiK+XS0fuq3H30Vf70kxNc5oBQmlr1n3GJel5JLkG0qSLRqMn7EIIIYQQQrQwmrALIYQQQgjRwmjCLoQQQgghRAtTtYbdR7Puqp/2uuu29nnNZ0Pv7rGuejXbUd06a9a7UbJul4K4Zr1slMe3Q4t6OGANO62rngvjl74c5mPbFdC2MeZxJXEQGQdj7WteP7yP/kYx5PMu/bWlzLmGu1GfNeukmeV1uy1abpc2m/uW53GiBsx12fv+77725XLXN3UfXTqvZc77+npYeFyMtfBjomm7Ht5Yh5810FSf+57ET8GwXtpYp9u5tnb1bfvCPhKbpt22Rjvg1rQbp5lAs+waU/bLuOqzvjp6vKGy7nrSvhhtNVGz7jsuaY5jxngjCJEMPWEXQgghhBCihdGEXQghhBBCiBZGE3YhhBBCCCFaGE3YhRBCCCGEaGFqDk7ysVOkaSIF7EFJrn25rmFK5f1pu0QHr9Ae5cg2Bx8ZptOgO7ZdDIrUlt10WkZ8/ygcnBQYQUmF2LYRwuS4Jmy+jG7zt0Cuy9fENKnaj+1b37YvZ7awydBmMgX8zJnGuDiMobzNwUnR8jwZnFwmU9MgF8d1XlGjacnx/ubgLBds7qtY3Zb28zY/O+h61jE4JXmoi6XtlAN9XO3ZroGxL5sxjaCs2lOfXEZdVzCSGbwUvzlt7SU1mZohTo0zJTbStJpm2FQrmUxlIhXNRk/YhRBCCCGEaGE0YRdCCCGEEKKF0YRdCCGEEEKIFqZqDbtLvWVoxRPIvXx3NTXyW14wQnicbXHQkl3jXg7jGshyRP1bIiUwByOxJr0bcQ17d7CJjhXXrNs07EyWgpBC6gvDGvhsGFd3l1m7HxmnLAlJzfAqEprWLmk1cDVlhPAQfH1d9aP3XlLtvUvDnjNCYfqva+jlPbWdvH/ZEo7k0qyXWDfuOLYZVkRa4Uh7WUOj7jBI1BGb5ryn3E9/zfjo1n21vMZ70uPYVo8BzHvPuEYOfLT8zjG2BCP1dax4cFIyzbovNv12K+nffUni/ah3EFISnXoQeJp1hPBET9iFEEIIIYRoYTRhF0IIIYQQooXRhF0IIYQQQogWpuZ12IUQQgghhKiWjRs3olgsuivWQKFQQHt7e13abgVqnrD7mEp9g5KM/ROE1TC+5ljXsbg8GkDEwUkh2KBKQUgUpMQm0xLsJlQbIQeEkLWvRH3JG30t03a8vJLijzVs/HKZNQNLmU+oUlJch7L1G7CbSvuuHylzBCG5DI2MyxcYfd+Y4WR2k6nv+7+ePwMa95ajfib23w7zXMIAGdv+aZsOfdpjg6r3eSZ4T7pMpeahajeZ9nU8n775lqdt7mwUrqCkVjKZ+phKk5pIG2kMdpnGW4WNGzeis3N7vPbaqrq0v/3226Orq2vQTtr1hF0IIYQQQtSVYrGI115bhQWLb0FHx7BU2169egMmT/hXFItFTdiFECJNNlY2YMPu6zF++o54ee4SDHt2ONoz6X6ICyGEaC1GjGjDiBFtqbZZqQz+ZTU1YRdCNIUNu6/HzHtvQ6FQQLFYxPlHXYD25zVhF0IIIZiqJ+xOrXeKQUlJ2kpjf2vbCXSpFUP3bd9mzXvFoYmvhFvKM0Fco877RusCQCWw98XntM1glHT1dTZNu0sn7htu5MLWnhnqYt/XplHv2b9/nbpTi9t/NwH08R6kPQwtcKTcDBNzHOwtxk/fEYVCAUCPWWjHaTti/fMb65p15A4vqr7cV//s1E+nGMTjq4eueGhgXf1w6Wm9w2xsGmeHRt08tr1tW99cIU3msQamJt1FPTXr3n1JqFn30am38vVs5b71RRiWEIYld0XPNgc7WtZxEFEJS3jnnm/DqWfvjz323A6VIXADi4HLy3OX9K4WUCwWsWTekib3SAghhGhNJIkZRLx7rwm4/w+/7JUYHHHYiXhm9uvN7pYQfTLs2eE4/6gLsOO0HbFkXo+GXY8QhBBicBOGZYT0K38abQ52NGEfREzfeUpMYjB9eqcm7KJlac8MQ/vzw7D++Y0Yg601WRdCiCFAJSylrgAYCooC/YkcRMydMz8mMZg7t6vJPRJCCCGEEEmpW3BStLieJtCeYw0Mw0WGvh+5tgOjPG4kZdPp32a/giMOOxHTp3di3twF+PusV5EJcn3ua/QttH93M/vWv7EscKT0uMyXSbazCU2nLqOoUd9S7jq2GW5kDz/KkoHK1jXfwCh+j5rGMG5wSzkbFrOOfV1d4wCpHA1EtH0+Fl9/HjNu2x04xeXVmxLTNpnWM1iH2/YxoQ4mk2mSsKpmBuWkfexmhjjZzqXeJtMkxxbVI9NpbUgSM4jIBDk8M/t1PDP7dQTI9E7WhRBCCCHEwEUzOiGEEEII0RB6TKdpP2Ef/KZTadiFEEIIIYRoYVJ7wu6j7koalFRvTXwU/kaTIQWuWb7llSzpxksUXpSl4c+G+dg2hxmFYXw7COJHj2raWf+eRbztfBCPBc6F8b7kw0L8WMZ5k245sm3ogHlfh5abcWnBo7plt248WZiRPSiJ9nXqo7ltu0bddS62tl1w31zBSbHekW40w5p2CtJyqePN6xvfoxA5Xp6Ozdumxt2+zdeAy6Pjmgv4/ejQ19ZRs87XJ6xj/JRLs+5b36kN9/jrkqZm3dW3tDXNNt9AMzXlLpIGJaWpWU+iUXeVt/I18PGctAJhpYSwkvIT9pTba0X0hF0IIYQQQogWRhp2IYQQQgjRGMJSz7+02xzkaMIuhBBCCCEagpZ1rA1JYoQQQgghxJDhuuuuw957742RI0di3LhxOPHEEzFnzpw+64ZhiKOPPhpBEOAXv/hFYzsaoeon7I00hpJHDXYbSbpkyLVUps6wtSNLxs/oeefo+1A55OCj+PBXgrjRk/1QGT4WjYyP6bRAplI2mRbIAFtggyyNRC4ybtnAbjJlEyobxTj8xmUEjW67DIu+plIfI6k7ZCmZqdQM3um/X95Q28Z7kI8dKc9SXQ4yY0MUt+0yCvL9kI+Us8k0l6n0W7enLXuQknG/WIJ6XCZR07DqZ87zMVsyrn19TalR4ygbkpPCWTf8eR8PRmOjL9f1G3OmVYNz+D3E5+kbpORzLknuw1qObTV+1tlkag3taiHTKV/vVjbE9kmlBFS602/Tg4cffhgzZszA3nvvjVKphCuvvBJHHHEEnn/+eWy11Vaxuv/xH//hDIRsBJLECCGEEEKIIcO9994b27799tsxbtw4zJ49GwceeGDv608//TRuvPFGzJo1C29729sa3c0YmrALIYQQQoiG0KNhz7orerYJAKtXr4693tbWhra2tr52ibFq1SoAwNixY3tfW79+Pc4++2zceuut2H777VPsbW1Iwy6EEEIIIQY8EyZMwKhRo3r/XXfddc59KpUKPvWpT2H//ffH7rvv3vv6JZdcgv322w8nnHBCPbtcNTU/YU8SlNRMWCfMfSsb+lp7UBLrcaPa7goFJ+VZDxvGW2PdeY4uTwlxjVbooe7nkCaXZj1v9D3etzzp6bMWDbtLk+6tK7ds+2rWc1yeIOwoqSad8dHP2wKdaqFCfeVnIdFxZj2leVf6fQLwefM1jerWzbL40X3LWSOdNYKYtpT7atadATKOcfLRqfoGqZg+A76mQaQs2bH4PCr8eVHHvxjmezA9rbcvPgFU3A+Xpr2eJA1K8mkvqWbd2zcyQDTsA55KCaik+4R9s4Z98eLF6Ojo6H25mqfrM2bMwLPPPotHH32097W7774bDzzwAP7617+m288E6Am7EEIIIYQY8HR0dMT+uSbsn/zkJ3HPPffgwQcfxPjx43tff+CBB/DSSy9h9OjRyOVyyOV6HnqecsopOPjgg+t5Cv0iDbsQQgghhGgMdXzCXi1hGOKiiy7CXXfdhYceegidnZ2x8ssvvxwf/vCHY6/tscceuPnmm3Hccccl7m4taMIuhBBCCCGGDDNmzMAdd9yBX/7ylxg5ciRee+01AMCoUaMwbNgwbL/99n0aTSdOnGhM7htF1RN2l3qL11231U+yRnvaGGuCU89z3mtvRlRGxnnGhzuDcvzYpEssGzryuO6c12GPt016eHJkZw29fLy8wMcmzXo+w9tb+s66cJemPcm660Bcl9pIzTq3z2t629ZN7+vYDNc3zi2yv6+2zXVsl76WEwCS4KPVB+Ja8WxizbprLfVKv+W+mvU0NeouDJ04r9Nt9KX6zzkfvXtfhCSC52torBHvs2a4Yx39RGuAO/b11fL74LvOui9J7j2nN8Ozbdat+7SdVLOeRMPu0+++qHDYxaCmDKSeTFp2V4nwzW9+EwAMecvMmTNx3nnnpdSndNETdiGEEEII0RCCSglBJV0LZVCDJMaXWvZJE5lOhRBCCCGEaGH0hF0IIYQQQjSGSglI+Qm7r+l0IKIn7EIIIYQQQrQwNT9h9zGOuuo2WRYUg4193HfjG47VlJqhLTKVkpGIA0NCujyVsPqgJDadsrk2BzaC2oOR8oZxtP/tLA2SaUKNb7sCh7i+zdyZ1GTKQTk+YUi+JlMfU6mrPdc3b29TWR1DQlzWKjYh2s6b7wVXEBJfo5xRzobI/k2MviZTtznPWpwINl+6gnf4syn6Ge0ymbrMl/U01/qSZgiQy+hbLau6N+HR7dsxdvJELO9ahP1f24TRhYJ7xxQJLPe5c98UTagclORtYPU0mcY+Ux0mUleIky+ZTP+f4mxI5X77hHC1BHrCXhOSxAghhBAtwqPbt+Pan9+BQqGAYrGIK086G8csb6GnWkKIpqAJuxBCiFRZU9qIv08Kse2UiXhj/iK8Y2GAkbn2ZndrQLB150QU3nqiXigUMLZzIrB8YZN7JUR6BGEJQZjyKjGpLxPZemjCLoQQIlX+PinEjb/8fu9T4k+f8EHsv6TZvRoYLOtahGKx2Dt2y7sWNbtLQogWoOoJu1OH7nFQl2Y9TWWYoSt25IW4tJ1GqAefTOSA/P2xxHr4gMOMWAPJna0+yjdDJ876eVPrbdeo5zOu8sh/c1s0EKzVzlG5M0jJUu6rA0+iWee+1lOj3nd7EZ0p7KQdbhJr27O+z3m56rs06j5BSH3tb6ufVKOeppabMYKSHPcxf74b2t7IHWbcK33oZ7edEn9KvO2UCci88kY1Xe/j2P37RHyDkpJo1n11w7Vq2g94bSOuPPnsHg37gkU44PWNQL6tqn37O3bSUC/bvklJEjjkPC/P7WhfXPr5pOFVZhhWud8ym74dACrpyunrT6UCVPyCjqpqc5CjJ+xCCCFS5Y358afEb85fDECSmGoYlW/DMctCYNlbMhjPyboQrU5PcFK6Rlnf4KSBiCbsQgghUuUdCwN8+oQPYtvOCXizazHeuQj6ayOEEAnQR6gQQohUGZlr79GsL3kTuwTt+ksjhNhCpVyHZR1Tlti0IApOEkIIIYQQooWp+bmHy24RNTElNZn6hDTVGzP0h82dW+DzCsgxFdLAcACJ00lowTQw9t9PwB6EBPQRfmQYRfsPTuIxcwUnGcZPw9zXf3uGgZHb9gxtsplMe9rrP7zIZTLlkB+n+dJRbjuWy9DKJAli8m3bbRzs/9guk6HLVOq9f6S+s+06Gn1duK4ff9bwOFg/lckAlwnjT7Zc5kpbGBVgjlvseic0maZ5TbxDfIwGqjelNvpeCixj7nts/+ClSuS/k4U2+ZhM+dgZCnALEphj+8TLIxmvHNKSiEmMu02hUgJS1rAPheAkPWEXQgghhBCihZGyUAghhBBCNISgUkaQsoY9kIZdCCGEEEII0UyqfsJuKBxdQUqW8qSa9dArpskP1h2zrpCPbdbf8t+sAzc1jPFyMyjJDw5Lih2Kto2+OXTmPvWdmnRHMJIrKMnUuEfr+umKk2jW+djmmFQfANRX31yadZt+3vdYjGt/e91kAUI+unJfTTrjCpCx6dSTantd45QI1kdbvDY99a27x0JJag0E6m9/HnND4x6pbwZl1VeznmZIkOvvHn9e2Eg7GMln3JJq1usZlOTCplnvKY/o5426yYKTjKCkbNh/uVPfbte0tzxhHVaJCQf/E3ZJYoQQQgghREMIKpXUJSzBEEg6HWBfy4QQQgghhBha6Am7EEIIIYRoDJVyHZZ1HPySGD1hF0IIIYQQooWp+gl7K5tMbfsn9HE6Tahm/eoPyP1mY6cL7lsUI9DJMOfRsekF3p+Dk7irUXMmGzVznkFKrqAkWyCRt5HTEdLjNm9u+e+kJlPf/b3OO3GQUvXmS7fp1C/cyNaXpGa7JOFH/mbb5oWbGD4/hynVCPWKDIzrM5A/c53X03mv9n+93fdSeqbSpNePx5RNiD7Hc5ppE5qvffZNChs/02279vekM4Qp49lvMlm6rv9gpmdZx3TPX8s6CiGEEEIIIZqKNOxCCCGEEKIxSMNeE3rCLoQQQgghRAtT8xN2lzbcpu6qp2YdSK5bTwJrv22wdtsXm4bd1Cjb93WFPNk067xtaMy5Ldp26siN+v3j3NehxTe04M79LXpqY9/0NOtc7t+2p27cQ1fs1IWnGeLiCDoy26a++GqeLedtHssz1CWBVtilK+e+sH42C3t5VPPu+txiPTzje/1jXg3fwK+Ur5FP20589POeIVtJtfs+45J2UFKSa5JUb89hST64AsUMzbstOIiKwjK1ZSabVdPFlkEa9tqQJEYIIYQQIgErNpVwZ24HjJo4BasWzcdJ3a9iTJumWH0iSUxN6G4SQgghhEjAnbkd8Lkf/gKFQgHFYhFfPuckXIilze6WGERowi6EEEIIkYBRE6egUCgAAAqFAkZN6ASWaMLeF0ElRFBJV8YTuLTSgwCZToUQQgghErBq0XwUi0UAQLFYxKrFXU3ukRhsVP2EnY2cScKQGmkqTfodrpFf2mwmUsD97SqwGj/9gpRcJlNbmJEr6Mh5nr71Y3X9AoAYXyNhpp//7qsvhvnW02Sas5nxnG37BQSZ9fs387lMpd5GQA8jadJQHqO+R+BMI419LnxDeVyfi7a+udpmA6tP24BnWFULGX99jaFebacYAFVL+0OFMKKrDrJ+Y3JS96v48jknYdSETqxa3IWTu18BIhr20BGcFN0O09Z3txqVcvo+WWnYhRBCCCGEjTFtuR7N+pKlPU9QZDgVKaM7SgghhBBCNIawDk/Yw8H/hF0adiGEEEIIIVqYqp+w+2rWbTr1tIOPfL6otZKROE3NOreXVLPu0pHbAolcQUmMK+zIrF996I/vGLuCkmxacZdm3dSJ99+Wb7lLs57N2MuThB85900YbsT4aJyNfT006n2VJzp2A3XCrs9E12eLLYgpqd45ie7c15Pge2yjLwl06fUeJx8Gqkbdt9+sC3ftb6vv8mpYg4/qjLNvLU4QVhCkfA5BOLDCo2pBkhghhBBCCNEYZDqtCUlihBBCCCGEaGH0hF0IIYQQQjSGSgVIe+nKlIOYWpHqNewu3Tlp/azrsDva8h12H126aw34NGEd+UDC1XObNtytG/fUnXrU9dbLJ1zH2dY3l97WpVn30bzzOtxJ1lXvqz3rOuwN1Kj31ZfYvp5rgPvqzm2eBdexXG0ngTXnrnXZ+TOWy7lvNk27C99xaqZPwKZZb6YmfaBq0PsiCGqfWPmOoan19tC0czcT6hFcuvPo2uu+GvUwlFhiKKAn7EIIIYQQojHoCXtN6GuZEEIIIYQQLYyesAshhBBCiIYQVCpIoIzqt83Bjp6wCyGEEEII0cJU/YTdZdY0gpMs1X1DmHz74tNW2kQNl+4xs4cbpex5seIyitYT32P7jIO3wdXRF5v5ywiMcplKjWP7mlT7N0C6TKaJg5Qsx05qKk2TNE2mXO5jlgTcITw+xkI2pRkmU9hNpnzvuUyofbGqexP+uF07tu6chGVdC/He1zdiVL7NuZ/3uHkEKfmS5Jp4hzC1sHHUdr1bud++VEg3ncm43gn9F/F7LCm2azDQg5IMKpU6rMM++J+wSxIjhBDCmz9u145rf/4jFAoFFItFXHnyWTh2+eCZ3Akh6oQm7DUhSYwQQghvtu6chEKhAAAoFArYevKkJvdICCEGL3rCLoQQwptlXQtRLBZ7n7AvW7Cw2V0SCVjZXcTvx47EmM5JWNG1EIctX4PR+UKzuyUGI3rCXhPpBSdRuW3oDL27pz7eOLa92NG2S9Pqpx0rR5pzhw/Zw0mcmnbLmGc9JW88xr77DxR8f1Jy1Y9ew6RBOm7Ne/9acV8NehLNOpfzWyTpODgDRiLlaYfZOMfBcr15jNLUajOuMeLPEg5xK9Pd5VLyRss3t/3e1zfiypPPwtaTJ2HZgh4NO/Jtica0LxrpebCR5vWrpb4PtWiefz92JL74s5/0fgG76tQzcOqaTd7tZPgPk4NW0sjHA4iaNwF0fwZKHDEU0RN2IYQQ3ozKt/Vo1pcv6HmhCsOpaF3GkMRpzORJwDMvNrlXYlASltNfESQc/E/Y9TVNCCGEGOKseEviBADFYhErJHESoqXQE3YhhBBiiHPY8jW46tQzMGbyJKxY0KNhhzTsog4oOKk2NGEXQgghhjij84UezfpmGYwm60K0FNUHJznkRvzdJipP8g5dcvTFZRRN83uW61iMTWPEBlZTwsXhJ3HYOMab2di+dkOrbd++js1w36MGWV8D60AyvPqFNjnKHSZTM/Sn//3dxj572y4DpRG0ZAuQStlEZty70X4YB08vGAkAspn4p0l0XHzNlEZ9T3OeDQ6ECWjMDBMbh8DwDVKJj2zc0O4bRtY4k6lp3K+fAdLXRO6L7f7g6+17bL4fkpy36z4OPB+lpnkNXJhBSlvaM42d9vPw7cugC0PyQavE1ISesAshhBg0rOou4sFthmPsW8sTHrJsHUbpabEQrYMm7DWhCbsQQohBw4PbDMeX7/xx7/KEnz/lTJy0urvZ3RJCiERolRghhBCDhrG0POHYzolN7pEQIkYlfOspe5r/Wmc9/3pRfXCSq9wShpRUo87HDhuoYffF1jNbGAng1ri7gpZsOEOaqD73lY/EOvNoX52adWot6xl9xX1j/b0PSb+xRs/Eqc3lfZ31ay839O6W4CPAHozUZ31L3139Zvh+cBF7+zt2denIWaPuE4bkGpNslvTvAW/XHrRkvH8zds16uRx/l/CxyqRZD0iXHEYG2udzpy+cAUSGl8fvc24FJbAu71pUUz83t9fbL08tvtFWip4F37YMj0MC7XdSzXorBSWlyZDWpIuGIEmMEGJAsLq0CU+8LY+tOydiWdci7PNKN8YUpE0WcQ5Ztg6fP+VMjO2ciOVdi3DIsnVa8USIVqIS1kHDPji/CEbRhF0IMSB44m15XH/XD3ufnF5+0jk4+s1m90q0GqPyhR7N+t9e6nlBk3UhxCBAE3YhxIBgm86JMW3y1p0TgDdfbnKvhBBCeFGpAI6lSf3bHPxP2GU6FUIMCN7sWhSLTl/WtbjJPRJCCCEaQ/WmU4up1FWfa/qaSt2GV3vgULythGEWDgOUra/87cgYF2d9MmumaUKlttlXxE2b1zTatr2uC9e4JDGZukjTEOXblm+gjM0AycZPwzDnMqG6gpYsAUIMl7M5i03Hpsmw552w/6tFXHHS2b0a9v1f7Ua2kI/VzGXL8bY5+MgzMMpWP8OGVQ6Xyvj1xSdoiU2EPKYVNpHy+71ifxcZ7UW2jQC3OsPXJNW2PczVzvdnygFCaZLJpPdsLu0gJKuBvY7BV+62Bv+63k1DT9hrQpIYIcSAoCPfhqPexFsymAyQb0Nz14QSQgjhjUynNSFJjBBCCCGEGDJcd9112HvvvTFy5EiMGzcOJ554IubMmdNbvnz5clx00UXYeeedMWzYMEycOBEXX3wxVq1a1bQ+a8IuhBBCCCEaQ1ipzz8PHn74YcyYMQNPPvkkfve736G7uxtHHHEE1q1bBwB45ZVX8Morr+DrX/86nn32Wdx+++249957ceGFF9ZjRKqiakkMa9ZdYUhRXbmvRt2lSXfp0KP7u7T2vpQd5VF9Jwchcd6TW7PugsIwYnv46cOM2qxhDq3FMd063xtct2+Fsq0zgwNTZ27HFX5kq+s6tvNYHrpTn8AfAAgyfh+sedqOtm/owh0adMbnPHnbV7POmncOVuL9M9n+xyl0atgpKKkU3y4b5xW/G42gpUj7jQ6ISRrUFCXN623u27ryrHr2rd5enboeK0GYVdoBUD7vK76eYahnr77ce++9se3bb78d48aNw+zZs3HggQdi9913x5133tlbPnXqVHzlK1/BBz7wAZRKJeRyjVeUS8MuhBBCCCEaQ1gHDftbT0RXr14de7mtrQ1tbW3O3TdLXcaOHWut09HR0ZTJOiBJjBBCCCGEGARMmDABo0aN6v133XXXOfepVCr41Kc+hf333x+77757n3XefPNNfOlLX8JHP/rRtLtcNXrCLoQQQgghGkMdV4lZvHgxOjo6el+u5un6jBkz8Oyzz+LRRx/ts3z16tU45phjsOuuu+Kaa65Jpbu1oAm7EEIIIYQY8HR0dMQm7C4++clP4p577sEjjzyC8ePHG+Vr1qzBUUcdhZEjR+Kuu+5CPs+uqsaRIDiJy/s3krpMpmWjnA2ubEJ1mFYt5ry0TahmiEjEpEQmEtYf8b45qmGeVxyOPslFnIM8puzk5L6UjXGx12d/TPT+sBlSgb5MxGSepb6bJlUy3EVaNPplNeb20TY1wAZJ3yAPH2ym0j7re5izXEFJtsCYvvpmC23yCaMBgCwZqLjcCEOKbLuMX2y+5MAhX6ImNTaJmkFHdpNpNluKb+f6P08XbBItlxwGyXK8vMTllqAl1ximbUrlgLg0sYVTmXXtjwTTNiHaSHuM69n3Vmqbr6/tmiYJfKoGvoa29hpt9K47LbAOexiGuOiii3DXXXfhoYceQmdnp1Fn9erVOPLII9HW1oa7774b7e3tafW2JvSEXQghhBBCDBlmzJiBO+64A7/85S8xcuRIvPbaawCAUaNGYdiwYVi9ejWOOOIIrF+/Hj/4wQ+wevXqXkPrtttui2y2npnrfaMJuxBCCCGEaAg1LJteVZs+fPOb3wQAHHzwwbHXZ86cifPOOw9PPfUU/vSnPwEApk2bFqvT1dWFyZMn19rVmtGEXQghhBBCNIYWkcTYOPjgg511Go1HcFIcm2YdiGuofYOQyvRVyaVRZ116yRJv5NrXhalZjxPVV7PWOkNK8CxthyFpWAMur7qbVazXyfr5OCHp6UqmODxGNnJA816xHdkdpOQ4tKHlTxNDO2jRZ3O/k66Z6tJ+x4/lGV7kClryCCByadZd4UZcnjO03HGFdc6iYa9UKADIERDkGzgS1bwaWnw+T0MfbQ9GYs06a9qjx+Z+u/S0Lg0sl5dpHKN9D4xAOL/It6Q+Ah+Shh353PdpU0/dcpp9T9pWPYOSfIORbIFwQYKQpT6x3HoufbtZ3rqhXSI99IRdCCGEEEI0hgrq8IQ95fZaEAUnCSGEEEII0cLoCbsQYsCyotiNX4/YGqMndmLloi68f/UKjC40b51cIYQQDvSEvSY81mH3XEs9ss3KrxJp1E0Nup9G3dDAR8orrnWaE15l1qVH1/HmsoCOxeuuc33Wfmedau8t+KvtXBp1vv68dnq/LaW+LnvW0tWAtX2sl27icraGJtLY9m2v+rpuTbtfeUy77zovh2ad1ytnPaat778esTWu+vGdKBQKKBaL+MIZp+IDxdX97sveDN9PeR9Nrbnms+92vG/LN5XwU0xEx8QpWL1oPk7DIoxt2/wRTp81Dj29Mcb8piSimtlKyBp2u76WacJqaL2kubZ22pkMPK7RvjR6He566vOTfBYl7Rff97b3IGvWUx8T+vMdRrwdbs2633tODA70hF0IMWAZPbEThUIBAFAoFDBm0mRg7t+b26k68VNMxJU/+GXvl5NrP3ACPoZXmt0tIYTwI0QtTxXdbQ5ypGEXQgxYVi7qQrFYBAAUi0WsWLiguR2qIx0Tp8S+nHRMmNLkHolWYmWxiB8P3wr3vX1X/Hj4Vlj51vtCCDE40BN2IcSA5Zi1y/DFM0/p1bAfu3Y5MEg17KsXzUexWOx9wr568Xygrdm9Eq3CvaPH4Av/93+998fVp5+OM9eva3a3hDAIK0FMApROm6k215Jowi6EGLCMKeR7NOvz/gYACAfpZB0ATsMiXPuBE9AxYQpWL+7RsOsjXGxmzKRJJA+bBLzwfJN7JUQfyHRaE9WbTmmbjUa2cCRfk2mZTKUlOPYP4vXL2BK0wqbSCplOUjedRrazNLxcNwzj7qusK3AEdrNXJXbspN9eHWlFRoiEx/GoLcqycVpr2YwbDagygrDY4Jqg243GJwzJZfQ02k7ZhOrTti9sxkMk1MdlvjL29cTnPJOa0oy+V+KfD2MKGXwUrwGvv4YwHwBoQ6XS975hhU2o1DfHx549pMveVNIQpyT4XgOfe7XeQUnm55zfOK1YuDD2C8yKhQt7y9I02/qS9udBFFdQko/JFIi/T9x17W8ifg86iYYPVmQyFSZ6PCOEEEIMcI5auQJXn346xkyahBULF+KolSuAt564C9FShAGQduLxEDCdasIuhBBCDHBGFwo9mvXNMhhN1oUYVGjCLoQQQgghGoJMp7VR9YTd1EtTOW1Hw4ySataNcotmvae81G+ZS9Me0rGYAHFdaSaM69RywZYhLdGxc2F8uCtBjsrjbXMgFActgfoSu2NZGM7Sbkrd4Zb5mtmCkoC4FNxoyxGUVGZNuiGfJ32u0bctcCaL61cyQwvoCtqi+tk661ptsMbdhitkyaettDH01/SeqtCHTTT8qNF66SRaX1Ojnt6quuVy/M43Ne32cWDtL4+5DX4POMe8ie8Z3+tXb926jei4urwZrjFv5Hn4atbrGZTkS2D5bGHNuus8K1Tf8JXY9reEKomhi56wCyGEEEKIxlCpg4ZdT9iFEEIIMdhZWezGbzvGYPTkyVi5YAGOXr0CowfxMqlCDDQ0YRdCCCGGOL/tGINr/u+nvctCXnP6aThr49pmd0sMRsLA1MombjPd5loRTdiFEEKIIc7oyZNjwUujJ00C5jzX5F61Pis2lXBnbgeMmjgFqxbNxymlVzCmTVMrGzKd1kbNwUkclMQGyXJk9EyDqmNfT5Npd1CM14+Ul4Nu677lMF7uIuCgpCBu9ipHhjQbxn9ODB2hTSFdDh4XhK7LFelLyAYZ6qeRIMTwm8mVOBT2X2aELtlbYhMql3NwUrScPwPYhMoGVg6r4razdfT6+AQjOduqs5nOJ7QpKRW6iJlM/1E9rW0q5fATKi/bTac+5+YymSYdJ59xaWbIS9J70Wd/Nur6Yt4f1Y+bcecE/DnmP+YrFyyIBS+tjAQv2Uj7s6eRJlQjUKwG7sztgM/98Be94/aVc07Eh7G0j2PZTahCuNDXQCGEEGKIc/TqFbjm9NMwetIkrFy4EEevXgFIw+5k1MQpsV8mRk3sBJaYE3YRoZKpg+l08GtiNGEXQgghhjijC/kezfpmGYwm61WxatH82C8TqxZ1mT/tCpECmrALIYQQQtTAKaVX8JVzTsSoiZ1YtagLp5ReAbKaWlnRso41UfNdZQQlWTTRrMUugTXpHGbEmvb+g5F62mNN+6YtZeGmWFkZpGknDXvouOqsYc8i3+92zqFZz7FLwls2brt88a/4geHI8NXP+XTO3nGWIXJUFcsKWY5Zphcy1oCR+L6NDDpibaf3iHNwB2c8Wc4liR7e1XZSWF/rGhcO8TE17VsIgtb51HYFQvFfGNa0p6mn98Wmz/YJVQKaGz7kIokOPem9ZruPgfg4u/TtvO37WeOjea+3X8aHpD4C9noE2erb2zxmowp5XIA3gJff6Bn4Qr5PdQZr1l3XUAhGXwOFEEIIIURDCMMg9S8oznU0BgGyKQshhBBCCNHC6Am7EEIIIYRoDFolpiY0YRdCCCGEEA0hrJj+geRtasLei81U2mf9yH+7gpLYjGlsk7nHCD+icKSo0bQbG+NllbgJtRKyCTXeNpMJyHQatMW2c5nItss06vBx8nkXPEyoGVI7lTmkh7bZF2S3x/V58CrLgIxDu8Y+It62BSnxZwDftvyedgUtDRQCRy6zyyjmG2aS1NSahGjgDJvO2NiZ1BiYpmHOJxAKME1o9TSh+oxTdqC+SVIm+b1hH3ObKdXX+MsYJtUE5+I7DklCuOqN9X2SMOjIKwgt7afPYlCgJ+xCCCGEEKIxhHVY1nEIrLIj06kQQgghhBAtjJ6wCyGEEEKIhlCfZR0H/xP2mifsrEO36dRZk260xaEQLk077Jr2SiSKp0Ka9DIFKZmadpeGnYaMfqPIhFsEnqytDzg4xVPTXqRy1rRnIg2UOKyItstGaBP1zVs6WH1wUsbwQ3B5vJSzLPh9GW3O8J2k/B62aT19deAchMS+AjN4qXodObfNcFtGeQuH3aSJr0a2nuPi0t/b/iD53nvNxNWXgfKHN+mY+vgK+N5g70ZSTXuaJB2XRt6rxjWIjiP/SUzoKXFdb5tufaC8J0R90RN2IYQQokmsKHbjV8PGYdSkTqxa2IXjNizFmELevaMQA5VKJrGJ12wz3eZaEU3YhRBCiCbxq2Hj8Pkf34lCoYBisYgvnXkKPlRe0exuCSFaDE3YhRBCiCYxalInCoUCAKBQKGDUpMnAfE3YxeAlrAR1WId98MuGNGEXQggh6sCKYjd+2b4dRk/qxMqFXThh4+uG3GXVwi4Ui8XeJ+yrFi5oTmeFaBAyndZGS07Y2VRqmFAdIR/R+pWwbKlpth2GUaNPGf+8z9ux887TMWfOXPzpyecQZO26q+jxKkH82GXETahJg5VKZBQNIi6ZDJuUUKbt+KUPQjY0xg9ujDjVj5c7E6Hi22SgyoZskAWVc3P9G17rLWuzGY8aaZ4yDKqGwdVv29V+tL5RxqFcLRS6lKY5M+n1NYOUGjcuSfoeePaz3uZM675NfOoWZEL8cth2+PwdP98idznrZJxXWd5T/ta4HL/xdXzprJMxamInVi1cgOM2LAVoUm8akAeOCZVJcj8kfY/4GEed905CCXYSk+lQmJwKk5acsLcK79lnV/zhgd/2ftgecshRmP2X+c3ulhBCiAHA6IlxucvoiZOBBctjdcYU8ji3vALh/JU9L8hwKgY7Mp3WhIKTLOy087TYh+3OO01rco+EEEIMFFYu6pG7AECxWMTKRQua2yEhxIBFT9gtvDhnXkxbOOfFec3ukhBCiAHCiRtfw5fOPhmjJ07GyoULcMLG1/UEXQx5ZDqtjaon7M2M3QjohwDWZ7NkOqblDrKxsgpr/yxBSH/584s49ND3Y6edpuHFF+dh1p/nIptps/YtSkjhRByk5Krv0rSbOvUt2xXQeVM/OfgqC9asc1oRqJz6Eq3K+nYzISi+SW+0MlU3gpPQP677tJ73sevnKlfwkStYySiPtJd2UFIj9ffeenqLjpW1vkk16z56e+8QpgR63KTn5dKhJ/FmBJn6/TYdOn5GNzTK9OGRJLzGl7ASYHS+gPPKy4Gut2Qwlsk6j6s9KMtX054s9KdZNNLXAfiFk6U+4ZQuXTjQE3YLQZDFrD/Pw6w/z+vdFkIIIYQQtaFVYmpDGnYhhBBCCCFaGD1hF0IIIYQQjUGrxNSEJuxCCCGEEKIhyHRaGy0xYc+Q9igT2L95ZUjJk6XTqGCLsYeNnrlMO6hyjDCwO/gNA6ylfjmMHztDRlDDVOrYn+uXeBwiBlo2jVZCu3knNOpTBUdfo827vujy9c5S23xs7gqXG3214PuWNo2e1ZPUhOost4UXJdx2tRct9w1KSmoyZcOdT1tJTabR/dMMYeqpb3/n+BhBfU2l5v7998XXoOwbtGQjrLDZ0v6OrFA5m1aTmFTrPUGIjqvrPH1NqElgA6uLxgaC+T1m9QpSaqJGeijos4WblpiwCyGEEEKIwY9Mp7Uh06kQQgghhBAtjJ6wCyGEEEKIxhDWwXQ6MKIFElH1hL2RPzYYOnHaDmk7IG14NqIrz4dxzTpr2oMMt+2ngauE5X73Dy1lgHmeIenvyiANO92QrPUvh1ENe7qWaZcGPqqZz1CKT4ZDmThYiXWmhp6+cXdfxvNQ0SvgG4TE+AQlcX1DN+6pK/fRrHNfkmrWXRpXnzCkNDXqvuVJz8vVnvXYhs7fT6PuvGaZ/q+3cR4JQpn6IvZTN+mnWattaJK5Ph3bpXG34qjq0ri7xiF6Lj51e+on+/zncY3S6DAjG0nPU4iBhJ6wCyGEEEKIhqBVYmpDE/Y6UwlL+Ke9O7HTzlMwd04Xnpq1EJlAwy6EEEIIIapDM8c68097d+J3f7gbhUIBxWIRRxx6Ap6evaTZ3RJCCCGEaDhhmP6qLg7V7qAgtQl7ANYtb4E156yvdZXnQuomXedcWOm/nHXBIa9dHl9H3dCNExWU7eXRrgfATjtPRaFQAAAUCgVM22kK/jb71Z5i0qBz26wiZA182jp1H0KE6A43Yuxe3ejceTy65ryM5bPyyAft4EE39O8uMTfhoyvnqu610Gl/QwvOfelf6+vSkTt14h7rrvO2r2Y9m7Hrwm2add4/7XXVk+jI66lRdx47RS1+X+W29cx9NevG9Xdp4LPlfssyWW7L8zzp2PzTdvQPu2sd9UqZ3rHUVqUS9zv5aNy99O2A9xpsfN6+Wv8kpK2BF8JKHSQx/F4fjOgJe52ZO2c+isVi7xP2eS/Ob3aXUmPsXt342R9u7z23Uw89D2tmt7t3FEIIIYQQVaMJe515atZCHHHoCZi2UyfmvdiFv85abNWwV8JuvGOvt2H69E7Mm7sAz8x63Zqm2kw6dx4f+/Vg8k7j8czsVU3ulRBCCCFalTDMWFciqq3Nwa+J0YS9zmSCHJ6evQRPz16CABmn4fQde70N9/3urt6n1kcdfjKem728Qb31o2vOy7FfDxa8+DKAkc3ulhBCCCHEoEIT9hZj+vTOuOZ9+uSWnbAvn5XHqYeeh8k7jceCFzdr2JvdKyGEEEK0LJUgfc25NOz9Y4ThsGEuVuYI0uFyNhKROTNjGEfpNCJd4dAlI2wIpdg2m1JdYUeGqdXiNGKTaYYCnwBg3twFcc373AX9ts3n1kgCBCgEw7B29jA8O3s1gA4Ugs39ouvJQUrGttl2fDsO17eZUtnfahwrgcmU65sGVmrLMG46jH6WoCSuz/u6TKXuIKXqg3VcgUFJzZY2I2lSE6lvfZuxNM0gJMBuBE0ahGQYRfkaUXm0fiZb7rcMAIJcvNzVVxdRsyebSsNy/DOUyytUjjIZXKncFrzkG7rE5+1cFcPj4zypQdU0maYnJ0h79Y80aaSRN0287yUxKNET9hbjmVmv46jDT8a06ZNbXsMuhBBCCOFDGAZ1WNZx8H+J0YS9xcgEeTw3e3mvDEaTdSGEEEKIoY0m7EIIIYQQoiGEdViHPfV13VuQ1CbsrEsuR5bYYU2zKygJrO3mYr4uVB7VqbNGnfXvQUAaxiCuv+RwonIYD1ZiHXolsAcr2fZlWLPOIU/ZkLYjl9PQ7jt8BEbwFevMjUHnvva/b562s9QUb+dcunM6djai7zP3DfutC7iDk1xBTBmbljthUBJr3FmXno3ojl2addu+1fQ9wxrpTPS8/fTyjGucGFu5r0bVN+zIXje9IKQ+60fvtaSa9axdZ57N0+dmVMNulJGmPU9t87F42xWcFNGZG5r17vh2uTv+Jy3o5nHhz2vWtJNGPuhfP8+fJS6Nu/FnK4nmvYGhTL5Sg3rqxOupvfcl7WP7jPNA17RrWcfaaJ5rUQghhBBCiAZz3XXXYe+998bIkSMxbtw4nHjiiZgzZ06szsaNGzFjxgxsvfXWGDFiBE455RS8/vrrTeqxJuxCCCGEEKJBbJbEpP3Ph4cffhgzZszAk08+id/97nfo7u7GEUccgXXr1vXWueSSS/CrX/0KP/3pT/Hwww/jlVdewcknn5z2cFSNNOxCCCGEEGLIcO+998a2b7/9dowbNw6zZ8/GgQceiFWrVuG73/0u7rjjDhxyyCEAgJkzZ+Ltb387nnzySeyzzz4N77OesAshhBBCiIaweVnHtP8BwOrVq2P/Nm3aVFWfVq1aBQAYO3YsAGD27Nno7u7GYYcd1ltnl112wcSJE/HEE0+kPCLVUfUTdjYSVhwC/6iJkc11HJSUI/NlCWzc9DOhZsJKv2UBmUjZhMom01JABqvAXj/eTUeQiuP7EhtH2WSaRyG+HW7ZzoXxMeMxNs2TZAx1mlDjBEHQb1k+4zKh0jY14DKpRpv3NY2ysdMVnMRGs+i2YSL1DEpiI6hh/DSClKoPTnKZTF2mVTZnZjLl/usmNJEmCS8y2/YL6fExkvkGH3nvbwkcaqTJFIgbTbOF7n7LACDTZi8PaBuOcQojxtKQTKXlTfHPQGywG3vZhMp/Ao27JbZ4gh1b6FKf9T1Mqo0MZeo53pb2kpor0zRE1ttk2qomVtcYDtRAqHowYcKE2PbVV1+Na665xrpPpVLBpz71Key///7YfffdAQCvvfYaCoUCRo8eHau73Xbb4bXXXkuzy1UjSYwQQgghhGgI9QxOWrx4MTo6Onpfb2trc+47Y8YMPPvss3j00UdT7VPaaMIuhBBCCCEGPB0dHbEJu4tPfvKTuOeee/DII49g/Pjxva9vv/32KBaLWLlyZewp++uvv47tt98+zS5XjTTsQgghhBCiIYRhHVaJ8XxiH4YhPvnJT+Kuu+7CAw88gM7Ozlj5nnvuiXw+jz/84Q+9r82ZMweLFi3Cvvvum8o4+JJecJIpFu+lTHp3rsu6QVdIj0vTXonozAPSqLOunDXqvhp3xlVuwww7Ig07Xa6oZh0AChGNe57GKGuEMHHb5CsgXXng0LBHdeisSecwoxxr2qkxrs/leQ4UCvr+7562/IKTbBp1wK4ddgUdGZp2Q1fOfeGwItKlR7ZdmnVnsBJrnh3HtgVGubaThhWlqTP3xaVL9zm2TaPeF9aQLsf1c9W3adYBIJMr9VuWHRY3dWXai/HtYXFNOwp03o6/QmFxy/7hBvrsd13fDdQW6cozDp15LCwpaw/FY816GNifh7k077FyOjbr3UEad1fAkFMTbbnPfZfPc70PGhn6k+TzwOe9nxTfoKuBFpzUCsyYMQN33HEHfvnLX2LkyJG9uvRRo0Zh2LBhGDVqFC688EJceumlGDt2LDo6OnDRRRdh3333bcoKMYAkMUIIIYQQokG0QtLpN7/5TQDAwQcfHHt95syZOO+88wAAN998MzKZDE455RRs2rQJRx55JL7xjW+k0d2a0IRdCCGEEEI0hFqCjqpp06t+FRP89vZ23Hrrrbj11ltr7VaqSMMuhBBCCCFEC6Mn7EIIIYQQoiHUc1nHwUz1wUn8Ajnk2Fgaq8ohPK7kIzaVGkFKDIUCRfrCIU0VMgK5TKlOk6lnMIsNNri6TKccjhQ1muapLptKXSZTI8yITaeGQTJqOo2XcXCSWW7fdgUn5aPGT8M0Gq9r9tsv9MdmSnWaSA3TqMOkajGZ8rbLZGq05QrScZhUbaFNbCp1GSCTBhBZ921goIjvsdhkyveerX2nyZTLOfiKrz9tc3nUaOoMSiKTaTCCzmtYPAAOBdquUN83RkysGepXJW5wDcvxz8SwRB8mDrOmDdeEIGSjPv3tMIygvD/3PVLfMMvSvhU2LHuaUBnbufK9lFTakCQwyKetqva3fNY0NJzIcVv6mlLF4EBP2IUQQgghREPQE/bakIZdCCGEEEKIFkZP2IUQQgghREMIK8mlVH21OdhJbcLOQx8LP2LZYMh1/TTtXJ915pVIuaGfD3lf+7EqDm1YJcFdYgQlhaxTZA17fDtnCUdijXqetPu+mnVXGFI2039dlybdpWHnoCTz2GGkrHrNeTXb3J6h147qio22/MKMnOWW+r6adZc+3idYyRmcZGja/QKFjHJHwFCr4qNRB1x6WhoDHmOXZt1RnwOJouVBjjxFdG8gR23xG5o1623t8e1K/9c36N4Y387ZtfhBjtrq5tAmqm98Bm8p55/cQ9KJZ/J2rxXXN9rjcKNIaFOFfV08RKxR99S0M9F7sZlSg3prs30062l/LvH9YK1rXN90fQRiYKAn7EIIIZrKstUVfPcvu2HkNtOx5o25uHCvZ7B1hxSbQgxGpGGvDU3YhRBCNJXv/mU3XHbDvSgUCigWi/j6Z4/CZw95rtndEkLUgfoknQ7+L/iD/wyFEEK0NCO3mY5CoQAAKBQKGLnNtCb3SAghWgs9YRdCCNFU1rw5F8VisfcJ+5o35zW7S0KIOlEJA1RSlrCk3V4r0pITdvOxP4UfGfWNGIlIGe9LRhLDdBonSz6T0DDIcshT/5gBUq5tCnnisCMOQwr6N52yyTSfIUOrJQipmvKoETRLl4NNojlHuSv8KMeBQ0H/dY1wIkdQkr9JtVJVWd99qd1kyuW5HJtKy/3W7SlnU6o9iIfrx0yITtOpPSAoibFsMJmvvMy5nkZe41i+YVU+4VX8Ac2rDLCptFzChf/0N3z9s0e+pWF/ERfu+Tdgs+myFLmXHb4+V8iWa4yNcYl+VtGxDYOra4zoPcb3aoWCk6K1zYA/DrKjxRQ8TKV9MVj1wM77wxII5xt05sIIu4oXWvcdrNdH2GnJCbsQQoihw9YdGXz2fc8CePatCb3UmkIMWipB+g9XBvDDmmrRp6IQQgghhBAtjJ6wCyGEEEKIhqBlHWujbhP26NCxNtsVpGTqxOOYunQut/1wQDo0h4Y9TVyadFPDHidL4UdcP6orNzXmfpp0H806ENet+2rWORjJCFby0JUnDUpy6cZzFl26qUFPV7OeI81sVHfu0qxzcJIrSMkI3jHK+w9tcuuEHUJkH7004/mzqO9SYPX8o+A9TtG6vtpsx7ENIuNqBL6USV9N28EmPo9N8c1iiY7FYUdbtsN4bhLCUlz3nfhndr6Xo+fquFVM/bv9+gVB9TplvheCDIUuldO9L233Q1/vgRXFbvyyfTuMntSJlQu7cMLG1zGGA7KagI9mnbfr6b0B7LeToW93hSxJK9GS/PGPf8R///d/46WXXsLPfvYz7Ljjjvj+97+Pzs5OHHDAAd7t6TILIYQQomZ+2b4dPv+jn+PTN/0nPv+jn+OX7ds1u0uihdn8hD3tf63EnXfeiSOPPBLDhg3DX//6V2za1POgYtWqVbj22mtralMTdiGEEELUzOhJnbF19EdPnNzcDomWZihM2L/85S/jW9/6Fr797W8jn9/ya9P++++Pp556qqY2pWEXQggh6sjyjWXcsXEaOsZPw+qX5+Hs9nkYWxg8z8tWLuyKraO/ctGCZndJiKYyZ84cHHjggcbro0aNwsqVK2tqM7UJe4Y0zpUwmb4r1jZtm5p1u6Y9SpbWTXfp5RnXuu1RXJp0xqVR5yObuvQt23w96qlZ53LWrBvrqLvWWWfLg3P/qI6ctNfxXfvQibvqV69xd2nUjbXPaTvn1KHzdqnfunysXC6uE85kHX1jjbuxTntE68nrURvrF3vqqR3a3yiGnprLHU9dQtJLu+oHzVw6zLL2PeMzhn3BWvDYNpeRjhwbaU1wxO+9oEh9y7GGnTpTiujnu0kv303Hdl0/vhdZsx7yeUfKEmiW79g4DZfP/HXvhPb684/BJ9u74pXKA3cCf8LG1/Gls07G6ImTsXLRApyw8XWgBTTsjcS5Dj9D93mrPSGuJ5Uwg4qnf6iaNluJ7bffHvPmzcPkyZNjrz/66KOYMmVKTW3qCbsQQghRRzrGT4tJRjrGTwXWdjn2qj8rNnXjrsLbMGpiJ1Yt6sJJxVcxps1/oj2mkMd5leXAguU9LwyxyboQzEc+8hH867/+K2677TYEQYBXXnkFTzzxBC677DJ8/vOfr6lNTdiFEEKIOrL65Xkxycjql18CRje7V8Bdhbfh3++4q7dfXz77JFyAN5vdLTHICcP0g5Na7ReKyy+/HJVKBYceeijWr1+PAw88EG1tbbjssstw0UUX1dSmJuxCCCFEHTm7fR6uP/8YdIyfitUvv4Rzhs1FK/z5HTUxbhYdNbETWKwJe1JWbCrhp5nxGDWhE6sWd+G0yssY09b86y0aQ7lcxmOPPYYZM2bgM5/5DObNm4e1a9di1113xYgRI2puV3eQEEIIUUfGtmdx0fD5wPr5wFgAyMb08c1i1aK4WXTVoi7TLCW8+WlmPD73g1/0jutXPnAiPorXmt2tlmGwBydls1kcccQReOGFFzB69GjsuuuuqbSb2oQ9TZNpI/ExkQLuoKWo7cEIRiL3pMtUataPYxpHo6ZTV117uctkyvtHj2e2bW/L7Ks93IhNqBlLXbep1B5WZG73H4aUOCjJMIpy2FHcnBetz3WNICUu5yAl7gsZAQM2nUbOldticx4bVg2SGCQ9TaeGmdIoz1jLo551V1tpEw918TXy2su577YzqZTJ6Nltf48Zx3IYP4360WvCP6Pz9aJtDhwKOYwq4PrxvoXRvrnCaxijb/Fi495rwoTjpOKr+PLZJ8U07PDUsPuaLdOWQrQioybQLxcTOoHXNGEfSuy+++6YP38+Ojs7U2tTT9iFEEKIIciYtnyPZn3xmz3f0mownAqTVYvpl4vFXYCGtpfB/oQd6FmH/bLLLsOXvvQl7Lnnnthqq61i5R0dHd5tasIuhBBCCJESp1Vexlc+cGJMw67p1hYqYYBKyhPstNtLyvvf/34AwPHHH48gIgsIwxBBEKBcLve3a7/oDhJCCCGESIkxbbkezfprr731ZF1TraHGgw8+mHqbdbuLoqq2CoUT+erdXQpXbj9NfMOPorr1pJp11pW7NOxxHbmfZp115KwT577ydrR947zo+pj7OjTqLo17VE/NbScMSsoYx2LdeSS0yaFZz5PWm4OSnDp0i8ad9e2sG+fgJNa0c/iRS/MebT/gtvh6ssbdN2DEgqGHdWjSKxxOY2jWSfNs0amHgV3vnrZWN81xc8JPq6KhJBXqB4+REQAU/zPD94sxTnyetnHk4CO613hfMziJjkXXPxqk5NKgu/D2T6R4/7BPIEngmKHzb7Enm43COG9PKw7vX4ndaw4vzQBnKEhiDjrooNTb1Nc+IYQQQgghUuKRRx6xlh944IHebWrCLoQQQgghGsJQeMJ+8MEHG69Ftey1aNg916kSQgghhBBC9MeKFSti/5YuXYp7770Xe++9N+6///6a2tQTdiGEEEII0RCGwioxo0aNMl47/PDDUSgUcOmll2L27NnebbbEhD1kUyqVs6mU66eJK0iJ+2b7iSJpMJKx7TKKRg2vxr6Obd/6Nh+Yw8Bq27ennI2hdqNodNvc1952kqAkIG4EzbAplI2atC/XZ5Mp728LUmKTqGkytQchZfMOUyqbUCPtZXJ241/aptOoGS8MyZxVoitO5QGVhxQCZBgBS/2Xhw7zncuUmgRXUFLaxAyQ9IY2zJEcXuQMznIEKeX6P9eAjZwZ+98S/jwwjKBsUo2Mc8j94nvHYRJ1mUzZEB2710L9GF4LxvXMeBhm+fo4Ar58r1CSCWa9De6ifmy33XaYM2dOTfu2xIRdCCGEEEIMfsIwfc255+KDdefvf/97bDsMQ7z66qu4/vrr8a53vaumNjVhF0IIIYQQDWEomE7f9a53IQgChPRNYp999sFtt91WU5uasAshhBBCCJESXV1dse1MJoNtt90W7e3tNbdZ9YTd0JWHrCvn+qGlbny75NCoVxyJBEmCk1hnzoSkTMvWcWGdgMXeXG5s969pdzTVx7Fdx4rjo2l3wSNqHNvRdlRnau7LGvT+Q5cAv6Cknva2lHMwkitIKcsadQ/NOhDXmbs065k8ByNxOe2ft+8fRMp5X0OzboQ0+SaM9K/XNDTmrCsusZ6a68f7UmGNO90PUZ1x4NCo81nyvekKr/GBdd+N1rh7wcFaBcf9EfkrFbBFgaoGRXqB2mKNuxm8Rbrl6DU1AqHsOIORuNwI4un/g6+ZmuVWe5KZJj6adoYX6fMNq7L1Y7Bp1sM6mE5b7b58+OGHccYZZ6CtrS32erFYxI9//GN86EMf8m5TThYhhBBCCCFS4vzzz8eqVauM19esWYPzzz+/pjYliRFCCCGEEA1hKGjYwzDsUzXx8ssv97nkYzVowi6EEEIIIURC3v3udyMIAgRBgEMPPRS53JZpdrlcRldXF4466qia2taEXQghhBBCNITB/IT9xBNPBAA8/fTTOPLIIzFixIjeskKhgMmTJ+OUU06pqe2aJ+w2kykQN5qWDROpy4Qat2+46rtMqTYyJOM3jJxOQ2uGtiJmW9o36zC4Gi37OkctuAKhfKnQsERbz3oeiq9eErucKziJzXh8fZ1BSRYjqWlQpSAlMnoawUqOICVbOJLLZJordFM5mUwd5Zm2/ssDNp0WaDvfv4mwKvgGKUVMp2UyYxXjjYfd8e0KbYclsooFVG6E+my5oypkcAUZYDNseGSjWAJTWr3hvvgYhQ0DLJuO+f5oo/ptNE7tkWuSoX5VqF8b6b7NxO9bI0iJw4qMaxoxGXPgV4X/LnmaTJ1BS5nIf7fGZKQWWskg6epL9BonHXPjXnLVtxzPN5RLNI+rr74aADB58mScccYZiVaFYfSEXQghhBBCNIRKHVaJSbu9pJx77rmpt6kJuxBCCCGEaAiDWRKzmXK5jJtvvhn/93//h0WLFqFYLMbKly9f7t1m6/wGK4QQQgghxADnC1/4Am666SacccYZWLVqFS699FKcfPLJyGQyuOaaa2pqs/rgpNCuLLaFI7GWu+zQqJdJaVgKuD5pP2nbR9POGvYsDUnG+1tbRPNIY+KrSecxzdL+rOU3o1lqq9tT375tg/Xt/K2Qy12ad+PW8xhGU9NOmmTPoCTWmUfrZwLWrLs06vYgJdasm+XR8KKEmnXSqGfbitbyILJtaJBZstdGHzM50nZy6hbfIKwzj2wHm+izIB/vd7jJHuJU2ZSHDdawVyKfD8Z9zTuX+DwdO2Rq9+K4YA1skLUHCNnKA5c0l0ObOCiJ2g4KtP9wemHYsC3/naN7qRS/r5HZQIfeFN8u0/1A948R+pXZcjz+rEgaTeUTlJQUlz+i1Z5OVgv3O2lgmFUrXufHmz5a/4F6vTYzFCQxP/zhD/Htb38bxxxzDK655hqcddZZmDp1Kt7xjnfgySefxMUXX+zdpp6wCyGEEEIIkRKvvfYa9thjDwDAiBEjekOUjj32WPz617+uqU1N2IUQQgghREMIEdTlXysxfvx4vPrqqwCAqVOn4v777wcA/OUvf0FbW1tNbWrCLoQQQgghREqcdNJJ+MMf/gAAuOiii/D5z38e06dPx4c+9CFccMEFNbWpVWKEEEIIIURDGAqrxFx//fW9/33GGWdg0qRJePzxxzF9+nQcd9xxNbVZ84TdHX4U9lvG+3Yjbhxik2nZKC9Zy9M0nRYQN0DZAqJ66kdNafG2eV/2xxieNDKZun4OiXr1jLoOX5/LD8dvBb+3BhmD2IxLbzTypPXhxerfWOQyHbHvl02lgacpNRcJN+IyI/jIMJnSNptUHSbUaJiNGZyUssl0GO0/LNL3rehjZDi5TocNj22GBfo5kMJwQGE4QTFuHMSmjVv+ez2ZDDeyCZEMq2wiBkHXu0KHDizGsLRNqEn+ALnMeEa5V+MJf5jlACJ+U7IpOWo0zeWwbHUZ331iF4zcehrWvDEXF77neWzdkel738BhSnQYfY2wpAT4BCX1bEcCwmjfRk5OfI+VZlCS97E96/uYVBsZAFXv8xb1pbu7Gx/72Mfw+c9/Hp2dnQCAffbZB/vss0+idiWJEUIIMWD47hO74LLrfoOLrvwWLrvht/jun3ZtdpeEEB5sXiUm7X+tQj6fx5133pl6u5qwCyGEGDCM3HoaCoWeXz4LhQJGbjOtyT0SQviwWRKT9r9W4sQTT8QvfvGLVNuUhl0IIcSAYc2yeSgWiygUCigWi1jz5rxmd0kIIWJMnz4dX/ziF/HYY49hzz33xFZbbRUrr2Ud9qon7Kz0Yu02KwGjuvUSWJNuD0bqDuJ62m7Et1nDXkJcaFoO43pbGwH9yJAP4vpa1se3haTPpS91UT12wIUhaZwpgcTIUXGMMR88G9HjVQzRenyTtdtcn6Wb/OW1zOVG3/qHNet8nty2oWn3OBZrFF1BSjwu2aD/oCTezpGO3NS02zXutlAmwAx1yeajwUmkYWdNe5qadSCuWx85IlYUdoyKbVc6xsa32+MfXGEu7hMJStS39avj22tXbamb5VCm9fG26LPBvHvoPKmUb3zWGcfKOHyIdeN8PSnMhpclc+nOU4X7wt4Oy7GNMeG6roAgfsMX6fM7F7kfKhVcuOcz+Pq/HYWR27ylYd/z70D3W33gkK0yjyH7JRyBQgnCbJzXK0VNNMsBkgYl+dxrSbXdzXwy2mpPZftjoPSzWiqoQ3BSiy3r+N3vfhejR4/G7NmzMXv27FhZEAT1nbALIYQQzWbrjgw+e+gLAF4AyiVI2SmEaDW6urpSb1OfdEIIIYQQoiEMBQ37ZorFIubMmYNSqeSu7EATdiGEEEIIIVJi/fr1uPDCCzF8+HDstttuWLRoEYCeEKXoGu0+VC2J4TXE3fUrkf+mNdod66yzZr07iOtQi2F87eVubIxtlyKLJ4cOxXM2yMf3BWnYg/ga0kyGNJFlbNGlZ0i7n6HhLoWGaj2+yesTh65rEK3vWOvYFMx71Te6Fq3qWEfdPAv7mtBZQ/Ja+5rErFl3adwNzXrQvy7d1Kjzuuu8zjppmnn/bPXbWV533VezbmzTBW+jMW7fojsPR4yMFZXHbhfbLo2ZENuujNgx3lYm/h7EphWxzeyaV+PbEc07rbptqhgrrMUmTTut+R6W2DfAY77lGlZYs24YP6gtQ2ccr87713U9a8dHD79pw2BLhUqJ3zOkf89maTt+sMqm+OdgJkP3Hm3HdOmONfvRTdcz/qcB4cb4scMy9b1MfY+Mg0ujzrpx19rptnXXXcf21f9Ks956JMtZGNjPWisIUtect5qG/YorrsDf/vY3PPTQQzjqqKN6Xz/ssMNwzTXX4PLLL/duUxp2IYQQQgghUuIXv/gFfvKTn2CfffZBEHnCudtuu+Gll16qqU1N2IUQQgghRGOoh+a8xX65eeONNzBu3Djj9XXr1sUm8D4M7N9VhBBCCCHEgGGwJ50CwF577YVf//rXvdubJ+nf+c53sO+++9bUpibsQgghhBBiyPDII4/guOOOww477IAgCIxU0rVr1+KTn/wkxo8fj2HDhmHXXXfFt771rarbv/baa3HllVfi4x//OEqlEm655RYcccQRmDlzJr7yla/U1OeaJTEhmffYWBrd5rpsMjWCkGi7m4xibDItltfG94/Ur4T2pXQyQXwI8hkymdJXmizVz6L/7SwZQ3iMDJ8X2zEdgUG8HbVLuYyfWU8TqhGsRNWj+SRGmcN06jaZ0v6WcfH9mc0wmXoEJQFxI6lZ5gpO4iAtNsSSaZHLI8c2zJEcpOQIRgrydKx4lhGQI3tnPmI6LZBRezgFJ42OR8e3D58cPxYFiBXblsXbo64E5S3v76AYN6BnaOmsoDtutjVDeei8cxy8E7+bg+g2GRRN06jDJE7Xn9vzwRWUw4ZmJ5YgJcM8S/2udNvP2/zcixOU49cgdm/zedCmYSIlk2llU9zgXCmyCTXb73ZY6t+QCqQflORnBLUbWJO1Xb9+DySaG/A0uJ6t1mMZRt/21q1bh3e+85244IILcPLJJxvll156KR544AH84Ac/wOTJk3H//ffjE5/4BHbYYQccf/zxzvYPOOAAPP3007j++uuxxx574P7778c//dM/4YknnsAee+zh1dfNSMMuhBBCCCGGDEcffTSOPvrofssff/xxnHvuuTj44IMBAB/96Efx3//93/jzn/9c1YQdAKZOnYpvf/vbaXQXgCbsQgghhBCiQVRg/rKWRpsAsHr16tjrbW1taGtrM3dwsN9+++Huu+/GBRdcgB122AEPPfQQXnzxRdx8881Vt1Eul3HXXXfhhRdeAADsuuuuOOGEE5DL1Tb11oRdCNE0li1bi5nfnYORI8ZhzdqluODDu2LkSPd+QgghBDNhQjz34+qrr8Y111zj3c5//ud/4qMf/SjGjx+PXC6HTCaDb3/72zjwwAOr2v+5557D8ccfj9deew0777wzAOCGG27Atttui1/96lfYfffdvfvUkAl7xfFdisONQnCwUlx3Gg1GAuKadQAolbdo3CshaVbBumH7Ny8OViqTvp77bguMMnX/LO7mtkg3TrrzMom5o4FCrFF3fZvltkkubeirWVceK6Nt1rwypoY9/kobZ6V4BCSw8s/QgTuClFiXzrrzXERHbmrU/YKS+NguopppX816ZpgjGIk167ydgKhmfeZ35+CyT9+MQqGAYrGIG2+8FBdfMiW+Q4Z0xtnIezZHYnt+cpHn8vhnRVCgcSjSe5avSWSbPQZhwO8y0r8H/HmQIDjFoVl31qd7LySjCd+riOi3nZlLjj8rrInOsE9gk8NXYGmLtfeV7px1OzTKSY8f6VuF+lmxhCwBfejpPYKSGF4Bw/v6+wYteejWB7JmvZX6nkSnziFurU49NeyLFy9GR0dH7+u1PF0HeibsTz75JO6++25MmjQJjzzyCGbMmIEddtgBhx12mHP/D3/4w9htt90wa9YsjBkzBgCwYsUKnHfeefjoRz+Kxx9/3LtPesIuhGgaI0eMQ6HQM6kuFAoYMcJct1YIIYSoho6OjtiEvRY2bNiAK6+8EnfddReOOeYYAMA73vEOPP300/j6179e1YT96aefjk3WAWDMmDH4yle+gr333rumfg0u67EQYkCxZu1SFIs9K7kUi0WsXbu0yT0SQghRTyphPdZiT69/3d3d6O7uRiYTnyJns1lUKtWp73faaSe8/vrrxutLly7FtGnT+tjDjZ6wCyGaxgUf3hU33ngpRowYh7Vrl+LCj+wOYH2zuyWEEKJOhAgSSQL7a9OHtWvXYt68eb3bXV1dePrppzF27FhMnDgRBx10ED7zmc9g2LBhmDRpEh5++GH87//+L2666aaq2r/uuutw8cUX45prrsE+++wDAHjyySfxxS9+ETfccEPMHFvtLwJDasIehhXss+/u2Hnn6ZgzZy6efOLvpoBaCNEwtt56BD57+ebUt6kAgI2bNGEXQghRP2bNmoX3ve99vduXXnopAODcc8/F7bffjh//+Me44oorcM4552D58uWYNGkSvvKVr+Bf/uVfqmr/2GOPBQCcfvrpvSmn4Vu+w+OOO653OwgClMv9+3SitOSE3WVS9W1tM/vsuzseeOC+XoPbIYcciT//6R+x2mFoP3YljA8s9zVqQjVNpmSmgssYag9SYjKR9rJk6MgHbDoznJxU7huW0X+ZYaYkgwwHJXFTad4NbJ41w4rsptRoUBLX5zLDZOowlRomNIcJKdpewP1qc5hMR8bN1CjQNsM/A0beJ0Epfqzs+lXxXdcujm3Ho46AIGAj4Jp4eXc8GC1WN5e3bgdsQmXzLJnIOTCMt6NGXw5KaibeBi6HadEIM4rca0YwGptI6V4xTKa5/sOJeirYA8RsGMFHdGzDdMqhT2wsjdRnkynXdb1/XSZTLo8aTdMORhoqplIXhhG8juc6lEylLjbLWNJu04eDDz64dwLdF9tvvz1mzpxZc38efPDBmvftj5acsNeLnXeeHjO47bTTdGPCLoQQQgghRK0cdNBBqbc5pCbsc+bMRbFY7H3C/uKLc5vdpUHJpsoG5P5pAyZO3xGL5i5B+a/D0JYZ1uxuCSGEEKLJ9JhO02+z1di4cSP+/ve/Y+nSpYZZtdq01ChDasL+5BN/xyGHHImddpqOF1/s0bBnMgX3jsKL3D9twA/vv633i9E5R1wA/E0TdiGEEEIMfu6991586EMfwptvvmmU+ejWo7TkhD1DKskM4trBTBDf5nCjSiaiS41+qQmAP//pH70ymEymgGwmvqh+jrYzpK/lY2VIlxZ4rJTJGneGNe8cxMTbUXLUj3JI2k2ShRrLF5EezAwg6vfQmDh9x5j0aOK0HfHK31i5XB8MDbpDN87n4dS0swY+EkDDwUnGvhk/Nb6pibVvW4+Vp7rD6QtUlj4KyqTtLtF25GlBsDF+bTPr4xr07Kol8V1L8fCiStuoeNtGUFJ7fLswfMu+3XGDalCgkAz2ahjbsG7zODbyIY6pec70W+ZsizWwro8p1kxb+pUhE0qF9fGs9S5zgBj7CvofZfYNGOflCBgydOcuzXuk3KlZ57YSaNa5743UrFfTXqPa8g2TS0r0eEnHQJr1/mmFVWLqzUUXXYTTTjsNV111FbbbbrtU2tQ67CJ1Fs1dEltbe9G8JY49hBBCCCEGB6+//jouvfTS1CbrQIs+YRcDm9JTw3DOERdg4rQdsWhej4Y9p6+GLc2y1RV89y+7YeQ207Hmzbm48J/+hq07dNGEEEKkSyusElNvTj31VDz00EOYOnVqam1qwi5Spy0zDHh6GJY8vQFZjNVkfQDw3b/shstuuLfXd/D1zx6Jz77v2WZ3SwghhBhw/Nd//RdOO+00/PGPf8Qee+yBfD4up7744ou929SEXYgmsGJTCT/P74BREzuxalEXTu5+BVu3Z9071omR28SXPB25zXQAmrALIYRIlzC0Z7fU2mYr8aMf/Qj3338/2tvb8dBDD/WGJwE9ptO6TtgzRsiP3ZQYrc8mUjZmZqkb2TD+TSQXsPmS3LVsFIu8UOZgFCJLptJ8Znhsu4D4dj6Mm9q479FzNYOR7JFAXF6m8lJQpvL+z43HuC2k1XBom02mWbr7M+TO5KmlzYSapcJ8hsvt2+a9FVrLbdj62VNuD1bywWaY+nl+B/z7D+/qfaL95XNOwkfwulf7USOZYXgr0RViR/pbHoPNrHkjvuTpmjdejIcllfg9FymjtoKNcSNoZuO62HZl2Jh4W/kR8frt28a2w0r8Pq9ETKlBkVJRc/H7OiRDY8CmUwdsWoyXJTTysbEzgdHMuy+O+mzgipo9TaMmfb4b5ms2evoZw2EzazsCoAxjJxtHHYFEsfqGadRjX7h/srf1pZVMpYM5SClKI0OVgGRG04F2TUIExhwyjTZbic997nP4whe+gMsvv9xY1KNW9IRdiCYwamJn7In2qAmdwCt+E/Y0uXCvZ/D1zx6FkdtMw5o35+HCPf8GedKFEEIIf4rFIs4444zUJuuAJuxCNIVVi7piT7RXLe4yf7ZoIFt3ZPDZQ54D8FzPC2VN1oUQQqRPGAap/yrQar8ynHvuufjJT36CK6+8MrU2NWEXogmc3P0KvnzOSRg1oROrFvdo2JFt4oxdCCGEEKlQLpfx1a9+Fffddx/e8Y53GKbTm266ybvNmifsrGkOWfMc+Tk9S5rjXEgaSOpGJWC9NR3c0DjH28tlt+jMDb07kUV8EPNBPKQlh7hmPU/ab96Onhvr/k0fgD0IiYOTWLNeDOLa4TBS36atB4ACBSmV6fr5KrejOvWMQ5POGnZT0x5at1mHHtUauvTujEuj7tSdWnSmNs3y6HwBF2aWAkuW9nS6LYcgsAcvmZ3b0l6lm67n+vh9HOTi74NMZWO8rbZ4mJETvsjRY22MvyeCUvw+BWnSkYuHOGVzI7Bs2Vp877b5GDFyO6xd8yo+dF4ntt56KwBAKRKkxBp1VOLnGdA2KB4aLI8u8TXrP/zGCEYxtpOG3Vg0zY4QHidGkJL9XgvLUcMUf1aQ3t3RF2eYmaFZr/6LrEuT7hw3i049zSCkPo9N2MqdHgTfYK0WezpZK0mDlqxhdA3WtNsY6NdrKCzr+Mwzz+Dd7343AODZZ+MLOAQuM10/6Am7EKLl+N5t8/GZy/5fr2Toa1//JC759O7N7pYQQgjh5MEHH0y9TQlVBxHlsIhJe2Zw6JmdmLBniFLo+dRUiBZhxMjtYqbcESO2b3KPhBBCpEFYp3+tyLx583Dfffdhw4YNAEw1ig96wj6ImLJXO+753Y96n0oed/jZWDy72b0Swp+1a16PmXLXrn0NwDbN7pYQQgjhZNmyZTj99NPx4IMPIggCzJ07F1OmTMGFF16IMWPG4MYbb/RuU0/YBxHTpk+KPZWcOn1ik3skRG2ce8EUfO3rF+OW/7waX/v6J/Gh8zqb3SUhhBApsFnDnva/VuKSSy5BPp/HokWLMHz4ljyfM844A/fee29NbVb9hN01FBwSlLV8FzAChFy5GRS8kSPDZImMoeWg295ghIANq9R2HtWbTHvaiwZG2UfNZUJ1wUbSeXMXxp5KvjR3EdxXrm8q9LMNvxnYKBr1IPqaTJ0mVDLEsQk1Wt3XdGQYwzyNYD6mU1coU0DnGWTJQGkxPZWLcfN0sJ7GgUxq2e646TRoi79ngiztn6O+xbbJVFqIt51ZvzZ+7OEr411b/2psu7tSQscw4KIZYwF0o+fJ+hqUNq7pOfbGN7e0tSHeVlAkMy2FOqFInw3dNKYcrGNsR97vFkNqz7ZfMJLr/okbXu1mSReGYdbuzY8TWIKMAITclsPQajQfVP8cyWm+c4QdudqzjbnLVOpsO0EY0mA2lfp8hic1mdraa6Uxa6W+pEEFpt8/jTZbifvvvx/33Xcfxo8fH3t9+vTpWLhwYU1tShIziJg/ayOOPfwsTJ0+EfPnLkbXrCJyQZt7RyGEEEIIkQrr1q2LPVnfzPLly9HWVtu8TJKYQUQ2KGDh7Aoe+PECLJ4daLIuhBBCiJZic3BS2v9aife+97343//9397tIAhQqVTw1a9+Fe973/tqalNP2IUQQgghhEiJr371qzj00EMxa9YsFItFfPazn8Vzzz2H5cuX47HHHqupzaon7GZQElWgLzfRpWsqVFgAa9ApYIh0hhwCxAFCeVIvRQOHOHyIdd98LC7nY7NmnbX6mZiG3f4Dhtk3GmNHX1jynouUB7RvnrT57DlwYcnJ6SmP/Ddr2N3bdo061zfCkVLUMbIutUL3R7nMIV1bBLusjw05pIc6bmjaM3bNOgfKxPS1pXi/ShRexHrYCp1HJl+ybge83b5lO6DzDDLr49vB8tg2f+iw7rwyvAM2Mhu3aOIza1fGy1bHt7FhPW3HNewhSdzDYrx3PK5hKRKkQ2No6N1Zs0z1K1zfoXmPtefUw/vpqX0IQ79E3sBzGTOf2t5abs/AqejnQZrBR331xWf/pE8TXfdHPeGAOL99XaFbCYOTItfEFZSUNEip4uk7GUwMheCkjo4OvPDCC/jmN7+JkSNHYu3atTj55JMxY8YMdHdX77OMoifsQgghhBBCpERnZydeffVVfO5zn4u9vmzZMowfPx7lso/TvwdN2IUQQgghREOoR9BRqwUn9ReQtHbtWrS3t9fUpibsQgghhBBCJOTSSy8F0GMyveqqq2IrxZTLZfzpT3/Cu971rprarl7Dzi+Qpt34ehNdSzdkjbnf+uQBaZNytHY6a8F91jPPUNusO2etN/fN3K5eG2jWZW0f9cUxDlFYW89186yPp+vJngWGxyVa3V/Dbt/O0PW06eldo89fes1tx1rLtF2O6FozpEnOuIT/DjJZ0oZb1m039JOkveYf3wy9dT7+UVBxaNoz5S3i70yJ9HgV0ruXVsW3u+PC8dza1fG+FGh1owy9D6LHY436+g3xbdasU/XKhvj69WF3zrpdiWxXSvF+sS/A0L+71ml3rdMdWxO89vXEG01YYxZEn2356oSdOvLatf6+Y1zPtdObqUn3hfuaSNOeULNua6+p75lBvM4+MLg17H/9618B9Dxhf+aZZ3rDLIGeQMt3vvOduOyyy2pqW0/YhRBCCCFEQxjMwUkPPvggAOD888/HLbfcgo4O+yIKPmjCLoQQQohBy4pN3fhF+/YYPbETKxd14cSNr2FMW969oxA1MnPmzNTb1IRdCCGEEIOWX7Rvj8/f8XMUCgUUi0V86eyTcX64rNndGrLUI+hooMmCakETdiEGKMs3lvGj4hR0jJ+G1S/Pw1mF+Rjb7rdGthBCDHZGT+zs1RIXCgWMnjgZWKgJuxhYVD1hD9iUSG490y4ZqR+weZKNIi6jJ5m7jKORCdUjqINNo2a53czjE0AUei485Oobp1XZQpvYZJqja8JnyUd2WZqi/kr2WvI2ByPljPpkrqRyW3gG3xkug7PLVGozmQJALhqs4tlWUn5UnILLb7+n96nR9ecdixntC/s+FptQHQbIgAyVIW3DEtrEJlTeDjaR8zMfN4oGBceXjmhQUzeFSXEQ0iY6j41kIt1kN52WqTxqOjWCk0qOYCTX/cEmNyPkJxLa5BnKk/TeaxVDl8skatSvc7hRmscy61d/rq0cwpPxNIZGx8kVlFQtKxd1oVgs9n5Wrly0IHGbzXyiO9CfJodIX3Peass61gM9YRdigNIxflrsqVHH+KnA6oVN7pUQQrQWJ258DV86+2SMnjgZKxctwIkbXwOkYRcDDE3YhRigrH55Xuyp0eqXXwLSM6QLIcSgYExbvkezvlkGo8l6UwlRBw17isvHtiqasAsxQDmrMB/Xn3csOsZPxeqXX8JZhflgeZgQQgghBj6pTdhzJDSO6ZOMUKX4Jmu1WYPO2u+KQ1HtE5zkwq0jr/3YvoFPXG7rm4+2HjA9Ci5Yl27bu5W+97IGvUyhPGXSjXL9LNeP6Jgzmfj1zJDGOZuLxxdx25mQg3js9/nofICP5xcDKxYjGBECyHFGWaRx2qa+VVjDzk8/jO0t9QPWcvM26cKDDRSsVIhvI2MPjIo9meFwIt62BB/1tc1afaM8cm5GWw7NuhGsxDpzY//+20sa0pM0UMiHeuptvXXhKYYbuTXrycawnrr0JNfEV1fO58Gadp8gJTNMjPqWMEgpjIWTpes5cF1Pn5CugU4l7PmXdpuDHT1hF0IIIYQQDSFE+ibRITBfdy7+IYQQQgghhGgiesIuhBBCCCEaQiUMUl8qtlWWnq0nesIuhBBCCCFEC1P1E3ae2VccJsVYsBLVZc+KEaNkGFgpSMcRjJSN2Bx9w4p8sS3+b5pl47VLtO2qX6GBy9A3SlvIU8ZxqUMeU08Tqg+GYdXTxORjzimz8Q9cziZTe1ASb0fNmmzc5O0yGSL5vCuG2ZIDw+JES4Ns3NDqa75KErRkhCyxGTMfN5VmuK9kxjU+IGxw+JARXsSmVOqrYZhl42//plY2mRp1DdNp/+FTPfUdQUsW05pxrISm0jTNl774hBUZ+3obBX3O0+/5VlLTaKsaDX37ZXzOeZlQPQzoZnVvfP621NNkOtipIP3gpLTba0X0hF0IIYQQQogWRhp2IYQQQgjREMKwDsFJQ+AXCz1hF0IIIYQQooWpXsPOmuaQ9dZxokE8GU99NAcnZUl3bPSF949pwT2Djxz6eB9NvEuzXkZcu9sddMfrB3HtL7fHp5YLt1zOSthm7VuWvo1mg/QSMlmj7sL8ZuwZzBHZn+9DQ9POGnW6lzhIqVSh8KNKpd/yoEQeA0eQEpeXAgoYynB7Dv1mHyzfWMaPilPQMX4aVr88D2cV5mNse9YdIMM3F4f6lLf0JchyGelOu0lXnqVy1ttbglPMjtKxDa09hxPZdeZG8JJFh846cFdwUlLNuu16s2Y9qUbdS9vdRK122uE2TBIdeppP/Frp6WFSz5GPpt28XvVVKts17I3TrKf5/mxFpGGvDUlihBjE/Kg4BZfffg8KhQKKxSKuP+9YzGhf2OxuCSGEGKKEofHMN5U2BzuSxAgxiOkYPw2FQgEAUCgU0DF+apN7JIQQQghf9IRdiEHM6pfnoVgs9j5hX/3yS0BHs3slhBBiqFJBYCyxnEabgx1N2IUYxJxVmI/rzzsWHeOnYvXLL+GswnwA6fkVhBBCCFF/ap6w+5hQA6prmFAZT1MqEw9O8sTxJa1iNFj9EdiwWgriptNiUIxtdyO+XSZTKpNH/0bTDBlm8nTpeUyTyMGMMWLvnbOczXY0brR/1EDLwUYlMjhlOSiJ2u4mk2lAI8Hm3KiBiusG3fnYdoaDrxzhRgGZUs036xZTcsD9Cnv2HZ3P4OP5xcCKxcBWAJBHhXKKALdJ0SDSRsBmSzaVskmNA6I8Q55sGAbISjJjJ49LtNxpCh1EJlOf0CYXyUymAye8aKAbA/sjaXCSa/+KxT2Yybjucz623Yroez9FSWoybWY4WbOphH3NpZK3OdiRhl0IIYQQQogWRpIYIYQQQgjRGOqwSkwiWcAAQU/YhRBCCCGEaGGqfsLuirZxadqjVBwa9aQa99ixPL/GZehMK46vbbZYB96Xg49CxzZr1suIBykZRLqeNTTq8bZd59VIzLAjLmdtb7w8kuGDMmn9SqTt5evF+soMeDuuDS+W+x831qgHVDdTimvanRTtxbErTHrKIOsXI5FEIxkEHCBE4+AIWmGtvtm+h0/EqcX205Fb2/fUqJt98Q11q1/witd5ex7LrD9wwovqqR0eLLpk1/vTdZ4+Gnebvr1v6mewr6d3w7dtn8+GVkCrxNSGJDEDkHLYjbfvORrTpk/GvLkL8MLslcgGnpNBIYQQQogGo+Ck2tCEfQDy9j1H47e/+2nv2tpHH34aXnxqXbO7JYQQQggh6oA07AOQadMnx9Irp02f3NwOCSGEEEJUQaVO/wY7mrAPQObNXYBisUfgXCwWMW/uguZ2SAghhBBC1I2mSGJsRk3ADFoy9vcRK3mGMHFtNqHyJgfv2PbNOL4fBVQegEN8ekbqH7NX4f2Hn46p0yfhpbkL8Y/Zq5ANCsiGW3TsfCxzu3EGDR4hw1TK28YYx7cN42gY/W8O6Ypvd3O5YUp1GSb7f8v4mCP7go1D+Zw9SKdS3pJelMnG05CydQwnYpymUg4vMfrSfxhV2jjNXE7zZf/v4aQmUy9TmmfQVZoGObeh1d43XxNpq4QXDRaTaNrUO0hpoNDIALGBZjJlFJxUG9KwD0CyQQEvPrUeLz71Qu+2EEIIIYQYnGjCLoQQQgghGkKI9HOOhsADdmnYhRBCCCGEaGXq9oQ9GqTkCi9yadoZ1riHVh25s7H4sT017bxYf/R4IR09S98B86Hf2ullulysS4+GJbWF7fFjkU44S/3O0TjweXtkVZmadEOjHm+MfQCsOzdydTxuGJdvwJck4ResO+Ryp2addMu5SkTDnolr2MsUnMS6UV+duC3ciAOjjH0pWMmlp/fWxHvgG9rjpysfOLpS7qtP0FJSjXojtb71bCspA12HvBnX+5/xuQYDWe8+lDXqLno07CkHJw2BR+ySxAghhBBCiIag4KTakCRGCCGEEEIMGR555BEcd9xx2GGHHRAEAX7xi18YdV544QUcf/zxGDVqFLbaaivsvffeWLRoUeM7+xaasAshhBBCiIbQCsFJ69atwzvf+U7ceuutfZa/9NJLOOCAA7DLLrvgoYcewt///nd8/vOfR3t7e5/1G0HdJDEu3Xqa2NZtt+nbgT6+sfhq2vnYsep+34cyYf+adACo0C1prK0e0YS1Ia6Pz1NbedIVZ+k8eNvoK23bRpnLeF11HlVznX3Wcls643jXVjyvCevsKijTdtDnf/e9r103XKbrXyDNeiVHOvVKqfe/s5m4RyFDmvNMhjXsvhp3Wis90l7Fsa+hf+dl2Z37s441229dF9766Qbq0l163eg4VWhMfddld+EzTkk160l8IUkZ7FrhRpB0DG0a+IGkWfclzXtvMI9TvTj66KNx9NFH91v+uc99Du9///vx1a9+tfe1qVOnNqJr/aIn7EIIIYQQoiFs1rCn/Q8AVq9eHfu3adMm7/5VKhX8+te/xk477YQjjzwS48aNw3ve854+ZTONRBN2IYQQQggx4JkwYQJGjRrV+++6667zbmPp0qVYu3Ytrr/+ehx11FG4//77cdJJJ+Hkk0/Gww8/XIdeV4dWiRFCCCGEEA2hFs15NW0CwOLFi9HR0dH7eltbm39bb+luTzjhBFxyySUAgHe96114/PHH8a1vfQsHHXRQ4v7WgibsQgghhBBiwNPR0RGbsNfCNttsg1wuh1133TX2+tvf/nY8+uijidpOQtUTdpe1K4nJNO1vWlF8QpYAtwnVgJqLmVBDu0k04PAiI1gpbvRzkY0YA3PUdiGIt5XP2E2nGTpt3rbBI+wdaEAmNjY1cvCSraxCveHrz2adHIcbkbmP79VypL4RjESXL6RrUq6wybRkLc9X4qbTXMRomiNDKgcpsaExm/EznRqm1Yjz17VvQPcaG2LZQGm8B2nQXcFLSUjTZJq0nwHfu5G+GdlhhrE3XiOpKS0aluRrMk3TdMrINDrwSfMa+oY4JaGe995gN5GGYfpBR2muc1IoFLD33ntjzpw5sddffPFFTJo0Kb0DeaIn7EIIIYQQoiGEcD8ErqVNH9auXYt58+b1bnd1deHpp5/G2LFjMXHiRHzmM5/BGWecgQMPPBDve9/7cO+99+JXv/oVHnrooVT77YMm7EIIIYQQYsgwa9YsvO997+vdvvTSSwEA5557Lm6//XacdNJJ+Na3voXrrrsOF198MXbeeWfceeedOOCAA5rVZU3YhRBCCCFEY6jUQRLj297BBx/slEhfcMEFuOCCCxL0Kl1qnrD7aNbrqVH3Jamm3cjssQQt5SiciPXUrFDnMQ0dmncmejxXEFLeUZ6lQ7mOHX2zuNR3HJzEktgybbv6FtrK+Fh0Qfl6VkK79jdvhB0F/dYt8zZr1rNxnTn3lYOUDE17dst2qRK/m3IZ1rTHz7ScYY26XfPO2tBoe4Y+ns4rQ6McsgeBLwrtz1rw6PE4AIoJaQxd4URJsPWzZzvZJ2EYeX8b/S7TvcJ94/N2vks9+pWyZn2gBMr4hna1Mq2kmU4yrq3saWilMRYDEz1hF0IIIYQQDSEadJRmm4MdBScJIYQQQgjRwugJuxBCCCGEaAj1DE4azOgJuxBCCCGEEC1M1U/Y2RDp823GZewcSLi+4URNqDxGWfRvUAVMc6WzLxx2ZGnLtZ3zDEoyzLeRU2HDG5tMmW5uyzCd2rej5s48hyxRY9xv7lo5YONoSNv9By25TaXcF7tJtRDG9y9TAFElcrxc1l6Xg5IyZIDMcv0shRtR/Uykr9y2C7c507EdOVenQY2N3GW/MDIbvibTgMbUN1ipEnkjBeTU5sCngK6J73mzWTcalpTUZOprDGxVs56rX61sSm3VMQVau2/NYrCNSSusEjMQ0RN2IYQQQgghWhhp2IUQQgghRENohaTTgYgm7EIIIYQQoiFIElMb1WvYadulS2+mYzdNnQ8HLfngUo1yP32PxftHNe2u4CPWrCc4TQB0vTmsiLZDz+/C3Pc8hx9FmmPNuvm9266/zZLulPJo0M1BShFtbylj17uXWWfO5ay352MZ4UcR7T5pjjk4iXXmvF0Jqe2KvX5U4x6S1p4/VDI0LiG17XrDBhzElO0/tImp8AUkXXkYpqhpd2jWM8a2PSDK0KUHW/paLsX7zW0bOvMG6ql9NetJ9Ln11vY2U4fOYWVRmhkQ1Eg9dSv7AHwZbDp00Xj0hF0IIYRoUVYWu/HrjjEYM6kTKxZ24ZjVK9CRLzS7W0LUjIKTakMTdiGEEKIFWVnsxv+M3hbf/tGPUSgUUCwWcc0Zp+KsDeua3TUhRIPRhF0IMaBZvrGEn1Q60TF+Cla/PB9nZLowtl0fbWLg8+uOMdjzoINRKPQ8US8UChgzcTIw57nmdkyIBCg4qTb0V00IMaD5SaUTV3zv7t4nkNedezw+jsXN7pYQiRkzqRPr169HsVjsvb9XLFrQ7G4JIZpA1RN2DpBhOATIRlKpkcu6Ef2mxeFCTD0Xone27eoblbvOO+pZ9DWZsleT92dsjmy+V/jWKDlMqNy2GZRE+1vMPDyG7Hcsk6mJA6UyDlNqd6R+W8hGTgqf6beXfcPBSmzujJaHFFdVJsNijkyJWYeplIOYbGE5OfoU4TEN6IIFQXxcMqFjZOhc2M3dMX5K7Alkx/gpwPLaJuxphuGwiZRNpmwUBV0DHqco3M9ywkAowyjKwUyRcldwUlKTaSuZ82x9cd0LvK+vgbISBlixYAEu+rfLcdNNN2H48OGY/fBD+PCqlUAh79WW75i2yjVolX60Ohx01upUUIdVYtJtriXRE3YhxIBm9cvzY08gV788Hxje7F4JkZyjV6/Af378XzB60iS8tnAhPrx6BUZ7TtaFEIMDTdiFEAOaMzJduO7c42Madn20icHA6EIeZ21cu0Wzrsm6GAQoOKk29FdNCDGgGdue69GsL1/81pP1gfextnxjGXcUp6Bj/DSsfnkezm6fh7GFgfUztxBCVEMYpi9h0bKOEVijzmNTsXy/8dG394VLh27Uj2h7ncdmzTIVc0CUK9zI9ifWdR4+GvWe+kG/5fX+U2/TnfOQd9MLrEHvJj01v5FZV86BQ9HzznIZN2YMDLfN5dyX/rdZR2h7T1SDSwsc07Abun/qS8hBSvHyPOvjWbtPA5mPauZL1m4asJY3w4FQ2XjfggrpsyMXyakjpuCkCrXF4USuMY+15ry3queOTVNx+e339Mp6rj//GHyysLD2Bgm3btzeeZuGncdsIGnUk+CrUU+qafehmZp1Xz01B44NVQaaDl00Ht0hQgjRZDrGT40bZ3ec2uQeCSFEfdgcnJT2v8GOJuxCCNFkVr/8EorFIgD0GGeXvNTkHgkhhGglBp7YUwghBhlnt72E688/Bh07TsXqJS/h7PZ5AGQwFEIMPhScVBuasAshRJMZ257FJ4d3Aeu6gNEAkB0af4GEEEJURfXBSYbJkE2oVO7RCTbnZQwjoF2cxLqeqBmPjZ7ctmFKdZlKPU2oNpKaTL2O5QhKcsHX1wZfew5IKNEY8vamcCNG77UJk3baEQtfXIJVs9pQCNp7yzNkmIyGBFXoZuBju8IaXOVlGkg2oUbhMTdCmaizRW6AgnZA4ThRoxgb//KZ/kOWACBLYUWGaZUMUBzaZMVhQs0YplM6OA1ESOOUi1xvDidi2FSaNHAoOgpZI1yKDK5GYJT9WAGbN9kQG+lrpczXx88IWqmwGdde33avDWaTafSausyRvqFbjRwXfxNq49SyMlsOPSph8kUZ+mpzsKMn7KLlGL3XJvzf72f2rphx+mHnY8PsdveOQgghhBCDEH21FS3HpJ12jK2YMWn6jk3ukRBCCCHSIKzTv8GOnrCLlmPhi0tiUfML5y4BMKrZ3RJCCCFEQip1CE6SJCZCd8jhNi4Ne/+Xw1e7xLpzs5yCViL1c6zdNMKGWI8Zb9s4MuuQaYdKpLzeP1+wDj3N4/lo1l0Y/aSmczSma2a344zDz8fE6Tti0dwlWDe7HYXouFJ9HxuBEfgVJiuPwqFLZkAU69/jFTj0qcSCfE6BipTzu83UpNOxjPvernG36ZYNfbRN2F8FLj11VH/tGz7j1FvTsVkjHz2eS/+ecQVfkQ6dj2Xo7yP1OQCqVIpvV8q8zZp3uwbepon31aynqVGud8iOra9JA4F8deTRey2p3l068cENf2aKwYmesIuWoxC0Y+Psdrw4ex2A0Sg08bNoY2UDNu2xHuOn7YiX5y3BsGeHoz0zrHkdEkIIIQYw4Vv/S7vNwY4m7EJY2LTHetx+72298pzzj7oA7c9rwi6EEEKIxqHfyYSwMH5a3AC74zQZYIUQQohaqYT1+TfY8ViHPa7HK4HXee5f08569oqn7pS1oKZmvULlEb0lslQ33pZL454LaL1ix7rtPqs68ygkVX5ER8H1TYxvbt912W3Y1sUHzLXLWZPOY8x663yG24vq27ltR2cdLJkXN8AumbcEo7F1VfsaWl664mVeE5xvLSoPLJp2Xlc75PvSW8PuWtc7UmZkGzi024Ymnd5zuRKVx88tEzlvXsM9dY0zNRfVFbvW1c7Q2vVZhz6esa0hz/p5Y131Mq+zHq9fdqzjXub7yUvD3jrPgZq79nmycXDEj3gxUDXORkbDIGKgXhPRPCSJEcJC+7PDcf5RF2DHaTtiybwlaH92uH6XEmIAsLJYxL2jR2PM5MlYsWABjl61EqPyhWZ3S4ghTwV1WCUm5fZaEU3YhbDQnhmG9ueHYd3zG3uerGuyLsSA4N7RY/CF//u/3l/Hrj79NJy5fn2zuyWEEDWh6YcQQohBx5hJk2L+kzGTJje3Q0IIAEAYhnX5N9jRE3YhhBCDjhULF8b8JysWLmh2l4QQkCSmVqqesBcRN4KVyXRaCuLbYWT4TNMphzDZhzpDxs8MmXnYhJqNnFaZAmCyVJdNqVwO2t9lQo2WVjjRh+s6En9MYyiFNLHJLbLJI8reHT50UhOq7dh8k7nOm+23/DNQll7IR7ZdmT1cnNSUGj0et+Ub6sPXgE2pTBgxBpaprEwhSxzSxGFVZXpP5YzgJHp/R/pmlDkuApc7Q3vIMJnJbDkejzG/R3yvAde37Z/N9j8mgGn8LFtCmKohZvys8BjZg5HYZGqYVB3XIG46tf8wm7aZLmo85GPbTMZHrVyBq08/HWMmTcKKhQtx1MqVQCGuYW/0uTSLNM22vvdtEgbL+AuRBnrCLoQQYtAxulDAmevXAS883/NCQYZTIVqBMKxDcNIQkMRIwy6EEEIIIUQLoyfsQgghhBCiIYRIX3M++J+ve0zYNwXF2HaZNO2lgDXuW7ZZo14OuqvuYF9kkY9ts4Y9jy0/fZbpFPNhfF8OfCqYiuv4pkPTXor8LMMt+WraWb3no2lnPXUjNe1GXdr2CZcCzJAfQ9MeKXZp1A2duePYxv50v2Qt+nnup+tY5jUinTmVR3WprCvlYB2+V0q0zRr3vBHqxJrmLb3h4KTQ6GkcQ+ud5WORnr4Sby8TbDm3DGn1XUFKLv2tSxMfhXXgLv170pCnqN6atb0uH4BPMBIfi3HpitMOJ6pYhimTSfYjcaPPxYfo/dPMfjC+fWmk5l2IwYyesAshhBBCiIZQCUPjYWkabQ52pGEXQgghhBCihdETdiGEEEII0RBC1GGVmCGgYteEXQghhBBCNAQFJ9VG1RP2bjKddiO+zabTEjb1/nc5jJtMebviMKllyKYYsMk0aKdjb+lLAfG1d9kAm6dy/pKWxIRaIk2VrwmVYVMqG0OjneeigC2P7BtikykVu94MNlOqcWzHvoZZ02EcjW6nbSp1HTvql2Tjpisfii93SL0tUV/sJlS/Mea+8jZfbw7Widf1M6G5Qno49ImDlqImtmzFbip1BSm5jKEc8ubVFo+p8Yb1tV9vwTDueppOzfY4WKn6/ettiLSbq9M9dquYTIFkfWmloCTui0yo/rSS6Vg0Dz1hF0IIIYQQDaGCOphOh4AkRqZTIYQQQgghWhg9YRdCCCGEEA1ByzrWRvUadtKsdweb4tthfLuI9b3/XarEyyqkYQ9JMVshXXiGwokyQTz8qER9yQVtvf9dDobH22Z1rqHdZh0xhxnZQ3yiN6HRFgcl0b6G7jyBxr3MwUjUuq/GnYOWmOioukKWkmrWOaAouuk6tksJ6Dq2EczUz3/37Ov3AeIbnBSt7/qsMs6LziTP2m3aP8zUz9LDfc9xEBONQzbSlzJ9NmQ5SIl15oZHgd6TFS7v/0fIJPr3vvb3Iakm3dWerX2bn6HuDGItb6v+3J22Bl2a9h6kSxe+6Am7EEIIMYRY2V3E78eOxJjOSVjRtRCHLV+D0fmCe0chUkDLOtaGJuxCCCHEEOL3Y0fiiz/7CQqFAorFIq469QycumaTe0chRNNo1V/hhBBCCFEHxnROQqHQ80S9UChgzORJTe6RGEpsXiUm7X+DHT1hF0IIIYYQK7oWolgs9j5hX7FgYbO7JIYQWtaxNjyCk8hUGm6Il2NjfLuyIfLf62Nl5UrcwGqYUEMOQ7GbTnOZYbHtfHSbfkMwDKxwbIdcztY/Cj+J9t04FoedsDPUbjJ13Y7lSH02rJoGV3tyEke6cDiOYRwNo3WpzDAVNc5s4zTAOkbVMJmyCTVFwxTfDvY4sfg14UweS6YWAPO8THsk37u0f+S8MxX7D3U8xobJNMPvCzLEksu4HHlPZsnYWa54mlBdQUsOk2psXw/DqqstX9wmVHu5j5HU1yxnftYMDfjeceFj6/Y1tDOHLV+Dq049A2MmT8KKBT0adkjDngiZSEW90RN2IYQQYggxOl/o0aw/82LPC5qsiwYi02ltSMMuhBBCCCFEC6Mn7EIIIYQQoiGEddCwD4Un7FVP2Mso0XZcdx7VrPdsR4KTynF9e5nqhmG87dCh3s1EgpF69u9f/ZcJ4mrsLPL27aBE5fEhCkLWhlNASVSvyf1yaFpd4Tc8KlbFHIc0saY9ZL0t64jjzRnhRXS46HnzTcVXx+i3o+0k8Hlw6FIzMXwBjg8crh89t7IRfGM/thGkRPU55CvLIU4RrXj8k8DUZnc7NO4GXJ1u/Kh+N6Qbk4/tCmnx1rTbNOwO/TvTyMCYRurOkwYrDRQtsPv6se/HUd9SzMfiMU6qafchafDRYAlKGij3qRg86Am7EEIIIYRoCJWggsCRBO3dppdte2AiDbsQg5j15Q1YtNNylN4/HIt2Wo715Q3unYQQQgjRUugJuxCDmDffvgH/85uZvestf/T952Pii8PcOwohhBB1oILQe9nTatoc7GjCLsQgZodp42OJhjtMHQ+8uN6xlxBCCFEfNmeTpt3mYKd60ymFG/E2hx9Fw5Eq4SaqG98OQ7at2Qfe0CrRZiaz5bTKYdygWqIAqDIZWCthfD1aPhY7kbk8iBmNOAjJVjf5N8Ro37htbto0oca3sw6TaiXg+tEte2iT6a7yM+/YwoxcJlM+Mhs5sxzy49WzZHBfXFTTt1fmvRxLNHzlpZcxEWOdJjU2VPG9GcbK4nB4UYZuAOPQjs/ZkO+1SBhSpUzmWHLP8r6GqdQRjGQzoXIZm8KdhlXHBaynkTCJMTSp2c732D7HS2p4tY25ef38jJ+u6YQ15M1xK7jbbt7TxyQm0wy74T2pVAanMVSG1+Q88sgj+NrXvobZs2fj1VdfxV133YUTTzyxz7r/8i//gv/+7//GzTffjE996lMN7WcUPWEXYhCzzQvD8NH3n48dpo7HKy+9jG1eGJbuMjxCCCGEBxX4JwFX06YP69atwzvf+U5ccMEFOPnkk/utd9ddd+HJJ5/EDjvskKyDKaAJuxCDmOHZYT2a9RfXYyLGarIuhBBiyHP00Ufj6KOPttZZsmQJLrroItx333045phjGtSz/tGEXQghhBBCNIR6Luu4evXq2OttbW1oa2vraxd7e5UKPvjBD+Izn/kMdtttt1T6mJSaJ+w+An8z2Mi1HQIIsd9++2LnnXfGnDlz8PjjT6BXvUzthXTho8cLQ3sIk6lRt29z/QoptKOaWHOEWHfm0jw6dMaWcu4nBzzxrlkq56CcXMABUXy8fpvu46Guaxxq1+fZ9O2AqXE36jsaNAKlohU8w01c4VQuotUNjaqjLfO8qw8IAuLnZujdWdvNQSuG/pJGnS0qPG6R3nO/+f3KP7uaunI4yvvXvLv07t6adsK1fyNppObddixXW0m1vaGHhp2vh3Gfe2rebX9R+bOB72tXmJHr+jXz3kqqU/dpO4mmvZG6cWnUa2fChAmx7auvvhrXXHONdzs33HADcrkcLr744pR6lpyWfcK+33774sEHH+g1y73vfYfg8cefbHa3hBBCCCFEjVRQQZDyqi6bH1IuXrwYHR0dva/X8nR99uzZuOWWW/DUU08ZKfDNpGWDk3beeefYcnQ77bRTk3skhBBCCCFalY6Ojti/Wibsf/zjH7F06VJMnDgRuVwOuVwOCxcuxKc//WlMnjw5/U5XScs+YZ8zZ05sOboXX3yx2V0SQgghhBAJqOcT9jT44Ac/iMMOOyz22pFHHokPfvCDOP/881M7ji81T9gDx8P5IKJ5DgLWT8e3A1I5hyjj8cefxPvedwh22mknvPjiXDz++J/Rq4YOeH/ajh3bviyGoe32hHXm0ZuG2y57LmNk6uVZI2vX1/uQpWuQo77nw/itwhr3fGTMee1rYyFup2bdtRa6x09UNCQ5u5TfWAs9CFm32n/zhjI7PWl+n/hq3mP70pnzevU+7wrWx5pruMdhrW9fvYtv0f0QWXs9uiY7AFQq8fvYpc03dOUemncfvTtg10f3tT/j2r9Vcemnk+jS+f2aVPtrXH/LZ3bamnXbe86o6zpNx63i0rh7rUfvKHdp1NM2H0YJQ86ESE/TnpShrFNvheCktWvXYt68eb3bXV1dePrppzF27FhMnDgRW2+9dax+Pp/H9ttvj5133jmV/tZCyz5hBwI8/vif8Pjjf0LPR9nQvbmFEEIIIUQ6zJo1C+973/t6ty+99FIAwLnnnovbb7+9Sb2y08ITdiGEEEIIMZio57KO1XLwwQcjDKv/1XLBggWePUqfljWdCiGEEEIIIfSEXQghhBBCNIgQlVRNopvbHOxUPWHPBvn4NuLbmYC3uyP/TcvqcE5KpUhHi0eGsCk1CMgAmRlGfW2L/Le930bbbGBN8COE7w3payotBfFxKqMUKSvBBhtic2QqzYfxceK+5fnWiRUbFzi+SaZU9v1weS5NN6eP06vPttmkGG2K003SDVKyGeBcGD5go9xurvUyoXLbRgVqjYyjbMbKBv3fP2waM8y01HZgmBTtxlEOJ4uakNkzxuv1GiZRzrbiMXf8POtjOnUZA+uJr5nOVT9qLDUMzU7Dqv3YrvdF7Pbi969veBG1zceymViNfnFbxn1LbSUIWko7VImlEGneq+Z58WdL80yoQ9lkKtJBT9iFEEIIIURDCFFGmLIiOzSyoQcf0rALIYQQQgjRwugJuxBCCCGEaAg98t7WDU5qVarXsFNV1oLnHDr1KBXSS1doX/5pg3XmmQz1hfbPRzTt3C9jm/riClJylUe13qxpZh04w5p1m0YdAIpBsd9y1rC7fi7KIz4upaAQ266E7fEdjFPJWcqS/ZBjhBuRzrAS1UD6pgnRe5wzvgz5PPctUsGl3a5nkBJrcRmnZt1RboNrslbTuPO4bdK0m1pt9pVEdOTcFPsjHBp3Z5CSxUeQPITJoXknuL3++gX462XrqSN2weFHSdrzWKWtz/rcl+idZ2rS7f3i9zufB19v23vSpX93TVX4Y9FX027DFZTk0qwnufdc/R4qunGXl0MMDvSEXQghxKBmdWkTntwhj607J2JZ1yLs80o3OnJt7h2FEKnT8/Ay7SfsAzMJ2gdN2IUQQgxqntwhj+vv+iEKhQKKxSIuP+kcHLG02b0SYmjSYzpN91cBmU6FEEKIAc7WnRNRKPTI/AqFArbunNDkHgkhhB96wi6EEGJQs6xrEYrFYu8T9mVdi6HnVUI0B5lOa6N602nIJlP74AQR9x6HD1XC7th2mPEbaA5p4nCkfDAs8t9xs2Q+jOsW2Uzra0K14dJUcTnfcGZQUtxIyibUTcGGLWU8xo6bucLXk0N8OGiJjcCRn6OMAKGQwiv4fuC+0Dabt+xBS6GlDM6/0YYx1IBMThHXmmlQtZhjAQSeQUrsgLQFKfmaTJN4dQ0DnBEwE4d/uDRMxa72Iudihg/F9zXP22EqddSPBjGlGcIEmEFMTNSkyv0s833pa+RzHNx2r7nMl77YjIK1muv2eaUbl590DrbunIBlXYuxzyvdQK7Nadautl994crgcX3WWN9j3BZtu66/K1hJJCdNw6tMpQLQE3YhhBCDnI5cW49mfekSABlAhtOWZmWxG7/tGIPRkydj5YIFOHr1Cowu5N07igFBiIrzIWItbQ52NGEXQgghRMvw244xuOb/ftorYbrm9NNw1sa1ze6WEE1FE3YhhBBCtAyjJ0+OmYRHT5oEzHmuyb0SaVFBGakGkfS2ObipesKeRzxIx9A4U+JMEG7ZzmbiP2XxTxe+A82hTcZ2RNPOmnU+D9ass6Y9w8EMRrBG9Tcda9ZZ08oaZ3Oc7NvR+rxvGd2ohN3YY6/tMG16J+bNXYBnZy3t9QM4j0Ua9xJds2zkenMAlKGwDPlYFLRDY57lMBxqPTZqJBw1w2gcmnZH11nrHe+rXQeaY82z4WHg8x4YulKbxryvctZLGwEy1L5V4+7Qy5thRX6ad74G0SAmVwhTlhr31rjzmUc2eUgNLbbjmvjCGvlG4qPf5XHgYCQfzbrvsRmX+4k17jZNu29wkrPcpXGPnHdSvXwtrFywIGYSXrlwYerHSBtp1kW90RP2IcQee22He3/3894PwaMOPwXPz17R7G4JIYQQvRy9egWuOf00jJ40CSsXLsTRq1cA0rAPGqRhrw1N2IcQ06Z3xn5mnDZ9sibsQgghWorRhXyPZn2zDEaT9UFFJayDJCYc/JIYLUQ7hJg3twvFYhEAUCwWMW/uguZ2SAghhBBCONET9iHEM7Nex1GHn4xp0ydj3tyFMQ27EEIIIUS9kSSmNqqesBfCuFmTTaZlw7y5ZSJYDuIhPjazZF9w8BKH+AQU4hM1krqCkVwm06wRENS6ZpDoOPGYZZFHNsjjH7PX4B+zn0GADPLB8H7r8xhnQvuPMVFDrStxjM2VPOZ8pBKV5+jeCyNOMg5KCtklanTNbkJlI5jNGMb9Zt8QH5rvpCxtG2ZLw+jdf18YNkSxwdkMyrLXj14zLnMFJxmhP2zspm3+odNmmDNNpfZAIVffDENsZJsNqWxCDcv9hy4B/sFL0b4ZoVrGveEY49b9GEuVRpzn6tImPPG2PLbpnIg3uxZh31e70ZFrc5qxG4nx/qdy/izxCVIy2qbGMxmXBZaObRknl7GTy0PX3y1LupXvsXyRsVT4oifsQgghRI088bY8rr/rh71m/stPOgdHvtHsXgnRuvQ8YU9Xcz4UnrBLwy6EEELUyDadE2Nm/q07JzS5R0KIwYiesAshhBA18mbXotia4cu6FkPPwoTonzCsGNLYNNoc7FQfnBTGzYkuzXM22NJ0hfTvrpAehttmTB36lvpGv1LWrNvKOSjJBfelQlpt1t+HFGYUPRx7DHiMjXEJOYyKxslxDaKhLyXjWPZxcI8x+yU4cGhLeZ776Uj9YLmkoafn4BVqLzrMrJ8PWJNsdCVZkFK0PMNj4siHcmHo5W2adodmnX/4NPXUyd4nsTJHCJM7SMmh3Y9s2/TtgD10qaecvDyGjrh/jbtN3w70oXEnXO/JwUo9NO37vtqNy086B1t3TsCyrsXY99VuINfm3jEBLp+Ib1ASE0bvPdrVFaTE+Grao9pwI1zMqSuvXbNeTftJqKdmvZ79Fq2DnrALIYQQNdKRa+vRrL+xBECm7pN1IQY6PQ9tU37CPgQ07JqwCyGEEEKIhhDWIeSoHm22GhLaCSGEEEII0cLoCbsQQgghhGgIPZZTSWJ8qXrCbpgxQzY1xstLEauZayCTmk5tBlgzlIdDl7jcvu2Da1/TvMPnQYYbKs+TmTeIOCDZoOqCx5D353IbbJ4sOwxurh+yAsPESsZA67lyABSF8himUzLzsVGQ0o2itY22qCe+QUpseDX2j5aTm85pQnUFKTFGUE/E8Epte/8w6WmYsplUbYbUvvbNOUyqFQo7il5+NpFxMBITcrfJfMfBSdxe1NTM94Z5ZHtoj8uU2kjCBJ+xroAfIwjLcd5pmlKTBiXZjIS+Ru16m1Rt+AcrRfdNduwkJtNWCkaSqVQAesIuhBBCCCEaRM8SjFrW0Rdp2IUQQgghhGhh9IRdCCGEEEI0hNBfONmUNluNqifsBarKuvMSh7yEW9SeZiBMuj9duHTp8brJNOouPX2a52bocQPWlZO2O+Ir8O2HOYZ+P77YjufSR/O+7Hkw9fUkJI9gehbi2yXWCbPu3KFZZ516NPuGsqoSBylxqpOhQ/XQmbIW1KVpZ2zXsN56aFO/2X+wCsN3cYauSdkRdhRWSGceKee6oLrI8H3NJgQW81Jnqb0gFtoUr2p6cfgzlw7VREmsS9vro9d1XX/+28Oad5fG3UfTnqbu2xeXRt05Tqwzj7bFY5AwSIkpl5MFqdnw1X771E87CEk6deFCT9iFEEIIIURD6DHYp/vglk37gxFN2IUQQgghREOoxxKMQ2FZR5lOhRBCCCGEaGH0hF0IIYQQQjSEMCzDDPdI2ubgf8LuEZzkChziICWLCbHOD/Z9jKQuE2k9MQKAjHLqG9+Q7HKM1GdDatrw9XXkU8Tgn67cwVl0bDrvSkS7VmYzNBl58kZwEplMbeFEfWxHd+ePH66bdpBStIJh/OQgJQ7hcphQDepoiHJJDyu297OjX3zebCLk6x1ShZCNv5FtNuJyyJLLhIqQXcp2E2r0+pufFdxPDtKiQ6FxuMx0fH29pKghGxb52I4wKn6PWkyoaYYqJYXHNImpFLAbZk2zOzdO9a09aezP+kmMnDKVilZDT9hFy1EKN2HyXnlM2Wki5r+4CItmdSMXtDW7W0IIIYRISD2ehusJuxBNYPJeedz9+x+iUCigWCzihMPOwZLZze6VEEIIIURzkOlUtBxTdpqIQqEAACgUCuicPrHJPRJCCCFEGoSo1OXfYMdDw24PZmAdYlTzXiGRG8fecLhFI7GFLAH+fcug9vAixuUTMDTtsZ2TBTz56sxt+PoE5r+4CMVisfcJe9fcRUjrxyDfs+Drb9Mh2vTtPcfm9wgHI8Xr+wQpsQbVpWlnMgnWsLVqzPuq7ziUqyd+2lJ72FTWEaSU52tou5WpMOOpaTc+iyyJNC5Nuq+m3YVNI51Uo87XM4nW1+inI4zKR9OeJFSpGnic+Bp6teUZsmYLXuIx9dW0G8eyF8c+ONMOo0pblx6lmRp1I5RNDEokiREtx4JZ3Tj+sHMwZfoEzJ+7GItmlZELdKsKIYQQAx1p2GtDsyDRcuSCNrw8G3h59hIAGU3WhRBCiEGCgpNqQxp2IYQQQgghWpiqH13meO1rXt/YooF1fSvw1cD6wP30hXWlLk17Ut26z7HSxKVZLwUla30bWbrNMrT+tEvjHlB5xtBbBpG6ye4ll77aVt+1hrtvuXEs2o6vy23XrLrOK833oLkevcMn4ql5TaZxpraNxe4dDUQ6k2FJOo05r/HP8H1c5go2CwOVJdW0G33z8G4wSTXrvL+P7tjQfTvWtg8ceuzo+8ZbB56i/tq17rqr3KZRd9X3qQv0oWlnPIal0c9MpUNvDApOqg09YRdCCCGEEKKFkThYCCGEEEI0iBDp/37SvNUGG4WesAshhBBCCNHC6Am7EEIIIYRoCD1683Q1+2GCLJGBQtUTdh5aI0gpYONQ/w6pCg0sBykxycyXnqEuKf6s4mqLyxtpaHW1XQni22wyLSFuQo3WZ1OpQWA3oZomVQ4cit8xUdMphw3xfdnMn5TMYKQ4ZtAS1ecKFlNbPQ1wfbUfxTAZOtpyB+/Y+uFonDDCqOg9x+ZNI3cnsjubStnAyEdis16J6vOHMZ9a9PPBZTJ24QoBqudCAC5MU+qW/15T2ohnJoXYdupEvPHSIuyxMMDIXPuWCtRtvrf4jzob/fhey1oDo+LbaQcp2UhqQvVpz2VYZVzvd6cpNdYxj7pNZiiZRkVz0BN2IYQQA4JnJoW48e7v96Ygf/r4D2K/Jc3ulRDCh54HgCk/YR9I3+5qRBp2IYQQA4Jtp05EoVAAABQKBWw7ZUKTeySE8KdSp3+DG03YhRBCDAjeeGkRisUiAKBYLOKN+Yub3CMhhGgMHsFJdq2fqUvfUp9/qLDr3U18darRn0YMDapfU9668kpMZ+rQDXKYiaN3lQQ6ZG7bFXxknpdd414KN2DnPTswbfpkzJu7EC/OXots0PMkrEKBBi7PgkuzngNr3rOR/+4/VAkAgsCuM/bSVxK+QUhJiY4qa68NTXLCQBCbn8cVbGR+ViTqSvxYnvVNHwH7a6g+DVs5GqTjCBcKHbpiI2CKtll3HA0Fy9AF4SAkZ5CS0Tc+NmomqffLCP2KnPc7FgX49AkfxLadE/BG12K8Y1HAlphUieqSjXsnYZCSM+wo5s1JNqiu9yQT/YR1ByX5hWy5Ne5b2pMufJBSB9Np4g+eAYA07CIVdt6zA7/53f/1akvff/gZeOmpYrO7JYYgG8obsGrXDdhx2o5YMm8JRj0/DMOyw5rdLZECI3Pt2H8JgCVvYicM018wIcSQQR93IhWmTZ8c05ZOmz4JLz01t8m9EkORVbtuwHd+e1vvl8cPH30Bhs3RhF0IIVoBmU5rQxp2kQrz5i6IaUvnzV3Y5B6JocqO03aMfXnccdqOTe6REEIIkQw9YRepMGf2arz/8NMxbfokzJu7KKZhF6KRLJm3BMVisfcJ+5J5S7A9xja7W0IIIQCgDk/YB9Si/TVSfXCSYWqiwBGLKZUNqYwZZsIHtxdz+0HM8Er95H3tTZvHsphMedtlKmUTqW8wEhtHA8sPJi6TKZOhtkLa5rCjArZC1+wyumbPBwDk0d77/uG2eF/ut1HfMJL2X873YdYRnMQm01b6yck0uVW/r6+J0OXXsRlLuazMhkfa9vUGcd9d4zDq+WH48NEXxDTsm33JvqZiHyOxaa61G5xtoTx9ETPzOYyAfLCkJtRY00Y4Uf91a8EwWHpcM97XMO4OUA+jEZTlMDwzvsFK0fspeVBSuqZUn2O1MkkXAhBDDz1hF0IMKoZlh2HYnGEoz9nQ82TdtSyREEKIBhLW4YH4wPmyViuasAshhBBCiAZRD4uoJuxCCCGEEEKkyOCfYKdN1RN2Q/vtEANGNe42fTuQvsbd1Z4PPpp1IP69sRSUrW2xrtwVTuQD68SNcocy0dif0klYdx49F7cmPb6dC+OahcARfpQ1gpOCPv+7Z984fC/ysRgut932SUKXqsHQHUd15KTd5PP2fUv4hCGxZr1MO7P+luu7MBUt0c+WeInvJWDtLlPPa2oEJfGxDV16NJSN3xPJPvNcYThR0g9GctS36uld18+vs1w/aOCkwqUrj+LStPu2bStPHADl0Gr7aNxd11u68NamUChg++23x2uvvVaX9rfffvveFcIGI3rCLoQQQggh6kp7ezu6urp6l4BOm0KhgPb29rq03Qpowi6EEEIIIepOe3v7oJ5U15NWWsVOCCGEEEIIQWjCLoQQQgghRAtTvenUMy0jakoNOWSJKzsMrGwiddmAon01Qls8TKN99sVRP2o0LaNEZfFtNplyfd8gpaiZM0smUcNk6hhEV32baZXL2ITKJtMs2Qpzhqk0Xs5HzgVbXnEFJxnGPvb1eYb0pGlK9AnpcbZF277hJzaTKRDvK/fbZTJ1BSvxmHJ5vEK8kMfMFYxlmpJbd+WC6DVgIy5/HPM1cAUpucx89cQ15tHz9r0+xvvZEaxkI+m94WPsBfzMl8b1JlxBSzYTqstE6huM5GNK9W3bRTPvcyGSoifsQgghhBBCtDCasAshhBBCCNHCaMIuhGg6GysbsGq3ZRh5QjtW7roMGysbmt0lIYQQomWoWsNuan8dWrKIqNInZAlwB2kYfQHrbdMMTqpesw7EdeisWWeNejGIr0Uaov+2qiEbuZwl2rcQUpgAa9wdQUtZx60S1a1z4IupaY+XuzTrOQ6JCbi9aBnrK3mb+41E5WnSyJCepKStBN20x3rcfu9tKBQKKBaLOO+oC1B4bhgAU5ce1bS7dP58/VjDyh9N5meLw39TR1jbm4303dDypqzN9dVb2/C0PxlEj+36s2Ps69Cst7JnwYZPyBLgDlqytVfvYCRrQJRn2y6SauCFaCZ6wi6EaDrjp+3Ym1BXKBQwftqOTe6REEII0Tpowi6EaDovz1vSm35XLBbx8rwlTe6REEII0Too6VQI0XTanhmO8466AOOn7YiX5y1B2zPD9ThBCCGEeAtN2IUQTac9Mwztzw3Dmuc2YhS21mRdCCGEiOARnBTfNgOJuH5kB4epNGBjILuSqJyDlNKEw4rYdGqWx7ejRlOXybSETbHtctgd30Z8u0Km1AyZM6MBRfmgHVQYo8BD6DChsnHUZixlUymbgnnb12SaZdNq5P4wTIa0bQQpGaZDR+iHZdswrA5if1OSU3OFVzFpjqsrKMkVpBU1yLkMyo2ETYVZT1uwr4nRhssY6msctcHmSfNYnkFLqdup+ydNQ2U9Tai2UKWqjpUgaMm3bRcD1WQsBKDnWEIIIYQQQrQ0mrALIYQQQgjRwmjCLoQQQgghRAvjEZxk16HZNO1GyJJnUJLxraKBmnYXoUXTzuFFrElnzXo3NsbbCku0HdewM9kg329ZQDrwkhFW5Oc/toUhcRCSOzipds16T/2gz//ua9sZlOTQMCdhsGra+bxChweFh8GwUzjaz9p05BbNeR9daamgpDTDkPgSsGaZN11a8KhWuN46YFdfbLg0z759b6bm2abPdvUrTU27q620Ne22thlfj4Kv5t2G9PCi0egJuxBCCCGEEC2MJuxCCCGEEEL8//buPDqKKm0D+FPdSSckJpB0EhDCHgI4IxBAIIR9dQQBQRAw4HKCgEEWR8ENRRkcBRlBBoQPHR1UDqKiIAjiMoIEHHbPKBHUQZBFkCwQCUmHdM0f8Wu6bqXrptKdpNP9/M7JOalU1a2lk86t2+97Xz/GDjsRERERkR+rdOEkMzHthnO0A/qYdmG9LiZWwn2eb3EedW85vYkr1cW7a2PSVVW7XoxxV4UYdkXRzl/u3r54LHFZJM4nLxLnXdfHoV979hNj1q26mHYtWcy6+Puim7fffR52kzHp+jnjjfc3Wjaao708voyP9zUxNlR8/d0vTsxfsQo3UVG9iwsX75PVbdkovl3ctmx7c/Oui9zPXR8fL7Ztcg5wM3HJARQ/ayZm3WzMsuw1qOy860q4DdaYKL9JTDEdTy39Pffda+LN3Pbe1AMovz3ftVXtf4FOJ9T8S0CxQ74tBSRWOq1lnOpVdLypOZJbt8D3R4/j4P4TsCh8GYmIqpwCRI7sg4i09lDEJ9PaxD+eM8gMFVCdpSjZcwglmz6tgScGqmns6dUyHW9qjk8+2wSbzQaHw4FB/Yfj8IHTNX1aREQBL3JkH0T26YQGCQmoExYmrYxcXfzjLKpAwF6YeaqqotBRjHO9ymaDK9n4aQ2fEVU3dthrmeTWLWCz2QAANpsNScnN2WEnIqpiSrgNEWnt0SAhAbFR0TV9OhoB268N2AurnDphYQCAs6kpKNm2k+ExQaYWf6YXnI4d/S8cjrI/UofDgR+OHa/hMyIiCnyWmCgoVour00RUEyJsYVAsVij1/OuhkapehUfYxdwaMdHMKAnVqKhS2bbmklAtJgoviW2XellkSUy+K63CEQBFfJ5SgEP7T2JQ/+FISm6OH475LoZdX9zI+FnOokvWvLa9r5NMxeJH+sJJnrf1tlCSLJHUT3LOpMw+mYt/U0ZJqLr3BnFfsXGT90z3mhmdl25fSRKqpFCSPpHU87YytanQitliOP6iSu/x728O/hIGExRkVdWCkKIoZffBwvHWYMOQmFrGooTg8IHTrjAYJpwSEQUGFYDDAlhCrHBeLYXNyT4qEZVhb4+IiMgPOCxAdGwMFEWBqqq4lJuHMOMZd4koSLDDTkRE5IWTp04hJzfH63auhlgQGRXlWr5cUICQq5577PZYO5okJnp9XH+V8UAmDn59GAd3ZtX0qWgkd+yAWwYOwpLnF5rab/7C5zGgT1+kdulSRWdGgaziMeziD0zEtBsVVQK8n05UjHl2GsSpywrlqLr4a21b2tJF+lhv91hufQEh7e12IlR7bEX7xqwIsd5iYSWRVbnWnlVoWzy2eG4W1fN1lO1vFdZ7LqQki1nXxb+bjFnXx5UbHFv4gbcx7kYx67J4djPFSMo9tpl9TR3J/P5GBcTEPA9v4/yN4tTFnAPxvUaXcyC8BrqcBUlMvFEsd22OKHXq3hc9X6dT9/pWbXy7L+PnZUV8KnMtJ0+dQkqPVBQWFlb2tCotIiICh3btQdMA7rRryF6eaoofWv/6GtSrV8/0fgsWLcR1kZHssFOlcISdiIioknJyc1BYWIg333wTbdu2rbbjZmdnIz09HTm5OcHTYfcTHdq1q+lToCBUmweFiIiI/ELbtm3RsWPHavvy5uHgyHffYfi4O9CwdRJimibixtQuWLzsJdf6r/btw6gJd6L5jTcgtlljdOnbG2+tf1vTxo6sXQhPsOOTzz/HnRn3wt6sCZJS2mHde+8CAJavXoWklHa4PrklpsyageLiYte+a9atRXiCHf/evw+DRw5HTNNEJHfqgNfXviU991NnTuPuqZPRqE0r1GvSCP2HDcXBrw9L9wuPt2PR0iV47Ol5SGyTjLhmTZAxLRMFvxVotjvx888Yd8/dSGjRDLFNG2Po6NvxzZEjmm2SO3bAzDmzXcsZ0zLRsWcadmTtQte+fRDbtDF6DBqgOa/weDsA4NF5TyE83o7weDt2ZO0CALz+1ltI6dEd9Ro3QsPkJPQdcgv2HzoovSYKLhxhJyIiCiIj08ejfnw8Vr64FNHR0fjx+HGcPnPGtf7kqZ+RelMXTLrrboSFhWHP3r2YMmsGnE4nJowdp2nrgdkPYcLYcbgnfQJee/MN3Js5Ff/59ht8+913+PuixTh+4ifMfnIumjdtijkzH9TsO2HyJGRMvAsPTZuB9R9swJSZ09GwQQMM6te/3PPOy89Hv1uH4LrISPzt2edQNzoaK15ZjZtHjsA3X+1DQkK84XW//MpqdGjXHq8sW46fTp7AE/OfQXFxMd5Y/QoAoOC3AgwaMQwWiwXLXliM8LAwPP/i3zBg2FDs2/ElGjdq5LHtc+fP48+PPYqHps9A3ahozF0wH2PumojsfQcQGhqKHVu3ofefbsb9GZNwx6hRAIC2rVvjy927MWXmdMzKnIbBAwbgSuEV7Dt0EPkXLxpeCwUfdtiJiIiCxIWcHPx08gQWL3gWQwbfDADo06OnZpsxt410fa+qKnqmdsfpM2fw6pp/6jrso4YNw+MPPQwAuKljJ3ywZTPefn8DsveWdVQBYGdWFjZs2qTrsN85+g7MnjELADCwXz8cP3ECCxYt9NhhX7ZqJS5evIhd2z5BQnxZ57xvz174Y2oXLFmxHM/Om2d47bawMLyz5g1YrWU5WeHhdTB11gw8MXs2WrdKxpq1a3Hy559xaFcW2iS3BgD07J6GVh3a4++rVuL5Z+Z7bDs3Lw+fbPwQN7RpAwCIiIzA4BHDsffAAaR164aunW8CADROTHR9DwD7Dx1EbEwM/jrvadfP/jRokOF1UHCqdIfdTBKqUVElcduy9b4rpCQmODolhVL0yVdCQqSQfCm2F6Jeu6VOIYnUKSaN6pIKtW2XqiWG24vcE2BDFW01PqtqNgnV+D7otndbr0/sNU4qlSWCipetT0p121ZX+EjStslCSSLFw/dABZJQJceW8SYZT7xusyxGh/ZxEqJRYqnsnsuSTK3Swktie+5tiUWVjBNeRYEajyjm/Hv7u0a+ZY+NRZPGjTF3wXzk5uWhb69eSGyoHTnOy8/H/IXP4cNtW3Hm7FmUlpa69hX1693H9X3d6GgkxMWhR7dUV2cdAJJatsTO3fqZXoYPGaJZvm3oUDwy7ymUlpa6OtXuPvviX+id1gOxMTG4evUqAMBqtaJnanfsP3xImpQ6ZNBgTbsjh92KKTOnY9/Bg2jdKhlZX32FP7Rt6+qsA0BsTAz69+mN3f/+yrDthg0auDrrAND29zZOnz3jaRcAZfHwuXl5yJiWibG3347uXboiIiLC+EIoKAXq/wwiIiISKIqCLevfRZtWyZj5yBwkdWiH7gP74cs9u13bTJqeifXvb8Cs+zOxef27yNr+Ke4afyeKiop17dWrW1ezHGqz6X5mC7WVu298XJxmOSE+ASUlJbiQU/4UmRdyc7Fp60e4rmF9zdfad9bj1OnT0msXjxcdFY3w8HD8cu4cACDvYr5r5F48r9y8fMO264rXbLMBAIqKigz369uzF/6x4mVkH/0Ot44ZjUZtknFv5lTk5uXJLoeCDENiiIiIgkirlklY++prKCkpwZ59e/Hkgr9gVPp4/PfrbxASEoKPtm/Hwmf+gvsz7nPt43S+6vPz+PXCBTS6vqFr+fyv5xEaGoo4u73c7WNj6qFl8/546pFHdevCbGHl7KE/nrtLBZdQVFSEBvXrl7VfLwbHfvxBt9/5X88jNqaetP3KGj96DMaPHoMLOTn4cOtWzJ77OEJDQrFq6UvynSlocISdiIgoCIWGhqJX9zQ8PH0GLhUU4Oy5X1DscMDpdMLmFtJS8FsBtny8zefH37hli2b5/c2b0bFd+3LDYQCgb6/eyD52FG1aJaNThxTN1x9vuEF6vC3bP3aF9wDAhk0fQlEUdE5JAQB079oV3xw5gmM/fO/aJi8/H5/v2IHuXbtV5hI1QkNDDUfc4+x23JOejv69++Do98e8Ph4FlgqPsEvCyg1j2sUYdZEYJ+p1TLumLTHOVCyyJBxLODdZIaUQVXhjUdzXSWLWhWJFiqJty6qY+wDEPU5dbDsUNs2ye6w9AITqYty15xIiLFt1hZWuXVyIUCjJbMy6dHtdsZvKbVveem+XNesk8dO+JHvy9vWxvWnPbHEao0OZjVnXxahL2hPj1N2XzY52eFsAyJcFhKq7+FFt4c19yc7O9vXpVMnx/vPtt5jz1FzcPuI2tGjWDJcuXcKil5agaZMmaNGsOaxWKzqnpGDRsqWIi4tDiNWKF5YtRXRUNH4tviA/gAlvvfM26tQJR8qN7bH+gw3YtWc3Pli7zuP2M6bcj3XvvYuBI25F5qTJaJyYiAs5Odh34ACub9AA06dMNTyeo7gYoydOwOR77sVPJ07g8flPY+Stw9CmVWtABSaOG4+XVq3EiHHjMO+xx1yzxISEhGDa5CleX2+b5GRs3rYVad1SERkZgeSkJLy4fDlyc3PRK60H4uPi8G32EWz/1+fSa1FVQFWr8J8K+R2GxBAREVWSPdaOiIgIpKenV/uxIyIiYI8tP3zEk/oJCaifkIBFS5fgzC9nUTcqGmnduuG1FStdI9v/fPn/kPnwg8h4IBOxMTHIzLgPv12+jCUrlvv0/NesXI25C+bj2cUvID4uDssXv4ibBwz0uL09NhY7P/oY8557Fk/Mfxo5eXmIj4tD106dMeyWIR73+39TMybhwoUc3HP/FDgcDgy7ZQiWPPe8a33UdVHY/v4mzHnyCWQ+OAulTidSu3TBp5s2G07pWFFLnluIhx5/DMPH3YErV67g4w82onNKCpatWon3Nm3EpYICNLq+IWZlTsOjD/7Z6+NRYFFUVRwrL9+4mOmaZdle7mPL4ii2Kknl1m8vrvc8KwwAlLqtF7ctFVqTrS8VWr+KUuP1yrX1JXAI664K+141XK8Kx5LRjLDDtyPsNuHZzp9G2K0mRtitkhFycb2Z7cWxjhDd6KxxW/IZT4TtTYz2+tNMHf40wq6bJUYywm41uOeyWWKsFu17hdHrWe65uu0v39fcpzviuev39/yayV5P6bEl/w/MfLIgPRdpbXvP7VkbxsE+ZwJaNG2GcJv2/fTkqVPIyS0/UbIq2WPtaJKYaHqGqZq2Zt1a3Df9AZzKPuYxXt3XwhPs+OtTT2NW5rSK7eCnN7XI4cCPJ37C5cX/gHr213K36ZX1fjWfFVUHjrATERF5oUliIpokJtb0aRBRAGPSKRERERGRH6vwCLsuMVRYb5iEqksq1f5AFiJj9pMp7bHFhFXjxvURQiafadx3V7Qfm4qJoE5dmIk2JEbftPauK7qE2GvL4rHEQklisqw3ITCANgxGFvIiC4GRJXYahanIwkhkYShmCiWJZIWSZMyEwMiYDYHwhq8/OZYWnHL7I5OFvMjCTGQhMGb++vUhTd7dY1++Rt4WM3JPbvNl8isFp4ljx2Pi2PHVesyi8yZDlsz+mvtpCA0FDo6wExERERH5MXbYiYiIZH7/mEL2iTBRVVJVtWz0v2LzhVAAYYediIhIwplXALXUiSvFxTV9KhTECh3FUJ2lUPMv1fSpUDWr9CwxZmLajYoqAfJiFd4UUrJIgjd1D6nClIQQix9JnnEsbhenCNclFh9ynwISAKyqd5P2aGPYxThyMQZdu2ymMBJgPHWj99M0SmLgdXHono8t/qpIp040uWwUtmh2GkezzDxt+3IqRX3bpprW7y+d1s9oX3Fb38asG633Nsbcm3h5qn5qkQOFWV/jlz5l79N1wsI07z01yT/OgkwxnUeiotBRjHPnz8Ox+xBQ5JDvRAGF0zoSERFVwOUNXwAAzqa1h2IN4EcsPgH4HxVQnaVw7D6Ekk2f1fTZUA1gh52IiKgiVODye1+gcMtuWGKiDD/+qc5iZb6cUQiAVx122Sdm0kNX4SxEZgtnVSXT16mqZWEwHFkPWuywExERmaAWOVB61niawOrssKs+7uR612n24w67H01J6vOHLAp4AfyZHhERERFR7VfhEXZZco0uUdRoW0nxIl8moTrFBEZJEqruoVdIrlQkhZW0CZBioSTtXbHqCikZP3GL04kZvSYWMUlUSCoV9w0RlnXrDZJMy47neZ23SaZiqKj+3NzWmSiyVNaWufUiTdGmGvy41exonuliZCZ2MHsfpEWedNt7br8qk0zL2nMr2mSwriJtBQrZ+7W3fFm0SdW9z3GU09ecEN/Pzd1jVfX8huD162/Qti/aN0P8uzGDo/PBKVD/hxARERERBQR22ImIiIiI/Bg77EREREREfkxRVda3JSIiIiLyVxxhJyIiIiLyY+ywExERERH5MXbYiYiIiIj8GDvsRERERER+jB12IiIiIiI/xg47EREREZEfY4ediIiIiMiPscNOREREROTH2GEnIiIiIvJj/wNrJcBWPRk3xQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "idw_surface = idw(points_3857, template=grid, column=\"temperature\")\n", + "\n", + "fig, ax = plt.subplots(figsize=(10, 7.5))\n", + "idw_surface.plot.imshow(ax=ax, cmap=\"inferno\", add_colorbar=True,\n", + " cbar_kwargs={\"shrink\": 0.8, \"label\": \"temperature\"})\n", + "ax.scatter(points_3857.geometry.x, points_3857.geometry.y, s=10,\n", + " c=\"white\", edgecolor=\"black\", linewidth=0.3)\n", + "ax.legend(handles=[Patch(facecolor=\"white\", edgecolor=\"black\",\n", + " label=\"sample points\")],\n", + " loc=\"lower right\", fontsize=11, framealpha=0.9)\n", + "ax.set_title(\"IDW surface from a GeoDataFrame\")\n", + "ax.set_axis_off()" + ] + }, + { + "cell_type": "markdown", + "id": "5cd120b8", + "metadata": {}, + "source": [ + "## The `.xrs` accessor: kriging and spline\n", + "\n", + "The same operations hang off the `.xrs` accessor. Called this way, the caller\n", + "raster *is* the template, so the output inherits its grid, chunks, and CRS with\n", + "no `template=` argument. Here are ordinary kriging and a thin plate spline side\n", + "by side." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "861a0896", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T16:58:16.821072Z", + "iopub.status.busy": "2026-06-24T16:58:16.820970Z", + "iopub.status.idle": "2026-06-24T16:58:17.140299Z", + "shell.execute_reply": "2026-06-24T16:58:17.139557Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "krig_surface = grid.xrs.kriging(points_3857, column=\"temperature\")\n", + "spline_surface = grid.xrs.spline(points_3857, column=\"temperature\")\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(14, 5.5))\n", + "for ax, surf, title in [(axes[0], krig_surface, \"grid.xrs.kriging\"),\n", + " (axes[1], spline_surface, \"grid.xrs.spline\")]:\n", + " surf.plot.imshow(ax=ax, cmap=\"inferno\", add_colorbar=True,\n", + " cbar_kwargs={\"shrink\": 0.8})\n", + " ax.scatter(points_3857.geometry.x, points_3857.geometry.y, s=6,\n", + " c=\"white\", edgecolor=\"black\", linewidth=0.2)\n", + " ax.set_title(title)\n", + " ax.set_axis_off()" + ] + }, + { + "cell_type": "markdown", + "id": "79291841", + "metadata": {}, + "source": [ + "## Point density with KDE\n", + "\n", + "`kde` measures where points cluster rather than interpolating a value, so it\n", + "needs no column for a plain density. On the accessor it reports density on the\n", + "caller grid. Pass `column=` to weight each point instead." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "fa9236f4", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T16:58:17.141483Z", + "iopub.status.busy": "2026-06-24T16:58:17.141380Z", + "iopub.status.idle": "2026-06-24T16:58:17.342793Z", + "shell.execute_reply": "2026-06-24T16:58:17.342175Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "density = grid.xrs.kde(points_3857)\n", + "\n", + "fig, ax = plt.subplots(figsize=(10, 7.5))\n", + "density.plot.imshow(ax=ax, cmap=\"magma\", add_colorbar=True,\n", + " cbar_kwargs={\"shrink\": 0.8, \"label\": \"density\"})\n", + "ax.scatter(points_3857.geometry.x, points_3857.geometry.y, s=8,\n", + " c=\"cyan\", edgecolor=\"black\", linewidth=0.2)\n", + "ax.set_title(\"Point density (grid.xrs.kde)\")\n", + "ax.set_axis_off()" + ] + }, + { + "cell_type": "markdown", + "id": "1a7ce530", + "metadata": {}, + "source": [ + "## Coregistration across CRSs\n", + "\n", + "The headline case: your points are in one CRS and your raster is in another.\n", + "With `coregister=True` the accessor reprojects the points from their CRS into\n", + "the caller's CRS before interpolating, the same idea as\n", + "`open_geotiff(coregister=True)` for rasters. Below, the original points are in\n", + "EPSG:4326 while the grid is in EPSG:3857. The coregistered result matches the\n", + "surface we got from the already-projected points." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "99c64a6d", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T16:58:17.344260Z", + "iopub.status.busy": "2026-06-24T16:58:17.344142Z", + "iopub.status.idle": "2026-06-24T16:58:17.437923Z", + "shell.execute_reply": "2026-06-24T16:58:17.437302Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "max difference vs pre-projected points: 0.00e+00\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# `points` is still in EPSG:4326; `grid` is EPSG:3857\n", + "coreg = grid.xrs.idw(points, column=\"temperature\", coregister=True)\n", + "\n", + "# Same result as interpolating the pre-projected points\n", + "direct = grid.xrs.idw(points_3857, column=\"temperature\")\n", + "max_diff = float(np.nanmax(np.abs(coreg.values - direct.values)))\n", + "print(f\"max difference vs pre-projected points: {max_diff:.2e}\")\n", + "\n", + "fig, ax = plt.subplots(figsize=(10, 7.5))\n", + "coreg.plot.imshow(ax=ax, cmap=\"inferno\", add_colorbar=True,\n", + " cbar_kwargs={\"shrink\": 0.8, \"label\": \"temperature\"})\n", + "ax.set_title(\"idw(coregister=True): EPSG:4326 points onto an EPSG:3857 grid\")\n", + "ax.set_axis_off()" + ] + }, + { + "cell_type": "markdown", + "id": "ad8da643", + "metadata": {}, + "source": [ + "
\n", + "Coregistration needs a CRS on both sides. The points carry their CRS in\n", + "GeoDataFrame.crs and the caller raster carries its CRS in\n", + "attrs['crs']. With coregister=False (the default), a\n", + "genuine CRS mismatch raises instead of silently interpolating in the wrong\n", + "units. Set the CRS on both before reprojecting.\n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "f37d9cbd", + "metadata": {}, + "source": [ + "### References\n", + "\n", + "- [Inverse distance weighting](https://en.wikipedia.org/wiki/Inverse_distance_weighting)\n", + "- [Kriging](https://en.wikipedia.org/wiki/Kriging)\n", + "- [Thin plate spline](https://en.wikipedia.org/wiki/Thin_plate_spline)\n", + "- [Kernel density estimation](https://en.wikipedia.org/wiki/Kernel_density_estimation)\n", + "- [GeoPandas coordinate reference systems](https://geopandas.org/en/stable/docs/user_guide/projections.html)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.14.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/user_guide/images/vector_interpolation_preview.png b/examples/user_guide/images/vector_interpolation_preview.png new file mode 100644 index 0000000000000000000000000000000000000000..b5db60e782472ef11204176a636e910a8ca12401 GIT binary patch literal 63961 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 literal 0 HcmV?d00001 From 7c4333b4cb11fc2140cffb049fe0aa41db763876 Mon Sep 17 00:00:00 2001 From: Brendan Collins Date: Wed, 24 Jun 2026 10:02:43 -0700 Subject: [PATCH 5/5] Address review: clearer non-numeric column error; add cupy parity test (#3480) --- xrspatial/interpolate/_vector.py | 7 +++++- xrspatial/tests/test_interpolate_vector.py | 25 ++++++++++++++++++++++ 2 files changed, 31 insertions(+), 1 deletion(-) diff --git a/xrspatial/interpolate/_vector.py b/xrspatial/interpolate/_vector.py index 3f256dade..f42e3216a 100644 --- a/xrspatial/interpolate/_vector.py +++ b/xrspatial/interpolate/_vector.py @@ -33,7 +33,12 @@ def _resolve_value_column(gdf, *, column, value_required, func_name): raise ValueError( f"{func_name}(): column {column!r} is not in the GeoDataFrame" ) - return np.asarray(gdf[column].values, dtype=np.float64) + try: + return np.asarray(gdf[column].values, dtype=np.float64) + except (ValueError, TypeError) as e: + raise ValueError( + f"{func_name}(): column {column!r} is not numeric" + ) from e if not value_required: return None diff --git a/xrspatial/tests/test_interpolate_vector.py b/xrspatial/tests/test_interpolate_vector.py index 0fc957d1b..c01941ff6 100644 --- a/xrspatial/tests/test_interpolate_vector.py +++ b/xrspatial/tests/test_interpolate_vector.py @@ -8,6 +8,7 @@ import xrspatial # noqa: F401 (registers the .xrs accessor) from xrspatial import idw, kde, kriging, spline +from xrspatial.tests.general_checks import cuda_and_cupy_available gpd = pytest.importorskip("geopandas") shapely_geometry = pytest.importorskip("shapely.geometry") @@ -141,6 +142,20 @@ def test_accessor_array_form_backward_compatible(): equal_nan=True) +@cuda_and_cupy_available +def test_geodataframe_parity_cupy(): + # the GeoDataFrame branch runs before backend dispatch, so a cupy + # template should match numpy. One smoke test documents that. + import cupy + t_np = _template("numpy") + t_cp = t_np.copy() + t_cp.data = cupy.asarray(t_cp.data) + out_np = idw(_gdf(), template=t_np, column="z") + out_cp = idw(_gdf(), template=t_cp, column="z") + np.testing.assert_allclose(_np(out_np), out_cp.data.get(), + equal_nan=True) + + def test_accessor_dataset(): t = _template() ds = t.to_dataset(name="band") @@ -239,6 +254,16 @@ def test_unknown_column_raises(): idw(_gdf(), template=t, column="nope") +def test_non_numeric_column_raises(): + t = _template() + gdf = gpd.GeoDataFrame( + {"label": ["a", "b", "c", "d", "e"]}, + geometry=[Point(a, b) for a, b in zip(PX, PY)], crs="EPSG:3857", + ) + with pytest.raises(ValueError, match="not numeric"): + idw(gdf, template=t, column="label") + + def test_positional_yz_with_geodataframe_raises(): t = _template() with pytest.raises(ValueError, match="pass template and column as keywords"):